From c4ba161dbcc3a1dc1fdee697a378aaf3c5417cb0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 6 Mar 2025 10:05:16 +0100
Subject: [PATCH 0001/1764] rANS: Suppress bogus compiler warnings, and add /
 improve some comments

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu          | 2 +-
 GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h                | 1 +
 Utilities/rANS/benchmarks/bench_ransDecode.cxx              | 3 +++
 4 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 3c118f402dc4f..e85a3c3e9e1f3 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -416,7 +416,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     mInternals = master->mInternals;
     GPUFailedMsg(cudaSetDevice(mDeviceId));
 
-    GPUInfo("CUDA Initialized from master");
+    GPUInfo("CUDA Initialisation successfull (from master)");
   }
 
   for (uint32_t i = 0; i < mEvents.size(); i++) {
diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h
index 7117dd0c718c6..c7a1b4f55e501 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h
@@ -21,7 +21,7 @@
 #include <hip/hip_ext.h>
 #include <hipcub/hipcub.hpp>
 #pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wshadow" // FIXME: Is this still needed?
 #include <thrust/sort.h>
 #include <thrust/execution_policy.h>
 #include <thrust/device_ptr.h>
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 2d73279cf1fe7..64d8549312736 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -114,6 +114,7 @@ class GPUTPCGMMergedTrack
   float mLastY;                  //* outer Y
   float mLastZ;                  //* outer Z
   uint32_t mFirstClusterRef;     //* index of the first track cluster in corresponding cluster arrays
+  // TODO: Change to 8 bit
   uint32_t mNClusters;           //* number of track clusters
   uint32_t mNClustersFitted;     //* number of clusters used in fit
   uint8_t mFlags;
diff --git a/Utilities/rANS/benchmarks/bench_ransDecode.cxx b/Utilities/rANS/benchmarks/bench_ransDecode.cxx
index a642b58a3431d..0a11b042a77ee 100644
--- a/Utilities/rANS/benchmarks/bench_ransDecode.cxx
+++ b/Utilities/rANS/benchmarks/bench_ransDecode.cxx
@@ -112,8 +112,11 @@ void ransDecodeBenchmark(benchmark::State& st, Args&&... args)
   using input_data_type = std::remove_cv_t<std::remove_reference_t<decltype(inputData)>>;
   using source_type = typename input_data_type::value_type;
 
+#pragma GCC diagnostic push // TODO: Remove me when fixed in GCC
+#pragma GCC diagnostic ignored "-Walloc-size-larger-than="
   EncodeBuffer<source_type> encodeBuffer{inputData.size()};
   DecodeBuffer<source_type> decodeBuffer{inputData.size()};
+#pragma GCC diagnostic pop
 
   const auto histogram = makeDenseHistogram::fromSamples(gsl::span<const source_type>(inputData));
   Metrics<source_type> metrics{histogram};

From 0bd7fb7f7f882973aaa431a593b285082550971e Mon Sep 17 00:00:00 2001
From: Maximilian Korwieser <maximilian.korwieser@cern.ch>
Date: Fri, 31 Jan 2025 13:04:55 +0100
Subject: [PATCH 0002/1764] [TPC-QC]Add functionality to set the coordinates of
 PV.

---
 Detectors/TPC/qc/include/TPCQC/Tracks.h | 23 +++++++++++++++--------
 Detectors/TPC/qc/src/Tracks.cxx         |  3 +--
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/Detectors/TPC/qc/include/TPCQC/Tracks.h b/Detectors/TPC/qc/include/TPCQC/Tracks.h
index f6cff7c2b8090..ff215b68ce3b1 100644
--- a/Detectors/TPC/qc/include/TPCQC/Tracks.h
+++ b/Detectors/TPC/qc/include/TPCQC/Tracks.h
@@ -81,19 +81,26 @@ class Tracks
     mUseCutMaxAbsDCArOnHistos = useCutMaxAbsDCArOnHistos;
   }
 
+  // Set PV position
+  void setPVposition(const o2::math_utils::Point3D<float> meanVtxPoint3D)
+  {
+    mPositionOfPV = meanVtxPoint3D;
+  }
+
   /// get ratios of 1D histograms
   std::unordered_map<std::string, std::unique_ptr<TH1>>& getMapHist() { return mMapHist; }
   const std::unordered_map<std::string, std::unique_ptr<TH1>>& getMapHist() const { return mMapHist; }
 
  private:
-  float mCutAbsEta = 1.f;                 // Eta cut
-  int mCutMinnCls = 60;                   // minimum N clusters
-  float mCutMindEdxTot = 20.f;            // dEdxTot min value
-  float mCutMinPtDCAr = 1.5f;             // minimum pT for DCAr plots DCAr vs. phi, eta, nCluster
-  float mSamplingFractionDCAr = 0.1f;     // sampling rate for calculation of DCAr
-  bool mTurnOffHistosForAsync = false;    // Decide whether to turn off some histograms for async to reduce memory
-  float mCutMaxAbsDCAr = 1.f;             // maximum DCAr
-  bool mUseCutMaxAbsDCArOnHistos = false; // Decide whether to use the cut on maximum DCAr for the histograms
+  float mCutAbsEta = 1.f;                         // Eta cut
+  int mCutMinnCls = 60;                           // minimum N clusters
+  float mCutMindEdxTot = 20.f;                    // dEdxTot min value
+  float mCutMinPtDCAr = 1.5f;                     // minimum pT for DCAr plots DCAr vs. phi, eta, nCluster
+  float mSamplingFractionDCAr = 0.1f;             // sampling rate for calculation of DCAr
+  bool mTurnOffHistosForAsync = false;            // Decide whether to turn off some histograms for async to reduce memory
+  float mCutMaxAbsDCAr = 1.f;                     // maximum DCAr
+  bool mUseCutMaxAbsDCArOnHistos = false;         // Decide whether to use the cut on maximum DCAr for the histograms
+  o2::math_utils::Point3D<float> mPositionOfPV{}; // Position of the PV
 
   std::unordered_map<std::string, std::unique_ptr<TH1>> mMapHist;
   std::vector<TH1F> mHist1D{};      ///< Initialize vector of 1D histograms
diff --git a/Detectors/TPC/qc/src/Tracks.cxx b/Detectors/TPC/qc/src/Tracks.cxx
index 9f1d9aabf9523..8e6f0d702df1b 100644
--- a/Detectors/TPC/qc/src/Tracks.cxx
+++ b/Detectors/TPC/qc/src/Tracks.cxx
@@ -180,9 +180,8 @@ bool Tracks::processTrack(const o2::tpc::TrackTPC& track)
       if (propagator->getMatLUT() && propagator->hasMagFieldSet()) {
         // ---| fill DCA histos |---
         o2::gpu::gpustd::array<float, 2> dca;
-        const o2::math_utils::Point3D<float> refPoint{0, 0, 0};
         o2::track::TrackPar propTrack(track);
-        if (propagator->propagateToDCABxByBz(refPoint, propTrack, 2.f, o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca)) {
+        if (propagator->propagateToDCABxByBz(mPositionOfPV, propTrack, 2.f, o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca)) {
           const auto phi = o2::math_utils::to02PiGen(track.getPhi());
           dcaHistPT->Fill(pt, dca[0]);
           dcaHist->Fill(phi, dca[0]);

From b6432870f6504a8005d8b70d24e596341679859c Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Tue, 4 Mar 2025 18:57:12 +0100
Subject: [PATCH 0003/1764] TPC: Cluster filter for PbPb 2023

---
 GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx | 46 ++++++++++++++++++-
 GPU/GPUTracking/Debug/GPUTPCClusterFilter.h   | 26 ++++++++++-
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   | 10 ++--
 .../Global/GPUChainTrackingClusterizer.cxx    |  4 +-
 .../Global/GPUChainTrackingCompression.cxx    |  6 ++-
 .../GPUChainTrackingDebugAndProfiling.cxx     |  5 +-
 7 files changed, 83 insertions(+), 16 deletions(-)

diff --git a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
index cdd0e4879f949..92adcbd9c14d7 100644
--- a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
+++ b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
@@ -12,14 +12,47 @@
 /// \file GPUTPCClusterFilter.cxx
 /// \author David Rohr
 
+#include "GPUCommonLogger.h"
 #include "GPUTPCClusterFilter.h"
 #include "DataFormatsTPC/ClusterNative.h"
 
 using namespace o2::gpu;
 
-GPUTPCClusterFilter::GPUTPCClusterFilter(const o2::tpc::ClusterNativeAccess& clusters)
+GPUTPCClusterFilter::GPUTPCClusterFilter(const o2::tpc::ClusterNativeAccess& clusters, uint8_t filterType)
+  : mFilterType(filterType)
 {
-  // Could initialize private variables based on the clusters here
+  if (filterType == 1) {
+    // Custom filter settings go here
+
+  } else if (filterType == 2) {
+    // PbPb23 filter
+    mClusterStats = std::make_unique<std::vector<int>[]>(MaxStacks);
+    static bool called = false;
+    if (!called) {
+      LOGP(info, "GPUTPCClusterFilter called for PbPb 2023 settings");
+      called = true;
+    }
+
+    for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
+      for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+        const uint32_t globalStack = getGlobalStack(iSector, iRow);
+        mClusterStats[globalStack].resize(MaxTimeBin);
+
+        for (uint32_t k = 0; k < clusters.nClusters[iSector][iRow]; k++) {
+          const o2::tpc::ClusterNative& cl = clusters.clusters[iSector][iRow][k];
+          const int clTime = static_cast<int>(cl.getTime());
+          const float clQmax = cl.getQmax();
+
+          if (clQmax < 12) {
+            if (clTime >= static_cast<int>(mClusterStats[globalStack].size())) {
+              mClusterStats[globalStack].resize(mClusterStats[globalStack].size() + 445);
+            }
+            ++mClusterStats[globalStack][clTime];
+          }
+        }
+      }
+    }
+  }
 }
 
 bool GPUTPCClusterFilter::filter(uint32_t sector, uint32_t row, o2::tpc::ClusterNative& cl)
@@ -27,5 +60,14 @@ bool GPUTPCClusterFilter::filter(uint32_t sector, uint32_t row, o2::tpc::Cluster
   // Return true to keep the cluster, false to drop it.
   // May change cluster properties by modifying the cl reference.
   // Note that this function might be called multiple times for the same cluster, in which case the final modified cl reference goes into the output clusters.
+  if (mFilterType == 2) {
+    const uint32_t globalStack = getGlobalStack(sector, row);
+    const int clTime = static_cast<int>(cl.getTime());
+    const float clQmax = cl.getQmax();
+    if ((mClusterStats[globalStack][clTime] > 40 && clQmax < 12) || (mClusterStats[globalStack][clTime] > 200)) {
+      return false;
+    }
+  }
+
   return true;
 }
diff --git a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.h b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.h
index 908f78fd23b9a..b39237757de53 100644
--- a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.h
+++ b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.h
@@ -15,7 +15,10 @@
 #ifndef GPUTPCCLUSTERFILTER_H
 #define GPUTPCCLUSTERFILTER_H
 
+#include <memory>
 #include <cstdint>
+#include <vector>
+#include "GPUDefConstantsAndSettings.h"
 
 namespace o2::tpc
 {
@@ -28,8 +31,29 @@ namespace o2::gpu
 class GPUTPCClusterFilter
 {
  public:
-  GPUTPCClusterFilter(const o2::tpc::ClusterNativeAccess& clusters);
+  GPUTPCClusterFilter(const o2::tpc::ClusterNativeAccess& clusters, uint8_t filterType);
   bool filter(uint32_t sector, uint32_t row, o2::tpc::ClusterNative& cl);
+
+ private:
+  static constexpr uint32_t MaxTimeBin = 14256;
+  static constexpr uint32_t MaxStacks = GPUCA_NSECTORS * 4;
+  uint8_t mFilterType = 0; //< 0: off, 1: custom, 2: PbPb23
+
+  std::unique_ptr<std::vector<int>[]> mClusterStats; //< Number of clusters per stack and time bin
+
+  uint32_t getGlobalStack(uint32_t sector, uint32_t row) const
+  {
+    int stack = 3;
+    if (row < 63) {
+      stack = 0;
+    } else if (row < 97) {
+      stack = 1;
+    } else if (row < 127) {
+      stack = 2;
+    }
+
+    return sector * 4 + stack;
+  };
 };
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 25419f3483dd6..3c31a4fbb8409 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -291,7 +291,7 @@ AddOption(tpcDownscaledEdx, uint8_t, 0, "", 0, "If != 0, downscale dEdx processi
 AddOption(tpcMaxAttachedClustersPerSectorRow, uint32_t, 51000, "", 0, "Maximum number of TPC attached clusters which can be decoded per SectorRow")
 AddOption(tpcUseOldCPUDecoding, bool, false, "", 0, "Enable old CPU-based TPC decoding")
 AddOption(tpcApplyCFCutsAtDecoding, bool, false, "", 0, "Apply cluster cuts from clusterization during decoding of compressed clusters")
-AddOption(tpcApplyDebugClusterFilter, bool, false, "", 0, "Apply custom cluster filter of GPUTPCClusterFilter class")
+AddOption(tpcApplyClusterFilterOnCPU, uint8_t, 0, "", 0, "Apply custom cluster filter of GPUTPCClusterFilter class, 0: off, 1: debug, 2: PbPb23")
 AddOption(RTCcacheFolder, std::string, "./rtccache/", "", 0, "Folder in which the cache file is stored")
 AddOption(RTCprependCommand, std::string, "", "", 0, "Prepend RTC compilation commands by this string")
 AddOption(RTCoverrideArchitecture, std::string, "", "", 0, "Override arhcitecture part of RTC compilation command line")
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 9de8b2174a182..a63886b93ccf9 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -294,16 +294,12 @@ bool GPUChainTracking::ValidateSettings()
       return false;
     }
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCDecompression) && GetProcessingSettings().tpcApplyCFCutsAtDecoding && !GetProcessingSettings().tpcUseOldCPUDecoding) {
-    GPUError("tpcApplyCFCutsAtDecoding currently requires tpcUseOldCPUDecoding");
-    return false;
-  }
   if ((GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && !(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && (GetProcessingSettings().tpcCompressionGatherMode == 1 || GetProcessingSettings().tpcCompressionGatherMode == 3)) {
     GPUError("Invalid tpcCompressionGatherMode for compression on CPU");
     return false;
   }
-  if (GetProcessingSettings().tpcApplyDebugClusterFilter == 1 && (GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding || GetProcessingSettings().delayedOutput || GetProcessingSettings().runMC)) {
-    GPUError("tpcApplyDebugClusterFilter cannot be used with GPU clusterization or with delayedOutput for GPU or with MC labels");
+  if (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0 && (GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding || GetProcessingSettings().delayedOutput || GetProcessingSettings().runMC)) {
+    GPUError("tpcApplyClusterFilterOnCPU cannot be used with GPU clusterization or with delayedOutput for GPU or with MC labels");
     return false;
   }
   if (GetRecoSteps() & RecoStep::TRDTracking) {
@@ -815,7 +811,7 @@ int32_t GPUChainTracking::RunChainFinalize()
 
   PrintDebugOutput();
 
-  //PrintMemoryRelations();
+  // PrintMemoryRelations();
 
   if (GetProcessingSettings().eventDisplay) {
     if (!mDisplayRunning) {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 121d60873324f..62a4a524d67df 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -635,7 +635,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     if (mWaitForFinalInputs) {
       GPUFatal("Cannot use waitForFinalInput callback without delayed output");
     }
-    if (!GetProcessingSettings().tpcApplyDebugClusterFilter) {
+    if (!GetProcessingSettings().tpcApplyClusterFilterOnCPU) {
       AllocateRegisteredMemory(mInputsHost->mResourceClusterNativeOutput, mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)]);
       tmpNativeClusters = mInputsHost->mPclusterNativeOutput;
     } else {
@@ -1021,7 +1021,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     tmpNativeAccess->clustersMCTruth = mcLabelsConstView;
     tmpNativeAccess->setOffsetPtrs();
     mIOPtrs.clustersNative = tmpNativeAccess;
-    if (GetProcessingSettings().tpcApplyDebugClusterFilter) {
+    if (GetProcessingSettings().tpcApplyClusterFilterOnCPU) {
       auto allocator = [this, &tmpNativeClusters](size_t size) {
         this->mInputsHost->mNClusterNative = size;
         this->AllocateRegisteredMemory(this->mInputsHost->mResourceClusterNativeOutput, this->mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)]);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 94d39249d620c..1b08de21abd0f 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -201,6 +201,11 @@ int32_t GPUChainTracking::RunTPCCompression()
 
 int32_t GPUChainTracking::RunTPCDecompression()
 {
+  const bool runFiltering = GetProcessingSettings().tpcApplyCFCutsAtDecoding || (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0) || (param().tpcCutTimeBin > 0);
+  if (runFiltering && !GetProcessingSettings().tpcUseOldCPUDecoding) {
+    GPUFatal("tpcApplyCFCutsAtDecoding, tpcApplyClusterFilterOnCPU and tpcCutTimeBin currently require tpcUseOldCPUDecoding");
+  }
+
   if (GetProcessingSettings().tpcUseOldCPUDecoding) {
     const auto& threadContext = GetThreadContext();
     TPCClusterDecompressor decomp;
@@ -214,7 +219,6 @@ int32_t GPUChainTracking::RunTPCDecompression()
       return ((tmpBuffer = std::make_unique<ClusterNative[]>(size))).get();
     };
     auto& decompressTimer = getTimer<TPCClusterDecompressor>("TPCDecompression", 0);
-    bool runFiltering = GetProcessingSettings().tpcApplyCFCutsAtDecoding;
     auto allocatorUse = runFiltering ? std::function<ClusterNative*(size_t)>{allocatorTmp} : std::function<ClusterNative*(size_t)>{allocatorFinal};
     decompressTimer.Start();
     if (decomp.decompress(mIOPtrs.tpcCompressedClusters, *mClusterNativeAccess, allocatorUse, param(), GetProcessingSettings().deterministicGPUReconstruction)) {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index ec6b48a55d50d..38e1cd0036c16 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -295,7 +295,8 @@ void GPUChainTracking::SanityCheck()
 
 void GPUChainTracking::RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* clusters, std::function<o2::tpc::ClusterNative*(size_t)> allocator, bool applyClusterCuts)
 {
-  GPUTPCClusterFilter clusterFilter(*clusters);
+  const uint8_t filterType = GetProcessingSettings().tpcApplyClusterFilterOnCPU;
+  GPUTPCClusterFilter clusterFilter(*clusters, filterType);
   o2::tpc::ClusterNative* outputBuffer = nullptr;
   for (int32_t iPhase = 0; iPhase < 2; iPhase++) {
     uint32_t countTotal = 0;
@@ -312,7 +313,7 @@ void GPUChainTracking::RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* cluster
           if (param().tpcCutTimeBin > 0) {
             keep = keep && cl.getTime() < param().tpcCutTimeBin;
           }
-          keep = keep && (!GetProcessingSettings().tpcApplyDebugClusterFilter || clusterFilter.filter(iSector, iRow, cl));
+          keep = keep && (!filterType || clusterFilter.filter(iSector, iRow, cl));
           if (iPhase && keep) {
             outputBuffer[countTotal] = cl;
           }

From 23958247bf8d01cdf23e053c7e4886c87d834041 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 6 Mar 2025 17:40:08 +0100
Subject: [PATCH 0004/1764] TPC: fix crash in MIPTrackFilterDevice when
 skipping first TF

---
 Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx b/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
index b8b95090d8534..1329dea236b1f 100644
--- a/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
+++ b/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
@@ -106,6 +106,7 @@ void MIPTrackFilterDevice::init(framework::InitContext& ic)
 
 void MIPTrackFilterDevice::run(ProcessingContext& pc)
 {
+  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   const auto currentTF = processing_helpers::getCurrentTF(pc);
   if ((mTFCounter++ % mProcessEveryNthTF) && (currentTF >= mProcessNFirstTFs)) {
     LOGP(info, "Skipping TF {}", currentTF);
@@ -115,7 +116,6 @@ void MIPTrackFilterDevice::run(ProcessingContext& pc)
     }
     return;
   }
-  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
 
   const auto tracks = pc.inputs().get<gsl::span<TrackTPC>>("tracks");
   const auto nTracks = tracks.size();

From 21d7d164517eb16042b7b86253c933e5cec191ca Mon Sep 17 00:00:00 2001
From: pillot <pillot@subatech.in2p3.fr>
Date: Fri, 7 Mar 2025 12:54:39 +0100
Subject: [PATCH 0005/1764] new executable to scan HV/LV CCDB objects and look
 for issues (#14022)

---
 Detectors/MUON/MCH/Conditions/CMakeLists.txt  |   12 +
 Detectors/MUON/MCH/Conditions/README.md       |   53 +-
 .../MCH/Conditions/src/scan-hvlv-ccdb.cxx     | 1121 +++++++++++++++++
 3 files changed, 1184 insertions(+), 2 deletions(-)
 create mode 100644 Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx

diff --git a/Detectors/MUON/MCH/Conditions/CMakeLists.txt b/Detectors/MUON/MCH/Conditions/CMakeLists.txt
index f0a84dec6a416..eff44df743df5 100644
--- a/Detectors/MUON/MCH/Conditions/CMakeLists.txt
+++ b/Detectors/MUON/MCH/Conditions/CMakeLists.txt
@@ -37,6 +37,18 @@ o2_add_executable(
     O2::MCHGlobalMapping
     )
 
+o2_add_executable(
+  scan-hvlv-ccdb
+  COMPONENT_NAME mch
+  SOURCES src/scan-hvlv-ccdb.cxx
+  PUBLIC_LINK_LIBRARIES
+    O2::CCDB
+    O2::CommonUtils
+    O2::DetectorsDCS
+    O2::MCHConditions
+    O2::MCHStatus
+    )
+
 if(BUILD_TESTING)
   o2_add_test(
     dcs-aliases
diff --git a/Detectors/MUON/MCH/Conditions/README.md b/Detectors/MUON/MCH/Conditions/README.md
index fda90ba8c9ca9..d35fdcd0a0958 100644
--- a/Detectors/MUON/MCH/Conditions/README.md
+++ b/Detectors/MUON/MCH/Conditions/README.md
@@ -17,7 +17,9 @@ Those objects are stored at the following CCDB paths :
 - MCH/Calib/BadChannel
 - MCH/Calib/RejectList
 
-The BadChannel and RejectList objects can be uploaded, e.g. for debug purposes, using the `o2-mch-bad-channels-ccdb` program :
+# o2-mch-bad-channels-ccdb
+
+The BadChannel and RejectList objects can be uploaded, e.g. for debug purposes, using the `o2-mch-bad-channels-ccdb` program:
 
 ```shell
 $ o2-mch-bad-channels-ccdb --help
@@ -46,10 +48,57 @@ Usage:
   -a [ --alias ] arg                    DCS alias (HV or LV) to reject
 ```
 
-For instance, to create in a local CCDB a RejectList object which declares solar number 32 as bad, from Tuesday 1 November 2022 00:00:01 UTC to Saturday 31 December 2022 23:59:59, use :
+For instance, to create in a local CCDB a RejectList object which declares solar number 32 as bad, from Tuesday 1 November 2022 00:00:01 UTC to Saturday 31 December 2022 23:59:59, use:
 
 ```shell
 $ o2-mch-bad-channels-ccdb -p -s 32 -t RejectList --starttimestamp 1667260801000 --endtimestamp 1672531199000
 ```
 
 The program will search the reference CCDB (defined with `--referenceccdb`) for existing objects valid during this period and propose you to either overwrite them or update them. In the first case, a single object will be created, valid for the whole period, containing only the new bad channels. In the second case, as many objects as necessary will be created with appropriate validity ranges, adding the new bad channels to the existing ones.
+
+# o2-mch-scan-hvlv-ccdb
+
+the HV or LV DCS datapoints stored in the CCDB (http://alice-ccdb.cern.ch) can be scanned using the `o2-mch-scan-hvlv-ccdb` program:
+
+```shell
+$ o2-mch-scan-hvlv-ccdb -h
+This program scans HV or LV channels looking for issues
+Usage:
+  -h [ --help ]                    produce help message
+  -r [ --runs ] arg                run(s) to scan (comma separated list of runs
+                                   or ASCII file with one run per line)
+  -c [ --channels ] arg            channel(s) to scan ("HV" or "LV" or comma
+                                   separated list of (part of) DCS aliases)
+  --configKeyValues arg            Semicolon separated key=value strings to
+                                   change HV thresholds
+  -d [ --duration ] arg (=0)       minimum duration (ms) of HV/LV issues to
+                                   consider
+  -w [ --warning ] arg (=1)        warning level (0, 1 or 2)
+  -p [ --print ] arg (=1)          print level (0, 1, 2 or 3)
+  -o [ --output ] arg (=scan.root) output root file name
+```
+
+It takes as input a list of runs and a list of either HV or LV channels to scan. **Note that it will scan the CCDB from the begining of the first run to the end of the last one, which can represent quite of lot of files.** More details about the options are given below.
+
+It produces as output a list of detected issues, with time, duration and affected runs, and a root file with the displays of the data points per channel per chamber for a visual inspection. Issues are triggered when HV/LV values go below a given threshold. For HV channels it also compares the issues found by the internal algorithm with the ones found by [Detectors/MUON/MCH/Status/src/HVStatusCreator.cxx](../Status/src/HVStatusCreator.cxx).
+
+For instance, to scan all HV channels for runs 545222 and 545223 and detect issues of a minimum duration of 10s, use:
+```shell
+o2-mch-scan-hvlv-ccdb -r 545222,545223 -c HV -d 10000
+```
+
+### channel input formats:
+* "HV" to scan all HV channels
+* "LV" to scan all LV channels
+* comma separated list of (part of) DCS aliases, which must be all of the same type, i.e contain either Quad/Slat (type = HV), or Group/an/di/Sol (type = LV)
+
+### warning levels:
+* 0: no warning
+* 1: check data points timestamp w.r.t. HV/LV file validity range with ±5s tolerance
+* 2: check data points timestamp w.r.t. HV/LV file validity range without tolerance
+
+### print levels:
+* 0: print detected issues
+* 1: same as 0 + print validity range of runs and HV/LV files
+* 2: same as 1 + print the first and last data points of each selected channel
+* 3: same as 1 + print all the data points of each selected channel
diff --git a/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx b/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
new file mode 100644
index 0000000000000..32cd365916c63
--- /dev/null
+++ b/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
@@ -0,0 +1,1121 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <algorithm>
+#include <ctime>
+#include <fstream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <boost/program_options.hpp>
+
+#include <fmt/format.h>
+
+#include "TFile.h"
+#include "TCanvas.h"
+#include "TGraph.h"
+#include "TH1F.h"
+#include "TLine.h"
+#include "TMultiGraph.h"
+#include "TStyle.h"
+
+#include "CCDB/BasicCCDBManager.h"
+#include "CCDB/CcdbApi.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "DetectorsDCS/DataPointIdentifier.h"
+#include "DetectorsDCS/DataPointValue.h"
+#include "MCHConditions/DCSAliases.h"
+#include "MCHStatus/HVStatusCreator.h"
+#include "MCHStatus/StatusMapCreatorParam.h"
+
+namespace po = boost::program_options;
+
+using namespace o2;
+using DPID = dcs::DataPointIdentifier;
+using DPVAL = dcs::DataPointValue;
+using DPMAP = std::unordered_map<DPID, std::vector<DPVAL>>;
+using DPMAP2 = std::map<std::string, std::map<uint64_t, double>>;
+using RBMAP = std::map<int, std::pair<uint64_t, uint64_t>>;
+using DPBMAP = std::map<uint64_t, uint64_t>;
+using ISSUE = std::tuple<uint64_t, uint64_t, double, double, std::string>;
+using ISSUELIST = std::vector<ISSUE>;
+using ISSUEMAP = std::map<std::string, ISSUELIST>;
+
+//----------------------------------------------------------------------------
+bool containsAKey(std::string data, const std::set<std::string>& Keys)
+{
+  /// check if the data contains one of the keys
+
+  auto itKey = std::find_if(Keys.begin(), Keys.end(), [&data](const auto& key) {
+    return data.find(key) != data.npos;
+  });
+
+  return itKey != Keys.end();
+}
+
+//----------------------------------------------------------------------------
+bool isValid(std::string alias)
+{
+  /// check if the alias is a valid (part of a) DCS alias
+
+  static const std::vector<std::string> aliases =
+    mch::dcs::aliases({mch::dcs::MeasurementType::HV_V,
+                       mch::dcs::MeasurementType::LV_V_FEE_ANALOG,
+                       mch::dcs::MeasurementType::LV_V_FEE_DIGITAL,
+                       mch::dcs::MeasurementType::LV_V_SOLAR});
+
+  auto itAlias = std::find_if(aliases.begin(), aliases.end(), [&alias](const auto& a) {
+    return a.find(alias) != a.npos;
+  });
+
+  return itAlias != aliases.end();
+}
+
+//----------------------------------------------------------------------------
+void scanWhat(std::string what, std::string& path, bool& scanHV, bool& scanAll, std::set<std::string>& aliases)
+{
+  /// get what to scan and where
+
+  static const std::set<std::string> hvKeys{"HV", "Quad", "Slat"};
+  static const std::set<std::string> lvKeys{"LV", "Group", "an", "di", "Sol"};
+
+  // HV or LV ?
+  path = "";
+  scanHV = false;
+  if (containsAKey(what, hvKeys)) {
+    path = "MCH/Calib/HV";
+    scanHV = true;
+  }
+  if (containsAKey(what, lvKeys)) {
+    if (scanHV) {
+      printf("error: cannot scan HV and LV channels at the same time\n");
+      exit(1);
+    }
+    path = "MCH/Calib/LV";
+  }
+  if (path.empty()) {
+    printf("error: no valid HV or LV channel to scan\n");
+    exit(1);
+  }
+
+  // everything or specific aliases ?
+  if (what.find(scanHV ? "HV" : "LV") != what.npos) {
+    scanAll = true;
+    aliases.clear();
+  } else {
+    scanAll = false;
+    std::istringstream input(what);
+    for (std::string alias; std::getline(input, alias, ',');) {
+      if (isValid(alias)) {
+        aliases.insert(alias);
+      } else {
+        printf("error: \"%s\" invalid (part of) HV or LV alias\n", alias.c_str());
+        exit(1);
+      }
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+uint64_t ms2s(uint64_t ts)
+{
+  /// convert the time stamp from ms to s
+
+  return (ts + 500) / 1000;
+}
+
+//----------------------------------------------------------------------------
+std::string getTime(uint64_t ts)
+{
+  /// convert the time stamp (ms) to local time
+
+  time_t t = ms2s(ts);
+
+  std::string time = std::ctime(&t);
+  time.pop_back(); // remove trailing \n
+
+  return time;
+}
+
+//----------------------------------------------------------------------------
+std::set<int> getRuns(std::string runList)
+{
+  /// read the runList from an ASCII file, or a comma separated run list, or a single run
+
+  std::set<int> runs{};
+
+  auto isNumber = [](std::string val) { return !val.empty() && val.find_first_not_of("0123456789") == val.npos; };
+
+  if (isNumber(runList)) {
+
+    runs.insert(std::stoi(runList));
+
+  } else if (runList.find(",") != runList.npos) {
+
+    std::istringstream input(runList);
+    for (std::string run; std::getline(input, run, ',');) {
+      if (isNumber(run)) {
+        runs.insert(std::stoi(run));
+      }
+    }
+
+  } else {
+
+    std::ifstream input(runList);
+    if (input.is_open()) {
+      for (std::string run; std::getline(input, run);) {
+        if (isNumber(run)) {
+          runs.insert(std::stoi(run));
+        }
+      }
+    }
+  }
+
+  return runs;
+}
+
+//----------------------------------------------------------------------------
+RBMAP getRunBoundaries(ccdb::CcdbApi const& api, std::string runList)
+{
+  /// return the SOR / EOR time stamps for every runs in the list
+
+  RBMAP runBoundaries{};
+
+  auto runs = getRuns(runList);
+
+  for (auto run : runs) {
+    auto boundaries = ccdb::CCDBManagerInstance::getRunDuration(api, run);
+    runBoundaries.emplace(run, boundaries);
+  }
+
+  return runBoundaries;
+}
+
+//----------------------------------------------------------------------------
+void checkRunBoundaries(const RBMAP& runBoundaries)
+{
+  /// check the consistency of the run time boundaries
+
+  if (runBoundaries.empty()) {
+    printf("error: no run found from the list\n");
+    exit(1);
+  }
+
+  bool error = false;
+  int previousRun = 0;
+  uint64_t endOfPreviousRun = 0;
+
+  for (const auto& [run, boundaries] : runBoundaries) {
+    if (boundaries.second <= boundaries.first) {
+      printf("error: run %d EOR <= SOR: %llu - %llu (%s - %s)\n",
+             run, boundaries.first, boundaries.second,
+             getTime(boundaries.first).c_str(), getTime(boundaries.second).c_str());
+      error = true;
+    }
+    if (boundaries.first <= endOfPreviousRun) {
+      printf("error: SOR run %d <= EOR run %d: %llu (%s) <= %llu (%s)\n",
+             run, previousRun, boundaries.first, getTime(boundaries.first).c_str(),
+             endOfPreviousRun, getTime(endOfPreviousRun).c_str());
+      error = true;
+    }
+    previousRun = run;
+    endOfPreviousRun = boundaries.second;
+  }
+
+  if (error) {
+    exit(1);
+  }
+}
+
+//----------------------------------------------------------------------------
+void printRunBoundaries(const RBMAP& runBoundaries)
+{
+  /// print the list of runs with their time boundaries
+
+  printf("\nlist of runs with their boundaries:\n");
+  printf("------------------------------------\n");
+
+  for (const auto& [run, boundaries] : runBoundaries) {
+    printf("%d: %llu - %llu (%s - %s)\n", run, boundaries.first, boundaries.second,
+           getTime(boundaries.first).c_str(), getTime(boundaries.second).c_str());
+  }
+
+  printf("------------------------------------\n");
+}
+
+//----------------------------------------------------------------------------
+void drawRunBoudaries(const RBMAP& runBoundaries, TCanvas* c)
+{
+  /// draw the run time boundaries
+
+  c->cd();
+
+  for (const auto& [run, boundaries] : runBoundaries) {
+
+    TLine* startRunLine = new TLine(ms2s(boundaries.first), c->GetUymin(), ms2s(boundaries.first), c->GetUymax());
+    startRunLine->SetUniqueID(run);
+    startRunLine->SetLineColor(4);
+    startRunLine->SetLineWidth(1);
+    startRunLine->Draw();
+
+    TLine* endRunLine = new TLine(ms2s(boundaries.second), c->GetUymin(), ms2s(boundaries.second), c->GetUymax());
+    endRunLine->SetUniqueID(run);
+    endRunLine->SetLineColor(2);
+    endRunLine->SetLineWidth(1);
+    endRunLine->Draw();
+  }
+}
+
+//----------------------------------------------------------------------------
+DPBMAP getDPBoundaries(ccdb::CcdbApi const& api, std::string what, uint64_t tStart, uint64_t tStop)
+{
+  /// get the time boundaries of every HV/LV files found in the time range
+
+  // add extra margin (ms) of ± 1 min to the creation time, which occurs every 30 min
+  static const uint64_t timeMarging[2] = {60000, 1860000};
+
+  std::istringstream fileInfo(api.list(what.c_str(), false, "text/plain",
+                                       tStop + timeMarging[1], tStart - timeMarging[0]));
+
+  DPBMAP dpBoundaries{};
+  std::string dummy{};
+  uint64_t begin = 0;
+  uint64_t end = 0;
+
+  for (std::string line; std::getline(fileInfo, line);) {
+    if (line.find("Validity:") == 0) {
+      std::istringstream in(line);
+      in >> dummy >> begin >> dummy >> end;
+      dpBoundaries.emplace(begin, end);
+    }
+  }
+
+  if (dpBoundaries.empty()) {
+    printf("\e[0;31merror: no file found in %s in time range %llu - %llu (%s - %s) --> use the default one\e[0m\n",
+           what.c_str(), tStart, tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
+    dpBoundaries.emplace(1, 9999999999999);
+  }
+
+  return dpBoundaries;
+}
+
+//----------------------------------------------------------------------------
+void checkDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV, uint64_t tStart, uint64_t tStop)
+{
+  /// check the consistency of HV/LV file time boundaries
+
+  bool error = false;
+
+  if (dpBoundaries.begin()->first > tStart) {
+    printf("error: the beginning of the time range is not covered: %llu > %llu (%s > %s)\n",
+           dpBoundaries.begin()->first, tStart,
+           getTime(dpBoundaries.begin()->first).c_str(), getTime(tStart).c_str());
+    error = true;
+  }
+  if (dpBoundaries.rbegin()->second < tStop) {
+    printf("error: the end of the time range is not covered: %llu < %llu (%s < %s)\n",
+           dpBoundaries.rbegin()->second, tStop,
+           getTime(dpBoundaries.rbegin()->second).c_str(), getTime(tStop).c_str());
+    error = true;
+  }
+
+  uint64_t previousTStop = dpBoundaries.begin()->first;
+  for (auto [tStart, tStop] : dpBoundaries) {
+    if (tStop <= tStart) {
+      printf("error: EOF <= SOF: %llu - %llu (%s - %s)\n",
+             tStart, tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
+      error = true;
+    }
+    if (tStart != previousTStop) {
+      printf("error: end of %s file != start of next %s file: %llu (%s) != %llu (%s))\n",
+             scanHV ? "HV" : "LV", scanHV ? "HV" : "LV",
+             previousTStop, getTime(previousTStop).c_str(), tStart, getTime(tStart).c_str());
+      error = true;
+    }
+    previousTStop = tStop;
+  }
+
+  if (error) {
+    exit(1);
+  }
+}
+
+//----------------------------------------------------------------------------
+void printDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV)
+{
+  /// print the time boundaries of every HV/LV files found in the full time range
+
+  printf("\nlist of %s file time boundaries:\n", scanHV ? "HV" : "LV");
+  printf("------------------------------------\n");
+
+  for (auto [tStart, tStop] : dpBoundaries) {
+    printf("%llu - %llu (%s - %s)\n", tStart, tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
+  }
+
+  printf("------------------------------------\n");
+}
+
+//----------------------------------------------------------------------------
+double getLVLimit(std::string alias)
+{
+  /// return the LV limit for that channel
+
+  static const double lvLimits[3] = {1.5, 1.5, 6.}; // FeeAnalog, FeeDigital, Solar
+
+  if (alias.find("an") != alias.npos) {
+    return lvLimits[0];
+  } else if (alias.find("di") != alias.npos) {
+    return lvLimits[1];
+  }
+  return lvLimits[2];
+}
+
+//----------------------------------------------------------------------------
+void drawLimit(double limit, TCanvas* c)
+{
+  /// draw the HV/LV limit for the displayed chamber
+
+  c->cd();
+
+  TLine* l = new TLine(c->GetUxmin(), limit, c->GetUxmax(), limit);
+  l->SetLineColor(1);
+  l->SetLineWidth(1);
+  l->SetLineStyle(2);
+  l->Draw();
+}
+
+//----------------------------------------------------------------------------
+std::string getDuration(uint64_t tStart, uint64_t tStop)
+{
+  /// get the duration (dd hh:mm:ss) between the two time stamps (ms)
+
+  auto dt = ms2s(tStop - tStart);
+  auto s = dt % 60;
+  auto m = (dt / 60) % 60;
+  auto h = (dt / 3600) % 24;
+  auto d = dt / 86400;
+
+  return fmt::format("{:02}d {:02}:{:02}:{:02}", d, h, m, s);
+}
+
+//----------------------------------------------------------------------------
+double getValue(DPVAL dp)
+{
+  /// return the value of this data point
+
+  union Converter {
+    uint64_t raw_data;
+    double value;
+  } converter;
+
+  converter.raw_data = dp.payload_pt1;
+
+  return converter.value;
+}
+
+//----------------------------------------------------------------------------
+std::string getDE(std::string alias)
+{
+  /// for DCS HV alias: return the corresponding DE (and sector)
+  /// for DCS LV alias: return an empty string
+
+  auto de = mch::dcs::aliasToDetElemId(alias);
+
+  if (de) {
+    return (mch::dcs::isQuadrant(mch::dcs::aliasToChamber(alias)))
+             ? fmt::format("DE{}-{}", *de, mch::dcs::aliasToNumber(alias) % 10)
+             : fmt::format("DE{}", *de);
+  }
+
+  return "";
+}
+
+//----------------------------------------------------------------------------
+void fillDataPoints(const std::vector<DPVAL>& dps, std::map<uint64_t, double>& dps2,
+                    uint64_t tMin, uint64_t tMax, int warningLevel)
+{
+  /// fill the map of data points
+
+  static const uint64_t tolerance = 5000;
+
+  if (dps.empty()) {
+    printf("error: the file does not contain any data point\n");
+    exit(1);
+  }
+
+  auto itDP = dps.begin();
+  auto ts = itDP->get_epoch_time();
+  std::string header = "warning:";
+  std::string color = (ts + tolerance < tMin || ts > tMin + tolerance) ? "\e[0;31m" : "\e[0;34m";
+  bool printWarning = warningLevel > 1 || (warningLevel == 1 && color == "\e[0;31m");
+
+  // check if the first data point is a copy of the last one from previous file
+  if (!dps2.empty()) {
+    auto previousTS = dps2.rbegin()->first;
+    if (ts != previousTS || getValue(*itDP) != dps2.rbegin()->second) {
+      if (ts <= previousTS) {
+        printf("error: wrong data point order (%llu <= %llu)\n", ts, previousTS);
+        exit(1);
+      }
+      if (printWarning) {
+        printf("%s%s missing the previous data point (dt = %s%llu ms)", color.c_str(), header.c_str(),
+               (previousTS < tMin) ? "-" : "+", (previousTS < tMin) ? tMin - previousTS : previousTS - tMin);
+        if (ts <= tMin) {
+          printf(" but get one at dt = -%llu ms\e[0m\n", tMin - ts);
+        } else {
+          printf("\e[0m\n");
+        }
+        header = "        ";
+      }
+    }
+  }
+
+  // add the first data point (should be before the start of validity of the file)
+  if (ts >= tMax) {
+    printf("error: first data point exceeding file validity range (dt = +%llu ms)\n", ts - tMax);
+    exit(1);
+  } else if (ts > tMin && printWarning) {
+    printf("%s%s missing data point prior file start of validity (dt = +%llu ms)\e[0m\n",
+           color.c_str(), header.c_str(), ts - tMin);
+    header = "        ";
+  }
+  dps2.emplace(ts, getValue(*itDP));
+
+  // add other data points (should be within the validity range of the file)
+  auto previousTS = ts;
+  for (++itDP; itDP < dps.end(); ++itDP) {
+    ts = itDP->get_epoch_time();
+    if (ts <= previousTS) {
+      printf("error: wrong data point order (%llu <= %llu)\n", ts, previousTS);
+      exit(1);
+    }
+    if (ts < tMin && (warningLevel > 1 || (warningLevel == 1 && ts + tolerance < tMin))) {
+      printf("%s%s data point outside of file validity range (dt = -%llu ms)\e[0m\n",
+             (ts + tolerance < tMin) ? "\e[0;31m" : "\e[0;34m", header.c_str(), tMin - ts);
+    } else if (ts >= tMax && warningLevel >= 1) {
+      printf("\e[0;31m%s data point outside of file validity range (dt = +%llu ms)\e[0m\n",
+             header.c_str(), ts - tMax);
+    }
+    dps2.emplace(ts, getValue(*itDP));
+    previousTS = ts;
+  }
+}
+
+//----------------------------------------------------------------------------
+void selectDataPoints(DPMAP2 dpsMapsPerCh[10], uint64_t tStart, uint64_t tStop)
+{
+  /// remove the data points outside of the given time range and, if needed,
+  /// add a data point at the boundaries with value equal to the preceding one
+
+  for (int ch = 0; ch < 10; ++ch) {
+    for (auto& [alias, dps] : dpsMapsPerCh[ch]) {
+
+      // get the first data point in the time range, remove the previous ones
+      // and add a data point with value equal to the preceding one if it exits
+      // or to this one otherwise
+      auto itFirst = dps.lower_bound(tStart);
+      if (itFirst != dps.begin()) {
+        double previousVal = std::prev(itFirst)->second;
+        for (auto it = dps.begin(); it != itFirst;) {
+          it = dps.erase(it);
+        }
+        dps.emplace(tStart, previousVal);
+      } else if (itFirst->first != tStart) {
+        if (itFirst->first > tStop) {
+          printf("error (%s): all data points are posterior to the end of the time range\n", alias.c_str());
+        } else {
+          printf("error (%s): first data point is posterior to the beginning of the time range\n", alias.c_str());
+        }
+        dps.emplace(tStart, itFirst->second);
+      }
+
+      // get the first data point exceeding the time range, remove it and the next ones
+      // and add a data point with value equal to the preceding one if needed
+      auto itLast = dps.upper_bound(tStop);
+      double previousVal = std::prev(itLast)->second;
+      for (auto it = itLast; it != dps.end();) {
+        it = dps.erase(it);
+      }
+      dps.emplace(tStop, previousVal);
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+void printDataPoints(const DPMAP2 dpsMapsPerCh[10], std::string hvlvFormat, bool all)
+{
+  /// print all the registered data points
+
+  const auto format1 = fmt::format("  %llu (%s): {} V\n", hvlvFormat.c_str());
+  const auto format2 = fmt::format(": %llu (%s): {} V -- %llu (%s): {} V\n",
+                                   hvlvFormat.c_str(), hvlvFormat.c_str());
+
+  for (int ch = 0; ch < 10; ++ch) {
+
+    printf("\n------------ chamber %d ------------\n", ch + 1);
+
+    for (const auto& [alias, dps] : dpsMapsPerCh[ch]) {
+
+      printf("- %s: %lu values", alias.c_str(), dps.size());
+
+      if (all) {
+
+        printf("\n");
+        for (const auto& [ts, val] : dps) {
+          printf(format1.c_str(), ts, getTime(ts).c_str(), val);
+        }
+
+      } else if (!dps.empty()) {
+
+        const auto firstdt = dps.begin();
+        const auto lastdt = dps.rbegin();
+        printf(format2.c_str(),
+               firstdt->first, getTime(firstdt->first).c_str(), firstdt->second,
+               lastdt->first, getTime(lastdt->first).c_str(), lastdt->second);
+
+      } else {
+        printf("\n");
+      }
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+TGraph* mapToGraph(std::string alias, const std::map<uint64_t, double>& dps)
+{
+  /// create a graph for the DCS channel and add the data points
+
+  TGraph* g = new TGraph(dps.size());
+
+  auto pos = alias.find(".");
+  auto shortAlias = alias.substr(0, pos);
+  auto de = getDE(alias);
+  auto title = de.empty() ? fmt::format("{}", shortAlias.c_str())
+                          : fmt::format("{} ({})", de.c_str(), shortAlias.c_str());
+  g->SetNameTitle(alias.c_str(), title.c_str());
+
+  int i(0);
+  for (auto [ts, val] : dps) {
+    g->SetPoint(i, ms2s(ts), val);
+    ++i;
+  }
+
+  g->SetMarkerSize(1.5);
+  g->SetMarkerStyle(2);
+  g->SetLineStyle(2);
+
+  return g;
+}
+
+//----------------------------------------------------------------------------
+TCanvas* drawDataPoints(TMultiGraph* mg, double min, double max)
+{
+  /// display the data points of the given chamber
+
+  TCanvas* c = new TCanvas(mg->GetName(), mg->GetHistogram()->GetTitle(), 1500, 900);
+
+  mg->Draw("A plc pmc");
+  mg->SetMinimum(min);
+  mg->SetMaximum(max);
+  mg->GetXaxis()->SetTimeDisplay(1);
+  mg->GetXaxis()->SetTimeFormat("%d/%m %H:%M");
+  mg->GetXaxis()->SetTimeOffset(0, "local");
+  mg->GetXaxis()->SetNdivisions(21010);
+
+  c->BuildLegend();
+  c->Update();
+
+  return c;
+}
+
+//----------------------------------------------------------------------------
+void findIssues(const std::map<uint64_t, double>& dps, double limit, ISSUELIST& issues)
+{
+  /// return the list of HV/LV issues (time range, min value, mean value) for each DCS channel
+
+  uint64_t tStart(0);
+  double min(0.);
+  double mean(0.);
+  uint64_t prevTS(0);
+  double prevVal(-1.);
+
+  for (auto [ts, val] : dps) {
+
+    if (val < limit) {
+
+      if (tStart == 0) {
+
+        // start a new issue...
+        tStart = ts;
+        min = val;
+        mean = 0.;
+        prevTS = ts;
+        prevVal = val;
+
+      } else {
+
+        // ... or complement the current one
+        min = std::min(min, val);
+        mean += prevVal * (ts - prevTS);
+        prevTS = ts;
+        prevVal = val;
+      }
+
+    } else if (tStart > 0) {
+
+      // complete the current issue, if any, and register it
+      mean += prevVal * (ts - prevTS);
+      mean /= (ts - tStart);
+      issues.emplace_back(tStart, ts, min, mean, "");
+      tStart = 0;
+    }
+  }
+
+  // complete the last issue, if any and its duration is != 0, and register it
+  if (tStart > 0 && prevTS != tStart) {
+    mean /= (prevTS - tStart);
+    issues.emplace_back(tStart, prevTS, min, mean, "");
+  }
+}
+
+//----------------------------------------------------------------------------
+void fillO2Issues(const std::vector<mch::HVStatusCreator::TimeRange>& o2issues, ISSUELIST& issues,
+                  uint64_t tMin, uint64_t tMax)
+{
+  /// fill the list of issues from O2 (extend the previous one and/or create new ones)
+
+  // the list must not be empty
+  if (o2issues.empty()) {
+    printf("error: O2 returns an empty list of issues\n");
+    exit(1);
+  }
+
+  for (auto itIssue = o2issues.begin(); itIssue != o2issues.end(); ++itIssue) {
+
+    // exclude issues fully outside of the DP file boudaries
+    if (itIssue->end <= tMin || itIssue->begin >= tMax) {
+      printf("\e[0;35mwarning: skipping O2 issue outside of file boundaries (%llu - %llu)\e[0m\n",
+             itIssue->begin, itIssue->end);
+      continue;
+    }
+
+    // only the first issue could in principle extend before the start of the DP file, to O
+    if (itIssue->begin < tMin - mch::StatusMapCreatorParam::Instance().timeMargin &&
+        (itIssue != o2issues.begin() || itIssue->begin != 0)) {
+      printf("\e[0;35mwarning: O2 returns an issue with uncommon start time (%llu < %llu)\e[0m\n",
+             itIssue->begin, tMin - mch::StatusMapCreatorParam::Instance().timeMargin);
+    }
+
+    // only the last issue could in principle extend beyond the end of the DP file, to infinity
+    if (itIssue->end >= tMax + mch::StatusMapCreatorParam::Instance().timeMargin &&
+        (itIssue != std::prev(o2issues.end()) || itIssue->end != std::numeric_limits<uint64_t>::max())) {
+      printf("\e[0;35mwarning: O2 returns an issue with uncommon end time (%llu >= %llu)\e[0m\n",
+             itIssue->end, tMax + mch::StatusMapCreatorParam::Instance().timeMargin);
+    }
+
+    // extend the last issue in case of continuity accross the DP files or add a new one,
+    // restricting their time range within the DP file boundaries
+    if (itIssue->begin <= tMin && !issues.empty() && std::get<1>(issues.back()) == tMin) {
+      std::get<1>(issues.back()) = std::min(itIssue->end, tMax);
+    } else {
+      issues.emplace_back(std::max(itIssue->begin, tMin), std::min(itIssue->end, tMax), 0., 0., "");
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+std::string findAffectedRuns(const RBMAP& runBoundaries, uint64_t tStart, uint64_t tStop)
+{
+  /// return the list of affected runs in this time range
+
+  std::string runs;
+
+  for (const auto& [run, boundaries] : runBoundaries) {
+
+    if (boundaries.second <= tStart) {
+      continue;
+    } else if (boundaries.first >= tStop) {
+      break;
+    }
+
+    runs += fmt::format("{},", run);
+  }
+
+  if (!runs.empty()) {
+    runs.pop_back();
+  }
+
+  return runs;
+}
+
+//----------------------------------------------------------------------------
+void selectIssues(ISSUEMAP issuesPerCh[10], const RBMAP& runBoundaries, uint64_t minDuration)
+{
+  /// select HV/LV issues of a minimum duration (ms) occurring during runs
+
+  for (int ch = 0; ch < 10; ++ch) {
+    for (auto& issues : issuesPerCh[ch]) {
+      for (auto itIssue = issues.second.begin(); itIssue != issues.second.end();) {
+
+        auto tStart = std::get<0>(*itIssue);
+        auto tStop = std::get<1>(*itIssue);
+
+        if (tStop - tStart < minDuration) {
+
+          itIssue = issues.second.erase(itIssue);
+
+        } else {
+
+          auto runs = findAffectedRuns(runBoundaries, tStart, tStop);
+
+          if (runs.empty()) {
+
+            itIssue = issues.second.erase(itIssue);
+
+          } else {
+
+            std::get<4>(*itIssue) = runs;
+            ++itIssue;
+          }
+        }
+      }
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+void selectO2Issues(ISSUEMAP issuesPerCh[10], const RBMAP& runBoundaries)
+{
+  /// select HV issues from O2 algorithm occurring during runs
+  /// and restrict the range of issues to the run range
+
+  for (int ch = 0; ch < 10; ++ch) {
+    for (auto& issues : issuesPerCh[ch]) {
+      for (auto itIssue = issues.second.begin(); itIssue != issues.second.end();) {
+
+        auto& tStart = std::get<0>(*itIssue);
+        auto& tStop = std::get<1>(*itIssue);
+
+        auto runs = findAffectedRuns(runBoundaries, tStart, tStop);
+
+        if (runs.empty()) {
+
+          itIssue = issues.second.erase(itIssue);
+
+        } else {
+
+          tStart = std::max(tStart, runBoundaries.begin()->second.first);
+          tStop = std::min(tStop, runBoundaries.rbegin()->second.second);
+          std::get<4>(*itIssue) = runs;
+          ++itIssue;
+        }
+      }
+    }
+  }
+}
+
+//----------------------------------------------------------------------------
+bool eraseIssue(const ISSUE& issue, ISSUELIST& issues)
+{
+  /// find an issue with the same time range and associated run list and erase it
+  /// return true in case of success
+
+  auto itIssue = std::find_if(issues.begin(), issues.end(), [&issue](const auto& i) {
+    return (std::get<0>(i) == std::get<0>(issue) &&
+            std::get<1>(i) == std::get<1>(issue) &&
+            std::get<4>(i) == std::get<4>(issue));
+  });
+
+  if (itIssue != issues.end()) {
+    issues.erase(itIssue);
+    return true;
+  }
+
+  return false;
+}
+
+//----------------------------------------------------------------------------
+void printIssues(const ISSUEMAP issuesPerCh[10], const ISSUEMAP o2IssuesPerCh[10],
+                 bool scanHV, std::string hvlvFormat)
+{
+  /// print all HV/LV issues
+
+  // copy the issues so that we can modify them (i.e. add empty lists or delete issues after printing)
+  ISSUEMAP issuesPerChCopy[10];
+  ISSUEMAP o2IssuesPerChCopy[10];
+  for (int ch = 0; ch < 10; ++ch) {
+    issuesPerChCopy[ch] = issuesPerCh[ch];
+    o2IssuesPerChCopy[ch] = o2IssuesPerCh[ch];
+  }
+
+  // make sure that all alias keys in the map o2IssuesPerChCopy are also in issuesPerChCopy in order to
+  // simplify the loop over all issues from both algorithms and fix the order in which they are printed
+  for (int ch = 0; ch < 10; ++ch) {
+    for (const auto& [alias, o2Issues] : o2IssuesPerChCopy[ch]) {
+      if (!o2Issues.empty()) {
+        issuesPerChCopy[ch].try_emplace(alias, ISSUELIST{});
+      }
+    }
+  }
+
+  auto printHeader = [](std::string alias) {
+    auto de = getDE(alias);
+    if (de.empty()) {
+      printf("Problem found for %s:\n", alias.c_str());
+    } else {
+      printf("Problem found for %s (%s):\n", alias.c_str(), de.c_str());
+    }
+  };
+
+  const auto format = fmt::format("%llu - %llu: %s (duration = %s, min = {} V, mean = {} V) --> run(s) %s\n",
+                                  hvlvFormat.c_str(), hvlvFormat.c_str());
+
+  auto printIssue = [&format](ISSUE issue, std::string color) {
+    const auto& [tStart, tStop, min, mean, runs] = issue;
+    printf("%s", color.c_str());
+    printf(format.c_str(), tStart, tStop,
+           getTime(tStart).c_str(), getDuration(tStart, tStop).c_str(), min, mean, runs.c_str());
+    printf("\e[0m");
+  };
+
+  if (scanHV) {
+    printf("\n------ list of issues from \e[0;31mthis macro only\e[0m, \e[0;35mO2 only\e[0m, or \e[0;32mboth\e[0m ------\n");
+  } else {
+    printf("\n------ list of issues ------\n");
+  }
+
+  bool foundIssues = false;
+
+  for (int ch = 0; ch < 10; ++ch) {
+    for (const auto& [alias, issues] : issuesPerChCopy[ch]) {
+
+      auto& o2Issues = o2IssuesPerChCopy[ch][alias];
+
+      if (!issues.empty() || !o2Issues.empty()) {
+
+        foundIssues = true;
+        printHeader(alias);
+
+        // print all issues found by this macro
+        for (const auto& issue : issues) {
+          // change color if the issue is not found by the O2 algorithm (only for HV)
+          std::string color = (scanHV && !eraseIssue(issue, o2Issues)) ? "\e[0;31m" : "\e[0;32m";
+          printIssue(issue, color);
+        }
+
+        // print other issues found by the O2 algorithm
+        for (const auto& issue : o2Issues) {
+          printIssue(issue, "\e[0;35m");
+        }
+
+        printf("----------------------------\n");
+      }
+    }
+  }
+
+  if (!foundIssues) {
+    printf("----------------------------\n");
+  }
+}
+
+//----------------------------------------------------------------------------
+int main(int argc, char** argv)
+{
+  /// scan HV or LV CCDB objects looking for issues
+
+  std::string runList = "";
+  std::string what = "";
+  std::string config = "";
+  uint64_t minDuration = 0;
+  int warningLevel = 1;
+  int printLevel = 1;
+  std::string outFileName = "";
+
+  po::options_description usage("Usage");
+  // clang-format off
+  usage.add_options()
+      ("help,h", "produce help message")
+      ("runs,r",po::value<std::string>(&runList)->default_value(""),"run(s) to scan (comma separated list of runs or ASCII file with one run per line)")
+      ("channels,c",po::value<std::string>(&what)->default_value(""),R"(channel(s) to scan ("HV" or "LV" or comma separated list of (part of) DCS aliases))")
+      ("configKeyValues",po::value<std::string>(&config)->default_value(""),"Semicolon separated key=value strings to change HV thresholds")
+      ("duration,d",po::value<uint64_t>(&minDuration)->default_value(0),"minimum duration (ms) of HV/LV issues to consider")
+      ("warning,w",po::value<int>(&warningLevel)->default_value(1),"warning level (0, 1 or 2)")
+      ("print,p",po::value<int>(&printLevel)->default_value(1),"print level (0, 1, 2 or 3)")
+      ("output,o",po::value<std::string>(&outFileName)->default_value("scan.root"),"output root file name")
+        ;
+  // clang-format on
+
+  po::options_description cmdline;
+  cmdline.add(usage);
+
+  po::variables_map vm;
+  po::store(po::command_line_parser(argc, argv).options(cmdline).run(), vm);
+
+  if (vm.count("help")) {
+    std::cout << "This program scans HV or LV channels looking for issues\n";
+    std::cout << usage << "\n";
+    return 2;
+  }
+
+  try {
+    po::notify(vm);
+  } catch (const po::error& e) {
+    std::cout << "error: " << e.what() << "\n";
+    exit(1);
+  }
+
+  if (runList.empty()) {
+    printf("error: you must provide run(s) to scan\n");
+    exit(1);
+  }
+
+  if (what.empty()) {
+    printf("error: you must provide channel(s) to scan\n");
+    exit(1);
+  }
+
+  // setup printout and display
+  const double hvRange[2] = {-10., 1700.};
+  const double lvRange[3] = {-1., 4., 8.}; // min, max FeeAnalog/FeeDigital, max Solar
+  const std::string hvFormat = "%7.2f";
+  const std::string lvFormat = "%4.2f";
+  gStyle->SetPalette(kVisibleSpectrum);
+
+  // setup algorithms searching for HV issues
+  conf::ConfigurableParam::updateFromString(config);
+  conf::ConfigurableParam::setValue("MCHStatusMap.hvMinDuration", std::to_string(minDuration));
+  conf::ConfigurableParam::setValue("MCHStatusMap.timeMargin", "0"); // must be 0 to compare O2 with this scan
+
+  // determine what is scanned
+  std::string path{};
+  bool scanHV = false;
+  bool scanAll = false;
+  std::set<std::string> aliases{};
+  scanWhat(what, path, scanHV, scanAll, aliases);
+
+  ccdb::CcdbApi api;
+  api.init("http://alice-ccdb.cern.ch");
+
+  // get the SOR/EOR of every runs from the list, ordered in run number
+  auto runBoundaries = getRunBoundaries(api, runList);
+  if (printLevel > 0) {
+    printRunBoundaries(runBoundaries);
+  }
+  checkRunBoundaries(runBoundaries);
+
+  // extract the time boundaries for each HV/LV file in the full time range
+  auto dpBoundaries = getDPBoundaries(api, path.c_str(), runBoundaries.begin()->second.first,
+                                      runBoundaries.rbegin()->second.second);
+  if (printLevel > 0) {
+    printDPBoundaries(dpBoundaries, scanHV);
+  }
+  checkDPBoundaries(dpBoundaries, scanHV, runBoundaries.begin()->second.first,
+                    runBoundaries.rbegin()->second.second);
+
+  // loop over the HV/LV files, fill the lists of data points per chamber and find issues using O2 algorithm
+  DPMAP2 dpsMapsPerCh[10];
+  mch::HVStatusCreator hvStatusCreator{};
+  ISSUEMAP o2issuesPerCh[10];
+  std::map<std::string, std::string> metadata;
+  for (auto boundaries : dpBoundaries) {
+
+    auto* dpMap = api.retrieveFromTFileAny<DPMAP>(path.c_str(), metadata, boundaries.first);
+
+    // fill the lists of data points per chamber for requested aliases
+    for (const auto& [dpid, dps] : *dpMap) {
+      std::string alias(dpid.get_alias());
+      if (!mch::dcs::isValid(alias)) {
+        printf("error: invalid DCS alias: %s\n", alias.c_str());
+        exit(1);
+      }
+      if ((scanAll || containsAKey(alias, aliases)) && (!scanHV || alias.find(".iMon") == alias.npos)) {
+        int chamber = mch::dcs::toInt(mch::dcs::aliasToChamber(alias));
+        fillDataPoints(dps, dpsMapsPerCh[chamber][alias], boundaries.first, boundaries.second, warningLevel);
+      }
+    }
+
+    // find issues for requested aliases using O2 algorithm (only for HV)
+    if (scanHV) {
+      hvStatusCreator.findBadHVs(*dpMap);
+      for (const auto& [alias, issues] : hvStatusCreator.getBadHVs()) {
+        if (scanAll || containsAKey(alias, aliases)) {
+          int chamber = mch::dcs::toInt(mch::dcs::aliasToChamber(alias));
+          fillO2Issues(issues, o2issuesPerCh[chamber][alias], boundaries.first, boundaries.second);
+        }
+      }
+    }
+  }
+  if (printLevel > 1) {
+    printf("\nall data points:");
+    printDataPoints(dpsMapsPerCh, scanHV ? hvFormat : lvFormat, printLevel > 2);
+  }
+
+  // select the data points in the time range
+  selectDataPoints(dpsMapsPerCh, runBoundaries.begin()->second.first, runBoundaries.rbegin()->second.second);
+  if (printLevel > 1) {
+    printf("\ndata points in the time range covered by runs:");
+    printDataPoints(dpsMapsPerCh, scanHV ? hvFormat : lvFormat, printLevel > 2);
+  }
+
+  // create and fill the graphs, and find HV/LV issues
+  ISSUEMAP issuesPerCh[10];
+  TMultiGraph* mg[10];
+  std::set<double> limits;
+  for (int ch = 0; ch < 10; ++ch) {
+    mg[ch] = new TMultiGraph;
+    mg[ch]->SetNameTitle(fmt::format("ch{}", ch + 1).c_str(),
+                         fmt::format("chamber {};time;{} (V)", ch + 1, scanHV ? "HV" : "LV").c_str());
+    for (const auto& [alias, dps] : dpsMapsPerCh[ch]) {
+      mg[ch]->Add(mapToGraph(alias, dps), "lp");
+      auto limit = scanHV ? mch::StatusMapCreatorParam::Instance().hvLimits[ch] : getLVLimit(alias);
+      limits.emplace(limit);
+      findIssues(dps, limit, issuesPerCh[ch][alias]);
+    }
+  }
+
+  // select HV/LV issues of a minimum duration (ms) occurring during runs
+  selectIssues(issuesPerCh, runBoundaries, minDuration);
+  selectO2Issues(o2issuesPerCh, runBoundaries);
+  printIssues(issuesPerCh, o2issuesPerCh, scanHV, scanHV ? hvFormat : lvFormat);
+
+  // display
+  TCanvas* c[10];
+  for (int ch = 0; ch < 10; ++ch) {
+    if (scanHV) {
+      c[ch] = drawDataPoints(mg[ch], hvRange[0], hvRange[1]);
+      drawLimit(mch::StatusMapCreatorParam::Instance().hvLimits[ch], c[ch]);
+    } else {
+      auto lvMax = (what.find("LV") != what.npos || what.find("Sol") != what.npos) ? lvRange[2] : lvRange[1];
+      c[ch] = drawDataPoints(mg[ch], lvRange[0], lvMax);
+      for (auto limit : limits) {
+        drawLimit(limit, c[ch]);
+      }
+    }
+    drawRunBoudaries(runBoundaries, c[ch]);
+  }
+
+  // save display
+  TFile dataFile(outFileName.c_str(), "recreate");
+  for (int ch = 0; ch < 10; ++ch) {
+    c[ch]->Write();
+  }
+  dataFile.Close();
+
+  return 0;
+}

From 8e0c5cf67c58f931d053d5dd214db1eaaa401110 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 21 Feb 2025 13:57:44 +0100
Subject: [PATCH 0006/1764] DPL Analysis: add test for identification concepts

---
 Framework/Core/CMakeLists.txt           |   1 +
 Framework/Core/include/Framework/ASoA.h |   7 +-
 Framework/Core/test/test_Concepts.cxx   | 164 ++++++++++++++++++++++++
 3 files changed, 171 insertions(+), 1 deletion(-)
 create mode 100644 Framework/Core/test/test_Concepts.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index c006a4135557b..7202e2299b7cc 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -200,6 +200,7 @@ add_executable(o2-test-framework-core
               test/test_CompletionPolicy.cxx
               test/test_ComputingResourceHelpers.cxx
               test/test_ComputingQuotaEvaluator.cxx
+              test/test_Concepts.cxx
               test/test_ControlServiceHelpers.cxx
               test/test_ConfigParamStore.cxx
               test/test_ConfigParamRegistry.cxx
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index cb2ff11a8e901..f21decd0d5c45 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -175,6 +175,8 @@ consteval auto intersectOriginals()
 
 namespace o2::soa
 {
+struct Binding;
+
 template <typename T>
 concept not_void = requires { !std::same_as<T, void>; };
 
@@ -192,7 +194,10 @@ template <typename C>
 concept is_self_index_column = not_void<typename C::self_index_t> && std::same_as<typename C::self_index_t, std::true_type>;
 
 template <typename C>
-concept is_index_column = !is_self_index_column<C> && (requires { &C::getId; } || requires { &C::getIds; });
+concept is_index_column = !is_self_index_column<C> && requires(C c, o2::soa::Binding b) {
+  { c.setCurrentRaw(b) } -> std::same_as<bool>;
+  requires std::same_as<decltype(c.mBinding), o2::soa::Binding>;
+};
 
 template <typename C>
 using is_external_index_t = typename std::conditional_t<is_index_column<C>, std::true_type, std::false_type>;
diff --git a/Framework/Core/test/test_Concepts.cxx b/Framework/Core/test/test_Concepts.cxx
new file mode 100644
index 0000000000000..00ad931828b44
--- /dev/null
+++ b/Framework/Core/test/test_Concepts.cxx
@@ -0,0 +1,164 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <TH1.h>
+#include "Framework/ASoA.h"
+#include "Framework/AnalysisDataModel.h"
+#include "Framework/Expressions.h"
+#include "Framework/AnalysisHelpers.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/Condition.h"
+#include "SimulationDataFormat/O2DatabasePDG.h"
+
+#include <catch_amalgamated.hpp>
+
+using namespace o2::framework;
+using namespace o2::soa;
+using namespace o2;
+
+struct P {
+  void process1(aod::Collisions const&)
+  {
+  }
+
+  PROCESS_SWITCH(P, process1, "", true);
+};
+
+TEST_CASE("IdentificationConcepts")
+{
+  // ASoA
+  int i;
+  REQUIRE(not_void<decltype(i)>);
+
+  REQUIRE(is_persistent_column<o2::aod::track::CollisionId>);
+
+  REQUIRE(is_self_index_column<o2::aod::mcparticle::DaughtersIdSlice>);
+
+  REQUIRE(!is_index_column<o2::aod::mcparticle::DaughtersIdSlice>);
+  REQUIRE(is_index_column<o2::aod::track::CollisionId>);
+  REQUIRE(is_index_column<o2::aod::indices::CollisionIds>);
+
+  REQUIRE(o2::aod::is_aod_hash<o2::aod::Hash<"AOD"_h>>);
+  REQUIRE(o2::aod::is_origin_hash<o2::aod::Hash<"AOD"_h>>);
+
+  REQUIRE(has_parent_t<o2::aod::Track>);
+
+  REQUIRE(is_metadata<o2::aod::TracksIUExtensionMetadata>);
+
+  REQUIRE(is_metadata_trait<o2::aod::MetadataTrait<o2::aod::Hash<"TRACK/0"_h>>>);
+
+  REQUIRE(has_metadata<o2::aod::MetadataTrait<o2::aod::Hash<"TRACK/0"_h>>>);
+
+  REQUIRE(has_extension<o2::aod::MetadataTrait<o2::aod::Hash<"EXTRACK/0"_h>>::metadata>);
+
+  REQUIRE(is_spawnable_column<o2::aod::track::Pt>);
+
+  REQUIRE(is_indexing_column<Index<>>);
+
+  REQUIRE(is_dynamic_column<o2::aod::track::Energy<o2::aod::track::Signed1Pt, o2::aod::track::Tgl>>);
+
+  REQUIRE(is_marker_column<o2::soa::Marker<1>>);
+
+  REQUIRE(is_column<o2::aod::track::Pt>);
+  REQUIRE(is_column<Index<>>);
+  REQUIRE(is_column<o2::aod::track::Energy<o2::aod::track::Signed1Pt, o2::aod::track::Tgl>>);
+  REQUIRE(is_column<o2::soa::Marker<1>>);
+
+  REQUIRE(is_table<o2::aod::Collisions>);
+
+  REQUIRE(is_iterator<o2::aod::Collision>);
+
+  REQUIRE(with_originals<o2::aod::Collisions>);
+
+  REQUIRE(with_sources<o2::aod::MetadataTrait<o2::aod::Hash<"MA_RN3_SP/0"_h>>::metadata>);
+
+  REQUIRE(with_base_table<o2::aod::Tracks>);
+
+  REQUIRE(is_index_table<o2::aod::Run3MatchedSparse>);
+
+  Preslice<o2::aod::Tracks> ps = o2::aod::track::collisionId;
+  REQUIRE(is_preslice<decltype(ps)>);
+
+  REQUIRE(has_filtered_policy<soa::Filtered<o2::aod::Tracks>::iterator>);
+
+  REQUIRE(is_filtered_iterator<soa::Filtered<o2::aod::Tracks>::iterator>);
+
+  REQUIRE(is_filtered_table<soa::Filtered<o2::aod::Tracks>>);
+
+  REQUIRE(is_filtered<soa::Filtered<o2::aod::Tracks>::iterator>);
+  REQUIRE(is_filtered<soa::Filtered<o2::aod::Tracks>>);
+
+  REQUIRE(is_not_filtered_table<o2::aod::Collisions>);
+
+  REQUIRE(is_join<o2::aod::Tracks>);
+
+  auto tl = []() -> SmallGroups<o2::aod::Collisions> { return {std::vector<std::shared_ptr<arrow::Table>>{}, SelectionVector{}, 0}; };
+  REQUIRE(is_smallgroups<decltype(tl())>);
+
+  // AnalysisHelpers
+  REQUIRE(is_producable<o2::aod::Collisions>);
+
+  Produces<o2::aod::Collisions> prod;
+  REQUIRE(is_produces<decltype(prod)>);
+
+  struct : ProducesGroup {
+    Produces<o2::aod::Collisions> p;
+  } prodg;
+  REQUIRE(is_produces_group<decltype(prodg)>);
+
+  REQUIRE(is_spawnable<o2::aod::Tracks>);
+
+  Spawns<o2::aod::Tracks> spw;
+  REQUIRE(is_spawns<decltype(spw)>);
+
+  Builds<o2::aod::Run3MatchedSparse> bld;
+  REQUIRE(is_builds<decltype(bld)>);
+
+  OutputObj<TH1F> oo{"test"};
+  REQUIRE(is_outputobj<decltype(oo)>);
+
+  Service<o2::O2DatabasePDG> srv;
+  REQUIRE(is_service<decltype(srv)>);
+
+  Partition<o2::aod::Tracks> part = o2::aod::track::collisionId >= 0;
+  REQUIRE(is_partition<decltype(part)>);
+
+  // AnalysisTask
+  Enumeration<0, 1> en;
+  REQUIRE(is_enumeration<decltype(en)>);
+
+  // Condition
+  Condition<int> c{""};
+  REQUIRE(is_condition<decltype(c)>);
+
+  struct : ConditionGroup {
+    Condition<float> c{""};
+  } cg;
+  REQUIRE(is_condition_group<decltype(cg)>);
+
+  // Configurable
+  Configurable<int> cc{"", 1, ""};
+  REQUIRE(is_configurable<decltype(cc)>);
+
+  ConfigurableAxis ca{"", {0, 1, 2, 3}, ""};
+  REQUIRE(is_configurable_axis<decltype(ca)>);
+
+  REQUIRE(is_process_configurable<decltype(P::doprocess1)>);
+
+  struct : ConfigurableGroup {
+    Configurable<int> c{"", 1, ""};
+  } ccg;
+  REQUIRE(is_configurable_group<decltype(ccg)>);
+
+  // Expressions
+  expressions::Filter f = o2::aod::track::pt > 1.0f;
+  REQUIRE(expressions::is_filter<decltype(f)>);
+}

From 47ce5171abaa392163d944cd0423cc3d1fbe2144 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Fri, 7 Mar 2025 13:25:15 +0100
Subject: [PATCH 0007/1764] GPU: remove unnecessary check

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index a63886b93ccf9..0e1cde343135e 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -298,8 +298,8 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("Invalid tpcCompressionGatherMode for compression on CPU");
     return false;
   }
-  if (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0 && (GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding || GetProcessingSettings().delayedOutput || GetProcessingSettings().runMC)) {
-    GPUError("tpcApplyClusterFilterOnCPU cannot be used with GPU clusterization or with delayedOutput for GPU or with MC labels");
+  if (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0 && (GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding || GetProcessingSettings().runMC)) {
+    GPUError("tpcApplyClusterFilterOnCPU cannot be used with GPU clusterization or with MC labels");
     return false;
   }
   if (GetRecoSteps() & RecoStep::TRDTracking) {

From b0476bbaaa58005dbd0f4c136c06dd8f0a397e85 Mon Sep 17 00:00:00 2001
From: Robert Muenzer <robert.muenzer@cern.ch>
Date: Wed, 5 Mar 2025 13:33:00 +0100
Subject: [PATCH 0008/1764] Decrease SAC writeout rate by 10

---
 prodtests/full-system-test/aggregator-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/aggregator-workflow.sh b/prodtests/full-system-test/aggregator-workflow.sh
index 23336cafffab8..90abe9786f89e 100755
--- a/prodtests/full-system-test/aggregator-workflow.sh
+++ b/prodtests/full-system-test/aggregator-workflow.sh
@@ -298,7 +298,7 @@ crus="0-359"  # to be used with $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC or ALL
 lanesFactorize=${O2_TPC_IDC_FACTORIZE_NLANES:-12}
 threadFactorize=${O2_TPC_IDC_FACTORIZE_NTHREADS:-16}
 nTFs=$((1000 * 128 / ${NHBPERTF}))
-nTFs_SAC=$((1000 * 128 / ${NHBPERTF}))
+nTFs_SAC=$((10000 * 128 / ${NHBPERTF}))
 nBuffer=$((100 * 128 / ${NHBPERTF}))
 IDC_DELTA="--disable-IDCDelta true" # off by default
 # deltas are on by default; you need to request explicitly to switch them off;

From adea3ba09468dfddb1f579e2172d3885bc97b92f Mon Sep 17 00:00:00 2001
From: Andreas Molander <andreas.molander@cern.ch>
Date: Tue, 18 Feb 2025 14:16:31 +0200
Subject: [PATCH 0009/1764] Update CODEOWNERS for FIT

Sahil is the new FIT software coordinator. Maciej and Arvind are no longer in the team.
---
 CODEOWNERS | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 92999185d6f31..3f6f4a9e42600 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -29,7 +29,7 @@
 /DataFormats/Detectors/CPV                     @peressounko @kharlov
 /DataFormats/Detectors/CTP                     @lietava
 /DataFormats/Detectors/EMCAL                   @mfasDa @jokonig
-/DataFormats/Detectors/FIT                     @jotwinow @afurs @andreasmolander @arvindkhuntia @mslupeck
+/DataFormats/Detectors/FIT                     @jotwinow @afurs @andreasmolander @sahilupadhyaya92
 /DataFormats/Detectors/FOCAL                   @maxrauch @mfasDa @iarsene @matthiasrichter
 /DataFormats/Detectors/GlobalTracking          @shahor02
 /DataFormats/Detectors/GlobalTrackingWorkflow  @shahor02
@@ -59,7 +59,7 @@
 /Detectors/Calibration             @chiarazampolli @shahor02
 /Detectors/CPV                     @peressounko @kharlov
 /Detectors/EMCAL                   @mfasDa @jokonig
-/Detectors/FIT                     @jotwinow @afurs @andreasmolander @arvindkhuntia @mslupeck
+/Detectors/FIT                     @jotwinow @afurs @andreasmolander @sahilupadhyaya92
 /Detectors/FOCAL                   @maxrauch @mfasDa @iarsene @matthiasrichter
 /Detectors/Geometry                @sawenzel @shahor02
 /Detectors/GlobalTracking          @shahor02

From 699feecb5261ff63bee7358c53f3505fd789c363 Mon Sep 17 00:00:00 2001
From: pillot <pillot@subatech.in2p3.fr>
Date: Fri, 7 Mar 2025 11:48:32 +0100
Subject: [PATCH 0010/1764] add protection against missing object

---
 .../MCH/Conditions/src/bad-channels-ccdb.cxx  | 20 ++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/Detectors/MUON/MCH/Conditions/src/bad-channels-ccdb.cxx b/Detectors/MUON/MCH/Conditions/src/bad-channels-ccdb.cxx
index d355a209329ca..04614d8ccd34d 100644
--- a/Detectors/MUON/MCH/Conditions/src/bad-channels-ccdb.cxx
+++ b/Detectors/MUON/MCH/Conditions/src/bad-channels-ccdb.cxx
@@ -100,7 +100,12 @@ std::set<uint64_t> listTSWhenBadChannelsChange(const std::string ccdbUrl, const
   std::string currentETag{};
   for (auto itTS = tsChanges.begin(); itTS != tsChanges.end();) {
     auto headers = api.retrieveHeaders(source, metadata, *itTS);
-    if (headers["ETag"] == currentETag) {
+    if (headers["ETag"].empty()) {
+      std::cout << "- Warning: missing file" << std::endl;
+      auto validUntil = (std::next(itTS) != tsChanges.end()) ? *std::next(itTS) : endTimestamp;
+      std::cout << fmt::format("  validity range: {} - {}\n", *itTS, validUntil);
+      ++itTS;
+    } else if (headers["ETag"] == currentETag) {
       itTS = tsChanges.erase(itTS);
     } else {
       if (verbose) {
@@ -129,6 +134,19 @@ BadChannelsVector queryBadChannels(const std::string ccdbUrl,
   std::map<std::string, std::string> metadata;
   auto source = ccdbPath(badChannelType);
   auto* badChannels = api.retrieveFromTFileAny<BadChannelsVector>(source, metadata, timestamp);
+  if (badChannels == nullptr) {
+    std::cout << "do you want to proceed anyway? [y/n] ";
+    std::string response{};
+    while (true) {
+      std::cin >> response;
+      if (response == "y") {
+        std::cout << "number of bad channels = 0" << std::endl;
+        return {};
+      } else if (response == "n") {
+        exit(3);
+      }
+    }
+  }
   std::cout << "number of bad channels = " << badChannels->size() << std::endl;
   if (verbose) {
     for (const auto& badChannel : *badChannels) {

From f34afc2da0528888b44d015a0306ef47d62e41b2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 7 Mar 2025 17:21:54 +0100
Subject: [PATCH 0011/1764] GPU: Bump required LLVM version for OpenCL

---
 dependencies/FindO2GPU.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index c5d53d6359ada..57c820fbe86b1 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -175,7 +175,7 @@ if(ENABLE_OPENCL)
   if(Clang_FOUND
      AND LLVM_FOUND
      AND NOT LLVM_CLANG STREQUAL "LLVM_CLANG-NOTFOUND"
-     AND LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL 13.0)
+     AND LLVM_PACKAGE_VERSION VERSION_GREATER_EQUAL 18.0)
     set(OPENCL_COMPATIBLE_CLANG_FOUND ON)
   endif()
   if(OpenCL_VERSION_STRING VERSION_GREATER_EQUAL 2.2

From 9e2d4c5f14311d41e80325fc373fad916b66f3c4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 7 Mar 2025 17:22:01 +0100
Subject: [PATCH 0012/1764] GPU: Simplify and cleanup code

---
 .../Global/GPUChainTrackingSectorTracker.cxx  | 38 ++++++-------------
 1 file changed, 11 insertions(+), 27 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index df7c513fc1120..dd7fe285265ad 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -93,6 +93,8 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   }
 
   bool streamInit[GPUCA_MAX_STREAMS] = {false};
+  int32_t streamInitAndOccMap = mRec->NStreams() - 1;
+
   if (doGPU) {
     for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
       processorsShadow()->tpcTrackers[iSector].GPUParametersConst()->gpumem = (char*)mRec->DeviceMemoryBase();
@@ -113,18 +115,12 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       return 2;
     }
 
-    WriteToConstantMemory(RecoStep::TPCSectorTracking, (char*)processors()->tpcTrackers - (char*)processors(), processorsShadow()->tpcTrackers, sizeof(GPUTPCTracker) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);
+    WriteToConstantMemory(RecoStep::TPCSectorTracking, (char*)processors()->tpcTrackers - (char*)processors(), processorsShadow()->tpcTrackers, sizeof(GPUTPCTracker) * NSECTORS, streamInitAndOccMap, &mEvents->init);
 
-    for (int32_t i = 0; i < mRec->NStreams() - 1; i++) {
-      streamInit[i] = false;
-    }
-    streamInit[mRec->NStreams() - 1] = true;
-  }
-  if (GPUDebug("Initialization (1)", 0)) {
-    return (2);
+    std::fill(streamInit, streamInit + mRec->NStreams(), false);
+    streamInit[streamInitAndOccMap] = true;
   }
 
-  int32_t streamOccMap = mRec->NStreams() - 1;
   if (param().rec.tpc.occupancyMapTimeBins || param().rec.tpc.sysClusErrorC12Norm) {
     AllocateRegisteredMemory(mInputsHost->mResourceOccupancyMap, mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::tpcOccupancyMap)]);
   }
@@ -134,21 +130,21 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     }
     uint32_t* ptr = doGPU ? mInputsShadow->mTPCClusterOccupancyMap : mInputsHost->mTPCClusterOccupancyMap;
     auto* ptrTmp = (GPUTPCClusterOccupancyMapBin*)mRec->AllocateVolatileMemory(GPUTPCClusterOccupancyMapBin::getTotalSize(param()), doGPU);
-    runKernel<GPUMemClean16>(GetGridAutoStep(streamOccMap, RecoStep::TPCSectorTracking), ptrTmp, GPUTPCClusterOccupancyMapBin::getTotalSize(param()));
-    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fill>(GetGridBlk(GPUCA_NSECTORS * GPUCA_ROW_COUNT, streamOccMap), ptrTmp);
-    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fold>(GetGridBlk(GPUTPCClusterOccupancyMapBin::getNBins(param()), streamOccMap), ptrTmp, ptr + 2);
+    runKernel<GPUMemClean16>(GetGridAutoStep(streamInitAndOccMap, RecoStep::TPCSectorTracking), ptrTmp, GPUTPCClusterOccupancyMapBin::getTotalSize(param()));
+    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fill>(GetGridBlk(GPUCA_NSECTORS * GPUCA_ROW_COUNT, streamInitAndOccMap), ptrTmp);
+    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fold>(GetGridBlk(GPUTPCClusterOccupancyMapBin::getNBins(param()), streamInitAndOccMap), ptrTmp, ptr + 2);
     mRec->ReturnVolatileMemory();
     mInputsHost->mTPCClusterOccupancyMap[1] = param().rec.tpc.occupancyMapTimeBins * 0x10000 + param().rec.tpc.occupancyMapTimeBinsAverage;
     if (doGPU) {
-      GPUMemCpy(RecoStep::TPCSectorTracking, mInputsHost->mTPCClusterOccupancyMap + 2, mInputsShadow->mTPCClusterOccupancyMap + 2, sizeof(*ptr) * GPUTPCClusterOccupancyMapBin::getNBins(mRec->GetParam()), streamOccMap, false, &mEvents->init);
+      GPUMemCpy(RecoStep::TPCSectorTracking, mInputsHost->mTPCClusterOccupancyMap + 2, mInputsShadow->mTPCClusterOccupancyMap + 2, sizeof(*ptr) * GPUTPCClusterOccupancyMapBin::getNBins(mRec->GetParam()), streamInitAndOccMap, false, &mEvents->init);
     } else {
-      TransferMemoryResourceLinkToGPU(RecoStep::TPCSectorTracking, mInputsHost->mResourceOccupancyMap, streamOccMap, &mEvents->init);
+      TransferMemoryResourceLinkToGPU(RecoStep::TPCSectorTracking, mInputsHost->mResourceOccupancyMap, streamInitAndOccMap, &mEvents->init);
     }
   }
   if (param().rec.tpc.occupancyMapTimeBins || param().rec.tpc.sysClusErrorC12Norm) {
     uint32_t& occupancyTotal = *mInputsHost->mTPCClusterOccupancyMap;
     occupancyTotal = CAMath::Float2UIntRn(mRec->MemoryScalers()->nTPCHits / (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasNHBFPerTF ? mIOPtrs.settingsTF->nHBFPerTF : 128));
-    mRec->UpdateParamOccupancyMap(param().rec.tpc.occupancyMapTimeBins ? mInputsHost->mTPCClusterOccupancyMap + 2 : nullptr, param().rec.tpc.occupancyMapTimeBins ? mInputsShadow->mTPCClusterOccupancyMap + 2 : nullptr, occupancyTotal, streamOccMap);
+    mRec->UpdateParamOccupancyMap(param().rec.tpc.occupancyMapTimeBins ? mInputsHost->mTPCClusterOccupancyMap + 2 : nullptr, param().rec.tpc.occupancyMapTimeBins ? mInputsShadow->mTPCClusterOccupancyMap + 2 : nullptr, occupancyTotal, streamInitAndOccMap);
   }
 
   int32_t streamMap[NSECTORS];
@@ -190,19 +186,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       }
     }
 
-    // Initialize temporary memory where needed
-    if (GetProcessingSettings().debugLevel >= 3) {
-      GPUInfo("Copying Sector Data to GPU and initializing temporary memory");
-    }
     runKernel<GPUMemClean16>(GetGridAutoStep(useStream, RecoStep::TPCSectorTracking), trkShadow.Data().HitWeights(), trkShadow.Data().NumberOfHitsPlusAlign() * sizeof(*trkShadow.Data().HitWeights()));
-
-    if (!doGPU) {
-      TransferMemoryResourcesToGPU(RecoStep::TPCSectorTracking, &trk, useStream); // Copy Data to GPU Global Memory
-    }
-    if (GPUDebug("Initialization (3)", useStream)) {
-      throw std::runtime_error("memcpy failure");
-    }
-
     runKernel<GPUTPCNeighboursFinder>({GetGridBlk(GPUCA_ROW_COUNT, useStream), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}});
     streamInit[useStream] = true;
 

From 5756ea1683c23dddb348ef70ac307812d47be548 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 17 Feb 2025 09:23:58 +0100
Subject: [PATCH 0013/1764] DPL: cleanup state switching

- Remove duplicate helper
- Add signposts to mark streaming states transitions
- Notify driver
---
 Framework/Core/src/DataProcessingDevice.cxx | 44 ++++++++++-----------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 8a3fbbcf5b2f1..e8676995772e6 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -141,6 +141,17 @@ void on_transition_requested_expired(uv_timer_t* handle)
   state.transitionHandling = TransitionHandlingState::Expired;
 }
 
+auto switchState(ServiceRegistryRef& ref, StreamingState newState) -> void
+{
+  auto& state = ref.get<DeviceState>();
+  auto& context = ref.get<DataProcessorContext>();
+  O2_SIGNPOST_ID_FROM_POINTER(dpid, device, &context);
+  O2_SIGNPOST_END(device, dpid, "state", "End of processing state %d", (int)state.streaming);
+  O2_SIGNPOST_START(device, dpid, "state", "Starting processing state %d", (int)newState);
+  state.streaming = newState;
+  ref.get<ControlService>().notifyStreamingState(state.streaming);
+};
+
 void on_data_processing_expired(uv_timer_t* handle)
 {
   auto* ref = (ServiceRegistryRef*)handle->data;
@@ -1236,7 +1247,7 @@ void DataProcessingDevice::PreRun()
   O2_SIGNPOST_ID_FROM_POINTER(cid, device, state.loop);
   O2_SIGNPOST_START(device, cid, "PreRun", "Entering PreRun callback.");
   state.quitRequested = false;
-  state.streaming = StreamingState::Streaming;
+  switchState(ref, StreamingState::Streaming);
   state.allowedProcessing = DeviceState::Any;
   for (auto& info : state.inputChannelInfos) {
     if (info.state != InputChannelState::Pull) {
@@ -1365,10 +1376,10 @@ void DataProcessingDevice::Run()
         // Check if we only have timers
         auto& spec = ref.get<DeviceSpec const>();
         if (hasOnlyTimers(spec)) {
-          state.streaming = StreamingState::EndOfStreaming;
+          switchState(ref, StreamingState::EndOfStreaming);
         }
 
-        // If this is a source device, dataTransitionTimeout and dataProcessingTimeout are effectively
+        // If this is a source device, exitTransitionTimeout and dataProcessingTimeout are effectively
         // the same (because source devices are not allowed to produce any calibration).
         // should be the same.
         if (hasOnlyGenerated(spec) && deviceContext.dataProcessingTimeout > 0) {
@@ -1385,7 +1396,8 @@ void DataProcessingDevice::Run()
           state.transitionHandling = TransitionHandlingState::Requested;
           ref.get<CallbackService>().call<CallbackService::Id::ExitRequested>(ServiceRegistryRef{ref});
           uv_update_time(state.loop);
-          O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for exitTransitionTimeout.", deviceContext.exitTransitionTimeout);
+          O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for exitTransitionTimeout.",
+                                 deviceContext.exitTransitionTimeout);
           uv_timer_start(deviceContext.gracePeriodTimer, on_transition_requested_expired, deviceContext.exitTransitionTimeout * 1000, 0);
           if (mProcessingPolicies.termination == TerminationPolicy::QUIT) {
             O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. Waiting for %d seconds before quitting.", (int)deviceContext.exitTransitionTimeout);
@@ -1728,15 +1740,6 @@ void DataProcessingDevice::doRun(ServiceRegistryRef ref)
 {
   auto& context = ref.get<DataProcessorContext>();
   O2_SIGNPOST_ID_FROM_POINTER(dpid, device, &context);
-  auto switchState = [ref](StreamingState newState) {
-    auto& state = ref.get<DeviceState>();
-    auto& context = ref.get<DataProcessorContext>();
-    O2_SIGNPOST_ID_FROM_POINTER(dpid, device, &context);
-    O2_SIGNPOST_END(device, dpid, "state", "End of processing state %d", (int)state.streaming);
-    O2_SIGNPOST_START(device, dpid, "state", "Starting processing state %d", (int)newState);
-    state.streaming = newState;
-    ref.get<ControlService>().notifyStreamingState(state.streaming);
-  };
   auto& state = ref.get<DeviceState>();
   auto& spec = ref.get<DeviceSpec const>();
 
@@ -1772,7 +1775,7 @@ void DataProcessingDevice::doRun(ServiceRegistryRef ref)
   // dependent on the callback, not something which is controlled by the
   // framework itself.
   if (context.allDone == true && state.streaming == StreamingState::Streaming) {
-    switchState(StreamingState::EndOfStreaming);
+    switchState(ref, StreamingState::EndOfStreaming);
     state.lastActiveDataProcessor = &context;
   }
 
@@ -1818,7 +1821,7 @@ void DataProcessingDevice::doRun(ServiceRegistryRef ref)
     }
     // This is needed because the transport is deleted before the device.
     relayer.clear();
-    switchState(StreamingState::Idle);
+    switchState(ref, StreamingState::Idle);
     // In case  we should process, note the data processor responsible for it
     if (shouldProcess) {
       state.lastActiveDataProcessor = &context;
@@ -2328,13 +2331,6 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     }
   };
 
-  auto switchState = [ref](StreamingState newState) {
-    auto& control = ref.get<ControlService>();
-    auto& state = ref.get<DeviceState>();
-    state.streaming = newState;
-    control.notifyStreamingState(state.streaming);
-  };
-
   ref.get<DataRelayer>().getReadyToProcess(completed);
   if (completed.empty() == true) {
     LOGP(debug, "No computations available for dispatching.");
@@ -2510,7 +2506,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
           O2_SIGNPOST_EVENT_EMIT(device, pcid, "device", "Skipping processing because we are discarding.");
         } else {
           O2_SIGNPOST_EVENT_EMIT(device, pcid, "device", "No processing callback provided. Switching to %{public}s.", "Idle");
-          state.streaming = StreamingState::Idle;
+          switchState(ref, StreamingState::Idle);
         }
         if (shouldProcess(action)) {
           auto& timingInfo = ref.get<TimingInfo>();
@@ -2598,7 +2594,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     for (auto& channel : spec.outputChannels) {
       DataProcessingHelpers::sendEndOfStream(ref, channel);
     }
-    switchState(StreamingState::Idle);
+    switchState(ref, StreamingState::Idle);
   }
 
   return true;

From 80faf100ebd930094d01ea63e0ffdbd3d64b2c67 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 17 Feb 2025 09:28:46 +0100
Subject: [PATCH 0014/1764] DPL: correctly handle data-processing-timeouts in
 sources

---
 Framework/Core/src/DataProcessingDevice.cxx | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index e8676995772e6..7f42805cfdb1e 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -156,16 +156,19 @@ void on_data_processing_expired(uv_timer_t* handle)
 {
   auto* ref = (ServiceRegistryRef*)handle->data;
   auto& state = ref->get<DeviceState>();
+  auto& spec = ref->get<DeviceSpec const>();
   state.loopReason |= DeviceState::TIMER_EXPIRED;
 
   // Check if this is a source device
   O2_SIGNPOST_ID_FROM_POINTER(cid, device, handle);
 
-  // Source devices should never end up in this callback, since the exitTransitionTimeout should
-  // be reset to the dataProcessingTimeout and the timers cohalesced.
-  assert(hasOnlyGenerated(ref->get<DeviceSpec const>()) == false);
-  O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for data processing expired. Only calibrations from this point onwards.");
-  state.allowedProcessing = DeviceState::CalibrationOnly;
+  if (hasOnlyGenerated(spec)) {
+    O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for data processing expired. Switching to EndOfStreaming.");
+    switchState(*ref, StreamingState::EndOfStreaming);
+  } else {
+    O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for data processing expired. Only calibrations from this point onwards.");
+    state.allowedProcessing = DeviceState::CalibrationOnly;
+  }
 }
 
 void on_communication_requested(uv_async_t* s)
@@ -1379,13 +1382,6 @@ void DataProcessingDevice::Run()
           switchState(ref, StreamingState::EndOfStreaming);
         }
 
-        // If this is a source device, exitTransitionTimeout and dataProcessingTimeout are effectively
-        // the same (because source devices are not allowed to produce any calibration).
-        // should be the same.
-        if (hasOnlyGenerated(spec) && deviceContext.dataProcessingTimeout > 0) {
-          deviceContext.exitTransitionTimeout = deviceContext.dataProcessingTimeout;
-        }
-
         // We do not do anything in particular if the data processing timeout would go past the exitTransitionTimeout
         if (deviceContext.dataProcessingTimeout > 0 && deviceContext.dataProcessingTimeout < deviceContext.exitTransitionTimeout) {
           uv_update_time(state.loop);

From 3961e74342b312adddee96dcdfa2cf8eb8928018 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 17 Feb 2025 10:36:24 +0100
Subject: [PATCH 0015/1764] DPL: drop messages explicitly

Somehow if they remain in the queue the confuse the oldest possible timeframe
mechanism.
---
 Framework/Core/src/DataRelayer.cxx | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index c2ae459aace38..385d9a6c50c4a 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -17,6 +17,7 @@
 #include "Framework/DataDescriptorMatcher.h"
 #include "Framework/DataSpecUtils.h"
 #include "Framework/DataProcessingHeader.h"
+#include "Framework/DataProcessingContext.h"
 #include "Framework/DataRef.h"
 #include "Framework/InputRecord.h"
 #include "Framework/InputSpan.h"
@@ -46,7 +47,6 @@
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 #include <gsl/span>
-#include <numeric>
 #include <string>
 
 using namespace o2::framework::data_matcher;
@@ -55,6 +55,8 @@ using DataProcessingHeader = o2::framework::DataProcessingHeader;
 using Verbosity = o2::monitoring::Verbosity;
 
 O2_DECLARE_DYNAMIC_LOG(data_relayer);
+// Stream which keeps track of the calibration lifetime logic
+O2_DECLARE_DYNAMIC_LOG(calibration);
 
 namespace o2::framework
 {
@@ -480,6 +482,13 @@ DataRelayer::RelayChoice
       // We are in calibration mode and the data does not have the calibration bit set.
       // We do not store it.
       if (services.get<DeviceState>().allowedProcessing == DeviceState::ProcessingType::CalibrationOnly && !isCalibrationData(messages[mi])) {
+        O2_SIGNPOST_ID_FROM_POINTER(cid, calibration, &services.get<DataProcessorContext>());
+        O2_SIGNPOST_EVENT_EMIT(calibration, cid, "calibration",
+                               "Dropping incoming %zu messages because they are data processing.", nPayloads);
+        // Actually dropping messages.
+        for (size_t i = mi; i < mi + nPayloads + 1; i++) {
+          auto discard = std::move(messages[i]);
+        }
         mi += nPayloads;
         continue;
       }

From 0cdfe91a3e879d32ab246e83556ed852d84911cb Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 9 Mar 2025 16:11:47 +0100
Subject: [PATCH 0016/1764] DPL: add dumping of memory profile in strategic
 location

---
 .../AnalysisSupport/src/DataInputDirector.cxx     | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index 981ca5254980d..2c51360cd9923 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -15,6 +15,7 @@
 #include "Framework/RootArrowFilesystem.h"
 #include "Framework/AnalysisDataModelHelpers.h"
 #include "Framework/Output.h"
+#include "Framework/Signpost.h"
 #include "Headers/DataHeader.h"
 #include "Framework/TableTreeHelpers.h"
 #include "Monitoring/Tags.h"
@@ -41,6 +42,9 @@
 #include <utility>
 #endif
 
+#include <dlfcn.h>
+O2_DECLARE_DYNAMIC_LOG(reader_memory_dump);
+
 namespace o2::framework
 {
 using namespace rapidjson;
@@ -458,6 +462,17 @@ bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh
 
   mIOTime += (uv_hrtime() - ioStart);
 
+  O2_SIGNPOST_ACTION(reader_memory_dump, [](void*) {
+    void (*dump_)(const char*);
+    if (void* sym = dlsym(nullptr, "igprof_dump_now")) {
+      dump_ = __extension__(void (*)(const char*)) sym;
+      if (dump_) {
+        std::string filename = fmt::format("reader-memory-dump-{}.gz", uv_hrtime());
+        dump_(filename.c_str());
+      }
+    }
+  });
+
   return true;
 }
 

From f6c7f18db2818535564090df92cbd0a84828f892 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Wed, 12 Feb 2025 16:31:38 +0100
Subject: [PATCH 0017/1764] Remove CodeCov badge

---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index 3dc6061a39351..8715613a0eb5c 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,6 @@
 
 <!--  /// \cond EXCLUDE_FOR_DOXYGEN -->
 
-[![codecov](https://codecov.io/gh/AliceO2Group/AliceO2/branch/dev/graph/badge.svg)](https://codecov.io/gh/AliceO2Group/AliceO2/branches/dev)
 [![JIRA](https://img.shields.io/badge/JIRA-Report%20issue-blue.svg)](https://alice.its.cern.ch/jira/secure/CreateIssue.jspa?pid=11201&issuetype=1)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1493334.svg)](https://doi.org/10.5281/zenodo.1493334)
 

From 88d8400ba8398f7d06d531bbad888e25898675a1 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Wed, 12 Feb 2025 16:35:21 +0100
Subject: [PATCH 0018/1764] Fix Format

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 8715613a0eb5c..5bdbc4a801e5e 100644
--- a/README.md
+++ b/README.md
@@ -61,8 +61,8 @@ Rules and instructions are available in the repository
 
 ### Enable C++ compiler warnings
 
-Currently O2 is built with minimal compiler warnings enabled. This is going to change in the near future. In the transition period, developers have to manualy enable warnings by building O2 with `ALIBUILD_O2_WARNINGS` environment variable set e.g. using the `-e`  option of `alibuild` e.g: 
-```bash 
+Currently O2 is built with minimal compiler warnings enabled. This is going to change in the near future. In the transition period, developers have to manualy enable warnings by building O2 with `ALIBUILD_O2_WARNINGS` environment variable set e.g. using the `-e`  option of `alibuild` e.g:
+```bash
 aliBuild build --debug -e ALIBUILD_O2_WARNINGS=1 --defaults o2 O2
-``` 
+```
 A helper script that extracts warnings from the build log skipping duplicates is available [here](https://github.com/AliceO2Group/AliceO2/blob/dev/scripts/filter-warnings.sh)

From 8290f89678f78df47310aabb749f2b5157138a62 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 8 Mar 2025 20:52:27 +0100
Subject: [PATCH 0019/1764] GPU: Fix compile warning from shadowed variable,
 disentangle filter types

---
 .../Global/GPUChainTrackingCompression.cxx       | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 1b08de21abd0f..57a759a58924e 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -201,8 +201,8 @@ int32_t GPUChainTracking::RunTPCCompression()
 
 int32_t GPUChainTracking::RunTPCDecompression()
 {
-  const bool runFiltering = GetProcessingSettings().tpcApplyCFCutsAtDecoding || (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0) || (param().tpcCutTimeBin > 0);
-  if (runFiltering && !GetProcessingSettings().tpcUseOldCPUDecoding) {
+  const bool runFullFiltering = GetProcessingSettings().tpcApplyCFCutsAtDecoding || (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0) || (param().tpcCutTimeBin > 0);
+  if (runFullFiltering && !GetProcessingSettings().tpcUseOldCPUDecoding) {
     GPUFatal("tpcApplyCFCutsAtDecoding, tpcApplyClusterFilterOnCPU and tpcCutTimeBin currently require tpcUseOldCPUDecoding");
   }
 
@@ -219,13 +219,13 @@ int32_t GPUChainTracking::RunTPCDecompression()
       return ((tmpBuffer = std::make_unique<ClusterNative[]>(size))).get();
     };
     auto& decompressTimer = getTimer<TPCClusterDecompressor>("TPCDecompression", 0);
-    auto allocatorUse = runFiltering ? std::function<ClusterNative*(size_t)>{allocatorTmp} : std::function<ClusterNative*(size_t)>{allocatorFinal};
+    auto allocatorUse = runFullFiltering ? std::function<ClusterNative*(size_t)>{allocatorTmp} : std::function<ClusterNative*(size_t)>{allocatorFinal};
     decompressTimer.Start();
     if (decomp.decompress(mIOPtrs.tpcCompressedClusters, *mClusterNativeAccess, allocatorUse, param(), GetProcessingSettings().deterministicGPUReconstruction)) {
       GPUError("Error decompressing clusters");
       return 1;
     }
-    if (runFiltering) {
+    if (runFullFiltering) {
       RunTPCClusterFilter(mClusterNativeAccess.get(), allocatorFinal, GetProcessingSettings().tpcApplyCFCutsAtDecoding);
     }
     decompressTimer.Stop();
@@ -245,7 +245,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
     mRec->PushNonPersistentMemory(qStr2Tag("TPCDCMPR"));
     RecoStep myStep = RecoStep::TPCDecompression;
     bool doGPU = GetRecoStepsGPU() & RecoStep::TPCDecompression;
-    bool runFiltering = param().tpcCutTimeBin > 0;
+    bool runTimeBinCutFiltering = param().tpcCutTimeBin > 0;
     GPUTPCDecompression& Decompressor = processors()->tpcDecompressor;
     GPUTPCDecompression& DecompressorShadow = doGPU ? processorsShadow()->tpcDecompressor : Decompressor;
     const auto& threadContext = GetThreadContext();
@@ -325,7 +325,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
     if (decodedAttachedClusters != cmprClsHost.nAttachedClusters) {
       GPUWarning("%u / %u clusters failed track model decoding (%f %%)", cmprClsHost.nAttachedClusters - decodedAttachedClusters, cmprClsHost.nAttachedClusters, 100.f * (float)(cmprClsHost.nAttachedClusters - decodedAttachedClusters) / (float)cmprClsHost.nAttachedClusters);
     }
-    if (runFiltering) { // If filtering, allocate a temporary buffer and cluster native access in decompressor context
+    if (runTimeBinCutFiltering) { // If filtering, allocate a temporary buffer and cluster native access in decompressor context
       Decompressor.mNClusterNativeBeforeFiltering = DecompressorShadow.mNClusterNativeBeforeFiltering = decodedAttachedClusters + cmprClsHost.nUnattachedClusters;
       AllocateRegisteredMemory(Decompressor.mResourceTmpBufferBeforeFiltering);
       AllocateRegisteredMemory(Decompressor.mResourceClusterNativeAccess);
@@ -362,13 +362,13 @@ int32_t GPUChainTracking::RunTPCDecompression()
       int32_t iStream = (iSector / batchSize) % mRec->NStreams();
       runKernel<GPUTPCDecompressionKernels, GPUTPCDecompressionKernels::step1unattached>({GetGridAuto(iStream), krnlRunRangeNone, {nullptr, &mEvents->single}}, iSector, batchSize);
       uint32_t copySize = std::accumulate(mClusterNativeAccess->nClustersSector + iSector, mClusterNativeAccess->nClustersSector + iSector + batchSize, 0u);
-      if (!runFiltering) {
+      if (!runTimeBinCutFiltering) {
         GPUMemCpy(RecoStep::TPCDecompression, mInputsHost->mPclusterNativeOutput + mClusterNativeAccess->clusterOffset[iSector][0], DecompressorShadow.mNativeClustersBuffer + mClusterNativeAccess->clusterOffset[iSector][0], sizeof(Decompressor.mNativeClustersBuffer[0]) * copySize, iStream, false);
       }
     }
     SynchronizeGPU();
 
-    if (runFiltering) { // If filtering is applied, count how many clusters will remain after filtering and allocate final buffers accordingly
+    if (runTimeBinCutFiltering) { // If filtering is applied, count how many clusters will remain after filtering and allocate final buffers accordingly
       AllocateRegisteredMemory(Decompressor.mResourceNClusterPerSectorRow);
       WriteToConstantMemory(myStep, (char*)&processors()->tpcDecompressor - (char*)processors(), &DecompressorShadow, sizeof(DecompressorShadow), unattachedStream);
       runKernel<GPUMemClean16>({GetGridAutoStep(unattachedStream, RecoStep::TPCDecompression), krnlRunRangeNone}, DecompressorShadow.mNClusterPerSectorRow, NSECTORS * GPUCA_ROW_COUNT * sizeof(DecompressorShadow.mNClusterPerSectorRow[0]));

From dd2d2aa66ec6b004806d190876392df908473e81 Mon Sep 17 00:00:00 2001
From: TrifleMichael <61475109+TrifleMichael@users.noreply.github.com>
Date: Mon, 10 Mar 2025 11:19:57 +0100
Subject: [PATCH 0020/1764] CCDBApi: Fix CCDBDownloader redirect errors
 (#14029)

* Fixing CcdbDownloader redirects

This commit addresses:
- Not following available redirects after receiving 4xx http code.
- Not following all redirects provided via "Location" header.
- Not following  redirects after failing alien:/ or file:/ retrieval.
- Improper fail-check in CcdbApi::loadLocalContentToMemory.
- The headers holding etags and content-type from multiple locations.

* Removing whitespaces
---
 CCDB/include/CCDB/CCDBDownloader.h |  8 +++--
 CCDB/src/CCDBDownloader.cxx        | 53 +++++++++++++++++++++---------
 CCDB/src/CcdbApi.cxx               | 37 ++++++++++++++++++---
 3 files changed, 76 insertions(+), 22 deletions(-)

diff --git a/CCDB/include/CCDB/CCDBDownloader.h b/CCDB/include/CCDB/CCDBDownloader.h
index 0bda186e308c6..6c057a537a096 100644
--- a/CCDB/include/CCDB/CCDBDownloader.h
+++ b/CCDB/include/CCDB/CCDBDownloader.h
@@ -47,6 +47,7 @@ struct HeaderObjectPair_t {
 
 typedef struct DownloaderRequestData {
   std::vector<std::string> hosts;
+  std::vector<std::string> locations;
   std::string path;
   long timestamp;
   HeaderObjectPair_t hoPair;
@@ -231,12 +232,13 @@ class CCDBDownloader
   std::string prepareRedirectedURL(std::string address, std::string potentialHost) const;
 
   /**
-   * Returns a vector of possible content locations based on the redirect headers.
+   * Updates the locations vector with the the locations.
    *
-   * @param baseUrl Content path.
    * @param headerMap Map containing response headers.
+   * @param locations Location list to be updated.
+   * @param locIndex Index of the next locaiton to be tried.
    */
-  std::vector<std::string> getLocations(std::multimap<std::string, std::string>* headerMap) const;
+  void updateLocations(std::multimap<std::string, std::string>* headerMap, std::vector<std::string>* locations, int* locIndex) const;
 
   std::string mUserAgentId = "CCDBDownloader";
   /**
diff --git a/CCDB/src/CCDBDownloader.cxx b/CCDB/src/CCDBDownloader.cxx
index 3fca3c8cc2ae6..2f033a50b36e7 100644
--- a/CCDB/src/CCDBDownloader.cxx
+++ b/CCDB/src/CCDBDownloader.cxx
@@ -362,7 +362,7 @@ void CCDBDownloader::tryNewHost(PerformData* performData, CURL* easy_handle)
 {
   auto requestData = performData->requestData;
   std::string newUrl = requestData->hosts.at(performData->hostInd) + "/" + requestData->path + "/" + std::to_string(requestData->timestamp);
-  LOG(debug) << "Connecting to another host " << newUrl;
+  LOG(debug) << "Connecting to another host " << newUrl << "\n";
   requestData->hoPair.header.clear();
   curl_easy_setopt(easy_handle, CURLOPT_URL, newUrl.c_str());
   mHandlesToBeAdded.push_back(easy_handle);
@@ -374,9 +374,11 @@ void CCDBDownloader::getLocalContent(PerformData* performData, std::string& newL
   LOG(debug) << "Redirecting to local content " << newLocation << "\n";
   if (requestData->localContentCallback(newLocation)) {
     contentRetrieved = true;
+    LOG(debug) << "Local content retrieved succesfully: " << newLocation << " n";
   } else {
     // Prepare next redirect url
     newLocation = getNewLocation(performData, locations);
+    LOG(debug) << "Failed to retrieve local content: " << newLocation << "\n";
   }
 }
 
@@ -396,7 +398,7 @@ std::string CCDBDownloader::getNewLocation(PerformData* performData, std::vector
 void CCDBDownloader::httpRedirect(PerformData* performData, std::string& newLocation, CURL* easy_handle)
 {
   auto requestData = performData->requestData;
-  LOG(debug) << "Trying content location " << newLocation;
+  LOG(debug) << "Trying content location " << newLocation << "\n";
   curl_easy_setopt(easy_handle, CURLOPT_URL, newLocation.c_str());
   mHandlesToBeAdded.push_back(easy_handle);
 }
@@ -404,7 +406,7 @@ void CCDBDownloader::httpRedirect(PerformData* performData, std::string& newLoca
 void CCDBDownloader::followRedirect(PerformData* performData, CURL* easy_handle, std::vector<std::string>& locations, bool& rescheduled, bool& contentRetrieved)
 {
   std::string newLocation = getNewLocation(performData, locations);
-  if (newLocation.find("alien:/", 0) != std::string::npos || newLocation.find("file:/", 0) != std::string::npos) {
+  while (!contentRetrieved && (newLocation.find("alien:/", 0) != std::string::npos || newLocation.find("file:/", 0) != std::string::npos)) {
     getLocalContent(performData, newLocation, contentRetrieved, locations);
   }
   if (!contentRetrieved && newLocation != "") {
@@ -508,8 +510,8 @@ void CCDBDownloader::transferFinished(CURL* easy_handle, CURLcode curlCode)
       std::string currentHost = requestData->hosts[performData->hostInd];
       std::string loggingMessage = prepareLogMessage(currentHost, requestData->userAgent, requestData->path, requestData->timestamp, requestData->headers, httpCode);
 
-      // Get alternative locations for the same host
-      auto locations = getLocations(&(requestData->hoPair.header));
+      // Get new locations based on received headers
+      updateLocations(&(requestData->hoPair.header), &requestData->locations, &performData->locInd);
 
       // React to received http code
       if (200 <= httpCode && httpCode < 400) {
@@ -517,8 +519,8 @@ void CCDBDownloader::transferFinished(CURL* easy_handle, CURLcode curlCode)
         if (304 == httpCode) {
           LOGP(debug, "Object exists but I am not serving it since it's already in your possession");
           contentRetrieved = true;
-        } else if (300 <= httpCode && httpCode < 400 && performData->locInd < locations.size()) {
-          followRedirect(performData, easy_handle, locations, rescheduled, contentRetrieved);
+        } else if (300 <= httpCode && httpCode < 400 && performData->locInd < requestData->locations.size()) {
+          followRedirect(performData, easy_handle, requestData->locations, rescheduled, contentRetrieved);
         } else if (200 <= httpCode && httpCode < 300) {
           contentRetrieved = true; // Can be overruled by following error check
         }
@@ -531,8 +533,16 @@ void CCDBDownloader::transferFinished(CURL* easy_handle, CURLcode curlCode)
         contentRetrieved = false;
       }
 
-      // Check if content was retrieved, or scheduled to be retrieved
-      if (!rescheduled && !contentRetrieved && performData->locInd == locations.size()) {
+      // Check if content was retrieved or scheduled to be retrieved
+      if (!rescheduled && !contentRetrieved) {
+        // Current location failed without providing 3xx http code, try next redirect for the same host
+        if (performData->locInd < requestData->locations.size()) {
+          followRedirect(performData, easy_handle, requestData->locations, rescheduled, contentRetrieved);
+        }
+      }
+
+      // Check again because content might have been retrieved or rescheduled via a redirect
+      if (!rescheduled && !contentRetrieved) {
         // Ran out of locations to redirect, try new host
         if (++performData->hostInd < requestData->hosts.size()) {
           tryNewHost(performData, easy_handle);
@@ -650,24 +660,37 @@ CURLcode CCDBDownloader::perform(CURL* handle)
   return batchBlockingPerform(handleVector).back();
 }
 
-std::vector<std::string> CCDBDownloader::getLocations(std::multimap<std::string, std::string>* headerMap) const
+void CCDBDownloader::updateLocations(std::multimap<std::string, std::string>* headerMap, std::vector<std::string>* locations, int* locIndex) const
 {
-  std::vector<std::string> locs;
+  std::vector<std::string> newLocations;
+
   auto iter = headerMap->find("Location");
   if (iter != headerMap->end()) {
-    locs.push_back(iter->second);
+    auto range = headerMap->equal_range("Location");
+    for (auto it = range.first; it != range.second; ++it) {
+      if (std::find(locations->begin(), locations->end(), it->second) == locations->end()) {
+        if (std::find(newLocations.begin(), newLocations.end(), it->second) == newLocations.end()) {
+          newLocations.push_back(it->second);
+        }
+      }
+    }
   }
+
   // add alternative locations (not yet included)
   auto iter2 = headerMap->find("Content-Location");
   if (iter2 != headerMap->end()) {
     auto range = headerMap->equal_range("Content-Location");
     for (auto it = range.first; it != range.second; ++it) {
-      if (std::find(locs.begin(), locs.end(), it->second) == locs.end()) {
-        locs.push_back(it->second);
+      if (std::find(locations->begin(), locations->end(), it->second) == locations->end()) {
+        if (std::find(newLocations.begin(), newLocations.end(), it->second) == newLocations.end()) {
+          newLocations.push_back(it->second);
+        }
       }
     }
   }
-  return locs;
+
+  // Insert location list at the current location index. This assures that the provided locations will be tried first.
+  locations->insert(locations->begin() + (*locIndex), newLocations.begin(), newLocations.end());
 }
 
 std::vector<CURLcode> CCDBDownloader::batchBlockingPerform(std::vector<CURL*> const& handleVector)
diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index df05d393100d6..2906438211c65 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -667,6 +667,23 @@ size_t header_map_callback(char* buffer, size_t size, size_t nitems, void* userd
         }
       }
     }
+
+    // Keep only the first ETag encountered
+    if (key == "ETag") {
+      auto cl = headers->find("ETag");
+      if (cl != headers->end()) {
+        insert = false;
+      }
+    }
+
+    // Keep only the first Content-Type encountered
+    if (key == "Content-Type") {
+      auto cl = headers->find("Content-Type");
+      if (cl != headers->end()) {
+        insert = false;
+      }
+    }
+
     if (insert) {
       headers->insert(std::make_pair(key, value));
     }
@@ -1971,14 +1988,26 @@ void CcdbApi::vectoredLoadFileToMemory(std::vector<RequestContext>& requestConte
 bool CcdbApi::loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string& url) const
 {
   if (url.find("alien:/", 0) != std::string::npos) {
-    loadFileToMemory(dest, url, nullptr); // headers loaded from the file in case of the snapshot reading only
-    return true;
+    std::map<std::string, std::string> localHeaders;
+    loadFileToMemory(dest, url, &localHeaders);
+    auto it = localHeaders.find("Error");
+    if (it != localHeaders.end() && it->second == "An error occurred during retrieval") {
+      return false;
+    } else {
+      return true;
+    }
   }
   if ((url.find("file:/", 0) != std::string::npos)) {
     std::string path = url.substr(7);
     if (std::filesystem::exists(path)) {
-      loadFileToMemory(dest, path, nullptr);
-      return true;
+      std::map<std::string, std::string> localHeaders;
+      loadFileToMemory(dest, url, &localHeaders);
+      auto it = localHeaders.find("Error");
+      if (it != localHeaders.end() && it->second == "An error occurred during retrieval") {
+        return false;
+      } else {
+        return true;
+      }
     }
   }
   return false;

From 622bcca8fa0fa2461a67462eca8f497900110e15 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 10 Mar 2025 10:12:29 +0100
Subject: [PATCH 0021/1764] DPL: drop obsolete TreeToTable code

Now using the arrow::Dataset API.
---
 Framework/Core/CMakeLists.txt                 |   2 -
 .../Core/include/Framework/DataAllocator.h    |  14 -
 .../Core/include/Framework/TableTreeHelpers.h |  54 ----
 Framework/Core/src/DataAllocator.cxx          |  32 ---
 Framework/Core/src/TableTreeHelpers.cxx       | 272 ------------------
 Framework/Core/test/benchmark_TreeToTable.cxx |  96 -------
 Framework/Core/test/test_TreeToTable.cxx      | 237 ---------------
 7 files changed, 707 deletions(-)
 delete mode 100644 Framework/Core/test/benchmark_TreeToTable.cxx
 delete mode 100644 Framework/Core/test/test_TreeToTable.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 7202e2299b7cc..f059984b5d85d 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -250,7 +250,6 @@ add_executable(o2-test-framework-core
               test/test_Variants.cxx
               test/test_WorkflowHelpers.cxx
               test/test_WorkflowSerialization.cxx
-              test/test_TreeToTable.cxx
               test/test_DataOutputDirector.cxx
               test/unittest_SimpleOptionsRetriever.cxx
               test/unittest_DataSpecUtils.cxx
@@ -348,7 +347,6 @@ foreach(b
         EventMixing
         HistogramRegistry
         TableToTree
-        TreeToTable
         ExternalFairMQDeviceProxies
         )
   o2_add_executable(benchmark-${b}
diff --git a/Framework/Core/include/Framework/DataAllocator.h b/Framework/Core/include/Framework/DataAllocator.h
index eb63b5469bb29..287513ec85845 100644
--- a/Framework/Core/include/Framework/DataAllocator.h
+++ b/Framework/Core/include/Framework/DataAllocator.h
@@ -233,15 +233,6 @@ class DataAllocator
     return tb;
   }
 
-  template <typename T, typename... Args>
-    requires(requires { static_cast<struct TreeToTable>(std::declval<std::decay_t<T>>()); })
-  decltype(auto) make(const Output& spec, Args... args)
-  {
-    auto t2t = std::move(LifetimeHolder<TreeToTable>(new std::decay_t<T>(args...)));
-    adopt(spec, t2t);
-    return t2t;
-  }
-
   template <typename T, typename... Args>
     requires(requires { static_cast<struct FragmentToBatch>(std::declval<std::decay_t<T>>()); })
   decltype(auto) make(const Output& spec, Args... args)
@@ -288,11 +279,6 @@ class DataAllocator
   void
     adopt(const Output& spec, LifetimeHolder<struct TableBuilder>&);
 
-  /// Adopt a Tree2Table in the framework and serialise / send
-  /// it as an Arrow table to all consumers of @a spec once done
-  void
-    adopt(const Output& spec, LifetimeHolder<struct TreeToTable>&);
-
   /// Adopt a Source2Batch in the framework and serialise / send
   /// it as an Arrow Dataset to all consumers of @a spec once done
   void
diff --git a/Framework/Core/include/Framework/TableTreeHelpers.h b/Framework/Core/include/Framework/TableTreeHelpers.h
index 92725d186ee33..3f76298a5bbd4 100644
--- a/Framework/Core/include/Framework/TableTreeHelpers.h
+++ b/Framework/Core/include/Framework/TableTreeHelpers.h
@@ -36,19 +36,6 @@ namespace o2::framework
 //    OR t2t.addBranch(column.get(), field.get()), ...;
 //  . t2t.process();
 //
-// .............................................................................
-// -----------------------------------------------------------------------------
-// TreeToTable allows to fill the contents of a given TTree to an arrow::Table
-//  ColumnIterator is used by TreeToTable
-//
-// To copy the contents of a tree tr to a table ta do:
-//  . TreeToTable t2t(tr);
-//  . t2t.addColumn(columnname1); t2t.addColumn(columnname2); ...
-//    OR
-//    t2t.addAllColumns();
-//  . auto ta = t2t.process();
-//
-// .............................................................................
 struct ROOTTypeInfo {
   EDataType type;
   char suffix[3];
@@ -58,29 +45,6 @@ struct ROOTTypeInfo {
 auto arrowTypeFromROOT(EDataType type, int size);
 auto basicROOTTypeFromArrow(arrow::Type::type id);
 
-class BranchToColumn
-{
- public:
-  BranchToColumn(TBranch* branch, bool VLA, std::string name, EDataType type, int listSize, arrow::MemoryPool* pool);
-  //  BranchToColumn(TBranch* branch, TBranch* sizeBranch, std::string name, EDataType type, arrow::MemoryPool* pool);
-  ~BranchToColumn() = default;
-  TBranch* branch();
-
-  std::pair<std::shared_ptr<arrow::ChunkedArray>, std::shared_ptr<arrow::Field>> read(TBuffer* buffer);
-
- private:
-  TBranch* mBranch = nullptr;
-  bool mVLA = false;
-  std::string mColumnName;
-  EDataType mType;
-  std::shared_ptr<arrow::DataType> mArrowType;
-  arrow::ArrayBuilder* mValueBuilder = nullptr;
-  std::unique_ptr<arrow::ArrayBuilder> mListBuilder = nullptr;
-  int mListSize = 1;
-  std::unique_ptr<arrow::ArrayBuilder> mBuilder = nullptr;
-  arrow::MemoryPool* mPool = nullptr;
-};
-
 class ColumnToBranch
 {
  public:
@@ -127,24 +91,6 @@ class TableToTree
   std::vector<std::unique_ptr<ColumnToBranch>> mColumnReaders;
 };
 
-class TreeToTable
-{
- public:
-  TreeToTable(arrow::MemoryPool* pool = arrow::default_memory_pool());
-  void setLabel(const char* label);
-  void addAllColumns(TTree* tree, std::vector<std::string>&& names = {});
-  void fill(TTree*);
-  std::shared_ptr<arrow::Table> finalize();
-
- private:
-  arrow::MemoryPool* mArrowMemoryPool;
-  std::vector<std::unique_ptr<BranchToColumn>> mBranchReaders;
-  std::string mTableLabel;
-  std::shared_ptr<arrow::Table> mTable;
-
-  void addReader(TBranch* branch, std::string const& name, bool VLA);
-};
-
 class FragmentToBatch
 {
  public:
diff --git a/Framework/Core/src/DataAllocator.cxx b/Framework/Core/src/DataAllocator.cxx
index b735eee1f3308..ca35089fdfaab 100644
--- a/Framework/Core/src/DataAllocator.cxx
+++ b/Framework/Core/src/DataAllocator.cxx
@@ -241,38 +241,6 @@ void DataAllocator::adopt(const Output& spec, LifetimeHolder<TableBuilder>& tb)
   context.addBuffer(std::move(header), buffer, std::move(finalizer), routeIndex);
 }
 
-void DataAllocator::adopt(const Output& spec, LifetimeHolder<TreeToTable>& t2t)
-{
-  auto& timingInfo = mRegistry.get<TimingInfo>();
-  RouteIndex routeIndex = matchDataHeader(spec, timingInfo.timeslice);
-
-  auto header = headerMessageFromOutput(spec, routeIndex, o2::header::gSerializationMethodArrow, 0);
-  auto& context = mRegistry.get<ArrowContext>();
-
-  auto creator = [transport = context.proxy().getOutputTransport(routeIndex)](size_t s) -> std::unique_ptr<fair::mq::Message> {
-    return transport->CreateMessage(s);
-  };
-  auto buffer = std::make_shared<FairMQResizableBuffer>(creator);
-
-  t2t.callback = [buffer = buffer, transport = context.proxy().getOutputTransport(routeIndex)](TreeToTable& tree) {
-    // Serialization happens in here, so that we can
-    // get rid of the intermediate tree 2 table object, saving memory.
-    auto table = tree.finalize();
-    doWriteTable(buffer, table.get());
-    // deletion happens in the caller
-  };
-
-  /// To finalise this we write the table to the buffer.
-  /// FIXME: most likely not a great idea. We should probably write to the buffer
-  ///        directly in the TableBuilder, incrementally.
-  auto finalizer = [](std::shared_ptr<FairMQResizableBuffer> b) -> void {
-    // This is empty because we already serialised the object when
-    // the LifetimeHolder goes out of scope.
-  };
-
-  context.addBuffer(std::move(header), buffer, std::move(finalizer), routeIndex);
-}
-
 void DataAllocator::adopt(const Output& spec, LifetimeHolder<FragmentToBatch>& f2b)
 {
   auto& timingInfo = mRegistry.get<TimingInfo>();
diff --git a/Framework/Core/src/TableTreeHelpers.cxx b/Framework/Core/src/TableTreeHelpers.cxx
index 84d4ff171bc39..92231cb9ce069 100644
--- a/Framework/Core/src/TableTreeHelpers.cxx
+++ b/Framework/Core/src/TableTreeHelpers.cxx
@@ -102,166 +102,6 @@ auto basicROOTTypeFromArrow(arrow::Type::type id)
   }
 }
 
-TBranch* BranchToColumn::branch()
-{
-  return mBranch;
-}
-
-BranchToColumn::BranchToColumn(TBranch* branch, bool VLA, std::string name, EDataType type, int listSize, arrow::MemoryPool* pool)
-  : mBranch{branch},
-    mVLA{VLA},
-    mColumnName{std::move(name)},
-    mType{type},
-    mArrowType{arrowTypeFromROOT(type, listSize)},
-    mListSize{listSize},
-    mPool{pool}
-
-{
-  if (mType == EDataType::kBool_t) {
-    if (mListSize > 1) {
-      auto status = arrow::MakeBuilder(mPool, mArrowType->field(0)->type(), &mBuilder);
-      if (!status.ok()) {
-        throw runtime_error("Cannot create value builder");
-      }
-      mListBuilder = std::make_unique<arrow::FixedSizeListBuilder>(mPool, std::move(mBuilder), mListSize);
-      mValueBuilder = static_cast<arrow::FixedSizeListBuilder*>(mListBuilder.get())->value_builder();
-    } else {
-      auto status = arrow::MakeBuilder(mPool, mArrowType, &mBuilder);
-      if (!status.ok()) {
-        throw runtime_error("Cannot create builder");
-      }
-      mValueBuilder = mBuilder.get();
-    }
-  }
-}
-
-std::pair<std::shared_ptr<arrow::ChunkedArray>, std::shared_ptr<arrow::Field>> BranchToColumn::read(TBuffer* buffer)
-{
-  O2_SIGNPOST_ID_FROM_POINTER(sid, tabletree_helpers, buffer);
-  auto totalEntries = mBranch->GetEntries();
-  arrow::Status status;
-  int readEntries = 0;
-  buffer->Reset();
-  std::shared_ptr<arrow::Array> array;
-
-  if (mType == EDataType::kBool_t) {
-    // boolean array special case: we need to use builder to create the bitmap
-    status = mValueBuilder->Reserve(totalEntries * mListSize);
-    if (mListSize > 1) {
-      status &= mListBuilder->Reserve(totalEntries);
-    }
-    if (!status.ok()) {
-      throw runtime_error("Failed to reserve memory for array builder");
-    }
-    while (readEntries < totalEntries) {
-      auto readLast = mBranch->GetBulkRead().GetBulkEntries(readEntries, *buffer);
-      readEntries += readLast;
-      status &= static_cast<arrow::BooleanBuilder*>(mValueBuilder)->AppendValues(reinterpret_cast<uint8_t const*>(buffer->GetCurrent()), readLast * mListSize);
-    }
-    if (mListSize > 1) {
-      status &= static_cast<arrow::FixedSizeListBuilder*>(mListBuilder.get())->AppendValues(readEntries);
-    }
-    if (!status.ok()) {
-      throw runtime_error("Failed to append values to array");
-    }
-    if (mListSize > 1) {
-      status &= mListBuilder->Finish(&array);
-    } else {
-      status &= mValueBuilder->Finish(&array);
-    }
-    if (!status.ok()) {
-      throw runtime_error("Failed to create array");
-    }
-  } else {
-    // other types: use serialized read to build arrays directly
-    size_t branchSize = mBranch->GetTotBytes();
-    auto&& result = arrow::AllocateResizableBuffer(mBranch->GetTotBytes(), mPool);
-    O2_SIGNPOST_EVENT_EMIT(tabletree_helpers, sid, "BranchToColumn", "Allocating %ld bytes for %{public}s", branchSize, mBranch->GetName());
-    if (!result.ok()) {
-      throw runtime_error("Cannot allocate values buffer");
-    }
-    std::shared_ptr<arrow::Buffer> arrowValuesBuffer = std::move(result).ValueUnsafe();
-    auto ptr = arrowValuesBuffer->mutable_data();
-    if (ptr == nullptr) {
-      throw runtime_error("Invalid buffer");
-    }
-
-    auto typeSize = TDataType::GetDataType(mType)->Size();
-    std::unique_ptr<TBufferFile> offsetBuffer = nullptr;
-
-    uint32_t offset = 0;
-    int count = 0;
-    std::shared_ptr<arrow::Buffer> arrowOffsetBuffer;
-    gsl::span<int> offsets;
-    int size = 0;
-    uint32_t totalSize = 0;
-    TBranch* mSizeBranch = nullptr;
-    if (mVLA) {
-      mSizeBranch = mBranch->GetTree()->GetBranch((std::string{mBranch->GetName()} + TableTreeHelpers::sizeBranchSuffix).c_str());
-      offsetBuffer = std::make_unique<TBufferFile>(TBuffer::EMode::kWrite, 4 * 1024 * 1024);
-      result = arrow::AllocateResizableBuffer((totalEntries + 1) * (int64_t)sizeof(int), mPool);
-      if (!result.ok()) {
-        throw runtime_error("Cannot allocate offset buffer");
-      }
-      arrowOffsetBuffer = std::move(result).ValueUnsafe();
-      unsigned char* ptrOffset = arrowOffsetBuffer->mutable_data();
-      auto* tPtrOffset = reinterpret_cast<int*>(ptrOffset);
-      offsets = gsl::span<int>{tPtrOffset, tPtrOffset + totalEntries + 1};
-
-      // read sizes first
-      while (readEntries < totalEntries) {
-        auto readLast = mSizeBranch->GetBulkRead().GetEntriesSerialized(readEntries, *offsetBuffer);
-        readEntries += readLast;
-        for (auto i = 0; i < readLast; ++i) {
-          offsets[count++] = (int)offset;
-          offset += swap32_(reinterpret_cast<uint32_t*>(offsetBuffer->GetCurrent())[i]);
-        }
-      }
-      offsets[count] = (int)offset;
-      totalSize = offset;
-      readEntries = 0;
-    }
-
-    while (readEntries < totalEntries) {
-      auto readLast = mBranch->GetBulkRead().GetEntriesSerialized(readEntries, *buffer);
-      if (mVLA) {
-        size = offsets[readEntries + readLast] - offsets[readEntries];
-      } else {
-        size = readLast * mListSize;
-      }
-      readEntries += readLast;
-      swapCopy(ptr, buffer->GetCurrent(), size, typeSize);
-      ptr += (ptrdiff_t)(size * typeSize);
-    }
-    if (!mVLA) {
-      totalSize = readEntries * mListSize;
-    }
-    std::shared_ptr<arrow::PrimitiveArray> varray;
-    switch (mListSize) {
-      case -1:
-        varray = std::make_shared<arrow::PrimitiveArray>(mArrowType->field(0)->type(), totalSize, arrowValuesBuffer);
-        array = std::make_shared<arrow::ListArray>(mArrowType, readEntries, arrowOffsetBuffer, varray);
-        break;
-      case 1:
-        array = std::make_shared<arrow::PrimitiveArray>(mArrowType, readEntries, arrowValuesBuffer);
-        break;
-      default:
-        varray = std::make_shared<arrow::PrimitiveArray>(mArrowType->field(0)->type(), totalSize, arrowValuesBuffer);
-        array = std::make_shared<arrow::FixedSizeListArray>(mArrowType, readEntries, varray);
-    }
-  }
-
-  auto fullArray = std::make_shared<arrow::ChunkedArray>(array);
-  auto field = std::make_shared<arrow::Field>(mBranch->GetName(), mArrowType);
-
-  mBranch->SetStatus(false);
-  mBranch->DropBaskets("all");
-  mBranch->Reset();
-  mBranch->GetTransientBuffer(0)->Expand(0);
-
-  return std::make_pair(fullArray, field);
-}
-
 ColumnToBranch::ColumnToBranch(TTree* tree, std::shared_ptr<arrow::ChunkedArray> const& column, std::shared_ptr<arrow::Field> const& field)
   : mBranchName{field->name()},
     mColumn{column.get()},
@@ -447,11 +287,6 @@ std::shared_ptr<TTree> TableToTree::process()
   return mTree;
 }
 
-TreeToTable::TreeToTable(arrow::MemoryPool* pool)
-  : mArrowMemoryPool{pool}
-{
-}
-
 namespace
 {
 struct BranchInfo {
@@ -461,113 +296,6 @@ struct BranchInfo {
 };
 } // namespace
 
-void TreeToTable::addAllColumns(TTree* tree, std::vector<std::string>&& names)
-{
-  auto branches = tree->GetListOfBranches();
-  auto n = branches->GetEntries();
-  if (n == 0) {
-    throw runtime_error("Tree has no branches");
-  }
-
-  std::vector<BranchInfo> branchInfos;
-  for (auto i = 0; i < n; ++i) {
-    auto branch = static_cast<TBranch*>(branches->At(i));
-    auto name = std::string{branch->GetName()};
-    auto pos = name.find(TableTreeHelpers::sizeBranchSuffix);
-    if (pos != std::string::npos) {
-      name.erase(pos);
-      branchInfos.emplace_back(BranchInfo{name, (TBranch*)nullptr, true});
-    } else {
-      auto lookup = std::find_if(branchInfos.begin(), branchInfos.end(), [&](BranchInfo const& bi) {
-        return bi.name == name;
-      });
-      if (lookup == branchInfos.end()) {
-        branchInfos.emplace_back(BranchInfo{name, branch, false});
-      } else {
-        lookup->ptr = branch;
-      }
-    }
-  }
-
-  if (names.empty()) {
-    for (auto& bi : branchInfos) {
-      addReader(bi.ptr, bi.name, bi.mVLA);
-    }
-  } else {
-    for (auto& name : names) {
-      auto lookup = std::find_if(branchInfos.begin(), branchInfos.end(), [&](BranchInfo const& bi) {
-        return name == bi.name;
-      });
-      if (lookup != branchInfos.end()) {
-        addReader(lookup->ptr, lookup->name, lookup->mVLA);
-      }
-    }
-    if (names.size() != mBranchReaders.size()) {
-      LOGF(warn, "Not all requested columns were found in the tree");
-    }
-  }
-  if (mBranchReaders.empty()) {
-    throw runtime_error("No columns will be read");
-  }
-  // Was affected by https://github.com/root-project/root/issues/8962
-  // Re-enabling this seems to cut the number of IOPS in half
-  tree->SetCacheSize(25000000);
-  // tree->SetClusterPrefetch(true);
-  for (auto& reader : mBranchReaders) {
-    tree->AddBranchToCache(reader->branch());
-    if (strncmp(reader->branch()->GetName(), "fIndexArray", strlen("fIndexArray")) == 0) {
-      std::string sizeBranchName = reader->branch()->GetName();
-      sizeBranchName += "_size";
-      auto* sizeBranch = (TBranch*)tree->GetBranch(sizeBranchName.c_str());
-      if (sizeBranch) {
-        tree->AddBranchToCache(sizeBranch);
-      }
-    }
-  }
-  tree->StopCacheLearningPhase();
-}
-
-void TreeToTable::setLabel(const char* label)
-{
-  mTableLabel = label;
-}
-
-void TreeToTable::fill(TTree* tree)
-{
-  std::vector<std::shared_ptr<arrow::ChunkedArray>> columns;
-  std::vector<std::shared_ptr<arrow::Field>> fields;
-  static TBufferFile buffer{TBuffer::EMode::kWrite, 4 * 1024 * 1024};
-  O2_SIGNPOST_ID_FROM_POINTER(sid, tabletree_helpers, &buffer);
-  O2_SIGNPOST_START(tabletree_helpers, sid, "TreeToTable", "Filling %{public}s", tree->GetName());
-  for (auto& reader : mBranchReaders) {
-    buffer.Reset();
-    auto arrayAndField = reader->read(&buffer);
-    columns.push_back(arrayAndField.first);
-    fields.push_back(arrayAndField.second);
-  }
-  O2_SIGNPOST_END(tabletree_helpers, sid, "TreeToTable", "Done filling.");
-
-  auto schema = std::make_shared<arrow::Schema>(fields, std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{mTableLabel}));
-  mTable = arrow::Table::Make(schema, columns);
-}
-
-void TreeToTable::addReader(TBranch* branch, std::string const& name, bool VLA)
-{
-  static TClass* cls;
-  EDataType type;
-  branch->GetExpectedType(cls, type);
-  auto listSize = -1;
-  if (!VLA) {
-    listSize = static_cast<TLeaf*>(branch->GetListOfLeaves()->At(0))->GetLenStatic();
-  }
-  mBranchReaders.emplace_back(std::make_unique<BranchToColumn>(branch, VLA, name, type, listSize, mArrowMemoryPool));
-}
-
-std::shared_ptr<arrow::Table> TreeToTable::finalize()
-{
-  return mTable;
-}
-
 FragmentToBatch::FragmentToBatch(StreamerCreator creator, std::shared_ptr<arrow::dataset::FileFragment> fragment, arrow::MemoryPool* pool)
   : mFragment{std::move(fragment)},
     mArrowMemoryPool{pool},
diff --git a/Framework/Core/test/benchmark_TreeToTable.cxx b/Framework/Core/test/benchmark_TreeToTable.cxx
deleted file mode 100644
index 6eca853a90ce4..0000000000000
--- a/Framework/Core/test/benchmark_TreeToTable.cxx
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "Framework/CommonDataProcessors.h"
-#include "Framework/TableTreeHelpers.h"
-#include "Framework/Logger.h"
-#include <benchmark/benchmark.h>
-#include <random>
-#include <vector>
-
-#include <TFile.h>
-
-using namespace o2::framework;
-using namespace arrow;
-using namespace o2::soa;
-
-namespace test
-{
-DECLARE_SOA_COLUMN_FULL(X, x, float, "x");
-DECLARE_SOA_COLUMN_FULL(Y, y, float, "y");
-DECLARE_SOA_COLUMN_FULL(Z, z, float, "z");
-DECLARE_SOA_DYNAMIC_COLUMN(Sum, sum, [](float x, float y) { return x + y; });
-} // namespace test
-
-#ifdef __APPLE__
-constexpr unsigned int maxrange = 15;
-#else
-constexpr unsigned int maxrange = 16;
-#endif
-
-static void BM_TreeToTable(benchmark::State& state)
-{
-
-  // initialize a random generator
-  std::default_random_engine e1(1234567891);
-  std::uniform_real_distribution<double> rd(0, 1);
-  std::normal_distribution<float> rf(5., 2.);
-  std::discrete_distribution<ULong64_t> rl({10, 20, 30, 30, 5, 5});
-  std::discrete_distribution<int> ri({10, 20, 30, 30, 5, 5});
-
-  // create a table and fill the columns with random numbers
-  TableBuilder builder;
-  auto rowWriter =
-    builder.persist<double, float, ULong64_t, int>({"a", "b", "c", "d"});
-  for (auto i = 0; i < state.range(0); ++i) {
-    rowWriter(0, rd(e1), rf(e1), rl(e1), ri(e1));
-  }
-  auto table = builder.finalize();
-
-  // now convert the table to a tree
-  TFile fout("tree2table.root", "RECREATE");
-  TableToTree ta2tr(table, &fout, "tree2table");
-  ta2tr.addAllBranches();
-  ta2tr.process();
-  fout.Close();
-
-  // read tree and convert to table again
-  TFile* f = nullptr;
-  TreeToTable* tr2ta = nullptr;
-  for (auto _ : state) {
-
-    // Open file and create tree
-    f = new TFile("tree2table.root", "READ");
-    auto tr = (TTree*)f->Get("tree2table");
-
-    // benchmark TreeToTable
-    if (tr) {
-      tr2ta = new TreeToTable;
-      tr2ta->addAllColumns(tr);
-      tr2ta->fill(tr);
-      auto ta = tr2ta->finalize();
-    } else {
-      LOG(info) << "tree is empty!";
-    }
-
-    // clean up
-    delete tr2ta;
-
-    f->Close();
-    delete f;
-  }
-
-  state.SetBytesProcessed(state.iterations() * state.range(0) * 24);
-}
-
-BENCHMARK(BM_TreeToTable)->Range(8, 8 << maxrange);
-
-BENCHMARK_MAIN();
diff --git a/Framework/Core/test/test_TreeToTable.cxx b/Framework/Core/test/test_TreeToTable.cxx
deleted file mode 100644
index 4f3429a5bba62..0000000000000
--- a/Framework/Core/test/test_TreeToTable.cxx
+++ /dev/null
@@ -1,237 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include <catch_amalgamated.hpp>
-
-#include "Framework/CommonDataProcessors.h"
-#include "Framework/TableTreeHelpers.h"
-#include "Framework/Logger.h"
-#include "Framework/TableBuilder.h"
-
-#include <TTree.h>
-#include <TRandom.h>
-#include <arrow/table.h>
-#include <array>
-
-using namespace o2::framework;
-
-TEST_CASE("TreeToTableConversion")
-{
-  /// Create a simple TTree
-  Int_t ndp = 17;
-
-  TFile f1("tree2table.root", "RECREATE");
-  TTree t1("t1", "a simple Tree with simple variables");
-  Bool_t ok, ts[5] = {false};
-  Float_t px, py, pz;
-  Double_t random;
-  Int_t ev;
-  uint8_t b;
-  const Int_t nelem = 9;
-  Double_t ij[nelem] = {0};
-  float xyzw[96];
-  memset(xyzw, 1, 96 * 4);
-  TString leaflist = Form("ij[%i]/D", nelem);
-
-  Int_t ncols = 10;
-  t1.Branch("ok", &ok, "ok/O");
-  t1.Branch("px", &px, "px/F");
-  t1.Branch("py", &py, "py/F");
-  t1.Branch("pz", &pz, "pz/F");
-  t1.Branch("random", &random, "random/D");
-  t1.Branch("ev", &ev, "ev/I");
-  t1.Branch("ij", ij, leaflist.Data());
-  t1.Branch("tests", ts, "tests[5]/O");
-  t1.Branch("xyzw", xyzw, "xyzw[96]/F");
-  t1.Branch("small", &b, "small/b");
-
-  // fill the tree
-  int ntruein[2] = {0};
-  for (int i = 0; i < ndp; i++) {
-    ok = (i % 2) == 0;
-    if (ok) {
-      ntruein[0]++;
-    }
-    gRandom->Rannor(px, py);
-    pz = px * px + py * py;
-    random = gRandom->Rndm();
-    ev = i + 1;
-    b = i % 3;
-    for (Int_t jj = 0; jj < nelem; jj++) {
-      ij[jj] = i + 100 * jj;
-    }
-    for (Int_t jj = 0; jj < 5; jj++) {
-      ts[jj] = (((i + jj) % 2) == 0);
-      if (ts[jj]) {
-        ntruein[1]++;
-      }
-    }
-
-    t1.Fill();
-  }
-  t1.Write();
-
-  // Create an arrow table from this.
-  TreeToTable tr2ta;
-  tr2ta.addAllColumns(&t1);
-  tr2ta.fill(&t1);
-  auto table = tr2ta.finalize();
-  f1.Close();
-
-  // test result
-  REQUIRE(table->Validate().ok() == true);
-  REQUIRE(table->num_rows() == ndp);
-  REQUIRE(table->num_columns() == ncols);
-
-  REQUIRE(table->column(0)->type()->id() == arrow::Type::BOOL);
-  REQUIRE(table->column(1)->type()->id() == arrow::Type::FLOAT);
-  REQUIRE(table->column(2)->type()->id() == arrow::Type::FLOAT);
-  REQUIRE(table->column(3)->type()->id() == arrow::Type::FLOAT);
-  REQUIRE(table->column(4)->type()->id() == arrow::Type::DOUBLE);
-  REQUIRE(table->column(5)->type()->id() == arrow::Type::INT32);
-  REQUIRE(table->column(6)->type()->id() == arrow::Type::FIXED_SIZE_LIST);
-  REQUIRE(table->column(7)->type()->id() == arrow::Type::FIXED_SIZE_LIST);
-  REQUIRE(table->column(8)->type()->id() == arrow::Type::FIXED_SIZE_LIST);
-  REQUIRE(table->column(9)->type()->id() == arrow::Type::UINT8);
-
-  REQUIRE(table->column(0)->type()->Equals(arrow::boolean()));
-  REQUIRE(table->column(1)->type()->Equals(arrow::float32()));
-  REQUIRE(table->column(2)->type()->Equals(arrow::float32()));
-  REQUIRE(table->column(3)->type()->Equals(arrow::float32()));
-  REQUIRE(table->column(4)->type()->Equals(arrow::float64()));
-  REQUIRE(table->column(5)->type()->Equals(arrow::int32()));
-  REQUIRE(table->column(6)->type()->Equals(arrow::fixed_size_list(arrow::float64(), nelem)));
-  REQUIRE(table->column(7)->type()->Equals(arrow::fixed_size_list(arrow::boolean(), 5)));
-  REQUIRE(table->column(8)->type()->Equals(arrow::fixed_size_list(arrow::float32(), 96)));
-  REQUIRE(table->column(9)->type()->Equals(arrow::uint8()));
-
-  // count number of rows with ok==true
-  int ntrueout = 0;
-  auto chunks = table->column(0);
-  REQUIRE(!(chunks.get() == nullptr));
-
-  auto oks = std::dynamic_pointer_cast<arrow::BooleanArray>(chunks->chunk(0));
-  REQUIRE(!(oks.get() == nullptr));
-
-  for (int ii = 0; ii < table->num_rows(); ii++) {
-    ntrueout += oks->Value(ii) ? 1 : 0;
-  }
-  REQUIRE(ntruein[0] == ntrueout);
-
-  // count number of ts with ts==true
-  chunks = table->column(7);
-  REQUIRE(!(chunks.get() == nullptr));
-
-  auto chunkToUse = std::static_pointer_cast<arrow::FixedSizeListArray>(chunks->chunk(0))->values();
-  REQUIRE(!(chunkToUse.get() == nullptr));
-
-  auto tests = std::dynamic_pointer_cast<arrow::BooleanArray>(chunkToUse);
-  ntrueout = 0;
-  for (int ii = 0; ii < table->num_rows() * 5; ii++) {
-    ntrueout += tests->Value(ii) ? 1 : 0;
-  }
-  REQUIRE(ntruein[1] == ntrueout);
-
-  // save table as tree
-  TFile* f2 = TFile::Open("table2tree.root", "RECREATE");
-  TableToTree ta2tr(table, f2, "mytree");
-  ta2tr.addAllBranches();
-
-  auto t2 = ta2tr.process();
-  auto br = (TBranch*)t2->GetBranch("ok");
-  REQUIRE(t2->GetEntries() == ndp);
-  REQUIRE(br->GetEntries() == ndp);
-  br = (TBranch*)t2->GetBranch("tests");
-  REQUIRE(br->GetEntries() == ndp);
-
-  f2->Close();
-}
-
-namespace o2::aod
-{
-namespace cols
-{
-DECLARE_SOA_COLUMN(Ivec, ivec, std::vector<int>);
-DECLARE_SOA_COLUMN(Fvec, fvec, std::vector<float>);
-DECLARE_SOA_COLUMN(Dvec, dvec, std::vector<double>);
-DECLARE_SOA_COLUMN(UIvec, uivec, std::vector<uint8_t>);
-} // namespace cols
-
-DECLARE_SOA_TABLE(Vectors, "AOD", "VECS", o2::soa::Index<>, cols::Ivec, cols::Fvec, cols::Dvec, cols::UIvec);
-} // namespace o2::aod
-
-TEST_CASE("VariableLists")
-{
-  TableBuilder b;
-  auto writer = b.cursor<o2::aod::Vectors>();
-  std::vector<int> iv;
-  std::vector<float> fv;
-  std::vector<double> dv;
-  std::vector<uint8_t> ui;
-
-  std::array<int, 3> empty = {3, 7, 10};
-  auto count = 0;
-  for (auto i = 1; i < 1000; ++i) {
-    iv.clear();
-    fv.clear();
-    dv.clear();
-    ui.clear();
-    if (count < empty.size() && i != empty[count]) {
-      for (auto j = 0; j < i % 10 + 1; ++j) {
-        iv.push_back(j + 2);
-        fv.push_back((j + 2) * 0.2134f);
-        dv.push_back((j + 4) * 0.192873819237);
-        ui.push_back(j);
-      }
-    } else {
-      count++;
-    }
-    writer(0, iv, fv, dv, ui);
-  }
-  auto table = b.finalize();
-
-  auto* f = TFile::Open("variable_lists.root", "RECREATE");
-  TableToTree ta2tr(table, f, "lists");
-  ta2tr.addAllBranches();
-  auto tree = ta2tr.process();
-  f->Close();
-
-  auto* f2 = TFile::Open("variable_lists.root", "READ");
-  auto* treeptr = static_cast<TTree*>(f2->Get("lists;1"));
-  TreeToTable tr2ta;
-  tr2ta.addAllColumns(treeptr);
-  tr2ta.fill(treeptr);
-  auto ta = tr2ta.finalize();
-  o2::aod::Vectors v{ta};
-  int i = 1;
-  count = 0;
-  for (auto& row : v) {
-    auto ivr = row.ivec();
-    auto fvr = row.fvec();
-    auto dvr = row.dvec();
-    auto uvr = row.uivec();
-    if (count < empty.size() && i != empty[count]) {
-      for (auto j = 0; j < i % 10 + 1; ++j) {
-        REQUIRE(ivr[j] == j + 2);
-        REQUIRE(fvr[j] == (j + 2) * 0.2134f);
-        REQUIRE(dvr[j] == (j + 4) * 0.192873819237);
-        REQUIRE(uvr[j] == j);
-      }
-    } else {
-      REQUIRE(ivr.size() == 0);
-      REQUIRE(fvr.size() == 0);
-      REQUIRE(dvr.size() == 0);
-      REQUIRE(uvr.size() == 0);
-      count++;
-    }
-    ++i;
-  }
-}

From ccb26194cc88a5c1f9a352037caa8cd601a5fb0a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 10 Mar 2025 15:14:53 +0100
Subject: [PATCH 0022/1764] GPU TPC: Fix filtering check (#14032)

---
 .../Global/GPUChainTrackingCompression.cxx            | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 57a759a58924e..03d319f42fd6b 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -201,12 +201,14 @@ int32_t GPUChainTracking::RunTPCCompression()
 
 int32_t GPUChainTracking::RunTPCDecompression()
 {
-  const bool runFullFiltering = GetProcessingSettings().tpcApplyCFCutsAtDecoding || (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0) || (param().tpcCutTimeBin > 0);
-  if (runFullFiltering && !GetProcessingSettings().tpcUseOldCPUDecoding) {
+  const bool needFullFiltering = GetProcessingSettings().tpcApplyCFCutsAtDecoding || (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0);
+  const bool runTimeBinCutFiltering = param().tpcCutTimeBin > 0;
+  if (needFullFiltering && !GetProcessingSettings().tpcUseOldCPUDecoding) {
     GPUFatal("tpcApplyCFCutsAtDecoding, tpcApplyClusterFilterOnCPU and tpcCutTimeBin currently require tpcUseOldCPUDecoding");
   }
 
   if (GetProcessingSettings().tpcUseOldCPUDecoding) {
+    const bool runFiltering = needFullFiltering || runTimeBinCutFiltering;
     const auto& threadContext = GetThreadContext();
     TPCClusterDecompressor decomp;
     auto allocatorFinal = [this](size_t size) {
@@ -219,13 +221,13 @@ int32_t GPUChainTracking::RunTPCDecompression()
       return ((tmpBuffer = std::make_unique<ClusterNative[]>(size))).get();
     };
     auto& decompressTimer = getTimer<TPCClusterDecompressor>("TPCDecompression", 0);
-    auto allocatorUse = runFullFiltering ? std::function<ClusterNative*(size_t)>{allocatorTmp} : std::function<ClusterNative*(size_t)>{allocatorFinal};
+    auto allocatorUse = runFiltering ? std::function<ClusterNative*(size_t)>{allocatorTmp} : std::function<ClusterNative*(size_t)>{allocatorFinal};
     decompressTimer.Start();
     if (decomp.decompress(mIOPtrs.tpcCompressedClusters, *mClusterNativeAccess, allocatorUse, param(), GetProcessingSettings().deterministicGPUReconstruction)) {
       GPUError("Error decompressing clusters");
       return 1;
     }
-    if (runFullFiltering) {
+    if (runFiltering) {
       RunTPCClusterFilter(mClusterNativeAccess.get(), allocatorFinal, GetProcessingSettings().tpcApplyCFCutsAtDecoding);
     }
     decompressTimer.Stop();
@@ -245,7 +247,6 @@ int32_t GPUChainTracking::RunTPCDecompression()
     mRec->PushNonPersistentMemory(qStr2Tag("TPCDCMPR"));
     RecoStep myStep = RecoStep::TPCDecompression;
     bool doGPU = GetRecoStepsGPU() & RecoStep::TPCDecompression;
-    bool runTimeBinCutFiltering = param().tpcCutTimeBin > 0;
     GPUTPCDecompression& Decompressor = processors()->tpcDecompressor;
     GPUTPCDecompression& DecompressorShadow = doGPU ? processorsShadow()->tpcDecompressor : Decompressor;
     const auto& threadContext = GetThreadContext();

From d2bd60f0d78e9f80807f03f740c7baa488068970 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 10 Mar 2025 11:20:34 +0100
Subject: [PATCH 0023/1764] GPU HIP Cmake: Get rid of hipcc, use Clang
 --cuda-device-only instead

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu   | 2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt              | 4 ++--
 GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt   | 6 ++----
 GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip.cxx | 2 +-
 GPU/GPUTracking/cmake/kernel_helpers.cmake           | 2 +-
 5 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index e85a3c3e9e1f3..7fb3744551953 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -28,7 +28,7 @@
 #ifndef __HIPCC__ // CUDA
 #define PER_KERNEL_OBJECT_EXT _fatbin
 #else // HIP
-#define PER_KERNEL_OBJECT_EXT _hip_cxx_o
+#define PER_KERNEL_OBJECT_EXT _hip_o
 #endif
 #define GPUCA_KRNL(x_class, ...) QGET_LD_BINARY_SYMBOLS(GPUCA_M_CAT3(cuda_kernel_module_fatbin_krnl_, GPUCA_M_KRNL_NAME(x_class), PER_KERNEL_OBJECT_EXT))
 #include "GPUReconstructionKernelList.h"
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index f6e420d5b9656..30f6683ff93c5 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -122,7 +122,7 @@ add_custom_target(${MODULE}_HIP_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/
 
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command
-    COMMAND echo -n "${hip_HIPCC_EXECUTABLE} ${GPU_RTC_FLAGS_SEPARATED} ${GPU_RTC_DEFINES} --genco" > ${GPU_RTC_BIN}.command
+    COMMAND echo -n "${CMAKE_HIP_COMPILER} ${GPU_RTC_FLAGS_SEPARATED} ${GPU_RTC_DEFINES} -x hip --cuda-device-only" > ${GPU_RTC_BIN}.command
     COMMAND_EXPAND_LISTS
     VERBATIM
     COMMENT "Preparing HIP RTC command file ${GPU_RTC_BIN}.command"
@@ -159,7 +159,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   install(FILES ${HDRS} DESTINATION include/GPU)
 
 #  o2_add_test(GPUsortHIP NAME test_GPUsortHIP
-#                  SOURCES test/testGPUsortHIP.hip.cxx
+#                  SOURCES test/testGPUsortHIP.hip
 #                  PUBLIC_LINK_LIBRARIES O2::GPUCommon hip::host hip::device hip::hipcub roc::rocthrust
 #                  COMPONENT_NAME GPU
 #                  LABELS gpu)
diff --git a/GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt b/GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt
index 15b72379fdfa7..789333eea9f04 100644
--- a/GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt
@@ -9,7 +9,5 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-add_library(GPUTrackingHIPKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.hip.cxx>, >)
-set(CMAKE_CXX_COMPILER ${hip_HIPCC_EXECUTABLE})
-set(CMAKE_CXX_FLAGS "${GPU_RTC_FLAGS} ${GPU_RTC_FLAGS_ARCH} --genco")
-unset(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER})
+add_library(GPUTrackingHIPKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.hip>, >)
+set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} --cuda-device-only")
diff --git a/GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip.cxx b/GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip.cxx
index 822af77bce48c..ed13124ef65df 100644
--- a/GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip.cxx
+++ b/GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file testGPUsortHIP.hip.cxx
+/// \file testGPUsortHIP.hip
 /// \author Michael Lettrich
 
 #define GPUCA_GPUTYPE_VEGA
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index ff003eca78948..b05fa19785dd8 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -96,7 +96,7 @@ function(o2_gpu_add_kernel kernel_name kernel_files kernel_bounds kernel_type)
   endif()
 
   if(HIP_ENABLED)
-    set(TMP_FILENAMEA "${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${TMP_FILENAME}.hip.cxx")
+    set(TMP_FILENAMEA "${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${TMP_FILENAME}.hip")
     set(O2_GPU_KERNEL_TEMPLATE_REPLACE "${TMP_KERNEL}")
     configure_file(${O2_GPU_BASE_DIR}/Base/hip/GPUReconstructionHIPkernel.template.hip ${TMP_FILENAMEA})
   endif()

From 9607305b9fed276904133fbd2487da73b3b3b41c Mon Sep 17 00:00:00 2001
From: Diego Stocco <dstocco@users.noreply.github.com>
Date: Tue, 11 Mar 2025 09:07:48 +0100
Subject: [PATCH 0024/1764] Add MID local board hardware name in the mapping
 info (#14034)

---
 Detectors/MUON/MID/GlobalMapping/exe/global-mapper.cxx        | 2 ++
 .../include/MIDGlobalMapping/ExtendedMappingInfo.h            | 1 +
 Detectors/MUON/MID/GlobalMapping/src/GlobalMapper.cxx         | 4 ++++
 3 files changed, 7 insertions(+)

diff --git a/Detectors/MUON/MID/GlobalMapping/exe/global-mapper.cxx b/Detectors/MUON/MID/GlobalMapping/exe/global-mapper.cxx
index 0086bf6b4caa5..f8efd6fddb79d 100644
--- a/Detectors/MUON/MID/GlobalMapping/exe/global-mapper.cxx
+++ b/Detectors/MUON/MID/GlobalMapping/exe/global-mapper.cxx
@@ -57,6 +57,8 @@ void stripsInfo2json(const std::vector<o2::mid::ExtendedMappingInfo>& infos, con
     writer.Int(infos[idx].locId);
     writer.Key("locIdDcs");
     writer.String(infos[idx].locIdDcs.c_str());
+    writer.Key("locIdHw");
+    writer.String(infos[idx].locIdHw.c_str());
     writer.EndObject();
   }
   writer.EndArray();
diff --git a/Detectors/MUON/MID/GlobalMapping/include/MIDGlobalMapping/ExtendedMappingInfo.h b/Detectors/MUON/MID/GlobalMapping/include/MIDGlobalMapping/ExtendedMappingInfo.h
index f05b2d6acba1f..1153f75c774ba 100644
--- a/Detectors/MUON/MID/GlobalMapping/include/MIDGlobalMapping/ExtendedMappingInfo.h
+++ b/Detectors/MUON/MID/GlobalMapping/include/MIDGlobalMapping/ExtendedMappingInfo.h
@@ -34,6 +34,7 @@ struct ExtendedMappingInfo {
   int cathode;          ///< Bending (0) or Non-bending (1) planes
   int locId;            ///< Local board ID
   std::string locIdDcs; ///< Local board ID for DCS
+  std::string locIdHw;  /// Local board ID in the hardware
   int xpos;             ///< Position X
   int ypos;             ///< Position Y
   int xwidth;           ///< Width X (signed)
diff --git a/Detectors/MUON/MID/GlobalMapping/src/GlobalMapper.cxx b/Detectors/MUON/MID/GlobalMapping/src/GlobalMapper.cxx
index aebaade01f963..eeb17759197c9 100644
--- a/Detectors/MUON/MID/GlobalMapping/src/GlobalMapper.cxx
+++ b/Detectors/MUON/MID/GlobalMapping/src/GlobalMapper.cxx
@@ -79,7 +79,10 @@ std::array<int, 4> GlobalMapper::getStripGeom(int deId, int columnId, int lineId
 ExtendedMappingInfo GlobalMapper::buildExtendedInfo(int deId, int columnId, int lineId, int stripId, int cathode) const
 {
   ExtendedMappingInfo info;
+  std::array<std::string, 4> boards{"12", "34", "56", "78"};
   info.id = getStripId(deId, columnId, lineId, stripId, cathode);
+  int irpc = detparams::getRPCLine(deId);
+  int iline = (irpc == 5 && columnId == 0) ? lineId - 1 : lineId;
   auto locId = static_cast<int>(mCrateMapper.deLocalBoardToRO(deId, columnId, lineId));
   info.locId = locId;
   std::string side = detparams::isRightSide(deId) ? "R" : "L";
@@ -92,6 +95,7 @@ ExtendedMappingInfo GlobalMapper::buildExtendedInfo(int deId, int columnId, int
   info.stripId = stripId;
   info.cathode = cathode;
   info.locIdDcs = fmt::format("{}{}{}{}", crateId, side, (locInCrate >= 8 ? "1" : "0"), locInCrate);
+  info.locIdHw = fmt::format("{}{}C{}L{}B{}", detparams::getChamber(deId) + 1, side, columnId + 1, irpc + 1, boards[iline]);
   auto geom = getStripGeom(deId, columnId, lineId, stripId, cathode);
   info.xpos = geom[0];
   info.ypos = geom[1];

From 41c8f04218623fc065fe6f85eb7d8f96f215cf33 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 11 Mar 2025 10:15:27 +0100
Subject: [PATCH 0025/1764] Drop need for Framework/RootTableBuilderHelpers.h
 (#14036)

---
 .../src/AODJAlienReaderHelpers.cxx            |   1 -
 Framework/Core/CMakeLists.txt                 |   5 -
 .../Framework/RootTableBuilderHelpers.h       | 233 ------------------
 Framework/Core/src/AODReaderHelpers.cxx       |   1 -
 Framework/Core/src/verifyAODFile.cxx          |  54 ----
 Framework/Core/test/test_Root2ArrowTable.cxx  | 136 ----------
 6 files changed, 430 deletions(-)
 delete mode 100644 Framework/Core/include/Framework/RootTableBuilderHelpers.h
 delete mode 100644 Framework/Core/src/verifyAODFile.cxx

diff --git a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
index f8a9705e4eb62..85ed9cd573d8a 100644
--- a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
@@ -14,7 +14,6 @@
 #include "Framework/TableTreeHelpers.h"
 #include "Framework/AnalysisHelpers.h"
 #include "Framework/DataProcessingStats.h"
-#include "Framework/RootTableBuilderHelpers.h"
 #include "Framework/RootArrowFilesystem.h"
 #include "Framework/AlgorithmSpec.h"
 #include "Framework/ConfigParamRegistry.h"
diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index f059984b5d85d..2691d9d33a0c6 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -328,11 +328,6 @@ o2_add_executable(dpl-run
                   PUBLIC_LINK_LIBRARIES O2::Framework
                   )
 
-o2_add_executable(verify-aod-file
-                  SOURCES src/verifyAODFile.cxx
-                  PUBLIC_LINK_LIBRARIES O2::Framework ROOT::TreePlayer
-                  COMPONENT_NAME Framework)
-
 # benchmarks
 
 foreach(b
diff --git a/Framework/Core/include/Framework/RootTableBuilderHelpers.h b/Framework/Core/include/Framework/RootTableBuilderHelpers.h
deleted file mode 100644
index 0fa818084a5a4..0000000000000
--- a/Framework/Core/include/Framework/RootTableBuilderHelpers.h
+++ /dev/null
@@ -1,233 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef o2_framework_RootTableBuilderHelpers_H_INCLUDED
-#define o2_framework_RootTableBuilderHelpers_H_INCLUDED
-
-#include "Framework/TableBuilder.h"
-#include "Framework/Logger.h"
-
-#include <Rtypes.h>
-#include <arrow/stl.h>
-#include <arrow/type_traits.h>
-#include <arrow/table.h>
-#include <arrow/builder.h>
-
-#include <TTreeReader.h>
-#include <TTreeReaderValue.h>
-#include <TTreeReaderArray.h>
-#include <TBuffer.h>
-#include <TBufferFile.h>
-
-#include <vector>
-#include <string>
-#include <memory>
-#include <tuple>
-
-namespace o2::framework
-{
-
-template <typename T>
-struct TreeReaderValueTraits {
-};
-
-/// Trait class to go from a set of TTreeReaderValues to
-/// arrow types.
-template <typename T>
-struct TreeReaderValueTraits<TTreeReaderValue<T>> {
-  using Type = typename TTreeReaderValue<T>::NonConstT_t;
-  using ArrowType = typename o2::framework::detail::ConversionTraits<Type>::ArrowType;
-  using BuilderType = typename arrow::TypeTraits<ArrowType>::BuilderType;
-};
-
-template <typename VALUE>
-struct TreeReaderValueTraits<TTreeReaderArray<VALUE>> {
-  using Iterator = typename TTreeReaderArray<VALUE>::iterator;
-  using Type = std::pair<Iterator, Iterator>;
-  using ArrowType = arrow::ListType;
-};
-
-static constexpr int PREBUFFER_SIZE = 32 * 1024;
-
-// When reading from a ROOT file special care must happen
-// because uint64_t is platform specific while ULong64_t is
-// always long long unsigned int (same for the signed version).
-// By using this traits we make sure that any 64 bit quantity
-// read from a root file uses the ROOT datatype, not the platform one.
-template <typename T>
-struct Remap64Bit {
-  using type = T;
-};
-
-template <>
-struct Remap64Bit<int64_t> {
-  using type = Long64_t;
-};
-
-template <>
-struct Remap64Bit<uint64_t> {
-  using type = ULong64_t;
-};
-
-template <int N>
-struct Remap64Bit<int64_t[N]> {
-  using type = Long64_t[N];
-};
-
-template <int N>
-struct Remap64Bit<uint64_t[N]> {
-  using type = ULong64_t[N];
-};
-
-template <typename T>
-using Remap64Bit_t = typename Remap64Bit<T>::type;
-
-template <typename T>
-struct ReaderHolder {
-  using Reader = TTreeReaderValue<T>;
-  using Type = T;
-
-  ReaderHolder(TBranch* branch, std::unique_ptr<Reader> reader_)
-    : reader{std::move(reader_)}
-  {
-  }
-
-  ReaderHolder(ReaderHolder&& other)
-    : reader{std::move(other.reader)},
-      pos{other.pos}
-  {
-  }
-
-  ReaderHolder& operator=(ReaderHolder&& other) = delete;
-
-  std::unique_ptr<Reader> reader;
-  int pos = 0;
-  Remap64Bit_t<T> buffer[PREBUFFER_SIZE];
-  int itemSize = sizeof(T);
-};
-
-template <typename T, int N>
-struct ReaderHolder<T[N]> {
-  using Reader = TTreeReaderArray<T>;
-  using Type = T (&)[N];
-
-  ReaderHolder(TBranch* branch, std::unique_ptr<Reader> reader_)
-    : reader{std::move(reader_)}
-  {
-  }
-
-  ReaderHolder(ReaderHolder&& other)
-    : reader{std::move(other.reader)},
-      pos{other.pos}
-  {
-  }
-
-  ReaderHolder& operator=(ReaderHolder&& other) = delete;
-
-  std::unique_ptr<Reader> reader;
-  int pos = 0;
-  Remap64Bit_t<T> buffer[PREBUFFER_SIZE * N];
-  int itemSize = sizeof(T) * N;
-};
-
-struct BulkExtractor {
-  template <typename T>
-  static auto deref(ReaderHolder<T>& holder, size_t maxSize)
-  {
-    holder.buffer[holder.pos % PREBUFFER_SIZE] = **holder.reader;
-    holder.pos++;
-    if (holder.pos == maxSize) {
-      return BulkInfo<Remap64Bit_t<T> const*>{holder.buffer, maxSize % PREBUFFER_SIZE};
-    }
-    // We flush only after PREBUFFER_SIZE items have been inserted
-    if ((holder.pos % PREBUFFER_SIZE) != 0) {
-      return BulkInfo<Remap64Bit_t<T> const*>{nullptr, 0};
-    }
-    return BulkInfo<Remap64Bit_t<T> const*>{holder.buffer, PREBUFFER_SIZE};
-  }
-
-  template <typename T, int N>
-  static auto deref(ReaderHolder<T[N]>& holder, size_t maxSize)
-  {
-    memcpy(&holder.buffer[(holder.pos % PREBUFFER_SIZE) * N], &((*holder.reader)[0]), N * sizeof(T));
-    holder.pos++;
-    if (holder.pos == maxSize) {
-      return BulkInfo<Remap64Bit_t<T> const*>{holder.buffer, maxSize % PREBUFFER_SIZE};
-    }
-    // We flush only after PREBUFFER_SIZE items have been inserted
-    if ((holder.pos % PREBUFFER_SIZE) != 0) {
-      return BulkInfo<Remap64Bit_t<T> const*>{nullptr, 0};
-    }
-    return BulkInfo<Remap64Bit_t<T> const*>{reinterpret_cast<T const*>(holder.buffer), PREBUFFER_SIZE};
-  }
-};
-
-template <typename T>
-struct HolderMaker {
-  static auto make(TTreeReader& reader, char const* branchName)
-  {
-    using Reader = TTreeReaderValue<T>;
-    return ReaderHolder<T>{reader.GetTree()->GetBranch(branchName), std::move(std::make_unique<Reader>(reader, branchName))};
-  }
-};
-
-template <typename T, int N>
-struct HolderMaker<T[N]> {
-  static auto make(TTreeReader& reader, char const* branchName)
-  {
-    using Reader = TTreeReaderArray<T>;
-    return ReaderHolder<T[N]>{reader.GetTree()->GetBranch(branchName), std::move(std::make_unique<Reader>(reader, branchName))};
-  }
-};
-
-template <typename C>
-struct ColumnReaderTrait {
-  static auto createReader(TTreeReader& reader)
-  {
-    return HolderMaker<Remap64Bit_t<typename C::type>>::make(reader, C::base::columnLabel());
-  }
-};
-
-struct RootTableBuilderHelpers {
-  /// Use bulk insertion when TTreeReaderValue everywhere
-  template <typename... T>
-  static void convertTTree(TableBuilder& builder,
-                           TTreeReader& reader,
-                           ReaderHolder<T>... holders)
-  {
-    std::array<char const*, sizeof...(T)> branchNames = {holders.reader->GetBranchName()...};
-    TTree* tree = reader.GetTree();
-    size_t maxExtries = reader.GetEntries(true);
-    tree->SetCacheSize(maxExtries * (holders.itemSize + ...));
-    (tree->AddBranchToCache(tree->GetBranch(holders.reader->GetBranchName()), true), ...);
-    tree->StopCacheLearningPhase();
-
-    auto filler = builder.bulkPersistChunked<Remap64Bit_t<typename std::decay_t<decltype(holders)>::Type>...>(branchNames, maxExtries);
-    while (reader.Next()) {
-      filler(0, BulkExtractor::deref(holders, maxExtries)...);
-    }
-  }
-
-  template <typename... C>
-  static void convertASoAColumns(TableBuilder& builder, TTreeReader& reader, pack<C...>)
-  {
-    return convertTTree(builder, reader, ColumnReaderTrait<C>::createReader(reader)...);
-  }
-
-  template <typename T>
-  static void convertASoA(TableBuilder& builder, TTreeReader& reader)
-  {
-    return convertASoAColumns(builder, reader, typename T::persistent_columns_t{});
-  }
-};
-
-} // namespace o2
-#endif // FRAMEWORK_ROOTTABLEBUILDERHELPERS_H
diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index f6513b5facea3..6270d07a022e8 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -15,7 +15,6 @@
 #include "Framework/AnalysisDataModelHelpers.h"
 #include "Framework/DataProcessingHelpers.h"
 #include "Framework/ExpressionHelpers.h"
-#include "Framework/RootTableBuilderHelpers.h"
 #include "Framework/AlgorithmSpec.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/ControlService.h"
diff --git a/Framework/Core/src/verifyAODFile.cxx b/Framework/Core/src/verifyAODFile.cxx
deleted file mode 100644
index 2660019031946..0000000000000
--- a/Framework/Core/src/verifyAODFile.cxx
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "Framework/AnalysisDataModel.h"
-#include "Framework/RootTableBuilderHelpers.h"
-#include "Framework/Logger.h"
-#include "Framework/ASoA.h"
-#include <TFile.h>
-#include <iostream>
-#include <memory>
-
-using namespace o2::framework;
-using namespace o2::soa;
-
-template <typename T>
-void verifyTable(TFile* infile, const char* branchName)
-{
-  std::cout << "Table: " << o2::aod::label<T::ref>() << std::endl;
-  std::unique_ptr<TTreeReader> reader = std::make_unique<TTreeReader>(branchName, infile);
-  TableBuilder builder;
-  RootTableBuilderHelpers::convertASoA<T>(builder, *reader);
-  auto table = builder.finalize();
-  std::cout << table->schema()->ToString() << std::endl;
-  std::cout << "---" << std::endl;
-}
-
-int main(int argc, char** argv)
-{
-  if (argc != 2) {
-    LOG(error) << "Bad number of arguments";
-    return 1;
-  }
-  auto infile = std::make_unique<TFile>(argv[1]);
-  if (infile.get() == nullptr || infile->IsOpen() == false) {
-    LOG(error) << "File not found: " << argv[1];
-    return 1;
-  }
-
-  verifyTable<o2::aod::Collisions>(infile.get(), "O2collision");
-  verifyTable<o2::aod::StoredTracks>(infile.get(), "O2track");
-  verifyTable<o2::aod::StoredTracksCov>(infile.get(), "O2track");
-  verifyTable<o2::aod::StoredTracksExtra>(infile.get(), "O2track");
-  verifyTable<o2::aod::Calos>(infile.get(), "O2calo");
-  verifyTable<o2::aod::StoredFwdTracks>(infile.get(), "O2fwdtrack");
-  return 0;
-}
diff --git a/Framework/Core/test/test_Root2ArrowTable.cxx b/Framework/Core/test/test_Root2ArrowTable.cxx
index 663be91a1e6f3..395048ae916d6 100644
--- a/Framework/Core/test/test_Root2ArrowTable.cxx
+++ b/Framework/Core/test/test_Root2ArrowTable.cxx
@@ -12,7 +12,6 @@
 #include <catch_amalgamated.hpp>
 
 #include "Framework/TableBuilder.h"
-#include "Framework/RootTableBuilderHelpers.h"
 #include "Framework/ASoA.h"
 #include "Framework/PluginManager.h"
 #include "../src/ArrowDebugHelpers.h"
@@ -50,87 +49,6 @@
 
 using namespace o2::framework;
 
-TEST_CASE("RootTree2Table")
-{
-  using namespace o2::framework;
-  /// Create a simple TTree
-  TTree t1("t1", "a simple Tree with simple variables");
-  Float_t xyz[3];
-  Int_t ij[2];
-  Float_t px, py, pz;
-  Double_t random;
-  Int_t ev;
-  t1.Branch("px", &px, "px/F");
-  t1.Branch("py", &py, "py/F");
-  t1.Branch("pz", &pz, "pz/F");
-  t1.Branch("random", &random, "random/D");
-  t1.Branch("ev", &ev, "ev/I");
-  t1.Branch("xyz", xyz, "xyz[3]/F");
-  t1.Branch("ij", ij, "ij[2]/I");
-  // fill the tree
-  for (Int_t i = 0; i < 1000; i++) {
-    xyz[0] = 1;
-    xyz[1] = 2;
-    xyz[2] = 3;
-    gRandom->Rannor(px, py);
-    pz = px * px + py * py;
-    xyz[2] = i + 1;
-    ij[0] = i;
-    ij[1] = i + 1;
-    random = gRandom->Rndm();
-    ev = i + 1;
-    t1.Fill();
-  }
-
-  // Create an arrow table from this.
-  TableBuilder builder;
-  TTreeReader reader(&t1);
-  auto&& xyzReader = HolderMaker<float[3]>::make(reader, "xyz");
-  auto&& ijkReader = HolderMaker<int[2]>::make(reader, "ij");
-  auto&& pxReader = HolderMaker<float>::make(reader, "px");
-  auto&& pyReader = HolderMaker<float>::make(reader, "py");
-  auto&& pzReader = HolderMaker<float>::make(reader, "pz");
-  auto&& randomReader = HolderMaker<double>::make(reader, "random");
-  auto&& evReader = HolderMaker<int>::make(reader, "ev");
-
-  RootTableBuilderHelpers::convertTTree(builder, reader, std::move(xyzReader), std::move(ijkReader), std::move(pxReader), std::move(pyReader), std::move(pzReader), std::move(randomReader), std::move(evReader));
-  auto table = builder.finalize();
-  REQUIRE(table->num_rows() == 1000);
-  REQUIRE(table->num_columns() == 7);
-  REQUIRE(table->schema()->field(0)->type()->id() == arrow::fixed_size_list(arrow::float32(), 3)->id());
-  REQUIRE(table->schema()->field(1)->type()->id() == arrow::fixed_size_list(arrow::int32(), 2)->id());
-  REQUIRE(table->schema()->field(2)->type()->id() == arrow::float32()->id());
-  REQUIRE(table->schema()->field(3)->type()->id() == arrow::float32()->id());
-  REQUIRE(table->schema()->field(4)->type()->id() == arrow::float32()->id());
-  REQUIRE(table->schema()->field(5)->type()->id() == arrow::float64()->id());
-  REQUIRE(table->schema()->field(6)->type()->id() == arrow::int32()->id());
-
-  {
-    auto chunkToUse = table->column(0)->chunk(0);
-    chunkToUse = std::dynamic_pointer_cast<arrow::FixedSizeListArray>(chunkToUse)->values();
-    auto array = std::static_pointer_cast<arrow::FloatArray>(chunkToUse);
-    // array of 3 floats, time 1000.
-    REQUIRE(array->length() == 3000);
-    const float* c = reinterpret_cast<float const*>(array->values()->data());
-
-    CHECK(c[0] == 1);
-    CHECK(c[1] == 2);
-    CHECK(c[2] == 1);
-  }
-  {
-    auto chunkToUse = table->column(1)->chunk(0);
-    chunkToUse = std::dynamic_pointer_cast<arrow::FixedSizeListArray>(chunkToUse)->values();
-    auto array = std::static_pointer_cast<arrow::Int32Array>(chunkToUse);
-    REQUIRE(array->length() == 2000);
-
-    const int* ptr = reinterpret_cast<int const*>(array->values()->data());
-    for (size_t i = 0; i < 1000; i++) {
-      CHECK(ptr[2 * i + 0] == i);
-      CHECK(ptr[2 * i + 1] == i + 1);
-    }
-  }
-}
-
 namespace o2::aod
 {
 namespace test
@@ -149,60 +67,6 @@ DECLARE_SOA_TABLE(Test, "AOD", "ETAPHI",
                   test::Random, test::Ev);
 } // namespace o2::aod
 
-TEST_CASE("RootTree2TableViaASoA")
-{
-  using namespace o2::framework;
-  /// Create a simple TTree
-  TTree t2("t2", "a simple Tree with simple variables");
-  Float_t xyz[3];
-  Int_t ij[2];
-  Float_t px, py, pz;
-  Double_t random;
-  Int_t ev;
-  t2.Branch("px", &px, "px/F");
-  t2.Branch("py", &py, "py/F");
-  t2.Branch("pz", &pz, "pz/F");
-  t2.Branch("random", &random, "random/D");
-  t2.Branch("ev", &ev, "ev/I");
-  t2.Branch("xyz", xyz, "xyz[3]/F");
-  t2.Branch("ij", ij, "ij[2]/I");
-  // fill the tree
-  for (Int_t i = 0; i < 1000; i++) {
-    gRandom->Rannor(xyz[0], xyz[1]);
-    gRandom->Rannor(px, py);
-    pz = px * px + py * py;
-    xyz[2] = i + 1;
-    ij[0] = i;
-    ij[1] = i + 1;
-    random = gRandom->Rndm();
-    ev = i + 1;
-    t2.Fill();
-  }
-
-  // Create an arrow table from this.
-  TableBuilder builder;
-  TTreeReader reader(&t2);
-  REQUIRE(t2.GetEntries() == 1000);
-
-  RootTableBuilderHelpers::convertASoA<o2::aod::Test>(builder, reader);
-  auto table = builder.finalize();
-  REQUIRE(table->num_rows() == 1000);
-  REQUIRE(table->num_columns() == 7);
-  REQUIRE(table->column(0)->type()->id() == arrow::float32()->id());
-  REQUIRE(table->column(1)->type()->id() == arrow::float32()->id());
-  REQUIRE(table->column(2)->type()->id() == arrow::float32()->id());
-  REQUIRE(table->column(3)->type()->id() == arrow::fixed_size_list(arrow::float32(), 3)->id());
-  REQUIRE(table->column(4)->type()->id() == arrow::fixed_size_list(arrow::int32(), 2)->id());
-  REQUIRE(table->column(5)->type()->id() == arrow::float64()->id());
-  REQUIRE(table->column(6)->type()->id() == arrow::int32()->id());
-
-  o2::aod::Test testTable{table};
-  for (auto& row : testTable) {
-    REQUIRE(row.ij()[0] == row.ij()[1] - 1);
-    REQUIRE(row.ij()[1] == row.ev());
-  }
-}
-
 TEST_CASE("RootTree2Fragment")
 {
   using namespace o2::framework;

From 83bcaaadc6bd8378afb18db7f56d11812b60060c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 11 Mar 2025 12:55:37 +0100
Subject: [PATCH 0026/1764] DPL: provide defaults for inputs and outputs
 (#14038)

Silence a bunch of warnings when using aggregate initialization.
---
 Framework/Core/include/Framework/DataProcessorSpec.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/DataProcessorSpec.h b/Framework/Core/include/Framework/DataProcessorSpec.h
index fafb7fda43ce3..9821a2561d08b 100644
--- a/Framework/Core/include/Framework/DataProcessorSpec.h
+++ b/Framework/Core/include/Framework/DataProcessorSpec.h
@@ -40,8 +40,8 @@ struct DataProcessorMetadata {
 
 struct DataProcessorSpec {
   std::string name;
-  Inputs inputs;
-  Outputs outputs;
+  Inputs inputs = {};
+  Outputs outputs = {};
   AlgorithmSpec algorithm;
 
   Options options = {};

From a8f75744fd7d4078a834ff71891cf306937c8c86 Mon Sep 17 00:00:00 2001
From: Sergio Garcia <47090312+singiamtel@users.noreply.github.com>
Date: Tue, 11 Mar 2025 13:43:03 +0100
Subject: [PATCH 0027/1764] Bump actions version (#14017)

> Error: This request has been automatically failed because it uses a deprecated version of `actions/cache: v2`. Please update your workflow to use v3/v4 of actions/cache to avoid interruptions
---
 .github/workflows/reports.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/reports.yml b/.github/workflows/reports.yml
index 0762debd04d54..cadb920fa022f 100644
--- a/.github/workflows/reports.yml
+++ b/.github/workflows/reports.yml
@@ -17,12 +17,12 @@ jobs:
     if: github.repository == 'AliceO2Group/AliceO2'
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
     - name: Set up Python 3.10
       uses: actions/setup-python@v5
       with:
         python-version: '3.10'
-    - uses: actions/cache@v2
+    - uses: actions/cache@v4
       name: Configure pip caching
       with:
         path: ~/.cache/pip

From 48c7605979462cfeed6a3944133a755cd0f5ca44 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 11 Mar 2025 17:14:30 +0100
Subject: [PATCH 0028/1764] DPL Analysis: improve error message when messages
 are malformed (#14040)

---
 Framework/AnalysisSupport/src/AODWriterHelpers.cxx | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index fa10d4661f537..2b1b4f880d1ee 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -274,19 +274,20 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
         LOG(error) << "Header not found";
         return;
       }
-      if (!ref.payload) {
-        LOG(error) << "Payload not found";
-        return;
-      }
       auto datah = o2::header::get<o2::header::DataHeader*>(ref.header);
       if (!datah) {
         LOG(error) << "No data header in stack";
         return;
       }
 
+      if (!ref.payload) {
+        LOGP(error, "Payload not found for {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
+        return;
+      }
+
       auto objh = o2::header::get<o2::framework::OutputObjHeader*>(ref.header);
       if (!objh) {
-        LOG(error) << "No output object header in stack";
+        LOGP(error, "No output object header in stack of {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
         return;
       }
 
@@ -297,7 +298,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
       tm.SetBufferOffset(0);
       tm.ResetMap();
       if (obj.kind == nullptr) {
-        LOG(error) << "Cannot read class info from buffer.";
+        LOGP(error, "Cannot read class info from buffer of {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
         return;
       }
 

From cfa7b71004811813df8cf27450047d7e427bc1a9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 11 Mar 2025 15:00:18 +0100
Subject: [PATCH 0029/1764] dpl-workflow: Automatically apply MI100 workaround
 in sync

---
 prodtests/full-system-test/dpl-workflow.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 0f5083dbcdebb..f9b0c7accbff9 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -259,7 +259,8 @@ if [[ $GPUTYPE == "HIP" ]]; then
     TIMESLICEOFFSET=$(($GPU_FIRST_ID + ($NUMAGPUIDS != 0 ? ($NGPUS * $NUMAID) : 0)))
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
-  [[ "${EPN_NODE_MI100:-}" != "1" ]] && export HSA_NO_SCRATCH_RECLAIM=1
+  [[ ${EPN_NODE_MI100:-} != "1" ]] && export HSA_NO_SCRATCH_RECLAIM=1
+  [[ $EPNSYNCMODE == 1 && ${EPN_NODE_MI100:-} == "1" ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else
   GPU_CONFIG_KEY+="GPU_proc.deviceNum=-2;"

From fc1fd7b0174cb3821c8c9616474e696f0cd30dde Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 11 Mar 2025 13:51:52 +0100
Subject: [PATCH 0030/1764] Fix scaling ITS CA tracker params for low Bfield

---
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx | 4 +---
 GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx             | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index f625b77a013b0..cbb31ff8bceb7 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -120,17 +120,15 @@ void ITSTrackingInterface::initialise()
   for (auto& params : trackParams) {
     params.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT;
   }
-
   // adjust pT settings to actual mag. field
   for (size_t ip = 0; ip < trackParams.size(); ip++) {
     auto& param = trackParams[ip];
+    param.TrackletMinPt *= bFactor;
     for (int ilg = trackConf.MaxTrackLenght; ilg >= trackConf.MinTrackLenght; ilg--) {
       int lslot = trackConf.MaxTrackLenght - ilg;
       param.MinPt[lslot] *= bFactor;
-      param.TrackletMinPt *= bFactor;
     }
   }
-
   mTracker->setParameters(trackParams);
   mVertexer->setParameters(vertParams);
 }
diff --git a/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx b/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
index b81e816d6fc1d..1601e11f2c6fa 100644
--- a/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
+++ b/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
@@ -22,7 +22,7 @@
 #include "ITStracking/Cell.h"
 #include "CommonConstants/MathConstants.h"
 
-#ifdef CA_DEBUG
+#if defined(CA_DEBUG) && !defined(GPUCA_GPUCODE_DEVICE)
 #include <cstdio>
 #endif
 

From c5209b138c1f44fc5cb374d3538eb732506bbdc7 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 11 Mar 2025 16:12:57 +0100
Subject: [PATCH 0031/1764] Do not fetch meta-data object unless reading
 explicit ccdb snapshot file

---
 CCDB/include/CCDB/CcdbApi.h | 2 +-
 CCDB/src/CcdbApi.cxx        | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/CCDB/include/CCDB/CcdbApi.h b/CCDB/include/CCDB/CcdbApi.h
index 5ad56fbd50557..1308742b57fd0 100644
--- a/CCDB/include/CCDB/CcdbApi.h
+++ b/CCDB/include/CCDB/CcdbApi.h
@@ -388,7 +388,7 @@ class CcdbApi //: public DatabaseInterface
   static bool removeSemaphore(std::string const& name, bool remove = false);
   static void removeLeakingSemaphores(std::string const& basedir, bool remove = false);
 
-  void loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders = nullptr) const;
+  void loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders = nullptr, bool fetchLocalMetaData = true) const;
   void loadFileToMemory(o2::pmr::vector<char>& dest, std::string const& path,
                         std::map<std::string, std::string> const& metadata, long timestamp,
                         std::map<std::string, std::string>* headers, std::string const& etag,
diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index 2906438211c65..c9d2fad882aa1 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -1989,7 +1989,7 @@ bool CcdbApi::loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string&
 {
   if (url.find("alien:/", 0) != std::string::npos) {
     std::map<std::string, std::string> localHeaders;
-    loadFileToMemory(dest, url, &localHeaders);
+    loadFileToMemory(dest, url, &localHeaders, false);
     auto it = localHeaders.find("Error");
     if (it != localHeaders.end() && it->second == "An error occurred during retrieval") {
       return false;
@@ -2001,7 +2001,7 @@ bool CcdbApi::loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string&
     std::string path = url.substr(7);
     if (std::filesystem::exists(path)) {
       std::map<std::string, std::string> localHeaders;
-      loadFileToMemory(dest, url, &localHeaders);
+      loadFileToMemory(dest, url, &localHeaders, o2::utils::Str::endsWith(path, ".root"));
       auto it = localHeaders.find("Error");
       if (it != localHeaders.end() && it->second == "An error occurred during retrieval") {
         return false;
@@ -2013,7 +2013,7 @@ bool CcdbApi::loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string&
   return false;
 }
 
-void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders) const
+void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders, bool fetchLocalMetaData) const
 {
   // Read file to memory as vector. For special case of the locally cached file retriev metadata stored directly in the file
   constexpr size_t MaxCopySize = 0x1L << 25;
@@ -2061,7 +2061,7 @@ void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& p
     totalread += nread;
   } while (nread == (long)MaxCopySize);
 
-  if (localHeaders) {
+  if (localHeaders && fetchLocalMetaData) {
     TMemFile memFile("name", const_cast<char*>(dest.data()), dest.size(), "READ");
     auto storedmeta = (std::map<std::string, std::string>*)extractFromTFile(memFile, TClass::GetClass("std::map<std::string, std::string>"), CCDBMETA_ENTRY);
     if (storedmeta) {

From ce065f9788b822d83f3154613b5bd9aa41ada987 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 08:58:07 +0100
Subject: [PATCH 0032/1764] GPU: Add IsNaN to CAMath

---
 GPU/Common/GPUCommonMath.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index 9aa260f59842f..ef837658f74d1 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -82,6 +82,7 @@ class GPUCommonMath
   GPUd() static int32_t Float2IntRn(float x);
   GPUd() static float Modf(float x, float y);
   GPUd() static bool Finite(float x);
+  GPUd() static bool IsNaN(float x);
   GPUd() static uint32_t Clz(uint32_t val);
   GPUd() static uint32_t Popcount(uint32_t val);
 
@@ -224,7 +225,8 @@ GPUdi() float GPUCommonMath::Floor(float x) { return CHOICE(floorf(x), floorf(x)
 #ifdef GPUCA_NO_FAST_MATH
 GPUdi() float GPUCommonMath::Round(float x) { return CHOICE(roundf(x), roundf(x), round(x)); }
 GPUdi() int32_t GPUCommonMath::Float2IntRn(float x) { return (int32_t)Round(x); }
-GPUdi() bool GPUCommonMath::Finite(float x) { return CHOICE(std::isfinite(x), isfinite(x), true); }
+GPUdi() bool GPUCommonMath::Finite(float x) { return CHOICE(std::isfinite(x), isfinite(x), true); } // Fixme: fix these 2 for OpenCL
+GPUdi() bool GPUCommonMath::IsNaN(float x) { return CHOICE(std::isnan(x), isnan(x), false); }
 GPUhdi() float GPUCommonMath::Sqrt(float x) { return CHOICE(sqrtf(x), (float)sqrt((double)x), sqrt(x)); }
 GPUdi() float GPUCommonMath::ATan(float x) { return CHOICE((float)atan((double)x), (float)atan((double)x), atan(x)); }
 GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return CHOICE((float)atan2((double)y, (double)x), (float)atan2((double)y, (double)x), atan2(y, x)); }

From 8b6b16c6e9b861066c7607dde33663ff881187c7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 11:36:06 +0100
Subject: [PATCH 0033/1764] GPU Math: Add memcpy and QuietNaN, fix Finite and
 IsNaN

---
 GPU/Common/GPUCommonMath.h | 34 +++++++++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index ef837658f74d1..5a813b74ed7b6 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -25,6 +25,8 @@
 #include <cmath>
 #include <algorithm>
 #include <atomic>
+#include <limits>
+#include <cstring>
 #endif
 
 #if !defined(GPUCA_GPUCODE_COMPILEKERNELS) && (!defined(GPUCA_GPUCODE_DEVICE) || defined(__CUDACC__) || defined(__HIPCC__))
@@ -83,9 +85,14 @@ class GPUCommonMath
   GPUd() static float Modf(float x, float y);
   GPUd() static bool Finite(float x);
   GPUd() static bool IsNaN(float x);
+  GPUd() static bool FiniteRelaxed(float x); // always true if not using NO_FAST_MATH
+  GPUd() static bool IsNaNRelaxed(float x);  // always true if not using NO_FAST_MATH
+  GPUd() static float QuietNaN();
   GPUd() static uint32_t Clz(uint32_t val);
   GPUd() static uint32_t Popcount(uint32_t val);
 
+  GPUd() static void memcpy(void* dst, const void* src, size_t size);
+
   GPUhdni() static float Hypot(float x, float y);
   GPUhdni() static float Hypot(float x, float y, float z);
   GPUhdni() static float Hypot(float x, float y, float z, float w);
@@ -181,6 +188,23 @@ typedef GPUCommonMath CAMath;
     #define CHOICE(c1, c2, c3) (c1) // Select first option for Host
 #endif // clang-format on
 
+GPUdi() void GPUCommonMath::memcpy(void* dst, const void* src, size_t size)
+{
+#ifndef GPUCA_GPUCODE_DEVICE
+  std::memcpy(dst, src, size);
+#elif defined(__CUDACC__) || defined(__HIPCC__)
+  ::memcpy(dst, src, size);
+#elif defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
+  __builtin_memcpy(dst, src, size);
+#else
+  char* d = (char*)dst;
+  const char* s = (const char*)src;
+  for (size_t i = 0; i < size; i++) {
+    d[i] = s[i];
+  }
+#endif
+}
+
 template <int32_t I, class T>
 GPUdi() constexpr T GPUCommonMath::nextMultipleOf(T val)
 {
@@ -222,11 +246,12 @@ GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
 GPUdi() uint32_t GPUCommonMath::Float2UIntRn(float x) { return (uint32_t)(int32_t)(x + 0.5f); }
 GPUdi() float GPUCommonMath::Floor(float x) { return CHOICE(floorf(x), floorf(x), floor(x)); }
 
+GPUdi() bool GPUCommonMath::Finite(float x) { return CHOICE(std::isfinite(x), isfinite(x), isfinite(x)); }
+GPUdi() bool GPUCommonMath::IsNaN(float x) { return CHOICE(std::isnan(x), isnan(x), isnan(x)); }
+GPUdi() float GPUCommonMath::QuietNaN() { return CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
 #ifdef GPUCA_NO_FAST_MATH
 GPUdi() float GPUCommonMath::Round(float x) { return CHOICE(roundf(x), roundf(x), round(x)); }
 GPUdi() int32_t GPUCommonMath::Float2IntRn(float x) { return (int32_t)Round(x); }
-GPUdi() bool GPUCommonMath::Finite(float x) { return CHOICE(std::isfinite(x), isfinite(x), true); } // Fixme: fix these 2 for OpenCL
-GPUdi() bool GPUCommonMath::IsNaN(float x) { return CHOICE(std::isnan(x), isnan(x), false); }
 GPUhdi() float GPUCommonMath::Sqrt(float x) { return CHOICE(sqrtf(x), (float)sqrt((double)x), sqrt(x)); }
 GPUdi() float GPUCommonMath::ATan(float x) { return CHOICE((float)atan((double)x), (float)atan((double)x), atan(x)); }
 GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return CHOICE((float)atan2((double)y, (double)x), (float)atan2((double)y, (double)x), atan2(y, x)); }
@@ -238,10 +263,11 @@ GPUdi() float GPUCommonMath::ASin(float x) { return CHOICE((float)asin((double)x
 GPUdi() float GPUCommonMath::ACos(float x) { return CHOICE((float)acos((double)x), (float)acos((double)x), acos(x)); }
 GPUdi() float GPUCommonMath::Log(float x) { return CHOICE((float)log((double)x), (float)log((double)x), log(x)); }
 GPUdi() float GPUCommonMath::Exp(float x) { return CHOICE((float)exp((double)x), (float)exp((double)x), exp(x)); }
+GPUdi() bool GPUCommonMath::FiniteRelaxed(float x) { return Finite(x); }
+GPUdi() bool GPUCommonMath::IsNaNRelaxed(float x) { return IsNaN(x); }
 #else
 GPUdi() float GPUCommonMath::Round(float x) { return CHOICE(roundf(x), rintf(x), rint(x)); }
 GPUdi() int32_t GPUCommonMath::Float2IntRn(float x) { return CHOICE((int32_t)Round(x), __float2int_rn(x), (int32_t)Round(x)); }
-GPUdi() bool GPUCommonMath::Finite(float x) { return CHOICE(std::isfinite(x), true, true); }
 GPUhdi() float GPUCommonMath::Sqrt(float x) { return CHOICE(sqrtf(x), sqrtf(x), sqrt(x)); }
 GPUdi() float GPUCommonMath::ATan(float x) { return CHOICE(atanf(x), atanf(x), atan(x)); }
 GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return CHOICE(atan2f(y, x), atan2f(y, x), atan2(y, x)); }
@@ -253,6 +279,8 @@ GPUdi() float GPUCommonMath::ASin(float x) { return CHOICE(asinf(x), asinf(x), a
 GPUdi() float GPUCommonMath::ACos(float x) { return CHOICE(acosf(x), acosf(x), acos(x)); }
 GPUdi() float GPUCommonMath::Log(float x) { return CHOICE(logf(x), logf(x), log(x)); }
 GPUdi() float GPUCommonMath::Exp(float x) { return CHOICE(expf(x), expf(x), exp(x)); }
+GPUdi() bool GPUCommonMath::FiniteRelaxed(float x) { return true; }
+GPUdi() bool GPUCommonMath::IsNaNRelaxed(float x) { return false; }
 #endif
 
 GPUhdi() void GPUCommonMath::SinCos(float x, float& s, float& c)

From 2dbd7f888467d52b54ebc8d24c4826f495d85440 Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Wed, 12 Mar 2025 13:31:58 +0100
Subject: [PATCH 0034/1764] Ctpdev (#14037)

* dev: ctp config to BK and first orbit and orbit reset via zmq

* clang
---
 .../include/CTPWorkflowScalers/RunManager.h   |  2 +-
 .../CTPWorkflowScalers/ctpCCDBManager.h       | 13 ++--
 .../CTP/workflowScalers/src/RunManager.cxx    | 37 ++++++++----
 .../workflowScalers/src/ctpCCDBManager.cxx    | 59 +++++++++++++++++++
 4 files changed, 94 insertions(+), 17 deletions(-)

diff --git a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
index 0d624ecd8b892..e0b204e6c4ce5 100644
--- a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
+++ b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
@@ -47,7 +47,7 @@ class CTPRunManager : public ctpCCDBManager
   CTPRunManager() = default;
   void init();
   int loadRun(const std::string& cfg);
-  int startRun(const std::string& cfg);
+  int setRunConfigBK(uint32_t runNumber, const std::string& cfg);
   int stopRun(uint32_t irun, long timeStamp);
   int addScalers(uint32_t irun, std::time_t time, bool start = 0);
   int processMessage(std::string& topic, const std::string& message);
diff --git a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
index 5fb6d3678f0ba..c968a83183624 100644
--- a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
+++ b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
@@ -27,12 +27,11 @@ class ctpCCDBManager
   int saveRunScalersToCCDB(CTPRunScalers& scalers, long timeStart, long timeStop);
   int saveRunScalersToQCDB(CTPRunScalers& scalers, long timeStart, long timeStop);
   int saveRunConfigToCCDB(CTPConfiguration* cfg, long timeStart);
+  int saveSoxOrbit(uint32_t runNumber, uint32_t soxOrbit, long timeStart);
+  int saveOrbitReset(long timeStamp);
   static CTPConfiguration getConfigFromCCDB(long timestamp, std::string run, bool& ok);
   static CTPConfiguration getConfigFromCCDB(long timestamp, std::string run);
   CTPRunScalers getScalersFromCCDB(long timestamp, std::string, bool& ok);
-  void setCCDBPathConfig(std::string path) { mCCDBPathCTPConfig = path; };
-  void setCCDBPathScalers(std::string path) { mCCDBPathCTPScalers = path; };
-  void setQCDBPathScalers(std::string path) { mQCDBPathCTPScalers = path; };
   static void setCCDBHost(std::string host) { mCCDBHost = host; };
   static void setQCDBHost(std::string host) { mQCDBHost = host; };
 
@@ -42,9 +41,11 @@ class ctpCCDBManager
   // std::string mQCDBHost = "http://ali-qcdb.cern.ch:8083";
   static std::string mCCDBHost;
   static std::string mQCDBHost;
-  std::string mCCDBPathCTPScalers = "CTP/Calib/Scalers";
-  std::string mCCDBPathCTPConfig = "CTP/Config/Config";
-  std::string mQCDBPathCTPScalers = "qc/CTP/Scalers";
+  const std::string mCCDBPathCTPScalers = "CTP/Calib/Scalers";
+  // std::string mCCDBPathCTPConfig = "CTP/Config/Config";  - in Configuration.h
+  const std::string mQCDBPathCTPScalers = "qc/CTP/Scalers";
+  const std::string mCCDBPathSoxOrbit = "CTP/Calib/FirstRunOrbit";
+  const std::string mCCDBPathOrbitReset = "CTP/Calib/OrbitReset";
   ClassDefNV(ctpCCDBManager, 1);
 };
 } // namespace ctp
diff --git a/Detectors/CTP/workflowScalers/src/RunManager.cxx b/Detectors/CTP/workflowScalers/src/RunManager.cxx
index e6861e6cb4b38..9af5b5e104120 100644
--- a/Detectors/CTP/workflowScalers/src/RunManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/RunManager.cxx
@@ -57,7 +57,7 @@ int CTPActiveRun::send2BK(std::unique_ptr<BkpClient>& BKClient, size_t ts, bool
     std::string clsname = cfg.getClassNameFromHWIndex(cls.first);
     // clsname = std::to_string(runOri) + "_" + clsname;
     try {
-      BKClient->triggerCounters()->createOrUpdateForRun(runNumber, clsname, ts, cntsbk[0], cntsbk[1], cntsbk[2], cntsbk[3], cntsbk[4], cntsbk[5]);
+      BKClient->ctpTriggerCounters()->createOrUpdateForRun(runNumber, clsname, ts, cntsbk[0], cntsbk[1], cntsbk[2], cntsbk[3], cntsbk[4], cntsbk[5]);
     } catch (std::runtime_error& error) {
       std::cerr << "An error occurred: " << error.what() << std::endl;
       return 1;
@@ -124,8 +124,19 @@ int CTPRunManager::loadRun(const std::string& cfg)
 
   return 0;
 }
-int CTPRunManager::startRun(const std::string& cfg)
+int CTPRunManager::setRunConfigBK(uint32_t runNumber, const std::string& cfg)
 {
+  std::cout << "Printing cfg:" << cfg << std::endl;
+  if (mBKClient) {
+    try {
+      uint32_t runNumber = 1;
+      mBKClient->run()->setRawCtpTriggerConfiguration(runNumber, cfg);
+    } catch (std::runtime_error& error) {
+      std::cerr << "An error occurred: " << error.what() << std::endl;
+      return 1;
+    }
+    LOG(info) << "Run BK:" << runNumber << " CFG:" << cfg;
+  }
   return 0;
 }
 int CTPRunManager::stopRun(uint32_t irun, long timeStamp)
@@ -221,6 +232,13 @@ int CTPRunManager::processMessage(std::string& topic, const std::string& message
     loadRun(message);
     return 0;
   }
+  if (topic.find("soxorbit") != std::string::npos) {
+    return 0;
+  }
+  if (topic.find("orbitreset") != std::string::npos) {
+    return 0;
+  }
+  static int nerror = 0;
   if (topic.find("sox") != std::string::npos) {
     // get config
     size_t irun = message.find("run");
@@ -230,17 +248,15 @@ int CTPRunManager::processMessage(std::string& topic, const std::string& message
     }
     LOG(info) << "SOX received, Run keyword position:" << irun;
     std::string cfg = message.substr(irun, message.size() - irun);
-    startRun(cfg);
     firstcounters = message.substr(0, irun);
-  }
-  if (topic.find("eox") != std::string::npos) {
+  } else if (topic.find("eox") != std::string::npos) {
     LOG(info) << "EOX received";
     mEOX = 1;
-  }
-  static int nerror = 0;
-  if (topic == "rocnts") {
-    if (nerror < 1) {
-      LOG(warning) << "Skipping topic rocnts";
+  } else if (topic.find("cnts") != std::string::npos) {
+    // just continue
+  } else {
+    if (nerror < 10) {
+      LOG(warning) << "Skipping topic:" << topic;
       nerror++;
     }
     return 0;
@@ -293,6 +309,7 @@ int CTPRunManager::processMessage(std::string& topic, const std::string& message
         mActiveRunNumbers[i] = mCounters[i];
         mActiveRuns[i] = run->second;
         mRunsLoaded.erase(run);
+        setRunConfigBK(mActiveRuns[i]->cfg.getRunNumber(), mActiveRuns[i]->cfg.getConfigString());
         addScalers(i, tt, 1);
         saveRunScalersToQCDB(mActiveRuns[i]->scalers, tt * 1000, tt * 1000);
       } else {
diff --git a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
index 3484cb97279b5..0d81b896b3e91 100644
--- a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
@@ -107,6 +107,65 @@ int ctpCCDBManager::saveRunConfigToCCDB(CTPConfiguration* cfg, long timeStart)
   }
   return ret;
 }
+int ctpCCDBManager::saveSoxOrbit(uint32_t runNumber, uint32_t soxOrbit, long timestamp)
+{
+  // data base
+  if (mCCDBHost == "none") {
+    LOG(info) << "SOX Orbit not written to CCDB none";
+    return 0;
+  }
+  std::vector<int64_t> vect;
+  if (timestamp == 0) {
+    auto now = std::chrono::system_clock::now();
+    timestamp = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
+  }
+  vect.push_back(timestamp);
+  vect.push_back((uint64_t)runNumber);
+  vect.push_back((uint64_t)soxOrbit);
+  long tmin = timestamp;
+  long tmax = tmin + 381928219;
+  o2::ccdb::CcdbApi api;
+  map<string, string> metadata; // can be empty
+  metadata["runNumber"] = std::to_string(runNumber);
+  api.init(mCCDBHost.c_str()); // or http://localhost:8080 for a local installation
+
+  // store abitrary user object in strongly typed manner
+  int ret = api.storeAsTFileAny(&vect, mCCDBPathSoxOrbit, metadata, tmin, tmax);
+  if (ret == 0) {
+    LOG(info) << "SOX orbit  saved in ccdb:" << mCCDBHost << " run:" << runNumber << " tmin:" << tmin << " tmax:" << tmax;
+  } else {
+    LOG(fatal) << "SOX orbit Problem writing to database ret:" << ret;
+  }
+  return 0;
+}
+int ctpCCDBManager::saveOrbitReset(long timeStamp)
+{
+  // data base
+  if (mCCDBHost == "none") {
+    LOG(info) << "Orbit Reset not written to CCDB none";
+    return 0;
+  }
+  std::vector<int64_t> vect;
+  if (timeStamp == 0) {
+    auto now = std::chrono::system_clock::now();
+    timeStamp = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
+  }
+  vect.push_back(timeStamp);
+  long tmin = timeStamp;
+  long tmax = tmin + 381928219;
+  o2::ccdb::CcdbApi api;
+  map<string, string> metadata; // can be empty
+  api.init(mCCDBHost.c_str());  // or http://localhost:8080 for a local installation
+
+  // store abitrary user object in strongly typed manner
+  int ret = api.storeAsTFileAny(&vect, mCCDBPathOrbitReset, metadata, tmin, tmax);
+  if (ret == 0) {
+    LOG(info) << "Orbit reset  saved in ccdb:" << mCCDBHost << " tmin:" << tmin << " tmax:" << tmax;
+  } else {
+    LOG(fatal) << "Orbit reset Problem writing to database ret:" << ret;
+  }
+  return 0;
+}
 CTPConfiguration ctpCCDBManager::getConfigFromCCDB(long timestamp, std::string run, bool& ok)
 {
   auto& mgr = o2::ccdb::BasicCCDBManager::instance();

From fb4de2054a035146aa88a425cc46b1d54f10a63d Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 12 Mar 2025 13:59:23 +0100
Subject: [PATCH 0035/1764] write pairs correlation tree only if requested

---
 Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index 36530bfe9238b..db57ad5f8a7eb 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -591,9 +591,8 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
           pr.nshTPCRow = shinfo.second;
         }
       }
+      (*mDBGOut) << "pairs" << "pr=" << trcPairsVec << "\n";
     }
-    (*mDBGOut) << "pairs"
-               << "pr=" << trcPairsVec << "\n";
   }
 
   int nvtot = mMaxNeighbours < 0 ? -1 : (int)pveVec.size();

From cf94b28f0d092a4e1351bb303143923f9b5487f7 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 12 Mar 2025 14:56:33 +0100
Subject: [PATCH 0036/1764] Do not scale ITS tracking cuts for B=0

---
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index cbb31ff8bceb7..b264ac46bc7b3 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -38,6 +38,9 @@ void ITSTrackingInterface::initialise()
   std::vector<TrackingParameters> trackParams;
   const auto& trackConf = o2::its::TrackerParamConfig::Instance();
   float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791;
+  if (bFactor < 0.01) {
+    bFactor = 1.;
+  }
   if (mMode == TrackingMode::Unset) {
     mMode = (TrackingMode)(trackConf.trackingMode);
     LOGP(info, "Tracking mode not set, trying to fetch it from configurable params to: {}", asString(mMode));

From 7486f59b97f80adc24644b949fcd4671c4045339 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 15:08:37 +0100
Subject: [PATCH 0037/1764] dpl-workflow: automatically apply MI100 workaround
 in async

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index f9b0c7accbff9..76235d127037a 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -260,7 +260,7 @@ if [[ $GPUTYPE == "HIP" ]]; then
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
   [[ ${EPN_NODE_MI100:-} != "1" ]] && export HSA_NO_SCRATCH_RECLAIM=1
-  [[ $EPNSYNCMODE == 1 && ${EPN_NODE_MI100:-} == "1" ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
+  [[ $EPNSYNCMODE == 1 || ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else
   GPU_CONFIG_KEY+="GPU_proc.deviceNum=-2;"

From fe6cd7c0a1239cfbbb257da2c1e18a61cc15adae Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 12 Mar 2025 16:52:13 +0100
Subject: [PATCH 0038/1764] DataModel: make V0s IsStandard explicit (#13937)

This makes the check more explicit to really have a standard v0.
If analysers just ask for this bit, for example they still would get tpc-only v0s. @ddobrigk
---
 Framework/Core/include/Framework/AnalysisDataModel.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index 8c9f323f3dcc6..70db8500e3421 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -1596,7 +1596,7 @@ DECLARE_SOA_INDEX_COLUMN(Collision, collision);                         //! Coll
 DECLARE_SOA_COLUMN(V0Type, v0Type, uint8_t);                            //! custom bitmap for various selections (see below)
 
 DECLARE_SOA_DYNAMIC_COLUMN(IsStandardV0, isStandardV0, //! is standard V0
-                           [](uint8_t V0Type) -> bool { return V0Type & (1 << 0); });
+                           [](uint8_t V0Type) -> bool { return V0Type == 1; });
 DECLARE_SOA_DYNAMIC_COLUMN(IsPhotonV0, isPhotonV0, //! is TPC-only V0 for which the photon-mass-hypothesis was good
                            [](uint8_t V0Type) -> bool { return V0Type & (1 << 1); });
 DECLARE_SOA_DYNAMIC_COLUMN(IsCollinearV0, isCollinearV0, //! is V0 for which the photon-mass-hypothesis was good and was fitted collinearly

From f0d987e4be494d043bfb05500d31978d663ce796 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 23:46:59 +0100
Subject: [PATCH 0039/1764] GPU QA: Fix debug ROOT dump if we wrote a different
 ROOT file meanwhile

---
 GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx b/GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx
index 846c85e8e1cb3..7155b783e725e 100644
--- a/GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx
+++ b/GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx
@@ -30,6 +30,7 @@ GPUROOTDumpCore::GPUROOTDumpCore(GPUROOTDumpCore::GPUROOTDumpCorePrivate)
 GPUROOTDumpCore::~GPUROOTDumpCore()
 {
   if (mFile) {
+    mFile->cd();
     for (uint32_t i = 0; i < mBranches.size(); i++) {
       mBranches[i]->write();
     }

From 5c6657a7c1843c1a152eda3c7d2776e4ee14785c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 23:49:58 +0100
Subject: [PATCH 0040/1764] GPU QA: Add histogram with number of rows in which
 primary TPC track has clusters

---
 GPU/GPUTracking/qa/GPUQA.cxx | 125 +++++++++++++++++++++--------------
 GPU/GPUTracking/qa/GPUQA.h   |   8 +--
 2 files changed, 80 insertions(+), 53 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 552c82f1bd299..ba7aeb3800a5e 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -525,8 +525,10 @@ int32_t GPUQA::InitQACreateHistograms()
 
   if (mQATasks & taskTrackStatistics) {
     // Create Tracks Histograms
-    snprintf(name, 2048, "nclusters");
-    createHist(mNCl, name, name, 160, 0, 159);
+    for (int32_t i = 0; i < 2; i++) {
+      snprintf(name, 2048, i ? "nrows_with_cluster" : "nclusters");
+      createHist(mNCl[i], name, name, 160, 0, 159);
+    }
     snprintf(name, 2048, "tracks");
     std::unique_ptr<double[]> binsPt{CreateLogAxis(AXIS_BINS[4], PT_MIN_CLUST, PT_MAX)};
     createHist(mTracks, name, name, AXIS_BINS[4], binsPt.get());
@@ -895,7 +897,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       mTrackMCLabelsReverse[iCol][i] = -1;
     }
   }
-  if (mQATasks & taskClusterAttach) {
+  if (mQATasks & taskClusterAttach && GetNMCLabels()) {
     mClusterParam.resize(GetNMCLabels());
     memset(mClusterParam.data(), 0, mClusterParam.size() * sizeof(mClusterParam[0]));
   }
@@ -1661,7 +1663,25 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         continue;
       }
       mTracks->Fill(1.f / fabsf(track.GetParam().GetQPt()));
-      mNCl->Fill(track.NClustersFitted());
+      mNCl[0]->Fill(track.NClustersFitted());
+      uint32_t nClCorrected = 0;
+      int32_t lastSector = -1, lastRow = -1;
+      const auto& trackClusters = mTracking->mIOPtrs.mergedTrackHits;
+      for (uint32_t j = 0; j < track.NClusters(); j++) {
+        if (trackClusters[track.FirstClusterRef() + j].state & GPUTPCGMMergedTrackHit::flagReject) {
+          continue;
+        }
+        if (trackClusters[track.FirstClusterRef() + j].sector == lastSector && trackClusters[track.FirstClusterRef() + j].row == lastRow) {
+          continue;
+        }
+        if (trackClusters[track.FirstClusterRef() + j].leg != trackClusters[track.FirstClusterRef() + track.NClusters() - 1].leg) {
+          continue;
+        }
+        nClCorrected++;
+        lastSector = trackClusters[track.FirstClusterRef() + j].sector;
+        lastRow = trackClusters[track.FirstClusterRef() + j].sector;
+      }
+      mNCl[1]->Fill(nClCorrected);
     }
     if (mClNative && mTracking && mTracking->GetTPCTransformHelper()) {
       for (uint32_t i = 0; i < GPUChainTracking::NSECTORS; i++) {
@@ -2055,12 +2075,15 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mLTracks = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.45, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
       SetLegend(mLTracks);
 
-      mCNCl = createGarbageCollected<TCanvas>("cncl", "Number of clusters per track", 0, 0, 700, 700. * 2. / 3.);
-      mCNCl->cd();
-      mPNCl = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
-      mPNCl->Draw();
-      mLNCl = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.45, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
-      SetLegend(mLNCl);
+      for (int32_t i = 0; i < 2; i++) {
+        snprintf(name, 2048, "cncl%d Pull", i);
+        mCNCl[i] = createGarbageCollected<TCanvas>(name, i ? "Number of clusters (corrected for multiple per row)" : "Number of clusters per track", 0, 0, 700, 700. * 2. / 3.);
+        mCNCl[i]->cd();
+        mPNCl[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
+        mPNCl[i]->Draw();
+        mLNCl[i] = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.45, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
+        SetLegend(mLNCl[i]);
+      }
 
       mCClXY = createGarbageCollected<TCanvas>("clxy", "Number of clusters per X / Y", 0, 0, 700, 700. * 2. / 3.);
       mCClXY->cd();
@@ -2696,47 +2719,51 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mCTracks->Print("plots/tracks.root");
     }
 
-    tmpMax = 0.;
-    for (int32_t k = 0; k < ConfigNumInputs; k++) {
-      TH1F* e = mNCl;
-      if (GetHist(e, tin, k, nNewInput) == nullptr) {
-        continue;
-      }
-      e->SetMaximum(-1111);
-      if (e->GetMaximum() > tmpMax) {
-        tmpMax = e->GetMaximum();
-      }
-    }
-    mPNCl->cd();
-    for (int32_t k = 0; k < ConfigNumInputs; k++) {
-      TH1F* e = mNCl;
-      if (GetHist(e, tin, k, nNewInput) == nullptr) {
-        continue;
-      }
-      if (tout && !mConfig.inputHistogramsOnly && k == 0) {
-        e->Write();
+    for (int32_t i = 0; i < 2; i++) {
+      tmpMax = 0.;
+      for (int32_t k = 0; k < ConfigNumInputs; k++) {
+        TH1F* e = mNCl[i];
+        if (GetHist(e, tin, k, nNewInput) == nullptr) {
+          continue;
+        }
+        e->SetMaximum(-1111);
+        if (e->GetMaximum() > tmpMax) {
+          tmpMax = e->GetMaximum();
+        }
       }
-      e->SetMaximum(tmpMax * 1.02);
-      e->SetMinimum(tmpMax * -0.02);
-      e->SetStats(kFALSE);
-      e->SetLineWidth(1);
-      e->GetYaxis()->SetTitle("a.u.");
-      e->GetXaxis()->SetTitle("NClusters");
-      if (qcout) {
-        qcout->Add(e);
+      mPNCl[i]->cd();
+      for (int32_t k = 0; k < ConfigNumInputs; k++) {
+        TH1F* e = mNCl[i];
+        if (GetHist(e, tin, k, nNewInput) == nullptr) {
+          continue;
+        }
+        if (tout && !mConfig.inputHistogramsOnly && k == 0) {
+          e->Write();
+        }
+        e->SetMaximum(tmpMax * 1.02);
+        e->SetMinimum(tmpMax * -0.02);
+        e->SetStats(kFALSE);
+        e->SetLineWidth(1);
+        e->GetYaxis()->SetTitle("a.u.");
+        e->GetXaxis()->SetTitle("NClusters");
+        if (qcout) {
+          qcout->Add(e);
+        }
+        e->SetMarkerColor(kBlack);
+        e->SetLineColor(colorNums[k % COLORCOUNT]);
+        e->Draw(k == 0 ? "" : "same");
+        GetName(fname, k);
+        snprintf(name, 2048, "%sNClusters%d", fname, i);
+        mLNCl[i]->AddEntry(e, name, "l");
+      }
+      mLNCl[i]->Draw();
+      mCNCl[i]->cd();
+      snprintf(name, 2048, "plots/nClusters%s.pdf", i ? "_corrected" : "");
+      mCNCl[i]->Print(name);
+      if (mConfig.writeRootFiles) {
+        snprintf(name, 2048, "plots/nClusters%s.root", i ? "_corrected" : "");
+        mCNCl[i]->Print(name);
       }
-      e->SetMarkerColor(kBlack);
-      e->SetLineColor(colorNums[k % COLORCOUNT]);
-      e->Draw(k == 0 ? "" : "same");
-      GetName(fname, k);
-      snprintf(name, 2048, "%sNClusters", fname);
-      mLNCl->AddEntry(e, name, "l");
-    }
-    mLNCl->Draw();
-    mCNCl->cd();
-    mCNCl->Print("plots/nClusters.pdf");
-    if (mConfig.writeRootFiles) {
-      mCNCl->Print("plots/nClusters.root");
     }
 
     mPClXY->cd();
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 32b0553700f90..87900b5279ec0 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -299,10 +299,10 @@ class GPUQA
   TPad* mPTracks;
   TLegend* mLTracks;
 
-  TH1F* mNCl;
-  TCanvas* mCNCl;
-  TPad* mPNCl;
-  TLegend* mLNCl;
+  TH1F* mNCl[2];
+  TCanvas* mCNCl[2];
+  TPad* mPNCl[2];
+  TLegend* mLNCl[2];
 
   TH2F* mClXY;
   TCanvas* mCClXY;

From 641977cccfa17710faaca7c18bbb7e607957b232 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Wed, 5 Mar 2025 18:41:31 +0100
Subject: [PATCH 0041/1764] Fixing handling of edge clusters

Adapting edge correction

Fixing edge handling

Please consider the following formatting changes

Fix for right edge check
---
 GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx  | 7 ++++++-
 GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h    | 2 +-
 GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx | 4 +++-
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
index d145aaed705d9..a826cdf71f575 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
@@ -97,7 +97,7 @@ GPUd() Charge ClusterAccumulator::updateOuter(PackedCharge charge, Delta2 d)
   return q;
 }
 
-GPUd() void ClusterAccumulator::finalize(const ChargePos& pos, Charge q, TPCTime timeOffset, const GPUTPCGeometry& geo)
+GPUd() void ClusterAccumulator::finalize(const ChargePos& pos, Charge q, TPCTime timeOffset, const GPUTPCGeometry& geo, Charge* padBoundaryCharges)
 {
   mQtot += q;
 
@@ -116,6 +116,11 @@ GPUd() void ClusterAccumulator::finalize(const ChargePos& pos, Charge q, TPCTime
   if (CfUtils::isAtEdge(pos, geo.NPads(pos.row()))) {
     bool leftEdge = (pad < 2);
     bool correct = (leftEdge) ? (pad < mPadMean) : (pad > mPadMean);
+    if (leftEdge && pad == 1) {                         // only check charge at boundary if maximum is at least one pad away from boundary
+      correct = correct && (padBoundaryCharges[0] > 0); // Only correct if cluster is asymmetric with charge > 0 towards sector boundary, otherwise all charge is found
+    } else if (!leftEdge && pad == (geo.NPads(pos.row()) - 2)) {
+      correct = correct && (padBoundaryCharges[1] > 0);
+    }
     mPadMean = (correct) ? pad : mPadMean;
   }
 }
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
index 26decbf0a5b14..c409a6cced3a5 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
@@ -40,7 +40,7 @@ class ClusterAccumulator
   GPUd() tpccf::Charge updateInner(PackedCharge, tpccf::Delta2);
   GPUd() tpccf::Charge updateOuter(PackedCharge, tpccf::Delta2);
 
-  GPUd() void finalize(const ChargePos&, tpccf::Charge, tpccf::TPCTime, const GPUTPCGeometry&);
+  GPUd() void finalize(const ChargePos&, tpccf::Charge, tpccf::TPCTime, const GPUTPCGeometry&, tpccf::Charge*);
   GPUd() bool toNative(const ChargePos&, tpccf::Charge, tpc::ClusterNative&, const GPUParam&) const;
 
  private:
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
index 1aeae812f5193..f28e80aa08201 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
@@ -58,6 +58,8 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
   ChargePos pos = filteredPeakPositions[CAMath::Min(idx, clusternum - 1)];
   Charge charge = chargeMap[pos].unpack();
 
+  Charge padBoundaryCharges[2] = {chargeMap[pos.delta({-1, 0})].unpack(), chargeMap[pos.delta({1, 0})].unpack()};
+
   ClusterAccumulator pc;
   CPU_ONLY(labelAcc->collect(pos, charge));
 
@@ -80,7 +82,7 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
     }
     return;
   }
-  pc.finalize(pos, charge, fragment.start, clusterer.Param().tpcGeometry);
+  pc.finalize(pos, charge, fragment.start, clusterer.Param().tpcGeometry, padBoundaryCharges);
 
   tpc::ClusterNative myCluster;
   bool rejectCluster = !pc.toNative(pos, charge, myCluster, clusterer.Param());

From 46445fa21a058dd94017a350be1b8f74cf55d476 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 19:26:48 +0100
Subject: [PATCH 0042/1764] GPU TPC CF: Use corrected check also for edge
 cluster tagging

---
 GPU/GPUTracking/TPCClusterFinder/CfUtils.h    |  5 --
 .../TPCClusterFinder/ClusterAccumulator.cxx   | 89 +++++++++----------
 .../TPCClusterFinder/ClusterAccumulator.h     |  4 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.cxx  |  6 +-
 4 files changed, 45 insertions(+), 59 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/CfUtils.h b/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
index 4504b8288aee0..75dcc166abd9b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
+++ b/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
@@ -27,11 +27,6 @@ class CfUtils
 {
 
  public:
-  static GPUdi() bool isAtEdge(const ChargePos& pos, tpccf::GlobalPad padsPerRow)
-  {
-    return (pos.pad() < 2 || pos.pad() >= padsPerRow - 2);
-  }
-
   static GPUdi() bool innerAboveThreshold(uint8_t aboveThreshold, uint16_t outerIdx)
   {
     return aboveThreshold & (1 << cfconsts::OuterToInner[outerIdx]);
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
index a826cdf71f575..77dc6e119df7d 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
@@ -21,45 +21,6 @@
 using namespace o2::gpu;
 using namespace o2::gpu::tpccf;
 
-GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, Charge q, tpc::ClusterNative& cn, const GPUParam& param) const
-{
-  cn.qTot = CAMath::Float2UIntRn(mQtot);
-  if (cn.qTot <= param.rec.tpc.cfQTotCutoff) {
-    return false;
-  }
-  cn.qMax = q;
-  if (cn.qMax <= param.rec.tpc.cfQMaxCutoff) {
-    return false;
-  }
-  if (mTimeMean < param.rec.tpc.clustersShiftTimebinsClusterizer) {
-    return false;
-  }
-  if (q <= param.rec.tpc.cfQMaxCutoffSingleTime && mTimeSigma == 0) {
-    return false;
-  }
-  if (q <= param.rec.tpc.cfQMaxCutoffSinglePad && mPadSigma == 0) {
-    return false;
-  }
-
-  bool isEdgeCluster = CfUtils::isAtEdge(pos, param.tpcGeometry.NPads(pos.row()));
-  bool wasSplitInTime = mSplitInTime >= param.rec.tpc.cfMinSplitNum;
-  bool wasSplitInPad = mSplitInPad >= param.rec.tpc.cfMinSplitNum;
-  bool isSingleCluster = (mPadSigma == 0) || (mTimeSigma == 0);
-
-  uint8_t flags = 0;
-  flags |= (isEdgeCluster) ? tpc::ClusterNative::flagEdge : 0;
-  flags |= (wasSplitInTime) ? tpc::ClusterNative::flagSplitTime : 0;
-  flags |= (wasSplitInPad) ? tpc::ClusterNative::flagSplitPad : 0;
-  flags |= (isSingleCluster) ? tpc::ClusterNative::flagSingle : 0;
-
-  cn.setTimeFlags(mTimeMean - param.rec.tpc.clustersShiftTimebinsClusterizer, flags);
-  cn.setPad(mPadMean);
-  cn.setSigmaTime(mTimeSigma);
-  cn.setSigmaPad(mPadSigma);
-
-  return true;
-}
-
 GPUd() void ClusterAccumulator::update(Charge splitCharge, Delta2 d)
 {
   mQtot += splitCharge;
@@ -97,7 +58,7 @@ GPUd() Charge ClusterAccumulator::updateOuter(PackedCharge charge, Delta2 d)
   return q;
 }
 
-GPUd() void ClusterAccumulator::finalize(const ChargePos& pos, Charge q, TPCTime timeOffset, const GPUTPCGeometry& geo, Charge* padBoundaryCharges)
+GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, Charge q, tpc::ClusterNative& cn, const GPUParam& param, TPCTime timeOffset, const Array2D<PackedCharge>& chargeMap)
 {
   mQtot += q;
 
@@ -113,14 +74,48 @@ GPUd() void ClusterAccumulator::finalize(const ChargePos& pos, Charge q, TPCTime
   mPadMean += pad;
   mTimeMean += timeOffset + pos.time();
 
-  if (CfUtils::isAtEdge(pos, geo.NPads(pos.row()))) {
+  bool isEdgeCluster = pos.pad() < 2 || pos.pad() >= param.tpcGeometry.NPads(pos.row()) - 2; // Geometrical edge check, peak within 2 pads of sector edge
+  if (isEdgeCluster) {
     bool leftEdge = (pad < 2);
-    bool correct = (leftEdge) ? (pad < mPadMean) : (pad > mPadMean);
-    if (leftEdge && pad == 1) {                         // only check charge at boundary if maximum is at least one pad away from boundary
-      correct = correct && (padBoundaryCharges[0] > 0); // Only correct if cluster is asymmetric with charge > 0 towards sector boundary, otherwise all charge is found
-    } else if (!leftEdge && pad == (geo.NPads(pos.row()) - 2)) {
-      correct = correct && (padBoundaryCharges[1] > 0);
+    if (leftEdge ? (pad == 1 && chargeMap[pos.delta({-1, 0})].unpack() < 1) : (pad == (param.tpcGeometry.NPads(pos.row()) - 2) && chargeMap[pos.delta({1, 0})].unpack() < 1)) {
+      isEdgeCluster = false; // No edge cluster if peak is close to edge but no charge at the edge.
+    } else if (leftEdge ? (pad < mPadMean) : (pad > mPadMean)) {
+      mPadMean = pad; // Correct to peak position if COG is close to middle of pad than peak
     }
-    mPadMean = (correct) ? pad : mPadMean;
   }
+
+  cn.qTot = CAMath::Float2UIntRn(mQtot);
+  if (cn.qTot <= param.rec.tpc.cfQTotCutoff) {
+    return false;
+  }
+  cn.qMax = q;
+  if (cn.qMax <= param.rec.tpc.cfQMaxCutoff) {
+    return false;
+  }
+  if (mTimeMean < param.rec.tpc.clustersShiftTimebinsClusterizer) {
+    return false;
+  }
+  if (q <= param.rec.tpc.cfQMaxCutoffSingleTime && mTimeSigma == 0) {
+    return false;
+  }
+  if (q <= param.rec.tpc.cfQMaxCutoffSinglePad && mPadSigma == 0) {
+    return false;
+  }
+
+  bool wasSplitInTime = mSplitInTime >= param.rec.tpc.cfMinSplitNum;
+  bool wasSplitInPad = mSplitInPad >= param.rec.tpc.cfMinSplitNum;
+  bool isSingleCluster = (mPadSigma == 0) || (mTimeSigma == 0);
+
+  uint8_t flags = 0;
+  flags |= (isEdgeCluster) ? tpc::ClusterNative::flagEdge : 0;
+  flags |= (wasSplitInTime) ? tpc::ClusterNative::flagSplitTime : 0;
+  flags |= (wasSplitInPad) ? tpc::ClusterNative::flagSplitPad : 0;
+  flags |= (isSingleCluster) ? tpc::ClusterNative::flagSingle : 0;
+
+  cn.setTimeFlags(mTimeMean - param.rec.tpc.clustersShiftTimebinsClusterizer, flags);
+  cn.setPad(mPadMean);
+  cn.setSigmaTime(mTimeSigma);
+  cn.setSigmaPad(mPadSigma);
+
+  return true;
 }
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
index c409a6cced3a5..73f7cb439775a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
@@ -17,6 +17,7 @@
 
 #include "clusterFinderDefs.h"
 #include "PackedCharge.h"
+#include "Array2D.h"
 
 namespace o2
 {
@@ -40,8 +41,7 @@ class ClusterAccumulator
   GPUd() tpccf::Charge updateInner(PackedCharge, tpccf::Delta2);
   GPUd() tpccf::Charge updateOuter(PackedCharge, tpccf::Delta2);
 
-  GPUd() void finalize(const ChargePos&, tpccf::Charge, tpccf::TPCTime, const GPUTPCGeometry&, tpccf::Charge*);
-  GPUd() bool toNative(const ChargePos&, tpccf::Charge, tpc::ClusterNative&, const GPUParam&) const;
+  GPUd() bool toNative(const ChargePos&, tpccf::Charge, tpc::ClusterNative&, const GPUParam&, tpccf::TPCTime, const Array2D<PackedCharge>&);
 
  private:
   float mQtot = 0;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
index f28e80aa08201..407deb6a588d0 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
@@ -58,8 +58,6 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
   ChargePos pos = filteredPeakPositions[CAMath::Min(idx, clusternum - 1)];
   Charge charge = chargeMap[pos].unpack();
 
-  Charge padBoundaryCharges[2] = {chargeMap[pos.delta({-1, 0})].unpack(), chargeMap[pos.delta({1, 0})].unpack()};
-
   ClusterAccumulator pc;
   CPU_ONLY(labelAcc->collect(pos, charge));
 
@@ -82,10 +80,8 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
     }
     return;
   }
-  pc.finalize(pos, charge, fragment.start, clusterer.Param().tpcGeometry, padBoundaryCharges);
-
   tpc::ClusterNative myCluster;
-  bool rejectCluster = !pc.toNative(pos, charge, myCluster, clusterer.Param());
+  bool rejectCluster = !pc.toNative(pos, charge, myCluster, clusterer.Param(), fragment.start, chargeMap);
 
   if (rejectCluster) {
     if (clusterPosInRow) {

From dffee581d1402171d2088cb1c5d4d5ad76d7bace Mon Sep 17 00:00:00 2001
From: iravasen <ivan.ravasenga@cern.ch>
Date: Thu, 13 Mar 2025 11:20:27 +0100
Subject: [PATCH 0043/1764] Refine calculations for rise time and ToT (#14039)

---
 .../workflow/src/ThresholdCalibratorSpec.cxx  | 46 +++++++++----------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
index 075a4869210e1..b651bfdedf3aa 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
@@ -1001,8 +1001,8 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
     this->mFitType = NO_FIT;
     this->mMin = 0;
     this->mMax = 400; // strobe delay goes from 0 to 400 (included) in steps of 4
-    this->mStep = 4;
-    this->mStrobeWindow = 5; // it's 4 but it corresponds to 4+1 (as from alpide manual)
+    this->mStep = 1;
+    this->mStrobeWindow = 1; // it's 0 but it corresponds to 0+1 (as from alpide manual)
     this->N_RANGE = (mMax - mMin) / mStep + 1;
     this->mCheckExactRow = true;
   } else if (runtype == TOT_CALIBRATION_1_ROW) {
@@ -1013,7 +1013,7 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
     this->mMin = 0;
     this->mMax = 2000; // strobe delay goes from 0 to 2000 in steps of 10
     this->mStep = 10;
-    this->mStrobeWindow = 2; // it's 1 but it corresponds to 1+1 (as from alpide manual)
+    this->mStrobeWindow = 10; // it's 9 but it corresponds to 9+1 (as from alpide manual)
     this->N_RANGE = (mMax - mMin) / mStep + 1;
     this->mMin2 = 0;   // charge min
     this->mMax2 = 170; // charge max
@@ -1028,7 +1028,7 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
     this->mMin = 300;
     this->mMax = 1100; // strobe delay goes from 300 to 1100 (included) in steps of 10
     this->mStep = 10;
-    this->mStrobeWindow = 2; // it's 1 but it corresponds to 1+1 (as from alpide manual)
+    this->mStrobeWindow = 10; // it's 9 but it corresponds to 9+1 (as from alpide manual)
     this->N_RANGE = (mMax - mMin) / mStep + 1;
     this->mMin2 = 30;                 // charge min
     this->mMax2 = 60;                 // charge max
@@ -1116,39 +1116,39 @@ std::vector<float> ITSThresholdCalibrator::calculatePulseParams(const short int&
 
   for (auto itrow = mPixelHits[chipID].begin(); itrow != mPixelHits[chipID].end(); itrow++) { // loop over the chip rows
     short int row = itrow->first;
-    for (short int col_i = 0; col_i < this->N_COL; col_i++) {                                                                     // loop over the pixels on the row
-      for (short int sdel_i = 0; sdel_i < this->N_RANGE; sdel_i++) {                                                              // loop over the strobe delays
-        if (mPixelHits[chipID][row][col_i][0][sdel_i] > 0 && mPixelHits[chipID][row][col_i][0][sdel_i] < nInj && rt_mindel < 0) { // from left, the last bin with 0 hits or the first with some hits
-          rt_mindel = sdel_i > 0 ? ((sdel_i - 1) * mStep) + 1 : (sdel_i * mStep) + 1;                                             // + 1 because if delay = n, we get n+1 in reality (ALPIDE feature)
+    for (short int col_i = 0; col_i < this->N_COL; col_i++) {                                                                              // loop over the pixels on the row
+      for (short int sdel_i = 0; sdel_i < this->N_RANGE; sdel_i++) {                                                                       // loop over the strobe delays
+        if (mPixelHits[chipID][row][col_i][0][sdel_i] > 0.1 * nInj && mPixelHits[chipID][row][col_i][0][sdel_i] < nInj && rt_mindel < 0) { // from left, first bin with 10% hits and 90% hits
+          rt_mindel = (sdel_i * mStep) + 1;                                                                                                // + 1 because if delay = n, we get n+1 in reality (ALPIDE feature)
         }
-        if (mPixelHits[chipID][row][col_i][0][sdel_i] == nInj) {
+        if (mPixelHits[chipID][row][col_i][0][sdel_i] >= 0.9 * nInj) { // for Rt max take the 90% point
           rt_maxdel = (sdel_i * mStep) + 1;
+          break;
+        }
+      }
+      for (short int sdel_i = 0; sdel_i < N_RANGE; sdel_i++) {
+        if (mPixelHits[chipID][row][col_i][0][sdel_i] >= 0.5 * nInj) { // for ToT take the 50% point
           tot_mindel = (sdel_i * mStep) + 1;
           break;
         }
       }
 
-      for (short int sdel_i = N_RANGE - 1; sdel_i >= 0; sdel_i--) { // from right, the first bin with nInj hits
-        if (mPixelHits[chipID][row][col_i][0][sdel_i] == nInj) {
+      for (short int sdel_i = N_RANGE - 1; sdel_i >= 0; sdel_i--) { // from right, the first bin with 50% nInj hits
+        if (mPixelHits[chipID][row][col_i][0][sdel_i] >= 0.5 * nInj) {
           tot_maxdel = (sdel_i * mStep) + 1;
           break;
         }
       }
 
       if (tot_maxdel > tot_mindel && tot_mindel >= 0 && tot_maxdel >= 0) {
-        sumTot += tot_maxdel - tot_mindel - (int)(mStrobeWindow / 2);
-        sumSqTot += (tot_maxdel - tot_mindel - (int)(mStrobeWindow / 2)) * (tot_maxdel - tot_mindel - (int)(mStrobeWindow / 2));
+        sumTot += tot_maxdel - tot_mindel - mStrobeWindow;
+        sumSqTot += (tot_maxdel - tot_mindel - mStrobeWindow) * (tot_maxdel - tot_mindel - mStrobeWindow);
         countTot++;
       }
 
-      if (rt_maxdel > rt_mindel && rt_maxdel > 0) {
-        if (rt_mindel < 0) {
-          sumRt += mStep + (int)(mStrobeWindow / 2); // resolution -> in case the rise is "instantaneous"
-          sumSqRt += (mStep + (int)(mStrobeWindow / 2)) * (mStep + (int)(mStrobeWindow / 2));
-        } else {
-          sumRt += rt_maxdel - rt_mindel + (int)(mStrobeWindow / 2);
-          sumSqRt += (rt_maxdel - rt_mindel + (int)(mStrobeWindow / 2)) * (rt_maxdel - rt_mindel + (int)(mStrobeWindow / 2));
-        }
+      if (rt_maxdel > rt_mindel && rt_maxdel > 0 && rt_mindel > 0) {
+        sumRt += rt_maxdel - rt_mindel + mStrobeWindow;
+        sumSqRt += (rt_maxdel - rt_mindel + mStrobeWindow) * (rt_maxdel - rt_mindel + mStrobeWindow);
         countRt++;
       }
 
@@ -1232,8 +1232,8 @@ std::vector<float> ITSThresholdCalibrator::calculatePulseParams2D(const short in
       }
 
       if (maxPl > tot_mindel && tot_mindel < 1e7 && maxPl >= 0) { // ToT
-        sumTot += maxPl - tot_mindel - (int)(mStrobeWindow / 2);
-        sumSqTot += (maxPl - tot_mindel - (int)(mStrobeWindow / 2)) * (maxPl - tot_mindel - (int)(mStrobeWindow / 2));
+        sumTot += maxPl - tot_mindel - mStrobeWindow;
+        sumSqTot += (maxPl - tot_mindel - mStrobeWindow) * (maxPl - tot_mindel - mStrobeWindow);
         countTot++;
       }
 

From 46380fc7fbd16567c6acae29dc991005a5b9b974 Mon Sep 17 00:00:00 2001
From: Chunzheng Wang <83008337+ChunzhengLab@users.noreply.github.com>
Date: Thu, 13 Mar 2025 11:21:59 +0100
Subject: [PATCH 0044/1764] AlpideResponse adjust for APTS (#13929)

Signed-off-by: Chunzheng Wang <chunzheng.wang@cern.ch>
---
 .../AlpideResponseData/AlpideResponse.cxx     | 66 ++++++++++++++-----
 .../ITSMFTSimulation/AlpideSimResponse.h      |  4 +-
 2 files changed, 52 insertions(+), 18 deletions(-)

diff --git a/Detectors/ITSMFT/common/data/AlpideResponseData/AlpideResponse.cxx b/Detectors/ITSMFT/common/data/AlpideResponseData/AlpideResponse.cxx
index f4c71d85df24e..86ffb24b239ed 100644
--- a/Detectors/ITSMFT/common/data/AlpideResponseData/AlpideResponse.cxx
+++ b/Detectors/ITSMFT/common/data/AlpideResponseData/AlpideResponse.cxx
@@ -14,55 +14,87 @@
 #include "ITSMFTSimulation/AlpideSimResponse.h"
 #include <TFile.h>
 #include <TSystem.h>
+#include <stdexcept>
 #include <cstdio>
 #include <cstddef>
 #include <fstream>
 #include <iostream>
 #include <string>
 
-void alpideResponse(const std::string& inpath = "./",
-                    const std::string& outpath = "./",
-                    const std::string& response_file = "AlpideResponseData.root")
+void alpideResponse(const std::string& inpath, const std::string& outpath, const std::string& chip_name)
 {
+  // Check input path validity
+  if (gSystem->AccessPathName(inpath.c_str())) {
+    throw std::invalid_argument("Input path does not exist or is inaccessible: " + inpath);
+  }
+
+  // Check output path validity
+  if (gSystem->AccessPathName(outpath.c_str(), kWritePermission)) {
+    throw std::invalid_argument("Output path is not writable: " + outpath);
+  }
 
   o2::itsmft::AlpideSimResponse resp0, resp1;
 
-  resp0.initData(0, inpath.data());
-  resp1.initData(1, inpath.data());
+  if (chip_name == "Alpide") {
+    resp0.initData(0, inpath.c_str());
+    resp1.initData(1, inpath.c_str());
+  } else if (chip_name == "APTS") {
+    resp1.setColMax(1.5e-4);
+    resp1.setRowMax(1.5e-4);
+    resp1.initData(1, inpath.c_str());
+  } else {
+    throw std::invalid_argument("Unknown chip name: " + chip_name);
+  }
 
-  auto file = TFile::Open((outpath + response_file).data(), "recreate");
-  file->WriteObjectAny(&resp0, "o2::itsmft::AlpideSimResponse", "response0");
+  std::string output_file = outpath + "/" + chip_name + "ResponseData.root";
+  auto file = TFile::Open(output_file.c_str(), "recreate");
+
+  if (!file || file->IsZombie()) {
+    throw std::runtime_error("Failed to create output file: " + output_file);
+  } else if (chip_name == "Alpide") {
+    file->WriteObjectAny(&resp0, "o2::itsmft::AlpideSimResponse", "response0");
+  }
   file->WriteObjectAny(&resp1, "o2::itsmft::AlpideSimResponse", "response1");
   file->Close();
+  delete file;
 }
 
 int main(int argc, const char* argv[])
 {
   namespace bpo = boost::program_options;
   bpo::variables_map vm;
-  bpo::options_description options("Alpide reponse generator options");
-  options.add_options()(
-    "inputdir,i", bpo::value<std::string>()->default_value("./"), "Path where Vbb-0.0V and Vbb-3.0V are located.")(
-    "outputdir,o", bpo::value<std::string>()->default_value("./"), "Path where to store the output.")(
-    "name,n", bpo::value<std::string>()->default_value("AlpideResponseData.root"), "Output file name.");
+  bpo::options_description options("Alpide response generator options");
+  options.add_options()("inputdir,i", bpo::value<std::string>()->default_value("./"), "Path where Vbb-0.0V and Vbb-3.0V are located.")("outputdir,o", bpo::value<std::string>()->default_value("./"), "Path where to store the output.")("chip,c", bpo::value<std::string>()->default_value("Alpide"), "Chip name (Alpide or APTS).");
 
   try {
     bpo::store(parse_command_line(argc, argv, options), vm);
+
     if (vm.count("help")) {
       std::cout << options << std::endl;
-      return 1;
+      return 0;
     }
+
     bpo::notify(vm);
   } catch (const bpo::error& e) {
     std::cerr << e.what() << "\n\n";
     std::cerr << "Error parsing command line arguments. Available options:\n";
-
     std::cerr << options << std::endl;
     return 2;
   }
 
-  std::cout << "Generating " << vm["inputdir"].as<std::string>() + vm["name"].as<std::string>() << std::endl;
-  alpideResponse(vm["inputdir"].as<std::string>(), vm["outputdir"].as<std::string>(), vm["name"].as<std::string>());
+  try {
+    std::cout << "Generating response for chip: " << vm["chip"].as<std::string>() << std::endl;
+    std::cout << "Input directory: " << vm["inputdir"].as<std::string>() << std::endl;
+    std::cout << "Output directory: " << vm["outputdir"].as<std::string>() << std::endl;
+
+    alpideResponse(vm["inputdir"].as<std::string>(),
+                   vm["outputdir"].as<std::string>(),
+                   vm["chip"].as<std::string>());
+    std::cout << "Response file generated successfully." << std::endl;
+  } catch (const std::exception& e) {
+    std::cerr << "Error: " << e.what() << std::endl;
+    return 1;
+  }
 
   return 0;
-}
\ No newline at end of file
+}
diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
index 0462115d3bfc6..92656a16257a1 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
@@ -132,6 +132,8 @@ class AlpideSimResponse
   float getStepCol() const { return mStepInvCol ? 1. / mStepInvCol : 0.f; }
   float getStepRow() const { return mStepInvRow ? 1. / mStepInvRow : 0.f; }
   float getStepDepth() const { return mStepInvDpt ? 1. / mStepInvDpt : 0.f; }
+  void setColMax(float v) noexcept { mColMax = v; }
+  void setRowMax(float v) noexcept { mRowMax = v; }
   void setDataPath(const std::string pth) { mDataPath = pth; }
   void setGridColName(const std::string nm) { mGridColName = nm; }
   void setGridRowName(const std::string nm) { mGridRowName = nm; }
@@ -142,7 +144,7 @@ class AlpideSimResponse
   const std::string& getColRowDataFmt() const { return mColRowDataFmt; }
   void print() const;
 
-  ClassDefNV(AlpideSimResponse, 1);
+  ClassDefNV(AlpideSimResponse, 2);
 };
 
 //-----------------------------------------------------

From c0831adaeecc26ceff98d7f1aae8b2e8b3c46741 Mon Sep 17 00:00:00 2001
From: Cas van Veen - They/them <96796377+Cas1997@users.noreply.github.com>
Date: Thu, 13 Mar 2025 11:42:23 +0100
Subject: [PATCH 0045/1764] ALICE3: TRK now hosts IRIS tracker which is divided
 into petal cases and made retractable (#13953)

* ALICE3: TRK now hosts IRIS tracker which is divided into petal cases and made retractable

* Fixed hits in sensitive volumes + fixed CMakeLists.txt

* Applied clang

* Uncommented services

* Final bug fix

* Fixed placement of the beam pipe from earlier PR

* Applied clang

---------

Co-authored-by: Matteo Concas <matteo.concas@cern.ch>
---
 .../ALICE3/FT3/simulation/src/Detector.cxx    |  17 +-
 .../include/Alice3DetectorsPassive/Pipe.h     |  12 +-
 .../Upgrades/ALICE3/Passive/src/Pipe.cxx      | 144 ++-----------
 .../TRK/base/include/TRKBase/TRKBaseParam.h   |   2 +
 .../ALICE3/TRK/simulation/CMakeLists.txt      |   8 +-
 .../include/TRKSimulation/Detector.h          |   7 +-
 .../include/TRKSimulation/TRKPetalCase.h      |  93 ++++++++
 .../include/TRKSimulation/TRKPetalDisk.h      |  64 ++++++
 .../include/TRKSimulation/TRKPetalLayer.h     |  61 ++++++
 .../include/TRKSimulation/TRKServices.h       |  12 +-
 .../ALICE3/TRK/simulation/src/Detector.cxx    | 108 +++++++---
 .../TRK/simulation/src/TRKPetalCase.cxx       | 202 ++++++++++++++++++
 .../TRK/simulation/src/TRKPetalDisk.cxx       |  94 ++++++++
 .../TRK/simulation/src/TRKPetalLayer.cxx      |  79 +++++++
 .../ALICE3/TRK/simulation/src/TRKServices.cxx |  96 ++++-----
 .../TRK/simulation/src/TRKSimulationLinkDef.h |   3 +
 macro/build_geometry.C                        |   2 +-
 17 files changed, 764 insertions(+), 240 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalCase.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalDisk.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalLayer.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalCase.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalDisk.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalLayer.cxx

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index 296bec8aa8922..ce132fdb33cd3 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -184,8 +184,8 @@ void Detector::buildBasicFT3(const FT3BaseParam& param)
 //_________________________________________________________________________________________________
 void Detector::buildFT3V1()
 {
-  //Build FT3 detector according to
-  //https://indico.cern.ch/event/992488/contributions/4174473/attachments/2168881/3661331/tracker_parameters_werner_jan_11_2021.pdf
+  // Build FT3 detector according to
+  // https://indico.cern.ch/event/992488/contributions/4174473/attachments/2168881/3661331/tracker_parameters_werner_jan_11_2021.pdf
 
   LOG(info) << "Building FT3 Detector: V1";
 
@@ -284,17 +284,15 @@ void Detector::buildFT3NewVacuumVessel()
   // to adhere to the changes that were presented at the ALICE 3 Upgrade days in March 2024
   // Inner radius at C-side to 7 cm
   // Inner radius at A-side stays at 5 cm
+  // 06.02.2025 update: IRIS layers are now in TRK
 
   LOG(info) << "Building FT3 Detector: After Upgrade Days March 2024 version";
 
-  mNumberOfLayers = 12;
+  mNumberOfLayers = 9;
   float sensorThickness = 30.e-4;
   float layersx2X0 = 1.e-2;
   std::vector<std::array<float, 5>> layersConfigCSide{
-    {26., .5, 2.5, 0.1f * layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
-    {30., .5, 2.5, 0.1f * layersx2X0},
-    {34., .5, 2.5, 0.1f * layersx2X0},
-    {77., 7.0, 35., layersx2X0},
+    {77., 7.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
     {100., 7.0, 35., layersx2X0},
     {122., 7.0, 35., layersx2X0},
     {150., 7.0, 68.f, layersx2X0},
@@ -305,10 +303,7 @@ void Detector::buildFT3NewVacuumVessel()
     {350., 7.0, 68.f, layersx2X0}};
 
   std::vector<std::array<float, 5>> layersConfigASide{
-    {26., .5, 2.5, 0.1f * layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
-    {30., .5, 2.5, 0.1f * layersx2X0},
-    {34., .5, 2.5, 0.1f * layersx2X0},
-    {77., 5.0, 35., layersx2X0},
+    {77., 5.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
     {100., 5.0, 35., layersx2X0},
     {122., 5.0, 35., layersx2X0},
     {150., 5.0, 68.f, layersx2X0},
diff --git a/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/Pipe.h b/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/Pipe.h
index 1d9858e2dfec3..b13d9ab68780a 100644
--- a/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/Pipe.h
+++ b/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/Pipe.h
@@ -26,8 +26,6 @@ class Alice3Pipe : public Alice3PassiveBase
   ~Alice3Pipe() override;
   Alice3Pipe(const char* name,
              const char* title = "Alice 3 Pipe",
-             const bool isTRKActivated = false,
-             const bool isFT3Activated = false,
              const float pipeRIn = 0.f,
              const float pipeThickness = 0.f,
              const float a3ipLength = 0.f,
@@ -50,9 +48,6 @@ class Alice3Pipe : public Alice3PassiveBase
   float getVacuumVesselWidth() const { return mVacuumVesselThick; }
   float getVacuumVesselLength() const { return mVacuumVesselASideLength; }
 
-  bool IsTRKActivated() const { return mIsTRKActivated; }
-  bool IsFT3Activated() const { return mIsFT3Activated; }
-
  private:
   void createMaterials();
   Alice3Pipe(const Alice3Pipe& orig) = default;
@@ -62,13 +57,10 @@ class Alice3Pipe : public Alice3PassiveBase
   float mPipeThick = 0.;  // inner beam pipe section thickness
   float mA3IPLength = 0.; // Length of A3IP
 
-  float mVacuumVesselRIn = 0.;    // inner diameter of the vacuum vessel
-  float mVacuumVesselThick = 0.;  // outer beam pipe section thickness
+  float mVacuumVesselRIn = 0.;         // inner diameter of the vacuum vessel
+  float mVacuumVesselThick = 0.;       // outer beam pipe section thickness
   float mVacuumVesselASideLength = 0.; // Length of the A Side of the vacuum vessel around the IP
 
-  bool mIsTRKActivated = true; // If TRK is not active don't create TRK layers allocations in the vacuum volume
-  bool mIsFT3Activated = true;
-
   ClassDefOverride(Alice3Pipe, 1);
 };
 } // namespace passive
diff --git a/Detectors/Upgrades/ALICE3/Passive/src/Pipe.cxx b/Detectors/Upgrades/ALICE3/Passive/src/Pipe.cxx
index 57f30241bd4ff..7dfd26a79b38d 100644
--- a/Detectors/Upgrades/ALICE3/Passive/src/Pipe.cxx
+++ b/Detectors/Upgrades/ALICE3/Passive/src/Pipe.cxx
@@ -12,8 +12,8 @@
 #include "Alice3DetectorsPassive/Pipe.h"
 #include <DetectorsBase/Detector.h>
 #include <DetectorsBase/MaterialManager.h>
-#include <TGeoTube.h>
-#include <TVirtualMC.h>
+#include "TGeoTube.h"
+#include "TVirtualMC.h"
 #include "TGeoManager.h"        // for TGeoManager, gGeoManager
 #include "TGeoMaterial.h"       // for TGeoMaterial
 #include "TGeoMedium.h"         // for TGeoMedium
@@ -31,8 +31,6 @@ using namespace o2::passive;
 Alice3Pipe::Alice3Pipe() : Alice3PassiveBase{"Alice3PIPE", ""} {}
 Alice3Pipe::Alice3Pipe(const char* name,
                        const char* title,
-                       bool isTRKActivated,
-                       bool isFT3Activated,
                        float pipeRIn,
                        float pipeThickness,
                        float a3ipLength,
@@ -40,8 +38,6 @@ Alice3Pipe::Alice3Pipe(const char* name,
                        float vacuumVesselThickness,
                        float vacuumVesselASideLength)
   : Alice3PassiveBase{name, title},
-    mIsTRKActivated{isTRKActivated},
-    mIsFT3Activated{isFT3Activated},
     mPipeRIn{pipeRIn},
     mPipeThick{pipeThickness},
     mA3IPLength{a3ipLength},
@@ -85,7 +81,6 @@ void Alice3Pipe::ConstructGeometry()
   auto& matmgr = o2::base::MaterialManager::Instance();
 
   const TGeoMedium* kMedBe = matmgr.getTGeoMedium("ALICE3_PIPE_BE");
-  const TGeoMedium* kMedVac = matmgr.getTGeoMedium("ALICE3_PIPE_VACUUM");
 
   // Top volume
   TGeoVolume* top = gGeoManager->GetVolume("cave");
@@ -96,96 +91,11 @@ void Alice3Pipe::ConstructGeometry()
 
   // We split the naming of the parts if the beam pipe for ALICE 3 into parts
   // - pipe A Side
-  // - vacuum vessel (which hosts the primary vacuum and covers all C Side as well)
-  // - iris vacuum vessel (which hosts the secondary vacuum)
+  // - pipe C Side (which hosts the primary vacuum vessel and covers all C Side as well)
 
   // A3IP update
-  // Vacuum
-  Double_t pipeASideLength = mA3IPLength / 2. - mVacuumVesselThick - mVacuumVesselASideLength;
-  Double_t pipeCSideLength = mA3IPLength / 2. + mVacuumVesselASideLength;
-  TGeoTube* vacuumBasePipe = new TGeoTube("PIPEVACUUM_BASEsh", 0., mPipeRIn, mA3IPLength / 2.);
-  TGeoTube* vacuumBaseVacuumVessel = new TGeoTube("VACUUM_VESSELVACUUM_BASEsh", mPipeRIn, mVacuumVesselRIn, pipeCSideLength / 2.);
-
-  TGeoTranslation* posPipeCSide = new TGeoTranslation("PIPE_CSIDE_POSITION", 0, 0, mVacuumVesselASideLength - pipeCSideLength / 2.);
-  posPipeCSide->RegisterYourself();
-  // Excavate volumes from the vacuum such that there is place for the TRK barrel layers and FT3 disc layers of the IRIS tracker
-  // And the other passive shapes: coldplate, iris tracker vacuum vessel
-  TGeoCompositeShape* vacuumComposite;
-  TGeoVolume* vacuumVolume;
-  TString compositeFormula{"PIPEVACUUM_BASEsh+VACUUM_VESSELVACUUM_BASEsh:PIPE_CSIDE_POSITION"};
-  TString subtractorsFormula;
-
-  if (!mIsTRKActivated) {
-    std::vector<TGeoTube*> trkLayerShapes;
-
-    std::vector<std::array<float, 3>> layersQuotas = {std::array<float, 3>{0.5f, 50.f, 100.e-4}, // TODO: Set layers dynamically. {radius, zLen, thickness}
-                                                      std::array<float, 3>{1.2f, 50.f, 100.e-4},
-                                                      std::array<float, 3>{2.5f, 50.f, 100.e-4}};
-
-    for (auto iLayer{0}; iLayer < layersQuotas.size(); ++iLayer) { // Create TRK layers shapes
-      auto& layerData = layersQuotas[iLayer];
-      trkLayerShapes.emplace_back(new TGeoTube(Form("TRKLAYER_%dsh", iLayer), layerData[0], layerData[0] + layerData[2], layerData[1] / 2.));
-      if (iLayer != 0) {
-        subtractorsFormula += "+";
-      }
-      subtractorsFormula += Form("TRKLAYER_%dsh", iLayer);
-    }
-
-    // IRIS vacuum vessel and coldplate dimensions
-    float coldplateRIn = 2.6f;              // cm
-    float coldplateThick = 150.e-3;         // cm
-    float coldplateLength = 50.f;           // cm
-    float irisVacuumVesselInnerRIn = 0.48f; // cm
-    float irisVacuumVesselOuterRIn = coldplateRIn + coldplateThick;
-    float irisVacuumVesselLength = 70.f;   // cm
-    float irisVacuumVesselThick = 150.e-4; // cm
-
-    // Excavate vacuum for hosting cold plate and IRIS tracker
-    TGeoTube* coldPlate = new TGeoTube("TRK_COLDPLATEsh", coldplateRIn, coldplateRIn + coldplateThick, coldplateLength / 2.);
-    subtractorsFormula += "+TRK_COLDPLATEsh";
-
-    TGeoTube* irisVacuumVesselInner = new TGeoTube("TRK_IRISVACUUMVESSELINNERsh", irisVacuumVesselInnerRIn, irisVacuumVesselInnerRIn + irisVacuumVesselThick, irisVacuumVesselLength / 2.);
-    subtractorsFormula += "+TRK_IRISVACUUMVESSELINNERsh";
-
-    TGeoTube* irisVacuumVesselOuter = new TGeoTube("TRK_IRISVACUUMVESSELOUTERsh", irisVacuumVesselOuterRIn, irisVacuumVesselOuterRIn + irisVacuumVesselThick, irisVacuumVesselLength / 2.);
-    subtractorsFormula += "+TRK_IRISVACUUMVESSELOUTERsh";
-
-    TGeoTube* irisVacuumVesselWall = new TGeoTube("TRK_IRISVACUUMVESSELWALLsh", irisVacuumVesselInnerRIn, irisVacuumVesselOuterRIn + irisVacuumVesselThick, irisVacuumVesselThick / 2.);
-    TGeoTranslation* posIrisVacVWallNegZSide = new TGeoTranslation("IRISWALLNEGZ", 0., 0., -irisVacuumVesselLength / 2. - irisVacuumVesselThick / 2.);
-    posIrisVacVWallNegZSide->RegisterYourself();
-    subtractorsFormula += "+TRK_IRISVACUUMVESSELWALLsh:IRISWALLNEGZ";
-
-    TGeoTranslation* posIrisVacVWallPosZSide = new TGeoTranslation("IRISWALLPOSZ", 0., 0., irisVacuumVesselLength / 2. + irisVacuumVesselThick / 2.);
-    posIrisVacVWallPosZSide->RegisterYourself();
-    subtractorsFormula += "+TRK_IRISVACUUMVESSELWALLsh:IRISWALLPOSZ";
-  }
-
-  if (!mIsFT3Activated) {
-    std::vector<TGeoTube*> ft3DiscShapes;
-    std::vector<TGeoTranslation*> ft3DiscPositions;
-
-    std::vector<std::array<float, 4>> discsQuotas = {std::array<float, 4>{0.5f, 2.5f, 100.e-4, 26.}, // TODO: Set discs dynamically. {rIn, rOut, thickness, zpos}
-                                                     std::array<float, 4>{0.5f, 2.5f, 100.e-4, 30.},
-                                                     std::array<float, 4>{0.5f, 2.5f, 100.e-4, 34.},
-                                                     std::array<float, 4>{0.5f, 2.5f, 100.e-4, -26.},
-                                                     std::array<float, 4>{0.5f, 2.5f, 100.e-4, -30.},
-                                                     std::array<float, 4>{0.5f, 2.5f, 100.e-4, -34.}};
-    TString tempSubtractorsFormula = "";
-    if (!mIsTRKActivated) {
-      tempSubtractorsFormula = "+";
-    }
-    for (auto iDisc{0}; iDisc < discsQuotas.size(); ++iDisc) {
-      auto& discData = discsQuotas[iDisc];
-      ft3DiscShapes.emplace_back(new TGeoTube(Form("FT3DISC_%dsh", iDisc), discData[0], discData[1], discData[2] / 2.));
-      ft3DiscPositions.emplace_back(new TGeoTranslation(Form("t%d", iDisc), 0., 0., discData[3]));
-      ft3DiscPositions[iDisc]->RegisterYourself();
-      if (iDisc != 0) {
-        tempSubtractorsFormula += "+";
-      }
-      tempSubtractorsFormula += Form("FT3DISC_%dsh:t%d", iDisc, iDisc);
-    }
-    subtractorsFormula += tempSubtractorsFormula;
-  }
+  Double_t pipeASideLength = mA3IPLength / 2. - mVacuumVesselThick - mVacuumVesselASideLength / 2.;
+  Double_t pipeCSideLength = mA3IPLength / 2. + mVacuumVesselASideLength / 2.;
 
   // Pipe tubes
   TGeoTube* pipeASide = new TGeoTube("PIPE_Ash", mPipeRIn, mPipeRIn + mPipeThick, pipeASideLength / 2.);
@@ -193,37 +103,25 @@ void Alice3Pipe::ConstructGeometry()
   TGeoTube* vacuumVesselWall = new TGeoTube("VACUUM_VESSEL_WALLsh", mPipeRIn, mVacuumVesselRIn + mVacuumVesselThick, mVacuumVesselThick / 2.);
 
   // Pipe and vacuum vessel positions
-  TGeoTranslation* posVacuumVesselWall = new TGeoTranslation("WALL_POSITION", 0, 0, mVacuumVesselASideLength + mVacuumVesselThick / 2.);
-  posVacuumVesselWall->RegisterYourself();
-  TGeoTranslation* posPipeASide = new TGeoTranslation("PIPE_ASIDE_POSITION", 0, 0, mVacuumVesselASideLength + mVacuumVesselThick + pipeASideLength / 2.);
+  TGeoTranslation* posPipeASide = new TGeoTranslation("PIPE_ASIDE_POSITION", 0, 0, mVacuumVesselASideLength / 2. + mVacuumVesselThick + pipeASideLength / 2.);
   posPipeASide->RegisterYourself();
+  TGeoTranslation* posPipeCSide = new TGeoTranslation("PIPE_CSIDE_POSITION", 0, 0, mVacuumVesselASideLength / 2. - pipeCSideLength / 2.);
+  posPipeCSide->RegisterYourself();
+  TGeoTranslation* posVacuumVesselWall = new TGeoTranslation("WALL_POSITION", 0, 0, mVacuumVesselASideLength / 2. + mVacuumVesselThick / 2.);
+  posVacuumVesselWall->RegisterYourself();
 
   // Pipe composite shape and volume
   TString pipeCompositeFormula =
-    "VACUUM_VESSEL_WALLsh:WALL_POSITION"
-    "+PIPE_Ash:PIPE_ASIDE_POSITION"
-    "+PIPE_Csh:PIPE_CSIDE_POSITION";
-
-  if (subtractorsFormula.Length()) {
-    LOG(info) << "Subtractors formula before : " << subtractorsFormula;
-    subtractorsFormula = Form("-(%s)", subtractorsFormula.Data());
-    LOG(info) << "Subtractors formula after: " << subtractorsFormula;
-
-    vacuumComposite = new TGeoCompositeShape("VACUUM_BASEsh", (compositeFormula + subtractorsFormula).Data());
-    vacuumVolume = new TGeoVolume("VACUUM_BASE", vacuumComposite, kMedVac);
-  } else {
-    vacuumComposite = new TGeoCompositeShape("VACUUM_BASEsh", compositeFormula.Data());
-    vacuumVolume = new TGeoVolume("VACUUM_BASE", vacuumComposite, kMedVac);
-  }
+    "PIPE_Ash:PIPE_ASIDE_POSITION"
+    "+PIPE_Csh:PIPE_CSIDE_POSITION"
+    "+VACUUM_VESSEL_WALLsh:WALL_POSITION";
 
   TGeoCompositeShape* pipeComposite = new TGeoCompositeShape("A3IPsh", pipeCompositeFormula);
   TGeoVolume* pipeVolume = new TGeoVolume("A3IP", pipeComposite, kMedBe);
 
   // Add everything to the barrel
-  barrel->AddNode(vacuumVolume, 1, new TGeoTranslation(0, 30.f, 0));
   barrel->AddNode(pipeVolume, 1, new TGeoTranslation(0, 30.f, 0));
 
-  vacuumVolume->SetLineColor(kGreen + 3);
   pipeVolume->SetLineColor(kGreen + 3);
 }
 
@@ -236,15 +134,6 @@ void Alice3Pipe::createMaterials()
   float sxmgmx = 10.;
   o2::base::Detector::initFieldTrackingParams(isxfld, sxmgmx);
 
-  //
-  // Air
-  //
-  float aAir[4] = {12.0107, 14.0067, 15.9994, 39.948};
-  float zAir[4] = {6., 7., 8., 18.};
-  float wAir[4] = {0.000124, 0.755267, 0.231781, 0.012827};
-  float dAir = 1.20479E-3;
-  float dAir1 = 1.20479E-11;
-
   // ****************
   //     Defines tracking media parameters.
   //
@@ -258,13 +147,8 @@ void Alice3Pipe::createMaterials()
   auto& matmgr = o2::base::MaterialManager::Instance();
 
   // Beryllium
-  matmgr.Material("ALICE3_PIPE", 5, "BERILLIUM$", 9.01, 4., 1.848, 35.3, 36.7);
+  matmgr.Material("ALICE3_PIPE", 5, "BERYLLIUM$", 9.01, 4., 1.848, 35.3, 36.7);
   matmgr.Medium("ALICE3_PIPE", 5, "BE", 5, 0, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
-
-  // Vacuum
-  matmgr.Mixture("ALICE3_PIPE", 16, "VACUUM$ ", aAir, zAir, dAir1, 4, wAir);
-
-  matmgr.Medium("ALICE3_PIPE", 16, "VACUUM", 16, 0, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
 }
 
 // ----------------------------------------------------------------------------
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index 9ea4bd1072d91..63c95b1e6b2f6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -29,6 +29,8 @@ enum eLayout {
 struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   std::string configFile = "";
   float serviceTubeX0 = 0.02f; // X0 Al2O3
+  Bool_t irisOpen = false;
+
   eLayout layoutML = kCylinder; // Type of segmentation for the middle layers
   eLayout layoutOL = kCylinder; // Type of segmentation for the outer layers
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
index 7706c0e10d778..c21b7b9aebbf6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
@@ -13,6 +13,9 @@ o2_add_library(TRKSimulation
                SOURCES src/TRKLayer.cxx
                        src/Detector.cxx
                        src/TRKServices.cxx
+                       src/TRKPetalCase.cxx
+                       src/TRKPetalLayer.cxx
+                       src/TRKPetalDisk.cxx
                PUBLIC_LINK_LIBRARIES O2::TRKBase
                                      O2::FT3Simulation
                                      O2::ITSMFTSimulation)
@@ -20,4 +23,7 @@ o2_add_library(TRKSimulation
 o2_target_root_dictionary(TRKSimulation
                           HEADERS include/TRKSimulation/Detector.h
                                   include/TRKSimulation/TRKLayer.h
-                                  include/TRKSimulation/TRKServices.h)
\ No newline at end of file
+                                  include/TRKSimulation/TRKServices.h
+                                  include/TRKSimulation/TRKPetalCase.h
+                                  include/TRKSimulation/TRKPetalLayer.h
+                                  include/TRKSimulation/TRKPetalDisk.h)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
index 5b777641dbe99..31f3da7a00bb4 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
@@ -17,6 +17,7 @@
 
 #include "TRKSimulation/TRKLayer.h"
 #include "TRKSimulation/TRKServices.h"
+#include "TRKSimulation/TRKPetalCase.h"
 #include "TRKBase/GeometryTGeo.h"
 
 #include <TLorentzVector.h>
@@ -87,7 +88,11 @@ class Detector : public o2::base::DetImpl<Detector>
   GeometryTGeo* mGeometryTGeo;         //!
   std::vector<o2::itsmft::Hit>* mHits; // ITSMFT ones for the moment
   std::vector<TRKLayer> mLayers;
-  TRKServices mServices;
+  TRKServices mServices;                 // Houses the services of the TRK, but not the Iris tracker
+  std::vector<TRKPetalCase> mPetalCases; // Houses the Iris tracker and its services. Created fully in the beam pipe
+
+  std::vector<std::string> mFirstOrLastLayers; // Names of the first or last layers
+  bool InsideFirstOrLastLayer(std::string layerName);
 
   void defineSensitiveVolumes();
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalCase.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalCase.h
new file mode 100644
index 0000000000000..cd45cc98fd177
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalCase.h
@@ -0,0 +1,93 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_TRK_PETALCASE_H
+#define ALICEO2_TRK_PETALCASE_H
+
+#include <Rtypes.h>
+
+#include "TRKSimulation/TRKPetalLayer.h"
+#include "TRKSimulation/TRKPetalDisk.h"
+#include "TGeoCompositeShape.h"
+
+namespace o2
+{
+namespace trk
+{
+class TRKPetalCase
+{
+ public:
+  TRKPetalCase() = default;
+  TRKPetalCase(Int_t number, TGeoVolume* motherVolume, Bool_t irisOpen);
+  ~TRKPetalCase() = default;
+
+  // Sensitive volume list
+  std::vector<TRKPetalLayer> mPetalLayers;
+  std::vector<TRKPetalDisk> mPetalDisks;
+
+  auto getPetalCaseName() { return mPetalCaseName; }
+  TString getFullName();
+
+ private:
+  void constructCase(TGeoVolume* motherVolume);
+  void constructColdPlate(TGeoVolume* motherVolume);
+  void constructDetectionPetals(TGeoVolume* motherVolume);
+  void addDetectionPetelsToFullComposite();
+
+  void addToPetalCaseComposite(TString shape) { mFullCompositeFormula += ("+" + shape); }
+
+  Int_t mPetalCaseNumber; // Used to determine rotation and position. 0-3
+  Bool_t mOpenState;      // At injection energy, the iris tracker is in the open position. During stable beams, it is closed
+
+  TString mPetalCaseName;
+  TString mFullCompositeFormula; // Used to excavate the petal and all its components from the vacuum
+
+  // Center position of the petal case. 0,0,0 at stable beams (a.k.a. closed state)
+  Double_t mXPos, mYPos, mZPos;
+
+  Double_t mWallThickness;   // cm // Assume all the walls have the same thickness for now
+  Double_t mRIn;             // cm
+  Double_t mROut;            // cm
+  Double_t mRInOpenState;    // cm
+  Double_t mPetalCaseLength; // cm
+
+  Double_t mAngularCoverageAzimuthalWall; // Rad // Angular coverage of azimuthal part of wall (equivalent to that of the sensitive volumes)
+  Double_t mAngularCoverageRadialWall;    // Rad // Angular coverage of radial part of wall
+  Double_t mToDeg;
+
+  // Petal case parts -> In one composite shape
+  TGeoTubeSeg* mInnerAzimuthalWall;
+  TGeoTubeSeg* mOuterAzimuthalWall;
+  TGeoTubeSeg* mRadialWall;
+  TGeoTubeSeg* mForwardWall;
+
+  TGeoRotation* mAzimuthalWallRot;
+  TGeoRotation* mRadialWall1Rot;
+  TGeoRotation* mRadialWall2Rot;
+
+  TGeoCombiTrans* mAzimuthalWallCombiTrans;
+  TGeoCombiTrans* mRadialWall1CombiTrans;
+  TGeoCombiTrans* mRadialWall2CombiTrans;
+  TGeoCombiTrans* mForwardWall1CombiTrans;
+  TGeoCombiTrans* mForwardWall2CombiTrans;
+
+  TGeoVolume* mPetalCaseVolume;
+
+  // Cold plate
+  TGeoTubeSeg* mColdPlate;
+  TGeoVolume* mColdPlateVolume;
+
+  ClassDef(TRKPetalCase, 1);
+};
+
+} // namespace trk
+} // namespace o2
+#endif // ALICEO2_TRK_PETALCASE_H
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalDisk.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalDisk.h
new file mode 100644
index 0000000000000..465f52eb8d41b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalDisk.h
@@ -0,0 +1,64 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TRKPetalDisk.h
+/// \brief Definition of the TRKPetalDisk class
+
+#ifndef ALICEO2_TRK_PETAL_DISK_H_
+#define ALICEO2_TRK_PETAL_DISK_H_
+
+#include "TGeoManager.h"       // for gGeoManager
+#include "Rtypes.h"            // for Double_t, Int_t, Bool_t, etc
+#include <fairlogger/Logger.h> // for LOG
+
+namespace o2
+{
+namespace trk
+{
+
+/// This class defines the Geometry for the TRK Disk TGeo.
+class TRKPetalDisk
+{
+ public:
+  TRKPetalDisk() = default;
+  TRKPetalDisk(Int_t diskNumber, std::string diskName, Float_t z, Float_t rIn, Float_t rOut, Float_t angularCoverage, Float_t Diskx2X0);
+  ~TRKPetalDisk() = default;
+
+  auto getInnerRadius() const { return mInnerRadius; }
+  auto getOuterRadius() const { return mOuterRadius; }
+  auto getThickness() const { return mChipThickness; }
+  auto getAngularCoverage() const { return mAngularCoverage; }
+  auto getZ() const { return mZ; }
+  auto getx2X0() const { return mx2X0; }
+  auto getName() const { return mDiskName; }
+  auto getSensorName() const { return mSensorName; }
+
+  /// Creates the actual Disk and places inside its mother volume
+  /// \param motherVolume the TGeoVolume owing the volume structure
+  void createDisk(TGeoVolume* motherVolume, TGeoCombiTrans* combiTrans);
+
+ private:
+  Int_t mDiskNumber = -1; ///< Current disk number
+  std::string mDiskName;  ///< Current disk name
+  std::string mSensorName;
+  Double_t mInnerRadius; ///< Inner radius of this disk
+  Double_t mOuterRadius; ///< Outer radius of this disk
+  Double_t mAngularCoverage;
+  Double_t mZ;             ///< Z position of the disk
+  Double_t mChipThickness; ///< Chip thickness
+  Double_t mx2X0;          ///< Disk material budget x/X0
+
+  ClassDef(TRKPetalDisk, 1);
+};
+} // namespace trk
+} // namespace o2
+
+#endif // ALICEO2_TRK_PETAL_DISK_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalLayer.h
new file mode 100644
index 0000000000000..4e7a7735d51f0
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalLayer.h
@@ -0,0 +1,61 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_TRK_PETAL_LAYER_H
+#define ALICEO2_TRK_PETAL_LAYER_H
+
+#include "TGeoManager.h"
+#include <Rtypes.h>
+#include "TGeoTube.h"
+
+#include "TRKBase/TRKBaseParam.h"
+
+namespace o2
+{
+namespace trk
+{
+class TRKPetalLayer
+{
+ public:
+  TRKPetalLayer() = default;
+  TRKPetalLayer(Int_t layerNumber, std::string layerName, Float_t rIn, Float_t angularCoverage, Float_t zLength, Float_t layerX2X0);
+  ~TRKPetalLayer() = default;
+
+  auto getInnerRadius() const { return mInnerRadius; }
+  auto getAngularCoverage() const { return mAngularCoverage; }
+  auto getZLength() { return mZ; }
+  auto getx2X0() const { return mX2X0; }
+  auto getChipThickness() const { return mChipThickness; }
+  auto getNumber() const { return mLayerNumber; }
+  auto getName() const { return mLayerName; }
+  auto getSensorName() const { return mSensorName; }
+
+  void createLayer(TGeoVolume* motherVolume, TGeoCombiTrans* combiTrans);
+
+ private:
+  Int_t mLayerNumber;
+  std::string mLayerName;
+  std::string mSensorName;
+  Float_t mInnerRadius;
+  Float_t mZ;
+  Float_t mX2X0;
+  Float_t mChipThickness;
+  Float_t mModuleWidth;     // u.m. = cm
+  Float_t mAngularCoverage; // rad
+
+  TGeoTubeSeg* mLayer;
+
+  ClassDef(TRKPetalLayer, 1);
+};
+
+} // namespace trk
+} // namespace o2
+#endif // ALICEO2_TRK_PETAL_LAYER_H
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
index 4a12be8572ed5..8dd3968743024 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
@@ -46,15 +46,18 @@ class TRKServices : public FairModule
   // ===================================================  ---> createOuterServices
  public:
   TRKServices() = default;
-  TRKServices(float rMin, float zLength, float thickness);
   void createMaterials();
   void createServices(TGeoVolume* motherVolume);
-  void createColdplate(TGeoVolume* motherVolume);
   void createMiddleServices(TGeoVolume* motherVolume);
   void createOuterDisksServices(TGeoVolume* motherVolume);
   void createOuterBarrelServices(TGeoVolume* motherVolume);
+  void createVacuumCompositeShape();
+  void excavateFromVacuum(TString shapeToExcavate);
+  void registerVacuum(TGeoVolume* motherVolume);
 
  protected:
+  // Vacuum
+  TString mVacuumCompositeFormula;
   // Coldplate
   float mColdPlateRMin;      // cm
   float mColdPlateZLength;   // cm
@@ -70,11 +73,6 @@ class TRKServices : public FairModule
   float mMiddleDiskThickness = 1.0;                      // cm
   std::vector<float> mCableFanWeights = {0.5, 0.3, 0.2}; // relative weights of the fan layers
 
-  // IRIS vacuum vessel
-  float mRInIRISVacV;       // cm
-  float mROutIRISVacV;      // cm
-  float mZLengthIRISVacV;   // cm
-  float mThicknessIRISVacV; // cm
   ClassDefOverride(TRKServices, 1);
 };
 } // namespace trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index b9015ce578caf..9b8ffc07b2d0e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -80,17 +80,17 @@ void Detector::configDefault()
   mLayers.clear();
 
   LOGP(warning, "Loading Scoping Document configuration for ALICE3 TRK");
-  mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 0.5f, 50.f, 100.e-4);
-  mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 1.2f, 50.f, 100.e-4);
-  mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 2.5f, 50.f, 100.e-4);
-  mLayers.emplace_back(3, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(3)}, 3.78f, 124.f, 100.e-3);
-  mLayers.emplace_back(4, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(4)}, 7.f, 124.f, 100.e-3);
-  mLayers.emplace_back(5, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(5)}, 12.f, 124.f, 100.e-3);
-  mLayers.emplace_back(6, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(6)}, 20.f, 124.f, 100.e-3);
-  mLayers.emplace_back(7, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(7)}, 30.f, 124.f, 100.e-3);
-  mLayers.emplace_back(8, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(8)}, 45.f, 258.f, 100.e-3);
-  mLayers.emplace_back(9, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(9)}, 60.f, 258.f, 100.e-3);
-  mLayers.emplace_back(10, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(10)}, 80.f, 258.f, 100.e-3);
+  // mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 0.5f, 50.f, 100.e-4);
+  // mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 1.2f, 50.f, 100.e-4);
+  // mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 2.5f, 50.f, 100.e-4);
+  mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 3.78f, 124.f, 100.e-3);
+  mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 7.f, 124.f, 100.e-3);
+  mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 12.f, 124.f, 100.e-3);
+  mLayers.emplace_back(3, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(3)}, 20.f, 124.f, 100.e-3);
+  mLayers.emplace_back(4, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(4)}, 30.f, 124.f, 100.e-3);
+  mLayers.emplace_back(5, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(5)}, 45.f, 258.f, 100.e-3);
+  mLayers.emplace_back(6, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(6)}, 60.f, 258.f, 100.e-3);
+  mLayers.emplace_back(7, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(7)}, 80.f, 258.f, 100.e-3);
 }
 
 void Detector::buildTRKNewVacuumVessel()
@@ -103,31 +103,32 @@ void Detector::buildTRKNewVacuumVessel()
   mLayers.clear();
 
   LOGP(warning, "Loading \"After Upgrade Days March 2024\" configuration for ALICE3 TRK");
-  mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 0.5f, 50.f, 100.e-4);
-  mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 1.2f, 50.f, 100.e-4);
-  mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 2.5f, 50.f, 100.e-4);
-  mLayers.emplace_back(3, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(3)}, 7.f, 124.f, 100.e-3);
-  mLayers.emplace_back(4, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(4)}, 9.f, 124.f, 100.e-3);
-  mLayers.emplace_back(5, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(5)}, 12.f, 124.f, 100.e-3);
-  mLayers.emplace_back(6, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(6)}, 20.f, 124.f, 100.e-3);
-  mLayers.emplace_back(7, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(7)}, 30.f, 124.f, 100.e-3);
-  mLayers.emplace_back(8, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(8)}, 45.f, 258.f, 100.e-3);
-  mLayers.emplace_back(9, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(9)}, 60.f, 258.f, 100.e-3);
-  mLayers.emplace_back(10, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(10)}, 80.f, 258.f, 100.e-3);
+  // mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 0.5f, 50.f, 100.e-4);
+  // mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 1.2f, 50.f, 100.e-4);
+  // mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 2.5f, 50.f, 100.e-4);
+  mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 7.f, 124.f, 100.e-3);
+  LOGP(info, "TRKLayer created. Name: {}", std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)});
+  mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 9.f, 124.f, 100.e-3);
+  mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 12.f, 124.f, 100.e-3);
+  mLayers.emplace_back(3, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(3)}, 20.f, 124.f, 100.e-3);
+  mLayers.emplace_back(4, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(4)}, 30.f, 124.f, 100.e-3);
+  mLayers.emplace_back(5, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(5)}, 45.f, 258.f, 100.e-3);
+  mLayers.emplace_back(6, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(6)}, 60.f, 258.f, 100.e-3);
+  mLayers.emplace_back(7, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(7)}, 80.f, 258.f, 100.e-3);
 
   auto& trkPars = TRKBaseParam::Instance();
 
   // Middle layers
+  mLayers[0].setLayout(trkPars.layoutML);
+  mLayers[1].setLayout(trkPars.layoutML);
+  mLayers[2].setLayout(trkPars.layoutML);
   mLayers[3].setLayout(trkPars.layoutML);
-  mLayers[4].setLayout(trkPars.layoutML);
-  mLayers[5].setLayout(trkPars.layoutML);
-  mLayers[6].setLayout(trkPars.layoutML);
 
   // Outer tracker
+  mLayers[4].setLayout(trkPars.layoutOL);
+  mLayers[5].setLayout(trkPars.layoutOL);
+  mLayers[6].setLayout(trkPars.layoutOL);
   mLayers[7].setLayout(trkPars.layoutOL);
-  mLayers[8].setLayout(trkPars.layoutOL);
-  mLayers[9].setLayout(trkPars.layoutOL);
-  mLayers[10].setLayout(trkPars.layoutOL);
 }
 
 void Detector::configFromFile(std::string fileName)
@@ -173,7 +174,7 @@ void Detector::configToFile(std::string fileName)
 
 void Detector::configServices()
 {
-  mServices = TRKServices{2.6f, 50.f, 150.e-3};
+  mServices = TRKServices();
 }
 
 void Detector::createMaterials()
@@ -237,6 +238,14 @@ void Detector::createGeometry()
 
   // Add service for inner tracker
   mServices.createServices(vTRK);
+  mPetalCases.clear();
+  // Add petal cases (the sensitive layers inside the petal cases get constructed here too)
+  auto& trkPars = TRKBaseParam::Instance();
+  for (Int_t petalCaseNumber = 0; petalCaseNumber < 4; ++petalCaseNumber) {
+    mPetalCases.emplace_back(petalCaseNumber, vTRK, trkPars.irisOpen);
+    mServices.excavateFromVacuum(mPetalCases[petalCaseNumber].getFullName());
+  }
+  mServices.registerVacuum(vTRK);
 }
 
 void Detector::InitializeO2Detector()
@@ -254,9 +263,35 @@ void Detector::defineSensitiveVolumes()
   TString volumeName;
   LOGP(info, "Adding TRK Sensitive Volumes");
 
+  // Add petal case sensitive volumes
+  for (int petalCase = 0; petalCase < 4; ++petalCase) {
+    // Petal layers
+    for (int petalLayer = 0; petalLayer < mPetalCases[petalCase].mPetalLayers.size(); ++petalLayer) {
+      volumeName = mPetalCases[petalCase].mPetalLayers[petalLayer].getSensorName();
+      if (petalLayer == 0) {
+        mFirstOrLastLayers.push_back(volumeName.Data());
+      }
+      LOGP(info, "Trying {}", volumeName.Data());
+      v = geoManager->GetVolume(volumeName.Data());
+      LOGP(info, "Adding TRK Sensitive Volume {}", v->GetName());
+      AddSensitiveVolume(v);
+    }
+    // Petal disks
+    for (int petalDisk = 0; petalDisk < mPetalCases[petalCase].mPetalDisks.size(); ++petalDisk) {
+      volumeName = mPetalCases[petalCase].mPetalDisks[petalDisk].getSensorName();
+      LOGP(info, "Trying {}", volumeName.Data());
+      v = geoManager->GetVolume(volumeName.Data());
+      LOGP(info, "Adding TRK Sensitive Volume {}", v->GetName());
+      AddSensitiveVolume(v);
+    }
+  }
+
   // The names of the TRK sensitive volumes have the format: TRKLayer(0...mLayers.size()-1)
   for (int j{0}; j < mLayers.size(); j++) {
     volumeName = GeometryTGeo::getTRKSensorPattern() + TString::Itoa(j, 10);
+    if (j == mLayers.size() - 1) {
+      mFirstOrLastLayers.push_back(volumeName.Data());
+    }
     LOGP(info, "Trying {}", volumeName.Data());
     v = geoManager->GetVolume(volumeName.Data());
     LOGP(info, "Adding TRK Sensitive Volume {}", v->GetName());
@@ -284,6 +319,18 @@ void Detector::Reset()
   }
 }
 
+bool Detector::InsideFirstOrLastLayer(std::string layerName)
+{
+  bool inside = false;
+  for (auto& firstOrLastLayer : mFirstOrLastLayers) {
+    if (firstOrLastLayer == layerName) {
+      inside = true;
+      break;
+    }
+  }
+  return inside;
+}
+
 bool Detector::ProcessHits(FairVolume* vol)
 {
   // This method is called from the MC stepping
@@ -296,7 +343,8 @@ bool Detector::ProcessHits(FairVolume* vol)
 
   // Is it needed to keep a track reference when the outer ITS volume is encountered?
   auto stack = (o2::data::Stack*)fMC->GetStack();
-  if (fMC->IsTrackExiting() && (lay == 0 || lay == mLayers.size() - 1)) {
+  // if (fMC->IsTrackExiting() && (lay == 0 || lay == mLayers.size() - 1)) {
+  if (fMC->IsTrackExiting() && InsideFirstOrLastLayer(vol->GetName())) {
     // Keep the track refs for the innermost and outermost layers only
     o2::TrackReference tr(*fMC, GetDetId());
     tr.setTrackID(stack->GetCurrentTrackNumber());
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalCase.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalCase.cxx
new file mode 100644
index 0000000000000..c729d7d1ec4dd
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalCase.cxx
@@ -0,0 +1,202 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKSimulation/TRKPetalCase.h"
+#include "TRKBase/GeometryTGeo.h"
+#include <DetectorsBase/MaterialManager.h>
+
+#include "Framework/Logger.h"
+
+#include "TGeoTube.h"
+#include "TGeoMatrix.h"
+#include "TGeoCompositeShape.h"
+#include "TGeoVolume.h"
+#include "TString.h"
+#include "TMath.h"
+
+namespace o2
+{
+namespace trk
+{
+TRKPetalCase::TRKPetalCase(Int_t number, TGeoVolume* motherVolume, Bool_t irisOpen) : mPetalCaseNumber(number), mOpenState(irisOpen)
+{
+
+  mWallThickness = .15e-1; // cm // Assume all the walls have the same thickness for now.
+  mRIn = 0.48;             // cm
+  mROut = 3;               // cm
+  mRInOpenState = 1.5;     // cm
+  mPetalCaseLength = 70.;  // cm
+
+  // Calculate angular coverages of azimuthal part of wall (equivalent to that of the sensitive volumes)
+  mAngularCoverageAzimuthalWall = (0.25 * (2 * mRIn * TMath::Pi()) - 2 * mWallThickness) / mRIn;
+  mAngularCoverageRadialWall = mWallThickness / mRIn;
+  mToDeg = 180 / TMath::Pi();
+
+  // Calculate the center of the petal (x_c, y_c, z_c) based on whether it is open or not
+  mZPos = 0;
+  if (mOpenState) {
+    Double_t rHalfPetal = 0.5 * (mRIn + mROut);
+    Double_t rOpenStateCenter = TMath::Sqrt(rHalfPetal * rHalfPetal + mRInOpenState * mRInOpenState);
+    mXPos = rOpenStateCenter * TMath::Cos(0.25 * TMath::Pi() + (mPetalCaseNumber - 1) * 0.5 * TMath::Pi());
+    mYPos = rOpenStateCenter * TMath::Sin(0.25 * TMath::Pi() + (mPetalCaseNumber - 1) * 0.5 * TMath::Pi());
+  } else {
+    mXPos = 0.;
+    mYPos = 0.;
+  }
+
+  // Make the petal case
+  constructCase(motherVolume);
+  // Make coldplate
+  constructColdPlate(motherVolume);
+  // Add the detection petals (quarter disks and barrel layers)
+  constructDetectionPetals(motherVolume);
+}
+
+TString TRKPetalCase::getFullName()
+{
+  TString fullCompositeName = Form("PETALCASE%d_FULLCOMPOSITE", mPetalCaseNumber);
+  TGeoCompositeShape* fullCompositeShape = new TGeoCompositeShape(fullCompositeName, mFullCompositeFormula);
+  return fullCompositeName;
+}
+
+void TRKPetalCase::constructCase(TGeoVolume* motherVolume)
+{
+
+  // Petal case parts in TGeoTubeSeg
+  mInnerAzimuthalWall = new TGeoTubeSeg(Form("PETAL%d_INNER_AZIMUTHAL_WALL", mPetalCaseNumber), mRIn, mRIn + mWallThickness, mPetalCaseLength / 2., -0.5 * mAngularCoverageAzimuthalWall * mToDeg, 0.5 * mAngularCoverageAzimuthalWall * mToDeg);
+  mOuterAzimuthalWall = new TGeoTubeSeg(Form("PETAL%d_OUTER_AZIMUTHAL_WALL", mPetalCaseNumber), mROut, mROut + mWallThickness, mPetalCaseLength / 2., -0.5 * mAngularCoverageAzimuthalWall * mToDeg, 0.5 * mAngularCoverageAzimuthalWall * mToDeg);
+  mRadialWall = new TGeoTubeSeg(Form("PETAL%d_RADIAL_WALL", mPetalCaseNumber), mRIn, mROut + mWallThickness, mPetalCaseLength / 2., -0.5 * mAngularCoverageRadialWall * mToDeg, 0.5 * mAngularCoverageRadialWall * mToDeg);
+  mForwardWall = new TGeoTubeSeg(Form("PETAL%d_FORWARD_WALL", mPetalCaseNumber), mRIn, mROut + mWallThickness, mWallThickness / 2., -0.5 * (mAngularCoverageAzimuthalWall + 2 * mAngularCoverageRadialWall) * mToDeg, 0.5 * (mAngularCoverageAzimuthalWall + 2 * mAngularCoverageRadialWall) * mToDeg);
+
+  // Rotate to correct section : 0-3
+  mAzimuthalWallRot = new TGeoRotation((TString)Form("PETAL%d_AZIMUTHAL_WALL_ROT", mPetalCaseNumber), (mPetalCaseNumber * 0.5 * TMath::Pi() + 0.5 * mAngularCoverageAzimuthalWall + mAngularCoverageRadialWall) * mToDeg, 0., 0.);
+  mAzimuthalWallRot->RegisterYourself();
+  mRadialWall1Rot = new TGeoRotation((TString)Form("PETAL%d_RADIAL_WALL1_ROT", mPetalCaseNumber), (mPetalCaseNumber * 0.5 * TMath::Pi() + 0.5 * mAngularCoverageRadialWall) * mToDeg, 0., 0.);
+  mRadialWall1Rot->RegisterYourself();
+  mRadialWall2Rot = new TGeoRotation((TString)Form("PETAL%d_RADIAL_WALL2_ROT", mPetalCaseNumber), (mPetalCaseNumber * 0.5 * TMath::Pi() + mAngularCoverageAzimuthalWall + 1.5 * mAngularCoverageRadialWall) * mToDeg, 0., 0.);
+  mRadialWall2Rot->RegisterYourself();
+
+  // Place to correct position (open or closed)
+  mAzimuthalWallCombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_AZIMUTHAL_WALL_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, mZPos, mAzimuthalWallRot);
+  mAzimuthalWallCombiTrans->RegisterYourself();
+  mRadialWall1CombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_RADIAL_WALL1_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, mZPos, mRadialWall1Rot);
+  mRadialWall1CombiTrans->RegisterYourself();
+  mRadialWall2CombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_RADIAL_WALL2_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, mZPos, mRadialWall2Rot);
+  mRadialWall2CombiTrans->RegisterYourself();
+  mForwardWall1CombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_FORWARD_WALL1_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, (mPetalCaseLength + mWallThickness) / 2., mAzimuthalWallRot);
+  mForwardWall1CombiTrans->RegisterYourself();
+  mForwardWall2CombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_FORWARD_WALL2_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, -(mPetalCaseLength + mWallThickness) / 2., mAzimuthalWallRot);
+  mForwardWall2CombiTrans->RegisterYourself();
+
+  TString petalCaseCompositeFormula = (TString)Form("PETAL%d_INNER_AZIMUTHAL_WALL:PETAL%d_AZIMUTHAL_WALL_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_OUTER_AZIMUTHAL_WALL:PETAL%d_AZIMUTHAL_WALL_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_RADIAL_WALL:PETAL%d_RADIAL_WALL1_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_RADIAL_WALL:PETAL%d_RADIAL_WALL2_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_FORWARD_WALL:PETAL%d_FORWARD_WALL1_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_FORWARD_WALL:PETAL%d_FORWARD_WALL2_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber);
+
+  TGeoCompositeShape* petalCaseComposite = new TGeoCompositeShape((TString)Form("PETALCASE%dsh", mPetalCaseNumber), petalCaseCompositeFormula);
+  mFullCompositeFormula = petalCaseComposite->GetName();
+  auto& matmgr = o2::base::MaterialManager::Instance();
+  const TGeoMedium* kMedBe = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_BERYLLIUM");
+
+  mPetalCaseName = Form("PETALCASE%d", mPetalCaseNumber);
+  mPetalCaseVolume = new TGeoVolume(mPetalCaseName, petalCaseComposite, kMedBe);
+  mPetalCaseVolume->SetVisibility(1);
+  mPetalCaseVolume->SetLineColor(kGray);
+
+  LOGP(info, "Creating IRIS Tracker vacuum petal case {}", mPetalCaseNumber);
+  LOGP(info, "Inserting {} in {} ", mPetalCaseVolume->GetName(), motherVolume->GetName());
+  motherVolume->AddNode(mPetalCaseVolume, 1, nullptr);
+}
+
+void TRKPetalCase::constructColdPlate(TGeoVolume* motherVolume)
+{
+  Double_t coldPlateRadius = 2.6;     // cm
+  Double_t coldPlateThickness = 0.15; // cm
+  Double_t coldPlateLength = 50.;     // cm
+
+  mColdPlate = new TGeoTubeSeg((TString)Form("PETAL%d_COLDPLATE", mPetalCaseNumber), coldPlateRadius, coldPlateRadius + coldPlateThickness, coldPlateLength / 2., -0.5 * mAngularCoverageAzimuthalWall * mToDeg, 0.5 * mAngularCoverageAzimuthalWall * mToDeg);
+  auto& matmgr = o2::base::MaterialManager::Instance();
+  const TGeoMedium* medCeramic = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_CERAMIC");
+  mColdPlateVolume = new TGeoVolume(Form("COLDPLATE%d", mPetalCaseNumber), mColdPlate, medCeramic);
+
+  TString coldPlateCompositeFormula = mColdPlate->GetName();
+  coldPlateCompositeFormula += ":";
+  coldPlateCompositeFormula += mAzimuthalWallCombiTrans->GetName();
+  addToPetalCaseComposite(coldPlateCompositeFormula);
+
+  mColdPlateVolume->SetVisibility(1);
+  mColdPlateVolume->SetLineColor(kGray);
+
+  LOGP(info, "Creating cold plate service");
+  LOGP(info, "Inserting {} in {} ", mColdPlateVolume->GetName(), motherVolume->GetName());
+  motherVolume->AddNode(mColdPlateVolume, 1, mAzimuthalWallCombiTrans);
+}
+
+void TRKPetalCase::constructDetectionPetals(TGeoVolume* motherVolume)
+{
+  // Add petal layers
+  // layerNumber, layerName, rIn, angularCoverage, zLength, layerx2X0
+  mPetalLayers.emplace_back(0, Form("%s_LAYER%d", mPetalCaseName.Data(), 0), 0.5f, mAngularCoverageAzimuthalWall, 50.f, 1.e-3);
+  mPetalLayers.emplace_back(1, Form("%s_LAYER%d", mPetalCaseName.Data(), 1), 1.2f, mAngularCoverageAzimuthalWall, 50.f, 1.e-3);
+  mPetalLayers.emplace_back(2, Form("%s_LAYER%d", mPetalCaseName.Data(), 2), 2.5f, mAngularCoverageAzimuthalWall, 50.f, 1.e-3);
+  for (Int_t i = 0; i < mPetalLayers.size(); ++i) {
+    mPetalLayers[i].createLayer(motherVolume, mAzimuthalWallCombiTrans);
+  }
+
+  // Add petal disks
+  // diskNumber, diskName, zPos, rIn, rOut, angularCoverage, diskx2X0
+  mPetalDisks.emplace_back(0, Form("%s_DISK%d", mPetalCaseName.Data(), 0), 26., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
+  mPetalDisks.emplace_back(1, Form("%s_DISK%d", mPetalCaseName.Data(), 1), 30., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
+  mPetalDisks.emplace_back(2, Form("%s_DISK%d", mPetalCaseName.Data(), 2), 34., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
+  mPetalDisks.emplace_back(3, Form("%s_DISK%d", mPetalCaseName.Data(), 3), -26., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
+  mPetalDisks.emplace_back(4, Form("%s_DISK%d", mPetalCaseName.Data(), 4), -30., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
+  mPetalDisks.emplace_back(5, Form("%s_DISK%d", mPetalCaseName.Data(), 5), -34., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
+  for (Int_t i = 0; i < mPetalDisks.size(); ++i) {
+    mPetalDisks[i].createDisk(motherVolume, mAzimuthalWallCombiTrans);
+  }
+
+  addDetectionPetelsToFullComposite();
+}
+
+void TRKPetalCase::addDetectionPetelsToFullComposite()
+{
+  for (Int_t i = 0; i < mPetalLayers.size(); ++i) {
+    Double_t zLength = mPetalLayers[i].getZLength();
+    Double_t rIn = mPetalLayers[i].getInnerRadius();
+    Double_t thickness = mPetalLayers[i].getChipThickness();
+    Double_t angularCoverage = mPetalLayers[i].getAngularCoverage();
+    TGeoTubeSeg* layerForExcavation = new TGeoTubeSeg(Form("PETALCASE%d_EXCAVATIONLAYER%d", mPetalCaseNumber, i), rIn, rIn + thickness, zLength / 2., -0.5 * angularCoverage * mToDeg, 0.5 * angularCoverage * mToDeg);
+
+    TString layerForExcavationCompositeFormula = layerForExcavation->GetName();
+    layerForExcavationCompositeFormula += ":";
+    layerForExcavationCompositeFormula += mAzimuthalWallCombiTrans->GetName();
+    addToPetalCaseComposite(layerForExcavationCompositeFormula);
+  }
+
+  for (Int_t i = 0; i < mPetalDisks.size(); ++i) {
+    Double_t zPos = mPetalDisks[i].getZ();
+    Double_t rIn = mPetalDisks[i].getInnerRadius();
+    Double_t rOut = mPetalDisks[i].getOuterRadius();
+    Double_t thickness = mPetalDisks[i].getThickness();
+    Double_t angularCoverage = mPetalDisks[i].getAngularCoverage();
+    TGeoTubeSeg* diskForExcavation = new TGeoTubeSeg(Form("PETALCASE%d_EXCAVATIONDISK%d", mPetalCaseNumber, i), rIn, rOut, thickness / 2., -0.5 * angularCoverage * mToDeg, 0.5 * angularCoverage * mToDeg);
+    TGeoCombiTrans* diskForExcavationCombiTrans = new TGeoCombiTrans(*(mAzimuthalWallCombiTrans->MakeClone())); // Copy from petal case
+    diskForExcavationCombiTrans->SetName((TString)Form("PETALCASE%d_EXCAVATIONDISK%d_COMBITRANS", mPetalCaseNumber, i));
+    diskForExcavationCombiTrans->SetDz(zPos); // Overwrite z location
+    diskForExcavationCombiTrans->RegisterYourself();
+
+    TString diskForExcavationCompositeFormula = diskForExcavation->GetName();
+    diskForExcavationCompositeFormula += ":";
+    diskForExcavationCompositeFormula += diskForExcavationCombiTrans->GetName();
+    addToPetalCaseComposite(diskForExcavationCompositeFormula);
+  }
+}
+
+// ClassImp(TRKPetalCase);
+} // namespace trk
+} // namespace o2
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalDisk.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalDisk.cxx
new file mode 100644
index 0000000000000..e24b24b48c882
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalDisk.cxx
@@ -0,0 +1,94 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TRKPetalDisk.cxx
+/// \brief Implementation of the TRKPetalDisk class
+
+#include "TRKSimulation/TRKPetalDisk.h"
+#include "TRKBase/GeometryTGeo.h"
+
+#include <fairlogger/Logger.h> // for LOG
+
+#include "TGeoManager.h"        // for TGeoManager, gGeoManager
+#include "TGeoMatrix.h"         // for TGeoCombiTrans, TGeoRotation, etc
+#include "TGeoTube.h"           // for TGeoTube, TGeoTubeSeg
+#include "TGeoVolume.h"         // for TGeoVolume, TGeoVolumeAssembly
+#include "TGeoCompositeShape.h" // for TGeoCompositeShape
+#include "TMathBase.h"          // for Abs
+#include "TMath.h"              // for Sin, RadToDeg, DegToRad, Cos, Tan, etc
+#include "TGeoTube.h"
+
+#include <cstdio> // for snprintf
+
+namespace o2
+{
+namespace trk
+{
+
+TRKPetalDisk::TRKPetalDisk(Int_t diskNumber, std::string diskName, Float_t z, Float_t rIn, Float_t rOut, Float_t angularCoverage, Float_t Diskx2X0)
+{
+  // Creates a simple parametrized petal disk
+  mDiskNumber = diskNumber;
+  mDiskName = diskName;
+  mZ = z;
+  mAngularCoverage = angularCoverage;
+  mx2X0 = Diskx2X0;
+  mInnerRadius = rIn;
+  mOuterRadius = rOut;
+  Float_t Si_X0 = 9.5;
+  mChipThickness = Diskx2X0 * Si_X0;
+
+  LOG(info) << "Creating TRK Disk " << mDiskNumber;
+  LOG(info) << "   Using silicon X0 = " << Si_X0 << " to emulate disk radiation length.";
+  LOG(info) << "   Disk z = " << mZ << " ; R_in = " << mInnerRadius << " ; R_out = " << mOuterRadius << " ; x2X0 = " << mx2X0 << " ; ChipThickness = " << mChipThickness;
+}
+
+void TRKPetalDisk::createDisk(TGeoVolume* motherVolume, TGeoCombiTrans* combiTrans)
+{
+  // Create tube, set sensitive volume, add to mother volume
+  Double_t toDeg = 180 / TMath::Pi();
+  std::string chipName = mDiskName + "_" + o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mDiskNumber),
+              sensName = mDiskName + "_" + Form("%s%d", GeometryTGeo::getTRKSensorPattern(), mDiskNumber);
+
+  mSensorName = sensName;
+
+  TGeoTubeSeg* sensor = new TGeoTubeSeg(mInnerRadius, mOuterRadius, mChipThickness / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
+  TGeoTubeSeg* chip = new TGeoTubeSeg(mInnerRadius, mOuterRadius, mChipThickness / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
+  TGeoTubeSeg* disk = new TGeoTubeSeg(mInnerRadius, mOuterRadius, mChipThickness / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
+
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+
+  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
+  sensVol->SetLineColor(kYellow);
+  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+  chipVol->SetLineColor(kYellow);
+  TGeoVolume* diskVol = new TGeoVolume(mDiskName.c_str(), disk, medAir);
+  diskVol->SetLineColor(kYellow);
+
+  LOG(info) << "Inserting " << sensVol->GetName() << " inside " << chipVol->GetName();
+  chipVol->AddNode(sensVol, 1, nullptr);
+
+  LOG(info) << "Inserting " << chipVol->GetName() << " inside " << diskVol->GetName();
+  diskVol->AddNode(chipVol, 1, nullptr);
+
+  // Finally put everything in the mother volume
+  TGeoCombiTrans* fwdPetalCombiTrans = new TGeoCombiTrans(*(combiTrans->MakeClone())); // Copy from petal case
+  fwdPetalCombiTrans->SetDz(mZ);                                                       // Overwrite z location
+  fwdPetalCombiTrans->RegisterYourself();
+
+  LOG(info) << "Inserting " << diskVol->GetName() << " inside " << motherVolume->GetName();
+  motherVolume->AddNode(diskVol, 1, fwdPetalCombiTrans);
+}
+// ClassImp(TRKPetalLayer);
+
+} // namespace trk
+} // namespace o2
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalLayer.cxx
new file mode 100644
index 0000000000000..c8ff0d957bb19
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalLayer.cxx
@@ -0,0 +1,79 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKSimulation/TRKPetalLayer.h"
+#include "TRKBase/GeometryTGeo.h"
+
+#include "Framework/Logger.h"
+
+#include "TGeoTube.h"
+#include "TGeoBBox.h"
+#include "TGeoVolume.h"
+#include "TGeoTube.h"
+#include "TGeoMatrix.h"
+
+#include "TMath.h"
+
+namespace o2
+{
+namespace trk
+{
+TRKPetalLayer::TRKPetalLayer(Int_t layerNumber, std::string layerName, Float_t rIn, Float_t angularCoverage, Float_t zLength, Float_t layerX2X0)
+  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rIn), mAngularCoverage(angularCoverage), mZ(zLength), mX2X0(layerX2X0), mModuleWidth(4.54)
+{
+  Float_t Si_X0 = 9.5f;
+  mChipThickness = mX2X0 * Si_X0;
+  LOGP(info, "Creating layer: id: {} rInner: {} thickness: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mChipThickness, mZ, mX2X0);
+}
+
+void TRKPetalLayer::createLayer(TGeoVolume* motherVolume, TGeoCombiTrans* combiTrans)
+{
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+
+  std::string staveName = mLayerName + "_" + o2::trk::GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber),
+              chipName = mLayerName + "_" + o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber),
+              sensName = mLayerName + "_" + Form("%s%d", GeometryTGeo::getTRKSensorPattern(), mLayerNumber);
+
+  mSensorName = sensName;
+
+  Double_t toDeg = 180 / TMath::Pi();
+  mLayer = new TGeoTubeSeg(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
+  TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), mLayer, medAir);
+  layerVol->SetLineColor(kYellow);
+
+  TGeoTubeSeg* stave = new TGeoTubeSeg(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
+  TGeoTubeSeg* chip = new TGeoTubeSeg(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
+  TGeoTubeSeg* sensor = new TGeoTubeSeg(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
+
+  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
+  sensVol->SetLineColor(kYellow);
+  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+  chipVol->SetLineColor(kYellow);
+  TGeoVolume* staveVol = new TGeoVolume(staveName.c_str(), stave, medSi);
+  staveVol->SetLineColor(kYellow);
+
+  LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+  chipVol->AddNode(sensVol, 1, nullptr);
+
+  LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
+  staveVol->AddNode(chipVol, 1, nullptr);
+
+  LOGP(info, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
+  layerVol->AddNode(staveVol, 1, nullptr);
+
+  LOGP(info, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
+  motherVolume->AddNode(layerVol, 1, combiTrans);
+}
+// ClassImp(TRKPetalLayer);
+
+} // namespace trk
+} // namespace o2
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 7937e3b4de09a..1fb966425f974 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -27,16 +27,6 @@ namespace o2
 {
 namespace trk
 {
-TRKServices::TRKServices(float rMin, float zLength, float thickness)
-{
-  mColdPlateRMin = rMin;
-  mColdPlateZLength = zLength;
-  mColdPlateThickness = thickness;
-  mZLengthIRISVacV = 70.;
-  mThicknessIRISVacV = 150.e-4;
-  mRInIRISVacV = 0.48;
-  mROutIRISVacV = mColdPlateRMin + mColdPlateThickness;
-}
 
 void TRKServices::createMaterials()
 {
@@ -63,6 +53,7 @@ void TRKServices::createMaterials()
   float zAir[4] = {6., 7., 8., 18.};
   float wAir[4] = {0.000124, 0.755267, 0.231781, 0.012827};
   float dAir = 1.20479E-3;
+  float dAir1 = 1.20479E-11; // vacuum denisity inside pipe
 
   // Water
   float aWater[2] = {1.00794, 15.9994};
@@ -115,6 +106,7 @@ void TRKServices::createMaterials()
   matmgr.Mixture("ALICE3_TRKSERVICES", 74, "ALUMINIUM5083", aAl5083, zAl5083, dAl5083, 9, wAl5083);                                    // AL5083 - Candidate for IRIS vacuum vessel
   matmgr.Mixture("ALICE3_TRKSERVICES", 75, "ALUMINIUMBERYLLIUMMETAL", aAlBeMet, zAlBeMet, dAlBeMet, 2, wAlBeMet);                      // Aluminium-Beryllium metal - Candidate for IRIS vacuum vessel
   matmgr.Material("ALICE3_TRKSERVICES", 76, "CARBONFIBERM55J6K", 12.0107, 6, 1.92, 999, 999);                                          // Carbon Fiber M55J
+  matmgr.Mixture("ALICE3_PIPE", 77, "VACUUM", aAir, zAir, dAir1, 4, wAir);
 
   matmgr.Medium("ALICE3_TRKSERVICES", 1, "CERAMIC", 66, 0, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);                  // Ceramic for cold plate
   matmgr.Medium("ALICE3_TRKSERVICES", 2, "COPPER", 67, 0, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);                   // Copper for cables
@@ -127,56 +119,62 @@ void TRKServices::createMaterials()
   matmgr.Medium("ALICE3_TRKSERVICES", 9, "ALUMINIUM5083", 74, 0, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);            // Al5083 for IRIS vacuum vessel
   matmgr.Medium("ALICE3_TRKSERVICES", 10, "ALUMINIUMBERYLLIUMMETAL", 75, 0, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin); // AlBeMet for IRIS vacuum vessel
   matmgr.Medium("ALICE3_TRKSERVICES", 11, "CARBONFIBERM55J6K", 76, 0, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);       // Carbon Fiber M55J
+  matmgr.Medium("ALICE3_PIPE", 12, "VACUUM", 77, 0, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);                         // Vacuum inside the beam pipe
 }
 
 void TRKServices::createServices(TGeoVolume* motherVolume)
 {
   createMaterials();
-  createColdplate(motherVolume);
+  createVacuumCompositeShape();
   createMiddleServices(motherVolume);
   createOuterDisksServices(motherVolume);
   createOuterBarrelServices(motherVolume);
 }
 
-void TRKServices::createColdplate(TGeoVolume* motherVolume)
+void TRKServices::createVacuumCompositeShape()
+{
+  Double_t pipeRIn = 1.8f;
+  Double_t A3IPLength = 1000.f;
+  Double_t vacuumVesselRIn = 5.6f;
+  Double_t vacuumVesselThickness = 0.08f;
+  Double_t vacuumVesselLength = 76.f;
+
+  // Vacuum for A and C Side
+  Double_t vacuumASideLength = A3IPLength / 2. - vacuumVesselThickness - vacuumVesselLength / 2.;
+  Double_t vacuumCSideLength = A3IPLength / 2. + vacuumVesselLength / 2.;
+
+  // Vacuum tubes
+  TGeoTube* vacuumASide = new TGeoTube("VACUUM_Ash", 0., pipeRIn, vacuumASideLength / 2.);
+  TGeoTube* vacuumCSide = new TGeoTube("VACUUM_Csh", 0., vacuumVesselRIn, vacuumCSideLength / 2.);
+
+  // Vacuum positions
+  TGeoTranslation* posVacuumASide = new TGeoTranslation("VACUUM_ASIDE_POSITION", 0, 0, vacuumVesselLength / 2. + vacuumVesselThickness + vacuumASideLength / 2.);
+  posVacuumASide->RegisterYourself();
+  TGeoTranslation* posVacuumCSide = new TGeoTranslation("VACUUM_CSIDE_POSITION", 0, 0, vacuumVesselLength / 2. - vacuumCSideLength / 2.);
+  posVacuumCSide->RegisterYourself();
+
+  mVacuumCompositeFormula =
+    "VACUUM_Ash:VACUUM_ASIDE_POSITION"
+    "+VACUUM_Csh:VACUUM_CSIDE_POSITION";
+}
+
+void TRKServices::excavateFromVacuum(TString shapeToExcavate)
+{
+  mVacuumCompositeFormula += "-";
+  mVacuumCompositeFormula += shapeToExcavate;
+}
+
+void TRKServices::registerVacuum(TGeoVolume* motherVolume)
 {
   auto& matmgr = o2::base::MaterialManager::Instance();
-  const TGeoMedium* medCeramic = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_CERAMIC");
-
-  TGeoTube* coldPlate = new TGeoTube("TRK_COLDPLATEsh", mColdPlateRMin, mColdPlateRMin + mColdPlateThickness, mColdPlateZLength / 2.);
-  TGeoVolume* coldPlateVolume = new TGeoVolume("TRK_COLDPLATE", coldPlate, medCeramic);
-  coldPlateVolume->SetVisibility(1);
-  coldPlateVolume->SetLineColor(kGray);
-
-  LOGP(info, "Creating cold plate service");
-
-  LOGP(info, "Inserting {} in {} ", coldPlateVolume->GetName(), motherVolume->GetName());
-  motherVolume->AddNode(coldPlateVolume, 1, nullptr);
-
-  // IRIS Tracker Vacuum Vessel
-  TGeoTube* irisVacuumVesselInnerTube = new TGeoTube("TRK_IRISVACUUMVESSEL_INNERTUBEsh", mRInIRISVacV, mRInIRISVacV + mThicknessIRISVacV, mZLengthIRISVacV / 2.);
-  TGeoTube* irisVacuumVesselOuterTube = new TGeoTube("TRK_IRISVACUUMVESSEL_OUTERTUBEsh", mROutIRISVacV, mROutIRISVacV + mThicknessIRISVacV, mZLengthIRISVacV / 2.);
-  TGeoTube* irisVacuumVesselWall = new TGeoTube("TRK_IRISVACUUMVESSEL_WALLsh", mRInIRISVacV, mROutIRISVacV + mThicknessIRISVacV, mThicknessIRISVacV / 2.);
-  TGeoTranslation* irisVacVWallNegZ = new TGeoTranslation("IRISVACVWALLNEGZ", 0., 0., -mZLengthIRISVacV / 2. - mThicknessIRISVacV / 2.);
-  irisVacVWallNegZ->RegisterYourself();
-  TGeoTranslation* irisVacVWallPosZ = new TGeoTranslation("IRISVACVWALLPOSZ", 0., 0., mZLengthIRISVacV / 2. + mThicknessIRISVacV / 2.);
-  irisVacVWallPosZ->RegisterYourself();
-  TString irisCompositeFormula =
-    "TRK_IRISVACUUMVESSEL_INNERTUBEsh"
-    "+TRK_IRISVACUUMVESSEL_OUTERTUBEsh"
-    "+TRK_IRISVACUUMVESSEL_WALLsh:IRISVACVWALLNEGZ"
-    "+TRK_IRISVACUUMVESSEL_WALLsh:IRISVACVWALLPOSZ";
-  TGeoCompositeShape* irisVacuumVesselComposite = new TGeoCompositeShape("TRK_IRISVACUUMVESSELsh", irisCompositeFormula);
-
-  const TGeoMedium* medBe = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_BERYLLIUM");
-  TGeoVolume* irisVacuumVesselVolume = new TGeoVolume("TRK_IRISVACUUMVESSEL", irisVacuumVesselComposite, medBe);
-
-  irisVacuumVesselVolume->SetVisibility(1);
-  irisVacuumVesselVolume->SetLineColor(kGray);
-
-  LOGP(info, "Creating IRIS Tracker vacuum vessel");
-  LOGP(info, "Inserting {} in {} ", irisVacuumVesselVolume->GetName(), motherVolume->GetName());
-  motherVolume->AddNode(irisVacuumVesselVolume, 1, nullptr);
+  const TGeoMedium* kMedVac = matmgr.getTGeoMedium("ALICE3_PIPE_VACUUM");
+
+  TGeoCompositeShape* vacuumComposite = new TGeoCompositeShape("A3IP_VACUUMsh", mVacuumCompositeFormula);
+  TGeoVolume* vacuumVolume = new TGeoVolume("A3IP_VACUUM", vacuumComposite, kMedVac);
+
+  // Add the vacuum to the barrel
+  vacuumVolume->SetLineColor(kGreen - 3);
+  motherVolume->AddNode(vacuumVolume, 1, new TGeoTranslation(0, 0, 0));
 }
 
 void TRKServices::createOuterDisksServices(TGeoVolume* motherVolume)
@@ -459,7 +457,7 @@ void TRKServices::createOuterBarrelServices(TGeoVolume* motherVolume)
   // Fiber 0.269 cm
   const float siO2FiberThick = 0.5 * 0.269;
   const float peFiberThick = 0.5 * 0.269;
-  float rMinOuterBarrelServices = ((TGeoTube*)motherVolume->GetNode(Form("%s10_1", GeometryTGeo::getTRKLayerPattern()))->GetVolume()->GetShape())->GetRmax();
+  float rMinOuterBarrelServices = ((TGeoTube*)motherVolume->GetNode(Form("%s7_1", GeometryTGeo::getTRKLayerPattern()))->GetVolume()->GetShape())->GetRmax();
   const float zLengthOuterBarrelServices = 350.f; // 175cm
 
   TGeoTube* outerBarrelFiberSIO2 = new TGeoTube("TRK_OUTERBARREL_FIBER_SIO2sh", rMinOuterBarrelServices, rMinOuterBarrelServices + siO2FiberThick, zLengthOuterBarrelServices);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
index 1b0181144b5d4..b82d8879e7dad 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
@@ -15,7 +15,10 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ class o2::trk::TRKPetalCase + ;
 #pragma link C++ class o2::trk::TRKLayer + ;
+#pragma link C++ class o2::trk::TRKPetalLayer + ;
+#pragma link C++ class o2::trk::TRKPetalDisk + ;
 #pragma link C++ class o2::trk::TRKServices + ;
 #pragma link C++ class o2::trk::Detector + ;
 #pragma link C++ class o2::base::DetImpl < o2::trk::Detector> + ;
diff --git a/macro/build_geometry.C b/macro/build_geometry.C
index 12d3842239874..93b06eb4bfeae 100644
--- a/macro/build_geometry.C
+++ b/macro/build_geometry.C
@@ -167,7 +167,7 @@ void build_geometry(FairRunSim* run = nullptr)
 #ifdef ENABLE_UPGRADES
   // upgraded beampipe at the interaction point (IP)
   if (isActivated("A3IP")) {
-    run->AddModule(new o2::passive::Alice3Pipe("A3IP", "Alice 3 beam pipe", !isActivated("TRK"), !isActivated("FT3"), 1.8f, 0.08f, 1000.f, 5.6f, 0.08f, 76.f));
+    run->AddModule(new o2::passive::Alice3Pipe("A3IP", "Alice 3 beam pipe", 1.8f, 0.08f, 1000.f, 5.6f, 0.08f, 76.f));
   }
 
   // the absorber

From ced3e8ada32e6a6393745a811f46fe37cd441448 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Thu, 13 Mar 2025 09:15:11 +0100
Subject: [PATCH 0046/1764] GPU: Remove thrust deprecated declarations in ITS
 code

---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 4fa7913c10e82..ce93523319e99 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -201,7 +201,7 @@ struct equal_tracklets {
 };
 
 template <typename T1, typename T2>
-struct pair_to_first : public thrust::unary_function<gpuPair<T1, T2>, T1> {
+struct pair_to_first {
   GPUhd() int operator()(const gpuPair<T1, T2>& a) const
   {
     return a.first;
@@ -209,7 +209,7 @@ struct pair_to_first : public thrust::unary_function<gpuPair<T1, T2>, T1> {
 };
 
 template <typename T1, typename T2>
-struct pair_to_second : public thrust::unary_function<gpuPair<T1, T2>, T2> {
+struct pair_to_second {
   GPUhd() int operator()(const gpuPair<T1, T2>& a) const
   {
     return a.second;
@@ -710,7 +710,7 @@ GPUg() void printPointersKernel(std::tuple<Args...> args)
 }
 
 template <typename T>
-struct trackletSortEmptyFunctor : public thrust::binary_function<T, T, bool> {
+struct trackletSortEmptyFunctor {
   GPUhd() bool operator()(const T& lhs, const T& rhs) const
   {
     return lhs.firstClusterIndex > rhs.firstClusterIndex;
@@ -718,7 +718,7 @@ struct trackletSortEmptyFunctor : public thrust::binary_function<T, T, bool> {
 };
 
 template <typename T>
-struct trackletSortIndexFunctor : public thrust::binary_function<T, T, bool> {
+struct trackletSortIndexFunctor {
   GPUhd() bool operator()(const T& lhs, const T& rhs) const
   {
     return lhs.firstClusterIndex < rhs.firstClusterIndex || (lhs.firstClusterIndex == rhs.firstClusterIndex && lhs.secondClusterIndex < rhs.secondClusterIndex);

From 5ec817dba37076f67a1fe7cbc28c189641a30e1f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 11 Mar 2025 13:05:34 +0100
Subject: [PATCH 0047/1764] GPU: Remove obsolete option to run TrackletSelector
 not in pipeline

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  6 --
 .../Base/GPUReconstructionIncludes.h          |  3 -
 .../Definitions/GPUDefGPUParameters.h         |  8 ---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 -
 .../Global/GPUChainTrackingSectorTracker.cxx  | 57 +------------------
 .../SectorTracker/GPUTPCTracker.cxx           |  2 +-
 GPU/GPUTracking/kernels.cmake                 |  2 +-
 7 files changed, 3 insertions(+), 76 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index a7e0c2cb827f1..4b767a6b8a8f7 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -273,9 +273,6 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     if (mProcessingSettings.trackletConstructorInPipeline < 0) {
       mProcessingSettings.trackletConstructorInPipeline = 1;
     }
-    if (mProcessingSettings.trackletSelectorInPipeline < 0) {
-      mProcessingSettings.trackletSelectorInPipeline = 1;
-    }
     if (mProcessingSettings.trackletSelectorSectors < 0) {
       mProcessingSettings.trackletSelectorSectors = 1;
     }
@@ -296,9 +293,6 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
 
   UpdateAutomaticProcessingSettings();
   GPUCA_GPUReconstructionUpdateDefaults();
-  if (!mProcessingSettings.trackletConstructorInPipeline) {
-    mProcessingSettings.trackletSelectorInPipeline = false;
-  }
   if (!mProcessingSettings.rtc.enable) {
     mProcessingSettings.rtc.optConstexpr = false;
   }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludes.h b/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
index b35613f3bec59..f18ab21dc3972 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
@@ -33,9 +33,6 @@
   if (mProcessingSettings.trackletConstructorInPipeline < 0) {                              \
     mProcessingSettings.trackletConstructorInPipeline = GPUCA_CONSTRUCTOR_IN_PIPELINE;      \
   }                                                                                         \
-  if (mProcessingSettings.trackletSelectorInPipeline < 0) {                                 \
-    mProcessingSettings.trackletSelectorInPipeline = GPUCA_SELECTOR_IN_PIPELINE;            \
-  }                                                                                         \
   if (mProcessingSettings.trackletSelectorSectors < 0) {                                    \
     mProcessingSettings.trackletSelectorSectors = GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT;     \
   }                                                                                         \
diff --git a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
index c40659ecd2632..772b4684b590e 100644
--- a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
+++ b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
@@ -85,7 +85,6 @@
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
   #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
-  #define GPUCA_SELECTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 1
   #define GPUCA_SORT_BEFORE_FIT 1
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
@@ -151,7 +150,6 @@
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
   #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
-  #define GPUCA_SELECTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 1
   #define GPUCA_SORT_BEFORE_FIT 1
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
@@ -217,7 +215,6 @@
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
   #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
-  #define GPUCA_SELECTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 1
   #define GPUCA_SORT_BEFORE_FIT 1
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
@@ -275,7 +272,6 @@
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
   #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
-  #define GPUCA_SELECTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 1
   #define GPUCA_SORT_BEFORE_FIT 1
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
@@ -537,9 +533,6 @@
   #ifndef GPUCA_CONSTRUCTOR_IN_PIPELINE
   #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
   #endif
-  #ifndef GPUCA_SELECTOR_IN_PIPELINE
-  #define GPUCA_SELECTOR_IN_PIPELINE 0
-  #endif
   #ifndef GPUCA_ALTERNATE_BORDER_SORT
   #define GPUCA_ALTERNATE_BORDER_SORT 0
   #endif
@@ -562,7 +555,6 @@
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 0
   #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
-  #define GPUCA_SELECTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 0
   #define GPUCA_SORT_BEFORE_FIT 0
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 3c31a4fbb8409..5663aed8033b7 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -259,7 +259,6 @@ AddOption(nTPCClustererLanes, int8_t, -1, "", 0, "Number of TPC clusterers that
 AddOption(overrideClusterizerFragmentLen, int32_t, -1, "", 0, "Force the cluster max fragment len to a certain value (-1 = autodetect)")
 AddOption(trackletSelectorSectors, int8_t, -1, "", 0, "Number of sectors to processes in parallel at max")
 AddOption(trackletConstructorInPipeline, int8_t, -1, "", 0, "Run tracklet constructor in the pipeline")
-AddOption(trackletSelectorInPipeline, int8_t, -1, "", 0, "Run tracklet selector in the pipeline")
 AddOption(delayedOutput, bool, true, "", 0, "Delay output to be parallel to track fit")
 AddOption(mergerSortTracks, int8_t, -1, "", 0, "Sort track indizes for GPU track fit")
 AddOption(alternateBorderSort, int8_t, -1, "", 0, "Alternative implementation for sorting of border tracks")
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index dd7fe285265ad..4b9b8c33a0887 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -226,7 +226,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       }
     }
 
-    if (!(doGPU || GetProcessingSettings().debugLevel >= 1) || GetProcessingSettings().trackletSelectorInPipeline) {
+    if (!(doGPU || GetProcessingSettings().debugLevel >= 1) || GetProcessingSettings().trackletConstructorInPipeline) {
       runKernel<GPUTPCTrackletSelector>({GetGridAuto(useStream), {iSector}});
       runKernel<GPUTPCExtrapolationTrackingCopyNumbers>({{1, -ThreadCount(), useStream}, {iSector}}, 1);
       if (GetProcessingSettings().deterministicGPUReconstruction) {
@@ -250,56 +250,6 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       ReleaseEvent(mEvents->init);
     }
 
-    if (!GetProcessingSettings().trackletSelectorInPipeline) {
-      if (GetProcessingSettings().trackletConstructorInPipeline) {
-        SynchronizeGPU();
-      } else {
-        for (int32_t i = 0; i < mRec->NStreams(); i++) {
-          RecordMarker(&mEvents->stream[i], i);
-        }
-        runKernel<GPUTPCTrackletConstructor, 1>({GetGridAuto(0), krnlRunRangeNone, {&mEvents->single, mEvents->stream, mRec->NStreams()}});
-        for (int32_t i = 0; i < mRec->NStreams(); i++) {
-          ReleaseEvent(mEvents->stream[i]);
-        }
-        SynchronizeEventAndRelease(mEvents->single);
-      }
-
-      if (GetProcessingSettings().debugLevel >= 4) {
-        for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
-          DoDebugAndDump(RecoStep::TPCSectorTracking, 128, processors()->tpcTrackers[iSector], &GPUTPCTracker::DumpTrackletHits, *mDebugFile);
-        }
-      }
-
-      int32_t runSectors = 0;
-      int32_t useStream = 0;
-      for (uint32_t iSector = 0; iSector < NSECTORS; iSector += runSectors) {
-        if (runSectors < GetProcessingSettings().trackletSelectorSectors) {
-          runSectors++;
-        }
-        runSectors = CAMath::Min<int32_t>(runSectors, NSECTORS - iSector);
-        if (getKernelProperties<GPUTPCTrackletSelector>().minBlocks * BlockCount() < (uint32_t)runSectors) {
-          runSectors = getKernelProperties<GPUTPCTrackletSelector>().minBlocks * BlockCount();
-        }
-
-        if (GetProcessingSettings().debugLevel >= 3) {
-          GPUInfo("Running TPC Tracklet selector (Stream %d, Sector %d to %d)", useStream, iSector, iSector + runSectors);
-        }
-        runKernel<GPUTPCTrackletSelector>({GetGridAuto(useStream), {iSector, runSectors}});
-        runKernel<GPUTPCExtrapolationTrackingCopyNumbers>({{1, -ThreadCount(), useStream}, {iSector}}, runSectors);
-        for (uint32_t k = iSector; k < iSector + runSectors; k++) {
-          if (GetProcessingSettings().deterministicGPUReconstruction) {
-            runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::sectorTracks>({GetGrid(1, 1, useStream), {k}});
-          }
-          TransferMemoryResourceLinkToHost(RecoStep::TPCSectorTracking, processors()->tpcTrackers[k].MemoryResCommon(), useStream, &mEvents->sector[k]);
-          streamMap[k] = useStream;
-        }
-        useStream++;
-        if (useStream >= mRec->NStreams()) {
-          useStream = 0;
-        }
-      }
-    }
-
     mSectorSelectorReady = 0;
 
     std::array<bool, NSECTORS> transferRunning;
@@ -335,11 +285,6 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
               processors()->tpcTrackers[iSector].DumpHitWeights(*mDebugFile);
             }
           }
-          if (!GetProcessingSettings().trackletSelectorInPipeline) {
-            if (GetProcessingSettings().debugMask & 512) {
-              processors()->tpcTrackers[iSector].DumpTrackHits(*mDebugFile);
-            }
-          }
         }
 
         if (transferRunning[iSector]) {
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index 63c64f78cc095..28521b2987a45 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -93,7 +93,7 @@ void* GPUTPCTracker::SetPointersCommon(void* mem)
 void GPUTPCTracker::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();
-  bool reuseCondition = !mRec->GetProcessingSettings().keepDisplayMemory && mRec->GetProcessingSettings().trackletSelectorInPipeline && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
+  bool reuseCondition = !mRec->GetProcessingSettings().keepDisplayMemory && mRec->GetProcessingSettings().trackletConstructorInPipeline && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
   GPUMemoryReuse reLinks{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerDataLinks, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
   mMemoryResLinks = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersDataLinks, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK, "TPCSectorLinks", reLinks);
   mMemoryResSectorScratch = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersDataScratch, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK | GPUMemoryResource::MEMORY_CUSTOM, "TPCSectorScratch");
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index c973264bfde2a..a823fc853e5b1 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -33,7 +33,7 @@ o2_gpu_add_kernel("GPUTPCStartHitsFinder"                             "= TPCTRAC
 o2_gpu_add_kernel("GPUTPCStartHitsSorter"                             "= TPCTRACKER"                                          LB      single)
 o2_gpu_add_kernel("GPUTPCTrackletConstructor, singleSector"           "= TPCTRACKER"                                          LB      single)
 o2_gpu_add_kernel("GPUTPCTrackletConstructor, allSectors"             "= TPCTRACKER"                                          LB      single)
-o2_gpu_add_kernel("GPUTPCTrackletSelector"                            "= TPCTRACKER"                                          LB      both)
+o2_gpu_add_kernel("GPUTPCTrackletSelector"                            "= TPCTRACKER"                                          LB      single)
 o2_gpu_add_kernel("GPUMemClean16"                                     "GPUGeneralKernels"                                     NO      "simple, REG, (GPUCA_THREAD_COUNT, 1)" void* ptr "uint64_t" size)
 o2_gpu_add_kernel("GPUitoa"                                           "GPUGeneralKernels"                                     NO      "simple, REG, (GPUCA_THREAD_COUNT, 1)" int32_t* ptr "uint64_t" size)
 o2_gpu_add_kernel("GPUTPCExtrapolationTrackingCopyNumbers"            "GPUTPCExtrapolationTracking TPCTRACKER"                NO      single int32_t n)

From 1b8388da5e43bbc506e62f0ad1f1d1b9449e87c6 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 11 Mar 2025 14:34:06 +0100
Subject: [PATCH 0048/1764] GPU: Remove obsolete preprocessor magic to create 2
 different kernels for single-slice and multi-slice

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  37 ++--
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |   6 +-
 .../Base/GPUReconstructionKernelMacros.h      |  82 ++------
 .../Base/GPUReconstructionKernels.h           |  11 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        |  22 +-
 .../Base/cuda/GPUReconstructionCUDA.h         |   2 +-
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  47 ++---
 .../GPUReconstructionCUDAkernel.template.cu   |   4 +-
 .../GPUReconstructionHIPkernel.template.hip   |   4 +-
 .../Base/opencl/GPUReconstructionOCL.cl       |   6 +-
 .../Base/opencl/GPUReconstructionOCL.h        |   6 +-
 .../opencl/GPUReconstructionOCLKernels.cxx    |  37 +---
 GPU/GPUTracking/Global/GPUChain.h             |   2 +-
 GPU/GPUTracking/cmake/kernel_helpers.cmake    |  41 ++--
 GPU/GPUTracking/kernels.cmake                 | 194 +++++++++---------
 15 files changed, 201 insertions(+), 300 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 969dd06d6297e..f5d350b4064d0 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -66,28 +66,25 @@ inline void GPUReconstructionCPUBackend::runKernelBackendInternal(const krnlSetu
   if (x.nThreads != 1) {
     throw std::runtime_error("Cannot run device kernel on host with nThreads != 1");
   }
-  uint32_t num = y.num == 0 || y.num == -1 ? 1 : y.num;
-  for (uint32_t k = 0; k < num; k++) {
-    int32_t nThreads = getNKernelHostThreads(false);
-    if (nThreads > 1) {
-      if (mProcessingSettings.debugLevel >= 5) {
-        printf("Running %d Threads\n", nThreads);
-      }
-      tbb::this_task_arena::isolate([&] {
-        mThreading->activeThreads->execute([&] {
-          tbb::parallel_for(tbb::blocked_range<uint32_t>(0, x.nBlocks, 1), [&](const tbb::blocked_range<uint32_t>& r) {
-            typename T::GPUSharedMemory smem;
-            for (uint32_t iB = r.begin(); iB < r.end(); iB++) {
-              T::template Thread<I>(x.nBlocks, 1, iB, 0, smem, T::Processor(*mHostConstantMem)[y.start + k], args...);
-            }
-          });
+  int32_t nThreads = getNKernelHostThreads(false);
+  if (nThreads > 1) {
+    if (mProcessingSettings.debugLevel >= 5) {
+      printf("Running %d Threads\n", nThreads);
+    }
+    tbb::this_task_arena::isolate([&] {
+      mThreading->activeThreads->execute([&] {
+        tbb::parallel_for(tbb::blocked_range<uint32_t>(0, x.nBlocks, 1), [&](const tbb::blocked_range<uint32_t>& r) {
+          typename T::GPUSharedMemory smem;
+          for (uint32_t iB = r.begin(); iB < r.end(); iB++) {
+            T::template Thread<I>(x.nBlocks, 1, iB, 0, smem, T::Processor(*mHostConstantMem)[y.index], args...);
+          }
         });
       });
-    } else {
-      for (uint32_t iB = 0; iB < x.nBlocks; iB++) {
-        typename T::GPUSharedMemory smem;
-        T::template Thread<I>(x.nBlocks, 1, iB, 0, smem, T::Processor(*mHostConstantMem)[y.start + k], args...);
-      }
+    });
+  } else {
+    for (uint32_t iB = 0; iB < x.nBlocks; iB++) {
+      typename T::GPUSharedMemory smem;
+      T::template Thread<I>(x.nBlocks, 1, iB, 0, smem, T::Processor(*mHostConstantMem)[y.index], args...);
     }
   }
 }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index 7901c34866c66..f90820281c74d 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -49,7 +49,7 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
 
  public:
   ~GPUReconstructionCPU() override;
-  static constexpr krnlRunRange krnlRunRangeNone{0, -1};
+  static constexpr krnlRunRange krnlRunRangeNone{0};
   static constexpr krnlEvent krnlEventNone = krnlEvent{nullptr, nullptr, 0};
 
   template <class S, int32_t I = 0, typename... Args>
@@ -77,7 +77,7 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
 
   GPUReconstructionCPU(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionKernels(cfg) {}
 
-#define GPUCA_KRNL(x_class, attributes, x_arguments, x_forward, x_types)                                                                                                                     \
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)                                                                                                                   \
   inline void runKernelImplWrapper(gpu_reconstruction_kernels::classArgument<GPUCA_M_KRNL_TEMPLATE(x_class)>, bool cpuFallback, double& timer, krnlSetup&& setup GPUCA_M_STRIP(x_arguments)) \
   {                                                                                                                                                                                          \
     if (cpuFallback) {                                                                                                                                                                       \
@@ -161,7 +161,7 @@ inline void GPUReconstructionCPU::runKernel(krnlSetup&& setup, Args&&... args)
     throw std::runtime_error("GPUCA_MAX_THREADS exceeded");
   }
   if (mProcessingSettings.debugLevel >= 3) {
-    GPUInfo("Running kernel %s (Stream %d, Range %d/%d, Grid %d/%d) on %s", GetKernelName<S, I>(), stream, setup.y.start, setup.y.num, nBlocks, nThreads, cpuFallback == 2 ? "CPU (forced)" : cpuFallback ? "CPU (fallback)" : mDeviceName.c_str());
+    GPUInfo("Running kernel %s (Stream %d, Index %d, Grid %d/%d) on %s", GetKernelName<S, I>(), stream, setup.y.index, nBlocks, nThreads, cpuFallback == 2 ? "CPU (forced)" : cpuFallback ? "CPU (fallback)" : mDeviceName.c_str());
   }
   if (nThreads == 0 || nBlocks == 0) {
     return;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
index 41abc8725c07b..f80b324970dc9 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
@@ -51,97 +51,45 @@
 #define GPUCA_ATTRRES3(XX) // 3 attributes not supported
 #define GPUCA_ATTRRES2(XX, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES2_, GPUCA_M_FIRST(__VA_ARGS__)))(XX, __VA_ARGS__)
 #define GPUCA_ATTRRES(XX, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(XX, __VA_ARGS__)
-// GPU Kernel entry point for single sector
-#define GPUCA_KRNLGPU_SINGLE_DEF(x_class, x_attributes, x_arguments, ...) \
-  GPUg() void GPUCA_ATTRRES(,GPUCA_M_SHIFT(GPUCA_M_STRIP(x_attributes))) GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))(GPUCA_CONSMEM_PTR int32_t iSector_internal GPUCA_M_STRIP(x_arguments))
-#ifdef GPUCA_KRNL_DEFONLY
-#define GPUCA_KRNLGPU_SINGLE(...) GPUCA_KRNLGPU_SINGLE_DEF(__VA_ARGS__);
-#else
-#define GPUCA_KRNLGPU_SINGLE(x_class, x_attributes, x_arguments, x_forward, ...) GPUCA_KRNLGPU_SINGLE_DEF(x_class, x_attributes, x_arguments, x_forward, __VA_ARGS__) \
-  { \
-    GPUshared() typename GPUCA_M_STRIP_FIRST(x_class)::GPUSharedMemory smem; \
-    GPUCA_M_STRIP_FIRST(x_class)::template Thread<GPUCA_M_KRNL_NUM(x_class)>(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), smem, GPUCA_M_STRIP_FIRST(x_class)::Processor(GPUCA_CONSMEM)[iSector_internal] GPUCA_M_STRIP(x_forward)); \
-  }
-#endif
 
-// GPU Kernel entry point for multiple sector
-#define GPUCA_KRNLGPU_MULTI_DEF(x_class, x_attributes, x_arguments, ...) \
-  GPUg() void GPUCA_ATTRRES(,GPUCA_M_SHIFT(GPUCA_M_STRIP(x_attributes))) GPUCA_M_CAT3(krnl_, GPUCA_M_KRNL_NAME(x_class), _multi)(GPUCA_CONSMEM_PTR int32_t firstSector, int32_t nSectorCount GPUCA_M_STRIP(x_arguments))
+// GPU Kernel entry point
+#define GPUCA_KRNLGPU_DEF(x_class, x_attributes, x_arguments, ...) \
+  GPUg() void GPUCA_ATTRRES(,GPUCA_M_STRIP(x_attributes)) GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))(GPUCA_CONSMEM_PTR int32_t _iSector_internal GPUCA_M_STRIP(x_arguments))
+
 #ifdef GPUCA_KRNL_DEFONLY
-#define GPUCA_KRNLGPU_MULTI(...) GPUCA_KRNLGPU_MULTI_DEF(__VA_ARGS__);
+#define GPUCA_KRNLGPU(...) GPUCA_KRNLGPU_DEF(__VA_ARGS__);
 #else
-#define GPUCA_KRNLGPU_MULTI(x_class, x_attributes, x_arguments, x_forward, ...) GPUCA_KRNLGPU_MULTI_DEF(x_class, x_attributes, x_arguments, x_forward, __VA_ARGS__) \
+#define GPUCA_KRNLGPU(x_class, x_attributes, x_arguments, x_forward, ...) \
+  GPUCA_KRNLGPU_DEF(x_class, x_attributes, x_arguments, x_forward, __VA_ARGS__) \
   { \
-    const int32_t iSector_internal = nSectorCount * (get_group_id(0) + (get_num_groups(0) % nSectorCount != 0 && nSectorCount * (get_group_id(0) + 1) % get_num_groups(0) != 0)) / get_num_groups(0); \
-    const int32_t nSectorBlockOffset = get_num_groups(0) * iSector_internal / nSectorCount; \
-    const int32_t sectorBlockId = get_group_id(0) - nSectorBlockOffset; \
-    const int32_t sectorGridDim = get_num_groups(0) * (iSector_internal + 1) / nSectorCount - get_num_groups(0) * (iSector_internal) / nSectorCount; \
     GPUshared() typename GPUCA_M_STRIP_FIRST(x_class)::GPUSharedMemory smem; \
-    GPUCA_M_STRIP_FIRST(x_class)::template Thread<GPUCA_M_KRNL_NUM(x_class)>(sectorGridDim, get_local_size(0), sectorBlockId, get_local_id(0), smem, GPUCA_M_STRIP_FIRST(x_class)::Processor(GPUCA_CONSMEM)[firstSector + iSector_internal] GPUCA_M_STRIP(x_forward)); \
+    GPUCA_M_STRIP_FIRST(x_class)::template Thread<GPUCA_M_KRNL_NUM(x_class)>(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), smem, GPUCA_M_STRIP_FIRST(x_class)::Processor(GPUCA_CONSMEM)[_iSector_internal] GPUCA_M_STRIP(x_forward)); \
   }
 #endif
 
-// GPU Host wrapper pre- and post-parts
-#define GPUCA_KRNL_PRE(x_class, ...) \
+// GPU Host wrappers for kernel
+#define GPUCA_KRNL_HOST(x_class, ...) \
+  GPUCA_KRNLGPU(x_class, __VA_ARGS__) \
   template <> class GPUCA_KRNL_BACKEND_CLASS::backendInternal<GPUCA_M_KRNL_TEMPLATE(x_class)> { \
    public: \
     template <typename T, typename... Args> \
     static inline void runKernelBackendMacro(const krnlSetupTime& _xyz, T* me, const Args&... args) \
     { \
       auto& x = _xyz.x; \
-      auto& y = _xyz.y;
-
-#define GPUCA_KRNL_POST() \
+      auto& y = _xyz.y; \
+      GPUCA_KRNL_CALL(x_class, __VA_ARGS__) \
     } \
   };
 
-// GPU Host wrappers for single kernel, multi-sector, or auto-detection
-#define GPUCA_KRNL_single(...) \
-  GPUCA_KRNLGPU_SINGLE(__VA_ARGS__) \
-  GPUCA_KRNL_PRE(__VA_ARGS__) \
-  if (y.num > 1) { \
-    throw std::runtime_error("Kernel called with invalid number of sectors"); \
-  } else { \
-    GPUCA_KRNL_CALL_single(__VA_ARGS__) \
-  } \
-  GPUCA_KRNL_POST()
-
-#define GPUCA_KRNL_multi(...) \
-  GPUCA_KRNLGPU_MULTI(__VA_ARGS__) \
-  GPUCA_KRNL_PRE(__VA_ARGS__) \
-  GPUCA_KRNL_CALL_multi(__VA_ARGS__) \
-  GPUCA_KRNL_POST()
-
-#define GPUCA_KRNL_(...) GPUCA_KRNL_single(__VA_ARGS__)
-#define GPUCA_KRNL_simple(...) GPUCA_KRNL_single(__VA_ARGS__)
-#define GPUCA_KRNL_both(...) \
-  GPUCA_KRNLGPU_SINGLE(__VA_ARGS__) \
-  GPUCA_KRNLGPU_MULTI(__VA_ARGS__) \
-  GPUCA_KRNL_PRE(__VA_ARGS__) \
-  if (y.num <= 1) { \
-    GPUCA_KRNL_CALL_single(__VA_ARGS__) \
-  } else { \
-    GPUCA_KRNL_CALL_multi(__VA_ARGS__) \
-  } \
-  GPUCA_KRNL_POST()
-
-#define GPUCA_KRNL_LOAD_(...) GPUCA_KRNL_LOAD_single(__VA_ARGS__)
-#define GPUCA_KRNL_LOAD_simple(...) GPUCA_KRNL_LOAD_single(__VA_ARGS__)
-#define GPUCA_KRNL_LOAD_both(...) \
-  GPUCA_KRNL_LOAD_single(__VA_ARGS__) \
-  GPUCA_KRNL_LOAD_multi(__VA_ARGS__)
-
 #define GPUCA_KRNL_PROP(x_class, x_attributes) \
   template <> gpu_reconstruction_kernels::krnlProperties GPUCA_KRNL_BACKEND_CLASS::getKernelPropertiesBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>() { \
-    gpu_reconstruction_kernels::krnlProperties ret = gpu_reconstruction_kernels::krnlProperties{GPUCA_ATTRRES(_INTERNAL_PROP,GPUCA_M_SHIFT(GPUCA_M_STRIP(x_attributes)))}; \
+    gpu_reconstruction_kernels::krnlProperties ret = gpu_reconstruction_kernels::krnlProperties{GPUCA_ATTRRES(_INTERNAL_PROP,GPUCA_M_STRIP(x_attributes))}; \
     return ret.nThreads > 0 ? ret : gpu_reconstruction_kernels::krnlProperties{(int32_t)mThreadCount}; \
   }
 
-// Generate GPU kernel and host wrapper
-#define GPUCA_KRNL_WRAP(x_func, x_class, x_attributes, ...) GPUCA_M_CAT(x_func, GPUCA_M_STRIP_FIRST(x_attributes))(x_class, x_attributes, __VA_ARGS__)
 #endif // GPUCA_GPUCODE
 
-#define GPUCA_KRNL_LB(x_class, x_attributes, ...) GPUCA_KRNL(x_class, (GPUCA_M_STRIP(x_attributes), REG, (GPUCA_M_CAT(GPUCA_LB_, GPUCA_M_KRNL_NAME(x_class)))), __VA_ARGS__)
+#define GPUCA_KRNL_LB(x_class, x_attributes, ...) GPUCA_KRNL(x_class, (REG, (GPUCA_M_CAT(GPUCA_LB_, GPUCA_M_KRNL_NAME(x_class))), GPUCA_M_STRIP(x_attributes)), __VA_ARGS__)
 
 #endif // O2_GPU_GPURECONSTRUCTIONKERNELMACROS_H
 // clang-format on
diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernels.h b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
index d541e36a06af9..ba30f38e902ad 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernels.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
@@ -41,11 +41,8 @@ struct krnlExec {
 };
 struct krnlRunRange {
   constexpr krnlRunRange() = default;
-  constexpr krnlRunRange(uint32_t a) : start(a), num(0) {}
-  constexpr krnlRunRange(uint32_t s, int32_t n) : start(s), num(n) {}
-
-  uint32_t start = 0;
-  int32_t num = 0;
+  constexpr krnlRunRange(uint32_t v) : index(v) {}
+  uint32_t index = 0;
 };
 struct krnlEvent {
   constexpr krnlEvent(deviceEvent* e = nullptr, deviceEvent* el = nullptr, int32_t n = 1) : ev(e), evList(el), nEvents(n) {}
@@ -63,7 +60,7 @@ struct krnlProperties {
 };
 
 struct krnlSetup {
-  krnlSetup(const krnlExec& xx, const krnlRunRange& yy = {0, -1}, const krnlEvent& zz = {nullptr, nullptr, 0}) : x(xx), y(yy), z(zz) {}
+  krnlSetup(const krnlExec& xx, const krnlRunRange& yy = {0}, const krnlEvent& zz = {nullptr, nullptr, 0}) : x(xx), y(yy), z(zz) {}
   krnlExec x;
   krnlRunRange y;
   krnlEvent z;
@@ -98,7 +95,7 @@ class GPUReconstructionKernels : public T
   template <class S, int32_t I = 0, typename... Args>
   using krnlSetupArgs = gpu_reconstruction_kernels::krnlSetupArgs<S, I, Args...>;
 
-#define GPUCA_KRNL(x_class, attributes, x_arguments, x_forward, x_types)                                                                                \
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)                                                                              \
   virtual void runKernelImpl(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args)                                          \
   {                                                                                                                                                     \
     T::template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(args);                                                                                 \
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 7fb3744551953..d2adc3cc1fd19 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -380,7 +380,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
   GPUFailedMsg(cuModuleLoadData(mInternals->kernelModules.back().get(), GPUCA_M_CAT3(_binary_cuda_kernel_module_fatbin_krnl_, GPUCA_M_KRNL_NAME(x_class), GPUCA_M_CAT(PER_KERNEL_OBJECT_EXT, _start))));
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
-      loadKernelModules(true, false);
+      loadKernelModules(true);
     }
 #endif
     void* devPtrConstantMem = nullptr;
@@ -630,13 +630,10 @@ void GPUReconstructionCUDABackend::PrintKernelOccupancies()
   }
 }
 
-void GPUReconstructionCUDA::loadKernelModules(bool perKernel, bool perSingleMulti)
+void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
 {
   uint32_t j = 0;
-#define GPUCA_KRNL(...)                          \
-  GPUCA_KRNL_WRAP(GPUCA_KRNL_LOAD_, __VA_ARGS__) \
-  j += !perSingleMulti;
-#define GPUCA_KRNL_LOAD_single(x_class, ...)                                                                                                                                               \
+#define GPUCA_KRNL(x_class, ...)                                                                                                                                                           \
   getRTCkernelNum<false, GPUCA_M_KRNL_TEMPLATE(x_class)>(mInternals->kernelFunctions.size());                                                                                              \
   mInternals->kernelFunctions.emplace_back(new CUfunction);                                                                                                                                \
   mInternals->kernelNames.emplace_back(GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))));                                                                                       \
@@ -644,20 +641,9 @@ void GPUReconstructionCUDA::loadKernelModules(bool perKernel, bool perSingleMult
     GPUInfo("Loading kernel %s (j = %u)", GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), j);                                                                                 \
   }                                                                                                                                                                                        \
   GPUFailedMsg(cuModuleGetFunction(mInternals->kernelFunctions.back().get(), *mInternals->kernelModules[perKernel ? j : 0], GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))))); \
-  j += perSingleMulti;
-#define GPUCA_KRNL_LOAD_multi(x_class, ...)                                                                                                                                                         \
-  getRTCkernelNum<true, GPUCA_M_KRNL_TEMPLATE(x_class)>(mInternals->kernelFunctions.size());                                                                                                        \
-  mInternals->kernelFunctions.emplace_back(new CUfunction);                                                                                                                                         \
-  mInternals->kernelNames.emplace_back(GPUCA_M_STR(GPUCA_M_CAT3(krnl_, GPUCA_M_KRNL_NAME(x_class), _multi)));                                                                                       \
-  if (mProcessingSettings.debugLevel >= 3) {                                                                                                                                                        \
-    GPUInfo("Loading kernel %s (j = %u)", GPUCA_M_STR(GPUCA_M_CAT3(krnl_, GPUCA_M_KRNL_NAME(x_class), _multi)), j);                                                                                 \
-  }                                                                                                                                                                                                 \
-  GPUFailedMsg(cuModuleGetFunction(mInternals->kernelFunctions.back().get(), *mInternals->kernelModules[perKernel ? j : 0], GPUCA_M_STR(GPUCA_M_CAT3(krnl_, GPUCA_M_KRNL_NAME(x_class), _multi)))); \
-  j += perSingleMulti;
+  j++;
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
-#undef GPUCA_KRNL_LOAD_single
-#undef GPUCA_KRNL_LOAD_multi
 
   if (j != mInternals->kernelModules.size()) {
     GPUFatal("Did not load all kernels (%u < %u)", j, (uint32_t)mInternals->kernelModules.size());
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index ee2f069028d74..dde70b9076e08 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -98,7 +98,7 @@ class GPUReconstructionCUDA : public GPUReconstructionKernels<GPUReconstructionC
  private:
   int32_t genRTC(std::string& filename, uint32_t& nCompile);
   void genAndLoadRTC();
-  void loadKernelModules(bool perKernel, bool perSingleMulti = true);
+  void loadKernelModules(bool perKernel);
   const char *mRtcSrcExtension = ".src", *mRtcBinExtension = ".o";
 };
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index c22aff4aab28c..0f8d9bf219ba6 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -48,20 +48,15 @@ inline void GPUReconstructionCUDABackend::runKernelBackendInternal(const krnlSet
   {
     auto& x = _xyz.x;
     auto& y = _xyz.y;
-    const void* pArgs[sizeof...(Args) + 3]; // 3 is max: cons mem + y.start + y.num
+    const void* pArgs[sizeof...(Args) + 3]; // 3 is max: cons mem + y.index + y.num
     int32_t arg_offset = 0;
 #ifdef GPUCA_NO_CONSTANT_MEMORY
     arg_offset = 1;
     pArgs[0] = &mDeviceConstantMem;
 #endif
-    pArgs[arg_offset] = &y.start;
-    GPUReconstructionCUDAInternals::getArgPtrs(&pArgs[arg_offset + 1 + (y.num > 1)], args...);
-    if (y.num <= 1) {
-      GPUFailedMsg(cuLaunchKernel(*mInternals->kernelFunctions[getRTCkernelNum<false, T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
-    } else {
-      pArgs[arg_offset + 1] = &y.num;
-      GPUFailedMsg(cuLaunchKernel(*mInternals->kernelFunctions[getRTCkernelNum<true, T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
-    }
+    pArgs[arg_offset] = &y.index;
+    GPUReconstructionCUDAInternals::getArgPtrs(&pArgs[arg_offset + 1], args...);
+    GPUFailedMsg(cuLaunchKernel(*mInternals->kernelFunctions[getRTCkernelNum<false, T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
   }
 }
 
@@ -88,33 +83,31 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
 #undef GPUCA_KRNL_REG
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
 
-#if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1
+#if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1 // ---------- COMPILE_MODE = perkernel ----------
 #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) \
   GPUCA_KRNL_PROP(x_class, x_attributes)                                   \
   template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
-#else
+#else // ---------- COMPILE_MODE = onefile | rdc ----------
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 2
-#define GPUCA_KRNL_DEFONLY
+#define GPUCA_KRNL_DEFONLY // COMPILE_MODE = rdc
 #endif
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)             \
-  GPUCA_KRNL_PROP(x_class, x_attributes)                                               \
-  GPUCA_KRNL_WRAP(GPUCA_KRNL_, x_class, x_attributes, x_arguments, x_forward, x_types) \
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) \
+  GPUCA_KRNL_PROP(x_class, x_attributes)                                   \
+  GPUCA_KRNL_HOST(x_class, x_attributes, x_arguments, x_forward, x_types)  \
   template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
+
 #ifndef __HIPCC__ // CUDA version
-#define GPUCA_KRNL_CALL_single(x_class, ...) \
-  GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))<<<x.nBlocks, x.nThreads, 0, me->mInternals->Streams[x.stream]>>>(GPUCA_CONSMEM_CALL y.start, args...);
-#define GPUCA_KRNL_CALL_multi(x_class, ...) \
-  GPUCA_M_CAT3(krnl_, GPUCA_M_KRNL_NAME(x_class), _multi)<<<x.nBlocks, x.nThreads, 0, me->mInternals->Streams[x.stream]>>>(GPUCA_CONSMEM_CALL y.start, y.num, args...);
+#define GPUCA_KRNL_CALL(x_class, ...) \
+  GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))<<<x.nBlocks, x.nThreads, 0, me->mInternals->Streams[x.stream]>>>(GPUCA_CONSMEM_CALL y.index, args...);
 #else // HIP version
 #undef GPUCA_KRNL_CUSTOM
 #define GPUCA_KRNL_CUSTOM(args) GPUCA_M_STRIP(args)
-#define GPUCA_KRNL_CALL_single(x_class, ...) \
-  hipLaunchKernelGGL(HIP_KERNEL_NAME(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), dim3(x.nBlocks), dim3(x.nThreads), 0, me->mInternals->Streams[x.stream], GPUCA_CONSMEM_CALL y.start, args...);
-#define GPUCA_KRNL_CALL_multi(x_class, ...) \
-  hipLaunchKernelGGL(HIP_KERNEL_NAME(GPUCA_M_CAT3(krnl_, GPUCA_M_KRNL_NAME(x_class), _multi)), dim3(x.nBlocks), dim3(x.nThreads), 0, me->mInternals->Streams[x.stream], GPUCA_CONSMEM_CALL y.start, y.num, args...);
+#define GPUCA_KRNL_CALL(x_class, ...) \
+  hipLaunchKernelGGL(HIP_KERNEL_NAME(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), dim3(x.nBlocks), dim3(x.nThreads), 0, me->mInternals->Streams[x.stream], GPUCA_CONSMEM_CALL y.index, args...);
 #endif // __HIPCC__
-#endif
+
+#endif // ---------- COMPILE_MODE = onefile | rdc ----------
 
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
@@ -137,13 +130,9 @@ int32_t GPUReconstructionCUDABackend::getRTCkernelNum(int32_t k)
 
 void GPUReconstructionCUDABackend::getRTCKernelCalls(std::vector<std::string>& kernels)
 {
-#define GPUCA_KRNL(...) GPUCA_KRNL_WRAP(GPUCA_KRNL_LOAD_, __VA_ARGS__)
-#define GPUCA_KRNL_LOAD_single(...) kernels.emplace_back(GPUCA_M_STR(GPUCA_KRNLGPU_SINGLE(__VA_ARGS__)));
-#define GPUCA_KRNL_LOAD_multi(...) kernels.emplace_back(GPUCA_M_STR(GPUCA_KRNLGPU_MULTI(__VA_ARGS__)));
+#define GPUCA_KRNL(...) kernels.emplace_back(GPUCA_M_STR(GPUCA_KRNLGPU(__VA_ARGS__)));
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
-#undef GPUCA_KRNL_LOAD_single
-#undef GPUCA_KRNL_LOAD_multi
 }
 
 #ifndef GPUCA_NO_CONSTANT_MEMORY
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
index bcf61eb07383f..3140c6b9158ad 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
@@ -15,9 +15,7 @@
 #define GPUCA_GPUCODE_COMPILEKERNELS
 #include "GPUReconstructionCUDAIncludesHost.h"
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
-#define GPUCA_KRNL(...) GPUCA_KRNL_WRAP(GPUCA_KRNL_LOAD_, __VA_ARGS__)
-#define GPUCA_KRNL_LOAD_single(...) GPUCA_KRNLGPU_SINGLE(__VA_ARGS__);
-#define GPUCA_KRNL_LOAD_multi(...) GPUCA_KRNLGPU_MULTI(__VA_ARGS__);
+#define GPUCA_KRNL(...) GPUCA_KRNLGPU(__VA_ARGS__);
 #include "GPUReconstructionKernelMacros.h"
 
 // clang-format off
diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
index ddbc9285763a9..427938a3bd704 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
@@ -15,9 +15,7 @@
 #define GPUCA_GPUCODE_COMPILEKERNELS
 #include "GPUReconstructionHIPIncludesHost.h"
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
-#define GPUCA_KRNL(...) GPUCA_KRNL_WRAP(GPUCA_KRNL_LOAD_, __VA_ARGS__)
-#define GPUCA_KRNL_LOAD_single(...) GPUCA_KRNLGPU_SINGLE(__VA_ARGS__);
-#define GPUCA_KRNL_LOAD_multi(...) GPUCA_KRNLGPU_MULTI(__VA_ARGS__);
+#define GPUCA_KRNL(...) GPUCA_KRNLGPU(__VA_ARGS__);
 #include "GPUReconstructionKernelMacros.h"
 
 // clang-format off
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
index 4a3cda6c2cddc..10a425e4c76e8 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
@@ -75,14 +75,10 @@ typedef signed char int8_t;
 
 // if (gpu_mem != pTracker.GPUParametersConst()->gpumem) return; //TODO!
 
-#define GPUCA_KRNL(...) GPUCA_KRNL_WRAP(GPUCA_KRNL_LOAD_, __VA_ARGS__)
-#define GPUCA_KRNL_LOAD_single(...) GPUCA_KRNLGPU_SINGLE(__VA_ARGS__)
-#define GPUCA_KRNL_LOAD_multi(...) GPUCA_KRNLGPU_MULTI(__VA_ARGS__)
+#define GPUCA_KRNL(...) GPUCA_KRNLGPU(__VA_ARGS__)
 #define GPUCA_CONSMEM_PTR GPUglobal() char *gpu_mem, GPUconstant() GPUConstantMem* pConstant,
 #define GPUCA_CONSMEM (*pConstant)
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
-#undef GPUCA_KRNL_LOAD_single
-#undef GPUCA_KRNL_LOAD_multi
 
 // clang-format on
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index 15015cdcb43c5..5132baa444cd9 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -56,9 +56,9 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
   void RecordMarker(deviceEvent* ev, int32_t stream) override;
 
   template <class T, int32_t I = 0>
-  int32_t AddKernel(bool multi = false);
+  int32_t AddKernel();
   template <class T, int32_t I = 0>
-  uint32_t FindKernel(int32_t num);
+  uint32_t FindKernel();
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
   template <class T, int32_t I = 0>
@@ -69,7 +69,7 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
 
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
-  template <class S, class T, int32_t I, bool MULTI>
+  template <class S, class T, int32_t I>
   S& getKernelObject();
 
   int32_t GetOCLPrograms();
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index 8a1c8a6525c0d..8a6c889773cb0 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -24,15 +24,11 @@ inline void GPUReconstructionOCLBackend::runKernelBackendInternal<GPUMemClean16,
 template <class T, int32_t I, typename... Args>
 inline void GPUReconstructionOCLBackend::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
 {
-  cl_kernel k = _xyz.y.num > 1 ? getKernelObject<cl_kernel, T, I, true>() : getKernelObject<cl_kernel, T, I, false>();
+  cl_kernel k = getKernelObject<cl_kernel, T, I>();
   auto& x = _xyz.x;
   auto& y = _xyz.y;
   auto& z = _xyz.z;
-  if (y.num <= 1) {
-    GPUFailedMsg(OCLsetKernelParameters(k, mInternals->mem_gpu, mInternals->mem_constant, y.start, args...));
-  } else {
-    GPUFailedMsg(OCLsetKernelParameters(k, mInternals->mem_gpu, mInternals->mem_constant, y.start, y.num, args...));
-  }
+  GPUFailedMsg(OCLsetKernelParameters(k, mInternals->mem_gpu, mInternals->mem_constant, y.index, args...));
 
   cl_event ev;
   cl_event* evr;
@@ -63,12 +59,9 @@ void GPUReconstructionOCLBackend::runKernelBackend(const krnlSetupArgs<T, I, Arg
 }
 
 template <class T, int32_t I>
-inline uint32_t GPUReconstructionOCLBackend::FindKernel(int32_t num)
+inline uint32_t GPUReconstructionOCLBackend::FindKernel()
 {
   std::string name(GetKernelName<T, I>());
-  if (num > 1) {
-    name += "_multi";
-  }
 
   for (uint32_t k = 0; k < mInternals->kernels.size(); k++) {
     if (mInternals->kernels[k].second == name) {
@@ -80,12 +73,9 @@ inline uint32_t GPUReconstructionOCLBackend::FindKernel(int32_t num)
 }
 
 template <class T, int32_t I>
-int32_t GPUReconstructionOCLBackend::AddKernel(bool multi)
+int32_t GPUReconstructionOCLBackend::AddKernel()
 {
   std::string name(GetKernelName<T, I>());
-  if (multi) {
-    name += "_multi";
-  }
   std::string kname("krnl_" + name);
 
   cl_int ocl_error;
@@ -98,30 +88,21 @@ int32_t GPUReconstructionOCLBackend::AddKernel(bool multi)
   return 0;
 }
 
-template <class S, class T, int32_t I, bool MULTI>
+template <class S, class T, int32_t I>
 S& GPUReconstructionOCLBackend::getKernelObject()
 {
-  static uint32_t krnl = FindKernel<T, I>(MULTI ? 2 : 1);
+  static uint32_t krnl = FindKernel<T, I>();
   return mInternals->kernels[krnl].first;
 }
 
 int32_t GPUReconstructionOCLBackend::AddKernels()
 {
-#define GPUCA_KRNL(...) \
-  GPUCA_KRNL_WRAP(GPUCA_KRNL_LOAD_, __VA_ARGS__)
-#define GPUCA_KRNL_LOAD_single(x_class, ...)              \
-  if (AddKernel<GPUCA_M_KRNL_TEMPLATE(x_class)>(false)) { \
-    return 1;                                             \
-  }
-#define GPUCA_KRNL_LOAD_multi(x_class, ...)              \
-  if (AddKernel<GPUCA_M_KRNL_TEMPLATE(x_class)>(true)) { \
-    return 1;                                            \
+#define GPUCA_KRNL(x_class, ...)                     \
+  if (AddKernel<GPUCA_M_KRNL_TEMPLATE(x_class)>()) { \
+    return 1;                                        \
   }
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
-#undef GPUCA_KRNL_LOAD_single
-#undef GPUCA_KRNL_LOAD_multi
-
   return 0;
 }
 
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index e017d9b60a269..b9da1c9a330d3 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -34,7 +34,7 @@ class GPUChain
   using krnlExec = gpu_reconstruction_kernels::krnlExec;
   using krnlEvent = gpu_reconstruction_kernels::krnlEvent;
   using deviceEvent = gpu_reconstruction_kernels::deviceEvent;
-  static constexpr krnlRunRange krnlRunRangeNone{0, -1};
+  static constexpr krnlRunRange krnlRunRangeNone{0};
   static constexpr krnlEvent krnlEventNone = krnlEvent{nullptr, nullptr, 0};
 
   virtual ~GPUChain() = default;
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index b05fa19785dd8..1f35b6fc468b2 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -20,18 +20,36 @@ define_property(TARGET PROPERTY O2_GPU_KERNEL_FILES)
 set(O2_GPU_KERNEL_WRAPPER_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/GPU/include_gpu_onthefly")
 file(MAKE_DIRECTORY ${O2_GPU_KERNEL_WRAPPER_FOLDER})
 set(O2_GPU_BASE_DIR "${CMAKE_CURRENT_LIST_DIR}/../")
-function(o2_gpu_add_kernel kernel_name kernel_files kernel_bounds kernel_type)
-  math(EXPR TMP_CHK "${ARGC} & 1")
-  if(${TMP_CHK})
-    message(FATAL_ERROR "Invalid number of arguments to kernel ${TMP_CHK}, must be odd to have pairs of argument type, argument name")
-  endif()
+function(o2_gpu_add_kernel kernel_name kernel_files)
   list(LENGTH ARGV n)
+  if(${n} GREATER 2)
+    set(kernel_options "${ARGV2}")
+  else()
+    set(kernel_options "")
+  endif()
+  if(kernel_options MATCHES "^LB")
+    set(TMP_BOUNDS "_LB")
+  elseif(kernel_options MATCHES "^NO" OR kernel_options STREQUAL "")
+    set(TMP_BOUNDS "")
+  else()
+    message(FATAL_ERROR "Invalid kernel options, must contain bounds at first")
+  endif()
+  string(LENGTH "${kernel_options}" TMP_CHK)
+  if(${TMP_CHK} GREATER 3)
+    string(SUBSTRING "${kernel_options}" 3 -1 kernel_extra)
+  else()
+    set(kernel_extra "")
+  endif()
   set(OPT1 "")
   set(OPT2 "")
   set(OPT3 "")
-  if(${n} GREATER 4)
+  if(${n} GREATER 3)
+    math(EXPR TMP_CHK "${ARGC} & 1")
+    if(NOT ${TMP_CHK})
+      message(FATAL_ERROR "Invalid number of arguments to kernel ${ARGC}, must be odd to have pairs of argument type, argument name")
+    endif()
     math(EXPR n "${n} - 1")
-    foreach(i RANGE 4 ${n} 2)
+    foreach(i RANGE 3 ${n} 2)
       math(EXPR j "${i} + 1")
       if(${ARGV${i}} MATCHES "\\*$")
         string(APPEND OPT1 ",GPUPtr1(${ARGV${i}},${ARGV${j}})")
@@ -43,16 +61,9 @@ function(o2_gpu_add_kernel kernel_name kernel_files kernel_bounds kernel_type)
       string(APPEND OPT3 ",${ARGV${i}}")
     endforeach()
   endif()
-  if(kernel_bounds MATCHES "^LB")
-    set(TMP_BOUNDS "_LB")
-  elseif(kernel_bounds MATCHES "^NO")
-    set(TMP_BOUNDS "")
-  else()
-    message(FATAL_ERROR "Invalid bounds")
-  endif()
   set(TMP_PRE "")
   set(TMP_POST "")
-  set(TMP_KERNEL "GPUCA_KRNL${TMP_BOUNDS}((${kernel_name}), (${kernel_type}), (${OPT1}), (${OPT2}), (${OPT3}))\n")
+  set(TMP_KERNEL "GPUCA_KRNL${TMP_BOUNDS}((${kernel_name}), (${kernel_extra}), (${OPT1}), (${OPT2}), (${OPT3}))\n")
   separate_arguments(kernel_files NATIVE_COMMAND ${kernel_files})
   list(GET kernel_files 0 TMP_KERNEL_CLASS_FILE)
   if (TMP_KERNEL_CLASS_FILE STREQUAL "=")
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index a823fc853e5b1..4b7aab75519fa 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -27,100 +27,100 @@ o2_gpu_kernel_file_list(TPCCLUSTERFINDER ERRORS ClusterAccumulator.cxx)
 o2_gpu_kernel_file_list(TRDTRACKER GPUTRDTrack.cxx GPUTRDTracker.cxx GPUTRDTrackletWord.cxx GeometryBase.cxx)
 o2_gpu_kernel_file_list(GLOBALREFIT TPCMERGER O2PROPAGATOR MATLUT GPUTrackingRefit.cxx)
 
-o2_gpu_add_kernel("GPUTPCNeighboursFinder"                            "= TPCTRACKER"                                          LB      single)
-o2_gpu_add_kernel("GPUTPCNeighboursCleaner"                           "= TPCTRACKER"                                          LB      single)
-o2_gpu_add_kernel("GPUTPCStartHitsFinder"                             "= TPCTRACKER"                                          LB      single)
-o2_gpu_add_kernel("GPUTPCStartHitsSorter"                             "= TPCTRACKER"                                          LB      single)
-o2_gpu_add_kernel("GPUTPCTrackletConstructor, singleSector"           "= TPCTRACKER"                                          LB      single)
-o2_gpu_add_kernel("GPUTPCTrackletConstructor, allSectors"             "= TPCTRACKER"                                          LB      single)
-o2_gpu_add_kernel("GPUTPCTrackletSelector"                            "= TPCTRACKER"                                          LB      single)
-o2_gpu_add_kernel("GPUMemClean16"                                     "GPUGeneralKernels"                                     NO      "simple, REG, (GPUCA_THREAD_COUNT, 1)" void* ptr "uint64_t" size)
-o2_gpu_add_kernel("GPUitoa"                                           "GPUGeneralKernels"                                     NO      "simple, REG, (GPUCA_THREAD_COUNT, 1)" int32_t* ptr "uint64_t" size)
-o2_gpu_add_kernel("GPUTPCExtrapolationTrackingCopyNumbers"            "GPUTPCExtrapolationTracking TPCTRACKER"                NO      single int32_t n)
-o2_gpu_add_kernel("GPUTPCExtrapolationTracking"                       "= TPCTRACKER TPCTRACKLETCONS"                          LB      single)
-o2_gpu_add_kernel("GPUTPCCreateTrackingData"                          "= TPCTRACKER TPCSECTORDATA"                            LB      single)
-o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, hitData"             "= TPCTRACKER"                                          NO      single)
-o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, startHits"           "= TPCTRACKER"                                          NO      single)
-o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, sectorTracks"        "= TPCTRACKER"                                          NO      single)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, clearIds"            "= TPCMERGER"                                           NO      single int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, sectorTracks"        "= TPCMERGER"                                           NO      single int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks1" "= TPCMERGER"                                           NO      single int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks2" "= TPCMERGER"                                           NO      single int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, borderTracks"        "= TPCMERGER"                                           NO      single int8_t parameter)
-o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fill"                    "= TPCOCCUPANCY"                                        LB      simple GPUTPCClusterOccupancyMapBin* map)
-o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fold"                    "= TPCOCCUPANCY"                                        LB      simple GPUTPCClusterOccupancyMapBin* map "uint32_t*" output)
-o2_gpu_add_kernel("GPUTPCGMMergerTrackFit"                            "GPUTPCGMMergerGPU TPCMERGER TPCTRACKER MATLUT TPCDEDX" LB      simple int32_t mode)
-o2_gpu_add_kernel("GPUTPCGMMergerFollowLoopers"                       "GPUTPCGMMergerGPU TPCMERGER TPCTRACKER MATLUT"         LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerUnpackResetIds"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple int32_t iSector)
-o2_gpu_add_kernel("GPUTPCGMMergerSectorRefit"                         "GPUTPCGMMergerGPU TPCMERGER MATLUT"                    LB      simple int32_t iSector)
-o2_gpu_add_kernel("GPUTPCGMMergerUnpackGlobal"                        "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple int32_t iSector)
-o2_gpu_add_kernel("GPUTPCGMMergerUnpackSaveNumber"                    "GPUTPCGMMergerGPU TPCMERGER"                           NO      simple int32_t id)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step0"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step1"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step2"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step3"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step4"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple int8_t useOrigTrackParam int8_t mergeAll)
-o2_gpu_add_kernel("GPUTPCGMMergerClearLinks"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple int8_t output)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeWithinPrepare"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeSectorsPrepare"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple int32_t border0 int32_t border1 int8_t useOrigTrackParam)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step0"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple int32_t iSector int8_t withinSector int8_t mergeMode)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step1"                 "GPUTPCGMMergerGPU TPCMERGER"                           NO      simple int32_t iSector int8_t withinSector int8_t mergeMode)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step2"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple int32_t iSector int8_t withinSector int8_t mergeMode)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, variant"               "GPUTPCGMMergerGPU TPCMERGER"                           NO      simple gputpcgmmergertypes::GPUTPCGMBorderRange* range int32_t N int32_t cmpMax)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeCE"                             "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerLinkExtrapolatedTracks"              "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerCollect"                             "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerSortTracks"                          "GPUTPCGMMergerGPU TPCMERGER"                           NO      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerSortTracksQPt"                       "GPUTPCGMMergerGPU TPCMERGER"                           NO      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerSortTracksPrepare"                   "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step0"              "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step1"              "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step2"              "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step0"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step1"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step2"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step0"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step1"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step2"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMO2Output, prepare"                         "= TPCMERGER"                                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMO2Output, sort"                            "= TPCMERGER"                                           NO      simple)
-o2_gpu_add_kernel("GPUTPCGMO2Output, output"                          "= TPCMERGER"                                           LB      simple)
-o2_gpu_add_kernel("GPUTPCGMO2Output, mc"                              "= TPCMERGER"                                           NO      simple)
-o2_gpu_add_kernel("GPUTRDTrackerKernels, gpuVersion"                  "= TRDTRACKER MATLUT TPCMERGER"                         LB      simple GPUTRDTrackerGPU* externalInstance)
-o2_gpu_add_kernel("GPUTRDTrackerKernels, o2Version"                   "= TRDTRACKER MATLUT O2PROPAGATOR"                      LB      simple GPUTRDTracker* externalInstance)
-o2_gpu_add_kernel("GPUITSFitterKernels"                               "= TPCMERGER MATLUT"                                    LB      simple)
-o2_gpu_add_kernel("GPUTPCConvertKernel"                               "="                                                     LB      simple)
-o2_gpu_add_kernel("GPUTPCCompressionKernels, step0attached"           "= TPCCOMPRESSION"                                      LB      simple)
-o2_gpu_add_kernel("GPUTPCCompressionKernels, step1unattached"         "= ERRORS"                                              LB      simple)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, unbuffered"        "GPUTPCCompressionKernels"                              LB      simple)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered32"        "GPUTPCCompressionKernels"                              LB      simple)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered64"        "GPUTPCCompressionKernels"                              LB      simple)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered128"       "GPUTPCCompressionKernels"                              LB      simple)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, multiBlock"        "GPUTPCCompressionKernels"                              LB      simple)
-o2_gpu_add_kernel("GPUTPCDecompressionKernels, step0attached"         "= TPCDECOMPRESSION"                                    LB      simple int32_t trackStart int32_t trackEnd)
-o2_gpu_add_kernel("GPUTPCDecompressionKernels, step1unattached"       "= TPCDECOMPRESSION"                                    LB      simple int32_t sectorStart int32_t nSectors)
-o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, sortPerSectorRow"  "GPUTPCDecompressionKernels"                            LB      simple)
-o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, countFilteredClusters"  "GPUTPCDecompressionKernels"                       LB      simple)
-o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, storeFilteredClusters"  "GPUTPCDecompressionKernels"                       LB      simple)
-o2_gpu_add_kernel("GPUTPCCFCheckPadBaseline"                          "= TPCCLUSTERFINDER"                                    LB      single)
-o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, fillIndexMap"             "= TPCCLUSTERFINDER"                                    LB      single)
-o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, fillFromDigits"           "= TPCCLUSTERFINDER"                                    LB      single)
-o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, findFragmentStart"        "= TPCCLUSTERFINDER"                                    LB      single int8_t setPositions)
-o2_gpu_add_kernel("GPUTPCCFPeakFinder"                                "= TPCCLUSTERFINDER"                                    LB      single)
-o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, noiseSuppression"        "= TPCCLUSTERFINDER"                                    LB      single)
-o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, updatePeaks"             "= TPCCLUSTERFINDER"                                    LB      single)
-o2_gpu_add_kernel("GPUTPCCFDeconvolution"                             "= TPCCLUSTERFINDER"                                    LB      single)
-o2_gpu_add_kernel("GPUTPCCFClusterizer"                               "= TPCCLUSTERFINDER"                                    LB      single int8_t onlyMC)
-o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, setRowOffsets"           "= TPCCLUSTERFINDER"                                    NO      single)
-o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, flatten"                 "= TPCCLUSTERFINDER"                                    NO      single GPUTPCLinearLabels* out)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanStart"               "= TPCCLUSTERFINDER"                                    LB      single int32_t iBuf int32_t stage)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanUp"                  "= TPCCLUSTERFINDER"                                    LB      single int32_t iBuf int32_t nElems)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanTop"                 "= TPCCLUSTERFINDER"                                    LB      single int32_t iBuf int32_t nElems)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                "= TPCCLUSTERFINDER"                                    LB      single int32_t iBuf "uint32_t" offset int32_t nElems)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"           "= TPCCLUSTERFINDER"                                    LB      single int32_t iBuf int32_t stage ChargePos* in ChargePos* out)
-o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                  "= TPCCLUSTERFINDER"                                    LB      single int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                              "GPUTPCCFDecodeZS"                                      LB      single int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                         "GPUTPCCFDecodeZS"                                      LB      single int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFGather"                                    "="                                                     LB      single o2::tpc::ClusterNative* dest)
-o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                "= GLOBALREFIT "                                        LB      simple)
-o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"        "= GLOBALREFIT "                                        LB      simple)
+o2_gpu_add_kernel("GPUTPCNeighboursFinder"                            "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCNeighboursCleaner"                           "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCStartHitsFinder"                             "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCStartHitsSorter"                             "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCTrackletConstructor, singleSector"           "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCTrackletConstructor, allSectors"             "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCTrackletSelector"                            "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUMemClean16"                                     "GPUGeneralKernels"                                     "NO_REG, (GPUCA_THREAD_COUNT, 1)" void* ptr "uint64_t" size)
+o2_gpu_add_kernel("GPUitoa"                                           "GPUGeneralKernels"                                     "NO_REG, (GPUCA_THREAD_COUNT, 1)" int32_t* ptr "uint64_t" size)
+o2_gpu_add_kernel("GPUTPCExtrapolationTrackingCopyNumbers"            "GPUTPCExtrapolationTracking TPCTRACKER"                NO int32_t n)
+o2_gpu_add_kernel("GPUTPCExtrapolationTracking"                       "= TPCTRACKER TPCTRACKLETCONS"                          LB)
+o2_gpu_add_kernel("GPUTPCCreateTrackingData"                          "= TPCTRACKER TPCSECTORDATA"                            LB)
+o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, hitData"             "= TPCTRACKER")
+o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, startHits"           "= TPCTRACKER")
+o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, sectorTracks"        "= TPCTRACKER")
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, clearIds"            "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, sectorTracks"        "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks1" "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks2" "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, borderTracks"        "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fill"                    "= TPCOCCUPANCY"                                        LB GPUTPCClusterOccupancyMapBin* map)
+o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fold"                    "= TPCOCCUPANCY"                                        LB GPUTPCClusterOccupancyMapBin* map "uint32_t*" output)
+o2_gpu_add_kernel("GPUTPCGMMergerTrackFit"                            "GPUTPCGMMergerGPU TPCMERGER TPCTRACKER MATLUT TPCDEDX" LB int32_t mode)
+o2_gpu_add_kernel("GPUTPCGMMergerFollowLoopers"                       "GPUTPCGMMergerGPU TPCMERGER TPCTRACKER MATLUT"         LB)
+o2_gpu_add_kernel("GPUTPCGMMergerUnpackResetIds"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector)
+o2_gpu_add_kernel("GPUTPCGMMergerSectorRefit"                         "GPUTPCGMMergerGPU TPCMERGER MATLUT"                    LB int32_t iSector)
+o2_gpu_add_kernel("GPUTPCGMMergerUnpackGlobal"                        "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector)
+o2_gpu_add_kernel("GPUTPCGMMergerUnpackSaveNumber"                    "GPUTPCGMMergerGPU TPCMERGER"                           NO int32_t id)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step0"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step1"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step2"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step3"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step4"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB int8_t useOrigTrackParam int8_t mergeAll)
+o2_gpu_add_kernel("GPUTPCGMMergerClearLinks"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB int8_t output)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeWithinPrepare"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeSectorsPrepare"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t border0 int32_t border1 int8_t useOrigTrackParam)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step0"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector int8_t withinSector int8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step1"                 "GPUTPCGMMergerGPU TPCMERGER"                           NO int32_t iSector int8_t withinSector int8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step2"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector int8_t withinSector int8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, variant"               "GPUTPCGMMergerGPU TPCMERGER"                           NO gputpcgmmergertypes::GPUTPCGMBorderRange* range int32_t N int32_t cmpMax)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeCE"                             "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerLinkExtrapolatedTracks"              "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerCollect"                             "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerSortTracks"                          "GPUTPCGMMergerGPU TPCMERGER")
+o2_gpu_add_kernel("GPUTPCGMMergerSortTracksQPt"                       "GPUTPCGMMergerGPU TPCMERGER")
+o2_gpu_add_kernel("GPUTPCGMMergerSortTracksPrepare"                   "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step0"              "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step1"              "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step2"              "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step0"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step1"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step2"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step0"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step1"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step2"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMO2Output, prepare"                         "= TPCMERGER"                                           LB)
+o2_gpu_add_kernel("GPUTPCGMO2Output, sort"                            "= TPCMERGER")
+o2_gpu_add_kernel("GPUTPCGMO2Output, output"                          "= TPCMERGER"                                           LB)
+o2_gpu_add_kernel("GPUTPCGMO2Output, mc"                              "= TPCMERGER")
+o2_gpu_add_kernel("GPUTRDTrackerKernels, gpuVersion"                  "= TRDTRACKER MATLUT TPCMERGER"                         LB GPUTRDTrackerGPU* externalInstance)
+o2_gpu_add_kernel("GPUTRDTrackerKernels, o2Version"                   "= TRDTRACKER MATLUT O2PROPAGATOR"                      LB GPUTRDTracker* externalInstance)
+o2_gpu_add_kernel("GPUITSFitterKernels"                               "= TPCMERGER MATLUT"                                    LB)
+o2_gpu_add_kernel("GPUTPCConvertKernel"                               "="                                                     LB)
+o2_gpu_add_kernel("GPUTPCCompressionKernels, step0attached"           "= TPCCOMPRESSION"                                      LB)
+o2_gpu_add_kernel("GPUTPCCompressionKernels, step1unattached"         "= ERRORS"                                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, unbuffered"        "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered32"        "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered64"        "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered128"       "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, multiBlock"        "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCDecompressionKernels, step0attached"         "= TPCDECOMPRESSION"                                    LB int32_t trackStart int32_t trackEnd)
+o2_gpu_add_kernel("GPUTPCDecompressionKernels, step1unattached"       "= TPCDECOMPRESSION"                                    LB int32_t sectorStart int32_t nSectors)
+o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, sortPerSectorRow"  "GPUTPCDecompressionKernels"                            LB)
+o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, countFilteredClusters"  "GPUTPCDecompressionKernels"                       LB)
+o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, storeFilteredClusters"  "GPUTPCDecompressionKernels"                       LB)
+o2_gpu_add_kernel("GPUTPCCFCheckPadBaseline"                          "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, fillIndexMap"             "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, fillFromDigits"           "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, findFragmentStart"        "= TPCCLUSTERFINDER"                                    LB int8_t setPositions)
+o2_gpu_add_kernel("GPUTPCCFPeakFinder"                                "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, noiseSuppression"        "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, updatePeaks"             "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFDeconvolution"                             "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFClusterizer"                               "= TPCCLUSTERFINDER"                                    LB int8_t onlyMC)
+o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, setRowOffsets"           "= TPCCLUSTERFINDER")
+o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, flatten"                 "= TPCCLUSTERFINDER"                                    NO GPUTPCLinearLabels* out)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanStart"               "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanUp"                  "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanTop"                 "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                "= TPCCLUSTERFINDER"                                    LB int32_t iBuf "uint32_t" offset int32_t nElems)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"           "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage ChargePos* in ChargePos* out)
+o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                  "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                              "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                         "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFGather"                                    "="                                                     LB o2::tpc::ClusterNative* dest)
+o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                "= GLOBALREFIT "                                        LB)
+o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"        "= GLOBALREFIT "                                        LB)

From 4795ce795401ca4e8c40ca150da0f820e6001150 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 11 Mar 2025 22:12:24 +0100
Subject: [PATCH 0049/1764] GPU: Improve kernel attribute resolution
 preprocessor logic

---
 .../Base/GPUReconstructionKernelMacros.h      | 28 +++++++++----------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
index f80b324970dc9..cd1180cbc9991 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
@@ -35,26 +35,24 @@
 #ifndef GPUCA_KRNL_REG
 #define GPUCA_KRNL_REG(...)
 #endif
-#define GPUCA_KRNL_REG_INTERNAL_PROP(...) GPUCA_M_STRIP(__VA_ARGS__)
 #ifndef GPUCA_KRNL_CUSTOM
 #define GPUCA_KRNL_CUSTOM(...)
 #endif
-#define GPUCA_KRNL_CUSTOM_INTERNAL_PROP(...)
-#define GPUCA_ATTRRES_REG(XX, reg, num, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_KRNL_REG, XX))(num) GPUCA_ATTRRES2(XX, __VA_ARGS__)
-#define GPUCA_ATTRRES2_REG(XX, reg, num, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_KRNL_REG, XX))(num) GPUCA_ATTRRES3(XX, __VA_ARGS__)
-#define GPUCA_ATTRRES_CUSTOM(XX, custom, args, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_KRNL_CUSTOM, XX))(args) GPUCA_ATTRRES2(XX, __VA_ARGS__)
-#define GPUCA_ATTRRES2_CUSTOM(XX, custom, args, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_KRNL_CUSTOM, XX))(args) GPUCA_ATTRRES3(XX, __VA_ARGS__)
-#define GPUCA_ATTRRES_NONE(XX, ...)
-#define GPUCA_ATTRRES2_NONE(XX, ...)
-#define GPUCA_ATTRRES_(XX, ...)
-#define GPUCA_ATTRRES2_(XX, ...)
-#define GPUCA_ATTRRES3(XX) // 3 attributes not supported
-#define GPUCA_ATTRRES2(XX, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES2_, GPUCA_M_FIRST(__VA_ARGS__)))(XX, __VA_ARGS__)
-#define GPUCA_ATTRRES(XX, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(XX, __VA_ARGS__)
+#define GPUCA_KRNL_REG_EXTRREG(...) GPUCA_M_STRIP(__VA_ARGS__)
+#define GPUCA_KRNL_CUSTOM_EXTRREG(MODE, ...) GPUCA_ATTRRES_XCUSTOM(MODE, __VA_ARGS__)
+#define GPUCA_KRNL_NONE_EXTRREG(MODE, ...) GPUCA_ATTRRES_XNONE(MODE, __VA_ARGS__)
+#define GPUCA_ATTRRES_REG(MODE, reg, num, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_KRNL_REG, MODE))(num) GPUCA_ATTRRES_XREG (MODE, __VA_ARGS__)
+#define GPUCA_ATTRRES_CUSTOM(MODE, custom, args, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_KRNL_CUSTOM, MODE))(args) GPUCA_ATTRRES_XCUSTOM(MODE, __VA_ARGS__)
+#define GPUCA_ATTRRES_NONE(MODE, none, ...) GPUCA_ATTRRES_XNONE(MODE, __VA_ARGS__)
+#define GPUCA_ATTRRES_(MODE, ...)
+#define GPUCA_ATTRRES_XNONE(MODE, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(MODE, __VA_ARGS__)
+#define GPUCA_ATTRRES_XCUSTOM(MODE, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(MODE, __VA_ARGS__)
+#define GPUCA_ATTRRES_XREG(MODE, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(MODE, __VA_ARGS__)
+#define GPUCA_ATTRRES(MODE, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(MODE, __VA_ARGS__)
 
 // GPU Kernel entry point
 #define GPUCA_KRNLGPU_DEF(x_class, x_attributes, x_arguments, ...) \
-  GPUg() void GPUCA_ATTRRES(,GPUCA_M_STRIP(x_attributes)) GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))(GPUCA_CONSMEM_PTR int32_t _iSector_internal GPUCA_M_STRIP(x_arguments))
+  GPUg() void GPUCA_ATTRRES(, GPUCA_M_STRIP(x_attributes)) GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))(GPUCA_CONSMEM_PTR int32_t _iSector_internal GPUCA_M_STRIP(x_arguments))
 
 #ifdef GPUCA_KRNL_DEFONLY
 #define GPUCA_KRNLGPU(...) GPUCA_KRNLGPU_DEF(__VA_ARGS__);
@@ -83,7 +81,7 @@
 
 #define GPUCA_KRNL_PROP(x_class, x_attributes) \
   template <> gpu_reconstruction_kernels::krnlProperties GPUCA_KRNL_BACKEND_CLASS::getKernelPropertiesBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>() { \
-    gpu_reconstruction_kernels::krnlProperties ret = gpu_reconstruction_kernels::krnlProperties{GPUCA_ATTRRES(_INTERNAL_PROP,GPUCA_M_STRIP(x_attributes))}; \
+    gpu_reconstruction_kernels::krnlProperties ret = gpu_reconstruction_kernels::krnlProperties{GPUCA_ATTRRES(_EXTRREG, GPUCA_M_STRIP(x_attributes))}; \
     return ret.nThreads > 0 ? ret : gpu_reconstruction_kernels::krnlProperties{(int32_t)mThreadCount}; \
   }
 

From ccabdf2e66a38222b26dd143c053707341bf2768 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 11 Mar 2025 22:23:47 +0100
Subject: [PATCH 0050/1764] GPU: Remove obsolete
 tracketConstructorWithoutPipeline option

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  6 ---
 .../Base/GPUReconstructionIncludes.h          |  6 ---
 .../Definitions/GPUDefGPUParameters.h         | 16 --------
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 -
 .../Global/GPUChainTrackingSectorTracker.cxx  | 37 +++++++------------
 .../SectorTracker/GPUTPCTracker.cxx           |  2 +-
 6 files changed, 15 insertions(+), 54 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 4b767a6b8a8f7..656fa37fb6a4c 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -270,12 +270,6 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
   }
   if (mProcessingSettings.deterministicGPUReconstruction && mProcessingSettings.debugLevel >= 6) {
     mProcessingSettings.nTPCClustererLanes = 1;
-    if (mProcessingSettings.trackletConstructorInPipeline < 0) {
-      mProcessingSettings.trackletConstructorInPipeline = 1;
-    }
-    if (mProcessingSettings.trackletSelectorSectors < 0) {
-      mProcessingSettings.trackletSelectorSectors = 1;
-    }
   }
   if (mProcessingSettings.createO2Output > 1 && mProcessingSettings.runQA && mProcessingSettings.qcRunFraction == 100.f) {
     mProcessingSettings.createO2Output = 1;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludes.h b/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
index f18ab21dc3972..6aba7e30a49d7 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
@@ -30,12 +30,6 @@
 #include <fstream>
 
 #define GPUCA_GPUReconstructionUpdateDefaults()                                             \
-  if (mProcessingSettings.trackletConstructorInPipeline < 0) {                              \
-    mProcessingSettings.trackletConstructorInPipeline = GPUCA_CONSTRUCTOR_IN_PIPELINE;      \
-  }                                                                                         \
-  if (mProcessingSettings.trackletSelectorSectors < 0) {                                    \
-    mProcessingSettings.trackletSelectorSectors = GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT;     \
-  }                                                                                         \
   if (mProcessingSettings.alternateBorderSort < 0) {                                        \
     mProcessingSettings.alternateBorderSort = GPUCA_ALTERNATE_BORDER_SORT;                  \
   }                                                                                         \
diff --git a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
index 772b4684b590e..3ed6c25762405 100644
--- a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
+++ b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
@@ -84,11 +84,9 @@
   #define GPUCA_LB_COMPRESSION_GATHER 1024
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 1
   #define GPUCA_SORT_BEFORE_FIT 1
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT 1
   #define GPUCA_NO_ATOMIC_PRECHECK 1
   #define GPUCA_DEDX_STORAGE_TYPE uint16_t
   #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
@@ -149,11 +147,9 @@
   #define GPUCA_LB_COMPRESSION_GATHER 1024
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 1
   #define GPUCA_SORT_BEFORE_FIT 1
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT 1
   #define GPUCA_NO_ATOMIC_PRECHECK 1
   #define GPUCA_DEDX_STORAGE_TYPE uint16_t
   #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
@@ -214,11 +210,9 @@
   #define GPUCA_LB_COMPRESSION_GATHER 1024
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 1
   #define GPUCA_SORT_BEFORE_FIT 1
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT 1
   #define GPUCA_NO_ATOMIC_PRECHECK 1
   #define GPUCA_DEDX_STORAGE_TYPE uint16_t
   #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
@@ -271,11 +265,9 @@
   #define GPUCA_LB_COMPRESSION_GATHER 1024
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 1
   #define GPUCA_SORT_BEFORE_FIT 1
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT 1
   #define GPUCA_NO_ATOMIC_PRECHECK 1
   #define GPUCA_COMP_GATHER_KERNEL 4
   #define GPUCA_COMP_GATHER_MODE 3
@@ -530,9 +522,6 @@
   #ifndef GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 12
   #endif
-  #ifndef GPUCA_CONSTRUCTOR_IN_PIPELINE
-  #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
-  #endif
   #ifndef GPUCA_ALTERNATE_BORDER_SORT
   #define GPUCA_ALTERNATE_BORDER_SORT 0
   #endif
@@ -542,9 +531,6 @@
   #ifndef GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
   #endif
-  #ifndef GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT
-  #define GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT 8                          // Currently must be smaller than avaiable MultiProcessors on GPU or will result in wrong results
-  #endif
   #ifndef GPUCA_COMP_GATHER_KERNEL
   #define GPUCA_COMP_GATHER_KERNEL 0
   #endif
@@ -554,11 +540,9 @@
 #else
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
   #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 0
-  #define GPUCA_CONSTRUCTOR_IN_PIPELINE 1
   #define GPUCA_ALTERNATE_BORDER_SORT 0
   #define GPUCA_SORT_BEFORE_FIT 0
   #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
-  #define GPUCA_TRACKLET_SELECTOR_SECTOR_COUNT 1
   #define GPUCA_THREAD_COUNT_FINDER 1
   #define GPUCA_COMP_GATHER_KERNEL 0
   #define GPUCA_COMP_GATHER_MODE 0
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 5663aed8033b7..9b6be7743e485 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -257,8 +257,6 @@ AddOption(autoAdjustHostThreads, bool, true, "", 0, "Auto-adjust number of OMP t
 AddOption(nStreams, int8_t, 8, "", 0, "Number of GPU streams / command queues")
 AddOption(nTPCClustererLanes, int8_t, -1, "", 0, "Number of TPC clusterers that can run in parallel (-1 = autoset)")
 AddOption(overrideClusterizerFragmentLen, int32_t, -1, "", 0, "Force the cluster max fragment len to a certain value (-1 = autodetect)")
-AddOption(trackletSelectorSectors, int8_t, -1, "", 0, "Number of sectors to processes in parallel at max")
-AddOption(trackletConstructorInPipeline, int8_t, -1, "", 0, "Run tracklet constructor in the pipeline")
 AddOption(delayedOutput, bool, true, "", 0, "Delay output to be parallel to track fit")
 AddOption(mergerSortTracks, int8_t, -1, "", 0, "Sort track indizes for GPU track fit")
 AddOption(alternateBorderSort, int8_t, -1, "", 0, "Alternative implementation for sorting of border tracks")
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 4b9b8c33a0887..0eb8af6a6a006 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -218,27 +218,23 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       AllocateRegisteredMemory(trk.MemoryResOutput());
     }
 
-    if (!(doGPU || GetProcessingSettings().debugLevel >= 1) || GetProcessingSettings().trackletConstructorInPipeline) {
-      runKernel<GPUTPCTrackletConstructor>({GetGridAuto(useStream), {iSector}});
-      DoDebugAndDump(RecoStep::TPCSectorTracking, 128, trk, &GPUTPCTracker::DumpTrackletHits, *mDebugFile);
-      if (GetProcessingSettings().debugMask & 256 && GetProcessingSettings().deterministicGPUReconstruction < 2) {
-        trk.DumpHitWeights(*mDebugFile);
-      }
+    runKernel<GPUTPCTrackletConstructor>({GetGridAuto(useStream), {iSector}});
+    DoDebugAndDump(RecoStep::TPCSectorTracking, 128, trk, &GPUTPCTracker::DumpTrackletHits, *mDebugFile);
+    if (GetProcessingSettings().debugMask & 256 && GetProcessingSettings().deterministicGPUReconstruction < 2) {
+      trk.DumpHitWeights(*mDebugFile);
     }
 
-    if (!(doGPU || GetProcessingSettings().debugLevel >= 1) || GetProcessingSettings().trackletConstructorInPipeline) {
-      runKernel<GPUTPCTrackletSelector>({GetGridAuto(useStream), {iSector}});
-      runKernel<GPUTPCExtrapolationTrackingCopyNumbers>({{1, -ThreadCount(), useStream}, {iSector}}, 1);
-      if (GetProcessingSettings().deterministicGPUReconstruction) {
-        runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::sectorTracks>({GetGrid(1, 1, useStream), {iSector}});
-      }
-      TransferMemoryResourceLinkToHost(RecoStep::TPCSectorTracking, trk.MemoryResCommon(), useStream, &mEvents->sector[iSector]);
-      streamMap[iSector] = useStream;
-      if (GetProcessingSettings().debugLevel >= 3) {
-        GPUInfo("Sector %u, Number of tracks: %d", iSector, *trk.NTracks());
-      }
-      DoDebugAndDump(RecoStep::TPCSectorTracking, 512, trk, &GPUTPCTracker::DumpTrackHits, *mDebugFile);
+    runKernel<GPUTPCTrackletSelector>({GetGridAuto(useStream), {iSector}});
+    runKernel<GPUTPCExtrapolationTrackingCopyNumbers>({{1, -ThreadCount(), useStream}, {iSector}}, 1);
+    if (GetProcessingSettings().deterministicGPUReconstruction) {
+      runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::sectorTracks>({GetGrid(1, 1, useStream), {iSector}});
     }
+    TransferMemoryResourceLinkToHost(RecoStep::TPCSectorTracking, trk.MemoryResCommon(), useStream, &mEvents->sector[iSector]);
+    streamMap[iSector] = useStream;
+    if (GetProcessingSettings().debugLevel >= 3) {
+      GPUInfo("Sector %u, Number of tracks: %d", iSector, *trk.NTracks());
+    }
+    DoDebugAndDump(RecoStep::TPCSectorTracking, 512, trk, &GPUTPCTracker::DumpTrackHits, *mDebugFile);
   });
   mRec->SetNActiveThreadsOuterLoop(1);
   if (error) {
@@ -280,11 +276,6 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
 
         if (GetProcessingSettings().keepAllMemory) {
           TransferMemoryResourcesToHost(RecoStep::TPCSectorTracking, &processors()->tpcTrackers[iSector], -1, true);
-          if (!GetProcessingSettings().trackletConstructorInPipeline) {
-            if (GetProcessingSettings().debugMask & 256 && GetProcessingSettings().deterministicGPUReconstruction < 2) {
-              processors()->tpcTrackers[iSector].DumpHitWeights(*mDebugFile);
-            }
-          }
         }
 
         if (transferRunning[iSector]) {
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index 28521b2987a45..4e815784f7cad 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -93,7 +93,7 @@ void* GPUTPCTracker::SetPointersCommon(void* mem)
 void GPUTPCTracker::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();
-  bool reuseCondition = !mRec->GetProcessingSettings().keepDisplayMemory && mRec->GetProcessingSettings().trackletConstructorInPipeline && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
+  bool reuseCondition = !mRec->GetProcessingSettings().keepDisplayMemory && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
   GPUMemoryReuse reLinks{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerDataLinks, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
   mMemoryResLinks = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersDataLinks, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK, "TPCSectorLinks", reLinks);
   mMemoryResSectorScratch = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersDataScratch, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK | GPUMemoryResource::MEMORY_CUSTOM, "TPCSectorScratch");

From 22a9b80b1c0932cf3c7c11d9a20b197cae11537a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 13:40:43 +0100
Subject: [PATCH 0051/1764] Simplify GPUCAMath a bit

---
 GPU/Common/GPUCommonMath.h                    | 191 +++++++-----------
 .../GPUTPCCompressionKernels.cxx              |   2 +-
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx |   4 +-
 .../display/render/GPUDisplayDraw.cxx         |   2 +-
 4 files changed, 80 insertions(+), 119 deletions(-)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index 5a813b74ed7b6..f4b9cd945799a 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -33,6 +33,15 @@
 #include <cstdint>
 #endif
 
+// GPUCA_CHOICE Syntax: GPUCA_CHOICE(Host, CUDA&HIP, OpenCL)
+#if defined(GPUCA_GPUCODE_DEVICE) && (defined(__CUDACC__) || defined(__HIPCC__)) // clang-format off
+    #define GPUCA_CHOICE(c1, c2, c3) (c2) // Select second option for CUDA and HIP
+#elif defined(GPUCA_GPUCODE_DEVICE) && defined (__OPENCL__)
+    #define GPUCA_CHOICE(c1, c2, c3) (c3) // Select third option for OpenCL
+#else
+    #define GPUCA_CHOICE(c1, c2, c3) (c1) // Select first option for Host
+#endif // clang-format on
+
 namespace o2
 {
 namespace gpu
@@ -44,9 +53,15 @@ class GPUCommonMath
   GPUd() static float2 MakeFloat2(float x, float y); // TODO: Find better appraoch that is constexpr
 
   template <class T>
-  GPUhd() static T Min(const T x, const T y);
+  GPUhd() static T Min(const T x, const T y)
+  {
+    return GPUCA_CHOICE(std::min(x, y), min(x, y), min(x, y));
+  }
   template <class T>
-  GPUhd() static T Max(const T x, const T y);
+  GPUhd() static T Max(const T x, const T y)
+  {
+    return GPUCA_CHOICE(std::max(x, y), max(x, y), max(x, y));
+  }
   template <class T, class S, class R>
   GPUd() static T MinWithRef(T x, T y, S refX, S refY, R& r);
   template <class T, class S, class R>
@@ -74,28 +89,28 @@ class GPUCommonMath
   GPUd() static float Pow(float x, float y);
   GPUd() static float Log(float x);
   GPUd() static float Exp(float x);
-  GPUhdni() static float Copysign(float x, float y);
+  GPUhdni() static float Copysign(float x, float y) { return GPUCA_CHOICE(std::copysignf(x, y), copysignf(x, y), copysign(x, y)); }
   GPUd() static constexpr float TwoPi() { return 6.2831853f; }
   GPUd() static constexpr float Pi() { return 3.1415927f; }
   GPUd() static float Round(float x);
-  GPUd() static float Floor(float x);
+  GPUd() static float Floor(float x) { return GPUCA_CHOICE(floorf(x), floorf(x), floor(x)); }
   GPUd() static uint32_t Float2UIntReint(const float& x);
-  GPUd() static uint32_t Float2UIntRn(float x);
+  GPUd() static uint32_t Float2UIntRn(float x) { return (uint32_t)(int32_t)(x + 0.5f); }
   GPUd() static int32_t Float2IntRn(float x);
   GPUd() static float Modf(float x, float y);
-  GPUd() static bool Finite(float x);
-  GPUd() static bool IsNaN(float x);
+  GPUd() static bool Finite(float x) { return GPUCA_CHOICE(std::isfinite(x), isfinite(x), isfinite(x)); }
+  GPUd() static bool IsNaN(float x) { return GPUCA_CHOICE(std::isnan(x), isnan(x), isnan(x)); }
   GPUd() static bool FiniteRelaxed(float x); // always true if not using NO_FAST_MATH
   GPUd() static bool IsNaNRelaxed(float x);  // always true if not using NO_FAST_MATH
-  GPUd() static float QuietNaN();
+  GPUd() static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
   GPUd() static uint32_t Clz(uint32_t val);
   GPUd() static uint32_t Popcount(uint32_t val);
 
   GPUd() static void memcpy(void* dst, const void* src, size_t size);
 
-  GPUhdni() static float Hypot(float x, float y);
-  GPUhdni() static float Hypot(float x, float y, float z);
-  GPUhdni() static float Hypot(float x, float y, float z, float w);
+  GPUhdi() static float Hypot(float x, float y) { return Sqrt(x * x + y * y); }
+  GPUhdi() static float Hypot(float x, float y, float z) { return Sqrt(x * x + y * y + z * z); }
+  GPUhdi() static float Hypot(float x, float y, float z, float w) { return Sqrt(x * x + y * y + z * z + w * w); }
 
   template <typename T>
   GPUhd() static void Swap(T& a, T& b);
@@ -154,15 +169,7 @@ class GPUCommonMath
   GPUd() constexpr static T nextMultipleOf(T val);
 
   template <typename... Args>
-  GPUdi() static float Sum2(float w, Args... args)
-  {
-    if constexpr (sizeof...(Args) == 0) {
-      return w * w;
-    } else {
-      return w * w + Sum2(args...);
-    }
-    return 0;
-  }
+  GPUhdni() static float Sum2(float w, Args... args);
 
  private:
   template <class S, class T>
@@ -179,14 +186,16 @@ class GPUCommonMath
 
 typedef GPUCommonMath CAMath;
 
-// CHOICE Syntax: CHOICE(Host, CUDA&HIP, OpenCL)
-#if defined(GPUCA_GPUCODE_DEVICE) && (defined(__CUDACC__) || defined(__HIPCC__)) // clang-format off
-    #define CHOICE(c1, c2, c3) (c2) // Select second option for CUDA and HIP
-#elif defined(GPUCA_GPUCODE_DEVICE) && defined (__OPENCL__)
-    #define CHOICE(c1, c2, c3) (c3) // Select third option for OpenCL
-#else
-    #define CHOICE(c1, c2, c3) (c1) // Select first option for Host
-#endif // clang-format on
+template <typename... Args>
+GPUhdi() float GPUCommonMath::Sum2(float w, Args... args)
+{
+  if constexpr (sizeof...(Args) == 0) {
+    return w * w;
+  } else {
+    return w * w + Sum2(args...);
+  }
+  return 0;
+}
 
 GPUdi() void GPUCommonMath::memcpy(void* dst, const void* src, size_t size)
 {
@@ -230,7 +239,7 @@ GPUdi() float2 GPUCommonMath::MakeFloat2(float x, float y)
 #endif // GPUCA_GPUCODE
 }
 
-GPUdi() float GPUCommonMath::Modf(float x, float y) { return CHOICE(fmodf(x, y), fmodf(x, y), fmod(x, y)); }
+GPUdi() float GPUCommonMath::Modf(float x, float y) { return GPUCA_CHOICE(fmodf(x, y), fmodf(x, y), fmod(x, y)); }
 
 GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
 {
@@ -243,42 +252,36 @@ GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
 #endif
 }
 
-GPUdi() uint32_t GPUCommonMath::Float2UIntRn(float x) { return (uint32_t)(int32_t)(x + 0.5f); }
-GPUdi() float GPUCommonMath::Floor(float x) { return CHOICE(floorf(x), floorf(x), floor(x)); }
-
-GPUdi() bool GPUCommonMath::Finite(float x) { return CHOICE(std::isfinite(x), isfinite(x), isfinite(x)); }
-GPUdi() bool GPUCommonMath::IsNaN(float x) { return CHOICE(std::isnan(x), isnan(x), isnan(x)); }
-GPUdi() float GPUCommonMath::QuietNaN() { return CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
 #ifdef GPUCA_NO_FAST_MATH
-GPUdi() float GPUCommonMath::Round(float x) { return CHOICE(roundf(x), roundf(x), round(x)); }
+GPUdi() float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), roundf(x), round(x)); }
 GPUdi() int32_t GPUCommonMath::Float2IntRn(float x) { return (int32_t)Round(x); }
-GPUhdi() float GPUCommonMath::Sqrt(float x) { return CHOICE(sqrtf(x), (float)sqrt((double)x), sqrt(x)); }
-GPUdi() float GPUCommonMath::ATan(float x) { return CHOICE((float)atan((double)x), (float)atan((double)x), atan(x)); }
-GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return CHOICE((float)atan2((double)y, (double)x), (float)atan2((double)y, (double)x), atan2(y, x)); }
-GPUdi() float GPUCommonMath::Sin(float x) { return CHOICE((float)sin((double)x), (float)sin((double)x), sin(x)); }
-GPUdi() float GPUCommonMath::Cos(float x) { return CHOICE((float)cos((double)x), (float)cos((double)x), cos(x)); }
-GPUdi() float GPUCommonMath::Tan(float x) { return CHOICE((float)tanf((double)x), (float)tanf((double)x), tan(x)); }
-GPUdi() float GPUCommonMath::Pow(float x, float y) { return CHOICE((float)pow((double)x, (double)y), pow((double)x, (double)y), pow(x, y)); }
-GPUdi() float GPUCommonMath::ASin(float x) { return CHOICE((float)asin((double)x), (float)asin((double)x), asin(x)); }
-GPUdi() float GPUCommonMath::ACos(float x) { return CHOICE((float)acos((double)x), (float)acos((double)x), acos(x)); }
-GPUdi() float GPUCommonMath::Log(float x) { return CHOICE((float)log((double)x), (float)log((double)x), log(x)); }
-GPUdi() float GPUCommonMath::Exp(float x) { return CHOICE((float)exp((double)x), (float)exp((double)x), exp(x)); }
+GPUhdi() float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), (float)sqrt((double)x), sqrt(x)); }
+GPUdi() float GPUCommonMath::ATan(float x) { return GPUCA_CHOICE((float)atan((double)x), (float)atan((double)x), atan(x)); }
+GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return GPUCA_CHOICE((float)atan2((double)y, (double)x), (float)atan2((double)y, (double)x), atan2(y, x)); }
+GPUdi() float GPUCommonMath::Sin(float x) { return GPUCA_CHOICE((float)sin((double)x), (float)sin((double)x), sin(x)); }
+GPUdi() float GPUCommonMath::Cos(float x) { return GPUCA_CHOICE((float)cos((double)x), (float)cos((double)x), cos(x)); }
+GPUdi() float GPUCommonMath::Tan(float x) { return GPUCA_CHOICE((float)tanf((double)x), (float)tanf((double)x), tan(x)); }
+GPUdi() float GPUCommonMath::Pow(float x, float y) { return GPUCA_CHOICE((float)pow((double)x, (double)y), pow((double)x, (double)y), pow(x, y)); }
+GPUdi() float GPUCommonMath::ASin(float x) { return GPUCA_CHOICE((float)asin((double)x), (float)asin((double)x), asin(x)); }
+GPUdi() float GPUCommonMath::ACos(float x) { return GPUCA_CHOICE((float)acos((double)x), (float)acos((double)x), acos(x)); }
+GPUdi() float GPUCommonMath::Log(float x) { return GPUCA_CHOICE((float)log((double)x), (float)log((double)x), log(x)); }
+GPUdi() float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE((float)exp((double)x), (float)exp((double)x), exp(x)); }
 GPUdi() bool GPUCommonMath::FiniteRelaxed(float x) { return Finite(x); }
 GPUdi() bool GPUCommonMath::IsNaNRelaxed(float x) { return IsNaN(x); }
 #else
-GPUdi() float GPUCommonMath::Round(float x) { return CHOICE(roundf(x), rintf(x), rint(x)); }
-GPUdi() int32_t GPUCommonMath::Float2IntRn(float x) { return CHOICE((int32_t)Round(x), __float2int_rn(x), (int32_t)Round(x)); }
-GPUhdi() float GPUCommonMath::Sqrt(float x) { return CHOICE(sqrtf(x), sqrtf(x), sqrt(x)); }
-GPUdi() float GPUCommonMath::ATan(float x) { return CHOICE(atanf(x), atanf(x), atan(x)); }
-GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return CHOICE(atan2f(y, x), atan2f(y, x), atan2(y, x)); }
-GPUdi() float GPUCommonMath::Sin(float x) { return CHOICE(sinf(x), sinf(x), sin(x)); }
-GPUdi() float GPUCommonMath::Cos(float x) { return CHOICE(cosf(x), cosf(x), cos(x)); }
-GPUdi() float GPUCommonMath::Tan(float x) { return CHOICE(tanf(x), tanf(x), tan(x)); }
-GPUdi() float GPUCommonMath::Pow(float x, float y) { return CHOICE(powf(x, y), powf(x, y), pow(x, y)); }
-GPUdi() float GPUCommonMath::ASin(float x) { return CHOICE(asinf(x), asinf(x), asin(x)); }
-GPUdi() float GPUCommonMath::ACos(float x) { return CHOICE(acosf(x), acosf(x), acos(x)); }
-GPUdi() float GPUCommonMath::Log(float x) { return CHOICE(logf(x), logf(x), log(x)); }
-GPUdi() float GPUCommonMath::Exp(float x) { return CHOICE(expf(x), expf(x), exp(x)); }
+GPUdi() float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), rintf(x), rint(x)); }
+GPUdi() int32_t GPUCommonMath::Float2IntRn(float x) { return GPUCA_CHOICE((int32_t)Round(x), __float2int_rn(x), (int32_t)Round(x)); }
+GPUhdi() float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), sqrtf(x), sqrt(x)); }
+GPUdi() float GPUCommonMath::ATan(float x) { return GPUCA_CHOICE(atanf(x), atanf(x), atan(x)); }
+GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return GPUCA_CHOICE(atan2f(y, x), atan2f(y, x), atan2(y, x)); }
+GPUdi() float GPUCommonMath::Sin(float x) { return GPUCA_CHOICE(sinf(x), sinf(x), sin(x)); }
+GPUdi() float GPUCommonMath::Cos(float x) { return GPUCA_CHOICE(cosf(x), cosf(x), cos(x)); }
+GPUdi() float GPUCommonMath::Tan(float x) { return GPUCA_CHOICE(tanf(x), tanf(x), tan(x)); }
+GPUdi() float GPUCommonMath::Pow(float x, float y) { return GPUCA_CHOICE(powf(x, y), powf(x, y), pow(x, y)); }
+GPUdi() float GPUCommonMath::ASin(float x) { return GPUCA_CHOICE(asinf(x), asinf(x), asin(x)); }
+GPUdi() float GPUCommonMath::ACos(float x) { return GPUCA_CHOICE(acosf(x), acosf(x), acos(x)); }
+GPUdi() float GPUCommonMath::Log(float x) { return GPUCA_CHOICE(logf(x), logf(x), log(x)); }
+GPUdi() float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE(expf(x), expf(x), exp(x)); }
 GPUdi() bool GPUCommonMath::FiniteRelaxed(float x) { return true; }
 GPUdi() bool GPUCommonMath::IsNaNRelaxed(float x) { return false; }
 #endif
@@ -293,7 +296,7 @@ GPUhdi() void GPUCommonMath::SinCos(float x, float& s, float& c)
 #elif !defined(GPUCA_GPUCODE_DEVICE) && (defined(__GNU_SOURCE__) || defined(_GNU_SOURCE) || defined(GPUCA_GPUCODE))
   sincosf(x, &s, &c);
 #else
-  CHOICE((void)((s = sinf(x)) + (c = cosf(x))), sincosf(x, &s, &c), s = sincos(x, &c));
+  GPUCA_CHOICE((void)((s = sinf(x)) + (c = cosf(x))), sincosf(x, &s, &c), s = sincos(x, &c));
 #endif
 }
 
@@ -304,14 +307,14 @@ GPUhdi() void GPUCommonMath::SinCosd(double x, double& s, double& c)
 #elif !defined(GPUCA_GPUCODE_DEVICE) && (defined(__GNU_SOURCE__) || defined(_GNU_SOURCE) || defined(GPUCA_GPUCODE))
   sincos(x, &s, &c);
 #else
-  CHOICE((void)((s = sin(x)) + (c = cos(x))), sincos(x, &s, &c), s = sincos(x, &c));
+  GPUCA_CHOICE((void)((s = sin(x)) + (c = cos(x))), sincos(x, &s, &c), s = sincos(x, &c));
 #endif
 }
 
 GPUdi() uint32_t GPUCommonMath::Clz(uint32_t x)
 {
 #if (defined(__GNUC__) || defined(__clang__) || defined(__CUDACC__) || defined(__HIPCC__))
-  return x == 0 ? 32 : CHOICE(__builtin_clz(x), __clz(x), __builtin_clz(x)); // use builtin if available
+  return x == 0 ? 32 : GPUCA_CHOICE(__builtin_clz(x), __clz(x), __builtin_clz(x)); // use builtin if available
 #else
   for (int32_t i = 31; i >= 0; i--) {
     if (x & (1u << i)) {
@@ -326,7 +329,7 @@ GPUdi() uint32_t GPUCommonMath::Popcount(uint32_t x)
 {
 #if (defined(__GNUC__) || defined(__clang__) || defined(__CUDACC__) || defined(__HIPCC__)) && !defined(__OPENCL__) // TODO: remove OPENCL when reported SPIR-V bug is fixed
   // use builtin if available
-  return CHOICE(__builtin_popcount(x), __popc(x), __builtin_popcount(x));
+  return GPUCA_CHOICE(__builtin_popcount(x), __popc(x), __builtin_popcount(x));
 #else
   x = x - ((x >> 1) & 0x55555555);
   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
@@ -334,45 +337,16 @@ GPUdi() uint32_t GPUCommonMath::Popcount(uint32_t x)
 #endif
 }
 
-GPUhdi() float GPUCommonMath::Hypot(float x, float y)
-{
-  return Sqrt(x * x + y * y);
-}
-
-GPUhdi() float GPUCommonMath::Hypot(float x, float y, float z)
-{
-  return Sqrt(x * x + y * y + z * z);
-}
-
-GPUhdi() float GPUCommonMath::Hypot(float x, float y, float z, float w)
-{
-  return Sqrt(x * x + y * y + z * z + w * w);
-}
-
 template <typename T>
-GPUd() void _swap(T& a, T& b)
+GPUhdi() void GPUCommonMath::Swap(T& a, T& b)
 {
+#ifndef GPUCA_GPUCODE_DEVICE
+  std::swap(a, b);
+#else
   T tmp = a;
   a = b;
   b = tmp;
-}
-
-template <typename T>
-GPUhdi() void GPUCommonMath::Swap(T& a, T& b)
-{
-  CHOICE(std::swap(a, b), _swap<T>(a, b), _swap<T>(a, b));
-}
-
-template <class T>
-GPUhdi() T GPUCommonMath::Min(const T x, const T y)
-{
-  return CHOICE(std::min(x, y), min(x, y), min(x, y));
-}
-
-template <class T>
-GPUhdi() T GPUCommonMath::Max(const T x, const T y)
-{
-  return CHOICE(std::max(x, y), max(x, y), max(x, y));
+#endif
 }
 
 template <class T, class S, class R>
@@ -441,32 +415,19 @@ GPUdi() float GPUCommonMath::InvSqrt(float _x)
 template <>
 GPUhdi() float GPUCommonMath::Abs<float>(float x)
 {
-  return CHOICE(fabsf(x), fabsf(x), fabs(x));
+  return GPUCA_CHOICE(fabsf(x), fabsf(x), fabs(x));
 }
 
-#if !defined(__OPENCL__) || defined(cl_khr_fp64)
 template <>
 GPUhdi() double GPUCommonMath::Abs<double>(double x)
 {
-  return CHOICE(fabs(x), fabs(x), fabs(x));
+  return GPUCA_CHOICE(fabs(x), fabs(x), fabs(x));
 }
-#endif
 
 template <>
 GPUhdi() int32_t GPUCommonMath::Abs<int32_t>(int32_t x)
 {
-  return CHOICE(abs(x), abs(x), abs(x));
-}
-
-GPUhdi() float GPUCommonMath::Copysign(float x, float y)
-{
-#if defined(__OPENCL__)
-  return copysign(x, y);
-#elif defined(GPUCA_GPUCODE) && !defined(__OPENCL__)
-  return copysignf(x, y);
-#else
-  return std::copysignf(x, y);
-#endif // GPUCA_GPUCODE
+  return GPUCA_CHOICE(abs(x), abs(x), abs(x));
 }
 
 template <class S, class T>
@@ -579,7 +540,7 @@ GPUdii() void GPUCommonMath::AtomicMinInternal(GPUglobalref() GPUgeneric() GPUAt
 }
 #endif
 
-#undef CHOICE
+#undef GPUCA_CHOICE
 
 } // namespace gpu
 } // namespace o2
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 966bffa963c7e..4831be9b12bcc 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -199,7 +199,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
 
     CompressedClustersPtrs& GPUrestrict() c = compressor.mPtrs;
 
-    const uint32_t nn = GPUCommonMath::nextMultipleOf<GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached)>(clusters->nClusters[iSector][iRow]);
+    const uint32_t nn = CAMath::nextMultipleOf<GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached)>(clusters->nClusters[iSector][iRow]);
     for (uint32_t i = iThread; i < nn + nThreads; i += nThreads) {
       const int32_t idx = idOffset + i;
       int32_t cidx = 0;
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
index 1bd2eca769913..fa0711887f60f 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
@@ -787,8 +787,8 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::FollowProlongation(PROP* prop, TRDTRK
         if (mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId == trkltIdx) {
           continue;
         }
-        if (GPUCommonMath::Abs(tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetZbin() - tracklets[trkltIdx].GetZbin()) == 1 &&
-            GPUCommonMath::Abs(tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetY() - tracklets[trkltIdx].GetY()) < 1) {
+        if (CAMath::Abs(tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetZbin() - tracklets[trkltIdx].GetZbin()) == 1 &&
+            CAMath::Abs(tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetY() - tracklets[trkltIdx].GetY()) < 1) {
           trkWork->setIsCrossingNeighbor(iLayer);
           trkWork->setHasNeighbor();
           break;
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 188df5467e83d..24668c576d795 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -64,7 +64,7 @@ inline void GPUDisplay::drawPointLinestrip(int32_t iSector, int32_t cid, int32_t
   mVertexBuffer[iSector].emplace_back(mGlobalPos[cid].x, mGlobalPos[cid].y * mYFactor, mCfgH.projectXY ? 0 : mGlobalPos[cid].z);
   float curVal;
   while ((curVal = mGlobalPos[cid].w) < id_limit) {
-    if (GPUCommonMath::AtomicCAS(&mGlobalPos[cid].w, curVal, (float)id)) {
+    if (CAMath::AtomicCAS(&mGlobalPos[cid].w, curVal, (float)id)) {
       break;
     }
     curVal = mGlobalPos[cid].w;

From c68243887320761f3a8ca2526403808a8fb2b7f0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 15:57:21 +0100
Subject: [PATCH 0052/1764] GPU TPC: Get rid of duplicate ReadEvent code path
 for initializing tracking data on CPU

---
 GPU/GPUTracking/Global/GPUChainTracking.h     |  1 -
 .../Global/GPUChainTrackingSectorTracker.cxx  | 26 +++----------------
 2 files changed, 3 insertions(+), 24 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 4a2778851e517..e7d6f420b9c4d 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -220,7 +220,6 @@ class GPUChainTracking : public GPUChain
 
   GPUChainTracking(GPUReconstruction* rec, uint32_t maxTPCHits = GPUCA_MAX_CLUSTERS, uint32_t maxTRDTracklets = GPUCA_MAX_TRD_TRACKLETS);
 
-  int32_t ReadEvent(uint32_t iSector, int32_t threadId);
   void WriteOutput(int32_t iSector, int32_t threadId);
   int32_t ExtrapolationTracking(uint32_t iSector, int32_t threadId, bool synchronizeOutput = true);
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 0eb8af6a6a006..efb3deb257a42 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -158,17 +158,9 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     if (GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Creating Sector Data (Sector %d)", iSector);
     }
-    if (doGPU) {
-      TransferMemoryResourcesToGPU(RecoStep::TPCSectorTracking, &trk, useStream);
-      runKernel<GPUTPCCreateTrackingData>({GetGridBlk(GPUCA_ROW_COUNT, useStream), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}});
-      streamInit[useStream] = true;
-    } else {
-      if (ReadEvent(iSector, 0)) {
-        GPUError("Error reading event");
-        error = 1;
-        return;
-      }
-    }
+    TransferMemoryResourcesToGPU(RecoStep::TPCSectorTracking, &trk, useStream);
+    runKernel<GPUTPCCreateTrackingData>({doGPU ? GetGridBlk(GPUCA_ROW_COUNT, useStream) : GetGridAuto(0), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}}); // TODO: Check why GetGridAuto(0) is much fast on CPU
+    streamInit[useStream] = true;
     if (GetProcessingSettings().deterministicGPUReconstruction) {
       runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::hitData>({GetGridBlk(GPUCA_ROW_COUNT, useStream), {iSector}});
     }
@@ -381,18 +373,6 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   return 0;
 }
 
-int32_t GPUChainTracking::ReadEvent(uint32_t iSector, int32_t threadId)
-{
-  if (GetProcessingSettings().debugLevel >= 5) {
-    GPUInfo("Running ReadEvent for sector %d on thread %d\n", iSector, threadId);
-  }
-  runKernel<GPUTPCCreateTrackingData>({{GetGridAuto(0, GPUReconstruction::krnlDeviceType::CPU)}, {iSector}});
-  if (GetProcessingSettings().debugLevel >= 5) {
-    GPUInfo("Finished ReadEvent for sector %d on thread %d\n", iSector, threadId);
-  }
-  return (0);
-}
-
 void GPUChainTracking::WriteOutput(int32_t iSector, int32_t threadId)
 {
   if (GetProcessingSettings().debugLevel >= 5) {

From 5848069446af06802fc6221868e9d075bba3d257 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 16:24:19 +0100
Subject: [PATCH 0053/1764] GPU TPC: Remove option to write out / start from
 obsolete TPC sector track data format

---
 GPU/GPUTracking/Base/GPUReconstruction.h      |   1 -
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |   1 -
 .../Base/GPUReconstructionDeviceBase.cxx      |   1 -
 GPU/GPUTracking/CMakeLists.txt                |   1 -
 GPU/GPUTracking/DataTypes/GPUDataTypes.h      |   2 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |   9 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |   3 +-
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |   1 -
 .../Global/GPUChainTrackingSectorTracker.cxx  |  36 +----
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |   1 -
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |   1 -
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |   1 -
 .../SectorTracker/GPUTPCSectorOutput.cxx      |  57 --------
 .../SectorTracker/GPUTPCSectorOutput.h        |  79 -----------
 .../SectorTracker/GPUTPCTracker.cxx           | 123 +-----------------
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.h |   9 --
 .../SectorTracker/GPUTPCTrackerDump.cxx       |  17 ---
 .../Standalone/Benchmark/standalone.cxx       |   1 -
 18 files changed, 11 insertions(+), 333 deletions(-)
 delete mode 100644 GPU/GPUTracking/SectorTracker/GPUTPCSectorOutput.cxx
 delete mode 100644 GPU/GPUTracking/SectorTracker/GPUTPCSectorOutput.h

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 529cce2bd087f..a0248180a5e2c 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -31,7 +31,6 @@
 #include "GPUOutputControl.h"
 #include "GPUMemoryResource.h"
 #include "GPUConstantMem.h"
-#include "GPUTPCSectorOutput.h"
 #include "GPULogging.h"
 
 namespace o2::its
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index f5d350b4064d0..f397fc51bd407 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -18,7 +18,6 @@
 #include "GPUChain.h"
 
 #include "GPUTPCClusterData.h"
-#include "GPUTPCSectorOutput.h"
 #include "GPUTPCSectorOutCluster.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUTPCGMMergedTrackHit.h"
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
index 64d9351b447e2..d1091f59b784a 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
@@ -16,7 +16,6 @@
 #include "GPUReconstructionIncludes.h"
 
 #include "GPUTPCTracker.h"
-#include "GPUTPCSectorOutput.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index b65674a68e6aa..c97742ac1d47f 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -37,7 +37,6 @@ set(SRCS
     SectorTracker/GPUTPCNeighboursCleaner.cxx
     SectorTracker/GPUTPCTracker.cxx
     SectorTracker/GPUTPCTrackingData.cxx
-    SectorTracker/GPUTPCSectorOutput.cxx
     SectorTracker/GPUTPCTrackletConstructor.cxx
     SectorTracker/GPUTPCSectorDebugSortKernels.cxx
     SectorTracker/GPUTPCCreateOccupancyMap.cxx
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.h b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
index 51b5c0b101537..f7bfe38be988d 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
@@ -139,7 +139,7 @@ class GPUDataTypes
                              AllRecoSteps = 0x7FFFFFFF,
                              NoRecoStep = 0 };
   enum ENUM_CLASS InOutType { TPCClusters = 1,
-                              TPCSectorTracks = 2,
+                              OBSOLETE = 2,
                               TPCMergedTracks = 4,
                               TPCCompressedClusters = 8,
                               TRDTracklets = 16,
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 0e1cde343135e..c186f916891ba 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -20,7 +20,6 @@
 #include "GPUChainTracking.h"
 #include "GPUChainTrackingDefs.h"
 #include "GPUTPCClusterData.h"
-#include "GPUTPCSectorOutput.h"
 #include "GPUTPCSectorOutCluster.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUTPCGMMergedTrackHit.h"
@@ -185,7 +184,7 @@ bool GPUChainTracking::ValidateSteps()
     GPUError("Invalid input, TPC Clusterizer needs TPC raw input");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && ((GetRecoStepsInputs() & GPUDataTypes::InOutType::TPCSectorTracks) || (GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCSectorTracks) || !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCConversion))) {
+  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCConversion)) {
     GPUError("Invalid input / output / step, merger cannot read/store sectors tracks and needs TPC conversion");
     return false;
   }
@@ -204,7 +203,7 @@ bool GPUChainTracking::ValidateSteps()
     GPUError("Missing input for TPC Cluster conversion / sector tracking / compression / dEdx: TPC Clusters required");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && !((GetRecoStepsInputs() & GPUDataTypes::InOutType::TPCSectorTracks) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking))) {
+  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking)) {
     GPUError("Input for TPC merger missing");
     return false;
   }
@@ -220,10 +219,6 @@ bool GPUChainTracking::ValidateSteps()
     GPUError("TPC Raw / TPC Clusters / TRD Tracklets cannot be output");
     return false;
   }
-  if ((GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCSectorTracks) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking)) {
-    GPUError("No TPC Sector Tracker Output available");
-    return false;
-  }
   if ((GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCMergedTracks) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging)) {
     GPUError("No TPC Merged Track Output available");
     return false;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index e7d6f420b9c4d..194573981838e 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -220,7 +220,6 @@ class GPUChainTracking : public GPUChain
 
   GPUChainTracking(GPUReconstruction* rec, uint32_t maxTPCHits = GPUCA_MAX_CLUSTERS, uint32_t maxTRDTracklets = GPUCA_MAX_TRD_TRACKLETS);
 
-  void WriteOutput(int32_t iSector, int32_t threadId);
   int32_t ExtrapolationTracking(uint32_t iSector, int32_t threadId, bool synchronizeOutput = true);
 
   int32_t PrepareProfile();
@@ -280,7 +279,7 @@ class GPUChainTracking : public GPUChain
   // Synchronization and Locks
   eventStruct* mEvents = nullptr;
   volatile int32_t mSectorSelectorReady = 0;
-  std::array<int8_t, NSECTORS> mWriteOutputDone;
+  std::array<int8_t, NSECTORS> mExtrapolationTrackingDone;
 
   std::vector<outputQueueEntry> mOutputQueue;
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index c4dddd4b8b88f..4f7846b852b98 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -15,7 +15,6 @@
 #include "GPUChainTracking.h"
 #include "GPUReconstructionIO.h"
 #include "GPUTPCClusterData.h"
-#include "GPUTPCSectorOutput.h"
 #include "GPUTPCSectorOutCluster.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUTPCGMMergedTrackHit.h"
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index efb3deb257a42..522ccbad47e59 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -242,9 +242,9 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
 
     std::array<bool, NSECTORS> transferRunning;
     transferRunning.fill(true);
-    if ((GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCSectorTracks) || (doGPU && !(GetRecoStepsGPU() & RecoStep::TPCMerging))) {
+    if (doGPU && !(GetRecoStepsGPU() & RecoStep::TPCMerging)) { // TODO: This seems pretty obsolete code path, can probably be removed.
       if (param().rec.tpc.extrapolationTracking) {
-        mWriteOutputDone.fill(0);
+        mExtrapolationTrackingDone.fill(0);
       }
 
       uint32_t tmpSector = 0;
@@ -288,18 +288,15 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
             uint32_t sectorLeft, sectorRight;
             GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorLeftRight(tmpSector2, sectorLeft, sectorRight);
 
-            if (tmpSector2 <= iSector && sectorLeft <= iSector && sectorRight <= iSector && mWriteOutputDone[tmpSector2] == 0) {
+            if (tmpSector2 <= iSector && sectorLeft <= iSector && sectorRight <= iSector && mExtrapolationTrackingDone[tmpSector2] == 0) {
               ExtrapolationTracking(tmpSector2, 0);
-              WriteOutput(tmpSector2, 0);
-              mWriteOutputDone[tmpSector2] = 1;
+              mExtrapolationTrackingDone[tmpSector2] = 1;
             }
           }
-        } else {
-          WriteOutput(iSector, 0);
         }
       }
     }
-    if (!(GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCSectorTracks) && param().rec.tpc.extrapolationTracking) {
+    if (param().rec.tpc.extrapolationTracking) {
       std::vector<bool> blocking(NSECTORS * mRec->NStreams());
       for (int32_t i = 0; i < NSECTORS; i++) {
         for (int32_t j = 0; j < mRec->NStreams(); j++) {
@@ -308,7 +305,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       }
       for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
         uint32_t tmpSector = GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorOrder(iSector);
-        if (!((GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCSectorTracks) || (doGPU && !(GetRecoStepsGPU() & RecoStep::TPCMerging)))) {
+        if (!(doGPU && !(GetRecoStepsGPU() & RecoStep::TPCMerging))) {
           uint32_t sectorLeft, sectorRight;
           GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorLeftRight(tmpSector, sectorLeft, sectorRight);
           if (doGPU && !blocking[tmpSector * mRec->NStreams() + sectorLeft % mRec->NStreams()]) {
@@ -334,9 +331,6 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       if (param().rec.tpc.extrapolationTracking) {
         ExtrapolationTracking(iSector, 0);
       }
-      if (GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCSectorTracks) {
-        WriteOutput(iSector, 0);
-      }
     });
     mRec->SetNActiveThreadsOuterLoop(1);
   }
@@ -348,12 +342,6 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     }
   }
 
-  if (GetProcessingSettings().debugMask & 1024 && !GetProcessingSettings().deterministicGPUReconstruction) {
-    for (uint32_t i = 0; i < NSECTORS; i++) {
-      processors()->tpcTrackers[i].DumpOutput(*mDebugFile);
-    }
-  }
-
   if (DoProfile()) {
     return (1);
   }
@@ -372,15 +360,3 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   mRec->PopNonPersistentMemory(RecoStep::TPCSectorTracking, qStr2Tag("TPCSLTRK"));
   return 0;
 }
-
-void GPUChainTracking::WriteOutput(int32_t iSector, int32_t threadId)
-{
-  if (GetProcessingSettings().debugLevel >= 5) {
-    GPUInfo("Running WriteOutput for sector %d on thread %d\n", iSector, threadId);
-  }
-  processors()->tpcTrackers[iSector].WriteOutputPrepare();
-  processors()->tpcTrackers[iSector].WriteOutput();
-  if (GetProcessingSettings().debugLevel >= 5) {
-    GPUInfo("Finished WriteOutput for sector %d on thread %d\n", iSector, threadId);
-  }
-}
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index f6a50565bac52..fa85d796baeba 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -42,7 +42,6 @@
 #include "GPUCommonConstants.h"
 
 #include "GPUTPCTrackParam.h"
-#include "GPUTPCSectorOutput.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUParam.h"
 #include "GPUTPCTrackLinearisation.h"
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index ae6a2582d833a..506dd88ab7058 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -42,7 +42,6 @@ struct ClusterNative;
 namespace o2::gpu
 {
 class GPUTPCSectorTrack;
-class GPUTPCSectorOutput;
 class GPUTPCGMTrackParam;
 class GPUTPCTracker;
 class GPUChainTracking;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index d6dfcc8424e65..ae413aaa98648 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -25,7 +25,6 @@
 #include "GPUO2DataTypes.h"
 #include "GPUCommonMath.h"
 #include "GPUTPCTrackParam.h"
-#include "GPUTPCSectorOutput.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUParam.h"
 #include "GPUParam.inc"
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutput.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutput.cxx
deleted file mode 100644
index 864a5c6b7106e..0000000000000
--- a/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutput.cxx
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCSectorOutput.cxx
-/// \author Sergey Gorbunov, Ivan Kisel, David Rohr
-
-#include "GPUOutputControl.h"
-#include "GPUTPCSectorOutput.h"
-#include "GPUCommonMath.h"
-#include <atomic>
-
-using namespace o2::gpu;
-
-uint32_t GPUTPCSectorOutput::EstimateSize(uint32_t nOfTracks, uint32_t nOfTrackClusters)
-{
-  // calculate the amount of memory [bytes] needed for the event
-  return sizeof(GPUTPCSectorOutput) + sizeof(GPUTPCTrack) * nOfTracks + sizeof(GPUTPCSectorOutCluster) * nOfTrackClusters;
-}
-
-#ifndef GPUCA_GPUCODE
-void GPUTPCSectorOutput::Allocate(GPUTPCSectorOutput*& ptrOutput, int32_t nTracks, int32_t nTrackHits, GPUOutputControl* outputControl, void*& internalMemory)
-{
-  // Allocate All memory needed for sector output
-  const size_t memsize = EstimateSize(nTracks, nTrackHits);
-
-  if (outputControl && outputControl->useExternal()) {
-    static std::atomic_flag lock = ATOMIC_FLAG_INIT;
-    while (lock.test_and_set(std::memory_order_acquire)) {
-    }
-    outputControl->checkCurrent();
-    if (outputControl->size - ((char*)outputControl->ptrCurrent - (char*)outputControl->ptrBase) < memsize) {
-      outputControl->size = 1;
-      ptrOutput = nullptr;
-      lock.clear(std::memory_order_release);
-      return;
-    }
-    ptrOutput = reinterpret_cast<GPUTPCSectorOutput*>(outputControl->ptrCurrent);
-    outputControl->ptrCurrent = (char*)outputControl->ptrCurrent + memsize;
-    lock.clear(std::memory_order_release);
-  } else {
-    if (internalMemory) {
-      free(internalMemory);
-    }
-    internalMemory = malloc(memsize);
-    ptrOutput = reinterpret_cast<GPUTPCSectorOutput*>(internalMemory);
-  }
-  ptrOutput->SetMemorySize(memsize);
-}
-#endif
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutput.h b/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutput.h
deleted file mode 100644
index cc02206dc09a7..0000000000000
--- a/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutput.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCSectorOutput.h
-/// \author Sergey Gorbunov, Ivan Kisel, David Rohr
-
-#ifndef GPUTPCSECTOROUTPUT_H
-#define GPUTPCSECTOROUTPUT_H
-
-#include "GPUTPCDef.h"
-#include "GPUTPCTrack.h"
-
-namespace o2::gpu
-{
-struct GPUOutputControl;
-
-/**
- * @class GPUTPCSectorOutput
- *
- * GPUTPCSectorOutput class is used to store the output of GPUTPCTracker{Component}
- * and transport the output to GPUTPCGBMerger{Component}
- *
- * The class contains all the necessary information about TPC tracks, reconstructed in one sector.
- * This includes the reconstructed track parameters and some compressed information
- * about the assigned clusters: clusterId, position and amplitude.
- *
- */
-class GPUTPCSectorOutput
-{
- public:
-  GPUhd() uint32_t NTracks() const
-  {
-    return mNTracks;
-  }
-  GPUhd() uint32_t NLocalTracks() const { return mNLocalTracks; }
-  GPUhd() uint32_t NTrackClusters() const { return mNTrackClusters; }
-  GPUhd() const GPUTPCTrack* GetFirstTrack() const
-  {
-    return (const GPUTPCTrack*)((const char*)this + sizeof(*this));
-  }
-  GPUhd() GPUTPCTrack* FirstTrack()
-  {
-    return (GPUTPCTrack*)((char*)this + sizeof(*this));
-  }
-  GPUhd() size_t Size() const
-  {
-    return (mMemorySize);
-  }
-
-  static uint32_t EstimateSize(uint32_t nOfTracks, uint32_t nOfTrackClusters);
-  static void Allocate(GPUTPCSectorOutput*& ptrOutput, int32_t nTracks, int32_t nTrackHits, GPUOutputControl* outputControl, void*& internalMemory);
-
-  GPUhd() void SetNTracks(uint32_t v) { mNTracks = v; }
-  GPUhd() void SetNLocalTracks(uint32_t v) { mNLocalTracks = v; }
-  GPUhd() void SetNTrackClusters(uint32_t v) { mNTrackClusters = v; }
-
- private:
-  GPUTPCSectorOutput() = delete;                                     // NOLINT: Must be private or ROOT tries to use them!
-  ~GPUTPCSectorOutput() = delete;                                    // NOLINT
-  GPUTPCSectorOutput(const GPUTPCSectorOutput&) = delete;            // NOLINT
-  GPUTPCSectorOutput& operator=(const GPUTPCSectorOutput&) = delete; // NOLINT
-
-  GPUhd() void SetMemorySize(size_t val) { mMemorySize = val; }
-
-  uint32_t mNTracks; // number of reconstructed tracks
-  uint32_t mNLocalTracks;
-  uint32_t mNTrackClusters; // total number of track clusters
-  size_t mMemorySize;       // Amount of memory really used
-};
-} // namespace o2::gpu
-#endif
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index 4e815784f7cad..6c1b4eda0d7f5 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -18,7 +18,6 @@
 #include "GPUCommonMath.h"
 
 #include "GPUTPCClusterData.h"
-#include "GPUTPCSectorOutput.h"
 #include "GPUO2DataTypes.h"
 #include "GPUTPCTrackParam.h"
 #include "GPUParam.inc"
@@ -39,12 +38,7 @@ using namespace o2::tpc;
 
 #if !defined(GPUCA_GPUCODE)
 
-GPUTPCTracker::~GPUTPCTracker()
-{
-  if (mOutputMemory) {
-    free(mOutputMemory);
-  }
-}
+GPUTPCTracker::~GPUTPCTracker() = default;
 
 // ----------------------------------------------------------------------------------
 void GPUTPCTracker::SetSector(int32_t iSector) { mISector = iSector; }
@@ -173,124 +167,9 @@ GPUh() int32_t GPUTPCTracker::CheckEmptySector()
   // Check if the Sector is empty, if so set the output apropriate and tell the reconstuct procesdure to terminate
   if (NHitsTotal() < 1) {
     mCommonMem->nTracks = mCommonMem->nTrackHits = 0;
-    if (mOutput) {
-      WriteOutputPrepare();
-      mOutput->SetNTracks(0);
-      mOutput->SetNTrackClusters(0);
-    }
     return 1;
   }
   return 0;
 }
 
-GPUh() void GPUTPCTracker::WriteOutputPrepare() { GPUTPCSectorOutput::Allocate(mOutput, mCommonMem->nTracks, mCommonMem->nTrackHits, &mRec->OutputControl(), mOutputMemory); }
-
-template <class T>
-static inline bool SortComparison(const T& a, const T& b)
-{
-  return (a.fSortVal < b.fSortVal);
-}
-
-GPUh() void GPUTPCTracker::WriteOutput()
-{
-  mOutput->SetNTracks(0);
-  mOutput->SetNLocalTracks(0);
-  mOutput->SetNTrackClusters(0);
-
-  if (mCommonMem->nTracks == 0) {
-    return;
-  }
-  if (mCommonMem->nTracks > GPUCA_MAX_SECTOR_NTRACK) {
-    GPUError("Maximum number of tracks exceeded, cannot store");
-    return;
-  }
-
-  int32_t nStoredHits = 0;
-  int32_t nStoredTracks = 0;
-  int32_t nStoredLocalTracks = 0;
-
-  GPUTPCTrack* out = mOutput->FirstTrack();
-
-  trackSortData* trackOrder = new trackSortData[mCommonMem->nTracks];
-  for (uint32_t i = 0; i < mCommonMem->nTracks; i++) {
-    trackOrder[i].fTtrack = i;
-    trackOrder[i].fSortVal = mTracks[trackOrder[i].fTtrack].NHits() / 1000.f + mTracks[trackOrder[i].fTtrack].Param().GetZ() * 100.f + mTracks[trackOrder[i].fTtrack].Param().GetY();
-  }
-  std::sort(trackOrder, trackOrder + mCommonMem->nLocalTracks, SortComparison<trackSortData>); // TODO: Check why this sorting affects the merging efficiency!
-  std::sort(trackOrder + mCommonMem->nLocalTracks, trackOrder + mCommonMem->nTracks, SortComparison<trackSortData>);
-
-  for (uint32_t iTrTmp = 0; iTrTmp < mCommonMem->nTracks; iTrTmp++) {
-    const int32_t iTr = trackOrder[iTrTmp].fTtrack;
-    GPUTPCTrack& iTrack = mTracks[iTr];
-
-    *out = iTrack;
-    int32_t nClu = 0;
-    int32_t iID = iTrack.FirstHitID();
-
-    for (int32_t ith = 0; ith < iTrack.NHits(); ith++) {
-      const GPUTPCHitId& ic = mTrackHits[iID + ith];
-      int32_t iRow = ic.RowIndex();
-      int32_t ih = ic.HitIndex();
-
-      const GPUTPCRow& row = mData.Row(iRow);
-      int32_t clusterIndex = mData.ClusterDataIndex(row, ih);
-#ifdef GPUCA_ARRAY_BOUNDS_CHECKS
-      if (ih >= row.NHits() || ih < 0) {
-        GPUError("Array out of bounds access (Sector Row) (Hit %d / %d - NumC %d): Sector %d Row %d Index %d", ith, iTrack.NHits(), NHitsTotal(), mISector, iRow, ih);
-        fflush(stdout);
-        continue;
-      }
-      if (clusterIndex >= NHitsTotal() || clusterIndex < 0) {
-        GPUError("Array out of bounds access (Cluster Data) (Hit %d / %d - NumC %d): Sector %d Row %d Hit %d, Clusterdata Index %d", ith, iTrack.NHits(), NHitsTotal(), mISector, iRow, ih, clusterIndex);
-        fflush(stdout);
-        continue;
-      }
-#endif
-
-      float origX, origY, origZ;
-      uint8_t flags;
-      uint16_t amp;
-      int32_t id;
-      if (Param().par.earlyTpcTransform) {
-        origX = mData.ClusterData()[clusterIndex].x;
-        origY = mData.ClusterData()[clusterIndex].y;
-        origZ = mData.ClusterData()[clusterIndex].z;
-        flags = mData.ClusterData()[clusterIndex].flags;
-        amp = mData.ClusterData()[clusterIndex].amp;
-        id = mData.ClusterData()[clusterIndex].id;
-      } else {
-        const ClusterNativeAccess& cls = *mConstantMem->ioPtrs.clustersNative;
-        id = clusterIndex + cls.clusterOffset[mISector][0];
-        GPUTPCConvertImpl::convert(*mConstantMem, mISector, iRow, cls.clustersLinear[id].getPad(), cls.clustersLinear[id].getTime(), origX, origY, origZ);
-        flags = cls.clustersLinear[id].getFlags();
-        amp = cls.clustersLinear[id].qTot;
-      }
-      GPUTPCSectorOutCluster c;
-      c.Set(id, iRow, flags, amp, origX, origY, origZ);
-#ifdef GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME
-      c.mPad = mData.ClusterData()[clusterIndex].pad;
-      c.mTime = mData.ClusterData()[clusterIndex].time;
-#endif
-      out->SetOutTrackCluster(nClu, c);
-      nClu++;
-    }
-
-    nStoredTracks++;
-    if (iTr < mCommonMem->nLocalTracks) {
-      nStoredLocalTracks++;
-    }
-    nStoredHits += nClu;
-    out->SetNHits(nClu);
-    out = out->NextTrack();
-  }
-  delete[] trackOrder;
-
-  mOutput->SetNTracks(nStoredTracks);
-  mOutput->SetNLocalTracks(nStoredLocalTracks);
-  mOutput->SetNTrackClusters(nStoredHits);
-  if (Param().par.debugLevel >= 3) {
-    GPUInfo("Sector %d, Output: Tracks %d, local tracks %d, hits %d", mISector, nStoredTracks, nStoredLocalTracks, nStoredHits);
-  }
-}
-
 #endif
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
index 4a789b5adf6bf..e8aac872198f5 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
@@ -29,7 +29,6 @@
 
 namespace o2::gpu
 {
-class GPUTPCSectorOutput;
 struct GPUTPCClusterData;
 struct GPUParam;
 class GPUTPCTrack;
@@ -50,8 +49,6 @@ class GPUTPCTracker : public GPUProcessor
   void InitializeRows(const GPUParam* param) { mData.InitializeRows(*param); }
 
   int32_t CheckEmptySector();
-  void WriteOutputPrepare();
-  void WriteOutput();
 
   // Debugging Stuff
   void DumpTrackingData(std::ostream& out);         // Dump Input Sector Data
@@ -60,7 +57,6 @@ class GPUTPCTracker : public GPUProcessor
   void DumpHitWeights(std::ostream& out);           //....
   void DumpTrackHits(std::ostream& out);            // Same for Track Hits
   void DumpTrackletHits(std::ostream& out);         // Same for Track Hits
-  void DumpOutput(std::ostream& out);               // Similar for output
 #endif
 
   struct StructGPUParameters {
@@ -88,7 +84,6 @@ class GPUTPCTracker : public GPUProcessor
     return mData.ClusterData();
   }
   GPUhdi() const GPUTPCRow& Row(const GPUTPCHitId& HitId) const { return mData.Row(HitId.RowIndex()); }
-  GPUhdi() GPUglobalref() GPUTPCSectorOutput* Output() const { return mOutput; }
   GPUhdni() GPUglobalref() commonMemoryStruct* CommonMemory() const
   {
     return (mCommonMem);
@@ -268,10 +263,6 @@ class GPUTPCTracker : public GPUProcessor
   GPUglobalref() GPUTPCTrack* mTracks = nullptr;            // reconstructed tracks
   GPUglobalref() GPUTPCHitId* mTrackHits = nullptr;         // array of track hit numbers
 
-  // output
-  GPUglobalref() GPUTPCSectorOutput* mOutput; // address of pointer pointing to SectorOutput Object
-  void* mOutputMemory;                        // Pointer to output memory if stored internally
-
   static int32_t StarthitSortComparison(const void* a, const void* b);
 };
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
index ba1727fa602a4..7d83ff9abd91c 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
@@ -13,7 +13,6 @@
 /// \author David Rohr
 
 #include "GPUTPCTracker.h"
-#include "GPUTPCSectorOutput.h"
 #include "GPUReconstruction.h"
 #include "GPUTPCHitId.h"
 #include "GPUTPCTrack.h"
@@ -26,22 +25,6 @@
 
 using namespace o2::gpu;
 
-void GPUTPCTracker::DumpOutput(std::ostream& out)
-{
-  if (Param().par.earlyTpcTransform) {
-    out << "\nSector " << mISector << "\n";
-    const GPUTPCTrack* track = (Output())->GetFirstTrack();
-    for (uint32_t j = 0; j < (Output())->NTracks(); j++) {
-      out << "Track " << j << " (" << track->NHits() << "): ";
-      for (int32_t k = 0; k < track->NHits(); k++) {
-        out << "(" << track->OutTrackCluster(k).GetX() << "," << track->OutTrackCluster(k).GetY() << "," << track->OutTrackCluster(k).GetZ() << ") ";
-      }
-      out << " - (" << track->Param().Y() << " " << track->Param().Z() << " " << track->Param().SinPhi() << " " << track->Param().DzDs() << " " << track->Param().QPt() << "\n";
-      track = track->GetNextTrack();
-    }
-  }
-}
-
 void GPUTPCTracker::DumpTrackingData(std::ostream& out)
 {
   // Dump Sector Input Data to File
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 682e6913d58d4..d6279df7c9188 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -416,7 +416,6 @@ int32_t SetupReconstruction()
   }
 
   steps.outputs.clear();
-  steps.outputs.setBits(GPUDataTypes::InOutType::TPCSectorTracks, false);
   steps.outputs.setBits(GPUDataTypes::InOutType::TPCMergedTracks, steps.steps.isSet(GPUDataTypes::RecoStep::TPCMerging));
   steps.outputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, steps.steps.isSet(GPUDataTypes::RecoStep::TPCCompression));
   steps.outputs.setBits(GPUDataTypes::InOutType::TRDTracks, steps.steps.isSet(GPUDataTypes::RecoStep::TRDTracking));

From ee009a4291823f61960932bbfde88597e60a6d6d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 16:42:27 +0100
Subject: [PATCH 0054/1764] GPU Math: Make constexpr what possible

---
 GPU/Common/GPUCommonMath.h | 154 ++++++++++++++++++-------------------
 1 file changed, 77 insertions(+), 77 deletions(-)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index f4b9cd945799a..e977b3679a4ee 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -53,12 +53,12 @@ class GPUCommonMath
   GPUd() static float2 MakeFloat2(float x, float y); // TODO: Find better appraoch that is constexpr
 
   template <class T>
-  GPUhd() static T Min(const T x, const T y)
+  GPUhd() constexpr static T Min(const T x, const T y)
   {
     return GPUCA_CHOICE(std::min(x, y), min(x, y), min(x, y));
   }
   template <class T>
-  GPUhd() static T Max(const T x, const T y)
+  GPUhd() constexpr static T Max(const T x, const T y)
   {
     return GPUCA_CHOICE(std::max(x, y), max(x, y), max(x, y));
   }
@@ -69,51 +69,51 @@ class GPUCommonMath
   template <class T, class S, class R>
   GPUd() static T MaxWithRef(T x, T y, T z, T w, S refX, S refY, S refZ, S refW, R& r);
   template <class T>
-  GPUdi() static T Clamp(const T v, const T lo, const T hi)
+  GPUdi() constexpr static T Clamp(const T v, const T lo, const T hi)
   {
     return Max(lo, Min(v, hi));
   }
-  GPUhdni() static float Sqrt(float x);
+  GPUhdni() constexpr static float Sqrt(float x);
   GPUd() static float InvSqrt(float x);
   template <class T>
-  GPUhd() static T Abs(T x);
-  GPUd() static float ASin(float x);
-  GPUd() static float ACos(float x);
-  GPUd() static float ATan(float x);
-  GPUhd() static float ATan2(float y, float x);
-  GPUd() static float Sin(float x);
-  GPUd() static float Cos(float x);
+  GPUhd() constexpr static T Abs(T x);
+  GPUd() constexpr static float ASin(float x);
+  GPUd() constexpr static float ACos(float x);
+  GPUd() constexpr static float ATan(float x);
+  GPUhd() constexpr static float ATan2(float y, float x);
+  GPUd() constexpr static float Sin(float x);
+  GPUd() constexpr static float Cos(float x);
   GPUhdni() static void SinCos(float x, float& s, float& c);
   GPUhdni() static void SinCosd(double x, double& s, double& c);
-  GPUd() static float Tan(float x);
-  GPUd() static float Pow(float x, float y);
-  GPUd() static float Log(float x);
-  GPUd() static float Exp(float x);
-  GPUhdni() static float Copysign(float x, float y) { return GPUCA_CHOICE(std::copysignf(x, y), copysignf(x, y), copysign(x, y)); }
-  GPUd() static constexpr float TwoPi() { return 6.2831853f; }
-  GPUd() static constexpr float Pi() { return 3.1415927f; }
-  GPUd() static float Round(float x);
-  GPUd() static float Floor(float x) { return GPUCA_CHOICE(floorf(x), floorf(x), floor(x)); }
-  GPUd() static uint32_t Float2UIntReint(const float& x);
-  GPUd() static uint32_t Float2UIntRn(float x) { return (uint32_t)(int32_t)(x + 0.5f); }
-  GPUd() static int32_t Float2IntRn(float x);
-  GPUd() static float Modf(float x, float y);
-  GPUd() static bool Finite(float x) { return GPUCA_CHOICE(std::isfinite(x), isfinite(x), isfinite(x)); }
-  GPUd() static bool IsNaN(float x) { return GPUCA_CHOICE(std::isnan(x), isnan(x), isnan(x)); }
-  GPUd() static bool FiniteRelaxed(float x); // always true if not using NO_FAST_MATH
-  GPUd() static bool IsNaNRelaxed(float x);  // always true if not using NO_FAST_MATH
-  GPUd() static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
-  GPUd() static uint32_t Clz(uint32_t val);
-  GPUd() static uint32_t Popcount(uint32_t val);
+  GPUd() constexpr static float Tan(float x);
+  GPUd() constexpr static float Pow(float x, float y);
+  GPUd() constexpr static float Log(float x);
+  GPUd() constexpr static float Exp(float x);
+  GPUhdni() constexpr static float Copysign(float x, float y) { return GPUCA_CHOICE(std::copysignf(x, y), copysignf(x, y), copysign(x, y)); }
+  GPUd() constexpr static float TwoPi() { return 6.2831853f; }
+  GPUd() constexpr static float Pi() { return 3.1415927f; }
+  GPUd() constexpr static float Round(float x);
+  GPUd() constexpr static float Floor(float x) { return GPUCA_CHOICE(floorf(x), floorf(x), floor(x)); }
+  GPUd() static uint32_t Float2UIntReint(float x);
+  GPUd() constexpr static uint32_t Float2UIntRn(float x) { return (uint32_t)(int32_t)(x + 0.5f); }
+  GPUd() constexpr static int32_t Float2IntRn(float x);
+  GPUd() constexpr static float Modf(float x, float y);
+  GPUd() constexpr static bool Finite(float x) { return GPUCA_CHOICE(std::isfinite(x), isfinite(x), isfinite(x)); }
+  GPUd() constexpr static bool IsNaN(float x) { return GPUCA_CHOICE(std::isnan(x), isnan(x), isnan(x)); }
+  GPUd() constexpr static bool FiniteRelaxed(float x); // always true if not using NO_FAST_MATH
+  GPUd() constexpr static bool IsNaNRelaxed(float x);  // always true if not using NO_FAST_MATH
+  GPUd() constexpr static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
+  GPUd() constexpr static uint32_t Clz(uint32_t val);
+  GPUd() constexpr static uint32_t Popcount(uint32_t val);
 
   GPUd() static void memcpy(void* dst, const void* src, size_t size);
 
-  GPUhdi() static float Hypot(float x, float y) { return Sqrt(x * x + y * y); }
-  GPUhdi() static float Hypot(float x, float y, float z) { return Sqrt(x * x + y * y + z * z); }
-  GPUhdi() static float Hypot(float x, float y, float z, float w) { return Sqrt(x * x + y * y + z * z + w * w); }
+  GPUhdi() constexpr static float Hypot(float x, float y) { return Sqrt(x * x + y * y); }
+  GPUhdi() constexpr static float Hypot(float x, float y, float z) { return Sqrt(x * x + y * y + z * z); }
+  GPUhdi() constexpr static float Hypot(float x, float y, float z, float w) { return Sqrt(x * x + y * y + z * z + w * w); }
 
   template <typename T>
-  GPUhd() static void Swap(T& a, T& b);
+  GPUhd() constexpr static void Swap(T& a, T& b);
 
   template <class T>
   GPUdi() static T AtomicExch(GPUglobalref() GPUgeneric() GPUAtomic(T) * addr, T val)
@@ -162,14 +162,14 @@ class GPUCommonMath
   {
     GPUCommonMath::AtomicMinInternal(addr, val);
   }
-  GPUd() static int32_t Mul24(int32_t a, int32_t b);
-  GPUd() static float FMulRZ(float a, float b);
+  GPUd() constexpr static int32_t Mul24(int32_t a, int32_t b);
+  GPUd() constexpr static float FMulRZ(float a, float b);
 
   template <int32_t I, class T>
   GPUd() constexpr static T nextMultipleOf(T val);
 
   template <typename... Args>
-  GPUhdni() static float Sum2(float w, Args... args);
+  GPUhdni() constexpr static float Sum2(float w, Args... args);
 
  private:
   template <class S, class T>
@@ -187,7 +187,7 @@ class GPUCommonMath
 typedef GPUCommonMath CAMath;
 
 template <typename... Args>
-GPUhdi() float GPUCommonMath::Sum2(float w, Args... args)
+GPUhdi() constexpr float GPUCommonMath::Sum2(float w, Args... args)
 {
   if constexpr (sizeof...(Args) == 0) {
     return w * w;
@@ -239,9 +239,9 @@ GPUdi() float2 GPUCommonMath::MakeFloat2(float x, float y)
 #endif // GPUCA_GPUCODE
 }
 
-GPUdi() float GPUCommonMath::Modf(float x, float y) { return GPUCA_CHOICE(fmodf(x, y), fmodf(x, y), fmod(x, y)); }
+GPUdi() constexpr float GPUCommonMath::Modf(float x, float y) { return GPUCA_CHOICE(fmodf(x, y), fmodf(x, y), fmod(x, y)); }
 
-GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
+GPUdi() uint32_t GPUCommonMath::Float2UIntReint(float x)
 {
 #if defined(GPUCA_GPUCODE_DEVICE) && (defined(__CUDACC__) || defined(__HIPCC__))
   return __float_as_uint(x);
@@ -253,37 +253,37 @@ GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
 }
 
 #ifdef GPUCA_NO_FAST_MATH
-GPUdi() float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), roundf(x), round(x)); }
-GPUdi() int32_t GPUCommonMath::Float2IntRn(float x) { return (int32_t)Round(x); }
-GPUhdi() float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), (float)sqrt((double)x), sqrt(x)); }
-GPUdi() float GPUCommonMath::ATan(float x) { return GPUCA_CHOICE((float)atan((double)x), (float)atan((double)x), atan(x)); }
-GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return GPUCA_CHOICE((float)atan2((double)y, (double)x), (float)atan2((double)y, (double)x), atan2(y, x)); }
-GPUdi() float GPUCommonMath::Sin(float x) { return GPUCA_CHOICE((float)sin((double)x), (float)sin((double)x), sin(x)); }
-GPUdi() float GPUCommonMath::Cos(float x) { return GPUCA_CHOICE((float)cos((double)x), (float)cos((double)x), cos(x)); }
-GPUdi() float GPUCommonMath::Tan(float x) { return GPUCA_CHOICE((float)tanf((double)x), (float)tanf((double)x), tan(x)); }
-GPUdi() float GPUCommonMath::Pow(float x, float y) { return GPUCA_CHOICE((float)pow((double)x, (double)y), pow((double)x, (double)y), pow(x, y)); }
-GPUdi() float GPUCommonMath::ASin(float x) { return GPUCA_CHOICE((float)asin((double)x), (float)asin((double)x), asin(x)); }
-GPUdi() float GPUCommonMath::ACos(float x) { return GPUCA_CHOICE((float)acos((double)x), (float)acos((double)x), acos(x)); }
-GPUdi() float GPUCommonMath::Log(float x) { return GPUCA_CHOICE((float)log((double)x), (float)log((double)x), log(x)); }
-GPUdi() float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE((float)exp((double)x), (float)exp((double)x), exp(x)); }
-GPUdi() bool GPUCommonMath::FiniteRelaxed(float x) { return Finite(x); }
-GPUdi() bool GPUCommonMath::IsNaNRelaxed(float x) { return IsNaN(x); }
+GPUdi() constexpr float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), roundf(x), round(x)); }
+GPUdi() constexpr int32_t GPUCommonMath::Float2IntRn(float x) { return (int32_t)Round(x); }
+GPUhdi() constexpr float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), (float)sqrt((double)x), sqrt(x)); }
+GPUdi() constexpr float GPUCommonMath::ATan(float x) { return GPUCA_CHOICE((float)atan((double)x), (float)atan((double)x), atan(x)); }
+GPUhdi() constexpr float GPUCommonMath::ATan2(float y, float x) { return GPUCA_CHOICE((float)atan2((double)y, (double)x), (float)atan2((double)y, (double)x), atan2(y, x)); }
+GPUdi() constexpr float GPUCommonMath::Sin(float x) { return GPUCA_CHOICE((float)sin((double)x), (float)sin((double)x), sin(x)); }
+GPUdi() constexpr float GPUCommonMath::Cos(float x) { return GPUCA_CHOICE((float)cos((double)x), (float)cos((double)x), cos(x)); }
+GPUdi() constexpr float GPUCommonMath::Tan(float x) { return GPUCA_CHOICE((float)tanf((double)x), (float)tanf((double)x), tan(x)); }
+GPUdi() constexpr float GPUCommonMath::Pow(float x, float y) { return GPUCA_CHOICE((float)pow((double)x, (double)y), pow((double)x, (double)y), pow(x, y)); }
+GPUdi() constexpr float GPUCommonMath::ASin(float x) { return GPUCA_CHOICE((float)asin((double)x), (float)asin((double)x), asin(x)); }
+GPUdi() constexpr float GPUCommonMath::ACos(float x) { return GPUCA_CHOICE((float)acos((double)x), (float)acos((double)x), acos(x)); }
+GPUdi() constexpr float GPUCommonMath::Log(float x) { return GPUCA_CHOICE((float)log((double)x), (float)log((double)x), log(x)); }
+GPUdi() constexpr float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE((float)exp((double)x), (float)exp((double)x), exp(x)); }
+GPUdi() constexpr bool GPUCommonMath::FiniteRelaxed(float x) { return Finite(x); }
+GPUdi() constexpr bool GPUCommonMath::IsNaNRelaxed(float x) { return IsNaN(x); }
 #else
-GPUdi() float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), rintf(x), rint(x)); }
-GPUdi() int32_t GPUCommonMath::Float2IntRn(float x) { return GPUCA_CHOICE((int32_t)Round(x), __float2int_rn(x), (int32_t)Round(x)); }
-GPUhdi() float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), sqrtf(x), sqrt(x)); }
-GPUdi() float GPUCommonMath::ATan(float x) { return GPUCA_CHOICE(atanf(x), atanf(x), atan(x)); }
-GPUhdi() float GPUCommonMath::ATan2(float y, float x) { return GPUCA_CHOICE(atan2f(y, x), atan2f(y, x), atan2(y, x)); }
-GPUdi() float GPUCommonMath::Sin(float x) { return GPUCA_CHOICE(sinf(x), sinf(x), sin(x)); }
-GPUdi() float GPUCommonMath::Cos(float x) { return GPUCA_CHOICE(cosf(x), cosf(x), cos(x)); }
-GPUdi() float GPUCommonMath::Tan(float x) { return GPUCA_CHOICE(tanf(x), tanf(x), tan(x)); }
-GPUdi() float GPUCommonMath::Pow(float x, float y) { return GPUCA_CHOICE(powf(x, y), powf(x, y), pow(x, y)); }
-GPUdi() float GPUCommonMath::ASin(float x) { return GPUCA_CHOICE(asinf(x), asinf(x), asin(x)); }
-GPUdi() float GPUCommonMath::ACos(float x) { return GPUCA_CHOICE(acosf(x), acosf(x), acos(x)); }
-GPUdi() float GPUCommonMath::Log(float x) { return GPUCA_CHOICE(logf(x), logf(x), log(x)); }
-GPUdi() float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE(expf(x), expf(x), exp(x)); }
-GPUdi() bool GPUCommonMath::FiniteRelaxed(float x) { return true; }
-GPUdi() bool GPUCommonMath::IsNaNRelaxed(float x) { return false; }
+GPUdi() constexpr float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), rintf(x), rint(x)); }
+GPUdi() constexpr int32_t GPUCommonMath::Float2IntRn(float x) { return GPUCA_CHOICE((int32_t)Round(x), __float2int_rn(x), (int32_t)Round(x)); }
+GPUhdi() constexpr float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), sqrtf(x), sqrt(x)); }
+GPUdi() constexpr float GPUCommonMath::ATan(float x) { return GPUCA_CHOICE(atanf(x), atanf(x), atan(x)); }
+GPUhdi() constexpr float GPUCommonMath::ATan2(float y, float x) { return GPUCA_CHOICE(atan2f(y, x), atan2f(y, x), atan2(y, x)); }
+GPUdi() constexpr float GPUCommonMath::Sin(float x) { return GPUCA_CHOICE(sinf(x), sinf(x), sin(x)); }
+GPUdi() constexpr float GPUCommonMath::Cos(float x) { return GPUCA_CHOICE(cosf(x), cosf(x), cos(x)); }
+GPUdi() constexpr float GPUCommonMath::Tan(float x) { return GPUCA_CHOICE(tanf(x), tanf(x), tan(x)); }
+GPUdi() constexpr float GPUCommonMath::Pow(float x, float y) { return GPUCA_CHOICE(powf(x, y), powf(x, y), pow(x, y)); }
+GPUdi() constexpr float GPUCommonMath::ASin(float x) { return GPUCA_CHOICE(asinf(x), asinf(x), asin(x)); }
+GPUdi() constexpr float GPUCommonMath::ACos(float x) { return GPUCA_CHOICE(acosf(x), acosf(x), acos(x)); }
+GPUdi() constexpr float GPUCommonMath::Log(float x) { return GPUCA_CHOICE(logf(x), logf(x), log(x)); }
+GPUdi() constexpr float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE(expf(x), expf(x), exp(x)); }
+GPUdi() constexpr bool GPUCommonMath::FiniteRelaxed(float x) { return true; }
+GPUdi() constexpr bool GPUCommonMath::IsNaNRelaxed(float x) { return false; }
 #endif
 
 GPUhdi() void GPUCommonMath::SinCos(float x, float& s, float& c)
@@ -311,7 +311,7 @@ GPUhdi() void GPUCommonMath::SinCosd(double x, double& s, double& c)
 #endif
 }
 
-GPUdi() uint32_t GPUCommonMath::Clz(uint32_t x)
+GPUdi() constexpr uint32_t GPUCommonMath::Clz(uint32_t x)
 {
 #if (defined(__GNUC__) || defined(__clang__) || defined(__CUDACC__) || defined(__HIPCC__))
   return x == 0 ? 32 : GPUCA_CHOICE(__builtin_clz(x), __clz(x), __builtin_clz(x)); // use builtin if available
@@ -325,7 +325,7 @@ GPUdi() uint32_t GPUCommonMath::Clz(uint32_t x)
 #endif
 }
 
-GPUdi() uint32_t GPUCommonMath::Popcount(uint32_t x)
+GPUdi() constexpr uint32_t GPUCommonMath::Popcount(uint32_t x)
 {
 #if (defined(__GNUC__) || defined(__clang__) || defined(__CUDACC__) || defined(__HIPCC__)) && !defined(__OPENCL__) // TODO: remove OPENCL when reported SPIR-V bug is fixed
   // use builtin if available
@@ -338,7 +338,7 @@ GPUdi() uint32_t GPUCommonMath::Popcount(uint32_t x)
 }
 
 template <typename T>
-GPUhdi() void GPUCommonMath::Swap(T& a, T& b)
+GPUhdi() constexpr void GPUCommonMath::Swap(T& a, T& b)
 {
 #ifndef GPUCA_GPUCODE_DEVICE
   std::swap(a, b);
@@ -413,19 +413,19 @@ GPUdi() float GPUCommonMath::InvSqrt(float _x)
 }
 
 template <>
-GPUhdi() float GPUCommonMath::Abs<float>(float x)
+GPUhdi() constexpr float GPUCommonMath::Abs<float>(float x)
 {
   return GPUCA_CHOICE(fabsf(x), fabsf(x), fabs(x));
 }
 
 template <>
-GPUhdi() double GPUCommonMath::Abs<double>(double x)
+GPUhdi() constexpr double GPUCommonMath::Abs<double>(double x)
 {
   return GPUCA_CHOICE(fabs(x), fabs(x), fabs(x));
 }
 
 template <>
-GPUhdi() int32_t GPUCommonMath::Abs<int32_t>(int32_t x)
+GPUhdi() constexpr int32_t GPUCommonMath::Abs<int32_t>(int32_t x)
 {
   return GPUCA_CHOICE(abs(x), abs(x), abs(x));
 }

From 938108f38d43deaf499bc2fe96cd765b4288825a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 17:09:16 +0100
Subject: [PATCH 0055/1764] GPU TPC: Make GPUTPCGeometry fully constexpr

---
 GPU/GPUTracking/DataTypes/GPUTPCGeometry.h    | 166 +++++++++---------
 .../TPCClusterFinder/ClusterAccumulator.h     |   2 +-
 .../TPCClusterFinder/GPUTPCClusterFinder.h    |   2 -
 3 files changed, 86 insertions(+), 84 deletions(-)

diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
index 461ac9366ca23..9ad83bff363ac 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
@@ -28,119 +28,123 @@
 
 namespace o2::gpu
 {
-// Copy of TPC constants from AliRoot:TPCGeometry / O2:TPC/Base/Mapper
-// Should be unified, but cannot take the contants from the official headers for now, since we want it to be constexpr
-class GPUTPCGeometry // TODO: Make values constexpr
+// Copy of TPC constants from AliRoot:TPCGeometry / O2:TPC/Base/Mapper, cannot take the contants from the official headers for now, since we want it to be const / constexpr
+
+namespace gputpcgeometry_internal
 {
 #ifdef GPUCA_TPC_GEOMETRY_O2
-  const float mX[GPUCA_ROW_COUNT] = {85.225f, 85.975f, 86.725f, 87.475f, 88.225f, 88.975f, 89.725f, 90.475f, 91.225f, 91.975f, 92.725f, 93.475f, 94.225f, 94.975f, 95.725f, 96.475f, 97.225f, 97.975f, 98.725f, 99.475f, 100.225f, 100.975f,
-                                     101.725f, 102.475f, 103.225f, 103.975f, 104.725f, 105.475f, 106.225f, 106.975f, 107.725f, 108.475f, 109.225f, 109.975f, 110.725f, 111.475f, 112.225f, 112.975f, 113.725f, 114.475f, 115.225f, 115.975f, 116.725f, 117.475f,
-                                     118.225f, 118.975f, 119.725f, 120.475f, 121.225f, 121.975f, 122.725f, 123.475f, 124.225f, 124.975f, 125.725f, 126.475f, 127.225f, 127.975f, 128.725f, 129.475f, 130.225f, 130.975f, 131.725f, 135.2f, 136.2f, 137.2f,
-                                     138.2f, 139.2f, 140.2f, 141.2f, 142.2f, 143.2f, 144.2f, 145.2f, 146.2f, 147.2f, 148.2f, 149.2f, 150.2f, 151.2f, 152.2f, 153.2f, 154.2f, 155.2f, 156.2f, 157.2f, 158.2f, 159.2f,
-                                     160.2f, 161.2f, 162.2f, 163.2f, 164.2f, 165.2f, 166.2f, 167.2f, 168.2f, 171.4f, 172.6f, 173.8f, 175.f, 176.2f, 177.4f, 178.6f, 179.8f, 181.f, 182.2f, 183.4f, 184.6f, 185.8f,
-                                     187.f, 188.2f, 189.4f, 190.6f, 191.8f, 193.f, 194.2f, 195.4f, 196.6f, 197.8f, 199.f, 200.2f, 201.4f, 202.6f, 203.8f, 205.f, 206.2f, 209.65f, 211.15f, 212.65f, 214.15f, 215.65f,
-                                     217.15f, 218.65f, 220.15f, 221.65f, 223.15f, 224.65f, 226.15f, 227.65f, 229.15f, 230.65f, 232.15f, 233.65f, 235.15f, 236.65f, 238.15f, 239.65f, 241.15f, 242.65f, 244.15f, 245.65f};
-
-  const uint8_t mNPads[GPUCA_ROW_COUNT] = {66, 66, 66, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88,
-                                           90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 92, 92, 92, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82,
-                                           82, 84, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 102, 102, 102, 104, 104, 104, 106, 110,
-                                           110, 112, 112, 112, 114, 114, 114, 116, 116, 116, 118, 118, 118, 118, 118, 120, 120, 122, 122, 124, 124, 124, 126, 126, 128, 128, 128, 130, 130, 132, 132, 132, 134, 134, 136, 136, 138, 138};
-
-  const uint8_t mRegion[GPUCA_ROW_COUNT] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-                                            4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
-  const uint8_t mRegionRows[10] = {17, 15, 16, 15, 18, 16, 16, 14, 13, 12};
-  const uint8_t mRegionStart[10] = {0, 17, 32, 48, 63, 81, 97, 113, 127, 140};
-
-  const uint8_t mSampaMapping[10] = {0, 0, 1, 1, 2, 3, 3, 4, 4, 2};
-  const uint8_t mChannelOffset[10] = {0, 16, 0, 16, 0, 0, 16, 0, 16, 16};
-  const uint8_t mSectorFECOffset[5] = {0, 15, 15 + 18, 15 + 18 + 18, 15 + 18 + 18 + 20};
-
-  const float mPadHeight[10] = {.75f, .75f, .75f, .75f, 1.f, 1.f, 1.2f, 1.2f, 1.5f, 1.5f};
-  const float mPadWidth[10] = {.416f, .420f, .420f, .436f, .6f, .6f, .608f, .588f, .604f, .607f};
-
-  static constexpr float FACTOR_T2Z = 250.f / 512.f; // Used in compression, must remain constant at 250cm, 512 time bins!
-
- public:
-  GPUd() int32_t GetRegion(int32_t row) const { return mRegion[row]; }
-  GPUd() int32_t GetRegionRows(int32_t region) const { return mRegionRows[region]; }
-  GPUd() int32_t GetRegionStart(int32_t region) const { return mRegionStart[region]; }
-  GPUd() int32_t GetSampaMapping(int32_t region) const { return mSampaMapping[region]; }
-  GPUd() int32_t GetChannelOffset(int32_t region) const { return mChannelOffset[region]; }
-  GPUd() int32_t GetSectorFECOffset(int32_t partition) const { return mSectorFECOffset[partition]; }
-  GPUd() int32_t GetROC(int32_t row) const { return row < 97 ? (row < 63 ? 0 : 1) : (row < 127 ? 2 : 3); }
-  GPUd() int32_t EndIROC() const { return 63; }
-  GPUd() int32_t EndOROC1() const { return 97; }
-  GPUd() int32_t EndOROC2() const { return 127; }
+GPUconstexpr() float mX[GPUCA_ROW_COUNT] = {85.225f, 85.975f, 86.725f, 87.475f, 88.225f, 88.975f, 89.725f, 90.475f, 91.225f, 91.975f, 92.725f, 93.475f, 94.225f, 94.975f, 95.725f, 96.475f, 97.225f, 97.975f, 98.725f, 99.475f, 100.225f, 100.975f,
+                                            101.725f, 102.475f, 103.225f, 103.975f, 104.725f, 105.475f, 106.225f, 106.975f, 107.725f, 108.475f, 109.225f, 109.975f, 110.725f, 111.475f, 112.225f, 112.975f, 113.725f, 114.475f, 115.225f, 115.975f, 116.725f, 117.475f,
+                                            118.225f, 118.975f, 119.725f, 120.475f, 121.225f, 121.975f, 122.725f, 123.475f, 124.225f, 124.975f, 125.725f, 126.475f, 127.225f, 127.975f, 128.725f, 129.475f, 130.225f, 130.975f, 131.725f, 135.2f, 136.2f, 137.2f,
+                                            138.2f, 139.2f, 140.2f, 141.2f, 142.2f, 143.2f, 144.2f, 145.2f, 146.2f, 147.2f, 148.2f, 149.2f, 150.2f, 151.2f, 152.2f, 153.2f, 154.2f, 155.2f, 156.2f, 157.2f, 158.2f, 159.2f,
+                                            160.2f, 161.2f, 162.2f, 163.2f, 164.2f, 165.2f, 166.2f, 167.2f, 168.2f, 171.4f, 172.6f, 173.8f, 175.f, 176.2f, 177.4f, 178.6f, 179.8f, 181.f, 182.2f, 183.4f, 184.6f, 185.8f,
+                                            187.f, 188.2f, 189.4f, 190.6f, 191.8f, 193.f, 194.2f, 195.4f, 196.6f, 197.8f, 199.f, 200.2f, 201.4f, 202.6f, 203.8f, 205.f, 206.2f, 209.65f, 211.15f, 212.65f, 214.15f, 215.65f,
+                                            217.15f, 218.65f, 220.15f, 221.65f, 223.15f, 224.65f, 226.15f, 227.65f, 229.15f, 230.65f, 232.15f, 233.65f, 235.15f, 236.65f, 238.15f, 239.65f, 241.15f, 242.65f, 244.15f, 245.65f};
+
+GPUconstexpr() uint8_t mNPads[GPUCA_ROW_COUNT] = {66, 66, 66, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88,
+                                                  90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 92, 92, 92, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82,
+                                                  82, 84, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 102, 102, 102, 104, 104, 104, 106, 110,
+                                                  110, 112, 112, 112, 114, 114, 114, 116, 116, 116, 118, 118, 118, 118, 118, 120, 120, 122, 122, 124, 124, 124, 126, 126, 128, 128, 128, 130, 130, 132, 132, 132, 134, 134, 136, 136, 138, 138};
+
+GPUconstexpr() uint8_t mRegion[GPUCA_ROW_COUNT] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+                                                   4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+GPUconstexpr() uint8_t mRegionRows[10] = {17, 15, 16, 15, 18, 16, 16, 14, 13, 12};
+GPUconstexpr() uint8_t mRegionStart[10] = {0, 17, 32, 48, 63, 81, 97, 113, 127, 140};
+
+GPUconstexpr() uint8_t mSampaMapping[10] = {0, 0, 1, 1, 2, 3, 3, 4, 4, 2};
+GPUconstexpr() uint8_t mChannelOffset[10] = {0, 16, 0, 16, 0, 0, 16, 0, 16, 16};
+GPUconstexpr() uint8_t mSectorFECOffset[5] = {0, 15, 15 + 18, 15 + 18 + 18, 15 + 18 + 18 + 20};
+
+GPUconstexpr() float mPadHeight[10] = {.75f, .75f, .75f, .75f, 1.f, 1.f, 1.2f, 1.2f, 1.5f, 1.5f};
+GPUconstexpr() float mPadWidth[10] = {.416f, .420f, .420f, .436f, .6f, .6f, .608f, .588f, .604f, .607f};
+
+constexpr float FACTOR_T2Z = 250.f / 512.f; // Used in compression, must remain constant at 250cm, 512 time bins!
 #else
-  const float mX[GPUCA_ROW_COUNT] = {85.195f, 85.945f, 86.695f, 87.445f, 88.195f, 88.945f, 89.695f, 90.445f, 91.195f, 91.945f, 92.695f, 93.445f, 94.195f, 94.945f, 95.695f, 96.445f, 97.195f, 97.945f, 98.695f, 99.445f, 100.195f, 100.945f, 101.695f,
-                                     102.445f, 103.195f, 103.945f, 104.695f, 105.445f, 106.195f, 106.945f, 107.695f, 108.445f, 109.195f, 109.945f, 110.695f, 111.445f, 112.195f, 112.945f, 113.695f, 114.445f, 115.195f, 115.945f, 116.695f, 117.445f, 118.195f, 118.945f,
-                                     119.695f, 120.445f, 121.195f, 121.945f, 122.695f, 123.445f, 124.195f, 124.945f, 125.695f, 126.445f, 127.195f, 127.945f, 128.695f, 129.445f, 130.195f, 130.945f, 131.695f, 135.180f, 136.180f, 137.180f, 138.180f, 139.180f, 140.180f,
-                                     141.180f, 142.180f, 143.180f, 144.180f, 145.180f, 146.180f, 147.180f, 148.180f, 149.180f, 150.180f, 151.180f, 152.180f, 153.180f, 154.180f, 155.180f, 156.180f, 157.180f, 158.180f, 159.180f, 160.180f, 161.180f, 162.180f, 163.180f,
-                                     164.180f, 165.180f, 166.180f, 167.180f, 168.180f, 169.180f, 170.180f, 171.180f, 172.180f, 173.180f, 174.180f, 175.180f, 176.180f, 177.180f, 178.180f, 179.180f, 180.180f, 181.180f, 182.180f, 183.180f, 184.180f, 185.180f, 186.180f,
-                                     187.180f, 188.180f, 189.180f, 190.180f, 191.180f, 192.180f, 193.180f, 194.180f, 195.180f, 196.180f, 197.180f, 198.180f, 199.430f, 200.930f, 202.430f, 203.930f, 205.430f, 206.930f, 208.430f, 209.930f, 211.430f, 212.930f, 214.430f,
-                                     215.930f, 217.430f, 218.930f, 220.430f, 221.930f, 223.430f, 224.930f, 226.430f, 227.930f, 229.430f, 230.930f, 232.430f, 233.930f, 235.430f, 236.930f, 238.430f, 239.930f, 241.430f, 242.930f, 244.430f, 245.930f};
-
-  const uint8_t mNPads[GPUCA_ROW_COUNT] = {68, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 92, 92, 92,
-                                           94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 108, 108, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82, 82, 84, 84,
-                                           84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108,
-                                           108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
-
-  const float mPadHeight[3] = {.75f, 1.f, 1.5f};
-  const float mPadWidth[3] = {.4f, .6f, .6f};
+GPUconstexpr() float mX[GPUCA_ROW_COUNT] = {85.195f, 85.945f, 86.695f, 87.445f, 88.195f, 88.945f, 89.695f, 90.445f, 91.195f, 91.945f, 92.695f, 93.445f, 94.195f, 94.945f, 95.695f, 96.445f, 97.195f, 97.945f, 98.695f, 99.445f, 100.195f, 100.945f, 101.695f,
+                                            102.445f, 103.195f, 103.945f, 104.695f, 105.445f, 106.195f, 106.945f, 107.695f, 108.445f, 109.195f, 109.945f, 110.695f, 111.445f, 112.195f, 112.945f, 113.695f, 114.445f, 115.195f, 115.945f, 116.695f, 117.445f, 118.195f, 118.945f,
+                                            119.695f, 120.445f, 121.195f, 121.945f, 122.695f, 123.445f, 124.195f, 124.945f, 125.695f, 126.445f, 127.195f, 127.945f, 128.695f, 129.445f, 130.195f, 130.945f, 131.695f, 135.180f, 136.180f, 137.180f, 138.180f, 139.180f, 140.180f,
+                                            141.180f, 142.180f, 143.180f, 144.180f, 145.180f, 146.180f, 147.180f, 148.180f, 149.180f, 150.180f, 151.180f, 152.180f, 153.180f, 154.180f, 155.180f, 156.180f, 157.180f, 158.180f, 159.180f, 160.180f, 161.180f, 162.180f, 163.180f,
+                                            164.180f, 165.180f, 166.180f, 167.180f, 168.180f, 169.180f, 170.180f, 171.180f, 172.180f, 173.180f, 174.180f, 175.180f, 176.180f, 177.180f, 178.180f, 179.180f, 180.180f, 181.180f, 182.180f, 183.180f, 184.180f, 185.180f, 186.180f,
+                                            187.180f, 188.180f, 189.180f, 190.180f, 191.180f, 192.180f, 193.180f, 194.180f, 195.180f, 196.180f, 197.180f, 198.180f, 199.430f, 200.930f, 202.430f, 203.930f, 205.430f, 206.930f, 208.430f, 209.930f, 211.430f, 212.930f, 214.430f,
+                                            215.930f, 217.430f, 218.930f, 220.430f, 221.930f, 223.430f, 224.930f, 226.430f, 227.930f, 229.430f, 230.930f, 232.430f, 233.930f, 235.430f, 236.930f, 238.430f, 239.930f, 241.430f, 242.930f, 244.430f, 245.930f};
+
+GPUconstexpr() uint8_t mNPads[GPUCA_ROW_COUNT] = {68, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 92, 92, 92,
+                                                  94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 108, 108, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82, 82, 84, 84,
+                                                  84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108,
+                                                  108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
+
+GPUconstexpr() float mPadHeight[3] = {.75f, 1.f, 1.5f};
+GPUconstexpr() float mPadWidth[3] = {.4f, .6f, .6f};
+
+constexpr float FACTOR_T2Z = 250.f / 1024.f; // Used in compression, must remain constant at 250cm, 1024 time bins!
+#endif
+} // namespace gputpcgeometry_internal
 
-  static constexpr float FACTOR_T2Z = 250.f / 1024.f; // Used in compression, must remain constant at 250cm, 1024 time bins!
+class GPUTPCGeometry // TODO: Make values constexpr
+{
+  static constexpr float FACTOR_Z2T = 1.f / gputpcgeometry_internal::FACTOR_T2Z;
 
  public:
-  GPUd() int32_t GetRegion(int32_t row) const { return (row < 63 ? 0 : row < 63 + 64 ? 1 : 2); }
-  GPUd() int32_t GetRegionRows(int32_t region) const { return 0; }  // dummy
-  GPUd() int32_t GetRegionStart(int32_t region) const { return 0; } // dummy
-  GPUd() int32_t GetROC(int32_t row) const { return GetRegion(row); }
-  GPUd() int32_t EndIROC() const { return 63; }
-  GPUd() int32_t EndOROC1() const { return 63 + 64; }
-  GPUd() int32_t EndOROC2() const { return GPUCA_ROW_COUNT; }
+#ifdef GPUCA_TPC_GEOMETRY_O2
+  GPUd() static constexpr int32_t GetRegion(int32_t row) { return gputpcgeometry_internal::mRegion[row]; }
+  GPUd() static constexpr int32_t GetRegionRows(int32_t region) { return gputpcgeometry_internal::mRegionRows[region]; }
+  GPUd() static constexpr int32_t GetRegionStart(int32_t region) { return gputpcgeometry_internal::mRegionStart[region]; }
+  GPUd() static constexpr int32_t GetSampaMapping(int32_t region) { return gputpcgeometry_internal::mSampaMapping[region]; }
+  GPUd() static constexpr int32_t GetChannelOffset(int32_t region) { return gputpcgeometry_internal::mChannelOffset[region]; }
+  GPUd() static constexpr int32_t GetSectorFECOffset(int32_t partition) { return gputpcgeometry_internal::mSectorFECOffset[partition]; }
+  GPUd() static constexpr int32_t GetROC(int32_t row) { return row < 97 ? (row < 63 ? 0 : 1) : (row < 127 ? 2 : 3); }
+  GPUd() static constexpr int32_t EndIROC() { return 63; }
+  GPUd() static constexpr int32_t EndOROC1() { return 97; }
+  GPUd() static constexpr int32_t EndOROC2() { return 127; }
+#else
+  GPUd() static constexpr int32_t GetRegion(int32_t row) { return (row < 63 ? 0 : row < 63 + 64 ? 1 : 2); }
+  GPUd() static constexpr int32_t GetRegionRows(int32_t region) { return 0; }  // dummy
+  GPUd() static constexpr int32_t GetRegionStart(int32_t region) { return 0; } // dummy
+  GPUd() static constexpr int32_t GetROC(int32_t row) { return GetRegion(row); }
+  GPUd() static constexpr int32_t EndIROC() { return 63; }
+  GPUd() static constexpr int32_t EndOROC1() { return 63 + 64; }
+  GPUd() static constexpr int32_t EndOROC2() { return GPUCA_ROW_COUNT; }
 #endif
- private:
-  static constexpr float FACTOR_Z2T = 1.f / FACTOR_T2Z;
 
- public:
   GPUd() static constexpr float TPCLength() { return 250.f - 0.275f; }
-  GPUd() float Row2X(int32_t row) const { return (mX[row]); }
-  GPUd() float PadHeight(int32_t row) const { return (mPadHeight[GetRegion(row)]); }
-  GPUd() float PadHeightByRegion(int32_t region) const { return (mPadHeight[region]); }
-  GPUd() float PadWidth(int32_t row) const { return (mPadWidth[GetRegion(row)]); }
-  GPUd() uint8_t NPads(int32_t row) const { return mNPads[row]; }
+  GPUd() static constexpr float Row2X(int32_t row) { return (gputpcgeometry_internal::mX[row]); }
+  GPUd() static constexpr float PadHeight(int32_t row) { return (gputpcgeometry_internal::mPadHeight[GetRegion(row)]); }
+  GPUd() static constexpr float PadHeightByRegion(int32_t region) { return (gputpcgeometry_internal::mPadHeight[region]); }
+  GPUd() static constexpr float PadWidth(int32_t row) { return (gputpcgeometry_internal::mPadWidth[GetRegion(row)]); }
+  GPUd() static constexpr uint8_t NPads(int32_t row) { return gputpcgeometry_internal::mNPads[row]; }
 
-  GPUd() float LinearPad2Y(int32_t sector, int32_t row, float pad) const
+  GPUd() static constexpr float LinearPad2Y(int32_t sector, int32_t row, float pad)
   {
 #ifdef GPUCA_TPC_GEOMETRY_O2
-    const float u = (pad - 0.5f * (mNPads[row] - 1)) * PadWidth(row);
+    const float u = (pad - 0.5f * (gputpcgeometry_internal::mNPads[row] - 1)) * PadWidth(row);
 #else
-    const float u = (pad - 0.5f * mNPads[row]) * PadWidth(row);
+    const float u = (pad - 0.5f * gputpcgeometry_internal::mNPads[row]) * PadWidth(row);
 #endif
     return (sector >= GPUCA_NSECTORS / 2) ? -u : u;
   }
 
-  GPUd() static float LinearTime2Z(int32_t sector, float time)
+  GPUd() static constexpr float LinearTime2Z(int32_t sector, float time)
   {
-    const float v = 250.f - time * FACTOR_T2Z; // Used in compression, must remain constant at 250cm!
+    const float v = 250.f - time * gputpcgeometry_internal::FACTOR_T2Z; // Used in compression, must remain constant at 250cm!
     return (sector >= GPUCA_NSECTORS / 2) ? -v : v;
   }
 
-  GPUd() float LinearY2Pad(int32_t sector, int32_t row, float y) const
+  GPUd() static constexpr float LinearY2Pad(int32_t sector, int32_t row, float y)
   {
     const float u = (sector >= GPUCA_NSECTORS / 2) ? -y : y;
 #ifdef GPUCA_TPC_GEOMETRY_O2
-    return u / PadWidth(row) + 0.5f * (mNPads[row] - 1);
+    return u / PadWidth(row) + 0.5f * (gputpcgeometry_internal::mNPads[row] - 1);
 #else
-    return u / PadWidth(row) + 0.5f * mNPads[row];
+    return u / PadWidth(row) + 0.5f * gputpcgeometry_internal::mNPads[row];
 #endif
   }
 
-  GPUd() static float LinearZ2Time(int32_t sector, float z)
+  GPUd() static constexpr float LinearZ2Time(int32_t sector, float z)
   {
     const float v = (sector >= GPUCA_NSECTORS / 2) ? -z : z;
     return (250.f - v) * FACTOR_Z2T; // Used in compression, must remain constant at 250cm
   }
 };
+
 } // namespace o2::gpu
 #endif
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
index 73f7cb439775a..b8c2bd81d8b37 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
@@ -31,8 +31,8 @@ namespace gpu
 {
 
 struct ChargePos;
-class GPUTPCGeometry;
 struct GPUParam;
+class GPUTPCGeometry;
 
 class ClusterAccumulator
 {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
index f59102aa6b5c3..3e9ea2c6f608b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
@@ -48,8 +48,6 @@ struct TPCPadGainCalib;
 
 struct ChargePos;
 
-class GPUTPCGeometry;
-
 class GPUTPCClusterFinder : public GPUProcessor
 {
  public:

From 5e8b7b5b23362a0036df67ae6b8e52296de5573c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Mar 2025 23:50:11 +0100
Subject: [PATCH 0056/1764] GPU Math: Revert some changes which are UB

---
 GPU/Common/GPUCommonMath.h                | 18 ++++++++----------
 GPU/GPUTracking/Standalone/CMakeLists.txt |  2 +-
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index e977b3679a4ee..c412662fc0c64 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -94,14 +94,12 @@ class GPUCommonMath
   GPUd() constexpr static float Pi() { return 3.1415927f; }
   GPUd() constexpr static float Round(float x);
   GPUd() constexpr static float Floor(float x) { return GPUCA_CHOICE(floorf(x), floorf(x), floor(x)); }
-  GPUd() static uint32_t Float2UIntReint(float x);
+  GPUd() static uint32_t Float2UIntReint(const float& x);
   GPUd() constexpr static uint32_t Float2UIntRn(float x) { return (uint32_t)(int32_t)(x + 0.5f); }
   GPUd() constexpr static int32_t Float2IntRn(float x);
   GPUd() constexpr static float Modf(float x, float y);
-  GPUd() constexpr static bool Finite(float x) { return GPUCA_CHOICE(std::isfinite(x), isfinite(x), isfinite(x)); }
-  GPUd() constexpr static bool IsNaN(float x) { return GPUCA_CHOICE(std::isnan(x), isnan(x), isnan(x)); }
-  GPUd() constexpr static bool FiniteRelaxed(float x); // always true if not using NO_FAST_MATH
-  GPUd() constexpr static bool IsNaNRelaxed(float x);  // always true if not using NO_FAST_MATH
+  GPUd() constexpr static bool Finite(float x);
+  GPUd() constexpr static bool IsNaN(float x);
   GPUd() constexpr static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
   GPUd() constexpr static uint32_t Clz(uint32_t val);
   GPUd() constexpr static uint32_t Popcount(uint32_t val);
@@ -241,7 +239,7 @@ GPUdi() float2 GPUCommonMath::MakeFloat2(float x, float y)
 
 GPUdi() constexpr float GPUCommonMath::Modf(float x, float y) { return GPUCA_CHOICE(fmodf(x, y), fmodf(x, y), fmod(x, y)); }
 
-GPUdi() uint32_t GPUCommonMath::Float2UIntReint(float x)
+GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
 {
 #if defined(GPUCA_GPUCODE_DEVICE) && (defined(__CUDACC__) || defined(__HIPCC__))
   return __float_as_uint(x);
@@ -266,8 +264,8 @@ GPUdi() constexpr float GPUCommonMath::ASin(float x) { return GPUCA_CHOICE((floa
 GPUdi() constexpr float GPUCommonMath::ACos(float x) { return GPUCA_CHOICE((float)acos((double)x), (float)acos((double)x), acos(x)); }
 GPUdi() constexpr float GPUCommonMath::Log(float x) { return GPUCA_CHOICE((float)log((double)x), (float)log((double)x), log(x)); }
 GPUdi() constexpr float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE((float)exp((double)x), (float)exp((double)x), exp(x)); }
-GPUdi() constexpr bool GPUCommonMath::FiniteRelaxed(float x) { return Finite(x); }
-GPUdi() constexpr bool GPUCommonMath::IsNaNRelaxed(float x) { return IsNaN(x); }
+GPUdi() constexpr bool GPUCommonMath::Finite(float x) { return GPUCA_CHOICE(std::isfinite(x), isfinite(x), isfinite(x)); }
+GPUdi() constexpr bool GPUCommonMath::IsNaN(float x) { return GPUCA_CHOICE(std::isnan(x), isnan(x), isnan(x)); }
 #else
 GPUdi() constexpr float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), rintf(x), rint(x)); }
 GPUdi() constexpr int32_t GPUCommonMath::Float2IntRn(float x) { return GPUCA_CHOICE((int32_t)Round(x), __float2int_rn(x), (int32_t)Round(x)); }
@@ -282,8 +280,8 @@ GPUdi() constexpr float GPUCommonMath::ASin(float x) { return GPUCA_CHOICE(asinf
 GPUdi() constexpr float GPUCommonMath::ACos(float x) { return GPUCA_CHOICE(acosf(x), acosf(x), acos(x)); }
 GPUdi() constexpr float GPUCommonMath::Log(float x) { return GPUCA_CHOICE(logf(x), logf(x), log(x)); }
 GPUdi() constexpr float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE(expf(x), expf(x), exp(x)); }
-GPUdi() constexpr bool GPUCommonMath::FiniteRelaxed(float x) { return true; }
-GPUdi() constexpr bool GPUCommonMath::IsNaNRelaxed(float x) { return false; }
+GPUdi() constexpr bool GPUCommonMath::Finite(float x) { return true; }
+GPUdi() constexpr bool GPUCommonMath::IsNaN(float x) { return false; }
 #endif
 
 GPUhdi() void GPUCommonMath::SinCos(float x, float& s, float& c)
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 1c61316ed454e..b9620b9385c73 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -51,7 +51,7 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 if(GPUCA_BUILD_DEBUG)
   set(CMAKE_CXX_FLAGS "-O0 -ggdb")
   if (GPUCA_BUILD_DEBUG_SANITIZE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-sanitize=vptr")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-sanitize=vptr") #TODO: Check why this does not work with clang
   endif()
   set(CMAKE_BUILD_TYPE DEBUG)
 else()

From c3d005fe4386ec4b9da41bd63c75d1abb3b5353c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 13 Mar 2025 09:35:43 +0100
Subject: [PATCH 0057/1764] GPU TPC CF: Split clusterizer CXX functions out
 into .inc file to be used externally

---
 .../TPCClusterFinder/GPUTPCCFClusterizer.cxx  | 231 +---------------
 .../TPCClusterFinder/GPUTPCCFClusterizer.h    |   8 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.inc  | 247 ++++++++++++++++++
 3 files changed, 253 insertions(+), 233 deletions(-)
 create mode 100644 GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
index 407deb6a588d0..2131347decec6 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
@@ -25,6 +25,8 @@
 using namespace o2::gpu;
 using namespace o2::gpu::tpccf;
 
+#include "GPUTPCCFClusterizer.inc"
+
 template <>
 GPUdii() void GPUTPCCFClusterizer::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int8_t onlyMC)
 {
@@ -35,232 +37,3 @@ GPUdii() void GPUTPCCFClusterizer::Thread<0>(int32_t nBlocks, int32_t nThreads,
 
   GPUTPCCFClusterizer::computeClustersImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, smem, chargeMap, clusterer.mPfilteredPeakPositions, clusterer.Param().rec, CPU_PTR(&labelAcc), clusterer.mPmemory->counters.nClusters, clusterer.mNMaxClusterPerRow, clusterer.mPclusterInRow, clusterOut, clusterer.mPclusterPosInRow);
 }
-
-GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread,
-                                                       processorType& clusterer,
-                                                       const CfFragment& fragment,
-                                                       GPUSharedMemory& smem,
-                                                       const Array2D<PackedCharge>& chargeMap,
-                                                       const ChargePos* filteredPeakPositions,
-                                                       const GPUSettingsRec& calib,
-                                                       MCLabelAccumulator* labelAcc,
-                                                       uint32_t clusternum,
-                                                       uint32_t maxClusterPerRow,
-                                                       uint32_t* clusterInRow,
-                                                       tpc::ClusterNative* clusterByRow,
-                                                       uint32_t* clusterPosInRow)
-{
-  uint32_t idx = get_global_id(0);
-
-  // For certain configurations dummy work items are added, so the total
-  // number of work items is dividable by 64.
-  // These dummy items also compute the last cluster but discard the result.
-  ChargePos pos = filteredPeakPositions[CAMath::Min(idx, clusternum - 1)];
-  Charge charge = chargeMap[pos].unpack();
-
-  ClusterAccumulator pc;
-  CPU_ONLY(labelAcc->collect(pos, charge));
-
-  buildCluster(
-    calib,
-    chargeMap,
-    pos,
-    smem.posBcast,
-    smem.buf,
-    smem.innerAboveThreshold,
-    &pc,
-    labelAcc);
-
-  if (idx >= clusternum) {
-    return;
-  }
-  if (fragment.isOverlap(pos.time())) {
-    if (clusterPosInRow) {
-      clusterPosInRow[idx] = maxClusterPerRow;
-    }
-    return;
-  }
-  tpc::ClusterNative myCluster;
-  bool rejectCluster = !pc.toNative(pos, charge, myCluster, clusterer.Param(), fragment.start, chargeMap);
-
-  if (rejectCluster) {
-    if (clusterPosInRow) {
-      clusterPosInRow[idx] = maxClusterPerRow;
-    }
-    return;
-  }
-
-  uint32_t rowIndex = 0;
-  if (clusterByRow != nullptr) {
-    rowIndex = sortIntoBuckets(
-      clusterer,
-      myCluster,
-      pos.row(),
-      maxClusterPerRow,
-      clusterInRow,
-      clusterByRow);
-    if (clusterPosInRow != nullptr) {
-      clusterPosInRow[idx] = rowIndex;
-    }
-  } else if (clusterPosInRow) {
-    rowIndex = clusterPosInRow[idx];
-  }
-
-  CPU_ONLY(labelAcc->commit(pos.row(), rowIndex, maxClusterPerRow));
-}
-
-GPUdii() void GPUTPCCFClusterizer::updateClusterInner(
-  const GPUSettingsRec& calib,
-  uint16_t lid,
-  uint16_t N,
-  const PackedCharge* buf,
-  const ChargePos& pos,
-  ClusterAccumulator* cluster,
-  MCLabelAccumulator* labelAcc,
-  uint8_t* innerAboveThreshold)
-{
-  uint8_t aboveThreshold = 0;
-
-  GPUCA_UNROLL(U(), U())
-  for (uint16_t i = 0; i < N; i++) {
-    Delta2 d = cfconsts::InnerNeighbors[i];
-
-    PackedCharge p = buf[N * lid + i];
-
-    Charge q = cluster->updateInner(p, d);
-
-    CPU_ONLY(labelAcc->collect(pos.delta(d), q));
-
-    aboveThreshold |= (uint8_t(q > calib.tpc.cfInnerThreshold) << i);
-  }
-
-  innerAboveThreshold[lid] = aboveThreshold;
-
-  GPUbarrier();
-}
-
-GPUdii() void GPUTPCCFClusterizer::updateClusterOuter(
-  uint16_t lid,
-  uint16_t N,
-  uint16_t M,
-  uint16_t offset,
-  const PackedCharge* buf,
-  const ChargePos& pos,
-  ClusterAccumulator* cluster,
-  MCLabelAccumulator* labelAcc)
-{
-  GPUCA_UNROLL(U(), U())
-  for (uint16_t i = offset; i < M + offset; i++) {
-    PackedCharge p = buf[N * lid + i];
-
-    Delta2 d = cfconsts::OuterNeighbors[i];
-
-    Charge q = cluster->updateOuter(p, d);
-    static_cast<void>(q); // Avoid unused varible warning on GPU.
-
-    CPU_ONLY(labelAcc->collect(pos.delta(d), q));
-  }
-}
-
-GPUdii() void GPUTPCCFClusterizer::buildCluster(
-  const GPUSettingsRec& calib,
-  const Array2D<PackedCharge>& chargeMap,
-  ChargePos pos,
-  ChargePos* posBcast,
-  PackedCharge* buf,
-  uint8_t* innerAboveThreshold,
-  ClusterAccumulator* myCluster,
-  MCLabelAccumulator* labelAcc)
-{
-  uint16_t ll = get_local_id(0);
-
-  posBcast[ll] = pos;
-  GPUbarrier();
-
-  CfUtils::blockLoad<PackedCharge>(
-    chargeMap,
-    SCRATCH_PAD_WORK_GROUP_SIZE,
-    SCRATCH_PAD_WORK_GROUP_SIZE,
-    ll,
-    0,
-    8,
-    cfconsts::InnerNeighbors,
-    posBcast,
-    buf);
-  updateClusterInner(
-    calib,
-    ll,
-    8,
-    buf,
-    pos,
-    myCluster,
-    labelAcc,
-    innerAboveThreshold);
-
-  uint16_t wgSizeHalf = (SCRATCH_PAD_WORK_GROUP_SIZE + 1) / 2;
-
-  bool inGroup1 = ll < wgSizeHalf;
-
-  uint16_t llhalf = (inGroup1) ? ll : (ll - wgSizeHalf);
-
-  CfUtils::condBlockLoad(
-    chargeMap,
-    wgSizeHalf,
-    SCRATCH_PAD_WORK_GROUP_SIZE,
-    ll,
-    0,
-    16,
-    cfconsts::OuterNeighbors,
-    posBcast,
-    innerAboveThreshold,
-    buf);
-
-  if (inGroup1) {
-    updateClusterOuter(
-      llhalf,
-      16,
-      16,
-      0,
-      buf,
-      pos,
-      myCluster,
-      labelAcc);
-  }
-
-#if defined(GPUCA_GPUCODE)
-  CfUtils::condBlockLoad(
-    chargeMap,
-    wgSizeHalf,
-    SCRATCH_PAD_WORK_GROUP_SIZE,
-    ll,
-    0,
-    16,
-    cfconsts::OuterNeighbors,
-    posBcast + wgSizeHalf,
-    innerAboveThreshold + wgSizeHalf,
-    buf);
-  if (!inGroup1) {
-    updateClusterOuter(
-      llhalf,
-      16,
-      16,
-      0,
-      buf,
-      pos,
-      myCluster,
-      labelAcc);
-  }
-#endif
-}
-
-GPUd() uint32_t GPUTPCCFClusterizer::sortIntoBuckets(processorType& clusterer, const tpc::ClusterNative& cluster, uint32_t row, uint32_t maxElemsPerBucket, uint32_t* elemsInBucket, tpc::ClusterNative* buckets)
-{
-  uint32_t index = CAMath::AtomicAdd(&elemsInBucket[row], 1u);
-  if (index < maxElemsPerBucket) {
-    buckets[maxElemsPerBucket * row + index] = cluster;
-  } else {
-    clusterer.raiseError(GPUErrors::ERROR_CF_ROW_CLUSTER_OVERFLOW, clusterer.mISector * 1000 + row, index, maxElemsPerBucket);
-    CAMath::AtomicExch(&elemsInBucket[row], maxElemsPerBucket);
-  }
-  return index;
-}
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
index 411c38c39459e..79f3325ed9ad2 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
@@ -59,14 +59,14 @@ class GPUTPCCFClusterizer : public GPUKernelTemplate
 
   static GPUd() void computeClustersImpl(int32_t, int32_t, int32_t, int32_t, processorType&, const CfFragment&, GPUSharedMemory&, const Array2D<PackedCharge>&, const ChargePos*, const GPUSettingsRec&, MCLabelAccumulator*, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*, uint32_t*);
 
+  static GPUd() void buildCluster(const GPUSettingsRec&, const Array2D<PackedCharge>&, ChargePos, ChargePos*, PackedCharge*, uint8_t*, ClusterAccumulator*, MCLabelAccumulator*);
+
+  static GPUd() uint32_t sortIntoBuckets(processorType&, const tpc::ClusterNative&, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*);
+
  private:
   static GPUd() void updateClusterInner(const GPUSettingsRec&, uint16_t, uint16_t, const PackedCharge*, const ChargePos&, ClusterAccumulator*, MCLabelAccumulator*, uint8_t*);
 
   static GPUd() void updateClusterOuter(uint16_t, uint16_t, uint16_t, uint16_t, const PackedCharge*, const ChargePos&, ClusterAccumulator*, MCLabelAccumulator*);
-
-  static GPUd() void buildCluster(const GPUSettingsRec&, const Array2D<PackedCharge>&, ChargePos, ChargePos*, PackedCharge*, uint8_t*, ClusterAccumulator*, MCLabelAccumulator*);
-
-  static GPUd() uint32_t sortIntoBuckets(processorType&, const tpc::ClusterNative&, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
new file mode 100644
index 0000000000000..c6d7a3b68c0a8
--- /dev/null
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
@@ -0,0 +1,247 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUTPCCFClusterizer.cxx
+/// \author Felix Weiglhofer
+
+#ifndef O2_GPU_CLUSTERIZER_INC_H
+#define O2_GPU_CLUSTERIZER_INC_H
+
+GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread,
+                                                       processorType& clusterer,
+                                                       const CfFragment& fragment,
+                                                       GPUSharedMemory& smem,
+                                                       const Array2D<PackedCharge>& chargeMap,
+                                                       const ChargePos* filteredPeakPositions,
+                                                       const GPUSettingsRec& calib,
+                                                       MCLabelAccumulator* labelAcc,
+                                                       uint32_t clusternum,
+                                                       uint32_t maxClusterPerRow,
+                                                       uint32_t* clusterInRow,
+                                                       tpc::ClusterNative* clusterByRow,
+                                                       uint32_t* clusterPosInRow)
+{
+  uint32_t idx = get_global_id(0);
+
+  // For certain configurations dummy work items are added, so the total
+  // number of work items is dividable by 64.
+  // These dummy items also compute the last cluster but discard the result.
+  ChargePos pos = filteredPeakPositions[CAMath::Min(idx, clusternum - 1)];
+  Charge charge = chargeMap[pos].unpack();
+
+  ClusterAccumulator pc;
+  CPU_ONLY(labelAcc->collect(pos, charge));
+
+  buildCluster(
+    calib,
+    chargeMap,
+    pos,
+    smem.posBcast,
+    smem.buf,
+    smem.innerAboveThreshold,
+    &pc,
+    labelAcc);
+
+  if (idx >= clusternum) {
+    return;
+  }
+  if (fragment.isOverlap(pos.time())) {
+    if (clusterPosInRow) {
+      clusterPosInRow[idx] = maxClusterPerRow;
+    }
+    return;
+  }
+  tpc::ClusterNative myCluster;
+  bool rejectCluster = !pc.toNative(pos, charge, myCluster, clusterer.Param(), fragment.start, chargeMap);
+
+  if (rejectCluster) {
+    if (clusterPosInRow) {
+      clusterPosInRow[idx] = maxClusterPerRow;
+    }
+    return;
+  }
+
+  uint32_t rowIndex = 0;
+  if (clusterByRow != nullptr) {
+    rowIndex = sortIntoBuckets(
+      clusterer,
+      myCluster,
+      pos.row(),
+      maxClusterPerRow,
+      clusterInRow,
+      clusterByRow);
+    if (clusterPosInRow != nullptr) {
+      clusterPosInRow[idx] = rowIndex;
+    }
+  } else if (clusterPosInRow) {
+    rowIndex = clusterPosInRow[idx];
+  }
+
+  CPU_ONLY(labelAcc->commit(pos.row(), rowIndex, maxClusterPerRow));
+}
+
+GPUdii() void GPUTPCCFClusterizer::updateClusterInner(
+  const GPUSettingsRec& calib,
+  uint16_t lid,
+  uint16_t N,
+  const PackedCharge* buf,
+  const ChargePos& pos,
+  ClusterAccumulator* cluster,
+  MCLabelAccumulator* labelAcc,
+  uint8_t* innerAboveThreshold)
+{
+  uint8_t aboveThreshold = 0;
+
+  GPUCA_UNROLL(U(), U())
+  for (uint16_t i = 0; i < N; i++) {
+    Delta2 d = cfconsts::InnerNeighbors[i];
+
+    PackedCharge p = buf[N * lid + i];
+
+    Charge q = cluster->updateInner(p, d);
+
+    CPU_ONLY(labelAcc->collect(pos.delta(d), q));
+
+    aboveThreshold |= (uint8_t(q > calib.tpc.cfInnerThreshold) << i);
+  }
+
+  innerAboveThreshold[lid] = aboveThreshold;
+
+  GPUbarrier();
+}
+
+GPUdii() void GPUTPCCFClusterizer::updateClusterOuter(
+  uint16_t lid,
+  uint16_t N,
+  uint16_t M,
+  uint16_t offset,
+  const PackedCharge* buf,
+  const ChargePos& pos,
+  ClusterAccumulator* cluster,
+  MCLabelAccumulator* labelAcc)
+{
+  GPUCA_UNROLL(U(), U())
+  for (uint16_t i = offset; i < M + offset; i++) {
+    PackedCharge p = buf[N * lid + i];
+
+    Delta2 d = cfconsts::OuterNeighbors[i];
+
+    Charge q = cluster->updateOuter(p, d);
+    static_cast<void>(q); // Avoid unused varible warning on GPU.
+
+    CPU_ONLY(labelAcc->collect(pos.delta(d), q));
+  }
+}
+
+GPUdii() void GPUTPCCFClusterizer::buildCluster(
+  const GPUSettingsRec& calib,
+  const Array2D<PackedCharge>& chargeMap,
+  ChargePos pos,
+  ChargePos* posBcast,
+  PackedCharge* buf,
+  uint8_t* innerAboveThreshold,
+  ClusterAccumulator* myCluster,
+  MCLabelAccumulator* labelAcc)
+{
+  uint16_t ll = get_local_id(0);
+
+  posBcast[ll] = pos;
+  GPUbarrier();
+
+  CfUtils::blockLoad<PackedCharge>(
+    chargeMap,
+    SCRATCH_PAD_WORK_GROUP_SIZE,
+    SCRATCH_PAD_WORK_GROUP_SIZE,
+    ll,
+    0,
+    8,
+    cfconsts::InnerNeighbors,
+    posBcast,
+    buf);
+  updateClusterInner(
+    calib,
+    ll,
+    8,
+    buf,
+    pos,
+    myCluster,
+    labelAcc,
+    innerAboveThreshold);
+
+  uint16_t wgSizeHalf = (SCRATCH_PAD_WORK_GROUP_SIZE + 1) / 2;
+
+  bool inGroup1 = ll < wgSizeHalf;
+
+  uint16_t llhalf = (inGroup1) ? ll : (ll - wgSizeHalf);
+
+  CfUtils::condBlockLoad(
+    chargeMap,
+    wgSizeHalf,
+    SCRATCH_PAD_WORK_GROUP_SIZE,
+    ll,
+    0,
+    16,
+    cfconsts::OuterNeighbors,
+    posBcast,
+    innerAboveThreshold,
+    buf);
+
+  if (inGroup1) {
+    updateClusterOuter(
+      llhalf,
+      16,
+      16,
+      0,
+      buf,
+      pos,
+      myCluster,
+      labelAcc);
+  }
+
+#if defined(GPUCA_GPUCODE)
+  CfUtils::condBlockLoad(
+    chargeMap,
+    wgSizeHalf,
+    SCRATCH_PAD_WORK_GROUP_SIZE,
+    ll,
+    0,
+    16,
+    cfconsts::OuterNeighbors,
+    posBcast + wgSizeHalf,
+    innerAboveThreshold + wgSizeHalf,
+    buf);
+  if (!inGroup1) {
+    updateClusterOuter(
+      llhalf,
+      16,
+      16,
+      0,
+      buf,
+      pos,
+      myCluster,
+      labelAcc);
+  }
+#endif
+}
+
+GPUd() uint32_t GPUTPCCFClusterizer::sortIntoBuckets(processorType& clusterer, const tpc::ClusterNative& cluster, uint32_t row, uint32_t maxElemsPerBucket, uint32_t* elemsInBucket, tpc::ClusterNative* buckets)
+{
+  uint32_t index = CAMath::AtomicAdd(&elemsInBucket[row], 1u);
+  if (index < maxElemsPerBucket) {
+    buckets[maxElemsPerBucket * row + index] = cluster;
+  } else {
+    clusterer.raiseError(GPUErrors::ERROR_CF_ROW_CLUSTER_OVERFLOW, clusterer.mISector * 1000 + row, index, maxElemsPerBucket);
+    CAMath::AtomicExch(&elemsInBucket[row], maxElemsPerBucket);
+  }
+  return index;
+}
+
+#endif // O2_GPU_CLUSTERIZER_INC_H

From db7b2f057d285cd65a434885fe9cbdbcadcfe18b Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Thu, 13 Mar 2025 17:54:22 +0100
Subject: [PATCH 0058/1764] GPU ITS: Fix broken initialisation + cleanup
 (#14058)

---
 .../tracking/include/ITStracking/TrackingConfigParam.h |  6 +++---
 .../ITSMFT/ITS/tracking/src/TrackingInterface.cxx      | 10 +++++-----
 Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx      |  1 -
 GPU/Workflow/src/GPUWorkflowITS.cxx                    |  1 -
 4 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 0cf44d08cac19..ec96321765534 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -56,13 +56,13 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
 struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerParamConfig> {
   // Use TGeo for mat. budget
   static const int MaxIter = 4;
-  static const int MinTrackLenght = 4;
-  static const int MaxTrackLenght = 7;
+  static const int MinTrackLength = 4;
+  static const int MaxTrackLength = 7;
   bool useMatCorrTGeo = false;  // use full geometry to corect for material budget accounting in the fits. Default is to use the material budget LUT.
   bool useFastMaterial = false; // use faster material approximation for material budget accounting in the fits.
   int deltaRof = 0;             // configure the width of the window in ROFs to be considered for the tracking.
   int minTrackLgtIter[MaxIter] = {};                                        // minimum track length at each iteration, used only if >0, otherwise use code defaults
-  float minPtIterLgt[MaxIter * (MaxTrackLenght - MinTrackLenght + 1)] = {}; // min.pT for given track length at this iteration, used only if >0, otherwise use code defaults
+  float minPtIterLgt[MaxIter * (MaxTrackLength - MinTrackLength + 1)] = {}; // min.pT for given track length at this iteration, used only if >0, otherwise use code defaults
   float sysErrY2[7] = {0};      // systematic error^2 in Y per layer
   float sysErrZ2[7] = {0};      // systematic error^2 in Z per layer
   float maxChi2ClusterAttachment = -1.f;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index b264ac46bc7b3..2c94c9bdb1f46 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -81,8 +81,8 @@ void ITSTrackingInterface::initialise()
         if (trackConf.minTrackLgtIter[ip] > 0) {
           param.MinTrackLength = trackConf.minTrackLgtIter[ip];
         }
-        for (int ilg = trackConf.MaxTrackLenght; ilg >= trackConf.MinTrackLenght; ilg--) {
-          int lslot0 = (trackConf.MaxTrackLenght - ilg), lslot = lslot0 + ip * (trackConf.MaxTrackLenght - trackConf.MinTrackLenght + 1);
+        for (int ilg = trackConf.MaxTrackLength; ilg >= trackConf.MinTrackLength; ilg--) {
+          int lslot0 = (trackConf.MaxTrackLength - ilg), lslot = lslot0 + ip * (trackConf.MaxTrackLength - trackConf.MinTrackLength + 1);
           if (trackConf.minPtIterLgt[lslot] > 0.) {
             param.MinPt[lslot0] = trackConf.minPtIterLgt[lslot];
           }
@@ -127,8 +127,8 @@ void ITSTrackingInterface::initialise()
   for (size_t ip = 0; ip < trackParams.size(); ip++) {
     auto& param = trackParams[ip];
     param.TrackletMinPt *= bFactor;
-    for (int ilg = trackConf.MaxTrackLenght; ilg >= trackConf.MinTrackLenght; ilg--) {
-      int lslot = trackConf.MaxTrackLenght - ilg;
+    for (int ilg = trackConf.MaxTrackLength; ilg >= trackConf.MinTrackLength; ilg--) {
+      int lslot = trackConf.MaxTrackLength - ilg;
       param.MinPt[lslot] *= bFactor;
     }
   }
@@ -384,7 +384,7 @@ void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContex
     geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G));
     initialise();
     getConfiguration(pc);
-    //
+
     if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
       o2::its::VertexerParamConfig::Instance().printKeyValues();
       o2::its::TrackerParamConfig::Instance().printKeyValues();
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index dd4c40a2141d9..9e4c98ad6e9a1 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -44,7 +44,6 @@ void TrackerDPL::init(InitContext& ic)
   mITSTrackingInterface.setTraitsFromProvider(mChainITS->GetITSVertexerTraits(),
                                               mChainITS->GetITSTrackerTraits(),
                                               mChainITS->GetITSTimeframe());
-  //  mITSTrackingInterface.initialise() will be called from the ITSTrackingInterface::updateTimeDependentParams at 1st initialization since it needs some run conditions
 }
 
 void TrackerDPL::stop()
diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index 552c5fca5b83e..db9303c431ae7 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -40,7 +40,6 @@ void GPURecoWorkflowSpec::initFunctionITS(o2::framework::InitContext& ic)
                                                                           mSpecConfig.itsOverrBeamEst);
   mGPUReco->GetITSTraits(trkTraits, vtxTraits, mITSTimeFrame);
   mITSTrackingInterface->setTraitsFromProvider(vtxTraits, trkTraits, mITSTimeFrame);
-  mITSTrackingInterface->initialise();
 }
 
 void GPURecoWorkflowSpec::finaliseCCDBITS(o2::framework::ConcreteDataMatcher& matcher, void* obj)

From b27c2a3ff29645f75f52eab793a5fb3558f1f7a3 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Thu, 13 Mar 2025 09:48:32 +0100
Subject: [PATCH 0059/1764] Making float16 variables compatible with GPU types

---
 Common/ML/include/ML/3rdparty/GPUORTFloat16.h | 126 ++++++++++--------
 1 file changed, 72 insertions(+), 54 deletions(-)

diff --git a/Common/ML/include/ML/3rdparty/GPUORTFloat16.h b/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
index db65328409d3c..76fd6734cf9db 100644
--- a/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
+++ b/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
@@ -5,10 +5,18 @@
 //    - https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/onnxruntime_float16.h
 //    - https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/onnxruntime_cxx_api.h
 
+#ifndef GPUORTFLOAT16_H
+#define GPUORTFLOAT16_H
+
+#ifndef GPUCA_GPUCODE_DEVICE
 #include <stdint.h>
 #include <cmath>
 #include <cstring>
 #include <limits>
+#endif
+
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
 
 namespace o2
 {
@@ -50,19 +58,19 @@ struct Float16Impl {
   /// </summary>
   /// <param name="v"></param>
   /// <returns></returns>
-  constexpr static uint16_t ToUint16Impl(float v) noexcept;
+  GPUd() constexpr static uint16_t ToUint16Impl(float v) noexcept;
 
   /// <summary>
   /// Converts float16 to float
   /// </summary>
   /// <returns>float representation of float16 value</returns>
-  float ToFloatImpl() const noexcept;
+  GPUd() float ToFloatImpl() const noexcept;
 
   /// <summary>
   /// Creates an instance that represents absolute value.
   /// </summary>
   /// <returns>Absolute value</returns>
-  uint16_t AbsImpl() const noexcept
+  GPUd() uint16_t AbsImpl() const noexcept
   {
     return static_cast<uint16_t>(val & ~kSignMask);
   }
@@ -71,7 +79,7 @@ struct Float16Impl {
   /// Creates a new instance with the sign flipped.
   /// </summary>
   /// <returns>Flipped sign instance</returns>
-  uint16_t NegateImpl() const noexcept
+  GPUd() uint16_t NegateImpl() const noexcept
   {
     return IsNaN() ? val : static_cast<uint16_t>(val ^ kSignMask);
   }
@@ -92,13 +100,13 @@ struct Float16Impl {
 
   uint16_t val{0};
 
-  Float16Impl() = default;
+  GPUdDefault() Float16Impl() = default;
 
   /// <summary>
   /// Checks if the value is negative
   /// </summary>
   /// <returns>true if negative</returns>
-  bool IsNegative() const noexcept
+  GPUd() bool IsNegative() const noexcept
   {
     return static_cast<int16_t>(val) < 0;
   }
@@ -107,7 +115,7 @@ struct Float16Impl {
   /// Tests if the value is NaN
   /// </summary>
   /// <returns>true if NaN</returns>
-  bool IsNaN() const noexcept
+  GPUd() bool IsNaN() const noexcept
   {
     return AbsImpl() > kPositiveInfinityBits;
   }
@@ -116,7 +124,7 @@ struct Float16Impl {
   /// Tests if the value is finite
   /// </summary>
   /// <returns>true if finite</returns>
-  bool IsFinite() const noexcept
+  GPUd() bool IsFinite() const noexcept
   {
     return AbsImpl() < kPositiveInfinityBits;
   }
@@ -125,7 +133,7 @@ struct Float16Impl {
   /// Tests if the value represents positive infinity.
   /// </summary>
   /// <returns>true if positive infinity</returns>
-  bool IsPositiveInfinity() const noexcept
+  GPUd() bool IsPositiveInfinity() const noexcept
   {
     return val == kPositiveInfinityBits;
   }
@@ -134,7 +142,7 @@ struct Float16Impl {
   /// Tests if the value represents negative infinity
   /// </summary>
   /// <returns>true if negative infinity</returns>
-  bool IsNegativeInfinity() const noexcept
+  GPUd() bool IsNegativeInfinity() const noexcept
   {
     return val == kNegativeInfinityBits;
   }
@@ -143,7 +151,7 @@ struct Float16Impl {
   /// Tests if the value is either positive or negative infinity.
   /// </summary>
   /// <returns>True if absolute value is infinity</returns>
-  bool IsInfinity() const noexcept
+  GPUd() bool IsInfinity() const noexcept
   {
     return AbsImpl() == kPositiveInfinityBits;
   }
@@ -152,7 +160,7 @@ struct Float16Impl {
   /// Tests if the value is NaN or zero. Useful for comparisons.
   /// </summary>
   /// <returns>True if NaN or zero.</returns>
-  bool IsNaNOrZero() const noexcept
+  GPUd() bool IsNaNOrZero() const noexcept
   {
     auto abs = AbsImpl();
     return (abs == 0 || abs > kPositiveInfinityBits);
@@ -162,7 +170,7 @@ struct Float16Impl {
   /// Tests if the value is normal (not zero, subnormal, infinite, or NaN).
   /// </summary>
   /// <returns>True if so</returns>
-  bool IsNormal() const noexcept
+  GPUd() bool IsNormal() const noexcept
   {
     auto abs = AbsImpl();
     return (abs < kPositiveInfinityBits)          // is finite
@@ -174,7 +182,7 @@ struct Float16Impl {
   /// Tests if the value is subnormal (denormal).
   /// </summary>
   /// <returns>True if so</returns>
-  bool IsSubnormal() const noexcept
+  GPUd() bool IsSubnormal() const noexcept
   {
     auto abs = AbsImpl();
     return (abs < kPositiveInfinityBits)          // is finite
@@ -186,13 +194,13 @@ struct Float16Impl {
   /// Creates an instance that represents absolute value.
   /// </summary>
   /// <returns>Absolute value</returns>
-  Derived Abs() const noexcept { return Derived::FromBits(AbsImpl()); }
+  GPUd() Derived Abs() const noexcept { return Derived::FromBits(AbsImpl()); }
 
   /// <summary>
   /// Creates a new instance with the sign flipped.
   /// </summary>
   /// <returns>Flipped sign instance</returns>
-  Derived Negate() const noexcept { return Derived::FromBits(NegateImpl()); }
+  GPUd() Derived Negate() const noexcept { return Derived::FromBits(NegateImpl()); }
 
   /// <summary>
   /// IEEE defines that positive and negative zero are equal, this gives us a quick equality check
@@ -202,12 +210,12 @@ struct Float16Impl {
   /// <param name="lhs">first value</param>
   /// <param name="rhs">second value</param>
   /// <returns>True if both arguments represent zero</returns>
-  static bool AreZero(const Float16Impl& lhs, const Float16Impl& rhs) noexcept
+  GPUd() static bool AreZero(const Float16Impl& lhs, const Float16Impl& rhs) noexcept
   {
     return static_cast<uint16_t>((lhs.val | rhs.val) & ~kSignMask) == 0;
   }
 
-  bool operator==(const Float16Impl& rhs) const noexcept
+  GPUd() bool operator==(const Float16Impl& rhs) const noexcept
   {
     if (IsNaN() || rhs.IsNaN()) {
       // IEEE defines that NaN is not equal to anything, including itself.
@@ -216,9 +224,9 @@ struct Float16Impl {
     return val == rhs.val;
   }
 
-  bool operator!=(const Float16Impl& rhs) const noexcept { return !(*this == rhs); }
+  GPUd() bool operator!=(const Float16Impl& rhs) const noexcept { return !(*this == rhs); }
 
-  bool operator<(const Float16Impl& rhs) const noexcept
+  GPUd() bool operator<(const Float16Impl& rhs) const noexcept
   {
     if (IsNaN() || rhs.IsNaN()) {
       // IEEE defines that NaN is unordered with respect to everything, including itself.
@@ -267,7 +275,7 @@ union float32_bits {
 }; // namespace detail
 
 template <class Derived>
-inline constexpr uint16_t Float16Impl<Derived>::ToUint16Impl(float v) noexcept
+GPUdi() constexpr uint16_t Float16Impl<Derived>::ToUint16Impl(float v) noexcept
 {
   detail::float32_bits f{};
   f.f = v;
@@ -316,7 +324,7 @@ inline constexpr uint16_t Float16Impl<Derived>::ToUint16Impl(float v) noexcept
 }
 
 template <class Derived>
-inline float Float16Impl<Derived>::ToFloatImpl() const noexcept
+GPUdi() float Float16Impl<Derived>::ToFloatImpl() const noexcept
 {
   constexpr detail::float32_bits magic = {113 << 23};
   constexpr unsigned int shifted_exp = 0x7c00 << 13; // exponent mask after shift
@@ -356,19 +364,19 @@ struct BFloat16Impl {
   /// </summary>
   /// <param name="v"></param>
   /// <returns></returns>
-  static uint16_t ToUint16Impl(float v) noexcept;
+  GPUd() static uint16_t ToUint16Impl(float v) noexcept;
 
   /// <summary>
   /// Converts bfloat16 to float
   /// </summary>
   /// <returns>float representation of bfloat16 value</returns>
-  float ToFloatImpl() const noexcept;
+  GPUd() float ToFloatImpl() const noexcept;
 
   /// <summary>
   /// Creates an instance that represents absolute value.
   /// </summary>
   /// <returns>Absolute value</returns>
-  uint16_t AbsImpl() const noexcept
+  GPUd() uint16_t AbsImpl() const noexcept
   {
     return static_cast<uint16_t>(val & ~kSignMask);
   }
@@ -377,7 +385,7 @@ struct BFloat16Impl {
   /// Creates a new instance with the sign flipped.
   /// </summary>
   /// <returns>Flipped sign instance</returns>
-  uint16_t NegateImpl() const noexcept
+  GPUd() uint16_t NegateImpl() const noexcept
   {
     return IsNaN() ? val : static_cast<uint16_t>(val ^ kSignMask);
   }
@@ -400,13 +408,13 @@ struct BFloat16Impl {
 
   uint16_t val{0};
 
-  BFloat16Impl() = default;
+  GPUdDefault() BFloat16Impl() = default;
 
   /// <summary>
   /// Checks if the value is negative
   /// </summary>
   /// <returns>true if negative</returns>
-  bool IsNegative() const noexcept
+  GPUd() bool IsNegative() const noexcept
   {
     return static_cast<int16_t>(val) < 0;
   }
@@ -415,7 +423,7 @@ struct BFloat16Impl {
   /// Tests if the value is NaN
   /// </summary>
   /// <returns>true if NaN</returns>
-  bool IsNaN() const noexcept
+  GPUd() bool IsNaN() const noexcept
   {
     return AbsImpl() > kPositiveInfinityBits;
   }
@@ -424,7 +432,7 @@ struct BFloat16Impl {
   /// Tests if the value is finite
   /// </summary>
   /// <returns>true if finite</returns>
-  bool IsFinite() const noexcept
+  GPUd() bool IsFinite() const noexcept
   {
     return AbsImpl() < kPositiveInfinityBits;
   }
@@ -433,7 +441,7 @@ struct BFloat16Impl {
   /// Tests if the value represents positive infinity.
   /// </summary>
   /// <returns>true if positive infinity</returns>
-  bool IsPositiveInfinity() const noexcept
+  GPUd() bool IsPositiveInfinity() const noexcept
   {
     return val == kPositiveInfinityBits;
   }
@@ -442,7 +450,7 @@ struct BFloat16Impl {
   /// Tests if the value represents negative infinity
   /// </summary>
   /// <returns>true if negative infinity</returns>
-  bool IsNegativeInfinity() const noexcept
+  GPUd() bool IsNegativeInfinity() const noexcept
   {
     return val == kNegativeInfinityBits;
   }
@@ -451,7 +459,7 @@ struct BFloat16Impl {
   /// Tests if the value is either positive or negative infinity.
   /// </summary>
   /// <returns>True if absolute value is infinity</returns>
-  bool IsInfinity() const noexcept
+  GPUd() bool IsInfinity() const noexcept
   {
     return AbsImpl() == kPositiveInfinityBits;
   }
@@ -460,7 +468,7 @@ struct BFloat16Impl {
   /// Tests if the value is NaN or zero. Useful for comparisons.
   /// </summary>
   /// <returns>True if NaN or zero.</returns>
-  bool IsNaNOrZero() const noexcept
+  GPUd() bool IsNaNOrZero() const noexcept
   {
     auto abs = AbsImpl();
     return (abs == 0 || abs > kPositiveInfinityBits);
@@ -470,7 +478,7 @@ struct BFloat16Impl {
   /// Tests if the value is normal (not zero, subnormal, infinite, or NaN).
   /// </summary>
   /// <returns>True if so</returns>
-  bool IsNormal() const noexcept
+  GPUd() bool IsNormal() const noexcept
   {
     auto abs = AbsImpl();
     return (abs < kPositiveInfinityBits)          // is finite
@@ -482,7 +490,7 @@ struct BFloat16Impl {
   /// Tests if the value is subnormal (denormal).
   /// </summary>
   /// <returns>True if so</returns>
-  bool IsSubnormal() const noexcept
+  GPUd() bool IsSubnormal() const noexcept
   {
     auto abs = AbsImpl();
     return (abs < kPositiveInfinityBits)          // is finite
@@ -494,13 +502,13 @@ struct BFloat16Impl {
   /// Creates an instance that represents absolute value.
   /// </summary>
   /// <returns>Absolute value</returns>
-  Derived Abs() const noexcept { return Derived::FromBits(AbsImpl()); }
+  GPUd() Derived Abs() const noexcept { return Derived::FromBits(AbsImpl()); }
 
   /// <summary>
   /// Creates a new instance with the sign flipped.
   /// </summary>
   /// <returns>Flipped sign instance</returns>
-  Derived Negate() const noexcept { return Derived::FromBits(NegateImpl()); }
+  GPUd() Derived Negate() const noexcept { return Derived::FromBits(NegateImpl()); }
 
   /// <summary>
   /// IEEE defines that positive and negative zero are equal, this gives us a quick equality check
@@ -510,7 +518,7 @@ struct BFloat16Impl {
   /// <param name="lhs">first value</param>
   /// <param name="rhs">second value</param>
   /// <returns>True if both arguments represent zero</returns>
-  static bool AreZero(const BFloat16Impl& lhs, const BFloat16Impl& rhs) noexcept
+  GPUd() static bool AreZero(const BFloat16Impl& lhs, const BFloat16Impl& rhs) noexcept
   {
     // IEEE defines that positive and negative zero are equal, this gives us a quick equality check
     // for two values by or'ing the private bits together and stripping the sign. They are both zero,
@@ -520,14 +528,17 @@ struct BFloat16Impl {
 };
 
 template <class Derived>
-inline uint16_t BFloat16Impl<Derived>::ToUint16Impl(float v) noexcept
+GPUdi() uint16_t BFloat16Impl<Derived>::ToUint16Impl(float v) noexcept
 {
   uint16_t result;
-  if (std::isnan(v)) {
+  if (o2::gpu::CAMath::IsNaN(v)) {
     result = kPositiveQNaNBits;
   } else {
     auto get_msb_half = [](float fl) {
       uint16_t result;
+#ifdef GPUCA_GPUCODE
+      o2::gpu::CAMath::memcpy(&result, reinterpret_cast<char*>(&fl) + sizeof(uint16_t), sizeof(uint16_t));
+#else
 #ifdef __cpp_if_constexpr
       if constexpr (detail::endian::native == detail::endian::little)
 #else
@@ -538,6 +549,7 @@ inline uint16_t BFloat16Impl<Derived>::ToUint16Impl(float v) noexcept
       } else {
         std::memcpy(&result, &fl, sizeof(uint16_t));
       }
+#endif
       return result;
     };
 
@@ -554,14 +566,18 @@ inline uint16_t BFloat16Impl<Derived>::ToUint16Impl(float v) noexcept
 }
 
 template <class Derived>
-inline float BFloat16Impl<Derived>::ToFloatImpl() const noexcept
+GPUdi() float BFloat16Impl<Derived>::ToFloatImpl() const noexcept
 {
   if (IsNaN()) {
-    return std::numeric_limits<float>::quiet_NaN();
+    return o2::gpu::CAMath::QuietNaN();
   }
   float result;
   char* const first = reinterpret_cast<char*>(&result);
   char* const second = first + sizeof(uint16_t);
+#ifdef GPUCA_GPUCODE
+  first[0] = first[1] = 0;
+  o2::gpu::CAMath::memcpy(second, &val, sizeof(uint16_t));
+#else
 #ifdef __cpp_if_constexpr
   if constexpr (detail::endian::native == detail::endian::little)
 #else
@@ -574,6 +590,7 @@ inline float BFloat16Impl<Derived>::ToFloatImpl() const noexcept
     std::memcpy(first, &val, sizeof(uint16_t));
     std::memset(second, 0, sizeof(uint16_t));
   }
+#endif
   return result;
 }
 
@@ -610,26 +627,26 @@ struct Float16_t : OrtDataType::Float16Impl<Float16_t> {
   /// <summary>
   /// Default constructor
   /// </summary>
-  Float16_t() = default;
+  GPUdDefault() Float16_t() = default;
 
   /// <summary>
   /// Explicit conversion to uint16_t representation of float16.
   /// </summary>
   /// <param name="v">uint16_t bit representation of float16</param>
   /// <returns>new instance of Float16_t</returns>
-  constexpr static Float16_t FromBits(uint16_t v) noexcept { return Float16_t(v); }
+  GPUd() constexpr static Float16_t FromBits(uint16_t v) noexcept { return Float16_t(v); }
 
   /// <summary>
   /// __ctor from float. Float is converted into float16 16-bit representation.
   /// </summary>
   /// <param name="v">float value</param>
-  explicit Float16_t(float v) noexcept { val = Base::ToUint16Impl(v); }
+  GPUd() explicit Float16_t(float v) noexcept { val = Base::ToUint16Impl(v); }
 
   /// <summary>
   /// Converts float16 to float
   /// </summary>
   /// <returns>float representation of float16 value</returns>
-  float ToFloat() const noexcept { return Base::ToFloatImpl(); }
+  GPUd() float ToFloat() const noexcept { return Base::ToFloatImpl(); }
 
   /// <summary>
   /// Checks if the value is negative
@@ -710,7 +727,7 @@ struct Float16_t : OrtDataType::Float16Impl<Float16_t> {
   /// <summary>
   /// User defined conversion operator. Converts Float16_t to float.
   /// </summary>
-  explicit operator float() const noexcept { return ToFloat(); }
+  GPUdi() explicit operator float() const noexcept { return ToFloat(); }
 
   using Base::operator==;
   using Base::operator!=;
@@ -751,26 +768,26 @@ struct BFloat16_t : OrtDataType::BFloat16Impl<BFloat16_t> {
  public:
   using Base = OrtDataType::BFloat16Impl<BFloat16_t>;
 
-  BFloat16_t() = default;
+  GPUdDefault() BFloat16_t() = default;
 
   /// <summary>
   /// Explicit conversion to uint16_t representation of bfloat16.
   /// </summary>
   /// <param name="v">uint16_t bit representation of bfloat16</param>
   /// <returns>new instance of BFloat16_t</returns>
-  static constexpr BFloat16_t FromBits(uint16_t v) noexcept { return BFloat16_t(v); }
+  GPUd() static constexpr BFloat16_t FromBits(uint16_t v) noexcept { return BFloat16_t(v); }
 
   /// <summary>
   /// __ctor from float. Float is converted into bfloat16 16-bit representation.
   /// </summary>
   /// <param name="v">float value</param>
-  explicit BFloat16_t(float v) noexcept { val = Base::ToUint16Impl(v); }
+  GPUd() explicit BFloat16_t(float v) noexcept { val = Base::ToUint16Impl(v); }
 
   /// <summary>
   /// Converts bfloat16 to float
   /// </summary>
   /// <returns>float representation of bfloat16 value</returns>
-  float ToFloat() const noexcept { return Base::ToFloatImpl(); }
+  GPUd() float ToFloat() const noexcept { return Base::ToFloatImpl(); }
 
   /// <summary>
   /// Checks if the value is negative
@@ -851,7 +868,7 @@ struct BFloat16_t : OrtDataType::BFloat16Impl<BFloat16_t> {
   /// <summary>
   /// User defined conversion operator. Converts BFloat16_t to float.
   /// </summary>
-  explicit operator float() const noexcept { return ToFloat(); }
+  GPUdi() explicit operator float() const noexcept { return ToFloat(); }
 
   // We do not have an inherited impl for the below operators
   // as the internal class implements them a little differently
@@ -864,4 +881,5 @@ static_assert(sizeof(BFloat16_t) == sizeof(uint16_t), "Sizes must match");
 
 } // namespace OrtDataType
 
-} // namespace o2
\ No newline at end of file
+} // namespace o2
+#endif
\ No newline at end of file

From 650a6ff5d636a634a13bb7b8e20f0ec30d0f1f13 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 13 Mar 2025 11:41:02 +0100
Subject: [PATCH 0060/1764] GPU TPC: Simplify host code for driving the
 extrapolation tracking

---
 GPU/GPUTracking/Base/GPUReconstruction.h      |   2 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |   2 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |   4 +-
 .../Global/GPUChainTrackingSectorTracker.cxx  | 116 +++++-------------
 4 files changed, 33 insertions(+), 91 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index a0248180a5e2c..93310284d7564 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -200,7 +200,7 @@ class GPUReconstruction
   void SetOutputControl(void* ptr, size_t size);
   void SetInputControl(void* ptr, size_t size);
   GPUOutputControl& OutputControl() { return mOutputControl; }
-  int32_t NStreams() const { return mNStreams; }
+  uint32_t NStreams() const { return mNStreams; }
   const void* DeviceMemoryBase() const { return mDeviceMemoryBase; }
 
   RecoStepField GetRecoSteps() const { return mRecoSteps.steps; }
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index c186f916891ba..6dcb6f1d7e514 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -260,7 +260,7 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("configured max time bin exceeds 256 orbits");
     return false;
   }
-  if ((GetRecoStepsGPU() & RecoStep::TPCClusterFinding) && std::max(GetProcessingSettings().nTPCClustererLanes + 1, GetProcessingSettings().nTPCClustererLanes * 2) + (GetProcessingSettings().doublePipeline ? 1 : 0) > mRec->NStreams()) {
+  if ((GetRecoStepsGPU() & RecoStep::TPCClusterFinding) && std::max(GetProcessingSettings().nTPCClustererLanes + 1, GetProcessingSettings().nTPCClustererLanes * 2) + (GetProcessingSettings().doublePipeline ? 1 : 0) > (int32_t)mRec->NStreams()) {
     GPUError("NStreams (%d) must be > nTPCClustererLanes (%d)", mRec->NStreams(), (int32_t)GetProcessingSettings().nTPCClustererLanes);
     return false;
   }
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 194573981838e..492ee65d1c9c1 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -220,7 +220,7 @@ class GPUChainTracking : public GPUChain
 
   GPUChainTracking(GPUReconstruction* rec, uint32_t maxTPCHits = GPUCA_MAX_CLUSTERS, uint32_t maxTRDTracklets = GPUCA_MAX_TRD_TRACKLETS);
 
-  int32_t ExtrapolationTracking(uint32_t iSector, int32_t threadId, bool synchronizeOutput = true);
+  int32_t ExtrapolationTracking(uint32_t iSector, bool blocking);
 
   int32_t PrepareProfile();
   int32_t DoProfile();
@@ -278,7 +278,6 @@ class GPUChainTracking : public GPUChain
 
   // Synchronization and Locks
   eventStruct* mEvents = nullptr;
-  volatile int32_t mSectorSelectorReady = 0;
   std::array<int8_t, NSECTORS> mExtrapolationTrackingDone;
 
   std::vector<outputQueueEntry> mOutputQueue;
@@ -299,6 +298,7 @@ class GPUChainTracking : public GPUChain
   void RunTPCTrackingMerger_Resolve(int8_t useOrigTrackParam, int8_t mergeAll, GPUReconstruction::krnlDeviceType deviceType);
   void RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* clusters, std::function<o2::tpc::ClusterNative*(size_t)> allocator, bool applyClusterCuts);
   bool NeedTPCClustersOnGPU();
+  uint32_t StreamForSector(uint32_t sector) const;
 
   std::mutex mMutexUpdateCalib;
   std::unique_ptr<GPUChainTrackingFinalContext> mPipelineFinalizationCtx;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 522ccbad47e59..dd71a797f2744 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -24,12 +24,18 @@
 
 using namespace o2::gpu;
 
-int32_t GPUChainTracking::ExtrapolationTracking(uint32_t iSector, int32_t threadId, bool synchronizeOutput)
+uint32_t GPUChainTracking::StreamForSector(uint32_t sector) const
 {
-  runKernel<GPUTPCExtrapolationTracking>({GetGridBlk(256, iSector % mRec->NStreams()), {iSector}});
-  TransferMemoryResourceLinkToHost(RecoStep::TPCSectorTracking, processors()->tpcTrackers[iSector].MemoryResCommon(), iSector % mRec->NStreams());
-  if (synchronizeOutput) {
-    SynchronizeStream(iSector % mRec->NStreams());
+  return sector % mRec->NStreams();
+}
+
+int32_t GPUChainTracking::ExtrapolationTracking(uint32_t iSector, bool blocking)
+{
+  const uint32_t stream = StreamForSector(iSector);
+  runKernel<GPUTPCExtrapolationTracking>({GetGridBlk(256, stream), {iSector}});
+  TransferMemoryResourceLinkToHost(RecoStep::TPCSectorTracking, processors()->tpcTrackers[iSector].MemoryResCommon(), stream);
+  if (blocking) {
+    SynchronizeStream(stream);
   }
   return (0);
 }
@@ -153,7 +159,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   mRec->runParallelOuterLoop(doGPU, NSECTORS, [&](uint32_t iSector) {
     GPUTPCTracker& trk = processors()->tpcTrackers[iSector];
     GPUTPCTracker& trkShadow = doGPU ? processorsShadow()->tpcTrackers[iSector] : trk;
-    int32_t useStream = (iSector % mRec->NStreams());
+    int32_t useStream = StreamForSector(iSector);
 
     if (GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Creating Sector Data (Sector %d)", iSector);
@@ -234,102 +240,38 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   }
 
   if (doGPU || GetProcessingSettings().debugLevel >= 1) {
-    if (doGPU) {
-      ReleaseEvent(mEvents->init);
-    }
-
-    mSectorSelectorReady = 0;
-
-    std::array<bool, NSECTORS> transferRunning;
-    transferRunning.fill(true);
-    if (doGPU && !(GetRecoStepsGPU() & RecoStep::TPCMerging)) { // TODO: This seems pretty obsolete code path, can probably be removed.
-      if (param().rec.tpc.extrapolationTracking) {
-        mExtrapolationTrackingDone.fill(0);
-      }
-
-      uint32_t tmpSector = 0;
-      for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
-        if (GetProcessingSettings().debugLevel >= 3) {
-          GPUInfo("Transfering Tracks from GPU to Host");
-        }
-
-        if (tmpSector == iSector) {
-          SynchronizeEvents(&mEvents->sector[iSector]);
-        }
-        while (tmpSector < NSECTORS && (tmpSector == iSector || IsEventDone(&mEvents->sector[tmpSector]))) {
-          ReleaseEvent(mEvents->sector[tmpSector]);
-          if (*processors()->tpcTrackers[tmpSector].NTracks() > 0) {
-            TransferMemoryResourceLinkToHost(RecoStep::TPCSectorTracking, processors()->tpcTrackers[tmpSector].MemoryResOutput(), streamMap[tmpSector], &mEvents->sector[tmpSector]);
-          } else {
-            transferRunning[tmpSector] = false;
-          }
-          tmpSector++;
-        }
-
-        if (GetProcessingSettings().keepAllMemory) {
-          TransferMemoryResourcesToHost(RecoStep::TPCSectorTracking, &processors()->tpcTrackers[iSector], -1, true);
-        }
-
-        if (transferRunning[iSector]) {
-          SynchronizeEvents(&mEvents->sector[iSector]);
-        }
-        if (GetProcessingSettings().debugLevel >= 3) {
-          GPUInfo("Tracks Transfered: %d / %d", *processors()->tpcTrackers[iSector].NTracks(), *processors()->tpcTrackers[iSector].NTrackHits());
-        }
-
-        if (GetProcessingSettings().debugLevel >= 3) {
-          GPUInfo("Data ready for sector %d", iSector);
-        }
-        mSectorSelectorReady = iSector;
-
-        if (param().rec.tpc.extrapolationTracking) {
-          for (uint32_t tmpSector2a = 0; tmpSector2a <= iSector; tmpSector2a++) {
-            uint32_t tmpSector2 = GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorOrder(tmpSector2a);
-            uint32_t sectorLeft, sectorRight;
-            GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorLeftRight(tmpSector2, sectorLeft, sectorRight);
-
-            if (tmpSector2 <= iSector && sectorLeft <= iSector && sectorRight <= iSector && mExtrapolationTrackingDone[tmpSector2] == 0) {
-              ExtrapolationTracking(tmpSector2, 0);
-              mExtrapolationTrackingDone[tmpSector2] = 1;
-            }
-          }
-        }
-      }
-    }
     if (param().rec.tpc.extrapolationTracking) {
       std::vector<bool> blocking(NSECTORS * mRec->NStreams());
-      for (int32_t i = 0; i < NSECTORS; i++) {
-        for (int32_t j = 0; j < mRec->NStreams(); j++) {
-          blocking[i * mRec->NStreams() + j] = i % mRec->NStreams() == j;
+      for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
+        for (uint32_t iStream = 0; iStream < mRec->NStreams(); iStream++) {
+          blocking[iSector * mRec->NStreams() + iStream] = StreamForSector(iSector) == iStream;
         }
       }
       for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
         uint32_t tmpSector = GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorOrder(iSector);
-        if (!(doGPU && !(GetRecoStepsGPU() & RecoStep::TPCMerging))) {
-          uint32_t sectorLeft, sectorRight;
-          GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorLeftRight(tmpSector, sectorLeft, sectorRight);
-          if (doGPU && !blocking[tmpSector * mRec->NStreams() + sectorLeft % mRec->NStreams()]) {
-            StreamWaitForEvents(tmpSector % mRec->NStreams(), &mEvents->sector[sectorLeft]);
-            blocking[tmpSector * mRec->NStreams() + sectorLeft % mRec->NStreams()] = true;
-          }
-          if (doGPU && !blocking[tmpSector * mRec->NStreams() + sectorRight % mRec->NStreams()]) {
-            StreamWaitForEvents(tmpSector % mRec->NStreams(), &mEvents->sector[sectorRight]);
-            blocking[tmpSector * mRec->NStreams() + sectorRight % mRec->NStreams()] = true;
-          }
+        uint32_t sectorLeft, sectorRight;
+        GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorLeftRight(tmpSector, sectorLeft, sectorRight);
+        if (doGPU && !blocking[tmpSector * mRec->NStreams() + StreamForSector(sectorLeft)]) {
+          StreamWaitForEvents(StreamForSector(tmpSector), &mEvents->sector[sectorLeft]);
+          blocking[tmpSector * mRec->NStreams() + StreamForSector(sectorLeft)] = true;
+        }
+        if (doGPU && !blocking[tmpSector * mRec->NStreams() + StreamForSector(sectorRight)]) {
+          StreamWaitForEvents(StreamForSector(tmpSector), &mEvents->sector[sectorRight]);
+          blocking[tmpSector * mRec->NStreams() + StreamForSector(sectorRight)] = true;
         }
-        ExtrapolationTracking(tmpSector, 0, false);
+        ExtrapolationTracking(tmpSector, false);
       }
     }
-    for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
-      if (doGPU && transferRunning[iSector]) {
+    if (doGPU) {
+      ReleaseEvent(mEvents->init);
+      for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
         ReleaseEvent(mEvents->sector[iSector]);
       }
     }
   } else {
-    mSectorSelectorReady = NSECTORS;
     mRec->runParallelOuterLoop(doGPU, NSECTORS, [&](uint32_t iSector) {
       if (param().rec.tpc.extrapolationTracking) {
-        ExtrapolationTracking(iSector, 0);
+        ExtrapolationTracking(iSector, true);
       }
     });
     mRec->SetNActiveThreadsOuterLoop(1);

From 705ebfb083c41183183c554c0cb17a6a9423e4c5 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 14 Mar 2025 09:05:24 +0100
Subject: [PATCH 0061/1764] GPU TPC CF: Split toNative back to finalize and
 toNative, to be used by NNClusterer

---
 GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx  | 9 +++++++--
 GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h    | 3 ++-
 GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc | 3 ++-
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
index 77dc6e119df7d..b6792ce3a9ef5 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
@@ -58,7 +58,7 @@ GPUd() Charge ClusterAccumulator::updateOuter(PackedCharge charge, Delta2 d)
   return q;
 }
 
-GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, Charge q, tpc::ClusterNative& cn, const GPUParam& param, TPCTime timeOffset, const Array2D<PackedCharge>& chargeMap)
+GPUd() void ClusterAccumulator::finalize(const ChargePos& pos, const Charge q, TPCTime timeOffset)
 {
   mQtot += q;
 
@@ -73,8 +73,13 @@ GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, Charge q, tpc::Cl
   Pad pad = pos.pad();
   mPadMean += pad;
   mTimeMean += timeOffset + pos.time();
+}
+
+GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, const Charge q, tpc::ClusterNative& cn, const GPUParam& param, const Array2D<PackedCharge>& chargeMap)
+{
+  Pad pad = pos.pad();
 
-  bool isEdgeCluster = pos.pad() < 2 || pos.pad() >= param.tpcGeometry.NPads(pos.row()) - 2; // Geometrical edge check, peak within 2 pads of sector edge
+  bool isEdgeCluster = pad < 2 || pad >= param.tpcGeometry.NPads(pos.row()) - 2; // Geometrical edge check, peak within 2 pads of sector edge
   if (isEdgeCluster) {
     bool leftEdge = (pad < 2);
     if (leftEdge ? (pad == 1 && chargeMap[pos.delta({-1, 0})].unpack() < 1) : (pad == (param.tpcGeometry.NPads(pos.row()) - 2) && chargeMap[pos.delta({1, 0})].unpack() < 1)) {
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
index b8c2bd81d8b37..f0c6ac47f3c8a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
@@ -41,7 +41,8 @@ class ClusterAccumulator
   GPUd() tpccf::Charge updateInner(PackedCharge, tpccf::Delta2);
   GPUd() tpccf::Charge updateOuter(PackedCharge, tpccf::Delta2);
 
-  GPUd() bool toNative(const ChargePos&, tpccf::Charge, tpc::ClusterNative&, const GPUParam&, tpccf::TPCTime, const Array2D<PackedCharge>&);
+  GPUd() void finalize(const ChargePos&, const tpccf::Charge, tpccf::TPCTime);
+  GPUd() bool toNative(const ChargePos&, const tpccf::Charge, tpc::ClusterNative&, const GPUParam&, const Array2D<PackedCharge>&);
 
  private:
   float mQtot = 0;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
index c6d7a3b68c0a8..8a6b73be8bd8d 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
@@ -60,7 +60,8 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
     return;
   }
   tpc::ClusterNative myCluster;
-  bool rejectCluster = !pc.toNative(pos, charge, myCluster, clusterer.Param(), fragment.start, chargeMap);
+  pc.finalize(pos, charge, fragment.start);
+  bool rejectCluster = !pc.toNative(pos, charge, myCluster, clusterer.Param(), chargeMap);
 
   if (rejectCluster) {
     if (clusterPosInRow) {

From b183c5586b9b9cf2aa9a5b1c91a06589e5577690 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 13 Mar 2025 14:52:24 +0100
Subject: [PATCH 0062/1764] GPU CMake: Auto-detect ROCm even if CMake prefix
 path not set

---
 dependencies/FindO2GPU.cmake | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 57c820fbe86b1..f8d41c032078f 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -198,7 +198,10 @@ endif()
 
 # Detect and enable HIP
 if(ENABLE_HIP)
-  if("$ENV{CMAKE_PREFIX_PATH}" MATCHES "rocm")
+  if(NOT "$ENV{CMAKE_PREFIX_PATH}" MATCHES "rocm" AND NOT CMAKE_PREFIX_PATH MATCHES "rocm" AND EXISTS "/opt/rocm/lib/cmake/")
+    list(APPEND CMAKE_PREFIX_PATH "/opt/rocm/lib/cmake")
+  endif()
+  if("$ENV{CMAKE_PREFIX_PATH}" MATCHES "rocm" OR CMAKE_PREFIX_PATH MATCHES "rocm")
     set(CMAKE_HIP_STANDARD ${CMAKE_CXX_STANDARD})
     set(CMAKE_HIP_STANDARD_REQUIRED TRUE)
     if(HIP_AMDGPUTARGET)
@@ -206,7 +209,7 @@ if(ENABLE_HIP)
       set(GPU_TARGETS "${HIP_AMDGPUTARGET}" CACHE STRING "AMD GPU targets to compile for" FORCE)
       set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}" CACHE STRING "AMD GPU targets to compile for" FORCE)
     endif()
-    set(TMP_ROCM_DIR_LIST $ENV{CMAKE_PREFIX_PATH})
+    set(TMP_ROCM_DIR_LIST "${CMAKE_PREFIX_PATH}:$ENV{CMAKE_PREFIX_PATH}")
     string(REPLACE ":" ";" TMP_ROCM_DIR_LIST "${TMP_ROCM_DIR_LIST}")
     list(FILTER TMP_ROCM_DIR_LIST INCLUDE REGEX rocm)
     list(POP_FRONT TMP_ROCM_DIR_LIST TMP_ROCM_DIR)

From 2626074691611ab3b40693eea263fc27808fa556 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 13 Mar 2025 15:00:35 +0100
Subject: [PATCH 0063/1764] GPU Standalone: fix prepare script using O2 env
 modules

---
 GPU/GPUTracking/Standalone/cmake/prepare.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/cmake/prepare.sh b/GPU/GPUTracking/Standalone/cmake/prepare.sh
index 826cdb5efb56c..17474b5fc6956 100755
--- a/GPU/GPUTracking/Standalone/cmake/prepare.sh
+++ b/GPU/GPUTracking/Standalone/cmake/prepare.sh
@@ -10,7 +10,7 @@ else
   WORK_DIR="$ALIBUILD_WORK_DIR"
 fi
 eval "`alienv shell-helper`"
-alienv load O2/latest
-for i in Vc boost fmt CMake ms_gsl Clang ninja; do
+# alienv load O2/latest
+for i in Vc boost fmt CMake ms_gsl Clang ninja TBB ROOT; do
   source sw/$ALIARCH/$i/latest/etc/profile.d/init.sh
 done

From b5ab60d021e934b92f335b6267f0891f098e4a65 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Fri, 14 Mar 2025 14:33:16 +0100
Subject: [PATCH 0064/1764] GPU clusterizer with neural networks (#13981)

* Copying kernels to implement NN clusterizer

* First version of clusterizer in GPU code

* Adding a compiling and running version with single-threaded ONNX model executions. Clusters are not getting published yet (FIXME)

* Clusters now working by a hack

* Working implementation of settings via GPUSettings.h and --configKeyValues "GPU_proc.[setting]=...;..."

* Modifying the onnx_interface to include the right headers

* Adjusting initialization for new ONNXRuntime version

* Adjusting global settings and CF code for several settings

* Adding return statement if cluster is rejected

* Adding some statements back

* Update to latest status of gpu clusterization

* Fixing uchar -> uint8_t

* Adding utils header

* Updating kernels.cmake to uint8_t

* Please consider the following formatting changes

* Adding an ONNX CPU library in the O2 framework

* Please consider the following formatting changes

* Fixing macOS build issues with calling O*.data()

* Fixing compiler issues and char -> uint8_t

* Fixing curly braces

* Fixing std::make_shared

* Changing order for <CommonUtils/StringUtils.h>

* Bug-fixing file name

* Making NN clusterizer more efficient

* Changing constexpr

* Fixing build issues

* Major changes to make clusterizer parallelizable. Problem remains: different sizes of nnClusterizerBatchedMode lead to different number of clusters if nnClusterizerBatchedMode < clusterer.mPmemory->counters.nClusters

* Adjusting for default CF regression

* Bug-fix for application of CF regression and logging message

* Adding is_boundary check earlier to avoid out-of-bounds access

* Bug-fixes for boundary reading

* Updating to use explicit calls to kernels instead of if-statements

* Bug-fix for class label application

* Explicit casting solves regression issues. To be done: Correct publishing for class2 regression

* Bug-fixes

* Adding some documentation

* Please consider the following formatting changes

* Modifying for Davids comments

* Modifications from comments on PR

* Please consider the following formatting changes

* iSlice -> iSector

* mISlice -> mISector

* Minor bug-fixes

* Adjusting for comments

* Bug-fix for fullCI build

* Adding GPUd() for on-device functions

* Fixing compile issues, only thing mssing: conversion of float to float16

* Let's see if this does the trick

* Making functions (constructors) GPUd() (GPUdDefault())

* GPU kernels should now be findable

* Adding ifdefs for standalone build and header exclusions in GPUORTFloat16

* Modifying the approach to not use std:: types. Still needs to be tested and need to do proper memory allocation

* New version of clusterizer. Compiles locally, but segfaults in fillInput kernel. Testing with the CI now.

* Please consider the following formatting changes

* Adjust for comments

* Please consider the following formatting changes

* Merging dev and adjusting build issues

* Adjusting for comments

* Fixing incorrect #endif

* Please consider the following formatting changes

* Fix indentation, remove duplicate define

* Fixing one memory issue. Segfault / memory leak persists

* Adjusting for new toNative function

* Fixing .finalize

* Adjusting CMakeLIsts and other bugs

* Adding GPUCA_HAS_ONNX only to tracking

* Changing to fixed size for number of clusters

* Fixed segfault. Not producing the right number of clusters yet.

* Network now accepts clusters over all sectors

* Whitespaces...

* Some weird formatting

* Please consider the following formatting changes

* Removing white-spaces

* Adding necessary if-statement to avoid automatic model loading

* Removing GPUConstantMem, adding interOpNumThreads option

* Found the bug where I loose clusters

* Editor configured for whitespaces at EOF

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
Co-authored-by: David Rohr <github@jwdt.org>
---
 Common/ML/include/ML/OrtInterface.h           |   9 +-
 Common/ML/src/OrtInterface.cxx                | 164 +++-----
 GPU/GPUTracking/Base/GPUConstantMem.h         |  10 +-
 GPU/GPUTracking/Base/GPUMemoryResource.h      |   1 +
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |   3 +
 GPU/GPUTracking/CMakeLists.txt                |  12 +-
 .../Definitions/GPUDefGPUParameters.h         |  13 +
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  30 ++
 .../GPUTrackingLinkDef_O2_DataTypes.h         |   1 +
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |   6 +
 .../Global/GPUChainTrackingClusterizer.cxx    | 112 ++++-
 GPU/GPUTracking/TPCClusterFinder/ChargePos.h  |   1 +
 .../TPCClusterFinder/ClusterAccumulator.h     |  11 +
 .../TPCClusterFinder/GPUTPCNNClusterizer.cxx  |  55 +++
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |  77 ++++
 .../GPUTPCNNClusterizerHost.cxx               |  65 +++
 .../GPUTPCNNClusterizerHost.h                 |  68 +++
 .../GPUTPCNNClusterizerKernels.cxx            | 386 ++++++++++++++++++
 .../GPUTPCNNClusterizerKernels.h              |  77 ++++
 GPU/GPUTracking/kernels.cmake                 |  13 +-
 20 files changed, 1002 insertions(+), 112 deletions(-)
 create mode 100644 GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
 create mode 100644 GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
 create mode 100644 GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
 create mode 100644 GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
 create mode 100644 GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
 create mode 100644 GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h

diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index 89631d59a3846..93549178848ca 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -41,6 +41,7 @@ class OrtModel
   OrtModel(std::unordered_map<std::string, std::string> optionsMap) { reset(optionsMap); }
   void init(std::unordered_map<std::string, std::string> optionsMap) { reset(optionsMap); }
   void reset(std::unordered_map<std::string, std::string>);
+  bool isInitialized() { return mInitialized; }
 
   virtual ~OrtModel() = default;
 
@@ -55,6 +56,9 @@ class OrtModel
   template <class I, class O> // class I is the input data type, e.g. float, class O is the output data type, e.g. O2::gpu::OrtDataType::Float16_t from O2/GPU/GPUTracking/ML/convert_float16.h
   std::vector<O> inference(std::vector<std::vector<I>>&);
 
+  template <class I, class O> // class I is the input data type, e.g. float, class O is the output data type, e.g. OrtDataType::Float16_t from O2/Common/ML/include/ML/GPUORTFloat16.h
+  void inference(I*, size_t, O*);
+
   // template<class I, class T, class O> // class I is the input data type, e.g. float, class T the throughput data type and class O is the output data type
   // std::vector<O> inference(std::vector<I>&);
 
@@ -79,8 +83,9 @@ class OrtModel
   std::vector<std::vector<int64_t>> mInputShapes, mOutputShapes;
 
   // Environment settings
-  std::string modelPath, device = "cpu", dtype = "float"; // device options should be cpu, rocm, migraphx, cuda
-  int intraOpNumThreads = 0, deviceId = 0, enableProfiling = 0, loggingLevel = 0, allocateDeviceMemory = 0, enableOptimizations = 0;
+  bool mInitialized = false;
+  std::string modelPath, device = "cpu", dtype = "float", thread_affinity = ""; // device options should be cpu, rocm, migraphx, cuda
+  int intraOpNumThreads = 1, interOpNumThreads = 1, deviceId = 0, enableProfiling = 0, loggingLevel = 0, allocateDeviceMemory = 0, enableOptimizations = 0;
 
   std::string printShape(const std::vector<int64_t>&);
 };
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index eb124ff6f12c9..fc784dd14d2dc 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -44,17 +44,20 @@ void OrtModel::reset(std::unordered_map<std::string, std::string> optionsMap)
   if (!optionsMap.contains("model-path")) {
     LOG(fatal) << "(ORT) Model path cannot be empty!";
   }
-  modelPath = optionsMap["model-path"];
-  device = (optionsMap.contains("device") ? optionsMap["device"] : "CPU");
-  dtype = (optionsMap.contains("dtype") ? optionsMap["dtype"] : "float");
-  deviceId = (optionsMap.contains("device-id") ? std::stoi(optionsMap["device-id"]) : 0);
-  allocateDeviceMemory = (optionsMap.contains("allocate-device-memory") ? std::stoi(optionsMap["allocate-device-memory"]) : 0);
-  intraOpNumThreads = (optionsMap.contains("intra-op-num-threads") ? std::stoi(optionsMap["intra-op-num-threads"]) : 0);
-  loggingLevel = (optionsMap.contains("logging-level") ? std::stoi(optionsMap["logging-level"]) : 2);
-  enableProfiling = (optionsMap.contains("enable-profiling") ? std::stoi(optionsMap["enable-profiling"]) : 0);
-  enableOptimizations = (optionsMap.contains("enable-optimizations") ? std::stoi(optionsMap["enable-optimizations"]) : 0);
-
-  std::string dev_mem_str = "Hip";
+
+  if (!optionsMap["model-path"].empty()) {
+    modelPath = optionsMap["model-path"];
+    device = (optionsMap.contains("device") ? optionsMap["device"] : "CPU");
+    dtype = (optionsMap.contains("dtype") ? optionsMap["dtype"] : "float");
+    deviceId = (optionsMap.contains("device-id") ? std::stoi(optionsMap["device-id"]) : 0);
+    allocateDeviceMemory = (optionsMap.contains("allocate-device-memory") ? std::stoi(optionsMap["allocate-device-memory"]) : 0);
+    intraOpNumThreads = (optionsMap.contains("intra-op-num-threads") ? std::stoi(optionsMap["intra-op-num-threads"]) : 0);
+    interOpNumThreads = (optionsMap.contains("inter-op-num-threads") ? std::stoi(optionsMap["inter-op-num-threads"]) : 0);
+    loggingLevel = (optionsMap.contains("logging-level") ? std::stoi(optionsMap["logging-level"]) : 0);
+    enableProfiling = (optionsMap.contains("enable-profiling") ? std::stoi(optionsMap["enable-profiling"]) : 0);
+    enableOptimizations = (optionsMap.contains("enable-optimizations") ? std::stoi(optionsMap["enable-optimizations"]) : 0);
+
+    std::string dev_mem_str = "Hip";
 #if defined(ORT_ROCM_BUILD)
 #if ORT_ROCM_BUILD == 1
   if (device == "ROCM") {
@@ -88,12 +91,15 @@ void OrtModel::reset(std::unordered_map<std::string, std::string> optionsMap)
 
   if (device == "CPU") {
     (pImplOrt->sessionOptions).SetIntraOpNumThreads(intraOpNumThreads);
-    if (intraOpNumThreads > 1) {
+    (pImplOrt->sessionOptions).SetInterOpNumThreads(interOpNumThreads);
+    if (intraOpNumThreads > 1 || interOpNumThreads > 1) {
       (pImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_PARALLEL);
     } else if (intraOpNumThreads == 1) {
       (pImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_SEQUENTIAL);
     }
-    LOG(info) << "(ORT) CPU execution provider set with " << intraOpNumThreads << " threads";
+    if (loggingLevel < 2) {
+      LOG(info) << "(ORT) CPU execution provider set with " << intraOpNumThreads << " (intraOpNumThreads) and " << interOpNumThreads << " (interOpNumThreads) threads";
+    }
   }
 
   (pImplOrt->sessionOptions).DisableMemPattern();
@@ -109,6 +115,9 @@ void OrtModel::reset(std::unordered_map<std::string, std::string> optionsMap)
   } else {
     (pImplOrt->sessionOptions).DisableProfiling();
   }
+
+  mInitialized = true;
+
   (pImplOrt->sessionOptions).SetGraphOptimizationLevel(GraphOptimizationLevel(enableOptimizations));
   (pImplOrt->sessionOptions).SetLogSeverityLevel(OrtLoggingLevel(loggingLevel));
 
@@ -154,16 +163,9 @@ void OrtModel::reset(std::unordered_map<std::string, std::string> optionsMap)
   outputNamesChar.resize(mOutputNames.size(), nullptr);
   std::transform(std::begin(mOutputNames), std::end(mOutputNames), std::begin(outputNamesChar),
                  [&](const std::string& str) { return str.c_str(); });
-
-  // Print names
-  LOG(info) << "\tInput Nodes:";
-  for (size_t i = 0; i < mInputNames.size(); i++) {
-    LOG(info) << "\t\t" << mInputNames[i] << " : " << printShape(mInputShapes[i]);
   }
-
-  LOG(info) << "\tOutput Nodes:";
-  for (size_t i = 0; i < mOutputNames.size(); i++) {
-    LOG(info) << "\t\t" << mOutputNames[i] << " : " << printShape(mOutputShapes[i]);
+  if (loggingLevel < 2) {
+    LOG(info) << "(ORT) Model loaded successfully! (input: " << printShape(mInputShapes[0]) << ", output: " << printShape(mOutputShapes[0]) << ")";
   }
 }
 
@@ -187,36 +189,6 @@ std::vector<O> OrtModel::v2v(std::vector<I>& input, bool clearInput)
   }
 }
 
-template <class I, class O> // class I is the input data type, e.g. float, class O is the output data type, e.g. O2::gpu::OrtDataType::Float16_t from O2/GPU/GPUTracking/ML/convert_float16.h
-std::vector<O> OrtModel::inference(std::vector<I>& input)
-{
-  std::vector<int64_t> inputShape{(int64_t)(input.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
-  std::vector<Ort::Value> inputTensor;
-  inputTensor.emplace_back(Ort::Value::CreateTensor<O>(pImplOrt->memoryInfo, reinterpret_cast<O*>(input.data()), input.size(), inputShape.data(), inputShape.size()));
-  // input.clear();
-  auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
-  O* outputValues = reinterpret_cast<O*>(outputTensors[0].template GetTensorMutableData<O>());
-  std::vector<O> outputValuesVec{outputValues, outputValues + inputShape[0] * mOutputShapes[0][1]};
-  outputTensors.clear();
-  return outputValuesVec;
-}
-
-template <class I, class O> // class I is the input data type, e.g. float, class O is the output data type, e.g. O2::gpu::OrtDataType::Float16_t from O2/GPU/GPUTracking/ML/convert_float16.h
-std::vector<O> OrtModel::inference(std::vector<std::vector<I>>& input)
-{
-  std::vector<Ort::Value> inputTensor;
-  for (auto i : input) {
-    std::vector<int64_t> inputShape{(int64_t)(i.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
-    inputTensor.emplace_back(Ort::Value::CreateTensor<O>(pImplOrt->memoryInfo, reinterpret_cast<O*>(i.data()), i.size(), inputShape.data(), inputShape.size()));
-  }
-  // input.clear();
-  auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
-  O* outputValues = reinterpret_cast<O*>(outputTensors[0].template GetTensorMutableData<O>());
-  std::vector<O> outputValuesVec{outputValues, outputValues + inputTensor.size() / mInputShapes[0][1] * mOutputShapes[0][1]};
-  outputTensors.clear();
-  return outputValuesVec;
-}
-
 std::string OrtModel::printShape(const std::vector<int64_t>& v)
 {
   std::stringstream ss("");
@@ -227,74 +199,68 @@ std::string OrtModel::printShape(const std::vector<int64_t>& v)
   return ss.str();
 }
 
-template <>
-std::vector<float> OrtModel::inference<float, float>(std::vector<float>& input)
+template <class I, class O>
+std::vector<O> OrtModel::inference(std::vector<I>& input)
 {
   std::vector<int64_t> inputShape{(int64_t)(input.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
   std::vector<Ort::Value> inputTensor;
-  inputTensor.emplace_back(Ort::Value::CreateTensor<float>(pImplOrt->memoryInfo, input.data(), input.size(), inputShape.data(), inputShape.size()));
+  if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
+    inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input.data()), input.size(), inputShape.data(), inputShape.size()));
+  } else {
+    inputTensor.emplace_back(Ort::Value::CreateTensor<I>(pImplOrt->memoryInfo, input.data(), input.size(), inputShape.data(), inputShape.size()));
+  }
   // input.clear();
   auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
-  float* outputValues = outputTensors[0].template GetTensorMutableData<float>();
-  std::vector<float> outputValuesVec{outputValues, outputValues + inputShape[0] * mOutputShapes[0][1]};
+  O* outputValues = outputTensors[0].template GetTensorMutableData<O>();
+  std::vector<O> outputValuesVec{outputValues, outputValues + inputShape[0] * mOutputShapes[0][1]};
   outputTensors.clear();
   return outputValuesVec;
 }
 
-template <>
-std::vector<float> OrtModel::inference<OrtDataType::Float16_t, float>(std::vector<OrtDataType::Float16_t>& input)
-{
-  std::vector<int64_t> inputShape{(int64_t)(input.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
-  std::vector<Ort::Value> inputTensor;
-  inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input.data()), input.size(), inputShape.data(), inputShape.size()));
-  // input.clear();
-  auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
-  float* outputValues = outputTensors[0].template GetTensorMutableData<float>();
-  std::vector<float> outputValuesVec{outputValues, outputValues + inputShape[0] * mOutputShapes[0][1]};
-  outputTensors.clear();
-  return outputValuesVec;
-}
+template std::vector<float> OrtModel::inference<float, float>(std::vector<float>&);
 
-template <>
-std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(std::vector<OrtDataType::Float16_t>& input)
-{
-  std::vector<int64_t> inputShape{(int64_t)(input.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
-  std::vector<Ort::Value> inputTensor;
-  inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input.data()), input.size(), inputShape.data(), inputShape.size()));
-  // input.clear();
-  auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
-  OrtDataType::Float16_t* outputValues = reinterpret_cast<OrtDataType::Float16_t*>(outputTensors[0].template GetTensorMutableData<Ort::Float16_t>());
-  std::vector<OrtDataType::Float16_t> outputValuesVec{outputValues, outputValues + inputShape[0] * mOutputShapes[0][1]};
-  outputTensors.clear();
-  return outputValuesVec;
-}
+template std::vector<float> OrtModel::inference<OrtDataType::Float16_t, float>(std::vector<OrtDataType::Float16_t>&);
 
-template <>
-std::vector<OrtDataType::Float16_t> OrtModel::inference<float, OrtDataType::Float16_t>(std::vector<float>& input)
+template std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(std::vector<OrtDataType::Float16_t>&);
+
+template <class I, class O>
+void OrtModel::inference(I* input, size_t input_size, O* output)
 {
-  std::vector<int64_t> inputShape{(int64_t)(input.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
-  std::vector<Ort::Value> inputTensor;
-  inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input.data()), input.size(), inputShape.data(), inputShape.size()));
-  // input.clear();
-  auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
-  OrtDataType::Float16_t* outputValues = reinterpret_cast<OrtDataType::Float16_t*>(outputTensors[0].template GetTensorMutableData<Ort::Float16_t>());
-  std::vector<OrtDataType::Float16_t> outputValuesVec{outputValues, outputValues + inputShape[0] * mOutputShapes[0][1]};
-  outputTensors.clear();
-  return outputValuesVec;
+  std::vector<int64_t> inputShape{(int64_t)(input_size / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
+  Ort::Value inputTensor = Ort::Value(nullptr);
+  if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
+    inputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input), input_size, inputShape.data(), inputShape.size());
+  } else {
+    inputTensor = Ort::Value::CreateTensor<I>(pImplOrt->memoryInfo, input, input_size, inputShape.data(), inputShape.size());
+  }
+
+  std::vector<int64_t> outputShape{inputShape[0], mOutputShapes[0][1]};
+  size_t outputSize = (int64_t)(input_size * mOutputShapes[0][1] / mInputShapes[0][1]);
+  Ort::Value outputTensor = Ort::Value::CreateTensor<O>(pImplOrt->memoryInfo, output, outputSize, outputShape.data(), outputShape.size());
+
+  (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), &inputTensor, 1, outputNamesChar.data(), &outputTensor, outputNamesChar.size()); // TODO: Not sure if 1 is correct here
 }
 
-template <>
-std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(std::vector<std::vector<OrtDataType::Float16_t>>& input)
+template void OrtModel::inference<OrtDataType::Float16_t, float>(OrtDataType::Float16_t*, size_t, float*);
+
+template void OrtModel::inference<float, float>(float*, size_t, float*);
+
+template <class I, class O>
+std::vector<O> OrtModel::inference(std::vector<std::vector<I>>& input)
 {
   std::vector<Ort::Value> inputTensor;
   for (auto i : input) {
     std::vector<int64_t> inputShape{(int64_t)(i.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
-    inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(i.data()), i.size(), inputShape.data(), inputShape.size()));
+    if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
+      inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(i.data()), i.size(), inputShape.data(), inputShape.size()));
+    } else {
+      inputTensor.emplace_back(Ort::Value::CreateTensor<I>(pImplOrt->memoryInfo, i.data(), i.size(), inputShape.data(), inputShape.size()));
+    }
   }
   // input.clear();
   auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
-  OrtDataType::Float16_t* outputValues = reinterpret_cast<OrtDataType::Float16_t*>(outputTensors[0].template GetTensorMutableData<Ort::Float16_t>());
-  std::vector<OrtDataType::Float16_t> outputValuesVec{outputValues, outputValues + inputTensor.size() / mInputShapes[0][1] * mOutputShapes[0][1]};
+  O* outputValues = reinterpret_cast<O*>(outputTensors[0].template GetTensorMutableData<O>());
+  std::vector<O> outputValuesVec{outputValues, outputValues + inputTensor.size() / mInputShapes[0][1] * mOutputShapes[0][1]};
   outputTensors.clear();
   return outputValuesVec;
 }
diff --git a/GPU/GPUTracking/Base/GPUConstantMem.h b/GPU/GPUTracking/Base/GPUConstantMem.h
index 4f83fa48a64e0..8f1cc90f5ae93 100644
--- a/GPU/GPUTracking/Base/GPUConstantMem.h
+++ b/GPU/GPUTracking/Base/GPUConstantMem.h
@@ -34,12 +34,15 @@
 #include "GPUKernelDebugOutput.h"
 #endif
 
+#ifdef GPUCA_HAS_ONNX
+#include "GPUTPCNNClusterizer.h"
+#endif
+
 namespace o2::gpu
 {
 struct GPUConstantMem {
   GPUParam param;
-  GPUTPCTracker
-    tpcTrackers[GPUCA_NSECTORS];
+  GPUTPCTracker tpcTrackers[GPUCA_NSECTORS];
   GPUTPCConvert tpcConverter;
   GPUTPCCompression tpcCompressor;
   GPUTPCDecompression tpcDecompressor;
@@ -55,6 +58,9 @@ struct GPUConstantMem {
 #ifdef GPUCA_KERNEL_DEBUGGER_OUTPUT
   GPUKernelDebugOutput debugOutput;
 #endif
+#ifdef GPUCA_HAS_ONNX
+  GPUTPCNNClusterizer tpcNNClusterer[GPUCA_NSECTORS];
+#endif
 
   template <int32_t I>
   GPUd() auto& getTRDTracker();
diff --git a/GPU/GPUTracking/Base/GPUMemoryResource.h b/GPU/GPUTracking/Base/GPUMemoryResource.h
index 3bb2c363db2a9..06e350db0bfc7 100644
--- a/GPU/GPUTracking/Base/GPUMemoryResource.h
+++ b/GPU/GPUTracking/Base/GPUMemoryResource.h
@@ -28,6 +28,7 @@ struct GPUMemoryReuse {
   };
   enum Group : uint16_t {
     ClustererScratch,
+    NNClusterer,
     ClustererZS,
     TrackerScratch,
     TrackerDataLinks,
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 656fa37fb6a4c..df9a7380834ce 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -93,6 +93,9 @@ GPUReconstruction::GPUReconstruction(const GPUSettingsDeviceBackend& cfg) : mHos
   for (uint32_t i = 0; i < NSECTORS; i++) {
     processors()->tpcTrackers[i].SetSector(i); // TODO: Move to a better place
     processors()->tpcClusterer[i].mISector = i;
+#ifdef GPUCA_HAS_ONNX
+    processors()->tpcNNClusterer[i].mISector = i;
+#endif
   }
 #ifndef GPUCA_NO_ROOT
   mROOTDump = GPUROOTDumpCore::getAndCreate();
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index c97742ac1d47f..d5a90dbd65ea3 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -159,8 +159,8 @@ set(HDRS_INSTALL
 )
 
 set(SRCS_NO_CINT ${SRCS_NO_CINT} display/GPUDisplayInterface.cxx)
-set(SRCS_NO_CINT
-    ${SRCS_NO_CINT}
+
+set(SRCS_NO_CINT ${SRCS_NO_CINT}
     Global/GPUChainITS.cxx
     ITS/GPUITSFitter.cxx
     ITS/GPUITSFitterKernels.cxx
@@ -191,6 +191,10 @@ set(SRCS_NO_CINT
     Refit/GPUTrackingRefitKernel.cxx
     Merger/GPUTPCGMO2Output.cxx)
 
+if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
+  list(APPEND SRCS_NO_CINT TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx TPCClusterFinder/GPUTPCNNClusterizer.cxx TPCClusterFinder/GPUTPCNNClusterizerHost.cxx)
+endif()
+
 set(SRCS_DATATYPES
     ${SRCS_DATATYPES}
     DataTypes/TPCPadGainCalib.cxx
@@ -273,6 +277,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                  PRIVATE_LINK_LIBRARIES O2::DataFormatsTPC
                  SOURCES ${SRCS_DATATYPES})
   target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2)
+
   o2_target_root_dictionary(GPUDataTypes
                             HEADERS ${HDRS_CINT_DATATYPES} ${HDRS_CINT_O2_ADDITIONAL}
                             LINKDEF GPUTrackingLinkDef_O2_DataTypes.h)
@@ -292,6 +297,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                                        O2::TPCFastTransformation
                                        O2::DetectorsRaw
                                        O2::Steer
+                                       O2::ML
                  PUBLIC_INCLUDE_DIRECTORIES .
                                             Definitions
                                             DataTypes
@@ -317,7 +323,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${targetName}
     PRIVATE $<TARGET_PROPERTY:O2::Framework,INTERFACE_INCLUDE_DIRECTORIES>)
 
-  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2)
+  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2 GPUCA_HAS_ONNX=1)
 
   o2_target_root_dictionary(${MODULE}
                             HEADERS ${HDRS_CINT_O2} ${HDRS_CINT_O2_ADDITIONAL}
diff --git a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
index 3ed6c25762405..55f2e76344bd5 100644
--- a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
+++ b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
@@ -477,6 +477,9 @@
   #ifndef GPUCA_LB_GPUTPCCFClusterizer
     #define GPUCA_LB_GPUTPCCFClusterizer 512
   #endif
+  #ifndef GPUCA_LB_GPUTPCNNClusterizerKernels
+    #define GPUCA_LB_GPUTPCNNClusterizerKernels 512
+  #endif
   #ifndef GPUCA_LB_GPUTrackingRefitKernel_mode0asGPU
     #define GPUCA_LB_GPUTrackingRefitKernel_mode0asGPU 256
   #endif
@@ -495,6 +498,16 @@
 
 #define GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression GPUCA_LB_GPUTPCCFNoiseSuppression
 #define GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks GPUCA_LB_GPUTPCCFNoiseSuppression
+
+#ifdef GPUCA_HAS_ONNX
+#define GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer GPUCA_LB_GPUTPCNNClusterizerKernels
+#define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN GPUCA_LB_GPUTPCNNClusterizerKernels
+#define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels GPUCA_LB_GPUTPCNNClusterizerKernels
+#define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
+#define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
+#define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression GPUCA_LB_GPUTPCNNClusterizerKernels
+#endif
+
 #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_THREAD_COUNT_SCAN
 #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_THREAD_COUNT_SCAN
 #define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_THREAD_COUNT_SCAN
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 9b6be7743e485..63fcf51004eae 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -222,6 +222,35 @@ AddOption(tpcTriggerHandling, bool, true, "", 0, "Enable TPC trigger handling")
 AddHelp("help", 'h')
 EndConfig()
 
+BeginSubConfig(GPUSettingsProcessingNNclusterizer, nn, configStandalone.proc, "NN", 0, "Processing settings for neural network clusterizer", proc_nn)
+AddOption(applyNNclusterizer, int, 0, "", 0, "(bool, default = 0), if the neural network clusterizer should be used.")
+AddOption(nnInferenceDevice, std::string, "CPU", "", 0, "(std::string) Specify inference device (cpu (default), rocm, cuda)")
+AddOption(nnInferenceDeviceId, unsigned int, 0, "", 0, "(unsigned int) Specify inference device id")
+AddOption(nnInferenceAllocateDevMem, int, 0, "", 0, "(bool, default = 0), if the device memory should be allocated for inference")
+AddOption(nnInferenceDtype, std::string, "fp32", "", 0, "(std::string) Specify the datatype for which inference is performed (fp32: default, fp16)") // fp32 or fp16
+AddOption(nnInferenceIntraOpNumThreads, int, 1, "", 0, "Number of threads used to evaluate one neural network (ONNX: SetIntraOpNumThreads). 0 = auto-detect, can lead to problems on SLURM systems.")
+AddOption(nnInferenceInterOpNumThreads, int, 1, "", 0, "Number of threads used to evaluate one neural network (ONNX: SetInterOpNumThreads). 0 = auto-detect, can lead to problems on SLURM systems.")
+AddOption(nnInferenceEnableOrtOptimization, unsigned int, 99, "", 0, "Enables graph optimizations in ONNX Runtime. Can be [0, 1, 2, 99] -> see https://github.com/microsoft/onnxruntime/blob/3f71d637a83dc3540753a8bb06740f67e926dc13/include/onnxruntime/core/session/onnxruntime_c_api.h#L347")
+AddOption(nnInferenceOrtProfiling, int, 0, "", 0, "Enables profiling of model execution in ONNX Runtime")
+AddOption(nnInferenceOrtProfilingPath, std::string, ".", "", 0, "If nnInferenceOrtProfiling is set, the path to store the profiling data")
+AddOption(nnInferenceVerbosity, int, 1, "", 0, "0: No messages; 1: Warnings; 2: Warnings + major debugs; >3: All debugs")
+AddOption(nnClusterizerAddIndexData, int, 1, "", 0, "If normalized index data (sector, row, pad), should be appended to the input")
+AddOption(nnClusterizerSizeInputRow, int, 3, "", 0, "Size of the input to the NN (currently calcualted as (length-1)/2")
+AddOption(nnClusterizerSizeInputPad, int, 3, "", 0, "Size of the input to the NN (currently calcualted as (length-1)/2")
+AddOption(nnClusterizerSizeInputTime, int, 3, "", 0, "Size of the input to the NN (currently calcualted as (length-1)/2")
+AddOption(nnClusterizerUseCfRegression, int, 0, "", 0, "(bool, default = false) If true, use the regression from the native clusterizer and not the NN")
+AddOption(nnClusterizerApplyCfDeconvolution, int, 0, "", 0, "Applies the CFDeconvolution kernel before the digits to the network are filled")
+AddOption(nnClusterizerBatchedMode, unsigned int, 1, "", 0, "(int, default = 1) If >1, the NN is evaluated on batched input of size specified in this variable")
+AddOption(nnClusterizerVerbosity, int, -1, "", 0, "(int, default = -1) If >0, logging messages of the clusterizer will be displayed")
+AddOption(nnClusterizerBoundaryFillValue, int, -1, "", 0, "Fill value for the boundary of the input to the NN")
+AddOption(nnClusterizerApplyNoiseSuppression, int, 1, "", 0, "Applies the NoiseSuppression kernel before the digits to the network are filled")
+AddOption(nnClassificationPath, std::string, "network_class.onnx", "", 0, "The classification network path")
+AddOption(nnClassThreshold, float, 0.5, "", 0, "The cutoff at which clusters will be accepted / rejected.")
+AddOption(nnRegressionPath, std::string, "network_reg.onnx", "", 0, "The regression network path")
+AddOption(nnSigmoidTrafoClassThreshold, int, 1, "", 0, "If true (default), then the classification threshold is transformed by an inverse sigmoid function. This depends on how the network was trained (with a sigmoid as acitvation function in the last layer or not).")
+AddHelp("help", 'h')
+EndConfig()
+
 BeginSubConfig(GPUSettingsProcessing, proc, configStandalone, "PROC", 0, "Processing settings", proc)
 AddOption(deviceNum, int32_t, -1, "gpuDevice", 0, "Set GPU device to use (-1: automatic, -2: for round-robin usage in timeslice-pipeline)")
 AddOption(gpuDeviceOnly, bool, false, "", 0, "Use only GPU as device (i.e. no CPU for OpenCL)")
@@ -299,6 +328,7 @@ AddOption(printSettings, bool, false, "", 0, "Print all settings when initializi
 AddVariable(eventDisplay, o2::gpu::GPUDisplayFrontendInterface*, nullptr)
 AddSubConfig(GPUSettingsProcessingRTC, rtc)
 AddSubConfig(GPUSettingsProcessingParam, param)
+AddSubConfig(GPUSettingsProcessingNNclusterizer, nn)
 AddHelp("help", 'h')
 EndConfig()
 #endif // __OPENCL__
diff --git a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
index ab60827655a43..35ebbabe41672 100644
--- a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
+++ b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
@@ -30,6 +30,7 @@
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessing + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingParam + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingRTC + ;
+#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingNNclusterizer + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplay + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplayLight + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplayHeavy + ;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 6dcb6f1d7e514..37ad164d20a60 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -103,6 +103,9 @@ void GPUChainTracking::RegisterPermanentMemoryAndProcessors()
   if (GetRecoSteps() & RecoStep::TPCClusterFinding) {
     for (uint32_t i = 0; i < NSECTORS; i++) {
       mRec->RegisterGPUProcessor(&processors()->tpcClusterer[i], GetRecoStepsGPU() & RecoStep::TPCClusterFinding);
+#ifdef GPUCA_HAS_ONNX
+      mRec->RegisterGPUProcessor(&processors()->tpcNNClusterer[i], GetRecoStepsGPU() & RecoStep::TPCClusterFinding);
+#endif
     }
   }
   if (GetRecoSteps() & RecoStep::Refit) {
@@ -148,6 +151,9 @@ void GPUChainTracking::RegisterGPUProcessors()
   if (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) {
     for (uint32_t i = 0; i < NSECTORS; i++) {
       mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcClusterer[i], &processors()->tpcClusterer[i]);
+#ifdef GPUCA_HAS_ONNX
+      mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcNNClusterer[i], &processors()->tpcNNClusterer[i]);
+#endif
     }
   }
   if (GetRecoStepsGPU() & RecoStep::Refit) {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 62a4a524d67df..63d56da37595b 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -39,6 +39,11 @@
 #include <Vc/Vc>
 #endif
 
+#ifdef GPUCA_HAS_ONNX
+#include "GPUTPCNNClusterizerKernels.h"
+#include "GPUTPCNNClusterizerHost.h"
+#endif
+
 using namespace o2::gpu;
 using namespace o2::tpc;
 using namespace o2::tpc::constants;
@@ -149,7 +154,8 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCount(uint
   uint32_t endpointAdcSamples[GPUTrackingInOutZS::NENDPOINTS];
   memset(endpointAdcSamples, 0, sizeof(endpointAdcSamples));
   bool doGPU = mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding;
-  int32_t firstHBF = (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasTfStartOrbit) ? mIOPtrs.settingsTF->tfStartOrbit : (mIOPtrs.tpcZS->sector[iSector].count[0] && mIOPtrs.tpcZS->sector[iSector].nZSPtr[0][0]) ? o2::raw::RDHUtils::getHeartBeatOrbit(*(const o2::header::RAWDataHeader*)mIOPtrs.tpcZS->sector[iSector].zsPtr[0][0]) : 0;
+  int32_t firstHBF = (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasTfStartOrbit) ? mIOPtrs.settingsTF->tfStartOrbit : (mIOPtrs.tpcZS->sector[iSector].count[0] && mIOPtrs.tpcZS->sector[iSector].nZSPtr[0][0]) ? o2::raw::RDHUtils::getHeartBeatOrbit(*(const o2::header::RAWDataHeader*)mIOPtrs.tpcZS->sector[iSector].zsPtr[0][0])
+                                                                                                                                                                                                               : 0;
 
   for (uint16_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
 #ifndef GPUCA_NO_VC
@@ -606,6 +612,41 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     RunTPCClusterizer_prepare(true); // Restore some pointers, allocated by the other pipeline, and set to 0 by SetupGPUProcessor (since not allocated in this pipeline)
   }
 
+#ifdef GPUCA_HAS_ONNX
+  if (GetProcessingSettings().nn.applyNNclusterizer) {
+    uint32_t maxClusters = -1;
+    for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
+      maxClusters = std::max(maxClusters, processors()->tpcClusterer[iSector].mNMaxClusters);
+    }
+    for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
+      GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[iSector];
+      const GPUSettingsProcessingNNclusterizer& nn_settings = GetProcessingSettings().nn;
+      clustererNN.nnClusterizerUseCfRegression = nn_settings.nnClusterizerUseCfRegression;
+      clustererNN.nnClusterizerSizeInputRow = nn_settings.nnClusterizerSizeInputRow;
+      clustererNN.nnClusterizerSizeInputPad = nn_settings.nnClusterizerSizeInputPad;
+      clustererNN.nnClusterizerSizeInputTime = nn_settings.nnClusterizerSizeInputTime;
+      clustererNN.nnClusterizerAddIndexData = nn_settings.nnClusterizerAddIndexData;
+      clustererNN.nnClusterizerElementSize = ((2 * nn_settings.nnClusterizerSizeInputRow + 1) * (2 * nn_settings.nnClusterizerSizeInputPad + 1) * (2 * nn_settings.nnClusterizerSizeInputTime + 1)) + (nn_settings.nnClusterizerAddIndexData ? 3 : 0);
+      clustererNN.nnClusterizerBatchedMode = nn_settings.nnClusterizerBatchedMode;
+      clustererNN.nnClusterizerBoundaryFillValue = nn_settings.nnClusterizerBoundaryFillValue;
+      clustererNN.nnClusterizerTotalClusters = maxClusters;
+      clustererNN.nnClassThreshold = nn_settings.nnClassThreshold;
+      clustererNN.nnSigmoidTrafoClassThreshold = nn_settings.nnSigmoidTrafoClassThreshold;
+      if (clustererNN.nnSigmoidTrafoClassThreshold) {
+        clustererNN.nnClassThreshold = (float)std::log(clustererNN.nnClassThreshold / (1.f - clustererNN.nnClassThreshold));
+      }
+      if (nn_settings.nnClusterizerVerbosity < 0) {
+        clustererNN.nnClusterizerVerbosity = nn_settings.nnInferenceVerbosity;
+      } else {
+        clustererNN.nnClusterizerVerbosity = nn_settings.nnClusterizerVerbosity;
+      }
+      clustererNN.nnClusterizerDtype = nn_settings.nnInferenceDtype.find("32") != std::string::npos;
+      GPUTPCNNClusterizerHost nnApplication(nn_settings, clustererNN);
+      AllocateRegisteredMemory(clustererNN.mMemoryId);
+    }
+  }
+#endif
+
   if (doGPU && mIOPtrs.tpcZS) {
     processorsShadow()->ioPtrs.tpcZS = mInputsShadow->mPzsMeta;
     WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->ioPtrs - (char*)processors(), &processorsShadow()->ioPtrs, sizeof(processorsShadow()->ioPtrs), mRec->NStreams() - 1);
@@ -854,6 +895,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         uint32_t iSector = iSectorBase + lane;
         GPUTPCClusterFinder& clusterer = processors()->tpcClusterer[iSector];
         GPUTPCClusterFinder& clustererShadow = doGPU ? processorsShadow()->tpcClusterer[iSector] : clusterer;
+
         if (doGPU) {
           SynchronizeStream(lane);
         }
@@ -871,17 +913,77 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           return;
         }
 
-        runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
-        DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 4, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
+        if (GetProcessingSettings().nn.applyNNclusterizer) {
+#ifdef GPUCA_HAS_ONNX
+          GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[iSector];
+          const GPUSettingsProcessingNNclusterizer& nn_settings = GetProcessingSettings().nn;
+          GPUTPCNNClusterizerHost nnApplication(nn_settings, clustererNN);
+
+          if (clustererNN.nnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
+            runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
+            DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 4, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
+          }
+
+          float time_clusterizer = 0, time_fill = 0;
+          for (int batch = 0; batch < std::ceil((float)clusterer.mPmemory->counters.nClusters / clustererNN.nnClusterizerBatchedMode); batch++) {
+            uint batchStart = batch * clustererNN.nnClusterizerBatchedMode;
+            size_t iSize = CAMath::Min((uint)clustererNN.nnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
+
+            auto start0 = std::chrono::high_resolution_clock::now();
+            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNN>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Filling the data
+
+            auto stop0 = std::chrono::high_resolution_clock::now();
+            auto start1 = std::chrono::high_resolution_clock::now();
+            nnApplication.networkInference(nnApplication.model_class, clustererNN, iSize, clustererNN.modelProbabilities, clustererNN.nnClusterizerDtype);
+            if (nnApplication.model_class.getNumOutputNodes()[0][1] == 1) {
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Assigning class labels
+            } else {
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass2Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Assigning class labels
+            }
+
+            if (!clustererNN.nnClusterizerUseCfRegression) {
+              nnApplication.networkInference(nnApplication.model_reg_1, clustererNN, iSize, clustererNN.outputDataReg1, clustererNN.nnClusterizerDtype);
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass1Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Running the NN for regression class 1
+              if (nnApplication.model_class.getNumOutputNodes()[0][1] > 1 && nnApplication.reg_model_paths.size() > 1) {
+                nnApplication.networkInference(nnApplication.model_reg_2, clustererNN, iSize, clustererNN.outputDataReg2, clustererNN.nnClusterizerDtype);
+                runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Running the NN for regression class 2
+              }
+            }
+            auto stop1 = std::chrono::high_resolution_clock::now();
+
+            time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
+            time_fill += std::chrono::duration_cast<std::chrono::nanoseconds>(stop0 - start0).count() / 1e9;
+          }
+          auto start1 = std::chrono::high_resolution_clock::now();
+          if (clustererNN.nnClusterizerUseCfRegression) {
+            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
+          }
+          auto stop1 = std::chrono::high_resolution_clock::now();
+          time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
+          if (clustererNN.nnClusterizerVerbosity < 3) {
+            int acceptedClusters = 0;
+            for (size_t i = 0; i < clusterer.mPmemory->counters.nClusters; ++i) {
+              acceptedClusters += clustererNN.outputDataClass[i];
+            }
+            LOG(info) << "[NN CF] Apply NN (fragment " << fragment.index << ", lane: " << lane << ", sector: " << iSector << "): filling data " << time_fill << "s ; clusterizer: " << time_clusterizer << "s ; " << clusterer.mPmemory->counters.nClusters << " clusters, " << acceptedClusters << " accepted. --> " << clusterer.mPmemory->counters.nClusters / (time_fill + time_clusterizer) << " clusters/s";
+          }
+#else
+          GPUFatal("Project not compiled with neural network clusterization. Aborting.");
+#endif
+        } else {
+          runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
+          DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 4, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
+          runKernel<GPUTPCCFClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), {iSector}}, 0);
+        }
 
-        runKernel<GPUTPCCFClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), {iSector}}, 0);
         if (doGPU && propagateMCLabels) {
           TransferMemoryResourceLinkToHost(RecoStep::TPCClusterFinding, clusterer.mScratchId, lane);
           if (doGPU) {
             SynchronizeStream(lane);
           }
-          runKernel<GPUTPCCFClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}}, 1);
+          runKernel<GPUTPCCFClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}}, 1); // Computes MC labels
         }
+
         if (GetProcessingSettings().debugLevel >= 3) {
           GPUInfo("Sector %02d Fragment %02d Lane %d: Found clusters: digits %u peaks %u clusters %u", iSector, fragment.index, lane, (int32_t)clusterer.mPmemory->counters.nPositions, (int32_t)clusterer.mPmemory->counters.nPeaks, (int32_t)clusterer.mPmemory->counters.nClusters);
         }
diff --git a/GPU/GPUTracking/TPCClusterFinder/ChargePos.h b/GPU/GPUTracking/TPCClusterFinder/ChargePos.h
index b4a4752b0f932..cdd489e0ef938 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ChargePos.h
+++ b/GPU/GPUTracking/TPCClusterFinder/ChargePos.h
@@ -45,6 +45,7 @@ struct ChargePos {
   GPUdi() tpccf::Row row() const { return gpad / TPC_PADS_PER_ROW_PADDED; }
   GPUdi() tpccf::Pad pad() const { return gpad % TPC_PADS_PER_ROW_PADDED - GPUCF_PADDING_PAD; }
   GPUdi() tpccf::TPCFragmentTime time() const { return timePadded - GPUCF_PADDING_TIME; }
+  GPUdi() tpccf::TPCFragmentTime globalTime() const { return timePadded; }
 
  private:
   // Maps the position of a pad given as row and index in that row to a unique
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
index f0c6ac47f3c8a..90d977372b201 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
@@ -41,6 +41,17 @@ class ClusterAccumulator
   GPUd() tpccf::Charge updateInner(PackedCharge, tpccf::Delta2);
   GPUd() tpccf::Charge updateOuter(PackedCharge, tpccf::Delta2);
 
+  GPUd() void setFull(float qtot, float padMean, float padSigma, float timeMean, float timeSigma, uint8_t splitInPad, uint8_t splitInTime)
+  {
+    mQtot = qtot;
+    mPadMean = padMean;
+    mPadSigma = padSigma;
+    mTimeMean = timeMean;
+    mTimeSigma = timeSigma;
+    mSplitInPad = splitInPad;
+    mSplitInTime = splitInTime;
+  }
+
   GPUd() void finalize(const ChargePos&, const tpccf::Charge, tpccf::TPCTime);
   GPUd() bool toNative(const ChargePos&, const tpccf::Charge, tpc::ClusterNative&, const GPUParam&, const Array2D<PackedCharge>&);
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
new file mode 100644
index 0000000000000..6a9b6f546ae07
--- /dev/null
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
@@ -0,0 +1,55 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUTPCNNClusterizer.cxx
+/// \author Christian Sonnabend
+
+#include "GPUReconstruction.h"
+#include "ML/3rdparty/GPUORTFloat16.h"
+#include "GPUTPCNNClusterizer.h"
+
+using namespace o2::gpu;
+
+void GPUTPCNNClusterizer::InitializeProcessor() {}
+
+void GPUTPCNNClusterizer::SetMaxData(const GPUTrackingInOutPointers& io) {}
+
+void* GPUTPCNNClusterizer::setIOPointers(void* mem)
+{
+  if (nnClusterizerDtype == 0 && nnClusterizerElementSize > 0) {
+    computePointerWithAlignment(mem, inputData16, nnClusterizerBatchedMode * nnClusterizerElementSize);
+  } else if (nnClusterizerDtype == 1 && nnClusterizerElementSize > 0) {
+    computePointerWithAlignment(mem, inputData32, nnClusterizerBatchedMode * nnClusterizerElementSize);
+  }
+  computePointerWithAlignment(mem, peakPositions, nnClusterizerBatchedMode);
+  computePointerWithAlignment(mem, clusterFlags, 2 * nnClusterizerBatchedMode);
+  computePointerWithAlignment(mem, centralCharges, nnClusterizerBatchedMode);
+  computePointerWithAlignment(mem, outputDataClass, nnClusterizerTotalClusters);
+  if (nnClusterizerModelClassNumOutputNodes > 0) {
+    computePointerWithAlignment(mem, modelProbabilities, nnClusterizerBatchedMode * nnClusterizerModelClassNumOutputNodes);
+  }
+  if (!nnClusterizerUseCfRegression) {
+    if (nnClusterizerModelReg1NumOutputNodes > 0) {
+      computePointerWithAlignment(mem, outputDataReg1, nnClusterizerBatchedMode * nnClusterizerModelReg1NumOutputNodes);
+    }
+    if (nnClusterizerModelReg2NumOutputNodes > 0) {
+      computePointerWithAlignment(mem, outputDataReg2, nnClusterizerBatchedMode * nnClusterizerModelReg2NumOutputNodes);
+    }
+  }
+  return mem;
+}
+
+void GPUTPCNNClusterizer::RegisterMemoryAllocation()
+{
+  AllocateAndInitializeLate();
+  int32_t memType = GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK;
+  mMemoryId = mRec->RegisterMemoryAllocation(this, &GPUTPCNNClusterizer::setIOPointers, memType, "TPCNNClusterer", GPUMemoryReuse{GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::NNClusterer, (uint16_t)(mISector % mRec->GetProcessingSettings().nTPCClustererLanes)});
+}
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
new file mode 100644
index 0000000000000..ea6340dfd48bc
--- /dev/null
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -0,0 +1,77 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUTPCNNClusterizer.h
+/// \author Christian Sonnabend
+
+#ifndef O2_GPUTPCNNCLUSTERIZER_H
+#define O2_GPUTPCNNCLUSTERIZER_H
+
+#include "ChargePos.h"
+#include "GPUProcessor.h"
+
+namespace o2::OrtDataType
+{
+struct Float16_t;
+}
+
+namespace o2::gpu
+{
+
+class GPUTPCNNClusterizer : public GPUProcessor
+{
+ public:
+  GPUTPCNNClusterizer() = default;
+  void* setIOPointers(void*);
+  void RegisterMemoryAllocation();
+  void InitializeProcessor();
+  void SetMaxData(const GPUTrackingInOutPointers&);
+
+  // Neural network clusterization
+
+  int nnClusterizerSizeInputRow = 3;
+  int nnClusterizerSizeInputPad = 3;
+  int nnClusterizerSizeInputTime = 3;
+  int nnClusterizerElementSize = -1;
+  bool nnClusterizerAddIndexData = true;
+  float nnClassThreshold = 0.16;
+  bool nnSigmoidTrafoClassThreshold = 1;
+  int nnClusterizerUseCfRegression = 0;
+  int nnClusterizerBatchedMode = 1;
+  int nnClusterizerTotalClusters = 1;
+  int nnClusterizerVerbosity = 0;
+  int nnClusterizerBoundaryFillValue = -1;
+  int nnClusterizerDumpDigits = 0;
+  int nnClusterizerApplyCfDeconvolution = 0;
+  int nnClusterizerModelClassNumOutputNodes = -1;
+  int nnClusterizerModelReg1NumOutputNodes = -1;
+  int nnClusterizerModelReg2NumOutputNodes = -1;
+  int nnClusterizerDtype = 0; // 0: float16, 1: float32
+  int mISector = -1;
+
+  // Memory allocation for neural network
+  uint class2_elements = 0;
+  float* inputData32 = nullptr;
+  OrtDataType::Float16_t* inputData16 = nullptr;
+  float* outputDataClass = nullptr;
+  float* modelProbabilities = nullptr;
+  float* outputDataReg1 = nullptr;
+  float* outputDataReg2 = nullptr;
+
+  ChargePos* peakPositions = nullptr;
+  bool* clusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptrx
+  float* centralCharges = nullptr;
+  int16_t mMemoryId = -1;
+}; // class GPUTPCNNClusterizer
+
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
new file mode 100644
index 0000000000000..5002c63524020
--- /dev/null
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -0,0 +1,65 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUTPCNNClusterizerHost.cxx
+/// \author Christian Sonnabend
+
+#include "GPUTPCNNClusterizerHost.h"
+#include "GPUTPCNNClusterizer.h"
+#include "GPUSettings.h"
+#include "ML/3rdparty/GPUORTFloat16.h"
+
+using namespace o2::gpu;
+
+GPUTPCNNClusterizerHost::GPUTPCNNClusterizerHost(const GPUSettingsProcessingNNclusterizer& settings, GPUTPCNNClusterizer& clusterer)
+{
+  OrtOptions = {
+    {"model-path", settings.nnClassificationPath},
+    {"device", settings.nnInferenceDevice},
+    {"device-id", std::to_string(settings.nnInferenceDeviceId)},
+    {"allocate-device-memory", std::to_string(settings.nnInferenceAllocateDevMem)},
+    {"dtype", settings.nnInferenceDtype},
+    {"intra-op-num-threads", std::to_string(settings.nnInferenceIntraOpNumThreads)},
+    {"inter-op-num-threads", std::to_string(settings.nnInferenceInterOpNumThreads)},
+    {"enable-optimizations", std::to_string(settings.nnInferenceEnableOrtOptimization)},
+    {"enable-profiling", std::to_string(settings.nnInferenceOrtProfiling)},
+    {"profiling-output-path", settings.nnInferenceOrtProfilingPath},
+    {"logging-level", std::to_string(settings.nnInferenceVerbosity)}};
+
+  model_class.init(OrtOptions);
+  clusterer.nnClusterizerModelClassNumOutputNodes = model_class.getNumOutputNodes()[0][1];
+
+  reg_model_paths = splitString(settings.nnRegressionPath, ":");
+
+  if (!settings.nnClusterizerUseCfRegression) {
+    if (model_class.getNumOutputNodes()[0][1] == 1 || reg_model_paths.size() == 1) {
+      OrtOptions["model-path"] = reg_model_paths[0];
+      model_reg_1.init(OrtOptions);
+      clusterer.nnClusterizerModelReg1NumOutputNodes = model_reg_1.getNumOutputNodes()[0][1];
+    } else {
+      OrtOptions["model-path"] = reg_model_paths[0];
+      model_reg_1.init(OrtOptions);
+      clusterer.nnClusterizerModelReg1NumOutputNodes = model_reg_1.getNumOutputNodes()[0][1];
+      OrtOptions["model-path"] = reg_model_paths[1];
+      model_reg_2.init(OrtOptions);
+      clusterer.nnClusterizerModelReg2NumOutputNodes = model_reg_2.getNumOutputNodes()[0][1];
+    }
+  }
+}
+
+void GPUTPCNNClusterizerHost::networkInference(o2::ml::OrtModel model, GPUTPCNNClusterizer& clusterer, size_t size, float* output, int32_t dtype)
+{
+  if (dtype == 0) {
+    model.inference<OrtDataType::Float16_t, float>(clusterer.inputData16, size * clusterer.nnClusterizerElementSize, output);
+  } else {
+    model.inference<float, float>(clusterer.inputData32, size * clusterer.nnClusterizerElementSize, output);
+  }
+}
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
new file mode 100644
index 0000000000000..7efa0edecb893
--- /dev/null
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
@@ -0,0 +1,68 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUTPCNNClusterizerHost.h
+/// \author Christian Sonnabend
+
+#ifndef O2_GPUTPCNNCLUSTERIZERHOST_H
+#define O2_GPUTPCNNCLUSTERIZERHOST_H
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "ML/OrtInterface.h"
+
+using namespace o2::ml;
+
+namespace o2::OrtDataType
+{
+struct Float16_t;
+}
+
+namespace o2::gpu
+{
+
+class GPUTPCNNClusterizer;
+struct GPUSettingsProcessingNNclusterizer;
+
+class GPUTPCNNClusterizerHost
+{
+ public:
+  GPUTPCNNClusterizerHost() = default;
+  GPUTPCNNClusterizerHost(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&);
+
+  void networkInference(o2::ml::OrtModel model, GPUTPCNNClusterizer& clusterer, size_t size, float* output, int32_t dtype);
+
+  std::unordered_map<std::string, std::string> OrtOptions;
+  o2::ml::OrtModel model_class, model_reg_1, model_reg_2; // For splitting clusters
+  std::vector<std::string> reg_model_paths;
+
+ private:
+  // Avoid including CommonUtils/StringUtils.h
+  std::vector<std::string> splitString(const std::string& input, const std::string& delimiter)
+  {
+    std::vector<std::string> tokens;
+    std::size_t pos = 0;
+    std::size_t found;
+
+    while ((found = input.find(delimiter, pos)) != std::string::npos) {
+      tokens.push_back(input.substr(pos, found - pos));
+      pos = found + delimiter.length();
+    }
+    tokens.push_back(input.substr(pos));
+
+    return tokens;
+  }
+}; // class GPUTPCNNClusterizerHost
+
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
new file mode 100644
index 0000000000000..25cd2497fbf62
--- /dev/null
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -0,0 +1,386 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUTPCNNClusterizerKernels.cxx
+/// \author Christian Sonnabend
+
+#include "GPUTPCNNClusterizerKernels.h"
+#include "GPUTPCCFClusterizer.h"
+
+using namespace o2::gpu;
+using namespace o2::gpu::tpccf;
+
+#include "CfConsts.h"
+#include "CfUtils.h"
+#include "ClusterAccumulator.h"
+#include "ML/3rdparty/GPUORTFloat16.h"
+
+#if !defined(GPUCA_GPUCODE)
+#include "GPUHostDataTypes.h"
+#include "MCLabelAccumulator.h"
+#endif
+
+#ifdef GPUCA_GPUCODE
+#include "GPUTPCCFClusterizer.inc"
+#endif
+
+// Defining individual thread functions for data filling, determining the class label and running the CF clusterizer
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::runCfClusterizer>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  uint glo_idx = get_global_id(0);
+  auto& clusterer = processors.tpcClusterer[sector];
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  if (clustererNN.outputDataClass[glo_idx] == 0) { // default clusterizer should not be called in batched mode due to mess-up with thread indices
+    return;
+  }
+  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CPU_ONLY(MCLabelAccumulator labelAcc(clusterer));
+  tpc::ClusterNative* clusterOut = (onlyMC) ? nullptr : clusterer.mPclusterByRow;
+  o2::gpu::GPUTPCCFClusterizer::GPUSharedMemory smem_new;
+  GPUTPCCFClusterizer::computeClustersImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, smem_new, chargeMap, clusterer.mPfilteredPeakPositions, clusterer.Param().rec, CPU_PTR(&labelAcc), clusterer.mPmemory->counters.nClusters, clusterer.mNMaxClusterPerRow, clusterer.mPclusterInRow, clusterOut, clusterer.mPclusterPosInRow);
+}
+
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNN>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  GPUTPCNNClusterizerKernels::fillInputData(nBlocks, nThreads, iBlock, iThread, processors, sector, dtype, batchStart);
+}
+
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass1Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  uint glo_idx = get_global_id(0);
+  processors.tpcNNClusterer[sector].outputDataClass[glo_idx + batchStart] = (int)(processors.tpcNNClusterer[sector].modelProbabilities[glo_idx] > processors.tpcNNClusterer[sector].nnClassThreshold);
+}
+
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass2Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  auto& clusterer = processors.tpcNNClusterer[sector];
+  uint glo_idx = get_global_id(0);
+  uint elem_iterator = glo_idx * clusterer.nnClusterizerModelClassNumOutputNodes;
+  float current_max_prob = 0.f; // If the neural network doesn't contain the softmax as a last layer, the outputs can range in [-infty, infty]
+  uint class_label = 0;
+  for (int pIdx = elem_iterator; pIdx < elem_iterator + clusterer.nnClusterizerModelClassNumOutputNodes; pIdx++) {
+    if (pIdx == elem_iterator) {
+      current_max_prob = clusterer.modelProbabilities[pIdx];
+    } else {
+      class_label = (clusterer.modelProbabilities[pIdx] > current_max_prob ? pIdx : class_label);
+    }
+  }
+  // uint class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clusterer.nnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
+  clusterer.outputDataClass[glo_idx + batchStart] = class_label;
+}
+
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass1Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  uint glo_idx = get_global_id(0);
+  if (glo_idx >= processors.tpcClusterer[sector].mPmemory->counters.nClusters) {
+    return;
+  }
+  GPUTPCNNClusterizerKernels::publishClustersReg1(glo_idx, smem, processors, sector, dtype, onlyMC, batchStart);
+}
+
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass2Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  uint glo_idx = get_global_id(0);
+  if (glo_idx >= processors.tpcClusterer[sector].mPmemory->counters.nClusters) {
+    return;
+  }
+  GPUTPCNNClusterizerKernels::publishClustersReg2(glo_idx, smem, processors, sector, dtype, onlyMC, batchStart);
+}
+
+// THe following arithmetic is done because the network is trained with a split between IROC and OROC boundary
+GPUd() int GPUTPCNNClusterizerKernels::padOffset(int row_ref, int row_current, const GPUTPCGeometry& geo)
+{
+  return (int)((geo.NPads(row_current) - geo.NPads(row_ref)) / 2);
+}
+
+GPUd() int GPUTPCNNClusterizerKernels::rowOffset(int row, int global_shift)
+{
+  return (row > 62 ? global_shift : 0);
+}
+
+GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int row, int pad, int global_shift, const GPUTPCGeometry& geo)
+{
+  if (pad < 0 || row < 0) { // Faster short-circuit
+    return true;
+  } else if (row < 63) {
+    return (pad >= static_cast<int>(geo.NPads(row)));
+  } else if (row < (63 + global_shift)) { // to account for the gap between IROC and OROC. Charge will be set to -1 in order to signal boundary to the neural network
+    return true;
+  } else if (row < (o2::tpc::constants::MAXGLOBALPADROW + global_shift)) {
+    return (pad >= static_cast<int>(geo.NPads(row - global_shift)));
+  } else {
+    return true;
+  }
+}
+
+// Filling the input data for the neural network where there is no boundary
+GPUd() void GPUTPCNNClusterizerKernels::fillInputData(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, processorType& processors, uint8_t sector, int8_t dtype, uint batchStart)
+{
+  uint glo_idx = get_global_id(0);
+  auto& clusterer = processors.tpcClusterer[sector];
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+
+  uint write_idx = glo_idx * clustererNN.nnClusterizerElementSize; // Potential optimization: Either choose nnClusterizerBatchedMode as a power of 2 or calculate from threadId and blockId
+
+  ChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
+  int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad()), time = static_cast<int>(peak.time()); // Explicit casting to avoid conversion errors
+  float central_charge = static_cast<float>(chargeMap[peak].unpack());
+
+  clustererNN.peakPositions[glo_idx] = peak;
+  clustererNN.centralCharges[glo_idx] = central_charge;
+  clustererNN.outputDataClass[glo_idx + batchStart] = -1;
+
+  int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.nnClusterizerSizeInputRow);
+#ifndef GPUCA_GPUCODE
+  GPUCA_UNROLL(U(), U());
+#endif
+  for (int r = -clustererNN.nnClusterizerSizeInputRow; r <= clustererNN.nnClusterizerSizeInputRow; r++) {
+    bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
+    int pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, row + r, clusterer.Param().tpcGeometry);
+    for (int p = -clustererNN.nnClusterizerSizeInputPad + pad_offset; p <= clustererNN.nnClusterizerSizeInputPad + pad_offset; p++) {
+      bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.nnClusterizerSizeInputRow, clusterer.Param().tpcGeometry);
+      for (int t = -clustererNN.nnClusterizerSizeInputTime; t <= clustererNN.nnClusterizerSizeInputTime; t++) {
+        if (!is_boundary) {
+          ChargePos tmp_pos(row + r, pad + p, time + t);
+          if (r == 0 && !clustererNN.clusterFlags[2 * glo_idx] && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) { // ordering is done for short circuit optimization
+            clustererNN.clusterFlags[2 * glo_idx] = CfUtils::isPeak(isPeakMap[tmp_pos]);
+            clustererNN.clusterFlags[2 * glo_idx + 1] = clustererNN.clusterFlags[2 * glo_idx];
+          }
+          if (dtype == 0) {
+            clustererNN.inputData16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
+          } else {
+            clustererNN.inputData32[write_idx] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+          }
+        } else {
+          // Filling boundary just to make sure that no values are left unintentionally
+          if (dtype == 0) {
+            clustererNN.inputData16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue));
+          } else {
+            clustererNN.inputData32[write_idx] = static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue);
+          }
+        }
+        write_idx++;
+      }
+    }
+  }
+  if (clustererNN.nnClusterizerAddIndexData) {
+    if (dtype == 0) {
+      clustererNN.inputData16[write_idx] = (OrtDataType::Float16_t)(clusterer.mISector / 36.f);
+      clustererNN.inputData16[write_idx + 1] = (OrtDataType::Float16_t)(row / 152.f);
+      clustererNN.inputData16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / clusterer.Param().tpcGeometry.NPads(row));
+    } else {
+      clustererNN.inputData32[write_idx] = clusterer.mISector / 36.f;
+      clustererNN.inputData32[write_idx + 1] = row / 152.f;
+      clustererNN.inputData32[write_idx + 2] = static_cast<float>(pad) / clusterer.Param().tpcGeometry.NPads(row);
+    }
+  }
+}
+
+GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg1(uint glo_idx, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  auto& clusterer = processors.tpcClusterer[sector];
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
+  MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
+  tpc::ClusterNative* clusterOut = (onlyMC) ? nullptr : clusterer.mPclusterByRow;
+  uint full_glo_idx = glo_idx + batchStart;
+  int model_output_index = glo_idx * clustererNN.nnClusterizerModelReg1NumOutputNodes;
+
+  // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.nnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
+
+  if (clustererNN.outputDataClass[full_glo_idx] == 1) {
+
+    ClusterAccumulator pc;
+
+    // Publishing logic is taken from default clusterizer
+    if (onlyMC) {
+      ClusterAccumulator dummy_pc;
+      CPU_ONLY(labelAcc->collect(clustererNN.peakPositions[glo_idx], chargeMap[clustererNN.peakPositions[glo_idx]].unpack()));
+      GPUTPCCFClusterizer::buildCluster(
+        clusterer.Param().rec,
+        chargeMap,
+        clustererNN.peakPositions[glo_idx],
+        smem.posBcast,
+        smem.buf,
+        smem.innerAboveThreshold,
+        &dummy_pc,
+        labelAcc);
+    }
+
+    if ((clusterer.mPmemory->fragment).isOverlap(clustererNN.peakPositions[glo_idx].time())) {
+      if (clusterer.mPclusterPosInRow) {
+        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
+      }
+      return;
+    }
+
+    pc.setFull(clustererNN.centralCharges[glo_idx] * clustererNN.outputDataReg1[model_output_index + 4],
+               static_cast<float>(clustererNN.peakPositions[glo_idx].pad()) + clustererNN.outputDataReg1[model_output_index],
+               clustererNN.outputDataReg1[model_output_index + 2],
+               (clusterer.mPmemory->fragment).start + static_cast<float>(clustererNN.peakPositions[glo_idx].time()) + clustererNN.outputDataReg1[model_output_index + 1],
+               clustererNN.outputDataReg1[model_output_index + 3],
+               clustererNN.clusterFlags[2 * glo_idx],
+               clustererNN.clusterFlags[2 * glo_idx + 1]);
+
+    tpc::ClusterNative myCluster;
+    bool rejectCluster = !pc.toNative(clustererNN.peakPositions[glo_idx], clustererNN.centralCharges[glo_idx], myCluster, clusterer.Param(), chargeMap);
+    if (rejectCluster) {
+      if (clusterer.mPclusterPosInRow) {
+        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
+      }
+      return;
+    }
+
+    uint rowIndex = 0;
+    if (clusterer.mPclusterByRow != nullptr) {
+      rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
+        clusterer,
+        myCluster,
+        clustererNN.peakPositions[glo_idx].row(),
+        clusterer.mNMaxClusterPerRow,
+        clusterer.mPclusterInRow,
+        clusterOut);
+      if (clusterer.mPclusterPosInRow != nullptr) {
+        clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
+      }
+    } else if (clusterer.mPclusterPosInRow) {
+      rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
+    }
+    CPU_ONLY(labelAcc->commit(clustererNN.peakPositions[glo_idx].row(), rowIndex, clusterer.mNMaxClusterPerRow));
+  } else {
+    if (clusterer.mPclusterPosInRow) {
+      clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
+    }
+    return;
+  }
+}
+
+GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg2(uint glo_idx, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  auto& clusterer = processors.tpcClusterer[sector];
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
+  MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
+  tpc::ClusterNative* clusterOut = (onlyMC) ? nullptr : clusterer.mPclusterByRow;
+  uint full_glo_idx = glo_idx + batchStart;
+  int model_output_index = glo_idx * clustererNN.nnClusterizerModelReg2NumOutputNodes;
+
+  // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.nnClusterizerModelReg2NumOutputNodes << " -- " << clustererNN.peakPositions.size() << " -- " << clustererNN.centralCharges.size();
+
+  if (clustererNN.outputDataClass[full_glo_idx] > 0) {
+
+    ClusterAccumulator pc;
+
+    if (onlyMC) {
+      ClusterAccumulator dummy_pc;
+      CPU_ONLY(labelAcc->collect(clustererNN.peakPositions[glo_idx], chargeMap[clustererNN.peakPositions[glo_idx]].unpack()));
+      GPUTPCCFClusterizer::buildCluster(
+        clusterer.Param().rec,
+        chargeMap,
+        clustererNN.peakPositions[glo_idx],
+        smem.posBcast,
+        smem.buf,
+        smem.innerAboveThreshold,
+        &dummy_pc,
+        labelAcc);
+    }
+
+    if ((clusterer.mPmemory->fragment).isOverlap(clustererNN.peakPositions[glo_idx].time())) {
+      if (clusterer.mPclusterPosInRow) {
+        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
+      }
+      return;
+    }
+
+    // Cluster 1
+    pc.setFull(clustererNN.centralCharges[glo_idx] * clustererNN.outputDataReg2[model_output_index + 8],
+               static_cast<float>(clustererNN.peakPositions[glo_idx].pad()) + clustererNN.outputDataReg2[model_output_index],
+               clustererNN.outputDataReg2[model_output_index + 4],
+               (clusterer.mPmemory->fragment).start + static_cast<float>(clustererNN.peakPositions[glo_idx].time()) + clustererNN.outputDataReg2[model_output_index + 2],
+               clustererNN.outputDataReg2[model_output_index + 6],
+               clustererNN.clusterFlags[2 * glo_idx],
+               clustererNN.clusterFlags[2 * glo_idx + 1]);
+
+    tpc::ClusterNative myCluster;
+    bool rejectCluster = !pc.toNative(clustererNN.peakPositions[glo_idx], clustererNN.centralCharges[glo_idx], myCluster, clusterer.Param(), chargeMap);
+    if (rejectCluster) {
+      if (clusterer.mPclusterPosInRow) {
+        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
+      }
+      return;
+    }
+
+    uint rowIndex = 0;
+    if (clusterer.mPclusterByRow != nullptr) {
+      rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
+        clusterer,
+        myCluster,
+        clustererNN.peakPositions[glo_idx].row(),
+        clusterer.mNMaxClusterPerRow,
+        clusterer.mPclusterInRow,
+        clusterOut);
+      if (clusterer.mPclusterPosInRow != nullptr) {
+        clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
+      }
+    } else if (clusterer.mPclusterPosInRow) {
+      rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
+    }
+    CPU_ONLY(labelAcc->commit(clustererNN.peakPositions[glo_idx].row(), rowIndex, clusterer.mNMaxClusterPerRow));
+
+    // Cluster 2
+    pc.setFull(clustererNN.centralCharges[glo_idx] * clustererNN.outputDataReg2[model_output_index + 9],
+               static_cast<float>(clustererNN.peakPositions[glo_idx].pad()) + clustererNN.outputDataReg2[model_output_index + 1],
+               clustererNN.outputDataReg2[model_output_index + 5],
+               (clusterer.mPmemory->fragment).start + static_cast<float>(clustererNN.peakPositions[glo_idx].time()) + clustererNN.outputDataReg2[model_output_index + 3],
+               clustererNN.outputDataReg2[model_output_index + 7],
+               clustererNN.clusterFlags[2 * glo_idx],
+               clustererNN.clusterFlags[2 * glo_idx + 1]);
+
+    rejectCluster = !pc.toNative(clustererNN.peakPositions[glo_idx], clustererNN.centralCharges[glo_idx], myCluster, clusterer.Param(), chargeMap);
+    if (rejectCluster) {
+      if (clusterer.mPclusterPosInRow) {
+        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
+      }
+      return;
+    }
+
+    if (clusterer.mPclusterByRow != nullptr) {
+      rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
+        clusterer,
+        myCluster,
+        clustererNN.peakPositions[glo_idx].row(),
+        clusterer.mNMaxClusterPerRow,
+        clusterer.mPclusterInRow,
+        clusterOut);
+      if (clusterer.mPclusterPosInRow != nullptr) {
+        clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
+      }
+    } else if (clusterer.mPclusterPosInRow) {
+      rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
+    }
+    // CPU_ONLY(labelAcc->commit(clustererNN.peakPositions[glo_idx].row(), rowIndex, clusterer.mNMaxClusterPerRow)); // -> Is this needed? How to handle MC labels for split clusters?
+  } else {
+    if (clusterer.mPclusterPosInRow) {
+      clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
+    }
+    return;
+  }
+}
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
new file mode 100644
index 0000000000000..c7bd18115d61f
--- /dev/null
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -0,0 +1,77 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUTPCNNClusterizerKernels.h
+/// \author Christian Sonnabend
+
+#ifndef O2_GPU_NN_CLUSTERIZER_H
+#define O2_GPU_NN_CLUSTERIZER_H
+
+#include "clusterFinderDefs.h"
+#include "GPUGeneralKernels.h"
+#include "GPUConstantMem.h"
+#include "GPUTPCClusterFinder.h"
+#include "Array2D.h"
+#include "PackedCharge.h"
+#include "GPUTPCNNClusterizer.h"
+
+namespace o2::tpc
+{
+struct ClusterNative;
+} // namespace o2::tpc
+
+namespace o2::gpu
+{
+
+class ClusterAccumulator;
+class MCLabelAccumulator;
+
+class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
+{
+ public:
+  static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels);
+  struct GPUSharedMemory {
+    // Regular cluster finder
+    ChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
+    PackedCharge buf[SCRATCH_PAD_WORK_GROUP_SIZE * SCRATCH_PAD_BUILD_N];
+    uint8_t innerAboveThreshold[SCRATCH_PAD_WORK_GROUP_SIZE];
+  };
+
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  {
+    return GPUDataTypes::RecoStep::TPCClusterFinding;
+  }
+
+  enum K : int32_t {
+    runCfClusterizer = 0,
+    fillInputNN = 1,
+    determineClass1Labels = 2,
+    determineClass2Labels = 3,
+    publishClass1Regression = 4,
+    publishClass2Regression = 5,
+  };
+
+  template <int32_t iKernel = defaultKernel, typename... Args>
+  GPUd() static void Thread(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, processorType&, uint8_t = 0, int8_t = 0, int8_t = 0, uint = 0, Args...);
+
+ private:
+  static GPUd() void fillInputData(int32_t, int32_t, int32_t, int32_t, processorType&, uint8_t, int8_t, uint);
+  static GPUd() void publishClustersReg1(uint, GPUSharedMemory&, processorType&, uint8_t, int8_t, int8_t, uint);
+  static GPUd() void publishClustersReg2(uint, GPUSharedMemory&, processorType&, uint8_t, int8_t, int8_t, uint);
+
+  static GPUd() int padOffset(int, int, const GPUTPCGeometry&);
+  static GPUd() int rowOffset(int, int);
+  static GPUd() bool isBoundary(int, int, int, const GPUTPCGeometry&);
+};
+
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 4b7aab75519fa..ad348a84264f0 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -24,6 +24,9 @@ o2_gpu_kernel_file_list(O2PROPAGATOR TrackParametrization.cxx TrackParametrizati
 o2_gpu_kernel_file_list(TPCCOMPRESSION GPUTPCCompressionTrackModel.cxx)
 o2_gpu_kernel_file_list(TPCDECOMPRESSION GPUTPCCompressionTrackModel.cxx ERRORS)
 o2_gpu_kernel_file_list(TPCCLUSTERFINDER ERRORS ClusterAccumulator.cxx)
+if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
+o2_gpu_kernel_file_list(TPCNNCLUSTERFINDER ERRORS ClusterAccumulator.cxx GPUTPCNNClusterizerKernels.cxx)
+endif()
 o2_gpu_kernel_file_list(TRDTRACKER GPUTRDTrack.cxx GPUTRDTracker.cxx GPUTRDTrackletWord.cxx GeometryBase.cxx)
 o2_gpu_kernel_file_list(GLOBALREFIT TPCMERGER O2PROPAGATOR MATLUT GPUTrackingRefit.cxx)
 
@@ -111,7 +114,15 @@ o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, noiseSuppression"        "= TPCCLUS
 o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, updatePeaks"             "= TPCCLUSTERFINDER"                                    LB)
 o2_gpu_add_kernel("GPUTPCCFDeconvolution"                             "= TPCCLUSTERFINDER"                                    LB)
 o2_gpu_add_kernel("GPUTPCCFClusterizer"                               "= TPCCLUSTERFINDER"                                    LB int8_t onlyMC)
-o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, setRowOffsets"           "= TPCCLUSTERFINDER")
+if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, runCfClusterizer"        "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNN"             "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass1Labels"   "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass2Labels"   "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass1Regression" "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass2Regression" "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+endif()
+o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, setRowOffsets" "= TPCCLUSTERFINDER")
 o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, flatten"                 "= TPCCLUSTERFINDER"                                    NO GPUTPCLinearLabels* out)
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanStart"               "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage)
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanUp"                  "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)

From 911f7dce4f1a36bf7031959822253ccb39f4b02a Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 15 Mar 2025 19:35:20 +0100
Subject: [PATCH 0065/1764] DPL: account for IO time correctly (#14064)

---
 .../AnalysisSupport/src/DataInputDirector.cxx | 56 +++++++++++++------
 1 file changed, 40 insertions(+), 16 deletions(-)

diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index 2c51360cd9923..cfb5ca34b062b 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -387,18 +387,53 @@ int DataInputDescriptor::findDFNumber(int file, std::string dfName)
   return it - dfList.begin();
 }
 
+struct CalculateDelta {
+  CalculateDelta(uint64_t& target)
+    : mTarget(target)
+  {
+    start = uv_hrtime();
+  }
+  ~CalculateDelta()
+  {
+    if (!active) {
+      return;
+    }
+    O2_SIGNPOST_ACTION(reader_memory_dump, [](void*) {
+      void (*dump_)(const char*);
+      if (void* sym = dlsym(nullptr, "igprof_dump_now")) {
+        dump_ = __extension__(void (*)(const char*)) sym;
+        if (dump_) {
+          std::string filename = fmt::format("reader-memory-dump-{}.gz", uv_hrtime());
+          dump_(filename.c_str());
+        }
+      }
+    });
+    mTarget += (uv_hrtime() - start);
+  }
+
+  void deactivate() {
+    active = false;
+  }
+
+  bool active = true;
+  uint64_t& mTarget;
+  uint64_t start;
+  uint64_t stop;
+};
+
 bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh, int counter, int numTF, std::string treename, size_t& totalSizeCompressed, size_t& totalSizeUncompressed)
 {
-  auto ioStart = uv_hrtime();
-
+  CalculateDelta t(mIOTime);
   auto folder = getFileFolder(counter, numTF);
   if (!folder.filesystem()) {
+    t.deactivate();
     return false;
   }
 
   auto rootFS = std::dynamic_pointer_cast<TFileFileSystem>(folder.filesystem());
 
   if (!rootFS) {
+    t.deactivate();
     throw std::runtime_error(fmt::format(R"(Not a TFile filesystem!)"));
   }
   // FIXME: Ugly. We should detect the format from the treename, good enough for now.
@@ -420,6 +455,7 @@ bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh
   // FIXME: we should distinguish between an actually missing object and one which has a non compatible
   // format.
   if (!format) {
+    t.deactivate();
     LOGP(debug, "Could not find tree {}. Trying in parent file.", fullpath.path());
     auto parentFile = getParentFile(counter, numTF, treename);
     if (parentFile != nullptr) {
@@ -460,19 +496,6 @@ bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh
   f2b->setLabel(treename.c_str());
   f2b->fill(datasetSchema, format);
 
-  mIOTime += (uv_hrtime() - ioStart);
-
-  O2_SIGNPOST_ACTION(reader_memory_dump, [](void*) {
-    void (*dump_)(const char*);
-    if (void* sym = dlsym(nullptr, "igprof_dump_now")) {
-      dump_ = __extension__(void (*)(const char*)) sym;
-      if (dump_) {
-        std::string filename = fmt::format("reader-memory-dump-{}.gz", uv_hrtime());
-        dump_(filename.c_str());
-      }
-    }
-  });
-
   return true;
 }
 
@@ -820,7 +843,8 @@ bool DataInputDirector::readTree(DataAllocator& outputs, header::DataHeader dh,
     treename = aod::datamodel::getTreeName(dh);
   }
 
-  return didesc->readTree(outputs, dh, counter, numTF, treename, totalSizeCompressed, totalSizeUncompressed);
+  auto result = didesc->readTree(outputs, dh, counter, numTF, treename, totalSizeCompressed, totalSizeUncompressed);
+  return result;
 }
 
 void DataInputDirector::closeInputFiles()

From 360be36ab9c948f133b745fbde7e6a822b47e8df Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 15 Mar 2025 20:03:50 +0100
Subject: [PATCH 0066/1764] GPU TPC CF: Add option to select 1pad or 2pad edge
 flag definition (#14067)

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 .../TPCClusterFinder/ClusterAccumulator.cxx   | 19 ++++++++++++-------
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 63fcf51004eae..b7f761c73ffc0 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -128,6 +128,7 @@ AddOptionRTC(cfInnerThreshold, uint8_t, 0, "", 0, "Cluster Finder extends cluste
 AddOptionRTC(cfMinSplitNum, uint8_t, 1, "", 0, "Minimum number of split charges in a cluster for the cluster to be marked as split")
 AddOptionRTC(cfNoiseSuppressionEpsilon, uint8_t, 10, "", 0, "Cluster Finder: Difference between peak and charge for the charge to count as a minima during noise suppression")
 AddOptionRTC(cfNoiseSuppressionEpsilonRelative, uint8_t, 76, "", 0, "Cluster Finder: Difference between peak and charge for the charge to count as a minima during noise suppression, relative as fraction of 255")
+AddOptionRTC(cfEdgeTwoPads, uint8_t, 1, "", 0, "Flag clusters with peak on the 2 pads closes to the sector edge as edge cluster")
 AddOptionRTC(nWays, uint8_t, 3, "", 0, "Do N fit passes in final fit of merger")
 AddOptionRTC(nWaysOuter, int8_t, 0, "", 0, "Store outer param")
 AddOptionRTC(trackFitRejectMode, int8_t, 5, "", 0, "0: no limit on rejection or missed hits, >0: break after n rejected hits, <0: reject at max -n hits")
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
index b6792ce3a9ef5..b3b3c64095017 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
@@ -79,14 +79,19 @@ GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, const Charge q, t
 {
   Pad pad = pos.pad();
 
-  bool isEdgeCluster = pad < 2 || pad >= param.tpcGeometry.NPads(pos.row()) - 2; // Geometrical edge check, peak within 2 pads of sector edge
-  if (isEdgeCluster) {
-    bool leftEdge = (pad < 2);
-    if (leftEdge ? (pad == 1 && chargeMap[pos.delta({-1, 0})].unpack() < 1) : (pad == (param.tpcGeometry.NPads(pos.row()) - 2) && chargeMap[pos.delta({1, 0})].unpack() < 1)) {
-      isEdgeCluster = false; // No edge cluster if peak is close to edge but no charge at the edge.
-    } else if (leftEdge ? (pad < mPadMean) : (pad > mPadMean)) {
-      mPadMean = pad; // Correct to peak position if COG is close to middle of pad than peak
+  bool isEdgeCluster;
+  if (param.rec.tpc.cfEdgeTwoPads) {
+    isEdgeCluster = pad < 2 || pad >= param.tpcGeometry.NPads(pos.row()) - 2; // Geometrical edge check, peak within 2 pads of sector edge
+    if (isEdgeCluster) {
+      bool leftEdge = (pad < 2);
+      if (leftEdge ? (pad == 1 && chargeMap[pos.delta({-1, 0})].unpack() < 1) : (pad == (param.tpcGeometry.NPads(pos.row()) - 2) && chargeMap[pos.delta({1, 0})].unpack() < 1)) {
+        isEdgeCluster = false; // No edge cluster if peak is close to edge but no charge at the edge.
+      } else if (leftEdge ? (pad < mPadMean) : (pad > mPadMean)) {
+        mPadMean = pad; // Correct to peak position if COG is close to middle of pad than peak
+      }
     }
+  } else {
+    isEdgeCluster = pad == 0 || pad == param.tpcGeometry.NPads(pos.row()) - 1;
   }
 
   cn.qTot = CAMath::Float2UIntRn(mQtot);

From b0776cad0fb5c1598bbe80628ff3b2ae492dc2aa Mon Sep 17 00:00:00 2001
From: pillot <pillot@subatech.in2p3.fr>
Date: Sat, 15 Mar 2025 20:11:06 +0100
Subject: [PATCH 0067/1764] [MCH] optional setting of CCDB file time window
 (#14059)

---
 Detectors/MUON/MCH/Conditions/README.md       |  2 +
 .../MCH/Conditions/src/scan-hvlv-ccdb.cxx     | 54 +++++++++++--------
 2 files changed, 34 insertions(+), 22 deletions(-)

diff --git a/Detectors/MUON/MCH/Conditions/README.md b/Detectors/MUON/MCH/Conditions/README.md
index d35fdcd0a0958..21892a7478d86 100644
--- a/Detectors/MUON/MCH/Conditions/README.md
+++ b/Detectors/MUON/MCH/Conditions/README.md
@@ -73,6 +73,8 @@ Usage:
                                    change HV thresholds
   -d [ --duration ] arg (=0)       minimum duration (ms) of HV/LV issues to
                                    consider
+  -i [ --interval ] arg (=30)      creation time interval (minutes) between
+                                   CCDB files
   -w [ --warning ] arg (=1)        warning level (0, 1 or 2)
   -p [ --print ] arg (=1)          print level (0, 1, 2 or 3)
   -o [ --output ] arg (=scan.root) output root file name
diff --git a/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx b/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
index 32cd365916c63..307759c97a0c3 100644
--- a/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
+++ b/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
@@ -153,6 +153,20 @@ std::string getTime(uint64_t ts)
   return time;
 }
 
+//----------------------------------------------------------------------------
+std::string getDuration(uint64_t tStart, uint64_t tStop)
+{
+  /// get the duration (dd hh:mm:ss) between the two time stamps (ms)
+
+  auto dt = ms2s(tStop - tStart);
+  auto s = dt % 60;
+  auto m = (dt / 60) % 60;
+  auto h = (dt / 3600) % 24;
+  auto d = dt / 86400;
+
+  return fmt::format("{:02}d {:02}:{:02}:{:02}", d, h, m, s);
+}
+
 //----------------------------------------------------------------------------
 std::set<int> getRuns(std::string runList)
 {
@@ -283,15 +297,17 @@ void drawRunBoudaries(const RBMAP& runBoundaries, TCanvas* c)
 }
 
 //----------------------------------------------------------------------------
-DPBMAP getDPBoundaries(ccdb::CcdbApi const& api, std::string what, uint64_t tStart, uint64_t tStop)
+DPBMAP getDPBoundaries(ccdb::CcdbApi const& api, std::string what,
+                       uint64_t tStart, uint64_t tStop, uint64_t timeInterval)
 {
   /// get the time boundaries of every HV/LV files found in the time range
 
-  // add extra margin (ms) of ± 1 min to the creation time, which occurs every 30 min
-  static const uint64_t timeMarging[2] = {60000, 1860000};
+  // add an extra margin (ms) of ± 1 min to the creation time,
+  // which corresponds to the end of the time interval covered by the file
+  static const uint64_t timeMarging = 60000;
 
   std::istringstream fileInfo(api.list(what.c_str(), false, "text/plain",
-                                       tStop + timeMarging[1], tStart - timeMarging[0]));
+                                       tStop + timeInterval + timeMarging, tStart - timeMarging));
 
   DPBMAP dpBoundaries{};
   std::string dummy{};
@@ -357,7 +373,7 @@ void checkDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV, uint64_t tStart,
 }
 
 //----------------------------------------------------------------------------
-void printDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV)
+void printDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV, uint64_t timeInterval)
 {
   /// print the time boundaries of every HV/LV files found in the full time range
 
@@ -365,7 +381,13 @@ void printDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV)
   printf("------------------------------------\n");
 
   for (auto [tStart, tStop] : dpBoundaries) {
-    printf("%llu - %llu (%s - %s)\n", tStart, tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
+    printf("%llu - %llu (%s - %s)", tStart, tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
+    if (tStop - tStart < 60000 * (timeInterval - 1) || tStop - tStart > 60000 * (timeInterval + 1)) {
+      printf("\e[0;31m ! warning: validity range %s != %llu±1 min\e[0m\n",
+             getDuration(tStart, tStop).c_str(), timeInterval);
+    } else {
+      printf("\n");
+    }
   }
 
   printf("------------------------------------\n");
@@ -400,20 +422,6 @@ void drawLimit(double limit, TCanvas* c)
   l->Draw();
 }
 
-//----------------------------------------------------------------------------
-std::string getDuration(uint64_t tStart, uint64_t tStop)
-{
-  /// get the duration (dd hh:mm:ss) between the two time stamps (ms)
-
-  auto dt = ms2s(tStop - tStart);
-  auto s = dt % 60;
-  auto m = (dt / 60) % 60;
-  auto h = (dt / 3600) % 24;
-  auto d = dt / 86400;
-
-  return fmt::format("{:02}d {:02}:{:02}:{:02}", d, h, m, s);
-}
-
 //----------------------------------------------------------------------------
 double getValue(DPVAL dp)
 {
@@ -943,6 +951,7 @@ int main(int argc, char** argv)
   std::string what = "";
   std::string config = "";
   uint64_t minDuration = 0;
+  uint64_t timeInterval = 30;
   int warningLevel = 1;
   int printLevel = 1;
   std::string outFileName = "";
@@ -955,6 +964,7 @@ int main(int argc, char** argv)
       ("channels,c",po::value<std::string>(&what)->default_value(""),R"(channel(s) to scan ("HV" or "LV" or comma separated list of (part of) DCS aliases))")
       ("configKeyValues",po::value<std::string>(&config)->default_value(""),"Semicolon separated key=value strings to change HV thresholds")
       ("duration,d",po::value<uint64_t>(&minDuration)->default_value(0),"minimum duration (ms) of HV/LV issues to consider")
+      ("interval,i",po::value<uint64_t>(&timeInterval)->default_value(30),"creation time interval (minutes) between CCDB files")
       ("warning,w",po::value<int>(&warningLevel)->default_value(1),"warning level (0, 1 or 2)")
       ("print,p",po::value<int>(&printLevel)->default_value(1),"print level (0, 1, 2 or 3)")
       ("output,o",po::value<std::string>(&outFileName)->default_value("scan.root"),"output root file name")
@@ -1021,9 +1031,9 @@ int main(int argc, char** argv)
 
   // extract the time boundaries for each HV/LV file in the full time range
   auto dpBoundaries = getDPBoundaries(api, path.c_str(), runBoundaries.begin()->second.first,
-                                      runBoundaries.rbegin()->second.second);
+                                      runBoundaries.rbegin()->second.second, timeInterval * 60000);
   if (printLevel > 0) {
-    printDPBoundaries(dpBoundaries, scanHV);
+    printDPBoundaries(dpBoundaries, scanHV, timeInterval);
   }
   checkDPBoundaries(dpBoundaries, scanHV, runBoundaries.begin()->second.first,
                     runBoundaries.rbegin()->second.second);

From 4de0c6c5b3c7a259c182c62666cf8f211277d009 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 13 Mar 2025 18:12:30 +0100
Subject: [PATCH 0068/1764] GPU: Provide general GPUFailedMsg functionality
 also externally

---
 GPU/Common/CMakeLists.txt                     |  1 +
 GPU/Common/GPUCommonChkErr.h                  | 21 +++++++++++++++++++
 GPU/Common/GPUCommonDefAPI.h                  |  2 +-
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 15 +++++++++++++
 GPU/GPUTracking/Base/GPUReconstruction.h      |  3 +++
 .../Base/GPUReconstructionDeviceBase.cxx      |  6 +++++-
 .../Base/GPUReconstructionDeviceBase.h        |  1 +
 .../Base/cuda/GPUReconstructionCUDA.cu        | 16 ++------------
 .../Base/cuda/GPUReconstructionCUDA.h         |  4 ++--
 .../GPUReconstructionCUDAExternalProvider.cu  |  2 +-
 .../cuda/GPUReconstructionCUDAInternals.h     |  4 +---
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  4 +++-
 .../Base/opencl/GPUReconstructionOCL.cxx      | 17 +++------------
 .../Base/opencl/GPUReconstructionOCL.h        |  3 +--
 .../opencl/GPUReconstructionOCLIncludesHost.h |  4 +---
 15 files changed, 61 insertions(+), 42 deletions(-)
 create mode 100644 GPU/Common/GPUCommonChkErr.h

diff --git a/GPU/Common/CMakeLists.txt b/GPU/Common/CMakeLists.txt
index 8466035d74ef7..8b0a75679479f 100644
--- a/GPU/Common/CMakeLists.txt
+++ b/GPU/Common/CMakeLists.txt
@@ -15,6 +15,7 @@ set(HDRS_INSTALL
     GPUCommonAlgorithm.h
     GPUCommonDef.h
     GPUCommonDefAPI.h
+    GPUCommonChkErr.h
     GPUCommonDefSettings.h
     GPUCommonConstants.h
     GPUCommonLogger.h
diff --git a/GPU/Common/GPUCommonChkErr.h b/GPU/Common/GPUCommonChkErr.h
new file mode 100644
index 0000000000000..df007b31dab64
--- /dev/null
+++ b/GPU/Common/GPUCommonChkErr.h
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUCommonChkErr.h
+/// \author David Rohr
+
+#ifndef GPUCOMMONCHKERR_H
+#define GPUCOMMONCHKERR_H
+
+#define GPUFailedMsg(x) GPUFailedMsgA(x, __FILE__, __LINE__, true)
+#define GPUFailedMsgI(x) GPUFailedMsgA(x, __FILE__, __LINE__, false)
+
+#endif
diff --git a/GPU/Common/GPUCommonDefAPI.h b/GPU/Common/GPUCommonDefAPI.h
index 0cd3c4ebddb7f..f7efbf7e976d4 100644
--- a/GPU/Common/GPUCommonDefAPI.h
+++ b/GPU/Common/GPUCommonDefAPI.h
@@ -36,7 +36,7 @@
   #define GPUdni()                                  // Device function, not-to-be-inlined
   #define GPUdnii() inline                          // Device function, not-to-be-inlined on device, inlined on host
   #define GPUh()                                    // Host-only function
-  // NOTE: All GPUd*() functions are also compiled on the host during GCC compilation.
+  // NOTE: All GPUd*() functions are also compiled on the host during host compilation.
   // The GPUh*() macros are for the rare cases of functions that you want to compile for the host during GPU compilation.
   // Usually, you do not need the GPUh*() versions. If in doubt, use GPUd*()!
   #define GPUhi() inline                            // to-be-inlined host-only function
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index df9a7380834ce..28241cb7aeec5 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -1078,6 +1078,21 @@ int32_t GPUReconstruction::CheckErrorCodes(bool cpuOnly, bool forceShowErrors, s
   return retVal;
 }
 
+int32_t GPUReconstruction::GPUFailedMsgA(const int64_t error, const char* file, int32_t line, bool failOnError)
+{
+  if (error == 0 || !GPUFailedMsgInternal(error, file, line)) {
+    return 0;
+  }
+  if (failOnError) {
+    if (mInitialized && mInErrorHandling == false) {
+      mInErrorHandling = true;
+      CheckErrorCodes(false, true);
+    }
+    throw std::runtime_error("GPU Backend Failure");
+  }
+  return 1;
+}
+
 void GPUReconstruction::DumpSettings(const char* dir)
 {
   std::string f;
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 93310284d7564..1fe08d08a8058 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -143,6 +143,7 @@ class GPUReconstruction
   virtual void* getGPUPointer(void* ptr) { return ptr; }
   virtual void startGPUProfiling() {}
   virtual void endGPUProfiling() {}
+  int32_t GPUFailedMsgA(const int64_t error, const char* file, int32_t line, bool failOnError);
   int32_t CheckErrorCodes(bool cpuOnly = false, bool forceShowErrors = false, std::vector<std::array<uint32_t, 4>>* fillErrors = nullptr);
   void RunPipelineWorker();
   void TerminatePipelineWorker();
@@ -246,6 +247,7 @@ class GPUReconstruction
   void UpdateMaxMemoryUsed();
   int32_t EnqueuePipeline(bool terminate = false);
   GPUChain* GetNextChainInQueue();
+  virtual int32_t GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const { return 0; }
 
   virtual int32_t registerMemoryForGPU_internal(const void* ptr, size_t size) = 0;
   virtual int32_t unregisterMemoryForGPU_internal(const void* ptr) = 0;
@@ -327,6 +329,7 @@ class GPUReconstruction
 
   // Others
   bool mInitialized = false;
+  bool mInErrorHandling = false;
   uint32_t mStatNEvents = 0;
   uint32_t mNEventsProcessed = 0;
   double mStatKernelTime = 0.;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
index d1091f59b784a..b389e99a0b2bb 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
@@ -175,7 +175,11 @@ void GPUReconstructionDeviceBase::runConstantRegistrators()
 {
   auto& list = getDeviceConstantMemRegistratorsVector();
   for (uint32_t i = 0; i < list.size(); i++) {
-    mDeviceConstantMemList.emplace_back(list[i]());
+    auto* ptr = list[i]();
+    if (ptr == nullptr) {
+      GPUFatal("Error registering constant memory");
+    }
+    mDeviceConstantMemList.emplace_back(ptr);
   }
 }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
index 6cd3813ff1431..c4595bed4c3fb 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
@@ -46,6 +46,7 @@ class GPUReconstructionDeviceBase : public GPUReconstructionCPU
   virtual int32_t InitDevice_Runtime() = 0;
   int32_t ExitDevice() override;
   virtual int32_t ExitDevice_Runtime() = 0;
+  virtual int32_t GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const override = 0;
   int32_t registerMemoryForGPU_internal(const void* ptr, size_t size) override;
   int32_t unregisterMemoryForGPU_internal(const void* ptr) override;
   void unregisterRemainingRegisteredMemory();
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index d2adc3cc1fd19..40e3fa9b90eae 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -61,9 +61,9 @@ GPUReconstructionCUDABackend::~GPUReconstructionCUDABackend()
   }
 }
 
-int32_t GPUReconstructionCUDABackend::GPUFailedMsgAI(const int64_t error, const char* file, int32_t line)
+static_assert(sizeof(cudaError_t) <= sizeof(int64_t) && cudaSuccess == 0);
+int32_t GPUReconstructionCUDABackend::GPUFailedMsgStatic(const int64_t error, const char* file, int32_t line)
 {
-  // Check for CUDA Error and in the case of an error display the corresponding error string
   if (error == cudaSuccess) {
     return (0);
   }
@@ -71,18 +71,6 @@ int32_t GPUReconstructionCUDABackend::GPUFailedMsgAI(const int64_t error, const
   return 1;
 }
 
-void GPUReconstructionCUDABackend::GPUFailedMsgA(const int64_t error, const char* file, int32_t line)
-{
-  if (GPUFailedMsgAI(error, file, line)) {
-    static bool runningCallbacks = false;
-    if (IsInitialized() && runningCallbacks == false) {
-      runningCallbacks = true;
-      CheckErrorCodes(false, true);
-    }
-    throw std::runtime_error("CUDA Failure");
-  }
-}
-
 GPUReconstructionCUDA::GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionKernels(cfg)
 {
   mDeviceBackendSettings.deviceType = DeviceType::CUDA;
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index dde70b9076e08..e04e14bd383d3 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -33,13 +33,13 @@ class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
 {
  public:
   ~GPUReconstructionCUDABackend() override;
-  static int32_t GPUFailedMsgAI(const int64_t error, const char* file, int32_t line);
-  void GPUFailedMsgA(const int64_t error, const char* file, int32_t line);
+  static int32_t GPUFailedMsgStatic(const int64_t error, const char* file, int32_t line);
 
  protected:
   GPUReconstructionCUDABackend(const GPUSettingsDeviceBackend& cfg);
 
   void PrintKernelOccupancies() override;
+  virtual int32_t GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const override { return GPUFailedMsgStatic(error, file, line); }
 
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
index 6bcafe565e930..521ca2182c9bb 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
@@ -36,7 +36,7 @@ using namespace o2::gpu;
 #ifndef GPUCA_NO_CONSTANT_MEMORY
 static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstSymbol([]() {
   void* retVal = nullptr;
-  if (cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer) != cudaSuccess) {
+  if (GPUReconstructionCUDA::GPUFailedMsgStatic(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer), __FILE__, __LINE__)) {
     throw std::runtime_error("Could not obtain GPU constant memory symbol");
   }
   return retVal;
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
index 49c466103c593..a6d55c2d729fd 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
@@ -22,13 +22,11 @@
 #include <vector>
 #include <memory>
 #include <string>
+#include "GPUCommonChkErr.h"
 
 namespace o2::gpu
 {
 
-#define GPUFailedMsg(x) GPUFailedMsgA(x, __FILE__, __LINE__)
-#define GPUFailedMsgI(x) GPUFailedMsgAI(x, __FILE__, __LINE__)
-
 struct GPUReconstructionCUDAInternals {
   std::vector<std::unique_ptr<CUmodule>> kernelModules;     // module for RTC compilation
   std::vector<std::unique_ptr<CUfunction>> kernelFunctions; // vector of ptrs to RTC kernels
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index 0f8d9bf219ba6..a5ab353f3d43f 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -138,7 +138,9 @@ void GPUReconstructionCUDABackend::getRTCKernelCalls(std::vector<std::string>& k
 #ifndef GPUCA_NO_CONSTANT_MEMORY
 static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstSymbol([]() {
   void* retVal = nullptr;
-  GPUReconstructionCUDA::GPUFailedMsgI(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer));
+  if (GPUReconstructionCUDA::GPUFailedMsgStatic(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer), __FILE__, __LINE__)) {
+    throw std::runtime_error("Could not obtain GPU constant memory symbol");
+  }
   return retVal;
 });
 #endif
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index c7a8be62a12ea..6639c78b113e5 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -48,28 +48,17 @@ GPUReconstructionOCLBackend::~GPUReconstructionOCLBackend()
   }
 }
 
-int32_t GPUReconstructionOCLBackend::GPUFailedMsgAI(const int64_t error, const char* file, int32_t line)
+static_assert(sizeof(cl_int) <= sizeof(int64_t) && CL_SUCCESS == 0);
+int32_t GPUReconstructionOCLBackend::GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const
 {
   // Check for OPENCL Error and in the case of an error display the corresponding error string
   if (error == CL_SUCCESS) {
     return (0);
   }
-  GPUError("OCL Error: %ld / %s (%s:%d)", error, convertErrorToString(error), file, line);
+  GPUError("OpenCL Error: %ld / %s (%s:%d)", error, convertErrorToString(error), file, line);
   return 1;
 }
 
-void GPUReconstructionOCLBackend::GPUFailedMsgA(const int64_t error, const char* file, int32_t line)
-{
-  if (GPUFailedMsgAI(error, file, line)) {
-    static bool runningCallbacks = false;
-    if (IsInitialized() && runningCallbacks == false) {
-      runningCallbacks = true;
-      CheckErrorCodes(false, true);
-    }
-    throw std::runtime_error("OpenCL Failure");
-  }
-}
-
 void GPUReconstructionOCLBackend::UpdateAutomaticProcessingSettings()
 {
   GPUCA_GPUReconstructionUpdateDefaults();
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index 5132baa444cd9..79f54274cd32c 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -39,8 +39,7 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
   int32_t ExitDevice_Runtime() override;
   void UpdateAutomaticProcessingSettings() override;
 
-  int32_t GPUFailedMsgAI(const int64_t error, const char* file, int32_t line);
-  void GPUFailedMsgA(const int64_t error, const char* file, int32_t line);
+  virtual int32_t GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const override;
 
   void SynchronizeGPU() override;
   int32_t DoStuckProtection(int32_t stream, deviceEvent event) override;
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
index aec5708a80f3c..9c8cdbe87c7c1 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
@@ -28,6 +28,7 @@
 
 #include "GPUReconstructionOCL.h"
 #include "GPUReconstructionIncludes.h"
+#include "GPUCommonChkErr.h"
 
 using namespace o2::gpu;
 
@@ -36,9 +37,6 @@ using namespace o2::gpu;
 #include <typeinfo>
 #include <cstdlib>
 
-#define GPUFailedMsg(x) GPUFailedMsgA(x, __FILE__, __LINE__)
-#define GPUFailedMsgI(x) GPUFailedMsgAI(x, __FILE__, __LINE__)
-
 namespace o2::gpu
 {
 struct GPUReconstructionOCLInternals {

From 78933b830a4d46b86b4a1360f2f9a8340962a0c7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 13 Mar 2025 18:13:23 +0100
Subject: [PATCH 0069/1764] GPU: Rename GPUFailedMsg to GPUChkErr

---
 GPU/Common/GPUCommonChkErr.h                  |  13 +-
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |   4 +-
 GPU/GPUTracking/Base/GPUReconstruction.h      |   4 +-
 .../Base/GPUReconstructionDeviceBase.h        |   2 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        | 154 +++++++++---------
 .../Base/cuda/GPUReconstructionCUDA.h         |   4 +-
 .../GPUReconstructionCUDAExternalProvider.cu  |   2 +-
 .../cuda/GPUReconstructionCUDAInternals.h     |  10 +-
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  12 +-
 .../Base/opencl/GPUReconstructionOCL.cxx      |  72 ++++----
 .../Base/opencl/GPUReconstructionOCL.h        |   2 +-
 .../opencl/GPUReconstructionOCLKernels.cxx    |  16 +-
 12 files changed, 152 insertions(+), 143 deletions(-)

diff --git a/GPU/Common/GPUCommonChkErr.h b/GPU/Common/GPUCommonChkErr.h
index df007b31dab64..00cb9e50d302f 100644
--- a/GPU/Common/GPUCommonChkErr.h
+++ b/GPU/Common/GPUCommonChkErr.h
@@ -12,10 +12,19 @@
 /// \file GPUCommonChkErr.h
 /// \author David Rohr
 
+// GPUChkErr and GPUChkErrI will both check x for an error, using the loaded backend of GPUReconstruction (requiring GPUReconstruction.h to be included by the user).
+// In case of an error, it will print out the corresponding CUDA / HIP / OpenCL error code
+// GPUChkErr will download GPUReconstruction error values from GPU, print them, and terminate the application with an exception if an error occured.
+// GPUChkErrI will return 0 or 1, depending on whether an error has occurred.
+// The Macros must be called ona GPUReconstruction instance, e.g.:
+// if (mRec->GPUChkErrI(cudaMalloc(...))) { exit(1); }
+// gpuRecObj.GPUChkErr(cudaMalloc(...));
+
 #ifndef GPUCOMMONCHKERR_H
 #define GPUCOMMONCHKERR_H
 
-#define GPUFailedMsg(x) GPUFailedMsgA(x, __FILE__, __LINE__, true)
-#define GPUFailedMsgI(x) GPUFailedMsgA(x, __FILE__, __LINE__, false)
+// Please #include "GPUReconstruction.h" in your code, if you use these 2!
+#define GPUChkErr(x) GPUChkErrA(x, __FILE__, __LINE__, true)
+#define GPUChkErrI(x) GPUChkErrA(x, __FILE__, __LINE__, false)
 
 #endif
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 28241cb7aeec5..2bd4c0e937c20 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -1078,9 +1078,9 @@ int32_t GPUReconstruction::CheckErrorCodes(bool cpuOnly, bool forceShowErrors, s
   return retVal;
 }
 
-int32_t GPUReconstruction::GPUFailedMsgA(const int64_t error, const char* file, int32_t line, bool failOnError)
+int32_t GPUReconstruction::GPUChkErrA(const int64_t error, const char* file, int32_t line, bool failOnError)
 {
-  if (error == 0 || !GPUFailedMsgInternal(error, file, line)) {
+  if (error == 0 || !GPUChkErrInternal(error, file, line)) {
     return 0;
   }
   if (failOnError) {
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 1fe08d08a8058..f363f3f58aa6f 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -143,7 +143,7 @@ class GPUReconstruction
   virtual void* getGPUPointer(void* ptr) { return ptr; }
   virtual void startGPUProfiling() {}
   virtual void endGPUProfiling() {}
-  int32_t GPUFailedMsgA(const int64_t error, const char* file, int32_t line, bool failOnError);
+  int32_t GPUChkErrA(const int64_t error, const char* file, int32_t line, bool failOnError);
   int32_t CheckErrorCodes(bool cpuOnly = false, bool forceShowErrors = false, std::vector<std::array<uint32_t, 4>>* fillErrors = nullptr);
   void RunPipelineWorker();
   void TerminatePipelineWorker();
@@ -247,7 +247,7 @@ class GPUReconstruction
   void UpdateMaxMemoryUsed();
   int32_t EnqueuePipeline(bool terminate = false);
   GPUChain* GetNextChainInQueue();
-  virtual int32_t GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const { return 0; }
+  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const { return 0; }
 
   virtual int32_t registerMemoryForGPU_internal(const void* ptr, size_t size) = 0;
   virtual int32_t unregisterMemoryForGPU_internal(const void* ptr) = 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
index c4595bed4c3fb..f0e19f588e0f1 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
@@ -46,7 +46,7 @@ class GPUReconstructionDeviceBase : public GPUReconstructionCPU
   virtual int32_t InitDevice_Runtime() = 0;
   int32_t ExitDevice() override;
   virtual int32_t ExitDevice_Runtime() = 0;
-  virtual int32_t GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const override = 0;
+  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override = 0;
   int32_t registerMemoryForGPU_internal(const void* ptr, size_t size) override;
   int32_t unregisterMemoryForGPU_internal(const void* ptr) override;
   void unregisterRemainingRegisteredMemory();
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 40e3fa9b90eae..d30eb51bd4938 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -62,7 +62,7 @@ GPUReconstructionCUDABackend::~GPUReconstructionCUDABackend()
 }
 
 static_assert(sizeof(cudaError_t) <= sizeof(int64_t) && cudaSuccess == 0);
-int32_t GPUReconstructionCUDABackend::GPUFailedMsgStatic(const int64_t error, const char* file, int32_t line)
+int32_t GPUReconstructionCUDABackend::GPUChkErrStatic(const int64_t error, const char* file, int32_t line)
 {
   if (error == cudaSuccess) {
     return (0);
@@ -123,7 +123,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     cudaDeviceProp deviceProp;
     int32_t count, bestDevice = -1;
     double bestDeviceSpeed = -1, deviceSpeed;
-    if (GPUFailedMsgI(cudaGetDeviceCount(&count))) {
+    if (GPUChkErrI(cudaGetDeviceCount(&count))) {
       GPUError("Error getting CUDA Device Count");
       return (1);
     }
@@ -139,9 +139,9 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       }
       size_t free, total;
 #ifndef __HIPCC__ // CUDA
-      if (GPUFailedMsgI(cudaInitDevice(i, 0, 0))) {
+      if (GPUChkErrI(cudaInitDevice(i, 0, 0))) {
 #else // HIP
-      if (GPUFailedMsgI(hipSetDevice(i))) {
+      if (GPUChkErrI(hipSetDevice(i))) {
 #endif
         if (mProcessingSettings.debugLevel >= 4) {
           GPUWarning("Couldn't create context for device %d. Skipping it.", i);
@@ -149,21 +149,21 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
         continue;
       }
       contextCreated = true;
-      if (GPUFailedMsgI(cudaMemGetInfo(&free, &total))) {
+      if (GPUChkErrI(cudaMemGetInfo(&free, &total))) {
         if (mProcessingSettings.debugLevel >= 4) {
           GPUWarning("Error obtaining CUDA memory info about device %d! Skipping it.", i);
         }
-        GPUFailedMsg(cudaDeviceReset());
+        GPUChkErr(cudaDeviceReset());
         continue;
       }
       if (count > 1) {
-        GPUFailedMsg(cudaDeviceReset());
+        GPUChkErr(cudaDeviceReset());
         contextCreated = false;
       }
       if (mProcessingSettings.debugLevel >= 4) {
         GPUInfo("Obtained current memory usage for device %d", i);
       }
-      if (GPUFailedMsgI(cudaGetDeviceProperties(&deviceProp, i))) {
+      if (GPUChkErrI(cudaGetDeviceProperties(&deviceProp, i))) {
         continue;
       }
       if (mProcessingSettings.debugLevel >= 4) {
@@ -221,13 +221,13 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     }
     if (noDevice) {
       if (contextCreated) {
-        GPUFailedMsgI(cudaDeviceReset());
+        GPUChkErrI(cudaDeviceReset());
       }
       return (1);
     }
     mDeviceId = bestDevice;
 
-    GPUFailedMsgI(cudaGetDeviceProperties(&deviceProp, mDeviceId));
+    GPUChkErrI(cudaGetDeviceProperties(&deviceProp, mDeviceId));
 
     if (mProcessingSettings.debugLevel >= 2) {
       GPUInfo("Using CUDA Device %s with Properties:", deviceProp.name);
@@ -280,27 +280,27 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
 #endif
 
 #ifndef __HIPCC__ // CUDA
-    if (contextCreated == 0 && GPUFailedMsgI(cudaInitDevice(mDeviceId, 0, 0))) {
+    if (contextCreated == 0 && GPUChkErrI(cudaInitDevice(mDeviceId, 0, 0))) {
 #else // HIP
-    if (contextCreated == 0 && GPUFailedMsgI(hipSetDevice(mDeviceId))) {
+    if (contextCreated == 0 && GPUChkErrI(hipSetDevice(mDeviceId))) {
 #endif
       GPUError("Could not set CUDA Device!");
       return (1);
     }
 
 #ifndef __HIPCC__ // CUDA
-    if (GPUFailedMsgI(cudaDeviceSetLimit(cudaLimitStackSize, GPUCA_GPU_STACK_SIZE))) {
+    if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitStackSize, GPUCA_GPU_STACK_SIZE))) {
       GPUError("Error setting CUDA stack size");
-      GPUFailedMsgI(cudaDeviceReset());
+      GPUChkErrI(cudaDeviceReset());
       return (1);
     }
-    if (GPUFailedMsgI(cudaDeviceSetLimit(cudaLimitMallocHeapSize, mProcessingSettings.deterministicGPUReconstruction ? std::max<size_t>(1024 * 1024 * 1024, GPUCA_GPU_HEAP_SIZE) : GPUCA_GPU_HEAP_SIZE))) {
+    if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitMallocHeapSize, mProcessingSettings.deterministicGPUReconstruction ? std::max<size_t>(1024 * 1024 * 1024, GPUCA_GPU_HEAP_SIZE) : GPUCA_GPU_HEAP_SIZE))) {
       GPUError("Error setting CUDA stack size");
-      GPUFailedMsgI(cudaDeviceReset());
+      GPUChkErrI(cudaDeviceReset());
       return (1);
     }
 #else // HIP
-    if (GPUFailedMsgI(hipSetDeviceFlags(hipDeviceScheduleBlockingSync))) {
+    if (GPUChkErrI(hipSetDeviceFlags(hipDeviceScheduleBlockingSync))) {
       GPUError("Could not set HIP Device flags!");
       return (1);
     }
@@ -319,35 +319,35 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     if (mProcessingSettings.debugLevel >= 3) {
       GPUInfo("Allocating memory on GPU");
     }
-    if (mDeviceMemorySize > deviceProp.totalGlobalMem || GPUFailedMsgI(cudaMalloc(&mDeviceMemoryBase, mDeviceMemorySize))) {
+    if (mDeviceMemorySize > deviceProp.totalGlobalMem || GPUChkErrI(cudaMalloc(&mDeviceMemoryBase, mDeviceMemorySize))) {
       size_t free, total;
-      GPUFailedMsg(cudaMemGetInfo(&free, &total));
+      GPUChkErr(cudaMemGetInfo(&free, &total));
       GPUError("CUDA Memory Allocation Error (trying %ld bytes, %ld available on GPU, %ld free)", (int64_t)mDeviceMemorySize, (int64_t)deviceProp.totalGlobalMem, (int64_t)free);
-      GPUFailedMsgI(cudaDeviceReset());
+      GPUChkErrI(cudaDeviceReset());
       return (1);
     }
     if (mProcessingSettings.debugLevel >= 3) {
       GPUInfo("Allocating memory on Host");
     }
-    if (GPUFailedMsgI(cudaMallocHost(&mHostMemoryBase, mHostMemorySize))) {
+    if (GPUChkErrI(cudaMallocHost(&mHostMemoryBase, mHostMemorySize))) {
       GPUError("Error allocating Page Locked Host Memory (trying %ld bytes)", (int64_t)mHostMemorySize);
-      GPUFailedMsgI(cudaDeviceReset());
+      GPUChkErrI(cudaDeviceReset());
       return (1);
     }
     if (mProcessingSettings.debugLevel >= 1) {
       GPUInfo("Memory ptrs: GPU (%ld bytes): %p - Host (%ld bytes): %p", (int64_t)mDeviceMemorySize, mDeviceMemoryBase, (int64_t)mHostMemorySize, mHostMemoryBase);
       memset(mHostMemoryBase, 0xDD, mHostMemorySize);
-      if (GPUFailedMsgI(cudaMemset(mDeviceMemoryBase, 0xDD, mDeviceMemorySize))) {
+      if (GPUChkErrI(cudaMemset(mDeviceMemoryBase, 0xDD, mDeviceMemorySize))) {
         GPUError("Error during CUDA memset");
-        GPUFailedMsgI(cudaDeviceReset());
+        GPUChkErrI(cudaDeviceReset());
         return (1);
       }
     }
 
     for (int32_t i = 0; i < mNStreams; i++) {
-      if (GPUFailedMsgI(cudaStreamCreateWithFlags(&mInternals->Streams[i], cudaStreamNonBlocking))) {
+      if (GPUChkErrI(cudaStreamCreateWithFlags(&mInternals->Streams[i], cudaStreamNonBlocking))) {
         GPUError("Error creating CUDA Stream");
-        GPUFailedMsgI(cudaDeviceReset());
+        GPUChkErrI(cudaDeviceReset());
         return (1);
       }
     }
@@ -365,7 +365,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     else {
 #define GPUCA_KRNL(x_class, ...)                                        \
   mInternals->kernelModules.emplace_back(std::make_unique<CUmodule>()); \
-  GPUFailedMsg(cuModuleLoadData(mInternals->kernelModules.back().get(), GPUCA_M_CAT3(_binary_cuda_kernel_module_fatbin_krnl_, GPUCA_M_KRNL_NAME(x_class), GPUCA_M_CAT(PER_KERNEL_OBJECT_EXT, _start))));
+  GPUChkErr(cuModuleLoadData(mInternals->kernelModules.back().get(), GPUCA_M_CAT3(_binary_cuda_kernel_module_fatbin_krnl_, GPUCA_M_KRNL_NAME(x_class), GPUCA_M_CAT(PER_KERNEL_OBJECT_EXT, _start))));
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
       loadKernelModules(true);
@@ -382,11 +382,11 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       CUdeviceptr tmp = nullptr; // HIP just uses void*
 #endif
       size_t tmpSize = 0;
-      GPUFailedMsg(cuModuleGetGlobal(&tmp, &tmpSize, *mInternals->kernelModules[i], "gGPUConstantMemBuffer"));
+      GPUChkErr(cuModuleGetGlobal(&tmp, &tmpSize, *mInternals->kernelModules[i], "gGPUConstantMemBuffer"));
       mDeviceConstantMemList.emplace_back((void*)tmp);
     }
 #else
-    GPUFailedMsg(cudaMalloc(&devPtrConstantMem, gGPUConstantMemBufferSize));
+    GPUChkErr(cudaMalloc(&devPtrConstantMem, gGPUConstantMemBufferSize));
 #endif
     mDeviceConstantMem = (GPUConstantMem*)devPtrConstantMem;
 
@@ -402,7 +402,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     mDeviceConstantMemList.resize(master->mDeviceConstantMemList.size());
     std::copy(master->mDeviceConstantMemList.begin(), master->mDeviceConstantMemList.end(), mDeviceConstantMemList.begin());
     mInternals = master->mInternals;
-    GPUFailedMsg(cudaSetDevice(mDeviceId));
+    GPUChkErr(cudaSetDevice(mDeviceId));
 
     GPUInfo("CUDA Initialisation successfull (from master)");
   }
@@ -411,12 +411,12 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     cudaEvent_t* events = (cudaEvent_t*)mEvents[i].data();
     for (uint32_t j = 0; j < mEvents[i].size(); j++) {
 #ifndef __HIPCC__ // CUDA
-      if (GPUFailedMsgI(cudaEventCreate(&events[j]))) {
+      if (GPUChkErrI(cudaEventCreate(&events[j]))) {
 #else
-      if (GPUFailedMsgI(hipEventCreateWithFlags(&events[j], hipEventBlockingSync))) {
+      if (GPUChkErrI(hipEventCreateWithFlags(&events[j], hipEventBlockingSync))) {
 #endif
         GPUError("Error creating event");
-        GPUFailedMsgI(cudaDeviceReset());
+        GPUChkErrI(cudaDeviceReset());
         return 1;
       }
     }
@@ -435,7 +435,7 @@ void GPUReconstructionCUDA::genAndLoadRTC()
   for (uint32_t i = 0; i < nCompile; i++) {
     if (mProcessingSettings.rtc.runTest != 2) {
       mInternals->kernelModules.emplace_back(std::make_unique<CUmodule>());
-      GPUFailedMsg(cuModuleLoad(mInternals->kernelModules.back().get(), (filename + "_" + std::to_string(i) + mRtcBinExtension).c_str()));
+      GPUChkErr(cuModuleLoad(mInternals->kernelModules.back().get(), (filename + "_" + std::to_string(i) + mRtcBinExtension).c_str()));
     }
     remove((filename + "_" + std::to_string(i) + mRtcSrcExtension).c_str());
     remove((filename + "_" + std::to_string(i) + mRtcBinExtension).c_str());
@@ -449,33 +449,33 @@ void GPUReconstructionCUDA::genAndLoadRTC()
 int32_t GPUReconstructionCUDA::ExitDevice_Runtime()
 {
   // Uninitialize CUDA
-  GPUFailedMsg(cudaSetDevice(mDeviceId));
+  GPUChkErr(cudaSetDevice(mDeviceId));
   SynchronizeGPU();
   unregisterRemainingRegisteredMemory();
 
   for (uint32_t i = 0; i < mEvents.size(); i++) {
     cudaEvent_t* events = (cudaEvent_t*)mEvents[i].data();
     for (uint32_t j = 0; j < mEvents[i].size(); j++) {
-      GPUFailedMsgI(cudaEventDestroy(events[j]));
+      GPUChkErrI(cudaEventDestroy(events[j]));
     }
   }
 
   if (mMaster == nullptr) {
-    GPUFailedMsgI(cudaFree(mDeviceMemoryBase));
+    GPUChkErrI(cudaFree(mDeviceMemoryBase));
 #ifdef GPUCA_NO_CONSTANT_MEMORY
-    GPUFailedMsgI(cudaFree(mDeviceConstantMem));
+    GPUChkErrI(cudaFree(mDeviceConstantMem));
 #endif
 
     for (int32_t i = 0; i < mNStreams; i++) {
-      GPUFailedMsgI(cudaStreamDestroy(mInternals->Streams[i]));
+      GPUChkErrI(cudaStreamDestroy(mInternals->Streams[i]));
     }
 
-    GPUFailedMsgI(cudaFreeHost(mHostMemoryBase));
+    GPUChkErrI(cudaFreeHost(mHostMemoryBase));
     for (uint32_t i = 0; i < mInternals->kernelModules.size(); i++) {
-      GPUFailedMsg(cuModuleUnload(*mInternals->kernelModules[i]));
+      GPUChkErr(cuModuleUnload(*mInternals->kernelModules[i]));
     }
 
-    GPUFailedMsgI(cudaDeviceReset());
+    GPUChkErrI(cudaDeviceReset());
     GPUInfo("CUDA Uninitialized");
   }
   mDeviceMemoryBase = nullptr;
@@ -491,18 +491,18 @@ size_t GPUReconstructionCUDA::GPUMemCpy(void* dst, const void* src, size_t size,
   }
   if (stream == -1) {
     SynchronizeGPU();
-    GPUFailedMsg(cudaMemcpy(dst, src, size, toGPU ? cudaMemcpyHostToDevice : cudaMemcpyDeviceToHost));
+    GPUChkErr(cudaMemcpy(dst, src, size, toGPU ? cudaMemcpyHostToDevice : cudaMemcpyDeviceToHost));
   } else {
     if (evList == nullptr) {
       nEvents = 0;
     }
     for (int32_t k = 0; k < nEvents; k++) {
-      GPUFailedMsg(cudaStreamWaitEvent(mInternals->Streams[stream], evList[k].get<cudaEvent_t>(), 0));
+      GPUChkErr(cudaStreamWaitEvent(mInternals->Streams[stream], evList[k].get<cudaEvent_t>(), 0));
     }
-    GPUFailedMsg(cudaMemcpyAsync(dst, src, size, toGPU == -2 ? cudaMemcpyDeviceToDevice : toGPU ? cudaMemcpyHostToDevice : cudaMemcpyDeviceToHost, mInternals->Streams[stream]));
+    GPUChkErr(cudaMemcpyAsync(dst, src, size, toGPU == -2 ? cudaMemcpyDeviceToDevice : toGPU ? cudaMemcpyHostToDevice : cudaMemcpyDeviceToHost, mInternals->Streams[stream]));
   }
   if (ev) {
-    GPUFailedMsg(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream == -1 ? 0 : stream]));
+    GPUChkErr(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream == -1 ? 0 : stream]));
   }
   if (mProcessingSettings.serializeGPU & 2) {
     GPUDebug(("GPUMemCpy " + std::to_string(toGPU)).c_str(), stream, true);
@@ -518,13 +518,13 @@ size_t GPUReconstructionCUDA::WriteToConstantMemory(size_t offset, const void* s
       continue;
     }
     if (stream == -1) {
-      GPUFailedMsg(cudaMemcpy(((char*)basePtr) + offset, src, size, cudaMemcpyHostToDevice));
+      GPUChkErr(cudaMemcpy(((char*)basePtr) + offset, src, size, cudaMemcpyHostToDevice));
     } else {
-      GPUFailedMsg(cudaMemcpyAsync(((char*)basePtr) + offset, src, size, cudaMemcpyHostToDevice, mInternals->Streams[stream]));
+      GPUChkErr(cudaMemcpyAsync(((char*)basePtr) + offset, src, size, cudaMemcpyHostToDevice, mInternals->Streams[stream]));
     }
   }
   if (ev && stream != -1) {
-    GPUFailedMsg(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream]));
+    GPUChkErr(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream]));
   }
   if (mProcessingSettings.serializeGPU & 2) {
     GPUDebug("WriteToConstantMemory", stream, true);
@@ -533,28 +533,28 @@ size_t GPUReconstructionCUDA::WriteToConstantMemory(size_t offset, const void* s
 }
 
 void GPUReconstructionCUDA::ReleaseEvent(deviceEvent ev) {}
-void GPUReconstructionCUDA::RecordMarker(deviceEvent* ev, int32_t stream) { GPUFailedMsg(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream])); }
+void GPUReconstructionCUDA::RecordMarker(deviceEvent* ev, int32_t stream) { GPUChkErr(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream])); }
 
 std::unique_ptr<gpu_reconstruction_kernels::threadContext> GPUReconstructionCUDA::GetThreadContext()
 {
-  GPUFailedMsg(cudaSetDevice(mDeviceId));
+  GPUChkErr(cudaSetDevice(mDeviceId));
   return GPUReconstructionProcessing::GetThreadContext();
 }
 
-void GPUReconstructionCUDA::SynchronizeGPU() { GPUFailedMsg(cudaDeviceSynchronize()); }
-void GPUReconstructionCUDA::SynchronizeStream(int32_t stream) { GPUFailedMsg(cudaStreamSynchronize(mInternals->Streams[stream])); }
+void GPUReconstructionCUDA::SynchronizeGPU() { GPUChkErr(cudaDeviceSynchronize()); }
+void GPUReconstructionCUDA::SynchronizeStream(int32_t stream) { GPUChkErr(cudaStreamSynchronize(mInternals->Streams[stream])); }
 
 void GPUReconstructionCUDA::SynchronizeEvents(deviceEvent* evList, int32_t nEvents)
 {
   for (int32_t i = 0; i < nEvents; i++) {
-    GPUFailedMsg(cudaEventSynchronize(evList[i].get<cudaEvent_t>()));
+    GPUChkErr(cudaEventSynchronize(evList[i].get<cudaEvent_t>()));
   }
 }
 
 void GPUReconstructionCUDA::StreamWaitForEvents(int32_t stream, deviceEvent* evList, int32_t nEvents)
 {
   for (int32_t i = 0; i < nEvents; i++) {
-    GPUFailedMsg(cudaStreamWaitEvent(mInternals->Streams[stream], evList[i].get<cudaEvent_t>(), 0));
+    GPUChkErr(cudaStreamWaitEvent(mInternals->Streams[stream], evList[i].get<cudaEvent_t>(), 0));
   }
 }
 
@@ -565,7 +565,7 @@ bool GPUReconstructionCUDA::IsEventDone(deviceEvent* evList, int32_t nEvents)
     if (retVal == cudaErrorNotReady) {
       return false;
     }
-    GPUFailedMsg(retVal);
+    GPUChkErr(retVal);
   }
   return (true);
 }
@@ -582,7 +582,7 @@ int32_t GPUReconstructionCUDA::GPUDebug(const char* state, int32_t stream, bool
   if (!force && mProcessingSettings.debugLevel <= 0) {
     return (0);
   }
-  if (GPUFailedMsgI(stream == -1 ? cudaDeviceSynchronize() : cudaStreamSynchronize(mInternals->Streams[stream]))) {
+  if (GPUChkErrI(stream == -1 ? cudaDeviceSynchronize() : cudaStreamSynchronize(mInternals->Streams[stream]))) {
     GPUError("CUDA Error while synchronizing (%s) (Stream %d)", state, stream);
     return (1);
   }
@@ -597,23 +597,23 @@ int32_t GPUReconstructionCUDA::registerMemoryForGPU_internal(const void* ptr, si
   if (mProcessingSettings.debugLevel >= 3) {
     GPUInfo("Registering %zu bytes of memory for GPU", size);
   }
-  return GPUFailedMsgI(cudaHostRegister((void*)ptr, size, cudaHostRegisterDefault));
+  return GPUChkErrI(cudaHostRegister((void*)ptr, size, cudaHostRegisterDefault));
 }
 
 int32_t GPUReconstructionCUDA::unregisterMemoryForGPU_internal(const void* ptr)
 {
-  return GPUFailedMsgI(cudaHostUnregister((void*)ptr));
+  return GPUChkErrI(cudaHostUnregister((void*)ptr));
 }
 
 void GPUReconstructionCUDABackend::PrintKernelOccupancies()
 {
   int32_t maxBlocks = 0, threads = 0, suggestedBlocks = 0, nRegs = 0, sMem = 0;
-  GPUFailedMsg(cudaSetDevice(mDeviceId));
+  GPUChkErr(cudaSetDevice(mDeviceId));
   for (uint32_t i = 0; i < mInternals->kernelFunctions.size(); i++) {
-    GPUFailedMsg(cuOccupancyMaxPotentialBlockSize(&suggestedBlocks, &threads, *mInternals->kernelFunctions[i], 0, 0, 0)); // NOLINT: failure in clang-tidy
-    GPUFailedMsg(cuOccupancyMaxActiveBlocksPerMultiprocessor(&maxBlocks, *mInternals->kernelFunctions[i], threads, 0));
-    GPUFailedMsg(cuFuncGetAttribute(&nRegs, CU_FUNC_ATTRIBUTE_NUM_REGS, *mInternals->kernelFunctions[i]));
-    GPUFailedMsg(cuFuncGetAttribute(&sMem, CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, *mInternals->kernelFunctions[i]));
+    GPUChkErr(cuOccupancyMaxPotentialBlockSize(&suggestedBlocks, &threads, *mInternals->kernelFunctions[i], 0, 0, 0)); // NOLINT: failure in clang-tidy
+    GPUChkErr(cuOccupancyMaxActiveBlocksPerMultiprocessor(&maxBlocks, *mInternals->kernelFunctions[i], threads, 0));
+    GPUChkErr(cuFuncGetAttribute(&nRegs, CU_FUNC_ATTRIBUTE_NUM_REGS, *mInternals->kernelFunctions[i]));
+    GPUChkErr(cuFuncGetAttribute(&sMem, CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, *mInternals->kernelFunctions[i]));
     GPUInfo("Kernel: %50s Block size: %4d, Maximum active blocks: %3d, Suggested blocks: %3d, Regs: %3d, smem: %3d", mInternals->kernelNames[i].c_str(), threads, maxBlocks, suggestedBlocks, nRegs, sMem);
   }
 }
@@ -621,14 +621,14 @@ void GPUReconstructionCUDABackend::PrintKernelOccupancies()
 void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
 {
   uint32_t j = 0;
-#define GPUCA_KRNL(x_class, ...)                                                                                                                                                           \
-  getRTCkernelNum<false, GPUCA_M_KRNL_TEMPLATE(x_class)>(mInternals->kernelFunctions.size());                                                                                              \
-  mInternals->kernelFunctions.emplace_back(new CUfunction);                                                                                                                                \
-  mInternals->kernelNames.emplace_back(GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))));                                                                                       \
-  if (mProcessingSettings.debugLevel >= 3) {                                                                                                                                               \
-    GPUInfo("Loading kernel %s (j = %u)", GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), j);                                                                                 \
-  }                                                                                                                                                                                        \
-  GPUFailedMsg(cuModuleGetFunction(mInternals->kernelFunctions.back().get(), *mInternals->kernelModules[perKernel ? j : 0], GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))))); \
+#define GPUCA_KRNL(x_class, ...)                                                                                                                                                        \
+  getRTCkernelNum<false, GPUCA_M_KRNL_TEMPLATE(x_class)>(mInternals->kernelFunctions.size());                                                                                           \
+  mInternals->kernelFunctions.emplace_back(new CUfunction);                                                                                                                             \
+  mInternals->kernelNames.emplace_back(GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))));                                                                                    \
+  if (mProcessingSettings.debugLevel >= 3) {                                                                                                                                            \
+    GPUInfo("Loading kernel %s (j = %u)", GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), j);                                                                              \
+  }                                                                                                                                                                                     \
+  GPUChkErr(cuModuleGetFunction(mInternals->kernelFunctions.back().get(), *mInternals->kernelModules[perKernel ? j : 0], GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))))); \
   j++;
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
@@ -644,27 +644,27 @@ int32_t GPUReconstructionCUDA::PrepareTextures()
 #ifdef GPUCA_USE_TEXTURES
   cudaChannelFormatDesc channelDescu2 = cudaCreateChannelDesc<cahit2>();
   size_t offset;
-  GPUFailedMsg(cudaBindTexture(&offset, &gAliTexRefu2, mProcessorsShadow->tpcTrackers[0].Data().Memory(), &channelDescu2, NSECTORS * GPUCA_SECTOR_DATA_MEMORY));
+  GPUChkErr(cudaBindTexture(&offset, &gAliTexRefu2, mProcessorsShadow->tpcTrackers[0].Data().Memory(), &channelDescu2, NSECTORS * GPUCA_SECTOR_DATA_MEMORY));
   cudaChannelFormatDesc channelDescu = cudaCreateChannelDesc<calink>();
-  GPUFailedMsg(cudaBindTexture(&offset, &gAliTexRefu, mProcessorsShadow->tpcTrackers[0].Data().Memory(), &channelDescu, NSECTORS * GPUCA_SECTOR_DATA_MEMORY));
+  GPUChkErr(cudaBindTexture(&offset, &gAliTexRefu, mProcessorsShadow->tpcTrackers[0].Data().Memory(), &channelDescu, NSECTORS * GPUCA_SECTOR_DATA_MEMORY));
 #endif
   return (0);
 }
 
 void GPUReconstructionCUDA::startGPUProfiling()
 {
-  GPUFailedMsg(cudaProfilerStart());
+  GPUChkErr(cudaProfilerStart());
 }
 
 void GPUReconstructionCUDA::endGPUProfiling()
 {
-  GPUFailedMsg(cudaProfilerStop());
+  GPUChkErr(cudaProfilerStop());
 }
 #else  // HIP
 void* GPUReconstructionHIP::getGPUPointer(void* ptr)
 {
   void* retVal = nullptr;
-  GPUFailedMsg(hipHostGetDevicePointer(&retVal, ptr, 0));
+  GPUChkErr(hipHostGetDevicePointer(&retVal, ptr, 0));
   return retVal;
 }
 #endif // __HIPCC__
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index e04e14bd383d3..02e8f92bb2328 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -33,13 +33,13 @@ class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
 {
  public:
   ~GPUReconstructionCUDABackend() override;
-  static int32_t GPUFailedMsgStatic(const int64_t error, const char* file, int32_t line);
+  static int32_t GPUChkErrStatic(const int64_t error, const char* file, int32_t line);
 
  protected:
   GPUReconstructionCUDABackend(const GPUSettingsDeviceBackend& cfg);
 
   void PrintKernelOccupancies() override;
-  virtual int32_t GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const override { return GPUFailedMsgStatic(error, file, line); }
+  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override { return GPUChkErrStatic(error, file, line); }
 
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
index 521ca2182c9bb..bc1d573385598 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
@@ -36,7 +36,7 @@ using namespace o2::gpu;
 #ifndef GPUCA_NO_CONSTANT_MEMORY
 static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstSymbol([]() {
   void* retVal = nullptr;
-  if (GPUReconstructionCUDA::GPUFailedMsgStatic(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer), __FILE__, __LINE__)) {
+  if (GPUReconstructionCUDA::GPUChkErrStatic(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer), __FILE__, __LINE__)) {
     throw std::runtime_error("Could not obtain GPU constant memory symbol");
   }
   return retVal;
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
index a6d55c2d729fd..027a9d5445b2c 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
@@ -49,7 +49,7 @@ class GPUDebugTiming
   {
     if (mDo) {
       if (mDeviceTimers) {
-        mRec->GPUFailedMsg(cudaEventRecord(mDeviceTimers[0].get<cudaEvent_t>(), mStreams[mXYZ.x.stream]));
+        mRec->GPUChkErr(cudaEventRecord(mDeviceTimers[0].get<cudaEvent_t>(), mStreams[mXYZ.x.stream]));
       } else {
         mTimer.ResetStart();
       }
@@ -59,13 +59,13 @@ class GPUDebugTiming
   {
     if (mDo && mXYZ.t == 0.) {
       if (mDeviceTimers) {
-        mRec->GPUFailedMsg(cudaEventRecord(mDeviceTimers[1].get<cudaEvent_t>(), mStreams[mXYZ.x.stream]));
-        mRec->GPUFailedMsg(cudaEventSynchronize(mDeviceTimers[1].get<cudaEvent_t>()));
+        mRec->GPUChkErr(cudaEventRecord(mDeviceTimers[1].get<cudaEvent_t>(), mStreams[mXYZ.x.stream]));
+        mRec->GPUChkErr(cudaEventSynchronize(mDeviceTimers[1].get<cudaEvent_t>()));
         float v;
-        mRec->GPUFailedMsg(cudaEventElapsedTime(&v, mDeviceTimers[0].get<cudaEvent_t>(), mDeviceTimers[1].get<cudaEvent_t>()));
+        mRec->GPUChkErr(cudaEventElapsedTime(&v, mDeviceTimers[0].get<cudaEvent_t>(), mDeviceTimers[1].get<cudaEvent_t>()));
         mXYZ.t = v * 1.e-3f;
       } else {
-        mRec->GPUFailedMsg(cudaStreamSynchronize(mStreams[mXYZ.x.stream]));
+        mRec->GPUChkErr(cudaStreamSynchronize(mStreams[mXYZ.x.stream]));
         mXYZ.t = mTimer.GetCurrentElapsedTime();
       }
     }
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index a5ab353f3d43f..f60f00c13710d 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -34,7 +34,7 @@ __global__ void gGPUConstantMemBuffer_dummy(int32_t* p) { *p = *(int32_t*)&gGPUC
 template <>
 inline void GPUReconstructionCUDABackend::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
-  GPUFailedMsg(cudaMemsetAsync(ptr, 0, size, mInternals->Streams[_xyz.x.stream]));
+  GPUChkErr(cudaMemsetAsync(ptr, 0, size, mInternals->Streams[_xyz.x.stream]));
 }
 
 template <class T, int32_t I, typename... Args>
@@ -56,7 +56,7 @@ inline void GPUReconstructionCUDABackend::runKernelBackendInternal(const krnlSet
 #endif
     pArgs[arg_offset] = &y.index;
     GPUReconstructionCUDAInternals::getArgPtrs(&pArgs[arg_offset + 1], args...);
-    GPUFailedMsg(cuLaunchKernel(*mInternals->kernelFunctions[getRTCkernelNum<false, T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
+    GPUChkErr(cuLaunchKernel(*mInternals->kernelFunctions[getRTCkernelNum<false, T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
   }
 }
 
@@ -67,16 +67,16 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
   auto& z = args.s.z;
   if (z.evList) {
     for (int32_t k = 0; k < z.nEvents; k++) {
-      GPUFailedMsg(cudaStreamWaitEvent(mInternals->Streams[x.stream], ((cudaEvent_t*)z.evList)[k], 0));
+      GPUChkErr(cudaStreamWaitEvent(mInternals->Streams[x.stream], ((cudaEvent_t*)z.evList)[k], 0));
     }
   }
   {
     GPUDebugTiming timer(mProcessingSettings.deviceTimers && mProcessingSettings.debugLevel > 0, (deviceEvent*)mDebugEvents, mInternals->Streams, args.s, this);
     std::apply([this, &args](auto&... vals) { this->runKernelBackendInternal<T, I, Args...>(args.s, vals...); }, args.v);
   }
-  GPUFailedMsg(cudaGetLastError());
+  GPUChkErr(cudaGetLastError());
   if (z.ev) {
-    GPUFailedMsg(cudaEventRecord(*(cudaEvent_t*)z.ev, mInternals->Streams[x.stream]));
+    GPUChkErr(cudaEventRecord(*(cudaEvent_t*)z.ev, mInternals->Streams[x.stream]));
   }
 }
 
@@ -138,7 +138,7 @@ void GPUReconstructionCUDABackend::getRTCKernelCalls(std::vector<std::string>& k
 #ifndef GPUCA_NO_CONSTANT_MEMORY
 static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstSymbol([]() {
   void* retVal = nullptr;
-  if (GPUReconstructionCUDA::GPUFailedMsgStatic(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer), __FILE__, __LINE__)) {
+  if (GPUReconstructionCUDA::GPUChkErrStatic(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer), __FILE__, __LINE__)) {
     throw std::runtime_error("Could not obtain GPU constant memory symbol");
   }
   return retVal;
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index 6639c78b113e5..e52494937f8bf 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -49,7 +49,7 @@ GPUReconstructionOCLBackend::~GPUReconstructionOCLBackend()
 }
 
 static_assert(sizeof(cl_int) <= sizeof(int64_t) && CL_SUCCESS == 0);
-int32_t GPUReconstructionOCLBackend::GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const
+int32_t GPUReconstructionOCLBackend::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
 {
   // Check for OPENCL Error and in the case of an error display the corresponding error string
   if (error == CL_SUCCESS) {
@@ -69,7 +69,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
   if (mMaster == nullptr) {
     cl_int ocl_error;
     cl_uint num_platforms;
-    if (GPUFailedMsgI(clGetPlatformIDs(0, nullptr, &num_platforms))) {
+    if (GPUChkErrI(clGetPlatformIDs(0, nullptr, &num_platforms))) {
       GPUErrorReturn("Error getting OpenCL Platform Count");
     }
     if (num_platforms == 0) {
@@ -82,7 +82,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
     // Query platforms and devices
     std::unique_ptr<cl_platform_id[]> platforms;
     platforms.reset(new cl_platform_id[num_platforms]);
-    if (GPUFailedMsgI(clGetPlatformIDs(num_platforms, platforms.get(), nullptr))) {
+    if (GPUChkErrI(clGetPlatformIDs(num_platforms, platforms.get(), nullptr))) {
       GPUErrorReturn("Error getting OpenCL Platforms");
     }
 
@@ -227,7 +227,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
       GPUErrorReturn("Did not find compatible OpenCL Platform / Device, aborting OPENCL Initialisation");
     }
     mInternals->platform = platforms[bestPlatform];
-    GPUFailedMsg(clGetDeviceIDs(mInternals->platform, CL_DEVICE_TYPE_ALL, devices.size(), devices.data(), nullptr));
+    GPUChkErr(clGetDeviceIDs(mInternals->platform, CL_DEVICE_TYPE_ALL, devices.size(), devices.data(), nullptr));
     mInternals->device = devices[bestDevice];
     queryDevice(mInternals->device);
 
@@ -267,7 +267,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
     mMaxBackendThreads = std::max<int32_t>(mMaxBackendThreads, deviceMaxWorkGroup * mBlockCount);
 
     mInternals->context = clCreateContext(nullptr, 1, &mInternals->device, nullptr, nullptr, &ocl_error);
-    if (GPUFailedMsgI(ocl_error)) {
+    if (GPUChkErrI(ocl_error)) {
       GPUErrorReturn("Could not create OPENCL Device Context!");
     }
 
@@ -280,13 +280,13 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
     }
 
     mInternals->mem_gpu = clCreateBuffer(mInternals->context, CL_MEM_READ_WRITE, mDeviceMemorySize, nullptr, &ocl_error);
-    if (GPUFailedMsgI(ocl_error)) {
+    if (GPUChkErrI(ocl_error)) {
       clReleaseContext(mInternals->context);
       GPUErrorReturn("OPENCL Memory Allocation Error");
     }
 
     mInternals->mem_constant = clCreateBuffer(mInternals->context, CL_MEM_READ_ONLY, gGPUConstantMemBufferSize, nullptr, &ocl_error);
-    if (GPUFailedMsgI(ocl_error)) {
+    if (GPUChkErrI(ocl_error)) {
       clReleaseMemObject(mInternals->mem_gpu);
       clReleaseContext(mInternals->context);
       GPUErrorReturn("OPENCL Constant Memory Allocation Error");
@@ -314,44 +314,44 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
 #else
       mInternals->command_queue[i] = clCreateCommandQueue(mInternals->context, mInternals->device, 0, &ocl_error);
 #endif
-      if (GPUFailedMsgI(ocl_error)) {
+      if (GPUChkErrI(ocl_error)) {
         GPUErrorReturn("Error creating OpenCL command queue");
       }
     }
-    if (GPUFailedMsgI(clEnqueueMigrateMemObjects(mInternals->command_queue[0], 1, &mInternals->mem_gpu, 0, 0, nullptr, nullptr))) {
+    if (GPUChkErrI(clEnqueueMigrateMemObjects(mInternals->command_queue[0], 1, &mInternals->mem_gpu, 0, 0, nullptr, nullptr))) {
       GPUErrorReturn("Error migrating buffer");
     }
-    if (GPUFailedMsgI(clEnqueueMigrateMemObjects(mInternals->command_queue[0], 1, &mInternals->mem_constant, 0, 0, nullptr, nullptr))) {
+    if (GPUChkErrI(clEnqueueMigrateMemObjects(mInternals->command_queue[0], 1, &mInternals->mem_constant, 0, 0, nullptr, nullptr))) {
       GPUErrorReturn("Error migrating buffer");
     }
 
     mInternals->mem_host = clCreateBuffer(mInternals->context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, mHostMemorySize, nullptr, &ocl_error);
-    if (GPUFailedMsgI(ocl_error)) {
+    if (GPUChkErrI(ocl_error)) {
       GPUErrorReturn("Error allocating pinned host memory");
     }
 
     const char* krnlGetPtr = "__kernel void krnlGetPtr(__global char* gpu_mem, __global char* constant_mem, __global size_t* host_mem) {if (get_global_id(0) == 0) {host_mem[0] = (size_t) gpu_mem; host_mem[1] = (size_t) constant_mem;}}";
     cl_program program = clCreateProgramWithSource(mInternals->context, 1, (const char**)&krnlGetPtr, nullptr, &ocl_error);
-    if (GPUFailedMsgI(ocl_error)) {
+    if (GPUChkErrI(ocl_error)) {
       GPUErrorReturn("Error creating program object");
     }
     ocl_error = clBuildProgram(program, 1, &mInternals->device, "", nullptr, nullptr);
-    if (GPUFailedMsgI(ocl_error)) {
+    if (GPUChkErrI(ocl_error)) {
       char build_log[16384];
       clGetProgramBuildInfo(program, mInternals->device, CL_PROGRAM_BUILD_LOG, 16384, build_log, nullptr);
       GPUImportant("Build Log:\n\n%s\n\n", build_log);
       GPUErrorReturn("Error compiling program");
     }
     cl_kernel kernel = clCreateKernel(program, "krnlGetPtr", &ocl_error);
-    if (GPUFailedMsgI(ocl_error)) {
+    if (GPUChkErrI(ocl_error)) {
       GPUErrorReturn("Error creating kernel");
     }
 
-    if (GPUFailedMsgI(OCLsetKernelParameters(kernel, mInternals->mem_gpu, mInternals->mem_constant, mInternals->mem_host)) ||
-        GPUFailedMsgI(clExecuteKernelA(mInternals->command_queue[0], kernel, 16, 16, nullptr)) ||
-        GPUFailedMsgI(clFinish(mInternals->command_queue[0])) ||
-        GPUFailedMsgI(clReleaseKernel(kernel)) ||
-        GPUFailedMsgI(clReleaseProgram(program))) {
+    if (GPUChkErrI(OCLsetKernelParameters(kernel, mInternals->mem_gpu, mInternals->mem_constant, mInternals->mem_host)) ||
+        GPUChkErrI(clExecuteKernelA(mInternals->command_queue[0], kernel, 16, 16, nullptr)) ||
+        GPUChkErrI(clFinish(mInternals->command_queue[0])) ||
+        GPUChkErrI(clReleaseKernel(kernel)) ||
+        GPUChkErrI(clReleaseProgram(program))) {
       GPUErrorReturn("Error obtaining device memory ptr");
     }
 
@@ -359,7 +359,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
       GPUInfo("Mapping hostmemory");
     }
     mHostMemoryBase = clEnqueueMapBuffer(mInternals->command_queue[0], mInternals->mem_host, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, 0, mHostMemorySize, 0, nullptr, nullptr, &ocl_error);
-    if (GPUFailedMsgI(ocl_error)) {
+    if (GPUChkErrI(ocl_error)) {
       GPUErrorReturn("Error allocating Page Locked Host Memory");
     }
 
@@ -435,14 +435,14 @@ size_t GPUReconstructionOCLBackend::GPUMemCpy(void* dst, const void* src, size_t
   }
   if (size == 0) {
     if (ev || nEvents) { // Workaround for OCL runtimes, which can throw an error in case size = 0
-      GPUFailedMsg(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream == -1 ? 0 : stream], nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
+      GPUChkErr(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream == -1 ? 0 : stream], nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
     }
   } else if (toGPU == -2) {
-    GPUFailedMsg(clEnqueueCopyBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_gpu, mInternals->mem_gpu, (char*)src - (char*)mDeviceMemoryBase, (char*)dst - (char*)mDeviceMemoryBase, size, nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
+    GPUChkErr(clEnqueueCopyBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_gpu, mInternals->mem_gpu, (char*)src - (char*)mDeviceMemoryBase, (char*)dst - (char*)mDeviceMemoryBase, size, nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
   } else if (toGPU) {
-    GPUFailedMsg(clEnqueueWriteBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_gpu, stream == -1, (char*)dst - (char*)mDeviceMemoryBase, size, src, nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
+    GPUChkErr(clEnqueueWriteBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_gpu, stream == -1, (char*)dst - (char*)mDeviceMemoryBase, size, src, nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
   } else {
-    GPUFailedMsg(clEnqueueReadBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_gpu, stream == -1, (char*)src - (char*)mDeviceMemoryBase, size, dst, nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
+    GPUChkErr(clEnqueueReadBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_gpu, stream == -1, (char*)src - (char*)mDeviceMemoryBase, size, dst, nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
   }
   if (mProcessingSettings.serializeGPU & 2) {
     GPUDebug(("GPUMemCpy " + std::to_string(toGPU)).c_str(), stream, true);
@@ -455,16 +455,16 @@ size_t GPUReconstructionOCLBackend::WriteToConstantMemory(size_t offset, const v
   if (stream == -1) {
     SynchronizeGPU();
   }
-  GPUFailedMsg(clEnqueueWriteBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_constant, stream == -1, offset, size, src, 0, nullptr, ev->getEventList<cl_event>()));
+  GPUChkErr(clEnqueueWriteBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_constant, stream == -1, offset, size, src, 0, nullptr, ev->getEventList<cl_event>()));
   if (mProcessingSettings.serializeGPU & 2) {
     GPUDebug("WriteToConstantMemory", stream, true);
   }
   return size;
 }
 
-void GPUReconstructionOCLBackend::ReleaseEvent(deviceEvent ev) { GPUFailedMsg(clReleaseEvent(ev.get<cl_event>())); }
+void GPUReconstructionOCLBackend::ReleaseEvent(deviceEvent ev) { GPUChkErr(clReleaseEvent(ev.get<cl_event>())); }
 
-void GPUReconstructionOCLBackend::RecordMarker(deviceEvent* ev, int32_t stream) { GPUFailedMsg(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev->getEventList<cl_event>())); }
+void GPUReconstructionOCLBackend::RecordMarker(deviceEvent* ev, int32_t stream) { GPUChkErr(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev->getEventList<cl_event>())); }
 
 int32_t GPUReconstructionOCLBackend::DoStuckProtection(int32_t stream, deviceEvent event)
 {
@@ -490,18 +490,18 @@ int32_t GPUReconstructionOCLBackend::DoStuckProtection(int32_t stream, deviceEve
 void GPUReconstructionOCLBackend::SynchronizeGPU()
 {
   for (int32_t i = 0; i < mNStreams; i++) {
-    GPUFailedMsg(clFinish(mInternals->command_queue[i]));
+    GPUChkErr(clFinish(mInternals->command_queue[i]));
   }
 }
 
-void GPUReconstructionOCLBackend::SynchronizeStream(int32_t stream) { GPUFailedMsg(clFinish(mInternals->command_queue[stream])); }
+void GPUReconstructionOCLBackend::SynchronizeStream(int32_t stream) { GPUChkErr(clFinish(mInternals->command_queue[stream])); }
 
-void GPUReconstructionOCLBackend::SynchronizeEvents(deviceEvent* evList, int32_t nEvents) { GPUFailedMsg(clWaitForEvents(nEvents, evList->getEventList<cl_event>())); }
+void GPUReconstructionOCLBackend::SynchronizeEvents(deviceEvent* evList, int32_t nEvents) { GPUChkErr(clWaitForEvents(nEvents, evList->getEventList<cl_event>())); }
 
 void GPUReconstructionOCLBackend::StreamWaitForEvents(int32_t stream, deviceEvent* evList, int32_t nEvents)
 {
   if (nEvents) {
-    GPUFailedMsg(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], nEvents, evList->getEventList<cl_event>(), nullptr));
+    GPUChkErr(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], nEvents, evList->getEventList<cl_event>(), nullptr));
   }
 }
 
@@ -509,7 +509,7 @@ bool GPUReconstructionOCLBackend::IsEventDone(deviceEvent* evList, int32_t nEven
 {
   cl_int eventdone;
   for (int32_t i = 0; i < nEvents; i++) {
-    GPUFailedMsg(clGetEventInfo(evList[i].get<cl_event>(), CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(eventdone), &eventdone, nullptr));
+    GPUChkErr(clGetEventInfo(evList[i].get<cl_event>(), CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(eventdone), &eventdone, nullptr));
     if (eventdone != CL_COMPLETE) {
       return false;
     }
@@ -524,7 +524,7 @@ int32_t GPUReconstructionOCLBackend::GPUDebug(const char* state, int32_t stream,
     return (0);
   }
   for (int32_t i = 0; i < mNStreams; i++) {
-    if (GPUFailedMsgI(clFinish(mInternals->command_queue[i]))) {
+    if (GPUChkErrI(clFinish(mInternals->command_queue[i]))) {
       GPUError("OpenCL Error while synchronizing (%s) (Stream %d/%d)", state, stream, i);
     }
   }
@@ -554,14 +554,14 @@ int32_t GPUReconstructionOCLBackend::GetOCLPrograms()
     mInternals->program = clCreateProgramWithSource(mInternals->context, (cl_uint)1, (const char**)&programs_sources, program_sizes, &ocl_error);
   }
 
-  if (GPUFailedMsgI(ocl_error)) {
+  if (GPUChkErrI(ocl_error)) {
     GPUError("Error creating OpenCL program from binary");
     return 1;
   }
 
-  if (GPUFailedMsgI(clBuildProgram(mInternals->program, 1, &mInternals->device, oclBuildFlags, nullptr, nullptr))) {
+  if (GPUChkErrI(clBuildProgram(mInternals->program, 1, &mInternals->device, oclBuildFlags, nullptr, nullptr))) {
     cl_build_status status;
-    if (GPUFailedMsgI(clGetProgramBuildInfo(mInternals->program, mInternals->device, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, nullptr)) == 0 && status == CL_BUILD_ERROR) {
+    if (GPUChkErrI(clGetProgramBuildInfo(mInternals->program, mInternals->device, CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, nullptr)) == 0 && status == CL_BUILD_ERROR) {
       size_t log_size;
       clGetProgramBuildInfo(mInternals->program, mInternals->device, CL_PROGRAM_BUILD_LOG, 0, nullptr, &log_size);
       std::unique_ptr<char[]> build_log(new char[log_size + 1]);
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index 79f54274cd32c..2abae229c74bb 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -39,7 +39,7 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
   int32_t ExitDevice_Runtime() override;
   void UpdateAutomaticProcessingSettings() override;
 
-  virtual int32_t GPUFailedMsgInternal(const int64_t error, const char* file, int32_t line) const override;
+  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override;
 
   void SynchronizeGPU() override;
   int32_t DoStuckProtection(int32_t stream, deviceEvent event) override;
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index 8a6c889773cb0..4f6a8725b4be5 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -18,7 +18,7 @@ template <>
 inline void GPUReconstructionOCLBackend::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
   cl_int4 val0 = {0, 0, 0, 0};
-  GPUFailedMsg(clEnqueueFillBuffer(mInternals->command_queue[_xyz.x.stream], mInternals->mem_gpu, &val0, sizeof(val0), (char*)ptr - (char*)mDeviceMemoryBase, (size + sizeof(val0) - 1) & ~(sizeof(val0) - 1), _xyz.z.evList == nullptr ? 0 : _xyz.z.nEvents, _xyz.z.evList->getEventList<cl_event>(), _xyz.z.ev->getEventList<cl_event>()));
+  GPUChkErr(clEnqueueFillBuffer(mInternals->command_queue[_xyz.x.stream], mInternals->mem_gpu, &val0, sizeof(val0), (char*)ptr - (char*)mDeviceMemoryBase, (size + sizeof(val0) - 1) & ~(sizeof(val0) - 1), _xyz.z.evList == nullptr ? 0 : _xyz.z.nEvents, _xyz.z.evList->getEventList<cl_event>(), _xyz.z.ev->getEventList<cl_event>()));
 }
 
 template <class T, int32_t I, typename... Args>
@@ -28,7 +28,7 @@ inline void GPUReconstructionOCLBackend::runKernelBackendInternal(const krnlSetu
   auto& x = _xyz.x;
   auto& y = _xyz.y;
   auto& z = _xyz.z;
-  GPUFailedMsg(OCLsetKernelParameters(k, mInternals->mem_gpu, mInternals->mem_constant, y.index, args...));
+  GPUChkErr(OCLsetKernelParameters(k, mInternals->mem_gpu, mInternals->mem_constant, y.index, args...));
 
   cl_event ev;
   cl_event* evr;
@@ -39,15 +39,15 @@ inline void GPUReconstructionOCLBackend::runKernelBackendInternal(const krnlSetu
   } else {
     evr = (cl_event*)z.ev;
   }
-  GPUFailedMsg(clExecuteKernelA(mInternals->command_queue[x.stream], k, x.nThreads, x.nThreads * x.nBlocks, evr, (cl_event*)z.evList, z.nEvents));
+  GPUChkErr(clExecuteKernelA(mInternals->command_queue[x.stream], k, x.nThreads, x.nThreads * x.nBlocks, evr, (cl_event*)z.evList, z.nEvents));
   if (mProcessingSettings.deviceTimers && mProcessingSettings.debugLevel > 0) {
     cl_ulong time_start, time_end;
-    GPUFailedMsg(clWaitForEvents(1, evr));
-    GPUFailedMsg(clGetEventProfilingInfo(*evr, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, nullptr));
-    GPUFailedMsg(clGetEventProfilingInfo(*evr, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, nullptr));
+    GPUChkErr(clWaitForEvents(1, evr));
+    GPUChkErr(clGetEventProfilingInfo(*evr, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, nullptr));
+    GPUChkErr(clGetEventProfilingInfo(*evr, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, nullptr));
     _xyz.t = (time_end - time_start) * 1.e-9f;
     if (tmpEvent) {
-      GPUFailedMsg(clReleaseEvent(ev));
+      GPUChkErr(clReleaseEvent(ev));
     }
   }
 }
@@ -80,7 +80,7 @@ int32_t GPUReconstructionOCLBackend::AddKernel()
 
   cl_int ocl_error;
   cl_kernel krnl = clCreateKernel(mInternals->program, kname.c_str(), &ocl_error);
-  if (GPUFailedMsgI(ocl_error)) {
+  if (GPUChkErrI(ocl_error)) {
     GPUError("Error creating OPENCL Kernel: %s", name.c_str());
     return 1;
   }

From 2fef8797a1b38b4fa1fbb7316481b8bc3062db10 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 14 Mar 2025 14:52:53 +0100
Subject: [PATCH 0070/1764] Fix compiler warning

---
 Generators/src/GeneratorFromFile.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Generators/src/GeneratorFromFile.cxx b/Generators/src/GeneratorFromFile.cxx
index 6d4e85afa6721..e37a3886c24e1 100644
--- a/Generators/src/GeneratorFromFile.cxx
+++ b/Generators/src/GeneratorFromFile.cxx
@@ -361,7 +361,7 @@ namespace
 std::vector<std::string> executeCommand(const std::string& command)
 {
   std::vector<std::string> result;
-  std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(command.c_str(), "r"), pclose);
+  std::unique_ptr<FILE, int (*)(FILE*)> pipe(popen(command.c_str(), "r"), pclose);
   if (!pipe) {
     throw std::runtime_error("Failed to open pipe");
   }

From 20f1352fa03206c836a48dcb3089a9db1a526f68 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 14 Mar 2025 15:06:29 +0100
Subject: [PATCH 0071/1764] GPU: Clean up more of C++ < 11 compatibility code

---
 GPU/GPUTracking/Base/GPUConstantMem.h         |  2 +-
 GPU/GPUTracking/Base/GPUGeneralKernels.h      |  6 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |  4 +-
 .../Base/GPUReconstructionKernels.h           |  8 +--
 GPU/GPUTracking/DataTypes/GPUDataTypes.h      | 60 ++++++++-----------
 GPU/GPUTracking/Global/GPUChain.cxx           | 12 ++--
 GPU/GPUTracking/Global/GPUChain.h             | 12 ++--
 .../SectorTracker/GPUTPCCreateTrackingData.h  |  2 +-
 .../GPUTPCExtrapolationTracking.h             |  4 +-
 .../SectorTracker/GPUTPCNeighboursCleaner.h   |  2 +-
 .../SectorTracker/GPUTPCNeighboursFinder.h    |  2 +-
 .../SectorTracker/GPUTPCStartHitsFinder.h     |  2 +-
 .../SectorTracker/GPUTPCStartHitsSorter.h     |  2 +-
 .../SectorTracker/GPUTPCTrackletConstructor.h |  2 +-
 .../SectorTracker/GPUTPCTrackletSelector.h    |  2 +-
 .../TRDTracking/GPUTRDTrackerKernels.h        |  2 +-
 16 files changed, 58 insertions(+), 66 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUConstantMem.h b/GPU/GPUTracking/Base/GPUConstantMem.h
index 8f1cc90f5ae93..e0b06f0a3ea55 100644
--- a/GPU/GPUTracking/Base/GPUConstantMem.h
+++ b/GPU/GPUTracking/Base/GPUConstantMem.h
@@ -96,7 +96,7 @@ static constexpr size_t gGPUConstantMemBufferSize = (sizeof(GPUConstantMem) + si
 #endif
 } // namespace o2::gpu
 #if defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM) && !defined(GPUCA_GPUCODE_HOSTONLY)
-GPUconstant() o2::gpu::GPUConstantMemCopyable gGPUConstantMemBuffer;
+GPUconstant() o2::gpu::GPUConstantMemCopyable gGPUConstantMemBuffer; // TODO: This should go into o2::gpu namespace, but then CUDA or HIP would not find the symbol
 #endif // GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM
 namespace o2::gpu
 {
diff --git a/GPU/GPUTracking/Base/GPUGeneralKernels.h b/GPU/GPUTracking/Base/GPUGeneralKernels.h
index 71980d38fdc9e..ce93e2e5eead8 100644
--- a/GPU/GPUTracking/Base/GPUGeneralKernels.h
+++ b/GPU/GPUTracking/Base/GPUGeneralKernels.h
@@ -79,7 +79,7 @@ class GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUConstantMem processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::NoRecoStep; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::NoRecoStep; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return &processors;
@@ -94,7 +94,7 @@ class GPUKernelTemplate
 class GPUMemClean16 : public GPUKernelTemplate
 {
  public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::NoRecoStep; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::NoRecoStep; }
   template <int32_t iKernel = defaultKernel>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors, GPUglobalref() void* ptr, uint64_t size);
 };
@@ -103,7 +103,7 @@ class GPUMemClean16 : public GPUKernelTemplate
 class GPUitoa : public GPUKernelTemplate
 {
  public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::NoRecoStep; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::NoRecoStep; }
   template <int32_t iKernel = defaultKernel>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors, GPUglobalref() int32_t* ptr, uint64_t size);
 };
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index f90820281c74d..fd999ec2304e1 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -134,8 +134,8 @@ template <class S, int32_t I, typename... Args>
 inline void GPUReconstructionCPU::runKernel(krnlSetup&& setup, Args&&... args)
 {
   HighResTimer* t = nullptr;
-  GPUCA_RECO_STEP myStep = S::GetRecoStep() == GPUCA_RECO_STEP::NoRecoStep ? setup.x.step : S::GetRecoStep();
-  if (myStep == GPUCA_RECO_STEP::NoRecoStep) {
+  GPUDataTypes::RecoStep myStep = S::GetRecoStep() == GPUDataTypes::RecoStep::NoRecoStep ? setup.x.step : S::GetRecoStep();
+  if (myStep == GPUDataTypes::RecoStep::NoRecoStep) {
     throw std::runtime_error("Failure running general kernel without defining RecoStep");
   }
   int32_t cpuFallback = IsGPU() ? (setup.x.device == krnlDeviceType::CPU ? 2 : (mRecoSteps.stepsGPUMask & myStep) != myStep) : 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernels.h b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
index ba30f38e902ad..b8f3e3746c743 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernels.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
@@ -30,14 +30,14 @@ struct classArgument {
 };
 
 struct krnlExec {
-  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto) : nBlocks(b), nThreads(t), stream(s), device(d), step(GPUCA_RECO_STEP::NoRecoStep) {}
-  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUCA_RECO_STEP st) : nBlocks(b), nThreads(t), stream(s), device(GPUReconstruction::krnlDeviceType::Auto), step(st) {}
-  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d, GPUCA_RECO_STEP st) : nBlocks(b), nThreads(t), stream(s), device(d), step(st) {}
+  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto) : nBlocks(b), nThreads(t), stream(s), device(d), step(GPUDataTypes::RecoStep::NoRecoStep) {}
+  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUDataTypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(GPUReconstruction::krnlDeviceType::Auto), step(st) {}
+  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(d), step(st) {}
   uint32_t nBlocks;
   uint32_t nThreads;
   int32_t stream;
   GPUReconstruction::krnlDeviceType device;
-  GPUCA_RECO_STEP step;
+  GPUDataTypes::RecoStep step;
 };
 struct krnlRunRange {
   constexpr krnlRunRange() = default;
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.h b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
index f7bfe38be988d..6cc1e7266e722 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
@@ -96,9 +96,6 @@ struct TPCPadGainCalib;
 struct TPCZSLinkMapping;
 
 #include "utils/bitfield.h"
-#define ENUM_CLASS class
-#define ENUM_UINT : uint32_t
-#define GPUCA_RECO_STEP GPUDataTypes::RecoStep
 
 class GPUTPCTrack;
 class GPUTPCHitId;
@@ -117,36 +114,33 @@ struct GPUSettingsTF;
 class GPUDataTypes
 {
  public:
-  enum ENUM_CLASS GeometryType ENUM_UINT{RESERVED_GEOMETRY = 0, ALIROOT = 1, O2 = 2};
-  enum DeviceType ENUM_UINT { INVALID_DEVICE = 0,
-                              CPU = 1,
-                              CUDA = 2,
-                              HIP = 3,
-                              OCL = 4 };
-  enum ENUM_CLASS GeneralStep { Prepare = 1,
-                                QA = 2 };
+  // clang-format off
+  enum class GeometryType : uint32_t { RESERVED_GEOMETRY = 0, ALIROOT = 1, O2 = 2 };
+  enum DeviceType : uint32_t { INVALID_DEVICE = 0, CPU = 1, CUDA = 2, HIP = 3, OCL = 4 };
+  enum class GeneralStep { Prepare = 1, QA = 2 };
+  // clang-format on
 
-  enum ENUM_CLASS RecoStep { TPCConversion = 1,
-                             TPCSectorTracking = 2,
-                             TPCMerging = 4,
-                             TPCCompression = 8,
-                             TRDTracking = 16,
-                             ITSTracking = 32,
-                             TPCdEdx = 64,
-                             TPCClusterFinding = 128,
-                             TPCDecompression = 256,
-                             Refit = 512,
-                             AllRecoSteps = 0x7FFFFFFF,
-                             NoRecoStep = 0 };
-  enum ENUM_CLASS InOutType { TPCClusters = 1,
-                              OBSOLETE = 2,
-                              TPCMergedTracks = 4,
-                              TPCCompressedClusters = 8,
-                              TRDTracklets = 16,
-                              TRDTracks = 32,
-                              TPCRaw = 64,
-                              ITSClusters = 128,
-                              ITSTracks = 256 };
+  enum class RecoStep { TPCConversion = 1,
+                        TPCSectorTracking = 2,
+                        TPCMerging = 4,
+                        TPCCompression = 8,
+                        TRDTracking = 16,
+                        ITSTracking = 32,
+                        TPCdEdx = 64,
+                        TPCClusterFinding = 128,
+                        TPCDecompression = 256,
+                        Refit = 512,
+                        AllRecoSteps = 0x7FFFFFFF,
+                        NoRecoStep = 0 };
+  enum class InOutType { TPCClusters = 1,
+                         OBSOLETE = 2,
+                         TPCMergedTracks = 4,
+                         TPCCompressedClusters = 8,
+                         TRDTracklets = 16,
+                         TRDTracks = 32,
+                         TPCRaw = 64,
+                         ITSClusters = 128,
+                         ITSTracks = 256 };
 #ifndef __OPENCL__
   static constexpr const char* const DEVICE_TYPE_NAMES[] = {"INVALID", "CPU", "CUDA", "HIP", "OCL"};
   static constexpr const char* const RECO_STEP_NAMES[] = {"TPC Transformation", "TPC Sector Tracking", "TPC Track Merging and Fit", "TPC Compression", "TRD Tracking", "ITS Tracking", "TPC dEdx Computation", "TPC Cluster Finding", "TPC Decompression", "Global Refit"};
@@ -312,8 +306,6 @@ struct GPUTrackingInOutPointers {
   const GPUSettingsTF* settingsTF = nullptr;
 };
 
-#undef ENUM_CLASS
-#undef ENUM_UINT
 } // namespace o2::gpu
 
 #endif
diff --git a/GPU/GPUTracking/Global/GPUChain.cxx b/GPU/GPUTracking/Global/GPUChain.cxx
index 6990d5e08b638..300de31a509ba 100644
--- a/GPU/GPUTracking/Global/GPUChain.cxx
+++ b/GPU/GPUTracking/Global/GPUChain.cxx
@@ -18,33 +18,33 @@ using namespace o2::gpu;
 constexpr GPUChain::krnlRunRange GPUChain::krnlRunRangeNone;
 constexpr GPUChain::krnlEvent GPUChain::krnlEventNone;
 
-GPUChain::krnlExec GPUChain::GetGrid(uint32_t totalItems, uint32_t nThreads, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUCA_RECO_STEP st)
+GPUChain::krnlExec GPUChain::GetGrid(uint32_t totalItems, uint32_t nThreads, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st)
 {
   const uint32_t nBlocks = (totalItems + nThreads - 1) / nThreads;
   return {nBlocks, nThreads, stream, d, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGrid(uint32_t totalItems, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUCA_RECO_STEP st)
+GPUChain::krnlExec GPUChain::GetGrid(uint32_t totalItems, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st)
 {
   return {(uint32_t)-1, totalItems, stream, d, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGridBlk(uint32_t nBlocks, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUCA_RECO_STEP st)
+GPUChain::krnlExec GPUChain::GetGridBlk(uint32_t nBlocks, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st)
 {
   return {(uint32_t)-2, nBlocks, stream, d, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGridBlkStep(uint32_t nBlocks, int32_t stream, GPUCA_RECO_STEP st)
+GPUChain::krnlExec GPUChain::GetGridBlkStep(uint32_t nBlocks, int32_t stream, GPUDataTypes::RecoStep st)
 {
   return {(uint32_t)-2, nBlocks, stream, GPUReconstruction::krnlDeviceType::Auto, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d, GPUCA_RECO_STEP st)
+GPUChain::krnlExec GPUChain::GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st)
 {
   return {(uint32_t)-3, 0, stream, d, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGridAutoStep(int32_t stream, GPUCA_RECO_STEP st)
+GPUChain::krnlExec GPUChain::GetGridAutoStep(int32_t stream, GPUDataTypes::RecoStep st)
 {
   return {(uint32_t)-3, 0, stream, GPUReconstruction::krnlDeviceType::Auto, st};
 }
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index b9da1c9a330d3..fff5d2efe0270 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -192,15 +192,15 @@ class GPUChain
     return mRec->getTimer<T, J>(name, num);
   }
   // Get GRID with NBLOCKS minimal such that nThreads * NBLOCS >= totalItems
-  krnlExec GetGrid(uint32_t totalItems, uint32_t nThreads, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUCA_RECO_STEP st = GPUCA_RECO_STEP::NoRecoStep);
+  krnlExec GetGrid(uint32_t totalItems, uint32_t nThreads, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
   // Get GRID with NBLOCKS minimal such that ideal number of threads * NBLOCKS >= totalItems
-  krnlExec GetGrid(uint32_t totalItems, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUCA_RECO_STEP st = GPUCA_RECO_STEP::NoRecoStep);
+  krnlExec GetGrid(uint32_t totalItems, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
   // Get GRID with specified number of blocks, each block with ideal number of threads
-  krnlExec GetGridBlk(uint32_t nBlocks, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUCA_RECO_STEP st = GPUCA_RECO_STEP::NoRecoStep);
-  krnlExec GetGridBlkStep(uint32_t nBlocks, int32_t stream, GPUCA_RECO_STEP st = GPUCA_RECO_STEP::NoRecoStep);
+  krnlExec GetGridBlk(uint32_t nBlocks, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
+  krnlExec GetGridBlkStep(uint32_t nBlocks, int32_t stream, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
   // Get GRID with ideal number of threads / blocks for GPU
-  krnlExec GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUCA_RECO_STEP st = GPUCA_RECO_STEP::NoRecoStep);
-  krnlExec GetGridAutoStep(int32_t stream, GPUCA_RECO_STEP st = GPUCA_RECO_STEP::NoRecoStep);
+  krnlExec GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
+  krnlExec GetGridAutoStep(int32_t stream, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
 
   inline uint32_t BlockCount() const { return mRec->mBlockCount; }
   inline uint32_t WarpSize() const { return mRec->mWarpSize; }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCCreateTrackingData.h b/GPU/GPUTracking/SectorTracker/GPUTPCCreateTrackingData.h
index 9327699c9404b..dc1beacf79d02 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCCreateTrackingData.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCCreateTrackingData.h
@@ -32,7 +32,7 @@ class GPUTPCCreateTrackingData : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
index 2d2b275d06399..91a33d132f136 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
@@ -30,7 +30,7 @@ class GPUTPCExtrapolationTracking : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
@@ -50,7 +50,7 @@ class GPUTPCExtrapolationTrackingCopyNumbers : public GPUKernelTemplate
 {
  public:
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
index 7af6e8eb1a582..de79b268aea78 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
@@ -38,7 +38,7 @@ class GPUTPCNeighboursCleaner : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
index 54dc0876f8a55..41b5eb8a4ffb8 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
@@ -49,7 +49,7 @@ class GPUTPCNeighboursFinder : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
index 5e620180570c8..c834b17369f0f 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
@@ -38,7 +38,7 @@ class GPUTPCStartHitsFinder : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
index b0349d660dbc1..0e2fd96dd2690 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
@@ -38,7 +38,7 @@ class GPUTPCStartHitsSorter : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
index 8757ed87072da..0f8314ee0fad4 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
@@ -97,7 +97,7 @@ class GPUTPCTrackletConstructor
   GPUd() static int32_t GPUTPCTrackletConstructorExtrapolationTracking(GPUconstantref() GPUTPCTracker& tracker, GPUsharedref() T& sMem, GPUTPCTrackParam& tParam, int32_t startrow, int32_t increment, int32_t iTracklet, calink* rowHits);
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
index bb969d866ef29..5009c672b030e 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
@@ -42,7 +42,7 @@ class GPUTPCTrackletSelector : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TPCSectorTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.h b/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.h
index 70b525420f294..21135ddc48dfa 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.h
@@ -26,7 +26,7 @@ class GPUTRDTrackerKernels : public GPUKernelTemplate
   enum K { defaultKernel = 0,
            gpuVersion = 0,
            o2Version = 1 };
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUCA_RECO_STEP::TRDTracking; }
+  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TRDTracking; }
   template <int32_t iKernel = defaultKernel, class T>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors, T* externalInstance = nullptr);
 };

From 315cfa4216eeda737371a8d4eac108b81e23d881 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 14 Mar 2025 15:06:57 +0100
Subject: [PATCH 0072/1764] GPU: Provide static versions of GPUChkErr() macros

test2

GPU: Provide static versions of GPUChkErr() macros
---
 GPU/Common/CMakeLists.txt                     |  2 +-
 GPU/Common/GPUCommonChkErr.h                  | 30 ---------
 GPU/Common/GPUCommonDef.h                     | 24 +++++--
 GPU/Common/GPUCommonHelpers.h                 | 62 +++++++++++++++++++
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  2 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        |  9 +--
 .../Base/cuda/GPUReconstructionCUDA.h         |  3 +-
 .../GPUReconstructionCUDAExternalProvider.cu  |  3 +-
 .../cuda/GPUReconstructionCUDAHelpers.inc     | 31 ++++++++++
 .../cuda/GPUReconstructionCUDAInternals.h     |  2 +-
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  4 +-
 .../Base/opencl/GPUReconstructionOCL.cxx      |  7 +--
 .../opencl/GPUReconstructionOCLIncludesHost.h |  2 +-
 14 files changed, 127 insertions(+), 56 deletions(-)
 delete mode 100644 GPU/Common/GPUCommonChkErr.h
 create mode 100644 GPU/Common/GPUCommonHelpers.h
 create mode 100644 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc

diff --git a/GPU/Common/CMakeLists.txt b/GPU/Common/CMakeLists.txt
index 8b0a75679479f..bacf4454c39fd 100644
--- a/GPU/Common/CMakeLists.txt
+++ b/GPU/Common/CMakeLists.txt
@@ -15,7 +15,7 @@ set(HDRS_INSTALL
     GPUCommonAlgorithm.h
     GPUCommonDef.h
     GPUCommonDefAPI.h
-    GPUCommonChkErr.h
+    GPUCommonHelpers.h
     GPUCommonDefSettings.h
     GPUCommonConstants.h
     GPUCommonLogger.h
diff --git a/GPU/Common/GPUCommonChkErr.h b/GPU/Common/GPUCommonChkErr.h
deleted file mode 100644
index 00cb9e50d302f..0000000000000
--- a/GPU/Common/GPUCommonChkErr.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUCommonChkErr.h
-/// \author David Rohr
-
-// GPUChkErr and GPUChkErrI will both check x for an error, using the loaded backend of GPUReconstruction (requiring GPUReconstruction.h to be included by the user).
-// In case of an error, it will print out the corresponding CUDA / HIP / OpenCL error code
-// GPUChkErr will download GPUReconstruction error values from GPU, print them, and terminate the application with an exception if an error occured.
-// GPUChkErrI will return 0 or 1, depending on whether an error has occurred.
-// The Macros must be called ona GPUReconstruction instance, e.g.:
-// if (mRec->GPUChkErrI(cudaMalloc(...))) { exit(1); }
-// gpuRecObj.GPUChkErr(cudaMalloc(...));
-
-#ifndef GPUCOMMONCHKERR_H
-#define GPUCOMMONCHKERR_H
-
-// Please #include "GPUReconstruction.h" in your code, if you use these 2!
-#define GPUChkErr(x) GPUChkErrA(x, __FILE__, __LINE__, true)
-#define GPUChkErrI(x) GPUChkErrA(x, __FILE__, __LINE__, false)
-
-#endif
diff --git a/GPU/Common/GPUCommonDef.h b/GPU/Common/GPUCommonDef.h
index ae8c48b500b69..b4a788e66a81c 100644
--- a/GPU/Common/GPUCommonDef.h
+++ b/GPU/Common/GPUCommonDef.h
@@ -35,13 +35,25 @@
     #define GPUCA_GPUCODE // Compiled by GPU compiler
   #endif
 
-  #if defined(__CUDA_ARCH__) || defined(__OPENCL__) || defined(__HIP_DEVICE_COMPILE__)
-    #define GPUCA_GPUCODE_DEVICE // Executed on device
+  #if defined(GPUCA_GPUCODE)
+    #if defined(__CUDA_ARCH__) || defined(__OPENCL__) || defined(__HIP_DEVICE_COMPILE__)
+      #define GPUCA_GPUCODE_DEVICE // Executed on device
+    #endif
+    #if defined(__CUDACC__)
+      #define GPUCA_GPUTYPE CUDA
+    #elif defined(__HIPCC__)
+      #define GPUCA_GPUTYPE HIP
+    #elif defined(__OPENCL__) || defined(__OPENCL_HOST__)
+      #define GPUCA_GPUTYPE OCL
+    #endif
   #endif
 #endif
+#ifndef GPUCA_GPUTYPE
+  #define GPUCA_GPUTYPE CPU
+#endif
 
 #if defined(GPUCA_STANDALONE) || (defined(GPUCA_O2_LIB) && !defined(GPUCA_O2_INTERFACE)) || defined (GPUCA_GPUCODE)
-  #define GPUCA_ALIGPUCODE
+  #define GPUCA_ALIGPUCODE // Part of GPUTracking library but not of interface
 #endif
 
 #if (defined(__CUDACC__) && defined(GPUCA_CUDA_NO_CONSTANT_MEMORY)) || (defined(__HIPCC__) && defined(GPUCA_HIP_NO_CONSTANT_MEMORY)) || (defined(__OPENCL__) && defined(GPUCA_OPENCL_NO_CONSTANT_MEMORY))
@@ -51,13 +63,13 @@
 #endif
 
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) && defined(DEBUG_STREAMER)
-#define GPUCA_DEBUG_STREAMER_CHECK(...) __VA_ARGS__
+  #define GPUCA_DEBUG_STREAMER_CHECK(...) __VA_ARGS__
 #else
-#define GPUCA_DEBUG_STREAMER_CHECK(...)
+  #define GPUCA_DEBUG_STREAMER_CHECK(...)
 #endif
 
 #ifndef GPUCA_RTC_SPECIAL_CODE
-#define GPUCA_RTC_SPECIAL_CODE(...)
+  #define GPUCA_RTC_SPECIAL_CODE(...)
 #endif
 
 // API Definitions for GPU Compilation
diff --git a/GPU/Common/GPUCommonHelpers.h b/GPU/Common/GPUCommonHelpers.h
new file mode 100644
index 0000000000000..ad876db0d6c3a
--- /dev/null
+++ b/GPU/Common/GPUCommonHelpers.h
@@ -0,0 +1,62 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUCommonHelpers.h
+/// \author David Rohr
+
+// GPUChkErr and GPUChkErrI will both check x for an error, using the loaded backend of GPUReconstruction (requiring GPUReconstruction.h to be included by the user).
+// In case of an error, it will print out the corresponding CUDA / HIP / OpenCL error code
+// GPUChkErr will download GPUReconstruction error values from GPU, print them, and terminate the application with an exception if an error occured.
+// GPUChkErrI will return 0 or 1, depending on whether an error has occurred.
+// These Macros must be called ona GPUReconstruction instance.
+// The GPUChkErrS and GPUChkErrSI are similar but static, without required GPUReconstruction instance.
+// Examples:
+// if (mRec->GPUChkErrI(cudaMalloc(...))) { exit(1); }
+// gpuRecObj.GPUChkErr(cudaMalloc(...));
+// if (GPUChkErrSI(cudaMalloc(..))) { exit(1); }
+
+#ifndef GPUCOMMONHELPERS_H
+#define GPUCOMMONHELPERS_H
+
+// Please #include "GPUReconstruction.h" in your code, if you use these 2!
+#define GPUChkErr(x) GPUChkErrA(x, __FILE__, __LINE__, true)
+#define GPUChkErrI(x) GPUChkErrA(x, __FILE__, __LINE__, false)
+#define GPUChkErrS(x) o2::gpu::internal::GPUReconstructionChkErr(x, __FILE__, __LINE__, true)
+#define GPUChkErrSI(x) o2::gpu::internal::GPUReconstructionChkErr(x, __FILE__, __LINE__, false)
+
+#include "GPUCommonDef.h"
+#include <cstdint>
+
+namespace o2::gpu::internal
+{
+#define GPUCOMMON_INTERNAL_CAT_A(a, b, c) a##b##c
+#define GPUCOMMON_INTERNAL_CAT(...) GPUCOMMON_INTERNAL_CAT_A(__VA_ARGS__)
+extern int32_t GPUCOMMON_INTERNAL_CAT(GPUReconstruction, GPUCA_GPUTYPE, ChkErr)(const int64_t error, const char* file, int32_t line);
+inline int32_t GPUReconstructionCPUChkErr(const int64_t error, const char* file, int32_t line)
+{
+  if (error) {
+    GPUError("GPUCommon Error Code %d (%s:%d)", error, file, line);
+  }
+  return error != 0;
+}
+static inline int32_t GPUReconstructionChkErr(const int64_t error, const char* file, int32_t line, bool failOnError)
+{
+  int32_t retVal = error && GPUCOMMON_INTERNAL_CAT(GPUReconstruction, GPUCA_GPUTYPE, ChkErr)(error, file, line);
+  if (retVal && failOnError) {
+    throw std::runtime_error("GPU API Call Failure");
+  }
+  return error;
+}
+#undef GPUCOMMON_INTERNAL_CAT_A
+#undef GPUCOMMON_INTERNAL_CAT
+} // namespace o2::gpu::internal
+
+#endif
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index a33234db49a27..5b2e53179e50c 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -18,7 +18,7 @@ endif()
 message(STATUS "Building GPUTracking with CUDA support ${TMP_TARGET}")
 
 set(SRCS GPUReconstructionCUDA.cu GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu)
-set(HDRS GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDADef.h GPUReconstructionCUDAIncludesHost.h CUDAThrustHelpers.h)
+set(HDRS GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDADef.h GPUReconstructionCUDAIncludesHost.h CUDAThrustHelpers.h)
 # -------------------------------- Prepare RTC -------------------------------------------------------
 enable_language(ASM)
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index d30eb51bd4938..d0d5ef4680fac 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -22,6 +22,7 @@
 #include "CUDAThrustHelpers.h"
 #include "GPUReconstructionIncludes.h"
 #include "GPUParamRTC.h"
+#include "GPUReconstructionCUDAHelpers.inc"
 
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1
 #include "utils/qGetLdBinarySymbols.h"
@@ -62,13 +63,9 @@ GPUReconstructionCUDABackend::~GPUReconstructionCUDABackend()
 }
 
 static_assert(sizeof(cudaError_t) <= sizeof(int64_t) && cudaSuccess == 0);
-int32_t GPUReconstructionCUDABackend::GPUChkErrStatic(const int64_t error, const char* file, int32_t line)
+int32_t GPUReconstructionCUDABackend::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
 {
-  if (error == cudaSuccess) {
-    return (0);
-  }
-  GPUError("CUDA Error: %ld / %s (%s:%d)", error, cudaGetErrorString((cudaError_t)error), file, line);
-  return 1;
+  return internal::GPUReconstructionCUDAChkErr(error, file, line);
 }
 
 GPUReconstructionCUDA::GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionKernels(cfg)
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 02e8f92bb2328..f78270d40146c 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -33,13 +33,12 @@ class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
 {
  public:
   ~GPUReconstructionCUDABackend() override;
-  static int32_t GPUChkErrStatic(const int64_t error, const char* file, int32_t line);
 
  protected:
   GPUReconstructionCUDABackend(const GPUSettingsDeviceBackend& cfg);
 
   void PrintKernelOccupancies() override;
-  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override { return GPUChkErrStatic(error, file, line); }
+  virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override;
 
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
index bc1d573385598..f341a778076b8 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
@@ -32,11 +32,12 @@ using namespace o2::gpu;
 #include "TrackParametrizationWithError.cxx"
 #include "Propagator.cxx"
 #include "TrackLTIntegral.cxx"
+#include "GPUReconstructionCUDAHelpers.inc"
 
 #ifndef GPUCA_NO_CONSTANT_MEMORY
 static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstSymbol([]() {
   void* retVal = nullptr;
-  if (GPUReconstructionCUDA::GPUChkErrStatic(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer), __FILE__, __LINE__)) {
+  if (GPUChkErrS(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer))) {
     throw std::runtime_error("Could not obtain GPU constant memory symbol");
   }
   return retVal;
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc
new file mode 100644
index 0000000000000..a34f940a1337a
--- /dev/null
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc
@@ -0,0 +1,31 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUReconstructionCUDAHelpers.inc
+/// \author David Rohr
+
+#ifndef GPURECONSTRUCTIONCUDAHELPERS_INC_H
+#define GPURECONSTRUCTIONCUDAHELPERS_INC_H
+
+#include "GPUCommonHelpers.h"
+
+namespace o2::gpu::internal
+{
+int32_t __attribute__((weak)) GPUReconstructionCUDAChkErr(const int64_t error, const char* file, int32_t line)
+{
+  if (error != cudaSuccess) {
+    GPUError("CUDA Error: %ld / %s (%s:%d)", error, cudaGetErrorString((cudaError_t)error), file, line);
+  }
+  return error != cudaSuccess;
+}
+} // namespace o2::gpu::internal
+
+#endif
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
index 027a9d5445b2c..c85d98d85420e 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
@@ -22,7 +22,7 @@
 #include <vector>
 #include <memory>
 #include <string>
-#include "GPUCommonChkErr.h"
+#include "GPUCommonHelpers.h"
 
 namespace o2::gpu
 {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index f60f00c13710d..0c83223ba238a 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -138,7 +138,7 @@ void GPUReconstructionCUDABackend::getRTCKernelCalls(std::vector<std::string>& k
 #ifndef GPUCA_NO_CONSTANT_MEMORY
 static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstSymbol([]() {
   void* retVal = nullptr;
-  if (GPUReconstructionCUDA::GPUChkErrStatic(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer), __FILE__, __LINE__)) {
+  if (GPUChkErrS(cudaGetSymbolAddress(&retVal, gGPUConstantMemBuffer))) {
     throw std::runtime_error("Could not obtain GPU constant memory symbol");
   }
   return retVal;
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 30f6683ff93c5..21a641c0cc7c0 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -24,7 +24,7 @@ message(STATUS "Building GPUTracking with HIP support ${TMP_TARGET}")
 if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   set(GPUCA_HIP_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/hipify)
   file(MAKE_DIRECTORY ${GPUCA_HIP_SOURCE_DIR})
-  set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAkernel.template.cu CUDAThrustHelpers.h GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDArtc.cu)
+  set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDAkernel.template.cu CUDAThrustHelpers.h GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDArtc.cu)
   set(GPUCA_HIP_LOCAL_FILE_LIST GPUReconstructionHIPIncludesHost.h)
   set(HIP_SOURCES "")
   foreach(file ${GPUCA_HIP_FILE_LIST})
@@ -63,7 +63,7 @@ endif()
 
 set(SRCS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.hip ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPKernels.hip)
 set(SRCS_CXX ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPGenRTC.cxx)
-set(HDRS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPInternals.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPDef.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPIncludesHost.h ${GPUCA_HIP_SOURCE_DIR}/HIPThrustHelpers.h)
+set(HDRS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPInternals.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPHelpers.inc ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPDef.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPIncludesHost.h ${GPUCA_HIP_SOURCE_DIR}/HIPThrustHelpers.h)
 
 # -------------------------------- Prepare RTC -------------------------------------------------------
 enable_language(ASM)
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index e52494937f8bf..e92205b9864e6 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -52,11 +52,10 @@ static_assert(sizeof(cl_int) <= sizeof(int64_t) && CL_SUCCESS == 0);
 int32_t GPUReconstructionOCLBackend::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
 {
   // Check for OPENCL Error and in the case of an error display the corresponding error string
-  if (error == CL_SUCCESS) {
-    return (0);
+  if (error != CL_SUCCESS) {
+    GPUError("OpenCL Error: %ld / %s (%s:%d)", error, convertErrorToString(error), file, line);
   }
-  GPUError("OpenCL Error: %ld / %s (%s:%d)", error, convertErrorToString(error), file, line);
-  return 1;
+  return error != CL_SUCCESS;
 }
 
 void GPUReconstructionOCLBackend::UpdateAutomaticProcessingSettings()
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
index 9c8cdbe87c7c1..97316cf9aa32e 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
@@ -28,7 +28,7 @@
 
 #include "GPUReconstructionOCL.h"
 #include "GPUReconstructionIncludes.h"
-#include "GPUCommonChkErr.h"
+#include "GPUCommonHelpers.h"
 
 using namespace o2::gpu;
 

From b8feb4d10f27015e45df85ec17cba5758ad523a5 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 14 Mar 2025 16:15:23 +0100
Subject: [PATCH 0073/1764] GPU: Automatically derive GPUReconstruction backend
 class from preprocessor constant

---
 GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h      | 4 ++--
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDADef.h      | 1 -
 .../Base/opencl/GPUReconstructionOCLKernels.cxx           | 1 -
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx                 | 8 ++++----
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx               | 2 +-
 5 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
index cd1180cbc9991..0b1a501ebc094 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
@@ -68,7 +68,7 @@
 // GPU Host wrappers for kernel
 #define GPUCA_KRNL_HOST(x_class, ...) \
   GPUCA_KRNLGPU(x_class, __VA_ARGS__) \
-  template <> class GPUCA_KRNL_BACKEND_CLASS::backendInternal<GPUCA_M_KRNL_TEMPLATE(x_class)> { \
+  template <> class GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::backendInternal<GPUCA_M_KRNL_TEMPLATE(x_class)> { \
    public: \
     template <typename T, typename... Args> \
     static inline void runKernelBackendMacro(const krnlSetupTime& _xyz, T* me, const Args&... args) \
@@ -80,7 +80,7 @@
   };
 
 #define GPUCA_KRNL_PROP(x_class, x_attributes) \
-  template <> gpu_reconstruction_kernels::krnlProperties GPUCA_KRNL_BACKEND_CLASS::getKernelPropertiesBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>() { \
+  template <> gpu_reconstruction_kernels::krnlProperties GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::getKernelPropertiesBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>() { \
     gpu_reconstruction_kernels::krnlProperties ret = gpu_reconstruction_kernels::krnlProperties{GPUCA_ATTRRES(_EXTRREG, GPUCA_M_STRIP(x_attributes))}; \
     return ret.nThreads > 0 ? ret : gpu_reconstruction_kernels::krnlProperties{(int32_t)mThreadCount}; \
   }
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDADef.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDADef.h
index 7f77925ca3aaa..4ed352279fb90 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDADef.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDADef.h
@@ -34,6 +34,5 @@
 #define GPUCA_CONSMEM_CALL me->mDeviceConstantMem,
 #define GPUCA_CONSMEM ((GPUConstantMem&)(*gGPUConstantMemBuffer))
 #endif
-#define GPUCA_KRNL_BACKEND_CLASS GPUReconstructionCUDABackend
 
 #endif
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index 4f6a8725b4be5..ce6b6553ae1f7 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -109,6 +109,5 @@ int32_t GPUReconstructionOCLBackend::AddKernels()
 #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) \
   GPUCA_KRNL_PROP(x_class, x_attributes)                                   \
   template void GPUReconstructionOCLBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
-#define GPUCA_KRNL_BACKEND_CLASS GPUReconstructionOCLBackend
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index fa85d796baeba..e6312d767a496 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -769,7 +769,7 @@ struct MergeBorderTracks_compMin {
 } // namespace o2::gpu::internal
 
 template <>
-inline void GPUCA_KRNL_BACKEND_CLASS::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
+inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
 {
   thrust::device_ptr<GPUTPCGMBorderRange> p(range);
   ThrustVolatileAsyncAllocator alloc(this);
@@ -1873,7 +1873,7 @@ struct GPUTPCGMMergerSortTracksQPt_comp {
 } // namespace o2::gpu::internal
 
 template <>
-inline void GPUCA_KRNL_BACKEND_CLASS::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<uint32_t> trackSort((uint32_t*)mProcessorsShadow->tpcMerger.TrackOrderProcess());
   ThrustVolatileAsyncAllocator alloc(this);
@@ -1881,7 +1881,7 @@ inline void GPUCA_KRNL_BACKEND_CLASS::runKernelBackendInternal<GPUTPCGMMergerSor
 }
 
 template <>
-inline void GPUCA_KRNL_BACKEND_CLASS::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<uint32_t> trackSort((uint32_t*)mProcessorsShadow->tpcMerger.TrackSort());
   ThrustVolatileAsyncAllocator alloc(this);
@@ -2106,7 +2106,7 @@ struct GPUTPCGMMergerMergeLoopers_comp {
 } // namespace o2::gpu::internal
 
 template <>
-inline void GPUCA_KRNL_BACKEND_CLASS::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<MergeLooperParam> params(mProcessorsShadow->tpcMerger.LooperCandidates());
   ThrustVolatileAsyncAllocator alloc(this);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 45293bae9820b..13f204d0f940a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -102,7 +102,7 @@ struct GPUTPCGMO2OutputSort_comp {
 };
 
 template <>
-inline void GPUCA_KRNL_BACKEND_CLASS::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<GPUTPCGMMerger::tmpSort> trackSort(mProcessorsShadow->tpcMerger.TrackSortO2());
   ThrustVolatileAsyncAllocator alloc(this);

From 154ffd467127ab9eb92649e78cbd2fdfa90f6f68 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 14 Mar 2025 16:33:57 +0100
Subject: [PATCH 0074/1764] GPU: Plenty of clang-format fixes

---
 GPU/GPUTracking/Base/GPUParam.h               |  8 +--
 GPU/GPUTracking/Base/GPUReconstruction.h      |  4 +-
 .../Base/GPUReconstructionConvert.cxx         |  2 +-
 .../Base/GPUReconstructionProcessing.h        |  2 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        |  2 +-
 GPU/GPUTracking/DataTypes/GPUOutputControl.h  |  2 +-
 GPU/GPUTracking/DataTypes/GPUSettings.h       |  6 +-
 GPU/GPUTracking/DataTypes/GPUTRDTrack.h       |  6 +-
 GPU/GPUTracking/Global/GPUChain.h             |  2 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |  2 +-
 .../Global/GPUChainTrackingClusterizer.cxx    |  3 +-
 .../Global/GPUChainTrackingRefit.cxx          |  4 +-
 GPU/GPUTracking/Interface/GPUO2Interface.cxx  |  2 +-
 .../GPUO2InterfaceConfigurableParam.h         |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h  | 16 ++---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  6 +-
 .../Merger/GPUTPCGMPolynomialFieldManager.h   |  4 +-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx |  2 +-
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |  2 +-
 .../SectorTracker/GPUTPCTracklet.h            |  2 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     | 12 ++--
 .../GPUTPCCFNoiseSuppression.cxx              |  4 +-
 .../TRDTracking/GPUTRDInterfaces.h            |  4 +-
 GPU/GPUTracking/TRDTracking/GPUTRDTrackData.h | 18 +++---
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx | 24 ++++---
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.h   | 62 +++++++++----------
 .../TRDTracking/GPUTRDTrackletWord.h          |  2 +-
 .../display/frontend/GPUDisplayFrontend.h     |  8 +--
 .../frontend/GPUDisplayFrontendWindows.cxx    | 12 ++--
 GPU/GPUTracking/qa/GPUQAHelper.h              |  6 +-
 GPU/GPUTracking/qa/genEvents.h                |  2 +-
 GPU/GPUTracking/utils/qconfig.cxx             |  8 +--
 GPU/GPUTracking/utils/threadserver.h          |  4 +-
 GPU/GPUbenchmark/cuda/Kernels.cu              |  6 +-
 GPU/TPCFastTransformation/BandMatrixSolver.h  |  2 +-
 GPU/TPCFastTransformation/ChebyshevFit1D.cxx  |  4 +-
 .../CorrectionMapsHelper.h                    | 28 ++++-----
 .../NDPiecewisePolynomials.h                  | 14 ++---
 GPU/TPCFastTransformation/Spline1DHelper.cxx  |  8 +--
 GPU/TPCFastTransformation/Spline1DHelperOld.h | 20 +++---
 GPU/TPCFastTransformation/Spline1DSpec.cxx    |  2 +-
 GPU/TPCFastTransformation/Spline1DSpec.h      | 12 ++--
 GPU/TPCFastTransformation/Spline2DSpec.cxx    |  2 +-
 GPU/TPCFastTransformation/SplineHelper.cxx    | 44 ++++++-------
 GPU/TPCFastTransformation/SplineHelper.h      |  6 +-
 GPU/TPCFastTransformation/SplineSpec.h        | 14 ++---
 .../TPCFastSpaceChargeCorrection.h            |  2 +-
 .../IrregularSpline2D3DCalibrator.cxx         |  2 +-
 .../devtools/RegularSpline1D.h                | 12 ++--
 .../devtools/SemiregularSpline2D3D.cxx        |  8 +--
 .../devtools/SemiregularSpline2D3D.h          | 32 +++++-----
 .../test/testMultivarPolynomials.cxx          |  4 +-
 GPU/Utils/FlatObject.h                        | 12 ++--
 GPU/Workflow/helper/src/GPUWorkflowHelper.cxx | 26 ++++----
 54 files changed, 250 insertions(+), 255 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 9bdf705dfeb59..fbce6246de112 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -59,10 +59,10 @@ struct GPUParam_t {
   int32_t continuousMaxTimeBin;
   int32_t tpcCutTimeBin;
 
-  GPUTPCGeometry tpcGeometry;                       // TPC Geometry
-  GPUTPCGMPolynomialField polynomialField;          // Polynomial approx. of magnetic field for TPC GM
-  const uint32_t* occupancyMap;                     // Ptr to TPC occupancy map
-  uint32_t occupancyTotal;                          // Total occupancy in the TPC (nCl / nHbf)
+  GPUTPCGeometry tpcGeometry;              // TPC Geometry
+  GPUTPCGMPolynomialField polynomialField; // Polynomial approx. of magnetic field for TPC GM
+  const uint32_t* occupancyMap;            // Ptr to TPC occupancy map
+  uint32_t occupancyTotal;                 // Total occupancy in the TPC (nCl / nHbf)
 
   GPUParamSector SectorParam[GPUCA_NSECTORS];
 
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index f363f3f58aa6f..5e03c77f08230 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -52,7 +52,7 @@ namespace gpu_reconstruction_kernels
 {
 struct deviceEvent;
 class threadContext;
-}
+} // namespace gpu_reconstruction_kernels
 
 class GPUReconstruction
 {
@@ -193,7 +193,7 @@ class GPUReconstruction
   bool IsInitialized() const { return mInitialized; }
   void SetSettings(float solenoidBzNominalGPU, const GPURecoStepConfiguration* workflow = nullptr);
   void SetSettings(const GPUSettingsGRP* grp, const GPUSettingsRec* rec = nullptr, const GPUSettingsProcessing* proc = nullptr, const GPURecoStepConfiguration* workflow = nullptr);
-  void SetResetTimers(bool reset) { mProcessingSettings.resetTimers = reset; } // May update also after Init()
+  void SetResetTimers(bool reset) { mProcessingSettings.resetTimers = reset; }     // May update also after Init()
   void SetDebugLevelTmp(int32_t level) { mProcessingSettings.debugLevel = level; } // Temporarily, before calling SetSettings()
   void UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p = nullptr, const GPUSettingsRecDynamic* d = nullptr);
   void UpdateDynamicSettings(const GPUSettingsRecDynamic* d);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
index 8f5cab6807050..bc760f6188caa 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
@@ -923,7 +923,7 @@ void zsEncoderDenseLinkBased::decodePage(std::vector<o2::tpc::Digit>& outputBuff
       if (decLinkX & 0b00100000) {
         bitmaskL2.set();
       } else {
-        bitmaskL2 = std::bitset<10>(((((uint16_t)decLinkX) & 0b11000000) << 2) | (uint16_t) * ((const uint8_t*)decPagePtr));
+        bitmaskL2 = std::bitset<10>(((((uint16_t)decLinkX) & 0b11000000) << 2) | (uint16_t)*((const uint8_t*)decPagePtr));
         decPagePtr += sizeof(uint8_t);
       }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index 4ccfb9ff10311..43560616782db 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -28,7 +28,7 @@ namespace gpu_reconstruction_kernels
 {
 struct deviceEvent {
   constexpr deviceEvent() = default;
-  constexpr deviceEvent(std::nullptr_t p) : v(nullptr){};
+  constexpr deviceEvent(std::nullptr_t p) : v(nullptr) {};
   template <class T>
   void set(T val)
   {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index d0d5ef4680fac..202edd49bc44c 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -496,7 +496,7 @@ size_t GPUReconstructionCUDA::GPUMemCpy(void* dst, const void* src, size_t size,
     for (int32_t k = 0; k < nEvents; k++) {
       GPUChkErr(cudaStreamWaitEvent(mInternals->Streams[stream], evList[k].get<cudaEvent_t>(), 0));
     }
-    GPUChkErr(cudaMemcpyAsync(dst, src, size, toGPU == -2 ? cudaMemcpyDeviceToDevice : toGPU ? cudaMemcpyHostToDevice : cudaMemcpyDeviceToHost, mInternals->Streams[stream]));
+    GPUChkErr(cudaMemcpyAsync(dst, src, size, toGPU == -2 ? cudaMemcpyDeviceToDevice : (toGPU ? cudaMemcpyHostToDevice : cudaMemcpyDeviceToHost), mInternals->Streams[stream]));
   }
   if (ev) {
     GPUChkErr(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream == -1 ? 0 : stream]));
diff --git a/GPU/GPUTracking/DataTypes/GPUOutputControl.h b/GPU/GPUTracking/DataTypes/GPUOutputControl.h
index 799fd25330ab4..0495f7ed1d0ff 100644
--- a/GPU/GPUTracking/DataTypes/GPUOutputControl.h
+++ b/GPU/GPUTracking/DataTypes/GPUOutputControl.h
@@ -78,7 +78,7 @@ struct GPUTrackingOutputs {
   static constexpr size_t count() { return sizeof(GPUTrackingOutputs) / sizeof(GPUOutputControl); }
   GPUOutputControl* asArray() { return (GPUOutputControl*)this; }
   size_t getIndex(const GPUOutputControl& v) { return &v - (const GPUOutputControl*)this; }
-  static int32_t getIndex(GPUOutputControl GPUTrackingOutputs::*v) { return &(((GPUTrackingOutputs*)(0x10000))->*v) - (GPUOutputControl*)(0x10000); }
+  static int32_t getIndex(GPUOutputControl GPUTrackingOutputs::* v) { return &(((GPUTrackingOutputs*)(0x10000))->*v) - (GPUOutputControl*)(0x10000); }
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/DataTypes/GPUSettings.h b/GPU/GPUTracking/DataTypes/GPUSettings.h
index 05888770ef9e5..c81a8e20e9926 100644
--- a/GPU/GPUTracking/DataTypes/GPUSettings.h
+++ b/GPU/GPUTracking/DataTypes/GPUSettings.h
@@ -73,9 +73,9 @@ struct GPUSettingsTF {
 
 // Settings defining the setup of the GPUReconstruction processing (basically selecting the device / class instance)
 struct GPUSettingsDeviceBackend {
-  uint32_t deviceType = GPUDataTypes::DeviceType::CPU;     // Device type, shall use GPUDataTypes::DEVICE_TYPE constants, e.g. CPU / CUDA
-  uint8_t forceDeviceType = 1;                             // Fail if device initialization fails, otherwise falls back to CPU
-  GPUReconstruction* master = nullptr;                     // GPUReconstruction master object
+  uint32_t deviceType = GPUDataTypes::DeviceType::CPU; // Device type, shall use GPUDataTypes::DEVICE_TYPE constants, e.g. CPU / CUDA
+  uint8_t forceDeviceType = 1;                         // Fail if device initialization fails, otherwise falls back to CPU
+  GPUReconstruction* master = nullptr;                 // GPUReconstruction master object
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDTrack.h b/GPU/GPUTracking/DataTypes/GPUTRDTrack.h
index 18f7c61e01fc3..b358e8b82d480 100644
--- a/GPU/GPUTracking/DataTypes/GPUTRDTrack.h
+++ b/GPU/GPUTracking/DataTypes/GPUTRDTrack.h
@@ -107,9 +107,9 @@ class GPUTRDTrack_t : public T
   GPUd() void setHasPadrowCrossing() { mIsCrossingNeighbor |= (1U << 7); }
 
  protected:
-  float mChi2;                       // total chi2.
-  float mSignal{-1.f};               // electron Likelihood for track
-  uint32_t mRefGlobalTrackId;        // raw GlobalTrackID of the seeding track (either ITS-TPC or TPC)
+  float mChi2;                          // total chi2.
+  float mSignal{-1.f};                  // electron Likelihood for track
+  uint32_t mRefGlobalTrackId;           // raw GlobalTrackID of the seeding track (either ITS-TPC or TPC)
   int32_t mAttachedTracklets[kNLayers]; // indices of the tracklets attached to this track; -1 means no tracklet in that layer
   int16_t mCollisionId;                 // the collision ID of the tracklets attached to this track; is used to retrieve the BC information for this track after the tracking is done
   uint8_t mFlags;                       // bits 0 to 5 indicate whether track is findable in layer 0 to 5, bit 6 indicates an ambiguous track and bit 7 flags if the track is stopped in the TRD
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index fff5d2efe0270..290ae32cafca8 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -46,7 +46,7 @@ class GPUChain
   virtual int32_t Finalize() = 0;
   virtual int32_t RunChain() = 0;
   virtual void MemorySize(size_t& gpuMem, size_t& pageLockedHostMem) = 0;
-  virtual void PrintMemoryStatistics(){};
+  virtual void PrintMemoryStatistics() {};
   virtual int32_t CheckErrorCodes(bool cpuOnly = false, bool forceShowErrors = false, std::vector<std::array<uint32_t, 4>>* fillErrors = nullptr) { return 0; }
   virtual bool SupportsDoublePipeline() { return false; }
   virtual int32_t FinalizePipelinedProcessing() { return 0; }
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 492ee65d1c9c1..5779cec31130c 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -43,7 +43,7 @@ class MatLayerCylSet;
 
 namespace o2::gpu
 {
-//class GPUTRDTrackerGPU;
+// class GPUTRDTrackerGPU;
 class GPUTPCGPUTracker;
 class GPUDisplayInterface;
 class GPUQA;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 63d56da37595b..a48050a6cacbc 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -154,8 +154,7 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCount(uint
   uint32_t endpointAdcSamples[GPUTrackingInOutZS::NENDPOINTS];
   memset(endpointAdcSamples, 0, sizeof(endpointAdcSamples));
   bool doGPU = mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding;
-  int32_t firstHBF = (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasTfStartOrbit) ? mIOPtrs.settingsTF->tfStartOrbit : (mIOPtrs.tpcZS->sector[iSector].count[0] && mIOPtrs.tpcZS->sector[iSector].nZSPtr[0][0]) ? o2::raw::RDHUtils::getHeartBeatOrbit(*(const o2::header::RAWDataHeader*)mIOPtrs.tpcZS->sector[iSector].zsPtr[0][0])
-                                                                                                                                                                                                               : 0;
+  int32_t firstHBF = (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasTfStartOrbit) ? mIOPtrs.settingsTF->tfStartOrbit : ((mIOPtrs.tpcZS->sector[iSector].count[0] && mIOPtrs.tpcZS->sector[iSector].nZSPtr[0][0]) ? o2::raw::RDHUtils::getHeartBeatOrbit(*(const o2::header::RAWDataHeader*)mIOPtrs.tpcZS->sector[iSector].zsPtr[0][0]) : 0);
 
   for (uint16_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
 #ifndef GPUCA_NO_VC
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx b/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
index 9e7085b31849e..8d1efd7011227 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
@@ -31,13 +31,13 @@ int32_t GPUChainTracking::RunRefit()
   RefitShadow.SetPropagator(doGPU ? processorsShadow()->calibObjects.o2Propagator : GetO2Propagator());
   RefitShadow.mPTracks = (doGPU ? processorsShadow() : processors())->tpcMerger.OutputTracks();
   WriteToConstantMemory(RecoStep::Refit, (char*)&processors()->trackingRefit - (char*)processors(), &RefitShadow, sizeof(RefitShadow), 0);
-  //TransferMemoryResourcesToGPU(RecoStep::Refit, &Refit, 0);
+  // TransferMemoryResourcesToGPU(RecoStep::Refit, &Refit, 0);
   if (param().rec.trackingRefitGPUModel) {
     runKernel<GPUTrackingRefitKernel, GPUTrackingRefitKernel::mode0asGPU>(GetGrid(mIOPtrs.nMergedTracks, 0));
   } else {
     runKernel<GPUTrackingRefitKernel, GPUTrackingRefitKernel::mode1asTrackParCov>(GetGrid(mIOPtrs.nMergedTracks, 0));
   }
-  //TransferMemoryResourcesToHost(RecoStep::Refit, &Refit, 0);
+  // TransferMemoryResourcesToHost(RecoStep::Refit, &Refit, 0);
   SynchronizeStream(0);
   return 0;
 }
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index 34cd5b7280dc3..4dac56afed671 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -46,7 +46,7 @@ struct GPUO2Interface_Internals {
 };
 } // namespace o2::gpu
 
-GPUO2Interface::GPUO2Interface() : mInternals(new GPUO2Interface_Internals){};
+GPUO2Interface::GPUO2Interface() : mInternals(new GPUO2Interface_Internals) {};
 
 GPUO2Interface::~GPUO2Interface() { Deinitialize(); }
 
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h b/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h
index 425c8b880b4e3..ebb426b7a8cfe 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h
@@ -50,7 +50,7 @@
 #define AddSubConfig(name, instance)
 #define BeginSubConfig(name, instance, parent, preoptname, preoptnameshort, descr, o2prefix)                                           \
   struct GPUCA_M_CAT(GPUConfigurableParam, name) : public o2::conf::ConfigurableParamHelper<GPUCA_M_CAT(GPUConfigurableParam, name)> { \
-    O2ParamDef(GPUCA_M_CAT(GPUConfigurableParam, name), GPUCA_M_STR(GPUCA_M_CAT(GPU_, o2prefix))) public:
+   O2ParamDef(GPUCA_M_CAT(GPUConfigurableParam, name), GPUCA_M_STR(GPUCA_M_CAT(GPU_, o2prefix))) public:
 #define BeginHiddenConfig(name, instance) struct GPUCA_M_CAT(GPUConfigurableParam, name) {
 #define EndConfig() \
   }                 \
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 64d8549312736..578fe1eeb4ca7 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -106,17 +106,17 @@ class GPUTPCGMMergedTrack
   GPUd() gputpcgmmergertypes::GPUTPCOuterParam& OuterParam() { return mOuterParam; }
 
  private:
-  GPUTPCGMTrackParam mParam;                        //* fitted track parameters
+  GPUTPCGMTrackParam mParam;                         //* fitted track parameters
   gputpcgmmergertypes::GPUTPCOuterParam mOuterParam; //* outer param
 
-  float mAlpha;                  //* alpha angle
-  float mLastX;                  //* outer X
-  float mLastY;                  //* outer Y
-  float mLastZ;                  //* outer Z
-  uint32_t mFirstClusterRef;     //* index of the first track cluster in corresponding cluster arrays
+  float mAlpha;              //* alpha angle
+  float mLastX;              //* outer X
+  float mLastY;              //* outer Y
+  float mLastZ;              //* outer Z
+  uint32_t mFirstClusterRef; //* index of the first track cluster in corresponding cluster arrays
   // TODO: Change to 8 bit
-  uint32_t mNClusters;           //* number of track clusters
-  uint32_t mNClustersFitted;     //* number of clusters used in fit
+  uint32_t mNClusters;       //* number of track clusters
+  uint32_t mNClustersFitted; //* number of clusters used in fit
   uint8_t mFlags;
   uint8_t mLegs;
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index e6312d767a496..1c2a8e2b29a9c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -2140,7 +2140,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
       }
       const float d2xy = CAMath::Sum2(params[i].x - params[j].x, params[i].y - params[j].y);
       if (d2xy > 15.f) {
-        //bs |= 1;
+        // bs |= 1;
         continue;
       }
       const auto& trk1 = mOutputTracks[params[i].id];
@@ -2148,7 +2148,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
       const auto& param1 = trk1.GetParam();
       const auto& param2 = trk2.GetParam();
       if (CAMath::Abs(param1.GetDzDs()) > 0.03f && CAMath::Abs(param2.GetDzDs()) > 0.03f && param1.GetDzDs() * param2.GetDzDs() * param1.GetQPt() * param2.GetQPt() < 0) {
-        //bs |= 2;
+        // bs |= 2;
         continue;
       }
 
@@ -2170,7 +2170,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
         }
       }
       if (!dzcorrok) {
-        //bs |= 4;
+        // bs |= 4;
         continue;
       }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.h b/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.h
index 88f0882a79f03..4a608fcc97068 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.h
@@ -39,11 +39,11 @@ class GPUTPCGMPolynomialFieldManager
   GPUTPCGMPolynomialFieldManager() = default;
 
   /* Get appropriate pre-calculated polynomial field for the given field value nominalFieldkG
- */
+   */
   static int32_t GetPolynomialField(float nominalFieldkG, o2::gpu::GPUTPCGMPolynomialField& field);
 
   /* Get pre-calculated polynomial field of type "type", scaled with respect to nominalFieldkG
- */
+   */
   static int32_t GetPolynomialField(StoredField_t type, float nominalFieldkG, o2::gpu::GPUTPCGMPolynomialField& field);
 };
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index e15d6fe8b17bd..0c171a74d4e42 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -716,7 +716,7 @@ GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict
       const float ImP1 = mP[1] + Ik11 * Iz1;
       const float ImC0 = mC[0] - Ik00 * mC[0];
       const float ImC2 = mC[2] - Ik11 * mC[2];
-      //printf("\t%21sInterpo ----- abde artaf%16s Y %8.3f, Z %8.3f (Errors %f <-- (%f, %f) %f <-- (%f, %f))\n", "", "", ImP0, ImP1, sqrtf(ImC0), sqrtf(mC[0]), sqrtf(inter->errorY), sqrtf(ImC2), sqrtf(mC[2]), sqrtf(inter->errorZ));
+      // printf("\t%21sInterpo ----- abde artaf%16s Y %8.3f, Z %8.3f (Errors %f <-- (%f, %f) %f <-- (%f, %f))\n", "", "", ImP0, ImP1, sqrtf(ImC0), sqrtf(mC[0]), sqrtf(inter->errorY), sqrtf(ImC2), sqrtf(mC[2]), sqrtf(inter->errorZ));
       const float Jz0 = posY - ImP0;
       const float Jz1 = posZ - ImP1;
       const float Jw0 = 1.f / (ImC0 + err2Y);
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index 9d10d40107b8f..502a70cb57762 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -256,7 +256,7 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
   int32_t nAvgCharge = 0;
 
   for (int32_t i = start; i != stop; i += cl ? 0 : direction) {
-    float x = 0, y = 0, z = 0, charge = 0; // FIXME: initialization unneeded, but GCC incorrectly produces uninitialized warnings otherwise
+    float x = 0, y = 0, z = 0, charge = 0;                  // FIXME: initialization unneeded, but GCC incorrectly produces uninitialized warnings otherwise
     float time = 0.f, invCharge = 0.f, invSqrtCharge = 0.f; // Same here...
     int32_t clusters = 0;
     while (true) {
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h
index 10ff0a32aeaf3..5bb63d6a10254 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h
@@ -30,7 +30,7 @@ class GPUTPCTracklet
 {
  public:
 #if !defined(GPUCA_GPUCODE)
-  GPUTPCTracklet() : mFirstRow(0), mLastRow(0), mParam(), mHitWeight(0), mFirstHit(0){};
+  GPUTPCTracklet() : mFirstRow(0), mLastRow(0), mParam(), mHitWeight(0), mFirstHit(0) {};
 #endif //! GPUCA_GPUCODE
 
   GPUhd() int32_t FirstRow() const { return mFirstRow; }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index e7634fa397bae..f1fd95d696f5d 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -101,7 +101,7 @@ GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUShared
       const int32_t nRows = (endpoint & 1) ? (s.nRowsRegion - s.nRowsRegion / 2) : (s.nRowsRegion / 2);
 
       for (int32_t l = 0; l < hdr->nTimeBinSpan; l++) { // TODO: Parallelize over time bins
-        pagePtr += (pagePtr - page) & 1;            // Ensure 16 bit alignment
+        pagePtr += (pagePtr - page) & 1;                // Ensure 16 bit alignment
         const TPCZSTBHDR* tbHdr = reinterpret_cast<const TPCZSTBHDR*>(pagePtr);
         if ((tbHdr->rowMask & 0x7FFF) == 0) {
           pagePtr += 2;
@@ -324,8 +324,8 @@ GPUd() void GPUTPCCFDecodeZSLink::DecodeTBSingleThread(
         bits -= DECODE_BITS;
         nSamplesWritten++;
         rawFECChannel++; // Ensure we don't decode same channel twice
-      }                  // while (bits >= DECODE_BITS)
-    }                    // while (nSamplesWritten < nAdc)
+      } // while (bits >= DECODE_BITS)
+    } // while (nSamplesWritten < nAdc)
 
   } else { // ! TPCZSHDRV2::TIGHTLY_PACKED_V3
     uint32_t rawFECChannel = 0;
@@ -705,7 +705,7 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
 #define PEEK_OVERFLOW(pagePtr, offset)                                                      \
   (*(PayloadExtendsToNextPage && (pagePtr) < nextPage && (pagePtr) + (offset) >= payloadEnd \
-       ? nextPage + sizeof(header::RAWDataHeader) + ((pagePtr) + (offset)-payloadEnd)       \
+       ? nextPage + sizeof(header::RAWDataHeader) + ((pagePtr) + (offset) - payloadEnd)     \
        : (pagePtr) + (offset)))
 
 #define TEST_BIT(x, bit) static_cast<bool>((x) & (1 << (bit)))
@@ -931,8 +931,8 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
       bits -= DECODE_BITS;
       nSamplesWritten++;
       rawFECChannel++; // Ensure we don't decode same channel twice
-    }                  // while (bits >= DECODE_BITS)
-  }                    // while (nSamplesWritten < nAdc)
+    } // while (bits >= DECODE_BITS)
+  } // while (nSamplesWritten < nAdc)
 
   assert(PayloadExtendsToNextPage || adcData <= page);
   assert(PayloadExtendsToNextPage || page <= payloadEnd);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.cxx
index 05fddda5bec68..f3a914cbfcaee 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.cxx
@@ -316,8 +316,8 @@ GPUd() void GPUTPCCFNoiseSuppression::findMinimaAndPeaks(
   uint8_t* bufp = (uint8_t*)buf;
 
   /**************************************
-     * Look for peaks
-     **************************************/
+   * Look for peaks
+   **************************************/
 
   CfUtils::blockLoad(
     peakMap,
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
index 24624e60ceba7..f6b8bea29822a 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
@@ -45,7 +45,7 @@ class propagatorInterface<o2::base::Propagator>
 {
  public:
   typedef o2::base::Propagator propagatorParam;
-  GPUd() propagatorInterface(const propagatorParam* prop) : mProp(prop){};
+  GPUd() propagatorInterface(const propagatorParam* prop) : mProp(prop) {};
   GPUd() propagatorInterface(const propagatorInterface<o2::base::Propagator>&) = delete;
   GPUd() propagatorInterface& operator=(const propagatorInterface<o2::base::Propagator>&) = delete;
 
@@ -200,7 +200,7 @@ class propagatorInterface<GPUTPCGMPropagator> : public GPUTPCGMPropagator
   }
   GPUd() bool propagateToX(float x, float maxSnp, float maxStep)
   {
-    //bool ok = PropagateToXAlpha(x, GetAlpha(), true) == 0 ? true : false;
+    // bool ok = PropagateToXAlpha(x, GetAlpha(), true) == 0 ? true : false;
     int32_t retVal = PropagateToXAlpha(x, GetAlpha(), true);
     bool ok = (retVal == 0) ? true : false;
     ok = mTrack->CheckNumericalQuality();
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTrackData.h b/GPU/GPUTracking/TRDTracking/GPUTRDTrackData.h
index 6a6e13fe84e36..ee7d7a30b1c55 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTrackData.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTrackData.h
@@ -18,15 +18,15 @@
 #define GPUTRDTRACKDATA_H
 
 struct GPUTRDTrackDataRecord {
-  float mAlpha;              // azimuthal angle of reference frame
-  float fX;                  // x: radial distance
-  float fY;                  // local Y-coordinate of a track (cm)
-  float fZ;                  // local Z-coordinate of a track (cm)
-  float mSinPhi;             // local sine of the track momentum azimuthal angle
-  float fTgl;                // tangent of the track momentum dip angle
-  float fq1Pt;               // 1/pt (1/(GeV/c))
-  float fC[15];              // covariance matrix
-  int32_t fTPCTrackID;       // id of corresponding TPC track
+  float mAlpha;                  // azimuthal angle of reference frame
+  float fX;                      // x: radial distance
+  float fY;                      // local Y-coordinate of a track (cm)
+  float fZ;                      // local Z-coordinate of a track (cm)
+  float mSinPhi;                 // local sine of the track momentum azimuthal angle
+  float fTgl;                    // tangent of the track momentum dip angle
+  float fq1Pt;                   // 1/pt (1/(GeV/c))
+  float fC[15];                  // covariance matrix
+  int32_t fTPCTrackID;           // id of corresponding TPC track
   int32_t fAttachedTracklets[6]; // IDs for attached tracklets sorted by layer
   uint8_t mIsPadrowCrossing;     // bits 0 to 5 indicate whether a padrow was crossed
 
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
index fa0711887f60f..c633f10adae38 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
@@ -12,7 +12,7 @@
 /// \file GPUTRDTracker.cxx
 /// \author Ole Schmidt
 
-//#define ENABLE_GPUTRDDEBUG
+// #define ENABLE_GPUTRDDEBUG
 #define ENABLE_WARNING 0
 #define ENABLE_INFO 0
 
@@ -326,7 +326,6 @@ GPUd() int32_t GPUTRDTracker_t<TRDTRK, PROP>::LoadTrack(const TRDTRK& trk, uint3
   return (0);
 }
 
-
 template <class TRDTRK, class PROP>
 GPUd() void GPUTRDTracker_t<TRDTRK, PROP>::DumpTracks()
 {
@@ -439,19 +438,19 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::CalculateSpacePoints(int32_t iCollisi
     int32_t trkltIdxStart = trkltIdxOffset + iFirstTrackletInDet;
     for (int32_t trkltIdx = trkltIdxStart; trkltIdx < trkltIdxStart + nTrackletsInDet; ++trkltIdx) {
       int32_t trkltZbin = tracklets[trkltIdx].GetZbin();
-      float xTrkltDet[3] = {0.f};                                            // trklt position in chamber coordinates
-      float xTrkltSec[3] = {0.f};                                            // trklt position in sector coordinates
+      float xTrkltDet[3] = {0.f}; // trklt position in chamber coordinates
+      float xTrkltSec[3] = {0.f}; // trklt position in sector coordinates
       xTrkltDet[0] = mGeo->AnodePos() + sRadialOffset;
       xTrkltDet[1] = tracklets[trkltIdx].GetY();
       xTrkltDet[2] = pp->GetRowPos(trkltZbin) - pp->GetRowSize(trkltZbin) / 2.f - pp->GetRowPos(pp->GetNrows() / 2);
-      //GPUInfo("Space point local %i: x=%f, y=%f, z=%f", trkltIdx, xTrkltDet[0], xTrkltDet[1], xTrkltDet[2]);
+      // GPUInfo("Space point local %i: x=%f, y=%f, z=%f", trkltIdx, xTrkltDet[0], xTrkltDet[1], xTrkltDet[2]);
       matrix->LocalToMaster(xTrkltDet, xTrkltSec);
       mSpacePoints[trkltIdx].setX(xTrkltSec[0]);
       mSpacePoints[trkltIdx].setY(xTrkltSec[1]);
       mSpacePoints[trkltIdx].setZ(xTrkltSec[2]);
       mSpacePoints[trkltIdx].setDy(tracklets[trkltIdx].GetdY());
 
-      //GPUInfo("Space point global %i: x=%f, y=%f, z=%f", trkltIdx, mSpacePoints[trkltIdx].getX(), mSpacePoints[trkltIdx].getY(), mSpacePoints[trkltIdx].getZ());
+      // GPUInfo("Space point global %i: x=%f, y=%f, z=%f", trkltIdx, mSpacePoints[trkltIdx].getX(), mSpacePoints[trkltIdx].getY(), mSpacePoints[trkltIdx].getZ());
     }
   }
   return result;
@@ -475,10 +474,10 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::FollowProlongation(PROP* prop, TRDTRK
   float zShiftTrk = 0.f;
   if (mProcessPerTimeFrame) {
     zShiftTrk = (mTrackAttribs[iTrk].mTime - GetConstantMem()->ioPtrs.trdTriggerTimes[collisionId]) * mTPCVdrift * mTrackAttribs[iTrk].mSide;
-    //float addZerr = (mTrackAttribs[iTrk].mTimeAddMax + mTrackAttribs[iTrk].mTimeSubMax) * .5f * mTPCVdrift;
-    // increase Z error based on time window
-    // -> this is here since it was done before, but the efficiency seems to be better if the covariance is not updated (more tracklets are attached)
-    //t->updateCovZ2(addZerr * addZerr); // TODO check again once detailed performance study tools are available, maybe this can be tuned
+    // float addZerr = (mTrackAttribs[iTrk].mTimeAddMax + mTrackAttribs[iTrk].mTimeSubMax) * .5f * mTPCVdrift;
+    //  increase Z error based on time window
+    //  -> this is here since it was done before, but the efficiency seems to be better if the covariance is not updated (more tracklets are attached)
+    // t->updateCovZ2(addZerr * addZerr); // TODO check again once detailed performance study tools are available, maybe this can be tuned
   }
   const GPUTRDpadPlane* pad = nullptr;
   const GPUTRDTrackletWord* tracklets = GetConstantMem()->ioPtrs.trdTracklets;
@@ -637,7 +636,7 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::FollowProlongation(PROP* prop, TRDTRK
             }
             Hypothesis hypo(trkWork->getNlayersFindable(), iCandidate, trkltIdx, trkWork->getChi2() + chi2);
             InsertHypothesis(hypo, nCurrHypothesis, hypothesisIdxOffset);
-          }   // end tracklet in window
+          } // end tracklet in window
         } // tracklet loop
       } // chamber loop
 
@@ -723,7 +722,7 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::FollowProlongation(PROP* prop, TRDTRK
 #ifdef ENABLE_GPUTRDDEBUG
       prop->setTrack(&trackNoUp);
       prop->rotate(GetAlphaOfSector(trkltSec));
-      //prop->propagateToX(spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getX(), .8f, 2.f);
+      // prop->propagateToX(spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getX(), .8f, 2.f);
       prop->propagateToX(mR[tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetDetector()], .8f, 2.f);
       prop->setTrack(trkWork);
 #endif
@@ -1103,7 +1102,6 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::IsGeoFindable(const TRDTRK* t, const
   return true;
 }
 
-
 #ifndef GPUCA_GPUCODE
 namespace o2::gpu
 {
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
index 29a9b529b0558..431fa357e8b89 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
@@ -85,7 +85,7 @@ class GPUTRDTracker_t : public GPUProcessor
     int32_t mLayers;      // number of layers with TRD space point
     int32_t mCandidateId; // to which track candidate the hypothesis belongs
     int32_t mTrackletId;  // tracklet index to be used for update (global index within tracklet array)
-    float mChi2;      // predicted chi2 for given space point
+    float mChi2;          // predicted chi2 for given space point
 
     GPUd() float GetReducedChi2() { return mLayers > 0 ? mChi2 / mLayers : mChi2; }
     GPUd() Hypothesis() : mLayers(0), mCandidateId(-1), mTrackletId(-1), mChi2(9999.f) {}
@@ -148,32 +148,32 @@ class GPUTRDTracker_t : public GPUProcessor
   GPUd() const typename PROP::propagatorParam* getPropagatorParam();
 
  protected:
-  float* mR;                               // radial position of each TRD chamber, alignment taken into account, radial spread within chambers < 7mm
-  bool mIsInitialized;                     // flag is set upon initialization
-  bool mGenerateSpacePoints;               // if true, only tracklets are provided as input and they will be converted into space points by the tracker
-  bool mProcessPerTimeFrame;               // if true, tracking is done per time frame instead of on a single events basis
-  int16_t mNAngleHistogramBins;            // number of bins per chamber for the angular difference histograms
-  float mAngleHistogramRange;              // range of impact angles covered by each histogram
-  int16_t mMemoryPermanent;                // memory id of permanent memory for the tracker
-  int16_t mMemoryTracklets;                // memory id of memory for TRD tracklets
-  int16_t mMemoryTracks;                   // memory id of memory for tracks (used for i/o)
-  int32_t mNMaxCollisions;                 // max number of collisions to process (per time frame)
-  int32_t mNMaxTracks;                     // max number of tracks the tracker can handle (per event)
-  int32_t mNMaxSpacePoints;                // max number of space points hold by the tracker (per event)
-  TRDTRK* mTracks;                         // array of trd-updated tracks
-  HelperTrackAttributes* mTrackAttribs;    // array with additional (transient) track attributes
-  int32_t mNCandidates;                    // max. track hypothesis per layer
-  int32_t mNTracks;                        // number of TPC tracks to be matched
-  int32_t mNEvents;                        // number of processed events
-  int32_t mMaxBackendThreads;              // maximum number of supported threads
+  float* mR;                            // radial position of each TRD chamber, alignment taken into account, radial spread within chambers < 7mm
+  bool mIsInitialized;                  // flag is set upon initialization
+  bool mGenerateSpacePoints;            // if true, only tracklets are provided as input and they will be converted into space points by the tracker
+  bool mProcessPerTimeFrame;            // if true, tracking is done per time frame instead of on a single events basis
+  int16_t mNAngleHistogramBins;         // number of bins per chamber for the angular difference histograms
+  float mAngleHistogramRange;           // range of impact angles covered by each histogram
+  int16_t mMemoryPermanent;             // memory id of permanent memory for the tracker
+  int16_t mMemoryTracklets;             // memory id of memory for TRD tracklets
+  int16_t mMemoryTracks;                // memory id of memory for tracks (used for i/o)
+  int32_t mNMaxCollisions;              // max number of collisions to process (per time frame)
+  int32_t mNMaxTracks;                  // max number of tracks the tracker can handle (per event)
+  int32_t mNMaxSpacePoints;             // max number of space points hold by the tracker (per event)
+  TRDTRK* mTracks;                      // array of trd-updated tracks
+  HelperTrackAttributes* mTrackAttribs; // array with additional (transient) track attributes
+  int32_t mNCandidates;                 // max. track hypothesis per layer
+  int32_t mNTracks;                     // number of TPC tracks to be matched
+  int32_t mNEvents;                     // number of processed events
+  int32_t mMaxBackendThreads;           // maximum number of supported threads
   // index of first tracklet for each chamber within tracklets array, last entry is total number of tracklets for given collision
   // the array has (kNChambers + 1) * numberOfCollisions entries
   // note, that for collision iColl one has to add an offset corresponding to the index of the first tracklet of iColl to the index stored in mTrackletIndexArray
   int32_t* mTrackletIndexArray;
-  Hypothesis* mHypothesis;                 // array with multiple track hypothesis
-  TRDTRK* mCandidates;                     // array of tracks for multiple hypothesis tracking
-  GPUTRDSpacePoint* mSpacePoints;          // array with tracklet coordinates in global tracking frame
-  const GPUTRDGeometry* mGeo;              // TRD geometry
+  Hypothesis* mHypothesis;        // array with multiple track hypothesis
+  TRDTRK* mCandidates;            // array of tracks for multiple hypothesis tracking
+  GPUTRDSpacePoint* mSpacePoints; // array with tracklet coordinates in global tracking frame
+  const GPUTRDGeometry* mGeo;     // TRD geometry
   /// ---- error parametrization depending on magnetic field ----
   float mRPhiA2;     // parameterization for tracklet position resolution
   float mRPhiB;      // parameterization for tracklet position resolution
@@ -185,14 +185,14 @@ class GPUTRDTracker_t : public GPUProcessor
   float mAngleToDyB; // parameterization for conversion track angle -> tracklet deflection
   float mAngleToDyC; // parameterization for conversion track angle -> tracklet deflection
   /// ---- end error parametrization ----
-  bool mDebugOutput;                  // store debug output
-  static constexpr const float sRadialOffset = -0.1f;             // due to (possible) mis-calibration of t0 -> will become obsolete when tracklet conversion is done outside of the tracker
-  float mMaxEta;                                                  // TPC tracks with higher eta are ignored
-  float mRoadZ;                       // in z, a constant search road is used
-  float mZCorrCoefNRC;                // tracklet z-position depends linearly on track dip angle
-  float mTPCVdrift;                   // TPC drift velocity used for shifting TPC tracks along Z
-  float mTPCTDriftOffset;             // TPC drift time additive offset
-  GPUTRDTrackerDebug<TRDTRK>* mDebug; // debug output
+  bool mDebugOutput;                                  // store debug output
+  static constexpr const float sRadialOffset = -0.1f; // due to (possible) mis-calibration of t0 -> will become obsolete when tracklet conversion is done outside of the tracker
+  float mMaxEta;                                      // TPC tracks with higher eta are ignored
+  float mRoadZ;                                       // in z, a constant search road is used
+  float mZCorrCoefNRC;                                // tracklet z-position depends linearly on track dip angle
+  float mTPCVdrift;                                   // TPC drift velocity used for shifting TPC tracks along Z
+  float mTPCTDriftOffset;                             // TPC drift time additive offset
+  GPUTRDTrackerDebug<TRDTRK>* mDebug;                 // debug output
 };
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.h b/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.h
index fc874070ec9b8..cd7dfb9432b93 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.h
@@ -82,7 +82,7 @@ namespace o2::gpu
 class GPUTRDTrackletWord : private o2::trd::Tracklet64
 {
  public:
-  GPUd() GPUTRDTrackletWord(uint64_t trackletWord = 0) : o2::trd::Tracklet64(trackletWord){};
+  GPUd() GPUTRDTrackletWord(uint64_t trackletWord = 0) : o2::trd::Tracklet64(trackletWord) {};
   GPUdDefault() GPUTRDTrackletWord(const GPUTRDTrackletWord& rhs) = default;
   GPUdDefault() GPUTRDTrackletWord& operator=(const GPUTRDTrackletWord& rhs) = default;
   GPUdDefault() ~GPUTRDTrackletWord() = default;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h
index ceb63e788564a..9087ec9a431f6 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h
@@ -138,12 +138,12 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
 
   std::unique_ptr<GPUDisplayGUIWrapper> mGUI;
 
-  void HandleKey(uint8_t key);               // Callback for handling key presses
-  int32_t DrawGLScene();                     // Callback to draw the GL scene
-  void HandleSendKey();                      // Optional callback to handle key press from external source (e.g. stdin by default)
+  void HandleKey(uint8_t key);                     // Callback for handling key presses
+  int32_t DrawGLScene();                           // Callback to draw the GL scene
+  void HandleSendKey();                            // Optional callback to handle key press from external source (e.g. stdin by default)
   void ResizeScene(int32_t width, int32_t height); // Callback when GL window is resized
   int32_t InitDisplay(bool initFailure = false);   // Callback to initialize the GL Display (to be called in StartDisplay)
-  void ExitDisplay();                        // Callback to clean up the GL Display
+  void ExitDisplay();                              // Callback to clean up the GL Display
   int32_t& drawTextFontSize();
 };
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.cxx
index 8d48536e0a351..e511718e258f7 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.cxx
@@ -80,12 +80,12 @@ void KillGLWindow() // Properly Kill The Window
 
 BOOL CreateGLWindow(char* title, int32_t width, int32_t height, int32_t bits, bool fullscreenflag)
 {
-  GLuint PixelFormat;               // Holds The Results After Searching For A Match
-  WNDCLASS wc;                      // Windows Class Structure
-  DWORD dwExStyle;                  // Window Extended Style
-  DWORD dwStyle;                    // Window Style
-  RECT WindowRect;                  // Grabs Rectangle Upper Left / Lower Right Values
-  WindowRect.left = (int64_t)0;     // Set Left Value To 0
+  GLuint PixelFormat;                  // Holds The Results After Searching For A Match
+  WNDCLASS wc;                         // Windows Class Structure
+  DWORD dwExStyle;                     // Window Extended Style
+  DWORD dwStyle;                       // Window Style
+  RECT WindowRect;                     // Grabs Rectangle Upper Left / Lower Right Values
+  WindowRect.left = (int64_t)0;        // Set Left Value To 0
   WindowRect.right = (int64_t)width;   // Set Right Value To Requested Width
   WindowRect.top = (int64_t)0;         // Set Top Value To 0
   WindowRect.bottom = (int64_t)height; // Set Bottom Value To Requested Height
diff --git a/GPU/GPUTracking/qa/GPUQAHelper.h b/GPU/GPUTracking/qa/GPUQAHelper.h
index 92da6bbac94e8..a7811c6fd55ed 100644
--- a/GPU/GPUTracking/qa/GPUQAHelper.h
+++ b/GPU/GPUTracking/qa/GPUQAHelper.h
@@ -91,7 +91,7 @@ class GPUTPCTrkLbl
   inline U computeLabel(float* labelWeight = nullptr, float* totalWeight = nullptr, int32_t* maxCount = nullptr)
   {
     if (mLabels.size() == 0) {
-      return U(); //default constructor creates NotSet label
+      return U(); // default constructor creates NotSet label
     } else {
       uint32_t bestLabelNum = 0, bestLabelCount = 0;
       for (uint32_t j = 0; j < mLabels.size(); j++) {
@@ -133,10 +133,10 @@ struct GPUTPCTrkLbl_ret {
   template <class T>
   GPUTPCTrkLbl_ret(T){};
 #ifdef GPUCA_TPC_GEOMETRY_O2
-  GPUTPCTrkLbl_ret(const MCCompLabel& a) : id(a.getTrackEventSourceID()){};
+  GPUTPCTrkLbl_ret(const MCCompLabel& a) : id(a.getTrackEventSourceID()) {};
 #endif
 #ifdef GPUCA_STANDALONE
-  GPUTPCTrkLbl_ret(const AliHLTTPCClusterMCWeight& a) : id(a.fMCID){};
+  GPUTPCTrkLbl_ret(const AliHLTTPCClusterMCWeight& a) : id(a.fMCID) {};
 #endif
   void setFakeFlag()
   {
diff --git a/GPU/GPUTracking/qa/genEvents.h b/GPU/GPUTracking/qa/genEvents.h
index fb3c5f22d61ef..43b946e6238b2 100644
--- a/GPU/GPUTracking/qa/genEvents.h
+++ b/GPU/GPUTracking/qa/genEvents.h
@@ -31,7 +31,7 @@ class genEvents
   int32_t GenerateEvent(const GPUParam& sectorParam, char* filename) { return 1; }
   void FinishEventGenerator() {}
 
-  static void RunEventGenerator(GPUChainTracking* rec){};
+  static void RunEventGenerator(GPUChainTracking* rec) {};
 };
 
 #else
diff --git a/GPU/GPUTracking/utils/qconfig.cxx b/GPU/GPUTracking/utils/qconfig.cxx
index cd6267179c844..cdb41ec5813f2 100644
--- a/GPU/GPUTracking/utils/qconfig.cxx
+++ b/GPU/GPUTracking/utils/qconfig.cxx
@@ -32,8 +32,7 @@
 namespace qConfig
 {
 #define QCONFIG_SETTING(name, type)                     \
-  struct qon_mxcat3(q, name, _t)                        \
-  {                                                     \
+  struct qon_mxcat3(q, name, _t) {                      \
     type v;                                             \
     constexpr qon_mxcat3(q, name, _t)(type s) : v(s) {} \
   };                                                    \
@@ -41,8 +40,7 @@ namespace qConfig
 
 #define QCONFIG_SETTING_TEMPLATE(name)                      \
   template <typename T>                                     \
-  struct qon_mxcat3(q, name, _t)                            \
-  {                                                         \
+  struct qon_mxcat3(q, name, _t) {                          \
     T v;                                                    \
     constexpr qon_mxcat3(q, name, _t)(const T& s) : v(s) {} \
   };                                                        \
@@ -68,7 +66,7 @@ static inline const char* getOptName(const char** argv, int32_t i)
 
 template <typename T>
 struct qConfigSettings {
-  qConfigSettings() : checkMin(false), checkMax(false), doSet(false), doDefault(false), min(), max(), set(), message(nullptr), allowEmpty(false){};
+  qConfigSettings() : checkMin(false), checkMax(false), doSet(false), doDefault(false), min(), max(), set(), message(nullptr), allowEmpty(false) {};
   template <typename S>
   qConfigSettings(const qConfigSettings<S> v) : checkMin(false), checkMax(false), doSet(false), doDefault(false), min(), max(), set(), message(v.message), allowEmpty(v.allowEmpty){};
   bool checkMin, checkMax;
diff --git a/GPU/GPUTracking/utils/threadserver.h b/GPU/GPUTracking/utils/threadserver.h
index 606531f46f201..c8dfe831fd578 100644
--- a/GPU/GPUTracking/utils/threadserver.h
+++ b/GPU/GPUTracking/utils/threadserver.h
@@ -98,7 +98,7 @@ class qThreadCls
     qThreadParamCls<S>& XthreadParam = *((qThreadParamCls<S>*)&this->threadParam);
 
     XthreadParam.pCls = pCls;
-    XthreadParam.pFunc = (void (S::*)(void*))pFunc;
+    XthreadParam.pFunc = (void(S::*)(void*))pFunc;
     XthreadParam.threadNum = threadNum;
     XthreadParam.pinCPU = pinCPU;
     pthread_t thr;
@@ -150,7 +150,7 @@ void* qThreadCls<S, T>::qThreadWrapperCls(T* arg)
     sched_setaffinity(0, sizeof(tmp_mask), &tmp_mask);
   }
 
-  void (S::*pFunc)(T*) = (void (S::*)(T*))arg_A->pFunc;
+  void (S::*pFunc)(T*) = (void(S::*)(T*))arg_A->pFunc;
   (arg_A->pCls->*pFunc)(arg);
 
   arg_A->threadMutex[1].Unlock();
diff --git a/GPU/GPUbenchmark/cuda/Kernels.cu b/GPU/GPUbenchmark/cuda/Kernels.cu
index 75799e4aa8c96..c309e7b2dbc5d 100644
--- a/GPU/GPUbenchmark/cuda/Kernels.cu
+++ b/GPU/GPUbenchmark/cuda/Kernels.cu
@@ -666,9 +666,9 @@ void GPUbenchmark<chunk_t>::runTest(Test test, Mode mode, KernelConfig config)
   }
   nThreads *= mOptions.threadPoolFraction;
 
-  void (*kernel)(chunk_t*, size_t) = &gpu::read_k<chunk_t>;                                   // Initialising to a default value
-  void (*kernel_distributed)(chunk_t**, size_t*) = &gpu::read_dist_k<chunk_t>;                // Initialising to a default value
-  void (*kernel_rand)(chunk_t*, size_t, int32_t) = &gpu::rand_read_k<chunk_t>;                // Initialising to a default value
+  void (*kernel)(chunk_t*, size_t) = &gpu::read_k<chunk_t>;                                       // Initialising to a default value
+  void (*kernel_distributed)(chunk_t**, size_t*) = &gpu::read_dist_k<chunk_t>;                    // Initialising to a default value
+  void (*kernel_rand)(chunk_t*, size_t, int32_t) = &gpu::rand_read_k<chunk_t>;                    // Initialising to a default value
   void (*kernel_rand_distributed)(chunk_t**, size_t*, int32_t) = &gpu::rand_read_dist_k<chunk_t>; // Initialising to a default value
 
   bool is_random{false};
diff --git a/GPU/TPCFastTransformation/BandMatrixSolver.h b/GPU/TPCFastTransformation/BandMatrixSolver.h
index f11f538e49275..7de44fe4b85e2 100644
--- a/GPU/TPCFastTransformation/BandMatrixSolver.h
+++ b/GPU/TPCFastTransformation/BandMatrixSolver.h
@@ -131,7 +131,7 @@ inline void BandMatrixSolver<BandWidthT>::triangulateBlock(double AA[], double b
       A[0] = c; // store 1/a[0][0]
       double* rowi = A + BandWidthT - 1;
       for (int32_t i = 1; i < m; i++) { // row 0+i
-        double ai = c * A[i];       // A[0][i]
+        double ai = c * A[i];           // A[0][i]
         for (int32_t j = i; j < m; j++) {
           rowi[j] -= ai * A[j]; // A[i][j] -= A[0][j]/A[0][0]*A[i][0]
         }
diff --git a/GPU/TPCFastTransformation/ChebyshevFit1D.cxx b/GPU/TPCFastTransformation/ChebyshevFit1D.cxx
index d709e5b9af92d..3edd8f8f22e55 100644
--- a/GPU/TPCFastTransformation/ChebyshevFit1D.cxx
+++ b/GPU/TPCFastTransformation/ChebyshevFit1D.cxx
@@ -71,7 +71,7 @@ void ChebyshevFit1D::fit()
       mA[i * mN + j] = mA[j * mN + i];
     }
   }
-  //print();
+  // print();
   {
     double* Ai = mA.data();
     for (int32_t i = 0; i < mN; i++, Ai += mN) {
@@ -88,7 +88,7 @@ void ChebyshevFit1D::fit()
         }
         mB[j] -= c * mB[i];
       }
-      //print();
+      // print();
     }
   }
   {
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
index 32ff6e1f06b10..46070b36e63b2 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -165,25 +165,25 @@ class CorrectionMapsHelper
                      MapRefBit = 0x2,
                      LumiBit = 0x4,
                      MapMShapeBit = 0x10 };
-  bool mOwner = false; // is content of pointers owned by the helper
+  bool mOwner = false;            // is content of pointers owned by the helper
   bool mLumiCTPAvailable = false; // is CTP Lumi available
   // these 2 are global options, must be set by the workflow global options
   int32_t mLumiScaleType = -1; // use CTP Lumi (1) or TPCScaler (2) for the correction scaling, 0 - no scaling
   int32_t mLumiScaleMode = -1; // scaling-mode of the correciton maps
   int32_t mUpdatedFlags = 0;
-  float mInstLumiCTP = 0.;                                         // instanteneous luminosity from CTP (a.u)
-  float mInstLumi = 0.;                                            // instanteneous luminosity (a.u) used for TPC corrections scaling
-  float mMeanLumi = 0.;                                            // mean luminosity of the map (a.u) used for TPC corrections scaling
-  float mMeanLumiRef = 0.;                                         // mean luminosity of the ref map (a.u) used for TPC corrections scaling reference
-  float mLumiScale = 0.;                                           // precalculated mInstLumi/mMeanLumi
-  float mMeanLumiOverride = -1.f;                                  // optional value to override mean lumi
-  float mMeanLumiRefOverride = -1.f;                               // optional value to override ref mean lumi
-  float mInstCTPLumiOverride = -1.f;                               // optional value to override inst lumi from CTP
-  bool mEnableMShape = false;                                      ///< use v shape correction
-  bool mScaleInverse{false};                                       // if set to false the inverse correction is already scaled and will not scaled again
-  o2::gpu::TPCFastTransform* mCorrMap{nullptr};                    // current transform
-  o2::gpu::TPCFastTransform* mCorrMapRef{nullptr};                 // reference transform
-  o2::gpu::TPCFastTransform* mCorrMapMShape{nullptr};              // correction map for v-shape distortions on A-side
+  float mInstLumiCTP = 0.;                            // instanteneous luminosity from CTP (a.u)
+  float mInstLumi = 0.;                               // instanteneous luminosity (a.u) used for TPC corrections scaling
+  float mMeanLumi = 0.;                               // mean luminosity of the map (a.u) used for TPC corrections scaling
+  float mMeanLumiRef = 0.;                            // mean luminosity of the ref map (a.u) used for TPC corrections scaling reference
+  float mLumiScale = 0.;                              // precalculated mInstLumi/mMeanLumi
+  float mMeanLumiOverride = -1.f;                     // optional value to override mean lumi
+  float mMeanLumiRefOverride = -1.f;                  // optional value to override ref mean lumi
+  float mInstCTPLumiOverride = -1.f;                  // optional value to override inst lumi from CTP
+  bool mEnableMShape = false;                         ///< use v shape correction
+  bool mScaleInverse{false};                          // if set to false the inverse correction is already scaled and will not scaled again
+  o2::gpu::TPCFastTransform* mCorrMap{nullptr};       // current transform
+  o2::gpu::TPCFastTransform* mCorrMapRef{nullptr};    // reference transform
+  o2::gpu::TPCFastTransform* mCorrMapMShape{nullptr}; // correction map for v-shape distortions on A-side
   ClassDefNV(CorrectionMapsHelper, 6);
 };
 
diff --git a/GPU/TPCFastTransformation/NDPiecewisePolynomials.h b/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
index 506cd39b519af..e750bffd28f4b 100644
--- a/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
+++ b/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
@@ -48,13 +48,13 @@ struct NDPiecewisePolynomialContainer {
   /// for ROOT I/O
   NDPiecewisePolynomialContainer() = default;
 
-  const uint32_t mDim{};                ///< number of dimensions of the polynomial
-  const uint32_t mDegree{};             ///< degree of the polynomials
-  const std::vector<float> mParams{};   ///< parameters of the polynomial
-  const bool mInteractionOnly{};        ///< consider only interaction terms
-  const std::vector<float> mMin{};      ///< min vertices positions of the grid
-  const std::vector<float> mMax{};      ///< max vertices positions of the grid
-  const std::vector<uint32_t> mN{};     ///< number of vertices for each dimension
+  const uint32_t mDim{};              ///< number of dimensions of the polynomial
+  const uint32_t mDegree{};           ///< degree of the polynomials
+  const std::vector<float> mParams{}; ///< parameters of the polynomial
+  const bool mInteractionOnly{};      ///< consider only interaction terms
+  const std::vector<float> mMin{};    ///< min vertices positions of the grid
+  const std::vector<float> mMax{};    ///< max vertices positions of the grid
+  const std::vector<uint32_t> mN{};   ///< number of vertices for each dimension
 };
 #endif
 
diff --git a/GPU/TPCFastTransformation/Spline1DHelper.cxx b/GPU/TPCFastTransformation/Spline1DHelper.cxx
index 938604bb9172d..9177c67d8b87b 100644
--- a/GPU/TPCFastTransformation/Spline1DHelper.cxx
+++ b/GPU/TPCFastTransformation/Spline1DHelper.cxx
@@ -606,7 +606,7 @@ int32_t Spline1DHelper<DataT>::test(const bool draw, const bool drawDataPoints)
     Spline1D<DataT, Ndim> spline2(spline1);
     spline1.approximateFunction(0., TMath::Pi(), F, nAuxiliaryPoints);
 
-    //if (itry == 0)
+    // if (itry == 0)
     {
       TFile outf("testSpline1D.root", "recreate");
       if (outf.IsZombie()) {
@@ -731,9 +731,9 @@ int32_t Spline1DHelper<DataT>::test(const bool draw, const bool drawDataPoints)
       }
     } // draw
   }
-  //delete canv;
-  //delete nt;
-  //delete knots;
+  // delete canv;
+  // delete nt;
+  // delete knots;
 
   statDf1 = sqrt(statDf1 / statN);
   statDf2 = sqrt(statDf2 / statN);
diff --git a/GPU/TPCFastTransformation/Spline1DHelperOld.h b/GPU/TPCFastTransformation/Spline1DHelperOld.h
index fc8d33ad64f87..971541e03258e 100644
--- a/GPU/TPCFastTransformation/Spline1DHelperOld.h
+++ b/GPU/TPCFastTransformation/Spline1DHelperOld.h
@@ -41,13 +41,13 @@ class Spline1DHelperOld
   /// \brief Helper structure for 1D spline construction
   ///
   struct DataPoint {
-    double u;    ///< u coordinate
-    double cS0;  ///< a coefficient for s0
-    double cZ0;  ///< a coefficient for s'0
-    double cS1;  ///< a coefficient for s1
-    double cZ1;  ///< a coefficient for s'1
+    double u;      ///< u coordinate
+    double cS0;    ///< a coefficient for s0
+    double cZ0;    ///< a coefficient for s'0
+    double cS1;    ///< a coefficient for s1
+    double cZ1;    ///< a coefficient for s'1
     int32_t iKnot; ///< index of the left knot of the segment
-    bool isKnot; ///< is the point placed at a knot
+    bool isKnot;   ///< is the point placed at a knot
   };
 
   /// _____________  Constructors / destructors __________________________
@@ -160,11 +160,11 @@ class Spline1DHelperOld
 
   /// helpers for the construction of 1D spline
 
-  Spline1D<double> mSpline;           ///< copy of the spline
-  int32_t mFdimensions;               ///< n of F dimensions
-  std::vector<DataPoint> mDataPoints; ///< measurement points
+  Spline1D<double> mSpline;             ///< copy of the spline
+  int32_t mFdimensions;                 ///< n of F dimensions
+  std::vector<DataPoint> mDataPoints;   ///< measurement points
   std::vector<int32_t> mKnotDataPoints; ///< which measurement points are at knots
-  std::vector<double> mLSMmatrixFull; ///< a matrix to convert the measurements into the spline parameters with the LSM method
+  std::vector<double> mLSMmatrixFull;   ///< a matrix to convert the measurements into the spline parameters with the LSM method
   std::vector<double> mLSMmatrixSderivatives;
   std::vector<double> mLSMmatrixSvalues;
 
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.cxx b/GPU/TPCFastTransformation/Spline1DSpec.cxx
index 603013d5e0808..0d33cdc88010a 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline1DSpec.cxx
@@ -144,7 +144,7 @@ void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots, co
   }
 }
 
-#endif //GPUCA_GPUCODE
+#endif // GPUCA_GPUCODE
 
 template <class DataT>
 void Spline1DContainer<DataT>::print() const
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 1ed1cc322ede3..6462f291d1136 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -211,13 +211,13 @@ class Spline1DContainer : public FlatObject
 
   /// _____________  Data members  ____________
 
-  int32_t mYdim = 0;            ///< dimentionality of F
-  int32_t mNumberOfKnots = 0;   ///< n knots on the grid
-  int32_t mUmax = 0;            ///< U of the last knot
-  DataT mXmin = 0;              ///< X of the first knot
-  DataT mXtoUscale = 0;         ///< a scaling factor to convert X to U
+  int32_t mYdim = 0;              ///< dimentionality of F
+  int32_t mNumberOfKnots = 0;     ///< n knots on the grid
+  int32_t mUmax = 0;              ///< U of the last knot
+  DataT mXmin = 0;                ///< X of the first knot
+  DataT mXtoUscale = 0;           ///< a scaling factor to convert X to U
   int32_t* mUtoKnotMap = nullptr; //! (transient!!) pointer to (integer U -> knot index) map inside the mFlatBufferPtr array
-  DataT* mParameters = nullptr; //! (transient!!) pointer to F-dependent parameters inside the mFlatBufferPtr array
+  DataT* mParameters = nullptr;   //! (transient!!) pointer to F-dependent parameters inside the mFlatBufferPtr array
 
   ClassDefNV(Spline1DContainer, 1);
 };
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.cxx b/GPU/TPCFastTransformation/Spline2DSpec.cxx
index 4571110bdedaa..055530b9314c2 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline2DSpec.cxx
@@ -66,7 +66,7 @@ void Spline2DContainer<DataT>::setActualBufferAddress(char* actualFlatBufferPtr)
   mParameters = nullptr;
 
   parametersOffset = alignSize(u2Offset + mGridX2.getFlatBufferSize(), getParameterAlignmentBytes());
-  //bufferSize = parametersOffset + getSizeOfParameters();
+  // bufferSize = parametersOffset + getSizeOfParameters();
   mParameters = reinterpret_cast<DataT*>(mFlatBufferPtr + parametersOffset);
 
   mGridX1.setActualBufferAddress(mFlatBufferPtr);
diff --git a/GPU/TPCFastTransformation/SplineHelper.cxx b/GPU/TPCFastTransformation/SplineHelper.cxx
index b0d1f4348ca60..6e1b53510e0d0 100644
--- a/GPU/TPCFastTransformation/SplineHelper.cxx
+++ b/GPU/TPCFastTransformation/SplineHelper.cxx
@@ -64,8 +64,8 @@ int32_t SplineHelper<DataT>::pointstoarray(const int32_t indices[], const int32_
 }
 
 ////////////////
-//arraytopoints
-// HILFSFUNKTION
+// arraytopoints
+//  HILFSFUNKTION
 template <typename DataT>
 int32_t SplineHelper<DataT>::arraytopoints(int32_t point, int32_t result[], const int32_t numbers[], int32_t dim)
 {
@@ -133,8 +133,8 @@ void SplineHelper<DataT>::approximateFunction(
   } // end for all DataPoints d
   // END MY VERSION
 
-  //std::vector<DataT> dataPointF(getNumberOfDataPoints() * mFdimensions);
-  //DUMYY VERSION Commented out
+  // std::vector<DataT> dataPointF(getNumberOfDataPoints() * mFdimensions);
+  // DUMYY VERSION Commented out
   /* for (int32_t i = 0; i < getNumberOfDataPoints() * mFdimensions; i++) {
     dataPointF[i] = 1.;
   } */
@@ -250,11 +250,11 @@ void SplineHelper<DataT>::approximateFunction(
   // TO BE REMOVED TEST:
   // LOG(info) << "number of paramtertypes per knot : " <<  numberOfParameterTypes << ", ";
 
-  std::unique_ptr<double[]> allParameters[numberOfParameterTypes]; //Array for the different parametertypes s, s'u, s'v, s''uv,...
+  std::unique_ptr<double[]> allParameters[numberOfParameterTypes]; // Array for the different parametertypes s, s'u, s'v, s''uv,...
   for (int32_t i = 0; i < numberOfParameterTypes; i++) {
-    allParameters[i] = std::unique_ptr<double[]>(new double[numberOfAllDataPoints * mFdimensions]); //To-Do:Fdim!!
+    allParameters[i] = std::unique_ptr<double[]>(new double[numberOfAllDataPoints * mFdimensions]); // To-Do:Fdim!!
   }
-  //filling allParameters[0] and FParameters with s:
+  // filling allParameters[0] and FParameters with s:
   for (int32_t i = 0; i < numberOfAllDataPoints; i++) {
     for (int32_t f = 0; f < mFdimensions; f++) {                                 // for all f-dimensions
       allParameters[0][i * mFdimensions + f] = DataPointF[i * mFdimensions + f]; // TO DO - Just get the pointer adress there PLEASE!
@@ -273,24 +273,24 @@ void SplineHelper<DataT>::approximateFunction(
       for (int32_t j = 0; j < mXdimensions; j++) { // calculate KNotindices for all dimensions
         // WORKAROUND Getting Knotindices:
         knotindices[j] = p0indices[j] / ((numberOfDataPoints[j] - 1) / (numberOfKnots[j] - 1));
-        //knotindices[j] = mHelpers[j].getDataPoint(p0indices[j]).iKnot; //in der Annahme der wert ist ein Knotenindex und falls der datapoint ein knoten ist, gibt er seinen eigenen knotenindex zurück
+        // knotindices[j] = mHelpers[j].getDataPoint(p0indices[j]).iKnot; //in der Annahme der wert ist ein Knotenindex und falls der datapoint ein knoten ist, gibt er seinen eigenen knotenindex zurück
       }
       // get the knotindexvalue for FParameters:
       int32_t knotind = pointstoarray(knotindices, numberOfKnots, mXdimensions);
 
       for (int32_t f = 0; f < mFdimensions; f++) {                                                           // for all f-dimensions get function values into Fparameters
-        Fparameters[knotind * numberOfParameterTypes * mFdimensions + f] = DataPointF[i * mFdimensions + f]; ///write derivatives in FParameters
+        Fparameters[knotind * numberOfParameterTypes * mFdimensions + f] = DataPointF[i * mFdimensions + f]; /// write derivatives in FParameters
       }
     } // end if isKnot
   } // end i (filling DataPointF Values into allParameters[0] and FParameters)
   // now: allParameters[0] = dataPointF;
 
-  //Array for input DataPointF-values for Spline1D::approximateFunctionGradually(...);
+  // Array for input DataPointF-values for Spline1D::approximateFunctionGradually(...);
   std::unique_ptr<double[]> dataPointF1D[mXdimensions];
   for (int32_t i = 0; i < mXdimensions; i++) {
     dataPointF1D[i] = std::unique_ptr<double[]>(new double[numberOfDataPoints[i] * mFdimensions]); // To-Do:Fdim!! For s and derivetives at all knots.
   }
-  //Array to be filled by Spline1D::approximateFunctionGradually(...);
+  // Array to be filled by Spline1D::approximateFunctionGradually(...);
   std::unique_ptr<DataT[]> par[mXdimensions];
   std::unique_ptr<double[]> parD[mXdimensions];
 
@@ -301,7 +301,7 @@ void SplineHelper<DataT>::approximateFunction(
 
   // LOG(info) << "NumberOfParameters: " <<  mNumberOfParameters ;
 
-  //STARTING MAIN-LOOP, for all Parametertypes:
+  // STARTING MAIN-LOOP, for all Parametertypes:
   for (int32_t p = 1; p < numberOfParameterTypes; p++) { // p = 1!! Wir kriegen s (p0) durch approximateFunction()oben
     int32_t dimension = 0;                               // find the dimension for approximation
     for (int32_t i = (int32_t)(log2f((float)p)); i >= 0; i--) {
@@ -366,9 +366,9 @@ void SplineHelper<DataT>::approximateFunction(
       for (int32_t i = 0; i < mXdimensions; i++) {
         redistributionindex[i] = startpoint[i];
       }
-      //redistributing the derivatives at dimension-Knots into array p
+      // redistributing the derivatives at dimension-Knots into array p
       for (int32_t i = 0; i < numberOfKnots[dimension]; i++) {                    // for all dimension-Knots
-        redistributionindex[dimension] = mHelpers[dimension].getKnotDataPoint(i); //find the indices
+        redistributionindex[dimension] = mHelpers[dimension].getKnotDataPoint(i); // find the indices
         int32_t finalposition = pointstoarray(redistributionindex, numberOfDataPoints, mXdimensions);
 
         for (int32_t f = 0; f < mFdimensions; f++) {
@@ -380,7 +380,7 @@ void SplineHelper<DataT>::approximateFunction(
           if (!mHelpers[j].getDataPoint(redistributionindex[j]).isKnot) {
             isKnot = 0;
             break;
-          } //noch mal checken!! Das muss noch anders!!
+          } // noch mal checken!! Das muss noch anders!!
         }
 
         if (isKnot) { // for all knots
@@ -388,20 +388,20 @@ void SplineHelper<DataT>::approximateFunction(
 
           for (int32_t j = 0; j < mXdimensions; j++) { // calculate Knotindices for all dimensions
             knotindices[j] = redistributionindex[j] / ((numberOfDataPoints[j] - 1) / (numberOfKnots[j] - 1));
-            //knotindices[j] = mHelpers[j].getDataPoint(redistributionindex[j]).iKnot; //in der Annahme der wert ist ein Knotenindex und falls der datapoint ein knoten ist, gibt er seinen eigenen knotenindex zurück
+            // knotindices[j] = mHelpers[j].getDataPoint(redistributionindex[j]).iKnot; //in der Annahme der wert ist ein Knotenindex und falls der datapoint ein knoten ist, gibt er seinen eigenen knotenindex zurück
           }
           // get the knotindexvalue for FParameters:
           int32_t knotind = pointstoarray(knotindices, numberOfKnots, mXdimensions);
           for (int32_t f = 0; f < mFdimensions; f++) {
-            Fparameters[knotind * numberOfParameterTypes * mFdimensions + p * mFdimensions + f] = par[dimension][2 * i * mFdimensions + mFdimensions + f]; ///write derivatives in FParameters
+            Fparameters[knotind * numberOfParameterTypes * mFdimensions + p * mFdimensions + f] = par[dimension][2 * i * mFdimensions + mFdimensions + f]; /// write derivatives in FParameters
           }
         }
       } // end for all fknots (for redistribution)
 
       // recalculation:
       for (int32_t i = 0; i < numberOfDataPoints[dimension]; i++) { // this is somehow still redundant// TO DO: ONLY PART OF approximateFunction WHERE NDIM is considerd!!
-        redistributionindex[dimension] = i;                     // getting current datapointindices
-        bool isKnot = 1;                                        // check is current datapoint a knot?
+        redistributionindex[dimension] = i;                         // getting current datapointindices
+        bool isKnot = 1;                                            // check is current datapoint a knot?
         for (int32_t j = 0; j < mXdimensions; j++) {
           if (!mHelpers[j].getDataPoint(redistributionindex[j]).isKnot) {
             isKnot = 0;
@@ -410,7 +410,7 @@ void SplineHelper<DataT>::approximateFunction(
         }
         double splineF[mFdimensions];
         double u = mHelpers[dimension].getDataPoint(i).u;
-        mHelpers[dimension].getSpline().interpolateU(mFdimensions, parD[dimension].get(), u, splineF); //recalculate at all datapoints of dimension
+        mHelpers[dimension].getSpline().interpolateU(mFdimensions, parD[dimension].get(), u, splineF); // recalculate at all datapoints of dimension
         for (int32_t dim = 0; dim < mFdimensions; dim++) {                                             // writing it in allParameters
           // LOG(info)<<allParameters [p-(int32_t)(pow(2.0, dimension))] [(int32_t)(startdatapoint*mFdimensions + i*distance + dim)]<<", ";
           allParameters[p - (int32_t)(pow(2.0, dimension))][(int32_t)(startdatapoint * mFdimensions + i * distance + dim)] = splineF[dim]; // write it in the array.
@@ -422,7 +422,7 @@ void SplineHelper<DataT>::approximateFunction(
 
           for (int32_t j = 0; j < mXdimensions; j++) { // calculate KNotindices for all dimensions
             knotindices[j] = redistributionindex[j] / ((numberOfDataPoints[j] - 1) / (numberOfKnots[j] - 1));
-            //knotindices[j] = mHelpers[j].getDataPoint(redistributionindex[j]).iKnot; //in der Annahme der wert ist ein Knotenindex und falls der datapoint ein knoten ist, gibt er seinen eigenen knotenindex zurück
+            // knotindices[j] = mHelpers[j].getDataPoint(redistributionindex[j]).iKnot; //in der Annahme der wert ist ein Knotenindex und falls der datapoint ein knoten ist, gibt er seinen eigenen knotenindex zurück
           }
           int32_t currentknotarrayindex = pointstoarray(knotindices, numberOfKnots, mXdimensions);
           // getting the recalculated value into FParameters:
@@ -433,7 +433,7 @@ void SplineHelper<DataT>::approximateFunction(
       } // end recalculation
     } // end of all1DSplines
   } // end of for parametertypes
-} //end of approxymateFunction MYVERSION!
+} // end of approxymateFunction MYVERSION!
 
 template <typename DataT>
 int32_t SplineHelper<DataT>::test(const bool draw, const bool drawDataPoints)
diff --git a/GPU/TPCFastTransformation/SplineHelper.h b/GPU/TPCFastTransformation/SplineHelper.h
index 986297e368aab..8c99e8113864f 100644
--- a/GPU/TPCFastTransformation/SplineHelper.h
+++ b/GPU/TPCFastTransformation/SplineHelper.h
@@ -106,9 +106,9 @@ class SplineHelper
   /// Stores an error message
   int32_t storeError(Int_t code, const char* msg);
 
-  TString mError = "";     ///< error string
-  int32_t mXdimensions;    ///< number of X dimensions
-  int32_t mFdimensions;    ///< number of F dimensions
+  TString mError = "";         ///< error string
+  int32_t mXdimensions;        ///< number of X dimensions
+  int32_t mFdimensions;        ///< number of F dimensions
   int32_t mNumberOfParameters; ///< number of parameters
   int32_t mNumberOfDataPoints; ///< number of data points
   std::vector<Spline1DHelperOld<DataT>> mHelpers;
diff --git a/GPU/TPCFastTransformation/SplineSpec.h b/GPU/TPCFastTransformation/SplineSpec.h
index dae17b22f42ea..1af427dee503b 100644
--- a/GPU/TPCFastTransformation/SplineSpec.h
+++ b/GPU/TPCFastTransformation/SplineSpec.h
@@ -299,7 +299,7 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
 
     DataT iParameters[(1 << (2 * maxXdim)) * maxYdim]; // Array for all parameters
 
-    //get the indices of the "most left" Knot:
+    // get the indices of the "most left" Knot:
 
     int32_t indices[maxXdim]; // indices of the 'most left' knot
     for (int32_t i = 0; i < nXdim; i++) {
@@ -309,7 +309,7 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
     int32_t indicestmp[maxXdim];
     for (int32_t i = 0; i < nKnotParametersPerY; i++) { // for every necessary Knot
       for (int32_t k = 0; k < nXdim; k++) {
-        indicestmp[k] = indices[k] + (i / (1 << k)) % 2; //get the knot-indices in every dimension (mirrored order binary counting)
+        indicestmp[k] = indices[k] + (i / (1 << k)) % 2; // get the knot-indices in every dimension (mirrored order binary counting)
       }
       int32_t index = TBase::getKnotIndex(indicestmp); // get index of the current Knot
 
@@ -317,7 +317,7 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
         iParameters[i * nKnotParameters + j] = Parameters[index * nKnotParameters + j];
       }
     }
-    //now start with the interpolation loop:
+    // now start with the interpolation loop:
 
     constexpr auto maxInterpolations = (1 << (2 * maxXdim - 2)) * maxYdim;
 
@@ -329,10 +329,10 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
     int32_t nInterpolations = (1 << (2 * nXdim - 2)) * nYdim;
     int32_t nKnots = 1 << (nXdim);
 
-    for (int32_t d = 0; d < nXdim; d++) {        // for every dimension
-      DataT* pointer[4] = {S0, D0, S1, D1};      // pointers for interpolation arrays S0, D0, S1, D1 point to Arraystart
-      for (int32_t i = 0; i < nKnots; i++) {     // for every knot
-        for (int32_t j = 0; j < nKnots; j++) {   // for every parametertype
+    for (int32_t d = 0; d < nXdim; d++) {            // for every dimension
+      DataT* pointer[4] = {S0, D0, S1, D1};          // pointers for interpolation arrays S0, D0, S1, D1 point to Arraystart
+      for (int32_t i = 0; i < nKnots; i++) {         // for every knot
+        for (int32_t j = 0; j < nKnots; j++) {       // for every parametertype
           int32_t pointernr = 2 * (i % 2) + (j % 2); // to which array should it be delivered
           for (int32_t k = 0; k < nYdim; k++) {
             pointer[pointernr][0] = iParameters[(i * nKnots + j) * nYdim + k];
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index c353f3f3329e7..9589ecbfc1fc4 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -43,7 +43,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// \brief The struct contains necessary info for TPC padrow
   ///
   struct RowInfo {
-    int32_t splineScenarioID{0}; ///< scenario index (which of Spline2D splines to use)
+    int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
     size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC slice
     ClassDefNV(RowInfo, 1);
   };
diff --git a/GPU/TPCFastTransformation/devtools/IrregularSpline2D3DCalibrator.cxx b/GPU/TPCFastTransformation/devtools/IrregularSpline2D3DCalibrator.cxx
index 27500d12d9d5d..7eea34c19ec25 100644
--- a/GPU/TPCFastTransformation/devtools/IrregularSpline2D3DCalibrator.cxx
+++ b/GPU/TPCFastTransformation/devtools/IrregularSpline2D3DCalibrator.cxx
@@ -428,7 +428,7 @@ double IrregularSpline2D3DCalibrator::getIntegralDeviationLine(const IrregularSp
     double d2 = dx * dx + dy * dy + dz * dz;
     sum += sqrt(d2 / 3.);
   }
-  //sum = sqrt(sum/3.);
+  // sum = sqrt(sum/3.);
   return sum;
 }
 
diff --git a/GPU/TPCFastTransformation/devtools/RegularSpline1D.h b/GPU/TPCFastTransformation/devtools/RegularSpline1D.h
index 2398ff4cd1cbc..885b2e12eea0b 100644
--- a/GPU/TPCFastTransformation/devtools/RegularSpline1D.h
+++ b/GPU/TPCFastTransformation/devtools/RegularSpline1D.h
@@ -97,11 +97,11 @@ inline T RegularSpline1D::getSpline(const int32_t iknot1, T f0, T f1, T f2, T f3
   /// The polynom is constructed with function values f0,f1,f2,f3 at knots {iknot0,iknot1,iknot2,iknot3}
   /// The u value supposed to be inside the [knot1,knot2] region, but also may be any.
 
-  ///f0 = f value at iknot1-1
-  ///f1 = f value at iknot1
-  ///f2 = f value at iknot1+1
-  ///f3 = f value at iknot1+2
-  ///u = u value where f(u) is searched for.
+  /// f0 = f value at iknot1-1
+  /// f1 = f value at iknot1
+  /// f2 = f value at iknot1+1
+  /// f3 = f value at iknot1+2
+  /// u = u value where f(u) is searched for.
 
   f0 -= f1;
   f2 -= f1;
@@ -153,7 +153,7 @@ inline double RegularSpline1D::knotIndexToU(int32_t iknot) const
 
 inline int32_t RegularSpline1D::getKnotIndex(float u) const
 {
-  //index is just u elem [0, 1] * numberOfKnots and then floored. (so the "left" coordinate beside u gets chosen)
+  // index is just u elem [0, 1] * numberOfKnots and then floored. (so the "left" coordinate beside u gets chosen)
   int32_t index = (int32_t)(u * (mNumberOfKnots - 1));
   if (index <= 1) {
     index = 1;
diff --git a/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.cxx b/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.cxx
index 076e4ee0ed780..c030bae650414 100644
--- a/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.cxx
+++ b/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.cxx
@@ -110,7 +110,7 @@ void SemiregularSpline2D3D::construct(const int32_t numberOfRowsInput, const int
 
   FlatObject::startConstruction();
 
-  //construct regular grid for v
+  // construct regular grid for v
   mGridV.construct(numberOfRows);
 
   // For each x element numbersOfKnots may be a single RegularSpline1D with x knots.
@@ -128,7 +128,7 @@ void SemiregularSpline2D3D::construct(const int32_t numberOfRowsInput, const int
   // this is the space which is taken just by the RegularSpline1D's
   mDataIndexMapOffset = numberOfRows * sizeof(RegularSpline1D);
 
-  //The buffer size is the size of the array
+  // The buffer size is the size of the array
   FlatObject::finishConstruction(mDataIndexMapOffset + numberOfRows * sizeof(int32_t));
 
   // Array for the 1D-Splines inside the buffer
@@ -146,7 +146,7 @@ void SemiregularSpline2D3D::construct(const int32_t numberOfRowsInput, const int
     numberOfKnots += knotsU;
   }
 
-  //save the numberOfRows and numberOfKnots
+  // save the numberOfRows and numberOfKnots
   mNumberOfRows = numberOfRows;
   mNumberOfKnots = numberOfKnots;
 
@@ -156,7 +156,7 @@ void SemiregularSpline2D3D::construct(const int32_t numberOfRowsInput, const int
   // this will count the amount of u-knots "under" a v-coordinate
   int32_t uSum = 0;
 
-  //count the amount of knots which are in gridU's lower than i
+  // count the amount of knots which are in gridU's lower than i
   for (int32_t dv = 0; dv < mNumberOfRows; dv++) {
     dataIndexMap[dv] = uSum;
     uSum += numbersOfKnots[dv];
diff --git a/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h b/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h
index 4da954c8096ac..954738fa74f1b 100644
--- a/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h
+++ b/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h
@@ -122,7 +122,7 @@ class SemiregularSpline2D3D : public FlatObject
   const RegularSpline1D& getGridV() const { return mGridV; }
 
   /// Get 1-D grid for V coordinate
-  //const RegularSpline1D& getGridV() const { return mGridV; }
+  // const RegularSpline1D& getGridV() const { return mGridV; }
   const RegularSpline1D& getGridU(const int32_t i) const { return getSplineArray()[i]; }
 
   /// Get u,v of i-th knot
@@ -131,7 +131,7 @@ class SemiregularSpline2D3D : public FlatObject
   /// Get size of the mFlatBuffer data
   size_t getFlatBufferSize() const { return mFlatBufferSize; }
 
-  ///Gets the knot index which is the i-th knot in v-space and the j-th knot in u-space
+  /// Gets the knot index which is the i-th knot in v-space and the j-th knot in u-space
   int32_t getDataIndex(int32_t i, int32_t j) const;
   int32_t getDataIndex0(int32_t i, int32_t j) const;
 
@@ -212,16 +212,16 @@ inline void SemiregularSpline2D3D::getKnotUV(int32_t iKnot, float& u, float& v)
     // the searched u-v-coordinates have to be in this spline.
     if (iKnot <= nk - 1) {
 
-      //in that case v is the current index
+      // in that case v is the current index
       v = mGridV.knotIndexToU(i);
 
-      //and u the coordinate of the given index
+      // and u the coordinate of the given index
       u = gridU.knotIndexToU(iKnot);
       break;
     }
 
-    //if iKnot is greater than number of knots the searched u-v cannot be in the current gridU
-    //so we search for nk less indizes and continue with the next v-coordinate
+    // if iKnot is greater than number of knots the searched u-v cannot be in the current gridU
+    // so we search for nk less indizes and continue with the next v-coordinate
     iKnot -= nk;
   }
 }
@@ -229,16 +229,16 @@ inline void SemiregularSpline2D3D::getKnotUV(int32_t iKnot, float& u, float& v)
 template <typename T>
 inline void SemiregularSpline2D3D::correctEdges(T* data) const
 {
-  //Regular v-Grid (vertical)
+  // Regular v-Grid (vertical)
   const RegularSpline1D& gridV = getGridV();
 
   int32_t nv = mNumberOfRows;
 
-  //EIGENTLICH V VOR U!!!
-  //Wegen Splines aber U vor V
+  // EIGENTLICH V VOR U!!!
+  // Wegen Splines aber U vor V
 
   { // ==== left edge of U ====
-    //loop through all gridUs
+    // loop through all gridUs
     for (int32_t iv = 1; iv < mNumberOfRows - 1; iv++) {
       T* f0 = data + getDataIndex(0, iv);
       T* f1 = f0 + 3;
@@ -251,7 +251,7 @@ inline void SemiregularSpline2D3D::correctEdges(T* data) const
   }
 
   { // ==== right edge of U ====
-    //loop through all gridUs
+    // loop through all gridUs
     for (int32_t iv = 1; iv < mNumberOfRows - 1; iv++) {
       const RegularSpline1D& gridU = getGridU(iv);
       int32_t nu = gridU.getNumberOfKnots();
@@ -270,8 +270,8 @@ inline void SemiregularSpline2D3D::correctEdges(T* data) const
     int32_t nu = gridU.getNumberOfKnots();
 
     for (int32_t iu = 0; iu < nu; iu++) {
-      //f0 to f3 are the x,y,z values of 4 points in the grid along the v axis.
-      //Since there are no knots because of the irregularity you can get this by using the getSplineMethod.
+      // f0 to f3 are the x,y,z values of 4 points in the grid along the v axis.
+      // Since there are no knots because of the irregularity you can get this by using the getSplineMethod.
       T* f0 = data + getDataIndex(iu, 0);
       float u = gridU.knotIndexToU(iu);
 
@@ -387,7 +387,7 @@ inline void SemiregularSpline2D3D::getSpline(const T* correctedData, float u, fl
     dataVx[vxIndex + 2] = gridU.getSpline(ui, correctedData[dataOffset + 2], correctedData[dataOffset + 5], correctedData[dataOffset + 8], correctedData[dataOffset + 11], u);
   }
 
-  //return results
+  // return results
   x = mGridV.getSpline(iknotv, dataVx[0], dataVx[3], dataVx[6], dataVx[9], v);
   y = mGridV.getSpline(iknotv, dataVx[1], dataVx[4], dataVx[7], dataVx[10], v);
   z = mGridV.getSpline(iknotv, dataVx[2], dataVx[5], dataVx[8], dataVx[11], v);
@@ -426,7 +426,7 @@ inline void SemiregularSpline2D3D::getSplineVec(const float* correctedData, floa
 
   */
 
-  //workaround 1:
+  // workaround 1:
   int32_t vGridi = mGridV.getKnotIndex(v);
 
   float dataU[12];
@@ -464,7 +464,7 @@ inline void SemiregularSpline2D3D::getSplineVec(const float* correctedData, floa
   y = res[1];
   z = res[2];
 
-//getSpline( correctedData, u, v, x, y, z );
+// getSpline( correctedData, u, v, x, y, z );
 #else
   getSpline(correctedData, u, v, x, y, z);
 #endif
diff --git a/GPU/TPCFastTransformation/test/testMultivarPolynomials.cxx b/GPU/TPCFastTransformation/test/testMultivarPolynomials.cxx
index a9c39e8528354..f77a55ffcc894 100644
--- a/GPU/TPCFastTransformation/test/testMultivarPolynomials.cxx
+++ b/GPU/TPCFastTransformation/test/testMultivarPolynomials.cxx
@@ -95,7 +95,7 @@ BOOST_AUTO_TEST_CASE(Polynomials5D_InteractionOnly)
   const int32_t nPar5D5DegInteraction = 32; // number of parameters
   const int32_t nDim = 5;                   // dimensions
   const int32_t nDegree = 5;                // degree
-  const float abstolerance = 0.0001f;   // abosulte difference between refernce to polynomial class
+  const float abstolerance = 0.0001f;       // abosulte difference between refernce to polynomial class
   const bool interactionOnly = true;
 
   MultivariatePolynomial<nDim, nDegree, interactionOnly> polCT;       // compile time polynomial
@@ -142,7 +142,7 @@ BOOST_AUTO_TEST_CASE(Piecewise_polynomials)
   const int32_t nPar5D5DegInteraction = 32; // number of parameters
   const int32_t nDim = 5;                   // dimensions
   const int32_t nDegree = 5;                // degree
-  const bool interactionOnly = true;    // consider only interaction terms
+  const bool interactionOnly = true;        // consider only interaction terms
 
   // reference polynomial which will be approximated by the NDPiecewisePolynomials
   MultivariatePolynomial<nDim, nDegree, interactionOnly> polCT;
diff --git a/GPU/Utils/FlatObject.h b/GPU/Utils/FlatObject.h
index eba81a2ba06a2..8e13a8dedb868 100644
--- a/GPU/Utils/FlatObject.h
+++ b/GPU/Utils/FlatObject.h
@@ -28,7 +28,7 @@
 #include "GPUCommonRtypes.h"
 #include "GPUCommonLogger.h"
 
-//#define GPUCA_GPUCODE // uncomment to test "GPU" mode
+// #define GPUCA_GPUCODE // uncomment to test "GPU" mode
 
 namespace o2
 {
@@ -319,10 +319,10 @@ class FlatObject
     InProgress = 0x2      ///< construction started: temporary  memory is reserved
   };
 
-  int32_t mFlatBufferSize = 0;                                        ///< size of the flat buffer
-  uint32_t mConstructionMask = ConstructionState::NotConstructed;     ///< mask for constructed object members, first two bytes are used by this class
-  char* mFlatBufferContainer = nullptr;                               //[mFlatBufferSize]  Optional container for the flat buffer
-  char* mFlatBufferPtr = nullptr;                                     //!  Pointer to the flat buffer
+  int32_t mFlatBufferSize = 0;                                    ///< size of the flat buffer
+  uint32_t mConstructionMask = ConstructionState::NotConstructed; ///< mask for constructed object members, first two bytes are used by this class
+  char* mFlatBufferContainer = nullptr;                           //[mFlatBufferSize]  Optional container for the flat buffer
+  char* mFlatBufferPtr = nullptr;                                 //!  Pointer to the flat buffer
 
   ClassDefNV(FlatObject, 1);
 };
@@ -569,7 +569,7 @@ inline void FlatObject::setFutureBufferAddress(char* futureFlatBufferPtr)
   mFlatBufferContainer = nullptr;
 }
 
-#endif //GPUCA_GPUCODE_DEVICE
+#endif // GPUCA_GPUCODE_DEVICE
 
 } // namespace gpu
 } // namespace o2
diff --git a/GPU/Workflow/helper/src/GPUWorkflowHelper.cxx b/GPU/Workflow/helper/src/GPUWorkflowHelper.cxx
index 52c3421fa8eb5..a9c9b78e9847e 100644
--- a/GPU/Workflow/helper/src/GPUWorkflowHelper.cxx
+++ b/GPU/Workflow/helper/src/GPUWorkflowHelper.cxx
@@ -51,7 +51,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
         ioPtr.itsClusterMC = ITSClsLabels;
       }
     }
-    //LOG(info) << "Got " << ioPtr.nItsClusters << " ITS Clusters";
+    // LOG(info) << "Got " << ioPtr.nItsClusters << " ITS Clusters";
   }
   if (maskTrk[GID::ITS] && ioPtr.nItsTracks == 0) {
     const auto& ITSTracksArray = recoCont.getITSTracks();
@@ -68,7 +68,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
         ioPtr.itsTrackMC = ITSTrkLabels.data();
       }
     }
-    //LOG(info) << "Got " << ioPtr.nItsTracks << " ITS Tracks";
+    // LOG(info) << "Got " << ioPtr.nItsTracks << " ITS Tracks";
   }
 
   if (maskTrk[GID::ITSTPC] && ioPtr.nTracksTPCITSO2 == 0) {
@@ -77,7 +77,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       ioPtr.nTracksTPCITSO2 = trkITSTPC.size();
       ioPtr.tracksTPCITSO2 = trkITSTPC.data();
     }
-    //LOG(info) << "Got " << ioPtr.nTracksTPCITSO2 << " ITS-TPC Tracks";
+    // LOG(info) << "Got " << ioPtr.nTracksTPCITSO2 << " ITS-TPC Tracks";
   }
 
   if (maskCl[GID::TOF] && ioPtr.nTOFClusters == 0) {
@@ -86,7 +86,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       ioPtr.nTOFClusters = tofClusters.size();
       ioPtr.tofClusters = tofClusters.data();
     }
-    //LOG(info) << "Got " << ioPtr.nTOFClusters << " TOF Clusters";
+    // LOG(info) << "Got " << ioPtr.nTOFClusters << " TOF Clusters";
   }
 
   if ((maskMatch[GID::TOF] || maskMatch[GID::ITSTPCTOF]) && ioPtr.nITSTPCTOFMatches == 0) {
@@ -95,7 +95,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       ioPtr.nITSTPCTOFMatches = itstpctofMatches.size();
       ioPtr.itstpctofMatches = itstpctofMatches.data();
     }
-    //LOG(info) << "Got " << ioPtr.nITSTPCTOFMatches << " ITS-TPC-TOF Matches";
+    // LOG(info) << "Got " << ioPtr.nITSTPCTOFMatches << " ITS-TPC-TOF Matches";
   }
 
   if ((maskMatch[GID::TOF] || maskMatch[GID::ITSTPCTRDTOF]) && ioPtr.nITSTPCTRDTOFMatches == 0) {
@@ -104,7 +104,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       ioPtr.nITSTPCTRDTOFMatches = itstpctrdtofMatches.size();
       ioPtr.itstpctrdtofMatches = itstpctrdtofMatches.data();
     }
-    //LOG(info) << "Got " << ioPtr.nITSTPCTRDTOFMatches << " ITS-TPC-TRD-TOF Matches";
+    // LOG(info) << "Got " << ioPtr.nITSTPCTRDTOFMatches << " ITS-TPC-TRD-TOF Matches";
   }
 
   if ((maskMatch[GID::TOF] || maskMatch[GID::TPCTOF]) && ioPtr.nTPCTOFMatches == 0) {
@@ -113,7 +113,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       ioPtr.nTPCTOFMatches = tpctofMatches.size();
       ioPtr.tpctofMatches = tpctofMatches.data();
     }
-    //LOG(info) << "Got " << ioPtr.nTPCTOFMatches << " TPC-TOF Matches";
+    // LOG(info) << "Got " << ioPtr.nTPCTOFMatches << " TPC-TOF Matches";
   }
 
   if ((maskMatch[GID::TOF] || maskMatch[GID::TPCTRDTOF]) && ioPtr.nTPCTRDTOFMatches == 0) {
@@ -122,12 +122,12 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       ioPtr.nTPCTRDTOFMatches = tpctrdtofMatches.size();
       ioPtr.tpctrdtofMatches = tpctrdtofMatches.data();
     }
-    //LOG(info) << "Got " << ioPtr.nTPCTOFMatches << " TPC-TOF Matches";
+    // LOG(info) << "Got " << ioPtr.nTPCTOFMatches << " TPC-TOF Matches";
   }
 
   if (maskCl[GID::TRD]) {
     recoCont.inputsTRD->fillGPUIOPtr(&ioPtr);
-    //LOG(info) << "Got " << ioPtr.nTRDTracklets << " TRD Tracklets";
+    // LOG(info) << "Got " << ioPtr.nTRDTracklets << " TRD Tracklets";
   }
 
   if (maskTrk[GID::ITSTPCTRD] && ioPtr.nTRDTracksITSTPCTRD == 0) {
@@ -136,7 +136,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       ioPtr.nTRDTracksITSTPCTRD = trdTracks.size();
       ioPtr.trdTracksITSTPCTRD = trdTracks.data();
     }
-    //LOG(info) << "Got " << ioPtr.nTRDTracksITSTPCTRD << " ITS-TPC-TRD Tracks";
+    // LOG(info) << "Got " << ioPtr.nTRDTracksITSTPCTRD << " ITS-TPC-TRD Tracks";
   }
 
   if (maskTrk[GID::TPCTRD] && ioPtr.nTRDTracksTPCTRD == 0) {
@@ -145,12 +145,12 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       ioPtr.nTRDTracksTPCTRD = trdTracks.size();
       ioPtr.trdTracksTPCTRD = trdTracks.data();
     }
-    //LOG(info) << "Got " << ioPtr.nTRDTracksTPCTRD << " TPC-TRD Tracks";
+    // LOG(info) << "Got " << ioPtr.nTRDTracksTPCTRD << " TPC-TRD Tracks";
   }
 
   if (maskCl[GID::TPC] && ioPtr.clustersNative == nullptr) {
     ioPtr.clustersNative = &recoCont.getTPCClusters();
-    //LOG(info) << "Got " << ioPtr.clustersNative->nClustersTotal << " TPC Clusters";
+    // LOG(info) << "Got " << ioPtr.clustersNative->nClustersTotal << " TPC Clusters";
   }
 
   if (maskTrk[GID::TPC] && ioPtr.nOutputTracksTPCO2 == 0) {
@@ -176,7 +176,7 @@ std::shared_ptr<const GPUWorkflowHelper::tmpDataContainer> GPUWorkflowHelper::fi
       retVal->tpcLinkTRD.resize(ioPtr.nOutputTracksTPCO2, -1);
       ioPtr.tpcLinkTRD = retVal->tpcLinkTRD.data();
     }
-    //LOG(info) << "Got " << ioPtr.nOutputTracksTPCO2 << " TPC Tracks";
+    // LOG(info) << "Got " << ioPtr.nOutputTracksTPCO2 << " TPC Tracks";
   }
 
   auto creator = [maskTrk, &ioPtr, &recoCont, &retVal](auto& trk, GID gid, float time, float) {

From 1838f8fa4746d146815b9e3855e3ebcc69802ab6 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 14 Mar 2025 22:34:57 +0100
Subject: [PATCH 0075/1764] GPU dpl-worflow: Remove HSA_NO_SCRATCH_RECLAIM=1
 optimization for MI50, with latest ROCm actually decreases performance...

---
 prodtests/full-system-test/dpl-workflow.sh | 1 -
 1 file changed, 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 76235d127037a..5259bbf951d73 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -259,7 +259,6 @@ if [[ $GPUTYPE == "HIP" ]]; then
     TIMESLICEOFFSET=$(($GPU_FIRST_ID + ($NUMAGPUIDS != 0 ? ($NGPUS * $NUMAID) : 0)))
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
-  [[ ${EPN_NODE_MI100:-} != "1" ]] && export HSA_NO_SCRATCH_RECLAIM=1
   [[ $EPNSYNCMODE == 1 || ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else

From 07cdaf8b104c494953904574f06fd3a12bcac879 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 09:09:14 +0100
Subject: [PATCH 0076/1764] GPU HIP: #define no longer needed, rocthrust does
 it internally

---
 GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h
index c7a1b4f55e501..5506e3925bf80 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h
@@ -15,8 +15,6 @@
 #ifndef O2_GPU_RECONSTRUCTIONHIPINCLUDES_H
 #define O2_GPU_RECONSTRUCTIONHIPINCLUDES_H
 
-#define __HIP_ENABLE_DEVICE_MALLOC__ 1 // Fix SWDEV-239120
-
 #include <hip/hip_runtime.h>
 #include <hip/hip_ext.h>
 #include <hipcub/hipcub.hpp>

From e4d7d36915b667590cb11139a4d972fbb2df9e1b Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Mon, 17 Mar 2025 10:55:51 +0100
Subject: [PATCH 0077/1764] ITS-GPU: remove debug options in production

---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index e2fc1f1388ad0..3cdb107e07438 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -13,7 +13,7 @@
 if(CUDA_ENABLED)
 find_package(CUDAToolkit)
 message(STATUS "Building ITS CUDA tracker")
-add_compile_options(-O0 -g -lineinfo -fPIC)
+# add_compile_options(-O0 -g -lineinfo -fPIC)
 # add_compile_definitions(ITS_MEASURE_GPU_TIME)
 o2_add_library(ITStrackingCUDA
                SOURCES ClusterLinesGPU.cu

From 203973d51038cd46734b6b8ce3a232b5ff913753 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 17 Mar 2025 12:05:52 +0100
Subject: [PATCH 0078/1764] Drop unneeded minimum requirement (#14075)

---
 Framework/Foundation/CMakeLists.txt | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Framework/Foundation/CMakeLists.txt b/Framework/Foundation/CMakeLists.txt
index 65a43073ef9d8..dc6d7238c60ac 100644
--- a/Framework/Foundation/CMakeLists.txt
+++ b/Framework/Foundation/CMakeLists.txt
@@ -8,8 +8,6 @@
 # In applying this license CERN does not waive the privileges and immunities
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
-cmake_minimum_required(VERSION 3.5)
-
 install(DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/include/Framework
         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 

From 900e6245e8a977bd9dfc0d96df1fbd5b3fd15850 Mon Sep 17 00:00:00 2001
From: pillot <pillot@subatech.in2p3.fr>
Date: Sun, 16 Mar 2025 13:49:31 +0100
Subject: [PATCH 0079/1764] fix compiler warning about printf format

---
 .../MCH/Conditions/src/scan-hvlv-ccdb.cxx     | 56 ++++++++++---------
 1 file changed, 29 insertions(+), 27 deletions(-)

diff --git a/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx b/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
index 307759c97a0c3..236effc4b1182 100644
--- a/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
+++ b/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
@@ -56,6 +56,7 @@ using DPBMAP = std::map<uint64_t, uint64_t>;
 using ISSUE = std::tuple<uint64_t, uint64_t, double, double, std::string>;
 using ISSUELIST = std::vector<ISSUE>;
 using ISSUEMAP = std::map<std::string, ISSUELIST>;
+using ULL = unsigned long long;
 
 //----------------------------------------------------------------------------
 bool containsAKey(std::string data, const std::set<std::string>& Keys)
@@ -238,14 +239,14 @@ void checkRunBoundaries(const RBMAP& runBoundaries)
   for (const auto& [run, boundaries] : runBoundaries) {
     if (boundaries.second <= boundaries.first) {
       printf("error: run %d EOR <= SOR: %llu - %llu (%s - %s)\n",
-             run, boundaries.first, boundaries.second,
+             run, (ULL)boundaries.first, (ULL)boundaries.second,
              getTime(boundaries.first).c_str(), getTime(boundaries.second).c_str());
       error = true;
     }
     if (boundaries.first <= endOfPreviousRun) {
       printf("error: SOR run %d <= EOR run %d: %llu (%s) <= %llu (%s)\n",
-             run, previousRun, boundaries.first, getTime(boundaries.first).c_str(),
-             endOfPreviousRun, getTime(endOfPreviousRun).c_str());
+             run, previousRun, (ULL)boundaries.first, getTime(boundaries.first).c_str(),
+             (ULL)endOfPreviousRun, getTime(endOfPreviousRun).c_str());
       error = true;
     }
     previousRun = run;
@@ -266,7 +267,7 @@ void printRunBoundaries(const RBMAP& runBoundaries)
   printf("------------------------------------\n");
 
   for (const auto& [run, boundaries] : runBoundaries) {
-    printf("%d: %llu - %llu (%s - %s)\n", run, boundaries.first, boundaries.second,
+    printf("%d: %llu - %llu (%s - %s)\n", run, (ULL)boundaries.first, (ULL)boundaries.second,
            getTime(boundaries.first).c_str(), getTime(boundaries.second).c_str());
   }
 
@@ -324,7 +325,7 @@ DPBMAP getDPBoundaries(ccdb::CcdbApi const& api, std::string what,
 
   if (dpBoundaries.empty()) {
     printf("\e[0;31merror: no file found in %s in time range %llu - %llu (%s - %s) --> use the default one\e[0m\n",
-           what.c_str(), tStart, tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
+           what.c_str(), (ULL)tStart, (ULL)tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
     dpBoundaries.emplace(1, 9999999999999);
   }
 
@@ -340,13 +341,13 @@ void checkDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV, uint64_t tStart,
 
   if (dpBoundaries.begin()->first > tStart) {
     printf("error: the beginning of the time range is not covered: %llu > %llu (%s > %s)\n",
-           dpBoundaries.begin()->first, tStart,
+           (ULL)dpBoundaries.begin()->first, (ULL)tStart,
            getTime(dpBoundaries.begin()->first).c_str(), getTime(tStart).c_str());
     error = true;
   }
   if (dpBoundaries.rbegin()->second < tStop) {
     printf("error: the end of the time range is not covered: %llu < %llu (%s < %s)\n",
-           dpBoundaries.rbegin()->second, tStop,
+           (ULL)dpBoundaries.rbegin()->second, (ULL)tStop,
            getTime(dpBoundaries.rbegin()->second).c_str(), getTime(tStop).c_str());
     error = true;
   }
@@ -355,13 +356,13 @@ void checkDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV, uint64_t tStart,
   for (auto [tStart, tStop] : dpBoundaries) {
     if (tStop <= tStart) {
       printf("error: EOF <= SOF: %llu - %llu (%s - %s)\n",
-             tStart, tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
+             (ULL)tStart, (ULL)tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
       error = true;
     }
     if (tStart != previousTStop) {
       printf("error: end of %s file != start of next %s file: %llu (%s) != %llu (%s))\n",
              scanHV ? "HV" : "LV", scanHV ? "HV" : "LV",
-             previousTStop, getTime(previousTStop).c_str(), tStart, getTime(tStart).c_str());
+             (ULL)previousTStop, getTime(previousTStop).c_str(), (ULL)tStart, getTime(tStart).c_str());
       error = true;
     }
     previousTStop = tStop;
@@ -381,10 +382,10 @@ void printDPBoundaries(const DPBMAP& dpBoundaries, bool scanHV, uint64_t timeInt
   printf("------------------------------------\n");
 
   for (auto [tStart, tStop] : dpBoundaries) {
-    printf("%llu - %llu (%s - %s)", tStart, tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
+    printf("%llu - %llu (%s - %s)", (ULL)tStart, (ULL)tStop, getTime(tStart).c_str(), getTime(tStop).c_str());
     if (tStop - tStart < 60000 * (timeInterval - 1) || tStop - tStart > 60000 * (timeInterval + 1)) {
       printf("\e[0;31m ! warning: validity range %s != %llu±1 min\e[0m\n",
-             getDuration(tStart, tStop).c_str(), timeInterval);
+             getDuration(tStart, tStop).c_str(), (ULL)timeInterval);
     } else {
       printf("\n");
     }
@@ -478,14 +479,15 @@ void fillDataPoints(const std::vector<DPVAL>& dps, std::map<uint64_t, double>& d
     auto previousTS = dps2.rbegin()->first;
     if (ts != previousTS || getValue(*itDP) != dps2.rbegin()->second) {
       if (ts <= previousTS) {
-        printf("error: wrong data point order (%llu <= %llu)\n", ts, previousTS);
+        printf("error: wrong data point order (%llu <= %llu)\n", (ULL)ts, (ULL)previousTS);
         exit(1);
       }
       if (printWarning) {
         printf("%s%s missing the previous data point (dt = %s%llu ms)", color.c_str(), header.c_str(),
-               (previousTS < tMin) ? "-" : "+", (previousTS < tMin) ? tMin - previousTS : previousTS - tMin);
+               (previousTS < tMin) ? "-" : "+",
+               (ULL)((previousTS < tMin) ? tMin - previousTS : previousTS - tMin));
         if (ts <= tMin) {
-          printf(" but get one at dt = -%llu ms\e[0m\n", tMin - ts);
+          printf(" but get one at dt = -%llu ms\e[0m\n", (ULL)(tMin - ts));
         } else {
           printf("\e[0m\n");
         }
@@ -496,11 +498,11 @@ void fillDataPoints(const std::vector<DPVAL>& dps, std::map<uint64_t, double>& d
 
   // add the first data point (should be before the start of validity of the file)
   if (ts >= tMax) {
-    printf("error: first data point exceeding file validity range (dt = +%llu ms)\n", ts - tMax);
+    printf("error: first data point exceeding file validity range (dt = +%llu ms)\n", (ULL)(ts - tMax));
     exit(1);
   } else if (ts > tMin && printWarning) {
     printf("%s%s missing data point prior file start of validity (dt = +%llu ms)\e[0m\n",
-           color.c_str(), header.c_str(), ts - tMin);
+           color.c_str(), header.c_str(), (ULL)(ts - tMin));
     header = "        ";
   }
   dps2.emplace(ts, getValue(*itDP));
@@ -510,15 +512,15 @@ void fillDataPoints(const std::vector<DPVAL>& dps, std::map<uint64_t, double>& d
   for (++itDP; itDP < dps.end(); ++itDP) {
     ts = itDP->get_epoch_time();
     if (ts <= previousTS) {
-      printf("error: wrong data point order (%llu <= %llu)\n", ts, previousTS);
+      printf("error: wrong data point order (%llu <= %llu)\n", (ULL)ts, (ULL)previousTS);
       exit(1);
     }
     if (ts < tMin && (warningLevel > 1 || (warningLevel == 1 && ts + tolerance < tMin))) {
       printf("%s%s data point outside of file validity range (dt = -%llu ms)\e[0m\n",
-             (ts + tolerance < tMin) ? "\e[0;31m" : "\e[0;34m", header.c_str(), tMin - ts);
+             (ts + tolerance < tMin) ? "\e[0;31m" : "\e[0;34m", header.c_str(), (ULL)(tMin - ts));
     } else if (ts >= tMax && warningLevel >= 1) {
       printf("\e[0;31m%s data point outside of file validity range (dt = +%llu ms)\e[0m\n",
-             header.c_str(), ts - tMax);
+             header.c_str(), (ULL)(ts - tMax));
     }
     dps2.emplace(ts, getValue(*itDP));
     previousTS = ts;
@@ -580,13 +582,13 @@ void printDataPoints(const DPMAP2 dpsMapsPerCh[10], std::string hvlvFormat, bool
 
     for (const auto& [alias, dps] : dpsMapsPerCh[ch]) {
 
-      printf("- %s: %lu values", alias.c_str(), dps.size());
+      printf("- %s: %zu values", alias.c_str(), dps.size());
 
       if (all) {
 
         printf("\n");
         for (const auto& [ts, val] : dps) {
-          printf(format1.c_str(), ts, getTime(ts).c_str(), val);
+          printf(format1.c_str(), (ULL)ts, getTime(ts).c_str(), val);
         }
 
       } else if (!dps.empty()) {
@@ -594,8 +596,8 @@ void printDataPoints(const DPMAP2 dpsMapsPerCh[10], std::string hvlvFormat, bool
         const auto firstdt = dps.begin();
         const auto lastdt = dps.rbegin();
         printf(format2.c_str(),
-               firstdt->first, getTime(firstdt->first).c_str(), firstdt->second,
-               lastdt->first, getTime(lastdt->first).c_str(), lastdt->second);
+               (ULL)firstdt->first, getTime(firstdt->first).c_str(), firstdt->second,
+               (ULL)lastdt->first, getTime(lastdt->first).c_str(), lastdt->second);
 
       } else {
         printf("\n");
@@ -719,7 +721,7 @@ void fillO2Issues(const std::vector<mch::HVStatusCreator::TimeRange>& o2issues,
     // exclude issues fully outside of the DP file boudaries
     if (itIssue->end <= tMin || itIssue->begin >= tMax) {
       printf("\e[0;35mwarning: skipping O2 issue outside of file boundaries (%llu - %llu)\e[0m\n",
-             itIssue->begin, itIssue->end);
+             (ULL)itIssue->begin, (ULL)itIssue->end);
       continue;
     }
 
@@ -727,14 +729,14 @@ void fillO2Issues(const std::vector<mch::HVStatusCreator::TimeRange>& o2issues,
     if (itIssue->begin < tMin - mch::StatusMapCreatorParam::Instance().timeMargin &&
         (itIssue != o2issues.begin() || itIssue->begin != 0)) {
       printf("\e[0;35mwarning: O2 returns an issue with uncommon start time (%llu < %llu)\e[0m\n",
-             itIssue->begin, tMin - mch::StatusMapCreatorParam::Instance().timeMargin);
+             (ULL)itIssue->begin, (ULL)(tMin - mch::StatusMapCreatorParam::Instance().timeMargin));
     }
 
     // only the last issue could in principle extend beyond the end of the DP file, to infinity
     if (itIssue->end >= tMax + mch::StatusMapCreatorParam::Instance().timeMargin &&
         (itIssue != std::prev(o2issues.end()) || itIssue->end != std::numeric_limits<uint64_t>::max())) {
       printf("\e[0;35mwarning: O2 returns an issue with uncommon end time (%llu >= %llu)\e[0m\n",
-             itIssue->end, tMax + mch::StatusMapCreatorParam::Instance().timeMargin);
+             (ULL)itIssue->end, (ULL)(tMax + mch::StatusMapCreatorParam::Instance().timeMargin));
     }
 
     // extend the last issue in case of continuity accross the DP files or add a new one,
@@ -897,7 +899,7 @@ void printIssues(const ISSUEMAP issuesPerCh[10], const ISSUEMAP o2IssuesPerCh[10
   auto printIssue = [&format](ISSUE issue, std::string color) {
     const auto& [tStart, tStop, min, mean, runs] = issue;
     printf("%s", color.c_str());
-    printf(format.c_str(), tStart, tStop,
+    printf(format.c_str(), (ULL)tStart, (ULL)tStop,
            getTime(tStart).c_str(), getDuration(tStart, tStop).c_str(), min, mean, runs.c_str());
     printf("\e[0m");
   };

From c39a87024ea2bd73db083972deae4c58ef8350ed Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Mon, 3 Feb 2025 10:32:02 +0100
Subject: [PATCH 0080/1764] Promoting critical Error logs to ILG Ops level

---
 Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx b/Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx
index b625ab344e112..d7a7282a78684 100644
--- a/Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx
+++ b/Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx
@@ -77,7 +77,7 @@ class EPNMonitor
   std::unordered_map<std::string, fileMon> mFiles;
   std::string mPath;
   std::vector<std::regex> mFilters;
-  std::unordered_map<std::string, std::pair<InfoLogger::InfoLogger::Severity, int>> mMapRootLogTypes;
+  std::unordered_map<std::string, std::pair<InfoLogger::InfoLogger::Severity, int>> mMapLogTypes;
   volatile unsigned int mRunNumber;
   std::string mPartition;
   unsigned int nLines = 0;
@@ -95,12 +95,11 @@ EPNMonitor::EPNMonitor(std::string path, bool infoLogger, int runNumber, std::st
   mFilters.emplace_back("^Warning in <TGraph");
   mFilters.emplace_back("^Warning in <TInterpreter");
   mFilters.emplace_back("Dividing histograms with different labels");
-  mMapRootLogTypes.emplace("Info in <", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Info, 13});
-  mMapRootLogTypes.emplace("Print in <", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Info, 13});
-  mMapRootLogTypes.emplace("Warning in <", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Warning, 11});
-  mMapRootLogTypes.emplace("Error in <", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Error, 2});
-  mMapRootLogTypes.emplace("Fatal in <", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Fatal, 1});
-  mMapRootLogTypes.emplace("*** Break ***", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Fatal, 1});
+  mMapLogTypes.emplace("(core dumped)", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Error, 1});
+  mMapLogTypes.emplace("Warning in <", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Warning, 11});
+  mMapLogTypes.emplace("Error in <", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Error, 2});
+  mMapLogTypes.emplace("Fatal in <", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Fatal, 1});
+  mMapLogTypes.emplace("*** Break ***", std::pair<InfoLogger::InfoLogger::Severity, int>{InfoLogger::InfoLogger::Severity::Fatal, 1});
   mInfoLoggerActive = infoLogger;
   mPath = path;
   mRunNumber = runNumber;
@@ -214,7 +213,7 @@ void EPNMonitor::thread()
             // assign proper severity / level for remaining ROOT log messages
             auto severity{InfoLogger::InfoLogger::Severity::Error};
             int level{3};
-            for (const auto& logType : mMapRootLogTypes) {
+            for (const auto& logType : mMapLogTypes) {
               if (line.find(logType.first) != std::string::npos) {
                 severity = std::get<InfoLogger::InfoLogger::Severity>(logType.second);
                 level = std::get<int>(logType.second);

From 79ea4b7a5091d0613f7a5b49fd96e9e385c20b21 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 12 Feb 2025 15:31:14 +0100
Subject: [PATCH 0081/1764] Promoting DPL errors relevant to the ECS shifter to
 critical, leaving messages to be ignored at error

---
 Detectors/TPC/workflow/src/IDCToVectorSpec.cxx | 6 +++---
 Framework/Core/src/CommonServices.cxx          | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx b/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
index 27dbcf5d85bbf..e9433c775a02a 100644
--- a/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
+++ b/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
@@ -405,7 +405,7 @@ class IDCToVectorDevice : public o2::framework::Task
 
       for (const auto& inf : infVec) {
         if (!inf.hasBothEPs()) {
-          LOGP(error, "IDC CRU {:3}: data missing at ({:8}, {:4}) for one or both end points {:02b} in TF {}", cru, inf.heartbeatOrbit, inf.heartbeatBC, inf.epSeen, tfCounter);
+          LOGP(critical, "IDC CRU {:3}: data missing at ({:8}, {:4}) for one or both end points {:02b} in TF {}", cru, inf.heartbeatOrbit, inf.heartbeatBC, inf.epSeen, tfCounter);
           hasErrors = true;
         }
       }
@@ -417,12 +417,12 @@ class IDCToVectorDevice : public o2::framework::Task
       }
 
       if (packetsInTF != infVec.size()) {
-        LOGP(error, "IDC CRU {:3}: number of IDC packets {} does not match max over all CRUs {} in TF {}", cru, packetsInTF, infVec.size(), tfCounter);
+        LOGP(critical, "IDC CRU {:3}: number of IDC packets {} does not match max over all CRUs {} in TF {}", cru, packetsInTF, infVec.size(), tfCounter);
         hasErrors = true;
       }
 
       if (!std::equal(infVecComp->begin(), infVecComp->end(), infVec.begin())) {
-        LOGP(error, "IDC CRU {:3}: mismatch in orbit numbers", cru);
+        LOGP(critical, "IDC CRU {:3}: mismatch in orbit numbers", cru);
         hasErrors = true;
       }
     }
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 95836adc02171..cc3c920bc7be1 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -579,7 +579,7 @@ auto decongestionCallbackOrdered = [](AsyncTask& task, size_t id) -> void {
     if (state.transitionHandling != TransitionHandlingState::NoTransition && DefaultsHelpers::onlineDeploymentMode()) {
       O2_SIGNPOST_EVENT_EMIT_WARN(async_queue, cid, "oldest_possible_timeslice", "Stop transition requested. Some Lifetime::Timeframe data got dropped starting at %" PRIi64, oldNextTimeslice);
     } else {
-      O2_SIGNPOST_EVENT_EMIT_ERROR(async_queue, cid, "oldest_possible_timeslice", "Some Lifetime::Timeframe data got dropped starting at %" PRIi64, oldNextTimeslice);
+      O2_SIGNPOST_EVENT_EMIT_CRITICAL(async_queue, cid, "oldest_possible_timeslice", "Some Lifetime::Timeframe data got dropped starting at %" PRIi64, oldNextTimeslice);
     }
     timesliceIndex.rescan();
   }
@@ -650,7 +650,7 @@ o2::framework::ServiceSpec
           if (state.transitionHandling != TransitionHandlingState::NoTransition && DefaultsHelpers::onlineDeploymentMode()) {
             O2_SIGNPOST_EVENT_EMIT_WARN(data_processor_context, cid, "oldest_possible_timeslice", "Stop transition requested. Some Lifetime::Timeframe data got dropped starting at %" PRIi64, oldNextTimeslice);
           } else {
-            O2_SIGNPOST_EVENT_EMIT_ERROR(data_processor_context, cid, "oldest_possible_timeslice", "Some Lifetime::Timeframe data got dropped starting at %" PRIi64, oldNextTimeslice);
+            O2_SIGNPOST_EVENT_EMIT_CRITICAL(data_processor_context, cid, "oldest_possible_timeslice", "Some Lifetime::Timeframe data got dropped starting at %" PRIi64, oldNextTimeslice);
           }
           timesliceIndex.rescan();
         }

From 74c2ec27488b2c0874884cb016b3d36771ffd7d9 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Mon, 17 Mar 2025 17:22:54 +0100
Subject: [PATCH 0082/1764] Bump nvToolsExt (#14074)

---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt | 1 -
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu   | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index 3cdb107e07438..531cf2b0dcd33 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -33,7 +33,6 @@ o2_add_library(ITStrackingCUDA
                                      O2::SimulationDataFormat
                                      O2::ReconstructionDataFormats
                                      O2::GPUCommon
-                                     CUDA::nvToolsExt
                PRIVATE_LINK_LIBRARIES O2::GPUTrackingCUDAExternalProvider
                TARGETVARNAME targetName)
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu
index 0bca6360d268c..7c42658242231 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu
@@ -13,7 +13,7 @@
 #include "ITStrackingGPU/TracerGPU.h"
 
 #if !defined(__HIPCC__) && defined(__USE_GPU_TRACER__)
-#include "nvToolsExt.h"
+#include <nvtx3/nvToolsExt.h>
 
 constexpr uint32_t colors[] = {0xff00ff00, 0xff0000ff, 0xffffff00, 0xffff00ff, 0xff00ffff, 0xffff0000, 0xffffffff};
 constexpr int num_colors = sizeof(colors) / sizeof(uint32_t);

From 64abf5c5e675edbef70cf21ae4a71b499246fb73 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 15:16:10 +0100
Subject: [PATCH 0083/1764] GPU: Fix GPUChkErr macro, GPU::Common should not
 use GPU::GPUTracking internals

---
 GPU/Common/GPUCommonHelpers.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/GPU/Common/GPUCommonHelpers.h b/GPU/Common/GPUCommonHelpers.h
index ad876db0d6c3a..915d93c9bc791 100644
--- a/GPU/Common/GPUCommonHelpers.h
+++ b/GPU/Common/GPUCommonHelpers.h
@@ -33,6 +33,7 @@
 #define GPUChkErrSI(x) o2::gpu::internal::GPUReconstructionChkErr(x, __FILE__, __LINE__, false)
 
 #include "GPUCommonDef.h"
+#include "GPUCommonLogger.h"
 #include <cstdint>
 
 namespace o2::gpu::internal
@@ -43,7 +44,7 @@ extern int32_t GPUCOMMON_INTERNAL_CAT(GPUReconstruction, GPUCA_GPUTYPE, ChkErr)(
 inline int32_t GPUReconstructionCPUChkErr(const int64_t error, const char* file, int32_t line)
 {
   if (error) {
-    GPUError("GPUCommon Error Code %d (%s:%d)", error, file, line);
+    LOGF(error, "GPUCommon Error Code %ld (%s:%d)", (long)error, file, line);
   }
   return error != 0;
 }

From 50bf6546f14e71cd62a01b634737af44c24bc265 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 09:23:17 +0100
Subject: [PATCH 0084/1764] GPU TPC CF: Fix rounding error in qMax cut

---
 GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx | 5 +----
 GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx | 2 +-
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
index b3b3c64095017..f876270a34358 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
@@ -98,10 +98,7 @@ GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, const Charge q, t
   if (cn.qTot <= param.rec.tpc.cfQTotCutoff) {
     return false;
   }
-  cn.qMax = q;
-  if (cn.qMax <= param.rec.tpc.cfQMaxCutoff) {
-    return false;
-  }
+  cn.qMax = q; // cfQMaxCutoff check already done at PeakFinder level
   if (mTimeMean < param.rec.tpc.clustersShiftTimebinsClusterizer) {
     return false;
   }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
index 30fdac92e8607..1de922f716c14 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
@@ -42,7 +42,7 @@ GPUdii() bool GPUTPCCFPeakFinder::isPeak(
 {
   uint16_t ll = get_local_id(0);
 
-  bool belowThreshold = (q <= calib.tpc.cfQMaxCutoff);
+  bool belowThreshold = (uint32_t)q <= calib.tpc.cfQMaxCutoff;
 
   uint16_t lookForPeaks;
   uint16_t partId = CfUtils::partition<SCRATCH_PAD_WORK_GROUP_SIZE>(

From 1e625e72171876fbb02e0e75c9c6b73a2c6e1ad5 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 10:35:55 +0100
Subject: [PATCH 0085/1764] Fix CMake warnings

---
 Steer/CMakeLists.txt | 2 ++
 run/CMakeLists.txt   | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/Steer/CMakeLists.txt b/Steer/CMakeLists.txt
index 70f50f4ab8823..8e2706d31bb0a 100644
--- a/Steer/CMakeLists.txt
+++ b/Steer/CMakeLists.txt
@@ -34,11 +34,13 @@ o2_target_root_dictionary(Steer
                                   include/Steer/MCKinematicsReader.h
                                   include/Steer/MaterialBudgetMap.h)
 o2_add_test(InteractionSampler
+            COMPONENT_NAME steer
             PUBLIC_LINK_LIBRARIES O2::SimulationDataFormat
             SOURCES test/testInteractionSampler.cxx
             LABELS steer)
 
 o2_add_test(HitProcessingManager
+            COMPONENT_NAME steer
             PUBLIC_LINK_LIBRARIES O2::Steer
             SOURCES test/testHitProcessingManager.cxx
             LABELS steer)
diff --git a/run/CMakeLists.txt b/run/CMakeLists.txt
index 662716901ed0a..fd43207f92d1e 100644
--- a/run/CMakeLists.txt
+++ b/run/CMakeLists.txt
@@ -229,6 +229,7 @@ set_property(TEST o2sim_G4 APPEND PROPERTY ENVIRONMENT ${G4ENV})
 
 
 o2_add_test(CheckStackG4
+  COMPONENT_NAME sim
   SOURCES checkStack.cxx
   NAME o2sim_checksimkinematics_G4
   WORKING_DIRECTORY ${SIMTESTDIR}
@@ -276,6 +277,7 @@ set_tests_properties(o2sim_G3
                                 G3)
 
 o2_add_test(CheckStackG3
+  COMPONENT_NAME sim
   SOURCES checkStack.cxx
   NAME o2sim_checksimkinematics_G3
   WORKING_DIRECTORY ${SIMTESTDIR}

From 40a883754789b3630fff732076136123a695ae3a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 10:49:01 +0100
Subject: [PATCH 0086/1764] GPU: Drop obsolete minimum version setting

---
 GPU/GPUTracking/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index d5a90dbd65ea3..5ce96d450f765 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -10,7 +10,6 @@
 # or submit itself to any jurisdiction.
 
 set(MODULE GPUTracking)
-cmake_minimum_required(VERSION 3.27 FATAL_ERROR)
 
 # set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O0") # to uncomment if needed, tired of typing this...
 # set(GPUCA_BUILD_DEBUG 1)

From 134f5ea21c5edd15c2836829b5ec629925342643 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 10:52:03 +0100
Subject: [PATCH 0087/1764] GPU TPC: Remove tpcGeometry instance, use constexpr
 GPUTPCGeometry::

---
 .../study/src/SVStudy.cxx                     |  3 +-
 .../study/src/TrackingStudy.cxx               |  3 +-
 .../TPC/workflow/src/EntropyEncoderSpec.cxx   |  4 +--
 GPU/GPUTracking/Base/GPUParam.cxx             |  6 ++--
 GPU/GPUTracking/Base/GPUParam.h               |  2 --
 GPU/GPUTracking/Base/GPUParam.inc             | 19 ++++++------
 .../Base/GPUReconstructionConvert.cxx         | 27 +++++++++--------
 .../GPUTPCCompressionKernels.cxx              | 14 ++++-----
 .../TPCClusterDecompressionCore.inc           | 18 ++++++-----
 GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx    |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 13 ++++----
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |  2 +-
 .../Merger/GPUTPCGMSectorTrack.cxx            |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 30 +++++++++----------
 .../SectorTracker/GPUTPCTrackingData.cxx      |  5 ++--
 .../GPUTPCTrackletConstructor.cxx             |  6 ++--
 .../TPCClusterFinder/ClusterAccumulator.cxx   |  8 ++---
 .../GPUTPCCFCheckPadBaseline.cxx              |  3 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     |  7 +++--
 .../GPUTPCNNClusterizerKernels.cxx            | 19 ++++++------
 .../GPUTPCNNClusterizerKernels.h              |  4 +--
 GPU/GPUTracking/dEdx/GPUdEdx.cxx              |  1 -
 GPU/GPUTracking/dEdx/GPUdEdx.h                | 21 ++++++-------
 .../display/render/GPUDisplayImportEvent.cxx  |  4 +--
 GPU/GPUTracking/qa/genEvents.cxx              |  2 +-
 26 files changed, 118 insertions(+), 109 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
index c28048a1f9503..1e141a29d3f55 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
@@ -48,6 +48,7 @@
 // #include "GPUSettingsO2.h"
 #include "GPUParam.h"
 #include "GPUParam.inc"
+#include "GPUTPCGeometry.h"
 #include "GPUO2InterfaceRefit.h"
 #include "GPUO2InterfaceUtils.h"
 
@@ -254,7 +255,7 @@ o2::dataformats::V0Ext SVStudySpec::processV0(int iv, o2::globaltracking::RecoCo
         tpcTr.getClusterReference(clRefs, tpcTr.getNClusterReferences() - 1, clSect, clRow, clIdx);
         const auto& clus = recoData.getTPCClusters().clusters[clSect][clRow][clIdx];
         prInfo.lowestRow = clRow;
-        int npads = mParam->tpcGeometry.NPads(clRow);
+        int npads = o2::gpu::GPUTPCGeometry::NPads(clRow);
         prInfo.padFromEdge = uint8_t(clus.getPad());
         if (prInfo.padFromEdge > npads / 2) {
           prInfo.padFromEdge = npads - 1 - prInfo.padFromEdge;
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index db57ad5f8a7eb..f206c43f7f57a 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -47,6 +47,7 @@
 #include "GPUO2Interface.h" // Needed for propper settings in GPUParam.h
 #include "GPUParam.h"
 #include "GPUParam.inc"
+#include "GPUTPCGeometry.h"
 #include "Steer/MCKinematicsReader.h"
 #include "MathUtils/fit.h"
 #include <TF1.h>
@@ -301,7 +302,7 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
       trExt.rowMinTPC = clRow;
       const auto& clus = tpcClusAcc.clusters[clSect][clRow][clIdx];
       trExt.padFromEdge = uint8_t(clus.getPad());
-      int npads = mTPCRefitter->getParam()->tpcGeometry.NPads(clRow);
+      int npads = o2::gpu::GPUTPCGeometry::NPads(clRow);
       if (trExt.padFromEdge > npads / 2) {
         trExt.padFromEdge = npads - 1 - trExt.padFromEdge;
       }
diff --git a/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx b/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
index cc964ade0d87c..2efa7077be125 100644
--- a/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
@@ -230,9 +230,9 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
       int myThread = 0;
 #endif
       unsigned int count = 0;
-      const float x = mParam->tpcGeometry.Row2X(j);
+      const float x = GPUTPCGeometry::Row2X(j);
       auto checker = [i, j, firstIR, totalT, x, this, &preCl, &count, &outBuffer = tmpBuffer[myThread], &rejectHits, &clustersFiltered](const o2::tpc::ClusterNative& cl, unsigned int k) {
-        const float y = mParam->tpcGeometry.LinearPad2Y(i, j, cl.getPad());
+        const float y = GPUTPCGeometry::LinearPad2Y(i, j, cl.getPad());
         const float r = sqrtf(x * x + y * y);
         const float maxz = r * mEtaFactor + mMaxZ;
         const unsigned int deltaBC = std::max<float>(0.f, totalT - mFastTransform->convDeltaZtoDeltaTimeInTimeFrameAbs(maxz)) * constants::LHCBCPERTIMEBIN;
diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index 192e46c36dc68..bbca150df405a 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -21,6 +21,7 @@
 #include "GPUDataTypes.h"
 #include "GPUConstantMem.h"
 #include "DetectorsBase/Propagator.h"
+#include "GPUTPCGeometry.h"
 
 using namespace o2::gpu;
 
@@ -32,7 +33,6 @@ using namespace o2::gpu;
 void GPUParam::SetDefaults(float solenoidBz)
 {
   memset((void*)this, 0, sizeof(*this));
-  new (&tpcGeometry) GPUTPCGeometry;
   new (&rec) GPUSettingsRec;
   occupancyMap = nullptr;
   occupancyTotal = 0;
@@ -178,8 +178,8 @@ void GPUParam::UpdateRun3ClusterErrors(const float* yErrorParam, const float* zE
     for (int32_t rowType = 0; rowType < 4; rowType++) {
       constexpr int32_t regionMap[4] = {0, 4, 6, 8};
       ParamErrors[yz][rowType][0] = param[0] * param[0];
-      ParamErrors[yz][rowType][1] = param[1] * param[1] * tpcGeometry.PadHeightByRegion(regionMap[rowType]);
-      ParamErrors[yz][rowType][2] = param[2] * param[2] / tpcGeometry.TPCLength() / tpcGeometry.PadHeightByRegion(regionMap[rowType]);
+      ParamErrors[yz][rowType][1] = param[1] * param[1] * GPUTPCGeometry::PadHeightByRegion(regionMap[rowType]);
+      ParamErrors[yz][rowType][2] = param[2] * param[2] / GPUTPCGeometry::TPCLength() / GPUTPCGeometry::PadHeightByRegion(regionMap[rowType]);
       ParamErrors[yz][rowType][3] = param[3] * param[3] * rec.tpc.clusterErrorOccupancyScaler * rec.tpc.clusterErrorOccupancyScaler;
     }
   }
diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index fbce6246de112..4b77628c88775 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -19,7 +19,6 @@
 #include "GPUCommonMath.h"
 #include "GPUDef.h"
 #include "GPUSettings.h"
-#include "GPUTPCGeometry.h"
 #include "GPUTPCGMPolynomialField.h"
 
 #if !defined(GPUCA_GPUCODE)
@@ -59,7 +58,6 @@ struct GPUParam_t {
   int32_t continuousMaxTimeBin;
   int32_t tpcCutTimeBin;
 
-  GPUTPCGeometry tpcGeometry;              // TPC Geometry
   GPUTPCGMPolynomialField polynomialField; // Polynomial approx. of magnetic field for TPC GM
   const uint32_t* occupancyMap;            // Ptr to TPC occupancy map
   uint32_t occupancyTotal;                 // Total occupancy in the TPC (nCl / nHbf)
diff --git a/GPU/GPUTracking/Base/GPUParam.inc b/GPU/GPUTracking/Base/GPUParam.inc
index 19dc1fc4a3578..a118a8f639fe9 100644
--- a/GPU/GPUTracking/Base/GPUParam.inc
+++ b/GPU/GPUTracking/Base/GPUParam.inc
@@ -18,6 +18,7 @@
 #include "GPUParam.h"
 #include "GPUTPCGMMergedTrackHit.h"
 #include "GPUTPCClusterOccupancyMap.h"
+#include "GPUTPCGeometry.h"
 
 namespace o2::gpu
 {
@@ -42,14 +43,14 @@ GPUdi() void GPUParam::Global2Sector(int32_t iSector, float X, float Y, float Z,
 
 GPUdi() void GPUParam::GetClusterErrorsSeeding2(uint8_t sector, int32_t iRow, float z, float sinPhi, float DzDs, float time, float& ErrY2, float& ErrZ2) const
 {
-  const int32_t rowType = tpcGeometry.GetROC(iRow);
-  z = CAMath::Abs(tpcGeometry.TPCLength() - CAMath::Abs(z));
+  const int32_t rowType = GPUTPCGeometry::GetROC(iRow);
+  z = CAMath::Abs(GPUTPCGeometry::TPCLength() - CAMath::Abs(z));
   const float s2 = CAMath::Min(sinPhi * sinPhi, 0.95f * 0.95f);
   const float sec2 = 1.f / (1.f - s2);
   const float angleY2 = s2 * sec2;          // dy/dx
   const float angleZ2 = DzDs * DzDs * sec2; // dz/dx
 
-  const float unscaledMult = time >= 0.f ? GetUnscaledMult(time) / tpcGeometry.Row2X(iRow) : 0.f;
+  const float unscaledMult = time >= 0.f ? GetUnscaledMult(time) / GPUTPCGeometry::Row2X(iRow) : 0.f;
 
   ErrY2 = GetClusterErrorSeeding(0, rowType, z, angleY2, unscaledMult); // Returns Err2
   ErrZ2 = GetClusterErrorSeeding(1, rowType, z, angleZ2, unscaledMult); // Returns Err2
@@ -132,8 +133,8 @@ GPUdi() float GPUParam::GetClusterErrorSeeding(int32_t yz, int32_t type, float z
 
 GPUdi() void GPUParam::GetClusterErrorsSeeding2(uint8_t sector, int32_t iRow, float z, float sinPhi, float DzDs, float time, float& ErrY2, float& ErrZ2) const
 {
-  int32_t rowType = tpcGeometry.GetROC(iRow);
-  z = CAMath::Abs(tpcGeometry.TPCLength() - CAMath::Abs(z));
+  int32_t rowType = GPUTPCGeometry::GetROC(iRow);
+  z = CAMath::Abs(GPUTPCGeometry::TPCLength() - CAMath::Abs(z));
   const float s2 = CAMath::Min(sinPhi * sinPhi, 0.95f * 0.95f);
   float sec2 = 1.f / (1.f - s2);
   float angleY2 = s2 * sec2;          // dy/dx
@@ -172,14 +173,14 @@ GPUdi() float GPUParam::GetSystematicClusterErrorC122(float trackX, float trackY
 
 GPUdi() void GPUParam::GetClusterErrors2(uint8_t sector, int32_t iRow, float z, float sinPhi, float DzDs, float time, float avgInvCharge, float invCharge, float& ErrY2, float& ErrZ2) const
 {
-  const int32_t rowType = tpcGeometry.GetROC(iRow);
-  z = CAMath::Abs(tpcGeometry.TPCLength() - CAMath::Abs(z));
+  const int32_t rowType = GPUTPCGeometry::GetROC(iRow);
+  z = CAMath::Abs(GPUTPCGeometry::TPCLength() - CAMath::Abs(z));
   const float s2 = CAMath::Min(sinPhi * sinPhi, 0.95f * 0.95f);
   const float sec2 = 1.f / (1.f - s2);
   const float angleY2 = s2 * sec2;          // dy/dx
   const float angleZ2 = DzDs * DzDs * sec2; // dz/dx
 
-  const float unscaledMult = time >= 0.f ? GetUnscaledMult(time) / tpcGeometry.Row2X(iRow) : 0.f;
+  const float unscaledMult = time >= 0.f ? GetUnscaledMult(time) / GPUTPCGeometry::Row2X(iRow) : 0.f;
   const float scaledInvAvgCharge = avgInvCharge * rec.tpc.clusterErrorChargeScaler > 0.f ? avgInvCharge * rec.tpc.clusterErrorChargeScaler : 1.f;
   const float scaledInvCharge = invCharge * rec.tpc.clusterErrorChargeScaler > 0.f ? invCharge * rec.tpc.clusterErrorChargeScaler : 1.f;
 
@@ -218,7 +219,7 @@ GPUdi() float GPUParam::GetUnscaledMult(float time) const
 
 GPUdi() bool GPUParam::rejectEdgeClusterByY(float uncorrectedY, int32_t iRow, float trackSigmaY) const
 {
-  return CAMath::Abs(uncorrectedY) > (tpcGeometry.NPads(iRow) - 1) * 0.5f * tpcGeometry.PadWidth(iRow) + rec.tpc.rejectEdgeClustersMargin + trackSigmaY * rec.tpc.rejectEdgeClustersSigmaMargin;
+  return CAMath::Abs(uncorrectedY) > (GPUTPCGeometry::NPads(iRow) - 1) * 0.5f * GPUTPCGeometry::PadWidth(iRow) + rec.tpc.rejectEdgeClustersMargin + trackSigmaY * rec.tpc.rejectEdgeClustersSigmaMargin;
 }
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
index bc760f6188caa..e12ca7ec601ad 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
@@ -24,6 +24,7 @@
 #include "GPUTPCClusterData.h"
 #include "GPUO2DataTypes.h"
 #include "GPUDataTypes.h"
+#include "GPUTPCGeometry.h"
 #include "AliHLTTPCRawCluster.h"
 #include "GPUParam.h"
 #include "GPULogging.h"
@@ -275,10 +276,10 @@ struct zsEncoderRow : public zsEncoder {
 
 inline bool zsEncoderRow::sort(const o2::tpc::Digit a, const o2::tpc::Digit b)
 {
-  int32_t endpointa = param->tpcGeometry.GetRegion(a.getRow());
-  int32_t endpointb = param->tpcGeometry.GetRegion(b.getRow());
-  endpointa = 2 * endpointa + (a.getRow() >= param->tpcGeometry.GetRegionStart(endpointa) + param->tpcGeometry.GetRegionRows(endpointa) / 2);
-  endpointb = 2 * endpointb + (b.getRow() >= param->tpcGeometry.GetRegionStart(endpointb) + param->tpcGeometry.GetRegionRows(endpointb) / 2);
+  int32_t endpointa = GPUTPCGeometry::GetRegion(a.getRow());
+  int32_t endpointb = GPUTPCGeometry::GetRegion(b.getRow());
+  endpointa = 2 * endpointa + (a.getRow() >= GPUTPCGeometry::GetRegionStart(endpointa) + GPUTPCGeometry::GetRegionRows(endpointa) / 2);
+  endpointb = 2 * endpointb + (b.getRow() >= GPUTPCGeometry::GetRegionStart(endpointb) + GPUTPCGeometry::GetRegionRows(endpointb) / 2);
   if (endpointa != endpointb) {
     return endpointa <= endpointb;
   }
@@ -295,11 +296,11 @@ bool zsEncoderRow::checkInput(std::vector<o2::tpc::Digit>& tmpBuffer, uint32_t k
 {
   seqLen = 1;
   if (lastRow != tmpBuffer[k].getRow()) {
-    endpointStart = param->tpcGeometry.GetRegionStart(curRegion);
+    endpointStart = GPUTPCGeometry::GetRegionStart(curRegion);
     endpoint = curRegion * 2;
-    if (tmpBuffer[k].getRow() >= endpointStart + param->tpcGeometry.GetRegionRows(curRegion) / 2) {
+    if (tmpBuffer[k].getRow() >= endpointStart + GPUTPCGeometry::GetRegionRows(curRegion) / 2) {
       endpoint++;
-      endpointStart += param->tpcGeometry.GetRegionRows(curRegion) / 2;
+      endpointStart += GPUTPCGeometry::GetRegionRows(curRegion) / 2;
     }
   }
   for (uint32_t l = k + 1; l < tmpBuffer.size(); l++) {
@@ -408,7 +409,7 @@ void zsEncoderRow::decodePage(std::vector<o2::tpc::Digit>& outputBuffer, const z
   if ((uint32_t)region != decEndpoint / 2) {
     throw std::runtime_error("CRU ID / endpoint mismatch");
   }
-  int32_t nRowsRegion = param->tpcGeometry.GetRegionRows(region);
+  int32_t nRowsRegion = GPUTPCGeometry::GetRegionRows(region);
 
   int32_t timeBin = (decHDR->timeOffset + (uint64_t)(o2::raw::RDHUtils::getHeartBeatOrbit(*rdh) - firstOrbit) * o2::constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
   for (int32_t l = 0; l < decHDR->nTimeBinSpan; l++) {
@@ -420,7 +421,7 @@ void zsEncoderRow::decodePage(std::vector<o2::tpc::Digit>& outputBuffer, const z
     if (tbHdr->rowMask != 0 && ((upperRows) ^ ((decEndpoint & 1) != 0))) {
       throw std::runtime_error("invalid endpoint");
     }
-    const int32_t rowOffset = param->tpcGeometry.GetRegionStart(region) + (upperRows ? (nRowsRegion / 2) : 0);
+    const int32_t rowOffset = GPUTPCGeometry::GetRegionStart(region) + (upperRows ? (nRowsRegion / 2) : 0);
     const int32_t nRows = upperRows ? (nRowsRegion - nRowsRegion / 2) : (nRowsRegion / 2);
     const int32_t nRowsUsed = __builtin_popcount((uint32_t)(tbHdr->rowMask & 0x7FFF));
     decPagePtr += nRowsUsed ? (2 * nRowsUsed) : 2;
@@ -513,7 +514,7 @@ void zsEncoderLinkBased::createBitmask(std::vector<o2::tpc::Digit>& tmpBuffer, u
   uint32_t l;
   for (l = k; l < tmpBuffer.size(); l++) {
     const auto& a = tmpBuffer[l];
-    int32_t cruinsector = param->tpcGeometry.GetRegion(a.getRow());
+    int32_t cruinsector = GPUTPCGeometry::GetRegion(a.getRow());
     o2::tpc::GlobalPadNumber pad = mapper.globalPadNumber(o2::tpc::PadPos(a.getRow(), a.getPad()));
     o2::tpc::FECInfo fec = mapper.fecInfo(pad);
     o2::tpc::CRU cru = cruinsector;
@@ -535,8 +536,8 @@ void zsEncoderLinkBased::createBitmask(std::vector<o2::tpc::Digit>& tmpBuffer, u
 bool zsEncoderLinkBased::sort(const o2::tpc::Digit a, const o2::tpc::Digit b)
 {
   // Fixme: this is blasphemy... one shoult precompute all values and sort an index array
-  int32_t cruinsectora = param->tpcGeometry.GetRegion(a.getRow());
-  int32_t cruinsectorb = param->tpcGeometry.GetRegion(b.getRow());
+  int32_t cruinsectora = GPUTPCGeometry::GetRegion(a.getRow());
+  int32_t cruinsectorb = GPUTPCGeometry::GetRegion(b.getRow());
   if (cruinsectora != cruinsectorb) {
     return cruinsectora < cruinsectorb;
   }
@@ -1124,7 +1125,7 @@ inline uint32_t zsEncoderRun<T>::run(std::vector<zsPage>* buffer, std::vector<o2
           }
         }
         if (lastRow != tmpBuffer[k].getRow()) {
-          curRegion = param->tpcGeometry.GetRegion(tmpBuffer[k].getRow());
+          curRegion = GPUTPCGeometry::GetRegion(tmpBuffer[k].getRow());
         }
         mustWriteSubPage = checkInput(tmpBuffer, k);
       } else {
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 4831be9b12bcc..445c03113cd39 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -18,7 +18,6 @@
 #include "GPUParam.h"
 #include "GPUCommonAlgorithm.h"
 #include "GPUTPCCompressionTrackModel.h"
-#include "GPUTPCGeometry.h"
 #include "GPUTPCClusterRejection.h"
 #include "GPUTPCCompressionKernels.inc"
 
@@ -68,9 +67,10 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
         continue; // No track model compression
       }
       const ClusterNative& GPUrestrict() orgCl = clusters -> clusters[hit.sector][hit.row][hit.num - clusters->clusterOffset[hit.sector][hit.row]];
-      float x = param.tpcGeometry.Row2X(hit.row);
-      float y = track.LinearPad2Y(hit.sector, orgCl.getPad(), param.tpcGeometry.PadWidth(hit.row), param.tpcGeometry.NPads(hit.row));
-      float z = param.tpcGeometry.LinearTime2Z(hit.sector, orgCl.getTime());
+      constexpr GPUTPCGeometry geo;
+      float x = geo.Row2X(hit.row);
+      float y = track.LinearPad2Y(hit.sector, orgCl.getPad(), geo.PadWidth(hit.row), geo.NPads(hit.row));
+      float z = geo.LinearTime2Z(hit.sector, orgCl.getTime());
       if (nClustersStored) {
         if ((hit.sector < GPUCA_NSECTORS) ^ (lastSector < GPUCA_NSECTORS)) {
           break;
@@ -78,7 +78,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
         if (lastLeg != hit.leg && track.Mirror()) {
           break;
         }
-        if (track.Propagate(param.tpcGeometry.Row2X(hit.row), param.SectorParam[hit.sector].Alpha)) {
+        if (track.Propagate(geo.Row2X(hit.row), param.SectorParam[hit.sector].Alpha)) {
           break;
         }
       }
@@ -115,9 +115,9 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
         }
         c.rowDiffA[cidx] = row;
         c.sliceLegDiffA[cidx] = (hit.leg == lastLeg ? 0 : compressor.NSECTORS) + sector;
-        float pad = CAMath::Max(0.f, CAMath::Min((float)param.tpcGeometry.NPads(GPUCA_ROW_COUNT - 1), track.LinearY2Pad(hit.sector, track.Y(), param.tpcGeometry.PadWidth(hit.row), param.tpcGeometry.NPads(hit.row))));
+        float pad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_ROW_COUNT - 1), track.LinearY2Pad(hit.sector, track.Y(), geo.PadWidth(hit.row), geo.NPads(hit.row))));
         c.padResA[cidx] = orgCl.padPacked - orgCl.packPad(pad);
-        float time = CAMath::Max(0.f, param.tpcGeometry.LinearZ2Time(hit.sector, track.Z() + zOffset));
+        float time = CAMath::Max(0.f, geo.LinearZ2Time(hit.sector, track.Z() + zOffset));
         c.timeResA[cidx] = (orgCl.getTimePacked() - orgCl.packTime(time)) & 0xFFFFFF;
         lastLeg = hit.leg;
       }
diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc b/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
index 6c4f70d7c6884..e4de5a503e52d 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
@@ -20,6 +20,7 @@
 #include "GPUTPCCompressionTrackModel.h"
 #include "GPUCommonAlgorithm.h"
 #include "GPUO2DataTypes.h"
+#include "GPUTPCGeometry.h"
 
 #ifndef GPUCA_GPUCODE
 #include <functional>
@@ -80,6 +81,7 @@ class TPCClusterDecompressionCore
     uint32_t slice = cmprClusters.sliceA[trackIndex];
     uint32_t row = cmprClusters.rowA[trackIndex];
     GPUTPCCompressionTrackModel track;
+    constexpr GPUTPCGeometry geo;
     uint32_t clusterIndex;
     for (clusterIndex = 0; clusterIndex < cmprClusters.nTrackClusters[trackIndex]; clusterIndex++) {
       uint32_t pad = 0, time = 0;
@@ -105,23 +107,23 @@ class TPCClusterDecompressionCore
         if (changeLeg && track.Mirror()) {
           break;
         }
-        if (track.Propagate(param.tpcGeometry.Row2X(row), param.SectorParam[slice].Alpha)) {
+        if (track.Propagate(geo.Row2X(row), param.SectorParam[slice].Alpha)) {
           break;
         }
         uint32_t timeTmp = cmprClusters.timeResA[clusterOffset - trackIndex - 1];
         if (timeTmp & 800000) {
           timeTmp |= 0xFF000000;
         }
-        time = timeTmp + ClusterNative::packTime(CAMath::Max(0.f, param.tpcGeometry.LinearZ2Time(slice, track.Z() + zOffset)));
-        float tmpPad = CAMath::Max(0.f, CAMath::Min((float)param.tpcGeometry.NPads(GPUCA_ROW_COUNT - 1), track.LinearY2Pad(slice, track.Y(), param.tpcGeometry.PadWidth(row), param.tpcGeometry.NPads(row))));
+        time = timeTmp + ClusterNative::packTime(CAMath::Max(0.f, geo.LinearZ2Time(slice, track.Z() + zOffset)));
+        float tmpPad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_ROW_COUNT - 1), track.LinearY2Pad(slice, track.Y(), geo.PadWidth(row), geo.NPads(row))));
         pad = cmprClusters.padResA[clusterOffset - trackIndex - 1] + ClusterNative::packPad(tmpPad);
         time = time & 0xFFFFFF;
         pad = (uint16_t)pad;
-        if (pad >= param.tpcGeometry.NPads(row) * ClusterNative::scalePadPacked) {
+        if (pad >= geo.NPads(row) * ClusterNative::scalePadPacked) {
           if (pad >= 0xFFFF - 11968) { // Constant 11968 = (2^15 - MAX_PADS(138) * scalePadPacked(64)) / 2
             pad = 0;
           } else {
-            pad = param.tpcGeometry.NPads(row) * ClusterNative::scalePadPacked - 1;
+            pad = geo.NPads(row) * ClusterNative::scalePadPacked - 1;
           }
         }
         if (param.continuousMaxTimeBin > 0 && time >= maxTime) {
@@ -136,11 +138,11 @@ class TPCClusterDecompressionCore
         pad = cmprClusters.padA[trackIndex];
       }
       const auto cluster = decompressTrackStore(cmprClusters, clusterOffset, slice, row, pad, time, args...);
-      float y = track.LinearPad2Y(slice, cluster.getPad(), param.tpcGeometry.PadWidth(row), param.tpcGeometry.NPads(row));
-      float z = param.tpcGeometry.LinearTime2Z(slice, cluster.getTime());
+      float y = track.LinearPad2Y(slice, cluster.getPad(), geo.PadWidth(row), geo.NPads(row));
+      float z = geo.LinearTime2Z(slice, cluster.getTime());
       if (clusterIndex == 0) {
         zOffset = z;
-        track.Init(param.tpcGeometry.Row2X(row), y, z - zOffset, param.SectorParam[slice].Alpha, cmprClusters.qPtA[trackIndex], param);
+        track.Init(geo.Row2X(row), y, z - zOffset, param.SectorParam[slice].Alpha, cmprClusters.qPtA[trackIndex], param);
       }
       if (clusterIndex + 1 < cmprClusters.nTrackClusters[trackIndex] && track.Filter(y, z - zOffset, row)) {
         break;
diff --git a/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx b/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
index 40ce8c0ccda81..0b8e67fbe495e 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
@@ -21,7 +21,7 @@ using namespace o2::gpu;
 
 TPCPadBitMap::TPCPadBitMap()
 {
-  GPUTPCGeometry geo{};
+  constexpr GPUTPCGeometry geo;
   int32_t offset = 0;
   for (int32_t r = 0; r < GPUCA_ROW_COUNT; r++) {
     mPadOffsetPerRow[r] = offset;
diff --git a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
index 41f0ad819d1b6..a20f3dc8aac1d 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
@@ -21,7 +21,7 @@ using namespace o2::gpu;
 
 TPCPadGainCalib::TPCPadGainCalib()
 {
-  GPUTPCGeometry geo{};
+  constexpr GPUTPCGeometry geo{};
   int32_t offset = 0;
   for (int32_t r = 0; r < GPUCA_ROW_COUNT; r++) {
     mPadOffsetPerRow[r] = offset;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 1c2a8e2b29a9c..f373d56ea0395 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -36,6 +36,7 @@
 #include "GPUO2DataTypes.h"
 #include "TPCFastTransform.h"
 #include "GPUTPCConvertImpl.h"
+#include "GPUTPCGeometry.h"
 
 #include "GPUCommonMath.h"
 #include "GPUCommonAlgorithm.h"
@@ -601,13 +602,13 @@ GPUd() void GPUTPCGMMerger::MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nT
   } else if (iBorder == 1) { // transport to the right edge of the sector and rotate horizontally
     dAlpha = -dAlpha - CAMath::Pi() / 2;
   } else if (iBorder == 2) { // transport to the middle of the sector and rotate vertically to the border on the left
-    x0 = Param().tpcGeometry.Row2X(63);
+    x0 = GPUTPCGeometry::Row2X(63);
   } else if (iBorder == 3) { // transport to the middle of the sector and rotate vertically to the border on the right
     dAlpha = -dAlpha;
-    x0 = Param().tpcGeometry.Row2X(63);
+    x0 = GPUTPCGeometry::Row2X(63);
   } else if (iBorder == 4) { // transport to the middle of the sßector, w/o rotation
     dAlpha = 0;
-    x0 = Param().tpcGeometry.Row2X(63);
+    x0 = GPUTPCGeometry::Row2X(63);
   }
 
   const float maxSin = CAMath::Sin(60.f / 180.f * CAMath::Pi());
@@ -955,7 +956,7 @@ template GPUdni() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int
 
 GPUd() void GPUTPCGMMerger::MergeWithinSectorsPrepare(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  float x0 = Param().tpcGeometry.Row2X(63);
+  float x0 = GPUTPCGeometry::Row2X(63);
   const float maxSin = CAMath::Sin(60.f / 180.f * CAMath::Pi());
 
   for (int32_t itr = iBlock * nThreads + iThread; itr < SectorTrackInfoLocalTotal(); itr += nThreads * nBlocks) {
@@ -1295,7 +1296,7 @@ GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const
   int32_t sector = track->Sector();
   for (int32_t attempt = 0; attempt < 2; attempt++) {
     GPUTPCGMBorderTrack b;
-    const float x0 = Param().tpcGeometry.Row2X(attempt == 0 ? 63 : cls.row);
+    const float x0 = GPUTPCGeometry::Row2X(attempt == 0 ? 63 : cls.row);
     if (track->TransportToX(this, x0, Param().bzCLight, b, GPUCA_MAX_SIN_PHI_LOW)) {
       b.SetTrackID(itr);
       b.SetNClusters(mOutputTracks[itr].NClusters());
@@ -1759,7 +1760,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     mergedTrack.SetCSide(p2.CSide());
 
     GPUTPCGMBorderTrack b;
-    const float toX = Param().par.earlyTpcTransform ? clXYZ[0].x : Param().tpcGeometry.Row2X(cl[0].row);
+    const float toX = Param().par.earlyTpcTransform ? clXYZ[0].x : GPUTPCGeometry::Row2X(cl[0].row);
     if (p2.TransportToX(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
       p1.X() = toX;
       p1.Y() = b.Par()[0];
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index ae413aaa98648..1e4cc633eb4ca 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -353,7 +353,7 @@ void GPUTPCGMMerger::DebugStreamerUpdate(int32_t iTrk, int32_t ihit, float xx, f
   auto uncorrectedYZ = StreamerUncorrectedZY(cluster.sector, cluster.row, track, prop);
   float invCharge = 1.f / clusterNative.qMax;
   int32_t iRow = cluster.row;
-  float unscaledMult = (time >= 0.f ? Param().GetUnscaledMult(time) / Param().tpcGeometry.Row2X(iRow) : 0.f);
+  float unscaledMult = (time >= 0.f ? Param().GetUnscaledMult(time) / GPUTPCGeometry::Row2X(iRow) : 0.f);
   const float clAlpha = Param().Alpha(cluster.sector);
   uint32_t occupancyTotal = Param().occupancyTotal;
   o2::utils::DebugStreamer::instance()->getStreamer("debug_update_track", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_update_track").data()
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index a439e6e653039..11b153c7f0d8b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -95,7 +95,7 @@ GPUd() void GPUTPCGMSectorTrack::SetParam2(const GPUTPCGMTrackParam& trk)
 GPUd() bool GPUTPCGMSectorTrack::FilterErrors(const GPUTPCGMMerger* merger, int32_t iSector, float maxSinPhi, float sinPhiMargin)
 {
   float lastX;
-  // float lastX = merger->Param().tpcGeometry.Row2X(mOrigTrack->Cluster(mOrigTrack->NClusters() - 1).GetRow()); // TODO: Why is this needed to be set below, Row2X should work, but looses some tracks
+  // float lastX = GPUTPCGeometry::Row2X(mOrigTrack->Cluster(mOrigTrack->NClusters() - 1).GetRow()); // TODO: Why is this needed to be set below, Row2X should work, but looses some tracks
   float y, z;
   int32_t row, index;
   const GPUTPCTracker& trk = merger->GetConstantMem()->tpcTrackers[iSector];
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index be1d3803312fe..3bd2257d02e01 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -219,7 +219,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         bool dodEdx = param.par.dodEdx && param.dodEdxDownscaled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2 && cluster.leg == clusters[maxN - 1].leg;
         dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, cluster.leg == clusters[maxN - 1].leg, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
         if (dodEdx) {
-          dEdx.fillSubThreshold(lastRow - wayDirection, param);
+          dEdx.fillSubThreshold(lastRow - wayDirection);
         }
       }
 
@@ -384,7 +384,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           pad /= clusterCount;
           relTime /= clusterCount;
           relTime = relTime - CAMath::Round(relTime);
-          dEdx.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], param, merger->GetConstantMem()->calibObjects, zz, pad, relTime);
+          dEdx.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
         }
       } else if (retVal >= GPUTPCGMPropagator::updateErrorClusterRejected) { // cluster far away form the track
         if (allowModification) {
@@ -650,7 +650,7 @@ GPUd() bool GPUTPCGMTrackParam::AttachClustersPropagate(const GPUTPCGMMerger* GP
     return dodEdx;
   }
   int32_t step = toRow > lastRow ? 1 : -1;
-  float xx = mX - Merger->Param().tpcGeometry.Row2X(lastRow);
+  float xx = mX - GPUTPCGeometry::Row2X(lastRow);
   for (int32_t iRow = lastRow + step; iRow != toRow; iRow += step) {
     if (CAMath::Abs(mP[2]) > maxSinPhi) {
       return dodEdx;
@@ -658,15 +658,15 @@ GPUd() bool GPUTPCGMTrackParam::AttachClustersPropagate(const GPUTPCGMMerger* GP
     if (CAMath::Abs(mP[0]) > CAMath::Abs(mX) * CAMath::Tan(kSectAngle / 2.f)) {
       return dodEdx;
     }
-    int32_t err = prop.PropagateToXAlpha(xx + Merger->Param().tpcGeometry.Row2X(iRow), prop.GetAlpha(), inFlyDirection);
+    int32_t err = prop.PropagateToXAlpha(xx + GPUTPCGeometry::Row2X(iRow), prop.GetAlpha(), inFlyDirection);
     if (err) {
       return dodEdx;
     }
     if (dodEdx && iRow + step == toRow) {
       float yUncorrected, zUncorrected;
       Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(sector, iRow, mP[0], mP[1], yUncorrected, zUncorrected);
-      uint32_t pad = CAMath::Float2UIntRn(Merger->Param().tpcGeometry.LinearY2Pad(sector, iRow, yUncorrected));
-      if (pad >= Merger->Param().tpcGeometry.NPads(iRow) || (Merger->GetConstantMem()->calibObjects.dEdxCalibContainer && Merger->GetConstantMem()->calibObjects.dEdxCalibContainer->isDead(sector, iRow, pad))) {
+      uint32_t pad = CAMath::Float2UIntRn(GPUTPCGeometry::LinearY2Pad(sector, iRow, yUncorrected));
+      if (pad >= GPUTPCGeometry::NPads(iRow) || (Merger->GetConstantMem()->calibObjects.dEdxCalibContainer && Merger->GetConstantMem()->calibObjects.dEdxCalibContainer->isDead(sector, iRow, pad))) {
         dodEdx = false;
       }
     }
@@ -782,7 +782,7 @@ GPUdic(0, 1) int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUr
       }
       CADEBUG(printf("\tPropagated to y = %f: X %f Z %f SinPhi %f\n", mX, mP[0], mP[1], mP[2]));
       for (int32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-        float rowX = Merger->Param().tpcGeometry.Row2X(j);
+        float rowX = GPUTPCGeometry::Row2X(j);
         if (CAMath::Abs(rowX - (-mP[0] * lrFactor)) < 1.5f) {
           CADEBUG(printf("\t\tAttempt row %d (Y %f Z %f)\n", j, mX * lrFactor, mP[1]));
           AttachClusters(Merger, sector, j, iTrack, false, mX * lrFactor, mP[1]);
@@ -823,18 +823,18 @@ GPUdic(0, 1) int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUr
   prop.Rotate180();
   CADEBUG(printf("\tMirrored position: Alpha %f X %f Y %f Z %f SinPhi %f DzDs %f\n", prop.GetAlpha(), mX, mP[0], mP[1], mP[2], mP[3]));
   iRow = toRow;
-  float dx = toX - Merger->Param().tpcGeometry.Row2X(toRow);
+  float dx = toX - GPUTPCGeometry::Row2X(toRow);
   if (up ^ (toX > mX)) {
     if (up) {
-      while (iRow < GPUCA_ROW_COUNT - 2 && Merger->Param().tpcGeometry.Row2X(iRow + 1) + dx <= mX) {
+      while (iRow < GPUCA_ROW_COUNT - 2 && GPUTPCGeometry::Row2X(iRow + 1) + dx <= mX) {
         iRow++;
       }
     } else {
-      while (iRow > 1 && Merger->Param().tpcGeometry.Row2X(iRow - 1) + dx >= mX) {
+      while (iRow > 1 && GPUTPCGeometry::Row2X(iRow - 1) + dx >= mX) {
         iRow--;
       }
     }
-    prop.PropagateToXAlpha(Merger->Param().tpcGeometry.Row2X(iRow) + dx, prop.GetAlpha(), inFlyDirection);
+    prop.PropagateToXAlpha(GPUTPCGeometry::Row2X(iRow) + dx, prop.GetAlpha(), inFlyDirection);
     AttachClustersPropagate(Merger, sector, iRow, toRow, iTrack, false, prop, inFlyDirection);
   }
   if (prop.PropagateToXAlpha(toX, prop.GetAlpha(), inFlyDirection)) {
@@ -875,7 +875,7 @@ GPUdni() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPU
     return;
   }
   float dx = (toX - X) / count;
-  const float myRowX = Merger->Param().tpcGeometry.Row2X(iRow);
+  const float myRowX = GPUTPCGeometry::Row2X(iRow);
   // printf("AttachMirror\n");
   // printf("X %f Y %f Z %f SinPhi %f toY %f -->\n", mX, mP[0], mP[1], mP[2], toY);
   // printf("X %f Y %f Z %f SinPhi %f, count %d dx %f (to: %f)\n", X, Y, Z, SinPhi, count, dx, X + count * dx);
@@ -905,7 +905,7 @@ GPUdni() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPU
     int32_t step = paramX >= mX ? 1 : -1;
     int32_t found = 0;
     for (int32_t j = iRow; j >= 0 && j < GPUCA_ROW_COUNT && found < 3; j += step) {
-      float rowX = mX + Merger->Param().tpcGeometry.Row2X(j) - myRowX;
+      float rowX = mX + GPUTPCGeometry::Row2X(j) - myRowX;
       if (CAMath::Abs(rowX - paramX) < 1.5f) {
         // printf("Attempt row %d\n", j);
         AttachClusters(Merger, sector, j, iTrack, false, mP[2] > 0 ? X : -X, Z);
@@ -930,8 +930,8 @@ GPUd() void GPUTPCGMTrackParam::ShiftZ2(const GPUTPCGMMergedTrackHit* clusters,
     const auto& GPUrestrict() cls = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
     tzInner = cls[clusters[N - 1].num].getTime();
     tzOuter = cls[clusters[0].num].getTime();
-    xInner = merger->Param().tpcGeometry.Row2X(clusters[N - 1].row);
-    xOuter = merger->Param().tpcGeometry.Row2X(clusters[0].row);
+    xInner = GPUTPCGeometry::Row2X(clusters[N - 1].row);
+    xOuter = GPUTPCGeometry::Row2X(clusters[0].row);
   }
   ShiftZ(merger, clusters[0].sector, tzInner, tzOuter, xInner, xOuter);
 }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
index a3e73c377ed44..9a4d2eebcb953 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
@@ -19,6 +19,7 @@
 #include "GPUProcessor.h"
 #include "GPUO2DataTypes.h"
 #include "GPUTPCConvertImpl.h"
+#include "GPUTPCGeometry.h"
 #include "GPUCommonMath.h"
 
 #ifndef GPUCA_GPUCODE_DEVICE
@@ -39,7 +40,7 @@ void GPUTPCTrackingData::InitializeRows(const GPUParam& p)
     new (&mRows[i]) GPUTPCRow;
   }
   for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
-    mRows[i].mX = p.tpcGeometry.Row2X(i);
+    mRows[i].mX = GPUTPCGeometry::Row2X(i);
     mRows[i].mMaxY = CAMath::Tan(p.par.dAlpha / 2.f) * mRows[i].mX;
   }
 }
@@ -101,7 +102,7 @@ void* GPUTPCTrackingData::SetPointersRows(void* mem)
 GPUd() void GPUTPCTrackingData::GetMaxNBins(GPUconstantref() const GPUConstantMem* mem, GPUTPCRow* GPUrestrict() row, int32_t& maxY, int32_t& maxZ)
 {
   maxY = row->mMaxY * 2.f / GPUCA_MIN_BIN_SIZE + 1;
-  maxZ = (mem->param.continuousMaxTimeBin > 0 ? (mem->calibObjects.fastTransformHelper->getCorrMap()->convTimeToZinTimeFrame(0, 0, mem->param.continuousMaxTimeBin)) : mem->param.tpcGeometry.TPCLength()) + 50;
+  maxZ = (mem->param.continuousMaxTimeBin > 0 ? (mem->calibObjects.fastTransformHelper->getCorrMap()->convTimeToZinTimeFrame(0, 0, mem->param.continuousMaxTimeBin)) : GPUTPCGeometry::TPCLength()) + 50;
   maxZ = maxZ / GPUCA_MIN_BIN_SIZE + 1;
 }
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
index 3aac31c87498c..5a7df0ba8b874 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
@@ -377,8 +377,8 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
       } while (false);
       (void)found;
       if (!found && tracker.GetConstantMem()->calibObjects.dEdxCalibContainer) {
-        uint32_t pad = CAMath::Float2UIntRn(tracker.Param().tpcGeometry.LinearY2Pad(tracker.ISector(), iRow, yUncorrected));
-        if (pad < tracker.Param().tpcGeometry.NPads(iRow) && tracker.GetConstantMem()->calibObjects.dEdxCalibContainer->isDead(tracker.ISector(), iRow, pad)) {
+        uint32_t pad = CAMath::Float2UIntRn(GPUTPCGeometry::LinearY2Pad(tracker.ISector(), iRow, yUncorrected));
+        if (pad < GPUTPCGeometry::NPads(iRow) && tracker.GetConstantMem()->calibObjects.dEdxCalibContainer->isDead(tracker.ISector(), iRow, pad)) {
           r.mNMissed--;
           rowHit = CALINK_DEAD_CHANNEL;
         }
@@ -395,7 +395,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
     const float z1 = row1.Grid().ZMin() + hh1.y * row1.HstepZ();
     const float z2 = row2.Grid().ZMin() + hh2.y * row2.HstepZ();
     float oldOffset = tParam.ZOffset();
-    tParam.ShiftZ(z1, z2, tracker.Param().tpcGeometry.Row2X(r.mFirstRow), tracker.Param().tpcGeometry.Row2X(r.mLastRow), tracker.Param().bzCLight, tracker.Param().rec.tpc.defaultZOffsetOverR);
+    tParam.ShiftZ(z1, z2, GPUTPCGeometry::Row2X(r.mFirstRow), GPUTPCGeometry::Row2X(r.mLastRow), tracker.Param().bzCLight, tracker.Param().rec.tpc.defaultZOffsetOverR);
     r.mLastZ -= tParam.ZOffset() - oldOffset;
     CADEBUG(printf("Shifted z from %f to %f\n", oldOffset, tParam.ZOffset()));
   }
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
index f876270a34358..622da856af805 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
@@ -13,9 +13,9 @@
 /// \author Felix Weiglhofer
 
 #include "ClusterAccumulator.h"
-#include "GPUTPCGeometry.h"
 #include "CfUtils.h"
 #include "GPUParam.h"
+#include "GPUTPCGeometry.h"
 #include "DataFormatsTPC/ClusterNative.h"
 
 using namespace o2::gpu;
@@ -81,17 +81,17 @@ GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, const Charge q, t
 
   bool isEdgeCluster;
   if (param.rec.tpc.cfEdgeTwoPads) {
-    isEdgeCluster = pad < 2 || pad >= param.tpcGeometry.NPads(pos.row()) - 2; // Geometrical edge check, peak within 2 pads of sector edge
+    isEdgeCluster = pad < 2 || pad >= GPUTPCGeometry::NPads(pos.row()) - 2; // Geometrical edge check, peak within 2 pads of sector edge
     if (isEdgeCluster) {
       bool leftEdge = (pad < 2);
-      if (leftEdge ? (pad == 1 && chargeMap[pos.delta({-1, 0})].unpack() < 1) : (pad == (param.tpcGeometry.NPads(pos.row()) - 2) && chargeMap[pos.delta({1, 0})].unpack() < 1)) {
+      if (leftEdge ? (pad == 1 && chargeMap[pos.delta({-1, 0})].unpack() < 1) : (pad == (GPUTPCGeometry::NPads(pos.row()) - 2) && chargeMap[pos.delta({1, 0})].unpack() < 1)) {
         isEdgeCluster = false; // No edge cluster if peak is close to edge but no charge at the edge.
       } else if (leftEdge ? (pad < mPadMean) : (pad > mPadMean)) {
         mPadMean = pad; // Correct to peak position if COG is close to middle of pad than peak
       }
     }
   } else {
-    isEdgeCluster = pad == 0 || pad == param.tpcGeometry.NPads(pos.row()) - 1;
+    isEdgeCluster = pad == 0 || pad == GPUTPCGeometry::NPads(pos.row()) - 1;
   }
 
   cn.qTot = CAMath::Float2UIntRn(mQtot);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
index 4a167b7d53890..1e76860331de6 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
@@ -15,6 +15,7 @@
 #include "GPUTPCCFCheckPadBaseline.h"
 #include "Array2D.h"
 #include "PackedCharge.h"
+#include "GPUTPCGeometry.h"
 #include "clusterFinderDefs.h"
 
 #ifndef GPUCA_GPUCODE
@@ -151,7 +152,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
 
 GPUd() ChargePos GPUTPCCFCheckPadBaseline::padToChargePos(int32_t& pad, const GPUTPCClusterFinder& clusterer)
 {
-  const GPUTPCGeometry& geo = clusterer.Param().tpcGeometry;
+  constexpr GPUTPCGeometry geo;
 
   int32_t padOffset = 0;
   for (Row r = 0; r < GPUCA_ROW_COUNT; r++) {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index f1fd95d696f5d..6662b93eccb78 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -22,6 +22,7 @@
 #include "GPUCommonAlgorithm.h"
 #include "TPCPadGainCalib.h"
 #include "TPCZSLinkMapping.h"
+#include "GPUTPCGeometry.h"
 
 using namespace o2::gpu;
 using namespace o2::gpu::tpccf;
@@ -57,8 +58,8 @@ GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUShared
   const size_t nDigits = clusterer.mPzsOffsets[iBlock].offset;
   if (iThread == 0) {
     const int32_t region = endpoint / 2;
-    s.nRowsRegion = clusterer.Param().tpcGeometry.GetRegionRows(region);
-    s.regionStartRow = clusterer.Param().tpcGeometry.GetRegionStart(region);
+    s.nRowsRegion = GPUTPCGeometry::GetRegionRows(region);
+    s.regionStartRow = GPUTPCGeometry::GetRegionStart(region);
     s.nThreadsPerRow = CAMath::Max(1u, nThreads / ((s.nRowsRegion + (endpoint & 1)) / 2));
     s.rowStride = nThreads / s.nThreadsPerRow;
     s.rowOffsetCounter = 0;
@@ -524,7 +525,7 @@ GPUd() o2::tpc::PadPos GPUTPCCFDecodeZSLinkBase::GetPadAndRowFromFEC(processorTy
 {
 #ifdef GPUCA_TPC_GEOMETRY_O2
   // Ported from tpc::Mapper (Not available on GPU...)
-  const GPUTPCGeometry& geo = clusterer.Param().tpcGeometry;
+  constexpr GPUTPCGeometry geo;
 
   const int32_t regionIter = cru % 2;
   const int32_t istreamm = ((rawFECChannel % 10) / 2);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 25cd2497fbf62..379ea27443fea 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -14,6 +14,7 @@
 
 #include "GPUTPCNNClusterizerKernels.h"
 #include "GPUTPCCFClusterizer.h"
+#include "GPUTPCGeometry.h"
 
 using namespace o2::gpu;
 using namespace o2::gpu::tpccf;
@@ -102,9 +103,9 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 }
 
 // THe following arithmetic is done because the network is trained with a split between IROC and OROC boundary
-GPUd() int GPUTPCNNClusterizerKernels::padOffset(int row_ref, int row_current, const GPUTPCGeometry& geo)
+GPUd() int GPUTPCNNClusterizerKernels::padOffset(int row_ref, int row_current)
 {
-  return (int)((geo.NPads(row_current) - geo.NPads(row_ref)) / 2);
+  return (int)((GPUTPCGeometry::NPads(row_current) - GPUTPCGeometry::NPads(row_ref)) / 2);
 }
 
 GPUd() int GPUTPCNNClusterizerKernels::rowOffset(int row, int global_shift)
@@ -112,16 +113,16 @@ GPUd() int GPUTPCNNClusterizerKernels::rowOffset(int row, int global_shift)
   return (row > 62 ? global_shift : 0);
 }
 
-GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int row, int pad, int global_shift, const GPUTPCGeometry& geo)
+GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int row, int pad, int global_shift)
 {
   if (pad < 0 || row < 0) { // Faster short-circuit
     return true;
   } else if (row < 63) {
-    return (pad >= static_cast<int>(geo.NPads(row)));
+    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row)));
   } else if (row < (63 + global_shift)) { // to account for the gap between IROC and OROC. Charge will be set to -1 in order to signal boundary to the neural network
     return true;
   } else if (row < (o2::tpc::constants::MAXGLOBALPADROW + global_shift)) {
-    return (pad >= static_cast<int>(geo.NPads(row - global_shift)));
+    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row - global_shift)));
   } else {
     return true;
   }
@@ -152,9 +153,9 @@ GPUd() void GPUTPCNNClusterizerKernels::fillInputData(int32_t nBlocks, int32_t n
 #endif
   for (int r = -clustererNN.nnClusterizerSizeInputRow; r <= clustererNN.nnClusterizerSizeInputRow; r++) {
     bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
-    int pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, row + r, clusterer.Param().tpcGeometry);
+    int pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, row + r);
     for (int p = -clustererNN.nnClusterizerSizeInputPad + pad_offset; p <= clustererNN.nnClusterizerSizeInputPad + pad_offset; p++) {
-      bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.nnClusterizerSizeInputRow, clusterer.Param().tpcGeometry);
+      bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.nnClusterizerSizeInputRow);
       for (int t = -clustererNN.nnClusterizerSizeInputTime; t <= clustererNN.nnClusterizerSizeInputTime; t++) {
         if (!is_boundary) {
           ChargePos tmp_pos(row + r, pad + p, time + t);
@@ -183,11 +184,11 @@ GPUd() void GPUTPCNNClusterizerKernels::fillInputData(int32_t nBlocks, int32_t n
     if (dtype == 0) {
       clustererNN.inputData16[write_idx] = (OrtDataType::Float16_t)(clusterer.mISector / 36.f);
       clustererNN.inputData16[write_idx + 1] = (OrtDataType::Float16_t)(row / 152.f);
-      clustererNN.inputData16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / clusterer.Param().tpcGeometry.NPads(row));
+      clustererNN.inputData16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
     } else {
       clustererNN.inputData32[write_idx] = clusterer.mISector / 36.f;
       clustererNN.inputData32[write_idx + 1] = row / 152.f;
-      clustererNN.inputData32[write_idx + 2] = static_cast<float>(pad) / clusterer.Param().tpcGeometry.NPads(row);
+      clustererNN.inputData32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
     }
   }
 }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index c7bd18115d61f..e6c1dc508d6e4 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -67,9 +67,9 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
   static GPUd() void publishClustersReg1(uint, GPUSharedMemory&, processorType&, uint8_t, int8_t, int8_t, uint);
   static GPUd() void publishClustersReg2(uint, GPUSharedMemory&, processorType&, uint8_t, int8_t, int8_t, uint);
 
-  static GPUd() int padOffset(int, int, const GPUTPCGeometry&);
+  static GPUd() int padOffset(int, int);
   static GPUd() int rowOffset(int, int);
-  static GPUd() bool isBoundary(int, int, int, const GPUTPCGeometry&);
+  static GPUd() bool isBoundary(int, int, int);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.cxx b/GPU/GPUTracking/dEdx/GPUdEdx.cxx
index 2e67ddda7c99c..b7da0de4c0e29 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.cxx
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.cxx
@@ -13,7 +13,6 @@
 /// \author David Rohr
 
 #include "GPUdEdx.h"
-#include "GPUTPCGeometry.h"
 #include "GPUdEdxInfo.h"
 #include "GPUCommonAlgorithm.h"
 #include "GPUParam.h"
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index 6c0a96d3adb75..bcd75af468c28 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -16,12 +16,12 @@
 #define GPUDEDX_H
 
 #include "GPUDef.h"
-#include "GPUTPCGeometry.h"
 #include "GPUCommonMath.h"
 #include "GPUParam.h"
 #include "GPUdEdxInfo.h"
 #include "DataFormatsTPC/Defs.h"
 #include "CalibdEdxContainer.h"
+#include "GPUTPCGeometry.h"
 #include "GPUDebugStreamer.h"
 
 namespace o2::gpu
@@ -32,8 +32,8 @@ class GPUdEdx
  public:
   // The driver must call clear(), fill clusters row by row outside-in, then run computedEdx() to get the result
   GPUd() void clear();
-  GPUd() void fillCluster(float qtot, float qmax, int32_t padRow, uint8_t sector, float trackSnp, float trackTgl, const GPUParam& param, const GPUCalibObjectsConst& calib, float z, float pad, float relTime);
-  GPUd() void fillSubThreshold(int32_t padRow, const GPUParam& param);
+  GPUd() void fillCluster(float qtot, float qmax, int32_t padRow, uint8_t sector, float trackSnp, float trackTgl, const GPUCalibObjectsConst& calib, float z, float pad, float relTime);
+  GPUd() void fillSubThreshold(int32_t padRow);
   GPUd() void computedEdx(GPUdEdxInfo& output, const GPUParam& param);
 
  private:
@@ -92,7 +92,7 @@ GPUdi() void GPUdEdx::checkSubThresh(int32_t roc)
   mLastROC = roc;
 }
 
-GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint8_t sector, float trackSnp, float trackTgl, const GPUParam& GPUrestrict() param, const GPUCalibObjectsConst& calib, float z, float pad, float relTime)
+GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint8_t sector, float trackSnp, float trackTgl, const GPUCalibObjectsConst& calib, float z, float pad, float relTime)
 {
   if (mCount >= MAX_NCL) {
     return;
@@ -100,8 +100,9 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
 
   // container containing all the dE/dx corrections
   auto calibContainer = calib.dEdxCalibContainer;
+  constexpr GPUTPCGeometry geo;
 
-  const int32_t roc = param.tpcGeometry.GetROC(padRow);
+  const int32_t roc = geo.GetROC(padRow);
   checkSubThresh(roc);
   float snp2 = trackSnp * trackSnp;
   if (snp2 > GPUCA_MAX_SIN_PHI_LOW) {
@@ -119,7 +120,7 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
   // getting the topology correction
   const uint32_t padPos = CAMath::Float2UIntRn(pad); // position of the pad is shifted half a pad ( pad=3 -> centre position of third pad)
   const float absRelPad = CAMath::Abs(pad - padPos);
-  const int32_t region = param.tpcGeometry.GetRegion(padRow);
+  const int32_t region = geo.GetRegion(padRow);
   z = CAMath::Abs(z);
   const float threshold = calibContainer->getZeroSupressionThreshold(sector, padRow, padPos); // TODO: Use the mean zero supresion threshold of all pads in the cluster?
   const bool useFullGainMap = calibContainer->isUsageOfFullGainMap();
@@ -161,8 +162,8 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
   }
 
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamdEdx)) {
-    float padlx = param.tpcGeometry.Row2X(padRow);
-    float padly = param.tpcGeometry.LinearPad2Y(sector, padRow, padPos);
+    float padlx = geo.Row2X(padRow);
+    float padly = geo.LinearPad2Y(sector, padRow, padPos);
     o2::utils::DebugStreamer::instance()->getStreamer("debug_dedx", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_dedx").data()
                                                                               << "qTot=" << mChargeTot[mCount - 1]
                                                                               << "qMax=" << mChargeMax[mCount - 1]
@@ -189,9 +190,9 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
   })
 }
 
-GPUdi() void GPUdEdx::fillSubThreshold(int32_t padRow, const GPUParam& GPUrestrict() param)
+GPUdi() void GPUdEdx::fillSubThreshold(int32_t padRow)
 {
-  const int32_t roc = param.tpcGeometry.GetROC(padRow);
+  const int32_t roc = GPUTPCGeometry::GetROC(padRow);
   checkSubThresh(roc);
   mNSubThresh++;
 }
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index 6fd70354c9486..0a780732273db 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -150,13 +150,13 @@ void GPUDisplay::DrawGLScene_updateEventData()
         float4* ptr = &mGlobalPos[cid];
         if (mParam->par.earlyTpcTransform) {
           const auto& cl = mIOPtrs->clusterData[iSector][i];
-          mParam->Sector2Global(iSector, (mCfgH.clustersOnNominalRow ? mParam->tpcGeometry.Row2X(row) : cl.x) + mCfgH.xAdd, cl.y, cl.z, &ptr->x, &ptr->y, &ptr->z);
+          mParam->Sector2Global(iSector, (mCfgH.clustersOnNominalRow ? GPUTPCGeometry::Row2X(row) : cl.x) + mCfgH.xAdd, cl.y, cl.z, &ptr->x, &ptr->y, &ptr->z);
         } else {
           float x, y, z;
           const auto& cln = mIOPtrs->clustersNative->clusters[iSector][0][i];
           GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, iSector, row, cln.getPad(), cln.getTime(), x, y, z);
           if (mCfgH.clustersOnNominalRow) {
-            x = mParam->tpcGeometry.Row2X(row);
+            x = GPUTPCGeometry::Row2X(row);
           }
           mParam->Sector2Global(iSector, x + mCfgH.xAdd, y, z, &ptr->x, &ptr->y, &ptr->z);
         }
diff --git a/GPU/GPUTracking/qa/genEvents.cxx b/GPU/GPUTracking/qa/genEvents.cxx
index 627cfc5f9909a..2e1bc1c5c64b2 100644
--- a/GPU/GPUTracking/qa/genEvents.cxx
+++ b/GPU/GPUTracking/qa/genEvents.cxx
@@ -222,7 +222,7 @@ int32_t genEvents::GenerateEvent(const GPUParam& param, char* filename)
 
     for (int32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
       // if( iRow>=50 ) break; //SG!!!
-      float xRow = param.tpcGeometry.Row2X(iRow);
+      float xRow = GPUTPCGeometry::Row2X(iRow);
       // transport to row
       int32_t err = 0;
       for (int32_t itry = 0; itry < 1; itry++) {

From 9070674d026b2540656e18760bb3ed1f8517835b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 17:54:41 +0100
Subject: [PATCH 0088/1764] GPU: Improve memory usage debug printout

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 15 +++++++--------
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  8 ++++++++
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 2bd4c0e937c20..b715b08f52b32 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -811,11 +811,9 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
     GPUFatal("Tag mismatch when popping non persistent memory from stack : pop %s vs on stack %s", qTag2Str(tag).c_str(), qTag2Str(std::get<3>(mNonPersistentMemoryStack.back())).c_str());
   }
   if ((mProcessingSettings.debugLevel >= 3 || mProcessingSettings.allocDebugLevel) && (IsGPU() || mProcessingSettings.forceHostMemoryPoolSize)) {
-    if (IsGPU()) {
-      printf("Allocated Device memory after %30s (%8s): %'13zd (non temporary %'13zd, blocked %'13zd)\n", GPUDataTypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<3>(mNonPersistentMemoryStack.back())).c_str(), ptrDiff(mDeviceMemoryPool, mDeviceMemoryBase) + ptrDiff((char*)mDeviceMemoryBase + mDeviceMemorySize, mDeviceMemoryPoolEnd), ptrDiff(mDeviceMemoryPool, mDeviceMemoryBase), mDeviceMemoryPoolBlocked ? ptrDiff((char*)mDeviceMemoryBase + mDeviceMemorySize, mDeviceMemoryPoolBlocked) : 0);
-    }
-    printf("Allocated Host memory after   %30s (%8s): %'13zd (non temporary %'13zd, blocked %'13zd)\n", GPUDataTypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<3>(mNonPersistentMemoryStack.back())).c_str(), ptrDiff(mHostMemoryPool, mHostMemoryBase) + ptrDiff((char*)mHostMemoryBase + mHostMemorySize, mHostMemoryPoolEnd), ptrDiff(mHostMemoryPool, mHostMemoryBase), mHostMemoryPoolBlocked ? ptrDiff((char*)mHostMemoryBase + mHostMemorySize, mHostMemoryPoolBlocked) : 0);
-    printf("%16s", "");
+    printf("Allocated memory after %30s (%8s) (Stack %zu): ", GPUDataTypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<3>(mNonPersistentMemoryStack.back())).c_str(), mNonPersistentMemoryStack.size());
+    PrintMemoryOverview();
+    printf("%76s", "");
     PrintMemoryMax();
   }
   mHostMemoryPoolEnd = std::get<0>(mNonPersistentMemoryStack.back());
@@ -888,9 +886,10 @@ void GPUReconstruction::PrintMemoryMax()
 void GPUReconstruction::PrintMemoryOverview()
 {
   if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
-    printf("Memory Allocation: Host %'zd / %'zu (Permanent %'zd), Device %'zd / %'zu, (Permanent %'zd) %zu chunks\n",
-           ptrDiff(mHostMemoryPool, mHostMemoryBase) + ptrDiff((char*)mHostMemoryBase + mHostMemorySize, mHostMemoryPoolEnd), mHostMemorySize, ptrDiff(mHostMemoryPermanent, mHostMemoryBase),
-           ptrDiff(mDeviceMemoryPool, mDeviceMemoryBase) + ptrDiff((char*)mDeviceMemoryBase + mDeviceMemorySize, mDeviceMemoryPoolEnd), mDeviceMemorySize, ptrDiff(mDeviceMemoryPermanent, mDeviceMemoryBase), mMemoryResources.size());
+    printf("Memory Allocation: Host %'13zd / %'13zu (Permanent %'13zd, Data %'13zd, Scratch %'13zd), Device %'13zd / %'13zu, (Permanent %'13zd, Data %'13zd, Scratch %'13zd) %zu chunks\n",
+           ptrDiff(mHostMemoryPool, mHostMemoryBase) + ptrDiff((char*)mHostMemoryBase + mHostMemorySize, mHostMemoryPoolEnd), mHostMemorySize, ptrDiff(mHostMemoryPermanent, mHostMemoryBase), ptrDiff(mHostMemoryPool, mHostMemoryPermanent), ptrDiff((char*)mHostMemoryBase + mHostMemorySize, mHostMemoryPoolEnd),
+           ptrDiff(mDeviceMemoryPool, mDeviceMemoryBase) + ptrDiff((char*)mDeviceMemoryBase + mDeviceMemorySize, mDeviceMemoryPoolEnd), mDeviceMemorySize, ptrDiff(mDeviceMemoryPermanent, mDeviceMemoryBase), ptrDiff(mDeviceMemoryPool, mDeviceMemoryPermanent), ptrDiff((char*)mDeviceMemoryBase + mDeviceMemorySize, mDeviceMemoryPoolEnd),
+           mMemoryResources.size());
   }
 }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index f397fc51bd407..abf2d55c95db7 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -215,6 +215,10 @@ int32_t GPUReconstructionCPU::RunChains()
   mStatNEvents++;
   mNEventsProcessed++;
 
+  if (mProcessingSettings.debugLevel >= 3 || mProcessingSettings.allocDebugLevel) {
+    printf("Allocated memory when starting processing %34s", "");
+    PrintMemoryOverview();
+  }
   mTimerTotal.Start();
   const std::clock_t cpuTimerStart = std::clock();
   if (mProcessingSettings.doublePipeline) {
@@ -235,6 +239,10 @@ int32_t GPUReconstructionCPU::RunChains()
   }
   mTimerTotal.Stop();
   mStatCPUTime += (double)(std::clock() - cpuTimerStart) / CLOCKS_PER_SEC;
+  if (mProcessingSettings.debugLevel >= 3 || mProcessingSettings.allocDebugLevel) {
+    printf("Allocated memory when ending processing %36s", "");
+    PrintMemoryOverview();
+  }
 
   mStatWallTime = (mTimerTotal.GetElapsedTime() * 1000000. / mStatNEvents);
   std::string nEventReport;

From 435b17ba0828727f3962032c4aeefd4e27891bbd Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 18:02:01 +0100
Subject: [PATCH 0089/1764] GPU TPC: Add option to clear all
 non-external-output TPC memory at end of processing

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx | 3 +++
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 1 +
 2 files changed, 4 insertions(+)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index abf2d55c95db7..a4074282da30f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -236,6 +236,9 @@ int32_t GPUReconstructionCPU::RunChains()
         return retVal;
       }
     }
+    if (GetProcessingSettings().tpcFreeAllocatedMemoryAfterProcessing) {
+      ClearAllocatedMemory();
+    }
   }
   mTimerTotal.Stop();
   mStatCPUTime += (double)(std::clock() - cpuTimerStart) / CLOCKS_PER_SEC;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index b7f761c73ffc0..f7004d76c726c 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -326,6 +326,7 @@ AddOption(oclPlatformNum, int32_t, -1, "", 0, "Platform to use, in case the back
 AddOption(oclCompileFromSources, bool, false, "", 0, "Compile OpenCL binary from included source code instead of using included spirv code")
 AddOption(oclOverrideSourceBuildFlags, std::string, "", "", 0, "Override OCL build flags for compilation from source, put a space for empty options")
 AddOption(printSettings, bool, false, "", 0, "Print all settings when initializing")
+AddOption(tpcFreeAllocatedMemoryAfterProcessing, bool, false, "", 0, "Clean all memory allocated by TPC when TPC processing done, only data written to external output resources will remain")
 AddVariable(eventDisplay, o2::gpu::GPUDisplayFrontendInterface*, nullptr)
 AddSubConfig(GPUSettingsProcessingRTC, rtc)
 AddSubConfig(GPUSettingsProcessingParam, param)

From 1c4d839ae9281bc727ba91d12886b12cf1dfc4af Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Mar 2025 15:32:52 +0100
Subject: [PATCH 0090/1764] GPU: Remove bogus placement new leading to memory
 leak

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx        | 2 --
 GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx | 1 -
 GPU/GPUTracking/Definitions/GPUSettingsList.h     | 2 +-
 3 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index b715b08f52b32..35e44d99d5c0c 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -86,8 +86,6 @@ GPUReconstruction::GPUReconstruction(const GPUSettingsDeviceBackend& cfg) : mHos
     mMaster = cfg.master;
     cfg.master->mSlaves.emplace_back(this);
   }
-  new (&mProcessingSettings) GPUSettingsProcessing;
-  new (&mGRPSettings) GPUSettingsGRP;
   param().SetDefaults(&mGRPSettings);
   mMemoryScalers.reset(new GPUMemorySizeScalers);
   for (uint32_t i = 0; i < NSECTORS; i++) {
diff --git a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
index c47bd488d96ef..aa01d26446b56 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
@@ -34,7 +34,6 @@ using namespace o2::gpu;
 GPUReconstruction* GPUReconstruction::CreateInstance(DeviceType type, bool forceType, GPUReconstruction* master)
 {
   GPUSettingsDeviceBackend cfg;
-  new (&cfg) GPUSettingsDeviceBackend;
   cfg.deviceType = type;
   cfg.forceDeviceType = forceType;
   cfg.master = master;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index f7004d76c726c..40a7fc71cbb4d 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -607,7 +607,7 @@ EndConfig()
 
 // Derrived parameters used in GPUParam
 BeginHiddenConfig(GPUSettingsParam, param)
-AddVariableRTC(dAlpha, float, 0.f)                 // angular size
+AddVariableRTC(dAlpha, float, 0.f)            // angular size
 AddVariableRTC(assumeConstantBz, int8_t, 0)   // Assume a constant magnetic field
 AddVariableRTC(toyMCEventsFlag, int8_t, 0)    // events were build with home-made event generator
 AddVariableRTC(continuousTracking, int8_t, 0) // Continuous tracking, estimate bz and errors for abs(z) = 125cm during seeding

From 4060a20febe97646422c8e89b1abc1037aca0788 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Mon, 10 Mar 2025 17:01:04 +0530
Subject: [PATCH 0091/1764] explicitly add CCDB to some CCDB fatal error
 strings

---
 CCDB/include/CCDB/BasicCCDBManager.h      | 2 +-
 Framework/CCDBSupport/src/CCDBHelpers.cxx | 6 +++---
 Framework/Core/src/DataRefUtils.cxx       | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/CCDB/include/CCDB/BasicCCDBManager.h b/CCDB/include/CCDB/BasicCCDBManager.h
index 678bedf24e551..8af1817718fa2 100644
--- a/CCDB/include/CCDB/BasicCCDBManager.h
+++ b/CCDB/include/CCDB/BasicCCDBManager.h
@@ -333,7 +333,7 @@ T* CCDBManagerInstance::getSpecificForRun(std::string const& path, int runNumber
   auto [start, stop] = getRunDuration(runNumber);
   if (start < 0 || stop < 0) {
     if (mFatalWhenNull) {
-      reportFatal(std::string("Failed to get run duration for run ") + std::to_string(runNumber));
+      reportFatal(std::string("Failed to get run duration for run ") + std::to_string(runNumber) + std::string(" from CCDB"));
     }
     return nullptr;
   }
diff --git a/Framework/CCDBSupport/src/CCDBHelpers.cxx b/Framework/CCDBSupport/src/CCDBHelpers.cxx
index 29d446403e1c8..0db4cbb5ac71d 100644
--- a/Framework/CCDBSupport/src/CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/CCDBHelpers.cxx
@@ -219,7 +219,7 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
         } else if (meta.defaultValue.get<int>() == 2) {
           timestampToUse = std::stoi(dtc.runNumber);
         } else {
-          LOGP(fatal, "Undefined run-dependent option {} for spec {}/{}/{}", meta.defaultValue.get<int>(), concrete.origin.as<std::string>(), concrete.description.as<std::string>(), int(concrete.subSpec));
+          LOGP(fatal, "Undefined ccdb-run-dependent option {} for spec {}/{}/{}", meta.defaultValue.get<int>(), concrete.origin.as<std::string>(), concrete.description.as<std::string>(), int(concrete.subSpec));
         }
       } else if (isPrefix(ccdbMetadataPrefix, meta.name)) {
         std::string key = meta.name.substr(ccdbMetadataPrefix.size());
@@ -252,7 +252,7 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
       LOGP(detail, "Loading {} for timestamp {}", path, timestampToUse);
       api.loadFileToMemory(v, path, metadata, timestampToUse, &headers, etag, helper->createdNotAfter, helper->createdNotBefore);
       if ((headers.count("Error") != 0) || (etag.empty() && v.empty())) {
-        LOGP(fatal, "Unable to find object {}/{}", path, timestampToUse);
+        LOGP(fatal, "Unable to find CCDB object {}/{}", path, timestampToUse);
         // FIXME: I should send a dummy message.
         continue;
       }
@@ -394,7 +394,7 @@ AlgorithmSpec CCDBHelpers::fetchFromCCDB()
             helper->lastCheckedTFCounterOrbReset = timingInfo.tfCounter;
             api.loadFileToMemory(v, path, metadata, timingInfo.creation, &headers, etag, helper->createdNotAfter, helper->createdNotBefore);
             if ((headers.count("Error") != 0) || (etag.empty() && v.empty())) {
-              LOGP(fatal, "Unable to find object {}/{}", path, timingInfo.creation);
+              LOGP(fatal, "Unable to find CCDB object {}/{}", path, timingInfo.creation);
               // FIXME: I should send a dummy message.
               return;
             }
diff --git a/Framework/Core/src/DataRefUtils.cxx b/Framework/Core/src/DataRefUtils.cxx
index f092429d9c5a0..69eb1dc7faba6 100644
--- a/Framework/Core/src/DataRefUtils.cxx
+++ b/Framework/Core/src/DataRefUtils.cxx
@@ -94,7 +94,7 @@ void* DataRefUtils::decodeCCDB(DataRef const& ref, std::type_info const& tinfo)
     headerSize = *reinterpret_cast<const int*>(buff + dh->payloadSize - Offset);
   }
   if (headerSize < 0) {
-    LOGP(fatal, "Anomalous flattened header size {} extracted", headerSize);
+    LOGP(fatal, "Anomalous flattened header size {} extracted for CCDB object {}/{}", headerSize, dh->dataOrigin.as<std::string>(), dh->dataDescription.as<std::string>());
   }
   TMemFile memFile("name", const_cast<char*>(ref.payload), dh->payloadSize - headerSize, "READ");
   gErrorIgnoreLevel = previousErrorLevel;
@@ -128,7 +128,7 @@ std::map<std::string, std::string> DataRefUtils::extractCCDBHeaders(DataRef cons
   }
 
   if (headerSize < 0) {
-    LOGP(fatal, "Anomalous flattened header size {} extracted", headerSize);
+    LOGP(fatal, "Anomalous flattened header size {} extracted for CCDB object {}/{}", headerSize, dh->dataOrigin.as<std::string>(), dh->dataDescription.as<std::string>());
   }
 
   buff += dh->payloadSize - headerSize; // jump to the start of flattened header

From caeafb5126c157792dbde64ca9310a86f7cd65b2 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Mon, 17 Mar 2025 10:53:31 +0100
Subject: [PATCH 0092/1764] itsresponse: remove incompatible arg in CMake

---
 Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt b/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
index ad26d9e658e16..381e4f4b54c01 100644
--- a/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
+++ b/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
@@ -29,7 +29,6 @@ endif()
 add_custom_command(TARGET O2exe-alpide-response-generator POST_BUILD
                    COMMAND ${CMAKE_BINARY_DIR}/stage/bin/o2-alpide-response-generator -i ${ITSRESPONSE_DIR}/response/AlpideResponseData/ -o ${CMAKE_CURRENT_BINARY_DIR}/
                    BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/AlpideResponseData.root
-                   DEPENDS alpide-response-generator
                    COMMENT "Generating AlpideResponseData.root"
 )
 

From 8c1e88b840a1910ff8a9138c6ed7bde87519a08c Mon Sep 17 00:00:00 2001
From: afurs <afurs@cern.ch>
Date: Sat, 15 Mar 2025 11:59:47 +0100
Subject: [PATCH 0093/1764] DataFormatsFIT: hotfix for LUT, excluded CCDB API
 from header

---
 .../Detectors/FIT/common/CMakeLists.txt       |  1 +
 .../include/DataFormatsFIT/LookUpTable.h      | 17 +++++-------
 .../Detectors/FIT/common/src/LookUpTable.cxx  | 26 +++++++++++++++++++
 3 files changed, 33 insertions(+), 11 deletions(-)
 create mode 100644 DataFormats/Detectors/FIT/common/src/LookUpTable.cxx

diff --git a/DataFormats/Detectors/FIT/common/CMakeLists.txt b/DataFormats/Detectors/FIT/common/CMakeLists.txt
index fc8d975a34023..61dbcabc7f087 100644
--- a/DataFormats/Detectors/FIT/common/CMakeLists.txt
+++ b/DataFormats/Detectors/FIT/common/CMakeLists.txt
@@ -13,6 +13,7 @@ o2_add_library(DataFormatsFIT
   SOURCES src/RawEventData.cxx
           src/Triggers.cxx
           src/RawDataMetric.cxx
+          src/LookUpTable.cxx
   PUBLIC_LINK_LIBRARIES O2::CommonDataFormat
                         O2::DetectorsCommonDataFormats
                         O2::CCDB)
diff --git a/DataFormats/Detectors/FIT/common/include/DataFormatsFIT/LookUpTable.h b/DataFormats/Detectors/FIT/common/include/DataFormatsFIT/LookUpTable.h
index 64ae3dc9653d0..aa4bb1fba8d41 100644
--- a/DataFormats/Detectors/FIT/common/include/DataFormatsFIT/LookUpTable.h
+++ b/DataFormats/Detectors/FIT/common/include/DataFormatsFIT/LookUpTable.h
@@ -15,8 +15,9 @@
 // Look Up Table FIT
 //////////////////////////////////////////////
 
-#include "CCDB/BasicCCDBManager.h"
 #include "DetectorsCommonDataFormats/DetID.h"
+#include "CommonUtils/NameConf.h"
+#include "Framework/Logger.h"
 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
 #include <boost/property_tree/ptree.hpp>
 #include <boost/property_tree/json_parser.hpp>
@@ -158,8 +159,7 @@ enum class EModuleType : int { kUnknown,
                                kTCM };
 
 template <typename MapEntryCRU2ModuleType = std::unordered_map<EntryCRU, EModuleType, HasherCRU, ComparerCRU>,
-          typename MapEntryPM2ChannelID = std::unordered_map<EntryPM, int, HasherPM, ComparerPM>,
-          typename = typename std::enable_if_t<std::is_integral<typename MapEntryPM2ChannelID::mapped_type>::value>>
+          typename MapEntryPM2ChannelID = std::unordered_map<EntryPM, int, HasherPM, ComparerPM>>
 class LookupTableBase
 {
  public:
@@ -174,7 +174,7 @@ class LookupTableBase
   typedef EntryPM_t Topo_t;                                         // temporary for common interface
 
   LookupTableBase() = default;
-  LookupTableBase(const Table_t& vecEntryFEE) { initFromTable(vecEntryFEE); }
+  LookupTableBase(const Table_t* vecEntryFEE) { initFromTable(vecEntryFEE); }
   LookupTableBase(const std::string& pathToFile) { initFromFile(pathToFile); }
   LookupTableBase(const std::string& urlCCDB, const std::string& pathToStorageInCCDB, long timestamp = -1) { initCCDB(urlCCDB, pathToStorageInCCDB, timestamp); }
   // Map of str module names -> enum types
@@ -243,13 +243,7 @@ class LookupTableBase
     prepareEntriesFEE(filepath);
     prepareLUT();
   }
-  void initCCDB(const std::string& urlCCDB, const std::string& pathToStorageInCCDB, long timestamp = -1)
-  {
-    auto& mgr = o2::ccdb::BasicCCDBManager::instance();
-    mgr.setURL(urlCCDB);
-    mVecEntryFEE = *(mgr.getForTimeStamp<Table_t>(pathToStorageInCCDB, timestamp));
-    prepareLUT();
-  }
+  void initCCDB(const std::string& urlCCDB, const std::string& pathToStorageInCCDB, long timestamp = -1);
   void initFromTable(const Table_t* vecEntryFEE)
   {
     mVecEntryFEE = *vecEntryFEE;
@@ -419,6 +413,7 @@ class LookupTableBase
   Table_t mVecEntryFEE;
   MapEntryCRU2ModuleType_t mMapEntryCRU2ModuleType;
   MapEntryPM2ChannelID_t mMapEntryPM2ChannelID;
+  typedef std::enable_if_t<std::is_integral<typename MapEntryPM2ChannelID::mapped_type>::value> CheckChannelIDtype; // should be integral
 };
 
 // Singleton for LookUpTable, coomon for all three FIT detectors
diff --git a/DataFormats/Detectors/FIT/common/src/LookUpTable.cxx b/DataFormats/Detectors/FIT/common/src/LookUpTable.cxx
new file mode 100644
index 0000000000000..73c0b1bf1bb9e
--- /dev/null
+++ b/DataFormats/Detectors/FIT/common/src/LookUpTable.cxx
@@ -0,0 +1,26 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "DataFormatsFIT/LookUpTable.h"
+#include "CCDB/BasicCCDBManager.h"
+#include <unordered_map>
+using namespace o2::fit;
+template <typename MapEntryCRU2ModuleType, typename MapEntryPM2ChannelID>
+void LookupTableBase<MapEntryCRU2ModuleType, MapEntryPM2ChannelID>::initCCDB(const std::string& urlCCDB, const std::string& pathToStorageInCCDB, long timestamp)
+{
+
+  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
+  mgr.setURL(urlCCDB);
+  mVecEntryFEE = *(mgr.getForTimeStamp<LookupTableBase<MapEntryCRU2ModuleType, MapEntryPM2ChannelID>::Table_t>(pathToStorageInCCDB, timestamp));
+  prepareLUT();
+}
+template class o2::fit::LookupTableBase<std::unordered_map<EntryCRU, EModuleType, HasherCRU, ComparerCRU>,
+                                        std::unordered_map<EntryPM, int, HasherPM, ComparerPM>>;

From 940e2e25ac2830b683ce0d5630b4370596b7a886 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Tue, 18 Mar 2025 10:48:12 +0100
Subject: [PATCH 0094/1764] Add empty skeleton for the TRK digitization
 (#13959)

---
 Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt  |   3 +-
 .../ALICE3/TRK/simulation/CMakeLists.txt      |   8 +-
 .../include/TRKSimulation/DPLDigitizerParam.h |  69 +++
 .../include/TRKSimulation/Digitizer.h         | 128 +++++
 .../TRK/simulation/src/DPLDigitizerParam.cxx  |  23 +
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   | 467 ++++++++++++++++++
 .../TRK/simulation/src/TRKSimulationLinkDef.h |   6 +
 .../ALICE3/TRK/workflow/CMakeLists.txt        |  32 ++
 .../include/TRKWorkflow/DigitReaderSpec.h     |  87 ++++
 .../include/TRKWorkflow/DigitWriterSpec.h     |  26 +
 .../TRK/workflow/src/DigitReaderSpec.cxx      | 139 ++++++
 .../TRK/workflow/src/DigitWriterSpec.cxx      | 110 +++++
 Steer/DigitizerWorkflow/CMakeLists.txt        |   5 +-
 .../src/SimpleDigitizerWorkflow.cxx           |  13 +
 .../src/TRKDigitizerSpec.cxx                  | 303 ++++++++++++
 .../DigitizerWorkflow/src/TRKDigitizerSpec.h  |  24 +
 16 files changed, 1439 insertions(+), 4 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/DPLDigitizerParam.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitReaderSpec.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitWriterSpec.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitReaderSpec.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitWriterSpec.cxx
 create mode 100644 Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
 create mode 100644 Steer/DigitizerWorkflow/src/TRKDigitizerSpec.h

diff --git a/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
index 83838a01d13f1..645e3149e4ab7 100644
--- a/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
@@ -10,4 +10,5 @@
 # or submit itself to any jurisdiction.
 
 add_subdirectory(base)
-add_subdirectory(simulation)
\ No newline at end of file
+add_subdirectory(simulation)
+add_subdirectory(workflow)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
index c21b7b9aebbf6..856fd310fe5a2 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
@@ -12,16 +12,20 @@
 o2_add_library(TRKSimulation
                SOURCES src/TRKLayer.cxx
                        src/Detector.cxx
+                       src/Digitizer.cxx
                        src/TRKServices.cxx
+                       src/DPLDigitizerParam.cxx
                        src/TRKPetalCase.cxx
                        src/TRKPetalLayer.cxx
                        src/TRKPetalDisk.cxx
                PUBLIC_LINK_LIBRARIES O2::TRKBase
                                      O2::FT3Simulation
-                                     O2::ITSMFTSimulation)
+                                     O2::ITSMFTSimulation
+                                     O2::SimulationDataFormat)
 
 o2_target_root_dictionary(TRKSimulation
-                          HEADERS include/TRKSimulation/Detector.h
+                          HEADERS include/TRKSimulation/Digitizer.h
+                                  include/TRKSimulation/Detector.h
                                   include/TRKSimulation/TRKLayer.h
                                   include/TRKSimulation/TRKServices.h
                                   include/TRKSimulation/TRKPetalCase.h
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
new file mode 100644
index 0000000000000..59b3551ecbd32
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
@@ -0,0 +1,69 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_TRKDPLDIGITIZERPARAM_H_
+#define ALICEO2_TRKDPLDIGITIZERPARAM_H_
+
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include <string_view>
+
+namespace o2
+{
+namespace trk
+{
+template <int N>
+struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizerParam<N>> {
+  static_assert(N == o2::detectors::DetID::TRK || N == o2::detectors::DetID::FT3, "only DetID::TRK or DetID::FT3 are allowed");
+
+  static constexpr std::string_view getParamName()
+  {
+    return N == o2::detectors::DetID::TRK ? ParamName[0] : ParamName[1];
+  }
+
+  bool continuous = true;                   ///< flag for continuous simulation
+  float noisePerPixel = DEFNoisePerPixel(); ///< ALPIDE Noise per channel
+  float strobeFlatTop = 7500.;              ///< strobe shape flat top
+  float strobeMaxRiseTime = 1100.;          ///< strobe max rise time
+  float strobeQRiseTime0 = 450.;            ///< q @ which strobe rise time is 0
+
+  double timeOffset = 0.;                 ///< time offset (in seconds!) to calculate ROFrame from hit time
+  int chargeThreshold = 150;              ///< charge threshold in Nelectrons
+  int minChargeToAccount = 15;            ///< minimum charge contribution to account
+  int nSimSteps = 7;                      ///< number of steps in response simulation
+  float energyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
+
+  float Vbb = 0.0;   ///< back bias absolute value for MFT (in Volt)
+  float IBVbb = 0.0; ///< back bias absolute value for ITS Inner Barrel (in Volt)
+  float OBVbb = 0.0; ///< back bias absolute value for ITS Outter Barrel (in Volt)
+
+  std::string noiseFilePath{}; ///< optional noise masks file path. FIXME to be removed once switch to CCDBFetcher
+
+  // boilerplate stuff + make principal key
+  O2ParamDef(DPLDigitizerParam, getParamName().data());
+
+ private:
+  static constexpr float DEFNoisePerPixel()
+  {
+    return N == o2::detectors::DetID::TRK ? 1e-8 : 1e-8; // ITS/MFT values here!!
+  }
+
+  static constexpr std::string_view ParamName[2] = {"TRKDigitizerParam", "FT3DigitizerParam"};
+};
+
+template <int N>
+DPLDigitizerParam<N> DPLDigitizerParam<N>::sInstance;
+
+} // namespace trk
+} // namespace o2
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
new file mode 100644
index 0000000000000..6863c5392cae3
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
@@ -0,0 +1,128 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Digitizer.h
+/// \brief Definition of the TRK digitizer
+#ifndef ALICEO2_TRK_DIGITIZER_H
+#define ALICEO2_TRK_DIGITIZER_H
+
+#include <vector>
+#include <deque>
+#include <memory>
+
+#include "Rtypes.h"  // for Digitizer::Class
+#include "TObject.h" // for TObject
+
+#include "ITSMFTSimulation/ChipDigitsContainer.h"
+// #include "ITSMFTSimulation/AlpideSimResponse.h"
+#include "ITSMFTSimulation/DigiParams.h"
+#include "ITSMFTSimulation/Hit.h"
+#include "TRKBase/GeometryTGeo.h"
+// #include "ITS3Base/SegmentationSuperAlpide.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "CommonDataFormat/InteractionRecord.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#endif
+
+namespace o2::trk
+{
+
+class Digitizer : public TObject
+{
+  using ExtraDig = std::vector<itsmft::PreDigitLabelRef>; ///< container for extra contributions to PreDigits
+
+ public:
+  void setDigits(std::vector<o2::itsmft::Digit>* dig) { mDigits = dig; }
+  void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
+  void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
+
+  o2::itsmft::DigiParams& getParams() { return (o2::itsmft::DigiParams&)mParams; }
+  const o2::itsmft::DigiParams& getParams() const { return mParams; }
+
+  void init();
+
+  /// Steer conversion of hits to digits
+  void process(const std::vector<itsmft::Hit>* hits, int evID, int srcID);
+  void setEventTime(const o2::InteractionTimeRecord& irt);
+  double getEndTimeOfROFMax() const
+  {
+    ///< return the time corresponding to end of the last reserved ROFrame : mROFrameMax
+    return mParams.getROFrameLength() * (mROFrameMax + 1) + mParams.getTimeOffset();
+  }
+
+  void setContinuous(bool v) { mParams.setContinuous(v); }
+  bool isContinuous() const { return mParams.isContinuous(); }
+  void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
+
+  void setDigiParams(const o2::itsmft::DigiParams& par) { mParams = par; }
+  const o2::itsmft::DigiParams& getDigitParams() const { return mParams; }
+
+  // provide the common itsmft::GeometryTGeo to access matrices and segmentation
+  void setGeometry(const o2::trk::GeometryTGeo* gm) { mGeometry = gm; }
+
+  uint32_t getEventROFrameMin() const { return mEventROFrameMin; }
+  uint32_t getEventROFrameMax() const { return mEventROFrameMax; }
+  void resetEventROFrames()
+  {
+    mEventROFrameMin = 0xffffffff;
+    mEventROFrameMax = 0;
+  }
+
+  void setDeadChannelsMap(const o2::itsmft::NoiseMap* mp) { mDeadChanMap = mp; }
+
+ private:
+  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
+  void registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
+
+  ExtraDig* getExtraDigBuffer(uint32_t roFrame)
+  {
+    if (mROFrameMin > roFrame) {
+      return nullptr; // nothing to do
+    }
+    int ind = roFrame - mROFrameMin;
+    while (ind >= int(mExtraBuff.size())) {
+      mExtraBuff.emplace_back(std::make_unique<ExtraDig>());
+    }
+    return mExtraBuff[ind].get();
+  }
+
+  static constexpr float sec2ns = 1e9;
+
+  o2::itsmft::DigiParams mParams;          ///< digitization parameters
+  o2::InteractionTimeRecord mEventTime;    ///< global event time and interaction record
+  o2::InteractionRecord mIRFirstSampledTF; ///< IR of the 1st sampled IR, noise-only ROFs will be inserted till this IR only
+  double mCollisionTimeWrtROF{};
+  uint32_t mROFrameMin = 0; ///< lowest RO frame of current digits
+  uint32_t mROFrameMax = 0; ///< highest RO frame of current digits
+  uint32_t mNewROFrame = 0; ///< ROFrame corresponding to provided time
+
+  uint32_t mEventROFrameMin = 0xffffffff; ///< lowest RO frame for processed events (w/o automatic noise ROFs)
+  uint32_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)
+
+  o2::itsmft::AlpideSimResponse* mAlpSimResp = nullptr; // simulated response
+
+  const o2::trk::GeometryTGeo* mGeometry = nullptr; ///< TRK geometry
+
+  std::vector<o2::itsmft::ChipDigitsContainer> mChips; ///< Array of chips digits containers
+  std::deque<std::unique_ptr<ExtraDig>> mExtraBuff;    ///< burrer (per roFrame) for extra digits
+
+  std::vector<o2::itsmft::Digit>* mDigits = nullptr;                       //! output digits
+  std::vector<o2::itsmft::ROFRecord>* mROFRecords = nullptr;               //! output ROF records
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mMCLabels = nullptr; //! output labels
+
+  const o2::itsmft::NoiseMap* mDeadChanMap = nullptr;
+
+  ClassDef(Digitizer, 1);
+};
+} // namespace o2::trk
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DPLDigitizerParam.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DPLDigitizerParam.cxx
new file mode 100644
index 0000000000000..a13f2e58bd3a4
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DPLDigitizerParam.cxx
@@ -0,0 +1,23 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKSimulation/DPLDigitizerParam.h"
+
+namespace o2
+{
+namespace trk
+{
+// this makes sure that the constructor of the parameters is statically called
+// so that these params are part of the parameter database
+static auto& sDigitizerParamITS = o2::trk::DPLDigitizerParam<o2::detectors::DetID::TRK>::Instance();
+static auto& sDigitizerParamMFT = o2::trk::DPLDigitizerParam<o2::detectors::DetID::FT3>::Instance();
+} // namespace trk
+} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
new file mode 100644
index 0000000000000..21e6e629ec418
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -0,0 +1,467 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Digitizer.cxx
+
+#include "DataFormatsITSMFT/Digit.h"
+// #include "ITSMFTBase/SegmentationAlpide.h"
+#include "TRKSimulation/DPLDigitizerParam.h"
+#include "TRKSimulation/Digitizer.h"
+// #include "MathUtils/Cartesian.h"
+// #include "SimulationDataFormat/MCTruthContainer.h"
+// #include "DetectorsRaw/HBFUtils.h"
+
+// #include <TRandom.h>
+// #include <climits>
+// #include <vector>
+// #include <numeric>
+#include <fairlogger/Logger.h> // for LOG
+
+using o2::itsmft::Digit;
+using o2::itsmft::Hit;
+// using Segmentation = o2::itsmft::SegmentationAlpide;
+
+using namespace o2::trk;
+// using namespace o2::base;
+
+//_______________________________________________________________________
+void Digitizer::init()
+{
+  // mNumberOfChips = mGeometry->getNumberOfChips();
+  // mChips.resize(mNumberOfChips);
+  // for (int i = mNumberOfChips; i--;) {
+  //   mChips[i].setChipIndex(i);
+  // if (mNoiseMap) {
+  //   mChips[i].setNoiseMap(mNoiseMap);
+  // }
+  // if (mDeadChanMap) {
+  //   mChips[i].disable(mDeadChanMap->isFullChipMasked(i));
+  //   mChips[i].setDeadChanMap(mDeadChanMap);
+  // }
+  // }
+  // initializing for both collection tables
+  /*for (int i = 0; i < 2; i++) {
+    mAlpSimResp[i].initData(i);
+  }*/
+
+  // importing the charge collection tables
+  // (initialized while building O2)
+  //   auto file = TFile::Open(mResponseFile.data());
+  //   if (!file) {
+  //     LOG(fatal) << "Cannot open response file " << mResponseFile;
+  //   }
+  /*std::string response = "response";
+  for (int i=0; i<2; i++) {
+    response.append(std::to_string(i));
+    mAlpSimResp[i] = *(o2::itsmft::AlpideSimResponse*)file->Get(response.data());
+  }*/
+  //   mAlpSimResp[0] = *(o2::itsmft::AlpideSimResponse*)file->Get("response0");
+  //   mAlpSimResp[1] = *(o2::itsmft::AlpideSimResponse*)file->Get("response1");
+
+  // importing the parameters from DPLDigitizerParam.h
+  auto& dOptTRK = DPLDigitizerParam<o2::detectors::DetID::TRK>::Instance();
+
+  LOGP(info, "TRK Digitizer is initalised.");
+}
+
+// auto Digitizer::getChipResponse(int chipID)
+// {
+//   if (mNumberOfChips < 10000) { // in MFT
+//     return mAlpSimRespMFT;
+//   }
+
+//   if (chipID < 432) { // in ITS Inner Barrel
+//     return mAlpSimRespIB;
+//   } else { // in ITS Outter Barrel
+//     return mAlpSimRespOB;
+//   }
+// }
+
+//_______________________________________________________________________
+void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
+{
+  // digitize single event, the time must have been set beforehand
+
+  // LOG(info) << "Digitizing " << mGeometry->getName() << " hits of entry " << evID << " from source "
+  //           << srcID << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
+  //           << " cont.mode: " << isContinuous()
+  //           << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
+
+  // // is there something to flush ?
+  // if (mNewROFrame > mROFrameMin) {
+  //   fillOutputContainer(mNewROFrame - 1); // flush out all frame preceding the new one
+  // }
+
+  // int nHits = hits->size();
+  // std::vector<int> hitIdx(nHits);
+  // std::iota(std::begin(hitIdx), std::end(hitIdx), 0);
+  // // sort hits to improve memory access
+  // std::sort(hitIdx.begin(), hitIdx.end(),
+  //           [hits](auto lhs, auto rhs) {
+  //             return (*hits)[lhs].GetDetectorID() < (*hits)[rhs].GetDetectorID();
+  //           });
+  // for (int i : hitIdx) {
+  //   processHit((*hits)[i], mROFrameMax, evID, srcID);
+  // }
+  // // in the triggered mode store digits after every MC event
+  // // TODO: in the real triggered mode this will not be needed, this is actually for the
+  // // single event processing only
+  // if (!mParams.isContinuous()) {
+  //   fillOutputContainer(mROFrameMax);
+  // }
+}
+
+//_______________________________________________________________________
+void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
+{
+  // // assign event time in ns
+  // mEventTime = irt;
+  // if (!mParams.isContinuous()) {
+  //   mROFrameMin = 0; // in triggered mode reset the frame counters
+  //   mROFrameMax = 0;
+  // }
+  // // RO frame corresponding to provided time
+  // mCollisionTimeWrtROF = mEventTime.timeInBCNS; // in triggered mode the ROF starts at BC (is there a delay?)
+  // if (mParams.isContinuous()) {
+  //   auto nbc = mEventTime.differenceInBC(mIRFirstSampledTF);
+  //   if (mCollisionTimeWrtROF < 0 && nbc > 0) {
+  //     nbc--;
+  //   }
+
+  //   // we might get interactions to digitize from before
+  //   // the first sampled IR
+  //   if (nbc < 0) {
+  //     mNewROFrame = 0;
+  //     // this event is before the first RO
+  //     mIsBeforeFirstRO = true;
+  //   } else {
+  //     mNewROFrame = nbc / mParams.getROFrameLengthInBC();
+  //     mIsBeforeFirstRO = false;
+  //   }
+  //   LOG(info) << " NewROFrame " << mNewROFrame << " nbc " << nbc;
+
+  //   // in continuous mode depends on starts of periodic readout frame
+  //   mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC()) * o2::constants::lhc::LHCBunchSpacingNS;
+  // } else {
+  //   mNewROFrame = 0;
+  // }
+
+  // if (mNewROFrame < mROFrameMin) {
+  //   LOG(error) << "New ROFrame " << mNewROFrame << " (" << irt << ") precedes currently cashed " << mROFrameMin;
+  //   throw std::runtime_error("deduced ROFrame precedes already processed one");
+  // }
+
+  // if (mParams.isContinuous() && mROFrameMax < mNewROFrame) {
+  //   mROFrameMax = mNewROFrame - 1; // all frames up to this are finished
+  // }
+}
+
+//_______________________________________________________________________
+void Digitizer::fillOutputContainer(uint32_t frameLast)
+{
+  // // fill output with digits from min.cached up to requested frame, generating the noise beforehand
+  // if (frameLast > mROFrameMax) {
+  //   frameLast = mROFrameMax;
+  // }
+  // // make sure all buffers for extra digits are created up to the maxFrame
+  // getExtraDigBuffer(mROFrameMax);
+
+  // LOG(info) << "Filling " << mGeometry->getName() << " digits output for RO frames " << mROFrameMin << ":"
+  //           << frameLast;
+
+  // o2::itsmft::ROFRecord rcROF;
+
+  // // we have to write chips in RO increasing order, therefore have to loop over the frames here
+  // for (; mROFrameMin <= frameLast; mROFrameMin++) {
+  //   rcROF.setROFrame(mROFrameMin);
+  //   rcROF.setFirstEntry(mDigits->size()); // start of current ROF in digits
+
+  //   auto& extra = *(mExtraBuff.front().get());
+  //   for (auto& chip : mChips) {
+  //     if (chip.isDisabled()) {
+  //       continue;
+  //     }
+  //     chip.addNoise(mROFrameMin, mROFrameMin, &mParams);
+  //     auto& buffer = chip.getPreDigits();
+  //     if (buffer.empty()) {
+  //       continue;
+  //     }
+  //     auto itBeg = buffer.begin();
+  //     auto iter = itBeg;
+  //     ULong64_t maxKey = chip.getOrderingKey(mROFrameMin + 1, 0, 0) - 1; // fetch digits with key below that
+  //     for (; iter != buffer.end(); ++iter) {
+  //       if (iter->first > maxKey) {
+  //         break; // is the digit ROFrame from the key > the max requested frame
+  //       }
+  //       auto& preDig = iter->second; // preDigit
+  //       if (preDig.charge >= mParams.getChargeThreshold()) {
+  //         int digID = mDigits->size();
+  //         mDigits->emplace_back(chip.getChipIndex(), preDig.row, preDig.col, preDig.charge);
+  //         mMCLabels->addElement(digID, preDig.labelRef.label);
+  //         auto& nextRef = preDig.labelRef; // extra contributors are in extra array
+  //         while (nextRef.next >= 0) {
+  //           nextRef = extra[nextRef.next];
+  //           mMCLabels->addElement(digID, nextRef.label);
+  //         }
+  //       }
+  //     }
+  //     buffer.erase(itBeg, iter);
+  //   }
+  //   // finalize ROF record
+  //   rcROF.setNEntries(mDigits->size() - rcROF.getFirstEntry()); // number of digits
+  //   if (isContinuous()) {
+  //     rcROF.getBCData().setFromLong(mIRFirstSampledTF.toLong() + mROFrameMin * mParams.getROFrameLengthInBC());
+  //   } else {
+  //     rcROF.getBCData() = mEventTime; // RSTODO do we need to add trigger delay?
+  //   }
+  //   if (mROFRecords) {
+  //     mROFRecords->push_back(rcROF);
+  //   }
+  //   extra.clear(); // clear container for extra digits of the mROFrameMin ROFrame
+  //   // and move it as a new slot in the end
+  //   mExtraBuff.emplace_back(mExtraBuff.front().release());
+  //   mExtraBuff.pop_front();
+  // }
+}
+
+//_______________________________________________________________________
+void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID)
+{
+  // // convert single hit to digits
+  // int chipID = hit.GetDetectorID();
+  // auto& chip = mChips[chipID];
+  // if (chip.isDisabled()) {
+  //   LOG(debug) << "skip disabled chip " << chipID;
+  //   return;
+  // }
+  // float timeInROF = hit.GetTime() * sec2ns;
+  // if (timeInROF > 20e3) {
+  //   const int maxWarn = 10;
+  //   static int warnNo = 0;
+  //   if (warnNo < maxWarn) {
+  //     LOG(warning) << "Ignoring hit with time_in_event = " << timeInROF << " ns"
+  //                  << ((++warnNo < maxWarn) ? "" : " (suppressing further warnings)");
+  //   }
+  //   return;
+  // }
+  // if (isContinuous()) {
+  //   timeInROF += mCollisionTimeWrtROF;
+  // }
+  // if (mIsBeforeFirstRO && timeInROF < 0) {
+  //   // disregard this hit because it comes from an event before readout starts and it does not effect this RO
+  //   return;
+  // }
+
+  // // calculate RO Frame for this hit
+  // if (timeInROF < 0) {
+  //   timeInROF = 0.;
+  // }
+  // float tTot = mParams.getSignalShape().getMaxDuration();
+  // // frame of the hit signal start wrt event ROFrame
+  // int roFrameRel = int(timeInROF * mParams.getROFrameLengthInv());
+  // // frame of the hit signal end  wrt event ROFrame: in the triggered mode we read just 1 frame
+  // uint32_t roFrameRelMax = mParams.isContinuous() ? (timeInROF + tTot) * mParams.getROFrameLengthInv() : roFrameRel;
+  // int nFrames = roFrameRelMax + 1 - roFrameRel;
+  // uint32_t roFrameMax = mNewROFrame + roFrameRelMax;
+  // if (roFrameMax > maxFr) {
+  //   maxFr = roFrameMax; // if signal extends beyond current maxFrame, increase the latter
+  // }
+
+  // // here we start stepping in the depth of the sensor to generate charge diffusion
+  // float nStepsInv = mParams.getNSimStepsInv();
+  // int nSteps = mParams.getNSimSteps();
+  // const auto& matrix = mGeometry->getMatrixL2G(hit.GetDetectorID());
+  // math_utils::Vector3D<float> xyzLocS(matrix ^ (hit.GetPosStart())); // start position in sensor frame
+  // math_utils::Vector3D<float> xyzLocE(matrix ^ (hit.GetPos()));      // end position in sensor frame
+
+  // math_utils::Vector3D<float> step(xyzLocE);
+  // step -= xyzLocS;
+  // step *= nStepsInv; // position increment at each step
+  // // the electrons will injected in the middle of each step
+  // math_utils::Vector3D<float> stepH(step * 0.5);
+  // xyzLocS += stepH;
+  // xyzLocE -= stepH;
+
+  // int rowS = -1, colS = -1, rowE = -1, colE = -1, nSkip = 0;
+  // // get entrance pixel row and col
+  // while (!Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
+  //   if (++nSkip >= nSteps) {
+  //     return; // did not enter to sensitive matrix
+  //   }
+  //   xyzLocS += step;
+  // }
+  // // get exit pixel row and col
+  // while (!Segmentation::localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
+  //   if (++nSkip >= nSteps) {
+  //     return; // did not enter to sensitive matrix
+  //   }
+  //   xyzLocE -= step;
+  // }
+  // // estimate the limiting min/max row and col where the non-0 response is possible
+  // if (rowS > rowE) {
+  //   std::swap(rowS, rowE);
+  // }
+  // if (colS > colE) {
+  //   std::swap(colS, colE);
+  // }
+  // rowS -= AlpideRespSimMat::NPix / 2;
+  // rowE += AlpideRespSimMat::NPix / 2;
+  // if (rowS < 0) {
+  //   rowS = 0;
+  // }
+  // if (rowE >= Segmentation::NRows) {
+  //   rowE = Segmentation::NRows - 1;
+  // }
+  // colS -= AlpideRespSimMat::NPix / 2;
+  // colE += AlpideRespSimMat::NPix / 2;
+  // if (colS < 0) {
+  //   colS = 0;
+  // }
+  // if (colE >= Segmentation::NCols) {
+  //   colE = Segmentation::NCols - 1;
+  // }
+  // int rowSpan = rowE - rowS + 1, colSpan = colE - colS + 1; // size of plaquet where some response is expected
+
+  // float respMatrix[rowSpan][colSpan]; // response accumulated here
+  // std::fill(&respMatrix[0][0], &respMatrix[0][0] + rowSpan * colSpan, 0.f);
+
+  // float nElectrons = hit.GetEnergyLoss() * mParams.getEnergyToNElectrons(); // total number of deposited electrons
+  // nElectrons *= nStepsInv;                                                  // N electrons injected per step
+  // if (nSkip) {
+  //   nSteps -= nSkip;
+  // }
+  // //
+  // int rowPrev = -1, colPrev = -1, row, col;
+  // float cRowPix = 0.f, cColPix = 0.f; // local coordinated of the current pixel center
+
+  // const o2::itsmft::AlpideSimResponse* resp = getChipResponse(chipID);
+
+  // // take into account that the AlpideSimResponse depth defintion has different min/max boundaries
+  // // although the max should coincide with the surface of the epitaxial layer, which in the chip
+  // // local coordinates has Y = +SensorLayerThickness/2
+
+  // xyzLocS.SetY(xyzLocS.Y() + resp->getDepthMax() - Segmentation::SensorLayerThickness / 2.);
+
+  // // collect charge in every pixel which might be affected by the hit
+  // for (int iStep = nSteps; iStep--;) {
+  //   // Get the pixel ID
+  //   Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
+  //   if (row != rowPrev || col != colPrev) { // update pixel and coordinates of its center
+  //     if (!Segmentation::detectorToLocal(row, col, cRowPix, cColPix)) {
+  //       continue; // should not happen
+  //     }
+  //     rowPrev = row;
+  //     colPrev = col;
+  //   }
+  //   bool flipCol, flipRow;
+  //   // note that response needs coordinates along column row (locX) (locZ) then depth (locY)
+  //   auto rspmat = resp->getResponse(xyzLocS.X() - cRowPix, xyzLocS.Z() - cColPix, xyzLocS.Y(), flipRow, flipCol);
+
+  //   xyzLocS += step;
+  //   if (!rspmat) {
+  //     continue;
+  //   }
+
+  //   for (int irow = AlpideRespSimMat::NPix; irow--;) {
+  //     int rowDest = row + irow - AlpideRespSimMat::NPix / 2 - rowS; // destination row in the respMatrix
+  //     if (rowDest < 0 || rowDest >= rowSpan) {
+  //       continue;
+  //     }
+  //     for (int icol = AlpideRespSimMat::NPix; icol--;) {
+  //       int colDest = col + icol - AlpideRespSimMat::NPix / 2 - colS; // destination column in the respMatrix
+  //       if (colDest < 0 || colDest >= colSpan) {
+  //         continue;
+  //       }
+  //       respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, flipRow, flipCol);
+  //     }
+  //   }
+  // }
+
+  // // fire the pixels assuming Poisson(n_response_electrons)
+  // o2::MCCompLabel lbl(hit.GetTrackID(), evID, srcID, false);
+  // auto roFrameAbs = mNewROFrame + roFrameRel;
+  // for (int irow = rowSpan; irow--;) {
+  //   uint16_t rowIS = irow + rowS;
+  //   for (int icol = colSpan; icol--;) {
+  //     float nEleResp = respMatrix[irow][icol];
+  //     if (!nEleResp) {
+  //       continue;
+  //     }
+  //     int nEle = gRandom->Poisson(nElectrons * nEleResp); // total charge in given pixel
+  //     // ignore charge which have no chance to fire the pixel
+  //     if (nEle < mParams.getMinChargeToAccount()) {
+  //       continue;
+  //     }
+  //     uint16_t colIS = icol + colS;
+  //     if (mNoiseMap && mNoiseMap->isNoisy(chipID, rowIS, colIS)) {
+  //       continue;
+  //     }
+  //     if (mDeadChanMap && mDeadChanMap->isNoisy(chipID, rowIS, colIS)) {
+  //       continue;
+  //     }
+  //     //
+  //     registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl);
+  //   }
+  // }
+}
+
+//________________________________________________________________________________
+void Digitizer::registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+                               uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl)
+{
+  // Register digits for given pixel, accounting for the possible signal contribution to
+  // multiple ROFrame. The signal starts at time tInROF wrt the start of provided roFrame
+  // In every ROFrame we check the collected signal during strobe
+
+  // float tStrobe = mParams.getStrobeDelay() - tInROF; // strobe start wrt signal start
+  // for (int i = 0; i < nROF; i++) {
+  //   uint32_t roFr = roFrame + i;
+  //   int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength());
+  //   tStrobe += mParams.getROFrameLength(); // for the next ROF
+
+  //   // discard too small contributions, they have no chance to produce a digit
+  //   if (nEleROF < mParams.getMinChargeToAccount()) {
+  //     continue;
+  //   }
+  //   if (roFr > mEventROFrameMax) {
+  //     mEventROFrameMax = roFr;
+  //   }
+  //   if (roFr < mEventROFrameMin) {
+  //     mEventROFrameMin = roFr;
+  //   }
+  //   auto key = chip.getOrderingKey(roFr, row, col);
+  //   PreDigit* pd = chip.findDigit(key);
+  //   if (!pd) {
+  //     chip.addDigit(key, roFr, row, col, nEleROF, lbl);
+  //   } else { // there is already a digit at this slot, account as PreDigitExtra contribution
+  //     pd->charge += nEleROF;
+  //     if (pd->labelRef.label == lbl) { // don't store the same label twice
+  //       continue;
+  //     }
+  //     ExtraDig* extra = getExtraDigBuffer(roFr);
+  //     int& nxt = pd->labelRef.next;
+  //     bool skip = false;
+  //     while (nxt >= 0) {
+  //       if ((*extra)[nxt].label == lbl) { // don't store the same label twice
+  //         skip = true;
+  //         break;
+  //       }
+  //       nxt = (*extra)[nxt].next;
+  //     }
+  //     if (skip) {
+  //       continue;
+  //     }
+  //     // new predigit will be added in the end of the chain
+  //     nxt = extra->size();
+  //     extra->emplace_back(lbl);
+  //   }
+  // }
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
index b82d8879e7dad..876810b5bef9d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
@@ -22,5 +22,11 @@
 #pragma link C++ class o2::trk::TRKServices + ;
 #pragma link C++ class o2::trk::Detector + ;
 #pragma link C++ class o2::base::DetImpl < o2::trk::Detector> + ;
+#pragma link C++ class o2::trk::Digitizer + ;
+
+// #pragma link C++ class o2::itsmft::DPLDigitizerParam < o2::detectors::DetID::ITS> + ;
+// #pragma link C++ class o2::itsmft::DPLDigitizerParam < o2::detectors::DetID::ITS> + ;
+// #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::DPLDigitizerParam < o2::detectors::DetID::TRK>> + ;
+// #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::DPLDigitizerParam < o2::detectors::DetID::FT3>> + ;
 
 #endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
new file mode 100644
index 0000000000000..c9f4099017717
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
@@ -0,0 +1,32 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(TRKWorkflow
+               SOURCES src/DigitReaderSpec.cxx
+                       src/DigitWriterSpec.cxx
+                    #    src/RecoWorkflow.cxx
+                    #    src/ClusterWriterWorkflow.cxx
+                    #    src/ClustererSpec.cxx
+                    #    src/ClusterWriterSpec.cxx
+                    #    src/TrackerSpec.cxx
+                    #    src/TrackWriterSpec.cxx
+                    #    src/TrackReaderSpec.cxx
+                    #    src/VertexReaderSpec.cxx
+               PUBLIC_LINK_LIBRARIES O2::Framework
+                                     O2::SimConfig
+                                     O2::DataFormatsITSMFT
+                                     O2::SimulationDataFormat
+                                     O2::DPLUtils)
+
+# o2_add_executable(reco-workflow
+#                   SOURCES src/trk-reco-workflow.cxx
+#                   COMPONENT_NAME alice3-trk
+#                   PUBLIC_LINK_LIBRARIES O2::TRKWorkflow)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitReaderSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitReaderSpec.h
new file mode 100644
index 0000000000000..2a0acd792f4a9
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitReaderSpec.h
@@ -0,0 +1,87 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRK_DIGITREADER
+#define O2_TRK_DIGITREADER
+
+#include "TFile.h"
+#include "TTree.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "DataFormatsITSMFT/GBTCalibData.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/Task.h"
+#include "Headers/DataHeader.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+
+using namespace o2::framework;
+
+namespace o2
+{
+namespace trk
+{
+
+class DigitReader : public Task
+{
+ public:
+  DigitReader() = delete;
+  DigitReader(o2::detectors::DetID id, bool useMC, bool useCalib);
+  ~DigitReader() override = default;
+  void init(InitContext& ic) final;
+  void run(ProcessingContext& pc) final;
+
+ protected:
+  void connectTree(const std::string& filename);
+
+  std::vector<o2::itsmft::Digit> mDigits, *mDigitsPtr = &mDigits;
+  std::vector<o2::itsmft::GBTCalibData> mCalib, *mCalibPtr = &mCalib;
+  std::vector<o2::itsmft::ROFRecord> mDigROFRec, *mDigROFRecPtr = &mDigROFRec;
+  std::vector<o2::itsmft::MC2ROFRecord> mDigMC2ROFs, *mDigMC2ROFsPtr = &mDigMC2ROFs;
+
+  o2::header::DataOrigin mOrigin = o2::header::gDataOriginInvalid;
+
+  std::unique_ptr<TFile> mFile;
+  std::unique_ptr<TTree> mTree;
+
+  bool mUseMC = true;    // use MC truth
+  bool mUseCalib = true; // send calib data
+
+  std::string mDetName = "";
+  std::string mDetNameLC = "";
+  std::string mFileName = "";
+  std::string mDigTreeName = "o2sim";
+  std::string mDigitBranchName = "Digit";
+  std::string mDigROFBranchName = "DigitROF";
+  std::string mCalibBranchName = "Calib";
+
+  std::string mDigtMCTruthBranchName = "DigitMCTruth";
+  std::string mDigtMC2ROFBranchName = "DigitMC2ROF";
+};
+
+class TRKDigitReader : public DigitReader
+{
+ public:
+  TRKDigitReader(bool useMC = true, bool useCalib = false)
+    : DigitReader(o2::detectors::DetID::TRK, useMC, useCalib)
+  {
+    mOrigin = o2::header::gDataOriginTRK;
+  }
+};
+
+/// create a processor spec
+/// read ITS/MFT Digit data from a root file
+framework::DataProcessorSpec getTRKDigitReaderSpec(bool useMC = true, bool useCalib = false, std::string defname = "trkdigits.root");
+
+} // namespace trk
+} // namespace o2
+
+#endif /* O2_TRK_DigitREADER */
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitWriterSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitWriterSpec.h
new file mode 100644
index 0000000000000..9c37d4318bb0f
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitWriterSpec.h
@@ -0,0 +1,26 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef STEER_TRKDIGITWRITER_H_
+#define STEER_TRKDIGITWRITER_H_
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2
+{
+namespace trk
+{
+
+o2::framework::DataProcessorSpec getTRKDigitWriterSpec(bool mctruth = true, bool dec = false, bool calib = false);
+} // namespace trk
+} // end namespace o2
+
+#endif /* STEER_TRKDIGITWRITER_H_ */
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitReaderSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitReaderSpec.cxx
new file mode 100644
index 0000000000000..09bb1f12a48e4
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitReaderSpec.cxx
@@ -0,0 +1,139 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <vector>
+
+#include "TTree.h"
+
+#include "Framework/ControlService.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/Logger.h"
+#include "TRKWorkflow/DigitReaderSpec.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/IOMCTruthContainerView.h"
+#include <cassert>
+
+using namespace o2::framework;
+using namespace o2::itsmft;
+
+namespace o2
+{
+namespace trk
+{
+
+DigitReader::DigitReader(o2::detectors::DetID id, bool useMC, bool useCalib)
+{
+  assert(id == o2::detectors::DetID::TRK);
+  mDetNameLC = mDetName = id.getName();
+  mDigTreeName = "o2sim";
+
+  mDigitBranchName = mDetName + mDigitBranchName;
+  mDigROFBranchName = mDetName + mDigROFBranchName;
+  mCalibBranchName = mDetName + mCalibBranchName;
+
+  mDigtMCTruthBranchName = mDetName + mDigtMCTruthBranchName;
+  mDigtMC2ROFBranchName = mDetName + mDigtMC2ROFBranchName;
+
+  mUseMC = useMC;
+  mUseCalib = useCalib;
+  std::transform(mDetNameLC.begin(), mDetNameLC.end(), mDetNameLC.begin(), ::tolower);
+}
+
+void DigitReader::init(InitContext& ic)
+{
+  mFileName = ic.options().get<std::string>((mDetNameLC + "-digit-infile").c_str());
+  connectTree(mFileName);
+}
+
+void DigitReader::run(ProcessingContext& pc)
+{
+  auto ent = mTree->GetReadEntry() + 1;
+  assert(ent < mTree->GetEntries()); // this should not happen
+
+  o2::dataformats::IOMCTruthContainerView* plabels = nullptr;
+  if (mUseMC) {
+    mTree->SetBranchAddress(mDigtMCTruthBranchName.c_str(), &plabels);
+  }
+  mTree->GetEntry(ent);
+  LOG(info) << mDetName << "DigitReader pushes " << mDigROFRec.size() << " ROFRecords, "
+            << mDigits.size() << " digits at entry " << ent;
+
+  // This is a very ugly way of providing DataDescription, which anyway does not need to contain detector name.
+  // To be fixed once the names-definition class is ready
+  pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, mDigROFRec);
+  pc.outputs().snapshot(Output{mOrigin, "DIGITS", 0}, mDigits);
+  if (mUseCalib) {
+    pc.outputs().snapshot(Output{mOrigin, "GBTCALIB", 0}, mCalib);
+  }
+
+  if (mUseMC) {
+    auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", 0});
+    plabels->copyandflatten(sharedlabels);
+    delete plabels;
+    pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, mDigMC2ROFs);
+  }
+
+  if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
+    pc.services().get<ControlService>().endOfStream();
+    pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+  }
+}
+
+void DigitReader::connectTree(const std::string& filename)
+{
+  mTree.reset(nullptr); // in case it was already loaded
+  mFile.reset(TFile::Open(filename.c_str()));
+  assert(mFile && !mFile->IsZombie());
+  mTree.reset((TTree*)mFile->Get(mDigTreeName.c_str()));
+  assert(mTree);
+
+  mTree->SetBranchAddress(mDigROFBranchName.c_str(), &mDigROFRecPtr);
+  mTree->SetBranchAddress(mDigitBranchName.c_str(), &mDigitsPtr);
+  if (mUseCalib) {
+    if (!mTree->GetBranch(mCalibBranchName.c_str())) {
+      throw std::runtime_error("GBT calibration data requested but not found in the tree");
+    }
+    mTree->SetBranchAddress(mCalibBranchName.c_str(), &mCalibPtr);
+  }
+  if (mUseMC) {
+    if (!mTree->GetBranch(mDigtMC2ROFBranchName.c_str()) || !mTree->GetBranch(mDigtMCTruthBranchName.c_str())) {
+      throw std::runtime_error("MC data requested but not found in the tree");
+    }
+    mTree->SetBranchAddress(mDigtMC2ROFBranchName.c_str(), &mDigMC2ROFsPtr);
+  }
+  LOG(info) << "Loaded tree from " << filename << " with " << mTree->GetEntries() << " entries";
+}
+
+DataProcessorSpec getTRKDigitReaderSpec(bool useMC, bool useCalib, std::string defname)
+{
+  std::vector<OutputSpec> outputSpec;
+  outputSpec.emplace_back("TRK", "DIGITS", 0, Lifetime::Timeframe);
+  outputSpec.emplace_back("TRK", "DIGITSROF", 0, Lifetime::Timeframe);
+  if (useCalib) {
+    outputSpec.emplace_back("TRK", "GBTCALIB", 0, Lifetime::Timeframe);
+  }
+  if (useMC) {
+    outputSpec.emplace_back("TRK", "DIGITSMCTR", 0, Lifetime::Timeframe);
+    outputSpec.emplace_back("TRK", "DIGITSMC2ROF", 0, Lifetime::Timeframe);
+  }
+
+  return DataProcessorSpec{
+    "trk-digit-reader",
+    Inputs{},
+    outputSpec,
+    AlgorithmSpec{adaptFromTask<TRKDigitReader>(useMC, useCalib)},
+    Options{
+      {"trk-digit-infile", VariantType::String, defname, {"Name of the input digit file"}}}};
+}
+
+} // namespace trk
+} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitWriterSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitWriterSpec.cxx
new file mode 100644
index 0000000000000..2a743551adddb
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitWriterSpec.cxx
@@ -0,0 +1,110 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @brief  Processor spec for a ROOT file writer for ITSMFT digits
+
+#include "TRKWorkflow/DigitWriterSpec.h"
+#include "DPLUtils/MakeRootTreeWriterSpec.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "DataFormatsITSMFT/GBTCalibData.h"
+#include "Headers/DataHeader.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/IOMCTruthContainerView.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include <vector>
+#include <string>
+#include <algorithm>
+
+using namespace o2::framework;
+using SubSpecificationType = o2::framework::DataAllocator::SubSpecificationType;
+
+namespace o2
+{
+namespace trk
+{
+
+template <typename T>
+using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
+using MCCont = o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>;
+
+/// create the processor spec
+/// describing a processor receiving digits for ITS/MFT and writing them to file
+DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib, o2::header::DataOrigin detOrig, o2::detectors::DetID detId)
+{
+  std::string detStr = o2::detectors::DetID::getName(detId);
+  std::string detStrL = dec ? "o2_" : ""; // for decoded digits prepend by o2
+  detStrL += detStr;
+  std::transform(detStrL.begin(), detStrL.end(), detStrL.begin(), ::tolower);
+  auto logger = [](std::vector<o2::itsmft::Digit> const& inDigits) {
+    LOG(info) << "RECEIVED DIGITS SIZE " << inDigits.size();
+  };
+
+  // the callback to be set as hook for custom action when the writer is closed
+  auto finishWriting = [](TFile* outputfile, TTree* outputtree) {
+    const auto* brArr = outputtree->GetListOfBranches();
+    int64_t nent = 0;
+    for (const auto* brc : *brArr) {
+      int64_t n = ((const TBranch*)brc)->GetEntries();
+      if (nent && (nent != n)) {
+        LOG(error) << "Branches have different number of entries";
+      }
+      nent = n;
+    }
+    outputtree->SetEntries(nent);
+    outputtree->Write("", TObject::kOverwrite);
+    outputfile->Close();
+  };
+
+  // handler for labels
+  // This is necessary since we can't store the original label buffer in a ROOT entry -- as is -- if it exceeds a certain size.
+  // We therefore convert it to a special split class.
+  auto fillLabels = [](TBranch& branch, std::vector<char> const& labelbuffer, DataRef const& /*ref*/) {
+    o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
+    LOG(info) << "WRITING " << labels.getNElements() << " LABELS ";
+
+    o2::dataformats::IOMCTruthContainerView outputcontainer;
+    auto ptr = &outputcontainer;
+    auto br = framework::RootTreeWriter::remapBranch(branch, &ptr);
+    outputcontainer.adopt(labelbuffer);
+    br->Fill();
+    br->ResetAddress();
+  };
+
+  return MakeRootTreeWriterSpec((detStr + "DigitWriter" + (dec ? "_dec" : "")).c_str(),
+                                (detStrL + "digits.root").c_str(),
+                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Digits tree"},
+                                MakeRootTreeWriterSpec::CustomClose(finishWriting),
+                                // in case of labels we first read them as std::vector<char> and process them correctly in the fillLabels hook
+                                BranchDefinition<std::vector<char>>{InputSpec{"digitsMCTR", detOrig, "DIGITSMCTR", 0},
+                                                                    (detStr + "DigitMCTruth").c_str(),
+                                                                    (mctruth ? 1 : 0), fillLabels},
+                                BranchDefinition<std::vector<itsmft::MC2ROFRecord>>{InputSpec{"digitsMC2ROF", detOrig, "DIGITSMC2ROF", 0},
+                                                                                    (detStr + "DigitMC2ROF").c_str(),
+                                                                                    (mctruth ? 1 : 0)},
+                                BranchDefinition<std::vector<itsmft::Digit>>{InputSpec{"digits", detOrig, "DIGITS", 0},
+                                                                             (detStr + "Digit").c_str(),
+                                                                             logger},
+                                BranchDefinition<std::vector<itsmft::GBTCalibData>>{InputSpec{"calib", detOrig, "GBTCALIB", 0},
+                                                                                    (detStr + "Calib").c_str(),
+                                                                                    (calib ? 1 : 0)},
+                                BranchDefinition<std::vector<itsmft::ROFRecord>>{InputSpec{"digitsROF", detOrig, "DIGITSROF", 0},
+                                                                                 (detStr + "DigitROF").c_str()})();
+}
+
+DataProcessorSpec getTRKDigitWriterSpec(bool mctruth, bool dec, bool calib)
+{
+  return getDigitWriterSpec(mctruth, dec, calib, o2::header::gDataOriginTRK, o2::detectors::DetID::TRK);
+}
+
+} // end namespace trk
+} // end namespace o2
diff --git a/Steer/DigitizerWorkflow/CMakeLists.txt b/Steer/DigitizerWorkflow/CMakeLists.txt
index 1b839ba462b63..babc5fce4d864 100644
--- a/Steer/DigitizerWorkflow/CMakeLists.txt
+++ b/Steer/DigitizerWorkflow/CMakeLists.txt
@@ -29,6 +29,7 @@ o2_add_executable(digitizer-workflow
                           src/ZDCDigitizerSpec.cxx
                           src/TOFDigitizerSpec.cxx
                           $<$<BOOL:${ENABLE_UPGRADES}>:src/ITS3DigitizerSpec.cxx>
+                          $<$<BOOL:${ENABLE_UPGRADES}>:src/TRKDigitizerSpec.cxx>
                   PUBLIC_LINK_LIBRARIES O2::Framework
                                         O2::Steer
                                         O2::CommonConstants
@@ -67,7 +68,9 @@ o2_add_executable(digitizer-workflow
                                         O2::DetectorsRaw
                                         $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3Simulation>
                                         $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3Workflow>
-                                        $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3Align>)
+                                        $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3Align>
+                                        $<$<BOOL:${ENABLE_UPGRADES}>:O2::TRKSimulation>
+                                        $<$<BOOL:${ENABLE_UPGRADES}>:O2::TRKWorkflow>)
 
 
 o2_add_executable(mctruth-testworkflow
diff --git a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
index a30294a240fb0..75141425f7c49 100644
--- a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
+++ b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
@@ -44,6 +44,10 @@
 // for ITS3
 #include "ITS3DigitizerSpec.h"
 #include "ITS3Workflow/DigitWriterSpec.h"
+
+// for alice 3 TRK
+#include "TRKDigitizerSpec.h"
+#include "TRKWorkflow/DigitWriterSpec.h"
 #endif
 
 // for TOF
@@ -632,6 +636,15 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     // // connect ITS digit writer
     specs.emplace_back(o2::its3::getITS3DigitWriterSpec(mctruth));
   }
+
+  // the ALICE 3 TRK part
+  if (isEnabled(o2::detectors::DetID::TRK)) {
+    detList.emplace_back(o2::detectors::DetID::TRK);
+    // connect the ALICE 3 TRK digitization
+    specs.emplace_back(o2::trk::getTRKDigitizerSpec(fanoutsize++, mctruth));
+    // connect the ALICE 3 TRK digit writer
+    specs.emplace_back(o2::trk::getTRKDigitWriterSpec(mctruth));
+  }
 #endif
 
   // the MFT part
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
new file mode 100644
index 0000000000000..f35b53a58fae4
--- /dev/null
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
@@ -0,0 +1,303 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKDigitizerSpec.h"
+#include "Framework/ControlService.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/DataRefUtils.h"
+#include "Framework/Lifetime.h"
+#include "Framework/Task.h"
+#include "Steer/HitProcessingManager.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "DetectorsBase/BaseDPLDigitizer.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "DetectorsCommonDataFormats/SimTraits.h"
+#include "DataFormatsParameters/GRPObject.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "TRKSimulation/Digitizer.h"
+#include "TRKSimulation/DPLDigitizerParam.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/TRKBaseParam.h"
+
+#include <TChain.h>
+#include <TStopwatch.h>
+
+#include <string>
+
+using namespace o2::framework;
+using SubSpecificationType = o2::framework::DataAllocator::SubSpecificationType;
+
+namespace
+{
+std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mctruth)
+{
+  std::vector<OutputSpec> outputs;
+  outputs.emplace_back(detOrig, "DIGITS", 0, Lifetime::Timeframe);
+  outputs.emplace_back(detOrig, "DIGITSROF", 0, Lifetime::Timeframe);
+  if (mctruth) {
+    outputs.emplace_back(detOrig, "DIGITSMC2ROF", 0, Lifetime::Timeframe);
+    outputs.emplace_back(detOrig, "DIGITSMCTR", 0, Lifetime::Timeframe);
+  }
+  outputs.emplace_back(detOrig, "ROMode", 0, Lifetime::Timeframe);
+  return outputs;
+}
+} // namespace
+
+namespace o2::trk
+{
+using namespace o2::base;
+class TRKDPLDigitizerTask : BaseDPLDigitizer
+{
+ public:
+  using BaseDPLDigitizer::init;
+
+  TRKDPLDigitizerTask(bool mctruth = true) : BaseDPLDigitizer(InitServices::FIELD | InitServices::GEOM), mWithMCTruth(mctruth) {}
+
+  void initDigitizerTask(framework::InitContext& ic) override
+  {
+    mDisableQED = ic.options().get<bool>("disable-qed");
+  }
+
+  void run(framework::ProcessingContext& pc)
+  {
+    if (mFinished) {
+      return;
+    }
+    updateTimeDependentParams(pc);
+
+    // read collision context from input
+    auto context = pc.inputs().get<o2::steer::DigitizationContext*>("collisioncontext");
+    context->initSimChains(mID, mSimChains);
+    const bool withQED = context->isQEDProvided() && !mDisableQED;
+    auto& timesview = context->getEventRecords(withQED);
+    LOG(info) << "GOT " << timesview.size() << " COLLISION TIMES";
+    LOG(info) << "SIMCHAINS " << mSimChains.size();
+
+    // if there is nothing to do ... return
+    if (timesview.empty()) {
+      return;
+    }
+    TStopwatch timer;
+    timer.Start();
+    LOG(info) << " CALLING TRK DIGITIZATION ";
+
+    // mDigitizer.setDigits(&mDigits);
+    mDigitizer.setROFRecords(&mROFRecords);
+    mDigitizer.setMCLabels(&mLabels);
+
+    // digits are directly put into DPL owned resource
+    auto& digitsAccum = pc.outputs().make<std::vector<itsmft::Digit>>(Output{mOrigin, "DIGITS", 0});
+
+    auto accumulate = [this, &digitsAccum]() {
+      // accumulate result of single event processing, called after processing every event supplied
+      // AND after the final flushing via digitizer::fillOutputContainer
+      if (mDigits.empty()) {
+        return; // no digits were flushed, nothing to accumulate
+      }
+      auto ndigAcc = digitsAccum.size();
+      std::copy(mDigits.begin(), mDigits.end(), std::back_inserter(digitsAccum));
+
+      // fix ROFrecords references on ROF entries
+      auto nROFRecsOld = mROFRecordsAccum.size();
+
+      for (int i = 0; i < mROFRecords.size(); i++) {
+        auto& rof = mROFRecords[i];
+        rof.setFirstEntry(ndigAcc + rof.getFirstEntry());
+        rof.print();
+
+        if (mFixMC2ROF < mMC2ROFRecordsAccum.size()) { // fix ROFRecord entry in MC2ROF records
+          for (int m2rid = mFixMC2ROF; m2rid < mMC2ROFRecordsAccum.size(); m2rid++) {
+            // need to register the ROFRecors entry for MC event starting from this entry
+            auto& mc2rof = mMC2ROFRecordsAccum[m2rid];
+            if (rof.getROFrame() == mc2rof.minROF) {
+              mFixMC2ROF++;
+              mc2rof.rofRecordID = nROFRecsOld + i;
+              mc2rof.print();
+            }
+          }
+        }
+      }
+
+      std::copy(mROFRecords.begin(), mROFRecords.end(), std::back_inserter(mROFRecordsAccum));
+      if (mWithMCTruth) {
+        mLabelsAccum.mergeAtBack(mLabels);
+      }
+      LOG(info) << "Added " << mDigits.size() << " digits ";
+      // clean containers from already accumulated stuff
+      mLabels.clear();
+      mDigits.clear();
+      mROFRecords.clear();
+    }; // and accumulate lambda
+
+    auto& eventParts = context->getEventParts(withQED);
+    // loop over all composite collisions given from context (aka loop over all the interaction records)
+    const int bcShift = mDigitizer.getParams().getROFrameBiasInBC();
+    // loop over all composite collisions given from context (aka loop over all the interaction records)
+    for (size_t collID = 0; collID < timesview.size(); ++collID) {
+      auto irt = timesview[collID];
+      if (irt.toLong() < bcShift) { // due to the ROF misalignment the collision would go to negative ROF ID, discard
+        continue;
+      }
+      irt -= bcShift; // account for the ROF start shift
+
+      mDigitizer.setEventTime(irt);
+      mDigitizer.resetEventROFrames(); // to estimate min/max ROF for this collID
+      // for each collision, loop over the constituents event and source IDs
+      // (background signal merging is basically taking place here)
+      for (auto& part : eventParts[collID]) {
+
+        // get the hits for this event and this source
+        mHits.clear();
+        context->retrieveHits(mSimChains, o2::detectors::SimTraits::DETECTORBRANCHNAMES[mID][0].c_str(), part.sourceID, part.entryID, &mHits);
+
+        if (!mHits.empty()) {
+          LOG(debug) << "For collision " << collID << " eventID " << part.entryID
+                     << " found " << mHits.size() << " hits ";
+          mDigitizer.process(&mHits, part.entryID, part.sourceID); // call actual digitization procedure
+        }
+      }
+      mMC2ROFRecordsAccum.emplace_back(collID, -1, mDigitizer.getEventROFrameMin(), mDigitizer.getEventROFrameMax());
+      accumulate();
+    }
+    mDigitizer.fillOutputContainer();
+    accumulate();
+
+    // here we have all digits and labels and we can send them to consumer (aka snapshot it onto output)
+
+    pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, mROFRecordsAccum);
+    if (mWithMCTruth) {
+      pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, mMC2ROFRecordsAccum);
+      auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", 0});
+      mLabelsAccum.flatten_to(sharedlabels);
+      // free space of existing label containers
+      mLabels.clear_andfreememory();
+      mLabelsAccum.clear_andfreememory();
+    }
+    LOG(info) << mID.getName() << ": Sending ROMode= " << mROMode << " to GRPUpdater";
+    pc.outputs().snapshot(Output{mOrigin, "ROMode", 0}, mROMode);
+
+    timer.Stop();
+    LOG(info) << "Digitization took " << timer.CpuTime() << "s";
+
+    // we should be only called once; tell DPL that this process is ready to exit
+    pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+
+    mFinished = true;
+  }
+
+  void updateTimeDependentParams(ProcessingContext& pc)
+  {
+    static bool initOnce{false};
+    if (!initOnce) {
+      initOnce = true;
+      auto& digipar = mDigitizer.getParams();
+
+      // configure digitizer
+      o2::trk::GeometryTGeo* geom = o2::trk::GeometryTGeo::Instance();
+      geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G)); // make sure L2G matrices are loaded
+      mDigitizer.setGeometry(geom);
+
+      const auto& dopt = o2::trk::DPLDigitizerParam<o2::detectors::DetID::TRK>::Instance();
+      pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("ITS_alppar");
+      const auto& aopt = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
+      digipar.setContinuous(dopt.continuous);
+      digipar.setROFrameBiasInBC(aopt.roFrameBiasInBC);
+      if (dopt.continuous) {
+        auto frameNS = aopt.roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingNS;
+        digipar.setROFrameLengthInBC(aopt.roFrameLengthInBC);
+        digipar.setROFrameLength(frameNS);                                                                       // RO frame in ns
+        digipar.setStrobeDelay(aopt.strobeDelay);                                                                // Strobe delay wrt beginning of the RO frame, in ns
+        digipar.setStrobeLength(aopt.strobeLengthCont > 0 ? aopt.strobeLengthCont : frameNS - aopt.strobeDelay); // Strobe length in ns
+      } else {
+        digipar.setROFrameLength(aopt.roFrameLengthTrig); // RO frame in ns
+        digipar.setStrobeDelay(aopt.strobeDelay);         // Strobe delay wrt beginning of the RO frame, in ns
+        digipar.setStrobeLength(aopt.strobeLengthTrig);   // Strobe length in ns
+      }
+      // parameters of signal time response: flat-top duration, max rise time and q @ which rise time is 0
+      digipar.getSignalShape().setParameters(dopt.strobeFlatTop, dopt.strobeMaxRiseTime, dopt.strobeQRiseTime0);
+      digipar.setChargeThreshold(dopt.chargeThreshold); // charge threshold in electrons
+      digipar.setNoisePerPixel(dopt.noisePerPixel);     // noise level
+      digipar.setTimeOffset(dopt.timeOffset);
+      digipar.setNSimSteps(dopt.nSimSteps);
+
+      mROMode = digipar.isContinuous() ? o2::parameters::GRPObject::CONTINUOUS : o2::parameters::GRPObject::PRESENT;
+      LOG(info) << mID.getName() << " simulated in "
+                << ((mROMode == o2::parameters::GRPObject::CONTINUOUS) ? "CONTINUOUS" : "TRIGGERED")
+                << " RO mode";
+
+      // if (oTRKParams::Instance().useDeadChannelMap) {
+      //   pc.inputs().get<o2::itsmft::NoiseMap*>("TRK_dead"); // trigger final ccdb update
+      // }
+
+      // init digitizer
+      mDigitizer.init();
+    }
+    // Other time-dependent parameters can be added below
+  }
+
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+  {
+    if (matcher == ConcreteDataMatcher(detectors::DetID::ITS, "ALPIDEPARAM", 0)) {
+      LOG(info) << mID.getName() << " Alpide param updated";
+      const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
+      par.printKeyValues();
+      return;
+    }
+    // if (matcher == ConcreteDataMatcher(mOrigin, "DEADMAP", 0)) {
+    //   LOG(info) << mID.getName() << " static dead map updated";
+    //   mDigitizer.setDeadChannelsMap((o2::itsmft::NoiseMap*)obj);
+    //   return;
+    // }
+  }
+
+ private:
+  bool mWithMCTruth{true};
+  bool mFinished{false};
+  bool mDisableQED{false};
+  const o2::detectors::DetID mID{o2::detectors::DetID::TRK};
+  const o2::header::DataOrigin mOrigin{o2::header::gDataOriginTRK};
+  o2::trk::Digitizer mDigitizer{};
+  std::vector<o2::itsmft::Digit> mDigits{};
+  std::vector<o2::itsmft::ROFRecord> mROFRecords{};
+  std::vector<o2::itsmft::ROFRecord> mROFRecordsAccum{};
+  std::vector<o2::itsmft::Hit> mHits{};
+  std::vector<o2::itsmft::Hit>* mHitsP{&mHits};
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabels{};
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabelsAccum{};
+  std::vector<o2::itsmft::MC2ROFRecord> mMC2ROFRecordsAccum{};
+  std::vector<TChain*> mSimChains{};
+
+  int mFixMC2ROF = 0;                                                             // 1st entry in mc2rofRecordsAccum to be fixed for ROFRecordID
+  o2::parameters::GRPObject::ROMode mROMode = o2::parameters::GRPObject::PRESENT; // readout mode
+};
+
+DataProcessorSpec getTRKDigitizerSpec(int channel, bool mctruth)
+{
+  std::string detStr = o2::detectors::DetID::getName(o2::detectors::DetID::TRK);
+  auto detOrig = o2::header::gDataOriginTRK;
+  std::vector<InputSpec> inputs;
+  inputs.emplace_back("collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe);
+  inputs.emplace_back("ITS_alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+  // if (oTRKParams::Instance().useDeadChannelMap) {
+  //   inputs.emplace_back("TRK_dead", "TRK", "DEADMAP", 0, Lifetime::Condition, ccdbParamSpec("TRK/Calib/DeadMap"));
+  // }
+
+  return DataProcessorSpec{detStr + "Digitizer",
+                           inputs, makeOutChannels(detOrig, mctruth),
+                           AlgorithmSpec{adaptFromTask<TRKDPLDigitizerTask>(mctruth)},
+                           Options{{"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
+}
+
+} // namespace o2::trk
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.h b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.h
new file mode 100644
index 0000000000000..5a1a59c3b9f5e
--- /dev/null
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.h
@@ -0,0 +1,24 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef STEER_DIGITIZERWORKFLOW_TRKDIGITIZER_H_
+#define STEER_DIGITIZERWORKFLOW_TRKDIGITIZER_H_
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2::trk
+{
+o2::framework::DataProcessorSpec getTRKDigitizerSpec(int channel, bool mctruth = true);
+}
+// namespace o2::trk
+// end namespace o2
+
+#endif

From 5fad059651ea1d743e8d338c7229b5b7d7af1f0a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 14 Mar 2025 16:21:22 +0100
Subject: [PATCH 0095/1764] Fix round-robin reading in
 DigitizationContext::retrieveHits

---
 .../include/SimulationDataFormat/DigitizationContext.h        | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/DigitizationContext.h b/DataFormats/simulation/include/SimulationDataFormat/DigitizationContext.h
index 5e1f5f66b3f65..b718b2d5eb804 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/DigitizationContext.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/DigitizationContext.h
@@ -218,6 +218,10 @@ inline void DigitizationContext::retrieveHits(std::vector<TChain*> const& chains
     return;
   }
   br->SetAddress(&hits);
+  auto maxEntries = br->GetEntries();
+  if (maxEntries) {
+    entryID %= maxEntries;
+  }
   br->GetEntry(entryID);
 }
 

From 433615988f7250854c926fbe98d79f51c9377c7f Mon Sep 17 00:00:00 2001
From: apalasciano <palascianoanto@gmail.com>
Date: Mon, 17 Feb 2025 11:51:21 +0100
Subject: [PATCH 0096/1764] Add DStar(2007)0 pdg code

---
 Common/Constants/include/CommonConstants/PhysicsConstants.h | 2 ++
 Common/Constants/include/CommonConstants/make_pdg_header.py | 1 +
 2 files changed, 3 insertions(+)

diff --git a/Common/Constants/include/CommonConstants/PhysicsConstants.h b/Common/Constants/include/CommonConstants/PhysicsConstants.h
index 6a8a791cffd22..c6fa3cddcdad5 100644
--- a/Common/Constants/include/CommonConstants/PhysicsConstants.h
+++ b/Common/Constants/include/CommonConstants/PhysicsConstants.h
@@ -52,6 +52,7 @@ enum Pdg {
   kDS1 = 10433,
   kDS2Star = 435,
   kDStar = 413,
+  kDStar0 = 423,
   kChiC1 = 20443,
   kJPsi = 443,
   kLambdaB0 = 5122,
@@ -101,6 +102,7 @@ constexpr double MassDSStar = 2.1122;
 constexpr double MassDS1 = 2.53511;
 constexpr double MassDS2Star = 2.5691;
 constexpr double MassDStar = 2.01026;
+constexpr double MassDStar0 = 2.00685;
 constexpr double MassChiC1 = 3.51067;
 constexpr double MassJPsi = 3.0969;
 constexpr double MassLambdaB0 = 5.6196;
diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index 5c1e4602a9fbb..e4f92e6e8b62d 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -107,6 +107,7 @@ class Pdg(Enum):
     kDS1 = 10433
     kDS2Star = 435
     kDStar = 413
+    kDStar0 = 423
     kChiC1 = 20443
     kJPsi = 443
     kLambdaB0 = 5122

From ed0781538b248a920150cdf3afb5fe1d1ee41aa3 Mon Sep 17 00:00:00 2001
From: Andreas Molander <andreas.molander@cern.ch>
Date: Wed, 4 Sep 2024 15:58:37 +0300
Subject: [PATCH 0097/1764] FIT: add RecPoint reader and writer workflows for
 FV0 and FDD

The main purpose of the commit:
- Adding workflows for reading RecPoints for FV0 and FDD, these are needed for MC aQC

Secondary purposes that arose during development:
- ROOT macro for comparing two RecPoint files
- Workflows for writing RecPoints added for FT0, FV0 and FDD (i.e. simply standalone RecPoint writers, not related to reconstrucion)
- The two items above were needed to verify the new RecPoint reader workflows, namely by: reconstructing CTFs -> writing RecPoints to file -> Reading RecPoints from file -> Writing RecPoints to new file -> Comparing the two files
- Minor cosmetics (e.g. reordering of includes) and utility functions (print and == operator functions)
---
 DataFormats/Detectors/FIT/FDD/CMakeLists.txt  |   1 +
 .../FIT/FDD/include/DataFormatsFDD/RecPoint.h |   7 +-
 .../Detectors/FIT/FDD/src/RecPoint.cxx        |  33 ++++++
 .../FT0/include/DataFormatsFT0/RecPoints.h    |   6 +-
 .../Detectors/FIT/FT0/src/RecPoints.cxx       |  14 ++-
 .../FV0/include/DataFormatsFV0/RecPoints.h    |   4 +
 .../Detectors/FIT/FV0/src/RecPoints.cxx       |  19 ++-
 Detectors/FIT/FDD/workflow/CMakeLists.txt     |  10 ++
 .../include/FDDWorkflow/RecPointReaderSpec.h  |   4 +-
 .../FDD/workflow/src/RecPointReaderSpec.cxx   |   8 +-
 .../src/recpoints-reader-workflow.cxx         |  57 +++++++++
 .../src/recpoints-writer-workflow.cxx         |  47 ++++++++
 Detectors/FIT/FT0/workflow/CMakeLists.txt     |   5 +
 .../src/recpoints-reader-workflow.cxx         |  37 +++---
 .../src/recpoints-writer-workflow.cxx         |  47 ++++++++
 Detectors/FIT/FV0/workflow/CMakeLists.txt     |  10 ++
 .../src/recpoints-reader-workflow.cxx         |  58 +++++++++
 .../src/recpoints-writer-workflow.cxx         |  47 ++++++++
 Detectors/FIT/macros/CMakeLists.txt           |   5 +
 Detectors/FIT/macros/compareRecPoints.C       | 110 ++++++++++++++++++
 20 files changed, 493 insertions(+), 36 deletions(-)
 create mode 100644 DataFormats/Detectors/FIT/FDD/src/RecPoint.cxx
 create mode 100644 Detectors/FIT/FDD/workflow/src/recpoints-reader-workflow.cxx
 create mode 100644 Detectors/FIT/FDD/workflow/src/recpoints-writer-workflow.cxx
 create mode 100644 Detectors/FIT/FT0/workflow/src/recpoints-writer-workflow.cxx
 create mode 100644 Detectors/FIT/FV0/workflow/src/recpoints-reader-workflow.cxx
 create mode 100644 Detectors/FIT/FV0/workflow/src/recpoints-writer-workflow.cxx
 create mode 100644 Detectors/FIT/macros/compareRecPoints.C

diff --git a/DataFormats/Detectors/FIT/FDD/CMakeLists.txt b/DataFormats/Detectors/FIT/FDD/CMakeLists.txt
index 6cf2deb3f988e..140ba1165bff8 100644
--- a/DataFormats/Detectors/FIT/FDD/CMakeLists.txt
+++ b/DataFormats/Detectors/FIT/FDD/CMakeLists.txt
@@ -11,6 +11,7 @@
 
 o2_add_library(DataFormatsFDD
   SOURCES src/RawEventData.cxx
+          src/RecPoint.cxx
           src/CTF.cxx
           src/LookUpTable.cxx
   PUBLIC_LINK_LIBRARIES O2::FDDBase
diff --git a/DataFormats/Detectors/FIT/FDD/include/DataFormatsFDD/RecPoint.h b/DataFormats/Detectors/FIT/FDD/include/DataFormatsFDD/RecPoint.h
index 6615dc322180b..f784d99145728 100644
--- a/DataFormats/Detectors/FIT/FDD/include/DataFormatsFDD/RecPoint.h
+++ b/DataFormats/Detectors/FIT/FDD/include/DataFormatsFDD/RecPoint.h
@@ -9,8 +9,9 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file RecPoint.h
+/// \file  RecPoint.h
 /// \brief Definition of the FDD RecPoint class
+
 #ifndef ALICEO2_FDD_RECPOINT_H
 #define ALICEO2_FDD_RECPOINT_H
 
@@ -42,6 +43,7 @@ struct ChannelDataFloat {
   }
 
   void print() const;
+  bool operator==(const ChannelDataFloat&) const = default;
 
   ClassDefNV(ChannelDataFloat, 1);
 };
@@ -80,6 +82,9 @@ class RecPoint
   int getFirstEntry() const { return mRef.getFirstEntry(); }
   int getEntriesInCurrentBC() const { return mRef.getEntries(); }
 
+  void print() const;
+  bool operator==(const RecPoint&) const = default;
+
  private:
   o2::dataformats::RangeReference<int, int> mRef;
   o2::InteractionRecord mIntRecord;
diff --git a/DataFormats/Detectors/FIT/FDD/src/RecPoint.cxx b/DataFormats/Detectors/FIT/FDD/src/RecPoint.cxx
new file mode 100644
index 0000000000000..854a09088a2f4
--- /dev/null
+++ b/DataFormats/Detectors/FIT/FDD/src/RecPoint.cxx
@@ -0,0 +1,33 @@
+// Copyright 2019-2024 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   RecPoint.cxx
+/// \brief  Implementation of the FDD RecPoint class
+/// \author Andreas Molander andreas.molander@cern.ch
+
+#include "DataFormatsFDD/RecPoint.h"
+#include "Framework/Logger.h"
+
+using namespace o2::fdd;
+
+void ChannelDataFloat::print() const
+{
+  LOG(info) << "ChannelDataFloat data:";
+  LOG(info) << "Channel ID: " << mPMNumber << ", Time (ps): " << mTime << ", Charge (ADC): " << mChargeADC << ", QTC chain: " << adcId;
+}
+
+void RecPoint::print() const
+{
+  LOG(info) << "RecPoint data:";
+  LOG(info) << "Collision times: A: " << getCollisionTimeA() << ", C: " << getCollisionTimeC();
+  LOG(info) << "Ref first: " << mRef.getFirstEntry() << ", Ref entries: " << mRef.getEntries();
+  LOG(info) << "Triggers: " << mTriggers.print();
+}
diff --git a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h
index 1178cc20a4da0..d688e076489b5 100644
--- a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h
+++ b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h
@@ -47,6 +47,7 @@ struct ChannelDataFloat {
   }
 
   void print() const;
+  bool operator==(const ChannelDataFloat&) const = default;
 
   ClassDefNV(ChannelDataFloat, 1);
 };
@@ -74,8 +75,6 @@ class RecPoints
   }
   ~RecPoints() = default;
 
-  void print() const;
-
   short getCollisionTime(int side) const { return mCollisionTime[side]; }
   short getCollisionTimeMean() const { return getCollisionTime(TimeMean); }
   short getCollisionTimeA() const { return getCollisionTime(TimeA); }
@@ -96,6 +95,9 @@ class RecPoints
   gsl::span<const ChannelDataFloat> getBunchChannelData(const gsl::span<const ChannelDataFloat> tfdata) const;
   short static constexpr sDummyCollissionTime = 32767;
 
+  void print() const;
+  bool operator==(const RecPoints&) const = default;
+
  private:
   std::array<short, 4> mCollisionTime = {sDummyCollissionTime,
                                          sDummyCollissionTime,
diff --git a/DataFormats/Detectors/FIT/FT0/src/RecPoints.cxx b/DataFormats/Detectors/FIT/FT0/src/RecPoints.cxx
index f580d0dd1ea8c..afd244f977f71 100644
--- a/DataFormats/Detectors/FIT/FT0/src/RecPoints.cxx
+++ b/DataFormats/Detectors/FIT/FT0/src/RecPoints.cxx
@@ -21,14 +21,22 @@
 
 using namespace o2::ft0;
 
+void ChannelDataFloat::print() const
+{
+  printf("  ChID% d | CFDtime=%f | QTCampl=%f QTC chain %d\n", ChId, CFDTime, QTCAmpl, ChainQTC);
+}
+
 gsl::span<const ChannelDataFloat> RecPoints::getBunchChannelData(const gsl::span<const ChannelDataFloat> tfdata) const
 {
   // extract the span of channel data for this bunch from the whole TF data
   return ref.getEntries() ? gsl::span<const ChannelDataFloat>(tfdata).subspan(ref.getFirstEntry(), ref.getEntries()) : gsl::span<const ChannelDataFloat>();
 }
 
-void ChannelDataFloat::print() const
+void RecPoints::print() const
 {
-
-  printf("  ChID% d | CFDtime=%f | QTCampl=%f QTC chain %d\n", ChId, CFDTime, QTCAmpl, ChainQTC);
+  LOG(info) << "RecPoint data:";
+  LOG(info) << "Collision times: mean: " << getCollisionTimeMean() << ", A: " << getCollisionTimeA() << ", C: " << getCollisionTimeC();
+  LOG(info) << "Vertex: " << getVertex();
+  LOG(info) << "Ref first: " << ref.getFirstEntry() << ", Ref entries: " << ref.getEntries();
+  LOG(info) << "Triggers: " << mTriggers.print();
 }
diff --git a/DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/RecPoints.h b/DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/RecPoints.h
index d7ee2e67613fc..b3527fdd049d2 100644
--- a/DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/RecPoints.h
+++ b/DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/RecPoints.h
@@ -42,6 +42,7 @@ struct ChannelDataFloat {
   }
 
   void print() const;
+  bool operator==(const ChannelDataFloat&) const = default;
 
   ClassDefNV(ChannelDataFloat, 1);
 };
@@ -77,6 +78,9 @@ class RecPoints
   gsl::span<const ChannelDataFloat> getBunchChannelData(const gsl::span<const ChannelDataFloat> tfdata) const;
   short static constexpr sDummyCollissionTime = 32767;
 
+  void print() const;
+  bool operator==(const RecPoints&) const = default;
+
  private:
   o2::dataformats::RangeReference<int, int> mRef;
   o2::InteractionRecord mIntRecord;
diff --git a/DataFormats/Detectors/FIT/FV0/src/RecPoints.cxx b/DataFormats/Detectors/FIT/FV0/src/RecPoints.cxx
index 18f2effc281e8..ef1554acf5419 100644
--- a/DataFormats/Detectors/FIT/FV0/src/RecPoints.cxx
+++ b/DataFormats/Detectors/FIT/FV0/src/RecPoints.cxx
@@ -14,13 +14,22 @@
 
 using namespace o2::fv0;
 
-gsl::span<const ChannelDataFloat> RecPoints::getBunchChannelData(const gsl::span<const ChannelDataFloat> tfdata) const
+void ChannelDataFloat::print() const
 {
-  // extract the span of channel data for this bunch from the whole TF data
-  return mRef.getEntries() ? gsl::span<const ChannelDataFloat>(tfdata).subspan(mRef.getFirstEntry(), mRef.getEntries()) : gsl::span<const ChannelDataFloat>();
+  printf("  Channel=%d | time=%f | charge=%f | adcId=%d\n", channel, time, charge, adcId);
 }
 
-void ChannelDataFloat::print() const
+void RecPoints::print() const
 {
-  printf("  Channel=%d | time=%f | charge=%f | adcId=%d\n", channel, time, charge, adcId);
+  printf("RecPoint data:");
+  printf("Collision times: first: %f, global mean: %f, selected mean: %f\n", getCollisionFirstTime(), getCollisionGlobalMeanTime(), getCollisionSelectedMeanTime());
+  printf("Ref first: %d, Ref entries: %d\n", mRef.getFirstEntry(), mRef.getEntries());
+  printf("Triggers: ");
+  mTriggers.print();
+}
+
+gsl::span<const ChannelDataFloat> RecPoints::getBunchChannelData(const gsl::span<const ChannelDataFloat> tfdata) const
+{
+  // extract the span of channel data for this bunch from the whole TF data
+  return mRef.getEntries() ? gsl::span<const ChannelDataFloat>(tfdata).subspan(mRef.getFirstEntry(), mRef.getEntries()) : gsl::span<const ChannelDataFloat>();
 }
diff --git a/Detectors/FIT/FDD/workflow/CMakeLists.txt b/Detectors/FIT/FDD/workflow/CMakeLists.txt
index 4f7c7f44bc31b..a4bcc6f0de6fb 100644
--- a/Detectors/FIT/FDD/workflow/CMakeLists.txt
+++ b/Detectors/FIT/FDD/workflow/CMakeLists.txt
@@ -52,6 +52,16 @@ o2_add_executable(flp-dpl-workflow
                   PUBLIC_LINK_LIBRARIES O2::FDDWorkflow O2::FDDRaw O2::FITWorkflow
                   TARGETVARNAME fddflpexe)
 
+o2_add_executable(recpoints-reader-workflow
+                  SOURCES src/recpoints-reader-workflow.cxx
+                  COMPONENT_NAME fdd
+                  PUBLIC_LINK_LIBRARIES O2::FDDWorkflow)
+
+o2_add_executable(recpoints-writer-workflow
+                  SOURCES src/recpoints-writer-workflow.cxx
+                  COMPONENT_NAME fdd
+                  PUBLIC_LINK_LIBRARIES O2::FDDWorkflow)
+
 o2_add_executable(integrate-cluster-workflow
                   SOURCES src/cluster-integrator.cxx
                   COMPONENT_NAME fdd
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RecPointReaderSpec.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RecPointReaderSpec.h
index 500883d5badfa..6c3c9694f3e1c 100644
--- a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RecPointReaderSpec.h
+++ b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RecPointReaderSpec.h
@@ -31,7 +31,7 @@ namespace fdd
 class RecPointReader : public Task
 {
  public:
-  RecPointReader(bool useMC = true);
+  RecPointReader(bool useMC = false);
   ~RecPointReader() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -42,7 +42,7 @@ class RecPointReader : public Task
   std::unique_ptr<TFile> mFile;
   std::unique_ptr<TTree> mTree;
 
-  bool mUseMC = true; // use MC truth
+  bool mUseMC = false; // use MC truth
   o2::header::DataOrigin mOrigin = o2::header::gDataOriginFDD;
 
   std::vector<o2::fdd::RecPoint>* mRecPoints = nullptr;
diff --git a/Detectors/FIT/FDD/workflow/src/RecPointReaderSpec.cxx b/Detectors/FIT/FDD/workflow/src/RecPointReaderSpec.cxx
index 9b612c31d28e6..3c4812c75b251 100644
--- a/Detectors/FIT/FDD/workflow/src/RecPointReaderSpec.cxx
+++ b/Detectors/FIT/FDD/workflow/src/RecPointReaderSpec.cxx
@@ -11,16 +11,14 @@
 
 /// @file  RecPointReaderSpec.cxx
 
-#include <vector>
-
-#include "TTree.h"
-
-#include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
+#include "Framework/ControlService.h"
 #include "Framework/Logger.h"
 #include "FDDWorkflow/RecPointReaderSpec.h"
 #include "CommonUtils/NameConf.h"
 
+#include <vector>
+
 using namespace o2::framework;
 using namespace o2::fdd;
 
diff --git a/Detectors/FIT/FDD/workflow/src/recpoints-reader-workflow.cxx b/Detectors/FIT/FDD/workflow/src/recpoints-reader-workflow.cxx
new file mode 100644
index 0000000000000..fcef4cc46901f
--- /dev/null
+++ b/Detectors/FIT/FDD/workflow/src/recpoints-reader-workflow.cxx
@@ -0,0 +1,57 @@
+// Copyright 2019-2024 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  recpoints-reader-workflow.cxx
+/// \brief FDD RecPoints reader workflow
+///
+/// \author Andreas Molander andreas.molander@cern.ch
+
+#include "FDDWorkflow/RecPointReaderSpec.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "Framework/CallbacksPolicy.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/Variant.h"
+
+#include <vector>
+
+using namespace o2::framework;
+
+void customize(std::vector<CallbacksPolicy>& policies)
+{
+  o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::vector<ConfigParamSpec> options{
+    {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+  o2::raw::HBFUtilsInitializer::addConfigOption(options);
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(const ConfigContext& ctx)
+{
+  o2::conf::ConfigurableParam::updateFromString(ctx.options().get<std::string>("configKeyValues"));
+  bool disableMC = ctx.options().get<bool>("disable-mc");
+  WorkflowSpec specs;
+  DataProcessorSpec producer = o2::fdd::getFDDRecPointReaderSpec(!disableMC);
+  specs.push_back(producer);
+
+  // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
+  o2::raw::HBFUtilsInitializer hbfIni(ctx, specs);
+  return specs;
+}
diff --git a/Detectors/FIT/FDD/workflow/src/recpoints-writer-workflow.cxx b/Detectors/FIT/FDD/workflow/src/recpoints-writer-workflow.cxx
new file mode 100644
index 0000000000000..e53ccd14c30ab
--- /dev/null
+++ b/Detectors/FIT/FDD/workflow/src/recpoints-writer-workflow.cxx
@@ -0,0 +1,47 @@
+// Copyright 2019-2024 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  recpoints-writer-workflow.cxx
+/// \brief FDD RecPoints writer workflow
+///
+/// \author Andreas Molander andreas.molander@cern.ch
+
+#include "FDDWorkflow/RecPointWriterSpec.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/Variant.h"
+
+#include <vector>
+
+using namespace o2::framework;
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::vector<ConfigParamSpec> options{
+    {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+  workflowOptions.insert(workflowOptions.end(), options.begin(), options.end());
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(const ConfigContext& ctx)
+{
+  o2::conf::ConfigurableParam::updateFromString(ctx.options().get<std::string>("configKeyValues"));
+  bool disableMC = ctx.options().get<bool>("disable-mc");
+
+  WorkflowSpec specs;
+  DataProcessorSpec producer = o2::fdd::getFDDRecPointWriterSpec(!disableMC);
+  specs.push_back(producer);
+  return specs;
+}
diff --git a/Detectors/FIT/FT0/workflow/CMakeLists.txt b/Detectors/FIT/FT0/workflow/CMakeLists.txt
index 2dbbbae41e261..123a29293e2fb 100644
--- a/Detectors/FIT/FT0/workflow/CMakeLists.txt
+++ b/Detectors/FIT/FT0/workflow/CMakeLists.txt
@@ -98,6 +98,11 @@ o2_add_executable(recpoints-reader-workflow
                   COMPONENT_NAME ft0
                   PUBLIC_LINK_LIBRARIES O2::FT0Workflow)
 
+o2_add_executable(recpoints-writer-workflow
+                  SOURCES src/recpoints-writer-workflow.cxx
+                  COMPONENT_NAME ft0
+                  PUBLIC_LINK_LIBRARIES O2::FT0Workflow)
+
 o2_add_executable(integrate-cluster-workflow
                   SOURCES src/cluster-integrator.cxx
                   COMPONENT_NAME ft0
diff --git a/Detectors/FIT/FT0/workflow/src/recpoints-reader-workflow.cxx b/Detectors/FIT/FT0/workflow/src/recpoints-reader-workflow.cxx
index d323b4135d7ea..b1d824e10687e 100644
--- a/Detectors/FIT/FT0/workflow/src/recpoints-reader-workflow.cxx
+++ b/Detectors/FIT/FT0/workflow/src/recpoints-reader-workflow.cxx
@@ -9,23 +9,24 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file recpoints-reader-workflow.cxx
-/// \brief Implementation of FT0 digits reader
+/// \file  recpoints-reader-workflow.cxx
+/// \brief FT0 RecPoints reader workflow
 ///
-/// \author ruben.shahoyan@cern.ch
+/// \author ruben.shahoyan@cern.ch, Andreas Molander andreas.molander@cern.ch
 
-#include "Framework/CallbackService.h"
-#include "Framework/ControlService.h"
-#include "Framework/CallbacksPolicy.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/Task.h"
-#include "FT0Workflow/RecPointReaderSpec.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "Framework/CallbacksPolicy.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/Variant.h"
+
+#include "FT0Workflow/RecPointReaderSpec.h"
+
+#include <vector>
 
 using namespace o2::framework;
 
-void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
+void customize(std::vector<CallbacksPolicy>& policies)
 {
   o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
 }
@@ -33,12 +34,9 @@ void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
 // we need to add workflow options before including Framework/runDataProcessing
 void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
-  // option allowing to set parameters
-
-  std::vector<o2::framework::ConfigParamSpec> options{
-    {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}}};
-  std::string keyvaluehelp("Semicolon separated key=value strings");
-  options.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {keyvaluehelp}});
+  std::vector<ConfigParamSpec> options{
+    {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -47,10 +45,13 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 
 WorkflowSpec defineDataProcessing(const ConfigContext& ctx)
 {
-  WorkflowSpec specs;
   o2::conf::ConfigurableParam::updateFromString(ctx.options().get<std::string>("configKeyValues"));
-  DataProcessorSpec producer = o2::ft0::getRecPointReaderSpec(ctx.options().get<bool>("disable-mc"));
+  bool disableMC = ctx.options().get<bool>("disable-mc");
+
+  WorkflowSpec specs;
+  DataProcessorSpec producer = o2::ft0::getRecPointReaderSpec(!disableMC);
   specs.push_back(producer);
+
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(ctx, specs);
   return specs;
diff --git a/Detectors/FIT/FT0/workflow/src/recpoints-writer-workflow.cxx b/Detectors/FIT/FT0/workflow/src/recpoints-writer-workflow.cxx
new file mode 100644
index 0000000000000..c8baef76b5ccd
--- /dev/null
+++ b/Detectors/FIT/FT0/workflow/src/recpoints-writer-workflow.cxx
@@ -0,0 +1,47 @@
+// Copyright 2019-2024 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  recpoints-writer-workflow.cxx
+/// \brief FT0 RecPoints writer workflow
+///
+/// \author Andreas Molander andreas.molander@cern.ch
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/Variant.h"
+
+#include "FT0Workflow/RecPointWriterSpec.h"
+
+#include <vector>
+
+using namespace o2::framework;
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::vector<ConfigParamSpec> options{
+    {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+  workflowOptions.insert(workflowOptions.end(), options.begin(), options.end());
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(const ConfigContext& ctx)
+{
+  o2::conf::ConfigurableParam::updateFromString(ctx.options().get<std::string>("configKeyValues"));
+  bool disableMC = ctx.options().get<bool>("disable-mc");
+
+  WorkflowSpec specs;
+  DataProcessorSpec producer = o2::ft0::getRecPointWriterSpec(!disableMC);
+  specs.push_back(producer);
+  return specs;
+}
diff --git a/Detectors/FIT/FV0/workflow/CMakeLists.txt b/Detectors/FIT/FV0/workflow/CMakeLists.txt
index eec745d5fdf1e..a304adc61b5fd 100644
--- a/Detectors/FIT/FV0/workflow/CMakeLists.txt
+++ b/Detectors/FIT/FV0/workflow/CMakeLists.txt
@@ -53,6 +53,16 @@ o2_add_executable(flp-dpl-workflow
                   PUBLIC_LINK_LIBRARIES O2::FV0Workflow O2::FITWorkflow O2::FV0Raw
                   TARGETVARNAME fv0flpexe)
 
+o2_add_executable(recpoints-reader-workflow
+                  SOURCES src/recpoints-reader-workflow.cxx
+                  COMPONENT_NAME fv0
+                  PUBLIC_LINK_LIBRARIES O2::FV0Workflow)
+
+o2_add_executable(recpoints-writer-workflow
+                  SOURCES src/recpoints-writer-workflow.cxx
+                  COMPONENT_NAME fv0
+                  PUBLIC_LINK_LIBRARIES O2::FV0Workflow)
+
 o2_add_executable(integrate-cluster-workflow
                   SOURCES src/cluster-integrator.cxx
                   COMPONENT_NAME fv0
diff --git a/Detectors/FIT/FV0/workflow/src/recpoints-reader-workflow.cxx b/Detectors/FIT/FV0/workflow/src/recpoints-reader-workflow.cxx
new file mode 100644
index 0000000000000..ecbe89b8bbed3
--- /dev/null
+++ b/Detectors/FIT/FV0/workflow/src/recpoints-reader-workflow.cxx
@@ -0,0 +1,58 @@
+// Copyright 2019-2024 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  recpoints-reader-workflow.cxx
+/// \brief FV0 RecPoints reader workflow
+///
+/// \author Andreas Molander andreas.molander@cern.ch
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "Framework/CallbacksPolicy.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/Variant.h"
+
+#include "FV0Workflow/RecPointReaderSpec.h"
+
+#include <vector>
+
+using namespace o2::framework;
+
+void customize(std::vector<CallbacksPolicy>& policies)
+{
+  o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::vector<ConfigParamSpec> options{
+    {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+  o2::raw::HBFUtilsInitializer::addConfigOption(options);
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(const ConfigContext& ctx)
+{
+  o2::conf::ConfigurableParam::updateFromString(ctx.options().get<std::string>("configKeyValues"));
+  bool disableMC = ctx.options().get<bool>("disable-mc");
+
+  WorkflowSpec specs;
+  DataProcessorSpec producer = o2::fv0::getRecPointReaderSpec(!disableMC);
+  specs.push_back(producer);
+
+  // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
+  o2::raw::HBFUtilsInitializer hbfIni(ctx, specs);
+  return specs;
+}
diff --git a/Detectors/FIT/FV0/workflow/src/recpoints-writer-workflow.cxx b/Detectors/FIT/FV0/workflow/src/recpoints-writer-workflow.cxx
new file mode 100644
index 0000000000000..0fd3bd3bef2e8
--- /dev/null
+++ b/Detectors/FIT/FV0/workflow/src/recpoints-writer-workflow.cxx
@@ -0,0 +1,47 @@
+// Copyright 2019-2024 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  recpoints-writer-workflow.cxx
+/// \brief FV0 RecPoints writer workflow
+///
+/// \author Andreas Molander andreas.molander@cern.ch
+
+#include "FV0Workflow/RecPointWriterSpec.h"
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/Variant.h"
+
+#include <vector>
+
+using namespace o2::framework;
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::vector<ConfigParamSpec> options{
+    {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+  workflowOptions.insert(workflowOptions.end(), options.begin(), options.end());
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(const ConfigContext& ctx)
+{
+  o2::conf::ConfigurableParam::updateFromString(ctx.options().get<std::string>("configKeyValues"));
+  bool disableMC = ctx.options().get<bool>("disable-mc");
+
+  WorkflowSpec specs;
+  DataProcessorSpec producer = o2::fv0::getRecPointWriterSpec(!disableMC);
+  specs.push_back(producer);
+  return specs;
+}
diff --git a/Detectors/FIT/macros/CMakeLists.txt b/Detectors/FIT/macros/CMakeLists.txt
index 81f2cc05e0b25..e7debb4184325 100644
--- a/Detectors/FIT/macros/CMakeLists.txt
+++ b/Detectors/FIT/macros/CMakeLists.txt
@@ -40,5 +40,10 @@ o2_add_test_root_macro(readFITDCSdata.C
                                              O2::CCDB
                        LABELS fit)
 
+o2_add_test_root_macro(compareRecPoints.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsFT0
+                                             O2::DataFormatsFIT
+                       LABELS fit)
+
 o2_data_file(COPY readFITDCSdata.C DESTINATION Detectors/FIT/macros/)
 o2_data_file(COPY readFITDeadChannelMap.C DESTINATION Detectors/FIT/macros/)
\ No newline at end of file
diff --git a/Detectors/FIT/macros/compareRecPoints.C b/Detectors/FIT/macros/compareRecPoints.C
new file mode 100644
index 0000000000000..0ce077bc616ba
--- /dev/null
+++ b/Detectors/FIT/macros/compareRecPoints.C
@@ -0,0 +1,110 @@
+// Copyright 2019-2024 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file compareRecPoints.C
+/// \brief ROOT macro to compare two trees with RecPoints
+///
+/// \author Artur Furs artur.furs@cern.ch, Andreas Molander andreas.molander@cern.ch
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include "DataFormatsFT0/RecPoints.h"
+#include "DataFormatsFV0/RecPoints.h"
+#include "DataFormatsFDD/RecPoint.h"
+
+#include "TFile.h"
+#include "TTree.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+#include <iostream>
+#endif
+
+void compareRecPoints(std::string filename1, std::string filename2)
+{
+  std::unique_ptr<TFile> file1(TFile::Open(filename1.c_str(), "READ"));
+  TTree* tree1 = (TTree*)file1->Get("o2sim");
+
+  std::unique_ptr<TFile> file2(TFile::Open(filename2.c_str(), "READ"));
+  TTree* tree2 = (TTree*)file2->Get("o2sim");
+
+  if (tree1->GetEntries() != tree2->GetEntries()) {
+    std::cout << "Non equal number of entries in trees!" << std::endl;
+    return;
+  }
+
+  typedef typename o2::ft0::RecPoints RecPoint;
+  typedef typename o2::ft0::ChannelDataFloat ChannelDataFloat;
+
+  std::vector<RecPoint> vecRecPoints1;
+  std::vector<RecPoint>* ptrVecRecPoints1 = &vecRecPoints1;
+
+  std::vector<ChannelDataFloat> vecChannelDataFloat1;
+  std::vector<ChannelDataFloat>* ptrVecChannelDataFloat1 = &vecChannelDataFloat1;
+
+  tree1->SetBranchAddress("FT0Cluster", &ptrVecRecPoints1);
+  tree1->SetBranchAddress("FT0RecChData", &ptrVecChannelDataFloat1);
+
+  std::vector<RecPoint> vecRecPoints2;
+  std::vector<RecPoint>* ptrVecRecPoints2 = &vecRecPoints2;
+
+  std::vector<ChannelDataFloat> vecChannelDataFloat2;
+  std::vector<ChannelDataFloat>* ptrVecChannelDataFloat2 = &vecChannelDataFloat2;
+
+  tree2->SetBranchAddress("FT0Cluster", &ptrVecRecPoints2);
+  tree2->SetBranchAddress("FT0RecChData", &ptrVecChannelDataFloat2);
+
+  for (int iEntry = 0; iEntry < tree1->GetEntries(); iEntry++) {
+    tree1->GetEntry(iEntry);
+    tree2->GetEntry(iEntry);
+
+    if (vecRecPoints1 != vecRecPoints2) {
+      std::cout << "Non equal RecPoints vector!" << std::endl;
+
+      if (vecRecPoints1.size() == vecRecPoints2.size()) {
+        for (int iEvent = 0; iEvent < vecRecPoints1.size(); iEvent++) {
+          const auto& recPoint1 = vecRecPoints1[iEvent];
+          const auto& recPoint2 = vecRecPoints2[iEvent];
+
+          if (!(recPoint1 == recPoint2)) {
+            std::cout << "First RecPoint" << std::endl;
+            recPoint1.print();
+            std::cout << "Second RecPoint" << std::endl;
+            recPoint2.print();
+          }
+        }
+      } else {
+        std::cout << "Non equal number of RecPoints!" << std::endl;
+      }
+    }
+    if (vecChannelDataFloat1 != vecChannelDataFloat2) {
+      std::cout << "Non equal ChannelDataFloat vector!" << std::endl;
+
+      if (vecChannelDataFloat1.size() == vecChannelDataFloat2.size()) {
+        for (int iEvent = 0; iEvent < vecChannelDataFloat1.size(); iEvent++) {
+          const auto& channelDataFloat1 = vecChannelDataFloat1[iEvent];
+          const auto& channelDataFloat2 = vecChannelDataFloat2[iEvent];
+
+          if (!(channelDataFloat1 == channelDataFloat2)) {
+            std::cout << "First ChannelDataFloat" << std::endl;
+            channelDataFloat1.print();
+            std::cout << "Second ChannelDataFloat" << std::endl;
+            channelDataFloat2.print();
+          }
+        }
+      } else {
+        std::cout << "Non equal number of ChannelDataFloat!" << std::endl;
+      }
+    }
+  }
+
+  return;
+}
\ No newline at end of file

From 95d50444d9d733b58f8f7b4cc03c43bcefb64316 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Tue, 18 Mar 2025 17:04:26 +0100
Subject: [PATCH 0098/1764] Fix BC filling in per TF digi contexts

---
 DataFormats/simulation/src/DigitizationContext.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index e875cb61951a9..499a478bc5148 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -679,6 +679,7 @@ DigitizationContext DigitizationContext::extractSingleTimeframe(int timeframeid,
   }
   r.mSimPrefixes = mSimPrefixes;
   r.mMuBC = mMuBC;
+  r.mBCFilling = mBCFilling;
   try {
     auto tf_ranges = timeframeindices.at(timeframeid);
 

From dcb02ef906d422fcdaae4dff21e335f6e8bba914 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 18 Mar 2025 10:21:46 +0100
Subject: [PATCH 0099/1764] GPU Display: suppress compiler warning with
 sanitizers enabled

---
 GPU/GPUTracking/display/GPUDisplay.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index 73f65b6b24241..bb270cda23565 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -161,6 +161,7 @@ class GPUDisplay : public GPUDisplayInterface
   {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wformat-security"
+#pragma GCC diagnostic ignored "-Wformat-truncation"
     snprintf(mInfoText2, 1024, args...);
 #pragma GCC diagnostic pop
     GPUInfo("%s", mInfoText2);

From c903618bcbda071dbd6e1538276176d1197bc6fc Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 18 Mar 2025 10:22:09 +0100
Subject: [PATCH 0100/1764] GPU Standalone can compile with sanitizers also
 without debug build

---
 GPU/GPUTracking/Standalone/CMakeLists.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index b9620b9385c73..de245a71845c3 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -50,9 +50,6 @@ set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 if(GPUCA_BUILD_DEBUG)
   set(CMAKE_CXX_FLAGS "-O0 -ggdb")
-  if (GPUCA_BUILD_DEBUG_SANITIZE)
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-sanitize=vptr") #TODO: Check why this does not work with clang
-  endif()
   set(CMAKE_BUILD_TYPE DEBUG)
 else()
   set(CMAKE_CXX_FLAGS "-O3 -march=native -ggdb -minline-all-stringops -funroll-loops -fno-stack-protector")
@@ -67,6 +64,9 @@ else()
   set(CMAKE_BUILD_TYPE RELEASE)
   add_definitions(-DNDEBUG)
 endif()
+if (GPUCA_BUILD_DEBUG_SANITIZE)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-sanitize=vptr") #TODO: Check why this does not work with clang
+endif()
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wall -Wextra -Wshadow -Wno-unused-function -Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unknown-pragmas -Wno-write-strings")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -rdynamic -Wl,--no-undefined")
 

From 5b6c4855a4a38b1960186dd0d64ea3c72220ed3d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 18 Mar 2025 11:05:52 +0100
Subject: [PATCH 0101/1764] GPU: Disable clang warnings when using C variable
 length array extension in C++

---
 GPU/GPUTracking/Standalone/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index de245a71845c3..8fa8f0c2b68c9 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -67,7 +67,7 @@ endif()
 if (GPUCA_BUILD_DEBUG_SANITIZE)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-sanitize=vptr") #TODO: Check why this does not work with clang
 endif()
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wall -Wextra -Wshadow -Wno-unused-function -Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unknown-pragmas -Wno-write-strings")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wall -Wextra -Wshadow -Wno-unused-function -Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unknown-pragmas -Wno-write-strings -Wno-vla-cxx-extension")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -rdynamic -Wl,--no-undefined")
 
 # Find mandatory packages

From 7a68fc21493361c9f9acb79d6411f60d6d8b1d88 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 18 Mar 2025 11:20:26 +0100
Subject: [PATCH 0102/1764] GPU Standalone: Fix build using clang compiler with
 sanitizers

---
 GPU/GPUTracking/Standalone/CMakeLists.txt | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 8fa8f0c2b68c9..6e536727a0c67 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -65,7 +65,10 @@ else()
   add_definitions(-DNDEBUG)
 endif()
 if (GPUCA_BUILD_DEBUG_SANITIZE)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-sanitize=vptr") #TODO: Check why this does not work with clang
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address,undefined -fno-sanitize=vptr")
+  if(CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -shared-libasan")
+  endif()
 endif()
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wall -Wextra -Wshadow -Wno-unused-function -Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unknown-pragmas -Wno-write-strings -Wno-vla-cxx-extension")
 set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -rdynamic -Wl,--no-undefined")
@@ -247,6 +250,13 @@ if(GPUCA_CONFIG_ROOT)
 endif()
 target_link_libraries(standalone_support PUBLIC Microsoft.GSL::GSL TPCFastTransformation)
 
+if (GPUCA_BUILD_DEBUG_SANITIZE AND CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=libclang_rt.asan-x86_64.so OUTPUT_VARIABLE CLANG_ASAN_SO_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
+  get_filename_component(CLANG_ASAN_SO_PATH "${CLANG_ASAN_SO_PATH}" DIRECTORY)
+  get_filename_component(CLANG_ASAN_SO_PATH "${CLANG_ASAN_SO_PATH}" ABSOLUTE)
+  target_link_options(ca PRIVATE "-Wl,-rpath,${CLANG_ASAN_SO_PATH}")
+endif()
+
 # Installation
 install(TARGETS ca TPCFastTransformation standalone_support)
 install(FILES "cmake/makefile" DESTINATION "${CMAKE_INSTALL_PREFIX}")

From 1eebd48731f33ec692a7d866908abcb9b498a4f1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 18 Mar 2025 11:38:06 +0100
Subject: [PATCH 0103/1764] GPU: Suppress another clang warning

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index a4074282da30f..a8a83fdbd9203 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -112,7 +112,12 @@ inline void GPUReconstructionCPUBackend::runKernelBackendInternal<GPUMemClean16,
 template <class T, int32_t I, typename... Args>
 void GPUReconstructionCPUBackend::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
 {
+#pragma GCC diagnostic push
+#if defined(__clang__)
+#pragma GCC diagnostic ignored "-Wunused-lambda-capture" // this is not alway captured below
+#endif
   std::apply([this, &args](auto&... vals) { runKernelBackendInternal<T, I, Args...>(args.s, vals...); }, args.v);
+#pragma GCC diagnostic push
 }
 
 template <class T, int32_t I>

From ce9dd396d2e570fb8897a351c588bedac11a2e1c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 18 Mar 2025 13:11:30 +0100
Subject: [PATCH 0104/1764] GPU: Fix some minor issues indicated by clang
 sanitizer

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 22 +++++++++++++------
 .../Global/GPUChainTrackingSectorTracker.cxx  |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 11 +++++-----
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |  2 +-
 4 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 35e44d99d5c0c..8bae1df267412 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -147,8 +147,12 @@ int32_t GPUReconstruction::Init()
   if (InitDevice()) {
     return 1;
   }
-  mHostMemoryPoolEnd = (char*)mHostMemoryBase + mHostMemorySize;
-  mDeviceMemoryPoolEnd = (char*)mDeviceMemoryBase + mDeviceMemorySize;
+  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
+    mHostMemoryPoolEnd = (char*)mHostMemoryBase + mHostMemorySize;
+    mDeviceMemoryPoolEnd = (char*)mDeviceMemoryBase + mDeviceMemorySize;
+  } else {
+    mHostMemoryPoolEnd = mDeviceMemoryPoolEnd = nullptr;
+  }
   if (InitPhasePermanentMemory()) {
     return 1;
   }
@@ -860,14 +864,18 @@ void GPUReconstruction::ClearAllocatedMemory(bool clearOutputs)
       FreeRegisteredMemory(i);
     }
   }
-  mHostMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mHostMemoryPermanent);
-  mDeviceMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mDeviceMemoryPermanent);
   mUnmanagedChunks.clear();
-  mVolatileMemoryStart = nullptr;
   mNonPersistentMemoryStack.clear();
   mNonPersistentIndividualAllocations.clear();
-  mHostMemoryPoolEnd = mHostMemoryPoolBlocked ? mHostMemoryPoolBlocked : ((char*)mHostMemoryBase + mHostMemorySize);
-  mDeviceMemoryPoolEnd = mDeviceMemoryPoolBlocked ? mDeviceMemoryPoolBlocked : ((char*)mDeviceMemoryBase + mDeviceMemorySize);
+  mVolatileMemoryStart = nullptr;
+  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
+    mHostMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mHostMemoryPermanent);
+    mDeviceMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mDeviceMemoryPermanent);
+    mHostMemoryPoolEnd = mHostMemoryPoolBlocked ? mHostMemoryPoolBlocked : ((char*)mHostMemoryBase + mHostMemorySize);
+    mDeviceMemoryPoolEnd = mDeviceMemoryPoolBlocked ? mDeviceMemoryPoolBlocked : ((char*)mDeviceMemoryBase + mDeviceMemorySize);
+  } else {
+    mHostMemoryPool = mDeviceMemoryPool = mHostMemoryPoolEnd = mDeviceMemoryPoolEnd = nullptr;
+  }
 }
 
 void GPUReconstruction::UpdateMaxMemoryUsed()
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index dd71a797f2744..e161f74a31032 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -150,7 +150,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   if (param().rec.tpc.occupancyMapTimeBins || param().rec.tpc.sysClusErrorC12Norm) {
     uint32_t& occupancyTotal = *mInputsHost->mTPCClusterOccupancyMap;
     occupancyTotal = CAMath::Float2UIntRn(mRec->MemoryScalers()->nTPCHits / (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasNHBFPerTF ? mIOPtrs.settingsTF->nHBFPerTF : 128));
-    mRec->UpdateParamOccupancyMap(param().rec.tpc.occupancyMapTimeBins ? mInputsHost->mTPCClusterOccupancyMap + 2 : nullptr, param().rec.tpc.occupancyMapTimeBins ? mInputsShadow->mTPCClusterOccupancyMap + 2 : nullptr, occupancyTotal, streamInitAndOccMap);
+    mRec->UpdateParamOccupancyMap(param().rec.tpc.occupancyMapTimeBins ? mInputsHost->mTPCClusterOccupancyMap + 2 : nullptr, doGPU && param().rec.tpc.occupancyMapTimeBins ? mInputsShadow->mTPCClusterOccupancyMap + 2 : nullptr, occupancyTotal, streamInitAndOccMap);
   }
 
   int32_t streamMap[NSECTORS];
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index f373d56ea0395..eb1df3f37b6b5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1706,20 +1706,20 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       nHits = nFilteredHits;
     }
 
-    uint32_t iOutTrackFirstCluster = CAMath::AtomicAdd(&mMemory->nOutputTrackClusters, (uint32_t)nHits);
+    const uint32_t iOutTrackFirstCluster = CAMath::AtomicAdd(&mMemory->nOutputTrackClusters, (uint32_t)nHits);
     if (iOutTrackFirstCluster >= mNMaxOutputTrackClusters) {
       raiseError(GPUErrors::ERROR_MERGER_HIT_OVERFLOW, iOutTrackFirstCluster, mNMaxOutputTrackClusters);
       CAMath::AtomicExch(&mMemory->nOutputTrackClusters, mNMaxOutputTrackClusters);
       continue;
     }
 
-    GPUTPCGMMergedTrackHit* cl = mClusters + iOutTrackFirstCluster;
-    GPUTPCGMMergedTrackHitXYZ* clXYZ = mClustersXYZ + iOutTrackFirstCluster;
+    GPUTPCGMMergedTrackHit* const cl = mClusters + iOutTrackFirstCluster;
 
     for (int32_t i = 0; i < nHits; i++) {
       uint8_t state;
       if (Param().par.earlyTpcTransform) {
         const GPUTPCClusterData& c = GetConstantMem()->tpcTrackers[trackClusters[i].sector].ClusterData()[trackClusters[i].id - GetConstantMem()->tpcTrackers[trackClusters[i].sector].Data().ClusterIdOffset()];
+        GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iOutTrackFirstCluster;
         clXYZ[i].x = c.x;
         clXYZ[i].y = c.y;
         clXYZ[i].z = c.z;
@@ -1760,7 +1760,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     mergedTrack.SetCSide(p2.CSide());
 
     GPUTPCGMBorderTrack b;
-    const float toX = Param().par.earlyTpcTransform ? clXYZ[0].x : GPUTPCGeometry::Row2X(cl[0].row);
+    const float toX = Param().par.earlyTpcTransform ? mClustersXYZ[iOutTrackFirstCluster].x : GPUTPCGeometry::Row2X(cl[0].row);
     if (p2.TransportToX(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
       p1.X() = toX;
       p1.Y() = b.Par()[0];
@@ -1791,12 +1791,13 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     if (Param().rec.tpc.mergeCE) {
       bool CEside;
       if (Param().par.earlyTpcTransform) {
+        const GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iOutTrackFirstCluster;
         CEside = (mergedTrack.CSide() != 0) ^ (clXYZ[0].z > clXYZ[nHits - 1].z);
       } else {
         auto& cls = mConstantMem->ioPtrs.clustersNative->clustersLinear;
         CEside = cls[cl[0].num].getTime() < cls[cl[nHits - 1].num].getTime();
       }
-      MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], &clXYZ[CEside ? (nHits - 1) : 0], iOutputTrack);
+      MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], Param().par.earlyTpcTransform ? &(mClustersXYZ + iOutTrackFirstCluster)[CEside ? (nHits - 1) : 0] : nullptr, iOutputTrack);
     }
   } // itr
 }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 3bd2257d02e01..d235b3398c062 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -1091,7 +1091,7 @@ GPUd() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict() tr
   GPUTPCGMTrackParam t = track.Param();
   float Alpha = track.Alpha();
   CADEBUG(int32_t nTrackHitsOld = nTrackHits; float ptOld = t.QPt());
-  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), merger->ClustersXYZ() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, &track.OuterParam());
+  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), merger->Param().par.earlyTpcTransform ? merger->ClustersXYZ() + track.FirstClusterRef() : nullptr, nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, &track.OuterParam());
   CADEBUG(printf("Finished Fit Track %d\n", iTrk));
   CADEBUG(printf("OUTPUT hits %d -> %d+%d = %d, QPt %f -> %f, SP %f, ok %d chi2 %f chi2ndf %f\n", nTrackHitsOld, nTrackHits, NTolerated, nTrackHits + NTolerated, ptOld, t.QPt(), t.SinPhi(), (int32_t)ok, t.Chi2(), t.Chi2() / CAMath::Max(1, nTrackHits)));
 

From 0064a3af79e6f92ee99725cf7a2d024b667bac2e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 18 Mar 2025 13:28:56 +0100
Subject: [PATCH 0105/1764] With -ffast-math, std::finite is UB and one shoult
 assume all float to be finite

---
 Common/MathUtils/include/MathUtils/detail/basicMath.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Common/MathUtils/include/MathUtils/detail/basicMath.h b/Common/MathUtils/include/MathUtils/detail/basicMath.h
index 3fc3fe374b380..3565764435a68 100644
--- a/Common/MathUtils/include/MathUtils/detail/basicMath.h
+++ b/Common/MathUtils/include/MathUtils/detail/basicMath.h
@@ -113,7 +113,11 @@ GPUdi() int nint(double x)
 template <>
 GPUdi() bool finite(double x)
 {
+#ifdef __FAST_MATH__
+  return false;
+#else
   return std::isfinite(x);
+#endif
 }
 template <>
 GPUdi() double log(double x)

From cb5e20f94f5717e0c00aa33d5f40f23f40dcb1d4 Mon Sep 17 00:00:00 2001
From: lietava <roman.lietava@cern.ch>
Date: Tue, 18 Mar 2025 16:03:48 +0100
Subject: [PATCH 0106/1764] fix: debug removed

---
 Detectors/CTP/workflowScalers/src/RunManager.cxx | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Detectors/CTP/workflowScalers/src/RunManager.cxx b/Detectors/CTP/workflowScalers/src/RunManager.cxx
index 9af5b5e104120..ac3eda60094e9 100644
--- a/Detectors/CTP/workflowScalers/src/RunManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/RunManager.cxx
@@ -126,10 +126,9 @@ int CTPRunManager::loadRun(const std::string& cfg)
 }
 int CTPRunManager::setRunConfigBK(uint32_t runNumber, const std::string& cfg)
 {
-  std::cout << "Printing cfg:" << cfg << std::endl;
+  std::cout << "Printing run:" << runNumber << " cfg:" << cfg << std::endl;
   if (mBKClient) {
     try {
-      uint32_t runNumber = 1;
       mBKClient->run()->setRawCtpTriggerConfiguration(runNumber, cfg);
     } catch (std::runtime_error& error) {
       std::cerr << "An error occurred: " << error.what() << std::endl;

From c71128566f99d77103251fd8e07c2d9e4ba5a947 Mon Sep 17 00:00:00 2001
From: Maurice Coquet <mcoquet@lxplus986.cern.ch>
Date: Tue, 18 Mar 2025 16:05:11 +0100
Subject: [PATCH 0107/1764] Fixing CCDB host address for MFT noise scan

---
 Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
index 617e02ebb9d9c..a34d8cc5f2975 100644
--- a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
@@ -59,7 +59,7 @@ void NoiseCalibratorSpec::init(InitContext& ic)
   mPathDcs = ic.options().get<std::string>("path-DCS");
   mOutputType = ic.options().get<std::string>("send-to-server");
   mNoiseMapForDcs.clear();
-  api.init("http://alice-ccdb.cern.ch");
+  api.init(o2::base::NameConf::getCCDBServer());
 }
 
 void NoiseCalibratorSpec::run(ProcessingContext& pc)

From ad59c78eed8256990430777517aa6f4ca89cd954 Mon Sep 17 00:00:00 2001
From: pillot <pillot@subatech.in2p3.fr>
Date: Sat, 15 Mar 2025 10:29:56 +0100
Subject: [PATCH 0108/1764] turn error into warning and continue the scan

---
 Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx b/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
index 236effc4b1182..ab716bc6eb752 100644
--- a/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
+++ b/Detectors/MUON/MCH/Conditions/src/scan-hvlv-ccdb.cxx
@@ -479,8 +479,7 @@ void fillDataPoints(const std::vector<DPVAL>& dps, std::map<uint64_t, double>& d
     auto previousTS = dps2.rbegin()->first;
     if (ts != previousTS || getValue(*itDP) != dps2.rbegin()->second) {
       if (ts <= previousTS) {
-        printf("error: wrong data point order (%llu <= %llu)\n", (ULL)ts, (ULL)previousTS);
-        exit(1);
+        printf("\e[0;31mwarning: wrong data point order (%llu <= %llu)\e[0m\n", (ULL)ts, (ULL)previousTS);
       }
       if (printWarning) {
         printf("%s%s missing the previous data point (dt = %s%llu ms)", color.c_str(), header.c_str(),
@@ -512,8 +511,9 @@ void fillDataPoints(const std::vector<DPVAL>& dps, std::map<uint64_t, double>& d
   for (++itDP; itDP < dps.end(); ++itDP) {
     ts = itDP->get_epoch_time();
     if (ts <= previousTS) {
-      printf("error: wrong data point order (%llu <= %llu)\n", (ULL)ts, (ULL)previousTS);
-      exit(1);
+      printf("\e[0;31mwarning: wrong data point order (%llu <= %llu)\e[0m\n", (ULL)ts, (ULL)previousTS);
+    } else {
+      previousTS = ts;
     }
     if (ts < tMin && (warningLevel > 1 || (warningLevel == 1 && ts + tolerance < tMin))) {
       printf("%s%s data point outside of file validity range (dt = -%llu ms)\e[0m\n",
@@ -523,7 +523,6 @@ void fillDataPoints(const std::vector<DPVAL>& dps, std::map<uint64_t, double>& d
              header.c_str(), (ULL)(ts - tMax));
     }
     dps2.emplace(ts, getValue(*itDP));
-    previousTS = ts;
   }
 }
 

From 1b5b9b672f89afd25af46309bce2147da41b685b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Barth=C3=A9l=C3=A9my=20von=20Haller?=
 <barthelemy.von.haller@cern.ch>
Date: Fri, 14 Mar 2025 16:30:49 +0100
Subject: [PATCH 0109/1764] Avoid fatal in CTPRateFetcher

---
 DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx b/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
index 43fa9dbe7f3f3..67e59aad3ea24 100644
--- a/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
+++ b/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
@@ -46,7 +46,8 @@ double CTPRateFetcher::fetchNoPuCorr(o2::ccdb::BasicCCDBManager* ccdb, uint64_t
         LOG(info) << "Trying different class";
         ret = fetchCTPratesClassesNoPuCorr(timeStamp, "CMTVX-NONE");
         if (ret < 0) {
-          LOG(fatal) << "None of the classes used for lumi found";
+          LOG(error) << "None of the classes used for lumi found";
+          return -1.;
         }
       }
       return ret;
@@ -245,17 +246,19 @@ void CTPRateFetcher::setupRun(int runNumber, o2::ccdb::BasicCCDBManager* ccdb, u
     return;
   }
   mRunNumber = runNumber;
-  LOG(info) << "Setting up CTP scalers for run " << mRunNumber;
+  LOG(info) << "Setting up CTP scalers for run " << mRunNumber << " and timestamp : " << timeStamp;
   auto ptrLHCIFdata = ccdb->getSpecific<parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", timeStamp);
   if (ptrLHCIFdata == nullptr) {
-    LOG(fatal) << "GRPLHCIFData not in database, timestamp:" << timeStamp;
+    LOG(error) << "GRPLHCIFData not in database, timestamp:" << timeStamp;
+    return;
   }
   mLHCIFdata = *ptrLHCIFdata;
   std::map<string, string> metadata;
   metadata["runNumber"] = std::to_string(mRunNumber);
   auto ptrConfig = ccdb->getSpecific<ctp::CTPConfiguration>("CTP/Config/Config", timeStamp, metadata);
   if (ptrConfig == nullptr) {
-    LOG(fatal) << "CTPRunConfig not in database, timestamp:" << timeStamp;
+    LOG(error) << "CTPRunConfig not in database, timestamp:" << timeStamp;
+    return;
   }
   mConfig = *ptrConfig;
   if (initScalers) {
@@ -264,7 +267,7 @@ void CTPRateFetcher::setupRun(int runNumber, o2::ccdb::BasicCCDBManager* ccdb, u
       mScalers = *ptrScalers;
       mScalers.convertRawToO2();
     } else {
-      LOG(fatal) << "CTPRunScalers not in database, timestamp:" << timeStamp;
+      LOG(error) << "CTPRunScalers not in database, timestamp:" << timeStamp;
     }
   }
 }

From af7c9d3a03dcf99e6ee587c311c05494cec27a35 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 19 Mar 2025 22:30:19 +0100
Subject: [PATCH 0110/1764] GPU Standalone: Simplify CMake script

---
 .../Standalone/Benchmark/CMakeLists.txt       |  4 +-
 GPU/GPUTracking/Standalone/CMakeLists.txt     | 70 +++++++------------
 GPU/GPUTracking/display/CMakeLists.txt        |  3 +
 3 files changed, 32 insertions(+), 45 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
index fe583be02fe6b..de2d683036193 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
@@ -22,8 +22,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                       TARGETVARNAME targetName
                       PUBLIC_LINK_LIBRARIES O2::GPUO2Interface O2::GPUTracking
                       SOURCES ${SRCS})
-
-    target_compile_definitions(${targetName} PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
@@ -31,6 +29,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
     set(targetName ca)
 endif()
 
+target_compile_definitions(${targetName} PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
+
 if(ROOT_FOUND)
   target_sources(${targetName} PRIVATE ../../qa/genEvents.cxx)
 endif()
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 6e536727a0c67..5ed511173f53e 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -187,40 +187,33 @@ include_directories(${GPU_DIR}/Common
 # Create main targets
 add_subdirectory(../../ GPU)
 add_library(standalone_support SHARED ${GPUTRACKING_DIR}/utils/EmptyFile.cxx)
+target_compile_definitions(standalone_support PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
-target_link_libraries(GPUTracking PUBLIC TPCFastTransformation standalone_support dl)
+target_link_libraries(standalone_support PUBLIC#
+                      dl
+                      pthread
+                      Microsoft.GSL::GSL
+                      TPCFastTransformation)
+target_link_libraries(GPUTracking PUBLIC TPCFastTransformation standalone_support)
 target_link_libraries(ca PUBLIC GPUTracking)
-target_link_libraries(standalone_support PUBLIC dl pthread)
-target_compile_definitions(ca PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
-target_compile_definitions(standalone_support PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
 # Add all sources and dependencies to to support based on Config File
 target_sources(standalone_support PRIVATE
-              ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
-              ${O2_DIR}/DataFormats/Detectors/TPC/src/CompressedClusters.cxx
-              ${O2_DIR}/DataFormats/simulation/src/MCCompLabel.cxx
-              ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
-              ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
-              ${O2_DIR}/DataFormats/Reconstruction/src/Vertex.cxx
-              ${O2_DIR}/DataFormats/Reconstruction/src/TrackLTIntegral.cxx
-              ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
-              ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
-              ${O2_DIR}/Detectors/TRD/base/src/GeometryBase.cxx
-              ${O2_DIR}/Detectors/Base/src/MatLayerCylSet.cxx
-              ${O2_DIR}/Detectors/Base/src/MatLayerCyl.cxx
-              ${O2_DIR}/Detectors/Base/src/Ray.cxx
-              ${O2_DIR}/Detectors/Base/src/Propagator.cxx
-              ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/Road.cxx)
-if(CONFIG_O2_ITS_TRAITS)
-  target_sources(standalone_support PRIVATE
-      ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/PrimaryVertexContext.cxx
-      ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
-      ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
-      ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/TrackerTraitsCPU.cxx
-      ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
-      ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx)
-  target_link_libraries(standalone_support PUBLIC Boost::boost)
-endif()
+               ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
+               ${O2_DIR}/DataFormats/Detectors/TPC/src/CompressedClusters.cxx
+               ${O2_DIR}/DataFormats/simulation/src/MCCompLabel.cxx
+               ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
+               ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+               ${O2_DIR}/DataFormats/Reconstruction/src/Vertex.cxx
+               ${O2_DIR}/DataFormats/Reconstruction/src/TrackLTIntegral.cxx
+               ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
+               ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+               ${O2_DIR}/Detectors/TRD/base/src/GeometryBase.cxx
+               ${O2_DIR}/Detectors/Base/src/MatLayerCylSet.cxx
+               ${O2_DIR}/Detectors/Base/src/MatLayerCyl.cxx
+               ${O2_DIR}/Detectors/Base/src/Ray.cxx
+               ${O2_DIR}/Detectors/Base/src/Propagator.cxx
+               ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/Road.cxx)
 
 if(GPUCA_CONFIG_FMT)
   target_link_libraries(standalone_support PUBLIC fmt::fmt)
@@ -232,23 +225,14 @@ if(GPUCA_CONFIG_VC)
   target_link_libraries(TPCFastTransformation PUBLIC Vc::Vc)
 endif()
 
-if(GPUCA_BUILD_EVENT_DISPLAY)
-  if(GPUCA_CONFIG_GL3W)
-    target_sources(GPUTrackingDisplay PRIVATE ${GPUTRACKING_DIR}/display/3rdparty/gl3w.c)
-  endif()
-  target_sources(GPUTracking PRIVATE ${GPUTRACKING_DIR}/display/3rdparty/HandMadeMath/HandMadeMathImpl.cxx)
-  target_include_directories(GPUTracking SYSTEM PUBLIC ${GPUTRACKING_DIR}/display/3rdparty)
-endif()
-
 if(GPUCA_CONFIG_ROOT)
   target_link_libraries(standalone_support PUBLIC
-                             ROOT::Core
-                             ROOT::RIO
-                             ROOT::Hist
-                             ROOT::Gui
-                             ROOT::Tree)
+                        ROOT::Core
+                        ROOT::RIO
+                        ROOT::Hist
+                        ROOT::Gui
+                        ROOT::Tree)
 endif()
-target_link_libraries(standalone_support PUBLIC Microsoft.GSL::GSL TPCFastTransformation)
 
 if (GPUCA_BUILD_DEBUG_SANITIZE AND CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
   execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=libclang_rt.asan-x86_64.so OUTPUT_VARIABLE CLANG_ASAN_SO_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index 68385d7916234..b3107dbec8c79 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -179,9 +179,12 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   endif()
   if(GPUCA_CONFIG_GL3W)
     target_compile_definitions(${targetName} PRIVATE GPUCA_DISPLAY_GL3W)
+    target_sources(${targetName} PRIVATE ${GPUTRACKING_DIR}/display/3rdparty/gl3w.c)
   else()
     target_link_libraries(${targetName} PRIVATE ${GLEW_LIBRARIES})
   endif()
+  target_sources(${targetName} PRIVATE ${GPUTRACKING_DIR}/display/3rdparty/HandMadeMath/HandMadeMathImpl.cxx)
+  target_include_directories(${targetName} SYSTEM PUBLIC ${GPUTRACKING_DIR}/display/3rdparty)
 endif()
 
 if (OPENGL_GLU_FOUND)

From 9046e703929252511633b3ac75a06f618802e2b3 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 19 Mar 2025 22:35:24 +0100
Subject: [PATCH 0111/1764] GPU Standalone: trap on FPE by default only when
 not using ffast-math

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h       | 2 +-
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 40a7fc71cbb4d..a1f650a2bc56e 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -521,7 +521,7 @@ AddOption(outputcontrolmem, uint64_t, 0, "outputMemory", 0, "Use predefined outp
 AddOption(inputcontrolmem, uint64_t, 0, "inputMemory", 0, "Use predefined input buffer of this size", min(0ul), message("Using %s bytes as input memory"))
 AddOption(cpuAffinity, int32_t, -1, "", 0, "Pin CPU affinity to this CPU core", min(-1))
 AddOption(fifoScheduler, bool, false, "", 0, "Use FIFO realtime scheduler", message("Setting FIFO scheduler: %s"))
-AddOption(fpe, bool, true, "", 0, "Trap on floating point exceptions")
+AddOption(fpe, int8_t, -1, "", 0, "Trap on floating point exceptions (-1 = if no ffast-math)")
 AddOption(flushDenormals, bool, true, "", 0, "Enable FTZ and DAZ (Flush all denormals to zero)")
 AddOption(solenoidBzNominalGPU, float, -1e6f, "", 0, "Field strength of solenoid Bz in kGaus")
 AddOption(constBz, bool, false, "", 0, "Force constand Bz")
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index d6279df7c9188..e9cb7c5179c59 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -142,7 +142,11 @@ int32_t ReadConfiguration(int argc, char** argv)
       return 1;
     }
   }
+#ifdef __FAST_MATH__
+  if (configStandalone.fpe == 1) {
+#else
   if (configStandalone.fpe) {
+#endif
     feenableexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW);
   }
   if (configStandalone.flushDenormals) {
@@ -158,7 +162,7 @@ int32_t ReadConfiguration(int argc, char** argv)
     printf("FIFO Scheduler setting not supported on Windows\n");
     return 1;
   }
-  if (configStandalone.fpe) {
+  if (configStandalone.fpe == 1) {
     printf("FPE not supported on Windows\n");
     return 1;
   }

From 90267bb6455493078cb2e97139d7d8443320034f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 20 Mar 2025 08:36:09 +0100
Subject: [PATCH 0112/1764] DPL: enable early forwarding for AODs (#14088)

Should improve parallelism for long trains. Requires FairMQ 1.9.2 and one needs to pass `--early-forwarding-policy always` for this to take effect.
---
 .../Framework/CompletionPolicyHelpers.h       |  5 ++++
 Framework/Core/include/Framework/InputSpan.h  | 15 +++++++++++-
 Framework/Core/src/CompletionPolicy.cxx       |  4 ++++
 .../Core/src/CompletionPolicyHelpers.cxx      | 18 ++++++++++++++
 Framework/Core/src/DataProcessingDevice.cxx   | 15 +++++++++++-
 Framework/Core/src/DataRelayer.cxx            | 24 +++++++++++++++++--
 Framework/Core/src/InputSpan.cxx              |  7 ++++--
 .../Core/test/test_InputRecordWalker.cxx      |  2 +-
 Framework/Core/test/test_InputSpan.cxx        |  2 +-
 Framework/Utils/test/RawPageTestData.h        |  6 +++--
 10 files changed, 88 insertions(+), 10 deletions(-)

diff --git a/Framework/Core/include/Framework/CompletionPolicyHelpers.h b/Framework/Core/include/Framework/CompletionPolicyHelpers.h
index 547add44560ea..aa336d040d30d 100644
--- a/Framework/Core/include/Framework/CompletionPolicyHelpers.h
+++ b/Framework/Core/include/Framework/CompletionPolicyHelpers.h
@@ -43,6 +43,11 @@ struct CompletionPolicyHelpers {
 
   /// When any of the parts of the record have been received, consume them.
   static CompletionPolicy consumeWhenAny(const char* name, CompletionPolicy::Matcher matcher);
+
+#if __has_include(<fairmq/shmem/Message.h>)
+  /// When any of the parts which has arrived has a refcount of 1.
+  static CompletionPolicy consumeWhenAnyZeroCount(const char* name, CompletionPolicy::Matcher matcher);
+#endif
   /// Default matcher applies for all devices
   static CompletionPolicy consumeWhenAny(CompletionPolicy::Matcher matcher = [](auto const&) -> bool { return true; })
   {
diff --git a/Framework/Core/include/Framework/InputSpan.h b/Framework/Core/include/Framework/InputSpan.h
index c435276c7134f..cf8c8acda6796 100644
--- a/Framework/Core/include/Framework/InputSpan.h
+++ b/Framework/Core/include/Framework/InputSpan.h
@@ -46,7 +46,7 @@ class InputSpan
   /// index and the buffer associated.
   /// @nofPartsGetter is the getter for the number of parts associated with an index
   /// @a size is the number of elements in the span.
-  InputSpan(std::function<DataRef(size_t, size_t)> getter, std::function<size_t(size_t)> nofPartsGetter, size_t size);
+  InputSpan(std::function<DataRef(size_t, size_t)> getter, std::function<size_t(size_t)> nofPartsGetter, std::function<int(size_t)> refCountGetter, size_t size);
 
   /// @a i-th element of the InputSpan
   [[nodiscard]] DataRef get(size_t i, size_t partidx = 0) const
@@ -66,6 +66,18 @@ class InputSpan
     return mNofPartsGetter(i);
   }
 
+  // Get the refcount for a given part
+  [[nodiscard]] int getRefCount(size_t i) const
+  {
+    if (i >= mSize) {
+      return 0;
+    }
+    if (!mRefCountGetter) {
+      return -1;
+    }
+    return mRefCountGetter(i);
+  }
+
   /// Number of elements in the InputSpan
   [[nodiscard]] size_t size() const
   {
@@ -236,6 +248,7 @@ class InputSpan
  private:
   std::function<DataRef(size_t, size_t)> mGetter;
   std::function<size_t(size_t)> mNofPartsGetter;
+  std::function<int(size_t)> mRefCountGetter;
   size_t mSize;
 };
 
diff --git a/Framework/Core/src/CompletionPolicy.cxx b/Framework/Core/src/CompletionPolicy.cxx
index 9d92fd07e6f5a..ec8997e32c5db 100644
--- a/Framework/Core/src/CompletionPolicy.cxx
+++ b/Framework/Core/src/CompletionPolicy.cxx
@@ -26,7 +26,11 @@ std::vector<CompletionPolicy>
 {
   return {
     CompletionPolicyHelpers::consumeWhenAllOrdered("internal-dpl-aod-writer"),
+#if __has_include(<fairmq/shmem/Message.h>)
+    CompletionPolicyHelpers::consumeWhenAnyZeroCount("internal-dpl-injected-dummy-sink", [](DeviceSpec const& s) { return s.name.find("internal-dpl-injected-dummy-sink") != std::string::npos; }),
+#else
     CompletionPolicyHelpers::consumeWhenAny("internal-dpl-injected-dummy-sink", [](DeviceSpec const& s) { return s.name.find("internal-dpl-injected-dummy-sink") != std::string::npos; }),
+#endif
     CompletionPolicyHelpers::consumeWhenAll()};
 }
 
diff --git a/Framework/Core/src/CompletionPolicyHelpers.cxx b/Framework/Core/src/CompletionPolicyHelpers.cxx
index 9dd895a6fed6d..e682f9a7c7dd6 100644
--- a/Framework/Core/src/CompletionPolicyHelpers.cxx
+++ b/Framework/Core/src/CompletionPolicyHelpers.cxx
@@ -19,6 +19,9 @@
 #include "Framework/TimingInfo.h"
 #include "DecongestionService.h"
 #include "Framework/Signpost.h"
+#if __has_include(<fairmq/shmem/Message.h>)
+#include <fairmq/shmem/Message.h>
+#endif
 
 #include <cassert>
 #include <regex>
@@ -249,6 +252,21 @@ CompletionPolicy CompletionPolicyHelpers::consumeExistingWhenAny(const char* nam
     }};
 }
 
+#if __has_include(<fairmq/shmem/Message.h>)
+CompletionPolicy CompletionPolicyHelpers::consumeWhenAnyZeroCount(const char* name, CompletionPolicy::Matcher matcher)
+{
+  auto callback = [](InputSpan const& inputs, std::vector<InputSpec> const&, ServiceRegistryRef& ref) -> CompletionPolicy::CompletionOp {
+    for (size_t i = 0; i < inputs.size(); ++i) {
+      if (inputs.get(i).header != nullptr && inputs.getRefCount(i) == 1) {
+        return CompletionPolicy::CompletionOp::Consume;
+      }
+    }
+    return CompletionPolicy::CompletionOp::Wait;
+  };
+  return CompletionPolicy{name, matcher, callback, false};
+}
+#endif
+
 CompletionPolicy CompletionPolicyHelpers::consumeWhenAny(const char* name, CompletionPolicy::Matcher matcher)
 {
   auto callback = [](InputSpan const& inputs, std::vector<InputSpec> const&, ServiceRegistryRef& ref) -> CompletionPolicy::CompletionOp {
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 7f42805cfdb1e..ae25d8d3a915c 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -57,6 +57,9 @@
 #include <fairmq/Parts.h>
 #include <fairmq/Socket.h>
 #include <fairmq/ProgOptions.h>
+#if __has_include(<fairmq/shmem/Message.h>)
+#include <fairmq/shmem/Message.h>
+#endif
 #include <Configuration/ConfigurationInterface.h>
 #include <Configuration/ConfigurationFactory.h>
 #include <Monitoring/Monitoring.h>
@@ -1214,12 +1217,14 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
       if (forwarded.matcher.lifetime != Lifetime::Condition) {
         onlyConditions = false;
       }
+#if !__has_include(<fairmq/shmem/Message.h>)
       if (strncmp(DataSpecUtils::asConcreteOrigin(forwarded.matcher).str, "AOD", 3) == 0) {
         context.canForwardEarly = false;
         overriddenEarlyForward = true;
         LOG(detail) << "Cannot forward early because of AOD input: " << DataSpecUtils::describe(forwarded.matcher);
         break;
       }
+#endif
       if (DataSpecUtils::partialMatch(forwarded.matcher, o2::header::DataDescription{"RAWDATA"}) && mProcessingPolicies.earlyForward == EarlyForwardPolicy::NORAW) {
         context.canForwardEarly = false;
         overriddenEarlyForward = true;
@@ -2230,7 +2235,15 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     auto nofPartsGetter = [&currentSetOfInputs](size_t i) -> size_t {
       return currentSetOfInputs[i].getNumberOfPairs();
     };
-    return InputSpan{getter, nofPartsGetter, currentSetOfInputs.size()};
+#if __has_include(<fairmq/shmem/Message.h>)
+    auto refCountGetter = [&currentSetOfInputs](size_t idx) -> int {
+      auto& header = static_cast<const fair::mq::shmem::Message&>(*currentSetOfInputs[idx].header(0));
+      return header.GetRefCount();
+    };
+#else
+    std::function<int(size_t)> refCountGetter = nullptr;
+#endif
+    return InputSpan{getter, nofPartsGetter, refCountGetter, currentSetOfInputs.size()};
   };
 
   auto markInputsAsDone = [ref](TimesliceSlot slot) -> void {
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 385d9a6c50c4a..f30866dc0aa1b 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -44,6 +44,10 @@
 #include <Monitoring/Monitoring.h>
 
 #include <fairmq/Channel.h>
+#include <functional>
+#if __has_include(<fairmq/shmem/Message.h>)
+#include <fairmq/shmem/Message.h>
+#endif
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 #include <gsl/span>
@@ -209,7 +213,15 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       auto nPartsGetter = [&partial](size_t idx) {
         return partial[idx].size();
       };
-      InputSpan span{getter, nPartsGetter, static_cast<size_t>(partial.size())};
+#if __has_include(<fairmq/shmem/Message.h>)
+      auto refCountGetter = [&partial](size_t idx) -> int {
+        auto& header = static_cast<const fair::mq::shmem::Message&>(*partial[idx].header(0));
+        return header.GetRefCount();
+      };
+#else
+      std::function<int(size_t)> refCountGetter = nullptr;
+#endif
+      InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
       // Setup the input span
 
       if (expirator.checker(services, timestamp.value, span) == false) {
@@ -755,7 +767,15 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
     auto nPartsGetter = [&partial](size_t idx) {
       return partial[idx].size();
     };
-    InputSpan span{getter, nPartsGetter, static_cast<size_t>(partial.size())};
+#if __has_include(<fairmq/shmem/Message.h>)
+    auto refCountGetter = [&partial](size_t idx) -> int {
+      auto& header = static_cast<const fair::mq::shmem::Message&>(*partial[idx].header(0));
+      return header.GetRefCount();
+    };
+#else
+    std::function<int(size_t)> refCountGetter = nullptr;
+#endif
+    InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
     CompletionPolicy::CompletionOp action = mCompletionPolicy.callbackFull(span, mInputs, mContext);
 
     auto& variables = mTimesliceIndex.getVariablesForSlot(slot);
diff --git a/Framework/Core/src/InputSpan.cxx b/Framework/Core/src/InputSpan.cxx
index 510b55cd0b9b9..d1dffc85602a5 100644
--- a/Framework/Core/src/InputSpan.cxx
+++ b/Framework/Core/src/InputSpan.cxx
@@ -29,8 +29,11 @@ InputSpan::InputSpan(std::function<DataRef(size_t, size_t)> getter, size_t size)
 {
 }
 
-InputSpan::InputSpan(std::function<DataRef(size_t, size_t)> getter, std::function<size_t(size_t)> nofPartsGetter, size_t size)
-  : mGetter{getter}, mNofPartsGetter{nofPartsGetter}, mSize{size}
+InputSpan::InputSpan(std::function<DataRef(size_t, size_t)> getter,
+                     std::function<size_t(size_t)> nofPartsGetter,
+                     std::function<int(size_t)> refCountGetter,
+                     size_t size)
+  : mGetter{getter}, mNofPartsGetter{nofPartsGetter}, mRefCountGetter(refCountGetter), mSize{size}
 {
 }
 
diff --git a/Framework/Core/test/test_InputRecordWalker.cxx b/Framework/Core/test/test_InputRecordWalker.cxx
index 5b9004a1a9366..9af3c0dd2dbe2 100644
--- a/Framework/Core/test/test_InputRecordWalker.cxx
+++ b/Framework/Core/test/test_InputRecordWalker.cxx
@@ -42,7 +42,7 @@ struct DataSet {
                                                            auto payload = static_cast<char const*>(this->messages[i].second.at(2 * part + 1)->data());
                                                            return DataRef{nullptr, header, payload};
                                                          },
-                                                         [this](size_t i) { return i < this->messages.size() ? messages[i].second.size() / 2 : 0; }, this->messages.size()},
+                                                         [this](size_t i) { return i < this->messages.size() ? messages[i].second.size() / 2 : 0; }, nullptr, this->messages.size()},
       record{schema, span, registry},
       values{std::move(v)}
   {
diff --git a/Framework/Core/test/test_InputSpan.cxx b/Framework/Core/test/test_InputSpan.cxx
index 0622ad898d249..c5682aea80b6c 100644
--- a/Framework/Core/test/test_InputSpan.cxx
+++ b/Framework/Core/test/test_InputSpan.cxx
@@ -37,7 +37,7 @@ TEST_CASE("TestInputSpan")
     return inputs[i].size() / 2;
   };
 
-  InputSpan span{getter, nPartsGetter, inputs.size()};
+  InputSpan span{getter, nPartsGetter, nullptr, inputs.size()};
   REQUIRE(span.size() == inputs.size());
   routeNo = 0;
   for (; routeNo < span.size(); ++routeNo) {
diff --git a/Framework/Utils/test/RawPageTestData.h b/Framework/Utils/test/RawPageTestData.h
index 684fc4d0cf8a3..a6b800f7cba32 100644
--- a/Framework/Utils/test/RawPageTestData.h
+++ b/Framework/Utils/test/RawPageTestData.h
@@ -47,7 +47,9 @@ struct DataSet {
              auto payload = static_cast<char const*>(this->messages[i].at(2 * part + 1)->data());
              return DataRef{nullptr, header, payload};
            },
-           [this](size_t i) { return i < this->messages.size() ? messages[i].size() / 2 : 0; }, this->messages.size()},
+           [this](size_t i) { return i < this->messages.size() ? messages[i].size() / 2 : 0; },
+           nullptr,
+           this->messages.size()},
       record{schema, span, registry},
       values{std::move(v)}
   {
@@ -63,5 +65,5 @@ struct DataSet {
 using AmendRawDataHeader = std::function<void(RAWDataHeader&)>;
 DataSet createData(std::vector<InputSpec> const& inputspecs, std::vector<DataHeader> const& dataheaders, AmendRawDataHeader amendRdh = nullptr);
 
-} // namespace o2::framework
+} // namespace o2::framework::test
 #endif // FRAMEWORK_UTILS_RAWPAGETESTDATA_H

From 7263f799ce8c3b660d0595fb95efeaef9b8c2f6c Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <matthias.kleiner@cern.ch>
Date: Thu, 20 Mar 2025 09:17:59 +0100
Subject: [PATCH 0113/1764] TPC: Adding check for empty IDCs

---
 .../include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h  | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h
index 5fe0d6a442dd5..35f51dd489115 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h
@@ -257,6 +257,11 @@ class TPCFourierTransformAggregatorSpec : public o2::framework::Task
   void makeTPCScaler(DataAllocator& output, const bool eos)
   {
     LOGP(info, "Making TPC scalers");
+    if (mTPCScalerCont.idcs.empty()) {
+      LOGP(warning, "No IDCs received for TPC scaler creation");
+      return;
+    }
+
     // check if IDC scalers can be created - check length of continous received IDCs
     std::vector<std::pair<long, long>> times;
     times.reserve(mTPCScalerCont.idcs.size());

From 42d5ae19a64f14c858496dd77dd1f6b5520c3415 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Thu, 20 Mar 2025 15:07:16 +0100
Subject: [PATCH 0114/1764] remove deprecated confkey value

---
 Common/SimConfig/include/SimConfig/SimParams.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Common/SimConfig/include/SimConfig/SimParams.h b/Common/SimConfig/include/SimConfig/SimParams.h
index 2c103f43b2b04..cf3ee2b01cf2e 100644
--- a/Common/SimConfig/include/SimConfig/SimParams.h
+++ b/Common/SimConfig/include/SimConfig/SimParams.h
@@ -36,7 +36,6 @@ struct SimCutParams : public o2::conf::ConfigurableParamHelper<SimCutParams> {
   float maxRTrackingZDC = 50; // R-cut applied in the tunnel leading to ZDC when z > beampipeZ (custom stepping function)
   float tunnelZ = 1900;       // Z-value from where we apply maxRTrackingZDC (default value taken from standard "hall" dimensions)
 
-  float globalDensityFactor = 1.f; // global factor that scales all material densities for systematic studies
   bool lowneut = false;
   O2ParamDef(SimCutParams, "SimCutParams");
 };
@@ -44,7 +43,7 @@ struct SimCutParams : public o2::conf::ConfigurableParamHelper<SimCutParams> {
 // parameter influencing material manager
 struct SimMaterialParams : public o2::conf::ConfigurableParamHelper<SimMaterialParams> {
   // Local density value takes precedence over global density value, i.e. local values overwrite the global value.
-  float globalDensityFactor = 1.f;
+  float globalDensityFactor = 1.f; // global factor that scales all material densities for systematic studies
   std::string localDensityFactor; // Expected format: "SimMaterialParams.localDensityFactor=<mod1>:<value1>,<mod2>:<value2>,..."
 
   O2ParamDef(SimMaterialParams, "SimMaterialParams");

From 97aeb5f7be62d251c196ea9c2d354b119bb8f29c Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sat, 22 Mar 2025 02:26:50 +0100
Subject: [PATCH 0115/1764] Common: allow to write c-style arrays in TreeStream

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Common/Utils/include/CommonUtils/TreeStream.h | 162 +++++++++---------
 Common/Utils/src/TreeStream.cxx               |  38 +++-
 Common/Utils/test/testTreeStream.cxx          |  42 ++++-
 3 files changed, 148 insertions(+), 94 deletions(-)

diff --git a/Common/Utils/include/CommonUtils/TreeStream.h b/Common/Utils/include/CommonUtils/TreeStream.h
index 2aa02f6509d2c..d1d4527ffc99d 100644
--- a/Common/Utils/include/CommonUtils/TreeStream.h
+++ b/Common/Utils/include/CommonUtils/TreeStream.h
@@ -19,6 +19,8 @@
 #include <TString.h>
 #include <TTree.h>
 #include <vector>
+#include <type_traits>
+#include <concepts>
 #include "GPUCommonDef.h"
 
 class TBranch;
@@ -39,10 +41,79 @@ namespace utils
 ///
 /// See testTreeStream.cxx for functional example
 ///
+namespace details
+{
+template <typename T>
+struct IsTrivialRootType {
+  static constexpr bool value =
+    std::is_same_v<T, Float_t> ||                                                        // Float_t
+    std::is_same_v<T, Double_t> ||                                                       // Double_t
+    std::is_same_v<T, ULong64_t> || std::is_same_v<T, ULong_t> ||                        // ULong64_t or ULong_t
+    std::is_same_v<T, Long64_t> || std::is_same_v<T, Long_t> ||                          // Long64_t or Long_t
+    std::is_same_v<T, UInt_t> ||                                                         // UInt_t
+    std::is_same_v<T, Int_t> ||                                                          // Int_t
+    std::is_same_v<T, UShort_t> ||                                                       // UShort_t
+    std::is_same_v<T, Short_t> ||                                                        // Short_t
+    std::is_same_v<T, UChar_t> ||                                                        // UChar_t
+    std::is_same_v<T, Char_t> || std::is_same_v<T, int8_t> || std::is_same_v<T, Bool_t>; // Char_t, int8_t, or Bool_t
+};
+
+template <typename T>
+struct IsTrivialRootType<T[]> {
+  static constexpr bool value = IsTrivialRootType<T>::value;
+};
+
+template <typename T, std::size_t N>
+struct IsTrivialRootType<T[N]> {
+  static constexpr bool value = IsTrivialRootType<T>::value;
+};
+
+template <typename T>
+concept TrivialRootType = IsTrivialRootType<T>::value;
+
+template <typename T>
+concept ComplexRootType = !IsTrivialRootType<T>::value;
+
+template <TrivialRootType T>
+static constexpr char getRootTypeCode()
+{
+  if constexpr (std::is_array_v<T>) {
+    return getRootTypeCode<std::remove_all_extents_t<T>>();
+  } else if constexpr (std::is_same_v<T, Float_t>) {
+    return 'F';
+  } else if constexpr (std::is_same_v<T, Double_t>) {
+    return 'D';
+  } else if constexpr (std::is_same_v<T, ULong64_t> ||
+                       std::is_same_v<T, ULong_t>) {
+    return 'l';
+  } else if constexpr (std::is_same_v<T, Long64_t> ||
+                       std::is_same_v<T, Long_t>) {
+    return 'L';
+  } else if constexpr (std::is_same_v<T, UInt_t>) {
+    return 'i';
+  } else if constexpr (std::is_same_v<T, Int_t>) {
+    return 'I';
+  } else if constexpr (std::is_same_v<T, UShort_t>) {
+    return 's';
+  } else if constexpr (std::is_same_v<T, Short_t>) {
+    return 'S';
+  } else if constexpr (std::is_same_v<T, UChar_t>) {
+    return 'b';
+  } else if constexpr (std::is_same_v<T, Char_t> ||
+                       std::is_same_v<T, int8_t> ||
+                       std::is_same_v<T, Bool_t>) {
+    return 'B';
+  } else {
+    static_assert(false, "unsupported type!");
+  }
+}
+} // namespace details
+
 class TreeStream
 {
  public:
   struct TreeDataElement {
+    int arsize = 1;              ///< size of array
     char type = 0;               ///< type of data element
     const TClass* cls = nullptr; ///< data type pointer
     const void* ptr = nullptr;   ///< pointer to element
@@ -64,87 +135,10 @@ class TreeStream
   void setID(int id) { mID = id; }
   int getID() const { return mID; }
 
-  TreeStream& operator<<(const Bool_t& b)
-  {
-    CheckIn('B', &b);
-    return *this;
-  }
-
-  TreeStream& operator<<(const Char_t& c)
-  {
-    CheckIn('B', &c);
-    return *this;
-  }
-
-  TreeStream& operator<<(const int8_t& i)
-  {
-    CheckIn('B', &i);
-    return *this;
-  }
-
-  TreeStream& operator<<(const UChar_t& c)
-  {
-    CheckIn('b', &c);
-    return *this;
-  }
-
-  TreeStream& operator<<(const Short_t& h)
-  {
-    CheckIn('S', &h);
-    return *this;
-  }
-
-  TreeStream& operator<<(const UShort_t& h)
-  {
-    CheckIn('s', &h);
-    return *this;
-  }
-
-  TreeStream& operator<<(const Int_t& i)
-  {
-    CheckIn('I', &i);
-    return *this;
-  }
-
-  TreeStream& operator<<(const UInt_t& i)
-  {
-    CheckIn('i', &i);
-    return *this;
-  }
-
-  TreeStream& operator<<(const Long_t& l)
-  {
-    CheckIn('L', &l);
-    return *this;
-  }
-
-  TreeStream& operator<<(const ULong_t& l)
-  {
-    CheckIn('l', &l);
-    return *this;
-  }
-
-  TreeStream& operator<<(const Long64_t& l)
-  {
-    CheckIn('L', &l);
-    return *this;
-  }
-
-  TreeStream& operator<<(const ULong64_t& l)
-  {
-    CheckIn('l', &l);
-    return *this;
-  }
-
-  TreeStream& operator<<(const Float_t& f)
-  {
-    CheckIn('F', &f);
-    return *this;
-  }
-
-  TreeStream& operator<<(const Double_t& d)
+  template <details::TrivialRootType T>
+  TreeStream& operator<<(const T& t)
   {
-    CheckIn('D', &d);
+    CheckIn(details::getRootTypeCode<T>(), &t);
     return *this;
   }
 
@@ -157,7 +151,7 @@ class TreeStream
     return *this;
   }
 
-  template <class T, typename std::enable_if<!std::is_pointer<GPUgeneric() T>::value, bool>::type* = nullptr>
+  template <details::ComplexRootType T, typename std::enable_if<!std::is_pointer<GPUgeneric() T>::value, bool>::type* = nullptr>
   TreeStream& operator<<(const T& obj)
   {
     CheckIn(&obj);
@@ -175,6 +169,7 @@ class TreeStream
   int mCurrentIndex = 0;           ///< index of current element
   int mID = -1;                    ///< identifier of layout
   int mNextNameCounter = 0;        ///< next name counter
+  int mNextArraySize = 0;          ///< next array size
   int mStatus = 0;                 ///< status of the layout
   TString mNextName;               ///< name for next entry
 
@@ -191,8 +186,7 @@ Int_t TreeStream::CheckIn(const T* obj)
   }
 
   if (mCurrentIndex >= static_cast<int>(mElements.size())) {
-    mElements.emplace_back();
-    auto& element = mElements.back();
+    auto& element = mElements.emplace_back();
     element.cls = pClass;
     TString name = mNextName;
     if (name.Length()) {
@@ -204,6 +198,8 @@ Int_t TreeStream::CheckIn(const T* obj)
     }
     element.name = name.Data();
     element.ptr = obj;
+    element.arsize = mNextArraySize;
+    mNextArraySize = 1; // reset
   } else {
     auto& element = mElements[mCurrentIndex];
     if (!element.cls) {
diff --git a/Common/Utils/src/TreeStream.cxx b/Common/Utils/src/TreeStream.cxx
index da25f25ad2eb1..cd0641a11d043 100644
--- a/Common/Utils/src/TreeStream.cxx
+++ b/Common/Utils/src/TreeStream.cxx
@@ -29,8 +29,7 @@ int TreeStream::CheckIn(Char_t type, const void* pointer)
   // Insert object
 
   if (mCurrentIndex >= static_cast<int>(mElements.size())) {
-    mElements.emplace_back();
-    auto& element = mElements.back();
+    auto& element = mElements.emplace_back();
     element.type = type;
     TString name = mNextName;
     if (name.Length()) {
@@ -42,6 +41,8 @@ int TreeStream::CheckIn(Char_t type, const void* pointer)
     }
     element.name = name.Data();
     element.ptr = pointer;
+    element.arsize = mNextArraySize;
+    mNextArraySize = 1; // reset
   } else {
     auto& element = mElements[mCurrentIndex];
     if (element.type != type) {
@@ -89,7 +90,13 @@ void TreeStream::BuildTree()
     }
 
     if (element.type > 0) {
-      TString nameC = TString::Format("%s/%c", name.Data(), element.type);
+      TString nameC;
+      if (element.arsize > 1) {
+        nameC = TString::Format("%s[%d]/%c", name.Data(), element.arsize,
+                                element.type);
+      } else {
+        nameC = TString::Format("%s/%c", name.Data(), element.type);
+      }
       br = mTree.Branch(name.Data(), const_cast<void*>(element.ptr), nameC.Data());
       if (entriesFilled) {
         br->SetAddress(nullptr);
@@ -148,28 +155,43 @@ TreeStream& TreeStream::Endl()
 TreeStream& TreeStream::operator<<(const Char_t* name)
 {
   // Stream the branch name
-  //
   if (name[0] == '\n') {
     return Endl();
   }
-  //
+
   // if tree was already defined ignore
   if (mTree.GetEntries() > 0) {
     return *this;
   }
+
+  int arsize = 1;
+
   // check branch name if tree was not
-  //
   Int_t last = 0;
   for (last = 0;; last++) {
     if (name[last] == 0) {
       break;
     }
   }
-
   if (last > 0 && name[last - 1] == '=') {
     mNextName = name;
-    mNextName[last - 1] = 0;
+    mNextName[last - 1] = 0; // remove '=' from string
     mNextNameCounter = 0;
+
+    TString inName{name};
+    auto brkStaPos = inName.Index('[');
+
+    if (brkStaPos != kNPOS) {
+      auto brkEndPos = inName.Index(']');
+      if (brkEndPos != kNPOS && brkEndPos > brkStaPos + 1) {
+        TString size = inName(brkStaPos + 1, brkEndPos - brkStaPos - 1);
+        arsize = size.Atoi();
+        mNextName = inName(0, brkStaPos); // use parsed name
+      }
+    }
   }
+
+  mNextArraySize = arsize;
+
   return *this;
 }
diff --git a/Common/Utils/test/testTreeStream.cxx b/Common/Utils/test/testTreeStream.cxx
index 7ff6f165a1d37..2491fea7f6efd 100644
--- a/Common/Utils/test/testTreeStream.cxx
+++ b/Common/Utils/test/testTreeStream.cxx
@@ -53,12 +53,28 @@ BOOST_AUTO_TEST_CASE(TreeStream_test)
       tstStream << "TrackTreeR"
                 << "id=" << i << "x=" << x << "track=" << trc << "\n";
     }
+
+    // test for c-arrays
+    int iArray[6] = {1, 2, 3, 4, 5, 6};
+    float fArray[6] = {1.1f, 2.2f, 3.3f, 4.4f, 5.5f, 6.6f};
+    for (int i{0}; i < nit; ++i) {
+      for (int j{0}; j < 6; ++j) {
+        iArray[j] += i;
+        fArray[j] += (float)i;
+      }
+      tstStream << "ArrayTree"
+                << "id=" << i
+                << "iArray[6]=" << iArray
+                << "fArray[6]=" << fArray
+                << "\n";
+    }
+
     // on destruction of tstTreem the trees will be stored, but we can also force it by
     tstStream.Close();
   }
   //
-  LOG(info) << "Testing reading back tree maid by the TreeStream ";
-  // read back tracks
+  LOG(info) << "Testing reading back tree made by the TreeStream ";
+  // read back tracks and arrays
   {
     TFile inpf(outFName.data());
     BOOST_CHECK(!inpf.IsZombie());
@@ -80,6 +96,27 @@ BOOST_AUTO_TEST_CASE(TreeStream_test)
       trc->printParam();
       BOOST_CHECK(std::abs(x - trc->getX()) < 1e-4);
     }
+
+    // check arrays
+    tree = (TTree*)inpf.GetObjectChecked("ArrayTree", "TTree");
+    BOOST_CHECK(tree);
+    nent = tree->GetEntries();
+    BOOST_CHECK(nent == nit);
+    int iArray[6];
+    float fArray[6];
+    BOOST_CHECK(!tree->SetBranchAddress("id", &id));
+    BOOST_CHECK(!tree->SetBranchAddress("iArray", iArray));
+    BOOST_CHECK(!tree->SetBranchAddress("fArray", fArray));
+    for (int i = 0; i < nit; i++) {
+      BOOST_CHECK(tree->GetEntry(i) > 0);
+      BOOST_CHECK(id == i);
+      for (int j = 0; j < 6; j++) {
+        BOOST_CHECK(iArray[j] == (1 + j + i * (i + 1) / 2));
+      }
+      for (int j = 0; j < 6; j++) {
+        BOOST_CHECK_CLOSE(fArray[j], (1.f + j + i * (i + 1) / 2.f + 0.1 * (j + 1)), 1e-5);
+      }
+    }
   }
 
   LOG(info) << "Testing loading tree via RootChain";
@@ -104,7 +141,6 @@ BOOST_AUTO_TEST_CASE(TreeStream_test)
   nit = 1000;
   BOOST_CHECK(UnitTestSparse(0.5, nit));
   BOOST_CHECK(UnitTestSparse(0.1, nit));
-  //
 }
 
 //_________________________________________________

From 6e8b562d7164cc2dd9892ac9a56847e98ef04cab Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 22 Mar 2025 15:12:57 +0100
Subject: [PATCH 0116/1764] DPL: cleanup creation of DataProcessorInfo (#14096)

- Use aggregate initialisation where possible
- Drop unused bits

Will simplify the plugins PR.
---
 Framework/Core/test/test_DataAllocator.cxx    |  1 -
 .../Core/test/test_DeviceSpecHelpers.cxx      | 31 +++++++++----------
 .../Core/test/test_FrameworkDataFlowToDDS.cxx | 16 +++++-----
 .../test_FrameworkDataFlowToO2Control.cxx     |  8 ++---
 .../Core/test/test_WorkflowSerialization.cxx  | 10 +++---
 5 files changed, 32 insertions(+), 34 deletions(-)

diff --git a/Framework/Core/test/test_DataAllocator.cxx b/Framework/Core/test/test_DataAllocator.cxx
index acdae51cab8e9..fefb6438b98d5 100644
--- a/Framework/Core/test/test_DataAllocator.cxx
+++ b/Framework/Core/test/test_DataAllocator.cxx
@@ -73,7 +73,6 @@ DataProcessorSpec getSourceSpec()
 {
   static_assert(enable_root_serialization<o2::test::Polymorphic>::value, "enable_root_serialization<o2::test::Polymorphic> must be true");
   auto processingFct = [](ProcessingContext& pc) {
-    static int counter = 0;
     o2::test::TriviallyCopyable a(42, 23, 0xdead);
     o2::test::Polymorphic b(0xbeef);
     std::vector<o2::test::Polymorphic> c{{0xaffe}, {0xd00f}};
diff --git a/Framework/Core/test/test_DeviceSpecHelpers.cxx b/Framework/Core/test/test_DeviceSpecHelpers.cxx
index 6240e784d09d3..4184be848c5ec 100644
--- a/Framework/Core/test/test_DeviceSpecHelpers.cxx
+++ b/Framework/Core/test/test_DeviceSpecHelpers.cxx
@@ -16,7 +16,6 @@
 #include "Framework/DriverConfig.h"
 #include "../src/DeviceSpecHelpers.h"
 #include <catch_amalgamated.hpp>
-#include <algorithm>
 #include <sstream>
 #include <cstring>
 #include <vector>
@@ -67,10 +66,10 @@ void check(const std::vector<std::string>& arguments,
   std::vector<DataProcessorInfo> dataProcessorInfos;
   for (auto& [name, _] : matrix) {
     dataProcessorInfos.push_back(DataProcessorInfo{
-      name,
-      "executable-name",
-      arguments,
-      workflowOptions,
+      .name = name,
+      .executable = "executable-name",
+      .cmdLineArgs = arguments,
+      .workflowOptions = workflowOptions,
     });
   }
   DriverConfig driverConfig{};
@@ -184,7 +183,7 @@ TEST_CASE("CheckOptionReworking")
 {
   {
     std::vector<DataProcessorInfo> infos = {
-      {{}, {}, {"--driver-client-backend", "foo"}},
+      {.cmdLineArgs = {"--driver-client-backend", "foo"}},
       {}};
     DeviceSpecHelpers::reworkHomogeneousOption(infos, "--driver-client-backend", "stdout://");
     REQUIRE(infos[0].cmdLineArgs[1] == "foo");
@@ -192,30 +191,30 @@ TEST_CASE("CheckOptionReworking")
   }
   {
     std::vector<DataProcessorInfo> infos = {
-      {{}, {}, {"--driver-client-backend", "foo"}},
-      {{}, {}, {"--driver-client-backend", "bar"}}};
+      {.cmdLineArgs = {"--driver-client-backend", "foo"}},
+      {.cmdLineArgs = {"--driver-client-backend", "bar"}}};
     REQUIRE_THROWS_AS(DeviceSpecHelpers::reworkHomogeneousOption(infos, "--driver-client-backend", "stdout://"), o2::framework::RuntimeErrorRef);
   }
   {
     std::vector<DataProcessorInfo> infos = {
-      {{}, {}, {"--driver-client-backend", "foo"}},
-      {{}, {}, {"--driver-client-backend", "foo"}}};
+      {.cmdLineArgs = {"--driver-client-backend", "foo"}},
+      {.cmdLineArgs = {"--driver-client-backend", "foo"}}};
     DeviceSpecHelpers::reworkHomogeneousOption(infos, "--driver-client-backend", "stdout://");
     REQUIRE(infos[0].cmdLineArgs[1] == "foo");
     REQUIRE(infos[1].cmdLineArgs[1] == "foo");
   }
   {
     std::vector<DataProcessorInfo> infos = {
-      {{}, {}, {"foo", "bar"}},
-      {{}, {}, {"fnjcnak", "foo"}}};
+      {.cmdLineArgs = {"foo", "bar"}},
+      {.cmdLineArgs = {"fnjcnak", "foo"}}};
     DeviceSpecHelpers::reworkHomogeneousOption(infos, "--driver-client-backend", "stdout://");
     REQUIRE(infos[0].cmdLineArgs[3] == "stdout://");
     REQUIRE(infos[1].cmdLineArgs[3] == "stdout://");
   }
   {
     std::vector<DataProcessorInfo> infos = {
-      {{}, {}, {"foo", "bar", "--driver-client-backend", "bar"}},
-      {{}, {}, {"fnjcnak", "foo"}}};
+      {.cmdLineArgs = {"foo", "bar", "--driver-client-backend", "bar"}},
+      {.cmdLineArgs = {"fnjcnak", "foo"}}};
     DeviceSpecHelpers::reworkHomogeneousOption(infos, "--driver-client-backend", "stdout://");
     REQUIRE(infos[0].cmdLineArgs[3] == "bar");
     REQUIRE(infos[1].cmdLineArgs[3] == "bar");
@@ -277,8 +276,8 @@ TEST_CASE("CheckIntegerReworking")
   }
   {
     std::vector<DataProcessorInfo> infos = {
-      {{}, {}, {"foo", "bar", "--readers", "3"}},
-      {{}, {}, {"--readers", "2"}}};
+      {.cmdLineArgs = {"foo", "bar", "--readers", "3"}},
+      {.cmdLineArgs = {"--readers", "2"}}};
     DeviceSpecHelpers::reworkIntegerOption(
       infos, "--readers", []() { return 1; }, 1, [](long long x, long long y) { return x > y ? x : y; });
     REQUIRE(infos[0].cmdLineArgs.size() == 4);
diff --git a/Framework/Core/test/test_FrameworkDataFlowToDDS.cxx b/Framework/Core/test/test_FrameworkDataFlowToDDS.cxx
index 593728696e77a..dd3b2eb80d253 100644
--- a/Framework/Core/test/test_FrameworkDataFlowToDDS.cxx
+++ b/Framework/Core/test/test_FrameworkDataFlowToDDS.cxx
@@ -142,10 +142,10 @@ TEST_CASE("TestDDS")
 
   std::vector<DataProcessorInfo> dataProcessorInfos = {
     {
-      {"A", "bcsadc/foo", {}, workflowOptions},
-      {"B", "foo", {}, workflowOptions},
-      {"C", "foo", {}, workflowOptions},
-      {"D", "foo", {}, workflowOptions},
+      {.name = "A", .executable = "bcsadc/foo", .workflowOptions = workflowOptions},
+      {.name = "B", .executable = "foo", .workflowOptions = workflowOptions},
+      {.name = "C", .executable = "foo", .workflowOptions = workflowOptions},
+      {.name = "D", .executable = "foo", .workflowOptions = workflowOptions},
     }};
   DriverConfig driverConfig = {
     .batch = true,
@@ -406,10 +406,10 @@ TEST_CASE("TestDDSExpendable")
 
   std::vector<DataProcessorInfo> dataProcessorInfos = {
     {
-      {"A", "bcsadc/foo", {}, workflowOptions},
-      {"B", "foo", {}, workflowOptions},
-      {"C", "foo", {}, workflowOptions},
-      {"D", "foo", {}, workflowOptions},
+      {.name = "A", .executable = "bcsadc/foo", .workflowOptions = workflowOptions},
+      {.name = "B", .executable = "foo", .workflowOptions = workflowOptions},
+      {.name = "C", .executable = "foo", .workflowOptions = workflowOptions},
+      {.name = "D", .executable = "foo", .workflowOptions = workflowOptions},
     }};
   DriverConfig driverConfig = {
     .batch = true,
diff --git a/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx b/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
index d5f402aa16caa..9cdbc357f9674 100644
--- a/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
+++ b/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
@@ -561,10 +561,10 @@ TEST_CASE("TestO2ControlDump")
 
   std::vector<DataProcessorInfo> dataProcessorInfos = {
     {
-      {"A", "bcsadc/foo", {}, workflowOptions},
-      {"B", "foo", {}, workflowOptions},
-      {"C", "foo", {}, workflowOptions},
-      {"D", "foo", {}, workflowOptions},
+      {.name = "A", .executable = "bcsadc/foo", .workflowOptions = workflowOptions},
+      {.name = "B", .executable = "foo", .workflowOptions = workflowOptions},
+      {.name = "C", .executable = "foo", .workflowOptions = workflowOptions},
+      {.name = "D", .executable = "foo", .workflowOptions = workflowOptions},
     }};
 
   DriverConfig driverConfig{
diff --git a/Framework/Core/test/test_WorkflowSerialization.cxx b/Framework/Core/test/test_WorkflowSerialization.cxx
index 6e541f7d22f07..298956970713d 100644
--- a/Framework/Core/test/test_WorkflowSerialization.cxx
+++ b/Framework/Core/test/test_WorkflowSerialization.cxx
@@ -52,10 +52,10 @@ TEST_CASE("TestVerifyWorkflowSerialization")
                                     {{"key1", "v\"al'1"}, {"", "val2"}, {"key3", ""}, {"", ""}}}};
 
   std::vector<DataProcessorInfo> dataProcessorInfoOut{
-    {"A", "test_Framework_test_SerializationWorkflow", {"foo"}, {ConfigParamSpec{"aBool", VariantType::Bool, true, {"A Bool"}}}},
-    {"B", "test_Framework_test_SerializationWorkflow", {"b-bar", "bfoof", "fbdbfaso"}},
-    {"C", "test_Framework_test_SerializationWorkflow", {}},
-    {"D", "test_Framework_test_SerializationWorkflow", {}},
+    {.name = "A", .executable = "test_Framework_test_SerializationWorkflow", .cmdLineArgs = {"foo"}, .workflowOptions = {ConfigParamSpec{"aBool", VariantType::Bool, true, {"A Bool"}}}},
+    {.name = "B", .executable = "test_Framework_test_SerializationWorkflow", .cmdLineArgs = {"b-bar", "bfoof", "fbdbfaso"}},
+    {.name = "C", .executable = "test_Framework_test_SerializationWorkflow"},
+    {.name = "D", .executable = "test_Framework_test_SerializationWorkflow"},
   };
 
   CommandInfo commandInfoOut{"o2-dpl-workflow -b --option 1 --option 2"};
@@ -94,7 +94,7 @@ TEST_CASE("TestVerifyWildcard")
     }};
 
   std::vector<DataProcessorInfo> dataProcessorInfoOut{
-    {"A", "test_Framework_test_SerializationWorkflow", {}},
+    {.name = "A", .executable = "test_Framework_test_SerializationWorkflow"},
   };
 
   CommandInfo commandInfoOut{"o2-dpl-workflow -b --option 1 --option 2"};

From f882cd3f686a6dba7bc0993aca3e936b63f8cd96 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 20 Mar 2025 18:57:56 +0100
Subject: [PATCH 0117/1764] GPU Standalone: Modernize CMake, get rid of legacy
 include_directories(...) and add_definitions(...)

---
 GPU/GPUTracking/CMakeLists.txt                |  54 ++++---
 .../Standalone/Benchmark/CMakeLists.txt       |   2 +
 GPU/GPUTracking/Standalone/CMakeLists.txt     | 150 ++++++++----------
 GPU/TPCFastTransformation/CMakeLists.txt      |   2 +
 4 files changed, 98 insertions(+), 110 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 5ce96d450f765..e69e11c91d157 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -262,6 +262,27 @@ string(REPLACE ".cxx" ".h" HDRS_TMP "${SRCS_DATATYPES}")
 set(HDRS_CINT_DATATYPES ${HDRS_CINT_DATATYPES} ${HDRS_TMP})
 unset(HDRS_TMP)
 
+set(INCDIRS
+    ${CMAKE_CURRENT_SOURCE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/Definitions
+    ${CMAKE_CURRENT_SOURCE_DIR}/DataTypes
+    ${CMAKE_CURRENT_SOURCE_DIR}/Base
+    ${CMAKE_CURRENT_SOURCE_DIR}/SectorTracker
+    ${CMAKE_CURRENT_SOURCE_DIR}/TPCConvert
+    ${CMAKE_CURRENT_SOURCE_DIR}/dEdx
+    ${CMAKE_CURRENT_SOURCE_DIR}/ITS
+    ${CMAKE_CURRENT_SOURCE_DIR}/TRDTracking
+    ${CMAKE_CURRENT_SOURCE_DIR}/qa
+    ${CMAKE_CURRENT_SOURCE_DIR}/Global
+    ${CMAKE_CURRENT_SOURCE_DIR}/HLTHeaders
+    ${CMAKE_CURRENT_SOURCE_DIR}/Interface
+    ${CMAKE_CURRENT_SOURCE_DIR}/Merger
+    ${CMAKE_CURRENT_SOURCE_DIR}/Refit
+    ${CMAKE_CURRENT_SOURCE_DIR}/Debug
+    ${CMAKE_CURRENT_SOURCE_DIR}/DataCompression
+    ${CMAKE_CURRENT_SOURCE_DIR}/TPCClusterFinder
+    ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
+
 # Main CMake part for O2
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   o2_add_library(GPUDataTypes
@@ -297,25 +318,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                                        O2::DetectorsRaw
                                        O2::Steer
                                        O2::ML
-                 PUBLIC_INCLUDE_DIRECTORIES .
-                                            Definitions
-                                            DataTypes
-                                            Base
-                                            SectorTracker
-                                            TPCConvert
-                                            dEdx
-                                            ITS
-                                            TRDTracking
-                                            qa
-                                            Global
-                                            HLTHeaders
-                                            Interface
-                                            Merger
-                                            Refit
-                                            Debug
-                                            DataCompression
-                                            TPCClusterFinder
-                                            ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly
+                 PUBLIC_INCLUDE_DIRECTORIES ${INCDIRS}
                  SOURCES ${SRCS} ${SRCS_NO_CINT} ${SRCS_NO_H})
 
   target_include_directories(
@@ -349,15 +352,18 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   add_library(${MODULE} SHARED ${SRCS} ${SRCS_NO_CINT} ${SRCS_NO_H} ${SRCS_DATATYPES})
   set(targetName ${MODULE})
   add_library(O2::${MODULE} ALIAS ${MODULE})
-  install(TARGETS ${MODULE})
+  install(TARGETS ${targetName})
+  target_link_libraries(${targetName} PUBLIC TPCFastTransformation)
+  target_include_directories(${targetName} PUBLIC ${INCDIRS})
 
   if(GPUCA_CONFIG_ROOT)
-    ROOT_GENERATE_DICTIONARY(G__${MODULE} ${HDRS_CINT_O2} ${HDRS_CINT_DATATYPES} ${HDRS_CINT_O2_ADDITIONAL} GPUTrackingLinkDef_Standalone.h)
-    target_sources(${MODULE} PRIVATE G__${MODULE})
+    ROOT_GENERATE_DICTIONARY(G__${targetName} ${HDRS_CINT_O2} ${HDRS_CINT_DATATYPES} ${HDRS_CINT_O2_ADDITIONAL} GPUTrackingLinkDef_Standalone.h MODULE ${targetName})
     INSTALL(FILES
-      ${CMAKE_CURRENT_BINARY_DIR}/lib${MODULE}_rdict.pcm
-      ${CMAKE_CURRENT_BINARY_DIR}/lib${MODULE}.rootmap
+      ${CMAKE_CURRENT_BINARY_DIR}/lib${targetName}_rdict.pcm
+      ${CMAKE_CURRENT_BINARY_DIR}/lib${targetName}.rootmap
     DESTINATION .)
+  else()
+    target_compile_definitions(${targetName} PRIVATE GPUCA_NO_ROOT)
   endif()
 endif()
 
diff --git a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
index de2d683036193..e418d94b62cb2 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
@@ -27,6 +27,8 @@ endif()
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
     add_executable(ca ${SRCS})
     set(targetName ca)
+    target_link_libraries(${targetName} PUBLIC GPUTracking)
+
 endif()
 
 target_compile_definitions(${targetName} PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 5ed511173f53e..cf5a447c26669 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -80,7 +80,6 @@ if(GPUCA_CONFIG_VC)
   find_package(Vc REQUIRED)
 else()
   set(Vc_FOUND OFF)
-  add_definitions(-DGPUCA_NO_VC)
 endif()
 
 if(GPUCA_BUILD_EVENT_DISPLAY)
@@ -111,118 +110,97 @@ else()
   set(OpenGL_FOUND OFF)
 endif()
 
-if(GPUCA_CONFIG_O2)
-  add_definitions(-DGPUCA_TPC_GEOMETRY_O2)
-endif()
-
 if(GPUCA_CONFIG_ROOT)
   find_package(ROOT CONFIG REQUIRED)
-else()
-  add_definitions(-DGPUCA_NO_ROOT)
 endif()
 find_package(Microsoft.GSL REQUIRED HINTS "$ENV{MS_GSL_ROOT}/share/cmake")
 
 if(GPUCA_CONFIG_FMT)
   find_package(fmt REQUIRED HINTS $ENV{FMT_ROOT})
 else()
-  add_definitions(-DGPUCA_NO_FMT)
+  set(fmt_FOUND OFF)
 endif()
 
 # Detect GPU Backends
 find_package(O2GPU)
 
-# Global include directories
-include_directories(${GPU_DIR}/Common
-                    ${GPU_DIR}/Utils
-                    ${GPU_DIR}/TPCFastTransformation
-                    ${GPUTRACKING_DIR}
-                    ${GPUTRACKING_DIR}/Debug
-                    ${GPUTRACKING_DIR}/Definitions
-                    ${GPUTRACKING_DIR}/DataTypes
-                    ${GPUTRACKING_DIR}/Base
-                    ${GPUTRACKING_DIR}/dEdx
-                    ${GPUTRACKING_DIR}/TPCConvert
-                    ${GPUTRACKING_DIR}/Global
-                    ${GPUTRACKING_DIR}/HLTHeaders
-                    ${GPUTRACKING_DIR}/Merger
-                    ${GPUTRACKING_DIR}/Refit
-                    ${GPUTRACKING_DIR}/qa
-                    ${GPUTRACKING_DIR}/SectorTracker
-                    ${GPUTRACKING_DIR}/DataCompression
-                    ${GPUTRACKING_DIR}/TRDTracking
-                    ${GPUTRACKING_DIR}/TPCClusterFinder
-                    ${GPUTRACKING_DIR}/ITS
-                    ${GPUTRACKING_DIR}/Interface
-                    ${O2_DIR}/Common/Field/include
-                    ${O2_DIR}/Common/Constants/include
-                    ${O2_DIR}/Common/MathUtils/include
-                    ${O2_DIR}/Common/Utils/include
-                    ${O2_DIR}/DataFormats/common/include
-                    ${O2_DIR}/DataFormats/Detectors/Common/include
-                    ${O2_DIR}/DataFormats/Detectors/ITSMFT/common/include
-                    ${O2_DIR}/DataFormats/Detectors/ITSMFT/ITS/include
-                    ${O2_DIR}/DataFormats/Detectors/TOF/include
-                    ${O2_DIR}/DataFormats/Detectors/TPC/include
-                    ${O2_DIR}/DataFormats/Detectors/TRD/include
-                    ${O2_DIR}/DataFormats/Headers/include
-                    ${O2_DIR}/DataFormats/MemoryResources/include
-                    ${O2_DIR}/DataFormats/Reconstruction/include
-                    ${O2_DIR}/DataFormats/Reconstruction/src
-                    ${O2_DIR}/DataFormats/simulation/include
-                    ${O2_DIR}/Detectors/Base/include
-                    ${O2_DIR}/Detectors/Base/src
-                    ${O2_DIR}/Detectors/ITSMFT/common/base/include
-                    ${O2_DIR}/Detectors/ITSMFT/ITS/base/include
-                    ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/include
-                    ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/GPU
-                    ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/GPU/cuda
-                    ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/GPU/hip
-                    ${O2_DIR}/Detectors/Raw/include
-                    ${O2_DIR}/Detectors/TOF/base/include
-                    ${O2_DIR}/Detectors/TPC/base/include
-                    ${O2_DIR}/Detectors/TRD/base/include
-                    ${O2_DIR}/Detectors/TRD/base/src
-                    ${O2_DIR}/Framework/Foundation/3rdparty/include)
-
 # Create main targets
 add_subdirectory(../../ GPU)
-add_library(standalone_support SHARED ${GPUTRACKING_DIR}/utils/EmptyFile.cxx)
+add_library(standalone_support SHARED ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
+            ${O2_DIR}/DataFormats/Detectors/TPC/src/CompressedClusters.cxx
+            ${O2_DIR}/DataFormats/simulation/src/MCCompLabel.cxx
+            ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
+            ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+            ${O2_DIR}/DataFormats/Reconstruction/src/Vertex.cxx
+            ${O2_DIR}/DataFormats/Reconstruction/src/TrackLTIntegral.cxx
+            ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
+            ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+            ${O2_DIR}/Detectors/TRD/base/src/GeometryBase.cxx
+            ${O2_DIR}/Detectors/Base/src/MatLayerCylSet.cxx
+            ${O2_DIR}/Detectors/Base/src/MatLayerCyl.cxx
+            ${O2_DIR}/Detectors/Base/src/Ray.cxx
+            ${O2_DIR}/Detectors/Base/src/Propagator.cxx
+            ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/Road.cxx)
+
 target_compile_definitions(standalone_support PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
+target_include_directories(standalone_support PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,INCLUDE_DIRECTORIES>)
+
+target_include_directories(standalone_support PUBLIC
+                           ${GPU_DIR}/Common
+                           ${GPU_DIR}/Utils
+                           ${O2_DIR}/Common/Field/include
+                           ${O2_DIR}/Common/Constants/include
+                           ${O2_DIR}/Common/MathUtils/include
+                           ${O2_DIR}/Common/Utils/include
+                           ${O2_DIR}/DataFormats/common/include
+                           ${O2_DIR}/DataFormats/Detectors/Common/include
+                           ${O2_DIR}/DataFormats/Detectors/ITSMFT/common/include
+                           ${O2_DIR}/DataFormats/Detectors/ITSMFT/ITS/include
+                           ${O2_DIR}/DataFormats/Detectors/TOF/include
+                           ${O2_DIR}/DataFormats/Detectors/TPC/include
+                           ${O2_DIR}/DataFormats/Detectors/TRD/include
+                           ${O2_DIR}/DataFormats/Headers/include
+                           ${O2_DIR}/DataFormats/MemoryResources/include
+                           ${O2_DIR}/DataFormats/Reconstruction/include
+                           ${O2_DIR}/DataFormats/Reconstruction/src
+                           ${O2_DIR}/DataFormats/simulation/include
+                           ${O2_DIR}/Detectors/Base/include
+                           ${O2_DIR}/Detectors/Base/src
+                           ${O2_DIR}/Detectors/ITSMFT/common/base/include
+                           ${O2_DIR}/Detectors/ITSMFT/ITS/base/include
+                           ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/include
+                           ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/GPU
+                           ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/GPU/cuda
+                           ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/GPU/hip
+                           ${O2_DIR}/Detectors/Raw/include
+                           ${O2_DIR}/Detectors/TOF/base/include
+                           ${O2_DIR}/Detectors/TPC/base/include
+                           ${O2_DIR}/Detectors/TRD/base/include
+                           ${O2_DIR}/Detectors/TRD/base/src
+                           ${O2_DIR}/Framework/Foundation/3rdparty/include)
 
 target_link_libraries(standalone_support PUBLIC#
                       dl
                       pthread
-                      Microsoft.GSL::GSL
-                      TPCFastTransformation)
-target_link_libraries(GPUTracking PUBLIC TPCFastTransformation standalone_support)
-target_link_libraries(ca PUBLIC GPUTracking)
-
-# Add all sources and dependencies to to support based on Config File
-target_sources(standalone_support PRIVATE
-               ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
-               ${O2_DIR}/DataFormats/Detectors/TPC/src/CompressedClusters.cxx
-               ${O2_DIR}/DataFormats/simulation/src/MCCompLabel.cxx
-               ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
-               ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
-               ${O2_DIR}/DataFormats/Reconstruction/src/Vertex.cxx
-               ${O2_DIR}/DataFormats/Reconstruction/src/TrackLTIntegral.cxx
-               ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
-               ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
-               ${O2_DIR}/Detectors/TRD/base/src/GeometryBase.cxx
-               ${O2_DIR}/Detectors/Base/src/MatLayerCylSet.cxx
-               ${O2_DIR}/Detectors/Base/src/MatLayerCyl.cxx
-               ${O2_DIR}/Detectors/Base/src/Ray.cxx
-               ${O2_DIR}/Detectors/Base/src/Propagator.cxx
-               ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/Road.cxx)
+                      Microsoft.GSL::GSL)
+
+target_link_libraries(GPUTracking PUBLIC standalone_support)
+target_link_libraries(TPCFastTransformation PUBLIC standalone_support)
+
+if(GPUCA_CONFIG_O2)
+  target_compile_definitions(GPUTracking PRIVATE GPUCA_TPC_GEOMETRY_O2)
+endif()
 
 if(GPUCA_CONFIG_FMT)
   target_link_libraries(standalone_support PUBLIC fmt::fmt)
-  target_link_libraries(TPCFastTransformation PUBLIC fmt::fmt)
+else()
+  target_compile_definitions(standalone_support PUBLIC GPUCA_NO_FMT)
 endif()
 
 if(GPUCA_CONFIG_VC)
   target_link_libraries(standalone_support PUBLIC Vc::Vc)
-  target_link_libraries(TPCFastTransformation PUBLIC Vc::Vc)
+else()
+  target_compile_definitions(standalone_support PUBLIC GPUCA_NO_VC)
 endif()
 
 if(GPUCA_CONFIG_ROOT)
diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index 133bf35281b55..c7869467d15b5 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -119,6 +119,8 @@ endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   add_library(${MODULE} SHARED ${SRCS})
+  set(targetName ${MODULE})
+  target_include_directories(${targetName} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
 install (FILES macro/TPCFastTransformInit.C

From 4f0674122bb8903ad679dbc4e0456687857d9977 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 22 Mar 2025 20:15:59 +0100
Subject: [PATCH 0118/1764] GPU CMake: remove unnecessary compile definitions

---
 GPU/Common/CMakeLists.txt | 2 --
 GPU/Utils/CMakeLists.txt  | 2 --
 2 files changed, 4 deletions(-)

diff --git a/GPU/Common/CMakeLists.txt b/GPU/Common/CMakeLists.txt
index bacf4454c39fd..efac4fc436758 100644
--- a/GPU/Common/CMakeLists.txt
+++ b/GPU/Common/CMakeLists.txt
@@ -37,8 +37,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                              PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}>
                                     $<INSTALL_INTERFACE:include/GPU>)
 
-  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2)
-
   # cuda test, only compile if CUDA
   if(CUDA_ENABLED)
     o2_add_test(GPUsortCUDA NAME test_GPUsortCUDA
diff --git a/GPU/Utils/CMakeLists.txt b/GPU/Utils/CMakeLists.txt
index 01ca3eb59c029..bf23c792c2034 100644
--- a/GPU/Utils/CMakeLists.txt
+++ b/GPU/Utils/CMakeLists.txt
@@ -31,7 +31,5 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                             HEADERS ${HDRS_CINT}
                             LINKDEF GPUUtilsLinkDef.h)
 
-  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2)
-
   install(FILES ${HDRS_CINT} ${HDRS_INSTALL} DESTINATION include/GPU)
 endif()

From 66174ae4805cb78c453c771dd1b24221380c2093 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 22 Mar 2025 20:31:19 +0100
Subject: [PATCH 0119/1764] GPU Standalone: Fix compilation without FMT

---
 GPU/GPUTracking/Definitions/GPULogging.h  | 2 +-
 GPU/GPUTracking/Standalone/CMakeLists.txt | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPULogging.h b/GPU/GPUTracking/Definitions/GPULogging.h
index 4ad6b70b2fd8b..c8ba635d1af7a 100644
--- a/GPU/GPUTracking/Definitions/GPULogging.h
+++ b/GPU/GPUTracking/Definitions/GPULogging.h
@@ -69,7 +69,7 @@
     #define GPUCritical(...) GPUWarning(__VA_ARGS__)
     #define GPUFatal(string, ...)                  \
       {                                            \
-        fprintf(stderr, string "\n", __VA_ARGS__); \
+        fprintf(stderr, string "\n", ##__VA_ARGS__); \
         exit(1);                                   \
       }
   #endif
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index cf5a447c26669..5a39f082f2bbd 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -128,7 +128,6 @@ find_package(O2GPU)
 add_subdirectory(../../ GPU)
 add_library(standalone_support SHARED ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
             ${O2_DIR}/DataFormats/Detectors/TPC/src/CompressedClusters.cxx
-            ${O2_DIR}/DataFormats/simulation/src/MCCompLabel.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/Vertex.cxx

From 0c4029015067d8f381ec76d1d5dd612556f8b7a5 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 22 Mar 2025 20:33:14 +0100
Subject: [PATCH 0120/1764] GPU: Fix incorrect printf syntax

---
 GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx       | 2 +-
 GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index a48050a6cacbc..4047dcae0a6b3 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -124,7 +124,7 @@ void GPUChainTracking::TPCClusterizerEnsureZSOffsets(uint32_t iSector, const CfF
     }
 
     if (pagesEndpoint != nPagesExpected) {
-      GPUFatal("Sector %d, Endpoint %d, Fragment %d: TPC raw page count mismatch: expected %d / buffered %lu", iSector, endpoint, fragment.index, pagesEndpoint, nPagesExpected);
+      GPUFatal("Sector %d, Endpoint %d, Fragment %d: TPC raw page count mismatch: expected %d / buffered %u", iSector, endpoint, fragment.index, pagesEndpoint, nPagesExpected);
     }
 
     if (nAdcDecoded != nAdcsExpected) {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 38e1cd0036c16..c42d9622f5332 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -258,13 +258,13 @@ void GPUChainTracking::SanityCheck()
     const auto& ref = trk.getClusterRef();
     if (ref.getFirstEntry() > mIOPtrs.nOutputClusRefsTPCO2) {
       if (nErrors++ < 1000) {
-        GPUError("Invalid getFirst() entry in cluster reference: %u > $u", ref.getFirstEntry(), mIOPtrs.nOutputClusRefsTPCO2);
+        GPUError("Invalid getFirst() entry in cluster reference: %u > %u", ref.getFirstEntry(), mIOPtrs.nOutputClusRefsTPCO2);
         continue;
       }
     }
     if (ref.getFirstEntry() + (ref.getEntries() * 3 + 1) / 2 > mIOPtrs.nOutputClusRefsTPCO2) {
       if (nErrors++ < 1000) {
-        GPUError("Invalid getEntries() entry in cluster reference: %u > $u", ref.getFirstEntry() + (ref.getEntries() * 3 + 1) / 2, mIOPtrs.nOutputClusRefsTPCO2);
+        GPUError("Invalid getEntries() entry in cluster reference: %u > %u", ref.getFirstEntry() + (ref.getEntries() * 3 + 1) / 2, mIOPtrs.nOutputClusRefsTPCO2);
         continue;
       }
     }

From 8df4ac28e698bd5294e442367a89e9d71bd0b48a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 22 Mar 2025 20:41:33 +0100
Subject: [PATCH 0121/1764] GPU Standalone: Add CMake check to require ROOT if
 building event display

---
 GPU/GPUTracking/Standalone/CMakeLists.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 5a39f082f2bbd..1f48b4fc5ade1 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -112,6 +112,8 @@ endif()
 
 if(GPUCA_CONFIG_ROOT)
   find_package(ROOT CONFIG REQUIRED)
+elseif(GPUCA_BUILD_EVENT_DISPLAY)
+  message(FATAL_ERROR "Cannot build event display without ROOT")
 endif()
 find_package(Microsoft.GSL REQUIRED HINTS "$ENV{MS_GSL_ROOT}/share/cmake")
 

From ee497d7867e8f9893dfa6437f2ebf483c7a3687c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 23 Mar 2025 19:30:12 +0100
Subject: [PATCH 0122/1764] GPU CMake: Shuffle stuff a bit and move all
 NO_FAST_MATH stuff to GPU/... and FindO2GPU.cmake

---
 GPU/CMakeLists.txt                |  1 -
 dependencies/FindO2GPU.cmake      | 26 +++++++++++++++-----------
 dependencies/O2CompileFlags.cmake |  7 -------
 3 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/GPU/CMakeLists.txt b/GPU/CMakeLists.txt
index 3c83c583eebfc..75cd5eddc0b24 100644
--- a/GPU/CMakeLists.txt
+++ b/GPU/CMakeLists.txt
@@ -16,7 +16,6 @@
 if(NOT DEFINED GPUCA_NO_FAST_MATH)
   set(GPUCA_NO_FAST_MATH 0)
 endif()
-set(GPUCA_CXX_NO_FAST_MATH_FLAGS "-fno-fast-math -ffp-contract=off")
 if(${GPUCA_NO_FAST_MATH})
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
 endif()
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index f8d41c032078f..69241ea30a375 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -64,9 +64,20 @@ function(set_target_hip_arch target)
   endif()
 endfunction()
 
-# Detect and enable CUDA
-STRING(REGEX REPLACE "\-std=[^ ]*" "" O2_GPU_CMAKE_CXX_FLAGS_NOSTD "${CMAKE_CXX_FLAGS}") # Need to strip c++17 imposed by alidist defaults
+# Need to strip c++17 imposed by alidist defaults
+STRING(REGEX REPLACE "\-std=[^ ]*" "" O2_GPU_CMAKE_CXX_FLAGS_NOSTD "${CMAKE_CXX_FLAGS}")
 
+# ---------------------------------- Fast Math / Deterministic Mode ----------------------------------
+if(GPUCA_NO_FAST_MATH_WHOLEO2)
+  set(GPUCA_NO_FAST_MATH 1)
+  add_definitions(-DGPUCA_NO_FAST_MATH)
+  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -fno-fast-math -ffp-contract=off")
+  set(CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -fno-fast-math -ffp-contract=off")
+endif()
+set(GPUCA_CXX_NO_FAST_MATH_FLAGS "-fno-fast-math -ffp-contract=off")
+set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--ftz=false --prec-div=true --prec-sqrt=true --fmad false")
+
+# ---------------------------------- CUDA ----------------------------------
 if(ENABLE_CUDA)
   set(CMAKE_CUDA_STANDARD ${CMAKE_CXX_STANDARD})
   set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)
@@ -124,7 +135,6 @@ if(ENABLE_CUDA)
     else()
       set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -Xptxas -O4 -Xcompiler -O4")
     endif()
-    set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--ftz=false --prec-div=true --prec-sqrt=true --fmad false")
     if(DEFINED GPUCA_NO_FAST_MATH AND "${GPUCA_NO_FAST_MATH}")
       set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CUDA_NO_FAST_MATH_FLAGS}")
     elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
@@ -146,7 +156,7 @@ if(ENABLE_CUDA)
   endif()
 endif()
 
-# Detect and enable OpenCL 1.2 from AMD
+# ---------------------------------- HIP ----------------------------------
 if(ENABLE_OPENCL)
   find_package(OpenCL)
   if(ENABLE_OPENCL AND NOT ENABLE_OPENCL STREQUAL "AUTO")
@@ -154,11 +164,6 @@ if(ENABLE_OPENCL)
   else()
     set_package_properties(OpenCL PROPERTIES TYPE OPTIONAL)
   endif()
-endif()
-
-# Detect and enable OpenCL 2.x
-if(ENABLE_OPENCL)
-  find_package(OpenCL)
   find_package(LLVM)
   if(LLVM_FOUND)
     find_package(Clang)
@@ -196,7 +201,7 @@ if(ENABLE_OPENCL)
   endif()
 endif()
 
-# Detect and enable HIP
+# ---------------------------------- HIP ----------------------------------
 if(ENABLE_HIP)
   if(NOT "$ENV{CMAKE_PREFIX_PATH}" MATCHES "rocm" AND NOT CMAKE_PREFIX_PATH MATCHES "rocm" AND EXISTS "/opt/rocm/lib/cmake/")
     list(APPEND CMAKE_PREFIX_PATH "/opt/rocm/lib/cmake")
@@ -303,7 +308,6 @@ if(ENABLE_HIP)
     endif()
     message(FATAL_ERROR "HIP requested but some of the above packages are not found")
   endif()
-
 endif()
 
 # if we end up here without a FATAL, it means we have found the "O2GPU" package
diff --git a/dependencies/O2CompileFlags.cmake b/dependencies/O2CompileFlags.cmake
index 08dd388cbdf36..eeddc189e8897 100644
--- a/dependencies/O2CompileFlags.cmake
+++ b/dependencies/O2CompileFlags.cmake
@@ -138,11 +138,4 @@ if(DEFINED ENV{O2_CXXFLAGS_OVERRIDE})
   message(STATUS "Setting CXXFLAGS Override $ENV{O2_CXXFLAGS_OVERRIDE}")
 endif()
 
-if(GPUCA_NO_FAST_MATH_WHOLEO2)
-  set(GPUCA_NO_FAST_MATH 1)
-  add_definitions(-DGPUCA_NO_FAST_MATH)
-  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -fno-fast-math -ffp-contract=off")
-  set(CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -fno-fast-math -ffp-contract=off")
-endif()
-
 message(STATUS "Using build type: ${CMAKE_BUILD_TYPE} - CXXFLAGS: ${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")

From e836e3fd219c12a40b306065d893680585d5aebf Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 23 Mar 2025 20:56:42 +0100
Subject: [PATCH 0123/1764] GPU: Replace GPUCA_NO_FAST_MATH by more fine-grain
 GPUCA_DETERMINISTIC_MODE

---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  |  4 +--
 GPU/CMakeLists.txt                            |  7 -----
 GPU/Common/GPUCommonMath.h                    |  6 ++--
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  4 +--
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  2 +-
 GPU/GPUTracking/Base/opencl/CMakeLists.txt    |  4 +--
 GPU/GPUTracking/CMakeLists.txt                | 15 ++++++----
 .../Definitions/GPUDefGPUParameters.h         |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 24 +++++++--------
 GPU/GPUTracking/Standalone/CMakeLists.txt     | 10 +------
 GPU/GPUTracking/Standalone/cmake/config.cmake | 16 +++++-----
 dependencies/FindO2GPU.cmake                  | 30 ++++++++++++++-----
 13 files changed, 66 insertions(+), 60 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index ce93523319e99..a66eba7c3bacb 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -43,7 +43,7 @@
 #define THRUST_NAMESPACE thrust::hip
 #endif
 
-#ifdef GPUCA_NO_FAST_MATH
+#ifdef GPUCA_DETERMINISTIC_MODE
 #define GPU_BLOCKS 1
 #define GPU_THREADS 1
 #else
@@ -1452,4 +1452,4 @@ template void processNeighboursHandler<7>(const int startLayer,
                                           const o2::base::PropagatorF::MatCorrType matCorrType,
                                           const int nBlocks,
                                           const int nThreads);
-} // namespace o2::its
\ No newline at end of file
+} // namespace o2::its
diff --git a/GPU/CMakeLists.txt b/GPU/CMakeLists.txt
index 75cd5eddc0b24..7e2b797ae714f 100644
--- a/GPU/CMakeLists.txt
+++ b/GPU/CMakeLists.txt
@@ -13,13 +13,6 @@
 # CMake, variables are defined for Sources / Headers first. Then, the actual
 # CMake build scripts use these variables.
 
-if(NOT DEFINED GPUCA_NO_FAST_MATH)
-  set(GPUCA_NO_FAST_MATH 0)
-endif()
-if(${GPUCA_NO_FAST_MATH})
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
-endif()
-
 add_subdirectory(Common)
 add_subdirectory(Utils)
 add_subdirectory(TPCFastTransformation)
diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index c412662fc0c64..b7a44c1df0f38 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -250,7 +250,7 @@ GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
 #endif
 }
 
-#ifdef GPUCA_NO_FAST_MATH
+#ifdef GPUCA_DETERMINISTIC_MODE
 GPUdi() constexpr float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), roundf(x), round(x)); }
 GPUdi() constexpr int32_t GPUCommonMath::Float2IntRn(float x) { return (int32_t)Round(x); }
 GPUhdi() constexpr float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), (float)sqrt((double)x), sqrt(x)); }
@@ -286,7 +286,7 @@ GPUdi() constexpr bool GPUCommonMath::IsNaN(float x) { return false; }
 
 GPUhdi() void GPUCommonMath::SinCos(float x, float& s, float& c)
 {
-#if defined(GPUCA_NO_FAST_MATH) && !defined(__OPENCL__)
+#if defined(GPUCA_DETERMINISTIC_MODE) && !defined(__OPENCL__)
   s = sin((double)x);
   c = cos((double)x);
 #elif !defined(GPUCA_GPUCODE_DEVICE) && defined(__APPLE__)
@@ -392,7 +392,7 @@ GPUdi() T GPUCommonMath::MaxWithRef(T x, T y, T z, T w, S refX, S refY, S refZ,
 
 GPUdi() float GPUCommonMath::InvSqrt(float _x)
 {
-#if defined(GPUCA_NO_FAST_MATH) || defined(__OPENCL__)
+#if defined(GPUCA_DETERMINISTIC_MODE) || defined(__OPENCL__)
   return 1.f / Sqrt(_x);
 #elif defined(__CUDACC__) || defined(__HIPCC__)
   return __frsqrt_rn(_x);
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 8bae1df267412..5582084fd0e17 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -261,8 +261,8 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     mProcessingSettings.deterministicGPUReconstruction = mProcessingSettings.debugLevel >= 6;
   }
   if (mProcessingSettings.deterministicGPUReconstruction) {
-#ifndef GPUCA_NO_FAST_MATH
-    GPUError("Warning, deterministicGPUReconstruction needs GPUCA_NO_FAST_MATH for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
+#ifndef GPUCA_DETERMINISTIC_MODE
+    GPUError("Warning, deterministicGPUReconstruction needs GPUCA_DETERMINISTIC_MODE for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
 #endif
     mProcessingSettings.overrideClusterizerFragmentLen = TPC_MAX_FRAGMENT_LEN_GPU;
     param().rec.tpc.nWaysOuter = true;
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 5b2e53179e50c..f8203c2dc5858 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -172,7 +172,7 @@ elseif(GPUCA_CUDA_COMPILE_MODE STREQUAL "perkernel")
                               TARGET_DIRECTORY ${targetName}
                               PROPERTIES
                               COMPILE_FLAGS "${GPUCA_CUDA_NO_FAST_MATH_FLAGS}"
-                              COMPILE_DEFINITIONS "GPUCA_NO_FAST_MATH")
+                              COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
 elseif(GPUCA_CUDA_COMPILE_MODE STREQUAL "rdc")
   message(FATAL_ERROR "CUDA RDC compilation of GPUReconstruction ios not yet working!")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=2)
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 21a641c0cc7c0..fee43eb6d8b0d 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -230,7 +230,7 @@ elseif(GPUCA_HIP_COMPILE_MODE STREQUAL "perkernel")
                               TARGET_DIRECTORY ${targetName}
                               PROPERTIES
                               COMPILE_FLAGS "${GPUCA_CXX_NO_FAST_MATH_FLAGS}"
-                              COMPILE_DEFINITIONS "GPUCA_NO_FAST_MATH")
+                              COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
 elseif(GPUCA_HIP_COMPILE_MODE STREQUAL "rdc")
   message(FATAL_ERROR "HIP RDC compilation of GPUReconstruction ios not yet working!")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=2)
diff --git a/GPU/GPUTracking/Base/opencl/CMakeLists.txt b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
index 89d2f386f768f..3da5b77f80d86 100644
--- a/GPU/GPUTracking/Base/opencl/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
@@ -24,10 +24,10 @@ set(CL_SRC ${GPUDIR}/Base/opencl/GPUReconstructionOCL.cl)
 set(CL_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCLCode)
 
 set(OCL_FLAGS -Dcl_clang_storage_class_specifiers -cl-std=CLC++2021)
-if(NOT DEFINED GPUCA_NO_FAST_MATH OR NOT ${GPUCA_NO_FAST_MATH})
+if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
   set(OCL_FLAGS ${OCL_FLAGS} -cl-denorms-are-zero -cl-mad-enable -cl-no-signed-zeros -cl-fast-relaxed-math)
 else()
-set(OCL_FLAGS ${OCL_FLAGS} -cl-fp32-correctly-rounded-divide-sqrt)
+  set(OCL_FLAGS ${OCL_FLAGS} -cl-fp32-correctly-rounded-divide-sqrt)
 endif()
 set(OCL_DEFINECL "-D$<JOIN:$<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>,$<SEMICOLON>-D>"
             "-I$<JOIN:$<FILTER:$<TARGET_PROPERTY:O2::GPUTracking,INCLUDE_DIRECTORIES>,EXCLUDE,^/usr/include/?>,$<SEMICOLON>-I>"
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index e69e11c91d157..dedfcf5953394 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -14,8 +14,13 @@ set(MODULE GPUTracking)
 # set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O0") # to uncomment if needed, tired of typing this...
 # set(GPUCA_BUILD_DEBUG 1)
 
-if(NOT "${GPUCA_NO_FAST_MATH}" AND NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math")
+if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
+  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
+  if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_OPTO2})
+    set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O2")
+  endif()
+elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
+  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O3 -ffast-math")
 endif()
 
 include(cmake/helpers.cmake)
@@ -375,7 +380,7 @@ set_source_files_properties(DataCompression/GPUTPCCompressionTrackModel.cxx
                             TARGET_DIRECTORY ${targetName}
                             PROPERTIES
                             COMPILE_FLAGS "${GPUCA_CXX_NO_FAST_MATH_FLAGS}"
-                            COMPILE_DEFINITIONS "GPUCA_NO_FAST_MATH")
+                            COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
 
 # GPUReconstructionLibrary needs to know which GPU backends are enabled for proper error messages
 configure_file(Base/GPUReconstructionAvailableBackends.template.h ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionAvailableBackends.h)
@@ -417,6 +422,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2" OR ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   endif()
 endif()
 
-if(${GPUCA_NO_FAST_MATH})
-  target_compile_definitions(${targetName} PUBLIC GPUCA_NO_FAST_MATH)
+if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_GPU})
+  target_compile_definitions(${targetName} PUBLIC GPUCA_DETERMINISTIC_MODE)
 endif()
diff --git a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
index 55f2e76344bd5..6d6645850408f 100644
--- a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
+++ b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
@@ -566,7 +566,7 @@
 #ifndef GPUCA_MERGER_INTERPOLATION_ERROR_TYPE
 #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
 #endif
-#ifdef GPUCA_NO_FAST_MATH
+#ifdef GPUCA_DETERMINISTIC_MODE
 #undef GPUCA_MERGER_INTERPOLATION_ERROR_TYPE
 #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
 #undef GPUCA_DEDX_STORAGE_TYPE
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index eb1df3f37b6b5..5ede29d7fd851 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -723,13 +723,13 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThrea
 
   if (iThread == 0) {
     if (iBlock == 0) {
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
       GPUCommonAlgorithm::sortDeviceDynamic(range1, range1 + N1, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return (a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId); });
 #else
       GPUCommonAlgorithm::sortDeviceDynamic(range1, range1 + N1, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return a.fMin < b.fMin; });
 #endif
     } else if (iBlock == 1) {
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
       GPUCommonAlgorithm::sortDeviceDynamic(range2, range2 + N2, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return (a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId); });
 #else
       GPUCommonAlgorithm::sortDeviceDynamic(range2, range2 + N2, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return a.fMax < b.fMax; });
@@ -749,7 +749,7 @@ namespace // anonymous
 struct MergeBorderTracks_compMax {
   GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
   {
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
     return (a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId);
 #else
     return a.fMax < b.fMax;
@@ -759,7 +759,7 @@ struct MergeBorderTracks_compMax {
 struct MergeBorderTracks_compMin {
   GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
   {
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
     return (a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId);
 #else
     return a.fMin < b.fMin;
@@ -906,7 +906,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThrea
 
     mTrackLinks[b1.TrackID()] = iBest2;
     if (mergeMode > 0) {
-#if defined(GPUCA_NO_FAST_MATH) // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
       CAMath::AtomicMax(&mTrackLinks[iBest2], b1.TrackID());
 #else
       mTrackLinks[iBest2] = b1.TrackID();
@@ -1469,7 +1469,7 @@ struct GPUTPCGMMerger_CompareClusterIdsLooper {
     if (a1.row != b1.row) {
       return ((a1.row > b1.row) ^ ((a.leg - leg) & 1) ^ outwards);
     }
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
     if (a1.id != b1.id) {
       return (a1.id > b1.id);
     }
@@ -1490,7 +1490,7 @@ struct GPUTPCGMMerger_CompareClusterIds {
     if (a.row != b.row) {
       return (a.row > b.row);
     }
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
     if (a.id != b.id) {
       return (a.id > b.id);
     }
@@ -1569,7 +1569,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     // unpack and sort clusters
     if (nParts > 1 && leg == 0) {
       GPUCommonAlgorithm::sort(trackParts, trackParts + nParts, [](const GPUTPCGMSectorTrack* a, const GPUTPCGMSectorTrack* b) {
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
         if (a->X() != b->X()) {
           return (a->X() > b->X());
         }
@@ -1834,7 +1834,7 @@ struct GPUTPCGMMergerSortTracks_comp {
     if (a.Legs() != b.Legs()) {
       return a.Legs() > b.Legs();
     }
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
     if (a.NClusters() != b.NClusters()) {
       return a.NClusters() > b.NClusters();
     }
@@ -1858,7 +1858,7 @@ struct GPUTPCGMMergerSortTracksQPt_comp {
   {
     const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
     const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
     if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
       return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
     }
@@ -1907,7 +1907,7 @@ GPUd() void GPUTPCGMMerger::SortTracks(int32_t nBlocks, int32_t nThreads, int32_
     if (a.Legs() != b.Legs()) {
       return a.Legs() > b.Legs();
     }
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
     if (a.NClusters() != b.NClusters()) {
       return a.NClusters() > b.NClusters();
     }
@@ -1937,7 +1937,7 @@ GPUd() void GPUTPCGMMerger::SortTracksQPt(int32_t nBlocks, int32_t nThreads, int
   auto comp = [cmp = mOutputTracks](const int32_t aa, const int32_t bb) {
     const GPUTPCGMMergedTrack& GPUrestrict() a = cmp[aa];
     const GPUTPCGMMergedTrack& GPUrestrict() b = cmp[bb];
-#ifdef GPUCA_NO_FAST_MATH // TODO: Use a better define as swith
+#ifdef GPUCA_DETERMINISTIC_MODE
     if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
       return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
     }
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 1f48b4fc5ade1..ed4fc5c9f7e2d 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -52,15 +52,7 @@ if(GPUCA_BUILD_DEBUG)
   set(CMAKE_CXX_FLAGS "-O0 -ggdb")
   set(CMAKE_BUILD_TYPE DEBUG)
 else()
-  set(CMAKE_CXX_FLAGS "-O3 -march=native -ggdb -minline-all-stringops -funroll-loops -fno-stack-protector")
-  if(DEFINED GPUCA_NO_FAST_MATH AND ${GPUCA_NO_FAST_MATH})
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-fast-math -ffp-contract=off")
-  else()
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ffast-math")
-  endif()
-  if (NOT CMAKE_CXX_COMPILER STREQUAL "clang++")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftracer -fprefetch-loop-arrays")
-  endif()
+  set(CMAKE_CXX_FLAGS "-O3 -march=native -ggdb")
   set(CMAKE_BUILD_TYPE RELEASE)
   add_definitions(-DNDEBUG)
 endif()
diff --git a/GPU/GPUTracking/Standalone/cmake/config.cmake b/GPU/GPUTracking/Standalone/cmake/config.cmake
index 87716d700abc8..af7c96bb96fbb 100644
--- a/GPU/GPUTracking/Standalone/cmake/config.cmake
+++ b/GPU/GPUTracking/Standalone/cmake/config.cmake
@@ -27,13 +27,13 @@ set(GPUCA_CONFIG_GL3W 0)
 set(GPUCA_CONFIG_O2 1)
 set(GPUCA_BUILD_DEBUG 0)
 set(GPUCA_BUILD_DEBUG_SANITIZE 0)
-set(GPUCA_NO_FAST_MATH 0)
-#set(GPUCA_CUDA_GCCBIN c++-13)
-#set(GPUCA_OPENCL_CLANGBIN clang-18)
-#set(HIP_AMDGPUTARGET "gfx906;gfx908;gfx90a")
-set(HIP_AMDGPUTARGET "default")
-#set(CUDA_COMPUTETARGET 86 89)
-set(CUDA_COMPUTETARGET "default")
-#set(GPUCA_CUDA_COMPILE_MODE perkernel)
+set(GPUCA_DETERMINISTIC_MODE 0)             # OFF / NO_FAST_MATH / OPTO2 / GPU / WHOLEO2
+#set(GPUCA_CUDA_GCCBIN c++-14)
+#set(GPUCA_OPENCL_CLANGBIN clang-19)
+set(HIP_AMDGPUTARGET "default")             # "gfx906;gfx908;gfx90a"
+set(CUDA_COMPUTETARGET "default")           # 86 89
+#set(GPUCA_CUDA_COMPILE_MODE perkernel)     # onefile / perkernel / rtc
 #set(GPUCA_HIP_COMPILE_MODE perkernel)
 #set(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE 1)
+#set(GPUCA_CONFIG_COMPILER gcc)             # gcc / clang
+#add_definitions(-DGPUCA_GPU_DEBUG_PRINT)
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 69241ea30a375..650a269209d9b 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -68,14 +68,30 @@ endfunction()
 STRING(REGEX REPLACE "\-std=[^ ]*" "" O2_GPU_CMAKE_CXX_FLAGS_NOSTD "${CMAKE_CXX_FLAGS}")
 
 # ---------------------------------- Fast Math / Deterministic Mode ----------------------------------
-if(GPUCA_NO_FAST_MATH_WHOLEO2)
-  set(GPUCA_NO_FAST_MATH 1)
-  add_definitions(-DGPUCA_NO_FAST_MATH)
-  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -fno-fast-math -ffp-contract=off")
-  set(CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -fno-fast-math -ffp-contract=off")
+# set(GPUCA_DETERMINISTIC_MODE WHOLEO2)          # Override
+set(GPUCA_DETERMINISTIC_MODE_MAP_OFF 0)
+set(GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH 1) # No -ffast-math and similar compile flags for GPU folder
+set(GPUCA_DETERMINISTIC_MODE_MAP_OPTO2 2)        # In addition, -O2 optimization on host for GPU folder
+set(GPUCA_DETERMINISTIC_MODE_MAP_GPU 3)          # In addition, GPUCA_DETERMINISTIC_MODE define for GPU folder
+set(GPUCA_DETERMINISTIC_MODE_MAP_ON 3)           # Synonym for GPU
+set(GPUCA_DETERMINISTIC_MODE_MAP_WHOLEO2 4)      # As GPU but for whole O2 code
+if(NOT DEFINED GPUCA_DETERMINISTIC_MODE)
+  set(GPUCA_DETERMINISTIC_MODE 0)
+elseif(NOT GPUCA_DETERMINISTIC_MODE MATCHES "^[0-9]+$")
+  if(NOT DEFINED GPUCA_DETERMINISTIC_MODE_MAP_${GPUCA_DETERMINISTIC_MODE})
+    message(FATAL_ERROR "Invalid setting ${GPUCA_DETERMINISTIC_MODE} for GPUCA_DETERMINISTIC_MODE")
+  endif()
+  set(GPUCA_DETERMINISTIC_MODE ${GPUCA_DETERMINISTIC_MODE_MAP_${GPUCA_DETERMINISTIC_MODE}})
+  message(STATUS "Set to ${GPUCA_DETERMINISTIC_MODE}")
 endif()
 set(GPUCA_CXX_NO_FAST_MATH_FLAGS "-fno-fast-math -ffp-contract=off")
 set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--ftz=false --prec-div=true --prec-sqrt=true --fmad false")
+if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_WHOLEO2})
+  add_definitions(-DGPUCA_DETERMINISTIC_MODE)
+  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
+  set(CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
+endif()
+
 
 # ---------------------------------- CUDA ----------------------------------
 if(ENABLE_CUDA)
@@ -135,7 +151,7 @@ if(ENABLE_CUDA)
     else()
       set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -Xptxas -O4 -Xcompiler -O4")
     endif()
-    if(DEFINED GPUCA_NO_FAST_MATH AND "${GPUCA_NO_FAST_MATH}")
+    if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
       set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CUDA_NO_FAST_MATH_FLAGS}")
     elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
       set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -use_fast_math --ftz=true")#
@@ -274,7 +290,7 @@ if(ENABLE_HIP)
     if(HIP_AMDGPUTARGET)
       set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}") # If GPU build is enforced we override autodetection
     endif()
-    if(NOT DEFINED GPUCA_NO_FAST_MATH OR NOT ${GPUCA_NO_FAST_MATH})
+    if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
       string(APPEND O2_HIP_CMAKE_CXX_FLAGS " -fgpu-flush-denormals-to-zero -ffast-math")
     endif()
     set(CMAKE_HIP_FLAGS "${O2_GPU_CMAKE_CXX_FLAGS_NOSTD} ${CMAKE_HIP_FLAGS} ${O2_HIP_CMAKE_CXX_FLAGS}")

From b6ad4bc54e104ec8842eb77cfed4af2edbda6d85 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 13:26:00 +0100
Subject: [PATCH 0124/1764] DPL: Print error in case we receive data with bogus
 runNumber / tfCounter

---
 Framework/Core/src/ExternalFairMQDeviceProxy.cxx | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index 823ef8f5fd5a0..52e0413d48dab 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -493,6 +493,12 @@ InjectorFunction dplModelAdaptor(std::vector<OutputSpec> const& filterSpecs, DPL
       }
     }
 
+    int fmqRunNumber = -1;
+    try {
+      fmqRunNumber = atoi(device->fConfig->GetProperty<std::string>("runNumber", "").c_str());
+    } catch (...) {
+    }
+
     for (int msgidx = 0; msgidx < parts.Size(); msgidx += 2) {
       if (parts.At(msgidx).get() == nullptr) {
         LOG(error) << "unexpected nullptr found. Skipping message pair.";
@@ -521,6 +527,9 @@ InjectorFunction dplModelAdaptor(std::vector<OutputSpec> const& filterSpecs, DPL
       timingInfo.runNumber = dh->runNumber;
       timingInfo.tfCounter = dh->tfCounter;
       LOG(debug) << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();
+      if (dh->runNumber == 0 || dh->tfCounter == 0 || (fmqRunNumber > 0 && fmqRunNumber != dh->runNumber)) {
+        LOG(error) << "INVALID runNumber / tfCounter: runNumber " << dh->runNumber << ", tfCounter " << dh->tfCounter << ", FMQ runNumber " << fmqRunNumber;
+      }
 
       OutputSpec query{dh->dataOrigin, dh->dataDescription, dh->subSpecification};
       LOG(debug) << "processing " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " time slice " << dph->startTime << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts;

From b83452a140d60b615fe88ee156f6311abe7aa72d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 13:26:34 +0100
Subject: [PATCH 0125/1764] GPU: Can insert marker earlier, no need to wait

---
 GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 6c79d87e50465..36a947dda9dc3 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -32,8 +32,8 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSecto
   }
   uint32_t n = withinSector == -1 ? NSECTORS / 2 : NSECTORS;
   if (GetProcessingSettings().alternateBorderSort && (!mRec->IsGPU() || doGPU)) {
-    TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResMemory(), 0, &mEvents->init);
     RecordMarker(&mEvents->single, 0);
+    TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResMemory(), 0, &mEvents->init);
     for (uint32_t i = 0; i < n; i++) {
       int32_t stream = i % mRec->NStreams();
       runKernel<GPUTPCGMMergerMergeBorders, 0>({GetGridAuto(stream, deviceType), krnlRunRangeNone, {nullptr, stream && i < (uint32_t)mRec->NStreams() ? &mEvents->single : nullptr}}, i, withinSector, mergeMode);

From fe2f93e7e42de2fcfbefd55a7e4246e85bd6813c Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 24 Mar 2025 18:26:21 +0100
Subject: [PATCH 0126/1764] Fix method MCTrackInfo::getNITSClusCont

---
 .../GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx
index 92107d90b48ed..204e0c741a675 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx
@@ -25,7 +25,9 @@ int MCTrackInfo::getNITSClusCont() const
   int longest = 0, current = 0;
   for (int i = 0; i < 7; i++) {
     if (pattITSCl & (0x1 << i)) {
-      longest = ++current;
+      if (++current > longest) {
+        longest = current;
+      }
     } else {
       current = 0;
     }

From e7d0f6ad02eb19bc6dab981b65bfa838234c865f Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Mon, 24 Mar 2025 17:40:10 +0100
Subject: [PATCH 0127/1764] ALICE3: Fix TRKConfigParam dictionary creation

---
 Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt   | 3 ++-
 .../ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h      | 8 ++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
index 856fd310fe5a2..a1cb0279efef8 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
@@ -30,4 +30,5 @@ o2_target_root_dictionary(TRKSimulation
                                   include/TRKSimulation/TRKServices.h
                                   include/TRKSimulation/TRKPetalCase.h
                                   include/TRKSimulation/TRKPetalLayer.h
-                                  include/TRKSimulation/TRKPetalDisk.h)
\ No newline at end of file
+                                  include/TRKSimulation/TRKPetalDisk.h
+                                  include/TRKSimulation/DPLDigitizerParam.h)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
index 876810b5bef9d..d80027593cef0 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
@@ -24,9 +24,9 @@
 #pragma link C++ class o2::base::DetImpl < o2::trk::Detector> + ;
 #pragma link C++ class o2::trk::Digitizer + ;
 
-// #pragma link C++ class o2::itsmft::DPLDigitizerParam < o2::detectors::DetID::ITS> + ;
-// #pragma link C++ class o2::itsmft::DPLDigitizerParam < o2::detectors::DetID::ITS> + ;
-// #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::DPLDigitizerParam < o2::detectors::DetID::TRK>> + ;
-// #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::DPLDigitizerParam < o2::detectors::DetID::FT3>> + ;
+#pragma link C++ class o2::trk::DPLDigitizerParam < o2::detectors::DetID::TRK> + ;
+#pragma link C++ class o2::trk::DPLDigitizerParam < o2::detectors::DetID::FT3> + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::DPLDigitizerParam < o2::detectors::DetID::TRK>> + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::DPLDigitizerParam < o2::detectors::DetID::FT3>> + ;
 
 #endif

From a31999e1aca0bd85c649a4995011a7317013a227 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 24 Mar 2025 15:48:44 +0100
Subject: [PATCH 0128/1764] Make ITS reco start layer configurable

---
 .../ITS/tracking/include/ITStracking/TrackingConfigParam.h     | 1 +
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx        | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index ec96321765534..cb6512248bf0c 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -62,6 +62,7 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   bool useFastMaterial = false; // use faster material approximation for material budget accounting in the fits.
   int deltaRof = 0;             // configure the width of the window in ROFs to be considered for the tracking.
   int minTrackLgtIter[MaxIter] = {};                                        // minimum track length at each iteration, used only if >0, otherwise use code defaults
+  uint8_t startLayerMask[MaxIter] = {};                                     // mask of start layer for this iteration (if >0)
   float minPtIterLgt[MaxIter * (MaxTrackLength - MinTrackLength + 1)] = {}; // min.pT for given track length at this iteration, used only if >0, otherwise use code defaults
   float sysErrY2[7] = {0};      // systematic error^2 in Y per layer
   float sysErrZ2[7] = {0};      // systematic error^2 in Z per layer
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 2c94c9bdb1f46..613402ce56e97 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -78,6 +78,9 @@ void ITSTrackingInterface::initialise()
       param.TrackletsPerClusterLimit = 1.e3f;
       // check if something was overridden via configurable params
       if (ip < trackConf.MaxIter) {
+        if (trackConf.startLayerMask[ip] > 0) {
+          trackParams[2].StartLayerMask = trackConf.startLayerMask[ip];
+        }
         if (trackConf.minTrackLgtIter[ip] > 0) {
           param.MinTrackLength = trackConf.minTrackLgtIter[ip];
         }

From c2aa2f542ded67b6f2c3bde53111241675e90501 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 13:57:07 +0100
Subject: [PATCH 0129/1764] GPU: Remove hack to disable synchronization in
 thrust::sort, which was not working any more

---
 GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h | 24 ++-----------------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  8 +++----
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  2 +-
 3 files changed, 7 insertions(+), 27 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h b/GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h
index fdc5c16d91f35..676610b5e4c52 100644
--- a/GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h
+++ b/GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h
@@ -22,12 +22,12 @@
 namespace o2::gpu
 {
 
-class ThrustVolatileAsyncAllocator
+class ThrustVolatileAllocator
 {
  public:
   typedef char value_type;
 
-  ThrustVolatileAsyncAllocator(GPUReconstruction* r) : mRec(r) {}
+  ThrustVolatileAllocator(GPUReconstruction* r) : mRec(r) {}
   char* allocate(std::ptrdiff_t n) { return (char*)mRec->AllocateVolatileDeviceMemory(n); }
 
   void deallocate(char* ptr, size_t) {}
@@ -38,24 +38,4 @@ class ThrustVolatileAsyncAllocator
 
 } // namespace o2::gpu
 
-#ifndef __HIPCC__
-// Override synchronize call at end of thrust algorithm running on stream, just don't run cudaStreamSynchronize
-namespace thrust::cuda_cub
-{
-
-typedef thrust::cuda_cub::execution_policy<typeof(thrust::cuda::par(*(o2::gpu::ThrustVolatileAsyncAllocator*)nullptr).on(*(cudaStream_t*)nullptr))> thrustStreamPolicy;
-template <>
-__host__ __device__ inline cudaError_t synchronize<thrustStreamPolicy>(thrustStreamPolicy& policy)
-{
-#ifndef GPUCA_GPUCODE_DEVICE
-  // Do not synchronize!
-  return cudaSuccess;
-#else
-  return synchronize_stream(derived_cast(policy));
-#endif
-}
-
-} // namespace thrust::cuda_cub
-#endif // __HIPCC__
-
 #endif // GPU_CUDATHRUSTHELPERS_H
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 5ede29d7fd851..92ecd380fa38f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -773,7 +773,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
 {
   thrust::device_ptr<GPUTPCGMBorderRange> p(range);
-  ThrustVolatileAsyncAllocator alloc(this);
+  ThrustVolatileAllocator alloc(this);
   if (cmpMax) {
     thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), p, p + N, MergeBorderTracks_compMax());
   } else {
@@ -1878,7 +1878,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<uint32_t> trackSort((uint32_t*)mProcessorsShadow->tpcMerger.TrackOrderProcess());
-  ThrustVolatileAsyncAllocator alloc(this);
+  ThrustVolatileAllocator alloc(this);
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 
@@ -1886,7 +1886,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<uint32_t> trackSort((uint32_t*)mProcessorsShadow->tpcMerger.TrackSort());
-  ThrustVolatileAsyncAllocator alloc(this);
+  ThrustVolatileAllocator alloc(this);
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
@@ -2111,7 +2111,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<MergeLooperParam> params(mProcessorsShadow->tpcMerger.LooperCandidates());
-  ThrustVolatileAsyncAllocator alloc(this);
+  ThrustVolatileAllocator alloc(this);
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), params, params + processors()->tpcMerger.Memory()->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 13f204d0f940a..c366133bbae21 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -105,7 +105,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<GPUTPCGMMerger::tmpSort> trackSort(mProcessorsShadow->tpcMerger.TrackSortO2());
-  ThrustVolatileAsyncAllocator alloc(this);
+  ThrustVolatileAllocator alloc(this);
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracksTPCO2(), GPUTPCGMO2OutputSort_comp());
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::sort>

From d9b654e5df67ecd8b5a81aa3625f3c9bb6164261 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 14:28:46 +0100
Subject: [PATCH 0130/1764] GPU: Add getThrustVolatileDeviceAllocator function

---
 GPU/Common/GPUCommonHelpers.h                 | 19 +++++++++
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 10 +++++
 GPU/GPUTracking/Base/GPUReconstruction.h      |  2 +
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  2 +-
 GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h | 41 -------------------
 .../Base/cuda/GPUReconstructionCUDA.cu        |  1 -
 .../GPUReconstructionCUDAExternalProvider.cu  |  1 -
 .../cuda/GPUReconstructionCUDAHelpers.inc     |  7 ++++
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  1 -
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  4 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  8 ++--
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  3 +-
 12 files changed, 47 insertions(+), 52 deletions(-)
 delete mode 100644 GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h

diff --git a/GPU/Common/GPUCommonHelpers.h b/GPU/Common/GPUCommonHelpers.h
index 915d93c9bc791..2927ddab6bd0c 100644
--- a/GPU/Common/GPUCommonHelpers.h
+++ b/GPU/Common/GPUCommonHelpers.h
@@ -35,6 +35,7 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonLogger.h"
 #include <cstdint>
+#include <functional>
 
 namespace o2::gpu::internal
 {
@@ -60,4 +61,22 @@ static inline int32_t GPUReconstructionChkErr(const int64_t error, const char* f
 #undef GPUCOMMON_INTERNAL_CAT
 } // namespace o2::gpu::internal
 
+namespace o2::gpu
+{
+class GPUReconstruction;
+class ThrustVolatileAllocator
+{
+ public:
+  typedef char value_type;
+
+  char* allocate(std::ptrdiff_t n);
+  void deallocate(char* ptr, size_t);
+
+ private:
+  ThrustVolatileAllocator(GPUReconstruction* r);
+  std::function<char*(size_t)> mAlloc;
+  friend class GPUReconstruction;
+};
+} // namespace o2::gpu
+
 #endif
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 5582084fd0e17..d96d5aad74622 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -30,6 +30,7 @@
 #include "GPUROOTDumpCore.h"
 #include "GPUConfigDump.h"
 #include "GPUChainTracking.h"
+#include "GPUCommonHelpers.h"
 
 #include "GPUMemoryResource.h"
 #include "GPUChain.h"
@@ -1193,3 +1194,12 @@ void GPUReconstruction::SetInputControl(void* ptr, size_t size)
 {
   mInputControl.set(ptr, size);
 }
+
+ThrustVolatileAllocator::ThrustVolatileAllocator(GPUReconstruction* r)
+{
+  mAlloc = [&r](size_t n) { return (char*)r->AllocateVolatileDeviceMemory(n); };
+}
+ThrustVolatileAllocator GPUReconstruction::getThrustVolatileDeviceAllocator()
+{
+  return ThrustVolatileAllocator(this);
+}
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 5e03c77f08230..18098396e1349 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -47,6 +47,7 @@ struct GPUMemorySizeScalers;
 struct GPUReconstructionPipelineContext;
 struct GPUReconstructionThreading;
 class GPUROOTDumpCore;
+class ThrustVolatileAllocator;
 
 namespace gpu_reconstruction_kernels
 {
@@ -165,6 +166,7 @@ class GPUReconstruction
   void ClearAllocatedMemory(bool clearOutputs = true);
   void ReturnVolatileDeviceMemory();
   void ReturnVolatileMemory();
+  ThrustVolatileAllocator getThrustVolatileDeviceAllocator();
   void PushNonPersistentMemory(uint64_t tag);
   void PopNonPersistentMemory(RecoStep step, uint64_t tag);
   void BlockStackedMemory(GPUReconstruction* rec);
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index f8203c2dc5858..99c59afd2011a 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -18,7 +18,7 @@ endif()
 message(STATUS "Building GPUTracking with CUDA support ${TMP_TARGET}")
 
 set(SRCS GPUReconstructionCUDA.cu GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu)
-set(HDRS GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDADef.h GPUReconstructionCUDAIncludesHost.h CUDAThrustHelpers.h)
+set(HDRS GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDADef.h GPUReconstructionCUDAIncludesHost.h)
 # -------------------------------- Prepare RTC -------------------------------------------------------
 enable_language(ASM)
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
diff --git a/GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h b/GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h
deleted file mode 100644
index 676610b5e4c52..0000000000000
--- a/GPU/GPUTracking/Base/cuda/CUDAThrustHelpers.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file CUDAThrustHelpers.h
-/// \author David Rohr
-
-#ifndef GPU_CUDATHRUSTHELPERS_H
-#define GPU_CUDATHRUSTHELPERS_H
-
-#include "GPULogging.h"
-#include <vector>
-#include <memory>
-
-namespace o2::gpu
-{
-
-class ThrustVolatileAllocator
-{
- public:
-  typedef char value_type;
-
-  ThrustVolatileAllocator(GPUReconstruction* r) : mRec(r) {}
-  char* allocate(std::ptrdiff_t n) { return (char*)mRec->AllocateVolatileDeviceMemory(n); }
-
-  void deallocate(char* ptr, size_t) {}
-
- private:
-  GPUReconstruction* mRec;
-};
-
-} // namespace o2::gpu
-
-#endif // GPU_CUDATHRUSTHELPERS_H
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 202edd49bc44c..175fd205153ea 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -19,7 +19,6 @@
 
 #include "GPUReconstructionCUDA.h"
 #include "GPUReconstructionCUDAInternals.h"
-#include "CUDAThrustHelpers.h"
 #include "GPUReconstructionIncludes.h"
 #include "GPUParamRTC.h"
 #include "GPUReconstructionCUDAHelpers.inc"
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
index f341a778076b8..534f5e8606897 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
@@ -16,7 +16,6 @@
 
 #include "GPUReconstructionCUDA.h"
 #include "GPUReconstructionCUDAInternals.h"
-#include "CUDAThrustHelpers.h"
 
 #include <stdexcept>
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc
index a34f940a1337a..c2b6f6d05dd7f 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAHelpers.inc
@@ -16,6 +16,7 @@
 #define GPURECONSTRUCTIONCUDAHELPERS_INC_H
 
 #include "GPUCommonHelpers.h"
+#include "GPUReconstruction.h"
 
 namespace o2::gpu::internal
 {
@@ -28,4 +29,10 @@ int32_t __attribute__((weak)) GPUReconstructionCUDAChkErr(const int64_t error, c
 }
 } // namespace o2::gpu::internal
 
+namespace o2::gpu
+{
+char* __attribute__((weak)) ThrustVolatileAllocator::allocate(std::ptrdiff_t n) { return mAlloc(n); }
+void __attribute__((weak)) ThrustVolatileAllocator::deallocate(char* ptr, size_t) {}
+} // namespace o2::gpu
+
 #endif
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index 0c83223ba238a..f1f459fe021bc 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -16,7 +16,6 @@
 
 #include "GPUReconstructionCUDA.h"
 #include "GPUReconstructionCUDAInternals.h"
-#include "CUDAThrustHelpers.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index fee43eb6d8b0d..16e6e72d56e9a 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -24,7 +24,7 @@ message(STATUS "Building GPUTracking with HIP support ${TMP_TARGET}")
 if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   set(GPUCA_HIP_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/hipify)
   file(MAKE_DIRECTORY ${GPUCA_HIP_SOURCE_DIR})
-  set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDAkernel.template.cu CUDAThrustHelpers.h GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDArtc.cu)
+  set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDAkernel.template.cu GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDArtc.cu)
   set(GPUCA_HIP_LOCAL_FILE_LIST GPUReconstructionHIPIncludesHost.h)
   set(HIP_SOURCES "")
   foreach(file ${GPUCA_HIP_FILE_LIST})
@@ -63,7 +63,7 @@ endif()
 
 set(SRCS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.hip ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPKernels.hip)
 set(SRCS_CXX ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPGenRTC.cxx)
-set(HDRS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPInternals.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPHelpers.inc ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPDef.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPIncludesHost.h ${GPUCA_HIP_SOURCE_DIR}/HIPThrustHelpers.h)
+set(HDRS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPInternals.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPHelpers.inc ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPDef.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPIncludesHost.h)
 
 # -------------------------------- Prepare RTC -------------------------------------------------------
 enable_language(ASM)
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 92ecd380fa38f..c57ca9e5e1436 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -773,7 +773,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
 {
   thrust::device_ptr<GPUTPCGMBorderRange> p(range);
-  ThrustVolatileAllocator alloc(this);
+  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
   if (cmpMax) {
     thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), p, p + N, MergeBorderTracks_compMax());
   } else {
@@ -1878,7 +1878,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<uint32_t> trackSort((uint32_t*)mProcessorsShadow->tpcMerger.TrackOrderProcess());
-  ThrustVolatileAllocator alloc(this);
+  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 
@@ -1886,7 +1886,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<uint32_t> trackSort((uint32_t*)mProcessorsShadow->tpcMerger.TrackSort());
-  ThrustVolatileAllocator alloc(this);
+  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
@@ -2111,7 +2111,7 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<MergeLooperParam> params(mProcessorsShadow->tpcMerger.LooperCandidates());
-  ThrustVolatileAllocator alloc(this);
+  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), params, params + processors()->tpcMerger.Memory()->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index c366133bbae21..9594391163586 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -105,7 +105,8 @@ template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
 {
   thrust::device_ptr<GPUTPCGMMerger::tmpSort> trackSort(mProcessorsShadow->tpcMerger.TrackSortO2());
-  ThrustVolatileAllocator alloc(this);
+  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
+  ;
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracksTPCO2(), GPUTPCGMO2OutputSort_comp());
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::sort>

From ac0408b22dc8acdd41a64308de4a24b2a32b6264 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 15:14:02 +0100
Subject: [PATCH 0131/1764] GPU: Add GPUCommonAlgorithm::sortOnDevice function
 for starting sort on device from host

---
 GPU/Common/GPUCommonAlgorithm.h                |  4 ++++
 GPU/Common/GPUCommonAlgorithmThrust.h          |  8 ++++++++
 .../Base/cuda/GPUReconstructionCUDA.h          |  2 ++
 .../Global/GPUChainTrackingMerger.cxx          |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx      | 18 +++++-------------
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx    |  5 +----
 6 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/GPU/Common/GPUCommonAlgorithm.h b/GPU/Common/GPUCommonAlgorithm.h
index a733f0ff99f26..b82c0059b9e15 100644
--- a/GPU/Common/GPUCommonAlgorithm.h
+++ b/GPU/Common/GPUCommonAlgorithm.h
@@ -43,6 +43,10 @@ class GPUCommonAlgorithm
   GPUd() static void sortInBlock(T* begin, T* end, const S& comp);
   template <class T, class S>
   GPUd() static void sortDeviceDynamic(T* begin, T* end, const S& comp);
+#ifndef __OPENCL__
+  template <class T, class S>
+  GPUh() static void sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp);
+#endif
   template <class T>
   GPUd() static void swap(T& a, T& b);
 
diff --git a/GPU/Common/GPUCommonAlgorithmThrust.h b/GPU/Common/GPUCommonAlgorithmThrust.h
index 0208c12f1cd08..f37445ede9c84 100644
--- a/GPU/Common/GPUCommonAlgorithmThrust.h
+++ b/GPU/Common/GPUCommonAlgorithmThrust.h
@@ -87,6 +87,14 @@ GPUdi() void GPUCommonAlgorithm::sortDeviceDynamic(T* begin, T* end, const S& co
   thrust::sort(GPUCA_THRUST_NAMESPACE::par, thrustBegin, thrustEnd, comp);
 }
 
+template <class T, class S>
+GPUhi() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp)
+{
+  thrust::device_ptr<T> p(begin);
+  auto alloc = rec->getThrustVolatileDeviceAllocator();
+  thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(rec->mInternals->Streams[stream]), p, p + N, comp);
+}
+
 } // namespace gpu
 } // namespace o2
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index f78270d40146c..30bbc76d4c415 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -54,6 +54,8 @@ class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
 
   void getRTCKernelCalls(std::vector<std::string>& kernels);
 
+  template <class T, class S>
+  friend GPUh() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp);
   GPUReconstructionCUDAInternals* mInternals;
 };
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 36a947dda9dc3..8fba328f8ac38 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -121,7 +121,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   for (uint32_t i = 0; i < NSECTORS; i++) {
     runKernel<GPUTPCGMMergerUnpackSaveNumber>({{1, -WarpSize(), 0, deviceType}}, i);
     runKernel<GPUTPCGMMergerUnpackResetIds>(GetGridAuto(0, deviceType), i);
-    runKernel<GPUTPCGMMergerSectorRefit>(GetGridAuto(0, deviceType), i);
+    runKernel<GPUTPCGMMergerSectorRefit>(GetGridAuto(0, deviceType), i); // TODO: Why all in stream 0?
   }
   if (GetProcessingSettings().deterministicGPUReconstruction) {
     runKernel<GPUTPCGMMergerUnpackSaveNumber>({{1, -WarpSize(), 0, deviceType}}, NSECTORS);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index c57ca9e5e1436..c8c844eee748a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -772,12 +772,10 @@ struct MergeBorderTracks_compMin {
 template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
 {
-  thrust::device_ptr<GPUTPCGMBorderRange> p(range);
-  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
   if (cmpMax) {
-    thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), p, p + N, MergeBorderTracks_compMax());
+    GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, range, N, MergeBorderTracks_compMax());
   } else {
-    thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), p, p + N, MergeBorderTracks_compMin());
+    GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, range, N, MergeBorderTracks_compMin());
   }
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize MergeBorderTracks<3>
@@ -1877,17 +1875,13 @@ struct GPUTPCGMMergerSortTracksQPt_comp {
 template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
 {
-  thrust::device_ptr<uint32_t> trackSort((uint32_t*)mProcessorsShadow->tpcMerger.TrackOrderProcess());
-  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
-  thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 
 template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
 {
-  thrust::device_ptr<uint32_t> trackSort((uint32_t*)mProcessorsShadow->tpcMerger.TrackSort());
-  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
-  thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
 
@@ -2110,9 +2104,7 @@ struct GPUTPCGMMergerMergeLoopers_comp {
 template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
 {
-  thrust::device_ptr<MergeLooperParam> params(mProcessorsShadow->tpcMerger.LooperCandidates());
-  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
-  thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), params, params + processors()->tpcMerger.Memory()->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.LooperCandidates(), processors()->tpcMerger.Memory()->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 9594391163586..8056f22484e70 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -104,10 +104,7 @@ struct GPUTPCGMO2OutputSort_comp {
 template <>
 inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
 {
-  thrust::device_ptr<GPUTPCGMMerger::tmpSort> trackSort(mProcessorsShadow->tpcMerger.TrackSortO2());
-  ThrustVolatileAllocator alloc = getThrustVolatileDeviceAllocator();
-  ;
-  thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(mInternals->Streams[_xyz.x.stream]), trackSort, trackSort + processors()->tpcMerger.NOutputTracksTPCO2(), GPUTPCGMO2OutputSort_comp());
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSortO2(), processors()->tpcMerger.NOutputTracksTPCO2(), GPUTPCGMO2OutputSort_comp());
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::sort>
 

From 15df642b632fea3b9bf45a47b785d3eac54da262 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 15:34:16 +0100
Subject: [PATCH 0132/1764] GPU: Switch to C++11 nested namespace style in more
 places

---
 GPU/Common/GPUCommonAlgorithm.h       | 28 ++++++---------------------
 GPU/Common/GPUCommonAlgorithmThrust.h |  8 ++------
 GPU/Common/GPUCommonMath.h            |  7 ++-----
 GPU/Common/GPUCommonTransform3D.h     |  7 ++-----
 GPU/Common/GPUROOTCartesianFwd.h      |  7 ++-----
 GPU/Common/GPUROOTSMatrixFwd.h        |  7 ++-----
 6 files changed, 16 insertions(+), 48 deletions(-)

diff --git a/GPU/Common/GPUCommonAlgorithm.h b/GPU/Common/GPUCommonAlgorithm.h
index b82c0059b9e15..4970876f39e4c 100644
--- a/GPU/Common/GPUCommonAlgorithm.h
+++ b/GPU/Common/GPUCommonAlgorithm.h
@@ -24,9 +24,7 @@
 
 // ----------------------------- SORTING -----------------------------
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 class GPUCommonAlgorithm
 {
@@ -75,13 +73,6 @@ class GPUCommonAlgorithm
   template <typename I>
   GPUd() static void IterSwap(I a, I b) noexcept;
 };
-} // namespace gpu
-} // namespace o2
-
-namespace o2
-{
-namespace gpu
-{
 
 #ifndef GPUCA_ALGORITHM_STD
 template <typename I>
@@ -221,8 +212,7 @@ GPUdi() void GPUCommonAlgorithm::QuickSort(I f, I l) noexcept
 
 typedef GPUCommonAlgorithm CAAlgo;
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #if (((defined(__CUDACC__) && !defined(__clang__)) || defined(__HIPCC__))) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_HOSTONLY)
 
@@ -230,9 +220,7 @@ typedef GPUCommonAlgorithm CAAlgo;
 
 #else
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 template <class T>
@@ -251,15 +239,12 @@ GPUdi() void GPUCommonAlgorithm::sortDeviceDynamic(T* begin, T* end, const S& co
   GPUCommonAlgorithm::sort(begin, end, comp);
 }
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif // THRUST
 // sort and sortInBlock below are not taken from Thrust, since our implementations are faster
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 template <class T>
@@ -332,8 +317,7 @@ GPUdi() void GPUCommonAlgorithm::swap(T& a, T& b)
 }
 #endif
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 // ----------------------------- WORK GROUP FUNCTIONS -----------------------------
 
diff --git a/GPU/Common/GPUCommonAlgorithmThrust.h b/GPU/Common/GPUCommonAlgorithmThrust.h
index f37445ede9c84..2da4b6a4f965d 100644
--- a/GPU/Common/GPUCommonAlgorithmThrust.h
+++ b/GPU/Common/GPUCommonAlgorithmThrust.h
@@ -30,9 +30,7 @@
 #define GPUCA_THRUST_NAMESPACE thrust::hip
 #endif
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 // - Our quicksort and bubble sort implementations are faster
@@ -94,8 +92,6 @@ GPUhi() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begi
   auto alloc = rec->getThrustVolatileDeviceAllocator();
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(rec->mInternals->Streams[stream]), p, p + N, comp);
 }
-
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index b7a44c1df0f38..58f046161aa8b 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -42,9 +42,7 @@
     #define GPUCA_CHOICE(c1, c2, c3) (c1) // Select first option for Host
 #endif // clang-format on
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 class GPUCommonMath
@@ -540,7 +538,6 @@ GPUdii() void GPUCommonMath::AtomicMinInternal(GPUglobalref() GPUgeneric() GPUAt
 
 #undef GPUCA_CHOICE
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif // GPUCOMMONMATH_H
diff --git a/GPU/Common/GPUCommonTransform3D.h b/GPU/Common/GPUCommonTransform3D.h
index 4c5cca1f00ddc..2f517aded7eed 100644
--- a/GPU/Common/GPUCommonTransform3D.h
+++ b/GPU/Common/GPUCommonTransform3D.h
@@ -17,9 +17,7 @@
 
 #include "GPUCommonDef.h"
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 class Transform3D
 {
@@ -79,7 +77,6 @@ class Transform3D
                                 kZZ = 10,
                                 kDZ = 11 };
 };
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Common/GPUROOTCartesianFwd.h b/GPU/Common/GPUROOTCartesianFwd.h
index 89b0aa44eb78c..c631637a3bc6e 100644
--- a/GPU/Common/GPUROOTCartesianFwd.h
+++ b/GPU/Common/GPUROOTCartesianFwd.h
@@ -46,9 +46,7 @@ class DefaultCoordinateSystemTag;
 } // namespace Math
 } // namespace ROOT
 
-namespace o2
-{
-namespace math_utils
+namespace o2::math_utils
 {
 
 namespace detail
@@ -79,7 +77,6 @@ template <typename T>
 using Vector3D = detail::GPUPoint3D<T, 1>;
 #endif
 
-} // namespace math_utils
-} // namespace o2
+} // namespace o2::math_utils
 
 #endif
diff --git a/GPU/Common/GPUROOTSMatrixFwd.h b/GPU/Common/GPUROOTSMatrixFwd.h
index 44b2254949df2..0159cc8922140 100644
--- a/GPU/Common/GPUROOTSMatrixFwd.h
+++ b/GPU/Common/GPUROOTSMatrixFwd.h
@@ -35,9 +35,7 @@ class MatRepStd;
 } // namespace Math
 } // namespace ROOT
 
-namespace o2
-{
-namespace math_utils
+namespace o2::math_utils
 {
 
 namespace detail
@@ -72,7 +70,6 @@ template <class T, uint32_t D1, uint32_t D2 = D1>
 using MatRepStd = detail::MatRepStdGPU<T, D1, D2>;
 #endif
 
-} // namespace math_utils
-} // namespace o2
+} // namespace o2::math_utils
 
 #endif

From 30efe2e219398cdefbac4ea06d431b140d042bed Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 13:56:25 +0100
Subject: [PATCH 0133/1764] GPUCommonAlgorithm: Cleanup preprocessor defines

---
 GPU/Common/GPUCommonAlgorithm.h       | 4 ++++
 GPU/Common/GPUCommonAlgorithmThrust.h | 4 +++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/GPU/Common/GPUCommonAlgorithm.h b/GPU/Common/GPUCommonAlgorithm.h
index 4970876f39e4c..5c19dda27f593 100644
--- a/GPU/Common/GPUCommonAlgorithm.h
+++ b/GPU/Common/GPUCommonAlgorithm.h
@@ -446,4 +446,8 @@ GPUdi() T warp_broadcast(T v, int32_t i)
 
 #endif
 
+#ifdef GPUCA_ALGORITHM_STD
+#undef GPUCA_ALGORITHM_STD
+#endif
+
 #endif
diff --git a/GPU/Common/GPUCommonAlgorithmThrust.h b/GPU/Common/GPUCommonAlgorithmThrust.h
index 2da4b6a4f965d..6bf605a370050 100644
--- a/GPU/Common/GPUCommonAlgorithmThrust.h
+++ b/GPU/Common/GPUCommonAlgorithmThrust.h
@@ -52,7 +52,7 @@ GPUdi() void GPUCommonAlgorithm::sort(T* begin, T* end, const S& comp)
 }
 
 template <class T>
-GPUdi() void GPUCommonAlgorithm::sortInBlock(T* begin, T* end)
+GPUdi() void GPUCommonAlgorithm::sortInBlock(T* begin, T* end) // TODO: Try cub::BlockMergeSort
 {
   if (get_local_id(0) == 0) {
     sortDeviceDynamic(begin, end);
@@ -94,4 +94,6 @@ GPUhi() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begi
 }
 } // namespace o2::gpu
 
+#undef GPUCA_THRUST_NAMESPACE
+
 #endif

From 7a706ae53b64cfddf58b69f231c13246b11dba26 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 16:14:36 +0100
Subject: [PATCH 0134/1764] GPUCommonAlgorithm: Use CUB for soring on device
 instead of Thrust

---
 GPU/Common/GPUCommonAlgorithmThrust.h    | 18 ++++++++++++++++--
 GPU/GPUTracking/Base/GPUGeneralKernels.h | 14 +++++++-------
 2 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/GPU/Common/GPUCommonAlgorithmThrust.h b/GPU/Common/GPUCommonAlgorithmThrust.h
index 6bf605a370050..049071227a58e 100644
--- a/GPU/Common/GPUCommonAlgorithmThrust.h
+++ b/GPU/Common/GPUCommonAlgorithmThrust.h
@@ -23,11 +23,16 @@
 #pragma GCC diagnostic pop
 
 #include "GPUCommonDef.h"
+#include "GPUCommonHelpers.h"
 
-#ifdef __CUDACC__
+#ifndef __HIPCC__ // CUDA
 #define GPUCA_THRUST_NAMESPACE thrust::cuda
-#else
+#define GPUCA_CUB_NAMESPACE cub
+#include <cub/cub.cuh>
+#else // HIP
 #define GPUCA_THRUST_NAMESPACE thrust::hip
+#define GPUCA_CUB_NAMESPACE hipcub
+#include <hipcub/hipcub.hpp>
 #endif
 
 namespace o2::gpu
@@ -89,11 +94,20 @@ template <class T, class S>
 GPUhi() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp)
 {
   thrust::device_ptr<T> p(begin);
+#if 0 // Use Thrust
   auto alloc = rec->getThrustVolatileDeviceAllocator();
   thrust::sort(GPUCA_THRUST_NAMESPACE::par(alloc).on(rec->mInternals->Streams[stream]), p, p + N, comp);
+#else // Use CUB
+  size_t tempSize = 0;
+  void* tempMem = nullptr;
+  GPUChkErrS(GPUCA_CUB_NAMESPACE::DeviceMergeSort::SortKeys(tempMem, tempSize, begin, N, comp, rec->mInternals->Streams[stream]));
+  tempMem = rec->AllocateVolatileDeviceMemory(tempSize);
+  GPUChkErrS(GPUCA_CUB_NAMESPACE::DeviceMergeSort::SortKeys(tempMem, tempSize, begin, N, comp, rec->mInternals->Streams[stream]));
+#endif
 }
 } // namespace o2::gpu
 
 #undef GPUCA_THRUST_NAMESPACE
+#undef GPUCA_CUB_NAMESPACE
 
 #endif
diff --git a/GPU/GPUTracking/Base/GPUGeneralKernels.h b/GPU/GPUTracking/Base/GPUGeneralKernels.h
index ce93e2e5eead8..eb816c91f5909 100644
--- a/GPU/GPUTracking/Base/GPUGeneralKernels.h
+++ b/GPU/GPUTracking/Base/GPUGeneralKernels.h
@@ -27,9 +27,9 @@
 #endif
 
 #if defined(__HIPCC__)
-#define GPUCA_CUB hipcub
+#define GPUCA_CUB_NAMESPACE hipcub
 #else
-#define GPUCA_CUB cub
+#define GPUCA_CUB_NAMESPACE cub
 #endif
 
 namespace o2::gpu
@@ -54,7 +54,7 @@ class GPUKernelTemplate
   struct GPUSharedMemoryWarpScan64 {
     // Provides the shared memory resources for warp wide CUB collectives
 #if (defined(__CUDACC__) || defined(__HIPCC__)) && defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_HOSTONLY)
-    typedef GPUCA_CUB::WarpScan<T> WarpScan;
+    typedef GPUCA_CUB_NAMESPACE::WarpScan<T> WarpScan;
     union {
       typename WarpScan::TempStorage cubWarpTmpMem;
     };
@@ -65,9 +65,9 @@ class GPUKernelTemplate
   struct GPUSharedMemoryScan64 {
     // Provides the shared memory resources for CUB collectives
 #if (defined(__CUDACC__) || defined(__HIPCC__)) && defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_HOSTONLY)
-    typedef GPUCA_CUB::BlockScan<T, I> BlockScan;
-    typedef GPUCA_CUB::BlockReduce<T, I> BlockReduce;
-    typedef GPUCA_CUB::WarpScan<T> WarpScan;
+    typedef GPUCA_CUB_NAMESPACE::BlockScan<T, I> BlockScan;
+    typedef GPUCA_CUB_NAMESPACE::BlockReduce<T, I> BlockReduce;
+    typedef GPUCA_CUB_NAMESPACE::WarpScan<T> WarpScan;
     union {
       typename BlockScan::TempStorage cubTmpMem;
       typename BlockReduce::TempStorage cubReduceTmpMem;
@@ -110,6 +110,6 @@ class GPUitoa : public GPUKernelTemplate
 
 } // namespace o2::gpu
 
-#undef GPUCA_CUB
+#undef GPUCA_CUB_NAMESPACE
 
 #endif

From 3e56e5536e6e20e0ae89bc4dd3b55a60dd4fdf17 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 24 Mar 2025 18:24:23 +0100
Subject: [PATCH 0135/1764] GPU: Improve synchronization during track-merging,
 no need to serialize the last kernel

---
 .../Global/GPUChainTrackingMerger.cxx          | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 8fba328f8ac38..ffab3ba0be063 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -50,19 +50,13 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSecto
       gputpcgmmergertypes::GPUTPCGMBorderRange* range2 = MergerShadow.BorderRange(jSector) + *processors()->tpcTrackers[jSector].NTracks();
       runKernel<GPUTPCGMMergerMergeBorders, 3>({{1, -WarpSize(), stream, deviceType}}, range1, n1, 0);
       runKernel<GPUTPCGMMergerMergeBorders, 3>({{1, -WarpSize(), stream, deviceType}}, range2, n2, 1);
-      deviceEvent* e = nullptr;
-      int32_t ne = 0;
-      if (i == n - 1) { // Synchronize all execution on stream 0 with the last kernel
-        ne = std::min<int32_t>(n, mRec->NStreams());
-        for (int32_t j = 1; j < ne; j++) {
-          RecordMarker(&mEvents->sector[j], j);
-        }
-        e = &mEvents->sector[1];
-        ne--;
-        stream = 0;
-      }
-      runKernel<GPUTPCGMMergerMergeBorders, 2>({GetGridAuto(stream, deviceType), krnlRunRangeNone, {nullptr, e, ne}}, i, withinSector, mergeMode);
+      runKernel<GPUTPCGMMergerMergeBorders, 2>({GetGridAuto(stream, deviceType)}, i, withinSector, mergeMode);
+    }
+    int32_t ne = std::min<int32_t>(n, mRec->NStreams()) - 1; // Stream 0 must wait for all streams, Note n > 1
+    for (int32_t j = 0; j < ne; j++) {
+      RecordMarker(&mEvents->sector[j], j + 1);
     }
+    StreamWaitForEvents(0, &mEvents->sector[0], ne);
   } else {
     for (uint32_t i = 0; i < n; i++) {
       runKernel<GPUTPCGMMergerMergeBorders, 0>(GetGridAuto(0, deviceType), i, withinSector, mergeMode);

From 8f6726b8474012cf20bbda11ed3af125ec8b7c33 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 25 Mar 2025 11:26:44 +0100
Subject: [PATCH 0136/1764] GPU: Change GPUCA_DETERMINISTIC_MODE define to
 GPUCA_DETERMINISTIC_CODE macro, that can be used also in RTC

---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  |   9 +-
 GPU/Common/GPUCommonDef.h                     |  10 +-
 GPU/Common/GPUCommonMath.h                    |  54 +++---
 .../Definitions/GPUDefGPUParameters.h         |   9 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 160 +++++++-----------
 GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h  |   2 +-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx |   2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |   2 +-
 GPU/GPUTracking/dEdx/GPUdEdx.cxx              |   4 +-
 GPU/GPUTracking/dEdx/GPUdEdx.h                |  14 +-
 10 files changed, 116 insertions(+), 150 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index a66eba7c3bacb..583452d0c429c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -43,13 +43,8 @@
 #define THRUST_NAMESPACE thrust::hip
 #endif
 
-#ifdef GPUCA_DETERMINISTIC_MODE
-#define GPU_BLOCKS 1
-#define GPU_THREADS 1
-#else
-#define GPU_BLOCKS 99999
-#define GPU_THREADS 99999
-#endif
+#define GPU_BLOCKS GPUCA_DETERMINISTIC_CODE(1, 99999)
+#define GPU_THREADS GPUCA_DETERMINISTIC_CODE(1, 99999)
 
 // O2 track model
 #include "ReconstructionDataFormats/Track.h"
diff --git a/GPU/Common/GPUCommonDef.h b/GPU/Common/GPUCommonDef.h
index b4a788e66a81c..78da104a0c029 100644
--- a/GPU/Common/GPUCommonDef.h
+++ b/GPU/Common/GPUCommonDef.h
@@ -68,10 +68,18 @@
   #define GPUCA_DEBUG_STREAMER_CHECK(...)
 #endif
 
-#ifndef GPUCA_RTC_SPECIAL_CODE
+#ifndef GPUCA_RTC_SPECIAL_CODE // By default, we ignore special RTC code
   #define GPUCA_RTC_SPECIAL_CODE(...)
 #endif
 
+#ifndef GPUCA_DETERMINISTIC_CODE
+  #ifdef GPUCA_DETERMINISTIC_MODE
+    #define GPUCA_DETERMINISTIC_CODE(det, indet) det // In deterministic mode, take deterministic code path
+  #else
+    #define GPUCA_DETERMINISTIC_CODE(det, indet) indet // otherwise the fast default code path
+  #endif
+#endif
+
 // API Definitions for GPU Compilation
 #include "GPUCommonDefAPI.h"
 
diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index 58f046161aa8b..6d97250e7f2f4 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -248,7 +248,7 @@ GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
 #endif
 }
 
-#ifdef GPUCA_DETERMINISTIC_MODE
+GPUCA_DETERMINISTIC_CODE( // clang-format off
 GPUdi() constexpr float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), roundf(x), round(x)); }
 GPUdi() constexpr int32_t GPUCommonMath::Float2IntRn(float x) { return (int32_t)Round(x); }
 GPUhdi() constexpr float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), (float)sqrt((double)x), sqrt(x)); }
@@ -264,7 +264,7 @@ GPUdi() constexpr float GPUCommonMath::Log(float x) { return GPUCA_CHOICE((float
 GPUdi() constexpr float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE((float)exp((double)x), (float)exp((double)x), exp(x)); }
 GPUdi() constexpr bool GPUCommonMath::Finite(float x) { return GPUCA_CHOICE(std::isfinite(x), isfinite(x), isfinite(x)); }
 GPUdi() constexpr bool GPUCommonMath::IsNaN(float x) { return GPUCA_CHOICE(std::isnan(x), isnan(x), isnan(x)); }
-#else
+, // !GPUCA_DETERMINISTIC_CODE
 GPUdi() constexpr float GPUCommonMath::Round(float x) { return GPUCA_CHOICE(roundf(x), rintf(x), rint(x)); }
 GPUdi() constexpr int32_t GPUCommonMath::Float2IntRn(float x) { return GPUCA_CHOICE((int32_t)Round(x), __float2int_rn(x), (int32_t)Round(x)); }
 GPUhdi() constexpr float GPUCommonMath::Sqrt(float x) { return GPUCA_CHOICE(sqrtf(x), sqrtf(x), sqrt(x)); }
@@ -280,20 +280,22 @@ GPUdi() constexpr float GPUCommonMath::Log(float x) { return GPUCA_CHOICE(logf(x
 GPUdi() constexpr float GPUCommonMath::Exp(float x) { return GPUCA_CHOICE(expf(x), expf(x), exp(x)); }
 GPUdi() constexpr bool GPUCommonMath::Finite(float x) { return true; }
 GPUdi() constexpr bool GPUCommonMath::IsNaN(float x) { return false; }
-#endif
+) // clang-format on
 
 GPUhdi() void GPUCommonMath::SinCos(float x, float& s, float& c)
 {
-#if defined(GPUCA_DETERMINISTIC_MODE) && !defined(__OPENCL__)
-  s = sin((double)x);
-  c = cos((double)x);
-#elif !defined(GPUCA_GPUCODE_DEVICE) && defined(__APPLE__)
-  __sincosf(x, &s, &c);
+  GPUCA_DETERMINISTIC_CODE( // clang-format off
+    s = sin((double)x);
+    c = cos((double)x);
+  , // !GPUCA_DETERMINISTIC_CODE
+#if !defined(GPUCA_GPUCODE_DEVICE) && defined(__APPLE__)
+    __sincosf(x, &s, &c);
 #elif !defined(GPUCA_GPUCODE_DEVICE) && (defined(__GNU_SOURCE__) || defined(_GNU_SOURCE) || defined(GPUCA_GPUCODE))
-  sincosf(x, &s, &c);
+    sincosf(x, &s, &c);
 #else
-  GPUCA_CHOICE((void)((s = sinf(x)) + (c = cosf(x))), sincosf(x, &s, &c), s = sincos(x, &c));
+    GPUCA_CHOICE((void)((s = sinf(x)) + (c = cosf(x))), sincosf(x, &s, &c), s = sincos(x, &c));
 #endif
+  ) // clang-format on
 }
 
 GPUhdi() void GPUCommonMath::SinCosd(double x, double& s, double& c)
@@ -390,22 +392,26 @@ GPUdi() T GPUCommonMath::MaxWithRef(T x, T y, T z, T w, S refX, S refY, S refZ,
 
 GPUdi() float GPUCommonMath::InvSqrt(float _x)
 {
-#if defined(GPUCA_DETERMINISTIC_MODE) || defined(__OPENCL__)
-  return 1.f / Sqrt(_x);
-#elif defined(__CUDACC__) || defined(__HIPCC__)
-  return __frsqrt_rn(_x);
-#elif defined(__FAST_MATH__)
-  return 1.f / sqrtf(_x);
+  GPUCA_DETERMINISTIC_CODE( // clang-format off
+    return 1.f / Sqrt(_x);
+  , // !GPUCA_DETERMINISTIC_CODE
+#if defined(__CUDACC__) || defined(__HIPCC__)
+    return __frsqrt_rn(_x);
+#elif defined(__OPENCL__) && defined(__clang__)
+    return 1.f / sqrt(_x);
+#elif !defined(__OPENCL__) && (defined(__FAST_MATH__) || defined(__clang__))
+    return 1.f / sqrtf(_x);
 #else
-  union {
-    float f;
-    int32_t i;
-  } x = {_x};
-  const float xhalf = 0.5f * x.f;
-  x.i = 0x5f3759df - (x.i >> 1);
-  x.f = x.f * (1.5f - xhalf * x.f * x.f);
-  return x.f;
+    union {
+      float f;
+      int32_t i;
+    } x = {_x};
+    const float xhalf = 0.5f * x.f;
+    x.i = 0x5f3759df - (x.i >> 1);
+    x.f = x.f * (1.5f - xhalf * x.f * x.f);
+    return x.f;
 #endif
+  ) // clang-format on
 }
 
 template <>
diff --git a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
index 6d6645850408f..5b5a89cc8bc39 100644
--- a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
+++ b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
@@ -25,6 +25,7 @@
 #error Please include GPUDef.h
 #endif
 
+#include "GPUCommonDef.h"
 #include "GPUDefMacros.h"
 
 // GPU Run Configuration
@@ -566,12 +567,8 @@
 #ifndef GPUCA_MERGER_INTERPOLATION_ERROR_TYPE
 #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
 #endif
-#ifdef GPUCA_DETERMINISTIC_MODE
-#undef GPUCA_MERGER_INTERPOLATION_ERROR_TYPE
-#define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
-#undef GPUCA_DEDX_STORAGE_TYPE
-#define GPUCA_DEDX_STORAGE_TYPE float
-#endif
+#define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)
+#define GPUCA_DEDX_STORAGE_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_DEDX_STORAGE_TYPE)
 
 #ifndef GPUCA_WARP_SIZE
 #ifdef GPUCA_GPUCODE
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index c8c844eee748a..288a24dee5d99 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -723,17 +723,9 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThrea
 
   if (iThread == 0) {
     if (iBlock == 0) {
-#ifdef GPUCA_DETERMINISTIC_MODE
-      GPUCommonAlgorithm::sortDeviceDynamic(range1, range1 + N1, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return (a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId); });
-#else
-      GPUCommonAlgorithm::sortDeviceDynamic(range1, range1 + N1, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return a.fMin < b.fMin; });
-#endif
+      GPUCommonAlgorithm::sortDeviceDynamic(range1, range1 + N1, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return GPUCA_DETERMINISTIC_CODE((a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId), a.fMin < b.fMin); });
     } else if (iBlock == 1) {
-#ifdef GPUCA_DETERMINISTIC_MODE
-      GPUCommonAlgorithm::sortDeviceDynamic(range2, range2 + N2, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return (a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId); });
-#else
-      GPUCommonAlgorithm::sortDeviceDynamic(range2, range2 + N2, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return a.fMax < b.fMax; });
-#endif
+      GPUCommonAlgorithm::sortDeviceDynamic(range2, range2 + N2, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return GPUCA_DETERMINISTIC_CODE((a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId), a.fMax < b.fMax); });
     }
   }
 #else
@@ -749,21 +741,13 @@ namespace // anonymous
 struct MergeBorderTracks_compMax {
   GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
   {
-#ifdef GPUCA_DETERMINISTIC_MODE
-    return (a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId);
-#else
-    return a.fMax < b.fMax;
-#endif
+    return GPUCA_DETERMINISTIC_CODE((a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId), a.fMax < b.fMax);
   }
 };
 struct MergeBorderTracks_compMin {
   GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
   {
-#ifdef GPUCA_DETERMINISTIC_MODE
-    return (a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId);
-#else
-    return a.fMin < b.fMin;
-#endif
+    return GPUCA_DETERMINISTIC_CODE((a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId), a.fMin < b.fMin);
   }
 };
 } // anonymous namespace
@@ -904,11 +888,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThrea
 
     mTrackLinks[b1.TrackID()] = iBest2;
     if (mergeMode > 0) {
-#ifdef GPUCA_DETERMINISTIC_MODE
-      CAMath::AtomicMax(&mTrackLinks[iBest2], b1.TrackID());
-#else
-      mTrackLinks[iBest2] = b1.TrackID();
-#endif
+      GPUCA_DETERMINISTIC_CODE(CAMath::AtomicMax(&mTrackLinks[iBest2], b1.TrackID()), mTrackLinks[iBest2] = b1.TrackID());
     }
   }
   // GPUInfo("STAT: sectors %d, %d: all %d merged %d", iSector1, iSector2, statAll, statMerged);
@@ -1467,14 +1447,7 @@ struct GPUTPCGMMerger_CompareClusterIdsLooper {
     if (a1.row != b1.row) {
       return ((a1.row > b1.row) ^ ((a.leg - leg) & 1) ^ outwards);
     }
-#ifdef GPUCA_DETERMINISTIC_MODE
-    if (a1.id != b1.id) {
-      return (a1.id > b1.id);
-    }
-    return aa > bb;
-#else
-    return a1.id > b1.id;
-#endif
+    return GPUCA_DETERMINISTIC_CODE((a1.id != b1.id) ? (a1.id > b1.id) : (aa > bb), a1.id > b1.id);
   }
 };
 
@@ -1488,14 +1461,7 @@ struct GPUTPCGMMerger_CompareClusterIds {
     if (a.row != b.row) {
       return (a.row > b.row);
     }
-#ifdef GPUCA_DETERMINISTIC_MODE
-    if (a.id != b.id) {
-      return (a.id > b.id);
-    }
-    return aa > bb;
-#else
-    return (a.id > b.id);
-#endif
+    return GPUCA_DETERMINISTIC_CODE((a.id != b.id) ? (a.id > b.id) : (aa > bb), a.id > b.id);
   }
 };
 } // anonymous namespace
@@ -1567,20 +1533,20 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     // unpack and sort clusters
     if (nParts > 1 && leg == 0) {
       GPUCommonAlgorithm::sort(trackParts, trackParts + nParts, [](const GPUTPCGMSectorTrack* a, const GPUTPCGMSectorTrack* b) {
-#ifdef GPUCA_DETERMINISTIC_MODE
-        if (a->X() != b->X()) {
+        GPUCA_DETERMINISTIC_CODE( // clang-format off
+          if (a->X() != b->X()) {
+            return (a->X() > b->X());
+          }
+          if (a->Y() != b->Y()) {
+            return (a->Y() > b->Y());
+          }
+          if (a->Z() != b->Z()) {
+            return (a->Z() > b->Z());
+          }
+          return a->QPt() > b->QPt();
+        , // !GPUCA_DETERMINISTIC_CODE
           return (a->X() > b->X());
-        }
-        if (a->Y() != b->Y()) {
-          return (a->Y() > b->Y());
-        }
-        if (a->Z() != b->Z()) {
-          return (a->Z() > b->Z());
-        }
-        return a->QPt() > b->QPt();
-#else
-        return (a->X() > b->X());
-#endif
+        ) // clang-format on
       });
     }
 
@@ -1832,20 +1798,18 @@ struct GPUTPCGMMergerSortTracks_comp {
     if (a.Legs() != b.Legs()) {
       return a.Legs() > b.Legs();
     }
-#ifdef GPUCA_DETERMINISTIC_MODE
-    if (a.NClusters() != b.NClusters()) {
+    GPUCA_DETERMINISTIC_CODE( // clang-format off
+      if (a.NClusters() != b.NClusters()) {
+        return a.NClusters() > b.NClusters();
+      } if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
+        return a.GetParam().GetY() > b.GetParam().GetY();
+      }
+      return aa > bb;
+    , // !GPUCA_DETERMINISTIC_CODE
       return a.NClusters() > b.NClusters();
-    }
-    if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
-      return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-    }
-    if (a.GetParam().GetY() != b.GetParam().GetY()) {
-      return a.GetParam().GetY() > b.GetParam().GetY();
-    }
-    return aa > bb;
-#else
-    return a.NClusters() > b.NClusters();
-#endif
+    ) // clang-format on
   }
 };
 
@@ -1856,17 +1820,16 @@ struct GPUTPCGMMergerSortTracksQPt_comp {
   {
     const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
     const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
-#ifdef GPUCA_DETERMINISTIC_MODE
-    if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+    GPUCA_DETERMINISTIC_CODE( // clang-format off
+      if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
+        return a.GetParam().GetY() > b.GetParam().GetY();
+      }
+      return a.GetParam().GetZ() > b.GetParam().GetZ();
+    , // !GPUCA_DETERMINISTIC_CODE
       return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-    }
-    if (a.GetParam().GetY() != b.GetParam().GetY()) {
-      return a.GetParam().GetY() > b.GetParam().GetY();
-    }
-    return a.GetParam().GetZ() > b.GetParam().GetZ();
-#else
-    return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-#endif
+    ) // clang-format on
   }
 };
 } // anonymous namespace
@@ -1901,20 +1864,18 @@ GPUd() void GPUTPCGMMerger::SortTracks(int32_t nBlocks, int32_t nThreads, int32_
     if (a.Legs() != b.Legs()) {
       return a.Legs() > b.Legs();
     }
-#ifdef GPUCA_DETERMINISTIC_MODE
-    if (a.NClusters() != b.NClusters()) {
+    GPUCA_DETERMINISTIC_CODE( // clang-format off
+      if (a.NClusters() != b.NClusters()) {
+        return a.NClusters() > b.NClusters();
+      } if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
+        return a.GetParam().GetY() > b.GetParam().GetY();
+      }
+      return aa > bb;
+    , // !GPUCA_DETERMINISTIC_CODE
       return a.NClusters() > b.NClusters();
-    }
-    if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
-      return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-    }
-    if (a.GetParam().GetY() != b.GetParam().GetY()) {
-      return a.GetParam().GetY() > b.GetParam().GetY();
-    }
-    return aa > bb;
-#else
-    return a.NClusters() > b.NClusters();
-#endif
+    ) // clang-format on
   };
 
   GPUCommonAlgorithm::sortDeviceDynamic(mTrackOrderProcess, mTrackOrderProcess + mMemory->nOutputTracks, comp);
@@ -1931,17 +1892,16 @@ GPUd() void GPUTPCGMMerger::SortTracksQPt(int32_t nBlocks, int32_t nThreads, int
   auto comp = [cmp = mOutputTracks](const int32_t aa, const int32_t bb) {
     const GPUTPCGMMergedTrack& GPUrestrict() a = cmp[aa];
     const GPUTPCGMMergedTrack& GPUrestrict() b = cmp[bb];
-#ifdef GPUCA_DETERMINISTIC_MODE
-    if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+    GPUCA_DETERMINISTIC_CODE( // clang-format off
+      if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
+        return a.GetParam().GetY() > b.GetParam().GetY();
+      }
+      return a.GetParam().GetZ() > b.GetParam().GetZ();
+    , // !GPUCA_DETERMINISTIC_CODE
       return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-    }
-    if (a.GetParam().GetY() != b.GetParam().GetY()) {
-      return a.GetParam().GetY() > b.GetParam().GetY();
-    }
-    return a.GetParam().GetZ() > b.GetParam().GetZ();
-#else
-    return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-#endif
+    ) // clang-format on
   };
 
   GPUCommonAlgorithm::sortDeviceDynamic(mTrackSort, mTrackSort + mMemory->nOutputTracks, comp);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h b/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
index 4e225a61661c2..238b04510862e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
@@ -32,7 +32,7 @@ enum attachTypes { attachAttached = 0x40000000,
 
 struct InterpolationErrorHit {
   float posY, posZ;
-  GPUCA_MERGER_INTERPOLATION_ERROR_TYPE errorY, errorZ;
+  GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A errorY, errorZ;
 };
 
 struct InterpolationErrors {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index 0c171a74d4e42..f1aac3da9a7a2 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -663,7 +663,7 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow,
   GPUCA_DEBUG_STREAMER_CHECK(if (debugVals) { debugVals->err2Y = err2Y; debugVals->err2Z = err2Z; });
 
   if (rejectChi2 >= rejectInterFill) {
-    if (rejectChi2 == rejectInterReject && inter->errorY < (GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)0) {
+    if (rejectChi2 == rejectInterReject && inter->errorY < (GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
       rejectChi2 = rejectDirect;
     } else {
       int32_t retVal = InterpolateReject(param, posY, posZ, clusterState, rejectChi2, inter, err2Y, err2Z);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index d235b3398c062..29524fb80ace0 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -308,7 +308,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       } else {
         int8_t rejectChi2 = attempt ? 0 : ((param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (refit ? (GPUTPCGMPropagator::rejectInterFill + ((nWays - iWay) & 1)) : 0) : (allowModification && goodRows > 5));
 #if EXTRACT_RESIDUALS == 1
-        if (iWay == nWays - 1 && interpolation.hit[ihit].errorY > (GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)0) {
+        if (iWay == nWays - 1 && interpolation.hit[ihit].errorY > (GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
           const float Iz0 = interpolation.hit[ihit].posY - mP[0];
           const float Iz1 = interpolation.hit[ihit].posZ - mP[1];
           float Iw0 = mC[2] + (float)interpolation.hit[ihit].errorZ;
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.cxx b/GPU/GPUTracking/dEdx/GPUdEdx.cxx
index b7da0de4c0e29..fd2aeda2828e3 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.cxx
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.cxx
@@ -55,7 +55,7 @@ GPUd() void GPUdEdx::computedEdx(GPUdEdxInfo& GPUrestrict() output, const GPUPar
   output.NHitsSubThresholdOROC3 = countOROC3;
 }
 
-GPUd() float GPUdEdx::GetSortTruncMean(GPUCA_DEDX_STORAGE_TYPE* GPUrestrict() array, int32_t count, int32_t trunclow, int32_t trunchigh)
+GPUd() float GPUdEdx::GetSortTruncMean(GPUCA_DEDX_STORAGE_TYPE_A* GPUrestrict() array, int32_t count, int32_t trunclow, int32_t trunchigh)
 {
   trunclow = count * trunclow / 128;
   trunchigh = count * trunchigh / 128;
@@ -65,7 +65,7 @@ GPUd() float GPUdEdx::GetSortTruncMean(GPUCA_DEDX_STORAGE_TYPE* GPUrestrict() ar
   CAAlgo::sort(array, array + count);
   float mean = 0;
   for (int32_t i = trunclow; i < trunchigh; i++) {
-    mean += (float)array[i] * (1.f / scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::factor);
+    mean += (float)array[i] * (1.f / scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor);
   }
   return (mean / (trunchigh - trunclow));
 }
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index bcd75af468c28..4d3b652bdc5d1 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -37,7 +37,7 @@ class GPUdEdx
   GPUd() void computedEdx(GPUdEdxInfo& output, const GPUParam& param);
 
  private:
-  GPUd() float GetSortTruncMean(GPUCA_DEDX_STORAGE_TYPE* array, int32_t count, int32_t trunclow, int32_t trunchigh);
+  GPUd() float GetSortTruncMean(GPUCA_DEDX_STORAGE_TYPE_A* array, int32_t count, int32_t trunclow, int32_t trunchigh);
   GPUd() void checkSubThresh(int32_t roc);
 
   template <typename T, typename fake = void>
@@ -62,8 +62,8 @@ class GPUdEdx
 
   static constexpr int32_t MAX_NCL = GPUCA_ROW_COUNT; // Must fit in mNClsROC (uint8_t)!
 
-  GPUCA_DEDX_STORAGE_TYPE mChargeTot[MAX_NCL]; // No need for default, just some memory
-  GPUCA_DEDX_STORAGE_TYPE mChargeMax[MAX_NCL]; // No need for default, just some memory
+  GPUCA_DEDX_STORAGE_TYPE_A mChargeTot[MAX_NCL]; // No need for default, just some memory
+  GPUCA_DEDX_STORAGE_TYPE_A mChargeMax[MAX_NCL]; // No need for default, just some memory
   float mSubThreshMinTot = 0.f;
   float mSubThreshMinMax = 0.f;
   uint8_t mNClsROC[4] = {0};
@@ -78,8 +78,8 @@ GPUdi() void GPUdEdx::checkSubThresh(int32_t roc)
   if (roc != mLastROC) {
     if (mNSubThresh && mCount + mNSubThresh <= MAX_NCL) {
       for (int32_t i = 0; i < mNSubThresh; i++) {
-        mChargeTot[mCount] = (GPUCA_DEDX_STORAGE_TYPE)(mSubThreshMinTot * scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::round);
-        mChargeMax[mCount++] = (GPUCA_DEDX_STORAGE_TYPE)(mSubThreshMinMax * scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::round);
+        mChargeTot[mCount] = (GPUCA_DEDX_STORAGE_TYPE_A)(mSubThreshMinTot * scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::round);
+        mChargeMax[mCount++] = (GPUCA_DEDX_STORAGE_TYPE_A)(mSubThreshMinMax * scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::round);
       }
       mNClsROC[mLastROC] += mNSubThresh;
       mNClsROCSubThresh[mLastROC] += mNSubThresh;
@@ -151,8 +151,8 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
   qmax /= residualGainMapGain;
   qtot /= residualGainMapGain;
 
-  mChargeTot[mCount] = (GPUCA_DEDX_STORAGE_TYPE)(qtot * scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::round);
-  mChargeMax[mCount++] = (GPUCA_DEDX_STORAGE_TYPE)(qmax * scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE>::round);
+  mChargeTot[mCount] = (GPUCA_DEDX_STORAGE_TYPE_A)(qtot * scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::round);
+  mChargeMax[mCount++] = (GPUCA_DEDX_STORAGE_TYPE_A)(qmax * scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::round);
   mNClsROC[roc]++;
   if (qtot < mSubThreshMinTot) {
     mSubThreshMinTot = qtot;

From d4a5ca78d81244bad4709591011aed486600b248 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Tue, 25 Mar 2025 13:02:28 +0100
Subject: [PATCH 0137/1764] GeneratorHybrid: improve unit treatment

So far, units are treated solely in the Generator::addTrack function.
This works well for fundamental generators.

However, the hybrid generator is a meta generator potentially consisting
of a collection of underlying generators that may have completely different
units. This may currently lead to wrong generator output, in certain cases.

This commit fixes these bugs and introduces unit handling within GeneratorHybrid.
---
 Generators/include/Generators/Generator.h     |  4 ++
 .../include/Generators/GeneratorHybrid.h      |  1 -
 Generators/src/GeneratorHybrid.cxx            | 60 +++++++++++++++----
 3 files changed, 52 insertions(+), 13 deletions(-)

diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 640cc80931862..bd35a00793e2d 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -78,9 +78,13 @@ class Generator : public FairGenerator
 
   /** setters **/
   void setMomentumUnit(double val) { mMomentumUnit = val; };
+  double getMomentumUnit() const { return mMomentumUnit; }
   void setEnergyUnit(double val) { mEnergyUnit = val; };
+  double getEnergyUnit() const { return mEnergyUnit; }
   void setPositionUnit(double val) { mPositionUnit = val; };
+  double getPositionUnit() const { return mPositionUnit; }
   void setTimeUnit(double val) { mTimeUnit = val; };
+  double getTimeUnit() const { return mTimeUnit; }
   void setBoost(Double_t val) { mBoost = val; };
   void setTriggerMode(ETriggerMode_t val) { mTriggerMode = val; };
   void addTrigger(Trigger trigger) { mTriggers.push_back(trigger); };
diff --git a/Generators/include/Generators/GeneratorHybrid.h b/Generators/include/Generators/GeneratorHybrid.h
index 955240d6a28fa..b92437b02d874 100644
--- a/Generators/include/Generators/GeneratorHybrid.h
+++ b/Generators/include/Generators/GeneratorHybrid.h
@@ -54,7 +54,6 @@ class GeneratorHybrid : public Generator
 {
 
  public:
-  GeneratorHybrid() = default;
   GeneratorHybrid(const std::string& inputgens);
   ~GeneratorHybrid();
 
diff --git a/Generators/src/GeneratorHybrid.cxx b/Generators/src/GeneratorHybrid.cxx
index 729d69527c384..83a694703c259 100644
--- a/Generators/src/GeneratorHybrid.cxx
+++ b/Generators/src/GeneratorHybrid.cxx
@@ -25,6 +25,12 @@ namespace eventgen
 
 GeneratorHybrid::GeneratorHybrid(const std::string& inputgens)
 {
+  // This generator has trivial unit conversions
+  setTimeUnit(1.);
+  setPositionUnit(1.);
+  setMomentumUnit(1.);
+  setEnergyUnit(1.);
+
   if (!parseJSON(inputgens)) {
     LOG(fatal) << "Failed to parse JSON configuration from input generators";
     exit(1);
@@ -382,6 +388,27 @@ bool GeneratorHybrid::importParticles()
       }
     }
   }
+
+  auto unit_transformer = [](auto& p, auto pos_unit, auto time_unit, auto en_unit, auto mom_unit) {
+    p.SetMomentum(p.Px() * mom_unit, p.Py() * mom_unit, p.Pz() * mom_unit, p.Energy() * en_unit);
+    p.SetProductionVertex(p.Vx() * pos_unit, p.Vy() * pos_unit, p.Vz() * pos_unit, p.T() * time_unit);
+  };
+
+  auto index_transformer = [](auto& p, int offset) {
+    for (int i = 0; i < 2; ++i) {
+      if (p.GetMother(i) != -1) {
+        const auto newindex = p.GetMother(i) + offset;
+        p.SetMother(i, newindex);
+      }
+    }
+    if (p.GetNDaughters() > 0) {
+      for (int i = 0; i < 2; ++i) {
+        const auto newindex = p.GetDaughter(i) + offset;
+        p.SetDaughter(i, newindex);
+      }
+    }
+  };
+
   // Clear particles and event header
   mParticles.clear();
   mMCEventHeader.clearInfo();
@@ -391,23 +418,20 @@ bool GeneratorHybrid::importParticles()
       LOG(info) << "Importing particles for task " << subIndex;
       auto subParticles = gens[subIndex]->getParticles();
 
+      auto time_unit = gens[subIndex]->getTimeUnit();
+      auto pos_unit = gens[subIndex]->getPositionUnit();
+      auto mom_unit = gens[subIndex]->getMomentumUnit();
+      auto energy_unit = gens[subIndex]->getEnergyUnit();
+
       // The particles carry mother and daughter indices, which are relative
       // to the sub-generator. We need to adjust these indices to reflect that particles
       // are now embedded into a cocktail.
       auto offset = mParticles.size();
       for (auto& p : subParticles) {
-        for (int i = 0; i < 2; ++i) {
-          if (p.GetMother(i) != -1) {
-            const auto newindex = p.GetMother(i) + offset;
-            p.SetMother(i, newindex);
-          }
-        }
-        if (p.GetNDaughters() > 0) {
-          for (int i = 0; i < 2; ++i) {
-            const auto newindex = p.GetDaughter(i) + offset;
-            p.SetDaughter(i, newindex);
-          }
-        }
+        // apply the mother-daugher index transformation
+        index_transformer(p, offset);
+        // apply unit transformation of sub-generator
+        unit_transformer(p, pos_unit, time_unit, energy_unit, mom_unit);
       }
 
       mParticles.insert(mParticles.end(), subParticles.begin(), subParticles.end());
@@ -420,6 +444,18 @@ bool GeneratorHybrid::importParticles()
     LOG(info) << "Importing particles for task " << genIndex;
     // at this moment the mIndex-th generator is ready to be used
     mParticles = gens[genIndex]->getParticles();
+
+    auto time_unit = gens[genIndex]->getTimeUnit();
+    auto pos_unit = gens[genIndex]->getPositionUnit();
+    auto mom_unit = gens[genIndex]->getMomentumUnit();
+    auto energy_unit = gens[genIndex]->getEnergyUnit();
+
+    // transform units to units of the hybrid generator
+    for (auto& p : mParticles) {
+      // apply unit transformation
+      unit_transformer(p, pos_unit, time_unit, energy_unit, mom_unit);
+    }
+
     // fetch the event Header information from the underlying generator
     gens[genIndex]->updateHeader(&mMCEventHeader);
     mInputTaskQueue.push(genIndex);

From 614112ed251d225b96f7476104f427568b359f8e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 25 Mar 2025 16:20:42 +0100
Subject: [PATCH 0138/1764] GPU RTC: Add deterministic mode

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt       | 18 ++++++++++++------
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx  |  3 +++
 .../Base/cuda/GPUReconstructionCUDArtc.cu      |  1 +
 GPU/GPUTracking/Base/hip/CMakeLists.txt        | 18 ++++++++++++------
 GPU/GPUTracking/Definitions/GPUSettingsList.h  |  1 +
 5 files changed, 29 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 99c59afd2011a..10b37496a2a62 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -85,8 +85,7 @@ add_custom_target(${MODULE}_CUDA_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command
     COMMAND echo -n "${CMAKE_CUDA_COMPILER} ${GPU_RTC_FLAGS_SEPARATED} ${GPU_RTC_DEFINES} -fatbin" > ${GPU_RTC_BIN}.command
-    COMMAND_EXPAND_LISTS
-    VERBATIM
+    COMMAND_EXPAND_LISTS VERBATIM
     COMMENT "Preparing CUDA RTC command file ${GPU_RTC_BIN}.command"
 )
 create_binary_resource(${GPU_RTC_BIN}.command ${GPU_RTC_BIN}.command.o)
@@ -94,13 +93,20 @@ create_binary_resource(${GPU_RTC_BIN}.command ${GPU_RTC_BIN}.command.o)
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command.arch
     COMMAND echo -n "${GPU_RTC_FLAGS_ARCH}" > ${GPU_RTC_BIN}.command.arch
-    COMMAND_EXPAND_LISTS
-    VERBATIM
-    COMMENT "Preparing CUDA RTC ARCH file ${GPU_RTC_BIN}.command.arch"
+    COMMAND_EXPAND_LISTS VERBATIM
+    COMMENT "Preparing CUDA RTC ARCH command file ${GPU_RTC_BIN}.command.arch"
 )
 create_binary_resource(${GPU_RTC_BIN}.command.arch ${GPU_RTC_BIN}.command.arch.o)
 
-set(SRCS ${SRCS} ${GPU_RTC_BIN}.src.o ${GPU_RTC_BIN}.command.o ${GPU_RTC_BIN}.command.arch.o)
+add_custom_command(
+    OUTPUT ${GPU_RTC_BIN}.command.no_fast_math
+    COMMAND echo -n "${GPUCA_CUDA_NO_FAST_MATH_FLAGS}" > ${GPU_RTC_BIN}.command.no_fast_math
+    COMMAND_EXPAND_LISTS VERBATIM
+    COMMENT "Preparing CUDA RTC NO_FAST_MATH command file ${GPU_RTC_BIN}.command.arch"
+)
+create_binary_resource(${GPU_RTC_BIN}.command.no_fast_math ${GPU_RTC_BIN}.command.no_fast_math.o)
+
+set(SRCS ${SRCS} ${GPU_RTC_BIN}.src.o ${GPU_RTC_BIN}.command.o ${GPU_RTC_BIN}.command.arch.o ${GPU_RTC_BIN}.command.no_fast_math.o)
 # -------------------------------- End RTC -------------------------------------------------------
 
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index 1a4721035818e..e789dc9b9ebc3 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -29,11 +29,13 @@ using namespace o2::gpu;
 QGET_LD_BINARY_SYMBOLS(GPUReconstructionCUDArtc_src);
 QGET_LD_BINARY_SYMBOLS(GPUReconstructionCUDArtc_command);
 QGET_LD_BINARY_SYMBOLS(GPUReconstructionCUDArtc_command_arch);
+QGET_LD_BINARY_SYMBOLS(GPUReconstructionCUDArtc_command_no_fast_math);
 
 int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
 {
   std::string rtcparam = std::string("#define GPUCA_RTC_CODE\n") +
                          std::string(mProcessingSettings.rtc.optSpecialCode ? "#define GPUCA_RTC_SPECIAL_CODE(...) __VA_ARGS__\n" : "#define GPUCA_RTC_SPECIAL_CODE(...)\n") +
+                         std::string(mProcessingSettings.rtc.deterministic ? "#define GPUCA_DETERMINISTIC_CODE(det, indet) det\n" : "#define GPUCA_DETERMINISTIC_CODE(det, indet) indet\n") +
                          GPUParamRTC::generateRTCCode(param(), mProcessingSettings.rtc.optConstexpr);
   if (filename == "") {
     filename = "/tmp/o2cagpu_rtc_";
@@ -52,6 +54,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
   std::string baseCommand = (mProcessingSettings.RTCprependCommand != "" ? (mProcessingSettings.RTCprependCommand + " ") : "");
   baseCommand += (getenv("O2_GPU_RTC_OVERRIDE_CMD") ? std::string(getenv("O2_GPU_RTC_OVERRIDE_CMD")) : std::string(_binary_GPUReconstructionCUDArtc_command_start, _binary_GPUReconstructionCUDArtc_command_len));
   baseCommand += std::string(" ") + (mProcessingSettings.RTCoverrideArchitecture != "" ? mProcessingSettings.RTCoverrideArchitecture : std::string(_binary_GPUReconstructionCUDArtc_command_arch_start, _binary_GPUReconstructionCUDArtc_command_arch_len));
+  baseCommand += mProcessingSettings.rtc.deterministic ? (std::string(" ") + std::string(_binary_GPUReconstructionCUDArtc_command_no_fast_math_start, _binary_GPUReconstructionCUDArtc_command_no_fast_math_len)) : std::string("");
 
   char shasource[21], shaparam[21], shacmd[21], shakernels[21];
   if (mProcessingSettings.rtc.cacheOutput) {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
index 31f9c54c5e7f8..2b6ec52f25831 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
@@ -15,6 +15,7 @@
 #define GPUCA_GPUCODE_GENRTC
 #define GPUCA_GPUCODE_COMPILEKERNELS
 #define GPUCA_RTC_SPECIAL_CODE(...) GPUCA_RTC_SPECIAL_CODE(__VA_ARGS__)
+#define GPUCA_DETERMINISTIC_CODE(...) GPUCA_DETERMINISTIC_CODE(__VA_ARGS__)
 #include "GPUReconstructionCUDADef.h"
 #include "GPUReconstructionIncludesDeviceAll.h"
 
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 16e6e72d56e9a..33963d72be9ab 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -123,8 +123,7 @@ add_custom_target(${MODULE}_HIP_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command
     COMMAND echo -n "${CMAKE_HIP_COMPILER} ${GPU_RTC_FLAGS_SEPARATED} ${GPU_RTC_DEFINES} -x hip --cuda-device-only" > ${GPU_RTC_BIN}.command
-    COMMAND_EXPAND_LISTS
-    VERBATIM
+    COMMAND_EXPAND_LISTS VERBATIM
     COMMENT "Preparing HIP RTC command file ${GPU_RTC_BIN}.command"
 )
 create_binary_resource(${GPU_RTC_BIN}.command ${GPU_RTC_BIN}.command.o)
@@ -132,13 +131,20 @@ create_binary_resource(${GPU_RTC_BIN}.command ${GPU_RTC_BIN}.command.o)
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command.arch
     COMMAND echo -n "${GPU_RTC_FLAGS_ARCH}" > ${GPU_RTC_BIN}.command.arch
-    COMMAND_EXPAND_LISTS
-    VERBATIM
-    COMMENT "Preparing HIP RTC ARCH file ${GPU_RTC_BIN}.command.arch"
+    COMMAND_EXPAND_LISTS VERBATIM
+    COMMENT "Preparing HIP RTC ARCH command file ${GPU_RTC_BIN}.command.arch"
 )
 create_binary_resource(${GPU_RTC_BIN}.command.arch ${GPU_RTC_BIN}.command.arch.o)
 
-set(SRCS ${SRCS} ${GPU_RTC_BIN}.src.o ${GPU_RTC_BIN}.command.o ${GPU_RTC_BIN}.command.arch.o)
+add_custom_command(
+    OUTPUT ${GPU_RTC_BIN}.command.no_fast_math
+    COMMAND echo -n "${GPUCA_CXX_NO_FAST_MATH_FLAGS}" > ${GPU_RTC_BIN}.command.no_fast_math
+    COMMAND_EXPAND_LISTS VERBATIM
+    COMMENT "Preparing HIP RTC NO_FAST_MATH command file ${GPU_RTC_BIN}.command.no_fast_math"
+)
+create_binary_resource(${GPU_RTC_BIN}.command.no_fast_math ${GPU_RTC_BIN}.command.no_fast_math.o)
+
+set(SRCS ${SRCS} ${GPU_RTC_BIN}.src.o ${GPU_RTC_BIN}.command.o ${GPU_RTC_BIN}.command.arch.o ${GPU_RTC_BIN}.command.no_fast_math.o)
 # -------------------------------- End RTC -------------------------------------------------------
 
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index a1f650a2bc56e..e0c5f845a475e 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -208,6 +208,7 @@ BeginSubConfig(GPUSettingsProcessingRTC, rtc, configStandalone.proc, "RTC", 0, "
 AddOption(cacheOutput, bool, false, "", 0, "Cache RTC compilation results")
 AddOption(optConstexpr, bool, true, "", 0, "Replace constant variables by static constexpr expressions")
 AddOption(optSpecialCode, int8_t, -1, "", 0, "Insert GPUCA_RTC_SPECIAL_CODE special code during RTC")
+AddOption(deterministic, bool, false, "", 0, "Compile RTC in deterministic mode, with NO_FAST_MATH flags and GPUCA_DETERMINISTIC_MODE define")
 AddOption(compilePerKernel, bool, true, "", 0, "Run one RTC compilation per kernel")
 AddOption(enable, bool, false, "", 0, "Use RTC to optimize GPU code")
 AddOption(runTest, int32_t, 0, "", 0, "Do not run the actual benchmark, but just test RTC compilation (1 full test, 2 test only compilation)")

From 8459848bd63c60c36b8b455fd830785f1f239dfe Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 25 Mar 2025 17:25:00 +0100
Subject: [PATCH 0139/1764] GPU RTC: Some cosmetic CMake changes to make RTC
 command lines more homogeneous

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt              | 2 +-
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu | 1 +
 GPU/GPUTracking/Base/hip/CMakeLists.txt               | 2 +-
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 10b37496a2a62..c1cc63aa0fc02 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -84,7 +84,7 @@ add_custom_target(${MODULE}_CUDA_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}
 
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command
-    COMMAND echo -n "${CMAKE_CUDA_COMPILER} ${GPU_RTC_FLAGS_SEPARATED} ${GPU_RTC_DEFINES} -fatbin" > ${GPU_RTC_BIN}.command
+    COMMAND echo -n "${CMAKE_CUDA_COMPILER} -forward-unknown-to-host-compiler ${GPU_RTC_DEFINES} ${GPU_RTC_FLAGS_SEPARATED} -x cu -fatbin" > ${GPU_RTC_BIN}.command
     COMMAND_EXPAND_LISTS VERBATIM
     COMMENT "Preparing CUDA RTC command file ${GPU_RTC_BIN}.command"
 )
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
index 2b6ec52f25831..919b5c11477ef 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
@@ -16,6 +16,7 @@
 #define GPUCA_GPUCODE_COMPILEKERNELS
 #define GPUCA_RTC_SPECIAL_CODE(...) GPUCA_RTC_SPECIAL_CODE(__VA_ARGS__)
 #define GPUCA_DETERMINISTIC_CODE(...) GPUCA_DETERMINISTIC_CODE(__VA_ARGS__)
+// GPUReconstructionCUDAIncludesHost.h auto-prependended without preprocessor running
 #include "GPUReconstructionCUDADef.h"
 #include "GPUReconstructionIncludesDeviceAll.h"
 
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 33963d72be9ab..dd47f4fe8e78b 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -122,7 +122,7 @@ add_custom_target(${MODULE}_HIP_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/
 
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command
-    COMMAND echo -n "${CMAKE_HIP_COMPILER} ${GPU_RTC_FLAGS_SEPARATED} ${GPU_RTC_DEFINES} -x hip --cuda-device-only" > ${GPU_RTC_BIN}.command
+    COMMAND echo -n "${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_FLAGS_SEPARATED} -x hip --cuda-device-only" > ${GPU_RTC_BIN}.command
     COMMAND_EXPAND_LISTS VERBATIM
     COMMENT "Preparing HIP RTC command file ${GPU_RTC_BIN}.command"
 )

From 9e23cd32483a055c5770c572bc3bccb54d6be913 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 25 Mar 2025 17:25:15 +0100
Subject: [PATCH 0140/1764] GPU RTC: Fix float precision for constexpr
 optimization

---
 GPU/GPUTracking/utils/qconfig.h         | 12 ++++++------
 GPU/GPUTracking/utils/qconfig_helpers.h | 16 +++++++++++-----
 GPU/GPUTracking/utils/qconfigrtc.h      |  1 +
 3 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/GPU/GPUTracking/utils/qconfig.h b/GPU/GPUTracking/utils/qconfig.h
index 79a9bd757b531..bc755e583c3b7 100644
--- a/GPU/GPUTracking/utils/qconfig.h
+++ b/GPU/GPUTracking/utils/qconfig.h
@@ -250,12 +250,12 @@ enum qConfigRetVal { qcrOK = 0,
 #define AddVariable(name, type, default) out << qon_mxstr(type) << " " << qon_mxstr(name) << ";\n";
 #define AddOptionArray(name, type, count, default, optname, optnameshort, help, ...) out << qon_mxstr(type) << " " << qon_mxstr(name) << "[" << qon_mxstr(count) << "];\n";
 #define AddOptionVec(name, type, optname, optnameshort, help, ...) out << "std::vector<" << qon_mxstr(type) << "> " << qon_mxstr(name) << ";\n";
-#define AddVariableRTC(name, type, default)                                                                                                                            \
-  if (useConstexpr) {                                                                                                                                                  \
-    out << "static constexpr " << qon_mxstr(type) << " " << qon_mxstr(name) << " = " << qConfig::print_type(std::get<const qConfigCurrentType*>(tSrc)->name) << ";\n"; \
-    out << qon_mxstr(type) << " " << qon_mxstr(qon_mxcat(_dummy_, name)) << ";\n";                                                                                     \
-  } else {                                                                                                                                                             \
-    AddOption(name, type, default, optname, optnameshort, help);                                                                                                       \
+#define AddVariableRTC(name, type, default)                                                                                                                                  \
+  if (useConstexpr) {                                                                                                                                                        \
+    out << "static constexpr " << qon_mxstr(type) << " " << qon_mxstr(name) << " = " << qConfig::print_type(std::get<const qConfigCurrentType*>(tSrc)->name, true) << ";\n"; \
+    out << qon_mxstr(type) << " " << qon_mxstr(qon_mxcat(_dummy_, name)) << ";\n";                                                                                           \
+  } else {                                                                                                                                                                   \
+    AddOption(name, type, default, optname, optnameshort, help);                                                                                                             \
   }
 #define AddOptionRTC(name, type, default, optname, optnameshort, help, ...) AddVariableRTC(name, type, default)
 #define AddOptionArrayRTC(name, type, count, default, optname, optnameshort, help, ...)                                                                                            \
diff --git a/GPU/GPUTracking/utils/qconfig_helpers.h b/GPU/GPUTracking/utils/qconfig_helpers.h
index e721f08ccfa90..51c89b759e9cf 100644
--- a/GPU/GPUTracking/utils/qconfig_helpers.h
+++ b/GPU/GPUTracking/utils/qconfig_helpers.h
@@ -17,6 +17,7 @@
 
 #include <string>
 #include <sstream>
+#include <type_traits>
 
 #define qon_mcat(a, b) a##b
 #define qon_mxcat(a, b) qon_mcat(a, b)
@@ -30,29 +31,34 @@
 namespace qConfig
 {
 template <class T>
-inline std::string print_type(T val)
+inline std::string print_type(T val, bool precise = false)
 {
   std::ostringstream s;
+  if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>) {
+    if (precise) {
+      s << std::hexfloat;
+    }
+  }
   s << val;
   return s.str();
 };
 template <>
-inline std::string print_type<char>(char val)
+inline std::string print_type<char>(char val, bool precise)
 {
   return std::to_string(val);
 };
 template <>
-inline std::string print_type<int8_t>(int8_t val)
+inline std::string print_type<int8_t>(int8_t val, bool precise)
 {
   return std::to_string(val);
 };
 template <>
-inline std::string print_type<uint8_t>(uint8_t val)
+inline std::string print_type<uint8_t>(uint8_t val, bool precise)
 {
   return std::to_string(val);
 };
 template <>
-inline std::string print_type<bool>(bool val)
+inline std::string print_type<bool>(bool val, bool precise)
 {
   return val ? "true" : "false";
 };
diff --git a/GPU/GPUTracking/utils/qconfigrtc.h b/GPU/GPUTracking/utils/qconfigrtc.h
index 97365a6412c5d..8d33ef0ac6355 100644
--- a/GPU/GPUTracking/utils/qconfigrtc.h
+++ b/GPU/GPUTracking/utils/qconfigrtc.h
@@ -31,6 +31,7 @@ template <class T>
 static std::string qConfigPrintRtc(const T& tSrc, bool useConstexpr)
 {
   std::stringstream out;
+  out << std::hexfloat;
 #define QCONFIG_PRINT_RTC
 #include "qconfig.h"
 #undef QCONFIG_PRINT_RTC

From 2ddad04f95a74fda82460408df82a3ae8c35aae8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 25 Mar 2025 21:38:52 +0100
Subject: [PATCH 0141/1764] GPU CMake: Clean up and collect files / kernels to
 be compiled in deterministic mode in one place

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      | 14 +++-------
 GPU/GPUTracking/Base/hip/CMakeLists.txt       | 14 +++-------
 GPU/GPUTracking/CMakeLists.txt                | 26 +++++++++++--------
 .../Standalone/Benchmark/CMakeLists.txt       |  3 +--
 GPU/GPUTracking/cmake/kernel_helpers.cmake    | 23 ++++++++++++++++
 GPU/GPUTracking/display/CMakeLists.txt        |  3 ++-
 6 files changed, 47 insertions(+), 36 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index c1cc63aa0fc02..de54f09fdc2e1 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -122,8 +122,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       ${CMAKE_CURRENT_SOURCE_DIR}
     TARGETVARNAME targetName)
 
-  target_compile_definitions(${targetName} PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
-
   install(FILES ${HDRS} DESTINATION include/GPU)
 endif()
 
@@ -131,11 +129,14 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   set(targetName "${MODULE}")
   set(TMP_BASELIB GPUTracking)
   add_library(${MODULE} SHARED ${SRCS})
+  add_library(O2::${MODULE} ALIAS ${MODULE})
   target_link_libraries(${MODULE} PUBLIC ${TMP_BASELIB})
   install(TARGETS GPUTrackingCUDA)
   include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
+target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
+
 # Setting target architecture and adding GPU libraries
 target_link_libraries(${targetName} PRIVATE cuda cudart nvrtc)
 set_target_cuda_arch(${targetName})
@@ -170,15 +171,6 @@ elseif(GPUCA_CUDA_COMPILE_MODE STREQUAL "perkernel")
   target_sources(${targetName} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o)
   set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o PROPERTIES EXTERNAL_OBJECT true GENERATED true)
 
-  # Disable all non-deterministic floating point to make TPC track model encoding / decoding precise
-  set_source_files_properties(${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_GPUTPCCompressionKernels_step0attached.cu
-                              ${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_GPUTPCCompressionKernels_step1unattached.cu
-                              ${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_GPUTPCDecompressionKernels_step0attached.cu
-                              ${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_GPUTPCDecompressionKernels_step1unattached.cu
-                              TARGET_DIRECTORY ${targetName}
-                              PROPERTIES
-                              COMPILE_FLAGS "${GPUCA_CUDA_NO_FAST_MATH_FLAGS}"
-                              COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
 elseif(GPUCA_CUDA_COMPILE_MODE STREQUAL "rdc")
   message(FATAL_ERROR "CUDA RDC compilation of GPUReconstruction ios not yet working!")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=2)
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index dd47f4fe8e78b..43259decef956 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -160,8 +160,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       ${GPUCA_HIP_SOURCE_DIR}
     TARGETVARNAME targetName)
 
-  target_compile_definitions(${targetName} PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
-
   install(FILES ${HDRS} DESTINATION include/GPU)
 
 #  o2_add_test(GPUsortHIP NAME test_GPUsortHIP
@@ -175,11 +173,14 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   set(targetName "${MODULE}")
   set(TMP_BASELIB GPUTracking)
   add_library(${MODULE} SHARED ${SRCS})
+  add_library(O2::${MODULE} ALIAS ${MODULE})
   target_link_libraries(${MODULE} PUBLIC ${TMP_BASELIB})
   install(TARGETS GPUTrackingHIP)
   include_directories(${GPUCA_HIP_SOURCE_DIR})
 endif()
 
+target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
+
 add_library(${MODULE}_CXX OBJECT ${SRCS_CXX}) # Adding a C++ library for the .cxx code of the HIP library, such that it does not link to HIP libraries, and CMake HIP Language doesn't add HIP compile flags.
 target_compile_definitions(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:${TMP_BASELIB},COMPILE_DEFINITIONS>)
 target_include_directories(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:${TMP_BASELIB},INCLUDE_DIRECTORIES>)
@@ -228,15 +229,6 @@ elseif(GPUCA_HIP_COMPILE_MODE STREQUAL "perkernel")
   target_sources(${targetName} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o)
   set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o PROPERTIES EXTERNAL_OBJECT true GENERATED true)
 
-  # Disable all non-deterministic floating point to make TPC track model encoding / decoding precise
-  set_source_files_properties(${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_GPUTPCCompressionKernels_step0attached.hip
-                              ${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_GPUTPCCompressionKernels_step1unattached.hip
-                              ${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_GPUTPCDecompressionKernels_step0attached.hip
-                              ${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_GPUTPCDecompressionKernels_step1unattached.hip
-                              TARGET_DIRECTORY ${targetName}
-                              PROPERTIES
-                              COMPILE_FLAGS "${GPUCA_CXX_NO_FAST_MATH_FLAGS}"
-                              COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
 elseif(GPUCA_HIP_COMPILE_MODE STREQUAL "rdc")
   message(FATAL_ERROR "HIP RDC compilation of GPUReconstruction ios not yet working!")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=2)
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index dedfcf5953394..ba2b9d05a3192 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -372,16 +372,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   endif()
 endif()
 
-# Disable all non-deterministic floating point to make TPC track model encoding / decoding precise
-set_source_files_properties(DataCompression/GPUTPCCompressionTrackModel.cxx
-                            DataCompression/GPUTPCCompressionKernels.cxx
-                            DataCompression/TPCClusterDecompressor.cxx
-                            DataCompression/GPUTPCDecompressionKernels.cxx
-                            TARGET_DIRECTORY ${targetName}
-                            PROPERTIES
-                            COMPILE_FLAGS "${GPUCA_CXX_NO_FAST_MATH_FLAGS}"
-                            COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
-
 # GPUReconstructionLibrary needs to know which GPU backends are enabled for proper error messages
 configure_file(Base/GPUReconstructionAvailableBackends.template.h ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionAvailableBackends.h)
 set_source_files_properties(Base/GPUReconstructionLibrary.cxx
@@ -423,5 +413,19 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2" OR ALIGPU_BUILD_TYPE STREQUAL "Standalone")
 endif()
 
 if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_GPU})
-  target_compile_definitions(${targetName} PUBLIC GPUCA_DETERMINISTIC_MODE)
+  target_compile_definitions(${targetName} PRIVATE GPUCA_DETERMINISTIC_MODE)
 endif()
+
+# Disable all non-deterministic floating point to make TPC track model encoding / decoding precise
+set_source_files_properties(DataCompression/GPUTPCCompressionTrackModel.cxx
+                            DataCompression/GPUTPCCompressionKernels.cxx
+                            DataCompression/TPCClusterDecompressor.cxx
+                            DataCompression/GPUTPCDecompressionKernels.cxx
+                            TARGET_DIRECTORY ${targetName}
+                            PROPERTIES
+                            COMPILE_FLAGS "${GPUCA_CXX_NO_FAST_MATH_FLAGS}"
+                            COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
+o2_gpu_kernel_set_deterministic(GPUTPCCompressionKernels_step0attached
+                                GPUTPCCompressionKernels_step1unattached
+                                GPUTPCDecompressionKernels_step0attached
+                                GPUTPCDecompressionKernels_step1unattached)
diff --git a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
index e418d94b62cb2..eeafcfc44142d 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
@@ -28,10 +28,9 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
     add_executable(ca ${SRCS})
     set(targetName ca)
     target_link_libraries(${targetName} PUBLIC GPUTracking)
-
 endif()
 
-target_compile_definitions(${targetName} PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
+target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
 if(ROOT_FOUND)
   target_sources(${targetName} PRIVATE ../../qa/genEvents.cxx)
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index 1f35b6fc468b2..e63b915640e8a 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -142,3 +142,26 @@ function(o2_gpu_kernel_file_list list)
   list(REMOVE_DUPLICATES TMP_FILE_LIST)
   set_property(TARGET O2_GPU_KERNELS PROPERTY O2_GPU_KERNELS_FILE_LIST_${list} "${TMP_FILE_LIST}")
 endfunction()
+
+function(o2_gpu_kernel_set_deterministic)
+  if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_GPU})
+    list(LENGTH ARGV n)
+    math(EXPR n "${n} - 1")
+    foreach(i RANGE 0 ${n})
+      if(CUDA_ENABLED AND (NOT DEFINED GPUCA_CUDA_COMPILE_MODE OR GPUCA_CUDA_COMPILE_MODE STREQUAL "perkernel"))
+        set_source_files_properties("${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${ARGV${i}}.cu"
+                                    TARGET_DIRECTORY O2::GPUTrackingCUDA
+                                    PROPERTIES
+                                    COMPILE_FLAGS "${GPUCA_CUDA_NO_FAST_MATH_FLAGS}"
+                                    COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
+      endif()
+      if(HIP_ENABLED AND (NOT DEFINED GPUCA_HIP_COMPILE_MODE OR GPUCA_HIP_COMPILE_MODE STREQUAL "perkernel"))
+        set_source_files_properties("${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${ARGV${i}}.hip"
+                                    TARGET_DIRECTORY O2::GPUTrackingHIP
+                                    PROPERTIES
+                                    COMPILE_FLAGS "${GPUCA_CXX_NO_FAST_MATH_FLAGS}"
+                                    COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
+      endif()
+    endforeach()
+  endif()
+endfunction()
diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index b3107dbec8c79..592ba3b38ff30 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -131,7 +131,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                  PUBLIC_INCLUDE_DIRECTORIES .
              SOURCES ${SRCS} ${SRCS_NO_H})
 
-  target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
   target_compile_definitions(${targetName} PRIVATE GPUCA_BUILD_EVENT_DISPLAY_GLFW GPUCA_DISPLAY_GL3W GPUCA_DISPLAY_OPENGL_CORE)
 
   install(FILES ${HDRS} ${HDRS_INSTALL} DESTINATION include/GPU)
@@ -158,6 +157,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/setinclude.sh PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE DESTINATION displayTrackFilter)
 endif()
 
+target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
+
 message(STATUS "Building GPU Event Display (Vulkan ${GPUCA_EVENT_DISPLAY_VULKAN}, Wayland ${GPUCA_EVENT_DISPLAY_WAYLAND}, Freetype ${GPUCA_EVENT_DISPLAY_FREETYPE}, Fontconfig ${Fontconfig_FOUND}, Qt ${GPUCA_EVENT_DISPLAY_QT})")
 target_link_libraries(${targetName} PUBLIC ${GLFW_LIBRARIES} OpenGL::GL)
 target_include_directories(${targetName} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})

From 8b6d22efaaccadcd2ca2d3c991ce692d5529cfe8 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Wed, 26 Mar 2025 10:17:13 +0100
Subject: [PATCH 0142/1764] Update CODEOWNERS (#14110)

* Update CODEOWNERS

Add @fprino to the ITS-related code owners.
---
 CODEOWNERS | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 3f6f4a9e42600..a22b122d0e6cd 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -34,7 +34,7 @@
 /DataFormats/Detectors/GlobalTracking          @shahor02
 /DataFormats/Detectors/GlobalTrackingWorkflow  @shahor02
 /DataFormats/Detectors/HMPID                   @gvolpe79
-/DataFormats/Detectors/ITSMFT                  @mcoquet642 @mconcas @shahor02
+/DataFormats/Detectors/ITSMFT                  @fprino @mcoquet642 @mconcas @shahor02
 /DataFormats/Detectors/MUON                    @AliceO2Group/muon-experts @shahor02
 /DataFormats/Detectors/PHOS                    @peressounko @kharlov
 /DataFormats/Detectors/Passive                 @sawenzel
@@ -65,7 +65,7 @@
 /Detectors/GlobalTracking          @shahor02
 /Detectors/GlobalTrackingWorkflow  @shahor02
 /Detectors/HMPID                   @gvolpe79
-/Detectors/ITSMFT                  @mcoquet642 @mconcas @shahor02
+/Detectors/ITSMFT                  @fprino @mcoquet642 @mconcas @shahor02
 /Detectors/MUON                    @AliceO2Group/muon-experts @shahor02
 /Detectors/PHOS                    @peressounko @kharlov
 /Detectors/Passive                 @sawenzel

From f26e72529547ff5eeca7889f6e0e6ccf1a9bf71d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 26 Mar 2025 08:32:53 +0100
Subject: [PATCH 0143/1764] GPU: Cleanup unused template parameter

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx                | 1 +
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu        | 2 +-
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h         | 2 +-
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu | 8 +++-----
 4 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index d96d5aad74622..9b6562d8e77ee 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -273,6 +273,7 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     if (mProcessingSettings.createO2Output > 1) {
       mProcessingSettings.createO2Output = 1;
     }
+    mProcessingSettings.rtc.deterministic = 1;
   }
   if (mProcessingSettings.deterministicGPUReconstruction && mProcessingSettings.debugLevel >= 6) {
     mProcessingSettings.nTPCClustererLanes = 1;
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 175fd205153ea..75ac0b5f18327 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -618,7 +618,7 @@ void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
 {
   uint32_t j = 0;
 #define GPUCA_KRNL(x_class, ...)                                                                                                                                                        \
-  getRTCkernelNum<false, GPUCA_M_KRNL_TEMPLATE(x_class)>(mInternals->kernelFunctions.size());                                                                                           \
+  getRTCkernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>(mInternals->kernelFunctions.size());                                                                                                  \
   mInternals->kernelFunctions.emplace_back(new CUfunction);                                                                                                                             \
   mInternals->kernelNames.emplace_back(GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))));                                                                                    \
   if (mProcessingSettings.debugLevel >= 3) {                                                                                                                                            \
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 30bbc76d4c415..9b80880b4fb3c 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -49,7 +49,7 @@ class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
   template <class T, int32_t I>
   class backendInternal;
 
-  template <bool multi, class T, int32_t I = 0>
+  template <class T, int32_t I = 0>
   static int32_t getRTCkernelNum(int32_t k = -1);
 
   void getRTCKernelCalls(std::vector<std::string>& kernels);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index f1f459fe021bc..f0c9ba46c4a56 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -55,7 +55,7 @@ inline void GPUReconstructionCUDABackend::runKernelBackendInternal(const krnlSet
 #endif
     pArgs[arg_offset] = &y.index;
     GPUReconstructionCUDAInternals::getArgPtrs(&pArgs[arg_offset + 1], args...);
-    GPUChkErr(cuLaunchKernel(*mInternals->kernelFunctions[getRTCkernelNum<false, T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
+    GPUChkErr(cuLaunchKernel(*mInternals->kernelFunctions[getRTCkernelNum<T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
   }
 }
 
@@ -111,7 +111,7 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
 
-template <bool multi, class T, int32_t I>
+template <class T, int32_t I>
 int32_t GPUReconstructionCUDABackend::getRTCkernelNum(int32_t k)
 {
   static int32_t num = k;
@@ -121,9 +121,7 @@ int32_t GPUReconstructionCUDABackend::getRTCkernelNum(int32_t k)
   return num;
 }
 
-#define GPUCA_KRNL(x_class, ...)                                                                                    \
-  template int32_t GPUReconstructionCUDABackend::getRTCkernelNum<false, GPUCA_M_KRNL_TEMPLATE(x_class)>(int32_t k); \
-  template int32_t GPUReconstructionCUDABackend::getRTCkernelNum<true, GPUCA_M_KRNL_TEMPLATE(x_class)>(int32_t k);
+#define GPUCA_KRNL(x_class, ...) template int32_t GPUReconstructionCUDABackend::getRTCkernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>(int32_t k);
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
 

From 95ae41ee037afd6c167e95a6bb98c1f92c389811 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 26 Mar 2025 13:15:36 +0100
Subject: [PATCH 0144/1764] GPU: Unify creation of list of kernel names and
 kernel numbers

---
 .../Base/GPUReconstructionProcessing.cxx      | 36 +++++++++++++++++++
 .../Base/GPUReconstructionProcessing.h        | 16 ++++-----
 .../Base/cuda/GPUReconstructionCUDA.cu        |  8 ++---
 .../Base/cuda/GPUReconstructionCUDA.h         |  5 ---
 .../cuda/GPUReconstructionCUDAInternals.h     |  1 -
 .../Base/cuda/GPUReconstructionCUDAKernels.cu | 16 +--------
 .../Base/opencl/GPUReconstructionOCL.cxx      |  2 +-
 .../Base/opencl/GPUReconstructionOCL.h        |  2 --
 .../opencl/GPUReconstructionOCLIncludesHost.h |  2 +-
 .../opencl/GPUReconstructionOCLKernels.cxx    | 19 ++--------
 10 files changed, 51 insertions(+), 56 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
index 51c48ebbfc0b2..074c4faeb2926 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
@@ -124,3 +124,39 @@ std::unique_ptr<gpu_reconstruction_kernels::threadContext> GPUReconstructionProc
 
 gpu_reconstruction_kernels::threadContext::threadContext() = default;
 gpu_reconstruction_kernels::threadContext::~threadContext() = default;
+
+template <class T, int32_t I>
+uint32_t GPUReconstructionProcessing::GetKernelNum(int32_t k)
+{
+  static int32_t num = k;
+  if (num < 0) {
+    throw std::runtime_error("Internal Error - Kernel Number not Set");
+  }
+  return num;
+}
+
+namespace o2::gpu::internal
+{
+static std::vector<std::string> initKernelNames()
+{
+  std::vector<std::string> retVal;
+#define GPUCA_KRNL(x_class, ...)                                                            \
+  GPUReconstructionProcessing::GetKernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>(retVal.size()); \
+  retVal.emplace_back(GPUCA_M_STR(GPUCA_M_KRNL_NAME(x_class)));
+#include "GPUReconstructionKernelList.h"
+#undef GPUCA_KRNL
+  return retVal;
+}
+} // namespace o2::gpu::internal
+
+const std::vector<std::string> GPUReconstructionProcessing::mKernelNames = o2::gpu::internal::initKernelNames();
+
+#define GPUCA_KRNL(x_class, ...)                                                                        \
+  template uint32_t GPUReconstructionProcessing::GetKernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>(int32_t); \
+  template <>                                                                                           \
+  const char* GPUReconstructionProcessing::GetKernelName<GPUCA_M_KRNL_TEMPLATE(x_class)>()              \
+  {                                                                                                     \
+    return GPUCA_M_STR(GPUCA_M_KRNL_NAME(x_class));                                                     \
+  }
+#include "GPUReconstructionKernelList.h"
+#undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index 43560616782db..4e763f07b4396 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -74,7 +74,10 @@ class GPUReconstructionProcessing : public GPUReconstruction
 
   // Interface to query name of a kernel
   template <class T, int32_t I>
-  constexpr static const char* GetKernelName();
+  static const char* GetKernelName();
+  const std::string& GetKernelName(int32_t i) const { return mKernelNames[i]; }
+  template <class T, int32_t I = 0>
+  static uint32_t GetKernelNum(int32_t k = -1);
 
   // Public queries for timers
   auto& getRecoStepTimer(RecoStep step) { return mTimersRecoSteps[getRecoStepNum(step)]; }
@@ -100,6 +103,8 @@ class GPUReconstructionProcessing : public GPUReconstruction
   GPUReconstructionProcessing(const GPUSettingsDeviceBackend& cfg) : GPUReconstruction(cfg) {}
   using deviceEvent = gpu_reconstruction_kernels::deviceEvent;
 
+  static const std::vector<std::string> mKernelNames;
+
   int32_t mActiveHostKernelThreads = 0;  // Number of currently active threads on the host for kernels
   uint32_t mNActiveThreadsOuterLoop = 1; // Number of threads currently running an outer loop
 
@@ -174,15 +179,6 @@ HighResTimer& GPUReconstructionProcessing::getTimer(const char* name, int32_t nu
   return timer->timer[num];
 }
 
-#define GPUCA_KRNL(x_class, ...)                                                                     \
-  template <>                                                                                        \
-  constexpr const char* GPUReconstructionProcessing::GetKernelName<GPUCA_M_KRNL_TEMPLATE(x_class)>() \
-  {                                                                                                  \
-    return GPUCA_M_STR(GPUCA_M_KRNL_NAME(x_class));                                                  \
-  }
-#include "GPUReconstructionKernelList.h"
-#undef GPUCA_KRNL
-
 } // namespace o2::gpu
 
 #endif
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 75ac0b5f18327..f87d5c8189cdc 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -610,7 +610,7 @@ void GPUReconstructionCUDABackend::PrintKernelOccupancies()
     GPUChkErr(cuOccupancyMaxActiveBlocksPerMultiprocessor(&maxBlocks, *mInternals->kernelFunctions[i], threads, 0));
     GPUChkErr(cuFuncGetAttribute(&nRegs, CU_FUNC_ATTRIBUTE_NUM_REGS, *mInternals->kernelFunctions[i]));
     GPUChkErr(cuFuncGetAttribute(&sMem, CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES, *mInternals->kernelFunctions[i]));
-    GPUInfo("Kernel: %50s Block size: %4d, Maximum active blocks: %3d, Suggested blocks: %3d, Regs: %3d, smem: %3d", mInternals->kernelNames[i].c_str(), threads, maxBlocks, suggestedBlocks, nRegs, sMem);
+    GPUInfo("Kernel: %50s Block size: %4d, Maximum active blocks: %3d, Suggested blocks: %3d, Regs: %3d, smem: %3d", GetKernelName(i).c_str(), threads, maxBlocks, suggestedBlocks, nRegs, sMem);
   }
 }
 
@@ -618,9 +618,10 @@ void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
 {
   uint32_t j = 0;
 #define GPUCA_KRNL(x_class, ...)                                                                                                                                                        \
-  getRTCkernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>(mInternals->kernelFunctions.size());                                                                                                  \
+  if (GetKernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>() != j) {                                                                                                                            \
+    GPUFatal("kernel numbers out of sync");                                                                                                                                             \
+  }                                                                                                                                                                                     \
   mInternals->kernelFunctions.emplace_back(new CUfunction);                                                                                                                             \
-  mInternals->kernelNames.emplace_back(GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))));                                                                                    \
   if (mProcessingSettings.debugLevel >= 3) {                                                                                                                                            \
     GPUInfo("Loading kernel %s (j = %u)", GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), j);                                                                              \
   }                                                                                                                                                                                     \
@@ -628,7 +629,6 @@ void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
   j++;
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
-
   if (j != mInternals->kernelModules.size()) {
     GPUFatal("Did not load all kernels (%u < %u)", j, (uint32_t)mInternals->kernelModules.size());
   }
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 9b80880b4fb3c..a98b14a873ca0 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -46,11 +46,6 @@ class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
   void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
   template <class T, int32_t I = 0>
   gpu_reconstruction_kernels::krnlProperties getKernelPropertiesBackend();
-  template <class T, int32_t I>
-  class backendInternal;
-
-  template <class T, int32_t I = 0>
-  static int32_t getRTCkernelNum(int32_t k = -1);
 
   void getRTCKernelCalls(std::vector<std::string>& kernels);
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
index c85d98d85420e..f3fc21243ef0e 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
@@ -30,7 +30,6 @@ namespace o2::gpu
 struct GPUReconstructionCUDAInternals {
   std::vector<std::unique_ptr<CUmodule>> kernelModules;     // module for RTC compilation
   std::vector<std::unique_ptr<CUfunction>> kernelFunctions; // vector of ptrs to RTC kernels
-  std::vector<std::string> kernelNames;                     // names of kernels
   cudaStream_t Streams[GPUCA_MAX_STREAMS];                  // Pointer to array of CUDA Streams
 
   static void getArgPtrs(const void** pArgs) {}
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index f0c9ba46c4a56..4b3f8a767226c 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -55,7 +55,7 @@ inline void GPUReconstructionCUDABackend::runKernelBackendInternal(const krnlSet
 #endif
     pArgs[arg_offset] = &y.index;
     GPUReconstructionCUDAInternals::getArgPtrs(&pArgs[arg_offset + 1], args...);
-    GPUChkErr(cuLaunchKernel(*mInternals->kernelFunctions[getRTCkernelNum<T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
+    GPUChkErr(cuLaunchKernel(*mInternals->kernelFunctions[GetKernelNum<T, I>()], x.nBlocks, 1, 1, x.nThreads, 1, 1, 0, mInternals->Streams[x.stream], (void**)pArgs, nullptr));
   }
 }
 
@@ -111,20 +111,6 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
 
-template <class T, int32_t I>
-int32_t GPUReconstructionCUDABackend::getRTCkernelNum(int32_t k)
-{
-  static int32_t num = k;
-  if (num < 0) {
-    throw std::runtime_error("Invalid kernel");
-  }
-  return num;
-}
-
-#define GPUCA_KRNL(x_class, ...) template int32_t GPUReconstructionCUDABackend::getRTCkernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>(int32_t k);
-#include "GPUReconstructionKernelList.h"
-#undef GPUCA_KRNL
-
 void GPUReconstructionCUDABackend::getRTCKernelCalls(std::vector<std::string>& kernels)
 {
 #define GPUCA_KRNL(...) kernels.emplace_back(GPUCA_M_STR(GPUCA_KRNLGPU(__VA_ARGS__)));
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index e92205b9864e6..e724f0f2cbfcd 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -399,7 +399,7 @@ int32_t GPUReconstructionOCLBackend::ExitDevice_Runtime()
       clReleaseMemObject(mInternals->mem_gpu);
       clReleaseMemObject(mInternals->mem_constant);
       for (uint32_t i = 0; i < mInternals->kernels.size(); i++) {
-        clReleaseKernel(mInternals->kernels[i].first);
+        clReleaseKernel(mInternals->kernels[i]);
       }
       mInternals->kernels.clear();
     }
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index 2abae229c74bb..29951cd43f167 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -56,8 +56,6 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
 
   template <class T, int32_t I = 0>
   int32_t AddKernel();
-  template <class T, int32_t I = 0>
-  uint32_t FindKernel();
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
   template <class T, int32_t I = 0>
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
index 97316cf9aa32e..0bb2f25093789 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
@@ -49,7 +49,7 @@ struct GPUReconstructionOCLInternals {
   cl_mem mem_host;
   cl_program program;
 
-  std::vector<std::pair<cl_kernel, std::string>> kernels;
+  std::vector<cl_kernel> kernels;
 };
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index ce6b6553ae1f7..fff69038c056f 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -58,20 +58,6 @@ void GPUReconstructionOCLBackend::runKernelBackend(const krnlSetupArgs<T, I, Arg
   std::apply([this, &args](auto&... vals) { runKernelBackendInternal<T, I, Args...>(args.s, vals...); }, args.v);
 }
 
-template <class T, int32_t I>
-inline uint32_t GPUReconstructionOCLBackend::FindKernel()
-{
-  std::string name(GetKernelName<T, I>());
-
-  for (uint32_t k = 0; k < mInternals->kernels.size(); k++) {
-    if (mInternals->kernels[k].second == name) {
-      return (k);
-    }
-  }
-  GPUError("Could not find OpenCL kernel %s", name.c_str());
-  throw ::std::runtime_error("Requested unsupported OpenCL kernel");
-}
-
 template <class T, int32_t I>
 int32_t GPUReconstructionOCLBackend::AddKernel()
 {
@@ -84,15 +70,14 @@ int32_t GPUReconstructionOCLBackend::AddKernel()
     GPUError("Error creating OPENCL Kernel: %s", name.c_str());
     return 1;
   }
-  mInternals->kernels.emplace_back(krnl, name);
+  mInternals->kernels.emplace_back(krnl);
   return 0;
 }
 
 template <class S, class T, int32_t I>
 S& GPUReconstructionOCLBackend::getKernelObject()
 {
-  static uint32_t krnl = FindKernel<T, I>();
-  return mInternals->kernels[krnl].first;
+  return mInternals->kernels[GetKernelNum<T, I>()];
 }
 
 int32_t GPUReconstructionOCLBackend::AddKernels()

From 5f90f0cc2e80b9f801a72fce3f7c8ba68a27275a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 26 Mar 2025 13:18:16 +0100
Subject: [PATCH 0145/1764] GPU: Solve a todo to make the timer atomic flag a
 member variable

---
 .../Base/GPUReconstructionProcessing.cxx      | 40 ++++++++-----------
 .../Base/GPUReconstructionProcessing.h        |  3 ++
 2 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
index 074c4faeb2926..bae95ac8d3f38 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
@@ -57,17 +57,24 @@ void GPUReconstructionProcessing::runParallelOuterLoop(bool doGPU, uint32_t nThr
   }
 }
 
-namespace o2::gpu
-{
-namespace // anonymous
+uint32_t GPUReconstructionProcessing::SetAndGetNActiveThreadsOuterLoop(bool condition, uint32_t max)
 {
-static std::atomic_flag timerFlag = ATOMIC_FLAG_INIT; // TODO: Should be a class member not global, but cannot be moved to header due to ROOT limitation
-} // anonymous namespace
-} // namespace o2::gpu
+  if (condition && mProcessingSettings.inKernelParallel != 1) {
+    mNActiveThreadsOuterLoop = mProcessingSettings.inKernelParallel == 2 ? std::min<uint32_t>(max, mMaxHostThreads) : mMaxHostThreads;
+  } else {
+    mNActiveThreadsOuterLoop = 1;
+  }
+  if (mProcessingSettings.debugLevel >= 5) {
+    printf("Running %d threads in outer loop\n", mNActiveThreadsOuterLoop);
+  }
+  return mNActiveThreadsOuterLoop;
+}
+
+std::atomic_flag GPUReconstructionProcessing::mTimerFlag = ATOMIC_FLAG_INIT;
 
 GPUReconstructionProcessing::timerMeta* GPUReconstructionProcessing::insertTimer(uint32_t id, std::string&& name, int32_t J, int32_t num, int32_t type, RecoStep step)
 {
-  while (timerFlag.test_and_set()) {
+  while (mTimerFlag.test_and_set()) {
   }
   if (mTimers.size() <= id) {
     mTimers.resize(id + 1);
@@ -81,20 +88,20 @@ GPUReconstructionProcessing::timerMeta* GPUReconstructionProcessing::insertTimer
     mTimers[id]->count++;
   }
   timerMeta* retVal = mTimers[id].get();
-  timerFlag.clear();
+  mTimerFlag.clear();
   return retVal;
 }
 
 GPUReconstructionProcessing::timerMeta* GPUReconstructionProcessing::getTimerById(uint32_t id, bool increment)
 {
   timerMeta* retVal = nullptr;
-  while (timerFlag.test_and_set()) {
+  while (mTimerFlag.test_and_set()) {
   }
   if (mTimers.size() > id && mTimers[id]) {
     retVal = mTimers[id].get();
     retVal->count += increment;
   }
-  timerFlag.clear();
+  mTimerFlag.clear();
   return retVal;
 }
 
@@ -104,19 +111,6 @@ uint32_t GPUReconstructionProcessing::getNextTimerId()
   return id.fetch_add(1);
 }
 
-uint32_t GPUReconstructionProcessing::SetAndGetNActiveThreadsOuterLoop(bool condition, uint32_t max)
-{
-  if (condition && mProcessingSettings.inKernelParallel != 1) {
-    mNActiveThreadsOuterLoop = mProcessingSettings.inKernelParallel == 2 ? std::min<uint32_t>(max, mMaxHostThreads) : mMaxHostThreads;
-  } else {
-    mNActiveThreadsOuterLoop = 1;
-  }
-  if (mProcessingSettings.debugLevel >= 5) {
-    printf("Running %d threads in outer loop\n", mNActiveThreadsOuterLoop);
-  }
-  return mNActiveThreadsOuterLoop;
-}
-
 std::unique_ptr<gpu_reconstruction_kernels::threadContext> GPUReconstructionProcessing::GetThreadContext()
 {
   return std::make_unique<gpu_reconstruction_kernels::threadContext>();
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index 4e763f07b4396..b0466efceac24 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -20,6 +20,7 @@
 
 #include "utils/timer.h"
 #include <functional>
+#include <atomic>
 
 namespace o2::gpu
 {
@@ -135,6 +136,8 @@ class GPUReconstructionProcessing : public GPUReconstruction
   uint32_t getNextTimerId();
   timerMeta* getTimerById(uint32_t id, bool increment = true);
   timerMeta* insertTimer(uint32_t id, std::string&& name, int32_t J, int32_t num, int32_t type, RecoStep step);
+
+  static std::atomic_flag mTimerFlag;
 };
 
 template <class T>

From fa403b41e99557774185f49657b0910bb2dbd327 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 26 Mar 2025 08:33:25 +0100
Subject: [PATCH 0146/1764] GPU: Propagate list of noFastMathKernels to GPU RTC
 and apply special compile settings

---
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx | 13 ++++--
 GPU/GPUTracking/CMakeLists.txt                |  4 ++
 .../cmake/GPUNoFastMathKernels.template.h     | 23 +++++++++++
 GPU/GPUTracking/cmake/kernel_helpers.cmake    | 40 +++++++++----------
 4 files changed, 57 insertions(+), 23 deletions(-)
 create mode 100644 GPU/GPUTracking/cmake/GPUNoFastMathKernels.template.h

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index e789dc9b9ebc3..51d3bd4044e8d 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -31,11 +31,12 @@ QGET_LD_BINARY_SYMBOLS(GPUReconstructionCUDArtc_command);
 QGET_LD_BINARY_SYMBOLS(GPUReconstructionCUDArtc_command_arch);
 QGET_LD_BINARY_SYMBOLS(GPUReconstructionCUDArtc_command_no_fast_math);
 
+#include "GPUNoFastMathKernels.h"
+
 int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
 {
   std::string rtcparam = std::string("#define GPUCA_RTC_CODE\n") +
                          std::string(mProcessingSettings.rtc.optSpecialCode ? "#define GPUCA_RTC_SPECIAL_CODE(...) __VA_ARGS__\n" : "#define GPUCA_RTC_SPECIAL_CODE(...)\n") +
-                         std::string(mProcessingSettings.rtc.deterministic ? "#define GPUCA_DETERMINISTIC_CODE(det, indet) det\n" : "#define GPUCA_DETERMINISTIC_CODE(det, indet) indet\n") +
                          GPUParamRTC::generateRTCCode(param(), mProcessingSettings.rtc.optConstexpr);
   if (filename == "") {
     filename = "/tmp/o2cagpu_rtc_";
@@ -54,7 +55,6 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
   std::string baseCommand = (mProcessingSettings.RTCprependCommand != "" ? (mProcessingSettings.RTCprependCommand + " ") : "");
   baseCommand += (getenv("O2_GPU_RTC_OVERRIDE_CMD") ? std::string(getenv("O2_GPU_RTC_OVERRIDE_CMD")) : std::string(_binary_GPUReconstructionCUDArtc_command_start, _binary_GPUReconstructionCUDArtc_command_len));
   baseCommand += std::string(" ") + (mProcessingSettings.RTCoverrideArchitecture != "" ? mProcessingSettings.RTCoverrideArchitecture : std::string(_binary_GPUReconstructionCUDArtc_command_arch_start, _binary_GPUReconstructionCUDArtc_command_arch_len));
-  baseCommand += mProcessingSettings.rtc.deterministic ? (std::string(" ") + std::string(_binary_GPUReconstructionCUDArtc_command_no_fast_math_start, _binary_GPUReconstructionCUDArtc_command_no_fast_math_len)) : std::string("");
 
   char shasource[21], shaparam[21], shacmd[21], shakernels[21];
   if (mProcessingSettings.rtc.cacheOutput) {
@@ -169,13 +169,20 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       kernel += mProcessingSettings.rtc.compilePerKernel ? kernels[i] : kernelsall;
       kernel += "}";
 
-      if (fwrite(rtcparam.c_str(), 1, rtcparam.size(), fp) != rtcparam.size() ||
+      bool deterministic = mProcessingSettings.rtc.deterministic || o2::gpu::internal::noFastMathKernels.find(GetKernelName(i)) != o2::gpu::internal::noFastMathKernels.end();
+      const std::string deterministicStr = std::string(deterministic ? "#define GPUCA_DETERMINISTIC_CODE(det, indet) det\n" : "#define GPUCA_DETERMINISTIC_CODE(det, indet) indet\n");
+
+      if (fwrite(deterministicStr.c_str(), 1, deterministicStr.size(), fp) != deterministicStr.size() ||
+          fwrite(rtcparam.c_str(), 1, rtcparam.size(), fp) != rtcparam.size() ||
           fwrite(_binary_GPUReconstructionCUDArtc_src_start, 1, _binary_GPUReconstructionCUDArtc_src_len, fp) != _binary_GPUReconstructionCUDArtc_src_len ||
           fwrite(kernel.c_str(), 1, kernel.size(), fp) != kernel.size()) {
         throw std::runtime_error("Error writing file");
       }
       fclose(fp);
       std::string command = baseCommand;
+      if (deterministic) {
+        command += std::string(" ") + std::string(_binary_GPUReconstructionCUDArtc_command_no_fast_math_start, _binary_GPUReconstructionCUDArtc_command_no_fast_math_len);
+      }
       command += " -c " + filename + "_" + std::to_string(i) + mRtcSrcExtension + " -o " + filename + "_" + std::to_string(i) + mRtcBinExtension;
       if (mProcessingSettings.debugLevel < 0) {
         command += " &> /dev/null";
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index ba2b9d05a3192..631f9f0edff4f 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -242,6 +242,10 @@ file(GENERATE
      OUTPUT include_gpu_onthefly/GPUReconstructionIncludesDeviceAll.h
      INPUT Base/GPUReconstructionIncludesDeviceAll.template.h
 )
+file(GENERATE
+     OUTPUT include_gpu_onthefly/GPUNoFastMathKernels.h
+     INPUT cmake/GPUNoFastMathKernels.template.h
+)
 if(NOT ALIGPU_BUILD_TYPE STREQUAL "O2")
   include_directories(${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
 endif()
diff --git a/GPU/GPUTracking/cmake/GPUNoFastMathKernels.template.h b/GPU/GPUTracking/cmake/GPUNoFastMathKernels.template.h
new file mode 100644
index 0000000000000..dac93277d5ec9
--- /dev/null
+++ b/GPU/GPUTracking/cmake/GPUNoFastMathKernels.template.h
@@ -0,0 +1,23 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUNoFastMathKernels.h
+/// \author David Rohr
+
+#include <unordered_set>
+#include <string>
+
+namespace o2::gpu::internal
+{
+// clang-format off
+static const std::unordered_set<std::string> noFastMathKernels = {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:REMOVE_DUPLICATES,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NO_FAST_MATH>>,APPEND,">,PREPEND,">,$<COMMA> >};
+// clang-format on
+} // namespace o2::gpu::internal
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index e63b915640e8a..99699cc72e940 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -17,6 +17,7 @@ define_property(TARGET PROPERTY O2_GPU_KERNELS)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_NAMES)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_INCLUDES)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_FILES)
+define_property(TARGET PROPERTY O2_GPU_KERNEL_NO_FAST_MATH)
 set(O2_GPU_KERNEL_WRAPPER_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/GPU/include_gpu_onthefly")
 file(MAKE_DIRECTORY ${O2_GPU_KERNEL_WRAPPER_FOLDER})
 set(O2_GPU_BASE_DIR "${CMAKE_CURRENT_LIST_DIR}/../")
@@ -144,24 +145,23 @@ function(o2_gpu_kernel_file_list list)
 endfunction()
 
 function(o2_gpu_kernel_set_deterministic)
-  if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_GPU})
-    list(LENGTH ARGV n)
-    math(EXPR n "${n} - 1")
-    foreach(i RANGE 0 ${n})
-      if(CUDA_ENABLED AND (NOT DEFINED GPUCA_CUDA_COMPILE_MODE OR GPUCA_CUDA_COMPILE_MODE STREQUAL "perkernel"))
-        set_source_files_properties("${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${ARGV${i}}.cu"
-                                    TARGET_DIRECTORY O2::GPUTrackingCUDA
-                                    PROPERTIES
-                                    COMPILE_FLAGS "${GPUCA_CUDA_NO_FAST_MATH_FLAGS}"
-                                    COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
-      endif()
-      if(HIP_ENABLED AND (NOT DEFINED GPUCA_HIP_COMPILE_MODE OR GPUCA_HIP_COMPILE_MODE STREQUAL "perkernel"))
-        set_source_files_properties("${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${ARGV${i}}.hip"
-                                    TARGET_DIRECTORY O2::GPUTrackingHIP
-                                    PROPERTIES
-                                    COMPILE_FLAGS "${GPUCA_CXX_NO_FAST_MATH_FLAGS}"
-                                    COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
-      endif()
-    endforeach()
-  endif()
+  list(LENGTH ARGV n)
+  math(EXPR n "${n} - 1")
+  foreach(i RANGE 0 ${n})
+    set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_NO_FAST_MATH "${ARGV${i}}")
+    if(CUDA_ENABLED AND (NOT DEFINED GPUCA_CUDA_COMPILE_MODE OR GPUCA_CUDA_COMPILE_MODE STREQUAL "perkernel"))
+      set_source_files_properties("${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${ARGV${i}}.cu"
+                                  TARGET_DIRECTORY O2::GPUTrackingCUDA
+                                  PROPERTIES
+                                  COMPILE_FLAGS "${GPUCA_CUDA_NO_FAST_MATH_FLAGS}"
+                                  COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
+    endif()
+    if(HIP_ENABLED AND (NOT DEFINED GPUCA_HIP_COMPILE_MODE OR GPUCA_HIP_COMPILE_MODE STREQUAL "perkernel"))
+      set_source_files_properties("${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${ARGV${i}}.hip"
+                                  TARGET_DIRECTORY O2::GPUTrackingHIP
+                                  PROPERTIES
+                                  COMPILE_FLAGS "${GPUCA_CXX_NO_FAST_MATH_FLAGS}"
+                                  COMPILE_DEFINITIONS "GPUCA_DETERMINISTIC_MODE")
+    endif()
+  endforeach()
 endfunction()

From 78d0f9c0d666f374acc8ed88efb383d75fdab388 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 26 Mar 2025 14:11:58 +0100
Subject: [PATCH 0147/1764] GPU Compile Flags: Set denormals to zero
 unconditionally

Before I kept them in NO_FAST_MATH mode, but this yields warning by nvcc,
which for some stupid reason cannot be disabled. And in principle,
with denormals globally disabled, it is also deterministic again,
and disabling it everywhere is as simple as enabling them everywhere.
---
 GPU/GPUTracking/Base/opencl/CMakeLists.txt        |  2 +-
 GPU/GPUTracking/CMakeLists.txt                    |  4 ++--
 GPU/GPUTracking/Definitions/GPUDefGPUParameters.h | 12 ++++++------
 dependencies/FindO2GPU.cmake                      | 12 +++++++++---
 4 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/Base/opencl/CMakeLists.txt b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
index 3da5b77f80d86..48f292a198b9c 100644
--- a/GPU/GPUTracking/Base/opencl/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
@@ -27,7 +27,7 @@ set(OCL_FLAGS -Dcl_clang_storage_class_specifiers -cl-std=CLC++2021)
 if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
   set(OCL_FLAGS ${OCL_FLAGS} -cl-denorms-are-zero -cl-mad-enable -cl-no-signed-zeros -cl-fast-relaxed-math)
 else()
-  set(OCL_FLAGS ${OCL_FLAGS} -cl-fp32-correctly-rounded-divide-sqrt)
+  set(OCL_FLAGS ${OCL_FLAGS} ${GPUCA_OCL_NO_FAST_MATH_FLAGS})
 endif()
 set(OCL_DEFINECL "-D$<JOIN:$<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>,$<SEMICOLON>-D>"
             "-I$<JOIN:$<FILTER:$<TARGET_PROPERTY:O2::GPUTracking,INCLUDE_DIRECTORIES>,EXCLUDE,^/usr/include/?>,$<SEMICOLON>-I>"
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 631f9f0edff4f..ad7dd9c210cd1 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -17,10 +17,10 @@ set(MODULE GPUTracking)
 if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
   set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
   if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_OPTO2})
-    set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O2")
+    set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O2 ${GPUCA_CLANG_FTZ}")
   endif()
 elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O3 -ffast-math")
+  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O3 -ffast-math ${GPUCA_CLANG_FTZ}")
 endif()
 
 include(cmake/helpers.cmake)
diff --git a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
index 5b5a89cc8bc39..910907368e891 100644
--- a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
+++ b/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
@@ -603,11 +603,11 @@
 // #define GPUCA_KERNEL_DEBUGGER_OUTPUT
 
 // Some assertions to make sure out parameters are not invalid
-  static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP, "Invalid GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP");
-  static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE");
-  #ifdef GPUCA_GPUCODE
-    static_assert(GPUCA_M_FIRST(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE, "Invalid GPUCA_TPC_COMP_CHUNK_SIZE");
-  #endif
+static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP, "Invalid GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP");
+static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE");
+#ifdef GPUCA_GPUCODE
+  static_assert(GPUCA_M_FIRST(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE, "Invalid GPUCA_TPC_COMP_CHUNK_SIZE");
+#endif
 
 // Derived parameters
 #ifdef GPUCA_USE_TEXTURES
@@ -621,5 +621,5 @@
 #define GPUCA_NEW_ALIGNMENT (std::align_val_t{GPUCA_BUFFER_ALIGNMENT})
 #define GPUCA_OPERATOR_NEW_ALIGNMENT ,GPUCA_NEW_ALIGNMENT
 
-    // clang-format on
+// clang-format on
 #endif
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 650a269209d9b..56b53e1be8879 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -84,8 +84,14 @@ elseif(NOT GPUCA_DETERMINISTIC_MODE MATCHES "^[0-9]+$")
   set(GPUCA_DETERMINISTIC_MODE ${GPUCA_DETERMINISTIC_MODE_MAP_${GPUCA_DETERMINISTIC_MODE}})
   message(STATUS "Set to ${GPUCA_DETERMINISTIC_MODE}")
 endif()
-set(GPUCA_CXX_NO_FAST_MATH_FLAGS "-fno-fast-math -ffp-contract=off")
-set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--ftz=false --prec-div=true --prec-sqrt=true --fmad false")
+if (CMAKE_SYSTEM_NAME MATCHES Darwin OR NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
+  set(GPUCA_CLANG_FTZ "")
+else()
+  set(GPUCA_CLANG_FTZ "-mdaz-ftz")
+endif()
+set(GPUCA_CXX_NO_FAST_MATH_FLAGS "-fno-fast-math -ffp-contract=off ${GPUCA_CLANG_FTZ}")
+set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--ftz=true --prec-div=true --prec-sqrt=true --fmad false")
+set(GPUCA_OCL_NO_FAST_MATH_FLAGS -cl-fp32-correctly-rounded-divide-sqrt -cl-denorms-are-zero)
 if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_WHOLEO2})
   add_definitions(-DGPUCA_DETERMINISTIC_MODE)
   set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
@@ -172,7 +178,7 @@ if(ENABLE_CUDA)
   endif()
 endif()
 
-# ---------------------------------- HIP ----------------------------------
+# ---------------------------------- OpenCL ----------------------------------
 if(ENABLE_OPENCL)
   find_package(OpenCL)
   if(ENABLE_OPENCL AND NOT ENABLE_OPENCL STREQUAL "AUTO")

From 81dad271ef926e4af9809038b0aa32c0bcaf0f66 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Thu, 27 Mar 2025 08:37:46 +0100
Subject: [PATCH 0148/1764] ITS Efficiency study: modified cuts and code
 cleanup (#13995)

* new method and checks

* Rebinning of Z and Phi efficiency plots

* ITS efficiency study: code cleanup

* Please consider the following formatting changes

* ITS efficiency study: raw pointers converted to smart pointers

* Please consider the following formatting changes

---------

Co-authored-by: Andrea Sofia Triolo <atriolo@flpits0.dyndns.cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../studies/include/ITSStudies/Efficiency.h   |   10 +-
 .../postprocessing/studies/src/Efficiency.cxx | 1675 +++++++++--------
 2 files changed, 841 insertions(+), 844 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/Efficiency.h b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/Efficiency.h
index 19df2279a2813..b6f43bb772390 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/Efficiency.h
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/Efficiency.h
@@ -28,15 +28,8 @@ namespace study
 using mask_t = o2::dataformats::GlobalTrackID::mask_t;
 o2::framework::DataProcessorSpec getEfficiencyStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC, std::shared_ptr<o2::steer::MCKinematicsReader> kineReader);
 
-////// phi cuts for B=0
-float mPhiCutsL0[10][2] = {{-122.5, -122}, {-91.8, -91.7}, {-61, -60}, {-30.1, -29.8}, {30, 30.2}, {59, 59.5}, {88, 89}, {117, 118.5}, {147, 147.8}, {176.5, 176.6}};
-float mPhiCutsL1[12][2] = {{-137, -136.5}, {-114, -113.5}, {-91.5, -91}, {-68.5, -68}, {-45.6, -45.4}, {-23.1, -22.9}, {45.4, 45.6}, {67.4, 67.6}, {89.4, 89.6}, {110.4, 110.6}, {132.4, 132.6}, {154.4, 154.6}};
-float mPhiCutsL2[17][2] = {{-162.85, -162.65}, {-145, -144.5}, {-127, -126.5}, {-109, -108.5}, {-91, -90.5}, {-73, -72.5}, {-55.1, -54.9}, {-37.35, -37.15}, {-19.5, -19}, {36.8, 37}, {54.4, 54.6}, {71.9, 72.1}, {89, 89.5}, {106.4, 106.6}, {123.65, 123.85}, {141.4, 141.6}, {158.9, 159.1}};
-
 float mEtaCuts[2] = {-1.0, 1.0};
-// float mPtCuts[2] = {1, 4.5}; //// for B=5
 float mPtCuts[2] = {0, 10}; /// no cut for B=0
-int mChi2cut = 100;
 
 // values obtained from the dca study for B=5
 // float dcaXY[3] = {-0.000326, -0.000217, -0.000187};
@@ -55,6 +48,9 @@ int dcaCut = 8;
 float mDCACutsXY[3][2] = {{dcaXY[0] - dcaCut * sigmaDcaXY[0], dcaXY[0] + dcaCut* sigmaDcaXY[0]}, {dcaXY[1] - dcaCut * sigmaDcaXY[1], dcaXY[1] + dcaCut* sigmaDcaXY[1]}, {dcaXY[2] - dcaCut * sigmaDcaXY[2], dcaXY[2] + dcaCut* sigmaDcaXY[2]}}; // cuts at 8 sigma for each layer for xy. The values represent m-8sigma and m+8sigma
 float mDCACutsZ[3][2] = {{dcaZ[0] - dcaCut * sigmaDcaZ[0], dcaZ[0] + dcaCut* sigmaDcaZ[0]}, {dcaZ[1] - dcaCut * sigmaDcaZ[1], dcaZ[1] + dcaCut* sigmaDcaZ[1]}, {dcaZ[2] - dcaCut * sigmaDcaZ[2], dcaZ[2] + dcaCut* sigmaDcaZ[2]}};
 
+/// excluding bad chips in MC that are not present in data: to be checked based on the anchoring
+std::vector<int> mExcludedChipMC = {66, 67, 68, 75, 76, 77, 84, 85, 86, 93, 94, 95, 102, 103, 104, 265, 266, 267, 274, 275, 276, 283, 284, 285, 413, 414, 415, 422, 423, 424, 431, 432, 433};
+
 } // namespace study
 } // namespace its
 } // namespace o2
diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/Efficiency.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/Efficiency.cxx
index 28e09e5d9a3be..bca1ec1e85001 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/Efficiency.cxx
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/Efficiency.cxx
@@ -43,6 +43,8 @@
 #include <TObjArray.h>
 #include <THStack.h>
 #include <TString.h>
+#include <TAttMarker.h>
+#include <TArrayD.h>
 #include <numeric>
 
 #define NLAYERS 3
@@ -75,8 +77,6 @@ class EfficiencyStudy : public Task
   void studyClusterSelectionMC();
   void countDuplicatedAfterCuts();
   void getEfficiency(bool isMC);
-  void getEfficiencyAndTrackInfo(bool isMC);
-  void saveDataInfo();
   void process(o2::globaltracking::RecoContainer&);
   void setClusterDictionary(const o2::itsmft::TopologyDictionary* d) { mDict = d; }
 
@@ -105,20 +105,14 @@ class EfficiencyStudy : public Task
   // Data
   GTrackID::mask_t mTracksSrc{};
   std::shared_ptr<DataRequest> mDataRequest;
-  unsigned short mMask = 0x7f;
 
   // Utils
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   std::unique_ptr<TFile> mOutFile;
   int mDuplicated_layer[NLAYERS] = {0};
-  const o2::parameters::GRPMagField* mGRPMagField = nullptr;
 
   //// Histos
-  // Distance betweeen original and duplicated clusters
-  std::unique_ptr<TH1D> mDistanceClustersX[NLAYERS];
-  std::unique_ptr<TH1D> mDistanceClustersY[NLAYERS];
-  std::unique_ptr<TH1D> mDistanceClustersZ[NLAYERS];
-  std::unique_ptr<TH1D> mDistanceClusters[NLAYERS];
+
   // DCA betweeen track and original cluster
   std::unique_ptr<TH1D> mDCAxyOriginal[NLAYERS];
   std::unique_ptr<TH1D> mDCAzOriginal[NLAYERS];
@@ -132,16 +126,12 @@ class EfficiencyStudy : public Task
 
   // phi, eta, pt of the cluster
   std::unique_ptr<TH1D> mPhiOriginal[NLAYERS];
-  std::unique_ptr<TH1D> mPhiTrackOriginal[NLAYERS];
   std::unique_ptr<TH1D> mEtaOriginal[NLAYERS];
   std::unique_ptr<TH1D> mPtOriginal[NLAYERS];
-  TH1D* mPtDuplicated[NLAYERS];
-  TH1D* mEtaDuplicated[NLAYERS];
-  TH1D* mPhiDuplicated[NLAYERS];
-  TH1D* mPhiTrackDuplicated[NLAYERS];
-  TH2D* mPhiTrackDuplicatedvsphiDuplicated[NLAYERS];
-  TH2D* mPhiTrackoriginalvsphioriginal[NLAYERS];
-  TH1D* mPhiOriginalIfDuplicated[NLAYERS];
+  std::unique_ptr<TH1D> mPtDuplicated[NLAYERS];
+  std::unique_ptr<TH1D> mEtaDuplicated[NLAYERS];
+  std::unique_ptr<TH1D> mPhiDuplicated[NLAYERS];
+  std::unique_ptr<TH1D> mPhiOriginalIfDuplicated[NLAYERS];
 
   std::unique_ptr<TH2D> mZvsPhiDUplicated[NLAYERS];
 
@@ -151,13 +141,6 @@ class EfficiencyStudy : public Task
   std::unique_ptr<TH2D> m2DClusterOriginalPositions;
   std::unique_ptr<TH2D> m2DClusterDuplicatedPositions;
 
-  std::unique_ptr<TH1D> mXoriginal;
-  std::unique_ptr<TH1D> mYoriginal;
-  std::unique_ptr<TH1D> mZoriginal;
-  std::unique_ptr<TH1D> mXduplicated;
-  std::unique_ptr<TH1D> mYduplicated;
-  std::unique_ptr<TH1D> mZduplicated;
-
   // Efficiency histos
   std::unique_ptr<TH1D> mEfficiencyGoodMatch;
   std::unique_ptr<TH1D> mEfficiencyFakeMatch;
@@ -165,29 +148,37 @@ class EfficiencyStudy : public Task
   std::unique_ptr<TH1D> mEfficiencyGoodMatch_layer[NLAYERS];
   std::unique_ptr<TH1D> mEfficiencyFakeMatch_layer[NLAYERS];
   std::unique_ptr<TH1D> mEfficiencyTotal_layer[NLAYERS];
-  TH2D* mEfficiencyGoodMatchPt_layer[NLAYERS];
-  TH2D* mEfficiencyFakeMatchPt_layer[NLAYERS];
-  TH2D* mEfficiencyGoodMatchEta_layer[NLAYERS];
-  TH2D* mEfficiencyFakeMatchEta_layer[NLAYERS];
-  TH2D* mEfficiencyGoodMatchPhi_layer[NLAYERS];
-  TH2D* mEfficiencyGoodMatchPhiTrack_layer[NLAYERS];
-  TH2D* mEfficiencyGoodMatchPhiOriginal_layer[NLAYERS];
-  TH2D* mEfficiencyFakeMatchPhi_layer[NLAYERS];
-  TH2D* mEfficiencyFakeMatchPhiTrack_layer[NLAYERS];
+  std::unique_ptr<TH2D> mEfficiencyGoodMatchPt_layer[NLAYERS];
+  std::unique_ptr<TH2D> mEfficiencyFakeMatchPt_layer[NLAYERS];
+  std::unique_ptr<TH2D> mEfficiencyGoodMatchEta_layer[NLAYERS];
+  std::unique_ptr<TH2D> mEfficiencyFakeMatchEta_layer[NLAYERS];
+  std::unique_ptr<TH2D> mEfficiencyGoodMatchPhi_layer[NLAYERS];
+  std::unique_ptr<TH2D> mEfficiencyGoodMatchPhiOriginal_layer[NLAYERS];
+  std::unique_ptr<TH2D> mEfficiencyFakeMatchPhi_layer[NLAYERS];
+
+  // std::unique_ptr<TH2D> mEfficiencyColEta[NLAYERS];
+  std::unique_ptr<TH2D> mDenColEta[NLAYERS];
+  std::unique_ptr<TH2D> mNumColEta[NLAYERS];
+  std::unique_ptr<TH2D> mDenRowPhi[NLAYERS];
+  std::unique_ptr<TH2D> mNumRowPhi[NLAYERS];
+  std::unique_ptr<TH2D> mDenRowCol[NLAYERS];
+  std::unique_ptr<TH2D> mNumRowCol[NLAYERS];
 
   // phi, eta, pt of the duplicated cluster per layer
-  TH2D* mPt_EtaDupl[NLAYERS];
+  std::unique_ptr<TH2D> mPt_EtaDupl[NLAYERS];
 
   // duplicated per layer and per cut
   std::unique_ptr<TH1D> mDuplicatedEtaAllPt[NLAYERS];
   std::unique_ptr<TH1D> mDuplicatedEta[NLAYERS][3];
   std::unique_ptr<TH1D> mDuplicatedPhiAllPt[NLAYERS];
   std::unique_ptr<TH1D> mDuplicatedPhi[NLAYERS][3];
-  TH1D* mDuplicatedPt[NLAYERS];
-  TH1D* mDuplicatedRow[NLAYERS];
-  TH2D* mDuplicatedPtEta[NLAYERS];
-  TH2D* mDuplicatedPtPhi[NLAYERS];
-  TH2D* mDuplicatedEtaPhi[NLAYERS];
+  std::unique_ptr<TH1D> mDuplicatedPt[NLAYERS];
+  std::unique_ptr<TH1D> mDuplicatedRow[NLAYERS];
+  std::unique_ptr<TH1D> mDuplicatedCol[NLAYERS];
+  std::unique_ptr<TH1D> mDuplicatedZ[NLAYERS];
+  std::unique_ptr<TH2D> mDuplicatedPtEta[NLAYERS];
+  std::unique_ptr<TH2D> mDuplicatedPtPhi[NLAYERS];
+  std::unique_ptr<TH2D> mDuplicatedEtaPhi[NLAYERS];
 
   // matches per layer and per cut
   std::unique_ptr<TH1D> mNGoodMatchesEtaAllPt[NLAYERS];
@@ -200,26 +191,36 @@ class EfficiencyStudy : public Task
   std::unique_ptr<TH1D> mNFakeMatchesPhiAllPt[NLAYERS];
   std::unique_ptr<TH1D> mNFakeMatchesPhi[NLAYERS][3];
 
-  TH1D* mNGoodMatchesPt[NLAYERS];
-  TH1D* mNFakeMatchesPt[NLAYERS];
+  std::unique_ptr<TH1D> mNGoodMatchesPt[NLAYERS];
+  std::unique_ptr<TH1D> mNFakeMatchesPt[NLAYERS];
+
+  std::unique_ptr<TH1D> mNGoodMatchesRow[NLAYERS];
+  std::unique_ptr<TH1D> mNFakeMatchesRow[NLAYERS];
+
+  std::unique_ptr<TH1D> mNGoodMatchesCol[NLAYERS];
+  std::unique_ptr<TH1D> mNFakeMatchesCol[NLAYERS];
 
-  TH1D* mNGoodMatchesRow[NLAYERS];
-  TH1D* mNFakeMatchesRow[NLAYERS];
+  std::unique_ptr<TH1D> mNGoodMatchesZ[NLAYERS];
+  std::unique_ptr<TH1D> mNFakeMatchesZ[NLAYERS];
 
-  TH2D* mNGoodMatchesPtEta[NLAYERS];
-  TH2D* mNFakeMatchesPtEta[NLAYERS];
+  std::unique_ptr<TH2D> mNGoodMatchesPtEta[NLAYERS];
+  std::unique_ptr<TH2D> mNFakeMatchesPtEta[NLAYERS];
 
-  TH2D* mNGoodMatchesPtPhi[NLAYERS];
-  TH2D* mNFakeMatchesPtPhi[NLAYERS];
+  std::unique_ptr<TH2D> mNGoodMatchesPtPhi[NLAYERS];
+  std::unique_ptr<TH2D> mNFakeMatchesPtPhi[NLAYERS];
 
-  TH2D* mNGoodMatchesEtaPhi[NLAYERS];
-  TH2D* mNFakeMatchesEtaPhi[NLAYERS];
+  std::unique_ptr<TH2D> mNGoodMatchesEtaPhi[NLAYERS];
+  std::unique_ptr<TH2D> mNFakeMatchesEtaPhi[NLAYERS];
 
   // calculating the efficiency with TEfficiency class
   std::unique_ptr<TEfficiency> mEffPtGood[NLAYERS];
   std::unique_ptr<TEfficiency> mEffPtFake[NLAYERS];
   std::unique_ptr<TEfficiency> mEffRowGood[NLAYERS];
   std::unique_ptr<TEfficiency> mEffRowFake[NLAYERS];
+  std::unique_ptr<TEfficiency> mEffColGood[NLAYERS];
+  std::unique_ptr<TEfficiency> mEffColFake[NLAYERS];
+  std::unique_ptr<TEfficiency> mEffZGood[NLAYERS];
+  std::unique_ptr<TEfficiency> mEffZFake[NLAYERS];
   std::unique_ptr<TEfficiency> mEffPtEtaGood[NLAYERS];
   std::unique_ptr<TEfficiency> mEffPtEtaFake[NLAYERS];
   std::unique_ptr<TEfficiency> mEffPtPhiGood[NLAYERS];
@@ -237,17 +238,15 @@ class EfficiencyStudy : public Task
   std::unique_ptr<TEfficiency> mEffPhiFakeAllPt[NLAYERS];
   std::unique_ptr<TEfficiency> mEffPhiFake[NLAYERS][3];
 
-  TH2D* mnGoodMatchesPt_layer[NLAYERS];
-  TH2D* mnFakeMatchesPt_layer[NLAYERS];
+  std::unique_ptr<TH2D> mnGoodMatchesPt_layer[NLAYERS];
+  std::unique_ptr<TH2D> mnFakeMatchesPt_layer[NLAYERS];
 
-  TH2D* mnGoodMatchesEta_layer[NLAYERS];
-  TH2D* mnFakeMatchesEta_layer[NLAYERS];
+  std::unique_ptr<TH2D> mnGoodMatchesEta_layer[NLAYERS];
+  std::unique_ptr<TH2D> mnFakeMatchesEta_layer[NLAYERS];
 
-  TH2D* mnGoodMatchesPhi_layer[NLAYERS];
-  TH2D* mnGoodMatchesPhiTrack_layer[NLAYERS];
-  TH2D* mnGoodMatchesPhiOriginal_layer[NLAYERS];
-  TH2D* mnFakeMatchesPhi_layer[NLAYERS];
-  TH2D* mnFakeMatchesPhiTrack_layer[NLAYERS];
+  std::unique_ptr<TH2D> mnGoodMatchesPhi_layer[NLAYERS];
+  std::unique_ptr<TH2D> mnGoodMatchesPhiOriginal_layer[NLAYERS];
+  std::unique_ptr<TH2D> mnFakeMatchesPhi_layer[NLAYERS];
 
   std::unique_ptr<TH1D> DCAxyData[NLAYERS];
   std::unique_ptr<TH1D> DCAzData[NLAYERS];
@@ -255,55 +254,77 @@ class EfficiencyStudy : public Task
   std::unique_ptr<TH1D> DCAxyRejected[NLAYERS];
   std::unique_ptr<TH1D> DCAzRejected[NLAYERS];
 
-  std::unique_ptr<TH1D> DistanceClustersX[NLAYERS];
-  std::unique_ptr<TH1D> DistanceClustersY[NLAYERS];
-  std::unique_ptr<TH1D> DistanceClustersZ[NLAYERS];
-  std::unique_ptr<TH1D> DistanceClustersXAftercuts[NLAYERS];
-  std::unique_ptr<TH1D> DistanceClustersYAftercuts[NLAYERS];
-  std::unique_ptr<TH1D> DistanceClustersZAftercuts[NLAYERS];
-
-  TH1D* denPt[NLAYERS];
-  TH1D* numPt[NLAYERS];
-  TH1D* numPtGood[NLAYERS];
-  TH1D* numPtFake[NLAYERS];
-
-  TH1D* denPhi[NLAYERS];
-  TH1D* numPhi[NLAYERS];
-  TH1D* numPhiGood[NLAYERS];
-  TH1D* numPhiFake[NLAYERS];
-
-  TH1D* denEta[NLAYERS];
-  TH1D* numEta[NLAYERS];
-  TH1D* numEtaGood[NLAYERS];
-  TH1D* numEtaFake[NLAYERS];
+  std::unique_ptr<TH1D> denPt[NLAYERS];
+  std::unique_ptr<TH1D> numPt[NLAYERS];
+  std::unique_ptr<TH1D> numPtGood[NLAYERS];
+  std::unique_ptr<TH1D> numPtFake[NLAYERS];
+
+  std::unique_ptr<TH1D> denPhi[NLAYERS];
+  std::unique_ptr<TH1D> numPhi[NLAYERS];
+  std::unique_ptr<TH1D> numPhiGood[NLAYERS];
+  std::unique_ptr<TH1D> numPhiFake[NLAYERS];
+
+  std::unique_ptr<TH1D> denEta[NLAYERS];
+  std::unique_ptr<TH1D> numEta[NLAYERS];
+  std::unique_ptr<TH1D> numEtaGood[NLAYERS];
+  std::unique_ptr<TH1D> numEtaFake[NLAYERS];
+
+  std::unique_ptr<TH1D> denRow[NLAYERS];
+  std::unique_ptr<TH1D> numRow[NLAYERS];
+  std::unique_ptr<TH1D> numRowGood[NLAYERS];
+  std::unique_ptr<TH1D> numRowFake[NLAYERS];
+
+  std::unique_ptr<TH1D> denCol[NLAYERS];
+  std::unique_ptr<TH1D> numCol[NLAYERS];
+  std::unique_ptr<TH1D> numColGood[NLAYERS];
+  std::unique_ptr<TH1D> numColFake[NLAYERS];
+  std::unique_ptr<TH1D> denZ[NLAYERS];
+  std::unique_ptr<TH1D> numZ[NLAYERS];
+  std::unique_ptr<TH1D> numZGood[NLAYERS];
+  std::unique_ptr<TH1D> numZFake[NLAYERS];
+
+  std::unique_ptr<TH1D> numLayers;
+  std::unique_ptr<TH1D> denLayers;
+  std::unique_ptr<TH1D> numGoodLayers;
+  std::unique_ptr<TH1D> numFakeLayers;
 
   int nDuplicatedClusters[NLAYERS] = {0};
   int nTracksSelected[NLAYERS] = {0}; // denominator fot the efficiency calculation
 
-  TH2D* diffPhivsPt[NLAYERS];
-  TH1D* diffTheta[NLAYERS];
-
-  TH1D* thetaOriginal[NLAYERS];
-  TH1D* thetaOriginalCalc[NLAYERS];
-  TH1D* thetaDuplicated[NLAYERS];
-  TH1D* thetaOriginalCalcWhenDuplicated[NLAYERS];
-  TH1D* thetaOriginalWhenDuplicated[NLAYERS];
-
   std::unique_ptr<TH1D> IPOriginalxy[NLAYERS];
   std::unique_ptr<TH1D> IPOriginalz[NLAYERS];
-  std::unique_ptr<TH1D> IPOriginalifDuplicatedxy[NLAYERS];
-  std::unique_ptr<TH1D> IPOriginalifDuplicatedz[NLAYERS];
 
   std::unique_ptr<TH1D> chipRowDuplicated[NLAYERS];
   std::unique_ptr<TH1D> chipRowOriginalIfDuplicated[NLAYERS];
 
-  std::unique_ptr<TH1D> chi2track;
   std::unique_ptr<TH1D> chi2trackAccepted;
+
+  /// checking where the duplicated not found are (histograms filled with the orifinal cluster variables)
+  std::unique_ptr<TH1D> phiFound[NLAYERS];
+  std::unique_ptr<TH1D> rowFound[NLAYERS];
+  std::unique_ptr<TH1D> phiNotFound[NLAYERS];
+  std::unique_ptr<TH1D> rowNotFound[NLAYERS];
+  std::unique_ptr<TH1D> zFound[NLAYERS];
+  std::unique_ptr<TH1D> zNotFound[NLAYERS];
+  std::unique_ptr<TH2D> colFoundOriginalVsDuplicated[NLAYERS];
+  std::unique_ptr<TH1D> colFoundOriginal[NLAYERS];
+  std::unique_ptr<TH1D> colNotFound[NLAYERS];
+  std::unique_ptr<TH1D> radiusFound[NLAYERS];
+  std::unique_ptr<TH1D> radiusNotFound[NLAYERS];
+  std::unique_ptr<TH2D> m2DClusterFoundPositions;
+  std::unique_ptr<TH2D> m2DClusterNotFoundPositions;
+  std::unique_ptr<TH1D> mChipNotFound;
+  std::unique_ptr<TH1D> mChipFound;
+  std::unique_ptr<TH2D> l0_00;
+  std::unique_ptr<TH2D> l1_15;
+  std::unique_ptr<TH2D> l2_19;
+  std::unique_ptr<TH2D> chipOrigVsOverlap;
+  std::unique_ptr<TH2D> chipmap;
 };
 
 void EfficiencyStudy::init(InitContext& ic)
 {
-  LOGP(info, "--------------- init");
+  LOGP(info, "init");
 
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
 
@@ -320,15 +341,8 @@ void EfficiencyStudy::init(InitContext& ic)
 
   mOutFile = std::make_unique<TFile>(mOutFileName.c_str(), "recreate");
 
-  mXoriginal = std::make_unique<TH1D>("xoriginal", "x original  ;x (cm); ", 200, 0, 0);
-  mYoriginal = std::make_unique<TH1D>("yoriginal", "y original  ;y (cm); ", 200, 0, 0);
-  mZoriginal = std::make_unique<TH1D>("zoriginal", "z original  ;z (cm); ", 300, 0, 0);
-  mXduplicated = std::make_unique<TH1D>("xduplicated", "x duplicated  ;x (cm); ", 200, -10, 10);
-  mYduplicated = std::make_unique<TH1D>("yduplicated", "y duplicated  ;y (cm); ", 200, -10, 10);
-  mZduplicated = std::make_unique<TH1D>("zduplicated", "z duplicated  ;z (cm); ", 300, -30, 30);
-
-  mDCAxyDuplicated = std::make_unique<TH1D>("dcaXYDuplicated", "Distance between track and duplicated cluster  ;DCA xy (cm); ", 400, -0.2, 0.2);
-  mDCAzDuplicated = std::make_unique<TH1D>("dcaZDuplicated", "Distance between track and duplicated cluster  ;DCA z (cm); ", 400, -0.2, 0.2);
+  mDCAxyDuplicated = std::make_unique<TH1D>("dcaXYDuplicated", "Distance between track and duplicated cluster  ;DCA xy (cm); ", 200, -0.01, 0.01);
+  mDCAzDuplicated = std::make_unique<TH1D>("dcaZDuplicated", "Distance between track and duplicated cluster  ;DCA z (cm); ", 200, -0.01, 0.01);
 
   m3DClusterPositions = std::make_unique<TH3D>("3DClusterPositions", ";x (cm);y (cm);z (cm)", 200, -10, 10, 200, -10, 10, 400, -20, 20);
   m3DDuplicatedClusterPositions = std::make_unique<TH3D>("3DDuplicatedClusterPositions", ";x (cm);y (cm);z (cm)", 200, -10, 10, 200, -10, 10, 500, -30, 30);
@@ -339,152 +353,192 @@ void EfficiencyStudy::init(InitContext& ic)
   mEfficiencyFakeMatch = std::make_unique<TH1D>("mEfficiencyFakeMatch", ";#sigma(DCA) cut;Efficiency;", 20, 0.5, 20.5);
   mEfficiencyTotal = std::make_unique<TH1D>("mEfficiencyTotal", ";#sigma(DCA) cut;Efficiency;", 20, 0.5, 20.5);
 
-  chi2track = std::make_unique<TH1D>("chi2track", "; $chi^{2}", 500, 0, 100);
-  chi2trackAccepted = std::make_unique<TH1D>("chi2trackAccepted", "; $chi^{2}", 500, 0, 100);
+  chi2trackAccepted = std::make_unique<TH1D>("chi2trackAccepted", "; $#chi^{2}", 500, 0, 100);
+
+  m2DClusterFoundPositions = std::make_unique<TH2D>("m2DClusterFoundPositions", ";x (cm);y (cm)", 250, -5, 5, 250, -5, 5);
+  m2DClusterNotFoundPositions = std::make_unique<TH2D>("m2DClusterNotFoundPositions", ";x (cm);y (cm)", 250, -5, 5, 250, -5, 5);
+  mChipNotFound = std::make_unique<TH1D>("mChipNotFound", ";chipID", 432, 0, 432);
+  mChipFound = std::make_unique<TH1D>("mChipFound", ";chipID", 432, 0, 432);
+  l0_00 = std::make_unique<TH2D>("l0_00", ";col; row", 2304, -0.5, 9215.5, 128, -0.5, 511.5);
+  l1_15 = std::make_unique<TH2D>("l1_15", ";col; row", 2304, -0.5, 9215.5, 512, -0.5, 511.5);
+  l2_19 = std::make_unique<TH2D>("l2_19", ";col; row", 2304, -0.5, 9215.5, 512, -0.5, 511.5);
+  chipOrigVsOverlap = std::make_unique<TH2D>("chipOrigVsOverlap", ";chipID Overlap;chipID Original", 9, 0, 9, 9, 0, 9);
+  chipmap = std::make_unique<TH2D>("chipmap", ";Column;Row", 1024, 0, 1023, 512, -0.5, 511.5);
+
+  numLayers = std::make_unique<TH1D>("numLayers", "numLayers; ; Efficiency", 3, -0.5, 2.5);
+  numGoodLayers = std::make_unique<TH1D>("numGoodLayers", "numGoodLayers; ; Efficiency", 3, -0.5, 2.5);
+  numFakeLayers = std::make_unique<TH1D>("numFakeLayers", "numFakeLayers; ; Efficiency", 3, -0.5, 2.5);
+  denLayers = std::make_unique<TH1D>("denLayers", "denLayers; ; Efficiency", 3, -0.5, 2.5);
 
   for (int i = 0; i < NLAYERS; i++) {
 
     chipRowDuplicated[i] = std::make_unique<TH1D>(Form("chipPosDuplicated_L%d", i), Form("L%d; row", i), 512, -0.5, 511.5);
     chipRowOriginalIfDuplicated[i] = std::make_unique<TH1D>(Form("chipPosOriginalIfDuplicated%d", i), Form("L%d; row", i), 512, -0.5, 511.5);
 
-    DCAxyData[i] = std::make_unique<TH1D>(Form("dcaXYData_L%d", i), "Distance between track and original cluster ;DCA xy (cm); ", 4000, -2, 2);
-    DCAzData[i] = std::make_unique<TH1D>(Form("dcaZData_L%d", i), "Distance between track and original cluster ;DCA z (cm); ", 4000, -2, 2);
+    DCAxyData[i] = std::make_unique<TH1D>(Form("dcaXYData_L%d", i), "Distance between track and original cluster ;DCA xy (cm); ", 4000, -0.2, 0.2);
+    DCAzData[i] = std::make_unique<TH1D>(Form("dcaZData_L%d", i), "Distance between track and original cluster ;DCA z (cm); ", 4000, -0.2, 0.2);
     DCAxyRejected[i] = std::make_unique<TH1D>(Form("DCAxyRejected%d", i), "Distance between track and original cluster (rejected) ;DCA xy (cm); ", 30000, -30, 30);
     DCAzRejected[i] = std::make_unique<TH1D>(Form("DCAzRejected%d", i), "Distance between track and original cluster (rejected) ;DCA z (cm); ", 30000, -30, 30);
 
-    DistanceClustersX[i] = std::make_unique<TH1D>(Form("distanceClustersX_L%d", i), ";Distance x (cm); ", 100, 0, 1);
-    DistanceClustersY[i] = std::make_unique<TH1D>(Form("distanceClustersY_L%d", i), ";Distance y (cm); ", 100, 0, 1);
-    DistanceClustersZ[i] = std::make_unique<TH1D>(Form("distanceClustersZ_L%d", i), ";Distance z (cm); ", 100, 0, 1);
-    DistanceClustersXAftercuts[i] = std::make_unique<TH1D>(Form("distanceClustersXAftercuts_L%d", i), ";Distance x (cm); ", 100, 0, 1);
-    DistanceClustersYAftercuts[i] = std::make_unique<TH1D>(Form("distanceClustersYAftercuts_L%d", i), ";Distance y (cm); ", 100, 0, 1);
-    DistanceClustersZAftercuts[i] = std::make_unique<TH1D>(Form("distanceClustersZAftercuts_L%d", i), ";Distance z (cm); ", 100, 0, 1);
+    mDCAxyOriginal[i] = std::make_unique<TH1D>(Form("dcaXYOriginal_L%d", i), "Distance between track and original cluster ;DCA xy (cm); ", 200, -0.01, 0.01);
+    mDCAzOriginal[i] = std::make_unique<TH1D>(Form("dcaZOriginal_L%d", i), "Distance between track and original cluster ;DCA z (cm); ", 200, -0.01, 0.01);
 
-    mDistanceClustersX[i] = std::make_unique<TH1D>(Form("distanceClustersX_L%d", i), ";Distance x (cm); ", 100, 0, 1);
-    mDistanceClustersY[i] = std::make_unique<TH1D>(Form("distanceClustersY_L%d", i), ";Distance y (cm); ", 100, 0, 1);
-    mDistanceClustersZ[i] = std::make_unique<TH1D>(Form("distanceClustersZ_L%d", i), ";Distance z (cm); ", 100, 0, 1);
-    mDistanceClusters[i] = std::make_unique<TH1D>(Form("distanceClusters_L%d", i), ";Distance (cm); ", 100, 0, 1);
-
-    mDCAxyOriginal[i] = std::make_unique<TH1D>(Form("dcaXYOriginal_L%d", i), "Distance between track and original cluster ;DCA xy (cm); ", 400, -0.2, 0.2);
-    mDCAzOriginal[i] = std::make_unique<TH1D>(Form("dcaZOriginal_L%d", i), "Distance between track and original cluster ;DCA z (cm); ", 400, -0.2, 0.2);
-
-    mPhiOriginal[i] = std::make_unique<TH1D>(Form("phiOriginal_L%d", i), ";phi (deg); ", 1440, -180, 180);
-    mPhiTrackOriginal[i] = std::make_unique<TH1D>(Form("phiTrackOriginal_L%d", i), ";phi Track (deg); ", 1440, 0, 360);
-    mEtaOriginal[i] = std::make_unique<TH1D>(Form("etaOriginal_L%d", i), ";eta (deg); ", 100, -2, 2);
+    mPhiOriginal[i] = std::make_unique<TH1D>(Form("phiOriginal_L%d", i), ";phi (rad); ", 90, -3.2, 3.2);
+    mEtaOriginal[i] = std::make_unique<TH1D>(Form("etaOriginal_L%d", i), ";eta (rad); ", 100, -2, 2);
     mPtOriginal[i] = std::make_unique<TH1D>(Form("ptOriginal_L%d", i), ";pt (GeV/c); ", 100, 0, 10);
 
-    mZvsPhiDUplicated[i] = std::make_unique<TH2D>(Form("zvsphiDuplicated_L%d", i), ";z (cm);phi (deg)", 400, -20, 20, 1440, -180, 180);
+    mZvsPhiDUplicated[i] = std::make_unique<TH2D>(Form("zvsphiDuplicated_L%d", i), ";z (cm);phi (rad)", 400, -20, 20, 90, -3.2, 3.2);
 
-    mPtDuplicated[i] = new TH1D(Form("ptDuplicated_L%d", i), ";pt (GeV/c); ", nbPt, 0, 7.5); // xbins);
-    mEtaDuplicated[i] = new TH1D(Form("etaDuplicated_L%d", i), ";eta; ", 40, -2, 2);
-    mPhiDuplicated[i] = new TH1D(Form("phiDuplicated_L%d", i), ";phi (deg); ", 1440, -180, 180);
-    mPhiTrackDuplicated[i] = new TH1D(Form("phiTrackDuplicated_L%d", i), ";phi Track (deg); ", 1440, 0, 360);
-    mPhiOriginalIfDuplicated[i] = new TH1D(Form("phiOriginalIfDuplicated_L%d", i), ";phi (deg); ", 1440, -180, 180);
-    mPhiTrackDuplicatedvsphiDuplicated[i] = new TH2D(Form("phiTrackDuplicatedvsphiDuplicated_L%d", i), ";phi track (deg);phi oridinal if duplicated (deg); ", 1440, 0, 360, 1440, -180, 180);
-    mPhiTrackoriginalvsphioriginal[i] = new TH2D(Form("phiTrackoriginalvsphioriginal_L%d", i), ";phi track (deg);phi original (deg); ", 1440, 0, 360, 1440, -180, 180);
-    mDCAxyDuplicated_layer[i] = std::make_unique<TH1D>(Form("dcaXYDuplicated_layer_L%d", i), "Distance between track and duplicated cluster  ;DCA xy (cm); ", 400, -0.2, 0.2);
-    mDCAzDuplicated_layer[i] = std::make_unique<TH1D>(Form("dcaZDuplicated_layer_L%d", i), "Distance between track and duplicated cluster  ;DCA z (cm); ", 400, -0.2, 0.2);
+    mPtDuplicated[i] = std::make_unique<TH1D>(Form("ptDuplicated_L%d", i), ";pt (GeV/c); ", nbPt, 0, 7.5); // xbins);
+    mEtaDuplicated[i] = std::make_unique<TH1D>(Form("etaDuplicated_L%d", i), ";eta; ", 40, -2, 2);
+    mPhiDuplicated[i] = std::make_unique<TH1D>(Form("phiDuplicated_L%d", i), ";phi (rad); ", 90, -3.2, 3.2);
+    mPhiOriginalIfDuplicated[i] = std::make_unique<TH1D>(Form("phiOriginalIfDuplicated_L%d", i), ";phi (rad); ", 90, -3.2, 3.2);
+    mDCAxyDuplicated_layer[i] = std::make_unique<TH1D>(Form("dcaXYDuplicated_layer_L%d", i), "Distance between track and duplicated cluster  ;DCA xy (cm); ", 100, -0.01, 0.01);
+    mDCAzDuplicated_layer[i] = std::make_unique<TH1D>(Form("dcaZDuplicated_layer_L%d", i), "Distance between track and duplicated cluster  ;DCA z (cm); ", 100, -0.01, 0.01);
 
     mEfficiencyGoodMatch_layer[i] = std::make_unique<TH1D>(Form("mEfficiencyGoodMatch_layer_L%d", i), ";#sigma(DCA) cut;Efficiency;", 20, 0.5, 20.5);
     mEfficiencyFakeMatch_layer[i] = std::make_unique<TH1D>(Form("mEfficiencyFakeMatch_layer_L%d", i), ";#sigma(DCA) cut;Efficiency;", 20, 0.5, 20.5);
     mEfficiencyTotal_layer[i] = std::make_unique<TH1D>(Form("mEfficiencyTotal_layer_L%d", i), ";#sigma(DCA) cut;Efficiency;", 20, 0.5, 20.5);
 
-    mEfficiencyGoodMatchPt_layer[i] = new TH2D(Form("mEfficiencyGoodMatchPt_layer_L%d", i), ";#it{p}_{T} (GeV/c);#sigma(DCA) cut;Efficiency;", nbPt, 0, 7.5, /* xbins*/ 20, 0.5, 20.5);
-    mEfficiencyFakeMatchPt_layer[i] = new TH2D(Form("mEfficiencyFakeMatchPt_layer_L%d", i), ";#it{p}_{T} (GeV/c);#sigma(DCA) cut;Efficiency;", nbPt, 0, 7.5, /* xbins*/ 20, 0.5, 20.5);
+    mEfficiencyGoodMatchPt_layer[i] = std::make_unique<TH2D>(Form("mEfficiencyGoodMatchPt_layer_L%d", i), ";#it{p}_{T} (GeV/c);#sigma(DCA) cut;Efficiency;", nbPt, 0, 7.5, /* xbins*/ 20, 0.5, 20.5);
+    mEfficiencyFakeMatchPt_layer[i] = std::make_unique<TH2D>(Form("mEfficiencyFakeMatchPt_layer_L%d", i), ";#it{p}_{T} (GeV/c);#sigma(DCA) cut;Efficiency;", nbPt, 0, 7.5, /* xbins*/ 20, 0.5, 20.5);
 
-    mEfficiencyGoodMatchEta_layer[i] = new TH2D(Form("mEfficiencyGoodMatchEta_layer_L%d", i), ";#eta;#sigma(DCA) cut;Efficiency;", 40, -2, 2, 20, 0.5, 20.5);
-    mEfficiencyFakeMatchEta_layer[i] = new TH2D(Form("mEfficiencyFakeMatchEta_layer_L%d", i), ";#eta;#sigma(DCA) cut;Efficiency;", 40, -2, 2, 20, 0.5, 20.5);
+    mEfficiencyGoodMatchEta_layer[i] = std::make_unique<TH2D>(Form("mEfficiencyGoodMatchEta_layer_L%d", i), ";#eta;#sigma(DCA) cut;Efficiency;", 40, -2, 2, 20, 0.5, 20.5);
+    mEfficiencyFakeMatchEta_layer[i] = std::make_unique<TH2D>(Form("mEfficiencyFakeMatchEta_layer_L%d", i), ";#eta;#sigma(DCA) cut;Efficiency;", 40, -2, 2, 20, 0.5, 20.5);
 
-    mEfficiencyGoodMatchPhi_layer[i] = new TH2D(Form("mEfficiencyGoodMatchPhi_layer_L%d", i), ";#phi;#sigma(DCA) cut;Efficiency;", 1440, -180, 180, 20, 0.5, 20.5);
-    mEfficiencyGoodMatchPhiTrack_layer[i] = new TH2D(Form("mEfficiencyGoodMatchPhiTrack_layer_L%d", i), ";#phi track;#sigma(DCA) cut;Efficiency;", 1440, 0, 360, 20, 0.5, 20.5);
-    mEfficiencyGoodMatchPhiOriginal_layer[i] = new TH2D(Form("mEfficiencyGoodMatchPhiOriginal_layer_L%d", i), ";#phi Original;#sigma(DCA) cut;Efficiency;", 1440, -180, 180, 20, 0.5, 20.5);
-    mEfficiencyFakeMatchPhi_layer[i] = new TH2D(Form("mEfficiencyFakeMatchPhi_layer_L%d", i), ";#phi;#sigma(DCA) cut;Efficiency;", 1440, -180, 180, 20, 0.5, 20.5);
-    mEfficiencyFakeMatchPhiTrack_layer[i] = new TH2D(Form("mEfficiencyFakeMatchPhiTrack_layer_L%d", i), ";#phi Track;#sigma(DCA) cut;Efficiency;", 1440, 0, 360, 20, 0.5, 20.5);
+    mEfficiencyGoodMatchPhi_layer[i] = std::make_unique<TH2D>(Form("mEfficiencyGoodMatchPhi_layer_L%d", i), ";#phi;#sigma(DCA) cut;Efficiency;", 90, -3.2, 3.2, 20, 0.5, 20.5);
+    mEfficiencyGoodMatchPhiOriginal_layer[i] = std::make_unique<TH2D>(Form("mEfficiencyGoodMatchPhiOriginal_layer_L%d", i), ";#phi Original;#sigma(DCA) cut;Efficiency;", 90, -3.2, 3.2, 20, 0.5, 20.5);
+    mEfficiencyFakeMatchPhi_layer[i] = std::make_unique<TH2D>(Form("mEfficiencyFakeMatchPhi_layer_L%d", i), ";#phi;#sigma(DCA) cut;Efficiency;", 90, -3.2, 3.2, 20, 0.5, 20.5);
 
-    mPt_EtaDupl[i] = new TH2D(Form("mPt_EtaDupl_L%d", i), ";#it{p}_{T} (GeV/c);#eta; ", 100, 0, 10, 100, -2, 2);
+    mPt_EtaDupl[i] = std::make_unique<TH2D>(Form("mPt_EtaDupl_L%d", i), ";#it{p}_{T} (GeV/c);#eta; ", 100, 0, 10, 100, -2, 2);
 
-    mDuplicatedPt[i] = new TH1D(Form("mDuplicatedPt_log_L%d", i), Form("; #it{p}_{T} (GeV/c); Number of duplciated clusters L%d", i), nbPt, 0, 7.5 /* xbins*/);
+    mDuplicatedPt[i] = std::make_unique<TH1D>(Form("mDuplicatedPt_log_L%d", i), Form("; #it{p}_{T} (GeV/c); Number of duplciated clusters L%d", i), nbPt, 0, 7.5 /* xbins*/);
     mDuplicatedPt[i]->Sumw2();
-    mNGoodMatchesPt[i] = new TH1D(Form("mNGoodMatchesPt_L%d", i), Form("; #it{p}_{T} (GeV/c); Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/);
+    mNGoodMatchesPt[i] = std::make_unique<TH1D>(Form("mNGoodMatchesPt_L%d", i), Form("; #it{p}_{T} (GeV/c); Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/);
     mNGoodMatchesPt[i]->Sumw2();
-    mNFakeMatchesPt[i] = new TH1D(Form("mNFakeMatchesPt_L%d", i), Form("; #it{p}_{T} (GeV/c); Number of fake matches L%d", i), nbPt, 0, 7.5 /* xbins*/);
+    mNFakeMatchesPt[i] = std::make_unique<TH1D>(Form("mNFakeMatchesPt_L%d", i), Form("; #it{p}_{T} (GeV/c); Number of fake matches L%d", i), nbPt, 0, 7.5 /* xbins*/);
     mNFakeMatchesPt[i]->Sumw2();
 
-    mDuplicatedRow[i] = new TH1D(Form("mDuplicatedRow_L%d", i), Form("; Row; Number of duplciated clusters L%d", i), 512, -0.5, 511.5);
+    mDuplicatedRow[i] = std::make_unique<TH1D>(Form("mDuplicatedRow_L%d", i), Form("; Row; Number of duplciated clusters L%d", i), 128, -0.5, 511.5);
     mDuplicatedRow[i]->Sumw2();
-    mNGoodMatchesRow[i] = new TH1D(Form("mNGoodMatchesRow_L%d", i), Form("; Row; Number of good matches L%d", i), 512, -0.5, 511.5);
+    mNGoodMatchesRow[i] = std::make_unique<TH1D>(Form("mNGoodMatchesRow_L%d", i), Form("; Row; Number of good matches L%d", i), 128, -0.5, 511.5);
     mNGoodMatchesRow[i]->Sumw2();
-    mNFakeMatchesRow[i] = new TH1D(Form("mNFakeMatchesRow_L%d", i), Form(";Row; Number of fake matches L%d", i), 512, -0.5, 511.5);
+    mNFakeMatchesRow[i] = std::make_unique<TH1D>(Form("mNFakeMatchesRow_L%d", i), Form(";Row; Number of fake matches L%d", i), 128, -0.5, 511.5);
     mNFakeMatchesRow[i]->Sumw2();
 
-    mDuplicatedPtEta[i] = new TH2D(Form("mDuplicatedPtEta_log_L%d", i), Form("; #it{p}_{T} (GeV/c);#eta; Number of duplciated clusters L%d", i), nbPt, 0, 7.5 /* xbins*/, 40, -2, 2);
+    mDuplicatedCol[i] = std::make_unique<TH1D>(Form("mDuplicatedCol_L%d", i), Form("; Col; Number of duplciated clusters L%d", i), 128, -0.5, 1023.5);
+    mDuplicatedCol[i]->Sumw2();
+    mNGoodMatchesCol[i] = std::make_unique<TH1D>(Form("mNGoodMatchesCol_L%d", i), Form("; Col; Number of good matches L%d", i), 128, -0.5, 1023.5);
+    mNGoodMatchesCol[i]->Sumw2();
+    mNFakeMatchesCol[i] = std::make_unique<TH1D>(Form("mNFakeMatchesCol_L%d", i), Form(";Col; Number of fake matches L%d", i), 128, -0.5, 1023.5);
+    mNFakeMatchesCol[i]->Sumw2();
+
+    mDuplicatedZ[i] = std::make_unique<TH1D>(Form("mDuplicatedZ_L%d", i), Form("; Z (cm); Number of duplciated clusters L%d", i), 100, -15, 15);
+    mDuplicatedZ[i]->Sumw2();
+    mNGoodMatchesZ[i] = std::make_unique<TH1D>(Form("mNGoodMatchesZ_L%d", i), Form("; Z (cm); Number of good matches L%d", i), 100, -15, 15);
+    mNGoodMatchesZ[i]->Sumw2();
+    mNFakeMatchesZ[i] = std::make_unique<TH1D>(Form("mNFakeMatchesZ_L%d", i), Form(";Z (cm); Number of fake matches L%d", i), 100, -15, 15);
+    mNFakeMatchesZ[i]->Sumw2();
+
+    mDuplicatedPtEta[i] = std::make_unique<TH2D>(Form("mDuplicatedPtEta_log_L%d", i), Form("; #it{p}_{T} (GeV/c);#eta; Number of duplciated clusters L%d", i), nbPt, 0, 7.5 /* xbins*/, 40, -2, 2);
     mDuplicatedPtEta[i]->Sumw2();
-    mNGoodMatchesPtEta[i] = new TH2D(Form("mNGoodMatchesPtEta_L%d", i), Form("; #it{p}_{T} (GeV/c);#eta; Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/, 40, -2, 2);
+    mNGoodMatchesPtEta[i] = std::make_unique<TH2D>(Form("mNGoodMatchesPtEta_L%d", i), Form("; #it{p}_{T} (GeV/c);#eta; Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/, 40, -2, 2);
     mNGoodMatchesPtEta[i]->Sumw2();
-    mNFakeMatchesPtEta[i] = new TH2D(Form("mNFakeMatchesPtEta_L%d", i), Form("; #it{p}_{T} (GeV/c);#eta; Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/, 40, -2, 2);
+    mNFakeMatchesPtEta[i] = std::make_unique<TH2D>(Form("mNFakeMatchesPtEta_L%d", i), Form("; #it{p}_{T} (GeV/c);#eta; Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/, 40, -2, 2);
     mNFakeMatchesPtEta[i]->Sumw2();
 
-    mDuplicatedPtPhi[i] = new TH2D(Form("mDuplicatedPtPhi_log_L%d", i), Form("; #it{p}_{T} (GeV/c);#phi (deg); Number of duplciated clusters L%d", i), nbPt, 0, 7.5 /* xbins*/, 1440, -180, 180);
+    mDuplicatedPtPhi[i] = std::make_unique<TH2D>(Form("mDuplicatedPtPhi_log_L%d", i), Form("; #it{p}_{T} (GeV/c);#phi (rad); Number of duplciated clusters L%d", i), nbPt, 0, 7.5 /* xbins*/, 90, -3.2, 3.2);
     mDuplicatedPtPhi[i]->Sumw2();
-    mNGoodMatchesPtPhi[i] = new TH2D(Form("mNGoodMatchesPtPhi_L%d", i), Form("; #it{p}_{T} (GeV/c);#phi (deg); Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/, 1440, -180, 180);
+    mNGoodMatchesPtPhi[i] = std::make_unique<TH2D>(Form("mNGoodMatchesPtPhi_L%d", i), Form("; #it{p}_{T} (GeV/c);#phi (rad); Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/, 90, -3.2, 3.2);
     mNGoodMatchesPtPhi[i]->Sumw2();
-    mNFakeMatchesPtPhi[i] = new TH2D(Form("mNFakeMatchesPtPhi_L%d", i), Form("; #it{p}_{T} (GeV/c);#phi (deg); Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/, 1440, -180, 180);
+    mNFakeMatchesPtPhi[i] = std::make_unique<TH2D>(Form("mNFakeMatchesPtPhi_L%d", i), Form("; #it{p}_{T} (GeV/c);#phi (rad); Number of good matches L%d", i), nbPt, 0, 7.5 /* xbins*/, 90, -3.2, 3.2);
     mNFakeMatchesPtPhi[i]->Sumw2();
 
-    mDuplicatedEtaPhi[i] = new TH2D(Form("mDuplicatedEtaPhi_L%d", i), Form("; #eta;#phi (deg); Number of duplciated clusters L%d", i), 40, -2, 2, 1440, -180, 180);
+    mDuplicatedEtaPhi[i] = std::make_unique<TH2D>(Form("mDuplicatedEtaPhi_L%d", i), Form("; #eta;#phi (rad); Number of duplciated clusters L%d", i), 40, -2, 2, 90, -3.2, 3.2);
     mDuplicatedEtaPhi[i]->Sumw2();
-    mNGoodMatchesEtaPhi[i] = new TH2D(Form("mNGoodMatchesEtaPhi_L%d", i), Form("; #eta;#phi (deg); Number of good matches L%d", i), 40, -2, 2, 1440, -180, 180);
+    mNGoodMatchesEtaPhi[i] = std::make_unique<TH2D>(Form("mNGoodMatchesEtaPhi_L%d", i), Form("; #eta;#phi (rad); Number of good matches L%d", i), 40, -2, 2, 90, -3.2, 3.2);
     mNGoodMatchesEtaPhi[i]->Sumw2();
-    mNFakeMatchesEtaPhi[i] = new TH2D(Form("mNFakeMatchesEtaPhi_L%d", i), Form("; #eta;#phi (deg); Number of good matches L%d", i), 40, -2, 2, 1440, -180, 180);
+    mNFakeMatchesEtaPhi[i] = std::make_unique<TH2D>(Form("mNFakeMatchesEtaPhi_L%d", i), Form("; #eta;#phi (rad); Number of good matches L%d", i), 40, -2, 2, 90, -3.2, 3.2);
     mNFakeMatchesEtaPhi[i]->Sumw2();
 
     mDuplicatedEtaAllPt[i] = std::make_unique<TH1D>(Form("mDuplicatedEtaAllPt_L%d", i), Form("; #eta; Number of duplicated clusters L%d", i), 40, -2, 2);
     mNGoodMatchesEtaAllPt[i] = std::make_unique<TH1D>(Form("mNGoodMatchesEtaAllPt_L%d", i), Form("; #eta; Number of good matches L%d", i), 40, -2, 2);
     mNFakeMatchesEtaAllPt[i] = std::make_unique<TH1D>(Form("mNFakeMatchesEtaAllPt_L%d", i), Form("; #eta; Number of fake matches L%d", i), 40, -2, 2);
 
-    mDuplicatedPhiAllPt[i] = std::make_unique<TH1D>(Form("mDuplicatedPhiAllPt_L%d", i), Form("; #phi (deg); Number of duplicated clusters L%d", i), 1440, -180, 180);
-    mNGoodMatchesPhiAllPt[i] = std::make_unique<TH1D>(Form("mNGoodMatchesPhiAllPt_L%d", i), Form("; #phi (deg); Number of good matches L%d", i), 1440, -180, 180);
-    mNFakeMatchesPhiAllPt[i] = std::make_unique<TH1D>(Form("mNFakeMatchesPhiAllPt_L%d", i), Form("; #phi (deg); Number of fake matches L%d", i), 1440, -180, 180);
-
-    mnGoodMatchesPt_layer[i] = new TH2D(Form("mnGoodMatchesPt_layer_L%d", i), ";pt; nGoodMatches", nbPt, 0, 7.5 /* xbins*/, 20, 0.5, 20.5);
-    mnFakeMatchesPt_layer[i] = new TH2D(Form("mnFakeMatchesPt_layer_L%d", i), ";pt; nFakeMatches", nbPt, 0, 7.5 /* xbins*/, 20, 0.5, 20.5);
-    mnGoodMatchesEta_layer[i] = new TH2D(Form("mnGoodMatchesEta_layer_L%d", i), ";#eta; nGoodMatches", 40, -2, 2, 20, 0.5, 20.5);
-    mnFakeMatchesEta_layer[i] = new TH2D(Form("mnFakeMatchesEta_layer_L%d", i), ";#eta; nFakeMatches", 40, -2, 2, 20, 0.5, 20.5);
-    mnGoodMatchesPhi_layer[i] = new TH2D(Form("mnGoodMatchesPhi_layer_L%d", i), ";#Phi; nGoodMatches", 1440, -180, 180, 20, 0.5, 20.5);
-    mnGoodMatchesPhiTrack_layer[i] = new TH2D(Form("mnGoodMatchesPhiTrack_layer_L%d", i), ";#Phi track; nGoodMatches", 1440, 0, 360, 20, 0.5, 20.5);
-    mnGoodMatchesPhiOriginal_layer[i] = new TH2D(Form("mnGoodMatchesPhiOriginal_layer_L%d", i), ";#Phi of the original Cluster; nGoodMatches", 1440, -180, 180, 20, 0.5, 20.5);
-    mnFakeMatchesPhi_layer[i] = new TH2D(Form("mnFakeMatchesPhi_layer_L%d", i), ";#Phi; nFakeMatches", 1440, -180, 180, 20, 0.5, 20.5);
-    mnFakeMatchesPhiTrack_layer[i] = new TH2D(Form("mnFakeMatchesPhiTrack_layer_L%d", i), ";#Phi track; nFakeMatches", 1440, 0, 360, 20, 0.5, 20.5);
-
-    denPt[i] = new TH1D(Form("denPt_L%d", i), Form("denPt_L%d", i), nbPt, 0, 7.5 /* xbins*/);
-    numPt[i] = new TH1D(Form("numPt_L%d", i), Form("numPt_L%d", i), nbPt, 0, 7.5 /* xbins*/);
-    numPtGood[i] = new TH1D(Form("numPtGood_L%d", i), Form("numPtGood_L%d", i), nbPt, 0, 7.5 /* xbins*/);
-    numPtFake[i] = new TH1D(Form("numPtFake_L%d", i), Form("numPtFake_L%d", i), nbPt, 0, 7.5 /* xbins*/);
-
-    denPhi[i] = new TH1D(Form("denPhi_L%d", i), Form("denPhi_L%d", i), 1440, -180, 180);
-    numPhi[i] = new TH1D(Form("numPhi_L%d", i), Form("numPhi_L%d", i), 1440, -180, 180);
-    numPhiGood[i] = new TH1D(Form("numPhiGood_L%d", i), Form("numPhiGood_L%d", i), 1440, -180, 180);
-    numPhiFake[i] = new TH1D(Form("numPhiFake_L%d", i), Form("numPhiFake_L%d", i), 1440, -180, 180);
-
-    denEta[i] = new TH1D(Form("denEta_L%d", i), Form("denEta_L%d", i), 200, -2, 2);
-    numEta[i] = new TH1D(Form("numEta_L%d", i), Form("numEta_L%d", i), 200, -2, 2);
-    numEtaGood[i] = new TH1D(Form("numEtaGood_L%d", i), Form("numEtaGood_L%d", i), 200, -2, 2);
-    numEtaFake[i] = new TH1D(Form("numEtaFake_L%d", i), Form("numEtaFake_L%d", i), 200, -2, 2);
-
-    diffPhivsPt[i] = new TH2D(Form("diffPhivsPt_L%d", i), Form("diffPhivsPt_L%d", i), nbPt, 0, 7.5 /* xbins*/, 50, 0, 5);
+    mDuplicatedPhiAllPt[i] = std::make_unique<TH1D>(Form("mDuplicatedPhiAllPt_L%d", i), Form("; #phi (rad); Number of duplicated clusters L%d", i), 90, -3.2, 3.2);
+    mNGoodMatchesPhiAllPt[i] = std::make_unique<TH1D>(Form("mNGoodMatchesPhiAllPt_L%d", i), Form("; #phi (rad); Number of good matches L%d", i), 90, -3.2, 3.2);
+    mNFakeMatchesPhiAllPt[i] = std::make_unique<TH1D>(Form("mNFakeMatchesPhiAllPt_L%d", i), Form("; #phi (rad); Number of fake matches L%d", i), 90, -3.2, 3.2);
+
+    mnGoodMatchesPt_layer[i] = std::make_unique<TH2D>(Form("mnGoodMatchesPt_layer_L%d", i), ";pt; nGoodMatches", nbPt, 0, 7.5 /* xbins*/, 20, 0.5, 20.5);
+    mnFakeMatchesPt_layer[i] = std::make_unique<TH2D>(Form("mnFakeMatchesPt_layer_L%d", i), ";pt; nFakeMatches", nbPt, 0, 7.5 /* xbins*/, 20, 0.5, 20.5);
+    mnGoodMatchesEta_layer[i] = std::make_unique<TH2D>(Form("mnGoodMatchesEta_layer_L%d", i), ";#eta; nGoodMatches", 40, -2, 2, 20, 0.5, 20.5);
+    mnFakeMatchesEta_layer[i] = std::make_unique<TH2D>(Form("mnFakeMatchesEta_layer_L%d", i), ";#eta; nFakeMatches", 40, -2, 2, 20, 0.5, 20.5);
+    mnGoodMatchesPhi_layer[i] = std::make_unique<TH2D>(Form("mnGoodMatchesPhi_layer_L%d", i), ";#Phi; nGoodMatches", 90, -3.2, 3.2, 20, 0.5, 20.5);
+    mnGoodMatchesPhiOriginal_layer[i] = std::make_unique<TH2D>(Form("mnGoodMatchesPhiOriginal_layer_L%d", i), ";#Phi of the original Cluster; nGoodMatches", 90, -3.2, 3.2, 20, 0.5, 20.5);
+    mnFakeMatchesPhi_layer[i] = std::make_unique<TH2D>(Form("mnFakeMatchesPhi_layer_L%d", i), ";#Phi; nFakeMatches", 90, -3.2, 3.2, 20, 0.5, 20.5);
+
+    denPt[i] = std::make_unique<TH1D>(Form("denPt_L%d", i), Form("denPt_L%d", i), nbPt, 0, 7.5 /* xbins*/);
+    numPt[i] = std::make_unique<TH1D>(Form("numPt_L%d", i), Form("numPt_L%d", i), nbPt, 0, 7.5 /* xbins*/);
+    numPtGood[i] = std::make_unique<TH1D>(Form("numPtGood_L%d", i), Form("numPtGood_L%d", i), nbPt, 0, 7.5 /* xbins*/);
+    numPtFake[i] = std::make_unique<TH1D>(Form("numPtFake_L%d", i), Form("numPtFake_L%d", i), nbPt, 0, 7.5 /* xbins*/);
+
+    denPhi[i] = std::make_unique<TH1D>(Form("denPhi_L%d", i), Form("denPhi_L%d", i), 90, -3.2, 3.2);
+    numPhi[i] = std::make_unique<TH1D>(Form("numPhi_L%d", i), Form("numPhi_L%d", i), 90, -3.2, 3.2);
+    numPhiGood[i] = std::make_unique<TH1D>(Form("numPhiGood_L%d", i), Form("numPhiGood_L%d", i), 90, -3.2, 3.2);
+    numPhiFake[i] = std::make_unique<TH1D>(Form("numPhiFake_L%d", i), Form("numPhiFake_L%d", i), 90, -3.2, 3.2);
+
+    denEta[i] = std::make_unique<TH1D>(Form("denEta_L%d", i), Form("denEta_L%d", i), 200, -2, 2);
+    numEta[i] = std::make_unique<TH1D>(Form("numEta_L%d", i), Form("numEta_L%d", i), 200, -2, 2);
+    numEtaGood[i] = std::make_unique<TH1D>(Form("numEtaGood_L%d", i), Form("numEtaGood_L%d", i), 200, -2, 2);
+    numEtaFake[i] = std::make_unique<TH1D>(Form("numEtaFake_L%d", i), Form("numEtaFake_L%d", i), 200, -2, 2);
+
+    denRow[i] = std::make_unique<TH1D>(Form("denRow_L%d", i), Form("denRow_L%d", i), 128, -0.5, 511.5);
+    numRow[i] = std::make_unique<TH1D>(Form("numRow_L%d", i), Form("numRow_L%d", i), 128, -0.5, 511.5);
+    numRowGood[i] = std::make_unique<TH1D>(Form("numRowGood_L%d", i), Form("numRowGood_L%d", i), 128, -0.5, 511.5);
+    numRowFake[i] = std::make_unique<TH1D>(Form("numRowFake_L%d", i), Form("numRowFake_L%d", i), 128, -0.5, 511.5);
+
+    denCol[i] = std::make_unique<TH1D>(Form("denCol_L%d", i), Form("denCol_L%d", i), 128, -0.5, 1023.5);
+    numCol[i] = std::make_unique<TH1D>(Form("numCol_L%d", i), Form("numCol_L%d", i), 128, -0.5, 1023.5);
+    numColGood[i] = std::make_unique<TH1D>(Form("numColGood_L%d", i), Form("numColGood_L%d", i), 128, -0.5, 1023.5);
+    numColFake[i] = std::make_unique<TH1D>(Form("numColFake_L%d", i), Form("numColFake_L%d", i), 128, -0.5, 1023.5);
+
+    denZ[i] = std::make_unique<TH1D>(Form("denZ_L%d", i), Form("denZ_L%d", i), 100, -15, 15);
+    numZ[i] = std::make_unique<TH1D>(Form("numZ_L%d", i), Form("numZ_L%d", i), 100, -15, 15);
+    numZGood[i] = std::make_unique<TH1D>(Form("numZGood_L%d", i), Form("numZGood_L%d", i), 100, -15, 15);
+    numZFake[i] = std::make_unique<TH1D>(Form("numZFake_L%d", i), Form("numZFake_L%d", i), 100, -15, 15);
+
+    mDenColEta[i] = std::make_unique<TH2D>(Form("mDenColEta_L%d", i), Form("mDenColEta_L%d", i), 128, -0.5, 1023.5, 50, -1, 1);
+    mNumColEta[i] = std::make_unique<TH2D>(Form("mNumColEta_L%d", i), Form("mNumColEta_L%d", i), 128, -0.5, 1023.5, 50, -1, 1);
+
+    mDenRowPhi[i] = std::make_unique<TH2D>(Form("mDenRowPhi_L%d", i), Form("mDenRowPhi_L%d", i), 128, -0.5, 511.5, 90, -3.2, 3.2);
+    mNumRowPhi[i] = std::make_unique<TH2D>(Form("mNumRowPhi_L%d", i), Form("mNumRowPhi_L%d", i), 128, -0.5, 511.5, 90, -3.2, 3.2);
+
+    mDenRowCol[i] = std::make_unique<TH2D>(Form("mDenRowCol_L%d", i), Form("mDenRowCol_L%d", i), 128, -0.5, 511.5, 128, -0.5, 1023.5);
+    mNumRowCol[i] = std::make_unique<TH2D>(Form("mNumRowCol_L%d", i), Form("mNumRowCol_L%d", i), 128, -0.5, 511.5, 128, -0.5, 1023.5);
 
     IPOriginalxy[i] = std::make_unique<TH1D>(Form("IPOriginalxy_L%d", i), Form("IPOriginalxy_L%d", i), 500, -0.002, 0.002);
     IPOriginalz[i] = std::make_unique<TH1D>(Form("IPOriginalz_L%d", i), Form("IPOriginalz_L%d", i), 200, -10, 10);
-    IPOriginalifDuplicatedxy[i] = std::make_unique<TH1D>(Form("IPOriginalifDuplicatedxy_L%d", i), Form("IPOriginalifDuplicatedxy_L%d", i), 1000, -0.005, 0.005);
-    IPOriginalifDuplicatedz[i] = std::make_unique<TH1D>(Form("IPOriginalifDuplicatedz_L%d", i), Form("IPOriginalifDuplicatedz_L%d", i), 200, -10, 10);
+
+    phiFound[i] = std::make_unique<TH1D>(Form("phiFound_L%d", i), Form("phiFound_L%d", i), 190, -3.2, 3.2);
+    rowFound[i] = std::make_unique<TH1D>(Form("rowFound_L%d", i), Form("rowFound_L%d", i), 128, -0.5, 511.5);
+    phiNotFound[i] = std::make_unique<TH1D>(Form("phiNotFound_L%d", i), Form("phiNotFound_L%d", i), 90, -3.2, 3.2);
+    rowNotFound[i] = std::make_unique<TH1D>(Form("rowNotFound_L%d", i), Form("rowNotFound_L%d", i), 128, -0.5, 511.5);
+    zFound[i] = std::make_unique<TH1D>(Form("zFound_L%d", i), Form("zFound_L%d", i), 100, -15, 15);
+    zNotFound[i] = std::make_unique<TH1D>(Form("zNotFound%d", i), Form("zNotFound%d", i), 100, -15, 15);
+    colFoundOriginalVsDuplicated[i] = std::make_unique<TH2D>(Form("colFoundOriginalVsDuplicated_L%d", i), Form("colFoundOriginalVsDuplicated_L%d; Col Original cluster; Col Overlap cluster", i), 9216, -0.5, 9215.5, 9216, -0.5, 9215.5);
+    colFoundOriginal[i] = std::make_unique<TH1D>(Form("colFoundOriginal_L%d", i), Form("colFoundOriginal_L%d; Col Original cluster;", i), 9216, -0.5, 9215.5);
+    colNotFound[i] = std::make_unique<TH1D>(Form("colNotFound_L%d", i), Form("colNotFound_L%d", i), 9216, -0.5, 9215.5);
+    radiusFound[i] = std::make_unique<TH1D>(Form("radiusFound_L%d", i), Form("radiusFound_L%d", i), 80, 0, 6);
+    radiusNotFound[i] = std::make_unique<TH1D>(Form("radiusNotFound_L%d", i), Form("radiusNotFound_L%d", i), 80, 0, 4);
 
     for (int j = 0; j < 3; j++) {
       mDuplicatedEta[i][j] = std::make_unique<TH1D>(Form("mDuplicatedEta_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #eta; Number of duplicated clusters L%d", mrangesPt[j][0], mrangesPt[j][1], i), 40, -2, 2);
       mNGoodMatchesEta[i][j] = std::make_unique<TH1D>(Form("mNGoodMatchesEta_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #eta; Number of good matches L%d", mrangesPt[j][0], mrangesPt[j][1], i), 40, -2, 2);
       mNFakeMatchesEta[i][j] = std::make_unique<TH1D>(Form("mNFakeMatchesEta_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #eta; Number of fake matches L%d", mrangesPt[j][0], mrangesPt[j][1], i), 40, -2, 2);
 
-      mDuplicatedPhi[i][j] = std::make_unique<TH1D>(Form("mDuplicatedPhi_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #phi; Number of duplicated clusters L%d", mrangesPt[j][0], mrangesPt[j][1], i), 1440, -180, 180);
-      mNGoodMatchesPhi[i][j] = std::make_unique<TH1D>(Form("mNGoodMatchesPhi_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #phi; Number of good matches L%d", mrangesPt[j][0], mrangesPt[j][1], i), 1440, -180, 180);
-      mNFakeMatchesPhi[i][j] = std::make_unique<TH1D>(Form("mNFakeMatchesPhi_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #phi; Number of fake matches L%d", mrangesPt[j][0], mrangesPt[j][1], i), 1440, -180, 180);
+      mDuplicatedPhi[i][j] = std::make_unique<TH1D>(Form("mDuplicatedPhi_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #phi; Number of duplicated clusters L%d", mrangesPt[j][0], mrangesPt[j][1], i), 90, -3.2, 3.2);
+      mNGoodMatchesPhi[i][j] = std::make_unique<TH1D>(Form("mNGoodMatchesPhi_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #phi; Number of good matches L%d", mrangesPt[j][0], mrangesPt[j][1], i), 90, -3.2, 3.2);
+      mNFakeMatchesPhi[i][j] = std::make_unique<TH1D>(Form("mNFakeMatchesPhi_L%d_pt%d", i, j), Form("%f < #it{p}_{T} < %f GeV/c; #phi; Number of fake matches L%d", mrangesPt[j][0], mrangesPt[j][1], i), 90, -3.2, 3.2);
     }
   }
   gStyle->SetPalette(55);
@@ -508,7 +562,6 @@ void EfficiencyStudy::initialiseRun(o2::globaltracking::RecoContainer& recoData)
     mTracksMCLabels = recoData.getITSTracksMCLabels();
     mClustersMCLCont = recoData.getITSClustersMCLabels();
   }
-
   mITSClustersArray.clear();
   mTracksROFRecords = recoData.getITSTracksROFRecords();
   mTracks = recoData.getITSTracks();
@@ -574,7 +627,7 @@ int EfficiencyStudy::getDCAClusterTrackMC(int countDuplicated = 0)
         continue;
       }
 
-      float ip[2];
+      float ip[2]; // IP from 0,0,0 and the track should be the deplacement of the primary vertex
       track.getImpactParams(0, 0, 0, 0, ip);
 
       // if (abs(ip[0])>0.001 ) continue; ///pv not in (0,0,0)
@@ -587,14 +640,12 @@ int EfficiencyStudy::getDCAClusterTrackMC(int countDuplicated = 0)
       auto pt = trackParCov.getPt();
       auto eta = trackParCov.getEta();
 
-      float phiTrack = trackParCov.getPhi() * 180 / M_PI;
-
-      if (pt < mPtCuts[0] || pt > mPtCuts[1]) {
-        continue;
-      }
-      if (eta < mEtaCuts[0] || eta > mEtaCuts[1]) {
-        continue;
-      }
+      // if (pt < mPtCuts[0] || pt > mPtCuts[1]) {
+      //   continue;
+      // }
+      // if (eta < mEtaCuts[0] || eta > mEtaCuts[1]) {
+      //   continue;
+      // }
 
       float phioriginal = 0;
       float phiduplicated = 0;
@@ -617,8 +668,7 @@ int EfficiencyStudy::getDCAClusterTrackMC(int countDuplicated = 0)
         o2::math_utils::Point3D<float> clusOriginalPointTrack = {clusOriginalPoint.getX(), clusOriginalPoint.getY(), clusOriginalPoint.getZ()};
         o2::math_utils::Point3D<float> clusOriginalPointGlob = mGeometry->getMatrixT2G(clusOriginal.getSensorID()) * clusOriginalPointTrack;
 
-        phioriginal = clusOriginalPointGlob.phi() * 180 / M_PI;
-        mPhiTrackoriginalvsphioriginal[layer]->Fill(phiTrack, phioriginal);
+        phioriginal = clusOriginalPointGlob.phi(); // * 180 / M_PI;
 
         mPhiOriginal[layer]->Fill(phioriginal);
         mPtOriginal[layer]->Fill(pt);
@@ -645,7 +695,7 @@ int EfficiencyStudy::getDCAClusterTrackMC(int countDuplicated = 0)
               o2::math_utils::Point3D<float> clusDuplicatedPointTrack = {clusDuplicatedPoint.getX(), clusDuplicatedPoint.getY(), clusDuplicatedPoint.getZ()};
               o2::math_utils::Point3D<float> clusDuplicatedPointGlob = mGeometry->getMatrixT2G(clusDuplicated.getSensorID()) * clusDuplicatedPointTrack;
               // phiduplicated = std::atan2(clusDuplicatedPointGlob.y(), clusDuplicatedPointGlob.x()) * 180 / M_PI + 180;
-              phiduplicated = clusDuplicatedPointGlob.phi() * 180 / M_PI;
+              phiduplicated = clusDuplicatedPointGlob.phi(); // * 180 / M_PI;
 
               auto labsClus = mClustersMCLCont->getLabels(iClus); // ideally I can have more than one label per cluster
               for (auto labC : labsClus) {
@@ -686,8 +736,6 @@ int EfficiencyStudy::getDCAClusterTrackMC(int countDuplicated = 0)
                     mEtaDuplicated[layerClus]->Fill(eta);
                     mPhiDuplicated[layerClus]->Fill(phiduplicated);
                     mZvsPhiDUplicated[layerClus]->Fill(clusDuplicatedPointGlob.Z(), phiduplicated);
-                    mPhiTrackDuplicated[layerClus]->Fill(phiTrack);
-                    mPhiTrackDuplicatedvsphiDuplicated[layerClus]->Fill(phiTrack, phioriginal);
                     mPhiOriginalIfDuplicated[layerClus]->Fill(phioriginal);
                   }
 
@@ -700,6 +748,8 @@ int EfficiencyStudy::getDCAClusterTrackMC(int countDuplicated = 0)
                     }
                     UShort_t rowDuplicated = clusDuplicated.getRow();
                     mDuplicatedRow[layerDuplicated]->Fill(rowOriginal);
+                    mDuplicatedCol[layerDuplicated]->Fill(clusOriginal.getCol());
+                    mDuplicatedZ[layerDuplicated]->Fill(clusOriginalPointGlob.Z());
                     mDuplicatedPt[layerDuplicated]->Fill(pt);
                     mDuplicatedPtEta[layerDuplicated]->Fill(pt, eta);
                     mDuplicatedPtPhi[layerDuplicated]->Fill(pt, phiduplicated);
@@ -713,12 +763,6 @@ int EfficiencyStudy::getDCAClusterTrackMC(int countDuplicated = 0)
                   m3DClusterPositions->Fill(clusDuplicatedPointGlob.x(), clusDuplicatedPointGlob.y(), clusDuplicatedPointGlob.z());
                   m2DClusterDuplicatedPositions->Fill(clusDuplicatedPointGlob.x(), clusDuplicatedPointGlob.y());
 
-                  /// compute the distance between original and dubplicated cluster
-                  mDistanceClustersX[layerClus]->Fill(abs(clusOriginalPointGlob.x() - clusDuplicatedPointGlob.x()));
-                  mDistanceClustersY[layerClus]->Fill(abs(clusOriginalPointGlob.y() - clusDuplicatedPointGlob.y()));
-                  mDistanceClustersZ[layerClus]->Fill(abs(clusOriginalPointGlob.z() - clusDuplicatedPointGlob.z()));
-                  mDistanceClusters[layerClus]->Fill(std::hypot(clusOriginalPointGlob.x() - clusDuplicatedPointGlob.x(), clusOriginalPointGlob.y() - clusDuplicatedPointGlob.y(), clusOriginalPointGlob.z() - clusDuplicatedPointGlob.z()));
-
                   /// Compute the DCA between the cluster location and the track
 
                   /// first propagate to the original cluster
@@ -815,7 +859,6 @@ void EfficiencyStudy::countDuplicatedAfterCuts()
     rofNEntriesClus = mClustersROFRecords[iROF].getNEntries();
 
     for (unsigned int iTrack = rofIndexTrack; iTrack < rofIndexTrack + rofNEntriesTrack; iTrack++) { // loop on tracks per ROF
-      // std::cout<<"Track number: "<<iTrack<<std::endl;
 
       auto track = mTracks[iTrack];
       o2::track::TrackParCov trackParCov = mTracks[iTrack];
@@ -831,14 +874,11 @@ void EfficiencyStudy::countDuplicatedAfterCuts()
         continue;
       }
 
-      auto pt = trackParCov.getPt();
       auto eta = trackParCov.getEta();
 
-      // applying the cuts on the track - only pt and eta cuts since for phi the layer is needed
-      if (pt < mPtCuts[0] || pt > mPtCuts[1]) {
-        continue;
-      }
-      if (eta < mEtaCuts[0] || eta > mEtaCuts[1]) {
+      // applying the cuts on the track - only eta
+
+      if (eta < mEtaCuts[0] || eta >= mEtaCuts[1]) {
         continue;
       }
 
@@ -860,38 +900,22 @@ void EfficiencyStudy::countDuplicatedAfterCuts()
 
         o2::math_utils::Point3D<float> clusOriginalPointTrack = {clusOriginalPoint.getX(), clusOriginalPoint.getY(), clusOriginalPoint.getZ()};
         o2::math_utils::Point3D<float> clusOriginalPointGlob = mGeometry->getMatrixT2G(clusOriginal.getSensorID()) * clusOriginalPointTrack;
-        phiOriginal = clusOriginalPointGlob.phi() * 180 / M_PI;
+        phiOriginal = clusOriginalPointGlob.phi(); // * 180 / M_PI;
 
-        /// applying the cuts on the phi of the original cluster
-        bool keepTrack = false; /// wether or not a cluster is found in an eligible track in the corresponding layer
-
-        if (layerOriginal == 0) {
-          for (int i = 0; i < 10; i++) {
-            if ((phiOriginal >= mPhiCutsL0[i][0] && phiOriginal <= mPhiCutsL0[i][1])) {
-              possibleduplicated[0]++;
-              keepTrack = true;
-            }
-          }
+        if (abs(clusOriginalPointGlob.y()) < 0.5) { ///// excluding gap between bottom and top barrels
+          continue;
         }
-        if (layerOriginal == 1) {
-          for (int i = 0; i < 12; i++) {
-            if ((phiOriginal >= mPhiCutsL1[i][0] && phiOriginal <= mPhiCutsL1[i][1])) {
-              possibleduplicated[1]++;
-              keepTrack = true;
-            }
-          }
+
+        if (abs(clusOriginalPointGlob.z()) >= 10) { /// excluding external z
+          continue;
         }
-        if (layerOriginal == 2) {
-          for (int i = 0; i < 17; i++) {
-            if ((phiOriginal >= mPhiCutsL2[i][0] && phiOriginal <= mPhiCutsL2[i][1])) {
-              possibleduplicated[2]++;
-              keepTrack = true;
-            }
-          }
+
+        if (clusOriginal.getRow() < 2 || (clusOriginal.getRow() > 15 && clusOriginal.getRow() < 496) || clusOriginal.getRow() > 509) { ////  cutting on the row
+          continue;
         }
 
-        if (!keepTrack) {
-          continue; /// if the track (cluster) is not eligible for any layer, go to the next one
+        if (clusOriginal.getCol() < 160 || clusOriginal.getCol() > 870) { /// excluding the gap between two chips in the same stave (comment to obtain the plot efficiency col vs eta)
+          continue;
         }
 
         for (auto& labT : labsTrack) { // for each valid label iterate over ALL the clusters in the ROF to see if there are duplicates
@@ -912,7 +936,7 @@ void EfficiencyStudy::countDuplicatedAfterCuts()
 
               o2::math_utils::Point3D<float> clusDuplicatedPointTrack = {clusDuplicatedPoint.getX(), clusDuplicatedPoint.getY(), clusDuplicatedPoint.getZ()};
               o2::math_utils::Point3D<float> clusDuplicatedPointGlob = mGeometry->getMatrixT2G(clusDuplicated.getSensorID()) * clusDuplicatedPointTrack;
-              phi = clusDuplicatedPointGlob.phi() * 180 / M_PI;
+              phi = clusDuplicatedPointGlob.phi(); // * 180 / M_PI;
 
               auto labsClus = mClustersMCLCont->getLabels(iClus); // ideally I can have more than one label per cluster
               for (auto labC : labsClus) {
@@ -940,7 +964,7 @@ void EfficiencyStudy::countDuplicatedAfterCuts()
                   }
 
                   duplicated[layer]++;
-                  std::cout << "Taken L" << layer << " # " << duplicated[layer] << " : pt, eta, phi = " << pt << " , " << eta << " , " << phiOriginal << " Label: " << std::endl;
+                  std::cout << "Taken L" << layer << " # " << duplicated[layer] << " : eta, phi = " << eta << " , " << phiOriginal << " Label: " << std::endl;
                   labC.print();
                 }
               }
@@ -1035,15 +1059,6 @@ void EfficiencyStudy::studyDCAcutsMC()
       float ip[2];
       track.getImpactParams(0, 0, 0, 0, ip);
 
-      if (pt < mPtCuts[0] || pt > mPtCuts[1]) {
-        continue;
-      }
-      if (eta < mEtaCuts[0] || eta > mEtaCuts[1]) {
-        continue;
-      }
-
-      float phiTrack = trackParCov.getPhi() * 180 / M_PI;
-
       float phi = -999.;
       float phiOriginal = -999.;
       int firstClus = track.getFirstClusterEntry(); // get the first cluster of the track
@@ -1077,7 +1092,7 @@ void EfficiencyStudy::studyDCAcutsMC()
         o2::math_utils::Point3D<float> clusOriginalPointTrack = {clusOriginalPoint.getX(), clusOriginalPoint.getY(), clusOriginalPoint.getZ()};
         o2::math_utils::Point3D<float> clusOriginalPointGlob = mGeometry->getMatrixT2G(clusOriginal.getSensorID()) * clusOriginalPointTrack;
 
-        phiOriginal = clusOriginalPointGlob.phi() * 180 / M_PI;
+        phiOriginal = clusOriginalPointGlob.phi(); // * 180 / M_PI;
 
         for (auto& labT : labsOriginal) { // for each valid label iterate over ALL the clusters in the ROF to see if there are duplicates
           if (labT != tracklab) {
@@ -1114,7 +1129,7 @@ void EfficiencyStudy::studyDCAcutsMC()
 
             o2::math_utils::Point3D<float> clusDuplicatedPointTrack = {clusDuplicatedPoint.getX(), clusDuplicatedPoint.getY(), clusDuplicatedPoint.getZ()};
             o2::math_utils::Point3D<float> clusDuplicatedPointGlob = mGeometry->getMatrixT2G(clusDuplicated.getSensorID()) * clusDuplicatedPointTrack;
-            phi = clusDuplicatedPointGlob.phi() * 180 / M_PI;
+            phi = clusDuplicatedPointGlob.phi(); // * 180 / M_PI;
 
             /// Compute the DCA between the duplicated cluster location and the track
             trackParCov.rotate(mGeometry->getSensorRefAlpha(clusDuplicated.getSensorID()));
@@ -1150,7 +1165,6 @@ void EfficiencyStudy::studyDCAcutsMC()
                     mnGoodMatchesPt_layer[layerDuplicated]->Fill(pt, i);
                     mnGoodMatchesEta_layer[layerDuplicated]->Fill(eta, i);
                     mnGoodMatchesPhi_layer[layerDuplicated]->Fill(phi, i);
-                    mnGoodMatchesPhiTrack_layer[layerDuplicated]->Fill(phiTrack, i);
                     mnGoodMatchesPhiOriginal_layer[layerDuplicated]->Fill(phiOriginal, i);
                   } else {
 
@@ -1159,7 +1173,6 @@ void EfficiencyStudy::studyDCAcutsMC()
                     mnFakeMatchesPt_layer[layerDuplicated]->Fill(pt, i);
                     mnFakeMatchesEta_layer[layerDuplicated]->Fill(eta, i);
                     mnFakeMatchesPhi_layer[layerDuplicated]->Fill(phi, i);
-                    mnFakeMatchesPhiTrack_layer[layerDuplicated]->Fill(phiTrack, i);
                   }
                 } else if (mVerboseOutput) {
                   LOGP(info, "Check DCA failed");
@@ -1211,13 +1224,6 @@ void EfficiencyStudy::studyDCAcutsMC()
           mEfficiencyGoodMatchPhiOriginal_layer[l]->SetBinContent(iphi + 1, i + 1, mnGoodMatchesPhiOriginal_layer[l]->GetBinContent(iphi + 1, i + 1) / mPhiOriginalIfDuplicated[l]->GetBinContent(iphi + 1));
         }
       }
-
-      for (int iphi = 0; iphi < mPhiTrackDuplicated[l]->GetNbinsX(); iphi++) {
-        if (mPhiTrackDuplicated[l]->GetBinContent(iphi + 1) != 0) {
-          mEfficiencyGoodMatchPhiTrack_layer[l]->SetBinContent(iphi + 1, i + 1, mnGoodMatchesPhiTrack_layer[l]->GetBinContent(iphi + 1, i + 1) / mPhiTrackDuplicated[l]->GetBinContent(iphi + 1));
-        }
-        mEfficiencyFakeMatchPhiTrack_layer[l]->SetBinContent(iphi + 1, i + 1, mnFakeMatchesPhiTrack_layer[l]->GetBinContent(iphi + 1, i + 1) / mPhiTrackDuplicated[l]->GetBinContent(iphi + 1));
-      }
     }
   }
   for (int i = 0; i < NLAYERS; i++) {
@@ -1243,8 +1249,6 @@ void EfficiencyStudy::studyDCAcutsMC()
     mEfficiencyGoodMatchEta_layer[l]->Write();
     mEfficiencyGoodMatchPhi_layer[l]->GetZaxis()->SetRangeUser(0, 1);
     mEfficiencyGoodMatchPhi_layer[l]->Write();
-    mEfficiencyGoodMatchPhiTrack_layer[l]->GetZaxis()->SetRangeUser(0, 1);
-    mEfficiencyGoodMatchPhiTrack_layer[l]->Write();
     mEfficiencyGoodMatchPhiOriginal_layer[l]->GetZaxis()->SetRangeUser(0, 1);
     mEfficiencyGoodMatchPhiOriginal_layer[l]->Write();
     mEfficiencyFakeMatchPt_layer[l]->GetZaxis()->SetRangeUser(0, 1);
@@ -1253,8 +1257,6 @@ void EfficiencyStudy::studyDCAcutsMC()
     mEfficiencyFakeMatchEta_layer[l]->Write();
     mEfficiencyFakeMatchPhi_layer[l]->GetZaxis()->SetRangeUser(0, 1);
     mEfficiencyFakeMatchPhi_layer[l]->Write();
-    mEfficiencyFakeMatchPhiTrack_layer[l]->GetZaxis()->SetRangeUser(0, 1);
-    mEfficiencyFakeMatchPhiTrack_layer[l]->Write();
   }
 
   mOutFile->mkdir("Efficiency/");
@@ -1289,7 +1291,6 @@ void EfficiencyStudy::studyDCAcutsMC()
   mEfficiencyTotal->Draw("same P l E1_NOSTAT  PLC PMC");
   leg->Draw("same");
   c.Write();
-  c.SaveAs("prova.png");
 
   TCanvas cc[NLAYERS];
   for (int l = 0; l < NLAYERS; l++) {
@@ -1312,12 +1313,12 @@ void EfficiencyStudy::studyDCAcutsMC()
     mEfficiencyTotal_layer[l]->Draw("same P l E1_NOSTAT");
     leg->Draw("same");
     cc[l].Write();
-    cc[l].SaveAs(Form("provaLayer%d.png", l));
   }
 }
 
 void EfficiencyStudy::studyClusterSelectionMC()
 {
+  //// to be used only with MC
   // study to find a good selection method for the duplicated cluster, to be used for non-MC data
   // iterate over tracks an associated clusters, and find the closer cluster that is not the original one applying cuts on staveID and chipID
   // fix the DCA < 10 sigma, then compute the efficiency for each bin of pt, eta and phi and also in the rows
@@ -1392,14 +1393,6 @@ void EfficiencyStudy::studyClusterSelectionMC()
       auto pt = trackParCov.getPt();
       auto eta = trackParCov.getEta();
 
-      if (pt < mPtCuts[0] || pt > mPtCuts[1]) {
-        continue;
-      }
-      if (eta < mEtaCuts[0] || eta > mEtaCuts[1]) {
-        continue;
-      }
-
-      // auto phi = trackParCov.getPhi()*180/M_PI;
       float phi = -999.;
       float phiOriginal = -999.;
       float phiDuplicated = -999.;
@@ -1410,7 +1403,6 @@ void EfficiencyStudy::studyClusterSelectionMC()
         tracklab.print();
       }
       for (int iclTrack = firstClus; iclTrack < firstClus + ncl; iclTrack++) { // loop on clusters associated to the track to extract layer, stave and chip to restrict the possible matches to be searched with the DCA cut
-        // LOGP(info, "New cluster");
         auto& clusOriginal = mClusters[mInputITSidxs[iclTrack]];
         auto layerOriginal = mGeometry->getLayer(clusOriginal.getSensorID());
         if (layerOriginal >= NLAYERS) {
@@ -1426,7 +1418,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
         o2::math_utils::Point3D<float> clusOriginalPointTrack = {clusOriginalPoint.getX(), clusOriginalPoint.getY(), clusOriginalPoint.getZ()};
         o2::math_utils::Point3D<float> clusOriginalPointGlob = mGeometry->getMatrixT2G(clusOriginal.getSensorID()) * clusOriginalPointTrack;
 
-        auto phiOriginal = clusOriginalPointGlob.phi() * 180 / M_PI;
+        auto phiOriginal = clusOriginalPointGlob.phi(); // * 180 / M_PI;
 
         auto labsOriginal = mClustersMCLCont->getLabels(mInputITSidxs[iclTrack]); // get labels of the cluster associated to the track (original)
         auto staveOriginal = mGeometry->getStave(clusOriginal.getSensorID());
@@ -1464,7 +1456,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
           o2::math_utils::Point3D<float> clusDuplicatedPointTrack = {clusDuplicatedPoint.getX(), clusDuplicatedPoint.getY(), clusDuplicatedPoint.getZ()};
           o2::math_utils::Point3D<float> clusDuplicatedPointGlob = mGeometry->getMatrixT2G(clusDuplicated.getSensorID()) * clusDuplicatedPointTrack;
 
-          auto phiDuplicated = clusDuplicatedPointGlob.phi() * 180 / M_PI;
+          auto phiDuplicated = clusDuplicatedPointGlob.phi(); // * 180 / M_PI;
 
           /// Compute the DCA between the duplicated cluster location and the track
           trackParCov.rotate(mGeometry->getSensorRefAlpha(clusDuplicated.getSensorID()));
@@ -1473,7 +1465,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
           }
 
           // Imposing that the distance between the original cluster and the duplicated one is less than x sigma
-          if (!(abs(meanDCAxyDuplicated[layerDuplicated] - clusDuplicatedDCA[0]) < 8 * sigmaDCAxyDuplicated[layerDuplicated] && abs(meanDCAzDuplicated[layerDuplicated] - clusDuplicatedDCA[1]) < 8 * sigmaDCAzDuplicated[layerDuplicated])) {
+          if (!(clusDuplicatedDCA[0] > mDCACutsXY[layerDuplicated][0] && clusDuplicatedDCA[0] < mDCACutsXY[layerDuplicated][1] && clusDuplicatedDCA[1] > mDCACutsZ[layerDuplicated][0] && clusDuplicatedDCA[1] < mDCACutsZ[layerDuplicated][1])) {
             continue;
           }
 
@@ -1503,12 +1495,11 @@ void EfficiencyStudy::studyClusterSelectionMC()
         for (auto lab : std::get<2>(clusID_rDCA_label)) {
           if (lab == tracklab) {
             isGood = true;
-            diffPhivsPt[layerOriginal]->Fill(pt, abs(phi - phiOriginal));
-            IPOriginalifDuplicatedxy[layerOriginal]->Fill(ip[0]);
-            IPOriginalifDuplicatedz[layerOriginal]->Fill(ip[1]);
 
             mNGoodMatchesPt[layerOriginal]->Fill(pt);
             mNGoodMatchesRow[layerOriginal]->Fill(row);
+            mNGoodMatchesCol[layerOriginal]->Fill(clusOriginal.getCol());
+            mNGoodMatchesZ[layerOriginal]->Fill(clusOriginalPointGlob.Z());
             mNGoodMatchesPtEta[layerOriginal]->Fill(pt, eta);
             mNGoodMatchesPtPhi[layerOriginal]->Fill(pt, phi);
             mNGoodMatchesEtaPhi[layerOriginal]->Fill(eta, phi);
@@ -1529,6 +1520,8 @@ void EfficiencyStudy::studyClusterSelectionMC()
 
           mNFakeMatchesPt[layerOriginal]->Fill(pt);
           mNFakeMatchesRow[layerOriginal]->Fill(row);
+          mNFakeMatchesCol[layerOriginal]->Fill(clusOriginal.getCol());
+          mNFakeMatchesZ[layerOriginal]->Fill(clusOriginalPointGlob.Z());
           mNFakeMatchesPtEta[layerOriginal]->Fill(pt, eta);
           mNFakeMatchesPtPhi[layerOriginal]->Fill(pt, phi);
           mNFakeMatchesEtaPhi[layerOriginal]->Fill(eta, phi);
@@ -1549,33 +1542,37 @@ void EfficiencyStudy::studyClusterSelectionMC()
   mOutFile->mkdir("EfficiencyCuts/");
   mOutFile->cd("EfficiencyCuts/");
 
-  std::cout << "------Calculatin efficiency..." << std::endl;
-  TH1D* axpt = new TH1D("axpt", "", 1, 0.05, 7.5);
-  TH1D* axRow = new TH1D("axRow", "", 1, -0.5, 511.5);
-  TH2D* axptetaGood = new TH2D("axptetaGood", "", 1, 0.05, 7.5, 1, -2, 2);
-  TH2D* axptetaFake = new TH2D("axptetaFake", "", 1, 0.05, 7.5, 1, -2, 2);
-  TH2D* axptphiGood = new TH2D("axptphiGood", "", 1, 0.05, 7.5, 1, -180, 180);
-  TH2D* axptphiFake = new TH2D("axptphiFake", "", 1, 0.05, 7.5, 1, -180, 180);
-  TH2D* axetaphiGood = new TH2D("axetaphiGood", "", 1, -2, 2, 1, -180, 180);
-  TH2D* axetaphiFake = new TH2D("axetaphiFake", "", 1, -2, 2, 1, -180, 180);
-  TH1D* axetaAllPt = new TH1D("axetaAllPt", "", 1, -2, 2);
-  TH1D* axeta[NLAYERS];
-  TH1D* axphi[NLAYERS];
+  std::cout << "Calculating efficiency..." << std::endl;
+  std::unique_ptr<TH1D> axpt = std::make_unique<TH1D>("axpt", "", 1, 0.05, 7.5);
+  std::unique_ptr<TH1D> axRow = std::make_unique<TH1D>("axRow", "", 1, -0.5, 511.5);
+  std::unique_ptr<TH1D> axCol = std::make_unique<TH1D>("axRow", "", 1, -0.5, 1023.5);
+  std::unique_ptr<TH1D> axZ = std::make_unique<TH1D>("axZ", "", 1, -15, 15);
+  std::unique_ptr<TH2D> axptetaGood = std::make_unique<TH2D>("axptetaGood", "", 1, 0.05, 7.5, 1, -2, 2);
+  std::unique_ptr<TH2D> axptetaFake = std::make_unique<TH2D>("axptetaFake", "", 1, 0.05, 7.5, 1, -2, 2);
+  std::unique_ptr<TH2D> axptphiGood = std::make_unique<TH2D>("axptphiGood", "", 1, 0.05, 7.5, 1, -3.2, 3.2);
+  std::unique_ptr<TH2D> axptphiFake = std::make_unique<TH2D>("axptphiFake", "", 1, 0.05, 7.5, 1, -3.2, 3.2);
+  std::unique_ptr<TH2D> axetaphiGood = std::make_unique<TH2D>("axetaphiGood", "", 1, -2, 2, 1, -3.2, 3.2);
+  std::unique_ptr<TH2D> axetaphiFake = std::make_unique<TH2D>("axetaphiFake", "", 1, -2, 2, 1, -3.2, 3.2);
+  std::unique_ptr<TH1D> axetaAllPt = std::make_unique<TH1D>("axetaAllPt", "", 1, -2, 2);
+  std::unique_ptr<TH1D> axeta[NLAYERS];
+  std::unique_ptr<TH1D> axphi[NLAYERS];
   for (int ipt = 0; ipt < 3; ipt++) {
-    axeta[ipt] = new TH1D(Form("axeta%d", ipt), Form("axeta%d", ipt), 1, -2, 2);
-    axphi[ipt] = new TH1D(Form("axphi%d", ipt), Form("axphi%d", ipt), 1, -180, 180);
+    axeta[ipt] = std::make_unique<TH1D>(Form("axeta%d", ipt), Form("axeta%d", ipt), 1, -2, 2);
+    axphi[ipt] = std::make_unique<TH1D>(Form("axphi%d", ipt), Form("axphi%d", ipt), 1, -3.2, 3.2);
   }
-  TH1D* axphiAllPt = new TH1D("axphi", "", 1, -180, 180);
-
-  TCanvas* effPt[NLAYERS];
-  TCanvas* effRow[NLAYERS];
-  TCanvas* effPtEta[NLAYERS][2];
-  TCanvas* effPtPhi[NLAYERS][2];
-  TCanvas* effEtaPhi[NLAYERS][2];
-  TCanvas* effEtaAllPt[NLAYERS];
-  TCanvas* effEta[NLAYERS][3];
-  TCanvas* effPhiAllPt[NLAYERS];
-  TCanvas* effPhi[NLAYERS][3];
+  std::unique_ptr<TH1D> axphiAllPt = std::make_unique<TH1D>("axphi", "", 1, -3.2, 3.2);
+
+  std::unique_ptr<TCanvas> effPt[NLAYERS];
+  std::unique_ptr<TCanvas> effRow[NLAYERS];
+  std::unique_ptr<TCanvas> effCol[NLAYERS];
+  std::unique_ptr<TCanvas> effZ[NLAYERS];
+  std::unique_ptr<TCanvas> effPtEta[NLAYERS][2];
+  std::unique_ptr<TCanvas> effPtPhi[NLAYERS][2];
+  std::unique_ptr<TCanvas> effEtaPhi[NLAYERS][2];
+  std::unique_ptr<TCanvas> effEtaAllPt[NLAYERS];
+  std::unique_ptr<TCanvas> effEta[NLAYERS][3];
+  std::unique_ptr<TCanvas> effPhiAllPt[NLAYERS];
+  std::unique_ptr<TCanvas> effPhi[NLAYERS][3];
 
   ///////////////// plotting results
   for (int l = 0; l < 3; l++) {
@@ -1583,12 +1580,8 @@ void EfficiencyStudy::studyClusterSelectionMC()
       std::cout << "Pt L" << l << "\n\n";
     }
 
-    diffPhivsPt[l]->Write();
-    IPOriginalifDuplicatedxy[l]->Write();
-    IPOriginalifDuplicatedz[l]->Write();
-
     // Pt
-    effPt[l] = new TCanvas(Form("effPt_L%d", l));
+    effPt[l] = std::make_unique<TCanvas>(Form("effPt_L%d", l));
 
     mEffPtGood[l] = std::make_unique<TEfficiency>(*mNGoodMatchesPt[l], *mDuplicatedPt[l]);
     stileEfficiencyGraph(mEffPtGood[l], Form("mEffPtGood_L%d", l), Form("L%d;#it{p}_{T} (GeV/#it{c});Efficiency", l), false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
@@ -1616,7 +1609,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
     effPt[l]->Write();
 
     // PtEtaGood
-    effPtEta[l][0] = new TCanvas(Form("effPtEtaGood_L%d", l));
+    effPtEta[l][0] = std::make_unique<TCanvas>(Form("effPtEtaGood_L%d", l));
 
     mEffPtEtaGood[l] = std::make_unique<TEfficiency>(*mNGoodMatchesPtEta[l], *mDuplicatedPtEta[l]);
     stileEfficiencyGraph(mEffPtEtaGood[l], Form("mEffPtEtaGood_L%d", l), Form("L%d;#it{p}_{T} (GeV/#it{c});#eta;Efficiency", l), true);
@@ -1647,7 +1640,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
     }
 
     // Row
-    effRow[l] = new TCanvas(Form("effRow_L%d", l));
+    effRow[l] = std::make_unique<TCanvas>(Form("effRow_L%d", l));
 
     for (int ibin = 1; ibin <= mNGoodMatchesRow[l]->GetNbinsX(); ibin++) {
       std::cout << "--- Good Row: Npass = " << mNGoodMatchesRow[l]->GetBinContent(ibin) << ",  Nall = " << mDuplicatedRow[l]->GetBinContent(ibin) << " for ibin = " << ibin << std::endl;
@@ -1667,7 +1660,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
 
     axRow->SetTitle(Form("L%d;Row;Efficiency", l));
     axRow->GetYaxis()->SetRangeUser(-0.1, 1.1);
-    axRow->GetXaxis()->SetRangeUser(0.05, 7.5);
+    axRow->GetXaxis()->SetRangeUser(0, 512);
     axRow->Draw();
     mEffRowGood[l]->Draw("same p");
     mEffRowFake[l]->Draw("same p");
@@ -1678,8 +1671,72 @@ void EfficiencyStudy::studyClusterSelectionMC()
     legRow->Draw("same");
     effRow[l]->Write();
 
+    // Col
+    effCol[l] = std::make_unique<TCanvas>(Form("effCol_L%d", l));
+
+    for (int ibin = 1; ibin <= mNGoodMatchesCol[l]->GetNbinsX(); ibin++) {
+      std::cout << "--- Good Col: Npass = " << mNGoodMatchesCol[l]->GetBinContent(ibin) << ",  Nall = " << mDuplicatedCol[l]->GetBinContent(ibin) << " for ibin = " << ibin << std::endl;
+    }
+
+    mEffColGood[l] = std::make_unique<TEfficiency>(*mNGoodMatchesCol[l], *mDuplicatedCol[l]);
+    stileEfficiencyGraph(mEffColGood[l], Form("mEffColGood_L%d", l), Form("L%d;Col;Efficiency", l), false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
+
+    for (int ibin = 1; ibin <= mNFakeMatchesCol[l]->GetNbinsX(); ibin++) {
+      if (mNFakeMatchesCol[l]->GetBinContent(ibin) > mDuplicatedCol[l]->GetBinContent(ibin)) {
+        std::cout << "--- Col: Npass = " << mNFakeMatchesCol[l]->GetBinContent(ibin) << ",  Nall = " << mDuplicatedCol[l]->GetBinContent(ibin) << " for ibin = " << ibin << std::endl;
+        mNFakeMatchesCol[l]->SetBinContent(ibin, mDuplicatedCol[l]->GetBinContent(ibin));
+      }
+    }
+    mEffColFake[l] = std::make_unique<TEfficiency>(*mNFakeMatchesCol[l], *mDuplicatedCol[l]);
+    stileEfficiencyGraph(mEffColFake[l], Form("mEffColFake_L%d", l), Form("L%d;Col;Efficiency", l), false, kFullDiamond, 1, kRed + 1, kRed + 1);
+
+    axCol->SetTitle(Form("L%d;Col;Efficiency", l));
+    axCol->GetYaxis()->SetRangeUser(-0.1, 1.1);
+    axCol->GetXaxis()->SetRangeUser(0, 1024);
+    axCol->Draw();
+    mEffColGood[l]->Draw("same p");
+    mEffColFake[l]->Draw("same p");
+
+    auto legCol = std::make_unique<TLegend>(0.70, 0.15, 0.89, 0.35);
+    legCol->AddEntry(mEffColGood[l].get(), "#frac{# good matches}{# tot duplicated clusters}", "pl");
+    legCol->AddEntry(mEffColFake[l].get(), "#frac{# fake matches}{# tot duplicated clusters}", "pl");
+    legCol->Draw("same");
+    effCol[l]->Write();
+
+    // Z
+    effZ[l] = std::make_unique<TCanvas>(Form("effZ_L%d", l));
+
+    for (int ibin = 1; ibin <= mNGoodMatchesZ[l]->GetNbinsX(); ibin++) {
+      std::cout << "--- Good Z: Npass = " << mNGoodMatchesZ[l]->GetBinContent(ibin) << ",  Nall = " << mDuplicatedZ[l]->GetBinContent(ibin) << " for ibin = " << ibin << std::endl;
+    }
+
+    mEffZGood[l] = std::make_unique<TEfficiency>(*mNGoodMatchesZ[l], *mDuplicatedZ[l]);
+    stileEfficiencyGraph(mEffZGood[l], Form("mEffZGood_L%d", l), Form("L%d;Z;Efficiency", l), false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
+
+    for (int ibin = 1; ibin <= mNFakeMatchesZ[l]->GetNbinsX(); ibin++) {
+      if (mNFakeMatchesZ[l]->GetBinContent(ibin) > mDuplicatedZ[l]->GetBinContent(ibin)) {
+        std::cout << "--- Z: Npass = " << mNFakeMatchesZ[l]->GetBinContent(ibin) << ",  Nall = " << mDuplicatedZ[l]->GetBinContent(ibin) << " for ibin = " << ibin << std::endl;
+        mNFakeMatchesZ[l]->SetBinContent(ibin, mDuplicatedZ[l]->GetBinContent(ibin));
+      }
+    }
+    mEffZFake[l] = std::make_unique<TEfficiency>(*mNFakeMatchesZ[l], *mDuplicatedZ[l]);
+    stileEfficiencyGraph(mEffZFake[l], Form("mEffZFake_L%d", l), Form("L%d;Z;Efficiency", l), false, kFullDiamond, 1, kRed + 1, kRed + 1);
+
+    axZ->SetTitle(Form("L%d;Z;Efficiency", l));
+    axZ->GetYaxis()->SetRangeUser(-0.1, 1.1);
+    axZ->GetXaxis()->SetRangeUser(0, 512);
+    axZ->Draw();
+    mEffZGood[l]->Draw("same p");
+    mEffZFake[l]->Draw("same p");
+
+    auto legZ = std::make_unique<TLegend>(0.70, 0.15, 0.89, 0.35);
+    legZ->AddEntry(mEffZGood[l].get(), "#frac{# good matches}{# tot duplicated clusters}", "pl");
+    legZ->AddEntry(mEffZFake[l].get(), "#frac{# fake matches}{# tot duplicated clusters}", "pl");
+    legZ->Draw("same");
+    effZ[l]->Write();
+
     // PtEtaGood
-    effPtEta[l][0] = new TCanvas(Form("effPtEtaGood_L%d", l));
+    effPtEta[l][0] = std::make_unique<TCanvas>(Form("effPtEtaGood_L%d", l));
 
     mEffPtEtaGood[l] = std::make_unique<TEfficiency>(*mNGoodMatchesPtEta[l], *mDuplicatedPtEta[l]);
     stileEfficiencyGraph(mEffPtEtaGood[l], Form("mEffPtEtaGood_L%d", l), Form("L%d;#it{p}_{T} (GeV/#it{c});#eta;Efficiency", l), true);
@@ -1710,7 +1767,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
     }
 
     // PtEtaFake
-    effPtEta[l][1] = new TCanvas(Form("effPtEtaFake_L%d", l));
+    effPtEta[l][1] = std::make_unique<TCanvas>(Form("effPtEtaFake_L%d", l));
 
     mEffPtEtaFake[l] = std::make_unique<TEfficiency>(*mNFakeMatchesPtEta[l], *mDuplicatedPtEta[l]);
     stileEfficiencyGraph(mEffPtEtaFake[l], Form("mEffPtEtaFake_L%d", l), Form("L%d;#it{p}_{T} (GeV/#it{c});#eta;Efficiency", l), true);
@@ -1724,14 +1781,14 @@ void EfficiencyStudy::studyClusterSelectionMC()
     effPtEta[l][1]->Write();
 
     // PtPhiGood
-    effPtPhi[l][0] = new TCanvas(Form("effPtPhiGood_L%d", l));
+    effPtPhi[l][0] = std::make_unique<TCanvas>(Form("effPtPhiGood_L%d", l));
 
     mEffPtPhiGood[l] = std::make_unique<TEfficiency>(*mNGoodMatchesPtPhi[l], *mDuplicatedPtPhi[l]);
-    stileEfficiencyGraph(mEffPtPhiGood[l], Form("mEffPtPhiGood_L%d", l), Form("L%d;#it{p}_{T} (GeV/#it{c});#phi (deg);Efficiency", l), true);
+    stileEfficiencyGraph(mEffPtPhiGood[l], Form("mEffPtPhiGood_L%d", l), Form("L%d;#it{p}_{T} (GeV/#it{c});#phi (rad);Efficiency", l), true);
 
-    axptphiGood->SetTitle(Form("L%d;#it{p}_{T} (GeV/#it{c});#phi (deg);Efficiency", l));
+    axptphiGood->SetTitle(Form("L%d;#it{p}_{T} (GeV/#it{c});#phi (rad);Efficiency", l));
     axptphiGood->GetZaxis()->SetRangeUser(-0.1, 1.1);
-    axptphiGood->GetYaxis()->SetRangeUser(-180, 180);
+    axptphiGood->GetYaxis()->SetRangeUser(-3.2, 3.2);
     axptphiGood->GetXaxis()->SetRangeUser(0.05, 7.5);
     axptphiGood->Draw();
     mEffPtPhiGood[l]->Draw("same colz");
@@ -1750,13 +1807,13 @@ void EfficiencyStudy::studyClusterSelectionMC()
     }
 
     // PtPhiFake
-    effPtPhi[l][1] = new TCanvas(Form("effPtPhiFake_L%d", l));
+    effPtPhi[l][1] = std::make_unique<TCanvas>(Form("effPtPhiFake_L%d", l));
 
     mEffPtPhiFake[l] = std::make_unique<TEfficiency>(*mNFakeMatchesPtPhi[l], *mDuplicatedPtPhi[l]);
-    stileEfficiencyGraph(mEffPtPhiFake[l], Form("mEffPtPhiFake_L%d", l), Form("L%d;#it{p}_{T} (GeV/#it{c});#phi (deg);Efficiency", l), true);
-    axptphiFake->SetTitle(Form("L%d;#it{p}_{T} (GeV/#it{c});#phi (deg);Efficiency", l));
+    stileEfficiencyGraph(mEffPtPhiFake[l], Form("mEffPtPhiFake_L%d", l), Form("L%d;#it{p}_{T} (GeV/#it{c});#phi (rad);Efficiency", l), true);
+    axptphiFake->SetTitle(Form("L%d;#it{p}_{T} (GeV/#it{c});#phi (rad);Efficiency", l));
     axptphiFake->GetZaxis()->SetRangeUser(-0.1, 1.1);
-    axptphiFake->GetYaxis()->SetRangeUser(-180, 180);
+    axptphiFake->GetYaxis()->SetRangeUser(-3.2, 3.2);
     axptphiFake->GetXaxis()->SetRangeUser(0.05, 7.5);
     axptphiFake->Draw();
     mEffPtPhiFake[l]->Draw("same colz");
@@ -1764,14 +1821,14 @@ void EfficiencyStudy::studyClusterSelectionMC()
     effPtPhi[l][1]->Write();
 
     // EtaPhiGood
-    effEtaPhi[l][0] = new TCanvas(Form("effEtaPhiGood_L%d", l));
+    effEtaPhi[l][0] = std::make_unique<TCanvas>(Form("effEtaPhiGood_L%d", l));
 
     mEffEtaPhiGood[l] = std::make_unique<TEfficiency>(*mNGoodMatchesEtaPhi[l], *mDuplicatedEtaPhi[l]);
-    stileEfficiencyGraph(mEffEtaPhiGood[l], Form("mEffEtaPhiGood_L%d", l), Form("L%d;#eta;#phi (deg);Efficiency", l), true);
+    stileEfficiencyGraph(mEffEtaPhiGood[l], Form("mEffEtaPhiGood_L%d", l), Form("L%d;#eta;#phi (rad);Efficiency", l), true);
 
-    axetaphiGood->SetTitle(Form("L%d;#eta;#phi (deg);Efficiency", l));
+    axetaphiGood->SetTitle(Form("L%d;#eta;#phi (rad);Efficiency", l));
     axetaphiGood->GetZaxis()->SetRangeUser(-0.1, 1.1);
-    axetaphiGood->GetYaxis()->SetRangeUser(-180, 180);
+    axetaphiGood->GetYaxis()->SetRangeUser(-3.2, 3.2);
     axetaphiGood->GetXaxis()->SetRangeUser(-2, 2);
     axetaphiGood->Draw();
     mEffEtaPhiGood[l]->Draw("same colz");
@@ -1790,13 +1847,13 @@ void EfficiencyStudy::studyClusterSelectionMC()
     }
 
     // EtaPhiFake
-    effEtaPhi[l][1] = new TCanvas(Form("effEtaPhiFake_L%d", l));
+    effEtaPhi[l][1] = std::make_unique<TCanvas>(Form("effEtaPhiFake_L%d", l));
 
     mEffEtaPhiFake[l] = std::make_unique<TEfficiency>(*mNFakeMatchesEtaPhi[l], *mDuplicatedEtaPhi[l]);
-    stileEfficiencyGraph(mEffEtaPhiFake[l], Form("mEffEtaPhiFake_L%d", l), Form("L%d;#eta;#phi (deg);Efficiency", l), true);
-    axetaphiFake->SetTitle(Form("L%d;#eta;#phi (deg);Efficiency", l));
+    stileEfficiencyGraph(mEffEtaPhiFake[l], Form("mEffEtaPhiFake_L%d", l), Form("L%d;#eta;#phi (rad);Efficiency", l), true);
+    axetaphiFake->SetTitle(Form("L%d;#eta;#phi (rad);Efficiency", l));
     axetaphiFake->GetZaxis()->SetRangeUser(-0.1, 1.1);
-    axetaphiFake->GetYaxis()->SetRangeUser(-180, 180);
+    axetaphiFake->GetYaxis()->SetRangeUser(-3.2, 3.2);
     axetaphiFake->GetXaxis()->SetRangeUser(-2, 2);
     axetaphiFake->Draw();
     mEffEtaPhiFake[l]->Draw("same colz");
@@ -1808,7 +1865,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
       std::cout << "Eta L" << l << "\n\n";
     }
 
-    effEtaAllPt[l] = new TCanvas(Form("effEtaAllPt_L%d", l));
+    effEtaAllPt[l] = std::make_unique<TCanvas>(Form("effEtaAllPt_L%d", l));
 
     mEffEtaGoodAllPt[l] = std::make_unique<TEfficiency>(*mNGoodMatchesEtaAllPt[l], *mDuplicatedEtaAllPt[l]);
     stileEfficiencyGraph(mEffEtaGoodAllPt[l], Form("mEffEtaGoodAllPt_L%d", l), Form("L%d;#eta;Efficiency", l), false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
@@ -1840,7 +1897,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
     /// eta and phi in different pt ranges
     for (int ipt = 0; ipt < 3; ipt++) {
       // eta
-      effEta[l][ipt] = new TCanvas(Form("effEta_L%d_pt%d", l, ipt));
+      effEta[l][ipt] = std::make_unique<TCanvas>(Form("effEta_L%d_pt%d", l, ipt));
 
       mEffEtaGood[l][ipt] = std::make_unique<TEfficiency>(*mNGoodMatchesEta[l][ipt], *mDuplicatedEta[l][ipt]);
       stileEfficiencyGraph(mEffEtaGood[l][ipt], Form("mEffEtaGood_L%d_pt%d", l, ipt), Form("L%d     %.1f #leq #it{p}_{T} < %.1f GeV/#it{c};#eta;Efficiency", l, mrangesPt[ipt][0], mrangesPt[ipt][1]), false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
@@ -1871,7 +1928,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
       effEta[l][ipt]->Write();
 
       // phi
-      effPhi[l][ipt] = new TCanvas(Form("effPhi_L%d_pt%d", l, ipt));
+      effPhi[l][ipt] = std::make_unique<TCanvas>(Form("effPhi_L%d_pt%d", l, ipt));
 
       for (int ibin = 1; ibin <= mNGoodMatchesPhi[l][ipt]->GetNbinsX(); ibin++) {
         if (mNGoodMatchesPhi[l][ipt]->GetBinContent(ibin) > mDuplicatedPhi[l][ipt]->GetBinContent(ibin)) {
@@ -1883,7 +1940,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
       }
 
       mEffPhiGood[l][ipt] = std::make_unique<TEfficiency>(*mNGoodMatchesPhi[l][ipt], *mDuplicatedPhi[l][ipt]);
-      stileEfficiencyGraph(mEffPhiGood[l][ipt], Form("mEffPhiGood_L%d_pt%d", l, ipt), Form("L%d     %.1f #leq #it{p}_{T} < %.1f GeV/#it{c};#phi (deg);Efficiency", l, mrangesPt[ipt][0], mrangesPt[ipt][1]), false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
+      stileEfficiencyGraph(mEffPhiGood[l][ipt], Form("mEffPhiGood_L%d_pt%d", l, ipt), Form("L%d     %.1f #leq #it{p}_{T} < %.1f GeV/#it{c};#phi (rad);Efficiency", l, mrangesPt[ipt][0], mrangesPt[ipt][1]), false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
 
       for (int ibin = 1; ibin <= mNFakeMatchesPhi[l][ipt]->GetNbinsX(); ibin++) {
         if (mNFakeMatchesPhi[l][ipt]->GetBinContent(ibin) > mDuplicatedPhi[l][ipt]->GetBinContent(ibin)) {
@@ -1895,9 +1952,9 @@ void EfficiencyStudy::studyClusterSelectionMC()
       }
 
       mEffPhiFake[l][ipt] = std::make_unique<TEfficiency>(*mNFakeMatchesPhi[l][ipt], *mDuplicatedPhi[l][ipt]);
-      stileEfficiencyGraph(mEffPhiFake[l][ipt], Form("mEffPhiFake_L%d_pt%d", l, ipt), Form("L%d    %.1f #leq #it{p}_{T} < %.1f GeV/#it{c};#phi (deg);Efficiency", l, mrangesPt[ipt][0], mrangesPt[ipt][1]), false, kFullDiamond, 1, kRed + 1, kRed + 1);
+      stileEfficiencyGraph(mEffPhiFake[l][ipt], Form("mEffPhiFake_L%d_pt%d", l, ipt), Form("L%d    %.1f #leq #it{p}_{T} < %.1f GeV/#it{c};#phi (rad);Efficiency", l, mrangesPt[ipt][0], mrangesPt[ipt][1]), false, kFullDiamond, 1, kRed + 1, kRed + 1);
 
-      axphi[ipt]->SetTitle(Form("L%d     %.1f #leq #it{p}_{T} < %.1f GeV/#it{c};#phi (deg);Efficiency", l, mrangesPt[ipt][0], mrangesPt[ipt][1]));
+      axphi[ipt]->SetTitle(Form("L%d     %.1f #leq #it{p}_{T} < %.1f GeV/#it{c};#phi (rad);Efficiency", l, mrangesPt[ipt][0], mrangesPt[ipt][1]));
       axphi[ipt]->GetYaxis()->SetRangeUser(-0.1, 1.1);
 
       axphi[ipt]->Draw();
@@ -1916,7 +1973,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
       std::cout << "Phi L" << l << "\n\n";
     }
 
-    effPhiAllPt[l] = new TCanvas(Form("effPhiAllPt_L%d", l));
+    effPhiAllPt[l] = std::make_unique<TCanvas>(Form("effPhiAllPt_L%d", l));
 
     for (int ibin = 1; ibin <= mNGoodMatchesPhiAllPt[l]->GetNbinsX(); ibin++) {
       if (mNGoodMatchesPhiAllPt[l]->GetBinContent(ibin) > mDuplicatedPhiAllPt[l]->GetBinContent(ibin)) {
@@ -1953,85 +2010,170 @@ void EfficiencyStudy::studyClusterSelectionMC()
     legPhi->Draw("same");
     effPhiAllPt[l]->Write();
   }
-}
-
-void EfficiencyStudy::saveDataInfo()
-{
-  // save histograms for data (phi, eta, pt,...)
-  LOGP(info, "--------------- saveDataInfo");
-
-  unsigned int rofIndexTrack = 0;
-  unsigned int rofNEntriesTrack = 0;
-  unsigned int rofIndexClus = 0;
-  unsigned int rofNEntriesClus = 0;
-  unsigned int totClus = 0;
-
-  for (unsigned int iROF = 0; iROF < mTracksROFRecords.size(); iROF++) { // loop on ROFRecords array
-    rofIndexTrack = mTracksROFRecords[iROF].getFirstEntry();
-    rofNEntriesTrack = mTracksROFRecords[iROF].getNEntries();
-
-    rofIndexClus = mClustersROFRecords[iROF].getFirstEntry();
-    rofNEntriesClus = mClustersROFRecords[iROF].getNEntries();
-
-    for (unsigned int iTrack = rofIndexTrack; iTrack < rofIndexTrack + rofNEntriesTrack; iTrack++) { // loop on tracks per ROF
-      auto track = mTracks[iTrack];
-      o2::track::TrackParCov trackParCov = mTracks[iTrack];
-      int firstClus = track.getFirstClusterEntry(); // get the first cluster of the track
-      int ncl = track.getNumberOfClusters();        // get the number of clusters of the track
-
-      if (ncl < 7) {
-        continue;
-      }
-      float ip[2];
-      track.getImpactParams(0, 0, 0, 0, ip);
-
-      auto pt = trackParCov.getPt();
-      auto eta = trackParCov.getEta();
-
-      float phiTrack = trackParCov.getPhi() * 180 / M_PI;
-
-      // if (pt < mPtCuts[0] || pt > mPtCuts[1]) continue;
-      // if (eta < mEtaCuts[0] || eta > mEtaCuts[1]) continue;
 
-      float phioriginal = 0;
-      float phiduplicated = 0;
-
-      for (int iclTrack = firstClus; iclTrack < firstClus + ncl; iclTrack++) { // loop on clusters associated to the track
-        auto& clusOriginal = mClusters[mInputITSidxs[iclTrack]];
-        auto clusOriginalPoint = mITSClustersArray[mInputITSidxs[iclTrack]]; // cluster spacepoint in the tracking system
-        auto staveOriginal = mGeometry->getStave(clusOriginal.getSensorID());
-        auto chipOriginal = mGeometry->getChipIdInStave(clusOriginal.getSensorID());
-
-        auto layer = mGeometry->getLayer(clusOriginal.getSensorID());
-        if (layer >= NLAYERS) {
-          continue; // checking only selected layers
-        }
-
-        o2::math_utils::Point3D<float> clusOriginalPointTrack = {clusOriginalPoint.getX(), clusOriginalPoint.getY(), clusOriginalPoint.getZ()};
-        o2::math_utils::Point3D<float> clusOriginalPointGlob = mGeometry->getMatrixT2G(clusOriginal.getSensorID()) * clusOriginalPointTrack;
-
-        phioriginal = clusOriginalPointGlob.phi() * 180 / M_PI;
-
-        mPhiOriginal[layer]->Fill(phioriginal);
-        mPhiTrackOriginal[layer]->Fill(phiTrack);
-        mPtOriginal[layer]->Fill(pt);
-        mEtaOriginal[layer]->Fill(eta);
-        m3DClusterPositions->Fill(clusOriginalPointGlob.x(), clusOriginalPointGlob.y(), clusOriginalPointGlob.z());
-        m2DClusterOriginalPositions->Fill(clusOriginalPointGlob.x(), clusOriginalPointGlob.y());
-      } // end loop on clusters
-      totClus += ncl;
-    } // end loop on tracks per ROF
-  } // end loop on ROFRecords array
-  LOGP(info, "Total number of clusters: {} ", totClus);
+  /// all Row
+  std::unique_ptr<TCanvas> effRowAll = std::make_unique<TCanvas>("effRowAll");
+  auto numRowGoodAll = std::unique_ptr<TH1D>((TH1D*)mNGoodMatchesRow[0]->Clone("numRowGoodAll"));
+  numRowGoodAll->Add(mNGoodMatchesRow[1].get());
+  numRowGoodAll->Add(mNGoodMatchesRow[2].get());
+  numRowGoodAll->Write();
+  auto numRowFakeAll = std::unique_ptr<TH1D>((TH1D*)mNFakeMatchesRow[0]->Clone("numRowFakeAll"));
+  numRowFakeAll->Add(mNFakeMatchesRow[1].get());
+  numRowFakeAll->Add(mNFakeMatchesRow[2].get());
+  numRowFakeAll->Write();
+  auto denRowAll = std::unique_ptr<TH1D>((TH1D*)mDuplicatedRow[0]->Clone("denRowAll"));
+  denRowAll->Add(mDuplicatedRow[1].get());
+  denRowAll->Add(mDuplicatedRow[2].get());
+  denRowAll->Write();
+
+  std::unique_ptr<TEfficiency> mEffRowGoodAll = std::make_unique<TEfficiency>(*numRowGoodAll, *denRowAll);
+  stileEfficiencyGraph(mEffRowGoodAll, "mEffRowGoodAll", "L0 + L1 + L2;Row;Efficiency", false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
+  std::unique_ptr<TEfficiency> mEffRowFakeAll = std::make_unique<TEfficiency>(*numRowFakeAll, *denRowAll);
+  stileEfficiencyGraph(mEffRowFakeAll, "mEffRowFakeAll", "L0 + L1 + L2;Row;Efficiency", false, kFullDiamond, 1, kRed + 1, kRed + 1);
+  axRow->SetTitle("L0 + L1 + L2;Row;Efficiency");
+  axRow->GetYaxis()->SetRangeUser(-0.1, 1.1);
+  axRow->Draw();
+  mEffRowGoodAll->Draw("same p");
+  mEffRowFakeAll->Draw("same p");
+
+  auto legRow = std::make_unique<TLegend>(0.70, 0.15, 0.89, 0.35);
+  legRow->AddEntry(mEffRowGoodAll.get(), "#frac{# good matches}{# tot duplicated clusters}", "pl");
+  legRow->AddEntry(mEffRowFakeAll.get(), "#frac{# fake matches}{# tot duplicated clusters}", "pl");
+  legRow->Draw("same");
+  effRowAll->Write();
+
+  /// all Col
+  std::unique_ptr<TCanvas> effColAll = std::make_unique<TCanvas>("effColAll");
+  auto numColGoodAll = std::unique_ptr<TH1D>((TH1D*)mNGoodMatchesCol[0]->Clone("numColGoodAll"));
+  numColGoodAll->Add(mNGoodMatchesCol[1].get());
+  numColGoodAll->Add(mNGoodMatchesCol[2].get());
+  numColGoodAll->Write();
+  auto numColFakeAll = std::unique_ptr<TH1D>((TH1D*)mNFakeMatchesCol[0]->Clone("numColFakeAll"));
+  numColFakeAll->Add(mNFakeMatchesCol[1].get());
+  numColFakeAll->Add(mNFakeMatchesCol[2].get());
+  numColFakeAll->Write();
+  auto denColAll = std::unique_ptr<TH1D>((TH1D*)mDuplicatedCol[0]->Clone("denColAll"));
+  denColAll->Add(mDuplicatedCol[1].get());
+  denColAll->Add(mDuplicatedCol[2].get());
+  denColAll->Write();
+
+  std::unique_ptr<TEfficiency> mEffColGoodAll = std::make_unique<TEfficiency>(*numColGoodAll, *denColAll);
+  stileEfficiencyGraph(mEffColGoodAll, "mEffColGoodAll", "L0 + L1 + L2;Column;Efficiency", false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
+  std::unique_ptr<TEfficiency> mEffColFakeAll = std::make_unique<TEfficiency>(*numColFakeAll, *denColAll);
+  stileEfficiencyGraph(mEffColFakeAll, "mEffColFakeAll", "L0 + L1 + L2;Column;Efficiency", false, kFullDiamond, 1, kRed + 1, kRed + 1);
+  axCol->SetTitle("L0 + L1 + L2;Col;Efficiency");
+  axCol->GetYaxis()->SetRangeUser(-0.1, 1.1);
+  axCol->Draw();
+  mEffColGoodAll->Draw("same p");
+  mEffColFakeAll->Draw("same p");
+
+  auto legCol = std::make_unique<TLegend>(0.70, 0.15, 0.89, 0.35);
+  legCol->AddEntry(mEffColGoodAll.get(), "#frac{# good matches}{# tot duplicated clusters}", "pl");
+  legCol->AddEntry(mEffColFakeAll.get(), "#frac{# fake matches}{# tot duplicated clusters}", "pl");
+  legCol->Draw("same");
+  effColAll->Write();
+
+  /// all Z
+  std::unique_ptr<TCanvas> effZAll = std::make_unique<TCanvas>("effZAll");
+  auto numZGoodAll = std::unique_ptr<TH1D>((TH1D*)mNGoodMatchesZ[0]->Clone("numZGoodAll"));
+  numZGoodAll->Add(mNGoodMatchesZ[1].get());
+  numZGoodAll->Add(mNGoodMatchesZ[2].get());
+  numZGoodAll->Write();
+  auto numZFakeAll = std::unique_ptr<TH1D>((TH1D*)mNFakeMatchesZ[0]->Clone("numZFakeAll"));
+  numZFakeAll->Add(mNFakeMatchesZ[1].get());
+  numZFakeAll->Add(mNFakeMatchesZ[2].get());
+  numZFakeAll->Write();
+  auto denZAll = std::unique_ptr<TH1D>((TH1D*)mDuplicatedZ[0]->Clone("denZAll"));
+  denZAll->Add(mDuplicatedZ[1].get());
+  denZAll->Add(mDuplicatedZ[2].get());
+  denZAll->Write();
+
+  std::unique_ptr<TEfficiency> mEffZGoodAll = std::make_unique<TEfficiency>(*numZGoodAll, *denZAll);
+  stileEfficiencyGraph(mEffZGoodAll, "mEffZGoodAll", "L0 + L1 + L2;Z;Efficiency", false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
+  std::unique_ptr<TEfficiency> mEffZFakeAll = std::make_unique<TEfficiency>(*numZFakeAll, *denZAll);
+  stileEfficiencyGraph(mEffZFakeAll, "mEffZFakeAll", "L0 + L1 + L2;Z;Efficiency", false, kFullDiamond, 1, kRed + 1, kRed + 1);
+  axZ->SetTitle("L0 + L1 + L2;Z;Efficiency");
+  axZ->GetYaxis()->SetRangeUser(-0.1, 1.1);
+  axZ->Draw();
+  mEffZGoodAll->Draw("same p");
+  mEffZFakeAll->Draw("same p");
+
+  auto legZ = std::make_unique<TLegend>(0.70, 0.15, 0.89, 0.35);
+  legZ->AddEntry(mEffZGoodAll.get(), "#frac{# good matches}{# tot duplicated clusters}", "pl");
+  legZ->AddEntry(mEffZFakeAll.get(), "#frac{# fake matches}{# tot duplicated clusters}", "pl");
+  legZ->Draw("same");
+  effZAll->Write();
+
+  /// all Eta
+  std::unique_ptr<TCanvas> effEtaAll = std::make_unique<TCanvas>("effEtaAll");
+  auto numEtaGoodAll = std::unique_ptr<TH1D>((TH1D*)mNGoodMatchesEtaAllPt[0]->Clone("numEtaGoodAll"));
+  numEtaGoodAll->Add(mNGoodMatchesEtaAllPt[1].get());
+  numEtaGoodAll->Add(mNGoodMatchesEtaAllPt[2].get());
+  numEtaGoodAll->Write();
+  auto numEtaFakeAll = std::unique_ptr<TH1D>((TH1D*)mNFakeMatchesEtaAllPt[0]->Clone("numEtaFakeAll"));
+  numEtaFakeAll->Add(mNFakeMatchesEtaAllPt[1].get());
+  numEtaFakeAll->Add(mNFakeMatchesEtaAllPt[2].get());
+  numEtaFakeAll->Write();
+  auto denEtaAll = std::unique_ptr<TH1D>((TH1D*)mDuplicatedEtaAllPt[0]->Clone("denEtaAll"));
+  denEtaAll->Add(mDuplicatedEtaAllPt[1].get());
+  denEtaAll->Add(mDuplicatedEtaAllPt[2].get());
+  denEtaAll->Write();
+
+  std::unique_ptr<TEfficiency> mEffEtaGoodAll = std::make_unique<TEfficiency>(*numEtaGoodAll, *denEtaAll);
+  stileEfficiencyGraph(mEffEtaGoodAll, "mEffEtaGoodAll", "L0 + L1 + L2;#Eta;Efficiency", false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
+  std::unique_ptr<TEfficiency> mEffEtaFakeAll = std::make_unique<TEfficiency>(*numEtaFakeAll, *denEtaAll);
+  stileEfficiencyGraph(mEffEtaFakeAll, "mEffEtaFakeAll", "L0 + L1 + L2;#Eta;Efficiency", false, kFullDiamond, 1, kRed + 1, kRed + 1);
+  axetaAllPt->SetTitle("L0 + L1 + L2;Eta;Efficiency");
+  axetaAllPt->GetYaxis()->SetRangeUser(-0.1, 1.1);
+  axetaAllPt->Draw();
+  mEffEtaGoodAll->Draw("same p");
+  mEffEtaFakeAll->Draw("same p");
+
+  auto legEta = std::make_unique<TLegend>(0.70, 0.15, 0.89, 0.35);
+  legEta->AddEntry(mEffEtaGoodAll.get(), "#frac{# good matches}{# tot duplicated clusters}", "pl");
+  legEta->AddEntry(mEffEtaFakeAll.get(), "#frac{# fake matches}{# tot duplicated clusters}", "pl");
+  legEta->Draw("same");
+  effEtaAll->Write();
+
+  /// all Phi
+  std::unique_ptr<TCanvas> effPhiAll = std::make_unique<TCanvas>("effPhiAll");
+  auto numPhiGoodAll = std::unique_ptr<TH1D>((TH1D*)mNGoodMatchesPhiAllPt[0]->Clone("numPhiGoodAll"));
+  numPhiGoodAll->Add(mNGoodMatchesPhiAllPt[1].get());
+  numPhiGoodAll->Add(mNGoodMatchesPhiAllPt[2].get());
+  numPhiGoodAll->Write();
+  auto numPhiFakeAll = std::unique_ptr<TH1D>((TH1D*)mNFakeMatchesPhiAllPt[0]->Clone("numPhiFakeAll"));
+  numPhiFakeAll->Add(mNFakeMatchesPhiAllPt[1].get());
+  numPhiFakeAll->Add(mNFakeMatchesPhiAllPt[2].get());
+  numPhiFakeAll->Write();
+  auto denPhiAll = std::unique_ptr<TH1D>((TH1D*)mDuplicatedPhiAllPt[0]->Clone("denPhiAll"));
+  denPhiAll->Add(mDuplicatedPhiAllPt[1].get());
+  denPhiAll->Add(mDuplicatedPhiAllPt[2].get());
+  denPhiAll->Write();
+
+  std::unique_ptr<TEfficiency> mEffPhiGoodAll = std::make_unique<TEfficiency>(*numPhiGoodAll, *denPhiAll);
+  stileEfficiencyGraph(mEffPhiGoodAll, "mEffPhiGoodAll", "L0 + L1 + L2;#Phi (rad);Efficiency", false, kFullDiamond, 1, kGreen + 3, kGreen + 3);
+  std::unique_ptr<TEfficiency> mEffPhiFakeAll = std::make_unique<TEfficiency>(*numPhiFakeAll, *denPhiAll);
+  stileEfficiencyGraph(mEffPhiFakeAll, "mEffPhiFakeAll", "L0 + L1 + L2;#Phi (rad);Efficiency", false, kFullDiamond, 1, kRed + 1, kRed + 1);
+  axphiAllPt->SetTitle("L0 + L1 + L2;Phi;Efficiency");
+  axphiAllPt->GetYaxis()->SetRangeUser(-0.1, 1.1);
+  axphiAllPt->Draw();
+  mEffPhiGoodAll->Draw("same p");
+  mEffPhiFakeAll->Draw("same p");
+
+  auto legPhi = std::make_unique<TLegend>(0.70, 0.15, 0.89, 0.35);
+  legPhi->AddEntry(mEffPhiGoodAll.get(), "#frac{# good matches}{# tot duplicated clusters}", "pl");
+  legPhi->AddEntry(mEffPhiFakeAll.get(), "#frac{# fake matches}{# tot duplicated clusters}", "pl");
+  legPhi->Draw("same");
+  effPhiAll->Write();
 }
 
 void EfficiencyStudy::getEfficiency(bool isMC)
 {
   // Extract the efficiency for the IB, exploiting the staves overlaps and the duplicated clusters for the tracks passing through the overlaps
-  // The denominator for the efficiency calculation will be the number of tracks per layer fulfilling some cuts (DCA, phi, eta, pt)
+  // The denominator for the efficiency calculation will be the number of tracks per layer fulfilling some cuts (eta, z, row, col)
   // The numerator will be the number of duplicated clusters for the tracks passing through the overlaps
 
-  LOGP(info, "--------------- getEfficiency");
+  LOGP(info, "getEfficiency()");
 
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
   o2::gpu::gpustd::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
@@ -2041,8 +2183,6 @@ void EfficiencyStudy::getEfficiency(bool isMC)
   unsigned int rofNEntriesTrack = 0;
   unsigned int rofIndexClus = 0;
   unsigned int rofNEntriesClus = 0;
-  int nLabels = 0;
-  unsigned int totClus = 0;
 
   int nbPt = 75;
   double xbins[nbPt + 1], ptcutl = 0.05, ptcuth = 7.5;
@@ -2054,7 +2194,6 @@ void EfficiencyStudy::getEfficiency(bool isMC)
   int totNClusters;
   int nDuplClusters;
 
-  // denominator fot the efficiency calculation
   for (unsigned int iROF = 0; iROF < mTracksROFRecords.size(); iROF++) { // loop on ROFRecords array
 
     rofIndexTrack = mTracksROFRecords[iROF].getFirstEntry();
@@ -2068,7 +2207,7 @@ void EfficiencyStudy::getEfficiency(bool isMC)
       auto track = mTracks[iTrack];
       o2::track::TrackParCov trackParCov = mTracks[iTrack];
 
-      auto pt = trackParCov.getPt();
+      auto pt = trackParCov.getPt(); // Always 0.6 GeV/c for B = 0 T
       auto eta = trackParCov.getEta();
       float phi = -999.;
       float phiOriginal = -999.;
@@ -2078,24 +2217,17 @@ void EfficiencyStudy::getEfficiency(bool isMC)
       float ip[2];
       track.getImpactParams(0, 0, 0, 0, ip);
 
-      float phiTrack = trackParCov.getPhi() * 180 / M_PI;
+      // float phiTrack = trackParCov.getPhi(); // * 180 / M_PI;
 
-      // applying the cuts on the track - only pt and eta, and chi2 cuts since for phi(cluster) the layer is needed
-      if (pt < mPtCuts[0] || pt > mPtCuts[1]) {
-        continue;
-      }
-      if (eta < mEtaCuts[0] || eta > mEtaCuts[1]) {
+      // applying the cuts on the track - only eta
+      if (eta < mEtaCuts[0] || eta >= mEtaCuts[1]) {
         continue;
       }
-      if (chi2 > mChi2cut) {
-        continue;
-      }
-
-      /// the cut on phi, since it is layer-dependent, can be applied only after finding the cluster and then the layer
 
       int firstClus = track.getFirstClusterEntry(); // get the first cluster of the track
       int ncl = track.getNumberOfClusters();        // get the number of clusters of the track
 
+      //// keeping only 7 clusters track to reduce fakes
       if (ncl < 7) {
         continue;
       }
@@ -2109,7 +2241,7 @@ void EfficiencyStudy::getEfficiency(bool isMC)
       }
 
       if (mVerboseOutput && isMC) {
-        LOGP(info, "--------- track Label: ");
+        LOGP(info, "track Label: ");
         tracklab.print();
       }
 
@@ -2119,358 +2251,73 @@ void EfficiencyStudy::getEfficiency(bool isMC)
         auto layerOriginal = mGeometry->getLayer(clusOriginal.getSensorID());
 
         UShort_t rowOriginal = clusOriginal.getRow();
+        UShort_t colOriginal = clusOriginal.getCol();
 
+        /// filling some chip maps
+        if (clusOriginal.getChipID() >= 0 && clusOriginal.getChipID() <= 8) {
+          l0_00->Fill(clusOriginal.getCol() + (1024 * (clusOriginal.getChipID() % 9)), clusOriginal.getRow());
+        }
+        if (clusOriginal.getChipID() >= 252 && clusOriginal.getChipID() <= 260) {
+          l1_15->Fill(clusOriginal.getCol() + (1024 * (clusOriginal.getChipID() % 9)), clusOriginal.getRow());
+        }
+        if (clusOriginal.getChipID() >= 423 && clusOriginal.getChipID() <= 431) {
+          l2_19->Fill(clusOriginal.getCol() + (1024 * (clusOriginal.getChipID() % 9)), clusOriginal.getRow());
+        }
+
+        //// only IB
         if (layerOriginal >= NLAYERS) {
           continue;
         }
 
+        chipmap->Fill(clusOriginal.getCol(), clusOriginal.getRow());
+
         IPOriginalxy[layerOriginal]->Fill(ip[0]);
         IPOriginalz[layerOriginal]->Fill(ip[1]);
 
+        ///// cluster point and conversion from track local coordinates to global coordinates
         o2::math_utils::Point3D<float> clusOriginalPointTrack = {clusOriginalPoint.getX(), clusOriginalPoint.getY(), clusOriginalPoint.getZ()};
         o2::math_utils::Point3D<float> clusOriginalPointGlob = mGeometry->getMatrixT2G(clusOriginal.getSensorID()) * clusOriginalPointTrack;
-        // phiOriginal = std::(clusOriginalPointGlob.y(), clusOriginalPointGlob.x()) * 180 / M_PI + 180;
-        phiOriginal = clusOriginalPointGlob.phi() * 180 / M_PI;
-
-        mXoriginal->Fill(clusOriginalPointGlob.x());
-        mYoriginal->Fill(clusOriginalPointGlob.y());
-        mZoriginal->Fill(clusOriginalPointGlob.z());
-
-        // std::cout<<" Layer: "<<layerOriginal<<" chipid: "<<clusOriginal.getChipID()<<" x: "<<clusOriginalPointGlob.x()<<" y: "<<clusOriginalPointGlob.y()<<" z: "<<clusOriginalPointGlob.z()<<std::endl;
+        phiOriginal = clusOriginalPointGlob.phi(); // * 180 / M_PI;
 
-        m2DClusterOriginalPositions->Fill(clusOriginalPointGlob.x(), clusOriginalPointGlob.y());
-        m3DClusterPositions->Fill(clusOriginalPointGlob.x(), clusOriginalPointGlob.y(), clusOriginalPointGlob.z());
-
-        /// applying the cuts on the phi of the original cluster
-        bool keepTrack = false; /// wether or not a cluster is found in an eligible track in the corresponding layer
-        if (layerOriginal == 0) {
-
-          for (int i = 0; i < 10; i++) {
-            if ((phiOriginal >= mPhiCutsL0[i][0] && phiOriginal <= mPhiCutsL0[i][1])) {
-              keepTrack = true;
-            }
-          }
-        }
-        if (layerOriginal == 1) {
-          for (int i = 0; i < 12; i++) {
-            if ((phiOriginal >= mPhiCutsL1[i][0] && phiOriginal <= mPhiCutsL1[i][1])) {
-              keepTrack = true;
-            }
-          }
-        }
-        if (layerOriginal == 2) {
-          for (int i = 0; i < 17; i++) {
-            if ((phiOriginal >= mPhiCutsL2[i][0] && phiOriginal <= mPhiCutsL2[i][1])) {
-              keepTrack = true;
-            }
-          }
-        }
-
-        /////////////////////////////////////
-        if (!(keepTrack)) {
-          continue; /// if the track (cluster) is not eligible for any layer, go to the next one
-        } else {    /// fill the den and go ahead
-          chi2trackAccepted->Fill(chi2);
-          denPt[layerOriginal]->Fill(pt);
-          denPhi[layerOriginal]->Fill(phiOriginal);
-          denEta[layerOriginal]->Fill(eta);
-          nTracksSelected[layerOriginal]++;
+        if (abs(clusOriginalPointGlob.y()) < 0.5) { ///// excluding gap between bottom and top barrels
+          continue;
         }
 
-        /// if the cuts up to here are passed, then search for the duplicated cluster, otherwise go to the next cluster
-        gsl::span<const o2::MCCompLabel> labsOriginal = {};
-        if (isMC) {
-          labsOriginal = mClustersMCLCont->getLabels(mInputITSidxs[iclTrack]); // get labels of the cluster associated to the track (original)
+        if (abs(clusOriginalPointGlob.z()) >= 10) { /// excluding external z
+          continue;
         }
 
-        auto staveOriginal = mGeometry->getStave(clusOriginal.getSensorID());
-        auto chipOriginal = mGeometry->getChipIdInStave(clusOriginal.getSensorID());
-
-        std::tuple<int, double, gsl::span<const o2::MCCompLabel>> clusID_rDCA_label = {0, 999., gsl::span<const o2::MCCompLabel>()}; // inizializing tuple with dummy values (if data, ignore the third value)
-
-        bool adjacentFound = 0;
-        float phiDuplicated = -999.;
-        float ptDuplicated = -999.;
-        float etaDuplicated = -999.;
-        float clusZ = -999.;
-        /// for each original cluster iterate over all the possible duplicated clusters to see first wether increment or not the denominator (if a track has a possible duplicated cluster in the selected phi region)
-        /// then if the phi is within the cuts, select the "adjacent" clusters (stave +-1, chip =,+-1) and calculate the DCA with the track. Then choose the closest one.
-        // std::cout<<"Loop on clusters 2"<<std::endl;
-        for (unsigned int iClus = rofIndexClus; iClus < rofIndexClus + rofNEntriesClus; iClus++) { // iteration over ALL the clusters in the ROF
-          auto clusDuplicated = mClusters[iClus];
-
-          auto clusDuplicatedPoint = mITSClustersArray[iClus];
-
-          o2::math_utils::Point3D<float> clusDuplicatedPointTrack = {clusDuplicatedPoint.getX(), clusDuplicatedPoint.getY(), clusDuplicatedPoint.getZ()};
-          o2::math_utils::Point3D<float> clusDuplicatedPointGlob = mGeometry->getMatrixT2G(clusDuplicated.getSensorID()) * clusDuplicatedPointTrack;
-          phi = clusDuplicatedPointGlob.phi() * 180 / M_PI;
-
-          //// applying constraints: the cluster should be on the same layer, should be on an adjacent stave and on the same or adjacent chip position
-          if (clusDuplicated.getSensorID() == clusOriginal.getSensorID()) {
-            continue;
-          }
-          auto layerDuplicated = mGeometry->getLayer(clusDuplicated.getSensorID());
-          if (layerDuplicated != layerOriginal) {
-            continue;
-          }
-          auto staveDuplicated = mGeometry->getStave(clusDuplicated.getSensorID());
-          if (abs(staveDuplicated - staveOriginal) != 1) {
-            continue;
-          }
-          auto chipDuplicated = mGeometry->getChipIdInStave(clusDuplicated.getSensorID());
-          if (abs(chipDuplicated - chipOriginal) > 1) {
-            continue;
-          }
-
-          gsl::span<const o2::MCCompLabel> labsDuplicated = {};
-          if (isMC) {
-            labsDuplicated = mClustersMCLCont->getLabels(iClus);
-          }
-
-          /// if the cheks are passed, then calculate the DCA
-          /// Compute the DCA between the duplicated cluster location and the track
-          trackParCov.rotate(mGeometry->getSensorRefAlpha(clusDuplicated.getSensorID()));
-          if (!propagator->propagateToDCA(clusDuplicatedPointGlob, trackParCov, b, 2.f, matCorr, &clusDuplicatedDCA)) { // check if the propagation fails
-            continue;
-          }
-
-          DCAxyData[layerDuplicated]->Fill(clusDuplicatedDCA[0]);
-          DCAzData[layerDuplicated]->Fill(clusDuplicatedDCA[1]);
-          // std::cout<<"DCA: "<<clusDuplicatedDCA[0]<<"  "<<clusDuplicatedDCA[1]<<"  (should be within ["<<mDCACutsXY[layerDuplicated][0]<<","<<mDCACutsXY[layerDuplicated][1]<<"] and ["<<mDCACutsZ[layerDuplicated][0]<<","<<mDCACutsZ[layerDuplicated][1]<<"])"<<std::endl;
-          // std::cout<<"Point Duplicated (x,y,z): "<<clusDuplicatedPointGlob.x()<<"  "<<clusDuplicatedPointGlob.y()<<"  "<<clusDuplicatedPointGlob.z()<<std::endl;
-          // std::cout<<"Point Original (x,y,z): "<<clusOriginalPointGlob.x()<<"  "<<clusOriginalPointGlob.y()<<"  "<<clusOriginalPointGlob.z()<<std::endl;
-          // std::cout<<"Layer, chipid, stave : "<<layerDuplicated<<"  "<<chipDuplicated<<"  "<<staveDuplicated<<std::endl;
-          // std::cout<<"Track position: "<<trackParCov.getX()<<"  "<<trackParCov.getY()<<"  "<<trackParCov.getZ()<<std::endl;
-          DistanceClustersX[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.x() - clusOriginalPointGlob.x()));
-          DistanceClustersY[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.y() - clusOriginalPointGlob.y()));
-          DistanceClustersZ[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.z() - clusOriginalPointGlob.z()));
-
-          // Imposing that the distance between the duplicated cluster and the track is less than x sigma
-          if (!(clusDuplicatedDCA[0] > mDCACutsXY[layerDuplicated][0] && clusDuplicatedDCA[0] < mDCACutsXY[layerDuplicated][1] && clusDuplicatedDCA[1] > mDCACutsZ[layerDuplicated][0] && clusDuplicatedDCA[1] < mDCACutsZ[layerDuplicated][1])) {
-            DCAxyRejected[layerDuplicated]->Fill(clusDuplicatedDCA[0]);
-            DCAzRejected[layerDuplicated]->Fill(clusDuplicatedDCA[1]);
-            continue;
-          }
-
-          m2DClusterDuplicatedPositions->Fill(clusDuplicatedPointGlob.x(), clusDuplicatedPointGlob.y());
-          m3DDuplicatedClusterPositions->Fill(clusDuplicatedPointGlob.x(), clusDuplicatedPointGlob.y(), clusDuplicatedPointGlob.z());
-
-          mXduplicated->Fill(clusDuplicatedPointGlob.x());
-          mYduplicated->Fill(clusDuplicatedPointGlob.y());
-          mZduplicated->Fill(clusDuplicatedPointGlob.z());
-
-          IPOriginalifDuplicatedxy[layerOriginal]->Fill(ip[0]);
-          IPOriginalifDuplicatedz[layerOriginal]->Fill(ip[1]);
-
-          DistanceClustersXAftercuts[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.x() - clusOriginalPointGlob.x()));
-          DistanceClustersYAftercuts[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.y() - clusOriginalPointGlob.y()));
-          DistanceClustersZAftercuts[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.z() - clusOriginalPointGlob.z()));
-
-          if (mVerboseOutput) {
-            LOGP(info, "Propagation ok");
-          }
-          double rDCA = std::hypot(clusDuplicatedDCA[0], clusDuplicatedDCA[1]);
-
-          // taking the closest cluster within x sigma
-          if (rDCA < std::get<1>(clusID_rDCA_label)) { // updating the closest cluster
-            if (isMC) {
-              clusID_rDCA_label = {iClus, rDCA, labsDuplicated};
-            } else {
-              clusID_rDCA_label = {iClus, rDCA, gsl::span<const o2::MCCompLabel>()};
-            }
-            phiDuplicated = phiOriginal;
-            ptDuplicated = pt;
-            etaDuplicated = eta;
-            clusZ = clusOriginalPointGlob.z();
-          }
-          adjacentFound = 1;
-        } // end loop on all the clusters in the rof -> at this point we have the information on the closest cluster (if there is one)
-
-        // here clusID_rDCA_label is updated with the closest cluster to the track other than the original one
-
-        if (!adjacentFound) {
+        if (rowOriginal < 2 || (rowOriginal > 15 && rowOriginal < 496) || rowOriginal > 509) { ////  cutting on the row
           continue;
         }
-        nDuplClusters++;
-        nDuplicatedClusters[layerOriginal]++;
-        numPt[layerOriginal]->Fill(ptDuplicated);
-        numPhi[layerOriginal]->Fill(phiDuplicated);
-        numEta[layerOriginal]->Fill(etaDuplicated);
-        mZvsPhiDUplicated[layerOriginal]->Fill(clusZ, phiDuplicated);
 
-        // checking if it is a good or fake match looking at the labels (only if isMC)
-        if (isMC) {
-          bool isGood = false;
-          for (auto lab : std::get<2>(clusID_rDCA_label)) {
-            if (lab == tracklab) {
-              isGood = true;
-              numPtGood[layerOriginal]->Fill(ptDuplicated);
-              numPhiGood[layerOriginal]->Fill(phiDuplicated);
-              numEtaGood[layerOriginal]->Fill(etaDuplicated);
-              continue;
-            }
-          }
-          if (!isGood) {
-            numPtFake[layerOriginal]->Fill(ptDuplicated);
-            numPhiFake[layerOriginal]->Fill(phiDuplicated);
-            numEtaFake[layerOriginal]->Fill(etaDuplicated);
+        if (mUseMC) { //// excluding known bad chips in MC which are not bad in data --- to be checked based on the anchored run
+          if (std::find(mExcludedChipMC.begin(), mExcludedChipMC.end(), clusOriginal.getChipID()) != mExcludedChipMC.end()) {
+            continue;
           }
         }
-      } // end loop on clusters associated to the track
-      totNClusters += NLAYERS;
-    } // end loop on tracks per ROF
-  } // end loop on ROFRecords array
 
-  std::cout << " Num of duplicated clusters L0: " << nDuplicatedClusters[0] << " N tracks selected: " << nTracksSelected[0] << std::endl;
-  std::cout << " Num of duplicated clusters L1: " << nDuplicatedClusters[1] << " N tracks selected: " << nTracksSelected[1] << std::endl;
-  std::cout << " Num of duplicated clusters L2: " << nDuplicatedClusters[2] << " N tracks selected: " << nTracksSelected[2] << std::endl;
-
-  std::cout << " --------- N total clusters: " << totNClusters << std::endl;
-  std::cout << " --------- N duplicated clusters: " << nDuplClusters << std::endl;
-}
-
-void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
-{
-  // Extract the efficiency for the IB, exploiting the staves overlaps and the duplicated clusters for the tracks passing through the overlaps
-  // The denominator for the efficiency calculation will be the number of tracks per layer fulfilling some cuts (DCA, phi, eta, pt)
-  // The numerator will be the number of duplicated clusters for the tracks passing through the overlaps
-  // additionally, print/save info (to be used in MC)
-
-  LOGP(info, "--------------- getEfficiency");
-
-  o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
-  o2::gpu::gpustd::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
-  auto propagator = o2::base::Propagator::Instance();
-
-  unsigned int rofIndexTrack = 0;
-  unsigned int rofNEntriesTrack = 0;
-  unsigned int rofIndexClus = 0;
-  unsigned int rofNEntriesClus = 0;
-  int nLabels = 0;
-  unsigned int totClus = 0;
-
-  int nbPt = 75;
-  double xbins[nbPt + 1], ptcutl = 0.05, ptcuth = 7.5;
-  double a = std::log(ptcuth / ptcutl) / nbPt;
-  for (int i = 0; i <= nbPt; i++) {
-    xbins[i] = ptcutl * std::exp(i * a);
-  }
-
-  int totNClusters;
-  int nDuplClusters;
-
-  // denominator fot the efficiency calculation
-  for (unsigned int iROF = 0; iROF < mTracksROFRecords.size(); iROF++) { // loop on ROFRecords array
-
-    rofIndexTrack = mTracksROFRecords[iROF].getFirstEntry();
-    rofNEntriesTrack = mTracksROFRecords[iROF].getNEntries();
-
-    rofIndexClus = mClustersROFRecords[iROF].getFirstEntry();
-    rofNEntriesClus = mClustersROFRecords[iROF].getNEntries();
-
-    ////// imposing cuts on the tracks = collecting tracks for the denominator
-    for (unsigned int iTrack = rofIndexTrack; iTrack < rofIndexTrack + rofNEntriesTrack; iTrack++) { // loop on tracks per ROF
-      auto track = mTracks[iTrack];
-      o2::track::TrackParCov trackParCov = mTracks[iTrack];
-
-      auto pt = trackParCov.getPt();
-      auto eta = trackParCov.getEta();
-      float phi = -999.;
-      float phiOriginal = -999.;
-
-      float chi2 = track.getChi2();
-
-      chi2track->Fill(chi2);
-
-      float phiTrack = trackParCov.getPhi() * 180 / M_PI;
-
-      // applying the cuts on the track - only pt and eta cuts since for phi(cluster) the layer is needed
-      if (pt < mPtCuts[0] || pt > mPtCuts[1]) {
-        continue;
-      }
-      if (eta < mEtaCuts[0] || eta > mEtaCuts[1]) {
-        continue;
-      }
-      if (chi2 > mChi2cut) {
-        continue;
-      }
-      /// the cut on phi, since it is layer-dependent, can be applied only after finding the cluster and then the layer
-
-      int firstClus = track.getFirstClusterEntry(); // get the first cluster of the track
-      int ncl = track.getNumberOfClusters();        // get the number of clusters of the track
-
-      if (ncl < 7) {
-        continue;
-      }
-
-      o2::MCCompLabel tracklab;
-      if (isMC) {
-        tracklab = mTracksMCLabels[iTrack];
-        if (tracklab.isFake()) {
+        if (clusOriginal.getCol() < 160 || clusOriginal.getCol() > 870) { /// excluding the gap between two chips in the same stave (comment to obtain the plot efficiency col vs eta)
           continue;
         }
-      }
-
-      if (mVerboseOutput && isMC) {
-        LOGP(info, "--------- track Label: ");
-        tracklab.print();
-      }
-
-      for (int iclTrack = firstClus; iclTrack < firstClus + ncl; iclTrack++) { // loop on clusters associated to the track to extract layer, stave and chip to restrict the possible matches to be searched with the DCA cut
-        auto& clusOriginal = mClusters[mInputITSidxs[iclTrack]];
-        auto clusOriginalPoint = mITSClustersArray[mInputITSidxs[iclTrack]];
-        auto layerOriginal = mGeometry->getLayer(clusOriginal.getSensorID());
-
-        UShort_t rowOriginal = clusOriginal.getRow();
-
-        if (layerOriginal >= NLAYERS) {
-          continue;
-        }
-
-        o2::math_utils::Point3D<float> clusOriginalPointTrack = {clusOriginalPoint.getX(), clusOriginalPoint.getY(), clusOriginalPoint.getZ()};
-        o2::math_utils::Point3D<float> clusOriginalPointGlob = mGeometry->getMatrixT2G(clusOriginal.getSensorID()) * clusOriginalPointTrack;
-        phiOriginal = clusOriginalPointGlob.phi() * 180 / M_PI;
-
-        mXoriginal->Fill(clusOriginalPointGlob.x());
-        mYoriginal->Fill(clusOriginalPointGlob.y());
-        mZoriginal->Fill(clusOriginalPointGlob.z());
 
+        /// if the track passes the cuts, fill the den and go ahead
         m2DClusterOriginalPositions->Fill(clusOriginalPointGlob.x(), clusOriginalPointGlob.y());
         m3DClusterPositions->Fill(clusOriginalPointGlob.x(), clusOriginalPointGlob.y(), clusOriginalPointGlob.z());
+        chi2trackAccepted->Fill(chi2);
+        denPt[layerOriginal]->Fill(pt);
+        denPhi[layerOriginal]->Fill(phiOriginal);
+        denEta[layerOriginal]->Fill(eta);
+        denRow[layerOriginal]->Fill(rowOriginal);
+        denCol[layerOriginal]->Fill(clusOriginal.getCol());
+        denZ[layerOriginal]->Fill(clusOriginalPointGlob.z());
+        nTracksSelected[layerOriginal]++;
+        mDenColEta[layerOriginal]->Fill(clusOriginal.getCol(), eta);
+        mDenRowPhi[layerOriginal]->Fill(clusOriginal.getRow(), clusOriginalPointGlob.z());
+        mDenRowCol[layerOriginal]->Fill(clusOriginal.getRow(), clusOriginal.getCol());
+        denLayers->Fill(layerOriginal);
 
-        /// applying the cuts on the phi of the original cluster
-        bool keepTrack = false; /// wether or not a cluster is found in an eligible track in the corresponding layer
-
-        if (layerOriginal == 0) {
-          for (int i = 0; i < 10; i++) {
-            if ((phiOriginal >= mPhiCutsL0[i][0] && phiOriginal <= mPhiCutsL0[i][1])) {
-              keepTrack = true;
-            }
-          }
-        }
-        if (layerOriginal == 1) {
-          for (int i = 0; i < 12; i++) {
-            if ((phiOriginal >= mPhiCutsL1[i][0] && phiOriginal <= mPhiCutsL1[i][1])) {
-              keepTrack = true;
-            }
-          }
-        }
-        if (layerOriginal == 2) {
-          for (int i = 0; i < 17; i++) {
-            if ((phiOriginal >= mPhiCutsL2[i][0] && phiOriginal <= mPhiCutsL2[i][1])) {
-              keepTrack = true;
-            }
-          }
-        }
-        if (!(keepTrack)) {
-          continue; /// if the track (cluster) is not eligible for any layer, go to the next one
-        } else {    /// fill the den and go ahead
-          chi2trackAccepted->Fill(chi2);
-          denPt[layerOriginal]->Fill(pt);
-          denPhi[layerOriginal]->Fill(phiOriginal);
-          denEta[layerOriginal]->Fill(eta);
-          nTracksSelected[layerOriginal]++;
-        }
+        /// if the cuts up to here are passed, then search for the duplicated cluster, otherwise go to the next cluster
         gsl::span<const o2::MCCompLabel> labsOriginal = {};
         if (isMC) {
           labsOriginal = mClustersMCLCont->getLabels(mInputITSidxs[iclTrack]); // get labels of the cluster associated to the track (original)
@@ -2487,19 +2334,16 @@ void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
         float etaDuplicated = -999.;
         float clusZ = -999.;
 
-        o2::MCCompLabel labelCandidateDuplicated;
-        bool duplExists = false;
+        o2::itsmft::CompClusterExt clusDuplicatedSelected = o2::itsmft::CompClusterExt();
 
-        /// for each original cluster iterate over all the possible duplicated clusters to see first wether increment or not the denominator (if a track has a possible duplicated cluster in the selected phi region)
-        /// then if the phi is within the cuts, select the "adjacent" clusters (stave +-1, chip =,+-1) and calculate the DCA with the track. Then choose the closest one.
+        /// for each original cluster iterate over all the possible duplicated clusters to select the "adjacent" clusters (stave +-1, chip =,+-1) and calculate the DCA with the track. Then choose the closest one.
         for (unsigned int iClus = rofIndexClus; iClus < rofIndexClus + rofNEntriesClus; iClus++) { // iteration over ALL the clusters in the ROF
           auto clusDuplicated = mClusters[iClus];
-
           auto clusDuplicatedPoint = mITSClustersArray[iClus];
 
           o2::math_utils::Point3D<float> clusDuplicatedPointTrack = {clusDuplicatedPoint.getX(), clusDuplicatedPoint.getY(), clusDuplicatedPoint.getZ()};
           o2::math_utils::Point3D<float> clusDuplicatedPointGlob = mGeometry->getMatrixT2G(clusDuplicated.getSensorID()) * clusDuplicatedPointTrack;
-          phi = clusDuplicatedPointGlob.phi() * 180 / M_PI;
+          phi = clusDuplicatedPointGlob.phi(); // * 180 / M_PI;
 
           //// applying constraints: the cluster should be on the same layer, should be on an adjacent stave and on the same or adjacent chip position
           if (clusDuplicated.getSensorID() == clusOriginal.getSensorID()) {
@@ -2509,12 +2353,6 @@ void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
           if (layerDuplicated != layerOriginal) {
             continue;
           }
-          labelCandidateDuplicated = mClustersMCLCont->getLabels(iClus)[0];
-          if (labelCandidateDuplicated == tracklab) {
-            duplExists = true;
-            std::cout << "Duplicated should exist with label: " << labelCandidateDuplicated.asString() << "  , phi = " << phi << " and be: ";
-            clusDuplicated.print();
-          }
           auto staveDuplicated = mGeometry->getStave(clusDuplicated.getSensorID());
           if (abs(staveDuplicated - staveOriginal) != 1) {
             continue;
@@ -2524,8 +2362,6 @@ void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
             continue;
           }
 
-          std::cout << "checks passed" << std::endl;
-
           gsl::span<const o2::MCCompLabel> labsDuplicated = {};
           if (isMC) {
             labsDuplicated = mClustersMCLCont->getLabels(iClus);
@@ -2538,13 +2374,8 @@ void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
             continue;
           }
 
-          std::cout << "dca calculated: " << clusDuplicatedDCA[0] << "  " << clusDuplicatedDCA[1] << std::endl;
-
           DCAxyData[layerDuplicated]->Fill(clusDuplicatedDCA[0]);
           DCAzData[layerDuplicated]->Fill(clusDuplicatedDCA[1]);
-          DistanceClustersX[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.x() - clusOriginalPointGlob.x()));
-          DistanceClustersY[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.y() - clusOriginalPointGlob.y()));
-          DistanceClustersZ[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.z() - clusOriginalPointGlob.z()));
 
           // Imposing that the distance between the duplicated cluster and the track is less than x sigma
           if (!(clusDuplicatedDCA[0] > mDCACutsXY[layerDuplicated][0] && clusDuplicatedDCA[0] < mDCACutsXY[layerDuplicated][1] && clusDuplicatedDCA[1] > mDCACutsZ[layerDuplicated][0] && clusDuplicatedDCA[1] < mDCACutsZ[layerDuplicated][1])) {
@@ -2552,15 +2383,9 @@ void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
             DCAzRejected[layerDuplicated]->Fill(clusDuplicatedDCA[1]);
             continue;
           }
+
           m2DClusterDuplicatedPositions->Fill(clusDuplicatedPointGlob.x(), clusDuplicatedPointGlob.y());
           m3DDuplicatedClusterPositions->Fill(clusDuplicatedPointGlob.x(), clusDuplicatedPointGlob.y(), clusDuplicatedPointGlob.z());
-          mXduplicated->Fill(clusDuplicatedPointGlob.x());
-          mYduplicated->Fill(clusDuplicatedPointGlob.y());
-          mZduplicated->Fill(clusDuplicatedPointGlob.z());
-
-          DistanceClustersXAftercuts[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.x() - clusOriginalPointGlob.x()));
-          DistanceClustersYAftercuts[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.y() - clusOriginalPointGlob.y()));
-          DistanceClustersZAftercuts[layerDuplicated]->Fill(abs(clusDuplicatedPointGlob.z() - clusOriginalPointGlob.z()));
 
           if (mVerboseOutput) {
             LOGP(info, "Propagation ok");
@@ -2578,32 +2403,46 @@ void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
             ptDuplicated = pt;
             etaDuplicated = eta;
             clusZ = clusOriginalPointGlob.z();
+            clusDuplicatedSelected = clusDuplicated;
           }
           adjacentFound = 1;
-          std::cout << "Duplicated found with label: " << labsDuplicated[0] << " and phi: " << phiDuplicated << std::endl;
-          clusDuplicated.print();
-          std::cout << "-----" << std::endl;
         } // end loop on all the clusters in the rof -> at this point we have the information on the closest cluster (if there is one)
 
         // here clusID_rDCA_label is updated with the closest cluster to the track other than the original one
-        // checking if it is a good or fake match looking at the labels (only if isMC)
+
         if (!adjacentFound) {
-          if (duplExists) {
-            std::cout << "No duplicated found but should exist" << std::endl;
-            std::cout << "DCA cuts were: xy-> " << mDCACutsXY[layerOriginal][0] << " to " << mDCACutsXY[layerOriginal][1] << " and z-> " << mDCACutsZ[layerOriginal][0] << " to " << mDCACutsZ[layerOriginal][1] << "\n-----" << std::endl;
-          } else {
-            std::cout << "No duplicated found and does not exist" << std::endl;
-          }
+          radiusNotFound[layerOriginal]->Fill(sqrt(clusOriginalPointGlob.x() * clusOriginalPointGlob.x() + clusOriginalPointGlob.y() * clusOriginalPointGlob.y()));
+          colNotFound[layerOriginal]->Fill(clusOriginal.getCol() + (1024 * (clusOriginal.getChipID() % 9)));
+          rowNotFound[layerOriginal]->Fill(rowOriginal);
+          zNotFound[layerOriginal]->Fill(clusOriginalPointGlob.z());
+          phiNotFound[layerOriginal]->Fill(phiOriginal);
           continue;
         }
-        std::cout << "-----" << std::endl;
+
+        chipOrigVsOverlap->Fill(clusOriginal.getChipID() % 9, clusDuplicatedSelected.getChipID() % 9);
+        mChipFound->Fill(clusOriginal.getChipID());
+        zFound[layerOriginal]->Fill(clusOriginalPointGlob.z());
+        radiusFound[layerOriginal]->Fill(sqrt(clusOriginalPointGlob.x() * clusOriginalPointGlob.x() + clusOriginalPointGlob.y() * clusOriginalPointGlob.y()));
+        colFoundOriginalVsDuplicated[layerOriginal]->Fill(clusOriginal.getCol() + (1024 * (clusOriginal.getChipID() % 9)), clusDuplicatedSelected.getCol() + (1024 * (clusDuplicatedSelected.getChipID() % 9)));
+        colFoundOriginal[layerOriginal]->Fill(clusOriginal.getCol() + (1024 * (clusOriginal.getChipID() % 9)));
+        m2DClusterFoundPositions->Fill(clusOriginalPointGlob.x(), clusOriginalPointGlob.y());
+        phiFound[layerOriginal]->Fill(phiOriginal);
+        rowFound[layerOriginal]->Fill(rowOriginal);
         nDuplClusters++;
         nDuplicatedClusters[layerOriginal]++;
-        numPt[layerOriginal]->Fill(ptDuplicated);
+        numPt[layerOriginal]->Fill(pt);
         numPhi[layerOriginal]->Fill(phiDuplicated);
         numEta[layerOriginal]->Fill(etaDuplicated);
+        numRow[layerOriginal]->Fill(rowOriginal);
+        numCol[layerOriginal]->Fill(clusOriginal.getCol());
+        numZ[layerOriginal]->Fill(clusOriginalPointGlob.z());
         mZvsPhiDUplicated[layerOriginal]->Fill(clusZ, phiDuplicated);
+        mNumColEta[layerOriginal]->Fill(clusOriginal.getCol(), eta);
+        mNumRowPhi[layerOriginal]->Fill(clusOriginal.getRow(), clusOriginalPointGlob.z());
+        mNumRowCol[layerOriginal]->Fill(clusOriginal.getRow(), clusOriginal.getCol());
+        numLayers->Fill(layerOriginal);
 
+        // checking if it is a good or fake match looking at the labels (only if isMC)
         if (isMC) {
           bool isGood = false;
           for (auto lab : std::get<2>(clusID_rDCA_label)) {
@@ -2612,6 +2451,10 @@ void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
               numPtGood[layerOriginal]->Fill(ptDuplicated);
               numPhiGood[layerOriginal]->Fill(phiDuplicated);
               numEtaGood[layerOriginal]->Fill(etaDuplicated);
+              numRowGood[layerOriginal]->Fill(rowOriginal);
+              numColGood[layerOriginal]->Fill(clusOriginal.getCol());
+              numZGood[layerOriginal]->Fill(clusOriginalPointGlob.z());
+              numGoodLayers->Fill(layerOriginal);
               continue;
             }
           }
@@ -2619,6 +2462,10 @@ void EfficiencyStudy::getEfficiencyAndTrackInfo(bool isMC)
             numPtFake[layerOriginal]->Fill(ptDuplicated);
             numPhiFake[layerOriginal]->Fill(phiDuplicated);
             numEtaFake[layerOriginal]->Fill(etaDuplicated);
+            numRowFake[layerOriginal]->Fill(rowOriginal);
+            numColFake[layerOriginal]->Fill(clusOriginal.getCol());
+            numZFake[layerOriginal]->Fill(clusOriginalPointGlob.z());
+            numFakeLayers->Fill(layerOriginal);
           }
         }
       } // end loop on clusters associated to the track
@@ -2642,16 +2489,14 @@ void EfficiencyStudy::process(o2::globaltracking::RecoContainer& recoData)
 
   if (mUseMC) {
     // getDCAClusterTrackMC();
-    // studyDCAcutsMC();
+    studyDCAcutsMC();
     // studyClusterSelectionMC();
-    // getEfficiencyAndTrackInfo(mUseMC);
     // countDuplicatedAfterCuts();
-  } else if (!mUseMC) {
-    // saveDataInfo();
+    getEfficiency(mUseMC);
+  } else {
+    getEfficiency(mUseMC);
   }
 
-  getEfficiency(mUseMC);
-
   LOGP(info, "** Found in {} rofs:\n\t- {} clusters\n\t",
        mClustersROFRecords.size(), mClusters.size());
 
@@ -2681,21 +2526,13 @@ void EfficiencyStudy::endOfStream(EndOfStreamContext& ec)
 
   mOutFile->mkdir("EfficiencyFinal/");
   mOutFile->mkdir("DCAFinal/");
+  mOutFile->mkdir("NotFoundChecks/");
 
-  mOutFile->mkdir("DistanceClusters/");
   mOutFile->mkdir("DCA/");
   mOutFile->mkdir("Pt_Eta_Phi/");
 
   if (mUseMC) {
 
-    mOutFile->cd("DistanceClusters");
-    for (int i = 0; i < NLAYERS; i++) {
-      mDistanceClustersX[i]->Write();
-      mDistanceClustersY[i]->Write();
-      mDistanceClustersZ[i]->Write();
-      mDistanceClusters[i]->Write();
-    }
-
     mOutFile->cd("DCA");
     mDCAxyDuplicated->Write();
     mDCAzDuplicated->Write();
@@ -2709,24 +2546,19 @@ void EfficiencyStudy::endOfStream(EndOfStreamContext& ec)
 
     mOutFile->cd("Pt_Eta_Phi/");
     for (int i = 0; i < NLAYERS; i++) {
-      mPhiOriginal[i]->Write();
-      mPhiTrackOriginal[i]->Write();
       mDuplicatedPhiAllPt[i]->Write();
-      mPtOriginal[i]->Write();
       mPtDuplicated[i]->Write();
       mEtaDuplicated[i]->Write();
       mPhiDuplicated[i]->Write();
-      mPhiTrackDuplicated[i]->Write();
-      mPhiTrackDuplicatedvsphiDuplicated[i]->Write();
-      mPhiTrackoriginalvsphioriginal[i]->Write();
       mPhiOriginalIfDuplicated[i]->Write();
       mDuplicatedPt[i]->Write();
       mDuplicatedPtEta[i]->Write();
       mDuplicatedPtPhi[i]->Write();
       mDuplicatedEtaPhi[i]->Write();
-      mEtaOriginal[i]->Write();
       mDuplicatedEtaAllPt[i]->Write();
       mDuplicatedRow[i]->Write();
+      mDuplicatedCol[i]->Write();
+      mDuplicatedZ[i]->Write();
 
       for (int p = 0; p < 3; p++) {
         mDuplicatedEta[i][p]->Write();
@@ -2741,7 +2573,6 @@ void EfficiencyStudy::endOfStream(EndOfStreamContext& ec)
     IPOriginalxy[i]->Write();
     IPOriginalz[i]->Write();
     mPhiOriginal[i]->Write();
-    mPhiTrackOriginal[i]->Write();
     mPtOriginal[i]->Write();
     mEtaOriginal[i]->Write();
     mZvsPhiDUplicated[i]->Write();
@@ -2752,75 +2583,245 @@ void EfficiencyStudy::endOfStream(EndOfStreamContext& ec)
   mOutFile->mkdir("chi2");
   mOutFile->cd("chi2/");
 
-  chi2track->Write();
   chi2trackAccepted->Write();
 
   mOutFile->cd("EfficiencyFinal/");
+  TList listNum;
+  TList listDen;
+  auto numPhiAll = std::unique_ptr<TH1D>((TH1D*)numPhi[0]->Clone("numPhiAll"));
+  auto denPhiAll = std::unique_ptr<TH1D>((TH1D*)denPhi[0]->Clone("denPhiAll"));
+
+  TList listNumColEta;
+  TList listDenColEta;
+  auto numColEtaAll = std::unique_ptr<TH1D>((TH1D*)mNumColEta[0]->Clone("numColEtaAll"));
+  auto denColEtaAll = std::unique_ptr<TH1D>((TH1D*)mDenColEta[0]->Clone("denColEtaAll"));
+
+  TList listNumRowPhi;
+  TList listDenRowPhi;
+  auto numRowPhiAll = std::unique_ptr<TH1D>((TH1D*)mNumRowPhi[0]->Clone("numRowPhiAll"));
+  auto denRowPhiAll = std::unique_ptr<TH1D>((TH1D*)mDenRowPhi[0]->Clone("denRowPhiAll"));
+
+  TList listNumRowCol;
+  TList listDenRowCol;
+  auto numRowColAll = std::unique_ptr<TH1D>((TH1D*)mNumRowCol[0]->Clone("numRowColAll"));
+  auto denRowColAll = std::unique_ptr<TH1D>((TH1D*)mDenRowCol[0]->Clone("denRowColAll"));
+
+  std::unique_ptr<TEfficiency> effLayers = std::make_unique<TEfficiency>(*numLayers, *denLayers);
+  effLayers->SetName("effLayers");
+  effLayers->SetTitle("; ;Efficiency");
+  std::unique_ptr<TEfficiency> effLayersGood = std::make_unique<TEfficiency>(*numGoodLayers, *denLayers);
+  effLayersGood->SetName("effLayersGood");
+  effLayersGood->SetTitle("; ;Efficiency Good Matches");
+  std::unique_ptr<TEfficiency> effLayersFake = std::make_unique<TEfficiency>(*numFakeLayers, *denLayers);
+  effLayersFake->SetName("effLayersFake");
+  effLayersFake->SetTitle("; ;Efficiency Fake Matches");
+  effLayers->Write();
+  effLayersGood->Write();
+  effLayersFake->Write();
+  denLayers->Write();
+  numLayers->Write();
+  numGoodLayers->Write();
+  numFakeLayers->Write();
 
   for (int l = 0; l < NLAYERS; l++) {
 
-    TEfficiency* effPt = new TEfficiency(*numPt[l], *denPt[l]);
+    std::unique_ptr<TEfficiency> effPt = std::make_unique<TEfficiency>(*numPt[l], *denPt[l]);
     effPt->SetName(Form("effPt_layer%d", l));
     effPt->SetTitle(Form("L%d;p_{T} (GeV/c);Efficiency", l));
-    TEfficiency* effPtGood = new TEfficiency(*numPtGood[l], *denPt[l]);
+    std::unique_ptr<TEfficiency> effPtGood = std::make_unique<TEfficiency>(*numPtGood[l], *denPt[l]);
     effPtGood->SetName(Form("effPtGood_layer%d", l));
     effPtGood->SetTitle(Form("L%d;p_{T} (GeV/c);Efficiency Good Matches", l));
-    TEfficiency* effPtFake = new TEfficiency(*numPtFake[l], *denPt[l]);
+    std::unique_ptr<TEfficiency> effPtFake = std::make_unique<TEfficiency>(*numPtFake[l], *denPt[l]);
     effPtFake->SetName(Form("effPtFake_layer%d", l));
     effPtFake->SetTitle(Form("L%d;p_{T} (GeV/c);Efficiency Fake Matches", l));
     effPt->Write();
     effPtGood->Write();
     effPtFake->Write();
 
-    TEfficiency* effPhi = new TEfficiency(*numPhi[l], *denPhi[l]);
+    std::unique_ptr<TEfficiency> effPhi = std::make_unique<TEfficiency>(*numPhi[l], *denPhi[l]);
     effPhi->SetName(Form("effPhi_layer%d", l));
     effPhi->SetTitle(Form("L%d;#phi;Efficiency", l));
-    TEfficiency* effPhiGood = new TEfficiency(*numPhiGood[l], *denPhi[l]);
+    std::unique_ptr<TEfficiency> effPhiGood = std::make_unique<TEfficiency>(*numPhiGood[l], *denPhi[l]);
     effPhiGood->SetName(Form("effPhiGood_layer%d", l));
     effPhiGood->SetTitle(Form("L%d;#phi;Efficiency Good Matches", l));
-    TEfficiency* effPhiFake = new TEfficiency(*numPhiFake[l], *denPhi[l]);
+    std::unique_ptr<TEfficiency> effPhiFake = std::make_unique<TEfficiency>(*numPhiFake[l], *denPhi[l]);
     effPhiFake->SetName(Form("effPhiFake_layer%d", l));
     effPhiFake->SetTitle(Form("L%d;#phi;Efficiency Fake Matches", l));
     effPhi->Write();
     effPhiGood->Write();
     effPhiFake->Write();
+    listNum.Add(numPhi[l].get());
+    listDen.Add(denPhi[l].get());
 
-    TEfficiency* effEta = new TEfficiency(*numEta[l], *denEta[l]);
+    std::unique_ptr<TEfficiency> effEta = std::make_unique<TEfficiency>(*numEta[l], *denEta[l]);
     effEta->SetName(Form("effEta_layer%d", l));
     effEta->SetTitle(Form("L%d;#eta;Efficiency", l));
-    TEfficiency* effEtaGood = new TEfficiency(*numEtaGood[l], *denEta[l]);
+    std::unique_ptr<TEfficiency> effEtaGood = std::make_unique<TEfficiency>(*numEtaGood[l], *denEta[l]);
     effEtaGood->SetName(Form("effEtaGood_layer%d", l));
     effEtaGood->SetTitle(Form("L%d;#eta;Efficiency Good Matches", l));
-    TEfficiency* effEtaFake = new TEfficiency(*numEtaFake[l], *denEta[l]);
+    std::unique_ptr<TEfficiency> effEtaFake = std::make_unique<TEfficiency>(*numEtaFake[l], *denEta[l]);
     effEtaFake->SetName(Form("effEtaFake_layer%d", l));
     effEtaFake->SetTitle(Form("L%d;#eta;Efficiency Fake Matches", l));
     effEta->Write();
     effEtaGood->Write();
     effEtaFake->Write();
 
+    std::unique_ptr<TEfficiency> effRow = std::make_unique<TEfficiency>(*numRow[l], *denRow[l]);
+    effRow->SetName(Form("effRow_layer%d", l));
+    effRow->SetTitle(Form("L%d;#Row;Efficiency", l));
+    std::unique_ptr<TEfficiency> effRowGood = std::make_unique<TEfficiency>(*numRowGood[l], *denRow[l]);
+    effRowGood->SetName(Form("effRowGood_layer%d", l));
+    effRowGood->SetTitle(Form("L%d;#Row;Efficiency Good Matches", l));
+    std::unique_ptr<TEfficiency> effRowFake = std::make_unique<TEfficiency>(*numRowFake[l], *denRow[l]);
+    effRowFake->SetName(Form("effRowFake_layer%d", l));
+    effRowFake->SetTitle(Form("L%d;#Row;Efficiency Fake Matches", l));
+    effRow->Write();
+    effRowGood->Write();
+    effRowFake->Write();
+
+    std::unique_ptr<TEfficiency> effCol = std::make_unique<TEfficiency>(*numCol[l], *denCol[l]);
+    effCol->SetName(Form("effCol_layer%d", l));
+    effCol->SetTitle(Form("L%d;#Col;Efficiency", l));
+    std::unique_ptr<TEfficiency> effColGood = std::make_unique<TEfficiency>(*numColGood[l], *denCol[l]);
+    effColGood->SetName(Form("effColGood_layer%d", l));
+    effColGood->SetTitle(Form("L%d;#Col;Efficiency Good Matches", l));
+    std::unique_ptr<TEfficiency> effColFake = std::make_unique<TEfficiency>(*numColFake[l], *denCol[l]);
+    effColFake->SetName(Form("effColFake_layer%d", l));
+    effColFake->SetTitle(Form("L%d;#Col;Efficiency Fake Matches", l));
+    effCol->Write();
+    effColGood->Write();
+    effColFake->Write();
+
+    std::unique_ptr<TEfficiency> effZ = std::make_unique<TEfficiency>(*numZ[l], *denZ[l]);
+    effZ->SetName(Form("effZ_layer%d", l));
+    effZ->SetTitle(Form("L%d;#Z (cm);Efficiency", l));
+    std::unique_ptr<TEfficiency> effZGood = std::make_unique<TEfficiency>(*numZGood[l], *denZ[l]);
+    effZGood->SetName(Form("effZGood_layer%d", l));
+    effZGood->SetTitle(Form("L%d;#Z (cm);Efficiency Good Matches", l));
+    std::unique_ptr<TEfficiency> effZFake = std::make_unique<TEfficiency>(*numZFake[l], *denZ[l]);
+    effZFake->SetName(Form("effZFake_layer%d", l));
+    effZFake->SetTitle(Form("L%d;#Z (cm);Efficiency Fake Matches", l));
+    effZ->Write();
+    effZGood->Write();
+    effZFake->Write();
+
+    std::unique_ptr<TEfficiency> effColEta = std::make_unique<TEfficiency>(*mNumColEta[l], *mDenColEta[l]);
+    effColEta->SetName(Form("effColEta_layer%d", l));
+    effColEta->SetTitle(Form("L%d;Column;#eta", l));
+    effColEta->Write();
+
+    listNumColEta.Add(mNumColEta[l].get());
+    listDenColEta.Add(mDenColEta[l].get());
+
+    std::unique_ptr<TEfficiency> effRowPhi = std::make_unique<TEfficiency>(*mNumRowPhi[l], *mDenRowPhi[l]);
+    effRowPhi->SetName(Form("effRowPhi_layer%d", l));
+    effRowPhi->SetTitle(Form("L%d;Column;#eta", l));
+    effRowPhi->Write();
+
+    listNumRowPhi.Add(mNumRowPhi[l].get());
+    listDenRowPhi.Add(mDenRowPhi[l].get());
+
+    std::unique_ptr<TEfficiency> effRowCol = std::make_unique<TEfficiency>(*mNumRowCol[l], *mDenRowCol[l]);
+    effRowCol->SetName(Form("effRowCol_layer%d", l));
+    effRowCol->SetTitle(Form("L%d;Column;#eta", l));
+    effRowCol->Write();
+
+    listNumRowCol.Add(mNumRowCol[l].get());
+    listDenRowCol.Add(mDenRowCol[l].get());
+
+    mNumRowCol[l]->Write();
+    mDenRowCol[l]->Write();
+    mNumRowPhi[l]->Write();
+    mDenRowPhi[l]->Write();
+    mNumColEta[l]->Write();
+    mDenColEta[l]->Write();
     numPhi[l]->Write();
     denPhi[l]->Write();
     numPt[l]->Write();
     denPt[l]->Write();
     numEta[l]->Write();
     denEta[l]->Write();
+    numRow[l]->Write();
+    denRow[l]->Write();
+    numCol[l]->Write();
+    denCol[l]->Write();
+    numZ[l]->Write();
+    denZ[l]->Write();
   }
+  numPhiAll->Merge(&listNum);
+  denPhiAll->Merge(&listDen);
+
+  numColEtaAll->Merge(&listNumColEta);
+  denColEtaAll->Merge(&listDenColEta);
+
+  numRowPhiAll->Merge(&listNumRowPhi);
+  denRowPhiAll->Merge(&listDenRowPhi);
+
+  numRowColAll->Merge(&listNumRowCol);
+  denRowColAll->Merge(&listDenRowCol);
+
+  std::unique_ptr<TEfficiency> effPhiAll = std::make_unique<TEfficiency>(*numPhiAll, *denPhiAll);
+  effPhiAll->SetName("effPhi_AllLayers");
+  effPhiAll->SetTitle("L0 + L1 + L2;#phi;Efficiency");
+  effPhiAll->Write();
+  numPhiAll->Write();
+  denPhiAll->Write();
+
+  std::unique_ptr<TEfficiency> effColEtaAll = std::make_unique<TEfficiency>(*numColEtaAll, *denColEtaAll);
+  effColEtaAll->SetName("effColEta_AllLayers");
+  effColEtaAll->SetTitle("L0 + L1 + L2;Column;#eta");
+  effColEtaAll->Write();
+  numColEtaAll->Write();
+  denColEtaAll->Write();
+
+  std::unique_ptr<TEfficiency> effRowPhiAll = std::make_unique<TEfficiency>(*numRowPhiAll, *denRowPhiAll);
+  effRowPhiAll->SetName("effRowPhi_AllLayers");
+  effRowPhiAll->SetTitle("L0 + L1 + L2;Column;#eta");
+  effRowPhiAll->Write();
+  numRowPhiAll->Write();
+  denRowPhiAll->Write();
+
+  std::unique_ptr<TEfficiency> effRowColAll = std::make_unique<TEfficiency>(*numRowColAll, *denRowColAll);
+  effRowColAll->SetName("effRowCol_AllLayers");
+  effRowColAll->SetTitle("L0 + L1 + L2;Column;#eta");
+  effRowColAll->Write();
+  numRowColAll->Write();
+  denRowColAll->Write();
 
   mOutFile->cd("DCAFinal/");
 
   for (int l = 0; l < NLAYERS; l++) {
     DCAxyData[l]->Write();
     DCAzData[l]->Write();
-    DistanceClustersX[l]->Write();
-    DistanceClustersY[l]->Write();
-    DistanceClustersZ[l]->Write();
-    DistanceClustersXAftercuts[l]->Write();
-    DistanceClustersYAftercuts[l]->Write();
-    DistanceClustersZAftercuts[l]->Write();
     DCAxyRejected[l]->Write();
     DCAzRejected[l]->Write();
   }
 
+  mOutFile->cd("NotFoundChecks/");
+
+  for (int l = 0; l < NLAYERS; l++) {
+    phiFound[l]->Write();
+    phiNotFound[l]->Write();
+    rowFound[l]->Write();
+    rowNotFound[l]->Write();
+    zFound[l]->Write();
+    zNotFound[l]->Write();
+    radiusFound[l]->Write();
+    radiusNotFound[l]->Write();
+    colFoundOriginalVsDuplicated[l]->Write();
+    colFoundOriginal[l]->Write();
+    colNotFound[l]->Write();
+  }
+  mChipFound->Write();
+  mChipNotFound->Write();
+  m2DClusterFoundPositions->Write();
+  l0_00->Write();
+  l1_15->Write();
+  l2_19->Write();
+  chipOrigVsOverlap->Write();
+  chipmap->SetContour(100);
+  chipmap->Write();
+
   mOutFile->Close();
 }
 

From d9d78bcededce73fe8ef2e452d81dff9f8c797d2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Mar 2025 09:28:41 +0100
Subject: [PATCH 0149/1764] GPU CMake: Cleanup and do not use Clang x86
 denormals flag for device compilation

---
 GPU/GPUTracking/Base/opencl/CMakeLists.txt |  4 +-
 GPU/GPUTracking/CMakeLists.txt             |  5 +-
 dependencies/FindO2GPU.cmake               | 55 +++++++++++-----------
 3 files changed, 33 insertions(+), 31 deletions(-)

diff --git a/GPU/GPUTracking/Base/opencl/CMakeLists.txt b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
index 48f292a198b9c..381c9c050ca09 100644
--- a/GPU/GPUTracking/Base/opencl/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
@@ -23,9 +23,9 @@ endif()
 set(CL_SRC ${GPUDIR}/Base/opencl/GPUReconstructionOCL.cl)
 set(CL_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCLCode)
 
-set(OCL_FLAGS -Dcl_clang_storage_class_specifiers -cl-std=CLC++2021)
+set(OCL_FLAGS -Dcl_clang_storage_class_specifiers -cl-std=CLC++2021 ${GPUCA_OCL_DENORMALS_FLAGS})
 if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
-  set(OCL_FLAGS ${OCL_FLAGS} -cl-denorms-are-zero -cl-mad-enable -cl-no-signed-zeros -cl-fast-relaxed-math)
+  set(OCL_FLAGS ${OCL_FLAGS} -cl-mad-enable -cl-no-signed-zeros -cl-fast-relaxed-math)
 else()
   set(OCL_FLAGS ${OCL_FLAGS} ${GPUCA_OCL_NO_FAST_MATH_FLAGS})
 endif()
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index ad7dd9c210cd1..39218e9f94527 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -17,11 +17,12 @@ set(MODULE GPUTracking)
 if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
   set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
   if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_OPTO2})
-    set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O2 ${GPUCA_CLANG_FTZ}")
+    set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O2")
   endif()
 elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O3 -ffast-math ${GPUCA_CLANG_FTZ}")
+  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O3 -ffast-math")
 endif()
+set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_DENORMALS_FLAGS}")
 
 include(cmake/helpers.cmake)
 
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 56b53e1be8879..d796d0b7145a8 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -85,17 +85,20 @@ elseif(NOT GPUCA_DETERMINISTIC_MODE MATCHES "^[0-9]+$")
   message(STATUS "Set to ${GPUCA_DETERMINISTIC_MODE}")
 endif()
 if (CMAKE_SYSTEM_NAME MATCHES Darwin OR NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
-  set(GPUCA_CLANG_FTZ "")
+  set(GPUCA_CXX_DENORMALS_FLAGS "")
 else()
-  set(GPUCA_CLANG_FTZ "-mdaz-ftz")
+  set(GPUCA_CXX_DENORMALS_FLAGS "-mdaz-ftz")
 endif()
-set(GPUCA_CXX_NO_FAST_MATH_FLAGS "-fno-fast-math -ffp-contract=off ${GPUCA_CLANG_FTZ}")
-set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--ftz=true --prec-div=true --prec-sqrt=true --fmad false")
-set(GPUCA_OCL_NO_FAST_MATH_FLAGS -cl-fp32-correctly-rounded-divide-sqrt -cl-denorms-are-zero)
+set(GPUCA_CUDA_DENORMALS_FLAGS "--ftz=true")
+set(GPUCA_OCL_DENORMALS_FLAGS "-cl-denorms-are-zero")
+set(GPUCA_HIP_DENORMALS_FLAGS "-fgpu-flush-denormals-to-zero")
+set(GPUCA_CXX_NO_FAST_MATH_FLAGS "-fno-fast-math -ffp-contract=off")
+set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--prec-div=true --prec-sqrt=true --fmad false")
+set(GPUCA_OCL_NO_FAST_MATH_FLAGS -cl-fp32-correctly-rounded-divide-sqrt )
 if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_WHOLEO2})
   add_definitions(-DGPUCA_DETERMINISTIC_MODE)
-  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
-  set(CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
+  string(APPEND CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
+  string(APPEND CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
 endif()
 
 
@@ -143,7 +146,8 @@ if(ENABLE_CUDA)
     endif()
   endif()
   if(CMAKE_CUDA_COMPILER)
-    set(CMAKE_CUDA_FLAGS "-Xcompiler \"${O2_GPU_CMAKE_CXX_FLAGS_NOSTD}\" ${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr --extended-lambda -Xcompiler -Wno-attributes")
+    set(CMAKE_CUDA_FLAGS "-Xcompiler \"${O2_GPU_CMAKE_CXX_FLAGS_NOSTD}\" ${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr --extended-lambda -Xcompiler -Wno-attributes ${GPUCA_CUDA_DENORMALS_FLAGS}")
+    set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "-Xcompiler \"${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}\" ${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
     if(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE)
       string(APPEND CMAKE_CUDA_FLAGS " -Xptxas -v")
     endif()
@@ -151,19 +155,18 @@ if(ENABLE_CUDA)
     if (NOT ENABLE_CUDA STREQUAL "AUTO")
       string(APPEND CMAKE_CUDA_FLAGS " --allow-unsupported-compiler")
     endif()
-    set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "-Xcompiler \"${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}\" ${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
     if(CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-      set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -lineinfo -Xptxas -O0 -Xcompiler -O0")
+      string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -lineinfo -Xptxas -O0")
     else()
-      set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -Xptxas -O4 -Xcompiler -O4")
+      string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -Xptxas -O4 -Xcompiler -O4")
     endif()
     if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
-      set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CUDA_NO_FAST_MATH_FLAGS}")
+      string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " ${GPUCA_CUDA_NO_FAST_MATH_FLAGS}")
     elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-      set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -use_fast_math --ftz=true")#
+      string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -use_fast_math --ftz=true")
     endif()
     if(CMAKE_CXX_FLAGS MATCHES "(^| )-Werror( |$)")
-      set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Werror=cross-execution-space-call")
+      string(APPEND CMAKE_CUDA_FLAGS " -Werror=cross-execution-space-call")
     endif()
     if(GPUCA_CUDA_GCCBIN)
       list(FILTER CMAKE_CUDA_IMPLICIT_LINK_DIRECTORIES EXCLUDE REGEX "^/usr/lib.*/gcc/") # Workaround, since CMake adds old GCC lib paths implicitly if we request that gcc for CUDA
@@ -285,27 +288,25 @@ if(ENABLE_HIP)
     set(HIP_ENABLED ON)
     set_target_properties(roc::rocthrust PROPERTIES IMPORTED_GLOBAL TRUE)
     message(STATUS "HIP Found (${hip_HIPCC_EXECUTABLE} version ${hip_VERSION})")
-    set(O2_HIP_CMAKE_CXX_FLAGS "-fgpu-defer-diag -mllvm -amdgpu-enable-lower-module-lds=false -mllvm -amdgpu-function-calls=true -Wno-invalid-command-line-argument -Wno-unused-command-line-argument -Wno-invalid-constexpr -Wno-ignored-optimization-argument -Wno-unused-private-field -Wno-pass-failed")
+    set(CMAKE_HIP_FLAGS "${O2_GPU_CMAKE_CXX_FLAGS_NOSTD} ${CMAKE_HIP_FLAGS} ${GPUCA_HIP_DENORMALS_FLAGS}")
+    set(CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
+    string(APPEND CMAKE_HIP_FLAGS " -fgpu-defer-diag -mllvm -amdgpu-enable-lower-module-lds=false -mllvm -amdgpu-function-calls=true -Wno-invalid-command-line-argument -Wno-unused-command-line-argument -Wno-invalid-constexpr -Wno-ignored-optimization-argument -Wno-unused-private-field -Wno-pass-failed ")
     if(hip_VERSION VERSION_GREATER_EQUAL "6.0" AND NOT hip_VERSION VERSION_GREATER_EQUAL "6.2")
-      string(APPEND O2_HIP_CMAKE_CXX_FLAGS " -mllvm -amdgpu-legacy-sgpr-spill-lowering=true") # TODO: Cleanup
+      string(APPEND CMAKE_HIP_FLAGS " -mllvm -amdgpu-legacy-sgpr-spill-lowering=true") # TODO: Cleanup
     endif()
     if(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE)
-      string(APPEND O2_HIP_CMAKE_CXX_FLAGS " -Rpass-analysis=kernel-resource-usage")
+      string(APPEND CMAKE_HIP_FLAGS " -Rpass-analysis=kernel-resource-usage")
+    endif()
+    if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
+      string(APPEND CMAKE_HIP_FLAGS " -ffast-math")
+    endif()
+    if(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
+      string(APPEND CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -O3")
     endif()
     string(REGEX REPLACE "(gfx1[0-9]+;?)" "" CMAKE_HIP_ARCHITECTURES "${CMAKE_HIP_ARCHITECTURES}") # ROCm currently doesn’t support integrated graphics
     if(HIP_AMDGPUTARGET)
       set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}") # If GPU build is enforced we override autodetection
     endif()
-    if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
-      string(APPEND O2_HIP_CMAKE_CXX_FLAGS " -fgpu-flush-denormals-to-zero -ffast-math")
-    endif()
-    set(CMAKE_HIP_FLAGS "${O2_GPU_CMAKE_CXX_FLAGS_NOSTD} ${CMAKE_HIP_FLAGS} ${O2_HIP_CMAKE_CXX_FLAGS}")
-    set(CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
-    if(CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-      set(CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O0 -ggdb")
-    else()
-      set(CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O3")
-    endif()
   else()
     set(HIP_ENABLED OFF)
   endif()

From d1fcd960548af1fbc975638e8b08abb44482d2dd Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Mar 2025 09:29:05 +0100
Subject: [PATCH 0150/1764] GPU HIP CMake: Remove deprecated option

---
 dependencies/FindO2GPU.cmake | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index d796d0b7145a8..bbbb420354fae 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -291,9 +291,6 @@ if(ENABLE_HIP)
     set(CMAKE_HIP_FLAGS "${O2_GPU_CMAKE_CXX_FLAGS_NOSTD} ${CMAKE_HIP_FLAGS} ${GPUCA_HIP_DENORMALS_FLAGS}")
     set(CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
     string(APPEND CMAKE_HIP_FLAGS " -fgpu-defer-diag -mllvm -amdgpu-enable-lower-module-lds=false -mllvm -amdgpu-function-calls=true -Wno-invalid-command-line-argument -Wno-unused-command-line-argument -Wno-invalid-constexpr -Wno-ignored-optimization-argument -Wno-unused-private-field -Wno-pass-failed ")
-    if(hip_VERSION VERSION_GREATER_EQUAL "6.0" AND NOT hip_VERSION VERSION_GREATER_EQUAL "6.2")
-      string(APPEND CMAKE_HIP_FLAGS " -mllvm -amdgpu-legacy-sgpr-spill-lowering=true") # TODO: Cleanup
-    endif()
     if(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE)
       string(APPEND CMAKE_HIP_FLAGS " -Rpass-analysis=kernel-resource-usage")
     endif()

From 210dc61adc0b14ee8e4ae62916d442dd02ed3f50 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 27 Mar 2025 15:57:38 +0100
Subject: [PATCH 0151/1764] DPL: make input slots display in DebugGUI
 scrollable (#14041)

---
 .../Core/include/Framework/DeviceControl.h    |  2 +
 .../src/FrameworkGUIDataRelayerUsage.cxx      | 95 ++++++++++++++-----
 .../src/FrameworkGUIDataRelayerUsage.h        |  5 +-
 .../src/FrameworkGUIDevicesGraph.cxx          |  3 +-
 4 files changed, 79 insertions(+), 26 deletions(-)

diff --git a/Framework/Core/include/Framework/DeviceControl.h b/Framework/Core/include/Framework/DeviceControl.h
index ce946e8e77fbf..03889c00f6cf9 100644
--- a/Framework/Core/include/Framework/DeviceControl.h
+++ b/Framework/Core/include/Framework/DeviceControl.h
@@ -52,6 +52,8 @@ struct DeviceControl {
   int logStreams = 0;
   /// An incremental number to identify the device state
   int requestedState = 0;
+  /// The first window in the records buffer to display in GUI
+  int firstWnd = 1;
 };
 
 } // namespace o2::framework
diff --git a/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx b/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
index 8e683d46131ea..c39e268fa90a7 100644
--- a/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
@@ -17,8 +17,7 @@
 #include "Framework/DataProcessingStates.h"
 #include "InspectorHelpers.h"
 #include "PaletteHelpers.h"
-#include "Framework/Logger.h"
-#include <iostream>
+#include "FrameworkGUIDataRelayerUsage.h"
 #include <cstring>
 #include <cmath>
 
@@ -27,11 +26,11 @@ static inline ImVec2 operator-(const ImVec2& lhs, const ImVec2& rhs) { return Im
 
 namespace o2::framework::gui
 {
-
 // This is to display the information in the data relayer
 struct HeatMapHelper {
   template <typename RECORD, typename ITEM>
-  static void draw(const char* name,
+  static void draw(const char* /*name*/,
+                   int& v,
                    ImVec2 const& sizeHint,
                    std::function<size_t()> const& getNumInputs,
                    std::function<size_t()> const& getNumRecords,
@@ -42,21 +41,69 @@ struct HeatMapHelper {
                    std::function<ImU32(int value)> const& getColor,
                    std::function<void(int row, int column)> const& describeCell)
   {
-    ImVec2 size = ImVec2(sizeHint.x, std::min(sizeHint.y, 16.f * getNumItems(0) + 2));
-    ImU32 BORDER_COLOR = ImColor(200, 200, 200, 255);
-    ImU32 BACKGROUND_COLOR = ImColor(20, 20, 20, 255);
+    float padding = 1;
+    // add slider to scroll between the grid display windows
+    size_t nw = getNumRecords() / WND;
+    ImGui::PushItemWidth(sizeHint.x);
+    ImGui::SliderInt("##window", &v, 1, nw, "wnd: %d", ImGuiSliderFlags_AlwaysClamp);
+    ImVec2 sliderMin = ImGui::GetItemRectMin();
+
     constexpr float MAX_BOX_X_SIZE = 16.f;
     constexpr float MAX_BOX_Y_SIZE = 16.f;
+
+    ImVec2 size = ImVec2(sizeHint.x, std::min(sizeHint.y, MAX_BOX_Y_SIZE * getNumItems(0) + 2));
+    ImU32 BORDER_COLOR = ImColor(200, 200, 200, 255);
+    ImU32 BACKGROUND_COLOR = ImColor(20, 20, 20, 255);
+    ImU32 BORDER_COLOR_A = ImColor(200, 200, 200, 0);
+    ImU32 BACKGROUND_COLOR_A = ImColor(0, 0, 0, 0);
+
     ImDrawList* drawList = ImGui::GetWindowDrawList();
-    ImVec2 winPos = ImGui::GetCursorScreenPos() + ImVec2{0, 7};
-    auto records = getNumRecords();
-    auto boxSizeX = std::min(size.x / records, MAX_BOX_X_SIZE);
-    auto numInputs = getNumInputs();
+    ImVec2 winPos = sliderMin;
 
+    // overlay activity indicator on the slider
+    auto xsz = size.x / nw;
+    drawList->AddRectFilled(
+      ImVec2{0., 0.} + winPos,
+      ImVec2{size.x, size.y} + winPos,
+      BACKGROUND_COLOR_A);
+    drawList->AddRect(
+      ImVec2{0. - 1, -1} + winPos,
+      ImVec2{size.x + 1, size.y - 1} + winPos,
+      BORDER_COLOR_A);
+
+    const static auto colorA = ImColor(ImVec4{0.945, 0.096, 0.278, 0.5});
+    const static auto colorE = ImColor(ImVec4{0, 0, 0, 0});
+
+    drawList->PrimReserve(nw * 6, nw * 4);
+    for (size_t iw = 0; iw < nw; ++iw) {
+      ImVec2 xOffset{iw * xsz + 2 * padding, 0};
+      ImVec2 xSize{xsz - 2 * padding, 0};
+      ImVec2 yOffset{0, 2 * padding};
+      ImVec2 ySize{0, 16 - 4 * padding};
+      bool active = 0;
+      for (size_t ir = iw; ir < ((iw + WND > getNumRecords()) ? getNumRecords() : iw + WND); ++ir) {
+        for (size_t i = 0; i < getNumItems(ir); ++i) {
+          active = getValue(*getItem(ir, i)) > 0;
+          if (active) {
+            break;
+          }
+        }
+      }
+      drawList->PrimRect(
+        xOffset + yOffset + winPos,
+        xOffset + xSize + yOffset + ySize + winPos,
+        active ? colorA : colorE);
+    }
+
+    // display the grid
+    size_t recordsWindow = v * WND;
+    auto boxSizeX = std::min(size.x / WND, MAX_BOX_X_SIZE);
+    auto numInputs = getNumInputs();
+    winPos = ImGui::GetCursorScreenPos() + ImVec2{0, 7};
     ImGui::InvisibleButton("sensible area", ImVec2(size.x, size.y));
     if (ImGui::IsItemHovered()) {
       auto pos = ImGui::GetMousePos() - winPos;
-      auto slot = std::lround(std::trunc(pos.x / size.x * records));
+      auto slot = (v - 1) * WND + std::lround(std::trunc(pos.x / size.x * WND));
       auto row = std::lround(std::trunc(pos.y / size.y * numInputs));
       describeCell(row, slot);
     }
@@ -69,21 +116,21 @@ struct HeatMapHelper {
       ImVec2(0. - 1, -1) + winPos,
       ImVec2{size.x + 1, size.y - 1} + winPos,
       BORDER_COLOR);
-    float padding = 1;
 
     size_t totalRects = 0;
-    for (size_t ri = 0, re = getNumRecords(); ri < re; ri++) {
+    for (size_t ri = (v - 1) * WND; ri < recordsWindow; ri++) {
       auto record = getRecord(ri);
       totalRects += getNumItems(record);
     }
 
     drawList->PrimReserve(totalRects * 6, totalRects * 4);
-    for (size_t ri = 0, re = getNumRecords(); ri < re; ri++) {
+    for (size_t ri = (v - 1) * WND; ri < recordsWindow; ri++) {
       auto record = getRecord(ri);
-      ImVec2 xOffset{(ri * boxSizeX) + padding, 0};
+      ImVec2 xOffset{((ri - (v - 1) * WND) * boxSizeX) + padding, 0};
       ImVec2 xSize{boxSizeX - 2 * padding, 0};
-      auto boxSizeY = std::min(size.y / getNumItems(record), MAX_BOX_Y_SIZE);
-      for (size_t mi = 0, me = getNumItems(record); mi < me; mi++) {
+      auto me = getNumItems(record);
+      auto boxSizeY = std::min(size.y / me, MAX_BOX_Y_SIZE);
+      for (size_t mi = 0; mi < me; mi++) {
         ImVec2 yOffSet{0, (mi * boxSizeY) + padding};
         ImVec2 ySize{0, boxSizeY - 2 * padding};
 
@@ -98,11 +145,12 @@ struct HeatMapHelper {
   }
 };
 
-void displayDataRelayer(DeviceMetricsInfo const& metrics,
-                        DeviceInfo const& info,
+void displayDataRelayer(DeviceMetricsInfo const& /*metrics*/,
+                        DeviceInfo const& /*info*/,
                         DeviceSpec const& spec,
                         DataProcessingStates const& states,
-                        ImVec2 const& size)
+                        ImVec2 const& size,
+                        int& v)
 {
   auto getNumInputs = [&states]() -> size_t {
     auto& inputsView = states.statesViews[(int)ProcessingStateId::DATA_QUERIES];
@@ -146,7 +194,7 @@ void displayDataRelayer(DeviceMetricsInfo const& metrics,
     }
     char const* const beginData = strchr(buffer + view.first, ' ') + 1;
     // Protect against buffer overflows
-    if (view.size <= beginData - buffer + i - view.first) {
+    if ((size_t)view.size <= beginData - buffer + i - view.first) {
       return &error;
     }
     return (int8_t const*)beginData + i; };
@@ -184,7 +232,7 @@ void displayDataRelayer(DeviceMetricsInfo const& metrics,
       if ((end - input) == 0) {
         continue;
       }
-      if (i == row) {
+      if (i == (size_t)row) {
         ImGui::Text("%d %.*s (%s)", row, int(end - input), input, InspectorHelpers::getLifeTimeStr(spec.inputs[i].matcher.lifetime).c_str());
         break;
       }
@@ -226,6 +274,7 @@ void displayDataRelayer(DeviceMetricsInfo const& metrics,
 
   if (getNumRecords()) {
     HeatMapHelper::draw<int, int8_t>("DataRelayer",
+                                     v,
                                      size,
                                      getNumInputs,
                                      getNumRecords,
diff --git a/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.h b/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.h
index 8c4941474d8a7..8bea06829f0dc 100644
--- a/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.h
+++ b/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.h
@@ -9,6 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include "Framework/DeviceSpec.h"
 class ImVec2;
 
 namespace o2::framework
@@ -19,9 +20,9 @@ class DataProcessingStates;
 
 namespace gui
 {
-
+static constexpr int WND = 16;
 /// View of the DataRelayer metrics for a given DeviceInfo
-void displayDataRelayer(DeviceMetricsInfo const& metrics, DeviceInfo const& info, DeviceSpec const& spec, DataProcessingStates const&, ImVec2 const& size);
+void displayDataRelayer(DeviceMetricsInfo const& metrics, DeviceInfo const& info, DeviceSpec const& spec, DataProcessingStates const&, ImVec2 const& size, int& v);
 
 } // namespace gui
 } // namespace o2::framework
diff --git a/Framework/GUISupport/src/FrameworkGUIDevicesGraph.cxx b/Framework/GUISupport/src/FrameworkGUIDevicesGraph.cxx
index 89126cf303a66..1c4ddd7e6aabf 100644
--- a/Framework/GUISupport/src/FrameworkGUIDevicesGraph.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDevicesGraph.cxx
@@ -713,7 +713,8 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
       default:
         break;
     }
-    gui::displayDataRelayer(metricsInfos[node->ID], infos[node->ID], specs[node->ID], allStates[node->ID], ImVec2(140., 90.));
+
+    gui::displayDataRelayer(metricsInfos[node->ID], infos[node->ID], specs[node->ID], allStates[node->ID], ImVec2(200., 160.), controls[node->ID].firstWnd);
     ImGui::EndGroup();
 
     // Save the size of what we have emitted and whether any of the widgets are being used

From 1c4e4a6be81b8b9762db927ebfdf5c636cda23ed Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 27 Mar 2025 16:51:56 +0100
Subject: [PATCH 0152/1764] DPL: allow searching for plugins in executables as
 well (#14118)

---
 Framework/Core/include/Framework/PluginManager.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/PluginManager.h b/Framework/Core/include/Framework/PluginManager.h
index d6b16f01ad713..96281942e667d 100644
--- a/Framework/Core/include/Framework/PluginManager.h
+++ b/Framework/Core/include/Framework/PluginManager.h
@@ -87,7 +87,7 @@ struct PluginManager {
 #else
         auto libraryName = fmt::format("lib{}.so", loadablePlugin.library);
 #endif
-        auto ret = uv_dlopen(libraryName.c_str(), &handle);
+        auto ret = uv_dlopen(loadablePlugin.library.empty() ? nullptr : libraryName.c_str(), &handle);
         if (ret != 0) {
           LOGP(error, "Could not load library {}", loadablePlugin.library);
           LOG(error) << uv_dlerror(&handle);

From 243279af0b17985227f1f3d0aa80794c1549122b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Mar 2025 11:12:37 +0100
Subject: [PATCH 0153/1764] GPU Standalone: unify duplicate denormal code in
 standalone benchmark

---
 .../Standalone/Benchmark/standalone.cxx       | 22 ----------
 GPU/GPUTracking/utils/qmaths_helpers.h        | 41 +++++++++++--------
 2 files changed, 25 insertions(+), 38 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index e9cb7c5179c59..2e3e4725bd6aa 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -53,9 +53,6 @@
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUSettings.h"
 #include <vector>
-#if not(defined(__ARM_NEON) or defined(__aarch64__)) // ARM doesn't have SSE
-#include <xmmintrin.h>
-#endif
 
 #include "GPUO2DataTypes.h"
 #include "GPUChainITS.h"
@@ -85,23 +82,6 @@ std::atomic<uint32_t> nIteration, nIterationEnd;
 std::vector<GPUTrackingInOutPointers> ioPtrEvents;
 std::vector<GPUChainTracking::InOutMemory> ioMemEvents;
 
-void SetCPUAndOSSettings()
-{
-#if not(defined(__ARM_NEON) or defined(__aarch64__)) // ARM doesn't have SSE
-#ifdef FE_DFL_DISABLE_SSE_DENORMS_ENV                // Flush and load denormals to zero in any case
-  fesetenv(FE_DFL_DISABLE_SSE_DENORMS_ENV);
-#else
-#ifndef _MM_FLUSH_ZERO_ON
-#define _MM_FLUSH_ZERO_ON 0x8000
-#endif
-#ifndef _MM_DENORMALS_ZERO_ON
-#define _MM_DENORMALS_ZERO_ON 0x0040
-#endif
-  _mm_setcsr(_mm_getcsr() | (_MM_FLUSH_ZERO_ON | _MM_DENORMALS_ZERO_ON));
-#endif
-#endif // ARM
-}
-
 int32_t ReadConfiguration(int argc, char** argv)
 {
   int32_t qcRet = qConfigParse(argc, (const char**)argv);
@@ -740,8 +720,6 @@ int32_t main(int argc, char** argv)
 {
   std::unique_ptr<GPUReconstruction> recUnique, recUniqueAsync, recUniquePipeline;
 
-  SetCPUAndOSSettings();
-
   if (ReadConfiguration(argc, argv)) {
     return 1;
   }
diff --git a/GPU/GPUTracking/utils/qmaths_helpers.h b/GPU/GPUTracking/utils/qmaths_helpers.h
index 9c5f704180aaa..5eb3ce4fb2483 100644
--- a/GPU/GPUTracking/utils/qmaths_helpers.h
+++ b/GPU/GPUTracking/utils/qmaths_helpers.h
@@ -15,24 +15,33 @@
 #ifndef QMATH_HELPERS_H
 #define QMATH_HELPERS_H
 
-#if defined __has_include
-#if __has_include(<xmmintrin.h>) && __has_include(<pmmintrin.h>)
-#include <xmmintrin.h>
-#include <pmmintrin.h>
-#if defined(_MM_FLUSH_ZERO_OFF) && defined(_MM_DENORMALS_ZERO_ON)
+#if !(defined(__ARM_NEON) || defined(__aarch64__)) && __has_include(<xmmintrin.h>) // clang-format off
+  #include <xmmintrin.h>
+  #if __has_include(<pmmintrin.h>)
+    #include <pmmintrin.h>
+  #endif
+#elif __has_include(<cfenv>)
+  #include <cfenv>
+#endif
+
 static void disable_denormals()
 {
-  _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
-  _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
+#if !(defined(__ARM_NEON) || defined(__aarch64__)) && __has_include(<xmmintrin.h>) // clang-format off
+  #if defined(_MM_FLUSH_ZERO_OFF) && defined(_MM_DENORMALS_ZERO_ON)
+    _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
+    _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
+  #else
+    #ifndef _MM_FLUSH_ZERO_ON
+      #define _MM_FLUSH_ZERO_ON 0x8000
+    #endif
+    #ifndef _MM_DENORMALS_ZERO_ON
+      #define _MM_DENORMALS_ZERO_ON 0x0040
+    #endif
+    _mm_setcsr(_mm_getcsr() | (_MM_FLUSH_ZERO_ON | _MM_DENORMALS_ZERO_ON));
+  #endif
+#elif __has_include(<cfenv>) && defined(FE_DFL_DISABLE_SSE_DENORMS_ENV)
+  fesetenv(FE_DFL_DISABLE_SSE_DENORMS_ENV);
+#endif // clang-format on
 }
-#define XMM_HAS_DENORMAL_DEACTIVATE
-#endif
-#endif
-#endif
-#ifdef XMM_HAS_DENORMAL_DEACTIVATE
-#undef XMM_HAS_DENORMAL_DEACTIVATE
-#else
-static void disable_denormals() {}
-#endif
 
 #endif

From 6d54cfc154ca9370a30dc5f212e9e40fd972fde1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 26 Mar 2025 22:18:27 +0100
Subject: [PATCH 0154/1764] GPU: Make launch bounds of GPUDefParamters
 available as C++ struct at runtime

---
 GPU/Common/GPUCommonDef.h                     |   2 +-
 GPU/GPUTracking/Base/GPUConstantMem.h         |   4 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  22 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |   7 +-
 .../Base/GPUReconstructionKernelMacros.h      |  27 +-
 .../Base/GPUReconstructionKernels.h           |  12 +-
 .../Base/GPUReconstructionProcessing.cxx      |  24 ++
 .../Base/GPUReconstructionProcessing.h        |   9 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        |  17 +-
 .../Base/cuda/GPUReconstructionCUDA.h         |   2 -
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |   5 +-
 .../Base/opencl/GPUReconstructionOCL.cxx      |   4 +
 .../Base/opencl/GPUReconstructionOCL.h        |   2 -
 .../opencl/GPUReconstructionOCLKernels.cxx    |   4 +-
 GPU/GPUTracking/CMakeLists.txt                |  12 +-
 GPU/GPUTracking/Definitions/GPUDef.h          |   2 +-
 .../Definitions/GPUDefConstantsAndSettings.h  |   4 +-
 .../Definitions/GPUDefParameters.template.h   |  27 ++
 ...Parameters.h => GPUDefParametersDefault.h} | 332 ++++++++++++++++--
 .../GPUDefParametersLoad.template.inc         |  56 +++
 GPU/GPUTracking/Standalone/CMakeLists.txt     |   7 +-
 .../cmake/GPUNoFastMathKernels.template.h     |   5 +
 GPU/GPUTracking/kernels.cmake                 |   4 +-
 dependencies/FindO2GPU.cmake                  |   1 -
 24 files changed, 488 insertions(+), 103 deletions(-)
 create mode 100644 GPU/GPUTracking/Definitions/GPUDefParameters.template.h
 rename GPU/GPUTracking/Definitions/{GPUDefGPUParameters.h => GPUDefParametersDefault.h} (69%)
 create mode 100644 GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc

diff --git a/GPU/Common/GPUCommonDef.h b/GPU/Common/GPUCommonDef.h
index 78da104a0c029..d7e99f53d4ce8 100644
--- a/GPU/Common/GPUCommonDef.h
+++ b/GPU/Common/GPUCommonDef.h
@@ -58,7 +58,7 @@
 
 #if (defined(__CUDACC__) && defined(GPUCA_CUDA_NO_CONSTANT_MEMORY)) || (defined(__HIPCC__) && defined(GPUCA_HIP_NO_CONSTANT_MEMORY)) || (defined(__OPENCL__) && defined(GPUCA_OPENCL_NO_CONSTANT_MEMORY))
   #define GPUCA_NO_CONSTANT_MEMORY
-#elif defined(__CUDACC__) || defined(__HIPCC__)
+#elif (defined(__CUDACC__) || defined(__HIPCC__)) && !defined(GPUCA_GPUCODE_HOSTONLY)
   #define GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM
 #endif
 
diff --git a/GPU/GPUTracking/Base/GPUConstantMem.h b/GPU/GPUTracking/Base/GPUConstantMem.h
index e0b06f0a3ea55..532c270431d99 100644
--- a/GPU/GPUTracking/Base/GPUConstantMem.h
+++ b/GPU/GPUTracking/Base/GPUConstantMem.h
@@ -95,7 +95,7 @@ union GPUConstantMemCopyable {
 static constexpr size_t gGPUConstantMemBufferSize = (sizeof(GPUConstantMem) + sizeof(uint4) - 1);
 #endif
 } // namespace o2::gpu
-#if defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM) && !defined(GPUCA_GPUCODE_HOSTONLY)
+#if defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM)
 GPUconstant() o2::gpu::GPUConstantMemCopyable gGPUConstantMemBuffer; // TODO: This should go into o2::gpu namespace, but then CUDA or HIP would not find the symbol
 #endif // GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM
 namespace o2::gpu
@@ -104,7 +104,7 @@ namespace o2::gpu
 // Must be placed here, to avoid circular header dependency
 GPUdi() GPUconstantref() const GPUConstantMem* GPUProcessor::GetConstantMem() const
 {
-#if defined(GPUCA_GPUCODE_DEVICE) && defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM) && !defined(GPUCA_GPUCODE_HOSTONLY)
+#if defined(GPUCA_GPUCODE_DEVICE) && defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM)
   return &GPUCA_CONSMEM;
 #else
   return mConstantMem;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index a8a83fdbd9203..d5404618c32b1 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -16,7 +16,7 @@
 #include "GPUReconstructionIncludes.h"
 #include "GPUReconstructionThreading.h"
 #include "GPUChain.h"
-
+#include "GPUDefParameters.h"
 #include "GPUTPCClusterData.h"
 #include "GPUTPCSectorOutCluster.h"
 #include "GPUTPCGMMergedTrack.h"
@@ -120,15 +120,27 @@ void GPUReconstructionCPUBackend::runKernelBackend(const krnlSetupArgs<T, I, Arg
 #pragma GCC diagnostic push
 }
 
-template <class T, int32_t I>
-krnlProperties GPUReconstructionCPUBackend::getKernelPropertiesBackend()
+template <class S, int32_t I>
+gpu_reconstruction_kernels::krnlProperties GPUReconstructionCPU::getKernelProperties(int gpu)
 {
-  return krnlProperties{1, 1};
+  if (gpu == -1) {
+    gpu = IsGPU();
+  }
+  const auto num = GetKernelNum<S, I>();
+  const auto* p = gpu ? mParDevice : mParCPU;
+  gpu_reconstruction_kernels::krnlProperties ret = {p->par_LB_maxThreads[num], p->par_LB_minBlocks[num], p->par_LB_forceBlocks[num]};
+  if (ret.nThreads == 0) {
+    ret.nThreads = gpu ? mThreadCount : 1u;
+  }
+  if (ret.minBlocks == 0) {
+    ret.minBlocks = 1;
+  }
+  return ret;
 }
 
 #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)                                                                                                       \
   template void GPUReconstructionCPUBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args); \
-  template krnlProperties GPUReconstructionCPUBackend::getKernelPropertiesBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>();
+  template krnlProperties GPUReconstructionCPU::getKernelProperties<GPUCA_M_KRNL_TEMPLATE(x_class)>(int gpu);
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index fd999ec2304e1..099fed5afacf0 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -38,8 +38,6 @@ class GPUReconstructionCPUBackend : public GPUReconstructionProcessing
   void runKernelBackend(const gpu_reconstruction_kernels::krnlSetupArgs<T, I, Args...>& args);
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackendInternal(const gpu_reconstruction_kernels::krnlSetupTime& _xyz, const Args&... args);
-  template <class T, int32_t I>
-  gpu_reconstruction_kernels::krnlProperties getKernelPropertiesBackend();
 };
 
 class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCPUBackend>
@@ -55,10 +53,7 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
   template <class S, int32_t I = 0, typename... Args>
   void runKernel(krnlSetup&& setup, Args&&... args);
   template <class S, int32_t I = 0>
-  const gpu_reconstruction_kernels::krnlProperties getKernelProperties()
-  {
-    return getKernelPropertiesImpl(gpu_reconstruction_kernels::classArgument<S, I>());
-  }
+  gpu_reconstruction_kernels::krnlProperties getKernelProperties(int gpu = -1);
 
   virtual int32_t GPUDebug(const char* state = "UNKNOWN", int32_t stream = -1, bool force = false);
   int32_t GPUStuck() { return mGPUStuck; }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
index 0b1a501ebc094..b3f6c6ec817fd 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
@@ -38,21 +38,18 @@
 #ifndef GPUCA_KRNL_CUSTOM
 #define GPUCA_KRNL_CUSTOM(...)
 #endif
-#define GPUCA_KRNL_REG_EXTRREG(...) GPUCA_M_STRIP(__VA_ARGS__)
-#define GPUCA_KRNL_CUSTOM_EXTRREG(MODE, ...) GPUCA_ATTRRES_XCUSTOM(MODE, __VA_ARGS__)
-#define GPUCA_KRNL_NONE_EXTRREG(MODE, ...) GPUCA_ATTRRES_XNONE(MODE, __VA_ARGS__)
-#define GPUCA_ATTRRES_REG(MODE, reg, num, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_KRNL_REG, MODE))(num) GPUCA_ATTRRES_XREG (MODE, __VA_ARGS__)
-#define GPUCA_ATTRRES_CUSTOM(MODE, custom, args, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_KRNL_CUSTOM, MODE))(args) GPUCA_ATTRRES_XCUSTOM(MODE, __VA_ARGS__)
-#define GPUCA_ATTRRES_NONE(MODE, none, ...) GPUCA_ATTRRES_XNONE(MODE, __VA_ARGS__)
-#define GPUCA_ATTRRES_(MODE, ...)
-#define GPUCA_ATTRRES_XNONE(MODE, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(MODE, __VA_ARGS__)
-#define GPUCA_ATTRRES_XCUSTOM(MODE, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(MODE, __VA_ARGS__)
-#define GPUCA_ATTRRES_XREG(MODE, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(MODE, __VA_ARGS__)
-#define GPUCA_ATTRRES(MODE, ...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(MODE, __VA_ARGS__)
+#define GPUCA_ATTRRES_REG(reg, num, ...) GPUCA_M_EXPAND(GPUCA_KRNL_REG)(num) GPUCA_ATTRRES_XREG (__VA_ARGS__)
+#define GPUCA_ATTRRES_CUSTOM(custom, args, ...) GPUCA_M_EXPAND(GPUCA_KRNL_CUSTOM)(args) GPUCA_ATTRRES_XCUSTOM(__VA_ARGS__)
+#define GPUCA_ATTRRES_NONE(none, ...) GPUCA_ATTRRES_XNONE(__VA_ARGS__)
+#define GPUCA_ATTRRES_(...)
+#define GPUCA_ATTRRES_XNONE(...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(__VA_ARGS__)
+#define GPUCA_ATTRRES_XCUSTOM(...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(__VA_ARGS__)
+#define GPUCA_ATTRRES_XREG(...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(__VA_ARGS__)
+#define GPUCA_ATTRRES(...) GPUCA_M_EXPAND(GPUCA_M_CAT(GPUCA_ATTRRES_, GPUCA_M_FIRST(__VA_ARGS__)))(__VA_ARGS__)
 
 // GPU Kernel entry point
 #define GPUCA_KRNLGPU_DEF(x_class, x_attributes, x_arguments, ...) \
-  GPUg() void GPUCA_ATTRRES(, GPUCA_M_STRIP(x_attributes)) GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))(GPUCA_CONSMEM_PTR int32_t _iSector_internal GPUCA_M_STRIP(x_arguments))
+  GPUg() void GPUCA_ATTRRES(GPUCA_M_STRIP(x_attributes)) GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))(GPUCA_CONSMEM_PTR int32_t _iSector_internal GPUCA_M_STRIP(x_arguments))
 
 #ifdef GPUCA_KRNL_DEFONLY
 #define GPUCA_KRNLGPU(...) GPUCA_KRNLGPU_DEF(__VA_ARGS__);
@@ -79,12 +76,6 @@
     } \
   };
 
-#define GPUCA_KRNL_PROP(x_class, x_attributes) \
-  template <> gpu_reconstruction_kernels::krnlProperties GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::getKernelPropertiesBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>() { \
-    gpu_reconstruction_kernels::krnlProperties ret = gpu_reconstruction_kernels::krnlProperties{GPUCA_ATTRRES(_EXTRREG, GPUCA_M_STRIP(x_attributes))}; \
-    return ret.nThreads > 0 ? ret : gpu_reconstruction_kernels::krnlProperties{(int32_t)mThreadCount}; \
-  }
-
 #endif // GPUCA_GPUCODE
 
 #define GPUCA_KRNL_LB(x_class, x_attributes, ...) GPUCA_KRNL(x_class, (REG, (GPUCA_M_CAT(GPUCA_LB_, GPUCA_M_KRNL_NAME(x_class))), GPUCA_M_STRIP(x_attributes)), __VA_ARGS__)
diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernels.h b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
index b8f3e3746c743..f3d52da8b5613 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernels.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
@@ -95,14 +95,10 @@ class GPUReconstructionKernels : public T
   template <class S, int32_t I = 0, typename... Args>
   using krnlSetupArgs = gpu_reconstruction_kernels::krnlSetupArgs<S, I, Args...>;
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)                                                                              \
-  virtual void runKernelImpl(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args)                                          \
-  {                                                                                                                                                     \
-    T::template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(args);                                                                                 \
-  }                                                                                                                                                     \
-  virtual gpu_reconstruction_kernels::krnlProperties getKernelPropertiesImpl(gpu_reconstruction_kernels::classArgument<GPUCA_M_KRNL_TEMPLATE(x_class)>) \
-  {                                                                                                                                                     \
-    return T::template getKernelPropertiesBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>();                                                                    \
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)                                     \
+  virtual void runKernelImpl(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args) \
+  {                                                                                                            \
+    T::template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(args);                                        \
   }
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
index bae95ac8d3f38..58df7f01823dc 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
@@ -12,11 +12,35 @@
 /// \file GPUReconstructionProcessing.cxx
 /// \author David Rohr
 
+#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
+#include "GPUDefParametersDefault.h"
+#include "GPUDefParametersLoad.inc"
+
 #include "GPUReconstructionProcessing.h"
 #include "GPUReconstructionThreading.h"
 
 using namespace o2::gpu;
 
+GPUReconstructionProcessing::GPUReconstructionProcessing(const GPUSettingsDeviceBackend& cfg) : GPUReconstruction(cfg)
+{
+  if (mMaster == nullptr) {
+    mParCPU = new GPUDefParameters(o2::gpu::internal::GPUDefParametersLoad());
+    mParDevice = new GPUDefParameters();
+  } else {
+    GPUReconstructionProcessing* master = dynamic_cast<GPUReconstructionProcessing*>(mMaster);
+    mParCPU = master->mParCPU;
+    mParDevice = master->mParDevice;
+  }
+}
+
+GPUReconstructionProcessing::~GPUReconstructionProcessing()
+{
+  if (mMaster == nullptr) {
+    delete mParCPU;
+    delete mParDevice;
+  }
+}
+
 int32_t GPUReconstructionProcessing::getNKernelHostThreads(bool splitCores)
 {
   int32_t nThreads = 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index b0466efceac24..f539c91b90a6e 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -25,6 +25,8 @@
 namespace o2::gpu
 {
 
+struct GPUDefParameters;
+
 namespace gpu_reconstruction_kernels
 {
 struct deviceEvent {
@@ -63,7 +65,7 @@ class threadContext
 class GPUReconstructionProcessing : public GPUReconstruction
 {
  public:
-  ~GPUReconstructionProcessing() override = default;
+  ~GPUReconstructionProcessing() override;
 
   // Threading
   int32_t getNKernelHostThreads(bool splitCores);
@@ -101,7 +103,7 @@ class GPUReconstructionProcessing : public GPUReconstruction
   };
 
  protected:
-  GPUReconstructionProcessing(const GPUSettingsDeviceBackend& cfg) : GPUReconstruction(cfg) {}
+  GPUReconstructionProcessing(const GPUSettingsDeviceBackend& cfg);
   using deviceEvent = gpu_reconstruction_kernels::deviceEvent;
 
   static const std::vector<std::string> mKernelNames;
@@ -132,6 +134,9 @@ class GPUReconstructionProcessing : public GPUReconstruction
   template <class T, int32_t J = -1>
   HighResTimer& getTimer(const char* name, int32_t num = -1);
 
+  GPUDefParameters* mParCPU = nullptr;
+  GPUDefParameters* mParDevice = nullptr;
+
  private:
   uint32_t getNextTimerId();
   timerMeta* getTimerById(uint32_t id, bool increment = true);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index f87d5c8189cdc..8790d7718f517 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -13,8 +13,13 @@
 /// \author David Rohr
 
 #define GPUCA_GPUCODE_HOSTONLY
-#include "GPUReconstructionCUDAIncludesHost.h"
 
+#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
+#include "GPUReconstructionCUDADef.h"
+#include "GPUDefParametersDefault.h"
+#include "GPUDefParametersLoad.inc"
+
+#include "GPUReconstructionCUDAIncludesHost.h"
 #include <cuda_profiler_api.h>
 
 #include "GPUReconstructionCUDA.h"
@@ -51,11 +56,14 @@ GPUReconstructionCUDABackend::GPUReconstructionCUDABackend(const GPUSettingsDevi
 {
   if (mMaster == nullptr) {
     mInternals = new GPUReconstructionCUDAInternals;
+    *mParDevice = o2::gpu::internal::GPUDefParametersLoad();
   }
+  mDeviceBackendSettings.deviceType = DeviceType::CUDA;
 }
 
 GPUReconstructionCUDABackend::~GPUReconstructionCUDABackend()
 {
+  Exit(); // Make sure we destroy everything (in particular the ITS tracker) before we exit CUDA
   if (mMaster == nullptr) {
     delete mInternals;
   }
@@ -69,7 +77,6 @@ int32_t GPUReconstructionCUDABackend::GPUChkErrInternal(const int64_t error, con
 
 GPUReconstructionCUDA::GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionKernels(cfg)
 {
-  mDeviceBackendSettings.deviceType = DeviceType::CUDA;
 #ifndef __HIPCC__ // CUDA
   mRtcSrcExtension = ".cu";
   mRtcBinExtension = ".fatbin";
@@ -78,11 +85,7 @@ GPUReconstructionCUDA::GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg
   mRtcBinExtension = ".o";
 #endif
 }
-
-GPUReconstructionCUDA::~GPUReconstructionCUDA()
-{
-  Exit(); // Make sure we destroy everything (in particular the ITS tracker) before we exit CUDA
-}
+GPUReconstructionCUDA::~GPUReconstructionCUDA() {}
 
 GPUReconstruction* GPUReconstruction_Create_CUDA(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionCUDA(cfg); }
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index a98b14a873ca0..ac5920f769f25 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -44,8 +44,6 @@ class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
   void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
-  template <class T, int32_t I = 0>
-  gpu_reconstruction_kernels::krnlProperties getKernelPropertiesBackend();
 
   void getRTCKernelCalls(std::vector<std::string>& kernels);
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index 4b3f8a767226c..2596d0e19ec48 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -83,16 +83,13 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
 
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1 // ---------- COMPILE_MODE = perkernel ----------
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) \
-  GPUCA_KRNL_PROP(x_class, x_attributes)                                   \
-  template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 #else // ---------- COMPILE_MODE = onefile | rdc ----------
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 2
 #define GPUCA_KRNL_DEFONLY // COMPILE_MODE = rdc
 #endif
 
 #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) \
-  GPUCA_KRNL_PROP(x_class, x_attributes)                                   \
   GPUCA_KRNL_HOST(x_class, x_attributes, x_arguments, x_forward, x_types)  \
   template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index e724f0f2cbfcd..7310b8b6041a9 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -12,7 +12,10 @@
 /// \file GPUReconstructionOCL.cxx
 /// \author David Rohr
 
+#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
 #include "GPUReconstructionOCLIncludesHost.h"
+#include "GPUDefParametersDefault.h"
+#include "GPUDefParametersLoad.inc"
 
 #include <map>
 
@@ -36,6 +39,7 @@ GPUReconstructionOCLBackend::GPUReconstructionOCLBackend(const GPUSettingsDevice
 {
   if (mMaster == nullptr) {
     mInternals = new GPUReconstructionOCLInternals;
+    *mParDevice = o2::gpu::internal::GPUDefParametersLoad();
   }
   mDeviceBackendSettings.deviceType = DeviceType::OCL;
 }
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index 29951cd43f167..16ef9b5e87fe8 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -58,8 +58,6 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
   int32_t AddKernel();
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
-  template <class T, int32_t I = 0>
-  gpu_reconstruction_kernels::krnlProperties getKernelPropertiesBackend();
 
   GPUReconstructionOCLInternals* mInternals;
   float mOclVersion;
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index fff69038c056f..f71336ac35e0e 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -91,8 +91,6 @@ int32_t GPUReconstructionOCLBackend::AddKernels()
   return 0;
 }
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) \
-  GPUCA_KRNL_PROP(x_class, x_attributes)                                   \
-  template void GPUReconstructionOCLBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) template void GPUReconstructionOCLBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 39218e9f94527..33715909e810c 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -129,7 +129,7 @@ set(HDRS_INSTALL
     DataTypes/GPUTriggerOutputs.h
     Debug/GPUROOTDump.h
     Definitions/GPUDefConstantsAndSettings.h
-    Definitions/GPUDefGPUParameters.h
+    Definitions/GPUDefParametersDefault.h
     Definitions/GPUDef.h
     Definitions/GPUDefMacros.h
     Definitions/GPULogging.h
@@ -247,10 +247,18 @@ file(GENERATE
      OUTPUT include_gpu_onthefly/GPUNoFastMathKernels.h
      INPUT cmake/GPUNoFastMathKernels.template.h
 )
+file(GENERATE
+     OUTPUT include_gpu_onthefly/GPUDefParameters.h
+     INPUT Definitions/GPUDefParameters.template.h
+)
+file(GENERATE
+     OUTPUT include_gpu_onthefly/GPUDefParametersLoad.inc
+     INPUT Definitions/GPUDefParametersLoad.template.inc
+)
 if(NOT ALIGPU_BUILD_TYPE STREQUAL "O2")
   include_directories(${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
 endif()
-set(HDRS_INSTALL ${HDRS_INSTALL} ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUReconstructionKernelList.h)
+set(HDRS_INSTALL ${HDRS_INSTALL} ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUReconstructionKernelList.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParameters.h)
 include(kernels.cmake)
 
 # Optional sources depending on optional dependencies
diff --git a/GPU/GPUTracking/Definitions/GPUDef.h b/GPU/GPUTracking/Definitions/GPUDef.h
index f01e3e6d38332..404f35f971c94 100644
--- a/GPU/GPUTracking/Definitions/GPUDef.h
+++ b/GPU/GPUTracking/Definitions/GPUDef.h
@@ -18,7 +18,7 @@
 
 #include "GPUCommonDef.h"
 #include "GPUDefConstantsAndSettings.h"
-#include "GPUDefGPUParameters.h"
+#include "GPUDefParametersDefault.h"
 #include "GPUCommonRtypes.h"
 
 // Macros for masking ptrs in OpenCL kernel calls as uint64_t (The API only allows us to pass buffer objects)
diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index f18390629f2bc..2d7aca8d71b92 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 // This files contains compile-time constants affecting the GPU algorithms / reconstruction results.
-// Architecture-dependant compile-time constants affecting the performance without changing the results are stored in GPUDefGPUParameters.h
+// Architecture-dependant compile-time constants affecting the performance without changing the results are stored in GPUDefParameters.h
 
 #ifndef GPUDEFCONSTANTSANDSETTINGS_H
 #define GPUDEFCONSTANTSANDSETTINGS_H
@@ -66,7 +66,7 @@
   #endif
 #endif
 
-//#define GPUCA_MERGER_BY_MC_LABEL                    // Use MC labels for TPC track merging - for performance studies
+//#define GPUCA_MERGER_BY_MC_LABEL                    // Use MC labels for TPC track merging - for performance studies // TODO: Cleanup unneeded options
 //#define GPUCA_FULL_CLUSTERDATA                      // Store all cluster information in the cluster data, also those not needed for tracking.
 //#define GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME        // Propagate Pad, Row, Time cluster information to GM
 //#define GPUCA_GM_USE_FULL_FIELD                     // Use offline magnetic field during GMPropagator prolongation
diff --git a/GPU/GPUTracking/Definitions/GPUDefParameters.template.h b/GPU/GPUTracking/Definitions/GPUDefParameters.template.h
new file mode 100644
index 0000000000000..731cb76b89193
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/GPUDefParameters.template.h
@@ -0,0 +1,27 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDefParameters.h
+/// \author David Rohr
+
+#ifndef GPUDEFPARAMETERS_H
+#define GPUDEFPARAMETERS_H
+
+namespace o2::gpu
+{
+struct GPUDefParameters {  // clang-format off
+  int32_t par_LB_maxThreads[$<LIST:LENGTH,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>>] = {};
+  int32_t par_LB_minBlocks[$<LIST:LENGTH,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>>] = {};
+  int32_t par_LB_forceBlocks[$<LIST:LENGTH,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>>] = {};
+};  // clang-format on
+}  // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
similarity index 69%
rename from GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
rename to GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
index 910907368e891..7051fff2f177d 100644
--- a/GPU/GPUTracking/Definitions/GPUDefGPUParameters.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUDefGPUParameters.h
+/// \file GPUDefParametersDefault.h
 /// \author David Rohr
 
 // This files contains compile-time constants affecting the GPU performance.
@@ -17,14 +17,10 @@
 // This file also contains all constants describing memory limitations, essentially limiting the total number of tracks, etc.
 // Compile-time constants affecting the tracking algorithms / results are located in GPUDefConstantsAndSettings.h
 
-#ifndef GPUDEFGPUPARAMETERS_H
-#define GPUDEFGPUPARAMETERS_H
+#ifndef GPUDEFPARAMETERSDEFAULT_H
+#define GPUDEFPARAMETERSDEFAULT_H
 // clang-format off
 
-#ifndef GPUDEF_H
-#error Please include GPUDef.h
-#endif
-
 #include "GPUCommonDef.h"
 #include "GPUDefMacros.h"
 
@@ -282,7 +278,7 @@
 #endif // GPUCA_GPUCODE
 
 #ifdef GPUCA_GPUCODE
-  // Default settings, if not already set for selected GPU type
+  // Default settings for GPU, if not already set for selected GPU type
   #ifndef GPUCA_THREAD_COUNT
     #define GPUCA_THREAD_COUNT 256
   #endif
@@ -334,10 +330,10 @@
   #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_sortPerSectorRow
     #define GPUCA_LB_GPUTPCDecompressionUtilKernels_sortPerSectorRow 256
   #endif
-    #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters
+  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters
     #define GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters 256
   #endif
-    #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters
+  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters
     #define GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters 256
   #endif
   #ifndef GPUCA_LB_GPUTPCCFDecodeZS
@@ -487,10 +483,15 @@
   #ifndef GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov
     #define GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov 256
   #endif
+  #ifndef GPUCA_LB_GPUMemClean16
+    #define GPUCA_LB_GPUMemClean16 GPUCA_THREAD_COUNT, 1
+  #endif
+  #ifndef GPUCA_LB_GPUitoa
+    #define GPUCA_LB_GPUitoa GPUCA_THREAD_COUNT, 1
+  #endif
   #define GPUCA_GET_THREAD_COUNT(...) GPUCA_M_FIRST(__VA_ARGS__)
 #else
-  // The following defaults are needed to compile the host code
-  #define GPUCA_GET_THREAD_COUNT(...) 1
+  #define GPUCA_GET_THREAD_COUNT(...) 1 // On the host, a thread is a block, and we run 1 "device thread" per block.
 #endif
 
 #define GPUCA_GET_WARP_COUNT(...) (GPUCA_GET_THREAD_COUNT(__VA_ARGS__) / GPUCA_WARP_SIZE)
@@ -523,33 +524,33 @@
 #define GPUCA_LB_GPUTPCCompressionGatherKernels_multiBlock GPUCA_LB_COMPRESSION_GATHER
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
-#define GPUCA_SPECIALIZE_THRUST_SORTS
+  #define GPUCA_SPECIALIZE_THRUST_SORTS
 #endif
 
 #ifndef GPUCA_NEIGHBORSFINDER_REGS
-#define GPUCA_NEIGHBORSFINDER_REGS NONE, 0
+  #define GPUCA_NEIGHBORSFINDER_REGS NONE, 0
 #endif
 #ifdef GPUCA_GPUCODE
   #ifndef GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 6
+     #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 6
   #endif
   #ifndef GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 12
+     #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 12
   #endif
   #ifndef GPUCA_ALTERNATE_BORDER_SORT
-  #define GPUCA_ALTERNATE_BORDER_SORT 0
+     #define GPUCA_ALTERNATE_BORDER_SORT 0
   #endif
   #ifndef GPUCA_SORT_BEFORE_FIT
-  #define GPUCA_SORT_BEFORE_FIT 0
+     #define GPUCA_SORT_BEFORE_FIT 0
   #endif
   #ifndef GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
+     #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
   #endif
   #ifndef GPUCA_COMP_GATHER_KERNEL
-  #define GPUCA_COMP_GATHER_KERNEL 0
+     #define GPUCA_COMP_GATHER_KERNEL 0
   #endif
   #ifndef GPUCA_COMP_GATHER_MODE
-  #define GPUCA_COMP_GATHER_MODE 2
+     #define GPUCA_COMP_GATHER_MODE 2
   #endif
 #else
   #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
@@ -562,20 +563,20 @@
   #define GPUCA_COMP_GATHER_MODE 0
 #endif
 #ifndef GPUCA_DEDX_STORAGE_TYPE
-#define GPUCA_DEDX_STORAGE_TYPE float
+  #define GPUCA_DEDX_STORAGE_TYPE float
 #endif
 #ifndef GPUCA_MERGER_INTERPOLATION_ERROR_TYPE
-#define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
 #endif
 #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)
 #define GPUCA_DEDX_STORAGE_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_DEDX_STORAGE_TYPE)
 
 #ifndef GPUCA_WARP_SIZE
-#ifdef GPUCA_GPUCODE
-#define GPUCA_WARP_SIZE 32
-#else
-#define GPUCA_WARP_SIZE 1
-#endif
+  #ifdef GPUCA_GPUCODE
+    #define GPUCA_WARP_SIZE 32
+  #else
+    #define GPUCA_WARP_SIZE 1
+  #endif
 #endif
 
 #define GPUCA_MAX_THREADS 1024
@@ -602,10 +603,10 @@
 
 // #define GPUCA_KERNEL_DEBUGGER_OUTPUT
 
-// Some assertions to make sure out parameters are not invalid
-static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP, "Invalid GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP");
-static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE");
-#ifdef GPUCA_GPUCODE
+// Some assertions to make sure the parameters are not invalid
+#if defined(GPUCA_GPUCODE)
+  static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP, "Invalid GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP");
+  static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE");
   static_assert(GPUCA_M_FIRST(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE, "Invalid GPUCA_TPC_COMP_CHUNK_SIZE");
 #endif
 
@@ -621,5 +622,270 @@ static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid
 #define GPUCA_NEW_ALIGNMENT (std::align_val_t{GPUCA_BUFFER_ALIGNMENT})
 #define GPUCA_OPERATOR_NEW_ALIGNMENT ,GPUCA_NEW_ALIGNMENT
 
+#ifdef GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
+  // Invalid default values, must not be used, but needed for now to make the GPUDefParametersLoad() happy // TOCO: cleanup
+  #ifndef GPUCA_LB_GPUTPCCreateTrackingData
+    #define GPUCA_LB_GPUTPCCreateTrackingData 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCTrackletConstructor
+    #define GPUCA_LB_GPUTPCTrackletConstructor 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCTrackletSelector
+    #define GPUCA_LB_GPUTPCTrackletSelector 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCNeighboursFinder
+    #define GPUCA_LB_GPUTPCNeighboursFinder 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCNeighboursCleaner
+    #define GPUCA_LB_GPUTPCNeighboursCleaner 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCExtrapolationTracking
+    #define GPUCA_LB_GPUTPCExtrapolationTracking 0
+  #endif
+  #ifndef GPUCA_LB_GPUTRDTrackerKernels_gpuVersion
+    #define GPUCA_LB_GPUTRDTrackerKernels_gpuVersion 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCreateOccupancyMap_fill
+    #define GPUCA_LB_GPUTPCCreateOccupancyMap_fill 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCreateOccupancyMap_fold
+    #define GPUCA_LB_GPUTPCCreateOccupancyMap_fold 0
+  #endif
+  #ifndef GPUCA_LB_GPUTRDTrackerKernels_o2Version
+    #define GPUCA_LB_GPUTRDTrackerKernels_o2Version 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCConvertKernel
+    #define GPUCA_LB_GPUTPCConvertKernel 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCompressionKernels_step0attached
+    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCompressionKernels_step1unattached
+    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCDecompressionKernels_step0attached
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCDecompressionKernels_step1unattached
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_sortPerSectorRow
+    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_sortPerSectorRow 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters
+    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters
+    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFDecodeZS
+    #define GPUCA_LB_GPUTPCCFDecodeZS 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFDecodeZSLink
+    #define GPUCA_LB_GPUTPCCFDecodeZSLink 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFDecodeZSDenseLink
+    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFGather
+    #define GPUCA_LB_GPUTPCCFGather 0
+  #endif
+  #ifndef GPUCA_LB_COMPRESSION_GATHER
+    #define GPUCA_LB_COMPRESSION_GATHER 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerTrackFit
+    #define GPUCA_LB_GPUTPCGMMergerTrackFit 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerFollowLoopers
+    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerSectorRefit
+    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerUnpackResetIds
+    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerUnpackGlobal
+    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step0
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step1
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step2
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step3
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step4
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerClearLinks
+    #define GPUCA_LB_GPUTPCGMMergerClearLinks 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare
+    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare
+    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_step0
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_step2
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeCE
+    #define GPUCA_LB_GPUTPCGMMergerMergeCE 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks
+    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerCollect
+    #define GPUCA_LB_GPUTPCGMMergerCollect 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerSortTracksPrepare
+    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step0
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_step0 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step1
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_step1 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step2
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_step2 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step0
+    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step0 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step1
+    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step1 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step2
+    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step2 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMO2Output_prepare
+    #define GPUCA_LB_GPUTPCGMO2Output_prepare 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMO2Output_output
+    #define GPUCA_LB_GPUTPCGMO2Output_output 0
+  #endif
+  #ifndef GPUCA_LB_GPUITSFitterKernels
+    #define GPUCA_LB_GPUITSFitterKernels 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCStartHitsFinder
+    #define GPUCA_LB_GPUTPCStartHitsFinder 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCStartHitsSorter
+    #define GPUCA_LB_GPUTPCStartHitsSorter 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFCheckPadBaseline
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFPeakFinder
+    #define GPUCA_LB_GPUTPCCFPeakFinder 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFNoiseSuppression
+    #define GPUCA_LB_GPUTPCCFNoiseSuppression 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFDeconvolution
+    #define GPUCA_LB_GPUTPCCFDeconvolution 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFClusterizer
+    #define GPUCA_LB_GPUTPCCFClusterizer 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCNNClusterizerKernels
+    #define GPUCA_LB_GPUTPCNNClusterizerKernels 0
+  #endif
+  #ifndef GPUCA_LB_GPUTrackingRefitKernel_mode0asGPU
+    #define GPUCA_LB_GPUTrackingRefitKernel_mode0asGPU 0
+  #endif
+  #ifndef GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov
+    #define GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov 0
+  #endif
+  #ifndef GPUCA_LB_GPUMemClean16
+    #define GPUCA_LB_GPUMemClean16 0
+  #endif
+  #ifndef GPUCA_LB_GPUitoa
+    #define GPUCA_LB_GPUitoa 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCExtrapolationTrackingCopyNumbers
+    #define GPUCA_LB_GPUTPCExtrapolationTrackingCopyNumbers 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCSectorDebugSortKernels_hitData
+    #define GPUCA_LB_GPUTPCSectorDebugSortKernels_hitData 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCSectorDebugSortKernels_startHits
+    #define GPUCA_LB_GPUTPCSectorDebugSortKernels_startHits 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCSectorDebugSortKernels_sectorTracks
+    #define GPUCA_LB_GPUTPCSectorDebugSortKernels_sectorTracks 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_clearIds
+    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_clearIds 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_sectorTracks
+    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_sectorTracks 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_extrapolatedTracks1
+    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_extrapolatedTracks1 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_extrapolatedTracks2
+    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_extrapolatedTracks2 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_borderTracks
+    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_borderTracks 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerUnpackSaveNumber
+    #define GPUCA_LB_GPUTPCGMMergerUnpackSaveNumber 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_step1
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step1 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_variant
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_variant 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerSortTracks
+    #define GPUCA_LB_GPUTPCGMMergerSortTracks 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMMergerSortTracksQPt
+    #define GPUCA_LB_GPUTPCGMMergerSortTracksQPt 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMO2Output_sort
+    #define GPUCA_LB_GPUTPCGMO2Output_sort 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCGMO2Output_mc
+    #define GPUCA_LB_GPUTPCGMO2Output_mc 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFMCLabelFlattener_setRowOffsets
+    #define GPUCA_LB_GPUTPCCFMCLabelFlattener_setRowOffsets 0
+  #endif
+  #ifndef GPUCA_LB_GPUTPCCFMCLabelFlattener_flatten
+    #define GPUCA_LB_GPUTPCCFMCLabelFlattener_flatten 0
+  #endif
+#endif // GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
+
 // clang-format on
-#endif
+#endif // GPUDEFPARAMETERSDEFAULT_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
new file mode 100644
index 0000000000000..953750b6f925b
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
@@ -0,0 +1,56 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDefParametersLoad.inc
+/// \author David Rohr
+
+#include "GPUDefParameters.h"
+#include "GPUDefMacros.h"
+#include <sstream>
+#include <string>
+
+namespace o2::gpu::internal
+{
+
+static GPUDefParameters GPUDefParametersLoad()
+{
+  return GPUDefParameters{
+    // clang-format off
+    {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_LB_>,APPEND,)>,$<COMMA>>},
+    {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_LB_>,APPEND,$<COMMA>0))>,$<COMMA>>},
+    {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_M_SHIFT(GPUCA_LB_>,APPEND,$<COMMA>0$<COMMA>0)))>,$<COMMA>>}
+    // clang-format on
+  };
+}
+
+#define GPUCA_EXPORT_KERNEL(name)                                      \
+  if (par.par_LB_maxThreads[i] > 0) {                                  \
+    o << "#define " GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i]; \
+    if (par.par_LB_minBlocks[i] > 0) {                                 \
+      o << ", " << par.par_LB_minBlocks[i];                            \
+    }                                                                  \
+    if (par.par_LB_forceBlocks[i] > 0) {                               \
+      o << ", " << par.par_LB_forceBlocks[i];                          \
+    }                                                                  \
+    o << "\n";                                                         \
+  }                                                                    \
+  i++;
+
+static std::string GPUDefParametersExport(const GPUDefParameters& par)
+{
+  std::stringstream o; // clang-format off
+  int32_t i = 0;
+  $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_EXPORT_KERNEL(>,APPEND,)>,
+  >
+  return o.str(); // clang-format on
+}
+
+} // namespace o2::gpu::internal
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index ed4fc5c9f7e2d..dfc8e8db3bc7a 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -62,8 +62,11 @@ if (GPUCA_BUILD_DEBUG_SANITIZE)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -shared-libasan")
   endif()
 endif()
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error -Wall -Wextra -Wshadow -Wno-unused-function -Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unknown-pragmas -Wno-write-strings -Wno-vla-cxx-extension")
-set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -rdynamic -Wl,--no-undefined")
+string(APPEND CMAKE_CXX_FLAGS " -Wno-error -Wall -Wextra -Wshadow -Wno-unused-function -Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unknown-pragmas -Wno-write-strings")
+string(APPEND CMAKE_SHARED_LINKER_FLAGS " -rdynamic -Wl,--no-undefined")
+if(CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
+  string(APPEND CMAKE_CXX_FLAGS " -Wno-vla-cxx-extension")
+endif()
 
 # Find mandatory packages
 find_package(TBB REQUIRED)
diff --git a/GPU/GPUTracking/cmake/GPUNoFastMathKernels.template.h b/GPU/GPUTracking/cmake/GPUNoFastMathKernels.template.h
index dac93277d5ec9..499672bf00b50 100644
--- a/GPU/GPUTracking/cmake/GPUNoFastMathKernels.template.h
+++ b/GPU/GPUTracking/cmake/GPUNoFastMathKernels.template.h
@@ -12,6 +12,9 @@
 /// \file GPUNoFastMathKernels.h
 /// \author David Rohr
 
+#ifndef GPUNOFASTMATHKERNELS_H
+#define GPUNOFASTMATHKERNELS_H
+
 #include <unordered_set>
 #include <string>
 
@@ -21,3 +24,5 @@ namespace o2::gpu::internal
 static const std::unordered_set<std::string> noFastMathKernels = {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:REMOVE_DUPLICATES,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NO_FAST_MATH>>,APPEND,">,PREPEND,">,$<COMMA> >};
 // clang-format on
 } // namespace o2::gpu::internal
+
+#endif
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index ad348a84264f0..6d8b49116accc 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -37,8 +37,8 @@ o2_gpu_add_kernel("GPUTPCStartHitsSorter"                             "= TPCTRAC
 o2_gpu_add_kernel("GPUTPCTrackletConstructor, singleSector"           "= TPCTRACKER"                                          LB)
 o2_gpu_add_kernel("GPUTPCTrackletConstructor, allSectors"             "= TPCTRACKER"                                          LB)
 o2_gpu_add_kernel("GPUTPCTrackletSelector"                            "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUMemClean16"                                     "GPUGeneralKernels"                                     "NO_REG, (GPUCA_THREAD_COUNT, 1)" void* ptr "uint64_t" size)
-o2_gpu_add_kernel("GPUitoa"                                           "GPUGeneralKernels"                                     "NO_REG, (GPUCA_THREAD_COUNT, 1)" int32_t* ptr "uint64_t" size)
+o2_gpu_add_kernel("GPUMemClean16"                                     "GPUGeneralKernels"                                     NO void* ptr "uint64_t" size)
+o2_gpu_add_kernel("GPUitoa"                                           "GPUGeneralKernels"                                     NO int32_t* ptr "uint64_t" size)
 o2_gpu_add_kernel("GPUTPCExtrapolationTrackingCopyNumbers"            "GPUTPCExtrapolationTracking TPCTRACKER"                NO int32_t n)
 o2_gpu_add_kernel("GPUTPCExtrapolationTracking"                       "= TPCTRACKER TPCTRACKLETCONS"                          LB)
 o2_gpu_add_kernel("GPUTPCCreateTrackingData"                          "= TPCTRACKER TPCSECTORDATA"                            LB)
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index bbbb420354fae..95db55041184f 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -82,7 +82,6 @@ elseif(NOT GPUCA_DETERMINISTIC_MODE MATCHES "^[0-9]+$")
     message(FATAL_ERROR "Invalid setting ${GPUCA_DETERMINISTIC_MODE} for GPUCA_DETERMINISTIC_MODE")
   endif()
   set(GPUCA_DETERMINISTIC_MODE ${GPUCA_DETERMINISTIC_MODE_MAP_${GPUCA_DETERMINISTIC_MODE}})
-  message(STATUS "Set to ${GPUCA_DETERMINISTIC_MODE}")
 endif()
 if (CMAKE_SYSTEM_NAME MATCHES Darwin OR NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
   set(GPUCA_CXX_DENORMALS_FLAGS "")

From a0e63ef302252475223531d74e7871dd942c951d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Mar 2025 15:52:06 +0100
Subject: [PATCH 0155/1764] GPU TPC: Drop unused TrackletConstructor_allSectors
 kernel

---
 .../Definitions/GPUDefParametersDefault.h     |  2 -
 .../Global/GPUChainTrackingSectorTracker.cxx  |  2 +-
 .../GPUTPCTrackletConstructor.cxx             | 75 +------------------
 .../SectorTracker/GPUTPCTrackletConstructor.h | 11 +--
 GPU/GPUTracking/kernels.cmake                 |  3 +-
 5 files changed, 4 insertions(+), 89 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
index 7051fff2f177d..1193731acd9cf 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
@@ -515,8 +515,6 @@
 #define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_THREAD_COUNT_SCAN
 #define GPUCA_LB_GPUTPCCFStreamCompaction_scanDown GPUCA_THREAD_COUNT_SCAN
 #define GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits GPUCA_THREAD_COUNT_SCAN
-#define GPUCA_LB_GPUTPCTrackletConstructor_singleSector GPUCA_LB_GPUTPCTrackletConstructor
-#define GPUCA_LB_GPUTPCTrackletConstructor_allSectors GPUCA_LB_GPUTPCTrackletConstructor
 #define GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered GPUCA_LB_COMPRESSION_GATHER
 #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered32 GPUCA_LB_COMPRESSION_GATHER
 #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64 GPUCA_LB_COMPRESSION_GATHER
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index e161f74a31032..3e7447892307a 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -105,7 +105,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
       processorsShadow()->tpcTrackers[iSector].GPUParametersConst()->gpumem = (char*)mRec->DeviceMemoryBase();
       // Initialize Startup Constants
-      processors()->tpcTrackers[iSector].GPUParameters()->nextStartHit = (((getKernelProperties<GPUTPCTrackletConstructor, GPUTPCTrackletConstructor::allSectors>().minBlocks * BlockCount()) + NSECTORS - 1 - iSector) / NSECTORS) * getKernelProperties<GPUTPCTrackletConstructor, GPUTPCTrackletConstructor::allSectors>().nThreads;
+      processors()->tpcTrackers[iSector].GPUParameters()->nextStartHit = (((getKernelProperties<GPUTPCTrackletConstructor>().minBlocks * BlockCount()) + NSECTORS - 1 - iSector) / NSECTORS) * getKernelProperties<GPUTPCTrackletConstructor>().nThreads;
       processorsShadow()->tpcTrackers[iSector].SetGPUTextureBase(mRec->DeviceMemoryBase());
     }
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
index 5a7df0ba8b874..71df683eee1dc 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
@@ -476,7 +476,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::DoTracklet(GPUconstantref() GPUTPCT
 }
 
 template <>
-GPUdii() void GPUTPCTrackletConstructor::Thread<GPUTPCTrackletConstructor::singleSector>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& sMem, processorType& GPUrestrict() tracker)
+GPUdii() void GPUTPCTrackletConstructor::Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& sMem, processorType& GPUrestrict() tracker)
 {
   if (get_local_id(0) == 0) {
     sMem.mNStartHits = *tracker.NStartHits();
@@ -491,79 +491,6 @@ GPUdii() void GPUTPCTrackletConstructor::Thread<GPUTPCTrackletConstructor::singl
   }
 }
 
-template <>
-GPUdii() void GPUTPCTrackletConstructor::Thread<GPUTPCTrackletConstructor::allSectors>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& sMem, processorType& GPUrestrict() tracker0)
-{
-  GPUconstantref() GPUTPCTracker* GPUrestrict() pTracker = &tracker0;
-#ifdef GPUCA_GPUCODE
-  int32_t mySector = get_group_id(0) % GPUCA_NSECTORS;
-  int32_t currentSector = -1;
-
-  if (get_local_id(0) == 0) {
-    sMem.mNextStartHitFirstRun = 1;
-  }
-  GPUCA_UNROLL(, U())
-  for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-    GPUconstantref() GPUTPCTracker& GPUrestrict() tracker = pTracker[mySector];
-
-    GPUTPCThreadMemory rMem;
-
-    while ((rMem.mISH = FetchTracklet(tracker, sMem)) != -2) {
-      if (rMem.mISH >= 0 && get_local_id(0) < GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletConstructor)) {
-        rMem.mISH += get_local_id(0);
-      } else {
-        rMem.mISH = -1;
-      }
-
-      if (mySector != currentSector) {
-        if (get_local_id(0) == 0) {
-          sMem.mNStartHits = *tracker.NStartHits();
-        }
-        CA_SHARED_CACHE(&sMem.mRows[0], tracker.TrackingDataRows(), GPUCA_ROW_COUNT * sizeof(GPUTPCRow));
-        GPUbarrier();
-        currentSector = mySector;
-      }
-
-      if (rMem.mISH >= 0 && rMem.mISH < sMem.mNStartHits) {
-        rMem.mGo = true;
-        DoTracklet(tracker, sMem, rMem);
-      }
-    }
-    if (++mySector >= GPUCA_NSECTORS) {
-      mySector = 0;
-    }
-  }
-#else
-  for (int32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-    Thread<singleSector>(nBlocks, nThreads, iBlock, iThread, sMem, pTracker[iSector]);
-  }
-#endif
-}
-
-#ifdef GPUCA_GPUCODE
-
-GPUd() int32_t GPUTPCTrackletConstructor::FetchTracklet(GPUconstantref() GPUTPCTracker& GPUrestrict() tracker, GPUsharedref() GPUSharedMemory& sMem)
-{
-  const uint32_t nStartHit = *tracker.NStartHits();
-  GPUbarrier();
-  if (get_local_id(0) == 0) {
-    int32_t firstStartHit = -2;
-    if (sMem.mNextStartHitFirstRun == 1) {
-      firstStartHit = (get_group_id(0) - tracker.ISector()) / GPUCA_NSECTORS * GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletConstructor);
-      sMem.mNextStartHitFirstRun = 0;
-    } else {
-      if (tracker.GPUParameters()->nextStartHit < nStartHit) {
-        firstStartHit = CAMath::AtomicAdd<uint32_t>(&tracker.GPUParameters()->nextStartHit, GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletConstructor));
-      }
-    }
-    sMem.mNextStartHitFirst = firstStartHit < (int32_t)nStartHit ? firstStartHit : -2;
-  }
-  GPUbarrier();
-  return (sMem.mNextStartHitFirst);
-}
-
-#endif // GPUCA_GPUCODE
-
 template <> // FIXME: GPUgeneric() needed to make the clang spirv output link correctly
 GPUd() int32_t GPUTPCTrackletConstructor::GPUTPCTrackletConstructorExtrapolationTracking<GPUgeneric() GPUTPCExtrapolationTracking::GPUSharedMemory>(GPUconstantref() GPUTPCTracker& GPUrestrict() tracker, GPUsharedref() GPUTPCExtrapolationTracking::GPUSharedMemory& sMem, GPUTPCTrackParam& GPUrestrict() tParam, int32_t row, int32_t increment, int32_t iTracklet, calink* rowHits)
 {
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
index 0f8314ee0fad4..af87d0276f1c7 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
@@ -28,14 +28,9 @@ namespace o2::gpu
  */
 class GPUTPCTracker;
 
-class GPUTPCTrackletConstructor
+class GPUTPCTrackletConstructor : public GPUKernelTemplate
 {
  public:
-  enum K {
-    singleSector = 0,
-    allSectors = 1
-  };
-
   class GPUTPCThreadMemory
   {
     friend class GPUTPCTrackletConstructor; //! friend class
@@ -89,10 +84,6 @@ class GPUTPCTrackletConstructor
 
   GPUd() static void DoTracklet(GPUconstantref() GPUTPCTracker& tracker, GPUsharedref() GPUTPCTrackletConstructor::GPUSharedMemory& sMem, GPUTPCThreadMemory& rMem);
 
-#ifdef GPUCA_GPUCODE
-  GPUd() static int32_t FetchTracklet(GPUconstantref() GPUTPCTracker& tracker, GPUsharedref() GPUSharedMemory& sMem);
-#endif // GPUCA_GPUCODE
-
   template <class T>
   GPUd() static int32_t GPUTPCTrackletConstructorExtrapolationTracking(GPUconstantref() GPUTPCTracker& tracker, GPUsharedref() T& sMem, GPUTPCTrackParam& tParam, int32_t startrow, int32_t increment, int32_t iTracklet, calink* rowHits);
 
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 6d8b49116accc..994f10a516b10 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -34,8 +34,7 @@ o2_gpu_add_kernel("GPUTPCNeighboursFinder"                            "= TPCTRAC
 o2_gpu_add_kernel("GPUTPCNeighboursCleaner"                           "= TPCTRACKER"                                          LB)
 o2_gpu_add_kernel("GPUTPCStartHitsFinder"                             "= TPCTRACKER"                                          LB)
 o2_gpu_add_kernel("GPUTPCStartHitsSorter"                             "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUTPCTrackletConstructor, singleSector"           "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUTPCTrackletConstructor, allSectors"             "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCTrackletConstructor"                         "= TPCTRACKER"                                          LB)
 o2_gpu_add_kernel("GPUTPCTrackletSelector"                            "= TPCTRACKER"                                          LB)
 o2_gpu_add_kernel("GPUMemClean16"                                     "GPUGeneralKernels"                                     NO void* ptr "uint64_t" size)
 o2_gpu_add_kernel("GPUitoa"                                           "GPUGeneralKernels"                                     NO int32_t* ptr "uint64_t" size)

From a5caa277d89ede13c8a8161438a9c1eda1cb14a2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Mar 2025 17:00:24 +0100
Subject: [PATCH 0156/1764] GPU: Count kernel number in Cmake, and pass to
 MACROS, to simplify the preprocessor logic

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  2 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |  2 +-
 .../Base/GPUReconstructionProcessing.cxx      | 44 ++++++-------------
 .../Base/GPUReconstructionProcessing.h        |  2 +-
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  6 +--
 .../opencl/GPUReconstructionOCLKernels.cxx    |  2 +-
 GPU/GPUTracking/cmake/kernel_helpers.cmake    |  4 +-
 7 files changed, 24 insertions(+), 38 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index d5404618c32b1..d714c6833d18d 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -138,7 +138,7 @@ gpu_reconstruction_kernels::krnlProperties GPUReconstructionCPU::getKernelProper
   return ret;
 }
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)                                                                                                       \
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)                                                                                                  \
   template void GPUReconstructionCPUBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args); \
   template krnlProperties GPUReconstructionCPU::getKernelProperties<GPUCA_M_KRNL_TEMPLATE(x_class)>(int gpu);
 #include "GPUReconstructionKernelList.h"
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index 099fed5afacf0..48d6ddf17959a 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -72,7 +72,7 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
 
   GPUReconstructionCPU(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionKernels(cfg) {}
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)                                                                                                                   \
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)                                                                                                              \
   inline void runKernelImplWrapper(gpu_reconstruction_kernels::classArgument<GPUCA_M_KRNL_TEMPLATE(x_class)>, bool cpuFallback, double& timer, krnlSetup&& setup GPUCA_M_STRIP(x_arguments)) \
   {                                                                                                                                                                                          \
     if (cpuFallback) {                                                                                                                                                                       \
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
index 58df7f01823dc..95a47dec946e6 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
@@ -143,38 +143,22 @@ std::unique_ptr<gpu_reconstruction_kernels::threadContext> GPUReconstructionProc
 gpu_reconstruction_kernels::threadContext::threadContext() = default;
 gpu_reconstruction_kernels::threadContext::~threadContext() = default;
 
-template <class T, int32_t I>
-uint32_t GPUReconstructionProcessing::GetKernelNum(int32_t k)
-{
-  static int32_t num = k;
-  if (num < 0) {
-    throw std::runtime_error("Internal Error - Kernel Number not Set");
-  }
-  return num;
-}
-
-namespace o2::gpu::internal
-{
-static std::vector<std::string> initKernelNames()
-{
-  std::vector<std::string> retVal;
-#define GPUCA_KRNL(x_class, ...)                                                            \
-  GPUReconstructionProcessing::GetKernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>(retVal.size()); \
-  retVal.emplace_back(GPUCA_M_STR(GPUCA_M_KRNL_NAME(x_class)));
+const std::vector<std::string> GPUReconstructionProcessing::mKernelNames = {
+#define GPUCA_KRNL(x_class, ...) GPUCA_M_STR(GPUCA_M_KRNL_NAME(x_class)),
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
-  return retVal;
-}
-} // namespace o2::gpu::internal
-
-const std::vector<std::string> GPUReconstructionProcessing::mKernelNames = o2::gpu::internal::initKernelNames();
-
-#define GPUCA_KRNL(x_class, ...)                                                                        \
-  template uint32_t GPUReconstructionProcessing::GetKernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>(int32_t); \
-  template <>                                                                                           \
-  const char* GPUReconstructionProcessing::GetKernelName<GPUCA_M_KRNL_TEMPLATE(x_class)>()              \
-  {                                                                                                     \
-    return GPUCA_M_STR(GPUCA_M_KRNL_NAME(x_class));                                                     \
+};
+
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, x_num)          \
+  template <>                                                                              \
+  uint32_t GPUReconstructionProcessing::GetKernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>()     \
+  {                                                                                        \
+    return x_num;                                                                          \
+  }                                                                                        \
+  template <>                                                                              \
+  const char* GPUReconstructionProcessing::GetKernelName<GPUCA_M_KRNL_TEMPLATE(x_class)>() \
+  {                                                                                        \
+    return GPUCA_M_STR(GPUCA_M_KRNL_NAME(x_class));                                        \
   }
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index f539c91b90a6e..2428027118c0a 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -80,7 +80,7 @@ class GPUReconstructionProcessing : public GPUReconstruction
   static const char* GetKernelName();
   const std::string& GetKernelName(int32_t i) const { return mKernelNames[i]; }
   template <class T, int32_t I = 0>
-  static uint32_t GetKernelNum(int32_t k = -1);
+  static uint32_t GetKernelNum();
 
   // Public queries for timers
   auto& getRecoStepTimer(RecoStep step) { return mTimersRecoSteps[getRecoStepNum(step)]; }
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index 2596d0e19ec48..ac79dd7576e48 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -83,14 +83,14 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
 
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1 // ---------- COMPILE_MODE = perkernel ----------
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 #else // ---------- COMPILE_MODE = onefile | rdc ----------
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 2
 #define GPUCA_KRNL_DEFONLY // COMPILE_MODE = rdc
 #endif
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) \
-  GPUCA_KRNL_HOST(x_class, x_attributes, x_arguments, x_forward, x_types)  \
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)        \
+  GPUCA_KRNL_HOST(x_class, x_attributes, x_arguments, x_forward, x_types, __VA_ARGS__) \
   template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 
 #ifndef __HIPCC__ // CUDA version
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index f71336ac35e0e..cca634fba65fc 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -91,6 +91,6 @@ int32_t GPUReconstructionOCLBackend::AddKernels()
   return 0;
 }
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types) template void GPUReconstructionOCLBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) template void GPUReconstructionOCLBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index 99699cc72e940..3c1ad9658566b 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -64,7 +64,9 @@ function(o2_gpu_add_kernel kernel_name kernel_files)
   endif()
   set(TMP_PRE "")
   set(TMP_POST "")
-  set(TMP_KERNEL "GPUCA_KRNL${TMP_BOUNDS}((${kernel_name}), (${kernel_extra}), (${OPT1}), (${OPT2}), (${OPT3}))\n")
+  get_property(LIST_KERNELS TARGET O2_GPU_KERNELS PROPERTY O2_GPU_KERNELS)
+  list(LENGTH LIST_KERNELS KERNEL_COUNT)
+  set(TMP_KERNEL "GPUCA_KRNL${TMP_BOUNDS}((${kernel_name}), (${kernel_extra}), (${OPT1}), (${OPT2}), (${OPT3}), ${KERNEL_COUNT})\n")
   separate_arguments(kernel_files NATIVE_COMMAND ${kernel_files})
   list(GET kernel_files 0 TMP_KERNEL_CLASS_FILE)
   if (TMP_KERNEL_CLASS_FILE STREQUAL "=")

From 90f376389dafe933649987a4cdeaf3e03dcc01bf Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Mar 2025 17:02:08 +0100
Subject: [PATCH 0157/1764] GPU: Rewrite virtual kernel call to a single
 virtual function, should enable further simplifications in the future

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.h     |  6 ++++--
 GPU/GPUTracking/Base/GPUReconstructionKernels.h | 16 +++++++++++-----
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index 48d6ddf17959a..163b00c804d7f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -75,10 +75,12 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
 #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)                                                                                                              \
   inline void runKernelImplWrapper(gpu_reconstruction_kernels::classArgument<GPUCA_M_KRNL_TEMPLATE(x_class)>, bool cpuFallback, double& timer, krnlSetup&& setup GPUCA_M_STRIP(x_arguments)) \
   {                                                                                                                                                                                          \
+    krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)> args(setup.x, setup.y, setup.z, timer GPUCA_M_STRIP(x_forward));                                                    \
+    const uint32_t num = GetKernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>();                                                                                                                     \
     if (cpuFallback) {                                                                                                                                                                       \
-      GPUReconstructionCPU::runKernelImpl(krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>(setup.x, setup.y, setup.z, timer GPUCA_M_STRIP(x_forward)));                  \
+      GPUReconstructionCPU::runKernelImpl(num, &args);                                                                                                                                       \
     } else {                                                                                                                                                                                 \
-      runKernelImpl(krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>(setup.x, setup.y, setup.z, timer GPUCA_M_STRIP(x_forward)));                                        \
+      runKernelImpl(num, &args);                                                                                                                                                             \
     }                                                                                                                                                                                        \
   }
 #include "GPUReconstructionKernelList.h"
diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernels.h b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
index f3d52da8b5613..7f500d471de1f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernels.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
@@ -95,13 +95,19 @@ class GPUReconstructionKernels : public T
   template <class S, int32_t I = 0, typename... Args>
   using krnlSetupArgs = gpu_reconstruction_kernels::krnlSetupArgs<S, I, Args...>;
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types)                                     \
-  virtual void runKernelImpl(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args) \
-  {                                                                                                            \
-    T::template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(args);                                        \
-  }
+  virtual void runKernelImpl(const int num, const void* args)
+  {
+    switch (num) { // clang-format off
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, x_num)                               \
+      case x_num: {                                                                                             \
+        const auto& args2 = *(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>*)args; \
+        T::template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(args2);                                    \
+        break; \
+      }
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
+    } // clang-format on
+  }
 };
 
 } // namespace o2::gpu

From 3f679a66429822f285a152c16ee9959556bdba84 Mon Sep 17 00:00:00 2001
From: Andreas Molander <andreas.molander@cern.ch>
Date: Thu, 20 Mar 2025 10:43:35 +0200
Subject: [PATCH 0158/1764] FIT: Geometry alignment macros

- Make misalignment macros usable for creating exact misalignments
- Add macro for reading misalignments from CCDB
- Add a couple of plots to hit reading marcos (needed to verify misalignments)
- Minor change to FV0 geometry to provoding symbolic names of alignable volumes
---
 Detectors/FIT/FT0/macros/FT0Misaligner.C      | 44 ++++++++++------
 .../FIT/FV0/base/include/FV0Base/Geometry.h   | 12 +++++
 Detectors/FIT/FV0/macros/FV0Misaligner.C      | 46 ++++++++++++-----
 Detectors/FIT/FV0/simulation/src/Detector.cxx | 19 +++----
 Detectors/FIT/macros/CMakeLists.txt           |  4 ++
 Detectors/FIT/macros/readAlignParam.C         | 51 +++++++++++++++++++
 Detectors/FIT/macros/readFT0hits.C            | 29 +++++++++--
 Detectors/FIT/macros/readFV0hits.C            | 37 ++++++++++++--
 8 files changed, 196 insertions(+), 46 deletions(-)
 create mode 100644 Detectors/FIT/macros/readAlignParam.C

diff --git a/Detectors/FIT/FT0/macros/FT0Misaligner.C b/Detectors/FIT/FT0/macros/FT0Misaligner.C
index 7585411066934..9621d1a079bc9 100644
--- a/Detectors/FIT/FT0/macros/FT0Misaligner.C
+++ b/Detectors/FIT/FT0/macros/FT0Misaligner.C
@@ -1,15 +1,30 @@
+// Copyright 2021-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  FT0Misaligner.C
+/// \brief ROOT macro for creating an FT0 geometry alignment object. Based on ITSMisaligner.C
+///
+/// \author Andreas Molander andreas.molander@cern.ch, Alla Maevskaya
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
-//#define ENABLE_UPGRADES
+
+#include "CCDB/CcdbApi.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
 #include "DetectorsCommonDataFormats/AlignParam.h"
-#include "DetectorsBase/GeometryManager.h"
-#include "CCDB/CcdbApi.h"
-#include "FT0Base/Geometry.h"
-#include <TRandom.h>
+
 #include <TFile.h>
 #include <vector>
 #include <fmt/format.h>
+
 #endif
 
 using AlgPar = std::array<double, 6>;
@@ -23,19 +38,15 @@ void FT0Misaligner(const std::string& ccdbHost = "http://ccdb-test.cern.ch:8080"
                    const std::string& fileName = "FT0Alignment.root")
 {
   std::vector<o2::detectors::AlignParam> params;
-  o2::base::GeometryManager::loadGeometry("", false);
-  //  auto geom = o2::ft0::Geometry::Instance();
   AlgPar pars;
   bool glo = true;
 
   o2::detectors::DetID detFT0("FT0");
 
-  // FT0 detector
-  //set A side
   std::string symNameA = "FT0A";
   pars = generateMisalignment(xA, yA, zA, psiA, thetaA, phiA);
   params.emplace_back(symNameA.c_str(), -1, pars[0], pars[1], pars[2], pars[3], pars[4], pars[5], glo);
-  //set C side
+
   std::string symNameC = "FT0C";
   pars = generateMisalignment(xC, yC, zC, psiC, thetaC, phiC);
   params.emplace_back(symNameC.c_str(), -1, pars[0], pars[1], pars[2], pars[3], pars[4], pars[5], glo);
@@ -57,14 +68,15 @@ void FT0Misaligner(const std::string& ccdbHost = "http://ccdb-test.cern.ch:8080"
     algFile.Close();
   }
 }
+
 AlgPar generateMisalignment(double x, double y, double z, double psi, double theta, double phi)
 {
   AlgPar pars;
-  pars[0] = gRandom->Gaus(0, x);
-  pars[1] = gRandom->Gaus(0, y);
-  pars[2] = gRandom->Gaus(0, z);
-  pars[3] = gRandom->Gaus(0, psi);
-  pars[4] = gRandom->Gaus(0, theta);
-  pars[5] = gRandom->Gaus(0, phi);
+  pars[0] = x;
+  pars[1] = y;
+  pars[2] = z;
+  pars[3] = psi;
+  pars[4] = theta;
+  pars[5] = phi;
   return std::move(pars);
 }
diff --git a/Detectors/FIT/FV0/base/include/FV0Base/Geometry.h b/Detectors/FIT/FV0/base/include/FV0Base/Geometry.h
index 3b50be7441ec2..ec87c07c57c45 100644
--- a/Detectors/FIT/FV0/base/include/FV0Base/Geometry.h
+++ b/Detectors/FIT/FV0/base/include/FV0Base/Geometry.h
@@ -133,6 +133,16 @@ class Geometry
     return o2::base::GeometryManager::getPNEntry(getDetID(), index);
   }
 
+  static std::string getDetectorRightSymName()
+  {
+    return sDetectorRightName + "_0";
+  }
+
+  static std::string getDetectorLeftSymName()
+  {
+    return sDetectorLeftName + "_1";
+  }
+
   /// Get the density of the PMTs.
   static constexpr float getPmtDensity()
   {
@@ -143,6 +153,8 @@ class Geometry
   explicit Geometry(EGeoType initType);
 
   inline static const std::string sDetectorName = "FV0";
+  inline static const std::string sDetectorRightName = sDetectorName + "RIGHT";
+  inline static const std::string sDetectorLeftName = sDetectorName + "LEFT";
 
   // General geometry constants
   static constexpr float sEpsilon = 0.01;     ///< Used to make one spatial dimension infinitesimally larger than other
diff --git a/Detectors/FIT/FV0/macros/FV0Misaligner.C b/Detectors/FIT/FV0/macros/FV0Misaligner.C
index 500bdaf565965..88f7a0b82b8b3 100644
--- a/Detectors/FIT/FV0/macros/FV0Misaligner.C
+++ b/Detectors/FIT/FV0/macros/FV0Misaligner.C
@@ -1,13 +1,32 @@
+// Copyright 2021-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  FV0Misaligner.C
+/// \brief ROOT macro for creating an FV0 geometry alignment object. The alignment object will align both
+///        detector halves in the same way. Based on ITSMisaligner.C
+///
+/// \author Andreas Molander andreas.molander@cern.ch, Alla Maevskaya
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
+
+#include "CCDB/CcdbApi.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
 #include "DetectorsCommonDataFormats/AlignParam.h"
-#include "DetectorsBase/GeometryManager.h"
-#include "CCDB/CcdbApi.h"
-#include <TRandom.h>
+#include "FV0Base/Geometry.h"
+
 #include <TFile.h>
 #include <vector>
 #include <fmt/format.h>
+
 #endif
 
 using AlgPar = std::array<double, 6>;
@@ -20,16 +39,14 @@ void FV0Misaligner(const std::string& ccdbHost = "http://ccdb-test.cern.ch:8080"
                    const std::string& fileName = "FV0Alignment.root")
 {
   std::vector<o2::detectors::AlignParam> params;
-  o2::base::GeometryManager::loadGeometry("", false);
   AlgPar pars;
   bool glo = true;
 
   o2::detectors::DetID detFV0("FV0");
 
-  // FV0 detector
-  for (int ihalf = 1; ihalf < 3; ihalf++) {
-    std::string symName = Form("FV0half_%i", ihalf);
-    pars = generateMisalignment(x, y, z, psi, theta, phi);
+  pars = generateMisalignment(x, y, z, psi, theta, phi);
+
+  for (auto& symName : {o2::fv0::Geometry::getDetectorRightSymName(), o2::fv0::Geometry::getDetectorLeftSymName()}) {
     params.emplace_back(symName.c_str(), -1, pars[0], pars[1], pars[2], pars[3], pars[4], pars[5], glo);
   }
 
@@ -50,14 +67,15 @@ void FV0Misaligner(const std::string& ccdbHost = "http://ccdb-test.cern.ch:8080"
     algFile.Close();
   }
 }
+
 AlgPar generateMisalignment(double x, double y, double z, double psi, double theta, double phi)
 {
   AlgPar pars;
-  pars[0] = gRandom->Gaus(0, x);
-  pars[1] = gRandom->Gaus(0, y);
-  pars[2] = gRandom->Gaus(0, z);
-  pars[3] = gRandom->Gaus(0, psi);
-  pars[4] = gRandom->Gaus(0, theta);
-  pars[5] = gRandom->Gaus(0, phi);
+  pars[0] = x;
+  pars[1] = y;
+  pars[2] = z;
+  pars[3] = psi;
+  pars[4] = theta;
+  pars[5] = phi;
   return std::move(pars);
 }
diff --git a/Detectors/FIT/FV0/simulation/src/Detector.cxx b/Detectors/FIT/FV0/simulation/src/Detector.cxx
index 8cf1f5530e93d..07eb9053bf3b8 100644
--- a/Detectors/FIT/FV0/simulation/src/Detector.cxx
+++ b/Detectors/FIT/FV0/simulation/src/Detector.cxx
@@ -280,6 +280,7 @@ void Detector::ConstructGeometry()
   // mGeometry->enableComponent(Geometry::eAluminiumContainer, false);
   mGeometry->buildGeometry();
 }
+
 void Detector::addAlignableVolumes() const
 {
   //
@@ -292,19 +293,19 @@ void Detector::addAlignableVolumes() const
   LOG(info) << "FV0: Add alignable volumes";
 
   if (!gGeoManager) {
-    LOG(fatal) << "TGeoManager doesn't exist !";
+    LOG(fatal) << "TGeoManager doesn't exist!";
     return;
   }
 
-  TString volPath, symName;
-  for (auto& half : {"RIGHT_0", "LEFT_1"}) {
-    volPath = Form("/cave_1/barrel_1/FV0_1/FV0%s", half);
-    symName = Form("FV0%s", half);
-    LOG(info) << "FV0: Add alignable volume: " << symName << ": " << volPath;
-    if (!gGeoManager->SetAlignableEntry(symName.Data(), volPath.Data())) {
-      LOG(fatal) << "FV0: Unable to set alignable entry! " << symName << ": " << volPath;
+  auto addAlignabelVolume = [](const std::string& volPath, const std::string& symName) -> void {
+    LOG(info) << "FV0: Add alignable volume: " << symName << " <-> " << volPath;
+    if (!gGeoManager->SetAlignableEntry(symName.c_str(), volPath.c_str())) {
+      LOG(fatal) << "FV0: Unable to set alignable entry! " << symName << " <-> " << volPath;
     }
-  }
+  };
+
+  addAlignabelVolume("/cave_1/barrel_1/FV0_1/FV0RIGHT_0", Geometry::getDetectorRightSymName());
+  addAlignabelVolume("/cave_1/barrel_1/FV0_1/FV0LEFT_1", Geometry::getDetectorLeftSymName());
 }
 
 o2::fv0::Hit* Detector::addHit(Int_t trackId, Int_t cellId,
diff --git a/Detectors/FIT/macros/CMakeLists.txt b/Detectors/FIT/macros/CMakeLists.txt
index e7debb4184325..a6bf1799a5dde 100644
--- a/Detectors/FIT/macros/CMakeLists.txt
+++ b/Detectors/FIT/macros/CMakeLists.txt
@@ -45,5 +45,9 @@ o2_add_test_root_macro(compareRecPoints.C
                                              O2::DataFormatsFIT
                        LABELS fit)
 
+o2_add_test_root_macro(readAlignParam.C
+                       PUBLIC_LINK_LIBRARIES O2::CCDB
+                       LABELS fit)
+
 o2_data_file(COPY readFITDCSdata.C DESTINATION Detectors/FIT/macros/)
 o2_data_file(COPY readFITDeadChannelMap.C DESTINATION Detectors/FIT/macros/)
\ No newline at end of file
diff --git a/Detectors/FIT/macros/readAlignParam.C b/Detectors/FIT/macros/readAlignParam.C
new file mode 100644
index 0000000000000..c438e7a0c86a5
--- /dev/null
+++ b/Detectors/FIT/macros/readAlignParam.C
@@ -0,0 +1,51 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  readAlignParam.C
+/// \brief ROOT macro for reading geometry alignment parameters
+///
+/// \author Andreas Molander <andreas.molander@cern.ch>
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+
+#include "CCDB/BasicCCDBManager.h"
+#include "DetectorsCommonDataFormats/AlignParam.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "DetectorsCommonDataFormats/DetectorNameConf.h"
+
+#include <string>
+#include <vector>
+
+#endif
+
+int readAlignParam(const std::string& detectorName = "FT0",
+                   long timestamp = -1,
+                   const std::string& ccdbUrl = "https://alice-ccdb.cern.ch")
+{
+  o2::ccdb::BasicCCDBManager& ccdbManager = o2::ccdb::BasicCCDBManager::instance();
+  ccdbManager.setURL(ccdbUrl);
+  ccdbManager.setTimestamp(timestamp);
+
+  const o2::detectors::DetID detID(detectorName.c_str());
+  const std::string alignmentPath = o2::base::DetectorNameConf::getAlignmentPath(detID);
+  const auto alignments = ccdbManager.get<std::vector<o2::detectors::AlignParam>>(alignmentPath);
+
+  if (!alignments) {
+    std::cerr << "No alignment parameters found at " << alignmentPath << std::endl;
+    return 1;
+  }
+
+  for (auto alignment : *alignments) {
+    alignment.print();
+  }
+
+  return 0;
+}
\ No newline at end of file
diff --git a/Detectors/FIT/macros/readFT0hits.C b/Detectors/FIT/macros/readFT0hits.C
index 14d25fa4a99a8..fafcaac570311 100644
--- a/Detectors/FIT/macros/readFT0hits.C
+++ b/Detectors/FIT/macros/readFT0hits.C
@@ -1,13 +1,29 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
+
+#include "DataFormatsFIT/Triggers.h"
 #include "DataFormatsFT0/Digit.h"
 #include "DataFormatsFT0/HitType.h"
 #include "SimulationDataFormat/MCEventHeader.h"
 #include <TFile.h>
+#include <TH1F.h>
 #include <TH2F.h>
 #include <TTree.h>
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
 
+#endif
+
 void readFT0hits()
 {
 
@@ -24,6 +40,8 @@ void readFT0hits()
   TH2F* hPel = new TH2F("hPelDig", "N p.e. ", 220, 0, 220, 500, 0, 10000);
   TH2F* hXYA = new TH2F("hXYA", "X vs Y A side", 400, -20, 20, 400, -20, 20);
   TH2F* hXYC = new TH2F("hXYC", "X vs Y C side", 400, -20, 20, 400, -20, 20);
+  TH1F* hZA = new TH1F("hZA", "Z A side", 200, 330, 340);
+  TH1F* hZC = new TH1F("hZC", "Z C side", 200, -90, -80);
 
   gDirectory = cwd;
 
@@ -59,10 +77,13 @@ void readFT0hits()
       hTimeHitA->Fill(detID, hit_time[detID] - 11.04);
       hTimeHitC->Fill(detID, hit_time[detID] - 2.91);
       countE[detID]++;
-      if (detID < 96)
+      if (detID < 96) {
         hXYA->Fill(hit.GetX(), hit.GetY());
-      if (detID > 95)
+        hZA->Fill(hit.GetZ());
+      } else {
         hXYC->Fill(hit.GetX(), hit.GetY());
+        hZC->Fill(hit.GetZ());
+      }
     }
     for (int ii = 0; ii < 220; ii++) {
       if (countE[ii] > 100) {
@@ -82,6 +103,6 @@ void readFT0hits()
   hMultHit->Write();
   hXYA->Write();
   hXYC->Write();
-
+  hZA->Write();
+  hZC->Write();
 } // end of macro
-#endif
diff --git a/Detectors/FIT/macros/readFV0hits.C b/Detectors/FIT/macros/readFV0hits.C
index 5b0dfa8428dc7..933138fb1434b 100644
--- a/Detectors/FIT/macros/readFV0hits.C
+++ b/Detectors/FIT/macros/readFV0hits.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
 #include <TFile.h>
@@ -22,6 +33,8 @@
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 
+#endif
+
 void AdjustStatBox(TH1* h, float x1ndc, float x2ndc, float y1ndc, float y2ndc)
 {
   gPad->Update();
@@ -54,6 +67,9 @@ void InitHistoNames(std::vector<std::string>& vhName, std::vector<int>& vPdg)
   vhName.push_back("hElossDet");
   vhName.push_back("hEtotVsR");
   vhName.push_back("hEtotVsEloss");
+  vhName.push_back("hXY");
+  vhName.push_back("hXYzoom");
+  vhName.push_back("hZ");
 
   for (UInt_t ipdg = 0; ipdg < vPdg.size(); ipdg++) {
     std::stringstream ss;
@@ -63,7 +79,7 @@ void InitHistoNames(std::vector<std::string>& vhName, std::vector<int>& vPdg)
   }
 }
 
-void readFV0Hits(std::string simPrefix = "o2sim", UInt_t rebin = 1)
+void readFV0hits(std::string simPrefix = "o2sim", UInt_t rebin = 1)
 {
   using namespace o2::detectors;
   std::string simFName(o2::base::DetectorNameConf::getHitsFileName(DetID::FV0, simPrefix));
@@ -85,6 +101,9 @@ void readFV0Hits(std::string simPrefix = "o2sim", UInt_t rebin = 1)
   TH2F* hElossDet = new TH2F(vHistoNames.at(8).c_str(), "", nEl, 0, el1, nCells, 0, nCells);
   TH2F* hEtotVsR = new TH2F(vHistoNames.at(9).c_str(), "", 30000, 0, 300, 80, 0, 80);
   TH2F* hEtotVsEloss = new TH2F(vHistoNames.at(10).c_str(), "", 30000, 0, 300, nEl, 0, el1);
+  TH2F* hXY = new TH2F(vHistoNames.at(11).c_str(), "", 200, -100, 100, 200, -100, 100);
+  TH2F* hXYzoom = new TH2F(vHistoNames.at(12).c_str(), "", 200, -20, 20, 200, -20, 20);
+  TH1F* hZ = new TH1F(vHistoNames.at(13).c_str(), "", 200, 315, 325);
 
   // Setup histo properties
   hElossDet->SetXTitle("Energy loss [MeV]");
@@ -96,6 +115,14 @@ void readFV0Hits(std::string simPrefix = "o2sim", UInt_t rebin = 1)
   hEtotVsEloss->SetXTitle("Total energy at entrance [MeV]");
   hEtotVsEloss->SetYTitle("Energy loss [MeV]");
   hEtotVsEloss->SetZTitle("Counts");
+  hXY->SetXTitle("X [cm]");
+  hXY->SetYTitle("Y [cm]");
+  hXY->SetZTitle("Counts");
+  hXYzoom->SetXTitle("X [cm]");
+  hXYzoom->SetYTitle("Y [cm]");
+  hXYzoom->SetZTitle("Counts");
+  hZ->SetXTitle("Hit Z-coordinate [cm]");
+  hZ->SetYTitle("Counts");
   for (UInt_t ih = 0; ih < vhElossVsDistance.size(); ih++) {
     TH2F* h = vhElossVsDistance.at(ih);
     std::stringstream ss;
@@ -124,6 +151,9 @@ void readFV0Hits(std::string simPrefix = "o2sim", UInt_t rebin = 1)
   vh.push_back(hEtotVsEloss);
   vh.insert(vh.end(), vhElossVsDistance.begin(), vhElossVsDistance.end());
   vh.insert(vh.end(), vhElossVsEtot.begin(), vhElossVsEtot.end());
+  vh.push_back(hXY);
+  vh.push_back(hXYzoom);
+  vh.push_back(hZ);
   for (UInt_t ih = 0; ih < vh.size(); ih++) {
     vh[ih]->SetDirectory(0);
     vh[ih]->GetXaxis()->SetTitleSize(fontsize);
@@ -177,6 +207,9 @@ void readFV0Hits(std::string simPrefix = "o2sim", UInt_t rebin = 1)
         vhElossVsDistance.at(vhElossVsDistance.size() - 1)->Fill(hit->GetEnergyLoss() * 1e3, distance);
         vhElossVsEtot.at(vhElossVsEtot.size() - 1)->Fill(hit->GetEnergyLoss() * 1e3, hit->GetTotalEnergyAtEntrance() * 1e3);
       }
+      hXY->Fill(hit->GetX(), hit->GetY());
+      hXYzoom->Fill(hit->GetX(), hit->GetY());
+      hZ->Fill(hit->GetZ());
     }
   }
 
@@ -323,5 +356,3 @@ int compareFV0Hits(std::string simFName1 = "fv0hit-rawhistos.root", std::string
   }
   return 0;
 }
-
-#endif

From 5a2ecfc89359b70fdc20c4bd05d0cf62c22a889b Mon Sep 17 00:00:00 2001
From: Sergio Garcia <47090312+singiamtel@users.noreply.github.com>
Date: Fri, 28 Mar 2025 09:25:38 +0100
Subject: [PATCH 0159/1764] Update tests in Clean PR action (#14119)

---
 .github/workflows/clean-test.yml | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/.github/workflows/clean-test.yml b/.github/workflows/clean-test.yml
index cbc524910c33e..0f15301d4eed9 100644
--- a/.github/workflows/clean-test.yml
+++ b/.github/workflows/clean-test.yml
@@ -19,10 +19,6 @@ name: Clean PR checks
       # Warning: the check_* keys are magic and must consist of the string
       # "check_" followed by the applicable check name exactly. The
       # "description" field is only the human-readable label for the input.
-      'check_build/O2/o2':
-        description: build/O2/o2
-        type: boolean
-        default: true
       'check_build/AliceO2/O2/o2/macOS':
         description: build/AliceO2/O2/o2/macOS
         type: boolean
@@ -31,14 +27,10 @@ name: Clean PR checks
         description: build/AliceO2/O2/o2/macOS-arm
         type: boolean
         default: true
-      'check_build/O2/fullCI':
+      'check_build/O2/fullCI_slc9':
         description: build/O2/fullCI
         type: boolean
         default: true
-      'check_build/O2/o2-cs8':
-        description: build/O2/o2-cs8
-        type: boolean
-        default: true
       'check_build/O2/o2-dataflow-cs8':
         description: build/O2/o2-dataflow-cs8
         type: boolean

From 1e69f5ebf9c1100d52752410592a9198345bc0a7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 12:45:28 +0100
Subject: [PATCH 0160/1764] GPU TPC: Fix Bz=0 threshold

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 288a24dee5d99..f03964d35ff82 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1740,7 +1740,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     p1.DzDs() = p2.DzDs();
     p1.QPt() = p2.QPt();
     mergedTrack.SetAlpha(p2.Alpha());
-    if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (0.01f * gpu_common_constants::kCLight)) {
+    if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (0.013f * gpu_common_constants::kCLight)) {
       p1.QPt() = 100.f / Param().rec.bz0Pt10MeV;
     }
 

From ebf86708921b595c8c7c190e0a6bb0acb058d05e Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 28 Mar 2025 12:08:28 +0100
Subject: [PATCH 0161/1764] Generator example for quick HepMC extraction from
 Pythia8

---
 .../Pythia8_HepMC_Wrapper/Pythia8HepMC3.macro | 44 +++++++++++++++++++
 .../Pythia8_HepMC_Wrapper/README.md           | 16 +++++++
 run/SimExamples/Pythia8_HepMC_Wrapper/run.sh  | 19 ++++++++
 run/SimExamples/README.md                     |  1 +
 4 files changed, 80 insertions(+)
 create mode 100644 run/SimExamples/Pythia8_HepMC_Wrapper/Pythia8HepMC3.macro
 create mode 100644 run/SimExamples/Pythia8_HepMC_Wrapper/README.md
 create mode 100755 run/SimExamples/Pythia8_HepMC_Wrapper/run.sh

diff --git a/run/SimExamples/Pythia8_HepMC_Wrapper/Pythia8HepMC3.macro b/run/SimExamples/Pythia8_HepMC_Wrapper/Pythia8HepMC3.macro
new file mode 100644
index 0000000000000..9e60bc0a5d851
--- /dev/null
+++ b/run/SimExamples/Pythia8_HepMC_Wrapper/Pythia8HepMC3.macro
@@ -0,0 +1,44 @@
+/// \author Marco Giacalone - March 2025
+
+// A simple wrapper and demonstrator around Pythia8 for extracting HepMC3 files.
+
+#include "Pythia8/Pythia.h"
+#include "Pythia8Plugins/HepMC3.h"
+
+using namespace o2::eventgen;
+
+class HepMC3_Pythia8Wrapper : public GeneratorPythia8
+{
+ public:
+  HepMC3_Pythia8Wrapper(std::string filename = "pythia8.hepmc") : GeneratorPythia8(), mFileName(filename)
+  {
+    // HepMC conversion object.
+    mToHepMC = std::make_unique<Pythia8::Pythia8ToHepMC>();
+    mToHepMC->setNewFile((filename == "" ? "pythia.hepmc" : filename));
+  };
+  ~HepMC3_Pythia8Wrapper() = default;
+
+  bool importParticles() override
+  {
+    // events are written after the importParticles step
+    // since some filtering is happening there
+    auto ret = GeneratorPythia8::importParticles();
+    if (ret) {
+      LOG(info) << "Writing event to HepMC3 format";
+      mToHepMC->writeNextEvent(mPythia);
+    }
+    return ret;
+  };
+
+ private:
+  std::string mFileName = "pythia8.hepmc";
+  std::unique_ptr<Pythia8::Pythia8ToHepMC> mToHepMC;
+};
+
+FairGenerator*
+  hepmc_pythia8(std::string filename = "pythia8.hepmc")
+{
+  std::cout << "HepMC3_Pythia8Wrapper initialising with filename: " << filename << std::endl;
+  auto py8 = new HepMC3_Pythia8Wrapper(filename);
+  return py8;
+}
diff --git a/run/SimExamples/Pythia8_HepMC_Wrapper/README.md b/run/SimExamples/Pythia8_HepMC_Wrapper/README.md
new file mode 100644
index 0000000000000..a334b7b3ef81e
--- /dev/null
+++ b/run/SimExamples/Pythia8_HepMC_Wrapper/README.md
@@ -0,0 +1,16 @@
+<!-- doxy
+\page refrunSimExamplesPythiaHepMCWrapper Example showing easy HepMC extraction using GeneratorPythia8
+/doxy -->
+
+This example demonstrates how we can extend GeneratorPythia8 in a user-defined macro (or external generator),
+to achieve additional HepMC3 export of generated Pythia8 events.
+
+The example provides a small utility for poeple in need to obtain HepMC files from Pythia8.
+Note that many other methods to achieve this are possible (See original Pythia8 example).
+
+The example provides:
+
+- The external generator implementation `Pythia8HepMC3.C`
+- a `run.sh` script demonstrating it's usage and a check feeding back the generated hepmc into the simulation
+
+
diff --git a/run/SimExamples/Pythia8_HepMC_Wrapper/run.sh b/run/SimExamples/Pythia8_HepMC_Wrapper/run.sh
new file mode 100755
index 0000000000000..16ff80f76b1d4
--- /dev/null
+++ b/run/SimExamples/Pythia8_HepMC_Wrapper/run.sh
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+#
+# Script doing Pythia8 event generation and writing these events into HepMC3 files
+# (next to generating the usual MCTrack kinematics output).
+#
+# The script also performs a second event generation based on the generated HepMC3 files.
+# In principle it should yield identical kinematics files.
+#
+
+NEVENTS=1000
+SEED=11
+
+o2-sim -j 1 -g external --configKeyValues 'GeneratorExternal.fileName=Pythia8HepMC3.macro;GeneratorExternal.funcName=hepmc_pythia8("skimmed.hepmc");GeneratorPythia8.config=${O2_ROOT}/share/Generators/egconfig/pythia8_inel.cfg' --seed ${SEED} --noGeant -o pythia8_skimmed -n ${NEVENTS}
+o2-sim -j 1 -g external --configKeyValues 'GeneratorExternal.fileName=Pythia8HepMC3.macro;GeneratorExternal.funcName=hepmc_pythia8("unskimmed.hepmc");GeneratorPythia8.config=${O2_ROOT}/share/Generators/egconfig/pythia8_inel.cfg;GeneratorPythia8.includePartonEvent=true' --seed ${SEED} --noGeant -o pythia8_unskimmed -n ${NEVENTS}
+
+# propagate generated hepmc file; it should produce the same kinematics as the original Pythia8
+o2-sim -j 1 -g hepmc --configKeyValues="GeneratorFileOrCmd.fileNames=skimmed.hepmc" --vertexMode kNoVertex --noGeant -o fromhepmc_skimmed -n ${NEVENTS} --seed ${SEED}
+o2-sim -j 1 -g hepmc --configKeyValues="GeneratorFileOrCmd.fileNames=unskimmed.hepmc" --vertexMode kNoVertex --noGeant -o fromhepmc_unskimmed -n ${NEVENTS} --seed ${SEED}
diff --git a/run/SimExamples/README.md b/run/SimExamples/README.md
index 725d60c4854ca..3a54625acf413 100644
--- a/run/SimExamples/README.md
+++ b/run/SimExamples/README.md
@@ -6,6 +6,7 @@
 
 <!-- doxy
 * \subpage refrunSimExamplesPythia8
+* \subpage refrunSimExamplesPythiaHepMCWrapper
 * \subpage refrunSimExamplesHF_Embedding_Pythia8
 * \subpage refrunSimExamplesSignal_ImpactB
 * \subpage refrunSimExamplesTrigger_ImpactB_Pythia8

From e29eadd3682330404efd012b6fb28474a116d3be Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Mar 2025 22:19:37 +0100
Subject: [PATCH 0162/1764] GPU RTC: Do not store preprocessed launch-bounds
 for RTC

---
 GPU/Common/GPUCommonAlgorithm.h               |  2 +-
 GPU/Common/GPUCommonAlgorithmThrust.h         | 13 +++-
 GPU/GPUTracking/Base/GPUParam.cxx             |  4 +-
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  6 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        |  3 +-
 .../GPUReconstructionCUDAExternalProvider.cu  |  3 +-
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx | 61 ++++++++++---------
 ... => GPUReconstructionCUDAIncludesSystem.h} |  6 +-
 .../Base/cuda/GPUReconstructionCUDAKernels.cu | 21 ++++---
 .../GPUReconstructionCUDAkernel.template.cu   |  3 +-
 .../Base/cuda/GPUReconstructionCUDArtc.cu     |  2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  8 +--
 ...h => GPUReconstructionHIPIncludesSystem.h} |  6 +-
 .../GPUReconstructionHIPkernel.template.hip   |  3 +-
 GPU/GPUTracking/Base/opencl/CMakeLists.txt    |  2 +-
 .../GPUDefParametersLoad.template.inc         | 24 ++++----
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 17 files changed, 91 insertions(+), 78 deletions(-)
 rename GPU/GPUTracking/Base/cuda/{GPUReconstructionCUDAIncludesHost.h => GPUReconstructionCUDAIncludesSystem.h} (91%)
 rename GPU/GPUTracking/Base/hip/{GPUReconstructionHIPIncludesHost.h => GPUReconstructionHIPIncludesSystem.h} (89%)

diff --git a/GPU/Common/GPUCommonAlgorithm.h b/GPU/Common/GPUCommonAlgorithm.h
index 5c19dda27f593..417c9e0d1f8c1 100644
--- a/GPU/Common/GPUCommonAlgorithm.h
+++ b/GPU/Common/GPUCommonAlgorithm.h
@@ -214,7 +214,7 @@ typedef GPUCommonAlgorithm CAAlgo;
 
 } // namespace o2::gpu
 
-#if (((defined(__CUDACC__) && !defined(__clang__)) || defined(__HIPCC__))) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_HOSTONLY)
+#if (((defined(__CUDACC__) && !defined(__clang__)) || defined(__HIPCC__))) && !defined(GPUCA_GPUCODE_HOSTONLY)
 
 #include "GPUCommonAlgorithmThrust.h"
 
diff --git a/GPU/Common/GPUCommonAlgorithmThrust.h b/GPU/Common/GPUCommonAlgorithmThrust.h
index 049071227a58e..7af3138d45490 100644
--- a/GPU/Common/GPUCommonAlgorithmThrust.h
+++ b/GPU/Common/GPUCommonAlgorithmThrust.h
@@ -15,6 +15,7 @@
 #ifndef GPUCOMMONALGORITHMTHRUST_H
 #define GPUCOMMONALGORITHMTHRUST_H
 
+#ifndef GPUCA_GPUCODE_COMPILEKERNELS
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wshadow"
 #include <thrust/sort.h>
@@ -25,14 +26,19 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonHelpers.h"
 
+#ifndef __HIPCC__ // CUDA
+#include <cub/cub.cuh>
+#else // HIP
+#include <hipcub/hipcub.hpp>
+#endif
+#endif // GPUCA_GPUCODE_COMPILEKERNELS
+
 #ifndef __HIPCC__ // CUDA
 #define GPUCA_THRUST_NAMESPACE thrust::cuda
 #define GPUCA_CUB_NAMESPACE cub
-#include <cub/cub.cuh>
 #else // HIP
 #define GPUCA_THRUST_NAMESPACE thrust::hip
 #define GPUCA_CUB_NAMESPACE hipcub
-#include <hipcub/hipcub.hpp>
 #endif
 
 namespace o2::gpu
@@ -90,6 +96,7 @@ GPUdi() void GPUCommonAlgorithm::sortDeviceDynamic(T* begin, T* end, const S& co
   thrust::sort(GPUCA_THRUST_NAMESPACE::par, thrustBegin, thrustEnd, comp);
 }
 
+#ifndef GPUCA_GPUCODE_COMPILEKERNELS
 template <class T, class S>
 GPUhi() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp)
 {
@@ -105,6 +112,8 @@ GPUhi() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begi
   GPUChkErrS(GPUCA_CUB_NAMESPACE::DeviceMergeSort::SortKeys(tempMem, tempSize, begin, N, comp, rec->mInternals->Streams[stream]));
 #endif
 }
+#endif // #ifndef GPUCA_GPUCODE_COMPILEKERNELS
+
 } // namespace o2::gpu
 
 #undef GPUCA_THRUST_NAMESPACE
diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index bbca150df405a..b835e1b198eea 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -193,12 +193,10 @@ void GPUParamRTC::setFrom(const GPUParam& param)
 
 std::string GPUParamRTC::generateRTCCode(const GPUParam& param, bool useConstexpr)
 {
-  return "#ifndef GPUCA_GPUCODE_DEVICE\n"
-         "#include <string>\n"
+  return "#include <string>\n"
          "#include <vector>\n"
          "#include <cstdint>\n"
          "#include <cstddef>\n"
-         "#endif\n"
          "namespace o2::gpu { class GPUDisplayFrontendInterface; }\n" +
          qConfigPrintRtc(std::make_tuple(&param.rec.tpc, &param.rec.trd, &param.rec, &param.par), useConstexpr);
 }
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index de54f09fdc2e1..ae3f0ecaf69dc 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -18,7 +18,7 @@ endif()
 message(STATUS "Building GPUTracking with CUDA support ${TMP_TARGET}")
 
 set(SRCS GPUReconstructionCUDA.cu GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu)
-set(HDRS GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDADef.h GPUReconstructionCUDAIncludesHost.h)
+set(HDRS GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDADef.h GPUReconstructionCUDAIncludesSystem.h)
 # -------------------------------- Prepare RTC -------------------------------------------------------
 enable_language(ASM)
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
@@ -67,8 +67,8 @@ set(GPU_RTC_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionCUDArtc)
 # cmake-format: off
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.src
-    COMMAND cp ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesHost.h ${GPU_RTC_BIN}.src
-    COMMAND ${CMAKE_CXX_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -nostdinc -E ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
+    COMMAND cp ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPU_RTC_BIN}.src
+    COMMAND ${CMAKE_CXX_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
     MAIN_DEPENDENCY ${GPU_RTC_SRC}
     IMPLICIT_DEPENDS CXX ${GPU_RTC_SRC}
     COMMAND_EXPAND_LISTS
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 8790d7718f517..3ca759626619b 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -19,7 +19,8 @@
 #include "GPUDefParametersDefault.h"
 #include "GPUDefParametersLoad.inc"
 
-#include "GPUReconstructionCUDAIncludesHost.h"
+#include "GPUReconstructionCUDAIncludesSystem.h"
+#include "GPUReconstructionCUDADef.h"
 #include <cuda_profiler_api.h>
 
 #include "GPUReconstructionCUDA.h"
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
index 534f5e8606897..9a23fcb460aa4 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAExternalProvider.cu
@@ -12,7 +12,8 @@
 /// \file GPUReconstructionCUDAExternalProvider.cu
 /// \author David Rohr
 
-#include "GPUReconstructionCUDAIncludesHost.h"
+#include "GPUReconstructionCUDAIncludesSystem.h"
+#include "GPUReconstructionCUDADef.h"
 
 #include "GPUReconstructionCUDA.h"
 #include "GPUReconstructionCUDAInternals.h"
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index 51d3bd4044e8d..31d4f54c00d10 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -13,6 +13,10 @@
 /// \author David Rohr
 
 #define GPUCA_GPUCODE_HOSTONLY
+#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
+#include "GPUDefParametersDefault.h"
+#include "GPUDefParametersLoad.inc"
+
 #include "GPUReconstructionCUDA.h"
 #include "GPUParamRTC.h"
 #include "GPUDefMacros.h"
@@ -55,13 +59,15 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
   std::string baseCommand = (mProcessingSettings.RTCprependCommand != "" ? (mProcessingSettings.RTCprependCommand + " ") : "");
   baseCommand += (getenv("O2_GPU_RTC_OVERRIDE_CMD") ? std::string(getenv("O2_GPU_RTC_OVERRIDE_CMD")) : std::string(_binary_GPUReconstructionCUDArtc_command_start, _binary_GPUReconstructionCUDArtc_command_len));
   baseCommand += std::string(" ") + (mProcessingSettings.RTCoverrideArchitecture != "" ? mProcessingSettings.RTCoverrideArchitecture : std::string(_binary_GPUReconstructionCUDArtc_command_arch_start, _binary_GPUReconstructionCUDArtc_command_arch_len));
+  const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true);
 
-  char shasource[21], shaparam[21], shacmd[21], shakernels[21];
+  char shasource[21], shaparam[21], shacmd[21], shakernels[21], shabounds[21];
   if (mProcessingSettings.rtc.cacheOutput) {
     o2::framework::internal::SHA1(shasource, _binary_GPUReconstructionCUDArtc_src_start, _binary_GPUReconstructionCUDArtc_src_len);
     o2::framework::internal::SHA1(shaparam, rtcparam.c_str(), rtcparam.size());
     o2::framework::internal::SHA1(shacmd, baseCommand.c_str(), baseCommand.size());
     o2::framework::internal::SHA1(shakernels, kernelsall.c_str(), kernelsall.size());
+    o2::framework::internal::SHA1(shabounds, launchBounds.c_str(), launchBounds.size());
   }
 
   nCompile = mProcessingSettings.rtc.compilePerKernel ? kernels.size() : 1;
@@ -88,32 +94,29 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     if (fp) {
       size_t len;
       while (true) {
-        if (fread(sharead, 1, 20, fp) != 20) {
-          throw std::runtime_error("Cache file corrupt");
-        }
-        if (!mProcessingSettings.rtc.ignoreCacheValid && memcmp(sharead, shasource, 20)) {
-          GPUInfo("Cache file content outdated (source)");
-          break;
-        }
-        if (fread(sharead, 1, 20, fp) != 20) {
-          throw std::runtime_error("Cache file corrupt");
-        }
-        if (!mProcessingSettings.rtc.ignoreCacheValid && memcmp(sharead, shaparam, 20)) {
-          GPUInfo("Cache file content outdated (param)");
-          break;
-        }
-        if (fread(sharead, 1, 20, fp) != 20) {
-          throw std::runtime_error("Cache file corrupt");
-        }
-        if (!mProcessingSettings.rtc.ignoreCacheValid && memcmp(sharead, shacmd, 20)) {
-          GPUInfo("Cache file content outdated (commandline)");
-          break;
-        }
-        if (fread(sharead, 1, 20, fp) != 20) {
-          throw std::runtime_error("Cache file corrupt");
-        }
-        if (!mProcessingSettings.rtc.ignoreCacheValid && memcmp(sharead, shakernels, 20)) {
-          GPUInfo("Cache file content outdated (kernel definitions)");
+        auto checkSHA = [&](const char* shacmp, const char* name) {
+          if (fread(sharead, 1, 20, fp) != 20) {
+            throw std::runtime_error("Cache file corrupt");
+          }
+          if (mProcessingSettings.debugLevel >= 3) {
+            char shaprint1[41], shaprint2[41];
+            for (uint32_t i = 0; i < 20; i++) {
+              sprintf(shaprint1 + 2 * i, "%02X ", shacmp[i]);
+              sprintf(shaprint2 + 2 * i, "%02X ", sharead[i]);
+            }
+            GPUInfo("SHA for %s: expected %s, read %s", name, shaprint1, shaprint2);
+          }
+          if (!mProcessingSettings.rtc.ignoreCacheValid && memcmp(sharead, shacmp, 20)) {
+            GPUInfo("Cache file content outdated (%s)", name);
+            return 1;
+          }
+          return 0;
+        };
+        if (checkSHA(shasource, "source") ||
+            checkSHA(shaparam, "param") ||
+            checkSHA(shacmd, "command line") ||
+            checkSHA(shakernels, "kernel definitions") ||
+            checkSHA(shabounds, "launch bounds")) {
           break;
         }
         GPUSettingsProcessingRTC cachedSettings;
@@ -169,11 +172,12 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       kernel += mProcessingSettings.rtc.compilePerKernel ? kernels[i] : kernelsall;
       kernel += "}";
 
-      bool deterministic = mProcessingSettings.rtc.deterministic || o2::gpu::internal::noFastMathKernels.find(GetKernelName(i)) != o2::gpu::internal::noFastMathKernels.end();
+      bool deterministic = mProcessingSettings.rtc.deterministic || (mProcessingSettings.rtc.compilePerKernel && o2::gpu::internal::noFastMathKernels.find(GetKernelName(i)) != o2::gpu::internal::noFastMathKernels.end());
       const std::string deterministicStr = std::string(deterministic ? "#define GPUCA_DETERMINISTIC_CODE(det, indet) det\n" : "#define GPUCA_DETERMINISTIC_CODE(det, indet) indet\n");
 
       if (fwrite(deterministicStr.c_str(), 1, deterministicStr.size(), fp) != deterministicStr.size() ||
           fwrite(rtcparam.c_str(), 1, rtcparam.size(), fp) != rtcparam.size() ||
+          fwrite(launchBounds.c_str(), 1, launchBounds.size(), fp) != launchBounds.size() ||
           fwrite(_binary_GPUReconstructionCUDArtc_src_start, 1, _binary_GPUReconstructionCUDArtc_src_len, fp) != _binary_GPUReconstructionCUDArtc_src_len ||
           fwrite(kernel.c_str(), 1, kernel.size(), fp) != kernel.size()) {
         throw std::runtime_error("Error writing file");
@@ -213,6 +217,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
           fwrite(shaparam, 1, 20, fp) != 20 ||
           fwrite(shacmd, 1, 20, fp) != 20 ||
           fwrite(shakernels, 1, 20, fp) != 20 ||
+          fwrite(shabounds, 1, 20, fp) != 20 ||
           fwrite(&mProcessingSettings.rtc, sizeof(mProcessingSettings.rtc), 1, fp) != 1) {
         throw std::runtime_error("Error writing cache file");
       }
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesHost.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
similarity index 91%
rename from GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesHost.h
rename to GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
index e3e26e6482fc4..1cb3679fc30dc 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesHost.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUReconstructionCUDAIncludes.h
+/// \file GPUReconstructionCUDAIncludesSystem.h
 /// \author David Rohr
 
 #ifndef O2_GPU_GPURECONSTRUCTIONCUDAINCLUDES_H
@@ -32,8 +32,4 @@
 #include <sm_20_atomic_functions.h>
 #include <cuda_fp16.h>
 
-#ifndef GPUCA_RTC_CODE
-#include "GPUReconstructionCUDADef.h"
-#endif
-
 #endif
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index ac79dd7576e48..f8efd8428f035 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -12,7 +12,8 @@
 /// \file GPUReconstructionCUDAKernels.cu
 /// \author David Rohr
 
-#include "GPUReconstructionCUDAIncludesHost.h"
+#include "GPUReconstructionCUDAIncludesSystem.h"
+#include "GPUReconstructionCUDADef.h"
 
 #include "GPUReconstructionCUDA.h"
 #include "GPUReconstructionCUDAInternals.h"
@@ -108,13 +109,6 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
 
-void GPUReconstructionCUDABackend::getRTCKernelCalls(std::vector<std::string>& kernels)
-{
-#define GPUCA_KRNL(...) kernels.emplace_back(GPUCA_M_STR(GPUCA_KRNLGPU(__VA_ARGS__)));
-#include "GPUReconstructionKernelList.h"
-#undef GPUCA_KRNL
-}
-
 #ifndef GPUCA_NO_CONSTANT_MEMORY
 static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstSymbol([]() {
   void* retVal = nullptr;
@@ -124,3 +118,14 @@ static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstS
   return retVal;
 });
 #endif
+
+void GPUReconstructionCUDABackend::getRTCKernelCalls(std::vector<std::string>& kernels)
+{
+#undef GPUCA_KRNL_LB
+#undef __launch_bounds__
+#define GPUCA_KRNL(...) kernels.emplace_back(GPUCA_M_STR(GPUCA_KRNLGPU(__VA_ARGS__)));
+#define GPUCA_KRNL_LB(x_class, x_attributes, ...) GPUCA_KRNL(x_class, (REG, (GPUCA_M_CAT(GPUCA_RTC_LB_, GPUCA_M_KRNL_NAME(x_class))), GPUCA_M_STRIP(x_attributes)), __VA_ARGS__)
+#include "GPUReconstructionKernelList.h"
+#undef GPUCA_KRNL
+#undef GPUCA_KRNL_LB
+}
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
index 3140c6b9158ad..847011a70f7f9 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
@@ -13,9 +13,10 @@
 /// \author David Rohr
 
 #define GPUCA_GPUCODE_COMPILEKERNELS
-#include "GPUReconstructionCUDAIncludesHost.h"
+#include "GPUReconstructionCUDAIncludesSystem.h"
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
 #define GPUCA_KRNL(...) GPUCA_KRNLGPU(__VA_ARGS__);
+#include "GPUReconstructionCUDADef.h"
 #include "GPUReconstructionKernelMacros.h"
 
 // clang-format off
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
index 919b5c11477ef..50a568ab345cf 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
@@ -16,7 +16,7 @@
 #define GPUCA_GPUCODE_COMPILEKERNELS
 #define GPUCA_RTC_SPECIAL_CODE(...) GPUCA_RTC_SPECIAL_CODE(__VA_ARGS__)
 #define GPUCA_DETERMINISTIC_CODE(...) GPUCA_DETERMINISTIC_CODE(__VA_ARGS__)
-// GPUReconstructionCUDAIncludesHost.h auto-prependended without preprocessor running
+// GPUReconstructionCUDAIncludesSystem.h prependended without preprocessor running
 #include "GPUReconstructionCUDADef.h"
 #include "GPUReconstructionIncludesDeviceAll.h"
 
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 43259decef956..eaa87d69c0de6 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -25,7 +25,7 @@ if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   set(GPUCA_HIP_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/hipify)
   file(MAKE_DIRECTORY ${GPUCA_HIP_SOURCE_DIR})
   set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDAkernel.template.cu GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDArtc.cu)
-  set(GPUCA_HIP_LOCAL_FILE_LIST GPUReconstructionHIPIncludesHost.h)
+  set(GPUCA_HIP_LOCAL_FILE_LIST GPUReconstructionHIPIncludesSystem.h)
   set(HIP_SOURCES "")
   foreach(file ${GPUCA_HIP_FILE_LIST})
     get_filename_component(ABS_CUDA_SORUCE ../cuda/${file} ABSOLUTE)
@@ -63,7 +63,7 @@ endif()
 
 set(SRCS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.hip ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPKernels.hip)
 set(SRCS_CXX ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPGenRTC.cxx)
-set(HDRS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPInternals.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPHelpers.inc ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPDef.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPIncludesHost.h)
+set(HDRS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPInternals.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPHelpers.inc ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPDef.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPIncludesSystem.h)
 
 # -------------------------------- Prepare RTC -------------------------------------------------------
 enable_language(ASM)
@@ -104,8 +104,8 @@ set(GPU_RTC_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionHIPrtc)
 # cmake-format: off
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.src
-    COMMAND cp ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesHost.h ${GPU_RTC_BIN}.src
-    COMMAND ${CMAKE_CXX_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
+    COMMAND cp ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPU_RTC_BIN}.src
+    COMMAND ${CMAKE_CXX_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
     MAIN_DEPENDENCY ${GPU_RTC_SRC}
     IMPLICIT_DEPENDS CXX ${GPU_RTC_SRC}
     DEPENDS ${MODULE}_HIPIFIED
diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
similarity index 89%
rename from GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h
rename to GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
index 5506e3925bf80..cfe1121ef1089 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesHost.h
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUReconstructionHIPIncludesHost.h
+/// \file GPUReconstructionHIPIncludesSystem.h
 /// \author David Rohr
 
 #ifndef O2_GPU_RECONSTRUCTIONHIPINCLUDES_H
@@ -25,8 +25,4 @@
 #include <thrust/device_ptr.h>
 #pragma GCC diagnostic pop
 
-#ifndef GPUCA_RTC_CODE
-#include "GPUReconstructionHIPDef.h"
-#endif
-
 #endif
diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
index 427938a3bd704..d5ac1d14c2d9e 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
@@ -13,9 +13,10 @@
 /// \author David Rohr
 
 #define GPUCA_GPUCODE_COMPILEKERNELS
-#include "GPUReconstructionHIPIncludesHost.h"
+#include "GPUReconstructionHIPIncludesSystem.h"
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
 #define GPUCA_KRNL(...) GPUCA_KRNLGPU(__VA_ARGS__);
+#include "GPUReconstructionHIPDef.h"
 #include "GPUReconstructionKernelMacros.h"
 
 // clang-format off
diff --git a/GPU/GPUTracking/Base/opencl/CMakeLists.txt b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
index 381c9c050ca09..7ab70553958ef 100644
--- a/GPU/GPUTracking/Base/opencl/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
@@ -76,7 +76,7 @@ if(OPENCL_ENABLED) # BUILD OpenCL source code for runtime compilation target
               ${OCL_DEFINECL}
               -cl-no-stdinc
               -nostdinc
-              -E ${CL_SRC} > ${CL_BIN}.src
+              -E -P ${CL_SRC} > ${CL_BIN}.src
       MAIN_DEPENDENCY ${CL_SRC}
       IMPLICIT_DEPENDS CXX ${CL_SRC}
       COMMAND_EXPAND_LISTS
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
index 953750b6f925b..73f7b5155fbdd 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
@@ -31,20 +31,20 @@ static GPUDefParameters GPUDefParametersLoad()
   };
 }
 
-#define GPUCA_EXPORT_KERNEL(name)                                      \
-  if (par.par_LB_maxThreads[i] > 0) {                                  \
-    o << "#define " GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i]; \
-    if (par.par_LB_minBlocks[i] > 0) {                                 \
-      o << ", " << par.par_LB_minBlocks[i];                            \
-    }                                                                  \
-    if (par.par_LB_forceBlocks[i] > 0) {                               \
-      o << ", " << par.par_LB_forceBlocks[i];                          \
-    }                                                                  \
-    o << "\n";                                                         \
-  }                                                                    \
+#define GPUCA_EXPORT_KERNEL(name)                                                                                  \
+  if (par.par_LB_maxThreads[i] > 0) {                                                                              \
+    o << "#define GPUCA_" << (forRTC ? "RTC_" : "") << "LB_" << GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i]; \
+    if (par.par_LB_minBlocks[i] > 0) {                                                                             \
+      o << ", " << par.par_LB_minBlocks[i];                                                                        \
+    }                                                                                                              \
+    if (par.par_LB_forceBlocks[i] > 0) {                                                                           \
+      o << ", " << par.par_LB_forceBlocks[i];                                                                      \
+    }                                                                                                              \
+    o << "\n";                                                                                                     \
+  }                                                                                                                \
   i++;
 
-static std::string GPUDefParametersExport(const GPUDefParameters& par)
+static std::string GPUDefParametersExport(const GPUDefParameters& par, bool forRTC)
 {
   std::stringstream o; // clang-format off
   int32_t i = 0;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index e0c5f845a475e..7fdc7054628a6 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -203,7 +203,6 @@ AddHelp("help", 'h')
 EndConfig()
 
 #ifndef __OPENCL__
-// Settings steering the processing once the device was selected, only available on the host
 BeginSubConfig(GPUSettingsProcessingRTC, rtc, configStandalone.proc, "RTC", 0, "Processing settings", proc_rtc)
 AddOption(cacheOutput, bool, false, "", 0, "Cache RTC compilation results")
 AddOption(optConstexpr, bool, true, "", 0, "Replace constant variables by static constexpr expressions")
@@ -253,6 +252,7 @@ AddOption(nnSigmoidTrafoClassThreshold, int, 1, "", 0, "If true (default), then
 AddHelp("help", 'h')
 EndConfig()
 
+// Settings steering the processing once the device was selected, only available on the host
 BeginSubConfig(GPUSettingsProcessing, proc, configStandalone, "PROC", 0, "Processing settings", proc)
 AddOption(deviceNum, int32_t, -1, "gpuDevice", 0, "Set GPU device to use (-1: automatic, -2: for round-robin usage in timeslice-pipeline)")
 AddOption(gpuDeviceOnly, bool, false, "", 0, "Use only GPU as device (i.e. no CPU for OpenCL)")

From 915d42dec42ed698358b9dd3ac49144916e84021 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Mar 2025 23:59:52 +0100
Subject: [PATCH 0163/1764] GPU RTC: Disable CUDA compiler diagnostic about
 unused variables

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt | 2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index ae3f0ecaf69dc..843fc3464e151 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -84,7 +84,7 @@ add_custom_target(${MODULE}_CUDA_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}
 
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command
-    COMMAND echo -n "${CMAKE_CUDA_COMPILER} -forward-unknown-to-host-compiler ${GPU_RTC_DEFINES} ${GPU_RTC_FLAGS_SEPARATED} -x cu -fatbin" > ${GPU_RTC_BIN}.command
+    COMMAND echo -n "${CMAKE_CUDA_COMPILER} -forward-unknown-to-host-compiler ${GPU_RTC_DEFINES} ${GPU_RTC_FLAGS_SEPARATED} -x cu -fatbin -Xcudafe --diag_suppress=177" > ${GPU_RTC_BIN}.command
     COMMAND_EXPAND_LISTS VERBATIM
     COMMENT "Preparing CUDA RTC command file ${GPU_RTC_BIN}.command"
 )
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index eaa87d69c0de6..5796c0c48686b 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -122,7 +122,7 @@ add_custom_target(${MODULE}_HIP_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/
 
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.command
-    COMMAND echo -n "${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_FLAGS_SEPARATED} -x hip --cuda-device-only" > ${GPU_RTC_BIN}.command
+    COMMAND echo -n "${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_FLAGS_SEPARATED} -x hip --cuda-device-only -Wno-unused-const-variable" > ${GPU_RTC_BIN}.command
     COMMAND_EXPAND_LISTS VERBATIM
     COMMENT "Preparing HIP RTC command file ${GPU_RTC_BIN}.command"
 )

From ce1e5d66cd24eaf71ff7378728cb1493fa9ab488 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 00:00:11 +0100
Subject: [PATCH 0164/1764] GPU TPC Clusterizer: remove unused constexpr debug
 variables

---
 GPU/GPUTracking/TPCClusterFinder/CfConsts.h | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/CfConsts.h b/GPU/GPUTracking/TPCClusterFinder/CfConsts.h
index 62695f2ae30a5..c600b8f3ea8f8 100644
--- a/GPU/GPUTracking/TPCClusterFinder/CfConsts.h
+++ b/GPU/GPUTracking/TPCClusterFinder/CfConsts.h
@@ -35,11 +35,6 @@ GPUconstexpr() tpccf::Delta2 InnerNeighbors[8] =
     {1, 0},
     {1, 1}};
 
-GPUconstexpr() bool InnerTestEq[8] =
-  {
-    true, true, true, true,
-    false, false, false, false};
-
 GPUconstexpr() tpccf::Delta2 OuterNeighbors[16] =
   {
     {-2, -1},

From 857cc422cc5186fbeb4da74754d6539fb3c14302 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 11:46:53 +0100
Subject: [PATCH 0165/1764] GPU RTC: Split options into technical and
 code-creation ones, add option to print launch-bounds used for RTC

---
 .../Base/cuda/GPUReconstructionCUDA.cu        |  6 ++---
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx | 25 +++++++++++--------
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 23 ++++++++++++++---
 .../GPUTrackingLinkDef_O2_DataTypes.h         |  1 +
 prodtests/full-system-test/dpl-workflow.sh    |  8 +++---
 5 files changed, 41 insertions(+), 22 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 3ca759626619b..4cfdf7febabd7 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -114,7 +114,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
   constexpr int32_t reqVerMaj = 2;
   constexpr int32_t reqVerMin = 0;
 #endif
-  if (mProcessingSettings.rtc.enable && mProcessingSettings.rtc.runTest == 2) {
+  if (mProcessingSettings.rtc.enable && mProcessingSettings.rtctech.runTest == 2) {
     genAndLoadRTC();
     exit(0);
   }
@@ -433,14 +433,14 @@ void GPUReconstructionCUDA::genAndLoadRTC()
     throw std::runtime_error("Runtime compilation failed");
   }
   for (uint32_t i = 0; i < nCompile; i++) {
-    if (mProcessingSettings.rtc.runTest != 2) {
+    if (mProcessingSettings.rtctech.runTest != 2) {
       mInternals->kernelModules.emplace_back(std::make_unique<CUmodule>());
       GPUChkErr(cuModuleLoad(mInternals->kernelModules.back().get(), (filename + "_" + std::to_string(i) + mRtcBinExtension).c_str()));
     }
     remove((filename + "_" + std::to_string(i) + mRtcSrcExtension).c_str());
     remove((filename + "_" + std::to_string(i) + mRtcBinExtension).c_str());
   }
-  if (mProcessingSettings.rtc.runTest == 2) {
+  if (mProcessingSettings.rtctech.runTest == 2) {
     return;
   }
   loadKernelModules(mProcessingSettings.rtc.compilePerKernel);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index 31d4f54c00d10..c6bbc26977f09 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -56,10 +56,13 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     kernelsall += kernels[i] + "\n";
   }
 
-  std::string baseCommand = (mProcessingSettings.RTCprependCommand != "" ? (mProcessingSettings.RTCprependCommand + " ") : "");
+  std::string baseCommand = (mProcessingSettings.rtctech.prependCommand != "" ? (mProcessingSettings.rtctech.prependCommand + " ") : "");
   baseCommand += (getenv("O2_GPU_RTC_OVERRIDE_CMD") ? std::string(getenv("O2_GPU_RTC_OVERRIDE_CMD")) : std::string(_binary_GPUReconstructionCUDArtc_command_start, _binary_GPUReconstructionCUDArtc_command_len));
-  baseCommand += std::string(" ") + (mProcessingSettings.RTCoverrideArchitecture != "" ? mProcessingSettings.RTCoverrideArchitecture : std::string(_binary_GPUReconstructionCUDArtc_command_arch_start, _binary_GPUReconstructionCUDArtc_command_arch_len));
+  baseCommand += std::string(" ") + (mProcessingSettings.rtctech.overrideArchitecture != "" ? mProcessingSettings.rtctech.overrideArchitecture : std::string(_binary_GPUReconstructionCUDArtc_command_arch_start, _binary_GPUReconstructionCUDArtc_command_arch_len));
   const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true);
+  if (mProcessingSettings.rtctech.printLaunchBounds || mProcessingSettings.debugLevel >= 3) {
+    GPUInfo("RTC Launch Bounds:\n%s", launchBounds.c_str());
+  }
 
   char shasource[21], shaparam[21], shacmd[21], shakernels[21], shabounds[21];
   if (mProcessingSettings.rtc.cacheOutput) {
@@ -74,12 +77,12 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
   bool cacheLoaded = false;
   int32_t fd = 0;
   if (mProcessingSettings.rtc.cacheOutput) {
-    if (mProcessingSettings.RTCcacheFolder != ".") {
-      std::filesystem::create_directories(mProcessingSettings.RTCcacheFolder);
+    if (mProcessingSettings.rtctech.cacheFolder != ".") {
+      std::filesystem::create_directories(mProcessingSettings.rtctech.cacheFolder);
     }
-    if (mProcessingSettings.rtc.cacheMutex) {
+    if (mProcessingSettings.rtctech.cacheMutex) {
       mode_t mask = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
-      fd = open((mProcessingSettings.RTCcacheFolder + "/cache.lock").c_str(), O_RDWR | O_CREAT | O_CLOEXEC, mask);
+      fd = open((mProcessingSettings.rtctech.cacheFolder + "/cache.lock").c_str(), O_RDWR | O_CREAT | O_CLOEXEC, mask);
       if (fd == -1) {
         throw std::runtime_error("Error opening rtc cache mutex lock file");
       }
@@ -89,7 +92,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       }
     }
 
-    FILE* fp = fopen((mProcessingSettings.RTCcacheFolder + "/rtc.cuda.cache").c_str(), "rb");
+    FILE* fp = fopen((mProcessingSettings.rtctech.cacheFolder + "/rtc.cuda.cache").c_str(), "rb");
     char sharead[20];
     if (fp) {
       size_t len;
@@ -106,7 +109,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
             }
             GPUInfo("SHA for %s: expected %s, read %s", name, shaprint1, shaprint2);
           }
-          if (!mProcessingSettings.rtc.ignoreCacheValid && memcmp(sharead, shacmp, 20)) {
+          if (!mProcessingSettings.rtctech.ignoreCacheValid && memcmp(sharead, shacmp, 20)) {
             GPUInfo("Cache file content outdated (%s)", name);
             return 1;
           }
@@ -124,7 +127,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
         if (fread(&cachedSettings, sizeof(cachedSettings), 1, fp) != 1) {
           throw std::runtime_error("Cache file corrupt");
         }
-        if (!mProcessingSettings.rtc.ignoreCacheValid && !(cachedSettings == mProcessingSettings.rtc)) {
+        if (!mProcessingSettings.rtctech.ignoreCacheValid && !(cachedSettings == mProcessingSettings.rtc)) {
           GPUInfo("Cache file content outdated (rtc parameters)");
           break;
         }
@@ -207,7 +210,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       GPUInfo("RTC Compilation finished (%f seconds)", rtcTimer.GetCurrentElapsedTime());
     }
     if (mProcessingSettings.rtc.cacheOutput) {
-      FILE* fp = fopen((mProcessingSettings.RTCcacheFolder + "/rtc.cuda.cache").c_str(), "w+b");
+      FILE* fp = fopen((mProcessingSettings.rtctech.cacheFolder + "/rtc.cuda.cache").c_str(), "w+b");
       if (fp == nullptr) {
         throw std::runtime_error("Cannot open cache file for writing");
       }
@@ -245,7 +248,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       fclose(fp);
     }
   }
-  if (mProcessingSettings.rtc.cacheOutput && mProcessingSettings.rtc.cacheMutex) {
+  if (mProcessingSettings.rtc.cacheOutput && mProcessingSettings.rtctech.cacheMutex) {
     if (lockf(fd, F_ULOCK, 0)) {
       throw std::runtime_error("Error unlocking RTC cache mutex file");
     }
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 7fdc7054628a6..d3a3fbaff16ff 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -35,6 +35,9 @@ BeginNamespace(gpu)
 
 // Settings concerning the reconstruction, stored as parameters in GPU constant memory
 // There must be no bool in here, use int8_t, as sizeof(bool) is compiler dependent and fails on GPUs!!!!!!
+// Split in different blocks for global and per Detector
+
+// Reconstruction parameters for TPC, no bool in here !!!
 BeginSubConfig(GPUSettingsRecTPC, tpc, configStandalone.rec, "RECTPC", 0, "Reconstruction settings", rec_tpc)
 AddOptionRTC(rejectQPtB5, float, 1.f / GPUCA_MIN_TRACK_PTB5_REJECT_DEFAULT, "", 0, "QPt threshold to reject clusters of TPC tracks (Inverse Pt, scaled to B=0.5T!!!)")
 AddOptionRTC(hitPickUpFactor, float, 1.f, "", 0, "multiplier for the combined cluster+track error during track following")
@@ -161,6 +164,7 @@ AddOptionArray(PID_remap, int8_t, 9, (0, 1, 2, 3, 4, 5, 6, 7, 8), "", 0, "Remap
 AddHelp("help", 'h')
 EndConfig()
 
+// Reconstruction parameters for TRD, no bool in here !!!
 BeginSubConfig(GPUSettingsRecTRD, trd, configStandalone.rec, "RECTRD", 0, "Reconstruction settings", rec_trd)
 AddOptionRTC(minTrackPt, float, .5f, "", 0, "Min Pt for tracks to be propagated through the TRD")
 AddOptionRTC(maxChi2, float, 20.f, "", 0, "Max chi2 for TRD tracklets to be matched to a track")
@@ -182,11 +186,12 @@ AddOptionRTC(pileupBwdNBC, uint8_t, 80, "", 0, "Pre-trigger Pile-up integration
 AddHelp("help", 'h')
 EndConfig()
 
-// Dynamic settings, must NOT use AddOptionRTC(...) !!!
+// Dynamic reconstruction parameters, no bool in here!!!, must NOT use AddOptionRTC(...) !!!
 BeginSubConfig(GPUSettingsRecDynamic, dyn, configStandalone.rec, "RECDYN", 0, "Reconstruction settings", rec_dyn)
 AddHelp("help", 'h')
 EndConfig()
 
+// Global reconstruction parameters, no bool in here !!!
 BeginSubConfig(GPUSettingsRec, rec, configStandalone, "REC", 0, "Reconstruction settings", rec)
 AddOptionRTC(maxTrackQPtB5, float, 1.f / GPUCA_MIN_TRACK_PTB5_DEFAULT, "", 0, "required max Q/Pt (==min Pt) of tracks")
 AddOptionRTC(fwdTPCDigitsAsClusters, uint8_t, 0, "", 0, "Forward TPC digits as clusters (if they pass the ZS threshold)")
@@ -203,6 +208,7 @@ AddHelp("help", 'h')
 EndConfig()
 
 #ifndef __OPENCL__
+// Parameters that might affect the RTC code (if these change, the cache cannot be used)
 BeginSubConfig(GPUSettingsProcessingRTC, rtc, configStandalone.proc, "RTC", 0, "Processing settings", proc_rtc)
 AddOption(cacheOutput, bool, false, "", 0, "Cache RTC compilation results")
 AddOption(optConstexpr, bool, true, "", 0, "Replace constant variables by static constexpr expressions")
@@ -210,12 +216,22 @@ AddOption(optSpecialCode, int8_t, -1, "", 0, "Insert GPUCA_RTC_SPECIAL_CODE spec
 AddOption(deterministic, bool, false, "", 0, "Compile RTC in deterministic mode, with NO_FAST_MATH flags and GPUCA_DETERMINISTIC_MODE define")
 AddOption(compilePerKernel, bool, true, "", 0, "Run one RTC compilation per kernel")
 AddOption(enable, bool, false, "", 0, "Use RTC to optimize GPU code")
+AddHelp("help", 'h')
+EndConfig()
+
+// Technical parameters for RunTimeCompilation, which do not change the RTC code
+BeginSubConfig(GPUSettingsProcessingRTCtechnical, rtctech, configStandalone.proc, "RTCTECH", 0, "Processing settings", proc_rtctech)
 AddOption(runTest, int32_t, 0, "", 0, "Do not run the actual benchmark, but just test RTC compilation (1 full test, 2 test only compilation)")
 AddOption(cacheMutex, bool, true, "", 0, "Use a file lock to serialize access to the cache folder")
 AddOption(ignoreCacheValid, bool, false, "", 0, "If set, allows to use RTC cached code files even if they are not valid for the current source code / parameters")
+AddOption(printLaunchBounds, bool, false, "", 0, "Print launch bounds used for RTC code as debugging option")
+AddOption(cacheFolder, std::string, "./rtccache/", "", 0, "Folder in which the cache file is stored")
+AddOption(prependCommand, std::string, "", "", 0, "Prepend RTC compilation commands by this string")
+AddOption(overrideArchitecture, std::string, "", "", 0, "Override arhcitecture part of RTC compilation command line") // Part of cmdLine, so checked against the cache
 AddHelp("help", 'h')
 EndConfig()
 
+// Parameters that steer reconstruction that do not go to the device, or only in derrived form.
 BeginSubConfig(GPUSettingsProcessingParam, param, configStandalone.proc, "PARAM", 0, "Processing settings", proc_param)
 AddOptionArray(tpcErrorParamY, float, 4, (0.06f, 0.24f, 0.12f, 0.1f), "", 0, "TPC Cluster Y Error Parameterization")
 AddOptionArray(tpcErrorParamZ, float, 4, (0.06f, 0.24f, 0.15f, 0.1f), "", 0, "TPC Cluster Z Error Parameterization")
@@ -223,6 +239,7 @@ AddOption(tpcTriggerHandling, bool, true, "", 0, "Enable TPC trigger handling")
 AddHelp("help", 'h')
 EndConfig()
 
+// Settings steering the processing of NN Clusterization
 BeginSubConfig(GPUSettingsProcessingNNclusterizer, nn, configStandalone.proc, "NN", 0, "Processing settings for neural network clusterizer", proc_nn)
 AddOption(applyNNclusterizer, int, 0, "", 0, "(bool, default = 0), if the neural network clusterizer should be used.")
 AddOption(nnInferenceDevice, std::string, "CPU", "", 0, "(std::string) Specify inference device (cpu (default), rocm, cuda)")
@@ -320,9 +337,6 @@ AddOption(tpcMaxAttachedClustersPerSectorRow, uint32_t, 51000, "", 0, "Maximum n
 AddOption(tpcUseOldCPUDecoding, bool, false, "", 0, "Enable old CPU-based TPC decoding")
 AddOption(tpcApplyCFCutsAtDecoding, bool, false, "", 0, "Apply cluster cuts from clusterization during decoding of compressed clusters")
 AddOption(tpcApplyClusterFilterOnCPU, uint8_t, 0, "", 0, "Apply custom cluster filter of GPUTPCClusterFilter class, 0: off, 1: debug, 2: PbPb23")
-AddOption(RTCcacheFolder, std::string, "./rtccache/", "", 0, "Folder in which the cache file is stored")
-AddOption(RTCprependCommand, std::string, "", "", 0, "Prepend RTC compilation commands by this string")
-AddOption(RTCoverrideArchitecture, std::string, "", "", 0, "Override arhcitecture part of RTC compilation command line")
 AddOption(oclPlatformNum, int32_t, -1, "", 0, "Platform to use, in case the backend provides multiple platforms (OpenCL only, -1 = auto-select, -2 query all platforms (also incompatible))")
 AddOption(oclCompileFromSources, bool, false, "", 0, "Compile OpenCL binary from included source code instead of using included spirv code")
 AddOption(oclOverrideSourceBuildFlags, std::string, "", "", 0, "Override OCL build flags for compilation from source, put a space for empty options")
@@ -330,6 +344,7 @@ AddOption(printSettings, bool, false, "", 0, "Print all settings when initializi
 AddOption(tpcFreeAllocatedMemoryAfterProcessing, bool, false, "", 0, "Clean all memory allocated by TPC when TPC processing done, only data written to external output resources will remain")
 AddVariable(eventDisplay, o2::gpu::GPUDisplayFrontendInterface*, nullptr)
 AddSubConfig(GPUSettingsProcessingRTC, rtc)
+AddSubConfig(GPUSettingsProcessingRTCtechnical, rtctech)
 AddSubConfig(GPUSettingsProcessingParam, param)
 AddSubConfig(GPUSettingsProcessingNNclusterizer, nn)
 AddHelp("help", 'h')
diff --git a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
index 35ebbabe41672..46fd50464c69b 100644
--- a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
+++ b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
@@ -30,6 +30,7 @@
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessing + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingParam + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingRTC + ;
+#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingRTCtechnical + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingNNclusterizer + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplay + ;
 #pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplayLight + ;
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 5259bbf951d73..bc92a686ab889 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -327,11 +327,11 @@ if has_detector_calib PHS && workflow_has_parameter CALIB; then
 fi
 
 [[ ${O2_GPU_DOUBLE_PIPELINE:-$EPNSYNCMODE} == 1 && $GPUTYPE != "CPU" ]] && GPU_CONFIG+=" --enableDoublePipeline"
-[[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc_rtc.enable=1;GPU_proc_rtc.cacheOutput=1;GPU_proc.RTCprependCommand=/usr/bin/env TMPDIR=/tmp /usr/bin/taskset -c 0-191;"
-[[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 && $EPNSYNCMODE == 1 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCcacheFolder=/var/tmp/o2_gpu_rtc_cache;"
+[[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc_rtc.enable=1;GPU_proc_rtc.cacheOutput=1;GPU_proc.RTCTECH.prependCommand=/usr/bin/env TMPDIR=/tmp /usr/bin/taskset -c 0-191;"
+[[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 && $EPNSYNCMODE == 1 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCTECH.cacheFolder=/var/tmp/o2_gpu_rtc_cache;"
 if [[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 ]] && [[ ( ${ALICE_O2_FST:-0} == 1 && ${FST_TMUX_NO_EPN:-0} == 0 ) || $EPNSYNCMODE == 1 ]]; then
-  [[ ${EPN_NODE_MI100:-0} == 0 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCoverrideArchitecture=--offload-arch=gfx906;"
-  [[ ${EPN_NODE_MI100:-0} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCoverrideArchitecture=--offload-arch=gfx908;"
+  [[ ${EPN_NODE_MI100:-0} == 0 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCTECH.overrideArchitecture=--offload-arch=gfx906;"
+  [[ ${EPN_NODE_MI100:-0} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCTECH.overrideArchitecture=--offload-arch=gfx908;"
 fi
 
 ( workflow_has_parameter AOD || [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-emcal-cell-writer-workflow ) && has_detector EMC && RAW_EMC_SUBSPEC=" --subspecification 1 "

From fc838513dcab8f20b16be947392e0777e19a737d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 16:44:13 +0100
Subject: [PATCH 0166/1764] Fix ROOT macro tests

---
 cmake/O2RootMacroExclusionList.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/O2RootMacroExclusionList.cmake b/cmake/O2RootMacroExclusionList.cmake
index d5596ccc424f4..ab79a802a6e3a 100644
--- a/cmake/O2RootMacroExclusionList.cmake
+++ b/cmake/O2RootMacroExclusionList.cmake
@@ -43,6 +43,7 @@ list(APPEND O2_ROOT_MACRO_EXCLUSION_LIST
             GPU/GPUTracking/Merger/macros/fitPolynomialFieldTpc.C # Needs AliRoot AliMagF
             GPU/GPUTracking/Merger/macros/fitPolynomialFieldTrd.C # Needs AliRoot AliMagF
             GPU/GPUTracking/Standalone/tools/dumpTRDClusterMatrices.C # Needs AliRoot AliCDBManager, AliGeomManager and AliTRDgeometry
+            GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C # Exampple, which needs special headers to work
             GPU/GPUTracking/TRDTracking/macros/checkDbgOutput.C # Needs AliRoot TStatToolkit
             GPU/TPCFastTransformation/devtools/loadlibs.C # Special macro
             GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C # Not yet ready
@@ -58,7 +59,6 @@ list(APPEND O2_ROOT_MACRO_EXCLUSION_LIST
             macro/CreateSampleIRFrames.C
             Detectors/Upgrades/ALICE3/macros/ALICE3Field.C)
 
-
 if(NOT BUILD_SIMULATION)
   # some complete sub_directories are not added to the build when not building
   # simulation, so the corresponding o2_add_test_root_macro won't be called at

From dc40fc3d252dbf752dd6facd9946cf62fddc9df1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 19:50:29 +0100
Subject: [PATCH 0167/1764] GPU RTC: Fix launch bounds, cut 3rd runtime
 parameter to force number of blocks started

---
 GPU/GPUTracking/Definitions/GPUDefParametersDefault.h         | 2 ++
 GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
index 1193731acd9cf..60403f3afbffc 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
@@ -24,6 +24,8 @@
 #include "GPUCommonDef.h"
 #include "GPUDefMacros.h"
 
+// Launch bound definition, 3 optional parameters: maxThreads per block, minBlocks per multiprocessor, force number of blocks (not passed to compiler as launch bounds)
+
 // GPU Run Configuration
 #ifdef GPUCA_GPUCODE
 #if defined(GPUCA_GPUTYPE_MI2xx)
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
index 73f7b5155fbdd..cd1875ecefcf7 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
@@ -37,7 +37,7 @@ static GPUDefParameters GPUDefParametersLoad()
     if (par.par_LB_minBlocks[i] > 0) {                                                                             \
       o << ", " << par.par_LB_minBlocks[i];                                                                        \
     }                                                                                                              \
-    if (par.par_LB_forceBlocks[i] > 0) {                                                                           \
+    if (!forRTC && par.par_LB_forceBlocks[i] > 0) {                                                                \
       o << ", " << par.par_LB_forceBlocks[i];                                                                      \
     }                                                                                                              \
     o << "\n";                                                                                                     \

From 13b9e9cb121b34580ce37973d33817fc7fc0cd96 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 12:57:02 +0100
Subject: [PATCH 0168/1764] GPU: Delete obsolete AliRoot file

---
 .../tools/switchToAliRootLicense.sh           | 26 -------------------
 1 file changed, 26 deletions(-)
 delete mode 100755 GPU/GPUTracking/Standalone/tools/switchToAliRootLicense.sh

diff --git a/GPU/GPUTracking/Standalone/tools/switchToAliRootLicense.sh b/GPU/GPUTracking/Standalone/tools/switchToAliRootLicense.sh
deleted file mode 100755
index 94545950805a0..0000000000000
--- a/GPU/GPUTracking/Standalone/tools/switchToAliRootLicense.sh
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/bin/bash
-cd ../../../../
-if [ $(ls | grep GPU | wc -l) != "1" ]; then
-    echo Incorrect directory
-    exit 1
-fi
-
-git grep -l "^// Copyright 2019-2020 CERN and copyright holders of ALICE O2." | \
-    grep "^GPU/Common/\|^GPU/GPUTracking/\|^GPU/TPCFastTransformation|^GPU/TPCSpaceChargeBase\|^cmake" | \
-    xargs -r -n 1 \
-    sed -i -e '/Copyright 2019-2020 CERN and copyright holders of ALICE O2./,/or submit itself to any jurisdiction/c\
-//**************************************************************************\
-//* This file is property of and copyright by the ALICE Project            *\
-//* ALICE Experiment at CERN, All rights reserved.                         *\
-//*                                                                        *\
-//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *\
-//*                  for The ALICE HLT Project.                            *\
-//*                                                                        *\
-//* Permission to use, copy, modify and distribute this software and its   *\
-//* documentation strictly for non-commercial purposes is hereby granted   *\
-//* without fee, provided that the above copyright notice appears in all   *\
-//* copies and that both the copyright notice and this permission notice   *\
-//* appear in the supporting documentation. The authors make no claims     *\
-//* about the suitability of this software for any purpose. It is          *\
-//* provided "as is" without express or implied warranty.                  *\
-//**************************************************************************\'

From bcf59e8179371a0040038ab426d2c2d098f3f504 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 12:57:19 +0100
Subject: [PATCH 0169/1764] GPU RTC: Add option to load runtime launch bounds
 parameters from file

---
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx   | 17 +++++++++++++++++
 GPU/GPUTracking/Definitions/GPUSettingsList.h   |  1 +
 2 files changed, 18 insertions(+)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index c6bbc26977f09..c3d614b8d9f98 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -59,6 +59,23 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
   std::string baseCommand = (mProcessingSettings.rtctech.prependCommand != "" ? (mProcessingSettings.rtctech.prependCommand + " ") : "");
   baseCommand += (getenv("O2_GPU_RTC_OVERRIDE_CMD") ? std::string(getenv("O2_GPU_RTC_OVERRIDE_CMD")) : std::string(_binary_GPUReconstructionCUDArtc_command_start, _binary_GPUReconstructionCUDArtc_command_len));
   baseCommand += std::string(" ") + (mProcessingSettings.rtctech.overrideArchitecture != "" ? mProcessingSettings.rtctech.overrideArchitecture : std::string(_binary_GPUReconstructionCUDArtc_command_arch_start, _binary_GPUReconstructionCUDArtc_command_arch_len));
+
+  if (mProcessingSettings.rtctech.loadLaunchBoundsFromFile.size()) {
+    FILE* fp = fopen(mProcessingSettings.rtctech.loadLaunchBoundsFromFile.c_str(), "rb");
+    if (fp == nullptr) {
+      throw std::runtime_error("Cannot open launch bounds parameter module file");
+    }
+    fseek(fp, 0, SEEK_END);
+    size_t size = ftell(fp);
+    if (size != sizeof(*mParDevice)) {
+      throw std::runtime_error("launch bounds parameter file has incorrect size");
+    }
+    fseek(fp, 0, SEEK_SET);
+    if (fread(mParDevice, 1, size, fp) != size) {
+      throw std::runtime_error("Error reading launch bounds parameter file");
+    }
+    fclose(fp);
+  }
   const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true);
   if (mProcessingSettings.rtctech.printLaunchBounds || mProcessingSettings.debugLevel >= 3) {
     GPUInfo("RTC Launch Bounds:\n%s", launchBounds.c_str());
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index d3a3fbaff16ff..5d716d32d928f 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -228,6 +228,7 @@ AddOption(printLaunchBounds, bool, false, "", 0, "Print launch bounds used for R
 AddOption(cacheFolder, std::string, "./rtccache/", "", 0, "Folder in which the cache file is stored")
 AddOption(prependCommand, std::string, "", "", 0, "Prepend RTC compilation commands by this string")
 AddOption(overrideArchitecture, std::string, "", "", 0, "Override arhcitecture part of RTC compilation command line") // Part of cmdLine, so checked against the cache
+AddOption(loadLaunchBoundsFromFile, std::string, "", "", 0, "Load a parameter object containing the launch bounds from a file")
 AddHelp("help", 'h')
 EndConfig()
 

From 483990f5e733c3549bd29ff2e14b24f19c9fb20c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 14:56:05 +0100
Subject: [PATCH 0170/1764] GPU Tools: Fix some copyright notices

---
 GPU/GPUTracking/Standalone/tools/createGeo.C       | 14 ++++++++++++++
 GPU/GPUTracking/Standalone/tools/createGeo.sh      | 11 +++++++++++
 GPU/GPUTracking/Standalone/tools/createLUT.C       | 14 ++++++++++++++
 .../Standalone/tools/dumpTRDClusterMatrices.C      | 11 +++++++++++
 4 files changed, 50 insertions(+)

diff --git a/GPU/GPUTracking/Standalone/tools/createGeo.C b/GPU/GPUTracking/Standalone/tools/createGeo.C
index 5684f2cc92da6..307d687f716d1 100644
--- a/GPU/GPUTracking/Standalone/tools/createGeo.C
+++ b/GPU/GPUTracking/Standalone/tools/createGeo.C
@@ -1,3 +1,17 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CreateGeo.C
+/// \author David Rohr
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 #include <TSystem.h>
 #include "TRDBase/GeometryFlat.h"
diff --git a/GPU/GPUTracking/Standalone/tools/createGeo.sh b/GPU/GPUTracking/Standalone/tools/createGeo.sh
index a449e1997a16e..49176f231aa80 100755
--- a/GPU/GPUTracking/Standalone/tools/createGeo.sh
+++ b/GPU/GPUTracking/Standalone/tools/createGeo.sh
@@ -1,3 +1,14 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
 #!/bin/bash
 
 PATH=$PATH:/usr/share/Modules/bin/:/home/qon/alice/alibuild
diff --git a/GPU/GPUTracking/Standalone/tools/createLUT.C b/GPU/GPUTracking/Standalone/tools/createLUT.C
index 83e46da29b9a3..7bb4edbf89f18 100644
--- a/GPU/GPUTracking/Standalone/tools/createLUT.C
+++ b/GPU/GPUTracking/Standalone/tools/createLUT.C
@@ -1,3 +1,17 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CreateLUT.C
+/// \author David Rohr
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 #include <TSystem.h>
 #include "DetectorsBase/MatLayerCylSet.h"
diff --git a/GPU/GPUTracking/Standalone/tools/dumpTRDClusterMatrices.C b/GPU/GPUTracking/Standalone/tools/dumpTRDClusterMatrices.C
index 757875e4199b3..c747a226f5edf 100644
--- a/GPU/GPUTracking/Standalone/tools/dumpTRDClusterMatrices.C
+++ b/GPU/GPUTracking/Standalone/tools/dumpTRDClusterMatrices.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 #include "AliCDBManager.h"
 #include "AliGeomManager.h"
 #include "AliTRDgeometry.h"

From ca4e47c5efea3cab22a4174b754fb60a32dfbdb5 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Mar 2025 14:56:47 +0100
Subject: [PATCH 0171/1764] GPU RTC: Add tool to dump GPU RTC launch bound
 parameter object

---
 GPU/Common/CMakeLists.txt                     |  5 +++
 GPU/GPUTracking/CMakeLists.txt                |  9 ++++-
 .../Standalone/tools/dumpGPUDefParam.C        | 38 +++++++++++++++++++
 3 files changed, 50 insertions(+), 2 deletions(-)
 create mode 100644 GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C

diff --git a/GPU/Common/CMakeLists.txt b/GPU/Common/CMakeLists.txt
index efac4fc436758..6951c3b2339b8 100644
--- a/GPU/Common/CMakeLists.txt
+++ b/GPU/Common/CMakeLists.txt
@@ -64,3 +64,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   endif()
   install(FILES ${HDRS_INSTALL} DESTINATION include/GPU)
 endif()
+
+if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
+  install(FILES ${HDRS_INSTALL}
+  DESTINATION include)
+endif()
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 33715909e810c..fe2fefe2412c0 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -258,7 +258,7 @@ file(GENERATE
 if(NOT ALIGPU_BUILD_TYPE STREQUAL "O2")
   include_directories(${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
 endif()
-set(HDRS_INSTALL ${HDRS_INSTALL} ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUReconstructionKernelList.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParameters.h)
+set(HDRS_INSTALL ${HDRS_INSTALL} ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUReconstructionKernelList.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParameters.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoad.inc)
 include(kernels.cmake)
 
 # Optional sources depending on optional dependencies
@@ -376,13 +376,18 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
 
   if(GPUCA_CONFIG_ROOT)
     ROOT_GENERATE_DICTIONARY(G__${targetName} ${HDRS_CINT_O2} ${HDRS_CINT_DATATYPES} ${HDRS_CINT_O2_ADDITIONAL} GPUTrackingLinkDef_Standalone.h MODULE ${targetName})
-    INSTALL(FILES
+    install(FILES
       ${CMAKE_CURRENT_BINARY_DIR}/lib${targetName}_rdict.pcm
       ${CMAKE_CURRENT_BINARY_DIR}/lib${targetName}.rootmap
     DESTINATION .)
   else()
     target_compile_definitions(${targetName} PRIVATE GPUCA_NO_ROOT)
   endif()
+  install(FILES ${HDRS_SRCS} ${HDRS_CINT_O2} ${HDRS_CINT_DATATYPES} ${HDRS_INSTALL}
+          DESTINATION include)
+  install(DIRECTORY utils
+          DESTINATION include
+          FILES_MATCHING PATTERN *.h)
 endif()
 
 # GPUReconstructionLibrary needs to know which GPU backends are enabled for proper error messages
diff --git a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
new file mode 100644
index 0000000000000..4a2575c40d79a
--- /dev/null
+++ b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
@@ -0,0 +1,38 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file dumpGPUDefParam.C
+/// \author David Rohr
+
+// Run e.g. as:
+// ROOT_INCLUDE_PATH="`pwd`/include" root -l -q -b src/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C'()'
+
+// Logic for testing to load the default parameters
+/*#define GPUCA_GPUCODE
+#define GPUCA_GPUTYPE_AMPERE
+#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
+#define GPUCA_MAXN 40
+#define GPUCA_ROW_COUNT 152
+#define GPUCA_TPC_COMP_CHUNK_SIZE 1024
+#include "GPUDefParametersDefault.h"*/
+
+// Load file that sets GPUDefParameters
+#include "testParam.h"
+
+#include "GPUDefParametersLoad.inc"
+void dumpGPUDefParam()
+{
+  auto param = o2::gpu::internal::GPUDefParametersLoad();
+  printf("Loaded params:\n%s", o2::gpu::internal::GPUDefParametersExport(param, false).c_str());
+  FILE* fp = fopen("parameters.out", "w+b");
+  fwrite(&param, 1, sizeof(param), fp);
+  fclose(fp);
+}

From 8d768c987a76ab1e5805668254543604f289c089 Mon Sep 17 00:00:00 2001
From: Maurice Coquet <mcoquet@lxplus976.cern.ch>
Date: Sat, 29 Mar 2025 16:07:38 +0100
Subject: [PATCH 0172/1764] MFT: Not using IRFrames in COSMICS

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index bc92a686ab889..04e147c7b2e6d 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -117,7 +117,7 @@ if [[ $SYNCMODE == 1 ]]; then
   [[ ! -z ${CUT_RANDOM_FRACTION_ITS:-} ]] && ITS_CONFIG_KEY+="fastMultConfig.cutRandomFraction=$CUT_RANDOM_FRACTION_ITS;"
   ITS_CONFIG_KEY+="ITSCATrackerParam.trackletsPerClusterLimit=${CUT_TRACKLETSPERCLUSTER_MAX_ITS:--1};ITSCATrackerParam.cellsPerClusterLimit=${CUT_CELLSPERCLUSTER_MAX_ITS:--1};"
   if has_detector_reco ITS; then
-    [[ $RUNTYPE == "COSMICS" ]] && MFT_CONFIG_KEY+="MFTTracking.irFramesOnly=1;"
+    [[ $RUNTYPE != "COSMICS" ]] && MFT_CONFIG_KEY+="MFTTracking.irFramesOnly=1;"
   fi
 
   PVERTEXING_CONFIG_KEY+="pvertexer.meanVertexExtraErrConstraint=0.3;" # for calibration relax the constraint

From ce608379d0798c5f10623ae5125dff44cfb4a1b5 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Wed, 26 Mar 2025 11:38:47 +0100
Subject: [PATCH 0173/1764] Remove perPV from FST

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 04e147c7b2e6d..2b3f876c5b58d 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -140,7 +140,7 @@ else
   if [[ $BEAMTYPE == "pp" ]]; then
     ITS_CONFIG_KEY+="ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;"
   elif [[ $BEAMTYPE == "PbPb" ]]; then
-    ITS_CONFIG_KEY+="ITSVertexerParam.lowMultBeamDistCut=0;ITSCATrackerParam.nROFsPerIterations=12;ITSCATrackerParam.perPrimaryVertexProcessing=true;"
+    ITS_CONFIG_KEY+="ITSVertexerParam.lowMultBeamDistCut=0;ITSCATrackerParam.nROFsPerIterations=12;"
   fi
 
   if [[ $IS_SIMULATED_DATA == 0 && $CTFINPUT == 1 ]]; then # Enable fixes to the MCH readout mapping for async processing of real data

From 110201176c90b7db628608660043de655c46499a Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Wed, 26 Mar 2025 11:40:27 +0100
Subject: [PATCH 0174/1764] Extend FST to allow for ITS-GPU reconstruction

---
 prodtests/full-system-test/dpl-workflow.sh | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 2b3f876c5b58d..d067d9a8526e9 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -101,10 +101,14 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 
 [[ "0$DISABLE_ROOT_OUTPUT" == "00" ]] && DISABLE_ROOT_OUTPUT=
 
+has_detectors_gpu TPC ITS && GPU_INPUT+=",its-clusters"
+has_detectors_gpu TPC ITS && GPU_OUTPUT+=",its-tracks"
+
 if [[ $CTFINPUT != 1 ]]; then
   GPU_OUTPUT+=",tpc-triggers"
 fi
 if [[ $SYNCMODE == 1 ]]; then
+  has_detectors_gpu TPC ITS && ITS_CONFIG_KEY+="ITSCATrackerParam.trackingMode=0;" # sets ITS gpu reco to sync
   if [[ $BEAMTYPE == "PbPb" ]]; then
     ITS_CONFIG_KEY+="fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:-100};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:-200};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:-20};"
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=50000;MCHTracking.maxTrackingDuration=20;"
@@ -137,10 +141,12 @@ if [[ $SYNCMODE == 1 ]]; then
   has_processing_step TPC_DEDX && GPU_CONFIG_KEY+="GPU_global.rundEdx=1;"
   has_detector ITS && TRD_FILTER_CONFIG+=" --filter-trigrec"
 else
+  has_detectors_gpu TPC ITS && ITS_CONFIG_KEY+="ITSCATrackerParam.trackingMode=1;" # sets ITS gpu reco to async
   if [[ $BEAMTYPE == "pp" ]]; then
     ITS_CONFIG_KEY+="ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;"
   elif [[ $BEAMTYPE == "PbPb" ]]; then
-    ITS_CONFIG_KEY+="ITSVertexerParam.lowMultBeamDistCut=0;ITSCATrackerParam.nROFsPerIterations=12;"
+    ITS_CONFIG_KEY+="ITSVertexerParam.lowMultBeamDistCut=0;"
+    ! has_detectors_gpu TPC ITS && ITS_CONFIG_KEY+="ITSCATrackerParam.nROFsPerIterations=12;"
   fi
 
   if [[ $IS_SIMULATED_DATA == 0 && $CTFINPUT == 1 ]]; then # Enable fixes to the MCH readout mapping for async processing of real data
@@ -497,6 +503,9 @@ fi
 # if TPC correction with IDC from CCDB was requested
 has_detector TPC && [[ ${NEED_TPC_SCALERS_WF:-} == 1 ]] && add_W o2-tpc-scaler-workflow " ${TPC_SCALERS_CONF:-} "
 
+# if ITS+TPC GPU: pass ITS CKVs to the GPU WF
+has_detectors_gpu TPC ITS && GPU_CONFIG_KEY+=$ITS_CONFIG_KEY
+
 # ---------------------------------------------------------------------------------------------------------------------
 # Raw decoder workflows - disabled in async mode
 if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
@@ -530,7 +539,7 @@ fi
 # Common reconstruction workflows
 (has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $TPC_CORR_OPT --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;$TPC_CORR_KEY"
 (has_detector_reco TOF || has_detector_ctf TOF) && ! has_detector_from_global_reader TOF && add_W o2-tof-reco-workflow "$TOF_CONFIG --input-type $TOF_INPUT --output-type $TOF_OUTPUT $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N tof-compressed-decoder TOF RAW 1),$(get_N TOFClusterer TOF REST 1)"
-has_detector_reco ITS && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--trackerCA $ITS_CONFIG $DISABLE_MC $DISABLE_DIGIT_CLUSTER_INPUT $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
+(has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--trackerCA $ITS_CONFIG $DISABLE_MC $DISABLE_DIGIT_CLUSTER_INPUT $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
 has_detector_reco FT0 && ! has_detector_from_global_reader FT0 && add_W o2-ft0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N ft0-reconstructor FT0 REST 1)"
 has_detector_reco TRD && ! has_detector_from_global_reader TRD && add_W o2-trd-tracklet-transformer "--disable-irframe-reader $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_FILTER_CONFIG --pipeline $(get_N TRDTRACKLETTRANSFORMER TRD REST 1 TRDTRKTRANS)"
 has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $SEND_ITSTPC_DTGL  $TPC_CORR_OPT --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
@@ -539,7 +548,7 @@ has_detector_reco TOF && [[ ! -z "$TOF_SOURCES" ]] && ! has_detector_from_global
 has_detectors TPC && [[ -z "$DISABLE_ROOT_OUTPUT" && "${SKIP_TPC_CLUSTERSTRACKS_OUTPUT:-}" != 1 ]] && ! has_detector_from_global_reader TPC && add_W o2-tpc-reco-workflow "--input-type pass-through --output-type clusters,tpc-triggers,tracks,send-clusters-per-sector $DISABLE_MC"
 
 # ---------------------------------------------------------------------------------------------------------------------
-# Reconstruction workflows normally active only in async mode in async mode ($LIST_OF_ASYNC_RECO_STEPS), but can be forced via $WORKFLOW_EXTRA_PROCESSING_STEPS
+# Reconstruction workflows normally active only in async mode ($LIST_OF_ASYNC_RECO_STEPS), but can be forced via $WORKFLOW_EXTRA_PROCESSING_STEPS
 has_detector MID && ! has_detector_from_global_reader MID && has_processing_step MID_RECO && add_W o2-mid-reco-workflow "$DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N MIDClusterizer MID REST 1),$(get_N MIDTracker MID REST 1)"
 has_detector MCH && ! has_detector_from_global_reader MCH && has_processing_step MCH_RECO && add_W o2-mch-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N mch-track-finder MCH REST 1 MCHTRK),$(get_N mch-cluster-finder MCH REST 1 MCHCL),$(get_N mch-cluster-transformer MCH REST 1)" "$MCH_CONFIG_KEY"
 has_detector MFT && ! has_detector_from_global_reader MFT && has_processing_step MFT_RECO && add_W o2-mft-reco-workflow "$DISABLE_DIGIT_CLUSTER_INPUT $DISABLE_MC $DISABLE_ROOT_OUTPUT $MFT_CONFIG --pipeline $(get_N mft-tracker MFT REST 1 MFTTRK)" "$MFT_CONFIG_KEY;$ITSMFT_STROBES"
@@ -574,6 +583,7 @@ has_detector_reco MCH && ( [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output
 has_detector_reco MCH && ( [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-mch-digits-writer-workflow ) && ! has_detector_from_global_reader MCH && add_W o2-mch-digits-writer-workflow "--input-digits-data-description F-DIGITS --input-digitrofs-data-description TC-F-DIGITROFS --mch-digit-outfile mchfdigits.root" "" 0
 has_detector_reco MCH && ( [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-mch-clusters-writer-workflow ) && ! has_detector_from_global_reader MCH && add_W o2-mch-clusters-writer-workflow "" "" 0
 has_detector_reco MCH && ( [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-mch-preclusters-writer-workflow ) && ! has_detector_from_global_reader MCH && add_W o2-mch-preclusters-writer-workflow "" "" 0
+has_detector_reco ITS && has_detector_gpu ITS TPC && [[ -z "$DISABLE_ROOT_OUTPUT" ]] && ! has_detector_from_global_reader ITS && add_W o2-its-track-writer-workflow "$DISABLE_MC" "" 0
 
 # always run vertexing if requested and if there are some sources, but in cosmic mode we work in pass-trough mode (create record for non-associated tracks)
 ( [[ $BEAMTYPE == "cosmic" ]] || ! has_detector_reco ITS) && PVERTEX_CONFIG+=" --skip"

From eaf7db396016a9bc4221360af932d19ff52c5157 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 29 Mar 2025 20:41:57 +0100
Subject: [PATCH 0175/1764] GPU Standalone: Use LAZY CMake install message

---
 GPU/GPUTracking/Standalone/CMakeLists.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index dfc8e8db3bc7a..fbc256d5d7f91 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -13,6 +13,8 @@
 cmake_minimum_required(VERSION 3.27 FATAL_ERROR)
 project(GPUTrackingStandalone)
 include(FeatureSummary)
+set(CMAKE_INSTALL_MESSAGE LAZY)
+
 set(CMAKE_INSTALL_BINDIR "${CMAKE_INSTALL_PREFIX}")
 set(CMAKE_INSTALL_LIBDIR "${CMAKE_INSTALL_PREFIX}")
 set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}")

From 7882df8a79307eeb9bd3b9af9c1ac0cd313abd4e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 29 Mar 2025 21:44:06 +0100
Subject: [PATCH 0176/1764] GPU RTC: Simplify the way LB preprocessor
 definitions are imported as parameter object, and replace explicit invalid
 list with CMake-auto-generated one

---
 .../Base/GPUReconstructionProcessing.cxx      |   5 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        |   6 +-
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx |   5 +-
 .../Base/opencl/GPUReconstructionOCL.cxx      |   2 -
 GPU/GPUTracking/CMakeLists.txt                |  25 +-
 .../Definitions/GPUDefParametersDefault.h     | 312 ++----------------
 .../GPUDefParametersLoad.template.inc         |   8 +-
 .../Standalone/tools/dumpGPUDefParam.C        |   1 -
 8 files changed, 54 insertions(+), 310 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
index 95a47dec946e6..d02309f66c762 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
@@ -12,12 +12,9 @@
 /// \file GPUReconstructionProcessing.cxx
 /// \author David Rohr
 
-#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
-#include "GPUDefParametersDefault.h"
-#include "GPUDefParametersLoad.inc"
-
 #include "GPUReconstructionProcessing.h"
 #include "GPUReconstructionThreading.h"
+#include "GPUDefParametersLoad.inc"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 4cfdf7febabd7..1b830ca95d4fb 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -14,11 +14,6 @@
 
 #define GPUCA_GPUCODE_HOSTONLY
 
-#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
-#include "GPUReconstructionCUDADef.h"
-#include "GPUDefParametersDefault.h"
-#include "GPUDefParametersLoad.inc"
-
 #include "GPUReconstructionCUDAIncludesSystem.h"
 #include "GPUReconstructionCUDADef.h"
 #include <cuda_profiler_api.h>
@@ -28,6 +23,7 @@
 #include "GPUReconstructionIncludes.h"
 #include "GPUParamRTC.h"
 #include "GPUReconstructionCUDAHelpers.inc"
+#include "GPUDefParametersLoad.inc"
 
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1
 #include "utils/qGetLdBinarySymbols.h"
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index c3d614b8d9f98..5f481d2cb9058 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -13,13 +13,10 @@
 /// \author David Rohr
 
 #define GPUCA_GPUCODE_HOSTONLY
-#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
-#include "GPUDefParametersDefault.h"
-#include "GPUDefParametersLoad.inc"
 
 #include "GPUReconstructionCUDA.h"
 #include "GPUParamRTC.h"
-#include "GPUDefMacros.h"
+#include "GPUDefParametersLoad.inc"
 #include <unistd.h>
 #include "Framework/SHA1.h"
 #include <sys/stat.h>
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index 7310b8b6041a9..af26bfc7aeca8 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -12,9 +12,7 @@
 /// \file GPUReconstructionOCL.cxx
 /// \author David Rohr
 
-#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
 #include "GPUReconstructionOCLIncludesHost.h"
-#include "GPUDefParametersDefault.h"
 #include "GPUDefParametersLoad.inc"
 
 #include <map>
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index fe2fefe2412c0..e722d375e4b93 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -231,7 +231,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
 endif()
 
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
-file(GENERATE
+file(GENERATE # TODO: Do this as a list
      OUTPUT include_gpu_onthefly/GPUReconstructionKernelList.h
      INPUT Base/GPUReconstructionKernelList.template.h
 )
@@ -255,10 +255,19 @@ file(GENERATE
      OUTPUT include_gpu_onthefly/GPUDefParametersLoad.inc
      INPUT Definitions/GPUDefParametersLoad.template.inc
 )
-if(NOT ALIGPU_BUILD_TYPE STREQUAL "O2")
-  include_directories(${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
-endif()
-set(HDRS_INSTALL ${HDRS_INSTALL} ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUReconstructionKernelList.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParameters.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoad.inc)
+file(GENERATE
+     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase
+     CONTENT "$<JOIN:$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,\n>"
+)
+add_custom_command(
+  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h
+  COMMAND awk "{print(\"#ifndef GPUCA_LB_\" $0 \"\\n#define GPUCA_LB_\" $0 \" 0\\n#endif\")}" ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase > ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h
+  COMMENT "Generating GPUDefParametersLoadPrepare.h"
+  VERBATIM
+  COMMAND_EXPAND_LISTS
+)
+
+set(HDRS_INSTALL ${HDRS_INSTALL} ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUReconstructionKernelList.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParameters.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoad.inc ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h)
 include(kernels.cmake)
 
 # Optional sources depending on optional dependencies
@@ -396,6 +405,12 @@ set_source_files_properties(Base/GPUReconstructionLibrary.cxx
                             PROPERTIES
                             INCLUDE_DIRECTORIES "${CMAKE_CURRENT_BINARY_DIR}")
 
+# Make sure header files generated with add_custom_command are built
+target_sources(${targetName}
+               PRIVATE FILE_SET "generatedHeaders"
+               TYPE HEADERS
+               FILES ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h # TODO: build file list for this
+               BASE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
 
 # Add compile definitions and libraries depending on available optional dependencies
 if(GPUCA_QA)
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
index 60403f3afbffc..4435e69c60ff6 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
@@ -492,6 +492,30 @@
     #define GPUCA_LB_GPUitoa GPUCA_THREAD_COUNT, 1
   #endif
   #define GPUCA_GET_THREAD_COUNT(...) GPUCA_M_FIRST(__VA_ARGS__)
+
+  // These kernel launch-bounds are derrived from one of the constants set above
+  #define GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression GPUCA_LB_GPUTPCCFNoiseSuppression
+  #define GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks GPUCA_LB_GPUTPCCFNoiseSuppression
+
+  #ifdef GPUCA_HAS_ONNX
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression GPUCA_LB_GPUTPCNNClusterizerKernels
+  #endif
+
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_THREAD_COUNT_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_THREAD_COUNT_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_THREAD_COUNT_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanDown GPUCA_THREAD_COUNT_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits GPUCA_THREAD_COUNT_SCAN
+  #define GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered GPUCA_LB_COMPRESSION_GATHER
+  #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered32 GPUCA_LB_COMPRESSION_GATHER
+  #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64 GPUCA_LB_COMPRESSION_GATHER
+  #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered128 GPUCA_LB_COMPRESSION_GATHER
+  #define GPUCA_LB_GPUTPCCompressionGatherKernels_multiBlock GPUCA_LB_COMPRESSION_GATHER
 #else
   #define GPUCA_GET_THREAD_COUNT(...) 1 // On the host, a thread is a block, and we run 1 "device thread" per block.
 #endif
@@ -500,29 +524,6 @@
 
 #define GPUCA_THREAD_COUNT_SCAN 512 // TODO: WARNING!!! Must not be GPUTYPE-dependent right now! // TODO: Fix!
 
-#define GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression GPUCA_LB_GPUTPCCFNoiseSuppression
-#define GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks GPUCA_LB_GPUTPCCFNoiseSuppression
-
-#ifdef GPUCA_HAS_ONNX
-#define GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer GPUCA_LB_GPUTPCNNClusterizerKernels
-#define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN GPUCA_LB_GPUTPCNNClusterizerKernels
-#define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels GPUCA_LB_GPUTPCNNClusterizerKernels
-#define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
-#define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
-#define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression GPUCA_LB_GPUTPCNNClusterizerKernels
-#endif
-
-#define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_THREAD_COUNT_SCAN
-#define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_THREAD_COUNT_SCAN
-#define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_THREAD_COUNT_SCAN
-#define GPUCA_LB_GPUTPCCFStreamCompaction_scanDown GPUCA_THREAD_COUNT_SCAN
-#define GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits GPUCA_THREAD_COUNT_SCAN
-#define GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered GPUCA_LB_COMPRESSION_GATHER
-#define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered32 GPUCA_LB_COMPRESSION_GATHER
-#define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64 GPUCA_LB_COMPRESSION_GATHER
-#define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered128 GPUCA_LB_COMPRESSION_GATHER
-#define GPUCA_LB_GPUTPCCompressionGatherKernels_multiBlock GPUCA_LB_COMPRESSION_GATHER
-
 #if defined(__CUDACC__) || defined(__HIPCC__)
   #define GPUCA_SPECIALIZE_THRUST_SORTS
 #endif
@@ -622,270 +623,5 @@
 #define GPUCA_NEW_ALIGNMENT (std::align_val_t{GPUCA_BUFFER_ALIGNMENT})
 #define GPUCA_OPERATOR_NEW_ALIGNMENT ,GPUCA_NEW_ALIGNMENT
 
-#ifdef GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
-  // Invalid default values, must not be used, but needed for now to make the GPUDefParametersLoad() happy // TOCO: cleanup
-  #ifndef GPUCA_LB_GPUTPCCreateTrackingData
-    #define GPUCA_LB_GPUTPCCreateTrackingData 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCTrackletConstructor
-    #define GPUCA_LB_GPUTPCTrackletConstructor 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCTrackletSelector
-    #define GPUCA_LB_GPUTPCTrackletSelector 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCNeighboursFinder
-    #define GPUCA_LB_GPUTPCNeighboursFinder 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCNeighboursCleaner
-    #define GPUCA_LB_GPUTPCNeighboursCleaner 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCExtrapolationTracking
-    #define GPUCA_LB_GPUTPCExtrapolationTracking 0
-  #endif
-  #ifndef GPUCA_LB_GPUTRDTrackerKernels_gpuVersion
-    #define GPUCA_LB_GPUTRDTrackerKernels_gpuVersion 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCreateOccupancyMap_fill
-    #define GPUCA_LB_GPUTPCCreateOccupancyMap_fill 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCreateOccupancyMap_fold
-    #define GPUCA_LB_GPUTPCCreateOccupancyMap_fold 0
-  #endif
-  #ifndef GPUCA_LB_GPUTRDTrackerKernels_o2Version
-    #define GPUCA_LB_GPUTRDTrackerKernels_o2Version 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCConvertKernel
-    #define GPUCA_LB_GPUTPCConvertKernel 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCompressionKernels_step0attached
-    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCompressionKernels_step1unattached
-    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionKernels_step0attached
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionKernels_step1unattached
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_sortPerSectorRow
-    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_sortPerSectorRow 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters
-    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters
-    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFDecodeZS
-    #define GPUCA_LB_GPUTPCCFDecodeZS 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFDecodeZSLink
-    #define GPUCA_LB_GPUTPCCFDecodeZSLink 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFDecodeZSDenseLink
-    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFGather
-    #define GPUCA_LB_GPUTPCCFGather 0
-  #endif
-  #ifndef GPUCA_LB_COMPRESSION_GATHER
-    #define GPUCA_LB_COMPRESSION_GATHER 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerTrackFit
-    #define GPUCA_LB_GPUTPCGMMergerTrackFit 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerFollowLoopers
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerSectorRefit
-    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerUnpackResetIds
-    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerUnpackGlobal
-    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step0
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step1
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step2
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step3
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step4
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerClearLinks
-    #define GPUCA_LB_GPUTPCGMMergerClearLinks 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare
-    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare
-    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_step0
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_step2
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeCE
-    #define GPUCA_LB_GPUTPCGMMergerMergeCE 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks
-    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerCollect
-    #define GPUCA_LB_GPUTPCGMMergerCollect 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerSortTracksPrepare
-    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step0
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_step0 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step1
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_step1 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step2
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_step2 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step0
-    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step0 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step1
-    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step1 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step2
-    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step2 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMO2Output_prepare
-    #define GPUCA_LB_GPUTPCGMO2Output_prepare 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMO2Output_output
-    #define GPUCA_LB_GPUTPCGMO2Output_output 0
-  #endif
-  #ifndef GPUCA_LB_GPUITSFitterKernels
-    #define GPUCA_LB_GPUITSFitterKernels 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCStartHitsFinder
-    #define GPUCA_LB_GPUTPCStartHitsFinder 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCStartHitsSorter
-    #define GPUCA_LB_GPUTPCStartHitsSorter 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFCheckPadBaseline
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFPeakFinder
-    #define GPUCA_LB_GPUTPCCFPeakFinder 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFNoiseSuppression
-    #define GPUCA_LB_GPUTPCCFNoiseSuppression 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFDeconvolution
-    #define GPUCA_LB_GPUTPCCFDeconvolution 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFClusterizer
-    #define GPUCA_LB_GPUTPCCFClusterizer 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCNNClusterizerKernels
-    #define GPUCA_LB_GPUTPCNNClusterizerKernels 0
-  #endif
-  #ifndef GPUCA_LB_GPUTrackingRefitKernel_mode0asGPU
-    #define GPUCA_LB_GPUTrackingRefitKernel_mode0asGPU 0
-  #endif
-  #ifndef GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov
-    #define GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov 0
-  #endif
-  #ifndef GPUCA_LB_GPUMemClean16
-    #define GPUCA_LB_GPUMemClean16 0
-  #endif
-  #ifndef GPUCA_LB_GPUitoa
-    #define GPUCA_LB_GPUitoa 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCExtrapolationTrackingCopyNumbers
-    #define GPUCA_LB_GPUTPCExtrapolationTrackingCopyNumbers 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCSectorDebugSortKernels_hitData
-    #define GPUCA_LB_GPUTPCSectorDebugSortKernels_hitData 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCSectorDebugSortKernels_startHits
-    #define GPUCA_LB_GPUTPCSectorDebugSortKernels_startHits 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCSectorDebugSortKernels_sectorTracks
-    #define GPUCA_LB_GPUTPCSectorDebugSortKernels_sectorTracks 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_clearIds
-    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_clearIds 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_sectorTracks
-    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_sectorTracks 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_extrapolatedTracks1
-    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_extrapolatedTracks1 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_extrapolatedTracks2
-    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_extrapolatedTracks2 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGlobalDebugSortKernels_borderTracks
-    #define GPUCA_LB_GPUTPCGlobalDebugSortKernels_borderTracks 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerUnpackSaveNumber
-    #define GPUCA_LB_GPUTPCGMMergerUnpackSaveNumber 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_step1
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step1 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_variant
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_variant 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerSortTracks
-    #define GPUCA_LB_GPUTPCGMMergerSortTracks 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerSortTracksQPt
-    #define GPUCA_LB_GPUTPCGMMergerSortTracksQPt 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMO2Output_sort
-    #define GPUCA_LB_GPUTPCGMO2Output_sort 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMO2Output_mc
-    #define GPUCA_LB_GPUTPCGMO2Output_mc 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFMCLabelFlattener_setRowOffsets
-    #define GPUCA_LB_GPUTPCCFMCLabelFlattener_setRowOffsets 0
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFMCLabelFlattener_flatten
-    #define GPUCA_LB_GPUTPCCFMCLabelFlattener_flatten 0
-  #endif
-#endif // GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
-
 // clang-format on
 #endif // GPUDEFPARAMETERSDEFAULT_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
index cd1875ecefcf7..c17244572ee0c 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
@@ -12,6 +12,12 @@
 /// \file GPUDefParametersLoad.inc
 /// \author David Rohr
 
+#include "GPUDefParametersLoadPrepare.h"
+
+#define GPUCA_M_LB_EMPTY_(...) 0
+#define GPUCA_M_LB_EMPTY_1(...) __VA_ARGS__
+#define GPUCA_M_LB_EMPTY0(...) GPUCA_M_CAT(GPUCA_M_LB_EMPTY_, __VA_OPT__(1))(__VA_ARGS__)
+
 #include "GPUDefParameters.h"
 #include "GPUDefMacros.h"
 #include <sstream>
@@ -24,7 +30,7 @@ static GPUDefParameters GPUDefParametersLoad()
 {
   return GPUDefParameters{
     // clang-format off
-    {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_LB_>,APPEND,)>,$<COMMA>>},
+    {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_LB_EMPTY0(GPUCA_M_FIRST(GPUCA_LB_>,APPEND,))>,$<COMMA>>},
     {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_LB_>,APPEND,$<COMMA>0))>,$<COMMA>>},
     {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_M_SHIFT(GPUCA_LB_>,APPEND,$<COMMA>0$<COMMA>0)))>,$<COMMA>>}
     // clang-format on
diff --git a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
index 4a2575c40d79a..4a72b0cef31a3 100644
--- a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
+++ b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
@@ -18,7 +18,6 @@
 // Logic for testing to load the default parameters
 /*#define GPUCA_GPUCODE
 #define GPUCA_GPUTYPE_AMPERE
-#define GPUCA_DEF_PARAMETERS_LOAD_DEFAULTS
 #define GPUCA_MAXN 40
 #define GPUCA_ROW_COUNT 152
 #define GPUCA_TPC_COMP_CHUNK_SIZE 1024

From 924c8e928d3dc2c2f4b42613edb514d05555405e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 31 Mar 2025 18:38:20 +0200
Subject: [PATCH 0177/1764] GPU CMake: fix some dependencies, which were just
 randomly not failing before

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt | 2 ++
 GPU/GPUTracking/Base/hip/CMakeLists.txt  | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 843fc3464e151..ff7d45ac327fa 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -158,6 +158,7 @@ elseif(GPUCA_CUDA_COMPILE_MODE STREQUAL "perkernel")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=1)
   target_compile_definitions(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},COMPILE_DEFINITIONS>)
   target_include_directories(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},INCLUDE_DIRECTORIES>)
+  target_link_libraries(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},LINK_LIBRARIES>)
   file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/cuda_kernel_module_fatbin)
   add_custom_command(
     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o
@@ -189,3 +190,4 @@ add_library(O2::GPUTrackingCUDAExternalProvider ALIAS GPUTrackingCUDAExternalPro
 set_property(TARGET GPUTrackingCUDAExternalProvider PROPERTY CUDA_SEPARABLE_COMPILATION ON)
 target_compile_definitions(GPUTrackingCUDAExternalProvider PRIVATE $<TARGET_PROPERTY:${targetName},COMPILE_DEFINITIONS>)
 target_include_directories(GPUTrackingCUDAExternalProvider PRIVATE $<TARGET_PROPERTY:${targetName},INCLUDE_DIRECTORIES>)
+add_dependencies(GPUTrackingCUDAExternalProvider O2::GPUTracking) # must not depend on GPU backend to avoid cyclic dependencies
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 5796c0c48686b..d785a8bf21d2d 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -184,6 +184,8 @@ target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracki
 add_library(${MODULE}_CXX OBJECT ${SRCS_CXX}) # Adding a C++ library for the .cxx code of the HIP library, such that it does not link to HIP libraries, and CMake HIP Language doesn't add HIP compile flags.
 target_compile_definitions(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:${TMP_BASELIB},COMPILE_DEFINITIONS>)
 target_include_directories(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:${TMP_BASELIB},INCLUDE_DIRECTORIES>)
+target_link_libraries(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:${TMP_BASELIB},LINK_LIBRARIES>)
+add_dependencies(${MODULE}_CXX O2::GPUTracking)
 target_link_libraries(${targetName} PRIVATE ${MODULE}_CXX)
 
 if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
@@ -213,6 +215,7 @@ elseif(GPUCA_HIP_COMPILE_MODE STREQUAL "perkernel")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=1)
   target_compile_definitions(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},COMPILE_DEFINITIONS>)
   target_include_directories(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},INCLUDE_DIRECTORIES>)
+  target_link_libraries(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},LINK_LIBRARIES>)
   if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
     add_dependencies(GPUTrackingHIPKernels ${MODULE}_HIPIFIED)
   endif()
@@ -249,6 +252,7 @@ target_compile_options(GPUTrackingHIPExternalProvider PRIVATE $<$<COMPILE_LANGUA
 target_link_options(GPUTrackingHIPExternalProvider PRIVATE $<$<COMPILE_LANGUAGE:HIP>:-fgpu-rdc>)
 target_compile_definitions(GPUTrackingHIPExternalProvider PRIVATE $<TARGET_PROPERTY:${targetName},COMPILE_DEFINITIONS>)
 target_include_directories(GPUTrackingHIPExternalProvider PRIVATE $<TARGET_PROPERTY:${targetName},INCLUDE_DIRECTORIES>)
+add_dependencies(GPUTrackingHIPExternalProvider O2::GPUTracking) # must not depend on GPU backend to avoid cyclic dependencies
 if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   add_dependencies(GPUTrackingHIPExternalProvider ${MODULE}_HIPIFIED)
 endif()

From 394e86f4c36353e95f19fccacd58544353554d9f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 31 Mar 2025 18:45:25 +0200
Subject: [PATCH 0178/1764] GPU HIP CMake: Remove workaround to build HIP
 kernels in separate CMake directory, now that we can compile them using HIP
 language

---
 GPU/GPUTracking/Base/hip/CMakeLists.txt            |  5 ++---
 GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt | 13 -------------
 2 files changed, 2 insertions(+), 16 deletions(-)
 delete mode 100644 GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt

diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index d785a8bf21d2d..0387bb8559833 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -207,9 +207,8 @@ endif()
 if(GPUCA_HIP_COMPILE_MODE STREQUAL "onefile")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=0)
 elseif(GPUCA_HIP_COMPILE_MODE STREQUAL "perkernel")
-  #add_library(GPUTrackingHIPKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.cu>, >)
-  #set_property(TARGET GPUTrackingHIPKernels PROPERTY HIP_FATBIN_COMPILATION ON)
-  add_subdirectory(per_kernel)
+  add_library(GPUTrackingHIPKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.hip>, >)
+  target_compile_options(GPUTrackingHIPKernels PRIVATE "--cuda-device-only")
   target_compile_options(GPUTrackingHIPKernels PRIVATE $<$<COMPILE_LANGUAGE:HIP>:-fno-gpu-rdc>)
   target_link_options(GPUTrackingHIPKernels PRIVATE $<$<COMPILE_LANGUAGE:HIP>:-fno-gpu-rdc>)
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=1)
diff --git a/GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt b/GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt
deleted file mode 100644
index 789333eea9f04..0000000000000
--- a/GPU/GPUTracking/Base/hip/per_kernel/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-# All rights not expressly granted are reserved.
-#
-# This software is distributed under the terms of the GNU General Public
-# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-#
-# In applying this license CERN does not waive the privileges and immunities
-# granted to it by virtue of its status as an Intergovernmental Organization
-# or submit itself to any jurisdiction.
-
-add_library(GPUTrackingHIPKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.hip>, >)
-set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} --cuda-device-only")

From 93bb53c5b959afbd0afbda3795ea8026b3240274 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 31 Mar 2025 22:28:52 +0200
Subject: [PATCH 0179/1764] GPU CMake: get rid of unnecessary temporary
 variable

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt |  6 ++----
 GPU/GPUTracking/Base/hip/CMakeLists.txt  | 12 +++++-------
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index ff7d45ac327fa..dd72119e3b56f 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -110,11 +110,10 @@ set(SRCS ${SRCS} ${GPU_RTC_BIN}.src.o ${GPU_RTC_BIN}.command.o ${GPU_RTC_BIN}.co
 # -------------------------------- End RTC -------------------------------------------------------
 
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
-  set(TMP_BASELIB O2::GPUTracking)
   o2_add_library(
     ${MODULE}
     SOURCES ${SRCS}
-    PUBLIC_LINK_LIBRARIES ${TMP_BASELIB} O2::ITStrackingCUDA
+    PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingCUDA
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
@@ -127,10 +126,9 @@ endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   set(targetName "${MODULE}")
-  set(TMP_BASELIB GPUTracking)
   add_library(${MODULE} SHARED ${SRCS})
   add_library(O2::${MODULE} ALIAS ${MODULE})
-  target_link_libraries(${MODULE} PUBLIC ${TMP_BASELIB})
+  target_link_libraries(${MODULE} PUBLIC O2::GPUTracking)
   install(TARGETS GPUTrackingCUDA)
   include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 endif()
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 0387bb8559833..5a68df8ac9527 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -148,11 +148,10 @@ set(SRCS ${SRCS} ${GPU_RTC_BIN}.src.o ${GPU_RTC_BIN}.command.o ${GPU_RTC_BIN}.co
 # -------------------------------- End RTC -------------------------------------------------------
 
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
-  set(TMP_BASELIB O2::GPUTracking)
   o2_add_library(
     ${MODULE}
     SOURCES ${SRCS}
-    PUBLIC_LINK_LIBRARIES ${TMP_BASELIB} O2::ITStrackingHIP
+    PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingHIP
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
@@ -171,10 +170,9 @@ endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   set(targetName "${MODULE}")
-  set(TMP_BASELIB GPUTracking)
   add_library(${MODULE} SHARED ${SRCS})
   add_library(O2::${MODULE} ALIAS ${MODULE})
-  target_link_libraries(${MODULE} PUBLIC ${TMP_BASELIB})
+  target_link_libraries(${MODULE} PUBLIC O2::GPUTracking)
   install(TARGETS GPUTrackingHIP)
   include_directories(${GPUCA_HIP_SOURCE_DIR})
 endif()
@@ -182,9 +180,9 @@ endif()
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
 add_library(${MODULE}_CXX OBJECT ${SRCS_CXX}) # Adding a C++ library for the .cxx code of the HIP library, such that it does not link to HIP libraries, and CMake HIP Language doesn't add HIP compile flags.
-target_compile_definitions(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:${TMP_BASELIB},COMPILE_DEFINITIONS>)
-target_include_directories(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:${TMP_BASELIB},INCLUDE_DIRECTORIES>)
-target_link_libraries(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:${TMP_BASELIB},LINK_LIBRARIES>)
+target_compile_definitions(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
+target_include_directories(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,INCLUDE_DIRECTORIES>)
+target_link_libraries(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,LINK_LIBRARIES>)
 add_dependencies(${MODULE}_CXX O2::GPUTracking)
 target_link_libraries(${targetName} PRIVATE ${MODULE}_CXX)
 

From d4afff4276fae2d31f6c3c79d9ec4246deff95f8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 1 Apr 2025 07:19:58 +0200
Subject: [PATCH 0180/1764] GPU: Fix codechecker: Empty destructor should be
 default

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 1b830ca95d4fb..f475929d49d50 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -82,7 +82,7 @@ GPUReconstructionCUDA::GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg
   mRtcBinExtension = ".o";
 #endif
 }
-GPUReconstructionCUDA::~GPUReconstructionCUDA() {}
+GPUReconstructionCUDA::~GPUReconstructionCUDA() = default;
 
 GPUReconstruction* GPUReconstruction_Create_CUDA(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionCUDA(cfg); }
 

From b3e20659eaf7ad73325b2c038e4e9bd1459a5b0a Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Tue, 11 Mar 2025 12:42:49 +0100
Subject: [PATCH 0181/1764] Extend gain calibration

---
 .../include/TPCCalibration/CalibdEdx.h        |  6 ++++--
 Detectors/TPC/calibration/src/CalibdEdx.cxx   |  8 ++++----
 .../TPC/calibration/src/CalibratordEdx.cxx    | 20 +++++++++----------
 Detectors/TPC/workflow/src/CalibdEdxSpec.cxx  |  9 +++++++--
 4 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CalibdEdx.h b/Detectors/TPC/calibration/include/TPCCalibration/CalibdEdx.h
index b40daa7b6e61f..20e470702a89a 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CalibdEdx.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CalibdEdx.h
@@ -121,6 +121,8 @@ class CalibdEdx
   }
   void fill(const TFIDInfo& tfid, const std::vector<TrackTPC>& tracks) { fill(tfid, gsl::span(tracks)); }
 
+  const TFIDInfo& getTFID() const { return mTFID; }
+
   /// Add counts from another container.
   void merge(const CalibdEdx* other);
 
@@ -174,10 +176,10 @@ class CalibdEdx
   constexpr static float recoverTgl(float scaledTgl, GEMstack rocType) { return scaledTgl * conf_dedx_corr::TglScale[rocType]; }
 
   /// dump this object to a file - the boost histogram is converted to a ROOT histogram -
-  void dumpToFile(const char* outFile, const char* outName) const;
+  void dumpToFile(const char* outFile);
 
   /// read the object from a file
-  static CalibdEdx readFromFile(const char* inFile, const char* inName);
+  static CalibdEdx readFromFile(const char* inFile);
 
   /// set lower and upper range in units of sigma which are used for the gaussian fits
   /// \param lowerSigma low sigma range
diff --git a/Detectors/TPC/calibration/src/CalibdEdx.cxx b/Detectors/TPC/calibration/src/CalibdEdx.cxx
index 2e20eacb94324..e1081335c04cb 100644
--- a/Detectors/TPC/calibration/src/CalibdEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalibdEdx.cxx
@@ -744,18 +744,18 @@ void CalibdEdx::finalizeDebugOutput() const
   }
 }
 
-void CalibdEdx::dumpToFile(const char* outFile, const char* outName) const
+void CalibdEdx::dumpToFile(const char* outFile)
 {
   TFile f(outFile, "RECREATE");
-  f.WriteObject(this, outName);
+  f.WriteObject(this, "calib");
   const auto* thn = getRootHist();
   f.WriteObject(thn, "histogram_data");
 }
 
-CalibdEdx CalibdEdx::readFromFile(const char* inFile, const char* inName)
+CalibdEdx CalibdEdx::readFromFile(const char* inFile)
 {
   TFile f(inFile, "READ");
-  auto* obj = (CalibdEdx*)f.Get(inName);
+  auto* obj = (CalibdEdx*)f.Get("calib");
   if (!obj) {
     CalibdEdx calTmp;
     return calTmp;
diff --git a/Detectors/TPC/calibration/src/CalibratordEdx.cxx b/Detectors/TPC/calibration/src/CalibratordEdx.cxx
index 7599e2f5d4472..bd61ca2ec6b1d 100644
--- a/Detectors/TPC/calibration/src/CalibratordEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalibratordEdx.cxx
@@ -44,10 +44,11 @@ void CalibratordEdx::finalizeSlot(Slot& slot)
   container->finalizeDebugOutput();
   mCalibs.push_back(container->getCalib());
 
-  TFType startTF = slot.getTFStart();
-  TFType endTF = slot.getTFEnd();
-  auto startTime = slot.getStartTimeMS();
-  auto endTime = slot.getEndTimeMS();
+  const TFType startTF = slot.getTFStart();
+  const TFType endTF = slot.getTFEnd();
+  const auto startTime = slot.getStartTimeMS();
+  const auto endTime = slot.getEndTimeMS();
+  const auto runNumber = container->getTFID().runNumber;
 
   mTFIntervals.emplace_back(startTF, endTF);
   mTimeIntervals.emplace_back(startTime, endTime);
@@ -56,6 +57,7 @@ void CalibratordEdx::finalizeSlot(Slot& slot)
     LOGP(info, "Dumping time slot data to file");
     auto calibCopy = container->getCalib();
     *mDebugOutputStreamer << "CalibdEdx"
+                          << "runNumber=" << runNumber
                           << "startTF=" << startTF      // Initial time frame ID of time slot
                           << "endTF=" << endTF          // Final time frame ID of time slot
                           << "startTime=" << startTime  // Initial time frame time of time slot
@@ -65,17 +67,15 @@ void CalibratordEdx::finalizeSlot(Slot& slot)
   }
 
   if (mDumpHistograms) {
-    const auto fileName = fmt::format("o2tpc_CalibratordEdx_Histos_{}_{}_{}_{}.root", startTime, endTime, startTF, endTF);
     const auto dumpTHn = (mDumpHistograms & 0x1) == 0x1;
     const auto dumpTree = (mDumpHistograms & 0x2) == 0x2;
     if (dumpTree) {
-      container->writeTTree(fileName);
+      const auto fileNameTree = fmt::format("o2tpc_CalibratordEdx_Tree_{}_{}_{}_{}_{}.root", runNumber, startTime, endTime, startTF, endTF);
+      container->writeTTree(fileNameTree);
     }
     if (dumpTHn) {
-      auto f = std::make_unique<TFile>(fileName.data(), dumpTree ? "update" : "recreate");
-      auto hn = container->getRootHist();
-      hn->Write("calibHist");
-      f->Close();
+      const auto fileName = fmt::format("o2tpc_CalibratordEdx_Histos_{}_{}_{}_{}_{}.root", runNumber, startTime, endTime, startTF, endTF);
+      container->dumpToFile(fileName.data());
     }
   }
 }
diff --git a/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx b/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
index 2eaf6125e6c29..5cf412f227d78 100644
--- a/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
@@ -82,7 +82,12 @@ class CalibdEdxDevice : public Task
       if (!fdEdxCustom || !fdEdxCustom->IsOpen() || fdEdxCustom->IsZombie()) {
         LOGP(error, "Could not open custom TimeGain file {}", mCustomdEdxFileName);
       } else {
-        const auto timeGain = fdEdxCustom->Get<o2::tpc::CalibdEdxCorrection>("CalibdEdxCorrection");
+        auto timeGain = fdEdxCustom->Get<o2::tpc::CalibdEdxCorrection>("CalibdEdxCorrection");
+
+        if (!timeGain) {
+          timeGain = fdEdxCustom->Get<o2::tpc::CalibdEdxCorrection>("ccdb_object");
+        }
+
         if (!timeGain) {
           LOGP(error, "Could not load 'CalibdEdxCorrection' from file {}", mCustomdEdxFileName);
         } else {
@@ -133,7 +138,7 @@ class CalibdEdxDevice : public Task
     sendOutput(eos.outputs());
 
     if (mDumpToFile) {
-      mCalib->dumpToFile("calibdEdx_Obj.root", "calib");
+      mCalib->dumpToFile("calibdEdx_Obj.root");
       mCalib->getCalib().writeToFile("calibdEdx.root");
       if (mDumpToFile > 1) {
         mCalib->writeTTree("calibdEdx.histo.tree.root");

From 04cf1b8051487f9a94a0836f15d2355a752180c5 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Wed, 26 Mar 2025 23:37:05 +0100
Subject: [PATCH 0182/1764] Extend DCS update and fit interval

---
 Detectors/TPC/dcs/src/DCSSpec.cxx | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/dcs/src/DCSSpec.cxx b/Detectors/TPC/dcs/src/DCSSpec.cxx
index 90cf9460caa3c..f99ff8f8aaaab 100644
--- a/Detectors/TPC/dcs/src/DCSSpec.cxx
+++ b/Detectors/TPC/dcs/src/DCSSpec.cxx
@@ -156,7 +156,8 @@ void DCSDevice::sendObject(DataAllocator& output, T& obj, const CDBType calibTyp
 
   std::map<std::string, std::string> md = mCDBStorage.getMetaData();
   o2::ccdb::CcdbObjectInfo w;
-  o2::calibration::Utils::prepareCCDBobjectInfo(obj, w, CDBTypeMap.at(calibType), md, mUpdateIntervalStart, mLastCreationTime - 1);
+  // for online processing extend the validity range. Will be truncated with the adjustableEOV procedure
+  o2::calibration::Utils::prepareCCDBobjectInfo(obj, w, CDBTypeMap.at(calibType), md, mUpdateIntervalStart, mLastCreationTime + 2 * mCCDBupdateInterval * 1000);
   auto image = o2::ccdb::CcdbApi::createObjectImage(&obj, &w);
 
   LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {} ", w.getPath(), w.getFileName(), image->size(), w.getStartValidityTimestamp(), w.getEndValidityTimestamp());
@@ -195,11 +196,11 @@ DataProcessorSpec getDCSSpec()
     Options{
       {"write-debug", VariantType::Bool, false, {"write a debug output tree"}},
       {"report-timing", VariantType::Bool, false, {"Report timing for every slice"}},
-      {"update-interval", VariantType::Int, 60 * 5, {"update interval in seconds for which ccdb entries are written"}},
-      {"fit-interval", VariantType::Int, 60, {"interval in seconds for which to e.g. perform fits of the temperature sensors"}},
+      {"update-interval", VariantType::Int, 60 * 15, {"update interval in seconds for which ccdb entries are written"}},
+      {"fit-interval", VariantType::Int, 60 * 5, {"interval in seconds for which to e.g. perform fits of the temperature sensors"}},
       {"round-to-interval", VariantType::Bool, false, {"round fit interval to fixed times e.g. to every 5min in the hour"}},
     } // end Options
-  };  // end DataProcessorSpec
+  }; // end DataProcessorSpec
 }
 
 } // end namespace o2::tpc

From 144751775e5f2500bc10f6dce8b1159ad9ad1b24 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 1 Apr 2025 16:33:43 +0200
Subject: [PATCH 0183/1764] DPL Analysis: fix combinations generator parsing in
 analysis task (#14133)

---
 .../Core/include/Framework/AnalysisManagers.h      |  4 +---
 .../Core/include/Framework/GroupedCombinations.h   | 14 +++++---------
 Framework/Core/test/test_Concepts.cxx              |  3 +++
 3 files changed, 9 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index ccabbd7a0a197..733e91706b4a8 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -495,16 +495,14 @@ bool initializeCache(ProcessingContext& context, T& cache)
 
 /// Combinations handling
 template <typename C, typename TG, typename... Ts>
-  requires(!is_combinations_generator<C>)
 void setGroupedCombination(C&, TG&, Ts&...)
 {
 }
 
 template <is_combinations_generator C, typename TG, typename... Ts>
-  requires((sizeof...(Ts) > 0) && (C::compatible(framework::pack<Ts...>{})))
 static void setGroupedCombination(C& comb, TG& grouping, std::tuple<Ts...>& associated)
 {
-  if constexpr (std::same_as<typename C::g_t, TG>) {
+  if constexpr (std::same_as<typename C::g_t, std::decay_t<TG>>) {
     comb.setTables(grouping, associated);
   }
 }
diff --git a/Framework/Core/include/Framework/GroupedCombinations.h b/Framework/Core/include/Framework/GroupedCombinations.h
index bdbddee871baa..b0a6c9e658a10 100644
--- a/Framework/Core/include/Framework/GroupedCombinations.h
+++ b/Framework/Core/include/Framework/GroupedCombinations.h
@@ -48,17 +48,12 @@ expressions::BindingNode getMatchingIndexNode()
 }
 
 template <typename T1, typename GroupingPolicy, typename BP, typename G, typename... As>
+  requires(sizeof...(As) > 0)
 struct GroupedCombinationsGenerator {
   using grouping_policy_t = GroupingPolicy;
   using g_t = G;
   using associated_pack_t = framework::pack<As...>;
 
-  template <typename... Ts>
-  static consteval bool compatible(framework::pack<Ts...> p)
-  {
-    return (framework::has_type<As>(p) && ...);
-  }
-
   using GroupedIteratorType = pack_to_tuple_t<interleaved_pack_t<repeated_type_pack_t<typename G::iterator, sizeof...(As)>, pack<As...>>>;
 
   struct GroupedIterator : public GroupingPolicy {
@@ -241,10 +236,11 @@ struct GroupedCombinationsGenerator {
 };
 
 template <typename T>
-concept is_combinations_generator = requires(T t) {
+concept is_combinations_generator = requires(T t, typename T::g_t const& g, pack_to_tuple_t<typename T::associated_pack_t>& a) {
   typename T::GroupedIterator;
-  &T::begin;
-  &T::end;
+  t.setTables(g, a);
+  { t.begin() } -> std::same_as<typename T::iterator>;
+  { t.end() } -> std::same_as<typename T::iterator>;
 };
 
 // Aliases for 2-particle correlations
diff --git a/Framework/Core/test/test_Concepts.cxx b/Framework/Core/test/test_Concepts.cxx
index 00ad931828b44..4bf4f977ec3a8 100644
--- a/Framework/Core/test/test_Concepts.cxx
+++ b/Framework/Core/test/test_Concepts.cxx
@@ -161,4 +161,7 @@ TEST_CASE("IdentificationConcepts")
   // Expressions
   expressions::Filter f = o2::aod::track::pt > 1.0f;
   REQUIRE(expressions::is_filter<decltype(f)>);
+
+  using C = SameKindPair<aod::Collisions, aod::Tracks, ColumnBinningPolicy<aod::collision::PosZ>>;
+  REQUIRE(is_combinations_generator<C>);
 }

From fb24eaad730186a6319d435e29cb85799747c2b9 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Fri, 28 Mar 2025 15:19:18 +0100
Subject: [PATCH 0184/1764] Fix missing header

---
 GPU/Common/GPUCommonHelpers.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/Common/GPUCommonHelpers.h b/GPU/Common/GPUCommonHelpers.h
index 2927ddab6bd0c..1d953a3027d21 100644
--- a/GPU/Common/GPUCommonHelpers.h
+++ b/GPU/Common/GPUCommonHelpers.h
@@ -36,6 +36,7 @@
 #include "GPUCommonLogger.h"
 #include <cstdint>
 #include <functional>
+#include <stdexcept>
 
 namespace o2::gpu::internal
 {

From 08ff25afa2ca3b4e8aedbb61c4b512ece38905c4 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Fri, 28 Mar 2025 15:20:06 +0100
Subject: [PATCH 0185/1764] Cleanup Stale ITS GPU code

---
 .../ITS/tracking/GPU/ITStrackingGPU/Array.h   |  62 ----
 .../ITS/tracking/GPU/ITStrackingGPU/Context.h |  70 ----
 .../ITStrackingGPU/PrimaryVertexContextGPU.h  | 144 --------
 .../ITS/tracking/GPU/ITStrackingGPU/Stream.h  |  14 +-
 .../GPU/ITStrackingGPU/TimeFrameChunk.h       |   4 +-
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  44 +--
 .../GPU/ITStrackingGPU/TrackerTraitsGPU.h     |   1 -
 .../GPU/ITStrackingGPU/UniquePointer.h        | 153 ---------
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   |  38 +--
 .../ITS/tracking/GPU/ITStrackingGPU/Vector.h  | 310 -----------------
 .../ITS/tracking/GPU/cuda/CMakeLists.txt      |   3 -
 .../ITSMFT/ITS/tracking/GPU/cuda/Context.cu   | 121 -------
 .../ITSMFT/ITS/tracking/GPU/cuda/Stream.cu    |  11 +-
 .../ITS/tracking/GPU/cuda/TimeFrameChunk.cu   |  66 ++--
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 165 +++++----
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 231 ++++++-------
 .../ITSMFT/ITS/tracking/GPU/cuda/Utils.cu     | 289 ----------------
 .../tracking/GPU/cuda/VertexerTraitsGPU.cxx   | 312 +++++++++---------
 .../ITS/tracking/GPU/cuda/VertexingKernels.cu |  13 +-
 .../ITS/tracking/GPU/hip/CMakeLists.txt       |   3 -
 .../tracking/include/ITStracking/Constants.h  |  28 +-
 .../include/ITStracking/Definitions.h         | 103 +-----
 Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx |   6 +-
 23 files changed, 426 insertions(+), 1765 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Array.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Context.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/PrimaryVertexContextGPU.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/UniquePointer.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Vector.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/cuda/Context.cu
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/cuda/Utils.cu

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Array.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Array.h
deleted file mode 100644
index f4f73e715c305..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Array.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file Array.h
-/// \brief
-///
-
-#ifndef ITSTRACKINGGPU_ARRAY_H_
-#define ITSTRACKINGGPU_ARRAY_H_
-
-#include "GPUCommonDef.h"
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-template <typename T, size_t Size>
-struct ArrayTraits final {
-  typedef T InternalArray[Size];
-
-  GPUhd() static constexpr T& getReference(const InternalArray& internalArray, size_t index) noexcept
-  {
-    return const_cast<T&>(internalArray[index]);
-  }
-
-  GPUhd() static constexpr T* getPointer(const InternalArray& internalArray) noexcept
-  {
-    return const_cast<T*>(internalArray);
-  }
-};
-
-template <typename T, size_t Size>
-struct Array final {
-
-  void copy(const Array<T, Size>& t)
-  {
-    memcpy(InternalArray, t.data(), Size * sizeof(T));
-  }
-
-  GPUhd() T* data() noexcept { return const_cast<T*>(InternalArray); }
-  GPUhd() const T* data() const noexcept { return const_cast<T*>(InternalArray); }
-  GPUhd() T& operator[](const int index) noexcept { return const_cast<T&>(InternalArray[index]); }
-  GPUhd() constexpr T& operator[](const int index) const noexcept { return const_cast<T&>(InternalArray[index]); }
-  GPUhd() size_t size() const noexcept { return Size; }
-
-  T InternalArray[Size];
-};
-} // namespace gpu
-} // namespace its
-} // namespace o2
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Context.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Context.h
deleted file mode 100644
index bfc4c63756e0b..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Context.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file Context.h
-/// \brief
-///
-
-#ifndef ITSTRACKINGGPU_CONTEXT_H_
-#define ITSTRACKINGGPU_CONTEXT_H_
-
-#include <string>
-#include <vector>
-#include "ITStracking/Definitions.h"
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-
-struct DeviceProperties final {
-  std::string name;
-  int gpuProcessors;
-  int gpuCores;
-  long globalMemorySize;
-  long constantMemorySize;
-  long sharedMemorySize;
-  long maxClockRate;
-  int busWidth;
-  long l2CacheSize;
-  long registersPerBlock;
-  int warpSize;
-  int maxThreadsPerBlock;
-  int maxBlocksPerSM;
-  dim3 maxThreadsDim;
-  dim3 maxGridDim;
-};
-
-class Context final
-{
- public:
-  static Context& getInstance();
-
-  Context(const Context&);
-  Context& operator=(const Context&);
-
-  const DeviceProperties& getDeviceProperties();
-  const DeviceProperties& getDeviceProperties(const int);
-
- private:
-  Context(bool dumpDevices = false);
-  ~Context() = default;
-
-  int mDevicesNum;
-  std::vector<DeviceProperties> mDeviceProperties;
-};
-} // namespace gpu
-} // namespace its
-} // namespace o2
-
-#endif /* TRAKINGITSU_INCLUDE_GPU_CONTEXT_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/PrimaryVertexContextGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/PrimaryVertexContextGPU.h
deleted file mode 100644
index a5e859475521c..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/PrimaryVertexContextGPU.h
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file PrimaryVertexContextNVNV.h
-/// \brief
-///
-
-#ifndef ITSTRACKINGGPU_PRIMARYVERTEXCONTEXTGPU_H_
-#define ITSTRACKINGGPU_PRIMARYVERTEXCONTEXTGPU_H_
-
-#include <array>
-
-#include <cub/cub.cuh>
-#include <cstdint>
-
-#include "ITStracking/Configuration.h"
-#include "ITStracking/Constants.h"
-#include "ITStracking/Definitions.h"
-#include "ITStracking/PrimaryVertexContext.h"
-#include "ITStracking/Road.h"
-#include "ITStracking/Tracklet.h"
-
-#include "DeviceStoreGPU.h"
-#include "UniquePointer.h"
-
-namespace o2
-{
-namespace its
-{
-
-class PrimaryVertexContextNV final : public PrimaryVertexContext
-{
- public:
-  PrimaryVertexContextNV() = default;
-  ~PrimaryVertexContextNV() override;
-
-  void initialise(const MemoryParameters& memParam, const TrackingParameters& trkParam,
-                  const std::vector<std::vector<Cluster>>& cl, const std::array<float, 3>& pv, const int iteration) override;
-
-  gpu::DeviceStoreNV& getDeviceContext();
-  gpu::Array<gpu::Vector<Cluster>, constants::its2::LayersNumber>& getDeviceClusters();
-  gpu::Array<gpu::Vector<Tracklet>, constants::its2::TrackletsPerRoad>& getDeviceTracklets();
-  gpu::Array<gpu::Vector<int>, constants::its2::CellsPerRoad>& getDeviceTrackletsLookupTable();
-  gpu::Array<gpu::Vector<int>, constants::its2::CellsPerRoad>& getDeviceTrackletsPerClustersTable();
-  gpu::Array<gpu::Vector<Cell>, constants::its2::CellsPerRoad>& getDeviceCells();
-  gpu::Array<gpu::Vector<int>, constants::its2::CellsPerRoad - 1>& getDeviceCellsLookupTable();
-  gpu::Array<gpu::Vector<int>, constants::its2::CellsPerRoad - 1>& getDeviceCellsPerTrackletTable();
-  std::array<gpu::Vector<int>, constants::its2::CellsPerRoad>& getTempTableArray();
-  std::array<gpu::Vector<Tracklet>, constants::its2::CellsPerRoad>& getTempTrackletArray();
-  std::array<gpu::Vector<Cell>, constants::its2::CellsPerRoad - 1>& getTempCellArray();
-  void updateDeviceContext();
-
- private:
-  gpu::DeviceStoreNV mGPUContext;
-  gpu::UniquePointer<gpu::DeviceStoreNV> mGPUContextDevicePointer;
-  std::array<gpu::Vector<int>, constants::its2::CellsPerRoad> mTempTableArray;
-  std::array<gpu::Vector<Tracklet>, constants::its2::CellsPerRoad> mTempTrackletArray;
-  std::array<gpu::Vector<Cell>, constants::its2::CellsPerRoad - 1> mTempCellArray;
-};
-
-inline PrimaryVertexContextNV::~PrimaryVertexContextNV() = default;
-
-inline gpu::DeviceStoreNV& PrimaryVertexContextNV::getDeviceContext()
-{
-  return *mGPUContextDevicePointer;
-}
-
-inline gpu::Array<gpu::Vector<Cluster>, constants::its2::LayersNumber>& PrimaryVertexContextNV::getDeviceClusters()
-{
-  return mGPUContext.getClusters();
-}
-
-inline gpu::Array<gpu::Vector<Tracklet>, constants::its2::TrackletsPerRoad>& PrimaryVertexContextNV::getDeviceTracklets()
-{
-  return mGPUContext.getTracklets();
-}
-
-inline gpu::Array<gpu::Vector<int>, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getDeviceTrackletsLookupTable()
-{
-  return mGPUContext.getTrackletsLookupTable();
-}
-
-inline gpu::Array<gpu::Vector<int>, constants::its2::CellsPerRoad>&
-  PrimaryVertexContextNV::getDeviceTrackletsPerClustersTable()
-{
-  return mGPUContext.getTrackletsPerClusterTable();
-}
-
-inline gpu::Array<gpu::Vector<Cell>, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getDeviceCells()
-{
-  return mGPUContext.getCells();
-}
-
-inline gpu::Array<gpu::Vector<int>, constants::its2::CellsPerRoad - 1>& PrimaryVertexContextNV::getDeviceCellsLookupTable()
-{
-  return mGPUContext.getCellsLookupTable();
-}
-
-inline gpu::Array<gpu::Vector<int>, constants::its2::CellsPerRoad - 1>&
-  PrimaryVertexContextNV::getDeviceCellsPerTrackletTable()
-{
-  return mGPUContext.getCellsPerTrackletTable();
-}
-
-inline std::array<gpu::Vector<int>, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getTempTableArray()
-{
-  return mTempTableArray;
-}
-
-inline std::array<gpu::Vector<Tracklet>, constants::its2::CellsPerRoad>& PrimaryVertexContextNV::getTempTrackletArray()
-{
-  return mTempTrackletArray;
-}
-
-inline std::array<gpu::Vector<Cell>, constants::its2::CellsPerRoad - 1>& PrimaryVertexContextNV::getTempCellArray()
-{
-  return mTempCellArray;
-}
-
-inline void PrimaryVertexContextNV::updateDeviceContext()
-{
-  mGPUContextDevicePointer = gpu::UniquePointer<gpu::DeviceStoreNV>{mGPUContext};
-}
-
-inline void PrimaryVertexContextNV::initialise(const MemoryParameters& memParam, const TrackingParameters& trkParam,
-                                               const std::vector<std::vector<Cluster>>& cl, const std::array<float, 3>& pv, const int iteration)
-{
-  ///TODO: to be re-enabled in the future
-  // this->PrimaryVertexContext::initialise(memParam, cl, pv, iteration);
-  // mGPUContextDevicePointer = mGPUContext.initialise(mPrimaryVertex, mClusters, mTracklets, mCells, mCellsLookupTable, mMinR, mMaxR);
-}
-
-} // namespace its
-} // namespace o2
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Stream.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Stream.h
index 20744b47cd9b5..ba36c29addc73 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Stream.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Stream.h
@@ -18,16 +18,11 @@
 
 #include "ITStracking/Definitions.h"
 
-namespace o2
-{
-namespace its
-{
-namespace gpu
+namespace o2::its::gpu
 {
 
 class Stream final
 {
-
  public:
   Stream();
   ~Stream();
@@ -37,8 +32,5 @@ class Stream final
  private:
   GPUStream mStream;
 };
-} // namespace gpu
-} // namespace its
-} // namespace o2
-
-#endif /* TRAKINGITSU_INCLUDE_GPU_STREAM_H_ */
+} // namespace o2::its::gpu
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
index c477922e59533..ac489fc8bfee5 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
@@ -17,8 +17,8 @@
 #include "ITStracking/TimeFrame.h"
 
 #include "ITStrackingGPU/ClusterLinesGPU.h"
-#include "ITStrackingGPU/Array.h"
-#include "ITStrackingGPU/Vector.h"
+// #include "ITStrackingGPU/Array.h"
+// #include "ITStrackingGPU/Vector.h"
 #include "ITStrackingGPU/Stream.h"
 
 #include <gsl/gsl>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 100e49def0d50..1581eea6ce81a 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -17,10 +17,8 @@
 #include "ITStracking/Configuration.h"
 
 #include "ITStrackingGPU/ClusterLinesGPU.h"
-#include "ITStrackingGPU/Array.h"
-#include "ITStrackingGPU/Vector.h"
 #include "ITStrackingGPU/Stream.h"
-#include "ITStrackingGPU/TimeFrameChunk.h"
+#include "ITStrackingGPU/Utils.h"
 
 #include <gsl/gsl>
 
@@ -39,8 +37,6 @@ class DefaultGPUAllocator : public ExternalAllocator
 template <int nLayers = 7>
 class TimeFrameGPU : public TimeFrame
 {
-  friend class GpuTimeFrameChunk<nLayers>;
-
  public:
   TimeFrameGPU();
   ~TimeFrameGPU();
@@ -88,24 +84,18 @@ class TimeFrameGPU : public TimeFrame
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
   void unregisterRest();
-  void initDeviceChunks(const int, const int);
   template <Task task>
-  size_t loadChunkData(const size_t, const size_t, const size_t);
-  size_t getNChunks() const { return mMemChunks.size(); }
-  GpuTimeFrameChunk<nLayers>& getChunk(const int chunk) { return mMemChunks[chunk]; }
-  Stream& getStream(const size_t stream) { return mGpuStreams[stream]; }
+  Stream& getStream(const size_t stream)
+  {
+    return mGpuStreams[stream];
+  }
   void wipe(const int);
 
   /// interface
   int getNClustersInRofSpan(const int, const int, const int) const;
   IndexTableUtils* getDeviceIndexTableUtils() { return mIndexTableUtilsDevice; }
   int* getDeviceROFramesClusters(const int layer) { return mROFramesClustersDevice[layer]; }
-  std::vector<std::vector<Vertex>>& getVerticesInChunks() { return mVerticesInChunks; }
-  std::vector<std::vector<int>>& getNVerticesInChunks() { return mNVerticesInChunks; }
   std::vector<o2::its::TrackITSExt>& getTrackITSExt() { return mTrackITSExt; }
-  std::vector<std::vector<o2::MCCompLabel>>& getLabelsInChunks() { return mLabelsInChunks; }
-  int getNAllocatedROFs() const { return mNrof; } // Allocated means maximum nROF for each chunk while populated is the number of loaded ones.
-  StaticTrackingParameters<nLayers>* getDeviceTrackingParameters() { return mTrackingParamsDevice; }
   Vertex* getDeviceVertices() { return mPrimaryVerticesDevice; }
   int* getDeviceROFramesPV() { return mROFramesPVDevice; }
   unsigned char* getDeviceUsedClusters(const int);
@@ -158,16 +148,13 @@ class TimeFrameGPU : public TimeFrame
  private:
   void allocMemAsync(void**, size_t, Stream*, bool); // Abstract owned and unowned memory allocations
   bool mHostRegistered = false;
-  std::vector<GpuTimeFrameChunk<nLayers>> mMemChunks;
   TimeFrameGPUParameters mGpuParams;
-  StaticTrackingParameters<nLayers> mStaticTrackingParams;
 
   // Host-available device buffer sizes
   std::array<int, nLayers - 1> mNTracklets;
   std::array<int, nLayers - 2> mNCells;
 
   // Device pointers
-  StaticTrackingParameters<nLayers>* mTrackingParamsDevice;
   IndexTableUtils* mIndexTableUtilsDevice;
 
   // Hybrid pref
@@ -216,31 +203,10 @@ class TimeFrameGPU : public TimeFrame
   size_t mAvailMemGB;
   bool mFirstInit = true;
 
-  // Output
-  std::vector<std::vector<Vertex>> mVerticesInChunks;
-  std::vector<std::vector<int>> mNVerticesInChunks;
-  std::vector<std::vector<o2::MCCompLabel>> mLabelsInChunks;
-
   // Temporary buffer for storing output tracks from GPU tracking
   std::vector<TrackITSExt> mTrackITSExt;
 };
 
-template <int nLayers>
-template <Task task>
-size_t TimeFrameGPU<nLayers>::loadChunkData(const size_t chunk, const size_t offset, const size_t maxRofs) // offset: readout frame to start from, maxRofs: to manage boundaries
-{
-  size_t nRof{0};
-
-  mMemChunks[chunk].reset(task, mGpuStreams[chunk]); // Reset chunks memory
-  if constexpr ((bool)task) {
-    nRof = mMemChunks[chunk].loadDataOnDevice(offset, maxRofs, 3, mGpuStreams[chunk]);
-  } else {
-    nRof = mMemChunks[chunk].loadDataOnDevice(offset, maxRofs, nLayers, mGpuStreams[chunk]);
-  }
-  LOGP(debug, "In chunk {}: loaded {} readout frames starting from {}", chunk, nRof, offset);
-  return nRof;
-}
-
 template <int nLayers>
 inline int TimeFrameGPU<nLayers>::getNClustersInRofSpan(const int rofIdstart, const int rofSpanSize, const int layerId) const
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
index 076523261ff7e..f9583d97ca030 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
@@ -55,7 +55,6 @@ class TrackerTraitsGPU : public TrackerTraits
  private:
   IndexTableUtils* mDeviceIndexTableUtils;
   gpu::TimeFrameGPU<7>* mTimeFrameGPU;
-  gpu::StaticTrackingParameters<nLayers>* mStaticTrkPars;
 };
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/UniquePointer.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/UniquePointer.h
deleted file mode 100644
index ce04da3dde622..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/UniquePointer.h
+++ /dev/null
@@ -1,153 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file UniquePointer.h
-/// \brief
-///
-
-#ifndef ITSTRACKINGGPU_UNIQUEPOINTER_H_
-#define ITSTRACKINGGPU_UNIQUEPOINTER_H_
-
-#include "Utils.h"
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-
-namespace
-{
-template <typename T>
-struct UniquePointerTraits final {
-  typedef T* InternalPointer;
-
-  GPUhd() static constexpr T& getReference(const InternalPointer& internalPointer) noexcept
-  {
-    return const_cast<T&>(*internalPointer);
-  }
-
-  GPUhd() static constexpr T* getPointer(const InternalPointer& internalPointer) noexcept
-  {
-    return const_cast<T*>(internalPointer);
-  }
-};
-} // namespace
-
-template <typename T>
-class UniquePointer final
-{
-  typedef UniquePointerTraits<T> PointerTraits;
-
- public:
-  UniquePointer();
-  explicit UniquePointer(const T&);
-  ~UniquePointer();
-
-  UniquePointer(const UniquePointer&) = delete;
-  UniquePointer& operator=(const UniquePointer&) = delete;
-
-  UniquePointer(UniquePointer&&);
-  UniquePointer& operator=(UniquePointer&&);
-
-  GPUhd() T* get() noexcept;
-  GPUhd() const T* get() const noexcept;
-  GPUhd() T& operator*() noexcept;
-  GPUhd() const T& operator*() const noexcept;
-
- protected:
-  void destroy();
-
- private:
-  typename PointerTraits::InternalPointer mDevicePointer;
-};
-
-template <typename T>
-UniquePointer<T>::UniquePointer() : mDevicePointer{nullptr}
-{
-  // Nothing to do
-}
-
-template <typename T>
-UniquePointer<T>::UniquePointer(const T& ref)
-{
-  try {
-
-    utils::host::gpuMalloc(reinterpret_cast<void**>(&mDevicePointer), sizeof(T));
-    utils::host::gpuMemcpyHostToDevice(mDevicePointer, &ref, sizeof(T));
-
-  } catch (...) {
-
-    destroy();
-
-    throw;
-  }
-}
-
-template <typename T>
-UniquePointer<T>::~UniquePointer()
-{
-  destroy();
-}
-
-template <typename T>
-UniquePointer<T>::UniquePointer(UniquePointer<T>&& other) : mDevicePointer{other.mDevicePointer}
-{
-  // Nothing to do
-}
-
-template <typename T>
-UniquePointer<T>& UniquePointer<T>::operator=(UniquePointer<T>&& other)
-{
-  mDevicePointer = other.mDevicePointer;
-  other.mDevicePointer = nullptr;
-
-  return *this;
-}
-
-template <typename T>
-void UniquePointer<T>::destroy()
-{
-  if (mDevicePointer != nullptr) {
-
-    utils::host::gpuFree(mDevicePointer);
-  }
-}
-
-template <typename T>
-GPUhd() T* UniquePointer<T>::get() noexcept
-{
-  return PointerTraits::getPointer(mDevicePointer);
-}
-
-template <typename T>
-GPUhd() const T* UniquePointer<T>::get() const noexcept
-{
-  return PointerTraits::getPointer(mDevicePointer);
-}
-
-template <typename T>
-GPUhd() T& UniquePointer<T>::operator*() noexcept
-{
-  return PointerTraits::getReference(mDevicePointer);
-}
-
-template <typename T>
-GPUhd() const T& UniquePointer<T>::operator*() const noexcept
-{
-  return PointerTraits::getReference(mDevicePointer);
-}
-} // namespace gpu
-} // namespace its
-} // namespace o2
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index a88e51742e84a..7ed70a4e0fdd9 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -31,6 +31,12 @@ struct gpuPair {
 
 namespace gpu
 {
+
+template <typename T>
+void discardResult(const T&)
+{
+}
+
 // Poor man implementation of a span-like struct. It is very limited.
 template <typename T>
 struct gpuSpan {
@@ -91,38 +97,6 @@ GPUhd() const T* getPtrFromRuler(int index, const T* src, const int* ruler, cons
 {
   return src + ruler[index] * stride;
 }
-
-GPUh() void gpuThrowOnError();
-
-namespace utils
-{
-#ifdef __CUDACC__
-void checkGPUError(const cudaError_t error, const char* file = __FILE__, const int line = __LINE__);
-#endif
-#ifdef __HIPCC__
-void checkGPUError(const hipError_t error, const char* file = __FILE__, const int line = __LINE__);
-#endif
-
-// Dump device properties
-void getDeviceProp(int, bool verbose = true);
-
-dim3 getBlockSize(const int);
-dim3 getBlockSize(const int, const int);
-dim3 getBlockSize(const int, const int, const int);
-dim3 getBlocksGrid(const dim3&, const int);
-dim3 getBlocksGrid(const dim3&, const int, const int);
-
-void gpuMalloc(void**, const int);
-void gpuFree(void*);
-void gpuMemset(void*, int, int);
-void gpuMemcpyHostToDevice(void*, const void*, int);
-void gpuMemcpyDeviceToHost(void*, const void*, int);
-void gpuMemcpyToSymbol(const void* symbol, const void* src, int size);
-void gpuMemcpyFromSymbol(void* dst, const void* symbol, int size);
-
-GPUd() int getLaneIndex();
-GPUd() int shareToWarp(const int, const int);
-} // namespace utils
 } // namespace gpu
 } // namespace its
 } // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Vector.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Vector.h
deleted file mode 100644
index 3912caec8449c..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Vector.h
+++ /dev/null
@@ -1,310 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file Vector.h
-/// \brief
-///
-
-#ifndef ITSTRACKINGGPU_VECTOR_H_
-#define ITSTRACKINGGPU_VECTOR_H_
-
-#include <cassert>
-#include <new>
-#include <type_traits>
-#include <vector>
-
-#include "Stream.h"
-#include "Utils.h"
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-
-template <typename T>
-class Vector final
-{
-  static_assert(std::is_trivially_destructible<T>::value, "Vector only supports trivially destructible objects.");
-
- public:
-  Vector();
-  explicit Vector(const size_t, const size_t = 0);
-  Vector(const T* const, const size_t, const size_t = 0);
-  GPUhd() ~Vector();
-
-  Vector(const Vector&) = delete;
-  Vector& operator=(const Vector&) = delete;
-
-  GPUhd() Vector(Vector&&);
-  Vector& operator=(Vector&&);
-
-  size_t getSizeFromDevice() const;
-
-  T getElementFromDevice(const size_t) const;
-
-  void resize(const size_t);
-  void reset(const size_t, const size_t = 0);
-  void reset(const T* const, const size_t, const size_t = 0);
-
-  void resetWithInt(const size_t, const int value = 0);
-  void copyIntoSizedVector(std::vector<T>&);
-
-  GPUhd() T* get() const;
-  GPUhd() size_t capacity() const;
-  GPUhd() Vector<T> getWeakCopy() const;
-  GPUd() T& operator[](const size_t) const;
-
-  GPUd() size_t size() const;
-  GPUhd() void dump();
-
-  template <typename... Args>
-  GPUd() void emplace(const size_t, Args&&...);
-
- protected:
-  void destroy();
-
- private:
-  GPUhd() Vector(const Vector&, const bool);
-
-  T* mArrayPtr = nullptr;
-  size_t* mDeviceSizePtr = nullptr;
-  size_t mCapacity;
-  bool mIsWeak;
-};
-
-template <typename T>
-Vector<T>::Vector() : Vector{nullptr, 0}
-{
-  // Nothing to do
-}
-
-template <typename T>
-Vector<T>::Vector(const size_t capacity, const size_t initialSize) : Vector{nullptr, capacity, initialSize}
-{
-  // Nothing to do
-}
-
-template <typename T>
-Vector<T>::Vector(const T* const source, const size_t size, const size_t initialSize) : mCapacity{size}, mIsWeak{false}
-{
-  if (size > 0) {
-    try {
-
-      utils::gpuMalloc(reinterpret_cast<void**>(&mArrayPtr), size * sizeof(T));
-      utils::gpuMalloc(reinterpret_cast<void**>(&mDeviceSizePtr), sizeof(size_t));
-
-      if (source != nullptr) {
-
-        utils::gpuMemcpyHostToDevice(mArrayPtr, source, size * sizeof(T));
-        utils::gpuMemcpyHostToDevice(mDeviceSizePtr, &size, sizeof(size_t));
-
-      } else {
-
-        utils::gpuMemcpyHostToDevice(mDeviceSizePtr, &initialSize, sizeof(size_t));
-      }
-
-    } catch (...) {
-
-      destroy();
-
-      throw;
-    }
-  }
-}
-
-template <typename T>
-GPUhd() Vector<T>::Vector(const Vector& other, const bool isWeak)
-  : mArrayPtr{other.mArrayPtr},
-    mDeviceSizePtr{other.mDeviceSizePtr},
-    mCapacity{other.mCapacity},
-    mIsWeak{isWeak}
-{
-  // Nothing to do
-}
-
-template <typename T>
-GPUhd() Vector<T>::~Vector()
-{
-  if (mIsWeak) {
-    return;
-  } else {
-#if defined(TRACKINGITSU_GPU_DEVICE)
-    assert(0);
-#else
-    destroy();
-#endif
-  }
-}
-
-template <typename T>
-GPUhd() Vector<T>::Vector(Vector<T>&& other)
-  : mArrayPtr{other.mArrayPtr},
-    mDeviceSizePtr{other.mDeviceSizePtr},
-    mCapacity{other.mCapacity},
-    mIsWeak{other.mIsWeak}
-{
-  other.mArrayPtr = nullptr;
-  other.mDeviceSizePtr = nullptr;
-}
-
-template <typename T>
-Vector<T>& Vector<T>::operator=(Vector<T>&& other)
-{
-  destroy();
-
-  mArrayPtr = other.mArrayPtr;
-  mDeviceSizePtr = other.mDeviceSizePtr;
-  mCapacity = other.mCapacity;
-  mIsWeak = other.mIsWeak;
-
-  other.mArrayPtr = nullptr;
-  other.mDeviceSizePtr = nullptr;
-
-  return *this;
-}
-
-template <typename T>
-size_t Vector<T>::getSizeFromDevice() const
-{
-  size_t size;
-  utils::gpuMemcpyDeviceToHost(&size, mDeviceSizePtr, sizeof(size_t));
-
-  return size;
-}
-
-template <typename T>
-void Vector<T>::resize(const size_t size)
-{
-  utils::gpuMemcpyHostToDevice(mDeviceSizePtr, &size, sizeof(size_t));
-}
-
-template <typename T>
-void Vector<T>::reset(const size_t capacity, const size_t initialSize)
-{
-  reset(nullptr, capacity, initialSize);
-}
-
-template <typename T>
-void Vector<T>::reset(const T* const source, const size_t size, const size_t initialSize)
-{
-  if (size > mCapacity) {
-    if (mArrayPtr != nullptr) {
-      utils::gpuFree(mArrayPtr);
-    }
-    utils::gpuMalloc(reinterpret_cast<void**>(&mArrayPtr), size * sizeof(T));
-    mCapacity = size;
-  }
-  if (mDeviceSizePtr == nullptr) {
-    utils::gpuMalloc(reinterpret_cast<void**>(&mDeviceSizePtr), sizeof(size_t));
-  }
-
-  if (source != nullptr) {
-    utils::gpuMemcpyHostToDevice(mArrayPtr, source, size * sizeof(T));
-    utils::gpuMemcpyHostToDevice(mDeviceSizePtr, &size, sizeof(size_t));
-  } else {
-    utils::gpuMemcpyHostToDevice(mDeviceSizePtr, &initialSize, sizeof(size_t));
-  }
-}
-
-template <typename T>
-void Vector<T>::resetWithInt(const size_t size, const int value)
-{
-  if (size > mCapacity) {
-    if (mArrayPtr != nullptr) {
-      utils::gpuFree(mArrayPtr);
-    }
-    utils::gpuMalloc(reinterpret_cast<void**>(&mArrayPtr), size * sizeof(int));
-    mCapacity = size;
-  }
-  if (mDeviceSizePtr == nullptr) {
-    utils::gpuMalloc(reinterpret_cast<void**>(&mDeviceSizePtr), sizeof(int));
-  }
-
-  utils::gpuMemset(mArrayPtr, value, size * sizeof(int));
-  utils::gpuMemcpyHostToDevice(mDeviceSizePtr, &size, sizeof(int));
-}
-
-template <typename T>
-void Vector<T>::copyIntoSizedVector(std::vector<T>& destinationVector)
-{
-  utils::gpuMemcpyDeviceToHost(destinationVector.data(), mArrayPtr, destinationVector.size() * sizeof(T));
-}
-
-template <typename T>
-inline void Vector<T>::destroy()
-{
-  if (mArrayPtr != nullptr) {
-    utils::gpuFree(mArrayPtr);
-  }
-  if (mDeviceSizePtr != nullptr) {
-    utils::gpuFree(mDeviceSizePtr);
-  }
-}
-
-template <typename T>
-GPUhd() T* Vector<T>::get() const
-{
-  return mArrayPtr;
-}
-
-template <typename T>
-GPUhd() size_t Vector<T>::capacity() const
-{
-  return mCapacity;
-}
-
-template <typename T>
-GPUhd() Vector<T> Vector<T>::getWeakCopy() const
-{
-  return Vector{*this, true};
-}
-
-template <typename T>
-GPUd() T& Vector<T>::operator[](const size_t index) const
-{
-  return mArrayPtr[index];
-}
-
-template <typename T>
-GPUh() T Vector<T>::getElementFromDevice(const size_t index) const
-{
-  T element;
-  utils::gpuMemcpyDeviceToHost(&element, mArrayPtr + index, sizeof(T));
-
-  return element;
-}
-
-template <typename T>
-GPUd() size_t Vector<T>::size() const
-{
-  return *mDeviceSizePtr;
-}
-
-template <typename T>
-template <typename... Args>
-GPUd() void Vector<T>::emplace(const size_t index, Args&&... arguments)
-{
-  new (mArrayPtr + index) T(std::forward<Args>(arguments)...);
-}
-
-template <typename T>
-GPUhd() void Vector<T>::dump()
-{
-  printf("mArrayPtr = %p\nmDeviceSize   = %p\nmCapacity     = %d\nmIsWeak       = %s\n",
-         mArrayPtr, mDeviceSizePtr, mCapacity, mIsWeak ? "true" : "false");
-}
-} // namespace gpu
-} // namespace its
-} // namespace o2
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index 531cf2b0dcd33..56f6e57e2f305 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -17,16 +17,13 @@ message(STATUS "Building ITS CUDA tracker")
 # add_compile_definitions(ITS_MEASURE_GPU_TIME)
 o2_add_library(ITStrackingCUDA
                SOURCES ClusterLinesGPU.cu
-                       Context.cu
                        Stream.cu
                        TrackerTraitsGPU.cxx
                        TimeFrameGPU.cu
-                       TimeFrameChunk.cu
                        TracerGPU.cu
                        TrackingKernels.cu
                        VertexingKernels.cu
                        VertexerTraitsGPU.cxx
-                       Utils.cu
                PUBLIC_INCLUDE_DIRECTORIES ../
                PUBLIC_LINK_LIBRARIES O2::ITStracking
                                      O2::SimConfig
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Context.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Context.cu
deleted file mode 100644
index f3bced9463020..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Context.cu
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include <cuda_runtime.h>
-#include "ITStrackingGPU/Context.h"
-#include "ITStrackingGPU/Utils.h"
-
-#include <sstream>
-#include <stdexcept>
-#include <iostream>
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-
-using utils::checkGPUError;
-
-Context::Context(bool dumpDevices)
-{
-  checkGPUError(cudaGetDeviceCount(&mDevicesNum), __FILE__, __LINE__);
-
-  if (mDevicesNum == 0) {
-    throw std::runtime_error{"There are no available GPU device(s)\n"};
-  }
-
-  mDeviceProperties.resize(mDevicesNum, DeviceProperties{});
-
-  int currentDeviceIndex;
-  checkGPUError(cudaGetDevice(&currentDeviceIndex), __FILE__, __LINE__);
-
-  for (int iDevice{0}; iDevice < mDevicesNum; ++iDevice) {
-
-    cudaDeviceProp deviceProperties;
-
-    checkGPUError(cudaSetDevice(iDevice), __FILE__, __LINE__);
-    checkGPUError(cudaGetDeviceProperties(&deviceProperties, iDevice), __FILE__, __LINE__);
-
-    int major = deviceProperties.major;
-    int minor = deviceProperties.minor;
-
-    mDeviceProperties[iDevice].name = deviceProperties.name;
-    mDeviceProperties[iDevice].gpuProcessors = deviceProperties.multiProcessorCount;
-    mDeviceProperties[iDevice].gpuCores = getGPUCores(major, minor) * deviceProperties.multiProcessorCount;
-    mDeviceProperties[iDevice].globalMemorySize = deviceProperties.totalGlobalMem;
-    mDeviceProperties[iDevice].constantMemorySize = deviceProperties.totalConstMem;
-    mDeviceProperties[iDevice].sharedMemorySize = deviceProperties.sharedMemPerBlock;
-    mDeviceProperties[iDevice].maxClockRate = deviceProperties.memoryClockRate;
-    mDeviceProperties[iDevice].busWidth = deviceProperties.memoryBusWidth;
-    mDeviceProperties[iDevice].l2CacheSize = deviceProperties.l2CacheSize;
-    mDeviceProperties[iDevice].registersPerBlock = deviceProperties.regsPerBlock;
-    mDeviceProperties[iDevice].warpSize = deviceProperties.warpSize;
-    mDeviceProperties[iDevice].maxThreadsPerBlock = deviceProperties.maxThreadsPerBlock;
-    mDeviceProperties[iDevice].maxBlocksPerSM = getGPUMaxThreadsPerComputingUnit();
-    mDeviceProperties[iDevice].maxThreadsDim = dim3{static_cast<unsigned int>(deviceProperties.maxThreadsDim[0]),
-                                                    static_cast<unsigned int>(deviceProperties.maxThreadsDim[1]),
-                                                    static_cast<unsigned int>(deviceProperties.maxThreadsDim[2])};
-    mDeviceProperties[iDevice].maxGridDim = dim3{static_cast<unsigned int>(deviceProperties.maxGridSize[0]),
-                                                 static_cast<unsigned int>(deviceProperties.maxGridSize[1]),
-                                                 static_cast<unsigned int>(deviceProperties.maxGridSize[2])};
-    if (dumpDevices) {
-      std::cout << "################ " << GPU_ARCH << " DEVICE " << iDevice << " ################" << std::endl;
-      std::cout << "Name " << mDeviceProperties[iDevice].name << std::endl;
-      std::cout << "minor " << minor << " major " << major << std::endl;
-      std::cout << "gpuProcessors " << mDeviceProperties[iDevice].gpuProcessors << std::endl;
-      std::cout << "gpuCores " << mDeviceProperties[iDevice].gpuCores << std::endl;
-      std::cout << "globalMemorySize " << mDeviceProperties[iDevice].globalMemorySize << std::endl;
-      std::cout << "constantMemorySize " << mDeviceProperties[iDevice].constantMemorySize << std::endl;
-      std::cout << "sharedMemorySize " << mDeviceProperties[iDevice].sharedMemorySize << std::endl;
-      std::cout << "maxClockRate " << mDeviceProperties[iDevice].maxClockRate << std::endl;
-      std::cout << "busWidth " << mDeviceProperties[iDevice].busWidth << std::endl;
-      std::cout << "l2CacheSize " << mDeviceProperties[iDevice].l2CacheSize << std::endl;
-      std::cout << "registersPerBlock " << mDeviceProperties[iDevice].registersPerBlock << std::endl;
-      std::cout << "warpSize " << mDeviceProperties[iDevice].warpSize << std::endl;
-      std::cout << "maxThreadsPerBlock " << mDeviceProperties[iDevice].maxThreadsPerBlock << std::endl;
-      std::cout << "maxBlocksPerSM " << mDeviceProperties[iDevice].maxBlocksPerSM << std::endl;
-      std::cout << "maxThreadsDim " << mDeviceProperties[iDevice].maxThreadsDim.x << ", "
-                << mDeviceProperties[iDevice].maxThreadsDim.y << ", "
-                << mDeviceProperties[iDevice].maxThreadsDim.z << std::endl;
-      std::cout << "maxGridDim " << mDeviceProperties[iDevice].maxGridDim.x << ", "
-                << mDeviceProperties[iDevice].maxGridDim.y << ", "
-                << mDeviceProperties[iDevice].maxGridDim.z << std::endl;
-      std::cout << std::endl;
-    }
-  }
-
-  checkGPUError(cudaSetDevice(currentDeviceIndex), __FILE__, __LINE__);
-}
-
-Context& Context::getInstance()
-{
-  static Context gpuContext;
-  return gpuContext;
-}
-
-const DeviceProperties& Context::getDeviceProperties()
-{
-  int currentDeviceIndex;
-  checkGPUError(cudaGetDevice(&currentDeviceIndex), __FILE__, __LINE__);
-
-  return getDeviceProperties(currentDeviceIndex);
-}
-
-const DeviceProperties& Context::getDeviceProperties(const int deviceIndex)
-{
-  return mDeviceProperties[deviceIndex];
-}
-
-} // namespace gpu
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Stream.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Stream.cu
index 885587d8d4544..34bc3dc68a7a4 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Stream.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Stream.cu
@@ -10,10 +10,8 @@
 // or submit itself to any jurisdiction.
 ///
 
-#include <cuda_runtime.h>
 #include "ITStrackingGPU/Stream.h"
-#include "ITStrackingGPU/Utils.h"
-#include "GPUCommonLogger.h"
+#include "GPUCommonHelpers.h"
 
 namespace o2
 {
@@ -21,16 +19,15 @@ namespace its
 {
 namespace gpu
 {
-using utils::checkGPUError;
 
 Stream::Stream()
 {
-  checkGPUError(cudaStreamCreate(&mStream));
+  GPUChkErrS(cudaStreamCreate(&mStream));
 }
+
 Stream::~Stream()
 {
-  LOGP(info, "Destroying stream");
-  checkGPUError(cudaStreamDestroy(mStream));
+  GPUChkErrS(cudaStreamDestroy(mStream));
 }
 
 const GPUStream& Stream::get() const
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameChunk.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameChunk.cu
index 8353b6ff0aa8b..c8512e667aea8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameChunk.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameChunk.cu
@@ -26,6 +26,7 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonLogger.h"
+#include "GPUCommonHelpers.h"
 
 #ifndef __HIPCC__
 #define THRUST_NAMESPACE thrust::cuda
@@ -39,38 +40,37 @@ using constants::GB;
 using constants::MB;
 namespace gpu
 {
-using utils::checkGPUError;
 
 template <int nLayers>
 GpuTimeFrameChunk<nLayers>::~GpuTimeFrameChunk()
 {
   if (mAllocated) {
     for (int i = 0; i < nLayers; ++i) {
-      checkGPUError(cudaFree(mClustersDevice[i]));
-      // checkGPUError(cudaFree(mTrackingFrameInfoDevice[i]));
-      checkGPUError(cudaFree(mClusterExternalIndicesDevice[i]));
-      checkGPUError(cudaFree(mIndexTablesDevice[i]));
+      GPUChkErrS(cudaFree(mClustersDevice[i]));
+      // GPUChkErrS(cudaFree(mTrackingFrameInfoDevice[i]));
+      GPUChkErrS(cudaFree(mClusterExternalIndicesDevice[i]));
+      GPUChkErrS(cudaFree(mIndexTablesDevice[i]));
       if (i < nLayers - 1) {
-        checkGPUError(cudaFree(mTrackletsDevice[i]));
-        checkGPUError(cudaFree(mTrackletsLookupTablesDevice[i]));
+        GPUChkErrS(cudaFree(mTrackletsDevice[i]));
+        GPUChkErrS(cudaFree(mTrackletsLookupTablesDevice[i]));
         if (i < nLayers - 2) {
-          checkGPUError(cudaFree(mCellsDevice[i]));
-          checkGPUError(cudaFree(mCellsLookupTablesDevice[i]));
-          checkGPUError(cudaFree(mRoadsLookupTablesDevice[i]));
+          GPUChkErrS(cudaFree(mCellsDevice[i]));
+          GPUChkErrS(cudaFree(mCellsLookupTablesDevice[i]));
+          GPUChkErrS(cudaFree(mRoadsLookupTablesDevice[i]));
           if (i < nLayers - 3) {
-            checkGPUError(cudaFree(mNeighboursCellLookupTablesDevice[i]));
-            checkGPUError(cudaFree(mNeighboursCellDevice[i]));
+            GPUChkErrS(cudaFree(mNeighboursCellLookupTablesDevice[i]));
+            GPUChkErrS(cudaFree(mNeighboursCellDevice[i]));
           }
         }
       }
     }
-    // checkGPUError(cudaFree(mRoadsDevice));
-    checkGPUError(cudaFree(mCUBTmpBufferDevice));
-    checkGPUError(cudaFree(mFoundTrackletsDevice));
-    checkGPUError(cudaFree(mNFoundCellsDevice));
-    checkGPUError(cudaFree(mCellsDeviceArray));
-    checkGPUError(cudaFree(mNeighboursCellDeviceArray));
-    checkGPUError(cudaFree(mNeighboursCellLookupTablesDeviceArray));
+    // GPUChkErrS(cudaFree(mRoadsDevice));
+    GPUChkErrS(cudaFree(mCUBTmpBufferDevice));
+    GPUChkErrS(cudaFree(mFoundTrackletsDevice));
+    GPUChkErrS(cudaFree(mNFoundCellsDevice));
+    GPUChkErrS(cudaFree(mCellsDeviceArray));
+    GPUChkErrS(cudaFree(mNeighboursCellDeviceArray));
+    GPUChkErrS(cudaFree(mNeighboursCellLookupTablesDeviceArray));
   }
 }
 
@@ -117,9 +117,9 @@ void GpuTimeFrameChunk<nLayers>::allocate(const size_t nrof, Stream& stream)
   // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mNeighboursCellLookupTablesDeviceArray), (nLayers - 3) * sizeof(int*), &stream, true);
 
   // /// Copy pointers of allocated memory to regrouping arrays
-  // checkGPUError(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, stream.get()));
-  // checkGPUError(cudaMemcpyAsync(mNeighboursCellDeviceArray, mNeighboursCellDevice.data(), (nLayers - 3) * sizeof(int*), cudaMemcpyHostToDevice, stream.get()));
-  // checkGPUError(cudaMemcpyAsync(mNeighboursCellLookupTablesDeviceArray, mNeighboursCellLookupTablesDevice.data(), (nLayers - 3) * sizeof(int*), cudaMemcpyHostToDevice, stream.get()));
+  // GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, stream.get()));
+  // GPUChkErrS(cudaMemcpyAsync(mNeighboursCellDeviceArray, mNeighboursCellDevice.data(), (nLayers - 3) * sizeof(int*), cudaMemcpyHostToDevice, stream.get()));
+  // GPUChkErrS(cudaMemcpyAsync(mNeighboursCellLookupTablesDeviceArray, mNeighboursCellLookupTablesDevice.data(), (nLayers - 3) * sizeof(int*), cudaMemcpyHostToDevice, stream.get()));
 
   mAllocated = true;
 }
@@ -133,28 +133,28 @@ void GpuTimeFrameChunk<nLayers>::reset(const Task task, Stream& stream)
   //     auto thrustTrackletsBegin = thrust::device_ptr<Tracklet>(mTrackletsDevice[i]);
   //     auto thrustTrackletsEnd = thrustTrackletsBegin + mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * mNRof;
   //     thrust::fill(THRUST_NAMESPACE::par.on(stream.get()), thrustTrackletsBegin, thrustTrackletsEnd, Tracklet{});
-  //     checkGPUError(cudaMemsetAsync(mNTrackletsPerClusterDevice[i], 0, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
+  //     GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterDevice[i], 0, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
   //   }
-  //   checkGPUError(cudaMemsetAsync(mUsedTrackletsDevice, false, sizeof(unsigned char) * mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
-  //   checkGPUError(cudaMemsetAsync(mClusteredLinesDevice, -1, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mTFGPUParams->maxTrackletsPerCluster * mNRof, stream.get()));
+  //   GPUChkErrS(cudaMemsetAsync(mUsedTrackletsDevice, false, sizeof(unsigned char) * mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
+  //   GPUChkErrS(cudaMemsetAsync(mClusteredLinesDevice, -1, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mTFGPUParams->maxTrackletsPerCluster * mNRof, stream.get()));
   // } else {
   //   for (int i = 0; i < nLayers; ++i) {
   //     if (i < nLayers - 1) {
-  //       checkGPUError(cudaMemsetAsync(mTrackletsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
+  //       GPUChkErrS(cudaMemsetAsync(mTrackletsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
   //       auto thrustTrackletsBegin = thrust::device_ptr<Tracklet>(mTrackletsDevice[i]);
   //       auto thrustTrackletsEnd = thrustTrackletsBegin + mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * mNRof;
   //       thrust::fill(THRUST_NAMESPACE::par.on(stream.get()), thrustTrackletsBegin, thrustTrackletsEnd, Tracklet{});
   //       if (i < nLayers - 2) {
-  //         checkGPUError(cudaMemsetAsync(mCellsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->cellsLUTsize * mNRof, stream.get()));
-  //         checkGPUError(cudaMemsetAsync(mRoadsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
+  //         GPUChkErrS(cudaMemsetAsync(mCellsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->cellsLUTsize * mNRof, stream.get()));
+  //         GPUChkErrS(cudaMemsetAsync(mRoadsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
   //         if (i < nLayers - 3) {
-  //           checkGPUError(cudaMemsetAsync(mNeighboursCellLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
-  //           checkGPUError(cudaMemsetAsync(mNeighboursCellDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
+  //           GPUChkErrS(cudaMemsetAsync(mNeighboursCellLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
+  //           GPUChkErrS(cudaMemsetAsync(mNeighboursCellDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
   //         }
   //       }
   //     }
   //   }
-  //   checkGPUError(cudaMemsetAsync(mNFoundCellsDevice, 0, (nLayers - 2) * sizeof(int), stream.get()));
+  //   GPUChkErrS(cudaMemsetAsync(mNFoundCellsDevice, 0, (nLayers - 2) * sizeof(int), stream.get()));
   // }
 }
 
@@ -275,12 +275,12 @@ size_t GpuTimeFrameChunk<nLayers>::loadDataOnDevice(const size_t startRof, const
   //   if (mHostClusters[i].size() > mTFGPUParams->clustersPerROfCapacity * nRofs) {
   //     LOGP(warning, "Clusters on layer {} exceed the expected value, resizing to config value: {}, will lose information!", i, mTFGPUParams->clustersPerROfCapacity * nRofs);
   //   }
-  //   checkGPUError(cudaMemcpyAsync(mClustersDevice[i],
+  //   GPUChkErrS(cudaMemcpyAsync(mClustersDevice[i],
   //                                 mHostClusters[i].data(),
   //                                 (int)std::min(mHostClusters[i].size(), mTFGPUParams->clustersPerROfCapacity * nRofs) * sizeof(Cluster),
   //                                 cudaMemcpyHostToDevice, stream.get()));
   //   if (mHostIndexTables[i].data()) {
-  //     checkGPUError(cudaMemcpyAsync(mIndexTablesDevice[i],
+  //     GPUChkErrS(cudaMemcpyAsync(mIndexTablesDevice[i],
   //                                   mHostIndexTables[i].data(),
   //                                   mHostIndexTables[i].size() * sizeof(int),
   //                                   cudaMemcpyHostToDevice, stream.get()));
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index b1aa55f533c34..55d523dcc30d0 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -26,23 +26,24 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonLogger.h"
+#include "GPUCommonHelpers.h"
 
 #ifdef ITS_MEASURE_GPU_TIME
-#define START_GPU_STREAM_TIMER(stream, name)           \
-  cudaEvent_t event_start, event_stop;                 \
-  checkGPUError(cudaEventCreate(&event_start));        \
-  checkGPUError(cudaEventCreate(&event_stop));         \
-  checkGPUError(cudaEventRecord(event_start, stream)); \
+#define START_GPU_STREAM_TIMER(stream, name)        \
+  cudaEvent_t event_start, event_stop;              \
+  GPUChkErrS(cudaEventCreate(&event_start));        \
+  GPUChkErrS(cudaEventCreate(&event_stop));         \
+  GPUChkErrS(cudaEventRecord(event_start, stream)); \
   const std::string task_name = name;
 
 #define STOP_GPU_STREAM_TIMER(stream)                                                \
-  checkGPUError(cudaEventRecord(event_stop, stream));                                \
-  checkGPUError(cudaEventSynchronize(event_stop));                                   \
+  GPUChkErrS(cudaEventRecord(event_stop, stream));                                   \
+  GPUChkErrS(cudaEventSynchronize(event_stop));                                      \
   float ms;                                                                          \
-  checkGPUError(cudaEventElapsedTime(&ms, event_start, event_stop));                 \
+  GPUChkErrS(cudaEventElapsedTime(&ms, event_start, event_stop));                    \
   std::cout << "Elapsed time for " << task_name << ": " << ms << " ms" << std::endl; \
-  checkGPUError(cudaEventDestroy(event_start));                                      \
-  checkGPUError(cudaEventDestroy(event_stop));
+  GPUChkErrS(cudaEventDestroy(event_start));                                         \
+  GPUChkErrS(cudaEventDestroy(event_stop));
 #else
 #define START_GPU_STREAM_TIMER(stream, name)
 #define STOP_GPU_STREAM_TIMER(stream)
@@ -57,7 +58,6 @@ using constants::MB;
 
 namespace gpu
 {
-using utils::checkGPUError;
 
 void* DefaultGPUAllocator::allocate(size_t size)
 {
@@ -69,7 +69,6 @@ template <int nLayers>
 TimeFrameGPU<nLayers>::TimeFrameGPU()
 {
   mIsGPU = true;
-  utils::getDeviceProp(0, true);
 }
 
 template <int nLayers>
@@ -82,7 +81,7 @@ void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream* strPt
     *ptr = mAllocator->allocate(size);
   } else {
     LOGP(debug, "Calling default CUDA allocator");
-    checkGPUError(cudaMallocAsync(reinterpret_cast<void**>(ptr), size, strPtr->get()));
+    GPUChkErrS(cudaMallocAsync(reinterpret_cast<void**>(ptr), size, strPtr->get()));
   }
 }
 
@@ -101,7 +100,7 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
     allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), nullptr, getExtAllocator());
   }
   LOGP(debug, "gpu-transfer: loading IndexTableUtils object, for {} MB.", sizeof(IndexTableUtils) / MB);
-  checkGPUError(cudaMemcpyAsync(mIndexTableUtilsDevice, &mIndexTableUtils, sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &mIndexTableUtils, sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -113,12 +112,12 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} unsorted clusters on layer {}, for {} MB.", mUnsortedClusters[iLayer].size(), iLayer, mUnsortedClusters[iLayer].size() * sizeof(Cluster) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), mUnsortedClusters[iLayer].size() * sizeof(Cluster), nullptr, getExtAllocator());
-      checkGPUError(cudaHostRegister(mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      checkGPUError(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaHostRegister(mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
+      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, getExtAllocator());
-    checkGPUError(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    checkGPUError(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
@@ -131,12 +130,12 @@ void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} clusters on layer {}, for {} MB.", mClusters[iLayer].size(), iLayer, mClusters[iLayer].size() * sizeof(Cluster) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), mClusters[iLayer].size() * sizeof(Cluster), nullptr, getExtAllocator());
-      checkGPUError(cudaHostRegister(mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      checkGPUError(cudaMemcpyAsync(mClustersDevice[iLayer], mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaHostRegister(mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
+      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, getExtAllocator());
-    checkGPUError(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    checkGPUError(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
@@ -149,10 +148,10 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading clusters indextable for layer {} with {} elements, for {} MB.", iLayer, mIndexTables[iLayer].size(), mIndexTables[iLayer].size() * sizeof(int) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), mIndexTables[iLayer].size() * sizeof(int), nullptr, getExtAllocator());
-      checkGPUError(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], mIndexTables[iLayer].data(), mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], mIndexTables[iLayer].data(), mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), nullptr, getExtAllocator());
-    checkGPUError(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
@@ -165,10 +164,10 @@ void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: creating {} used clusters flags on layer {}, for {} MB.", mUsedClusters[iLayer].size(), iLayer, mUsedClusters[iLayer].size() * sizeof(unsigned char) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), mUsedClusters[iLayer].size() * sizeof(unsigned char), nullptr, getExtAllocator());
-      checkGPUError(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0].get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), nullptr, getExtAllocator());
-    checkGPUError(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
@@ -179,7 +178,7 @@ void TimeFrameGPU<nLayers>::loadUsedClustersDevice()
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading used clusters flags");
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} used clusters flags on layer {}, for {} MB.", mUsedClusters[iLayer].size(), iLayer, mClusters[iLayer].size() * sizeof(unsigned char) / MB);
-    checkGPUError(cudaMemcpyAsync(mUsedClustersDevice[iLayer], mUsedClusters[iLayer].data(), mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], mUsedClusters[iLayer].data(), mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
@@ -192,10 +191,10 @@ void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} ROframe clusters info on layer {}, for {} MB.", mROFramesClusters[iLayer].size(), iLayer, mROFramesClusters[iLayer].size() * sizeof(int) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), mROFramesClusters[iLayer].size() * sizeof(int), nullptr, getExtAllocator());
-      checkGPUError(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], mROFramesClusters[iLayer].data(), mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], mROFramesClusters[iLayer].data(), mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), nullptr, getExtAllocator());
-    checkGPUError(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
@@ -208,12 +207,12 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} tfinfo on layer {}, for {} MB.", mTrackingFrameInfo[iLayer].size(), iLayer, mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), nullptr, getExtAllocator());
-      checkGPUError(cudaHostRegister(mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
-      checkGPUError(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaHostRegister(mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
+      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), nullptr, getExtAllocator());
-    checkGPUError(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
-    checkGPUError(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
@@ -225,7 +224,7 @@ void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
     START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading multiplicity cut mask");
     LOGP(debug, "gpu-transfer: loading multiplicity cut mask with {} elements, for {} MB.", mMultiplicityCutMask.size(), mMultiplicityCutMask.size() * sizeof(bool) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), mMultiplicityCutMask.size() * sizeof(uint8_t), nullptr, getExtAllocator());
-    checkGPUError(cudaMemcpyAsync(mMultMaskDevice, mMultiplicityCutMask.data(), mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, mMultiplicityCutMask.data(), mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
@@ -237,10 +236,10 @@ void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
     START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading seeding vertices");
     LOGP(debug, "gpu-transfer: loading {} ROframes vertices, for {} MB.", mROFramesPV.size(), mROFramesPV.size() * sizeof(int) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), mROFramesPV.size() * sizeof(int), nullptr, getExtAllocator());
-    checkGPUError(cudaMemcpyAsync(mROFramesPVDevice, mROFramesPV.data(), mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, mROFramesPV.data(), mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     LOGP(debug, "gpu-transfer: loading {} seeding vertices, for {} MB.", mPrimaryVertices.size(), mPrimaryVertices.size() * sizeof(Vertex) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), mPrimaryVertices.size() * sizeof(Vertex), nullptr, getExtAllocator());
-    checkGPUError(cudaMemcpyAsync(mPrimaryVerticesDevice, mPrimaryVertices.data(), mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, mPrimaryVertices.data(), mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
@@ -254,11 +253,11 @@ void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
       LOGP(debug, "gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {} MB.", mClusters[iLayer].size() + 1, iLayer, (mClusters[iLayer].size() + 1) * sizeof(int) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (mClusters[iLayer].size() + 1) * sizeof(int), nullptr, getExtAllocator());
     }
-    checkGPUError(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
   }
   if (!iteration) {
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), nullptr, getExtAllocator());
-    checkGPUError(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
@@ -269,13 +268,13 @@ void TimeFrameGPU<nLayers>::createTrackletsBuffers()
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells buffers");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     mNTracklets[iLayer] = 0;
-    checkGPUError(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost));
+    GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost));
     LOGP(debug, "gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {} MB.", mNTracklets[iLayer], iLayer, mNTracklets[iLayer] * sizeof(Tracklet) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), nullptr, getExtAllocator());
   }
   allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), nullptr, getExtAllocator());
-  checkGPUError(cudaHostRegister(mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaHostRegisterPortable));
-  checkGPUError(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -285,8 +284,8 @@ void TimeFrameGPU<nLayers>::loadTrackletsDevice()
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} tracklets on layer {}, for {} MB.", mTracklets[iLayer].size(), iLayer, mTracklets[iLayer].size() * sizeof(Tracklet) / MB);
-    checkGPUError(cudaHostRegister(mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
-    checkGPUError(cudaMemcpyAsync(mTrackletsDevice[iLayer], mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaHostRegister(mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
@@ -297,11 +296,11 @@ void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {} MB", mTrackletsLookupTable[iLayer].size(), iLayer + 1, mTrackletsLookupTable[iLayer].size() * sizeof(int) / MB);
-    checkGPUError(cudaHostRegister(mTrackletsLookupTable[iLayer].data(), mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-    checkGPUError(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], mTrackletsLookupTable[iLayer].data(), mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice));
+    GPUChkErrS(cudaHostRegister(mTrackletsLookupTable[iLayer].data(), mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], mTrackletsLookupTable[iLayer].data(), mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice));
   }
-  checkGPUError(cudaHostRegister(mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaHostRegisterPortable));
-  checkGPUError(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
+  GPUChkErrS(cudaHostRegister(mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -311,12 +310,12 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells neighbours");
   // Here we do also the creation of the CellsDeviceArray, as the cells buffers are populated separately in the previous steps.
   allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, getExtAllocator());
-  checkGPUError(cudaHostRegister(mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaHostRegisterPortable));
-  checkGPUError(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaHostRegister(mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), nullptr, getExtAllocator());
-    checkGPUError(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
@@ -327,7 +326,7 @@ void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const uns
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighboursLUT");
   LOGP(debug, "gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), nullptr, getExtAllocator()); // We need one element more to move exc -> inc
-  checkGPUError(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0].get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -339,11 +338,11 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
     LOGP(debug, "gpu-transfer: loading {} cell seeds on layer {}, for {} MB.", mCells[iLayer].size(), iLayer, mCells[iLayer].size() * sizeof(CellSeed) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), mCells[iLayer].size() * sizeof(CellSeed), nullptr, getExtAllocator());
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mCells[iLayer].size() + 1) * sizeof(int), nullptr, getExtAllocator()); // accessory for the neigh. finding.
-    checkGPUError(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
-    checkGPUError(cudaMemcpyAsync(mCellsDevice[iLayer], mCells[iLayer].data(), mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], mCells[iLayer].data(), mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
   allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, getExtAllocator());
-  checkGPUError(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -354,10 +353,10 @@ void TimeFrameGPU<nLayers>::createCellsLUTDevice()
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: creating cell LUT for {} elements on layer {}, for {} MB.", mNTracklets[iLayer] + 1, iLayer, (mNTracklets[iLayer] + 1) * sizeof(int) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), nullptr, getExtAllocator());
-    checkGPUError(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
   }
   allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), nullptr, getExtAllocator());
-  checkGPUError(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -366,7 +365,7 @@ void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells buffers");
   mNCells[layer] = 0;
-  checkGPUError(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost));
+  GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost));
   LOGP(debug, "gpu-transfer: creating cell buffer for {} elements on layer {}, for {} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), nullptr, getExtAllocator());
 
@@ -379,8 +378,8 @@ void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading cells LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading cell LUT for {} elements on layer {}, for {} MB.", mCellsLookupTable[iLayer].size(), iLayer, mCellsLookupTable[iLayer].size() * sizeof(int) / MB);
-    checkGPUError(cudaHostRegister(mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-    checkGPUError(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaHostRegister(mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
@@ -390,8 +389,8 @@ void TimeFrameGPU<nLayers>::loadRoadsDevice()
 {
   LOGP(debug, "gpu-transfer: loading {} roads, for {} MB.", mRoads.size(), mRoads.size() * sizeof(Road<nLayers - 2>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), mRoads.size() * sizeof(Road<nLayers - 2>), &(mGpuStreams[0]), getExtAllocator());
-  checkGPUError(cudaHostRegister(mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
-  checkGPUError(cudaMemcpyAsync(mRoadsDevice, mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaHostRegister(mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
 }
 
 template <int nLayers>
@@ -400,8 +399,8 @@ void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(std::vector<CellSeed>& seeds)
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading track seeds");
   LOGP(debug, "gpu-transfer: loading {} track seeds, for {} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), &(mGpuStreams[0]), getExtAllocator());
-  checkGPUError(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
-  checkGPUError(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -411,7 +410,7 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, con
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), &(mGpuStreams[0]), getExtAllocator());
-  checkGPUError(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), &(mGpuStreams[0]), getExtAllocator());
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
@@ -425,7 +424,7 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, std
   mCellsNeighbours[layer].resize(neighbours.size());
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), neighbours.size() * sizeof(gpuPair<int, int>), &(mGpuStreams[0]), getExtAllocator());
-  checkGPUError(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), &(mGpuStreams[0]), getExtAllocator());
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
@@ -436,7 +435,7 @@ void TimeFrameGPU<nLayers>::createNeighboursDeviceArray()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDeviceArray), (nLayers - 2) * sizeof(int*), &(mGpuStreams[0]), getExtAllocator());
-  checkGPUError(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -448,8 +447,8 @@ void TimeFrameGPU<nLayers>::createTrackITSExtDevice(std::vector<CellSeed>& seeds
   mTrackITSExt.resize(seeds.size());
   LOGP(debug, "gpu-allocation: reserving {} tracks, for {} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), &(mGpuStreams[0]), getExtAllocator());
-  checkGPUError(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0].get()));
-  checkGPUError(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0].get()));
+  GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -460,7 +459,7 @@ void TimeFrameGPU<nLayers>::downloadCellsDevice()
   for (int iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading {} cells on layer: {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
     mCells[iLayer].resize(mNCells[iLayer]);
-    checkGPUError(cudaMemcpyAsync(mCells[iLayer].data(), mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCells[iLayer].data(), mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
@@ -472,7 +471,7 @@ void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading cells lut on layer {} for {} elements", iLayer, (mNTracklets[iLayer + 1] + 1));
     mCellsLookupTable[iLayer].resize(mNTracklets[iLayer + 1] + 1);
-    checkGPUError(cudaMemcpyAsync(mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
@@ -483,7 +482,7 @@ void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<std::vecto
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), fmt::format("downloading neighbours from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading {} neighbours, for {} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / MB);
   // TODO: something less dangerous than assuming the same memory layout of std::pair and gpuPair... or not? :)
-  checkGPUError(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
 }
 
 template <int nLayers>
@@ -491,7 +490,7 @@ void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(std::vector<int>& lut, c
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), fmt::format("downloading neighbours LUT from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {} MB.", lut.size(), layer, lut.size() * sizeof(int) / MB);
-  checkGPUError(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -500,9 +499,9 @@ void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(std::vector<CellSeed>& see
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading tracks");
   LOGP(debug, "gpu-transfer: downloading {} tracks, for {} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / MB);
-  checkGPUError(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
-  checkGPUError(cudaHostUnregister(mTrackITSExt.data()));
-  checkGPUError(cudaHostUnregister(seeds.data()));
+  GPUChkErrS(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  GPUChkErrS(cudaHostUnregister(mTrackITSExt.data()));
+  GPUChkErrS(cudaHostUnregister(seeds.data()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -511,8 +510,8 @@ void TimeFrameGPU<nLayers>::unregisterRest()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "unregistering rest of the host memory");
   LOGP(debug, "unregistering rest of the host memory...");
-  checkGPUError(cudaHostUnregister(mCellsDevice.data()));
-  checkGPUError(cudaHostUnregister(mTrackletsDevice.data()));
+  GPUChkErrS(cudaHostUnregister(mCellsDevice.data()));
+  GPUChkErrS(cudaHostUnregister(mTrackletsDevice.data()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
@@ -520,13 +519,13 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
 {
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-    checkGPUError(cudaHostUnregister(mUnsortedClusters[iLayer].data()));
-    checkGPUError(cudaHostUnregister(mClusters[iLayer].data()));
-    checkGPUError(cudaHostUnregister(mTrackingFrameInfo[iLayer].data()));
+    GPUChkErrS(cudaHostUnregister(mUnsortedClusters[iLayer].data()));
+    GPUChkErrS(cudaHostUnregister(mClusters[iLayer].data()));
+    GPUChkErrS(cudaHostUnregister(mTrackingFrameInfo[iLayer].data()));
   }
-  checkGPUError(cudaHostUnregister(mTrackingFrameInfoDevice.data()));
-  checkGPUError(cudaHostUnregister(mUnsortedClustersDevice.data()));
-  checkGPUError(cudaHostUnregister(mClustersDevice.data()));
+  GPUChkErrS(cudaHostUnregister(mTrackingFrameInfoDevice.data()));
+  GPUChkErrS(cudaHostUnregister(mUnsortedClustersDevice.data()));
+  GPUChkErrS(cudaHostUnregister(mClustersDevice.data()));
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 583452d0c429c..805e66675e1b9 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -36,6 +36,9 @@
 
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
 #include "ITStrackingGPU/TrackingKernels.h"
+#include "ITStrackingGPU/Utils.h"
+
+#include "GPUCommonHelpers.h"
 
 #ifndef __HIPCC__
 #define THRUST_NAMESPACE thrust::cuda
@@ -51,20 +54,6 @@
 #include "DetectorsBase/Propagator.h"
 using namespace o2::track;
 
-#define gpuCheckError(x)                \
-  {                                     \
-    gpuAssert((x), __FILE__, __LINE__); \
-  }
-inline void gpuAssert(cudaError_t code, const char* file, int line, bool abort = true)
-{
-  if (code != cudaSuccess) {
-    LOGF(error, "GPUassert: %s %s %d", cudaGetErrorString(code), file, line);
-    if (abort) {
-      throw std::runtime_error("GPU assert failed.");
-    }
-  }
-}
-
 namespace o2::its
 {
 using namespace constants::its2;
@@ -873,20 +862,20 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
       mulScatAng[iLayer]);
     void* d_temp_storage = nullptr;
     size_t temp_storage_bytes = 0;
-    gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
-                                                temp_storage_bytes,        // temp_storage_bytes
-                                                trackletsLUTsHost[iLayer], // d_in
-                                                trackletsLUTsHost[iLayer], // d_out
-                                                nClusters[iLayer] + 1,     // num_items
-                                                0));                       // NOLINT: this is the offset of the sum, not a pointer
-    discardResult(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-    gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
-                                                temp_storage_bytes,        // temp_storage_bytes
-                                                trackletsLUTsHost[iLayer], // d_in
-                                                trackletsLUTsHost[iLayer], // d_out
-                                                nClusters[iLayer] + 1,     // num_items
-                                                0));                       // NOLINT: this is the offset of the sum, not a pointer
-    gpuCheckError(cudaFree(d_temp_storage));
+    GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
+                                             temp_storage_bytes,        // temp_storage_bytes
+                                             trackletsLUTsHost[iLayer], // d_in
+                                             trackletsLUTsHost[iLayer], // d_out
+                                             nClusters[iLayer] + 1,     // num_items
+                                             0));                       // NOLINT: this is the offset of the sum, not a pointer
+    GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+    GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
+                                             temp_storage_bytes,        // temp_storage_bytes
+                                             trackletsLUTsHost[iLayer], // d_in
+                                             trackletsLUTsHost[iLayer], // d_out
+                                             nClusters[iLayer] + 1,     // num_items
+                                             0));                       // NOLINT: this is the offset of the sum, not a pointer
+    GPUChkErrS(cudaFree(d_temp_storage));
   }
 }
 
@@ -955,24 +944,24 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
     auto unique_end = thrust::unique(thrust::device, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::equal_tracklets());
     nTracklets[iLayer] = unique_end - tracklets_ptr;
     if (iLayer > 0) {
-      gpuCheckError(cudaMemset(trackletsLUTsHost[iLayer], 0, nClusters[iLayer] * sizeof(int)));
+      GPUChkErrS(cudaMemset(trackletsLUTsHost[iLayer], 0, nClusters[iLayer] * sizeof(int)));
       gpu::compileTrackletsLookupTableKernel<<<nBlocks, nThreads>>>(spanTracklets[iLayer], trackletsLUTsHost[iLayer], nTracklets[iLayer]);
       void* d_temp_storage = nullptr;
       size_t temp_storage_bytes = 0;
-      gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
-                                                  temp_storage_bytes,        // temp_storage_bytes
-                                                  trackletsLUTsHost[iLayer], // d_in
-                                                  trackletsLUTsHost[iLayer], // d_out
-                                                  nClusters[iLayer] + 1,     // num_items
-                                                  0));                       // NOLINT: this is the offset of the sum, not a pointer
-      discardResult(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-      gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
-                                                  temp_storage_bytes,        // temp_storage_bytes
-                                                  trackletsLUTsHost[iLayer], // d_in
-                                                  trackletsLUTsHost[iLayer], // d_out
-                                                  nClusters[iLayer] + 1,     // num_items
-                                                  0));                       // NOLINT: this is the offset of the sum, not a pointer
-      gpuCheckError(cudaFree(d_temp_storage));
+      GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
+                                               temp_storage_bytes,        // temp_storage_bytes
+                                               trackletsLUTsHost[iLayer], // d_in
+                                               trackletsLUTsHost[iLayer], // d_out
+                                               nClusters[iLayer] + 1,     // num_items
+                                               0));                       // NOLINT: this is the offset of the sum, not a pointer
+      GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+      GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
+                                               temp_storage_bytes,        // temp_storage_bytes
+                                               trackletsLUTsHost[iLayer], // d_in
+                                               trackletsLUTsHost[iLayer], // d_out
+                                               nClusters[iLayer] + 1,     // num_items
+                                               0));                       // NOLINT: this is the offset of the sum, not a pointer
+      GPUChkErrS(cudaFree(d_temp_storage));
     }
   }
 }
@@ -1011,20 +1000,20 @@ void countCellsHandler(
     nSigmaCut);               // const float
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
-  gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage,     // d_temp_storage
-                                              temp_storage_bytes, // temp_storage_bytes
-                                              cellsLUTsHost,      // d_in
-                                              cellsLUTsHost,      // d_out
-                                              nTracklets + 1,     // num_items
-                                              0));                // NOLINT: this is the offset of the sum, not a pointer
-  discardResult(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-  gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage,     // d_temp_storage
-                                              temp_storage_bytes, // temp_storage_bytes
-                                              cellsLUTsHost,      // d_in
-                                              cellsLUTsHost,      // d_out
-                                              nTracklets + 1,     // num_items
-                                              0));                // NOLINT: this is the offset of the sum, not a pointer
-  gpuCheckError(cudaFree(d_temp_storage));
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,     // d_temp_storage
+                                           temp_storage_bytes, // temp_storage_bytes
+                                           cellsLUTsHost,      // d_in
+                                           cellsLUTsHost,      // d_out
+                                           nTracklets + 1,     // num_items
+                                           0));                // NOLINT: this is the offset of the sum, not a pointer
+  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,     // d_temp_storage
+                                           temp_storage_bytes, // temp_storage_bytes
+                                           cellsLUTsHost,      // d_in
+                                           cellsLUTsHost,      // d_out
+                                           nTracklets + 1,     // num_items
+                                           0));                // NOLINT: this is the offset of the sum, not a pointer
+  GPUChkErrS(cudaFree(d_temp_storage));
 }
 
 void computeCellsHandler(
@@ -1089,37 +1078,37 @@ unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
 
   void *d_temp_storage = nullptr, *d_temp_storage_2 = nullptr;
   size_t temp_storage_bytes = 0, temp_storage_bytes_2 = 0;
-  gpuCheckError(cub::DeviceScan::InclusiveSum(d_temp_storage,     // d_temp_storage
-                                              temp_storage_bytes, // temp_storage_bytes
-                                              neighboursLUT,      // d_in
-                                              neighboursLUT,      // d_out
-                                              nCellsNext));       // num_items
-
-  discardResult(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-  gpuCheckError(cub::DeviceScan::InclusiveSum(d_temp_storage,     // d_temp_storage
-                                              temp_storage_bytes, // temp_storage_bytes
-                                              neighboursLUT,      // d_in
-                                              neighboursLUT,      // d_out
-                                              nCellsNext));       // num_items
-
-  gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage_2,     // d_temp_storage
-                                              temp_storage_bytes_2, // temp_storage_bytes
-                                              neighboursIndexTable, // d_in
-                                              neighboursIndexTable, // d_out
-                                              nCells + 1,           // num_items
-                                              0));                  // NOLINT: this is the offset of the sum, not a pointer
-
-  discardResult(cudaMalloc(&d_temp_storage_2, temp_storage_bytes_2));
-  gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage_2,     // d_temp_storage
-                                              temp_storage_bytes_2, // temp_storage_bytes
-                                              neighboursIndexTable, // d_in
-                                              neighboursIndexTable, // d_out
-                                              nCells + 1,           // num_items
-                                              0));                  // NOLINT: this is the offset of the sum, not a pointer
+  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage,     // d_temp_storage
+                                           temp_storage_bytes, // temp_storage_bytes
+                                           neighboursLUT,      // d_in
+                                           neighboursLUT,      // d_out
+                                           nCellsNext));       // num_items
+
+  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage,     // d_temp_storage
+                                           temp_storage_bytes, // temp_storage_bytes
+                                           neighboursLUT,      // d_in
+                                           neighboursLUT,      // d_out
+                                           nCellsNext));       // num_items
+
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage_2,     // d_temp_storage
+                                           temp_storage_bytes_2, // temp_storage_bytes
+                                           neighboursIndexTable, // d_in
+                                           neighboursIndexTable, // d_out
+                                           nCells + 1,           // num_items
+                                           0));                  // NOLINT: this is the offset of the sum, not a pointer
+
+  GPUChkErrS(cudaMalloc(&d_temp_storage_2, temp_storage_bytes_2));
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage_2,     // d_temp_storage
+                                           temp_storage_bytes_2, // temp_storage_bytes
+                                           neighboursIndexTable, // d_in
+                                           neighboursIndexTable, // d_out
+                                           nCells + 1,           // num_items
+                                           0));                  // NOLINT: this is the offset of the sum, not a pointer
   unsigned int nNeighbours;
-  gpuCheckError(cudaMemcpy(&nNeighbours, &neighboursLUT[nCellsNext - 1], sizeof(unsigned int), cudaMemcpyDeviceToHost));
-  gpuCheckError(cudaFree(d_temp_storage));
-  gpuCheckError(cudaFree(d_temp_storage_2));
+  GPUChkErrS(cudaMemcpy(&nNeighbours, &neighboursLUT[nCellsNext - 1], sizeof(unsigned int), cudaMemcpyDeviceToHost));
+  GPUChkErrS(cudaFree(d_temp_storage));
+  GPUChkErrS(cudaFree(d_temp_storage_2));
   return nNeighbours;
 }
 
@@ -1150,8 +1139,8 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
     layerIndex,
     nCells,
     maxCellNeighbours);
-  gpuCheckError(cudaPeekAtLastError());
-  gpuCheckError(cudaDeviceSynchronize());
+  GPUChkErrS(cudaPeekAtLastError());
+  GPUChkErrS(cudaDeviceSynchronize());
 }
 
 int filterCellNeighboursHandler(std::vector<int>& neighHost, // TODO: eventually remove this!
@@ -1172,12 +1161,12 @@ int filterCellNeighboursHandler(std::vector<int>& neighHost, // TODO: eventually
   thrust::copy(thrust::make_permutation_iterator(neighVectorPairs, vals.begin()),
                thrust::make_permutation_iterator(neighVectorPairs, vals.end()),
                sortedNeigh.begin());
-  discardResult(cudaDeviceSynchronize());
+  GPUChkErrS(cudaDeviceSynchronize());
   auto trimmedBegin = thrust::find_if(sortedNeigh.begin(), sortedNeigh.end(), gpu::is_valid_pair<int, int>()); // trim leading -1s
   auto trimmedSize = sortedNeigh.end() - trimmedBegin;
   neighHost.resize(trimmedSize);
   thrust::transform(trimmedBegin, sortedNeigh.end(), validNeighs, gpu::pair_to_first<int, int>());
-  gpuCheckError(cudaMemcpy(neighHost.data(), cellNeighbours, trimmedSize * sizeof(int), cudaMemcpyDeviceToHost));
+  GPUChkErrS(cudaMemcpy(neighHost.data(), cellNeighbours, trimmedSize * sizeof(int), cudaMemcpyDeviceToHost));
 
   return trimmedSize;
 }
@@ -1225,19 +1214,19 @@ void processNeighboursHandler(const int startLayer,
                                                             matCorrType);
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
-  gpuCheckError(cub::DeviceScan::ExclusiveSum(nullptr,                                       // d_temp_storage
-                                              temp_storage_bytes,                            // temp_storage_bytes
-                                              thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
-                                              thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
-                                              nCells[startLayer] + 1,                        // num_items
-                                              0));                                           // NOLINT: this is the offset of the sum, not a pointer
-  discardResult(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-  gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage,                                // d_temp_storage
-                                              temp_storage_bytes,                            // temp_storage_bytes
-                                              thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
-                                              thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
-                                              nCells[startLayer] + 1,                        // num_items
-                                              0));                                           // NOLINT: this is the offset of the sum, not a pointer
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(nullptr,                                       // d_temp_storage
+                                           temp_storage_bytes,                            // temp_storage_bytes
+                                           thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
+                                           thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
+                                           nCells[startLayer] + 1,                        // num_items
+                                           0));                                           // NOLINT: this is the offset of the sum, not a pointer
+  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,                                // d_temp_storage
+                                           temp_storage_bytes,                            // temp_storage_bytes
+                                           thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
+                                           thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
+                                           nCells[startLayer] + 1,                        // num_items
+                                           0));                                           // NOLINT: this is the offset of the sum, not a pointer
 
   updatedCellId.resize(foundSeedsTable.back());
   updatedCellSeed.resize(foundSeedsTable.back());
@@ -1260,7 +1249,7 @@ void processNeighboursHandler(const int startLayer,
                                                              propagator,
                                                              matCorrType);
   auto t1 = updatedCellSeed.size();
-  gpuCheckError(cudaFree(d_temp_storage));
+  GPUChkErrS(cudaFree(d_temp_storage));
   int level = startLevel;
   for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
     temp_storage_bytes = 0;
@@ -1289,19 +1278,19 @@ void processNeighboursHandler(const int startLayer,
                                                               maxChi2ClusterAttachment,
                                                               propagator,
                                                               matCorrType);
-    gpuCheckError(cub::DeviceScan::ExclusiveSum(nullptr,                                       // d_temp_storage
-                                                temp_storage_bytes,                            // temp_storage_bytes
-                                                thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
-                                                thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
-                                                nCells[iLayer] + 1,                            // num_items
-                                                0));                                           // NOLINT: this is the offset of the sum, not a pointer
-    discardResult(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-    gpuCheckError(cub::DeviceScan::ExclusiveSum(d_temp_storage,                                // d_temp_storage
-                                                temp_storage_bytes,                            // temp_storage_bytes
-                                                thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
-                                                thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
-                                                nCells[iLayer] + 1,                            // num_items
-                                                0));                                           // NOLINT: this is the offset of the sum, not a pointer
+    GPUChkErrS(cub::DeviceScan::ExclusiveSum(nullptr,                                       // d_temp_storage
+                                             temp_storage_bytes,                            // temp_storage_bytes
+                                             thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
+                                             thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
+                                             nCells[iLayer] + 1,                            // num_items
+                                             0));                                           // NOLINT: this is the offset of the sum, not a pointer
+    GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+    GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,                                // d_temp_storage
+                                             temp_storage_bytes,                            // temp_storage_bytes
+                                             thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
+                                             thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
+                                             nCells[iLayer] + 1,                            // num_items
+                                             0));                                           // NOLINT: this is the offset of the sum, not a pointer
     auto foundSeeds{foundSeedsTable.back()};
     updatedCellId.resize(foundSeeds);
     thrust::fill(updatedCellId.begin(), updatedCellId.end(), 0);
@@ -1325,7 +1314,7 @@ void processNeighboursHandler(const int startLayer,
                                                                maxChi2ClusterAttachment,
                                                                propagator,
                                                                matCorrType);
-    gpuCheckError(cudaFree(d_temp_storage));
+    GPUChkErrS(cudaFree(d_temp_storage));
   }
   thrust::device_vector<CellSeed> outSeeds(updatedCellSeed.size());
   auto end = thrust::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
@@ -1365,8 +1354,8 @@ void trackSeedHandler(CellSeed* trackSeeds,
   thrust::device_ptr<o2::its::TrackITSExt> tr_ptr(tracks);
 
   thrust::sort(tr_ptr, tr_ptr + nSeeds, gpu::compare_track_chi2());
-  gpuCheckError(cudaPeekAtLastError());
-  gpuCheckError(cudaDeviceSynchronize());
+  GPUChkErrS(cudaPeekAtLastError());
+  GPUChkErrS(cudaDeviceSynchronize());
 }
 
 template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Utils.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Utils.cu
deleted file mode 100644
index 99a24f347bd48..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Utils.cu
+++ /dev/null
@@ -1,289 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include <cuda_runtime.h>
-#include "ITStrackingGPU/Utils.h"
-#include "ITStrackingGPU/Context.h"
-#include "ITStracking/Constants.h"
-
-#include <sstream>
-#include <stdexcept>
-#include <cstdio>
-#include <iomanip>
-#include <numeric>
-#include <iostream>
-#include <cstdint>
-
-namespace
-{
-int roundUp(const int numToRound, const int multiple)
-{
-  if (multiple == 0) {
-    return numToRound;
-  }
-
-  int remainder{numToRound % multiple};
-  if (remainder == 0) {
-    return numToRound;
-  }
-  return numToRound + multiple - remainder;
-}
-
-int findNearestDivisor(const int numToRound, const int divisor)
-{
-
-  if (numToRound > divisor) {
-    return divisor;
-  }
-
-  int result = numToRound;
-  while (divisor % result != 0) {
-    ++result;
-  }
-  return result;
-}
-
-} // namespace
-
-namespace o2
-{
-namespace its
-{
-using constants::GB;
-namespace gpu
-{
-GPUh() void gpuThrowOnError()
-{
-  cudaError_t error = cudaGetLastError();
-
-  if (error != cudaSuccess) {
-    std::ostringstream errorString{};
-    errorString << GPU_ARCH << " API returned error  [" << cudaGetErrorString(error) << "] (code " << error << ")" << std::endl;
-    throw std::runtime_error{errorString.str()};
-  }
-}
-
-double bytesToconfig(size_t s) { return (double)s / (1024.0); }
-double bytesToGB(size_t s) { return (double)s / GB; }
-
-void utils::checkGPUError(const cudaError_t error, const char* file, const int line)
-{
-  if (error != cudaSuccess) {
-    std::ostringstream errorString{};
-    errorString << file << ":" << line << std::endl
-                << GPU_ARCH << " API returned error [" << cudaGetErrorString(error) << "] (code "
-                << error << ")" << std::endl;
-    throw std::runtime_error{errorString.str()};
-  }
-}
-
-void utils::getDeviceProp(int deviceId, bool print)
-{
-  const int w1 = 34;
-  std::cout << std::left;
-  std::cout << std::setw(w1)
-            << "--------------------------------------------------------------------------------"
-            << std::endl;
-  std::cout << std::setw(w1) << "device#" << deviceId << std::endl;
-
-  cudaDeviceProp props;
-  checkGPUError(cudaGetDeviceProperties(&props, deviceId));
-  if (print) {
-    std::cout << std::setw(w1) << "Name: " << props.name << std::endl;
-    std::cout << std::setw(w1) << "pciBusID: " << props.pciBusID << std::endl;
-    std::cout << std::setw(w1) << "pciDeviceID: " << props.pciDeviceID << std::endl;
-    std::cout << std::setw(w1) << "pciDomainID: " << props.pciDomainID << std::endl;
-    std::cout << std::setw(w1) << "multiProcessorCount: " << props.multiProcessorCount << std::endl;
-    std::cout << std::setw(w1) << "maxThreadsPerMultiProcessor: " << props.maxThreadsPerMultiProcessor
-              << std::endl;
-    std::cout << std::setw(w1) << "isMultiGpuBoard: " << props.isMultiGpuBoard << std::endl;
-    std::cout << std::setw(w1) << "clockRate: " << (float)props.clockRate / 1000.0 << " Mhz" << std::endl;
-    std::cout << std::setw(w1) << "memoryClockRate: " << (float)props.memoryClockRate / 1000.0 << " Mhz"
-              << std::endl;
-    std::cout << std::setw(w1) << "memoryBusWidth: " << props.memoryBusWidth << std::endl;
-    std::cout << std::setw(w1) << "clockInstructionRate: " << (float)props.clockRate / 1000.0
-              << " Mhz" << std::endl;
-    std::cout << std::setw(w1) << "totalGlobalMem: " << std::fixed << std::setprecision(2)
-              << bytesToGB(props.totalGlobalMem) << " GB" << std::endl;
-#if !defined(__CUDACC__)
-    std::cout << std::setw(w1) << "maxSharedMemoryPerMultiProcessor: " << std::fixed << std::setprecision(2)
-              << bytesToconfig(props.sharedMemPerMultiprocessor) << " config" << std::endl;
-#endif
-#if defined(__HIPCC__)
-    std::cout << std::setw(w1) << "maxSharedMemoryPerMultiProcessor: " << std::fixed << std::setprecision(2)
-              << bytesToconfig(props.maxSharedMemoryPerMultiProcessor) << " config" << std::endl;
-#endif
-    std::cout << std::setw(w1) << "totalConstMem: " << props.totalConstMem << std::endl;
-    std::cout << std::setw(w1) << "sharedMemPerBlock: " << (float)props.sharedMemPerBlock / 1024.0 << " config"
-              << std::endl;
-    std::cout << std::setw(w1) << "canMapHostMemory: " << props.canMapHostMemory << std::endl;
-    std::cout << std::setw(w1) << "regsPerBlock: " << props.regsPerBlock << std::endl;
-    std::cout << std::setw(w1) << "warpSize: " << props.warpSize << std::endl;
-    std::cout << std::setw(w1) << "l2CacheSize: " << props.l2CacheSize << std::endl;
-    std::cout << std::setw(w1) << "computeMode: " << props.computeMode << std::endl;
-    std::cout << std::setw(w1) << "maxThreadsPerBlock: " << props.maxThreadsPerBlock << std::endl;
-    std::cout << std::setw(w1) << "maxThreadsDim.x: " << props.maxThreadsDim[0] << std::endl;
-    std::cout << std::setw(w1) << "maxThreadsDim.y: " << props.maxThreadsDim[1] << std::endl;
-    std::cout << std::setw(w1) << "maxThreadsDim.z: " << props.maxThreadsDim[2] << std::endl;
-    std::cout << std::setw(w1) << "maxGridSize.x: " << props.maxGridSize[0] << std::endl;
-    std::cout << std::setw(w1) << "maxGridSize.y: " << props.maxGridSize[1] << std::endl;
-    std::cout << std::setw(w1) << "maxGridSize.z: " << props.maxGridSize[2] << std::endl;
-    std::cout << std::setw(w1) << "major: " << props.major << std::endl;
-    std::cout << std::setw(w1) << "minor: " << props.minor << std::endl;
-    std::cout << std::setw(w1) << "concurrentKernels: " << props.concurrentKernels << std::endl;
-    std::cout << std::setw(w1) << "cooperativeLaunch: " << props.cooperativeLaunch << std::endl;
-    std::cout << std::setw(w1) << "cooperativeMultiDeviceLaunch: " << props.cooperativeMultiDeviceLaunch << std::endl;
-#if defined(__HIPCC__)
-    std::cout << std::setw(w1) << "arch.hasGlobalInt32Atomics: " << props.arch.hasGlobalInt32Atomics << std::endl;
-    std::cout << std::setw(w1) << "arch.hasGlobalFloatAtomicExch: " << props.arch.hasGlobalFloatAtomicExch
-              << std::endl;
-    std::cout << std::setw(w1) << "arch.hasSharedInt32Atomics: " << props.arch.hasSharedInt32Atomics << std::endl;
-    std::cout << std::setw(w1) << "arch.hasSharedFloatAtomicExch: " << props.arch.hasSharedFloatAtomicExch
-              << std::endl;
-    std::cout << std::setw(w1) << "arch.hasFloatAtomicAdd: " << props.arch.hasFloatAtomicAdd << std::endl;
-    std::cout << std::setw(w1) << "arch.hasGlobalInt64Atomics: " << props.arch.hasGlobalInt64Atomics << std::endl;
-    std::cout << std::setw(w1) << "arch.hasSharedInt64Atomics: " << props.arch.hasSharedInt64Atomics << std::endl;
-    std::cout << std::setw(w1) << "arch.hasDoubles: " << props.arch.hasDoubles << std::endl;
-    std::cout << std::setw(w1) << "arch.hasWarpVote: " << props.arch.hasWarpVote << std::endl;
-    std::cout << std::setw(w1) << "arch.hasWarpBallot: " << props.arch.hasWarpBallot << std::endl;
-    std::cout << std::setw(w1) << "arch.hasWarpShuffle: " << props.arch.hasWarpShuffle << std::endl;
-    std::cout << std::setw(w1) << "arch.hasFunnelShift: " << props.arch.hasFunnelShift << std::endl;
-    std::cout << std::setw(w1) << "arch.hasThreadFenceSystem: " << props.arch.hasThreadFenceSystem << std::endl;
-    std::cout << std::setw(w1) << "arch.hasSyncThreadsExt: " << props.arch.hasSyncThreadsExt << std::endl;
-    std::cout << std::setw(w1) << "arch.hasSurfaceFuncs: " << props.arch.hasSurfaceFuncs << std::endl;
-    std::cout << std::setw(w1) << "arch.has3dGrid: " << props.arch.has3dGrid << std::endl;
-    std::cout << std::setw(w1) << "arch.hasDynamicParallelism: " << props.arch.hasDynamicParallelism << std::endl;
-    std::cout << std::setw(w1) << "gcnArchName: " << props.gcnArchName << std::endl;
-#endif
-    std::cout << std::setw(w1) << "isIntegrated: " << props.integrated << std::endl;
-    std::cout << std::setw(w1) << "maxTexture1D: " << props.maxTexture1D << std::endl;
-    std::cout << std::setw(w1) << "maxTexture2D.width: " << props.maxTexture2D[0] << std::endl;
-    std::cout << std::setw(w1) << "maxTexture2D.height: " << props.maxTexture2D[1] << std::endl;
-    std::cout << std::setw(w1) << "maxTexture3D.width: " << props.maxTexture3D[0] << std::endl;
-    std::cout << std::setw(w1) << "maxTexture3D.height: " << props.maxTexture3D[1] << std::endl;
-    std::cout << std::setw(w1) << "maxTexture3D.depth: " << props.maxTexture3D[2] << std::endl;
-#if defined(__HIPCC__)
-    std::cout << std::setw(w1) << "isLargeBar: " << props.isLargeBar << std::endl;
-    std::cout << std::setw(w1) << "asicRevision: " << props.asicRevision << std::endl;
-#endif
-
-    int deviceCnt;
-    checkGPUError(cudaGetDeviceCount(&deviceCnt));
-    std::cout << std::setw(w1) << "peers: ";
-    for (int i = 0; i < deviceCnt; i++) {
-      int isPeer;
-      checkGPUError(cudaDeviceCanAccessPeer(&isPeer, i, deviceId));
-      if (isPeer) {
-        std::cout << "device#" << i << " ";
-      }
-    }
-    std::cout << std::endl;
-    std::cout << std::setw(w1) << "non-peers: ";
-    for (int i = 0; i < deviceCnt; i++) {
-      int isPeer;
-      checkGPUError(cudaDeviceCanAccessPeer(&isPeer, i, deviceId));
-      if (!isPeer) {
-        std::cout << "device#" << i << " ";
-      }
-    }
-    std::cout << std::endl;
-
-    size_t free, total;
-    checkGPUError(cudaMemGetInfo(&free, &total));
-
-    std::cout << std::fixed << std::setprecision(2);
-    std::cout << std::setw(w1) << "memInfo.total: " << bytesToGB(total) << " GB" << std::endl;
-    std::cout << std::setw(w1) << "memInfo.free:  " << bytesToGB(free) << " GB (" << std::setprecision(0)
-              << (float)free / total * 100.0 << "%)" << std::endl;
-  }
-}
-
-dim3 utils::getBlockSize(const int colsNum)
-{
-  return getBlockSize(colsNum, 1);
-}
-
-dim3 utils::getBlockSize(const int colsNum, const int rowsNum)
-{
-  const DeviceProperties& deviceProperties = Context::getInstance().getDeviceProperties();
-  return getBlockSize(colsNum, rowsNum, deviceProperties.gpuCores / deviceProperties.maxBlocksPerSM);
-}
-
-dim3 utils::getBlockSize(const int colsNum, const int rowsNum, const int maxThreadsPerBlock)
-{
-  const DeviceProperties& deviceProperties = Context::getInstance().getDeviceProperties();
-  int xThreads = max(min(colsNum, deviceProperties.maxThreadsDim.x), 1);
-  int yThreads = max(min(rowsNum, deviceProperties.maxThreadsDim.y), 1);
-  const int totalThreads = roundUp(min(xThreads * yThreads, maxThreadsPerBlock),
-                                   deviceProperties.warpSize);
-
-  if (xThreads > yThreads) {
-
-    xThreads = findNearestDivisor(xThreads, totalThreads);
-    yThreads = totalThreads / xThreads;
-
-  } else {
-
-    yThreads = findNearestDivisor(yThreads, totalThreads);
-    xThreads = totalThreads / yThreads;
-  }
-
-  return dim3{static_cast<unsigned int>(xThreads), static_cast<unsigned int>(yThreads)};
-}
-
-dim3 utils::getBlocksGrid(const dim3& threadsPerBlock, const int rowsNum)
-{
-  return getBlocksGrid(threadsPerBlock, rowsNum, 1);
-}
-
-dim3 utils::getBlocksGrid(const dim3& threadsPerBlock, const int rowsNum, const int colsNum)
-{
-
-  return dim3{1 + (rowsNum - 1) / threadsPerBlock.x, 1 + (colsNum - 1) / threadsPerBlock.y};
-}
-
-void utils::gpuMalloc(void** p, const int size)
-{
-  checkGPUError(cudaMalloc(p, size), __FILE__, __LINE__);
-}
-
-void utils::gpuFree(void* p)
-{
-  checkGPUError(cudaFree(p), __FILE__, __LINE__);
-}
-
-void utils::gpuMemset(void* p, int value, int size)
-{
-  checkGPUError(cudaMemset(p, value, size), __FILE__, __LINE__);
-}
-
-void utils::gpuMemcpyHostToDevice(void* dst, const void* src, int size)
-{
-  checkGPUError(cudaMemcpy(dst, src, size, cudaMemcpyHostToDevice), __FILE__, __LINE__);
-}
-
-void utils::gpuMemcpyDeviceToHost(void* dst, const void* src, int size)
-{
-  checkGPUError(cudaMemcpy(dst, src, size, cudaMemcpyDeviceToHost), __FILE__, __LINE__);
-}
-
-void utils::gpuMemcpyToSymbol(const void* symbol, const void* src, int size)
-{
-  checkGPUError(cudaMemcpyToSymbol(symbol, src, size, 0, cudaMemcpyHostToDevice), __FILE__, __LINE__);
-}
-
-void utils::gpuMemcpyFromSymbol(void* dst, const void* symbol, int size)
-{
-  checkGPUError(cudaMemcpyFromSymbol(dst, symbol, size, 0, cudaMemcpyDeviceToHost), __FILE__, __LINE__);
-}
-} // namespace gpu
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
index a26d52b2961c3..f630d2cdec76a 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
@@ -54,162 +54,162 @@ void VertexerTraitsGPU::computeTracklets(const int iteration)
   if (!mTimeFrameGPU->getClusters().size()) {
     return;
   }
-  std::vector<std::thread> threads(mTimeFrameGPU->getNChunks());
-  for (int chunkId{0}; chunkId < mTimeFrameGPU->getNChunks(); ++chunkId) {
-    //   int rofPerChunk{mTimeFrameGPU->mNrof / (int)mTimeFrameGPU->getNChunks()};
-    //   mTimeFrameGPU->getVerticesInChunks()[chunkId].clear();
-    //   mTimeFrameGPU->getNVerticesInChunks()[chunkId].clear();
-    //   mTimeFrameGPU->getLabelsInChunks()[chunkId].clear();
-    //   auto doVertexReconstruction = [&, chunkId, rofPerChunk]() -> void {
-    //     auto offset = chunkId * rofPerChunk;
-    //     auto maxROF = offset + rofPerChunk;
-    //     while (offset < maxROF) {
-    //       auto rofs = mTimeFrameGPU->loadChunkData<gpu::Task::Vertexer>(chunkId, offset, maxROF);
-    //       RANGE("chunk_gpu_vertexing", 1);
-    //       // gpu::GpuTimer timer{offset, mTimeFrameGPU->getStream(chunkId).get()};
-    //       // timer.Start("vtTrackletFinder");
-    //       gpu::trackleterKernelMultipleRof<TrackletMode::Layer0Layer1><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),         // const Cluster* clustersNextLayer,    // 0 2
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),         // const Cluster* clustersCurrentLayer, // 1 1
-    //         mTimeFrameGPU->getDeviceROframesClusters(0),                   // const int* sizeNextLClusters,
-    //         mTimeFrameGPU->getDeviceROframesClusters(1),                   // const int* sizeCurrentLClusters,
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceIndexTables(0),      // const int* nextIndexTables,
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),        // Tracklet* Tracklets,
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0), // int* foundTracklets,
-    //         mTimeFrameGPU->getDeviceIndexTableUtils(),                     // const IndexTableUtils* utils,
-    //         offset,                                                        // const unsigned int startRofId,
-    //         rofs,                                                          // const unsigned int rofSize,
-    //         mVrtParams.phiCut,                                             // const float phiCut,
-    //         mVrtParams.maxTrackletsPerCluster);                            // const size_t maxTrackletsPerCluster = 1e2
-
-    //       gpu::trackleterKernelMultipleRof<TrackletMode::Layer1Layer2><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(2),         // const Cluster* clustersNextLayer,    // 0 2
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),         // const Cluster* clustersCurrentLayer, // 1 1
-    //         mTimeFrameGPU->getDeviceROframesClusters(2),                   // const int* sizeNextLClusters,
-    //         mTimeFrameGPU->getDeviceROframesClusters(1),                   // const int* sizeCurrentLClusters,
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceIndexTables(2),      // const int* nextIndexTables,
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),        // Tracklet* Tracklets,
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1), // int* foundTracklets,
-    //         mTimeFrameGPU->getDeviceIndexTableUtils(),                     // const IndexTableUtils* utils,
-    //         offset,                                                        // const unsigned int startRofId,
-    //         rofs,                                                          // const unsigned int rofSize,
-    //         mVrtParams.phiCut,                                             // const float phiCut,
-    //         mVrtParams.maxTrackletsPerCluster);                            // const size_t maxTrackletsPerCluster = 1e2
-
-    //       gpu::trackletSelectionKernelMultipleRof<true><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),            // const Cluster* clusters0,               // Clusters on layer 0
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),            // const Cluster* clusters1,               // Clusters on layer 1
-    //         mTimeFrameGPU->getDeviceROframesClusters(0),                      // const int* sizeClustersL0,              // Number of clusters on layer 0 per ROF
-    //         mTimeFrameGPU->getDeviceROframesClusters(1),                      // const int* sizeClustersL1,              // Number of clusters on layer 1 per ROF
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),           // Tracklet* tracklets01,                  // Tracklets on layer 0-1
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),           // Tracklet* tracklets12,                  // Tracklets on layer 1-2
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0),    // const int* nFoundTracklets01,           // Number of tracklets found on layers 0-1
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1),    // const int* nFoundTracklet12,            // Number of tracklets found on layers 1-2
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),        // unsigned char* usedTracklets,           // Used tracklets
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceLines(),                // Line* lines,                            // Lines
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),          // int* nFoundLines,                       // Number of found lines
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), // int* nExclusiveFoundLines,              // Number of found lines exclusive scan
-    //         offset,                                                           // const unsigned int startRofId,          // Starting ROF ID
-    //         rofs,                                                             // const unsigned int rofSize,             // Number of ROFs to consider
-    //         mVrtParams.maxTrackletsPerCluster,                                // const int maxTrackletsPerCluster = 1e2, // Maximum number of tracklets per cluster
-    //         mVrtParams.tanLambdaCut,                                          // const float tanLambdaCut = 0.025f,      // Cut on tan lambda
-    //         mVrtParams.phiCut);                                               // const float phiCut = 0.002f)            // Cut on phi
-
-    //       discardResult(cub::DeviceScan::ExclusiveSum(mTimeFrameGPU->getChunk(chunkId).getDeviceCUBTmpBuffer(),
-    //                                                   mTimeFrameGPU->getChunk(chunkId).getTimeFrameGPUParameters()->tmpCUBBufferSize,
-    //                                                   mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),
-    //                                                   mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(),
-    //                                                   mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1),
-    //                                                   mTimeFrameGPU->getStream(chunkId).get()));
-
-    //       // Reset used tracklets
-    //       checkGPUError(cudaMemsetAsync(mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),
-    //                                     false,
-    //                                     sizeof(unsigned char) * mVrtParams.maxTrackletsPerCluster * mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1),
-    //                                     mTimeFrameGPU->getStream(chunkId).get()),
-    //                     __FILE__, __LINE__);
-
-    //       gpu::trackletSelectionKernelMultipleRof<false><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),            // const Cluster* clusters0,               // Clusters on layer 0
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),            // const Cluster* clusters1,               // Clusters on layer 1
-    //         mTimeFrameGPU->getDeviceROframesClusters(0),                      // const int* sizeClustersL0,              // Number of clusters on layer 0 per ROF
-    //         mTimeFrameGPU->getDeviceROframesClusters(1),                      // const int* sizeClustersL1,              // Number of clusters on layer 1 per ROF
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),           // Tracklet* tracklets01,                  // Tracklets on layer 0-1
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),           // Tracklet* tracklets12,                  // Tracklets on layer 1-2
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0),    // const int* nFoundTracklets01,           // Number of tracklets found on layers 0-1
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1),    // const int* nFoundTracklet12,            // Number of tracklets found on layers 1-2
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),        // unsigned char* usedTracklets,           // Used tracklets
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceLines(),                // Line* lines,                            // Lines
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),          // int* nFoundLines,                       // Number of found lines
-    //         mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), // int* nExclusiveFoundLines,              // Number of found lines exclusive scan
-    //         offset,                                                           // const unsigned int startRofId,          // Starting ROF ID
-    //         rofs,                                                             // const unsigned int rofSize,             // Number of ROFs to consider
-    //         mVrtParams.maxTrackletsPerCluster,                                // const int maxTrackletsPerCluster = 1e2, // Maximum number of tracklets per cluster
-    //         mVrtParams.tanLambdaCut,                                          // const float tanLambdaCut = 0.025f,      // Cut on tan lambda
-    //         mVrtParams.phiCut);                                               // const float phiCut = 0.002f)            // Cut on phi
-
-    //       int nClusters = mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1);
-    //       int lastFoundLines;
-    //       std::vector<int> exclusiveFoundLinesHost(nClusters + 1);
-
-    //       // Obtain whole exclusive sum including nCluster+1 element  (nCluster+1)th element is the total number of found lines.
-    //       checkGPUError(cudaMemcpyAsync(exclusiveFoundLinesHost.data(), mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), (nClusters) * sizeof(int), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
-    //       checkGPUError(cudaMemcpyAsync(&lastFoundLines, mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines() + nClusters - 1, sizeof(int), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
-    //       exclusiveFoundLinesHost[nClusters] = exclusiveFoundLinesHost[nClusters - 1] + lastFoundLines;
-
-    //       std::vector<Line> lines(exclusiveFoundLinesHost[nClusters]);
-
-    //       checkGPUError(cudaMemcpyAsync(lines.data(), mTimeFrameGPU->getChunk(chunkId).getDeviceLines(), sizeof(Line) * lines.size(), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
-    //       checkGPUError(cudaStreamSynchronize(mTimeFrameGPU->getStream(chunkId).get()));
-
-    //       // Compute vertices
-    //       std::vector<ClusterLines> clusterLines;
-    //       std::vector<bool> usedLines;
-    //       for (int rofId{0}; rofId < rofs; ++rofId) {
-    //         auto rof = offset + rofId;
-    //         auto clustersL1offsetRof = mTimeFrameGPU->getROframeClusters(1)[rof] - mTimeFrameGPU->getROframeClusters(1)[offset]; // starting cluster offset for this ROF
-    //         auto nClustersL1Rof = mTimeFrameGPU->getROframeClusters(1)[rof + 1] - mTimeFrameGPU->getROframeClusters(1)[rof];     // number of clusters for this ROF
-    //         auto linesOffsetRof = exclusiveFoundLinesHost[clustersL1offsetRof];                                                  // starting line offset for this ROF
-    //         auto nLinesRof = exclusiveFoundLinesHost[clustersL1offsetRof + nClustersL1Rof] - linesOffsetRof;
-    //         gsl::span<const o2::its::Line> linesInRof(lines.data() + linesOffsetRof, static_cast<gsl::span<o2::its::Line>::size_type>(nLinesRof));
-
-    //         usedLines.resize(linesInRof.size(), false);
-    //         usedLines.assign(linesInRof.size(), false);
-    //         clusterLines.clear();
-    //         clusterLines.reserve(nClustersL1Rof);
-    //         computeVerticesInRof(rof,
-    //                              linesInRof,
-    //                              usedLines,
-    //                              clusterLines,
-    //                              mTimeFrameGPU->getBeamXY(),
-    //                              mTimeFrameGPU->getVerticesInChunks()[chunkId],
-    //                              mTimeFrameGPU->getNVerticesInChunks()[chunkId],
-    //                              mTimeFrameGPU,
-    //                              mTimeFrameGPU->hasMCinformation() ? &mTimeFrameGPU->getLabelsInChunks()[chunkId] : nullptr);
-    //       }
-    //       offset += rofs;
-    //     }
-    //   };
-    //   // Do work
-    //   threads[chunkId] = std::thread(doVertexReconstruction);
-    // }
-    // for (auto& thread : threads) {
-    //   thread.join();
-    // }
-    // for (int chunkId{0}; chunkId < mTimeFrameGPU->getNChunks(); ++chunkId) {
-    //   int start{0};
-    //   for (int rofId{0}; rofId < mTimeFrameGPU->getNVerticesInChunks()[chunkId].size(); ++rofId) {
-    //     gsl::span<const Vertex> rofVerts{mTimeFrameGPU->getVerticesInChunks()[chunkId].data() + start, static_cast<gsl::span<Vertex>::size_type>(mTimeFrameGPU->getNVerticesInChunks()[chunkId][rofId])};
-    //     mTimeFrameGPU->addPrimaryVertices(rofVerts);
-    //     if (mTimeFrameGPU->hasMCinformation()) {
-    //       mTimeFrameGPU->getVerticesLabels().emplace_back();
-    //       // TODO: add MC labels
-    //     }
-    //     start += mTimeFrameGPU->getNVerticesInChunks()[chunkId][rofId];
-    //   }
-    // }
-    // mTimeFrameGPU->wipe(3);
-  }
+  // std::vector<std::thread> threads(mTimeFrameGPU->getNChunks());
+  // for (int chunkId{0}; chunkId < mTimeFrameGPU->getNChunks(); ++chunkId) {
+  //   int rofPerChunk{mTimeFrameGPU->mNrof / (int)mTimeFrameGPU->getNChunks()};
+  //   mTimeFrameGPU->getVerticesInChunks()[chunkId].clear();
+  //   mTimeFrameGPU->getNVerticesInChunks()[chunkId].clear();
+  //   mTimeFrameGPU->getLabelsInChunks()[chunkId].clear();
+  //   auto doVertexReconstruction = [&, chunkId, rofPerChunk]() -> void {
+  //     auto offset = chunkId * rofPerChunk;
+  //     auto maxROF = offset + rofPerChunk;
+  //     while (offset < maxROF) {
+  //       auto rofs = mTimeFrameGPU->loadChunkData<gpu::Task::Vertexer>(chunkId, offset, maxROF);
+  //       RANGE("chunk_gpu_vertexing", 1);
+  //       // gpu::GpuTimer timer{offset, mTimeFrameGPU->getStream(chunkId).get()};
+  //       // timer.Start("vtTrackletFinder");
+  //       gpu::trackleterKernelMultipleRof<TrackletMode::Layer0Layer1><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),         // const Cluster* clustersNextLayer,    // 0 2
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),         // const Cluster* clustersCurrentLayer, // 1 1
+  //         mTimeFrameGPU->getDeviceROframesClusters(0),                   // const int* sizeNextLClusters,
+  //         mTimeFrameGPU->getDeviceROframesClusters(1),                   // const int* sizeCurrentLClusters,
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceIndexTables(0),      // const int* nextIndexTables,
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),        // Tracklet* Tracklets,
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0), // int* foundTracklets,
+  //         mTimeFrameGPU->getDeviceIndexTableUtils(),                     // const IndexTableUtils* utils,
+  //         offset,                                                        // const unsigned int startRofId,
+  //         rofs,                                                          // const unsigned int rofSize,
+  //         mVrtParams.phiCut,                                             // const float phiCut,
+  //         mVrtParams.maxTrackletsPerCluster);                            // const size_t maxTrackletsPerCluster = 1e2
+
+  //       gpu::trackleterKernelMultipleRof<TrackletMode::Layer1Layer2><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(2),         // const Cluster* clustersNextLayer,    // 0 2
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),         // const Cluster* clustersCurrentLayer, // 1 1
+  //         mTimeFrameGPU->getDeviceROframesClusters(2),                   // const int* sizeNextLClusters,
+  //         mTimeFrameGPU->getDeviceROframesClusters(1),                   // const int* sizeCurrentLClusters,
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceIndexTables(2),      // const int* nextIndexTables,
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),        // Tracklet* Tracklets,
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1), // int* foundTracklets,
+  //         mTimeFrameGPU->getDeviceIndexTableUtils(),                     // const IndexTableUtils* utils,
+  //         offset,                                                        // const unsigned int startRofId,
+  //         rofs,                                                          // const unsigned int rofSize,
+  //         mVrtParams.phiCut,                                             // const float phiCut,
+  //         mVrtParams.maxTrackletsPerCluster);                            // const size_t maxTrackletsPerCluster = 1e2
+
+  //       gpu::trackletSelectionKernelMultipleRof<true><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),            // const Cluster* clusters0,               // Clusters on layer 0
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),            // const Cluster* clusters1,               // Clusters on layer 1
+  //         mTimeFrameGPU->getDeviceROframesClusters(0),                      // const int* sizeClustersL0,              // Number of clusters on layer 0 per ROF
+  //         mTimeFrameGPU->getDeviceROframesClusters(1),                      // const int* sizeClustersL1,              // Number of clusters on layer 1 per ROF
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),           // Tracklet* tracklets01,                  // Tracklets on layer 0-1
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),           // Tracklet* tracklets12,                  // Tracklets on layer 1-2
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0),    // const int* nFoundTracklets01,           // Number of tracklets found on layers 0-1
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1),    // const int* nFoundTracklet12,            // Number of tracklets found on layers 1-2
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),        // unsigned char* usedTracklets,           // Used tracklets
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceLines(),                // Line* lines,                            // Lines
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),          // int* nFoundLines,                       // Number of found lines
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), // int* nExclusiveFoundLines,              // Number of found lines exclusive scan
+  //         offset,                                                           // const unsigned int startRofId,          // Starting ROF ID
+  //         rofs,                                                             // const unsigned int rofSize,             // Number of ROFs to consider
+  //         mVrtParams.maxTrackletsPerCluster,                                // const int maxTrackletsPerCluster = 1e2, // Maximum number of tracklets per cluster
+  //         mVrtParams.tanLambdaCut,                                          // const float tanLambdaCut = 0.025f,      // Cut on tan lambda
+  //         mVrtParams.phiCut);                                               // const float phiCut = 0.002f)            // Cut on phi
+
+  //       discardResult(cub::DeviceScan::ExclusiveSum(mTimeFrameGPU->getChunk(chunkId).getDeviceCUBTmpBuffer(),
+  //                                                   mTimeFrameGPU->getChunk(chunkId).getTimeFrameGPUParameters()->tmpCUBBufferSize,
+  //                                                   mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),
+  //                                                   mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(),
+  //                                                   mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1),
+  //                                                   mTimeFrameGPU->getStream(chunkId).get()));
+
+  //       // Reset used tracklets
+  //       checkGPUError(cudaMemsetAsync(mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),
+  //                                     false,
+  //                                     sizeof(unsigned char) * mVrtParams.maxTrackletsPerCluster * mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1),
+  //                                     mTimeFrameGPU->getStream(chunkId).get()),
+  //                     __FILE__, __LINE__);
+
+  //       gpu::trackletSelectionKernelMultipleRof<false><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),            // const Cluster* clusters0,               // Clusters on layer 0
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),            // const Cluster* clusters1,               // Clusters on layer 1
+  //         mTimeFrameGPU->getDeviceROframesClusters(0),                      // const int* sizeClustersL0,              // Number of clusters on layer 0 per ROF
+  //         mTimeFrameGPU->getDeviceROframesClusters(1),                      // const int* sizeClustersL1,              // Number of clusters on layer 1 per ROF
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),           // Tracklet* tracklets01,                  // Tracklets on layer 0-1
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),           // Tracklet* tracklets12,                  // Tracklets on layer 1-2
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0),    // const int* nFoundTracklets01,           // Number of tracklets found on layers 0-1
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1),    // const int* nFoundTracklet12,            // Number of tracklets found on layers 1-2
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),        // unsigned char* usedTracklets,           // Used tracklets
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceLines(),                // Line* lines,                            // Lines
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),          // int* nFoundLines,                       // Number of found lines
+  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), // int* nExclusiveFoundLines,              // Number of found lines exclusive scan
+  //         offset,                                                           // const unsigned int startRofId,          // Starting ROF ID
+  //         rofs,                                                             // const unsigned int rofSize,             // Number of ROFs to consider
+  //         mVrtParams.maxTrackletsPerCluster,                                // const int maxTrackletsPerCluster = 1e2, // Maximum number of tracklets per cluster
+  //         mVrtParams.tanLambdaCut,                                          // const float tanLambdaCut = 0.025f,      // Cut on tan lambda
+  //         mVrtParams.phiCut);                                               // const float phiCut = 0.002f)            // Cut on phi
+
+  //       int nClusters = mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1);
+  //       int lastFoundLines;
+  //       std::vector<int> exclusiveFoundLinesHost(nClusters + 1);
+
+  //       // Obtain whole exclusive sum including nCluster+1 element  (nCluster+1)th element is the total number of found lines.
+  //       checkGPUError(cudaMemcpyAsync(exclusiveFoundLinesHost.data(), mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), (nClusters) * sizeof(int), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
+  //       checkGPUError(cudaMemcpyAsync(&lastFoundLines, mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines() + nClusters - 1, sizeof(int), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
+  //       exclusiveFoundLinesHost[nClusters] = exclusiveFoundLinesHost[nClusters - 1] + lastFoundLines;
+
+  //       std::vector<Line> lines(exclusiveFoundLinesHost[nClusters]);
+
+  //       checkGPUError(cudaMemcpyAsync(lines.data(), mTimeFrameGPU->getChunk(chunkId).getDeviceLines(), sizeof(Line) * lines.size(), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
+  //       checkGPUError(cudaStreamSynchronize(mTimeFrameGPU->getStream(chunkId).get()));
+
+  //       // Compute vertices
+  //       std::vector<ClusterLines> clusterLines;
+  //       std::vector<bool> usedLines;
+  //       for (int rofId{0}; rofId < rofs; ++rofId) {
+  //         auto rof = offset + rofId;
+  //         auto clustersL1offsetRof = mTimeFrameGPU->getROframeClusters(1)[rof] - mTimeFrameGPU->getROframeClusters(1)[offset]; // starting cluster offset for this ROF
+  //         auto nClustersL1Rof = mTimeFrameGPU->getROframeClusters(1)[rof + 1] - mTimeFrameGPU->getROframeClusters(1)[rof];     // number of clusters for this ROF
+  //         auto linesOffsetRof = exclusiveFoundLinesHost[clustersL1offsetRof];                                                  // starting line offset for this ROF
+  //         auto nLinesRof = exclusiveFoundLinesHost[clustersL1offsetRof + nClustersL1Rof] - linesOffsetRof;
+  //         gsl::span<const o2::its::Line> linesInRof(lines.data() + linesOffsetRof, static_cast<gsl::span<o2::its::Line>::size_type>(nLinesRof));
+
+  //         usedLines.resize(linesInRof.size(), false);
+  //         usedLines.assign(linesInRof.size(), false);
+  //         clusterLines.clear();
+  //         clusterLines.reserve(nClustersL1Rof);
+  //         computeVerticesInRof(rof,
+  //                              linesInRof,
+  //                              usedLines,
+  //                              clusterLines,
+  //                              mTimeFrameGPU->getBeamXY(),
+  //                              mTimeFrameGPU->getVerticesInChunks()[chunkId],
+  //                              mTimeFrameGPU->getNVerticesInChunks()[chunkId],
+  //                              mTimeFrameGPU,
+  //                              mTimeFrameGPU->hasMCinformation() ? &mTimeFrameGPU->getLabelsInChunks()[chunkId] : nullptr);
+  //       }
+  //       offset += rofs;
+  //     }
+  //   };
+  //   // Do work
+  //   threads[chunkId] = std::thread(doVertexReconstruction);
+  // }
+  // for (auto& thread : threads) {
+  //   thread.join();
+  // }
+  // for (int chunkId{0}; chunkId < mTimeFrameGPU->getNChunks(); ++chunkId) {
+  //   int start{0};
+  //   for (int rofId{0}; rofId < mTimeFrameGPU->getNVerticesInChunks()[chunkId].size(); ++rofId) {
+  //     gsl::span<const Vertex> rofVerts{mTimeFrameGPU->getVerticesInChunks()[chunkId].data() + start, static_cast<gsl::span<Vertex>::size_type>(mTimeFrameGPU->getNVerticesInChunks()[chunkId][rofId])};
+  //     mTimeFrameGPU->addPrimaryVertices(rofVerts);
+  //     if (mTimeFrameGPU->hasMCinformation()) {
+  //       mTimeFrameGPU->getVerticesLabels().emplace_back();
+  //       // TODO: add MC labels
+  //     }
+  //     start += mTimeFrameGPU->getNVerticesInChunks()[chunkId][rofId];
+  //   }
+  // }
+  // mTimeFrameGPU->wipe(3);
+  // }
 }
 
 void VertexerTraitsGPU::computeTrackletMatching(const int iteration)
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
index 2ba4471ef61e5..3aab0624ef556 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
@@ -14,6 +14,7 @@
 #include <cub/cub.cuh>
 
 #include "ITStrackingGPU/VertexingKernels.h"
+#include "GPUCommonHelpers.h"
 
 namespace o2
 {
@@ -21,7 +22,6 @@ namespace its
 {
 using constants::its::VertexerHistogramVolume;
 using constants::math::TwoPi;
-using gpu::utils::checkGPUError;
 using math_utils::getNormalizedPhi;
 using namespace constants::its2;
 
@@ -84,17 +84,6 @@ GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerInde
               getPhiBinIndex(phiRangeMax)};
 }
 
-GPUh() void gpuThrowOnError()
-{
-  cudaError_t error = cudaGetLastError();
-
-  if (error != cudaSuccess) {
-    std::ostringstream errorString{};
-    errorString << GPU_ARCH << " API returned error  [" << cudaGetErrorString(error) << "] (code " << error << ")" << std::endl;
-    throw std::runtime_error{errorString.str()};
-  }
-}
-
 template <typename... Args>
 GPUd() void printOnThread(const unsigned int tId, const char* str, Args... args)
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
index 0b686273a159a..8015f0b20e862 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
@@ -14,16 +14,13 @@ if(HIP_ENABLED)
   set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} -fgpu-rdc")
   o2_add_hipified_library(ITStrackingHIP
                  SOURCES ../cuda/ClusterLinesGPU.cu
-                         ../cuda/Context.cu
                          ../cuda/TimeFrameGPU.cu
-                         ../cuda/TimeFrameChunk.cu
                          ../cuda/Stream.cu
                          ../cuda/TrackerTraitsGPU.cxx
                          ../cuda/TracerGPU.cu
                          ../cuda/TrackingKernels.cu
                          ../cuda/VertexingKernels.cu
                          ../cuda/VertexerTraitsGPU.cxx
-                         ../cuda/Utils.cu
                  PUBLIC_INCLUDE_DIRECTORIES ../
                  PUBLIC_LINK_LIBRARIES O2::ITStracking
                                        O2::GPUTracking
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index 6324b03cb8ca6..da02149fbc432 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -23,8 +23,10 @@
 
 #include "ITStracking/Definitions.h"
 #include "CommonConstants/MathConstants.h"
+
 #include "GPUCommonMath.h"
 #include "GPUCommonDef.h"
+#include "GPUCommonArray.h"
 
 namespace o2
 {
@@ -52,9 +54,9 @@ constexpr int ClustersPerCell{3};
 constexpr int UnusedIndex{-1};
 constexpr float Resolution{0.0005f};
 
-GPUhdi() constexpr GPUArray<float, 3> VertexerHistogramVolume()
+GPUhdi() constexpr o2::gpu::gpustd::array<float, 3> VertexerHistogramVolume()
 {
-  return GPUArray<float, 3>{{1.98, 1.98, 40.f}};
+  return o2::gpu::gpustd::array<float, 3>{{1.98, 1.98, 40.f}};
 }
 } // namespace its
 
@@ -64,27 +66,29 @@ constexpr int LayersNumber{7};
 constexpr int TrackletsPerRoad{LayersNumber - 1};
 constexpr int CellsPerRoad{LayersNumber - 2};
 
-GPUhdi() constexpr GPUArray<float, LayersNumber> LayersZCoordinate()
+GPUhdi() constexpr o2::gpu::gpustd::array<float, LayersNumber> LayersZCoordinate()
 {
   constexpr double s = 1.; // safety margin
-  return GPUArray<float, LayersNumber>{{16.333f + s, 16.333f + s, 16.333f + s, 42.140f + s, 42.140f + s, 73.745f + s, 73.745f + s}};
+  return o2::gpu::gpustd::array<float, LayersNumber>{16.333f + s, 16.333f + s, 16.333f + s, 42.140f + s, 42.140f + s, 73.745f + s, 73.745f + s};
 }
-GPUhdi() constexpr GPUArray<float, LayersNumber> LayersRCoordinate()
+
+GPUhdi() constexpr o2::gpu::gpustd::array<float, LayersNumber> LayersRCoordinate()
 {
-  return GPUArray<float, LayersNumber>{{2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f}};
+  return o2::gpu::gpustd::array<float, LayersNumber>{{2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f}};
 }
 
 constexpr int ZBins{256};
 constexpr int PhiBins{128};
 constexpr float InversePhiBinSize{PhiBins / constants::math::TwoPi};
-GPUhdi() constexpr GPUArray<float, LayersNumber> InverseZBinSize()
+GPUhdi() constexpr o2::gpu::gpustd::array<float, LayersNumber> InverseZBinSize()
 {
   constexpr auto zSize = LayersZCoordinate();
-  return GPUArray<float, LayersNumber>{{0.5f * ZBins / (zSize[0]), 0.5f * ZBins / (zSize[1]), 0.5f * ZBins / (zSize[2]),
-                                        0.5f * ZBins / (zSize[3]), 0.5f * ZBins / (zSize[4]), 0.5f * ZBins / (zSize[5]),
-                                        0.5f * ZBins / (zSize[6])}};
+  return o2::gpu::gpustd::array<float, LayersNumber>{0.5f * ZBins / (zSize[0]), 0.5f * ZBins / (zSize[1]), 0.5f * ZBins / (zSize[2]),
+                                                     0.5f * ZBins / (zSize[3]), 0.5f * ZBins / (zSize[4]), 0.5f * ZBins / (zSize[5]),
+                                                     0.5f * ZBins / (zSize[6])};
 }
-inline float getInverseZCoordinate(const int layerIndex)
+
+GPUhdi() constexpr float getInverseZCoordinate(const int layerIndex)
 {
   return 0.5f * ZBins / LayersZCoordinate()[layerIndex];
 }
@@ -115,7 +119,7 @@ namespace pdgcodes
 constexpr int PionCode{211};
 }
 } // namespace constants
-#ifndef __OPENCL__ /// FIXME: this is for compatibility with OCL
+#ifndef GPUCA_GPUCODE_DEVICE
 typedef std::vector<std::vector<int>> index_table_t;
 #endif
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
index a1d2fa338ba63..59d0e59eb0637 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
@@ -15,15 +15,6 @@
 #ifndef TRACKINGITS_DEFINITIONS_H_
 #define TRACKINGITS_DEFINITIONS_H_
 
-// #define CA_DEBUG
-// #define VTX_DEBUG
-#define __USE_GPU_TRACER__
-
-template <typename T>
-void discardResult(const T&)
-{
-}
-
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <array>
 #endif
@@ -36,103 +27,17 @@ void discardResult(const T&)
   } while (0)
 #endif
 
-#if defined(__CUDA_ARCH__) // ????
-#define TRACKINGITSU_GPU_DEVICE
-#endif
-
 #if defined(__CUDACC__) || defined(__HIPCC__)
-#define MATH_CEIL ceil
-
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <cstddef>
-#endif
-#include "../GPU/ITStrackingGPU/Array.h"
-
-template <typename T, size_t Size>
-using GPUArray = o2::its::gpu::Array<T, Size>;
-
 #ifdef __CUDACC__
-#define GPU_ARCH "CUDA"
-
+#include <cuda_runtime.h>
 typedef cudaStream_t GPUStream;
-inline int getGPUCores(const int major, const int minor)
-{
-  // Defines for GPU Architecture types (using the SM version to determine the # of cores per SM
-  typedef struct
-  {
-    int SM; // 0xMm (hexidecimal notation), M = SM Major version, and m = SM minor version
-    int Cores;
-  } sSMtoCores;
-
-  sSMtoCores nGpuArchCoresPerSM[] =
-    {
-      {0x20, 32},  // Fermi Generation (SM 2.0) GF100 class
-      {0x21, 48},  // Fermi Generation (SM 2.1) GF10x class
-      {0x30, 192}, // Kepler Generation (SM 3.0) GK10x class
-      {0x32, 192}, // Kepler Generation (SM 3.2) GK10x class
-      {0x35, 192}, // Kepler Generation (SM 3.5) GK11x class
-      {0x37, 192}, // Kepler Generation (SM 3.7) GK21x class
-      {0x50, 128}, // Maxwell Generation (SM 5.0) GM10x class
-      {0x52, 128}, // Maxwell Generation (SM 5.2) GM20x class
-      {0x53, 128}, // Maxwell Generation (SM 5.3) GM20x class
-      {0x60, 64},  // Pascal Generation (SM 6.0) GP100 class
-      {0x61, 128}, // Pascal Generation (SM 6.1) GP10x class
-      {0x62, 128}, // Pascal Generation (SM 6.2) GP10x class
-      {0x70, 64},  // Volta Generation (SM 7.0) GV100 class
-      {0x72, 64},  // Volta Generation (SM 7.2) GV10B class
-      {0x75, 64},  // Turing Generation (SM 7.5) TU1xx class
-      {-1, -1}};
-
-  int index = 0;
-
-  while (nGpuArchCoresPerSM[index].SM != -1) {
-    if (nGpuArchCoresPerSM[index].SM == ((major << 4) + minor)) {
-      return nGpuArchCoresPerSM[index].Cores;
-    }
-
-    index++;
-  }
-
-  // If we don't find the values, we default use the previous one to run properly
-  return nGpuArchCoresPerSM[index - 1].Cores;
-}
-inline int getGPUMaxThreadsPerComputingUnit()
-{
-  return 8;
-}
-
 #else // __HIPCC__
-#define GPU_ARCH "HIP"
+#include <hip/hip_runtime.h>
 typedef hipStream_t GPUStream;
-inline int getGPUCores(const int major, const int minor)
-{
-  // Hardcoded result for AMD RADEON WX 9100, to be decided if and how determine this paramter
-  return 4096;
-}
-
-inline int getGPUMaxThreadsPerComputingUnit()
-{
-  return 8;
-}
 #endif
-
 #else
-#define MATH_CEIL std::ceil
-#ifndef __VECTOR_TYPES_H__
-#include "GPUCommonDef.h"
-#endif
-#ifndef __OPENCL__
-#include <cstddef>
-template <typename T, size_t Size>
-using GPUArray = std::array<T, Size>;
-#else
-#include "../GPU/ITStrackingGPU/Array.h"
-template <typename T, size_t Size>
-using GPUArray = o2::its::gpu::Array<T, Size>;
-#endif
-
-typedef struct _dummyStream {
+typedef struct __dummyStream {
 } GPUStream;
 #endif
 
-#endif
+#endif
\ No newline at end of file
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
index 52119048b0ed8..630ad9acf59d2 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
@@ -17,6 +17,8 @@
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/IndexTableUtils.h"
 
+#include "GPUCommonArray.h"
+
 namespace o2
 {
 namespace its
@@ -90,8 +92,8 @@ bool Cluster::operator==(const Cluster& rhs) const
          this->indexTableBinIndex == rhs.indexTableBinIndex;
 }
 
-TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, GPUArray<float, 2>&& posTF,
-                                     GPUArray<float, 3>&& covTF)
+TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, o2::gpu::gpustd::array<float, 2>&& posTF,
+                                     o2::gpu::gpustd::array<float, 3>&& covTF)
   : xCoordinate{x}, yCoordinate{y}, zCoordinate{z}, xTrackingFrame{xTF}, alphaTrackingFrame{alpha}, positionTrackingFrame{posTF}, covarianceTrackingFrame{covTF}
 {
   // Nothing to do

From aacbb84ab5cfdca6231e0d7a7fa2de029e4256cd Mon Sep 17 00:00:00 2001
From: Matteo Concas <mconcas@cern.ch>
Date: Mon, 31 Mar 2025 10:26:55 +0200
Subject: [PATCH 0186/1764] Remove cuda runtime header, apparently unneeded

---
 .../ITSMFT/ITS/tracking/include/ITStracking/Definitions.h    | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
index 59d0e59eb0637..2b0ac3de808fd 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
@@ -29,10 +29,11 @@
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
 #ifdef __CUDACC__
-#include <cuda_runtime.h>
 typedef cudaStream_t GPUStream;
 #else // __HIPCC__
+#ifndef GPUCA_GPUCODE_DEVICE
 #include <hip/hip_runtime.h>
+#endif
 typedef hipStream_t GPUStream;
 #endif
 #else
@@ -40,4 +41,4 @@ typedef struct __dummyStream {
 } GPUStream;
 #endif
 
-#endif
\ No newline at end of file
+#endif

From 720f7c4ae73afd2bcb5845d0c119733c28d5220b Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Mon, 31 Mar 2025 19:37:41 +0200
Subject: [PATCH 0187/1764] Remove separate Stream class abstraction

---
 .../ITS/tracking/GPU/ITStrackingGPU/Stream.h  |  36 ---
 .../GPU/ITStrackingGPU/TimeFrameChunk.h       |   2 -
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |   6 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   |   1 -
 .../ITS/tracking/GPU/cuda/CMakeLists.txt      |   1 -
 .../ITSMFT/ITS/tracking/GPU/cuda/Stream.cu    |  40 ---
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 249 ++++++++++--------
 .../ITS/tracking/GPU/hip/CMakeLists.txt       |   1 -
 .../include/ITStracking/Definitions.h         |  15 --
 9 files changed, 142 insertions(+), 209 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Stream.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/cuda/Stream.cu

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Stream.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Stream.h
deleted file mode 100644
index ba36c29addc73..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Stream.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file Stream.h
-/// \brief
-///
-
-#ifndef ITSTRACKINGGPU_STREAM_H_
-#define ITSTRACKINGGPU_STREAM_H_
-
-#include "ITStracking/Definitions.h"
-
-namespace o2::its::gpu
-{
-
-class Stream final
-{
- public:
-  Stream();
-  ~Stream();
-
-  [[nodiscard]] const GPUStream& get() const;
-
- private:
-  GPUStream mStream;
-};
-} // namespace o2::its::gpu
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
index ac489fc8bfee5..4a028bf12eb40 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
@@ -17,8 +17,6 @@
 #include "ITStracking/TimeFrame.h"
 
 #include "ITStrackingGPU/ClusterLinesGPU.h"
-// #include "ITStrackingGPU/Array.h"
-// #include "ITStrackingGPU/Vector.h"
 #include "ITStrackingGPU/Stream.h"
 
 #include <gsl/gsl>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 1581eea6ce81a..29d2404e98681 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -17,7 +17,6 @@
 #include "ITStracking/Configuration.h"
 
 #include "ITStrackingGPU/ClusterLinesGPU.h"
-#include "ITStrackingGPU/Stream.h"
 #include "ITStrackingGPU/Utils.h"
 
 #include <gsl/gsl>
@@ -28,6 +27,7 @@ namespace its
 {
 namespace gpu
 {
+class Stream;
 
 class DefaultGPUAllocator : public ExternalAllocator
 {
@@ -87,7 +87,7 @@ class TimeFrameGPU : public TimeFrame
   template <Task task>
   Stream& getStream(const size_t stream)
   {
-    return mGpuStreams[stream];
+    return *mGpuStreams[stream];
   }
   void wipe(const int);
 
@@ -199,7 +199,7 @@ class TimeFrameGPU : public TimeFrame
   const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
   // State
-  std::vector<Stream> mGpuStreams;
+  std::vector<Stream*> mGpuStreams;
   size_t mAvailMemGB;
   bool mFirstInit = true;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index 7ed70a4e0fdd9..74c118009d67d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -17,7 +17,6 @@
 #define ITSTRACKINGGPU_UTILS_H_
 
 #include "GPUCommonDef.h"
-#include "Stream.h"
 
 namespace o2
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index 56f6e57e2f305..9769930504f29 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -17,7 +17,6 @@ message(STATUS "Building ITS CUDA tracker")
 # add_compile_definitions(ITS_MEASURE_GPU_TIME)
 o2_add_library(ITStrackingCUDA
                SOURCES ClusterLinesGPU.cu
-                       Stream.cu
                        TrackerTraitsGPU.cxx
                        TimeFrameGPU.cu
                        TracerGPU.cu
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Stream.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Stream.cu
deleted file mode 100644
index 34bc3dc68a7a4..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/Stream.cu
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-
-#include "ITStrackingGPU/Stream.h"
-#include "GPUCommonHelpers.h"
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-
-Stream::Stream()
-{
-  GPUChkErrS(cudaStreamCreate(&mStream));
-}
-
-Stream::~Stream()
-{
-  GPUChkErrS(cudaStreamDestroy(mStream));
-}
-
-const GPUStream& Stream::get() const
-{
-  return mStream;
-}
-
-} // namespace gpu
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 55d523dcc30d0..ee99955ba6669 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -58,6 +58,32 @@ using constants::MB;
 
 namespace gpu
 {
+class Stream final
+{
+ public:
+  Stream();
+  ~Stream();
+
+  [[nodiscard]] const cudaStream_t& get() const;
+
+ private:
+  cudaStream_t mStream;
+};
+
+Stream::Stream()
+{
+  GPUChkErrS(cudaStreamCreate(&mStream));
+}
+
+Stream::~Stream()
+{
+  GPUChkErrS(cudaStreamDestroy(mStream));
+}
+
+const cudaStream_t& Stream::get() const
+{
+  return mStream;
+}
 
 void* DefaultGPUAllocator::allocate(size_t size)
 {
@@ -94,31 +120,31 @@ void TimeFrameGPU<nLayers>::setDevicePropagator(const o2::base::PropagatorImpl<f
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading indextable utils");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading indextable utils");
   if (!iteration) {
     LOGP(debug, "gpu-allocation: allocating IndexTableUtils buffer, for {} MB.", sizeof(IndexTableUtils) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), nullptr, getExtAllocator());
   }
   LOGP(debug, "gpu-transfer: loading IndexTableUtils object, for {} MB.", sizeof(IndexTableUtils) / MB);
-  GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &mIndexTableUtils, sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &mIndexTableUtils, sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading unsorted clusters");
+    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading unsorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} unsorted clusters on layer {}, for {} MB.", mUnsortedClusters[iLayer].size(), iLayer, mUnsortedClusters[iLayer].size() * sizeof(Cluster) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), mUnsortedClusters[iLayer].size() * sizeof(Cluster), nullptr, getExtAllocator());
       GPUChkErrS(cudaHostRegister(mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, getExtAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+    GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
 
@@ -126,17 +152,17 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading sorted clusters");
+    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} clusters on layer {}, for {} MB.", mClusters[iLayer].size(), iLayer, mClusters[iLayer].size() * sizeof(Cluster) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), mClusters[iLayer].size() * sizeof(Cluster), nullptr, getExtAllocator());
       GPUChkErrS(cudaHostRegister(mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, getExtAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+    GPUChkErrS(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
 
@@ -144,15 +170,15 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading sorted clusters");
+    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading clusters indextable for layer {} with {} elements, for {} MB.", iLayer, mIndexTables[iLayer].size(), mIndexTables[iLayer].size() * sizeof(int) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), mIndexTables[iLayer].size() * sizeof(int), nullptr, getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], mIndexTables[iLayer].data(), mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], mIndexTables[iLayer].data(), mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
 
@@ -160,72 +186,72 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating used clusters flags");
+    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating used clusters flags");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: creating {} used clusters flags on layer {}, for {} MB.", mUsedClusters[iLayer].size(), iLayer, mUsedClusters[iLayer].size() * sizeof(unsigned char) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), mUsedClusters[iLayer].size() * sizeof(unsigned char), nullptr, getExtAllocator());
-      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0]->get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadUsedClustersDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading used clusters flags");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading used clusters flags");
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} used clusters flags on layer {}, for {} MB.", mUsedClusters[iLayer].size(), iLayer, mClusters[iLayer].size() * sizeof(unsigned char) / MB);
-    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], mUsedClusters[iLayer].data(), mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], mUsedClusters[iLayer].data(), mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading ROframe clusters");
+    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading ROframe clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} ROframe clusters info on layer {}, for {} MB.", mROFramesClusters[iLayer].size(), iLayer, mROFramesClusters[iLayer].size() * sizeof(int) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), mROFramesClusters[iLayer].size() * sizeof(int), nullptr, getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], mROFramesClusters[iLayer].data(), mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], mROFramesClusters[iLayer].data(), mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+    GPUChkErrS(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading trackingframeinfo");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading trackingframeinfo");
   if (!iteration) {
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} tfinfo on layer {}, for {} MB.", mTrackingFrameInfo[iLayer].size(), iLayer, mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), nullptr, getExtAllocator());
       GPUChkErrS(cudaHostRegister(mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), nullptr, getExtAllocator());
     GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading multiplicity cut mask");
+    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading multiplicity cut mask");
     LOGP(debug, "gpu-transfer: loading multiplicity cut mask with {} elements, for {} MB.", mMultiplicityCutMask.size(), mMultiplicityCutMask.size() * sizeof(bool) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), mMultiplicityCutMask.size() * sizeof(uint8_t), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, mMultiplicityCutMask.data(), mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+    GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, mMultiplicityCutMask.data(), mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
 
@@ -233,39 +259,39 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading seeding vertices");
+    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading seeding vertices");
     LOGP(debug, "gpu-transfer: loading {} ROframes vertices, for {} MB.", mROFramesPV.size(), mROFramesPV.size() * sizeof(int) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), mROFramesPV.size() * sizeof(int), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, mROFramesPV.data(), mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, mROFramesPV.data(), mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     LOGP(debug, "gpu-transfer: loading {} seeding vertices, for {} MB.", mPrimaryVertices.size(), mPrimaryVertices.size() * sizeof(Vertex) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), mPrimaryVertices.size() * sizeof(Vertex), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, mPrimaryVertices.data(), mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+    GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, mPrimaryVertices.data(), mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating tracklets LUTs");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating tracklets LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     if (!iteration) {
       LOGP(debug, "gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {} MB.", mClusters[iLayer].size() + 1, iLayer, (mClusters[iLayer].size() + 1) * sizeof(int) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (mClusters[iLayer].size() + 1) * sizeof(int), nullptr, getExtAllocator());
     }
-    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0]->get()));
   }
   if (!iteration) {
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsBuffers()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells buffers");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells buffers");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     mNTracklets[iLayer] = 0;
     GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost));
@@ -274,26 +300,26 @@ void TimeFrameGPU<nLayers>::createTrackletsBuffers()
   }
   allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), nullptr, getExtAllocator());
   GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  GPUChkErrS(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackletsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading tracklets");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} tracklets on layer {}, for {} MB.", mTracklets[iLayer].size(), iLayer, mTracklets[iLayer].size() * sizeof(Tracklet) / MB);
     GPUChkErrS(cudaHostRegister(mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading tracklets");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {} MB", mTrackletsLookupTable[iLayer].size(), iLayer + 1, mTrackletsLookupTable[iLayer].size() * sizeof(int) / MB);
     GPUChkErrS(cudaHostRegister(mTrackletsLookupTable[iLayer].data(), mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
@@ -301,218 +327,218 @@ void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
   }
   GPUChkErrS(cudaHostRegister(mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells neighbours");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells neighbours");
   // Here we do also the creation of the CellsDeviceArray, as the cells buffers are populated separately in the previous steps.
   allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, getExtAllocator());
   GPUChkErrS(cudaHostRegister(mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0]->get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const unsigned int nCells)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighboursLUT");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighboursLUT");
   LOGP(debug, "gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), nullptr, getExtAllocator()); // We need one element more to move exc -> inc
-  GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0]->get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadCellsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading cell seeds");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading cell seeds");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} cell seeds on layer {}, for {} MB.", mCells[iLayer].size(), iLayer, mCells[iLayer].size() * sizeof(CellSeed) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), mCells[iLayer].size() * sizeof(CellSeed), nullptr, getExtAllocator());
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mCells[iLayer].size() + 1) * sizeof(int), nullptr, getExtAllocator()); // accessory for the neigh. finding.
-    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
-    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], mCells[iLayer].data(), mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], mCells[iLayer].data(), mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
   allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells LUTs");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: creating cell LUT for {} elements on layer {}, for {} MB.", mNTracklets[iLayer] + 1, iLayer, (mNTracklets[iLayer] + 1) * sizeof(int) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0]->get()));
   }
   allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), nullptr, getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  GPUChkErrS(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells buffers");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells buffers");
   mNCells[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost));
   LOGP(debug, "gpu-transfer: creating cell buffer for {} elements on layer {}, for {} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), nullptr, getExtAllocator());
 
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading cells LUTs");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading cells LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading cell LUT for {} elements on layer {}, for {} MB.", mCellsLookupTable[iLayer].size(), iLayer, mCellsLookupTable[iLayer].size() * sizeof(int) / MB);
     GPUChkErrS(cudaHostRegister(mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadRoadsDevice()
 {
   LOGP(debug, "gpu-transfer: loading {} roads, for {} MB.", mRoads.size(), mRoads.size() * sizeof(Road<nLayers - 2>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), mRoads.size() * sizeof(Road<nLayers - 2>), &(mGpuStreams[0]), getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), mRoads.size() * sizeof(Road<nLayers - 2>), mGpuStreams[0], getExtAllocator());
   GPUChkErrS(cudaHostRegister(mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(std::vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading track seeds");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading track seeds");
   LOGP(debug, "gpu-transfer: loading {} track seeds, for {} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), &(mGpuStreams[0]), getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), mGpuStreams[0], getExtAllocator());
   GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, const unsigned int nNeighbours)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), &(mGpuStreams[0]), getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
+  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0], getExtAllocator());
+  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0]->get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), &(mGpuStreams[0]), getExtAllocator());
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), mGpuStreams[0], getExtAllocator());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, std::vector<std::pair<int, int>>& neighbours)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
   mCellsNeighbours[layer].clear();
   mCellsNeighbours[layer].resize(neighbours.size());
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), neighbours.size() * sizeof(gpuPair<int, int>), &(mGpuStreams[0]), getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
+  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0], getExtAllocator());
+  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0]->get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), &(mGpuStreams[0]), getExtAllocator());
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), mGpuStreams[0], getExtAllocator());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDeviceArray()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDeviceArray), (nLayers - 2) * sizeof(int*), &(mGpuStreams[0]), getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], getExtAllocator());
+  GPUChkErrS(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackITSExtDevice(std::vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving tracks");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving tracks");
   mTrackITSExt.clear();
   mTrackITSExt.resize(seeds.size());
   LOGP(debug, "gpu-allocation: reserving {} tracks, for {} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), &(mGpuStreams[0]), getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0].get()));
+  allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0], getExtAllocator());
+  GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0]->get()));
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading cells");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading cells");
   for (int iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading {} cells on layer: {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
     mCells[iLayer].resize(mNCells[iLayer]);
-    GPUChkErrS(cudaMemcpyAsync(mCells[iLayer].data(), mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCells[iLayer].data(), mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading cell luts");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading cell luts");
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading cells lut on layer {} for {} elements", iLayer, (mNTracklets[iLayer + 1] + 1));
     mCellsLookupTable[iLayer].resize(mNTracklets[iLayer + 1] + 1);
-    GPUChkErrS(cudaMemcpyAsync(mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<std::vector<std::pair<int, int>>>& neighbours, const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), fmt::format("downloading neighbours from layer {}", layer));
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), fmt::format("downloading neighbours from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading {} neighbours, for {} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / MB);
   // TODO: something less dangerous than assuming the same memory layout of std::pair and gpuPair... or not? :)
-  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(std::vector<int>& lut, const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), fmt::format("downloading neighbours LUT from layer {}", layer));
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), fmt::format("downloading neighbours LUT from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {} MB.", lut.size(), layer, lut.size() * sizeof(int) / MB);
-  GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(std::vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading tracks");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading tracks");
   LOGP(debug, "gpu-transfer: downloading {} tracks, for {} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / MB);
-  GPUChkErrS(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
   GPUChkErrS(cudaHostUnregister(mTrackITSExt.data()));
   GPUChkErrS(cudaHostUnregister(seeds.data()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterRest()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "unregistering rest of the host memory");
+  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "unregistering rest of the host memory");
   LOGP(debug, "unregistering rest of the host memory...");
   GPUChkErrS(cudaHostUnregister(mCellsDevice.data()));
   GPUChkErrS(cudaHostUnregister(mTrackletsDevice.data()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
 template <int nLayers>
@@ -536,6 +562,9 @@ void TimeFrameGPU<nLayers>::initialise(const int iteration,
                                        const TimeFrameGPUParameters* gpuParam)
 {
   mGpuStreams.resize(mGpuParams.nTimeFrameChunks);
+  for (auto& str : mGpuStreams) {
+    str = new Stream();
+  }
   o2::its::TimeFrame::initialise(iteration, trkParam, maxLayers);
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
index 8015f0b20e862..cc43b6845a714 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
@@ -15,7 +15,6 @@ if(HIP_ENABLED)
   o2_add_hipified_library(ITStrackingHIP
                  SOURCES ../cuda/ClusterLinesGPU.cu
                          ../cuda/TimeFrameGPU.cu
-                         ../cuda/Stream.cu
                          ../cuda/TrackerTraitsGPU.cxx
                          ../cuda/TracerGPU.cu
                          ../cuda/TrackingKernels.cu
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
index 2b0ac3de808fd..352e13963b6d1 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
@@ -26,19 +26,4 @@
   do {                 \
   } while (0)
 #endif
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-#ifdef __CUDACC__
-typedef cudaStream_t GPUStream;
-#else // __HIPCC__
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <hip/hip_runtime.h>
-#endif
-typedef hipStream_t GPUStream;
-#endif
-#else
-typedef struct __dummyStream {
-} GPUStream;
-#endif
-
 #endif

From e5623362507163cc93a85874ea954ac1cb7e878b Mon Sep 17 00:00:00 2001
From: Artur Furs <9881239+afurs@users.noreply.github.com>
Date: Wed, 2 Apr 2025 14:41:51 +0300
Subject: [PATCH 0188/1764] [AFIT-112]: FT0's reco update, 3 new event bits
 (#14123)

* [AFIT-112]: FT0's reco update, 3 new event bits

* [AFIT-112]: minor optimization

* AFIT-112: hotfix

AFIT-112: hotfix

AFIT-112: hotfix

* AFIT-112: hotfix

* RecPoints: accessor for tech word
---
 .../FT0/include/DataFormatsFT0/RecPoints.h    | 93 +++++++++++++++----
 .../common/include/DataFormatsFIT/Triggers.h  | 10 ++
 .../src/CollisionTimeRecoTask.cxx             | 21 ++++-
 3 files changed, 101 insertions(+), 23 deletions(-)

diff --git a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h
index d688e076489b5..0503e4f39948f 100644
--- a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h
+++ b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/RecPoints.h
@@ -24,7 +24,9 @@
 #include "Rtypes.h"
 #include <TObject.h>
 #include <gsl/span>
-
+#include <string>
+#include <utility>
+#include <map>
 namespace o2
 {
 namespace ft0
@@ -32,10 +34,10 @@ namespace ft0
 
 struct ChannelDataFloat {
 
-  int ChId = -1;           //channel Id
-  int ChainQTC = -1;       //QTC chain
-  float CFDTime = -20000;  //time in ps, 0 at the LHC clk center
-  float QTCAmpl = -20000;  // Amplitude mV
+  int ChId = -1;          // channel Id
+  int ChainQTC = -1;      // QTC chain
+  float CFDTime = -20000; // time in ps, 0 at the LHC clk center
+  float QTCAmpl = -20000; // Amplitude mV
 
   ChannelDataFloat() = default;
   ChannelDataFloat(int iPmt, float time, float charge, int chainQTC)
@@ -56,10 +58,39 @@ class RecPoints
 {
 
  public:
-  enum : int { TimeMean,
-               TimeA,
-               TimeC,
-               Vertex };
+  enum ETimeType { kTimeMean,
+                   kTimeA,
+                   kTimeC,
+                   kTimeVertex };
+
+  // Enum for trigger nits specified in rec-points and AOD data
+  enum ETriggerBits { kOrA = 0,           // OrA time-trigger signal
+                      kOrC = 1,           // OrC time-trigger signal
+                      kSemiCentral = 2,   // Semi-central amplitude-trigger signal
+                      kCentral = 3,       // Central amplitude-trigger signal
+                      kVertex = 4,        // Vertex time-trigger signal
+                      kIsActiveSideA = 5, // Side-A has at least one channel active
+                      kIsActiveSideC = 6, // Side-C has at least one channel active
+                      kIsFlangeEvent = 7  // Flange event at Side-C, at least one channel has time which corresponds to -82 cm area
+  };
+  static const inline std::map<unsigned int, std::string> sMapTriggerBits = {
+    {ETriggerBits::kOrA, "OrA"},
+    {ETriggerBits::kOrC, "OrC"},
+    {ETriggerBits::kSemiCentral, "Semicentral"},
+    {ETriggerBits::kCentral, "Central"},
+    {ETriggerBits::kVertex, "Vertex"},
+    {ETriggerBits::kIsActiveSideA, "IsActiveSideA"},
+    {ETriggerBits::kIsActiveSideC, "IsActiveSideC"},
+    {ETriggerBits::kIsFlangeEvent, "IsFlangeEvent"}};
+
+  enum ETechnicalBits { kLaser = 0,             // indicates the laser was triggered in this BC
+                        kOutputsAreBlocked = 1, // indicates that laser-induced pulses should arrive from detector to FEE in this BC (and trigger outputs are blocked)
+                        kDataIsValid = 2,       // data is valid for processing
+  };
+  static const inline std::map<unsigned int, std::string> sMapTechnicalBits = {
+    {ETechnicalBits::kLaser, "Laser"},
+    {ETechnicalBits::kOutputsAreBlocked, "OutputsAreBlocked"},
+    {ETechnicalBits::kDataIsValid, "DataIsValid"}};
 
   o2::dataformats::RangeReference<int, int> ref;
   o2::InteractionRecord mIntRecord; // Interaction record (orbit, bc)
@@ -73,25 +104,41 @@ class RecPoints
     mIntRecord = iRec;
     mTriggers = chTrig;
   }
+  RecPoints(int chDataFirstEntryPos,
+            int chDataNEntries,
+            const o2::InteractionRecord& ir,
+            const std::array<short, 4>& arrTimes,
+            const o2::fit::Triggers& digitTriggers,
+            uint8_t extraTriggerWord) : mIntRecord(ir), mCollisionTime(arrTimes), mTriggers(digitTriggers)
+  {
+    ref.setFirstEntry(chDataFirstEntryPos);
+    ref.setEntries(chDataNEntries);
+    initRecPointTriggers(digitTriggers, extraTriggerWord);
+  }
+
   ~RecPoints() = default;
 
   short getCollisionTime(int side) const { return mCollisionTime[side]; }
-  short getCollisionTimeMean() const { return getCollisionTime(TimeMean); }
-  short getCollisionTimeA() const { return getCollisionTime(TimeA); }
-  short getCollisionTimeC() const { return getCollisionTime(TimeC); }
+  short getCollisionTimeMean() const { return getCollisionTime(kTimeMean); }
+  short getCollisionTimeA() const { return getCollisionTime(kTimeA); }
+  short getCollisionTimeC() const { return getCollisionTime(kTimeC); }
   bool isValidTime(int side) const { return getCollisionTime(side) < o2::InteractionRecord::DummyTime; }
   void setCollisionTime(short time, int side) { mCollisionTime[side] = time; }
 
-  short getVertex() const { return getCollisionTime(Vertex); }
-  void setVertex(short vertex) { mCollisionTime[Vertex] = vertex; }
+  short getVertex() const { return getCollisionTime(kTimeVertex); }
+  void setVertex(short vertex) { mCollisionTime[kTimeVertex] = vertex; }
 
   o2::fit::Triggers getTrigger() const { return mTriggers; }
   void setTriggers(o2::fit::Triggers trig) { mTriggers = trig; }
+  uint8_t getTechnicalWord() const { return mTechnicalWord; }
+  static constexpr uint8_t makeExtraTrgWord(bool isActiveA = true, bool isActiveC = true, bool isFlangeEvent = true)
+  {
+    return (static_cast<uint8_t>(isActiveA) << kIsActiveSideA) |
+           (static_cast<uint8_t>(isActiveC) << kIsActiveSideC) |
+           (static_cast<uint8_t>(isFlangeEvent) << kIsFlangeEvent);
+  }
 
   o2::InteractionRecord getInteractionRecord() const { return mIntRecord; };
-
-  // void SetMgrEventTime(Double_t time) { mTimeStamp = time; }
-
   gsl::span<const ChannelDataFloat> getBunchChannelData(const gsl::span<const ChannelDataFloat> tfdata) const;
   short static constexpr sDummyCollissionTime = 32767;
 
@@ -99,13 +146,21 @@ class RecPoints
   bool operator==(const RecPoints&) const = default;
 
  private:
+  void initRecPointTriggers(const o2::fit::Triggers& digitTriggers, uint8_t extraTrgWord = 0)
+  {
+    const auto digitTriggerWord = digitTriggers.getTriggersignals();
+    const auto trgAndTechWordPair = o2::fit::Triggers::parseDigitTriggerWord(digitTriggerWord, true);
+    mTriggers.setTriggers(trgAndTechWordPair.first | extraTrgWord);
+    mTechnicalWord = trgAndTechWordPair.second;
+  }
+
   std::array<short, 4> mCollisionTime = {sDummyCollissionTime,
                                          sDummyCollissionTime,
                                          sDummyCollissionTime,
                                          sDummyCollissionTime};
   o2::fit::Triggers mTriggers; // pattern of triggers  in this BC
-
-  ClassDefNV(RecPoints, 3);
+  uint8_t mTechnicalWord{0};   // field for keeping ETechnicalBits
+  ClassDefNV(RecPoints, 4);
 };
 } // namespace ft0
 } // namespace o2
diff --git a/DataFormats/Detectors/FIT/common/include/DataFormatsFIT/Triggers.h b/DataFormats/Detectors/FIT/common/include/DataFormatsFIT/Triggers.h
index 6a0eee027498e..a660d77820207 100644
--- a/DataFormats/Detectors/FIT/common/include/DataFormatsFIT/Triggers.h
+++ b/DataFormats/Detectors/FIT/common/include/DataFormatsFIT/Triggers.h
@@ -70,6 +70,12 @@ class Triggers
   {
     return trgWord | (static_cast<uint64_t>(checkMinBiasFT0(trgWord)) << bitMinBias);
   }
+  static constexpr std::pair<uint8_t, uint8_t> parseDigitTriggerWord(uint8_t digitWord, bool shiftTechBitsToBegin = false)
+  {
+    const uint8_t techWordMask = word(bitLaser, bitOutputsAreBlocked, bitDataIsValid);
+    const uint8_t shiftTechWordPos = shiftTechBitsToBegin ? bitLaser : 0;
+    return {(digitWord & (~techWordMask)), (digitWord & techWordMask) >> shiftTechWordPos};
+  }
 
   bool getOrA() const { return (triggersignals & (1 << bitA)) != 0; }
   bool getOrC() const { return (triggersignals & (1 << bitC)) != 0; }               // only used by FT0/FDD (same bit as OrAOut in FV0)
@@ -104,6 +110,10 @@ class Triggers
     timeA = atimeA;
     timeC = atimeC;
   }
+  void setTriggers(uint8_t trgsig)
+  {
+    triggersignals = trgsig;
+  }
 
   void setTriggers(Bool_t isA, Bool_t isC, Bool_t isVrtx, Bool_t isCnt, Bool_t isSCnt, uint8_t chanA, uint8_t chanC, int32_t aamplA,
                    int32_t aamplC, int16_t atimeA, int16_t atimeC, Bool_t isLaser, Bool_t isOutputsAreBlocked, Bool_t isDataValid)
diff --git a/Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx b/Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx
index 2610131ff51a7..7363cef57cf31 100644
--- a/Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx
+++ b/Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx
@@ -58,6 +58,10 @@ RP CollisionTimeRecoTask::processDigit(const o2::ft0::Digit& digit,
   constexpr int nMCPsA = 4 * Geometry::NCellsA;
 
   int nch{0};
+  bool isActiveA = false;
+  bool isActiveC = false;
+  bool isFlangeEvent = false;
+
   for (const auto& channelData : inChData) {
     if (channelData.ChId >= NCHANNELS) {
       // Reference channels shouldn't participate in reco at all!
@@ -68,15 +72,23 @@ RP CollisionTimeRecoTask::processDigit(const o2::ft0::Digit& digit,
       outChData.emplace_back(channelData.ChId, timeInPS, (float)channelData.QTCAmpl, channelData.ChainQTC);
       nch++;
     }
+    const bool isOkForTimeCalc = TimeFilterParam::Instance().checkAll(channelData);
     //  only signals which satisfy conditions may participate in time calculation
-    if (TimeFilterParam::Instance().checkAll(channelData)) {
-      if (channelData.ChId < nMCPsA) {
+    if (channelData.ChId < nMCPsA) {
+      // A-side
+      if (isOkForTimeCalc) {
         sideAtime += timeInPS;
         ndigitsA++;
-      } else {
+      }
+      isActiveA = true;
+    } else {
+      // C-side
+      if (isOkForTimeCalc) {
         sideCtime += timeInPS;
         ndigitsC++;
       }
+      isActiveC = true;
+      isFlangeEvent |= channelData.CFDTime < -350 && channelData.CFDTime > -450;
     }
   }
   std::array<short, 4> mCollisionTime = {RP::sDummyCollissionTime, RP::sDummyCollissionTime, RP::sDummyCollissionTime, RP::sDummyCollissionTime};
@@ -90,7 +102,8 @@ RP CollisionTimeRecoTask::processDigit(const o2::ft0::Digit& digit,
   } else {
     mCollisionTime[TimeMean] = std::min(mCollisionTime[TimeA], mCollisionTime[TimeC]);
   }
-  return RecPoints{mCollisionTime, firstEntry, nch, digit.mIntRecord, digit.mTriggers};
+  const uint8_t extraTrgWord = RecPoints::makeExtraTrgWord(isActiveA, isActiveC, isFlangeEvent);
+  return RecPoints(firstEntry, nch, digit.mIntRecord, mCollisionTime, digit.mTriggers, extraTrgWord);
 }
 //______________________________________________________
 void CollisionTimeRecoTask::FinishTask()

From c3f439d22f5a6cd34ff2252d7e2c8dc014d1c5e8 Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Thu, 3 Apr 2025 11:20:30 +0200
Subject: [PATCH 0189/1764] DPL: avoid expensive find_if for check of
 AVAILABLE_MANAGED_SHM metric when sending metrics (#14138)

---
 .../Core/include/Framework/DataProcessingStats.h    |  2 ++
 Framework/Core/src/CommonServices.cxx               | 13 +++++++------
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/Framework/Core/include/Framework/DataProcessingStats.h b/Framework/Core/include/Framework/DataProcessingStats.h
index ec96bf8e9973c..d42f9a9d26610 100644
--- a/Framework/Core/include/Framework/DataProcessingStats.h
+++ b/Framework/Core/include/Framework/DataProcessingStats.h
@@ -189,6 +189,8 @@ struct DataProcessingStats {
   std::array<MetricSpec, MAX_METRICS> metricSpecs = {};
   std::array<int64_t, MAX_METRICS> lastPublishedMetrics = {};
   std::vector<int> availableMetrics;
+  // for fast check for AVAILABLE_MANAGED_SHM metric which is only provided for readout-proxy
+  bool hasAvailSHMMetric = false;
   // How many commands have been committed to the queue.
   std::atomic<int> insertedCmds = 0;
   // The insertion point for the next command.
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index cc3c920bc7be1..e13f1cb2094b7 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -764,11 +764,8 @@ auto sendRelayerMetrics(ServiceRegistryRef registry, DataProcessingStats& stats)
   using namespace fair::mq::shmem;
   auto& spec = registry.get<DeviceSpec const>();
 
-  auto hasMetric = [&runningWorkflow](const DataProcessingStats::MetricSpec& metric) -> bool {
-    return metric.metricId == static_cast<int>(ProcessingStatsId::AVAILABLE_MANAGED_SHM_BASE) + (runningWorkflow.shmSegmentId % 512);
-  };
   // FIXME: Ugly, but we do it only every 5 seconds...
-  if (std::find_if(stats.metricSpecs.begin(), stats.metricSpecs.end(), hasMetric) != stats.metricSpecs.end()) {
+  if (stats.hasAvailSHMMetric) {
     auto device = registry.get<RawDeviceService>().device();
     long freeMemory = -1;
     try {
@@ -1104,8 +1101,12 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
                    .sendInitialValue = true}};
 
       for (auto& metric : metrics) {
-        if (metric.metricId == (int)ProcessingStatsId::AVAILABLE_MANAGED_SHM_BASE + (runningWorkflow.shmSegmentId % 512) && spec.name.compare("readout-proxy") != 0) {
-          continue;
+        if (metric.metricId == (int)ProcessingStatsId::AVAILABLE_MANAGED_SHM_BASE + (runningWorkflow.shmSegmentId % 512)) {
+          if (spec.name.compare("readout-proxy") == 0) {
+            stats->hasAvailSHMMetric = true;
+          } else {
+            continue;
+          }
         }
         stats->registerMetric(metric);
       }

From a3163d2430e48a267443ff9f2ee274b80bce49d0 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 3 Apr 2025 11:24:26 +0200
Subject: [PATCH 0190/1764] DPL: Improve debug message for missing runNumber.
 (#14136)

---
 Framework/Core/src/ExternalFairMQDeviceProxy.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index 52e0413d48dab..449beb0cb8c0b 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -528,7 +528,9 @@ InjectorFunction dplModelAdaptor(std::vector<OutputSpec> const& filterSpecs, DPL
       timingInfo.tfCounter = dh->tfCounter;
       LOG(debug) << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();
       if (dh->runNumber == 0 || dh->tfCounter == 0 || (fmqRunNumber > 0 && fmqRunNumber != dh->runNumber)) {
-        LOG(error) << "INVALID runNumber / tfCounter: runNumber " << dh->runNumber << ", tfCounter " << dh->tfCounter << ", FMQ runNumber " << fmqRunNumber;
+        LOG(error) << "INVALID runNumber / tfCounter: runNumber " << dh->runNumber
+                   << ", tfCounter " << dh->tfCounter << ", FMQ runNumber " << fmqRunNumber
+                   << " for msgidx " << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();
       }
 
       OutputSpec query{dh->dataOrigin, dh->dataDescription, dh->subSpecification};

From 75153a01bd4aad4524bdc759e78ff493ff73160d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 3 Apr 2025 11:24:58 +0200
Subject: [PATCH 0191/1764] DPL: attempt at adding the run number to timers and
 enumerations (#14135)

---
 Framework/Core/src/LifetimeHelpers.cxx | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Framework/Core/src/LifetimeHelpers.cxx b/Framework/Core/src/LifetimeHelpers.cxx
index 657bdcb40326b..4621738ec154e 100644
--- a/Framework/Core/src/LifetimeHelpers.cxx
+++ b/Framework/Core/src/LifetimeHelpers.cxx
@@ -25,6 +25,7 @@
 #include "Framework/FairMQDeviceProxy.h"
 #include "Framework/Formatters.h"
 #include "Framework/DeviceState.h"
+#include "Framework/DataTakingContext.h"
 #include "Framework/Signpost.h"
 
 #include "Headers/DataHeader.h"
@@ -421,6 +422,11 @@ ExpirationHandler::Handler LifetimeHelpers::enumerate(ConcreteDataMatcher const&
     dh.payloadSize = sizeof(counter_t);
     dh.payloadSerializationMethod = gSerializationMethodNone;
     dh.tfCounter = timestamp;
+    try {
+      dh.runNumber = atoi(services.get<DataTakingContext>().runNumber.c_str());
+    } catch (...) {
+      dh.runNumber = 0;
+    }
     dh.firstTForbit = timestamp * orbitMultiplier + orbitOffset;
     DataProcessingHeader dph{timestamp, 1};
     services.get<CallbackService>().call<CallbackService::Id::NewTimeslice>(dh, dph);

From 1a486e94dc3122aa51266c4ac0f78c7bc6cb2152 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 2 Apr 2025 10:40:30 +0200
Subject: [PATCH 0192/1764] Common: DCAFitter fix collinear not touching calc

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Common/DCAFitter/include/DCAFitter/HelixHelper.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Common/DCAFitter/include/DCAFitter/HelixHelper.h b/Common/DCAFitter/include/DCAFitter/HelixHelper.h
index 62ef0bbebdac7..bd710e459ac54 100644
--- a/Common/DCAFitter/include/DCAFitter/HelixHelper.h
+++ b/Common/DCAFitter/include/DCAFitter/HelixHelper.h
@@ -131,9 +131,9 @@ struct CrossInfo {
     if (isCollinear) {
       /// for collinear tracks it is better to take
       /// a weighted average of the crossing points as a radius
-      float r2r = trcA.rC + o2::gpu::GPUCommonMath::Sqrt(rBSign);
+      float r2r = trcA.rC + rBSign;
       float r1_r = trcA.rC / r2r;
-      float r2_r = o2::gpu::GPUCommonMath::Sqrt(rBSign) / r2r;
+      float r2_r = rBSign / r2r;
       xDCA[0] = r2_r * trcA.xC + r1_r * (xDist + trcA.xC);
       yDCA[0] = r2_r * trcA.yC + r1_r * (yDist + trcA.yC);
     } else {

From 239eeaa1b5ad5ae9df3ec8b804f6594cb916fc38 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 21 Mar 2025 22:54:43 +0100
Subject: [PATCH 0193/1764] AOD: save selected TPC standalone tracks from
 thinning

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../AODProducerWorkflowSpec.h                 |  3 +++
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 19 +++++++++++++++++++
 2 files changed, 22 insertions(+)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 959aed28cab6b..1f82eaf34c473 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -239,6 +239,9 @@ class AODProducerWorkflowDPL : public Task
   bool mPropMuons{false};
   float mTrackQCFraction{0.00};
   int64_t mTrackQCNTrCut{4};
+  float mTrackQCDCAxy{3.};
+  float mTrackQCPt{0.2};
+  int mTrackQCNCls{80};
   float mSqrtS{13860.};
   std::mt19937 mGenerator{}; ///< random generator for trackQA sampling
   o2::base::Propagator::MatCorrType mMatCorr{o2::base::Propagator::MatCorrType::USEMatCorrLUT};
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index c12b614960554..8532107d57035 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -512,6 +512,19 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
             }
           }
 
+          // include specific selection of tpc standalone tracks if thinning is active
+          if (mThinTracks && extraInfoHolder.isTPConly && !writeQAData) { // if trackQA is written then no check has to be done
+            auto trk = data.getTPCTrack(trackIndex);
+            if (trk.getNClusters() >= mTrackQCNCls && trk.getPt() >= mTrackQCPt) {
+              o2::dataformats::DCA dcaInfo{999.f, 999.f, 999.f, 999.f, 999.f};
+              o2::dataformats::VertexBase v = mVtx.getMeanVertex(collisionID < 0 ? 0.f : data.getPrimaryVertex(collisionID).getZ());
+              if (o2::base::Propagator::Instance()->propagateToDCABxByBz(v, trk, 2., mMatCorr, &dcaInfo) && std::abs(dcaInfo.getY()) < mTrackQCDCAxy) {
+                writeQAData = true; // just setting this to not thin the track
+              }
+            }
+          }
+
+          // Skip thinning if not enabled or track is not tpc standalone or assoc. to a V0 or qa'ed
           if (mThinTracks && src == GIndex::Source::TPC && mGIDUsedBySVtx.find(trackIndex) == mGIDUsedBySVtx.end() && mGIDUsedByStr.find(trackIndex) == mGIDUsedByStr.end() && !writeQAData) {
             mGIDToTableID.emplace(trackIndex, -1); // pretend skipped tracks are stored; this is safe since they are are not written to disk and -1 indicates to all users to not use this track
             continue;
@@ -1683,6 +1696,9 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
   }
   mTrackQCFraction = ic.options().get<float>("trackqc-fraction");
   mTrackQCNTrCut = ic.options().get<int64_t>("trackqc-NTrCut");
+  mTrackQCDCAxy = ic.options().get<float>("trackqc-tpc-dca");
+  mTrackQCPt = ic.options().get<float>("trackqc-tpc-pt");
+  mTrackQCNCls = ic.options().get<int>("trackqc-tpc-cls");
   if (auto seed = ic.options().get<int>("seed"); seed == 0) {
     LOGP(info, "Using random device for seeding");
     std::random_device rd;
@@ -3237,6 +3253,9 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"thin-tracks", VariantType::Bool, false, {"Produce thinned track tables"}},
       ConfigParamSpec{"trackqc-fraction", VariantType::Float, float(0.1), {"Fraction of tracks to QC"}},
       ConfigParamSpec{"trackqc-NTrCut", VariantType::Int64, 4L, {"Minimal length of the track - in amount of tracklets"}},
+      ConfigParamSpec{"trackqc-tpc-dca", VariantType::Float, 3.f, {"Keep TPC standalone track with this DCAxy to the PV"}},
+      ConfigParamSpec{"trackqc-tpc-cls", VariantType::Int, 80, {"Keep TPC standalone track with this #clusters"}},
+      ConfigParamSpec{"trackqc-tpc-pt", VariantType::Float, 0.2f, {"Keep TPC standalone track with this pt"}},
       ConfigParamSpec{"with-streamers", VariantType::String, "", {"Bit-mask to steer writing of intermediate streamer files"}},
       ConfigParamSpec{"seed", VariantType::Int, 0, {"Set seed for random generator used for sampling (0 (default) means using a random_device)"}},
     }};

From d8b8f6cfd4908bcfe7d8e5136d30d3ee43103e43 Mon Sep 17 00:00:00 2001
From: Francesco Mazzaschi <fmazzasc@alipap1.cern.ch>
Date: Tue, 1 Apr 2025 18:27:58 +0200
Subject: [PATCH 0194/1764] [Strangeness Tracker] Use meaningful matching chi2
 calculation

---
 .../include/StrangenessTracking/StrangenessTracker.h          | 1 +
 .../Vertexing/StrangenessTracking/src/StrangenessTracker.cxx  | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h b/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
index 302b1de201ab1..9ca34e548f1c8 100644
--- a/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
+++ b/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
@@ -321,6 +321,7 @@ class StrangenessTracker
  protected:
   bool mMCTruthON = false;                             /// flag availability of MC truth
   int mNThreads = 1;                                   /// number of threads (externally driven)
+  float mGlobalChi2 = -1;                              /// global topology matching chi2
   gsl::span<const TrackITS> mInputITStracks;           // input ITS tracks
   std::vector<VBracket> mITSvtxBrackets;               // time brackets for ITS tracks
   std::vector<int> mTracksIdxTable;                    // index table for ITS tracks
diff --git a/Detectors/Vertexing/StrangenessTracking/src/StrangenessTracker.cxx b/Detectors/Vertexing/StrangenessTracking/src/StrangenessTracker.cxx
index 720ef4c9d5d87..c8a62fa76e3ed 100644
--- a/Detectors/Vertexing/StrangenessTracking/src/StrangenessTracker.cxx
+++ b/Detectors/Vertexing/StrangenessTracking/src/StrangenessTracker.cxx
@@ -345,7 +345,6 @@ bool StrangenessTracker::matchDecayToITStrack(float decayR, StrangeTrack& strang
   auto trackClusters = getTrackClusters(itsTrack);
   auto trackClusSizes = getTrackClusterSizes(itsTrack);
   auto& lastClus = trackClusters[0];
-  strangeTrack.mMatchChi2 = getMatchingChi2(strangeTrack.mMother, itsTrack);
 
   auto radTol = decayR < 4 ? mStrParams->mRadiusTolIB : mStrParams->mRadiusTolOB;
   auto nMinClusMother = trackClusters.size() < 4 ? 2 : mStrParams->mMinMotherClus;
@@ -413,11 +412,13 @@ bool StrangenessTracker::matchDecayToITStrack(float decayR, StrangeTrack& strang
 
   std::reverse(motherClusters.begin(), motherClusters.end());
 
+  mGlobalChi2 = -1;
   for (auto& clus : motherClusters) {
     if (!updateTrack(clus, motherTrackClone)) {
       break;
     }
   }
+  strangeTrack.mMatchChi2 = mGlobalChi2;
 
   LOG(debug) << "Inward-outward refit finished, starting final topology refit";
   // final Topology refit
@@ -517,6 +518,7 @@ bool StrangenessTracker::updateTrack(const ITSCluster& clus, o2::track::TrackPar
     return false;
   }
 
+  mGlobalChi2 += chi2;
   return true;
 }
 

From 9a6abee09fbe2ed670fdd9eac6433c7e6630e1c8 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 4 Apr 2025 15:11:50 +0200
Subject: [PATCH 0195/1764] ITSMFT: add asString() for clusters (#14130)

Allows to get formatted string of clusters.

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/DataFormatsITSMFT/CompCluster.h      |  4 +++-
 .../Detectors/ITSMFT/common/src/CompCluster.cxx  | 16 +++++++++++++---
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/CompCluster.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/CompCluster.h
index 18acc82e72239..361544798dc80 100644
--- a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/CompCluster.h
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/CompCluster.h
@@ -88,6 +88,7 @@ class CompCluster
   }
 
   void print() const;
+  std::string asString() const;
 
   ClassDefNV(CompCluster, 2);
 };
@@ -97,7 +98,7 @@ class CompCluster
 class CompClusterExt : public CompCluster
 {
  private:
-  UShort_t mChipID;  ///< chip id
+  UShort_t mChipID; ///< chip id
 
  public:
   CompClusterExt(UShort_t row = 0, UShort_t col = 0, UShort_t patt = 0, UShort_t chipID = 0) : CompCluster(row, col, patt), mChipID(chipID)
@@ -116,6 +117,7 @@ class CompClusterExt : public CompCluster
   void setChipID(UShort_t c) { mChipID = c; }
 
   void print() const;
+  std::string asString() const;
 
   ClassDefNV(CompClusterExt, 1);
 };
diff --git a/DataFormats/Detectors/ITSMFT/common/src/CompCluster.cxx b/DataFormats/Detectors/ITSMFT/common/src/CompCluster.cxx
index 95ecd73f6e9d5..1f4be3163b3d2 100644
--- a/DataFormats/Detectors/ITSMFT/common/src/CompCluster.cxx
+++ b/DataFormats/Detectors/ITSMFT/common/src/CompCluster.cxx
@@ -15,22 +15,32 @@
 #include "DataFormatsITSMFT/CompCluster.h"
 #include <cassert>
 #include <iostream>
+#include <format>
 
 using namespace o2::itsmft;
 
 std::ostream& operator<<(std::ostream& stream, const CompCluster& cl)
 {
-  stream << " row: " << cl.getRow() << " col: " << cl.getCol()
-         << " pattID " << cl.getPatternID() << " [flag: " << cl.getFlag() << "] ";
+  stream << cl.asString();
   return stream;
 }
 
 std::ostream& operator<<(std::ostream& stream, const CompClusterExt& cl)
 {
-  stream << " chip: " << cl.getChipID() << ((const CompCluster&)cl);
+  stream << cl.asString();
   return stream;
 }
 
+std::string CompCluster::asString() const
+{
+  return std::format(" row: {:4d} col: {:4d} pattID: {:4d} [flag: {:1d}]", getRow(), getCol(), getPatternID(), getFlag());
+}
+
+std::string CompClusterExt::asString() const
+{
+  return std::format(" chip: {:5d} row: {:4d} col: {:4d} pattID: {:4d} [flag: {:1d}]", getChipID(), getRow(), getCol(), getPatternID(), getFlag());
+}
+
 //______________________________________________________________________________
 void CompCluster::print() const
 {

From 839dfe20d2833b0d9b9e7559f853c400811d0c8a Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 4 Apr 2025 15:14:02 +0200
Subject: [PATCH 0196/1764] GPU: Array add fill method (#14139)

---
 GPU/Common/GPUCommonArray.h | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/GPU/Common/GPUCommonArray.h b/GPU/Common/GPUCommonArray.h
index 853d864dc2d4d..c9babbf5548b4 100644
--- a/GPU/Common/GPUCommonArray.h
+++ b/GPU/Common/GPUCommonArray.h
@@ -29,6 +29,12 @@ struct array {
   GPUd() const T& operator[](size_t i) const { return m_internal_V__[i]; };
   GPUd() T* data() { return m_internal_V__; };
   GPUd() const T* data() const { return m_internal_V__; };
+  GPUd() void fill(const T& t)
+  {
+    for (size_t i{0}; i < N; ++i) {
+      m_internal_V__[i] = t;
+    }
+  }
   T m_internal_V__[N];
 };
 template <class T, class... E>

From 38a9d9156c46ede21713592cf7ba3be07af434ec Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 4 Apr 2025 01:08:42 +0200
Subject: [PATCH 0197/1764] Fill alternative TPC dedx according to new
 dEdxClusterRejectionFlagMaskAlt opt.

The old TrackTPC::getdEdx() is unchanged, the new info can be accessed
as TrackTPC::getdEdxAlt()
---
 .../TPC/include/DataFormatsTPC/TrackTPC.h     |  6 ++-
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  1 +
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  3 ++
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  2 +
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 46 +++++++++++--------
 6 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/TrackTPC.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/TrackTPC.h
index 0b40090de1c2e..e7e23dea91e88 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/TrackTPC.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/TrackTPC.h
@@ -128,6 +128,9 @@ class TrackTPC : public o2::track::TrackParCov
   GPUd() const dEdxInfo& getdEdx() const { return mdEdx; }
   GPUd() void setdEdx(const dEdxInfo& v) { mdEdx = v; }
 
+  GPUd() const dEdxInfo& getdEdxAlt() const { return mdEdxAlt; }
+  GPUd() void setdEdxAlt(const dEdxInfo& v) { mdEdxAlt = v; }
+
  private:
   float mTime0 = 0.f;                 ///< Assumed time of the vertex that created the track in TPC time bins, 0 for triggered data
   float mDeltaTFwd = 0;               ///< max possible increment to mTime0
@@ -136,9 +139,10 @@ class TrackTPC : public o2::track::TrackParCov
   float mChi2 = 0.f;                  // Chi2 of the track
   o2::track::TrackParCov mOuterParam; // Track parameters at outer end of TPC.
   dEdxInfo mdEdx;                     // dEdx Information
+  dEdxInfo mdEdxAlt;                  // dEdx alternative Information
   ClusRef mClustersReference;         // reference to externale cluster indices
 
-  ClassDefNV(TrackTPC, 4);
+  ClassDefNV(TrackTPC, 5);
 };
 
 } // namespace tpc
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 5d716d32d928f..34fac6514851c 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -158,6 +158,7 @@ AddOptionRTC(enablePID, int8_t, 1, "", 0, "Enable PID response")
 AddOptionRTC(PID_useNsigma, int8_t, 1, "", 0, "Use nSigma instead of absolute distance in PID response")
 AddOptionRTC(adddEdxSubThresholdClusters, int8_t, 1, "", 0, "Add sub threshold clusters in TPC dEdx computation")
 AddOptionRTC(dEdxClusterRejectionFlagMask, int8_t, o2::gpu::GPUTPCGMMergedTrackHit::flagEdge, "", 0, "OR mask of TPC flags that will reject the cluster in dEdx")
+AddOptionRTC(dEdxClusterRejectionFlagMaskAlt, int8_t, o2::gpu::GPUTPCGMMergedTrackHit::flagEdge, "", 0, "OR mask of TPC flags that will reject the cluster in alternative dEdx")
 AddOptionRTC(rejectEdgeClustersInSeeding, int8_t, 0, "", 0, "Reject edge clusters based on uncorrected track Y during seeding")
 AddOptionRTC(rejectEdgeClustersInTrackFit, int8_t, 0, "", 0, "Reject edge clusters based on uncorrected track Y during track fit")
 AddOptionArray(PID_remap, int8_t, 9, (0, 1, 2, 3, 4, 5, 6, 7, 8), "", 0, "Remap Ipid to PID_reamp[Ipid] (no remap if<0)") // BUG: CUDA cannot yet hand AddOptionArrayRTC
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index f03964d35ff82..bdf60f744b9ca 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -299,6 +299,7 @@ void* GPUTPCGMMerger::SetPointersOutput(void* mem)
   computePointerWithAlignment(mem, mOutputTracks, mNMaxTracks);
   if (mRec->GetParam().dodEdxDownscaled) {
     computePointerWithAlignment(mem, mOutputTracksdEdx, mNMaxTracks);
+    computePointerWithAlignment(mem, mOutputTracksdEdxAlt, mNMaxTracks);
   }
   computePointerWithAlignment(mem, mClusters, mNMaxOutputTrackClusters);
   if (mRec->GetParam().par.earlyTpcTransform) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 506dd88ab7058..6c6e0e02a2dc2 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -108,6 +108,8 @@ class GPUTPCGMMerger : public GPUProcessor
   GPUhdi() GPUTPCGMMergedTrack* OutputTracks() { return mOutputTracks; }
   GPUhdi() const GPUdEdxInfo* OutputTracksdEdx() const { return mOutputTracksdEdx; }
   GPUhdi() GPUdEdxInfo* OutputTracksdEdx() { return mOutputTracksdEdx; }
+  GPUhdi() const GPUdEdxInfo* OutputTracksdEdxAlt() const { return mOutputTracksdEdxAlt; }
+  GPUhdi() GPUdEdxInfo* OutputTracksdEdxAlt() { return mOutputTracksdEdxAlt; }
   GPUhdi() uint32_t NClusters() const { return mNClusters; }
   GPUhdi() uint32_t NMaxClusters() const { return mNMaxClusters; }
   GPUhdi() uint32_t NMaxTracks() const { return mNMaxTracks; }
@@ -261,6 +263,7 @@ class GPUTPCGMMerger : public GPUProcessor
   int32_t mNClusters = 0;                           // Total number of incoming clusters (from sector tracks)
   GPUTPCGMMergedTrack* mOutputTracks = nullptr;     //* array of output merged tracks
   GPUdEdxInfo* mOutputTracksdEdx = nullptr;         //* dEdx information
+  GPUdEdxInfo* mOutputTracksdEdxAlt = nullptr;      //* dEdx alternative information
   GPUTPCGMSectorTrack* mSectorTrackInfos = nullptr; //* additional information for sector tracks
   int32_t* mSectorTrackInfoIndex = nullptr;
   GPUTPCGMMergedTrackHit* mClusters = nullptr;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 8056f22484e70..13b34a0a64a84 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -114,6 +114,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
   constexpr float MinDelta = 0.1f;
   const GPUTPCGMMergedTrack* tracks = merger.OutputTracks();
   GPUdEdxInfo* tracksdEdx = merger.OutputTracksdEdx();
+  GPUdEdxInfo* tracksdEdxAlt = merger.OutputTracksdEdxAlt();
   const int32_t nTracks = merger.NOutputTracksTPCO2();
   const GPUTPCGMMergedTrackHit* trackClusters = merger.Clusters();
   constexpr uint8_t flagsReject = getFlagsReject();
@@ -146,6 +147,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
     auto& outerPar = tracks[i].OuterParam();
     if (merger.Param().par.dodEdx && merger.Param().dodEdxDownscaled) {
       oTrack.setdEdx(tracksdEdx[i]);
+      oTrack.setdEdxAlt(tracksdEdxAlt[i]);
     }
 
     auto snpOut = outerPar.P[2];
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 29524fb80ace0..260c64db052af 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -60,7 +60,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
   const GPUParam& GPUrestrict() param = merger->Param();
 
-  GPUdEdx dEdx;
+  GPUdEdx dEdx, dEdxAlt;
   GPUTPCGMPropagator prop;
   gputpcgmmergertypes::InterpolationErrors interpolation;
   prop.SetMaterialTPC();
@@ -220,6 +220,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, cluster.leg == clusters[maxN - 1].leg, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
         if (dodEdx) {
           dEdx.fillSubThreshold(lastRow - wayDirection);
+          dEdxAlt.fillSubThreshold(lastRow - wayDirection);
         }
       }
 
@@ -366,25 +367,33 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           CADEBUG(printf("Reinit linearization\n"));
           prop.SetTrack(this, prop.GetAlpha());
         }
-        if (param.par.dodEdx && param.dodEdxDownscaled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg && (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMask) == 0) { // TODO: Costimize flag to remove, and option to remove double-clusters
-          float qtot = 0, qmax = 0, pad = 0, relTime = 0;
-          const int32_t clusterCount = (ihit - ihitMergeFirst) * wayDirection + 1;
-          for (int32_t iTmp = ihitMergeFirst; iTmp != ihit + wayDirection; iTmp += wayDirection) {
-            if (merger->GetConstantMem()->ioPtrs.clustersNative == nullptr) {
-              qtot += clustersXYZ[ihit].amp;
-            } else {
-              const ClusterNative& cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num];
-              qtot += cl.qTot;
-              qmax = CAMath::Max<float>(qmax, cl.qMax);
-              pad += cl.getPad();
-              relTime += cl.getTime();
+        if (param.par.dodEdx && param.dodEdxDownscaled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg) { // TODO: Costimize flag to remove, and option to remove double-clusters
+          bool acc = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMask) == 0, accAlt = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) == 0;
+          if (acc || accAlt) {
+            float qtot = 0, qmax = 0, pad = 0, relTime = 0;
+            const int32_t clusterCount = (ihit - ihitMergeFirst) * wayDirection + 1;
+            for (int32_t iTmp = ihitMergeFirst; iTmp != ihit + wayDirection; iTmp += wayDirection) {
+              if (merger->GetConstantMem()->ioPtrs.clustersNative == nullptr) {
+                qtot += clustersXYZ[ihit].amp;
+              } else {
+                const ClusterNative& cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num];
+                qtot += cl.qTot;
+                qmax = CAMath::Max<float>(qmax, cl.qMax);
+                pad += cl.getPad();
+                relTime += cl.getTime();
+              }
+            }
+            qtot /= clusterCount; // TODO: Weighted Average
+            pad /= clusterCount;
+            relTime /= clusterCount;
+            relTime = relTime - CAMath::Round(relTime);
+            if (acc) {
+              dEdx.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
+            }
+            if (accAlt) {
+              dEdxAlt.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
             }
           }
-          qtot /= clusterCount; // TODO: Weighted Average
-          pad /= clusterCount;
-          relTime /= clusterCount;
-          relTime = relTime - CAMath::Round(relTime);
-          dEdx.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
         }
       } else if (retVal >= GPUTPCGMPropagator::updateErrorClusterRejected) { // cluster far away form the track
         if (allowModification) {
@@ -419,6 +428,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
   if (param.par.dodEdx && param.dodEdxDownscaled) {
     dEdx.computedEdx(merger->OutputTracksdEdx()[iTrk], param);
+    dEdxAlt.computedEdx(merger->OutputTracksdEdxAlt()[iTrk], param);
   }
   Alpha = prop.GetAlpha();
   MoveToReference(prop, param, Alpha);

From a3917a699141405cf224353c3631ea19131b76fe Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 4 Apr 2025 01:14:38 +0200
Subject: [PATCH 0198/1764] AOD TrackQA stores track.dEdxAlt.dEdxTPCTot used
 for its dEdx info normalization

When filling AOD extra track info, the TPCSignal and the number of clusters used for PID
are overridden to those coming from the TrackTPC::dEdxAlt if the nominal dEdx.dEdxTotTPC==0.
This is flagged by extraInfo.flags |= o2::aod::track::TPCdEdxAlt

The ratio is stored with the same precision as the nominal dEdxAlt.dEdxTPCTot in the extraInfo.TPCSignal.
+Extra fixes like clamping to uint8_t instead of casting float to it.
---
 .../AODProducerWorkflowSpec.h                 |  1 +
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 35 +++++++++++++------
 .../include/Framework/AnalysisDataModel.h     | 15 ++++++--
 Framework/Core/include/Framework/DataTypes.h  |  1 +
 4 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 1f82eaf34c473..b89acaa41066f 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -416,6 +416,7 @@ class AODProducerWorkflowDPL : public Task
   struct TrackQA {
     GID trackID;
     float tpcTime0{};
+    float tpcdEdxNorm{};
     int16_t tpcdcaR{};
     int16_t tpcdcaZ{};
     uint8_t tpcClusterByteMask{};
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 8532107d57035..2b133770357fc 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -362,6 +362,7 @@ void AODProducerWorkflowDPL::addToTracksQATable(TracksQACursorType& tracksQACurs
   tracksQACursor(
     trackQAInfoHolder.trackID,
     truncateFloatFraction(trackQAInfoHolder.tpcTime0, mTPCTime0),
+    truncateFloatFraction(trackQAInfoHolder.tpcdEdxNorm, mTrackSignal),
     trackQAInfoHolder.tpcdcaR,
     trackQAInfoHolder.tpcdcaZ,
     trackQAInfoHolder.tpcClusterByteMask,
@@ -2558,14 +2559,18 @@ AODProducerWorkflowDPL::TrackExtraInfo AODProducerWorkflowDPL::processBarrelTrac
   if (contributorsGID[GIndex::Source::TPC].isIndexSet()) {
     const auto& tpcOrig = data.getTPCTrack(contributorsGID[GIndex::TPC]);
     const auto& tpcClData = mTPCCounters[contributorsGID[GIndex::TPC]];
+    const auto& dEdx = tpcOrig.getdEdx().dEdxTotTPC > 0 ? tpcOrig.getdEdx() : tpcOrig.getdEdxAlt();
+    if (tpcOrig.getdEdx().dEdxTotTPC == 0) {
+      extraInfoHolder.flags |= o2::aod::track::TPCdEdxAlt;
+    }
     extraInfoHolder.tpcInnerParam = tpcOrig.getP() / tpcOrig.getAbsCharge();
     extraInfoHolder.tpcChi2NCl = tpcOrig.getNClusters() ? tpcOrig.getChi2() / tpcOrig.getNClusters() : 0;
-    extraInfoHolder.tpcSignal = tpcOrig.getdEdx().dEdxTotTPC;
+    extraInfoHolder.tpcSignal = dEdx.dEdxTotTPC;
     extraInfoHolder.tpcNClsFindable = tpcOrig.getNClusters();
     extraInfoHolder.tpcNClsFindableMinusFound = tpcOrig.getNClusters() - tpcClData.found;
     extraInfoHolder.tpcNClsFindableMinusCrossedRows = tpcOrig.getNClusters() - tpcClData.crossed;
     extraInfoHolder.tpcNClsShared = tpcClData.shared;
-    uint32_t clsUsedForPID = tpcOrig.getdEdx().NHitsIROC + tpcOrig.getdEdx().NHitsOROC1 + tpcOrig.getdEdx().NHitsOROC2 + tpcOrig.getdEdx().NHitsOROC3;
+    uint32_t clsUsedForPID = dEdx.NHitsIROC + dEdx.NHitsOROC1 + dEdx.NHitsOROC2 + dEdx.NHitsOROC3;
     extraInfoHolder.tpcNClsFindableMinusPID = tpcOrig.getNClusters() - clsUsedForPID;
     if (src == GIndex::TPC) { // standalone TPC track should set its time from their timebins range
       if (needBCSlice) {
@@ -2621,6 +2626,11 @@ AODProducerWorkflowDPL::TrackQA AODProducerWorkflowDPL::processBarrelTrackQA(int
       using ValType = decltype(value);
       return static_cast<int8_t>(TMath::Nint(std::clamp(value, static_cast<ValType>(std::numeric_limits<int8_t>::min()), static_cast<ValType>(std::numeric_limits<int8_t>::max()))));
     };
+    auto safeUInt8Clamp = [](auto value) -> uint8_t {
+      using ValType = decltype(value);
+      return static_cast<uint8_t>(TMath::Nint(std::clamp(value, static_cast<ValType>(std::numeric_limits<uint8_t>::min()), static_cast<ValType>(std::numeric_limits<uint8_t>::max()))));
+    };
+
     /// get tracklet byteMask
     uint8_t clusterCounters[8] = {0};
     {
@@ -2641,16 +2651,18 @@ AODProducerWorkflowDPL::TrackQA AODProducerWorkflowDPL::processBarrelTrackQA(int
     }
     trackQAHolder.tpcTime0 = tpcOrig.getTime0();
     trackQAHolder.tpcClusterByteMask = byteMask;
-    const float dEdxNorm = (tpcOrig.getdEdx().dEdxTotTPC > 0) ? 100. / tpcOrig.getdEdx().dEdxTotTPC : 0;
-    trackQAHolder.tpcdEdxMax0R = uint8_t(tpcOrig.getdEdx().dEdxMaxIROC * dEdxNorm);
-    trackQAHolder.tpcdEdxMax1R = uint8_t(tpcOrig.getdEdx().dEdxMaxOROC1 * dEdxNorm);
-    trackQAHolder.tpcdEdxMax2R = uint8_t(tpcOrig.getdEdx().dEdxMaxOROC2 * dEdxNorm);
-    trackQAHolder.tpcdEdxMax3R = uint8_t(tpcOrig.getdEdx().dEdxMaxOROC3 * dEdxNorm);
+    const auto& dEdxInfoAlt = tpcOrig.getdEdxAlt(); // tpcOrig.getdEdx()
+    const float dEdxNorm = (dEdxInfoAlt.dEdxTotTPC > 0) ? 100. / dEdxInfoAlt.dEdxTotTPC : 0;
+    trackQAHolder.tpcdEdxNorm = dEdxInfoAlt.dEdxTotTPC;
+    trackQAHolder.tpcdEdxMax0R = safeUInt8Clamp(dEdxInfoAlt.dEdxMaxIROC * dEdxNorm);
+    trackQAHolder.tpcdEdxMax1R = safeUInt8Clamp(dEdxInfoAlt.dEdxMaxOROC1 * dEdxNorm);
+    trackQAHolder.tpcdEdxMax2R = safeUInt8Clamp(dEdxInfoAlt.dEdxMaxOROC2 * dEdxNorm);
+    trackQAHolder.tpcdEdxMax3R = safeUInt8Clamp(dEdxInfoAlt.dEdxMaxOROC3 * dEdxNorm);
     //
-    trackQAHolder.tpcdEdxTot0R = uint8_t(tpcOrig.getdEdx().dEdxTotIROC * dEdxNorm);
-    trackQAHolder.tpcdEdxTot1R = uint8_t(tpcOrig.getdEdx().dEdxTotOROC1 * dEdxNorm);
-    trackQAHolder.tpcdEdxTot2R = uint8_t(tpcOrig.getdEdx().dEdxTotOROC2 * dEdxNorm);
-    trackQAHolder.tpcdEdxTot3R = uint8_t(tpcOrig.getdEdx().dEdxTotOROC3 * dEdxNorm);
+    trackQAHolder.tpcdEdxTot0R = safeUInt8Clamp(dEdxInfoAlt.dEdxTotIROC * dEdxNorm);
+    trackQAHolder.tpcdEdxTot1R = safeUInt8Clamp(dEdxInfoAlt.dEdxTotOROC1 * dEdxNorm);
+    trackQAHolder.tpcdEdxTot2R = safeUInt8Clamp(dEdxInfoAlt.dEdxTotOROC2 * dEdxNorm);
+    trackQAHolder.tpcdEdxTot3R = safeUInt8Clamp(dEdxInfoAlt.dEdxTotOROC3 * dEdxNorm);
     ///
     float scaleTOF{0};
     auto contributorsGIDA = data.getSingleDetectorRefs(trackIndex);
@@ -2721,6 +2733,7 @@ AODProducerWorkflowDPL::TrackQA AODProducerWorkflowDPL::processBarrelTrackQA(int
                        << "scaleGlo3=" << scaleGlo(3)
                        << "scaleGlo4=" << scaleGlo(4)
                        << "trackQAHolder.tpcTime0=" << trackQAHolder.tpcTime0
+                       << "trackQAHolder.tpcdEdxNorm=" << trackQAHolder.tpcdEdxNorm
                        << "trackQAHolder.tpcdcaR=" << trackQAHolder.tpcdcaR
                        << "trackQAHolder.tpcdcaZ=" << trackQAHolder.tpcdcaZ
                        << "trackQAHolder.tpcdcaClusterByteMask=" << trackQAHolder.tpcClusterByteMask
diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index 70db8500e3421..d90952f38ac9f 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -680,10 +680,11 @@ namespace trackqa
 // TRACKQA TABLE COLUMNS
 DECLARE_SOA_INDEX_COLUMN(Track, track);                                   //! track to which this QA information belongs
 DECLARE_SOA_COLUMN(TPCTime0, tpcTime0, float);                            //! tpc only time0 (mTime0 in TPC track)
+DECLARE_SOA_COLUMN(TPCdEdxNorm, tpcdEdxNorm, float);                      //! 100/TrackTPC.mdEdxAlt used to normalize dEdX...values below
 DECLARE_SOA_COLUMN(TPCDCAR, tpcdcaR, int16_t);                            //! tpc only DCAr
 DECLARE_SOA_COLUMN(TPCDCAZ, tpcdcaZ, int16_t);                            //! tpc only DCAz
 DECLARE_SOA_COLUMN(TPCClusterByteMask, tpcClusterByteMask, uint8_t);      //! tracklet bitmask - track defining 8 tracklets (152=8*19 rows) bit set if nCluster>thr (default 5)
-DECLARE_SOA_COLUMN(TPCdEdxMax0R, tpcdEdxMax0R, uint8_t);                  //! TPC dEdxQMax -ROC0/dEdx
+DECLARE_SOA_COLUMN(TPCdEdxMax0R, tpcdEdxMax0R, uint8_t);                  //! TPC dEdxQMax -ROC0/dEdx from TrackTPC.mdEdxAlt
 DECLARE_SOA_COLUMN(TPCdEdxMax1R, tpcdEdxMax1R, uint8_t);                  //! TPC dEdxQMax -ROC1/dEdx
 DECLARE_SOA_COLUMN(TPCdEdxMax2R, tpcdEdxMax2R, uint8_t);                  //! TPC dEdxQMax -ROC2/dEdx
 DECLARE_SOA_COLUMN(TPCdEdxMax3R, tpcdEdxMax3R, uint8_t);                  //! TPC dEdxQMax -ROC3/dEdx
@@ -736,7 +737,17 @@ DECLARE_SOA_TABLE_VERSIONED(TracksQA_002, "AOD", "TRACKQA", 2, //! trackQA infor
                             trackqa::IsDummy<trackqa::DeltaRefContParamY, trackqa::DeltaRefContParamZ, trackqa::DeltaRefContParamSnp, trackqa::DeltaRefContParamTgl, trackqa::DeltaRefContParamQ2Pt,
                                              trackqa::DeltaRefGloParamY, trackqa::DeltaRefGloParamZ, trackqa::DeltaRefGloParamSnp, trackqa::DeltaRefGloParamTgl, trackqa::DeltaRefGloParamQ2Pt>);
 
-using TracksQAVersion = TracksQA_002;
+DECLARE_SOA_TABLE_VERSIONED(TracksQA_003, "AOD", "TRACKQA", 3, //! trackQA information - version 3 - including alternative dedx normalization
+                            o2::soa::Index<>, trackqa::TrackId, trackqa::TPCTime0, trackqa::TPCdEdxNorm, trackqa::TPCDCAR, trackqa::TPCDCAZ, trackqa::TPCClusterByteMask,
+                            trackqa::TPCdEdxMax0R, trackqa::TPCdEdxMax1R, trackqa::TPCdEdxMax2R, trackqa::TPCdEdxMax3R,
+                            trackqa::TPCdEdxTot0R, trackqa::TPCdEdxTot1R, trackqa::TPCdEdxTot2R, trackqa::TPCdEdxTot3R,
+                            trackqa::DeltaRefContParamY, trackqa::DeltaRefContParamZ, trackqa::DeltaRefContParamSnp, trackqa::DeltaRefContParamTgl, trackqa::DeltaRefContParamQ2Pt,
+                            trackqa::DeltaRefGloParamY, trackqa::DeltaRefGloParamZ, trackqa::DeltaRefGloParamSnp, trackqa::DeltaRefGloParamTgl, trackqa::DeltaRefGloParamQ2Pt,
+                            trackqa::DeltaTOFdX, trackqa::DeltaTOFdZ,
+                            trackqa::IsDummy<trackqa::DeltaRefContParamY, trackqa::DeltaRefContParamZ, trackqa::DeltaRefContParamSnp, trackqa::DeltaRefContParamTgl, trackqa::DeltaRefContParamQ2Pt,
+                                             trackqa::DeltaRefGloParamY, trackqa::DeltaRefGloParamZ, trackqa::DeltaRefGloParamSnp, trackqa::DeltaRefGloParamTgl, trackqa::DeltaRefGloParamQ2Pt>);
+
+using TracksQAVersion = TracksQA_003;
 using TracksQA = TracksQAVersion::iterator;
 
 namespace fwdtrack
diff --git a/Framework/Core/include/Framework/DataTypes.h b/Framework/Core/include/Framework/DataTypes.h
index 0a96ab49059fe..e273a78f8d0a2 100644
--- a/Framework/Core/include/Framework/DataTypes.h
+++ b/Framework/Core/include/Framework/DataTypes.h
@@ -50,6 +50,7 @@ enum TrackFlags : uint32_t {
   PVContributor = 0x2,       // This track has contributed to the collision vertex fit
   OrphanTrack = 0x4,         // Track has no association with any collision vertex
   TrackTimeAsym = 0x8,       // track with an asymmetric time range
+  TPCdEdxAlt = 0x10,         // TPCSignal and tpcNClsFindableMinusPID correspond for alternative dEdx since the nominal was 0
   // NOTE Highest 4 (29..32) bits reserved for PID hypothesis
 };
 enum TrackFlagsRun2Enum {

From 10e0ecf4a3952c978cf66938776d425ea7c19ff4 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Fri, 4 Apr 2025 14:12:41 +0200
Subject: [PATCH 0199/1764] GPU RTC: fix rtctech configKeyValue options in
 dpl-workflow.sh

---
 prodtests/full-system-test/dpl-workflow.sh | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index d067d9a8526e9..2dfc74e3ecfb3 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -333,11 +333,11 @@ if has_detector_calib PHS && workflow_has_parameter CALIB; then
 fi
 
 [[ ${O2_GPU_DOUBLE_PIPELINE:-$EPNSYNCMODE} == 1 && $GPUTYPE != "CPU" ]] && GPU_CONFIG+=" --enableDoublePipeline"
-[[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc_rtc.enable=1;GPU_proc_rtc.cacheOutput=1;GPU_proc.RTCTECH.prependCommand=/usr/bin/env TMPDIR=/tmp /usr/bin/taskset -c 0-191;"
-[[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 && $EPNSYNCMODE == 1 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCTECH.cacheFolder=/var/tmp/o2_gpu_rtc_cache;"
+[[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc_rtc.enable=1;GPU_proc_rtc.cacheOutput=1;GPU_proc_rtctech.prependCommand=/usr/bin/env TMPDIR=/tmp /usr/bin/taskset -c 0-191;"
+[[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 && $EPNSYNCMODE == 1 ]] && GPU_CONFIG_KEY+="GPU_proc_rtctech.cacheFolder=/var/tmp/o2_gpu_rtc_cache;"
 if [[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 ]] && [[ ( ${ALICE_O2_FST:-0} == 1 && ${FST_TMUX_NO_EPN:-0} == 0 ) || $EPNSYNCMODE == 1 ]]; then
-  [[ ${EPN_NODE_MI100:-0} == 0 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCTECH.overrideArchitecture=--offload-arch=gfx906;"
-  [[ ${EPN_NODE_MI100:-0} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc.RTCTECH.overrideArchitecture=--offload-arch=gfx908;"
+  [[ ${EPN_NODE_MI100:-0} == 0 ]] && GPU_CONFIG_KEY+="GPU_proc_rtctech.overrideArchitecture=--offload-arch=gfx906;"
+  [[ ${EPN_NODE_MI100:-0} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc_rtctech.overrideArchitecture=--offload-arch=gfx908;"
 fi
 
 ( workflow_has_parameter AOD || [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-emcal-cell-writer-workflow ) && has_detector EMC && RAW_EMC_SUBSPEC=" --subspecification 1 "

From 56dc84e7ab0194224cccc62a8b03f6b7297a7d0a Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Mon, 7 Apr 2025 09:02:57 +0200
Subject: [PATCH 0200/1764] Fixes for the latest clang on osx (#14143)

---
 GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx | 3 +--
 Utilities/rANS/include/rANS/compat.h                       | 4 ++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx b/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx
index 7ccc82b3512d3..6a17377ae5d01 100644
--- a/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx
+++ b/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx
@@ -73,8 +73,7 @@ std::vector<std::string> MultivariatePolynomialHelper<0, 0, false>::getTerms() c
 TLinearFitter MultivariatePolynomialHelper<0, 0, false>::getTLinearFitter() const
 {
   const std::string formula = getTLinearFitterFormula();
-  TLinearFitter fitter(int32_t(mDim), formula.data(), "");
-  return fitter;
+  return TLinearFitter(int32_t(mDim), formula.data(), "");
 }
 
 std::vector<float> MultivariatePolynomialHelper<0, 0, false>::fit(TLinearFitter& fitter, std::vector<double>& x, std::vector<double>& y, std::vector<double>& error, const bool clearPoints)
diff --git a/Utilities/rANS/include/rANS/compat.h b/Utilities/rANS/include/rANS/compat.h
index a4917246eb455..982428a1d69a9 100644
--- a/Utilities/rANS/include/rANS/compat.h
+++ b/Utilities/rANS/include/rANS/compat.h
@@ -201,7 +201,7 @@ class makeEncoder
   template <typename source_T>
   [[nodiscard]] inline static decltype(auto) fromSamples(gsl::span<const source_T> range, size_t renormingPrecision = 0)
   {
-    auto histogram = makeDenseHistogram::template fromSamples(range);
+    auto histogram = makeDenseHistogram::fromSamples(range);
     return makeEncoder::fromHistogram(std::move(histogram), renormingPrecision);
   };
 
@@ -296,4 +296,4 @@ using decoder_type = decltype(makeDecoder::fromRenormed(RenormedDenseHistogram<s
 
 } // namespace o2::rans::compat
 
-#endif /* RANS_COMPAT_H_ */
\ No newline at end of file
+#endif /* RANS_COMPAT_H_ */

From 8e4ed02544eb11fff8433e4ca259576eb29eda6e Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 7 Apr 2025 11:13:56 +0200
Subject: [PATCH 0201/1764] DPL Analysis: add configurable expression columns
 (#14141)

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Framework/Core/include/Framework/ASoA.h       |  63 +++++++++-
 .../Core/include/Framework/AnalysisHelpers.h  |  54 ++++++++-
 .../Core/include/Framework/AnalysisManagers.h |  66 +++++++----
 .../Core/include/Framework/AnalysisTask.h     |   6 +-
 .../Core/include/Framework/Expressions.h      |  11 +-
 .../Core/include/Framework/TableBuilder.h     |  58 +++++----
 Framework/Core/src/AODReaderHelpers.cxx       | 112 ++++++++++--------
 Framework/Core/src/TableBuilder.cxx           |   9 +-
 Framework/Core/src/runDataProcessing.cxx      |   2 +-
 Framework/Core/test/test_TableSpawner.cxx     |  28 ++++-
 10 files changed, 310 insertions(+), 99 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index f21decd0d5c45..e098cd89f6d5d 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -425,6 +425,9 @@ concept has_metadata = is_metadata_trait<T> && not_void<typename T::metadata>;
 template <typename T>
 concept has_extension = is_metadata<T> && not_void<typename T::extension_table_t>;
 
+template <typename T>
+concept has_configurable_extension = has_extension<T> && requires(T t) { typename T::configurable_t; requires std::same_as<std::true_type, typename T::configurable_t>; };
+
 template <typename T>
 concept is_spawnable_column = std::same_as<typename T::spawnable_t, std::true_type>;
 
@@ -2355,7 +2358,7 @@ O2HASH("TEST/0");
   DECLARE_SOA_BITMAP_COLUMN_FULL(_Name_, _Getter_, _Size_, "f" #_Name_)
 
 /// An 'expression' column. i.e. a column that can be calculated from other
-/// columns with gandiva based on supplied C++ expression.
+/// columns with gandiva based on static C++ expression.
 #define DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_, _Expression_)                                                       \
   struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                                                               \
     static constexpr const char* mLabel = _Label_;                                                                                                \
@@ -2393,6 +2396,38 @@ O2HASH("TEST/0");
 #define DECLARE_SOA_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Expression_) \
   DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, "f" #_Name_, _Expression_);
 
+/// A configurable 'expression' column. i.e. a column that can be calculated from other
+/// columns with gandiva based on dynamically supplied C++ expression or a string definition.
+#define DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Label_)                                                             \
+  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                                                               \
+    static constexpr const char* mLabel = _Label_;                                                                                                \
+    static constexpr const int32_t mHash = _Label_ ""_h;                                                                                          \
+    using base = o2::soa::Column<_Type_, _Name_>;                                                                                                 \
+    using type = _Type_;                                                                                                                          \
+    using column_t = _Name_;                                                                                                                      \
+    using spawnable_t = std::true_type;                                                                                                           \
+    _Name_(arrow::ChunkedArray const* column)                                                                                                     \
+      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                                                                    \
+    {                                                                                                                                             \
+    }                                                                                                                                             \
+                                                                                                                                                  \
+    _Name_() = default;                                                                                                                           \
+    _Name_(_Name_ const& other) = default;                                                                                                        \
+    _Name_& operator=(_Name_ const& other) = default;                                                                                             \
+                                                                                                                                                  \
+    decltype(auto) _Getter_() const                                                                                                               \
+    {                                                                                                                                             \
+      return *mColumnIterator;                                                                                                                    \
+    }                                                                                                                                             \
+                                                                                                                                                  \
+    decltype(auto) get() const                                                                                                                    \
+    {                                                                                                                                             \
+      return _Getter_();                                                                                                                          \
+    }                                                                                                                                             \
+  };                                                                                                                                              \
+  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(), \
+                                                                                       o2::framework::expressions::selectArrowType<_Type_>() }
+
 /// An index column is a column of indices to elements / of another table named
 /// _Name_##s. The column name will be _Name_##Id and will always be stored in
 /// "fIndex"#_Table_#[_Suffix_]. If _Suffix_ is not empty it has to begin
@@ -3104,6 +3139,32 @@ consteval auto getIndexTargets()
   O2HASH(#_Name_ "Extension");                                               \
   DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, #_Name_ "Extension", _Table_, "AOD", "EX" _Description_, 0, __VA_ARGS__)
 
+#define DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_FULL(_Name_, _Label_, _OriginalTable_, _Origin_, _Desc_, _Version_, ...)           \
+  O2HASH(_Desc_ "/" #_Version_);                                                                                                   \
+  template <typename O>                                                                                                            \
+  using _Name_##CfgExtensionFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>;          \
+  using _Name_##CfgExtension = _Name_##CfgExtensionFrom<o2::aod::Hash<_Origin_ ""_h>>;                                             \
+  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                             \
+  struct _Name_##CfgExtensionMetadataFrom : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                \
+    using base_table_t = _OriginalTable_;                                                                                          \
+    using extension_table_t = _Name_##CfgExtensionFrom<O>;                                                                         \
+    using placeholders_pack_t = framework::pack<__VA_ARGS__>;                                                                      \
+    using configurable_t = std::true_type;                                                                                         \
+    static constexpr auto sources = _OriginalTable_::originals;                                                                    \
+  };                                                                                                                               \
+  using _Name_##CfgExtensionMetadata = _Name_##CfgExtensionMetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                             \
+  template <>                                                                                                                      \
+  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                \
+    using metadata = _Name_##CfgExtensionMetadata;                                                                                 \
+  };                                                                                                                               \
+  template <typename O>                                                                                                            \
+  using _Name_##From = o2::soa::JoinFull<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, _OriginalTable_, _Name_##CfgExtensionFrom<O>>; \
+  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
+
+#define DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(_Name_, _Table_, _Description_, ...) \
+  O2HASH(#_Name_ "CfgExtension");                                                    \
+  DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_FULL(_Name_, #_Name_ "CfgExtension", _Table_, "AOD", "EX" _Description_, 0, __VA_ARGS__)
+
 #define DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, _Origin_, _Version_, _Desc_, _Exclusive_, ...)                                         \
   O2HASH(#_Name_);                                                                                                                         \
   O2HASH(_Desc_ "/" #_Version_);                                                                                                           \
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 59bade6d43cd0..985f80cd548bc 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -247,6 +247,9 @@ struct TableTransform {
 template <typename T>
 concept is_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>> && soa::has_extension<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata>;
 
+template <typename T>
+concept is_dynamically_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>> && soa::has_configurable_extension<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata>;
+
 template <is_spawnable T>
 constexpr auto transformBase()
 {
@@ -282,12 +285,60 @@ struct Spawns : decltype(transformBase<T>()) {
   }
   std::shared_ptr<typename T::table_t> table = nullptr;
   std::shared_ptr<extension_t> extension = nullptr;
+  std::shared_ptr<gandiva::Projector> projector = nullptr;
 };
 
 template <typename T>
 concept is_spawns = requires(T t) {
   typename T::metadata;
   requires std::same_as<decltype(t.pack()), typename T::expression_pack_t>;
+  requires std::same_as<decltype(t.projector), std::shared_ptr<gandiva::Projector>>;
+};
+
+/// This helper struct allows you to declare extended tables with dynamically-supplied
+/// expressions to be created by the task
+/// The actual expressions have to be set in init() for the configurable expression
+/// columns, used to define the table
+
+template <is_dynamically_spawnable T>
+struct Defines : decltype(transformBase<T>()) {
+  using spawnable_t = T;
+  using metadata = decltype(transformBase<T>())::metadata;
+  using extension_t = typename metadata::extension_table_t;
+  using base_table_t = typename metadata::base_table_t;
+  using placeholders_pack_t = typename metadata::placeholders_pack_t;
+  static constexpr size_t N = framework::pack_size(placeholders_pack_t{});
+
+  constexpr auto pack()
+  {
+    return placeholders_pack_t{};
+  }
+
+  typename T::table_t* operator->()
+  {
+    return table.get();
+  }
+  typename T::table_t const& operator*() const
+  {
+    return *table;
+  }
+
+  auto asArrowTable()
+  {
+    return extension->asArrowTable();
+  }
+  std::shared_ptr<typename T::table_t> table = nullptr;
+  std::shared_ptr<extension_t> extension = nullptr;
+
+  std::array<o2::framework::expressions::Projector, N> projectors;
+  std::shared_ptr<gandiva::Projector> projector = nullptr;
+};
+
+template <typename T>
+concept is_defines = requires(T t) {
+  typename T::metadata;
+  requires std::same_as<decltype(t.pack()), typename T::placeholders_pack_t>;
+  requires std::same_as<decltype(t.projector), std::shared_ptr<gandiva::Projector>>;
 };
 
 /// Policy to control index building
@@ -744,7 +795,8 @@ template <soa::is_table T, soa::is_spawnable_column... Cs>
 auto Extend(T const& table)
 {
   using output_t = Join<T, soa::Table<o2::aod::Hash<"JOIN"_h>, o2::aod::Hash<"JOIN/0"_h>, o2::aod::Hash<"JOIN"_h>, Cs...>>;
-  return output_t{{o2::framework::spawner(framework::pack<Cs...>{}, {table.asArrowTable()}, "dynamicExtension"), table.asArrowTable()}, 0};
+  static std::shared_ptr<gandiva::Projector> projector = nullptr;
+  return output_t{{o2::framework::spawner(framework::pack<Cs...>{}, {table.asArrowTable()}, "dynamicExtension", projector), table.asArrowTable()}, 0};
 }
 
 /// Template function to attach dynamic columns on-the-fly (e.g. inside
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 733e91706b4a8..330eaf01f0be4 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -141,22 +141,30 @@ bool requestInputs(std::vector<InputSpec>&, T const&)
 }
 
 template <is_spawns T>
-bool requestInputs(std::vector<InputSpec>& inputs, T const& spawns)
+const char* controlOption()
 {
-  auto base_specs = spawns.base_specs();
-  for (auto base_spec : base_specs) {
-    base_spec.metadata.push_back(ConfigParamSpec{std::string{"control:spawn"}, VariantType::Bool, true, {"\"\""}});
-    DataSpecUtils::updateInputList(inputs, std::forward<InputSpec>(base_spec));
-  }
-  return true;
+  return "control:spawn";
 }
 
 template <is_builds T>
-bool requestInputs(std::vector<InputSpec>& inputs, T const& builds)
+const char* controlOption()
 {
-  auto base_specs = builds.base_specs();
+  return "control:build";
+}
+
+template <is_defines T>
+const char* controlOption()
+{
+  return "control:define";
+}
+
+template <typename T>
+  requires(is_spawns<T> || is_builds<T> || is_defines<T>)
+bool requestInputs(std::vector<InputSpec>& inputs, T const& entity)
+{
+  auto base_specs = entity.base_specs();
   for (auto base_spec : base_specs) {
-    base_spec.metadata.push_back(ConfigParamSpec{std::string{"control:build"}, VariantType::Bool, true, {"\"\""}});
+    base_spec.metadata.push_back(ConfigParamSpec{std::string{controlOption<T>()}, VariantType::Bool, true, {"\"\""}});
     DataSpecUtils::updateInputList(inputs, std::forward<InputSpec>(base_spec));
   }
   return true;
@@ -219,17 +227,11 @@ bool appendOutput(std::vector<OutputSpec>& outputs, T& obj, uint32_t hash)
   return true;
 }
 
-template <is_spawns T>
-bool appendOutput(std::vector<OutputSpec>& outputs, T& spawns, uint32_t)
-{
-  outputs.emplace_back(spawns.spec());
-  return true;
-}
-
-template <is_builds T>
-bool appendOutput(std::vector<OutputSpec>& outputs, T& builds, uint32_t)
+template <typename T>
+  requires(is_spawns<T> || is_builds<T> || is_defines<T>)
+bool appendOutput(std::vector<OutputSpec>& outputs, T& entity, uint32_t)
 {
-  outputs.emplace_back(builds.spec());
+  outputs.emplace_back(entity.spec());
   return true;
 }
 
@@ -286,7 +288,7 @@ bool prepareOutput(ProcessingContext& context, T& spawns)
     originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
   }
 
-  spawns.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>>(originalTable, o2::aod::label<metadata::extension_table_t::ref>()));
+  spawns.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>>(originalTable, o2::aod::label<metadata::extension_table_t::ref>(), spawns.projector));
   spawns.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({spawns.extension->asArrowTable(), originalTable}));
   return true;
 }
@@ -298,6 +300,21 @@ bool prepareOuput(ProcessingContext& context, T& builds)
   return builds.template build<typename T::buildable_t::indexing_t>(builds.pack(), extractOriginals<metadata::sources.size(), metadata::sources>(context));
 }
 
+template <is_defines T>
+bool prepareOutput(ProcessingContext& context, T& defines)
+{
+  using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
+  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context));
+  if (originalTable->schema()->fields().empty() == true) {
+    using base_table_t = typename T::base_table_t::table_t;
+    originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
+  }
+
+  defines.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>>(originalTable, o2::aod::label<metadata::extension_table_t::ref>(), defines.projectors.data(), defines.projector));
+  defines.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({defines.extension->asArrowTable(), originalTable}));
+  return true;
+}
+
 template <typename T>
 bool finalizeOutput(ProcessingContext&, T&)
 {
@@ -333,6 +350,13 @@ bool finalizeOutput(ProcessingContext& context, T& builds)
   return true;
 }
 
+template <is_defines T>
+bool finalizeOutput(ProcessingContext& context, T& defines)
+{
+  context.outputs().adopt(defines.output(), defines.asArrowTable());
+  return true;
+}
+
 /// Service handling
 template <typename T>
 bool addService(std::vector<ServiceSpec>&, T&)
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index b78bf61aea558..bd1a1cfd88954 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -576,7 +576,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
     homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareService(ic, element); }, *task.get());
 
     auto& callbacks = ic.services().get<CallbackService>();
-    auto endofdatacb = [task](EndOfStreamContext& eosContext) {
+    auto eoscb = [task](EndOfStreamContext& eosContext) {
       homogeneous_apply_refs([&eosContext](auto& element) {
           analysis_task_parsers::postRunService(eosContext, element);
           analysis_task_parsers::postRunOutput(eosContext, element);
@@ -585,13 +585,13 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
       eosContext.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     };
 
-    callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
+    callbacks.set<CallbackService::Id::EndOfStream>(eoscb);
 
     /// update configurables in filters and partitions
     homogeneous_apply_refs(
       [&ic](auto& element) -> bool { return analysis_task_parsers::updatePlaceholders(ic, element); },
       *task.get());
-    /// create for filters gandiva trees matched to schemas and store the pointers into expressionInfos
+    /// create expression trees for filters gandiva trees matched to schemas and store the pointers into expressionInfos
     homogeneous_apply_refs([&expressionInfos](auto& element) {
       return analysis_task_parsers::createExpressionTrees(expressionInfos, element);
     },
diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index ff22a35a00a23..1d2883418de71 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -404,6 +404,8 @@ inline Node ifnode(Node&& condition_, Configurable<L1> const& then_, Configurabl
 
 /// A struct, containing the root of the expression tree
 struct Filter {
+  Filter() = default;
+
   Filter(Node&& node_) : node{std::make_unique<Node>(std::forward<Node>(node_))}
   {
     (void)designateSubtrees(node.get());
@@ -413,7 +415,14 @@ struct Filter {
   {
     (void)designateSubtrees(node.get());
   }
-  std::unique_ptr<Node> node;
+
+  Filter& operator=(Filter&& other) noexcept
+  {
+    node = std::move(other.node);
+    return *this;
+  }
+
+  std::unique_ptr<Node> node = nullptr;
 
   size_t designateSubtrees(Node* node, size_t index = 0);
 };
diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index df392f6fbbaf5..32fe78b852eff 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -855,11 +855,41 @@ auto makeEmptyTable(const char* name, framework::pack<Cs...> p)
 }
 
 std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
-                                            expressions::Projector* projectors, std::vector<std::shared_ptr<arrow::Field>> const& fields, const char* name);
+                                            expressions::Projector* projectors, std::vector<std::shared_ptr<arrow::Field>> const& fields, const char* name, std::shared_ptr<gandiva::Projector>& projector);
 
 /// Expression-based column generator to materialize columns
 template <aod::is_aod_hash D>
-auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name)
+  requires(soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
+auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector)
+{
+  using placeholders_pack_t = typename o2::aod::MetadataTrait<D>::metadata::placeholders_pack_t;
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
+  if (fullTable->num_rows() == 0) {
+    return makeEmptyTable(name, placeholders_pack_t{});
+  }
+  static auto fields = o2::soa::createFieldsFromColumns(placeholders_pack_t{});
+  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(placeholders_pack_t{}), projectors, fields, name, projector);
+}
+
+template <aod::is_aod_hash D>
+  requires(soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
+auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector)
+{
+  using placeholders_pack_t = typename o2::aod::MetadataTrait<D>::metadata::placeholders_pack_t;
+  if (fullTable->num_rows() == 0) {
+    return makeEmptyTable(name, placeholders_pack_t{});
+  }
+  static auto fields = o2::soa::createFieldsFromColumns(placeholders_pack_t{});
+  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(placeholders_pack_t{}), projectors, fields, name, projector);
+}
+
+template <aod::is_aod_hash D>
+  requires(soa::has_extension<typename o2::aod::MetadataTrait<D>::metadata> && !soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
+auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, std::shared_ptr<gandiva::Projector>& projector)
 {
   using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
   auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
@@ -874,11 +904,12 @@ auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* na
   }
   (expression_pack_t{});
 
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name);
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name, projector);
 }
 
 template <aod::is_aod_hash D>
-auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name)
+  requires(soa::has_extension<typename o2::aod::MetadataTrait<D>::metadata> && !soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
+auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, std::shared_ptr<gandiva::Projector>& projector)
 {
   using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
   if (fullTable->num_rows() == 0) {
@@ -892,24 +923,11 @@ auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name)
   }
   (expression_pack_t{});
 
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name);
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name, projector);
 }
 
-// template <soa::OriginEnc ORIGIN, typename... C>
-// auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name)
-// {
-//   auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
-//   if (fullTable->num_rows() == 0) {
-//     return makeEmptyTable<soa::Table<ORIGIN, C...>>(name);
-//   }
-//   static auto fields = o2::soa::createFieldsFromColumns(columns);
-//   static auto new_schema = std::make_shared<arrow::Schema>(fields);
-//   std::array<expressions::Projector, sizeof...(C)> projectors{{std::move(C::Projector())...}};
-//   return spawnerHelper(fullTable, new_schema, sizeof...(C), projectors.data(), fields, name);
-// }
-
 template <typename... C>
-auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name)
+auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, std::shared_ptr<gandiva::Projector>& projector)
 {
   auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
   if (fullTable->num_rows() == 0) {
@@ -918,7 +936,7 @@ auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::T
   static auto fields = o2::soa::createFieldsFromColumns(columns);
   static auto new_schema = std::make_shared<arrow::Schema>(fields);
   std::array<expressions::Projector, sizeof...(C)> projectors{{std::move(C::Projector())...}};
-  return spawnerHelper(fullTable, new_schema, sizeof...(C), projectors.data(), fields, name);
+  return spawnerHelper(fullTable, new_schema, sizeof...(C), projectors.data(), fields, name, projector);
 }
 
 template <typename... T>
diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index 6270d07a022e8..c413f2520919d 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -83,53 +83,65 @@ static inline auto extractOriginals(ProcessingContext& pc)
     return {pc.inputs().get<TableConsumer>(o2::aod::label<refs[Is]>())->asArrowTable()...};
   }(std::make_index_sequence<refs.size()>());
 }
+namespace
+{
+template <typename D>
+  requires(D::exclusive)
+auto make_build(D metadata, InputSpec const& input, ProcessingContext& pc)
+{
+  using metadata_t = decltype(metadata);
+  using Key = typename metadata_t::Key;
+  using index_pack_t = typename metadata_t::index_pack_t;
+  constexpr auto sources = metadata_t::sources;
+  return o2::framework::IndexBuilder<o2::framework::Exclusive>::indexBuilder<Key, sources.size(), sources>(input.binding.c_str(),
+                                                                                                           extractOriginals<sources.size(), sources>(pc),
+                                                                                                           index_pack_t{});
+}
+
+template <typename D>
+  requires(!D::exclusive)
+auto make_build(D metadata, InputSpec const& input, ProcessingContext& pc)
+{
+  using metadata_t = decltype(metadata);
+  using Key = typename metadata_t::Key;
+  using index_pack_t = typename metadata_t::index_pack_t;
+  constexpr auto sources = metadata_t::sources;
+  return o2::framework::IndexBuilder<o2::framework::Sparse>::indexBuilder<Key, sources.size(), sources>(input.binding.c_str(),
+                                                                                                        extractOriginals<sources.size(), sources>(pc),
+                                                                                                        index_pack_t{});
+}
+} // namespace
 
 AlgorithmSpec AODReaderHelpers::indexBuilderCallback(std::vector<InputSpec>& requested)
 {
-  return AlgorithmSpec::InitCallback{[requested](InitContext& ic) {
+  return AlgorithmSpec::InitCallback{[requested](InitContext& /*ic*/) {
     return [requested](ProcessingContext& pc) {
       auto outputs = pc.outputs();
       // spawn tables
       for (auto& input : requested) {
         auto&& [origin, description, version] = DataSpecUtils::asConcreteDataMatcher(input);
-        auto maker = [&](auto metadata) {
-          using metadata_t = decltype(metadata);
-          using Key = typename metadata_t::Key;
-          using index_pack_t = typename metadata_t::index_pack_t;
-          constexpr auto sources = metadata_t::sources;
-          if constexpr (metadata_t::exclusive == true) {
-            return o2::framework::IndexBuilder<o2::framework::Exclusive>::indexBuilder<Key, sources.size(), sources>(input.binding.c_str(),
-                                                                                                                     extractOriginals<sources.size(), sources>(pc),
-                                                                                                                     index_pack_t{});
-          } else {
-            return o2::framework::IndexBuilder<o2::framework::Sparse>::indexBuilder<Key, sources.size(), sources>(input.binding.c_str(),
-                                                                                                                  extractOriginals<sources.size(), sources>(pc),
-                                                                                                                  index_pack_t{});
-          }
-        };
-
         if (description == header::DataDescription{"MA_RN2_EX"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::Run2MatchedExclusiveMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run2MatchedExclusiveMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_RN2_SP"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::Run2MatchedSparseMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run2MatchedSparseMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_RN3_EX"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::Run3MatchedExclusiveMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run3MatchedExclusiveMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_RN3_SP"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::Run3MatchedSparseMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run3MatchedSparseMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_BCCOL_EX"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::MatchedBCCollisionsExclusiveMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::MatchedBCCollisionsExclusiveMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_BCCOL_SP"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::MatchedBCCollisionsSparseMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::MatchedBCCollisionsSparseMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_BCCOLS_EX"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::MatchedBCCollisionsExclusiveMultiMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::MatchedBCCollisionsExclusiveMultiMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_BCCOLS_SP"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::MatchedBCCollisionsSparseMultiMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::MatchedBCCollisionsSparseMultiMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_RN3_BC_SP"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::Run3MatchedToBCSparseMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run3MatchedToBCSparseMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_RN3_BC_EX"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::Run3MatchedToBCExclusiveMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run3MatchedToBCExclusiveMetadata{}, input, pc));
         } else if (description == header::DataDescription{"MA_RN2_BC_SP"}) {
-          outputs.adopt(Output{origin, description, version}, maker(o2::aod::Run2MatchedToBCSparseMetadata{}));
+          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run2MatchedToBCSparseMetadata{}, input, pc));
         } else {
           throw std::runtime_error("Not an index table");
         }
@@ -138,6 +150,18 @@ AlgorithmSpec AODReaderHelpers::indexBuilderCallback(std::vector<InputSpec>& req
   }};
 }
 
+namespace
+{
+template <o2::aod::is_aod_hash D>
+auto make_spawn(InputSpec const& input, ProcessingContext& pc)
+{
+  using metadata_t = o2::aod::MetadataTrait<D>::metadata;
+  constexpr auto sources = metadata_t::sources;
+  static std::shared_ptr<gandiva::Projector> projector = nullptr;
+  return o2::framework::spawner<D>(extractOriginals<sources.size(), sources>(pc), input.binding.c_str(), projector);
+}
+} // namespace
+
 AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(std::vector<InputSpec>& requested)
 {
   return AlgorithmSpec::InitCallback{[requested](InitContext& /*ic*/) {
@@ -146,43 +170,37 @@ AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(std::vector<InputSpec>& reque
       // spawn tables
       for (auto& input : requested) {
         auto&& [origin, description, version] = DataSpecUtils::asConcreteDataMatcher(input);
-        auto maker = [&]<o2::aod::is_aod_hash D>() {
-          using metadata_t = o2::aod::MetadataTrait<D>::metadata;
-          constexpr auto sources = metadata_t::sources;
-          return o2::framework::spawner<D>(extractOriginals<sources.size(), sources>(pc), input.binding.c_str());
-        };
-
         if (description == header::DataDescription{"EXTRACK"}) {
-          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACK/0"_h>>());
+          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACK/0"_h>>(input, pc));
         } else if (description == header::DataDescription{"EXTRACK_IU"}) {
-          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACK_IU/0"_h>>());
+          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACK_IU/0"_h>>(input, pc));
         } else if (description == header::DataDescription{"EXTRACKCOV"}) {
-          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKCOV/0"_h>>());
+          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKCOV/0"_h>>(input, pc));
         } else if (description == header::DataDescription{"EXTRACKCOV_IU"}) {
-          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKCOV_IU/0"_h>>());
+          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKCOV_IU/0"_h>>(input, pc));
         } else if (description == header::DataDescription{"EXTRACKEXTRA"}) {
           if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKEXTRA/0"_h>>());
+            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKEXTRA/0"_h>>(input, pc));
           } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKEXTRA/1"_h>>());
+            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKEXTRA/1"_h>>(input, pc));
           } else if (version == 2U) {
-            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXTRACKEXTRA/2"_h>>());
+            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKEXTRA/2"_h>>(input, pc));
           }
         } else if (description == header::DataDescription{"EXMFTTRACK"}) {
           if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXMFTTRACK/0"_h>>());
+            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMFTTRACK/0"_h>>(input, pc));
           } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXMFTTRACK/1"_h>>());
+            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMFTTRACK/1"_h>>(input, pc));
           }
         } else if (description == header::DataDescription{"EXFWDTRACK"}) {
-          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXFWDTRACK/0"_h>>());
+          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXFWDTRACK/0"_h>>(input, pc));
         } else if (description == header::DataDescription{"EXFWDTRACKCOV"}) {
-          outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXFWDTRACKCOV/0"_h>>());
+          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXFWDTRACKCOV/0"_h>>(input, pc));
         } else if (description == header::DataDescription{"EXMCPARTICLE"}) {
           if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXMCPARTICLE/0"_h>>());
+            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMCPARTICLE/0"_h>>(input, pc));
           } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, maker.template operator()<o2::aod::Hash<"EXMCPARTICLE/1"_h>>());
+            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMCPARTICLE/1"_h>>(input, pc));
           }
         } else {
           throw runtime_error("Not an extended table");
diff --git a/Framework/Core/src/TableBuilder.cxx b/Framework/Core/src/TableBuilder.cxx
index 5681568d40ebd..d9827559c2148 100644
--- a/Framework/Core/src/TableBuilder.cxx
+++ b/Framework/Core/src/TableBuilder.cxx
@@ -85,9 +85,12 @@ void TableBuilder::setLabel(const char* label)
 }
 
 std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
-                                            expressions::Projector* projectors, std::vector<std::shared_ptr<arrow::Field>> const& fields, const char* name)
+                                            expressions::Projector* projectors, std::vector<std::shared_ptr<arrow::Field>> const& fields, const char* name,
+                                            std::shared_ptr<gandiva::Projector>& projector)
 {
-  auto mergedProjectors = framework::expressions::createProjectorHelper(nColumns, projectors, fullTable->schema(), fields);
+  if (projector == nullptr) {
+    projector = framework::expressions::createProjectorHelper(nColumns, projectors, fullTable->schema(), fields);
+  }
 
   arrow::TableBatchReader reader(*fullTable);
   std::shared_ptr<arrow::RecordBatch> batch;
@@ -105,7 +108,7 @@ std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const&
       break;
     }
     try {
-      s = mergedProjectors->Evaluate(*batch, arrow::default_memory_pool(), &v);
+      s = projector->Evaluate(*batch, arrow::default_memory_pool(), &v);
       if (!s.ok()) {
         throw runtime_error_f("Cannot apply projector to source table of %s: %s", name, s.ToString().c_str());
       }
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 6c38945039d84..a7e80134a2cc0 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1684,7 +1684,7 @@ int runStateMachine(DataProcessorSpecs const& workflow,
               for (auto& input : device.inputs) {
                 for (auto& param : input.metadata) {
                   if (param.type == VariantType::Bool && param.name.find("control:") != std::string::npos) {
-                    if (param.name != "control:default" && param.name != "control:spawn" && param.name != "control:build") {
+                    if (param.name != "control:default" && param.name != "control:spawn" && param.name != "control:build" && param.name != "control:define") {
                       auto confName = confNameFromParam(param.name).second;
                       param.defaultValue = reg->get<bool>(confName.c_str());
                     }
diff --git a/Framework/Core/test/test_TableSpawner.cxx b/Framework/Core/test/test_TableSpawner.cxx
index 3d8879d115213..2291ba5f4f787 100644
--- a/Framework/Core/test/test_TableSpawner.cxx
+++ b/Framework/Core/test/test_TableSpawner.cxx
@@ -28,10 +28,14 @@ DECLARE_SOA_COLUMN(Y, y, float);
 DECLARE_SOA_COLUMN(Z, z, float);
 DECLARE_SOA_EXPRESSION_COLUMN(Rsq, rsq, float, test::x* test::x + test::y * test::y + test::z * test::z);
 DECLARE_SOA_EXPRESSION_COLUMN(Sin, sin, float, test::x / nsqrt(test::x * test::x + test::y * test::y));
+
+DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(Cfg, cfg, float, "configurable");
 } // namespace test
 
 DECLARE_SOA_TABLE(Points, "AOD", "PTSNG", test::X, test::Y, test::Z);
 DECLARE_SOA_EXTENDED_TABLE(ExPoints, Points, "EXPTSNG", 0, test::Rsq, test::Sin);
+
+DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(ExcPoints, Points, "CFGPTS", test::Cfg);
 } // namespace o2::aod
 
 TEST_CASE("TestTableSpawner")
@@ -46,8 +50,10 @@ TEST_CASE("TestTableSpawner")
   auto t1 = b1.finalize();
   Points st1{t1};
 
+  std::shared_ptr<gandiva::Projector> projector = nullptr;
+
   auto expoints_a = o2::soa::Extend<o2::aod::Points, test::Rsq, test::Sin>(st1);
-  auto extension = ExPointsExtension{o2::framework::spawner<o2::aod::Hash<"EXPTSNG/0"_h>>(t1, o2::aod::Hash<"ExPoints"_h>::str)};
+  auto extension = ExPointsExtension{o2::framework::spawner<o2::aod::Hash<"EXPTSNG/0"_h>>(t1, o2::aod::Hash<"ExPoints"_h>::str, projector)};
   auto expoints = ExPoints{{t1, extension.asArrowTable()}, 0};
 
   REQUIRE(expoints_a.size() == 9);
@@ -71,4 +77,24 @@ TEST_CASE("TestTableSpawner")
     ++rexp;
     ++rexp_a;
   }
+
+  Defines<ExcPoints> excpts;
+  excpts.projectors[0] = test::x * test::x + test::y * test::y + test::z * test::z;
+
+  auto extension_2 = ExcPointsCfgExtension{o2::framework::spawner<o2::aod::Hash<"EXCFGPTS/0"_h>>({t1}, o2::aod::Hash<"ExcPoints"_h>::str, excpts.projectors.data(), excpts.projector)};
+  auto excpoints = ExcPoints{{t1, extension_2.asArrowTable()}, 0};
+
+  rex = extension.begin();
+  auto rex_2 = extension_2.begin();
+  auto rexcp = excpoints.begin();
+
+  for (auto i = 1; i < 10; ++i) {
+    float rsq = i * i * 4 + i * i * 9 + i * i * 16;
+    REQUIRE(rex.rsq() == rsq);
+    REQUIRE(rex_2.cfg() == rsq);
+    REQUIRE(rexcp.cfg() == rsq);
+    ++rex;
+    ++rex_2;
+    ++rexcp;
+  }
 }

From 927ea3919f4334d5278c32b348755ea1fc70076f Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 7 Apr 2025 11:17:54 +0200
Subject: [PATCH 0202/1764] Common: EnumFlags modifications (#14131)

* Common: EnumFlags turn set with empty string into reset

* Common: EnumFlags fix max rep.

* Common: EnumFlags allow ',' as delimiter
---
 Common/Utils/include/CommonUtils/EnumFlags.h | 26 +++++++++++---------
 Common/Utils/test/testEnumFlags.cxx          | 16 ++++++++++++
 2 files changed, 31 insertions(+), 11 deletions(-)

diff --git a/Common/Utils/include/CommonUtils/EnumFlags.h b/Common/Utils/include/CommonUtils/EnumFlags.h
index c4dba607d7804..fcd7d2d9e5e26 100644
--- a/Common/Utils/include/CommonUtils/EnumFlags.h
+++ b/Common/Utils/include/CommonUtils/EnumFlags.h
@@ -154,14 +154,14 @@ struct FlagsHelper final {
     }
     return values;
   }
-  static constexpr auto Values{getValues(std::make_index_sequence<MaxScan - MinScan - MarginScan>())};              // Enum Values
-  static constexpr auto count() noexcept { return Values.size(); }                                                  // Number of enum members
-  static constexpr auto Min_v{Values.front()};                                                                      // Enum first entry
-  static constexpr auto Max_v{Values.back()};                                                                       // Enum last entry
-  static constexpr auto Min_u_v{static_cast<size_t>(Min_v)};                                                        // Enum first entry as size_t
-  static constexpr auto Max_u_v{static_cast<size_t>(Max_v)};                                                        // Enum last entry as size_t
-  static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); }                      // Is the enum continuous
-  static constexpr uint64_t MaxRep{(Max_u_v >= 64) ? std::numeric_limits<uint64_t>::max() : (1ULL << Max_u_v) - 1}; // largest representable value
+  static constexpr auto Values{getValues(std::make_index_sequence<MaxScan - MinScan - MarginScan>())}; // Enum Values
+  static constexpr auto count() noexcept { return Values.size(); }                                     // Number of enum members
+  static constexpr auto Min_v{Values.front()};                                                         // Enum first entry
+  static constexpr auto Max_v{Values.back()};                                                          // Enum last entry
+  static constexpr auto Min_u_v{static_cast<size_t>(Min_v)};                                           // Enum first entry as size_t
+  static constexpr auto Max_u_v{static_cast<size_t>(Max_v)};                                           // Enum last entry as size_t
+  static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); }         // Is the enum continuous
+  static constexpr auto MaxRep{((1 << (Max_u_v - Min_u_v + 1)) - 1) << Min_u_v};                       // largest representable value
 
   template <E e>
   static constexpr std::string_view getName()
@@ -398,11 +398,14 @@ class EnumFlags
   // Sets flags from a string representation.
   // This can be either from a number representation (binary or digits) or
   // a concatenation of the enums members name e.g., 'Enum1|Enum2|...'
-  void set(const std::string& s, int base = 2)
+  void set(const std::string& s = "", int base = 2)
   {
     // on throw restore previous state and rethrow
     const U prev = mBits;
     reset();
+    if (s.empty()) { // no-op
+      return;
+    }
     try {
       setImpl(s, base);
     } catch (const std::exception& e) {
@@ -665,7 +668,7 @@ class EnumFlags
         throw std::out_of_range("Values exceeds enum range.");
       }
       mBits = static_cast<U>(v);
-    } else if (std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isalnum(c) != 0 || c == '|' || c == ' ' || c == ':'; })) {
+    } else if (std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isalnum(c) != 0 || c == '|' || c == ' ' || c == ':' || c == ','; })) {
       std::string cs{s};
       std::transform(cs.begin(), cs.end(), cs.begin(), [](unsigned char c) { return std::tolower(c); });
       if (cs == H::All) {
@@ -673,7 +676,8 @@ class EnumFlags
       } else if (cs == H::None) {
         mBits = None;
       } else {
-        for (const auto& tok : Str::tokenize(s, '|')) {
+        char token = (s.find(',') != std::string::npos) ? ',' : '|';
+        for (const auto& tok : Str::tokenize(s, token)) {
           if (auto e = H::fromString(tok)) {
             mBits |= to_bit(*e);
           } else {
diff --git a/Common/Utils/test/testEnumFlags.cxx b/Common/Utils/test/testEnumFlags.cxx
index 2838d09b2e6a3..5c8b71eb9040a 100644
--- a/Common/Utils/test/testEnumFlags.cxx
+++ b/Common/Utils/test/testEnumFlags.cxx
@@ -34,6 +34,8 @@ BOOST_AUTO_TEST_CASE(Flags_test)
 
   // Test default initialization
   EFlags flags;
+  BOOST_TEST(flags.None == 0);
+  BOOST_TEST(flags.All == 31);
   BOOST_TEST(flags.value() == 0);
   BOOST_TEST(!flags.any());
 
@@ -139,6 +141,20 @@ BOOST_AUTO_TEST_CASE(Flags_test)
       BOOST_TEST(flags.test(TestEnum::Bit4));
     }
 
+    { // test with different delimiter
+      std::string str = "Bit4,TestEnum::Bit2 , Bit1 ";
+      flags.set(str);
+      BOOST_TEST(flags.test(TestEnum::Bit1));
+      BOOST_TEST(flags.test(TestEnum::Bit2));
+      BOOST_TEST(!flags.test(TestEnum::Bit3));
+      BOOST_TEST(flags.test(TestEnum::Bit4));
+    }
+
+    { // throw test with mixed delimiter
+      std::string str = "Bit4|TestEnum::Bit2 , Bit1 ";
+      BOOST_CHECK_THROW(flags.set(str), std::invalid_argument);
+    }
+
     { // test throw
       std::string str = "Invalid";
       BOOST_CHECK_THROW(flags.set(str), std::invalid_argument);

From 436c0b0d6c585ff76a9d9797fd5dbcf6526f4500 Mon Sep 17 00:00:00 2001
From: sawan <sawankumawat4@gmail.com>
Date: Mon, 3 Feb 2025 20:14:06 +0530
Subject: [PATCH 0203/1764] added particle f2(1270)

---
 .../simulation/include/SimulationDataFormat/O2DatabasePDG.h   | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h b/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
index 6b1690946e951..0ee5c06a74411 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
@@ -490,6 +490,10 @@ inline void O2DatabasePDG::addALICEParticles(TDatabasePDG* db)
   }
 
   // glueball hunting
+  ionCode = 225;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("f2_1270", "f2_1270", 1.2754, kFALSE, 0.1858, 0, "Resonance", ionCode);
+  }
   ionCode = 115;
   if (!db->GetParticle(ionCode)) {
     db->AddParticle("a2_1320", "a2_1320", 1.3182, kFALSE, 0.1078, 0, "Resonance", ionCode);

From cadc5fa33d7eb8f28551a5f83c65d833d97ced16 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 7 Apr 2025 13:46:28 +0200
Subject: [PATCH 0204/1764] Common: DCAFitter add fit status code (#14132)

* Common: DCAFitter add fit status code

* Common: DCAFitter add test/summary of stats

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Common: DCAFitter catch maxIter reached

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Common: DCAFitter fix spell

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Common: DCAFitter simplify exp.-backoff of logging

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../DCAFitter/include/DCAFitter/DCAFitterN.h  | 144 ++++++++++++------
 Common/DCAFitter/test/testDCAFitterN.cxx      |  49 +++++-
 2 files changed, 148 insertions(+), 45 deletions(-)

diff --git a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
index 97ea6d206247b..569b3ea49e515 100644
--- a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
+++ b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
@@ -75,21 +75,20 @@ struct TrackDeriv {
 ///< Log log-throttling helper
 struct LogLogThrottler {
   size_t evCount{0};
-  size_t evCountPrev{0};
-  size_t logCount{0};
-
+  size_t nextLog{1};
   GPUdi() bool needToLog()
   {
-    if (size_t(o2::gpu::GPUCommonMath::Log(++evCount)) + 1 > logCount) {
-      logCount++;
+    if (++evCount > nextLog) {
+      nextLog *= 2;
       return true;
     }
     return false;
   }
-
-  GPUdi() size_t getNMuted() const { return evCount - evCountPrev - 1; }
-
-  GPUdi() void clear() { evCount = evCountPrev = logCount = 0; }
+  GPUdi() void clear()
+  {
+    evCount = 0;
+    nextLog = 1;
+  }
 };
 
 template <int N, typename... Args>
@@ -118,10 +117,31 @@ class DCAFitterN
   using ArrTrPos = o2::gpu::gpustd::array<Vec3D, N>;         // container of Track positions
 
  public:
-  enum BadCovPolicy {   // if encountering non-positive defined cov. matrix, the choice is:
-    Discard = 0,        // stop evaluation
-    Override = 1,       // override correlation coef. to have cov.matrix pos.def and continue
-    OverrideAndFlag = 2 // override correlation coef. to have cov.matrix pos.def, set mPropFailed flag of corresponding candidate to true and continue (up to the user to check the flag)
+  enum BadCovPolicy : uint8_t { // if encountering non-positive defined cov. matrix, the choice is:
+    Discard = 0,                // stop evaluation
+    Override = 1,               // override correlation coef. to have cov.matrix pos.def and continue
+    OverrideAndFlag = 2         // override correlation coef. to have cov.matrix pos.def, set mPropFailed flag of corresponding candidate to true and continue (up to the user to check the flag)
+  };
+
+  enum FitStatus : uint8_t { // fit status of crossing hypothesis
+    None,                    // no status set (should not be possible!)
+
+    /* Good Conditions */
+    Converged, // fit converged
+    MaxIter,   // max iterations reached before fit convergence
+
+    /* Error Conditions */
+    NoCrossing,      // no reasaonable crossing was found
+    RejRadius,       // radius of crossing was not acceptable
+    RejTrackX,       // one candidate track x was below the mimimum required radius
+    RejTrackRoughZ,  // rejected by rough cut on tracks Z difference
+    RejChi2Max,      // rejected by maximum chi2 cut
+    FailProp,        // propagation of at least prong to PCA failed
+    FailInvCov,      // inversion of cov.-matrix failed
+    FailInvWeight,   // inversion of Ti weight matrix failed
+    FailInv2ndDeriv, // inversion of 2nd derivatives failed
+    FailCorrTracks,  // correction of tracks to updated x failed
+    FailCloserAlt,   // alternative PCA is closer
   };
 
   static constexpr int getNProngs() { return N; }
@@ -154,7 +174,7 @@ class DCAFitterN
   ///< check if propagation of tracks to candidate vertex was done
   GPUd() bool isPropagateTracksToVertexDone(int cand = 0) const { return mTrPropDone[mOrder[cand]]; }
 
-  ///< check if propagation of tracks to candidate vertex was done
+  ///< check if propagation of tracks to candidate vertex failed
   bool isPropagationFailure(int cand = 0) const { return mPropFailed[mOrder[cand]]; }
 
   ///< track param propagated to V0 candidate (no check for the candidate validity)
@@ -201,6 +221,8 @@ class DCAFitterN
 
   const Track* getOrigTrackPtr(int i) const { return mOrigTrPtr[i]; }
 
+  GPUdi() FitStatus getFitStatus(int cand = 0) const noexcept { return mFitStatus[mOrder[cand]]; }
+
   ///< return number of iterations during minimization (no check for its validity)
   GPUdi() int getNIterations(int cand = 0) const { return mNIters[mOrder[cand]]; }
   GPUdi() void setPropagateToPCA(bool v = true) { mPropagateToPCA = v; }
@@ -315,6 +337,12 @@ class DCAFitterN
   {
     mCurHyp = 0;
     mAllowAltPreference = true;
+    mOrder.fill(0);
+    mPropFailed.fill(false);
+    mTrPropDone.fill(false);
+    mNIters.fill(0);
+    mChi2.fill(-1);
+    mFitStatus.fill(FitStatus::None);
   }
 
   GPUdi() static void setTrackPos(Vec3D& pnt, const Track& tr)
@@ -362,12 +390,13 @@ class DCAFitterN
   LogLogThrottler mLoggerBadCov{};
   LogLogThrottler mLoggerBadInv{};
   LogLogThrottler mLoggerBadProp{};
-  MatSym3D mWeightInv;                                   // inverse weight of single track, [sum{M^T E M}]^-1 in EQ.T
+  MatSym3D mWeightInv; // inverse weight of single track, [sum{M^T E M}]^-1 in EQ.T
   o2::gpu::gpustd::array<int, MAXHYP> mOrder{0};
   int mCurHyp = 0;
   int mCrossIDCur = 0;
   int mCrossIDAlt = -1;
   BadCovPolicy mBadCovPolicy{BadCovPolicy::Discard};                                              // what to do in case of non-pos-def. cov. matrix, see BadCovPolicy enum
+  o2::gpu::gpustd::array<FitStatus, MAXHYP> mFitStatus{};                                         // fit status of each hypothesis fit
   bool mAllowAltPreference = true;                                                                // if the fit converges to alternative PCA seed, abandon the current one
   bool mUseAbsDCA = false;                                                                        // use abs. distance minimization rather than chi2
   bool mWeightedFinalPCA = false;                                                                 // recalculate PCA as a cov-matrix weighted mean, even if absDCA method was used
@@ -390,7 +419,7 @@ class DCAFitterN
   float mMaxStep = 2.0;                                                                           // Max step for propagation with Propagator
   int mFitterID = 0;                                                                              // locat fitter ID (mostly for debugging)
   size_t mCallID = 0;
-  ClassDefNV(DCAFitterN, 2);
+  ClassDefNV(DCAFitterN, 3);
 };
 
 ///_________________________________________________________________________
@@ -407,10 +436,8 @@ GPUd() int DCAFitterN<N, Args...>::process(const Tr&... args)
     mTrAux[i].set(*mOrigTrPtr[i], mBz);
   }
   if (!mCrossings.set(mTrAux[0], *mOrigTrPtr[0], mTrAux[1], *mOrigTrPtr[1], mMaxDXYIni, mIsCollinear)) { // even for N>2 it should be enough to test just 1 loop
-    return 0;                                                                                            // no crossing
-  }
-  for (int ih = 0; ih < MAXHYP; ih++) {
-    mPropFailed[ih] = false;
+    mFitStatus[mCurHyp] = FitStatus::NoCrossing;
+    return 0;
   }
   if (mUseAbsDCA) {
     calcRMatrices(); // needed for fast residuals derivatives calculation in case of abs. distance minimization
@@ -428,13 +455,11 @@ GPUd() int DCAFitterN<N, Args...>::process(const Tr&... args)
   for (int ic = 0; ic < mCrossings.nDCA; ic++) {
     // check if radius is acceptable
     if (mCrossings.xDCA[ic] * mCrossings.xDCA[ic] + mCrossings.yDCA[ic] * mCrossings.yDCA[ic] > mMaxR2) {
+      mFitStatus[mCurHyp] = FitStatus::RejRadius;
       continue;
     }
     mCrossIDCur = ic;
     mCrossIDAlt = (mCrossings.nDCA == 2 && mAllowAltPreference) ? 1 - ic : -1; // works for max 2 crossings
-    mNIters[mCurHyp] = 0;
-    mTrPropDone[mCurHyp] = false;
-    mChi2[mCurHyp] = -1.;
     mPCA[mCurHyp][0] = mCrossings.xDCA[ic];
     mPCA[mCurHyp][1] = mCrossings.yDCA[ic];
 
@@ -468,6 +493,7 @@ GPUd() bool DCAFitterN<N, Args...>::calcPCACoefs()
 {
   //< calculate Ti matrices for global vertex decomposition to V = sum_{0<i<N} Ti pi, see EQ.T in the ref
   if (!calcInverseWeight()) {
+    mFitStatus[mCurHyp] = FitStatus::FailInvWeight;
     return false;
   }
   for (int i = N; i--;) { // build Mi*Ei matrix
@@ -720,13 +746,13 @@ GPUd() bool DCAFitterN<N, Args...>::recalculatePCAWithErrors(int cand)
         if (mLoggerBadCov.needToLog()) {
 #ifndef GPUCA_GPUCODE
           printf("fitter %d: error (%ld muted): overrode invalid track covariance from %s\n",
-                 mFitterID, mLoggerBadCov.getNMuted(), mCandTr[mCurHyp][i].asString().c_str());
+                 mFitterID, mLoggerBadCov.evCount, mCandTr[mCurHyp][i].asString().c_str());
 #else
           printf("fitter %d: error (%ld muted): overrode invalid track covariance cyy:%e czz:%e cyz:%e\n",
-                 mFitterID, mLoggerBadCov.getNMuted(), mCandTr[mCurHyp][i].getSigmaY2(), mCandTr[mCurHyp][i].getSigmaZ2(), mCandTr[mCurHyp][i].getSigmaZY());
+                 mFitterID, mLoggerBadCov.evCount, mCandTr[mCurHyp][i].getSigmaY2(), mCandTr[mCurHyp][i].getSigmaZ2(), mCandTr[mCurHyp][i].getSigmaZY());
 #endif
-          mLoggerBadCov.evCountPrev = mLoggerBadCov.evCount;
         }
+        mFitStatus[mCurHyp] = FitStatus::FailInvCov;
         if (mBadCovPolicy == Discard) {
           return false;
         } else if (mBadCovPolicy == OverrideAndFlag) {
@@ -935,21 +961,25 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2()
   for (int i = N; i--;) {
     mCandTr[mCurHyp][i] = *mOrigTrPtr[i];
     auto x = mTrAux[i].c * mPCA[mCurHyp][0] + mTrAux[i].s * mPCA[mCurHyp][1]; // X of PCA in the track frame
-    if (x < mMinXSeed || !propagateToX(mCandTr[mCurHyp][i], x)) {
+    if (x < mMinXSeed) {
+      mFitStatus[mCurHyp] = FitStatus::RejTrackX;
       return false;
     }
-    setTrackPos(mTrPos[mCurHyp][i], mCandTr[mCurHyp][i]);      // prepare positions
+    if (!propagateToX(mCandTr[mCurHyp][i], x)) {
+      return false;
+    }
+    setTrackPos(mTrPos[mCurHyp][i], mCandTr[mCurHyp][i]);             // prepare positions
     if (!mTrcEInv[mCurHyp][i].set(mCandTr[mCurHyp][i], XerrFactor)) { // prepare inverse cov.matrices at starting point
       if (mLoggerBadCov.needToLog()) {
 #ifndef GPUCA_GPUCODE
         printf("fitter %d: error (%ld muted): overrode invalid track covariance from %s\n",
-               mFitterID, mLoggerBadCov.getNMuted(), mCandTr[mCurHyp][i].asString().c_str());
+               mFitterID, mLoggerBadCov.evCount, mCandTr[mCurHyp][i].asString().c_str());
 #else
         printf("fitter %d: error (%ld muted): overrode invalid track covariance cyy:%e czz:%e cyz:%e\n",
-               mFitterID, mLoggerBadCov.getNMuted(), mCandTr[mCurHyp][i].getSigmaY2(), mCandTr[mCurHyp][i].getSigmaZ2(), mCandTr[mCurHyp][i].getSigmaZY());
+               mFitterID, mLoggerBadCov.evCount, mCandTr[mCurHyp][i].getSigmaY2(), mCandTr[mCurHyp][i].getSigmaZ2(), mCandTr[mCurHyp][i].getSigmaZY());
 #endif
-        mLoggerBadCov.evCountPrev = mLoggerBadCov.evCount;
       }
+      mFitStatus[mCurHyp] = FitStatus::FailInvCov;
       if (mBadCovPolicy == Discard) {
         return false;
       } else if (mBadCovPolicy == OverrideAndFlag) {
@@ -959,6 +989,7 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2()
   }
 
   if (mMaxDZIni > 0 && !roughDZCut()) { // apply rough cut on tracks Z difference
+    mFitStatus[mCurHyp] = FitStatus::RejTrackX;
     return false;
   }
 
@@ -976,17 +1007,19 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2()
     // do Newton-Rapson iteration with corrections = - dchi2/d{x0..xN} * [ d^2chi2/d{x0..xN}^2 ]^-1
     if (!mD2Chi2Dx2.Invert()) {
       if (mLoggerBadInv.needToLog()) {
-        printf("fitter %d: error (%ld muted): Inversion failed\n", mFitterID, mLoggerBadCov.getNMuted());
-        mLoggerBadInv.evCountPrev = mLoggerBadInv.evCount;
+        printf("fitter %d: error (%ld muted): Inversion failed\n", mFitterID, mLoggerBadCov.evCount);
       }
+      mFitStatus[mCurHyp] = FitStatus::FailInv2ndDeriv;
       return false;
     }
     VecND dx = mD2Chi2Dx2 * mDChi2Dx;
     if (!correctTracks(dx)) {
+      mFitStatus[mCurHyp] = FitStatus::FailCorrTracks;
       return false;
     }
     calcPCA(); // updated PCA
     if (mCrossIDAlt >= 0 && closerToAlternative()) {
+      mFitStatus[mCurHyp] = FitStatus::FailCloserAlt;
       mAllowAltPreference = false;
       return false;
     }
@@ -994,13 +1027,21 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2()
     chi2Upd = calcChi2(); // updated chi2
     if (getAbsMax(dx) < mMinParamChange || chi2Upd > chi2 * mMinRelChi2Change) {
       chi2 = chi2Upd;
+      mFitStatus[mCurHyp] = FitStatus::Converged;
       break; // converged
     }
     chi2 = chi2Upd;
   } while (++mNIters[mCurHyp] < mMaxIter);
+  if (mNIters[mCurHyp] == mMaxIter) {
+    mFitStatus[mCurHyp] = FitStatus::MaxIter;
+  }
   //
   mChi2[mCurHyp] = chi2 * NInv;
-  return mChi2[mCurHyp] < mMaxChi2;
+  if (mChi2[mCurHyp] >= mMaxChi2) {
+    mFitStatus[mCurHyp] = FitStatus::RejChi2Max;
+    return false;
+  }
+  return true;
 }
 
 //___________________________________________________________________
@@ -1012,12 +1053,17 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2NoErr()
   for (int i = N; i--;) {
     mCandTr[mCurHyp][i] = *mOrigTrPtr[i];
     auto x = mTrAux[i].c * mPCA[mCurHyp][0] + mTrAux[i].s * mPCA[mCurHyp][1]; // X of PCA in the track frame
-    if (x < mMinXSeed || !propagateParamToX(mCandTr[mCurHyp][i], x)) {
+    if (x < mMinXSeed) {
+      mFitStatus[mCurHyp] = FitStatus::RejTrackX;
+      return false;
+    }
+    if (!propagateParamToX(mCandTr[mCurHyp][i], x)) {
       return false;
     }
     setTrackPos(mTrPos[mCurHyp][i], mCandTr[mCurHyp][i]); // prepare positions
   }
   if (mMaxDZIni > 0 && !roughDZCut()) { // apply rough cut on tracks Z difference
+    mFitStatus[mCurHyp] = FitStatus::RejTrackX;
     return false;
   }
 
@@ -1032,17 +1078,19 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2NoErr()
     // do Newton-Rapson iteration with corrections = - dchi2/d{x0..xN} * [ d^2chi2/d{x0..xN}^2 ]^-1
     if (!mD2Chi2Dx2.Invert()) {
       if (mLoggerBadInv.needToLog()) {
-        printf("itter %d: error (%ld muted): Inversion failed\n", mFitterID, mLoggerBadCov.getNMuted());
-        mLoggerBadInv.evCountPrev = mLoggerBadInv.evCount;
+        printf("fitter %d: error (%ld muted): Inversion failed\n", mFitterID, mLoggerBadCov.evCount);
       }
+      mFitStatus[mCurHyp] = FitStatus::FailInv2ndDeriv;
       return false;
     }
     VecND dx = mD2Chi2Dx2 * mDChi2Dx;
     if (!correctTracks(dx)) {
+      mFitStatus[mCurHyp] = FitStatus::FailCorrTracks;
       return false;
     }
     calcPCANoErr(); // updated PCA
     if (mCrossIDAlt >= 0 && closerToAlternative()) {
+      mFitStatus[mCurHyp] = FitStatus::FailCloserAlt;
       mAllowAltPreference = false;
       return false;
     }
@@ -1050,13 +1098,21 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2NoErr()
     chi2Upd = calcChi2NoErr(); // updated chi2
     if (getAbsMax(dx) < mMinParamChange || chi2Upd > chi2 * mMinRelChi2Change) {
       chi2 = chi2Upd;
+      mFitStatus[mCurHyp] = FitStatus::Converged;
       break; // converged
     }
     chi2 = chi2Upd;
   } while (++mNIters[mCurHyp] < mMaxIter);
+  if (mNIters[mCurHyp] == mMaxIter) {
+    mFitStatus[mCurHyp] = FitStatus::MaxIter;
+  }
   //
   mChi2[mCurHyp] = chi2 * NInv;
-  return mChi2[mCurHyp] < mMaxChi2;
+  if (mChi2[mCurHyp] >= mMaxChi2) {
+    mFitStatus[mCurHyp] = FitStatus::RejChi2Max;
+    return false;
+  }
+  return true;
 }
 
 //___________________________________________________________________
@@ -1182,14 +1238,14 @@ GPUdi() bool DCAFitterN<N, Args...>::propagateParamToX(o2::track::TrackPar& t, f
     res = t.propagateParamTo(x, mBz);
   }
   if (!res) {
+    mFitStatus[mCurHyp] = FitStatus::FailProp;
     mPropFailed[mCurHyp] = true;
     if (mLoggerBadProp.needToLog()) {
 #ifndef GPUCA_GPUCODE
-      printf("fitter %d: error (%ld muted): propagation failed for %s\n", mFitterID, mLoggerBadProp.getNMuted(), t.asString().c_str());
+      printf("fitter %d: error (%ld muted): propagation failed for %s\n", mFitterID, mLoggerBadProp.evCount, t.asString().c_str());
 #else
-      printf("fitter %d: error (%ld muted): propagation failed\n", mFitterID, mLoggerBadProp.getNMuted());
+      printf("fitter %d: error (%ld muted): propagation failed\n", mFitterID, mLoggerBadProp.evCount);
 #endif
-      mLoggerBadProp.evCountPrev = mLoggerBadProp.evCount;
     }
   }
   return res;
@@ -1208,14 +1264,14 @@ GPUdi() bool DCAFitterN<N, Args...>::propagateToX(o2::track::TrackParCov& t, flo
     res = t.propagateTo(x, mBz);
   }
   if (!res) {
+    mFitStatus[mCurHyp] = FitStatus::FailProp;
     mPropFailed[mCurHyp] = true;
     if (mLoggerBadProp.needToLog()) {
 #ifndef GPUCA_GPUCODE
-      printf("fitter %d: error (%ld muted): propagation failed for %s\n", mFitterID, mLoggerBadProp.getNMuted(), t.asString().c_str());
+      printf("fitter %d: error (%ld muted): propagation failed for %s\n", mFitterID, mLoggerBadProp.evCount, t.asString().c_str());
 #else
-      printf("fitter %d: error (%ld muted): propagation failed\n", mFitterID, mLoggerBadProp.getNMuted());
+      printf("fitter %d: error (%ld muted): propagation failed\n", mFitterID, mLoggerBadProp.evCount);
 #endif
-      mLoggerBadProp.evCountPrev = mLoggerBadProp.evCount;
     }
   }
   return res;
diff --git a/Common/DCAFitter/test/testDCAFitterN.cxx b/Common/DCAFitter/test/testDCAFitterN.cxx
index a102a0a4253e3..bd00b5bed841e 100644
--- a/Common/DCAFitter/test/testDCAFitterN.cxx
+++ b/Common/DCAFitter/test/testDCAFitterN.cxx
@@ -134,7 +134,7 @@ TLorentzVector generate(Vec3D& vtx, std::vector<o2::track::TrackParCov>& vctr, f
       float rad = forceQ[i] == 0 ? 600. : TMath::Abs(1. / trc.getCurvature(bz));
       if (!trc.propagateTo(trc.getX() + (gRandom->Rndm() - 0.5) * rad * 0.05, bz) ||
           !trc.rotate(trc.getAlpha() + (gRandom->Rndm() - 0.5) * 0.2)) {
-        printf("Failed to randomize ");
+        LOGP(error, "Failed to randomize ");
         trc.print();
       }
     }
@@ -143,6 +143,22 @@ TLorentzVector generate(Vec3D& vtx, std::vector<o2::track::TrackParCov>& vctr, f
   return parent;
 }
 
+static constexpr int NFitStatus{14};
+using FitStatusArray = std::array<std::array<int, 3>, NFitStatus>;
+static constexpr const char* FitStatusNames[NFitStatus] = {
+  "None", "Converged", "MaxIter", "NoCrossing", "RejRadius", "RejTrackX", "RejTrackRoughZ", "RejChi2Max",
+  "FailProp", "FailInvConv", "FailInvWeight", "FailInv2ndDeriv", "FailCorrTracks", "FailCloserAlt"};
+inline void printStat(const FitStatusArray& a)
+{
+  LOGP(info, "FitStatus summary      : ....A / ..AWD / ...WD (A=abs.dist;AWD=abs.wghPCA.dist;WD=wgh.dist)");
+  for (int i{0}; i < NFitStatus; ++i) {
+    LOGP(info, "{:2d}={:20s}: {:5d} / {:5d} / {:5d}", i, FitStatusNames[i], a[i][0], a[i][1], a[i][2]);
+  }
+  BOOST_CHECK(a[0][0] == 0); // ensure coverage of all possible states
+  BOOST_CHECK(a[0][1] == 0);
+  BOOST_CHECK(a[0][2] == 0);
+}
+
 BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
 {
   constexpr int NTest = 10000;
@@ -159,6 +175,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
   std::vector<double> k0dec = {pion, pion};
   std::vector<double> dchdec = {pion, kch, pion};
   std::vector<o2::track::TrackParCov> vctracks;
+  FitStatusArray fitstat;
   Vec3D vtxGen;
 
   double bz = 5.0;
@@ -166,6 +183,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
   {
     LOG(info) << "\n\nProcessing 2-prong Helix - Helix case";
     std::vector<int> forceQ{1, 1};
+    std::memset(fitstat.data(), 0, sizeof(fitstat));
 
     o2::vertexing::DCAFitterN<2> ft; // 2 prong fitter
     ft.setBz(bz);
@@ -196,6 +214,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDA += minD;
         nfoundA++;
       }
+      ++fitstat[ft.getFitStatus()][0];
 
       ft.setUseAbsDCA(true);
       ft.setWeightedFinalPCA(true);
@@ -208,6 +227,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDAW += minD;
         nfoundAW++;
       }
+      ++fitstat[ft.getFitStatus()][1];
 
       ft.setUseAbsDCA(false);
       ft.setWeightedFinalPCA(false);
@@ -220,6 +240,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDW += minD;
         nfoundW++;
       }
+      ++fitstat[ft.getFitStatus()][2];
     }
     // ft.print();
     meanDA /= nfoundA ? nfoundA : 1;
@@ -232,6 +253,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
               << " mean.dist to truth: " << meanDAW << " CPU time: " << swAW.CpuTime() * 1000 << " ms";
     LOG(info) << "2-prongs with wgh.dist minization: eff= " << float(nfoundW) / NTest
               << " mean.dist to truth: " << meanDW << " CPU time: " << swW.CpuTime() * 1000 << " ms";
+    printStat(fitstat);
     BOOST_CHECK(nfoundA > 0.99 * NTest);
     BOOST_CHECK(nfoundAW > 0.99 * NTest);
     BOOST_CHECK(nfoundW > 0.99 * NTest);
@@ -245,6 +267,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
   {
     LOG(info) << "\n\nProcessing 2-prong Helix - Helix case gamma conversion";
     std::vector<int> forceQ{1, 1};
+    std::memset(fitstat.data(), 0, sizeof(fitstat));
 
     o2::vertexing::DCAFitterN<2> ft; // 2 prong fitter
     ft.setBz(bz);
@@ -254,6 +277,8 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
     ft.setMaxDXYIni(4);          // do not consider V0 seeds with tracks XY-distance exceeding this. This is default anyway
     ft.setMinParamChange(1e-3);  // stop iterations if max correction is below this value. This is default anyway
     ft.setMinRelChi2Change(0.9); // stop iterations if chi2 improves by less that this factor
+    ft.setMaxChi2();
+    ft.setCollinear(true);
 
     std::string treeName2A = "gpr2a", treeName2AW = "gpr2aw", treeName2W = "gpr2w";
     TStopwatch swA, swAW, swW;
@@ -275,6 +300,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDA += minD;
         nfoundA++;
       }
+      ++fitstat[ft.getFitStatus()][0];
 
       ft.setUseAbsDCA(true);
       ft.setWeightedFinalPCA(true);
@@ -287,6 +313,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDAW += minD;
         nfoundAW++;
       }
+      ++fitstat[ft.getFitStatus()][1];
 
       ft.setUseAbsDCA(false);
       ft.setWeightedFinalPCA(false);
@@ -299,6 +326,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDW += minD;
         nfoundW++;
       }
+      ++fitstat[ft.getFitStatus()][2];
     }
     // ft.print();
     meanDA /= nfoundA ? nfoundA : 1;
@@ -311,6 +339,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
               << " mean.dist to truth: " << meanDAW << " CPU time: " << swAW.CpuTime() * 1000 << " ms";
     LOG(info) << "2-prongs with wgh.dist minization: eff= " << float(nfoundW) / NTest
               << " mean.dist to truth: " << meanDW << " CPU time: " << swW.CpuTime() * 1000 << " ms";
+    printStat(fitstat);
     BOOST_CHECK(nfoundA > 0.99 * NTest);
     BOOST_CHECK(nfoundAW > 0.99 * NTest);
     BOOST_CHECK(nfoundW > 0.99 * NTest);
@@ -324,6 +353,8 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
   {
     std::vector<int> forceQ{1, 1};
     LOG(info) << "\n\nProcessing 2-prong Helix - Line case";
+    std::memset(fitstat.data(), 0, sizeof(fitstat));
+
     o2::vertexing::DCAFitterN<2> ft; // 2 prong fitter
     ft.setBz(bz);
     ft.setPropagateToPCA(true);  // After finding the vertex, propagate tracks to the DCA. This is default anyway
@@ -354,6 +385,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDA += minD;
         nfoundA++;
       }
+      ++fitstat[ft.getFitStatus()][0];
 
       ft.setUseAbsDCA(true);
       ft.setWeightedFinalPCA(true);
@@ -366,6 +398,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDAW += minD;
         nfoundAW++;
       }
+      ++fitstat[ft.getFitStatus()][1];
 
       ft.setUseAbsDCA(false);
       ft.setWeightedFinalPCA(false);
@@ -378,6 +411,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDW += minD;
         nfoundW++;
       }
+      ++fitstat[ft.getFitStatus()][2];
     }
     // ft.print();
     meanDA /= nfoundA ? nfoundA : 1;
@@ -390,6 +424,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
               << " mean.dist to truth: " << meanDAW << " CPU time: " << swAW.CpuTime() * 1000 << " ms";
     LOG(info) << "2-prongs with wgh.dist minization: eff= " << float(nfoundW) / NTest
               << " mean.dist to truth: " << meanDW << " CPU time: " << swW.CpuTime() * 1000 << " ms";
+    printStat(fitstat);
     BOOST_CHECK(nfoundA > 0.99 * NTest);
     BOOST_CHECK(nfoundAW > 0.99 * NTest);
     BOOST_CHECK(nfoundW > 0.99 * NTest);
@@ -403,6 +438,8 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
   {
     std::vector<int> forceQ{0, 0};
     LOG(info) << "\n\nProcessing 2-prong Line - Line case";
+    std::memset(fitstat.data(), 0, sizeof(fitstat));
+
     o2::vertexing::DCAFitterN<2> ft; // 2 prong fitter
     ft.setBz(bz);
     ft.setPropagateToPCA(true);  // After finding the vertex, propagate tracks to the DCA. This is default anyway
@@ -432,6 +469,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDA += minD;
         nfoundA++;
       }
+      ++fitstat[ft.getFitStatus()][0];
 
       ft.setUseAbsDCA(true);
       ft.setWeightedFinalPCA(true);
@@ -444,6 +482,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDAW += minD;
         nfoundAW++;
       }
+      ++fitstat[ft.getFitStatus()][1];
 
       ft.setUseAbsDCA(false);
       ft.setWeightedFinalPCA(false);
@@ -456,6 +495,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDW += minD;
         nfoundW++;
       }
+      ++fitstat[ft.getFitStatus()][2];
     }
     // ft.print();
     meanDA /= nfoundA ? nfoundA : 1;
@@ -468,6 +508,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
               << " mean.dist to truth: " << meanDAW << " CPU time: " << swAW.CpuTime() * 1000 << " ms";
     LOG(info) << "2-prongs with wgh.dist minization: eff= " << float(nfoundW) / NTest
               << " mean.dist to truth: " << meanDW << " CPU time: " << swW.CpuTime() * 1000 << " ms";
+    printStat(fitstat);
     BOOST_CHECK(nfoundA > 0.99 * NTest);
     BOOST_CHECK(nfoundAW > 0.99 * NTest);
     BOOST_CHECK(nfoundW > 0.99 * NTest);
@@ -481,6 +522,8 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
   {
     LOG(info) << "\n\nProcessing 3-prong vertices";
     std::vector<int> forceQ{1, 1, 1};
+    std::memset(fitstat.data(), 0, sizeof(fitstat));
+
     o2::vertexing::DCAFitterN<3> ft; // 3 prong fitter
     ft.setBz(bz);
     ft.setPropagateToPCA(true);  // After finding the vertex, propagate tracks to the DCA. This is default anyway
@@ -509,6 +552,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDA += minD;
         nfoundA++;
       }
+      ++fitstat[ft.getFitStatus()][0];
 
       ft.setUseAbsDCA(true);
       ft.setWeightedFinalPCA(true);
@@ -521,6 +565,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDAW += minD;
         nfoundAW++;
       }
+      ++fitstat[ft.getFitStatus()][1];
 
       ft.setUseAbsDCA(false);
       ft.setWeightedFinalPCA(false);
@@ -533,6 +578,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
         meanDW += minD;
         nfoundW++;
       }
+      ++fitstat[ft.getFitStatus()][2];
     }
     // ft.print();
     meanDA /= nfoundA ? nfoundA : 1;
@@ -545,6 +591,7 @@ BOOST_AUTO_TEST_CASE(DCAFitterNProngs)
               << " mean.dist to truth: " << meanDAW << " CPU time: " << swAW.CpuTime() * 1000 << " ms";
     LOG(info) << "3-prongs with wgh.dist minization: eff= " << float(nfoundW) / NTest
               << " mean.dist to truth: " << meanDW << " CPU time: " << swW.CpuTime() * 1000 << " ms";
+    printStat(fitstat);
     BOOST_CHECK(nfoundA > 0.99 * NTest);
     BOOST_CHECK(nfoundAW > 0.99 * NTest);
     BOOST_CHECK(nfoundW > 0.99 * NTest);

From 793542f37f169281dbe9f55a746107f5333b9ad0 Mon Sep 17 00:00:00 2001
From: iravasen <ivan.ravasenga@cern.ch>
Date: Tue, 8 Apr 2025 15:38:00 +0200
Subject: [PATCH 0205/1764] From rise time to time of arrival (#14150)

---
 .../workflow/src/ThresholdCalibratorSpec.cxx  | 43 ++++++++-----------
 1 file changed, 18 insertions(+), 25 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
index b651bfdedf3aa..e1d7dc725e9e3 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
@@ -1111,24 +1111,18 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
 std::vector<float> ITSThresholdCalibrator::calculatePulseParams(const short int& chipID)
 {
 
-  int rt_mindel = -1, rt_maxdel = -1, tot_mindel = -1, tot_maxdel = -1;
-  int sumRt = 0, sumSqRt = 0, countRt = 0, sumTot = 0, sumSqTot = 0, countTot = 0;
+  int tot_mindel = -1, tot_maxdel = -1;
+  float sumToA = 0., sumSqToA = 0., countToA = 0., sumTot = 0., sumSqTot = 0., countTot = 0.;
+  float toa = -1.;
 
   for (auto itrow = mPixelHits[chipID].begin(); itrow != mPixelHits[chipID].end(); itrow++) { // loop over the chip rows
     short int row = itrow->first;
-    for (short int col_i = 0; col_i < this->N_COL; col_i++) {                                                                              // loop over the pixels on the row
-      for (short int sdel_i = 0; sdel_i < this->N_RANGE; sdel_i++) {                                                                       // loop over the strobe delays
-        if (mPixelHits[chipID][row][col_i][0][sdel_i] > 0.1 * nInj && mPixelHits[chipID][row][col_i][0][sdel_i] < nInj && rt_mindel < 0) { // from left, first bin with 10% hits and 90% hits
-          rt_mindel = (sdel_i * mStep) + 1;                                                                                                // + 1 because if delay = n, we get n+1 in reality (ALPIDE feature)
-        }
-        if (mPixelHits[chipID][row][col_i][0][sdel_i] >= 0.9 * nInj) { // for Rt max take the 90% point
-          rt_maxdel = (sdel_i * mStep) + 1;
-          break;
-        }
-      }
+    for (short int col_i = 0; col_i < this->N_COL; col_i++) { // loop over the pixels on the row
+
       for (short int sdel_i = 0; sdel_i < N_RANGE; sdel_i++) {
-        if (mPixelHits[chipID][row][col_i][0][sdel_i] >= 0.5 * nInj) { // for ToT take the 50% point
-          tot_mindel = (sdel_i * mStep) + 1;
+        if (mPixelHits[chipID][row][col_i][0][sdel_i] >= 0.5 * nInj) { // for ToT and ToA take the 50% point
+          tot_mindel = (sdel_i * mStep) + 1;                           // +1 is for n --> n+1 (alpide manual)
+          toa = (sdel_i * mStep) + 1;
           break;
         }
       }
@@ -1146,24 +1140,23 @@ std::vector<float> ITSThresholdCalibrator::calculatePulseParams(const short int&
         countTot++;
       }
 
-      if (rt_maxdel > rt_mindel && rt_maxdel > 0 && rt_mindel > 0) {
-        sumRt += rt_maxdel - rt_mindel + mStrobeWindow;
-        sumSqRt += (rt_maxdel - rt_mindel + mStrobeWindow) * (rt_maxdel - rt_mindel + mStrobeWindow);
-        countRt++;
+      if (toa > 0) {
+        sumToA += toa + float(mStrobeWindow) / 2.;
+        sumSqToA += (toa + float(mStrobeWindow) / 2.) * (toa + float(mStrobeWindow) / 2.);
+        countToA++;
       }
 
-      rt_mindel = -1;
-      rt_maxdel = -1;
+      toa = -1.;
       tot_maxdel = -1;
       tot_mindel = -1;
     } // end loop over col_i
   }   // end loop over chip rows
 
-  std::vector<float> output; // {avgRt, rmsRt, avgTot, rmsTot}
+  std::vector<float> output; // {avgToA, rmsToA, avgTot, rmsTot}
   // Avg Rt
-  output.push_back(!countRt ? 0. : (float)sumRt / (float)countRt);
+  output.push_back(!countToA ? 0. : (float)sumToA / (float)countToA);
   // Rms Rt
-  output.push_back(!countRt ? 0. : (std::sqrt((float)sumSqRt / (float)countRt - output[0] * output[0])) * 25.);
+  output.push_back(!countToA ? 0. : (std::sqrt((float)sumSqToA / (float)countToA - output[0] * output[0])) * 25.);
   output[0] *= 25.;
   // Avg ToT
   output.push_back(!countTot ? 0. : (float)sumTot / (float)countTot);
@@ -1728,8 +1721,8 @@ void ITSThresholdCalibrator::addDatabaseEntry(
     o2::dcs::addConfigItem(this->mTuning, "ChipDbID", std::to_string(confDBid));
     o2::dcs::addConfigItem(this->mTuning, "Tot", std::to_string(data[2]));    // time over threshold
     o2::dcs::addConfigItem(this->mTuning, "TotRms", std::to_string(data[3])); // time over threshold rms
-    o2::dcs::addConfigItem(this->mTuning, "Rt", std::to_string(data[0]));     // rise time
-    o2::dcs::addConfigItem(this->mTuning, "RtRms", std::to_string(data[1]));  // rise time rms
+    o2::dcs::addConfigItem(this->mTuning, "ToA", std::to_string(data[0]));    // rise time
+    o2::dcs::addConfigItem(this->mTuning, "ToARms", std::to_string(data[1])); // rise time rms
   }
 
   //- Pulse shape 2D: avgToT, rmsToT, MTC, rmsMTC, avgMTCD, rmsMTCD, avgMPL, rmsMPL, avgMPLC, rmsMPLC

From 24c97f247de4de1b811157c401bd2e9ef80f155b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 9 Apr 2025 09:23:07 +0200
Subject: [PATCH 0206/1764] DPL: fix setting of run number (#14152)

This is actually a workaround. The real issue is that timer at the moment are
completely outside of the data streaming and therefore do not have access to
the DataTakingService, where the proper calculation for the run number happens
and it's cached.

OK for now.

In the future we should make sure that the LifetimeHelpers::enumerate
gets a "Streaming" context, not the global one.
---
 Framework/Core/src/LifetimeHelpers.cxx   | 2 +-
 Framework/Core/test/test_SimpleTimer.cxx | 5 ++++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/LifetimeHelpers.cxx b/Framework/Core/src/LifetimeHelpers.cxx
index 4621738ec154e..21aa29c1f10e9 100644
--- a/Framework/Core/src/LifetimeHelpers.cxx
+++ b/Framework/Core/src/LifetimeHelpers.cxx
@@ -423,7 +423,7 @@ ExpirationHandler::Handler LifetimeHelpers::enumerate(ConcreteDataMatcher const&
     dh.payloadSerializationMethod = gSerializationMethodNone;
     dh.tfCounter = timestamp;
     try {
-      dh.runNumber = atoi(services.get<DataTakingContext>().runNumber.c_str());
+      dh.runNumber = strtoull(services.get<RawDeviceService>().device()->fConfig->GetProperty<std::string>("runNumber", "0").c_str(), nullptr, 10);
     } catch (...) {
       dh.runNumber = 0;
     }
diff --git a/Framework/Core/test/test_SimpleTimer.cxx b/Framework/Core/test/test_SimpleTimer.cxx
index df935eb6eb2a0..b2b5a4558f961 100644
--- a/Framework/Core/test/test_SimpleTimer.cxx
+++ b/Framework/Core/test/test_SimpleTimer.cxx
@@ -38,7 +38,10 @@ std::vector<DataProcessorSpec> defineDataProcessing(ConfigContext const&)
         InputSpec{"atimer", "TST", "TIMER", 0, Lifetime::Timer}},
       {},
       AlgorithmSpec{
-        adaptStateless([](ControlService& control) {
+        adaptStateless([](ControlService& control, InputRecord& inputs) {
+          DataRef ref = inputs.get("atimer");
+          auto* header = o2::header::get<o2::header::DataHeader*>(ref.header);
+          LOG(info) << "Run number: " << header->runNumber;
           // This is invoked autonomously by the timer.
           control.readyToQuit(QuitRequest::Me);
         })}},

From 26402846cfd9e7dfb2bfe3f7ff09345ce794aa5e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 9 Apr 2025 21:45:14 +0200
Subject: [PATCH 0207/1764] DPL: set run number also on EoS (#14158)

---
 .../Core/src/ExternalFairMQDeviceProxy.cxx    | 32 +++++++++++++++++--
 1 file changed, 29 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index 449beb0cb8c0b..e67e484f7faf5 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -397,6 +397,11 @@ void injectMissingData(fair::mq::Device& device, fair::mq::Parts& parts, std::ve
     }
     std::string missing = "";
     bool showAlarm = false;
+    uint32_t runNumber = 0;
+    try {
+      runNumber = strtoul(device.fConfig->GetProperty<std::string>("runNumber", "").c_str(), nullptr, 10);
+    } catch (...) {
+    }
     for (auto mi : unmatchedDescriptions) {
       auto& spec = routes[mi].matcher;
       missing += " " + DataSpecUtils::describe(spec);
@@ -412,6 +417,7 @@ void injectMissingData(fair::mq::Device& device, fair::mq::Parts& parts, std::ve
       dh.dataDescription = concrete.description;
       dh.subSpecification = *subSpec;
       dh.payloadSize = 0;
+      dh.runNumber = runNumber;
       dh.splitPayloadParts = 0;
       dh.splitPayloadIndex = 0;
       dh.payloadSerializationMethod = header::gSerializationMethodNone;
@@ -504,7 +510,8 @@ InjectorFunction dplModelAdaptor(std::vector<OutputSpec> const& filterSpecs, DPL
         LOG(error) << "unexpected nullptr found. Skipping message pair.";
         continue;
       }
-      const auto dh = o2::header::get<DataHeader*>(parts.At(msgidx)->GetData());
+      auto* header = parts.At(msgidx)->GetData();
+      const auto dh = o2::header::get<DataHeader*>(header);
       if (!dh) {
         LOG(error) << "data on input " << msgidx << " does not follow the O2 data model, DataHeader missing";
         if (msgidx > 0) {
@@ -512,7 +519,7 @@ InjectorFunction dplModelAdaptor(std::vector<OutputSpec> const& filterSpecs, DPL
         }
         continue;
       }
-      auto dph = o2::header::get<DataProcessingHeader*>(parts.At(msgidx)->GetData());
+      auto dph = o2::header::get<DataProcessingHeader*>(header);
       if (!dph) {
         LOG(error) << "data on input " << msgidx << " does not follow the O2 data model, DataProcessingHeader missing";
         continue;
@@ -527,7 +534,7 @@ InjectorFunction dplModelAdaptor(std::vector<OutputSpec> const& filterSpecs, DPL
       timingInfo.runNumber = dh->runNumber;
       timingInfo.tfCounter = dh->tfCounter;
       LOG(debug) << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();
-      if (dh->runNumber == 0 || dh->tfCounter == 0 || (fmqRunNumber > 0 && fmqRunNumber != dh->runNumber)) {
+      if (dh->runNumber == 0 || (dh->tfCounter == 0 && o2::header::get<SourceInfoHeader*>(header) == nullptr) || (fmqRunNumber > 0 && fmqRunNumber != dh->runNumber)) {
         LOG(error) << "INVALID runNumber / tfCounter: runNumber " << dh->runNumber
                    << ", tfCounter " << dh->tfCounter << ", FMQ runNumber " << fmqRunNumber
                    << " for msgidx " << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();
@@ -623,6 +630,11 @@ InjectorFunction incrementalConverter(OutputSpec const& spec, o2::header::Serial
   auto timesliceId = std::make_shared<size_t>(startTime);
   return [timesliceId, spec, step, method](TimingInfo&, ServiceRegistryRef const& services, fair::mq::Parts& parts, ChannelRetriever channelRetriever, size_t newTimesliceId, bool&) {
     auto* device = services.get<RawDeviceService>().device();
+    uint32_t runNumber = 0;
+    try {
+      runNumber = strtoul(device->fConfig->GetProperty<std::string>("runNumber", "").c_str(), nullptr, 10);
+    } catch (...) {
+    }
     // We iterate on all the parts and we send them two by two,
     // adding the appropriate O2 header.
     for (int i = 0; i < parts.Size(); ++i) {
@@ -635,6 +647,7 @@ InjectorFunction incrementalConverter(OutputSpec const& spec, o2::header::Serial
       dh.dataDescription = matcher.description;
       dh.subSpecification = matcher.subSpec;
       dh.payloadSize = parts.At(i)->GetSize();
+      dh.runNumber = runNumber;
 
       DataProcessingHeader dph{newTimesliceId, 0};
       if (*timesliceId != newTimesliceId) {
@@ -977,11 +990,18 @@ DataProcessorSpec specifyFairMQDeviceOutputProxy(char const* name,
         if (channelName != outputChannelName) {
           continue;
         }
+
+        uint32_t runNumber = 0;
+        try {
+          runNumber = strtoul(device->fConfig->GetProperty<std::string>("runNumber", "").c_str(), nullptr, 10);
+        } catch (...) {
+        }
         DataHeader dh;
         dh.dataOrigin = "DPL";
         dh.dataDescription = "EOS";
         dh.subSpecification = 0;
         dh.payloadSize = 0;
+        dh.runNumber = runNumber;
         dh.payloadSerializationMethod = o2::header::gSerializationMethodNone;
         dh.tfCounter = 0;
         dh.firstTForbit = 0;
@@ -1091,12 +1111,18 @@ DataProcessorSpec specifyFairMQDeviceMultiOutputProxy(char const* name,
         if (!checkChannel(channelName)) {
           continue;
         }
+        uint32_t runNumber = 0;
+        try {
+          runNumber = strtoul(device->fConfig->GetProperty<std::string>("runNumber", "").c_str(), nullptr, 10);
+        } catch (...) {
+        }
         DataHeader dh;
         dh.dataOrigin = "DPL";
         dh.dataDescription = "EOS";
         dh.subSpecification = 0;
         dh.payloadSize = 0;
         dh.payloadSerializationMethod = o2::header::gSerializationMethodNone;
+        dh.runNumber = runNumber;
         dh.tfCounter = 0;
         dh.firstTForbit = 0;
         SourceInfoHeader sih;

From fcdf98dec8cf81dbaa3e982e4b4a528d4b059762 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 10 Apr 2025 08:52:42 +0200
Subject: [PATCH 0208/1764] ITS3: Fix matrix generation in helper class
 (#13895)

* ITS: change layer name to debug severity

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: ITS3 matrix generation fix + demoting&removal of logging

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS3: Propagate rename to ITS helper class

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS3: make ITSRESPONSE cached var

Allows reusing this variable later on.

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: digiparams make print func virtual

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/base/src/GeometryTGeo.cxx      | 100 ++++++++----------
 .../ITSMFT/ITS/simulation/src/Detector.cxx    |   6 +-
 .../data/AlpideResponseData/CMakeLists.txt    |   4 +-
 .../include/ITSMFTSimulation/DigiParams.h     |  20 ++--
 4 files changed, 58 insertions(+), 72 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx b/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
index b52fd8f58320f..89b4d63729543 100644
--- a/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
+++ b/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
@@ -24,8 +24,6 @@
 
 #ifdef ENABLE_UPGRADES
 #include "ITS3Base/SpecsV2.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
-using SuperSegmentation = o2::its3::SegmentationSuperAlpide;
 #endif
 
 #include <TGeoBBox.h>         // for TGeoBBox
@@ -420,33 +418,20 @@ TGeoHMatrix* GeometryTGeo::extractMatrixSensor(int index) const
   static int chipInGlo{0};
 
   // account for the difference between physical sensitive layer (where charge collection is simulated) and effective sensor thicknesses
+  // in the ITS3 case this accounted by specialized functions
   double delta = Segmentation::SensorLayerThickness - Segmentation::SensorLayerThicknessEff;
-#ifdef ENABLE_UPGRADES
-  if (mIsLayerITS3[getLayer(index)]) {
-    delta = its3::SegmentationSuperAlpide::mSensorLayerThickness - its3::SegmentationSuperAlpide::mSensorLayerThicknessEff;
-  }
-#endif
-
   static TGeoTranslation tra(0., 0.5 * delta, 0.);
-
+#ifdef ENABLE_UPGRADES // only apply for non ITS3 OB layers
+  if (!mIsLayerITS3[getLayer(index)]) {
+    matTmp *= tra;
+  }
+#else
   matTmp *= tra;
+#endif
 
   return &matTmp;
 }
 
-//__________________________________________________________________________
-const o2::math_utils::Transform3D GeometryTGeo::getT2LMatrixITS3(int isn, float alpha)
-{
-  // create for sensor isn the TGeo matrix for Tracking to Local frame transformations
-  static TGeoHMatrix t2l;
-  t2l.Clear();
-  t2l.RotateZ(alpha * RadToDeg()); // rotate in direction of normal to the tangent to the cylinder
-  const TGeoHMatrix& matL2G = getMatrixL2G(isn);
-  const auto& matL2Gi = matL2G.Inverse();
-  t2l.MultiplyLeft(&matL2Gi);
-  return Mat3D(t2l);
-}
-
 //__________________________________________________________________________
 void GeometryTGeo::Build(int loadTrans)
 {
@@ -492,23 +477,6 @@ void GeometryTGeo::Build(int loadTrans)
     mLastChipIndex[i] = numberOfChips - 1;
   }
 
-  LOGP(debug, "Summary of extracted Geometry:");
-  LOGP(debug, "  There are {} Layers and {} HalfBarrels", mNumberOfLayers, mNumberOfHalfBarrels);
-  for (int i = 0; i < mNumberOfLayers; i++) {
-    LOGP(debug, "    Layer {}: {:*^30}", i, "START");
-    LOGP(debug, "      - mNumberOfStaves={}", mNumberOfStaves[i]);
-    LOGP(debug, "        - mNumberOfChipsPerStave={}", mNumberOfChipsPerStave[i]);
-    LOGP(debug, "      - mNumberOfHalfStaves={}", mNumberOfHalfStaves[i]);
-    LOGP(debug, "        - mNumberOfChipsPerHalfStave={}", mNumberOfChipsPerHalfStave[i]);
-    LOGP(debug, "      - mNumberOfModules={}", mNumberOfModules[i]);
-    LOGP(debug, "        - mNumberOfChipsPerModules={}", mNumberOfChipsPerModule[i]);
-    LOGP(debug, "        - mNumberOfChipsPerLayer={}", mNumberOfChipsPerLayer[i]);
-    LOGP(debug, "        - mNumberOfChipsPerHalfBarrel={}", mNumberOfChipsPerHalfBarrel[i]);
-    LOGP(debug, "      - mLastChipIndex={}", mLastChipIndex[i]);
-    LOGP(debug, "    Layer {}: {:*^30}", i, "END");
-  }
-  LOGP(debug, "In total there {} chips registered", numberOfChips);
-
 #ifdef ENABLE_UPGRADES
   if (std::any_of(mIsLayerITS3.cbegin(), mIsLayerITS3.cend(), [](auto b) { return b; })) {
     LOGP(info, "Found active IT3 layers -> Renaming Detector ITS to IT3");
@@ -880,34 +848,39 @@ void GeometryTGeo::extractSensorXAlpha(int isn, float& x, float& alp)
 
   const TGeoHMatrix* matL2G = extractMatrixSensor(isn);
   double locA[3] = {-100., 0., 0.}, locB[3] = {100., 0., 0.}, gloA[3], gloB[3];
-  int iLayer = getLayer(isn);
+  double xp{0}, yp{0};
 
 #ifdef ENABLE_UPGRADES
-  if (mIsLayerITS3[iLayer]) {
-    // We need to calcualte the line tangent at the mid-point in the geometry
+  if (int iLayer = getLayer(isn); mIsLayerITS3[iLayer]) {
+    // For a TGeoTubeSeg the local coordinate system is defined at the origin
+    // of the circle of the side, since in our implementation we rotated the geometry a bit
     const auto radius = o2::its3::constants::radii[iLayer];
     const auto phi1 = o2::its3::constants::tile::width / radius;
     const auto phi2 = o2::its3::constants::pixelarray::width / radius + phi1;
     const auto phi3 = (phi2 - phi1) / 2.; // mid-point in phi
-    const auto x = radius * std::cos(phi3);
-    const auto y = radius * std::sin(phi3);
-    // For the tangent we make the parametric line equation y = m * x - c
-    const auto m = x / y;
-    const auto c = y - m * x;
-    // Now we can given any x calulate points along this line, we pick points far away,
-    // the calculation of the normal should work then below.
-    locA[1] = m * locA[0] + c;
-    locB[1] = m * locB[0] + c;
-  }
-#endif
-
+    locA[0] = radius * std::cos(phi3);
+    locA[1] = radius * std::sin(phi3);
+    matL2G->LocalToMaster(locA, gloA);
+    xp = gloA[0];
+    yp = gloA[1];
+  } else {
+    matL2G->LocalToMaster(locA, gloA);
+    matL2G->LocalToMaster(locB, gloB);
+    double dx = gloB[0] - gloA[0], dy = gloB[1] - gloA[1];
+    double t = (gloB[0] * dx + gloB[1] * dy) / (dx * dx + dy * dy);
+    xp = gloB[0] - dx * t;
+    yp = gloB[1] - dy * t;
+  }
+#else // just ITS2 part
   matL2G->LocalToMaster(locA, gloA);
   matL2G->LocalToMaster(locB, gloB);
   double dx = gloB[0] - gloA[0], dy = gloB[1] - gloA[1];
   double t = (gloB[0] * dx + gloB[1] * dy) / (dx * dx + dy * dy);
-  double xp = gloB[0] - dx * t, yp = gloB[1] - dy * t;
-  x = Sqrt(xp * xp + yp * yp);
-  alp = ATan2(yp, xp);
+  xp = gloB[0] - dx * t;
+  yp = gloB[1] - dy * t;
+#endif
+  x = std::hypot(xp, yp);
+  alp = std::atan2(yp, xp);
   o2::math_utils::bringTo02Pi(alp);
 }
 
@@ -926,6 +899,19 @@ TGeoHMatrix& GeometryTGeo::createT2LMatrix(int isn)
   return t2l;
 }
 
+//__________________________________________________________________________
+const o2::math_utils::Transform3D GeometryTGeo::getT2LMatrixITS3(int isn, float alpha)
+{
+  // create for sensor isn the TGeo matrix for Tracking to Local frame transformations with correction for effective thickness
+  static TGeoHMatrix t2l;
+  t2l.Clear();
+  t2l.RotateZ(alpha * RadToDeg()); // rotate in direction of normal to the tangent to the cylinder
+  const TGeoHMatrix& matL2G = getMatrixL2G(isn);
+  const auto& matL2Gi = matL2G.Inverse();
+  t2l.MultiplyLeft(&matL2Gi);
+  return Mat3D(t2l);
+}
+
 //__________________________________________________________________________
 int GeometryTGeo::extractVolumeCopy(const char* name, const char* prefix) const
 {
diff --git a/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx b/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
index bf2e997794ee4..2304a9102092a 100644
--- a/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
+++ b/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
@@ -190,7 +190,7 @@ Detector::Detector(Bool_t active, TString name)
     } else {
       mLayerName[j].Form("%s%d", GeometryTGeo::getITSSensorPattern(), j); // See V3Layer
     }
-    LOGP(info, "{}: mLayerName={}", j, mLayerName[j].Data());
+    LOGP(debug, "{}: mLayerName={}", j, mLayerName[j].Data());
   }
 
   if (mNumberLayers > 0) { // if not, we'll Fatal-ize in CreateGeometry
@@ -723,8 +723,8 @@ void Detector::defineLayer(Int_t nlay, Double_t phi0, Double_t r, Int_t nstav, I
   // Return:
   //   none.
 
-  LOG(info) << "L# " << nlay << " Phi:" << phi0 << " R:" << r << " Nst:" << nstav << " Nunit:" << nunit
-            << " Lthick:" << lthick << " Dthick:" << dthick << " DetID:" << dettypeID << " B:" << buildLevel;
+  LOG(debug) << "L# " << nlay << " Phi:" << phi0 << " R:" << r << " Nst:" << nstav << " Nunit:" << nunit
+             << " Lthick:" << lthick << " Dthick:" << dthick << " DetID:" << dettypeID << " B:" << buildLevel;
 
   if (nlay >= mNumberLayers || nlay < 0) {
     LOG(error) << "Wrong layer number " << nlay;
diff --git a/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt b/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
index 381e4f4b54c01..d1f3e756394b1 100644
--- a/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
+++ b/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
@@ -20,10 +20,10 @@ set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${CMAKE_SOURCE_DI
 
 if(ITSRESPONSE)
   message(STATUS "ITSRESPONSE option provided, setting ITSRESPONSE_DIR from it: " ${ITSRESPONSE})
-  set(ITSRESPONSE_DIR ${ITSRESPONSE})
+  set(ITSRESPONSE_DIR ${ITSRESPONSE} CACHE PATH "ITSResponse directory")
 else()
   message(STATUS "ITSRESPONSE option not provided, setting ITSRESPONSE_DIR from environment ITSRESPONSE_ROOT: " $ENV{ITSRESPONSE_ROOT})
-  set(ITSRESPONSE_DIR $ENV{ITSRESPONSE_ROOT})
+  set(ITSRESPONSE_DIR $ENV{ITSRESPONSE_ROOT} CACHE PATH "ITSResponse directory")
 endif()
 
 add_custom_command(TARGET O2exe-alpide-response-generator POST_BUILD
diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
index 7772c47237ae8..b27739c26bc4d 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
@@ -96,18 +96,18 @@ class DigiParams
   const SignalShape& getSignalShape() const { return mSignalShape; }
   SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
 
-  void print() const;
+  virtual void print() const;
 
  private:
   static constexpr double infTime = 1e99;
-  bool mIsContinuous = false;        ///< flag for continuous simulation
-  float mNoisePerPixel = 1.e-8;      ///< ALPIDE Noise per chip
-  int mROFrameLengthInBC = 0;        ///< ROF length in BC for continuos mode
-  float mROFrameLength = 0;          ///< length of RO frame in ns
-  float mStrobeDelay = 0.;           ///< strobe start (in ns) wrt ROF start
-  float mStrobeLength = 0;           ///< length of the strobe in ns (sig. over threshold checked in this window only)
-  double mTimeOffset = -2 * infTime; ///< time offset (in seconds!) to calculate ROFrame from hit time
-  int mROFrameBiasInBC = 0;          ///< misalignment of the ROF start in BC
+  bool mIsContinuous = false;              ///< flag for continuous simulation
+  float mNoisePerPixel = 1.e-8;            ///< ALPIDE Noise per chip
+  int mROFrameLengthInBC = 0;              ///< ROF length in BC for continuos mode
+  float mROFrameLength = 0;                ///< length of RO frame in ns
+  float mStrobeDelay = 0.;                 ///< strobe start (in ns) wrt ROF start
+  float mStrobeLength = 0;                 ///< length of the strobe in ns (sig. over threshold checked in this window only)
+  double mTimeOffset = -2 * infTime;       ///< time offset (in seconds!) to calculate ROFrame from hit time
+  int mROFrameBiasInBC = 0;                ///< misalignment of the ROF start in BC
   int mChargeThreshold = 150;              ///< charge threshold in Nelectrons
   int mMinChargeToAccount = 15;            ///< minimum charge contribution to account
   int mNSimSteps = 7;                      ///< number of steps in response simulation
@@ -125,7 +125,7 @@ class DigiParams
   float mROFrameLengthInv = 0; ///< inverse length of RO frame in ns
   float mNSimStepsInv = 0;     ///< its inverse
 
-  ClassDefNV(DigiParams, 2);
+  ClassDef(DigiParams, 2);
 };
 } // namespace itsmft
 } // namespace o2

From 04b2596a380cba6b4a5aae332ebace594231e21b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 10 Apr 2025 09:13:35 +0200
Subject: [PATCH 0209/1764] DPL: do not compute GUI metrics if we are in online
 mode (#14163)

---
 Framework/Core/src/CommonServices.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index e13f1cb2094b7..9d30dac8c4de8 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -848,7 +848,9 @@ auto flushMetrics(ServiceRegistryRef registry, DataProcessingStats& stats) -> vo
     }
     monitoring.send(std::move(metric));
   });
-  relayer.sendContextState();
+  if (DefaultsHelpers::onlineDeploymentMode() == false) {
+    relayer.sendContextState();
+  }
   monitoring.flushBuffer();
   O2_SIGNPOST_END(monitoring_service, sid, "flush", "done flushing metrics");
 };

From 0a831b2817e686e14d9b5129f6fd0fc45ea035db Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 10 Apr 2025 14:28:28 +0200
Subject: [PATCH 0210/1764] DPL: extend DataRefUtils::match to support multiple
 headers (#14160)

---
 .../Core/include/Framework/DataRefUtils.h     | 23 ++++++++++++++-----
 .../include/Framework/InputRecordWalker.h     |  5 ++--
 .../include/DPLUtils/DPLRawPageSequencer.h    |  2 +-
 3 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/Framework/Core/include/Framework/DataRefUtils.h b/Framework/Core/include/Framework/DataRefUtils.h
index 4c1bd0ed7ed10..d50699badc63b 100644
--- a/Framework/Core/include/Framework/DataRefUtils.h
+++ b/Framework/Core/include/Framework/DataRefUtils.h
@@ -11,6 +11,7 @@
 #ifndef O2_FRAMEWORK_DATAREFUTILS_H_
 #define O2_FRAMEWORK_DATAREFUTILS_H_
 
+#include "Framework/DataDescriptorMatcher.h"
 #include "Framework/DataRef.h"
 #include "Framework/RootSerializationSupport.h"
 #include "Framework/SerializationMethods.h"
@@ -33,6 +34,9 @@ class ConfigurableParam;
 namespace o2::framework
 {
 
+template <typename H>
+concept DataHeaderLike = requires(H& dh) {dh.dataOrigin; dh.dataDescription; dh.subSpecification; };
+
 // FIXME: Should enforce the fact that DataRefs are read only...
 struct DataRefUtils {
 
@@ -52,7 +56,7 @@ struct DataRefUtils {
       if ((payloadSize % sizeof(T)) != 0) {
         throw runtime_error("Cannot extract POD from message as size do not match");
       }
-      //FIXME: provide a const collection
+      // FIXME: provide a const collection
       return gsl::span<T>(reinterpret_cast<T*>(const_cast<char*>(ref.payload)), payloadSize / sizeof(T));
     } else if constexpr (has_root_dictionary<T>::value == true &&
                          is_messageable<T>::value == false) {
@@ -220,17 +224,24 @@ struct DataRefUtils {
     return ref.spec != nullptr && ref.spec->binding == binding;
   }
 
-  /// check if the O2 message referred by DataRef matches a particular
-  /// input spec. The DataHeader is retrieved from the header message and matched
-  /// against @ref spec parameter.
-  static bool match(DataRef const& ref, InputSpec const& spec)
+  template <DataHeaderLike H>
+  static bool matchHeader(DataRef const& ref, InputSpec const& spec)
   {
-    auto dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    auto const* dh = o2::header::get<H*>(ref.header);
     if (dh == nullptr) {
       return false;
     }
     return DataSpecUtils::match(spec, dh->dataOrigin, dh->dataDescription, dh->subSpecification);
   }
+
+  /// check if the O2 message referred by DataRef matches a particular
+  /// input spec. The DataHeader is retrieved from the header message and matched
+  /// against @ref spec parameter.
+  template <DataHeaderLike... H>
+  static bool match(DataRef const& ref, InputSpec const& spec)
+  {
+    return (DataRefUtils::matchHeader<H>(ref, spec) || ... || matchHeader<o2::header::DataHeader>(ref, spec));
+  }
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/include/Framework/InputRecordWalker.h b/Framework/Core/include/Framework/InputRecordWalker.h
index a67a7dfb04820..4d36a1f17bc82 100644
--- a/Framework/Core/include/Framework/InputRecordWalker.h
+++ b/Framework/Core/include/Framework/InputRecordWalker.h
@@ -12,11 +12,11 @@
 #define FRAMEWORK_INPUTRECORDWALKER_H
 
 /// @file   InputRecordWalker.h
-/// @author Matthias Richter
 /// @since  2020-03-25
 /// @brief  A helper class to iteratate over all parts of all input routes
 
 #include "Framework/InputRecord.h"
+#include "Framework/DataRefUtils.h"
 
 namespace o2::framework
 {
@@ -49,6 +49,7 @@ namespace o2::framework
 ///   for (auto const& ref : InputRecordWalker(inputs, filter)) {
 ///     // do something with the data
 ///   }
+template <DataHeaderLike... EXTRA_HEADERS>
 class InputRecordWalker
 {
  public:
@@ -131,7 +132,7 @@ class InputRecordWalker
           if (mFilterSpecs.size() > 0) {
             bool isSelected = false;
             for (auto const& spec : mFilterSpecs) {
-              if ((isSelected = DataRefUtils::match(*mCurrent, spec)) == true) {
+              if ((isSelected = DataRefUtils::match<EXTRA_HEADERS...>(*mCurrent, spec)) == true) {
                 break;
               }
             }
diff --git a/Framework/Utils/include/DPLUtils/DPLRawPageSequencer.h b/Framework/Utils/include/DPLUtils/DPLRawPageSequencer.h
index 785dc9e04bd45..2fb8374e45c12 100644
--- a/Framework/Utils/include/DPLUtils/DPLRawPageSequencer.h
+++ b/Framework/Utils/include/DPLUtils/DPLRawPageSequencer.h
@@ -191,7 +191,7 @@ class DPLRawPageSequencer
   }
 
  private:
-  InputRecordWalker mInput;
+  InputRecordWalker<> mInput;
 
   template <typename Predicate, typename Inserter>
   void forwardInternal(Predicate pred, Inserter inserter, const char* data, size_t size, const o2::header::DataHeader* dh)

From b78b50c251ad7dca06d844c4c4860954b08b113b Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Thu, 10 Apr 2025 15:28:11 +0200
Subject: [PATCH 0211/1764] ctpdev: orbitreset and orbitsox via zmq II (#14147)

* dev: finishing orbitsox and orbitreset via zmq

* clang

* fix

* fix

* dev: removed infologger and using LOG(important)

* clang

* fix
---
 .../include/CTPWorkflowScalers/RunManager.h   |  1 +
 .../CTP/workflowScalers/src/RunManager.cxx    | 39 ++++++++++++++++++-
 .../workflowScalers/src/ctpCCDBManager.cxx    |  5 ++-
 3 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
index e0b204e6c4ce5..72fb9c2056367 100644
--- a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
+++ b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
@@ -18,6 +18,7 @@
 #include "DataFormatsCTP/Configuration.h"
 #include "BookkeepingApi/BkpClientFactory.h"
 #include "BookkeepingApi/BkpClient.h"
+
 using namespace o2::bkp::api;
 namespace o2
 {
diff --git a/Detectors/CTP/workflowScalers/src/RunManager.cxx b/Detectors/CTP/workflowScalers/src/RunManager.cxx
index ac3eda60094e9..5d0b906e28088 100644
--- a/Detectors/CTP/workflowScalers/src/RunManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/RunManager.cxx
@@ -18,6 +18,7 @@
 #include <regex>
 #include "CommonUtils/StringUtils.h"
 #include <fairlogger/Logger.h>
+
 using namespace o2::ctp;
 ///
 /// Active run to keep cfg and saclers of active runs
@@ -232,10 +233,44 @@ int CTPRunManager::processMessage(std::string& topic, const std::string& message
     return 0;
   }
   if (topic.find("soxorbit") != std::string::npos) {
-    return 0;
+    std::vector<std::string> tokens = o2::utils::Str::tokenize(message, ' ');
+    int ret = 0;
+    if (tokens.size() == 3) {
+      long timestamp = std::stol(tokens[0]);
+      uint32_t runnumber = std::stoul(tokens[1]);
+      uint32_t orbit = std::stoul(tokens[2]);
+      ret = saveSoxOrbit(runnumber, orbit, timestamp);
+      std::string logmessage;
+      if (ret) {
+        logmessage = "Failed to update CCDB with SOX orbit.";
+      } else {
+        logmessage = "CCDB updated with SOX orbit.";
+      }
+      LOG(important) << logmessage << " run:" << runnumber << " sox orbit:" << orbit << " ts:" << timestamp;
+    } else {
+      LOG(error) << "Topic soxorbit dize !=3: " << message << " token size:" << tokens.size();
+      ret = 1;
+    }
+    return ret;
   }
   if (topic.find("orbitreset") != std::string::npos) {
-    return 0;
+    std::vector<std::string> tokens = o2::utils::Str::tokenize(message, ' ');
+    int ret = 0;
+    if (tokens.size() == 1) {
+      long timestamp = std::stol(tokens[0]);
+      ret = saveOrbitReset(timestamp);
+      std::string logmessage;
+      if (ret) {
+        logmessage = "Failed to update CCDB with orbitreset. ";
+      } else {
+        logmessage = "CCDB updated with orbitreset. ";
+      }
+      LOG(important) << logmessage << timestamp;
+    } else {
+      LOG(error) << "Topic orbit reset != 2: " << message << " token size:" << tokens.size();
+      ret = 1;
+    }
+    return ret;
   }
   static int nerror = 0;
   if (topic.find("sox") != std::string::npos) {
diff --git a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
index 0d81b896b3e91..cbe8fe5dd675f 100644
--- a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
@@ -122,7 +122,7 @@ int ctpCCDBManager::saveSoxOrbit(uint32_t runNumber, uint32_t soxOrbit, long tim
   vect.push_back(timestamp);
   vect.push_back((uint64_t)runNumber);
   vect.push_back((uint64_t)soxOrbit);
-  long tmin = timestamp;
+  long tmin = timestamp / 1000;
   long tmax = tmin + 381928219;
   o2::ccdb::CcdbApi api;
   map<string, string> metadata; // can be empty
@@ -149,9 +149,10 @@ int ctpCCDBManager::saveOrbitReset(long timeStamp)
   if (timeStamp == 0) {
     auto now = std::chrono::system_clock::now();
     timeStamp = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
+    LOG(warn) << "Received timestamp = 0 , using current time:" << timeStamp;
   }
   vect.push_back(timeStamp);
-  long tmin = timeStamp;
+  long tmin = timeStamp / 1000;
   long tmax = tmin + 381928219;
   o2::ccdb::CcdbApi api;
   map<string, string> metadata; // can be empty

From b17041de14862c743f6a883c8cc66d7743295916 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 9 Apr 2025 16:05:59 +0200
Subject: [PATCH 0212/1764] Possibility to request TPC occupancy map w/o askig
 for clusters

---
 .../DataFormatsGlobalTracking/RecoContainer.h |  2 ++
 .../GlobalTracking/src/RecoContainer.cxx      | 25 ++++++++++++++++---
 2 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/DataFormats/Detectors/GlobalTracking/include/DataFormatsGlobalTracking/RecoContainer.h b/DataFormats/Detectors/GlobalTracking/include/DataFormatsGlobalTracking/RecoContainer.h
index d128467168c92..31d531ef19265 100644
--- a/DataFormats/Detectors/GlobalTracking/include/DataFormatsGlobalTracking/RecoContainer.h
+++ b/DataFormats/Detectors/GlobalTracking/include/DataFormatsGlobalTracking/RecoContainer.h
@@ -225,6 +225,7 @@ struct DataRequest {
   void requestITSClusters(bool mc);
   void requestMFTClusters(bool mc);
   void requestTPCClusters(bool mc);
+  void requestTPCOccMap();
   void requestTPCTriggers();
   void requestTOFClusters(bool mc);
   void requestTRDTracklets(bool mc);
@@ -377,6 +378,7 @@ struct RecoContainer {
   void addITSClusters(o2::framework::ProcessingContext& pc, bool mc);
   void addMFTClusters(o2::framework::ProcessingContext& pc, bool mc);
   void addTPCClusters(o2::framework::ProcessingContext& pc, bool mc, bool shmap, bool occmap);
+  void addTPCOccMap(o2::framework::ProcessingContext& pc);
   void addTPCTriggers(o2::framework::ProcessingContext& pc);
   void addTOFClusters(o2::framework::ProcessingContext& pc, bool mc);
   void addHMPClusters(o2::framework::ProcessingContext& pc, bool mc);
diff --git a/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx b/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
index c26de2bfda896..39cc05d8a69e7 100644
--- a/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
+++ b/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
@@ -123,7 +123,7 @@ void DataRequest::requestTPCTracks(bool mc)
   addInput({"trackTPCClRefs", "TPC", "CLUSREFS", 0, Lifetime::Timeframe});
   if (requestMap.find("clusTPC") != requestMap.end()) {
     addInput({"clusTPCshmap", "TPC", "CLSHAREDMAP", 0, Lifetime::Timeframe});
-    addInput({"clusTPCoccmap", "TPC", "TPCOCCUPANCYMAP", 0, Lifetime::Timeframe});
+    requestTPCOccMap();
   }
   if (mc) {
     addInput({"trackTPCMCTR", "TPC", "TRACKSMCLBL", 0, Lifetime::Timeframe});
@@ -267,6 +267,12 @@ void DataRequest::requestMFTClusters(bool mc)
   requestMap["clusMFT"] = mc;
 }
 
+void DataRequest::requestTPCOccMap()
+{
+  addInput({"clusTPCoccmap", "TPC", "TPCOCCUPANCYMAP", 0, Lifetime::Timeframe});
+  requestMap["TPCOcc"] = false;
+}
+
 void DataRequest::requestTPCClusters(bool mc)
 {
   addInput({"clusTPC", ConcreteDataTypeMatcher{"TPC", "CLUSTERNATIVE"}, Lifetime::Timeframe});
@@ -275,7 +281,7 @@ void DataRequest::requestTPCClusters(bool mc)
   }
   if (requestMap.find("trackTPC") != requestMap.end()) {
     addInput({"clusTPCshmap", "TPC", "CLSHAREDMAP", 0, Lifetime::Timeframe});
-    addInput({"clusTPCoccmap", "TPC", "TPCOCCUPANCYMAP", 0, Lifetime::Timeframe});
+    requestTPCOccMap();
   }
   if (mc) {
     addInput({"clusTPCMC", ConcreteDataTypeMatcher{"TPC", "CLNATIVEMCLBL"}, Lifetime::Timeframe});
@@ -704,10 +710,17 @@ void RecoContainer::collectData(ProcessingContext& pc, const DataRequest& reques
     addMFTClusters(pc, req->second);
   }
 
+  req = reqMap.find("TPCOcc");
+  bool TPCOccDone = false;
+  if (req != reqMap.end()) {
+    TPCOccDone = true;
+    addTPCOccMap(pc);
+  }
+
   req = reqMap.find("clusTPC");
   if (req != reqMap.end()) {
     auto tracksON = reqMap.find("trackTPC") != reqMap.end();
-    addTPCClusters(pc, req->second, tracksON, tracksON);
+    addTPCClusters(pc, req->second, tracksON, tracksON && (!TPCOccDone));
   }
 
   req = reqMap.find("trigTPC");
@@ -1100,6 +1113,12 @@ void RecoContainer::addMFTClusters(ProcessingContext& pc, bool mc)
   }
 }
 
+//__________________________________________________________
+void RecoContainer::addTPCOccMap(ProcessingContext& pc)
+{
+  occupancyMapTPC = pc.inputs().get<gsl::span<unsigned int>>("clusTPCoccmap");
+}
+
 //__________________________________________________________
 void RecoContainer::addTPCClusters(ProcessingContext& pc, bool mc, bool shmap, bool occmap)
 {

From 276c3223609bbc50a8609a4131157a84f89c7e98 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 9 Apr 2025 16:07:10 +0200
Subject: [PATCH 0213/1764] ITSTPC QC does not need TPC clusters, just occ.

---
 Detectors/GLOQC/src/MatchITSTPCQC.cxx | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Detectors/GLOQC/src/MatchITSTPCQC.cxx b/Detectors/GLOQC/src/MatchITSTPCQC.cxx
index 86de9cd9c056e..e1832056f072c 100644
--- a/Detectors/GLOQC/src/MatchITSTPCQC.cxx
+++ b/Detectors/GLOQC/src/MatchITSTPCQC.cxx
@@ -470,7 +470,7 @@ void MatchITSTPCQC::initDataRequest()
   if (mDoK0QC) {
     mDataRequest->requestPrimaryVertices(mUseMC);
     mDataRequest->requestSecondaryVertices(mUseMC);
-    mDataRequest->requestTPCClusters(false);
+    mDataRequest->requestTPCOccMap();
   }
 }
 
@@ -478,7 +478,6 @@ void MatchITSTPCQC::initDataRequest()
 
 void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx)
 {
-
   // Getting the B field
   mBz = o2::base::Propagator::Instance()->getNominalBz();
 
@@ -1058,7 +1057,6 @@ void MatchITSTPCQC::run(o2::framework::ProcessingContext& ctx)
     } else {
       mTBinClOcc.resize(1);
     }
-
     auto v0IDs = mRecoCont.getV0sIdx();
     auto nv0 = v0IDs.size();
     if (nv0 > mRecoCont.getV0s().size()) {

From 4f4b5458db0b1b5f1fcbf8e7c6111ab300d6b370 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 10 Apr 2025 20:44:31 +0200
Subject: [PATCH 0214/1764] DPL: Do not compute metrics if the GUI is not
 available (#14170)

---
 Framework/Core/src/CommonServices.cxx | 4 +---
 Framework/Core/src/DataRelayer.cxx    | 3 +++
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 9d30dac8c4de8..e13f1cb2094b7 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -848,9 +848,7 @@ auto flushMetrics(ServiceRegistryRef registry, DataProcessingStats& stats) -> vo
     }
     monitoring.send(std::move(metric));
   });
-  if (DefaultsHelpers::onlineDeploymentMode() == false) {
-    relayer.sendContextState();
-  }
+  relayer.sendContextState();
   monitoring.flushBuffer();
   O2_SIGNPOST_END(monitoring_service, sid, "flush", "done flushing metrics");
 };
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index f30866dc0aa1b..c6333350d6da7 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -1034,6 +1034,9 @@ uint64_t DataRelayer::getCreationTimeForSlot(TimesliceSlot slot)
 
 void DataRelayer::sendContextState()
 {
+  if (!mContext.get<DriverConfig const>().driverHasGUI) {
+    return;
+  }
   std::scoped_lock<O2_LOCKABLE(std::recursive_mutex)> lock(mMutex);
   auto& states = mContext.get<DataProcessingStates>();
   for (size_t ci = 0; ci < mTimesliceIndex.size(); ++ci) {

From 8688938bd04ddeb7227b43ff136d39f463b60e37 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 10 Apr 2025 20:46:13 +0200
Subject: [PATCH 0215/1764] DataSampling: make sure the original DataHeader is
 available in the sampled data (#14164)

---
 .../include/DataSampling/DataSamplingHeader.h | 13 ++++--
 .../include/DataSampling/Dispatcher.h         |  4 +-
 .../DataSampling/src/DataSamplingHeader.cxx   | 13 +++---
 Utilities/DataSampling/src/Dispatcher.cxx     |  7 ++--
 .../test/test_DataSamplingHeader.cxx          | 42 +++++++++++--------
 5 files changed, 47 insertions(+), 32 deletions(-)

diff --git a/Utilities/DataSampling/include/DataSampling/DataSamplingHeader.h b/Utilities/DataSampling/include/DataSampling/DataSamplingHeader.h
index adc2c97759f52..0cc96e2125dec 100644
--- a/Utilities/DataSampling/include/DataSampling/DataSamplingHeader.h
+++ b/Utilities/DataSampling/include/DataSampling/DataSamplingHeader.h
@@ -41,8 +41,15 @@ struct DataSamplingHeader : public header::BaseHeader {
   uint32_t totalEvaluatedMessages = 0;
   DeviceIDType deviceID = "";
 
-  DataSamplingHeader();
-  DataSamplingHeader(uint64_t _sampleTimeUs, uint32_t _totalAcceptedMessages, uint32_t _totalEvaluatedMessages, DeviceIDType _deviceID);
+  /// Presampled description for the data. Copied from the original DataHeader.
+  header::DataDescription dataDescription;
+  /// Presampled origin for the data. Copied from the original DataHeader.
+  header::DataOrigin dataOrigin;
+  /// Presampled subSpecification for the data.
+  header::DataHeader::SubSpecificationType subSpecification;
+
+  DataSamplingHeader() = delete;
+  DataSamplingHeader(uint64_t _sampleTimeUs, uint32_t _totalAcceptedMessages, uint32_t _totalEvaluatedMessages, DeviceIDType _deviceID, header::DataHeader const& original);
   DataSamplingHeader(const DataSamplingHeader&) = default;
   DataSamplingHeader& operator=(const DataSamplingHeader&) = default;
 
@@ -51,4 +58,4 @@ struct DataSamplingHeader : public header::BaseHeader {
 
 } // namespace o2::utilities
 
-#endif //ALICEO2_DATASAMPLINGHEADER_H
+#endif // ALICEO2_DATASAMPLINGHEADER_H
diff --git a/Utilities/DataSampling/include/DataSampling/Dispatcher.h b/Utilities/DataSampling/include/DataSampling/Dispatcher.h
index d92876f4c6125..1d34269f87536 100644
--- a/Utilities/DataSampling/include/DataSampling/Dispatcher.h
+++ b/Utilities/DataSampling/include/DataSampling/Dispatcher.h
@@ -64,7 +64,7 @@ class Dispatcher : public framework::Task
   framework::Options getOptions();
 
  private:
-  DataSamplingHeader prepareDataSamplingHeader(const DataSamplingPolicy& policy);
+  DataSamplingHeader prepareDataSamplingHeader(const DataSamplingPolicy& policy, header::DataHeader const& original);
   header::Stack extractAdditionalHeaders(const char* inputHeaderStack) const;
   void reportStats(monitoring::Monitoring& monitoring) const;
   void send(framework::DataAllocator& dataAllocator, const framework::DataRef& inputData, const framework::Output& output) const;
@@ -78,4 +78,4 @@ class Dispatcher : public framework::Task
 
 } // namespace o2::utilities
 
-#endif //ALICEO2_DISPATCHER_H
+#endif // ALICEO2_DISPATCHER_H
diff --git a/Utilities/DataSampling/src/DataSamplingHeader.cxx b/Utilities/DataSampling/src/DataSamplingHeader.cxx
index 392e37a5d9117..204d4aa2b56a6 100644
--- a/Utilities/DataSampling/src/DataSamplingHeader.cxx
+++ b/Utilities/DataSampling/src/DataSamplingHeader.cxx
@@ -19,16 +19,15 @@
 namespace o2::utilities
 {
 
-DataSamplingHeader::DataSamplingHeader() : BaseHeader(sizeof(DataSamplingHeader), sHeaderType, sSerializationMethod, sVersion)
-{
-}
-
-DataSamplingHeader::DataSamplingHeader(uint64_t _sampleTimeUs, uint32_t _totalAcceptedMessages, uint32_t _totalEvaluatedMessages, DeviceIDType _deviceID)
+DataSamplingHeader::DataSamplingHeader(uint64_t _sampleTimeUs, uint32_t _totalAcceptedMessages, uint32_t _totalEvaluatedMessages, DeviceIDType _deviceID, header::DataHeader const& _original)
   : BaseHeader(sizeof(DataSamplingHeader), sHeaderType, sSerializationMethod, sVersion),
     sampleTimeUs(_sampleTimeUs),
     totalAcceptedMessages(_totalAcceptedMessages),
     totalEvaluatedMessages(_totalEvaluatedMessages),
-    deviceID(_deviceID)
+    deviceID(_deviceID),
+    dataDescription(_original.dataDescription),
+    dataOrigin(_original.dataOrigin),
+    subSpecification(_original.subSpecification)
 {
 }
 
@@ -42,4 +41,4 @@ const uint32_t o2::utilities::DataSamplingHeader::sVersion = 1;
 const o2::header::HeaderType o2::utilities::DataSamplingHeader::sHeaderType = header::String2<uint64_t>("DataSamp");
 const o2::header::SerializationMethod o2::utilities::DataSamplingHeader::sSerializationMethod = o2::header::gSerializationMethodNone;
 
-} // namespace o2::utilities
\ No newline at end of file
+} // namespace o2::utilities
diff --git a/Utilities/DataSampling/src/Dispatcher.cxx b/Utilities/DataSampling/src/Dispatcher.cxx
index 28ff4d5568da9..38ad15f5fd752 100644
--- a/Utilities/DataSampling/src/Dispatcher.cxx
+++ b/Utilities/DataSampling/src/Dispatcher.cxx
@@ -99,7 +99,7 @@ void Dispatcher::run(ProcessingContext& ctx)
       //  a "TST/RAWDATA/*" output.
       if (auto route = policy->match(inputMatcher); route != nullptr && policy->decide(firstPart)) {
         auto routeAsConcreteDataType = DataSpecUtils::asConcreteDataTypeMatcher(*route);
-        auto dsheader = prepareDataSamplingHeader(*policy);
+        auto dsheader = prepareDataSamplingHeader(*policy, *firstInputHeader);
         for (const auto& part : inputIt) {
           if (part.header != nullptr) {
             // We copy every header which is not DataHeader or DataProcessingHeader,
@@ -144,7 +144,7 @@ void Dispatcher::reportStats(Monitoring& monitoring) const
   monitoring.send(Metric{dispatcherTotalAcceptedMessages, "Dispatcher_messages_passed", Verbosity::Prod}.addTag(tags::Key::Subsystem, tags::Value::DataSampling));
 }
 
-DataSamplingHeader Dispatcher::prepareDataSamplingHeader(const DataSamplingPolicy& policy)
+DataSamplingHeader Dispatcher::prepareDataSamplingHeader(const DataSamplingPolicy& policy, header::DataHeader const& original)
 {
   uint64_t sampleTime = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
 
@@ -152,7 +152,8 @@ DataSamplingHeader Dispatcher::prepareDataSamplingHeader(const DataSamplingPolic
     sampleTime,
     policy.getTotalAcceptedMessages(),
     policy.getTotalEvaluatedMessages(),
-    mDeviceID};
+    mDeviceID,
+    original};
 }
 
 header::Stack Dispatcher::extractAdditionalHeaders(const char* inputHeaderStack) const
diff --git a/Utilities/DataSampling/test/test_DataSamplingHeader.cxx b/Utilities/DataSampling/test/test_DataSamplingHeader.cxx
index 48ab5ba953eec..377e9d855467d 100644
--- a/Utilities/DataSampling/test/test_DataSamplingHeader.cxx
+++ b/Utilities/DataSampling/test/test_DataSamplingHeader.cxx
@@ -21,57 +21,62 @@
 using namespace o2::utilities;
 using namespace o2::header;
 
-BOOST_AUTO_TEST_CASE(DataSamplingHeaderDefault)
-{
-  DataSamplingHeader header;
-
-  BOOST_CHECK_EQUAL(header.sampleTimeUs, 0);
-  BOOST_CHECK_EQUAL(header.totalAcceptedMessages, 0);
-  BOOST_CHECK_EQUAL(header.totalEvaluatedMessages, 0);
-  BOOST_CHECK_EQUAL(strcmp(header.deviceID.str, ""), 0);
-}
-
 BOOST_AUTO_TEST_CASE(DataSamplingHeaderInit)
 {
-  DataSamplingHeader header{123, 456, 789, "abc"};
+  o2::header::DataHeader original("A", "TST", 1);
+  DataSamplingHeader header{123, 456, 789, "abc", original};
 
   BOOST_CHECK_EQUAL(header.sampleTimeUs, 123);
   BOOST_CHECK_EQUAL(header.totalAcceptedMessages, 456);
   BOOST_CHECK_EQUAL(header.totalEvaluatedMessages, 789);
   BOOST_CHECK_EQUAL(strcmp(header.deviceID.str, "abc"), 0);
+  BOOST_CHECK_EQUAL(strcmp(header.dataOrigin.str, "TST"), 0);
+  BOOST_CHECK_EQUAL(strcmp(header.dataDescription.str, "A"), 0);
+  BOOST_CHECK_EQUAL(header.subSpecification, 1);
 }
 
 BOOST_AUTO_TEST_CASE(DataSamplingHeaderCopy)
 {
-  DataSamplingHeader header{123, 456, 789, "abc"};
+  o2::header::DataHeader original("A", "TST", 1);
+  DataSamplingHeader header{123, 456, 789, "abc", original};
   DataSamplingHeader copy(header);
 
   BOOST_CHECK_EQUAL(copy.sampleTimeUs, 123);
   BOOST_CHECK_EQUAL(copy.totalAcceptedMessages, 456);
   BOOST_CHECK_EQUAL(copy.totalEvaluatedMessages, 789);
   BOOST_CHECK_EQUAL(strcmp(copy.deviceID.str, "abc"), 0);
+  BOOST_CHECK_EQUAL(strcmp(copy.dataOrigin.str, "TST"), 0);
+  BOOST_CHECK_EQUAL(strcmp(copy.dataDescription.str, "A"), 0);
+  BOOST_CHECK_EQUAL(copy.subSpecification, 1);
 }
 
 BOOST_AUTO_TEST_CASE(DataSamplingHeaderAssignement)
 {
-  DataSamplingHeader first{123, 456, 789, "abc"};
-  DataSamplingHeader second;
-  second = first;
+  o2::header::DataHeader original("A", "TST", 1);
+  DataSamplingHeader first{123, 456, 789, "abc", original};
+  DataSamplingHeader second = first;
 
   BOOST_CHECK_EQUAL(first.sampleTimeUs, 123);
   BOOST_CHECK_EQUAL(first.totalAcceptedMessages, 456);
   BOOST_CHECK_EQUAL(first.totalEvaluatedMessages, 789);
   BOOST_CHECK_EQUAL(strcmp(first.deviceID.str, "abc"), 0);
+  BOOST_CHECK_EQUAL(strcmp(first.dataOrigin.str, "TST"), 0);
+  BOOST_CHECK_EQUAL(strcmp(first.dataDescription.str, "A"), 0);
+  BOOST_CHECK_EQUAL(first.subSpecification, 1);
 
   BOOST_CHECK_EQUAL(second.sampleTimeUs, 123);
   BOOST_CHECK_EQUAL(second.totalAcceptedMessages, 456);
   BOOST_CHECK_EQUAL(second.totalEvaluatedMessages, 789);
   BOOST_CHECK_EQUAL(strcmp(second.deviceID.str, "abc"), 0);
+  BOOST_CHECK_EQUAL(strcmp(second.dataOrigin.str, "TST"), 0);
+  BOOST_CHECK_EQUAL(strcmp(second.dataDescription.str, "A"), 0);
+  BOOST_CHECK_EQUAL(second.subSpecification, 1);
 }
 
 BOOST_AUTO_TEST_CASE(DataSamplingHeaderOnStack)
 {
-  DataSamplingHeader header{123, 456, 789, "abc"};
+  o2::header::DataHeader original("A", "TST", 1);
+  DataSamplingHeader header{123, 456, 789, "abc", original};
   Stack headerStack{header};
 
   const auto* dsHeaderFromStack = get<DataSamplingHeader*>(headerStack.data());
@@ -81,4 +86,7 @@ BOOST_AUTO_TEST_CASE(DataSamplingHeaderOnStack)
   BOOST_CHECK_EQUAL(dsHeaderFromStack->totalAcceptedMessages, 456);
   BOOST_CHECK_EQUAL(dsHeaderFromStack->totalEvaluatedMessages, 789);
   BOOST_CHECK_EQUAL(strcmp(dsHeaderFromStack->deviceID.str, "abc"), 0);
-}
\ No newline at end of file
+  BOOST_CHECK_EQUAL(strcmp(dsHeaderFromStack->dataOrigin.str, "TST"), 0);
+  BOOST_CHECK_EQUAL(strcmp(dsHeaderFromStack->dataDescription.str, "A"), 0);
+  BOOST_CHECK_EQUAL(dsHeaderFromStack->subSpecification, 1);
+}

From a4e08418b60179e006690b1c056f5d3e553b934a Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 10 Apr 2025 22:40:19 +0200
Subject: [PATCH 0216/1764] DPL: exclude tfCounter == 0 messages for EOS
 (#14169)

* DPL: exclude tfCounter == 0 messages for EOS
---
 Framework/Core/src/ExternalFairMQDeviceProxy.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index e67e484f7faf5..cfc445725a92d 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -534,7 +534,7 @@ InjectorFunction dplModelAdaptor(std::vector<OutputSpec> const& filterSpecs, DPL
       timingInfo.runNumber = dh->runNumber;
       timingInfo.tfCounter = dh->tfCounter;
       LOG(debug) << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();
-      if (dh->runNumber == 0 || (dh->tfCounter == 0 && o2::header::get<SourceInfoHeader*>(header) == nullptr) || (fmqRunNumber > 0 && fmqRunNumber != dh->runNumber)) {
+      if (dh->runNumber == 0 || (dh->tfCounter == 0 && dh->dataDescription.as<std::string>() != "EOS") || (fmqRunNumber > 0 && fmqRunNumber != dh->runNumber)) {
         LOG(error) << "INVALID runNumber / tfCounter: runNumber " << dh->runNumber
                    << ", tfCounter " << dh->tfCounter << ", FMQ runNumber " << fmqRunNumber
                    << " for msgidx " << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();

From 4655f501f3a603da52150084145b31c225f5b4e5 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 10 Apr 2025 14:31:11 +0200
Subject: [PATCH 0217/1764] TPC cluster/digits helper can walk over sampled
 data

---
 DataFormats/Detectors/TPC/CMakeLists.txt                     | 1 +
 .../Detectors/TPC/include/DataFormatsTPC/WorkflowHelper.h    | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/DataFormats/Detectors/TPC/CMakeLists.txt b/DataFormats/Detectors/TPC/CMakeLists.txt
index b8b93c308e85d..81b1d5efad59a 100644
--- a/DataFormats/Detectors/TPC/CMakeLists.txt
+++ b/DataFormats/Detectors/TPC/CMakeLists.txt
@@ -34,6 +34,7 @@ o2_add_library(
                         O2::ReconstructionDataFormats
                         O2::CommonDataFormat
                         O2::Headers
+                        O2::DataSampling
                         O2::Algorithm)
 
 o2_target_root_dictionary(
diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/WorkflowHelper.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/WorkflowHelper.h
index 30b40ed70b9c7..f4a318bc30101 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/WorkflowHelper.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/WorkflowHelper.h
@@ -21,6 +21,7 @@
 #include "Framework/DataRefUtils.h"
 #include <Framework/InputRecord.h>
 #include "Framework/InputRecordWalker.h"
+#include "DataSampling/DataSamplingHeader.h"
 #include "DataFormatsTPC/TrackTPC.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
@@ -80,7 +81,7 @@ static auto getWorkflowTPCInput(o2::framework::ProcessingContext& pc, int verbos
     if (do_digits) {
       std::fill(inputDigitsMCIndex.begin(), inputDigitsMCIndex.end(), -1);
     }
-    for (auto const& ref : o2::framework::InputRecordWalker(pc.inputs(), filter)) {
+    for (auto const& ref : o2::framework::InputRecordWalker<o2::utilities::DataSamplingHeader>(pc.inputs(), filter)) {
       auto const* sectorHeader = o2::framework::DataRefUtils::getHeader<TPCSectorHeader*>(ref);
       if (sectorHeader == nullptr) {
         // FIXME: think about error policy
@@ -127,7 +128,7 @@ static auto getWorkflowTPCInput(o2::framework::ProcessingContext& pc, int verbos
       {"check", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, "CLUSTERNATIVE"}, o2::framework::Lifetime::Timeframe},
     };
     unsigned long recvMask = 0;
-    for (auto const& ref : o2::framework::InputRecordWalker(pc.inputs(), filter)) {
+    for (auto const& ref : o2::framework::InputRecordWalker<o2::utilities::DataSamplingHeader>(pc.inputs(), filter)) {
       auto const* sectorHeader = o2::framework::DataRefUtils::getHeader<TPCSectorHeader*>(ref);
       if (sectorHeader == nullptr) {
         throw std::runtime_error("sector header missing on header stack");

From 356d6990cd1fdc13e28dbbb71ad0a4777cd1dd8b Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 10 Apr 2025 21:54:25 +0200
Subject: [PATCH 0218/1764] Add in-place replaceAll method to StrUtils

---
 Common/Utils/include/CommonUtils/StringUtils.h |  3 +++
 Common/Utils/src/StringUtils.cxx               | 13 +++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/Common/Utils/include/CommonUtils/StringUtils.h b/Common/Utils/include/CommonUtils/StringUtils.h
index 7a2edbf3b2f53..c68e441d5b1c4 100644
--- a/Common/Utils/include/CommonUtils/StringUtils.h
+++ b/Common/Utils/include/CommonUtils/StringUtils.h
@@ -146,6 +146,9 @@ struct Str {
     return s.str();
   }
 
+  // replace all occurencies of from by to, return count
+  static int replaceAll(std::string& s, const std::string& from, const std::string& to);
+
   // generate random string of given length, suitable for file names
   static std::string getRandomString(int length);
 
diff --git a/Common/Utils/src/StringUtils.cxx b/Common/Utils/src/StringUtils.cxx
index 03bf68df5a41c..4c0dd30ae6211 100644
--- a/Common/Utils/src/StringUtils.cxx
+++ b/Common/Utils/src/StringUtils.cxx
@@ -34,6 +34,19 @@ std::vector<std::string> Str::tokenize(const std::string& src, char delim, bool
   return tokens;
 }
 
+// replace all occurencies of from by to, return count
+int Str::replaceAll(std::string& s, const std::string& from, const std::string& to)
+{
+  int count = 0;
+  size_t pos = 0;
+  while ((pos = s.find(from, pos)) != std::string::npos) {
+    s.replace(pos, from.length(), to);
+    pos += to.length(); // Handles case where 'to' is a substring of 'from'
+    count++;
+  }
+  return count;
+}
+
 // generate random string of given lenght, suitable for file names
 std::string Str::getRandomString(int lenght)
 {

From b75d6433d3513c547588a9f93d0c64d536607311 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 10 Apr 2025 17:08:30 +0200
Subject: [PATCH 0219/1764] o2-ecs-grp-create creates CTP/Config if
 --original-run <run> passed at SOR

Will clone the CTP/Config/Config of (replayed) original-run with the credentials of the new synthetic run
---
 Detectors/GRP/workflows/CMakeLists.txt        |  1 +
 .../GRP/workflows/src/create-grp-ecs.cxx      | 64 +++++++++++++++++--
 2 files changed, 59 insertions(+), 6 deletions(-)

diff --git a/Detectors/GRP/workflows/CMakeLists.txt b/Detectors/GRP/workflows/CMakeLists.txt
index ea56cf8270335..1097855a5d579 100644
--- a/Detectors/GRP/workflows/CMakeLists.txt
+++ b/Detectors/GRP/workflows/CMakeLists.txt
@@ -45,6 +45,7 @@ o2_add_executable(grp-create
                   SOURCES src/create-grp-ecs.cxx
                   PUBLIC_LINK_LIBRARIES O2::DetectorsCommonDataFormats
                                         O2::DataFormatsParameters
+                                        O2::DataFormatsCTP
                                         O2::CommonUtils
                                         O2::CCDB
                                         Boost::program_options)
diff --git a/Detectors/GRP/workflows/src/create-grp-ecs.cxx b/Detectors/GRP/workflows/src/create-grp-ecs.cxx
index 95bfb878cee9d..873133e0dd46b 100644
--- a/Detectors/GRP/workflows/src/create-grp-ecs.cxx
+++ b/Detectors/GRP/workflows/src/create-grp-ecs.cxx
@@ -15,8 +15,10 @@
 #include <regex>
 #include <TSystem.h>
 #include "DataFormatsParameters/GRPECSObject.h"
+#include "DataFormatsCTP/Configuration.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "CCDB/CcdbApi.h"
+#include "CCDB/BasicCCDBManager.h"
 #include "CommonUtils/NameConf.h"
 #include "CommonUtils/StringUtils.h"
 
@@ -31,6 +33,7 @@ enum CCDBRefreshMode { NONE,
 
 int createGRPECSObject(const std::string& dataPeriod,
                        int run,
+                       int runOrig, // in case of replay
                        int runTypeI,
                        int nHBPerTF,
                        const std::string& _detsReadout,
@@ -44,13 +47,14 @@ int createGRPECSObject(const std::string& dataPeriod,
                        long marginAtSOR,
                        long marginAtEOR,
                        const std::string& ccdbServer = "",
+                       std::string ccdbServerInp = "",
                        const std::string& metaDataStr = "",
                        CCDBRefreshMode refresh = CCDBRefreshMode::NONE)
 {
   int retValGLO = 0;
   int retValRCT = 0;
   int retValGLOmd = 0;
-
+  int retValCTP = 0;
   // substitute TRG by CTP
   std::regex regCTP(R"((^\s*|,\s*)(TRG)(\s*,|\s*$))");
   std::string detsReadout{std::regex_replace(_detsReadout, regCTP, "$1CTP$3")};
@@ -78,6 +82,8 @@ int createGRPECSObject(const std::string& dataPeriod,
     tendVal = tend + marginAtEOR;
   }
   GRPECSObject grpecs;
+  o2::ctp::CTPConfiguration* ctpConfig = nullptr;
+  o2::ctp::CTPConfiguration ctpConfigNew;
   grpecs.setTimeStart(tstart);
   grpecs.setTimeEnd(tend);
   grpecs.setTimeStartCTP(tstartCTP);
@@ -119,10 +125,32 @@ int createGRPECSObject(const std::string& dataPeriod,
     }
   };
 
+  if (ccdbServerInp.empty()) {
+    ccdbServerInp = ccdbServer;
+  }
+  if (runOrig > 0 && runOrig != run && tend <= tstart && !ccdbServerInp.empty()) { // create CTP config
+    try {
+      auto& bcm = o2::ccdb::BasicCCDBManager::instance();
+      bcm.setURL(ccdbServerInp);
+      bcm.setFatalWhenNull(false);
+      ctpConfig = bcm.getForRun<o2::ctp::CTPConfiguration>("CTP/Config/Config", runOrig);
+      if (!ctpConfig) {
+        throw std::runtime_error(fmt::format("Failed to access CTP/Config/Config for original run {}", runOrig));
+      }
+      std::string cfstr = ctpConfig->getConfigString(), srun{fmt::format("run {}", run)}, srunOrig{fmt::format("run {}", runOrig)};
+      o2::utils::Str::replaceAll(cfstr, srunOrig, srun);
+      ctpConfigNew.loadConfigurationRun3(cfstr);
+      ctpConfigNew.setRunNumber(run);
+    } catch (std::exception e) {
+      LOGP(error, "Failed to create CTP/Config/Config from the original run {}, reason: {}", runOrig, e.what());
+    }
+  }
+
   toKeyValPairs(metaDataStr);
 
   if (!ccdbServer.empty()) {
     CcdbApi api;
+
     const std::string objPath{"GLO/Config/GRPECS"};
     api.init(ccdbServer);
     metadata["responsible"] = "ECS";
@@ -181,13 +209,33 @@ int createGRPECSObject(const std::string& dataPeriod,
         }
       }
     }
+
+    if (ctpConfig && ctpConfigNew.getRunNumber() == run) { // create CTP config
+      std::map<std::string, std::string> metadataCTP;
+      metadataCTP["runNumber"] = fmt::format("{}", run);
+      metadataCTP["comment"] = fmt::format("cloned from run {}", runOrig);
+      retValCTP = api.storeAsTFileAny(&ctpConfigNew, "CTP/Config/Config", metadataCTP, tstart, tendVal);
+      if (retValCTP == 0) {
+        LOGP(info, "Uploaded to {}/{} with validity {}:{} for SOR:{}/EOR:{}, cloned from run {}", ccdbServer, "CTP/Config/Config", tstart, tendVal, tstart, tend, runOrig);
+      } else {
+        LOGP(alarm, "Upload to {}/{} with validity {}:{} for SOR:{}/EOR:{} (cloned from run {}) FAILED, returned with code {}", ccdbServer, "CTP/Config/Config", tstart, tendVal, tstart, tend, runOrig, retValCTP);
+      }
+    }
   } else { // write a local file
     auto fname = o2::base::NameConf::getGRPECSFileName();
     TFile grpF(fname.c_str(), "recreate");
     grpF.WriteObjectAny(&grpecs, grpecs.Class(), o2::base::NameConf::CCDBOBJECT.data());
-    LOG(info) << "Stored to local file " << fname;
+    grpF.Close();
+    LOGP(info, "Stored GRPECS to local file {}", fname);
+    if (ctpConfig && ctpConfigNew.getRunNumber() == run) {
+      std::string ctnpfname = fmt::format("CTPConfig_{}_from_{}.root", run, runOrig);
+      TFile ctpF(ctnpfname.c_str(), "recreate");
+      ctpF.WriteObjectAny(&ctpConfigNew, ctpConfigNew.Class(), o2::base::NameConf::CCDBOBJECT.data());
+      ctpF.Close();
+      LOGP(info, "Stored CTPConfig to local file {}", ctnpfname);
+    }
   }
-  //
+
   if (refresh != CCDBRefreshMode::NONE && !ccdbServer.empty()) {
     auto cmd = fmt::format("curl -I -i -s \"{}{}latest/%5Cw%7B3%7D/.*/`date +%s000`/?prepare={}\"", ccdbServer, ccdbServer.back() == '/' ? "" : "/", refresh == CCDBRefreshMode::SYNC ? "sync" : "true");
     auto t0 = std::chrono::high_resolution_clock::now();
@@ -195,7 +243,7 @@ int createGRPECSObject(const std::string& dataPeriod,
     auto t1 = std::chrono::high_resolution_clock::now();
     LOGP(info, "Executed [{}] -> {} in {:.3f} s", cmd, res, std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count() / 1000.f);
   }
-  if (retValGLO != 0 || retValRCT != 0 || retValGLOmd != 0) {
+  if (retValGLO != 0 || retValRCT != 0 || retValGLOmd != 0 || retValCTP != 0) {
     return 4;
   }
   return 0;
@@ -229,10 +277,12 @@ int main(int argc, char** argv)
     add_option("start-time-ctp", bpo::value<long>()->default_value(0), "run start CTP time in ms, same as ECS if not set or 0");
     add_option("end-time-ctp", bpo::value<long>()->default_value(0), "run end CTP time in ms, same as ECS if not set or 0");
     add_option("ccdb-server", bpo::value<std::string>()->default_value("http://alice-ccdb.cern.ch"), "CCDB server for upload, local file if empty");
+    add_option("ccdb-server-input", bpo::value<std::string>()->default_value(""), "CCDB server for inputs (if needed, e.g. CTPConfig), dy default ccdb-server is used");
     add_option("meta-data,m", bpo::value<std::string>()->default_value("")->implicit_value(""), "metadata as key1=value1;key2=value2;..");
     add_option("refresh", bpo::value<string>()->default_value("")->implicit_value("async"), R"(refresh server cache after upload: "none" (or ""), "async" (non-blocking) and "sync" (blocking))");
     add_option("marginSOR", bpo::value<long>()->default_value(4 * o2::ccdb::CcdbObjectInfo::DAY), "validity at SOR");
     add_option("marginEOR", bpo::value<long>()->default_value(10 * o2::ccdb::CcdbObjectInfo::MINUTE), "validity margin to add after EOR");
+    add_option("original-run,o", bpo::value<int>()->default_value(0), "if >0, use as the source run to create CTP/Config/Config object");
     opt_all.add(opt_general).add(opt_hidden);
     bpo::store(bpo::command_line_parser(argc, argv).options(opt_all).positional(opt_pos).run(), vm);
 
@@ -253,13 +303,13 @@ int main(int argc, char** argv)
   }
   if (vm.count("run") == 0) {
     std::cerr << "ERROR: "
-              << "obligator run number is missing" << std::endl;
+              << "obligatory run number is missing" << std::endl;
     std::cerr << opt_general << std::endl;
     exit(3);
   }
   if (vm.count("period") == 0) {
     std::cerr << "ERROR: "
-              << "obligator data taking period name is missing" << std::endl;
+              << "obligatory data taking period name is missing" << std::endl;
     std::cerr << opt_general << std::endl;
     exit(3);
   }
@@ -278,6 +328,7 @@ int main(int argc, char** argv)
   int retVal = createGRPECSObject(
     vm["period"].as<std::string>(),
     vm["run"].as<int>(),
+    vm["original-run"].as<int>(),
     vm["run-type"].as<int>(),
     vm["hbf-per-tf"].as<int>(),
     vm["detectors"].as<std::string>(),
@@ -291,6 +342,7 @@ int main(int argc, char** argv)
     vm["marginSOR"].as<long>(),
     vm["marginEOR"].as<long>(),
     vm["ccdb-server"].as<std::string>(),
+    vm["ccdb-server-input"].as<std::string>(),
     vm["meta-data"].as<std::string>(),
     refresh);
 

From 9e322a95f4f1b2e81c54d71a360a3ef8ca159f0d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 11 Apr 2025 13:38:56 +0200
Subject: [PATCH 0220/1764] DPL Analysis: improve handling of tables with
 sources (#14172)

---
 .../Core/include/Framework/AnalysisHelpers.h  | 57 +++++++++++++++----
 .../Core/include/Framework/AnalysisTask.h     | 51 +----------------
 Framework/Core/src/WorkflowHelpers.cxx        | 18 +++---
 3 files changed, 57 insertions(+), 69 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 985f80cd548bc..55d2490dff1bc 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -13,7 +13,6 @@
 
 #include "Framework/ASoA.h"
 #include "Framework/DataAllocator.h"
-#include "Framework/ExpressionHelpers.h"
 #include "Framework/IndexBuilderHelpers.h"
 #include "Framework/InputSpec.h"
 #include "Framework/Output.h"
@@ -28,6 +27,48 @@
 #include <string>
 namespace o2::soa
 {
+template <TableRef R>
+constexpr auto tableRef2ConfigParamSpec()
+{
+  return o2::framework::ConfigParamSpec{
+    std::string{"input:"} + o2::aod::label<R>(),
+    framework::VariantType::String,
+    aod::sourceSpec<R>(),
+    {"\"\""}};
+}
+
+namespace
+{
+template <soa::with_sources T>
+inline constexpr auto getSources()
+{
+  return []<size_t N, std::array<soa::TableRef, N> refs>() {
+    return []<size_t... Is>(std::index_sequence<Is...>) {
+      return std::vector{soa::tableRef2ConfigParamSpec<refs[Is]>()...};
+    }(std::make_index_sequence<N>());
+  }.template operator()<T::sources.size(), T::sources>();
+}
+
+template <soa::with_sources T>
+constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  std::vector<framework::ConfigParamSpec> inputMetadata;
+  auto inputSources = getSources<T>();
+  std::sort(inputSources.begin(), inputSources.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name < b.name; });
+  auto last = std::unique(inputSources.begin(), inputSources.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name == b.name; });
+  inputSources.erase(last, inputSources.end());
+  inputMetadata.insert(inputMetadata.end(), inputSources.begin(), inputSources.end());
+  return inputMetadata;
+}
+
+template <typename T>
+  requires(!soa::with_sources<T>)
+constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  return {};
+}
+}  // namespace
+
 template <TableRef R>
 constexpr auto tableRef2InputSpec()
 {
@@ -35,7 +76,9 @@ constexpr auto tableRef2InputSpec()
     o2::aod::label<R>(),
     o2::aod::origin<R>(),
     o2::aod::description(o2::aod::signature<R>()),
-    R.version};
+    R.version,
+    framework::Lifetime::Timeframe,
+    getInputMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>()};
 }
 
 template <TableRef R>
@@ -64,16 +107,6 @@ constexpr auto tableRef2OutputRef()
     o2::aod::label<R>(),
     R.version};
 }
-
-template <TableRef R>
-constexpr auto tableRef2ConfigParamSpec()
-{
-  return o2::framework::ConfigParamSpec{
-    std::string{"input:"} + o2::aod::label<R>(),
-    framework::VariantType::String,
-    aod::sourceSpec<R>(),
-    {"\"\""}};
-}
 }  // namespace o2::soa
 
 namespace o2::framework
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index bd1a1cfd88954..c7f3da1948c62 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -65,46 +65,6 @@ concept is_enumeration = is_enumeration_v<std::decay_t<T>>;
 // the contents of an AnalysisTask...
 namespace {
 struct AnalysisDataProcessorBuilder {
-  template <typename T>
-  static ConfigParamSpec getSpec()
-  {
-    if constexpr (soa::has_metadata<aod::MetadataTrait<T>>) {
-      return ConfigParamSpec{std::string{"input:"} + aod::MetadataTrait<T>::metadata::tableLabel(), VariantType::String, aod::MetadataTrait<T>::metadata::sourceSpec(), {"\"\""}};
-    } else {
-      using O1 = framework::pack_element_t<0, typename T::originals>;
-      return ConfigParamSpec{std::string{"input:"} + aod::MetadataTrait<T>::metadata::tableLabel(), VariantType::String, aod::MetadataTrait<O1>::metadata::sourceSpec(), {"\"\""}};
-    }
-  }
-
-  template <soa::TableRef R>
-  static ConfigParamSpec getSpec()
-  {
-    return soa::tableRef2ConfigParamSpec<R>();
-  }
-
-  template <soa::with_sources T>
-  static inline auto getSources()
-  {
-    return []<size_t N, std::array<soa::TableRef, N> refs>() {
-      return []<size_t... Is>(std::index_sequence<Is...>) {
-        return std::vector{soa::tableRef2ConfigParamSpec<refs[Is]>()...};
-      }(std::make_index_sequence<N>());
-    }.template operator()<T::sources.size(), T::sources>();
-  }
-
-  template <soa::with_sources T>
-
-  static auto getInputMetadata()
-  {
-    std::vector<ConfigParamSpec> inputMetadata;
-    auto inputSources = getSources<T>();
-    std::sort(inputSources.begin(), inputSources.end(), [](ConfigParamSpec const& a, ConfigParamSpec const& b) { return a.name < b.name; });
-    auto last = std::unique(inputSources.begin(), inputSources.end(), [](ConfigParamSpec const& a, ConfigParamSpec const& b) { return a.name == b.name; });
-    inputSources.erase(last, inputSources.end());
-    inputMetadata.insert(inputMetadata.end(), inputSources.begin(), inputSources.end());
-    return inputMetadata;
-  }
-
   template <typename G, typename... Args>
   static void addGroupingCandidates(std::vector<StringPair>& bk, std::vector<StringPair>& bku)
   {
@@ -130,14 +90,9 @@ struct AnalysisDataProcessorBuilder {
   template <soa::TableRef R>
   static void addOriginalRef(const char* name, bool value, std::vector<InputSpec>& inputs)
   {
-    using metadata = typename aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata;
-    std::vector<ConfigParamSpec> inputMetadata;
-    inputMetadata.emplace_back(ConfigParamSpec{std::string{"control:"} + name, VariantType::Bool, value, {"\"\""}});
-    if constexpr (soa::with_sources<metadata>) {
-      auto inputSources = getInputMetadata<metadata>();
-      inputMetadata.insert(inputMetadata.end(), inputSources.begin(), inputSources.end());
-    }
-    DataSpecUtils::updateInputList(inputs, InputSpec{o2::aod::label<R>(), o2::aod::origin<R>(), aod::description(o2::aod::signature<R>()), R.version, Lifetime::Timeframe, inputMetadata});
+    auto spec = soa::tableRef2InputSpec<R>();
+    spec.metadata.emplace_back(ConfigParamSpec{std::string{"control:"} + name, VariantType::Bool, value, {"\"\""}});
+    DataSpecUtils::updateInputList(inputs, std::move(spec));
   }
 
   /// helpers to append expression information for a single argument
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index b18b559fe99fb..652e863f98394 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -385,6 +385,15 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   auto outputSpecLessThan = [](OutputSpec const& lhs, OutputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
   std::sort(ac.requestedDYNs.begin(), ac.requestedDYNs.end(), inputSpecLessThan);
   std::sort(ac.providedDYNs.begin(), ac.providedDYNs.end(), outputSpecLessThan);
+
+  DataProcessorSpec indexBuilder{
+    "internal-dpl-aod-index-builder",
+    {},
+    {},
+    readers::AODReaderHelpers::indexBuilderCallback(ac.requestedIDXs),
+    {}};
+  AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.requestedIDXs, ac.requestedAODs, ac.requestedDYNs, indexBuilder);
+
   for (auto& input : ac.requestedDYNs) {
     if (std::none_of(ac.providedDYNs.begin(), ac.providedDYNs.end(), [&input](auto const& x) { return DataSpecUtils::match(input, x); })) {
       ac.spawnerInputs.emplace_back(input);
@@ -397,15 +406,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     {},
     readers::AODReaderHelpers::aodSpawnerCallback(ac.spawnerInputs),
     {}};
-
-  DataProcessorSpec indexBuilder{
-    "internal-dpl-aod-index-builder",
-    {},
-    {},
-    readers::AODReaderHelpers::indexBuilderCallback(ac.requestedIDXs),
-    {}};
-
-  AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.requestedIDXs, ac.requestedAODs, ac.requestedDYNs, indexBuilder);
   AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, aodSpawner);
 
   AnalysisSupportHelpers::addMissingOutputsToReader(ac.providedAODs, ac.requestedAODs, aodReader);

From 206d9ab0ef4c905694237d9cb36a5d966e284aaf Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sat, 12 Apr 2025 08:13:44 +0200
Subject: [PATCH 0221/1764] ITS3: fix tracking initialisation (#14154)

---
 .../ITS3/reconstruction/src/TrackingInterface.cxx     | 11 +++++++++++
 Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx  |  1 -
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
index 10c6b9265a8bb..afb276e956e76 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
@@ -14,6 +14,7 @@
 #include "ITSBase/GeometryTGeo.h"
 #include "ITSMFTBase/DPLAlpideParam.h"
 #include "DetectorsBase/GRPGeomHelper.h"
+#include "Framework/DeviceSpec.h"
 
 namespace o2::its3
 {
@@ -31,7 +32,17 @@ void ITS3TrackingInterface::updateTimeDependentParams(framework::ProcessingConte
     }
     auto geom = its::GeometryTGeo::Instance();
     geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G));
+    initialise();
     getConfiguration(pc);
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
+      o2::its::VertexerParamConfig::Instance().printKeyValues();
+      o2::its::TrackerParamConfig::Instance().printKeyValues();
+      const auto& trParams = getTracker()->getParameters();
+      for (size_t it = 0; it < trParams.size(); it++) {
+        const auto& par = trParams[it];
+        LOGP(info, "recoIter#{} : {}", it, par.asString());
+      }
+    }
   }
 }
 
diff --git a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
index 90f94e625d6ea..5b710a3d11fef 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
@@ -67,7 +67,6 @@ void TrackerDPL::init(InitContext& ic)
   mITS3TrackingInterface.setTraitsFromProvider(mChainITS->GetITSVertexerTraits(),
                                                mChainITS->GetITSTrackerTraits(),
                                                mChainITS->GetITSTimeframe());
-  mITS3TrackingInterface.initialise();
 }
 
 void TrackerDPL::stop()

From 4be2de6e8316d05db24c5439b56ec6f67ce89e88 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sat, 12 Apr 2025 08:14:35 +0200
Subject: [PATCH 0222/1764] ITS3: add metal layer + fix macros (#13894)

---
 Detectors/Upgrades/ITS3/CMakeLists.txt        |   6 +-
 Detectors/Upgrades/ITS3/README.md             | 105 +++++++-
 .../ITS3/alignment/src/MisalignmentHits.cxx   |   1 -
 Detectors/Upgrades/ITS3/base/CMakeLists.txt   |  12 +-
 .../ITS3/base/include/ITS3Base/ITS3Params.h   |   3 +-
 ...tionSuperAlpide.h => SegmentationMosaix.h} | 133 ++++-----
 .../ITS3/base/include/ITS3Base/SpecsV2.h      | 150 +++++++----
 .../Upgrades/ITS3/base/src/ITS3BaseLinkDef.h  |   1 -
 .../ITS3/base/src/SegmentationSuperAlpide.cxx |  20 --
 Detectors/Upgrades/ITS3/data/CMakeLists.txt   |  25 ++
 .../Upgrades/ITS3/macros/test/CMakeLists.txt  |   4 +-
 .../ITS3/macros/test/CheckClusterSize.C       |  24 +-
 .../ITS3/macros/test/CheckClustersITS3.C      |  66 +++--
 .../ITS3/macros/test/CheckDigitsDensity.C     |  16 +-
 .../ITS3/macros/test/CheckDigitsITS3.C        |  21 +-
 .../Upgrades/ITS3/macros/test/CheckHits.C     |   2 -
 ...erAlpideSegment.C => CheckMosaixSegment.C} |  74 +++--
 ...gmentTrans.C => CheckMosaixSegmentTrans.C} |  42 ++-
 .../ITS3/macros/test/CheckTileNumbering.C     |   6 +-
 .../macros/test/CompareClustersAndDigits.C    |  39 +--
 .../ITS3/macros/test/CreateDictionariesITS3.C | 115 +++++---
 .../ITS3/macros/test/TestSensorGeometry.C     |  19 +-
 .../BuildTopologyDictionary.h                 |  48 ++--
 .../include/ITS3Reconstruction/Clusterer.h    |  10 +-
 .../include/ITS3Reconstruction/IOUtils.h      |  23 +-
 .../include/ITS3Reconstruction/LookUp.h       |  20 +-
 .../ITS3Reconstruction/TopologyDictionary.h   | 124 +++++----
 .../src/BuildTopologyDictionary.cxx           | 254 +++++++++++-------
 .../ITS3/reconstruction/src/Clusterer.cxx     |  21 +-
 .../ITS3/reconstruction/src/IOUtils.cxx       |   3 -
 .../src/ITS3ReconstructionLinkDef.h           |   1 +
 .../ITS3/reconstruction/src/LookUp.cxx        |  21 +-
 .../reconstruction/src/TopologyDictionary.cxx | 176 ++++++++----
 .../Upgrades/ITS3/simulation/CMakeLists.txt   |   4 +-
 .../DescriptorInnerBarrelITS3.h               |   6 +-
 .../include/ITS3Simulation/DigiParams.h       |  45 ++++
 .../include/ITS3Simulation/Digitizer.h        |  31 ++-
 .../include/ITS3Simulation/ITS3Layer.h        |  25 +-
 .../src/DescriptorInnerBarrelITS3.cxx         |   4 +-
 .../ITS3/simulation/src/DigiParams.cxx        |  40 +++
 .../ITS3/simulation/src/Digitizer.cxx         | 111 +++++---
 .../ITS3/simulation/src/ITS3Layer.cxx         |  54 ++--
 .../simulation/src/ITS3SimulationLinkDef.h    |   1 +
 43 files changed, 1197 insertions(+), 709 deletions(-)
 rename Detectors/Upgrades/ITS3/base/include/ITS3Base/{SegmentationSuperAlpide.h => SegmentationMosaix.h} (54%)
 delete mode 100644 Detectors/Upgrades/ITS3/base/src/SegmentationSuperAlpide.cxx
 create mode 100644 Detectors/Upgrades/ITS3/data/CMakeLists.txt
 rename Detectors/Upgrades/ITS3/macros/test/{CheckSuperAlpideSegment.C => CheckMosaixSegment.C} (78%)
 rename Detectors/Upgrades/ITS3/macros/test/{CheckSuperAlpideSegmentTrans.C => CheckMosaixSegmentTrans.C} (85%)
 create mode 100644 Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
 create mode 100644 Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx

diff --git a/Detectors/Upgrades/ITS3/CMakeLists.txt b/Detectors/Upgrades/ITS3/CMakeLists.txt
index 6965061571da6..73ad4b9d53e37 100644
--- a/Detectors/Upgrades/ITS3/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/CMakeLists.txt
@@ -9,11 +9,13 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-#add_compile_options(-O0 -g -fPIC)
+#add_compile_options(-O0 -g -fPIC -fsanitize=address)
+#add_link_options(-fsanitize=address)
 
-add_subdirectory(macros)
+add_subdirectory(data)
 add_subdirectory(simulation)
 add_subdirectory(alignment)
 add_subdirectory(base)
 add_subdirectory(workflow)
 add_subdirectory(reconstruction)
+add_subdirectory(macros)
diff --git a/Detectors/Upgrades/ITS3/README.md b/Detectors/Upgrades/ITS3/README.md
index 6d3b0d8d821fb..afcea6a5c3e17 100644
--- a/Detectors/Upgrades/ITS3/README.md
+++ b/Detectors/Upgrades/ITS3/README.md
@@ -35,7 +35,7 @@ export ALICEO2_CCDB_LOCALCACHE=${PWD}/ccdb
 
 Simulate diamond
 
-``` bash
+```bash
 # append to o2-sim
 --configKeyValues="Diamond.width[2]=6.;""
 ```
@@ -86,13 +86,27 @@ TODO
 
 ```bash
 # Create Full Geometry
-o2-sim -g pythia8pp -j10 --detectorList ALICE2.1 --run 303901 -n0
+o2-sim --detectorList ALICE2.1 --run 303901 -n0
 cp o2sim_geometry.root ${ALICEO2_CCDB_LOCALCACHE}/GLO/Config/Geometry/snapshot.root
 o2-create-aligned-geometry-workflow -b --configKeyValues "HBFUtils.startTime=1547978230000" --condition-remap="file://${ALICEO2_CCDB_LOCALCACHE}=GLO/Config/Geometry"
 cp o2sim_geometry-aligned.root ${ALICEO2_CCDB_LOCALCACHE}/GLO/Config/GeometryAligned/snapshot.root
 cp its_GeometryTGeo.root ${ALICEO2_CCDB_LOCALCACHE}/ITS/Config/Geometry/snapshot.root
 ```
 
+or copying the ideal geometry to the aligned one and:
+
+```cpp
+{
+      o2::base::GeometryManager::loadGeometry("");
+      auto itsTGeo = o2::its::GeometryTGeo::Instance();
+      itsTGeo->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2GRot));
+      TFile outF("its_GeometryTGeo.root", "recreate");
+      outF.WriteObjectAny(itsTGeo, "o2::its::GeometryTGeo", "ccdb_object");
+      outF.Close();
+      itsTGeo->destroy();
+}
+```
+
 ### Regenerating the TopologyDictionary
 
 1. Clusterization w/o tracking
@@ -158,7 +172,7 @@ The file `hijing.C` can be found [here](https://alice.its.cern.ch/jira/browse/AO
 2. (optional) Run the macro `CreateITS3StaticDeadMap.C` and/or visualize with `CheckTileNumbering.C`
 3. Move the ccdb object into `${ALICEO2_CCDB_LOCALCACHE}/IT3/Calib/DeadMap`, this is not optional since there is no default object uploaded
 4. Run digitizer with `ITS3Params.useDeadChannelMap=true;`, e.g.:
-``` bash
+```bash
 o2-sim-digitizer-workflow --configKeyValues="ITS3Params.useDeadChannelMap=true;"
 ```
 
@@ -168,6 +182,89 @@ o2-sim-digitizer-workflow --configKeyValues="ITS3Params.useDeadChannelMap=true;"
 1. Create misalignment parameters with `CreateMisalignmentITS3.C`
 2. Visualize with `ShowCoefficients.C`
 3. Run digitizer
-``` bash
+```bash
 o2-sim-digitizer-workflow -b --configKeyValues="ITS3Params.applyMisalignmentHits=true;ITS3Params.misalignmentHitsParams=misparams.root"
 ```
+
+
+### Misc
+#### Setup to run SIM+DIGIT+TRACKING
+```bash
+
+#!/bin/bash
+
+export IGNORE_VALIDITYCHECK_OF_CCDB_LOCALCACHE=1
+export ALICEO2_CCDB_LOCALCACHE=$PWD/ccdb
+
+BASE_DIR="batch_"
+TOTAL_DIRS=4
+SIM_CMD="o2-sim -g pythia8pp --detectorList ALICE2.1 -m IT3 --run 303901 -n2000 --field ccdb -j8"
+DIGIT_CMD="o2-sim-digitizer-workflow -b --interactionRate 675000 --run --configKeyValues=\"HBFUtils.runNumber=303901;HBFUtils.nHBFPerTF=32;ITSAlpideParam.roFrameLengthInBC=198\""
+RECO_CMD="o2-its3-reco-workflow -b --run --configKeyValues=\"ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;ITSCATrackerParam.useTrackFollower=0;ITSCATrackerParam.findShortTracks=1;HBFUtils.runNumber=303901;HBFUtils.nHBFPerTF=32;ITSAlpideParam.roFrameLengthInBC=198\" --tracking-mode async"
+
+for ((i = 1; i <= TOTAL_DIRS; i++)); do
+    DIR="${BASE_DIR}${i}"
+
+    if [ ! -d "$DIR" ]; then
+        mkdir "$DIR"
+    fi
+
+    if [ -f "${DIR}/sim_done" ]; then
+        echo "Skipping SIM ${DIR} because _done exists."
+        continue
+    fi
+
+    cd "$DIR"
+
+    echo "Executing SIM command in ${DIR}..."
+    eval $SIM_CMD >sim.log
+
+    touch sim_done
+
+    cd ..
+done
+
+for ((i = 1; i <= TOTAL_DIRS; i++)); do
+    DIR="${BASE_DIR}${i}"
+
+    if [ ! -d "$DIR" ]; then
+        mkdir "$DIR"
+    fi
+
+    if [ -f "${DIR}/digit_done" ]; then
+        echo "Skipping DIGIT ${DIR} because _done exists."
+        continue
+    fi
+
+    cd "$DIR"
+
+    echo "Executing DIGIT command in ${DIR}..."
+    eval $DIGIT_CMD >digit.log
+
+    touch digit_done
+
+    cd ..
+done
+
+for ((i = 1; i <= TOTAL_DIRS; i++)); do
+    DIR="${BASE_DIR}${i}"
+
+    if [ ! -d "$DIR" ]; then
+        mkdir "$DIR"
+    fi
+
+    if [ -f "${DIR}/reco_done" ]; then
+        echo "Skipping RECO ${DIR} because _done exists."
+        continue
+    fi
+
+    cd "$DIR"
+
+    echo "Executing RECO command in ${DIR}..."
+    eval $RECO_CMD >reco.log
+
+    touch reco_done
+
+    cd ..
+done
+```
diff --git a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentHits.cxx b/Detectors/Upgrades/ITS3/alignment/src/MisalignmentHits.cxx
index fbc0b5d623dca..66ab4c8090b54 100644
--- a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentHits.cxx
+++ b/Detectors/Upgrades/ITS3/alignment/src/MisalignmentHits.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 
 #include "ITS3Align/MisalignmentHits.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
 #include "ITS3Base/ITS3Params.h"
 #include "SimConfig/DigiParams.h"
 #include "DetectorsBase/Propagator.h"
diff --git a/Detectors/Upgrades/ITS3/base/CMakeLists.txt b/Detectors/Upgrades/ITS3/base/CMakeLists.txt
index 8695e2323bbab..306226e5088cf 100644
--- a/Detectors/Upgrades/ITS3/base/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/base/CMakeLists.txt
@@ -9,11 +9,9 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-o2_add_library(ITS3Base
-               SOURCES src/SegmentationSuperAlpide.cxx
-                       src/ITS3Params.cxx
-               PUBLIC_LINK_LIBRARIES O2::CommonConstants O2::MathUtils O2::DetectorsBase)
+o2_add_library(
+  ITS3Base
+  SOURCES src/ITS3Params.cxx
+  PUBLIC_LINK_LIBRARIES O2::CommonConstants O2::MathUtils O2::DetectorsBase)
 
-o2_target_root_dictionary(ITS3Base
-                          HEADERS include/ITS3Base/SegmentationSuperAlpide.h
-                                  include/ITS3Base/ITS3Params.h)
+o2_target_root_dictionary(ITS3Base HEADERS include/ITS3Base/ITS3Params.h)
diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/ITS3Params.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/ITS3Params.h
index c685bf0f085d6..0bd548cef953d 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/ITS3Params.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/ITS3Params.h
@@ -25,7 +25,8 @@ struct ITS3Params : public o2::conf::ConfigurableParamHelper<ITS3Params> {
   bool misalignmentHitsUseProp{false};                                              // Use propagtor for mis-alignment
   std::string globalGeoMisAlignerMacro{"${O2_ROOT}/share/macro/MisAlignGeoITS3.C"}; // Path to macro for global geometry mis-alignment
   // Chip studies
-  bool useDeadChannelMap{false}; // Query for a dead channel map to study disabling individual tiles
+  bool useDeadChannelMap{false};            // Query for a dead channel map to study disabling individual tiles
+  std::string chipResponseFunction{"APTS"}; // Chip response function one of "Alpide", "APTS" or "Mosaix" (not yet available)
 
   O2ParamDef(ITS3Params, "ITS3Params");
 };
diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationSuperAlpide.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
similarity index 54%
rename from Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationSuperAlpide.h
rename to Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
index dbdf90574ce5d..f8d4a784120a0 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationSuperAlpide.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
@@ -9,30 +9,39 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file SegmentationSuperAlpide.h
-/// \brief Definition of the SegmentationSuperAlpide class
+/// \file SegmentationMosaix.h
+/// \brief Definition of the SegmentationMosaix class
 /// \author felix.schlepper@cern.ch
 
-#ifndef ALICEO2_ITS3_SEGMENTATIONSUPERALPIDE_H_
-#define ALICEO2_ITS3_SEGMENTATIONSUPERALPIDE_H_
+#ifndef ALICEO2_ITS3_SEGMENTATIONMOSAIX_H_
+#define ALICEO2_ITS3_SEGMENTATIONMOSAIX_H_
+
+#include <type_traits>
 
 #include "MathUtils/Cartesian.h"
 #include "ITS3Base/SpecsV2.h"
-#include "Rtypes.h"
-
-#include <type_traits>
 
 namespace o2::its3
 {
 
 /// Segmentation and response for pixels in ITS3 upgrade
-class SegmentationSuperAlpide
+class SegmentationMosaix
 {
   // This class defines the segmenation of the pixelArray in the tile. We define
   // two coordinate systems, one width x,z detector local coordianates (cm) and
   // the more natural row,col layout: Also all the transformation between these
   // two. The class provides the transformation from the tile to TGeo
   // coordinates.
+  // In fact there exist three coordinate systems and one is transient.
+  // 1. The curved coordinate system. The chip's local coordinate system is
+  //    defined with its center at the the mid-point of the tube.
+  // 2. The flat coordinate system. This is the tube segment projected onto a flat
+  //    surface. In the projection we implicitly assume that the inner and outer
+  //    stretch does not depend on the radius.
+  //    Additionally, there is a difference between the flat geometrical center
+  //    and the phyiscal center defined by the metal layer.
+  // 3. The detector coordinate system. Defined by the row and column segmentation
+  //    defined at the upper edge in the flat coord.
 
   // row,col=0
   // |
@@ -53,25 +62,32 @@ class SegmentationSuperAlpide
   // |           |          |
   // x----------------------x
  public:
-  virtual ~SegmentationSuperAlpide() = default;
-  SegmentationSuperAlpide(const SegmentationSuperAlpide&) = default;
-  SegmentationSuperAlpide(SegmentationSuperAlpide&&) = delete;
-  SegmentationSuperAlpide& operator=(const SegmentationSuperAlpide&) = delete;
-  SegmentationSuperAlpide& operator=(SegmentationSuperAlpide&&) = delete;
-  constexpr SegmentationSuperAlpide(int layer) : mLayer{layer} {}
-
-  static constexpr int mNCols{constants::pixelarray::nCols};
-  static constexpr int mNRows{constants::pixelarray::nRows};
-  static constexpr int nPixels{mNCols * mNRows};
-  static constexpr float mLength{constants::pixelarray::length};
-  static constexpr float mWidth{constants::pixelarray::width};
-  static constexpr float mPitchCol{constants::pixelarray::length / static_cast<float>(mNCols)};
-  static constexpr float mPitchRow{constants::pixelarray::width / static_cast<float>(mNRows)};
-  static constexpr float mSensorLayerThickness{constants::thickness};
-  static constexpr float mSensorLayerThicknessEff{constants::effThickness};
-  static constexpr std::array<float, constants::nLayers> mRadii{constants::radii};
-
-  /// Transformation from the curved surface to a flat surface
+  constexpr SegmentationMosaix(int layer) : mRadius(static_cast<float>(constants::radiiMiddle[layer])) {}
+  constexpr ~SegmentationMosaix() = default;
+  constexpr SegmentationMosaix(const SegmentationMosaix&) = default;
+  constexpr SegmentationMosaix(SegmentationMosaix&&) = delete;
+  constexpr SegmentationMosaix& operator=(const SegmentationMosaix&) = default;
+  constexpr SegmentationMosaix& operator=(SegmentationMosaix&&) = delete;
+
+  static constexpr int NCols{constants::pixelarray::nCols};
+  static constexpr int NRows{constants::pixelarray::nRows};
+  static constexpr int NPixels{NCols * NRows};
+  static constexpr float Length{constants::pixelarray::length};
+  static constexpr float LengthH{Length / 2.f};
+  static constexpr float Width{constants::pixelarray::width};
+  static constexpr float WidthH{Width / 2.f};
+  static constexpr float PitchCol{constants::pixelarray::pixels::mosaix::pitchZ};
+  static constexpr float PitchRow{constants::pixelarray::pixels::mosaix::pitchX};
+  static constexpr float SensorLayerThickness{constants::totalThickness};
+  static constexpr float NominalYShift{constants::nominalYShift};
+
+  /// Transformation from the curved surface to a flat surface.
+  /// Additionally a shift in the flat coordinates must be applied because
+  /// the center of the TGeoShap when projected will be higher than the
+  /// physical thickness of the chip (we add an additional hull to account for
+  /// the copper metal interconnection which is in reality part of the chip but in our
+  /// simulation the silicon and metal layer are separated). Thus we shift the projected center
+  /// down by this difference to align the coordinate systems.
   /// \param xCurved Detector local curved coordinate x in cm with respect to
   /// the center of the sensitive volume.
   /// \param yCurved Detector local curved coordinate y in cm with respect to
@@ -80,18 +96,20 @@ class SegmentationSuperAlpide
   /// the center of the sensitive volume.
   /// \param yFlat Detector local flat coordinate y in cm with respect to
   /// the center of the sensitive volume.
-  void curvedToFlat(const float xCurved, const float yCurved, float& xFlat, float& yFlat) const noexcept
+  constexpr void curvedToFlat(const float xCurved, const float yCurved, float& xFlat, float& yFlat) const noexcept
   {
-    // MUST align the flat surface with the curved surface with the original pixel array is on
+    // MUST align the flat surface with the curved surface with the original pixel array is on and account for metal
+    // stack
     float dist = std::hypot(xCurved, yCurved);
-    float phiReadout = constants::tile::readout::width / constants::radii[mLayer];
     float phi = std::atan2(yCurved, xCurved);
-    xFlat = mRadii[mLayer] * (phi - phiReadout) - constants::pixelarray::width / 2.;
-    yFlat = dist - mRadii[mLayer];
+    xFlat = (mRadius * phi) - WidthH;
+    // the y position is in the silicon volume however we need the chip volume (silicon+metalstack)
+    // this is accounted by a y shift
+    yFlat = dist - mRadius + NominalYShift;
   }
 
   /// Transformation from the flat surface to a curved surface
-  /// It works only if the detector is not rototraslated
+  /// It works only if the detector is not rototraslated.
   /// \param xFlat Detector local flat coordinate x in cm with respect to
   /// the center of the sensitive volume.
   /// \param yFlat Detector local flat coordinate y in cm with respect to
@@ -100,13 +118,15 @@ class SegmentationSuperAlpide
   /// the center of the sensitive volume.
   /// \param yCurved Detector local curved coordinate y in cm with respect to
   /// the center of the sensitive volume.
-  void flatToCurved(float xFlat, float yFlat, float& xCurved, float& yCurved) const noexcept
+  constexpr void flatToCurved(float xFlat, float yFlat, float& xCurved, float& yCurved) const noexcept
   {
-    // MUST align the flat surface with the curved surface with the original pixel array is on
-    float dist = yFlat + mRadii[mLayer];
-    float phiReadout = constants::tile::readout::width / mRadii[mLayer];
-    xCurved = dist * std::cos(phiReadout + (xFlat + constants::pixelarray::width / 2.) / mRadii[mLayer]);
-    yCurved = dist * std::sin(phiReadout + (xFlat + constants::pixelarray::width / 2.) / mRadii[mLayer]);
+    // MUST align the flat surface with the curved surface with the original pixel array is on and account for metal
+    // stack
+    // the y position is in the chip volume however we need the silicon volume
+    // this is accounted by a -y shift
+    float dist = yFlat - NominalYShift + mRadius;
+    xCurved = dist * std::cos((xFlat + WidthH) / mRadius);
+    yCurved = dist * std::sin((xFlat + WidthH) / mRadius);
   }
 
   /// Transformation from Geant detector centered local coordinates (cm) to
@@ -120,7 +140,7 @@ class SegmentationSuperAlpide
   /// the center of the sensitive volume.
   /// \param int iRow Detector x cell coordinate.
   /// \param int iCol Detector z cell coordinate.
-  bool localToDetector(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
+  constexpr bool localToDetector(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
   {
     localToDetectorUnchecked(xRow, zCol, iRow, iCol);
     if (!isValid(iRow, iCol)) {
@@ -131,11 +151,10 @@ class SegmentationSuperAlpide
   }
 
   // Same as localToDetector w.o. checks.
-  void localToDetectorUnchecked(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
+  constexpr void localToDetectorUnchecked(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
   {
-    namespace cp = constants::pixelarray;
-    iRow = std::floor((cp::width / 2. - xRow) / mPitchRow);
-    iCol = std::floor((zCol + cp::length / 2.) / mPitchCol);
+    iRow = static_cast<int>(std::floor((WidthH - xRow) / PitchRow));
+    iCol = static_cast<int>(std::floor((zCol + LengthH) / PitchCol));
   }
 
   /// Transformation from Detector cell coordinates to Geant detector centered
@@ -148,7 +167,7 @@ class SegmentationSuperAlpide
   /// center of the sensitive volume.
   /// If iRow and or iCol is outside of the segmentation range a value of -0.5*Dx()
   /// or -0.5*Dz() is returned.
-  bool detectorToLocal(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
+  constexpr bool detectorToLocal(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
   {
     if (!isValid(iRow, iCol)) {
       return false;
@@ -159,11 +178,10 @@ class SegmentationSuperAlpide
 
   // Same as detectorToLocal w.o. checks.
   // We position ourself in the middle of the pixel.
-  void detectorToLocalUnchecked(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
+  constexpr void detectorToLocalUnchecked(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
   {
-    namespace cp = constants::pixelarray;
-    xRow = -(iRow + 0.5) * mPitchRow + cp::width / 2.;
-    zCol = (iCol + 0.5) * mPitchCol - cp::length / 2.;
+    xRow = -(static_cast<float>(iRow) + 0.5f) * PitchRow + WidthH;
+    zCol = (static_cast<float>(iCol) + 0.5f) * PitchCol - LengthH;
   }
 
   bool detectorToLocal(int const row, int const col, math_utils::Point3D<float>& loc) const noexcept
@@ -172,7 +190,7 @@ class SegmentationSuperAlpide
     if (!detectorToLocal(row, col, xRow, zCol)) {
       return false;
     }
-    loc.SetCoordinates(xRow, 0., zCol);
+    loc.SetCoordinates(xRow, NominalYShift, zCol);
     return true;
   }
 
@@ -180,28 +198,23 @@ class SegmentationSuperAlpide
   {
     float xRow{0.}, zCol{0.};
     detectorToLocalUnchecked(row, col, xRow, zCol);
-    loc.SetCoordinates(xRow, 0., zCol);
+    loc.SetCoordinates(xRow, NominalYShift, zCol);
   }
 
  private:
   template <typename T>
-  [[nodiscard]] bool isValid(T const row, T const col) const noexcept
+  [[nodiscard]] constexpr bool isValid(T const row, T const col) const noexcept
   {
     if constexpr (std::is_floating_point_v<T>) { // compares in local coord.
-      namespace cp = constants::pixelarray;
-      return !static_cast<bool>(row <= -cp::width / 2. || cp::width / 2. <= row || col <= -cp::length / 2. || cp::length / 2. <= col);
+      return (-WidthH < row && row < WidthH && -LengthH < col && col < LengthH);
     } else { // compares in rows/cols
-      return !static_cast<bool>(row < 0 || row >= static_cast<int>(mNRows) || col < 0 || col >= static_cast<int>(mNCols));
+      return !static_cast<bool>(row < 0 || row >= static_cast<int>(NRows) || col < 0 || col >= static_cast<int>(NCols));
     }
   }
 
-  const int mLayer{0}; ///< chip layer
-
-  ClassDef(SegmentationSuperAlpide, 1);
+  float mRadius;
 };
 
-/// Segmentation array
-extern const std::array<SegmentationSuperAlpide, constants::nLayers> SuperSegmentations;
 } // namespace o2::its3
 
 #endif
diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
index d3efde58d0e0d..fedaad9182cce 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
@@ -21,114 +21,164 @@
 
 #include <array>
 
+// This files defines the design specifications of the chip.
+// Each TGeoShape has the following properties
+// length: dimension in z-axis
+// width: dimension in xy-axes
+// color: for visulisation
 namespace o2::its3::constants
 {
-constexpr float cm{1e+2}; // This is the default unit of TGeo so we use this as scale
-constexpr float mu{1e-6 * cm};
-constexpr float mm{1e-3 * cm};
+constexpr double cm{1e+2}; // This is the default unit of TGeo so we use this as scale
+constexpr double mu{1e-6 * cm};
+constexpr double mm{1e-3 * cm};
 namespace pixelarray
 {
-constexpr float width{9.197 * mm};
-constexpr float length{3.571 * mm};
+constexpr double width{9.197 * mm};
+constexpr double length{3.571 * mm};
 constexpr int nCols{156};
 constexpr int nRows{442};
 constexpr int nPixels{nRows * nCols};
 constexpr EColor color{kGreen};
-constexpr float area{width * length};
+constexpr double area{width * length};
 } // namespace pixelarray
 namespace tile
 {
 namespace biasing
 {
-constexpr float width{0.06 * mm};
-constexpr float length{3.571 * mm};
+constexpr double width{0.06 * mm};
+constexpr double length{3.571 * mm};
 constexpr EColor color{kYellow};
 static_assert(length == pixelarray::length);
 } // namespace biasing
 namespace powerswitches
 {
-constexpr float width{9.257 * mm};
-constexpr float length{0.02 * mm};
-constexpr float z{pixelarray::width};
+constexpr double width{9.257 * mm};
+constexpr double length{0.02 * mm};
+constexpr double z{pixelarray::width};
 constexpr EColor color{kBlue};
 } // namespace powerswitches
 namespace readout
 {
-constexpr float width{0.525 * mm};
-constexpr float length{3.591 * mm};
+constexpr double width{0.525 * mm};
+constexpr double length{3.591 * mm};
 constexpr EColor color{kMagenta};
 static_assert(length == (biasing::length + powerswitches::length));
 } // namespace readout
-constexpr float length{readout::length};
-constexpr float width{powerswitches::width + readout::width};
+constexpr double length{readout::length};
+constexpr double width{powerswitches::width + readout::width};
 } // namespace tile
 namespace rsu
 {
 namespace databackbone
 {
-constexpr float width{9.782 * mm};
-constexpr float length{0.06 * mm};
+constexpr double width{9.782 * mm};
+constexpr double length{0.06 * mm};
 constexpr EColor color{kRed};
 } // namespace databackbone
-constexpr float width{19.564 * mm};
-constexpr float length{21.666 * mm};
+constexpr double width{19.564 * mm};
+constexpr double length{21.666 * mm};
 constexpr unsigned int nTiles{12};
 } // namespace rsu
 namespace segment
 {
-constexpr float width{rsu::width};
+constexpr double width{rsu::width};
 namespace lec
 {
-constexpr float width{segment::width};
-constexpr float length{4.5 * mm};
+constexpr double width{segment::width};
+constexpr double length{4.5 * mm};
 constexpr EColor color{kCyan};
 } // namespace lec
 namespace rec
 {
-constexpr float width{segment::width};
-constexpr float length{1.5 * mm};
+constexpr double width{segment::width};
+constexpr double length{1.5 * mm};
 constexpr EColor color{kCyan};
 } // namespace rec
 constexpr unsigned int nRSUs{12};
 constexpr unsigned int nTilesPerSegment{nRSUs * rsu::nTiles};
-constexpr float length{nRSUs * rsu::length + lec::length + rec::length};
-constexpr float lengthSensitive{nRSUs * rsu::length};
+constexpr double length{(nRSUs * rsu::length) + lec::length + rec::length};
+constexpr double lengthSensitive{nRSUs * rsu::length};
 } // namespace segment
 namespace carbonfoam
 {
 // TODO: Waiting for the further information from WP5(Corrado)
-constexpr float longeronsWidth{2.0 * mm};                                 // what is the height of the longerons?
-constexpr float longeronsLength{263 * mm};                                // from blueprint
-constexpr float HringLength{6.0 * mm};                                    // from blueprint
-constexpr float edgeBetwChipAndFoam{1.0 * mm};                            // from blueprint but not used cause forms are already overlapping
-constexpr float gapBetwHringsLongerons{0.05 * mm};                        // from blueprint
-constexpr std::array<int, 3> nHoles{11, 11, 11};                          // how many holes for each layer?
-constexpr std::array<float, 3> radiusHoles{1.0 * mm, 1.0 * mm, 2.0 * mm}; // what is the radius of the holes for each layer?
+constexpr double longeronsWidth{2.0 * mm};                                 // what is the height of the longerons?
+constexpr double longeronsLength{263 * mm};                                // from blueprint
+constexpr double HringLength{6.0 * mm};                                    // from blueprint
+constexpr double edgeBetwChipAndFoam{1.0 * mm};                            // from blueprint but not used cause forms are already overlapping
+constexpr double gapBetwHringsLongerons{0.05 * mm};                        // from blueprint
+constexpr std::array<int, 3> nHoles{11, 11, 11};                           // how many holes for each layer?
+constexpr std::array<double, 3> radiusHoles{1.0 * mm, 1.0 * mm, 2.0 * mm}; // what is the radius of the holes for each layer?
 constexpr EColor color{kGray};
 } // namespace carbonfoam
+namespace metalstack
+{
+constexpr double thickness{5 * mu}; // physical thickness of the copper metal stack
+constexpr double length{segment::length};
+constexpr double width{segment::width};
+constexpr EColor color{kBlack};
+} // namespace metalstack
+namespace silicon
+{
+constexpr double thickness{45 * mu};                                     // thickness of silicon
+constexpr double thicknessIn{(thickness + metalstack::thickness) / 2.};  // inner silicon thickness
+constexpr double thicknessOut{(thickness - metalstack::thickness) / 2.}; // outer silicon thickness
+} // namespace silicon
 constexpr unsigned int nLayers{3};
 constexpr unsigned int nTotLayers{7};
 constexpr unsigned int nSensorsIB{2 * nLayers};
-constexpr float equatorialGap{1 * mm};
+constexpr double equatorialGap{1 * mm};
 constexpr std::array<unsigned int, nLayers> nSegments{3, 4, 5};
-constexpr float thickness{50 * mu};                                                                                                  //< Physical Thickness of chip
-constexpr float effThickness{66 * mu};                                                                                               //< Physical thickness + metal substrate
-constexpr std::array<float, nLayers> radii{19.0006 * mm, 25.228 * mm, 31.4554 * mm};                                                 // middle radius e.g. inner radius+thickness/2.
-constexpr std::array<float, nLayers> radiiInner{radii[0] - thickness / 2.f, radii[1] - thickness / 2.f, radii[2] - thickness / 2.f}; // inner radius
-constexpr std::array<float, nLayers> radiiOuter{radii[0] + thickness / 2.f, radii[1] + thickness / 2.f, radii[2] + thickness / 2.f}; // inner radius
+constexpr double totalThickness{silicon::thickness + metalstack::thickness};                                                                                         // total chip thickness
+constexpr std::array<double, nLayers> radii{19.0006 * mm, 25.228 * mm, 31.4554 * mm};                                                                                // nominal radius
+constexpr std::array<double, nLayers> radiiInner{radii[0] - silicon::thicknessIn, radii[1] - silicon::thicknessIn, radii[2] - silicon::thicknessIn};                 // inner silicon radius
+constexpr std::array<double, nLayers> radiiOuter{radii[0] + silicon::thicknessOut, radii[1] + silicon::thicknessOut, radii[2] + silicon::thicknessOut};              // outer silicon radius
+constexpr std::array<double, nLayers> radiiMiddle{(radiiInner[0] + radiiOuter[0]) / 2., (radiiInner[1] + radiiOuter[1]) / 2., (radiiInner[2] + radiiOuter[2]) / 2.}; // middle silicon radius
+constexpr double nominalYShift{-metalstack::thickness / 2.};                                                                                                         // shift to position in silicion volume to the chip volume (silicon+metalstack)
+
+// extra information of pixels and their response functions
+namespace pixelarray::pixels
+{
+namespace mosaix
+{
+constexpr double pitchX{width / static_cast<double>(nRows)};
+constexpr double pitchZ{length / static_cast<double>(nCols)};
+} // namespace mosaix
+namespace apts
+{
+constexpr double pitchX{15.0 * mu};
+constexpr double pitchZ{15.0 * mu};
+constexpr double responseUpperLimit{10 * mu};
+constexpr double responseYShift{responseUpperLimit - silicon::thicknessOut};
+} // namespace apts
+namespace moss
+{
+namespace top
+{
+constexpr double pitchX{22.5 * mu};
+constexpr double pitchZ{22.5 * mu};
+} // namespace top
+namespace bot
+{
+constexpr double pitchX{18.0 * mu};
+constexpr double pitchZ{18.0 * mu};
+} // namespace bot
+} // namespace moss
+} // namespace pixelarray::pixels
+
 namespace detID
 {
-constexpr unsigned int mDetIDs{2 * 12 * 12 * 12};                //< 2 Hemispheres * (3,4,5=12 segments in a layer) * 12 RSUs in a segment * 12 Tiles in a RSU
-constexpr unsigned int l0IDStart{0};                             //< Start DetID layer 0
-constexpr unsigned int l0IDEnd{2 * 3 * 12 * 12 - 1};             //< End First DetID layer 0; inclusive range
-constexpr unsigned int l0IDTot{2 * 3 * 12 * 12};                 //< Total DetID in Layer 0
-constexpr unsigned int l1IDStart{l0IDEnd + 1};                   //< Start DetID layer 1
-constexpr unsigned int l1IDEnd{l1IDStart + 2 * 4 * 12 * 12 - 1}; //< End First DetID layer 1; inclusive range
-constexpr unsigned int l1IDTot{2 * 4 * 12 * 12};                 //< Total DetID in Layer 1
-constexpr unsigned int l2IDStart{l1IDEnd + 1};                   //< Start DetID layer 2
-constexpr unsigned int l2IDEnd{l2IDStart + 2 * 5 * 12 * 12 - 1}; //< End First DetID layer 2; inclusive range
-constexpr unsigned int l2IDTot{2 * 5 * 12 * 12};                 //< Total DetID in Layer 2
-constexpr unsigned int nChips{l2IDEnd + 1};                      //< number of Chips (PixelArrays) in IB
+constexpr unsigned int mDetIDs{2 * 12 * 12 * 12};                  //< 2 Hemispheres * (3,4,5=12 segments in a layer) * 12 RSUs in a segment * 12 Tiles in a RSU
+constexpr unsigned int l0IDStart{0};                               //< Start DetID layer 0
+constexpr unsigned int l0IDEnd{(2 * 3 * 12 * 12) - 1};             //< End First DetID layer 0; inclusive range
+constexpr unsigned int l0IDTot{2 * 3 * 12 * 12};                   //< Total DetID in Layer 0
+constexpr unsigned int l1IDStart{l0IDEnd + 1};                     //< Start DetID layer 1
+constexpr unsigned int l1IDEnd{l1IDStart + (2 * 4 * 12 * 12) - 1}; //< End First DetID layer 1; inclusive range
+constexpr unsigned int l1IDTot{2 * 4 * 12 * 12};                   //< Total DetID in Layer 1
+constexpr unsigned int l2IDStart{l1IDEnd + 1};                     //< Start DetID layer 2
+constexpr unsigned int l2IDEnd{l2IDStart + (2 * 5 * 12 * 12) - 1}; //< End First DetID layer 2; inclusive range
+constexpr unsigned int l2IDTot{2 * 5 * 12 * 12};                   //< Total DetID in Layer 2
+constexpr unsigned int nChips{l2IDEnd + 1};                        //< number of Chips (PixelArrays) in IB
 
 template <typename T = int>
 inline T getDetID2Layer(T detID)
diff --git a/Detectors/Upgrades/ITS3/base/src/ITS3BaseLinkDef.h b/Detectors/Upgrades/ITS3/base/src/ITS3BaseLinkDef.h
index dc0557824e0f8..144711b052a1b 100644
--- a/Detectors/Upgrades/ITS3/base/src/ITS3BaseLinkDef.h
+++ b/Detectors/Upgrades/ITS3/base/src/ITS3BaseLinkDef.h
@@ -15,7 +15,6 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class o2::its3::SegmentationSuperAlpide + ;
 #pragma link C++ class o2::its3::ITS3Params + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its3::ITS3Params> + ;
 
diff --git a/Detectors/Upgrades/ITS3/base/src/SegmentationSuperAlpide.cxx b/Detectors/Upgrades/ITS3/base/src/SegmentationSuperAlpide.cxx
deleted file mode 100644
index 26ca09f351bec..0000000000000
--- a/Detectors/Upgrades/ITS3/base/src/SegmentationSuperAlpide.cxx
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "ITS3Base/SegmentationSuperAlpide.h"
-
-ClassImp(o2::its3::SegmentationSuperAlpide);
-
-namespace o2::its3
-{
-
-const std::array<SegmentationSuperAlpide, constants::nLayers> SuperSegmentations{0, 1, 2};
-}
diff --git a/Detectors/Upgrades/ITS3/data/CMakeLists.txt b/Detectors/Upgrades/ITS3/data/CMakeLists.txt
new file mode 100644
index 0000000000000..ba8b60c8aa7eb
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/data/CMakeLists.txt
@@ -0,0 +1,25 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+add_custom_target(
+  GenerateAPTSResponse ALL
+  COMMAND
+    ${CMAKE_BINARY_DIR}/stage/bin/o2-alpide-response-generator -c APTS -i
+    ${ITSRESPONSE_DIR}/response/ITS3ChipResponseData/AptsResponseData/ -o
+    ${CMAKE_CURRENT_BINARY_DIR}/
+  BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/APTSResponseData.root
+  DEPENDS GenerateAlpideResponse
+  COMMENT "Generating APTSResponseData.root")
+install(
+  FILES "${CMAKE_CURRENT_BINARY_DIR}/APTSResponseData.root"
+  DESTINATION
+    "${CMAKE_INSTALL_PREFIX}/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/"
+)
diff --git a/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt b/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
index bdd0329c55ecd..39e435f0ba2e6 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
@@ -19,8 +19,8 @@ its3_add_macro(CheckHits.C)
 its3_add_macro(CheckDigitsDensity.C)
 its3_add_macro(CheckClusterSize.C)
 its3_add_macro(CompareClusterSize.C)
-its3_add_macro(CheckSuperAlpideSegment.C)
-its3_add_macro(CheckSuperAlpideSegmentTrans.C)
+its3_add_macro(CheckMosaixSegment.C)
+its3_add_macro(CheckMosaixSegmentTrans.C)
 its3_add_macro(CompareClustersAndDigits.C)
 its3_add_macro(CheckROFs.C)
 its3_add_macro(CheckTileNumbering.C)
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckClusterSize.C b/Detectors/Upgrades/ITS3/macros/test/CheckClusterSize.C
index addaaf47269d2..564b20350b883 100755
--- a/Detectors/Upgrades/ITS3/macros/test/CheckClusterSize.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckClusterSize.C
@@ -43,6 +43,7 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCEventHeader.h"
 #include "SimulationDataFormat/MCTrack.h"
+#include "ITS3Base/SpecsV2.h"
 #endif
 #define ENABLE_UPGRADES
 #include "SimulationDataFormat/MCTruthContainer.h"
@@ -65,7 +66,11 @@ void checkFile(const std::unique_ptr<TFile>& file);
 
 inline auto hist_map(unsigned short id)
 {
-  return std::clamp(id, static_cast<unsigned short>(0), static_cast<unsigned short>(6)) / 2;
+  int lay = o2::its3::constants::detID::getDetID2Layer<int>(id);
+  if (lay == -1) {
+    return nLayers - 1;
+  }
+  return lay;
 }
 
 void CheckClusterSize(std::string clusFileName = "o2clus_its.root",
@@ -133,7 +138,7 @@ void CheckClusterSize(std::string clusFileName = "o2clus_its.root",
   std::vector<TH2D> hOtherSecondaryEta;
   std::vector<TH2D> hOtherSecondaryPt;
   std::vector<TH2D> hOtherSecondaryPhi;
-  for (int i = 0; i < 4; ++i) {
+  for (int i = 0; i < nLayers; ++i) {
     hPrimary.emplace_back(Form("primary/L%d", i), Form("L%d Primary Cluster Size", i), maxClusterSize, 0, maxClusterSize);
     hPrimaryEta.emplace_back(Form("primary/EtaL%d", i), Form("L%d Primary Cluster Size vs Eta", i), maxClusterSize, 0, maxClusterSize, 100, -3.0, 3.0);
     hPrimaryPt.emplace_back(Form("primary/Pt%d", i), Form("L%d Primary Cluster Size vs Pt", i), maxClusterSize, 0, maxClusterSize, 100, 0.0, 10.0);
@@ -238,35 +243,39 @@ void CheckClusterSize(std::string clusFileName = "o2clus_its.root",
   int nROFRec = (int)rofRecVec.size();
   auto pattIt = patternsPtr->cbegin();
 
+  int cInvalid{0}, cGood{0};
   for (int irof = 0; irof < nROFRec; irof++) {
     const auto& rofRec = rofRecVec[irof];
-    // rofRec.print();
+    /*rofRec.print();*/
 
     for (int icl = 0; icl < rofRec.getNEntries(); icl++) {
       int clEntry = rofRec.getFirstEntry() + icl;
       const auto& cluster = clusArr[clEntry];
-      // cluster.print();
+      /*cluster.print();*/
 
       auto pattId = cluster.getPatternID();
       auto id = cluster.getSensorID();
+      auto ib = o2::its3::constants::detID::isDetITS3(id);
       int clusterSize{-1};
-      if (pattId == o2::itsmft::CompCluster::InvalidPatternID || dict.isGroup(pattId)) {
+      if (pattId == o2::itsmft::CompCluster::InvalidPatternID || dict.isGroup(pattId, ib)) {
         o2::itsmft::ClusterPattern patt(pattIt);
         clusterSize = patt.getNPixels();
         continue;
       } else {
-        clusterSize = dict.getNpixels(pattId);
+        clusterSize = dict.getNpixels(pattId, ib);
       }
 
       const auto& label = (clusLabArr->getLabels(clEntry))[0];
       if (!label.isValid() || label.getSourceID() != 0 || !label.isCorrect()) {
+        ++cInvalid;
         continue;
       }
+      ++cGood;
 
       const int trackID = label.getTrackID();
       int evID = label.getEventID();
       const auto& pInfo = info[evID][trackID];
-      if (id > 6) {
+      if (!o2::its3::constants::detID::isDetITS3(id)) {
         hOuterBarrel.Fill(clusterSize);
       }
 
@@ -332,6 +341,7 @@ void CheckClusterSize(std::string clusFileName = "o2clus_its.root",
       }
     }
   }
+  std::cout << "Good labels: " << cGood << "; invalid: " << cInvalid << '\n';
   std::cout << "Done measuring cluster sizes:" << std::endl;
   for (int i = 0; i < nLayers; ++i) {
     std::cout << "* Layer " << i << ":\n";
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C b/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
index af03ed7a9877b..006271a1ea7bd 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
@@ -25,7 +25,7 @@
 #define ENABLE_UPGRADES
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "ITS3Base/SpecsV2.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "DataFormatsITSMFT/CompCluster.h"
@@ -50,22 +50,24 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
   using namespace o2::base;
   using namespace o2::its;
 
-  using SuperSegmentation = o2::its3::SegmentationSuperAlpide;
+  using MosaixSegmentation = o2::its3::SegmentationMosaix;
   using Segmentation = o2::itsmft::SegmentationAlpide;
   using o2::itsmft::CompClusterExt;
   using o2::itsmft::Hit;
   using ROFRec = o2::itsmft::ROFRecord;
   using MC2ROF = o2::itsmft::MC2ROFRecord;
   using HitVec = std::vector<Hit>;
-  using MC2HITS_map = std::unordered_map<uint64_t, int>; // maps (track_ID<<16 + chip_ID) to entry in the hit vector
+  using MC2HITS_map = std::unordered_map<uint64_t, int>; // maps (track_ID<<32 + chip_ID) to entry in the hit vector
+  std::array<MosaixSegmentation, 3> mMosaixSegmentations{0, 1, 2};
 
   std::vector<HitVec*> hitVecPool;
   std::vector<MC2HITS_map> mc2hitVec;
 
-  ULong_t cPattValid{0}, cPattInvalid{0}, cLabelInvalid{0}, cNoMC{0};
+  ULong_t cPattValidIB{0}, cPattInvalidIB{0}, cLabelInvalidIB{0}, cNoMCIB{0};
+  ULong_t cPattValidOB{0}, cPattInvalidOB{0}, cLabelInvalidOB{0}, cNoMCOB{0};
 
   TFile fout("CheckClusters.root", "recreate");
-  TNtuple nt("ntc", "cluster ntuple", "ev:lab:hlx:hlz:hgx:hgz:tx:tz:cgx:cgy:cgz:clx:cly:clz:dx:dy:dz:ex:ez:patid:rof:npx:id");
+  TNtuple nt("ntc", "cluster ntuple", "ev:lab:hlx:hlz:hgx:hgz:tx:tz:cgx:cgy:cgz:clx:cly:clz:dx:dy:dz:ex:ez:patid:rof:npx:id:eta:row:col:lay");
 
   // Geometry
   o2::base::GeometryManager::loadGeometry(inputGeom);
@@ -102,6 +104,7 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
   } else {
     LOG(info) << "Running without dictionary !";
   }
+  dict.print();
 
   // ROFrecords
   std::vector<ROFRec> rofRecVec, *rofRecVecP = &rofRecVec;
@@ -174,20 +177,18 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
       auto isIB = o2::its3::constants::detID::isDetITS3(chipID);
       auto layer = o2::its3::constants::detID::getDetID2Layer(chipID);
       auto clusterSize{-1};
-      if (pattID == o2::itsmft::CompCluster::InvalidPatternID || dict.isGroup(pattID)) {
+      if (pattID == o2::itsmft::CompCluster::InvalidPatternID || dict.isGroup(pattID, isIB)) {
         o2::itsmft::ClusterPattern patt(pattIt);
         locC = dict.getClusterCoordinates(cluster, patt, false);
         LOGP(debug, "I am invalid and I am on chip {}", chipID);
-        ++cPattInvalid;
+        (isIB) ? ++cPattInvalidIB : ++cPattInvalidOB;
         continue;
       } else {
         locC = dict.getClusterCoordinates(cluster);
-        errX = dict.getErrX(pattID);
-        errZ = dict.getErrZ(pattID);
-        errX *= (isIB) ? SuperSegmentation::mPitchRow : Segmentation::PitchRow;
-        errZ *= (isIB) ? SuperSegmentation::mPitchCol : Segmentation::PitchCol;
-        npix = dict.getNpixels(pattID);
-        ++cPattValid;
+        errX = dict.getErrX(pattID, isIB);
+        errZ = dict.getErrZ(pattID, isIB);
+        npix = dict.getNpixels(pattID, isIB);
+        (isIB) ? ++cPattValidIB : ++cPattValidOB;
       }
 
       // Transformation to the local --> global
@@ -195,7 +196,7 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
       const auto& lab = (clusLabArr->getLabels(clEntry))[0];
 
       if (!lab.isValid()) {
-        ++cLabelInvalid;
+        (isIB) ? ++cLabelInvalidIB : ++cLabelInvalidOB;
         continue;
       }
 
@@ -207,7 +208,7 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
       auto hitEntry = mc2hit.find(key);
       if (hitEntry == mc2hit.end()) {
         LOG(debug) << "Failed to find MC hit entry for Tr" << trID << " chipID" << chipID;
-        ++cNoMC;
+        (isIB) ? ++cNoMCIB : ++cNoMCOB;
         continue;
       }
       const auto& hit = (*hitArray)[hitEntry->second];
@@ -234,25 +235,22 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
       } else {
         // compare in local flat coordinates
         float xFlatEnd{0.}, yFlatEnd{0.};
-        o2::its3::SuperSegmentations[layer].curvedToFlat(locH.X(), locH.Y(), xFlatEnd, yFlatEnd);
+        mMosaixSegmentations[layer].curvedToFlat(locH.X(), locH.Y(), xFlatEnd, yFlatEnd);
         locH.SetXYZ(xFlatEnd, yFlatEnd, locH.Z());
         float xFlatSta{0.}, yFlatSta{0.};
-        o2::its3::SuperSegmentations[layer].curvedToFlat(locHsta.X(), locHsta.Y(), xFlatSta, yFlatSta);
+        mMosaixSegmentations[layer].curvedToFlat(locHsta.X(), locHsta.Y(), xFlatSta, yFlatSta);
         locHsta.SetXYZ(xFlatSta, yFlatSta, locHsta.Z());
-        // recalculate x/y in flat
-        // x0 = xFlatSta, dltx = xFlatEnd - x0;
-        // y0 = yFlatSta, dlty = yFlatEnd - y0;
-        // r = (0.5 * (SuperSegmentation::mSensorLayerThickness - SuperSegmentation::mSensorLayerThicknessEff) - y0) / dlty;
-        // locH.SetXYZ(x0 + r * dltx, y0 + r * dlty, z0 + r * dltz);
 
         // not really precise, but okish
         locH.SetXYZ(0.5f * (locH.X() + locHsta.X()), 0.5f * (locH.Y() + locHsta.Y()), 0.5f * (locH.Z() + locHsta.Z()));
 
-        o2::its3::SuperSegmentations[layer].curvedToFlat(locC.X(), locC.Y(), xFlatSta, yFlatSta);
+        mMosaixSegmentations[layer].curvedToFlat(locC.X(), locC.Y(), xFlatSta, yFlatSta);
         locC.SetXYZ(xFlatSta, yFlatSta, locC.Z());
       }
+      float theta = std::acos(gloC.Z() / gloC.Rho());
+      float eta = -std::log(std::tan(theta / 2));
 
-      std::array<float, 23> data = {(float)lab.getEventID(), (float)trID,
+      std::array<float, 27> data = {(float)lab.getEventID(), (float)trID,
                                     locH.X(), locH.Z(),
                                     gloH.X(), gloH.Z(),
                                     dltx / dlty, dltz / dlty,
@@ -260,13 +258,15 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
                                     locC.X(), locC.Y(), locC.Z(),
                                     locC.X() - locH.X(), locC.Y() - locH.Y(), locC.Z() - locH.Z(),
                                     errX, errZ, (float)pattID,
-                                    (float)rofRec.getROFrame(), (float)npix, (float)chipID};
+                                    (float)rofRec.getROFrame(), (float)npix, (float)chipID, eta, (float)cluster.getRow(), (float)cluster.getCol(), (float)layer};
       nt.Fill(data.data());
     }
   }
 
-  LOGP(info, "There were {} valid PatternIDs and {} ({:.1f}%) invalid ones", cPattValid, cPattInvalid, ((float)cPattInvalid / (float)(cPattInvalid + cPattValid)) * 100);
-  LOGP(info, "There were {} invalid Labels and {} with No MC Hit information ", cLabelInvalid, cNoMC);
+  LOGP(info, "IB {} valid PatternIDs and {} ({:.1f}%) invalid ones", cPattValidIB, cPattInvalidIB, ((float)cPattInvalidIB / (float)(cPattInvalidIB + cPattValidIB)) * 100);
+  LOGP(info, "IB {} invalid Labels and {} with No MC Hit information ", cLabelInvalidIB, cNoMCIB);
+  LOGP(info, "OB {} valid PatternIDs and {} ({:.1f}%) invalid ones", cPattValidOB, cPattInvalidOB, ((float)cPattInvalidOB / (float)(cPattInvalidOB + cPattValidOB)) * 100);
+  LOGP(info, "OB {} invalid Labels and {} with No MC Hit information ", cLabelInvalidOB, cNoMCOB);
 
   auto canvCgXCgY = new TCanvas("canvCgXCgY", "", 1600, 1600);
   canvCgXCgY->Divide(2, 2);
@@ -292,6 +292,18 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
   nt.Draw("dx:dz>>h_dx_vs_dz_OB_z(1000, -0.01, 0.01, 1000, -0.01, 0.01)", "id >= 3456 && abs(cgz) < 2", "colz");
   canvdXdZ->SaveAs("it3clusters_dx_vs_dz.pdf");
 
+  auto canvCHXZ = new TCanvas("canvCHXZ", "", 1600, 1600);
+  canvCHXZ->Divide(2, 2);
+  canvCHXZ->cd(1);
+  nt.Draw("(cgx-hgx)*10000:eta>>h_chx_IB(101,-1.4,1.4,101,-50,50)", "id<3456", "prof");
+  canvCHXZ->cd(2);
+  nt.Draw("(cgx-hgx)*10000:eta>>h_chx_OB(101,-1.4,1.4,101,-50,50)", "id>=3456", "prof");
+  canvCHXZ->cd(3);
+  nt.Draw("(cgz-hgz)*10000:eta>>h_chz_IB(101,-1.4,1.4,101,-50,50)", "id<3456", "prof");
+  canvCHXZ->cd(4);
+  nt.Draw("(cgz-hgz)*10000:eta>>h_chz_OB(101,-1.4,1.4,101,-50,50)", "id>=3456", "prof");
+  canvCgXCgY->SaveAs("it3clusters_xz_eta.pdf");
+
   auto c1 = new TCanvas("p1", "pullX");
   c1->cd();
   c1->SetLogy();
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckDigitsDensity.C b/Detectors/Upgrades/ITS3/macros/test/CheckDigitsDensity.C
index 0c8d9c3bdfbec..67b75e33bc430 100755
--- a/Detectors/Upgrades/ITS3/macros/test/CheckDigitsDensity.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckDigitsDensity.C
@@ -37,7 +37,7 @@
 #include "ITS3Base/SpecsV2.h"
 #include "CommonConstants/MathConstants.h"
 #include "DataFormatsITSMFT/Digit.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "DetectorsBase/GeometryManager.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "fairlogger/Logger.h"
@@ -56,7 +56,7 @@ constexpr double qedRate = qedXSection / hadXSection * interaction_rate; // Hz
 constexpr double qedFactor = qedRate * integration_time;                 // a.u.
 using o2::itsmft::Digit;
 namespace its3 = o2::its3;
-using SSAlpide = its3::SegmentationSuperAlpide;
+using Mosaix = its3::SegmentationMosaix;
 
 void checkFile(const std::unique_ptr<TFile>& file);
 
@@ -64,7 +64,7 @@ void CheckDigitsDensity(int nEvents = 10000, std::string digitFileName = "it3dig
 {
   gROOT->SetBatch(batch);
   LOGP(debug, "Checking Digit ITS3 Density");
-  // Vars
+  std::array<Mosaix, 3> mMosaixSegmentations{0, 1, 2};
 
   // Geometry
   o2::base::GeometryManager::loadGeometry(geomFileName);
@@ -80,8 +80,8 @@ void CheckDigitsDensity(int nEvents = 10000, std::string digitFileName = "it3dig
   digitTree->SetBranchAddress("IT3Digit", &digitArrayPtr);
   std::array<TH2F*, 3> hists;
   for (int i{3}; i--;) {
-    double rmin = its3::constants::radii[i] - its3::constants::thickness;
-    double rmax = its3::constants::radii[i] + its3::constants::thickness;
+    double rmin = its3::constants::radiiInner[i];
+    double rmax = its3::constants::radiiOuter[i];
     hists[i] = new TH2F(Form("h_digits_dens_L%d", i), Form("Digit Density L%d in %d Events; Z_{Glo} [cm]; R_{Glo} [cm]", i, nEvents), 100, -15, 15, 100, rmin, rmax);
   }
 
@@ -103,8 +103,8 @@ void CheckDigitsDensity(int nEvents = 10000, std::string digitFileName = "it3dig
       // goto curved coordinates
       float x{0.f}, y{0.f}, z{0.f};
       float xFlat{0.f}, yFlat{0.f};
-      its3::SuperSegmentations[layer].detectorToLocal(row, col, xFlat, z);
-      its3::SuperSegmentations[layer].flatToCurved(xFlat, 0., x, y);
+      mMosaixSegmentations[layer].detectorToLocal(row, col, xFlat, z);
+      mMosaixSegmentations[layer].flatToCurved(xFlat, 0., x, y);
       const o2::math_utils::Point3D<double> locD(x, y, z);
       const auto gloD = gman->getMatrixL2G(id)(locD); // convert to global
       const auto R = std::hypot(gloD.X(), gloD.Y());
@@ -115,7 +115,7 @@ void CheckDigitsDensity(int nEvents = 10000, std::string digitFileName = "it3dig
   std::unique_ptr<TFile> oFile(TFile::Open("checkDigitsDensity.root", "RECREATE"));
   checkFile(oFile);
   for (const auto& h : hists) {
-    h->Scale(1. / (SSAlpide::mPitchCol * SSAlpide::mPitchRow * nEvents));
+    h->Scale(1. / (Mosaix::PitchCol * Mosaix::PitchRow * nEvents));
     h->ProjectionX()->Write();
     h->Write();
   }
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C b/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
index 16aa3adc8101c..1dc4a4e2d6b47 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
@@ -27,7 +27,7 @@
 #define ENABLE_UPGRADES
 #include "ITSBase/GeometryTGeo.h"
 #include "DataFormatsITSMFT/Digit.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "ITSMFTSimulation/Hit.h"
 #include "MathUtils/Utils.h"
@@ -51,6 +51,7 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
   using o2::itsmft::Hit;
 
   using o2::itsmft::SegmentationAlpide;
+  std::array<its3::SegmentationMosaix, 3> mMosaixSegmentations{0, 1, 2};
 
   TFile* f = TFile::Open("CheckDigits.root", "recreate");
   TNtuple* nt = new TNtuple("ntd", "digit ntuple", "id:x:y:z:rowD:colD:rowH:colH:xlH:zlH:xlcH:zlcH:dx:dz");
@@ -165,8 +166,8 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
       if (isIB) {
         // ITS3 IB
         float xFlat{0.f}, yFlat{0.f};
-        its3::SuperSegmentations[layer].detectorToLocal(ix, iz, xFlat, z);
-        its3::SuperSegmentations[layer].flatToCurved(xFlat, 0., x, y);
+        mMosaixSegmentations[layer].detectorToLocal(ix, iz, xFlat, z);
+        mMosaixSegmentations[layer].flatToCurved(xFlat, 0., x, y);
       } else {
         // ITS2 OB
         SegmentationAlpide::detectorToLocal(ix, iz, x, z);
@@ -184,7 +185,7 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
       const auto* mc2hit = &mc2hitVec[lab.getEventID()];
       const auto& hitEntry = mc2hit->find(key);
       if (hitEntry == mc2hit->end()) {
-        LOGP(error, "Failed to find MC hit entry for Tr {} chipID {}", trID, chipID);
+        LOGP(debug, "Failed to find MC hit entry for Tr {} chipID {}", trID, chipID);
         continue;
       }
 
@@ -196,18 +197,18 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
       auto xyzLocE = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
       auto xyzLocS = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
       o2::math_utils::Vector3D<float> xyzLocM;
-      xyzLocM.SetCoordinates(0.5 * (xyzLocE.X() + xyzLocS.X()), 0.5 * (xyzLocE.Y() + xyzLocS.Y()), 0.5 * (xyzLocE.Z() + xyzLocS.Z()));
+      xyzLocM.SetCoordinates(0.5f * (xyzLocE.X() + xyzLocS.X()), 0.5f * (xyzLocE.Y() + xyzLocS.Y()), 0.5f * (xyzLocE.Z() + xyzLocS.Z()));
       float xlc = 0., zlc = 0.;
       int row = 0, col = 0;
 
       if (isIB) {
         float xFlat{0.}, yFlat{0.};
-        its3::SuperSegmentations[layer].curvedToFlat(xyzLocM.X(), xyzLocM.Y(), xFlat, yFlat);
+        mMosaixSegmentations[layer].curvedToFlat(xyzLocM.X(), xyzLocM.Y(), xFlat, yFlat);
         xyzLocM.SetCoordinates(xFlat, yFlat, xyzLocM.Z());
-        its3::SuperSegmentations[layer].curvedToFlat(locD.X(), locD.Y(), xFlat, yFlat);
+        mMosaixSegmentations[layer].curvedToFlat(locD.X(), locD.Y(), xFlat, yFlat);
         locD.SetCoordinates(xFlat, yFlat, locD.Z());
-        if (auto v1 = !its3::SuperSegmentations[layer].localToDetector(xyzLocM.X(), xyzLocM.Z(), row, col),
-            v2 = !its3::SuperSegmentations[layer].detectorToLocal(row, col, xlc, zlc);
+        if (auto v1 = !mMosaixSegmentations[layer].localToDetector(xyzLocM.X(), xyzLocM.Z(), row, col),
+            v2 = !mMosaixSegmentations[layer].detectorToLocal(row, col, xlc, zlc);
             v1 || v2) {
           continue;
         }
@@ -223,7 +224,7 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
 
       (isIB) ? ++nDigitFilledIB : ++nDigitFilledOB;
     } // end loop on digits array
-  }   // end loop on ROFRecords array
+  } // end loop on ROFRecords array
 
   auto canvXY = new TCanvas("canvXY", "", 1600, 1600);
   canvXY->Divide(2, 2);
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckHits.C b/Detectors/Upgrades/ITS3/macros/test/CheckHits.C
index 7833b7c205f4a..00ac0a992ba39 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckHits.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckHits.C
@@ -31,7 +31,6 @@
 
 #define ENABLE_UPGRADES
 #include "CommonConstants/MathConstants.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
 #include "ITS3Base/SpecsV2.h"
 #include "ITSMFTSimulation/Hit.h"
 #include "SimulationDataFormat/MCTrack.h"
@@ -39,7 +38,6 @@
 
 namespace it3c = o2::its3::constants;
 namespace it3d = it3c::detID;
-using SSAlpide = o2::its3::SegmentationSuperAlpide;
 using o2::itsmft::Hit;
 
 constexpr double interaction_rate = 50e3;                                // Hz
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckSuperAlpideSegment.C b/Detectors/Upgrades/ITS3/macros/test/CheckMosaixSegment.C
similarity index 78%
rename from Detectors/Upgrades/ITS3/macros/test/CheckSuperAlpideSegment.C
rename to Detectors/Upgrades/ITS3/macros/test/CheckMosaixSegment.C
index 76ac02959415d..12e1ab3a7280d 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckSuperAlpideSegment.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckMosaixSegment.C
@@ -9,9 +9,6 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file CheckTracksITS3.C
-/// \brief Simple macro to check ITS3 tracks
-
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
 #include "Rtypes.h"
@@ -24,14 +21,6 @@
 #include "TGLViewer.h"
 #include "TMath.h"
 
-#include "TEveGeoNode.h"
-#include "TEveManager.h"
-#include "TEveViewer.h"
-#include "TEvePointSet.h"
-#include "TEveTrackPropagator.h"
-#include "TEveTrack.h"
-#include "TEveVSDStructs.h"
-
 #include "TFile.h"
 #include "TGraph.h"
 #include "TH1D.h"
@@ -49,40 +38,41 @@
 #include "MathUtils/Cartesian.h"
 
 #include "ITS3Base/SpecsV2.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "ITSBase/GeometryTGeo.h"
 
 #endif
 
 using gITS = o2::its::GeometryTGeo;
 
-void CheckSuperAlpideSegment(bool isTestDetectorToLocal = false,
-                             bool isTestFlatToCurved = false,
-                             bool isTestLocalToGlobal = false)
+void CheckMosaixSegment(bool isTestDetectorToLocal = false,
+                        bool isTestFlatToCurved = false,
+                        bool isTestLocalToGlobal = false)
 {
   using namespace o2::its3;
-  static constexpr unsigned int mNCols{SegmentationSuperAlpide::mNCols};
-  static constexpr unsigned int mNRows{SegmentationSuperAlpide::mNRows};
+  static constexpr unsigned int mNCols{SegmentationMosaix::NCols};
+  static constexpr unsigned int mNRows{SegmentationMosaix::NRows};
   static constexpr unsigned int nPixels{mNCols * mNRows};
+  std::array<SegmentationMosaix, 3> mMosaixSegmentations{0, 1, 2};
 
   if (isTestDetectorToLocal || isTestFlatToCurved) {
     namespace cp = constants::pixelarray;
-    TH2I* h_raw_col = new TH2I("h_raw_col", "raws and cols sown;raw;col", mNRows, 0, mNRows, mNCols, 0, mNCols);
-    TH2D* h_xLocal_zLocal = new TH2D("h_xLocal_zLocal", "x and z from raws and cols;xLocal;zLocal", mNRows, -cp::length / 2, cp::length / 2, mNCols, -cp::width / 2, cp::width / 2);
-    TH2I* h_raw_col_translate = new TH2I("h_raw_col_translate", "raws and cols from x and z;raw;col", mNRows, 0, mNRows, mNCols, 0, mNCols);
-    TGraph* g_raw_xLocal = new TGraph();
-    g_raw_xLocal->SetMarkerStyle(20);
-    g_raw_xLocal->SetMarkerSize(0.2);
+    TH2I* h_row_col = new TH2I("h_row_col", "rows and cols sown;row;col", mNRows, 0, mNRows, mNCols, 0, mNCols);
+    TH2D* h_xLocal_zLocal = new TH2D("h_xLocal_zLocal", "x and z from rows and cols;xLocal;zLocal", mNRows, -cp::length / 2, cp::length / 2, mNCols, -cp::width / 2, cp::width / 2);
+    TH2I* h_row_col_translate = new TH2I("h_row_col_translate", "rows and cols from x and z;row;col", mNRows, 0, mNRows, mNCols, 0, mNCols);
+    TGraph* g_row_xLocal = new TGraph();
+    g_row_xLocal->SetMarkerStyle(20);
+    g_row_xLocal->SetMarkerSize(0.2);
     TGraph* g_col_zLocal = new TGraph();
     g_col_zLocal->SetMarkerStyle(20);
     g_col_zLocal->SetMarkerSize(0.2);
-    TGraph* g_raw_xLocal_translate = new TGraph();
-    g_raw_xLocal_translate->SetMarkerStyle(20);
-    g_raw_xLocal_translate->SetMarkerSize(0.2);
+    TGraph* g_row_xLocal_translate = new TGraph();
+    g_row_xLocal_translate->SetMarkerStyle(20);
+    g_row_xLocal_translate->SetMarkerSize(0.2);
     TGraph* g_col_zLocal_translate = new TGraph();
     g_col_zLocal_translate->SetMarkerStyle(20);
 
-    SegmentationSuperAlpide seg(0);
+    SegmentationMosaix seg(0);
     int nPoint = 0;
     for (UInt_t i = 0; i < mNRows; ++i) {
       for (UInt_t j = 0; j < mNCols; ++j) {
@@ -92,16 +82,16 @@ void CheckSuperAlpideSegment(bool isTestDetectorToLocal = false,
         int col_trans = -1;
         seg.detectorToLocal(i, j, xLocal, zLocal);
         seg.localToDetector(xLocal, zLocal, row_trans, col_trans);
-        g_raw_xLocal->SetPoint(nPoint, i, xLocal);
+        g_row_xLocal->SetPoint(nPoint, i, xLocal);
         g_col_zLocal->SetPoint(nPoint, j, zLocal);
-        g_raw_xLocal_translate->SetPoint(nPoint, xLocal, row_trans);
+        g_row_xLocal_translate->SetPoint(nPoint, xLocal, row_trans);
         g_col_zLocal_translate->SetPoint(nPoint++, zLocal, col_trans);
 
         bool pattern = ((i >= 50 && i <= 100) || (i >= 250 && i <= 350)) && ((j >= 30 && j <= 70) || (j >= 100 && j <= 120));
         if (pattern) {
-          h_raw_col->Fill(i, j);
+          h_row_col->Fill(i, j);
           h_xLocal_zLocal->Fill(xLocal, zLocal);
-          h_raw_col_translate->Fill(row_trans, col_trans);
+          h_row_col_translate->Fill(row_trans, col_trans);
         }
       }
     }
@@ -110,29 +100,30 @@ void CheckSuperAlpideSegment(bool isTestDetectorToLocal = false,
     // gStyle->SetPalette(kCMYK);
     c1->Divide(3, 1);
     c1->cd(1);
-    h_raw_col->Draw("colz");
+    h_row_col->Draw("colz");
     c1->cd(2);
     h_xLocal_zLocal->Draw("colz");
     c1->cd(3);
-    h_raw_col_translate->Draw("colz");
+    h_row_col_translate->Draw("colz");
 
     TCanvas* c2 = new TCanvas("c2", "c2", 1600, 400);
     c2->Divide(4, 1);
     c2->cd(1);
-    g_raw_xLocal->SetTitle("xLocal vs raw;raw;xLocal");
-    g_raw_xLocal->Draw("same ap");
+    g_row_xLocal->SetTitle("xLocal vs row;row;xLocal");
+    g_row_xLocal->Draw("same ap");
     c2->cd(2);
     g_col_zLocal->SetTitle("zLocal vs col;col;zLocal");
     g_col_zLocal->Draw("same ap");
     c2->cd(3);
-    g_raw_xLocal_translate->SetTitle("raw_translate vs xLocal;xLocal;raw_translate");
-    g_raw_xLocal_translate->Draw("same ap");
+    g_row_xLocal_translate->SetTitle("row_translate vs xLocal;xLocal;row_translate");
+    g_row_xLocal_translate->Draw("same ap");
     c2->cd(4);
     g_col_zLocal_translate->SetTitle("col_translate vs zLocal;zLocal;col_translate");
     g_col_zLocal_translate->Draw("same ap");
   }
 
   if (isTestLocalToGlobal) {
+    o2::base::GeometryManager::loadGeometry();
     namespace cp = constants::pixelarray;
     TH2D* h_xCurved_yCurved = new TH2D("h_xCurved_yCurved", "from flat to curved;x;y", 200, -1, 4, 200, -2, 3);
     TH2D* h_xFlat_yFlat = new TH2D("h_xFlat_yFlat", "from curved to flat ;x;y", 200, -1, 4, 200, -2, 3);
@@ -170,11 +161,11 @@ void CheckSuperAlpideSegment(bool isTestDetectorToLocal = false,
                   float xLocal_translate = 0;
                   float yLocal_translate = 0;
 
-                  SuperSegmentations[iLayer].detectorToLocal(row, col, xLocal, zLocal);
-                  SuperSegmentations[iLayer].flatToCurved(xLocal, 0., xCurved, yCurved);
+                  mMosaixSegmentations[iLayer].detectorToLocal(row, col, xLocal, zLocal);
+                  mMosaixSegmentations[iLayer].flatToCurved(xLocal, 0., xCurved, yCurved);
                   double posLocal[3] = {xCurved, yCurved, zLocal};
                   double posGlobal[3] = {0, 0, 0};
-                  SuperSegmentations[iLayer].curvedToFlat(xCurved, yCurved, xLocal_translate, yLocal_translate);
+                  mMosaixSegmentations[iLayer].curvedToFlat(xCurved, yCurved, xLocal_translate, yLocal_translate);
                   matrix->LocalToMaster(posLocal, posGlobal);
 
                   h_xCurved_yCurved->Fill(xLocal, 0);
@@ -195,8 +186,7 @@ void CheckSuperAlpideSegment(bool isTestDetectorToLocal = false,
     TArc* arc[3];
     h_xCurved_yCurved->Draw("colz");
     for (int i = 0; i < 3; i++) {
-      arc[i] = new TArc(-0, 0, constants::radii[i] + constants::thickness / 2., -5, 40);
-      arc[i]->SetLineColor(kRed);
+      arc[i] = new TArc(-0, 0, constants::radiiOuter[i], -5, 40);
       arc[i]->SetFillStyle(0);
     }
 
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckSuperAlpideSegmentTrans.C b/Detectors/Upgrades/ITS3/macros/test/CheckMosaixSegmentTrans.C
similarity index 85%
rename from Detectors/Upgrades/ITS3/macros/test/CheckSuperAlpideSegmentTrans.C
rename to Detectors/Upgrades/ITS3/macros/test/CheckMosaixSegmentTrans.C
index 64937f2ad2855..1a723bd6017bb 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckSuperAlpideSegmentTrans.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckMosaixSegmentTrans.C
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file CheckSuperAlpideSegmentTrans.C
+/// \file CheckMosaixSegmentTrans.C
 /// \brief Simple macro to check ITS3 Alpide Trans
 
 #if !defined(__CLING__) || defined(__ROOTCLING__)
@@ -26,7 +26,7 @@
 #include "TStyle.h"
 #include "TTree.h"
 
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "ITS3Base/SpecsV2.h"
 
 #endif
@@ -37,10 +37,11 @@ constexpr float PI = 3.14159274101257324e+00f;
 constexpr float Rad2Deg = 180.f / PI;
 constexpr float Deg2Rad = 1. / Rad2Deg;
 
-constexpr auto nRows{SegmentationSuperAlpide::mNRows};
-constexpr auto nCols{SegmentationSuperAlpide::mNCols};
-constexpr auto fLength{SegmentationSuperAlpide::mLength};
-constexpr auto fWidth{SegmentationSuperAlpide::mWidth};
+constexpr auto nRows{SegmentationMosaix::NRows};
+constexpr auto nCols{SegmentationMosaix::NCols};
+constexpr auto fLength{SegmentationMosaix::Length};
+constexpr auto fWidth{SegmentationMosaix::Width};
+const std::array<SegmentationMosaix, 3> mMosaixSegmentations{0, 1, 2};
 
 TH2* DrawReverseBins(TH2* h)
 {
@@ -83,13 +84,13 @@ void DrawXAxisCol(TH1* h)
   newaxis->Draw();
 }
 
-void CheckSuperAlpideSegmentTrans()
+void CheckMosaixSegmentTrans()
 {
   gStyle->SetOptStat(1111111);
 
   for (int iLayer{0}; iLayer < 3; ++iLayer) {
-    float r_inner = constants::radii[iLayer] - constants::thickness / 2.;
-    float r_outer = constants::radii[iLayer] + constants::thickness / 2.;
+    float r_inner = constants::radiiInner[iLayer];
+    float r_outer = constants::radiiOuter[iLayer];
     float phiReadout_inner =
       constants::tile::readout::width / r_inner * Rad2Deg;
     float phiReadout_outer =
@@ -140,10 +141,10 @@ void CheckSuperAlpideSegmentTrans()
       g_arc_inner->AddPoint(x_inner, y_inner);
       g_arc_outer->AddPoint(x_outer, y_outer);
       // Test Segmentation
-      SuperSegmentations[iLayer].curvedToFlat(x_inner, y_inner, x_inner_flat, y_inner_flat);
-      SuperSegmentations[iLayer].flatToCurved(x_inner_flat, y_inner_flat, x_inner_curved, y_inner_curved);
-      SuperSegmentations[iLayer].curvedToFlat(x_outer, y_outer, x_outer_flat, y_outer_flat);
-      SuperSegmentations[iLayer].flatToCurved(x_outer_flat, y_outer_flat, x_outer_curved, y_outer_curved);
+      mMosaixSegmentations[iLayer].curvedToFlat(x_inner, y_inner, x_inner_flat, y_inner_flat);
+      mMosaixSegmentations[iLayer].flatToCurved(x_inner_flat, y_inner_flat, x_inner_curved, y_inner_curved);
+      mMosaixSegmentations[iLayer].curvedToFlat(x_outer, y_outer, x_outer_flat, y_outer_flat);
+      mMosaixSegmentations[iLayer].flatToCurved(x_outer_flat, y_outer_flat, x_outer_curved, y_outer_curved);
       g_arc_inner_flat->AddPoint(x_inner_flat, y_inner_flat);
       g_arc_outer_flat->AddPoint(x_outer_flat, y_outer_flat);
       h_f2c_res->Fill(x_inner - x_inner_curved, y_inner - y_inner_curved);
@@ -201,15 +202,12 @@ void CheckSuperAlpideSegmentTrans()
       for (int iCol{0}; iCol < nCols; ++iCol) {
         float xRow{0}, zCol{0};
         int iiRow{0}, iiCol{0};
-        auto v1 =
-          SuperSegmentations[iLayer].detectorToLocal(iRow, iCol, xRow, zCol);
-        auto v2 = SuperSegmentations[iLayer].localToDetector(xRow, zCol, iiRow,
-                                                             iiCol);
-        // Info("L2D",
-        //      "iRow=%d, iCol=%d --d2l(%s)--> xRow=%f, zCol=%f --l2d(%s)--> "
-        //      "iiRow=%d, iiCol=%d",
-        //      iRow, iCol, v1 ? "good" : "bad", xRow, zCol, v2 ? "good" :
-        //      "bad", iiRow, iiCol);
+        auto v1 = mMosaixSegmentations[iLayer].detectorToLocal(iRow, iCol, xRow, zCol);
+        auto v2 = mMosaixSegmentations[iLayer].localToDetector(xRow, zCol, iiRow, iiCol);
+        Info("L2D",
+             "iRow=%d, iCol=%d --d2l(%s)--> xRow=%f, zCol=%f --l2d(%s)--> "
+             "iiRow=%d, iiCol=%d",
+             iRow, iCol, v1 ? "good" : "bad", xRow, zCol, v2 ? "good" : "bad", iiRow, iiCol);
         if (!v1 || !v2) {
           Error("LOOP", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx Layer %d", iLayer);
           return;
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckTileNumbering.C b/Detectors/Upgrades/ITS3/macros/test/CheckTileNumbering.C
index 3a01960b1859d..220b1d39ad42b 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckTileNumbering.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckTileNumbering.C
@@ -25,7 +25,7 @@
 
 #include "ITSBase/GeometryTGeo.h"
 #include "ITS3Base/SpecsV2.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "MathUtils/Cartesian.h"
 #include "MathUtils/Utils.h"
 #include "DataFormatsITSMFT/NoiseMap.h"
@@ -102,6 +102,8 @@ void CheckTileNumbering(const std::string& inputGeom = "", const std::string& de
   Int_t colors[NRGBs] = {kWhite, kRed, kGray};
   TColor::SetPalette(NRGBs, colors, 1.0);
 
+  std::array<o2::its3::SegmentationMosaix, 3> mMosaixSegmentations{0, 1, 2};
+
   const float phiOffsetL0 = std::asin(o2::its3::constants::equatorialGap / 2.f / o2::its3::constants::radii[0]);
   const float phiOffsetL1 = std::asin(o2::its3::constants::equatorialGap / 2.f / o2::its3::constants::radii[1]);
   const float phiOffsetL2 = std::asin(o2::its3::constants::equatorialGap / 2.f / o2::its3::constants::radii[2]);
@@ -142,7 +144,7 @@ void CheckTileNumbering(const std::string& inputGeom = "", const std::string& de
   for (unsigned int iDet{0}; iDet <= o2::its3::constants::detID::l2IDEnd; ++iDet) {
     int sensorID = o2::its3::constants::detID::getSensorID(iDet);
     int layerID = o2::its3::constants::detID::getDetID2Layer(iDet);
-    o2::its3::SuperSegmentations[layerID].flatToCurved(xFlat, 0., x, y);
+    mMosaixSegmentations[layerID].flatToCurved(xFlat, 0., x, y);
     o2::math_utils::Point3D<float> locC{x, y, z};
     auto gloC = gman->getMatrixL2G(iDet)(locC);
     float phi = o2::math_utils::to02Pi(std::atan2(gloC.Y(), gloC.X()));
diff --git a/Detectors/Upgrades/ITS3/macros/test/CompareClustersAndDigits.C b/Detectors/Upgrades/ITS3/macros/test/CompareClustersAndDigits.C
index f151de72c8ac1..c124481cc6f76 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CompareClustersAndDigits.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CompareClustersAndDigits.C
@@ -31,7 +31,7 @@
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "ITS3Base/SpecsV2.h"
 #include "ITS3Reconstruction/TopologyDictionary.h"
 #include "ITSBase/GeometryTGeo.h"
@@ -86,7 +86,6 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
 
   using namespace o2::base;
   using o2::itsmft::Hit;
-  using SuperSegmentation = o2::its3::SegmentationSuperAlpide;
   using Segmentation = o2::itsmft::SegmentationAlpide;
   using o2::itsmft::CompClusterExt;
   using ROFRec = o2::itsmft::ROFRecord;
@@ -97,6 +96,8 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
   std::vector<HitVec*> hitVecPool;
   std::vector<MC2HITS_map> mc2hitVec;
 
+  std::array<o2::its3::SegmentationMosaix, 3> mMosaixSegmentations{0, 1, 2};
+
   // Geometry
   o2::base::GeometryManager::loadGeometry(inputGeom);
   auto gman = o2::its::GeometryTGeo::Instance();
@@ -124,9 +125,9 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
   TFile fileC(clusfile.data());
   auto* clusTree = dynamic_cast<TTree*>(fileC.Get("o2sim"));
   std::vector<CompClusterExt>* clusArr = nullptr;
-  clusTree->SetBranchAddress("IT3ClusterComp", &clusArr);
+  clusTree->SetBranchAddress("ITSClusterComp", &clusArr);
   std::vector<unsigned char>* patternsPtr = nullptr;
-  auto pattBranch = clusTree->GetBranch("IT3ClusterPatt");
+  auto pattBranch = clusTree->GetBranch("ITSClusterPatt");
   if (pattBranch != nullptr) {
     pattBranch->SetAddress(&patternsPtr);
   }
@@ -144,14 +145,14 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
 
   // ROFrecords
   std::vector<ROFRec> rofRecVec, *rofRecVecP = &rofRecVec;
-  clusTree->SetBranchAddress("IT3ClustersROF", &rofRecVecP);
+  clusTree->SetBranchAddress("ITSClustersROF", &rofRecVecP);
 
   // Cluster MC labels
   o2::dataformats::MCTruthContainer<o2::MCCompLabel>* clusLabArr = nullptr;
   std::vector<MC2ROF> mc2rofVec, *mc2rofVecP = &mc2rofVec;
-  if ((hitTree != nullptr) && (clusTree->GetBranch("IT3ClusterMCTruth") != nullptr)) {
-    clusTree->SetBranchAddress("IT3ClusterMCTruth", &clusLabArr);
-    clusTree->SetBranchAddress("IT3ClustersMC2ROF", &mc2rofVecP);
+  if ((hitTree != nullptr) && (clusTree->GetBranch("ITSClusterMCTruth") != nullptr)) {
+    clusTree->SetBranchAddress("ITSClusterMCTruth", &clusLabArr);
+    clusTree->SetBranchAddress("ITSClustersMC2ROF", &mc2rofVecP);
   }
 
   clusTree->GetEntry(0);
@@ -188,7 +189,7 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
   std::vector<Data> data(nChips);
   for (int iChip{0}; iChip < nChips; ++iChip) {
     auto& dat = data[iChip];
-    int col{o2::its3::SegmentationSuperAlpide::mNCols}, row{o2::its3::SegmentationSuperAlpide::mNRows};
+    int col{o2::its3::SegmentationMosaix::NCols}, row{o2::its3::SegmentationMosaix::NRows};
     if (!o2::its3::constants::detID::isDetITS3(iChip)) {
       col = o2::itsmft::SegmentationAlpide::NCols;
       row = o2::itsmft::SegmentationAlpide::NRows;
@@ -259,7 +260,7 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
       const auto pattID = cluster.getPatternID();
       const auto isIB = o2::its3::constants::detID::isDetITS3(chipID);
       const auto layer = gman->getLayer(chipID);
-      if (pattID == o2::itsmft::CompCluster::InvalidPatternID || dict.isGroup(pattID)) {
+      if (pattID == o2::itsmft::CompCluster::InvalidPatternID || dict.isGroup(pattID, isIB)) {
         continue;
       }
       const auto& lab = (clusLabArr->getLabels(clEntry))[0];
@@ -282,9 +283,9 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
       o2::math_utils::Point3D<float> locHMiddle;
       if (isIB) {
         float xFlat{0.}, yFlat{0.};
-        o2::its3::SuperSegmentations[layer].curvedToFlat(locHEnd.X(), locHEnd.Y(), xFlat, yFlat);
+        mMosaixSegmentations[layer].curvedToFlat(locHEnd.X(), locHEnd.Y(), xFlat, yFlat);
         locHEnd.SetXYZ(xFlat, yFlat, locHEnd.Z());
-        o2::its3::SuperSegmentations[layer].curvedToFlat(locHStart.X(), locHStart.Y(), xFlat, yFlat);
+        mMosaixSegmentations[layer].curvedToFlat(locHStart.X(), locHStart.Y(), xFlat, yFlat);
         locHStart.SetXYZ(xFlat, yFlat, locHStart.Z());
       }
       locHMiddle.SetXYZ(0.5f * (locHEnd.X() + locHStart.X()), 0.5f * (locHEnd.Y() + locHStart.Y()), 0.5f * (locHEnd.Z() + locHStart.Z()));
@@ -292,10 +293,10 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
       int rowHS, colHS, rowHM, colHM, rowHE, colHE, colC, rowC;
       bool v1, v2, v3, v4;
       if (isIB) {
-        v1 = o2::its3::SuperSegmentations[layer].localToDetector(locHStart.X(), locHStart.Z(), rowHS, colHS);
-        v2 = o2::its3::SuperSegmentations[layer].localToDetector(locHMiddle.X(), locHMiddle.Z(), rowHM, colHM);
-        v3 = o2::its3::SuperSegmentations[layer].localToDetector(locHEnd.X(), locHEnd.Z(), rowHE, colHE);
-        v4 = o2::its3::SuperSegmentations[layer].localToDetector(locC.X(), locC.Z(), rowC, colC);
+        v1 = mMosaixSegmentations[layer].localToDetector(locHStart.X(), locHStart.Z(), rowHS, colHS);
+        v2 = mMosaixSegmentations[layer].localToDetector(locHMiddle.X(), locHMiddle.Z(), rowHM, colHM);
+        v3 = mMosaixSegmentations[layer].localToDetector(locHEnd.X(), locHEnd.Z(), rowHE, colHE);
+        v4 = mMosaixSegmentations[layer].localToDetector(locC.X(), locC.Z(), rowC, colC);
       } else {
         v1 = o2::itsmft::SegmentationAlpide::localToDetector(locHStart.X(), locHStart.Z(), rowHS, colHS);
         v2 = o2::itsmft::SegmentationAlpide::localToDetector(locHMiddle.X(), locHMiddle.Z(), rowHM, colHM);
@@ -315,7 +316,7 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
       data[chipID].cog->AddPoint(colC, rowC);
 
       constexpr float delta = 1e-2;
-      const auto& patt = dict.getPattern(cluster.getPatternID());
+      const auto& patt = dict.getPattern(cluster.getPatternID(), isIB);
       auto box = new TBox(
         cluster.getCol() - delta - 0.5,
         cluster.getRow() - delta - 0.5,
@@ -338,8 +339,8 @@ void CompareClustersAndDigits(std::string clusfile = "o2clus_it3.root",
     }
     auto& dat = data[iChip];
     gFile->cd();
-    /* auto path = gman->getMatrixPath(iChip); */
-    TString path; // TODO wrong use above
+    auto path = gman->getMatrixPath(iChip);
+    /*TString path; // TODO wrong use above*/
     const std::string cpath{path.Data() + 39, path.Data() + path.Length()};
     const std::filesystem::path p{cpath};
     if (oFile->mkdir(p.parent_path().c_str(), "", true) == nullptr) {
diff --git a/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C b/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
index d8783ba7c8fb9..cc241afb3357a 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
@@ -34,7 +34,7 @@
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITSMFT/ClusterTopology.h"
 #include "ITS3Reconstruction/TopologyDictionary.h"
@@ -60,14 +60,13 @@ void CreateDictionariesITS3(bool saveDeltas = false,
                             std::string collContextfile = "collisioncontext.root",
                             std::string inputGeom = "",
                             float checkOutliers = 2., // reject outliers (MC dX or dZ exceeds row/col span by a factor above the threshold)
-                            float minPtMC = 0.01)     // account only MC hits with pT above threshold
+                            float minPtMC = 0.1)      // account only MC hits with pT above threshold
 {
   const int QEDSourceID = 99; // Clusters from this MC source correspond to QED electrons
 
   using namespace o2::base;
   using namespace o2::its;
 
-  using o2::its3::SegmentationSuperAlpide;
   using Segmentation = o2::itsmft::SegmentationAlpide;
   using o2::its3::BuildTopologyDictionary;
   using o2::itsmft::ClusterTopology;
@@ -82,12 +81,14 @@ void CreateDictionariesITS3(bool saveDeltas = false,
   std::vector<HitVec*> hitVecPool;
   std::vector<MC2HITS_map> mc2hitVec;
   o2::its3::TopologyDictionary clusDictOld;
+  std::array<o2::its3::SegmentationMosaix, 3> mMosaixSegmentations{0, 1, 2};
   if (!clusDictFile.empty()) {
     clusDictOld.readFromFile(clusDictFile);
-    LOGP(info, "Loaded external cluster dictionary with {} entries from {}", clusDictOld.getSize(), clusDictFile);
+    LOGP(info, "Loaded external cluster dictionary with {} IB/{} OBentries from {}", clusDictOld.getSize(true), clusDictOld.getSize(false), clusDictFile);
   }
 
-  ULong_t cOk{0}, cOutliers{0}, cFailedMC{0};
+  ULong_t cOkIB{0}, cOutliersIB{0}, cFailedMCIB{0};
+  ULong_t cOkOB{0}, cOutliersOB{0}, cFailedMCOB{0};
 
   TFile* fout = nullptr;
   TNtuple* nt = nullptr;
@@ -233,17 +234,18 @@ void CreateDictionariesITS3(bool saveDeltas = false,
 
         const auto& cluster = (*clusArr)[clEntry];
         o2::itsmft::ClusterPattern pattern;
+        bool ib = o2::its3::constants::detID::isDetITS3(cluster.getChipID());
 
         if (cluster.getPatternID() != CompCluster::InvalidPatternID) {
-          if (clusDictOld.getSize() == 0) {
+          if (clusDictOld.getSize(ib) == 0) {
             LOG(error) << "Encountered patternID = " << cluster.getPatternID() << " != " << CompCluster::InvalidPatternID;
             LOG(error) << "Clusters have already been generated with a dictionary which was not provided";
             return;
           }
-          if (clusDictOld.isGroup(cluster.getPatternID())) {
+          if (clusDictOld.isGroup(cluster.getPatternID(), ib)) {
             pattern.acquirePattern(pattIdx);
           } else {
-            pattern = clusDictOld.getPattern(cluster.getPatternID());
+            pattern = clusDictOld.getPattern(cluster.getPatternID(), ib);
           }
         } else {
           pattern.acquirePattern(pattIdx);
@@ -270,44 +272,43 @@ void CreateDictionariesITS3(bool saveDeltas = false,
                 o2::math_utils::Vector3D<float> xyzLocM;
                 xyzLocM.SetCoordinates(0.5f * (xyzLocE.X() + xyzLocS.X()), 0.5f * (xyzLocE.Y() + xyzLocS.Y()), 0.5f * (xyzLocE.Z() + xyzLocS.Z()));
                 auto locC = o2::its3::TopologyDictionary::getClusterCoordinates(cluster, pattern, false);
-                bool isIB = o2::its3::constants::detID::isDetITS3(chipID);
                 int layer = gman->getLayer(chipID);
-                if (isIB) {
+                if (ib) {
                   float xFlat{0.}, yFlat{0.};
-                  o2::its3::SuperSegmentations[layer].curvedToFlat(xyzLocM.X(), xyzLocM.Y(), xFlat, yFlat);
+                  mMosaixSegmentations[layer].curvedToFlat(xyzLocM.X(), xyzLocM.Y(), xFlat, yFlat);
                   xyzLocM.SetCoordinates(xFlat, yFlat, xyzLocM.Z());
-                  o2::its3::SuperSegmentations[layer].curvedToFlat(locC.X(), locC.Y(), xFlat, yFlat);
+                  mMosaixSegmentations[layer].curvedToFlat(locC.X(), locC.Y(), xFlat, yFlat);
                   locC.SetCoordinates(xFlat, yFlat, locC.Z());
                 }
                 dX = xyzLocM.X() - locC.X();
                 dZ = xyzLocM.Z() - locC.Z();
-                dX /= (isIB) ? o2::its3::SegmentationSuperAlpide::mPitchRow : o2::itsmft::SegmentationAlpide::PitchRow;
-                dZ /= (isIB) ? o2::its3::SegmentationSuperAlpide::mPitchCol : o2::itsmft::SegmentationAlpide::PitchCol;
+                dX /= (ib) ? o2::its3::SegmentationMosaix::PitchRow : o2::itsmft::SegmentationAlpide::PitchRow;
+                dZ /= (ib) ? o2::its3::SegmentationMosaix::PitchCol : o2::itsmft::SegmentationAlpide::PitchCol;
                 if (saveDeltas) {
                   nt->Fill(topology.getHash(), dX, dZ);
                 }
                 if (checkOutliers > 0.) {
                   if (bool bX = std::abs(dX) > topology.getRowSpan() * checkOutliers, bZ = std::abs(dZ) > topology.getColumnSpan() * checkOutliers; bX || bZ) { // ignore outlier
-                    ++cOutliers;
+                    (ib) ? ++cOutliersIB : ++cOutliersOB;
                     LOGP(debug, "Ignored Value dX={} > {} * {} -> {}", dX, topology.getRowSpan(), checkOutliers, bX);
                     LOGP(debug, "Ignored Value dZ={} > {} * {} -> {}", dZ, topology.getColumnSpan(), checkOutliers, bZ);
                     dX = dZ = BuildTopologyDictionary::IgnoreVal;
                   } else {
-                    ++cOk;
+                    (ib) ? ++cOkIB : ++cOkOB;
                   }
                 }
               }
             } else {
               /* LOGP(info, "  Failed to find MC hit entry for Tr: {} chipID: {}", trID, chipID); */
               /* lab.print(); */
-              ++cFailedMC;
+              (ib) ? ++cFailedMCIB : ++cFailedMCOB;
             }
-            signalDictionary.accountTopology(topology, dX, dZ);
+            signalDictionary.accountTopology(topology, ib, dX, dZ);
           } else {
-            noiseDictionary.accountTopology(topology, dX, dZ);
+            noiseDictionary.accountTopology(topology, ib, dX, dZ);
           }
         }
-        completeDictionary.accountTopology(topology, dX, dZ);
+        completeDictionary.accountTopology(topology, ib, dX, dZ);
       }
 
       // clean MC cache for events which are not needed anymore
@@ -323,12 +324,14 @@ void CreateDictionariesITS3(bool saveDeltas = false,
     }
   }
 
-  LOGP(info, "Clusters: {} okay (failed MCHit2Clus {}); outliers {}", cOk, cFailedMC, cOutliers);
+  LOGP(info, "IB Clusters: {} okay (failed MCHit2Clus {}); outliers {}", cOkIB, cFailedMCIB, cOutliersIB);
+  LOGP(info, "OB Clusters: {} okay (failed MCHit2Clus {}); outliers {}", cOkOB, cFailedMCOB, cOutliersOB);
 
   auto dID = o2::detectors::DetID::IT3;
 
   LOGP(info, "Complete Dictionary:");
-  completeDictionary.setThreshold(probThreshold);
+  completeDictionary.setThreshold(probThreshold, true);
+  completeDictionary.setThreshold(probThreshold, false);
   completeDictionary.groupRareTopologies();
   completeDictionary.printDictionaryBinary(o2::base::DetectorNameConf::getAlpideClusterDictionaryFileName(dID, ""));
   completeDictionary.printDictionary(o2::base::DetectorNameConf::getAlpideClusterDictionaryFileName(dID, "", "txt"));
@@ -336,24 +339,34 @@ void CreateDictionariesITS3(bool saveDeltas = false,
 
   TFile histogramOutput("histograms.root", "recreate");
   TCanvas* cComplete = new TCanvas("cComplete", "Distribution of all the topologies");
-  cComplete->cd();
-  cComplete->SetLogy();
-  TH1F* hComplete = completeDictionary.getDictionary().getTopologyDistribution("hComplete");
-  hComplete->SetDirectory(nullptr);
-  hComplete->Draw("hist");
-  hComplete->Write();
+  cComplete->Divide(2, 1);
+  cComplete->cd(1);
+  TH1F* hCompleteIB = completeDictionary.getDictionary().getTopologyDistribution("hCompleteInnerBarrel", true);
+  hCompleteIB->SetDirectory(nullptr);
+  hCompleteIB->Draw("hist");
+  gPad->SetLogy();
+  cComplete->cd(2);
+  TH1F* hCompleteOB = completeDictionary.getDictionary().getTopologyDistribution("hCompleteOuterBarrel", false);
+  hCompleteOB->SetDirectory(nullptr);
+  hCompleteOB->Draw("hist");
+  gPad->SetLogy();
+  histogramOutput.cd();
+  hCompleteIB->Write();
+  hCompleteOB->Write();
   cComplete->Write();
 
   if (clusLabArr) {
     LOGP(info, "Noise Dictionary:");
-    noiseDictionary.setThreshold(0.0001);
+    noiseDictionary.setThreshold(0.0001, true);
+    noiseDictionary.setThreshold(0.0001, false);
     noiseDictionary.groupRareTopologies();
     noiseDictionary.printDictionaryBinary(o2::base::DetectorNameConf::getAlpideClusterDictionaryFileName(dID, "noiseClusTopo"));
     noiseDictionary.printDictionary(o2::base::DetectorNameConf::getAlpideClusterDictionaryFileName(dID, "noiseClusTopo", "txt"));
     noiseDictionary.saveDictionaryRoot(o2::base::DetectorNameConf::getAlpideClusterDictionaryFileName(dID, "noiseClusTopo", "root"));
 
     LOGP(info, "Signal Dictionary:");
-    signalDictionary.setThreshold(0.0001);
+    signalDictionary.setThreshold(0.0001, true);
+    signalDictionary.setThreshold(0.0001, false);
     signalDictionary.groupRareTopologies();
     signalDictionary.printDictionaryBinary(o2::base::DetectorNameConf::getAlpideClusterDictionaryFileName(dID, "signal"));
     signalDictionary.printDictionary(o2::base::DetectorNameConf::getAlpideClusterDictionaryFileName(dID, "signal", "txt"));
@@ -361,26 +374,42 @@ void CreateDictionariesITS3(bool saveDeltas = false,
 
     LOGP(info, "Plotting Channels");
     auto cNoise = new TCanvas("cNoise", "Distribution of noise topologies");
-    cNoise->cd();
-    cNoise->SetLogy();
-    auto hNoise = noiseDictionary.getDictionary().getTopologyDistribution("hNoise");
-    hNoise->SetDirectory(nullptr);
-    hNoise->Draw("hist");
+    cNoise->Divide(2, 1);
+    cNoise->cd(1);
+    auto hNoiseIB = noiseDictionary.getDictionary().getTopologyDistribution("hNoiseInnerBarrel", true);
+    hNoiseIB->SetDirectory(nullptr);
+    hNoiseIB->Draw("hist");
+    gPad->SetLogy();
+    cNoise->cd(2);
+    auto hNoiseOB = noiseDictionary.getDictionary().getTopologyDistribution("hNoiseOuterBarrel", false);
+    hNoiseOB->SetDirectory(nullptr);
+    hNoiseOB->Draw("hist");
+    gPad->SetLogy();
     histogramOutput.cd();
-    hNoise->Write();
+    hNoiseIB->Write();
+    hNoiseOB->Write();
     cNoise->Write();
+
     auto cSignal = new TCanvas("cSignal", "cSignal");
-    cSignal->cd();
+    cSignal->Divide(2, 1);
+    cSignal->cd(1);
+    auto hSignalIB = signalDictionary.getDictionary().getTopologyDistribution("hSignalInnerBarrel", true);
+    hSignalIB->SetDirectory(nullptr);
+    hSignalIB->Draw("hist");
+    gPad->SetLogy();
+    cSignal->cd(2);
     cSignal->SetLogy();
-    auto hSignal = signalDictionary.getDictionary().getTopologyDistribution("hSignal");
-    hSignal->SetDirectory(nullptr);
-    hSignal->Draw("hist");
+    auto hSignalOB = signalDictionary.getDictionary().getTopologyDistribution("hSignalOuterBarrel", false);
+    hSignalOB->SetDirectory(nullptr);
+    hSignalOB->Draw("hist");
+    gPad->SetLogy();
     histogramOutput.cd();
-    hSignal->Write();
+    hSignalIB->Write();
+    hSignalOB->Write();
     cSignal->Write();
-    sw.Stop();
-    sw.Print();
   }
+  sw.Stop();
+  sw.Print();
   if (saveDeltas) {
     fout->cd();
     nt->Write();
diff --git a/Detectors/Upgrades/ITS3/macros/test/TestSensorGeometry.C b/Detectors/Upgrades/ITS3/macros/test/TestSensorGeometry.C
index 1a0ec73e34f31..4b54bbced2929 100644
--- a/Detectors/Upgrades/ITS3/macros/test/TestSensorGeometry.C
+++ b/Detectors/Upgrades/ITS3/macros/test/TestSensorGeometry.C
@@ -21,7 +21,7 @@
 #include "TList.h"
 #endif
 
-void TestSensorGeometry(bool checkFull = false)
+void TestSensorGeometry(bool draw = false, bool checkFull = false)
 {
   gGeoManager = new TGeoManager("simple", "Simple geometry");
   TGeoMaterial* matVacuum = new TGeoMaterial("Vacuum", 0, 0, 0);
@@ -30,8 +30,7 @@ void TestSensorGeometry(bool checkFull = false)
   auto top = gGeoManager->MakeBox("TOP", Vacuum, 270., 270., 120.);
   gGeoManager->SetTopVolume(top);
 
-  o2::its3::ITS3Layer layer0{0, top, nullptr,
-                             o2::its3::ITS3Layer::BuildLevel::kLayer, true};
+  o2::its3::ITS3Layer layer0{2, top, nullptr, o2::its3::ITS3Layer::BuildLevel::kLayer, true};
 
   // Print available medias
   TIter next{gGeoManager->GetListOfMedia()};
@@ -42,13 +41,17 @@ void TestSensorGeometry(bool checkFull = false)
 
   gGeoManager->CloseGeometry();
   gGeoManager->SetVisLevel(99);
+  if (draw) {
+    gGeoManager->Draw("ogl");
+  }
+
   if (checkFull) {
     gGeoManager->CheckGeometryFull();
-  }
-  gGeoManager->CheckOverlaps(0.0001);
-  TIter nextOverlap{gGeoManager->GetListOfOverlaps()};
-  while ((obj = (TObject*)nextOverlap())) {
-    LOGP(info, "Overlap in {}", obj->GetName());
+    gGeoManager->CheckOverlaps(0.00001);
+    TIter nextOverlap{gGeoManager->GetListOfOverlaps()};
+    while ((obj = (TObject*)nextOverlap())) {
+      LOGP(info, "Overlap in {}", obj->GetName());
+    }
   }
 
   std::unique_ptr<TFile> f{TFile::Open("geo.root", "RECREATE")};
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/BuildTopologyDictionary.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/BuildTopologyDictionary.h
index 7df603bb29fb2..662c58aeb2cd8 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/BuildTopologyDictionary.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/BuildTopologyDictionary.h
@@ -24,31 +24,47 @@ namespace o2::its3
 
 class BuildTopologyDictionary
 {
+  using TopoInfo = std::unordered_map<long unsigned, itsmft::TopologyInfo>;
+  using TopoStat = std::map<long unsigned, itsmft::TopoStat>;
+  using TopoFreq = std::vector<std::pair<unsigned long, unsigned long>>;
+
  public:
   static constexpr float IgnoreVal = 999.;
-  void accountTopology(const itsmft::ClusterTopology& cluster, float dX = IgnoreVal, float dZ = IgnoreVal);
-  void setNCommon(unsigned int nCommon); // set number of common topologies
-  void setThreshold(double thr);
-  void setThresholdCumulative(double cumulative); // Considering the integral
+  void accountTopology(const itsmft::ClusterTopology& cluster, bool IB, float dX = IgnoreVal, float dZ = IgnoreVal);
+  void setNCommon(unsigned int nCommon, bool IB); // set number of common topologies
+  void setThreshold(double thr, bool IB);
+  void setThresholdCumulative(double cumulative, bool IB); // Considering the integral
   void groupRareTopologies();
-  friend std::ostream& operator<<(std::ostream& os, const BuildTopologyDictionary& BD);
   void printDictionary(const std::string& fname);
   void printDictionaryBinary(const std::string& fname);
   void saveDictionaryRoot(const std::string& fname);
 
-  unsigned int getTotClusters() const { return mTotClusters; }
-  unsigned int getNotInGroups() const { return mNCommonTopologies; }
-  TopologyDictionary getDictionary() const { return mDictionary; }
+  [[nodiscard]] unsigned int getTotClusters(bool IB) const { return (IB) ? mTotClustersIB : mTotClustersOB; }
+  [[nodiscard]] unsigned int getNotInGroups(bool IB) const { return (IB) ? mNCommonTopologiesIB : mNCommonTopologiesOB; }
+  [[nodiscard]] const TopologyDictionary& getDictionary() const { return mDictionary; }
+
+  friend std::ostream& operator<<(std::ostream& os, const BuildTopologyDictionary& BD);
 
  private:
-  TopologyDictionary mDictionary;                                          ///< Dictionary of topologies
-  std::map<unsigned long, itsmft::TopoStat> mTopologyMap;                  //! Temporary map of type <hash, TopStat>
-  std::vector<std::pair<unsigned long, unsigned long>> mTopologyFrequency; //! <freq,hash>, needed to define threshold
-  unsigned int mTotClusters{0};
-  unsigned int mNCommonTopologies{0};
-  double mFrequencyThreshold{0.};
-
-  std::unordered_map<long unsigned, itsmft::TopologyInfo> mMapInfo;
+  void accountTopologyImpl(const itsmft::ClusterTopology& cluster, TopoInfo& tinfo, TopoStat& tstat, unsigned int& ntot, float sigmaX, float sigmaZ, float dX, float dZ);
+  void setNCommonImpl(unsigned int ncom, TopoFreq& tfreq, TopoStat& tstat, unsigned int& ncommon, unsigned int ntot);
+  void setThresholdImpl(double thr, TopoFreq& tfreq, TopoInfo& tinfo, TopoStat& tstat, unsigned int& ncommon, double& freqthres, unsigned int ntot);
+  void setThresholdCumulativeImpl(double cumulative, TopoFreq& tfreq, unsigned int& ncommon, double& freqthres, unsigned int ntot);
+  void groupRareTopologiesImpl(TopoFreq& tfreq, TopoInfo& tinfo, TopoStat& tstat, unsigned int& ncommon, double& freqthres, TopologyDictionaryData& data, unsigned int ntot);
+
+  TopologyDictionary mDictionary; ///< Dictionary of topologies
+  unsigned int mTotClustersIB{0};
+  unsigned int mTotClustersOB{0};
+  unsigned int mNCommonTopologiesIB{0};
+  unsigned int mNCommonTopologiesOB{0};
+  double mFrequencyThresholdIB{0.};
+  double mFrequencyThresholdOB{0.};
+  TopoInfo mMapInfoIB;
+  TopoInfo mMapInfoOB;
+  TopoStat mTopologyMapIB;       //! IB Temporary map of type <hash, TopStat>
+  TopoStat mTopologyMapOB;       //! OB Temporary map of type <hash, TopStat>
+  TopoFreq mTopologyFrequencyIB; //! IB <freq,hash>, needed to define threshold
+  TopoFreq mTopologyFrequencyOB; //! OB <freq,hash>, needed to define threshold
 
   ClassDefNV(BuildTopologyDictionary, 3);
 };
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/Clusterer.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/Clusterer.h
index 20acf07d4f547..a81db09217e9b 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/Clusterer.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/Clusterer.h
@@ -207,7 +207,7 @@ class Clusterer
 
   template <typename VCLUS, typename VPAT>
   static void streamCluster(const std::vector<PixelData>& pixbuf, const std::array<Label, MaxLabels>* lblBuff, const BBox& bbox, const its3::LookUp& pattIdConverter,
-                            VCLUS* compClusPtr, VPAT* patternsPtr, MCTruth* labelsClusPtr, int nlab, bool isHuge = false);
+                            VCLUS* compClusPtr, VPAT* patternsPtr, MCTruth* labelsClusPtr, int nlab, bool isIB, bool isHuge = false);
 
   bool isContinuousReadOut() const { return mContinuousReadout; }
   void setContinuousReadOut(bool v) { mContinuousReadout = v; }
@@ -230,7 +230,7 @@ class Clusterer
   ///< load the dictionary of cluster topologies
   void setDictionary(const its3::TopologyDictionary* dict)
   {
-    LOGP(info, "Setting TopologyDictionary with size={}", dict->getSize());
+    LOGP(info, "Setting TopologyDictionary with IB size={} & OB size={}", dict->getSize(true), dict->getSize(false));
     mPattIdConverter.setDictionary(dict);
     // dict->print();
   }
@@ -274,7 +274,7 @@ class Clusterer
 
 template <typename VCLUS, typename VPAT>
 void Clusterer::streamCluster(const std::vector<PixelData>& pixbuf, const std::array<Label, MaxLabels>* lblBuff, const Clusterer::BBox& bbox, const its3::LookUp& pattIdConverter,
-                              VCLUS* compClusPtr, VPAT* patternsPtr, MCTruth* labelsClusPtr, int nlab, bool isHuge)
+                              VCLUS* compClusPtr, VPAT* patternsPtr, MCTruth* labelsClusPtr, int nlab, bool isIB, bool isHuge)
 {
   if (labelsClusPtr && lblBuff) { // MC labels were requested
     auto cnt = compClusPtr->size();
@@ -291,10 +291,10 @@ void Clusterer::streamCluster(const std::vector<PixelData>& pixbuf, const std::a
     int nbits = ir * colSpanW + ic;
     patt[nbits >> 3] |= (0x1 << (7 - (nbits % 8)));
   }
-  uint16_t pattID = (isHuge || pattIdConverter.size() == 0) ? CompCluster::InvalidPatternID : pattIdConverter.findGroupID(rowSpanW, colSpanW, patt.data());
+  uint16_t pattID = (isHuge || pattIdConverter.size(isIB) == 0) ? CompCluster::InvalidPatternID : pattIdConverter.findGroupID(rowSpanW, colSpanW, isIB, patt.data());
   uint16_t row = bbox.rowMin, col = bbox.colMin;
   LOGP(debug, "PattID: findGroupID({},{},{})={}", row, col, patt[0], pattID);
-  if (pattID == CompCluster::InvalidPatternID || pattIdConverter.isGroup(pattID)) {
+  if (pattID == CompCluster::InvalidPatternID || pattIdConverter.isGroup(pattID, isIB)) {
     if (pattID != CompCluster::InvalidPatternID) {
       // For groupped topologies, the reference pixel is the COG pixel
       float xCOG = 0., zCOG = 0.;
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
index 2407344aa0193..b9e7fd0f6ec39 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
@@ -16,14 +16,13 @@
 #include "ITS3Reconstruction/TopologyDictionary.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/IOUtils.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "ITS3Base/SpecsV2.h"
 
 namespace o2::its3::ioutils
 {
-using SSAlpide = o2::its3::SegmentationSuperAlpide;
-constexpr float DefClusErrorRow = o2::its3::SegmentationSuperAlpide::mPitchRow * 0.5;
-constexpr float DefClusErrorCol = o2::its3::SegmentationSuperAlpide::mPitchCol * 0.5;
+constexpr float DefClusErrorRow = o2::its3::SegmentationMosaix::PitchRow * 0.5;
+constexpr float DefClusErrorCol = o2::its3::SegmentationMosaix::PitchCol * 0.5;
 constexpr float DefClusError2Row = DefClusErrorRow * DefClusErrorRow;
 constexpr float DefClusError2Col = DefClusErrorCol * DefClusErrorCol;
 
@@ -31,13 +30,14 @@ template <class iterator, typename T = float>
 o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, iterator& iter, const its3::TopologyDictionary* dict, T& sig2y, T& sig2z)
 {
   auto pattID = c.getPatternID();
+  auto ib = constants::detID::isDetITS3(c.getSensorID());
   // Dummy COG errors (about half pixel size)
-  sig2y = (constants::detID::isDetITS3(c.getSensorID())) ? DefClusError2Row : o2::its::ioutils::DefClusError2Row;
-  sig2z = (constants::detID::isDetITS3(c.getSensorID())) ? DefClusError2Col : o2::its::ioutils::DefClusError2Col;
+  sig2y = (ib) ? DefClusError2Row : o2::its::ioutils::DefClusError2Row;
+  sig2z = (ib) ? DefClusError2Col : o2::its::ioutils::DefClusError2Col;
   if (pattID != itsmft::CompCluster::InvalidPatternID) {
-    sig2y = dict->getErr2X(pattID) * sig2y; // Error is given in detector coordinates
-    sig2z = dict->getErr2Z(pattID) * sig2z;
-    if (!dict->isGroup(pattID)) {
+    sig2y = dict->getErr2X(pattID, ib);
+    sig2z = dict->getErr2Z(pattID, ib);
+    if (!dict->isGroup(pattID, ib)) {
       return dict->getClusterCoordinates<T>(c);
     } else {
       o2::itsmft::ClusterPattern patt(iter);
@@ -53,13 +53,14 @@ template <class iterator, typename T = float>
 o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, iterator& iter, const its3::TopologyDictionary* dict, T& sig2y, T& sig2z, uint8_t& cls)
 {
   auto pattID = c.getPatternID();
+  auto ib = constants::detID::isDetITS3(c.getSensorID());
   auto iterC = iter;
   unsigned int clusterSize{999};
-  if (pattID == itsmft::CompCluster::InvalidPatternID || dict->isGroup(pattID)) {
+  if (pattID == itsmft::CompCluster::InvalidPatternID || dict->isGroup(pattID, ib)) {
     o2::itsmft::ClusterPattern patt(iterC);
     clusterSize = patt.getNPixels();
   } else {
-    clusterSize = dict->getNpixels(pattID);
+    clusterSize = dict->getNpixels(pattID, ib);
   }
   cls = static_cast<uint8_t>(std::clamp(clusterSize, static_cast<unsigned int>(std::numeric_limits<uint8_t>::min()), static_cast<unsigned int>(std::numeric_limits<uint8_t>::max())));
   return extractClusterData(c, iter, dict, sig2y, sig2z);
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/LookUp.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/LookUp.h
index 0fbecb41393ff..809a129a0debf 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/LookUp.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/LookUp.h
@@ -21,7 +21,6 @@
 #ifndef ALICEO2_ITS3_LOOKUP_H
 #define ALICEO2_ITS3_LOOKUP_H
 
-#include "DataFormatsITSMFT/ClusterTopology.h"
 #include "ITS3Reconstruction/TopologyDictionary.h"
 
 namespace o2::its3
@@ -32,20 +31,21 @@ class LookUp
   LookUp() = default;
   LookUp(std::string fileName);
   static int groupFinder(int nRow, int nCol);
-  int findGroupID(int nRow, int nCol, const unsigned char patt[itsmft::ClusterPattern::MaxPatternBytes]) const;
-  int getTopologiesOverThreshold() const { return mTopologiesOverThreshold; }
+  int findGroupID(int nRow, int nCol, bool IB, const unsigned char patt[itsmft::ClusterPattern::MaxPatternBytes]) const;
+  int getTopologiesOverThreshold(bool IB) const { return (IB) ? mTopologiesOverThresholdIB : mTopologiesOverThresholdOB; }
   void loadDictionary(std::string fileName);
   void setDictionary(const TopologyDictionary* dict);
-  bool isGroup(int id) const { return mDictionary.isGroup(id); }
-  int size() const { return mDictionary.getSize(); }
-  auto getPattern(int id) const { return mDictionary.getPattern(id); }
-  auto getDictionaty() const { return mDictionary; }
+  auto getDictionary() const { return mDictionary; }
+  bool isGroup(int id, bool IB) const { return mDictionary.isGroup(id, IB); }
+  int size(bool IB) const { return mDictionary.getSize(IB); }
+  auto getPattern(int id, bool IB) const { return mDictionary.getPattern(id, IB); }
 
  private:
-  TopologyDictionary mDictionary{};
-  int mTopologiesOverThreshold{0};
+  TopologyDictionary mDictionary;
+  int mTopologiesOverThresholdIB{0};
+  int mTopologiesOverThresholdOB{0};
 
-  ClassDefNV(LookUp, 2);
+  ClassDefNV(LookUp, 3);
 };
 } // namespace o2::its3
 
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TopologyDictionary.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TopologyDictionary.h
index a11131ed9f61f..d5f5721170aa7 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TopologyDictionary.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TopologyDictionary.h
@@ -24,6 +24,18 @@ namespace o2::its3
 class BuildTopologyDictionary;
 class LookUp;
 
+struct TopologyDictionaryData {
+  static constexpr int STopoSize{(8 * 255) + 1};
+  std::array<int, STopoSize> mSmallTopologiesLUT{};  ///< Look-Up Table for the topologies with 1-byte linearised matrix
+  std::vector<itsmft::GroupStruct> mVectorOfIDs;     ///< Vector of topologies and groups
+  std::unordered_map<unsigned long, int> mCommonMap; ///< Map of pair <hash, position in mVectorOfIDs>
+  std::unordered_map<int, int> mGroupMap;            ///< Map of pair <groudID, position in mVectorOfIDs>
+
+  void print() const noexcept;
+
+  ClassDefNV(TopologyDictionaryData, 1);
+};
+
 class TopologyDictionary
 {
  public:
@@ -32,91 +44,108 @@ class TopologyDictionary
 
   /// constexpr for the definition of the groups of rare topologies.
   /// The attritbution of the group ID is stringly dependent on the following parameters: it must be a power of 2.
-  static constexpr int RowClassSpan = 4;                                                                    ///< Row span of the classes of rare topologies
-  static constexpr int ColClassSpan = 4;                                                                    ///< Column span of the classes of rare topologies
-  static constexpr int MaxNumberOfRowClasses = 1 + (itsmft::ClusterPattern::MaxRowSpan - 1) / RowClassSpan; ///< Maximum number of row classes for the groups of rare topologies
-  static constexpr int MaxNumberOfColClasses = 1 + (itsmft::ClusterPattern::MaxColSpan - 1) / ColClassSpan; ///< Maximum number of col classes for the groups of rare topologies
-  static constexpr int NumberOfRareGroups = MaxNumberOfRowClasses * MaxNumberOfColClasses;                  ///< Number of entries corresponding to groups of rare topologies (those whos matrix exceed the max number of bytes are empty).
+  static constexpr int RowClassSpan = 4;                                                                      ///< Row span of the classes of rare topologies
+  static constexpr int ColClassSpan = 4;                                                                      ///< Column span of the classes of rare topologies
+  static constexpr int MaxNumberOfRowClasses = 1 + ((itsmft::ClusterPattern::MaxRowSpan - 1) / RowClassSpan); ///< Maximum number of row classes for the groups of rare topologies
+  static constexpr int MaxNumberOfColClasses = 1 + ((itsmft::ClusterPattern::MaxColSpan - 1) / ColClassSpan); ///< Maximum number of col classes for the groups of rare topologies
+  static constexpr int NumberOfRareGroups = MaxNumberOfRowClasses * MaxNumberOfColClasses;                    ///< Number of entries corresponding to groups of rare topologies (those whos matrix exceed the max number of bytes are empty).
+  /// Resets internal structures
+  void reset() noexcept;
+  void resetMaps(bool IB = true) noexcept;
   /// Prints the dictionary
   friend std::ostream& operator<<(std::ostream& os, const its3::TopologyDictionary& dictionary);
   /// Prints the dictionary in a binary file
   void writeBinaryFile(const std::string& outputFile);
   /// Reads the dictionary from a binary file
-  int readBinaryFile(const std::string& fileName);
-
-  int readFromFile(const std::string& fileName);
+  void readBinaryFile(const std::string& fileName);
+  void readFromFile(const std::string& fileName);
+  void print() const noexcept;
 
   /// Returns the x position of the COG for the n_th element
-  inline float getXCOG(int n) const
+  [[nodiscard]] float getXCOG(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mXCOG;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mXCOG;
   }
   /// Returns the error on the x position of the COG for the n_th element
-  inline float getErrX(int n) const
+  [[nodiscard]] float getErrX(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mErrX;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mErrX;
   }
   /// Returns the z position of the COG for the n_th element
-  inline float getZCOG(int n) const
+  [[nodiscard]] float getZCOG(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mZCOG;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mZCOG;
   }
   /// Returns the error on the z position of the COG for the n_th element
-  inline float getErrZ(int n) const
+  [[nodiscard]] float getErrZ(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mErrZ;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mErrZ;
   }
   /// Returns the error^2 on the x position of the COG for the n_th element
-  inline float getErr2X(int n) const
+  [[nodiscard]] float getErr2X(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mErr2X;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mErr2X;
   }
   /// Returns the error^2 on the z position of the COG for the n_th element
-  inline float getErr2Z(int n) const
+  [[nodiscard]] float getErr2Z(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mErr2Z;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mErr2Z;
   }
   /// Returns the hash of the n_th element
-  inline unsigned long getHash(int n) const
+  [[nodiscard]] unsigned long getHash(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mHash;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mHash;
   }
   /// Returns the number of fired pixels of the n_th element
-  inline int getNpixels(int n) const
+  [[nodiscard]] int getNpixels(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mNpixels;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mNpixels;
   }
   /// Returns the frequency of the n_th element;
-  inline double getFrequency(int n) const
+  [[nodiscard]] double getFrequency(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mFrequency;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mFrequency;
   }
   /// Returns true if the element corresponds to a group of rare topologies
-  inline bool isGroup(int n) const
+  [[nodiscard]] bool isGroup(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mIsGroup;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mIsGroup;
   }
   /// Returns the pattern of the topology
-  inline const itsmft::ClusterPattern& getPattern(int n) const
+  [[nodiscard]] const itsmft::ClusterPattern& getPattern(int n, bool IB = true) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
-    return mVectorOfIDs[n].mPattern;
+    const auto& data = (IB) ? mDataIB : mDataOB;
+    assert(n >= 0 || n < (int)data.mVectorOfIDs.size());
+    return data.mVectorOfIDs[n].mPattern;
   }
 
   /// Fills a hostogram with the distribution of the IDs
-  TH1F* getTopologyDistribution(const std::string_view hname = "h_topo_dist") const;
+  [[nodiscard]] TH1F* getTopologyDistribution(const std::string_view hname, bool IB = true) const;
   /// Returns the number of elements in the dicionary;
-  int getSize() const { return (int)mVectorOfIDs.size(); }
+  [[nodiscard]] int getSize(bool IB) const
+  {
+    return static_cast<int>((IB) ? mDataIB.mVectorOfIDs.size() : mDataOB.mVectorOfIDs.size());
+  }
   /// Returns the local position of a compact cluster
 
   /// Returns the local position of a compact cluster
@@ -133,13 +162,10 @@ class TopologyDictionary
   friend its3::LookUp;
 
  private:
-  static constexpr int STopoSize{8 * 255 + 1};
-  std::unordered_map<unsigned long, int> mCommonMap{}; ///< Map of pair <hash, position in mVectorOfIDs>
-  std::unordered_map<int, int> mGroupMap{};            ///< Map of pair <groudID, position in mVectorOfIDs>
-  int mSmallTopologiesLUT[STopoSize]{};                ///< Look-Up Table for the topologies with 1-byte linearised matrix
-  std::vector<itsmft::GroupStruct> mVectorOfIDs{};     ///< Vector of topologies and groups
+  TopologyDictionaryData mDataIB;
+  TopologyDictionaryData mDataOB;
 
-  ClassDefNV(TopologyDictionary, 3);
+  ClassDefNV(TopologyDictionary, 4);
 };
 } // namespace o2::its3
 
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/BuildTopologyDictionary.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/BuildTopologyDictionary.cxx
index 87ad450eecd9e..f7eec52f9434a 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/BuildTopologyDictionary.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/BuildTopologyDictionary.cxx
@@ -14,7 +14,9 @@
 #include "ITS3Reconstruction/BuildTopologyDictionary.h"
 #include "ITS3Reconstruction/LookUp.h"
 #include "DataFormatsITSMFT/CompCluster.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+
+#include "ITSMFTBase/SegmentationAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 
 #include "TFile.h"
 
@@ -22,14 +24,25 @@ ClassImp(o2::its3::BuildTopologyDictionary);
 
 namespace o2::its3
 {
-void BuildTopologyDictionary::accountTopology(const itsmft::ClusterTopology& cluster, float dX, float dZ)
+void BuildTopologyDictionary::accountTopology(const itsmft::ClusterTopology& cluster, bool IB, float dX, float dZ)
 {
-  mTotClusters++;
+  accountTopologyImpl(cluster,
+                      ((IB) ? mMapInfoIB : mMapInfoOB),
+                      ((IB) ? mTopologyMapIB : mTopologyMapOB),
+                      ((IB) ? mTotClustersIB : mTotClustersOB),
+                      ((IB) ? SegmentationMosaix::PitchRow : itsmft::SegmentationAlpide::PitchRow),
+                      ((IB) ? SegmentationMosaix::PitchCol : itsmft::SegmentationAlpide::PitchCol),
+                      dX, dZ);
+}
+
+void BuildTopologyDictionary::accountTopologyImpl(const itsmft::ClusterTopology& cluster, TopoInfo& tinfo, TopoStat& tstat, unsigned int& tot, float sigmaX, float sigmaZ, float dX, float dZ)
+{
+  ++tot;
   bool useDf = dX < IgnoreVal / 2; // we may need to account the frequency but to not update the centroid
 
   // std::pair<unordered_map<unsigned long, itsmft::TopoStat>::iterator,bool> ret;
   // auto ret = mTopologyMap.insert(std::make_pair(cluster.getHash(), std::make_pair(cluster, 1)));
-  auto& topoStat = mTopologyMap[cluster.getHash()];
+  auto& topoStat = tstat[cluster.getHash()];
   topoStat.countsTotal++;
   if (topoStat.countsTotal == 1) { // a new topology is inserted
     topoStat.topology = cluster;
@@ -45,14 +58,14 @@ void BuildTopologyDictionary::accountTopology(const itsmft::ClusterTopology& clu
       topInf.mZmean = dZ;
       topoStat.countsWithBias = 1;
     } else { // assign expected sigmas from the pixel X, Z sizes
-      topInf.mXsigma2 = 1.f / 12.f / (float)std::min(10, topInf.mSizeX);
-      topInf.mZsigma2 = 1.f / 12.f / (float)std::min(10, topInf.mSizeZ);
+      topInf.mXsigma2 = sigmaX * sigmaX / 12.f / (float)std::min(10, topInf.mSizeX);
+      topInf.mZsigma2 = sigmaZ * sigmaZ / (float)std::min(10, topInf.mSizeZ);
     }
-    mMapInfo.emplace(cluster.getHash(), topInf);
+    tinfo.emplace(cluster.getHash(), topInf);
   } else {
     if (useDf) {
       auto num = topoStat.countsWithBias++;
-      auto ind = mMapInfo.find(cluster.getHash());
+      auto ind = tinfo.find(cluster.getHash());
       float tmpxMean = ind->second.mXmean;
       float newxMean = ind->second.mXmean = ((tmpxMean)*num + dX) / (num + 1);
       float tmpxSigma2 = ind->second.mXsigma2;
@@ -65,101 +78,135 @@ void BuildTopologyDictionary::accountTopology(const itsmft::ClusterTopology& clu
   }
 }
 
-void BuildTopologyDictionary::setThreshold(double thr)
+void BuildTopologyDictionary::setNCommon(unsigned int nCommon, bool IB)
+{
+  mDictionary.resetMaps(IB);
+
+  auto& freqTopo = ((IB) ? mTopologyFrequencyIB : mTopologyFrequencyOB);
+  auto& freqThres = ((IB) ? mFrequencyThresholdIB : mFrequencyThresholdOB);
+  auto& comTopo = ((IB) ? mNCommonTopologiesIB : mNCommonTopologiesOB);
+  auto ntot = ((IB) ? mTotClustersIB : mTotClustersOB);
+
+  setNCommonImpl(nCommon,
+                 freqTopo,
+                 ((IB) ? mTopologyMapIB : mTopologyMapOB),
+                 comTopo,
+                 ntot);
+  // Recaculate also the threshold
+  freqThres = ((double)freqTopo[comTopo - 1].first) / ntot;
+}
+
+void BuildTopologyDictionary::setNCommonImpl(unsigned int ncom, TopoFreq& tfreq, TopoStat& tstat, unsigned int& ncommon, unsigned int ntot)
 {
-  mTopologyFrequency.clear();
-  for (auto&& p : mTopologyMap) { // p is pair<ulong,TopoStat>
-    mTopologyFrequency.emplace_back(p.second.countsTotal, p.first);
+  if (ncom >= itsmft::CompCluster::InvalidPatternID) {
+    LOGP(warning, "Redefining nCommon from {} to {} to be below InvalidPatternID", ncom, itsmft::CompCluster::InvalidPatternID - 1);
+    ncom = itsmft::CompCluster::InvalidPatternID - 1;
+  }
+  tfreq.clear();
+  for (auto&& p : tstat) { // p os pair<ulong,TopoStat>
+    tfreq.emplace_back(p.second.countsTotal, p.first);
   }
-  std::sort(mTopologyFrequency.begin(), mTopologyFrequency.end(),
+  std::sort(tfreq.begin(), tfreq.end(),
             [](const std::pair<unsigned long, unsigned long>& couple1,
                const std::pair<unsigned long, unsigned long>& couple2) { return (couple1.first > couple2.first); });
-  mNCommonTopologies = 0;
-  mDictionary.mCommonMap.clear();
-  mDictionary.mGroupMap.clear();
-  mFrequencyThreshold = thr;
-  for (auto& q : mTopologyFrequency) {
-    if (((double)q.first) / mTotClusters > thr) {
-      mNCommonTopologies++;
+  ncommon = ncom;
+}
+
+void BuildTopologyDictionary::setThreshold(double thr, bool IB)
+{
+  mDictionary.resetMaps(IB);
+  setThresholdImpl(thr,
+                   ((IB) ? mTopologyFrequencyIB : mTopologyFrequencyOB),
+                   ((IB) ? mMapInfoIB : mMapInfoOB),
+                   ((IB) ? mTopologyMapIB : mTopologyMapOB),
+                   ((IB) ? mNCommonTopologiesIB : mNCommonTopologiesOB),
+                   ((IB) ? mFrequencyThresholdIB : mFrequencyThresholdOB),
+                   ((IB) ? mTotClustersIB : mTotClustersOB));
+}
+
+void BuildTopologyDictionary::setThresholdImpl(double thr, TopoFreq& tfreq, TopoInfo& tinfo, TopoStat& tstat, unsigned int& ncommon, double& freqthres, unsigned int ntot)
+{
+  setNCommonImpl(0, tfreq, tstat, ncommon, ntot);
+  freqthres = thr;
+  for (auto& q : tfreq) {
+    if (((double)q.first) / ntot > thr) {
+      ++ncommon;
     } else {
       break;
     }
   }
-  if (mNCommonTopologies >= itsmft::CompCluster::InvalidPatternID) {
-    mFrequencyThreshold = ((double)mTopologyFrequency[itsmft::CompCluster::InvalidPatternID - 1].first) / mTotClusters;
-    LOGP(warning, "Redefining prob. threshould from {} to {} to be below InvalidPatternID (was {})", thr, mFrequencyThreshold, mNCommonTopologies);
-    mNCommonTopologies = itsmft::CompCluster::InvalidPatternID - 1;
+  if (ncommon >= itsmft::CompCluster::InvalidPatternID) {
+    freqthres = ((double)tfreq[itsmft::CompCluster::InvalidPatternID - 1].first) / ntot;
+    LOGP(warning, "Redefining prob. threshold from {} to {} to be below InvalidPatternID (was {})", thr, freqthres, ntot);
+    ncommon = itsmft::CompCluster::InvalidPatternID - 1;
   }
 }
 
-void BuildTopologyDictionary::setNCommon(unsigned int nCommon)
+void BuildTopologyDictionary::setThresholdCumulative(double cumulative, bool IB)
 {
-  if (nCommon >= itsmft::CompCluster::InvalidPatternID) {
-    LOGP(warning, "Redefining nCommon from {} to {} to be below InvalidPatternID", nCommon, itsmft::CompCluster::InvalidPatternID - 1);
-    nCommon = itsmft::CompCluster::InvalidPatternID - 1;
-  }
-  mTopologyFrequency.clear();
-  for (auto&& p : mTopologyMap) { // p os pair<ulong,TopoStat>
-    mTopologyFrequency.emplace_back(p.second.countsTotal, p.first);
+  if (cumulative <= 0. || cumulative >= 1.) {
+    cumulative = 0.99;
   }
-  std::sort(mTopologyFrequency.begin(), mTopologyFrequency.end(),
-            [](const std::pair<unsigned long, unsigned long>& couple1,
-               const std::pair<unsigned long, unsigned long>& couple2) { return (couple1.first > couple2.first); });
-  mNCommonTopologies = nCommon;
-  mDictionary.mCommonMap.clear();
-  mDictionary.mGroupMap.clear();
-  mFrequencyThreshold = ((double)mTopologyFrequency[mNCommonTopologies - 1].first) / mTotClusters;
+
+  auto& freqTopo = ((IB) ? mTopologyFrequencyIB : mTopologyFrequencyOB);
+  auto& freqThres = ((IB) ? mFrequencyThresholdIB : mFrequencyThresholdOB);
+  auto& statTopo = ((IB) ? mTopologyMapIB : mTopologyMapOB);
+  auto& comTopo = ((IB) ? mNCommonTopologiesIB : mNCommonTopologiesOB);
+  auto ntot = ((IB) ? mTotClustersIB : mTotClustersOB);
+
+  mDictionary.resetMaps(IB);
+  setNCommonImpl(0, freqTopo, statTopo, comTopo, ntot);
+  setThresholdCumulativeImpl(cumulative, freqTopo, comTopo, freqThres, ntot);
 }
 
-void BuildTopologyDictionary::setThresholdCumulative(double cumulative)
+void BuildTopologyDictionary::setThresholdCumulativeImpl(double cumulative, TopoFreq& tfreq, unsigned int& ncommon, double& freqthres, unsigned int ntot)
 {
-  mTopologyFrequency.clear();
-  if (cumulative <= 0. || cumulative >= 1.) {
-    cumulative = 0.99;
-  }
   double totFreq = 0.;
-  for (auto&& p : mTopologyMap) { // p os pair<ulong,TopoStat>
-    mTopologyFrequency.emplace_back(p.second.countsTotal, p.first);
-  }
-  std::sort(mTopologyFrequency.begin(), mTopologyFrequency.end(),
-            [](const std::pair<unsigned long, unsigned long>& couple1,
-               const std::pair<unsigned long, unsigned long>& couple2) { return (couple1.first > couple2.first); });
-  mNCommonTopologies = 0;
-  mDictionary.mCommonMap.clear();
-  mDictionary.mGroupMap.clear();
-  for (auto& q : mTopologyFrequency) {
-    totFreq += ((double)(q.first)) / mTotClusters;
+  for (auto& q : tfreq) {
+    totFreq += ((double)(q.first)) / ntot;
     if (totFreq < cumulative) {
-      mNCommonTopologies++;
-      if (mNCommonTopologies >= itsmft::CompCluster::InvalidPatternID) {
-        totFreq -= ((double)(q.first)) / mTotClusters;
-        mNCommonTopologies--;
+      ++ncommon;
+      if (ncommon >= itsmft::CompCluster::InvalidPatternID) {
+        totFreq -= ((double)(q.first)) / ntot;
+        --ncommon;
         LOGP(warning, "Redefining cumulative threshould from {} to {} to be below InvalidPatternID)", cumulative, totFreq);
       }
     } else {
       break;
     }
   }
-  mFrequencyThreshold = ((double)(mTopologyFrequency[--mNCommonTopologies].first)) / mTotClusters;
-  while (std::fabs(((double)mTopologyFrequency[mNCommonTopologies].first) / mTotClusters - mFrequencyThreshold) < 1.e-15) {
-    mNCommonTopologies--;
+  freqthres = ((double)(tfreq[--ncommon].first)) / ntot;
+  while (std::fabs(((double)tfreq[ncommon--].first) / ntot - freqthres) < 1.e-15) {
   }
-  mFrequencyThreshold = ((double)mTopologyFrequency[mNCommonTopologies++].first) / mTotClusters;
+  freqthres = ((double)tfreq[ncommon++].first) / ntot;
 }
 
 void BuildTopologyDictionary::groupRareTopologies()
 {
   LOG(info) << "Dictionary finalisation";
-  LOG(info) << "Number of clusters: " << mTotClusters;
+  LOG(info) << "Number of IB clusters: " << mTotClustersIB;
+  LOG(info) << "Number of OB clusters: " << mTotClustersOB;
+
+  groupRareTopologiesImpl(mTopologyFrequencyIB, mMapInfoIB, mTopologyMapIB, mNCommonTopologiesIB, mFrequencyThresholdIB, mDictionary.mDataIB, mNCommonTopologiesIB);
+  groupRareTopologiesImpl(mTopologyFrequencyOB, mMapInfoOB, mTopologyMapOB, mNCommonTopologiesOB, mFrequencyThresholdOB, mDictionary.mDataOB, mNCommonTopologiesOB);
+
+  LOG(info) << "Dictionay finalised";
+  LOG(info) << "IB:";
+  mDictionary.mDataIB.print();
+  LOG(info) << "OB:";
+  mDictionary.mDataOB.print();
+}
 
+void BuildTopologyDictionary::groupRareTopologiesImpl(TopoFreq& tfreq, TopoInfo& tinfo, TopoStat& tstat, unsigned int& ncommon, double& freqthres, TopologyDictionaryData& data, unsigned int ntot)
+{
   double totFreq = 0.;
-  for (unsigned int j = 0; j < mNCommonTopologies; j++) {
+  for (unsigned int j = 0; j < ncommon; j++) {
     itsmft::GroupStruct gr;
-    gr.mHash = mTopologyFrequency[j].second;
-    gr.mFrequency = ((double)(mTopologyFrequency[j].first)) / mTotClusters;
+    gr.mHash = tfreq[j].second;
+    gr.mFrequency = ((double)(tfreq[j].first)) / ntot;
     totFreq += gr.mFrequency;
     // rough estimation for the error considering a8 uniform distribution
-    const auto& topo = mMapInfo.find(gr.mHash)->second;
+    const auto& topo = tinfo.find(gr.mHash)->second;
     gr.mErrX = std::sqrt(topo.mXsigma2);
     gr.mErrZ = std::sqrt(topo.mZsigma2);
     gr.mErr2X = topo.mXsigma2;
@@ -169,11 +216,11 @@ void BuildTopologyDictionary::groupRareTopologies()
     gr.mNpixels = topo.mNpixels;
     gr.mPattern = topo.mPattern;
     gr.mIsGroup = false;
-    mDictionary.mVectorOfIDs.push_back(gr);
+    data.mVectorOfIDs.push_back(gr);
     if (j == int(itsmft::CompCluster::InvalidPatternID - 1)) {
       LOGP(warning, "Limiting N unique topologies to {}, threshold freq. to {}, cumulative freq. to {} to be below InvalidPatternID", j, gr.mFrequency, totFreq);
-      mNCommonTopologies = j;
-      mFrequencyThreshold = gr.mFrequency;
+      ncommon = j;
+      freqthres = gr.mFrequency;
       break;
     }
   }
@@ -193,8 +240,8 @@ void BuildTopologyDictionary::groupRareTopologies()
       // Create a structure for a group of rare topologies
       itsmft::GroupStruct gr;
       gr.mHash = (((unsigned long)(grNum)) << 32) & 0xffffffff00000000;
-      gr.mErrX = its3::TopologyDictionary::RowClassSpan / std::sqrt(12 * std::min(10, rowBinEdge));
-      gr.mErrZ = its3::TopologyDictionary::ColClassSpan / std::sqrt(12 * std::min(10, colBinEdge));
+      gr.mErrX = its3::TopologyDictionary::RowClassSpan / std::sqrt(12.f * (float)std::min(10, rowBinEdge));
+      gr.mErrZ = its3::TopologyDictionary::ColClassSpan / std::sqrt(12.f * (float)std::min(10, colBinEdge));
       gr.mErr2X = gr.mErrX * gr.mErrX;
       gr.mErr2Z = gr.mErrZ * gr.mErrZ;
       gr.mXCOG = 0;
@@ -228,58 +275,65 @@ void BuildTopologyDictionary::groupRareTopologies()
   int rs{}, cs{}, index{};
 
   // Updating the counts for the groups of rare topologies
-  for (auto j{mNCommonTopologies}; j < mTopologyFrequency.size(); j++) {
-    unsigned long hash1 = mTopologyFrequency[j].second;
-    rs = mTopologyMap.find(hash1)->second.topology.getRowSpan();
-    cs = mTopologyMap.find(hash1)->second.topology.getColumnSpan();
+  for (auto j{ncommon}; j < tfreq.size(); j++) {
+    unsigned long hash1 = tfreq[j].second;
+    rs = tstat.find(hash1)->second.topology.getRowSpan();
+    cs = tstat.find(hash1)->second.topology.getColumnSpan();
     index = its3::LookUp::groupFinder(rs, cs);
-    tmp_GroupMap[index].second += mTopologyFrequency[j].first;
+    tmp_GroupMap[index].second += tfreq[j].first;
   }
 
   for (auto&& p : tmp_GroupMap) {
     itsmft::GroupStruct& group = p.second.first;
-    group.mFrequency = ((double)p.second.second) / mTotClusters;
-    mDictionary.mVectorOfIDs.push_back(group);
+    group.mFrequency = ((double)p.second.second) / ntot;
+    data.mVectorOfIDs.push_back(group);
   }
 
   // Sorting the dictionary preserving all unique topologies
-  std::sort(mDictionary.mVectorOfIDs.begin(), mDictionary.mVectorOfIDs.end(), [](const itsmft::GroupStruct& a, const itsmft::GroupStruct& b) {
+  std::sort(data.mVectorOfIDs.begin(), data.mVectorOfIDs.end(), [](const itsmft::GroupStruct& a, const itsmft::GroupStruct& b) {
     return (!a.mIsGroup) && b.mIsGroup ? true : (a.mIsGroup && (!b.mIsGroup) ? false : (a.mFrequency > b.mFrequency));
   });
-  if (mDictionary.mVectorOfIDs.size() >= itsmft::CompCluster::InvalidPatternID - 1) {
+  if (data.mVectorOfIDs.size() >= itsmft::CompCluster::InvalidPatternID - 1) {
     LOGP(warning, "Max allowed {} patterns is reached, stopping", itsmft::CompCluster::InvalidPatternID - 1);
-    mDictionary.mVectorOfIDs.resize(itsmft::CompCluster::InvalidPatternID - 1);
+    data.mVectorOfIDs.resize(itsmft::CompCluster::InvalidPatternID - 1);
   }
   // Sorting the dictionary to final form
-  std::sort(mDictionary.mVectorOfIDs.begin(), mDictionary.mVectorOfIDs.end(), [](const itsmft::GroupStruct& a, const itsmft::GroupStruct& b) { return a.mFrequency > b.mFrequency; });
+  std::sort(data.mVectorOfIDs.begin(), data.mVectorOfIDs.end(), [](const itsmft::GroupStruct& a, const itsmft::GroupStruct& b) { return a.mFrequency > b.mFrequency; });
   // Creating the map for common topologies
-  for (int iKey = 0; iKey < mDictionary.getSize(); iKey++) {
-    itsmft::GroupStruct& gr = mDictionary.mVectorOfIDs[iKey];
+  for (int iKey = 0; iKey < data.mVectorOfIDs.size(); iKey++) {
+    itsmft::GroupStruct& gr = data.mVectorOfIDs[iKey];
     if (!gr.mIsGroup) {
-      mDictionary.mCommonMap.emplace(gr.mHash, iKey);
+      data.mCommonMap.emplace(gr.mHash, iKey);
       if (gr.mPattern.getUsedBytes() == 1) {
-        mDictionary.mSmallTopologiesLUT[(gr.mPattern.getColumnSpan() - 1) * 255 + (int)gr.mPattern.getByte(2)] = iKey;
+        data.mSmallTopologiesLUT[(gr.mPattern.getColumnSpan() - 1) * 255 + (int)gr.mPattern.getByte(2)] = iKey;
       }
     } else {
-      mDictionary.mGroupMap.emplace((int)(gr.mHash >> 32) & 0x00000000ffffffff, iKey);
+      data.mGroupMap.emplace((int)(gr.mHash >> 32) & 0x00000000ffffffff, iKey);
     }
   }
-  LOG(info) << "Dictionay finalised";
-  LOG(info) << "Number of keys: " << mDictionary.getSize();
-  LOG(info) << "Number of common topologies: " << mDictionary.mCommonMap.size();
-  LOG(info) << "Number of groups of rare topologies: " << mDictionary.mGroupMap.size();
 }
 
 std::ostream& operator<<(std::ostream& os, const BuildTopologyDictionary& DB)
 {
-  for (unsigned int i = 0; i < DB.mNCommonTopologies; i++) {
-    const unsigned long& hash = DB.mTopologyFrequency[i].second;
+  os << "--- InnerBarrel\n";
+  for (unsigned int i = 0; i < DB.mNCommonTopologiesIB; i++) {
+    const unsigned long& hash = DB.mTopologyFrequencyIB[i].second;
+    os << "Hash: " << hash << '\n';
+    os << "counts: " << DB.mTopologyMapIB.find(hash)->second.countsTotal;
+    os << " (with bias provided: " << DB.mTopologyMapIB.find(hash)->second.countsWithBias << ")" << '\n';
+    os << "sigmaX: " << std::sqrt(DB.mMapInfoIB.find(hash)->second.mXsigma2) << '\n';
+    os << "sigmaZ: " << std::sqrt(DB.mMapInfoIB.find(hash)->second.mZsigma2) << '\n';
+    os << DB.mTopologyMapIB.find(hash)->second.topology;
+  }
+  os << "--- OuterBarrel\n";
+  for (unsigned int i = 0; i < DB.mNCommonTopologiesOB; i++) {
+    const unsigned long& hash = DB.mTopologyFrequencyOB[i].second;
     os << "Hash: " << hash << '\n';
-    os << "counts: " << DB.mTopologyMap.find(hash)->second.countsTotal;
-    os << " (with bias provided: " << DB.mTopologyMap.find(hash)->second.countsWithBias << ")" << '\n';
-    os << "sigmaX: " << std::sqrt(DB.mMapInfo.find(hash)->second.mXsigma2) << '\n';
-    os << "sigmaZ: " << std::sqrt(DB.mMapInfo.find(hash)->second.mZsigma2) << '\n';
-    os << DB.mTopologyMap.find(hash)->second.topology;
+    os << "counts: " << DB.mTopologyMapOB.find(hash)->second.countsTotal;
+    os << " (with bias provided: " << DB.mTopologyMapOB.find(hash)->second.countsWithBias << ")" << '\n';
+    os << "sigmaX: " << std::sqrt(DB.mMapInfoOB.find(hash)->second.mXsigma2) << '\n';
+    os << "sigmaZ: " << std::sqrt(DB.mMapInfoOB.find(hash)->second.mZsigma2) << '\n';
+    os << DB.mTopologyMapOB.find(hash)->second.topology;
   }
   return os;
 }
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/Clusterer.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/Clusterer.cxx
index 90f5245bcef58..bce17b3759340 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/Clusterer.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/Clusterer.cxx
@@ -12,15 +12,14 @@
 /// \file Clusterer.cxx
 /// \brief Implementation of the ITS cluster finder
 
-#include "ITS3Reconstruction/Clusterer.h"
+#include <algorithm>
 
-#include <TTree.h>
-#include "Framework/Logger.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Reconstruction/Clusterer.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "CommonDataFormat/InteractionRecord.h"
 
-#include <algorithm>
+#include "TTree.h"
 
 #ifdef WITH_OPENMP
 #include <omp.h>
@@ -252,7 +251,7 @@ void Clusterer::ClustererThread::finishChip(ChipPixelData* curChipData, CompClus
       preClusterIndices[i2] = -1;
     }
     if (bbox.isAcceptableSize()) {
-      parent->streamCluster(pixArrBuff, &labelsBuff, bbox, parent->mPattIdConverter, compClusPtr, patternsPtr, labelsClusPtr, nlab);
+      parent->streamCluster(pixArrBuff, &labelsBuff, bbox, parent->mPattIdConverter, compClusPtr, patternsPtr, labelsClusPtr, nlab, constants::detID::isDetITS3(curChipData->getChipID()));
     } else {
       auto warnLeft = MaxHugeClusWarn - parent->mNHugeClus;
       if (warnLeft > 0) {
@@ -278,7 +277,7 @@ void Clusterer::ClustererThread::finishChip(ChipPixelData* curChipData, CompClus
             }
           }
           if (!pixbuf.empty()) { // Stream a piece of cluster only if the reduced bounding box is not empty
-            parent->streamCluster(pixbuf, &labelsBuff, bboxT, parent->mPattIdConverter, compClusPtr, patternsPtr, labelsClusPtr, nlab, true);
+            parent->streamCluster(pixbuf, &labelsBuff, bboxT, parent->mPattIdConverter, compClusPtr, patternsPtr, labelsClusPtr, nlab, constants::detID::isDetITS3(curChipData->getChipID()), true);
             pixbuf.clear();
           }
           bboxT.rowMin = bboxT.rowMax + 1;
@@ -305,10 +304,12 @@ void Clusterer::ClustererThread::finishChipSingleHitFast(uint32_t hit, ChipPixel
     }
   }
 
+  auto ib = constants::detID::isDetITS3(curChipData->getChipID());
+
   // add to compact clusters, which must be always filled
   unsigned char patt[ClusterPattern::MaxPatternBytes]{0x1 << (7 - (0 % 8))}; // unrolled 1 hit version of full loop in finishChip
-  uint16_t pattID = (parent->mPattIdConverter.size() == 0) ? CompCluster::InvalidPatternID : parent->mPattIdConverter.findGroupID(1, 1, patt);
-  if ((pattID == CompCluster::InvalidPatternID || parent->mPattIdConverter.isGroup(pattID)) && patternsPtr) {
+  uint16_t pattID = (parent->mPattIdConverter.size(ib) == 0) ? CompCluster::InvalidPatternID : parent->mPattIdConverter.findGroupID(1, 1, ib, patt);
+  if ((pattID == CompCluster::InvalidPatternID || parent->mPattIdConverter.isGroup(pattID, ib)) && patternsPtr) {
     patternsPtr->emplace_back(1); // rowspan
     patternsPtr->emplace_back(1); // colspan
     patternsPtr->insert(patternsPtr->end(), std::begin(patt), std::begin(patt) + 1);
@@ -334,7 +335,7 @@ void Clusterer::ClustererThread::initChip(const ChipPixelData* curChipData, uint
   size = itsmft::SegmentationAlpide::NRows + 2;
   int chipId = curChipData->getChipID();
   if (its3::constants::detID::isDetITS3(chipId)) {
-    size = its3::SegmentationSuperAlpide::mNRows + 2;
+    size = its3::SegmentationMosaix::NRows + 2;
   }
 
   delete[] column1;
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index 50e651f7f5675..58dd56ac41f95 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -16,8 +16,6 @@
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITS3Reconstruction/TopologyDictionary.h"
 #include "ITSBase/GeometryTGeo.h"
-#include "ITSMFTBase/SegmentationAlpide.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
 #include "ITS3Base/SpecsV2.h"
 #include "ITStracking/TrackingConfigParam.h"
 #include "Framework/Logger.h"
@@ -80,7 +78,6 @@ int loadROFrameDataITS3(its::TimeFrame* tf,
       auto isITS3 = its3::constants::detID::isDetITS3(sensorID);
       auto layer = geom->getLayer(sensorID);
 
-      auto pattID = c.getPatternID();
       float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
       uint8_t clusterSize{0};
       auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2, clusterSize);
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/ITS3ReconstructionLinkDef.h b/Detectors/Upgrades/ITS3/reconstruction/src/ITS3ReconstructionLinkDef.h
index f19a7fcaba9ca..2ebd89970d9a1 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/ITS3ReconstructionLinkDef.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/ITS3ReconstructionLinkDef.h
@@ -16,6 +16,7 @@
 #pragma link off all functions;
 
 #pragma link C++ class o2::its3::Clusterer + ;
+#pragma link C++ class o2::its3::TopologyDictionaryData + ;
 #pragma link C++ class o2::its3::TopologyDictionary + ;
 #pragma link C++ class o2::its3::BuildTopologyDictionary + ;
 #pragma link C++ class o2::its3::LookUp + ;
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/LookUp.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/LookUp.cxx
index caabfa6f2decb..e137e091dc631 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/LookUp.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/LookUp.cxx
@@ -31,7 +31,8 @@ LookUp::LookUp(std::string fileName)
 void LookUp::loadDictionary(std::string fileName)
 {
   mDictionary.readFromFile(fileName);
-  mTopologiesOverThreshold = mDictionary.mCommonMap.size();
+  mTopologiesOverThresholdIB = mDictionary.mDataIB.mCommonMap.size();
+  mTopologiesOverThresholdOB = mDictionary.mDataOB.mCommonMap.size();
 }
 
 void LookUp::setDictionary(const its3::TopologyDictionary* dict)
@@ -39,7 +40,8 @@ void LookUp::setDictionary(const its3::TopologyDictionary* dict)
   if (dict != nullptr) {
     mDictionary = *dict;
   }
-  mTopologiesOverThreshold = mDictionary.mCommonMap.size();
+  mTopologiesOverThresholdIB = mDictionary.mDataIB.mCommonMap.size();
+  mTopologiesOverThresholdOB = mDictionary.mDataOB.mCommonMap.size();
 }
 
 int LookUp::groupFinder(int nRow, int nCol)
@@ -61,25 +63,26 @@ int LookUp::groupFinder(int nRow, int nCol)
   return grNum;
 }
 
-int LookUp::findGroupID(int nRow, int nCol, const unsigned char patt[itsmft::ClusterPattern::MaxPatternBytes]) const
+int LookUp::findGroupID(int nRow, int nCol, bool IB, const unsigned char patt[itsmft::ClusterPattern::MaxPatternBytes]) const
 {
+  const auto& data = (IB) ? mDictionary.mDataIB : mDictionary.mDataOB;
   int nBits = nRow * nCol;
   if (nBits < 9) { // Small unique topology
-    int ID = mDictionary.mSmallTopologiesLUT[(nCol - 1) * 255 + (int)patt[0]];
+    int ID = data.mSmallTopologiesLUT[(nCol - 1) * 255 + (int)patt[0]];
     if (ID >= 0) {
       return ID;
     }
   } else { // Big unique topology
     unsigned long hash = itsmft::ClusterTopology::getCompleteHash(nRow, nCol, patt);
-    auto ret = mDictionary.mCommonMap.find(hash);
-    if (ret != mDictionary.mCommonMap.end()) {
+    auto ret = data.mCommonMap.find(hash);
+    if (ret != data.mCommonMap.end()) {
       return ret->second;
     }
   }
-  if (!mDictionary.mGroupMap.empty()) { // rare valid topology group
+  if (!data.mGroupMap.empty()) { // rare valid topology group
     int index = groupFinder(nRow, nCol);
-    auto res = mDictionary.mGroupMap.find(index);
-    return res == mDictionary.mGroupMap.end() ? itsmft::CompCluster::InvalidPatternID : res->second;
+    auto res = data.mGroupMap.find(index);
+    return res == data.mGroupMap.end() ? itsmft::CompCluster::InvalidPatternID : res->second;
   }
   return itsmft::CompCluster::InvalidPatternID;
 }
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
index 66a4b0a6878cd..61ab051ffb565 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
@@ -12,7 +12,7 @@
 /// \file TopologyDictionary.cxx
 
 #include "ITS3Reconstruction/TopologyDictionary.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "CommonUtils/StringUtils.h"
 #include <TFile.h>
@@ -23,9 +23,16 @@ ClassImp(o2::its3::TopologyDictionary);
 namespace o2::its3
 {
 
+void TopologyDictionaryData::print() const noexcept
+{
+  LOG(info) << "Number of keys: " << mVectorOfIDs.size();
+  LOG(info) << "Number of common topologies: " << mCommonMap.size();
+  LOG(info) << "Number of groups of rare topologies: " << mGroupMap.size();
+}
+
 TopologyDictionary::TopologyDictionary()
 {
-  memset(mSmallTopologiesLUT, -1, STopoSize * sizeof(int));
+  reset();
 }
 
 TopologyDictionary::TopologyDictionary(const std::string& fileName)
@@ -33,10 +40,43 @@ TopologyDictionary::TopologyDictionary(const std::string& fileName)
   readFromFile(fileName);
 }
 
+void TopologyDictionary::print() const noexcept
+{
+  LOG(info) << "ITS3 TopologyDictionary";
+  LOG(info) << "InnerBarrel";
+  mDataIB.print();
+  LOG(info) << "OuterBarrel";
+  mDataOB.print();
+}
+
+void TopologyDictionary::reset() noexcept
+{
+  mDataIB.mSmallTopologiesLUT.fill(-1);
+  mDataOB.mSmallTopologiesLUT.fill(-1);
+  mDataIB.mVectorOfIDs.clear();
+  mDataOB.mVectorOfIDs.clear();
+}
+
+void TopologyDictionary::resetMaps(bool IB) noexcept
+{
+  auto& data = (IB) ? mDataIB : mDataOB;
+  data.mCommonMap.clear();
+  data.mGroupMap.clear();
+}
+
 std::ostream& operator<<(std::ostream& os, const its3::TopologyDictionary& dict)
 {
   int ID = 0;
-  for (auto& p : dict.mVectorOfIDs) {
+  os << "--- InnerBarrel:\n";
+  for (auto& p : dict.mDataIB.mVectorOfIDs) {
+    os << "ID: " << ID++ << " Hash: " << p.mHash << " ErrX: " << p.mErrX << " ErrZ : " << p.mErrZ << " xCOG: " << p.mXCOG << " zCOG: " << p.mZCOG << " Npixles: " << p.mNpixels << " Frequency: " << p.mFrequency << " isGroup : " << std::boolalpha << p.mIsGroup << '\n'
+       << p.mPattern << '\n'
+       << "*********************************************************" << '\n'
+       << '\n';
+  }
+  ID = 0;
+  os << "--- OuterBarrel:\n";
+  for (auto& p : dict.mDataOB.mVectorOfIDs) {
     os << "ID: " << ID++ << " Hash: " << p.mHash << " ErrX: " << p.mErrX << " ErrZ : " << p.mErrZ << " xCOG: " << p.mXCOG << " zCOG: " << p.mZCOG << " Npixles: " << p.mNpixels << " Frequency: " << p.mFrequency << " isGroup : " << std::boolalpha << p.mIsGroup << '\n'
        << p.mPattern << '\n'
        << "*********************************************************" << '\n'
@@ -48,24 +88,36 @@ std::ostream& operator<<(std::ostream& os, const its3::TopologyDictionary& dict)
 void TopologyDictionary::writeBinaryFile(const std::string& outputfile)
 {
   std::ofstream file_output(outputfile, std::ios::out | std::ios::binary);
-  for (auto& p : mVectorOfIDs) {
-    file_output.write(reinterpret_cast<char*>(&p.mHash), sizeof(unsigned long));
-    file_output.write(reinterpret_cast<char*>(&p.mErrX), sizeof(float));
-    file_output.write(reinterpret_cast<char*>(&p.mErrZ), sizeof(float));
-    file_output.write(reinterpret_cast<char*>(&p.mErr2X), sizeof(float));
-    file_output.write(reinterpret_cast<char*>(&p.mErr2Z), sizeof(float));
-    file_output.write(reinterpret_cast<char*>(&p.mXCOG), sizeof(float));
-    file_output.write(reinterpret_cast<char*>(&p.mZCOG), sizeof(float));
-    file_output.write(reinterpret_cast<char*>(&p.mNpixels), sizeof(int));
-    file_output.write(reinterpret_cast<char*>(&p.mFrequency), sizeof(double));
-    file_output.write(reinterpret_cast<char*>(&p.mIsGroup), sizeof(bool));
-    file_output.write(const_cast<char*>(reinterpret_cast<const char*>(&p.mPattern.getPattern())),
-                      sizeof(unsigned char) * (itsmft::ClusterPattern::kExtendedPatternBytes));
+  if (!file_output) {
+    throw std::runtime_error(fmt::format("Cannot open output file %s!", outputfile));
   }
+
+  auto writeData = [](auto& file_output, auto& data) {
+    auto size = data.mVectorOfIDs.size();
+    file_output.write(reinterpret_cast<char*>(&size), sizeof(size));
+    for (auto& p : data.mVectorOfIDs) {
+      file_output.write(reinterpret_cast<char*>(&p.mHash), sizeof(unsigned long));
+      file_output.write(reinterpret_cast<char*>(&p.mErrX), sizeof(float));
+      file_output.write(reinterpret_cast<char*>(&p.mErrZ), sizeof(float));
+      file_output.write(reinterpret_cast<char*>(&p.mErr2X), sizeof(float));
+      file_output.write(reinterpret_cast<char*>(&p.mErr2Z), sizeof(float));
+      file_output.write(reinterpret_cast<char*>(&p.mXCOG), sizeof(float));
+      file_output.write(reinterpret_cast<char*>(&p.mZCOG), sizeof(float));
+      file_output.write(reinterpret_cast<char*>(&p.mNpixels), sizeof(int));
+      file_output.write(reinterpret_cast<char*>(&p.mFrequency), sizeof(double));
+      file_output.write(reinterpret_cast<char*>(&p.mIsGroup), sizeof(bool));
+      file_output.write(const_cast<char*>(reinterpret_cast<const char*>(&p.mPattern.getPattern())),
+                        sizeof(unsigned char) * (itsmft::ClusterPattern::kExtendedPatternBytes));
+    }
+  };
+
+  writeData(file_output, mDataIB);
+  writeData(file_output, mDataOB);
+
   file_output.close();
 }
 
-int TopologyDictionary::readFromFile(const std::string& fname)
+void TopologyDictionary::readFromFile(const std::string& fname)
 {
   LOGP(info, "Reading TopologyDictionary from File '{}'", fname);
   if (o2::utils::Str::endsWith(fname, ".root")) {
@@ -76,59 +128,63 @@ int TopologyDictionary::readFromFile(const std::string& fname)
   } else {
     throw std::runtime_error(fmt::format("Unrecognized format {}", fname));
   }
-  return 0;
 }
 
-int TopologyDictionary::readBinaryFile(const std::string& fname)
+void TopologyDictionary::readBinaryFile(const std::string& fname)
 {
-  mVectorOfIDs.clear();
-  mCommonMap.clear();
-  for (auto& p : mSmallTopologiesLUT) {
-    p = -1;
-  }
+  reset();
+
   std::ifstream in(fname.data(), std::ios::in | std::ios::binary);
-  itsmft::GroupStruct gr;
-  int groupID = 0;
   if (!in.is_open()) {
     LOG(error) << "The file " << fname << " coud not be opened";
     throw std::runtime_error("The file coud not be opened");
   } else {
-    while (in.read(reinterpret_cast<char*>(&gr.mHash), sizeof(unsigned long))) {
-      in.read(reinterpret_cast<char*>(&gr.mErrX), sizeof(float));
-      in.read(reinterpret_cast<char*>(&gr.mErrZ), sizeof(float));
-      in.read(reinterpret_cast<char*>(&gr.mErr2X), sizeof(float));
-      in.read(reinterpret_cast<char*>(&gr.mErr2Z), sizeof(float));
-      in.read(reinterpret_cast<char*>(&gr.mXCOG), sizeof(float));
-      in.read(reinterpret_cast<char*>(&gr.mZCOG), sizeof(float));
-      in.read(reinterpret_cast<char*>(&gr.mNpixels), sizeof(int));
-      in.read(reinterpret_cast<char*>(&gr.mFrequency), sizeof(double));
-      in.read(reinterpret_cast<char*>(&gr.mIsGroup), sizeof(bool));
-      in.read(const_cast<char*>(reinterpret_cast<const char*>(&gr.mPattern.getPattern())), sizeof(unsigned char) * (itsmft::ClusterPattern::kExtendedPatternBytes));
-      mVectorOfIDs.push_back(gr);
-      if (!gr.mIsGroup) {
-        mCommonMap.insert(std::make_pair(gr.mHash, groupID));
-        if (gr.mPattern.getUsedBytes() == 1) {
-          mSmallTopologiesLUT[(gr.mPattern.getColumnSpan() - 1) * 255 + (int)gr.mPattern.getByte(2)] = groupID;
+
+    auto readData = [](auto& in, auto& data) {
+      int groupID = 0;
+      std::size_t size{}, cur{};
+      itsmft::GroupStruct gr;
+      in.read(reinterpret_cast<char*>(&size), sizeof(std::size_t));
+      while (cur++ != size) {
+        in.read(reinterpret_cast<char*>(&gr.mHash), sizeof(unsigned long));
+        in.read(reinterpret_cast<char*>(&gr.mErrX), sizeof(float));
+        in.read(reinterpret_cast<char*>(&gr.mErrZ), sizeof(float));
+        in.read(reinterpret_cast<char*>(&gr.mErr2X), sizeof(float));
+        in.read(reinterpret_cast<char*>(&gr.mErr2Z), sizeof(float));
+        in.read(reinterpret_cast<char*>(&gr.mXCOG), sizeof(float));
+        in.read(reinterpret_cast<char*>(&gr.mZCOG), sizeof(float));
+        in.read(reinterpret_cast<char*>(&gr.mNpixels), sizeof(int));
+        in.read(reinterpret_cast<char*>(&gr.mFrequency), sizeof(double));
+        in.read(reinterpret_cast<char*>(&gr.mIsGroup), sizeof(bool));
+        in.read(const_cast<char*>(reinterpret_cast<const char*>(&gr.mPattern.getPattern())), sizeof(unsigned char) * (itsmft::ClusterPattern::kExtendedPatternBytes));
+        data.mVectorOfIDs.push_back(gr);
+        if (!gr.mIsGroup) {
+          data.mCommonMap.insert(std::make_pair(gr.mHash, groupID));
+          if (gr.mPattern.getUsedBytes() == 1) {
+            data.mSmallTopologiesLUT[(gr.mPattern.getColumnSpan() - 1) * 255 + (int)gr.mPattern.getByte(2)] = groupID;
+          }
+        } else {
+          data.mGroupMap.insert(std::make_pair((int)(gr.mHash >> 32) & 0x00000000ffffffff, groupID));
         }
-      } else {
-        mGroupMap.insert(std::make_pair((int)(gr.mHash >> 32) & 0x00000000ffffffff, groupID));
+        groupID++;
       }
-      groupID++;
-    }
+    };
+
+    readData(in, mDataIB);
+    readData(in, mDataOB);
   }
   in.close();
-  return 0;
 }
 
-TH1F* TopologyDictionary::getTopologyDistribution(const std::string_view hname) const
+TH1F* TopologyDictionary::getTopologyDistribution(const std::string_view hname, bool IB) const
 {
-  int dictSize = getSize();
-  auto* histo = new TH1F(hname.data(), ";Topology ID;Frequency", dictSize, -0.5, dictSize - 0.5);
+  int dictSize = getSize(IB);
+  auto* histo = new TH1F(hname.data(), Form("%s;Topology ID;Frequency", (IB) ? "InnerBarrel" : "OuterBarrel"), dictSize, -0.5, dictSize - 0.5);
   histo->SetFillColor(kRed);
   histo->SetFillStyle(3005);
   histo->SetDrawOption("histo");
   for (int i = 0; i < dictSize; i++) {
-    histo->Fill(i, getFrequency(i));
+    histo->Fill(i, getFrequency(i, IB));
   }
   return histo;
 }
@@ -136,18 +192,19 @@ TH1F* TopologyDictionary::getTopologyDistribution(const std::string_view hname)
 template <typename T>
 math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::CompClusterExt& cl) const
 {
+  static std::array<o2::its3::SegmentationMosaix, 3> mIBSegmentations{0, 1, 2};
   math_utils::Point3D<T> locCl;
   if (!its3::constants::detID::isDetITS3(cl.getSensorID())) {
     o2::itsmft::SegmentationAlpide::detectorToLocalUnchecked(cl.getRow(), cl.getCol(), locCl);
-    locCl.SetX(locCl.X() + this->getXCOG(cl.getPatternID()) * itsmft::SegmentationAlpide::PitchRow);
-    locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID()) * itsmft::SegmentationAlpide::PitchCol);
+    locCl.SetX(locCl.X() + this->getXCOG(cl.getPatternID(), false) * itsmft::SegmentationAlpide::PitchRow);
+    locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID(), false) * itsmft::SegmentationAlpide::PitchCol);
   } else {
     auto layer = its3::constants::detID::getDetID2Layer(cl.getSensorID());
-    its3::SuperSegmentations[layer].detectorToLocalUnchecked(cl.getRow(), cl.getCol(), locCl);
-    locCl.SetX(locCl.X() + this->getXCOG(cl.getPatternID()) * its3::SegmentationSuperAlpide::mPitchRow);
-    locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID()) * its3::SegmentationSuperAlpide::mPitchCol);
+    mIBSegmentations[layer].detectorToLocalUnchecked(cl.getRow(), cl.getCol(), locCl);
+    locCl.SetX(locCl.X() + this->getXCOG(cl.getPatternID(), true) * its3::SegmentationMosaix::PitchRow);
+    locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID(), true) * its3::SegmentationMosaix::PitchCol);
     float xCurved{0.f}, yCurved{0.f};
-    its3::SuperSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
+    mIBSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
     locCl.SetXYZ(xCurved, yCurved, locCl.Z());
   }
   return locCl;
@@ -156,6 +213,7 @@ math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::C
 template <typename T>
 math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup)
 {
+  static std::array<o2::its3::SegmentationMosaix, 3> mIBSegmentations{0, 1, 2};
   auto refRow = cl.getRow();
   auto refCol = cl.getCol();
   float xCOG = 0, zCOG = 0;
@@ -169,9 +227,9 @@ math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::C
     o2::itsmft::SegmentationAlpide::detectorToLocalUnchecked(refRow + xCOG, refCol + zCOG, locCl);
   } else {
     auto layer = its3::constants::detID::getDetID2Layer(cl.getSensorID());
-    its3::SuperSegmentations[layer].detectorToLocalUnchecked(refRow + xCOG, refCol + zCOG, locCl);
+    mIBSegmentations[layer].detectorToLocalUnchecked(refRow + xCOG, refCol + zCOG, locCl);
     float xCurved{0.f}, yCurved{0.f};
-    its3::SuperSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
+    mIBSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);
     locCl.SetXYZ(xCurved, yCurved, locCl.Z());
   }
   return locCl;
diff --git a/Detectors/Upgrades/ITS3/simulation/CMakeLists.txt b/Detectors/Upgrades/ITS3/simulation/CMakeLists.txt
index 17a8fd2748b87..2fad72a96426d 100644
--- a/Detectors/Upgrades/ITS3/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/simulation/CMakeLists.txt
@@ -14,6 +14,7 @@ o2_add_library(ITS3Simulation
                        src/ITS3Services.cxx
                        src/DescriptorInnerBarrelITS3.cxx
                        src/Digitizer.cxx
+                       src/DigiParams.cxx
                PUBLIC_LINK_LIBRARIES O2::SimulationDataFormat
                                      O2::ITSBase O2::ITSMFTSimulation
                                      ROOT::Physics)
@@ -23,6 +24,7 @@ o2_target_root_dictionary(ITS3Simulation
                                   include/ITS3Simulation/ITS3Services.h
                                   include/ITS3Simulation/DescriptorInnerBarrelITS3.h
                                   include/ITS3Simulation/Digitizer.h
+                                  include/ITS3Simulation/DigiParams.h
                                   )
 
-o2_data_file(COPY data  DESTINATION Detectors/ITS3/simulation)
\ No newline at end of file
+o2_data_file(COPY data  DESTINATION Detectors/ITS3/simulation)
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
index 80536a14d99c2..d1b54f81face4 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
@@ -45,9 +45,9 @@ class DescriptorInnerBarrelITS3 : public o2::its::DescriptorInnerBarrel
   int mNumLayers{constants::nLayers};
 
   // wrapper volume properties
-  double mWrapperMinRadiusITS3{1.8};
-  double mWrapperMaxRadiusITS3{4.};
-  double mWrapperZSpanITS3{20.};
+  static constexpr double mWrapperMinRadiusITS3{1.8};
+  static constexpr double mWrapperMaxRadiusITS3{4.};
+  static constexpr double mWrapperZSpanITS3{constants::segment::length + 5.};
 
  private:
   std::array<std::unique_ptr<ITS3Layer>, constants::nLayers> mIBLayers;
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
new file mode 100644
index 0000000000000..eca0a71949ba7
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
@@ -0,0 +1,45 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ITS3_DIGIPARAMS_H
+#define ITS3_DIGIPARAMS_H
+
+#include "ITSMFTSimulation/DigiParams.h"
+
+namespace o2::its3
+{
+
+class DigiParams final : public o2::itsmft::DigiParams
+{
+ public:
+  const o2::itsmft::AlpideSimResponse* getAlpSimResponse() const = delete;
+  void setAlpSimResponse(const o2::itsmft::AlpideSimResponse* par) = delete;
+
+  const o2::itsmft::AlpideSimResponse* getOBSimResponse() const { return mOBSimResponse; }
+  void setOBSimResponse(const o2::itsmft::AlpideSimResponse* response) { mOBSimResponse = response; }
+
+  const o2::itsmft::AlpideSimResponse* getIBSimResponse() const { return mIBSimResponse; }
+  void setIBSimResponse(const o2::itsmft::AlpideSimResponse* response) { mIBSimResponse = response; }
+
+  bool hasResponseFunctions() const { return mIBSimResponse != nullptr && mOBSimResponse != nullptr; }
+
+  void print() const final;
+
+ private:
+  const o2::itsmft::AlpideSimResponse* mOBSimResponse = nullptr; //!< pointer to external response
+  const o2::itsmft::AlpideSimResponse* mIBSimResponse = nullptr; //!< pointer to external response
+
+  ClassDef(DigiParams, 1);
+};
+
+} // namespace o2::its3
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
index 7ece842b6f61f..8d0f06a27343b 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
@@ -18,15 +18,15 @@
 #include <deque>
 #include <memory>
 
-#include "Rtypes.h"  // for Digitizer::Class
-#include "TObject.h" // for TObject
+#include "Rtypes.h"
+#include "TObject.h"
 
 #include "ITSMFTSimulation/ChipDigitsContainer.h"
 #include "ITSMFTSimulation/AlpideSimResponse.h"
-#include "ITSMFTSimulation/DigiParams.h"
 #include "ITSMFTSimulation/Hit.h"
 #include "ITSBase/GeometryTGeo.h"
-#include "ITS3Base/SegmentationSuperAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
+#include "ITS3Simulation/DigiParams.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "CommonDataFormat/InteractionRecord.h"
@@ -35,6 +35,7 @@
 
 namespace o2::its3
 {
+
 class Digitizer : public TObject
 {
   using ExtraDig = std::vector<itsmft::PreDigitLabelRef>; ///< container for extra contributions to PreDigits
@@ -44,8 +45,8 @@ class Digitizer : public TObject
   void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
   void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
 
-  o2::itsmft::DigiParams& getParams() { return (o2::itsmft::DigiParams&)mParams; }
-  const o2::itsmft::DigiParams& getParams() const { return mParams; }
+  o2::its3::DigiParams& getParams() { return mParams; }
+  const o2::its3::DigiParams& getParams() const { return mParams; }
 
   void init();
 
@@ -62,9 +63,6 @@ class Digitizer : public TObject
   bool isContinuous() const { return mParams.isContinuous(); }
   void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
 
-  void setDigiParams(const o2::itsmft::DigiParams& par) { mParams = par; }
-  const o2::itsmft::DigiParams& getDigitParams() const { return mParams; }
-
   // provide the common itsmft::GeometryTGeo to access matrices and segmentation
   void setGeometry(const o2::its::GeometryTGeo* gm) { mGeometry = gm; }
 
@@ -97,7 +95,7 @@ class Digitizer : public TObject
 
   static constexpr float sec2ns = 1e9;
 
-  o2::itsmft::DigiParams mParams;          ///< digitization parameters
+  o2::its3::DigiParams mParams;            ///< digitization parameters
   o2::InteractionTimeRecord mEventTime;    ///< global event time and interaction record
   o2::InteractionRecord mIRFirstSampledTF; ///< IR of the 1st sampled IR, noise-only ROFs will be inserted till this IR only
   double mCollisionTimeWrtROF{};
@@ -108,7 +106,15 @@ class Digitizer : public TObject
   uint32_t mEventROFrameMin = 0xffffffff; ///< lowest RO frame for processed events (w/o automatic noise ROFs)
   uint32_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)
 
-  o2::itsmft::AlpideSimResponse* mAlpSimResp = nullptr; // simulated response
+  static constexpr std::array<o2::its3::SegmentationMosaix, 3> mIBSegmentations{0, 1, 2};
+
+  o2::itsmft::AlpideSimResponse* mSimRespIB = nullptr; // simulated response for IB
+  o2::itsmft::AlpideSimResponse* mSimRespOB = nullptr; // simulated response for OB
+  bool mSimRespIBOrientation{false};                   // wether the orientation in the IB response function is flipped
+  float mSimRespIBShift{0.f};                          // adjusting the Y-shift in the IB response function to match sensor local coord.
+  float mSimRespIBScaleX{1.f};                         // scale x-local coordinate to response function x-coordinate
+  float mSimRespIBScaleZ{1.f};                         // scale z-local coordinate to response function z-coordinate
+  float mSimRespOBShift{0.f};                          // adjusting the Y-shift in the OB response function to match sensor local coord.
 
   const o2::its::GeometryTGeo* mGeometry = nullptr; ///< ITS3 geometry
 
@@ -121,8 +127,9 @@ class Digitizer : public TObject
 
   const o2::itsmft::NoiseMap* mDeadChanMap = nullptr;
 
-  ClassDef(Digitizer, 4);
+  ClassDef(Digitizer, 5);
 };
+
 } // namespace o2::its3
 
 #endif /* ALICEO2_ITS3_DIGITIZER_H */
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h
index 7543650e04a71..fd9195f9ee228 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h
@@ -20,13 +20,12 @@
 #include <TGeoTube.h>
 #include <TGeoVolume.h>
 
-#include "Framework/Logger.h"
-#include <fmt/core.h>
+#include "ITS3Base/SpecsV2.h"
 
 namespace o2::its3
 {
 
-/// This class defines the Geometry for the ITS3  using TGeo.
+/// This class defines the geometry for the ITS3 IB layers.
 class ITS3Layer
 {
   // The hierarchy will be the following:
@@ -45,8 +44,8 @@ class ITS3Layer
     kTile,
     kRSU,
     kSegment,
-    kCarbonForm,
     kChip,
+    kCarbonForm,
     kLayer,
     kAll,
   };
@@ -56,11 +55,10 @@ class ITS3Layer
     return mNames[static_cast<size_t>((b == BuildLevel::kAll) ? BuildLevel::kLayer : b)];
   }
 
-  explicit ITS3Layer(int layer = 0) : mNLayer(layer)
-  {
-    LOGP(debug, "Called on {} layer {}", layer, mNLayer);
-    init();
-  }
+  explicit ITS3Layer(int layer = 0) : mNLayer(layer),
+                                      mR(o2::its3::constants::radii[mNLayer]),
+                                      mRmin(o2::its3::constants::radiiInner[mNLayer]),
+                                      mRmax(o2::its3::constants::radiiOuter[mNLayer]) {}
 
   explicit ITS3Layer(TGeoVolume* motherVolume, int layer = 0) : ITS3Layer(layer)
   {
@@ -82,6 +80,7 @@ class ITS3Layer
   TGeoMedium* mSilicon{nullptr};
   TGeoMedium* mAir{nullptr};
   TGeoMedium* mCarbon{nullptr};
+  TGeoMedium* mCopper{nullptr};
   void getMaterials(bool create = false);
   TGeoMedium* getMaterial(const char* matName, bool create = false);
 
@@ -97,10 +96,12 @@ class ITS3Layer
 
   uint8_t mNLayer{0}; // Layer number
   double mR{0};       // Middle Radius
-  double mRmin{};     // Minimum Radius
+  double mRmin{0};    // Minimum Radius
   double mRmax{0};    // Maximum Radius
 
-  // Individual Pieces
+  // Individual pieces
+  // since TGeo manages the resources itself one should not use these pointers
+  // after initializition anymore!
   TGeoVolume* mPixelArray{nullptr};
   TGeoVolumeAssembly* mTile{nullptr};
   TGeoVolumeAssembly* mRSU{nullptr};
@@ -109,7 +110,7 @@ class ITS3Layer
   TGeoVolumeAssembly* mCarbonForm{nullptr};
   TGeoVolumeAssembly* mLayer{nullptr};
 
-  ClassDef(ITS3Layer, 2);
+  ClassDef(ITS3Layer, 3);
 };
 } // namespace o2::its3
 
diff --git a/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx b/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
index 6d1bc621b5287..540e1d41f1c62 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
@@ -18,14 +18,14 @@ ClassImp(DescriptorInnerBarrelITS3);
 
 void DescriptorInnerBarrelITS3::createLayer(int iLayer, TGeoVolume* dest)
 {
-  LOGP(info, "ITS3-IB: Creating Layer {}", iLayer);
+  LOGP(debug, "ITS3-IB: Creating Layer {}", iLayer);
   mIBLayers[iLayer] = std::make_unique<ITS3Layer>(iLayer);
   mIBLayers[iLayer]->createLayer(dest);
 }
 
 void DescriptorInnerBarrelITS3::createServices(TGeoVolume* dest)
 {
-  LOGP(info, "ITS3-IB: Creating Services");
+  LOGP(debug, "ITS3-IB: Creating Services");
   mServices = std::make_unique<ITS3Services>();
   mServices->createCYSSAssembly(dest);
 }
diff --git a/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx b/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx
new file mode 100644
index 0000000000000..a9f17a544b3c4
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx
@@ -0,0 +1,40 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DigiParams.cxx
+/// \brief Implementation of the ITS3 digitization steering params
+
+#include "Framework/Logger.h"
+#include "ITS3Simulation/DigiParams.h"
+
+ClassImp(o2::its3::DigiParams);
+
+namespace o2::its3
+{
+
+void DigiParams::print() const
+{
+  // print settings
+  LOGF(info, "ITS3 DigiParams settings:");
+  LOGF(info, "Continuous readout             : %s", isContinuous() ? "ON" : "OFF");
+  LOGF(info, "Readout Frame Length(ns)       : %f", getROFrameLength());
+  LOGF(info, "Strobe delay (ns)              : %f", getStrobeDelay());
+  LOGF(info, "Strobe length (ns)             : %f", getStrobeLength());
+  LOGF(info, "Threshold (N electrons)        : %d", getChargeThreshold());
+  LOGF(info, "Min N electrons to account     : %d", getMinChargeToAccount());
+  LOGF(info, "Number of charge sharing steps : %d", getNSimSteps());
+  LOGF(info, "ELoss to N electrons factor    : %e", getEnergyToNElectrons());
+  LOGF(info, "Noise level per pixel          : %e", getNoisePerPixel());
+  LOGF(info, "Charge time-response:\n");
+  getSignalShape().print();
+}
+
+} // namespace o2::its3
diff --git a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
index f1519c1d04063..3c75bf3e8f680 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
@@ -14,6 +14,7 @@
 
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "ITS3Simulation/Digitizer.h"
+#include "ITS3Base/ITS3Params.h"
 #include "MathUtils/Cartesian.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "DetectorsRaw/HBFUtils.h"
@@ -21,12 +22,12 @@
 #include "Framework/Logger.h"
 
 #include <TRandom.h>
+#include <algorithm>
 #include <vector>
 #include <numeric>
 
 using o2::itsmft::Hit;
-using Segmentation = o2::itsmft::SegmentationAlpide;
-using SuperSegmentation = o2::its3::SegmentationSuperAlpide;
+using SegmentationAlpide = o2::itsmft::SegmentationAlpide;
 using o2::itsmft::AlpideRespSimMat;
 using o2::itsmft::PreDigit;
 
@@ -44,14 +45,44 @@ void Digitizer::init()
     }
   }
 
-  if (mParams.getAlpSimResponse() == nullptr) {
-    std::string responseFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
-    LOGP(info, "Loading AlpideSimRespnse from file: {}", responseFile);
-    auto file = TFile::Open(responseFile.data());
-    mAlpSimResp = (o2::itsmft::AlpideSimResponse*)file->Get("response0"); // We use by default the alpide response for Vbb=0V
-    mParams.setAlpSimResponse(mAlpSimResp);
+  if (!mParams.hasResponseFunctions()) {
+    auto loadSetResponseFunc = [&](const char* name, const char* fileIB, const char* nameIB, const char* fileOB, const char* nameOB) {
+      LOGP(info, "Loading response function for {}: IB={}:{} ; OB={}:{}", name, nameIB, fileIB, nameOB, fileOB);
+      auto fIB = TFile::Open(fileIB, "READ");
+      if (!fIB || fIB->IsZombie() || !fIB->IsOpen()) {
+        LOGP(fatal, "Cannot open file {}", fileIB);
+      }
+      auto fOB = TFile::Open(fileOB, "READ");
+      if (!fOB || fOB->IsZombie() || !fOB->IsOpen()) {
+        LOGP(fatal, "Cannot open file {}", fileOB);
+      }
+      mParams.setIBSimResponse(mSimRespIB = fIB->Get<o2::itsmft::AlpideSimResponse>(nameIB));
+      mParams.setOBSimResponse(mSimRespOB = fOB->Get<o2::itsmft::AlpideSimResponse>(nameOB));
+      fIB->Close();
+      fOB->Close();
+    };
+
+    if (const auto& func = ITS3Params::Instance().chipResponseFunction; func == "Alpide") {
+      constexpr const char* responseFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
+      loadSetResponseFunc("Alpide", responseFile, "response0", responseFile, "response1");
+      mSimRespIBShift = mSimRespIB->getDepthMax() - SegmentationMosaix::SensorLayerThickness / 2.f + 10.e-4f;
+      mSimRespOBShift = mSimRespOB->getDepthMax() - SegmentationAlpide::SensorLayerThickness / 2.f;
+    } else if (func == "APTS") {
+      constexpr const char* responseFileIB = "$(O2_ROOT)/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/APTSResponseData.root";
+      constexpr const char* responseFileOB = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
+      loadSetResponseFunc("APTS", responseFileIB, "response1", responseFileOB, "response1");
+      mSimRespIBShift = mSimRespIB->getDepthMax() + (float)constants::pixelarray::pixels::apts::responseYShift;
+      mSimRespOBShift = mSimRespOB->getDepthMax() - SegmentationAlpide::SensorLayerThickness / 2.f;
+      mSimRespIBScaleX = 0.5f * constants::pixelarray::pixels::apts::pitchX / SegmentationMosaix::PitchRow;
+      mSimRespIBScaleZ = 0.5f * constants::pixelarray::pixels::apts::pitchZ / SegmentationMosaix::PitchCol;
+      mSimRespIBOrientation = true;
+    } else {
+      LOGP(fatal, "ResponseFunction '{}' not implemented!", func);
+    }
   }
   mParams.print();
+  LOGP(info, "IBShift = {} ; OBShift = {}", mSimRespIBShift, mSimRespOBShift);
+  LOGP(info, "IB-Scale: X={} ; Z={}", mSimRespIBScaleX, mSimRespIBScaleZ);
   mIRFirstSampledTF = o2::raw::HBFUtils::Instance().getFirstSampledTFIR();
 }
 
@@ -143,7 +174,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
     for (size_t iChip{0}; iChip < mChips.size(); ++iChip) {
       auto& chip = mChips[iChip];
       if (constants::detID::isDetITS3(iChip)) { // Check if this is a chip of ITS3
-        chip.addNoise(mROFrameMin, mROFrameMin, &mParams, SuperSegmentation::mNRows, SuperSegmentation::mNCols);
+        chip.addNoise(mROFrameMin, mROFrameMin, &mParams, SegmentationMosaix::NRows, SegmentationMosaix::NCols);
       } else {
         chip.addNoise(mROFrameMin, mROFrameMin, &mParams);
       }
@@ -238,8 +269,8 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   if (innerBarrel) {
     // transform the point on the curved surface to a flat one
     float xFlatE{0.f}, yFlatE{0.f}, xFlatS{0.f}, yFlatS{0.f};
-    SuperSegmentations[layer].curvedToFlat(xyzLocS.X(), xyzLocS.Y(), xFlatS, yFlatS);
-    SuperSegmentations[layer].curvedToFlat(xyzLocE.X(), xyzLocE.Y(), xFlatE, yFlatE);
+    mIBSegmentations[layer].curvedToFlat(xyzLocS.X(), xyzLocS.Y(), xFlatS, yFlatS);
+    mIBSegmentations[layer].curvedToFlat(xyzLocE.X(), xyzLocE.Y(), xFlatE, yFlatE);
     // update the local coordinates with the flattened ones
     xyzLocS.SetXYZ(xFlatS, yFlatS, xyzLocS.Z());
     xyzLocE.SetXYZ(xFlatE, yFlatE, xyzLocE.Z());
@@ -255,14 +286,14 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   int rowS = -1, colS = -1, rowE = -1, colE = -1, nSkip = 0;
   if (innerBarrel) {
     // get entrance pixel row and col
-    while (!SuperSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
+    while (!mIBSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
       if (++nSkip >= nSteps) {
         return; // did not enter to sensitive matrix
       }
       xyzLocS += step;
     }
     // get exit pixel row and col
-    while (!SuperSegmentations[layer].localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
+    while (!mIBSegmentations[layer].localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
       if (++nSkip >= nSteps) {
         return; // did not enter to sensitive matrix
       }
@@ -270,14 +301,14 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
     }
   } else {
     // get entrance pixel row and col
-    while (!Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
+    while (!SegmentationAlpide::localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
       if (++nSkip >= nSteps) {
         return; // did not enter to sensitive matrix
       }
       xyzLocS += step;
     }
     // get exit pixel row and col
-    while (!Segmentation::localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
+    while (!SegmentationAlpide::localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
       if (++nSkip >= nSteps) {
         return; // did not enter to sensitive matrix
       }
@@ -294,23 +325,17 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   }
   rowS -= AlpideRespSimMat::NPix / 2;
   rowE += AlpideRespSimMat::NPix / 2;
-  if (rowS < 0) {
-    rowS = 0;
-  }
+  rowS = std::max(rowS, 0);
 
-  int maxNrows{innerBarrel ? SuperSegmentation::mNRows : Segmentation::NRows};
-  int maxNcols{innerBarrel ? SuperSegmentation::mNCols : Segmentation::NCols};
-  if (rowE >= maxNrows) {
-    rowE = maxNrows - 1;
-  }
+  const int maxNrows{innerBarrel ? SegmentationMosaix::NRows : SegmentationAlpide::NRows};
+  const int maxNcols{innerBarrel ? SegmentationMosaix::NCols : SegmentationAlpide::NCols};
+
+  rowE = std::min(rowE, maxNrows - 1);
   colS -= AlpideRespSimMat::NPix / 2;
   colE += AlpideRespSimMat::NPix / 2;
-  if (colS < 0) {
-    colS = 0;
-  }
-  if (colE >= maxNcols) {
-    colE = maxNcols - 1;
-  }
+  colS = std::max(colS, 0);
+  colE = std::min(colE, maxNcols - 1);
+
   int rowSpan = rowE - rowS + 1, colSpan = colE - colS + 1; // size of plaquet where some response is expected
   float respMatrix[rowSpan][colSpan];                       // response accumulated here
   std::fill(&respMatrix[0][0], &respMatrix[0][0] + rowSpan * colSpan, 0.f);
@@ -327,22 +352,22 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   // take into account that the AlpideSimResponse depth defintion has different min/max boundaries
   // although the max should coincide with the surface of the epitaxial layer, which in the chip
   // local coordinates has Y = +SensorLayerThickness/2
-  float thickness = innerBarrel ? SuperSegmentation::mSensorLayerThickness : Segmentation::SensorLayerThickness;
-  xyzLocS.SetY(xyzLocS.Y() + mAlpSimResp->getDepthMax() - thickness / 2.);
+  xyzLocS.SetY(xyzLocS.Y() + ((innerBarrel) ? mSimRespIBShift : mSimRespOBShift));
+
   // collect charge in evey pixel which might be affected by the hit
   for (int iStep = nSteps; iStep--;) {
     // Get the pixel ID
     if (innerBarrel) {
-      SuperSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
+      mIBSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
     } else {
-      Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
+      SegmentationAlpide::localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
     }
     if (row != rowPrev || col != colPrev) { // update pixel and coordinates of its center
       if (innerBarrel) {
-        if (!SuperSegmentations[layer].detectorToLocal(row, col, cRowPix, cColPix)) {
+        if (!mIBSegmentations[layer].detectorToLocal(row, col, cRowPix, cColPix)) {
           continue;
         }
-      } else if (!Segmentation::detectorToLocal(row, col, cRowPix, cColPix)) {
+      } else if (!SegmentationAlpide::detectorToLocal(row, col, cRowPix, cColPix)) {
         continue; // should not happen
       }
       rowPrev = row;
@@ -350,9 +375,17 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
     }
     bool flipCol = false, flipRow = false;
     // note that response needs coordinates along column row (locX) (locZ) then depth (locY)
-    double rowMax{0.5f * (innerBarrel ? SuperSegmentation::mPitchRow : Segmentation::PitchRow)};
-    double colMax{0.5f * (innerBarrel ? SuperSegmentation::mPitchCol : Segmentation::PitchCol)};
-    auto rspmat = mAlpSimResp->getResponse(xyzLocS.X() - cRowPix, xyzLocS.Z() - cColPix, xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
+    float rowMax{}, colMax{};
+    const AlpideRespSimMat* rspmat{nullptr};
+    if (innerBarrel) {
+      rowMax = 0.5f * SegmentationMosaix::PitchRow;
+      colMax = 0.5f * SegmentationMosaix::PitchCol;
+      rspmat = mSimRespIB->getResponse(mSimRespIBScaleX * (xyzLocS.X() - cRowPix), mSimRespIBScaleZ * (xyzLocS.Z() - cColPix), xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
+    } else {
+      rowMax = 0.5f * SegmentationAlpide::PitchRow;
+      colMax = 0.5f * SegmentationAlpide::PitchCol;
+      rspmat = mSimRespOB->getResponse(xyzLocS.X() - cRowPix, xyzLocS.Z() - cColPix, xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
+    }
 
     xyzLocS += step;
     if (rspmat == nullptr) {
@@ -369,7 +402,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
         if (colDest < 0 || colDest >= colSpan) {
           continue;
         }
-        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, flipRow, flipCol);
+        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, ((innerBarrel && mSimRespIBOrientation) ? !flipRow : flipRow), flipCol);
       }
     }
   }
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx b/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
index 26e47e03057c2..8dc94e339c793 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
@@ -18,11 +18,11 @@
 #include "TGeoVolume.h"
 #include "TGeoCompositeShape.h"
 
+#include "Framework/Logger.h"
 #include "CommonConstants/MathConstants.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITS3Base/SpecsV2.h"
 #include "ITS3Simulation/ITS3Layer.h"
-#include "fairlogger/Logger.h"
 
 namespace o2m = o2::constants::math;
 namespace its3c = o2::its3::constants;
@@ -31,13 +31,6 @@ namespace o2::its3
 {
 using its3TGeo = o2::its::GeometryTGeo;
 
-void ITS3Layer::init()
-{
-  mR = its3c::radii[mNLayer];
-  mRmin = its3c::radiiInner[mNLayer];
-  mRmax = its3c::radiiOuter[mNLayer];
-}
-
 void ITS3Layer::getMaterials(bool create)
 {
   if (gGeoManager == nullptr) {
@@ -47,6 +40,7 @@ void ITS3Layer::getMaterials(bool create)
   mSilicon = getMaterial("IT3_SI$", create);
   mAir = getMaterial("IT3_AIR$", create);
   mCarbon = getMaterial("IT3_CARBON$", create);
+  mCopper = getMaterial("IT3_COPPER$", create);
 }
 
 TGeoMedium* ITS3Layer::getMaterial(const char* matName, bool create)
@@ -58,11 +52,11 @@ TGeoMedium* ITS3Layer::getMaterial(const char* matName, bool create)
     } else { // create dummy
       auto matDummy = gGeoManager->GetMaterial("MAT_DUMMY$");
       if (matDummy == nullptr) {
-        LOGP(info, "Created Dummy material");
+        LOGP(warn, "Created Dummy material");
         matDummy = new TGeoMaterial("MAT_DUMMY$", 26.98, 13, 2.7);
       }
       mat = new TGeoMedium(matName, 1, matDummy);
-      LOGP(info, "Created medium {}", matName);
+      LOGP(warn, "Created medium {}", matName);
     }
   }
   return mat;
@@ -75,12 +69,10 @@ void ITS3Layer::createLayer(TGeoVolume* motherVolume)
   createLayerImpl();
   mBuilt = true;
 
-  LOGP(info, "ITS3-Layer: Created Layer {} with mR={} (minR={}, maxR={})", mNLayer, mR, mRmin, mRmax);
   if (motherVolume == nullptr) {
     return;
   }
   // Add it to motherVolume
-  LOGP(debug, "  `-> Attaching to motherVolume '{}'", motherVolume->GetName());
   auto* trans = new TGeoTranslation(0, 0, -constants::segment::lengthSensitive / 2.);
   motherVolume->AddNode(mLayer, 0, trans);
 }
@@ -91,15 +83,9 @@ void ITS3Layer::createPixelArray()
     return;
   }
   // A pixel array is pure silicon and the sensitive part of our detector.
-  // It will be segmented into a 442x156 matrix by the
-  // SuperSegmentationAlpide.
-  // Pixel Array is just a longer version of the biasing but starts in phi at
-  // biasPhi2.
   using namespace its3c::pixelarray;
-  double pixelArrayPhi1 = constants::tile::readout::width / mR * o2m::Rad2Deg;
-  double pixelArrayPhi2 = width / mR * o2m::Rad2Deg + pixelArrayPhi1;
-  auto pixelArray = new TGeoTubeSeg(mRmin, mRmax, length / 2.,
-                                    pixelArrayPhi1, pixelArrayPhi2);
+  double pixelArrayPhi = width / mR * o2m::Rad2Deg;
+  auto pixelArray = new TGeoTubeSeg(mRmin, mRmax, length / 2., 0, pixelArrayPhi);
   mPixelArray = new TGeoVolume(its3TGeo::getITS3PixelArrayPattern(mNLayer), pixelArray, mSilicon);
   mPixelArray->SetLineColor(color);
   mPixelArray->RegisterYourself();
@@ -131,8 +117,9 @@ void ITS3Layer::createTile()
   mTile->AddNode(readoutVol, 0, zMoveReadout);
 
   // Pixel Array is just a longer version of the biasing but starts in phi at
-  // biasPhi2.
-  mTile->AddNode(mPixelArray, 0);
+  // readoutPhi2.
+  auto phiRotPixelArray = new TGeoRotation(Form("its3PhiPixelArrayOffset_%d", mNLayer), readoutPhi2, 0, 0);
+  mTile->AddNode(mPixelArray, 0, phiRotPixelArray);
 
   // Biasing
   double biasPhi1 = constants::pixelarray::width / mR * o2m::Rad2Deg + readoutPhi2;
@@ -199,7 +186,7 @@ void ITS3Layer::createRSU()
 
   // Rotation for top half and vertical mirroring
   double phi = width / mR * o2m::Rad2Deg;
-  auto rot = new TGeoRotation("", 0, 0, -phi);
+  auto rot = new TGeoRotation(Form("its3RotHalfBarrel_%d", mNLayer), 0, 0, -phi);
   rot->ReflectY(true);
 
   // Upper Left
@@ -276,11 +263,19 @@ void ITS3Layer::createChip()
   mChip = new TGeoVolumeAssembly(its3TGeo::getITS3ChipPattern(mNLayer));
   mChip->VisibleDaughters();
 
+  auto phiOffset = constants::segment::width / mR * o2m::Rad2Deg;
   for (unsigned int i{0}; i < constants::nSegments[mNLayer]; ++i) {
-    double phiOffset = constants::segment::width / mR * o2m::Rad2Deg;
-    auto rot = new TGeoRotation("", 0, 0, phiOffset * i);
+    auto rot = new TGeoRotation(Form("its3PhiSegmentOffset_%d_%d", mNLayer, i), 0, 0, phiOffset * i);
     mChip->AddNode(mSegment, i, rot);
   }
+
+  // Add metal stack positioned radially outward
+  auto zMoveMetal = new TGeoTranslation(0, 0, constants::metalstack::length / 2. - constants::segment::lec::length);
+  auto metal = new TGeoTubeSeg(mRmax, mRmax + constants::metalstack::thickness, constants::metalstack::length / 2., 0, constants::nSegments[mNLayer] * phiOffset);
+  auto metalVol = new TGeoVolume(Form("metal%d", mNLayer), metal, mCopper);
+  metalVol->SetLineColor(constants::metalstack::color);
+  metalVol->RegisterYourself();
+  mChip->AddNode(metalVol, 0, zMoveMetal);
 }
 
 void ITS3Layer::createCarbonForm()
@@ -296,7 +291,7 @@ void ITS3Layer::createCarbonForm()
   mCarbonForm->VisibleDaughters();
   double dRadius = -1;
   if (mNLayer < 2) {
-    dRadius = constants::radii[mNLayer + 1] - constants::radii[mNLayer] - constants::thickness;
+    dRadius = constants::radii[mNLayer + 1] - constants::radii[mNLayer] - constants::totalThickness;
   } else {
     dRadius = 0.7; // TODO: lack of carbon foam radius for layer 2, use 0.7mm as a temporary value
   }
@@ -372,8 +367,8 @@ void ITS3Layer::createLayerImpl()
   // The offset is the right angle triangle of the middle radius with the
   // transverse axis.
   double phiOffset = std::asin(constants::equatorialGap / 2. / mR) * o2m::Rad2Deg;
-  auto rotTop = new TGeoRotation("", 0, 0, +phiOffset);
-  auto rotBot = new TGeoRotation("", 0, 0, phiOffset + 180);
+  auto rotTop = new TGeoRotation(Form("its3CarbonPhiOffsetTop_%d", mNLayer), 0, 0, +phiOffset);
+  auto rotBot = new TGeoRotation(Form("its3CarbonPhiOffsetBot_%d", mNLayer), 0, 0, phiOffset + 180);
 
   mLayer->AddNode(mCarbonForm, 0, rotTop);
   mLayer->AddNode(mCarbonForm, 1, rotBot);
@@ -412,8 +407,7 @@ void ITS3Layer::buildPartial(TGeoVolume* motherVolume, TGeoMatrix* mat, BuildLev
     case BuildLevel::kLayer:
       [[fallthrough]];
     default:
-      createLayerImpl();
-      motherVolume->AddNode(mLayer, 0, mat);
+      createLayer(motherVolume);
   }
   LOGP(info, "Partially built ITS3-{}-{}", mNLayer, getName(level));
 }
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3SimulationLinkDef.h b/Detectors/Upgrades/ITS3/simulation/src/ITS3SimulationLinkDef.h
index b9af595018a34..fca3f5d63c2c4 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ITS3SimulationLinkDef.h
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3SimulationLinkDef.h
@@ -18,6 +18,7 @@
 #pragma link C++ class o2::its3::ITS3Layer + ;
 #pragma link C++ class o2::its3::ITS3Services + ;
 #pragma link C++ class o2::its3::DescriptorInnerBarrelITS3 + ;
+#pragma link C++ class o2::its3::DigiParams + ;
 #pragma link C++ class o2::its3::Digitizer + ;
 
 #endif

From f0eebb64b1ef1ce4c1ebf79fa531ae06bf7049f5 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sat, 12 Apr 2025 12:45:08 +0200
Subject: [PATCH 0223/1764] ITS3: remove unnecessary reader/writers (#14157)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../Upgrades/ITS3/workflow/CMakeLists.txt     |  25 ----
 .../include/ITS3Workflow/ClusterReaderSpec.h  |  76 -----------
 .../include/ITS3Workflow/ClusterWriterSpec.h  |  31 -----
 .../ITS3Workflow/ClusterWriterWorkflow.h      |  31 -----
 .../include/ITS3Workflow/TrackReaderSpec.h    |  79 ------------
 .../include/ITS3Workflow/TrackWriterSpec.h    |  31 -----
 .../include/ITS3Workflow/VertexReaderSpec.h   |  65 ----------
 .../ITS3/workflow/src/ClusterReaderSpec.cxx   | 122 ------------------
 .../ITS3/workflow/src/ClusterWriterSpec.cxx   |  72 -----------
 .../workflow/src/ClusterWriterWorkflow.cxx    |  36 ------
 .../ITS3/workflow/src/RecoWorkflow.cxx        |   8 +-
 .../ITS3/workflow/src/TrackReaderSpec.cxx     | 120 -----------------
 .../ITS3/workflow/src/TrackWriterSpec.cxx     |  82 ------------
 .../ITS3/workflow/src/VertexReaderSpec.cxx    |  84 ------------
 14 files changed, 4 insertions(+), 858 deletions(-)
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterReaderSpec.h
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterWriterSpec.h
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterWriterWorkflow.h
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackReaderSpec.h
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackWriterSpec.h
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/VertexReaderSpec.h
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/src/ClusterReaderSpec.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/src/ClusterWriterSpec.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/src/ClusterWriterWorkflow.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/src/TrackReaderSpec.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/src/TrackWriterSpec.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/workflow/src/VertexReaderSpec.cxx

diff --git a/Detectors/Upgrades/ITS3/workflow/CMakeLists.txt b/Detectors/Upgrades/ITS3/workflow/CMakeLists.txt
index 649e4d737d42c..bcb3cf46375e9 100644
--- a/Detectors/Upgrades/ITS3/workflow/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/workflow/CMakeLists.txt
@@ -15,13 +15,8 @@ o2_add_library(ITS3Workflow
                SOURCES src/DigitReaderSpec.cxx
                        src/DigitWriterSpec.cxx
                        src/RecoWorkflow.cxx
-                       src/ClusterWriterWorkflow.cxx
                        src/ClustererSpec.cxx
-                       src/ClusterWriterSpec.cxx
                        src/TrackerSpec.cxx
-                       src/TrackWriterSpec.cxx
-                       src/TrackReaderSpec.cxx
-                       src/VertexReaderSpec.cxx
                PUBLIC_LINK_LIBRARIES O2::Framework
                                      O2::SimConfig
                                      O2::DataFormatsITSMFT
@@ -35,27 +30,7 @@ o2_add_library(ITS3Workflow
                                      O2::GPUTracking
                                      O2::ITSBase)
 
-# o2_add_executable(digit-writer-workflow
-#                   SOURCES src/digit-writer-workflow.cxx
-#                   COMPONENT_NAME its3
-#                   PUBLIC_LINK_LIBRARIES O2::ITS3Workflow)
-
-# o2_add_executable(digit-reader-workflow
-#                   SOURCES src/digit-reader-workflow.cxx
-#                   COMPONENT_NAME its3
-#                   PUBLIC_LINK_LIBRARIES O2::ITS3Workflow)
-
 o2_add_executable(reco-workflow
                   SOURCES src/its3-reco-workflow.cxx
                   COMPONENT_NAME its3
                   PUBLIC_LINK_LIBRARIES O2::ITS3Workflow)
-
-# o2_add_executable(cluster-writer-workflow
-#                   SOURCES src/its-cluster-writer-workflow.cxx
-#                   COMPONENT_NAME its
-#                   PUBLIC_LINK_LIBRARIES O2::ITSWorkflow)
-
-# o2_add_executable(cluster-reader-workflow
-#                   SOURCES src/its-cluster-reader-workflow.cxx
-#                   COMPONENT_NAME its
-#                   PUBLIC_LINK_LIBRARIES O2::ITSWorkflow)
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterReaderSpec.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterReaderSpec.h
deleted file mode 100644
index c411c2accace1..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterReaderSpec.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClusterReaderSpec.h
-
-#ifndef O2_ITSMFT_CLUSTERREADER
-#define O2_ITSMFT_CLUSTERREADER
-
-#include "TFile.h"
-#include "TTree.h"
-
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-#include "Headers/DataHeader.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-
-using namespace o2::framework;
-
-namespace o2::its3
-{
-
-class ClusterReader : public Task
-{
- public:
-  ClusterReader(bool useMC, bool usePatterns = true);
-
-  void init(InitContext& ic) final;
-  void run(ProcessingContext& pc) final;
-
- protected:
-  void connectTree(const std::string& filename);
-
-  std::vector<o2::itsmft::ROFRecord> mClusROFRec, *mClusROFRecPtr = &mClusROFRec;
-  std::vector<o2::itsmft::CompClusterExt> mClusterCompArray, *mClusterCompArrayPtr = &mClusterCompArray;
-  std::vector<unsigned char> mPatternsArray, *mPatternsArrayPtr = &mPatternsArray;
-  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mClusterMCTruth, *mClusterMCTruthPtr = &mClusterMCTruth;
-  std::vector<o2::itsmft::MC2ROFRecord> mClusMC2ROFs, *mClusMC2ROFsPtr = &mClusMC2ROFs;
-
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginITS;
-
-  std::unique_ptr<TFile> mFile;
-  std::unique_ptr<TTree> mTree;
-
-  bool mUseMC = true;       // use MC truth
-  bool mUsePatterns = true; // send patterns
-
-  std::string mDetName = "ITS"; // pretending to be ITS
-  std::string mDetNameLC = "its";
-  std::string mDetNameReal = "IT3";
-  std::string mFileName = "";
-  std::string mClusTreeName = "o2sim";
-  std::string mClusROFBranchName = "ClustersROF";
-  std::string mClusterPattBranchName = "ClusterPatt";
-  std::string mClusterCompBranchName = "ClusterComp";
-  std::string mClustMCTruthBranchName = "ClusterMCTruth";
-  std::string mClustMC2ROFBranchName = "ClustersMC2ROF";
-};
-
-/// create a processor spec
-/// read ITS/MFT cluster data from a root file
-framework::DataProcessorSpec getITS3ClusterReaderSpec(bool useMC = true, bool usePatterns = true);
-
-} // namespace o2::its3
-
-#endif /* O2_ITSMFT_CLUSTERREADER */
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterWriterSpec.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterWriterSpec.h
deleted file mode 100644
index 49106871d89d5..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterWriterSpec.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClusterWriterSpec.h
-
-#ifndef O2_ITS_CLUSTERWRITER
-#define O2_ITS_CLUSTERWRITER
-
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace its3
-{
-
-/// create a processor spec
-/// write ITS clusters to ROOT file
-framework::DataProcessorSpec getClusterWriterSpec(bool useMC);
-
-} // namespace its3
-} // namespace o2
-
-#endif /* O2_ITS_CLUSTERWRITER */
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterWriterWorkflow.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterWriterWorkflow.h
deleted file mode 100644
index 05268e7ca3a1e..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/ClusterWriterWorkflow.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef O2_ITS_CLUSTER_WRITER_WORKFLOW_H
-#define O2_ITS_CLUSTER_WRITER_WORKFLOW_H
-
-/// @file   ClusterWriterWorkflow.h
-
-#include "Framework/WorkflowSpec.h"
-
-namespace o2
-{
-namespace its3
-{
-
-namespace cluster_writer_workflow
-{
-framework::WorkflowSpec getWorkflow(bool useMC);
-}
-
-} // namespace its3
-} // namespace o2
-#endif
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackReaderSpec.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackReaderSpec.h
deleted file mode 100644
index 1686b7c275941..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackReaderSpec.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   TrackReaderSpec.h
-
-#ifndef O2_ITS3_TRACKREADER
-#define O2_ITS3_TRACKREADER
-
-#include "TFile.h"
-#include "TTree.h"
-
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-#include "Headers/DataHeader.h"
-#include "DataFormatsITS/TrackITS.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "ReconstructionDataFormats/Vertex.h"
-
-namespace o2
-{
-namespace its3
-{
-
-class TrackReader : public o2::framework::Task
-{
-  using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
- public:
-  TrackReader(bool useMC = true);
-  ~TrackReader() override = default;
-  void init(o2::framework::InitContext& ic) final;
-  void run(o2::framework::ProcessingContext& pc) final;
-
- protected:
-  void connectTree(const std::string& filename);
-
-  std::vector<o2::itsmft::ROFRecord> mROFRec, *mROFRecInp = &mROFRec;
-  std::vector<o2::itsmft::ROFRecord> mVerticesROFRec, *mVerticesROFRecInp = &mVerticesROFRec;
-  std::vector<o2::its::TrackITS> mTracks, *mTracksInp = &mTracks;
-  std::vector<Vertex> mVertices, *mVerticesInp = &mVertices;
-  std::vector<int> mClusInd, *mClusIndInp = &mClusInd;
-  std::vector<o2::MCCompLabel> mMCTruth, *mMCTruthInp = &mMCTruth;
-  std::vector<o2::MCCompLabel> mMCVertTruth, *mMCVTruthInp = &mMCTruth;
-
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginITS;
-
-  bool mUseMC = true; // use MC truth
-
-  std::unique_ptr<TFile> mFile;
-  std::unique_ptr<TTree> mTree;
-  std::string mInputFileName = "";
-  std::string mTrackTreeName = "o2sim";
-  std::string mROFBranchName = "ITSTracksROF";
-  std::string mTrackBranchName = "ITSTrack";
-  std::string mClusIdxBranchName = "ITSTrackClusIdx";
-  std::string mVertexBranchName = "Vertices";
-  std::string mVertexROFBranchName = "VerticesROF";
-  std::string mTrackMCTruthBranchName = "ITSTrackMCTruth";
-  std::string mTrackMCVertTruthBranchName = "ITSVertexMCTruth";
-};
-
-/// create a processor spec
-/// read ITS track data from a root file
-framework::DataProcessorSpec getITS3TrackReaderSpec(bool useMC = true);
-
-} // namespace its3
-} // namespace o2
-
-#endif /* O2_ITS3_TRACKREADER */
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackWriterSpec.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackWriterSpec.h
deleted file mode 100644
index 32f704fd61b45..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackWriterSpec.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   TrackWriterSpec.h
-
-#ifndef O2_ITS3_TRACKWRITER
-#define O2_ITS3_TRACKWRITER
-
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace its3
-{
-
-/// create a processor spec
-/// write ITS tracks to ROOT file
-o2::framework::DataProcessorSpec getTrackWriterSpec(bool useMC);
-
-} // namespace its3
-} // namespace o2
-
-#endif /* O2_ITS_TRACKWRITER */
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/VertexReaderSpec.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/VertexReaderSpec.h
deleted file mode 100644
index 6c723d07982f2..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/VertexReaderSpec.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   VertexReaderSpec.h
-
-#ifndef O2_ITS3_VERTEXREADER
-#define O2_ITS3_VERTEXREADER
-
-#include "TFile.h"
-#include "TTree.h"
-
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-#include "ReconstructionDataFormats/Vertex.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-
-namespace o2
-{
-namespace its3
-{
-// read ITS vertices from the output tree of ITS tracking
-
-class VertexReader : public o2::framework::Task
-{
-  using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
- public:
-  VertexReader() = default;
-  ~VertexReader() override = default;
-  void init(o2::framework::InitContext& ic) final;
-  void run(o2::framework::ProcessingContext& pc) final;
-
- protected:
-  void connectTree(const std::string& filename);
-  void accumulate();
-
-  std::vector<o2::itsmft::ROFRecord> mVerticesROFRec, *mVerticesROFRecPtr = &mVerticesROFRec;
-  std::vector<Vertex> mVertices, *mVerticesPtr = &mVertices;
-
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginITS;
-
-  std::unique_ptr<TFile> mFile;
-  std::unique_ptr<TTree> mTree;
-  std::string mFileName = "";
-  std::string mVertexTreeName = "o2sim";
-  std::string mVertexBranchName = "Vertices";
-  std::string mVertexROFBranchName = "VerticesROF";
-};
-
-/// create a processor spec
-/// read ITS vertex data from a root file
-o2::framework::DataProcessorSpec getITS3VertexReaderSpec();
-
-} // namespace its3
-} // namespace o2
-
-#endif /* O2_ITS3_VERTEXREADER */
diff --git a/Detectors/Upgrades/ITS3/workflow/src/ClusterReaderSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/ClusterReaderSpec.cxx
deleted file mode 100644
index 5030b1fcdd30a..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/src/ClusterReaderSpec.cxx
+++ /dev/null
@@ -1,122 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClusterReaderSpec.cxx
-
-#include <vector>
-
-#include "TTree.h"
-
-#include "Framework/ControlService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/Logger.h"
-#include "ITS3Workflow/ClusterReaderSpec.h"
-#include <cassert>
-#include "CommonUtils/NameConf.h"
-
-using namespace o2::framework;
-using namespace o2::itsmft;
-
-namespace o2
-{
-namespace its3
-{
-
-ClusterReader::ClusterReader(bool useMC, bool usePatterns)
-{
-  mUseMC = useMC;
-  mUsePatterns = usePatterns;
-}
-
-void ClusterReader::init(InitContext& ic)
-{
-  mFileName = o2::utils::concat_string(o2::base::NameConf::rectifyDirectory(ic.options().get<std::string>("input-dir")),
-                                       ic.options().get<std::string>((mDetNameLC + "-cluster-infile").c_str()));
-  connectTree(mFileName);
-}
-
-void ClusterReader::run(ProcessingContext& pc)
-{
-  auto ent = mTree->GetReadEntry() + 1;
-  assert(ent < mTree->GetEntries()); // this should not happen
-  mTree->GetEntry(ent);
-  LOG(info) << mDetNameReal << "ClusterReader pushes " << mClusROFRec.size() << " ROFRecords,"
-            << mClusterCompArray.size() << " compact clusters at entry " << ent;
-
-  // This is a very ugly way of providing DataDescription, which anyway does not need to contain detector name.
-  // To be fixed once the names-definition class is ready
-  pc.outputs().snapshot(Output{mOrigin, "CLUSTERSROF", 0}, mClusROFRec);
-  pc.outputs().snapshot(Output{mOrigin, "COMPCLUSTERS", 0}, mClusterCompArray);
-  if (mUsePatterns) {
-    pc.outputs().snapshot(Output{mOrigin, "PATTERNS", 0}, mPatternsArray);
-  }
-  if (mUseMC) {
-    pc.outputs().snapshot(Output{mOrigin, "CLUSTERSMCTR", 0}, mClusterMCTruth);
-    pc.outputs().snapshot(Output{mOrigin, "CLUSTERSMC2ROF", 0}, mClusMC2ROFs);
-  }
-
-  if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
-    pc.services().get<ControlService>().endOfStream();
-    pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
-  }
-}
-
-void ClusterReader::connectTree(const std::string& filename)
-{
-  mTree.reset(nullptr); // in case it was already loaded
-  mFile.reset(TFile::Open(filename.c_str()));
-  assert(mFile && !mFile->IsZombie());
-  mTree.reset((TTree*)mFile->Get(mClusTreeName.c_str()));
-  assert(mTree);
-
-  mTree->SetBranchAddress((mDetName + mClusROFBranchName).c_str(), &mClusROFRecPtr);
-  mTree->SetBranchAddress((mDetName + mClusterCompBranchName).c_str(), &mClusterCompArrayPtr);
-  if (mUsePatterns) {
-    mTree->SetBranchAddress((mDetName + mClusterPattBranchName).c_str(), &mPatternsArrayPtr);
-  }
-  if (mUseMC) {
-    if (mTree->GetBranch((mDetName + mClustMCTruthBranchName).c_str()) &&
-        mTree->GetBranch((mDetName + mClustMC2ROFBranchName).c_str())) {
-      mTree->SetBranchAddress((mDetName + mClustMCTruthBranchName).c_str(), &mClusterMCTruthPtr);
-      mTree->SetBranchAddress((mDetName + mClustMC2ROFBranchName).c_str(), &mClusMC2ROFsPtr);
-    } else {
-      LOG(info) << "MC-truth is missing";
-      mUseMC = false;
-    }
-  }
-  LOG(info) << "Loaded tree from " << filename << " with " << mTree->GetEntries() << " entries";
-}
-
-DataProcessorSpec getITS3ClusterReaderSpec(bool useMC, bool usePatterns)
-{
-  std::vector<OutputSpec> outputSpec;
-  outputSpec.emplace_back("IT3", "CLUSTERSROF", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("IT3", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  if (usePatterns) {
-    outputSpec.emplace_back("IT3", "PATTERNS", 0, Lifetime::Timeframe);
-  }
-  if (useMC) {
-    outputSpec.emplace_back("IT3", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    outputSpec.emplace_back("IT3", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
-  }
-
-  return DataProcessorSpec{
-    "its3-cluster-reader",
-    Inputs{},
-    outputSpec,
-    AlgorithmSpec{adaptFromTask<ClusterReader>(useMC, usePatterns)},
-    Options{
-      {"its-cluster-infile", VariantType::String, "o2clus_its.root", {"Name of the input cluster file"}},
-      {"input-dir", VariantType::String, "none", {"Input directory"}}}};
-}
-
-} // namespace its3
-} // namespace o2
diff --git a/Detectors/Upgrades/ITS3/workflow/src/ClusterWriterSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/ClusterWriterSpec.cxx
deleted file mode 100644
index 0231560b3ac25..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/src/ClusterWriterSpec.cxx
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClusterWriterSpec.cxx
-
-#include <vector>
-
-#include "ITS3Workflow/ClusterWriterSpec.h"
-#include "DPLUtils/MakeRootTreeWriterSpec.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace its3
-{
-
-template <typename T>
-using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
-using CompClusType = std::vector<o2::itsmft::CompClusterExt>;
-using PatternsType = std::vector<unsigned char>;
-using ROFrameRType = std::vector<o2::itsmft::ROFRecord>;
-using LabelsType = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
-using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
-using namespace o2::header;
-
-DataProcessorSpec getClusterWriterSpec(bool useMC)
-{
-  // Spectators for logging
-  // this is only to restore the original behavior
-  auto compClustersSize = std::make_shared<int>(0);
-  auto compClustersSizeGetter = [compClustersSize](CompClusType const& compClusters) {
-    *compClustersSize = compClusters.size();
-  };
-  auto logger = [compClustersSize](std::vector<o2::itsmft::ROFRecord> const& rofs) {
-    LOG(info) << "ITS3ClusterWriter pulled " << *compClustersSize << " clusters, in " << rofs.size() << " RO frames";
-  };
-  return MakeRootTreeWriterSpec("its3-cluster-writer",
-                                "o2clus_its.root",
-                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Tree with ITS clusters"},
-                                BranchDefinition<CompClusType>{InputSpec{"compclus", "ITS", "COMPCLUSTERS", 0},
-                                                               "ITSClusterComp",
-                                                               compClustersSizeGetter},
-                                BranchDefinition<PatternsType>{InputSpec{"patterns", "ITS", "PATTERNS", 0},
-                                                               "ITSClusterPatt"},
-                                BranchDefinition<ROFrameRType>{InputSpec{"ROframes", "ITS", "CLUSTERSROF", 0},
-                                                               "ITSClustersROF",
-                                                               logger},
-                                BranchDefinition<LabelsType>{InputSpec{"labels", "ITS", "CLUSTERSMCTR", 0},
-                                                             "ITSClusterMCTruth",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""},
-                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", "ITS", "CLUSTERSMC2ROF", 0},
-                                                             "ITSClustersMC2ROF",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""})();
-}
-
-} // namespace its3
-} // namespace o2
diff --git a/Detectors/Upgrades/ITS3/workflow/src/ClusterWriterWorkflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/ClusterWriterWorkflow.cxx
deleted file mode 100644
index ae79b7797d57d..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/src/ClusterWriterWorkflow.cxx
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClusterWriterWorkflow.cxx
-
-#include "ITS3Workflow/ClusterWriterWorkflow.h"
-#include "ITS3Workflow/ClusterWriterSpec.h"
-
-namespace o2
-{
-namespace its3
-{
-
-namespace cluster_writer_workflow
-{
-
-framework::WorkflowSpec getWorkflow(bool useMC)
-{
-  framework::WorkflowSpec specs;
-
-  specs.emplace_back(getClusterWriterSpec(useMC));
-
-  return specs;
-}
-
-} // namespace cluster_writer_workflow
-} // namespace its3
-} // namespace o2
diff --git a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
index 721ef36335631..21ae5b4a72345 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
@@ -11,9 +11,9 @@
 
 #include "ITS3Workflow/RecoWorkflow.h"
 #include "ITS3Workflow/ClustererSpec.h"
-#include "ITS3Workflow/ClusterWriterSpec.h"
 #include "ITS3Workflow/TrackerSpec.h"
-#include "ITS3Workflow/TrackWriterSpec.h"
+#include "ITSWorkflow/ClusterWriterSpec.h"
+#include "ITSWorkflow/TrackWriterSpec.h"
 #include "ITS3Workflow/DigitReaderSpec.h"
 #include "Framework/Logger.h"
 
@@ -34,14 +34,14 @@ framework::WorkflowSpec getWorkflow(bool useMC, const std::string& trmode, o2::g
   }
 
   if (!disableRootOutput) {
-    specs.emplace_back(o2::its3::getClusterWriterSpec(useMC));
+    specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
   }
 
   if (trmode != "off") {
     specs.emplace_back(o2::its3::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
 
     if (!disableRootOutput) {
-      specs.emplace_back(o2::its3::getTrackWriterSpec(useMC));
+      specs.emplace_back(o2::its::getTrackWriterSpec(useMC));
     }
   }
 
diff --git a/Detectors/Upgrades/ITS3/workflow/src/TrackReaderSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/TrackReaderSpec.cxx
deleted file mode 100644
index 409fa69e7815b..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/src/TrackReaderSpec.cxx
+++ /dev/null
@@ -1,120 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   TrackReaderSpec.cxx
-
-#include <vector>
-#include <cassert>
-#include "Framework/ControlService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "ITS3Workflow/TrackReaderSpec.h"
-#include "CommonUtils/NameConf.h"
-
-using namespace o2::framework;
-using namespace o2::its3;
-
-namespace o2
-{
-namespace its3
-{
-
-TrackReader::TrackReader(bool useMC)
-{
-  mUseMC = useMC;
-}
-
-void TrackReader::init(InitContext& ic)
-{
-  mInputFileName = o2::utils::Str::concat_string(o2::utils::Str::rectifyDirectory(ic.options().get<std::string>("input-dir")),
-                                                 ic.options().get<std::string>("its3-tracks-infile"));
-  connectTree(mInputFileName);
-}
-
-void TrackReader::run(ProcessingContext& pc)
-{
-  auto ent = mTree->GetReadEntry() + 1;
-  assert(ent < mTree->GetEntries()); // this should not happen
-  mTree->GetEntry(ent);
-  LOG(info) << "Pushing " << mTracks.size() << " track in " << mROFRec.size() << " ROFs at entry " << ent;
-  pc.outputs().snapshot(Output{mOrigin, "ITSTrackROF", 0}, mROFRec);
-  pc.outputs().snapshot(Output{mOrigin, "TRACKS", 0}, mTracks);
-  pc.outputs().snapshot(Output{mOrigin, "TRACKCLSID", 0}, mClusInd);
-  pc.outputs().snapshot(Output{"ITS", "VERTICES", 0}, mVertices);
-  pc.outputs().snapshot(Output{"ITS", "VERTICESROF", 0}, mVerticesROFRec);
-  if (mUseMC) {
-    pc.outputs().snapshot(Output{mOrigin, "TRACKSMCTR", 0}, mMCTruth);
-    pc.outputs().snapshot(Output{mOrigin, "VERTICESMCTR", 0}, mMCVertTruth);
-  }
-
-  if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
-    pc.services().get<ControlService>().endOfStream();
-    pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
-  }
-}
-
-void TrackReader::connectTree(const std::string& filename)
-{
-  mTree.reset(nullptr); // in case it was already loaded
-  mFile.reset(TFile::Open(filename.c_str()));
-  assert(mFile && !mFile->IsZombie());
-  mTree.reset((TTree*)mFile->Get(mTrackTreeName.c_str()));
-  assert(mTree);
-  assert(mTree->GetBranch(mROFBranchName.c_str()));
-
-  mTree->SetBranchAddress(mROFBranchName.c_str(), &mROFRecInp);
-  mTree->SetBranchAddress(mTrackBranchName.c_str(), &mTracksInp);
-  mTree->SetBranchAddress(mClusIdxBranchName.c_str(), &mClusIndInp);
-  if (!mTree->GetBranch(mVertexBranchName.c_str())) {
-    LOG(warning) << "No " << mVertexBranchName << " branch in " << mTrackTreeName << " -> vertices will be empty";
-  } else {
-    mTree->SetBranchAddress(mVertexBranchName.c_str(), &mVerticesInp);
-  }
-  if (!mTree->GetBranch(mVertexROFBranchName.c_str())) {
-    LOG(warning) << "No " << mVertexROFBranchName << " branch in " << mTrackTreeName
-                 << " -> vertices ROFrecords will be empty";
-  } else {
-    mTree->SetBranchAddress(mVertexROFBranchName.c_str(), &mVerticesROFRecInp);
-  }
-  if (mUseMC) {
-    if (mTree->GetBranch(mTrackMCTruthBranchName.c_str())) {
-      mTree->SetBranchAddress(mTrackMCTruthBranchName.c_str(), &mMCTruthInp);
-    } else {
-      LOG(warning) << "MC-truth is missing, message will be empty";
-    }
-  }
-  LOG(info) << "Loaded tree from " << filename << " with " << mTree->GetEntries() << " entries";
-}
-
-DataProcessorSpec getITS3TrackReaderSpec(bool useMC)
-{
-  std::vector<OutputSpec> outputSpec;
-  outputSpec.emplace_back("ITS", "ITSTrackROF", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("ITS", "TRACKS", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("ITS", "TRACKCLSID", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("ITS", "VERTICES", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("ITS", "VERTICESROF", 0, Lifetime::Timeframe);
-  if (useMC) {
-    outputSpec.emplace_back("ITS", "TRACKSMCTR", 0, Lifetime::Timeframe);
-    outputSpec.emplace_back("ITS", "VERTICESMCTR", 0, Lifetime::Timeframe);
-  }
-
-  return DataProcessorSpec{
-    "its3-track-reader",
-    Inputs{},
-    outputSpec,
-    AlgorithmSpec{adaptFromTask<TrackReader>(useMC)},
-    Options{
-      {"its-tracks-infile", VariantType::String, "o2trac_its.root", {"Name of the input ITS3 track file"}},
-      {"input-dir", VariantType::String, "none", {"Input directory"}}}};
-}
-
-} // namespace its3
-} // namespace o2
diff --git a/Detectors/Upgrades/ITS3/workflow/src/TrackWriterSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/TrackWriterSpec.cxx
deleted file mode 100644
index 856c806e74247..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/src/TrackWriterSpec.cxx
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   TrackWriterSpec.cxx
-
-#include <vector>
-
-#include "ITS3Workflow/TrackWriterSpec.h"
-#include "DPLUtils/MakeRootTreeWriterSpec.h"
-#include "DataFormatsITS/TrackITS.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-#include "ReconstructionDataFormats/Vertex.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace its3
-{
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
-template <typename T>
-using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
-using LabelsType = std::vector<o2::MCCompLabel>;
-using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
-using namespace o2::header;
-
-DataProcessorSpec getTrackWriterSpec(bool useMC)
-{
-  // Spectators for logging
-  // this is only to restore the original behavior
-  auto tracksSize = std::make_shared<int>(0);
-  auto tracksSizeGetter = [tracksSize](std::vector<o2::its::TrackITS> const& tracks) {
-    *tracksSize = tracks.size();
-  };
-  auto logger = [tracksSize](std::vector<o2::itsmft::ROFRecord> const& rofs) {
-    LOG(info) << "ITS3TrackWriter pulled " << *tracksSize << " tracks, in " << rofs.size() << " RO frames";
-  };
-  // NOTE: We name the branches as ITS and not IT3 to ensure matching works.
-  return MakeRootTreeWriterSpec("its3-track-writer",
-                                "o2trac_its.root",
-                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Tree with ITS3 tracks"},
-                                BranchDefinition<std::vector<o2::its::TrackITS>>{InputSpec{"tracks", "ITS", "TRACKS", 0},
-                                                                                 "ITSTrack",
-                                                                                 tracksSizeGetter},
-                                BranchDefinition<std::vector<int>>{InputSpec{"trackClIdx", "ITS", "TRACKCLSID", 0},
-                                                                   "ITSTrackClusIdx"},
-                                BranchDefinition<std::vector<Vertex>>{InputSpec{"vertices", "ITS", "VERTICES", 0},
-                                                                      "Vertices"},
-                                BranchDefinition<std::vector<o2::itsmft::ROFRecord>>{InputSpec{"vtxROF", "ITS", "VERTICESROF", 0},
-                                                                                     "VerticesROF"},
-                                BranchDefinition<std::vector<o2::itsmft::ROFRecord>>{InputSpec{"ROframes", "ITS", "ITSTrackROF", 0},
-                                                                                     "ITSTracksROF",
-                                                                                     logger},
-                                BranchDefinition<LabelsType>{InputSpec{"labels", "ITS", "TRACKSMCTR", 0},
-                                                             "ITSTrackMCTruth",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""},
-                                BranchDefinition<LabelsType>{InputSpec{"labelsVertices", "ITS", "VERTICESMCTR", 0},
-                                                             "ITSVertexMCTruth",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""},
-                                BranchDefinition<std::vector<float>>{InputSpec{"purityVertices", "ITS", "VERTICESMCPUR", 0},
-                                                                     "ITSVertexMCPurity", (useMC ? 1 : 0), ""},
-                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", "ITS", "ITSTrackMC2ROF", 0},
-                                                             "ITSTracksMC2ROF",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""})();
-}
-
-} // namespace its3
-} // namespace o2
diff --git a/Detectors/Upgrades/ITS3/workflow/src/VertexReaderSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/VertexReaderSpec.cxx
deleted file mode 100644
index 25fd3e530161a..0000000000000
--- a/Detectors/Upgrades/ITS3/workflow/src/VertexReaderSpec.cxx
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   VertexReaderSpec.cxx
-
-#include <vector>
-
-#include "Framework/ControlService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/Logger.h"
-#include "ITSWorkflow/VertexReaderSpec.h"
-#include "CommonUtils/NameConf.h"
-
-using namespace o2::framework;
-using namespace o2::its;
-
-namespace o2
-{
-namespace its
-{
-
-void VertexReader::init(InitContext& ic)
-{
-  mFileName = o2::utils::Str::concat_string(o2::utils::Str::rectifyDirectory(ic.options().get<std::string>("input-dir")),
-                                            ic.options().get<std::string>("its-vertex-infile"));
-  connectTree(mFileName);
-}
-
-void VertexReader::run(ProcessingContext& pc)
-{
-  auto ent = mTree->GetReadEntry() + 1;
-  assert(ent < mTree->GetEntries()); // this should not happen
-  mTree->GetEntry(ent);
-  LOG(info) << "Pushing " << mVerticesPtr->size() << " vertices in " << mVerticesROFRecPtr->size()
-            << " ROFs at entry " << ent;
-  pc.outputs().snapshot(Output{"IT3", "VERTICES", 0}, mVertices);
-  pc.outputs().snapshot(Output{"IT3", "VERTICESROF", 0}, mVerticesROFRec);
-
-  if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
-    pc.services().get<ControlService>().endOfStream();
-    pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
-  }
-}
-
-void VertexReader::connectTree(const std::string& filename)
-{
-  mTree.reset(nullptr); // in case it was already loaded
-  mFile.reset(TFile::Open(filename.c_str()));
-  assert(mFile && !mFile->IsZombie());
-  mTree.reset((TTree*)mFile->Get(mVertexTreeName.c_str()));
-  assert(mTree);
-  assert(mTree->GetBranch(mVertexBranchName.c_str()));
-  assert(mTree->GetBranch(mVertexROFBranchName.c_str()));
-  mTree->SetBranchAddress(mVertexBranchName.c_str(), &mVerticesPtr);
-  mTree->SetBranchAddress(mVertexROFBranchName.c_str(), &mVerticesROFRecPtr);
-  LOG(info) << "Loaded tree from " << filename << " with " << mTree->GetEntries() << " entries";
-}
-
-DataProcessorSpec getITS3VertexReaderSpec()
-{
-  std::vector<OutputSpec> outputSpec;
-  outputSpec.emplace_back("IT3", "VERTICES", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("IT3", "VERTICESROF", 0, Lifetime::Timeframe);
-
-  return DataProcessorSpec{
-    "its3-vertex-reader",
-    Inputs{},
-    outputSpec,
-    AlgorithmSpec{adaptFromTask<VertexReader>()},
-    Options{
-      {"its3-vertex-infile", VariantType::String, "o2trac_its3.root", {"Name of the input ITS3 vertex file"}},
-      {"input-dir", VariantType::String, "none", {"Input directory"}}}};
-}
-
-} // namespace its
-} // namespace o2

From 7e212e1e87659b8f075ef961a0e70a11cbf104cc Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 13 Apr 2025 14:02:18 +0200
Subject: [PATCH 0224/1764] jobutils: Don't treat bogus Geant message about
 exceptions as error

---
 Utilities/Tools/jobutils.sh | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Utilities/Tools/jobutils.sh b/Utilities/Tools/jobutils.sh
index 4d51ac8522c6d..54f1394197815 100644
--- a/Utilities/Tools/jobutils.sh
+++ b/Utilities/Tools/jobutils.sh
@@ -189,10 +189,12 @@ taskwrapper() {
              -e \"terminate called without an active\"     \
              -e \"\*\*\* Error in\""                  # <--- LIBC fatal error messages
 
-    grepcommand="grep -a -H ${pattern} $logfile ${JOBUTILS_JOB_SUPERVISEDFILES} >> encountered_exceptions_list 2>/dev/null"
+    exclude_pattern="-e \"To change the tolerance or the exception severity\""
+
+    grepcommand="grep -a -H ${pattern} $logfile ${JOBUTILS_JOB_SUPERVISEDFILES} | grep -a -v ${exclude_pattern} >> encountered_exceptions_list 2>/dev/null"
     eval ${grepcommand}
 
-    grepcommand="grep -a -h --count ${pattern} $logfile ${JOBUTILS_JOB_SUPERVISEDFILES} 2>/dev/null"
+    grepcommand="cat encountered_exceptions_list 2>/dev/null | wc -l"
     # using eval here since otherwise the pattern is translated to a
     # a weirdly quoted stringlist
     RC=$(eval ${grepcommand})

From 7872ee5a85ac0762faa1dbb50da8dd0ddd904104 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 10 Apr 2025 13:07:26 +0200
Subject: [PATCH 0225/1764] GPU CMake: cleanup and fix some todos

---
 GPU/GPUTracking/CMakeLists.txt | 43 ++++++++++++++--------------------
 1 file changed, 17 insertions(+), 26 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index e722d375e4b93..44a630fe19f48 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -230,31 +230,21 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       Interface/GPUO2InterfaceConfigurableParam.cxx)
 endif()
 
+set(TEMPLATE_HEADER_LIST Base/GPUReconstructionKernelList.template.h
+                         Base/GPUReconstructionKernelIncludes.template.h
+                         Base/GPUReconstructionIncludesDeviceAll.template.h
+                         cmake/GPUNoFastMathKernels.template.h
+                         Definitions/GPUDefParameters.template.h
+                         Definitions/GPUDefParametersLoad.template.inc)
+set(GENERATED_HEADERS_LIST "")
+
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
-file(GENERATE # TODO: Do this as a list
-     OUTPUT include_gpu_onthefly/GPUReconstructionKernelList.h
-     INPUT Base/GPUReconstructionKernelList.template.h
-)
-file(GENERATE
-     OUTPUT include_gpu_onthefly/GPUReconstructionKernelIncludes.h
-     INPUT Base/GPUReconstructionKernelIncludes.template.h
-)
-file(GENERATE
-     OUTPUT include_gpu_onthefly/GPUReconstructionIncludesDeviceAll.h
-     INPUT Base/GPUReconstructionIncludesDeviceAll.template.h
-)
-file(GENERATE
-     OUTPUT include_gpu_onthefly/GPUNoFastMathKernels.h
-     INPUT cmake/GPUNoFastMathKernels.template.h
-)
-file(GENERATE
-     OUTPUT include_gpu_onthefly/GPUDefParameters.h
-     INPUT Definitions/GPUDefParameters.template.h
-)
-file(GENERATE
-     OUTPUT include_gpu_onthefly/GPUDefParametersLoad.inc
-     INPUT Definitions/GPUDefParametersLoad.template.inc
-)
+foreach(TEMPLATE_FILE ${TEMPLATE_HEADER_LIST})
+  get_filename_component(OUTPUT_FILE_NAME ${TEMPLATE_FILE} NAME)
+  string(REPLACE ".template" "" OUTPUT_FILE_NAME ${OUTPUT_FILE_NAME})
+  file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/${OUTPUT_FILE_NAME} INPUT ${TEMPLATE_FILE})
+  list(APPEND GENERATED_HEADERS_LIST ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/${OUTPUT_FILE_NAME})
+endforeach()
 file(GENERATE
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase
      CONTENT "$<JOIN:$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,\n>"
@@ -266,6 +256,7 @@ add_custom_command(
   VERBATIM
   COMMAND_EXPAND_LISTS
 )
+list(APPEND GENERATED_HEADERS_LIST ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h)
 
 set(HDRS_INSTALL ${HDRS_INSTALL} ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUReconstructionKernelList.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParameters.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoad.inc ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h)
 include(kernels.cmake)
@@ -405,11 +396,11 @@ set_source_files_properties(Base/GPUReconstructionLibrary.cxx
                             PROPERTIES
                             INCLUDE_DIRECTORIES "${CMAKE_CURRENT_BINARY_DIR}")
 
-# Make sure header files generated with add_custom_command are built
+# Make sure header files generated with add_custom_command are built before being used
 target_sources(${targetName}
                PRIVATE FILE_SET "generatedHeaders"
                TYPE HEADERS
-               FILES ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h # TODO: build file list for this
+               FILES ${GENERATED_HEADERS_LIST}
                BASE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
 
 # Add compile definitions and libraries depending on available optional dependencies

From e3b82a84be0aff2dea342a291b6e50e177ec6b90 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 10 Apr 2025 12:29:50 +0200
Subject: [PATCH 0226/1764] GPU: Fix typo in variable name, fix comments, fix
 debug messages

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx | 10 +++++-----
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  4 ++--
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  4 ++--
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  2 +-
 GPU/GPUTracking/cmake/kernel_helpers.cmake    |  2 +-
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index d714c6833d18d..ed47358cc9d5c 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -68,7 +68,7 @@ inline void GPUReconstructionCPUBackend::runKernelBackendInternal(const krnlSetu
   int32_t nThreads = getNKernelHostThreads(false);
   if (nThreads > 1) {
     if (mProcessingSettings.debugLevel >= 5) {
-      printf("Running %d Threads\n", nThreads);
+      printf("Running %d Threads\n", mThreading->activeThreads->max_concurrency());
     }
     tbb::this_task_arena::isolate([&] {
       mThreading->activeThreads->execute([&] {
@@ -91,10 +91,10 @@ inline void GPUReconstructionCPUBackend::runKernelBackendInternal(const krnlSetu
 template <>
 inline void GPUReconstructionCPUBackend::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
-  int32_t nnThreads = std::max<int32_t>(1, std::min<int32_t>(size / (16 * 1024 * 1024), getNKernelHostThreads(true)));
-  if (nnThreads > 1) {
-    tbb::parallel_for(0, nnThreads, [&](int iThread) {
-      size_t threadSize = size / nnThreads;
+  int32_t nThreads = std::max<int32_t>(1, std::min<int32_t>(size / (16 * 1024 * 1024), getNKernelHostThreads(true)));
+  if (nThreads > 1) {
+    tbb::parallel_for(0, nThreads, [&](int iThread) {
+      size_t threadSize = size / nThreads;
       if (threadSize % 4096) {
         threadSize += 4096 - threadSize % 4096;
       }
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index dd72119e3b56f..e17f1fcd7091e 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -77,8 +77,8 @@ add_custom_command(
 create_binary_resource(${GPU_RTC_BIN}.src ${GPU_RTC_BIN}.src.o)
 
 add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_CUDA_SRC_CHK.done
-                    COMMAND ! grep "# [0-9]* \"\\(/usr/\\|.*GCC-Toolchain\\)" ${GPU_RTC_BIN}.src > ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_CUDA_SRC_CHK.done || bash -c "echo ERROR: CUDA RTC sources contain standard headers 1>&2 && exit 1"
-                    COMMENT "Checking CUDA RTC File ${GPU_RTC_BIN}.src"
+                    COMMAND ! grep "# [0-9]* \"\\(/usr/\\|.*GCC-Toolchain\\)" ${GPU_RTC_BIN}.src > ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_CUDA_SRC_CHK.done || bash -c "echo ERROR: CUDA RTC sources contain system headers 1>&2 && exit 1"
+                    COMMENT "Checking CUDA RTC File ${GPU_RTC_BIN}.src for system headers"
                     DEPENDS ${GPU_RTC_BIN}.src VERBATIM)
 add_custom_target(${MODULE}_CUDA_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_CUDA_SRC_CHK.done)
 
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 5a68df8ac9527..9a9b1e36a167c 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -115,8 +115,8 @@ add_custom_command(
 create_binary_resource(${GPU_RTC_BIN}.src ${GPU_RTC_BIN}.src.o)
 
 add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_HIP_SRC_CHK.done
-                    COMMAND ! grep "# [0-9]* \"\\(/usr/\\|.*GCC-Toolchain\\)" ${GPU_RTC_BIN}.src > ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_HIP_SRC_CHK.done || bash -c "echo ERROR: HIP RTC sources contain standard headers 1>&2 && exit 1"
-                    COMMENT "Checking HIP RTC File ${GPU_RTC_BIN}.src"
+                    COMMAND ! grep "# [0-9]* \"\\(/usr/\\|.*GCC-Toolchain\\)" ${GPU_RTC_BIN}.src > ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_HIP_SRC_CHK.done || bash -c "echo ERROR: HIP RTC sources contain system headers 1>&2 && exit 1"
+                    COMMENT "Checking HIP RTC File ${GPU_RTC_BIN}.src for system headers"
                     DEPENDS ${GPU_RTC_BIN}.src VERBATIM)
 add_custom_target(${MODULE}_HIP_SRC_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_HIP_SRC_CHK.done)
 
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 37ad164d20a60..6753db280d5bf 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -267,7 +267,7 @@ bool GPUChainTracking::ValidateSettings()
     return false;
   }
   if ((GetRecoStepsGPU() & RecoStep::TPCClusterFinding) && std::max(GetProcessingSettings().nTPCClustererLanes + 1, GetProcessingSettings().nTPCClustererLanes * 2) + (GetProcessingSettings().doublePipeline ? 1 : 0) > (int32_t)mRec->NStreams()) {
-    GPUError("NStreams (%d) must be > nTPCClustererLanes (%d)", mRec->NStreams(), (int32_t)GetProcessingSettings().nTPCClustererLanes);
+    GPUError("NStreams of %d insufficient for %d nTPCClustererLanes", mRec->NStreams(), (int32_t)GetProcessingSettings().nTPCClustererLanes);
     return false;
   }
   if (GetProcessingSettings().noGPUMemoryRegistration && GetProcessingSettings().tpcCompressionGatherMode != 3) {
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index 3c1ad9658566b..7faab410d20ea 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -76,7 +76,6 @@ function(o2_gpu_add_kernel kernel_name kernel_files)
   set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_NAMES "${kernel_name}")
   set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_INCLUDES "${TMP_KERNEL_CLASS_FILE}")
   set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_FILES "${TMP_KERNEL_CLASS_FILE}.cxx")
-  # add_custom_command OUTPUT option does not support target-dependend generator expressions, thus this workaround
 
   set(O2_GPU_KERNEL_TEMPLATE_FILES "GPUConstantMem.h")
   if (GPUCA_BUILD_DEBUG)
@@ -102,6 +101,7 @@ function(o2_gpu_add_kernel kernel_name kernel_files)
   list(TRANSFORM O2_GPU_KERNEL_TEMPLATE_FILES PREPEND "#include \"")
   list(JOIN O2_GPU_KERNEL_TEMPLATE_FILES "\n" O2_GPU_KERNEL_TEMPLATE_FILES)
 
+  # add_custom_command OUTPUT option does not support target-dependend generator expressions, thus this workaround to create CUDA and HIP files
   string(REPLACE ", " "_" TMP_FILENAME "${kernel_name}")
   if(CUDA_ENABLED)
     set(TMP_FILENAMEA "${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_${TMP_FILENAME}.cu")

From 4c4e0044afb9a37b1117d7a773815a3abb86a306 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 10 Apr 2025 13:28:55 +0200
Subject: [PATCH 0227/1764] GPU: Clean up some unused parameters

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx            | 10 +++++-----
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx         |  4 ++--
 GPU/GPUTracking/Definitions/GPUDefParametersDefault.h |  7 -------
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx   |  8 ++++----
 4 files changed, 11 insertions(+), 18 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 9b6562d8e77ee..2f643706647ee 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -449,7 +449,7 @@ int32_t GPUReconstruction::Exit()
       if (mMemoryResources[i].mReuse >= 0) {
         continue;
       }
-      operator delete(mMemoryResources[i].mPtrDevice GPUCA_OPERATOR_NEW_ALIGNMENT);
+      operator delete(mMemoryResources[i].mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
       mMemoryResources[i].mPtr = mMemoryResources[i].mPtrDevice = nullptr;
     }
   }
@@ -577,7 +577,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
   if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && (control == nullptr || control->useInternal())) {
     if (!(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) {
       if (res->mPtrDevice && res->mReuse < 0) {
-        operator delete(res->mPtrDevice GPUCA_OPERATOR_NEW_ALIGNMENT);
+        operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
       }
       res->mSize = std::max((size_t)res->SetPointers((void*)1) - 1, res->mOverrideSize);
       if (res->mReuse >= 0) {
@@ -587,7 +587,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         }
         res->mPtrDevice = mMemoryResources[res->mReuse].mPtrDevice;
       } else {
-        res->mPtrDevice = operator new(res->mSize + GPUCA_BUFFER_ALIGNMENT GPUCA_OPERATOR_NEW_ALIGNMENT);
+        res->mPtrDevice = operator new(res->mSize + GPUCA_BUFFER_ALIGNMENT, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
       }
       res->mPtr = GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(res->mPtrDevice);
       res->SetPointers(res->mPtr);
@@ -775,7 +775,7 @@ void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)
     std::cout << "Freeing " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
   }
   if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && res->mReuse < 0) {
-    operator delete(res->mPtrDevice GPUCA_OPERATOR_NEW_ALIGNMENT);
+    operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
   }
   res->mPtr = nullptr;
   res->mPtrDevice = nullptr;
@@ -825,7 +825,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
   for (uint32_t i = std::get<2>(mNonPersistentMemoryStack.back()); i < mNonPersistentIndividualAllocations.size(); i++) {
     GPUMemoryResource* res = mNonPersistentIndividualAllocations[i];
     if (res->mReuse < 0) {
-      operator delete(res->mPtrDevice GPUCA_OPERATOR_NEW_ALIGNMENT);
+      operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
     }
     res->mPtr = nullptr;
     res->mPtrDevice = nullptr;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index ed47358cc9d5c..9b569d3e88f3c 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -202,7 +202,7 @@ int32_t GPUReconstructionCPU::InitDevice()
       if (mDeviceMemorySize > mHostMemorySize) {
         mHostMemorySize = mDeviceMemorySize;
       }
-      mHostMemoryBase = operator new(mHostMemorySize GPUCA_OPERATOR_NEW_ALIGNMENT);
+      mHostMemoryBase = operator new(mHostMemorySize, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
     }
     mHostMemoryPermanent = mHostMemoryBase;
     ClearAllocatedMemory();
@@ -218,7 +218,7 @@ int32_t GPUReconstructionCPU::ExitDevice()
 {
   if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     if (mMaster == nullptr) {
-      operator delete(mHostMemoryBase GPUCA_OPERATOR_NEW_ALIGNMENT);
+      operator delete(mHostMemoryBase, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
     }
     mHostMemoryPool = mHostMemoryBase = mHostMemoryPoolEnd = mHostMemoryPermanent = nullptr;
     mHostMemorySize = 0;
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
index 4435e69c60ff6..44f3eb299d4c1 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
@@ -594,14 +594,11 @@
 #define GPUCA_MAX_CLUSTERS           ((size_t)     1024 * 1024 * 1024) // Maximum number of TPC clusters
 #define GPUCA_MAX_TRD_TRACKLETS      ((size_t)             128 * 1024) // Maximum number of TRD tracklets
 #define GPUCA_MAX_ITS_FIT_TRACKS     ((size_t)              96 * 1024) // Max number of tracks for ITS track fit
-#define GPUCA_TRACKER_CONSTANT_MEM   ((size_t)              63 * 1024) // Amount of Constant Memory to reserve
 #define GPUCA_MEMORY_SIZE            ((size_t) 6 * 1024 * 1024 * 1024) // Size of memory allocated on Device
 #define GPUCA_HOST_MEMORY_SIZE       ((size_t) 1 * 1024 * 1024 * 1024) // Size of memory allocated on Host
 #define GPUCA_GPU_STACK_SIZE         ((size_t)               8 * 1024) // Stack size per GPU thread
 #define GPUCA_GPU_HEAP_SIZE          ((size_t)       16 * 1025 * 1024) // Stack size per GPU thread
 
-#define GPUCA_MAX_SECTOR_NTRACK (2 << 24)                               // Maximum number of tracks per sector (limited by track id format)
-
 // #define GPUCA_KERNEL_DEBUGGER_OUTPUT
 
 // Some assertions to make sure the parameters are not invalid
@@ -614,14 +611,10 @@
 // Derived parameters
 #ifdef GPUCA_USE_TEXTURES
   #define GPUCA_TEXTURE_FETCH_CONSTRUCTOR                              // Fetch data through texture cache
-  #define GPUCA_TEXTURE_FETCH_NEIGHBORS                                // Fetch also in Neighbours Finder
 #endif
 #if defined(GPUCA_SORT_STARTHITS_GPU) && defined(GPUCA_GPUCODE)
   #define GPUCA_SORT_STARTHITS
 #endif
 
-#define GPUCA_NEW_ALIGNMENT (std::align_val_t{GPUCA_BUFFER_ALIGNMENT})
-#define GPUCA_OPERATOR_NEW_ALIGNMENT ,GPUCA_NEW_ALIGNMENT
-
 // clang-format on
 #endif // GPUDEFPARAMETERSDEFAULT_H
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 2e3e4725bd6aa..b32db2bfebf11 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -71,7 +71,7 @@ GPUChainTracking *chainTracking, *chainTrackingAsync, *chainTrackingPipeline;
 GPUChainITS *chainITS, *chainITSAsync, *chainITSPipeline;
 void unique_ptr_aligned_delete(char* v)
 {
-  operator delete(v GPUCA_OPERATOR_NEW_ALIGNMENT);
+  operator delete(v, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
 }
 std::unique_ptr<char, void (*)(char*)> outputmemory(nullptr, unique_ptr_aligned_delete), outputmemoryPipeline(nullptr, unique_ptr_aligned_delete), inputmemory(nullptr, unique_ptr_aligned_delete);
 std::unique_ptr<GPUDisplayFrontendInterface> eventDisplay;
@@ -221,20 +221,20 @@ int32_t ReadConfiguration(int argc, char** argv)
 
   if (configStandalone.outputcontrolmem) {
     bool forceEmptyMemory = getenv("LD_PRELOAD") && strstr(getenv("LD_PRELOAD"), "valgrind") != nullptr;
-    outputmemory.reset((char*)operator new(configStandalone.outputcontrolmem GPUCA_OPERATOR_NEW_ALIGNMENT));
+    outputmemory.reset((char*)operator new(configStandalone.outputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
     if (forceEmptyMemory) {
       printf("Valgrind detected, emptying GPU output memory to avoid false positive undefined reads");
       memset(outputmemory.get(), 0, configStandalone.outputcontrolmem);
     }
     if (configStandalone.proc.doublePipeline) {
-      outputmemoryPipeline.reset((char*)operator new(configStandalone.outputcontrolmem GPUCA_OPERATOR_NEW_ALIGNMENT));
+      outputmemoryPipeline.reset((char*)operator new(configStandalone.outputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
       if (forceEmptyMemory) {
         memset(outputmemoryPipeline.get(), 0, configStandalone.outputcontrolmem);
       }
     }
   }
   if (configStandalone.inputcontrolmem) {
-    inputmemory.reset((char*)operator new(configStandalone.inputcontrolmem GPUCA_OPERATOR_NEW_ALIGNMENT));
+    inputmemory.reset((char*)operator new(configStandalone.inputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
   }
 
   configStandalone.proc.showOutputStat = true;

From 4952cee09a99f788e070dc513d14e9ebdfb04165 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 8 Apr 2025 11:26:52 +0200
Subject: [PATCH 0228/1764] ITS3: GPU tracking

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITS3Workflow/RecoWorkflow.h       |  1 +
 .../ITS3/workflow/src/RecoWorkflow.cxx        | 40 +++++++++++++++++--
 .../ITS3/workflow/src/its3-reco-workflow.cxx  |  4 +-
 3 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
index bac8a128c5b39..1760aa1d850eb 100644
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
+++ b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
@@ -26,6 +26,7 @@ namespace o2::its3::reco_workflow
 framework::WorkflowSpec getWorkflow(bool useMC,
                                     const std::string& trmode,
                                     o2::gpu::GPUDataTypes::DeviceType dtype,
+                                    bool useGPUWorkflow,
                                     bool upstreamDigits,
                                     bool upstreamClusters,
                                     bool disableRootOutput,
diff --git a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
index 21ae5b4a72345..947e53f80ddf1 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
@@ -15,12 +15,18 @@
 #include "ITSWorkflow/ClusterWriterSpec.h"
 #include "ITSWorkflow/TrackWriterSpec.h"
 #include "ITS3Workflow/DigitReaderSpec.h"
-#include "Framework/Logger.h"
+#include "GPUWorkflow/GPUWorkflowSpec.h"
+#include "Framework/CCDBParamSpec.h"
+
+// Dummy pointers
+using CompletionPolicyData = std::vector<InputSpec>;
+static CompletionPolicyData gPolicyData;
+static std::shared_ptr<o2::gpu::GPURecoWorkflowSpec> gTask;
 
 namespace o2::its3::reco_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC, const std::string& trmode, o2::gpu::GPUDataTypes::DeviceType dtype,
+framework::WorkflowSpec getWorkflow(bool useMC, const std::string& trmode, o2::gpu::GPUDataTypes::DeviceType dtype, bool useGPUWorkflow,
                                     bool upstreamDigits, bool upstreamClusters, bool disableRootOutput, bool useGeom, int useTrig, bool overrideBeamPosition)
 {
   framework::WorkflowSpec specs;
@@ -38,8 +44,36 @@ framework::WorkflowSpec getWorkflow(bool useMC, const std::string& trmode, o2::g
   }
 
   if (trmode != "off") {
-    specs.emplace_back(o2::its3::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
+    if (useGPUWorkflow) {
+      o2::gpu::GPURecoWorkflowSpec::Config cfg;
+      cfg.runITSTracking = true;
+      cfg.isITS3 = true;
+      cfg.itsTriggerType = useTrig;
+      cfg.itsOverrBeamEst = overrideBeamPosition;
+      cfg.processMC = useMC;
+      Inputs ggInputs;
+      auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true,
+                                                                  useGeom ? o2::base::GRPGeomRequest::Aligned : o2::base::GRPGeomRequest::None,
+                                                                  ggInputs, true);
+      if (!useGeom) {
+        ggRequest->addInput({"itsTGeo", "ITS", "GEOMTGEO", 0, Lifetime::Condition, framework::ccdbParamSpec("ITS/Config/Geometry")}, ggInputs);
+      }
+
+      auto task = std::make_shared<o2::gpu::GPURecoWorkflowSpec>(&gPolicyData, cfg, std::vector<int>(), 0, ggRequest);
+      gTask = task;
+      Inputs taskInputs = task->inputs();
+      Options taskOptions = task->options();
+      std::move(ggInputs.begin(), ggInputs.end(), std::back_inserter(taskInputs));
 
+      specs.emplace_back(DataProcessorSpec{
+        "its3-gpu-tracker",
+        taskInputs,
+        task->outputs(),
+        AlgorithmSpec{adoptTask<o2::gpu::GPURecoWorkflowSpec>(task)},
+        taskOptions});
+    } else {
+      specs.emplace_back(o2::its3::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
+    }
     if (!disableRootOutput) {
       specs.emplace_back(o2::its::getTrackWriterSpec(useMC));
     }
diff --git a/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
index b8aec2541d31f..2f0eda73742cb 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
@@ -48,6 +48,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"tracking-mode", o2::framework::VariantType::String, "off", {"off,sync,async,cosmics"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight IT3 part"}},
+    {"use-gpu-workflow", o2::framework::VariantType::Bool, false, {"use GPU workflow (default: false)"}},
     {"gpu-device", o2::framework::VariantType::Int, 1, {"use gpu device: CPU=1,CUDA=2,HIP=3 (default: CPU)"}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
@@ -67,6 +68,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto extClusters = configcontext.options().get<bool>("clusters-from-upstream");
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
+  auto useGPUWfx = configcontext.options().get<bool>("use-gpu-workflow");
   std::transform(trmode.begin(), trmode.end(), trmode.begin(), [](unsigned char c) { return std::tolower(c); });
 
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
@@ -80,7 +82,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
       LOG(fatal) << "Unknown trigger type requested for events prescaling: " << selTrig;
     }
   }
-  auto wf = o2::its3::reco_workflow::getWorkflow(useMC, trmode, gpuDevice, extDigits, extClusters, disableRootOutput, useGeom, trType, beamPosOVerride);
+  auto wf = o2::its3::reco_workflow::getWorkflow(useMC, trmode, gpuDevice, useGPUWfx, extDigits, extClusters, disableRootOutput, useGeom, trType, beamPosOVerride);
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, wf);

From fad8881705586ffaadde0f965c937e05d3fd766c Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 8 Apr 2025 11:26:15 +0200
Subject: [PATCH 0229/1764] GPU: Add ITS3 to workflow

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 GPU/Workflow/CMakeLists.txt                      |  3 ++-
 .../include/GPUWorkflow/GPUWorkflowSpec.h        |  1 +
 GPU/Workflow/src/GPUWorkflowITS.cxx              | 16 ++++++++++++++++
 GPU/Workflow/src/GPUWorkflowSpec.cxx             | 10 +++++++---
 4 files changed, 26 insertions(+), 4 deletions(-)

diff --git a/GPU/Workflow/CMakeLists.txt b/GPU/Workflow/CMakeLists.txt
index aa725168b9db2..db8d22dda1bae 100644
--- a/GPU/Workflow/CMakeLists.txt
+++ b/GPU/Workflow/CMakeLists.txt
@@ -27,7 +27,8 @@ o2_add_library(GPUWorkflow
                                      O2::DataFormatsGlobalTracking
                                      O2::DataFormatsTRD
                PRIVATE_LINK_LIBRARIES O2::GPUTracking
-                                      O2::ITSTrackingInterface)
+                                      O2::ITSTrackingInterface
+                                      $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3TrackingInterface>)
 
 o2_add_executable(reco-workflow
        COMPONENT_NAME gpu
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index eda3b28c6cff6..0038233f1c376 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -130,6 +130,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     bool runITSTracking = false;
     bool itsOverrBeamEst = false;
     bool tpcTriggerHandling = false;
+    bool isITS3 = false;
   };
 
   GPURecoWorkflowSpec(CompletionPolicyData* policyData, Config const& specconfig, std::vector<int32_t> const& tpcsectors, uint64_t tpcSectorMask, std::shared_ptr<o2::base::GRPGeomRequest>& ggr, std::function<bool(o2::framework::DataProcessingHeader::StartTime)>** gPolicyOrder = nullptr);
diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index db9303c431ae7..e56958cba2c9b 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -20,6 +20,10 @@
 
 #include "ITStracking/TrackingInterface.h"
 
+#ifdef ENABLE_UPGRADES
+#include "ITS3Reconstruction/TrackingInterface.h"
+#endif
+
 namespace o2::gpu
 {
 
@@ -35,6 +39,18 @@ void GPURecoWorkflowSpec::initFunctionITS(o2::framework::InitContext& ic)
 {
   o2::its::VertexerTraits* vtxTraits = nullptr;
   o2::its::TrackerTraits* trkTraits = nullptr;
+#ifdef ENABLE_UPGRADES
+  if (mSpecConfig.isITS3) {
+    mITSTrackingInterface = std::make_unique<o2::its3::ITS3TrackingInterface>(mSpecConfig.processMC,
+                                                                              mSpecConfig.itsTriggerType,
+                                                                              mSpecConfig.itsOverrBeamEst);
+  } else
+#endif
+  {
+    mITSTrackingInterface = std::make_unique<o2::its::ITSTrackingInterface>(mSpecConfig.processMC,
+                                                                            mSpecConfig.itsTriggerType,
+                                                                            mSpecConfig.itsOverrBeamEst);
+  }
   mITSTrackingInterface = std::make_unique<o2::its::ITSTrackingInterface>(mSpecConfig.processMC,
                                                                           mSpecConfig.itsTriggerType,
                                                                           mSpecConfig.itsOverrBeamEst);
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index aa4f3cfca1289..7ad03ec58ae80 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -1174,9 +1174,13 @@ Inputs GPURecoWorkflowSpec::inputs()
     } else if (mSpecConfig.itsTriggerType == 2) {
       inputs.emplace_back("phystrig", "TRD", "TRKTRGRD", 0, Lifetime::Timeframe);
     }
-    inputs.emplace_back("itscldict", "ITS", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
-    inputs.emplace_back("itsalppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
-
+    if (mSpecConfig.isITS3) {
+      inputs.emplace_back("cldict", "IT3", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("IT3/Calib/ClusterDictionary"));
+      inputs.emplace_back("alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+    } else {
+      inputs.emplace_back("itscldict", "ITS", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
+      inputs.emplace_back("itsalppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+    }
     if (mSpecConfig.itsOverrBeamEst) {
       inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
     }

From 304938e708db28c837d8fc14a6248df3db3ce185 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 26 Feb 2025 15:41:21 +0100
Subject: [PATCH 0230/1764] ITS3: propagating split dict to external

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/GlobalTracking/src/MatchTPCITS.cxx              | 8 ++++----
 .../include/StrangenessTracking/StrangenessTracker.h      | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index 403b7dbbb0e09..f689caed87351 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -671,7 +671,8 @@ bool MatchTPCITS::prepareITSData()
     auto pattID = clus.getPatternID();
     unsigned int npix;
 #ifdef ENABLE_UPGRADES
-    if ((pattID == o2::itsmft::CompCluster::InvalidPatternID) || ((withITS3) ? mIT3Dict->isGroup(pattID) : mITSDict->isGroup(pattID))) { // braces guarantee evaluation order
+    auto ib = o2::its3::constants::detID::isDetITS3(clus.getChipID());
+    if ((pattID == o2::itsmft::CompCluster::InvalidPatternID) || ((withITS3) ? mIT3Dict->isGroup(pattID, ib) : mITSDict->isGroup(pattID))) { // braces guarantee evaluation order
 #else
     if (pattID == o2::itsmft::CompCluster::InvalidPatternID || mITSDict->isGroup(pattID)) {
 #endif
@@ -681,7 +682,7 @@ bool MatchTPCITS::prepareITSData()
     } else {
 #ifdef ENABLE_UPGRADES
       if (withITS3) {
-        npix = mIT3Dict->getNpixels(pattID);
+        npix = mIT3Dict->getNpixels(pattID, ib);
       } else {
         npix = mITSDict->getNpixels(pattID);
       }
@@ -1444,8 +1445,7 @@ void MatchTPCITS::refitWinners(pmr::vector<o2::dataformats::TrackTPCITS>& matche
 
 #ifdef WITH_OPENMP
 #pragma omp parallel for schedule(dynamic) num_threads(mNThreads) \
-  reduction(+                                                     \
-            : nFailedRefit)
+  reduction(+ : nFailedRefit)
 #endif
   for (int ifit = 0; ifit < nToFit; ifit++) {
     int iTPC = tpcToFit[ifit], iITS;
diff --git a/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h b/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
index 9ca34e548f1c8..11feac64c59ae 100644
--- a/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
+++ b/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
@@ -279,20 +279,20 @@ class StrangenessTracker
     for (unsigned int iClus{0}; iClus < ITSclus.size(); ++iClus) {
       auto& clus = ITSclus[iClus];
       auto pattID = clus.getPatternID();
+      auto ib = o2::its3::constants::detID::isDetITS3(clus.getChipID());
       int npix;
       o2::itsmft::ClusterPattern patt;
 
-      if (pattID == o2::itsmft::CompCluster::InvalidPatternID || mdict->isGroup(pattID)) {
+      if (pattID == o2::itsmft::CompCluster::InvalidPatternID || mdict->isGroup(pattID, ib)) {
         patt.acquirePattern(pattIt);
         npix = patt.getNPixels();
       } else {
 
-        npix = mdict->getNpixels(pattID);
-        patt = mdict->getPattern(pattID);
+        npix = mdict->getNpixels(pattID, ib);
+        patt = mdict->getPattern(pattID, ib);
       }
       clusSizeVec[iClus] = npix;
     }
-    // LOG(info) << " Patt Npixel: " << pattVec[0].getNPixels();
   }
 #endif
 

From 9a0a760ec1f251b6728807901e50511d49ed6ab7 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 14 Apr 2025 10:54:36 +0200
Subject: [PATCH 0231/1764] ITS: CellSeed forced cast to int for chi2 (#14173)

@mconcas @mpuccio is there a reason why there the `getChi2()` method casts the chi2 to int?
Seems to me that this is a bit broken.
---
 Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index fa0473ae88462..9ed5daed447df 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -97,7 +97,7 @@ class CellSeed final : public o2::track::TrackParCovF
   GPUhd() void setFirstTrackletIndex(int trkl) { mTracklets[0] = trkl; };
   GPUhd() int getSecondTrackletIndex() const { return mTracklets[1]; };
   GPUhd() void setSecondTrackletIndex(int trkl) { mTracklets[1] = trkl; };
-  GPUhd() int getChi2() const { return mChi2; };
+  GPUhd() float getChi2() const { return mChi2; };
   GPUhd() void setChi2(float chi2) { mChi2 = chi2; };
   GPUhd() int getLevel() const { return mLevel; };
   GPUhd() void setLevel(int level) { mLevel = level; };

From ad25169b756bf60e0c46e3cc69ed1cb2ec28e50f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 13 Apr 2025 23:34:34 +0200
Subject: [PATCH 0232/1764] Fix decay

It looks like the comment is correct and the PDG id is wrong.
---
 Steer/src/O2MCApplication.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Steer/src/O2MCApplication.cxx b/Steer/src/O2MCApplication.cxx
index e1bba03e81c50..e44758241b8d2 100644
--- a/Steer/src/O2MCApplication.cxx
+++ b/Steer/src/O2MCApplication.cxx
@@ -887,7 +887,7 @@ void addSpecialParticles()
   mode4s[1][1] = 111;        // pion0
   bratio4s[2] = 40.;
   mode4s[2][0] = 1000010030; // tritium
-  mode4s[2][2] = 2212;       // pion+
+  mode4s[2][2] = 211;        // pion+
   mode4s[2][1] = 2112;       // neutron
 
   TVirtualMC::GetMC()->SetDecayMode(1110020040, bratio4s, mode4s);

From 0f9450ef8ec19b2dbd2c3b809f5cfcd716913880 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 14 Apr 2025 16:01:21 +0200
Subject: [PATCH 0233/1764] ONNX: Use CMake defines not env variables

---
 Common/ML/CMakeLists.txt       | 16 ++++++++--------
 Common/ML/src/OrtInterface.cxx | 32 +++++++++++++-------------------
 2 files changed, 21 insertions(+), 27 deletions(-)

diff --git a/Common/ML/CMakeLists.txt b/Common/ML/CMakeLists.txt
index 74be306c8b6a5..540fe8ebf271c 100644
--- a/Common/ML/CMakeLists.txt
+++ b/Common/ML/CMakeLists.txt
@@ -10,17 +10,17 @@
 # or submit itself to any jurisdiction.
 
 # Pass ORT variables as a preprocessor definition
-if(DEFINED ENV{ORT_ROCM_BUILD})
-    add_compile_definitions(ORT_ROCM_BUILD=$ENV{ORT_ROCM_BUILD})
+if(ORT_ROCM_BUILD)
+    add_compile_definitions(ORT_ROCM_BUILD=1)
 endif()
-if(DEFINED ENV{ORT_CUDA_BUILD})
-    add_compile_definitions(ORT_CUDA_BUILD=$ENV{ORT_CUDA_BUILD})
+if(ORT_CUDA_BUILD)
+    add_compile_definitions(ORT_CUDA_BUILD=1)
 endif()
-if(DEFINED ENV{ORT_MIGRAPHX_BUILD})
-    add_compile_definitions(ORT_MIGRAPHX_BUILD=$ENV{ORT_MIGRAPHX_BUILD})
+if(ORT_MIGRAPHX_BUILD)
+    add_compile_definitions(ORT_MIGRAPHX_BUILD=1)
 endif()
-if(DEFINED ENV{ORT_TENSORRT_BUILD})
-    add_compile_definitions(ORT_TENSORRT_BUILD=$ENV{ORT_TENSORRT_BUILD})
+if(ORT_TENSORRT_BUILD)
+    add_compile_definitions(ORT_TENSORRT_BUILD=1)
 endif()
 
 o2_add_library(ML
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index fc784dd14d2dc..88f548bd4fe7b 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -59,29 +59,23 @@ void OrtModel::reset(std::unordered_map<std::string, std::string> optionsMap)
 
     std::string dev_mem_str = "Hip";
 #if defined(ORT_ROCM_BUILD)
-#if ORT_ROCM_BUILD == 1
-  if (device == "ROCM") {
-    Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_ROCM(pImplOrt->sessionOptions, deviceId));
-    LOG(info) << "(ORT) ROCM execution provider set";
-  }
-#endif
+    if (device == "ROCM") {
+      Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_ROCM(pImplOrt->sessionOptions, deviceId));
+      LOG(info) << "(ORT) ROCM execution provider set";
+    }
 #endif
 #if defined(ORT_MIGRAPHX_BUILD)
-#if ORT_MIGRAPHX_BUILD == 1
-  if (device == "MIGRAPHX") {
-    Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_MIGraphX(pImplOrt->sessionOptions, deviceId));
-    LOG(info) << "(ORT) MIGraphX execution provider set";
-  }
-#endif
+    if (device == "MIGRAPHX") {
+      Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_MIGraphX(pImplOrt->sessionOptions, deviceId));
+      LOG(info) << "(ORT) MIGraphX execution provider set";
+    }
 #endif
 #if defined(ORT_CUDA_BUILD)
-#if ORT_CUDA_BUILD == 1
-  if (device == "CUDA") {
-    Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_CUDA(pImplOrt->sessionOptions, deviceId));
-    LOG(info) << "(ORT) CUDA execution provider set";
-    dev_mem_str = "Cuda";
-  }
-#endif
+    if (device == "CUDA") {
+      Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_CUDA(pImplOrt->sessionOptions, deviceId));
+      LOG(info) << "(ORT) CUDA execution provider set";
+      dev_mem_str = "Cuda";
+    }
 #endif
 
   if (allocateDeviceMemory) {

From 013e1514fc94bc13564dfcf7bafd0c3f633f6a69 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 10 Apr 2025 15:10:20 +0200
Subject: [PATCH 0234/1764] Split GPUDefParameters file into constants, and
 RTC-dynamic parameters with a defaults file, and a wrapper!

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |   2 +-
 GPU/GPUTracking/CMakeLists.txt                |   8 +-
 GPU/GPUTracking/Definitions/GPUDef.h          |   2 +-
 .../Definitions/GPUDefParametersConstants.h   |  87 ++++++++++++
 ...rsDefault.h => GPUDefParametersDefaults.h} | 132 ++----------------
 .../GPUDefParametersLoad.template.inc         |   2 +-
 ...e.h => GPUDefParametersRuntime.template.h} |   8 +-
 .../Definitions/GPUDefParametersWrapper.h     |  66 +++++++++
 .../Standalone/tools/dumpGPUDefParam.C        |   7 +-
 9 files changed, 182 insertions(+), 132 deletions(-)
 create mode 100644 GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
 rename GPU/GPUTracking/Definitions/{GPUDefParametersDefault.h => GPUDefParametersDefaults.h} (81%)
 rename GPU/GPUTracking/Definitions/{GPUDefParameters.template.h => GPUDefParametersRuntime.template.h} (87%)
 create mode 100644 GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 9b569d3e88f3c..39507beda8a55 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -16,7 +16,7 @@
 #include "GPUReconstructionIncludes.h"
 #include "GPUReconstructionThreading.h"
 #include "GPUChain.h"
-#include "GPUDefParameters.h"
+#include "GPUDefParametersRuntime.h"
 #include "GPUTPCClusterData.h"
 #include "GPUTPCSectorOutCluster.h"
 #include "GPUTPCGMMergedTrack.h"
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 44a630fe19f48..f428d982394e0 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -129,7 +129,9 @@ set(HDRS_INSTALL
     DataTypes/GPUTriggerOutputs.h
     Debug/GPUROOTDump.h
     Definitions/GPUDefConstantsAndSettings.h
-    Definitions/GPUDefParametersDefault.h
+    Definitions/GPUDefParametersWrapper.h
+    Definitions/GPUDefParametersConstants.h
+    Definitions/GPUDefParametersDefaults.h
     Definitions/GPUDef.h
     Definitions/GPUDefMacros.h
     Definitions/GPULogging.h
@@ -234,7 +236,7 @@ set(TEMPLATE_HEADER_LIST Base/GPUReconstructionKernelList.template.h
                          Base/GPUReconstructionKernelIncludes.template.h
                          Base/GPUReconstructionIncludesDeviceAll.template.h
                          cmake/GPUNoFastMathKernels.template.h
-                         Definitions/GPUDefParameters.template.h
+                         Definitions/GPUDefParametersRuntime.template.h
                          Definitions/GPUDefParametersLoad.template.inc)
 set(GENERATED_HEADERS_LIST "")
 
@@ -258,7 +260,7 @@ add_custom_command(
 )
 list(APPEND GENERATED_HEADERS_LIST ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h)
 
-set(HDRS_INSTALL ${HDRS_INSTALL} ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUReconstructionKernelList.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParameters.h ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoad.inc ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h)
+set(HDRS_INSTALL ${HDRS_INSTALL} ${GENERATED_HEADERS_LIST})
 include(kernels.cmake)
 
 # Optional sources depending on optional dependencies
diff --git a/GPU/GPUTracking/Definitions/GPUDef.h b/GPU/GPUTracking/Definitions/GPUDef.h
index 404f35f971c94..c77b9ce159306 100644
--- a/GPU/GPUTracking/Definitions/GPUDef.h
+++ b/GPU/GPUTracking/Definitions/GPUDef.h
@@ -18,7 +18,7 @@
 
 #include "GPUCommonDef.h"
 #include "GPUDefConstantsAndSettings.h"
-#include "GPUDefParametersDefault.h"
+#include "GPUDefParametersWrapper.h"
 #include "GPUCommonRtypes.h"
 
 // Macros for masking ptrs in OpenCL kernel calls as uint64_t (The API only allows us to pass buffer objects)
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
new file mode 100644
index 0000000000000..3a16d02ecf7c6
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
@@ -0,0 +1,87 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDefParametersConstants.h
+/// \author David Rohr
+
+// This file contains compile-time constants, independent from the backend
+
+#ifndef GPUDEFPARAMETERSCONSTANTS_H
+#define GPUDEFPARAMETERSCONSTANTS_H
+// clang-format off
+
+#define GPUCA_THREAD_COUNT_SCAN 512 // TODO: WARNING!!! Must not be GPUTYPE-dependent right now! // TODO: Fix!
+
+#if defined(__CUDACC__) || defined(__HIPCC__)
+  #define GPUCA_SPECIALIZE_THRUST_SORTS
+#endif
+
+#define GPUCA_MAX_THREADS 1024
+#define GPUCA_MAX_STREAMS 36
+
+#if defined(GPUCA_GPUCODE)
+  #define GPUCA_SORT_STARTHITS                                         // Sort the start hits when running on GPU
+#endif
+
+#define GPUCA_ROWALIGNMENT 16                                          // Align of Row Hits and Grid
+#define GPUCA_BUFFER_ALIGNMENT 64                                      // Alignment of buffers obtained from SetPointers
+#define GPUCA_MEMALIGN (64 * 1024)                                     // Alignment of allocated memory blocks
+
+// Default maximum numbers
+#define GPUCA_MAX_CLUSTERS           ((size_t)     1024 * 1024 * 1024) // Maximum number of TPC clusters
+#define GPUCA_MAX_TRD_TRACKLETS      ((size_t)             128 * 1024) // Maximum number of TRD tracklets
+#define GPUCA_MAX_ITS_FIT_TRACKS     ((size_t)              96 * 1024) // Max number of tracks for ITS track fit
+#define GPUCA_MEMORY_SIZE            ((size_t) 6 * 1024 * 1024 * 1024) // Size of memory allocated on Device
+#define GPUCA_HOST_MEMORY_SIZE       ((size_t) 1 * 1024 * 1024 * 1024) // Size of memory allocated on Host
+#define GPUCA_GPU_STACK_SIZE         ((size_t)               8 * 1024) // Stack size per GPU thread
+#define GPUCA_GPU_HEAP_SIZE          ((size_t)       16 * 1025 * 1024) // Stack size per GPU thread
+
+#ifdef GPUCA_GPUCODE
+  #ifndef GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP
+     #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 6
+  #endif
+  #ifndef GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE
+     #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 12
+  #endif
+  #ifndef GPUCA_ALTERNATE_BORDER_SORT
+     #define GPUCA_ALTERNATE_BORDER_SORT 0
+  #endif
+  #ifndef GPUCA_SORT_BEFORE_FIT
+     #define GPUCA_SORT_BEFORE_FIT 0
+  #endif
+  #ifndef GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION
+     #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
+  #endif
+  #ifndef GPUCA_COMP_GATHER_KERNEL
+     #define GPUCA_COMP_GATHER_KERNEL 0
+  #endif
+  #ifndef GPUCA_COMP_GATHER_MODE
+     #define GPUCA_COMP_GATHER_MODE 2
+  #endif
+#else
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 0
+  #define GPUCA_ALTERNATE_BORDER_SORT 0
+  #define GPUCA_SORT_BEFORE_FIT 0
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
+  #define GPUCA_THREAD_COUNT_FINDER 1
+  #define GPUCA_COMP_GATHER_KERNEL 0
+  #define GPUCA_COMP_GATHER_MODE 0
+#endif
+#ifndef GPUCA_DEDX_STORAGE_TYPE
+  #define GPUCA_DEDX_STORAGE_TYPE float
+#endif
+#ifndef GPUCA_MERGER_INTERPOLATION_ERROR_TYPE
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
+#endif
+
+// clang-format on
+#endif // GPUDEFPARAMETERSCONSTANTS_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
similarity index 81%
rename from GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
rename to GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 44f3eb299d4c1..360fb1ffb5269 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefault.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -9,28 +9,22 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUDefParametersDefault.h
+/// \file GPUDefParametersDefaults.h
 /// \author David Rohr
 
-// This files contains compile-time constants affecting the GPU performance.
-// Many of these constants are GPU-architecture specific.
-// This file also contains all constants describing memory limitations, essentially limiting the total number of tracks, etc.
-// Compile-time constants affecting the tracking algorithms / results are located in GPUDefConstantsAndSettings.h
+// This file contains compile-time constants affecting the GPU performance.
 
-#ifndef GPUDEFPARAMETERSDEFAULT_H
-#define GPUDEFPARAMETERSDEFAULT_H
+#ifndef GPUDEFPARAMETERSDEFAULTS_H
+#define GPUDEFPARAMETERSDEFAULTS_H
 // clang-format off
 
-#include "GPUCommonDef.h"
-#include "GPUDefMacros.h"
-
 // Launch bound definition, 3 optional parameters: maxThreads per block, minBlocks per multiprocessor, force number of blocks (not passed to compiler as launch bounds)
 
 // GPU Run Configuration
 #ifdef GPUCA_GPUCODE
 #if defined(GPUCA_GPUTYPE_MI2xx)
   #define GPUCA_WARP_SIZE 64
-  #define GPUCA_THREAD_COUNT 256
+  #define GPUCA_THREAD_COUNT_DEFAULT 256
   #define GPUCA_LB_GPUTPCCreateTrackingData 256
   #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
   #define GPUCA_LB_GPUTPCStartHitsFinder 1024
@@ -93,7 +87,7 @@
   #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_VEGA)
   #define GPUCA_WARP_SIZE 64
-  #define GPUCA_THREAD_COUNT 256
+  #define GPUCA_THREAD_COUNT_DEFAULT 256
   #define GPUCA_LB_GPUTPCCreateTrackingData 128
   #define GPUCA_LB_GPUTPCStartHitsSorter 1024, 2
   #define GPUCA_LB_GPUTPCStartHitsFinder 1024
@@ -156,7 +150,7 @@
   #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_AMPERE)
   #define GPUCA_WARP_SIZE 32
-  #define GPUCA_THREAD_COUNT 512
+  #define GPUCA_THREAD_COUNT_DEFAULT 512
   #define GPUCA_LB_GPUTPCCreateTrackingData 384
   #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
   #define GPUCA_LB_GPUTPCStartHitsFinder 512
@@ -219,7 +213,7 @@
   #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_TURING)
   #define GPUCA_WARP_SIZE 32
-  #define GPUCA_THREAD_COUNT 512
+  #define GPUCA_THREAD_COUNT_DEFAULT 512
   #define GPUCA_LB_GPUTPCCreateTrackingData 256
   #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
   #define GPUCA_LB_GPUTPCStartHitsFinder 512
@@ -281,8 +275,8 @@
 
 #ifdef GPUCA_GPUCODE
   // Default settings for GPU, if not already set for selected GPU type
-  #ifndef GPUCA_THREAD_COUNT
-    #define GPUCA_THREAD_COUNT 256
+  #ifndef GPUCA_THREAD_COUNT_DEFAULT
+    #define GPUCA_THREAD_COUNT_DEFAULT 256
   #endif
   #ifndef GPUCA_LB_GPUTPCCreateTrackingData
     #define GPUCA_LB_GPUTPCCreateTrackingData 256
@@ -486,13 +480,11 @@
     #define GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov 256
   #endif
   #ifndef GPUCA_LB_GPUMemClean16
-    #define GPUCA_LB_GPUMemClean16 GPUCA_THREAD_COUNT, 1
+    #define GPUCA_LB_GPUMemClean16 GPUCA_THREAD_COUNT_DEFAULT, 1
   #endif
   #ifndef GPUCA_LB_GPUitoa
-    #define GPUCA_LB_GPUitoa GPUCA_THREAD_COUNT, 1
+    #define GPUCA_LB_GPUitoa GPUCA_THREAD_COUNT_DEFAULT, 1
   #endif
-  #define GPUCA_GET_THREAD_COUNT(...) GPUCA_M_FIRST(__VA_ARGS__)
-
   // These kernel launch-bounds are derrived from one of the constants set above
   #define GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression GPUCA_LB_GPUTPCCFNoiseSuppression
   #define GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks GPUCA_LB_GPUTPCCFNoiseSuppression
@@ -516,105 +508,7 @@
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64 GPUCA_LB_COMPRESSION_GATHER
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered128 GPUCA_LB_COMPRESSION_GATHER
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_multiBlock GPUCA_LB_COMPRESSION_GATHER
-#else
-  #define GPUCA_GET_THREAD_COUNT(...) 1 // On the host, a thread is a block, and we run 1 "device thread" per block.
-#endif
-
-#define GPUCA_GET_WARP_COUNT(...) (GPUCA_GET_THREAD_COUNT(__VA_ARGS__) / GPUCA_WARP_SIZE)
-
-#define GPUCA_THREAD_COUNT_SCAN 512 // TODO: WARNING!!! Must not be GPUTYPE-dependent right now! // TODO: Fix!
-
-#if defined(__CUDACC__) || defined(__HIPCC__)
-  #define GPUCA_SPECIALIZE_THRUST_SORTS
-#endif
-
-#ifndef GPUCA_NEIGHBORSFINDER_REGS
-  #define GPUCA_NEIGHBORSFINDER_REGS NONE, 0
-#endif
-#ifdef GPUCA_GPUCODE
-  #ifndef GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP
-     #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 6
-  #endif
-  #ifndef GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE
-     #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 12
-  #endif
-  #ifndef GPUCA_ALTERNATE_BORDER_SORT
-     #define GPUCA_ALTERNATE_BORDER_SORT 0
-  #endif
-  #ifndef GPUCA_SORT_BEFORE_FIT
-     #define GPUCA_SORT_BEFORE_FIT 0
-  #endif
-  #ifndef GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION
-     #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
-  #endif
-  #ifndef GPUCA_COMP_GATHER_KERNEL
-     #define GPUCA_COMP_GATHER_KERNEL 0
-  #endif
-  #ifndef GPUCA_COMP_GATHER_MODE
-     #define GPUCA_COMP_GATHER_MODE 2
-  #endif
-#else
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 0
-  #define GPUCA_ALTERNATE_BORDER_SORT 0
-  #define GPUCA_SORT_BEFORE_FIT 0
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
-  #define GPUCA_THREAD_COUNT_FINDER 1
-  #define GPUCA_COMP_GATHER_KERNEL 0
-  #define GPUCA_COMP_GATHER_MODE 0
-#endif
-#ifndef GPUCA_DEDX_STORAGE_TYPE
-  #define GPUCA_DEDX_STORAGE_TYPE float
-#endif
-#ifndef GPUCA_MERGER_INTERPOLATION_ERROR_TYPE
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
-#endif
-#define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)
-#define GPUCA_DEDX_STORAGE_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_DEDX_STORAGE_TYPE)
-
-#ifndef GPUCA_WARP_SIZE
-  #ifdef GPUCA_GPUCODE
-    #define GPUCA_WARP_SIZE 32
-  #else
-    #define GPUCA_WARP_SIZE 1
-  #endif
-#endif
-
-#define GPUCA_MAX_THREADS 1024
-#define GPUCA_MAX_STREAMS 36
-
-#define GPUCA_SORT_STARTHITS_GPU                                       // Sort the start hits when running on GPU
-#define GPUCA_ROWALIGNMENT 16                                          // Align of Row Hits and Grid
-#define GPUCA_BUFFER_ALIGNMENT 64                                      // Alignment of buffers obtained from SetPointers
-#define GPUCA_MEMALIGN (64 * 1024)                                     // Alignment of allocated memory blocks
-
-// #define GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE                       // Output Profiling Data for Tracklet Constructor Tracklet Scheduling
-
-// Default maximum numbers
-#define GPUCA_MAX_CLUSTERS           ((size_t)     1024 * 1024 * 1024) // Maximum number of TPC clusters
-#define GPUCA_MAX_TRD_TRACKLETS      ((size_t)             128 * 1024) // Maximum number of TRD tracklets
-#define GPUCA_MAX_ITS_FIT_TRACKS     ((size_t)              96 * 1024) // Max number of tracks for ITS track fit
-#define GPUCA_MEMORY_SIZE            ((size_t) 6 * 1024 * 1024 * 1024) // Size of memory allocated on Device
-#define GPUCA_HOST_MEMORY_SIZE       ((size_t) 1 * 1024 * 1024 * 1024) // Size of memory allocated on Host
-#define GPUCA_GPU_STACK_SIZE         ((size_t)               8 * 1024) // Stack size per GPU thread
-#define GPUCA_GPU_HEAP_SIZE          ((size_t)       16 * 1025 * 1024) // Stack size per GPU thread
-
-// #define GPUCA_KERNEL_DEBUGGER_OUTPUT
-
-// Some assertions to make sure the parameters are not invalid
-#if defined(GPUCA_GPUCODE)
-  static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP, "Invalid GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP");
-  static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE");
-  static_assert(GPUCA_M_FIRST(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE, "Invalid GPUCA_TPC_COMP_CHUNK_SIZE");
-#endif
-
-// Derived parameters
-#ifdef GPUCA_USE_TEXTURES
-  #define GPUCA_TEXTURE_FETCH_CONSTRUCTOR                              // Fetch data through texture cache
-#endif
-#if defined(GPUCA_SORT_STARTHITS_GPU) && defined(GPUCA_GPUCODE)
-  #define GPUCA_SORT_STARTHITS
 #endif
 
 // clang-format on
-#endif // GPUDEFPARAMETERSDEFAULT_H
+#endif // GPUDEFPARAMETERSDEFAULTS_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
index c17244572ee0c..edec6530c1c5d 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
@@ -18,7 +18,7 @@
 #define GPUCA_M_LB_EMPTY_1(...) __VA_ARGS__
 #define GPUCA_M_LB_EMPTY0(...) GPUCA_M_CAT(GPUCA_M_LB_EMPTY_, __VA_OPT__(1))(__VA_ARGS__)
 
-#include "GPUDefParameters.h"
+#include "GPUDefParametersRuntime.h"
 #include "GPUDefMacros.h"
 #include <sstream>
 #include <string>
diff --git a/GPU/GPUTracking/Definitions/GPUDefParameters.template.h b/GPU/GPUTracking/Definitions/GPUDefParametersRuntime.template.h
similarity index 87%
rename from GPU/GPUTracking/Definitions/GPUDefParameters.template.h
rename to GPU/GPUTracking/Definitions/GPUDefParametersRuntime.template.h
index 731cb76b89193..f3537c058a824 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParameters.template.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersRuntime.template.h
@@ -9,11 +9,11 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUDefParameters.h
+/// \file GPUDefParametersRuntime.h
 /// \author David Rohr
 
-#ifndef GPUDEFPARAMETERS_H
-#define GPUDEFPARAMETERS_H
+#ifndef GPUDEFPARAMETERSRUNTIME_H
+#define GPUDEFPARAMETERSRUNTIME_H
 
 namespace o2::gpu
 {
@@ -24,4 +24,4 @@ struct GPUDefParameters {  // clang-format off
 };  // clang-format on
 }  // namespace o2::gpu
 
-#endif
+#endif  // GPUDEFPARAMETERSRUNTIME_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
new file mode 100644
index 0000000000000..7f2bb271d18c8
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -0,0 +1,66 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDefParametersWrapper.h
+/// \author David Rohr
+
+// Wrapper file to load all compile-time parameters (architecture / rtc - dependent ones, and constant ones)
+// Compile-time constants affecting the tracking algorithms / results are located in GPUDefConstantsAndSettings.h
+
+#ifndef GPUDEFPARAMETERSWRAPPER_H
+#define GPUDEFPARAMETERSWRAPPER_H
+// clang-format off
+
+#include "GPUCommonDef.h"
+#include "GPUDefMacros.h"
+
+#ifndef GPUCA_GPUCODE_GENRTC
+#include "GPUDefParametersDefaults.h"
+#endif
+#include "GPUDefParametersConstants.h"
+
+#ifdef GPUCA_GPUCODE
+  #define GPUCA_GET_THREAD_COUNT(...) GPUCA_M_FIRST(__VA_ARGS__)
+#else
+  #define GPUCA_GET_THREAD_COUNT(...) 1 // On the host, a thread is a block, and we run 1 "device thread" per block.
+#endif
+
+#define GPUCA_GET_WARP_COUNT(...) (GPUCA_GET_THREAD_COUNT(__VA_ARGS__) / GPUCA_WARP_SIZE)
+
+#define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)
+#define GPUCA_DEDX_STORAGE_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_DEDX_STORAGE_TYPE)
+
+#ifndef GPUCA_WARP_SIZE
+  #ifdef GPUCA_GPUCODE
+    #define GPUCA_WARP_SIZE 32
+  #else
+    #define GPUCA_WARP_SIZE 1
+  #endif
+#endif
+
+// #define GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE                       // Output Profiling Data for Tracklet Constructor Tracklet Scheduling
+
+// #define GPUCA_KERNEL_DEBUGGER_OUTPUT
+
+// Some assertions to make sure the parameters are not invalid
+#if defined(GPUCA_GPUCODE)
+  static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP, "Invalid GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP");
+  static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE");
+  static_assert(GPUCA_M_FIRST(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE, "Invalid GPUCA_TPC_COMP_CHUNK_SIZE");
+#endif
+
+// Derived parameters
+#ifdef GPUCA_USE_TEXTURES
+  #define GPUCA_TEXTURE_FETCH_CONSTRUCTOR                              // Fetch data through texture cache
+#endif
+
+// clang-format on
+#endif // GPUDEFPARAMETERSWRAPPER_H
diff --git a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
index 4a72b0cef31a3..785c049816252 100644
--- a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
+++ b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
@@ -16,14 +16,15 @@
 // ROOT_INCLUDE_PATH="`pwd`/include" root -l -q -b src/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C'()'
 
 // Logic for testing to load the default parameters
-/*#define GPUCA_GPUCODE
+/* #define GPUCA_GPUCODE
 #define GPUCA_GPUTYPE_AMPERE
 #define GPUCA_MAXN 40
 #define GPUCA_ROW_COUNT 152
 #define GPUCA_TPC_COMP_CHUNK_SIZE 1024
-#include "GPUDefParametersDefault.h"*/
+#include "GPUDefParametersConstants.h"
+#include "GPUDefParametersDefaults.h" */
 
-// Load file that sets GPUDefParameters
+// Alternatively, logic to load file that sets GPUDefParameters
 #include "testParam.h"
 
 #include "GPUDefParametersLoad.inc"

From 260d7d579864cb8ab91fd2d40278b52b66e7b2d8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 13 Apr 2025 20:05:43 +0200
Subject: [PATCH 0235/1764] GPU CUDA/HIP: Set warp size automatically, not
 hard-coded

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu       | 9 +++------
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx            | 3 ++-
 GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h   | 3 +++
 GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h    | 8 --------
 4 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index f475929d49d50..47a9b675d27f6 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -111,6 +111,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
   constexpr int32_t reqVerMin = 0;
 #endif
   if (mProcessingSettings.rtc.enable && mProcessingSettings.rtctech.runTest == 2) {
+    mWarpSize = GPUCA_WARP_SIZE;
     genAndLoadRTC();
     exit(0);
   }
@@ -244,16 +245,12 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUInfo("\ttextureAlignment = %ld", (uint64_t)deviceProp.textureAlignment);
       GPUInfo(" ");
     }
-    if (deviceProp.warpSize != GPUCA_WARP_SIZE) {
+    if (deviceProp.warpSize != GPUCA_WARP_SIZE && !mProcessingSettings.rtc.enable) {
       throw std::runtime_error("Invalid warp size on GPU");
     }
+    mWarpSize = deviceProp.warpSize;
     mBlockCount = deviceProp.multiProcessorCount;
     mMaxBackendThreads = std::max<int32_t>(mMaxBackendThreads, deviceProp.maxThreadsPerBlock * mBlockCount);
-#ifndef __HIPCC__ // CUDA
-    mWarpSize = 32;
-#else // HIP
-    mWarpSize = 64;
-#endif
     mDeviceName = deviceProp.name;
     mDeviceName += " (CUDA GPU)";
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index 5f481d2cb9058..abcd47ca01c90 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -73,7 +73,8 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     }
     fclose(fp);
   }
-  const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true);
+  const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true) +
+                                   "#define GPUCA_WARP_SIZE " + std::to_string(mWarpSize) + "\n";
   if (mProcessingSettings.rtctech.printLaunchBounds || mProcessingSettings.debugLevel >= 3) {
     GPUInfo("RTC Launch Bounds:\n%s", launchBounds.c_str());
   }
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 360fb1ffb5269..396934e17da82 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -275,6 +275,9 @@
 
 #ifdef GPUCA_GPUCODE
   // Default settings for GPU, if not already set for selected GPU type
+  #ifndef GPUCA_WARP_SIZE
+    #define GPUCA_WARP_SIZE 32
+  #endif
   #ifndef GPUCA_THREAD_COUNT_DEFAULT
     #define GPUCA_THREAD_COUNT_DEFAULT 256
   #endif
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
index 7f2bb271d18c8..114c8d229b493 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -38,14 +38,6 @@
 #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)
 #define GPUCA_DEDX_STORAGE_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_DEDX_STORAGE_TYPE)
 
-#ifndef GPUCA_WARP_SIZE
-  #ifdef GPUCA_GPUCODE
-    #define GPUCA_WARP_SIZE 32
-  #else
-    #define GPUCA_WARP_SIZE 1
-  #endif
-#endif
-
 // #define GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE                       // Output Profiling Data for Tracklet Constructor Tracklet Scheduling
 
 // #define GPUCA_KERNEL_DEBUGGER_OUTPUT

From a87ed76713dd648eecba500001afc682663ad46f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 13 Apr 2025 20:54:30 +0200
Subject: [PATCH 0236/1764] GPU: Switch some preprocessor defines to constexpr

---
 .../Definitions/GPUDefParametersWrapper.h       | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
index 114c8d229b493..ce7889fe7fadd 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -27,14 +27,17 @@
 #endif
 #include "GPUDefParametersConstants.h"
 
-#ifdef GPUCA_GPUCODE
-  #define GPUCA_GET_THREAD_COUNT(...) GPUCA_M_FIRST(__VA_ARGS__)
+namespace o2::gpu
+{
+#if defined(GPUCA_GPUCODE)
+  GPUhdi() static constexpr uint32_t GPUCA_GET_THREAD_COUNT(uint32_t val, ...) { return val; }
+  GPUhdi() static constexpr uint32_t GPUCA_GET_WARP_COUNT(uint32_t val, ...) { return val / GPUCA_WARP_SIZE; }
 #else
-  #define GPUCA_GET_THREAD_COUNT(...) 1 // On the host, a thread is a block, and we run 1 "device thread" per block.
+  static constexpr uint32_t GPUCA_WARP_SIZE = 1; // On the host, a thread is a block is a warp, and we run 1 "device thread" per block.
+  #define GPUCA_GET_THREAD_COUNT(...) 1          // This must be a define not a constexpr function
+  #define GPUCA_GET_WARP_COUNT(...) 1            // since launch bound constants are not defined in host-code, and must evaluate to 1!
 #endif
 
-#define GPUCA_GET_WARP_COUNT(...) (GPUCA_GET_THREAD_COUNT(__VA_ARGS__) / GPUCA_WARP_SIZE)
-
 #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)
 #define GPUCA_DEDX_STORAGE_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_DEDX_STORAGE_TYPE)
 
@@ -46,7 +49,7 @@
 #if defined(GPUCA_GPUCODE)
   static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP, "Invalid GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP");
   static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE");
-  static_assert(GPUCA_M_FIRST(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE, "Invalid GPUCA_TPC_COMP_CHUNK_SIZE");
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE, "Invalid GPUCA_TPC_COMP_CHUNK_SIZE");
 #endif
 
 // Derived parameters
@@ -54,5 +57,7 @@
   #define GPUCA_TEXTURE_FETCH_CONSTRUCTOR                              // Fetch data through texture cache
 #endif
 
+} // namespace o2::gpu
+
 // clang-format on
 #endif // GPUDEFPARAMETERSWRAPPER_H

From 504bb9cb6102b535ff8f69e137b8d056cdbe043f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 13 Apr 2025 20:55:00 +0200
Subject: [PATCH 0237/1764] GPU: Get rid of GPUCA_RTC_LB_..., use only
 GPUCA_LB_...

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  2 +-
 .../Base/cuda/GPUReconstructionCUDA.h         |  3 +-
 .../GPUReconstructionCUDAIncludesSystem.h     |  6 ++--
 .../Base/cuda/GPUReconstructionCUDAKernels.cu | 11 -------
 .../cuda/GPUReconstructionCUDARTCCalls.cu     | 32 +++++++++++++++++++
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  4 +--
 .../hip/GPUReconstructionHIPIncludesSystem.h  |  6 ++--
 .../Definitions/GPUDefParametersDefaults.h    |  2 +-
 .../GPUDefParametersLoad.template.inc         | 22 ++++++-------
 .../Definitions/GPUDefParametersWrapper.h     |  4 +--
 10 files changed, 56 insertions(+), 36 deletions(-)
 create mode 100644 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index e17f1fcd7091e..3655eaf66055e 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -17,7 +17,7 @@ if(DEFINED CUDA_COMPUTETARGET)
 endif()
 message(STATUS "Building GPUTracking with CUDA support ${TMP_TARGET}")
 
-set(SRCS GPUReconstructionCUDA.cu GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu)
+set(SRCS GPUReconstructionCUDA.cu GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDARTCCalls.cu)
 set(HDRS GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDADef.h GPUReconstructionCUDAIncludesSystem.h)
 # -------------------------------- Prepare RTC -------------------------------------------------------
 enable_language(ASM)
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index ac5920f769f25..3441c6b9a4fd6 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -45,8 +45,6 @@ class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
 
-  void getRTCKernelCalls(std::vector<std::string>& kernels);
-
   template <class T, class S>
   friend GPUh() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp);
   GPUReconstructionCUDAInternals* mInternals;
@@ -91,6 +89,7 @@ class GPUReconstructionCUDA : public GPUReconstructionKernels<GPUReconstructionC
 
  private:
   int32_t genRTC(std::string& filename, uint32_t& nCompile);
+  void getRTCKernelCalls(std::vector<std::string>& kernels);
   void genAndLoadRTC();
   void loadKernelModules(bool perKernel);
   const char *mRtcSrcExtension = ".src", *mRtcBinExtension = ".o";
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
index 1cb3679fc30dc..3f072059a9ad7 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
@@ -12,8 +12,8 @@
 /// \file GPUReconstructionCUDAIncludesSystem.h
 /// \author David Rohr
 
-#ifndef O2_GPU_GPURECONSTRUCTIONCUDAINCLUDES_H
-#define O2_GPU_GPURECONSTRUCTIONCUDAINCLUDES_H
+#ifndef O2_GPU_GPURECONSTRUCTIONCUDAINCLUDESSYSTEM_H
+#define O2_GPU_GPURECONSTRUCTIONCUDAINCLUDESSYSTEM_H
 
 #include <cstdint>
 #include <type_traits>
@@ -32,4 +32,4 @@
 #include <sm_20_atomic_functions.h>
 #include <cuda_fp16.h>
 
-#endif
+#endif // O2_GPU_GPURECONSTRUCTIONCUDAINCLUDESSYSTEM_H
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index f8efd8428f035..cf08785e6b3d5 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -118,14 +118,3 @@ static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstS
   return retVal;
 });
 #endif
-
-void GPUReconstructionCUDABackend::getRTCKernelCalls(std::vector<std::string>& kernels)
-{
-#undef GPUCA_KRNL_LB
-#undef __launch_bounds__
-#define GPUCA_KRNL(...) kernels.emplace_back(GPUCA_M_STR(GPUCA_KRNLGPU(__VA_ARGS__)));
-#define GPUCA_KRNL_LB(x_class, x_attributes, ...) GPUCA_KRNL(x_class, (REG, (GPUCA_M_CAT(GPUCA_RTC_LB_, GPUCA_M_KRNL_NAME(x_class))), GPUCA_M_STRIP(x_attributes)), __VA_ARGS__)
-#include "GPUReconstructionKernelList.h"
-#undef GPUCA_KRNL
-#undef GPUCA_KRNL_LB
-}
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu
new file mode 100644
index 0000000000000..571428dc39e21
--- /dev/null
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu
@@ -0,0 +1,32 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUReconstructionCUDARTCCalls.cu
+/// \author David Rohr
+
+#define GPUCA_GPUCODE_HOSTONLY
+#define GPUCA_GPUCODE_NO_LAUNCH_BOUNDS
+
+#define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_STRIP(args))
+
+#include "GPUReconstructionCUDAIncludesSystem.h"
+#include "GPUReconstructionCUDADef.h"
+#include "GPUReconstructionCUDA.h"
+
+using namespace o2::gpu;
+
+void GPUReconstructionCUDA::getRTCKernelCalls(std::vector<std::string>& kernels)
+{
+#undef GPUCA_KRNL
+#define GPUCA_KRNL(...) kernels.emplace_back(GPUCA_M_STR(GPUCA_KRNLGPU(__VA_ARGS__)));
+#undef __launch_bounds__
+#include "GPUReconstructionKernelList.h"
+}
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 9a9b1e36a167c..55211e5ff10f6 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -24,7 +24,7 @@ message(STATUS "Building GPUTracking with HIP support ${TMP_TARGET}")
 if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   set(GPUCA_HIP_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/hipify)
   file(MAKE_DIRECTORY ${GPUCA_HIP_SOURCE_DIR})
-  set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDAkernel.template.cu GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDArtc.cu)
+  set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDAkernel.template.cu GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDArtc.cu GPUReconstructionCUDARTCCalls.cu)
   set(GPUCA_HIP_LOCAL_FILE_LIST GPUReconstructionHIPIncludesSystem.h)
   set(HIP_SOURCES "")
   foreach(file ${GPUCA_HIP_FILE_LIST})
@@ -61,7 +61,7 @@ else()
   get_filename_component(GPUCA_HIP_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} ABSOLUTE)
 endif()
 
-set(SRCS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.hip ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPKernels.hip)
+set(SRCS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.hip ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPKernels.hip ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPRTCCalls.hip)
 set(SRCS_CXX ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPGenRTC.cxx)
 set(HDRS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPInternals.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPHelpers.inc ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPDef.h ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPIncludesSystem.h)
 
diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
index cfe1121ef1089..1a3a1ff0108af 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
@@ -12,8 +12,8 @@
 /// \file GPUReconstructionHIPIncludesSystem.h
 /// \author David Rohr
 
-#ifndef O2_GPU_RECONSTRUCTIONHIPINCLUDES_H
-#define O2_GPU_RECONSTRUCTIONHIPINCLUDES_H
+#ifndef O2_GPU_RECONSTRUCTIONHIPINCLUDESSYSTEM_H
+#define O2_GPU_RECONSTRUCTIONHIPINCLUDESSYSTEM_H
 
 #include <hip/hip_runtime.h>
 #include <hip/hip_ext.h>
@@ -25,4 +25,4 @@
 #include <thrust/device_ptr.h>
 #pragma GCC diagnostic pop
 
-#endif
+#endif // O2_GPU_RECONSTRUCTIONHIPINCLUDESSYSTEM_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 396934e17da82..406fb5e8048d6 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -14,7 +14,7 @@
 
 // This file contains compile-time constants affecting the GPU performance.
 
-#ifndef GPUDEFPARAMETERSDEFAULTS_H
+#if !defined(GPUDEFPARAMETERSDEFAULTS_H) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.
 #define GPUDEFPARAMETERSDEFAULTS_H
 // clang-format off
 
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
index edec6530c1c5d..938cedbdacc93 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
@@ -37,17 +37,17 @@ static GPUDefParameters GPUDefParametersLoad()
   };
 }
 
-#define GPUCA_EXPORT_KERNEL(name)                                                                                  \
-  if (par.par_LB_maxThreads[i] > 0) {                                                                              \
-    o << "#define GPUCA_" << (forRTC ? "RTC_" : "") << "LB_" << GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i]; \
-    if (par.par_LB_minBlocks[i] > 0) {                                                                             \
-      o << ", " << par.par_LB_minBlocks[i];                                                                        \
-    }                                                                                                              \
-    if (!forRTC && par.par_LB_forceBlocks[i] > 0) {                                                                \
-      o << ", " << par.par_LB_forceBlocks[i];                                                                      \
-    }                                                                                                              \
-    o << "\n";                                                                                                     \
-  }                                                                                                                \
+#define GPUCA_EXPORT_KERNEL(name)                                                  \
+  if (par.par_LB_maxThreads[i] > 0) {                                              \
+    o << "#define GPUCA_LB_" << GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i]; \
+    if (par.par_LB_minBlocks[i] > 0) {                                             \
+      o << ", " << par.par_LB_minBlocks[i];                                        \
+    }                                                                              \
+    if (!forRTC && par.par_LB_forceBlocks[i] > 0) {                                \
+      o << ", " << par.par_LB_forceBlocks[i];                                      \
+    }                                                                              \
+    o << "\n";                                                                     \
+  }                                                                                \
   i++;
 
 static std::string GPUDefParametersExport(const GPUDefParameters& par, bool forRTC)
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
index ce7889fe7fadd..b61312b7b04be 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -22,14 +22,14 @@
 #include "GPUCommonDef.h"
 #include "GPUDefMacros.h"
 
-#ifndef GPUCA_GPUCODE_GENRTC
+#if defined(GPUCA_GPUCODE)
 #include "GPUDefParametersDefaults.h"
 #endif
 #include "GPUDefParametersConstants.h"
 
 namespace o2::gpu
 {
-#if defined(GPUCA_GPUCODE)
+#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)
   GPUhdi() static constexpr uint32_t GPUCA_GET_THREAD_COUNT(uint32_t val, ...) { return val; }
   GPUhdi() static constexpr uint32_t GPUCA_GET_WARP_COUNT(uint32_t val, ...) { return val / GPUCA_WARP_SIZE; }
 #else

From 731144f9b7ea49b5001e3c0acfca7edd2970b184 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 13 Apr 2025 22:17:17 +0200
Subject: [PATCH 0238/1764] GPU HIP: Don't hipify cxx files

---
 GPU/GPUTracking/Base/hip/CMakeLists.txt | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 55211e5ff10f6..3a03a054d4a7e 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -30,14 +30,24 @@ if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   foreach(file ${GPUCA_HIP_FILE_LIST})
     get_filename_component(ABS_CUDA_SORUCE ../cuda/${file} ABSOLUTE)
     get_filename_component(CUDA_SOURCE ${file} NAME)
+    get_filename_component(CUDA_SOURCE_EXT ${file} EXT)
     string(REPLACE ".cu" ".hip" HIP_SOURCE1 ${CUDA_SOURCE})
     string(REPLACE "CUDA" "HIP" HIP_SOURCE ${HIP_SOURCE1})
-    add_custom_command(
-      OUTPUT ${GPUCA_HIP_SOURCE_DIR}/${HIP_SOURCE}
-      COMMAND ${hip_HIPIFY_PERL_EXECUTABLE} --quiet-warnings ${ABS_CUDA_SORUCE} | sed -e 's/CUDA/HIP/g' -e 's/cuda/hip/g' > ${GPUCA_HIP_SOURCE_DIR}/${HIP_SOURCE}
-      DEPENDS ${ABS_CUDA_SORUCE}
-      COMMENT "Hippifying ${HIP_SOURCE}"
-    )
+    if(CUDA_SOURCE_EXT STREQUAL ".cu" OR CUDA_SOURCE_EXT STREQUAL ".h")
+      add_custom_command(
+        OUTPUT ${GPUCA_HIP_SOURCE_DIR}/${HIP_SOURCE}
+        COMMAND ${hip_HIPIFY_PERL_EXECUTABLE} --quiet-warnings ${ABS_CUDA_SORUCE} | sed -e 's/CUDA/HIP/g' -e 's/cuda/hip/g' > ${GPUCA_HIP_SOURCE_DIR}/${HIP_SOURCE}
+        DEPENDS ${ABS_CUDA_SORUCE}
+        COMMENT "Hippifying ${HIP_SOURCE}"
+      )
+    else()
+      add_custom_command(
+        OUTPUT ${GPUCA_HIP_SOURCE_DIR}/${HIP_SOURCE}
+        COMMAND sed -e 's/CUDA/HIP/g' -e 's/cuda/hip/g' ${ABS_CUDA_SORUCE} > ${GPUCA_HIP_SOURCE_DIR}/${HIP_SOURCE}
+        DEPENDS ${ABS_CUDA_SORUCE}
+        COMMENT "Generating HIP source ${HIP_SOURCE}"
+      )
+    endif()
     list(APPEND HIP_SOURCES "${GPUCA_HIP_SOURCE_DIR}/${HIP_SOURCE}")
   endforeach()
   foreach(file ${GPUCA_HIP_LOCAL_FILE_LIST})

From 3812d54df627c334249c6ca29a4b7615694f7dbb Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 13 Apr 2025 22:31:00 +0200
Subject: [PATCH 0239/1764] GPU: Fix some global preprocessor defines that were
 used incorrectly

---
 GPU/Common/GPUCommonDefAPI.h                   |  2 +-
 .../GPUTPCCompressionKernels.cxx               |  3 +++
 .../DataCompression/GPUTPCCompressionKernels.h | 18 +++++++++++-------
 .../Definitions/GPUDefParametersDefaults.h     |  2 --
 .../Definitions/GPUDefParametersWrapper.h      |  7 -------
 .../SectorTracker/GPUTPCNeighboursFinder.h     |  1 +
 .../SectorTracker/GPUTPCTrackletSelector.h     |  1 +
 .../GPUTPCCFNoiseSuppression.h                 |  4 +++-
 .../GPUTPCCFStreamCompaction.h                 |  7 +++++++
 .../GPUTPCNNClusterizerKernels.h               |  8 +++++++-
 10 files changed, 34 insertions(+), 19 deletions(-)

diff --git a/GPU/Common/GPUCommonDefAPI.h b/GPU/Common/GPUCommonDefAPI.h
index f7efbf7e976d4..b029038a3b521 100644
--- a/GPU/Common/GPUCommonDefAPI.h
+++ b/GPU/Common/GPUCommonDefAPI.h
@@ -43,7 +43,7 @@
   #define GPUhd()                                   // Host and device function, inlined during GPU compilation to avoid symbol clashes in host code
   #define GPUhdi() inline                           // Host and device function, to-be-inlined on host and device
   #define GPUhdni()                                 // Host and device function, not to-be-inlined automatically
-  #define GPUg() INVALID_TRIGGER_ERROR_NO_HOST_CODE // GPU kernel
+  #define GPUg() INVALID_TRIGGER_ERROR_NO_GPU_CODE  // GPU kernel
   #define GPUshared()                               // shared memory variable declaration
   #define GPUglobal()                               // global memory variable declaration (only used for kernel input pointers)
   #define GPUconstant()                             // constant memory variable declaraion
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 445c03113cd39..5dbbf63ca8264 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -258,6 +258,9 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
         break;
       }
       if (param.rec.tpc.compressionTypeMask & GPUSettings::CompressionDifferences) {
+#ifdef GPUCA_GPUCODE
+        static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE);
+#endif
         if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZPadTime) {
           CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>(clusters->clusters[iSector][iRow]));
         } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZTimePad) {
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
index b0bb8a6c12ecc..81817abf1e6d6 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
@@ -72,15 +72,19 @@ class GPUTPCCompressionGatherKernels : public GPUKernelTemplate
   using Vec64 = uint64_t;
   using Vec128 = uint4;
 
-  struct GPUSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<uint32_t, GPUCA_GET_THREAD_COUNT(GPUCA_LB_COMPRESSION_GATHER)> {
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_buffered32));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_buffered128));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_multiBlock));
+  struct GPUSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<uint32_t, GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered)> {
     union {
-      uint32_t warpOffset[GPUCA_GET_WARP_COUNT(GPUCA_LB_COMPRESSION_GATHER)];
-      Vec32 buf32[GPUCA_GET_WARP_COUNT(GPUCA_LB_COMPRESSION_GATHER)][GPUCA_WARP_SIZE];
-      Vec64 buf64[GPUCA_GET_WARP_COUNT(GPUCA_LB_COMPRESSION_GATHER)][GPUCA_WARP_SIZE];
-      Vec128 buf128[GPUCA_GET_WARP_COUNT(GPUCA_LB_COMPRESSION_GATHER)][GPUCA_WARP_SIZE];
+      uint32_t warpOffset[GPUCA_GET_WARP_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered)];
+      Vec32 buf32[GPUCA_GET_WARP_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered)][GPUCA_WARP_SIZE];
+      Vec64 buf64[GPUCA_GET_WARP_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered)][GPUCA_WARP_SIZE];
+      Vec128 buf128[GPUCA_GET_WARP_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered)][GPUCA_WARP_SIZE];
       struct {
-        uint32_t sizes[GPUCA_GET_WARP_COUNT(GPUCA_LB_COMPRESSION_GATHER)][GPUCA_WARP_SIZE];
-        uint32_t srcOffsets[GPUCA_GET_WARP_COUNT(GPUCA_LB_COMPRESSION_GATHER)][GPUCA_WARP_SIZE];
+        uint32_t sizes[GPUCA_GET_WARP_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered)][GPUCA_WARP_SIZE];
+        uint32_t srcOffsets[GPUCA_GET_WARP_COUNT(GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered)][GPUCA_WARP_SIZE];
       } unbuffered;
     };
 
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 406fb5e8048d6..83ef7d8cf810b 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -492,14 +492,12 @@
   #define GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression GPUCA_LB_GPUTPCCFNoiseSuppression
   #define GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks GPUCA_LB_GPUTPCCFNoiseSuppression
 
-  #ifdef GPUCA_HAS_ONNX
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression GPUCA_LB_GPUTPCNNClusterizerKernels
-  #endif
 
   #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_THREAD_COUNT_SCAN
   #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_THREAD_COUNT_SCAN
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
index b61312b7b04be..beeefa4eb5f9d 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -45,13 +45,6 @@ namespace o2::gpu
 
 // #define GPUCA_KERNEL_DEBUGGER_OUTPUT
 
-// Some assertions to make sure the parameters are not invalid
-#if defined(GPUCA_GPUCODE)
-  static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP, "Invalid GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP");
-  static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE, "Invalid GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE");
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE, "Invalid GPUCA_TPC_COMP_CHUNK_SIZE");
-#endif
-
 // Derived parameters
 #ifdef GPUCA_USE_TEXTURES
   #define GPUCA_TEXTURE_FETCH_CONSTRUCTOR                              // Fetch data through texture cache
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
index 41b5eb8a4ffb8..1bf5000cfbe5c 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
@@ -41,6 +41,7 @@ class GPUTPCNeighboursFinder : public GPUKernelTemplate
     int32_t mIRowUp; // next row number
     int32_t mIRowDn; // previous row number
 #if GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP > 0
+    static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP);
     float mA1[GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
     float mA2[GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
     calink mB[GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
index 5009c672b030e..f487931bdaf4b 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
@@ -37,6 +37,7 @@ class GPUTPCTrackletSelector : public GPUKernelTemplate
     int32_t mNTracklets;    // n of tracklets
     int32_t mReserved;      // for alignment reasons
 #if GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+    static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE);
     GPUTPCHitId mHits[GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletSelector)];
 #endif // GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
   };
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
index f5d8f533df651..71236bc317443 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
@@ -34,7 +34,9 @@ class GPUTPCCFNoiseSuppression : public GPUKernelTemplate
     noiseSuppression = 0,
     updatePeaks = 1,
   };
-  static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFNoiseSuppression);
+  static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression);
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks));
+
   struct GPUSharedMemory {
     ChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
     PackedCharge buf[SCRATCH_PAD_WORK_GROUP_SIZE * SCRATCH_PAD_NOISE_N];
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
index 25d3588be6d17..a72907fe55e89 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
@@ -37,6 +37,13 @@ class GPUTPCCFStreamCompaction : public GPUKernelTemplate
 
   struct GPUSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<int32_t, GPUCA_THREAD_COUNT_SCAN> {
   };
+#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)
+  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanStart));
+  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanUp));
+  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanTop));
+  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanDown));
+  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits));
+#endif
 
   typedef GPUTPCClusterFinder processorType;
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index e6c1dc508d6e4..a1d641fdb0b93 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -37,7 +37,13 @@ class MCLabelAccumulator;
 class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
 {
  public:
-  static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels);
+  // Must all have same number of threads, since they use a common SCRATCH_PAD_WORK_GROUP_SIZE below
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
+  static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer);
   struct GPUSharedMemory {
     // Regular cluster finder
     ChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];

From da00550e828dad4617bc4730797d154e4bf79858 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 13 Apr 2025 23:10:44 +0200
Subject: [PATCH 0240/1764] GPU: Temporarily move some defines back to the
 wrapper, to be cleaned up in another PR

---
 .../Definitions/GPUDefParametersDefaults.h    | 40 ---------------
 .../Definitions/GPUDefParametersWrapper.h     | 50 ++++++++++++++++++-
 2 files changed, 49 insertions(+), 41 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 83ef7d8cf810b..ce703e2ceba4a 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -75,16 +75,6 @@
   #define GPUCA_LB_GPUTPCCFDeconvolution 512
   #define GPUCA_LB_GPUTPCCFClusterizer 448
   #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_VEGA)
   #define GPUCA_WARP_SIZE 64
   #define GPUCA_THREAD_COUNT_DEFAULT 256
@@ -138,16 +128,6 @@
   #define GPUCA_LB_GPUTPCCFDeconvolution 512
   #define GPUCA_LB_GPUTPCCFClusterizer 512
   #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_AMPERE)
   #define GPUCA_WARP_SIZE 32
   #define GPUCA_THREAD_COUNT_DEFAULT 512
@@ -201,16 +181,6 @@
   #define GPUCA_LB_GPUTPCCFDeconvolution 384
   #define GPUCA_LB_GPUTPCCFClusterizer 448
   #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_TURING)
   #define GPUCA_WARP_SIZE 32
   #define GPUCA_THREAD_COUNT_DEFAULT 512
@@ -256,16 +226,6 @@
   #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
   #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
   #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
   // #define GPUCA_USE_TEXTURES
 #elif defined(GPUCA_GPUTYPE_OPENCL)
 #else
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
index beeefa4eb5f9d..8d8815d8a8044 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -22,7 +22,55 @@
 #include "GPUCommonDef.h"
 #include "GPUDefMacros.h"
 
-#if defined(GPUCA_GPUCODE)
+#ifdef GPUCA_GPUCODE
+#if defined(GPUCA_GPUTYPE_MI2xx)
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+  #define GPUCA_ALTERNATE_BORDER_SORT 1
+  #define GPUCA_SORT_BEFORE_FIT 1
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
+  #define GPUCA_NO_ATOMIC_PRECHECK 1
+  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
+  #define GPUCA_COMP_GATHER_KERNEL 4
+  #define GPUCA_COMP_GATHER_MODE 3
+#elif defined(GPUCA_GPUTYPE_VEGA)
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+  #define GPUCA_ALTERNATE_BORDER_SORT 1
+  #define GPUCA_SORT_BEFORE_FIT 1
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
+  #define GPUCA_NO_ATOMIC_PRECHECK 1
+  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
+  #define GPUCA_COMP_GATHER_KERNEL 4
+  #define GPUCA_COMP_GATHER_MODE 3
+#elif defined(GPUCA_GPUTYPE_AMPERE)
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+  #define GPUCA_ALTERNATE_BORDER_SORT 1
+  #define GPUCA_SORT_BEFORE_FIT 1
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
+  #define GPUCA_NO_ATOMIC_PRECHECK 1
+  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
+  #define GPUCA_COMP_GATHER_KERNEL 4
+  #define GPUCA_COMP_GATHER_MODE 3
+#elif defined(GPUCA_GPUTYPE_TURING)
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+  #define GPUCA_ALTERNATE_BORDER_SORT 1
+  #define GPUCA_SORT_BEFORE_FIT 1
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
+  #define GPUCA_NO_ATOMIC_PRECHECK 1
+  #define GPUCA_COMP_GATHER_KERNEL 4
+  #define GPUCA_COMP_GATHER_MODE 3
+  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
+#endif
+#endif
+
+#ifdef GPUCA_GPUCODE
 #include "GPUDefParametersDefaults.h"
 #endif
 #include "GPUDefParametersConstants.h"

From a946be89a02079eb7d8169b23137303cbbab8aa7 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Mon, 14 Apr 2025 11:17:23 +0200
Subject: [PATCH 0241/1764] GPU: remove automatic workaround for MI100 memory
 errors

---
 prodtests/full-system-test/dpl-workflow.sh | 1 -
 1 file changed, 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 2dfc74e3ecfb3..bb2712bedd92e 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -265,7 +265,6 @@ if [[ $GPUTYPE == "HIP" ]]; then
     TIMESLICEOFFSET=$(($GPU_FIRST_ID + ($NUMAGPUIDS != 0 ? ($NGPUS * $NUMAID) : 0)))
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
-  [[ $EPNSYNCMODE == 1 || ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else
   GPU_CONFIG_KEY+="GPU_proc.deviceNum=-2;"

From 466ba06a25b9cebf15601a5db4a33b835fee170f Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 15 Apr 2025 13:21:21 +0200
Subject: [PATCH 0242/1764] DPL Analysis: introduce binned expression (#14174)

---
 .../include/Framework/ExpressionHelpers.h     |  12 --
 .../Core/include/Framework/Expressions.h      | 131 +++++++++++++++++-
 Framework/Core/src/Expressions.cxx            |  34 ++---
 Framework/Core/test/test_Expressions.cxx      |  27 +++-
 4 files changed, 162 insertions(+), 42 deletions(-)

diff --git a/Framework/Core/include/Framework/ExpressionHelpers.h b/Framework/Core/include/Framework/ExpressionHelpers.h
index b531a39519272..f881abf7b0e6c 100644
--- a/Framework/Core/include/Framework/ExpressionHelpers.h
+++ b/Framework/Core/include/Framework/ExpressionHelpers.h
@@ -75,18 +75,6 @@ struct ColumnOperationSpec {
     result.type = type;
   }
 };
-
-/// helper struct used to parse trees
-struct NodeRecord {
-  /// pointer to the actual tree node
-  Node* node_ptr = nullptr;
-  size_t index = 0;
-  explicit NodeRecord(Node* node_, size_t index_) : node_ptr(node_), index{index_} {}
-  bool operator!=(NodeRecord const& rhs)
-  {
-    return this->node_ptr != rhs.node_ptr;
-  }
-};
 } // namespace o2::framework::expressions
 
 #endif // O2_FRAMEWORK_EXPRESSIONS_HELPERS_H_
diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 1d2883418de71..af89e56f85835 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -41,6 +41,7 @@ class Projector;
 #include <string>
 #include <memory>
 #include <set>
+#include <stack>
 namespace gandiva
 {
 using Selection = std::shared_ptr<gandiva::SelectionVector>;
@@ -114,6 +115,8 @@ struct LiteralNode {
   {
   }
 
+  LiteralNode(LiteralNode const& other) = default;
+
   using var_t = LiteralValue::stored_type;
   var_t value;
   atype::type type = atype::NA;
@@ -132,6 +135,7 @@ struct BindingNode {
 /// An expression tree node corresponding to binary or unary operation
 struct OpNode {
   OpNode(BasicOp op_) : op{op_} {}
+  OpNode(OpNode const& other) = default;
   BasicOp op;
 };
 
@@ -147,6 +151,8 @@ struct PlaceholderNode : LiteralNode {
     }
   }
 
+  PlaceholderNode(PlaceholderNode const& other) = default;
+
   void reset(InitContext& context)
   {
     value = retrieve(context, name.data());
@@ -156,6 +162,28 @@ struct PlaceholderNode : LiteralNode {
   LiteralNode::var_t (*retrieve)(InitContext&, char const*);
 };
 
+/// A placeholder node for parameters taken from an array
+struct ParameterNode : LiteralNode {
+  ParameterNode(int index_ = -1)
+    : LiteralNode((float)0),
+      index{index_}
+  {
+  }
+
+  ParameterNode(ParameterNode const&) = default;
+
+  template <typename T>
+  void reset(T value_, int index_ = -1)
+  {
+    (*static_cast<LiteralNode*>(this)) = LiteralNode(value_);
+    if (index_ > 0) {
+      index = index_;
+    }
+  }
+
+  int index;
+};
+
 /// A conditional node
 struct ConditionalNode {
 };
@@ -178,6 +206,10 @@ struct Node {
   {
   }
 
+  Node(ParameterNode&& p) : self{std::forward<ParameterNode>(p)}, left{nullptr}, right{nullptr}, condition{nullptr}
+  {
+  }
+
   Node(ConditionalNode op, Node&& then_, Node&& else_, Node&& condition_)
     : self{op},
       left{std::make_unique<Node>(std::forward<Node>(then_))},
@@ -196,16 +228,70 @@ struct Node {
       right{nullptr},
       condition{nullptr} {}
 
+  Node(Node const& other)
+    : self{other.self},
+      index{other.index}
+  {
+    if (other.left != nullptr) {
+      left = std::make_unique<Node>(*other.left);
+    }
+    if (other.right != nullptr) {
+      right = std::make_unique<Node>(*other.right);
+    }
+    if (other.condition != nullptr) {
+      condition = std::make_unique<Node>(*other.condition);
+    }
+  }
+
   /// variant with possible nodes
-  using self_t = std::variant<LiteralNode, BindingNode, OpNode, PlaceholderNode, ConditionalNode>;
+  using self_t = std::variant<LiteralNode, BindingNode, OpNode, PlaceholderNode, ConditionalNode, ParameterNode>;
   self_t self;
   size_t index = 0;
   /// pointers to children
-  std::unique_ptr<Node> left;
-  std::unique_ptr<Node> right;
-  std::unique_ptr<Node> condition;
+  std::unique_ptr<Node> left = nullptr;
+  std::unique_ptr<Node> right = nullptr;
+  std::unique_ptr<Node> condition = nullptr;
+};
+
+/// helper struct used to parse trees
+struct NodeRecord {
+  /// pointer to the actual tree node
+  Node* node_ptr = nullptr;
+  size_t index = 0;
+  explicit NodeRecord(Node* node_, size_t index_) : node_ptr(node_), index{index_} {}
+  bool operator!=(NodeRecord const& rhs)
+  {
+    return this->node_ptr != rhs.node_ptr;
+  }
 };
 
+/// Tree-walker helper
+template <typename L>
+void walk(Node* head, L const& pred)
+{
+  std::stack<NodeRecord> path;
+  path.emplace(head, 0);
+  while (!path.empty()) {
+    auto& top = path.top();
+    pred(top.node_ptr);
+
+    auto* leftp = top.node_ptr->left.get();
+    auto* rightp = top.node_ptr->right.get();
+    auto* condp = top.node_ptr->condition.get();
+    path.pop();
+
+    if (leftp != nullptr) {
+      path.emplace(leftp, 0);
+    }
+    if (rightp != nullptr) {
+      path.emplace(rightp, 0);
+    }
+    if (condp != nullptr) {
+      path.emplace(condp, 0);
+    }
+  }
+}
+
 /// overloaded operators to build the tree from an expression
 
 #define BINARY_OP_NODES(_operator_, _operation_)                                                        \
@@ -402,6 +488,43 @@ inline Node ifnode(Node&& condition_, Configurable<L1> const& then_, Configurabl
   return Node{ConditionalNode{}, PlaceholderNode{then_}, PlaceholderNode{else_}, std::forward<Node>(condition_)};
 }
 
+/// Parameters
+inline Node par(int index)
+{
+  return Node{ParameterNode{index}};
+}
+
+/// binned functional
+template <typename T>
+inline Node binned(std::vector<T> const& binning, std::vector<T> const& parameters, Node&& binned, Node&& pexp, Node&& out)
+{
+  int bins = binning.size() - 1;
+  const auto binned_copy = binned;
+  const auto out_copy = out;
+  auto root = ifnode(Node{binned_copy} < binning[0], Node{out_copy}, LiteralNode{-1});
+  auto* current = &root;
+  for (auto i = 0; i < bins; ++i) {
+    current->right = std::make_unique<Node>(ifnode(Node{binned_copy} < binning[i + 1], updateParameters(pexp, bins, parameters, i), LiteralNode{-1}));
+    current = current->right.get();
+  }
+  current->right = std::make_unique<Node>(out);
+  return root;
+}
+
+template <typename T>
+Node updateParameters(Node const& pexp, int bins, std::vector<T> const& parameters, int bin)
+{
+  Node result{pexp};
+  auto updateParameter = [&bins, &parameters, &bin](Node* node) {
+    if (node->self.index() == 5) {
+      auto* n = std::get_if<5>(&node->self);
+      n->reset(parameters[n->index * bins + bin]);
+    }
+  };
+  walk(&result, updateParameter);
+  return result;
+}
+
 /// A struct, containing the root of the expression tree
 struct Filter {
   Filter() = default;
diff --git a/Framework/Core/src/Expressions.cxx b/Framework/Core/src/Expressions.cxx
index 45bb120b6eb74..6f646515b7837 100644
--- a/Framework/Core/src/Expressions.cxx
+++ b/Framework/Core/src/Expressions.cxx
@@ -118,6 +118,13 @@ struct PlaceholderNodeHelper {
     return DatumSpec{node.value, node.type};
   }
 };
+
+struct ParameterNodeHelper {
+  DatumSpec operator()(ParameterNode const& node) const
+  {
+    return DatumSpec{node.value, node.type};
+  }
+};
 } // namespace
 
 std::shared_ptr<arrow::DataType> concreteArrowType(atype::type type)
@@ -189,37 +196,13 @@ std::ostream& operator<<(std::ostream& os, DatumSpec const& spec)
 
 void updatePlaceholders(Filter& filter, InitContext& context)
 {
-  std::stack<NodeRecord> path;
-
-  // insert the top node into stack
-  path.emplace(filter.node.get(), 0);
-
   auto updateNode = [&](Node* node) {
     if (node->self.index() == 3) {
       std::get_if<3>(&node->self)->reset(context);
     }
   };
 
-  // while the stack is not empty
-  while (!path.empty()) {
-    auto& top = path.top();
-    updateNode(top.node_ptr);
-
-    auto* leftp = top.node_ptr->left.get();
-    auto* rightp = top.node_ptr->right.get();
-    auto* condp = top.node_ptr->condition.get();
-    path.pop();
-
-    if (leftp != nullptr) {
-      path.emplace(leftp, 0);
-    }
-    if (rightp != nullptr) {
-      path.emplace(rightp, 0);
-    }
-    if (condp != nullptr) {
-      path.emplace(condp, 0);
-    }
-  }
+  expressions::walk(filter.node.get(), updateNode);
 }
 
 const char* stringType(atype::type t)
@@ -267,6 +250,7 @@ Operations createOperations(Filter const& expression)
         [lh = LiteralNodeHelper{}](LiteralNode const& node) { return lh(node); },
         [bh = BindingNodeHelper{}](BindingNode const& node) { return bh(node); },
         [ph = PlaceholderNodeHelper{}](PlaceholderNode const& node) { return ph(node); },
+        [pr = ParameterNodeHelper{}](ParameterNode const& node) { return pr(node); },
         [](auto&&) { return DatumSpec{}; }},
       node->self);
   };
diff --git a/Framework/Core/test/test_Expressions.cxx b/Framework/Core/test/test_Expressions.cxx
index 8b08a9a38aa63..2296b5dcbfbc4 100644
--- a/Framework/Core/test/test_Expressions.cxx
+++ b/Framework/Core/test/test_Expressions.cxx
@@ -12,7 +12,6 @@
 #include "Framework/Configurable.h"
 #include "Framework/ExpressionHelpers.h"
 #include "Framework/AnalysisDataModel.h"
-#include "Framework/AODReaderHelpers.h"
 #include <catch_amalgamated.hpp>
 #include <arrow/util/config.h>
 
@@ -283,3 +282,29 @@ TEST_CASE("TestConditionalExpressions")
   auto gandiva_filter2 = createFilter(schema2, gandiva_condition2);
   REQUIRE(gandiva_tree2->ToString() == "bool greater_than((float) fSigned1Pt, (const float) 0 raw(0)) && if (bool less_than(float absf((float) fEta), (const float) 1 raw(3f800000)) && if (bool less_than((float) fPt, (const float) 1 raw(3f800000))) { bool greater_than((float) fPhi, (const float) 1.5708 raw(3fc90fdb)) } else { bool less_than((float) fPhi, (const float) 1.5708 raw(3fc90fdb)) }) { bool greater_than(float absf((float) fX), (const float) 1 raw(3f800000)) } else { bool greater_than(float absf((float) fY), (const float) 1 raw(3f800000)) }");
 }
+
+TEST_CASE("TestBinnedExpressions")
+{
+  std::vector<float> bins{0.5, 1.5, 2.5, 3.5, 4.5};
+  std::vector<float> params{1.0, 1.1, 1.2, 1.3, 2.0, 2.1, 2.2, 2.3, 3.0, 3.1, 3.2, 3.3, 4.0, 4.1, 4.2, 4.3};
+  Projector p = binned(bins, params, o2::aod::track::pt, par(0) * o2::aod::track::x + par(1) * o2::aod::track::y + par(2) * o2::aod::track::z + par(3) * o2::aod::track::phi, LiteralNode{0.f});
+  auto pspecs = createOperations(p);
+  auto schema = std::make_shared<arrow::Schema>(std::vector{o2::aod::track::Pt::asArrowField(), o2::aod::track::X::asArrowField(), o2::aod::track::Y::asArrowField(), o2::aod::track::Z::asArrowField(), o2::aod::track::Phi::asArrowField()});
+  auto tree = createExpressionTree(pspecs, schema);
+  REQUIRE(tree->ToString() == "if (bool less_than((float) fPt, (const float) 0.5 raw(3f000000))) { (const float) 0 raw(0) } else { if (bool less_than((float) fPt, (const float) 1.5 raw(3fc00000))) { float add(float add(float add(float multiply((const float) 1 raw(3f800000), (float) fX), float multiply((const float) 2 raw(40000000), (float) fY)), float multiply((const float) 3 raw(40400000), (float) fZ)), float multiply((const float) 4 raw(40800000), (float) fPhi)) } else { if (bool less_than((float) fPt, (const float) 2.5 raw(40200000))) { float add(float add(float add(float multiply((const float) 1.1 raw(3f8ccccd), (float) fX), float multiply((const float) 2.1 raw(40066666), (float) fY)), float multiply((const float) 3.1 raw(40466666), (float) fZ)), float multiply((const float) 4.1 raw(40833333), (float) fPhi)) } else { if (bool less_than((float) fPt, (const float) 3.5 raw(40600000))) { float add(float add(float add(float multiply((const float) 1.2 raw(3f99999a), (float) fX), float multiply((const float) 2.2 raw(400ccccd), (float) fY)), float multiply((const float) 3.2 raw(404ccccd), (float) fZ)), float multiply((const float) 4.2 raw(40866666), (float) fPhi)) } else { if (bool less_than((float) fPt, (const float) 4.5 raw(40900000))) { float add(float add(float add(float multiply((const float) 1.3 raw(3fa66666), (float) fX), float multiply((const float) 2.3 raw(40133333), (float) fY)), float multiply((const float) 3.3 raw(40533333), (float) fZ)), float multiply((const float) 4.3 raw(4089999a), (float) fPhi)) } else { (const float) 0 raw(0) } } } } }");
+
+  std::vector<float> binning{0, o2::constants::math::PIHalf, o2::constants::math::PI, o2::constants::math::PI + o2::constants::math::PIHalf, o2::constants::math::TwoPI};
+  std::vector<float> parameters{1.0, 1.1, 1.2, 1.3,  // par 0
+                                2.0, 2.1, 2.2, 2.3,  // par 1
+                                3.0, 3.1, 3.2, 3.3,  // par 2
+                                4.0, 4.1, 4.2, 4.3}; // par 3
+
+  Projector p2 = binned((std::vector<float>)binning,
+                        (std::vector<float>)parameters,
+                        o2::aod::track::phi, par(0) * o2::aod::track::x * o2::aod::track::x + par(1) * o2::aod::track::y * o2::aod::track::y + par(2) * o2::aod::track::z * o2::aod::track::z,
+                        LiteralNode{-1.f});
+  auto p2specs = createOperations(p2);
+  auto schema2 = std::make_shared<arrow::Schema>(std::vector{o2::aod::track::Phi::asArrowField(), o2::aod::track::X::asArrowField(), o2::aod::track::Y::asArrowField(), o2::aod::track::Z::asArrowField()});
+  auto tree2 = createExpressionTree(p2specs, schema2);
+  REQUIRE(tree2->ToString() == "if (bool less_than((float) fPhi, (const float) 0 raw(0))) { (const float) -1 raw(bf800000) } else { if (bool less_than((float) fPhi, (const float) 1.5708 raw(3fc90fdb))) { float add(float add(float multiply(float multiply((const float) 1 raw(3f800000), (float) fX), (float) fX), float multiply(float multiply((const float) 2 raw(40000000), (float) fY), (float) fY)), float multiply(float multiply((const float) 3 raw(40400000), (float) fZ), (float) fZ)) } else { if (bool less_than((float) fPhi, (const float) 3.14159 raw(40490fdb))) { float add(float add(float multiply(float multiply((const float) 1.1 raw(3f8ccccd), (float) fX), (float) fX), float multiply(float multiply((const float) 2.1 raw(40066666), (float) fY), (float) fY)), float multiply(float multiply((const float) 3.1 raw(40466666), (float) fZ), (float) fZ)) } else { if (bool less_than((float) fPhi, (const float) 4.71239 raw(4096cbe4))) { float add(float add(float multiply(float multiply((const float) 1.2 raw(3f99999a), (float) fX), (float) fX), float multiply(float multiply((const float) 2.2 raw(400ccccd), (float) fY), (float) fY)), float multiply(float multiply((const float) 3.2 raw(404ccccd), (float) fZ), (float) fZ)) } else { if (bool less_than((float) fPhi, (const float) 6.28319 raw(40c90fdb))) { float add(float add(float multiply(float multiply((const float) 1.3 raw(3fa66666), (float) fX), (float) fX), float multiply(float multiply((const float) 2.3 raw(40133333), (float) fY), (float) fY)), float multiply(float multiply((const float) 3.3 raw(40533333), (float) fZ), (float) fZ)) } else { (const float) -1 raw(bf800000) } } } } }");
+}

From 64ef6b929885f2f422d22eb6d2d824a50b40e463 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 15 Apr 2025 14:10:51 +0200
Subject: [PATCH 0243/1764] Revert "GPU: Temporarily move some defines back to
 the wrapper, to be cleaned up in another PR"

This reverts commit da00550e828dad4617bc4730797d154e4bf79858.
---
 .../Definitions/GPUDefParametersDefaults.h    | 40 +++++++++++++++
 .../Definitions/GPUDefParametersWrapper.h     | 50 +------------------
 2 files changed, 41 insertions(+), 49 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index ce703e2ceba4a..83ef7d8cf810b 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -75,6 +75,16 @@
   #define GPUCA_LB_GPUTPCCFDeconvolution 512
   #define GPUCA_LB_GPUTPCCFClusterizer 448
   #define GPUCA_LB_COMPRESSION_GATHER 1024
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+  #define GPUCA_ALTERNATE_BORDER_SORT 1
+  #define GPUCA_SORT_BEFORE_FIT 1
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
+  #define GPUCA_NO_ATOMIC_PRECHECK 1
+  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
+  #define GPUCA_COMP_GATHER_KERNEL 4
+  #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_VEGA)
   #define GPUCA_WARP_SIZE 64
   #define GPUCA_THREAD_COUNT_DEFAULT 256
@@ -128,6 +138,16 @@
   #define GPUCA_LB_GPUTPCCFDeconvolution 512
   #define GPUCA_LB_GPUTPCCFClusterizer 512
   #define GPUCA_LB_COMPRESSION_GATHER 1024
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+  #define GPUCA_ALTERNATE_BORDER_SORT 1
+  #define GPUCA_SORT_BEFORE_FIT 1
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
+  #define GPUCA_NO_ATOMIC_PRECHECK 1
+  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
+  #define GPUCA_COMP_GATHER_KERNEL 4
+  #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_AMPERE)
   #define GPUCA_WARP_SIZE 32
   #define GPUCA_THREAD_COUNT_DEFAULT 512
@@ -181,6 +201,16 @@
   #define GPUCA_LB_GPUTPCCFDeconvolution 384
   #define GPUCA_LB_GPUTPCCFClusterizer 448
   #define GPUCA_LB_COMPRESSION_GATHER 1024
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+  #define GPUCA_ALTERNATE_BORDER_SORT 1
+  #define GPUCA_SORT_BEFORE_FIT 1
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
+  #define GPUCA_NO_ATOMIC_PRECHECK 1
+  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
+  #define GPUCA_COMP_GATHER_KERNEL 4
+  #define GPUCA_COMP_GATHER_MODE 3
 #elif defined(GPUCA_GPUTYPE_TURING)
   #define GPUCA_WARP_SIZE 32
   #define GPUCA_THREAD_COUNT_DEFAULT 512
@@ -226,6 +256,16 @@
   #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
   #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
   #define GPUCA_LB_COMPRESSION_GATHER 1024
+  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
+  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+  #define GPUCA_ALTERNATE_BORDER_SORT 1
+  #define GPUCA_SORT_BEFORE_FIT 1
+  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
+  #define GPUCA_NO_ATOMIC_PRECHECK 1
+  #define GPUCA_COMP_GATHER_KERNEL 4
+  #define GPUCA_COMP_GATHER_MODE 3
+  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
+  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
   // #define GPUCA_USE_TEXTURES
 #elif defined(GPUCA_GPUTYPE_OPENCL)
 #else
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
index 8d8815d8a8044..beeefa4eb5f9d 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -22,55 +22,7 @@
 #include "GPUCommonDef.h"
 #include "GPUDefMacros.h"
 
-#ifdef GPUCA_GPUCODE
-#if defined(GPUCA_GPUTYPE_MI2xx)
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-#elif defined(GPUCA_GPUTYPE_VEGA)
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-#elif defined(GPUCA_GPUTYPE_AMPERE)
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-#elif defined(GPUCA_GPUTYPE_TURING)
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-#endif
-#endif
-
-#ifdef GPUCA_GPUCODE
+#if defined(GPUCA_GPUCODE)
 #include "GPUDefParametersDefaults.h"
 #endif
 #include "GPUDefParametersConstants.h"

From efbf1474d8f2dcf42572bd7abdd7439580e8f7ba Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 15 Apr 2025 14:10:39 +0200
Subject: [PATCH 0244/1764] GPU: Move compile-time constant parameters to new
 scheme with runtimeParameter struct and automatic RTC-generated defines

With this, we can revert the workaround to have the parameters as defines in the wrapper file
---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |   2 -
 GPU/GPUTracking/Base/GPUReconstruction.h      |   3 +-
 .../Base/GPUReconstructionIncludes.h          |  19 +-
 .../Base/GPUReconstructionProcessing.h        |   1 +
 .../Base/cuda/GPUReconstructionCUDA.cu        |   5 -
 .../Base/cuda/GPUReconstructionCUDA.h         |   1 -
 .../Base/opencl/GPUReconstructionOCL.cxx      |   5 -
 .../Base/opencl/GPUReconstructionOCL.h        |   1 -
 GPU/GPUTracking/CMakeLists.txt                |   9 +-
 .../DataCompression/GPUTPCCompression.cxx     |  16 +-
 .../Definitions/GPUDefConstantsAndSettings.h  |   2 +-
 .../Definitions/GPUDefParametersConstants.h   |  45 +-
 .../Definitions/GPUDefParametersDefaults.h    | 567 ++++++++++--------
 .../GPUDefParametersLoad.template.inc         |  35 +-
 .../GPUDefParametersRuntime.template.h        |   4 +
 .../Definitions/GPUDefParametersWrapper.h     |   6 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |   8 +-
 .../Global/GPUChainTrackingCompression.cxx    |  25 +-
 .../Global/GPUChainTrackingMerger.cxx         |  10 +-
 .../Global/GPUChainTrackingSectorTracker.cxx  |   5 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |   4 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h  |   2 +-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx |   2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |  10 +-
 .../SectorTracker/GPUTPCNeighboursFinder.cxx  |   2 +-
 .../SectorTracker/GPUTPCNeighboursFinder.h    |  10 +-
 .../SectorTracker/GPUTPCStartHitsFinder.cxx   |   4 +-
 .../SectorTracker/GPUTPCTracker.cxx           |   6 +-
 .../SectorTracker/GPUTPCTrackletSelector.cxx  |  18 +-
 .../SectorTracker/GPUTPCTrackletSelector.h    |   8 +-
 GPU/GPUTracking/cmake/kernel_helpers.cmake    |  19 +
 GPU/GPUTracking/dEdx/GPUdEdx.cxx              |   4 +-
 GPU/GPUTracking/dEdx/GPUdEdx.h                |  14 +-
 GPU/GPUTracking/kernels.cmake                 |  13 +
 34 files changed, 466 insertions(+), 419 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 2f643706647ee..b4dac39ae1cd2 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -292,8 +292,6 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     mProcessingSettings.delayedOutput = false;
   }
 
-  UpdateAutomaticProcessingSettings();
-  GPUCA_GPUReconstructionUpdateDefaults();
   if (!mProcessingSettings.rtc.enable) {
     mProcessingSettings.rtc.optConstexpr = false;
   }
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 18098396e1349..23fb6e4d9ff06 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -48,6 +48,7 @@ struct GPUReconstructionPipelineContext;
 struct GPUReconstructionThreading;
 class GPUROOTDumpCore;
 class ThrustVolatileAllocator;
+struct GPUDefParameters;
 
 namespace gpu_reconstruction_kernels
 {
@@ -205,6 +206,7 @@ class GPUReconstruction
   GPUOutputControl& OutputControl() { return mOutputControl; }
   uint32_t NStreams() const { return mNStreams; }
   const void* DeviceMemoryBase() const { return mDeviceMemoryBase; }
+  virtual const GPUDefParameters& getGPUParameters(bool doGPU) const = 0;
 
   RecoStepField GetRecoSteps() const { return mRecoSteps.steps; }
   RecoStepField GetRecoStepsGPU() const { return mRecoSteps.stepsGPUMask; }
@@ -239,7 +241,6 @@ class GPUReconstruction
   void FreeRegisteredMemory(GPUMemoryResource* res);
   GPUReconstruction(const GPUSettingsDeviceBackend& cfg); // Constructor
   int32_t InitPhaseBeforeDevice();
-  virtual void UpdateAutomaticProcessingSettings() {}
   virtual int32_t InitDevice() = 0;
   int32_t InitPhasePermanentMemory();
   int32_t InitPhaseAfterDevice();
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludes.h b/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
index 6aba7e30a49d7..d3f11d86a731d 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
@@ -29,21 +29,4 @@
 #include <iostream>
 #include <fstream>
 
-#define GPUCA_GPUReconstructionUpdateDefaults()                                             \
-  if (mProcessingSettings.alternateBorderSort < 0) {                                        \
-    mProcessingSettings.alternateBorderSort = GPUCA_ALTERNATE_BORDER_SORT;                  \
-  }                                                                                         \
-  if (mProcessingSettings.mergerSortTracks < 0) {                                           \
-    mProcessingSettings.mergerSortTracks = GPUCA_SORT_BEFORE_FIT;                           \
-  }                                                                                         \
-  if (param().rec.tpc.looperInterpolationInExtraPass < 0) {                                 \
-    param().rec.tpc.looperInterpolationInExtraPass = GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION; \
-  }                                                                                         \
-  if (mProcessingSettings.tpcCompressionGatherModeKernel < 0) {                             \
-    mProcessingSettings.tpcCompressionGatherModeKernel = GPUCA_COMP_GATHER_KERNEL;          \
-  }                                                                                         \
-  if (mProcessingSettings.tpcCompressionGatherMode < 0) {                                   \
-    mProcessingSettings.tpcCompressionGatherMode = GPUCA_COMP_GATHER_MODE;                  \
-  }
-
-#endif
+#endif // GPURECONSTRUCTIONINCLUDES_H
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index 2428027118c0a..e8892c4be702b 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -101,6 +101,7 @@ class GPUReconstructionProcessing : public GPUReconstruction
     uint32_t countToGPU = 0;
     uint32_t countToHost = 0;
   };
+  const GPUDefParameters& getGPUParameters(bool doGPU) const override { return *(doGPU ? mParDevice : mParCPU); }
 
  protected:
   GPUReconstructionProcessing(const GPUSettingsDeviceBackend& cfg);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 47a9b675d27f6..3bea91994ba86 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -99,11 +99,6 @@ void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>
   }
 }
 
-void GPUReconstructionCUDA::UpdateAutomaticProcessingSettings()
-{
-  GPUCA_GPUReconstructionUpdateDefaults();
-}
-
 int32_t GPUReconstructionCUDA::InitDevice_Runtime()
 {
 #ifndef __HIPCC__ // CUDA
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 3441c6b9a4fd6..b1a3a53a6a62f 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -59,7 +59,6 @@ class GPUReconstructionCUDA : public GPUReconstructionKernels<GPUReconstructionC
  protected:
   int32_t InitDevice_Runtime() override;
   int32_t ExitDevice_Runtime() override;
-  void UpdateAutomaticProcessingSettings() override;
 
   std::unique_ptr<gpu_reconstruction_kernels::threadContext> GetThreadContext() override;
   void SynchronizeGPU() override;
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index af26bfc7aeca8..e276f83413bbc 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -60,11 +60,6 @@ int32_t GPUReconstructionOCLBackend::GPUChkErrInternal(const int64_t error, cons
   return error != CL_SUCCESS;
 }
 
-void GPUReconstructionOCLBackend::UpdateAutomaticProcessingSettings()
-{
-  GPUCA_GPUReconstructionUpdateDefaults();
-}
-
 int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
 {
   if (mMaster == nullptr) {
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index 16ef9b5e87fe8..abde42f01f073 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -37,7 +37,6 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
 
   int32_t InitDevice_Runtime() override;
   int32_t ExitDevice_Runtime() override;
-  void UpdateAutomaticProcessingSettings() override;
 
   virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override;
 
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index f428d982394e0..eaeec508ff27a 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -247,14 +247,17 @@ foreach(TEMPLATE_FILE ${TEMPLATE_HEADER_LIST})
   file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/${OUTPUT_FILE_NAME} INPUT ${TEMPLATE_FILE})
   list(APPEND GENERATED_HEADERS_LIST ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/${OUTPUT_FILE_NAME})
 endforeach()
+set(GPUDEFPARAMETERSLBLIST "$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,LB_>,\n>\n")
+string(APPEND GPUDEFPARAMETERSLBLIST "$<JOIN:$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_PARAMS>,PREPEND,PAR_>,\n>\n")
+string(APPEND GPUDEFPARAMETERSLBLIST "$<JOIN:$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_STRING_PARAMS>,PREPEND,PAR_>,\n>")
 file(GENERATE
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase
-     CONTENT "$<JOIN:$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,\n>"
-)
+     CONTENT ${GPUDEFPARAMETERSLBLIST})
 add_custom_command(
   OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h
-  COMMAND awk "{print(\"#ifndef GPUCA_LB_\" $0 \"\\n#define GPUCA_LB_\" $0 \" 0\\n#endif\")}" ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase > ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h
+  COMMAND awk "{print(\"#ifndef GPUCA_\" $0 \"\\n#define GPUCA_\" $0 \" 0\\n#endif\")}" ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase > ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h
   COMMENT "Generating GPUDefParametersLoadPrepare.h"
+  DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase
   VERBATIM
   COMMAND_EXPAND_LISTS
 )
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index 335b201d11d07..8a22545314252 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -16,6 +16,7 @@
 #include "GPUReconstruction.h"
 #include "GPUO2DataTypes.h"
 #include "GPUMemorySizeScalers.h"
+#include "GPUDefParametersRuntime.h"
 
 using namespace o2::gpu;
 
@@ -36,11 +37,12 @@ void* GPUTPCCompression::SetPointersOutputHost(void* mem)
 
 void* GPUTPCCompression::SetPointersScratch(void* mem)
 {
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   computePointerWithAlignment(mem, mClusterStatus, mMaxClusters);
-  if (mRec->GetProcessingSettings().tpcCompressionGatherMode >= 2) {
+  if (gatherMode >= 2) {
     computePointerWithAlignment(mem, mAttachedClusterFirstIndex, mMaxTracks);
   }
-  if (mRec->GetProcessingSettings().tpcCompressionGatherMode != 1) {
+  if (gatherMode != 1) {
     SetPointersCompressedClusters(mem, mPtrs, mMaxTrackClusters, mMaxTracks, mMaxClustersInCache, false);
   }
   return mem;
@@ -48,8 +50,9 @@ void* GPUTPCCompression::SetPointersScratch(void* mem)
 
 void* GPUTPCCompression::SetPointersOutput(void* mem)
 {
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   computePointerWithAlignment(mem, mAttachedClusterFirstIndex, mMaxTrackClusters);
-  if (mRec->GetProcessingSettings().tpcCompressionGatherMode == 1) {
+  if (gatherMode == 1) {
     SetPointersCompressedClusters(mem, mPtrs, mMaxTrackClusters, mMaxTracks, mMaxClustersInCache, false);
   }
   return mem;
@@ -102,12 +105,13 @@ void* GPUTPCCompression::SetPointersMemory(void* mem)
 void GPUTPCCompression::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   mMemoryResOutputHost = mRec->RegisterMemoryAllocation(this, &GPUTPCCompression::SetPointersOutputHost, GPUMemoryResource::MEMORY_OUTPUT_FLAG | GPUMemoryResource::MEMORY_HOST | GPUMemoryResource::MEMORY_CUSTOM, "TPCCompressionOutputHost");
-  if (mRec->GetProcessingSettings().tpcCompressionGatherMode == 3) {
+  if (gatherMode == 3) {
     mMemoryResOutputGPU = mRec->RegisterMemoryAllocation(this, &GPUTPCCompression::SetPointersOutputGPU, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_GPU | GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_STACK, "TPCCompressionOutputGPU");
   }
-  uint32_t stackScratch = (mRec->GetProcessingSettings().tpcCompressionGatherMode != 3) ? GPUMemoryResource::MEMORY_STACK : 0;
-  if (mRec->GetProcessingSettings().tpcCompressionGatherMode < 2) {
+  uint32_t stackScratch = (gatherMode != 3) ? GPUMemoryResource::MEMORY_STACK : 0;
+  if (gatherMode < 2) {
     mRec->RegisterMemoryAllocation(this, &GPUTPCCompression::SetPointersOutput, GPUMemoryResource::MEMORY_OUTPUT | stackScratch, "TPCCompressionOutput");
   }
   mRec->RegisterMemoryAllocation(this, &GPUTPCCompression::SetPointersScratch, GPUMemoryResource::MEMORY_SCRATCH | stackScratch, "TPCCompressionScratch");
diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index 2d7aca8d71b92..48218dd7859e6 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 // This files contains compile-time constants affecting the GPU algorithms / reconstruction results.
-// Architecture-dependant compile-time constants affecting the performance without changing the results are stored in GPUDefParameters.h
+// Architecture-dependant compile-time constants affecting the performance without changing the results are stored in GPUDefParameters*.h
 
 #ifndef GPUDEFCONSTANTSANDSETTINGS_H
 #define GPUDEFCONSTANTSANDSETTINGS_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
index 3a16d02ecf7c6..dd4a5dcbe7ba8 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
@@ -21,16 +21,12 @@
 #define GPUCA_THREAD_COUNT_SCAN 512 // TODO: WARNING!!! Must not be GPUTYPE-dependent right now! // TODO: Fix!
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
-  #define GPUCA_SPECIALIZE_THRUST_SORTS
+  #define GPUCA_SPECIALIZE_THRUST_SORTS // Not compiled with RTC, so must be compile-time constant
 #endif
 
 #define GPUCA_MAX_THREADS 1024
 #define GPUCA_MAX_STREAMS 36
 
-#if defined(GPUCA_GPUCODE)
-  #define GPUCA_SORT_STARTHITS                                         // Sort the start hits when running on GPU
-#endif
-
 #define GPUCA_ROWALIGNMENT 16                                          // Align of Row Hits and Grid
 #define GPUCA_BUFFER_ALIGNMENT 64                                      // Alignment of buffers obtained from SetPointers
 #define GPUCA_MEMALIGN (64 * 1024)                                     // Alignment of allocated memory blocks
@@ -44,44 +40,5 @@
 #define GPUCA_GPU_STACK_SIZE         ((size_t)               8 * 1024) // Stack size per GPU thread
 #define GPUCA_GPU_HEAP_SIZE          ((size_t)       16 * 1025 * 1024) // Stack size per GPU thread
 
-#ifdef GPUCA_GPUCODE
-  #ifndef GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP
-     #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 6
-  #endif
-  #ifndef GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE
-     #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 12
-  #endif
-  #ifndef GPUCA_ALTERNATE_BORDER_SORT
-     #define GPUCA_ALTERNATE_BORDER_SORT 0
-  #endif
-  #ifndef GPUCA_SORT_BEFORE_FIT
-     #define GPUCA_SORT_BEFORE_FIT 0
-  #endif
-  #ifndef GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION
-     #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
-  #endif
-  #ifndef GPUCA_COMP_GATHER_KERNEL
-     #define GPUCA_COMP_GATHER_KERNEL 0
-  #endif
-  #ifndef GPUCA_COMP_GATHER_MODE
-     #define GPUCA_COMP_GATHER_MODE 2
-  #endif
-#else
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 0
-  #define GPUCA_ALTERNATE_BORDER_SORT 0
-  #define GPUCA_SORT_BEFORE_FIT 0
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 0
-  #define GPUCA_THREAD_COUNT_FINDER 1
-  #define GPUCA_COMP_GATHER_KERNEL 0
-  #define GPUCA_COMP_GATHER_MODE 0
-#endif
-#ifndef GPUCA_DEDX_STORAGE_TYPE
-  #define GPUCA_DEDX_STORAGE_TYPE float
-#endif
-#ifndef GPUCA_MERGER_INTERPOLATION_ERROR_TYPE
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE float
-#endif
-
 // clang-format on
 #endif // GPUDEFPARAMETERSCONSTANTS_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 83ef7d8cf810b..b212abbcd2707 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -14,266 +14,265 @@
 
 // This file contains compile-time constants affecting the GPU performance.
 
-#if !defined(GPUDEFPARAMETERSDEFAULTS_H) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.
+#if !defined(GPUDEFPARAMETERSDEFAULTS_H)
 #define GPUDEFPARAMETERSDEFAULTS_H
 // clang-format off
 
 // Launch bound definition, 3 optional parameters: maxThreads per block, minBlocks per multiprocessor, force number of blocks (not passed to compiler as launch bounds)
 
 // GPU Run Configuration
-#ifdef GPUCA_GPUCODE
-#if defined(GPUCA_GPUTYPE_MI2xx)
-  #define GPUCA_WARP_SIZE 64
-  #define GPUCA_THREAD_COUNT_DEFAULT 256
-  #define GPUCA_LB_GPUTPCCreateTrackingData 256
-  #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
-  #define GPUCA_LB_GPUTPCStartHitsFinder 1024
-  #define GPUCA_LB_GPUTPCTrackletConstructor 512, 2
-  #define GPUCA_LB_GPUTPCTrackletSelector 192, 3
-  #define GPUCA_LB_GPUTPCNeighboursFinder 1024, 1
-  #define GPUCA_LB_GPUTPCNeighboursCleaner 896
-  #define GPUCA_LB_GPUTPCExtrapolationTracking 256
-  #define GPUCA_LB_GPUTPCCFDecodeZS 64, 4
-  #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-  #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
-  #define GPUCA_LB_GPUTPCCFGather 1024, 1
-  #define GPUCA_LB_GPUTPCGMMergerTrackFit 128, 1
-  #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 64, 12
-  #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256
-  #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-  #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step0 512
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step1 512
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step2 512
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step3 512
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step4 512
-  #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 512
-  #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 512
-  #define GPUCA_LB_GPUTPCGMMergerMergeCE 512
-  #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-  #define GPUCA_LB_GPUTPCGMMergerCollect 512
-  #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-  #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 64, 2
-  #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
-  #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
-  #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
-  #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
-  #define GPUCA_LB_GPUTPCCFPeakFinder 512
-  #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
-  #define GPUCA_LB_GPUTPCCFDeconvolution 512
-  #define GPUCA_LB_GPUTPCCFClusterizer 448
-  #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-#elif defined(GPUCA_GPUTYPE_VEGA)
-  #define GPUCA_WARP_SIZE 64
-  #define GPUCA_THREAD_COUNT_DEFAULT 256
-  #define GPUCA_LB_GPUTPCCreateTrackingData 128
-  #define GPUCA_LB_GPUTPCStartHitsSorter 1024, 2
-  #define GPUCA_LB_GPUTPCStartHitsFinder 1024
-  #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2
-  #define GPUCA_LB_GPUTPCTrackletSelector 256, 8
-  #define GPUCA_LB_GPUTPCNeighboursFinder 1024, 1
-  #define GPUCA_LB_GPUTPCNeighboursCleaner 896
-  #define GPUCA_LB_GPUTPCExtrapolationTracking 256
-  #define GPUCA_LB_GPUTPCCFDecodeZS 64, 4
-  #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-  #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
-  #define GPUCA_LB_GPUTPCCFGather 1024, 1
-  #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 1
-  #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 4, 200
-  #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256
-  #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-  #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256
-  #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
-  #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-  #define GPUCA_LB_GPUTPCGMMergerCollect 512
-  #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-  #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 192, 2
-  #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
-  #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
-  #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
-  #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
-  #define GPUCA_LB_GPUTPCCFPeakFinder 512
-  #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
-  #define GPUCA_LB_GPUTPCCFDeconvolution 512
-  #define GPUCA_LB_GPUTPCCFClusterizer 512
-  #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-#elif defined(GPUCA_GPUTYPE_AMPERE)
-  #define GPUCA_WARP_SIZE 32
-  #define GPUCA_THREAD_COUNT_DEFAULT 512
-  #define GPUCA_LB_GPUTPCCreateTrackingData 384
-  #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
-  #define GPUCA_LB_GPUTPCStartHitsFinder 512
-  #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2 // best single-kernel: 128, 4
-  #define GPUCA_LB_GPUTPCTrackletSelector 192, 3    // best single-kernel: 128, 4
-  #define GPUCA_LB_GPUTPCNeighboursFinder 640, 1    // best single-kernel: 768, 1
-  #define GPUCA_LB_GPUTPCNeighboursCleaner 512
-  #define GPUCA_LB_GPUTPCExtrapolationTracking 128, 4
-  #define GPUCA_LB_GPUTPCCFDecodeZS 64, 10
-  #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-  #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
-  #define GPUCA_LB_GPUTPCCFGather 1024, 1
-  #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 4
-  #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 64, 12
-  #define GPUCA_LB_GPUTPCGMMergerSectorRefit 32, 6
-  #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-  #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256, 4
-  #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256, 2
-  #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 192
-  #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 64, 2
-  #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
-  #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-  #define GPUCA_LB_GPUTPCGMMergerCollect 256, 2
-  #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-  #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 64, 2
-  #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 3
-  #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
-  #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
-  #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64,8
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 448
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 448
-  #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 448
-  #define GPUCA_LB_GPUTPCCFPeakFinder 128
-  #define GPUCA_LB_GPUTPCCFNoiseSuppression 448
-  #define GPUCA_LB_GPUTPCCFDeconvolution 384
-  #define GPUCA_LB_GPUTPCCFClusterizer 448
-  #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-#elif defined(GPUCA_GPUTYPE_TURING)
-  #define GPUCA_WARP_SIZE 32
-  #define GPUCA_THREAD_COUNT_DEFAULT 512
-  #define GPUCA_LB_GPUTPCCreateTrackingData 256
-  #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
-  #define GPUCA_LB_GPUTPCStartHitsFinder 512
-  #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2
-  #define GPUCA_LB_GPUTPCTrackletSelector 192, 3
-  #define GPUCA_LB_GPUTPCNeighboursFinder 640, 1
-  #define GPUCA_LB_GPUTPCNeighboursCleaner 512
-  #define GPUCA_LB_GPUTPCExtrapolationTracking 192, 2
-  #define GPUCA_LB_GPUTPCCFDecodeZS 64, 8
-  #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-  #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
-  #define GPUCA_LB_GPUTPCCFGather 1024, 1
-  #define GPUCA_LB_GPUTPCGMMergerTrackFit 32, 8
-  #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 128, 4
-  #define GPUCA_LB_GPUTPCGMMergerSectorRefit 64, 5
-  #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-  #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
-  #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256, 4
-  #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256, 2
-  #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 192
-  #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
-  #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-  #define GPUCA_LB_GPUTPCGMMergerCollect 128, 2
-  #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
-  #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
-  #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-  #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 128
-  #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
-  #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
-  #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
-  #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #define GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-  #define GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-  #define GPUCA_ALTERNATE_BORDER_SORT 1
-  #define GPUCA_SORT_BEFORE_FIT 1
-  #define GPUCA_MERGER_SPLIT_LOOP_INTERPOLATION 1
-  #define GPUCA_NO_ATOMIC_PRECHECK 1
-  #define GPUCA_COMP_GATHER_KERNEL 4
-  #define GPUCA_COMP_GATHER_MODE 3
-  #define GPUCA_DEDX_STORAGE_TYPE uint16_t
-  #define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE half
-  // #define GPUCA_USE_TEXTURES
-#elif defined(GPUCA_GPUTYPE_OPENCL)
-#else
-  #error GPU TYPE NOT SET
-#endif
-#endif // GPUCA_GPUCODE
+#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.
+  // GPU-architecture-dependent default settings
+  #if defined(GPUCA_GPUTYPE_MI2xx)
+    #define GPUCA_WARP_SIZE 64
+    #define GPUCA_THREAD_COUNT_DEFAULT 256
+    #define GPUCA_LB_GPUTPCCreateTrackingData 256
+    #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
+    #define GPUCA_LB_GPUTPCStartHitsFinder 1024
+    #define GPUCA_LB_GPUTPCTrackletConstructor 512, 2
+    #define GPUCA_LB_GPUTPCTrackletSelector 192, 3
+    #define GPUCA_LB_GPUTPCNeighboursFinder 1024, 1
+    #define GPUCA_LB_GPUTPCNeighboursCleaner 896
+    #define GPUCA_LB_GPUTPCExtrapolationTracking 256
+    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 4
+    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFGather 1024, 1
+    #define GPUCA_LB_GPUTPCGMMergerTrackFit 128, 1
+    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 64, 12
+    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256
+    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
+    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 512
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 512
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 512
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 512
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 512
+    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 512
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 512
+    #define GPUCA_LB_GPUTPCGMMergerMergeCE 512
+    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
+    #define GPUCA_LB_GPUTPCGMMergerCollect 512
+    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
+    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 64, 2
+    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
+    #define GPUCA_LB_GPUTPCCFPeakFinder 512
+    #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
+    #define GPUCA_LB_GPUTPCCFDeconvolution 512
+    #define GPUCA_LB_GPUTPCCFClusterizer 448
+    #define GPUCA_LB_COMPRESSION_GATHER 1024
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
+    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
+    #define GPUCA_PAR_SORT_BEFORE_FIT 1
+    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 1
+    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
+    #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
+    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
+    #define GPUCA_PAR_COMP_GATHER_KERNEL 4
+    #define GPUCA_PAR_COMP_GATHER_MODE 3
+  #elif defined(GPUCA_GPUTYPE_VEGA)
+    #define GPUCA_WARP_SIZE 64
+    #define GPUCA_THREAD_COUNT_DEFAULT 256
+    #define GPUCA_LB_GPUTPCCreateTrackingData 128
+    #define GPUCA_LB_GPUTPCStartHitsSorter 1024, 2
+    #define GPUCA_LB_GPUTPCStartHitsFinder 1024
+    #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2
+    #define GPUCA_LB_GPUTPCTrackletSelector 256, 8
+    #define GPUCA_LB_GPUTPCNeighboursFinder 1024, 1
+    #define GPUCA_LB_GPUTPCNeighboursCleaner 896
+    #define GPUCA_LB_GPUTPCExtrapolationTracking 256
+    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 4
+    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFGather 1024, 1
+    #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 1
+    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 4, 200
+    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256
+    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
+    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256
+    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
+    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
+    #define GPUCA_LB_GPUTPCGMMergerCollect 512
+    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
+    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 192, 2
+    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
+    #define GPUCA_LB_GPUTPCCFPeakFinder 512
+    #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
+    #define GPUCA_LB_GPUTPCCFDeconvolution 512
+    #define GPUCA_LB_GPUTPCCFClusterizer 512
+    #define GPUCA_LB_COMPRESSION_GATHER 1024
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
+    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
+    #define GPUCA_PAR_SORT_BEFORE_FIT 1
+    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 1
+    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
+    #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
+    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
+    #define GPUCA_PAR_COMP_GATHER_KERNEL 4
+    #define GPUCA_PAR_COMP_GATHER_MODE 3
+  #elif defined(GPUCA_GPUTYPE_AMPERE)
+    #define GPUCA_WARP_SIZE 32
+    #define GPUCA_THREAD_COUNT_DEFAULT 512
+    #define GPUCA_LB_GPUTPCCreateTrackingData 384
+    #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
+    #define GPUCA_LB_GPUTPCStartHitsFinder 512
+    #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2 // best single-kernel: 128, 4
+    #define GPUCA_LB_GPUTPCTrackletSelector 192, 3    // best single-kernel: 128, 4
+    #define GPUCA_LB_GPUTPCNeighboursFinder 640, 1    // best single-kernel: 768, 1
+    #define GPUCA_LB_GPUTPCNeighboursCleaner 512
+    #define GPUCA_LB_GPUTPCExtrapolationTracking 128, 4
+    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 10
+    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFGather 1024, 1
+    #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 4
+    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 64, 12
+    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 32, 6
+    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
+    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256, 4
+    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256, 2
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 192
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 64, 2
+    #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
+    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
+    #define GPUCA_LB_GPUTPCGMMergerCollect 256, 2
+    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
+    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 64, 2
+    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 3
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64,8
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 448
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 448
+    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 448
+    #define GPUCA_LB_GPUTPCCFPeakFinder 128
+    #define GPUCA_LB_GPUTPCCFNoiseSuppression 448
+    #define GPUCA_LB_GPUTPCCFDeconvolution 384
+    #define GPUCA_LB_GPUTPCCFClusterizer 448
+    #define GPUCA_LB_COMPRESSION_GATHER 1024
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
+    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
+    #define GPUCA_PAR_SORT_BEFORE_FIT 1
+    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 1
+    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
+    #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
+    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
+    #define GPUCA_PAR_COMP_GATHER_KERNEL 4
+    #define GPUCA_PAR_COMP_GATHER_MODE 3
+  #elif defined(GPUCA_GPUTYPE_TURING)
+    #define GPUCA_WARP_SIZE 32
+    #define GPUCA_THREAD_COUNT_DEFAULT 512
+    #define GPUCA_LB_GPUTPCCreateTrackingData 256
+    #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
+    #define GPUCA_LB_GPUTPCStartHitsFinder 512
+    #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2
+    #define GPUCA_LB_GPUTPCTrackletSelector 192, 3
+    #define GPUCA_LB_GPUTPCNeighboursFinder 640, 1
+    #define GPUCA_LB_GPUTPCNeighboursCleaner 512
+    #define GPUCA_LB_GPUTPCExtrapolationTracking 192, 2
+    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 8
+    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFGather 1024, 1
+    #define GPUCA_LB_GPUTPCGMMergerTrackFit 32, 8
+    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 128, 4
+    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 64, 5
+    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
+    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
+    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256, 4
+    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256, 2
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 192
+    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
+    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
+    #define GPUCA_LB_GPUTPCGMMergerCollect 128, 2
+    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
+    #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
+    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 128
+    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
+    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
+    #define GPUCA_LB_COMPRESSION_GATHER 1024
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
+    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
+    #define GPUCA_PAR_SORT_BEFORE_FIT 1
+    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 1
+    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
+    #define GPUCA_PAR_COMP_GATHER_KERNEL 4
+    #define GPUCA_PAR_COMP_GATHER_MODE 3
+    #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
+    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
+    // #define GPUCA_USE_TEXTURES
+  #elif defined(GPUCA_GPUTYPE_OPENCL)
+  #else
+    #error GPU TYPE NOT SET
+  #endif
 
-#ifdef GPUCA_GPUCODE
   // Default settings for GPU, if not already set for selected GPU type
   #ifndef GPUCA_WARP_SIZE
     #define GPUCA_WARP_SIZE 32
@@ -509,7 +508,67 @@
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64 GPUCA_LB_COMPRESSION_GATHER
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered128 GPUCA_LB_COMPRESSION_GATHER
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_multiBlock GPUCA_LB_COMPRESSION_GATHER
-#endif
+
+  // Defaults for non-LB parameters
+  #ifndef GPUCA_PAR_SORT_STARTHITS
+    #define GPUCA_PAR_SORT_STARTHITS 1
+  #endif
+  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 6
+  #endif
+  #ifndef GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE
+    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 12
+  #endif
+  #ifndef GPUCA_PAR_ALTERNATE_BORDER_SORT
+    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 0
+  #endif
+  #ifndef GPUCA_PAR_SORT_BEFORE_FIT
+    #define GPUCA_PAR_SORT_BEFORE_FIT 0
+  #endif
+  #ifndef GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION
+    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 0
+  #endif
+  #ifndef GPUCA_PAR_COMP_GATHER_KERNEL
+    #define GPUCA_PAR_COMP_GATHER_KERNEL 0
+  #endif
+  #ifndef GPUCA_PAR_COMP_GATHER_MODE
+    #define GPUCA_PAR_COMP_GATHER_MODE 2
+  #endif
+#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)
+
+#ifndef GPUCA_GPUCODE_GENRTC
+  // Defaults (also for CPU) for non-LB parameters
+  #ifndef GPUCA_PAR_SORT_STARTHITS
+    #define GPUCA_PAR_SORT_STARTHITS 0
+  #endif
+  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
+  #endif
+  #ifndef GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE
+    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 0
+  #endif
+  #ifndef GPUCA_PAR_ALTERNATE_BORDER_SORT
+    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 0
+  #endif
+  #ifndef GPUCA_PAR_SORT_BEFORE_FIT
+    #define GPUCA_PAR_SORT_BEFORE_FIT 0
+  #endif
+  #ifndef GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION
+    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 0
+  #endif
+  #ifndef GPUCA_PAR_COMP_GATHER_KERNEL
+    #define GPUCA_PAR_COMP_GATHER_KERNEL 0
+  #endif
+  #ifndef GPUCA_PAR_COMP_GATHER_MODE
+    #define GPUCA_PAR_COMP_GATHER_MODE 0
+  #endif
+  #ifndef GPUCA_PAR_DEDX_STORAGE_TYPE
+    #define GPUCA_PAR_DEDX_STORAGE_TYPE float
+  #endif
+  #ifndef GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE
+    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE float
+  #endif
+#endif // GPUCA_GPUCODE_GENRTC
 
 // clang-format on
 #endif // GPUDEFPARAMETERSDEFAULTS_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
index 938cedbdacc93..ac71adc6232a6 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
@@ -32,29 +32,38 @@ static GPUDefParameters GPUDefParametersLoad()
     // clang-format off
     {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_LB_EMPTY0(GPUCA_M_FIRST(GPUCA_LB_>,APPEND,))>,$<COMMA>>},
     {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_LB_>,APPEND,$<COMMA>0))>,$<COMMA>>},
-    {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_M_SHIFT(GPUCA_LB_>,APPEND,$<COMMA>0$<COMMA>0)))>,$<COMMA>>}
+    {$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_M_SHIFT(GPUCA_LB_>,APPEND,$<COMMA>0$<COMMA>0)))>,$<COMMA>>},
+    $<JOIN:$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_PARAMS>,PREPEND,GPUCA_PAR_>,$<COMMA>>,
+    $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_STRING_PARAMS>,PREPEND,GPUCA_M_STR(GPUCA_PAR_>,APPEND,)>,$<COMMA>>
     // clang-format on
   };
 }
 
-#define GPUCA_EXPORT_KERNEL(name)                                                  \
-  if (par.par_LB_maxThreads[i] > 0) {                                              \
-    o << "#define GPUCA_LB_" << GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i]; \
-    if (par.par_LB_minBlocks[i] > 0) {                                             \
-      o << ", " << par.par_LB_minBlocks[i];                                        \
-    }                                                                              \
-    if (!forRTC && par.par_LB_forceBlocks[i] > 0) {                                \
-      o << ", " << par.par_LB_forceBlocks[i];                                      \
-    }                                                                              \
-    o << "\n";                                                                     \
-  }                                                                                \
+#define GPUCA_EXPORT_KERNEL_LB(name)                                            \
+  if (par.par_LB_maxThreads[i] > 0) {                                           \
+    o << "#define GPUCA_LB_" GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i]; \
+    if (par.par_LB_minBlocks[i] > 0) {                                          \
+      o << ", " << par.par_LB_minBlocks[i];                                     \
+    }                                                                           \
+    if (!forRTC && par.par_LB_forceBlocks[i] > 0) {                             \
+      o << ", " << par.par_LB_forceBlocks[i];                                   \
+    }                                                                           \
+    o << "\n";                                                                  \
+  }                                                                             \
   i++;
 
+#define GPUCA_EXPORT_KERNEL_PARAM(name) \
+  o << "#define GPUCA_PAR_" GPUCA_M_STR(name) " " << GPUCA_M_CAT(par.par_, name) << "\n";
+
 static std::string GPUDefParametersExport(const GPUDefParameters& par, bool forRTC)
 {
   std::stringstream o; // clang-format off
   int32_t i = 0;
-  $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_EXPORT_KERNEL(>,APPEND,)>,
+  $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,GPUCA_EXPORT_KERNEL_LB(>,APPEND,)>,
+  >
+  $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_PARAMS>,PREPEND,GPUCA_EXPORT_KERNEL_PARAM(>,APPEND,)>,
+  >
+  $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_STRING_PARAMS>,PREPEND,GPUCA_EXPORT_KERNEL_PARAM(>,APPEND,)>,
   >
   return o.str(); // clang-format on
 }
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersRuntime.template.h b/GPU/GPUTracking/Definitions/GPUDefParametersRuntime.template.h
index f3537c058a824..d023de7916676 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersRuntime.template.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersRuntime.template.h
@@ -21,6 +21,10 @@ struct GPUDefParameters {  // clang-format off
   int32_t par_LB_maxThreads[$<LIST:LENGTH,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>>] = {};
   int32_t par_LB_minBlocks[$<LIST:LENGTH,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>>] = {};
   int32_t par_LB_forceBlocks[$<LIST:LENGTH,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>>] = {};
+  $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_PARAMS>,PREPEND,int32_t par_>,APPEND, = 0>,$<SEMICOLON>
+  >;
+  $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_STRING_PARAMS>,PREPEND,char par_>,APPEND,[128] = "">,$<SEMICOLON>
+  >;
 };  // clang-format on
 }  // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
index beeefa4eb5f9d..b2c08d689aeb2 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -22,9 +22,7 @@
 #include "GPUCommonDef.h"
 #include "GPUDefMacros.h"
 
-#if defined(GPUCA_GPUCODE)
 #include "GPUDefParametersDefaults.h"
-#endif
 #include "GPUDefParametersConstants.h"
 
 namespace o2::gpu
@@ -38,8 +36,8 @@ namespace o2::gpu
   #define GPUCA_GET_WARP_COUNT(...) 1            // since launch bound constants are not defined in host-code, and must evaluate to 1!
 #endif
 
-#define GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_MERGER_INTERPOLATION_ERROR_TYPE)
-#define GPUCA_DEDX_STORAGE_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_DEDX_STORAGE_TYPE)
+#define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE)
+#define GPUCA_PAR_DEDX_STORAGE_TYPE_A GPUCA_DETERMINISTIC_CODE(float, GPUCA_PAR_DEDX_STORAGE_TYPE)
 
 // #define GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE                       // Output Profiling Data for Tracklet Constructor Tracklet Scheduling
 
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 6753db280d5bf..43fa49ff74817 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -40,6 +40,7 @@
 #include "GPUTrackingInputProvider.h"
 #include "GPUNewCalibValues.h"
 #include "GPUTriggerOutputs.h"
+#include "GPUDefParametersRuntime.h"
 
 #include "GPUTPCClusterStatistics.h"
 #include "GPUHostDataTypes.h"
@@ -254,6 +255,7 @@ bool GPUChainTracking::ValidateSteps()
 
 bool GPUChainTracking::ValidateSettings()
 {
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   if ((param().rec.tpc.nWays & 1) == 0) {
     GPUError("nWay setting musst be odd number!");
     return false;
@@ -270,7 +272,7 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("NStreams of %d insufficient for %d nTPCClustererLanes", mRec->NStreams(), (int32_t)GetProcessingSettings().nTPCClustererLanes);
     return false;
   }
-  if (GetProcessingSettings().noGPUMemoryRegistration && GetProcessingSettings().tpcCompressionGatherMode != 3) {
+  if (GetProcessingSettings().noGPUMemoryRegistration && gatherMode != 3) {
     GPUError("noGPUMemoryRegistration only possible with gather mode 3");
     return false;
   }
@@ -286,7 +288,7 @@ bool GPUChainTracking::ValidateSettings()
       GPUError("Must use external output for double pipeline mode");
       return false;
     }
-    if (GetProcessingSettings().tpcCompressionGatherMode == 1) {
+    if (gatherMode == 1) {
       GPUError("Double pipeline incompatible to compression mode 1");
       return false;
     }
@@ -295,7 +297,7 @@ bool GPUChainTracking::ValidateSettings()
       return false;
     }
   }
-  if ((GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && !(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && (GetProcessingSettings().tpcCompressionGatherMode == 1 || GetProcessingSettings().tpcCompressionGatherMode == 3)) {
+  if ((GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && !(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && (gatherMode == 1 || gatherMode == 3)) {
     GPUError("Invalid tpcCompressionGatherMode for compression on CPU");
     return false;
   }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 03d319f42fd6b..8fb6fc4771658 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -18,6 +18,7 @@
 #include "GPUTrackingInputProvider.h"
 #include "GPUTPCCFChainContext.h"
 #include "TPCClusterDecompressor.h"
+#include "GPUDefParametersRuntime.h"
 #include "utils/strtag.h"
 
 #include <numeric>
@@ -30,6 +31,7 @@ int32_t GPUChainTracking::RunTPCCompression()
   mRec->PushNonPersistentMemory(qStr2Tag("TPCCOMPR"));
   RecoStep myStep = RecoStep::TPCCompression;
   bool doGPU = GetRecoStepsGPU() & RecoStep::TPCCompression;
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(doGPU).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   GPUTPCCompression& Compressor = processors()->tpcCompressor;
   GPUTPCCompression& CompressorShadow = doGPU ? processorsShadow()->tpcCompressor : Compressor;
   const auto& threadContext = GetThreadContext();
@@ -37,7 +39,7 @@ int32_t GPUChainTracking::RunTPCCompression()
     RecordMarker(&mEvents->single, 0);
   }
 
-  if (GetProcessingSettings().tpcCompressionGatherMode == 3) {
+  if (gatherMode == 3) {
     mRec->AllocateVolatileDeviceMemory(0); // make future device memory allocation volatile
   }
   SetupGPUProcessor(&Compressor, true);
@@ -70,7 +72,7 @@ int32_t GPUChainTracking::RunTPCCompression()
   Compressor.mOutputFlat->set(outputSize, *Compressor.mOutput);
   char* hostFlatPtr = (char*)Compressor.mOutput->qTotU; // First array as allocated in GPUTPCCompression::SetPointersCompressedClusters
   size_t copySize = 0;
-  if (GetProcessingSettings().tpcCompressionGatherMode == 3) {
+  if (gatherMode == 3) {
     CompressorShadow.mOutputA = Compressor.mOutput;
     copySize = AllocateRegisteredMemory(Compressor.mMemoryResOutputGPU); // We overwrite Compressor.mOutput with the allocated output pointers on the GPU
   }
@@ -81,8 +83,8 @@ int32_t GPUChainTracking::RunTPCCompression()
     SynchronizeStream(OutputStream()); // Synchronize output copies running in parallel from memory that might be released, only the following async copy from stacked memory is safe after the chain finishes.
     outputStream = OutputStream();
   }
-  if (GetProcessingSettings().tpcCompressionGatherMode >= 2) {
-    if (GetProcessingSettings().tpcCompressionGatherMode == 2) {
+  if (gatherMode >= 2) {
+    if (gatherMode == 2) {
       void* devicePtr = mRec->getGPUPointer(Compressor.mOutputFlat);
       if (devicePtr != Compressor.mOutputFlat) {
         CompressedClustersPtrs& ptrs = *Compressor.mOutput; // We need to update the ptrs with the gpu-mapped version of the host address space
@@ -94,7 +96,8 @@ int32_t GPUChainTracking::RunTPCCompression()
     TransferMemoryResourcesToGPU(myStep, &Compressor, outputStream);
     constexpr uint32_t nBlocksDefault = 2;
     constexpr uint32_t nBlocksMulti = 1 + 2 * 200;
-    switch (GetProcessingSettings().tpcCompressionGatherModeKernel) {
+    int32_t gatherModeKernel = mRec->GetProcessingSettings().tpcCompressionGatherModeKernel == -1 ? mRec->getGPUParameters(doGPU).par_COMP_GATHER_KERNEL : mRec->GetProcessingSettings().tpcCompressionGatherMode;
+    switch (gatherModeKernel) {
       case 0:
         runKernel<GPUTPCCompressionGatherKernels, GPUTPCCompressionGatherKernels::unbuffered>(GetGridBlkStep(nBlocksDefault, outputStream, RecoStep::TPCCompression));
         getKernelTimer<GPUTPCCompressionGatherKernels, GPUTPCCompressionGatherKernels::unbuffered>(RecoStep::TPCCompression, 0, outputSize, false);
@@ -117,10 +120,10 @@ int32_t GPUChainTracking::RunTPCCompression()
         getKernelTimer<GPUTPCCompressionGatherKernels, GPUTPCCompressionGatherKernels::multiBlock>(RecoStep::TPCCompression, 0, outputSize, false);
         break;
       default:
-        GPUError("Invalid compression kernel %d selected.", (int32_t)GetProcessingSettings().tpcCompressionGatherModeKernel);
+        GPUError("Invalid compression kernel %d selected.", (int32_t)gatherModeKernel);
         return 1;
     }
-    if (GetProcessingSettings().tpcCompressionGatherMode == 3) {
+    if (gatherMode == 3) {
       RecordMarker(&mEvents->stream[outputStream], outputStream);
       char* deviceFlatPts = (char*)Compressor.mOutput->qTotU;
       if (GetProcessingSettings().doublePipeline) {
@@ -135,9 +138,9 @@ int32_t GPUChainTracking::RunTPCCompression()
     }
   } else {
     int8_t direction = 0;
-    if (GetProcessingSettings().tpcCompressionGatherMode == 0) {
+    if (gatherMode == 0) {
       P = &CompressorShadow.mPtrs;
-    } else if (GetProcessingSettings().tpcCompressionGatherMode == 1) {
+    } else if (gatherMode == 1) {
       P = &Compressor.mPtrs;
       direction = -1;
       gatherTimer = &getTimer<GPUTPCCompressionKernels>("GPUTPCCompression_GatherOnCPU", 0);
@@ -181,11 +184,11 @@ int32_t GPUChainTracking::RunTPCCompression()
     GPUMemCpyAlways(myStep, O->timeA, P->timeA, O->nTracks * sizeof(O->timeA[0]), outputStream, direction);
     GPUMemCpyAlways(myStep, O->padA, P->padA, O->nTracks * sizeof(O->padA[0]), outputStream, direction);
   }
-  if (GetProcessingSettings().tpcCompressionGatherMode == 1) {
+  if (gatherMode == 1) {
     gatherTimer->Stop();
   }
   mIOPtrs.tpcCompressedClusters = Compressor.mOutputFlat;
-  if (GetProcessingSettings().tpcCompressionGatherMode == 3) {
+  if (gatherMode == 3) {
     SynchronizeEventAndRelease(mEvents->stream[outputStream]);
     mRec->ReturnVolatileDeviceMemory();
   }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index ffab3ba0be063..a647c213660c9 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -14,6 +14,7 @@
 
 #include "GPUChainTracking.h"
 #include "GPULogging.h"
+#include "GPUDefParametersRuntime.h"
 #include "GPUO2DataTypes.h"
 #include "GPUQA.h"
 #include "utils/strtag.h"
@@ -31,7 +32,7 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSecto
     runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::borderTracks>({{nBorderTracks, -WarpSize(), 0, deviceType}}, 0);
   }
   uint32_t n = withinSector == -1 ? NSECTORS / 2 : NSECTORS;
-  if (GetProcessingSettings().alternateBorderSort && (!mRec->IsGPU() || doGPU)) {
+  if (GetProcessingSettings().alternateBorderSort == -1 ? mRec->getGPUParameters(doGPU).par_ALTERNATE_BORDER_SORT : GetProcessingSettings().alternateBorderSort) {
     RecordMarker(&mEvents->single, 0);
     TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResMemory(), 0, &mEvents->init);
     for (uint32_t i = 0; i < n; i++) {
@@ -176,7 +177,8 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     waitForTransfer = 1;
   }
 
-  if (GetProcessingSettings().mergerSortTracks) {
+  const bool mergerSortTracks = GetProcessingSettings().mergerSortTracks == -1 ? mRec->getGPUParameters(doGPU).par_SORT_BEFORE_FIT : GetProcessingSettings().mergerSortTracks;
+  if (mergerSortTracks) {
     runKernel<GPUTPCGMMergerSortTracksPrepare>(GetGridAuto(0, deviceType));
     CondWaitEvent(waitForTransfer, &mEvents->single);
     runKernel<GPUTPCGMMergerSortTracks>(GetGridAuto(0, deviceType));
@@ -212,11 +214,11 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     mOutputQueue.clear();
   }
 
-  runKernel<GPUTPCGMMergerTrackFit>(doGPU ? GetGrid(Merger.NOutputTracks(), 0) : GetGridAuto(0), GetProcessingSettings().mergerSortTracks ? 1 : 0);
+  runKernel<GPUTPCGMMergerTrackFit>(doGPU ? GetGrid(Merger.NOutputTracks(), 0) : GetGridAuto(0), mergerSortTracks ? 1 : 0);
   if (param().rec.tpc.retryRefit == 1) {
     runKernel<GPUTPCGMMergerTrackFit>(GetGridAuto(0), -1);
   }
-  if (param().rec.tpc.looperInterpolationInExtraPass) {
+  if (param().rec.tpc.looperInterpolationInExtraPass == -1 ? mRec->getGPUParameters(doGPU).par_MERGER_SPLIT_LOOP_INTERPOLATION : param().rec.tpc.looperInterpolationInExtraPass) {
     runKernel<GPUTPCGMMergerFollowLoopers>(GetGridAuto(0));
   }
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 3e7447892307a..64a9179baf0e6 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -19,6 +19,7 @@
 #include "GPUTPCClusterData.h"
 #include "GPUTrackingInputProvider.h"
 #include "GPUTPCClusterOccupancyMap.h"
+#include "GPUDefParametersRuntime.h"
 #include "utils/strtag.h"
 #include <fstream>
 
@@ -200,11 +201,9 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     DoDebugAndDump(RecoStep::TPCSectorTracking, 4, trk, &GPUTPCTracker::DumpLinks, *mDebugFile, 1);
 
     runKernel<GPUTPCStartHitsFinder>({GetGridBlk(GPUCA_ROW_COUNT - 6, useStream), {iSector}});
-#ifdef GPUCA_SORT_STARTHITS_GPU
-    if (doGPU) {
+    if (mRec->getGPUParameters(doGPU).par_SORT_STARTHITS) {
       runKernel<GPUTPCStartHitsSorter>({GetGridAuto(useStream), {iSector}});
     }
-#endif
     if (GetProcessingSettings().deterministicGPUReconstruction) {
       runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::startHits>({GetGrid(1, 1, useStream), {iSector}});
     }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index bdf60f744b9ca..f42e5f35b1dc9 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -37,6 +37,7 @@
 #include "TPCFastTransform.h"
 #include "GPUTPCConvertImpl.h"
 #include "GPUTPCGeometry.h"
+#include "GPUDefParametersRuntime.h"
 
 #include "GPUCommonMath.h"
 #include "GPUCommonAlgorithm.h"
@@ -288,7 +289,8 @@ void* GPUTPCGMMerger::SetPointersMemory(void* mem)
 void* GPUTPCGMMerger::SetPointersRefitScratch(void* mem)
 {
   computePointerWithAlignment(mem, mTrackOrderAttach, mNMaxTracks);
-  if (mRec->GetProcessingSettings().mergerSortTracks) {
+  const bool mergerSortTracks = mRec->GetProcessingSettings().mergerSortTracks == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCMerging).par_SORT_BEFORE_FIT : mRec->GetProcessingSettings().mergerSortTracks;
+  if (mergerSortTracks) {
     computePointerWithAlignment(mem, mTrackOrderProcess, mNMaxTracks);
   }
   return mem;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h b/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
index 238b04510862e..ba251ce34a3eb 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
@@ -32,7 +32,7 @@ enum attachTypes { attachAttached = 0x40000000,
 
 struct InterpolationErrorHit {
   float posY, posZ;
-  GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A errorY, errorZ;
+  GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A errorY, errorZ;
 };
 
 struct InterpolationErrors {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index f1aac3da9a7a2..1617ac7b828af 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -663,7 +663,7 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow,
   GPUCA_DEBUG_STREAMER_CHECK(if (debugVals) { debugVals->err2Y = err2Y; debugVals->err2Z = err2Z; });
 
   if (rejectChi2 >= rejectInterFill) {
-    if (rejectChi2 == rejectInterReject && inter->errorY < (GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
+    if (rejectChi2 == rejectInterReject && inter->errorY < (GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
       rejectChi2 = rejectDirect;
     } else {
       int32_t retVal = InterpolateReject(param, posY, posZ, clusterState, rejectChi2, inter, err2Y, err2Z);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 260c64db052af..77453a87b3763 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -309,7 +309,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       } else {
         int8_t rejectChi2 = attempt ? 0 : ((param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (refit ? (GPUTPCGMPropagator::rejectInterFill + ((nWays - iWay) & 1)) : 0) : (allowModification && goodRows > 5));
 #if EXTRACT_RESIDUALS == 1
-        if (iWay == nWays - 1 && interpolation.hit[ihit].errorY > (GPUCA_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
+        if (iWay == nWays - 1 && interpolation.hit[ihit].errorY > (GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
           const float Iz0 = interpolation.hit[ihit].posY - mP[0];
           const float Iz1 = interpolation.hit[ihit].posZ - mP[1];
           float Iw0 = mC[2] + (float)interpolation.hit[ihit].errorZ;
@@ -631,7 +631,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
     for (uint32_t ih = hitFst; ih < hitLst; ih++) {
       int32_t id = idOffset + ids[ih];
       GPUAtomic(uint32_t)* const weight = weights + id;
-#if !defined(GPUCA_NO_ATOMIC_PRECHECK) && GPUCA_NO_ATOMIC_PRECHECK < 1
+#if GPUCA_NO_ATOMIC_PRECHECK == 0
       if (myWeight <= *weight) {
         continue;
       }
@@ -757,7 +757,8 @@ GPUdic(0, 1) int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUr
   if (Merger->Param().rec.tpc.disableRefitAttachment & 4) {
     return 1;
   }
-  if (Merger->Param().rec.tpc.looperInterpolationInExtraPass && phase2 == false) {
+  const bool inExtraPass = Merger->Param().rec.tpc.looperInterpolationInExtraPass == -1 ? GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION : Merger->Param().rec.tpc.looperInterpolationInExtraPass;
+  if (inExtraPass && phase2 == false) {
     StoreAttachMirror(Merger, sector, iRow, iTrack, toAlpha, toY, toX, toSector, toRow, inFlyDirection, prop.GetAlpha());
     return 1;
   }
@@ -862,7 +863,8 @@ GPUdni() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPU
   if (Merger->Param().rec.tpc.disableRefitAttachment & 8) {
     return;
   }
-  if (Merger->Param().rec.tpc.looperInterpolationInExtraPass && phase2 == false) {
+  const bool inExtraPass = Merger->Param().rec.tpc.looperInterpolationInExtraPass == -1 ? GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION : Merger->Param().rec.tpc.looperInterpolationInExtraPass;
+  if (inExtraPass && phase2 == false) {
     StoreAttachMirror(Merger, sector, iRow, iTrack, 0, toY, 0, -1, 0, 0, prop.GetAlpha());
     return;
   }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
index ec348b59ce7a5..d76c079bb406f 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
@@ -76,7 +76,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
   }
 
 #define UnrollGlobal 4
-#define MaxShared GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP
+#define MaxShared GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP
 #if MaxShared < GPUCA_MAXN
 #define MaxGlobal ((GPUCA_MAXN - MaxShared - 1) / UnrollGlobal + 1) * UnrollGlobal
 #else
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
index 1bf5000cfbe5c..0ecd230a67415 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
@@ -40,11 +40,11 @@ class GPUTPCNeighboursFinder : public GPUKernelTemplate
     int32_t mIRow;   // row number
     int32_t mIRowUp; // next row number
     int32_t mIRowDn; // previous row number
-#if GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP > 0
-    static_assert(GPUCA_MAXN >= GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP);
-    float mA1[GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
-    float mA2[GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
-    calink mB[GPUCA_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
+#if GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP > 0
+    static_assert(GPUCA_MAXN >= GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP);
+    float mA1[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
+    float mA2[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
+    calink mB[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
 #endif
     GPUTPCRow mRow, mRowUp, mRowDown;
   };
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
index af79dddae554e..20dfd69864816 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
@@ -39,7 +39,7 @@ GPUdii() void GPUTPCStartHitsFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nThr
     uint32_t linkUpData = tracker.mData.mLinkUpData[lHitNumberOffset + ih];
 
     if (tracker.mData.mLinkDownData[lHitNumberOffset + ih] == CALINK_INVAL && linkUpData != CALINK_INVAL && tracker.mData.mLinkUpData[rowUp.mHitNumberOffset + linkUpData] != CALINK_INVAL) {
-#ifdef GPUCA_SORT_STARTHITS
+#if GPUCA_PAR_SORT_STARTHITS > 0
       GPUglobalref() GPUTPCHitId* const GPUrestrict() startHits = tracker.mTrackletTmpStartHits + s.mIRow * tracker.mNMaxRowStartHits;
       uint32_t nextRowStartHits = CAMath::AtomicAddShared(&s.mNRowStartHits, 1u);
       if (nextRowStartHits >= tracker.mNMaxRowStartHits) {
@@ -61,7 +61,7 @@ GPUdii() void GPUTPCStartHitsFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nThr
   }
   GPUbarrier();
 
-#ifdef GPUCA_SORT_STARTHITS
+#if GPUCA_PAR_SORT_STARTHITS > 0
   if (iThread == 0) {
     uint32_t nOffset = CAMath::AtomicAdd(&tracker.mCommonMem->nStartHits, s.mNRowStartHits);
     tracker.mRowStartHitCountOffset[s.mIRow] = s.mNRowStartHits;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index 6c1b4eda0d7f5..e923e126e1841 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -22,6 +22,7 @@
 #include "GPUTPCTrackParam.h"
 #include "GPUParam.inc"
 #include "GPUTPCConvertImpl.h"
+#include "GPUDefParametersRuntime.h"
 
 #if !defined(GPUCA_GPUCODE)
 #include <cstring>
@@ -143,13 +144,12 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   mNMaxRowHits = mRec->MemoryScalers()->NTPCTrackletHits(mData.NumberOfHits());
   mNMaxTracks = mRec->MemoryScalers()->NTPCSectorTracks(mData.NumberOfHits());
   mNMaxTrackHits = mRec->MemoryScalers()->NTPCSectorTrackHits(mData.NumberOfHits(), mRec->GetProcessingSettings().tpcInputWithClusterRejection);
-#ifdef GPUCA_SORT_STARTHITS_GPU
-  if (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) {
+
+  if (mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking).par_SORT_STARTHITS) {
     if (mNMaxStartHits > mNMaxRowStartHits * GPUCA_ROW_COUNT) {
       mNMaxStartHits = mNMaxRowStartHits * GPUCA_ROW_COUNT;
     }
   }
-#endif
   mData.SetMaxData();
 }
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
index 8810b692e1377..e27a8f66ae754 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
@@ -33,7 +33,7 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
   }
   GPUbarrier();
 
-  GPUTPCHitId trackHits[GPUCA_ROW_COUNT - GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE];
+  GPUTPCHitId trackHits[GPUCA_ROW_COUNT - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
   const float maxSharedFrac = tracker.Param().rec.tpc.trackletMaxSharedFraction;
 
   for (int32_t itr = s.mItr0 + iThread; itr < s.mNTracklets; itr += s.mNThreadsTotal) {
@@ -67,13 +67,13 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
         bool sharedOK = nShared <= (nHits < sharingMinNorm ? maxShared : nHits * maxSharedFrac);
         if (own || sharedOK) { // SG!!!
           gap = 0;
-#if GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-          if (nHits < GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE) {
+#if GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+          if (nHits < GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE) {
             s.mHits[nHits][iThread].Set(irow, ih);
           } else
-#endif // GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+#endif // GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
           {
-            trackHits[nHits - GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE].Set(irow, ih);
+            trackHits[nHits - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE].Set(irow, ih);
           }
           nHits++;
           if (!own) {
@@ -101,13 +101,13 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
           tracker.Tracks()[itrout].SetFirstHitID(nFirstTrackHit);
           tracker.Tracks()[itrout].SetNHits(nHits);
           for (int32_t jh = 0; jh < nHits; jh++) {
-#if GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-            if (jh < GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE) {
+#if GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+            if (jh < GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE) {
               tracker.TrackHits()[nFirstTrackHit + jh] = s.mHits[jh][iThread];
             } else
-#endif // GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+#endif // GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
             {
-              tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE];
+              tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
             }
           }
         }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
index f487931bdaf4b..e5a28c80f37f9 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
@@ -36,10 +36,10 @@ class GPUTPCTrackletSelector : public GPUKernelTemplate
     int32_t mNThreadsTotal; // total n threads
     int32_t mNTracklets;    // n of tracklets
     int32_t mReserved;      // for alignment reasons
-#if GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-    static_assert(GPUCA_ROW_COUNT >= GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE);
-    GPUTPCHitId mHits[GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletSelector)];
-#endif // GPUCA_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+#if GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
+    static_assert(GPUCA_ROW_COUNT >= GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE);
+    GPUTPCHitId mHits[GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletSelector)];
+#endif // GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index 7faab410d20ea..35f2915d9486a 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -18,6 +18,8 @@ define_property(TARGET PROPERTY O2_GPU_KERNEL_NAMES)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_INCLUDES)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_FILES)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_NO_FAST_MATH)
+define_property(TARGET PROPERTY O2_GPU_KERNEL_PARAMS)
+define_property(TARGET PROPERTY O2_GPU_KERNEL_STRING_PARAMS)
 set(O2_GPU_KERNEL_WRAPPER_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/GPU/include_gpu_onthefly")
 file(MAKE_DIRECTORY ${O2_GPU_KERNEL_WRAPPER_FOLDER})
 set(O2_GPU_BASE_DIR "${CMAKE_CURRENT_LIST_DIR}/../")
@@ -167,3 +169,20 @@ function(o2_gpu_kernel_set_deterministic)
     endif()
   endforeach()
 endfunction()
+
+function(o2_gpu_kernel_add_parameter)
+  list(LENGTH ARGV n)
+  math(EXPR n "${n} - 1")
+  foreach(i RANGE 0 ${n})
+    message(STATUS "Adding ${ARGV${i}}")
+    set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_PARAMS "${ARGV${i}}")
+  endforeach()
+endfunction()
+function(o2_gpu_kernel_add_string_parameter)
+  list(LENGTH ARGV n)
+  math(EXPR n "${n} - 1")
+  foreach(i RANGE 0 ${n})
+    message(STATUS "Adding ${ARGV${i}}")
+    set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_STRING_PARAMS "${ARGV${i}}")
+  endforeach()
+endfunction()
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.cxx b/GPU/GPUTracking/dEdx/GPUdEdx.cxx
index fd2aeda2828e3..340463b9ec7f7 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.cxx
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.cxx
@@ -55,7 +55,7 @@ GPUd() void GPUdEdx::computedEdx(GPUdEdxInfo& GPUrestrict() output, const GPUPar
   output.NHitsSubThresholdOROC3 = countOROC3;
 }
 
-GPUd() float GPUdEdx::GetSortTruncMean(GPUCA_DEDX_STORAGE_TYPE_A* GPUrestrict() array, int32_t count, int32_t trunclow, int32_t trunchigh)
+GPUd() float GPUdEdx::GetSortTruncMean(GPUCA_PAR_DEDX_STORAGE_TYPE_A* GPUrestrict() array, int32_t count, int32_t trunclow, int32_t trunchigh)
 {
   trunclow = count * trunclow / 128;
   trunchigh = count * trunchigh / 128;
@@ -65,7 +65,7 @@ GPUd() float GPUdEdx::GetSortTruncMean(GPUCA_DEDX_STORAGE_TYPE_A* GPUrestrict()
   CAAlgo::sort(array, array + count);
   float mean = 0;
   for (int32_t i = trunclow; i < trunchigh; i++) {
-    mean += (float)array[i] * (1.f / scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor);
+    mean += (float)array[i] * (1.f / scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::factor);
   }
   return (mean / (trunchigh - trunclow));
 }
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index 4d3b652bdc5d1..e556fd3845d42 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -37,7 +37,7 @@ class GPUdEdx
   GPUd() void computedEdx(GPUdEdxInfo& output, const GPUParam& param);
 
  private:
-  GPUd() float GetSortTruncMean(GPUCA_DEDX_STORAGE_TYPE_A* array, int32_t count, int32_t trunclow, int32_t trunchigh);
+  GPUd() float GetSortTruncMean(GPUCA_PAR_DEDX_STORAGE_TYPE_A* array, int32_t count, int32_t trunclow, int32_t trunchigh);
   GPUd() void checkSubThresh(int32_t roc);
 
   template <typename T, typename fake = void>
@@ -62,8 +62,8 @@ class GPUdEdx
 
   static constexpr int32_t MAX_NCL = GPUCA_ROW_COUNT; // Must fit in mNClsROC (uint8_t)!
 
-  GPUCA_DEDX_STORAGE_TYPE_A mChargeTot[MAX_NCL]; // No need for default, just some memory
-  GPUCA_DEDX_STORAGE_TYPE_A mChargeMax[MAX_NCL]; // No need for default, just some memory
+  GPUCA_PAR_DEDX_STORAGE_TYPE_A mChargeTot[MAX_NCL]; // No need for default, just some memory
+  GPUCA_PAR_DEDX_STORAGE_TYPE_A mChargeMax[MAX_NCL]; // No need for default, just some memory
   float mSubThreshMinTot = 0.f;
   float mSubThreshMinMax = 0.f;
   uint8_t mNClsROC[4] = {0};
@@ -78,8 +78,8 @@ GPUdi() void GPUdEdx::checkSubThresh(int32_t roc)
   if (roc != mLastROC) {
     if (mNSubThresh && mCount + mNSubThresh <= MAX_NCL) {
       for (int32_t i = 0; i < mNSubThresh; i++) {
-        mChargeTot[mCount] = (GPUCA_DEDX_STORAGE_TYPE_A)(mSubThreshMinTot * scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::round);
-        mChargeMax[mCount++] = (GPUCA_DEDX_STORAGE_TYPE_A)(mSubThreshMinMax * scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::round);
+        mChargeTot[mCount] = (GPUCA_PAR_DEDX_STORAGE_TYPE_A)(mSubThreshMinTot * scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::round);
+        mChargeMax[mCount++] = (GPUCA_PAR_DEDX_STORAGE_TYPE_A)(mSubThreshMinMax * scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::round);
       }
       mNClsROC[mLastROC] += mNSubThresh;
       mNClsROCSubThresh[mLastROC] += mNSubThresh;
@@ -151,8 +151,8 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
   qmax /= residualGainMapGain;
   qtot /= residualGainMapGain;
 
-  mChargeTot[mCount] = (GPUCA_DEDX_STORAGE_TYPE_A)(qtot * scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::round);
-  mChargeMax[mCount++] = (GPUCA_DEDX_STORAGE_TYPE_A)(qmax * scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_DEDX_STORAGE_TYPE_A>::round);
+  mChargeTot[mCount] = (GPUCA_PAR_DEDX_STORAGE_TYPE_A)(qtot * scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::round);
+  mChargeMax[mCount++] = (GPUCA_PAR_DEDX_STORAGE_TYPE_A)(qmax * scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::round);
   mNClsROC[roc]++;
   if (qtot < mSubThreshMinTot) {
     mSubThreshMinTot = qtot;
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 994f10a516b10..ee3af2b87d925 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -134,3 +134,16 @@ o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                         "GPUTPCCFD
 o2_gpu_add_kernel("GPUTPCCFGather"                                    "="                                                     LB o2::tpc::ClusterNative* dest)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                "= GLOBALREFIT "                                        LB)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"        "= GLOBALREFIT "                                        LB)
+
+o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP
+                            TRACKLET_SELECTOR_HITS_REG_SIZE
+                            ALTERNATE_BORDER_SORT
+                            SORT_BEFORE_FIT
+                            MERGER_SPLIT_LOOP_INTERPOLATION
+                            NO_ATOMIC_PRECHECK
+                            COMP_GATHER_KERNEL
+                            COMP_GATHER_MODE
+                            SORT_STARTHITS)
+
+o2_gpu_kernel_add_string_parameter(DEDX_STORAGE_TYPE
+                                   MERGER_INTERPOLATION_ERROR_TYPE)

From 9cb8054883602562b7f62034bb468bb3ed707017 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 16 Apr 2025 10:15:47 +0200
Subject: [PATCH 0245/1764] DPL GUI: do not sent any state when GUI is disabled
 (#14184)

---
 Framework/Core/src/CommonServices.cxx | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index e13f1cb2094b7..5c333bbb85e3b 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -44,6 +44,7 @@
 #include "Framework/DeviceConfig.h"
 #include "Framework/DefaultsHelpers.h"
 #include "Framework/Signpost.h"
+#include "Framework/DriverConfig.h"
 
 #include "TextDriverClient.h"
 #include "WSDriverClient.h"
@@ -800,6 +801,9 @@ auto sendRelayerMetrics(ServiceRegistryRef registry, DataProcessingStats& stats)
 
 auto flushStates(ServiceRegistryRef registry, DataProcessingStates& states) -> void
 {
+  if (!registry.get<DriverConfig const>().driverHasGUI) {
+    return;
+  }
   states.flushChangedStates([&states, registry](std::string const& spec, int64_t timestamp, std::string_view value) mutable -> void {
     auto& client = registry.get<ControlService>();
     client.push(spec, value, timestamp);

From 39b766b44eb9a19c9f8dc4c39f880273ea1205f1 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Mon, 14 Apr 2025 15:06:19 +0200
Subject: [PATCH 0246/1764] Updated EPOS4 example using different versions and
 HQ

---
 run/SimExamples/HepMC_EPOS4/README.md     |  7 ++--
 run/SimExamples/HepMC_EPOS4/epos.sh       | 36 +++++++++++++++----
 run/SimExamples/HepMC_EPOS4/example.optns |  3 +-
 run/SimExamples/HepMC_EPOS4/rundpg.sh     | 42 ++++++++++++++++++++--
 run/SimExamples/HepMC_EPOS4/rundpl.sh     | 43 +++++++++++++++++++++--
 run/SimExamples/HepMC_EPOS4/runo2sim.sh   | 42 ++++++++++++++++++++--
 6 files changed, 156 insertions(+), 17 deletions(-)
 mode change 100644 => 100755 run/SimExamples/HepMC_EPOS4/README.md
 mode change 100644 => 100755 run/SimExamples/HepMC_EPOS4/example.optns
 mode change 100644 => 100755 run/SimExamples/HepMC_EPOS4/rundpg.sh
 mode change 100644 => 100755 run/SimExamples/HepMC_EPOS4/runo2sim.sh

diff --git a/run/SimExamples/HepMC_EPOS4/README.md b/run/SimExamples/HepMC_EPOS4/README.md
old mode 100644
new mode 100755
index 94c50572cff9f..8609501a6981a
--- a/run/SimExamples/HepMC_EPOS4/README.md
+++ b/run/SimExamples/HepMC_EPOS4/README.md
@@ -7,10 +7,12 @@ An in-depth explanation of the mechanisms behind the HepMC(3) data handling can
 HepMC_fifo folder of the MC examples. The scripts use the `cmd` parameter of `GeneratorHepMC`
 to spawn the EPOS4 generation via the `epos.sh` script.
 
-EPOS4 uses the outdated HepMC2 libraries, so this had to be specified in the steering scripts
+EPOS 4.0.0 uses the outdated HepMC2 libraries, so this had to be specified in the steering scripts
 of the generators configuration. If `HepMC.version=2` is removed then the scripts will not work
 anymore. This is to say that the balance achieved with the configurations provided is easily
 destroyed if the user base edits parts that are not understood completely.
+The latest EPOS 4.0.3 and EPOS4HQ both use HepMC3, so the version is automatically
+updated when these generators are used.
 
 # Scripts description
 
@@ -47,6 +49,7 @@ If no parameters are provided to the scripts, they will run with default values
 - **-n , --nevents** &rarr; changes the number of events in the .optns file or gets the one in the file if no events are provided
 - **-i , --input** &rarr; .optns filename to feed EPOS4, no extension must be set in the filename
 - **-j , --jobs** &rarr; sets the number of workers (jobs)
+- **-hq** &rarr; enables EPOS4HQ generation
 - **-h , --help** &rarr; prints usage instructions
 - **-e , --ecm** &rarr; sets the center-of-mass energy in the options file
 
@@ -62,6 +65,6 @@ Now the three scripts start to differ:
 - **rundpg.sh** &rarr; first the o2dpg_sim_workflow.py script will be launched generating the json configuration, then the o2_dpg_workflow_runner.py script will start the workflow
 - **rundpl.sh** &rarr; o2-sim-dpl-eventgen is executed piping its results to o2-sim-mctracks-to-aod and afterwards to o2-analysis-mctracks-to-aod-simple-task
 
-The last few lines of the scripts contain the execution of o2-sim, DPG worflow creator/runner and DPL software respectively, so this part can be modified by the users following their requirements. It's important not to delete from the configuration keys `GeneratorFileOrCmd.cmd=$cmd -i $optns;GeneratorFileOrCmd.bMaxSwitch=none;HepMC.version=2;` and it would be better to provide additional configurations via the -m flag. EPOS4 cannot set a maximum impact parameter value, so it's better to leave the bMaxSwitch to none, while the others serve the sole purpose of running successfully the generator using auto generated FIFOs.
+The last few lines of the scripts contain the execution of o2-sim, DPG worflow creator/runner and DPL software respectively, so this part can be modified by the users following their requirements. It's important not to delete from the configuration keys `GeneratorFileOrCmd.cmd=$cmd -i $optns;GeneratorFileOrCmd.bMaxSwitch=none$HEPMC;` and it would be better to provide additional configurations via the -m flag. EPOS4 cannot set a maximum impact parameter value, so it's better to leave the bMaxSwitch to none, while the others serve the sole purpose of running successfully the generator using auto generated FIFOs.
 
 
diff --git a/run/SimExamples/HepMC_EPOS4/epos.sh b/run/SimExamples/HepMC_EPOS4/epos.sh
index 46a7dbfa27e5c..a4185b756bf56 100755
--- a/run/SimExamples/HepMC_EPOS4/epos.sh
+++ b/run/SimExamples/HepMC_EPOS4/epos.sh
@@ -1,11 +1,23 @@
-#!/bin/sh
+#!/bin/bash
 # Script based on CRMC example
 # EPOS4 option files must contain ihepmc set to 2 to print HepMC
 # data on stdout. -hepmc flag is not needed anymore, but -hepstd is fundamental
 # in order not to print useless information on stdout (a z-*optns*.mtr file will be created)
 
 optns="example"
-seed=$RANDOM
+seed=1
+EPOS4=""
+
+if [ -z "$EPO4VSN" ]; then
+    # Error: EPO4VSN environment variable is not set
+    exit 1
+fi
+
+if [ "$EPO4VSN" = "4.0.0" ]; then
+    EPOS4="$EPOS4_ROOT/epos4/scripts/epos"
+else
+    EPOS4="$EPOS4_ROOT/bin/epos"
+fi
 
 while test $# -gt 0 ; do
     case $1 in
@@ -18,13 +30,23 @@ done
 
 if [ ! -f $optns.optns ]; then
     echo "Error: Options file $optns.optns not found"
-    exit 1
+    exit 2
+fi
+
+if grep -Fq "set ihq 1" $optns.optns; then
+    if [ -z "$EPO4HQVSN" ]; then
+        # Error: EPOS4HQ version not found
+        exit 3
+    else
+        # Running with EPOS4HQ
+        EPOS4="$EPO4HQ/bin/eposhq"
+    fi
 fi
 
 if [ $seed -eq 0 ]; then
-    echo "Seed can't be 0, random number will be used"
-    seed=$RANDOM
+    # Seed can't be 0, random number will be used
+    seed="$RANDOM"
 fi
 
-# Or filters the stdout with only HepMC2 useful data
-$EPOS4_ROOT/epos4/scripts/epos -hepstd -s $seed $optns | sed -n 's/^\(HepMC::\|[EAUWVP] \)/\1/p'
+# OR filters the stdout with only HepMC useful data
+$EPOS4 -hepstd -s $seed $optns | sed -n 's/^\(HepMC::\|[EAUWVP] \)/\1/p'
diff --git a/run/SimExamples/HepMC_EPOS4/example.optns b/run/SimExamples/HepMC_EPOS4/example.optns
old mode 100644
new mode 100755
index c2b067941e4e8..9df738d15fcff
--- a/run/SimExamples/HepMC_EPOS4/example.optns
+++ b/run/SimExamples/HepMC_EPOS4/example.optns
@@ -29,4 +29,5 @@ set nfreeze 1            !number of freeze out events per hydro event
 set modsho 1             !printout every modsho events
 set centrality 0         !0=min bias
 set ihepmc 2             !HepMC output enabled on stdout
-set nfull 10
+set nfull 10             !Total nEvents to be generated
+set ihq 1                !Enable EPOS4HQ
diff --git a/run/SimExamples/HepMC_EPOS4/rundpg.sh b/run/SimExamples/HepMC_EPOS4/rundpg.sh
old mode 100644
new mode 100755
index 93993f66bfbd6..ea6d29ce0fa54
--- a/run/SimExamples/HepMC_EPOS4/rundpg.sh
+++ b/run/SimExamples/HepMC_EPOS4/rundpg.sh
@@ -23,6 +23,18 @@ optns="example"
 TF=1
 eCM=-1
 JOBS=2
+HEPMC=""
+HQ=false
+
+if [ -z "$EPO4VSN" ]; then
+    echo "Error: EPOS4 version not found"
+    exit 7
+fi
+if [ "$EPO4VSN" == "4.0.0" ]; then
+    HEPMC=";HepMC.version=2"
+else
+    HEPMC=";HepMC.version=3"
+fi
 
 usage()
 {
@@ -38,6 +50,7 @@ Options:
   -h,--help                Print these instructions
   -e,--ecm     ENERGY      Center-of-Mass energy
   -t,--tf      TF          Timeframes ($TF)
+  -hq          HQ          Enable EPOS4HQ
   --                       Rest of command line sent to o2-sim
 
 COMMAND must be quoted if it contains spaces or other special
@@ -59,6 +72,7 @@ while test $# -gt 0 ; do
         -i|--input)   optns=$2 ; shift ;;
         -j|--jobs)    JOBS=$2 ; shift ;;
         -e|--ecm)     eCM=$2 ; shift ;;
+        -hq)          HQ=true ; shift ;;
         -h|--help) usage; ${O2DPG_ROOT}/MC/bin/o2dpg_sim_workflow.py --help  ; exit 0 ;;
         -t|--tf)     TF=$2 ; shift ;;
         --)           shift ; break ;;
@@ -115,6 +129,30 @@ else
     fi
 fi
 
+# Set HQ mode
+
+if [ "$HQ" = true ]; then
+    echo "Setting HQ mode"
+    if grep -Fq "ihq" $optns.optns; then
+        sed -i "/ihq/c\set ihq 1" $optns.optns
+    else
+        echo "set ihq 1" >> $optns.optns
+    fi
+    if [ -z "$EPO4HQVSN" ]; then
+        echo "Error: EPOS4HQ version not found"
+        exit 7
+    else
+        HEPMC=";HepMC.version=3"
+    fi
+else
+    echo "Turning OFF HQ mode"
+    if grep -Fq "ihq" $optns.optns; then
+        sed -i "/ihq/c\set ihq 0" $optns.optns
+    else
+        echo "set ihq 0" >> $optns.optns
+    fi
+fi
+
 # Copy options file in each timeframe folder
 for i in $(seq 1 $TF); do
     if [ ! -d tf$i ]; then
@@ -125,8 +163,8 @@ done
 
 # create workflow
 
-${O2DPG_ROOT}/MC/bin/o2dpg_sim_workflow.py -eCM $eCM -ns $NEV -gen hepmc -tf $TF -j $JOBS \
-        -interactionRate 500000 -confKey "GeneratorFileOrCmd.cmd=$cmd -i $optns;GeneratorFileOrCmd.bMaxSwitch=none;HepMC.version=2;${more}"
+${O2DPG_ROOT}/MC/bin/o2dpg_sim_workflow.py -eCM $eCM -ns $NEV -gen hepmc -tf $TF -j $JOBS -seed $RANDOM \
+        -interactionRate 500000 -confKey "GeneratorFileOrCmd.cmd=$cmd -i $optns;GeneratorFileOrCmd.bMaxSwitch=none$HEPMC;${more}"
 
 # Run workflow
 ${O2DPG_ROOT}/MC/bin/o2_dpg_workflow_runner.py -f workflow.json -tt aod --stdout-on-failure
diff --git a/run/SimExamples/HepMC_EPOS4/rundpl.sh b/run/SimExamples/HepMC_EPOS4/rundpl.sh
index c3851175d08f4..919eedf1a2340 100755
--- a/run/SimExamples/HepMC_EPOS4/rundpl.sh
+++ b/run/SimExamples/HepMC_EPOS4/rundpl.sh
@@ -21,6 +21,18 @@ more=""
 optns="example"
 eCM=-1
 JOBS=2
+HEPMC=""
+HQ=false
+
+if [ -z "$EPO4VSN" ]; then
+    echo "Error: EPOS4 version not found"
+    exit 7
+fi
+if [ "$EPO4VSN" == "4.0.0" ]; then
+    HEPMC=";HepMC.version=2"
+else
+    HEPMC=";HepMC.version=3"
+fi
 
 usage()
 {
@@ -35,6 +47,7 @@ Options:
   -j,--jobs    JOBS        Number of jobs ($JOBS)
   -e,--ecm     ENERGY      Center-of-Mass energy
   -h,--help                Print these instructions
+  -hq          HQ          Enable EPOS4HQ
   --                       Rest of command line sent to o2-sim
 
 COMMAND must be quoted if it contains spaces or other special
@@ -56,6 +69,7 @@ while test $# -gt 0 ; do
         -i|--input)   optns=$2 ; shift ;;
         -j|--jobs)    JOBS=$2 ; shift ;;
         -e|--ecm)     eCM=$2 ; shift ;;
+        -hq)          HQ=true ; shift ;;
         -h|--help) usage; o2-sim-dpl-eventgen --help full ; exit 0 ;;
         --)           shift ; break ;;
         *) echo "Unknown option '$1', did you forget '--'?" >/dev/stderr
@@ -111,9 +125,32 @@ else
     fi
 fi
 
-# Starting simulation => seed is fed automatically to epos with the --seed flag. HepMC.version = 2 is mandatory
+# Set HQ mode
+
+if [ "$HQ" = true ]; then
+    echo "Setting HQ mode"
+    if grep -Fq "ihq" $optns.optns; then
+        sed -i "/ihq/c\set ihq 1" $optns.optns
+    else
+        echo "set ihq 1" >> $optns.optns
+    fi
+    if [ -z "$EPO4HQVSN" ]; then
+        echo "Error: EPOS4HQ version not found"
+        exit 7
+    else
+        HEPMC=";HepMC.version=3"
+    fi
+else
+    echo "Turning OFF HQ mode"
+    if grep -Fq "ihq" $optns.optns; then
+        sed -i "/ihq/c\set ihq 0" $optns.optns
+    else
+        echo "set ihq 0" >> $optns.optns
+    fi
+fi
+
+# Starting simulation => seed is fed automatically to epos with the --seed flag. HepMC.version = 2 is mandatory for version 4.0.0
 # otherwise the simulation won't work.
 # Seed is automatically set to Random by the epos.sh script because the --seed option with o2-sim-dpl-eventgen does not feed the number to GeneratorHepMC
-
-o2-sim-dpl-eventgen -b --nEvents ${NEV} --generator hepmc --configKeyValues "GeneratorFileOrCmd.cmd=$cmd -i $optns;GeneratorFileOrCmd.bMaxSwitch=none;HepMC.version=2;${more}" |\
+o2-sim-dpl-eventgen -b --nEvents ${NEV} --generator hepmc --configKeyValues "GeneratorFileOrCmd.cmd=$cmd -i $optns;GeneratorFileOrCmd.bMaxSwitch=none$HEPMC;${more}" |\
                     o2-sim-mctracks-to-aod -b | o2-analysis-mctracks-to-aod-simple-task -b
diff --git a/run/SimExamples/HepMC_EPOS4/runo2sim.sh b/run/SimExamples/HepMC_EPOS4/runo2sim.sh
old mode 100644
new mode 100755
index 31698f39a87f0..a241f9affba19
--- a/run/SimExamples/HepMC_EPOS4/runo2sim.sh
+++ b/run/SimExamples/HepMC_EPOS4/runo2sim.sh
@@ -21,6 +21,18 @@ more=""
 optns="example"
 eCM=-1
 JOBS=2
+HEPMC=""
+HQ=false
+
+if [ -z "$EPO4VSN" ]; then
+    echo "Error: EPOS4 version not found"
+    exit 7
+fi
+if [ "$EPO4VSN" == "4.0.0" ]; then
+    HEPMC=";HepMC.version=2"
+else
+    HEPMC=";HepMC.version=3"
+fi
 
 usage()
 {
@@ -35,6 +47,7 @@ Options:
   -j,--jobs    JOBS        Number of jobs ($JOBS)
   -e,--ecm     ENERGY      Center-of-Mass energy
   -h,--help                Print these instructions
+  -hq          HQ          Enable EPOS4HQ
   --                       Rest of command line sent to o2-sim
 
 COMMAND must be quoted if it contains spaces or other special
@@ -56,6 +69,7 @@ while test $# -gt 0 ; do
         -i|--input)   optns=$2 ; shift ;;
         -j|--jobs)    JOBS=$2 ; shift ;;
         -e|--ecm)     eCM=$2 ; shift ;;
+        -hq)          HQ=true ; shift ;;
         -h|--help) usage; o2-sim --help full ; exit 0 ;;
         --)           shift ; break ;;
         *) echo "Unknown option '$1', did you forget '--'?" >/dev/stderr
@@ -111,7 +125,31 @@ else
     fi
 fi
 
-# Starting simulation => seed is fed automatically to epos with the --seed flag. HepMC.version = 2 is mandatory
+# Set HQ mode
+
+if [ "$HQ" = true ]; then
+    echo "Setting HQ mode"
+    if grep -Fq "ihq" $optns.optns; then
+        sed -i "/ihq/c\set ihq 1" $optns.optns
+    else
+        echo "set ihq 1" >> $optns.optns
+    fi
+    if [ -z "$EPO4HQVSN" ]; then
+        echo "Error: EPOS4HQ version not found"
+        exit 7
+    else
+        HEPMC=";HepMC.version=3"
+    fi
+else
+    echo "Turning OFF HQ mode"
+    if grep -Fq "ihq" $optns.optns; then
+        sed -i "/ihq/c\set ihq 0" $optns.optns
+    else
+        echo "set ihq 0" >> $optns.optns
+    fi
+fi
+
+# Starting simulation => seed is fed automatically to epos with the --seed flag. HepMC.version = 2 is mandatory for version 4.0.0
 # otherwise the simulation won't work
 o2-sim -j $JOBS -n ${NEV} -g hepmc --seed $RANDOM  \
-       --configKeyValues "GeneratorFileOrCmd.cmd=$cmd -i $optns;GeneratorFileOrCmd.bMaxSwitch=none;HepMC.version=2;${more}"
+       --configKeyValues "GeneratorFileOrCmd.cmd=$cmd -i $optns;GeneratorFileOrCmd.bMaxSwitch=none$HEPMC;${more}"

From 455f7df21328b0d74a86f36a4f92811f4bc09726 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Wed, 16 Apr 2025 16:31:21 +0200
Subject: [PATCH 0247/1764] Include pO and OO example configurations for
 Pythia8

---
 Generators/share/egconfig/pythia8_OO.cfg | 8 ++++++++
 Generators/share/egconfig/pythia8_pO.cfg | 8 ++++++++
 2 files changed, 16 insertions(+)
 create mode 100644 Generators/share/egconfig/pythia8_OO.cfg
 create mode 100644 Generators/share/egconfig/pythia8_pO.cfg

diff --git a/Generators/share/egconfig/pythia8_OO.cfg b/Generators/share/egconfig/pythia8_OO.cfg
new file mode 100644
index 0000000000000..ff098e6b65135
--- /dev/null
+++ b/Generators/share/egconfig/pythia8_OO.cfg
@@ -0,0 +1,8 @@
+### beams
+Beams:idA 1000080160    # Oxygen
+Beams:idB 1000080160    # Oxygen
+Beams:eCM 10720.        # GeV
+
+### decays
+ParticleDecays:limitTau0 on	
+ParticleDecays:tau0Max 10.	
diff --git a/Generators/share/egconfig/pythia8_pO.cfg b/Generators/share/egconfig/pythia8_pO.cfg
new file mode 100644
index 0000000000000..aff9d3337cd9d
--- /dev/null
+++ b/Generators/share/egconfig/pythia8_pO.cfg
@@ -0,0 +1,8 @@
+### beams
+Beams:idA 2212          # proton
+Beams:idB 1000080160    # Oxygen
+Beams:eCM 13600.        # GeV
+
+### decays
+ParticleDecays:limitTau0 on	
+ParticleDecays:tau0Max 10.	

From 10cd81636c902b15283a504eae413445e97e6d84 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 16 Apr 2025 15:15:27 +0200
Subject: [PATCH 0248/1764] GPU TPC: When running cluster rejection based on
 interpolation, also reject during update with current cluster position

---
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 34 +++++++++----------
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.h   |  5 ++-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |  2 +-
 3 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index 1617ac7b828af..9e23f9af3cf43 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -691,7 +691,7 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow,
     return 0;
   }
 
-  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect, err2Y, err2Z, &param);
+  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect || rejectChi2 == rejectInterReject, err2Y, err2Z, &param);
 }
 
 GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict() param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z)
@@ -704,7 +704,7 @@ GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict
     inter->errorY = mC[0];
     inter->errorZ = mC[2];
   } else if (rejectChi2 == rejectInterReject) {
-    float chiY, chiZ;
+    float chi2Y, chi2Z;
     if (mFitInProjections || mT->NDF() <= 0) {
       const float Iz0 = inter->posY - mP[0];
       const float Iz1 = inter->posZ - mP[1];
@@ -721,8 +721,8 @@ GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict
       const float Jz1 = posZ - ImP1;
       const float Jw0 = 1.f / (ImC0 + err2Y);
       const float Jw2 = 1.f / (ImC2 + err2Z);
-      chiY = Jw0 * Jz0 * Jz0;
-      chiZ = Jw2 * Jz1 * Jz1;
+      chi2Y = Jw0 * Jz0 * Jz0;
+      chi2Z = Jw2 * Jz1 * Jz1;
     } else {
       const float Iz0 = inter->posY - mP[0];
       const float Iz1 = inter->posZ - mP[1];
@@ -751,11 +751,11 @@ GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict
       Jw0 *= Jdet;
       const float Jw1 = ImC1 * Jdet;
       Jw2 *= Jdet;
-      chiY = CAMath::Abs((Jw0 * Jz0 + Jw1 * Jz1) * Jz0);
-      chiZ = CAMath::Abs((Jw1 * Jz0 + Jw2 * Jz1) * Jz1);
+      chi2Y = CAMath::Abs((Jw0 * Jz0 + Jw1 * Jz1) * Jz0);
+      chi2Z = CAMath::Abs((Jw1 * Jz0 + Jw2 * Jz1) * Jz1);
     }
-    if (RejectCluster(chiY * param.rec.tpc.clusterRejectChi2TolleranceY, chiZ * param.rec.tpc.clusterRejectChi2TolleranceZ, clusterState)) { // TODO: Relative Pt resolution decreases slightly, why?
-      return updateErrorClusterRejected;
+    if (RejectCluster(chi2Y * param.rec.tpc.clusterRejectChi2TolleranceY, chi2Z * param.rec.tpc.clusterRejectChi2TolleranceZ, clusterState)) { // TODO: Relative Pt resolution decreases slightly, why?
+      return updateErrorClusterRejectedInInterpolation;
     }
   }
   return 0;
@@ -771,13 +771,13 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int16_t cluste
 
   const float z0 = posY - mP[0];
   const float z1 = posZ - mP[1];
-  float w0, w1, w2, chiY, chiZ;
+  float w0, w1, w2, chi2Y, chi2Z;
   if (mFitInProjections || mT->NDF() <= 0) {
     w0 = 1.f / (err2Y + d00);
     w1 = 0;
     w2 = 1.f / (err2Z + d11);
-    chiY = w0 * z0 * z0;
-    chiZ = w2 * z1 * z1;
+    chi2Y = w0 * z0 * z0;
+    chi2Z = w2 * z1 * z1;
   } else {
     w0 = d11 + err2Z, w1 = d10, w2 = d00 + err2Y;
     { // Invert symmetric matrix
@@ -790,13 +790,13 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int16_t cluste
       w1 = -w1 * det;
       w2 = w2 * det;
     }
-    chiY = CAMath::Abs((w0 * z0 + w1 * z1) * z0);
-    chiZ = CAMath::Abs((w1 * z0 + w2 * z1) * z1);
+    chi2Y = CAMath::Abs((w0 * z0 + w1 * z1) * z0);
+    chi2Z = CAMath::Abs((w1 * z0 + w2 * z1) * z1);
   }
-  float dChi2 = chiY + chiZ;
-  // GPUInfo("hits %d chi2 %f, new %f %f (dy %f dz %f)", N, mChi2, chiY, chiZ, z0, z1);
-  if (rejectChi2 == 1 && RejectCluster(chiY * param->rec.tpc.clusterRejectChi2TolleranceY, chiZ * param->rec.tpc.clusterRejectChi2TolleranceZ, clusterState)) {
-    return updateErrorClusterRejected;
+  float dChi2 = chi2Y + chi2Z;
+  // GPUInfo("hits %d chi2 %f, new %f %f (dy %f dz %f)", N, mChi2, chi2Y, chi2Z, z0, z1);
+  if (rejectChi2 && RejectCluster(chi2Y * param->rec.tpc.clusterRejectChi2TolleranceY, chi2Z * param->rec.tpc.clusterRejectChi2TolleranceZ, clusterState)) {
+    return updateErrorClusterRejectedInUpdate;
   }
   mT->Chi2() += dChi2;
   mT->NDF() += 2;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
index a2369bafc9751..d2d06df7b5710 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
@@ -52,7 +52,10 @@ class GPUTPCGMPropagator
   enum UpdateRetVal {
     updateErrorFitFailed = -1,
     updateErrorClusterRejected = 2,
-    updateErrorEdgeCluster = 3
+    updateErrorClusterRejectedDistance = 2,
+    updateErrorEdgeCluster = 3,
+    updateErrorClusterRejectedInInterpolation = 4,
+    updateErrorClusterRejectedInUpdate = 5
   };
   enum RejectChi2Mode {
     rejectDirect = 1,
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 77453a87b3763..3b50bec45a41e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -305,7 +305,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       int32_t retVal;
       float threshold = 3.f + (lastUpdateX >= 0 ? (CAMath::Abs(mX - lastUpdateX) / 2) : 0.f);
       if (mNDF > 5 && (CAMath::Abs(yy - mP[0]) > threshold || CAMath::Abs(zz - mP[1]) > threshold)) {
-        retVal = GPUTPCGMPropagator::updateErrorClusterRejected;
+        retVal = GPUTPCGMPropagator::updateErrorClusterRejectedDistance;
       } else {
         int8_t rejectChi2 = attempt ? 0 : ((param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (refit ? (GPUTPCGMPropagator::rejectInterFill + ((nWays - iWay) & 1)) : 0) : (allowModification && goodRows > 5));
 #if EXTRACT_RESIDUALS == 1

From 84714d9838b3a07f4ed88903e6628071e322b549 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 16 Apr 2025 18:37:13 +0200
Subject: [PATCH 0249/1764] GPU: Fix track buffer size for 0 magnetic field

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index f42e5f35b1dc9..bf8d5294bb7c4 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -378,8 +378,8 @@ void GPUTPCGMMerger::SetMaxData(const GPUTrackingInOutPointers& io)
     }
   }
   mNMaxOutputTrackClusters = mRec->MemoryScalers()->NTPCMergedTrackHits(mNClusters);
-  if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (0.01f * gpu_common_constants::kCLight)) {
-    mNMaxTracks = mRec->MemoryScalers()->getValue(mNTotalSectorTracks, mNTotalSectorTracks);
+  if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (0.013f * gpu_common_constants::kCLight)) {
+    mNMaxTracks = mRec->MemoryScalers()->getValue(mNTotalSectorTracks, mNTotalSectorTracks); // 0 magnetic field
   } else {
     mNMaxTracks = mRec->MemoryScalers()->NTPCMergedTracks(mNTotalSectorTracks);
   }

From 63bc2e3893851ef0f849bb4c98c65eae1ba21e47 Mon Sep 17 00:00:00 2001
From: noferini <9963644+noferini@users.noreply.github.com>
Date: Sat, 4 Jan 2025 11:17:58 +0100
Subject: [PATCH 0250/1764] fix in FT0 digitization (time wrt BC)

---
 Detectors/FIT/FT0/simulation/src/Digitizer.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/FIT/FT0/simulation/src/Digitizer.cxx b/Detectors/FIT/FT0/simulation/src/Digitizer.cxx
index a261475df31f5..aca012f1bc5a9 100644
--- a/Detectors/FIT/FT0/simulation/src/Digitizer.cxx
+++ b/Detectors/FIT/FT0/simulation/src/Digitizer.cxx
@@ -220,7 +220,7 @@ void Digitizer::process(const std::vector<o2::ft0::HitType>* hits,
     // Subtract time-of-flight from hit time
     const Float_t timeOfFlight = hit.GetPos().R() / o2::constants::physics::LightSpeedCm2NS;
     const Float_t timeOffset = is_A_side ? params.hitTimeOffsetA : params.hitTimeOffsetC;
-    Double_t hit_time = hit.GetTime() - timeOfFlight + timeOffset;
+    Double_t hit_time = hit.GetTime() - timeOfFlight + timeOffset + mIntRecord.getTimeOffsetWrtBC();
 
     if (hit_time > 150) {
       continue; // not collect very slow particles
@@ -285,7 +285,7 @@ void Digitizer::storeBC(BCCache& bc,
     if (mCalibOffset) {
       miscalib = mCalibOffset->mTimeOffsets[ipmt];
     }
-    int smeared_time = 1000. * (*cfd.particle - params.mCfdShift) * params.mChannelWidthInverse + miscalib + int(1000. * mIntRecord.getTimeOffsetWrtBC() * params.mChannelWidthInverse);
+    int smeared_time = 1000. * (*cfd.particle - params.mCfdShift) * params.mChannelWidthInverse + miscalib; // + int(1000. * mIntRecord.getTimeOffsetWrtBC() * params.mChannelWidthInverse);
     bool is_time_in_signal_gate = (smeared_time > -params.mTime_trg_gate && smeared_time < params.mTime_trg_gate);
     float charge = measure_amplitude(channel_times) * params.mCharge2amp;
     float amp = is_time_in_signal_gate ? params.mMV_2_Nchannels * charge : 0;

From d98f5354db54f8410925a3578a8d7cead2079fae Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 17 Apr 2025 01:55:38 +0200
Subject: [PATCH 0251/1764] Fix margin for 0 B-field in the GPU code

---
 GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx
index 7793fac7e03ac..cf35a7f261167 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx
@@ -195,7 +195,7 @@ int32_t GPUTPCGMPolynomialFieldManager::GetPolynomialField(float nominalFieldkG,
 
   StoredField_t type = kUnknown;
 
-  if (fabsf(nominalFieldkG) < 0.01f) {
+  if (fabsf(nominalFieldkG) < 0.013f) {
     type = kUniform;
     nominalFieldkG = 0;
   } else if (fabsf(fabsf(nominalFieldkG) - 5.00668f) <= fabsf(fabsf(nominalFieldkG) - 2.f)) {

From 9a197c20a013b43f11c1605214307306a78a9c1a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 16 Apr 2025 10:06:28 +0200
Subject: [PATCH 0252/1764] Use common FatalWhenNull setting in
 getSpecificForRun

---
 CCDB/include/CCDB/BasicCCDBManager.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CCDB/include/CCDB/BasicCCDBManager.h b/CCDB/include/CCDB/BasicCCDBManager.h
index 8af1817718fa2..b7bf6920a5c7c 100644
--- a/CCDB/include/CCDB/BasicCCDBManager.h
+++ b/CCDB/include/CCDB/BasicCCDBManager.h
@@ -330,7 +330,7 @@ T* CCDBManagerInstance::getForRun(std::string const& path, int runNumber, bool s
 template <typename T>
 T* CCDBManagerInstance::getSpecificForRun(std::string const& path, int runNumber, MD metaData)
 {
-  auto [start, stop] = getRunDuration(runNumber);
+  auto [start, stop] = getRunDuration(runNumber, mFatalWhenNull);
   if (start < 0 || stop < 0) {
     if (mFatalWhenNull) {
       reportFatal(std::string("Failed to get run duration for run ") + std::to_string(runNumber) + std::string(" from CCDB"));

From 919e8f2c8b81d80d3d249e289dcdea657b4377ae Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Mon, 14 Apr 2025 11:02:43 +0200
Subject: [PATCH 0253/1764] DPL: set runNumber in DataHeader from raw data
 readers

---
 Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx | 7 ++++++-
 Detectors/Raw/src/RawFileReaderWorkflow.cxx   | 7 ++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
index ef59d94b26048..07a62a7fd4a58 100644
--- a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
+++ b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
@@ -327,7 +327,12 @@ void TFReaderSpec::stopProcessing(o2f::ProcessingContext& ctx)
     auto device = ctx.services().get<o2f::RawDeviceService>().device();
     o2f::SourceInfoHeader exitHdr;
     exitHdr.state = o2f::InputChannelState::Completed;
-    const auto exitStack = o2h::Stack(o2h::DataHeader(o2h::gDataDescriptionInfo, o2h::gDataOriginAny, 0, 0), o2f::DataProcessingHeader(), exitHdr);
+    o2h::DataHeader dh = o2h::DataHeader(o2h::gDataDescriptionInfo, o2h::gDataOriginAny, 0, 0);
+    try {
+      dh.runNumber = strtoul(device->fConfig->GetProperty<std::string>("runNumber", "").c_str(), nullptr, 10);
+    } catch (...) {
+    }
+    const auto exitStack = o2h::Stack(dh, o2f::DataProcessingHeader(), exitHdr);
     auto fmqFactory = device->GetChannel(mInput.rawChannelConfig, 0).Transport();
     auto hdEOSMessage = fmqFactory->CreateMessage(exitStack.size(), fair::mq::Alignment{64});
     auto plEOSMessage = fmqFactory->CreateMessage(0, fair::mq::Alignment{64});
diff --git a/Detectors/Raw/src/RawFileReaderWorkflow.cxx b/Detectors/Raw/src/RawFileReaderWorkflow.cxx
index 46f7ba2a5c7f1..a7313f3154ac2 100644
--- a/Detectors/Raw/src/RawFileReaderWorkflow.cxx
+++ b/Detectors/Raw/src/RawFileReaderWorkflow.cxx
@@ -347,7 +347,12 @@ void RawReaderSpecs::run(o2f::ProcessingContext& ctx)
       if (!mRawChannelName.empty()) { // send endOfStream message to raw channel
         o2f::SourceInfoHeader exitHdr;
         exitHdr.state = o2f::InputChannelState::Completed;
-        const auto exitStack = o2::header::Stack(o2h::DataHeader(o2h::gDataDescriptionInfo, o2h::gDataOriginAny, 0, 0), o2f::DataProcessingHeader(), exitHdr);
+        o2h::DataHeader dh = o2h::DataHeader(o2h::gDataDescriptionInfo, o2h::gDataOriginAny, 0, 0);
+        try {
+          dh.runNumber = strtoul(device->fConfig->GetProperty<std::string>("runNumber", "").c_str(), nullptr, 10);
+        } catch (...) {
+        }
+        const auto exitStack = o2::header::Stack(dh, o2f::DataProcessingHeader(), exitHdr);
         auto fmqFactory = device->GetChannel(mRawChannelName, 0).Transport();
         auto hdEOSMessage = fmqFactory->CreateMessage(exitStack.size(), fair::mq::Alignment{64});
         auto plEOSMessage = fmqFactory->CreateMessage(0, fair::mq::Alignment{64});

From a7246d0f2f8c01fd893483fe83e902a1ff5c7e47 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 17 Apr 2025 09:33:09 +0200
Subject: [PATCH 0254/1764] GPU: Use a unified constant instead of copy and
 paste for 0 field cut

---
 GPU/Common/GPUCommonConstants.h                           | 1 +
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx                 | 4 ++--
 GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/GPU/Common/GPUCommonConstants.h b/GPU/Common/GPUCommonConstants.h
index 01d67eab1f9d3..1a7e34885c34a 100644
--- a/GPU/Common/GPUCommonConstants.h
+++ b/GPU/Common/GPUCommonConstants.h
@@ -20,6 +20,7 @@
 namespace o2::gpu::gpu_common_constants
 {
 static constexpr const float kCLight = 0.000299792458f; // TODO: Duplicate of MathConstants, fix this now that we use only OpenCL CPP
+static constexpr const float kZeroFieldCut = 0.013f;
 }
 
 #endif
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index bf8d5294bb7c4..82b21e2045b8e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -378,7 +378,7 @@ void GPUTPCGMMerger::SetMaxData(const GPUTrackingInOutPointers& io)
     }
   }
   mNMaxOutputTrackClusters = mRec->MemoryScalers()->NTPCMergedTrackHits(mNClusters);
-  if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (0.013f * gpu_common_constants::kCLight)) {
+  if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (gpu_common_constants::kZeroFieldCut * gpu_common_constants::kCLight)) {
     mNMaxTracks = mRec->MemoryScalers()->getValue(mNTotalSectorTracks, mNTotalSectorTracks); // 0 magnetic field
   } else {
     mNMaxTracks = mRec->MemoryScalers()->NTPCMergedTracks(mNTotalSectorTracks);
@@ -1743,7 +1743,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     p1.DzDs() = p2.DzDs();
     p1.QPt() = p2.QPt();
     mergedTrack.SetAlpha(p2.Alpha());
-    if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (0.013f * gpu_common_constants::kCLight)) {
+    if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (gpu_common_constants::kZeroFieldCut * gpu_common_constants::kCLight)) {
       p1.QPt() = 100.f / Param().rec.bz0Pt10MeV;
     }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx
index cf35a7f261167..6717ac775b077 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPolynomialFieldManager.cxx
@@ -195,7 +195,7 @@ int32_t GPUTPCGMPolynomialFieldManager::GetPolynomialField(float nominalFieldkG,
 
   StoredField_t type = kUnknown;
 
-  if (fabsf(nominalFieldkG) < 0.013f) {
+  if (fabsf(nominalFieldkG) < gpu_common_constants::kZeroFieldCut) {
     type = kUniform;
     nominalFieldkG = 0;
   } else if (fabsf(fabsf(nominalFieldkG) - 5.00668f) <= fabsf(fabsf(nominalFieldkG) - 2.f)) {

From b45085c120b07fd313e9d0d546705a0f9c0f7c3e Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Thu, 17 Apr 2025 11:04:40 +0200
Subject: [PATCH 0255/1764] Include 20Neon in Pythia8 particles database

---
 Generators/share/egconfig/pythia8_NeNe.cfg | 8 ++++++++
 Generators/src/GeneratorPythia8.cxx        | 2 ++
 2 files changed, 10 insertions(+)
 create mode 100644 Generators/share/egconfig/pythia8_NeNe.cfg

diff --git a/Generators/share/egconfig/pythia8_NeNe.cfg b/Generators/share/egconfig/pythia8_NeNe.cfg
new file mode 100644
index 0000000000000..fff1dbb5f3d59
--- /dev/null
+++ b/Generators/share/egconfig/pythia8_NeNe.cfg
@@ -0,0 +1,8 @@
+### beams
+Beams:idA 1000100200	# Neon
+Beams:idB 1000100200    # Neon
+Beams:eCM 10720.	# GeV
+
+### decays
+ParticleDecays:limitTau0 on	
+ParticleDecays:tau0Max 10.	
diff --git a/Generators/src/GeneratorPythia8.cxx b/Generators/src/GeneratorPythia8.cxx
index 385eb148412ef..e883ceb6470a9 100644
--- a/Generators/src/GeneratorPythia8.cxx
+++ b/Generators/src/GeneratorPythia8.cxx
@@ -209,6 +209,8 @@ Bool_t GeneratorPythia8::Init()
       mPythia.setUserHooksPtr((Pythia8::UserHooksPtr)powhegHooks);
     }
   }
+  /** Add 20Neon to collision particle database */
+  mPythia.particleData.addParticle(1000100200, "20Ne", 6, 30, 0, 19.992440);
   /** initialise **/
   if (!mPythia.init()) {
     LOG(fatal) << "Failed to init \'Pythia8\': init returned with error";

From 99c08d385ed02f7dfb2f8e2032f6a2882bd24171 Mon Sep 17 00:00:00 2001
From: pillot <pillot@subatech.in2p3.fr>
Date: Thu, 17 Apr 2025 17:08:29 +0200
Subject: [PATCH 0256/1764] improve track extrapolation to vtx wo MCS
 correction (#14189)

---
 .../include/MCHTracking/TrackExtrap.h         | 16 +++++++++-----
 .../MUON/MCH/Tracking/src/TrackExtrap.cxx     | 21 ++++++++++++++++++-
 2 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/Detectors/MUON/MCH/Tracking/include/MCHTracking/TrackExtrap.h b/Detectors/MUON/MCH/Tracking/include/MCHTracking/TrackExtrap.h
index 709d2c991a1be..37b3cafb90523 100644
--- a/Detectors/MUON/MCH/Tracking/include/MCHTracking/TrackExtrap.h
+++ b/Detectors/MUON/MCH/Tracking/include/MCHTracking/TrackExtrap.h
@@ -18,6 +18,7 @@
 #define O2_MCH_TRACKEXTRAP_H_
 
 #include <cstddef>
+#include <optional>
 
 #include <TMatrixD.h>
 
@@ -70,17 +71,21 @@ class TrackExtrap
     /// Add branson correction resolution to parameter covariances
     return extrapToVertex(trackParam, xVtx, yVtx, zVtx, errXVtx, errYVtx, true, false);
   }
-  static bool extrapToVertexWithoutBranson(TrackParam& trackParam, double zVtx)
+  static bool extrapToVertexWithoutBranson(TrackParam& trackParam, double zVtx,
+                                           double xUpstream = 0., double yUpstream = 0.,
+                                           std::optional<double> zUpstream = std::nullopt)
   {
     /// Extrapolate track parameters to vertex, corrected for energy loss effects only
     /// Add dispersion due to multiple scattering and energy loss fluctuation to parameter covariances
-    return extrapToVertex(trackParam, 0., 0., zVtx, 0., 0., false, true);
+    return extrapToVertex(trackParam, 0., 0., zVtx, 0., 0., false, true, xUpstream, yUpstream, zUpstream);
   }
-  static bool extrapToVertexUncorrected(TrackParam& trackParam, double zVtx)
+  static bool extrapToVertexUncorrected(TrackParam& trackParam, double zVtx,
+                                        double xUpstream = 0., double yUpstream = 0.,
+                                        std::optional<double> zUpstream = std::nullopt)
   {
     /// Extrapolate track parameters to vertex without multiple scattering and energy loss corrections
     /// Add dispersion due to multiple scattering to parameter covariances
-    return extrapToVertex(trackParam, 0., 0., zVtx, 0., 0., false, false);
+    return extrapToVertex(trackParam, 0., 0., zVtx, 0., 0., false, false, xUpstream, yUpstream, zUpstream);
   }
 
   static bool extrapToMID(TrackParam& trackParam);
@@ -92,7 +97,8 @@ class TrackExtrap
 
  private:
   static bool extrapToVertex(TrackParam& trackParam, double xVtx, double yVtx, double zVtx,
-                             double errXVtx, double errYVtx, bool correctForMCS, bool correctForEnergyLoss);
+                             double errXVtx, double errYVtx, bool correctForMCS, bool correctForEnergyLoss,
+                             double xUpstream = 0., double yUpstream = 0., std::optional<double> zUpstream = std::nullopt);
 
   static bool getAbsorberCorrectionParam(double trackXYZIn[3], double trackXYZOut[3], double pTotal,
                                          double& pathLength, double& f0, double& f1, double& f2,
diff --git a/Detectors/MUON/MCH/Tracking/src/TrackExtrap.cxx b/Detectors/MUON/MCH/Tracking/src/TrackExtrap.cxx
index a91d42aca0f3b..09b8d6d3b330f 100644
--- a/Detectors/MUON/MCH/Tracking/src/TrackExtrap.cxx
+++ b/Detectors/MUON/MCH/Tracking/src/TrackExtrap.cxx
@@ -276,7 +276,8 @@ bool TrackExtrap::extrapToMID(TrackParam& trackParam)
 
 //__________________________________________________________________________
 bool TrackExtrap::extrapToVertex(TrackParam& trackParam, double xVtx, double yVtx, double zVtx,
-                                 double errXVtx, double errYVtx, bool correctForMCS, bool correctForEnergyLoss)
+                                 double errXVtx, double errYVtx, bool correctForMCS, bool correctForEnergyLoss,
+                                 double xUpstream, double yUpstream, std::optional<double> zUpstream)
 {
   /// Main method for extrapolation to the vertex:
   /// Returns the track parameters and covariances resulting from the extrapolation of the current trackParam
@@ -285,6 +286,8 @@ bool TrackExtrap::extrapToVertex(TrackParam& trackParam, double xVtx, double yVt
   /// if correctForMCS=false: add parameter dispersion due to MCS in parameter covariances
   /// if correctForEnergyLoss=true:  correct parameters for energy loss and add energy loss fluctuation to covariances
   /// if correctForEnergyLoss=false: do nothing about energy loss
+  /// In case correctForMCS=false and the position of the track upstream the absorber is provided, it is used
+  /// to compute the absorber correction parameters, instead of the extrapolated track position from downstream
 
   if (trackParam.getZ() == zVtx) {
     return true; // nothing to be done if already at vertex
@@ -301,6 +304,18 @@ bool TrackExtrap::extrapToVertex(TrackParam& trackParam, double xVtx, double yVt
     }
   }
 
+  // check the upstream track position with respect to the absorber if provided and used (spectro z<0)
+  // zUpstream must be >= SAbsZBeg with 100 µm tolerance to account for numerical precision
+  if (!correctForMCS && zUpstream && *zUpstream < SAbsZBeg - 0.01) {
+    if (*zUpstream < SAbsZEnd) {
+      LOG(warning) << "Upstream Z (" << *zUpstream << ") downstream the front absorber (zAbsorberEnd = " << SAbsZEnd << ")";
+      return false;
+    } else {
+      LOG(warning) << "Upstream Z (" << *zUpstream << ") inside the front absorber (" << SAbsZBeg << ", " << SAbsZEnd << ")";
+      return false;
+    }
+  }
+
   // Check the track position with respect to the vertex and the absorber (spectro z<0)
   if (trackParam.getZ() > SAbsZEnd) {
     if (trackParam.getZ() > zVtx) {
@@ -328,6 +343,10 @@ bool TrackExtrap::extrapToVertex(TrackParam& trackParam, double xVtx, double yVt
     trackXYZIn[2] = SAbsZBeg;
     trackXYZIn[0] = trackXYZOut[0] + (xVtx - trackXYZOut[0]) / (zVtx - trackXYZOut[2]) * (trackXYZIn[2] - trackXYZOut[2]);
     trackXYZIn[1] = trackXYZOut[1] + (yVtx - trackXYZOut[1]) / (zVtx - trackXYZOut[2]) * (trackXYZIn[2] - trackXYZOut[2]);
+  } else if (zUpstream) { // or linear propagation to the upstream track position
+    trackXYZIn[2] = SAbsZBeg;
+    trackXYZIn[0] = trackXYZOut[0] + (xUpstream - trackXYZOut[0]) / (*zUpstream - trackXYZOut[2]) * (trackXYZIn[2] - trackXYZOut[2]);
+    trackXYZIn[1] = trackXYZOut[1] + (yUpstream - trackXYZOut[1]) / (*zUpstream - trackXYZOut[2]) * (trackXYZIn[2] - trackXYZOut[2]);
   } else { // or standard propagation without vertex constraint
     TrackParam trackParamIn(trackParam);
     if (!extrapToZ(trackParamIn, SAbsZBeg)) {

From 8c94458e83debdbc773d4e1a57923a6e63733c2d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 17 Apr 2025 20:36:15 +0200
Subject: [PATCH 0257/1764] Saner publishing period for FLP case (#14198)

---
 Framework/Core/src/CommonServices.cxx | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 5c333bbb85e3b..22324cd84b390 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -891,6 +891,11 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
       if (!DefaultsHelpers::onlineDeploymentMode() && DefaultsHelpers::deploymentMode() != DeploymentMode::FST) {
         arrowAndResourceLimitingMetrics = true;
       }
+
+      int64_t consumedTimeframesPublishInterval = 0;
+      if (DefaultsHelpers::deploymentMode() == DeploymentMode::OnlineECS) {
+        consumedTimeframesPublishInterval = 5000;
+      }
       // Input proxies should not report cpu_usage_fraction,
       // because of the rate limiting which biases the measurement.
       auto& spec = services.get<DeviceSpec const>();
@@ -950,7 +955,7 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
         MetricSpec{.name = "consumed-timeframes",
                    .metricId = (int)ProcessingStatsId::CONSUMED_TIMEFRAMES,
                    .kind = Kind::UInt64,
-                   .minPublishInterval = 0,
+                   .minPublishInterval = consumedTimeframesPublishInterval,
                    .maxRefreshLatency = quickRefreshInterval,
                    .sendInitialValue = true},
         MetricSpec{.name = "min_input_latency_ms",

From b856a634468cfe8e80890ce3d6b77fb7bbba9dd6 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 17 Apr 2025 15:52:54 +0200
Subject: [PATCH 0258/1764] GPU CMake: Fix compile flags, particularly HIP
 deterministic mode was missing -ffp-contract=off

---
 dependencies/FindO2GPU.cmake | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 95db55041184f..d50705d106bf3 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -162,7 +162,7 @@ if(ENABLE_CUDA)
     if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
       string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " ${GPUCA_CUDA_NO_FAST_MATH_FLAGS}")
     elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-      string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -use_fast_math --ftz=true")
+      string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -use_fast_math ${GPUCA_CUDA_DENORMALS_FLAGS}")
     endif()
     if(CMAKE_CXX_FLAGS MATCHES "(^| )-Werror( |$)")
       string(APPEND CMAKE_CUDA_FLAGS " -Werror=cross-execution-space-call")
@@ -293,11 +293,10 @@ if(ENABLE_HIP)
     if(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE)
       string(APPEND CMAKE_HIP_FLAGS " -Rpass-analysis=kernel-resource-usage")
     endif()
-    if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
-      string(APPEND CMAKE_HIP_FLAGS " -ffast-math")
-    endif()
-    if(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-      string(APPEND CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -O3")
+    if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
+      string(APPEND CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
+    elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
+      string(APPEND CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -ffast-math -O3")
     endif()
     string(REGEX REPLACE "(gfx1[0-9]+;?)" "" CMAKE_HIP_ARCHITECTURES "${CMAKE_HIP_ARCHITECTURES}") # ROCm currently doesn’t support integrated graphics
     if(HIP_AMDGPUTARGET)

From fc52b5db290f2ebeced93820c8de20379f9f3283 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 16 Apr 2025 18:44:10 +0200
Subject: [PATCH 0259/1764] GPU TPC: Change some code in sector tracking from
 prepreccor #if to if constexpr, to avoid preprocessing the RTC code

---
 .../SectorTracker/GPUTPCNeighboursFinder.cxx  | 153 +++++++++---------
 .../SectorTracker/GPUTPCNeighboursFinder.h    |   2 -
 .../SectorTracker/GPUTPCStartHitsFinder.cxx   |  50 +++---
 .../SectorTracker/GPUTPCTrackletSelector.cxx  |  48 +++---
 .../SectorTracker/GPUTPCTrackletSelector.h    |   2 -
 5 files changed, 127 insertions(+), 128 deletions(-)

diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
index d76c079bb406f..4cdb4d151eba4 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
@@ -75,14 +75,10 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
     return;
   }
 
-#define UnrollGlobal 4
-#define MaxShared GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP
-#if MaxShared < GPUCA_MAXN
-#define MaxGlobal ((GPUCA_MAXN - MaxShared - 1) / UnrollGlobal + 1) * UnrollGlobal
-#else
-#define MaxGlobal 0
-#endif
-#define MaxTotal MaxShared + MaxGlobal
+  static constexpr uint32_t UNROLL_GLOBAL = 4;
+  static constexpr uint32_t MAX_SHARED = GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP;
+  static constexpr uint32_t MAX_GLOBAL = (MAX_SHARED < GPUCA_MAXN) ? (((GPUCA_MAXN - MAX_SHARED - 1) / UNROLL_GLOBAL + 1) * UNROLL_GLOBAL) : 0;
+  static constexpr uint32_t MAX_TOTAL = MAX_SHARED + MAX_GLOBAL;
 
   const float chi2Cut = 3.f * 3.f * 4 * (s.mUpDx * s.mUpDx + s.mDnDx * s.mDnDx);
   // float chi2Cut = 3.f*3.f*(s.mUpDx*s.mUpDx + s.mDnDx*s.mDnDx ); //SG
@@ -117,10 +113,8 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
   const float kAreaSlopeZUp = kAngularMultiplier != 0.f ? 1.f : s.mUpTx;
   const float kAreaSlopeZDn = kAngularMultiplier != 0.f ? 1.f : s.mDnTx;
 
-#if MaxGlobal > 0
-  calink neighUp[MaxGlobal];
-  float yzUp[2 * MaxGlobal];
-#endif
+  calink neighUp[MAX_GLOBAL];
+  float yzUp[2 * MAX_GLOBAL];
 
   for (int32_t ih = iThread; ih < s.mNHits; ih += nThreads) {
 
@@ -128,7 +122,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
     const float y = y0 + hitData.x * stepY;
     const float z = z0 + hitData.y * stepZ;
 
-    int32_t nNeighUp = 0;
+    uint32_t nNeighUp = 0;
     float minZ, maxZ, minY, maxY;
     int32_t binYmin, binYmax, binZmin, binZmax;
     int32_t nY;
@@ -145,11 +139,11 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
       nY = rowUp.Grid().Ny();
     }
 
-    for (int32_t k1 = binZmin; k1 <= binZmax && (nNeighUp < MaxTotal); k1++) {
+    for (int32_t k1 = binZmin; k1 <= binZmax && (nNeighUp < MAX_TOTAL); k1++) {
       int32_t iMin = lFirstHitInBin[lFirstHitInBinOffsetUp + k1 * nY + binYmin];
       int32_t iMax = lFirstHitInBin[lFirstHitInBinOffsetUp + k1 * nY + binYmax + 1];
       GPUCA_UNROLL(U(4), U(2))
-      for (int32_t i = iMin; i < iMax && (nNeighUp < MaxTotal); i++) {
+      for (int32_t i = iMin; i < iMax && (nNeighUp < MAX_TOTAL); i++) {
         const GPUglobalref() cahit2& hitDataUp = pHitData[lHitNumberOffsetUp + i];
         GPUTPCHit h;
         h.mY = y0Up + (hitDataUp.x) * stepYUp;
@@ -159,51 +153,48 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
           continue;
         }
 
-#if MaxGlobal > 0
-#if MaxShared == 0
-        if (true) {
-#else
-        if (nNeighUp >= MaxShared) {
-#endif
-          neighUp[nNeighUp - MaxShared] = (calink)i;
-          yzUp[2 * (nNeighUp - MaxShared)] = s.mDnDx * (h.Y() - y);
-          yzUp[2 * (nNeighUp - MaxShared) + 1] = s.mDnDx * (h.Z() - z);
-        } else
-#endif
-        {
-#if MaxShared > 0
-          s.mB[nNeighUp][iThread] = (calink)i;
-          s.mA1[nNeighUp][iThread] = s.mDnDx * (h.Y() - y);
-          s.mA2[nNeighUp][iThread] = s.mDnDx * (h.Z() - z);
-#endif
+        const bool inGlobal = nNeighUp >= MAX_SHARED;
+        if constexpr (MAX_GLOBAL > 0) {
+          if (inGlobal) {
+            neighUp[nNeighUp - MAX_SHARED] = (calink)i;
+            yzUp[2 * (nNeighUp - MAX_SHARED)] = s.mDnDx * (h.Y() - y);
+            yzUp[2 * (nNeighUp - MAX_SHARED) + 1] = s.mDnDx * (h.Z() - z);
+          }
+        }
+        if constexpr (MAX_SHARED > 0) {
+          if (!inGlobal) {
+            s.mB[nNeighUp][iThread] = (calink)i;
+            s.mA1[nNeighUp][iThread] = s.mDnDx * (h.Y() - y);
+            s.mA2[nNeighUp][iThread] = s.mDnDx * (h.Z() - z);
+          }
         }
         nNeighUp++;
       }
     }
 
-#if MaxShared > 0 // init a rest of the shared array
-    for (int32_t iUp = nNeighUp; iUp < MaxShared; iUp++) {
-      s.mA1[iUp][iThread] = -1.e10f;
-      s.mA2[iUp][iThread] = -1.e10f;
-      s.mB[iUp][iThread] = (calink)-1;
+    if constexpr (MAX_SHARED > 0) { // init the rest of the shared array
+      for (uint32_t iUp = nNeighUp; iUp < MAX_SHARED; iUp++) {
+        s.mA1[iUp][iThread] = -1.e10f;
+        s.mA2[iUp][iThread] = -1.e10f;
+        s.mB[iUp][iThread] = (calink)-1;
+      }
     }
-#endif
 
-#if MaxGlobal > 0 // init a rest of the UnrollGlobal chunk of the global array
-    int32_t Nrest = nNeighUp - MaxShared;
-    int32_t N4 = (Nrest / UnrollGlobal) * UnrollGlobal;
-    if (N4 < Nrest) {
-      N4 += UnrollGlobal;
-      GPUCA_UNROLL(U(UnrollGlobal - 1), U(UnrollGlobal - 1))
-      for (int32_t k = 0; k < UnrollGlobal - 1; k++) {
-        if (Nrest + k < N4) {
-          yzUp[2 * (Nrest + k)] = -1.e10f;
-          yzUp[2 * (Nrest + k) + 1] = -1.e10f;
-          neighUp[Nrest + k] = (calink)-1;
+    const uint32_t Nrest = nNeighUp - MAX_SHARED;
+    uint32_t N4 = (Nrest / UNROLL_GLOBAL) * UNROLL_GLOBAL;
+    if constexpr (MAX_GLOBAL > 0) { // init the rest of the UNROLL_GLOBAL chunk of the global array
+      if (nNeighUp > MAX_SHARED && N4 < Nrest) {
+        N4 += UNROLL_GLOBAL;
+        GPUCA_UNROLL(U(UNROLL_GLOBAL - 1), U(UNROLL_GLOBAL - 1))
+        for (uint32_t k = 0; k + 1 < UNROLL_GLOBAL; k++) {
+          if (Nrest + k < N4) {
+            yzUp[2 * (Nrest + k)] = -1.e10f;
+            yzUp[2 * (Nrest + k) + 1] = -1.e10f;
+            neighUp[Nrest + k] = (calink)-1;
+          }
         }
       }
     }
-#endif
 
     { // area in the lower row
       const float yy = y * s.mDnTx;
@@ -236,47 +227,49 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
         float yDnProjUp = s.mUpDx * (yDn - y);
         float zDnProjUp = s.mUpDx * (zDn - z);
 
-#if MaxShared > 0
-        GPUCA_UNROLL(U(MaxShared), U(MaxShared))
-        for (int32_t iUp = 0; iUp < MaxShared; iUp++) {
-          const float dy = yDnProjUp - s.mA1[iUp][iThread];
-          const float dz = zDnProjUp - s.mA2[iUp][iThread];
-          const float d = dy * dy + dz * dz;
-          if (d < bestD) {
-            bestD = d;
-            linkDn = i;
-            linkUp = iUp;
-          }
-        }
-#endif
-
-#if MaxGlobal > 0
-        for (int32_t iUp = 0; iUp < N4; iUp += UnrollGlobal) {
-          GPUCA_UNROLL(U(UnrollGlobal), U(UnrollGlobal))
-          for (int32_t k = 0; k < UnrollGlobal; k++) {
-            int32_t jUp = iUp + k;
-            const float dy = yDnProjUp - yzUp[2 * jUp];
-            const float dz = zDnProjUp - yzUp[2 * jUp + 1];
+        if constexpr (MAX_SHARED > 0) {
+          GPUCA_UNROLL(U(MAX_SHARED), U(MAX_SHARED))
+          for (uint32_t iUp = 0; iUp < MAX_SHARED; iUp++) {
+            const float dy = yDnProjUp - s.mA1[iUp][iThread];
+            const float dz = zDnProjUp - s.mA2[iUp][iThread];
             const float d = dy * dy + dz * dz;
             if (d < bestD) {
               bestD = d;
               linkDn = i;
-              linkUp = MaxShared + jUp;
+              linkUp = iUp;
+            }
+          }
+        }
+
+        if constexpr (MAX_GLOBAL > 0) {
+          if (nNeighUp > MAX_SHARED) {
+            for (uint32_t iUp = 0; iUp < N4; iUp += UNROLL_GLOBAL) {
+              GPUCA_UNROLL(U(UNROLL_GLOBAL), U(UNROLL_GLOBAL))
+              for (uint32_t k = 0; k < UNROLL_GLOBAL; k++) {
+                const uint32_t jUp = iUp + k;
+                const float dy = yDnProjUp - yzUp[2 * jUp];
+                const float dz = zDnProjUp - yzUp[2 * jUp + 1];
+                const float d = dy * dy + dz * dz;
+                if (d < bestD) {
+                  bestD = d;
+                  linkDn = i;
+                  linkUp = MAX_SHARED + jUp;
+                }
+              }
             }
           }
         }
-#endif
       }
     }
 
     if (linkUp >= 0) {
-#if MaxShared > 0 && MaxGlobal > 0
-      linkUp = (linkUp >= MaxShared) ? neighUp[linkUp - MaxShared] : s.mB[linkUp][iThread];
-#elif MaxShared > 0
-      linkUp = s.mB[linkUp][iThread];
-#else
-      linkUp = neighUp[linkUp];
-#endif
+      if constexpr (MAX_SHARED > 0 && MAX_GLOBAL > 0) {
+        linkUp = ((uint32_t)linkUp >= MAX_SHARED) ? neighUp[linkUp - MAX_SHARED] : s.mB[linkUp][iThread];
+      } else if constexpr (MAX_SHARED > 0) {
+        linkUp = s.mB[linkUp][iThread];
+      } else {
+        linkUp = neighUp[linkUp];
+      }
     }
 
     tracker.mData.mLinkUpData[lHitNumberOffset + ih] = linkUp;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
index 0ecd230a67415..6bdc637b6bad6 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
@@ -40,12 +40,10 @@ class GPUTPCNeighboursFinder : public GPUKernelTemplate
     int32_t mIRow;   // row number
     int32_t mIRowUp; // next row number
     int32_t mIRowDn; // previous row number
-#if GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP > 0
     static_assert(GPUCA_MAXN >= GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP);
     float mA1[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
     float mA2[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
     calink mB[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
-#endif
     GPUTPCRow mRow, mRowUp, mRowDown;
   };
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
index 20dfd69864816..06dac4a68c540 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
@@ -39,36 +39,38 @@ GPUdii() void GPUTPCStartHitsFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nThr
     uint32_t linkUpData = tracker.mData.mLinkUpData[lHitNumberOffset + ih];
 
     if (tracker.mData.mLinkDownData[lHitNumberOffset + ih] == CALINK_INVAL && linkUpData != CALINK_INVAL && tracker.mData.mLinkUpData[rowUp.mHitNumberOffset + linkUpData] != CALINK_INVAL) {
-#if GPUCA_PAR_SORT_STARTHITS > 0
-      GPUglobalref() GPUTPCHitId* const GPUrestrict() startHits = tracker.mTrackletTmpStartHits + s.mIRow * tracker.mNMaxRowStartHits;
-      uint32_t nextRowStartHits = CAMath::AtomicAddShared(&s.mNRowStartHits, 1u);
-      if (nextRowStartHits >= tracker.mNMaxRowStartHits) {
-        tracker.raiseError(GPUErrors::ERROR_ROWSTARTHIT_OVERFLOW, tracker.ISector() * 1000 + s.mIRow, nextRowStartHits, tracker.mNMaxRowStartHits);
-        CAMath::AtomicExchShared(&s.mNRowStartHits, tracker.mNMaxRowStartHits);
-        break;
+      GPUglobalref() GPUTPCHitId* GPUrestrict() startHits;
+      uint32_t nextRowStartHits;
+      if constexpr (GPUCA_PAR_SORT_STARTHITS > 0) {
+        startHits = tracker.mTrackletTmpStartHits + s.mIRow * tracker.mNMaxRowStartHits;
+        nextRowStartHits = CAMath::AtomicAddShared(&s.mNRowStartHits, 1u);
+        if (nextRowStartHits >= tracker.mNMaxRowStartHits) {
+          tracker.raiseError(GPUErrors::ERROR_ROWSTARTHIT_OVERFLOW, tracker.ISector() * 1000 + s.mIRow, nextRowStartHits, tracker.mNMaxRowStartHits);
+          CAMath::AtomicExchShared(&s.mNRowStartHits, tracker.mNMaxRowStartHits);
+          break;
+        }
+      } else {
+        startHits = tracker.mTrackletStartHits;
+        nextRowStartHits = CAMath::AtomicAdd(&tracker.mCommonMem->nStartHits, 1u);
+        if (nextRowStartHits >= tracker.mNMaxStartHits) {
+          tracker.raiseError(GPUErrors::ERROR_STARTHIT_OVERFLOW, tracker.ISector() * 1000 + s.mIRow, nextRowStartHits, tracker.mNMaxStartHits);
+          CAMath::AtomicExch(&tracker.mCommonMem->nStartHits, tracker.mNMaxStartHits);
+          break;
+        }
       }
-#else
-      GPUglobalref() GPUTPCHitId* const GPUrestrict() startHits = tracker.mTrackletStartHits;
-      uint32_t nextRowStartHits = CAMath::AtomicAdd(&tracker.mCommonMem->nStartHits, 1u);
-      if (nextRowStartHits >= tracker.mNMaxStartHits) {
-        tracker.raiseError(GPUErrors::ERROR_STARTHIT_OVERFLOW, tracker.ISector() * 1000 + s.mIRow, nextRowStartHits, tracker.mNMaxStartHits);
-        CAMath::AtomicExch(&tracker.mCommonMem->nStartHits, tracker.mNMaxStartHits);
-        break;
-      }
-#endif
       startHits[nextRowStartHits].Set(s.mIRow, ih);
     }
   }
   GPUbarrier();
 
-#if GPUCA_PAR_SORT_STARTHITS > 0
-  if (iThread == 0) {
-    uint32_t nOffset = CAMath::AtomicAdd(&tracker.mCommonMem->nStartHits, s.mNRowStartHits);
-    tracker.mRowStartHitCountOffset[s.mIRow] = s.mNRowStartHits;
-    if (nOffset + s.mNRowStartHits > tracker.mNMaxStartHits) {
-      tracker.raiseError(GPUErrors::ERROR_STARTHIT_OVERFLOW, tracker.ISector() * 1000 + s.mIRow, nOffset + s.mNRowStartHits, tracker.mNMaxStartHits);
-      CAMath::AtomicExch(&tracker.mCommonMem->nStartHits, tracker.mNMaxStartHits);
+  if constexpr (GPUCA_PAR_SORT_STARTHITS > 0) {
+    if (iThread == 0) {
+      uint32_t nOffset = CAMath::AtomicAdd(&tracker.mCommonMem->nStartHits, s.mNRowStartHits);
+      tracker.mRowStartHitCountOffset[s.mIRow] = s.mNRowStartHits;
+      if (nOffset + s.mNRowStartHits > tracker.mNMaxStartHits) {
+        tracker.raiseError(GPUErrors::ERROR_STARTHIT_OVERFLOW, tracker.ISector() * 1000 + s.mIRow, nOffset + s.mNRowStartHits, tracker.mNMaxStartHits);
+        CAMath::AtomicExch(&tracker.mCommonMem->nStartHits, tracker.mNMaxStartHits);
+      }
     }
   }
-#endif
 }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
index e27a8f66ae754..0bf3448bed730 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
@@ -48,11 +48,11 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
 
     int32_t irow = firstRow;
 
-    int32_t gap = 0;
-    int32_t nShared = 0;
-    int32_t nHits = 0;
-    const int32_t minHits = tracker.Param().rec.tpc.minNClustersTrackSeed == -1 ? GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tracklet.Param().QPt() * tracker.Param().qptB5Scaler) : tracker.Param().rec.tpc.minNClustersTrackSeed;
-    const int32_t sharingMinNorm = minHits * tracker.Param().rec.tpc.trackletMinSharedNormFactor;
+    uint32_t gap = 0;
+    uint32_t nShared = 0;
+    uint32_t nHits = 0;
+    const uint32_t minHits = tracker.Param().rec.tpc.minNClustersTrackSeed == -1 ? GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tracklet.Param().QPt() * tracker.Param().qptB5Scaler) : tracker.Param().rec.tpc.minNClustersTrackSeed;
+    const uint32_t sharingMinNorm = minHits * tracker.Param().rec.tpc.trackletMinSharedNormFactor;
     float maxShared = maxSharedFrac * sharingMinNorm;
 
     GPUCA_UNROLL(, U(1))
@@ -63,16 +63,20 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
       }
       if (ih != CALINK_INVAL && ih != CALINK_DEAD_CHANNEL) {
         GPUglobalref() const GPUTPCRow& row = tracker.Row(irow);
-        bool own = (tracker.HitWeight(row, ih) <= w);
-        bool sharedOK = nShared <= (nHits < sharingMinNorm ? maxShared : nHits * maxSharedFrac);
+        const bool own = (tracker.HitWeight(row, ih) <= w);
+        const bool sharedOK = nShared <= (nHits < sharingMinNorm ? maxShared : nHits * maxSharedFrac);
         if (own || sharedOK) { // SG!!!
           gap = 0;
-#if GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-          if (nHits < GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE) {
-            s.mHits[nHits][iThread].Set(irow, ih);
-          } else
-#endif // GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-          {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtype-limits"
+          const bool inShared = nHits < (uint32_t)GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE;
+#pragma GCC diagnostic pop
+          if constexpr (GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE > 0) {
+            if (inShared) {
+              s.mHits[nHits][iThread].Set(irow, ih);
+            }
+          }
+          if (!inShared) {
             trackHits[nHits - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE].Set(irow, ih);
           }
           nHits++;
@@ -100,13 +104,17 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
           tracker.Tracks()[itrout].SetParam(tracklet.Param());
           tracker.Tracks()[itrout].SetFirstHitID(nFirstTrackHit);
           tracker.Tracks()[itrout].SetNHits(nHits);
-          for (int32_t jh = 0; jh < nHits; jh++) {
-#if GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-            if (jh < GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE) {
-              tracker.TrackHits()[nFirstTrackHit + jh] = s.mHits[jh][iThread];
-            } else
-#endif // GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
-            {
+          for (uint32_t jh = 0; jh < nHits; jh++) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wtype-limits"
+            const bool inShared = jh < (uint32_t)GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE;
+#pragma GCC diagnostic pop
+            if constexpr (GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE > 0) {
+              if (inShared) {
+                tracker.TrackHits()[nFirstTrackHit + jh] = s.mHits[jh][iThread];
+              }
+            }
+            if (!inShared) {
               tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
             }
           }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
index e5a28c80f37f9..070e02fad8222 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
@@ -36,10 +36,8 @@ class GPUTPCTrackletSelector : public GPUKernelTemplate
     int32_t mNThreadsTotal; // total n threads
     int32_t mNTracklets;    // n of tracklets
     int32_t mReserved;      // for alignment reasons
-#if GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
     static_assert(GPUCA_ROW_COUNT >= GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE);
     GPUTPCHitId mHits[GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletSelector)];
-#endif // GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE != 0
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;

From e966e71fcd2033de0b95fae6d1e437381b4b9a1a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 17 Apr 2025 10:10:11 +0200
Subject: [PATCH 0260/1764] GPU: Add missing static_assert to guarantee correct
 unroll factor, will crash otherwise (apparently forgotten by AMD)

---
 GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
index 4cdb4d151eba4..6731fed55cc9c 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
@@ -76,6 +76,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
   }
 
   static constexpr uint32_t UNROLL_GLOBAL = 4;
+  static_assert(GPUCA_MAXN % UNROLL_GLOBAL == 0);
   static constexpr uint32_t MAX_SHARED = GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP;
   static constexpr uint32_t MAX_GLOBAL = (MAX_SHARED < GPUCA_MAXN) ? (((GPUCA_MAXN - MAX_SHARED - 1) / UNROLL_GLOBAL + 1) * UNROLL_GLOBAL) : 0;
   static constexpr uint32_t MAX_TOTAL = MAX_SHARED + MAX_GLOBAL;

From 2ab600016e4a20b2e0dfea2cae94105dab3ca942 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 17 Apr 2025 13:40:07 +0200
Subject: [PATCH 0261/1764] GPU: Make some of the optimizations AMD did for the
 neighbors finder for MI50 optional

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  6 ++++-
 .../Definitions/GPUDefParametersDefaults.h    | 12 +++++++++
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 .../SectorTracker/GPUTPCNeighboursFinder.cxx  | 27 ++++++++++---------
 GPU/GPUTracking/kernels.cmake                 |  2 ++
 5 files changed, 34 insertions(+), 15 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index b4dac39ae1cd2..acca74e57a80e 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -263,7 +263,7 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
   }
   if (mProcessingSettings.deterministicGPUReconstruction) {
 #ifndef GPUCA_DETERMINISTIC_MODE
-    GPUError("Warning, deterministicGPUReconstruction needs GPUCA_DETERMINISTIC_MODE for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
+    GPUError("WARNING, deterministicGPUReconstruction needs GPUCA_DETERMINISTIC_MODE for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
 #endif
     mProcessingSettings.overrideClusterizerFragmentLen = TPC_MAX_FRAGMENT_LEN_GPU;
     param().rec.tpc.nWaysOuter = true;
@@ -274,6 +274,10 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
       mProcessingSettings.createO2Output = 1;
     }
     mProcessingSettings.rtc.deterministic = 1;
+  } else {
+#ifdef GPUCA_DETERMINISTIC_MODE
+    GPUError("WARNING, compiled with GPUCA_DETERMINISTIC_MODE but deterministicGPUReconstruction not set, only compile-time determinism and deterministic math enforced, not fully deterministic!");
+#endif
   }
   if (mProcessingSettings.deterministicGPUReconstruction && mProcessingSettings.debugLevel >= 6) {
     mProcessingSettings.nTPCClustererLanes = 1;
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index b212abbcd2707..4ee6b23d46b51 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -516,6 +516,12 @@
   #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP
     #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 6
   #endif
+  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL 4
+  #endif
+  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED 1
+  #endif
   #ifndef GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE
     #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 12
   #endif
@@ -544,6 +550,12 @@
   #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP
     #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
   #endif
+  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL 0
+  #endif
+  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED 0
+  #endif
   #ifndef GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE
     #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 0
   #endif
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 34fac6514851c..9d1772379f6bd 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -284,7 +284,7 @@ AddOption(allocDebugLevel, int32_t, 0, "allocDebug", 0, "Some debug output for m
 AddOption(debugMask, int32_t, 262143, "", 0, "Mask for debug output dumps to file")
 AddOption(serializeGPU, int8_t, 0, "", 0, "Synchronize after each kernel call (bit 1) and DMA transfer (bit 2) and identify failures")
 AddOption(recoTaskTiming, bool, 0, "", 0, "Perform summary timing after whole reconstruction tasks")
-AddOption(deterministicGPUReconstruction, int32_t, -1, "", 0, "Make CPU and GPU debug output comparable (sort / skip concurrent parts), -1 = automatic if debugLevel >= 6")
+AddOption(deterministicGPUReconstruction, int32_t, -1, "", 0, "Make CPU and GPU debug output comparable (sort / skip concurrent parts), -1 = automatic if debugLevel >= 6", def(1))
 AddOption(showOutputStat, bool, false, "", 0, "Print some track output statistics")
 AddOption(runCompressionStatistics, bool, false, "compressionStat", 0, "Run statistics and verification for cluster compression")
 AddOption(resetTimers, int8_t, 1, "", 0, "Reset timers every event")
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
index 6731fed55cc9c..54ce7f12c655f 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
@@ -75,7 +75,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
     return;
   }
 
-  static constexpr uint32_t UNROLL_GLOBAL = 4;
+  static constexpr uint32_t UNROLL_GLOBAL = GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL > 1 ? GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL : 1;
   static_assert(GPUCA_MAXN % UNROLL_GLOBAL == 0);
   static constexpr uint32_t MAX_SHARED = GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP;
   static constexpr uint32_t MAX_GLOBAL = (MAX_SHARED < GPUCA_MAXN) ? (((GPUCA_MAXN - MAX_SHARED - 1) / UNROLL_GLOBAL + 1) * UNROLL_GLOBAL) : 0;
@@ -173,7 +173,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
       }
     }
 
-    if constexpr (MAX_SHARED > 0) { // init the rest of the shared array
+    if constexpr (MAX_SHARED > 0 && GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED) { // init the rest of the shared array
       for (uint32_t iUp = nNeighUp; iUp < MAX_SHARED; iUp++) {
         s.mA1[iUp][iThread] = -1.e10f;
         s.mA2[iUp][iThread] = -1.e10f;
@@ -181,17 +181,17 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
       }
     }
 
-    const uint32_t Nrest = nNeighUp - MAX_SHARED;
-    uint32_t N4 = (Nrest / UNROLL_GLOBAL) * UNROLL_GLOBAL;
-    if constexpr (MAX_GLOBAL > 0) { // init the rest of the UNROLL_GLOBAL chunk of the global array
-      if (nNeighUp > MAX_SHARED && N4 < Nrest) {
-        N4 += UNROLL_GLOBAL;
+    const uint32_t nRest = nNeighUp - MAX_SHARED;
+    uint32_t nRestUnrolled = (nRest / UNROLL_GLOBAL) * UNROLL_GLOBAL;
+    if constexpr (MAX_GLOBAL > 1) { // init the rest of the UNROLL_GLOBAL chunk of the global array
+      if (nNeighUp > MAX_SHARED && nRestUnrolled < nRest) {
+        nRestUnrolled += UNROLL_GLOBAL;
         GPUCA_UNROLL(U(UNROLL_GLOBAL - 1), U(UNROLL_GLOBAL - 1))
         for (uint32_t k = 0; k + 1 < UNROLL_GLOBAL; k++) {
-          if (Nrest + k < N4) {
-            yzUp[2 * (Nrest + k)] = -1.e10f;
-            yzUp[2 * (Nrest + k) + 1] = -1.e10f;
-            neighUp[Nrest + k] = (calink)-1;
+          if (nRest + k < nRestUnrolled) {
+            yzUp[2 * (nRest + k)] = -1.e10f;
+            yzUp[2 * (nRest + k) + 1] = -1.e10f;
+            neighUp[nRest + k] = (calink)-1;
           }
         }
       }
@@ -229,8 +229,9 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
         float zDnProjUp = s.mUpDx * (zDn - z);
 
         if constexpr (MAX_SHARED > 0) {
+          const uint32_t maxSharedUp = GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED ? MAX_SHARED : CAMath::Min(nNeighUp, MAX_SHARED);
           GPUCA_UNROLL(U(MAX_SHARED), U(MAX_SHARED))
-          for (uint32_t iUp = 0; iUp < MAX_SHARED; iUp++) {
+          for (uint32_t iUp = 0; iUp < maxSharedUp; iUp++) {
             const float dy = yDnProjUp - s.mA1[iUp][iThread];
             const float dz = zDnProjUp - s.mA2[iUp][iThread];
             const float d = dy * dy + dz * dz;
@@ -244,7 +245,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
 
         if constexpr (MAX_GLOBAL > 0) {
           if (nNeighUp > MAX_SHARED) {
-            for (uint32_t iUp = 0; iUp < N4; iUp += UNROLL_GLOBAL) {
+            for (uint32_t iUp = 0; iUp < nRestUnrolled; iUp += UNROLL_GLOBAL) {
               GPUCA_UNROLL(U(UNROLL_GLOBAL), U(UNROLL_GLOBAL))
               for (uint32_t k = 0; k < UNROLL_GLOBAL; k++) {
                 const uint32_t jUp = iUp + k;
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index ee3af2b87d925..fcf576d828b7f 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -136,6 +136,8 @@ o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                "= GLOBALR
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"        "= GLOBALREFIT "                                        LB)
 
 o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP
+                            NEIGHBOURS_FINDER_UNROLL_GLOBAL
+                            NEIGHBOURS_FINDER_UNROLL_SHARED
                             TRACKLET_SELECTOR_HITS_REG_SIZE
                             ALTERNATE_BORDER_SORT
                             SORT_BEFORE_FIT

From 233a4e4bf1f5ea05c218598c05ba734909d3155f Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 18 Apr 2025 09:32:40 +0200
Subject: [PATCH 0262/1764] Common: DCAFitter explanation to README

---
 Common/DCAFitter/README.md | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/Common/DCAFitter/README.md b/Common/DCAFitter/README.md
index 1699ffb4f8aca..e385378d10caf 100644
--- a/Common/DCAFitter/README.md
+++ b/Common/DCAFitter/README.md
@@ -93,3 +93,41 @@ In this case the relevant correlation coefficient of the cov.matrix is redefined
 
 `DCAFitterN::setBadCovPolicy(DCAFitterN::OverrideAnFlag);` continue fit with overridden cov.matrix but set the propagation failure flag (can be checked using the same `isPropagationFailure(int cand = 0)` method).
 
+## Fit status
+The fitter provides a fit status for each candidate, which can be retrieved using:
+```
+FitStatus status = ft.getFitStatus(int cand = 0);
+```
+The possible values are:
+```
+enum FitStatus : uint8_t {    // part of the DCAFitterN class
+     None,                    // no status set (should not be possible!)
+
+     /* Good Conditions */
+     Converged, // fit converged
+     MaxIter,   // max iterations reached before fit convergence (can still be a good vertex)
+
+     /* Error Conditions */
+     NoCrossing,      // no reasonable crossing was found
+     RejRadius,       // radius of crossing was not acceptable
+     RejTrackX,       // one candidate track x was below the minimum required radius
+     RejTrackRoughZ,  // rejected by rough cut on tracks Z difference
+     RejChi2Max,      // rejected by maximum chi2 cut
+     FailProp,        // propagation of at least prong to PCA failed
+     FailInvCov,      // inversion of cov.-matrix failed
+     FailInvWeight,   // inversion of Ti weight matrix failed
+     FailInv2ndDeriv, // inversion of 2nd derivatives failed
+     FailCorrTracks,  // correction of tracks to updated x failed
+     FailCloserAlt,   // alternative PCA is closer
+};
+```
+This is allows to track where candiate fit was abondended.
+```
+int nc = ft.process(tr0,tr1,tr2);
+auto status = ft.getFitStatus();
+if (nc) {
+     // status can either be FitStatus::Converged or FitStatus::MaxIter
+}
+// status can be on of the error conditions
+```
+A more thorough example is given in `testDCAFitterN.cxx`.

From 6963217343a8c835231e1494eae7508ac1badb74 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 10 Apr 2025 10:59:24 +0200
Subject: [PATCH 0263/1764] Fix for TPC edge clusters in CTF decoding

---
 .../DataCompression/GPUTPCDecompressionKernels.cxx  | 13 +++++++++++++
 .../DataCompression/TPCClusterDecompressor.cxx      | 13 +++++++++++++
 GPU/GPUTracking/Definitions/GPUSettingsList.h       |  1 +
 3 files changed, 27 insertions(+)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
index ee1a9c97cc30b..68e45f0c08c32 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
@@ -57,6 +57,19 @@ GPUdii() void GPUTPCDecompressionKernels::Thread<GPUTPCDecompressionKernels::ste
     ClusterNative* clout = buffer + decompressor.mNativeClustersIndex[linearIndex];
     uint32_t end = offsets[linearIndex] + ((linearIndex >= decompressor.mInputGPU.nSliceRows) ? 0 : decompressor.mInputGPU.nSliceRowClusters[linearIndex]);
     TPCClusterDecompressionCore::decompressHits(cmprClusters, offsets[linearIndex], end, clout);
+    if (processors.param.rec.tpc.clustersEdgeFixDistance > 0.f) {
+      constexpr GPUTPCGeometry geo;
+      for (uint32_t k = 0; k < outputAccess->nClusters[iSector][iRow]; k++) {
+        auto& cluster = buffer[k];
+        if (cluster.getFlags() & ClusterNative::flagEdge) {
+          auto padF = cluster.getPad();
+          float distEdge = padF < geo.NPads(iRow) / 2 ? padF : geo.NPads(iRow) - 1 - padF;
+          if (distEdge > processors.param.rec.tpc.clustersEdgeFixDistance) {
+            cluster.setFlags(cluster.getFlags() ^ ClusterNative::flagEdge);
+          }
+        }
+      }
+    }
     if (processors.param.rec.tpc.clustersShiftTimebins != 0.f) {
       for (uint32_t k = 0; k < outputAccess->nClusters[iSector][iRow]; k++) {
         auto& cl = buffer[k];
diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
index 296a203cf070b..cd1717faf178d 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
@@ -94,6 +94,19 @@ int32_t TPCClusterDecompressor::decompress(const CompressedClusters* clustersCom
       ClusterNative* clout = buffer + clusters[i][j].size();
       uint32_t end = offsets[i][j] + ((i * GPUCA_ROW_COUNT + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_ROW_COUNT + j]);
       TPCClusterDecompressionCore::decompressHits(*clustersCompressed, offsets[i][j], end, clout);
+      if (param.rec.tpc.clustersEdgeFixDistance > 0.f) {
+        constexpr GPUTPCGeometry geo;
+        for (uint32_t k = 0; k < clustersNative.nClusters[i][j]; k++) {
+          auto& cluster = buffer[k];
+          if (cluster.getFlags() & ClusterNative::flagEdge) {
+            auto padF = cluster.getPad();
+            float distEdge = padF < geo.NPads(j) / 2 ? padF : geo.NPads(j) - 1 - padF;
+            if (distEdge > param.rec.tpc.clustersEdgeFixDistance) {
+              cluster.setFlags(cluster.getFlags() ^ ClusterNative::flagEdge);
+            }
+          }
+        }
+      }
       if (param.rec.tpc.clustersShiftTimebins != 0.f) {
         for (uint32_t k = 0; k < clustersNative.nClusters[i][j]; k++) {
           auto& cl = buffer[k];
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 9d1772379f6bd..6858889f9a603 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -72,6 +72,7 @@ AddOptionRTC(tubeChi2, float, 5.f * 5.f, "", 0, "Max chi2 to mark cluster adjace
 AddOptionRTC(tubeMaxSize2, float, 2.5f * 2.5f, "", 0, "Square of max tube size (normally derrived from tpcTubeChi2)")
 AddOptionRTC(clustersShiftTimebins, float, 0, "", 0, "Shift of TPC clusters (applied during CTF cluster decoding)")
 AddOptionRTC(clustersShiftTimebinsClusterizer, float, 0, "", 0, "Shift of TPC clusters (applied during CTF clusterization)")
+AddOptionRTC(clustersEdgeFixDistance, float, 0.f, "", 0, "If >0, revert cluster.flag edge bit distance to edge exceeds this parameter (fixed during CTF decoding)")
 AddOptionRTC(defaultZOffsetOverR, float, 0.5210953f, "", 0, "Shift of TPC clusters (applied during CTF cluster decoding)")
 AddOptionRTC(PID_EKrangeMin, float, 0.47f, "", 0, "min P of electron/K BB bands crossing")
 AddOptionRTC(PID_EKrangeMax, float, 0.57f, "", 0, "max P of electron/K BB bands crossing")

From 186e9142adfd224096e1c84559a1a9d53c94bc87 Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Sat, 19 Apr 2025 11:07:02 +0200
Subject: [PATCH 0264/1764] ctpdev: consistency checker fixes (#14202)

* fix

* clang

---------

Co-authored-by: Roman Lietava <rl@192.168.1.25>
---
 Detectors/CTP/reconstruction/src/RawDataDecoder.cxx | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
index faa3dbac3e934..fa7fd673c7e85 100644
--- a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
+++ b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
@@ -636,8 +636,13 @@ int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits,
   for (auto const& digit : digits) {
     // if class mask => inps
     for (int i = 0; i < digit.CTPClassMask.size(); i++) {
-      if (digit.CTPClassMask[i]) {
+      if (digit.CTPClassMask[i] & trgclassmask) {
         const CTPClass* cls = mCTPConfig.getCTPClassFromHWIndex(i);
+        if (cls == nullptr) {
+          LOG(error) << "Class mask index not found in CTP config:" << i;
+          ret = 128;
+          continue;
+        }
         uint64_t clsinpmask = cls->descriptor->getInputsMask();
         uint64_t diginpmask = digit.CTPInputMask.to_ullong();
         if (!((clsinpmask & diginpmask) == clsinpmask)) {

From fc8f84f350a60ef31a78e18310f1b1be84dd1137 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 18 Apr 2025 19:55:43 +0200
Subject: [PATCH 0265/1764] GPU RTC: Don't pass a third launch bounds parameter

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu
index 571428dc39e21..3e4d3113fb995 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu
@@ -15,7 +15,7 @@
 #define GPUCA_GPUCODE_HOSTONLY
 #define GPUCA_GPUCODE_NO_LAUNCH_BOUNDS
 
-#define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_STRIP(args))
+#define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
 
 #include "GPUReconstructionCUDAIncludesSystem.h"
 #include "GPUReconstructionCUDADef.h"

From 1de28ad9206a381bcfc569c8f0c1675ada63db65 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 18 Apr 2025 22:51:43 +0200
Subject: [PATCH 0266/1764] GPU: Fix parameter that was forgotten when moving
 to if constexpr with GPUCA_PAR_...

---
 GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h | 3 +++
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx          | 8 ++++----
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 4ee6b23d46b51..57ad9907ca86f 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -574,6 +574,9 @@
   #ifndef GPUCA_PAR_COMP_GATHER_MODE
     #define GPUCA_PAR_COMP_GATHER_MODE 0
   #endif
+  #ifndef GPUCA_PAR_NO_ATOMIC_PRECHECK
+    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 0
+  #endif
   #ifndef GPUCA_PAR_DEDX_STORAGE_TYPE
     #define GPUCA_PAR_DEDX_STORAGE_TYPE float
   #endif
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 3b50bec45a41e..ddf01b586cd70 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -631,11 +631,11 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
     for (uint32_t ih = hitFst; ih < hitLst; ih++) {
       int32_t id = idOffset + ids[ih];
       GPUAtomic(uint32_t)* const weight = weights + id;
-#if GPUCA_NO_ATOMIC_PRECHECK == 0
-      if (myWeight <= *weight) {
-        continue;
+      if constexpr (GPUCA_PAR_NO_ATOMIC_PRECHECK == 0) {
+        if (myWeight <= *weight) {
+          continue;
+        }
       }
-#endif
       const cahit2 hh = CA_TEXTURE_FETCH(cahit2, gAliTexRefu2, hits, ih);
       const float y = y0 + hh.x * stepY;
       const float z = z0 + hh.y * stepZ;

From 8ffe16744647bf7792b3e04dfa9df8dbefcb8afd Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 19 Apr 2025 12:28:36 +0200
Subject: [PATCH 0267/1764] GPU: Cleanup, remove obsolete code

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |  1 -
 .../Base/cuda/GPUReconstructionCUDA.cu        | 18 ----------
 .../Base/cuda/GPUReconstructionCUDA.h         |  1 -
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  5 ---
 .../Base/opencl/GPUReconstructionOCL.cl       |  2 --
 GPU/GPUTracking/Definitions/GPUDef.h          |  6 ----
 .../Definitions/GPUDefParametersDefaults.h    |  1 -
 .../Definitions/GPUDefParametersWrapper.h     |  5 ---
 GPU/GPUTracking/Global/GPUChain.h             |  1 -
 .../Global/GPUChainTrackingSectorTracker.cxx  | 11 -------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |  8 ++---
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.h | 33 ++++---------------
 .../SectorTracker/GPUTPCTrackingData.h        |  8 +----
 .../GPUTPCTrackletConstructor.cxx             | 18 +++++-----
 .../SectorTracker/GPUTPCTrackletConstructor.h |  3 --
 15 files changed, 19 insertions(+), 102 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index 163b00c804d7f..dfd6176827484 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -112,7 +112,6 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
   int32_t ExitDevice() override;
   int32_t GetThread();
 
-  virtual int32_t PrepareTextures() { return 0; }
   virtual int32_t DoStuckProtection(int32_t stream, deviceEvent event) { return 0; }
 
   // Pointers to tracker classes
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 3bea91994ba86..3b5e257cc8000 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -254,12 +254,6 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       return (1);
     }
 
-#ifdef GPUCA_USE_TEXTURES
-    if (GPUCA_SECTOR_DATA_MEMORY * NSECTORS > (size_t)deviceProp.maxTexture1DLinear) {
-      GPUError("Invalid maximum texture size of device: %ld < %ld\n", (int64_t)deviceProp.maxTexture1DLinear, (int64_t)(GPUCA_SECTOR_DATA_MEMORY * NSECTORS));
-      return (1);
-    }
-#endif
 #ifndef GPUCA_NO_CONSTANT_MEMORY
     if (gGPUConstantMemBufferSize > deviceProp.totalConstMem) {
       GPUError("Insufficient constant memory available on GPU %d < %d!", (int32_t)deviceProp.totalConstMem, (int32_t)gGPUConstantMemBufferSize);
@@ -627,18 +621,6 @@ void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
 }
 
 #ifndef __HIPCC__ // CUDA
-int32_t GPUReconstructionCUDA::PrepareTextures()
-{
-#ifdef GPUCA_USE_TEXTURES
-  cudaChannelFormatDesc channelDescu2 = cudaCreateChannelDesc<cahit2>();
-  size_t offset;
-  GPUChkErr(cudaBindTexture(&offset, &gAliTexRefu2, mProcessorsShadow->tpcTrackers[0].Data().Memory(), &channelDescu2, NSECTORS * GPUCA_SECTOR_DATA_MEMORY));
-  cudaChannelFormatDesc channelDescu = cudaCreateChannelDesc<calink>();
-  GPUChkErr(cudaBindTexture(&offset, &gAliTexRefu, mProcessorsShadow->tpcTrackers[0].Data().Memory(), &channelDescu, NSECTORS * GPUCA_SECTOR_DATA_MEMORY));
-#endif
-  return (0);
-}
-
 void GPUReconstructionCUDA::startGPUProfiling()
 {
   GPUChkErr(cudaProfilerStart());
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index b1a3a53a6a62f..106168ef961a5 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -79,7 +79,6 @@ class GPUReconstructionCUDA : public GPUReconstructionKernels<GPUReconstructionC
 
 #ifndef __HIPCC__ // CUDA
   bool CanQueryMaxMemory() override { return true; }
-  int32_t PrepareTextures() override;
   void startGPUProfiling() override;
   void endGPUProfiling() override;
 #else // HIP
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index cf08785e6b3d5..d53f7cbd81ca9 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -20,11 +20,6 @@
 
 using namespace o2::gpu;
 
-#ifdef GPUCA_USE_TEXTURES
-texture<cahit2, cudaTextureType1D, cudaReadModeElementType> gAliTexRefu2;
-texture<calink, cudaTextureType1D, cudaReadModeElementType> gAliTexRefu;
-#endif
-
 #include "GPUReconstructionIncludesDeviceAll.h"
 
 #if defined(__HIPCC__) && defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM)
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
index 10a425e4c76e8..ffdc34d6c9881 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
@@ -73,8 +73,6 @@ typedef signed char int8_t;
 #include "GPUConstantMem.h"
 #include "GPUReconstructionIncludesDeviceAll.h"
 
-// if (gpu_mem != pTracker.GPUParametersConst()->gpumem) return; //TODO!
-
 #define GPUCA_KRNL(...) GPUCA_KRNLGPU(__VA_ARGS__)
 #define GPUCA_CONSMEM_PTR GPUglobal() char *gpu_mem, GPUconstant() GPUConstantMem* pConstant,
 #define GPUCA_CONSMEM (*pConstant)
diff --git a/GPU/GPUTracking/Definitions/GPUDef.h b/GPU/GPUTracking/Definitions/GPUDef.h
index c77b9ce159306..69723813d384f 100644
--- a/GPU/GPUTracking/Definitions/GPUDef.h
+++ b/GPU/GPUTracking/Definitions/GPUDef.h
@@ -58,12 +58,6 @@
   #define CA_SHARED_CACHE_REF(target, src, size, reftype, ref) GPUglobalref() const reftype* __restrict__ ref = src
 #endif
 
-#ifdef GPUCA_TEXTURE_FETCH_CONSTRUCTOR
-  #define CA_TEXTURE_FETCH(type, texture, address, entry) tex1Dfetch(texture, ((char*) address - tracker.Data().GPUTextureBase()) / sizeof(type) + entry);
-#else
-  #define CA_TEXTURE_FETCH(type, texture, address, entry) address[entry];
-#endif
-
 #endif //GPUTPCDEF_H
 
 #ifdef GPUCA_CADEBUG
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 57ad9907ca86f..19301ef2bef9f 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -267,7 +267,6 @@
     #define GPUCA_PAR_COMP_GATHER_MODE 3
     #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
     #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
-    // #define GPUCA_USE_TEXTURES
   #elif defined(GPUCA_GPUTYPE_OPENCL)
   #else
     #error GPU TYPE NOT SET
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
index b2c08d689aeb2..8a54ab2163eab 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersWrapper.h
@@ -43,11 +43,6 @@ namespace o2::gpu
 
 // #define GPUCA_KERNEL_DEBUGGER_OUTPUT
 
-// Derived parameters
-#ifdef GPUCA_USE_TEXTURES
-  #define GPUCA_TEXTURE_FETCH_CONSTRUCTOR                              // Fetch data through texture cache
-#endif
-
 } // namespace o2::gpu
 
 // clang-format on
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index 290ae32cafca8..c4dccb091fc95 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -216,7 +216,6 @@ class GPUChain
 
   inline GPUChain* GetNextChainInQueue() { return mRec->GetNextChainInQueue(); }
 
-  virtual int32_t PrepareTextures() { return 0; }
   virtual int32_t DoStuckProtection(int32_t stream, deviceEvent event) { return 0; }
 
   template <class T, class S, typename... Args>
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 64a9179baf0e6..962b0922eeecc 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -103,17 +103,6 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   int32_t streamInitAndOccMap = mRec->NStreams() - 1;
 
   if (doGPU) {
-    for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
-      processorsShadow()->tpcTrackers[iSector].GPUParametersConst()->gpumem = (char*)mRec->DeviceMemoryBase();
-      // Initialize Startup Constants
-      processors()->tpcTrackers[iSector].GPUParameters()->nextStartHit = (((getKernelProperties<GPUTPCTrackletConstructor>().minBlocks * BlockCount()) + NSECTORS - 1 - iSector) / NSECTORS) * getKernelProperties<GPUTPCTrackletConstructor>().nThreads;
-      processorsShadow()->tpcTrackers[iSector].SetGPUTextureBase(mRec->DeviceMemoryBase());
-    }
-
-    if (PrepareTextures()) {
-      return (2);
-    }
-
     // Copy Tracker Object to GPU Memory
     if (GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Copying Tracker objects to GPU");
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index ddf01b586cd70..5bd8fd556aa3f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -580,10 +580,8 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   }
   const GPUTPCTracker& GPUrestrict() tracker = *(Merger -> GetConstantMem()->tpcTrackers + sector);
   const GPUTPCRow& GPUrestrict() row = tracker.Row(iRow);
-#ifndef GPUCA_TEXTURE_FETCH_CONSTRUCTOR
   GPUglobalref() const cahit2* hits = tracker.HitData(row);
   GPUglobalref() const calink* firsthit = tracker.FirstHitInBin(row);
-#endif //! GPUCA_TEXTURE_FETCH_CONSTRUCTOR
   if (row.NHits() == 0) {
     return -1e6f;
   }
@@ -626,8 +624,8 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   }
   for (int32_t k = 0; k <= nz; k++) {
     const int32_t mybin = bin + k * nBinsY;
-    const uint32_t hitFst = CA_TEXTURE_FETCH(calink, gAliTexRefu, firsthit, mybin);
-    const uint32_t hitLst = CA_TEXTURE_FETCH(calink, gAliTexRefu, firsthit, mybin + ny + 1);
+    const uint32_t hitFst = firsthit[mybin];
+    const uint32_t hitLst = firsthit[mybin + ny + 1];
     for (uint32_t ih = hitFst; ih < hitLst; ih++) {
       int32_t id = idOffset + ids[ih];
       GPUAtomic(uint32_t)* const weight = weights + id;
@@ -636,7 +634,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
           continue;
         }
       }
-      const cahit2 hh = CA_TEXTURE_FETCH(cahit2, gAliTexRefu2, hits, ih);
+      const cahit2 hh = hits[ih];
       const float y = y0 + hh.x * stepY;
       const float z = z0 + hh.y * stepZ;
       const float dy = y - uncorrectedY;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
index e8aac872198f5..3bebdc4fa2b06 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
@@ -59,24 +59,14 @@ class GPUTPCTracker : public GPUProcessor
   void DumpTrackletHits(std::ostream& out);         // Same for Track Hits
 #endif
 
-  struct StructGPUParameters {
-    GPUAtomic(uint32_t) nextStartHit; // Next Tracklet to process
-  };
-
-  struct StructGPUParametersConst {
-    GPUglobalref() char* gpumem; // Base pointer to GPU memory (Needed for OpenCL for verification)
-  };
-
   struct commonMemoryStruct {
-    commonMemoryStruct() : nStartHits(0), nTracklets(0), nRowHits(0), nTracks(0), nLocalTracks(0), nTrackHits(0), nLocalTrackHits(0), gpuParameters() {}
-    GPUAtomic(uint32_t) nStartHits;    // number of start hits
-    GPUAtomic(uint32_t) nTracklets;    // number of tracklets
-    GPUAtomic(uint32_t) nRowHits;      // number of tracklet hits
-    GPUAtomic(uint32_t) nTracks;       // number of reconstructed tracks
-    int32_t nLocalTracks;              // number of reconstructed tracks before extrapolation tracking
-    GPUAtomic(uint32_t) nTrackHits;    // number of track hits
-    int32_t nLocalTrackHits;           // see above
-    StructGPUParameters gpuParameters; // GPU parameters
+    GPUAtomic(uint32_t) nStartHits = 0; // number of start hits
+    GPUAtomic(uint32_t) nTracklets = 0; // number of tracklets
+    GPUAtomic(uint32_t) nRowHits = 0;   // number of tracklet hits
+    GPUAtomic(uint32_t) nTracks = 0;    // number of reconstructed tracks
+    int32_t nLocalTracks = 0;           // number of reconstructed tracks before extrapolation tracking
+    GPUAtomic(uint32_t) nTrackHits = 0; // number of track hits
+    int32_t nLocalTrackHits = 0;        // see above
   };
 
   GPUhdi() GPUglobalref() const GPUTPCClusterData* ClusterData() const
@@ -205,13 +195,6 @@ class GPUTPCTracker : public GPUProcessor
 
   GPUhd() GPUglobalref() GPUTPCRow* TrackingDataRows() const { return (mData.Rows()); }
   GPUhd() GPUglobalref() int32_t* RowStartHitCountOffset() const { return (mRowStartHitCountOffset); }
-  GPUhd() GPUglobalref() StructGPUParameters* GPUParameters() const { return (&mCommonMem->gpuParameters); }
-  GPUhd() StructGPUParametersConst* GPUParametersConst()
-  {
-    return (&mGPUParametersConst);
-  }
-  GPUhd() const StructGPUParametersConst* GetGPUParametersConst() const { return (&mGPUParametersConst); }
-  GPUhd() void SetGPUTextureBase(GPUglobalref() const void* val) { mData.SetGPUTextureBase(val); }
 
   struct trackSortData {
     int32_t fTtrack; // Track ID
@@ -253,8 +236,6 @@ class GPUTPCTracker : public GPUProcessor
   GPUglobalref() GPUTPCHitId* mTrackletTmpStartHits = nullptr; // Unsorted start hits
   GPUglobalref() char* mGPUTrackletTemp = nullptr;             // Temp Memory for GPU Tracklet Constructor
 
-  StructGPUParametersConst mGPUParametersConst; // Parameters for GPU if this is a GPU tracker
-
   // event
   GPUglobalref() commonMemoryStruct* mCommonMem = nullptr;  // common event memory
   GPUglobalref() GPUTPCHitId* mTrackletStartHits = nullptr; // start hits for the tracklets
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.h
index d7d5e76bc9d44..b08fbed4b319d 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.h
@@ -29,7 +29,7 @@ class GPUTPCHit;
 class GPUTPCTrackingData
 {
  public:
-  GPUTPCTrackingData() : mNumberOfHits(0), mNumberOfHitsPlusAlign(0), mClusterIdOffset(0), mGPUTextureBase(nullptr), mRows(nullptr), mLinkUpData(nullptr), mLinkDownData(nullptr), mClusterData(nullptr) {}
+  GPUTPCTrackingData() : mNumberOfHits(0), mNumberOfHitsPlusAlign(0), mClusterIdOffset(0), mRows(nullptr), mLinkUpData(nullptr), mLinkDownData(nullptr), mClusterData(nullptr) {}
 
 #ifndef GPUCA_GPUCODE_DEVICE
   ~GPUTPCTrackingData() = default;
@@ -112,10 +112,6 @@ class GPUTPCTrackingData
 
   GPUhdi() GPUglobalref() GPUAtomic(uint32_t) * HitWeights() { return (mHitWeights); }
 
-  GPUhdi() void SetGPUTextureBase(GPUglobalref() const void* val) { mGPUTextureBase = val; }
-  GPUhdi() char* GPUTextureBase() const { return ((char*)mGPUTextureBase); }
-  GPUhdi() char* GPUTextureBaseConst() const { return ((char*)mGPUTextureBase); }
-
   GPUhdi() GPUglobalref() const GPUTPCClusterData* ClusterData() const { return mClusterData; }
 
  private:
@@ -135,8 +131,6 @@ class GPUTPCTrackingData
   int32_t mNumberOfHitsPlusAlign;
   int32_t mClusterIdOffset;
 
-  GPUglobalref() const void* mGPUTextureBase; // pointer to start of GPU texture
-
   GPUglobalref() GPUTPCRow* mRows; // The row objects needed for most accessor functions
 
   GPUglobalref() calink* mLinkUpData;        // hit index in the row above which is linked to the given (global) hit index
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
index 71df683eee1dc..2660f6d8cbf44 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
@@ -123,10 +123,10 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
         break; // SG!!! - jump over the row
       }
 
-      cahit2 hh = CA_TEXTURE_FETCH(cahit22, gAliTexRefu2, tracker.HitData(row), r.mCurrIH);
+      cahit2 hh = tracker.HitData(row)[r.mCurrIH];
 
       int32_t seedIH = r.mCurrIH;
-      r.mCurrIH = CA_TEXTURE_FETCH(calink, gAliTexRefs, tracker.HitLinkUpData(row), r.mCurrIH);
+      r.mCurrIH = tracker.HitLinkUpData(row)[r.mCurrIH];
 
       float x = row.X();
       float y = y0 + hh.x * stepY;
@@ -282,10 +282,8 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
           break;
         }
 
-#ifndef GPUCA_TEXTURE_FETCH_CONSTRUCTOR
         GPUglobalref() const cahit2* hits = tracker.HitData(row);
         GPUglobalref() const calink* firsthit = tracker.FirstHitInBin(row);
-#endif //! GPUCA_TEXTURE_FETCH_CONSTRUCTOR
         tracker.GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(tracker.ISector(), iRow, yUncorrected, zUncorrected, yUncorrected, zUncorrected);
 
         if (tracker.Param().rec.tpc.rejectEdgeClustersInSeeding && tracker.Param().rejectEdgeClusterByY(yUncorrected, iRow, CAMath::Sqrt(tParam.Err2Y()))) {
@@ -318,14 +316,14 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
 #endif
             int32_t nBinsY = row.Grid().Ny();
             int32_t mybin = bin + k * nBinsY;
-            uint32_t hitFst = CA_TEXTURE_FETCH(calink, gAliTexRefu, firsthit, mybin);
-            uint32_t hitLst = CA_TEXTURE_FETCH(calink, gAliTexRefu, firsthit, mybin + ny + 1);
+            uint32_t hitFst = firsthit[mybin];
+            uint32_t hitLst = firsthit[mybin + ny + 1];
 #ifdef __HIPCC__ // Todo: fixme!
             for (uint32_t ih = hitFst - 1; ++ih < hitLst; /*ih++*/) {
 #else
             for (uint32_t ih = hitFst; ih < hitLst; ih++) {
 #endif
-              cahit2 hh = CA_TEXTURE_FETCH(cahit2, gAliTexRefu2, hits, ih);
+              cahit2 hh = hits[ih];
               float y = y0 + hh.x * stepY;
               float z = z0 + hh.y * stepZ;
               float dy = y - yUncorrected;
@@ -353,7 +351,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
           }
         }
 
-        cahit2 hh = CA_TEXTURE_FETCH(cahit2, gAliTexRefu2, hits, best);
+        cahit2 hh = hits[best];
         float y = y0 + hh.x * stepY + tParam.GetY() - yUncorrected;
         float z = z0 + hh.y * stepZ + tParam.GetZ() - zUncorrected;
 
@@ -390,8 +388,8 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
     const GPUglobalref() GPUTPCRow& GPUrestrict() row2 = tracker.Row(r.mLastRow);
     GPUglobalref() const cahit2* hits1 = tracker.HitData(row1);
     GPUglobalref() const cahit2* hits2 = tracker.HitData(row2);
-    const cahit2 hh1 = CA_TEXTURE_FETCH(cahit2, gAliTexRefu2, hits1, rowHits[r.mFirstRow]);
-    const cahit2 hh2 = CA_TEXTURE_FETCH(cahit2, gAliTexRefu2, hits2, rowHits[r.mLastRow]);
+    const cahit2 hh1 = hits1[rowHits[r.mFirstRow]];
+    const cahit2 hh2 = hits2[rowHits[r.mLastRow]];
     const float z1 = row1.Grid().ZMin() + hh1.y * row1.HstepZ();
     const float z2 = row2.Grid().ZMin() + hh2.y * row2.HstepZ();
     float oldOffset = tParam.ZOffset();
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
index af87d0276f1c7..031c32b2b4334 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
@@ -63,9 +63,6 @@ class GPUTPCTrackletConstructor : public GPUKernelTemplate
 
   struct GPUSharedMemory {
     CA_SHARED_STORAGE(GPUTPCRow mRows[GPUCA_ROW_COUNT]); // rows
-    int32_t mNextStartHitFirst;                          // First start hit to be processed by CUDA block during next iteration
-    int32_t mNextStartHitCount;                          // Number of start hits to be processed by CUDA block during next iteration
-    int32_t mNextStartHitFirstRun;                       // First run for dynamic scheduler?
     int32_t mNStartHits;                                 // Total number of start hits
 
 #ifdef GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE

From 497d53fdd0e4daaae9cf526a3c1988f8684728a9 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Sun, 20 Apr 2025 12:22:22 +0200
Subject: [PATCH 0268/1764] GPU stream implementation for ONNX runtime (#14117)

* Initial set of bug.fixes and cosmetic changes

* Please consider the following formatting changes

* Adjusting eval sizes. Makes code neater and avoids some calculations

* Adding separate functions. Now the host process only needs one instance and one initialization

* First version of CCDB implementation

* Working CCDB API calls (tested with test-ccdb)

* Improve fetching, but have to pass settings by value, not const ref

* Using const ref and moving CCDB calls to host initialization

* Simplifications and renaming

* Please consider the following formatting changes

* First version of GPU stream implementation. Still needs testing.

* Fixes

* Please consider the following formatting changes

* Adding the lane variable. This PR will in any case conflict with #14069

* Compiles on EPNs. Need to add shadow processors next. But for this, I will merge https://github.com/AliceO2Group/AliceO2/pull/14069 to have the changes in GPUChainTrackingClusterizer.

* Adding shadow instance. Not sure if this correctly allocates GPU memory using AllocateRegisteredMemory

* This runs, but will eventually fill up the VRAM. Need to include a mem clean

* Found the stream allocation issue. Now starting optimizations

* Improve readability and adapt for some comments

* Fixing memory assignment issue. Reconstruction runs through with FP32 networks

* Major reworkings to add FP16 support

* Bug-fixes

* Improved data filling speeds by factor 3

* Limiting threads for ONNX evaluation

* Bug-fix for correct thread assignment and input data filling

* Minor changes

* Adding I** inference, potentally needed for CNN + FC inference

* CCDB fetching of NNs ported to GPUWorkflowSpec

* Adjusting CPU threads and ORT copmile definitions

* About 10x speed-up due to explicit io binding

* Changes for synchronization and consistency. No performance loss.

* Please consider the following formatting changes

* Fixing warnings (errors due to size_t)

* Fixing linker issues

* Adding volatile memory allocation and MockedOrtAllocator. Removing print statements and time measurements

* Please consider the following formatting changes

* Circumvent "unused result" warning and build failure

* Adjust for comments

* Please consider the following formatting changes

* Fixing build flags

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Common/ML/CMakeLists.txt                      |  21 +-
 Common/ML/include/ML/3rdparty/GPUORTFloat16.h |   2 +-
 Common/ML/include/ML/OrtInterface.h           |  86 +++-
 Common/ML/src/OrtInterface.cxx                | 410 +++++++++++++-----
 Detectors/TPC/calibration/CMakeLists.txt      |   2 +
 .../TPCCalibration/NeuralNetworkClusterizer.h |  38 ++
 .../src/NeuralNetworkClusterizer.cxx          |  48 ++
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |   8 +
 .../Base/GPUReconstructionProcessing.h        |   5 +
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |   6 +
 .../Base/cuda/GPUReconstructionCUDA.cu        |  42 ++
 .../Base/cuda/GPUReconstructionCUDA.h         |   6 +
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |   6 +
 GPU/GPUTracking/CMakeLists.txt                |   1 +
 .../Definitions/GPUDefParametersDefaults.h    |   1 +
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  14 +-
 GPU/GPUTracking/Global/GPUChain.h             |   1 +
 .../Global/GPUChainTrackingClusterizer.cxx    | 250 ++++++++---
 .../TPCClusterFinder/GPUTPCNNClusterizer.cxx  |  78 +++-
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |  33 +-
 .../GPUTPCNNClusterizerHost.cxx               | 191 +++++++-
 .../GPUTPCNNClusterizerHost.h                 |  39 +-
 .../GPUTPCNNClusterizerKernels.cxx            | 393 ++++++++++-------
 .../GPUTPCNNClusterizerKernels.h              |  10 +-
 GPU/GPUTracking/kernels.cmake                 |   1 +
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |   3 +
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |  45 ++
 27 files changed, 1301 insertions(+), 439 deletions(-)
 create mode 100644 Detectors/TPC/calibration/include/TPCCalibration/NeuralNetworkClusterizer.h
 create mode 100644 Detectors/TPC/calibration/src/NeuralNetworkClusterizer.cxx

diff --git a/Common/ML/CMakeLists.txt b/Common/ML/CMakeLists.txt
index 540fe8ebf271c..2db91fc4f4320 100644
--- a/Common/ML/CMakeLists.txt
+++ b/Common/ML/CMakeLists.txt
@@ -9,21 +9,14 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-# Pass ORT variables as a preprocessor definition
-if(ORT_ROCM_BUILD)
-    add_compile_definitions(ORT_ROCM_BUILD=1)
-endif()
-if(ORT_CUDA_BUILD)
-    add_compile_definitions(ORT_CUDA_BUILD=1)
-endif()
-if(ORT_MIGRAPHX_BUILD)
-    add_compile_definitions(ORT_MIGRAPHX_BUILD=1)
-endif()
-if(ORT_TENSORRT_BUILD)
-    add_compile_definitions(ORT_TENSORRT_BUILD=1)
-endif()
-
 o2_add_library(ML
                SOURCES src/OrtInterface.cxx
                TARGETVARNAME targetName
                PRIVATE_LINK_LIBRARIES O2::Framework ONNXRuntime::ONNXRuntime)
+
+# Pass ORT variables as a preprocessor definition
+target_compile_definitions(${targetName} PRIVATE
+    $<$<BOOL:${ORT_ROCM_BUILD}>:ORT_ROCM_BUILD>
+    $<$<BOOL:${ORT_CUDA_BUILD}>:ORT_CUDA_BUILD>
+    $<$<BOOL:${ORT_MIGRAPHX_BUILD}>:ORT_MIGRAPHX_BUILD>
+    $<$<BOOL:${ORT_TENSORRT_BUILD}>:ORT_TENSORRT_BUILD>)
diff --git a/Common/ML/include/ML/3rdparty/GPUORTFloat16.h b/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
index 76fd6734cf9db..9516ba5dad573 100644
--- a/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
+++ b/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
@@ -882,4 +882,4 @@ static_assert(sizeof(BFloat16_t) == sizeof(uint16_t), "Sizes must match");
 } // namespace OrtDataType
 
 } // namespace o2
-#endif
\ No newline at end of file
+#endif
diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index 93549178848ca..e37b6a69b6036 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -26,6 +26,13 @@
 // O2 includes
 #include "Framework/Logger.h"
 
+namespace Ort
+{
+struct SessionOptions;
+struct MemoryInfo;
+struct Env;
+} // namespace Ort
+
 namespace o2
 {
 
@@ -36,14 +43,52 @@ class OrtModel
 {
 
  public:
-  // Constructor
+  // Constructors & destructors
   OrtModel() = default;
-  OrtModel(std::unordered_map<std::string, std::string> optionsMap) { reset(optionsMap); }
-  void init(std::unordered_map<std::string, std::string> optionsMap) { reset(optionsMap); }
-  void reset(std::unordered_map<std::string, std::string>);
+  OrtModel(std::unordered_map<std::string, std::string> optionsMap) { init(optionsMap); }
+  void init(std::unordered_map<std::string, std::string> optionsMap)
+  {
+    initOptions(optionsMap);
+    initEnvironment();
+  }
+  virtual ~OrtModel() = default;
+
+  // General purpose
+  void initOptions(std::unordered_map<std::string, std::string> optionsMap);
+  void initEnvironment();
+  void initSession();
+  void memoryOnDevice(int32_t = 0);
   bool isInitialized() { return mInitialized; }
+  void resetSession();
 
-  virtual ~OrtModel() = default;
+  // Getters
+  std::vector<std::vector<int64_t>> getNumInputNodes() const { return mInputShapes; }
+  std::vector<std::vector<int64_t>> getNumOutputNodes() const { return mOutputShapes; }
+  std::vector<std::string> getInputNames() const { return mInputNames; }
+  std::vector<std::string> getOutputNames() const { return mOutputNames; }
+  Ort::SessionOptions* getSessionOptions();
+  Ort::MemoryInfo* getMemoryInfo();
+  Ort::Env* getEnv();
+  int32_t getIntraOpNumThreads() const { return intraOpNumThreads; }
+  int32_t getInterOpNumThreads() const { return interOpNumThreads; }
+
+  // Setters
+  void setDeviceId(int32_t id) { deviceId = id; }
+  void setIO();
+  void setActiveThreads(int threads) { intraOpNumThreads = threads; }
+  void setIntraOpNumThreads(int threads)
+  {
+    if (deviceType == "CPU") {
+      intraOpNumThreads = threads;
+    }
+  }
+  void setInterOpNumThreads(int threads)
+  {
+    if (deviceType == "CPU") {
+      interOpNumThreads = threads;
+    }
+  }
+  void setEnv(Ort::Env*);
 
   // Conversion
   template <class I, class O>
@@ -53,41 +98,36 @@ class OrtModel
   template <class I, class O> // class I is the input data type, e.g. float, class O is the output data type, e.g. OrtDataType::Float16_t from O2/Common/ML/include/ML/GPUORTFloat16.h
   std::vector<O> inference(std::vector<I>&);
 
-  template <class I, class O> // class I is the input data type, e.g. float, class O is the output data type, e.g. O2::gpu::OrtDataType::Float16_t from O2/GPU/GPUTracking/ML/convert_float16.h
+  template <class I, class O>
   std::vector<O> inference(std::vector<std::vector<I>>&);
 
-  template <class I, class O> // class I is the input data type, e.g. float, class O is the output data type, e.g. OrtDataType::Float16_t from O2/Common/ML/include/ML/GPUORTFloat16.h
-  void inference(I*, size_t, O*);
-
-  // template<class I, class T, class O> // class I is the input data type, e.g. float, class T the throughput data type and class O is the output data type
-  // std::vector<O> inference(std::vector<I>&);
-
-  // Reset session
-  void resetSession();
+  template <class I, class O>
+  void inference(I*, int64_t, O*);
 
-  std::vector<std::vector<int64_t>> getNumInputNodes() const { return mInputShapes; }
-  std::vector<std::vector<int64_t>> getNumOutputNodes() const { return mOutputShapes; }
-  std::vector<std::string> getInputNames() const { return mInputNames; }
-  std::vector<std::string> getOutputNames() const { return mOutputNames; }
+  template <class I, class O>
+  void inference(I**, int64_t, O*);
 
-  void setActiveThreads(int threads) { intraOpNumThreads = threads; }
+  void release(bool = false);
 
  private:
-  // ORT variables -> need to be hidden as Pimpl
+  // ORT variables -> need to be hidden as pImpl
   struct OrtVariables;
   OrtVariables* pImplOrt;
 
   // Input & Output specifications of the loaded network
   std::vector<const char*> inputNamesChar, outputNamesChar;
   std::vector<std::string> mInputNames, mOutputNames;
-  std::vector<std::vector<int64_t>> mInputShapes, mOutputShapes;
+  std::vector<std::vector<int64_t>> mInputShapes, mOutputShapes, inputShapesCopy, outputShapesCopy; // Input shapes
+  std::vector<int64_t> inputSizePerNode, outputSizePerNode;                                         // Output shapes
+  int32_t mInputsTotal = 0, mOutputsTotal = 0;                                                      // Total number of inputs and outputs
 
   // Environment settings
   bool mInitialized = false;
-  std::string modelPath, device = "cpu", dtype = "float", thread_affinity = ""; // device options should be cpu, rocm, migraphx, cuda
-  int intraOpNumThreads = 1, interOpNumThreads = 1, deviceId = 0, enableProfiling = 0, loggingLevel = 0, allocateDeviceMemory = 0, enableOptimizations = 0;
+  std::string modelPath, envName = "", deviceType = "CPU", thread_affinity = ""; // device options should be cpu, rocm, migraphx, cuda
+  int32_t intraOpNumThreads = 1, interOpNumThreads = 1, deviceId = -1, enableProfiling = 0, loggingLevel = 0, allocateDeviceMemory = 0, enableOptimizations = 0;
 
   std::string printShape(const std::vector<int64_t>&);
+  std::string printShape(const std::vector<std::vector<int64_t>>&, std::vector<std::string>&);
 };
 
 } // namespace ml
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index 88f548bd4fe7b..24a2fbffb252c 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -33,11 +33,12 @@ struct OrtModel::OrtVariables { // The actual implementation is hidden in the .c
   Ort::SessionOptions sessionOptions;
   Ort::AllocatorWithDefaultOptions allocator;
   Ort::MemoryInfo memoryInfo = Ort::MemoryInfo("Cpu", OrtAllocatorType::OrtDeviceAllocator, 0, OrtMemType::OrtMemTypeDefault);
+  std::unique_ptr<Ort::IoBinding> ioBinding = nullptr;
 };
 
-void OrtModel::reset(std::unordered_map<std::string, std::string> optionsMap)
+// General purpose
+void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsMap)
 {
-
   pImplOrt = new OrtVariables();
 
   // Load from options map
@@ -47,77 +48,60 @@ void OrtModel::reset(std::unordered_map<std::string, std::string> optionsMap)
 
   if (!optionsMap["model-path"].empty()) {
     modelPath = optionsMap["model-path"];
-    device = (optionsMap.contains("device") ? optionsMap["device"] : "CPU");
-    dtype = (optionsMap.contains("dtype") ? optionsMap["dtype"] : "float");
-    deviceId = (optionsMap.contains("device-id") ? std::stoi(optionsMap["device-id"]) : 0);
+    deviceType = (optionsMap.contains("device-type") ? optionsMap["device-type"] : "CPU");
+    deviceId = (optionsMap.contains("device-id") ? std::stoi(optionsMap["device-id"]) : -1);
     allocateDeviceMemory = (optionsMap.contains("allocate-device-memory") ? std::stoi(optionsMap["allocate-device-memory"]) : 0);
     intraOpNumThreads = (optionsMap.contains("intra-op-num-threads") ? std::stoi(optionsMap["intra-op-num-threads"]) : 0);
     interOpNumThreads = (optionsMap.contains("inter-op-num-threads") ? std::stoi(optionsMap["inter-op-num-threads"]) : 0);
     loggingLevel = (optionsMap.contains("logging-level") ? std::stoi(optionsMap["logging-level"]) : 0);
     enableProfiling = (optionsMap.contains("enable-profiling") ? std::stoi(optionsMap["enable-profiling"]) : 0);
     enableOptimizations = (optionsMap.contains("enable-optimizations") ? std::stoi(optionsMap["enable-optimizations"]) : 0);
-
-    std::string dev_mem_str = "Hip";
-#if defined(ORT_ROCM_BUILD)
-    if (device == "ROCM") {
-      Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_ROCM(pImplOrt->sessionOptions, deviceId));
-      LOG(info) << "(ORT) ROCM execution provider set";
-    }
-#endif
-#if defined(ORT_MIGRAPHX_BUILD)
-    if (device == "MIGRAPHX") {
-      Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_MIGraphX(pImplOrt->sessionOptions, deviceId));
-      LOG(info) << "(ORT) MIGraphX execution provider set";
-    }
-#endif
-#if defined(ORT_CUDA_BUILD)
-    if (device == "CUDA") {
-      Ort::ThrowOnError(OrtSessionOptionsAppendExecutionProvider_CUDA(pImplOrt->sessionOptions, deviceId));
-      LOG(info) << "(ORT) CUDA execution provider set";
-      dev_mem_str = "Cuda";
+    envName = (optionsMap.contains("onnx-environment-name") ? optionsMap["onnx-environment-name"] : "onnx_model_inference");
+
+    if (deviceType == "CPU") {
+      (pImplOrt->sessionOptions).SetIntraOpNumThreads(intraOpNumThreads);
+      (pImplOrt->sessionOptions).SetInterOpNumThreads(interOpNumThreads);
+      if (intraOpNumThreads > 1 || interOpNumThreads > 1) {
+        (pImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_PARALLEL);
+      } else if (intraOpNumThreads == 1) {
+        (pImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_SEQUENTIAL);
+      }
+      if (loggingLevel < 2) {
+        LOG(info) << "(ORT) CPU execution provider set with " << intraOpNumThreads << " (intraOpNumThreads) and " << interOpNumThreads << " (interOpNumThreads) threads";
+      }
     }
-#endif
 
-  if (allocateDeviceMemory) {
-    pImplOrt->memoryInfo = Ort::MemoryInfo(dev_mem_str.c_str(), OrtAllocatorType::OrtDeviceAllocator, deviceId, OrtMemType::OrtMemTypeDefault);
-    LOG(info) << "(ORT) Memory info set to on-device memory";
-  }
+    // OrtROCMProviderOptions rocm_options{};
+    // (pImplOrt->sessionOptions).AppendExecutionProvider_ROCM(rocm_options);
 
-  if (device == "CPU") {
-    (pImplOrt->sessionOptions).SetIntraOpNumThreads(intraOpNumThreads);
-    (pImplOrt->sessionOptions).SetInterOpNumThreads(interOpNumThreads);
-    if (intraOpNumThreads > 1 || interOpNumThreads > 1) {
-      (pImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_PARALLEL);
-    } else if (intraOpNumThreads == 1) {
-      (pImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_SEQUENTIAL);
-    }
-    if (loggingLevel < 2) {
-      LOG(info) << "(ORT) CPU execution provider set with " << intraOpNumThreads << " (intraOpNumThreads) and " << interOpNumThreads << " (interOpNumThreads) threads";
-    }
-  }
-
-  (pImplOrt->sessionOptions).DisableMemPattern();
-  (pImplOrt->sessionOptions).DisableCpuMemArena();
+    (pImplOrt->sessionOptions).DisableMemPattern();
+    (pImplOrt->sessionOptions).DisableCpuMemArena();
 
-  if (enableProfiling) {
-    if (optionsMap.contains("profiling-output-path")) {
-      (pImplOrt->sessionOptions).EnableProfiling((optionsMap["profiling-output-path"] + "/ORT_LOG_").c_str());
+    if (enableProfiling) {
+      if (optionsMap.contains("profiling-output-path")) {
+        (pImplOrt->sessionOptions).EnableProfiling((optionsMap["profiling-output-path"] + "/ORT_LOG_").c_str());
+      } else {
+        LOG(warning) << "(ORT) If profiling is enabled, optionsMap[\"profiling-output-path\"] should be set. Disabling profiling for now.";
+        (pImplOrt->sessionOptions).DisableProfiling();
+      }
     } else {
-      LOG(warning) << "(ORT) If profiling is enabled, optionsMap[\"profiling-output-path\"] should be set. Disabling profiling for now.";
       (pImplOrt->sessionOptions).DisableProfiling();
     }
-  } else {
-    (pImplOrt->sessionOptions).DisableProfiling();
-  }
 
-  mInitialized = true;
+    (pImplOrt->sessionOptions).SetGraphOptimizationLevel(GraphOptimizationLevel(enableOptimizations));
+    (pImplOrt->sessionOptions).SetLogSeverityLevel(OrtLoggingLevel(loggingLevel));
 
-  (pImplOrt->sessionOptions).SetGraphOptimizationLevel(GraphOptimizationLevel(enableOptimizations));
-  (pImplOrt->sessionOptions).SetLogSeverityLevel(OrtLoggingLevel(loggingLevel));
+    mInitialized = true;
+  } else {
+    LOG(fatal) << "(ORT) Model path cannot be empty!";
+  }
+}
 
+void OrtModel::initEnvironment()
+{
   pImplOrt->env = std::make_shared<Ort::Env>(
     OrtLoggingLevel(loggingLevel),
-    (optionsMap["onnx-environment-name"].empty() ? "onnx_model_inference" : optionsMap["onnx-environment-name"].c_str()),
+    (envName.empty() ? "ORT" : envName.c_str()),
     // Integrate ORT logging into Fairlogger
     [](void* param, OrtLoggingLevel severity, const char* category, const char* logid, const char* code_location, const char* message) {
       if (severity == ORT_LOGGING_LEVEL_VERBOSE) {
@@ -136,31 +120,48 @@ void OrtModel::reset(std::unordered_map<std::string, std::string> optionsMap)
     },
     (void*)3);
   (pImplOrt->env)->DisableTelemetryEvents(); // Disable telemetry events
-  pImplOrt->session = std::make_shared<Ort::Session>(*(pImplOrt->env), modelPath.c_str(), pImplOrt->sessionOptions);
+}
 
-  for (size_t i = 0; i < (pImplOrt->session)->GetInputCount(); ++i) {
-    mInputNames.push_back((pImplOrt->session)->GetInputNameAllocated(i, pImplOrt->allocator).get());
-  }
-  for (size_t i = 0; i < (pImplOrt->session)->GetInputCount(); ++i) {
-    mInputShapes.emplace_back((pImplOrt->session)->GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape());
-  }
-  for (size_t i = 0; i < (pImplOrt->session)->GetOutputCount(); ++i) {
-    mOutputNames.push_back((pImplOrt->session)->GetOutputNameAllocated(i, pImplOrt->allocator).get());
-  }
-  for (size_t i = 0; i < (pImplOrt->session)->GetOutputCount(); ++i) {
-    mOutputShapes.emplace_back((pImplOrt->session)->GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape());
+void OrtModel::initSession()
+{
+  if (allocateDeviceMemory) {
+    memoryOnDevice(deviceId);
   }
+  pImplOrt->session = std::make_shared<Ort::Session>(*pImplOrt->env, modelPath.c_str(), pImplOrt->sessionOptions);
+  pImplOrt->ioBinding = std::make_unique<Ort::IoBinding>(*pImplOrt->session);
+
+  setIO();
 
-  inputNamesChar.resize(mInputNames.size(), nullptr);
-  std::transform(std::begin(mInputNames), std::end(mInputNames), std::begin(inputNamesChar),
-                 [&](const std::string& str) { return str.c_str(); });
-  outputNamesChar.resize(mOutputNames.size(), nullptr);
-  std::transform(std::begin(mOutputNames), std::end(mOutputNames), std::begin(outputNamesChar),
-                 [&](const std::string& str) { return str.c_str(); });
-  }
   if (loggingLevel < 2) {
-    LOG(info) << "(ORT) Model loaded successfully! (input: " << printShape(mInputShapes[0]) << ", output: " << printShape(mOutputShapes[0]) << ")";
+    LOG(info) << "(ORT) Model loaded successfully! (inputs: " << printShape(mInputShapes, mInputNames) << ", outputs: " << printShape(mOutputShapes, mInputNames) << ")";
+  }
+}
+
+void OrtModel::memoryOnDevice(int32_t deviceIndex)
+{
+#if (defined(ORT_ROCM_BUILD) || defined(ORT_MIGRAPHX_BUILD) || defined(ORT_CUDA_BUILD) || defined(ORT_TENSORRT_BUILD))
+  if (deviceIndex >= 0) {
+    (pImplOrt->runOptions).AddConfigEntry("disable_synchronize_execution_providers", "1");
+    (pImplOrt->sessionOptions).AddConfigEntry("session.use_device_allocator_for_initializers", "1"); // See kOrtSessionOptionsUseDeviceAllocatorForInitializers, https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/onnxruntime_session_options_config_keys.h
+    (pImplOrt->sessionOptions).AddConfigEntry("session.use_env_allocators", "1");                    // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
+    (pImplOrt->sessionOptions).AddConfigEntry("session_options.enable_cpu_mem_arena", "0");          // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
+    // Arena memory shrinkage comes at performance cost
+    /// For now prefer to use single allocation, enabled by O2/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu -> SetONNXGPUStream -> rocm_options.arena_extend_strategy = 0;
+    // (pImplOrt->runOptions).AddConfigEntry("memory.enable_memory_arena_shrinkage", ("gpu:" + std::to_string(deviceIndex)).c_str()); // See kOrtRunOptionsConfigEnableMemoryArenaShrinkage, https://github.com/microsoft/onnxruntime/blob/90c263f471bbce724e77d8e62831d3a9fa838b2f/include/onnxruntime/core/session/onnxruntime_run_options_config_keys.h#L27
+
+    std::string dev_mem_str = "";
+    if (deviceType == "ROCM") {
+      dev_mem_str = "Hip";
+    }
+    if (deviceType == "CUDA") {
+      dev_mem_str = "Cuda";
+    }
+    pImplOrt->memoryInfo = Ort::MemoryInfo(dev_mem_str.c_str(), OrtAllocatorType::OrtDeviceAllocator, deviceIndex, OrtMemType::OrtMemTypeDefault);
+    if (loggingLevel < 2) {
+      LOG(info) << "(ORT) Memory info set to on-device memory for device type " << deviceType << " with ID " << deviceIndex << " and pImplOrt pointer " << pImplOrt;
+    }
   }
+#endif
 }
 
 void OrtModel::resetSession()
@@ -168,6 +169,22 @@ void OrtModel::resetSession()
   pImplOrt->session = std::make_shared<Ort::Session>(*(pImplOrt->env), modelPath.c_str(), pImplOrt->sessionOptions);
 }
 
+// Getters
+Ort::SessionOptions* OrtModel::getSessionOptions()
+{
+  return &pImplOrt->sessionOptions;
+}
+
+Ort::MemoryInfo* OrtModel::getMemoryInfo()
+{
+  return &pImplOrt->memoryInfo;
+}
+
+Ort::Env* OrtModel::getEnv()
+{
+  return (pImplOrt->env).get();
+}
+
 template <class I, class O>
 std::vector<O> OrtModel::v2v(std::vector<I>& input, bool clearInput)
 {
@@ -183,20 +200,70 @@ std::vector<O> OrtModel::v2v(std::vector<I>& input, bool clearInput)
   }
 }
 
-std::string OrtModel::printShape(const std::vector<int64_t>& v)
+void OrtModel::setIO()
 {
-  std::stringstream ss("");
-  for (size_t i = 0; i < v.size() - 1; i++) {
-    ss << v[i] << "x";
+  for (size_t i = 0; i < (pImplOrt->session)->GetInputCount(); ++i) {
+    mInputNames.push_back((pImplOrt->session)->GetInputNameAllocated(i, pImplOrt->allocator).get());
   }
-  ss << v[v.size() - 1];
-  return ss.str();
+  for (size_t i = 0; i < (pImplOrt->session)->GetInputCount(); ++i) {
+    mInputShapes.emplace_back((pImplOrt->session)->GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape());
+  }
+  for (size_t i = 0; i < (pImplOrt->session)->GetOutputCount(); ++i) {
+    mOutputNames.push_back((pImplOrt->session)->GetOutputNameAllocated(i, pImplOrt->allocator).get());
+  }
+  for (size_t i = 0; i < (pImplOrt->session)->GetOutputCount(); ++i) {
+    mOutputShapes.emplace_back((pImplOrt->session)->GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape());
+  }
+
+  inputNamesChar.resize(mInputNames.size(), nullptr);
+  std::transform(std::begin(mInputNames), std::end(mInputNames), std::begin(inputNamesChar),
+                 [&](const std::string& str) { return str.c_str(); });
+  outputNamesChar.resize(mOutputNames.size(), nullptr);
+  std::transform(std::begin(mOutputNames), std::end(mOutputNames), std::begin(outputNamesChar),
+                 [&](const std::string& str) { return str.c_str(); });
+
+  inputShapesCopy = mInputShapes;
+  outputShapesCopy = mOutputShapes;
+  inputSizePerNode.resize(mInputShapes.size(), 1);
+  outputSizePerNode.resize(mOutputShapes.size(), 1);
+  mInputsTotal = 1;
+  for (size_t i = 0; i < mInputShapes.size(); ++i) {
+    if (mInputShapes[i].size() > 0) {
+      for (size_t j = 1; j < mInputShapes[i].size(); ++j) {
+        if (mInputShapes[i][j] > 0) {
+          mInputsTotal *= mInputShapes[i][j];
+          inputSizePerNode[i] *= mInputShapes[i][j];
+        }
+      }
+    }
+  }
+  mOutputsTotal = 1;
+  for (size_t i = 0; i < mOutputShapes.size(); ++i) {
+    if (mOutputShapes[i].size() > 0) {
+      for (size_t j = 1; j < mOutputShapes[i].size(); ++j) {
+        if (mOutputShapes[i][j] > 0) {
+          mOutputsTotal *= mOutputShapes[i][j];
+          outputSizePerNode[i] *= mOutputShapes[i][j];
+        }
+      }
+    }
+  }
+}
+
+void OrtModel::setEnv(Ort::Env* env)
+{
+  pImplOrt->env = std::shared_ptr<Ort::Env>(env);
 }
 
+// Inference
 template <class I, class O>
 std::vector<O> OrtModel::inference(std::vector<I>& input)
 {
-  std::vector<int64_t> inputShape{(int64_t)(input.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
+  std::vector<int64_t> inputShape = mInputShapes[0];
+  inputShape[0] = input.size();
+  for (size_t i = 1; i < mInputShapes[0].size(); ++i) {
+    inputShape[0] /= mInputShapes[0][i];
+  }
   std::vector<Ort::Value> inputTensor;
   if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
     inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input.data()), input.size(), inputShape.data(), inputShape.size()));
@@ -212,51 +279,182 @@ std::vector<O> OrtModel::inference(std::vector<I>& input)
 }
 
 template std::vector<float> OrtModel::inference<float, float>(std::vector<float>&);
-
 template std::vector<float> OrtModel::inference<OrtDataType::Float16_t, float>(std::vector<OrtDataType::Float16_t>&);
-
 template std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(std::vector<OrtDataType::Float16_t>&);
 
 template <class I, class O>
-void OrtModel::inference(I* input, size_t input_size, O* output)
+void OrtModel::inference(I* input, int64_t input_size, O* output)
 {
-  std::vector<int64_t> inputShape{(int64_t)(input_size / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
+  // std::vector<std::string> providers = Ort::GetAvailableProviders();
+  // for (const auto& provider : providers) {
+  //     LOG(info) << "Available Execution Provider: " << provider;
+  // }
+  std::vector<int64_t> inputShape{input_size, (int64_t)mInputShapes[0][1]};
   Ort::Value inputTensor = Ort::Value(nullptr);
   if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
-    inputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input), input_size, inputShape.data(), inputShape.size());
+    inputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input), input_size * mInputShapes[0][1], inputShape.data(), inputShape.size());
   } else {
-    inputTensor = Ort::Value::CreateTensor<I>(pImplOrt->memoryInfo, input, input_size, inputShape.data(), inputShape.size());
+    inputTensor = Ort::Value::CreateTensor<I>(pImplOrt->memoryInfo, input, input_size * mInputShapes[0][1], inputShape.data(), inputShape.size());
   }
+  (pImplOrt->ioBinding)->BindInput(mInputNames[0].c_str(), inputTensor);
 
-  std::vector<int64_t> outputShape{inputShape[0], mOutputShapes[0][1]};
-  size_t outputSize = (int64_t)(input_size * mOutputShapes[0][1] / mInputShapes[0][1]);
-  Ort::Value outputTensor = Ort::Value::CreateTensor<O>(pImplOrt->memoryInfo, output, outputSize, outputShape.data(), outputShape.size());
+  std::vector<int64_t> outputShape{input_size, mOutputShapes[0][1]};
+  Ort::Value outputTensor = Ort::Value(nullptr);
+  if constexpr (std::is_same_v<O, OrtDataType::Float16_t>) {
+    outputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(output), input_size * mOutputShapes[0][1], outputShape.data(), outputShape.size());
+  } else {
+    outputTensor = Ort::Value::CreateTensor<O>(pImplOrt->memoryInfo, output, input_size * mOutputShapes[0][1], outputShape.data(), outputShape.size());
+  }
+  (pImplOrt->ioBinding)->BindOutput(mOutputNames[0].c_str(), outputTensor);
 
-  (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), &inputTensor, 1, outputNamesChar.data(), &outputTensor, outputNamesChar.size()); // TODO: Not sure if 1 is correct here
+  (pImplOrt->session)->Run(pImplOrt->runOptions, *pImplOrt->ioBinding);
 }
 
-template void OrtModel::inference<OrtDataType::Float16_t, float>(OrtDataType::Float16_t*, size_t, float*);
+template void OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(OrtDataType::Float16_t*, int64_t, OrtDataType::Float16_t*);
+template void OrtModel::inference<OrtDataType::Float16_t, float>(OrtDataType::Float16_t*, int64_t, float*);
+template void OrtModel::inference<float, OrtDataType::Float16_t>(float*, int64_t, OrtDataType::Float16_t*);
+template void OrtModel::inference<float, float>(float*, int64_t, float*);
+
+template <class I, class O>
+void OrtModel::inference(I** input, int64_t input_size, O* output)
+{
+  std::vector<Ort::Value> inputTensors(inputShapesCopy.size());
+
+  for (size_t i = 0; i < inputShapesCopy.size(); ++i) {
+
+    inputShapesCopy[i][0] = input_size;  // batch-size
+    outputShapesCopy[i][0] = input_size; // batch-size
+
+    if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
+      inputTensors[i] = Ort::Value::CreateTensor<Ort::Float16_t>(
+        pImplOrt->memoryInfo,
+        reinterpret_cast<Ort::Float16_t*>(input[i]),
+        inputSizePerNode[i] * input_size,
+        inputShapesCopy[i].data(),
+        inputShapesCopy[i].size());
+    } else {
+      inputTensors[i] = Ort::Value::CreateTensor<I>(
+        pImplOrt->memoryInfo,
+        input[i],
+        inputSizePerNode[i] * input_size,
+        inputShapesCopy[i].data(),
+        inputShapesCopy[i].size());
+    }
+  }
+
+  Ort::Value outputTensor = Ort::Value(nullptr);
+  if constexpr (std::is_same_v<O, OrtDataType::Float16_t>) {
+    outputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(
+      pImplOrt->memoryInfo,
+      reinterpret_cast<Ort::Float16_t*>(output),
+      outputSizePerNode[0] * input_size, // assumes that there is only one output node
+      outputShapesCopy[0].data(),
+      outputShapesCopy[0].size());
+  } else {
+    outputTensor = Ort::Value::CreateTensor<O>(
+      pImplOrt->memoryInfo,
+      output,
+      outputSizePerNode[0] * input_size, // assumes that there is only one output node
+      outputShapesCopy[0].data(),
+      outputShapesCopy[0].size());
+  }
+
+  // === Run inference ===
+  pImplOrt->session->Run(
+    pImplOrt->runOptions,
+    inputNamesChar.data(),
+    inputTensors.data(),
+    inputNamesChar.size(),
+    outputNamesChar.data(),
+    &outputTensor,
+    outputNamesChar.size());
+}
 
-template void OrtModel::inference<float, float>(float*, size_t, float*);
+template void OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(OrtDataType::Float16_t**, int64_t, OrtDataType::Float16_t*);
+template void OrtModel::inference<OrtDataType::Float16_t, float>(OrtDataType::Float16_t**, int64_t, float*);
+template void OrtModel::inference<float, OrtDataType::Float16_t>(float**, int64_t, OrtDataType::Float16_t*);
+template void OrtModel::inference<float, float>(float**, int64_t, float*);
 
 template <class I, class O>
-std::vector<O> OrtModel::inference(std::vector<std::vector<I>>& input)
+std::vector<O> OrtModel::inference(std::vector<std::vector<I>>& inputs)
 {
-  std::vector<Ort::Value> inputTensor;
-  for (auto i : input) {
-    std::vector<int64_t> inputShape{(int64_t)(i.size() / mInputShapes[0][1]), (int64_t)mInputShapes[0][1]};
+  std::vector<Ort::Value> input_tensors;
+
+  for (size_t i = 0; i < inputs.size(); ++i) {
+
+    inputShapesCopy[i][0] = inputs[i].size() / inputSizePerNode[i]; // batch-size
+
     if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
-      inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(i.data()), i.size(), inputShape.data(), inputShape.size()));
+      input_tensors.emplace_back(
+        Ort::Value::CreateTensor<Ort::Float16_t>(
+          pImplOrt->memoryInfo,
+          reinterpret_cast<Ort::Float16_t*>(inputs[i].data()),
+          inputSizePerNode[i] * inputShapesCopy[i][0],
+          inputShapesCopy[i].data(),
+          inputShapesCopy[i].size()));
     } else {
-      inputTensor.emplace_back(Ort::Value::CreateTensor<I>(pImplOrt->memoryInfo, i.data(), i.size(), inputShape.data(), inputShape.size()));
+      input_tensors.emplace_back(
+        Ort::Value::CreateTensor<I>(
+          pImplOrt->memoryInfo,
+          inputs[i].data(),
+          inputSizePerNode[i] * inputShapesCopy[i][0],
+          inputShapesCopy[i].data(),
+          inputShapesCopy[i].size()));
     }
   }
-  // input.clear();
-  auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
-  O* outputValues = reinterpret_cast<O*>(outputTensors[0].template GetTensorMutableData<O>());
-  std::vector<O> outputValuesVec{outputValues, outputValues + inputTensor.size() / mInputShapes[0][1] * mOutputShapes[0][1]};
-  outputTensors.clear();
-  return outputValuesVec;
+
+  int32_t totalOutputSize = mOutputsTotal * inputShapesCopy[0][0];
+
+  // === Run inference ===
+  auto output_tensors = pImplOrt->session->Run(
+    pImplOrt->runOptions,
+    inputNamesChar.data(),
+    input_tensors.data(),
+    input_tensors.size(),
+    outputNamesChar.data(),
+    outputNamesChar.size());
+
+  // === Extract output values ===
+  O* output_data = output_tensors[0].template GetTensorMutableData<O>();
+  std::vector<O> output_vec(output_data, output_data + totalOutputSize);
+  output_tensors.clear();
+  return output_vec;
+}
+
+template std::vector<float> OrtModel::inference<float, float>(std::vector<std::vector<float>>&);
+template std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(std::vector<std::vector<OrtDataType::Float16_t>>&);
+
+// Release session
+void OrtModel::release(bool profilingEnabled)
+{
+  // if (profilingEnabled) {
+  //   pImplOrt->session->EndProfiling();
+  // }
+  LOG(info) << "(ORT) Size of pImplOrt: " << sizeof(*pImplOrt) << " bytes";
+}
+
+// private
+std::string OrtModel::printShape(const std::vector<int64_t>& v)
+{
+  std::stringstream ss("");
+  for (size_t i = 0; i < v.size() - 1; i++) {
+    ss << v[i] << "x";
+  }
+  ss << v[v.size() - 1];
+  return ss.str();
+}
+
+std::string OrtModel::printShape(const std::vector<std::vector<int64_t>>& v, std::vector<std::string>& n)
+{
+  std::stringstream ss("");
+  for (size_t i = 0; i < v.size(); i++) {
+    ss << n[i] << " -> (";
+    for (size_t j = 0; j < v[i].size() - 1; j++) {
+      ss << v[i][j] << "x";
+    }
+    ss << v[i][v[i].size() - 1] << "); ";
+  }
+  return ss.str();
 }
 
 } // namespace ml
diff --git a/Detectors/TPC/calibration/CMakeLists.txt b/Detectors/TPC/calibration/CMakeLists.txt
index 0ec62e5f323b3..7722fc4e2884f 100644
--- a/Detectors/TPC/calibration/CMakeLists.txt
+++ b/Detectors/TPC/calibration/CMakeLists.txt
@@ -25,6 +25,7 @@ o2_add_library(TPCCalibration
                        src/CalibPadGainTracksBase.cxx
                        src/CalibLaserTracks.cxx
                        src/LaserTracksCalibrator.cxx
+                       src/NeuralNetworkClusterizer.cxx
                        src/SACDecoder.cxx
                        src/IDCAverageGroup.cxx
                        src/IDCAverageGroupBase.cxx
@@ -82,6 +83,7 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/FastHisto.h
                                   include/TPCCalibration/CalibLaserTracks.h
                                   include/TPCCalibration/LaserTracksCalibrator.h
+                                  include/TPCCalibration/NeuralNetworkClusterizer.h
                                   include/TPCCalibration/SACDecoder.h
                                   include/TPCCalibration/IDCAverageGroup.h
                                   include/TPCCalibration/IDCAverageGroupBase.h
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/NeuralNetworkClusterizer.h b/Detectors/TPC/calibration/include/TPCCalibration/NeuralNetworkClusterizer.h
new file mode 100644
index 0000000000000..196bba644714c
--- /dev/null
+++ b/Detectors/TPC/calibration/include/TPCCalibration/NeuralNetworkClusterizer.h
@@ -0,0 +1,38 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   NeuralNetworkClusterizer.h
+/// \brief  Fetching neural networks for clusterization from CCDB
+/// \author Christian Sonnabend
+
+#ifndef AliceO2_TPC_NeuralNetworkClusterizer_h
+#define AliceO2_TPC_NeuralNetworkClusterizer_h
+
+#include "CCDB/CcdbApi.h"
+
+namespace o2::tpc
+{
+
+class NeuralNetworkClusterizer
+{
+ public:
+  NeuralNetworkClusterizer() = default;
+  void initCcdbApi(std::string url);
+  void loadIndividualFromCCDB(std::map<std::string, std::string> settings);
+
+ private:
+  o2::ccdb::CcdbApi ccdbApi;
+  std::map<std::string, std::string> metadata;
+  std::map<std::string, std::string> headers;
+};
+
+} // namespace o2::tpc
+#endif
diff --git a/Detectors/TPC/calibration/src/NeuralNetworkClusterizer.cxx b/Detectors/TPC/calibration/src/NeuralNetworkClusterizer.cxx
new file mode 100644
index 0000000000000..bfbb7afc946f8
--- /dev/null
+++ b/Detectors/TPC/calibration/src/NeuralNetworkClusterizer.cxx
@@ -0,0 +1,48 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   NeuralNetworkClusterizer.cxx
+/// \brief  Fetching neural networks for clusterization from CCDB
+/// \author Christian Sonnabend
+
+#include <CommonUtils/StringUtils.h>
+#include "TPCCalibration/NeuralNetworkClusterizer.h"
+
+using namespace o2::tpc;
+
+void NeuralNetworkClusterizer::initCcdbApi(std::string url)
+{
+  ccdbApi.init(url);
+}
+
+void NeuralNetworkClusterizer::loadIndividualFromCCDB(std::map<std::string, std::string> settings)
+{
+  metadata["inputDType"] = settings["inputDType"];
+  metadata["outputDType"] = settings["outputDType"];
+  metadata["nnCCDBEvalType"] = settings["nnCCDBEvalType"];         // classification_1C, classification_2C, regression_1C, regression_2C
+  metadata["nnCCDBWithMomentum"] = settings["nnCCDBWithMomentum"]; // 0, 1 -> Only for regression model
+  metadata["nnCCDBLayerType"] = settings["nnCCDBLayerType"];       // FC, CNN
+  if (settings["nnCCDBInteractionRate"] != "" && std::stoi(settings["nnCCDBInteractionRate"]) > 0) {
+    metadata["nnCCDBInteractionRate"] = settings["nnCCDBInteractionRate"];
+  }
+  if (settings["nnCCDBBeamType"] != "") {
+    metadata["nnCCDBBeamType"] = settings["nnCCDBBeamType"];
+  }
+
+  bool retrieveSuccess = ccdbApi.retrieveBlob(settings["nnCCDBPath"], settings["outputFolder"], metadata, 1, false, settings["outputFile"]);
+  // headers = ccdbApi.retrieveHeaders(settings["nnPathCCDB"], metadata, 1); // potentially needed to init some local variables
+
+  if (retrieveSuccess) {
+    LOG(info) << "Network " << settings["nnCCDBPath"] << " retrieved from CCDB, stored at " << settings["outputFile"];
+  } else {
+    LOG(error) << "Failed to retrieve network from CCDB";
+  }
+}
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index dfd6176827484..b37bf2b75f01c 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -24,6 +24,11 @@
 #include "GPUReconstructionKernelIncludes.h"
 #include "GPUReconstructionKernels.h"
 
+namespace Ort
+{
+struct SessionOptions;
+}
+
 namespace o2::gpu
 {
 
@@ -108,6 +113,9 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
   size_t WriteToConstantMemory(size_t offset, const void* src, size_t size, int32_t stream = -1, deviceEvent* ev = nullptr) override;
   virtual size_t TransferMemoryInternal(GPUMemoryResource* res, int32_t stream, deviceEvent* ev, deviceEvent* evList, int32_t nEvents, bool toGPU, const void* src, void* dst);
 
+  // ONNX runtime
+  virtual void SetONNXGPUStream(Ort::SessionOptions&, int32_t, int32_t*) {}
+
   int32_t InitDevice() override;
   int32_t ExitDevice() override;
   int32_t GetThread();
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index e8892c4be702b..4ce8bc1b42743 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -22,6 +22,11 @@
 #include <functional>
 #include <atomic>
 
+namespace Ort
+{
+struct SessionOptions;
+}
+
 namespace o2::gpu
 {
 
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 3655eaf66055e..f595fb051db54 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -114,6 +114,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${MODULE}
     SOURCES ${SRCS}
     PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingCUDA
+    PRIVATE_LINK_LIBRARIES ONNXRuntime::ONNXRuntime
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
@@ -121,6 +122,11 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       ${CMAKE_CURRENT_SOURCE_DIR}
     TARGETVARNAME targetName)
 
+  target_compile_definitions(${targetName} PRIVATE
+    GPUCA_HAS_ONNX=1
+    $<$<BOOL:${ORT_CUDA_BUILD}>:ORT_CUDA_BUILD>
+    $<$<BOOL:${ORT_TENSORRT_BUILD}>:ORT_TENSORRT_BUILD>)
+
   install(FILES ${HDRS} DESTINATION include/GPU)
 endif()
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 3b5e257cc8000..fe2906caace80 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -37,6 +37,10 @@
 #undef GPUCA_KRNL
 #endif
 
+#ifdef GPUCA_HAS_ONNX
+#include <onnxruntime_cxx_api.h>
+#endif
+
 static constexpr size_t REQUIRE_MIN_MEMORY = 1024L * 1024 * 1024;
 static constexpr size_t REQUIRE_MEMORY_RESERVED = 512L * 1024 * 1024;
 static constexpr size_t REQUIRE_FREE_MEMORY_RESERVED_PER_SM = 40L * 1024 * 1024;
@@ -630,6 +634,28 @@ void GPUReconstructionCUDA::endGPUProfiling()
 {
   GPUChkErr(cudaProfilerStop());
 }
+
+void GPUReconstructionCUDA::SetONNXGPUStream(Ort::SessionOptions& session_options, int32_t stream, int32_t* deviceId)
+{
+#ifdef ORT_CUDA_BUILD
+  cudaGetDevice(deviceId);
+  OrtCUDAProviderOptionsV2* cuda_options = nullptr;
+  CreateCUDAProviderOptions(&cuda_options);
+
+  // std::vector<const char*> keys{"device_id", "gpu_mem_limit", "arena_extend_strategy", "cudnn_conv_algo_search", "do_copy_in_default_stream", "cudnn_conv_use_max_workspace", "cudnn_conv1d_pad_to_nc1d"};
+  // std::vector<const char*> values{"0", "2147483648", "kSameAsRequested", "DEFAULT", "1", "1", "1"};
+  // UpdateCUDAProviderOptions(cuda_options, keys.data(), values.data(), keys.size());
+
+  // this implicitly sets "has_user_compute_stream"
+  cuda_options.has_user_compute_stream = 1;
+  UpdateCUDAProviderOptionsWithValue(cuda_options, "user_compute_stream", mInternals->Streams[stream]);
+  session_options.AppendExecutionProvider_CUDA_V2(cuda_options);
+
+  // Finally, don't forget to release the provider options
+  ReleaseCUDAProviderOptions(cuda_options);
+#endif // ORT_CUDA_BUILD
+}
+
 #else  // HIP
 void* GPUReconstructionHIP::getGPUPointer(void* ptr)
 {
@@ -637,6 +663,22 @@ void* GPUReconstructionHIP::getGPUPointer(void* ptr)
   GPUChkErr(hipHostGetDevicePointer(&retVal, ptr, 0));
   return retVal;
 }
+
+void GPUReconstructionHIP::SetONNXGPUStream(Ort::SessionOptions& session_options, int32_t stream, int32_t* deviceId)
+{
+#ifdef ORT_ROCM_BUILD
+  // Create ROCm provider options
+  cudaGetDevice(deviceId);
+  // const auto& api = Ort::GetApi();
+  // api.GetCurrentGpuDeviceId(deviceId);
+  OrtROCMProviderOptions rocm_options;
+  rocm_options.has_user_compute_stream = 1; // Indicate that we are passing a user stream
+  rocm_options.arena_extend_strategy = 0;   // kNextPowerOfTwo = 0, kSameAsRequested = 1 -> https://github.com/search?q=repo%3Amicrosoft%2Fonnxruntime%20kSameAsRequested&type=code
+  // rocm_options.gpu_mem_limit = 1073741824; // 0 means no limit
+  rocm_options.user_compute_stream = mInternals->Streams[stream];
+  session_options.AppendExecutionProvider_ROCM(rocm_options);
+#endif // ORT_ROCM_BUILD
+}
 #endif // __HIPCC__
 
 namespace o2::gpu
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 106168ef961a5..2fc4d14bba491 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -25,6 +25,11 @@ extern "C" __declspec(dllexport) o2::gpu::GPUReconstruction* GPUReconstruction_C
 extern "C" o2::gpu::GPUReconstruction* GPUReconstruction_Create_CUDA(const o2::gpu::GPUSettingsDeviceBackend& cfg);
 #endif
 
+namespace Ort
+{
+struct SessionOptions;
+}
+
 namespace o2::gpu
 {
 struct GPUReconstructionCUDAInternals;
@@ -74,6 +79,7 @@ class GPUReconstructionCUDA : public GPUReconstructionKernels<GPUReconstructionC
   size_t GPUMemCpy(void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev = nullptr, deviceEvent* evList = nullptr, int32_t nEvents = 1) override;
   void ReleaseEvent(deviceEvent ev) override;
   void RecordMarker(deviceEvent* ev, int32_t stream) override;
+  void SetONNXGPUStream(Ort::SessionOptions& session_options, int32_t stream, int32_t* deviceId) override;
 
   void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame>* timeFrame) override;
 
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 3a03a054d4a7e..d7adb222d547b 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -162,6 +162,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${MODULE}
     SOURCES ${SRCS}
     PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingHIP
+    PRIVATE_LINK_LIBRARIES ONNXRuntime::ONNXRuntime
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
@@ -169,6 +170,11 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       ${GPUCA_HIP_SOURCE_DIR}
     TARGETVARNAME targetName)
 
+  target_compile_definitions(${targetName} PRIVATE
+    GPUCA_HAS_ONNX=1
+    $<$<BOOL:${ORT_ROCM_BUILD}>:ORT_ROCM_BUILD>
+    $<$<BOOL:${ORT_MIGRAPHX_BUILD}>:ORT_MIGRAPHX_BUILD>)
+
   install(FILES ${HDRS} DESTINATION include/GPU)
 
 #  o2_add_test(GPUsortHIP NAME test_GPUsortHIP
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index eaeec508ff27a..e82799b9e59c3 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -341,6 +341,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                                        O2::DetectorsRaw
                                        O2::Steer
                                        O2::ML
+                 PRIVATE_LINK_LIBRARIES ONNXRuntime::ONNXRuntime
                  PUBLIC_INCLUDE_DIRECTORIES ${INCDIRS}
                  SOURCES ${SRCS} ${SRCS_NO_CINT} ${SRCS_NO_H})
 
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 19301ef2bef9f..a56fb97771fe5 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -492,6 +492,7 @@
 
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNSingleElement GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 6858889f9a603..1106f96ed1cb2 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -248,7 +248,8 @@ AddOption(applyNNclusterizer, int, 0, "", 0, "(bool, default = 0), if the neural
 AddOption(nnInferenceDevice, std::string, "CPU", "", 0, "(std::string) Specify inference device (cpu (default), rocm, cuda)")
 AddOption(nnInferenceDeviceId, unsigned int, 0, "", 0, "(unsigned int) Specify inference device id")
 AddOption(nnInferenceAllocateDevMem, int, 0, "", 0, "(bool, default = 0), if the device memory should be allocated for inference")
-AddOption(nnInferenceDtype, std::string, "fp32", "", 0, "(std::string) Specify the datatype for which inference is performed (fp32: default, fp16)") // fp32 or fp16
+AddOption(nnInferenceInputDType, std::string, "FP32", "", 0, "(std::string) Specify the datatype for which inference is performed (FP32: default, fp16)") // fp32 or fp16
+AddOption(nnInferenceOutputDType, std::string, "FP32", "", 0, "(std::string) Specify the datatype for which inference is performed (fp32: default, fp16)") // fp32 or fp16
 AddOption(nnInferenceIntraOpNumThreads, int, 1, "", 0, "Number of threads used to evaluate one neural network (ONNX: SetIntraOpNumThreads). 0 = auto-detect, can lead to problems on SLURM systems.")
 AddOption(nnInferenceInterOpNumThreads, int, 1, "", 0, "Number of threads used to evaluate one neural network (ONNX: SetInterOpNumThreads). 0 = auto-detect, can lead to problems on SLURM systems.")
 AddOption(nnInferenceEnableOrtOptimization, unsigned int, 99, "", 0, "Enables graph optimizations in ONNX Runtime. Can be [0, 1, 2, 99] -> see https://github.com/microsoft/onnxruntime/blob/3f71d637a83dc3540753a8bb06740f67e926dc13/include/onnxruntime/core/session/onnxruntime_c_api.h#L347")
@@ -269,6 +270,17 @@ AddOption(nnClassificationPath, std::string, "network_class.onnx", "", 0, "The c
 AddOption(nnClassThreshold, float, 0.5, "", 0, "The cutoff at which clusters will be accepted / rejected.")
 AddOption(nnRegressionPath, std::string, "network_reg.onnx", "", 0, "The regression network path")
 AddOption(nnSigmoidTrafoClassThreshold, int, 1, "", 0, "If true (default), then the classification threshold is transformed by an inverse sigmoid function. This depends on how the network was trained (with a sigmoid as acitvation function in the last layer or not).")
+AddOption(nnEvalMode, std::string, "c1:r1", "", 0, "Concatention of modes, e.g. c1:r1 (classification class 1, regression class 1)")
+// CCDB
+AddOption(nnLoadFromCCDB, int, 1, "", 0, "If 1 networks are fetched from ccdb, else locally")
+AddOption(nnLocalFolder, std::string, ".", "", 0, "Local folder in which the networks will be fetched")
+AddOption(nnCCDBURL, std::string, "http://ccdb-test.cern.ch:8080", "", 0, "The CCDB URL from where the network files are fetched")
+AddOption(nnCCDBPath, std::string, "Users/c/csonnabe/TPC/Clusterization", "", 0, "Folder path containing the networks")
+AddOption(nnCCDBWithMomentum, int, 1, "", 0, "Distinguishes between the network with and without momentum output for the regression")
+AddOption(nnCCDBClassificationLayerType, std::string, "FC", "", 0, "Distinguishes between network with different layer types. Options: FC, CNN")
+AddOption(nnCCDBRegressionLayerType, std::string, "CNN", "", 0, "Distinguishes between network with different layer types. Options: FC, CNN")
+AddOption(nnCCDBBeamType, std::string, "PbPb", "", 0, "Distinguishes between networks trained for different beam types. Options: PbPb, pp")
+AddOption(nnCCDBInteractionRate, int, 50, "", 0, "Distinguishes between networks for different interaction rates [kHz].")
 AddHelp("help", 'h')
 EndConfig()
 
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index c4dccb091fc95..1e99e3b73736f 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -83,6 +83,7 @@ class GPUChain
   inline GPUParam& param() { return mRec->param(); }
   inline const GPUConstantMem* processors() const { return mRec->processors(); }
   inline void SynchronizeStream(int32_t stream) { mRec->SynchronizeStream(stream); }
+  inline void SetONNXGPUStream(Ort::SessionOptions& opt, int32_t stream, int32_t* deviceId) { mRec->SetONNXGPUStream(opt, stream, deviceId); }
   inline void SynchronizeEvents(deviceEvent* evList, int32_t nEvents = 1) { mRec->SynchronizeEvents(evList, nEvents); }
   inline void SynchronizeEventAndRelease(deviceEvent& ev, bool doGPU = true)
   {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 4047dcae0a6b3..7db0ba66305e9 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -611,49 +611,89 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     RunTPCClusterizer_prepare(true); // Restore some pointers, allocated by the other pipeline, and set to 0 by SetupGPUProcessor (since not allocated in this pipeline)
   }
 
+  if (doGPU && mIOPtrs.tpcZS) {
+    processorsShadow()->ioPtrs.tpcZS = mInputsShadow->mPzsMeta;
+    WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->ioPtrs - (char*)processors(), &processorsShadow()->ioPtrs, sizeof(processorsShadow()->ioPtrs), mRec->NStreams() - 1);
+  }
+  if (doGPU) {
+    WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)processors()->tpcClusterer - (char*)processors(), processorsShadow()->tpcClusterer, sizeof(GPUTPCClusterFinder) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);
+  }
+
 #ifdef GPUCA_HAS_ONNX
+  const GPUSettingsProcessingNNclusterizer& nn_settings = GetProcessingSettings().nn;
+  GPUTPCNNClusterizerHost nnApplications[GetProcessingSettings().nTPCClustererLanes];
+
   if (GetProcessingSettings().nn.applyNNclusterizer) {
-    uint32_t maxClusters = -1;
-    for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
-      maxClusters = std::max(maxClusters, processors()->tpcClusterer[iSector].mNMaxClusters);
-    }
-    for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
-      GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[iSector];
-      const GPUSettingsProcessingNNclusterizer& nn_settings = GetProcessingSettings().nn;
-      clustererNN.nnClusterizerUseCfRegression = nn_settings.nnClusterizerUseCfRegression;
-      clustererNN.nnClusterizerSizeInputRow = nn_settings.nnClusterizerSizeInputRow;
-      clustererNN.nnClusterizerSizeInputPad = nn_settings.nnClusterizerSizeInputPad;
-      clustererNN.nnClusterizerSizeInputTime = nn_settings.nnClusterizerSizeInputTime;
-      clustererNN.nnClusterizerAddIndexData = nn_settings.nnClusterizerAddIndexData;
-      clustererNN.nnClusterizerElementSize = ((2 * nn_settings.nnClusterizerSizeInputRow + 1) * (2 * nn_settings.nnClusterizerSizeInputPad + 1) * (2 * nn_settings.nnClusterizerSizeInputTime + 1)) + (nn_settings.nnClusterizerAddIndexData ? 3 : 0);
-      clustererNN.nnClusterizerBatchedMode = nn_settings.nnClusterizerBatchedMode;
-      clustererNN.nnClusterizerBoundaryFillValue = nn_settings.nnClusterizerBoundaryFillValue;
-      clustererNN.nnClusterizerTotalClusters = maxClusters;
-      clustererNN.nnClassThreshold = nn_settings.nnClassThreshold;
-      clustererNN.nnSigmoidTrafoClassThreshold = nn_settings.nnSigmoidTrafoClassThreshold;
-      if (clustererNN.nnSigmoidTrafoClassThreshold) {
-        clustererNN.nnClassThreshold = (float)std::log(clustererNN.nnClassThreshold / (1.f - clustererNN.nnClassThreshold));
+    int32_t deviceId = -1;
+    int32_t numLanes = GetProcessingSettings().nTPCClustererLanes;
+    int32_t maxThreads = mRec->getNKernelHostThreads(true);
+    // bool recreateMemoryAllocator = false;
+    mRec->runParallelOuterLoop(doGPU, numLanes, [&](uint32_t lane) {
+      nnApplications[lane].init(nn_settings);
+      if (nnApplications[lane].modelsUsed[0]) {
+        SetONNXGPUStream(*(nnApplications[lane].model_class).getSessionOptions(), lane, &deviceId);
+        (nnApplications[lane].model_class).setDeviceId(deviceId);
+        if (nnApplications[lane].model_class.getIntraOpNumThreads() > maxThreads) {
+          nnApplications[lane].model_class.setIntraOpNumThreads(maxThreads);
+        }
+        (nnApplications[lane].model_class).initEnvironment();
+        // Registering this once seems to be enough, even with different environmnents / models. ONNX apparently uses this per device and stores the OrtAllocator internally. All models will then use the volatile allocation.
+        // But environment must be valid, so we init the model environment first and use it here afterwards.
+        // Either this is done in one environment with lane == 0 or by recreating the allocator using recreateMemoryAllocator.
+        // TODO: Volatile allocation works for reserving, but not yet for allocations when binding the input tensor
+        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].model_class).getEnv(), (nnApplications[lane].model_class).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        // recreateMemoryAllocator = true;
+        (nnApplications[lane].model_class).initSession();
       }
-      if (nn_settings.nnClusterizerVerbosity < 0) {
-        clustererNN.nnClusterizerVerbosity = nn_settings.nnInferenceVerbosity;
-      } else {
-        clustererNN.nnClusterizerVerbosity = nn_settings.nnClusterizerVerbosity;
+      if (nnApplications[lane].modelsUsed[1]) {
+        SetONNXGPUStream(*(nnApplications[lane].model_reg_1).getSessionOptions(), lane, &deviceId);
+        (nnApplications[lane].model_reg_1).setDeviceId(deviceId);
+        if (nnApplications[lane].model_reg_1.getIntraOpNumThreads() > maxThreads) {
+          nnApplications[lane].model_reg_1.setIntraOpNumThreads(maxThreads);
+        }
+        // (nnApplications[lane].model_reg_1).setEnv((nnApplications[lane].model_class).getEnv());
+        (nnApplications[lane].model_reg_1).initEnvironment();
+        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].model_reg_1).getEnv(), (nnApplications[lane].model_reg_1).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        (nnApplications[lane].model_reg_1).initSession();
+      }
+      if (nnApplications[lane].modelsUsed[2]) {
+        SetONNXGPUStream(*(nnApplications[lane].model_reg_2).getSessionOptions(), lane, &deviceId);
+        (nnApplications[lane].model_reg_2).setDeviceId(deviceId);
+        if (nnApplications[lane].model_reg_2.getIntraOpNumThreads() > maxThreads) {
+          nnApplications[lane].model_reg_2.setIntraOpNumThreads(maxThreads);
+        }
+        (nnApplications[lane].model_reg_2).initEnvironment();
+        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].model_class).getEnv(), (nnApplications[lane].model_class).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        (nnApplications[lane].model_reg_2).initSession();
+      }
+      if (nn_settings.nnClusterizerVerbosity < 3) {
+        LOG(info) << "(ORT) Allocated ONNX stream for lane " << lane << " and device " << deviceId;
+      }
+    });
+    mRec->runParallelOuterLoop(doGPU, NSECTORS, [&](uint32_t sector) {
+      GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[sector];
+      GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[sector] : clustererNN;
+      int32_t lane = sector % numLanes;
+      clustererNN.deviceId = deviceId;
+      clustererNN.mISector = sector;
+      clustererNN.nnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
+      nnApplications[lane].initClusterizer(nn_settings, clustererNN);
+      if (doGPU) {
+        clustererNNShadow.deviceId = deviceId;
+        clustererNNShadow.mISector = sector;
+        clustererNNShadow.nnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
+        nnApplications[lane].initClusterizer(nn_settings, clustererNNShadow);
       }
-      clustererNN.nnClusterizerDtype = nn_settings.nnInferenceDtype.find("32") != std::string::npos;
-      GPUTPCNNClusterizerHost nnApplication(nn_settings, clustererNN);
       AllocateRegisteredMemory(clustererNN.mMemoryId);
+    });
+    if (doGPU) {
+      WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->tpcNNClusterer - (char*)processors(), &processorsShadow()->tpcNNClusterer, sizeof(GPUTPCNNClusterizer) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);
     }
+    LOG(info) << "Size of nnApplications[lane]: " << sizeof(nnApplications[0]) << " bytes";
+    LOG(info) << "Size of nnApplications: " << sizeof(GPUTPCNNClusterizerHost) * GetProcessingSettings().nTPCClustererLanes << " bytes";
   }
 #endif
 
-  if (doGPU && mIOPtrs.tpcZS) {
-    processorsShadow()->ioPtrs.tpcZS = mInputsShadow->mPzsMeta;
-    WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->ioPtrs - (char*)processors(), &processorsShadow()->ioPtrs, sizeof(processorsShadow()->ioPtrs), mRec->NStreams() - 1);
-  }
-  if (doGPU) {
-    WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)processors()->tpcClusterer - (char*)processors(), processorsShadow()->tpcClusterer, sizeof(GPUTPCClusterFinder) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);
-  }
-
   size_t nClsTotal = 0;
   ClusterNativeAccess* tmpNativeAccess = mClusterNativeAccess.get();
   ClusterNative* tmpNativeClusters = nullptr;
@@ -914,58 +954,122 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
         if (GetProcessingSettings().nn.applyNNclusterizer) {
 #ifdef GPUCA_HAS_ONNX
-          GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[iSector];
-          const GPUSettingsProcessingNNclusterizer& nn_settings = GetProcessingSettings().nn;
-          GPUTPCNNClusterizerHost nnApplication(nn_settings, clustererNN);
+          GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[lane];
+          GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[lane] : clustererNN;
+          GPUTPCNNClusterizerHost& nnApplication = nnApplications[lane];
+
+          int withMC = (doGPU && propagateMCLabels);
 
-          if (clustererNN.nnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
+          if (clustererNNShadow.nnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
             runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
             DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 4, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
           }
 
-          float time_clusterizer = 0, time_fill = 0;
-          for (int batch = 0; batch < std::ceil((float)clusterer.mPmemory->counters.nClusters / clustererNN.nnClusterizerBatchedMode); batch++) {
-            uint batchStart = batch * clustererNN.nnClusterizerBatchedMode;
-            size_t iSize = CAMath::Min((uint)clustererNN.nnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
+          float time_clusterizer = 0, time_fill = 0, time_networks = 0;
+          for (int batch = 0; batch < std::ceil((float)clusterer.mPmemory->counters.nClusters / clustererNNShadow.nnClusterizerBatchedMode); batch++) {
+            uint batchStart = batch * clustererNNShadow.nnClusterizerBatchedMode;
+            size_t iSize = CAMath::Min((uint)clustererNNShadow.nnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
 
             auto start0 = std::chrono::high_resolution_clock::now();
-            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNN>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Filling the data
+            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNSingleElement>({GetGrid(iSize * clustererNNShadow.nnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceInputDType, withMC, batchStart); // Filling the data
 
-            auto stop0 = std::chrono::high_resolution_clock::now();
-            auto start1 = std::chrono::high_resolution_clock::now();
-            nnApplication.networkInference(nnApplication.model_class, clustererNN, iSize, clustererNN.modelProbabilities, clustererNN.nnClusterizerDtype);
+            // auto stop0 = std::chrono::high_resolution_clock::now();
+            // auto start1 = std::chrono::high_resolution_clock::now();
+
+            // NN evaluations
+            if (clustererNNShadow.nnInferenceInputDType == 0) {
+              if (clustererNNShadow.nnInferenceOutputDType == 0) {
+                (nnApplication.model_class).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.modelProbabilities_16);
+              } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
+                (nnApplication.model_class).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.modelProbabilities_32);
+              }
+            } else if (clustererNNShadow.nnInferenceInputDType == 1) {
+              if (clustererNNShadow.nnInferenceOutputDType == 0) {
+                (nnApplication.model_class).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.modelProbabilities_16);
+              } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
+                (nnApplication.model_class).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.modelProbabilities_32);
+              }
+            }
+            if (!clustererNNShadow.nnClusterizerUseCfRegression) {
+              if (clustererNNShadow.nnInferenceInputDType == 0) {
+                if (clustererNNShadow.nnInferenceOutputDType == 0) {
+                  (nnApplication.model_reg_1).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.outputDataReg1_16);
+                } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
+                  (nnApplication.model_reg_1).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.outputDataReg1_32);
+                }
+              } else if (clustererNNShadow.nnInferenceInputDType == 1) {
+                if (clustererNNShadow.nnInferenceOutputDType == 0) {
+                  (nnApplication.model_reg_1).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.outputDataReg1_16);
+                } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
+                  (nnApplication.model_reg_1).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.outputDataReg1_32);
+                }
+              }
+              if (nnApplication.model_class.getNumOutputNodes()[0][1] > 1 && nnApplication.model_reg_2.isInitialized()) {
+                if (clustererNNShadow.nnInferenceInputDType == 0) {
+                  if (clustererNNShadow.nnInferenceOutputDType == 0) {
+                    (nnApplication.model_reg_2).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.outputDataReg2_16);
+                  } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
+                    (nnApplication.model_reg_2).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.outputDataReg2_32);
+                  }
+                } else if (clustererNNShadow.nnInferenceInputDType == 1) {
+                  if (clustererNNShadow.nnInferenceOutputDType == 0) {
+                    (nnApplication.model_reg_2).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.outputDataReg2_16);
+                  } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
+                    (nnApplication.model_reg_2).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.outputDataReg2_32);
+                  }
+                }
+              }
+            }
+
+            // auto stopNNs = std::chrono::high_resolution_clock::now();
+
+            // Publishing kernels
             if (nnApplication.model_class.getNumOutputNodes()[0][1] == 1) {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Assigning class labels
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceOutputDType, withMC, batchStart); // Assigning class labels
             } else {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass2Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Assigning class labels
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass2Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceOutputDType, withMC, batchStart); // Assigning class labels
             }
-
-            if (!clustererNN.nnClusterizerUseCfRegression) {
-              nnApplication.networkInference(nnApplication.model_reg_1, clustererNN, iSize, clustererNN.outputDataReg1, clustererNN.nnClusterizerDtype);
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass1Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Running the NN for regression class 1
-              if (nnApplication.model_class.getNumOutputNodes()[0][1] > 1 && nnApplication.reg_model_paths.size() > 1) {
-                nnApplication.networkInference(nnApplication.model_reg_2, clustererNN, iSize, clustererNN.outputDataReg2, clustererNN.nnClusterizerDtype);
-                runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, batchStart); // Running the NN for regression class 2
+            if (!clustererNNShadow.nnClusterizerUseCfRegression) {
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass1Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceOutputDType, withMC, batchStart); // Publishing class 1 regression results
+              if (nnApplication.model_class.getNumOutputNodes()[0][1] > 1 && nnApplication.model_reg_2.isInitialized()) {
+                runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceOutputDType, withMC, batchStart); // Publishing class 2 regression results
               }
             }
-            auto stop1 = std::chrono::high_resolution_clock::now();
 
-            time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
-            time_fill += std::chrono::duration_cast<std::chrono::nanoseconds>(stop0 - start0).count() / 1e9;
+            // for(int i = 0; i < iSize; ++i) {
+            //   if(clustererNNShadow.outputDataClass[i + batchStart] > 1) {
+            //     LOG(info) << "WARNING ORT: Output of  " << i + batchStart << " / " << clusterer.mPmemory->counters.nClusters << " is " << clustererNNShadow.modelProbabilities_16[i].ToFloat() << " and " << clustererNNShadow.outputDataClass[i + batchStart] << " thresh " << clustererNNShadow.nnClassThreshold << " instead of 0 or 1. Please check the model and the input data.";
+            //     // std::string input = "[";
+            //     // for(int j = 0; j < clustererNNShadow.nnClusterizerElementSize; j++){
+            //     //   input += std::to_string(clustererNNShadow.inputData_16[i * clustererNNShadow.nnClusterizerElementSize + j].ToFloat()) + ", ";
+            //     // }
+            //     // input += "]";
+            //     // LOG(info) << "Input is: " << input;
+            //   }
+            // }
+
+            // auto stop1 = std::chrono::high_resolution_clock::now();
+
+            // time_networks += std::chrono::duration_cast<std::chrono::nanoseconds>(stopNNs - start1).count() / 1e9;
+            // time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
+            // time_fill += std::chrono::duration_cast<std::chrono::nanoseconds>(stop0 - start0).count() / 1e9;
           }
-          auto start1 = std::chrono::high_resolution_clock::now();
-          if (clustererNN.nnClusterizerUseCfRegression) {
-            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNN.nnClusterizerDtype, 0, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
-          }
-          auto stop1 = std::chrono::high_resolution_clock::now();
-          time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
-          if (clustererNN.nnClusterizerVerbosity < 3) {
-            int acceptedClusters = 0;
-            for (size_t i = 0; i < clusterer.mPmemory->counters.nClusters; ++i) {
-              acceptedClusters += clustererNN.outputDataClass[i];
-            }
-            LOG(info) << "[NN CF] Apply NN (fragment " << fragment.index << ", lane: " << lane << ", sector: " << iSector << "): filling data " << time_fill << "s ; clusterizer: " << time_clusterizer << "s ; " << clusterer.mPmemory->counters.nClusters << " clusters, " << acceptedClusters << " accepted. --> " << clusterer.mPmemory->counters.nClusters / (time_fill + time_clusterizer) << " clusters/s";
+          if (clustererNNShadow.nnClusterizerUseCfRegression) {
+            // auto start1 = std::chrono::high_resolution_clock::now();
+            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceInputDType, withMC, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
+            // auto stop1 = std::chrono::high_resolution_clock::now();
+            // time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
           }
+          // if (clustererNNShadow.nnClusterizerVerbosity < 3) {
+          //   int acceptedClusters = 0;
+          //   for (size_t i = 0; i < clusterer.mPmemory->counters.nClusters; ++i) {
+          //     if(clustererNNShadow.outputDataClass[i] > 1 || clustererNNShadow.outputDataClass[i] < 0) {
+          //       LOG(info) << "WARNING ORT 2: " << clustererNNShadow.outputDataClass[i] << " for index " << i << " / " << clusterer.mPmemory->counters.nClusters;
+          //     }
+          //     acceptedClusters += clustererNNShadow.outputDataClass[i];
+          //   }
+          //   LOG(info) << "[NN CF] Apply NN (fragment " << fragment.index << ", lane: " << lane << ", sector: " << iSector << "): filling data " << time_fill << "s ; networks: " << time_networks << "s ; clusterizer: " << time_clusterizer << "s ; " << clusterer.mPmemory->counters.nClusters << " clusters, " << acceptedClusters << " accepted. --> " << (int32_t)clusterer.mPmemory->counters.nClusters / (time_fill + time_clusterizer) << " clusters/s";
+          // }
 #else
           GPUFatal("Project not compiled with neural network clusterization. Aborting.");
 #endif
@@ -1066,6 +1170,12 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     }
   }
   for (int32_t i = 0; i < GetProcessingSettings().nTPCClustererLanes; i++) {
+    // if (GetProcessingSettings().nn.applyNNclusterizer) {
+    //   GPUTPCNNClusterizerHost& nnApplication = nnApplications[i];
+    //   nnApplication.model_class.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
+    //   nnApplication.model_reg_1.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
+    //   nnApplication.model_reg_2.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
+    // }
     if (transferRunning[i]) {
       ReleaseEvent(mEvents->stream[i], doGPU);
     }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
index 6a9b6f546ae07..fe3202fe7b439 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
@@ -24,29 +24,73 @@ void GPUTPCNNClusterizer::SetMaxData(const GPUTrackingInOutPointers& io) {}
 
 void* GPUTPCNNClusterizer::setIOPointers(void* mem)
 {
-  if (nnClusterizerDtype == 0 && nnClusterizerElementSize > 0) {
-    computePointerWithAlignment(mem, inputData16, nnClusterizerBatchedMode * nnClusterizerElementSize);
-  } else if (nnClusterizerDtype == 1 && nnClusterizerElementSize > 0) {
-    computePointerWithAlignment(mem, inputData32, nnClusterizerBatchedMode * nnClusterizerElementSize);
-  }
-  computePointerWithAlignment(mem, peakPositions, nnClusterizerBatchedMode);
-  computePointerWithAlignment(mem, clusterFlags, 2 * nnClusterizerBatchedMode);
-  computePointerWithAlignment(mem, centralCharges, nnClusterizerBatchedMode);
-  computePointerWithAlignment(mem, outputDataClass, nnClusterizerTotalClusters);
-  if (nnClusterizerModelClassNumOutputNodes > 0) {
-    computePointerWithAlignment(mem, modelProbabilities, nnClusterizerBatchedMode * nnClusterizerModelClassNumOutputNodes);
-  }
-  if (!nnClusterizerUseCfRegression) {
-    if (nnClusterizerModelReg1NumOutputNodes > 0) {
-      computePointerWithAlignment(mem, outputDataReg1, nnClusterizerBatchedMode * nnClusterizerModelReg1NumOutputNodes);
+  if (nnClusterizerBatchedMode > 0) {
+    if (nnInferenceInputDType == 0 && nnClusterizerElementSize > 0) {
+      computePointerWithAlignment(mem, inputData_16, nnClusterizerBatchedMode * nnClusterizerElementSize);
+    } else if (nnInferenceInputDType == 1 && nnClusterizerElementSize > 0) {
+      computePointerWithAlignment(mem, inputData_32, nnClusterizerBatchedMode * nnClusterizerElementSize);
     }
-    if (nnClusterizerModelReg2NumOutputNodes > 0) {
-      computePointerWithAlignment(mem, outputDataReg2, nnClusterizerBatchedMode * nnClusterizerModelReg2NumOutputNodes);
+    computePointerWithAlignment(mem, clusterFlags, 2 * nnClusterizerBatchedMode);
+
+    if (nnInferenceOutputDType == 0 && nnClusterizerElementSize > 0) {
+      if (nnClusterizerModelClassNumOutputNodes > 0) {
+        computePointerWithAlignment(mem, modelProbabilities_16, nnClusterizerBatchedMode * nnClusterizerModelClassNumOutputNodes);
+      }
+      if (!nnClusterizerUseCfRegression) {
+        if (nnClusterizerModelReg1NumOutputNodes > 0) {
+          computePointerWithAlignment(mem, outputDataReg1_16, nnClusterizerBatchedMode * nnClusterizerModelReg1NumOutputNodes);
+        }
+        if (nnClusterizerModelReg2NumOutputNodes > 0) {
+          computePointerWithAlignment(mem, outputDataReg2_16, nnClusterizerBatchedMode * nnClusterizerModelReg2NumOutputNodes);
+        }
+      }
+    } else if (nnInferenceOutputDType == 1 && nnClusterizerElementSize > 0) {
+      if (nnClusterizerModelClassNumOutputNodes > 0) {
+        computePointerWithAlignment(mem, modelProbabilities_32, nnClusterizerBatchedMode * nnClusterizerModelClassNumOutputNodes);
+      }
+      if (!nnClusterizerUseCfRegression) {
+        if (nnClusterizerModelReg1NumOutputNodes > 0) {
+          computePointerWithAlignment(mem, outputDataReg1_32, nnClusterizerBatchedMode * nnClusterizerModelReg1NumOutputNodes);
+        }
+        if (nnClusterizerModelReg2NumOutputNodes > 0) {
+          computePointerWithAlignment(mem, outputDataReg2_32, nnClusterizerBatchedMode * nnClusterizerModelReg2NumOutputNodes);
+        }
+      }
     }
   }
+  if (nnClusterizerTotalClusters > 0) {
+    computePointerWithAlignment(mem, outputDataClass, nnClusterizerTotalClusters);
+  }
   return mem;
 }
 
+// std::vector<int32_t> GPUTPCNNClusterizer::pointerSizes() {
+//   std::vector<int32_t> sizes(7, -1);
+//   if (nnClusterizerBatchedMode > 0) {
+//     if (nnInferenceInputDType == 0 && nnClusterizerElementSize > 0) {
+//       sizes[0] = nnClusterizerBatchedMode * nnClusterizerElementSize; // inputData16
+//     } else if (nnInferenceInputDType == 1 && nnClusterizerElementSize > 0) {
+//       sizes[1] = nnClusterizerBatchedMode * nnClusterizerElementSize; // inputData32
+//     }
+//     sizes[2] = 2 * nnClusterizerBatchedMode; // clusterFlags
+//     if (nnClusterizerModelClassNumOutputNodes > 0) {
+//       sizes[3] = nnClusterizerBatchedMode * nnClusterizerModelClassNumOutputNodes; // modelProbabilities
+//     }
+//     if (!nnClusterizerUseCfRegression) {
+//       if (nnClusterizerModelReg1NumOutputNodes > 0) {
+//         sizes[4] = nnClusterizerBatchedMode * nnClusterizerModelReg1NumOutputNodes; // outputDataReg1
+//       }
+//       if (nnClusterizerModelReg2NumOutputNodes > 0) {
+//         sizes[5] = nnClusterizerBatchedMode * nnClusterizerModelReg2NumOutputNodes; // outputDataReg2
+//       }
+//     }
+//   }
+//   if (nnClusterizerTotalClusters > 0) {
+//     sizes[6] = nnClusterizerTotalClusters; // outputDataClass
+//   }
+//   return sizes;
+// }
+
 void GPUTPCNNClusterizer::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index ea6340dfd48bc..da490b0f94d58 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -42,33 +42,38 @@ class GPUTPCNNClusterizer : public GPUProcessor
   int nnClusterizerSizeInputTime = 3;
   int nnClusterizerElementSize = -1;
   bool nnClusterizerAddIndexData = true;
-  float nnClassThreshold = 0.16;
+  float nnClassThreshold = 0.01;
   bool nnSigmoidTrafoClassThreshold = 1;
   int nnClusterizerUseCfRegression = 0;
   int nnClusterizerBatchedMode = 1;
   int nnClusterizerTotalClusters = 1;
   int nnClusterizerVerbosity = 0;
   int nnClusterizerBoundaryFillValue = -1;
-  int nnClusterizerDumpDigits = 0;
-  int nnClusterizerApplyCfDeconvolution = 0;
   int nnClusterizerModelClassNumOutputNodes = -1;
   int nnClusterizerModelReg1NumOutputNodes = -1;
   int nnClusterizerModelReg2NumOutputNodes = -1;
-  int nnClusterizerDtype = 0; // 0: float16, 1: float32
+  int nnInferenceInputDType = 0;  // 0: float16, 1: float32
+  int nnInferenceOutputDType = 0; // 0: float16, 1: float32
   int mISector = -1;
+  int deviceId = -1;
 
   // Memory allocation for neural network
-  uint class2_elements = 0;
-  float* inputData32 = nullptr;
-  OrtDataType::Float16_t* inputData16 = nullptr;
-  float* outputDataClass = nullptr;
-  float* modelProbabilities = nullptr;
-  float* outputDataReg1 = nullptr;
-  float* outputDataReg2 = nullptr;
 
-  ChargePos* peakPositions = nullptr;
-  bool* clusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptrx
-  float* centralCharges = nullptr;
+  bool* clusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptr
+  int* outputDataClass = nullptr;
+
+  // FP32
+  float* inputData_32 = nullptr;
+  float* modelProbabilities_32 = nullptr;
+  float* outputDataReg1_32 = nullptr;
+  float* outputDataReg2_32 = nullptr;
+
+  // FP16
+  OrtDataType::Float16_t* inputData_16 = nullptr;
+  OrtDataType::Float16_t* modelProbabilities_16 = nullptr;
+  OrtDataType::Float16_t* outputDataReg1_16 = nullptr;
+  OrtDataType::Float16_t* outputDataReg2_16 = nullptr;
+
   int16_t mMemoryId = -1;
 }; // class GPUTPCNNClusterizer
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index 5002c63524020..db2f05711f537 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -12,54 +12,205 @@
 /// \file GPUTPCNNClusterizerHost.cxx
 /// \author Christian Sonnabend
 
+#include <CommonUtils/StringUtils.h>
+
 #include "GPUTPCNNClusterizerHost.h"
 #include "GPUTPCNNClusterizer.h"
 #include "GPUSettings.h"
 #include "ML/3rdparty/GPUORTFloat16.h"
+#include "GPUReconstruction.h"
+
+#ifdef GPUCA_HAS_ONNX
+#include <onnxruntime_cxx_api.h>
+#endif
 
 using namespace o2::gpu;
 
-GPUTPCNNClusterizerHost::GPUTPCNNClusterizerHost(const GPUSettingsProcessingNNclusterizer& settings, GPUTPCNNClusterizer& clusterer)
+void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& settings)
 {
+  std::string class_model_path = settings.nnClassificationPath, reg_model_path = settings.nnRegressionPath;
+  std::vector<std::string> reg_model_paths;
+  std::vector<std::string> evalMode = o2::utils::Str::tokenize(settings.nnEvalMode, ':');
+
+  if (settings.nnLoadFromCCDB) {
+    reg_model_path = settings.nnLocalFolder + "/net_regression_c1.onnx"; // Needs to be set identical to NeuralNetworkClusterizer.cxx, otherwise the networks might be loaded from the wrong place
+    if (evalMode[0] == "c1") {
+      class_model_path = settings.nnLocalFolder + "/net_classification_c1.onnx";
+    } else if (evalMode[0] == "c2") {
+      class_model_path = settings.nnLocalFolder + "/net_classification_c2.onnx";
+    }
+
+    if (evalMode[1] == "r2") {
+      reg_model_path += ":" + settings.nnLocalFolder + "/net_regression_c2.onnx";
+    }
+  }
+
   OrtOptions = {
-    {"model-path", settings.nnClassificationPath},
-    {"device", settings.nnInferenceDevice},
-    {"device-id", std::to_string(settings.nnInferenceDeviceId)},
+    {"model-path", class_model_path},
+    {"device-type", settings.nnInferenceDevice},
     {"allocate-device-memory", std::to_string(settings.nnInferenceAllocateDevMem)},
-    {"dtype", settings.nnInferenceDtype},
     {"intra-op-num-threads", std::to_string(settings.nnInferenceIntraOpNumThreads)},
     {"inter-op-num-threads", std::to_string(settings.nnInferenceInterOpNumThreads)},
     {"enable-optimizations", std::to_string(settings.nnInferenceEnableOrtOptimization)},
     {"enable-profiling", std::to_string(settings.nnInferenceOrtProfiling)},
     {"profiling-output-path", settings.nnInferenceOrtProfilingPath},
-    {"logging-level", std::to_string(settings.nnInferenceVerbosity)}};
+    {"logging-level", std::to_string(settings.nnInferenceVerbosity)},
+    {"onnx-environment-name", "c1"}};
 
-  model_class.init(OrtOptions);
-  clusterer.nnClusterizerModelClassNumOutputNodes = model_class.getNumOutputNodes()[0][1];
+  model_class.initOptions(OrtOptions);
+  modelsUsed[0] = true;
 
-  reg_model_paths = splitString(settings.nnRegressionPath, ":");
+  reg_model_paths = o2::utils::Str::tokenize(reg_model_path, ':');
 
   if (!settings.nnClusterizerUseCfRegression) {
-    if (model_class.getNumOutputNodes()[0][1] == 1 || reg_model_paths.size() == 1) {
+    if (reg_model_paths.size() == 1) {
       OrtOptions["model-path"] = reg_model_paths[0];
-      model_reg_1.init(OrtOptions);
-      clusterer.nnClusterizerModelReg1NumOutputNodes = model_reg_1.getNumOutputNodes()[0][1];
+      OrtOptions["onnx-environment-name"] = "r1";
+      model_reg_1.initOptions(OrtOptions);
+      modelsUsed[1] = true;
     } else {
       OrtOptions["model-path"] = reg_model_paths[0];
-      model_reg_1.init(OrtOptions);
-      clusterer.nnClusterizerModelReg1NumOutputNodes = model_reg_1.getNumOutputNodes()[0][1];
+      OrtOptions["onnx-environment-name"] = "r1";
+      model_reg_1.initOptions(OrtOptions);
+      modelsUsed[1] = true;
       OrtOptions["model-path"] = reg_model_paths[1];
-      model_reg_2.init(OrtOptions);
-      clusterer.nnClusterizerModelReg2NumOutputNodes = model_reg_2.getNumOutputNodes()[0][1];
+      OrtOptions["onnx-environment-name"] = "r2";
+      model_reg_2.initOptions(OrtOptions);
+      modelsUsed[2] = true;
     }
   }
 }
 
-void GPUTPCNNClusterizerHost::networkInference(o2::ml::OrtModel model, GPUTPCNNClusterizer& clusterer, size_t size, float* output, int32_t dtype)
+void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclusterizer& settings, GPUTPCNNClusterizer& clustererNN)
 {
-  if (dtype == 0) {
-    model.inference<OrtDataType::Float16_t, float>(clusterer.inputData16, size * clusterer.nnClusterizerElementSize, output);
+  clustererNN.nnClusterizerUseCfRegression = settings.nnClusterizerUseCfRegression;
+  clustererNN.nnClusterizerSizeInputRow = settings.nnClusterizerSizeInputRow;
+  clustererNN.nnClusterizerSizeInputPad = settings.nnClusterizerSizeInputPad;
+  clustererNN.nnClusterizerSizeInputTime = settings.nnClusterizerSizeInputTime;
+  clustererNN.nnClusterizerAddIndexData = settings.nnClusterizerAddIndexData;
+  clustererNN.nnClusterizerElementSize = ((2 * settings.nnClusterizerSizeInputRow + 1) * (2 * settings.nnClusterizerSizeInputPad + 1) * (2 * settings.nnClusterizerSizeInputTime + 1)) + (settings.nnClusterizerAddIndexData ? 3 : 0);
+  clustererNN.nnClusterizerBatchedMode = settings.nnClusterizerBatchedMode;
+  clustererNN.nnClusterizerBoundaryFillValue = settings.nnClusterizerBoundaryFillValue;
+  clustererNN.nnSigmoidTrafoClassThreshold = settings.nnSigmoidTrafoClassThreshold;
+  if (clustererNN.nnSigmoidTrafoClassThreshold) {
+    clustererNN.nnClassThreshold = (float)std::log(settings.nnClassThreshold / (1.f - settings.nnClassThreshold));
+  } else {
+    clustererNN.nnClassThreshold = settings.nnClassThreshold;
+  }
+  if (settings.nnClusterizerVerbosity < 0) {
+    clustererNN.nnClusterizerVerbosity = settings.nnInferenceVerbosity;
   } else {
-    model.inference<float, float>(clusterer.inputData32, size * clusterer.nnClusterizerElementSize, output);
+    clustererNN.nnClusterizerVerbosity = settings.nnClusterizerVerbosity;
+  }
+  clustererNN.nnInferenceInputDType = settings.nnInferenceInputDType.find("32") != std::string::npos;
+  clustererNN.nnInferenceOutputDType = settings.nnInferenceOutputDType.find("32") != std::string::npos;
+  clustererNN.nnClusterizerModelClassNumOutputNodes = model_class.getNumOutputNodes()[0][1];
+  if (!settings.nnClusterizerUseCfRegression) {
+    if (model_class.getNumOutputNodes()[0][1] == 1 || !model_reg_2.isInitialized()) {
+      clustererNN.nnClusterizerModelReg1NumOutputNodes = model_reg_1.getNumOutputNodes()[0][1];
+    } else {
+      clustererNN.nnClusterizerModelReg1NumOutputNodes = model_reg_1.getNumOutputNodes()[0][1];
+      clustererNN.nnClusterizerModelReg2NumOutputNodes = model_reg_2.getNumOutputNodes()[0][1];
+    }
+  }
+}
+
+// MockedOrtAllocator implementation to be able to use volatile assignment
+struct MockedOrtAllocator : OrtAllocator {
+  MockedOrtAllocator(GPUReconstruction* = nullptr, OrtMemoryInfo* = nullptr);
+  ~MockedOrtAllocator();
+
+  void* Alloc(size_t size);
+  void Free(void* p);
+  const OrtMemoryInfo* Info() const;
+  void* Reserve(size_t size);
+  size_t NumAllocations() const;
+  size_t NumReserveAllocations() const;
+
+  void LeakCheck();
+
+ private:
+  MockedOrtAllocator(const MockedOrtAllocator&) = delete;
+  MockedOrtAllocator& operator=(const MockedOrtAllocator&) = delete;
+
+  std::atomic<size_t> memory_inuse{0};
+  std::atomic<size_t> num_allocations{0};
+  std::atomic<size_t> num_reserve_allocations{0};
+  OrtMemoryInfo* memory_info;
+  GPUReconstruction* rec;
+};
+
+MockedOrtAllocator::MockedOrtAllocator(GPUReconstruction* r, OrtMemoryInfo* info)
+{
+  OrtAllocator::version = ORT_API_VERSION;
+  OrtAllocator::Alloc = [](OrtAllocator* this_, size_t size) { return static_cast<MockedOrtAllocator*>(this_)->Alloc(size); };
+  OrtAllocator::Free = [](OrtAllocator* this_, void* p) { static_cast<MockedOrtAllocator*>(this_)->Free(p); };
+  OrtAllocator::Info = [](const OrtAllocator* this_) { return static_cast<const MockedOrtAllocator*>(this_)->Info(); };
+  OrtAllocator::Reserve = [](OrtAllocator* this_, size_t size) { return static_cast<MockedOrtAllocator*>(this_)->Reserve(size); };
+  rec = r;
+  memory_info = info;
+}
+
+MockedOrtAllocator::~MockedOrtAllocator()
+{
+  // Ort::GetApi().ReleaseMemoryInfo(memory_info);
+}
+
+void* MockedOrtAllocator::Alloc(size_t size)
+{
+  // LOG(info) << "(ORT) Allocating volatile memory of size " << size << " bytes";
+  return rec->AllocateVolatileDeviceMemory(size);
+}
+
+void* MockedOrtAllocator::Reserve(size_t size)
+{
+  // LOG(info) << "(ORT) Reserving volatile memory of size " << size << " bytes";
+  return rec->AllocateVolatileDeviceMemory(size);
+}
+
+void MockedOrtAllocator::Free(void* p)
+{
+  // LOG(info) << "(ORT) Freeing volatile memory " << p;
+  rec->ReturnVolatileDeviceMemory();
+}
+
+const OrtMemoryInfo* MockedOrtAllocator::Info() const
+{
+  return memory_info;
+}
+
+size_t MockedOrtAllocator::NumAllocations() const
+{
+  return num_allocations.load();
+}
+
+size_t MockedOrtAllocator::NumReserveAllocations() const
+{
+  return num_reserve_allocations.load();
+}
+
+void MockedOrtAllocator::LeakCheck()
+{
+  if (memory_inuse.load())
+    LOG(warning) << "memory leak!!!";
+}
+
+void GPUTPCNNClusterizerHost::volatileOrtAllocator(Ort::Env* env, Ort::MemoryInfo* memInfo, GPUReconstruction* rec, bool recreate)
+{
+  mockedAlloc = std::make_shared<MockedOrtAllocator>(rec, (OrtMemoryInfo*)(*memInfo));
+  if (recreate) {
+    Ort::ThrowOnError(Ort::GetApi().UnregisterAllocator((OrtEnv*)(*env), (OrtMemoryInfo*)(*memInfo)));
   }
+  Ort::ThrowOnError(Ort::GetApi().RegisterAllocator((OrtEnv*)(*env), mockedAlloc.get()));
+  memInfo = (Ort::MemoryInfo*)mockedAlloc->Info();
+}
+
+const OrtMemoryInfo* GPUTPCNNClusterizerHost::getMockedMemoryInfo()
+{
+  return mockedAlloc->Info();
+}
+
+MockedOrtAllocator* GPUTPCNNClusterizerHost::getMockedAllocator()
+{
+  return mockedAlloc.get();
 }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
index 7efa0edecb893..0379b83d0ae02 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
@@ -22,6 +22,15 @@
 
 using namespace o2::ml;
 
+class OrtMemoryInfo;
+class OrtAllocator;
+struct MockedOrtAllocator;
+namespace Ort
+{
+struct Env;
+struct MemoryInfo;
+} // namespace Ort
+
 namespace o2::OrtDataType
 {
 struct Float16_t;
@@ -30,6 +39,7 @@ struct Float16_t;
 namespace o2::gpu
 {
 
+class GPUReconstruction;
 class GPUTPCNNClusterizer;
 struct GPUSettingsProcessingNNclusterizer;
 
@@ -37,30 +47,23 @@ class GPUTPCNNClusterizerHost
 {
  public:
   GPUTPCNNClusterizerHost() = default;
-  GPUTPCNNClusterizerHost(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&);
+  GPUTPCNNClusterizerHost(const GPUSettingsProcessingNNclusterizer& settings) { init(settings); }
+
+  void init(const GPUSettingsProcessingNNclusterizer&);
+  void initClusterizer(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&);
 
-  void networkInference(o2::ml::OrtModel model, GPUTPCNNClusterizer& clusterer, size_t size, float* output, int32_t dtype);
+  // ONNX
+  void volatileOrtAllocator(Ort::Env*, Ort::MemoryInfo*, GPUReconstruction*, bool = false);
+  MockedOrtAllocator* getMockedAllocator();
+  const OrtMemoryInfo* getMockedMemoryInfo();
 
   std::unordered_map<std::string, std::string> OrtOptions;
   o2::ml::OrtModel model_class, model_reg_1, model_reg_2; // For splitting clusters
+  std::vector<bool> modelsUsed = {false, false, false};   // 0: class, 1: reg_1, 2: reg_2
+  int32_t deviceId = -1;
   std::vector<std::string> reg_model_paths;
 
- private:
-  // Avoid including CommonUtils/StringUtils.h
-  std::vector<std::string> splitString(const std::string& input, const std::string& delimiter)
-  {
-    std::vector<std::string> tokens;
-    std::size_t pos = 0;
-    std::size_t found;
-
-    while ((found = input.find(delimiter, pos)) != std::string::npos) {
-      tokens.push_back(input.substr(pos, found - pos));
-      pos = found + delimiter.length();
-    }
-    tokens.push_back(input.substr(pos));
-
-    return tokens;
-  }
+  std::shared_ptr<MockedOrtAllocator> mockedAlloc = nullptr;
 }; // class GPUTPCNNClusterizerHost
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 379ea27443fea..2cf9ab2037007 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -35,7 +35,7 @@ using namespace o2::gpu::tpccf;
 
 // Defining individual thread functions for data filling, determining the class label and running the CF clusterizer
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::runCfClusterizer>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::runCfClusterizer>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint batchStart)
 {
   uint glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
@@ -45,109 +45,26 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
   }
   Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CPU_ONLY(MCLabelAccumulator labelAcc(clusterer));
-  tpc::ClusterNative* clusterOut = (onlyMC) ? nullptr : clusterer.mPclusterByRow;
+  tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
   o2::gpu::GPUTPCCFClusterizer::GPUSharedMemory smem_new;
   GPUTPCCFClusterizer::computeClustersImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, smem_new, chargeMap, clusterer.mPfilteredPeakPositions, clusterer.Param().rec, CPU_PTR(&labelAcc), clusterer.mPmemory->counters.nClusters, clusterer.mNMaxClusterPerRow, clusterer.mPclusterInRow, clusterOut, clusterer.mPclusterPosInRow);
 }
 
 template <>
 GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNN>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
-{
-  GPUTPCNNClusterizerKernels::fillInputData(nBlocks, nThreads, iBlock, iThread, processors, sector, dtype, batchStart);
-}
-
-template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass1Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
-{
-  uint glo_idx = get_global_id(0);
-  processors.tpcNNClusterer[sector].outputDataClass[glo_idx + batchStart] = (int)(processors.tpcNNClusterer[sector].modelProbabilities[glo_idx] > processors.tpcNNClusterer[sector].nnClassThreshold);
-}
-
-template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass2Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
-{
-  auto& clusterer = processors.tpcNNClusterer[sector];
-  uint glo_idx = get_global_id(0);
-  uint elem_iterator = glo_idx * clusterer.nnClusterizerModelClassNumOutputNodes;
-  float current_max_prob = 0.f; // If the neural network doesn't contain the softmax as a last layer, the outputs can range in [-infty, infty]
-  uint class_label = 0;
-  for (int pIdx = elem_iterator; pIdx < elem_iterator + clusterer.nnClusterizerModelClassNumOutputNodes; pIdx++) {
-    if (pIdx == elem_iterator) {
-      current_max_prob = clusterer.modelProbabilities[pIdx];
-    } else {
-      class_label = (clusterer.modelProbabilities[pIdx] > current_max_prob ? pIdx : class_label);
-    }
-  }
-  // uint class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clusterer.nnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
-  clusterer.outputDataClass[glo_idx + batchStart] = class_label;
-}
-
-template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass1Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
-{
-  uint glo_idx = get_global_id(0);
-  if (glo_idx >= processors.tpcClusterer[sector].mPmemory->counters.nClusters) {
-    return;
-  }
-  GPUTPCNNClusterizerKernels::publishClustersReg1(glo_idx, smem, processors, sector, dtype, onlyMC, batchStart);
-}
-
-template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass2Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
-{
-  uint glo_idx = get_global_id(0);
-  if (glo_idx >= processors.tpcClusterer[sector].mPmemory->counters.nClusters) {
-    return;
-  }
-  GPUTPCNNClusterizerKernels::publishClustersReg2(glo_idx, smem, processors, sector, dtype, onlyMC, batchStart);
-}
-
-// THe following arithmetic is done because the network is trained with a split between IROC and OROC boundary
-GPUd() int GPUTPCNNClusterizerKernels::padOffset(int row_ref, int row_current)
-{
-  return (int)((GPUTPCGeometry::NPads(row_current) - GPUTPCGeometry::NPads(row_ref)) / 2);
-}
-
-GPUd() int GPUTPCNNClusterizerKernels::rowOffset(int row, int global_shift)
-{
-  return (row > 62 ? global_shift : 0);
-}
-
-GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int row, int pad, int global_shift)
-{
-  if (pad < 0 || row < 0) { // Faster short-circuit
-    return true;
-  } else if (row < 63) {
-    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row)));
-  } else if (row < (63 + global_shift)) { // to account for the gap between IROC and OROC. Charge will be set to -1 in order to signal boundary to the neural network
-    return true;
-  } else if (row < (o2::tpc::constants::MAXGLOBALPADROW + global_shift)) {
-    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row - global_shift)));
-  } else {
-    return true;
-  }
-}
-
-// Filling the input data for the neural network where there is no boundary
-GPUd() void GPUTPCNNClusterizerKernels::fillInputData(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, processorType& processors, uint8_t sector, int8_t dtype, uint batchStart)
 {
   uint glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
-
   uint write_idx = glo_idx * clustererNN.nnClusterizerElementSize; // Potential optimization: Either choose nnClusterizerBatchedMode as a power of 2 or calculate from threadId and blockId
 
+  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   ChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
   int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad()), time = static_cast<int>(peak.time()); // Explicit casting to avoid conversion errors
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
-
-  clustererNN.peakPositions[glo_idx] = peak;
-  clustererNN.centralCharges[glo_idx] = central_charge;
-  clustererNN.outputDataClass[glo_idx + batchStart] = -1;
-
   int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.nnClusterizerSizeInputRow);
+
 #ifndef GPUCA_GPUCODE
   GPUCA_UNROLL(U(), U());
 #endif
@@ -160,20 +77,20 @@ GPUd() void GPUTPCNNClusterizerKernels::fillInputData(int32_t nBlocks, int32_t n
         if (!is_boundary) {
           ChargePos tmp_pos(row + r, pad + p, time + t);
           if (r == 0 && !clustererNN.clusterFlags[2 * glo_idx] && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) { // ordering is done for short circuit optimization
-            clustererNN.clusterFlags[2 * glo_idx] = CfUtils::isPeak(isPeakMap[tmp_pos]);
+            clustererNN.clusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
             clustererNN.clusterFlags[2 * glo_idx + 1] = clustererNN.clusterFlags[2 * glo_idx];
           }
           if (dtype == 0) {
-            clustererNN.inputData16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
-          } else {
-            clustererNN.inputData32[write_idx] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+            clustererNN.inputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
+          } else if (dtype == 1) {
+            clustererNN.inputData_32[write_idx] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
           }
         } else {
           // Filling boundary just to make sure that no values are left unintentionally
           if (dtype == 0) {
-            clustererNN.inputData16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue));
+            clustererNN.inputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue));
           } else {
-            clustererNN.inputData32[write_idx] = static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue);
+            clustererNN.inputData_32[write_idx] = static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue);
           }
         }
         write_idx++;
@@ -182,66 +99,191 @@ GPUd() void GPUTPCNNClusterizerKernels::fillInputData(int32_t nBlocks, int32_t n
   }
   if (clustererNN.nnClusterizerAddIndexData) {
     if (dtype == 0) {
-      clustererNN.inputData16[write_idx] = (OrtDataType::Float16_t)(clusterer.mISector / 36.f);
-      clustererNN.inputData16[write_idx + 1] = (OrtDataType::Float16_t)(row / 152.f);
-      clustererNN.inputData16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
+      clustererNN.inputData_16[write_idx] = (OrtDataType::Float16_t)(sector / 36.f);
+      clustererNN.inputData_16[write_idx + 1] = (OrtDataType::Float16_t)(row / 152.f);
+      clustererNN.inputData_16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
+    } else {
+      clustererNN.inputData_32[write_idx] = sector / 36.f;
+      clustererNN.inputData_32[write_idx + 1] = row / 152.f;
+      clustererNN.inputData_32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+    }
+  }
+}
+
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNSingleElement>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  uint glo_idx = get_global_id(0);
+  auto& clusterer = processors.tpcClusterer[sector];
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  uint base_idx = CAMath::Floor(glo_idx / clustererNN.nnClusterizerElementSize);
+  uint transient_index = glo_idx % clustererNN.nnClusterizerElementSize;
+
+  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+  ChargePos peak = clusterer.mPfilteredPeakPositions[base_idx + batchStart];
+  int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad());
+
+  if (clustererNN.nnClusterizerAddIndexData && transient_index == (clustererNN.nnClusterizerElementSize - 1)) {
+    uint top_idx = (base_idx + 1) * clustererNN.nnClusterizerElementSize;
+    for (uint16_t i = 0; i < 8; i++) {
+      Delta2 d = cfconsts::InnerNeighbors[i];
+      ChargePos tmp_pos = peak.delta(d);
+      clustererNN.clusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
+      clustererNN.clusterFlags[2 * glo_idx + 1] = clustererNN.clusterFlags[2 * glo_idx];
+    }
+    if (dtype == 0) {
+      clustererNN.inputData_16[top_idx - 3] = (OrtDataType::Float16_t)(sector / 36.f);
+      clustererNN.inputData_16[top_idx - 2] = (OrtDataType::Float16_t)(row / 152.f);
+      clustererNN.inputData_16[top_idx - 1] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
     } else {
-      clustererNN.inputData32[write_idx] = clusterer.mISector / 36.f;
-      clustererNN.inputData32[write_idx + 1] = row / 152.f;
-      clustererNN.inputData32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+      clustererNN.inputData_32[top_idx - 3] = sector / 36.f;
+      clustererNN.inputData_32[top_idx - 2] = row / 152.f;
+      clustererNN.inputData_32[top_idx - 1] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+    }
+  } else if (transient_index < (clustererNN.nnClusterizerElementSize - 3)) {
+    int time = static_cast<int>(peak.time());
+    int r = CAMath::Floor(transient_index / ((2 * clustererNN.nnClusterizerSizeInputPad + 1) * (2 * clustererNN.nnClusterizerSizeInputTime + 1))) - clustererNN.nnClusterizerSizeInputRow;
+    bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
+    if (is_row_boundary) {
+      if (dtype == 0) {
+        clustererNN.inputData_16[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue));
+      } else {
+        clustererNN.inputData_32[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue);
+      }
+    } else {
+      int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.nnClusterizerSizeInputRow);
+      int pad_offset = GPUTPCNNClusterizerKernels::padOffset(row, row + r);
+      int rest_1 = transient_index % ((2 * clustererNN.nnClusterizerSizeInputPad + 1) * (2 * clustererNN.nnClusterizerSizeInputTime + 1));
+      int p = CAMath::Floor(rest_1 / (2 * clustererNN.nnClusterizerSizeInputTime + 1)) - clustererNN.nnClusterizerSizeInputPad + pad_offset;
+      bool is_boundary = GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.nnClusterizerSizeInputRow);
+
+      if (!is_boundary) {
+        float central_charge = static_cast<float>(chargeMap[peak].unpack());
+        int t = (rest_1 % (2 * clustererNN.nnClusterizerSizeInputTime + 1)) - clustererNN.nnClusterizerSizeInputTime;
+        ChargePos tmp_pos(row + r, pad + p, time + t);
+        if (dtype == 0) {
+          clustererNN.inputData_16[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
+        } else if (dtype == 1) {
+          clustererNN.inputData_32[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+        }
+      } else {
+        if (dtype == 0) {
+          clustererNN.inputData_16[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue));
+        } else {
+          clustererNN.inputData_32[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue);
+        }
+      }
     }
   }
 }
 
-GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg1(uint glo_idx, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass1Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+{
+  uint glo_idx = get_global_id(0);
+  if (dtype == 0) {
+    processors.tpcNNClusterer[sector].outputDataClass[glo_idx + batchStart] = (int)((processors.tpcNNClusterer[sector].modelProbabilities_16[glo_idx]).ToFloat() > processors.tpcNNClusterer[sector].nnClassThreshold);
+  } else if (dtype == 1) {
+    processors.tpcNNClusterer[sector].outputDataClass[glo_idx + batchStart] = (int)(processors.tpcNNClusterer[sector].modelProbabilities_32[glo_idx] > processors.tpcNNClusterer[sector].nnClassThreshold);
+  }
+}
+
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass2Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
 {
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  uint glo_idx = get_global_id(0);
+  uint elem_iterator = glo_idx * clustererNN.nnClusterizerModelClassNumOutputNodes;
+  float current_max_prob = 0.f; // If the neural network doesn't contain the softmax as a last layer, the outputs can range in [-infty, infty]
+  uint class_label = 0;
+  for (int pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.nnClusterizerModelClassNumOutputNodes; pIdx++) {
+    if (pIdx == elem_iterator) {
+      if (dtype == 0) {
+        current_max_prob = static_cast<float>(clustererNN.modelProbabilities_16[pIdx]);
+      } else if (dtype == 1) {
+        current_max_prob = clustererNN.modelProbabilities_32[pIdx];
+      }
+    } else {
+      if (dtype == 0) {
+        current_max_prob = CAMath::Max(current_max_prob, clustererNN.modelProbabilities_16[pIdx].ToFloat());
+      } else if (dtype == 1) {
+        current_max_prob = CAMath::Max(current_max_prob, clustererNN.modelProbabilities_32[pIdx]);
+      }
+    }
+  }
+  // uint class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clustererNN.nnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
+  clustererNN.outputDataClass[glo_idx + batchStart] = class_label;
+  if (class_label > 1) {
+    clustererNN.clusterFlags[2 * glo_idx] = 1;
+    clustererNN.clusterFlags[2 * glo_idx + 1] = 1;
+  }
+}
+
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass1Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint batchStart)
+{
+  uint glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
+
   Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  ChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
+  float central_charge = static_cast<float>(chargeMap[peak].unpack());
+
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
-  tpc::ClusterNative* clusterOut = (onlyMC) ? nullptr : clusterer.mPclusterByRow;
+  tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
   uint full_glo_idx = glo_idx + batchStart;
   int model_output_index = glo_idx * clustererNN.nnClusterizerModelReg1NumOutputNodes;
 
   // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.nnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
 
-  if (clustererNN.outputDataClass[full_glo_idx] == 1) {
+  if (clustererNN.outputDataClass[full_glo_idx] == 1 || (clustererNN.nnClusterizerModelReg2NumOutputNodes == -1 && clustererNN.outputDataClass[full_glo_idx] >= 1)) {
 
     ClusterAccumulator pc;
 
     // Publishing logic is taken from default clusterizer
-    if (onlyMC) {
+    if (withMC) {
       ClusterAccumulator dummy_pc;
-      CPU_ONLY(labelAcc->collect(clustererNN.peakPositions[glo_idx], chargeMap[clustererNN.peakPositions[glo_idx]].unpack()));
+      CPU_ONLY(labelAcc->collect(peak, central_charge));
       GPUTPCCFClusterizer::buildCluster(
         clusterer.Param().rec,
         chargeMap,
-        clustererNN.peakPositions[glo_idx],
+        peak,
         smem.posBcast,
         smem.buf,
         smem.innerAboveThreshold,
         &dummy_pc,
         labelAcc);
     }
-
-    if ((clusterer.mPmemory->fragment).isOverlap(clustererNN.peakPositions[glo_idx].time())) {
+    if ((clusterer.mPmemory->fragment).isOverlap(peak.time())) {
       if (clusterer.mPclusterPosInRow) {
         clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
       }
       return;
     }
 
-    pc.setFull(clustererNN.centralCharges[glo_idx] * clustererNN.outputDataReg1[model_output_index + 4],
-               static_cast<float>(clustererNN.peakPositions[glo_idx].pad()) + clustererNN.outputDataReg1[model_output_index],
-               clustererNN.outputDataReg1[model_output_index + 2],
-               (clusterer.mPmemory->fragment).start + static_cast<float>(clustererNN.peakPositions[glo_idx].time()) + clustererNN.outputDataReg1[model_output_index + 1],
-               clustererNN.outputDataReg1[model_output_index + 3],
-               clustererNN.clusterFlags[2 * glo_idx],
-               clustererNN.clusterFlags[2 * glo_idx + 1]);
+    if (dtype == 0) {
+      pc.setFull(central_charge * clustererNN.outputDataReg1_16[model_output_index + 4].ToFloat(),
+                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg1_16[model_output_index].ToFloat(),
+                 clustererNN.outputDataReg1_16[model_output_index + 2].ToFloat(),
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg1_16[model_output_index + 1].ToFloat(),
+                 clustererNN.outputDataReg1_16[model_output_index + 3].ToFloat(),
+                 clustererNN.clusterFlags[2 * glo_idx],
+                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+    } else if (dtype == 1) {
+      pc.setFull(central_charge * clustererNN.outputDataReg1_32[model_output_index + 4],
+                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg1_32[model_output_index],
+                 clustererNN.outputDataReg1_32[model_output_index + 2],
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg1_32[model_output_index + 1],
+                 clustererNN.outputDataReg1_32[model_output_index + 3],
+                 clustererNN.clusterFlags[2 * glo_idx],
+                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+    }
 
     tpc::ClusterNative myCluster;
-    bool rejectCluster = !pc.toNative(clustererNN.peakPositions[glo_idx], clustererNN.centralCharges[glo_idx], myCluster, clusterer.Param(), chargeMap);
+    bool rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
     if (rejectCluster) {
       if (clusterer.mPclusterPosInRow) {
         clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
@@ -250,11 +292,11 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg1(uint glo_idx, GPUSha
     }
 
     uint rowIndex = 0;
-    if (clusterer.mPclusterByRow != nullptr) {
+    if (clusterOut != nullptr) {
       rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
         clusterer,
         myCluster,
-        clustererNN.peakPositions[glo_idx].row(),
+        peak.row(),
         clusterer.mNMaxClusterPerRow,
         clusterer.mPclusterInRow,
         clusterOut);
@@ -264,7 +306,7 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg1(uint glo_idx, GPUSha
     } else if (clusterer.mPclusterPosInRow) {
       rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
     }
-    CPU_ONLY(labelAcc->commit(clustererNN.peakPositions[glo_idx].row(), rowIndex, clusterer.mNMaxClusterPerRow));
+    CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow));
   } else {
     if (clusterer.mPclusterPosInRow) {
       clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
@@ -273,38 +315,41 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg1(uint glo_idx, GPUSha
   }
 }
 
-GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg2(uint glo_idx, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass2Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint batchStart)
 {
+  uint glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
+
   Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  ChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
+  float central_charge = static_cast<float>(chargeMap[peak].unpack());
+
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
-  tpc::ClusterNative* clusterOut = (onlyMC) ? nullptr : clusterer.mPclusterByRow;
+  tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
   uint full_glo_idx = glo_idx + batchStart;
   int model_output_index = glo_idx * clustererNN.nnClusterizerModelReg2NumOutputNodes;
 
-  // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.nnClusterizerModelReg2NumOutputNodes << " -- " << clustererNN.peakPositions.size() << " -- " << clustererNN.centralCharges.size();
-
   if (clustererNN.outputDataClass[full_glo_idx] > 0) {
 
     ClusterAccumulator pc;
 
-    if (onlyMC) {
+    if (withMC) {
       ClusterAccumulator dummy_pc;
-      CPU_ONLY(labelAcc->collect(clustererNN.peakPositions[glo_idx], chargeMap[clustererNN.peakPositions[glo_idx]].unpack()));
+      CPU_ONLY(labelAcc->collect(peak, central_charge));
       GPUTPCCFClusterizer::buildCluster(
         clusterer.Param().rec,
         chargeMap,
-        clustererNN.peakPositions[glo_idx],
+        peak,
         smem.posBcast,
         smem.buf,
         smem.innerAboveThreshold,
         &dummy_pc,
         labelAcc);
     }
-
-    if ((clusterer.mPmemory->fragment).isOverlap(clustererNN.peakPositions[glo_idx].time())) {
+    if ((clusterer.mPmemory->fragment).isOverlap(peak.time())) {
       if (clusterer.mPclusterPosInRow) {
         clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
       }
@@ -312,16 +357,26 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg2(uint glo_idx, GPUSha
     }
 
     // Cluster 1
-    pc.setFull(clustererNN.centralCharges[glo_idx] * clustererNN.outputDataReg2[model_output_index + 8],
-               static_cast<float>(clustererNN.peakPositions[glo_idx].pad()) + clustererNN.outputDataReg2[model_output_index],
-               clustererNN.outputDataReg2[model_output_index + 4],
-               (clusterer.mPmemory->fragment).start + static_cast<float>(clustererNN.peakPositions[glo_idx].time()) + clustererNN.outputDataReg2[model_output_index + 2],
-               clustererNN.outputDataReg2[model_output_index + 6],
-               clustererNN.clusterFlags[2 * glo_idx],
-               clustererNN.clusterFlags[2 * glo_idx + 1]);
+    if (dtype == 0) {
+      pc.setFull(central_charge * clustererNN.outputDataReg2_16[model_output_index + 8].ToFloat(),
+                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg2_16[model_output_index].ToFloat(),
+                 clustererNN.outputDataReg2_16[model_output_index + 4].ToFloat(),
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg2_16[model_output_index + 2].ToFloat(),
+                 clustererNN.outputDataReg2_16[model_output_index + 6].ToFloat(),
+                 clustererNN.clusterFlags[2 * glo_idx],
+                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+    } else if (dtype == 1) {
+      pc.setFull(central_charge * clustererNN.outputDataReg2_32[model_output_index + 8],
+                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg2_32[model_output_index],
+                 clustererNN.outputDataReg2_32[model_output_index + 4],
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg2_32[model_output_index + 2],
+                 clustererNN.outputDataReg2_32[model_output_index + 6],
+                 clustererNN.clusterFlags[2 * glo_idx],
+                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+    }
 
     tpc::ClusterNative myCluster;
-    bool rejectCluster = !pc.toNative(clustererNN.peakPositions[glo_idx], clustererNN.centralCharges[glo_idx], myCluster, clusterer.Param(), chargeMap);
+    bool rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
     if (rejectCluster) {
       if (clusterer.mPclusterPosInRow) {
         clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
@@ -330,11 +385,11 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg2(uint glo_idx, GPUSha
     }
 
     uint rowIndex = 0;
-    if (clusterer.mPclusterByRow != nullptr) {
+    if (clusterOut != nullptr) {
       rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
         clusterer,
         myCluster,
-        clustererNN.peakPositions[glo_idx].row(),
+        peak.row(),
         clusterer.mNMaxClusterPerRow,
         clusterer.mPclusterInRow,
         clusterOut);
@@ -344,18 +399,28 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg2(uint glo_idx, GPUSha
     } else if (clusterer.mPclusterPosInRow) {
       rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
     }
-    CPU_ONLY(labelAcc->commit(clustererNN.peakPositions[glo_idx].row(), rowIndex, clusterer.mNMaxClusterPerRow));
+    CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow));
 
     // Cluster 2
-    pc.setFull(clustererNN.centralCharges[glo_idx] * clustererNN.outputDataReg2[model_output_index + 9],
-               static_cast<float>(clustererNN.peakPositions[glo_idx].pad()) + clustererNN.outputDataReg2[model_output_index + 1],
-               clustererNN.outputDataReg2[model_output_index + 5],
-               (clusterer.mPmemory->fragment).start + static_cast<float>(clustererNN.peakPositions[glo_idx].time()) + clustererNN.outputDataReg2[model_output_index + 3],
-               clustererNN.outputDataReg2[model_output_index + 7],
-               clustererNN.clusterFlags[2 * glo_idx],
-               clustererNN.clusterFlags[2 * glo_idx + 1]);
-
-    rejectCluster = !pc.toNative(clustererNN.peakPositions[glo_idx], clustererNN.centralCharges[glo_idx], myCluster, clusterer.Param(), chargeMap);
+    if (dtype == 0) {
+      pc.setFull(central_charge * clustererNN.outputDataReg2_16[model_output_index + 9].ToFloat(),
+                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg2_16[model_output_index + 1].ToFloat(),
+                 clustererNN.outputDataReg2_16[model_output_index + 5].ToFloat(),
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg2_16[model_output_index + 3].ToFloat(),
+                 clustererNN.outputDataReg2_16[model_output_index + 7].ToFloat(),
+                 clustererNN.clusterFlags[2 * glo_idx],
+                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+    } else if (dtype == 1) {
+      pc.setFull(central_charge * clustererNN.outputDataReg2_32[model_output_index + 9],
+                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg2_32[model_output_index + 1],
+                 clustererNN.outputDataReg2_32[model_output_index + 5],
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg2_32[model_output_index + 3],
+                 clustererNN.outputDataReg2_32[model_output_index + 7],
+                 clustererNN.clusterFlags[2 * glo_idx],
+                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+    }
+
+    rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
     if (rejectCluster) {
       if (clusterer.mPclusterPosInRow) {
         clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
@@ -363,11 +428,11 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg2(uint glo_idx, GPUSha
       return;
     }
 
-    if (clusterer.mPclusterByRow != nullptr) {
+    if (clusterOut != nullptr) {
       rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
         clusterer,
         myCluster,
-        clustererNN.peakPositions[glo_idx].row(),
+        peak.row(),
         clusterer.mNMaxClusterPerRow,
         clusterer.mPclusterInRow,
         clusterOut);
@@ -377,7 +442,7 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg2(uint glo_idx, GPUSha
     } else if (clusterer.mPclusterPosInRow) {
       rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
     }
-    // CPU_ONLY(labelAcc->commit(clustererNN.peakPositions[glo_idx].row(), rowIndex, clusterer.mNMaxClusterPerRow)); // -> Is this needed? How to handle MC labels for split clusters?
+    // CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow)); // -> Is this needed? How to handle MC labels for split clusters?
   } else {
     if (clusterer.mPclusterPosInRow) {
       clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
@@ -385,3 +450,29 @@ GPUd() void GPUTPCNNClusterizerKernels::publishClustersReg2(uint glo_idx, GPUSha
     return;
   }
 }
+
+// THe following arithmetic is done because the network is trained with a split between IROC and OROC boundary
+GPUd() int GPUTPCNNClusterizerKernels::padOffset(int row_ref, int row_current)
+{
+  return (int)((GPUTPCGeometry::NPads(row_current) - GPUTPCGeometry::NPads(row_ref)) / 2);
+}
+
+GPUd() int GPUTPCNNClusterizerKernels::rowOffset(int row, int global_shift)
+{
+  return (row > 62 ? global_shift : 0);
+}
+
+GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int row, int pad, int global_shift)
+{
+  if (pad < 0 || row < 0) { // Faster short-circuit
+    return true;
+  } else if (row < 63) {
+    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row)));
+  } else if (row < (63 + global_shift)) { // to account for the gap between IROC and OROC. Charge will be set to -1 in order to signal boundary to the neural network
+    return true;
+  } else if (row < (o2::tpc::constants::MAXGLOBALPADROW + global_shift)) {
+    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row - global_shift)));
+  } else {
+    return true;
+  }
+}
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index a1d641fdb0b93..27cfba2487aed 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -39,6 +39,7 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
  public:
   // Must all have same number of threads, since they use a common SCRATCH_PAD_WORK_GROUP_SIZE below
   static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNSingleElement) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
   static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
   static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
   static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
@@ -59,10 +60,11 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
   enum K : int32_t {
     runCfClusterizer = 0,
     fillInputNN = 1,
-    determineClass1Labels = 2,
-    determineClass2Labels = 3,
-    publishClass1Regression = 4,
-    publishClass2Regression = 5,
+    fillInputNNSingleElement = 2,
+    determineClass1Labels = 3,
+    determineClass2Labels = 4,
+    publishClass1Regression = 5,
+    publishClass2Regression = 6,
   };
 
   template <int32_t iKernel = defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index fcf576d828b7f..7e3ddf868af2a 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -116,6 +116,7 @@ o2_gpu_add_kernel("GPUTPCCFClusterizer"                               "= TPCCLUS
 if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, runCfClusterizer"        "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNN"             "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNNSingleElement"             "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass1Labels"   "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass2Labels"   "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass1Regression" "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 0038233f1c376..73f1f208e8889 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -83,6 +83,7 @@ class GPUO2Interface;
 struct TPCPadGainCalib;
 struct TPCZSLinkMapping;
 struct GPUSettingsO2;
+struct GPUSettingsProcessingNNclusterizer;
 class GPUO2InterfaceQA;
 struct GPUTrackingInOutPointers;
 struct GPUTrackingInOutZS;
@@ -225,6 +226,8 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   uint32_t mNextThreadIndex = 0;
   bool mUpdateGainMapCCDB = true;
   std::unique_ptr<o2::gpu::GPUSettingsTF> mTFSettings;
+  std::unique_ptr<o2::gpu::GPUSettingsProcessingNNclusterizer> mNNClusterizerSettings;
+
   Config mSpecConfig;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGR;
   bool mGRPGeomUpdated = false;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 7ad03ec58ae80..8a755a703705f 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -78,6 +78,7 @@
 #include "DetectorsRaw/RDHUtils.h"
 #include "ITStracking/TrackingInterface.h"
 #include "GPUWorkflowInternal.h"
+#include "TPCCalibration/NeuralNetworkClusterizer.h"
 // #include "Framework/ThreadPool.h"
 
 #include <TStopwatch.h>
@@ -132,6 +133,50 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
 {
   GRPGeomHelper::instance().setRequest(mGGR);
   GPUO2InterfaceConfiguration& config = *mConfig.get();
+  GPUSettingsProcessingNNclusterizer& mNNClusterizerSettings = mConfig->configProcessing.nn;
+
+  if (mNNClusterizerSettings.nnLoadFromCCDB) {
+    LOG(info) << "Loading neural networks from CCDB";
+    o2::tpc::NeuralNetworkClusterizer nnClusterizerFetcher;
+    nnClusterizerFetcher.initCcdbApi(mNNClusterizerSettings.nnCCDBURL);
+    std::map<std::string, std::string> ccdbSettings = {
+      {"nnCCDBURL", mNNClusterizerSettings.nnCCDBURL},
+      {"nnCCDBPath", mNNClusterizerSettings.nnCCDBPath},
+      {"inputDType", mNNClusterizerSettings.nnInferenceInputDType},
+      {"outputDType", mNNClusterizerSettings.nnInferenceOutputDType},
+      {"outputFolder", mNNClusterizerSettings.nnLocalFolder},
+      {"nnCCDBPath", mNNClusterizerSettings.nnCCDBPath},
+      {"nnCCDBWithMomentum", std::to_string(mNNClusterizerSettings.nnCCDBWithMomentum)},
+      {"nnCCDBBeamType", mNNClusterizerSettings.nnCCDBBeamType},
+      {"nnCCDBInteractionRate", std::to_string(mNNClusterizerSettings.nnCCDBInteractionRate)}};
+
+    std::string nnFetchFolder = mNNClusterizerSettings.nnLocalFolder;
+    std::vector<std::string> evalMode = o2::utils::Str::tokenize(mNNClusterizerSettings.nnEvalMode, ':');
+
+    if (evalMode[0] == "c1") {
+      ccdbSettings["nnCCDBLayerType"] = mNNClusterizerSettings.nnCCDBClassificationLayerType;
+      ccdbSettings["nnCCDBEvalType"] = "classification_c1";
+      ccdbSettings["outputFile"] = "net_classification_c1.onnx";
+      nnClusterizerFetcher.loadIndividualFromCCDB(ccdbSettings);
+    } else if (evalMode[0] == "c2") {
+      ccdbSettings["nnCCDBLayerType"] = mNNClusterizerSettings.nnCCDBClassificationLayerType;
+      ccdbSettings["nnCCDBEvalType"] = "classification_c2";
+      ccdbSettings["outputFile"] = "net_classification_c2.onnx";
+      nnClusterizerFetcher.loadIndividualFromCCDB(ccdbSettings);
+    }
+
+    ccdbSettings["nnCCDBLayerType"] = mNNClusterizerSettings.nnCCDBRegressionLayerType;
+    ccdbSettings["nnCCDBEvalType"] = "regression_c1";
+    ccdbSettings["outputFile"] = "net_regression_c1.onnx";
+    nnClusterizerFetcher.loadIndividualFromCCDB(ccdbSettings);
+    if (evalMode[1] == "r2") {
+      ccdbSettings["nnCCDBLayerType"] = mNNClusterizerSettings.nnCCDBRegressionLayerType;
+      ccdbSettings["nnCCDBEvalType"] = "regression_c2";
+      ccdbSettings["outputFile"] = "net_regression_c2.onnx";
+      nnClusterizerFetcher.loadIndividualFromCCDB(ccdbSettings);
+    }
+    LOG(info) << "Neural network loading done!";
+  }
 
   // Create configuration object and fill settings
   mConfig->configGRP.solenoidBzNominalGPU = 0;

From 760831f9229c18525c9442ae053b8b348afb2cf3 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 19 Apr 2025 15:24:00 +0200
Subject: [PATCH 0269/1764] GPU: Simplify kernel Call interface, remove
 intermediate classes and headers where possible

---
 .../workflow/src/TRDGlobalTrackingSpec.cxx    |   2 +
 GPU/GPUTracking/Base/GPUProcessor.cxx         |   2 +-
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 257 ++++++++++--------
 GPU/GPUTracking/Base/GPUReconstruction.h      | 107 +++-----
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  49 ++--
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   | 111 +-------
 .../Base/GPUReconstructionCPUKernels.h        |  98 +++++++
 .../Base/GPUReconstructionConvert.cxx         |   2 +-
 .../Base/GPUReconstructionDeviceBase.cxx      |  21 +-
 .../Base/GPUReconstructionDeviceBase.h        |   8 +-
 GPU/GPUTracking/Base/GPUReconstructionIO.h    |  40 ++-
 .../Base/GPUReconstructionKernelMacros.h      |   2 +-
 .../Base/GPUReconstructionKernels.h           | 115 --------
 .../Base/GPUReconstructionLibrary.cxx         |   1 +
 .../Base/GPUReconstructionProcessing.cxx      |  19 +-
 .../Base/GPUReconstructionProcessing.h        |  98 ++++++-
 .../GPUReconstructionProcessingKernels.inc    |  41 +++
 .../Base/GPUReconstructionTimeframe.cxx       |   2 +
 .../Base/cuda/GPUReconstructionCUDA.cu        | 101 ++++---
 .../Base/cuda/GPUReconstructionCUDA.h         |  24 +-
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx |  62 ++---
 .../cuda/GPUReconstructionCUDAInternals.h     |   8 +-
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  14 +-
 .../Base/opencl/GPUReconstructionOCL.cxx      | 109 ++++----
 .../Base/opencl/GPUReconstructionOCL.h        |  13 +-
 .../opencl/GPUReconstructionOCLIncludesHost.h |   6 +-
 .../opencl/GPUReconstructionOCLKernels.cxx    |  19 +-
 GPU/GPUTracking/CMakeLists.txt                |   8 +-
 .../DataCompression/GPUTPCCompression.cxx     |   3 +-
 .../DataTypes/GPUKernelClassesFwd.h           |  40 +++
 GPU/GPUTracking/Global/GPUChain.h             |  46 +++-
 GPU/GPUTracking/Global/GPUChainITS.cxx        |   1 +
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |   4 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |  41 +--
 .../Global/GPUChainTrackingClusterizer.cxx    |  37 ++-
 .../Global/GPUChainTrackingCompression.cxx    |   3 +
 .../GPUChainTrackingDebugAndProfiling.cxx     |   6 +-
 GPU/GPUTracking/Global/GPUChainTrackingDefs.h |   2 +-
 .../Global/GPUChainTrackingGetters.inc        |  36 +++
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |   1 +
 .../Global/GPUChainTrackingMerger.cxx         |   5 +
 .../Global/GPUChainTrackingRefit.cxx          |   4 +
 .../Global/GPUChainTrackingSectorTracker.cxx  |  10 +
 .../Global/GPUChainTrackingTRD.cxx            |  10 +-
 .../Global/GPUChainTrackingTransformation.cxx |   4 +
 .../Global/GPUTrackingInputProvider.cxx       |   3 +
 GPU/GPUTracking/Interface/GPUO2Interface.cxx  |   2 +
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |   8 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |   1 +
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |   2 +-
 .../SectorTracker/GPUTPCTrackerDump.cxx       |   1 +
 .../Standalone/Benchmark/standalone.cxx       |  25 +-
 GPU/GPUTracking/Standalone/tools/createGeo.C  |   1 +
 GPU/GPUTracking/Standalone/tools/createLUT.C  |   1 +
 .../{Array2D.h => CfArray2D.h}                |  18 +-
 .../{ChargePos.h => CfChargePos.h}            |  14 +-
 GPU/GPUTracking/TPCClusterFinder/CfUtils.h    |  18 +-
 .../TPCClusterFinder/ClusterAccumulator.cxx   |   4 +-
 .../TPCClusterFinder/ClusterAccumulator.h     |   8 +-
 .../GPUTPCCFChargeMapFiller.cxx               |  16 +-
 .../GPUTPCCFChargeMapFiller.h                 |   8 +-
 .../GPUTPCCFCheckPadBaseline.cxx              |  14 +-
 .../GPUTPCCFCheckPadBaseline.h                |   2 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.cxx  |   2 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.h    |  12 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.inc  |  16 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     |  14 +-
 .../GPUTPCCFDeconvolution.cxx                 |  14 +-
 .../TPCClusterFinder/GPUTPCCFDeconvolution.h  |   6 +-
 .../GPUTPCCFNoiseSuppression.cxx              |  32 +--
 .../GPUTPCCFNoiseSuppression.h                |  12 +-
 .../TPCClusterFinder/GPUTPCCFPeakFinder.cxx   |  20 +-
 .../TPCClusterFinder/GPUTPCCFPeakFinder.h     |  10 +-
 .../GPUTPCCFStreamCompaction.cxx              |   4 +-
 .../TPCClusterFinder/GPUTPCClusterFinder.cxx  |   6 +-
 .../TPCClusterFinder/GPUTPCClusterFinder.h    |   8 +-
 .../GPUTPCClusterFinderDump.cxx               |   8 +-
 .../TPCClusterFinder/GPUTPCNNClusterizer.cxx  |   1 +
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |   2 +-
 .../GPUTPCNNClusterizerKernels.cxx            |  28 +-
 .../GPUTPCNNClusterizerKernels.h              |   4 +-
 .../TPCClusterFinder/MCLabelAccumulator.cxx   |   2 +-
 .../TPCClusterFinder/MCLabelAccumulator.h     |   6 +-
 GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx  |   1 +
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx |   1 +
 GPU/GPUTracking/display/GPUDisplay.cxx        |   3 +-
 GPU/GPUTracking/display/GPUDisplay.h          |  16 +-
 .../display/backend/GPUDisplayBackend.cxx     |   1 +
 .../backend/GPUDisplayBackendOpenGL.cxx       |   2 +
 .../backend/GPUDisplayBackendVulkan.cxx       |   2 +
 .../display/frontend/GPUDisplayFrontend.cxx   |   3 +
 .../frontend/GPUDisplayFrontendWayland.cxx    |   1 +
 .../display/frontend/GPUDisplayInfo.inc       |  36 +++
 .../display/frontend/GPUDisplayKeys.cxx       |   1 +
 .../display/helpers/GPUDisplayAnimation.cxx   |   2 +
 .../GPUDisplayBackendOpenGLMagneticField.cxx  |   1 +
 .../display/helpers/GPUDisplayHelpers.cxx     |   3 +
 .../helpers/GPUDisplayInterpolation.cxx       |   1 +
 .../display/helpers/GPUDisplayLoader.cxx      |   1 +
 .../display/helpers/GPUDisplayROOT.cxx        |   3 +
 .../display/render/GPUDisplayDraw.cxx         |   3 +-
 .../display/render/GPUDisplayImportEvent.cxx  |   1 +
 GPU/GPUTracking/kernels.cmake                 |   2 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  |   3 +-
 GPU/GPUTracking/qa/genEvents.cxx              |   3 +-
 105 files changed, 1136 insertions(+), 899 deletions(-)
 create mode 100644 GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
 delete mode 100644 GPU/GPUTracking/Base/GPUReconstructionKernels.h
 create mode 100644 GPU/GPUTracking/Base/GPUReconstructionProcessingKernels.inc
 create mode 100644 GPU/GPUTracking/DataTypes/GPUKernelClassesFwd.h
 create mode 100644 GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
 rename GPU/GPUTracking/TPCClusterFinder/{Array2D.h => CfArray2D.h} (81%)
 rename GPU/GPUTracking/TPCClusterFinder/{ChargePos.h => CfChargePos.h} (80%)
 create mode 100644 GPU/GPUTracking/display/frontend/GPUDisplayInfo.inc

diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index 424657ac19426..375fa732007cc 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -51,6 +51,8 @@
 #include "GPUTRDTrackletWord.h"
 #include "GPUTRDInterfaces.h"
 #include "GPUTRDGeometry.h"
+#include "GPUConstantMem.h"
+#include "GPUTRDTrackerKernels.h"
 
 #ifdef ENABLE_UPGRADES
 #include "ITS3Reconstruction/IOUtils.h"
diff --git a/GPU/GPUTracking/Base/GPUProcessor.cxx b/GPU/GPUTracking/Base/GPUProcessor.cxx
index 8a18f71d535e3..82627fb00723c 100644
--- a/GPU/GPUTracking/Base/GPUProcessor.cxx
+++ b/GPU/GPUTracking/Base/GPUProcessor.cxx
@@ -14,7 +14,7 @@
 
 #include "GPUProcessor.h"
 #include "GPUReconstruction.h"
-#include "GPUReconstructionDeviceBase.h"
+#include "GPUSettings.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index acca74e57a80e..c79c743e96ce5 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -30,7 +30,9 @@
 #include "GPUROOTDumpCore.h"
 #include "GPUConfigDump.h"
 #include "GPUChainTracking.h"
+#include "GPUConstantMem.h"
 #include "GPUCommonHelpers.h"
+#include "GPUSettings.h"
 
 #include "GPUMemoryResource.h"
 #include "GPUChain.h"
@@ -75,10 +77,10 @@ constexpr GPUReconstruction::GeometryType GPUReconstruction::geometryType;
 
 static ptrdiff_t ptrDiff(void* a, void* b) { return (char*)a - (char*)b; }
 
-GPUReconstruction::GPUReconstruction(const GPUSettingsDeviceBackend& cfg) : mHostConstantMem(new GPUConstantMem), mDeviceBackendSettings(cfg)
+GPUReconstruction::GPUReconstruction(const GPUSettingsDeviceBackend& cfg) : mHostConstantMem(new GPUConstantMem), mGRPSettings(new GPUSettingsGRP), mDeviceBackendSettings(new GPUSettingsDeviceBackend(cfg)), mProcessingSettings(new GPUSettingsProcessing)
 {
   if (cfg.master) {
-    if (cfg.master->mDeviceBackendSettings.deviceType != cfg.deviceType) {
+    if (cfg.master->GetDeviceBackendSettings().deviceType != cfg.deviceType) {
       throw std::invalid_argument("device type of master and slave GPUReconstruction does not match");
     }
     if (cfg.master->mMaster) {
@@ -87,7 +89,7 @@ GPUReconstruction::GPUReconstruction(const GPUSettingsDeviceBackend& cfg) : mHos
     mMaster = cfg.master;
     cfg.master->mSlaves.emplace_back(this);
   }
-  param().SetDefaults(&mGRPSettings);
+  param().SetDefaults(mGRPSettings.get());
   mMemoryScalers.reset(new GPUMemorySizeScalers);
   for (uint32_t i = 0; i < NSECTORS; i++) {
     processors()->tpcTrackers[i].SetSector(i); // TODO: Move to a better place
@@ -148,7 +150,7 @@ int32_t GPUReconstruction::Init()
   if (InitDevice()) {
     return 1;
   }
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     mHostMemoryPoolEnd = (char*)mHostMemoryBase + mHostMemorySize;
     mDeviceMemoryPoolEnd = (char*)mDeviceMemoryBase + mDeviceMemorySize;
   } else {
@@ -213,7 +215,7 @@ static uint32_t getDefaultNThreads()
 
 int32_t GPUReconstruction::InitPhaseBeforeDevice()
 {
-  if (mProcessingSettings.printSettings) {
+  if (GetProcessingSettings().printSettings) {
     if (mSlaves.size() || mMaster) {
       printf("\nConfig Dump %s\n", mMaster ? "Slave" : "Master");
     }
@@ -223,7 +225,7 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
         break;
       }
     }
-    GPUConfigDump::dumpConfig(&param().rec, &mProcessingSettings, chTrk ? chTrk->GetQAConfig() : nullptr, chTrk ? chTrk->GetEventDisplayConfig() : nullptr, &mDeviceBackendSettings, &mRecoSteps);
+    GPUConfigDump::dumpConfig(&param().rec, mProcessingSettings.get(), chTrk ? chTrk->GetQAConfig() : nullptr, chTrk ? chTrk->GetEventDisplayConfig() : nullptr, mDeviceBackendSettings.get(), &mRecoSteps);
   }
   mRecoSteps.stepsGPUMask &= mRecoSteps.steps;
   mRecoSteps.stepsGPUMask &= AvailableGPURecoSteps();
@@ -231,95 +233,95 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     mRecoSteps.stepsGPUMask.set((uint8_t)0);
   }
 
-  if (mProcessingSettings.forceMemoryPoolSize >= 1024 || mProcessingSettings.forceHostMemoryPoolSize >= 1024) {
-    mProcessingSettings.memoryAllocationStrategy = GPUMemoryResource::ALLOCATION_GLOBAL;
+  if (GetProcessingSettings().forceMemoryPoolSize >= 1024 || GetProcessingSettings().forceHostMemoryPoolSize >= 1024) {
+    mProcessingSettings->memoryAllocationStrategy = GPUMemoryResource::ALLOCATION_GLOBAL;
   }
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_AUTO) {
-    mProcessingSettings.memoryAllocationStrategy = IsGPU() ? GPUMemoryResource::ALLOCATION_GLOBAL : GPUMemoryResource::ALLOCATION_INDIVIDUAL;
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_AUTO) {
+    mProcessingSettings->memoryAllocationStrategy = IsGPU() ? GPUMemoryResource::ALLOCATION_GLOBAL : GPUMemoryResource::ALLOCATION_INDIVIDUAL;
   }
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
-    mProcessingSettings.forceMemoryPoolSize = mProcessingSettings.forceHostMemoryPoolSize = 0;
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
+    mProcessingSettings->forceMemoryPoolSize = mProcessingSettings->forceHostMemoryPoolSize = 0;
   }
-  if (mProcessingSettings.debugLevel >= 4) {
-    mProcessingSettings.keepAllMemory = true;
+  if (GetProcessingSettings().debugLevel >= 4) {
+    mProcessingSettings->keepAllMemory = true;
   }
-  if (mProcessingSettings.debugLevel >= 5 && mProcessingSettings.allocDebugLevel < 2) {
-    mProcessingSettings.allocDebugLevel = 2;
+  if (GetProcessingSettings().debugLevel >= 5 && GetProcessingSettings().allocDebugLevel < 2) {
+    mProcessingSettings->allocDebugLevel = 2;
   }
-  if (mProcessingSettings.eventDisplay || mProcessingSettings.keepAllMemory) {
-    mProcessingSettings.keepDisplayMemory = true;
+  if (GetProcessingSettings().eventDisplay || GetProcessingSettings().keepAllMemory) {
+    mProcessingSettings->keepDisplayMemory = true;
   }
-  if (mProcessingSettings.debugLevel < 6) {
-    mProcessingSettings.debugMask = 0;
+  if (GetProcessingSettings().debugLevel < 6) {
+    mProcessingSettings->debugMask = 0;
   }
-  if (mProcessingSettings.debugLevel < 1) {
-    mProcessingSettings.deviceTimers = false;
+  if (GetProcessingSettings().debugLevel < 1) {
+    mProcessingSettings->deviceTimers = false;
   }
-  if (mProcessingSettings.debugLevel > 0) {
-    mProcessingSettings.recoTaskTiming = true;
+  if (GetProcessingSettings().debugLevel > 0) {
+    mProcessingSettings->recoTaskTiming = true;
   }
-  if (mProcessingSettings.deterministicGPUReconstruction == -1) {
-    mProcessingSettings.deterministicGPUReconstruction = mProcessingSettings.debugLevel >= 6;
+  if (GetProcessingSettings().deterministicGPUReconstruction == -1) {
+    mProcessingSettings->deterministicGPUReconstruction = GetProcessingSettings().debugLevel >= 6;
   }
-  if (mProcessingSettings.deterministicGPUReconstruction) {
+  if (GetProcessingSettings().deterministicGPUReconstruction) {
 #ifndef GPUCA_DETERMINISTIC_MODE
     GPUError("WARNING, deterministicGPUReconstruction needs GPUCA_DETERMINISTIC_MODE for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
 #endif
-    mProcessingSettings.overrideClusterizerFragmentLen = TPC_MAX_FRAGMENT_LEN_GPU;
+    mProcessingSettings->overrideClusterizerFragmentLen = TPC_MAX_FRAGMENT_LEN_GPU;
     param().rec.tpc.nWaysOuter = true;
     if (param().rec.tpc.looperInterpolationInExtraPass == -1) {
       param().rec.tpc.looperInterpolationInExtraPass = 0;
     }
-    if (mProcessingSettings.createO2Output > 1) {
-      mProcessingSettings.createO2Output = 1;
+    if (GetProcessingSettings().createO2Output > 1) {
+      mProcessingSettings->createO2Output = 1;
     }
-    mProcessingSettings.rtc.deterministic = 1;
+    mProcessingSettings->rtc.deterministic = 1;
   } else {
 #ifdef GPUCA_DETERMINISTIC_MODE
     GPUError("WARNING, compiled with GPUCA_DETERMINISTIC_MODE but deterministicGPUReconstruction not set, only compile-time determinism and deterministic math enforced, not fully deterministic!");
 #endif
   }
-  if (mProcessingSettings.deterministicGPUReconstruction && mProcessingSettings.debugLevel >= 6) {
-    mProcessingSettings.nTPCClustererLanes = 1;
+  if (GetProcessingSettings().deterministicGPUReconstruction && GetProcessingSettings().debugLevel >= 6) {
+    mProcessingSettings->nTPCClustererLanes = 1;
   }
-  if (mProcessingSettings.createO2Output > 1 && mProcessingSettings.runQA && mProcessingSettings.qcRunFraction == 100.f) {
-    mProcessingSettings.createO2Output = 1;
+  if (GetProcessingSettings().createO2Output > 1 && GetProcessingSettings().runQA && GetProcessingSettings().qcRunFraction == 100.f) {
+    mProcessingSettings->createO2Output = 1;
   }
-  if (!mProcessingSettings.createO2Output || !IsGPU()) {
-    mProcessingSettings.clearO2OutputFromGPU = false;
+  if (!GetProcessingSettings().createO2Output || !IsGPU()) {
+    mProcessingSettings->clearO2OutputFromGPU = false;
   }
   if (!(mRecoSteps.stepsGPUMask & GPUDataTypes::RecoStep::TPCMerging)) {
-    mProcessingSettings.mergerSortTracks = false;
+    mProcessingSettings->mergerSortTracks = false;
   }
 
-  if (mProcessingSettings.debugLevel > 3 || !IsGPU() || mProcessingSettings.deterministicGPUReconstruction) {
-    mProcessingSettings.delayedOutput = false;
+  if (GetProcessingSettings().debugLevel > 3 || !IsGPU() || GetProcessingSettings().deterministicGPUReconstruction) {
+    mProcessingSettings->delayedOutput = false;
   }
 
-  if (!mProcessingSettings.rtc.enable) {
-    mProcessingSettings.rtc.optConstexpr = false;
+  if (!GetProcessingSettings().rtc.enable) {
+    mProcessingSettings->rtc.optConstexpr = false;
   }
 
-  mMemoryScalers->factor = mProcessingSettings.memoryScalingFactor;
-  mMemoryScalers->conservative = mProcessingSettings.conservativeMemoryEstimate;
-  mMemoryScalers->returnMaxVal = mProcessingSettings.forceMaxMemScalers != 0;
-  if (mProcessingSettings.forceMaxMemScalers > 1) {
-    mMemoryScalers->rescaleMaxMem(mProcessingSettings.forceMaxMemScalers);
+  mMemoryScalers->factor = GetProcessingSettings().memoryScalingFactor;
+  mMemoryScalers->conservative = GetProcessingSettings().conservativeMemoryEstimate;
+  mMemoryScalers->returnMaxVal = GetProcessingSettings().forceMaxMemScalers != 0;
+  if (GetProcessingSettings().forceMaxMemScalers > 1) {
+    mMemoryScalers->rescaleMaxMem(GetProcessingSettings().forceMaxMemScalers);
   }
 
-  if (mProcessingSettings.nHostThreads != -1 && mProcessingSettings.ompThreads != -1) {
+  if (GetProcessingSettings().nHostThreads != -1 && GetProcessingSettings().ompThreads != -1) {
     GPUFatal("Must not use both nHostThreads and ompThreads at the same time!");
-  } else if (mProcessingSettings.ompThreads != -1) {
-    mProcessingSettings.nHostThreads = mProcessingSettings.ompThreads;
+  } else if (GetProcessingSettings().ompThreads != -1) {
+    mProcessingSettings->nHostThreads = GetProcessingSettings().ompThreads;
     GPUWarning("You are using the deprecated ompThreads option, please switch to nHostThreads!");
   }
 
-  if (mProcessingSettings.nHostThreads <= 0) {
-    mProcessingSettings.nHostThreads = internal::getDefaultNThreads();
+  if (GetProcessingSettings().nHostThreads <= 0) {
+    mProcessingSettings->nHostThreads = internal::getDefaultNThreads();
   } else {
-    mProcessingSettings.autoAdjustHostThreads = false;
+    mProcessingSettings->autoAdjustHostThreads = false;
   }
-  mMaxHostThreads = mProcessingSettings.nHostThreads;
+  mMaxHostThreads = GetProcessingSettings().nHostThreads;
   if (mMaster == nullptr) {
     mThreading = std::make_shared<GPUReconstructionThreading>();
     mThreading->control = std::make_unique<tbb::global_control>(tbb::global_control::max_allowed_parallelism, mMaxHostThreads);
@@ -330,26 +332,26 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
   }
   mMaxBackendThreads = std::max(mMaxBackendThreads, mMaxHostThreads);
   if (IsGPU()) {
-    mNStreams = std::max<int32_t>(mProcessingSettings.nStreams, 3);
+    mNStreams = std::max<int32_t>(GetProcessingSettings().nStreams, 3);
   }
 
-  if (mProcessingSettings.nTPCClustererLanes == -1) {
-    mProcessingSettings.nTPCClustererLanes = (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) ? 3 : std::max<int32_t>(1, std::min<int32_t>(GPUCA_NSECTORS, mProcessingSettings.inKernelParallel ? (mMaxHostThreads >= 4 ? std::min<int32_t>(mMaxHostThreads / 2, mMaxHostThreads >= 32 ? GPUCA_NSECTORS : 4) : 1) : mMaxHostThreads));
+  if (GetProcessingSettings().nTPCClustererLanes == -1) {
+    mProcessingSettings->nTPCClustererLanes = (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) ? 3 : std::max<int32_t>(1, std::min<int32_t>(GPUCA_NSECTORS, GetProcessingSettings().inKernelParallel ? (mMaxHostThreads >= 4 ? std::min<int32_t>(mMaxHostThreads / 2, mMaxHostThreads >= 32 ? GPUCA_NSECTORS : 4) : 1) : mMaxHostThreads));
   }
-  if (mProcessingSettings.overrideClusterizerFragmentLen == -1) {
-    mProcessingSettings.overrideClusterizerFragmentLen = ((GetRecoStepsGPU() & RecoStep::TPCClusterFinding) || (mMaxHostThreads / mProcessingSettings.nTPCClustererLanes >= 3)) ? TPC_MAX_FRAGMENT_LEN_GPU : TPC_MAX_FRAGMENT_LEN_HOST;
+  if (GetProcessingSettings().overrideClusterizerFragmentLen == -1) {
+    mProcessingSettings->overrideClusterizerFragmentLen = ((GetRecoStepsGPU() & RecoStep::TPCClusterFinding) || (mMaxHostThreads / GetProcessingSettings().nTPCClustererLanes >= 3)) ? TPC_MAX_FRAGMENT_LEN_GPU : TPC_MAX_FRAGMENT_LEN_HOST;
   }
-  if (mProcessingSettings.nTPCClustererLanes > GPUCA_NSECTORS) {
-    GPUError("Invalid value for nTPCClustererLanes: %d", mProcessingSettings.nTPCClustererLanes);
-    mProcessingSettings.nTPCClustererLanes = GPUCA_NSECTORS;
+  if (GetProcessingSettings().nTPCClustererLanes > GPUCA_NSECTORS) {
+    GPUError("Invalid value for nTPCClustererLanes: %d", GetProcessingSettings().nTPCClustererLanes);
+    mProcessingSettings->nTPCClustererLanes = GPUCA_NSECTORS;
   }
 
-  if (mProcessingSettings.doublePipeline && (mChains.size() != 1 || mChains[0]->SupportsDoublePipeline() == false || !IsGPU() || mProcessingSettings.memoryAllocationStrategy != GPUMemoryResource::ALLOCATION_GLOBAL)) {
+  if (GetProcessingSettings().doublePipeline && (mChains.size() != 1 || mChains[0]->SupportsDoublePipeline() == false || !IsGPU() || GetProcessingSettings().memoryAllocationStrategy != GPUMemoryResource::ALLOCATION_GLOBAL)) {
     GPUError("Must use double pipeline mode only with exactly one chain that must support it");
     return 1;
   }
 
-  if (mMaster == nullptr && mProcessingSettings.doublePipeline) {
+  if (mMaster == nullptr && GetProcessingSettings().doublePipeline) {
     mPipelineContext.reset(new GPUReconstructionPipelineContext);
   }
 
@@ -367,16 +369,16 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     mDeviceMemorySize += memPrimary;
     mHostMemorySize += memPageLocked;
   }
-  if (mProcessingSettings.forceMemoryPoolSize && mProcessingSettings.forceMemoryPoolSize <= 2 && CanQueryMaxMemory()) {
-    mDeviceMemorySize = mProcessingSettings.forceMemoryPoolSize;
-  } else if (mProcessingSettings.forceMemoryPoolSize > 2) {
-    mDeviceMemorySize = mProcessingSettings.forceMemoryPoolSize;
+  if (GetProcessingSettings().forceMemoryPoolSize && GetProcessingSettings().forceMemoryPoolSize <= 2 && CanQueryMaxMemory()) {
+    mDeviceMemorySize = GetProcessingSettings().forceMemoryPoolSize;
+  } else if (GetProcessingSettings().forceMemoryPoolSize > 2) {
+    mDeviceMemorySize = GetProcessingSettings().forceMemoryPoolSize;
     if (!IsGPU() || mOutputControl.useInternal()) {
       mHostMemorySize = mDeviceMemorySize;
     }
   }
-  if (mProcessingSettings.forceHostMemoryPoolSize) {
-    mHostMemorySize = mProcessingSettings.forceHostMemoryPoolSize;
+  if (GetProcessingSettings().forceHostMemoryPoolSize) {
+    mHostMemorySize = GetProcessingSettings().forceHostMemoryPoolSize;
   }
 
   for (uint32_t i = 0; i < mProcessors.size(); i++) {
@@ -399,7 +401,7 @@ int32_t GPUReconstruction::InitPhasePermanentMemory()
 
 int32_t GPUReconstruction::InitPhaseAfterDevice()
 {
-  if (mProcessingSettings.forceMaxMemScalers <= 1 && mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
+  if (GetProcessingSettings().forceMaxMemScalers <= 1 && GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     mMemoryScalers->rescaleMaxMem(IsGPU() ? mDeviceMemorySize : mHostMemorySize);
   }
   for (uint32_t i = 0; i < mChains.size(); i++) {
@@ -446,7 +448,7 @@ int32_t GPUReconstruction::Exit()
 
   mChains.clear();          // Make sure we destroy a possible ITS GPU tracker before we call the destructors
   mHostConstantMem.reset(); // Reset these explicitly before the destruction of other members unloads the library
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
     for (uint32_t i = 0; i < mMemoryResources.size(); i++) {
       if (mMemoryResources[i].mReuse >= 0) {
         continue;
@@ -481,9 +483,38 @@ void GPUReconstruction::ComputeReuseMax(GPUProcessor* proc)
   }
 }
 
+int16_t GPUReconstruction::RegisterMemoryAllocationHelper(GPUProcessor* proc, void* (GPUProcessor::*setPtr)(void*), int32_t type, const char* name, const GPUMemoryReuse& re)
+{
+  if (!(type & (GPUMemoryResource::MEMORY_HOST | GPUMemoryResource::MEMORY_GPU))) {
+    if ((type & GPUMemoryResource::MEMORY_SCRATCH) && !GetProcessingSettings().keepDisplayMemory) { // keepAllMemory --> keepDisplayMemory
+      type |= (proc->mGPUProcessorType == GPUProcessor::PROCESSOR_TYPE_CPU ? GPUMemoryResource::MEMORY_HOST : GPUMemoryResource::MEMORY_GPU);
+    } else {
+      type |= GPUMemoryResource::MEMORY_HOST | GPUMemoryResource::MEMORY_GPU;
+    }
+  }
+  if (proc->mGPUProcessorType == GPUProcessor::PROCESSOR_TYPE_CPU) {
+    type &= ~GPUMemoryResource::MEMORY_GPU;
+  }
+  mMemoryResources.emplace_back(proc, setPtr, (GPUMemoryResource::MemoryType)type, name);
+  if (mMemoryResources.size() >= 32768) {
+    throw std::bad_alloc();
+  }
+  uint16_t retVal = mMemoryResources.size() - 1;
+  if (re.type != GPUMemoryReuse::NONE && !GetProcessingSettings().disableMemoryReuse) {
+    const auto& it = mMemoryReuse1to1.find(re.id);
+    if (it == mMemoryReuse1to1.end()) {
+      mMemoryReuse1to1[re.id] = {proc, retVal};
+    } else {
+      mMemoryResources[retVal].mReuse = it->second.res[0];
+      it->second.res.emplace_back(retVal);
+    }
+  }
+  return retVal;
+}
+
 size_t GPUReconstruction::AllocateRegisteredMemory(GPUProcessor* proc, bool resetCustom)
 {
-  if (mProcessingSettings.debugLevel >= 5) {
+  if (GetProcessingSettings().debugLevel >= 5) {
     GPUInfo("Allocating memory %p", (void*)proc);
   }
   size_t total = 0;
@@ -496,7 +527,7 @@ size_t GPUReconstruction::AllocateRegisteredMemory(GPUProcessor* proc, bool rese
       }
     }
   }
-  if (mProcessingSettings.debugLevel >= 5) {
+  if (GetProcessingSettings().debugLevel >= 5) {
     GPUInfo("Allocating memory done");
   }
   return total;
@@ -504,7 +535,7 @@ size_t GPUReconstruction::AllocateRegisteredMemory(GPUProcessor* proc, bool rese
 
 size_t GPUReconstruction::AllocateRegisteredPermanentMemory()
 {
-  if (mProcessingSettings.debugLevel >= 5) {
+  if (GetProcessingSettings().debugLevel >= 5) {
     GPUInfo("Allocating Permanent Memory");
   }
   int32_t total = 0;
@@ -515,7 +546,7 @@ size_t GPUReconstruction::AllocateRegisteredPermanentMemory()
   }
   mHostMemoryPermanent = mHostMemoryPool;
   mDeviceMemoryPermanent = mDeviceMemoryPool;
-  if (mProcessingSettings.debugLevel >= 5) {
+  if (GetProcessingSettings().debugLevel >= 5) {
     GPUInfo("Permanent Memory Done");
   }
   return total;
@@ -534,7 +565,7 @@ size_t GPUReconstruction::AllocateRegisteredMemoryHelper(GPUMemoryResource* res,
       GPUError("Insufficient reuse memory %lu < %lu (%s) (%s)", mMemoryResources[res->mReuse].mSize, retVal, res->mName, device);
       throw std::bad_alloc();
     }
-    if (mProcessingSettings.allocDebugLevel >= 2) {
+    if (GetProcessingSettings().allocDebugLevel >= 2) {
       std::cout << "Reused (" << device << ") " << res->mName << ": " << retVal << "\n";
     }
     return retVal;
@@ -568,7 +599,7 @@ size_t GPUReconstruction::AllocateRegisteredMemoryHelper(GPUMemoryResource* res,
     std::cerr << "Memory pool size exceeded (" << device << ") (" << res->mName << ": " << (memorypoolend ? (memorysize + ptrDiff(memorypool, memorypoolend)) : ptrDiff(memorypool, memorybase)) << " > " << memorysize << "\n";
     throw std::bad_alloc();
   }
-  if (mProcessingSettings.allocDebugLevel >= 2) {
+  if (GetProcessingSettings().allocDebugLevel >= 2) {
     std::cout << "Allocated (" << device << ") " << res->mName << ": " << retVal << " - available: " << (memorypoolend ? ptrDiff(memorypoolend, memorypool) : (memorysize - ptrDiff(memorypool, memorybase))) << "\n";
   }
   return retVal;
@@ -576,7 +607,7 @@ size_t GPUReconstruction::AllocateRegisteredMemoryHelper(GPUMemoryResource* res,
 
 void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res, GPUOutputControl* control, GPUReconstruction* recPool)
 {
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && (control == nullptr || control->useInternal())) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && (control == nullptr || control->useInternal())) {
     if (!(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) {
       if (res->mPtrDevice && res->mReuse < 0) {
         operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
@@ -593,7 +624,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
       }
       res->mPtr = GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(res->mPtrDevice);
       res->SetPointers(res->mPtr);
-      if (mProcessingSettings.allocDebugLevel >= 2) {
+      if (GetProcessingSettings().allocDebugLevel >= 2) {
         std::cout << (res->mReuse >= 0 ? "Reused " : "Allocated ") << res->mName << ": " << res->mSize << "\n";
       }
       if (res->mType & GPUMemoryResource::MEMORY_STACK) {
@@ -612,13 +643,13 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
     if (IsGPU() && res->mOverrideSize < GPUCA_BUFFER_ALIGNMENT) {
       res->mOverrideSize = GPUCA_BUFFER_ALIGNMENT;
     }
-    if ((!IsGPU() || (res->mType & GPUMemoryResource::MEMORY_HOST) || mProcessingSettings.keepDisplayMemory) && !(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) { // keepAllMemory --> keepDisplayMemory
+    if ((!IsGPU() || (res->mType & GPUMemoryResource::MEMORY_HOST) || GetProcessingSettings().keepDisplayMemory) && !(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) { // keepAllMemory --> keepDisplayMemory
       if (control && control->useExternal()) {
         if (control->allocator) {
           res->mSize = std::max((size_t)res->SetPointers((void*)1) - 1, res->mOverrideSize);
           res->mPtr = control->allocator(CAMath::nextMultipleOf<GPUCA_BUFFER_ALIGNMENT>(res->mSize));
           res->mSize = std::max<size_t>(ptrDiff(res->SetPointers(res->mPtr), res->mPtr), res->mOverrideSize);
-          if (mProcessingSettings.allocDebugLevel >= 2) {
+          if (GetProcessingSettings().allocDebugLevel >= 2) {
             std::cout << "Allocated (from callback) " << res->mName << ": " << res->mSize << "\n";
           }
         } else {
@@ -676,7 +707,7 @@ void* GPUReconstruction::AllocateUnmanagedMemory(size_t size, int32_t type)
   if (type != GPUMemoryResource::MEMORY_HOST && (!IsGPU() || type != GPUMemoryResource::MEMORY_GPU)) {
     throw std::runtime_error("Requested invalid memory typo for unmanaged allocation");
   }
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
     mUnmanagedChunks.emplace_back(new char[size + GPUCA_BUFFER_ALIGNMENT]);
     return GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(mUnmanagedChunks.back().get());
   } else {
@@ -689,7 +720,7 @@ void* GPUReconstruction::AllocateUnmanagedMemory(size_t size, int32_t type)
       throw std::bad_alloc();
     }
     UpdateMaxMemoryUsed();
-    if (mProcessingSettings.allocDebugLevel >= 2) {
+    if (GetProcessingSettings().allocDebugLevel >= 2) {
       std::cout << "Allocated (unmanaged " << (type == GPUMemoryResource::MEMORY_GPU ? "gpu" : "host") << "): " << size << " - available: " << ptrDiff(poolend, pool) << "\n";
     }
     return retVal;
@@ -711,7 +742,7 @@ void* GPUReconstruction::AllocateVolatileDeviceMemory(size_t size)
     throw std::bad_alloc();
   }
   UpdateMaxMemoryUsed();
-  if (mProcessingSettings.allocDebugLevel >= 2) {
+  if (GetProcessingSettings().allocDebugLevel >= 2) {
     std::cout << "Allocated (volatile GPU): " << size << " - available: " << ptrDiff(mDeviceMemoryPoolEnd, mDeviceMemoryPool) << "\n";
   }
 
@@ -773,10 +804,10 @@ void GPUReconstruction::FreeRegisteredMemory(int16_t ires)
 
 void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)
 {
-  if (mProcessingSettings.allocDebugLevel >= 2 && (res->mPtr || res->mPtrDevice)) {
+  if (GetProcessingSettings().allocDebugLevel >= 2 && (res->mPtr || res->mPtrDevice)) {
     std::cout << "Freeing " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
   }
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && res->mReuse < 0) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && res->mReuse < 0) {
     operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
   }
   res->mPtr = nullptr;
@@ -789,7 +820,7 @@ void GPUReconstruction::ReturnVolatileDeviceMemory()
     mDeviceMemoryPool = mVolatileMemoryStart;
     mVolatileMemoryStart = nullptr;
   }
-  if (mProcessingSettings.allocDebugLevel >= 2) {
+  if (GetProcessingSettings().allocDebugLevel >= 2) {
     std::cout << "Freed (volatile GPU) - available: " << ptrDiff(mDeviceMemoryPoolEnd, mDeviceMemoryPool) << "\n";
   }
 }
@@ -807,7 +838,7 @@ void GPUReconstruction::PushNonPersistentMemory(uint64_t tag)
 
 void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
 {
-  if (mProcessingSettings.keepDisplayMemory || mProcessingSettings.disableMemoryReuse) {
+  if (GetProcessingSettings().keepDisplayMemory || GetProcessingSettings().disableMemoryReuse) {
     return;
   }
   if (mNonPersistentMemoryStack.size() == 0) {
@@ -816,7 +847,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
   if (tag != 0 && std::get<3>(mNonPersistentMemoryStack.back()) != tag) {
     GPUFatal("Tag mismatch when popping non persistent memory from stack : pop %s vs on stack %s", qTag2Str(tag).c_str(), qTag2Str(std::get<3>(mNonPersistentMemoryStack.back())).c_str());
   }
-  if ((mProcessingSettings.debugLevel >= 3 || mProcessingSettings.allocDebugLevel) && (IsGPU() || mProcessingSettings.forceHostMemoryPoolSize)) {
+  if ((GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) && (IsGPU() || GetProcessingSettings().forceHostMemoryPoolSize)) {
     printf("Allocated memory after %30s (%8s) (Stack %zu): ", GPUDataTypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<3>(mNonPersistentMemoryStack.back())).c_str(), mNonPersistentMemoryStack.size());
     PrintMemoryOverview();
     printf("%76s", "");
@@ -872,7 +903,7 @@ void GPUReconstruction::ClearAllocatedMemory(bool clearOutputs)
   mNonPersistentMemoryStack.clear();
   mNonPersistentIndividualAllocations.clear();
   mVolatileMemoryStart = nullptr;
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     mHostMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mHostMemoryPermanent);
     mDeviceMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mDeviceMemoryPermanent);
     mHostMemoryPoolEnd = mHostMemoryPoolBlocked ? mHostMemoryPoolBlocked : ((char*)mHostMemoryBase + mHostMemorySize);
@@ -895,7 +926,7 @@ void GPUReconstruction::PrintMemoryMax()
 
 void GPUReconstruction::PrintMemoryOverview()
 {
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     printf("Memory Allocation: Host %'13zd / %'13zu (Permanent %'13zd, Data %'13zd, Scratch %'13zd), Device %'13zd / %'13zu, (Permanent %'13zd, Data %'13zd, Scratch %'13zd) %zu chunks\n",
            ptrDiff(mHostMemoryPool, mHostMemoryBase) + ptrDiff((char*)mHostMemoryBase + mHostMemorySize, mHostMemoryPoolEnd), mHostMemorySize, ptrDiff(mHostMemoryPermanent, mHostMemoryBase), ptrDiff(mHostMemoryPool, mHostMemoryPermanent), ptrDiff((char*)mHostMemoryBase + mHostMemorySize, mHostMemoryPoolEnd),
            ptrDiff(mDeviceMemoryPool, mDeviceMemoryBase) + ptrDiff((char*)mDeviceMemoryBase + mDeviceMemorySize, mDeviceMemoryPoolEnd), mDeviceMemorySize, ptrDiff(mDeviceMemoryPermanent, mDeviceMemoryBase), ptrDiff(mDeviceMemoryPool, mDeviceMemoryPermanent), ptrDiff((char*)mDeviceMemoryBase + mDeviceMemorySize, mDeviceMemoryPoolEnd),
@@ -934,7 +965,7 @@ void GPUReconstruction::PrintMemoryStatistics()
 
 int32_t GPUReconstruction::registerMemoryForGPU(const void* ptr, size_t size)
 {
-  if (mProcessingSettings.noGPUMemoryRegistration) {
+  if (GetProcessingSettings().noGPUMemoryRegistration) {
     return 0;
   }
   int32_t retVal = registerMemoryForGPU_internal(ptr, size);
@@ -946,7 +977,7 @@ int32_t GPUReconstruction::registerMemoryForGPU(const void* ptr, size_t size)
 
 int32_t GPUReconstruction::unregisterMemoryForGPU(const void* ptr)
 {
-  if (mProcessingSettings.noGPUMemoryRegistration) {
+  if (GetProcessingSettings().noGPUMemoryRegistration) {
     return 0;
   }
   const auto& pos = mRegisteredMemoryPtrs.find(ptr);
@@ -982,10 +1013,10 @@ int32_t GPUReconstruction::getGeneralStepNum(GeneralStep step, bool validCheck)
 
 void GPUReconstruction::RunPipelineWorker()
 {
-  if (!mInitialized || !mProcessingSettings.doublePipeline || mMaster != nullptr || !mSlaves.size()) {
+  if (!mInitialized || !GetProcessingSettings().doublePipeline || mMaster != nullptr || !mSlaves.size()) {
     throw std::invalid_argument("Cannot start double pipeline mode");
   }
-  if (mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("Pipeline worker started");
   }
   bool terminate = false;
@@ -1011,7 +1042,7 @@ void GPUReconstruction::RunPipelineWorker()
     }
     q->c.notify_one();
   }
-  if (mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("Pipeline worker ended");
   }
 }
@@ -1107,7 +1138,7 @@ void GPUReconstruction::DumpSettings(const char* dir)
   std::string f;
   f = dir;
   f += "settings.dump";
-  DumpStructToFile(&mGRPSettings, f.c_str());
+  DumpStructToFile(mGRPSettings.get(), f.c_str());
   for (uint32_t i = 0; i < mChains.size(); i++) {
     mChains[i]->DumpSettings(dir);
   }
@@ -1121,11 +1152,11 @@ void GPUReconstruction::UpdateDynamicSettings(const GPUSettingsRecDynamic* d)
 void GPUReconstruction::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p, const GPUSettingsRecDynamic* d)
 {
   if (g) {
-    mGRPSettings = *g;
+    *mGRPSettings = *g;
   }
   if (p) {
-    mProcessingSettings.debugLevel = p->debugLevel;
-    mProcessingSettings.resetTimers = p->resetTimers;
+    mProcessingSettings->debugLevel = p->debugLevel;
+    mProcessingSettings->resetTimers = p->resetTimers;
   }
   GPURecoStepConfiguration* w = nullptr;
   if (mRecoSteps.steps.isSet(GPUDataTypes::RecoStep::TPCdEdx)) {
@@ -1142,11 +1173,11 @@ int32_t GPUReconstruction::ReadSettings(const char* dir)
   std::string f;
   f = dir;
   f += "settings.dump";
-  new (&mGRPSettings) GPUSettingsGRP;
-  if (ReadStructFromFile(f.c_str(), &mGRPSettings)) {
+  new (mGRPSettings.get()) GPUSettingsGRP;
+  if (ReadStructFromFile(f.c_str(), mGRPSettings.get())) {
     return 1;
   }
-  param().UpdateSettings(&mGRPSettings);
+  param().UpdateSettings(mGRPSettings.get());
   for (uint32_t i = 0; i < mChains.size(); i++) {
     mChains[i]->ReadSettings(dir);
   }
@@ -1173,9 +1204,9 @@ void GPUReconstruction::SetSettings(const GPUSettingsGRP* grp, const GPUSettings
     GPUError("Cannot update settings while initialized");
     throw std::runtime_error("Settings updated while initialized");
   }
-  mGRPSettings = *grp;
+  *mGRPSettings = *grp;
   if (proc) {
-    mProcessingSettings = *proc;
+    *mProcessingSettings = *proc;
   }
   if (workflow) {
     mRecoSteps.steps = workflow->steps;
@@ -1183,7 +1214,7 @@ void GPUReconstruction::SetSettings(const GPUSettingsGRP* grp, const GPUSettings
     mRecoSteps.inputs = workflow->inputs;
     mRecoSteps.outputs = workflow->outputs;
   }
-  param().SetDefaults(&mGRPSettings, rec, proc, workflow);
+  param().SetDefaults(mGRPSettings.get(), rec, proc, workflow);
 }
 
 void GPUReconstruction::SetOutputControl(void* ptr, size_t size)
@@ -1193,10 +1224,14 @@ void GPUReconstruction::SetOutputControl(void* ptr, size_t size)
   SetOutputControl(outputControl);
 }
 
-void GPUReconstruction::SetInputControl(void* ptr, size_t size)
-{
-  mInputControl.set(ptr, size);
-}
+void GPUReconstruction::SetInputControl(void* ptr, size_t size) { mInputControl.set(ptr, size); }
+GPUReconstruction::DeviceType GPUReconstruction::GetDeviceType() const { return (DeviceType)GetDeviceBackendSettings().deviceType; }
+const GPUParam& GPUReconstruction::GetParam() const { return mHostConstantMem->param; }
+void GPUReconstruction::SetResetTimers(bool reset) { mProcessingSettings->resetTimers = reset; }
+void GPUReconstruction::SetDebugLevelTmp(int32_t level) { mProcessingSettings->debugLevel = level; }
+GPUParam& GPUReconstruction::param() { return mHostConstantMem->param; }
+const GPUTrackingInOutPointers GPUReconstruction::GetIOPtrs() const { return mHostConstantMem->ioPtrs; }
+const GPUCalibObjectsConst& GPUReconstruction::GetCalib() const { return processors()->calibObjects; }
 
 ThrustVolatileAllocator::ThrustVolatileAllocator(GPUReconstruction* r)
 {
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 23fb6e4d9ff06..b6256f7f8ad82 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -25,13 +25,13 @@
 #include <unordered_map>
 #include <unordered_set>
 
-#include "GPUTRDDef.h"
-#include "GPUParam.h"
-#include "GPUSettings.h"
-#include "GPUOutputControl.h"
+#include "GPUDataTypes.h"
 #include "GPUMemoryResource.h"
-#include "GPUConstantMem.h"
-#include "GPULogging.h"
+#include "GPUOutputControl.h"
+
+/*#include "GPUParam.h"
+#include "GPUSettings.h"
+#include "GPULogging.h"*/
 
 namespace o2::its
 {
@@ -49,6 +49,13 @@ struct GPUReconstructionThreading;
 class GPUROOTDumpCore;
 class ThrustVolatileAllocator;
 struct GPUDefParameters;
+class GPUMemoryResource;
+struct GPUSettingsDeviceBackend;
+struct GPUSettingsGRP;
+struct GPUSettingsProcessing;
+struct GPUSettingsRec;
+struct GPUSettingsRecDynamic;
+struct GPUMemoryReuse;
 
 namespace gpu_reconstruction_kernels
 {
@@ -186,18 +193,20 @@ class GPUReconstruction
   bool slavesExist() { return mSlaves.size() || mMaster; }
 
   // Getters / setters for parameters
-  DeviceType GetDeviceType() const { return (DeviceType)mDeviceBackendSettings.deviceType; }
+  DeviceType GetDeviceType() const;
   bool IsGPU() const { return GetDeviceType() != DeviceType::INVALID_DEVICE && GetDeviceType() != DeviceType::CPU; }
-  const GPUParam& GetParam() const { return mHostConstantMem->param; }
+  const GPUParam& GetParam() const;
   const GPUConstantMem& GetConstantMem() const { return *mHostConstantMem; }
-  const GPUSettingsGRP& GetGRPSettings() const { return mGRPSettings; }
-  const GPUSettingsDeviceBackend& GetDeviceBackendSettings() { return mDeviceBackendSettings; }
-  const GPUSettingsProcessing& GetProcessingSettings() const { return mProcessingSettings; }
+  const GPUTrackingInOutPointers GetIOPtrs() const;
+  const GPUSettingsGRP& GetGRPSettings() const { return *mGRPSettings; }
+  const GPUSettingsDeviceBackend& GetDeviceBackendSettings() const { return *mDeviceBackendSettings; }
+  const GPUSettingsProcessing& GetProcessingSettings() const { return *mProcessingSettings; }
+  const GPUCalibObjectsConst& GetCalib() const;
   bool IsInitialized() const { return mInitialized; }
   void SetSettings(float solenoidBzNominalGPU, const GPURecoStepConfiguration* workflow = nullptr);
   void SetSettings(const GPUSettingsGRP* grp, const GPUSettingsRec* rec = nullptr, const GPUSettingsProcessing* proc = nullptr, const GPURecoStepConfiguration* workflow = nullptr);
-  void SetResetTimers(bool reset) { mProcessingSettings.resetTimers = reset; }     // May update also after Init()
-  void SetDebugLevelTmp(int32_t level) { mProcessingSettings.debugLevel = level; } // Temporarily, before calling SetSettings()
+  void SetResetTimers(bool reset);      // May update also after Init()
+  void SetDebugLevelTmp(int32_t level); // Temporarily, before calling SetSettings()
   void UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p = nullptr, const GPUSettingsRecDynamic* d = nullptr);
   void UpdateDynamicSettings(const GPUSettingsRecDynamic* d);
   void SetOutputControl(const GPUOutputControl& v) { mOutputControl = v; }
@@ -272,6 +281,7 @@ class GPUReconstruction
   size_t ReadData(FILE* fp, const T** entries, S* num, std::unique_ptr<T[]>* mem, InOutPointerType type, T** nonConstPtrs = nullptr);
   template <class T>
   T* AllocateIOMemoryHelper(size_t n, const T*& ptr, std::unique_ptr<T[]>& u);
+  int16_t RegisterMemoryAllocationHelper(GPUProcessor* proc, void* (GPUProcessor::*setPtr)(void*), int32_t type, const char* name, const GPUMemoryReuse& re);
 
   // Private helper functions to dump / load flat objects
   template <class T>
@@ -292,17 +302,17 @@ class GPUReconstruction
   // Pointers to tracker classes
   GPUConstantMem* processors() { return mHostConstantMem.get(); }
   const GPUConstantMem* processors() const { return mHostConstantMem.get(); }
-  GPUParam& param() { return mHostConstantMem->param; }
+  GPUParam& param();
   std::unique_ptr<GPUConstantMem> mHostConstantMem;
   GPUConstantMem* mDeviceConstantMem = nullptr;
 
   // Settings
-  GPUSettingsGRP mGRPSettings;                          // Global Run Parameters
-  GPUSettingsDeviceBackend mDeviceBackendSettings;      // Processing Parameters (at constructor level)
-  GPUSettingsProcessing mProcessingSettings;            // Processing Parameters (at init level)
-  GPUOutputControl mOutputControl;                      // Controls the output of the individual components
-  GPUOutputControl mInputControl;                       // Prefefined input memory location for reading standalone dumps
-  std::unique_ptr<GPUMemorySizeScalers> mMemoryScalers; // Scalers how much memory will be needed
+  std::unique_ptr<GPUSettingsGRP> mGRPSettings;                     // Global Run Parameters
+  std::unique_ptr<GPUSettingsDeviceBackend> mDeviceBackendSettings; // Processing Parameters (at constructor level)
+  std::unique_ptr<GPUSettingsProcessing> mProcessingSettings;       // Processing Parameters (at init level)
+  GPUOutputControl mOutputControl;                                  // Controls the output of the individual components
+  GPUOutputControl mInputControl;                                   // Prefefined input memory location for reading standalone dumps
+  std::unique_ptr<GPUMemorySizeScalers> mMemoryScalers;             // Scalers how much memory will be needed
 
   GPURecoStepConfiguration mRecoSteps;
 
@@ -392,35 +402,6 @@ class GPUReconstruction
   static GPUReconstruction* GPUReconstruction_Create_CPU(const GPUSettingsDeviceBackend& cfg);
 };
 
-template <class T>
-inline T* GPUReconstruction::AllocateIOMemoryHelper(size_t n, const T*& ptr, std::unique_ptr<T[]>& u)
-{
-  if (n == 0) {
-    u.reset(nullptr);
-    return nullptr;
-  }
-  T* retVal;
-  if (mInputControl.useExternal()) {
-    u.reset(nullptr);
-    mInputControl.checkCurrent();
-    GPUProcessor::computePointerWithAlignment(mInputControl.ptrCurrent, retVal, n);
-    if ((size_t)((char*)mInputControl.ptrCurrent - (char*)mInputControl.ptrBase) > mInputControl.size) {
-      throw std::bad_alloc();
-    }
-  } else {
-    u.reset(new T[n]);
-    retVal = u.get();
-    if (mProcessingSettings.registerStandaloneInputMemory) {
-      if (registerMemoryForGPU(u.get(), n * sizeof(T))) {
-        GPUError("Error registering memory for GPU: %p - %ld bytes\n", (void*)u.get(), (int64_t)(n * sizeof(T)));
-        throw std::bad_alloc();
-      }
-    }
-  }
-  ptr = retVal;
-  return retVal;
-}
-
 template <class T, typename... Args>
 inline T* GPUReconstruction::AddChain(Args... args)
 {
@@ -431,31 +412,7 @@ inline T* GPUReconstruction::AddChain(Args... args)
 template <class T>
 inline int16_t GPUReconstruction::RegisterMemoryAllocation(T* proc, void* (T::*setPtr)(void*), int32_t type, const char* name, const GPUMemoryReuse& re)
 {
-  if (!(type & (GPUMemoryResource::MEMORY_HOST | GPUMemoryResource::MEMORY_GPU))) {
-    if ((type & GPUMemoryResource::MEMORY_SCRATCH) && !mProcessingSettings.keepDisplayMemory) { // keepAllMemory --> keepDisplayMemory
-      type |= (proc->mGPUProcessorType == GPUProcessor::PROCESSOR_TYPE_CPU ? GPUMemoryResource::MEMORY_HOST : GPUMemoryResource::MEMORY_GPU);
-    } else {
-      type |= GPUMemoryResource::MEMORY_HOST | GPUMemoryResource::MEMORY_GPU;
-    }
-  }
-  if (proc->mGPUProcessorType == GPUProcessor::PROCESSOR_TYPE_CPU) {
-    type &= ~GPUMemoryResource::MEMORY_GPU;
-  }
-  mMemoryResources.emplace_back(proc, static_cast<void* (GPUProcessor::*)(void*)>(setPtr), (GPUMemoryResource::MemoryType)type, name);
-  if (mMemoryResources.size() >= 32768) {
-    throw std::bad_alloc();
-  }
-  uint16_t retVal = mMemoryResources.size() - 1;
-  if (re.type != GPUMemoryReuse::NONE && !mProcessingSettings.disableMemoryReuse) {
-    const auto& it = mMemoryReuse1to1.find(re.id);
-    if (it == mMemoryReuse1to1.end()) {
-      mMemoryReuse1to1[re.id] = {proc, retVal};
-    } else {
-      mMemoryResources[retVal].mReuse = it->second.res[0];
-      it->second.res.emplace_back(retVal);
-    }
-  }
-  return retVal;
+  return RegisterMemoryAllocationHelper(proc, static_cast<void* (GPUProcessor::*)(void*)>(setPtr), type, name, re);
 }
 
 template <class T>
@@ -471,7 +428,7 @@ inline void GPUReconstruction::SetupGPUProcessor(T* proc, bool allocate)
 {
   static_assert(sizeof(T) > sizeof(GPUProcessor), "Need to setup derived class");
   if (allocate) {
-    proc->SetMaxData(mHostConstantMem->ioPtrs);
+    proc->SetMaxData(GetIOPtrs());
   }
   if (proc->mGPUProcessorType != GPUProcessor::PROCESSOR_TYPE_DEVICE && proc->mLinkedProcessor) {
     std::memcpy((void*)proc->mLinkedProcessor, (const void*)proc, sizeof(*proc));
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 39507beda8a55..2453ce4a2328f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -30,19 +30,18 @@
 #include "GPUTRDTrackletLabels.h"
 #include "GPUMemoryResource.h"
 #include "GPUConstantMem.h"
+#include "GPULogging.h"
 #include "GPUMemorySizeScalers.h"
+#include "GPUReconstructionProcessingKernels.inc"
+
 #include <atomic>
 #include <ctime>
 
-#define GPUCA_LOGGING_PRINTF
-#include "GPULogging.h"
-
 #ifndef _WIN32
 #include <unistd.h>
 #endif
 
 using namespace o2::gpu;
-using namespace o2::gpu::gpu_reconstruction_kernels;
 
 constexpr GPUReconstructionCPU::krnlRunRange GPUReconstructionCPU::krnlRunRangeNone;
 constexpr GPUReconstructionCPU::krnlEvent GPUReconstructionCPU::krnlEventNone;
@@ -55,7 +54,7 @@ GPUReconstructionCPU::~GPUReconstructionCPU()
 }
 
 template <class T, int32_t I, typename... Args>
-inline void GPUReconstructionCPUBackend::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
+inline void GPUReconstructionCPU::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
 {
   auto& x = _xyz.x;
   auto& y = _xyz.y;
@@ -67,7 +66,7 @@ inline void GPUReconstructionCPUBackend::runKernelBackendInternal(const krnlSetu
   }
   int32_t nThreads = getNKernelHostThreads(false);
   if (nThreads > 1) {
-    if (mProcessingSettings.debugLevel >= 5) {
+    if (GetProcessingSettings().debugLevel >= 5) {
       printf("Running %d Threads\n", mThreading->activeThreads->max_concurrency());
     }
     tbb::this_task_arena::isolate([&] {
@@ -89,7 +88,7 @@ inline void GPUReconstructionCPUBackend::runKernelBackendInternal(const krnlSetu
 }
 
 template <>
-inline void GPUReconstructionCPUBackend::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
+inline void GPUReconstructionCPU::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
   int32_t nThreads = std::max<int32_t>(1, std::min<int32_t>(size / (16 * 1024 * 1024), getNKernelHostThreads(true)));
   if (nThreads > 1) {
@@ -110,7 +109,7 @@ inline void GPUReconstructionCPUBackend::runKernelBackendInternal<GPUMemClean16,
 }
 
 template <class T, int32_t I, typename... Args>
-void GPUReconstructionCPUBackend::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
+void GPUReconstructionCPU::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
 {
 #pragma GCC diagnostic push
 #if defined(__clang__)
@@ -121,14 +120,14 @@ void GPUReconstructionCPUBackend::runKernelBackend(const krnlSetupArgs<T, I, Arg
 }
 
 template <class S, int32_t I>
-gpu_reconstruction_kernels::krnlProperties GPUReconstructionCPU::getKernelProperties(int gpu)
+GPUReconstructionProcessing::krnlProperties GPUReconstructionCPU::getKernelProperties(int gpu)
 {
   if (gpu == -1) {
     gpu = IsGPU();
   }
   const auto num = GetKernelNum<S, I>();
   const auto* p = gpu ? mParDevice : mParCPU;
-  gpu_reconstruction_kernels::krnlProperties ret = {p->par_LB_maxThreads[num], p->par_LB_minBlocks[num], p->par_LB_forceBlocks[num]};
+  GPUReconstructionProcessing::krnlProperties ret = {p->par_LB_maxThreads[num], p->par_LB_minBlocks[num], p->par_LB_forceBlocks[num]};
   if (ret.nThreads == 0) {
     ret.nThreads = gpu ? mThreadCount : 1u;
   }
@@ -138,9 +137,9 @@ gpu_reconstruction_kernels::krnlProperties GPUReconstructionCPU::getKernelProper
   return ret;
 }
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)                                                                                                  \
-  template void GPUReconstructionCPUBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args); \
-  template krnlProperties GPUReconstructionCPU::getKernelProperties<GPUCA_M_KRNL_TEMPLATE(x_class)>(int gpu);
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)                                                                                           \
+  template void GPUReconstructionCPU::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args); \
+  template GPUReconstructionProcessing::krnlProperties GPUReconstructionCPU::getKernelProperties<GPUCA_M_KRNL_TEMPLATE(x_class)>(int gpu);
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
 
@@ -169,7 +168,7 @@ size_t GPUReconstructionCPU::TransferMemoryResourcesHelper(GPUProcessor* proc, i
     if (!(res.mType & GPUMemoryResource::MEMORY_GPU) || (res.mType & GPUMemoryResource::MEMORY_CUSTOM_TRANSFER)) {
       continue;
     }
-    if (!mProcessingSettings.keepAllMemory && !all && (res.mType & exc) && !(res.mType & inc)) {
+    if (!GetProcessingSettings().keepAllMemory && !all && (res.mType & exc) && !(res.mType & inc)) {
       continue;
     }
     if (toGPU) {
@@ -197,7 +196,7 @@ int32_t GPUReconstructionCPU::InitDevice()
 {
   mActiveHostKernelThreads = mMaxHostThreads;
   mThreading->activeThreads = std::make_unique<tbb::task_arena>(mActiveHostKernelThreads);
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     if (mMaster == nullptr) {
       if (mDeviceMemorySize > mHostMemorySize) {
         mHostMemorySize = mDeviceMemorySize;
@@ -207,7 +206,7 @@ int32_t GPUReconstructionCPU::InitDevice()
     mHostMemoryPermanent = mHostMemoryBase;
     ClearAllocatedMemory();
   }
-  if (mProcessingSettings.inKernelParallel) {
+  if (GetProcessingSettings().inKernelParallel) {
     mBlockCount = mMaxHostThreads;
   }
   mProcShadow.mProcessorsProc = processors();
@@ -216,7 +215,7 @@ int32_t GPUReconstructionCPU::InitDevice()
 
 int32_t GPUReconstructionCPU::ExitDevice()
 {
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     if (mMaster == nullptr) {
       operator delete(mHostMemoryBase, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
     }
@@ -232,13 +231,13 @@ int32_t GPUReconstructionCPU::RunChains()
   mStatNEvents++;
   mNEventsProcessed++;
 
-  if (mProcessingSettings.debugLevel >= 3 || mProcessingSettings.allocDebugLevel) {
+  if (GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) {
     printf("Allocated memory when starting processing %34s", "");
     PrintMemoryOverview();
   }
   mTimerTotal.Start();
   const std::clock_t cpuTimerStart = std::clock();
-  if (mProcessingSettings.doublePipeline) {
+  if (GetProcessingSettings().doublePipeline) {
     int32_t retVal = EnqueuePipeline();
     if (retVal) {
       return retVal;
@@ -259,7 +258,7 @@ int32_t GPUReconstructionCPU::RunChains()
   }
   mTimerTotal.Stop();
   mStatCPUTime += (double)(std::clock() - cpuTimerStart) / CLOCKS_PER_SEC;
-  if (mProcessingSettings.debugLevel >= 3 || mProcessingSettings.allocDebugLevel) {
+  if (GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) {
     printf("Allocated memory when ending processing %36s", "");
     PrintMemoryOverview();
   }
@@ -281,7 +280,7 @@ int32_t GPUReconstructionCPU::RunChains()
       for (int32_t j = 0; j < mTimers[i]->num; j++) {
         HighResTimer& timer = mTimers[i]->timer[j];
         time += timer.GetElapsedTime();
-        if (mProcessingSettings.resetTimers) {
+        if (GetProcessingSettings().resetTimers) {
           timer.Reset();
         }
       }
@@ -297,7 +296,7 @@ int32_t GPUReconstructionCPU::RunChains()
         snprintf(bandwidth, 256, " (%8.3f GB/s - %'14zu bytes - %'14zu per call)", mTimers[i]->memSize / time * 1e-9, mTimers[i]->memSize / mStatNEvents, mTimers[i]->memSize / mStatNEvents / mTimers[i]->count);
       }
       printf("Execution Time: Task (%c %8ux): %50s Time: %'10.0f us%s\n", type == 0 ? 'K' : 'C', mTimers[i]->count, mTimers[i]->name.c_str(), time * 1000000 / mStatNEvents, bandwidth);
-      if (mProcessingSettings.resetTimers) {
+      if (GetProcessingSettings().resetTimers) {
         mTimers[i]->count = 0;
         mTimers[i]->memSize = 0;
       }
@@ -317,7 +316,7 @@ int32_t GPUReconstructionCPU::RunChains()
         printf("Execution Time: Step (D %8ux): %11s %38s Time: %'10.0f us (%8.3f GB/s - %'14zu bytes - %'14zu per call)\n", mTimersRecoSteps[i].countToHost, "DMA to Host", GPUDataTypes::RECO_STEP_NAMES[i], mTimersRecoSteps[i].timerToHost.GetElapsedTime() * 1000000 / mStatNEvents,
                mTimersRecoSteps[i].bytesToHost / mTimersRecoSteps[i].timerToHost.GetElapsedTime() * 1e-9, mTimersRecoSteps[i].bytesToHost / mStatNEvents, mTimersRecoSteps[i].bytesToHost / mTimersRecoSteps[i].countToHost);
       }
-      if (mProcessingSettings.resetTimers) {
+      if (GetProcessingSettings().resetTimers) {
         mTimersRecoSteps[i].bytesToGPU = mTimersRecoSteps[i].bytesToHost = 0;
         mTimersRecoSteps[i].timerToGPU.Reset();
         mTimersRecoSteps[i].timerToHost.Reset();
@@ -340,7 +339,7 @@ int32_t GPUReconstructionCPU::RunChains()
   } else if (GetProcessingSettings().debugLevel >= 0) {
     GPUInfo("Total Wall Time: %10.0f us%s", mStatWallTime, nEventReport.c_str());
   }
-  if (mProcessingSettings.resetTimers) {
+  if (GetProcessingSettings().resetTimers) {
     mStatNEvents = 0;
     mStatCPUTime = 0;
     mTimerTotal.Reset();
@@ -366,7 +365,7 @@ void GPUReconstructionCPU::UpdateParamOccupancyMap(const uint32_t* mapHost, cons
     if (!((size_t)&param().occupancyTotal - (size_t)&param().occupancyMap == sizeof(param().occupancyMap) && sizeof(param().occupancyMap) == sizeof(size_t) && sizeof(param().occupancyTotal) < sizeof(size_t))) {
       throw std::runtime_error("occupancy data not consecutive in GPUParam");
     }
-    const auto threadContext = GetThreadContext();
+    const auto holdContext = GetThreadContext();
     size_t tmp[2] = {(size_t)mapGPU, 0};
     memcpy(&tmp[1], &occupancyTotal, sizeof(occupancyTotal));
     WriteToConstantMemory((char*)&processors()->param.occupancyMap - (char*)processors(), &tmp, sizeof(param().occupancyMap) + sizeof(param().occupancyTotal), stream);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index b37bf2b75f01c..d0d8b05c4af0e 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -16,14 +16,9 @@
 #define GPURECONSTRUCTIONICPU_H
 
 #include "GPUReconstructionProcessing.h"
-#include "GPUConstantMem.h"
 #include <stdexcept>
 #include <vector>
 
-#include "GPUGeneralKernels.h"
-#include "GPUReconstructionKernelIncludes.h"
-#include "GPUReconstructionKernels.h"
-
 namespace Ort
 {
 struct SessionOptions;
@@ -32,20 +27,7 @@ struct SessionOptions;
 namespace o2::gpu
 {
 
-class GPUReconstructionCPUBackend : public GPUReconstructionProcessing
-{
- public:
-  ~GPUReconstructionCPUBackend() override = default;
-
- protected:
-  GPUReconstructionCPUBackend(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionProcessing(cfg) {}
-  template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackend(const gpu_reconstruction_kernels::krnlSetupArgs<T, I, Args...>& args);
-  template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackendInternal(const gpu_reconstruction_kernels::krnlSetupTime& _xyz, const Args&... args);
-};
-
-class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCPUBackend>
+class GPUReconstructionCPU : public GPUReconstructionProcessing::KernelInterface<GPUReconstructionCPU, GPUReconstructionProcessing>
 {
   friend GPUReconstruction* GPUReconstruction::GPUReconstruction_Create_CPU(const GPUSettingsDeviceBackend& cfg);
   friend class GPUChain;
@@ -55,10 +37,10 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
   static constexpr krnlRunRange krnlRunRangeNone{0};
   static constexpr krnlEvent krnlEventNone = krnlEvent{nullptr, nullptr, 0};
 
-  template <class S, int32_t I = 0, typename... Args>
-  void runKernel(krnlSetup&& setup, Args&&... args);
   template <class S, int32_t I = 0>
-  gpu_reconstruction_kernels::krnlProperties getKernelProperties(int gpu = -1);
+  krnlProperties getKernelProperties(int gpu = -1);
+  template <class T, int32_t I = 0, typename... Args>
+  void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
 
   virtual int32_t GPUDebug(const char* state = "UNKNOWN", int32_t stream = -1, bool force = false);
   int32_t GPUStuck() { return mGPUStuck; }
@@ -75,21 +57,10 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
     int16_t mMemoryResProcessors = -1;
   };
 
-  GPUReconstructionCPU(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionKernels(cfg) {}
-
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)                                                                                                              \
-  inline void runKernelImplWrapper(gpu_reconstruction_kernels::classArgument<GPUCA_M_KRNL_TEMPLATE(x_class)>, bool cpuFallback, double& timer, krnlSetup&& setup GPUCA_M_STRIP(x_arguments)) \
-  {                                                                                                                                                                                          \
-    krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)> args(setup.x, setup.y, setup.z, timer GPUCA_M_STRIP(x_forward));                                                    \
-    const uint32_t num = GetKernelNum<GPUCA_M_KRNL_TEMPLATE(x_class)>();                                                                                                                     \
-    if (cpuFallback) {                                                                                                                                                                       \
-      GPUReconstructionCPU::runKernelImpl(num, &args);                                                                                                                                       \
-    } else {                                                                                                                                                                                 \
-      runKernelImpl(num, &args);                                                                                                                                                             \
-    }                                                                                                                                                                                        \
-  }
-#include "GPUReconstructionKernelList.h"
-#undef GPUCA_KRNL
+  GPUReconstructionCPU(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionProcessing::KernelInterface<GPUReconstructionCPU, GPUReconstructionProcessing>(cfg) {}
+
+  template <class T, int32_t I = 0, typename... Args>
+  void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
 
   int32_t registerMemoryForGPU_internal(const void* ptr, size_t size) override { return 0; }
   int32_t unregisterMemoryForGPU_internal(const void* ptr) override { return 0; }
@@ -132,72 +103,10 @@ class GPUReconstructionCPU : public GPUReconstructionKernels<GPUReconstructionCP
 
  private:
   size_t TransferMemoryResourcesHelper(GPUProcessor* proc, int32_t stream, bool all, bool toGPU);
+  template <class S, int32_t I = 0, typename... Args>
+  void runKernelInterface(krnlSetup&& setup, Args const&... args);
 };
 
-template <class S, int32_t I, typename... Args>
-inline void GPUReconstructionCPU::runKernel(krnlSetup&& setup, Args&&... args)
-{
-  HighResTimer* t = nullptr;
-  GPUDataTypes::RecoStep myStep = S::GetRecoStep() == GPUDataTypes::RecoStep::NoRecoStep ? setup.x.step : S::GetRecoStep();
-  if (myStep == GPUDataTypes::RecoStep::NoRecoStep) {
-    throw std::runtime_error("Failure running general kernel without defining RecoStep");
-  }
-  int32_t cpuFallback = IsGPU() ? (setup.x.device == krnlDeviceType::CPU ? 2 : (mRecoSteps.stepsGPUMask & myStep) != myStep) : 0;
-  uint32_t& nThreads = setup.x.nThreads;
-  uint32_t& nBlocks = setup.x.nBlocks;
-  const uint32_t stream = setup.x.stream;
-  auto prop = getKernelProperties<S, I>();
-  const int32_t autoThreads = cpuFallback ? 1 : prop.nThreads;
-  const int32_t autoBlocks = cpuFallback ? 1 : (prop.forceBlocks ? prop.forceBlocks : (prop.minBlocks * mBlockCount));
-  if (nBlocks == (uint32_t)-1) {
-    nBlocks = (nThreads + autoThreads - 1) / autoThreads;
-    nThreads = autoThreads;
-  } else if (nBlocks == (uint32_t)-2) {
-    nBlocks = nThreads;
-    nThreads = autoThreads;
-  } else if (nBlocks == (uint32_t)-3) {
-    nBlocks = autoBlocks;
-    nThreads = autoThreads;
-  } else if ((int32_t)nThreads < 0) {
-    nThreads = cpuFallback ? 1 : -nThreads;
-  }
-  if (nThreads > GPUCA_MAX_THREADS) {
-    throw std::runtime_error("GPUCA_MAX_THREADS exceeded");
-  }
-  if (mProcessingSettings.debugLevel >= 3) {
-    GPUInfo("Running kernel %s (Stream %d, Index %d, Grid %d/%d) on %s", GetKernelName<S, I>(), stream, setup.y.index, nBlocks, nThreads, cpuFallback == 2 ? "CPU (forced)" : cpuFallback ? "CPU (fallback)" : mDeviceName.c_str());
-  }
-  if (nThreads == 0 || nBlocks == 0) {
-    return;
-  }
-  if (mProcessingSettings.debugLevel >= 1) {
-    t = &getKernelTimer<S, I>(myStep, !IsGPU() || cpuFallback ? getHostThreadIndex() : stream);
-    if ((!mProcessingSettings.deviceTimers || !IsGPU() || cpuFallback) && (mNActiveThreadsOuterLoop < 2 || getHostThreadIndex() == 0)) {
-      t->Start();
-    }
-  }
-  double deviceTimerTime = 0.;
-  runKernelImplWrapper(gpu_reconstruction_kernels::classArgument<S, I>(), cpuFallback, deviceTimerTime, std::forward<krnlSetup&&>(setup), std::forward<Args>(args)...);
-  if (GPUDebug(GetKernelName<S, I>(), stream, mProcessingSettings.serializeGPU & 1)) {
-    throw std::runtime_error("kernel failure");
-  }
-  if (mProcessingSettings.debugLevel >= 1) {
-    if (t) {
-      if (deviceTimerTime != 0.) {
-        t->AddTime(deviceTimerTime);
-        if (t->IsRunning()) {
-          t->Abort();
-        }
-      } else if (t->IsRunning()) {
-        t->Stop();
-      }
-    }
-    if (CheckErrorCodes(cpuFallback) && !mProcessingSettings.ignoreNonFatalGPUErrors) {
-      throw std::runtime_error("kernel error code");
-    }
-  }
-}
-
 } // namespace o2::gpu
 
 #endif
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h b/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
new file mode 100644
index 0000000000000..837516a93b6ae
--- /dev/null
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
@@ -0,0 +1,98 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUReconstructionCPUKernels.h
+/// \author David Rohr
+
+#ifndef GPURECONSTRUCTIONICPUKERNELS_H
+#define GPURECONSTRUCTIONICPUKERNELS_H
+
+#include "GPUReconstructionCPU.h"
+#include "GPUSettings.h"
+#include "GPULogging.h"
+
+namespace o2::gpu
+{
+
+template <class S, int32_t I, typename... Args>
+inline void GPUReconstructionCPU::runKernelInterface(krnlSetup&& setup, Args const&... args)
+{
+  HighResTimer* t = nullptr;
+  GPUDataTypes::RecoStep myStep = S::GetRecoStep() == GPUDataTypes::RecoStep::NoRecoStep ? setup.x.step : S::GetRecoStep();
+  if (myStep == GPUDataTypes::RecoStep::NoRecoStep) {
+    throw std::runtime_error("Failure running general kernel without defining RecoStep");
+  }
+  int32_t cpuFallback = IsGPU() ? (setup.x.device == krnlDeviceType::CPU ? 2 : (mRecoSteps.stepsGPUMask & myStep) != myStep) : 0;
+  uint32_t& nThreads = setup.x.nThreads;
+  uint32_t& nBlocks = setup.x.nBlocks;
+  const uint32_t stream = setup.x.stream;
+  auto prop = getKernelProperties<S, I>();
+  const int32_t autoThreads = cpuFallback ? 1 : prop.nThreads;
+  const int32_t autoBlocks = cpuFallback ? 1 : (prop.forceBlocks ? prop.forceBlocks : (prop.minBlocks * mBlockCount));
+  if (nBlocks == (uint32_t)-1) {
+    nBlocks = (nThreads + autoThreads - 1) / autoThreads;
+    nThreads = autoThreads;
+  } else if (nBlocks == (uint32_t)-2) {
+    nBlocks = nThreads;
+    nThreads = autoThreads;
+  } else if (nBlocks == (uint32_t)-3) {
+    nBlocks = autoBlocks;
+    nThreads = autoThreads;
+  } else if ((int32_t)nThreads < 0) {
+    nThreads = cpuFallback ? 1 : -nThreads;
+  }
+  if (nThreads > GPUCA_MAX_THREADS) {
+    throw std::runtime_error("GPUCA_MAX_THREADS exceeded");
+  }
+  if (GetProcessingSettings().debugLevel >= 3) {
+    GPUInfo("Running kernel %s (Stream %d, Index %d, Grid %d/%d) on %s", GetKernelName<S, I>(), stream, setup.y.index, nBlocks, nThreads, cpuFallback == 2 ? "CPU (forced)" : (cpuFallback ? "CPU (fallback)" : mDeviceName.c_str()));
+  }
+  if (nThreads == 0 || nBlocks == 0) {
+    return;
+  }
+  if (GetProcessingSettings().debugLevel >= 1) {
+    t = &getKernelTimer<S, I>(myStep, !IsGPU() || cpuFallback ? getHostThreadIndex() : stream);
+    if ((!GetProcessingSettings().deviceTimers || !IsGPU() || cpuFallback) && (mNActiveThreadsOuterLoop < 2 || getHostThreadIndex() == 0)) {
+      t->Start();
+    }
+  }
+  double deviceTimerTime = 0.;
+  krnlSetupArgs<S, I, Args...> argPack{{}, {{setup.x, setup.y, setup.z}, deviceTimerTime}, {args...}};
+  const uint32_t num = GetKernelNum<S, I>();
+  if (cpuFallback) {
+    GPUReconstructionCPU::runKernelVirtual(num, &argPack);
+  } else {
+    runKernelVirtual(num, &argPack);
+  }
+
+  if (GPUDebug(GetKernelName<S, I>(), stream, GetProcessingSettings().serializeGPU & 1)) {
+    throw std::runtime_error("kernel failure");
+  }
+  if (GetProcessingSettings().debugLevel >= 1) {
+    if (t) {
+      if (deviceTimerTime != 0.) {
+        t->AddTime(deviceTimerTime);
+        if (t->IsRunning()) {
+          t->Abort();
+        }
+      } else if (t->IsRunning()) {
+        t->Stop();
+      }
+    }
+    if (CheckErrorCodes(cpuFallback) && !GetProcessingSettings().ignoreNonFatalGPUErrors) {
+      throw std::runtime_error("kernel error code");
+    }
+  }
+}
+
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
index e12ca7ec601ad..2dec88393f632 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
@@ -25,7 +25,7 @@
 #include "GPUO2DataTypes.h"
 #include "GPUDataTypes.h"
 #include "GPUTPCGeometry.h"
-#include "AliHLTTPCRawCluster.h"
+#include "AliHLTTPCRawCluster.h" // TODO: Is this still needed at all, or can it be removed?
 #include "GPUParam.h"
 #include "GPULogging.h"
 #include <algorithm>
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
index b389e99a0b2bb..9962bdf3922c1 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
@@ -14,6 +14,7 @@
 
 #include "GPUReconstructionDeviceBase.h"
 #include "GPUReconstructionIncludes.h"
+#include "GPUConstantMem.h"
 
 #include "GPUTPCTracker.h"
 
@@ -93,21 +94,21 @@ int32_t GPUReconstructionDeviceBase::InitDevice()
   // CPU_SET(0, &mask);
   // sched_setaffinity(0, sizeof(mask), &mask);
 
-  if (mProcessingSettings.memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
+  if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
     GPUError("Individual memory allocation strategy unsupported for device\n");
     return (1);
   }
-  if (mProcessingSettings.nStreams > GPUCA_MAX_STREAMS) {
-    GPUError("Too many straems requested %d > %d\n", mProcessingSettings.nStreams, GPUCA_MAX_STREAMS);
+  if (GetProcessingSettings().nStreams > GPUCA_MAX_STREAMS) {
+    GPUError("Too many straems requested %d > %d\n", GetProcessingSettings().nStreams, GPUCA_MAX_STREAMS);
     return (1);
   }
 
   void* semLock = nullptr;
-  if (mProcessingSettings.globalInitMutex && GetGlobalLock(semLock)) {
+  if (GetProcessingSettings().globalInitMutex && GetGlobalLock(semLock)) {
     return (1);
   }
 
-  if (mProcessingSettings.deviceTimers) {
+  if (GetProcessingSettings().deviceTimers) {
     AddGPUEvents(mDebugEvents);
   }
 
@@ -117,7 +118,7 @@ int32_t GPUReconstructionDeviceBase::InitDevice()
     return (1);
   }
 
-  if (mProcessingSettings.globalInitMutex) {
+  if (GetProcessingSettings().globalInitMutex) {
     ReleaseGlobalLock(semLock);
   }
 
@@ -129,7 +130,7 @@ int32_t GPUReconstructionDeviceBase::InitDevice()
   mProcShadow.mMemoryResProcessors = RegisterMemoryAllocation(&mProcShadow, &GPUProcessorProcessors::SetPointersDeviceProcessor, GPUMemoryResource::MEMORY_PERMANENT | GPUMemoryResource::MEMORY_HOST, "Processors");
   AllocateRegisteredMemory(mProcShadow.mMemoryResProcessors);
 
-  if (mMaster == nullptr || mProcessingSettings.debugLevel >= 2) {
+  if (mMaster == nullptr || GetProcessingSettings().debugLevel >= 2) {
     GPUInfo("GPU Tracker initialization successfull"); // Verbosity reduced because GPU backend will print GPUImportant message!
   }
 
@@ -186,13 +187,15 @@ void GPUReconstructionDeviceBase::runConstantRegistrators()
 size_t GPUReconstructionDeviceBase::TransferMemoryInternal(GPUMemoryResource* res, int32_t stream, deviceEvent* ev, deviceEvent* evList, int32_t nEvents, bool toGPU, const void* src, void* dst)
 {
   if (!(res->Type() & GPUMemoryResource::MEMORY_GPU)) {
-    if (mProcessingSettings.debugLevel >= 4) {
+    if (GetProcessingSettings().debugLevel >= 4) {
       GPUInfo("Skipped transfer of non-GPU memory resource: %s", res->Name());
     }
     return 0;
   }
-  if (mProcessingSettings.debugLevel >= 3 && (strcmp(res->Name(), "ErrorCodes") || mProcessingSettings.debugLevel >= 4)) {
+  if (GetProcessingSettings().debugLevel >= 3 && (strcmp(res->Name(), "ErrorCodes") || GetProcessingSettings().debugLevel >= 4)) {
     GPUInfo("Copying to %s: %s - %ld bytes", toGPU ? "GPU" : "Host", res->Name(), (int64_t)res->Size());
   }
   return GPUMemCpy(dst, src, res->Size(), stream, toGPU, ev, evList, nEvents);
 }
+
+const GPUParam* GPUReconstructionDeviceBase::DeviceParam() const { return &mDeviceConstantMem->param; }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
index f0e19f588e0f1..c8288f978f6ae 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.h
@@ -22,16 +22,12 @@
 
 namespace o2::gpu
 {
-#if !(defined(__CLING__) || defined(__ROOTCLING__) || defined(G__ROOT))
-extern template class GPUReconstructionKernels<GPUReconstructionCPUBackend>;
-#endif
-
 class GPUReconstructionDeviceBase : public GPUReconstructionCPU
 {
  public:
   ~GPUReconstructionDeviceBase() override;
 
-  const GPUParam* DeviceParam() const { return &mDeviceConstantMem->param; }
+  const GPUParam* DeviceParam() const;
   struct deviceConstantMemRegistration {
     deviceConstantMemRegistration(void* (*reg)())
     {
@@ -51,8 +47,6 @@ class GPUReconstructionDeviceBase : public GPUReconstructionCPU
   int32_t unregisterMemoryForGPU_internal(const void* ptr) override;
   void unregisterRemainingRegisteredMemory();
 
-  virtual const GPUTPCTracker* CPUTracker(int32_t iSector) { return &processors()->tpcTrackers[iSector]; }
-
   int32_t GPUDebug(const char* state = "UNKNOWN", int32_t stream = -1, bool force = false) override = 0;
   size_t TransferMemoryInternal(GPUMemoryResource* res, int32_t stream, deviceEvent* ev, deviceEvent* evList, int32_t nEvents, bool toGPU, const void* src, void* dst) override;
   size_t GPUMemCpy(void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev = nullptr, deviceEvent* evList = nullptr, int32_t nEvents = 1) override = 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIO.h b/GPU/GPUTracking/Base/GPUReconstructionIO.h
index 2208c15846e09..810ebfffe1703 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIO.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIO.h
@@ -16,10 +16,40 @@
 #define GPURECONSTRUCTIONIO_H
 
 #include "GPUReconstruction.h"
+#include "GPUSettings.h"
 
 namespace o2::gpu
 {
 
+template <class T>
+inline T* GPUReconstruction::AllocateIOMemoryHelper(size_t n, const T*& ptr, std::unique_ptr<T[]>& u)
+{
+  if (n == 0) {
+    u.reset(nullptr);
+    return nullptr;
+  }
+  T* retVal;
+  if (mInputControl.useExternal()) {
+    u.reset(nullptr);
+    mInputControl.checkCurrent();
+    GPUProcessor::computePointerWithAlignment(mInputControl.ptrCurrent, retVal, n);
+    if ((size_t)((char*)mInputControl.ptrCurrent - (char*)mInputControl.ptrBase) > mInputControl.size) {
+      throw std::bad_alloc();
+    }
+  } else {
+    u.reset(new T[n]);
+    retVal = u.get();
+    if (GetProcessingSettings().registerStandaloneInputMemory) {
+      if (registerMemoryForGPU(u.get(), n * sizeof(T))) {
+        GPUError("Error registering memory for GPU: %p - %ld bytes\n", (void*)u.get(), (int64_t)(n * sizeof(T)));
+        throw std::bad_alloc();
+      }
+    }
+  }
+  ptr = retVal;
+  return retVal;
+}
+
 template <class T, class S>
 inline uint32_t GPUReconstruction::DumpData(FILE* fp, const T* const* entries, const S* num, InOutPointerType type)
 {
@@ -38,7 +68,7 @@ inline uint32_t GPUReconstruction::DumpData(FILE* fp, const T* const* entries, c
       fwrite(entries[i], sizeof(*entries[i]), num[i], fp);
     }
   }
-  if (mProcessingSettings.debugLevel >= 2) {
+  if (GetProcessingSettings().debugLevel >= 2) {
     GPUInfo("Dumped %ld %s", (int64_t)numTotal, IOTYPENAMES[type]);
   }
   return numTotal;
@@ -72,7 +102,7 @@ inline size_t GPUReconstruction::ReadData(FILE* fp, const T** entries, S* num, s
     numTotal += num[i];
   }
   (void)r;
-  if (mProcessingSettings.debugLevel >= 2) {
+  if (GetProcessingSettings().debugLevel >= 2) {
     GPUInfo("Read %ld %s", (int64_t)numTotal, IOTYPENAMES[type]);
   }
   return numTotal;
@@ -112,7 +142,7 @@ inline std::unique_ptr<T> GPUReconstruction::ReadFlatObjectFromFile(const char*
   r = fread((void*)retVal.get(), 1, size[0], fp);
   r = fread(buf, 1, size[1], fp);
   fclose(fp);
-  if (mProcessingSettings.debugLevel >= 2) {
+  if (GetProcessingSettings().debugLevel >= 2) {
     GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
   }
   retVal->clearInternalBufferPtr();
@@ -151,7 +181,7 @@ inline std::unique_ptr<T> GPUReconstruction::ReadStructFromFile(const char* file
   std::unique_ptr<T> newObj(new T);
   r = fread(newObj.get(), 1, size, fp);
   fclose(fp);
-  if (mProcessingSettings.debugLevel >= 2) {
+  if (GetProcessingSettings().debugLevel >= 2) {
     GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
   }
   return newObj;
@@ -172,7 +202,7 @@ inline int32_t GPUReconstruction::ReadStructFromFile(const char* file, T* obj)
   }
   r = fread(obj, 1, size, fp);
   fclose(fp);
-  if (mProcessingSettings.debugLevel >= 2) {
+  if (GetProcessingSettings().debugLevel >= 2) {
     GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
   }
   return 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
index b3f6c6ec817fd..2b16dfb32fe14 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
@@ -65,7 +65,7 @@
 // GPU Host wrappers for kernel
 #define GPUCA_KRNL_HOST(x_class, ...) \
   GPUCA_KRNLGPU(x_class, __VA_ARGS__) \
-  template <> class GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::backendInternal<GPUCA_M_KRNL_TEMPLATE(x_class)> { \
+  template <> class GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::backendInternal<GPUCA_M_KRNL_TEMPLATE(x_class)> { \
    public: \
     template <typename T, typename... Args> \
     static inline void runKernelBackendMacro(const krnlSetupTime& _xyz, T* me, const Args&... args) \
diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernels.h b/GPU/GPUTracking/Base/GPUReconstructionKernels.h
deleted file mode 100644
index 7f500d471de1f..0000000000000
--- a/GPU/GPUTracking/Base/GPUReconstructionKernels.h
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUReconstructionKernels.h
-/// \author David Rohr
-
-#ifndef GPURECONSTRUCTIONKERNELS_H
-#define GPURECONSTRUCTIONKERNELS_H
-
-#include "GPUReconstruction.h"
-
-namespace o2::gpu
-{
-
-namespace gpu_reconstruction_kernels
-{
-
-template <class T, int32_t I = 0>
-struct classArgument {
-  using t = T;
-  static constexpr int32_t i = I;
-};
-
-struct krnlExec {
-  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto) : nBlocks(b), nThreads(t), stream(s), device(d), step(GPUDataTypes::RecoStep::NoRecoStep) {}
-  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUDataTypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(GPUReconstruction::krnlDeviceType::Auto), step(st) {}
-  constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(d), step(st) {}
-  uint32_t nBlocks;
-  uint32_t nThreads;
-  int32_t stream;
-  GPUReconstruction::krnlDeviceType device;
-  GPUDataTypes::RecoStep step;
-};
-struct krnlRunRange {
-  constexpr krnlRunRange() = default;
-  constexpr krnlRunRange(uint32_t v) : index(v) {}
-  uint32_t index = 0;
-};
-struct krnlEvent {
-  constexpr krnlEvent(deviceEvent* e = nullptr, deviceEvent* el = nullptr, int32_t n = 1) : ev(e), evList(el), nEvents(n) {}
-  deviceEvent* ev;
-  deviceEvent* evList;
-  int32_t nEvents;
-};
-
-struct krnlProperties {
-  krnlProperties(int32_t t = 0, int32_t b = 1, int32_t b2 = 0) : nThreads(t), minBlocks(b), forceBlocks(b2) {}
-  uint32_t nThreads;
-  uint32_t minBlocks;
-  uint32_t forceBlocks;
-  uint32_t total() { return forceBlocks ? forceBlocks : (nThreads * minBlocks); }
-};
-
-struct krnlSetup {
-  krnlSetup(const krnlExec& xx, const krnlRunRange& yy = {0}, const krnlEvent& zz = {nullptr, nullptr, 0}) : x(xx), y(yy), z(zz) {}
-  krnlExec x;
-  krnlRunRange y;
-  krnlEvent z;
-};
-
-struct krnlSetupTime : public krnlSetup {
-  double& t;
-};
-
-template <class T, int32_t I = 0, typename... Args>
-struct krnlSetupArgs : public gpu_reconstruction_kernels::classArgument<T, I> {
-  krnlSetupArgs(const krnlExec& xx, const krnlRunRange& yy, const krnlEvent& zz, double& tt, const Args&... args) : s{{xx, yy, zz}, tt}, v(args...) {}
-  const krnlSetupTime s;
-  std::tuple<typename std::conditional<(sizeof(Args) > sizeof(void*)), const Args&, const Args>::type...> v;
-};
-
-} // namespace gpu_reconstruction_kernels
-
-template <class T>
-class GPUReconstructionKernels : public T
-{
- public:
-  GPUReconstructionKernels(const GPUSettingsDeviceBackend& cfg) : T(cfg) {}
-
- protected:
-  using deviceEvent = gpu_reconstruction_kernels::deviceEvent;
-  using krnlExec = gpu_reconstruction_kernels::krnlExec;
-  using krnlRunRange = gpu_reconstruction_kernels::krnlRunRange;
-  using krnlEvent = gpu_reconstruction_kernels::krnlEvent;
-  using krnlSetup = gpu_reconstruction_kernels::krnlSetup;
-  using krnlSetupTime = gpu_reconstruction_kernels::krnlSetupTime;
-  template <class S, int32_t I = 0, typename... Args>
-  using krnlSetupArgs = gpu_reconstruction_kernels::krnlSetupArgs<S, I, Args...>;
-
-  virtual void runKernelImpl(const int num, const void* args)
-  {
-    switch (num) { // clang-format off
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, x_num)                               \
-      case x_num: {                                                                                             \
-        const auto& args2 = *(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>*)args; \
-        T::template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(args2);                                    \
-        break; \
-      }
-#include "GPUReconstructionKernelList.h"
-#undef GPUCA_KRNL
-    } // clang-format on
-  }
-};
-
-} // namespace o2::gpu
-
-#endif
diff --git a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
index aa01d26446b56..89517c612403b 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
@@ -24,6 +24,7 @@
 
 #include "GPUReconstruction.h"
 #include "GPUReconstructionAvailableBackends.h"
+#include "GPUSettings.h"
 
 #include "utils/qlibload.h"
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
index d02309f66c762..a511102a492ef 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.cxx
@@ -15,6 +15,9 @@
 #include "GPUReconstructionProcessing.h"
 #include "GPUReconstructionThreading.h"
 #include "GPUDefParametersLoad.inc"
+#include "GPUReconstructionKernelIncludes.h"
+#include "GPUSettings.h"
+#include "GPULogging.h"
 
 using namespace o2::gpu;
 
@@ -41,7 +44,7 @@ GPUReconstructionProcessing::~GPUReconstructionProcessing()
 int32_t GPUReconstructionProcessing::getNKernelHostThreads(bool splitCores)
 {
   int32_t nThreads = 0;
-  if (mProcessingSettings.inKernelParallel == 2 && mNActiveThreadsOuterLoop) {
+  if (GetProcessingSettings().inKernelParallel == 2 && mNActiveThreadsOuterLoop) {
     if (splitCores) {
       nThreads = mMaxHostThreads / mNActiveThreadsOuterLoop;
       nThreads += (uint32_t)getHostThreadIndex() < mMaxHostThreads % mNActiveThreadsOuterLoop;
@@ -50,7 +53,7 @@ int32_t GPUReconstructionProcessing::getNKernelHostThreads(bool splitCores)
     }
     nThreads = std::max(1, nThreads);
   } else {
-    nThreads = mProcessingSettings.inKernelParallel ? mMaxHostThreads : 1;
+    nThreads = GetProcessingSettings().inKernelParallel ? mMaxHostThreads : 1;
   }
   return nThreads;
 }
@@ -59,7 +62,7 @@ void GPUReconstructionProcessing::SetNActiveThreads(int32_t n)
 {
   mActiveHostKernelThreads = std::max(1, n < 0 ? mMaxHostThreads : std::min(n, mMaxHostThreads));
   mThreading->activeThreads = std::make_unique<tbb::task_arena>(mActiveHostKernelThreads);
-  if (mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("Set number of active parallel kernels threads on host to %d (%d requested)", mActiveHostKernelThreads, n);
   }
 }
@@ -80,12 +83,12 @@ void GPUReconstructionProcessing::runParallelOuterLoop(bool doGPU, uint32_t nThr
 
 uint32_t GPUReconstructionProcessing::SetAndGetNActiveThreadsOuterLoop(bool condition, uint32_t max)
 {
-  if (condition && mProcessingSettings.inKernelParallel != 1) {
-    mNActiveThreadsOuterLoop = mProcessingSettings.inKernelParallel == 2 ? std::min<uint32_t>(max, mMaxHostThreads) : mMaxHostThreads;
+  if (condition && GetProcessingSettings().inKernelParallel != 1) {
+    mNActiveThreadsOuterLoop = GetProcessingSettings().inKernelParallel == 2 ? std::min<uint32_t>(max, mMaxHostThreads) : mMaxHostThreads;
   } else {
     mNActiveThreadsOuterLoop = 1;
   }
-  if (mProcessingSettings.debugLevel >= 5) {
+  if (GetProcessingSettings().debugLevel >= 5) {
     printf("Running %d threads in outer loop\n", mNActiveThreadsOuterLoop);
   }
   return mNActiveThreadsOuterLoop;
@@ -132,9 +135,9 @@ uint32_t GPUReconstructionProcessing::getNextTimerId()
   return id.fetch_add(1);
 }
 
-std::unique_ptr<gpu_reconstruction_kernels::threadContext> GPUReconstructionProcessing::GetThreadContext()
+std::unique_ptr<GPUReconstructionProcessing::threadContext> GPUReconstructionProcessing::GetThreadContext()
 {
-  return std::make_unique<gpu_reconstruction_kernels::threadContext>();
+  return std::make_unique<threadContext>();
 }
 
 gpu_reconstruction_kernels::threadContext::threadContext() = default;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index 4ce8bc1b42743..9e611e57148c6 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -16,7 +16,6 @@
 #define GPURECONSTRUCTIONPROCESSING_H
 
 #include "GPUReconstruction.h"
-#include "GPUReconstructionKernelIncludes.h"
 
 #include "utils/timer.h"
 #include <functional>
@@ -32,7 +31,7 @@ namespace o2::gpu
 
 struct GPUDefParameters;
 
-namespace gpu_reconstruction_kernels
+namespace gpu_reconstruction_kernels // TODO: Get rid of this namespace
 {
 struct deviceEvent {
   constexpr deviceEvent() = default;
@@ -72,6 +71,86 @@ class GPUReconstructionProcessing : public GPUReconstruction
  public:
   ~GPUReconstructionProcessing() override;
 
+  using deviceEvent = gpu_reconstruction_kernels::deviceEvent;
+  using threadContext = gpu_reconstruction_kernels::threadContext;
+
+  struct RecoStepTimerMeta {
+    HighResTimer timerToGPU;
+    HighResTimer timerToHost;
+    HighResTimer timerTotal;
+    double timerCPU = 0.;
+    size_t bytesToGPU = 0;
+    size_t bytesToHost = 0;
+    uint32_t countToGPU = 0;
+    uint32_t countToHost = 0;
+  };
+
+  template <class T, int32_t I = 0>
+  struct kernelInterfaceArguments {
+    using t = T;
+    static constexpr int32_t i = I;
+  };
+
+  struct krnlExec {
+    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto) : nBlocks(b), nThreads(t), stream(s), device(d), step(GPUDataTypes::RecoStep::NoRecoStep) {}
+    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUDataTypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(GPUReconstruction::krnlDeviceType::Auto), step(st) {}
+    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(d), step(st) {}
+    uint32_t nBlocks;
+    uint32_t nThreads;
+    int32_t stream;
+    GPUReconstruction::krnlDeviceType device;
+    GPUDataTypes::RecoStep step;
+  };
+  struct krnlRunRange {
+    constexpr krnlRunRange() = default;
+    constexpr krnlRunRange(uint32_t v) : index(v) {}
+    uint32_t index = 0;
+  };
+  struct krnlEvent {
+    constexpr krnlEvent(deviceEvent* e = nullptr, deviceEvent* el = nullptr, int32_t n = 1) : ev(e), evList(el), nEvents(n) {}
+    deviceEvent* ev;
+    deviceEvent* evList;
+    int32_t nEvents;
+  };
+
+  struct krnlProperties {
+    krnlProperties(int32_t t = 0, int32_t b = 1, int32_t b2 = 0) : nThreads(t), minBlocks(b), forceBlocks(b2) {}
+    uint32_t nThreads;
+    uint32_t minBlocks;
+    uint32_t forceBlocks;
+    uint32_t total() { return forceBlocks ? forceBlocks : (nThreads * minBlocks); }
+  };
+
+  struct krnlSetup {
+    krnlSetup(const krnlExec& xx, const krnlRunRange& yy = {0}, const krnlEvent& zz = {nullptr, nullptr, 0}) : x(xx), y(yy), z(zz) {}
+    krnlExec x;
+    krnlRunRange y;
+    krnlEvent z;
+  };
+
+  struct krnlSetupTime : public krnlSetup {
+    double& t;
+  };
+
+  template <class T, int32_t I = 0, typename... Args>
+  struct krnlSetupArgs : public kernelInterfaceArguments<T, I> {
+    const krnlSetupTime s;
+    std::tuple<typename std::conditional<(sizeof(Args) > sizeof(void*)), const Args&, const Args>::type...> v;
+  };
+
+  template <class T, class S>
+  class KernelInterface : public S
+  {
+   public:
+    template <typename... Args>
+    KernelInterface(const Args&... args) : S(args...)
+    {
+    }
+
+   protected:
+    virtual void runKernelVirtual(const int num, const void* args);
+  };
+
   // Threading
   int32_t getNKernelHostThreads(bool splitCores);
   uint32_t getNActiveThreadsOuterLoop() const { return mNActiveThreadsOuterLoop; }
@@ -94,23 +173,12 @@ class GPUReconstructionProcessing : public GPUReconstruction
   template <class T>
   void AddGPUEvents(T*& events);
 
-  virtual std::unique_ptr<gpu_reconstruction_kernels::threadContext> GetThreadContext() override;
+  virtual std::unique_ptr<threadContext> GetThreadContext() override;
 
-  struct RecoStepTimerMeta {
-    HighResTimer timerToGPU;
-    HighResTimer timerToHost;
-    HighResTimer timerTotal;
-    double timerCPU = 0.;
-    size_t bytesToGPU = 0;
-    size_t bytesToHost = 0;
-    uint32_t countToGPU = 0;
-    uint32_t countToHost = 0;
-  };
   const GPUDefParameters& getGPUParameters(bool doGPU) const override { return *(doGPU ? mParDevice : mParCPU); }
 
  protected:
   GPUReconstructionProcessing(const GPUSettingsDeviceBackend& cfg);
-  using deviceEvent = gpu_reconstruction_kernels::deviceEvent;
 
   static const std::vector<std::string> mKernelNames;
 
@@ -181,7 +249,7 @@ HighResTimer& GPUReconstructionProcessing::getTimer(const char* name, int32_t nu
   static int32_t id = getNextTimerId();
   timerMeta* timer = getTimerById(id);
   if (timer == nullptr) {
-    int32_t max = std::max<int32_t>({mMaxHostThreads, mProcessingSettings.nStreams});
+    int32_t max = std::max<int32_t>({mMaxHostThreads, GPUCA_MAX_STREAMS});
     timer = insertTimer(id, name, J, max, 1, RecoStep::NoRecoStep);
   }
   if (num == -1) {
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessingKernels.inc b/GPU/GPUTracking/Base/GPUReconstructionProcessingKernels.inc
new file mode 100644
index 0000000000000..49d02515372b8
--- /dev/null
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessingKernels.inc
@@ -0,0 +1,41 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUReconstructionProcessingKernels.h
+/// \author David Rohr
+
+#ifndef GPURECONSTRUCTIONPROCESSINGKERNELS_H
+#define GPURECONSTRUCTIONPROCESSINGKERNELS_H
+
+#include "GPUReconstructionProcessing.h"
+#include "GPUReconstructionKernelIncludes.h"
+
+namespace o2::gpu
+{
+
+template <class T, class S>
+void GPUReconstructionProcessing::KernelInterface<T, S>::runKernelVirtual(const int num, const void* args)
+{
+  switch (num) { // clang-format off
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, x_num)                             \
+    case x_num: {                                                                                             \
+      const auto& args2 = *(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>*)args; \
+      ((T*)this)->template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(args2);                                    \
+      break;                                                                                                  \
+    }
+#include "GPUReconstructionKernelList.h"
+#undef GPUCA_KRNL
+  } // clang-format on
+}
+
+} // namespace o2::gpu
+
+#endif // GPURECONSTRUCTIONPROCESSINGKERNELS_H
diff --git a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
index 4693a1eff24f2..b25b93e957b15 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
@@ -14,6 +14,8 @@
 
 #include "GPUReconstructionTimeframe.h"
 #include "GPUReconstruction.h"
+#include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
 #include "display/GPUDisplayInterface.h"
 #include "GPUQA.h"
 #include "AliHLTTPCClusterMCData.h"
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index fe2906caace80..970b331ea99fb 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -24,6 +24,7 @@
 #include "GPUParamRTC.h"
 #include "GPUReconstructionCUDAHelpers.inc"
 #include "GPUDefParametersLoad.inc"
+#include "GPUReconstructionProcessingKernels.inc"
 
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1
 #include "utils/qGetLdBinarySymbols.h"
@@ -53,16 +54,23 @@ __global__ void dummyInitKernel(void*) {}
 
 #include "GPUReconstructionIncludesITS.h"
 
-GPUReconstructionCUDABackend::GPUReconstructionCUDABackend(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionDeviceBase(cfg, sizeof(GPUReconstructionDeviceBase))
+GPUReconstructionCUDA::GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionProcessing::KernelInterface<GPUReconstructionCUDA, GPUReconstructionDeviceBase>(cfg, sizeof(GPUReconstructionDeviceBase))
 {
   if (mMaster == nullptr) {
     mInternals = new GPUReconstructionCUDAInternals;
     *mParDevice = o2::gpu::internal::GPUDefParametersLoad();
   }
-  mDeviceBackendSettings.deviceType = DeviceType::CUDA;
+  mDeviceBackendSettings->deviceType = DeviceType::CUDA;
+#ifndef __HIPCC__ // CUDA
+  mRtcSrcExtension = ".cu";
+  mRtcBinExtension = ".fatbin";
+#else // HIP
+  mRtcSrcExtension = ".hip";
+  mRtcBinExtension = ".o";
+#endif
 }
 
-GPUReconstructionCUDABackend::~GPUReconstructionCUDABackend()
+GPUReconstructionCUDA::~GPUReconstructionCUDA()
 {
   Exit(); // Make sure we destroy everything (in particular the ITS tracker) before we exit CUDA
   if (mMaster == nullptr) {
@@ -71,23 +79,11 @@ GPUReconstructionCUDABackend::~GPUReconstructionCUDABackend()
 }
 
 static_assert(sizeof(cudaError_t) <= sizeof(int64_t) && cudaSuccess == 0);
-int32_t GPUReconstructionCUDABackend::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
+int32_t GPUReconstructionCUDA::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
 {
   return internal::GPUReconstructionCUDAChkErr(error, file, line);
 }
 
-GPUReconstructionCUDA::GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionKernels(cfg)
-{
-#ifndef __HIPCC__ // CUDA
-  mRtcSrcExtension = ".cu";
-  mRtcBinExtension = ".fatbin";
-#else // HIP
-  mRtcSrcExtension = ".hip";
-  mRtcBinExtension = ".o";
-#endif
-}
-GPUReconstructionCUDA::~GPUReconstructionCUDA() = default;
-
 GPUReconstruction* GPUReconstruction_Create_CUDA(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionCUDA(cfg); }
 
 void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame>* timeFrame)
@@ -109,7 +105,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
   constexpr int32_t reqVerMaj = 2;
   constexpr int32_t reqVerMin = 0;
 #endif
-  if (mProcessingSettings.rtc.enable && mProcessingSettings.rtctech.runTest == 2) {
+  if (GetProcessingSettings().rtc.enable && GetProcessingSettings().rtctech.runTest == 2) {
     mWarpSize = GPUCA_WARP_SIZE;
     genAndLoadRTC();
     exit(0);
@@ -123,14 +119,14 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUError("Error getting CUDA Device Count");
       return (1);
     }
-    if (mProcessingSettings.debugLevel >= 2) {
+    if (GetProcessingSettings().debugLevel >= 2) {
       GPUInfo("Available CUDA devices:");
     }
     std::vector<bool> devicesOK(count, false);
     std::vector<size_t> devMemory(count, 0);
     bool contextCreated = false;
     for (int32_t i = 0; i < count; i++) {
-      if (mProcessingSettings.debugLevel >= 4) {
+      if (GetProcessingSettings().debugLevel >= 4) {
         GPUInfo("Examining device %d", i);
       }
       size_t free, total;
@@ -139,14 +135,14 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
 #else // HIP
       if (GPUChkErrI(hipSetDevice(i))) {
 #endif
-        if (mProcessingSettings.debugLevel >= 4) {
+        if (GetProcessingSettings().debugLevel >= 4) {
           GPUWarning("Couldn't create context for device %d. Skipping it.", i);
         }
         continue;
       }
       contextCreated = true;
       if (GPUChkErrI(cudaMemGetInfo(&free, &total))) {
-        if (mProcessingSettings.debugLevel >= 4) {
+        if (GetProcessingSettings().debugLevel >= 4) {
           GPUWarning("Error obtaining CUDA memory info about device %d! Skipping it.", i);
         }
         GPUChkErr(cudaDeviceReset());
@@ -156,13 +152,13 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
         GPUChkErr(cudaDeviceReset());
         contextCreated = false;
       }
-      if (mProcessingSettings.debugLevel >= 4) {
+      if (GetProcessingSettings().debugLevel >= 4) {
         GPUInfo("Obtained current memory usage for device %d", i);
       }
       if (GPUChkErrI(cudaGetDeviceProperties(&deviceProp, i))) {
         continue;
       }
-      if (mProcessingSettings.debugLevel >= 4) {
+      if (GetProcessingSettings().debugLevel >= 4) {
         GPUInfo("Obtained device properties for device %d", i);
       }
       int32_t deviceOK = true;
@@ -179,7 +175,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       }
 
       deviceSpeed = (double)deviceProp.multiProcessorCount * (double)deviceProp.clockRate * (double)deviceProp.warpSize * (double)free * (double)deviceProp.major * (double)deviceProp.major;
-      if (mProcessingSettings.debugLevel >= 2) {
+      if (GetProcessingSettings().debugLevel >= 2) {
         GPUImportant("Device %s%2d: %s (Rev: %d.%d - Mem Avail %lu / %lu)%s %s", deviceOK ? " " : "[", i, deviceProp.name, deviceProp.major, deviceProp.minor, free, (size_t)deviceProp.totalGlobalMem, deviceOK ? " " : " ]", deviceOK ? "" : deviceFailure);
       }
       if (!deviceOK) {
@@ -191,7 +187,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
         bestDevice = i;
         bestDeviceSpeed = deviceSpeed;
       } else {
-        if (mProcessingSettings.debugLevel >= 2 && mProcessingSettings.deviceNum < 0) {
+        if (GetProcessingSettings().debugLevel >= 2 && GetProcessingSettings().deviceNum < 0) {
           GPUInfo("Skipping: Speed %f < %f\n", deviceSpeed, bestDeviceSpeed);
         }
       }
@@ -204,15 +200,15 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUImportant("Requiring Revision %d.%d, Mem: %lu", reqVerMaj, reqVerMin, std::max<size_t>(mDeviceMemorySize, REQUIRE_MIN_MEMORY));
 #endif
       noDevice = true;
-    } else if (mProcessingSettings.deviceNum > -1) {
-      if (mProcessingSettings.deviceNum >= (signed)count) {
-        GPUError("Requested device ID %d does not exist", mProcessingSettings.deviceNum);
+    } else if (GetProcessingSettings().deviceNum > -1) {
+      if (GetProcessingSettings().deviceNum >= (signed)count) {
+        GPUError("Requested device ID %d does not exist", GetProcessingSettings().deviceNum);
         noDevice = true;
-      } else if (!devicesOK[mProcessingSettings.deviceNum]) {
-        GPUError("Unsupported device requested (%d)", mProcessingSettings.deviceNum);
+      } else if (!devicesOK[GetProcessingSettings().deviceNum]) {
+        GPUError("Unsupported device requested (%d)", GetProcessingSettings().deviceNum);
         noDevice = true;
       } else {
-        bestDevice = mProcessingSettings.deviceNum;
+        bestDevice = GetProcessingSettings().deviceNum;
       }
     }
     if (noDevice) {
@@ -225,7 +221,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
 
     GPUChkErrI(cudaGetDeviceProperties(&deviceProp, mDeviceId));
 
-    if (mProcessingSettings.debugLevel >= 2) {
+    if (GetProcessingSettings().debugLevel >= 2) {
       GPUInfo("Using CUDA Device %s with Properties:", deviceProp.name);
       GPUInfo("\ttotalGlobalMem = %ld", (uint64_t)deviceProp.totalGlobalMem);
       GPUInfo("\tsharedMemPerBlock = %ld", (uint64_t)deviceProp.sharedMemPerBlock);
@@ -244,7 +240,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUInfo("\ttextureAlignment = %ld", (uint64_t)deviceProp.textureAlignment);
       GPUInfo(" ");
     }
-    if (deviceProp.warpSize != GPUCA_WARP_SIZE && !mProcessingSettings.rtc.enable) {
+    if (deviceProp.warpSize != GPUCA_WARP_SIZE && !GetProcessingSettings().rtc.enable) {
       throw std::runtime_error("Invalid warp size on GPU");
     }
     mWarpSize = deviceProp.warpSize;
@@ -280,7 +276,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUChkErrI(cudaDeviceReset());
       return (1);
     }
-    if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitMallocHeapSize, mProcessingSettings.deterministicGPUReconstruction ? std::max<size_t>(1024 * 1024 * 1024, GPUCA_GPU_HEAP_SIZE) : GPUCA_GPU_HEAP_SIZE))) {
+    if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitMallocHeapSize, GetProcessingSettings().deterministicGPUReconstruction ? std::max<size_t>(1024 * 1024 * 1024, GPUCA_GPU_HEAP_SIZE) : GPUCA_GPU_HEAP_SIZE))) {
       GPUError("Error setting CUDA stack size");
       GPUChkErrI(cudaDeviceReset());
       return (1);
@@ -302,7 +298,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       mDeviceMemorySize = mDeviceMemorySize * 2 / 3; // Leave 1/3 of GPU memory for event display
     }
 
-    if (mProcessingSettings.debugLevel >= 3) {
+    if (GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Allocating memory on GPU");
     }
     if (mDeviceMemorySize > deviceProp.totalGlobalMem || GPUChkErrI(cudaMalloc(&mDeviceMemoryBase, mDeviceMemorySize))) {
@@ -312,7 +308,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUChkErrI(cudaDeviceReset());
       return (1);
     }
-    if (mProcessingSettings.debugLevel >= 3) {
+    if (GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Allocating memory on Host");
     }
     if (GPUChkErrI(cudaMallocHost(&mHostMemoryBase, mHostMemorySize))) {
@@ -320,7 +316,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUChkErrI(cudaDeviceReset());
       return (1);
     }
-    if (mProcessingSettings.debugLevel >= 1) {
+    if (GetProcessingSettings().debugLevel >= 1) {
       GPUInfo("Memory ptrs: GPU (%ld bytes): %p - Host (%ld bytes): %p", (int64_t)mDeviceMemorySize, mDeviceMemoryBase, (int64_t)mHostMemorySize, mHostMemoryBase);
       memset(mHostMemoryBase, 0xDD, mHostMemorySize);
       if (GPUChkErrI(cudaMemset(mDeviceMemoryBase, 0xDD, mDeviceMemorySize))) {
@@ -344,7 +340,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     hipLaunchKernelGGL(HIP_KERNEL_NAME(dummyInitKernel), dim3(mBlockCount), dim3(256), 0, 0, mDeviceMemoryBase);
 #endif
 
-    if (mProcessingSettings.rtc.enable) {
+    if (GetProcessingSettings().rtc.enable) {
       genAndLoadRTC();
     }
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1
@@ -419,17 +415,17 @@ void GPUReconstructionCUDA::genAndLoadRTC()
     throw std::runtime_error("Runtime compilation failed");
   }
   for (uint32_t i = 0; i < nCompile; i++) {
-    if (mProcessingSettings.rtctech.runTest != 2) {
+    if (GetProcessingSettings().rtctech.runTest != 2) {
       mInternals->kernelModules.emplace_back(std::make_unique<CUmodule>());
       GPUChkErr(cuModuleLoad(mInternals->kernelModules.back().get(), (filename + "_" + std::to_string(i) + mRtcBinExtension).c_str()));
     }
     remove((filename + "_" + std::to_string(i) + mRtcSrcExtension).c_str());
     remove((filename + "_" + std::to_string(i) + mRtcBinExtension).c_str());
   }
-  if (mProcessingSettings.rtctech.runTest == 2) {
+  if (GetProcessingSettings().rtctech.runTest == 2) {
     return;
   }
-  loadKernelModules(mProcessingSettings.rtc.compilePerKernel);
+  loadKernelModules(GetProcessingSettings().rtc.compilePerKernel);
 }
 
 int32_t GPUReconstructionCUDA::ExitDevice_Runtime()
@@ -472,7 +468,7 @@ int32_t GPUReconstructionCUDA::ExitDevice_Runtime()
 
 size_t GPUReconstructionCUDA::GPUMemCpy(void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev, deviceEvent* evList, int32_t nEvents)
 {
-  if (mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().debugLevel >= 3) {
     stream = -1;
   }
   if (stream == -1) {
@@ -490,7 +486,7 @@ size_t GPUReconstructionCUDA::GPUMemCpy(void* dst, const void* src, size_t size,
   if (ev) {
     GPUChkErr(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream == -1 ? 0 : stream]));
   }
-  if (mProcessingSettings.serializeGPU & 2) {
+  if (GetProcessingSettings().serializeGPU & 2) {
     GPUDebug(("GPUMemCpy " + std::to_string(toGPU)).c_str(), stream, true);
   }
   return size;
@@ -512,7 +508,7 @@ size_t GPUReconstructionCUDA::WriteToConstantMemory(size_t offset, const void* s
   if (ev && stream != -1) {
     GPUChkErr(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream]));
   }
-  if (mProcessingSettings.serializeGPU & 2) {
+  if (GetProcessingSettings().serializeGPU & 2) {
     GPUDebug("WriteToConstantMemory", stream, true);
   }
   return size;
@@ -521,7 +517,7 @@ size_t GPUReconstructionCUDA::WriteToConstantMemory(size_t offset, const void* s
 void GPUReconstructionCUDA::ReleaseEvent(deviceEvent ev) {}
 void GPUReconstructionCUDA::RecordMarker(deviceEvent* ev, int32_t stream) { GPUChkErr(cudaEventRecord(ev->get<cudaEvent_t>(), mInternals->Streams[stream])); }
 
-std::unique_ptr<gpu_reconstruction_kernels::threadContext> GPUReconstructionCUDA::GetThreadContext()
+std::unique_ptr<GPUReconstructionProcessing::threadContext> GPUReconstructionCUDA::GetThreadContext()
 {
   GPUChkErr(cudaSetDevice(mDeviceId));
   return GPUReconstructionProcessing::GetThreadContext();
@@ -565,14 +561,14 @@ int32_t GPUReconstructionCUDA::GPUDebug(const char* state, int32_t stream, bool
     GPUError("CUDA Error %s while running (%s) (Stream %d)", cudaGetErrorString(cuErr), state, stream);
     return (1);
   }
-  if (!force && mProcessingSettings.debugLevel <= 0) {
+  if (!force && GetProcessingSettings().debugLevel <= 0) {
     return (0);
   }
   if (GPUChkErrI(stream == -1 ? cudaDeviceSynchronize() : cudaStreamSynchronize(mInternals->Streams[stream]))) {
     GPUError("CUDA Error while synchronizing (%s) (Stream %d)", state, stream);
     return (1);
   }
-  if (mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("GPU Sync Done");
   }
   return (0);
@@ -580,7 +576,7 @@ int32_t GPUReconstructionCUDA::GPUDebug(const char* state, int32_t stream, bool
 
 int32_t GPUReconstructionCUDA::registerMemoryForGPU_internal(const void* ptr, size_t size)
 {
-  if (mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("Registering %zu bytes of memory for GPU", size);
   }
   return GPUChkErrI(cudaHostRegister((void*)ptr, size, cudaHostRegisterDefault));
@@ -591,7 +587,7 @@ int32_t GPUReconstructionCUDA::unregisterMemoryForGPU_internal(const void* ptr)
   return GPUChkErrI(cudaHostUnregister((void*)ptr));
 }
 
-void GPUReconstructionCUDABackend::PrintKernelOccupancies()
+void GPUReconstructionCUDA::PrintKernelOccupancies()
 {
   int32_t maxBlocks = 0, threads = 0, suggestedBlocks = 0, nRegs = 0, sMem = 0;
   GPUChkErr(cudaSetDevice(mDeviceId));
@@ -612,7 +608,7 @@ void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
     GPUFatal("kernel numbers out of sync");                                                                                                                                             \
   }                                                                                                                                                                                     \
   mInternals->kernelFunctions.emplace_back(new CUfunction);                                                                                                                             \
-  if (mProcessingSettings.debugLevel >= 3) {                                                                                                                                            \
+  if (GetProcessingSettings().debugLevel >= 3) {                                                                                                                                        \
     GPUInfo("Loading kernel %s (j = %u)", GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), j);                                                                              \
   }                                                                                                                                                                                     \
   GPUChkErr(cuModuleGetFunction(mInternals->kernelFunctions.back().get(), *mInternals->kernelModules[perKernel ? j : 0], GPUCA_M_STR(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))))); \
@@ -680,8 +676,3 @@ void GPUReconstructionHIP::SetONNXGPUStream(Ort::SessionOptions& session_options
 #endif // ORT_ROCM_BUILD
 }
 #endif // __HIPCC__
-
-namespace o2::gpu
-{
-template class GPUReconstructionKernels<GPUReconstructionCUDABackend>;
-}
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 2fc4d14bba491..ed75100dfe351 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -16,6 +16,7 @@
 #define GPURECONSTRUCTIONCUDA_H
 
 #include "GPUReconstructionDeviceBase.h"
+#include "GPUCommonAlgorithm.h"
 #include <vector>
 #include <string>
 
@@ -34,38 +35,31 @@ namespace o2::gpu
 {
 struct GPUReconstructionCUDAInternals;
 
-class GPUReconstructionCUDABackend : public GPUReconstructionDeviceBase
+class GPUReconstructionCUDA : public GPUReconstructionProcessing::KernelInterface<GPUReconstructionCUDA, GPUReconstructionDeviceBase>
 {
  public:
-  ~GPUReconstructionCUDABackend() override;
-
- protected:
-  GPUReconstructionCUDABackend(const GPUSettingsDeviceBackend& cfg);
+  GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg);
+  ~GPUReconstructionCUDA() override;
 
   void PrintKernelOccupancies() override;
   virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override;
 
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
-  template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
 
   template <class T, class S>
   friend GPUh() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp);
+
+ protected:
   GPUReconstructionCUDAInternals* mInternals;
-};
 
-class GPUReconstructionCUDA : public GPUReconstructionKernels<GPUReconstructionCUDABackend>
-{
- public:
-  ~GPUReconstructionCUDA() override;
-  GPUReconstructionCUDA(const GPUSettingsDeviceBackend& cfg);
+  template <class T, int32_t I = 0, typename... Args>
+  void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
 
- protected:
   int32_t InitDevice_Runtime() override;
   int32_t ExitDevice_Runtime() override;
 
-  std::unique_ptr<gpu_reconstruction_kernels::threadContext> GetThreadContext() override;
+  std::unique_ptr<threadContext> GetThreadContext() override;
   void SynchronizeGPU() override;
   int32_t GPUDebug(const char* state = "UNKNOWN", int32_t stream = -1, bool force = false) override;
   void SynchronizeStream(int32_t stream) override;
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index abcd47ca01c90..5706f32e73e96 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -37,8 +37,8 @@ QGET_LD_BINARY_SYMBOLS(GPUReconstructionCUDArtc_command_no_fast_math);
 int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
 {
   std::string rtcparam = std::string("#define GPUCA_RTC_CODE\n") +
-                         std::string(mProcessingSettings.rtc.optSpecialCode ? "#define GPUCA_RTC_SPECIAL_CODE(...) __VA_ARGS__\n" : "#define GPUCA_RTC_SPECIAL_CODE(...)\n") +
-                         GPUParamRTC::generateRTCCode(param(), mProcessingSettings.rtc.optConstexpr);
+                         std::string(GetProcessingSettings().rtc.optSpecialCode ? "#define GPUCA_RTC_SPECIAL_CODE(...) __VA_ARGS__\n" : "#define GPUCA_RTC_SPECIAL_CODE(...)\n") +
+                         GPUParamRTC::generateRTCCode(param(), GetProcessingSettings().rtc.optConstexpr);
   if (filename == "") {
     filename = "/tmp/o2cagpu_rtc_";
   }
@@ -53,12 +53,12 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     kernelsall += kernels[i] + "\n";
   }
 
-  std::string baseCommand = (mProcessingSettings.rtctech.prependCommand != "" ? (mProcessingSettings.rtctech.prependCommand + " ") : "");
+  std::string baseCommand = (GetProcessingSettings().rtctech.prependCommand != "" ? (GetProcessingSettings().rtctech.prependCommand + " ") : "");
   baseCommand += (getenv("O2_GPU_RTC_OVERRIDE_CMD") ? std::string(getenv("O2_GPU_RTC_OVERRIDE_CMD")) : std::string(_binary_GPUReconstructionCUDArtc_command_start, _binary_GPUReconstructionCUDArtc_command_len));
-  baseCommand += std::string(" ") + (mProcessingSettings.rtctech.overrideArchitecture != "" ? mProcessingSettings.rtctech.overrideArchitecture : std::string(_binary_GPUReconstructionCUDArtc_command_arch_start, _binary_GPUReconstructionCUDArtc_command_arch_len));
+  baseCommand += std::string(" ") + (GetProcessingSettings().rtctech.overrideArchitecture != "" ? GetProcessingSettings().rtctech.overrideArchitecture : std::string(_binary_GPUReconstructionCUDArtc_command_arch_start, _binary_GPUReconstructionCUDArtc_command_arch_len));
 
-  if (mProcessingSettings.rtctech.loadLaunchBoundsFromFile.size()) {
-    FILE* fp = fopen(mProcessingSettings.rtctech.loadLaunchBoundsFromFile.c_str(), "rb");
+  if (GetProcessingSettings().rtctech.loadLaunchBoundsFromFile.size()) {
+    FILE* fp = fopen(GetProcessingSettings().rtctech.loadLaunchBoundsFromFile.c_str(), "rb");
     if (fp == nullptr) {
       throw std::runtime_error("Cannot open launch bounds parameter module file");
     }
@@ -75,12 +75,12 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
   }
   const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true) +
                                    "#define GPUCA_WARP_SIZE " + std::to_string(mWarpSize) + "\n";
-  if (mProcessingSettings.rtctech.printLaunchBounds || mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().rtctech.printLaunchBounds || GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("RTC Launch Bounds:\n%s", launchBounds.c_str());
   }
 
   char shasource[21], shaparam[21], shacmd[21], shakernels[21], shabounds[21];
-  if (mProcessingSettings.rtc.cacheOutput) {
+  if (GetProcessingSettings().rtc.cacheOutput) {
     o2::framework::internal::SHA1(shasource, _binary_GPUReconstructionCUDArtc_src_start, _binary_GPUReconstructionCUDArtc_src_len);
     o2::framework::internal::SHA1(shaparam, rtcparam.c_str(), rtcparam.size());
     o2::framework::internal::SHA1(shacmd, baseCommand.c_str(), baseCommand.size());
@@ -88,16 +88,16 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     o2::framework::internal::SHA1(shabounds, launchBounds.c_str(), launchBounds.size());
   }
 
-  nCompile = mProcessingSettings.rtc.compilePerKernel ? kernels.size() : 1;
+  nCompile = GetProcessingSettings().rtc.compilePerKernel ? kernels.size() : 1;
   bool cacheLoaded = false;
   int32_t fd = 0;
-  if (mProcessingSettings.rtc.cacheOutput) {
-    if (mProcessingSettings.rtctech.cacheFolder != ".") {
-      std::filesystem::create_directories(mProcessingSettings.rtctech.cacheFolder);
+  if (GetProcessingSettings().rtc.cacheOutput) {
+    if (GetProcessingSettings().rtctech.cacheFolder != ".") {
+      std::filesystem::create_directories(GetProcessingSettings().rtctech.cacheFolder);
     }
-    if (mProcessingSettings.rtctech.cacheMutex) {
+    if (GetProcessingSettings().rtctech.cacheMutex) {
       mode_t mask = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
-      fd = open((mProcessingSettings.rtctech.cacheFolder + "/cache.lock").c_str(), O_RDWR | O_CREAT | O_CLOEXEC, mask);
+      fd = open((GetProcessingSettings().rtctech.cacheFolder + "/cache.lock").c_str(), O_RDWR | O_CREAT | O_CLOEXEC, mask);
       if (fd == -1) {
         throw std::runtime_error("Error opening rtc cache mutex lock file");
       }
@@ -107,7 +107,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       }
     }
 
-    FILE* fp = fopen((mProcessingSettings.rtctech.cacheFolder + "/rtc.cuda.cache").c_str(), "rb");
+    FILE* fp = fopen((GetProcessingSettings().rtctech.cacheFolder + "/rtc.cuda.cache").c_str(), "rb");
     char sharead[20];
     if (fp) {
       size_t len;
@@ -116,7 +116,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
           if (fread(sharead, 1, 20, fp) != 20) {
             throw std::runtime_error("Cache file corrupt");
           }
-          if (mProcessingSettings.debugLevel >= 3) {
+          if (GetProcessingSettings().debugLevel >= 3) {
             char shaprint1[41], shaprint2[41];
             for (uint32_t i = 0; i < 20; i++) {
               sprintf(shaprint1 + 2 * i, "%02X ", shacmp[i]);
@@ -124,7 +124,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
             }
             GPUInfo("SHA for %s: expected %s, read %s", name, shaprint1, shaprint2);
           }
-          if (!mProcessingSettings.rtctech.ignoreCacheValid && memcmp(sharead, shacmp, 20)) {
+          if (!GetProcessingSettings().rtctech.ignoreCacheValid && memcmp(sharead, shacmp, 20)) {
             GPUInfo("Cache file content outdated (%s)", name);
             return 1;
           }
@@ -142,7 +142,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
         if (fread(&cachedSettings, sizeof(cachedSettings), 1, fp) != 1) {
           throw std::runtime_error("Cache file corrupt");
         }
-        if (!mProcessingSettings.rtctech.ignoreCacheValid && !(cachedSettings == mProcessingSettings.rtc)) {
+        if (!GetProcessingSettings().rtctech.ignoreCacheValid && !(cachedSettings == GetProcessingSettings().rtc)) {
           GPUInfo("Cache file content outdated (rtc parameters)");
           break;
         }
@@ -172,13 +172,13 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     }
   }
   if (!cacheLoaded) {
-    if (mProcessingSettings.debugLevel >= 0) {
+    if (GetProcessingSettings().debugLevel >= 0) {
       GPUInfo("Starting CUDA RTC Compilation");
     }
     HighResTimer rtcTimer;
     rtcTimer.ResetStart();
     tbb::parallel_for<uint32_t>(0, nCompile, [&](auto i) {
-      if (mProcessingSettings.debugLevel >= 3) {
+      if (GetProcessingSettings().debugLevel >= 3) {
         printf("Compiling %s\n", (filename + "_" + std::to_string(i) + mRtcSrcExtension).c_str());
       }
       FILE* fp = fopen((filename + "_" + std::to_string(i) + mRtcSrcExtension).c_str(), "w+b");
@@ -187,10 +187,10 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       }
 
       std::string kernel = "extern \"C\" {";
-      kernel += mProcessingSettings.rtc.compilePerKernel ? kernels[i] : kernelsall;
+      kernel += GetProcessingSettings().rtc.compilePerKernel ? kernels[i] : kernelsall;
       kernel += "}";
 
-      bool deterministic = mProcessingSettings.rtc.deterministic || (mProcessingSettings.rtc.compilePerKernel && o2::gpu::internal::noFastMathKernels.find(GetKernelName(i)) != o2::gpu::internal::noFastMathKernels.end());
+      bool deterministic = GetProcessingSettings().rtc.deterministic || (GetProcessingSettings().rtc.compilePerKernel && o2::gpu::internal::noFastMathKernels.find(GetKernelName(i)) != o2::gpu::internal::noFastMathKernels.end());
       const std::string deterministicStr = std::string(deterministic ? "#define GPUCA_DETERMINISTIC_CODE(det, indet) det\n" : "#define GPUCA_DETERMINISTIC_CODE(det, indet) indet\n");
 
       if (fwrite(deterministicStr.c_str(), 1, deterministicStr.size(), fp) != deterministicStr.size() ||
@@ -206,26 +206,26 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
         command += std::string(" ") + std::string(_binary_GPUReconstructionCUDArtc_command_no_fast_math_start, _binary_GPUReconstructionCUDArtc_command_no_fast_math_len);
       }
       command += " -c " + filename + "_" + std::to_string(i) + mRtcSrcExtension + " -o " + filename + "_" + std::to_string(i) + mRtcBinExtension;
-      if (mProcessingSettings.debugLevel < 0) {
+      if (GetProcessingSettings().debugLevel < 0) {
         command += " &> /dev/null";
-      } else if (mProcessingSettings.debugLevel < 2) {
+      } else if (GetProcessingSettings().debugLevel < 2) {
         command += " > /dev/null";
       }
-      if (mProcessingSettings.debugLevel >= 3) {
+      if (GetProcessingSettings().debugLevel >= 3) {
         printf("Running command %s\n", command.c_str());
       }
       if (system(command.c_str())) {
-        if (mProcessingSettings.debugLevel >= 3) {
+        if (GetProcessingSettings().debugLevel >= 3) {
           printf("Source code file: %s", filename.c_str());
         }
         throw std::runtime_error("Error during CUDA compilation");
       } // clang-format off
     }, tbb::simple_partitioner()); // clang-format on
-    if (mProcessingSettings.debugLevel >= 0) {
+    if (GetProcessingSettings().debugLevel >= 0) {
       GPUInfo("RTC Compilation finished (%f seconds)", rtcTimer.GetCurrentElapsedTime());
     }
-    if (mProcessingSettings.rtc.cacheOutput) {
-      FILE* fp = fopen((mProcessingSettings.rtctech.cacheFolder + "/rtc.cuda.cache").c_str(), "w+b");
+    if (GetProcessingSettings().rtc.cacheOutput) {
+      FILE* fp = fopen((GetProcessingSettings().rtctech.cacheFolder + "/rtc.cuda.cache").c_str(), "w+b");
       if (fp == nullptr) {
         throw std::runtime_error("Cannot open cache file for writing");
       }
@@ -236,7 +236,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
           fwrite(shacmd, 1, 20, fp) != 20 ||
           fwrite(shakernels, 1, 20, fp) != 20 ||
           fwrite(shabounds, 1, 20, fp) != 20 ||
-          fwrite(&mProcessingSettings.rtc, sizeof(mProcessingSettings.rtc), 1, fp) != 1) {
+          fwrite(&GetProcessingSettings().rtc, sizeof(GetProcessingSettings().rtc), 1, fp) != 1) {
         throw std::runtime_error("Error writing cache file");
       }
 
@@ -263,7 +263,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       fclose(fp);
     }
   }
-  if (mProcessingSettings.rtc.cacheOutput && mProcessingSettings.rtctech.cacheMutex) {
+  if (GetProcessingSettings().rtc.cacheOutput && GetProcessingSettings().rtctech.cacheMutex) {
     if (lockf(fd, F_ULOCK, 0)) {
       throw std::runtime_error("Error unlocking RTC cache mutex file");
     }
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
index f3fc21243ef0e..0813c9d22ea09 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
@@ -44,7 +44,7 @@ struct GPUReconstructionCUDAInternals {
 class GPUDebugTiming
 {
  public:
-  GPUDebugTiming(bool d, gpu_reconstruction_kernels::deviceEvent* t, cudaStream_t* s, const gpu_reconstruction_kernels::krnlSetupTime& x, GPUReconstructionCUDABackend* r) : mDeviceTimers(t), mStreams(s), mXYZ(x), mRec(r), mDo(d)
+  GPUDebugTiming(bool d, GPUReconstructionProcessing::deviceEvent* t, cudaStream_t* s, const GPUReconstructionProcessing::krnlSetupTime& x, GPUReconstructionCUDA* r) : mDeviceTimers(t), mStreams(s), mXYZ(x), mRec(r), mDo(d)
   {
     if (mDo) {
       if (mDeviceTimers) {
@@ -71,10 +71,10 @@ class GPUDebugTiming
   }
 
  private:
-  gpu_reconstruction_kernels::deviceEvent* mDeviceTimers;
+  GPUReconstructionProcessing::deviceEvent* mDeviceTimers;
   cudaStream_t* mStreams;
-  const gpu_reconstruction_kernels::krnlSetupTime& mXYZ;
-  GPUReconstructionCUDABackend* mRec;
+  const GPUReconstructionProcessing::krnlSetupTime& mXYZ;
+  GPUReconstructionCUDA* mRec;
   HighResTimer mTimer;
   bool mDo;
 };
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index d53f7cbd81ca9..758ab1b0e36c3 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -27,16 +27,16 @@ __global__ void gGPUConstantMemBuffer_dummy(int32_t* p) { *p = *(int32_t*)&gGPUC
 #endif
 
 template <>
-inline void GPUReconstructionCUDABackend::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
+inline void GPUReconstructionCUDA::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
   GPUChkErr(cudaMemsetAsync(ptr, 0, size, mInternals->Streams[_xyz.x.stream]));
 }
 
 template <class T, int32_t I, typename... Args>
-inline void GPUReconstructionCUDABackend::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
+inline void GPUReconstructionCUDA::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
 {
 #if !defined(GPUCA_KERNEL_COMPILE_MODE) || GPUCA_KERNEL_COMPILE_MODE != 1
-  if (!mProcessingSettings.rtc.enable) {
+  if (!GetProcessingSettings().rtc.enable) {
     backendInternal<T, I>::runKernelBackendMacro(_xyz, this, args...);
   } else
 #endif
@@ -56,7 +56,7 @@ inline void GPUReconstructionCUDABackend::runKernelBackendInternal(const krnlSet
 }
 
 template <class T, int32_t I, typename... Args>
-void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
+void GPUReconstructionCUDA::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
 {
   auto& x = args.s.x;
   auto& z = args.s.z;
@@ -66,7 +66,7 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
     }
   }
   {
-    GPUDebugTiming timer(mProcessingSettings.deviceTimers && mProcessingSettings.debugLevel > 0, (deviceEvent*)mDebugEvents, mInternals->Streams, args.s, this);
+    GPUDebugTiming timer(GetProcessingSettings().deviceTimers && GetProcessingSettings().debugLevel > 0, (deviceEvent*)mDebugEvents, mInternals->Streams, args.s, this);
     std::apply([this, &args](auto&... vals) { this->runKernelBackendInternal<T, I, Args...>(args.s, vals...); }, args.v);
   }
   GPUChkErr(cudaGetLastError());
@@ -79,7 +79,7 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
 
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1 // ---------- COMPILE_MODE = perkernel ----------
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) template void GPUReconstructionCUDA::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 #else // ---------- COMPILE_MODE = onefile | rdc ----------
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 2
 #define GPUCA_KRNL_DEFONLY // COMPILE_MODE = rdc
@@ -87,7 +87,7 @@ void GPUReconstructionCUDABackend::runKernelBackend(const krnlSetupArgs<T, I, Ar
 
 #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)        \
   GPUCA_KRNL_HOST(x_class, x_attributes, x_arguments, x_forward, x_types, __VA_ARGS__) \
-  template void GPUReconstructionCUDABackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
+  template void GPUReconstructionCUDA::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 
 #ifndef __HIPCC__ // CUDA version
 #define GPUCA_KRNL_CALL(x_class, ...) \
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index e276f83413bbc..28c809dd4a09a 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUReconstructionOCLIncludesHost.h"
+#include "GPUReconstructionProcessingKernels.inc"
 #include "GPUDefParametersLoad.inc"
 
 #include <map>
@@ -33,16 +34,16 @@ QGET_LD_BINARY_SYMBOLS(GPUReconstructionOCLCode_spirv);
 
 GPUReconstruction* GPUReconstruction_Create_OCL(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionOCL(cfg); }
 
-GPUReconstructionOCLBackend::GPUReconstructionOCLBackend(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionDeviceBase(cfg, sizeof(GPUReconstructionDeviceBase))
+GPUReconstructionOCL::GPUReconstructionOCL(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionProcessing::KernelInterface<GPUReconstructionOCL, GPUReconstructionDeviceBase>(cfg, sizeof(GPUReconstructionDeviceBase))
 {
   if (mMaster == nullptr) {
     mInternals = new GPUReconstructionOCLInternals;
     *mParDevice = o2::gpu::internal::GPUDefParametersLoad();
   }
-  mDeviceBackendSettings.deviceType = DeviceType::OCL;
+  mDeviceBackendSettings->deviceType = DeviceType::OCL;
 }
 
-GPUReconstructionOCLBackend::~GPUReconstructionOCLBackend()
+GPUReconstructionOCL::~GPUReconstructionOCL()
 {
   Exit(); // Make sure we destroy everything (in particular the ITS tracker) before we exit
   if (mMaster == nullptr) {
@@ -51,7 +52,7 @@ GPUReconstructionOCLBackend::~GPUReconstructionOCLBackend()
 }
 
 static_assert(sizeof(cl_int) <= sizeof(int64_t) && CL_SUCCESS == 0);
-int32_t GPUReconstructionOCLBackend::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
+int32_t GPUReconstructionOCL::GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const
 {
   // Check for OPENCL Error and in the case of an error display the corresponding error string
   if (error != CL_SUCCESS) {
@@ -60,7 +61,7 @@ int32_t GPUReconstructionOCLBackend::GPUChkErrInternal(const int64_t error, cons
   return error != CL_SUCCESS;
 }
 
-int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
+int32_t GPUReconstructionOCL::InitDevice_Runtime()
 {
   if (mMaster == nullptr) {
     cl_int ocl_error;
@@ -71,7 +72,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
     if (num_platforms == 0) {
       GPUErrorReturn("No OpenCL Platform found");
     }
-    if (mProcessingSettings.debugLevel >= 2) {
+    if (GetProcessingSettings().debugLevel >= 2) {
       GPUInfo("%d OpenCL Platforms found", num_platforms);
     }
 
@@ -118,17 +119,17 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
 
     cl_uint deviceCount, bestDevice = (cl_uint)-1, bestPlatform = (cl_uint)-1;
     for (uint32_t iPlatform = 0; iPlatform < num_platforms; iPlatform++) {
-      if (mProcessingSettings.oclPlatformNum >= 0) {
-        if (mProcessingSettings.oclPlatformNum >= (int32_t)num_platforms) {
+      if (GetProcessingSettings().oclPlatformNum >= 0) {
+        if (GetProcessingSettings().oclPlatformNum >= (int32_t)num_platforms) {
           GPUErrorReturn("Invalid platform specified");
         }
-        iPlatform = mProcessingSettings.oclPlatformNum;
+        iPlatform = GetProcessingSettings().oclPlatformNum;
       }
       std::string platformUsageInfo;
       bool platformCompatible = false;
       queryPlatform(platforms[iPlatform]);
       if (clGetDeviceIDs(platforms[iPlatform], CL_DEVICE_TYPE_ALL, 0, nullptr, &deviceCount) != CL_SUCCESS) {
-        if (mProcessingSettings.oclPlatformNum >= 0) {
+        if (GetProcessingSettings().oclPlatformNum >= 0) {
           GPUErrorReturn("No device in requested platform or error obtaining device count");
         }
         platformUsageInfo += " - no devices";
@@ -139,32 +140,32 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
         }
       }
 
-      if (mProcessingSettings.oclPlatformNum >= 0 || mProcessingSettings.debugLevel >= 2) {
-        GPUInfo("%s Platform %d: (%s %s) %s %s (Compatible: %s)%s", mProcessingSettings.oclPlatformNum >= 0 ? "Enforced" : "Available", iPlatform, platform_profile.c_str(), platform_version.c_str(), platform_vendor.c_str(), platform_name.c_str(), platformCompatible ? "yes" : "no", mProcessingSettings.debugLevel >= 2 ? platformUsageInfo.c_str() : "");
+      if (GetProcessingSettings().oclPlatformNum >= 0 || GetProcessingSettings().debugLevel >= 2) {
+        GPUInfo("%s Platform %d: (%s %s) %s %s (Compatible: %s)%s", GetProcessingSettings().oclPlatformNum >= 0 ? "Enforced" : "Available", iPlatform, platform_profile.c_str(), platform_version.c_str(), platform_vendor.c_str(), platform_name.c_str(), platformCompatible ? "yes" : "no", GetProcessingSettings().debugLevel >= 2 ? platformUsageInfo.c_str() : "");
       }
 
-      if (platformCompatible || mProcessingSettings.oclPlatformNum >= 0 || (mProcessingSettings.oclPlatformNum == -2 && deviceCount)) {
+      if (platformCompatible || GetProcessingSettings().oclPlatformNum >= 0 || (GetProcessingSettings().oclPlatformNum == -2 && deviceCount)) {
         if (deviceCount > devices.size()) {
           devices.resize(deviceCount);
         }
         if (clGetDeviceIDs(platforms[iPlatform], CL_DEVICE_TYPE_ALL, deviceCount, devices.data(), nullptr) != CL_SUCCESS) {
-          if (mProcessingSettings.oclPlatformNum >= 0) {
+          if (GetProcessingSettings().oclPlatformNum >= 0) {
             GPUErrorReturn("Error getting OpenCL devices");
           }
           continue;
         }
 
         for (uint32_t i = 0; i < deviceCount; i++) {
-          if (mProcessingSettings.deviceNum >= 0) {
-            if (mProcessingSettings.deviceNum >= (signed)deviceCount) {
-              GPUErrorReturn("Requested device ID %d does not exist", mProcessingSettings.deviceNum);
+          if (GetProcessingSettings().deviceNum >= 0) {
+            if (GetProcessingSettings().deviceNum >= (signed)deviceCount) {
+              GPUErrorReturn("Requested device ID %d does not exist", GetProcessingSettings().deviceNum);
             }
-            i = mProcessingSettings.deviceNum;
+            i = GetProcessingSettings().deviceNum;
           }
           bool deviceOK = true;
           queryDevice(devices[i]);
           std::string deviceFailure;
-          if (mProcessingSettings.gpuDeviceOnly && ((device_type & CL_DEVICE_TYPE_CPU) || !(device_type & CL_DEVICE_TYPE_GPU))) {
+          if (GetProcessingSettings().gpuDeviceOnly && ((device_type & CL_DEVICE_TYPE_CPU) || !(device_type & CL_DEVICE_TYPE_GPU))) {
             deviceOK = false;
             deviceFailure += " - No GPU device";
           }
@@ -193,12 +194,12 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
           }
 
           double bestDeviceSpeed = -1, deviceSpeed = (double)device_freq * (double)device_shaders;
-          if (mProcessingSettings.debugLevel >= 2) {
+          if (GetProcessingSettings().debugLevel >= 2) {
             GPUInfo("  Device %s%2d: %s %s (Frequency %d, Shaders %d, %d bit) (Speed Value: %ld)%s %s", deviceOK ? " " : "[", i, device_vendor.c_str(), device_name.c_str(), (int32_t)device_freq, (int32_t)device_shaders, (int32_t)device_nbits, (int64_t)deviceSpeed, deviceOK ? " " : " ]", deviceOK ? "" : deviceFailure.c_str());
           }
           if (!deviceOK) {
-            if (mProcessingSettings.deviceNum >= 0) {
-              GPUInfo("Unsupported device requested on platform %d: (%d)", iPlatform, mProcessingSettings.deviceNum);
+            if (GetProcessingSettings().deviceNum >= 0) {
+              GPUInfo("Unsupported device requested on platform %d: (%d)", iPlatform, GetProcessingSettings().deviceNum);
               break;
             }
             continue;
@@ -209,12 +210,12 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
             bestDeviceSpeed = deviceSpeed;
             mOclVersion = platform_version_f;
           }
-          if (mProcessingSettings.deviceNum >= 0) {
+          if (GetProcessingSettings().deviceNum >= 0) {
             break;
           }
         }
       }
-      if (mProcessingSettings.oclPlatformNum >= 0) {
+      if (GetProcessingSettings().oclPlatformNum >= 0) {
         break;
       }
     }
@@ -238,7 +239,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
     deviceVersion = query(clGetDeviceInfo, mInternals->device, CL_DEVICE_VERSION);
     int versionMajor, versionMinor;
     sscanf(deviceVersion.c_str(), "OpenCL %d.%d", &versionMajor, &versionMinor);
-    if (mProcessingSettings.debugLevel >= 2) {
+    if (GetProcessingSettings().debugLevel >= 2) {
       GPUInfo("Using OpenCL platform %d / device %d: %s %s with properties:", bestPlatform, bestDevice, device_vendor.c_str(), device_name.c_str());
       GPUInfo("\tVersion = %s", deviceVersion);
       GPUInfo("\tFrequency = %d", (int32_t)device_freq);
@@ -271,7 +272,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
       return 1;
     }
 
-    if (mProcessingSettings.debugLevel >= 2) {
+    if (GetProcessingSettings().debugLevel >= 2) {
       GPUInfo("OpenCL program and kernels loaded successfully");
     }
 
@@ -289,21 +290,21 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
     }
 
     if (device_type & CL_DEVICE_TYPE_CPU) {
-      if (mProcessingSettings.deviceTimers && mProcessingSettings.debugLevel >= 2) {
+      if (GetProcessingSettings().deviceTimers && GetProcessingSettings().debugLevel >= 2) {
         GPUInfo("Disabling device timers for CPU device");
       }
-      mProcessingSettings.deviceTimers = 0;
+      mProcessingSettings->deviceTimers = 0;
     }
     for (int32_t i = 0; i < mNStreams; i++) {
 #ifdef CL_VERSION_2_0
       cl_queue_properties prop = 0;
-      if (versionMajor >= 2 && IsGPU() && mProcessingSettings.deviceTimers) {
+      if (versionMajor >= 2 && IsGPU() && GetProcessingSettings().deviceTimers) {
         prop |= CL_QUEUE_PROFILING_ENABLE;
       }
       mInternals->command_queue[i] = clCreateCommandQueueWithProperties(mInternals->context, mInternals->device, &prop, &ocl_error);
-      if (mProcessingSettings.deviceTimers && ocl_error == CL_INVALID_QUEUE_PROPERTIES) {
+      if (GetProcessingSettings().deviceTimers && ocl_error == CL_INVALID_QUEUE_PROPERTIES) {
         GPUError("GPU device timers not supported by OpenCL platform, disabling");
-        mProcessingSettings.deviceTimers = 0;
+        mProcessingSettings->deviceTimers = 0;
         prop = 0;
         mInternals->command_queue[i] = clCreateCommandQueueWithProperties(mInternals->context, mInternals->device, &prop, &ocl_error);
       }
@@ -351,7 +352,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
       GPUErrorReturn("Error obtaining device memory ptr");
     }
 
-    if (mProcessingSettings.debugLevel >= 2) {
+    if (GetProcessingSettings().debugLevel >= 2) {
       GPUInfo("Mapping hostmemory");
     }
     mHostMemoryBase = clEnqueueMapBuffer(mInternals->command_queue[0], mInternals->mem_host, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, 0, mHostMemorySize, 0, nullptr, nullptr, &ocl_error);
@@ -362,7 +363,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
     mDeviceMemoryBase = ((void**)mHostMemoryBase)[0];
     mDeviceConstantMem = (GPUConstantMem*)((void**)mHostMemoryBase)[1];
 
-    if (mProcessingSettings.debugLevel >= 1) {
+    if (GetProcessingSettings().debugLevel >= 1) {
       GPUInfo("Memory ptrs: GPU (%ld bytes): %p - Host (%ld bytes): %p", (int64_t)mDeviceMemorySize, mDeviceMemoryBase, (int64_t)mHostMemorySize, mHostMemoryBase);
       memset(mHostMemoryBase, 0xDD, mHostMemorySize);
     }
@@ -386,7 +387,7 @@ int32_t GPUReconstructionOCLBackend::InitDevice_Runtime()
   return (0);
 }
 
-int32_t GPUReconstructionOCLBackend::ExitDevice_Runtime()
+int32_t GPUReconstructionOCL::ExitDevice_Runtime()
 {
   // Uninitialize OPENCL
   SynchronizeGPU();
@@ -418,12 +419,12 @@ int32_t GPUReconstructionOCLBackend::ExitDevice_Runtime()
   return (0);
 }
 
-size_t GPUReconstructionOCLBackend::GPUMemCpy(void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev, deviceEvent* evList, int32_t nEvents)
+size_t GPUReconstructionOCL::GPUMemCpy(void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev, deviceEvent* evList, int32_t nEvents)
 {
   if (evList == nullptr) {
     nEvents = 0;
   }
-  if (mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().debugLevel >= 3) {
     stream = -1;
   }
   if (stream == -1) {
@@ -440,33 +441,33 @@ size_t GPUReconstructionOCLBackend::GPUMemCpy(void* dst, const void* src, size_t
   } else {
     GPUChkErr(clEnqueueReadBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_gpu, stream == -1, (char*)src - (char*)mDeviceMemoryBase, size, dst, nEvents, evList->getEventList<cl_event>(), ev->getEventList<cl_event>()));
   }
-  if (mProcessingSettings.serializeGPU & 2) {
+  if (GetProcessingSettings().serializeGPU & 2) {
     GPUDebug(("GPUMemCpy " + std::to_string(toGPU)).c_str(), stream, true);
   }
   return size;
 }
 
-size_t GPUReconstructionOCLBackend::WriteToConstantMemory(size_t offset, const void* src, size_t size, int32_t stream, deviceEvent* ev)
+size_t GPUReconstructionOCL::WriteToConstantMemory(size_t offset, const void* src, size_t size, int32_t stream, deviceEvent* ev)
 {
   if (stream == -1) {
     SynchronizeGPU();
   }
   GPUChkErr(clEnqueueWriteBuffer(mInternals->command_queue[stream == -1 ? 0 : stream], mInternals->mem_constant, stream == -1, offset, size, src, 0, nullptr, ev->getEventList<cl_event>()));
-  if (mProcessingSettings.serializeGPU & 2) {
+  if (GetProcessingSettings().serializeGPU & 2) {
     GPUDebug("WriteToConstantMemory", stream, true);
   }
   return size;
 }
 
-void GPUReconstructionOCLBackend::ReleaseEvent(deviceEvent ev) { GPUChkErr(clReleaseEvent(ev.get<cl_event>())); }
+void GPUReconstructionOCL::ReleaseEvent(deviceEvent ev) { GPUChkErr(clReleaseEvent(ev.get<cl_event>())); }
 
-void GPUReconstructionOCLBackend::RecordMarker(deviceEvent* ev, int32_t stream) { GPUChkErr(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev->getEventList<cl_event>())); }
+void GPUReconstructionOCL::RecordMarker(deviceEvent* ev, int32_t stream) { GPUChkErr(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev->getEventList<cl_event>())); }
 
-int32_t GPUReconstructionOCLBackend::DoStuckProtection(int32_t stream, deviceEvent event)
+int32_t GPUReconstructionOCL::DoStuckProtection(int32_t stream, deviceEvent event)
 {
-  if (mProcessingSettings.stuckProtection) {
+  if (GetProcessingSettings().stuckProtection) {
     cl_int tmp = 0;
-    for (int32_t i = 0; i <= mProcessingSettings.stuckProtection / 50; i++) {
+    for (int32_t i = 0; i <= GetProcessingSettings().stuckProtection / 50; i++) {
       usleep(50);
       clGetEventInfo(event.get<cl_event>(), CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(tmp), &tmp, nullptr);
       if (tmp == CL_COMPLETE) {
@@ -483,25 +484,25 @@ int32_t GPUReconstructionOCLBackend::DoStuckProtection(int32_t stream, deviceEve
   return 0;
 }
 
-void GPUReconstructionOCLBackend::SynchronizeGPU()
+void GPUReconstructionOCL::SynchronizeGPU()
 {
   for (int32_t i = 0; i < mNStreams; i++) {
     GPUChkErr(clFinish(mInternals->command_queue[i]));
   }
 }
 
-void GPUReconstructionOCLBackend::SynchronizeStream(int32_t stream) { GPUChkErr(clFinish(mInternals->command_queue[stream])); }
+void GPUReconstructionOCL::SynchronizeStream(int32_t stream) { GPUChkErr(clFinish(mInternals->command_queue[stream])); }
 
-void GPUReconstructionOCLBackend::SynchronizeEvents(deviceEvent* evList, int32_t nEvents) { GPUChkErr(clWaitForEvents(nEvents, evList->getEventList<cl_event>())); }
+void GPUReconstructionOCL::SynchronizeEvents(deviceEvent* evList, int32_t nEvents) { GPUChkErr(clWaitForEvents(nEvents, evList->getEventList<cl_event>())); }
 
-void GPUReconstructionOCLBackend::StreamWaitForEvents(int32_t stream, deviceEvent* evList, int32_t nEvents)
+void GPUReconstructionOCL::StreamWaitForEvents(int32_t stream, deviceEvent* evList, int32_t nEvents)
 {
   if (nEvents) {
     GPUChkErr(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], nEvents, evList->getEventList<cl_event>(), nullptr));
   }
 }
 
-bool GPUReconstructionOCLBackend::IsEventDone(deviceEvent* evList, int32_t nEvents)
+bool GPUReconstructionOCL::IsEventDone(deviceEvent* evList, int32_t nEvents)
 {
   cl_int eventdone;
   for (int32_t i = 0; i < nEvents; i++) {
@@ -513,10 +514,10 @@ bool GPUReconstructionOCLBackend::IsEventDone(deviceEvent* evList, int32_t nEven
   return true;
 }
 
-int32_t GPUReconstructionOCLBackend::GPUDebug(const char* state, int32_t stream, bool force)
+int32_t GPUReconstructionOCL::GPUDebug(const char* state, int32_t stream, bool force)
 {
   // Wait for OPENCL-Kernel to finish and check for OPENCL errors afterwards, in case of debugmode
-  if (!force && mProcessingSettings.debugLevel <= 0) {
+  if (!force && GetProcessingSettings().debugLevel <= 0) {
     return (0);
   }
   for (int32_t i = 0; i < mNStreams; i++) {
@@ -524,13 +525,13 @@ int32_t GPUReconstructionOCLBackend::GPUDebug(const char* state, int32_t stream,
       GPUError("OpenCL Error while synchronizing (%s) (Stream %d/%d)", state, stream, i);
     }
   }
-  if (mProcessingSettings.debugLevel >= 3) {
+  if (GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("GPU Sync Done");
   }
   return (0);
 }
 
-int32_t GPUReconstructionOCLBackend::GetOCLPrograms()
+int32_t GPUReconstructionOCL::GetOCLPrograms()
 {
   cl_int ocl_error;
 
@@ -571,7 +572,7 @@ int32_t GPUReconstructionOCLBackend::GetOCLPrograms()
   return AddKernels();
 }
 
-const char* GPUReconstructionOCLBackend::convertErrorToString(int32_t errorcode)
+const char* GPUReconstructionOCL::convertErrorToString(int32_t errorcode)
 {
   static const std::map<cl_int, const char*> error_map = {
     {CL_SUCCESS, "CL_SUCCESS"},
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index abde42f01f073..091bc0409630d 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -27,14 +27,16 @@ namespace o2::gpu
 {
 struct GPUReconstructionOCLInternals;
 
-class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
+class GPUReconstructionOCL : public GPUReconstructionProcessing::KernelInterface<GPUReconstructionOCL, GPUReconstructionDeviceBase>
 {
  public:
-  ~GPUReconstructionOCLBackend() override;
+  GPUReconstructionOCL(const GPUSettingsDeviceBackend& cfg);
+  ~GPUReconstructionOCL() override;
 
- protected:
-  GPUReconstructionOCLBackend(const GPUSettingsDeviceBackend& cfg);
+  template <class T, int32_t I = 0, typename... Args>
+  void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
 
+ protected:
   int32_t InitDevice_Runtime() override;
   int32_t ExitDevice_Runtime() override;
 
@@ -61,8 +63,6 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
   GPUReconstructionOCLInternals* mInternals;
   float mOclVersion;
 
-  template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
   template <class S, class T, int32_t I>
   S& getKernelObject();
 
@@ -78,7 +78,6 @@ class GPUReconstructionOCLBackend : public GPUReconstructionDeviceBase
   int32_t AddKernels();
 };
 
-using GPUReconstructionOCL = GPUReconstructionKernels<GPUReconstructionOCLBackend>;
 } // namespace o2::gpu
 
 #endif
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
index 0bb2f25093789..919791948d6c3 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
@@ -54,7 +54,7 @@ struct GPUReconstructionOCLInternals {
 } // namespace o2::gpu
 
 template <typename T, typename... Args>
-inline int64_t GPUReconstructionOCLBackend::OCLsetKernelParameters_helper(cl_kernel& kernel, int32_t i, const T& firstParameter, const Args&... restOfParameters)
+inline int64_t GPUReconstructionOCL::OCLsetKernelParameters_helper(cl_kernel& kernel, int32_t i, const T& firstParameter, const Args&... restOfParameters)
 {
   int64_t retVal = clSetKernelArg(kernel, i, sizeof(T), &firstParameter);
   if (retVal) {
@@ -67,12 +67,12 @@ inline int64_t GPUReconstructionOCLBackend::OCLsetKernelParameters_helper(cl_ker
 }
 
 template <typename... Args>
-inline int64_t GPUReconstructionOCLBackend::OCLsetKernelParameters(cl_kernel& kernel, const Args&... args)
+inline int64_t GPUReconstructionOCL::OCLsetKernelParameters(cl_kernel& kernel, const Args&... args)
 {
   return OCLsetKernelParameters_helper(kernel, 0, args...);
 }
 
-inline int64_t GPUReconstructionOCLBackend::clExecuteKernelA(cl_command_queue queue, cl_kernel krnl, size_t local_size, size_t global_size, cl_event* pEvent, cl_event* wait, cl_int nWaitEvents)
+inline int64_t GPUReconstructionOCL::clExecuteKernelA(cl_command_queue queue, cl_kernel krnl, size_t local_size, size_t global_size, cl_event* pEvent, cl_event* wait, cl_int nWaitEvents)
 {
   return clEnqueueNDRangeKernel(queue, krnl, 1, nullptr, &global_size, &local_size, wait == nullptr ? 0 : nWaitEvents, wait, pEvent);
 }
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index cca634fba65fc..29b71017e9f73 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -13,16 +13,17 @@
 /// \author David Rohr
 
 #include "GPUReconstructionOCLIncludesHost.h"
+#include "GPUReconstructionKernelIncludes.h"
 
 template <>
-inline void GPUReconstructionOCLBackend::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
+inline void GPUReconstructionOCL::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
   cl_int4 val0 = {0, 0, 0, 0};
   GPUChkErr(clEnqueueFillBuffer(mInternals->command_queue[_xyz.x.stream], mInternals->mem_gpu, &val0, sizeof(val0), (char*)ptr - (char*)mDeviceMemoryBase, (size + sizeof(val0) - 1) & ~(sizeof(val0) - 1), _xyz.z.evList == nullptr ? 0 : _xyz.z.nEvents, _xyz.z.evList->getEventList<cl_event>(), _xyz.z.ev->getEventList<cl_event>()));
 }
 
 template <class T, int32_t I, typename... Args>
-inline void GPUReconstructionOCLBackend::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
+inline void GPUReconstructionOCL::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
 {
   cl_kernel k = getKernelObject<cl_kernel, T, I>();
   auto& x = _xyz.x;
@@ -33,14 +34,14 @@ inline void GPUReconstructionOCLBackend::runKernelBackendInternal(const krnlSetu
   cl_event ev;
   cl_event* evr;
   bool tmpEvent = false;
-  if (z.ev == nullptr && mProcessingSettings.deviceTimers && mProcessingSettings.debugLevel > 0) {
+  if (z.ev == nullptr && GetProcessingSettings().deviceTimers && GetProcessingSettings().debugLevel > 0) {
     evr = &ev;
     tmpEvent = true;
   } else {
     evr = (cl_event*)z.ev;
   }
   GPUChkErr(clExecuteKernelA(mInternals->command_queue[x.stream], k, x.nThreads, x.nThreads * x.nBlocks, evr, (cl_event*)z.evList, z.nEvents));
-  if (mProcessingSettings.deviceTimers && mProcessingSettings.debugLevel > 0) {
+  if (GetProcessingSettings().deviceTimers && GetProcessingSettings().debugLevel > 0) {
     cl_ulong time_start, time_end;
     GPUChkErr(clWaitForEvents(1, evr));
     GPUChkErr(clGetEventProfilingInfo(*evr, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, nullptr));
@@ -53,13 +54,13 @@ inline void GPUReconstructionOCLBackend::runKernelBackendInternal(const krnlSetu
 }
 
 template <class T, int32_t I, typename... Args>
-void GPUReconstructionOCLBackend::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
+void GPUReconstructionOCL::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
 {
   std::apply([this, &args](auto&... vals) { runKernelBackendInternal<T, I, Args...>(args.s, vals...); }, args.v);
 }
 
 template <class T, int32_t I>
-int32_t GPUReconstructionOCLBackend::AddKernel()
+int32_t GPUReconstructionOCL::AddKernel()
 {
   std::string name(GetKernelName<T, I>());
   std::string kname("krnl_" + name);
@@ -75,12 +76,12 @@ int32_t GPUReconstructionOCLBackend::AddKernel()
 }
 
 template <class S, class T, int32_t I>
-S& GPUReconstructionOCLBackend::getKernelObject()
+S& GPUReconstructionOCL::getKernelObject()
 {
   return mInternals->kernels[GetKernelNum<T, I>()];
 }
 
-int32_t GPUReconstructionOCLBackend::AddKernels()
+int32_t GPUReconstructionOCL::AddKernels()
 {
 #define GPUCA_KRNL(x_class, ...)                     \
   if (AddKernel<GPUCA_M_KRNL_TEMPLATE(x_class)>()) { \
@@ -91,6 +92,6 @@ int32_t GPUReconstructionOCLBackend::AddKernels()
   return 0;
 }
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) template void GPUReconstructionOCLBackend::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) template void GPUReconstructionOCL::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index e82799b9e59c3..0cd302cc0be94 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -113,7 +113,7 @@ set(HDRS_INSTALL
     Base/GPUReconstructionIO.h
     Base/GPUReconstructionIncludesITS.h
     Base/GPUReconstructionKernelMacros.h
-    Base/GPUReconstructionKernels.h
+    Base/GPUReconstructionCPUKernels.h
     DataCompression/GPUTPCClusterRejection.h
     DataCompression/GPUTPCCompressionKernels.inc
     DataCompression/TPCClusterDecompressionCore.inc
@@ -127,6 +127,7 @@ set(HDRS_INSTALL
     DataTypes/GPUTRDDef.h
     DataTypes/GPUTRDInterfaceO2Track.h
     DataTypes/GPUTriggerOutputs.h
+    DataTypes/GPUKernelClassesFwd.h
     Debug/GPUROOTDump.h
     Definitions/GPUDefConstantsAndSettings.h
     Definitions/GPUDefParametersWrapper.h
@@ -137,6 +138,7 @@ set(HDRS_INSTALL
     Definitions/GPULogging.h
     Definitions/GPUSettingsList.h
     Global/GPUChainTrackingDefs.h
+    Global/GPUChainTrackingGetters.inc
     Global/GPUErrorCodes.h
     Merger/GPUTPCGMBorderTrack.h
     Merger/GPUTPCGMMergedTrack.h
@@ -217,11 +219,11 @@ set(SRCS_NO_H ${SRCS_NO_H}
 
 set(HDRS_INSTALL ${HDRS_INSTALL}
                   ITS/GPUITSTrack.h
-                  TPCClusterFinder/Array2D.h
+                  TPCClusterFinder/CfArray2D.h
                   TPCClusterFinder/CfConsts.h
                   TPCClusterFinder/CfFragment.h
                   TPCClusterFinder/CfUtils.h
-                  TPCClusterFinder/ChargePos.h
+                  TPCClusterFinder/CfChargePos.h
                   Definitions/clusterFinderDefs.h
                   TPCClusterFinder/PackedCharge.h
                   TPCClusterFinder/GPUTPCCFChainContext.h)
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index 8a22545314252..2a0c5b58d8a83 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -17,6 +17,7 @@
 #include "GPUO2DataTypes.h"
 #include "GPUMemorySizeScalers.h"
 #include "GPUDefParametersRuntime.h"
+#include "GPUConstantMem.h"
 
 using namespace o2::gpu;
 
@@ -123,7 +124,7 @@ void GPUTPCCompression::SetMaxData(const GPUTrackingInOutPointers& io)
   mMaxClusters = io.clustersNative->nClustersTotal;
   mMaxClusterFactorBase1024 = mMaxClusters > 100000000 ? mRec->MemoryScalers()->NTPCUnattachedHitsBase1024(mRec->GetParam().rec.tpc.rejectionStrategy) : 1024;
   mMaxClustersInCache = mMaxClusters * mMaxClusterFactorBase1024 / 1024;
-  mMaxTrackClusters = mRec->GetConstantMem().tpcMerger.NOutputTrackClusters();
+  mMaxTrackClusters = mRec->GetConstantMem().tpcMerger.NOutputTrackClusters(); // TODO: Why is this not using ioPtrs? Could remove GPUConstantMem.h include
   mMaxTracks = mRec->GetConstantMem().tpcMerger.NOutputTracks();
   if (mMaxClusters % 16) {
     mMaxClusters += 16 - (mMaxClusters % 16);
diff --git a/GPU/GPUTracking/DataTypes/GPUKernelClassesFwd.h b/GPU/GPUTracking/DataTypes/GPUKernelClassesFwd.h
new file mode 100644
index 0000000000000..405eb339dea3b
--- /dev/null
+++ b/GPU/GPUTracking/DataTypes/GPUKernelClassesFwd.h
@@ -0,0 +1,40 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUKernelClassesFwd.h
+/// \author David Rohr
+
+#ifndef GPUKERNELCLASSESFWDN_H
+#define GPUKERNELCLASSESFWDN_H
+
+#include "GPUTRDDef.h"
+
+namespace o2::gpu
+{
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) class GPUCA_M_FIRST(GPUCA_M_STRIP(x_class));
+#include "GPUReconstructionKernelList.h"
+#undef GPUCA_KRNL
+
+struct GPUTPCClusterOccupancyMapBin;
+namespace gputpcgmmergertypes
+{
+struct GPUTPCGMBorderRange;
+}
+struct GPUTPCLinearLabels;
+struct CfChargePos;
+} // namespace o2::gpu
+
+namespace o2::tpc
+{
+struct ClusterNative;
+} // namespace o2::tpc
+
+#endif
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index 1e99e3b73736f..5df324fcba648 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -16,11 +16,14 @@
 #define GPUCHAIN_H
 
 #include "GPUReconstructionCPU.h"
+#include "GPUReconstructionCPUKernels.h"
+#include "GPUKernelClassesFwd.h"
 
 #include <ctime>
 
 namespace o2::gpu
 {
+
 class GPUChain
 {
   friend class GPUReconstruction;
@@ -30,10 +33,10 @@ class GPUChain
   using GeneralStep = GPUReconstruction::GeneralStep;
   using InOutPointerType = GPUReconstruction::InOutPointerType;
   using GeometryType = GPUReconstruction::GeometryType;
-  using krnlRunRange = gpu_reconstruction_kernels::krnlRunRange;
-  using krnlExec = gpu_reconstruction_kernels::krnlExec;
-  using krnlEvent = gpu_reconstruction_kernels::krnlEvent;
-  using deviceEvent = gpu_reconstruction_kernels::deviceEvent;
+  using krnlRunRange = GPUReconstructionProcessing::krnlRunRange;
+  using krnlExec = GPUReconstructionProcessing::krnlExec;
+  using krnlEvent = GPUReconstructionProcessing::krnlEvent;
+  using deviceEvent = GPUReconstructionProcessing::deviceEvent;
   static constexpr krnlRunRange krnlRunRangeNone{0};
   static constexpr krnlEvent krnlEventNone = krnlEvent{nullptr, nullptr, 0};
 
@@ -56,20 +59,20 @@ class GPUChain
   virtual void DumpSettings(const char* dir = "") {}
   virtual void ReadSettings(const char* dir = "") {}
 
-  const GPUParam& GetParam() const { return mRec->mHostConstantMem->param; }
-  const GPUSettingsGRP& GetGRPSettings() const { return mRec->mGRPSettings; }
-  const GPUCalibObjectsConst& calib() const { return processors()->calibObjects; }
+  const GPUParam& GetParam() const { return mRec->GetParam(); }
+  const GPUSettingsGRP& GetGRPSettings() const { return mRec->GetGRPSettings(); }
+  const GPUCalibObjectsConst& GetCalib() const { return mRec->GetCalib(); }
   GPUReconstruction* rec() { return mRec; }
   const GPUReconstruction* rec() const { return mRec; }
-  inline const GPUConstantMem* GetProcessors() { return mRec->processors(); }
+  inline const GPUConstantMem* GetProcessors() const { return mRec->processors(); }
 
   // Make functions from GPUReconstruction*** available
   GPUReconstruction::RecoStepField GetRecoSteps() const { return mRec->GetRecoSteps(); }
   GPUReconstruction::RecoStepField GetRecoStepsGPU() const { return mRec->GetRecoStepsGPU(); }
   GPUReconstruction::InOutTypeField GetRecoStepsInputs() const { return mRec->GetRecoStepsInputs(); }
   GPUReconstruction::InOutTypeField GetRecoStepsOutputs() const { return mRec->GetRecoStepsOutputs(); }
-  inline const GPUSettingsDeviceBackend& GetDeviceBackendSettings() const { return mRec->mDeviceBackendSettings; }
-  inline const GPUSettingsProcessing& GetProcessingSettings() const { return mRec->mProcessingSettings; }
+  inline const GPUSettingsDeviceBackend& GetDeviceBackendSettings() const { return mRec->GetDeviceBackendSettings(); }
+  inline const GPUSettingsProcessing& GetProcessingSettings() const { return mRec->GetProcessingSettings(); }
 
  protected:
   GPUReconstructionCPU* mRec;
@@ -102,7 +105,7 @@ class GPUChain
   }
   inline bool IsEventDone(deviceEvent* evList, int32_t nEvents = 1) { return mRec->IsEventDone(evList, nEvents); }
   inline void RecordMarker(deviceEvent* ev, int32_t stream) { mRec->RecordMarker(ev, stream); }
-  virtual inline std::unique_ptr<gpu_reconstruction_kernels::threadContext> GetThreadContext() { return mRec->GetThreadContext(); }
+  virtual inline std::unique_ptr<GPUReconstructionProcessing::threadContext> GetThreadContext() { return mRec->GetThreadContext(); }
   inline void SynchronizeGPU() { mRec->SynchronizeGPU(); }
   inline void ReleaseEvent(deviceEvent ev, bool doGPU = true)
   {
@@ -171,13 +174,16 @@ class GPUChain
   {
     mRec->ReadStructFromFile<T>(file, obj);
   }
+
   template <class S, int32_t I = 0, typename... Args>
-  inline void runKernel(gpu_reconstruction_kernels::krnlSetup&& setup, Args&&... args)
+    requires(sizeof(S) >= 0) // Yields better incomplete type errors than calling runKernelCallInterface directly
+  inline void runKernel(GPUReconstructionProcessing::krnlSetup&& setup, Args const&... args)
   {
-    return mRec->runKernel<S, I, Args...>(std::forward<gpu_reconstruction_kernels::krnlSetup&&>(setup), std::forward<Args>(args)...);
+    runKernelCallInterface<S, I>(std::forward<GPUReconstructionProcessing::krnlSetup&&>(setup), args...);
   }
+
   template <class S, int32_t I = 0>
-  gpu_reconstruction_kernels::krnlProperties getKernelProperties()
+  GPUReconstructionProcessing::krnlProperties getKernelProperties()
   {
     return mRec->getKernelProperties<S, I>();
   }
@@ -233,6 +239,16 @@ class GPUChain
  private:
   template <bool Always = false, class T, class S, typename... Args>
   void timeCpy(RecoStep step, int32_t toGPU, S T::*func, Args... args);
+
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)                                                                                                                                                                             \
+  template <class S, int32_t I>                                                                                                                                                                                                                             \
+    requires(std::is_same_v<S, GPUCA_M_FIRST(GPUCA_M_STRIP(x_class))> && I == S::GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_M_STRIP(x_class), defaultKernel)))                                                                                                       \
+  inline void runKernelCallInterface(GPUReconstructionProcessing::krnlSetup&& setup GPUCA_M_STRIP(x_arguments))                                                                                                                                             \
+  {                                                                                                                                                                                                                                                         \
+    mRec->runKernelInterface<GPUCA_M_FIRST(GPUCA_M_STRIP(x_class)), S::GPUCA_M_FIRST(GPUCA_M_SHIFT(GPUCA_M_STRIP(x_class), defaultKernel)) GPUCA_M_STRIP(x_types)>(std::forward<GPUReconstructionProcessing::krnlSetup&&>(setup) GPUCA_M_STRIP(x_forward)); \
+  }
+#include "GPUReconstructionKernelList.h"
+#undef GPUCA_KRNL
 };
 
 template <bool Always, class T, class S, typename... Args>
@@ -243,7 +259,7 @@ inline void GPUChain::timeCpy(RecoStep step, int32_t toGPU, S T::*func, Args...
   }
   HighResTimer* timer = nullptr;
   size_t* bytes = nullptr;
-  if (mRec->mProcessingSettings.debugLevel >= 1 && toGPU >= 0) { // Todo: time special cases toGPU < 0
+  if (mRec->GetProcessingSettings().debugLevel >= 1 && toGPU >= 0) { // Todo: time special cases toGPU < 0
     int32_t id = mRec->getRecoStepNum(step, false);
     if (id != -1) {
       auto& tmp = mRec->mTimersRecoSteps[id];
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index 640b92a0eb0f4..eeead79b1840b 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUChainITS.h"
+#include "GPUConstantMem.h"
 #include "DataFormatsITS/TrackITS.h"
 #include "ITStracking/ExternalAllocator.h"
 #include "GPUReconstructionIncludesITS.h"
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 43fa49ff74817..a3f9b996e070d 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -18,6 +18,8 @@
 #include <chrono>
 
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
+#include "GPUReconstructionIO.h"
 #include "GPUChainTrackingDefs.h"
 #include "GPUTPCClusterData.h"
 #include "GPUTPCSectorOutCluster.h"
@@ -755,7 +757,7 @@ int32_t GPUChainTracking::RunChain()
     }
   }
 
-  if (GetProcessingSettings().trdTrackModelO2 ? runRecoStep(RecoStep::TRDTracking, &GPUChainTracking::RunTRDTracking<GPUTRDTrackerKernels::o2Version>) : runRecoStep(RecoStep::TRDTracking, &GPUChainTracking::RunTRDTracking<GPUTRDTrackerKernels::gpuVersion>)) {
+  if (runRecoStep(RecoStep::TRDTracking, &GPUChainTracking::RunTRDTracking)) {
     return 1;
   }
 
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 5779cec31130c..8664652b549e3 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -24,6 +24,12 @@
 #include <vector>
 #include <utility>
 
+namespace o2::dataformats
+{
+template <typename TruthElement>
+class ConstMCTruthContainer;
+} // namespace o2::dataformats
+
 namespace o2::trd
 {
 class GeometryFlat;
@@ -39,6 +45,9 @@ class CalibdEdxContainer;
 namespace o2::base
 {
 class MatLayerCylSet;
+template <typename>
+class PropagatorImpl;
+using Propagator = PropagatorImpl<float>;
 } // namespace o2::base
 
 namespace o2::gpu
@@ -55,6 +64,8 @@ struct GPUChainTrackingFinalContext;
 struct GPUTPCCFChainContext;
 struct GPUNewCalibValues;
 struct GPUTriggerOutputs;
+struct CfFragment;
+class GPUTPCClusterFinder;
 
 class GPUChainTracking : public GPUChain
 {
@@ -137,11 +148,6 @@ class GPUChainTracking : public GPUChain
   void ConvertZSFilter(bool zs12bit);
 
   // Getters for external usage of tracker classes
-  GPUTRDTrackerGPU* GetTRDTrackerGPU() { return &processors()->trdTrackerGPU; }
-  GPUTPCTracker* GetTPCSectorTrackers() { return processors()->tpcTrackers; }
-  const GPUTPCTracker* GetTPCSectorTrackers() const { return processors()->tpcTrackers; }
-  const GPUTPCGMMerger& GetTPCMerger() const { return processors()->tpcMerger; }
-  GPUTPCGMMerger& GetTPCMerger() { return processors()->tpcMerger; }
   GPUDisplayInterface* GetEventDisplay() { return mEventDisplay.get(); }
   const GPUQA* GetQA() const { return mQAFromForeignChain ? mQAFromForeignChain->mQA.get() : mQA.get(); }
   GPUQA* GetQA() { return mQAFromForeignChain ? mQAFromForeignChain->mQA.get() : mQA.get(); }
@@ -155,7 +161,6 @@ class GPUChainTracking : public GPUChain
   int32_t ForwardTPCDigits();
   int32_t RunTPCTrackingSectors();
   int32_t RunTPCTrackingMerger(bool synchronizeOutput = true);
-  template <int32_t I>
   int32_t RunTRDTracking();
   template <int32_t I, class T = GPUTRDTracker>
   int32_t DoTRDGPUTracking(T* externalInstance = nullptr);
@@ -164,22 +169,22 @@ class GPUChainTracking : public GPUChain
   int32_t RunRefit();
 
   // Getters / setters for parameters
-  const CorrectionMapsHelper* GetTPCTransformHelper() const { return processors()->calibObjects.fastTransformHelper; }
-  const TPCPadGainCalib* GetTPCPadGainCalib() const { return processors()->calibObjects.tpcPadGain; }
-  const TPCZSLinkMapping* GetTPCZSLinkMapping() const { return processors()->calibObjects.tpcZSLinkMapping; }
-  const o2::tpc::CalibdEdxContainer* GetdEdxCalibContainer() const { return processors()->calibObjects.dEdxCalibContainer; }
-  const o2::base::MatLayerCylSet* GetMatLUT() const { return processors()->calibObjects.matLUT; }
-  const GPUTRDGeometry* GetTRDGeometry() const { return (GPUTRDGeometry*)processors()->calibObjects.trdGeometry; }
-  const o2::base::Propagator* GetO2Propagator() const { return processors()->calibObjects.o2Propagator; }
+  const CorrectionMapsHelper* GetTPCTransformHelper() const;
+  const TPCPadGainCalib* GetTPCPadGainCalib() const;
+  const TPCZSLinkMapping* GetTPCZSLinkMapping() const;
+  const o2::tpc::CalibdEdxContainer* GetdEdxCalibContainer() const;
+  const o2::base::MatLayerCylSet* GetMatLUT() const;
+  const GPUTRDGeometry* GetTRDGeometry() const;
+  const o2::base::Propagator* GetO2Propagator() const;
   const o2::base::Propagator* GetDeviceO2Propagator();
   void SetTPCFastTransform(std::unique_ptr<TPCFastTransform>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper);
   void SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut);
   void SetTRDGeometry(std::unique_ptr<o2::trd::GeometryFlat>&& geo);
-  void SetMatLUT(const o2::base::MatLayerCylSet* lut) { processors()->calibObjects.matLUT = lut; }
-  void SetTRDGeometry(const o2::trd::GeometryFlat* geo) { processors()->calibObjects.trdGeometry = geo; }
+  void SetMatLUT(const o2::base::MatLayerCylSet* lut);
+  void SetTRDGeometry(const o2::trd::GeometryFlat* geo);
   void SetO2Propagator(const o2::base::Propagator* prop);
-  void SetCalibObjects(const GPUCalibObjectsConst& obj) { processors()->calibObjects = obj; }
-  void SetCalibObjects(const GPUCalibObjects& obj) { memcpy((void*)&processors()->calibObjects, (const void*)&obj, sizeof(obj)); }
+  void SetCalibObjects(const GPUCalibObjectsConst& obj);
+  void SetCalibObjects(const GPUCalibObjects& obj);
   void SetUpdateCalibObjects(const GPUCalibObjectsConst& obj, const GPUNewCalibValues& vals);
   void SetSubOutputControl(int32_t i, GPUOutputControl* v) { mSubOutputControls[i] = v; }
   void SetFinalInputCallback(std::function<void()> v) { mWaitForFinalInputs = v; }
@@ -298,6 +303,8 @@ class GPUChainTracking : public GPUChain
   void RunTPCTrackingMerger_Resolve(int8_t useOrigTrackParam, int8_t mergeAll, GPUReconstruction::krnlDeviceType deviceType);
   void RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* clusters, std::function<o2::tpc::ClusterNative*(size_t)> allocator, bool applyClusterCuts);
   bool NeedTPCClustersOnGPU();
+  template <int32_t I>
+  int32_t RunTRDTrackingInternal();
   uint32_t StreamForSector(uint32_t sector) const;
 
   std::mutex mMutexUpdateCalib;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 7db0ba66305e9..981d565852d28 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -19,11 +19,20 @@
 #include "GPUMemorySizeScalers.h"
 #include "GPUTrackingInputProvider.h"
 #include "GPUNewCalibValues.h"
-#include <fstream>
-
-#ifdef GPUCA_O2_LIB
-#include "CommonDataFormat/InteractionRecord.h"
-#endif
+#include "GPUConstantMem.h"
+#include "CfChargePos.h"
+#include "CfArray2D.h"
+#include "GPUGeneralKernels.h"
+#include "GPUTPCCFStreamCompaction.h"
+#include "GPUTPCCFChargeMapFiller.h"
+#include "GPUTPCCFDecodeZS.h"
+#include "GPUTPCCFCheckPadBaseline.h"
+#include "GPUTPCCFPeakFinder.h"
+#include "GPUTPCCFNoiseSuppression.h"
+#include "GPUTPCCFDeconvolution.h"
+#include "GPUTPCCFClusterizer.h"
+#include "GPUTPCCFGather.h"
+#include "GPUTPCCFMCLabelFlattener.h"
 #include "GPUTriggerOutputs.h"
 #include "GPUHostDataTypes.h"
 #include "GPUTPCCFChainContext.h"
@@ -32,18 +41,24 @@
 #include "DataFormatsTPC/Digit.h"
 #include "DataFormatsTPC/Constants.h"
 #include "TPCBase/RDHUtils.h"
+#include "GPULogging.h"
+
+#ifdef GPUCA_HAS_ONNX
+#include "GPUTPCNNClusterizerKernels.h"
+#include "GPUTPCNNClusterizerHost.h"
+#endif
+
+#ifdef GPUCA_O2_LIB
+#include "CommonDataFormat/InteractionRecord.h"
+#endif
 
 #include "utils/strtag.h"
+#include <fstream>
 
 #ifndef GPUCA_NO_VC
 #include <Vc/Vc>
 #endif
 
-#ifdef GPUCA_HAS_ONNX
-#include "GPUTPCNNClusterizerKernels.h"
-#include "GPUTPCNNClusterizerHost.h"
-#endif
-
 using namespace o2::gpu;
 using namespace o2::tpc;
 using namespace o2::tpc::constants;
@@ -791,7 +806,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
         using ChargeMapType = decltype(*clustererShadow.mPchargeMap);
         using PeakMapType = decltype(*clustererShadow.mPpeakMap);
-        runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPchargeMap, TPCMapMemoryLayout<ChargeMapType>::items(GetProcessingSettings().overrideClusterizerFragmentLen) * sizeof(ChargeMapType)); // TODO: Not working in OpenCL2!!!
+        runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPchargeMap, TPCMapMemoryLayout<ChargeMapType>::items(GetProcessingSettings().overrideClusterizerFragmentLen) * sizeof(ChargeMapType));
         runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPpeakMap, TPCMapMemoryLayout<PeakMapType>::items(GetProcessingSettings().overrideClusterizerFragmentLen) * sizeof(PeakMapType));
         if (fragment.index == 0) {
           runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPpadIsNoisy, TPC_PADS_IN_SECTOR * sizeof(*clustererShadow.mPpadIsNoisy));
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 8fb6fc4771658..fc07a91004c5f 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -19,6 +19,9 @@
 #include "GPUTPCCFChainContext.h"
 #include "TPCClusterDecompressor.h"
 #include "GPUDefParametersRuntime.h"
+#include "GPUConstantMem.h" // TODO: Try to get rid of as many GPUConstantMem includes as possible!
+#include "GPUTPCCompressionKernels.h"
+#include "GPUTPCDecompressionKernels.h"
 #include "utils/strtag.h"
 
 #include <numeric>
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index c42d9622f5332..5d05cd6a97776 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -15,6 +15,8 @@
 #include "GPUChainTracking.h"
 #include "GPUTrackingInputProvider.h"
 #include "GPUMemorySizeScalers.h"
+#include "GPUConstantMem.h"
+#include "GPUTPCClusterFilter.h"
 #include <map>
 #include <memory>
 #include <string>
@@ -23,8 +25,6 @@
 #include "bitmapfile.h"
 #endif
 
-#include "GPUTPCClusterFilter.h"
-
 #define PROFILE_MAX_SIZE (100 * 1024 * 1024)
 
 using namespace o2::gpu;
@@ -209,7 +209,7 @@ void GPUChainTracking::PrintDebugOutput()
 void GPUChainTracking::PrintOutputStat()
 {
   int32_t nTracks = 0, nAttachedClusters = 0, nAttachedClustersFitted = 0, nAdjacentClusters = 0;
-  uint32_t nCls = GetProcessingSettings().doublePipeline ? mIOPtrs.clustersNative->nClustersTotal : GetTPCMerger().NMaxClusters();
+  uint32_t nCls = GetProcessingSettings().doublePipeline ? mIOPtrs.clustersNative->nClustersTotal : processors()->tpcMerger.NMaxClusters();
   if (GetProcessingSettings().createO2Output > 1) {
     nTracks = mIOPtrs.nOutputTracksTPCO2;
     nAttachedClusters = mIOPtrs.nMergedTrackHits;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDefs.h b/GPU/GPUTracking/Global/GPUChainTrackingDefs.h
index dc1a665e6052c..e02419955001a 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDefs.h
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDefs.h
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUChainTracking.h
+/// \file GPUChainTrackingDefs.h
 /// \author David Rohr
 
 #ifndef GPUCHAINTRACKINGDEFS_H
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc b/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
new file mode 100644
index 0000000000000..5b72a8f23c242
--- /dev/null
+++ b/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
@@ -0,0 +1,36 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUChainTrackingGetters.inc
+/// \author David Rohr
+
+#ifndef GPUCHAINTRACKINGGETTERS_INC_H
+#define GPUCHAINTRACKINGGETTERS_INC_H
+
+#include "GPUChainTracking.h"
+#include "GPUConstantMem.h"
+
+namespace o2::gpu
+{
+inline const CorrectionMapsHelper* GPUChainTracking::GetTPCTransformHelper() const { return processors()->calibObjects.fastTransformHelper; }
+inline const TPCPadGainCalib* GPUChainTracking::GetTPCPadGainCalib() const { return processors()->calibObjects.tpcPadGain; }
+inline const TPCZSLinkMapping* GPUChainTracking::GetTPCZSLinkMapping() const { return processors()->calibObjects.tpcZSLinkMapping; }
+inline const o2::tpc::CalibdEdxContainer* GPUChainTracking::GetdEdxCalibContainer() const { return processors()->calibObjects.dEdxCalibContainer; }
+inline const o2::base::MatLayerCylSet* GPUChainTracking::GetMatLUT() const { return processors()->calibObjects.matLUT; }
+inline const GPUTRDGeometry* GPUChainTracking::GetTRDGeometry() const { return (GPUTRDGeometry*)processors()->calibObjects.trdGeometry; }
+inline const o2::base::Propagator* GPUChainTracking::GetO2Propagator() const { return processors()->calibObjects.o2Propagator; }
+inline void GPUChainTracking::SetMatLUT(const o2::base::MatLayerCylSet* lut) { processors()->calibObjects.matLUT = lut; }
+inline void GPUChainTracking::SetTRDGeometry(const o2::trd::GeometryFlat* geo) { processors()->calibObjects.trdGeometry = geo; }
+inline void GPUChainTracking::SetCalibObjects(const GPUCalibObjectsConst& obj) { processors()->calibObjects = obj; }
+inline void GPUChainTracking::SetCalibObjects(const GPUCalibObjects& obj) { memcpy((void*)&processors()->calibObjects, (const void*)&obj, sizeof(obj)); }
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 4f7846b852b98..5e7672022b3ff 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -34,6 +34,7 @@
 #include "GPUTrackingInputProvider.h"
 #include "TPCZSLinkMapping.h"
 #include "GPUTriggerOutputs.h"
+#include "GPUConstantMem.h"
 
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index a647c213660c9..163f08634ef86 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -17,6 +17,11 @@
 #include "GPUDefParametersRuntime.h"
 #include "GPUO2DataTypes.h"
 #include "GPUQA.h"
+#include "GPUTPCGMMerger.h"
+#include "GPUConstantMem.h"
+#include "GPUTPCGMMergerGPU.h"
+#include "GPUTPCGMO2Output.h"
+#include "GPUTPCGlobalDebugSortKernels.h"
 #include "utils/strtag.h"
 #include <fstream>
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx b/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
index 8d1efd7011227..4662b5464f710 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
@@ -13,8 +13,12 @@
 /// \author David Rohr
 
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
 #include "GPULogging.h"
 #include "GPUO2DataTypes.h"
+#include "GPUTrackingRefit.h"
+#include "GPUConstantMem.h"
+#include "GPUTrackingRefitKernel.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 962b0922eeecc..635641c00ae14 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -20,6 +20,16 @@
 #include "GPUTrackingInputProvider.h"
 #include "GPUTPCClusterOccupancyMap.h"
 #include "GPUDefParametersRuntime.h"
+#include "GPUTPCExtrapolationTracking.h"
+#include "GPUTPCCreateOccupancyMap.h"
+#include "GPUTPCCreateTrackingData.h"
+#include "GPUTPCNeighboursFinder.h"
+#include "GPUTPCNeighboursCleaner.h"
+#include "GPUTPCStartHitsFinder.h"
+#include "GPUTPCStartHitsSorter.h"
+#include "GPUTPCTrackletConstructor.h"
+#include "GPUTPCTrackletSelector.h"
+#include "GPUTPCSectorDebugSortKernels.h"
 #include "utils/strtag.h"
 #include <fstream>
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx b/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
index 0f17bbcc26842..f9011131803e3 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
@@ -21,13 +21,19 @@
 #include "GPUTRDTracker.h"
 #include "GPUTrackingInputProvider.h"
 #include "GPUTRDTrackerKernels.h"
+#include "GPUConstantMem.h"
 #include "utils/strtag.h"
 
 using namespace o2::gpu;
 using namespace o2::trd;
 
-template <int32_t I>
 int32_t GPUChainTracking::RunTRDTracking()
+{
+  return GetProcessingSettings().trdTrackModelO2 ? RunTRDTrackingInternal<GPUTRDTrackerKernels::o2Version>() : RunTRDTrackingInternal<GPUTRDTrackerKernels::gpuVersion>();
+}
+
+template <int32_t I>
+int32_t GPUChainTracking::RunTRDTrackingInternal()
 {
   auto& Tracker = processors()->getTRDTracker<I>();
   if (!Tracker.IsInitialized()) {
@@ -189,9 +195,7 @@ int32_t GPUChainTracking::DoTRDGPUTracking(T* externalInstance)
   return (0);
 }
 
-template int32_t GPUChainTracking::RunTRDTracking<GPUTRDTrackerKernels::gpuVersion>();
 template int32_t GPUChainTracking::DoTRDGPUTracking<GPUTRDTrackerKernels::gpuVersion>(GPUTRDTrackerGPU*);
 template int32_t GPUChainTracking::DoTRDGPUTracking<GPUTRDTrackerKernels::gpuVersion>(GPUTRDTracker*);
-template int32_t GPUChainTracking::RunTRDTracking<GPUTRDTrackerKernels::o2Version>();
 template int32_t GPUChainTracking::DoTRDGPUTracking<GPUTRDTrackerKernels::o2Version>(GPUTRDTracker*);
 template int32_t GPUChainTracking::DoTRDGPUTracking<GPUTRDTrackerKernels::o2Version>(GPUTRDTrackerGPU*);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
index db5e5ae3aeb75..c9d4d269f070c 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
@@ -19,9 +19,13 @@
 #include "GPUTPCClusterData.h"
 #include "GPUReconstructionConvert.h"
 #include "GPUMemorySizeScalers.h"
+#include "GPUTPCConvert.h"
 #include "AliHLTTPCRawCluster.h"
+#include "GPUConstantMem.h"
+#include "GPUTPCConvertKernel.h"
 
 #include "DataFormatsTPC/ClusterNative.h"
+#include "DataFormatsTPC/ZeroSuppression.h"
 #include "CommonDataFormat/InteractionRecord.h"
 #include "utils/strtag.h"
 
diff --git a/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx b/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
index a5457bf3f2f23..7ef9baa903fbe 100644
--- a/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
+++ b/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
@@ -18,6 +18,9 @@
 #include "GPUReconstruction.h"
 #include "GPUTPCClusterOccupancyMap.h"
 #include "GPUErrors.h"
+#include "GPUParam.h"
+#include "DataFormatsTPC/ClusterNative.h"
+#include "GPUTRDSpacePoint.h"
 
 using namespace o2::gpu;
 using namespace o2::tpc;
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index 4dac56afed671..81eb2c285192b 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -15,6 +15,7 @@
 #include "GPUO2Interface.h"
 #include "GPUReconstruction.h"
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
 #include "GPUChainITS.h"
 #include "GPUMemorySizeScalers.h"
 #include "GPUOutputControl.h"
@@ -23,6 +24,7 @@
 #include "GPUParam.inc"
 #include "GPUQA.h"
 #include "GPUOutputControl.h"
+#include "DetectorsBase/Propagator.h"
 #include <iostream>
 #include <fstream>
 #include <thread>
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 82b21e2045b8e..4f960a8e1ec76 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -757,7 +757,7 @@ struct MergeBorderTracks_compMin {
 } // namespace o2::gpu::internal
 
 template <>
-inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
 {
   if (cmpMax) {
     GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, range, N, MergeBorderTracks_compMax());
@@ -1839,13 +1839,13 @@ struct GPUTPCGMMergerSortTracksQPt_comp {
 } // namespace o2::gpu::internal
 
 template <>
-inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
 {
   GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 
 template <>
-inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
 {
   GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
@@ -2065,7 +2065,7 @@ struct GPUTPCGMMergerMergeLoopers_comp {
 } // namespace o2::gpu::internal
 
 template <>
-inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
 {
   GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.LooperCandidates(), processors()->tpcMerger.Memory()->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
 }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 1e4cc633eb4ca..2f8fbecadce5f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -36,6 +36,7 @@
 #include "GPUTPCClusterOccupancyMap.h"
 #include "GPUTrackingRefit.h"
 #include "CorrectionMapsHelper.h"
+#include "GPUConstantMem.h"
 
 using namespace o2::gpu;
 using namespace gputpcgmmergertypes;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 13b34a0a64a84..6640b556c3011 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -102,7 +102,7 @@ struct GPUTPCGMO2OutputSort_comp {
 };
 
 template <>
-inline void GPUCA_M_CAT3(GPUReconstruction, GPUCA_GPUTYPE, Backend)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
 {
   GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSortO2(), processors()->tpcMerger.NOutputTracksTPCO2(), GPUTPCGMO2OutputSort_comp());
 }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
index 7d83ff9abd91c..e66ad71783dbd 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
@@ -16,6 +16,7 @@
 #include "GPUReconstruction.h"
 #include "GPUTPCHitId.h"
 #include "GPUTPCTrack.h"
+#include "GPULogging.h"
 
 #include <iostream>
 #include <cstring>
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index b32db2bfebf11..d4c83f92a2157 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -17,11 +17,24 @@
 #include "GPUReconstructionTimeframe.h"
 #include "GPUReconstructionConvert.h"
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
 #include "GPUTPCDef.h"
 #include "GPUQA.h"
+#include "GPUParam.h"
 #include "display/GPUDisplayInterface.h"
 #include "genEvents.h"
 
+#include "TPCFastTransform.h"
+#include "CorrectionMapsHelper.h"
+#include "GPUTPCGMMergedTrack.h"
+#include "GPUSettings.h"
+#include "GPUConstantMem.h"
+
+#include "GPUO2DataTypes.h"
+#include "GPUChainITS.h"
+
+#include "DataFormatsTPC/CompressedClusters.h"
+
 #include <iostream>
 #include <fstream>
 #include <cstdio>
@@ -32,6 +45,7 @@
 #include <thread>
 #include <future>
 #include <atomic>
+#include <vector>
 
 #ifndef _WIN32
 #include <unistd.h>
@@ -48,15 +62,6 @@
 #include "utils/qmaths_helpers.h"
 #include "utils/vecpod.h"
 
-#include "TPCFastTransform.h"
-#include "CorrectionMapsHelper.h"
-#include "GPUTPCGMMergedTrack.h"
-#include "GPUSettings.h"
-#include <vector>
-
-#include "GPUO2DataTypes.h"
-#include "GPUChainITS.h"
-
 using namespace o2::gpu;
 
 // #define BROKEN_EVENTS
@@ -915,7 +920,7 @@ int32_t main(int argc, char** argv)
       nEventsProcessed++;
 
       if (configStandalone.timeFrameTime) {
-        double nClusters = chainTracking->GetTPCMerger().NMaxClusters();
+        double nClusters = chainTracking->GetProcessors()->tpcMerger.NMaxClusters();
         if (nClusters > 0) {
           const int32_t nOrbits = 32;
           const double colRate = 50000;
diff --git a/GPU/GPUTracking/Standalone/tools/createGeo.C b/GPU/GPUTracking/Standalone/tools/createGeo.C
index 307d687f716d1..c454978177ad6 100644
--- a/GPU/GPUTracking/Standalone/tools/createGeo.C
+++ b/GPU/GPUTracking/Standalone/tools/createGeo.C
@@ -20,6 +20,7 @@
 #include "GPUO2Interface.h"
 #include "GPUReconstruction.h"
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/Standalone/tools/createLUT.C b/GPU/GPUTracking/Standalone/tools/createLUT.C
index 7bb4edbf89f18..b4a053aa46c66 100644
--- a/GPU/GPUTracking/Standalone/tools/createLUT.C
+++ b/GPU/GPUTracking/Standalone/tools/createLUT.C
@@ -18,6 +18,7 @@
 #include "GPUO2Interface.h"
 #include "GPUReconstruction.h"
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/Array2D.h b/GPU/GPUTracking/TPCClusterFinder/CfArray2D.h
similarity index 81%
rename from GPU/GPUTracking/TPCClusterFinder/Array2D.h
rename to GPU/GPUTracking/TPCClusterFinder/CfArray2D.h
index b62176fdc4365..3c8bcf94da4b3 100644
--- a/GPU/GPUTracking/TPCClusterFinder/Array2D.h
+++ b/GPU/GPUTracking/TPCClusterFinder/CfArray2D.h
@@ -16,22 +16,22 @@
 #define O2_GPU_ARRAY2D_H
 
 #include "clusterFinderDefs.h"
-#include "ChargePos.h"
+#include "CfChargePos.h"
 
 namespace o2::gpu
 {
 
 template <typename T, typename Layout>
-class AbstractArray2D
+class AbstractCfArray2D
 {
 
  public:
-  GPUdi() explicit AbstractArray2D(T* d) : data(d) {}
+  GPUdi() explicit AbstractCfArray2D(T* d) : data(d) {}
 
-  GPUdi() T& operator[](const ChargePos& p) { return data[Layout::idx(p)]; }
-  GPUdi() const T& operator[](const ChargePos& p) const { return data[Layout::idx(p)]; }
+  GPUdi() T& operator[](const CfChargePos& p) { return data[Layout::idx(p)]; }
+  GPUdi() const T& operator[](const CfChargePos& p) const { return data[Layout::idx(p)]; }
 
-  GPUdi() void safeWrite(const ChargePos& p, const T& v)
+  GPUdi() void safeWrite(const CfChargePos& p, const T& v)
   {
     if (data != nullptr) {
       (*this)[p] = v;
@@ -52,7 +52,7 @@ class TilingLayout
     WidthInTiles = (TPC_NUM_OF_PADS + Width - 1) / Width,
   };
 
-  GPUdi() static tpccf::SizeT idx(const ChargePos& p)
+  GPUdi() static tpccf::SizeT idx(const CfChargePos& p)
   {
     const tpccf::SizeT tilePad = p.gpad / Width;
     const tpccf::SizeT tileTime = p.timePadded / Height;
@@ -72,7 +72,7 @@ class TilingLayout
 class LinearLayout
 {
  public:
-  GPUdi() static tpccf::SizeT idx(const ChargePos& p)
+  GPUdi() static tpccf::SizeT idx(const CfChargePos& p)
   {
     return TPC_NUM_OF_PADS * p.timePadded + p.gpad;
   }
@@ -119,7 +119,7 @@ using TPCMapMemoryLayout = LinearLayout;
 #endif
 
 template <typename T>
-using Array2D = AbstractArray2D<T, TPCMapMemoryLayout<T>>;
+using CfArray2D = AbstractCfArray2D<T, TPCMapMemoryLayout<T>>;
 
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/ChargePos.h b/GPU/GPUTracking/TPCClusterFinder/CfChargePos.h
similarity index 80%
rename from GPU/GPUTracking/TPCClusterFinder/ChargePos.h
rename to GPU/GPUTracking/TPCClusterFinder/CfChargePos.h
index cdd489e0ef938..bf6ce2fc804ba 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ChargePos.h
+++ b/GPU/GPUTracking/TPCClusterFinder/CfChargePos.h
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file ChargePos.h
+/// \file CfChargePos.h
 /// \author Felix Weiglhofer
 
 #ifndef O2_GPU_CHARGE_POS_H
@@ -22,20 +22,20 @@ namespace o2::gpu
 
 #define INVALID_TIME_BIN (-GPUCF_PADDING_TIME - 1)
 
-struct ChargePos {
+struct CfChargePos {
   tpccf::GlobalPad gpad;
   tpccf::TPCFragmentTime timePadded;
 
-  GPUdDefault() ChargePos() = default;
+  GPUdDefault() CfChargePos() = default;
 
-  constexpr GPUhdi() ChargePos(tpccf::Row row, tpccf::Pad pad, tpccf::TPCFragmentTime t)
+  constexpr GPUhdi() CfChargePos(tpccf::Row row, tpccf::Pad pad, tpccf::TPCFragmentTime t)
     : gpad(tpcGlobalPadIdx(row, pad)), timePadded(t + GPUCF_PADDING_TIME)
   {
   }
 
-  GPUdi() ChargePos(const tpccf::GlobalPad& p, const tpccf::TPCFragmentTime& t) : gpad(p), timePadded(t) {}
+  GPUdi() CfChargePos(const tpccf::GlobalPad& p, const tpccf::TPCFragmentTime& t) : gpad(p), timePadded(t) {}
 
-  GPUdi() ChargePos delta(const tpccf::Delta2& d) const
+  GPUdi() CfChargePos delta(const tpccf::Delta2& d) const
   {
     return {tpccf::GlobalPad(gpad + d.x), tpccf::TPCFragmentTime(timePadded + d.y)};
   }
@@ -56,7 +56,7 @@ struct ChargePos {
   }
 };
 
-inline constexpr ChargePos INVALID_CHARGE_POS{255, 255, INVALID_TIME_BIN};
+inline constexpr CfChargePos INVALID_CHARGE_POS{255, 255, INVALID_TIME_BIN};
 
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/CfUtils.h b/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
index 75dcc166abd9b..96f4893c74af3 100644
--- a/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
+++ b/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
@@ -17,7 +17,7 @@
 
 #include "clusterFinderDefs.h"
 #include "GPUCommonAlgorithm.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "CfConsts.h"
 
 namespace o2::gpu
@@ -169,14 +169,14 @@ class CfUtils
 
   template <typename T>
   static GPUdi() void blockLoad(
-    const Array2D<T>& map,
+    const CfArray2D<T>& map,
     uint32_t wgSize,
     uint32_t elems,
     uint16_t ll,
     uint32_t offset,
     uint32_t N,
     GPUconstexprref() const tpccf::Delta2* neighbors,
-    const ChargePos* posBcast,
+    const CfChargePos* posBcast,
     GPUgeneric() T* buf)
   {
 #if defined(GPUCA_GPUCODE)
@@ -186,7 +186,7 @@ class CfUtils
     tpccf::Delta2 d = neighbors[x + offset];
 
     for (uint32_t i = y; i < wgSize; i += (elems / N)) {
-      ChargePos readFrom = posBcast[i];
+      CfChargePos readFrom = posBcast[i];
       uint32_t writeTo = N * i + x;
       buf[writeTo] = map[readFrom.delta(d)];
     }
@@ -196,7 +196,7 @@ class CfUtils
       return;
     }
 
-    ChargePos readFrom = posBcast[ll];
+    CfChargePos readFrom = posBcast[ll];
 
     GPUbarrier();
 
@@ -213,14 +213,14 @@ class CfUtils
 
   template <typename T, bool Inv = false>
   static GPUdi() void condBlockLoad(
-    const Array2D<T>& map,
+    const CfArray2D<T>& map,
     uint16_t wgSize,
     uint16_t elems,
     uint16_t ll,
     uint16_t offset,
     uint16_t N,
     GPUconstexprref() const tpccf::Delta2* neighbors,
-    const ChargePos* posBcast,
+    const CfChargePos* posBcast,
     const uint8_t* aboveThreshold,
     GPUgeneric() T* buf)
   {
@@ -230,7 +230,7 @@ class CfUtils
     uint16_t x = ll % N;
     tpccf::Delta2 d = neighbors[x + offset];
     for (uint32_t i = y; i < wgSize; i += (elems / N)) {
-      ChargePos readFrom = posBcast[i];
+      CfChargePos readFrom = posBcast[i];
       uint8_t above = aboveThreshold[i];
       uint32_t writeTo = N * i + x;
       T v(0);
@@ -247,7 +247,7 @@ class CfUtils
       return;
     }
 
-    ChargePos readFrom = posBcast[ll];
+    CfChargePos readFrom = posBcast[ll];
     uint8_t above = aboveThreshold[ll];
     GPUbarrier();
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
index 622da856af805..a80283b91c940 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.cxx
@@ -58,7 +58,7 @@ GPUd() Charge ClusterAccumulator::updateOuter(PackedCharge charge, Delta2 d)
   return q;
 }
 
-GPUd() void ClusterAccumulator::finalize(const ChargePos& pos, const Charge q, TPCTime timeOffset)
+GPUd() void ClusterAccumulator::finalize(const CfChargePos& pos, const Charge q, TPCTime timeOffset)
 {
   mQtot += q;
 
@@ -75,7 +75,7 @@ GPUd() void ClusterAccumulator::finalize(const ChargePos& pos, const Charge q, T
   mTimeMean += timeOffset + pos.time();
 }
 
-GPUd() bool ClusterAccumulator::toNative(const ChargePos& pos, const Charge q, tpc::ClusterNative& cn, const GPUParam& param, const Array2D<PackedCharge>& chargeMap)
+GPUd() bool ClusterAccumulator::toNative(const CfChargePos& pos, const Charge q, tpc::ClusterNative& cn, const GPUParam& param, const CfArray2D<PackedCharge>& chargeMap)
 {
   Pad pad = pos.pad();
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
index 90d977372b201..fb208ca0150d4 100644
--- a/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
+++ b/GPU/GPUTracking/TPCClusterFinder/ClusterAccumulator.h
@@ -17,7 +17,7 @@
 
 #include "clusterFinderDefs.h"
 #include "PackedCharge.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 
 namespace o2
 {
@@ -30,7 +30,7 @@ struct ClusterNative;
 namespace gpu
 {
 
-struct ChargePos;
+struct CfChargePos;
 struct GPUParam;
 class GPUTPCGeometry;
 
@@ -52,8 +52,8 @@ class ClusterAccumulator
     mSplitInTime = splitInTime;
   }
 
-  GPUd() void finalize(const ChargePos&, const tpccf::Charge, tpccf::TPCTime);
-  GPUd() bool toNative(const ChargePos&, const tpccf::Charge, tpc::ClusterNative&, const GPUParam&, const Array2D<PackedCharge>&);
+  GPUd() void finalize(const CfChargePos&, const tpccf::Charge, tpccf::TPCTime);
+  GPUd() bool toNative(const CfChargePos&, const tpccf::Charge, tpc::ClusterNative&, const GPUParam&, const CfArray2D<PackedCharge>&);
 
  private:
   float mQtot = 0;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.cxx
index 8dbc5804f8fb8..d2ca3d419c138 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.cxx
@@ -13,7 +13,7 @@
 /// \author Felix Weiglhofer
 
 #include "GPUTPCCFChargeMapFiller.h"
-#include "ChargePos.h"
+#include "CfChargePos.h"
 #include "DataFormatsTPC/Digit.h"
 #include "TPCPadGainCalib.h"
 
@@ -23,14 +23,14 @@ using namespace o2::gpu::tpccf;
 template <>
 GPUdii() void GPUTPCCFChargeMapFiller::Thread<GPUTPCCFChargeMapFiller::fillIndexMap>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
-  Array2D<uint32_t> indexMap(clusterer.mPindexMap);
+  CfArray2D<uint32_t> indexMap(clusterer.mPindexMap);
   fillIndexMapImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer.mPmemory->fragment, clusterer.mPdigits, indexMap, clusterer.mPmemory->counters.nDigitsInFragment);
 }
 
 GPUd() void GPUTPCCFChargeMapFiller::fillIndexMapImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread,
                                                       const CfFragment& fragment,
                                                       const tpc::Digit* digits,
-                                                      Array2D<uint32_t>& indexMap,
+                                                      CfArray2D<uint32_t>& indexMap,
                                                       size_t maxDigit)
 {
   size_t idx = get_global_id(0);
@@ -39,21 +39,21 @@ GPUd() void GPUTPCCFChargeMapFiller::fillIndexMapImpl(int32_t nBlocks, int32_t n
   }
   CPU_ONLY(idx += fragment.digitsStart);
   CPU_ONLY(tpc::Digit digit = digits[idx]);
-  CPU_ONLY(ChargePos pos(digit.getRow(), digit.getPad(), fragment.toLocal(digit.getTimeStamp())));
+  CPU_ONLY(CfChargePos pos(digit.getRow(), digit.getPad(), fragment.toLocal(digit.getTimeStamp())));
   CPU_ONLY(indexMap.safeWrite(pos, idx));
 }
 
 template <>
 GPUdii() void GPUTPCCFChargeMapFiller::Thread<GPUTPCCFChargeMapFiller::fillFromDigits>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   fillFromDigitsImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, clusterer.mPmemory->counters.nPositions, clusterer.mPdigits, clusterer.mPpositions, chargeMap);
 }
 
 GPUd() void GPUTPCCFChargeMapFiller::fillFromDigitsImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, processorType& clusterer, const CfFragment& fragment, size_t digitNum,
                                                         const tpc::Digit* digits,
-                                                        ChargePos* positions,
-                                                        Array2D<PackedCharge>& chargeMap)
+                                                        CfChargePos* positions,
+                                                        CfArray2D<PackedCharge>& chargeMap)
 {
   size_t idx = get_global_id(0);
   if (idx >= digitNum) {
@@ -61,7 +61,7 @@ GPUd() void GPUTPCCFChargeMapFiller::fillFromDigitsImpl(int32_t nBlocks, int32_t
   }
   tpc::Digit digit = digits[fragment.digitsStart + idx];
 
-  ChargePos pos(digit.getRow(), digit.getPad(), fragment.toLocal(digit.getTimeStamp()));
+  CfChargePos pos(digit.getRow(), digit.getPad(), fragment.toLocal(digit.getTimeStamp()));
   positions[idx] = pos;
   float q = digit.getChargeFloat();
   q *= clusterer.GetConstantMem()->calibObjects.tpcPadGain->getGainCorrection(clusterer.mISector, digit.getRow(), digit.getPad());
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.h
index f7aab78c33bd1..800ba786c2105 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.h
@@ -19,7 +19,7 @@
 #include "GPUGeneralKernels.h"
 #include "GPUConstantMem.h"
 #include "GPUTPCClusterFinder.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "PackedCharge.h"
 
 namespace o2::tpc
@@ -30,7 +30,7 @@ class Digit;
 namespace o2::gpu
 {
 
-struct ChargePos;
+struct CfChargePos;
 
 class GPUTPCCFChargeMapFiller : public GPUKernelTemplate
 {
@@ -55,9 +55,9 @@ class GPUTPCCFChargeMapFiller : public GPUKernelTemplate
   template <int32_t iKernel = defaultKernel, typename... Args>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, Args... args);
 
-  static GPUd() void fillIndexMapImpl(int32_t, int32_t, int32_t, int32_t, const CfFragment&, const tpc::Digit*, Array2D<uint32_t>&, size_t);
+  static GPUd() void fillIndexMapImpl(int32_t, int32_t, int32_t, int32_t, const CfFragment&, const tpc::Digit*, CfArray2D<uint32_t>&, size_t);
 
-  static GPUd() void fillFromDigitsImpl(int32_t, int32_t, int32_t, int32_t, processorType&, const CfFragment&, size_t, const tpc::Digit*, ChargePos*, Array2D<PackedCharge>&);
+  static GPUd() void fillFromDigitsImpl(int32_t, int32_t, int32_t, int32_t, processorType&, const CfFragment&, size_t, const tpc::Digit*, CfChargePos*, CfArray2D<PackedCharge>&);
 
  private:
   static GPUd() size_t findTransition(int32_t, const tpc::Digit*, size_t, size_t);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
index 1e76860331de6..ec084c308312e 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
@@ -13,7 +13,7 @@
 /// \author Felix Weiglhofer
 
 #include "GPUTPCCFCheckPadBaseline.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "PackedCharge.h"
 #include "GPUTPCGeometry.h"
 #include "clusterFinderDefs.h"
@@ -33,10 +33,10 @@ template <>
 GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
   const CfFragment& fragment = clusterer.mPmemory->fragment;
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
 
   int32_t basePad = iBlock * PadsPerCacheline;
-  ChargePos basePos = padToChargePos(basePad, clusterer);
+  CfChargePos basePos = padToCfChargePos(basePad, clusterer);
 
   if (not basePos.valid()) {
     return;
@@ -55,7 +55,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
   bool handlePad = localTimeBin == 0;
 
   for (tpccf::TPCFragmentTime t = fragment.firstNonOverlapTimeBin(); t < fragment.lastNonOverlapTimeBin(); t += NumOfCachedTimebins) {
-    const ChargePos pos = basePos.delta({localPadId, int16_t(t + localTimeBin)});
+    const CfChargePos pos = basePos.delta({localPadId, int16_t(t + localTimeBin)});
     smem.charges[localPadId][localTimeBin] = (pos.valid()) ? chargeMap[pos].unpack() : 0;
     GPUbarrier();
     if (handlePad) {
@@ -150,7 +150,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
 #endif
 }
 
-GPUd() ChargePos GPUTPCCFCheckPadBaseline::padToChargePos(int32_t& pad, const GPUTPCClusterFinder& clusterer)
+GPUd() CfChargePos GPUTPCCFCheckPadBaseline::padToCfChargePos(int32_t& pad, const GPUTPCClusterFinder& clusterer)
 {
   constexpr GPUTPCGeometry geo;
 
@@ -161,12 +161,12 @@ GPUd() ChargePos GPUTPCCFCheckPadBaseline::padToChargePos(int32_t& pad, const GP
     if (0 <= padInRow && padInRow < CAMath::nextMultipleOf<PadsPerCacheline, int32_t>(npads)) {
       int32_t cachelineOffset = padInRow % PadsPerCacheline;
       pad -= cachelineOffset;
-      return ChargePos{r, Pad(padInRow - cachelineOffset), 0};
+      return CfChargePos{r, Pad(padInRow - cachelineOffset), 0};
     }
     padOffset += npads;
   }
 
-  return ChargePos{0, 0, INVALID_TIME_BIN};
+  return CfChargePos{0, 0, INVALID_TIME_BIN};
 }
 
 GPUd() void GPUTPCCFCheckPadBaseline::updatePadBaseline(int32_t pad, const GPUTPCClusterFinder& clusterer, int32_t totalCharges, int32_t consecCharges, Charge maxCharge)
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
index d6daa6803ca39..2403aa6d29ecd 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
@@ -52,7 +52,7 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer);
 
  private:
-  GPUd() static ChargePos padToChargePos(int32_t& pad, const GPUTPCClusterFinder&);
+  GPUd() static CfChargePos padToCfChargePos(int32_t& pad, const GPUTPCClusterFinder&);
   GPUd() static void updatePadBaseline(int32_t pad, const GPUTPCClusterFinder&, int32_t totalCharges, int32_t consecCharges, tpccf::Charge maxCharge);
 };
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
index 2131347decec6..c9c6b157499f2 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
@@ -30,7 +30,7 @@ using namespace o2::gpu::tpccf;
 template <>
 GPUdii() void GPUTPCCFClusterizer::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int8_t onlyMC)
 {
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CPU_ONLY(MCLabelAccumulator labelAcc(clusterer));
 
   tpc::ClusterNative* clusterOut = (onlyMC) ? nullptr : clusterer.mPclusterByRow;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
index 79f3325ed9ad2..466d13d3254de 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
@@ -19,7 +19,7 @@
 #include "GPUGeneralKernels.h"
 #include "GPUConstantMem.h"
 #include "GPUTPCClusterFinder.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "PackedCharge.h"
 
 namespace o2::tpc
@@ -38,7 +38,7 @@ class GPUTPCCFClusterizer : public GPUKernelTemplate
  public:
   static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFClusterizer);
   struct GPUSharedMemory {
-    ChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
+    CfChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
     PackedCharge buf[SCRATCH_PAD_WORK_GROUP_SIZE * SCRATCH_PAD_BUILD_N];
     uint8_t innerAboveThreshold[SCRATCH_PAD_WORK_GROUP_SIZE];
   };
@@ -57,16 +57,16 @@ class GPUTPCCFClusterizer : public GPUKernelTemplate
   template <int32_t iKernel = defaultKernel>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int8_t);
 
-  static GPUd() void computeClustersImpl(int32_t, int32_t, int32_t, int32_t, processorType&, const CfFragment&, GPUSharedMemory&, const Array2D<PackedCharge>&, const ChargePos*, const GPUSettingsRec&, MCLabelAccumulator*, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*, uint32_t*);
+  static GPUd() void computeClustersImpl(int32_t, int32_t, int32_t, int32_t, processorType&, const CfFragment&, GPUSharedMemory&, const CfArray2D<PackedCharge>&, const CfChargePos*, const GPUSettingsRec&, MCLabelAccumulator*, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*, uint32_t*);
 
-  static GPUd() void buildCluster(const GPUSettingsRec&, const Array2D<PackedCharge>&, ChargePos, ChargePos*, PackedCharge*, uint8_t*, ClusterAccumulator*, MCLabelAccumulator*);
+  static GPUd() void buildCluster(const GPUSettingsRec&, const CfArray2D<PackedCharge>&, CfChargePos, CfChargePos*, PackedCharge*, uint8_t*, ClusterAccumulator*, MCLabelAccumulator*);
 
   static GPUd() uint32_t sortIntoBuckets(processorType&, const tpc::ClusterNative&, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*);
 
  private:
-  static GPUd() void updateClusterInner(const GPUSettingsRec&, uint16_t, uint16_t, const PackedCharge*, const ChargePos&, ClusterAccumulator*, MCLabelAccumulator*, uint8_t*);
+  static GPUd() void updateClusterInner(const GPUSettingsRec&, uint16_t, uint16_t, const PackedCharge*, const CfChargePos&, ClusterAccumulator*, MCLabelAccumulator*, uint8_t*);
 
-  static GPUd() void updateClusterOuter(uint16_t, uint16_t, uint16_t, uint16_t, const PackedCharge*, const ChargePos&, ClusterAccumulator*, MCLabelAccumulator*);
+  static GPUd() void updateClusterOuter(uint16_t, uint16_t, uint16_t, uint16_t, const PackedCharge*, const CfChargePos&, ClusterAccumulator*, MCLabelAccumulator*);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
index 8a6b73be8bd8d..e32abbf37584f 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
@@ -19,8 +19,8 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
                                                        processorType& clusterer,
                                                        const CfFragment& fragment,
                                                        GPUSharedMemory& smem,
-                                                       const Array2D<PackedCharge>& chargeMap,
-                                                       const ChargePos* filteredPeakPositions,
+                                                       const CfArray2D<PackedCharge>& chargeMap,
+                                                       const CfChargePos* filteredPeakPositions,
                                                        const GPUSettingsRec& calib,
                                                        MCLabelAccumulator* labelAcc,
                                                        uint32_t clusternum,
@@ -34,7 +34,7 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
   // For certain configurations dummy work items are added, so the total
   // number of work items is dividable by 64.
   // These dummy items also compute the last cluster but discard the result.
-  ChargePos pos = filteredPeakPositions[CAMath::Min(idx, clusternum - 1)];
+  CfChargePos pos = filteredPeakPositions[CAMath::Min(idx, clusternum - 1)];
   Charge charge = chargeMap[pos].unpack();
 
   ClusterAccumulator pc;
@@ -94,7 +94,7 @@ GPUdii() void GPUTPCCFClusterizer::updateClusterInner(
   uint16_t lid,
   uint16_t N,
   const PackedCharge* buf,
-  const ChargePos& pos,
+  const CfChargePos& pos,
   ClusterAccumulator* cluster,
   MCLabelAccumulator* labelAcc,
   uint8_t* innerAboveThreshold)
@@ -125,7 +125,7 @@ GPUdii() void GPUTPCCFClusterizer::updateClusterOuter(
   uint16_t M,
   uint16_t offset,
   const PackedCharge* buf,
-  const ChargePos& pos,
+  const CfChargePos& pos,
   ClusterAccumulator* cluster,
   MCLabelAccumulator* labelAcc)
 {
@@ -144,9 +144,9 @@ GPUdii() void GPUTPCCFClusterizer::updateClusterOuter(
 
 GPUdii() void GPUTPCCFClusterizer::buildCluster(
   const GPUSettingsRec& calib,
-  const Array2D<PackedCharge>& chargeMap,
-  ChargePos pos,
-  ChargePos* posBcast,
+  const CfArray2D<PackedCharge>& chargeMap,
+  CfChargePos pos,
+  CfChargePos* posBcast,
   PackedCharge* buf,
   uint8_t* innerAboveThreshold,
   ClusterAccumulator* myCluster,
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index 6662b93eccb78..312085d2947ab 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -15,7 +15,7 @@
 #include "GPUTPCCFDecodeZS.h"
 #include "GPUCommonMath.h"
 #include "GPUTPCClusterFinder.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "PackedCharge.h"
 #include "CfUtils.h"
 #include "CommonConstants/LHCConstants.h"
@@ -53,8 +53,8 @@ GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUShared
   if (zs.count[endpoint] == 0) {
     return;
   }
-  ChargePos* positions = clusterer.mPpositions;
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfChargePos* positions = clusterer.mPpositions;
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   const size_t nDigits = clusterer.mPzsOffsets[iBlock].offset;
   if (iThread == 0) {
     const int32_t region = endpoint / 2;
@@ -175,7 +175,7 @@ GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUShared
                   TPCTime globalTime = timeBin + l;
                   bool inFragment = fragment.contains(globalTime);
                   Row row = rowOffset + m;
-                  ChargePos pos(row, Pad(pad), inFragment ? fragment.toLocal(globalTime) : INVALID_TIME_BIN);
+                  CfChargePos pos(row, Pad(pad), inFragment ? fragment.toLocal(globalTime) : INVALID_TIME_BIN);
                   positions[nDigitsTmp++] = pos;
 
                   if (inFragment) {
@@ -552,7 +552,7 @@ GPUd() o2::tpc::PadPos GPUTPCCFDecodeZSLinkBase::GetPadAndRowFromFEC(processorTy
 GPUd() void GPUTPCCFDecodeZSLinkBase::WriteCharge(processorType& clusterer, float charge, PadPos padAndRow, TPCFragmentTime localTime, size_t positionOffset)
 {
   const uint32_t sector = clusterer.mISector;
-  ChargePos* positions = clusterer.mPpositions;
+  CfChargePos* positions = clusterer.mPpositions;
 #ifdef GPUCA_CHECK_TPCZS_CORRUPTION
   if (padAndRow.getRow() >= GPUCA_ROW_COUNT) {
     positions[positionOffset] = INVALID_CHARGE_POS;
@@ -560,9 +560,9 @@ GPUd() void GPUTPCCFDecodeZSLinkBase::WriteCharge(processorType& clusterer, floa
     return;
   }
 #endif
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
 
-  ChargePos pos(padAndRow.getRow(), padAndRow.getPad(), localTime);
+  CfChargePos pos(padAndRow.getRow(), padAndRow.getPad(), localTime);
   positions[positionOffset] = pos;
 
   charge *= clusterer.GetConstantMem()->calibObjects.tpcPadGain->getGainCorrection(sector, padAndRow.getRow(), padAndRow.getPad());
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.cxx
index dab8123698abf..429d51685e504 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.cxx
@@ -15,7 +15,7 @@
 #include "GPUTPCCFDeconvolution.h"
 #include "CfConsts.h"
 #include "CfUtils.h"
-#include "ChargePos.h"
+#include "CfChargePos.h"
 #include "GPUDefMacros.h"
 
 using namespace o2::gpu;
@@ -24,15 +24,15 @@ using namespace o2::gpu::tpccf;
 template <>
 GPUdii() void GPUTPCCFDeconvolution::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   GPUTPCCFDeconvolution::deconvolutionImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), smem, isPeakMap, chargeMap, clusterer.mPpositions, clusterer.mPmemory->counters.nPositions);
 }
 
 GPUdii() void GPUTPCCFDeconvolution::deconvolutionImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem,
-                                                       const Array2D<uint8_t>& peakMap,
-                                                       Array2D<PackedCharge>& chargeMap,
-                                                       const ChargePos* positions,
+                                                       const CfArray2D<uint8_t>& peakMap,
+                                                       CfArray2D<PackedCharge>& chargeMap,
+                                                       const CfChargePos* positions,
                                                        const uint32_t digitnum)
 {
   SizeT idx = get_global_id(0);
@@ -40,7 +40,7 @@ GPUdii() void GPUTPCCFDeconvolution::deconvolutionImpl(int32_t nBlocks, int32_t
   bool iamDummy = (idx >= digitnum);
   idx = iamDummy ? digitnum - 1 : idx;
 
-  ChargePos pos = positions[idx];
+  CfChargePos pos = positions[idx];
 
   bool iamPeak = CfUtils::isPeak(peakMap[pos]);
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
index 78fcc8ba1785a..e971a042e95a4 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
@@ -20,7 +20,7 @@
 #include "GPUGeneralKernels.h"
 #include "GPUConstantMem.h"
 #include "GPUTPCClusterFinder.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "PackedCharge.h"
 
 namespace o2::gpu
@@ -31,7 +31,7 @@ class GPUTPCCFDeconvolution : public GPUKernelTemplate
  public:
   static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFDeconvolution);
   struct GPUSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<int16_t, SCRATCH_PAD_WORK_GROUP_SIZE> {
-    ChargePos posBcast1[SCRATCH_PAD_WORK_GROUP_SIZE];
+    CfChargePos posBcast1[SCRATCH_PAD_WORK_GROUP_SIZE];
     uint8_t aboveThresholdBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
     uint8_t buf[SCRATCH_PAD_WORK_GROUP_SIZE * SCRATCH_PAD_COUNT_N];
   };
@@ -51,7 +51,7 @@ class GPUTPCCFDeconvolution : public GPUKernelTemplate
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, Args... args);
 
  private:
-  static GPUd() void deconvolutionImpl(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, const Array2D<uint8_t>&, Array2D<PackedCharge>&, const ChargePos*, const uint32_t);
+  static GPUd() void deconvolutionImpl(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, const CfArray2D<uint8_t>&, CfArray2D<PackedCharge>&, const CfChargePos*, const uint32_t);
 
   static GPUdi() uint8_t countPeaksInner(uint16_t, const uint8_t*, uint8_t*);
   static GPUdi() uint8_t countPeaksOuter(uint16_t, uint8_t, const uint8_t*);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.cxx
index f3a914cbfcaee..4dfa50d9439e4 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.cxx
@@ -13,10 +13,10 @@
 /// \author Felix Weiglhofer
 
 #include "GPUTPCCFNoiseSuppression.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "CfConsts.h"
 #include "CfUtils.h"
-#include "ChargePos.h"
+#include "CfChargePos.h"
 
 using namespace o2::gpu;
 using namespace o2::gpu::tpccf;
@@ -24,29 +24,29 @@ using namespace o2::gpu::tpccf;
 template <>
 GPUdii() void GPUTPCCFNoiseSuppression::Thread<GPUTPCCFNoiseSuppression::noiseSuppression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   noiseSuppressionImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), smem, clusterer.Param().rec, chargeMap, isPeakMap, clusterer.mPpeakPositions, clusterer.mPmemory->counters.nPeaks, clusterer.mPisPeak);
 }
 
 template <>
 GPUdii() void GPUTPCCFNoiseSuppression::Thread<GPUTPCCFNoiseSuppression::updatePeaks>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
-  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+  CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   updatePeaksImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer.mPpeakPositions, clusterer.mPisPeak, clusterer.mPmemory->counters.nPeaks, isPeakMap);
 }
 
 GPUdii() void GPUTPCCFNoiseSuppression::noiseSuppressionImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem,
                                                              const GPUSettingsRec& calibration,
-                                                             const Array2D<PackedCharge>& chargeMap,
-                                                             const Array2D<uint8_t>& peakMap,
-                                                             const ChargePos* peakPositions,
+                                                             const CfArray2D<PackedCharge>& chargeMap,
+                                                             const CfArray2D<uint8_t>& peakMap,
+                                                             const CfChargePos* peakPositions,
                                                              const uint32_t peaknum,
                                                              uint8_t* isPeakPredicate)
 {
   SizeT idx = get_global_id(0);
 
-  ChargePos pos = peakPositions[CAMath::Min(idx, (SizeT)(peaknum - 1))];
+  CfChargePos pos = peakPositions[CAMath::Min(idx, (SizeT)(peaknum - 1))];
   Charge charge = chargeMap[pos].unpack();
 
   uint64_t minimas, bigger, peaksAround;
@@ -75,10 +75,10 @@ GPUdii() void GPUTPCCFNoiseSuppression::noiseSuppressionImpl(int32_t nBlocks, in
 }
 
 GPUd() void GPUTPCCFNoiseSuppression::updatePeaksImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread,
-                                                      const ChargePos* peakPositions,
+                                                      const CfChargePos* peakPositions,
                                                       const uint8_t* isPeak,
                                                       const uint32_t peakNum,
-                                                      Array2D<uint8_t>& peakMap)
+                                                      CfArray2D<uint8_t>& peakMap)
 {
   SizeT idx = get_global_id(0);
 
@@ -86,7 +86,7 @@ GPUd() void GPUTPCCFNoiseSuppression::updatePeaksImpl(int32_t nBlocks, int32_t n
     return;
   }
 
-  ChargePos pos = peakPositions[idx];
+  CfChargePos pos = peakPositions[idx];
 
   uint8_t peak = isPeak[idx];
 
@@ -164,12 +164,12 @@ GPUdi() bool GPUTPCCFNoiseSuppression::keepPeak(
 }
 
 GPUd() void GPUTPCCFNoiseSuppression::findMinimaAndPeaks(
-  const Array2D<PackedCharge>& chargeMap,
-  const Array2D<uint8_t>& peakMap,
+  const CfArray2D<PackedCharge>& chargeMap,
+  const CfArray2D<uint8_t>& peakMap,
   const GPUSettingsRec& calibration,
   float q,
-  const ChargePos& pos,
-  ChargePos* posBcast,
+  const CfChargePos& pos,
+  CfChargePos* posBcast,
   PackedCharge* buf,
   uint64_t* minimas,
   uint64_t* bigger,
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
index 71236bc317443..59196da11079b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
@@ -19,13 +19,13 @@
 #include "GPUGeneralKernels.h"
 #include "GPUConstantMem.h"
 #include "GPUTPCClusterFinder.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "PackedCharge.h"
 
 namespace o2::gpu
 {
 
-struct ChargePos;
+struct CfChargePos;
 
 class GPUTPCCFNoiseSuppression : public GPUKernelTemplate
 {
@@ -38,7 +38,7 @@ class GPUTPCCFNoiseSuppression : public GPUKernelTemplate
   static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks));
 
   struct GPUSharedMemory {
-    ChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
+    CfChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
     PackedCharge buf[SCRATCH_PAD_WORK_GROUP_SIZE * SCRATCH_PAD_NOISE_N];
   };
 
@@ -57,9 +57,9 @@ class GPUTPCCFNoiseSuppression : public GPUKernelTemplate
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, Args... args);
 
  private:
-  static GPUd() void noiseSuppressionImpl(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, const GPUSettingsRec&, const Array2D<PackedCharge>&, const Array2D<uint8_t>&, const ChargePos*, const uint32_t, uint8_t*);
+  static GPUd() void noiseSuppressionImpl(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, const GPUSettingsRec&, const CfArray2D<PackedCharge>&, const CfArray2D<uint8_t>&, const CfChargePos*, const uint32_t, uint8_t*);
 
-  static GPUd() void updatePeaksImpl(int32_t, int32_t, int32_t, int32_t, const ChargePos*, const uint8_t*, const uint32_t, Array2D<uint8_t>&);
+  static GPUd() void updatePeaksImpl(int32_t, int32_t, int32_t, int32_t, const CfChargePos*, const uint8_t*, const uint32_t, CfArray2D<uint8_t>&);
 
   static GPUdi() void checkForMinima(const float, const float, const float, PackedCharge, int32_t, uint64_t*, uint64_t*);
 
@@ -69,7 +69,7 @@ class GPUTPCCFNoiseSuppression : public GPUKernelTemplate
 
   static GPUdi() bool keepPeak(uint64_t, uint64_t);
 
-  static GPUd() void findMinimaAndPeaks(const Array2D<PackedCharge>&, const Array2D<uint8_t>&, const GPUSettingsRec&, float, const ChargePos&, ChargePos*, PackedCharge*, uint64_t*, uint64_t*, uint64_t*);
+  static GPUd() void findMinimaAndPeaks(const CfArray2D<PackedCharge>&, const CfArray2D<uint8_t>&, const GPUSettingsRec&, float, const CfChargePos&, CfChargePos*, PackedCharge*, uint64_t*, uint64_t*, uint64_t*);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
index 1de922f716c14..6749ab8e8485e 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
@@ -14,7 +14,7 @@
 
 #include "GPUTPCCFPeakFinder.h"
 
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "CfUtils.h"
 #include "PackedCharge.h"
 #include "TPCPadGainCalib.h"
@@ -25,19 +25,19 @@ using namespace o2::gpu::tpccf;
 template <>
 GPUdii() void GPUTPCCFPeakFinder::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   findPeaksImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), smem, chargeMap, clusterer.mPpadIsNoisy, clusterer.mPpositions, clusterer.mPmemory->counters.nPositions, clusterer.Param().rec, *clusterer.GetConstantMem()->calibObjects.tpcPadGain, clusterer.mPisPeak, isPeakMap);
 }
 
 GPUdii() bool GPUTPCCFPeakFinder::isPeak(
   GPUSharedMemory& smem,
   Charge q,
-  const ChargePos& pos,
+  const CfChargePos& pos,
   uint16_t N,
-  const Array2D<PackedCharge>& chargeMap,
+  const CfArray2D<PackedCharge>& chargeMap,
   const GPUSettingsRec& calib,
-  ChargePos* posBcast,
+  CfChargePos* posBcast,
   PackedCharge* buf)
 {
   uint16_t ll = get_local_id(0);
@@ -91,21 +91,21 @@ GPUdii() bool GPUTPCCFPeakFinder::isPeak(
 }
 
 GPUd() void GPUTPCCFPeakFinder::findPeaksImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem,
-                                              const Array2D<PackedCharge>& chargeMap,
+                                              const CfArray2D<PackedCharge>& chargeMap,
                                               const uint8_t* padHasLostBaseline,
-                                              const ChargePos* positions,
+                                              const CfChargePos* positions,
                                               SizeT digitnum,
                                               const GPUSettingsRec& calib,
                                               const TPCPadGainCalib& gainCorrection, // Only used for globalPad() function
                                               uint8_t* isPeakPredicate,
-                                              Array2D<uint8_t>& peakMap)
+                                              CfArray2D<uint8_t>& peakMap)
 {
   SizeT idx = get_global_id(0);
 
   // For certain configurations dummy work items are added, so the total
   // number of work items is dividable by 64.
   // These dummy items also compute the last digit but discard the result.
-  ChargePos pos = positions[CAMath::Min(idx, (SizeT)(digitnum - 1))];
+  CfChargePos pos = positions[CAMath::Min(idx, (SizeT)(digitnum - 1))];
   Charge charge = pos.valid() ? chargeMap[pos].unpack() : Charge(0);
 
   bool hasLostBaseline = padHasLostBaseline[gainCorrection.globalPad(pos.row(), pos.pad())];
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.h
index ec17d98322239..e480518ddc9dd 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.h
@@ -19,20 +19,20 @@
 #include "GPUConstantMem.h"
 
 #include "clusterFinderDefs.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "PackedCharge.h"
 
 namespace o2::gpu
 {
 
-struct ChargePos;
+struct CfChargePos;
 
 class GPUTPCCFPeakFinder : public GPUKernelTemplate
 {
  public:
   static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFPeakFinder);
   struct GPUSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<int16_t, SCRATCH_PAD_WORK_GROUP_SIZE> {
-    ChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
+    CfChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
     PackedCharge buf[SCRATCH_PAD_WORK_GROUP_SIZE * SCRATCH_PAD_SEARCH_N];
   };
 
@@ -51,9 +51,9 @@ class GPUTPCCFPeakFinder : public GPUKernelTemplate
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, Args... args);
 
  private:
-  static GPUd() void findPeaksImpl(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, const Array2D<PackedCharge>&, const uint8_t*, const ChargePos*, tpccf::SizeT, const GPUSettingsRec&, const TPCPadGainCalib&, uint8_t*, Array2D<uint8_t>&);
+  static GPUd() void findPeaksImpl(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, const CfArray2D<PackedCharge>&, const uint8_t*, const CfChargePos*, tpccf::SizeT, const GPUSettingsRec&, const TPCPadGainCalib&, uint8_t*, CfArray2D<uint8_t>&);
 
-  static GPUd() bool isPeak(GPUSharedMemory&, tpccf::Charge, const ChargePos&, uint16_t, const Array2D<PackedCharge>&, const GPUSettingsRec&, ChargePos*, PackedCharge*);
+  static GPUd() bool isPeak(GPUSharedMemory&, tpccf::Charge, const CfChargePos&, uint16_t, const CfArray2D<PackedCharge>&, const GPUSettingsRec&, CfChargePos*, PackedCharge*);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
index efed3643800b6..1da5a1158a8c2 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
@@ -15,7 +15,7 @@
 #include "GPUTPCCFStreamCompaction.h"
 #include "GPUCommonAlgorithm.h"
 
-#include "ChargePos.h"
+#include "CfChargePos.h"
 #include "CfUtils.h"
 
 using namespace o2::gpu;
@@ -92,7 +92,7 @@ GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanDow
 }
 
 template <>
-GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::compactDigits>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t iBuf, int32_t stage, ChargePos* in, ChargePos* out)
+GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::compactDigits>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t iBuf, int32_t stage, CfChargePos* in, CfChargePos* out)
 {
   uint32_t nElems = CompactionElems(clusterer, stage);
   SizeT bufferSize = (stage) ? clusterer.mNMaxClusters : clusterer.mNMaxPeaks;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
index 613c4ad9e5fa6..051391f12cc6d 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
@@ -16,12 +16,14 @@
 #include "GPUReconstruction.h"
 #include "GPUMemorySizeScalers.h"
 #include "GPUHostDataTypes.h"
+#include "GPUSettings.h"
 
+#include "DataFormatsTPC/ClusterNative.h"
 #include "DataFormatsTPC/ZeroSuppression.h"
 #include "DataFormatsTPC/Digit.h"
 
-#include "ChargePos.h"
-#include "Array2D.h"
+#include "CfChargePos.h"
+#include "CfArray2D.h"
 
 using namespace o2::gpu;
 using namespace o2::tpc;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
index 3e9ea2c6f608b..96efe08be6dc6 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
@@ -46,7 +46,7 @@ namespace o2::gpu
 struct GPUTPCClusterMCInterimArray;
 struct TPCPadGainCalib;
 
-struct ChargePos;
+struct CfChargePos;
 
 class GPUTPCClusterFinder : public GPUProcessor
 {
@@ -98,9 +98,9 @@ class GPUTPCClusterFinder : public GPUProcessor
   MinMaxCN* mMinMaxCN = nullptr;
   uint8_t* mPpadIsNoisy = nullptr;
   tpc::Digit* mPdigits = nullptr; // input digits, only set if ZS is skipped
-  ChargePos* mPpositions = nullptr;
-  ChargePos* mPpeakPositions = nullptr;
-  ChargePos* mPfilteredPeakPositions = nullptr;
+  CfChargePos* mPpositions = nullptr;
+  CfChargePos* mPpeakPositions = nullptr;
+  CfChargePos* mPfilteredPeakPositions = nullptr;
   uint8_t* mPisPeak = nullptr;
   uint32_t* mPclusterPosInRow = nullptr; // store the index where the corresponding cluster is stored in a bucket.
                                          // Required when MC are enabled to write the mc data to the correct position.
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
index a9fbc1b5f40e0..da30375149b7c 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
@@ -14,8 +14,10 @@
 
 #include "GPUTPCClusterFinder.h"
 #include "GPUReconstruction.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "DataFormatsTPC/Digit.h"
+#include "DataFormatsTPC/ClusterNative.h"
+#include "GPUSettings.h"
 
 using namespace o2::gpu;
 using namespace o2::gpu::tpccf;
@@ -37,7 +39,7 @@ void GPUTPCClusterFinder::DumpDigits(std::ostream& out)
 void GPUTPCClusterFinder::DumpChargeMap(std::ostream& out, std::string_view title)
 {
   out << "\nClusterer - " << title << " - Sector " << mISector << " - Fragment " << mPmemory->fragment.index << "\n";
-  Array2D<uint16_t> map(mPchargeMap);
+  CfArray2D<uint16_t> map(mPchargeMap);
 
   out << std::hex;
 
@@ -71,7 +73,7 @@ void GPUTPCClusterFinder::DumpPeakMap(std::ostream& out, std::string_view title)
 {
   out << "\nClusterer - " << title << " - Sector " << mISector << " - Fragment " << mPmemory->fragment.index << "\n";
 
-  Array2D<uint8_t> map(mPpeakMap);
+  CfArray2D<uint8_t> map(mPpeakMap);
 
   out << std::hex;
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
index fe3202fe7b439..092af2ea393c5 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
@@ -15,6 +15,7 @@
 #include "GPUReconstruction.h"
 #include "ML/3rdparty/GPUORTFloat16.h"
 #include "GPUTPCNNClusterizer.h"
+#include "GPUSettings.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index da490b0f94d58..022642f9f142e 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -15,7 +15,7 @@
 #ifndef O2_GPUTPCNNCLUSTERIZER_H
 #define O2_GPUTPCNNCLUSTERIZER_H
 
-#include "ChargePos.h"
+#include "CfChargePos.h"
 #include "GPUProcessor.h"
 
 namespace o2::OrtDataType
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 2cf9ab2037007..512bc1d3bb09b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -43,7 +43,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
   if (clustererNN.outputDataClass[glo_idx] == 0) { // default clusterizer should not be called in batched mode due to mess-up with thread indices
     return;
   }
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CPU_ONLY(MCLabelAccumulator labelAcc(clusterer));
   tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
   o2::gpu::GPUTPCCFClusterizer::GPUSharedMemory smem_new;
@@ -58,9 +58,9 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   auto& clustererNN = processors.tpcNNClusterer[sector];
   uint write_idx = glo_idx * clustererNN.nnClusterizerElementSize; // Potential optimization: Either choose nnClusterizerBatchedMode as a power of 2 or calculate from threadId and blockId
 
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
-  ChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
   int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad()), time = static_cast<int>(peak.time()); // Explicit casting to avoid conversion errors
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
   int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.nnClusterizerSizeInputRow);
@@ -75,7 +75,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
       bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.nnClusterizerSizeInputRow);
       for (int t = -clustererNN.nnClusterizerSizeInputTime; t <= clustererNN.nnClusterizerSizeInputTime; t++) {
         if (!is_boundary) {
-          ChargePos tmp_pos(row + r, pad + p, time + t);
+          CfChargePos tmp_pos(row + r, pad + p, time + t);
           if (r == 0 && !clustererNN.clusterFlags[2 * glo_idx] && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) { // ordering is done for short circuit optimization
             clustererNN.clusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
             clustererNN.clusterFlags[2 * glo_idx + 1] = clustererNN.clusterFlags[2 * glo_idx];
@@ -119,16 +119,16 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   uint base_idx = CAMath::Floor(glo_idx / clustererNN.nnClusterizerElementSize);
   uint transient_index = glo_idx % clustererNN.nnClusterizerElementSize;
 
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  Array2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
-  ChargePos peak = clusterer.mPfilteredPeakPositions[base_idx + batchStart];
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[base_idx + batchStart];
   int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad());
 
   if (clustererNN.nnClusterizerAddIndexData && transient_index == (clustererNN.nnClusterizerElementSize - 1)) {
     uint top_idx = (base_idx + 1) * clustererNN.nnClusterizerElementSize;
     for (uint16_t i = 0; i < 8; i++) {
       Delta2 d = cfconsts::InnerNeighbors[i];
-      ChargePos tmp_pos = peak.delta(d);
+      CfChargePos tmp_pos = peak.delta(d);
       clustererNN.clusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
       clustererNN.clusterFlags[2 * glo_idx + 1] = clustererNN.clusterFlags[2 * glo_idx];
     }
@@ -161,7 +161,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
       if (!is_boundary) {
         float central_charge = static_cast<float>(chargeMap[peak].unpack());
         int t = (rest_1 % (2 * clustererNN.nnClusterizerSizeInputTime + 1)) - clustererNN.nnClusterizerSizeInputTime;
-        ChargePos tmp_pos(row + r, pad + p, time + t);
+        CfChargePos tmp_pos(row + r, pad + p, time + t);
         if (dtype == 0) {
           clustererNN.inputData_16[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
         } else if (dtype == 1) {
@@ -227,8 +227,8 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  ChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
 
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
@@ -322,8 +322,8 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
-  Array2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  ChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
 
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index 27cfba2487aed..dc7f537c6c1e8 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -19,7 +19,7 @@
 #include "GPUGeneralKernels.h"
 #include "GPUConstantMem.h"
 #include "GPUTPCClusterFinder.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include "PackedCharge.h"
 #include "GPUTPCNNClusterizer.h"
 
@@ -47,7 +47,7 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
   static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer);
   struct GPUSharedMemory {
     // Regular cluster finder
-    ChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
+    CfChargePos posBcast[SCRATCH_PAD_WORK_GROUP_SIZE];
     PackedCharge buf[SCRATCH_PAD_WORK_GROUP_SIZE * SCRATCH_PAD_BUILD_N];
     uint8_t innerAboveThreshold[SCRATCH_PAD_WORK_GROUP_SIZE];
   };
diff --git a/GPU/GPUTracking/TPCClusterFinder/MCLabelAccumulator.cxx b/GPU/GPUTracking/TPCClusterFinder/MCLabelAccumulator.cxx
index 19ef7aa9ecd0d..e58edae208115 100644
--- a/GPU/GPUTracking/TPCClusterFinder/MCLabelAccumulator.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/MCLabelAccumulator.cxx
@@ -26,7 +26,7 @@ MCLabelAccumulator::MCLabelAccumulator(GPUTPCClusterFinder& clusterer)
 {
 }
 
-void MCLabelAccumulator::collect(const ChargePos& pos, Charge q)
+void MCLabelAccumulator::collect(const CfChargePos& pos, Charge q)
 {
   if (q == 0 || !engaged()) {
     return;
diff --git a/GPU/GPUTracking/TPCClusterFinder/MCLabelAccumulator.h b/GPU/GPUTracking/TPCClusterFinder/MCLabelAccumulator.h
index 176fbea02befe..35c24bfeb5f18 100644
--- a/GPU/GPUTracking/TPCClusterFinder/MCLabelAccumulator.h
+++ b/GPU/GPUTracking/TPCClusterFinder/MCLabelAccumulator.h
@@ -16,7 +16,7 @@
 #define O2_GPU_MC_LABEL_ACCUMULATOR_H
 
 #include "clusterFinderDefs.h"
-#include "Array2D.h"
+#include "CfArray2D.h"
 #include <bitset>
 #include <vector>
 
@@ -44,14 +44,14 @@ class MCLabelAccumulator
  public:
   MCLabelAccumulator(GPUTPCClusterFinder&);
 
-  void collect(const ChargePos&, tpccf::Charge);
+  void collect(const CfChargePos&, tpccf::Charge);
 
   bool engaged() const { return mLabels != nullptr && mOutput != nullptr; }
 
   void commit(tpccf::Row, uint32_t, uint32_t);
 
  private:
-  Array2D<const uint32_t> mIndexMap;
+  CfArray2D<const uint32_t> mIndexMap;
   const o2::dataformats::ConstMCLabelContainerView* mLabels = nullptr;
   GPUTPCClusterMCInterimArray* mOutput = nullptr;
 
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx b/GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx
index 3d6b45c372ea0..899149d320bda 100644
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx
+++ b/GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx
@@ -17,6 +17,7 @@
 #include "GPUTPCClusterData.h"
 #include "GPUReconstruction.h"
 #include "GPUO2DataTypes.h"
+#include "GPUParam.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
index c633f10adae38..2f754d2416bc1 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
@@ -22,6 +22,7 @@
 #include "GPUTRDTrackerDebug.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonAlgorithm.h"
+#include "GPUConstantMem.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/display/GPUDisplay.cxx b/GPU/GPUTracking/display/GPUDisplay.cxx
index c2b74489e6250..5b0960919da15 100644
--- a/GPU/GPUTracking/display/GPUDisplay.cxx
+++ b/GPU/GPUTracking/display/GPUDisplay.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUDisplay.h"
+#include "frontend/GPUDisplayInfo.inc"
 
 #include "GPUTPCDef.h"
 
@@ -204,7 +205,7 @@ int32_t GPUDisplay::DrawGLScene()
   int32_t retVal = 0;
   if (mChain) {
     mIOPtrs = &mChain->mIOPtrs;
-    mCalib = &mChain->calib();
+    mCalib = &mChain->GetCalib();
   }
   if (!mIOPtrs) {
     mNCollissions = 0;
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index bb270cda23565..dbd90020698b2 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -15,12 +15,10 @@
 #ifndef GPUDISPLAY_H
 #define GPUDISPLAY_H
 
-#include "GPUSettings.h"
 #include "frontend/GPUDisplayFrontend.h"
 #include "backend/GPUDisplayBackend.h"
 #include "GPUDisplayInterface.h"
 
-#include "GPUChainTracking.h"
 #include "../utils/vecpod.h"
 #include "../utils/qsem.h"
 
@@ -34,6 +32,7 @@ namespace o2::gpu
 class GPUTPCTracker;
 struct GPUParam;
 class GPUQA;
+class GPUTRDGeometry;
 
 class GPUDisplay : public GPUDisplayInterface
 {
@@ -77,7 +76,7 @@ class GPUDisplay : public GPUDisplayInterface
   int32_t& drawTextFontSize() { return mDrawTextFontSize; }
 
  private:
-  static constexpr int32_t NSECTORS = GPUChainTracking::NSECTORS;
+  static constexpr int32_t NSECTORS = GPUCA_NSECTORS;
   static constexpr float GL_SCALE_FACTOR = (1.f / 100.f);
 
   static constexpr const int32_t N_POINTS_TYPE = 15;
@@ -157,16 +156,7 @@ class GPUDisplay : public GPUDisplayInterface
   void insertVertexList(std::pair<vecpod<int32_t>*, vecpod<uint32_t>*>& vBuf, size_t first, size_t last);
   void insertVertexList(int32_t iSector, size_t first, size_t last);
   template <typename... Args>
-  void SetInfo(Args... args)
-  {
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wformat-security"
-#pragma GCC diagnostic ignored "-Wformat-truncation"
-    snprintf(mInfoText2, 1024, args...);
-#pragma GCC diagnostic pop
-    GPUInfo("%s", mInfoText2);
-    mInfoText2Timer.ResetStart();
-  }
+  void SetInfo(Args... args);
   void PrintGLHelpText(float colorValue);
   void calcXYZ(const float*);
   void mAnimationCloseAngle(float& newangle, float lastAngle);
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
index ded8803801fb7..98d2593c27950 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
@@ -34,6 +34,7 @@
 #endif
 
 #include "GPUDisplay.h"
+#include "GPULogging.h"
 #include <string>
 
 using namespace o2::gpu;
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
index 3ee3384c8e118..25ae5e1f8055f 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
@@ -27,6 +27,8 @@
 #include "GPUDisplayBackendOpenGL.h"
 #include "shaders/GPUDisplayShaders.h"
 #include "GPUDisplay.h"
+#include "GPULogging.h"
+#include "GPUParam.h"
 
 #define OPENGL_EMULATE_MULTI_DRAW 0
 
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
index 2324c194d04b9..93c19356ac062 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
@@ -19,6 +19,8 @@ VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
 #include "GPUCommonDef.h"
 #include "GPUDisplayBackendVulkan.h"
 #include "GPUDisplay.h"
+#include "GPULogging.h"
+#include "GPUParam.h"
 
 #include <mutex>
 
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx
index 590d8648eb5bb..22970c3228815 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx
@@ -30,6 +30,9 @@
 #include "GPUDisplayFrontendWayland.h"
 #endif
 
+#include "GPULogging.h"
+#include <cstring>
+
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_QT
 #include "GPUDisplayGUIWrapper.h"
 #else
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
index ad3b620ba8f55..d0aae2ffaad02 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
@@ -18,6 +18,7 @@
 #include "GPUDisplayGUIWrapper.h"
 #include "GPUDisplay.h"
 #include "GPULogging.h"
+#include "GPUParam.h"
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayInfo.inc b/GPU/GPUTracking/display/frontend/GPUDisplayInfo.inc
new file mode 100644
index 0000000000000..b6ac78b31f315
--- /dev/null
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayInfo.inc
@@ -0,0 +1,36 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDisplayInfo.inc
+/// \author David Rohr
+
+#ifndef GPUDISPLAYINFO_INC_H
+#define GPUDISPLAYINFO_INC_H
+
+#include "GPUDisplay.h"
+#include "GPULogging.h"
+
+namespace o2::gpu
+{
+template <typename... Args>
+void GPUDisplay::SetInfo(Args... args)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-security"
+#pragma GCC diagnostic ignored "-Wformat-truncation"
+  snprintf(mInfoText2, 1024, args...);
+#pragma GCC diagnostic pop
+  GPUInfo("%s", mInfoText2);
+  mInfoText2Timer.ResetStart();
+}
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
index 32ff6c73e110c..54258857a244c 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUDisplay.h"
+#include "frontend/GPUDisplayInfo.inc"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayAnimation.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayAnimation.cxx
index 6c0595b073cd0..cc9ec2e766c4d 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayAnimation.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayAnimation.cxx
@@ -13,6 +13,8 @@
 /// \author David Rohr
 
 #include "GPUDisplay.h"
+#include "frontend/GPUDisplayInfo.inc"
+#include "GPUCommonMath.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayBackendOpenGLMagneticField.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayBackendOpenGLMagneticField.cxx
index b04c93ab8496e..ef94628baeb38 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayBackendOpenGLMagneticField.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayBackendOpenGLMagneticField.cxx
@@ -31,6 +31,7 @@
 #include "backend/GPUDisplayBackendOpenGL.h"
 #include "shaders/GPUDisplayShaders.h"
 #include "GPUDisplay.h"
+#include "GPULogging.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx
index ca9fd6be01703..9d188d03c7b69 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx
@@ -13,6 +13,9 @@
 /// \author David Rohr
 
 #include "GPUDisplay.h"
+#include "GPUChainTracking.h"
+#include "GPULogging.h"
+#include "GPUParam.h"
 
 #ifndef _WIN32
 #include "bitmapfile.h"
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayInterpolation.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayInterpolation.cxx
index 644995929acb7..4dacaec2fbca5 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayInterpolation.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayInterpolation.cxx
@@ -14,6 +14,7 @@
 
 #include <cstdio>
 #include "GPUDisplay.h"
+#include "GPULogging.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayLoader.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayLoader.cxx
index ee50f32e3c1ac..d31ee206f35e2 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayLoader.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayLoader.cxx
@@ -16,6 +16,7 @@
 #include "frontend/GPUDisplayFrontend.h"
 #include "GPUDisplayInterface.h"
 
+#include <cstring>
 #include <tuple>
 #include <stdexcept>
 
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayROOT.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayROOT.cxx
index dbeefc7bf9b07..07a05e585d422 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayROOT.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayROOT.cxx
@@ -17,6 +17,9 @@
 #endif
 
 #include "GPUDisplay.h"
+#include "GPULogging.h"
+#include "GPUConstantMem.h"
+#include "GPUChainTracking.h"
 using namespace o2::gpu;
 
 #ifndef GPUCA_NO_ROOT
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 24668c576d795..e1d63ea1a21e4 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -28,6 +28,7 @@
 #include "GPUTPCMCInfo.h"
 #include "GPUParam.inc"
 #include "GPUCommonMath.h"
+#include "GPUChainTracking.h"
 
 #include <type_traits>
 
@@ -43,7 +44,7 @@ using namespace o2::gpu;
 #define GET_CID(sector, i) (mParam->par.earlyTpcTransform ? mIOPtrs->clusterData[sector][i].id : (mIOPtrs->clustersNative->clusterOffset[sector][0] + i))
 
 const GPUTRDGeometry* GPUDisplay::trdGeometry() { return (GPUTRDGeometry*)mCalib->trdGeometry; }
-const GPUTPCTracker& GPUDisplay::sectorTracker(int32_t iSector) { return mChain->GetTPCSectorTrackers()[iSector]; }
+const GPUTPCTracker& GPUDisplay::sectorTracker(int32_t iSector) { return mChain->GetProcessors()->tpcTrackers[iSector]; }
 
 inline void GPUDisplay::insertVertexList(std::pair<vecpod<int32_t>*, vecpod<uint32_t>*>& vBuf, size_t first, size_t last)
 {
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index 0a780732273db..ab4c0abd7b60e 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -17,6 +17,7 @@
 #endif
 
 #include "GPUDisplay.h"
+#include "frontend/GPUDisplayInfo.inc"
 #include "GPUO2DataTypes.h"
 #include "GPUTPCClusterData.h"
 #include "GPUTPCConvertImpl.h"
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 7e3ddf868af2a..202ea47d1f3bf 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -128,7 +128,7 @@ o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanStart"               "= TPCCLUS
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanUp"                  "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanTop"                 "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                "= TPCCLUSTERFINDER"                                    LB int32_t iBuf "uint32_t" offset int32_t nElems)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"           "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage ChargePos* in ChargePos* out)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"           "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage CfChargePos* in CfChargePos* out)
 o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                  "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF)
 o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                              "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
 o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                         "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index ba7aeb3800a5e..6a2623fb6e09d 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -38,6 +38,7 @@
 #include "GPUTPCDef.h"
 #include "GPUTPCTrackingData.h"
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
 #include "GPUTPCTrack.h"
 #include "GPUTPCTracker.h"
 #include "GPUTPCGMMergedTrack.h"
@@ -1702,7 +1703,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     }
   }
 
-  uint32_t nCl = clNative ? clNative->nClustersTotal : mTracking->GetTPCMerger().NMaxClusters();
+  uint32_t nCl = clNative ? clNative->nClustersTotal : mTracking->GetProcessors()->tpcMerger.NMaxClusters();
   mClusterCounts.nTotal += nCl;
   if (mQATasks & taskClusterCounts) {
     for (uint32_t i = 0; i < nCl; i++) {
diff --git a/GPU/GPUTracking/qa/genEvents.cxx b/GPU/GPUTracking/qa/genEvents.cxx
index 2e1bc1c5c64b2..9c2220f9ef748 100644
--- a/GPU/GPUTracking/qa/genEvents.cxx
+++ b/GPU/GPUTracking/qa/genEvents.cxx
@@ -37,6 +37,7 @@
 #include "GPUTPCGMPropagator.h"
 #include "GPUTPCGMMerger.h"
 #include "GPUChainTracking.h"
+#include "GPUConstantMem.h"
 
 #include "../utils/qconfig.h"
 
@@ -169,7 +170,7 @@ int32_t genEvents::GenerateEvent(const GPUParam& param, char* filename)
   GPUTPCGMPropagator prop;
   {
     prop.SetToyMCEventsFlag(kTRUE);
-    const GPUTPCGMMerger& merger = mRec->GetTPCMerger();
+    const GPUTPCGMMerger& merger = mRec->GetProcessors()->tpcMerger;
     prop.SetPolynomialField(&merger.Param().polynomialField);
   }
 

From 73a093527f4973ed92d43e7a8c893cbd8909af63 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 20 Apr 2025 20:57:39 +0200
Subject: [PATCH 0270/1764] GPU: Move kernel specializations to dedicated file

---
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |   8 +-
 ...GPUReconstructionCUDAKernelsSpecialize.inc | 138 ++++++++++++++++++
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |   2 +-
 .../opencl/GPUReconstructionOCLKernels.cxx    |   7 +-
 .../GPUReconstructionOCLKernelsSpecialize.inc |  20 +++
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 124 +---------------
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  15 --
 7 files changed, 164 insertions(+), 150 deletions(-)
 create mode 100644 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
 create mode 100644 GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernelsSpecialize.inc

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index 758ab1b0e36c3..11a62bcec2318 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -22,16 +22,12 @@ using namespace o2::gpu;
 
 #include "GPUReconstructionIncludesDeviceAll.h"
 
+#include "GPUReconstructionCUDAKernelsSpecialize.inc"
+
 #if defined(__HIPCC__) && defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM)
 __global__ void gGPUConstantMemBuffer_dummy(int32_t* p) { *p = *(int32_t*)&gGPUConstantMemBuffer; }
 #endif
 
-template <>
-inline void GPUReconstructionCUDA::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
-{
-  GPUChkErr(cudaMemsetAsync(ptr, 0, size, mInternals->Streams[_xyz.x.stream]));
-}
-
 template <class T, int32_t I, typename... Args>
 inline void GPUReconstructionCUDA::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
 {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
new file mode 100644
index 0000000000000..899c2e240cd94
--- /dev/null
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
@@ -0,0 +1,138 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUReconstructionCUDAKernelsSpecialize.inc
+/// \author David Rohr
+
+#if defined(GPUCA_SPECIALIZE_THRUST_SORTS) && !defined(GPUCA_GPUCODE_COMPILEKERNELS)
+
+namespace o2::gpu::internal
+{
+namespace // anonymous
+{
+struct MergeBorderTracks_compMax {
+  GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
+  {
+    return GPUCA_DETERMINISTIC_CODE((a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId), a.fMax < b.fMax);
+  }
+};
+struct MergeBorderTracks_compMin {
+  GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
+  {
+    return GPUCA_DETERMINISTIC_CODE((a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId), a.fMin < b.fMin);
+  }
+};
+
+struct GPUTPCGMMergerSortTracks_comp {
+  const GPUTPCGMMergedTrack* const mCmp;
+  GPUhd() GPUTPCGMMergerSortTracks_comp(GPUTPCGMMergedTrack* cmp) : mCmp(cmp) {}
+  GPUd() bool operator()(const int32_t aa, const int32_t bb)
+  {
+    const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
+    const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
+    if (a.CCE() != b.CCE()) {
+      return a.CCE() > b.CCE();
+    }
+    if (a.Legs() != b.Legs()) {
+      return a.Legs() > b.Legs();
+    }
+    GPUCA_DETERMINISTIC_CODE( // clang-format off
+      if (a.NClusters() != b.NClusters()) {
+        return a.NClusters() > b.NClusters();
+      } if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
+        return a.GetParam().GetY() > b.GetParam().GetY();
+      }
+      return aa > bb;
+    , // !GPUCA_DETERMINISTIC_CODE
+      return a.NClusters() > b.NClusters();
+    ) // clang-format on
+  }
+};
+
+struct GPUTPCGMMergerSortTracksQPt_comp {
+  const GPUTPCGMMergedTrack* const mCmp;
+  GPUhd() GPUTPCGMMergerSortTracksQPt_comp(GPUTPCGMMergedTrack* cmp) : mCmp(cmp) {}
+  GPUd() bool operator()(const int32_t aa, const int32_t bb)
+  {
+    const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
+    const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
+    GPUCA_DETERMINISTIC_CODE( // clang-format off
+      if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
+        return a.GetParam().GetY() > b.GetParam().GetY();
+      }
+      return a.GetParam().GetZ() > b.GetParam().GetZ();
+    , // !GPUCA_DETERMINISTIC_CODE
+      return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+    ) // clang-format on
+  }
+};
+
+struct GPUTPCGMMergerMergeLoopers_comp {
+  GPUd() bool operator()(const MergeLooperParam& a, const MergeLooperParam& b)
+  {
+    return CAMath::Abs(a.refz) < CAMath::Abs(b.refz);
+  }
+};
+
+struct GPUTPCGMO2OutputSort_comp {
+  GPUd() bool operator()(const GPUTPCGMMerger::tmpSort& a, const GPUTPCGMMerger::tmpSort& b)
+  {
+    return (a.y > b.y);
+  }
+};
+
+} // anonymous namespace
+} // namespace o2::gpu::internal
+
+template <>
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
+{
+  if (cmpMax) {
+    GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, range, N, MergeBorderTracks_compMax());
+  } else {
+    GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, range, N, MergeBorderTracks_compMin());
+  }
+}
+
+template <>
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
+{
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
+}
+
+template <>
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
+{
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
+}
+
+template <>
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
+{
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.LooperCandidates(), processors()->tpcMerger.Memory()->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
+}
+
+template <>
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
+{
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSortO2(), processors()->tpcMerger.NOutputTracksTPCO2(), GPUTPCGMO2OutputSort_comp());
+}
+#endif // GPUCA_SPECIALIZE_THRUST_SORTS
+
+template <>
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
+{
+  GPUChkErr(cudaMemsetAsync(ptr, 0, size, mInternals->Streams[_xyz.x.stream]));
+}
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index d7adb222d547b..d29a6afb60899 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -24,7 +24,7 @@ message(STATUS "Building GPUTracking with HIP support ${TMP_TARGET}")
 if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   set(GPUCA_HIP_SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/hipify)
   file(MAKE_DIRECTORY ${GPUCA_HIP_SOURCE_DIR})
-  set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDAkernel.template.cu GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDArtc.cu GPUReconstructionCUDARTCCalls.cu)
+  set(GPUCA_HIP_FILE_LIST GPUReconstructionCUDA.cu GPUReconstructionCUDAExternalProvider.cu GPUReconstructionCUDA.h GPUReconstructionCUDAInternals.h GPUReconstructionCUDAHelpers.inc GPUReconstructionCUDAkernel.template.cu GPUReconstructionCUDADef.h GPUReconstructionCUDAGenRTC.cxx GPUReconstructionCUDAKernels.cu GPUReconstructionCUDAKernelsSpecialize.inc GPUReconstructionCUDArtc.cu GPUReconstructionCUDARTCCalls.cu)
   set(GPUCA_HIP_LOCAL_FILE_LIST GPUReconstructionHIPIncludesSystem.h)
   set(HIP_SOURCES "")
   foreach(file ${GPUCA_HIP_FILE_LIST})
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index 29b71017e9f73..72c68428149dd 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -15,12 +15,7 @@
 #include "GPUReconstructionOCLIncludesHost.h"
 #include "GPUReconstructionKernelIncludes.h"
 
-template <>
-inline void GPUReconstructionOCL::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
-{
-  cl_int4 val0 = {0, 0, 0, 0};
-  GPUChkErr(clEnqueueFillBuffer(mInternals->command_queue[_xyz.x.stream], mInternals->mem_gpu, &val0, sizeof(val0), (char*)ptr - (char*)mDeviceMemoryBase, (size + sizeof(val0) - 1) & ~(sizeof(val0) - 1), _xyz.z.evList == nullptr ? 0 : _xyz.z.nEvents, _xyz.z.evList->getEventList<cl_event>(), _xyz.z.ev->getEventList<cl_event>()));
-}
+#include "GPUReconstructionOCLKernelsSpecialize.inc"
 
 template <class T, int32_t I, typename... Args>
 inline void GPUReconstructionOCL::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernelsSpecialize.inc b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernelsSpecialize.inc
new file mode 100644
index 0000000000000..1b860e47a4243
--- /dev/null
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernelsSpecialize.inc
@@ -0,0 +1,20 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUReconstructionOCLKernelsSpecialize.inc
+/// \author David Rohr
+
+template <>
+inline void GPUReconstructionOCL::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
+{
+  cl_int4 val0 = {0, 0, 0, 0};
+  GPUChkErr(clEnqueueFillBuffer(mInternals->command_queue[_xyz.x.stream], mInternals->mem_gpu, &val0, sizeof(val0), (char*)ptr - (char*)mDeviceMemoryBase, (size + sizeof(val0) - 1) & ~(sizeof(val0) - 1), _xyz.z.evList == nullptr ? 0 : _xyz.z.nEvents, _xyz.z.evList->getEventList<cl_event>(), _xyz.z.ev->getEventList<cl_event>()));
+}
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 4f960a8e1ec76..b6241ad36b5de 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -736,46 +736,15 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThrea
 #endif
 }
 
-#if defined(GPUCA_SPECIALIZE_THRUST_SORTS) && !defined(GPUCA_GPUCODE_COMPILEKERNELS) // Specialize MergeBorderTracks<3>
-namespace o2::gpu::internal
-{
-namespace // anonymous
-{
-struct MergeBorderTracks_compMax {
-  GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
-  {
-    return GPUCA_DETERMINISTIC_CODE((a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId), a.fMax < b.fMax);
-  }
-};
-struct MergeBorderTracks_compMin {
-  GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
-  {
-    return GPUCA_DETERMINISTIC_CODE((a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId), a.fMin < b.fMin);
-  }
-};
-} // anonymous namespace
-} // namespace o2::gpu::internal
-
-template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
-{
-  if (cmpMax) {
-    GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, range, N, MergeBorderTracks_compMax());
-  } else {
-    GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, range, N, MergeBorderTracks_compMin());
-  }
-}
-#endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize MergeBorderTracks<3>
-
 template <>
 GPUd() void GPUTPCGMMerger::MergeBorderTracks<3>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUTPCGMBorderRange* range, int32_t N, int32_t cmpMax)
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
   if (iThread == 0) {
     if (cmpMax) {
-      GPUCommonAlgorithm::sortDeviceDynamic(range, range + N, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return a.fMax < b.fMax; });
+      GPUCommonAlgorithm::sortDeviceDynamic(range, range + N, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return GPUCA_DETERMINISTIC_CODE((a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId), a.fMax < b.fMax); });
     } else {
-      GPUCommonAlgorithm::sortDeviceDynamic(range, range + N, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return a.fMin < b.fMin; });
+      GPUCommonAlgorithm::sortDeviceDynamic(range, range + N, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return GPUCA_DETERMINISTIC_CODE((a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId), a.fMin < b.fMin); });
     }
   }
 #endif
@@ -1783,74 +1752,6 @@ GPUd() void GPUTPCGMMerger::PrepareClustersForFit0(int32_t nBlocks, int32_t nThr
   }
 }
 
-#if defined(GPUCA_SPECIALIZE_THRUST_SORTS) && !defined(GPUCA_GPUCODE_COMPILEKERNELS) // Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
-namespace o2::gpu::internal
-{
-namespace // anonymous
-{
-struct GPUTPCGMMergerSortTracks_comp {
-  const GPUTPCGMMergedTrack* const mCmp;
-  GPUhd() GPUTPCGMMergerSortTracks_comp(GPUTPCGMMergedTrack* cmp) : mCmp(cmp) {}
-  GPUd() bool operator()(const int32_t aa, const int32_t bb)
-  {
-    const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
-    const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
-    if (a.CCE() != b.CCE()) {
-      return a.CCE() > b.CCE();
-    }
-    if (a.Legs() != b.Legs()) {
-      return a.Legs() > b.Legs();
-    }
-    GPUCA_DETERMINISTIC_CODE( // clang-format off
-      if (a.NClusters() != b.NClusters()) {
-        return a.NClusters() > b.NClusters();
-      } if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
-        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
-        return a.GetParam().GetY() > b.GetParam().GetY();
-      }
-      return aa > bb;
-    , // !GPUCA_DETERMINISTIC_CODE
-      return a.NClusters() > b.NClusters();
-    ) // clang-format on
-  }
-};
-
-struct GPUTPCGMMergerSortTracksQPt_comp {
-  const GPUTPCGMMergedTrack* const mCmp;
-  GPUhd() GPUTPCGMMergerSortTracksQPt_comp(GPUTPCGMMergedTrack* cmp) : mCmp(cmp) {}
-  GPUd() bool operator()(const int32_t aa, const int32_t bb)
-  {
-    const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
-    const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
-    GPUCA_DETERMINISTIC_CODE( // clang-format off
-      if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
-        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
-        return a.GetParam().GetY() > b.GetParam().GetY();
-      }
-      return a.GetParam().GetZ() > b.GetParam().GetZ();
-    , // !GPUCA_DETERMINISTIC_CODE
-      return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-    ) // clang-format on
-  }
-};
-} // anonymous namespace
-} // namespace o2::gpu::internal
-
-template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
-{
-  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
-}
-
-template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
-{
-  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
-}
-#endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
-
 GPUd() void GPUTPCGMMerger::SortTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
@@ -2050,27 +1951,6 @@ GPUd() void GPUTPCGMMerger::MergeLoopersSort(int32_t nBlocks, int32_t nThreads,
 #endif
 }
 
-#if defined(GPUCA_SPECIALIZE_THRUST_SORTS) && !defined(GPUCA_GPUCODE_COMPILEKERNELS) // Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
-namespace o2::gpu::internal
-{
-namespace // anonymous
-{
-struct GPUTPCGMMergerMergeLoopers_comp {
-  GPUd() bool operator()(const MergeLooperParam& a, const MergeLooperParam& b)
-  {
-    return CAMath::Abs(a.refz) < CAMath::Abs(b.refz);
-  }
-};
-} // anonymous namespace
-} // namespace o2::gpu::internal
-
-template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
-{
-  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.LooperCandidates(), processors()->tpcMerger.Memory()->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
-}
-#endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMMergerSortTracks and GPUTPCGMMergerSortTracksQPt
-
 GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
   const MergeLooperParam* params = mLooperCandidates;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 6640b556c3011..ea219a02a1887 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -93,21 +93,6 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::sort>(int32_t nBlocks,
 #endif
 }
 
-#if defined(GPUCA_SPECIALIZE_THRUST_SORTS) && !defined(GPUCA_GPUCODE_COMPILEKERNELS) // Specialize GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::sort>
-struct GPUTPCGMO2OutputSort_comp {
-  GPUd() bool operator()(const GPUTPCGMMerger::tmpSort& a, const GPUTPCGMMerger::tmpSort& b)
-  {
-    return (a.y > b.y);
-  }
-};
-
-template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
-{
-  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSortO2(), processors()->tpcMerger.NOutputTracksTPCO2(), GPUTPCGMO2OutputSort_comp());
-}
-#endif // GPUCA_SPECIALIZE_THRUST_SORTS - Specialize GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::sort>
-
 template <>
 GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {

From 29e2526be7b62961793f538b1c00d7f7f1618ccb Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 21 Apr 2025 10:30:29 +0200
Subject: [PATCH 0271/1764] GPU: Add protections not to do invalid memory
 allocations while volatile memory is allocated

---
 GPU/GPUTracking/Base/GPUMemoryResource.h      | 34 +++++------
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 56 ++++++++++++-------
 GPU/GPUTracking/Base/GPUReconstruction.h      | 18 +++---
 GPU/GPUTracking/Global/GPUChainITS.cxx        |  4 +-
 .../Global/GPUChainTrackingCompression.cxx    |  2 +-
 .../GPUChainTrackingDebugAndProfiling.cxx     |  2 +-
 .../Global/GPUChainTrackingMerger.cxx         |  2 +-
 7 files changed, 69 insertions(+), 49 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUMemoryResource.h b/GPU/GPUTracking/Base/GPUMemoryResource.h
index 06e350db0bfc7..947bcac504733 100644
--- a/GPU/GPUTracking/Base/GPUMemoryResource.h
+++ b/GPU/GPUTracking/Base/GPUMemoryResource.h
@@ -56,24 +56,24 @@ class GPUMemoryResource
 
  public:
   enum MemoryType {
-    MEMORY_HOST = 1,
-    MEMORY_GPU = 2,
-    MEMORY_INPUT_FLAG = 4,
-    MEMORY_INPUT = 7,
-    MEMORY_OUTPUT_FLAG = 8,
-    MEMORY_OUTPUT = 11,
-    MEMORY_INOUT = 15,
-    MEMORY_SCRATCH = 16,
-    MEMORY_SCRATCH_HOST = 17,
-    MEMORY_EXTERNAL = 32,
-    MEMORY_PERMANENT = 64,
-    MEMORY_CUSTOM = 128,
-    MEMORY_CUSTOM_TRANSFER = 256,
-    MEMORY_STACK = 512
+    MEMORY_HOST = 1,              // Memory allocated on host (irrespective of other flags)
+    MEMORY_GPU = 2,               // Memory allocated on GPU (irrespective of other flags)
+    MEMORY_INPUT_FLAG = 4,        // Flag to signal this memory is copied to GPU with TransferMemoryResourcesToGPU, and alike
+    MEMORY_INPUT = 7,             // Input data for GPU has the MEMORY_INPUT_FLAG flat and is allocated on host and GPU
+    MEMORY_OUTPUT_FLAG = 8,       // Flag to signal this memory is copied to Host with TransferMemoryResourcesToHost, and alike
+    MEMORY_OUTPUT = 11,           // Output data for GPU has the MEMORY_OUTPUT_FLAG flat and is allocated on host and GPU
+    MEMORY_INOUT = 15,            // Combination if MEMORY_INPUT and MEMORY_OUTPUT
+    MEMORY_SCRATCH = 16,          // Scratch memory, is allocated only on GPU by default if running on GPU, only on host otherwise, if MEMORY_HOST and MEMORY_GPU flags not set.
+    MEMORY_SCRATCH_HOST = 17,     // Scratch memory only on host
+    MEMORY_EXTERNAL = 32,         // Special flag to signal that memory on host shall not be allocated, but will be provided externally and manually
+    MEMORY_PERMANENT = 64,        // Permanent memory, registered once with AllocateRegisteredPermanentMemory, not per time frame. Only for small sizes!
+    MEMORY_CUSTOM = 128,          // Memory is not allocated automatically with AllocateRegisteredMemory(GPUProcessor), but must be allocated manually via AllocateRegisteredMemory(memoryId)
+    MEMORY_CUSTOM_TRANSFER = 256, // Memory is not transfered automatically with TransferMemoryResourcesTo, but must be transferred manually with TransferMemoryTo...(memoryId)
+    MEMORY_STACK = 512            // Use memory from non-persistent stack at the end of the global memory region. Not persistent for full TF. Use PushNonPersistentMemory and PopNonPersistentMemory to release memory from the stack
   };
-  enum AllocationType { ALLOCATION_AUTO = 0,
-                        ALLOCATION_INDIVIDUAL = 1,
-                        ALLOCATION_GLOBAL = 2 };
+  enum AllocationType { ALLOCATION_AUTO = 0,       // --> GLOBAL if GPU is used, INDIVIDUAL otherwise
+                        ALLOCATION_INDIVIDUAL = 1, // Individual memory allocations with malloc (host only)
+                        ALLOCATION_GLOBAL = 2 };   // Allocate memory blocks from large preallocated memory range with internal allocator (host and GPU)
 
   GPUMemoryResource(GPUProcessor* proc, void* (GPUProcessor::*setPtr)(void*), MemoryType type, const char* name = "") : mProcessor(proc), mPtr(nullptr), mPtrDevice(nullptr), mSetPointers(setPtr), mName(name), mSize(0), mOverrideSize(0), mReuse(-1), mType(type)
   {
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index c79c743e96ce5..ab2210e5dd555 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -538,6 +538,10 @@ size_t GPUReconstruction::AllocateRegisteredPermanentMemory()
   if (GetProcessingSettings().debugLevel >= 5) {
     GPUInfo("Allocating Permanent Memory");
   }
+  if (mVolatileMemoryStart) {
+    GPUError("Must not allocate permanent memory while volatile chunks are allocated");
+    throw std::bad_alloc();
+  }
   int32_t total = 0;
   for (uint32_t i = 0; i < mMemoryResources.size(); i++) {
     if ((mMemoryResources[i].mType & GPUMemoryResource::MEMORY_PERMANENT) && mMemoryResources[i].mPtr == nullptr) {
@@ -669,6 +673,10 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         GPUError("Device Processor not set (%s)", res->mName);
         throw std::bad_alloc();
       }
+      if (mVolatileMemoryStart && !mDeviceMemoryAsVolatile && !(res->mType & GPUMemoryResource::MEMORY_STACK)) {
+        GPUError("Must not allocate non-stacked device memory while volatile chunks are allocated");
+        throw std::bad_alloc();
+      }
       size_t size = AllocateRegisteredMemoryHelper(res, res->mPtrDevice, recPool->mDeviceMemoryPool, recPool->mDeviceMemoryBase, recPool->mDeviceMemorySize, &GPUMemoryResource::SetDevicePointers, recPool->mDeviceMemoryPoolEnd, " gpu");
 
       if (!(res->mType & GPUMemoryResource::MEMORY_HOST) || (res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) {
@@ -702,7 +710,7 @@ size_t GPUReconstruction::AllocateRegisteredMemory(int16_t ires, GPUOutputContro
   return res->mReuse >= 0 ? 0 : res->mSize;
 }
 
-void* GPUReconstruction::AllocateUnmanagedMemory(size_t size, int32_t type)
+void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
 {
   if (type != GPUMemoryResource::MEMORY_HOST && (!IsGPU() || type != GPUMemoryResource::MEMORY_GPU)) {
     throw std::runtime_error("Requested invalid memory typo for unmanaged allocation");
@@ -711,6 +719,10 @@ void* GPUReconstruction::AllocateUnmanagedMemory(size_t size, int32_t type)
     mUnmanagedChunks.emplace_back(new char[size + GPUCA_BUFFER_ALIGNMENT]);
     return GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(mUnmanagedChunks.back().get());
   } else {
+    if (mVolatileMemoryStart && !mDeviceMemoryAsVolatile && (type & GPUMemoryResource::MEMORY_GPU) && !(type & GPUMemoryResource::MEMORY_STACK)) {
+      GPUError("Must not allocate direct memory while volatile chunks are allocated");
+      throw std::bad_alloc();
+    }
     void*& pool = type == GPUMemoryResource::MEMORY_GPU ? mDeviceMemoryPool : mHostMemoryPool;
     void*& poolend = type == GPUMemoryResource::MEMORY_GPU ? mDeviceMemoryPoolEnd : mHostMemoryPoolEnd;
     char* retVal;
@@ -745,7 +757,6 @@ void* GPUReconstruction::AllocateVolatileDeviceMemory(size_t size)
   if (GetProcessingSettings().allocDebugLevel >= 2) {
     std::cout << "Allocated (volatile GPU): " << size << " - available: " << ptrDiff(mDeviceMemoryPoolEnd, mDeviceMemoryPool) << "\n";
   }
-
   return retVal;
 }
 
@@ -758,6 +769,30 @@ void* GPUReconstruction::AllocateVolatileMemory(size_t size, bool device)
   return GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(mVolatileChunks.back().get());
 }
 
+void GPUReconstruction::MakeFutureDeviceMemoryAllocationsVolatile()
+{
+  mDeviceMemoryAsVolatile = true;
+  AllocateVolatileDeviceMemory(0);
+}
+
+void GPUReconstruction::ReturnVolatileDeviceMemory()
+{
+  mDeviceMemoryAsVolatile = false;
+  if (mVolatileMemoryStart) {
+    mDeviceMemoryPool = mVolatileMemoryStart;
+    mVolatileMemoryStart = nullptr;
+  }
+  if (GetProcessingSettings().allocDebugLevel >= 2) {
+    std::cout << "Freed (volatile GPU) - available: " << ptrDiff(mDeviceMemoryPoolEnd, mDeviceMemoryPool) << "\n";
+  }
+}
+
+void GPUReconstruction::ReturnVolatileMemory()
+{
+  ReturnVolatileDeviceMemory();
+  mVolatileChunks.clear();
+}
+
 void GPUReconstruction::ResetRegisteredMemoryPointers(GPUProcessor* proc)
 {
   for (uint32_t i = 0; i < mMemoryResources.size(); i++) {
@@ -814,23 +849,6 @@ void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)
   res->mPtrDevice = nullptr;
 }
 
-void GPUReconstruction::ReturnVolatileDeviceMemory()
-{
-  if (mVolatileMemoryStart) {
-    mDeviceMemoryPool = mVolatileMemoryStart;
-    mVolatileMemoryStart = nullptr;
-  }
-  if (GetProcessingSettings().allocDebugLevel >= 2) {
-    std::cout << "Freed (volatile GPU) - available: " << ptrDiff(mDeviceMemoryPoolEnd, mDeviceMemoryPool) << "\n";
-  }
-}
-
-void GPUReconstruction::ReturnVolatileMemory()
-{
-  ReturnVolatileDeviceMemory();
-  mVolatileChunks.clear();
-}
-
 void GPUReconstruction::PushNonPersistentMemory(uint64_t tag)
 {
   mNonPersistentMemoryStack.emplace_back(mHostMemoryPoolEnd, mDeviceMemoryPoolEnd, mNonPersistentIndividualAllocations.size(), tag);
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index b6256f7f8ad82..396a007761fb7 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -166,9 +166,10 @@ class GPUReconstruction
 
   size_t AllocateRegisteredMemory(int16_t res, GPUOutputControl* control = nullptr);
   void AllocateRegisteredForeignMemory(int16_t res, GPUReconstruction* rec, GPUOutputControl* control = nullptr);
-  void* AllocateUnmanagedMemory(size_t size, int32_t type);
+  void* AllocateDirectMemory(size_t size, int32_t type);
   void* AllocateVolatileDeviceMemory(size_t size);
   void* AllocateVolatileMemory(size_t size, bool device);
+  void MakeFutureDeviceMemoryAllocationsVolatile();
   void FreeRegisteredMemory(GPUProcessor* proc, bool freeCustom = false, bool freePermanent = false);
   void FreeRegisteredMemory(int16_t res);
   void ClearAllocatedMemory(bool clearOutputs = true);
@@ -326,14 +327,15 @@ class GPUReconstruction
   void* mHostMemoryPoolBlocked = nullptr;   // Ptr to end of pool
   size_t mHostMemorySize = 0;               // Size of host memory buffer
   size_t mHostMemoryUsedMax = 0;            // Maximum host memory size used over time
-  void* mDeviceMemoryBase = nullptr;        //
-  void* mDeviceMemoryPermanent = nullptr;   //
-  void* mDeviceMemoryPool = nullptr;        //
-  void* mDeviceMemoryPoolEnd = nullptr;     //
-  void* mDeviceMemoryPoolBlocked = nullptr; //
-  size_t mDeviceMemorySize = 0;             //
+  void* mDeviceMemoryBase = nullptr;        // Same for device ...
+  void* mDeviceMemoryPermanent = nullptr;   // ...
+  void* mDeviceMemoryPool = nullptr;        // ...
+  void* mDeviceMemoryPoolEnd = nullptr;     // ...
+  void* mDeviceMemoryPoolBlocked = nullptr; // ...
+  size_t mDeviceMemorySize = 0;             // ...
+  size_t mDeviceMemoryUsedMax = 0;          // ...
   void* mVolatileMemoryStart = nullptr;     // Ptr to beginning of temporary volatile memory allocation, nullptr if uninitialized
-  size_t mDeviceMemoryUsedMax = 0;          //
+  bool mDeviceMemoryAsVolatile = false;     // Make device memory allocations volatile
 
   std::unordered_set<const void*> mRegisteredMemoryPtrs; // List of pointers registered for GPU
 
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index eeead79b1840b..5d36dc63ca85d 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -28,7 +28,7 @@ class GPUFrameworkExternalAllocator final : public o2::its::ExternalAllocator
  public:
   void* allocate(size_t size) override
   {
-    return mFWReco->AllocateUnmanagedMemory(size, GPUMemoryResource::MEMORY_GPU);
+    return mFWReco->AllocateDirectMemory(size, GPUMemoryResource::MEMORY_GPU);
   }
 
   void setReconstructionFramework(o2::gpu::GPUReconstruction* fwr) { mFWReco = fwr; }
@@ -86,7 +86,7 @@ o2::its::TimeFrame* GPUChainITS::GetITSTimeframe()
   }
 #if !defined(GPUCA_STANDALONE)
   if (mITSTimeFrame->mIsGPU) {
-    auto doFWExtAlloc = [this](size_t size) -> void* { return rec()->AllocateUnmanagedMemory(size, GPUMemoryResource::MEMORY_GPU); };
+    auto doFWExtAlloc = [this](size_t size) -> void* { return rec()->AllocateDirectMemory(size, GPUMemoryResource::MEMORY_GPU); };
 
     mFrameworkAllocator.reset(new o2::its::GPUFrameworkExternalAllocator);
     mFrameworkAllocator->setReconstructionFramework(rec());
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index fc07a91004c5f..24c74a661f18e 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -43,7 +43,7 @@ int32_t GPUChainTracking::RunTPCCompression()
   }
 
   if (gatherMode == 3) {
-    mRec->AllocateVolatileDeviceMemory(0); // make future device memory allocation volatile
+    mRec->MakeFutureDeviceMemoryAllocationsVolatile();
   }
   SetupGPUProcessor(&Compressor, true);
   new (Compressor.mMemory) GPUTPCCompression::memory;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 5d05cd6a97776..53bdfbadd4b25 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -34,7 +34,7 @@ static inline uint32_t RGB(uint8_t r, uint8_t g, uint8_t b) { return (uint32_t)r
 int32_t GPUChainTracking::PrepareProfile()
 {
 #ifdef GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE
-  char* tmpMem = (char*)mRec->AllocateUnmanagedMemory(PROFILE_MAX_SIZE, GPUMemoryResource::MEMORY_GPU);
+  char* tmpMem = (char*)mRec->AllocateDirectMemory(PROFILE_MAX_SIZE, GPUMemoryResource::MEMORY_GPU);
   processorsShadow()->tpcTrackers[0].mStageAtSync = tmpMem;
   runKernel<GPUMemClean16>({{BlockCount(), ThreadCount(), -1}}, tmpMem, PROFILE_MAX_SIZE);
 #endif
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 163f08634ef86..84835a1695071 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -297,7 +297,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     SynchronizeEventAndRelease(mEvents->single, doGPU);
 
     if (GetProcessingSettings().clearO2OutputFromGPU) {
-      mRec->AllocateVolatileDeviceMemory(0); // make future device memory allocation volatile
+      mRec->MakeFutureDeviceMemoryAllocationsVolatile();
     }
     AllocateRegisteredMemory(Merger.MemoryResOutputO2(), mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::tpcTracksO2)]);
     AllocateRegisteredMemory(Merger.MemoryResOutputO2Clus(), mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::tpcTracksO2ClusRefs)]);

From 52c23287f6abc479a29f9aa2fc1acebf64e58f29 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 20 Apr 2025 23:01:33 +0200
Subject: [PATCH 0272/1764] GPU: Get rid of backendInternal additional wrapper

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx | 18 +-----
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |  5 +-
 .../GPUReconstructionProcessingKernels.inc    |  9 ++-
 .../Base/cuda/GPUReconstructionCUDA.cu        |  3 +-
 .../Base/cuda/GPUReconstructionCUDA.h         |  7 +--
 .../Base/cuda/GPUReconstructionCUDAKernels.cu | 60 +++++++++----------
 ...GPUReconstructionCUDAKernelsSpecialize.inc | 12 ++--
 .../Base/opencl/GPUReconstructionOCL.cxx      |  2 +-
 .../Base/opencl/GPUReconstructionOCL.h        |  4 +-
 .../opencl/GPUReconstructionOCLKernels.cxx    | 14 +----
 .../GPUReconstructionOCLKernelsSpecialize.inc |  2 +-
 11 files changed, 59 insertions(+), 77 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 2453ce4a2328f..5f80a56e9e64e 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -54,7 +54,7 @@ GPUReconstructionCPU::~GPUReconstructionCPU()
 }
 
 template <class T, int32_t I, typename... Args>
-inline void GPUReconstructionCPU::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
+inline void GPUReconstructionCPU::runKernelBackend(const krnlSetupTime& _xyz, const Args&... args)
 {
   auto& x = _xyz.x;
   auto& y = _xyz.y;
@@ -88,7 +88,7 @@ inline void GPUReconstructionCPU::runKernelBackendInternal(const krnlSetupTime&
 }
 
 template <>
-inline void GPUReconstructionCPU::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
+inline void GPUReconstructionCPU::runKernelBackend<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
   int32_t nThreads = std::max<int32_t>(1, std::min<int32_t>(size / (16 * 1024 * 1024), getNKernelHostThreads(true)));
   if (nThreads > 1) {
@@ -108,17 +108,6 @@ inline void GPUReconstructionCPU::runKernelBackendInternal<GPUMemClean16, 0>(con
   }
 }
 
-template <class T, int32_t I, typename... Args>
-void GPUReconstructionCPU::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
-{
-#pragma GCC diagnostic push
-#if defined(__clang__)
-#pragma GCC diagnostic ignored "-Wunused-lambda-capture" // this is not alway captured below
-#endif
-  std::apply([this, &args](auto&... vals) { runKernelBackendInternal<T, I, Args...>(args.s, vals...); }, args.v);
-#pragma GCC diagnostic push
-}
-
 template <class S, int32_t I>
 GPUReconstructionProcessing::krnlProperties GPUReconstructionCPU::getKernelProperties(int gpu)
 {
@@ -137,8 +126,7 @@ GPUReconstructionProcessing::krnlProperties GPUReconstructionCPU::getKernelPrope
   return ret;
 }
 
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)                                                                                           \
-  template void GPUReconstructionCPU::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args); \
+#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) \
   template GPUReconstructionProcessing::krnlProperties GPUReconstructionCPU::getKernelProperties<GPUCA_M_KRNL_TEMPLATE(x_class)>(int gpu);
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index d0d8b05c4af0e..d93d1335d45c5 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -40,7 +40,7 @@ class GPUReconstructionCPU : public GPUReconstructionProcessing::KernelInterface
   template <class S, int32_t I = 0>
   krnlProperties getKernelProperties(int gpu = -1);
   template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
+  void runKernelBackend(const krnlSetupTime& _xyz, const Args&... args);
 
   virtual int32_t GPUDebug(const char* state = "UNKNOWN", int32_t stream = -1, bool force = false);
   int32_t GPUStuck() { return mGPUStuck; }
@@ -59,9 +59,6 @@ class GPUReconstructionCPU : public GPUReconstructionProcessing::KernelInterface
 
   GPUReconstructionCPU(const GPUSettingsDeviceBackend& cfg) : GPUReconstructionProcessing::KernelInterface<GPUReconstructionCPU, GPUReconstructionProcessing>(cfg) {}
 
-  template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
-
   int32_t registerMemoryForGPU_internal(const void* ptr, size_t size) override { return 0; }
   int32_t unregisterMemoryForGPU_internal(const void* ptr) override { return 0; }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessingKernels.inc b/GPU/GPUTracking/Base/GPUReconstructionProcessingKernels.inc
index 49d02515372b8..b303cb7c8d39c 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessingKernels.inc
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessingKernels.inc
@@ -21,6 +21,11 @@
 namespace o2::gpu
 {
 
+#pragma GCC diagnostic push
+#if defined(__clang__)
+#pragma GCC diagnostic ignored "-Wunused-lambda-capture" // this is not alway captured below
+#endif
+
 template <class T, class S>
 void GPUReconstructionProcessing::KernelInterface<T, S>::runKernelVirtual(const int num, const void* args)
 {
@@ -28,7 +33,7 @@ void GPUReconstructionProcessing::KernelInterface<T, S>::runKernelVirtual(const
 #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, x_num)                             \
     case x_num: {                                                                                             \
       const auto& args2 = *(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>*)args; \
-      ((T*)this)->template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(args2);                                    \
+      std::apply([this, &args2](auto&... vals) { ((T*)this)->template runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>(args2.s, vals...); }, args2.v); \
       break;                                                                                                  \
     }
 #include "GPUReconstructionKernelList.h"
@@ -36,6 +41,8 @@ void GPUReconstructionProcessing::KernelInterface<T, S>::runKernelVirtual(const
   } // clang-format on
 }
 
+#pragma GCC diagnostic push
+
 } // namespace o2::gpu
 
 #endif // GPURECONSTRUCTIONPROCESSINGKERNELS_H
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 970b331ea99fb..c40c607396f3f 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -24,7 +24,8 @@
 #include "GPUParamRTC.h"
 #include "GPUReconstructionCUDAHelpers.inc"
 #include "GPUDefParametersLoad.inc"
-#include "GPUReconstructionProcessingKernels.inc"
+#include "GPUReconstructionKernelIncludes.h"
+#include "GPUConstantMem.h"
 
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1
 #include "utils/qGetLdBinarySymbols.h"
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index ed75100dfe351..36dcdffb1c6d6 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -45,7 +45,9 @@ class GPUReconstructionCUDA : public GPUReconstructionProcessing::KernelInterfac
   virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override;
 
   template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
+  void runKernelBackend(const krnlSetupTime& _xyz, const Args&... args);
+  template <class T, int32_t I = 0, typename... Args>
+  void runKernelBackendTimed(const krnlSetupTime& _xyz, const Args&... args);
 
   template <class T, class S>
   friend GPUh() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp);
@@ -53,9 +55,6 @@ class GPUReconstructionCUDA : public GPUReconstructionProcessing::KernelInterfac
  protected:
   GPUReconstructionCUDAInternals* mInternals;
 
-  template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
-
   int32_t InitDevice_Runtime() override;
   int32_t ExitDevice_Runtime() override;
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index 11a62bcec2318..3267e1d5c67f6 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -23,13 +23,15 @@ using namespace o2::gpu;
 #include "GPUReconstructionIncludesDeviceAll.h"
 
 #include "GPUReconstructionCUDAKernelsSpecialize.inc"
+#include "GPUReconstructionProcessingKernels.inc"
+template void GPUReconstructionProcessing::KernelInterface<GPUReconstructionCUDA, GPUReconstructionDeviceBase>::runKernelVirtual(const int num, const void* args);
 
 #if defined(__HIPCC__) && defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM)
 __global__ void gGPUConstantMemBuffer_dummy(int32_t* p) { *p = *(int32_t*)&gGPUConstantMemBuffer; }
 #endif
 
 template <class T, int32_t I, typename... Args>
-inline void GPUReconstructionCUDA::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
+inline void GPUReconstructionCUDA::runKernelBackendTimed(const krnlSetupTime& _xyz, const Args&... args)
 {
 #if !defined(GPUCA_KERNEL_COMPILE_MODE) || GPUCA_KERNEL_COMPILE_MODE != 1
   if (!GetProcessingSettings().rtc.enable) {
@@ -52,18 +54,18 @@ inline void GPUReconstructionCUDA::runKernelBackendInternal(const krnlSetupTime&
 }
 
 template <class T, int32_t I, typename... Args>
-void GPUReconstructionCUDA::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
+inline void GPUReconstructionCUDA::runKernelBackend(const krnlSetupTime& _xyz, const Args&... args)
 {
-  auto& x = args.s.x;
-  auto& z = args.s.z;
+  auto& x = _xyz.x;
+  auto& z = _xyz.z;
   if (z.evList) {
     for (int32_t k = 0; k < z.nEvents; k++) {
       GPUChkErr(cudaStreamWaitEvent(mInternals->Streams[x.stream], ((cudaEvent_t*)z.evList)[k], 0));
     }
   }
   {
-    GPUDebugTiming timer(GetProcessingSettings().deviceTimers && GetProcessingSettings().debugLevel > 0, (deviceEvent*)mDebugEvents, mInternals->Streams, args.s, this);
-    std::apply([this, &args](auto&... vals) { this->runKernelBackendInternal<T, I, Args...>(args.s, vals...); }, args.v);
+    GPUDebugTiming timer(GetProcessingSettings().deviceTimers && GetProcessingSettings().debugLevel > 0, (deviceEvent*)mDebugEvents, mInternals->Streams, _xyz, this);
+    runKernelBackendTimed<T, I, Args...>(_xyz, args...);
   }
   GPUChkErr(cudaGetLastError());
   if (z.ev) {
@@ -74,31 +76,29 @@ void GPUReconstructionCUDA::runKernelBackend(const krnlSetupArgs<T, I, Args...>&
 #undef GPUCA_KRNL_REG
 #define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
 
-#if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1 // ---------- COMPILE_MODE = perkernel ----------
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) template void GPUReconstructionCUDA::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
-#else // ---------- COMPILE_MODE = onefile | rdc ----------
-#if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 2
-#define GPUCA_KRNL_DEFONLY // COMPILE_MODE = rdc
-#endif
-
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...)        \
-  GPUCA_KRNL_HOST(x_class, x_attributes, x_arguments, x_forward, x_types, __VA_ARGS__) \
-  template void GPUReconstructionCUDA::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
-
-#ifndef __HIPCC__ // CUDA version
-#define GPUCA_KRNL_CALL(x_class, ...) \
-  GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))<<<x.nBlocks, x.nThreads, 0, me->mInternals->Streams[x.stream]>>>(GPUCA_CONSMEM_CALL y.index, args...);
-#else // HIP version
-#undef GPUCA_KRNL_CUSTOM
-#define GPUCA_KRNL_CUSTOM(args) GPUCA_M_STRIP(args)
-#define GPUCA_KRNL_CALL(x_class, ...) \
-  hipLaunchKernelGGL(HIP_KERNEL_NAME(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), dim3(x.nBlocks), dim3(x.nThreads), 0, me->mInternals->Streams[x.stream], GPUCA_CONSMEM_CALL y.index, args...);
-#endif // __HIPCC__
-
+// clang-format off
+#if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE != 1 // ---------- COMPILE_MODE = perkernel ----------
+  #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 2
+    #define GPUCA_KRNL_DEFONLY // COMPILE_MODE = rdc
+  #endif
+
+  #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) \
+    GPUCA_KRNL_HOST(x_class, x_attributes, x_arguments, x_forward, x_types, __VA_ARGS__)
+
+  #ifndef __HIPCC__ // CUDA version
+    #define GPUCA_KRNL_CALL(x_class, ...) \
+      GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))<<<x.nBlocks, x.nThreads, 0, me->mInternals->Streams[x.stream]>>>(GPUCA_CONSMEM_CALL y.index, args...);
+  #else // HIP version
+    #undef GPUCA_KRNL_CUSTOM
+    #define GPUCA_KRNL_CUSTOM(args) GPUCA_M_STRIP(args)
+    #define GPUCA_KRNL_CALL(x_class, ...) \
+      hipLaunchKernelGGL(HIP_KERNEL_NAME(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), dim3(x.nBlocks), dim3(x.nThreads), 0, me->mInternals->Streams[x.stream], GPUCA_CONSMEM_CALL y.index, args...);
+  #endif // __HIPCC__
+
+  #include "GPUReconstructionKernelList.h"
+  #undef GPUCA_KRNL
 #endif // ---------- COMPILE_MODE = onefile | rdc ----------
-
-#include "GPUReconstructionKernelList.h"
-#undef GPUCA_KRNL
+// clang-format on
 
 #ifndef GPUCA_NO_CONSTANT_MEMORY
 static GPUReconstructionDeviceBase::deviceConstantMemRegistration registerConstSymbol([]() {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
index 899c2e240cd94..8796f063abdc5 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
@@ -97,7 +97,7 @@ struct GPUTPCGMO2OutputSort_comp {
 } // namespace o2::gpu::internal
 
 template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
 {
   if (cmpMax) {
     GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, range, N, MergeBorderTracks_compMax());
@@ -107,32 +107,32 @@ inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInter
 }
 
 template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
 {
   GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 
 template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
 {
   GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 
 template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerMergeLoopers, 1>(const krnlSetupTime& _xyz)
 {
   GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.LooperCandidates(), processors()->tpcMerger.Memory()->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
 }
 
 template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(const krnlSetupTime& _xyz)
 {
   GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSortO2(), processors()->tpcMerger.NOutputTracksTPCO2(), GPUTPCGMO2OutputSort_comp());
 }
 #endif // GPUCA_SPECIALIZE_THRUST_SORTS
 
 template <>
-inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
+inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
   GPUChkErr(cudaMemsetAsync(ptr, 0, size, mInternals->Streams[_xyz.x.stream]));
 }
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index 28c809dd4a09a..949dd6195b262 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -13,8 +13,8 @@
 /// \author David Rohr
 
 #include "GPUReconstructionOCLIncludesHost.h"
-#include "GPUReconstructionProcessingKernels.inc"
 #include "GPUDefParametersLoad.inc"
+#include "GPUConstantMem.h"
 
 #include <map>
 
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index 091bc0409630d..958d5186bf41a 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -34,7 +34,7 @@ class GPUReconstructionOCL : public GPUReconstructionProcessing::KernelInterface
   ~GPUReconstructionOCL() override;
 
   template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackend(const krnlSetupArgs<T, I, Args...>& args);
+  void runKernelBackend(const krnlSetupTime& _xyz, const Args&... args);
 
  protected:
   int32_t InitDevice_Runtime() override;
@@ -57,8 +57,6 @@ class GPUReconstructionOCL : public GPUReconstructionProcessing::KernelInterface
 
   template <class T, int32_t I = 0>
   int32_t AddKernel();
-  template <class T, int32_t I = 0, typename... Args>
-  void runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args);
 
   GPUReconstructionOCLInternals* mInternals;
   float mOclVersion;
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
index 72c68428149dd..655df5404276b 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernels.cxx
@@ -16,9 +16,11 @@
 #include "GPUReconstructionKernelIncludes.h"
 
 #include "GPUReconstructionOCLKernelsSpecialize.inc"
+#include "GPUReconstructionProcessingKernels.inc"
+template void GPUReconstructionProcessing::KernelInterface<GPUReconstructionOCL, GPUReconstructionDeviceBase>::runKernelVirtual(const int num, const void* args);
 
 template <class T, int32_t I, typename... Args>
-inline void GPUReconstructionOCL::runKernelBackendInternal(const krnlSetupTime& _xyz, const Args&... args)
+inline void GPUReconstructionOCL::runKernelBackend(const krnlSetupTime& _xyz, const Args&... args)
 {
   cl_kernel k = getKernelObject<cl_kernel, T, I>();
   auto& x = _xyz.x;
@@ -48,12 +50,6 @@ inline void GPUReconstructionOCL::runKernelBackendInternal(const krnlSetupTime&
   }
 }
 
-template <class T, int32_t I, typename... Args>
-void GPUReconstructionOCL::runKernelBackend(const krnlSetupArgs<T, I, Args...>& args)
-{
-  std::apply([this, &args](auto&... vals) { runKernelBackendInternal<T, I, Args...>(args.s, vals...); }, args.v);
-}
-
 template <class T, int32_t I>
 int32_t GPUReconstructionOCL::AddKernel()
 {
@@ -86,7 +82,3 @@ int32_t GPUReconstructionOCL::AddKernels()
 #undef GPUCA_KRNL
   return 0;
 }
-
-#define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) template void GPUReconstructionOCL::runKernelBackend<GPUCA_M_KRNL_TEMPLATE(x_class)>(const krnlSetupArgs<GPUCA_M_KRNL_TEMPLATE(x_class) GPUCA_M_STRIP(x_types)>& args);
-#include "GPUReconstructionKernelList.h"
-#undef GPUCA_KRNL
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernelsSpecialize.inc b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernelsSpecialize.inc
index 1b860e47a4243..d5b0338aecbd9 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernelsSpecialize.inc
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLKernelsSpecialize.inc
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 template <>
-inline void GPUReconstructionOCL::runKernelBackendInternal<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
+inline void GPUReconstructionOCL::runKernelBackend<GPUMemClean16, 0>(const krnlSetupTime& _xyz, void* const& ptr, uint64_t const& size)
 {
   cl_int4 val0 = {0, 0, 0, 0};
   GPUChkErr(clEnqueueFillBuffer(mInternals->command_queue[_xyz.x.stream], mInternals->mem_gpu, &val0, sizeof(val0), (char*)ptr - (char*)mDeviceMemoryBase, (size + sizeof(val0) - 1) & ~(sizeof(val0) - 1), _xyz.z.evList == nullptr ? 0 : _xyz.z.nEvents, _xyz.z.evList->getEventList<cl_event>(), _xyz.z.ev->getEventList<cl_event>()));

From 255597cf52515da16637a9a37bb3b70de1806d80 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 20 Apr 2025 23:47:46 +0200
Subject: [PATCH 0273/1764] GPU: Fix onefile compile mode after all the
 refactoring

---
 .../Base/GPUReconstructionKernelMacros.h        | 14 --------------
 .../Base/cuda/GPUReconstructionCUDA.h           |  2 ++
 .../Base/cuda/GPUReconstructionCUDAKernels.cu   | 17 +++++++++++++----
 3 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
index 2b16dfb32fe14..a03d9de13ef8f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
@@ -62,20 +62,6 @@
   }
 #endif
 
-// GPU Host wrappers for kernel
-#define GPUCA_KRNL_HOST(x_class, ...) \
-  GPUCA_KRNLGPU(x_class, __VA_ARGS__) \
-  template <> class GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::backendInternal<GPUCA_M_KRNL_TEMPLATE(x_class)> { \
-   public: \
-    template <typename T, typename... Args> \
-    static inline void runKernelBackendMacro(const krnlSetupTime& _xyz, T* me, const Args&... args) \
-    { \
-      auto& x = _xyz.x; \
-      auto& y = _xyz.y; \
-      GPUCA_KRNL_CALL(x_class, __VA_ARGS__) \
-    } \
-  };
-
 #endif // GPUCA_GPUCODE
 
 #define GPUCA_KRNL_LB(x_class, x_attributes, ...) GPUCA_KRNL(x_class, (REG, (GPUCA_M_CAT(GPUCA_LB_, GPUCA_M_KRNL_NAME(x_class))), GPUCA_M_STRIP(x_attributes)), __VA_ARGS__)
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 36dcdffb1c6d6..6c126d153d8ae 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -48,6 +48,8 @@ class GPUReconstructionCUDA : public GPUReconstructionProcessing::KernelInterfac
   void runKernelBackend(const krnlSetupTime& _xyz, const Args&... args);
   template <class T, int32_t I = 0, typename... Args>
   void runKernelBackendTimed(const krnlSetupTime& _xyz, const Args&... args);
+  template <class T, int32_t I>
+  struct kernelBackendMacro;
 
   template <class T, class S>
   friend GPUh() void GPUCommonAlgorithm::sortOnDevice(auto* rec, int32_t stream, T* begin, size_t N, const S& comp);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index 3267e1d5c67f6..e6ed94bba2cec 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -35,7 +35,7 @@ inline void GPUReconstructionCUDA::runKernelBackendTimed(const krnlSetupTime& _x
 {
 #if !defined(GPUCA_KERNEL_COMPILE_MODE) || GPUCA_KERNEL_COMPILE_MODE != 1
   if (!GetProcessingSettings().rtc.enable) {
-    backendInternal<T, I>::runKernelBackendMacro(_xyz, this, args...);
+    kernelBackendMacro<T, I>::run(_xyz, this, args...);
   } else
 #endif
   {
@@ -82,9 +82,6 @@ inline void GPUReconstructionCUDA::runKernelBackend(const krnlSetupTime& _xyz, c
     #define GPUCA_KRNL_DEFONLY // COMPILE_MODE = rdc
   #endif
 
-  #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) \
-    GPUCA_KRNL_HOST(x_class, x_attributes, x_arguments, x_forward, x_types, __VA_ARGS__)
-
   #ifndef __HIPCC__ // CUDA version
     #define GPUCA_KRNL_CALL(x_class, ...) \
       GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))<<<x.nBlocks, x.nThreads, 0, me->mInternals->Streams[x.stream]>>>(GPUCA_CONSMEM_CALL y.index, args...);
@@ -95,6 +92,18 @@ inline void GPUReconstructionCUDA::runKernelBackend(const krnlSetupTime& _xyz, c
       hipLaunchKernelGGL(HIP_KERNEL_NAME(GPUCA_M_CAT(krnl_, GPUCA_M_KRNL_NAME(x_class))), dim3(x.nBlocks), dim3(x.nThreads), 0, me->mInternals->Streams[x.stream], GPUCA_CONSMEM_CALL y.index, args...);
   #endif // __HIPCC__
 
+  #define GPUCA_KRNL(x_class, x_attributes, x_arguments, x_forward, x_types, ...) \
+    GPUCA_KRNLGPU(x_class, x_attributes, x_arguments, x_forward, x_types, __VA_ARGS__) \
+    template <> struct GPUReconstructionCUDA::kernelBackendMacro<GPUCA_M_KRNL_TEMPLATE(x_class)> { \
+      template <typename... Args> \
+      static inline void run(const GPUReconstructionProcessing::krnlSetupTime& _xyz, auto* me, const Args&... args) \
+      { \
+        auto& x = _xyz.x; \
+        auto& y = _xyz.y; \
+        GPUCA_KRNL_CALL(x_class, x_attributes, x_arguments, x_forward, x_types, __VA_ARGS__) \
+      } \
+    };
+
   #include "GPUReconstructionKernelList.h"
   #undef GPUCA_KRNL
 #endif // ---------- COMPILE_MODE = onefile | rdc ----------

From 062fbe612c19a9bb23d77fff43c42d74d7e54b6e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 22 Apr 2025 10:33:57 +0200
Subject: [PATCH 0274/1764] ITS: fix integer comparison warning in NoiseMap

---
 .../ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h
index 49e6f531eeb76..25b7f451b6452 100644
--- a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/NoiseMap.h
@@ -205,7 +205,7 @@ class NoiseMap
   NoiseMap merge(const NoiseMap* prev)
   {
     int incre = 0;
-    for (size_t i = 0; i < (int)mNoisyPixels.size(); ++i) {
+    for (size_t i = 0; i < mNoisyPixels.size(); ++i) {
       for (const auto& prev_np : prev->mNoisyPixels[i]) { // only enters this for loop if the "i" chip exists.
         if (mNoisyPixels[i].find(prev_np.first) == mNoisyPixels[i].end()) {
           mNoisyPixels[i][prev_np.first] = prev_np.second;

From b05a704889e0d5004c8029f25161af4112d27a90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?BiaoZhang=20=28=E5=BC=A0=E5=BD=AA=29?=
 <52267892+zhangbiao-phy@users.noreply.github.com>
Date: Tue, 22 Apr 2025 11:36:55 +0200
Subject: [PATCH 0275/1764] Add PDG code and mass of Bc meson (#14175)

* Add PDG code and mass of Bc

* Update make_pdg_header.py with Bc meson

* Update PhysicsConstants.h

* Update PhysicsConstants.h
---
 Common/Constants/include/CommonConstants/PhysicsConstants.h | 2 ++
 Common/Constants/include/CommonConstants/make_pdg_header.py | 1 +
 2 files changed, 3 insertions(+)

diff --git a/Common/Constants/include/CommonConstants/PhysicsConstants.h b/Common/Constants/include/CommonConstants/PhysicsConstants.h
index c6fa3cddcdad5..f3b983b966faf 100644
--- a/Common/Constants/include/CommonConstants/PhysicsConstants.h
+++ b/Common/Constants/include/CommonConstants/PhysicsConstants.h
@@ -34,6 +34,7 @@ enum Pdg {
   kB0 = 511,
   kB0Bar = -511,
   kBPlus = 521,
+  kBCPlus = 541,
   kBS = 531,
   kBSBar = -531,
   kD0 = 421,
@@ -84,6 +85,7 @@ enum Pdg {
 constexpr double MassB0 = 5.27966;
 constexpr double MassB0Bar = 5.27966;
 constexpr double MassBPlus = 5.27934;
+constexpr double MassBCPlus = 6.27447;
 constexpr double MassBS = 5.36692;
 constexpr double MassBSBar = 5.36692;
 constexpr double MassD0 = 1.86484;
diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index e4f92e6e8b62d..89e3f0e35070d 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -89,6 +89,7 @@ class Pdg(Enum):
     kB0 = 511
     kB0Bar = -511
     kBPlus = 521
+    kBCPlus = 541
     kBS = 531
     kBSBar = -531
     kD0 = 421

From 3412dff968bad3565c97df879a5974c6366610ca Mon Sep 17 00:00:00 2001
From: Mattia Faggin <mattia.faggin@cern.ch>
Date: Tue, 22 Apr 2025 11:37:16 +0200
Subject: [PATCH 0276/1764] Add SigmaC(2520). (#14187)

* Add SigmaC(2520).

* Remove comments

* Update python script.

---------

Co-authored-by: Mattia Faggin <mfaggin@alipap1.cern.ch>
---
 Common/Constants/include/CommonConstants/PhysicsConstants.h | 4 ++++
 Common/Constants/include/CommonConstants/make_pdg_header.py | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/Common/Constants/include/CommonConstants/PhysicsConstants.h b/Common/Constants/include/CommonConstants/PhysicsConstants.h
index f3b983b966faf..5f169f799eb5b 100644
--- a/Common/Constants/include/CommonConstants/PhysicsConstants.h
+++ b/Common/Constants/include/CommonConstants/PhysicsConstants.h
@@ -64,6 +64,8 @@ enum Pdg {
   kPhi = 333,
   kSigmaC0 = 4112,
   kSigmaCPlusPlus = 4222,
+  kSigmaCStar0 = 4114,
+  kSigmaCStarPlusPlus = 4224,
   kX3872 = 9920443,
   kXi0 = 3322,
   kXiB0 = 5232,
@@ -115,6 +117,8 @@ constexpr double MassKPlusStar892 = 0.89167;
 constexpr double MassPhi = 1.019461;
 constexpr double MassSigmaC0 = 2.45375;
 constexpr double MassSigmaCPlusPlus = 2.45397;
+constexpr double MassSigmaCStar0 = 2.51848;
+constexpr double MassSigmaCStarPlusPlus = 2.51841;
 constexpr double MassX3872 = 3.87165;
 constexpr double MassXi0 = 1.31486;
 constexpr double MassXiB0 = 5.7919;
diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index 89e3f0e35070d..4fdfd052ff613 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -119,6 +119,8 @@ class Pdg(Enum):
     kPhi = 333
     kSigmaC0 = 4112
     kSigmaCPlusPlus = 4222
+    kSigmaCStar0 = 4114
+    kSigmaCStarPlusPlus = 4224
     kX3872 = 9920443
     kXi0 = 3322
     kXiB0 = 5232

From 37d0ba15113ee8666208a00b0e6ef7c070df8f3f Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Thu, 10 Apr 2025 08:06:34 +0200
Subject: [PATCH 0277/1764] TPC: change default setting for pad status map

---
 .../TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h
index aff7c279cf5a8..667386e6481ca 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h
@@ -506,7 +506,7 @@ DataProcessorSpec getTPCFactorizeIDCSpec(const int lane, const std::vector<uint3
             {"dump-IDCDelta", VariantType::Bool, false, {"Dump IDCDelta to file"}},
             {"dump-IDCDelta-calib-data", VariantType::Bool, false, {"Dump IDCDelta as calibration data to file"}},
             {"add-offset-for-CCDB-timestamp", VariantType::Bool, false, {"Add an offset of 1 hour for the validity range of the CCDB objects"}},
-            {"pad-status-map-offset", VariantType::Float, 0.f, {"Offset in seconds for timestamp of pad status map CCDB object (overwrites pad-status-map-offset-nslots)"}},
+            {"pad-status-map-offset", VariantType::Float, 120.f, {"Offset in seconds for timestamp of pad status map CCDB object (overwrites pad-status-map-offset-nslots)"}},
             {"pad-status-map-offset-nslots", VariantType::Int, 0, {"Offset in slot length units for timestamp of pad status map CCDB object"}},
             {"output-dir", VariantType::String, "none", {"calibration files output directory, must exist"}},
             {"meta-output-dir", VariantType::String, "/dev/null", {"calibration metadata output directory, must exist (if not /dev/null)"}},

From 4204d44502e870131de397622c1ea571c8485af3 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Apr 2025 09:28:39 +0200
Subject: [PATCH 0278/1764] GPU CMake: Set GPU architecture before checking the
 language, to suppress warnings about architecture detection failure

---
 dependencies/FindO2GPU.cmake | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index d50705d106bf3..0c5313c16af68 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -103,6 +103,9 @@ endif()
 
 # ---------------------------------- CUDA ----------------------------------
 if(ENABLE_CUDA)
+  if(CUDA_COMPUTETARGET)
+    set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET} CACHE STRING "" FORCE)
+  endif()
   set(CMAKE_CUDA_STANDARD ${CMAKE_CXX_STANDARD})
   set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)
   include(CheckLanguage)
@@ -227,6 +230,9 @@ endif()
 
 # ---------------------------------- HIP ----------------------------------
 if(ENABLE_HIP)
+  if(HIP_AMDGPUTARGET)
+    set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}" CACHE STRING "" FORCE)
+  endif()
   if(NOT "$ENV{CMAKE_PREFIX_PATH}" MATCHES "rocm" AND NOT CMAKE_PREFIX_PATH MATCHES "rocm" AND EXISTS "/opt/rocm/lib/cmake/")
     list(APPEND CMAKE_PREFIX_PATH "/opt/rocm/lib/cmake")
   endif()
@@ -300,7 +306,7 @@ if(ENABLE_HIP)
     endif()
     string(REGEX REPLACE "(gfx1[0-9]+;?)" "" CMAKE_HIP_ARCHITECTURES "${CMAKE_HIP_ARCHITECTURES}") # ROCm currently doesn’t support integrated graphics
     if(HIP_AMDGPUTARGET)
-      set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}") # If GPU build is enforced we override autodetection
+      set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}")
     endif()
   else()
     set(HIP_ENABLED OFF)

From 33f93083e7524497014e31740f87a5a74c399ca1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Apr 2025 09:34:49 +0200
Subject: [PATCH 0279/1764] ONNXRuntime CMake: Use standard ONNXRuntime
 lowercase library syntax, remove obsolete wrapper, move detection from
 toplevel CMake to dependencies

---
 CMakeLists.txt                           |  2 --
 Common/ML/CMakeLists.txt                 |  2 +-
 GPU/GPUTracking/Base/cuda/CMakeLists.txt |  2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt  |  2 +-
 GPU/GPUTracking/CMakeLists.txt           |  2 +-
 dependencies/FindONNXRuntime.cmake       | 23 -----------------------
 dependencies/O2Dependencies.cmake        |  3 +++
 7 files changed, 7 insertions(+), 29 deletions(-)
 delete mode 100644 dependencies/FindONNXRuntime.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d28f191021fdf..b71d05175e9e9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,8 +41,6 @@ o2_build_sanity_checks()
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 
-include(dependencies/FindONNXRuntime.cmake)
-
 include(O2CheckCXXFeatures)
 o2_check_cxx_features()
 
diff --git a/Common/ML/CMakeLists.txt b/Common/ML/CMakeLists.txt
index 2db91fc4f4320..a5b336bf7e820 100644
--- a/Common/ML/CMakeLists.txt
+++ b/Common/ML/CMakeLists.txt
@@ -12,7 +12,7 @@
 o2_add_library(ML
                SOURCES src/OrtInterface.cxx
                TARGETVARNAME targetName
-               PRIVATE_LINK_LIBRARIES O2::Framework ONNXRuntime::ONNXRuntime)
+               PRIVATE_LINK_LIBRARIES O2::Framework onnxruntime::onnxruntime)
 
 # Pass ORT variables as a preprocessor definition
 target_compile_definitions(${targetName} PRIVATE
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index f595fb051db54..8dd430d00a5c0 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -114,7 +114,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${MODULE}
     SOURCES ${SRCS}
     PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingCUDA
-    PRIVATE_LINK_LIBRARIES ONNXRuntime::ONNXRuntime
+    PRIVATE_LINK_LIBRARIES onnxruntime::onnxruntime
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index d29a6afb60899..315a6c2fa3080 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -162,7 +162,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${MODULE}
     SOURCES ${SRCS}
     PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingHIP
-    PRIVATE_LINK_LIBRARIES ONNXRuntime::ONNXRuntime
+    PRIVATE_LINK_LIBRARIES onnxruntime::onnxruntime
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 0cd302cc0be94..c0648b3274108 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -343,7 +343,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                                        O2::DetectorsRaw
                                        O2::Steer
                                        O2::ML
-                 PRIVATE_LINK_LIBRARIES ONNXRuntime::ONNXRuntime
+                 PRIVATE_LINK_LIBRARIES onnxruntime::onnxruntime
                  PUBLIC_INCLUDE_DIRECTORIES ${INCDIRS}
                  SOURCES ${SRCS} ${SRCS_NO_CINT} ${SRCS_NO_H})
 
diff --git a/dependencies/FindONNXRuntime.cmake b/dependencies/FindONNXRuntime.cmake
deleted file mode 100644
index b783c2e1c7bf3..0000000000000
--- a/dependencies/FindONNXRuntime.cmake
+++ /dev/null
@@ -1,23 +0,0 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-# All rights not expressly granted are reserved.
-#
-# This software is distributed under the terms of the GNU General Public
-# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-#
-# In applying this license CERN does not waive the privileges and immunities
-# granted to it by virtue of its status as an Intergovernmental Organization
-# or submit itself to any jurisdiction.
-
-find_package(ONNXRuntime::ONNXRuntime CONFIG)
-if (ONNXRuntime::ONNXRuntime_FOUND)
-  set(onnxruntime_FOUND 1)
-  add_library(onnxruntime::onnxruntime ALIAS ONNXRuntime::ONNXRuntime)
-endif()
-
-if (NOT ONNXRuntime::ONNXRuntime_FOUND)
-  find_package(onnxruntime CONFIG)
-  if (onnxruntime_FOUND)
-    add_library(ONNXRuntime::ONNXRuntime ALIAS onnxruntime::onnxruntime)
-  endif()
-endif()
diff --git a/dependencies/O2Dependencies.cmake b/dependencies/O2Dependencies.cmake
index c5c22b3a79097..9020f99b4877b 100644
--- a/dependencies/O2Dependencies.cmake
+++ b/dependencies/O2Dependencies.cmake
@@ -69,6 +69,9 @@ if (NOT TARGET Gandiva::gandiva_shared)
   add_library(Gandiva::gandiva_shared ALIAS gandiva_shared)
 endif()
 
+find_package(onnxruntime CONFIG)
+set_package_properties(onnxruntime PROPERTIES TYPE REQUIRED)
+
 find_package(Vc)
 set_package_properties(Vc PROPERTIES TYPE REQUIRED)
 

From 121ec682d4868106df67cf923699e82523afd23c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Apr 2025 10:22:49 +0200
Subject: [PATCH 0280/1764] GPU ONNX: Fix compiler warning and simplify code

---
 .../Base/cuda/GPUReconstructionCUDA.cu        | 53 +++++++++----------
 1 file changed, 24 insertions(+), 29 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index c40c607396f3f..d5b01bfa34833 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -621,21 +621,10 @@ void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
   }
 }
 
-#ifndef __HIPCC__ // CUDA
-void GPUReconstructionCUDA::startGPUProfiling()
-{
-  GPUChkErr(cudaProfilerStart());
-}
-
-void GPUReconstructionCUDA::endGPUProfiling()
-{
-  GPUChkErr(cudaProfilerStop());
-}
-
 void GPUReconstructionCUDA::SetONNXGPUStream(Ort::SessionOptions& session_options, int32_t stream, int32_t* deviceId)
 {
-#ifdef ORT_CUDA_BUILD
-  cudaGetDevice(deviceId);
+  GPUChkErr(cudaGetDevice(deviceId));
+#if !defined(__HIPCC__) && defined(ORT_CUDA_BUILD)
   OrtCUDAProviderOptionsV2* cuda_options = nullptr;
   CreateCUDAProviderOptions(&cuda_options);
 
@@ -650,22 +639,7 @@ void GPUReconstructionCUDA::SetONNXGPUStream(Ort::SessionOptions& session_option
 
   // Finally, don't forget to release the provider options
   ReleaseCUDAProviderOptions(cuda_options);
-#endif // ORT_CUDA_BUILD
-}
-
-#else  // HIP
-void* GPUReconstructionHIP::getGPUPointer(void* ptr)
-{
-  void* retVal = nullptr;
-  GPUChkErr(hipHostGetDevicePointer(&retVal, ptr, 0));
-  return retVal;
-}
-
-void GPUReconstructionHIP::SetONNXGPUStream(Ort::SessionOptions& session_options, int32_t stream, int32_t* deviceId)
-{
-#ifdef ORT_ROCM_BUILD
-  // Create ROCm provider options
-  cudaGetDevice(deviceId);
+#elif defined(ORT_ROCM_BUILD)
   // const auto& api = Ort::GetApi();
   // api.GetCurrentGpuDeviceId(deviceId);
   OrtROCMProviderOptions rocm_options;
@@ -676,4 +650,25 @@ void GPUReconstructionHIP::SetONNXGPUStream(Ort::SessionOptions& session_options
   session_options.AppendExecutionProvider_ROCM(rocm_options);
 #endif // ORT_ROCM_BUILD
 }
+
+#ifndef __HIPCC__ // CUDA
+
+void GPUReconstructionCUDA::startGPUProfiling()
+{
+  GPUChkErr(cudaProfilerStart());
+}
+
+void GPUReconstructionCUDA::endGPUProfiling()
+{
+  GPUChkErr(cudaProfilerStop());
+}
+
+#else // HIP
+void* GPUReconstructionHIP::getGPUPointer(void* ptr)
+{
+  void* retVal = nullptr;
+  GPUChkErr(hipHostGetDevicePointer(&retVal, ptr, 0));
+  return retVal;
+}
+
 #endif // __HIPCC__

From 72eed35cf94511efea88384d35dba3b9ad9e9bae Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Tue, 22 Apr 2025 14:23:33 +0200
Subject: [PATCH 0281/1764] Bug fix for incorrect setting

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 1106f96ed1cb2..2d8c2184e3b02 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -272,7 +272,7 @@ AddOption(nnRegressionPath, std::string, "network_reg.onnx", "", 0, "The regress
 AddOption(nnSigmoidTrafoClassThreshold, int, 1, "", 0, "If true (default), then the classification threshold is transformed by an inverse sigmoid function. This depends on how the network was trained (with a sigmoid as acitvation function in the last layer or not).")
 AddOption(nnEvalMode, std::string, "c1:r1", "", 0, "Concatention of modes, e.g. c1:r1 (classification class 1, regression class 1)")
 // CCDB
-AddOption(nnLoadFromCCDB, int, 1, "", 0, "If 1 networks are fetched from ccdb, else locally")
+AddOption(nnLoadFromCCDB, int, 0, "", 0, "If 1 networks are fetched from ccdb, else locally")
 AddOption(nnLocalFolder, std::string, ".", "", 0, "Local folder in which the networks will be fetched")
 AddOption(nnCCDBURL, std::string, "http://ccdb-test.cern.ch:8080", "", 0, "The CCDB URL from where the network files are fetched")
 AddOption(nnCCDBPath, std::string, "Users/c/csonnabe/TPC/Clusterization", "", 0, "Folder path containing the networks")

From 83c6a8a500f4f4a01e83475fbd608cbde674af76 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Apr 2025 11:06:27 +0200
Subject: [PATCH 0282/1764] ML: Fix compiler warnings

---
 Common/ML/include/ML/3rdparty/GPUORTFloat16.h    | 10 +++++-----
 Common/ML/include/ML/OrtInterface.h              |  1 +
 Common/ML/src/OrtInterface.cxx                   |  4 ++--
 .../Global/GPUChainTrackingClusterizer.cxx       |  4 ++--
 .../TPCClusterFinder/GPUTPCNNClusterizerHost.cxx | 16 +++++++++-------
 .../GPUTPCNNClusterizerKernels.cxx               |  6 +++---
 6 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/Common/ML/include/ML/3rdparty/GPUORTFloat16.h b/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
index 9516ba5dad573..3bf2f465b2a35 100644
--- a/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
+++ b/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
@@ -535,9 +535,9 @@ GPUdi() uint16_t BFloat16Impl<Derived>::ToUint16Impl(float v) noexcept
     result = kPositiveQNaNBits;
   } else {
     auto get_msb_half = [](float fl) {
-      uint16_t result;
+      uint16_t res;
 #ifdef GPUCA_GPUCODE
-      o2::gpu::CAMath::memcpy(&result, reinterpret_cast<char*>(&fl) + sizeof(uint16_t), sizeof(uint16_t));
+      o2::gpu::CAMath::memcpy(&res, reinterpret_cast<char*>(&fl) + sizeof(uint16_t), sizeof(uint16_t));
 #else
 #ifdef __cpp_if_constexpr
       if constexpr (detail::endian::native == detail::endian::little)
@@ -545,12 +545,12 @@ GPUdi() uint16_t BFloat16Impl<Derived>::ToUint16Impl(float v) noexcept
       if (detail::endian::native == detail::endian::little)
 #endif
       {
-        std::memcpy(&result, reinterpret_cast<char*>(&fl) + sizeof(uint16_t), sizeof(uint16_t));
+        std::memcpy(&res, reinterpret_cast<char*>(&fl) + sizeof(uint16_t), sizeof(uint16_t));
       } else {
-        std::memcpy(&result, &fl, sizeof(uint16_t));
+        std::memcpy(&res, &fl, sizeof(uint16_t));
       }
 #endif
-      return result;
+      return res;
     };
 
     uint16_t upper_bits = get_msb_half(v);
diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index e37b6a69b6036..791f6813c2d24 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -22,6 +22,7 @@
 #include <memory>
 #include <map>
 #include <thread>
+#include <unordered_map>
 
 // O2 includes
 #include "Framework/Logger.h"
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index 24a2fbffb252c..a8a20b11f9e64 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -19,6 +19,8 @@
 // ONNX includes
 #include <onnxruntime_cxx_api.h>
 
+#include <sstream>
+
 namespace o2
 {
 
@@ -139,7 +141,6 @@ void OrtModel::initSession()
 
 void OrtModel::memoryOnDevice(int32_t deviceIndex)
 {
-#if (defined(ORT_ROCM_BUILD) || defined(ORT_MIGRAPHX_BUILD) || defined(ORT_CUDA_BUILD) || defined(ORT_TENSORRT_BUILD))
   if (deviceIndex >= 0) {
     (pImplOrt->runOptions).AddConfigEntry("disable_synchronize_execution_providers", "1");
     (pImplOrt->sessionOptions).AddConfigEntry("session.use_device_allocator_for_initializers", "1"); // See kOrtSessionOptionsUseDeviceAllocatorForInitializers, https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/onnxruntime_session_options_config_keys.h
@@ -161,7 +162,6 @@ void OrtModel::memoryOnDevice(int32_t deviceIndex)
       LOG(info) << "(ORT) Memory info set to on-device memory for device type " << deviceType << " with ID " << deviceIndex << " and pImplOrt pointer " << pImplOrt;
     }
   }
-#endif
 }
 
 void OrtModel::resetSession()
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 981d565852d28..37c12b2a3b3f4 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -980,12 +980,12 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 4, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
           }
 
-          float time_clusterizer = 0, time_fill = 0, time_networks = 0;
+          // float time_clusterizer = 0, time_fill = 0, time_networks = 0;
           for (int batch = 0; batch < std::ceil((float)clusterer.mPmemory->counters.nClusters / clustererNNShadow.nnClusterizerBatchedMode); batch++) {
             uint batchStart = batch * clustererNNShadow.nnClusterizerBatchedMode;
             size_t iSize = CAMath::Min((uint)clustererNNShadow.nnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
 
-            auto start0 = std::chrono::high_resolution_clock::now();
+            // auto start0 = std::chrono::high_resolution_clock::now();
             runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNSingleElement>({GetGrid(iSize * clustererNNShadow.nnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceInputDType, withMC, batchStart); // Filling the data
 
             // auto stop0 = std::chrono::high_resolution_clock::now();
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index db2f05711f537..31b71fd8f1ebe 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -29,7 +29,7 @@ using namespace o2::gpu;
 void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& settings)
 {
   std::string class_model_path = settings.nnClassificationPath, reg_model_path = settings.nnRegressionPath;
-  std::vector<std::string> reg_model_paths;
+  std::vector<std::string> reg_model_paths_local;
   std::vector<std::string> evalMode = o2::utils::Str::tokenize(settings.nnEvalMode, ':');
 
   if (settings.nnLoadFromCCDB) {
@@ -60,20 +60,20 @@ void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& set
   model_class.initOptions(OrtOptions);
   modelsUsed[0] = true;
 
-  reg_model_paths = o2::utils::Str::tokenize(reg_model_path, ':');
+  reg_model_paths_local = o2::utils::Str::tokenize(reg_model_path, ':');
 
   if (!settings.nnClusterizerUseCfRegression) {
-    if (reg_model_paths.size() == 1) {
-      OrtOptions["model-path"] = reg_model_paths[0];
+    if (reg_model_paths_local.size() == 1) {
+      OrtOptions["model-path"] = reg_model_paths_local[0];
       OrtOptions["onnx-environment-name"] = "r1";
       model_reg_1.initOptions(OrtOptions);
       modelsUsed[1] = true;
     } else {
-      OrtOptions["model-path"] = reg_model_paths[0];
+      OrtOptions["model-path"] = reg_model_paths_local[0];
       OrtOptions["onnx-environment-name"] = "r1";
       model_reg_1.initOptions(OrtOptions);
       modelsUsed[1] = true;
-      OrtOptions["model-path"] = reg_model_paths[1];
+      OrtOptions["model-path"] = reg_model_paths_local[1];
       OrtOptions["onnx-environment-name"] = "r2";
       model_reg_2.initOptions(OrtOptions);
       modelsUsed[2] = true;
@@ -154,6 +154,7 @@ MockedOrtAllocator::MockedOrtAllocator(GPUReconstruction* r, OrtMemoryInfo* info
 MockedOrtAllocator::~MockedOrtAllocator()
 {
   // Ort::GetApi().ReleaseMemoryInfo(memory_info);
+  (void)0; // Suppress warning for empty destructor
 }
 
 void* MockedOrtAllocator::Alloc(size_t size)
@@ -191,8 +192,9 @@ size_t MockedOrtAllocator::NumReserveAllocations() const
 
 void MockedOrtAllocator::LeakCheck()
 {
-  if (memory_inuse.load())
+  if (memory_inuse.load()) {
     LOG(warning) << "memory leak!!!";
+  }
 }
 
 void GPUTPCNNClusterizerHost::volatileOrtAllocator(Ort::Env* env, Ort::MemoryInfo* memInfo, GPUReconstruction* rec, bool recreate)
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 512bc1d3bb09b..413293502d3c6 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -124,7 +124,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   CfChargePos peak = clusterer.mPfilteredPeakPositions[base_idx + batchStart];
   int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad());
 
-  if (clustererNN.nnClusterizerAddIndexData && transient_index == (clustererNN.nnClusterizerElementSize - 1)) {
+  if (clustererNN.nnClusterizerAddIndexData && (int32_t)transient_index == (clustererNN.nnClusterizerElementSize - 1)) {
     uint top_idx = (base_idx + 1) * clustererNN.nnClusterizerElementSize;
     for (uint16_t i = 0; i < 8; i++) {
       Delta2 d = cfconsts::InnerNeighbors[i];
@@ -141,7 +141,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
       clustererNN.inputData_32[top_idx - 2] = row / 152.f;
       clustererNN.inputData_32[top_idx - 1] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
     }
-  } else if (transient_index < (clustererNN.nnClusterizerElementSize - 3)) {
+  } else if ((int32_t)transient_index < (clustererNN.nnClusterizerElementSize - 3)) {
     int time = static_cast<int>(peak.time());
     int r = CAMath::Floor(transient_index / ((2 * clustererNN.nnClusterizerSizeInputPad + 1) * (2 * clustererNN.nnClusterizerSizeInputTime + 1))) - clustererNN.nnClusterizerSizeInputRow;
     bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
@@ -197,7 +197,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::det
   uint elem_iterator = glo_idx * clustererNN.nnClusterizerModelClassNumOutputNodes;
   float current_max_prob = 0.f; // If the neural network doesn't contain the softmax as a last layer, the outputs can range in [-infty, infty]
   uint class_label = 0;
-  for (int pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.nnClusterizerModelClassNumOutputNodes; pIdx++) {
+  for (uint pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.nnClusterizerModelClassNumOutputNodes; pIdx++) {
     if (pIdx == elem_iterator) {
       if (dtype == 0) {
         current_max_prob = static_cast<float>(clustererNN.modelProbabilities_16[pIdx]);

From 427e840295ead75ab7256b6c85fa1ed2cb4f0ec0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Apr 2025 11:06:40 +0200
Subject: [PATCH 0283/1764] GPU Standalone: support build with ONNXRuntime

---
 Common/ML/CMakeLists.txt                      |   2 +-
 Common/ML/include/ML/OrtInterface.h           |   2 +-
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  12 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  11 +-
 GPU/GPUTracking/CMakeLists.txt                |  10 +-
 GPU/GPUTracking/Standalone/CMakeLists.txt     |  23 +-
 GPU/GPUTracking/Standalone/cmake/config.cmake |   1 +
 GPU/GPUTracking/Standalone/cmake/prepare.sh   |   2 +-
 GPU/GPUTracking/cmake/kernel_helpers.cmake    |   2 -
 GPU/GPUTracking/kernels.cmake                 | 214 +++++++++---------
 10 files changed, 151 insertions(+), 128 deletions(-)

diff --git a/Common/ML/CMakeLists.txt b/Common/ML/CMakeLists.txt
index a5b336bf7e820..0ed52e1a23e20 100644
--- a/Common/ML/CMakeLists.txt
+++ b/Common/ML/CMakeLists.txt
@@ -12,7 +12,7 @@
 o2_add_library(ML
                SOURCES src/OrtInterface.cxx
                TARGETVARNAME targetName
-               PRIVATE_LINK_LIBRARIES O2::Framework onnxruntime::onnxruntime)
+               PRIVATE_LINK_LIBRARIES O2::GPUCommon onnxruntime::onnxruntime)
 
 # Pass ORT variables as a preprocessor definition
 target_compile_definitions(${targetName} PRIVATE
diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index 791f6813c2d24..ea70e28c0421c 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -25,7 +25,7 @@
 #include <unordered_map>
 
 // O2 includes
-#include "Framework/Logger.h"
+#include "GPUCommonLogger.h"
 
 namespace Ort
 {
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 8dd430d00a5c0..36162bcaa2f13 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -121,12 +121,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       ${CMAKE_SOURCE_DIR}/DataFormats/Reconstruction/src
       ${CMAKE_CURRENT_SOURCE_DIR}
     TARGETVARNAME targetName)
-
-  target_compile_definitions(${targetName} PRIVATE
-    GPUCA_HAS_ONNX=1
-    $<$<BOOL:${ORT_CUDA_BUILD}>:ORT_CUDA_BUILD>
-    $<$<BOOL:${ORT_TENSORRT_BUILD}>:ORT_TENSORRT_BUILD>)
-
   install(FILES ${HDRS} DESTINATION include/GPU)
 endif()
 
@@ -141,6 +135,12 @@ endif()
 
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
+if (onnxruntime_FOUND)
+  target_compile_definitions(${targetName} PRIVATE
+                                           $<$<BOOL:${ORT_CUDA_BUILD}>:ORT_CUDA_BUILD>
+                                           $<$<BOOL:${ORT_TENSORRT_BUILD}>:ORT_TENSORRT_BUILD>)
+endif()
+
 # Setting target architecture and adding GPU libraries
 target_link_libraries(${targetName} PRIVATE cuda cudart nvrtc)
 set_target_cuda_arch(${targetName})
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 315a6c2fa3080..9398ffdd5b9f1 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -170,11 +170,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       ${GPUCA_HIP_SOURCE_DIR}
     TARGETVARNAME targetName)
 
-  target_compile_definitions(${targetName} PRIVATE
-    GPUCA_HAS_ONNX=1
-    $<$<BOOL:${ORT_ROCM_BUILD}>:ORT_ROCM_BUILD>
-    $<$<BOOL:${ORT_MIGRAPHX_BUILD}>:ORT_MIGRAPHX_BUILD>)
-
   install(FILES ${HDRS} DESTINATION include/GPU)
 
 #  o2_add_test(GPUsortHIP NAME test_GPUsortHIP
@@ -195,6 +190,12 @@ endif()
 
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
+if (onnxruntime_FOUND)
+  target_compile_definitions(${targetName} PRIVATE
+                                           $<$<BOOL:${ORT_ROCM_BUILD}>:ORT_ROCM_BUILD>
+                                           $<$<BOOL:${ORT_MIGRAPHX_BUILD}>:ORT_MIGRAPHX_BUILD>)
+endif()
+
 add_library(${MODULE}_CXX OBJECT ${SRCS_CXX}) # Adding a C++ library for the .cxx code of the HIP library, such that it does not link to HIP libraries, and CMake HIP Language doesn't add HIP compile flags.
 target_compile_definitions(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 target_include_directories(${MODULE}_CXX PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,INCLUDE_DIRECTORIES>)
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index c0648b3274108..4c1de17025627 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -200,7 +200,7 @@ set(SRCS_NO_CINT ${SRCS_NO_CINT}
     Refit/GPUTrackingRefitKernel.cxx
     Merger/GPUTPCGMO2Output.cxx)
 
-if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
+if(onnxruntime_FOUND)
   list(APPEND SRCS_NO_CINT TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx TPCClusterFinder/GPUTPCNNClusterizer.cxx TPCClusterFinder/GPUTPCNNClusterizerHost.cxx)
 endif()
 
@@ -343,7 +343,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                                        O2::DetectorsRaw
                                        O2::Steer
                                        O2::ML
-                 PRIVATE_LINK_LIBRARIES onnxruntime::onnxruntime
                  PUBLIC_INCLUDE_DIRECTORIES ${INCDIRS}
                  SOURCES ${SRCS} ${SRCS_NO_CINT} ${SRCS_NO_H})
 
@@ -351,7 +350,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${targetName}
     PRIVATE $<TARGET_PROPERTY:O2::Framework,INTERFACE_INCLUDE_DIRECTORIES>)
 
-  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2 GPUCA_HAS_ONNX=1)
+  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2)
 
   o2_target_root_dictionary(${MODULE}
                             HEADERS ${HDRS_CINT_O2} ${HDRS_CINT_O2_ADDITIONAL}
@@ -421,6 +420,11 @@ target_link_libraries(${targetName} PRIVATE TBB::tbb)
 
 target_compile_options(${targetName} PRIVATE -Wno-instantiation-after-specialization)
 
+if (onnxruntime_FOUND)
+  target_compile_definitions(${targetName} PRIVATE GPUCA_HAS_ONNX=1)
+  target_link_libraries(${targetName} PRIVATE onnxruntime::onnxruntime)
+endif()
+
 # Add CMake recipes for GPU Tracking librararies
 if(CUDA_ENABLED OR OPENCL_ENABLED OR HIP_ENABLED)
   if(CMAKE_SYSTEM_NAME MATCHES Darwin)
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index fbc256d5d7f91..a17c58ad1ba03 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -121,11 +121,25 @@ else()
 endif()
 
 # Detect GPU Backends
-find_package(O2GPU)
+find_package(O2GPU REQUIRED)
+
+if(GPUCA_CONFIG_ONNX)
+  find_package(onnxruntime REQUIRED)
+  if(CUDA_ENABLED AND NOT DEFINED ORT_CUDA_BUILD)
+    set(ORT_CUDA_BUILD ON)
+  elseif(HIP_ENABLED AND NOT DEFINED ORT_ROCM_BUILD)
+    set(ORT_ROCM_BUILD ON)
+  endif()
+else()
+  set(onnxruntime_FOUND OFF)
+endif()
 
 # Create main targets
 add_subdirectory(../../ GPU)
-add_library(standalone_support SHARED ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
+add_library(standalone_support SHARED
+            ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
+            ${O2_DIR}/Common/ML/src/OrtInterface.cxx
+            ${O2_DIR}/Common/Utils/src/StringUtils.cxx
             ${O2_DIR}/DataFormats/Detectors/TPC/src/CompressedClusters.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
@@ -150,6 +164,7 @@ target_include_directories(standalone_support PUBLIC
                            ${O2_DIR}/Common/Constants/include
                            ${O2_DIR}/Common/MathUtils/include
                            ${O2_DIR}/Common/Utils/include
+                           ${O2_DIR}/Common/ML/include
                            ${O2_DIR}/DataFormats/common/include
                            ${O2_DIR}/DataFormats/Detectors/Common/include
                            ${O2_DIR}/DataFormats/Detectors/ITSMFT/common/include
@@ -210,6 +225,10 @@ if(GPUCA_CONFIG_ROOT)
                         ROOT::Tree)
 endif()
 
+if(GPUCA_CONFIG_ONNX)
+  target_link_libraries(standalone_support PRIVATE onnxruntime::onnxruntime)
+endif()
+
 if (GPUCA_BUILD_DEBUG_SANITIZE AND CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
   execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=libclang_rt.asan-x86_64.so OUTPUT_VARIABLE CLANG_ASAN_SO_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
   get_filename_component(CLANG_ASAN_SO_PATH "${CLANG_ASAN_SO_PATH}" DIRECTORY)
diff --git a/GPU/GPUTracking/Standalone/cmake/config.cmake b/GPU/GPUTracking/Standalone/cmake/config.cmake
index af7c96bb96fbb..1de0cfa27d7ee 100644
--- a/GPU/GPUTracking/Standalone/cmake/config.cmake
+++ b/GPU/GPUTracking/Standalone/cmake/config.cmake
@@ -18,6 +18,7 @@ set(ENABLE_OPENCL AUTO)
 set(GPUCA_CONFIG_VC 1)
 set(GPUCA_CONFIG_FMT 1)
 set(GPUCA_CONFIG_ROOT 1)
+set(GPUCA_CONFIG_ONNX 0)
 set(GPUCA_BUILD_EVENT_DISPLAY 1)
 set(GPUCA_BUILD_EVENT_DISPLAY_FREETYPE 1)
 set(GPUCA_BUILD_EVENT_DISPLAY_VULKAN 1)
diff --git a/GPU/GPUTracking/Standalone/cmake/prepare.sh b/GPU/GPUTracking/Standalone/cmake/prepare.sh
index 17474b5fc6956..121245e23dc65 100755
--- a/GPU/GPUTracking/Standalone/cmake/prepare.sh
+++ b/GPU/GPUTracking/Standalone/cmake/prepare.sh
@@ -11,6 +11,6 @@ else
 fi
 eval "`alienv shell-helper`"
 # alienv load O2/latest
-for i in Vc boost fmt CMake ms_gsl Clang ninja TBB ROOT; do
+for i in Vc boost fmt CMake ms_gsl Clang ninja TBB ROOT ONNXRuntime; do
   source sw/$ALIARCH/$i/latest/etc/profile.d/init.sh
 done
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index 35f2915d9486a..e36cb4e2f3149 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -174,7 +174,6 @@ function(o2_gpu_kernel_add_parameter)
   list(LENGTH ARGV n)
   math(EXPR n "${n} - 1")
   foreach(i RANGE 0 ${n})
-    message(STATUS "Adding ${ARGV${i}}")
     set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_PARAMS "${ARGV${i}}")
   endforeach()
 endfunction()
@@ -182,7 +181,6 @@ function(o2_gpu_kernel_add_string_parameter)
   list(LENGTH ARGV n)
   math(EXPR n "${n} - 1")
   foreach(i RANGE 0 ${n})
-    message(STATUS "Adding ${ARGV${i}}")
     set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_STRING_PARAMS "${ARGV${i}}")
   endforeach()
 endfunction()
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 202ea47d1f3bf..937a92fef33df 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -24,117 +24,117 @@ o2_gpu_kernel_file_list(O2PROPAGATOR TrackParametrization.cxx TrackParametrizati
 o2_gpu_kernel_file_list(TPCCOMPRESSION GPUTPCCompressionTrackModel.cxx)
 o2_gpu_kernel_file_list(TPCDECOMPRESSION GPUTPCCompressionTrackModel.cxx ERRORS)
 o2_gpu_kernel_file_list(TPCCLUSTERFINDER ERRORS ClusterAccumulator.cxx)
-if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
-o2_gpu_kernel_file_list(TPCNNCLUSTERFINDER ERRORS ClusterAccumulator.cxx GPUTPCNNClusterizerKernels.cxx)
-endif()
 o2_gpu_kernel_file_list(TRDTRACKER GPUTRDTrack.cxx GPUTRDTracker.cxx GPUTRDTrackletWord.cxx GeometryBase.cxx)
 o2_gpu_kernel_file_list(GLOBALREFIT TPCMERGER O2PROPAGATOR MATLUT GPUTrackingRefit.cxx)
+if(onnxruntime_FOUND)
+o2_gpu_kernel_file_list(TPCNNCLUSTERFINDER ERRORS ClusterAccumulator.cxx GPUTPCNNClusterizerKernels.cxx)
+endif()
 
-o2_gpu_add_kernel("GPUTPCNeighboursFinder"                            "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUTPCNeighboursCleaner"                           "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUTPCStartHitsFinder"                             "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUTPCStartHitsSorter"                             "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUTPCTrackletConstructor"                         "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUTPCTrackletSelector"                            "= TPCTRACKER"                                          LB)
-o2_gpu_add_kernel("GPUMemClean16"                                     "GPUGeneralKernels"                                     NO void* ptr "uint64_t" size)
-o2_gpu_add_kernel("GPUitoa"                                           "GPUGeneralKernels"                                     NO int32_t* ptr "uint64_t" size)
-o2_gpu_add_kernel("GPUTPCExtrapolationTrackingCopyNumbers"            "GPUTPCExtrapolationTracking TPCTRACKER"                NO int32_t n)
-o2_gpu_add_kernel("GPUTPCExtrapolationTracking"                       "= TPCTRACKER TPCTRACKLETCONS"                          LB)
-o2_gpu_add_kernel("GPUTPCCreateTrackingData"                          "= TPCTRACKER TPCSECTORDATA"                            LB)
-o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, hitData"             "= TPCTRACKER")
-o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, startHits"           "= TPCTRACKER")
-o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, sectorTracks"        "= TPCTRACKER")
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, clearIds"            "= TPCMERGER"                                           NO int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, sectorTracks"        "= TPCMERGER"                                           NO int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks1" "= TPCMERGER"                                           NO int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks2" "= TPCMERGER"                                           NO int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, borderTracks"        "= TPCMERGER"                                           NO int8_t parameter)
-o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fill"                    "= TPCOCCUPANCY"                                        LB GPUTPCClusterOccupancyMapBin* map)
-o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fold"                    "= TPCOCCUPANCY"                                        LB GPUTPCClusterOccupancyMapBin* map "uint32_t*" output)
-o2_gpu_add_kernel("GPUTPCGMMergerTrackFit"                            "GPUTPCGMMergerGPU TPCMERGER TPCTRACKER MATLUT TPCDEDX" LB int32_t mode)
-o2_gpu_add_kernel("GPUTPCGMMergerFollowLoopers"                       "GPUTPCGMMergerGPU TPCMERGER TPCTRACKER MATLUT"         LB)
-o2_gpu_add_kernel("GPUTPCGMMergerUnpackResetIds"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector)
-o2_gpu_add_kernel("GPUTPCGMMergerSectorRefit"                         "GPUTPCGMMergerGPU TPCMERGER MATLUT"                    LB int32_t iSector)
-o2_gpu_add_kernel("GPUTPCGMMergerUnpackGlobal"                        "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector)
-o2_gpu_add_kernel("GPUTPCGMMergerUnpackSaveNumber"                    "GPUTPCGMMergerGPU TPCMERGER"                           NO int32_t id)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step0"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step1"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step2"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step3"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerResolve, step4"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB int8_t useOrigTrackParam int8_t mergeAll)
-o2_gpu_add_kernel("GPUTPCGMMergerClearLinks"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB int8_t output)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeWithinPrepare"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeSectorsPrepare"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t border0 int32_t border1 int8_t useOrigTrackParam)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step0"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector int8_t withinSector int8_t mergeMode)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step1"                 "GPUTPCGMMergerGPU TPCMERGER"                           NO int32_t iSector int8_t withinSector int8_t mergeMode)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step2"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector int8_t withinSector int8_t mergeMode)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, variant"               "GPUTPCGMMergerGPU TPCMERGER"                           NO gputpcgmmergertypes::GPUTPCGMBorderRange* range int32_t N int32_t cmpMax)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeCE"                             "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerLinkExtrapolatedTracks"              "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerCollect"                             "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerSortTracks"                          "GPUTPCGMMergerGPU TPCMERGER")
-o2_gpu_add_kernel("GPUTPCGMMergerSortTracksQPt"                       "GPUTPCGMMergerGPU TPCMERGER")
-o2_gpu_add_kernel("GPUTPCGMMergerSortTracksPrepare"                   "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step0"              "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step1"              "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step2"              "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step0"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step1"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step2"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step0"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step1"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step2"                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMO2Output, prepare"                         "= TPCMERGER"                                           LB)
-o2_gpu_add_kernel("GPUTPCGMO2Output, sort"                            "= TPCMERGER")
-o2_gpu_add_kernel("GPUTPCGMO2Output, output"                          "= TPCMERGER"                                           LB)
-o2_gpu_add_kernel("GPUTPCGMO2Output, mc"                              "= TPCMERGER")
-o2_gpu_add_kernel("GPUTRDTrackerKernels, gpuVersion"                  "= TRDTRACKER MATLUT TPCMERGER"                         LB GPUTRDTrackerGPU* externalInstance)
-o2_gpu_add_kernel("GPUTRDTrackerKernels, o2Version"                   "= TRDTRACKER MATLUT O2PROPAGATOR"                      LB GPUTRDTracker* externalInstance)
-o2_gpu_add_kernel("GPUITSFitterKernels"                               "= TPCMERGER MATLUT"                                    LB)
-o2_gpu_add_kernel("GPUTPCConvertKernel"                               "="                                                     LB)
-o2_gpu_add_kernel("GPUTPCCompressionKernels, step0attached"           "= TPCCOMPRESSION"                                      LB)
-o2_gpu_add_kernel("GPUTPCCompressionKernels, step1unattached"         "= ERRORS"                                              LB)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, unbuffered"        "GPUTPCCompressionKernels"                              LB)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered32"        "GPUTPCCompressionKernels"                              LB)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered64"        "GPUTPCCompressionKernels"                              LB)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered128"       "GPUTPCCompressionKernels"                              LB)
-o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, multiBlock"        "GPUTPCCompressionKernels"                              LB)
-o2_gpu_add_kernel("GPUTPCDecompressionKernels, step0attached"         "= TPCDECOMPRESSION"                                    LB int32_t trackStart int32_t trackEnd)
-o2_gpu_add_kernel("GPUTPCDecompressionKernels, step1unattached"       "= TPCDECOMPRESSION"                                    LB int32_t sectorStart int32_t nSectors)
-o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, sortPerSectorRow"  "GPUTPCDecompressionKernels"                            LB)
-o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, countFilteredClusters"  "GPUTPCDecompressionKernels"                       LB)
-o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, storeFilteredClusters"  "GPUTPCDecompressionKernels"                       LB)
-o2_gpu_add_kernel("GPUTPCCFCheckPadBaseline"                          "= TPCCLUSTERFINDER"                                    LB)
-o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, fillIndexMap"             "= TPCCLUSTERFINDER"                                    LB)
-o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, fillFromDigits"           "= TPCCLUSTERFINDER"                                    LB)
-o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, findFragmentStart"        "= TPCCLUSTERFINDER"                                    LB int8_t setPositions)
-o2_gpu_add_kernel("GPUTPCCFPeakFinder"                                "= TPCCLUSTERFINDER"                                    LB)
-o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, noiseSuppression"        "= TPCCLUSTERFINDER"                                    LB)
-o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, updatePeaks"             "= TPCCLUSTERFINDER"                                    LB)
-o2_gpu_add_kernel("GPUTPCCFDeconvolution"                             "= TPCCLUSTERFINDER"                                    LB)
-o2_gpu_add_kernel("GPUTPCCFClusterizer"                               "= TPCCLUSTERFINDER"                                    LB int8_t onlyMC)
-if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, runCfClusterizer"        "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNN"             "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNNSingleElement"             "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass1Labels"   "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass2Labels"   "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass1Regression" "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass2Regression" "= TPCNNCLUSTERFINDER"                                LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNeighboursFinder"                                "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCNeighboursCleaner"                               "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCStartHitsFinder"                                 "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCStartHitsSorter"                                 "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCTrackletConstructor"                             "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUTPCTrackletSelector"                                "= TPCTRACKER"                                          LB)
+o2_gpu_add_kernel("GPUMemClean16"                                         "GPUGeneralKernels"                                     NO void* ptr uint64_t size)
+o2_gpu_add_kernel("GPUitoa"                                               "GPUGeneralKernels"                                     NO int32_t* ptr uint64_t size)
+o2_gpu_add_kernel("GPUTPCExtrapolationTrackingCopyNumbers"                "GPUTPCExtrapolationTracking TPCTRACKER"                NO int32_t n)
+o2_gpu_add_kernel("GPUTPCExtrapolationTracking"                           "= TPCTRACKER TPCTRACKLETCONS"                          LB)
+o2_gpu_add_kernel("GPUTPCCreateTrackingData"                              "= TPCTRACKER TPCSECTORDATA"                            LB)
+o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, hitData"                 "= TPCTRACKER")
+o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, startHits"               "= TPCTRACKER")
+o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, sectorTracks"            "= TPCTRACKER")
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, clearIds"                "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, sectorTracks"            "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks1"     "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks2"     "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, borderTracks"            "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fill"                        "= TPCOCCUPANCY"                                        LB GPUTPCClusterOccupancyMapBin* map)
+o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fold"                        "= TPCOCCUPANCY"                                        LB GPUTPCClusterOccupancyMapBin* map uint32_t* output)
+o2_gpu_add_kernel("GPUTPCGMMergerTrackFit"                                "GPUTPCGMMergerGPU TPCMERGER TPCTRACKER MATLUT TPCDEDX" LB int32_t mode)
+o2_gpu_add_kernel("GPUTPCGMMergerFollowLoopers"                           "GPUTPCGMMergerGPU TPCMERGER TPCTRACKER MATLUT"         LB)
+o2_gpu_add_kernel("GPUTPCGMMergerUnpackResetIds"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector)
+o2_gpu_add_kernel("GPUTPCGMMergerSectorRefit"                             "GPUTPCGMMergerGPU TPCMERGER MATLUT"                    LB int32_t iSector)
+o2_gpu_add_kernel("GPUTPCGMMergerUnpackGlobal"                            "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector)
+o2_gpu_add_kernel("GPUTPCGMMergerUnpackSaveNumber"                        "GPUTPCGMMergerGPU TPCMERGER"                           NO int32_t id)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step0"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step1"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step2"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step3"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerResolve, step4"                          "GPUTPCGMMergerGPU TPCMERGER"                           LB int8_t useOrigTrackParam int8_t mergeAll)
+o2_gpu_add_kernel("GPUTPCGMMergerClearLinks"                              "GPUTPCGMMergerGPU TPCMERGER"                           LB int8_t output)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeWithinPrepare"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeSectorsPrepare"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t border0 int32_t border1 int8_t useOrigTrackParam)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step0"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector int8_t withinSector int8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step1"                     "GPUTPCGMMergerGPU TPCMERGER"                           NO int32_t iSector int8_t withinSector int8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step2"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector int8_t withinSector int8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, variant"                   "GPUTPCGMMergerGPU TPCMERGER"                           NO gputpcgmmergertypes::GPUTPCGMBorderRange* range int32_t N int32_t cmpMax)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeCE"                                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerLinkExtrapolatedTracks"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerCollect"                                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerSortTracks"                              "GPUTPCGMMergerGPU TPCMERGER")
+o2_gpu_add_kernel("GPUTPCGMMergerSortTracksQPt"                           "GPUTPCGMMergerGPU TPCMERGER")
+o2_gpu_add_kernel("GPUTPCGMMergerSortTracksPrepare"                       "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step0"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step1"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step2"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step0"                         "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step1"                         "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step2"                         "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step0"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step1"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeLoopers, step2"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMO2Output, prepare"                             "= TPCMERGER"                                           LB)
+o2_gpu_add_kernel("GPUTPCGMO2Output, sort"                                "= TPCMERGER")
+o2_gpu_add_kernel("GPUTPCGMO2Output, output"                              "= TPCMERGER"                                           LB)
+o2_gpu_add_kernel("GPUTPCGMO2Output, mc"                                  "= TPCMERGER")
+o2_gpu_add_kernel("GPUTRDTrackerKernels, gpuVersion"                      "= TRDTRACKER MATLUT TPCMERGER"                         LB GPUTRDTrackerGPU* externalInstance)
+o2_gpu_add_kernel("GPUTRDTrackerKernels, o2Version"                       "= TRDTRACKER MATLUT O2PROPAGATOR"                      LB GPUTRDTracker* externalInstance)
+o2_gpu_add_kernel("GPUITSFitterKernels"                                   "= TPCMERGER MATLUT"                                    LB)
+o2_gpu_add_kernel("GPUTPCConvertKernel"                                   "="                                                     LB)
+o2_gpu_add_kernel("GPUTPCCompressionKernels, step0attached"               "= TPCCOMPRESSION"                                      LB)
+o2_gpu_add_kernel("GPUTPCCompressionKernels, step1unattached"             "= ERRORS"                                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, unbuffered"            "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered32"            "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered64"            "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, buffered128"           "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, multiBlock"            "GPUTPCCompressionKernels"                              LB)
+o2_gpu_add_kernel("GPUTPCDecompressionKernels, step0attached"             "= TPCDECOMPRESSION"                                    LB int32_t trackStart int32_t trackEnd)
+o2_gpu_add_kernel("GPUTPCDecompressionKernels, step1unattached"           "= TPCDECOMPRESSION"                                    LB int32_t sectorStart int32_t nSectors)
+o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, sortPerSectorRow"      "GPUTPCDecompressionKernels"                            LB)
+o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, countFilteredClusters" "GPUTPCDecompressionKernels"                            LB)
+o2_gpu_add_kernel("GPUTPCDecompressionUtilKernels, storeFilteredClusters" "GPUTPCDecompressionKernels"                            LB)
+o2_gpu_add_kernel("GPUTPCCFCheckPadBaseline"                              "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, fillIndexMap"                 "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, fillFromDigits"               "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, findFragmentStart"            "= TPCCLUSTERFINDER"                                    LB int8_t setPositions)
+o2_gpu_add_kernel("GPUTPCCFPeakFinder"                                    "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, noiseSuppression"            "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, updatePeaks"                 "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFDeconvolution"                                 "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFClusterizer"                                   "= TPCCLUSTERFINDER"                                    LB int8_t onlyMC)
+o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, setRowOffsets"               "= TPCCLUSTERFINDER")
+o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, flatten"                     "= TPCCLUSTERFINDER"                                    NO GPUTPCLinearLabels* out)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanStart"                   "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanUp"                      "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanTop"                     "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                    "= TPCCLUSTERFINDER"                                    LB int32_t iBuf uint32_t offset int32_t nElems)
+o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"               "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage CfChargePos* in CfChargePos* out)
+o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                      "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                                  "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFGather"                                        "="                                                     LB o2::tpc::ClusterNative* dest)
+o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                    "= GLOBALREFIT "                                        LB)
+o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"            "= GLOBALREFIT "                                        LB)
+if(onnxruntime_FOUND)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, runCfClusterizer"          "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNN"               "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNNSingleElement"  "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass1Labels"     "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass2Labels"     "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass1Regression"   "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass2Regression"   "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
 endif()
-o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, setRowOffsets" "= TPCCLUSTERFINDER")
-o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, flatten"                 "= TPCCLUSTERFINDER"                                    NO GPUTPCLinearLabels* out)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanStart"               "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanUp"                  "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanTop"                 "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                "= TPCCLUSTERFINDER"                                    LB int32_t iBuf "uint32_t" offset int32_t nElems)
-o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"           "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage CfChargePos* in CfChargePos* out)
-o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                  "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                              "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                         "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFGather"                                    "="                                                     LB o2::tpc::ClusterNative* dest)
-o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                "= GLOBALREFIT "                                        LB)
-o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"        "= GLOBALREFIT "                                        LB)
 
 o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP
                             NEIGHBOURS_FINDER_UNROLL_GLOBAL

From e9b2d160946a3e929f6309c4af97171dd9cf0617 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Apr 2025 18:34:36 +0200
Subject: [PATCH 0284/1764] CUDA ORT: Must use api struct to call functions

---
 .../Base/cuda/GPUReconstructionCUDA.cu         | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index d5b01bfa34833..d4f9faaf203c9 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -621,24 +621,34 @@ void GPUReconstructionCUDA::loadKernelModules(bool perKernel)
   }
 }
 
+#define ORTCHK(command)                               \
+  {                                                   \
+    OrtStatus* status = command;                      \
+    if (status != nullptr) {                          \
+      const char* msg = api->GetErrorMessage(status); \
+      GPUFatal("ONNXRuntime Error: %s", msg);         \
+    }                                                 \
+  }
+
 void GPUReconstructionCUDA::SetONNXGPUStream(Ort::SessionOptions& session_options, int32_t stream, int32_t* deviceId)
 {
   GPUChkErr(cudaGetDevice(deviceId));
 #if !defined(__HIPCC__) && defined(ORT_CUDA_BUILD)
+  const OrtApi* api = OrtGetApiBase()->GetApi(ORT_API_VERSION);
   OrtCUDAProviderOptionsV2* cuda_options = nullptr;
-  CreateCUDAProviderOptions(&cuda_options);
+  ORTCHK(api->CreateCUDAProviderOptions(&cuda_options));
 
   // std::vector<const char*> keys{"device_id", "gpu_mem_limit", "arena_extend_strategy", "cudnn_conv_algo_search", "do_copy_in_default_stream", "cudnn_conv_use_max_workspace", "cudnn_conv1d_pad_to_nc1d"};
   // std::vector<const char*> values{"0", "2147483648", "kSameAsRequested", "DEFAULT", "1", "1", "1"};
   // UpdateCUDAProviderOptions(cuda_options, keys.data(), values.data(), keys.size());
 
   // this implicitly sets "has_user_compute_stream"
-  cuda_options.has_user_compute_stream = 1;
-  UpdateCUDAProviderOptionsWithValue(cuda_options, "user_compute_stream", mInternals->Streams[stream]);
+  cuda_options->has_user_compute_stream = 1;
+  ORTCHK(api->UpdateCUDAProviderOptionsWithValue(cuda_options, "user_compute_stream", mInternals->Streams[stream]));
   session_options.AppendExecutionProvider_CUDA_V2(cuda_options);
 
   // Finally, don't forget to release the provider options
-  ReleaseCUDAProviderOptions(cuda_options);
+  api->ReleaseCUDAProviderOptions(cuda_options);
 #elif defined(ORT_ROCM_BUILD)
   // const auto& api = Ort::GetApi();
   // api.GetCurrentGpuDeviceId(deviceId);

From 17132044b680bcbfe5d979fcc0f107b3d5ccdc2e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Apr 2025 22:35:20 +0200
Subject: [PATCH 0285/1764] GPU CUDA ORT: Fix usage of OrtCUDAProviderOptionsV2

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt           | 2 +-
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu | 3 +--
 GPU/GPUTracking/Base/hip/CMakeLists.txt            | 2 +-
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 36162bcaa2f13..dbdf6b606df18 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -114,7 +114,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${MODULE}
     SOURCES ${SRCS}
     PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingCUDA
-    PRIVATE_LINK_LIBRARIES onnxruntime::onnxruntime
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
@@ -139,6 +138,7 @@ if (onnxruntime_FOUND)
   target_compile_definitions(${targetName} PRIVATE
                                            $<$<BOOL:${ORT_CUDA_BUILD}>:ORT_CUDA_BUILD>
                                            $<$<BOOL:${ORT_TENSORRT_BUILD}>:ORT_TENSORRT_BUILD>)
+  target_link_libraries(${targetName} PRIVATE onnxruntime::onnxruntime)
 endif()
 
 # Setting target architecture and adding GPU libraries
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index d4f9faaf203c9..c8e5420a8bcf3 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -643,9 +643,8 @@ void GPUReconstructionCUDA::SetONNXGPUStream(Ort::SessionOptions& session_option
   // UpdateCUDAProviderOptions(cuda_options, keys.data(), values.data(), keys.size());
 
   // this implicitly sets "has_user_compute_stream"
-  cuda_options->has_user_compute_stream = 1;
   ORTCHK(api->UpdateCUDAProviderOptionsWithValue(cuda_options, "user_compute_stream", mInternals->Streams[stream]));
-  session_options.AppendExecutionProvider_CUDA_V2(cuda_options);
+  ORTCHK(api->SessionOptionsAppendExecutionProvider_CUDA_V2(session_options, cuda_options));
 
   // Finally, don't forget to release the provider options
   api->ReleaseCUDAProviderOptions(cuda_options);
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 9398ffdd5b9f1..4689fee02d31e 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -162,7 +162,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${MODULE}
     SOURCES ${SRCS}
     PUBLIC_LINK_LIBRARIES O2::GPUTracking O2::ITStrackingHIP
-    PRIVATE_LINK_LIBRARIES onnxruntime::onnxruntime
     PRIVATE_INCLUDE_DIRECTORIES
       ${CMAKE_SOURCE_DIR}/Detectors/Base/src
       ${CMAKE_SOURCE_DIR}/Detectors/TRD/base/src
@@ -194,6 +193,7 @@ if (onnxruntime_FOUND)
   target_compile_definitions(${targetName} PRIVATE
                                            $<$<BOOL:${ORT_ROCM_BUILD}>:ORT_ROCM_BUILD>
                                            $<$<BOOL:${ORT_MIGRAPHX_BUILD}>:ORT_MIGRAPHX_BUILD>)
+  target_link_libraries(${targetName} PRIVATE onnxruntime::onnxruntime)
 endif()
 
 add_library(${MODULE}_CXX OBJECT ${SRCS_CXX}) # Adding a C++ library for the .cxx code of the HIP library, such that it does not link to HIP libraries, and CMake HIP Language doesn't add HIP compile flags.

From 6a0656424b366aa04fd338ac3f27f26b40df948d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 21 Apr 2025 21:23:11 +0200
Subject: [PATCH 0286/1764] GPU: Use aligned new/delete for some host
 allocations

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx | 27 ++++++++++++++--------
 GPU/GPUTracking/Base/GPUReconstruction.h   | 10 +++++---
 2 files changed, 25 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index ab2210e5dd555..7a8d73e689b84 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -716,8 +716,13 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
     throw std::runtime_error("Requested invalid memory typo for unmanaged allocation");
   }
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
-    mUnmanagedChunks.emplace_back(new char[size + GPUCA_BUFFER_ALIGNMENT]);
-    return GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(mUnmanagedChunks.back().get());
+    char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
+    if ((type & GPUMemoryResource::MEMORY_STACK)) {
+      mNonPersistentIndividualDirectAllocations.emplace_back(retVal, alignedDeleter());
+    } else {
+      mDirectMemoryChunks.emplace_back(retVal, alignedDeleter());
+    }
+    return retVal;
   } else {
     if (mVolatileMemoryStart && !mDeviceMemoryAsVolatile && (type & GPUMemoryResource::MEMORY_GPU) && !(type & GPUMemoryResource::MEMORY_STACK)) {
       GPUError("Must not allocate direct memory while volatile chunks are allocated");
@@ -765,8 +770,9 @@ void* GPUReconstruction::AllocateVolatileMemory(size_t size, bool device)
   if (device) {
     return AllocateVolatileDeviceMemory(size);
   }
-  mVolatileChunks.emplace_back(new char[size + GPUCA_BUFFER_ALIGNMENT]);
-  return GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(mVolatileChunks.back().get());
+  char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
+  mVolatileChunks.emplace_back(retVal, alignedDeleter());
+  return retVal;
 }
 
 void GPUReconstruction::MakeFutureDeviceMemoryAllocationsVolatile()
@@ -851,7 +857,7 @@ void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)
 
 void GPUReconstruction::PushNonPersistentMemory(uint64_t tag)
 {
-  mNonPersistentMemoryStack.emplace_back(mHostMemoryPoolEnd, mDeviceMemoryPoolEnd, mNonPersistentIndividualAllocations.size(), tag);
+  mNonPersistentMemoryStack.emplace_back(mHostMemoryPoolEnd, mDeviceMemoryPoolEnd, mNonPersistentIndividualAllocations.size(), mNonPersistentIndividualDirectAllocations.size(), tag);
 }
 
 void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
@@ -862,11 +868,11 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
   if (mNonPersistentMemoryStack.size() == 0) {
     GPUFatal("Trying to pop memory state from empty stack");
   }
-  if (tag != 0 && std::get<3>(mNonPersistentMemoryStack.back()) != tag) {
-    GPUFatal("Tag mismatch when popping non persistent memory from stack : pop %s vs on stack %s", qTag2Str(tag).c_str(), qTag2Str(std::get<3>(mNonPersistentMemoryStack.back())).c_str());
+  if (tag != 0 && std::get<4>(mNonPersistentMemoryStack.back()) != tag) {
+    GPUFatal("Tag mismatch when popping non persistent memory from stack : pop %s vs on stack %s", qTag2Str(tag).c_str(), qTag2Str(std::get<4>(mNonPersistentMemoryStack.back())).c_str());
   }
   if ((GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) && (IsGPU() || GetProcessingSettings().forceHostMemoryPoolSize)) {
-    printf("Allocated memory after %30s (%8s) (Stack %zu): ", GPUDataTypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<3>(mNonPersistentMemoryStack.back())).c_str(), mNonPersistentMemoryStack.size());
+    printf("Allocated memory after %30s (%8s) (Stack %zu): ", GPUDataTypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<4>(mNonPersistentMemoryStack.back())).c_str(), mNonPersistentMemoryStack.size());
     PrintMemoryOverview();
     printf("%76s", "");
     PrintMemoryMax();
@@ -882,6 +888,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
     res->mPtrDevice = nullptr;
   }
   mNonPersistentIndividualAllocations.resize(std::get<2>(mNonPersistentMemoryStack.back()));
+  mNonPersistentIndividualDirectAllocations.resize(std::get<3>(mNonPersistentMemoryStack.back()));
   mNonPersistentMemoryStack.pop_back();
 }
 
@@ -917,9 +924,11 @@ void GPUReconstruction::ClearAllocatedMemory(bool clearOutputs)
       FreeRegisteredMemory(i);
     }
   }
-  mUnmanagedChunks.clear();
   mNonPersistentMemoryStack.clear();
   mNonPersistentIndividualAllocations.clear();
+  mDirectMemoryChunks.clear();
+  mNonPersistentIndividualDirectAllocations.clear();
+  mVolatileChunks.clear();
   mVolatileMemoryStart = nullptr;
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     mHostMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mHostMemoryPermanent);
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 396a007761fb7..f5b39cb370b9e 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -69,8 +69,6 @@ class GPUReconstruction
   class LibraryLoader; // These must be the first members to ensure correct destructor order!
   std::shared_ptr<LibraryLoader> mMyLib = nullptr;
   std::vector<GPUMemoryResource> mMemoryResources;
-  std::vector<std::unique_ptr<char[]>> mUnmanagedChunks;
-  std::vector<std::unique_ptr<char[]>> mVolatileChunks;
   std::vector<std::unique_ptr<GPUChain>> mChains;
 
  public:
@@ -373,9 +371,15 @@ class GPUReconstruction
     GPUProcessor* proc = nullptr;
     std::vector<uint16_t> res;
   };
+  struct alignedDeleter {
+    void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)); };
+  };
   std::unordered_map<GPUMemoryReuse::ID, MemoryReuseMeta> mMemoryReuse1to1;
-  std::vector<std::tuple<void*, void*, size_t, uint64_t>> mNonPersistentMemoryStack;
+  std::vector<std::tuple<void*, void*, size_t, size_t, uint64_t>> mNonPersistentMemoryStack; // hostPoolAddress, devicePoolAddress, individualAllocationCount, directIndividualAllocationCound, tag
   std::vector<GPUMemoryResource*> mNonPersistentIndividualAllocations;
+  std::vector<std::unique_ptr<char[], alignedDeleter>> mNonPersistentIndividualDirectAllocations;
+  std::vector<std::unique_ptr<char[], alignedDeleter>> mDirectMemoryChunks;
+  std::vector<std::unique_ptr<char[], alignedDeleter>> mVolatileChunks;
 
   std::unique_ptr<GPUReconstructionPipelineContext> mPipelineContext;
 

From fef77bcb601992f654c44035c593b1c60c41bbfa Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 21 Apr 2025 21:40:18 +0200
Subject: [PATCH 0287/1764] GPU: Direct memory allocation supports stacked
 memory

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx | 45 +++++++++++++---------
 1 file changed, 26 insertions(+), 19 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 7a8d73e689b84..ad2ee2e840d00 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -712,9 +712,6 @@ size_t GPUReconstruction::AllocateRegisteredMemory(int16_t ires, GPUOutputContro
 
 void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
 {
-  if (type != GPUMemoryResource::MEMORY_HOST && (!IsGPU() || type != GPUMemoryResource::MEMORY_GPU)) {
-    throw std::runtime_error("Requested invalid memory typo for unmanaged allocation");
-  }
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
     char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
     if ((type & GPUMemoryResource::MEMORY_STACK)) {
@@ -723,25 +720,35 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
       mDirectMemoryChunks.emplace_back(retVal, alignedDeleter());
     }
     return retVal;
+  }
+
+  if ((type & ~(GPUMemoryResource::MEMORY_HOST | GPUMemoryResource::MEMORY_GPU | GPUMemoryResource::MEMORY_STACK)) || ((type & GPUMemoryResource::MEMORY_HOST) && (type & GPUMemoryResource::MEMORY_GPU))) {
+    throw std::runtime_error("Requested invalid memory typo for direct allocation");
+  }
+  if (mVolatileMemoryStart && !mDeviceMemoryAsVolatile && (type & GPUMemoryResource::MEMORY_GPU) && !(type & GPUMemoryResource::MEMORY_STACK)) {
+    GPUError("Must not allocate direct memory while volatile chunks are allocated");
+    throw std::bad_alloc();
+  }
+
+  void*& pool = (type & GPUMemoryResource::MEMORY_GPU) ? mDeviceMemoryPool : mHostMemoryPool;
+  void*& poolend = (type & GPUMemoryResource::MEMORY_GPU) ? mDeviceMemoryPoolEnd : mHostMemoryPoolEnd;
+  char* retVal;
+  if ((type & GPUMemoryResource::MEMORY_STACK)) {
+    poolend = (char*)poolend - size;
+    poolend = (char*)poolend - GPUProcessor::getAlignmentMod<GPUCA_MEMALIGN>(poolend);
+    retVal = (char*)poolend;
   } else {
-    if (mVolatileMemoryStart && !mDeviceMemoryAsVolatile && (type & GPUMemoryResource::MEMORY_GPU) && !(type & GPUMemoryResource::MEMORY_STACK)) {
-      GPUError("Must not allocate direct memory while volatile chunks are allocated");
-      throw std::bad_alloc();
-    }
-    void*& pool = type == GPUMemoryResource::MEMORY_GPU ? mDeviceMemoryPool : mHostMemoryPool;
-    void*& poolend = type == GPUMemoryResource::MEMORY_GPU ? mDeviceMemoryPoolEnd : mHostMemoryPoolEnd;
-    char* retVal;
     GPUProcessor::computePointerWithAlignment(pool, retVal, size);
-    if (pool > poolend) {
-      GPUError("Insufficient unmanaged memory: missing %ld bytes", ptrDiff(pool, poolend));
-      throw std::bad_alloc();
-    }
-    UpdateMaxMemoryUsed();
-    if (GetProcessingSettings().allocDebugLevel >= 2) {
-      std::cout << "Allocated (unmanaged " << (type == GPUMemoryResource::MEMORY_GPU ? "gpu" : "host") << "): " << size << " - available: " << ptrDiff(poolend, pool) << "\n";
-    }
-    return retVal;
   }
+  if (pool > poolend) {
+    GPUError("Insufficient unmanaged memory: missing %ld bytes", ptrDiff(pool, poolend));
+    throw std::bad_alloc();
+  }
+  UpdateMaxMemoryUsed();
+  if (GetProcessingSettings().allocDebugLevel >= 2) {
+    std::cout << "Allocated (unmanaged " << (type == GPUMemoryResource::MEMORY_GPU ? "gpu" : "host") << "): " << size << " - available: " << ptrDiff(poolend, pool) << "\n";
+  }
+  return retVal;
 }
 
 void* GPUReconstruction::AllocateVolatileDeviceMemory(size_t size)

From 1f6767ce039ea2ec6cc72da136368f1dad9677e3 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Apr 2025 18:07:01 +0200
Subject: [PATCH 0288/1764] GPU CMake: Another attempt to silence the CMake
 warnings about architectures

---
 GPU/GPUTracking/Standalone/CMakeLists.txt |  6 +++---
 dependencies/FindO2GPU.cmake              | 17 +++++------------
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index a17c58ad1ba03..0859223187f00 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -125,10 +125,10 @@ find_package(O2GPU REQUIRED)
 
 if(GPUCA_CONFIG_ONNX)
   find_package(onnxruntime REQUIRED)
-  if(CUDA_ENABLED AND NOT DEFINED ORT_CUDA_BUILD)
-    set(ORT_CUDA_BUILD ON)
-  elseif(HIP_ENABLED AND NOT DEFINED ORT_ROCM_BUILD)
+  if(HIP_ENABLED AND NOT DEFINED ORT_ROCM_BUILD)
     set(ORT_ROCM_BUILD ON)
+  elseif(CUDA_ENABLED AND NOT DEFINED ORT_CUDA_BUILD)
+    set(ORT_CUDA_BUILD ON)
   endif()
 else()
   set(onnxruntime_FOUND OFF)
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 0c5313c16af68..33925e8cf1341 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -104,7 +104,9 @@ endif()
 # ---------------------------------- CUDA ----------------------------------
 if(ENABLE_CUDA)
   if(CUDA_COMPUTETARGET)
-    set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET} CACHE STRING "" FORCE)
+    set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET})
+  else()
+    set(CMAKE_CUDA_ARCHITECTURES 61-virtual)
   endif()
   set(CMAKE_CUDA_STANDARD ${CMAKE_CXX_STANDARD})
   set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)
@@ -121,11 +123,6 @@ if(ENABLE_CUDA)
       message(STATUS "Using as CUDA GCC version: ${GPUCA_CUDA_GCCBIN}")
       set(CMAKE_CUDA_HOST_COMPILER "${GPUCA_CUDA_GCCBIN}")
     endif()
-    if(CUDA_COMPUTETARGET)
-      set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET} CACHE STRING "" FORCE)
-    else()
-      set(CMAKE_CUDA_ARCHITECTURES 61-virtual CACHE STRING "" FORCE)
-    endif()
     enable_language(CUDA)
     get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
     if (ENABLE_CUDA STREQUAL "AUTO")
@@ -231,7 +228,8 @@ endif()
 # ---------------------------------- HIP ----------------------------------
 if(ENABLE_HIP)
   if(HIP_AMDGPUTARGET)
-    set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}" CACHE STRING "" FORCE)
+    set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}")
+    set(AMDGPU_TARGETS "${HIP_AMDGPUTARGET}")
   endif()
   if(NOT "$ENV{CMAKE_PREFIX_PATH}" MATCHES "rocm" AND NOT CMAKE_PREFIX_PATH MATCHES "rocm" AND EXISTS "/opt/rocm/lib/cmake/")
     list(APPEND CMAKE_PREFIX_PATH "/opt/rocm/lib/cmake")
@@ -239,11 +237,6 @@ if(ENABLE_HIP)
   if("$ENV{CMAKE_PREFIX_PATH}" MATCHES "rocm" OR CMAKE_PREFIX_PATH MATCHES "rocm")
     set(CMAKE_HIP_STANDARD ${CMAKE_CXX_STANDARD})
     set(CMAKE_HIP_STANDARD_REQUIRED TRUE)
-    if(HIP_AMDGPUTARGET)
-      set(AMDGPU_TARGETS "${HIP_AMDGPUTARGET}" CACHE STRING "AMD GPU targets to compile for" FORCE)
-      set(GPU_TARGETS "${HIP_AMDGPUTARGET}" CACHE STRING "AMD GPU targets to compile for" FORCE)
-      set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}" CACHE STRING "AMD GPU targets to compile for" FORCE)
-    endif()
     set(TMP_ROCM_DIR_LIST "${CMAKE_PREFIX_PATH}:$ENV{CMAKE_PREFIX_PATH}")
     string(REPLACE ":" ";" TMP_ROCM_DIR_LIST "${TMP_ROCM_DIR_LIST}")
     list(FILTER TMP_ROCM_DIR_LIST INCLUDE REGEX rocm)

From cde32e7eee5ac9ff2668621115d0f839b95fb11c Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 17 Apr 2025 20:22:59 +0200
Subject: [PATCH 0289/1764] Common: ConfKey align prov + print hash

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/CommonUtils/ConfigurableParam.h   |  2 +-
 .../CommonUtils/ConfigurableParamHelper.h     | 14 +++---
 Common/Utils/src/ConfigurableParamHelper.cxx  | 49 ++++++++++++++-----
 3 files changed, 46 insertions(+), 19 deletions(-)

diff --git a/Common/Utils/include/CommonUtils/ConfigurableParam.h b/Common/Utils/include/CommonUtils/ConfigurableParam.h
index f44d9efcaea76..39b24bbbbd57c 100644
--- a/Common/Utils/include/CommonUtils/ConfigurableParam.h
+++ b/Common/Utils/include/CommonUtils/ConfigurableParam.h
@@ -162,7 +162,7 @@ class ConfigurableParam
   virtual std::string getName() const = 0;
 
   // print the current keys and values to screen (optionally with provenance information)
-  virtual void printKeyValues(bool showprov = true, bool useLogger = false) const = 0;
+  virtual void printKeyValues(bool showprov = true, bool useLogger = false, bool withPadding = false, bool showHash = false) const = 0;
 
   // get a single size_t hash_value of this parameter (can be used as a checksum to see
   // if object changed or different)
diff --git a/Common/Utils/include/CommonUtils/ConfigurableParamHelper.h b/Common/Utils/include/CommonUtils/ConfigurableParamHelper.h
index 7d9cb78bb9968..6e69fae03e6c3 100644
--- a/Common/Utils/include/CommonUtils/ConfigurableParamHelper.h
+++ b/Common/Utils/include/CommonUtils/ConfigurableParamHelper.h
@@ -34,7 +34,7 @@ struct ParamDataMember {
   std::string value;
   std::string provenance;
 
-  std::string toString(std::string const& prefix, bool showProv) const;
+  std::string toString(std::string const& prefix, bool showProv, size_t padding = 0) const;
 };
 
 // ----------------------------------------------------------------
@@ -58,8 +58,8 @@ class _ParamHelper
   static void syncCCDBandRegistry(std::string const& mainkey, TClass* cl, void* to, void* from,
                                   std::map<std::string, ConfigurableParam::EParamProvenance>* provmap, size_t offset);
 
-  static void outputMembersImpl(std::ostream& out, std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger);
-  static void printMembersImpl(std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger);
+  static void outputMembersImpl(std::ostream& out, std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger, bool withPadding = false, bool showHash = false);
+  static void printMembersImpl(std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger, bool withPadding, bool showHash);
 
   static size_t getHashImpl(std::string const& mainkey, std::vector<ParamDataMember> const* members);
 
@@ -100,13 +100,13 @@ class ConfigurableParamHelper : virtual public ConfigurableParam
   // ----------------------------------------------------------------
 
   // one of the key methods, using introspection to print itself
-  void printKeyValues(bool showProv = true, bool useLogger = false) const final
+  void printKeyValues(bool showProv = true, bool useLogger = false, bool withPadding = true, bool showHash = true) const final
   {
     if (!isInitialized()) {
       initialize();
     }
     auto members = getDataMembers();
-    _ParamHelper::printMembersImpl(getName(), members, showProv, useLogger);
+    _ParamHelper::printMembersImpl(getName(), members, showProv, useLogger, withPadding, showHash);
   }
 
   //
@@ -237,13 +237,13 @@ class ConfigurableParamPromoter : public Base, virtual public ConfigurableParam
   // ----------------------------------------------------------------
 
   // one of the key methods, using introspection to print itself
-  void printKeyValues(bool showProv = true, bool useLogger = false) const final
+  void printKeyValues(bool showProv = true, bool useLogger = false, bool withPadding = true, bool showHash = true) const final
   {
     if (!isInitialized()) {
       initialize();
     }
     auto members = getDataMembers();
-    _ParamHelper::printMembersImpl(getName(), members, showProv, useLogger);
+    _ParamHelper::printMembersImpl(getName(), members, showProv, useLogger, withPadding, showHash);
   }
 
   //
diff --git a/Common/Utils/src/ConfigurableParamHelper.cxx b/Common/Utils/src/ConfigurableParamHelper.cxx
index f217d402bcb45..161735b3a5ce4 100644
--- a/Common/Utils/src/ConfigurableParamHelper.cxx
+++ b/Common/Utils/src/ConfigurableParamHelper.cxx
@@ -26,6 +26,7 @@
 #include <boost/property_tree/ptree.hpp>
 #include <boost/functional/hash.hpp>
 #include <functional>
+#include <format>
 #ifdef NDEBUG
 #undef NDEBUG
 #endif
@@ -35,16 +36,25 @@ using namespace o2::conf;
 
 // ----------------------------------------------------------------------
 
-std::string ParamDataMember::toString(std::string const& prefix, bool showProv) const
+std::string ParamDataMember::toString(std::string const& prefix, bool showProv, size_t padding) const
 {
-  std::string nil = "<null>";
-
+  const std::string label = prefix + "." + name + " : " + value;
   std::ostringstream out;
-  out << prefix << "." << name << " : " << value;
+  out << label;
 
   if (showProv) {
-    std::string prov = (provenance.compare("") == 0 ? nil : provenance);
-    out << "\t\t[ " + prov + " ]";
+    std::string prov = (provenance.compare("") == 0 ? "<null>" : provenance);
+    if (padding) {
+      size_t len = label.size() - prefix.size() - 5; // 4 four the extra chars + 1 for the maxpad
+      if (len < padding) {
+        out << std::string(padding - len, ' ');
+      } else {
+        out << ' ';
+      }
+      out << "[ " + prov + " ]";
+    } else {
+      out << "\t\t[ " + prov + " ]";
+    }
   }
   return out.str();
 }
@@ -308,23 +318,40 @@ void _ParamHelper::fillKeyValuesImpl(std::string const& mainkey, TClass* cl, voi
 
 // ----------------------------------------------------------------------
 
-void _ParamHelper::printMembersImpl(std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger)
+void _ParamHelper::printMembersImpl(std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger, bool withPadding, bool showHash)
 {
 
-  _ParamHelper::outputMembersImpl(std::cout, mainkey, members, showProv, useLogger);
+  _ParamHelper::outputMembersImpl(std::cout, mainkey, members, showProv, useLogger, withPadding, showHash);
 }
 
-void _ParamHelper::outputMembersImpl(std::ostream& out, std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger)
+void _ParamHelper::outputMembersImpl(std::ostream& out, std::string const& mainkey, std::vector<ParamDataMember> const* members, bool showProv, bool useLogger, bool withPadding, bool showHash)
 {
   if (members == nullptr) {
     return;
   }
 
+  size_t maxpad{0};
+  if (withPadding) {
+    for (auto& member : *members) {
+      maxpad = std::max(maxpad, member.name.size() + member.value.size());
+    }
+  }
+
+  if (showHash) {
+    std::string shash = std::format("{:07x}", getHashImpl(mainkey, members));
+    shash = shash.substr(0, 7);
+    if (useLogger) {
+      LOG(info) << mainkey << " [Hash#" << shash << "]";
+    } else {
+      out << mainkey << " [Hash#" << shash << "]\n";
+    }
+  }
+
   for (auto& member : *members) {
     if (useLogger) {
-      LOG(info) << member.toString(mainkey, showProv);
+      LOG(info) << member.toString(mainkey, showProv, maxpad);
     } else {
-      out << member.toString(mainkey, showProv) << "\n";
+      out << member.toString(mainkey, showProv, maxpad) << "\n";
     }
   }
 }

From aae7f0a9d4201dd1efff98d47d3ea51ebd7e9c19 Mon Sep 17 00:00:00 2001
From: Francesco Mazzaschi <43742195+fmazzasc@users.noreply.github.com>
Date: Wed, 23 Apr 2025 15:19:36 +0200
Subject: [PATCH 0290/1764] [StrangenessTracker] Fix chi2 calculation and
 attachment structure (#14186)

* [StrangenessTracker] Fix chi2 calculation and attachment structure

* Please consider the following formatting changes

---------

Co-authored-by: Francesco Mazzaschi <fmazzasc@alipap1.cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../StrangenessTracking/StrangenessTracker.h       |  7 ++-----
 .../StrangenessTracking/src/StrangenessTracker.cxx | 14 ++++++--------
 2 files changed, 8 insertions(+), 13 deletions(-)

diff --git a/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h b/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
index 11feac64c59ae..b30be4dd081e3 100644
--- a/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
+++ b/Detectors/Vertexing/StrangenessTracking/include/StrangenessTracking/StrangenessTracker.h
@@ -56,7 +56,7 @@ enum DauType : int {
 
 struct ClusAttachments {
 
-  std::array<unsigned int, 7> arr;
+  std::array<int, 7> arr;
 };
 
 class StrangenessTracker
@@ -357,10 +357,7 @@ class StrangenessTracker
   std::vector<DCAFitter4> mFitter4Body; // optional DCA Fitter for final 4 Body refit (per thread)
 
   o2::base::PropagatorImpl<float>::MatCorrType mCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE; // use mat correction
-
-  std::vector<std::vector<o2::track::TrackParCovF>> mDaughterTracks; // vector of daughter tracks (per thread)
-  ClusAttachments mStructClus;                                       // # of attached tracks, 1 for mother, 2 for daughter
-
+  std::vector<std::vector<o2::track::TrackParCovF>> mDaughterTracks;                                                     // vector of daughter tracks (per thread)
   ClassDefNV(StrangenessTracker, 1);
 };
 
diff --git a/Detectors/Vertexing/StrangenessTracking/src/StrangenessTracker.cxx b/Detectors/Vertexing/StrangenessTracking/src/StrangenessTracker.cxx
index c8a62fa76e3ed..acbaa9d6a08fd 100644
--- a/Detectors/Vertexing/StrangenessTracking/src/StrangenessTracker.cxx
+++ b/Detectors/Vertexing/StrangenessTracking/src/StrangenessTracker.cxx
@@ -245,7 +245,7 @@ void StrangenessTracker::processCascade(int iCasc, const Cascade& casc, const Ca
         strangeTrack.mDecayRef = iCasc;
         strangeTrack.mITSRef = mSortedITSindexes[iTrack];
         mStrangeTrackVec[iThread].push_back(strangeTrack);
-        mClusAttachments[iThread].push_back(mStructClus);
+        mClusAttachments[iThread].push_back(structClus);
         if (mMCTruthON) {
           auto lab = getStrangeTrackLabel(itsTrack, strangeTrack, structClus);
           mStrangeTrackLabels[iThread].push_back(lab);
@@ -350,7 +350,7 @@ bool StrangenessTracker::matchDecayToITStrack(float decayR, StrangeTrack& strang
   auto nMinClusMother = trackClusters.size() < 4 ? 2 : mStrParams->mMinMotherClus;
 
   std::vector<ITSCluster> motherClusters;
-  std::array<unsigned int, 7> nAttachments;
+  std::array<int, 7> nAttachments;
   nAttachments.fill(-1); // fill arr with -1
 
   int nUpdates = 0;
@@ -412,13 +412,13 @@ bool StrangenessTracker::matchDecayToITStrack(float decayR, StrangeTrack& strang
 
   std::reverse(motherClusters.begin(), motherClusters.end());
 
-  mGlobalChi2 = -1;
+  mGlobalChi2 = 0;
   for (auto& clus : motherClusters) {
     if (!updateTrack(clus, motherTrackClone)) {
       break;
     }
   }
-  strangeTrack.mMatchChi2 = mGlobalChi2;
+  strangeTrack.mMatchChi2 = mGlobalChi2 / motherClusters.size();
 
   LOG(debug) << "Inward-outward refit finished, starting final topology refit";
   // final Topology refit
@@ -481,7 +481,6 @@ bool StrangenessTracker::matchDecayToITStrack(float decayR, StrangeTrack& strang
     strangeTrack.mTopoChi2 = mFitter3Body[iThread].getChi2AtPCACandidate();
   }
   structClus.arr = nAttachments;
-
   return true;
 }
 
@@ -508,9 +507,8 @@ bool StrangenessTracker::updateTrack(const ITSCluster& clus, o2::track::TrackPar
       return false;
     }
   }
-  auto chi2 = std::abs(track.getPredictedChi2Quiet(clus)); // abs to be understood
-  LOG(debug) << "Chi2: " << chi2;
-  if (chi2 > mStrParams->mMaxChi2 || chi2 < 0) {
+  auto chi2 = track.getPredictedChi2Quiet(clus); // abs to be understood
+  if (std::abs(chi2) > mStrParams->mMaxChi2) {
     return false;
   }
 

From 04baff0b28a95c388a139f2554a77eeab97588dc Mon Sep 17 00:00:00 2001
From: abmodak <67369858+abmodak@users.noreply.github.com>
Date: Wed, 23 Apr 2025 18:50:42 +0200
Subject: [PATCH 0291/1764] Add PMD info to AO2Ds (#13998)

---
 .../include/Framework/AnalysisDataModel.h     | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index d90952f38ac9f..3216a24ed73a2 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -1778,6 +1778,23 @@ DECLARE_SOA_COLUMN(DCAr, dcaR, float);                                  //! DCA
 DECLARE_SOA_COLUMN(DCAz, dcaZ, float);                                  //! DCA in z direction
 DECLARE_SOA_COLUMN(Mass, mass, float);                                  //! mass of the conversion. Do NOT use for cut!
 } // namespace oftv0
+namespace pmd
+{
+DECLARE_SOA_INDEX_COLUMN(BC, bc);                       //! BC index
+DECLARE_SOA_COLUMN(X, pmdclsx, float);                  //! cluster x position
+DECLARE_SOA_COLUMN(Y, pmdclsy, float);                  //! cluster y position
+DECLARE_SOA_COLUMN(Z, pmdclsz, float);                  //! cluster z position
+DECLARE_SOA_COLUMN(CluADC, pmdclsadc, float);           //! cluster energy in ADC
+DECLARE_SOA_COLUMN(CluPID, pmdclspid, float);           //! cluster probability, 1: photon, 0:hadron
+DECLARE_SOA_COLUMN(Det, pmddet, uint8_t);               //! Detector, 0:PRE, 1:CPV
+DECLARE_SOA_COLUMN(Ncell, pmdncell, uint8_t);           //! cluster cells
+DECLARE_SOA_COLUMN(Smn, pmdmodule, int32_t);            //! module number
+DECLARE_SOA_COLUMN(TrackNo, pmdtrackno, int32_t);       //! Track number assigned to clus from simulation
+DECLARE_SOA_COLUMN(TrackPid, pmdtrackpid, int32_t);     //! Track PID assigned to clus from simulation
+DECLARE_SOA_COLUMN(SigX, pmdsigx, float);               //! Cluster x-width
+DECLARE_SOA_COLUMN(SigY, pmdsigy, float);               //! Cluster y-width
+DECLARE_SOA_COLUMN(ClMatching, pmdclmatching, int32_t); //! Cluster of PRE matching with CPV
+} // namespace pmd
 } // namespace run2
 
 DECLARE_SOA_TABLE(Run2BCInfos_000, "AOD", "RUN2BCINFO", run2::EventCuts, //! Legacy information for Run 2 event selection
@@ -1811,6 +1828,14 @@ DECLARE_SOA_TABLE(Run2OTFV0s, "AOD", "Run2OTFV0", //! Run 2 V0 on the fly table
 
 using Run2OTFV0 = Run2OTFV0s::iterator;
 
+DECLARE_SOA_TABLE(Pmds, "AOD", "PMD", //! Photon information from PMD detector
+                  o2::soa::Index<>, run2::pmd::BCId, run2::pmd::X, run2::pmd::Y,
+                  run2::pmd::Z, run2::pmd::CluADC, run2::pmd::CluPID, run2::pmd::Det,
+                  run2::pmd::Ncell, run2::pmd::Smn, run2::pmd::TrackNo, run2::pmd::TrackPid,
+                  run2::pmd::SigX, run2::pmd::SigY, run2::pmd::ClMatching);
+
+using Pmd = Pmds::iterator;
+
 // ---- MC tables ----
 namespace mccollision
 {

From 72b50c63aeeb24144bc186d2c4efabc56503cf55 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 24 Apr 2025 07:22:33 +0200
Subject: [PATCH 0292/1764] ITS: Fix GPU deterministic mode + refactoring
 (#14200)

---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  14 +-
 .../GPU/ITStrackingGPU/TrackerTraitsGPU.h     |  29 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |   3 +-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  87 ++--
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 445 ++++++++----------
 .../tracking/include/ITStracking/Tracker.h    |  31 +-
 .../include/ITStracking/TrackerTraits.h       |  30 +-
 .../include/ITStracking/TrackingInterface.h   |   5 +-
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx | 188 ++------
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  24 +-
 .../ITS/tracking/src/TrackingInterface.cxx    |  19 +-
 .../ITSMFT/ITS/workflow/src/TrackerSpec.cxx   |   2 +
 12 files changed, 317 insertions(+), 560 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 29d2404e98681..88666cdfdb7fb 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -15,18 +15,13 @@
 
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Configuration.h"
-
-#include "ITStrackingGPU/ClusterLinesGPU.h"
 #include "ITStrackingGPU/Utils.h"
 
 #include <gsl/gsl>
 
-namespace o2
-{
-namespace its
-{
-namespace gpu
+namespace o2::its::gpu
 {
+
 class Stream;
 
 class DefaultGPUAllocator : public ExternalAllocator
@@ -228,7 +223,6 @@ inline int TimeFrameGPU<nLayers>::getNumberOfCells() const
   return std::accumulate(mNCells.begin(), mNCells.end(), 0);
 }
 
-} // namespace gpu
-} // namespace its
-} // namespace o2
+} // namespace o2::its::gpu
+
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
index f9583d97ca030..c765307473749 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
@@ -13,8 +13,6 @@
 #ifndef ITSTRACKINGGPU_TRACKERTRAITSGPU_H_
 #define ITSTRACKINGGPU_TRACKERTRAITSGPU_H_
 
-#include "ITStracking/Configuration.h"
-#include "ITStracking/Definitions.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITStrackingGPU/TimeFrameGPU.h"
 
@@ -24,28 +22,27 @@ namespace its
 {
 
 template <int nLayers = 7>
-class TrackerTraitsGPU : public TrackerTraits
+class TrackerTraitsGPU final : public TrackerTraits
 {
  public:
   TrackerTraitsGPU() = default;
   ~TrackerTraitsGPU() override = default;
 
-  // void computeLayerCells() final;
-  void adoptTimeFrame(TimeFrame* tf) override;
-  void initialiseTimeFrame(const int iteration) override;
+  void adoptTimeFrame(TimeFrame* tf) final;
+  void initialiseTimeFrame(const int iteration) final;
+
   void computeLayerTracklets(const int iteration, int, int) final;
-  void computeLayerCells(const int iteration) override;
-  void setBz(float) override;
-  void findCellsNeighbours(const int iteration) override;
-  void findRoads(const int iteration) override;
+  void computeLayerCells(const int iteration) final;
+  void findCellsNeighbours(const int iteration) final;
+  void findRoads(const int iteration) final;
+
+  bool supportsExtendTracks() const noexcept final { return false; }
+  bool supportsFindShortPrimaries() const noexcept final { return false; }
 
-  // Methods to get CPU execution from traits
-  void initialiseTimeFrameHybrid(const int iteration) override { initialiseTimeFrame(iteration); };
-  void computeTrackletsHybrid(const int iteration, int, int) override;
-  void computeCellsHybrid(const int iteration) override;
-  void findCellsNeighboursHybrid(const int iteration) override;
+  void setBz(float) final;
 
-  void extendTracks(const int iteration) override;
+  const char* getName() const noexcept final { return "GPU"; }
+  bool isGPU() const noexcept final { return true; }
 
   // TimeFrameGPU information forwarding
   int getTFNumberOfClusters() const override;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 720867ddaba29..21b14fd9292d2 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -176,8 +176,7 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   const int nBlocks,
                                   const int nThreads);
 
-int filterCellNeighboursHandler(std::vector<int>&,
-                                gpuPair<int, int>*,
+int filterCellNeighboursHandler(gpuPair<int, int>*,
                                 int*,
                                 unsigned int);
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 3c65faddcff71..f3b62ec8a6108 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -11,10 +11,7 @@
 ///
 
 #include <array>
-#include <sstream>
-#include <iostream>
 #include <unistd.h>
-#include <thread>
 
 #include "DataFormatsITS/TrackITS.h"
 
@@ -41,54 +38,7 @@ void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
 }
 
 template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int, int)
-{
-}
-
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
-{
-}
-
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
-{
-}
-
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::extendTracks(const int iteration)
-{
-}
-
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::setBz(float bz)
-{
-  mBz = bz;
-  mTimeFrameGPU->setBz(bz);
-}
-
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfClusters() const
-{
-  return mTimeFrameGPU->getNumberOfClusters();
-}
-
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfTracklets() const
-{
-  return std::accumulate(mTimeFrameGPU->getNTracklets().begin(), mTimeFrameGPU->getNTracklets().end(), 0);
-}
-
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfCells() const
-{
-  return mTimeFrameGPU->getNumberOfCells();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Hybrid tracking
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeTrackletsHybrid(const int iteration, int iROFslice, int iVertex)
+void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   mTimeFrameGPU->createTrackletsLUTDevice(iteration);
@@ -161,7 +111,7 @@ void TrackerTraitsGPU<nLayers>::computeTrackletsHybrid(const int iteration, int
 }
 
 template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeCellsHybrid(const int iteration)
+void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
 {
   mTimeFrameGPU->createCellsLUTDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
@@ -208,7 +158,7 @@ void TrackerTraitsGPU<nLayers>::computeCellsHybrid(const int iteration)
 }
 
 template <int nLayers>
-void TrackerTraitsGPU<nLayers>::findCellsNeighboursHybrid(const int iteration)
+void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
 {
   mTimeFrameGPU->createNeighboursIndexTablesDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
@@ -250,8 +200,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighboursHybrid(const int iteration)
                                  conf.nBlocks,
                                  conf.nThreads);
 
-    filterCellNeighboursHandler(mTimeFrameGPU->getCellsNeighbours()[iLayer],
-                                mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
+    filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                 mTimeFrameGPU->getDeviceNeighbours(iLayer),
                                 nNeigh);
   }
@@ -270,9 +219,6 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
       if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
       }
-      std::vector<int> lastCellId, updatedCellId;
-      std::vector<CellSeed> lastCellSeed, updatedCellSeed;
-
       processNeighboursHandler<nLayers>(startLayer,
                                         startLevel,
                                         mTimeFrameGPU->getDeviceArrayCells(),
@@ -366,5 +312,30 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
   }
 };
 
+template <int nLayers>
+int TrackerTraitsGPU<nLayers>::getTFNumberOfClusters() const
+{
+  return mTimeFrameGPU->getNumberOfClusters();
+}
+
+template <int nLayers>
+int TrackerTraitsGPU<nLayers>::getTFNumberOfTracklets() const
+{
+  return std::accumulate(mTimeFrameGPU->getNTracklets().begin(), mTimeFrameGPU->getNTracklets().end(), 0);
+}
+
+template <int nLayers>
+int TrackerTraitsGPU<nLayers>::getTFNumberOfCells() const
+{
+  return mTimeFrameGPU->getNumberOfCells();
+}
+
+template <int nLayers>
+void TrackerTraitsGPU<nLayers>::setBz(float bz)
+{
+  mBz = bz;
+  mTimeFrameGPU->setBz(bz);
+}
+
 template class TrackerTraitsGPU<7>;
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 805e66675e1b9..bb39e9e70341b 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -12,11 +12,9 @@
 
 #include <cuda_runtime.h>
 #include <array>
-#include <sstream>
-#include <iostream>
 #include <unistd.h>
-#include <thread>
 
+#include <cub/cub.cuh>
 #include <thrust/execution_policy.h>
 #include <thrust/device_ptr.h>
 #include <thrust/device_vector.h>
@@ -28,7 +26,6 @@
 #include <thrust/sequence.h>
 
 #include "ITStracking/Constants.h"
-#include "ITStracking/Configuration.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/MathUtils.h"
 #include "DataFormatsITS/TrackITS.h"
@@ -59,7 +56,7 @@ namespace o2::its
 using namespace constants::its2;
 using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
-GPUd() float Sq(float v)
+GPUdii() float Sq(float v)
 {
   return v * v;
 }
@@ -76,15 +73,15 @@ GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerInde
   const float zRangeMax = o2::gpu::CAMath::Max(z1, z2) + maxdeltaz;
   const float phiRangeMax = (maxdeltaphi > constants::math::Pi) ? constants::math::TwoPi : currentCluster.phi + maxdeltaphi;
 
-  if (zRangeMax < -LayersZCoordinate()[layerIndex + 1] ||
-      zRangeMin > LayersZCoordinate()[layerIndex + 1] || zRangeMin > zRangeMax) {
+  if (zRangeMax < -utils.getLayerZ(layerIndex) ||
+      zRangeMin > utils.getLayerZ(layerIndex) || zRangeMin > zRangeMax) {
 
     return getEmptyBinsRect();
   }
 
-  return int4{o2::gpu::CAMath::Max(0, utils.getZBinIndex(layerIndex + 1, zRangeMin)),
+  return int4{o2::gpu::CAMath::Max(0, utils.getZBinIndex(layerIndex, zRangeMin)),
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
-              o2::gpu::CAMath::Min(ZBins - 1, utils.getZBinIndex(layerIndex + 1, zRangeMax)),
+              o2::gpu::CAMath::Min(utils.getNzBins() - 1, utils.getZBinIndex(layerIndex, zRangeMax)),
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
 }
 
@@ -184,6 +181,11 @@ struct equal_tracklets {
   GPUhd() bool operator()(const Tracklet& a, const Tracklet& b) { return a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex == b.secondClusterIndex; }
 };
 
+template <typename T1, typename T2>
+struct sort_by_second {
+  GPUhd() bool operator()(const gpuPair<T1, T2>& a, const gpuPair<T1, T2>& b) const { return a.second < b.second; }
+};
+
 template <typename T1, typename T2>
 struct pair_to_first {
   GPUhd() int operator()(const gpuPair<T1, T2>& a) const
@@ -522,7 +524,7 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
         const float zAtRmax{tanLambda * (maxR - currentCluster.radius) + currentCluster.zCoordinate};
         const float sqInverseDeltaZ0{1.f / (Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
         const float sigmaZ{o2::gpu::CAMath::Sqrt(Sq(resolution) * Sq(tanLambda) * ((Sq(inverseR0) + sqInverseDeltaZ0) * Sq(meanDeltaR) + 1.f) + Sq(meanDeltaR * MSAngle))};
-        const int4 selectedBinsRect{getBinsRect(currentCluster, layerIndex, *utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
+        const int4 selectedBinsRect{getBinsRect(currentCluster, layerIndex + 1, *utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
         if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
           continue;
         }
@@ -800,6 +802,44 @@ GPUg() void printCellSeeds(CellSeed* seed, int nCells, const unsigned int tId =
     }
   }
 }
+
+template <typename T>
+GPUhi() void cubExclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr)
+{
+  void* d_temp_storage = nullptr;
+  size_t temp_storage_bytes = 0;
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out,
+                                           in_out, num_items, stream));
+  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out,
+                                           in_out, num_items, stream));
+  GPUChkErrS(cudaFree(d_temp_storage));
+}
+
+template <typename Vector>
+GPUhi() void cubExclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr)
+{
+  cubExclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream);
+}
+
+template <typename T>
+GPUhi() void cubInclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr)
+{
+  void* d_temp_storage = nullptr;
+  size_t temp_storage_bytes = 0;
+  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out,
+                                           in_out, num_items, stream));
+  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out,
+                                           in_out, num_items, stream));
+  GPUChkErrS(cudaFree(d_temp_storage));
+}
+
+template <typename Vector>
+GPUhi() void cubInclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr)
+{
+  cubInclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream);
+}
 } // namespace gpu
 
 template <int nLayers>
@@ -833,7 +873,8 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  const int nThreads)
 {
   for (int iLayer = 0; iLayer < nLayers - 1; ++iLayer) {
-    gpu::computeLayerTrackletsMultiROFKernel<true><<<nBlocks, nThreads>>>(
+    gpu::computeLayerTrackletsMultiROFKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                                     o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
       utils,
       multMask,
       iLayer,
@@ -860,22 +901,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
       resolutions[iLayer],
       radii[iLayer + 1] - radii[iLayer],
       mulScatAng[iLayer]);
-    void* d_temp_storage = nullptr;
-    size_t temp_storage_bytes = 0;
-    GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
-                                             temp_storage_bytes,        // temp_storage_bytes
-                                             trackletsLUTsHost[iLayer], // d_in
-                                             trackletsLUTsHost[iLayer], // d_out
-                                             nClusters[iLayer] + 1,     // num_items
-                                             0));                       // NOLINT: this is the offset of the sum, not a pointer
-    GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-    GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
-                                             temp_storage_bytes,        // temp_storage_bytes
-                                             trackletsLUTsHost[iLayer], // d_in
-                                             trackletsLUTsHost[iLayer], // d_out
-                                             nClusters[iLayer] + 1,     // num_items
-                                             0));                       // NOLINT: this is the offset of the sum, not a pointer
-    GPUChkErrS(cudaFree(d_temp_storage));
+    gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1);
   }
 }
 
@@ -913,55 +939,42 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    const int nThreads)
 {
   for (int iLayer = 0; iLayer < nLayers - 1; ++iLayer) {
-    gpu::computeLayerTrackletsMultiROFKernel<false><<<nBlocks, nThreads>>>(utils,
-                                                                           multMask,
-                                                                           iLayer,
-                                                                           startROF,
-                                                                           endROF,
-                                                                           maxROF,
-                                                                           deltaROF,
-                                                                           vertices,
-                                                                           rofPV,
-                                                                           nVertices,
-                                                                           vertexId,
-                                                                           clusters,
-                                                                           ROFClusters,
-                                                                           usedClusters,
-                                                                           clustersIndexTables,
-                                                                           tracklets,
-                                                                           trackletsLUTs,
-                                                                           iteration,
-                                                                           NSigmaCut,
-                                                                           phiCuts[iLayer],
-                                                                           resolutionPV,
-                                                                           minRs[iLayer + 1],
-                                                                           maxRs[iLayer + 1],
-                                                                           resolutions[iLayer],
-                                                                           radii[iLayer + 1] - radii[iLayer],
-                                                                           mulScatAng[iLayer]);
+    gpu::computeLayerTrackletsMultiROFKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS), o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(utils,
+                                                                                                                                                multMask,
+                                                                                                                                                iLayer,
+                                                                                                                                                startROF,
+                                                                                                                                                endROF,
+                                                                                                                                                maxROF,
+                                                                                                                                                deltaROF,
+                                                                                                                                                vertices,
+                                                                                                                                                rofPV,
+                                                                                                                                                nVertices,
+                                                                                                                                                vertexId,
+                                                                                                                                                clusters,
+                                                                                                                                                ROFClusters,
+                                                                                                                                                usedClusters,
+                                                                                                                                                clustersIndexTables,
+                                                                                                                                                tracklets,
+                                                                                                                                                trackletsLUTs,
+                                                                                                                                                iteration,
+                                                                                                                                                NSigmaCut,
+                                                                                                                                                phiCuts[iLayer],
+                                                                                                                                                resolutionPV,
+                                                                                                                                                minRs[iLayer + 1],
+                                                                                                                                                maxRs[iLayer + 1],
+                                                                                                                                                resolutions[iLayer],
+                                                                                                                                                radii[iLayer + 1] - radii[iLayer],
+                                                                                                                                                mulScatAng[iLayer]);
     thrust::device_ptr<Tracklet> tracklets_ptr(spanTracklets[iLayer]);
     thrust::sort(thrust::device, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::sort_tracklets());
     auto unique_end = thrust::unique(thrust::device, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::equal_tracklets());
     nTracklets[iLayer] = unique_end - tracklets_ptr;
     if (iLayer > 0) {
       GPUChkErrS(cudaMemset(trackletsLUTsHost[iLayer], 0, nClusters[iLayer] * sizeof(int)));
-      gpu::compileTrackletsLookupTableKernel<<<nBlocks, nThreads>>>(spanTracklets[iLayer], trackletsLUTsHost[iLayer], nTracklets[iLayer]);
-      void* d_temp_storage = nullptr;
-      size_t temp_storage_bytes = 0;
-      GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
-                                               temp_storage_bytes,        // temp_storage_bytes
-                                               trackletsLUTsHost[iLayer], // d_in
-                                               trackletsLUTsHost[iLayer], // d_out
-                                               nClusters[iLayer] + 1,     // num_items
-                                               0));                       // NOLINT: this is the offset of the sum, not a pointer
-      GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-      GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,            // d_temp_storage
-                                               temp_storage_bytes,        // temp_storage_bytes
-                                               trackletsLUTsHost[iLayer], // d_in
-                                               trackletsLUTsHost[iLayer], // d_out
-                                               nClusters[iLayer] + 1,     // num_items
-                                               0));                       // NOLINT: this is the offset of the sum, not a pointer
-      GPUChkErrS(cudaFree(d_temp_storage));
+      gpu::compileTrackletsLookupTableKernel<<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                               o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+        spanTracklets[iLayer], trackletsLUTsHost[iLayer], nTracklets[iLayer]);
+      gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1);
     }
   }
 }
@@ -984,7 +997,8 @@ void countCellsHandler(
   const int nBlocks,
   const int nThreads)
 {
-  gpu::computeLayerCellsKernel<true><<<nBlocks, nThreads>>>(
+  gpu::computeLayerCellsKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                       o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
     sortedClusters,           // const Cluster**
     unsortedClusters,         // const Cluster**
     tfInfo,                   // const TrackingFrameInfo**
@@ -998,22 +1012,7 @@ void countCellsHandler(
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
     nSigmaCut);               // const float
-  void* d_temp_storage = nullptr;
-  size_t temp_storage_bytes = 0;
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,     // d_temp_storage
-                                           temp_storage_bytes, // temp_storage_bytes
-                                           cellsLUTsHost,      // d_in
-                                           cellsLUTsHost,      // d_out
-                                           nTracklets + 1,     // num_items
-                                           0));                // NOLINT: this is the offset of the sum, not a pointer
-  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,     // d_temp_storage
-                                           temp_storage_bytes, // temp_storage_bytes
-                                           cellsLUTsHost,      // d_in
-                                           cellsLUTsHost,      // d_out
-                                           nTracklets + 1,     // num_items
-                                           0));                // NOLINT: this is the offset of the sum, not a pointer
-  GPUChkErrS(cudaFree(d_temp_storage));
+  gpu::cubExclusiveScanInPlace(cellsLUTsHost, nTracklets + 1);
 }
 
 void computeCellsHandler(
@@ -1034,7 +1033,8 @@ void computeCellsHandler(
   const int nBlocks,
   const int nThreads)
 {
-  gpu::computeLayerCellsKernel<false><<<nBlocks, nThreads>>>(
+  gpu::computeLayerCellsKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                        o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
     sortedClusters,           // const Cluster**
     unsortedClusters,         // const Cluster**
     tfInfo,                   // const TrackingFrameInfo**
@@ -1064,7 +1064,8 @@ unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                         const int nBlocks,
                                         const int nThreads)
 {
-  gpu::computeLayerCellNeighboursKernel<true><<<nBlocks, nThreads>>>(
+  gpu::computeLayerCellNeighboursKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                                o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1076,39 +1077,10 @@ unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
     nCells,
     maxCellNeighbours);
 
-  void *d_temp_storage = nullptr, *d_temp_storage_2 = nullptr;
-  size_t temp_storage_bytes = 0, temp_storage_bytes_2 = 0;
-  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage,     // d_temp_storage
-                                           temp_storage_bytes, // temp_storage_bytes
-                                           neighboursLUT,      // d_in
-                                           neighboursLUT,      // d_out
-                                           nCellsNext));       // num_items
-
-  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage,     // d_temp_storage
-                                           temp_storage_bytes, // temp_storage_bytes
-                                           neighboursLUT,      // d_in
-                                           neighboursLUT,      // d_out
-                                           nCellsNext));       // num_items
-
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage_2,     // d_temp_storage
-                                           temp_storage_bytes_2, // temp_storage_bytes
-                                           neighboursIndexTable, // d_in
-                                           neighboursIndexTable, // d_out
-                                           nCells + 1,           // num_items
-                                           0));                  // NOLINT: this is the offset of the sum, not a pointer
-
-  GPUChkErrS(cudaMalloc(&d_temp_storage_2, temp_storage_bytes_2));
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage_2,     // d_temp_storage
-                                           temp_storage_bytes_2, // temp_storage_bytes
-                                           neighboursIndexTable, // d_in
-                                           neighboursIndexTable, // d_out
-                                           nCells + 1,           // num_items
-                                           0));                  // NOLINT: this is the offset of the sum, not a pointer
+  gpu::cubInclusiveScanInPlace(neighboursLUT, nCellsNext);
+  gpu::cubExclusiveScanInPlace(neighboursIndexTable, nCells + 1);
   unsigned int nNeighbours;
   GPUChkErrS(cudaMemcpy(&nNeighbours, &neighboursLUT[nCellsNext - 1], sizeof(unsigned int), cudaMemcpyDeviceToHost));
-  GPUChkErrS(cudaFree(d_temp_storage));
-  GPUChkErrS(cudaFree(d_temp_storage_2));
   return nNeighbours;
 }
 
@@ -1143,32 +1115,18 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
   GPUChkErrS(cudaDeviceSynchronize());
 }
 
-int filterCellNeighboursHandler(std::vector<int>& neighHost, // TODO: eventually remove this!
-                                gpuPair<int, int>* cellNeighbourPairs,
+int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
                                 int* cellNeighbours,
                                 unsigned int nNeigh)
 {
   thrust::device_ptr<gpuPair<int, int>> neighVectorPairs(cellNeighbourPairs);
   thrust::device_ptr<int> validNeighs(cellNeighbours);
-  thrust::device_vector<int> keys(nNeigh); // TODO: externally allocate.
-  thrust::device_vector<int> vals(nNeigh); // TODO: externally allocate.
-  thrust::copy(thrust::make_transform_iterator(neighVectorPairs, gpu::pair_to_second<int, int>()),
-               thrust::make_transform_iterator(neighVectorPairs + nNeigh, gpu::pair_to_second<int, int>()),
-               keys.begin());
-  thrust::sequence(vals.begin(), vals.end());
-  thrust::sort_by_key(keys.begin(), keys.end(), vals.begin());
-  thrust::device_vector<gpuPair<int, int>> sortedNeigh(nNeigh);
-  thrust::copy(thrust::make_permutation_iterator(neighVectorPairs, vals.begin()),
-               thrust::make_permutation_iterator(neighVectorPairs, vals.end()),
-               sortedNeigh.begin());
-  GPUChkErrS(cudaDeviceSynchronize());
-  auto trimmedBegin = thrust::find_if(sortedNeigh.begin(), sortedNeigh.end(), gpu::is_valid_pair<int, int>()); // trim leading -1s
-  auto trimmedSize = sortedNeigh.end() - trimmedBegin;
-  neighHost.resize(trimmedSize);
-  thrust::transform(trimmedBegin, sortedNeigh.end(), validNeighs, gpu::pair_to_first<int, int>());
-  GPUChkErrS(cudaMemcpy(neighHost.data(), cellNeighbours, trimmedSize * sizeof(int), cudaMemcpyDeviceToHost));
+  auto updatedEnd = thrust::remove_if(neighVectorPairs, neighVectorPairs + nNeigh, gpu::is_invalid_pair<int, int>());
+  size_t newSize = updatedEnd - neighVectorPairs;
+  thrust::stable_sort(neighVectorPairs, neighVectorPairs + newSize, gpu::sort_by_second<int, int>());
+  thrust::transform(neighVectorPairs, neighVectorPairs + newSize, validNeighs, gpu::pair_to_first<int, int>());
 
-  return trimmedSize;
+  return newSize;
 }
 
 template <int nLayers>
@@ -1190,137 +1148,117 @@ void processNeighboursHandler(const int startLayer,
                               const int nBlocks,
                               const int nThreads)
 {
-  thrust::device_vector<int> foundSeedsTable(nCells[startLayer] + 1); // Shortcut: device_vector skips central memory management, we are relying on the contingency. TODO: fix this.
-                                                                      // thrust::device_vector<int> lastCellIds(lastCellIdHost);
-                                                                      // thrust::device_vector<CellSeed> lastCellSeed(lastCellSeedHost);
-  thrust::device_vector<int> lastCellId, updatedCellId;
-  thrust::device_vector<CellSeed> lastCellSeed, updatedCellSeed;
-  gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(startLayer,
-                                                            startLevel,
-                                                            allCellSeeds,
-                                                            currentCellSeeds,
-                                                            nullptr,
-                                                            nCells[startLayer],
-                                                            nullptr,
-                                                            nullptr,
-                                                            thrust::raw_pointer_cast(&foundSeedsTable[0]),
-                                                            usedClusters,
-                                                            neighbours[startLayer - 1],
-                                                            neighboursDeviceLUTs[startLayer - 1],
-                                                            foundTrackingFrameInfo,
-                                                            bz,
-                                                            maxChi2ClusterAttachment,
-                                                            propagator,
-                                                            matCorrType);
-  void* d_temp_storage = nullptr;
-  size_t temp_storage_bytes = 0;
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(nullptr,                                       // d_temp_storage
-                                           temp_storage_bytes,                            // temp_storage_bytes
-                                           thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
-                                           thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
-                                           nCells[startLayer] + 1,                        // num_items
-                                           0));                                           // NOLINT: this is the offset of the sum, not a pointer
-  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,                                // d_temp_storage
-                                           temp_storage_bytes,                            // temp_storage_bytes
-                                           thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
-                                           thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
-                                           nCells[startLayer] + 1,                        // num_items
-                                           0));                                           // NOLINT: this is the offset of the sum, not a pointer
-
-  updatedCellId.resize(foundSeedsTable.back());
-  updatedCellSeed.resize(foundSeedsTable.back());
-
-  gpu::processNeighboursKernel<false><<<nBlocks, nThreads>>>(startLayer,
-                                                             startLevel,
-                                                             allCellSeeds,
-                                                             currentCellSeeds,
-                                                             nullptr,
-                                                             nCells[startLayer],
-                                                             thrust::raw_pointer_cast(&updatedCellSeed[0]),
-                                                             thrust::raw_pointer_cast(&updatedCellId[0]),
-                                                             thrust::raw_pointer_cast(&foundSeedsTable[0]),
-                                                             usedClusters,
-                                                             neighbours[startLayer - 1],
-                                                             neighboursDeviceLUTs[startLayer - 1],
-                                                             foundTrackingFrameInfo,
-                                                             bz,
-                                                             maxChi2ClusterAttachment,
-                                                             propagator,
-                                                             matCorrType);
-  auto t1 = updatedCellSeed.size();
-  GPUChkErrS(cudaFree(d_temp_storage));
+  thrust::device_vector<int> foundSeedsTable(nCells[startLayer] + 1); // Shortcut: device_vector skips central memory management, we are relying on the contingency.
+                                                                      // TODO: fix this.
+
+  gpu::processNeighboursKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                       o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+    startLayer,
+    startLevel,
+    allCellSeeds,
+    currentCellSeeds,
+    nullptr,
+    nCells[startLayer],
+    nullptr,
+    nullptr,
+    thrust::raw_pointer_cast(&foundSeedsTable[0]),
+    usedClusters,
+    neighbours[startLayer - 1],
+    neighboursDeviceLUTs[startLayer - 1],
+    foundTrackingFrameInfo,
+    bz,
+    maxChi2ClusterAttachment,
+    propagator,
+    matCorrType);
+  gpu::cubExclusiveScanInPlace(foundSeedsTable, nCells[startLayer] + 1);
+
+  thrust::device_vector<int> updatedCellId(foundSeedsTable.back());
+  thrust::device_vector<CellSeed> updatedCellSeed(foundSeedsTable.back());
+  gpu::processNeighboursKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                        o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+    startLayer,
+    startLevel,
+    allCellSeeds,
+    currentCellSeeds,
+    nullptr,
+    nCells[startLayer],
+    thrust::raw_pointer_cast(&updatedCellSeed[0]),
+    thrust::raw_pointer_cast(&updatedCellId[0]),
+    thrust::raw_pointer_cast(&foundSeedsTable[0]),
+    usedClusters,
+    neighbours[startLayer - 1],
+    neighboursDeviceLUTs[startLayer - 1],
+    foundTrackingFrameInfo,
+    bz,
+    maxChi2ClusterAttachment,
+    propagator,
+    matCorrType);
+
   int level = startLevel;
+  thrust::device_vector<int> lastCellId;
+  thrust::device_vector<CellSeed> lastCellSeed;
   for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
-    temp_storage_bytes = 0;
     lastCellSeed.swap(updatedCellSeed);
     lastCellId.swap(updatedCellId);
     thrust::device_vector<CellSeed>().swap(updatedCellSeed);
     thrust::device_vector<int>().swap(updatedCellId);
     auto lastCellSeedSize{lastCellSeed.size()};
-    foundSeedsTable.resize(nCells[iLayer] + 1);
+    foundSeedsTable.resize(lastCellSeedSize + 1);
     thrust::fill(foundSeedsTable.begin(), foundSeedsTable.end(), 0);
-    --level;
-    gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(iLayer,
-                                                              level,
-                                                              allCellSeeds,
-                                                              thrust::raw_pointer_cast(&lastCellSeed[0]),
-                                                              thrust::raw_pointer_cast(&lastCellId[0]),
-                                                              lastCellSeedSize,
-                                                              nullptr,
-                                                              nullptr,
-                                                              thrust::raw_pointer_cast(&foundSeedsTable[0]),
-                                                              usedClusters,
-                                                              neighbours[iLayer - 1],
-                                                              neighboursDeviceLUTs[iLayer - 1],
-                                                              foundTrackingFrameInfo,
-                                                              bz,
-                                                              maxChi2ClusterAttachment,
-                                                              propagator,
-                                                              matCorrType);
-    GPUChkErrS(cub::DeviceScan::ExclusiveSum(nullptr,                                       // d_temp_storage
-                                             temp_storage_bytes,                            // temp_storage_bytes
-                                             thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
-                                             thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
-                                             nCells[iLayer] + 1,                            // num_items
-                                             0));                                           // NOLINT: this is the offset of the sum, not a pointer
-    GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-    GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage,                                // d_temp_storage
-                                             temp_storage_bytes,                            // temp_storage_bytes
-                                             thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_in
-                                             thrust::raw_pointer_cast(&foundSeedsTable[0]), // d_out
-                                             nCells[iLayer] + 1,                            // num_items
-                                             0));                                           // NOLINT: this is the offset of the sum, not a pointer
+
+    gpu::processNeighboursKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                         o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+      iLayer,
+      --level,
+      allCellSeeds,
+      thrust::raw_pointer_cast(&lastCellSeed[0]),
+      thrust::raw_pointer_cast(&lastCellId[0]),
+      lastCellSeedSize,
+      nullptr,
+      nullptr,
+      thrust::raw_pointer_cast(&foundSeedsTable[0]),
+      usedClusters,
+      neighbours[iLayer - 1],
+      neighboursDeviceLUTs[iLayer - 1],
+      foundTrackingFrameInfo,
+      bz,
+      maxChi2ClusterAttachment,
+      propagator,
+      matCorrType);
+    gpu::cubExclusiveScanInPlace(foundSeedsTable, foundSeedsTable.size());
+
     auto foundSeeds{foundSeedsTable.back()};
     updatedCellId.resize(foundSeeds);
     thrust::fill(updatedCellId.begin(), updatedCellId.end(), 0);
     updatedCellSeed.resize(foundSeeds);
     thrust::fill(updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed());
 
-    gpu::processNeighboursKernel<false><<<nBlocks, nThreads>>>(iLayer,
-                                                               level,
-                                                               allCellSeeds,
-                                                               thrust::raw_pointer_cast(&lastCellSeed[0]),
-                                                               thrust::raw_pointer_cast(&lastCellId[0]),
-                                                               lastCellSeedSize,
-                                                               thrust::raw_pointer_cast(&updatedCellSeed[0]),
-                                                               thrust::raw_pointer_cast(&updatedCellId[0]),
-                                                               thrust::raw_pointer_cast(&foundSeedsTable[0]),
-                                                               usedClusters,
-                                                               neighbours[iLayer - 1],
-                                                               neighboursDeviceLUTs[iLayer - 1],
-                                                               foundTrackingFrameInfo,
-                                                               bz,
-                                                               maxChi2ClusterAttachment,
-                                                               propagator,
-                                                               matCorrType);
-    GPUChkErrS(cudaFree(d_temp_storage));
+    gpu::processNeighboursKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                          o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+      iLayer,
+      level,
+      allCellSeeds,
+      thrust::raw_pointer_cast(&lastCellSeed[0]),
+      thrust::raw_pointer_cast(&lastCellId[0]),
+      lastCellSeedSize,
+      thrust::raw_pointer_cast(&updatedCellSeed[0]),
+      thrust::raw_pointer_cast(&updatedCellId[0]),
+      thrust::raw_pointer_cast(&foundSeedsTable[0]),
+      usedClusters,
+      neighbours[iLayer - 1],
+      neighboursDeviceLUTs[iLayer - 1],
+      foundTrackingFrameInfo,
+      bz,
+      maxChi2ClusterAttachment,
+      propagator,
+      matCorrType);
   }
+
   thrust::device_vector<CellSeed> outSeeds(updatedCellSeed.size());
   auto end = thrust::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
   auto s{end - outSeeds.begin()};
   std::vector<CellSeed> outSeedsHost(s);
-  thrust::copy(updatedCellSeed.begin(), updatedCellSeed.begin() + s, outSeedsHost.begin());
+  thrust::copy(outSeeds.begin(), outSeeds.begin() + s, outSeedsHost.begin());
   seedsHost.insert(seedsHost.end(), outSeedsHost.begin(), outSeedsHost.end());
 }
 
@@ -1339,7 +1277,8 @@ void trackSeedHandler(CellSeed* trackSeeds,
                       const int nThreads)
 {
   thrust::device_vector<float> minPts(minPtsHost);
-  gpu::fitTrackSeedsKernel<<<nBlocks, nThreads>>>(
+  gpu::fitTrackSeedsKernel<<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                             o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
     trackSeeds,                           // CellSeed*
     foundTrackingFrameInfo,               // TrackingFrameInfo**
     tracks,                               // TrackITSExt*
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 58483e4aa9f6f..8f0a471b40c59 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -50,21 +50,14 @@ class TrackerTraits;
 
 class Tracker
 {
+  using LogFunc = std::function<void(const std::string& s)>;
 
  public:
   Tracker(TrackerTraits* traits);
 
-  Tracker(const Tracker&) = delete;
-  Tracker& operator=(const Tracker&) = delete;
-  ~Tracker();
-
   void adoptTimeFrame(TimeFrame& tf);
 
-  void clustersToTracks(
-    std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; }, std::function<void(std::string s)> = [](std::string s) { std::cerr << s << std::endl; });
-  void clustersToTracksHybrid(
-    std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; }, std::function<void(std::string s)> = [](std::string s) { std::cerr << s << std::endl; });
-  std::vector<TrackITSExt>& getTracks();
+  void clustersToTracks(LogFunc = [](std::string s) { std::cout << s << std::endl; }, LogFunc = [](std::string s) { std::cerr << s << std::endl; });
 
   void setParameters(const std::vector<TrackingParameters>&);
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
@@ -74,7 +67,7 @@ class Tracker
   bool isMatLUT() const;
   void setNThreads(int n);
   int getNThreads() const;
-  std::uint32_t mTimeFrameCounter = 0;
+  void printSummary() const;
 
  private:
   void initialiseTimeFrame(int& iteration);
@@ -82,16 +75,7 @@ class Tracker
   void computeCells(int& iteration);
   void findCellsNeighbours(int& iteration);
   void findRoads(int& iteration);
-
-  void initialiseTimeFrameHybrid(int& iteration);
-  void computeTrackletsHybrid(int& iteration, int& iROFslice, int& iVertex);
-  void computeCellsHybrid(int& iteration);
-  void findCellsNeighboursHybrid(int& iteration);
-  void findRoadsHybrid(int& iteration);
-  void findTracksHybrid(int& iteration);
-
   void findShortPrimaries();
-  void findTracks();
   void extendTracks(int& iteration);
 
   // MC interaction
@@ -100,7 +84,7 @@ class Tracker
   void rectifyClusterIndices();
 
   template <typename... T>
-  float evaluateTask(void (Tracker::*)(T...), const char*, std::function<void(std::string s)> logger, T&&... args);
+  float evaluateTask(void (Tracker::*)(T...), const char*, LogFunc logger, T&&... args);
 
   TrackerTraits* mTraits = nullptr; /// Observer pointer, not owned by this class
   TimeFrame* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
@@ -108,7 +92,9 @@ class Tracker
   std::vector<TrackingParameters> mTrkParams;
   o2::gpu::GPUChainITS* mRecoChain = nullptr;
 
-  unsigned int mNumberOfRuns{0};
+  unsigned int mNumberOfDroppedTFs{0};
+  unsigned int mTimeFrameCounter{0};
+  double mTotalTime{0};
 };
 
 inline void Tracker::setParameters(const std::vector<TrackingParameters>& trkPars)
@@ -117,8 +103,7 @@ inline void Tracker::setParameters(const std::vector<TrackingParameters>& trkPar
 }
 
 template <typename... T>
-float Tracker::evaluateTask(void (Tracker::*task)(T...), const char* taskName, std::function<void(std::string s)> logger,
-                            T&&... args)
+float Tracker::evaluateTask(void (Tracker::*task)(T...), const char* taskName, LogFunc logger, T&&... args)
 {
   float diff{0.f};
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 46499db92d4d5..6b514c6e8d000 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -16,23 +16,12 @@
 #ifndef TRACKINGITSU_INCLUDE_TRACKERTRAITS_H_
 #define TRACKINGITSU_INCLUDE_TRACKERTRAITS_H_
 
-#include <array>
-#include <chrono>
 #include <cmath>
-#include <fstream>
-#include <iomanip>
-#include <iosfwd>
-#include <memory>
-#include <utility>
-#include <functional>
 
 #include "DetectorsBase/Propagator.h"
-#include "DetectorsBase/MatLayerCylSet.h"
 #include "ITStracking/Configuration.h"
-#include "ITStracking/Definitions.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/TimeFrame.h"
-#include "ITStracking/Road.h"
 
 // #define OPTIMISATION_OUTPUT
 
@@ -52,30 +41,29 @@ class TrackerTraits
   virtual ~TrackerTraits() = default;
   virtual void adoptTimeFrame(TimeFrame* tf);
   virtual void initialiseTimeFrame(const int iteration);
+
   virtual void computeLayerTracklets(const int iteration, int iROFslice, int iVertex);
   virtual void computeLayerCells(const int iteration);
   virtual void findCellsNeighbours(const int iteration);
   virtual void findRoads(const int iteration);
-  virtual void initialiseTimeFrameHybrid(const int iteration) { LOGP(error, "initialiseTimeFrameHybrid: this method should never be called with CPU traits"); }
-  virtual void computeTrackletsHybrid(const int iteration, int, int) { LOGP(error, "computeTrackletsHybrid: this method should never be called with CPU traits"); }
-  virtual void computeCellsHybrid(const int iteration) { LOGP(error, "computeCellsHybrid: this method should never be called with CPU traits"); }
-  virtual void findCellsNeighboursHybrid(const int iteration) { LOGP(error, "findCellsNeighboursHybrid: this method should never be called with CPU traits"); }
-  virtual void findRoadsHybrid(const int iteration) { LOGP(error, "findRoadsHybrid: this method should never be called with CPU traits"); }
-  virtual void findTracksHybrid(const int iteration) { LOGP(error, "findTracksHybrid: this method should never be called with CPU traits"); }
-  virtual void findTracks() { LOGP(error, "findTracks: this method is deprecated."); }
+
+  virtual bool supportsExtendTracks() const noexcept { return true; }
   virtual void extendTracks(const int iteration);
+  virtual bool supportsFindShortPrimaries() const noexcept { return true; }
   virtual void findShortPrimaries();
-  virtual void setBz(float bz);
+
   virtual bool trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration);
   virtual void processNeighbours(int iLayer, int iLevel, const std::vector<CellSeed>& currentCellSeed, const std::vector<int>& currentCellId, std::vector<CellSeed>& updatedCellSeed, std::vector<int>& updatedCellId);
 
   void UpdateTrackingParameters(const std::vector<TrackingParameters>& trkPars);
   TimeFrame* getTimeFrame() { return mTimeFrame; }
 
-  void setIsGPU(const unsigned char isgpu) { mIsGPU = isgpu; };
+  virtual void setBz(float bz);
   float getBz() const;
   void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mCorrType = type; }
   bool isMatLUT() const;
+  virtual const char* getName() const noexcept { return "CPU"; }
+  virtual bool isGPU() const noexcept { return false; }
 
   // Others
   GPUhd() static consteval int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
@@ -109,13 +97,11 @@ class TrackerTraits
   o2::gpu::GPUChainITS* mChain = nullptr;
   TimeFrame* mTimeFrame;
   std::vector<TrackingParameters> mTrkParams;
-  bool mIsGPU = false;
 };
 
 inline void TrackerTraits::initialiseTimeFrame(const int iteration)
 {
   mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers);
-  setIsGPU(false);
 }
 
 inline float TrackerTraits::getBz() const
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index b584bf6b8008b..6eacb94ebb1ea 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -37,9 +37,7 @@ class ITSTrackingInterface
                        const bool overrBeamEst)
     : mIsMC{isMC},
       mUseTriggers{trgType},
-      mOverrideBeamEstimation{overrBeamEst}
-  {
-  }
+      mOverrideBeamEstimation{overrBeamEst} {}
 
   void setClusterDictionary(const o2::itsmft::TopologyDictionary* d) { mDict = d; }
   void setMeanVertex(const o2::dataformats::MeanVertexObject* v)
@@ -56,6 +54,7 @@ class ITSTrackingInterface
   void initialise();
   template <bool isGPU = false>
   void run(framework::ProcessingContext& pc);
+  void printSummary() const;
 
   virtual void updateTimeDependentParams(framework::ProcessingContext& pc);
   virtual void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 50dc1f5dfd039..c23ba0576c625 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -25,8 +25,7 @@
 
 #include "ReconstructionDataFormats/Track.h"
 #include <cassert>
-#include <iostream>
-#include <dlfcn.h>
+#include <format>
 #include <cstdlib>
 #include <string>
 #include <climits>
@@ -37,17 +36,16 @@ namespace its
 {
 using o2::its::constants::GB;
 
-Tracker::Tracker(o2::its::TrackerTraits* traits)
+Tracker::Tracker(o2::its::TrackerTraits* traits) : mTraits(traits)
 {
   /// Initialise standard configuration with 1 iteration
   mTrkParams.resize(1);
-  mTraits = traits;
 }
 
-Tracker::~Tracker() = default;
-
-void Tracker::clustersToTracks(std::function<void(std::string s)> logger, std::function<void(std::string s)> error)
+void Tracker::clustersToTracks(LogFunc logger, LogFunc error)
 {
+  LogFunc evalLog = [](const std::string&) {};
+
   double total{0};
   mTraits->UpdateTrackingParameters(mTrkParams);
   int maxNvertices{-1};
@@ -62,22 +60,20 @@ void Tracker::clustersToTracks(std::function<void(std::string s)> logger, std::f
     if (iteration == 3 && mTrkParams[0].DoUPCIteration) {
       mTimeFrame->swapMasks();
     }
-    logger(fmt::format("ITS Tracking iteration {} summary:", iteration));
     double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
     int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
-
-    total += evaluateTask(&Tracker::initialiseTimeFrame, "Timeframe initialisation", logger, iteration);
     int nROFsIterations = mTrkParams[iteration].nROFsPerIterations > 0 ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
     int iVertex{std::min(maxNvertices, 0)};
+    logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
 
+    total += evaluateTask(&Tracker::initialiseTimeFrame, "Timeframe initialisation", logger, iteration);
     do {
       for (int iROFs{0}; iROFs < nROFsIterations; ++iROFs) {
-        timeTracklets += evaluateTask(
-          &Tracker::computeTracklets, "Tracklet finding", [](std::string) {}, iteration, iROFs, iVertex);
+        timeTracklets += evaluateTask(&Tracker::computeTracklets, "Tracklet finding", evalLog, iteration, iROFs, iVertex);
         nTracklets += mTraits->getTFNumberOfTracklets();
         if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
           mTimeFrame->printSliceInfo(iROFs, mTrkParams[iteration].nROFsPerIterations);
-          error(fmt::format("Too much memory used during trackleting in iteration {} in ROF span {}-{}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
+          error(std::format("Too much memory used during trackleting in iteration {} in ROF span {}-{}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
                             iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTimeFrame->getArtefactsMemory() / GB, mTrkParams[iteration].MaxMemory / GB));
           if (mTrkParams[iteration].DropTFUponFailure) {
             dropTF = true;
@@ -86,17 +82,16 @@ void Tracker::clustersToTracks(std::function<void(std::string s)> logger, std::f
         }
         float trackletsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfTracklets()) / mTraits->getTFNumberOfClusters() : 0.f;
         if (trackletsPerCluster > mTrkParams[iteration].TrackletsPerClusterLimit) {
-          error(fmt::format("Too many tracklets per cluster ({}) in iteration {} in ROF span {}-{}:, check the detector status and/or the selections. Current limit is {}",
+          error(std::format("Too many tracklets per cluster ({}) in iteration {} in ROF span {}-{}:, check the detector status and/or the selections. Current limit is {}",
                             trackletsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].TrackletsPerClusterLimit));
           break;
         }
 
-        timeCells += evaluateTask(
-          &Tracker::computeCells, "Cell finding", [](std::string) {}, iteration);
+        timeCells += evaluateTask(&Tracker::computeCells, "Cell finding", evalLog, iteration);
         nCells += mTraits->getTFNumberOfCells();
         if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
           mTimeFrame->printSliceInfo(iROFs, mTrkParams[iteration].nROFsPerIterations);
-          error(fmt::format("Too much memory used during cell finding in iteration {} in ROF span {}-{}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
+          error(std::format("Too much memory used during cell finding in iteration {} in ROF span {}-{}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
                             iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTimeFrame->getArtefactsMemory() / GB, mTrkParams[iteration].MaxMemory / GB));
           if (mTrkParams[iteration].DropTFUponFailure) {
             dropTF = true;
@@ -105,131 +100,53 @@ void Tracker::clustersToTracks(std::function<void(std::string s)> logger, std::f
         }
         float cellsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfCells()) / mTraits->getTFNumberOfClusters() : 0.f;
         if (cellsPerCluster > mTrkParams[iteration].CellsPerClusterLimit) {
-          error(fmt::format("Too many cells per cluster ({}) in iteration {} in ROF span {}-{}, check the detector status and/or the selections. Current limit is {}",
+          error(std::format("Too many cells per cluster ({}) in iteration {} in ROF span {}-{}, check the detector status and/or the selections. Current limit is {}",
                             cellsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].CellsPerClusterLimit));
           break;
         }
 
-        timeNeighbours += evaluateTask(
-          &Tracker::findCellsNeighbours, "Neighbour finding", [](std::string) {}, iteration);
+        timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, "Neighbour finding", evalLog, iteration);
         nNeighbours += mTimeFrame->getNumberOfNeighbours();
-        timeRoads += evaluateTask(
-          &Tracker::findRoads, "Road finding", [](std::string) {}, iteration);
+        timeRoads += evaluateTask(&Tracker::findRoads, "Road finding", evalLog, iteration);
       }
       iVertex++;
     } while (iVertex < maxNvertices && !dropTF);
-    logger(fmt::format(" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
-    logger(fmt::format(" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
-    logger(fmt::format(" - Neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
-    logger(fmt::format(" - Track finding: {} tracks found in {:.2f} ms", nTracks + mTimeFrame->getNumberOfTracks(), timeRoads));
+    logger(std::format(" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
+    logger(std::format(" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
+    logger(std::format(" - Neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
+    logger(std::format(" - Track finding: {} tracks found in {:.2f} ms", nTracks + mTimeFrame->getNumberOfTracks(), timeRoads));
     total += timeTracklets + timeCells + timeNeighbours + timeRoads;
-    if (mTrkParams[iteration].UseTrackFollower) {
+    if (mTraits->supportsExtendTracks() && mTrkParams[iteration].UseTrackFollower && !dropTF) {
       int nExtendedTracks{-mTimeFrame->mNExtendedTracks}, nExtendedClusters{-mTimeFrame->mNExtendedUsedClusters};
       auto timeExtending = evaluateTask(&Tracker::extendTracks, "Extending tracks", [](const std::string&) {}, iteration);
       total += timeExtending;
-      logger(fmt::format(" - Extending Tracks: {} extended tracks using {} clusters found in {:.2f} ms", nExtendedTracks + mTimeFrame->mNExtendedTracks, nExtendedClusters + mTimeFrame->mNExtendedUsedClusters, timeExtending));
+      logger(std::format(" - Extending Tracks: {} extended tracks using {} clusters found in {:.2f} ms", nExtendedTracks + mTimeFrame->mNExtendedTracks, nExtendedClusters + mTimeFrame->mNExtendedUsedClusters, timeExtending));
     }
     if (dropTF) {
-      error(fmt::format("...Dropping Timeframe..."));
+      error("...Dropping Timeframe...");
       mTimeFrame->dropTracks();
-      break; // breaking out the iterations loop
+      ++mNumberOfDroppedTFs;
+      return;
     }
   }
 
-  total += evaluateTask(&Tracker::findShortPrimaries, "Short primaries finding", logger);
-
-  std::stringstream sstream;
-  if constexpr (constants::DoTimeBenchmarks) {
-    sstream << std::setw(2) << " - "
-            << "Timeframe " << mTimeFrameCounter++ << " processing completed in: " << total << "ms using " << mTraits->getNThreads() << " threads.";
+  if (mTraits->supportsFindShortPrimaries() && mTrkParams[0].FindShortTracks) {
+    auto nTracksB = mTimeFrame->getNumberOfTracks();
+    total += evaluateTask(&Tracker::findShortPrimaries, "Short primaries finding", logger);
+    auto nTracksA = mTimeFrame->getNumberOfTracks();
+    logger(std::format("  `-> found {} additional tracks", nTracksA - nTracksB));
   }
-  logger(sstream.str());
 
-  if (mTimeFrame->hasMCinformation()) {
-    computeTracksMClabels();
-  }
-  rectifyClusterIndices();
-  mNumberOfRuns++;
-}
-
-void Tracker::clustersToTracksHybrid(std::function<void(std::string s)> logger, std::function<void(std::string s)> error)
-{
-  double total{0.};
-  mTraits->UpdateTrackingParameters(mTrkParams);
-  int maxNvertices{-1};
-  if (mTrkParams[0].PerPrimaryVertexProcessing) {
-    for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
-      maxNvertices = std::max(maxNvertices, (int)mTimeFrame->getPrimaryVertices(iROF).size());
-    }
-  }
-
-  for (int iteration = 0; iteration < (int)mTrkParams.size(); ++iteration) {
-    int nROFsIterations = mTrkParams[iteration].nROFsPerIterations > 0 ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
-    logger(fmt::format("=========== ITS Hybrid Tracking iteration {} summary ===========", iteration, nROFsIterations, maxNvertices));
-    double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
-    int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
-
-    total += evaluateTask(&Tracker::initialiseTimeFrameHybrid, "Hybrid Timeframe initialisation", logger, iteration);
-    int iVertex{std::min(maxNvertices, 0)};
-
-    do {
-      for (int iROFs{0}; iROFs < nROFsIterations; ++iROFs) {
-        timeTracklets += evaluateTask(
-          &Tracker::computeTrackletsHybrid, "Tracklet finding", [](std::string) {}, iteration, iROFs, iVertex);
-        nTracklets += mTraits->getTFNumberOfTracklets();
-        if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
-          error(fmt::format("Too much memory used during trackleting in iteration {}, check the detector status and/or the selections.", iteration));
-          break;
-        }
-        float trackletsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfTracklets()) / mTraits->getTFNumberOfClusters() : 0.f;
-        if (trackletsPerCluster > mTrkParams[iteration].TrackletsPerClusterLimit) {
-          error(fmt::format("Too many tracklets per cluster ({}) in iteration {}, check the detector status and/or the selections. Current limit is {}", trackletsPerCluster, iteration, mTrkParams[iteration].TrackletsPerClusterLimit));
-          break;
-        }
-
-        timeCells += evaluateTask(
-          &Tracker::computeCellsHybrid, "Cell finding", [](std::string) {}, iteration);
-        nCells += mTraits->getTFNumberOfCells();
-        if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
-          error(fmt::format("Too much memory used during cell finding in iteration {}, check the detector status and/or the selections.", iteration));
-          break;
-        }
-        float cellsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfCells()) / mTraits->getTFNumberOfClusters() : 0.f;
-        if (cellsPerCluster > mTrkParams[iteration].CellsPerClusterLimit) {
-          error(fmt::format("Too many cells per cluster ({}) in iteration {}, check the detector status and/or the selections. Current limit is {}", cellsPerCluster, iteration, mTrkParams[iteration].CellsPerClusterLimit));
-          break;
-        }
-
-        timeNeighbours += evaluateTask(
-          &Tracker::findCellsNeighboursHybrid, "Neighbour finding", [](std::string) {}, iteration);
-        nNeighbours += mTimeFrame->getNumberOfNeighbours();
-        timeRoads += evaluateTask(
-          &Tracker::findRoads, "Road finding", [](std::string) {}, iteration);
-      }
-      iVertex++;
-    } while (iVertex < maxNvertices);
-    logger(fmt::format(" - Hybrid tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
-    logger(fmt::format(" - Hybrid cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
-    logger(fmt::format(" - Hybrid neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
-    logger(fmt::format(" - Hybrid track finding: {} tracks found in {:.2f} ms", nTracks + mTimeFrame->getNumberOfTracks(), timeRoads));
-    total += timeTracklets + timeCells + timeNeighbours + timeRoads;
-    // total += evaluateTask(&Tracker::extendTracks, "Hybrid extending tracks", logger, iteration);
-  }
-
-  // total += evaluateTask(&Tracker::findShortPrimaries, "Hybrid short primaries finding", logger);
-
-  std::stringstream sstream;
   if constexpr (constants::DoTimeBenchmarks) {
-    sstream << std::setw(2) << " - "
-            << "Timeframe " << mTimeFrameCounter++ << " processing completed in: " << total << "ms using " << mTraits->getNThreads() << " threads.";
+    logger(std::format("=== TimeFrame {} processing completed in: {:.2f} ms using {} thread(s) ===", mTimeFrameCounter, total, mTraits->getNThreads()));
   }
-  logger(sstream.str());
 
   if (mTimeFrame->hasMCinformation()) {
     computeTracksMClabels();
   }
   rectifyClusterIndices();
-  mNumberOfRuns++;
+  ++mTimeFrameCounter;
+  mTotalTime += total;
 }
 
 void Tracker::initialiseTimeFrame(int& iteration)
@@ -257,41 +174,6 @@ void Tracker::findRoads(int& iteration)
   mTraits->findRoads(iteration);
 }
 
-void Tracker::initialiseTimeFrameHybrid(int& iteration)
-{
-  mTraits->initialiseTimeFrameHybrid(iteration);
-}
-
-void Tracker::computeTrackletsHybrid(int& iteration, int& iROFslice, int& iVertex)
-{
-  mTraits->computeTrackletsHybrid(iteration, iROFslice, iVertex); // placeholder for the proper ROF/vertex slicing
-}
-
-void Tracker::computeCellsHybrid(int& iteration)
-{
-  mTraits->computeCellsHybrid(iteration);
-}
-
-void Tracker::findCellsNeighboursHybrid(int& iteration)
-{
-  mTraits->findCellsNeighboursHybrid(iteration);
-}
-
-void Tracker::findRoadsHybrid(int& iteration)
-{
-  mTraits->findRoadsHybrid(iteration);
-}
-
-void Tracker::findTracksHybrid(int& iteration)
-{
-  mTraits->findTracksHybrid(iteration);
-}
-
-void Tracker::findTracks()
-{
-  mTraits->findTracks();
-}
-
 void Tracker::extendTracks(int& iteration)
 {
   mTraits->extendTracks(iteration);
@@ -575,5 +457,11 @@ int Tracker::getNThreads() const
 {
   return mTraits->getNThreads();
 }
+
+void Tracker::printSummary() const
+{
+  LOGP(info, "Tracker summary: Processed {} TFs (dropped {}) in TOT={:.2f} s, AVG/TF={:.2f} s", mTimeFrameCounter, mNumberOfDroppedTFs, mTotalTime * 1.e-3, mTotalTime * 1.e-3 / ((mTimeFrameCounter > 0) ? (double)mTimeFrameCounter : -1.0));
+}
+
 } // namespace its
 } // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 8dcb7bfd315c1..987e8e3128fb4 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -19,7 +19,9 @@
 #include <cassert>
 #include <iostream>
 
-#include <fmt/format.h>
+#ifdef OPTIMISATION_OUTPUT
+#include <format>
+#endif
 
 #include "CommonConstants/MathConstants.h"
 #include "DetectorsBase/Propagator.h"
@@ -38,7 +40,7 @@ using o2::base::PropagatorF;
 
 namespace
 {
-float Sq(float q)
+inline float Sq(float q)
 {
   return q * q;
 }
@@ -57,7 +59,7 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
 
 #ifdef OPTIMISATION_OUTPUT
   static int iter{0};
-  std::ofstream off(fmt::format("tracklets{}.txt", iter++));
+  std::ofstream off(std::format("tracklets{}.txt", iter++));
 #endif
 
   for (int iLayer = 0; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
@@ -173,7 +175,7 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
                     break;
                   }
                 }
-                off << fmt::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
+                off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
 #endif
 
                 if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
@@ -270,7 +272,7 @@ void TrackerTraits::computeLayerCells(const int iteration)
 {
 #ifdef OPTIMISATION_OUTPUT
   static int iter{0};
-  std::ofstream off(fmt::format("cells{}.txt", iter++));
+  std::ofstream off(std::format("cells{}.txt", iter++));
 #endif
 
   for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
@@ -318,7 +320,7 @@ void TrackerTraits::computeLayerCells(const int iteration)
 #ifdef OPTIMISATION_OUTPUT
         bool good{tf->getTrackletsLabel(iLayer)[iTracklet] == tf->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
         float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
-        off << fmt::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
+        off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
 #endif
 
         if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
@@ -402,7 +404,7 @@ void TrackerTraits::computeLayerCells(const int iteration)
 void TrackerTraits::findCellsNeighbours(const int iteration)
 {
 #ifdef OPTIMISATION_OUTPUT
-  std::ofstream off(fmt::format("cellneighs{}.txt", iteration));
+  std::ofstream off(std::format("cellneighs{}.txt", iteration));
 #endif
   for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
     const int nextLayerCellsNum{static_cast<int>(mTimeFrame->getCells()[iLayer + 1].size())};
@@ -439,7 +441,7 @@ void TrackerTraits::findCellsNeighbours(const int iteration)
 
 #ifdef OPTIMISATION_OUTPUT
         bool good{mTimeFrame->getCellsLabel(iLayer)[iCell] == mTimeFrame->getCellsLabel(iLayer + 1)[iNextCell]};
-        off << fmt::format("{}\t{:d}\t{}", iLayer, good, chi2) << std::endl;
+        off << std::format("{}\t{:d}\t{}", iLayer, good, chi2) << std::endl;
 #endif
 
         if (chi2 > mTrkParams[0].MaxChi2ClusterAttachment) {
@@ -469,6 +471,7 @@ void TrackerTraits::findCellsNeighbours(const int iteration)
 
 void TrackerTraits::processNeighbours(int iLayer, int iLevel, const std::vector<CellSeed>& currentCellSeed, const std::vector<int>& currentCellId, std::vector<CellSeed>& updatedCellSeeds, std::vector<int>& updatedCellsIds)
 {
+  bool print = iLayer == 3 && iLevel == 2;
   if (iLevel < 2 || iLayer < 1) {
     std::cout << "Error: layer " << iLayer << " or level " << iLevel << " cannot be processed by processNeighbours" << std::endl;
     exit(1);
@@ -723,10 +726,7 @@ void TrackerTraits::extendTracks(const int iteration)
 
 void TrackerTraits::findShortPrimaries()
 {
-  if (!mTrkParams[0].FindShortTracks) {
-    return;
-  }
-  auto propagator = o2::base::Propagator::Instance();
+  const auto propagator = o2::base::Propagator::Instance();
   mTimeFrame->fillPrimaryVerticesXandAlpha();
 
   for (auto& cell : mTimeFrame->getCells()[0]) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 613402ce56e97..f0dad2722a301 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -310,18 +310,10 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     mTimeFrame->setMultiplicityCutMask(processingMask);
     mTimeFrame->setROFMask(processUPCMask);
     // Run CA tracker
-    if constexpr (isGPU) {
-      if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
-        mTracker->clustersToTracksHybrid(logger, fatalLogger);
-      } else {
-        mTracker->clustersToTracksHybrid(logger, errorLogger);
-      }
+    if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
+      mTracker->clustersToTracks(logger, fatalLogger);
     } else {
-      if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
-        mTracker->clustersToTracks(logger, fatalLogger);
-      } else {
-        mTracker->clustersToTracks(logger, errorLogger);
-      }
+      mTracker->clustersToTracks(logger, errorLogger);
     }
     size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
     allTracks.reserve(totTracks);
@@ -438,6 +430,11 @@ void ITSTrackingInterface::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   }
 }
 
+void ITSTrackingInterface::printSummary() const
+{
+  mTracker->printSummary();
+}
+
 void ITSTrackingInterface::setTraitsFromProvider(VertexerTraits* vertexerTraits,
                                                  TrackerTraits* trackerTraits,
                                                  TimeFrame* frame)
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index 9e4c98ad6e9a1..abbb88aea42fa 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -48,6 +48,7 @@ void TrackerDPL::init(InitContext& ic)
 
 void TrackerDPL::stop()
 {
+  mITSTrackingInterface.printSummary();
   LOGF(info, "CPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
@@ -69,6 +70,7 @@ void TrackerDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 
 void TrackerDPL::endOfStream(EndOfStreamContext& ec)
 {
+  mITSTrackingInterface.printSummary();
   LOGF(info, "ITS CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 

From 7175de4628fc409f267ae9eb3ebd2ccbe163b569 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Thu, 24 Apr 2025 09:15:53 +0200
Subject: [PATCH 0293/1764] Fixing member variable naming (#14217)

* Fixing member variable naming

* Please consider the following formatting changes

* Changing to mPImplOrt

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Common/ML/include/ML/OrtInterface.h           |  30 +--
 Common/ML/src/OrtInterface.cxx                | 250 +++++++++---------
 .../Global/GPUChainTrackingClusterizer.cxx    | 172 ++++++------
 .../TPCClusterFinder/GPUTPCNNClusterizer.cxx  |  78 +++---
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |  56 ++--
 .../GPUTPCNNClusterizerHost.cxx               |  82 +++---
 .../GPUTPCNNClusterizerHost.h                 |  12 +-
 .../GPUTPCNNClusterizerKernels.cxx            | 210 +++++++--------
 8 files changed, 444 insertions(+), 446 deletions(-)

diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index ea70e28c0421c..b4f40f3f5c694 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -70,23 +70,23 @@ class OrtModel
   Ort::SessionOptions* getSessionOptions();
   Ort::MemoryInfo* getMemoryInfo();
   Ort::Env* getEnv();
-  int32_t getIntraOpNumThreads() const { return intraOpNumThreads; }
-  int32_t getInterOpNumThreads() const { return interOpNumThreads; }
+  int32_t getIntraOpNumThreads() const { return mIntraOpNumThreads; }
+  int32_t getInterOpNumThreads() const { return mInterOpNumThreads; }
 
   // Setters
-  void setDeviceId(int32_t id) { deviceId = id; }
+  void setDeviceId(int32_t id) { mDeviceId = id; }
   void setIO();
-  void setActiveThreads(int threads) { intraOpNumThreads = threads; }
+  void setActiveThreads(int threads) { mIntraOpNumThreads = threads; }
   void setIntraOpNumThreads(int threads)
   {
-    if (deviceType == "CPU") {
-      intraOpNumThreads = threads;
+    if (mDeviceType == "CPU") {
+      mIntraOpNumThreads = threads;
     }
   }
   void setInterOpNumThreads(int threads)
   {
-    if (deviceType == "CPU") {
-      interOpNumThreads = threads;
+    if (mDeviceType == "CPU") {
+      mInterOpNumThreads = threads;
     }
   }
   void setEnv(Ort::Env*);
@@ -113,19 +113,19 @@ class OrtModel
  private:
   // ORT variables -> need to be hidden as pImpl
   struct OrtVariables;
-  OrtVariables* pImplOrt;
+  OrtVariables* mPImplOrt;
 
   // Input & Output specifications of the loaded network
-  std::vector<const char*> inputNamesChar, outputNamesChar;
+  std::vector<const char*> mInputNamesChar, mOutputNamesChar;
   std::vector<std::string> mInputNames, mOutputNames;
-  std::vector<std::vector<int64_t>> mInputShapes, mOutputShapes, inputShapesCopy, outputShapesCopy; // Input shapes
-  std::vector<int64_t> inputSizePerNode, outputSizePerNode;                                         // Output shapes
-  int32_t mInputsTotal = 0, mOutputsTotal = 0;                                                      // Total number of inputs and outputs
+  std::vector<std::vector<int64_t>> mInputShapes, mOutputShapes, mInputShapesCopy, mOutputShapesCopy; // Input shapes
+  std::vector<int64_t> mInputSizePerNode, mOutputSizePerNode;                                         // Output shapes
+  int32_t mInputsTotal = 0, mOutputsTotal = 0;                                                        // Total number of inputs and outputs
 
   // Environment settings
   bool mInitialized = false;
-  std::string modelPath, envName = "", deviceType = "CPU", thread_affinity = ""; // device options should be cpu, rocm, migraphx, cuda
-  int32_t intraOpNumThreads = 1, interOpNumThreads = 1, deviceId = -1, enableProfiling = 0, loggingLevel = 0, allocateDeviceMemory = 0, enableOptimizations = 0;
+  std::string mModelPath, mEnvName = "", mDeviceType = "CPU", mThreadAffinity = ""; // device options should be cpu, rocm, migraphx, cuda
+  int32_t mIntraOpNumThreads = 1, mInterOpNumThreads = 1, mDeviceId = -1, mEnableProfiling = 0, mLoggingLevel = 0, mAllocateDeviceMemory = 0, mEnableOptimizations = 0;
 
   std::string printShape(const std::vector<int64_t>&);
   std::string printShape(const std::vector<std::vector<int64_t>>&, std::vector<std::string>&);
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index a8a20b11f9e64..df7f0a2deba82 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -41,7 +41,7 @@ struct OrtModel::OrtVariables { // The actual implementation is hidden in the .c
 // General purpose
 void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsMap)
 {
-  pImplOrt = new OrtVariables();
+  mPImplOrt = new OrtVariables();
 
   // Load from options map
   if (!optionsMap.contains("model-path")) {
@@ -49,49 +49,49 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
   }
 
   if (!optionsMap["model-path"].empty()) {
-    modelPath = optionsMap["model-path"];
-    deviceType = (optionsMap.contains("device-type") ? optionsMap["device-type"] : "CPU");
-    deviceId = (optionsMap.contains("device-id") ? std::stoi(optionsMap["device-id"]) : -1);
-    allocateDeviceMemory = (optionsMap.contains("allocate-device-memory") ? std::stoi(optionsMap["allocate-device-memory"]) : 0);
-    intraOpNumThreads = (optionsMap.contains("intra-op-num-threads") ? std::stoi(optionsMap["intra-op-num-threads"]) : 0);
-    interOpNumThreads = (optionsMap.contains("inter-op-num-threads") ? std::stoi(optionsMap["inter-op-num-threads"]) : 0);
-    loggingLevel = (optionsMap.contains("logging-level") ? std::stoi(optionsMap["logging-level"]) : 0);
-    enableProfiling = (optionsMap.contains("enable-profiling") ? std::stoi(optionsMap["enable-profiling"]) : 0);
-    enableOptimizations = (optionsMap.contains("enable-optimizations") ? std::stoi(optionsMap["enable-optimizations"]) : 0);
-    envName = (optionsMap.contains("onnx-environment-name") ? optionsMap["onnx-environment-name"] : "onnx_model_inference");
-
-    if (deviceType == "CPU") {
-      (pImplOrt->sessionOptions).SetIntraOpNumThreads(intraOpNumThreads);
-      (pImplOrt->sessionOptions).SetInterOpNumThreads(interOpNumThreads);
-      if (intraOpNumThreads > 1 || interOpNumThreads > 1) {
-        (pImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_PARALLEL);
-      } else if (intraOpNumThreads == 1) {
-        (pImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_SEQUENTIAL);
+    mModelPath = optionsMap["model-path"];
+    mDeviceType = (optionsMap.contains("device-type") ? optionsMap["device-type"] : "CPU");
+    mDeviceId = (optionsMap.contains("device-id") ? std::stoi(optionsMap["device-id"]) : -1);
+    mAllocateDeviceMemory = (optionsMap.contains("allocate-device-memory") ? std::stoi(optionsMap["allocate-device-memory"]) : 0);
+    mIntraOpNumThreads = (optionsMap.contains("intra-op-num-threads") ? std::stoi(optionsMap["intra-op-num-threads"]) : 0);
+    mInterOpNumThreads = (optionsMap.contains("inter-op-num-threads") ? std::stoi(optionsMap["inter-op-num-threads"]) : 0);
+    mLoggingLevel = (optionsMap.contains("logging-level") ? std::stoi(optionsMap["logging-level"]) : 0);
+    mEnableProfiling = (optionsMap.contains("enable-profiling") ? std::stoi(optionsMap["enable-profiling"]) : 0);
+    mEnableOptimizations = (optionsMap.contains("enable-optimizations") ? std::stoi(optionsMap["enable-optimizations"]) : 0);
+    mEnvName = (optionsMap.contains("onnx-environment-name") ? optionsMap["onnx-environment-name"] : "onnx_model_inference");
+
+    if (mDeviceType == "CPU") {
+      (mPImplOrt->sessionOptions).SetIntraOpNumThreads(mIntraOpNumThreads);
+      (mPImplOrt->sessionOptions).SetInterOpNumThreads(mInterOpNumThreads);
+      if (mIntraOpNumThreads > 1 || mInterOpNumThreads > 1) {
+        (mPImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_PARALLEL);
+      } else if (mIntraOpNumThreads == 1) {
+        (mPImplOrt->sessionOptions).SetExecutionMode(ExecutionMode::ORT_SEQUENTIAL);
       }
-      if (loggingLevel < 2) {
-        LOG(info) << "(ORT) CPU execution provider set with " << intraOpNumThreads << " (intraOpNumThreads) and " << interOpNumThreads << " (interOpNumThreads) threads";
+      if (mLoggingLevel < 2) {
+        LOG(info) << "(ORT) CPU execution provider set with " << mIntraOpNumThreads << " (mIntraOpNumThreads) and " << mInterOpNumThreads << " (mInterOpNumThreads) threads";
       }
     }
 
     // OrtROCMProviderOptions rocm_options{};
-    // (pImplOrt->sessionOptions).AppendExecutionProvider_ROCM(rocm_options);
+    // (mPImplOrt->sessionOptions).AppendExecutionProvider_ROCM(rocm_options);
 
-    (pImplOrt->sessionOptions).DisableMemPattern();
-    (pImplOrt->sessionOptions).DisableCpuMemArena();
+    (mPImplOrt->sessionOptions).DisableMemPattern();
+    (mPImplOrt->sessionOptions).DisableCpuMemArena();
 
-    if (enableProfiling) {
+    if (mEnableProfiling) {
       if (optionsMap.contains("profiling-output-path")) {
-        (pImplOrt->sessionOptions).EnableProfiling((optionsMap["profiling-output-path"] + "/ORT_LOG_").c_str());
+        (mPImplOrt->sessionOptions).EnableProfiling((optionsMap["profiling-output-path"] + "/ORT_LOG_").c_str());
       } else {
         LOG(warning) << "(ORT) If profiling is enabled, optionsMap[\"profiling-output-path\"] should be set. Disabling profiling for now.";
-        (pImplOrt->sessionOptions).DisableProfiling();
+        (mPImplOrt->sessionOptions).DisableProfiling();
       }
     } else {
-      (pImplOrt->sessionOptions).DisableProfiling();
+      (mPImplOrt->sessionOptions).DisableProfiling();
     }
 
-    (pImplOrt->sessionOptions).SetGraphOptimizationLevel(GraphOptimizationLevel(enableOptimizations));
-    (pImplOrt->sessionOptions).SetLogSeverityLevel(OrtLoggingLevel(loggingLevel));
+    (mPImplOrt->sessionOptions).SetGraphOptimizationLevel(GraphOptimizationLevel(mEnableOptimizations));
+    (mPImplOrt->sessionOptions).SetLogSeverityLevel(OrtLoggingLevel(mLoggingLevel));
 
     mInitialized = true;
   } else {
@@ -101,9 +101,9 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
 
 void OrtModel::initEnvironment()
 {
-  pImplOrt->env = std::make_shared<Ort::Env>(
-    OrtLoggingLevel(loggingLevel),
-    (envName.empty() ? "ORT" : envName.c_str()),
+  mPImplOrt->env = std::make_shared<Ort::Env>(
+    OrtLoggingLevel(mLoggingLevel),
+    (mEnvName.empty() ? "ORT" : mEnvName.c_str()),
     // Integrate ORT logging into Fairlogger
     [](void* param, OrtLoggingLevel severity, const char* category, const char* logid, const char* code_location, const char* message) {
       if (severity == ORT_LOGGING_LEVEL_VERBOSE) {
@@ -121,20 +121,20 @@ void OrtModel::initEnvironment()
       }
     },
     (void*)3);
-  (pImplOrt->env)->DisableTelemetryEvents(); // Disable telemetry events
+  (mPImplOrt->env)->DisableTelemetryEvents(); // Disable telemetry events
 }
 
 void OrtModel::initSession()
 {
-  if (allocateDeviceMemory) {
-    memoryOnDevice(deviceId);
+  if (mAllocateDeviceMemory) {
+    memoryOnDevice(mDeviceId);
   }
-  pImplOrt->session = std::make_shared<Ort::Session>(*pImplOrt->env, modelPath.c_str(), pImplOrt->sessionOptions);
-  pImplOrt->ioBinding = std::make_unique<Ort::IoBinding>(*pImplOrt->session);
+  mPImplOrt->session = std::make_shared<Ort::Session>(*mPImplOrt->env, mModelPath.c_str(), mPImplOrt->sessionOptions);
+  mPImplOrt->ioBinding = std::make_unique<Ort::IoBinding>(*mPImplOrt->session);
 
   setIO();
 
-  if (loggingLevel < 2) {
+  if (mLoggingLevel < 2) {
     LOG(info) << "(ORT) Model loaded successfully! (inputs: " << printShape(mInputShapes, mInputNames) << ", outputs: " << printShape(mOutputShapes, mInputNames) << ")";
   }
 }
@@ -142,47 +142,47 @@ void OrtModel::initSession()
 void OrtModel::memoryOnDevice(int32_t deviceIndex)
 {
   if (deviceIndex >= 0) {
-    (pImplOrt->runOptions).AddConfigEntry("disable_synchronize_execution_providers", "1");
-    (pImplOrt->sessionOptions).AddConfigEntry("session.use_device_allocator_for_initializers", "1"); // See kOrtSessionOptionsUseDeviceAllocatorForInitializers, https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/onnxruntime_session_options_config_keys.h
-    (pImplOrt->sessionOptions).AddConfigEntry("session.use_env_allocators", "1");                    // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
-    (pImplOrt->sessionOptions).AddConfigEntry("session_options.enable_cpu_mem_arena", "0");          // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
+    (mPImplOrt->runOptions).AddConfigEntry("disable_synchronize_execution_providers", "1");
+    (mPImplOrt->sessionOptions).AddConfigEntry("session.use_device_allocator_for_initializers", "1"); // See kOrtSessionOptionsUseDeviceAllocatorForInitializers, https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/session/onnxruntime_session_options_config_keys.h
+    (mPImplOrt->sessionOptions).AddConfigEntry("session.use_env_allocators", "1");                    // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
+    (mPImplOrt->sessionOptions).AddConfigEntry("session_options.enable_cpu_mem_arena", "0");          // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
     // Arena memory shrinkage comes at performance cost
     /// For now prefer to use single allocation, enabled by O2/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu -> SetONNXGPUStream -> rocm_options.arena_extend_strategy = 0;
-    // (pImplOrt->runOptions).AddConfigEntry("memory.enable_memory_arena_shrinkage", ("gpu:" + std::to_string(deviceIndex)).c_str()); // See kOrtRunOptionsConfigEnableMemoryArenaShrinkage, https://github.com/microsoft/onnxruntime/blob/90c263f471bbce724e77d8e62831d3a9fa838b2f/include/onnxruntime/core/session/onnxruntime_run_options_config_keys.h#L27
+    // (mPImplOrt->runOptions).AddConfigEntry("memory.enable_memory_arena_shrinkage", ("gpu:" + std::to_string(deviceIndex)).c_str()); // See kOrtRunOptionsConfigEnableMemoryArenaShrinkage, https://github.com/microsoft/onnxruntime/blob/90c263f471bbce724e77d8e62831d3a9fa838b2f/include/onnxruntime/core/session/onnxruntime_run_options_config_keys.h#L27
 
     std::string dev_mem_str = "";
-    if (deviceType == "ROCM") {
+    if (mDeviceType == "ROCM") {
       dev_mem_str = "Hip";
     }
-    if (deviceType == "CUDA") {
+    if (mDeviceType == "CUDA") {
       dev_mem_str = "Cuda";
     }
-    pImplOrt->memoryInfo = Ort::MemoryInfo(dev_mem_str.c_str(), OrtAllocatorType::OrtDeviceAllocator, deviceIndex, OrtMemType::OrtMemTypeDefault);
-    if (loggingLevel < 2) {
-      LOG(info) << "(ORT) Memory info set to on-device memory for device type " << deviceType << " with ID " << deviceIndex << " and pImplOrt pointer " << pImplOrt;
+    mPImplOrt->memoryInfo = Ort::MemoryInfo(dev_mem_str.c_str(), OrtAllocatorType::OrtDeviceAllocator, deviceIndex, OrtMemType::OrtMemTypeDefault);
+    if (mLoggingLevel < 2) {
+      LOG(info) << "(ORT) Memory info set to on-device memory for device type " << mDeviceType << " with ID " << deviceIndex << " and mPImplOrt pointer " << mPImplOrt;
     }
   }
 }
 
 void OrtModel::resetSession()
 {
-  pImplOrt->session = std::make_shared<Ort::Session>(*(pImplOrt->env), modelPath.c_str(), pImplOrt->sessionOptions);
+  mPImplOrt->session = std::make_shared<Ort::Session>(*(mPImplOrt->env), mModelPath.c_str(), mPImplOrt->sessionOptions);
 }
 
 // Getters
 Ort::SessionOptions* OrtModel::getSessionOptions()
 {
-  return &pImplOrt->sessionOptions;
+  return &mPImplOrt->sessionOptions;
 }
 
 Ort::MemoryInfo* OrtModel::getMemoryInfo()
 {
-  return &pImplOrt->memoryInfo;
+  return &mPImplOrt->memoryInfo;
 }
 
 Ort::Env* OrtModel::getEnv()
 {
-  return (pImplOrt->env).get();
+  return (mPImplOrt->env).get();
 }
 
 template <class I, class O>
@@ -202,37 +202,37 @@ std::vector<O> OrtModel::v2v(std::vector<I>& input, bool clearInput)
 
 void OrtModel::setIO()
 {
-  for (size_t i = 0; i < (pImplOrt->session)->GetInputCount(); ++i) {
-    mInputNames.push_back((pImplOrt->session)->GetInputNameAllocated(i, pImplOrt->allocator).get());
+  for (size_t i = 0; i < (mPImplOrt->session)->GetInputCount(); ++i) {
+    mInputNames.push_back((mPImplOrt->session)->GetInputNameAllocated(i, mPImplOrt->allocator).get());
   }
-  for (size_t i = 0; i < (pImplOrt->session)->GetInputCount(); ++i) {
-    mInputShapes.emplace_back((pImplOrt->session)->GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape());
+  for (size_t i = 0; i < (mPImplOrt->session)->GetInputCount(); ++i) {
+    mInputShapes.emplace_back((mPImplOrt->session)->GetInputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape());
   }
-  for (size_t i = 0; i < (pImplOrt->session)->GetOutputCount(); ++i) {
-    mOutputNames.push_back((pImplOrt->session)->GetOutputNameAllocated(i, pImplOrt->allocator).get());
+  for (size_t i = 0; i < (mPImplOrt->session)->GetOutputCount(); ++i) {
+    mOutputNames.push_back((mPImplOrt->session)->GetOutputNameAllocated(i, mPImplOrt->allocator).get());
   }
-  for (size_t i = 0; i < (pImplOrt->session)->GetOutputCount(); ++i) {
-    mOutputShapes.emplace_back((pImplOrt->session)->GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape());
+  for (size_t i = 0; i < (mPImplOrt->session)->GetOutputCount(); ++i) {
+    mOutputShapes.emplace_back((mPImplOrt->session)->GetOutputTypeInfo(i).GetTensorTypeAndShapeInfo().GetShape());
   }
 
-  inputNamesChar.resize(mInputNames.size(), nullptr);
-  std::transform(std::begin(mInputNames), std::end(mInputNames), std::begin(inputNamesChar),
+  mInputNamesChar.resize(mInputNames.size(), nullptr);
+  std::transform(std::begin(mInputNames), std::end(mInputNames), std::begin(mInputNamesChar),
                  [&](const std::string& str) { return str.c_str(); });
-  outputNamesChar.resize(mOutputNames.size(), nullptr);
-  std::transform(std::begin(mOutputNames), std::end(mOutputNames), std::begin(outputNamesChar),
+  mOutputNamesChar.resize(mOutputNames.size(), nullptr);
+  std::transform(std::begin(mOutputNames), std::end(mOutputNames), std::begin(mOutputNamesChar),
                  [&](const std::string& str) { return str.c_str(); });
 
-  inputShapesCopy = mInputShapes;
-  outputShapesCopy = mOutputShapes;
-  inputSizePerNode.resize(mInputShapes.size(), 1);
-  outputSizePerNode.resize(mOutputShapes.size(), 1);
+  mInputShapesCopy = mInputShapes;
+  mOutputShapesCopy = mOutputShapes;
+  mInputSizePerNode.resize(mInputShapes.size(), 1);
+  mOutputSizePerNode.resize(mOutputShapes.size(), 1);
   mInputsTotal = 1;
   for (size_t i = 0; i < mInputShapes.size(); ++i) {
     if (mInputShapes[i].size() > 0) {
       for (size_t j = 1; j < mInputShapes[i].size(); ++j) {
         if (mInputShapes[i][j] > 0) {
           mInputsTotal *= mInputShapes[i][j];
-          inputSizePerNode[i] *= mInputShapes[i][j];
+          mInputSizePerNode[i] *= mInputShapes[i][j];
         }
       }
     }
@@ -243,7 +243,7 @@ void OrtModel::setIO()
       for (size_t j = 1; j < mOutputShapes[i].size(); ++j) {
         if (mOutputShapes[i][j] > 0) {
           mOutputsTotal *= mOutputShapes[i][j];
-          outputSizePerNode[i] *= mOutputShapes[i][j];
+          mOutputSizePerNode[i] *= mOutputShapes[i][j];
         }
       }
     }
@@ -252,7 +252,7 @@ void OrtModel::setIO()
 
 void OrtModel::setEnv(Ort::Env* env)
 {
-  pImplOrt->env = std::shared_ptr<Ort::Env>(env);
+  mPImplOrt->env = std::shared_ptr<Ort::Env>(env);
 }
 
 // Inference
@@ -266,12 +266,12 @@ std::vector<O> OrtModel::inference(std::vector<I>& input)
   }
   std::vector<Ort::Value> inputTensor;
   if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
-    inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input.data()), input.size(), inputShape.data(), inputShape.size()));
+    inputTensor.emplace_back(Ort::Value::CreateTensor<Ort::Float16_t>(mPImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input.data()), input.size(), inputShape.data(), inputShape.size()));
   } else {
-    inputTensor.emplace_back(Ort::Value::CreateTensor<I>(pImplOrt->memoryInfo, input.data(), input.size(), inputShape.data(), inputShape.size()));
+    inputTensor.emplace_back(Ort::Value::CreateTensor<I>(mPImplOrt->memoryInfo, input.data(), input.size(), inputShape.data(), inputShape.size()));
   }
   // input.clear();
-  auto outputTensors = (pImplOrt->session)->Run(pImplOrt->runOptions, inputNamesChar.data(), inputTensor.data(), inputTensor.size(), outputNamesChar.data(), outputNamesChar.size());
+  auto outputTensors = (mPImplOrt->session)->Run(mPImplOrt->runOptions, mInputNamesChar.data(), inputTensor.data(), inputTensor.size(), mOutputNamesChar.data(), mOutputNamesChar.size());
   O* outputValues = outputTensors[0].template GetTensorMutableData<O>();
   std::vector<O> outputValuesVec{outputValues, outputValues + inputShape[0] * mOutputShapes[0][1]};
   outputTensors.clear();
@@ -292,22 +292,22 @@ void OrtModel::inference(I* input, int64_t input_size, O* output)
   std::vector<int64_t> inputShape{input_size, (int64_t)mInputShapes[0][1]};
   Ort::Value inputTensor = Ort::Value(nullptr);
   if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
-    inputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input), input_size * mInputShapes[0][1], inputShape.data(), inputShape.size());
+    inputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(mPImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(input), input_size * mInputShapes[0][1], inputShape.data(), inputShape.size());
   } else {
-    inputTensor = Ort::Value::CreateTensor<I>(pImplOrt->memoryInfo, input, input_size * mInputShapes[0][1], inputShape.data(), inputShape.size());
+    inputTensor = Ort::Value::CreateTensor<I>(mPImplOrt->memoryInfo, input, input_size * mInputShapes[0][1], inputShape.data(), inputShape.size());
   }
-  (pImplOrt->ioBinding)->BindInput(mInputNames[0].c_str(), inputTensor);
+  (mPImplOrt->ioBinding)->BindInput(mInputNames[0].c_str(), inputTensor);
 
   std::vector<int64_t> outputShape{input_size, mOutputShapes[0][1]};
   Ort::Value outputTensor = Ort::Value(nullptr);
   if constexpr (std::is_same_v<O, OrtDataType::Float16_t>) {
-    outputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(pImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(output), input_size * mOutputShapes[0][1], outputShape.data(), outputShape.size());
+    outputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(mPImplOrt->memoryInfo, reinterpret_cast<Ort::Float16_t*>(output), input_size * mOutputShapes[0][1], outputShape.data(), outputShape.size());
   } else {
-    outputTensor = Ort::Value::CreateTensor<O>(pImplOrt->memoryInfo, output, input_size * mOutputShapes[0][1], outputShape.data(), outputShape.size());
+    outputTensor = Ort::Value::CreateTensor<O>(mPImplOrt->memoryInfo, output, input_size * mOutputShapes[0][1], outputShape.data(), outputShape.size());
   }
-  (pImplOrt->ioBinding)->BindOutput(mOutputNames[0].c_str(), outputTensor);
+  (mPImplOrt->ioBinding)->BindOutput(mOutputNames[0].c_str(), outputTensor);
 
-  (pImplOrt->session)->Run(pImplOrt->runOptions, *pImplOrt->ioBinding);
+  (mPImplOrt->session)->Run(mPImplOrt->runOptions, *mPImplOrt->ioBinding);
 }
 
 template void OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(OrtDataType::Float16_t*, int64_t, OrtDataType::Float16_t*);
@@ -318,56 +318,56 @@ template void OrtModel::inference<float, float>(float*, int64_t, float*);
 template <class I, class O>
 void OrtModel::inference(I** input, int64_t input_size, O* output)
 {
-  std::vector<Ort::Value> inputTensors(inputShapesCopy.size());
+  std::vector<Ort::Value> inputTensors(mInputShapesCopy.size());
 
-  for (size_t i = 0; i < inputShapesCopy.size(); ++i) {
+  for (size_t i = 0; i < mInputShapesCopy.size(); ++i) {
 
-    inputShapesCopy[i][0] = input_size;  // batch-size
-    outputShapesCopy[i][0] = input_size; // batch-size
+    mInputShapesCopy[i][0] = input_size;  // batch-size
+    mOutputShapesCopy[i][0] = input_size; // batch-size
 
     if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
       inputTensors[i] = Ort::Value::CreateTensor<Ort::Float16_t>(
-        pImplOrt->memoryInfo,
+        mPImplOrt->memoryInfo,
         reinterpret_cast<Ort::Float16_t*>(input[i]),
-        inputSizePerNode[i] * input_size,
-        inputShapesCopy[i].data(),
-        inputShapesCopy[i].size());
+        mInputSizePerNode[i] * input_size,
+        mInputShapesCopy[i].data(),
+        mInputShapesCopy[i].size());
     } else {
       inputTensors[i] = Ort::Value::CreateTensor<I>(
-        pImplOrt->memoryInfo,
+        mPImplOrt->memoryInfo,
         input[i],
-        inputSizePerNode[i] * input_size,
-        inputShapesCopy[i].data(),
-        inputShapesCopy[i].size());
+        mInputSizePerNode[i] * input_size,
+        mInputShapesCopy[i].data(),
+        mInputShapesCopy[i].size());
     }
   }
 
   Ort::Value outputTensor = Ort::Value(nullptr);
   if constexpr (std::is_same_v<O, OrtDataType::Float16_t>) {
     outputTensor = Ort::Value::CreateTensor<Ort::Float16_t>(
-      pImplOrt->memoryInfo,
+      mPImplOrt->memoryInfo,
       reinterpret_cast<Ort::Float16_t*>(output),
-      outputSizePerNode[0] * input_size, // assumes that there is only one output node
-      outputShapesCopy[0].data(),
-      outputShapesCopy[0].size());
+      mOutputSizePerNode[0] * input_size, // assumes that there is only one output node
+      mOutputShapesCopy[0].data(),
+      mOutputShapesCopy[0].size());
   } else {
     outputTensor = Ort::Value::CreateTensor<O>(
-      pImplOrt->memoryInfo,
+      mPImplOrt->memoryInfo,
       output,
-      outputSizePerNode[0] * input_size, // assumes that there is only one output node
-      outputShapesCopy[0].data(),
-      outputShapesCopy[0].size());
+      mOutputSizePerNode[0] * input_size, // assumes that there is only one output node
+      mOutputShapesCopy[0].data(),
+      mOutputShapesCopy[0].size());
   }
 
   // === Run inference ===
-  pImplOrt->session->Run(
-    pImplOrt->runOptions,
-    inputNamesChar.data(),
+  mPImplOrt->session->Run(
+    mPImplOrt->runOptions,
+    mInputNamesChar.data(),
     inputTensors.data(),
-    inputNamesChar.size(),
-    outputNamesChar.data(),
+    mInputNamesChar.size(),
+    mOutputNamesChar.data(),
     &outputTensor,
-    outputNamesChar.size());
+    mOutputNamesChar.size());
 }
 
 template void OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(OrtDataType::Float16_t**, int64_t, OrtDataType::Float16_t*);
@@ -382,37 +382,37 @@ std::vector<O> OrtModel::inference(std::vector<std::vector<I>>& inputs)
 
   for (size_t i = 0; i < inputs.size(); ++i) {
 
-    inputShapesCopy[i][0] = inputs[i].size() / inputSizePerNode[i]; // batch-size
+    mInputShapesCopy[i][0] = inputs[i].size() / mInputSizePerNode[i]; // batch-size
 
     if constexpr (std::is_same_v<I, OrtDataType::Float16_t>) {
       input_tensors.emplace_back(
         Ort::Value::CreateTensor<Ort::Float16_t>(
-          pImplOrt->memoryInfo,
+          mPImplOrt->memoryInfo,
           reinterpret_cast<Ort::Float16_t*>(inputs[i].data()),
-          inputSizePerNode[i] * inputShapesCopy[i][0],
-          inputShapesCopy[i].data(),
-          inputShapesCopy[i].size()));
+          mInputSizePerNode[i] * mInputShapesCopy[i][0],
+          mInputShapesCopy[i].data(),
+          mInputShapesCopy[i].size()));
     } else {
       input_tensors.emplace_back(
         Ort::Value::CreateTensor<I>(
-          pImplOrt->memoryInfo,
+          mPImplOrt->memoryInfo,
           inputs[i].data(),
-          inputSizePerNode[i] * inputShapesCopy[i][0],
-          inputShapesCopy[i].data(),
-          inputShapesCopy[i].size()));
+          mInputSizePerNode[i] * mInputShapesCopy[i][0],
+          mInputShapesCopy[i].data(),
+          mInputShapesCopy[i].size()));
     }
   }
 
-  int32_t totalOutputSize = mOutputsTotal * inputShapesCopy[0][0];
+  int32_t totalOutputSize = mOutputsTotal * mInputShapesCopy[0][0];
 
   // === Run inference ===
-  auto output_tensors = pImplOrt->session->Run(
-    pImplOrt->runOptions,
-    inputNamesChar.data(),
+  auto output_tensors = mPImplOrt->session->Run(
+    mPImplOrt->runOptions,
+    mInputNamesChar.data(),
     input_tensors.data(),
     input_tensors.size(),
-    outputNamesChar.data(),
-    outputNamesChar.size());
+    mOutputNamesChar.data(),
+    mOutputNamesChar.size());
 
   // === Extract output values ===
   O* output_data = output_tensors[0].template GetTensorMutableData<O>();
@@ -428,9 +428,9 @@ template std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Fl
 void OrtModel::release(bool profilingEnabled)
 {
   // if (profilingEnabled) {
-  //   pImplOrt->session->EndProfiling();
+  //   mPImplOrt->session->EndProfiling();
   // }
-  LOG(info) << "(ORT) Size of pImplOrt: " << sizeof(*pImplOrt) << " bytes";
+  LOG(info) << "(ORT) Size of mPImplOrt: " << sizeof(*mPImplOrt) << " bytes";
 }
 
 // private
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 37c12b2a3b3f4..630c2200e5900 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -645,41 +645,41 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     // bool recreateMemoryAllocator = false;
     mRec->runParallelOuterLoop(doGPU, numLanes, [&](uint32_t lane) {
       nnApplications[lane].init(nn_settings);
-      if (nnApplications[lane].modelsUsed[0]) {
-        SetONNXGPUStream(*(nnApplications[lane].model_class).getSessionOptions(), lane, &deviceId);
-        (nnApplications[lane].model_class).setDeviceId(deviceId);
-        if (nnApplications[lane].model_class.getIntraOpNumThreads() > maxThreads) {
-          nnApplications[lane].model_class.setIntraOpNumThreads(maxThreads);
+      if (nnApplications[lane].mModelsUsed[0]) {
+        SetONNXGPUStream(*(nnApplications[lane].mModelClass).getSessionOptions(), lane, &deviceId);
+        (nnApplications[lane].mModelClass).setDeviceId(deviceId);
+        if (nnApplications[lane].mModelClass.getIntraOpNumThreads() > maxThreads) {
+          nnApplications[lane].mModelClass.setIntraOpNumThreads(maxThreads);
         }
-        (nnApplications[lane].model_class).initEnvironment();
+        (nnApplications[lane].mModelClass).initEnvironment();
         // Registering this once seems to be enough, even with different environmnents / models. ONNX apparently uses this per device and stores the OrtAllocator internally. All models will then use the volatile allocation.
         // But environment must be valid, so we init the model environment first and use it here afterwards.
         // Either this is done in one environment with lane == 0 or by recreating the allocator using recreateMemoryAllocator.
         // TODO: Volatile allocation works for reserving, but not yet for allocations when binding the input tensor
-        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].model_class).getEnv(), (nnApplications[lane].model_class).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
         // recreateMemoryAllocator = true;
-        (nnApplications[lane].model_class).initSession();
+        (nnApplications[lane].mModelClass).initSession();
       }
-      if (nnApplications[lane].modelsUsed[1]) {
-        SetONNXGPUStream(*(nnApplications[lane].model_reg_1).getSessionOptions(), lane, &deviceId);
-        (nnApplications[lane].model_reg_1).setDeviceId(deviceId);
-        if (nnApplications[lane].model_reg_1.getIntraOpNumThreads() > maxThreads) {
-          nnApplications[lane].model_reg_1.setIntraOpNumThreads(maxThreads);
+      if (nnApplications[lane].mModelsUsed[1]) {
+        SetONNXGPUStream(*(nnApplications[lane].mModelReg1).getSessionOptions(), lane, &deviceId);
+        (nnApplications[lane].mModelReg1).setDeviceId(deviceId);
+        if (nnApplications[lane].mModelReg1.getIntraOpNumThreads() > maxThreads) {
+          nnApplications[lane].mModelReg1.setIntraOpNumThreads(maxThreads);
         }
-        // (nnApplications[lane].model_reg_1).setEnv((nnApplications[lane].model_class).getEnv());
-        (nnApplications[lane].model_reg_1).initEnvironment();
-        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].model_reg_1).getEnv(), (nnApplications[lane].model_reg_1).getMemoryInfo(), mRec, recreateMemoryAllocator);
-        (nnApplications[lane].model_reg_1).initSession();
+        // (nnApplications[lane].mModelReg1).setEnv((nnApplications[lane].mModelClass).getEnv());
+        (nnApplications[lane].mModelReg1).initEnvironment();
+        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].mModelReg1).getEnv(), (nnApplications[lane].mModelReg1).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        (nnApplications[lane].mModelReg1).initSession();
       }
-      if (nnApplications[lane].modelsUsed[2]) {
-        SetONNXGPUStream(*(nnApplications[lane].model_reg_2).getSessionOptions(), lane, &deviceId);
-        (nnApplications[lane].model_reg_2).setDeviceId(deviceId);
-        if (nnApplications[lane].model_reg_2.getIntraOpNumThreads() > maxThreads) {
-          nnApplications[lane].model_reg_2.setIntraOpNumThreads(maxThreads);
+      if (nnApplications[lane].mModelsUsed[2]) {
+        SetONNXGPUStream(*(nnApplications[lane].mModelReg2).getSessionOptions(), lane, &deviceId);
+        (nnApplications[lane].mModelReg2).setDeviceId(deviceId);
+        if (nnApplications[lane].mModelReg2.getIntraOpNumThreads() > maxThreads) {
+          nnApplications[lane].mModelReg2.setIntraOpNumThreads(maxThreads);
         }
-        (nnApplications[lane].model_reg_2).initEnvironment();
-        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].model_class).getEnv(), (nnApplications[lane].model_class).getMemoryInfo(), mRec, recreateMemoryAllocator);
-        (nnApplications[lane].model_reg_2).initSession();
+        (nnApplications[lane].mModelReg2).initEnvironment();
+        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        (nnApplications[lane].mModelReg2).initSession();
       }
       if (nn_settings.nnClusterizerVerbosity < 3) {
         LOG(info) << "(ORT) Allocated ONNX stream for lane " << lane << " and device " << deviceId;
@@ -689,14 +689,14 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
       GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[sector];
       GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[sector] : clustererNN;
       int32_t lane = sector % numLanes;
-      clustererNN.deviceId = deviceId;
+      clustererNN.mDeviceId = deviceId;
       clustererNN.mISector = sector;
-      clustererNN.nnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
+      clustererNN.mNnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
       nnApplications[lane].initClusterizer(nn_settings, clustererNN);
       if (doGPU) {
-        clustererNNShadow.deviceId = deviceId;
+        clustererNNShadow.mDeviceId = deviceId;
         clustererNNShadow.mISector = sector;
-        clustererNNShadow.nnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
+        clustererNNShadow.mNnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
         nnApplications[lane].initClusterizer(nn_settings, clustererNNShadow);
       }
       AllocateRegisteredMemory(clustererNN.mMemoryId);
@@ -975,62 +975,62 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
           int withMC = (doGPU && propagateMCLabels);
 
-          if (clustererNNShadow.nnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
+          if (clustererNNShadow.mNnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
             runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
             DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 4, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
           }
 
           // float time_clusterizer = 0, time_fill = 0, time_networks = 0;
-          for (int batch = 0; batch < std::ceil((float)clusterer.mPmemory->counters.nClusters / clustererNNShadow.nnClusterizerBatchedMode); batch++) {
-            uint batchStart = batch * clustererNNShadow.nnClusterizerBatchedMode;
-            size_t iSize = CAMath::Min((uint)clustererNNShadow.nnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
+          for (int batch = 0; batch < std::ceil((float)clusterer.mPmemory->counters.nClusters / clustererNNShadow.mNnClusterizerBatchedMode); batch++) {
+            uint batchStart = batch * clustererNNShadow.mNnClusterizerBatchedMode;
+            size_t iSize = CAMath::Min((uint)clustererNNShadow.mNnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
 
             // auto start0 = std::chrono::high_resolution_clock::now();
-            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNSingleElement>({GetGrid(iSize * clustererNNShadow.nnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceInputDType, withMC, batchStart); // Filling the data
+            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNSingleElement>({GetGrid(iSize * clustererNNShadow.mNnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, batchStart); // Filling the data
 
             // auto stop0 = std::chrono::high_resolution_clock::now();
             // auto start1 = std::chrono::high_resolution_clock::now();
 
             // NN evaluations
-            if (clustererNNShadow.nnInferenceInputDType == 0) {
-              if (clustererNNShadow.nnInferenceOutputDType == 0) {
-                (nnApplication.model_class).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.modelProbabilities_16);
-              } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
-                (nnApplication.model_class).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.modelProbabilities_32);
+            if (clustererNNShadow.mNnInferenceInputDType == 0) {
+              if (clustererNNShadow.mNnInferenceOutputDType == 0) {
+                (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mModelProbabilities_16);
+              } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
+                (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mModelProbabilities_32);
               }
-            } else if (clustererNNShadow.nnInferenceInputDType == 1) {
-              if (clustererNNShadow.nnInferenceOutputDType == 0) {
-                (nnApplication.model_class).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.modelProbabilities_16);
-              } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
-                (nnApplication.model_class).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.modelProbabilities_32);
+            } else if (clustererNNShadow.mNnInferenceInputDType == 1) {
+              if (clustererNNShadow.mNnInferenceOutputDType == 0) {
+                (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mModelProbabilities_16);
+              } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
+                (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mModelProbabilities_32);
               }
             }
-            if (!clustererNNShadow.nnClusterizerUseCfRegression) {
-              if (clustererNNShadow.nnInferenceInputDType == 0) {
-                if (clustererNNShadow.nnInferenceOutputDType == 0) {
-                  (nnApplication.model_reg_1).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.outputDataReg1_16);
-                } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
-                  (nnApplication.model_reg_1).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.outputDataReg1_32);
+            if (!clustererNNShadow.mNnClusterizerUseCfRegression) {
+              if (clustererNNShadow.mNnInferenceInputDType == 0) {
+                if (clustererNNShadow.mNnInferenceOutputDType == 0) {
+                  (nnApplication.mModelReg1).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mOutputDataReg1_16);
+                } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
+                  (nnApplication.mModelReg1).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mOutputDataReg1_32);
                 }
-              } else if (clustererNNShadow.nnInferenceInputDType == 1) {
-                if (clustererNNShadow.nnInferenceOutputDType == 0) {
-                  (nnApplication.model_reg_1).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.outputDataReg1_16);
-                } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
-                  (nnApplication.model_reg_1).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.outputDataReg1_32);
+              } else if (clustererNNShadow.mNnInferenceInputDType == 1) {
+                if (clustererNNShadow.mNnInferenceOutputDType == 0) {
+                  (nnApplication.mModelReg1).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mOutputDataReg1_16);
+                } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
+                  (nnApplication.mModelReg1).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mOutputDataReg1_32);
                 }
               }
-              if (nnApplication.model_class.getNumOutputNodes()[0][1] > 1 && nnApplication.model_reg_2.isInitialized()) {
-                if (clustererNNShadow.nnInferenceInputDType == 0) {
-                  if (clustererNNShadow.nnInferenceOutputDType == 0) {
-                    (nnApplication.model_reg_2).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.outputDataReg2_16);
-                  } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
-                    (nnApplication.model_reg_2).inference(clustererNNShadow.inputData_16, iSize, clustererNNShadow.outputDataReg2_32);
+              if (nnApplication.mModelClass.getNumOutputNodes()[0][1] > 1 && nnApplication.mModelReg2.isInitialized()) {
+                if (clustererNNShadow.mNnInferenceInputDType == 0) {
+                  if (clustererNNShadow.mNnInferenceOutputDType == 0) {
+                    (nnApplication.mModelReg2).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mOutputDataReg2_16);
+                  } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
+                    (nnApplication.mModelReg2).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mOutputDataReg2_32);
                   }
-                } else if (clustererNNShadow.nnInferenceInputDType == 1) {
-                  if (clustererNNShadow.nnInferenceOutputDType == 0) {
-                    (nnApplication.model_reg_2).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.outputDataReg2_16);
-                  } else if (clustererNNShadow.nnInferenceOutputDType == 1) {
-                    (nnApplication.model_reg_2).inference(clustererNNShadow.inputData_32, iSize, clustererNNShadow.outputDataReg2_32);
+                } else if (clustererNNShadow.mNnInferenceInputDType == 1) {
+                  if (clustererNNShadow.mNnInferenceOutputDType == 0) {
+                    (nnApplication.mModelReg2).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mOutputDataReg2_16);
+                  } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
+                    (nnApplication.mModelReg2).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mOutputDataReg2_32);
                   }
                 }
               }
@@ -1039,24 +1039,24 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             // auto stopNNs = std::chrono::high_resolution_clock::now();
 
             // Publishing kernels
-            if (nnApplication.model_class.getNumOutputNodes()[0][1] == 1) {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceOutputDType, withMC, batchStart); // Assigning class labels
+            if (nnApplication.mModelClass.getNumOutputNodes()[0][1] == 1) {
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Assigning class labels
             } else {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass2Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceOutputDType, withMC, batchStart); // Assigning class labels
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass2Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Assigning class labels
             }
-            if (!clustererNNShadow.nnClusterizerUseCfRegression) {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass1Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceOutputDType, withMC, batchStart); // Publishing class 1 regression results
-              if (nnApplication.model_class.getNumOutputNodes()[0][1] > 1 && nnApplication.model_reg_2.isInitialized()) {
-                runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceOutputDType, withMC, batchStart); // Publishing class 2 regression results
+            if (!clustererNNShadow.mNnClusterizerUseCfRegression) {
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass1Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Publishing class 1 regression results
+              if (nnApplication.mModelClass.getNumOutputNodes()[0][1] > 1 && nnApplication.mModelReg2.isInitialized()) {
+                runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Publishing class 2 regression results
               }
             }
 
             // for(int i = 0; i < iSize; ++i) {
-            //   if(clustererNNShadow.outputDataClass[i + batchStart] > 1) {
-            //     LOG(info) << "WARNING ORT: Output of  " << i + batchStart << " / " << clusterer.mPmemory->counters.nClusters << " is " << clustererNNShadow.modelProbabilities_16[i].ToFloat() << " and " << clustererNNShadow.outputDataClass[i + batchStart] << " thresh " << clustererNNShadow.nnClassThreshold << " instead of 0 or 1. Please check the model and the input data.";
+            //   if(clustererNNShadow.mOutputDataClass[i + batchStart] > 1) {
+            //     LOG(info) << "WARNING ORT: Output of  " << i + batchStart << " / " << clusterer.mPmemory->counters.nClusters << " is " << clustererNNShadow.mModelProbabilities_16[i].ToFloat() << " and " << clustererNNShadow.mOutputDataClass[i + batchStart] << " thresh " << clustererNNShadow.mNnClassThreshold << " instead of 0 or 1. Please check the model and the input data.";
             //     // std::string input = "[";
-            //     // for(int j = 0; j < clustererNNShadow.nnClusterizerElementSize; j++){
-            //     //   input += std::to_string(clustererNNShadow.inputData_16[i * clustererNNShadow.nnClusterizerElementSize + j].ToFloat()) + ", ";
+            //     // for(int j = 0; j < clustererNNShadow.mNnClusterizerElementSize; j++){
+            //     //   input += std::to_string(clustererNNShadow.mInputData_16[i * clustererNNShadow.mNnClusterizerElementSize + j].ToFloat()) + ", ";
             //     // }
             //     // input += "]";
             //     // LOG(info) << "Input is: " << input;
@@ -1069,19 +1069,19 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             // time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
             // time_fill += std::chrono::duration_cast<std::chrono::nanoseconds>(stop0 - start0).count() / 1e9;
           }
-          if (clustererNNShadow.nnClusterizerUseCfRegression) {
+          if (clustererNNShadow.mNnClusterizerUseCfRegression) {
             // auto start1 = std::chrono::high_resolution_clock::now();
-            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNNShadow.nnInferenceInputDType, withMC, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
+            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
             // auto stop1 = std::chrono::high_resolution_clock::now();
             // time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
           }
-          // if (clustererNNShadow.nnClusterizerVerbosity < 3) {
+          // if (clustererNNShadow.mNnClusterizerVerbosity < 3) {
           //   int acceptedClusters = 0;
           //   for (size_t i = 0; i < clusterer.mPmemory->counters.nClusters; ++i) {
-          //     if(clustererNNShadow.outputDataClass[i] > 1 || clustererNNShadow.outputDataClass[i] < 0) {
-          //       LOG(info) << "WARNING ORT 2: " << clustererNNShadow.outputDataClass[i] << " for index " << i << " / " << clusterer.mPmemory->counters.nClusters;
+          //     if(clustererNNShadow.mOutputDataClass[i] > 1 || clustererNNShadow.mOutputDataClass[i] < 0) {
+          //       LOG(info) << "WARNING ORT 2: " << clustererNNShadow.mOutputDataClass[i] << " for index " << i << " / " << clusterer.mPmemory->counters.nClusters;
           //     }
-          //     acceptedClusters += clustererNNShadow.outputDataClass[i];
+          //     acceptedClusters += clustererNNShadow.mOutputDataClass[i];
           //   }
           //   LOG(info) << "[NN CF] Apply NN (fragment " << fragment.index << ", lane: " << lane << ", sector: " << iSector << "): filling data " << time_fill << "s ; networks: " << time_networks << "s ; clusterizer: " << time_clusterizer << "s ; " << clusterer.mPmemory->counters.nClusters << " clusters, " << acceptedClusters << " accepted. --> " << (int32_t)clusterer.mPmemory->counters.nClusters / (time_fill + time_clusterizer) << " clusters/s";
           // }
@@ -1187,9 +1187,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   for (int32_t i = 0; i < GetProcessingSettings().nTPCClustererLanes; i++) {
     // if (GetProcessingSettings().nn.applyNNclusterizer) {
     //   GPUTPCNNClusterizerHost& nnApplication = nnApplications[i];
-    //   nnApplication.model_class.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
-    //   nnApplication.model_reg_1.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
-    //   nnApplication.model_reg_2.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
+    //   nnApplication.mModelClass.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
+    //   nnApplication.mModelReg1.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
+    //   nnApplication.mModelReg2.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
     // }
     if (transferRunning[i]) {
       ReleaseEvent(mEvents->stream[i], doGPU);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
index 092af2ea393c5..da37c0771fe84 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
@@ -25,69 +25,69 @@ void GPUTPCNNClusterizer::SetMaxData(const GPUTrackingInOutPointers& io) {}
 
 void* GPUTPCNNClusterizer::setIOPointers(void* mem)
 {
-  if (nnClusterizerBatchedMode > 0) {
-    if (nnInferenceInputDType == 0 && nnClusterizerElementSize > 0) {
-      computePointerWithAlignment(mem, inputData_16, nnClusterizerBatchedMode * nnClusterizerElementSize);
-    } else if (nnInferenceInputDType == 1 && nnClusterizerElementSize > 0) {
-      computePointerWithAlignment(mem, inputData_32, nnClusterizerBatchedMode * nnClusterizerElementSize);
+  if (mNnClusterizerBatchedMode > 0) {
+    if (mNnInferenceInputDType == 0 && mNnClusterizerElementSize > 0) {
+      computePointerWithAlignment(mem, mInputData_16, mNnClusterizerBatchedMode * mNnClusterizerElementSize);
+    } else if (mNnInferenceInputDType == 1 && mNnClusterizerElementSize > 0) {
+      computePointerWithAlignment(mem, mInputData_32, mNnClusterizerBatchedMode * mNnClusterizerElementSize);
     }
-    computePointerWithAlignment(mem, clusterFlags, 2 * nnClusterizerBatchedMode);
+    computePointerWithAlignment(mem, mClusterFlags, 2 * mNnClusterizerBatchedMode);
 
-    if (nnInferenceOutputDType == 0 && nnClusterizerElementSize > 0) {
-      if (nnClusterizerModelClassNumOutputNodes > 0) {
-        computePointerWithAlignment(mem, modelProbabilities_16, nnClusterizerBatchedMode * nnClusterizerModelClassNumOutputNodes);
+    if (mNnInferenceOutputDType == 0 && mNnClusterizerElementSize > 0) {
+      if (mNnClusterizerModelClassNumOutputNodes > 0) {
+        computePointerWithAlignment(mem, mModelProbabilities_16, mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes);
       }
-      if (!nnClusterizerUseCfRegression) {
-        if (nnClusterizerModelReg1NumOutputNodes > 0) {
-          computePointerWithAlignment(mem, outputDataReg1_16, nnClusterizerBatchedMode * nnClusterizerModelReg1NumOutputNodes);
+      if (!mNnClusterizerUseCfRegression) {
+        if (mNnClusterizerModelReg1NumOutputNodes > 0) {
+          computePointerWithAlignment(mem, mOutputDataReg1_16, mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes);
         }
-        if (nnClusterizerModelReg2NumOutputNodes > 0) {
-          computePointerWithAlignment(mem, outputDataReg2_16, nnClusterizerBatchedMode * nnClusterizerModelReg2NumOutputNodes);
+        if (mNnClusterizerModelReg2NumOutputNodes > 0) {
+          computePointerWithAlignment(mem, mOutputDataReg2_16, mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes);
         }
       }
-    } else if (nnInferenceOutputDType == 1 && nnClusterizerElementSize > 0) {
-      if (nnClusterizerModelClassNumOutputNodes > 0) {
-        computePointerWithAlignment(mem, modelProbabilities_32, nnClusterizerBatchedMode * nnClusterizerModelClassNumOutputNodes);
+    } else if (mNnInferenceOutputDType == 1 && mNnClusterizerElementSize > 0) {
+      if (mNnClusterizerModelClassNumOutputNodes > 0) {
+        computePointerWithAlignment(mem, mModelProbabilities_32, mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes);
       }
-      if (!nnClusterizerUseCfRegression) {
-        if (nnClusterizerModelReg1NumOutputNodes > 0) {
-          computePointerWithAlignment(mem, outputDataReg1_32, nnClusterizerBatchedMode * nnClusterizerModelReg1NumOutputNodes);
+      if (!mNnClusterizerUseCfRegression) {
+        if (mNnClusterizerModelReg1NumOutputNodes > 0) {
+          computePointerWithAlignment(mem, mOutputDataReg1_32, mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes);
         }
-        if (nnClusterizerModelReg2NumOutputNodes > 0) {
-          computePointerWithAlignment(mem, outputDataReg2_32, nnClusterizerBatchedMode * nnClusterizerModelReg2NumOutputNodes);
+        if (mNnClusterizerModelReg2NumOutputNodes > 0) {
+          computePointerWithAlignment(mem, mOutputDataReg2_32, mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes);
         }
       }
     }
   }
-  if (nnClusterizerTotalClusters > 0) {
-    computePointerWithAlignment(mem, outputDataClass, nnClusterizerTotalClusters);
+  if (mNnClusterizerTotalClusters > 0) {
+    computePointerWithAlignment(mem, mOutputDataClass, mNnClusterizerTotalClusters);
   }
   return mem;
 }
 
 // std::vector<int32_t> GPUTPCNNClusterizer::pointerSizes() {
 //   std::vector<int32_t> sizes(7, -1);
-//   if (nnClusterizerBatchedMode > 0) {
-//     if (nnInferenceInputDType == 0 && nnClusterizerElementSize > 0) {
-//       sizes[0] = nnClusterizerBatchedMode * nnClusterizerElementSize; // inputData16
-//     } else if (nnInferenceInputDType == 1 && nnClusterizerElementSize > 0) {
-//       sizes[1] = nnClusterizerBatchedMode * nnClusterizerElementSize; // inputData32
+//   if (mNnClusterizerBatchedMode > 0) {
+//     if (mNnInferenceInputDType == 0 && mNnClusterizerElementSize > 0) {
+//       sizes[0] = mNnClusterizerBatchedMode * mNnClusterizerElementSize; // inputData16
+//     } else if (mNnInferenceInputDType == 1 && mNnClusterizerElementSize > 0) {
+//       sizes[1] = mNnClusterizerBatchedMode * mNnClusterizerElementSize; // inputData32
 //     }
-//     sizes[2] = 2 * nnClusterizerBatchedMode; // clusterFlags
-//     if (nnClusterizerModelClassNumOutputNodes > 0) {
-//       sizes[3] = nnClusterizerBatchedMode * nnClusterizerModelClassNumOutputNodes; // modelProbabilities
+//     sizes[2] = 2 * mNnClusterizerBatchedMode; // mClusterFlags
+//     if (mNnClusterizerModelClassNumOutputNodes > 0) {
+//       sizes[3] = mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes; // modelProbabilities
 //     }
-//     if (!nnClusterizerUseCfRegression) {
-//       if (nnClusterizerModelReg1NumOutputNodes > 0) {
-//         sizes[4] = nnClusterizerBatchedMode * nnClusterizerModelReg1NumOutputNodes; // outputDataReg1
+//     if (!mNnClusterizerUseCfRegression) {
+//       if (mNnClusterizerModelReg1NumOutputNodes > 0) {
+//         sizes[4] = mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes; // outputDataReg1
 //       }
-//       if (nnClusterizerModelReg2NumOutputNodes > 0) {
-//         sizes[5] = nnClusterizerBatchedMode * nnClusterizerModelReg2NumOutputNodes; // outputDataReg2
+//       if (mNnClusterizerModelReg2NumOutputNodes > 0) {
+//         sizes[5] = mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes; // outputDataReg2
 //       }
 //     }
 //   }
-//   if (nnClusterizerTotalClusters > 0) {
-//     sizes[6] = nnClusterizerTotalClusters; // outputDataClass
+//   if (mNnClusterizerTotalClusters > 0) {
+//     sizes[6] = mNnClusterizerTotalClusters; // mOutputDataClass
 //   }
 //   return sizes;
 // }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index 022642f9f142e..f7c2d13407b0e 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -37,42 +37,42 @@ class GPUTPCNNClusterizer : public GPUProcessor
 
   // Neural network clusterization
 
-  int nnClusterizerSizeInputRow = 3;
-  int nnClusterizerSizeInputPad = 3;
-  int nnClusterizerSizeInputTime = 3;
-  int nnClusterizerElementSize = -1;
-  bool nnClusterizerAddIndexData = true;
-  float nnClassThreshold = 0.01;
-  bool nnSigmoidTrafoClassThreshold = 1;
-  int nnClusterizerUseCfRegression = 0;
-  int nnClusterizerBatchedMode = 1;
-  int nnClusterizerTotalClusters = 1;
-  int nnClusterizerVerbosity = 0;
-  int nnClusterizerBoundaryFillValue = -1;
-  int nnClusterizerModelClassNumOutputNodes = -1;
-  int nnClusterizerModelReg1NumOutputNodes = -1;
-  int nnClusterizerModelReg2NumOutputNodes = -1;
-  int nnInferenceInputDType = 0;  // 0: float16, 1: float32
-  int nnInferenceOutputDType = 0; // 0: float16, 1: float32
+  int mNnClusterizerSizeInputRow = 3;
+  int mNnClusterizerSizeInputPad = 3;
+  int mNnClusterizerSizeInputTime = 3;
+  int mNnClusterizerElementSize = -1;
+  bool mNnClusterizerAddIndexData = true;
+  float mNnClassThreshold = 0.01;
+  bool mNnSigmoidTrafoClassThreshold = 1;
+  int mNnClusterizerUseCfRegression = 0;
+  int mNnClusterizerBatchedMode = 1;
+  int mNnClusterizerTotalClusters = 1;
+  int mNnClusterizerVerbosity = 0;
+  int mNnClusterizerBoundaryFillValue = -1;
+  int mNnClusterizerModelClassNumOutputNodes = -1;
+  int mNnClusterizerModelReg1NumOutputNodes = -1;
+  int mNnClusterizerModelReg2NumOutputNodes = -1;
+  int mNnInferenceInputDType = 0;  // 0: float16, 1: float32
+  int mNnInferenceOutputDType = 0; // 0: float16, 1: float32
   int mISector = -1;
-  int deviceId = -1;
+  int mDeviceId = -1;
 
   // Memory allocation for neural network
 
-  bool* clusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptr
-  int* outputDataClass = nullptr;
+  bool* mClusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptr
+  int* mOutputDataClass = nullptr;
 
   // FP32
-  float* inputData_32 = nullptr;
-  float* modelProbabilities_32 = nullptr;
-  float* outputDataReg1_32 = nullptr;
-  float* outputDataReg2_32 = nullptr;
+  float* mInputData_32 = nullptr;
+  float* mModelProbabilities_32 = nullptr;
+  float* mOutputDataReg1_32 = nullptr;
+  float* mOutputDataReg2_32 = nullptr;
 
   // FP16
-  OrtDataType::Float16_t* inputData_16 = nullptr;
-  OrtDataType::Float16_t* modelProbabilities_16 = nullptr;
-  OrtDataType::Float16_t* outputDataReg1_16 = nullptr;
-  OrtDataType::Float16_t* outputDataReg2_16 = nullptr;
+  OrtDataType::Float16_t* mInputData_16 = nullptr;
+  OrtDataType::Float16_t* mModelProbabilities_16 = nullptr;
+  OrtDataType::Float16_t* mOutputDataReg1_16 = nullptr;
+  OrtDataType::Float16_t* mOutputDataReg2_16 = nullptr;
 
   int16_t mMemoryId = -1;
 }; // class GPUTPCNNClusterizer
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index 31b71fd8f1ebe..ca2deec60601c 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -45,7 +45,7 @@ void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& set
     }
   }
 
-  OrtOptions = {
+  mOrtOptions = {
     {"model-path", class_model_path},
     {"device-type", settings.nnInferenceDevice},
     {"allocate-device-memory", std::to_string(settings.nnInferenceAllocateDevMem)},
@@ -57,60 +57,60 @@ void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& set
     {"logging-level", std::to_string(settings.nnInferenceVerbosity)},
     {"onnx-environment-name", "c1"}};
 
-  model_class.initOptions(OrtOptions);
-  modelsUsed[0] = true;
+  mModelClass.initOptions(mOrtOptions);
+  mModelsUsed[0] = true;
 
   reg_model_paths_local = o2::utils::Str::tokenize(reg_model_path, ':');
 
   if (!settings.nnClusterizerUseCfRegression) {
     if (reg_model_paths_local.size() == 1) {
-      OrtOptions["model-path"] = reg_model_paths_local[0];
-      OrtOptions["onnx-environment-name"] = "r1";
-      model_reg_1.initOptions(OrtOptions);
-      modelsUsed[1] = true;
+      mOrtOptions["model-path"] = reg_model_paths_local[0];
+      mOrtOptions["onnx-environment-name"] = "r1";
+      mModelReg1.initOptions(mOrtOptions);
+      mModelsUsed[1] = true;
     } else {
-      OrtOptions["model-path"] = reg_model_paths_local[0];
-      OrtOptions["onnx-environment-name"] = "r1";
-      model_reg_1.initOptions(OrtOptions);
-      modelsUsed[1] = true;
-      OrtOptions["model-path"] = reg_model_paths_local[1];
-      OrtOptions["onnx-environment-name"] = "r2";
-      model_reg_2.initOptions(OrtOptions);
-      modelsUsed[2] = true;
+      mOrtOptions["model-path"] = reg_model_paths_local[0];
+      mOrtOptions["onnx-environment-name"] = "r1";
+      mModelReg1.initOptions(mOrtOptions);
+      mModelsUsed[1] = true;
+      mOrtOptions["model-path"] = reg_model_paths_local[1];
+      mOrtOptions["onnx-environment-name"] = "r2";
+      mModelReg2.initOptions(mOrtOptions);
+      mModelsUsed[2] = true;
     }
   }
 }
 
 void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclusterizer& settings, GPUTPCNNClusterizer& clustererNN)
 {
-  clustererNN.nnClusterizerUseCfRegression = settings.nnClusterizerUseCfRegression;
-  clustererNN.nnClusterizerSizeInputRow = settings.nnClusterizerSizeInputRow;
-  clustererNN.nnClusterizerSizeInputPad = settings.nnClusterizerSizeInputPad;
-  clustererNN.nnClusterizerSizeInputTime = settings.nnClusterizerSizeInputTime;
-  clustererNN.nnClusterizerAddIndexData = settings.nnClusterizerAddIndexData;
-  clustererNN.nnClusterizerElementSize = ((2 * settings.nnClusterizerSizeInputRow + 1) * (2 * settings.nnClusterizerSizeInputPad + 1) * (2 * settings.nnClusterizerSizeInputTime + 1)) + (settings.nnClusterizerAddIndexData ? 3 : 0);
-  clustererNN.nnClusterizerBatchedMode = settings.nnClusterizerBatchedMode;
-  clustererNN.nnClusterizerBoundaryFillValue = settings.nnClusterizerBoundaryFillValue;
-  clustererNN.nnSigmoidTrafoClassThreshold = settings.nnSigmoidTrafoClassThreshold;
-  if (clustererNN.nnSigmoidTrafoClassThreshold) {
-    clustererNN.nnClassThreshold = (float)std::log(settings.nnClassThreshold / (1.f - settings.nnClassThreshold));
+  clustererNN.mNnClusterizerUseCfRegression = settings.nnClusterizerUseCfRegression;
+  clustererNN.mNnClusterizerSizeInputRow = settings.nnClusterizerSizeInputRow;
+  clustererNN.mNnClusterizerSizeInputPad = settings.nnClusterizerSizeInputPad;
+  clustererNN.mNnClusterizerSizeInputTime = settings.nnClusterizerSizeInputTime;
+  clustererNN.mNnClusterizerAddIndexData = settings.nnClusterizerAddIndexData;
+  clustererNN.mNnClusterizerElementSize = ((2 * settings.nnClusterizerSizeInputRow + 1) * (2 * settings.nnClusterizerSizeInputPad + 1) * (2 * settings.nnClusterizerSizeInputTime + 1)) + (settings.nnClusterizerAddIndexData ? 3 : 0);
+  clustererNN.mNnClusterizerBatchedMode = settings.nnClusterizerBatchedMode;
+  clustererNN.mNnClusterizerBoundaryFillValue = settings.nnClusterizerBoundaryFillValue;
+  clustererNN.mNnSigmoidTrafoClassThreshold = settings.nnSigmoidTrafoClassThreshold;
+  if (clustererNN.mNnSigmoidTrafoClassThreshold) {
+    clustererNN.mNnClassThreshold = (float)std::log(settings.nnClassThreshold / (1.f - settings.nnClassThreshold));
   } else {
-    clustererNN.nnClassThreshold = settings.nnClassThreshold;
+    clustererNN.mNnClassThreshold = settings.nnClassThreshold;
   }
   if (settings.nnClusterizerVerbosity < 0) {
-    clustererNN.nnClusterizerVerbosity = settings.nnInferenceVerbosity;
+    clustererNN.mNnClusterizerVerbosity = settings.nnInferenceVerbosity;
   } else {
-    clustererNN.nnClusterizerVerbosity = settings.nnClusterizerVerbosity;
+    clustererNN.mNnClusterizerVerbosity = settings.nnClusterizerVerbosity;
   }
-  clustererNN.nnInferenceInputDType = settings.nnInferenceInputDType.find("32") != std::string::npos;
-  clustererNN.nnInferenceOutputDType = settings.nnInferenceOutputDType.find("32") != std::string::npos;
-  clustererNN.nnClusterizerModelClassNumOutputNodes = model_class.getNumOutputNodes()[0][1];
+  clustererNN.mNnInferenceInputDType = settings.nnInferenceInputDType.find("32") != std::string::npos;
+  clustererNN.mNnInferenceOutputDType = settings.nnInferenceOutputDType.find("32") != std::string::npos;
+  clustererNN.mNnClusterizerModelClassNumOutputNodes = mModelClass.getNumOutputNodes()[0][1];
   if (!settings.nnClusterizerUseCfRegression) {
-    if (model_class.getNumOutputNodes()[0][1] == 1 || !model_reg_2.isInitialized()) {
-      clustererNN.nnClusterizerModelReg1NumOutputNodes = model_reg_1.getNumOutputNodes()[0][1];
+    if (mModelClass.getNumOutputNodes()[0][1] == 1 || !mModelReg2.isInitialized()) {
+      clustererNN.mNnClusterizerModelReg1NumOutputNodes = mModelReg1.getNumOutputNodes()[0][1];
     } else {
-      clustererNN.nnClusterizerModelReg1NumOutputNodes = model_reg_1.getNumOutputNodes()[0][1];
-      clustererNN.nnClusterizerModelReg2NumOutputNodes = model_reg_2.getNumOutputNodes()[0][1];
+      clustererNN.mNnClusterizerModelReg1NumOutputNodes = mModelReg1.getNumOutputNodes()[0][1];
+      clustererNN.mNnClusterizerModelReg2NumOutputNodes = mModelReg2.getNumOutputNodes()[0][1];
     }
   }
 }
@@ -199,20 +199,20 @@ void MockedOrtAllocator::LeakCheck()
 
 void GPUTPCNNClusterizerHost::volatileOrtAllocator(Ort::Env* env, Ort::MemoryInfo* memInfo, GPUReconstruction* rec, bool recreate)
 {
-  mockedAlloc = std::make_shared<MockedOrtAllocator>(rec, (OrtMemoryInfo*)(*memInfo));
+  mMockedAlloc = std::make_shared<MockedOrtAllocator>(rec, (OrtMemoryInfo*)(*memInfo));
   if (recreate) {
     Ort::ThrowOnError(Ort::GetApi().UnregisterAllocator((OrtEnv*)(*env), (OrtMemoryInfo*)(*memInfo)));
   }
-  Ort::ThrowOnError(Ort::GetApi().RegisterAllocator((OrtEnv*)(*env), mockedAlloc.get()));
-  memInfo = (Ort::MemoryInfo*)mockedAlloc->Info();
+  Ort::ThrowOnError(Ort::GetApi().RegisterAllocator((OrtEnv*)(*env), mMockedAlloc.get()));
+  memInfo = (Ort::MemoryInfo*)mMockedAlloc->Info();
 }
 
 const OrtMemoryInfo* GPUTPCNNClusterizerHost::getMockedMemoryInfo()
 {
-  return mockedAlloc->Info();
+  return mMockedAlloc->Info();
 }
 
 MockedOrtAllocator* GPUTPCNNClusterizerHost::getMockedAllocator()
 {
-  return mockedAlloc.get();
+  return mMockedAlloc.get();
 }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
index 0379b83d0ae02..e659753f21d7d 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
@@ -57,13 +57,11 @@ class GPUTPCNNClusterizerHost
   MockedOrtAllocator* getMockedAllocator();
   const OrtMemoryInfo* getMockedMemoryInfo();
 
-  std::unordered_map<std::string, std::string> OrtOptions;
-  o2::ml::OrtModel model_class, model_reg_1, model_reg_2; // For splitting clusters
-  std::vector<bool> modelsUsed = {false, false, false};   // 0: class, 1: reg_1, 2: reg_2
-  int32_t deviceId = -1;
-  std::vector<std::string> reg_model_paths;
-
-  std::shared_ptr<MockedOrtAllocator> mockedAlloc = nullptr;
+  std::unordered_map<std::string, std::string> mOrtOptions;
+  o2::ml::OrtModel mModelClass, mModelReg1, mModelReg2;  // For splitting clusters
+  std::vector<bool> mModelsUsed = {false, false, false}; // 0: class, 1: reg_1, 2: reg_2
+  int32_t mDeviceId = -1;
+  std::shared_ptr<MockedOrtAllocator> mMockedAlloc = nullptr;
 }; // class GPUTPCNNClusterizerHost
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 413293502d3c6..47bc5e8da80ca 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -40,7 +40,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
   uint glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  if (clustererNN.outputDataClass[glo_idx] == 0) { // default clusterizer should not be called in batched mode due to mess-up with thread indices
+  if (clustererNN.mOutputDataClass[glo_idx] == 0) { // default clusterizer should not be called in batched mode due to mess-up with thread indices
     return;
   }
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
@@ -56,56 +56,56 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   uint glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  uint write_idx = glo_idx * clustererNN.nnClusterizerElementSize; // Potential optimization: Either choose nnClusterizerBatchedMode as a power of 2 or calculate from threadId and blockId
+  uint write_idx = glo_idx * clustererNN.mNnClusterizerElementSize; // Potential optimization: Either choose mNnClusterizerBatchedMode as a power of 2 or calculate from threadId and blockId
 
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   CfChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
   int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad()), time = static_cast<int>(peak.time()); // Explicit casting to avoid conversion errors
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
-  int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.nnClusterizerSizeInputRow);
+  int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
 
 #ifndef GPUCA_GPUCODE
   GPUCA_UNROLL(U(), U());
 #endif
-  for (int r = -clustererNN.nnClusterizerSizeInputRow; r <= clustererNN.nnClusterizerSizeInputRow; r++) {
+  for (int r = -clustererNN.mNnClusterizerSizeInputRow; r <= clustererNN.mNnClusterizerSizeInputRow; r++) {
     bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
     int pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, row + r);
-    for (int p = -clustererNN.nnClusterizerSizeInputPad + pad_offset; p <= clustererNN.nnClusterizerSizeInputPad + pad_offset; p++) {
-      bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.nnClusterizerSizeInputRow);
-      for (int t = -clustererNN.nnClusterizerSizeInputTime; t <= clustererNN.nnClusterizerSizeInputTime; t++) {
+    for (int p = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; p++) {
+      bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow);
+      for (int t = -clustererNN.mNnClusterizerSizeInputTime; t <= clustererNN.mNnClusterizerSizeInputTime; t++) {
         if (!is_boundary) {
           CfChargePos tmp_pos(row + r, pad + p, time + t);
-          if (r == 0 && !clustererNN.clusterFlags[2 * glo_idx] && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) { // ordering is done for short circuit optimization
-            clustererNN.clusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
-            clustererNN.clusterFlags[2 * glo_idx + 1] = clustererNN.clusterFlags[2 * glo_idx];
+          if (r == 0 && !clustererNN.mClusterFlags[2 * glo_idx] && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) { // ordering is done for short circuit optimization
+            clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
+            clustererNN.mClusterFlags[2 * glo_idx + 1] = clustererNN.mClusterFlags[2 * glo_idx];
           }
           if (dtype == 0) {
-            clustererNN.inputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
+            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
           } else if (dtype == 1) {
-            clustererNN.inputData_32[write_idx] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+            clustererNN.mInputData_32[write_idx] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
           }
         } else {
           // Filling boundary just to make sure that no values are left unintentionally
           if (dtype == 0) {
-            clustererNN.inputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue));
+            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
           } else {
-            clustererNN.inputData_32[write_idx] = static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue);
+            clustererNN.mInputData_32[write_idx] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
           }
         }
         write_idx++;
       }
     }
   }
-  if (clustererNN.nnClusterizerAddIndexData) {
+  if (clustererNN.mNnClusterizerAddIndexData) {
     if (dtype == 0) {
-      clustererNN.inputData_16[write_idx] = (OrtDataType::Float16_t)(sector / 36.f);
-      clustererNN.inputData_16[write_idx + 1] = (OrtDataType::Float16_t)(row / 152.f);
-      clustererNN.inputData_16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
+      clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(sector / 36.f);
+      clustererNN.mInputData_16[write_idx + 1] = (OrtDataType::Float16_t)(row / 152.f);
+      clustererNN.mInputData_16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
     } else {
-      clustererNN.inputData_32[write_idx] = sector / 36.f;
-      clustererNN.inputData_32[write_idx + 1] = row / 152.f;
-      clustererNN.inputData_32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+      clustererNN.mInputData_32[write_idx] = sector / 36.f;
+      clustererNN.mInputData_32[write_idx + 1] = row / 152.f;
+      clustererNN.mInputData_32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
     }
   }
 }
@@ -116,62 +116,62 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   uint glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  uint base_idx = CAMath::Floor(glo_idx / clustererNN.nnClusterizerElementSize);
-  uint transient_index = glo_idx % clustererNN.nnClusterizerElementSize;
+  uint base_idx = CAMath::Floor(glo_idx / clustererNN.mNnClusterizerElementSize);
+  uint transient_index = glo_idx % clustererNN.mNnClusterizerElementSize;
 
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   CfChargePos peak = clusterer.mPfilteredPeakPositions[base_idx + batchStart];
   int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad());
 
-  if (clustererNN.nnClusterizerAddIndexData && (int32_t)transient_index == (clustererNN.nnClusterizerElementSize - 1)) {
-    uint top_idx = (base_idx + 1) * clustererNN.nnClusterizerElementSize;
+  if (clustererNN.mNnClusterizerAddIndexData && (int32_t)transient_index == (clustererNN.mNnClusterizerElementSize - 1)) {
+    uint top_idx = (base_idx + 1) * clustererNN.mNnClusterizerElementSize;
     for (uint16_t i = 0; i < 8; i++) {
       Delta2 d = cfconsts::InnerNeighbors[i];
       CfChargePos tmp_pos = peak.delta(d);
-      clustererNN.clusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
-      clustererNN.clusterFlags[2 * glo_idx + 1] = clustererNN.clusterFlags[2 * glo_idx];
+      clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
+      clustererNN.mClusterFlags[2 * glo_idx + 1] = clustererNN.mClusterFlags[2 * glo_idx];
     }
     if (dtype == 0) {
-      clustererNN.inputData_16[top_idx - 3] = (OrtDataType::Float16_t)(sector / 36.f);
-      clustererNN.inputData_16[top_idx - 2] = (OrtDataType::Float16_t)(row / 152.f);
-      clustererNN.inputData_16[top_idx - 1] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
+      clustererNN.mInputData_16[top_idx - 3] = (OrtDataType::Float16_t)(sector / 36.f);
+      clustererNN.mInputData_16[top_idx - 2] = (OrtDataType::Float16_t)(row / 152.f);
+      clustererNN.mInputData_16[top_idx - 1] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
     } else {
-      clustererNN.inputData_32[top_idx - 3] = sector / 36.f;
-      clustererNN.inputData_32[top_idx - 2] = row / 152.f;
-      clustererNN.inputData_32[top_idx - 1] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+      clustererNN.mInputData_32[top_idx - 3] = sector / 36.f;
+      clustererNN.mInputData_32[top_idx - 2] = row / 152.f;
+      clustererNN.mInputData_32[top_idx - 1] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
     }
-  } else if ((int32_t)transient_index < (clustererNN.nnClusterizerElementSize - 3)) {
+  } else if ((int32_t)transient_index < (clustererNN.mNnClusterizerElementSize - 3)) {
     int time = static_cast<int>(peak.time());
-    int r = CAMath::Floor(transient_index / ((2 * clustererNN.nnClusterizerSizeInputPad + 1) * (2 * clustererNN.nnClusterizerSizeInputTime + 1))) - clustererNN.nnClusterizerSizeInputRow;
+    int r = CAMath::Floor(transient_index / ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1))) - clustererNN.mNnClusterizerSizeInputRow;
     bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
     if (is_row_boundary) {
       if (dtype == 0) {
-        clustererNN.inputData_16[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue));
+        clustererNN.mInputData_16[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
       } else {
-        clustererNN.inputData_32[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue);
+        clustererNN.mInputData_32[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
       }
     } else {
-      int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.nnClusterizerSizeInputRow);
+      int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
       int pad_offset = GPUTPCNNClusterizerKernels::padOffset(row, row + r);
-      int rest_1 = transient_index % ((2 * clustererNN.nnClusterizerSizeInputPad + 1) * (2 * clustererNN.nnClusterizerSizeInputTime + 1));
-      int p = CAMath::Floor(rest_1 / (2 * clustererNN.nnClusterizerSizeInputTime + 1)) - clustererNN.nnClusterizerSizeInputPad + pad_offset;
-      bool is_boundary = GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.nnClusterizerSizeInputRow);
+      int rest_1 = transient_index % ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1));
+      int p = CAMath::Floor(rest_1 / (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputPad + pad_offset;
+      bool is_boundary = GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow);
 
       if (!is_boundary) {
         float central_charge = static_cast<float>(chargeMap[peak].unpack());
-        int t = (rest_1 % (2 * clustererNN.nnClusterizerSizeInputTime + 1)) - clustererNN.nnClusterizerSizeInputTime;
+        int t = (rest_1 % (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputTime;
         CfChargePos tmp_pos(row + r, pad + p, time + t);
         if (dtype == 0) {
-          clustererNN.inputData_16[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
+          clustererNN.mInputData_16[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
         } else if (dtype == 1) {
-          clustererNN.inputData_32[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+          clustererNN.mInputData_32[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
         }
       } else {
         if (dtype == 0) {
-          clustererNN.inputData_16[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue));
+          clustererNN.mInputData_16[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
         } else {
-          clustererNN.inputData_32[base_idx * clustererNN.nnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.nnClusterizerBoundaryFillValue);
+          clustererNN.mInputData_32[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
         }
       }
     }
@@ -183,9 +183,9 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::det
 {
   uint glo_idx = get_global_id(0);
   if (dtype == 0) {
-    processors.tpcNNClusterer[sector].outputDataClass[glo_idx + batchStart] = (int)((processors.tpcNNClusterer[sector].modelProbabilities_16[glo_idx]).ToFloat() > processors.tpcNNClusterer[sector].nnClassThreshold);
+    processors.tpcNNClusterer[sector].mOutputDataClass[glo_idx + batchStart] = (int)((processors.tpcNNClusterer[sector].mModelProbabilities_16[glo_idx]).ToFloat() > processors.tpcNNClusterer[sector].mNnClassThreshold);
   } else if (dtype == 1) {
-    processors.tpcNNClusterer[sector].outputDataClass[glo_idx + batchStart] = (int)(processors.tpcNNClusterer[sector].modelProbabilities_32[glo_idx] > processors.tpcNNClusterer[sector].nnClassThreshold);
+    processors.tpcNNClusterer[sector].mOutputDataClass[glo_idx + batchStart] = (int)(processors.tpcNNClusterer[sector].mModelProbabilities_32[glo_idx] > processors.tpcNNClusterer[sector].mNnClassThreshold);
   }
 }
 
@@ -194,29 +194,29 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::det
 {
   auto& clustererNN = processors.tpcNNClusterer[sector];
   uint glo_idx = get_global_id(0);
-  uint elem_iterator = glo_idx * clustererNN.nnClusterizerModelClassNumOutputNodes;
+  uint elem_iterator = glo_idx * clustererNN.mNnClusterizerModelClassNumOutputNodes;
   float current_max_prob = 0.f; // If the neural network doesn't contain the softmax as a last layer, the outputs can range in [-infty, infty]
   uint class_label = 0;
-  for (uint pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.nnClusterizerModelClassNumOutputNodes; pIdx++) {
+  for (uint pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes; pIdx++) {
     if (pIdx == elem_iterator) {
       if (dtype == 0) {
-        current_max_prob = static_cast<float>(clustererNN.modelProbabilities_16[pIdx]);
+        current_max_prob = static_cast<float>(clustererNN.mModelProbabilities_16[pIdx]);
       } else if (dtype == 1) {
-        current_max_prob = clustererNN.modelProbabilities_32[pIdx];
+        current_max_prob = clustererNN.mModelProbabilities_32[pIdx];
       }
     } else {
       if (dtype == 0) {
-        current_max_prob = CAMath::Max(current_max_prob, clustererNN.modelProbabilities_16[pIdx].ToFloat());
+        current_max_prob = CAMath::Max(current_max_prob, clustererNN.mModelProbabilities_16[pIdx].ToFloat());
       } else if (dtype == 1) {
-        current_max_prob = CAMath::Max(current_max_prob, clustererNN.modelProbabilities_32[pIdx]);
+        current_max_prob = CAMath::Max(current_max_prob, clustererNN.mModelProbabilities_32[pIdx]);
       }
     }
   }
-  // uint class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clustererNN.nnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
-  clustererNN.outputDataClass[glo_idx + batchStart] = class_label;
+  // uint class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
+  clustererNN.mOutputDataClass[glo_idx + batchStart] = class_label;
   if (class_label > 1) {
-    clustererNN.clusterFlags[2 * glo_idx] = 1;
-    clustererNN.clusterFlags[2 * glo_idx + 1] = 1;
+    clustererNN.mClusterFlags[2 * glo_idx] = 1;
+    clustererNN.mClusterFlags[2 * glo_idx + 1] = 1;
   }
 }
 
@@ -235,11 +235,11 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
   tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
   uint full_glo_idx = glo_idx + batchStart;
-  int model_output_index = glo_idx * clustererNN.nnClusterizerModelReg1NumOutputNodes;
+  int model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg1NumOutputNodes;
 
-  // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.nnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
+  // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.mNnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
 
-  if (clustererNN.outputDataClass[full_glo_idx] == 1 || (clustererNN.nnClusterizerModelReg2NumOutputNodes == -1 && clustererNN.outputDataClass[full_glo_idx] >= 1)) {
+  if (clustererNN.mOutputDataClass[full_glo_idx] == 1 || (clustererNN.mNnClusterizerModelReg2NumOutputNodes == -1 && clustererNN.mOutputDataClass[full_glo_idx] >= 1)) {
 
     ClusterAccumulator pc;
 
@@ -265,21 +265,21 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
     }
 
     if (dtype == 0) {
-      pc.setFull(central_charge * clustererNN.outputDataReg1_16[model_output_index + 4].ToFloat(),
-                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg1_16[model_output_index].ToFloat(),
-                 clustererNN.outputDataReg1_16[model_output_index + 2].ToFloat(),
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg1_16[model_output_index + 1].ToFloat(),
-                 clustererNN.outputDataReg1_16[model_output_index + 3].ToFloat(),
-                 clustererNN.clusterFlags[2 * glo_idx],
-                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+      pc.setFull(central_charge * clustererNN.mOutputDataReg1_16[model_output_index + 4].ToFloat(),
+                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_16[model_output_index].ToFloat(),
+                 clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat(),
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_16[model_output_index + 1].ToFloat(),
+                 clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat(),
+                 clustererNN.mClusterFlags[2 * glo_idx],
+                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
     } else if (dtype == 1) {
-      pc.setFull(central_charge * clustererNN.outputDataReg1_32[model_output_index + 4],
-                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg1_32[model_output_index],
-                 clustererNN.outputDataReg1_32[model_output_index + 2],
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg1_32[model_output_index + 1],
-                 clustererNN.outputDataReg1_32[model_output_index + 3],
-                 clustererNN.clusterFlags[2 * glo_idx],
-                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+      pc.setFull(central_charge * clustererNN.mOutputDataReg1_32[model_output_index + 4],
+                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_32[model_output_index],
+                 clustererNN.mOutputDataReg1_32[model_output_index + 2],
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_32[model_output_index + 1],
+                 clustererNN.mOutputDataReg1_32[model_output_index + 3],
+                 clustererNN.mClusterFlags[2 * glo_idx],
+                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
     }
 
     tpc::ClusterNative myCluster;
@@ -330,9 +330,9 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
   tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
   uint full_glo_idx = glo_idx + batchStart;
-  int model_output_index = glo_idx * clustererNN.nnClusterizerModelReg2NumOutputNodes;
+  int model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg2NumOutputNodes;
 
-  if (clustererNN.outputDataClass[full_glo_idx] > 0) {
+  if (clustererNN.mOutputDataClass[full_glo_idx] > 0) {
 
     ClusterAccumulator pc;
 
@@ -358,21 +358,21 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
     // Cluster 1
     if (dtype == 0) {
-      pc.setFull(central_charge * clustererNN.outputDataReg2_16[model_output_index + 8].ToFloat(),
-                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg2_16[model_output_index].ToFloat(),
-                 clustererNN.outputDataReg2_16[model_output_index + 4].ToFloat(),
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg2_16[model_output_index + 2].ToFloat(),
-                 clustererNN.outputDataReg2_16[model_output_index + 6].ToFloat(),
-                 clustererNN.clusterFlags[2 * glo_idx],
-                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+      pc.setFull(central_charge * clustererNN.mOutputDataReg2_16[model_output_index + 8].ToFloat(),
+                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index].ToFloat(),
+                 clustererNN.mOutputDataReg2_16[model_output_index + 4].ToFloat(),
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 2].ToFloat(),
+                 clustererNN.mOutputDataReg2_16[model_output_index + 6].ToFloat(),
+                 clustererNN.mClusterFlags[2 * glo_idx],
+                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
     } else if (dtype == 1) {
-      pc.setFull(central_charge * clustererNN.outputDataReg2_32[model_output_index + 8],
-                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg2_32[model_output_index],
-                 clustererNN.outputDataReg2_32[model_output_index + 4],
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg2_32[model_output_index + 2],
-                 clustererNN.outputDataReg2_32[model_output_index + 6],
-                 clustererNN.clusterFlags[2 * glo_idx],
-                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+      pc.setFull(central_charge * clustererNN.mOutputDataReg2_32[model_output_index + 8],
+                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index],
+                 clustererNN.mOutputDataReg2_32[model_output_index + 4],
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 2],
+                 clustererNN.mOutputDataReg2_32[model_output_index + 6],
+                 clustererNN.mClusterFlags[2 * glo_idx],
+                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
     }
 
     tpc::ClusterNative myCluster;
@@ -403,21 +403,21 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
     // Cluster 2
     if (dtype == 0) {
-      pc.setFull(central_charge * clustererNN.outputDataReg2_16[model_output_index + 9].ToFloat(),
-                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg2_16[model_output_index + 1].ToFloat(),
-                 clustererNN.outputDataReg2_16[model_output_index + 5].ToFloat(),
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg2_16[model_output_index + 3].ToFloat(),
-                 clustererNN.outputDataReg2_16[model_output_index + 7].ToFloat(),
-                 clustererNN.clusterFlags[2 * glo_idx],
-                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+      pc.setFull(central_charge * clustererNN.mOutputDataReg2_16[model_output_index + 9].ToFloat(),
+                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index + 1].ToFloat(),
+                 clustererNN.mOutputDataReg2_16[model_output_index + 5].ToFloat(),
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 3].ToFloat(),
+                 clustererNN.mOutputDataReg2_16[model_output_index + 7].ToFloat(),
+                 clustererNN.mClusterFlags[2 * glo_idx],
+                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
     } else if (dtype == 1) {
-      pc.setFull(central_charge * clustererNN.outputDataReg2_32[model_output_index + 9],
-                 static_cast<float>(peak.pad()) + clustererNN.outputDataReg2_32[model_output_index + 1],
-                 clustererNN.outputDataReg2_32[model_output_index + 5],
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.outputDataReg2_32[model_output_index + 3],
-                 clustererNN.outputDataReg2_32[model_output_index + 7],
-                 clustererNN.clusterFlags[2 * glo_idx],
-                 clustererNN.clusterFlags[2 * glo_idx + 1]);
+      pc.setFull(central_charge * clustererNN.mOutputDataReg2_32[model_output_index + 9],
+                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index + 1],
+                 clustererNN.mOutputDataReg2_32[model_output_index + 5],
+                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 3],
+                 clustererNN.mOutputDataReg2_32[model_output_index + 7],
+                 clustererNN.mClusterFlags[2 * glo_idx],
+                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
     }
 
     rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);

From 67b81698f9c95edff48e630623b063a3c6fa9b51 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Apr 2025 10:10:26 +0200
Subject: [PATCH 0294/1764] GPU TPC: Make cluster rejection based on chi2 from
 current track position optional if in rejection based on interpolation mode

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 1 +
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 2d8c2184e3b02..4c32c3e46e3a7 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -151,6 +151,7 @@ AddOptionRTC(forceEarlyTransform, int8_t, -1, "", 0, "Force early TPC transforma
 AddOptionRTC(dropLoopers, uint8_t, 0, "", 0, "Drop looping tracks starting from second loop")
 AddOptionRTC(mergerCovSource, uint8_t, 2, "", 0, "Method to obtain covariance in track merger: 0 = simple filterErrors method, 1 = use cov from track following, 2 = refit (default)")
 AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation instead of extrapolation for chi2 based cluster rejection")
+AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position")
 AddOptionRTC(mergeCE, uint8_t, 1, "", 0, "Merge tracks accross the central electrode")
 AddOptionRTC(retryRefit, int8_t, 1, "", 0, "Retry refit with seeding errors and without cluster rejection when fit fails (=2 means retry in same kernel, =1 for separate kernel")
 AddOptionRTC(looperInterpolationInExtraPass, int8_t, -1, "", 0, "Perform looper interpolation in an extra pass")
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index 9e23f9af3cf43..90612fc98f836 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -691,7 +691,7 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow,
     return 0;
   }
 
-  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect || rejectChi2 == rejectInterReject, err2Y, err2Z, &param);
+  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect || (param.rec.tpc.mergerInterpolateRejectAlsoOnCurrentPosition && rejectChi2 == rejectInterReject), err2Y, err2Z, &param);
 }
 
 GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict() param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z)

From 8060987d94bb48a2b71c98066a8952630246723d Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 24 Apr 2025 12:06:38 +0200
Subject: [PATCH 0295/1764] Fix: TrackLTIntegral.addStep needs (q/p)^2 instead
 of 1/p^2

Since the charge dependence of beta is accounted internally.
---
 .../TrackLTIntegral.h                          |  2 +-
 .../TrackParametrization.h                     | 13 +++++++++++++
 .../Reconstruction/src/TrackLTIntegral.cxx     |  6 +++---
 .../test/testLTOFIntegration.cxx               |  4 ++--
 Detectors/Base/src/Propagator.cxx              | 18 +++++++++---------
 Detectors/GlobalTracking/src/MatchTPCITS.cxx   |  4 ++--
 .../TRD/workflow/src/TRDGlobalTrackingSpec.cxx |  4 ++--
 7 files changed, 32 insertions(+), 19 deletions(-)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackLTIntegral.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackLTIntegral.h
index 6cf9ceda8e195..e799804805972 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackLTIntegral.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackLTIntegral.h
@@ -63,7 +63,7 @@ class TrackLTIntegral
     }
   }
 
-  GPUd() void addStep(float dL, float p2Inv);
+  GPUd() void addStep(float dL, float q2p2);
   GPUd() void addX2X0(float d) { mX2X0 += d; }
   GPUd() void addXRho(float d) { mXRho += d; }
 
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index a51ec3b7010a7..bfd56eb8f024f 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -191,6 +191,7 @@ class TrackParametrization
   GPUd() value_t getPhi() const;
   GPUd() value_t getPhiPos() const;
 
+  GPUd() value_t getQ2P2() const;
   GPUd() value_t getPtInv() const;
   GPUd() value_t getP2Inv() const;
   GPUd() value_t getP2() const;
@@ -555,6 +556,18 @@ GPUdi() auto TrackParametrization<value_T>::getPhiPos() const -> value_t
   return phi;
 }
 
+//____________________________________________________________
+template <typename value_T>
+GPUdi() auto TrackParametrization<value_T>::getQ2P2() const -> value_t
+{
+  // return the (q/p)^2
+  value_t q2pt2 = mP[kQ2Pt] * mP[kQ2Pt];
+  if (q2pt2 < MinPTInv * MinPTInv) {
+    q2pt2 = MinPTInv * MinPTInv;
+  }
+  return q2pt2 / (1.f + getTgl() * getTgl());
+}
+
 //____________________________________________________________
 template <typename value_T>
 GPUdi() auto TrackParametrization<value_T>::getPtInv() const -> value_t
diff --git a/DataFormats/Reconstruction/src/TrackLTIntegral.cxx b/DataFormats/Reconstruction/src/TrackLTIntegral.cxx
index 3efddff00f512..426c3da04726c 100644
--- a/DataFormats/Reconstruction/src/TrackLTIntegral.cxx
+++ b/DataFormats/Reconstruction/src/TrackLTIntegral.cxx
@@ -39,9 +39,9 @@ GPUd() void TrackLTIntegral::print() const
 }
 
 //_____________________________________________________
-GPUd() void TrackLTIntegral::addStep(float dL, float p2Inv)
+GPUd() void TrackLTIntegral::addStep(float dL, float q2p2)
 {
-  ///< add step in cm to integrals
+  ///< add step in cm to integrals, q2p2 is (q/p)^2.
   mL += dL;
   if (isTimeNotNeeded()) {
     return;
@@ -49,7 +49,7 @@ GPUd() void TrackLTIntegral::addStep(float dL, float p2Inv)
   const float dTns = dL * 1000.f / o2::constants::physics::LightSpeedCm2NS; // time change in ps for beta = 1 particle
   for (int id = 0; id < getNTOFs(); id++) {
     const float m2z = track::PID::getMass2Z(id);
-    const float betaInv = math_utils::sqrt(1.f + m2z * m2z * p2Inv);
+    const float betaInv = math_utils::sqrt(1.f + m2z * m2z * q2p2);
     mT[id] += dTns * betaInv;
   }
 }
diff --git a/DataFormats/Reconstruction/test/testLTOFIntegration.cxx b/DataFormats/Reconstruction/test/testLTOFIntegration.cxx
index bb65c60d08d18..f737b1df53666 100644
--- a/DataFormats/Reconstruction/test/testLTOFIntegration.cxx
+++ b/DataFormats/Reconstruction/test/testLTOFIntegration.cxx
@@ -33,8 +33,8 @@ BOOST_AUTO_TEST_CASE(TrackLTIntegral)
   const int nStep = 100;
   const float dx2x0 = 0.01f;
   for (int i = 0; i < nStep; i++) {
-    lt.addStep(1., trc.getP2Inv());
-    lt1.addStep(1., trc1.getP2Inv());
+    lt.addStep(1., trc.getQ2P2());
+    lt1.addStep(1., trc1.getQ2P2());
     lt1.addX2X0(dx2x0);
   }
   trc.printParam();
diff --git a/Detectors/Base/src/Propagator.cxx b/Detectors/Base/src/Propagator.cxx
index c7c7b461034e5..754c0c14e6f60 100644
--- a/Detectors/Base/src/Propagator.cxx
+++ b/Detectors/Base/src/Propagator.cxx
@@ -189,14 +189,14 @@ GPUd() bool PropagatorImpl<value_T>::PropagateToXBxByBz(TrackParCov_t& track, va
           res = false;
         }
         if (tofInfo) {
-          tofInfo->addStep(mb.length, track.getP2Inv()); // fill L,ToF info using already calculated step length
+          tofInfo->addStep(mb.length, track.getQ2P2()); // fill L,ToF info using already calculated step length
           tofInfo->addX2X0(mb.meanX2X0);
           tofInfo->addXRho(mb.getXRho(signCorr));
         }
       } else if (tofInfo) { // if tofInfo filling was requested w/o material correction, we need to calculate the step lenght
         auto xyz1 = track.getXYZGlo();
         math_utils::Vector3D<value_type> stepV(xyz1.X() - xyz0.X(), xyz1.Y() - xyz0.Y(), xyz1.Z() - xyz0.Z());
-        tofInfo->addStep(stepV.R(), track.getP2Inv());
+        tofInfo->addStep(stepV.R(), track.getQ2P2());
       }
       return res;
     };
@@ -258,14 +258,14 @@ GPUd() bool PropagatorImpl<value_T>::PropagateToXBxByBz(TrackPar_t& track, value
           res = false;
         }
         if (tofInfo) {
-          tofInfo->addStep(mb.length, track.getP2Inv()); // fill L,ToF info using already calculated step length
+          tofInfo->addStep(mb.length, track.getQ2P2()); // fill L,ToF info using already calculated step length
           tofInfo->addX2X0(mb.meanX2X0);
           tofInfo->addXRho(mb.getXRho(signCorr));
         }
       } else if (tofInfo) { // if tofInfo filling was requested w/o material correction, we need to calculate the step lenght
         auto xyz1 = track.getXYZGlo();
         math_utils::Vector3D<value_type> stepV(xyz1.X() - xyz0.X(), xyz1.Y() - xyz0.Y(), xyz1.Z() - xyz0.Z());
-        tofInfo->addStep(stepV.R(), track.getP2Inv());
+        tofInfo->addStep(stepV.R(), track.getQ2P2());
       }
       return res;
     };
@@ -324,14 +324,14 @@ GPUd() bool PropagatorImpl<value_T>::propagateToX(TrackParCov_t& track, value_ty
           res = false;
         }
         if (tofInfo) {
-          tofInfo->addStep(mb.length, track.getP2Inv()); // fill L,ToF info using already calculated step length
+          tofInfo->addStep(mb.length, track.getQ2P2()); // fill L,ToF info using already calculated step length
           tofInfo->addX2X0(mb.meanX2X0);
           tofInfo->addXRho(mb.getXRho(signCorr));
         }
       } else if (tofInfo) { // if tofInfo filling was requested w/o material correction, we need to calculate the step lenght
         auto xyz1 = track.getXYZGlo();
         math_utils::Vector3D<value_type> stepV(xyz1.X() - xyz0.X(), xyz1.Y() - xyz0.Y(), xyz1.Z() - xyz0.Z());
-        tofInfo->addStep(stepV.R(), track.getP2Inv());
+        tofInfo->addStep(stepV.R(), track.getQ2P2());
       }
       return res;
     };
@@ -390,14 +390,14 @@ GPUd() bool PropagatorImpl<value_T>::propagateToX(TrackPar_t& track, value_type
           res = false;
         }
         if (tofInfo) {
-          tofInfo->addStep(mb.length, track.getP2Inv()); // fill L,ToF info using already calculated step length
+          tofInfo->addStep(mb.length, track.getQ2P2()); // fill L,ToF info using already calculated step length
           tofInfo->addX2X0(mb.meanX2X0);
           tofInfo->addXRho(mb.getXRho(signCorr));
         }
       } else if (tofInfo) { // if tofInfo filling was requested w/o material correction, we need to calculate the step lenght
         auto xyz1 = track.getXYZGlo();
         math_utils::Vector3D<value_type> stepV(xyz1.X() - xyz0.X(), xyz1.Y() - xyz0.Y(), xyz1.Z() - xyz0.Z());
-        tofInfo->addStep(stepV.R(), track.getP2Inv());
+        tofInfo->addStep(stepV.R(), track.getQ2P2());
       }
       return res;
     };
@@ -717,7 +717,7 @@ GPUd() value_T PropagatorImpl<value_T>::estimateLTFast(o2::track::TrackLTIntegra
   // since we assume the track or its parent comes from the beam-line or decay, add XY(?) distance to it
   value_T dcaT = math_utils::detail::sqrt<value_type>(xdca * xdca + ydca * ydca);
   length += dcaT;
-  lt.addStep(length, trc.getP2Inv());
+  lt.addStep(length, trc.getQ2P2());
   return dcaT;
 }
 
diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index f689caed87351..c8c9dda6a4025 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -1714,7 +1714,7 @@ bool MatchTPCITS::refitTrackTPCITS(int slot, int iTPC, int& iITS, pmr::vector<o2
     }
     auto posEnd = tracOut.getXYZGlo();
     auto lInt = propagator->estimateLTIncrement(tracOut, posStart, posEnd);
-    tofL.addStep(lInt, tracOut.getP2Inv());
+    tofL.addStep(lInt, tracOut.getQ2P2());
     tofL.addX2X0(lInt * mTPCmeanX0Inv);
     propagator->PropagateToXBxByBz(tracOut, o2::constants::geom::XTPCOuterRef, MaxSnp, 10., mUseMatCorrFlag, &tofL);
 
@@ -1804,7 +1804,7 @@ bool MatchTPCITS::refitABTrack(int iITSAB, const TPCABSeed& seed, pmr::vector<o2
     }
     auto posEnd = tracOut.getXYZGlo();
     auto lInt = propagator->estimateLTIncrement(tracOut, posStart, posEnd);
-    tofL.addStep(lInt, tracOut.getP2Inv());
+    tofL.addStep(lInt, tracOut.getQ2P2());
     tofL.addX2X0(lInt * mTPCmeanX0Inv);
     propagator->PropagateToXBxByBz(tracOut, o2::constants::geom::XTPCOuterRef, MaxSnp, 10., mUseMatCorrFlag, &tofL);
     const auto& trackTune = TrackTuneParams::Instance();
diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index 375fa732007cc..b5a1530e83d8c 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -638,7 +638,7 @@ bool TRDGlobalTracking::refitITSTPCTRDTrack(TrackTRD& trk, float timeTRD, o2::gl
   }
   auto posEnd = trk.getXYZGlo();
   auto lInt = propagator->estimateLTIncrement(trk, posStart, posEnd);
-  trk.getLTIntegralOut().addStep(lInt, trk.getP2Inv());
+  trk.getLTIntegralOut().addStep(lInt, trk.getQ2P2());
   // trk.getLTIntegralOut().addX2X0(lInt * mTPCmeanX0Inv); // do we need to account for the material budget here? probably
 
   const auto& trackTune = TrackTuneParams::Instance();
@@ -733,7 +733,7 @@ bool TRDGlobalTracking::refitTPCTRDTrack(TrackTRD& trk, float timeTRD, o2::globa
   }
   auto posEnd = trk.getXYZGlo();
   auto lInt = propagator->estimateLTIncrement(trk, posStart, posEnd);
-  trk.getLTIntegralOut().addStep(lInt, trk.getP2Inv());
+  trk.getLTIntegralOut().addStep(lInt, trk.getQ2P2());
   // trk.getLTIntegralOut().addX2X0(lInt * mTPCmeanX0Inv); // do we need to account for the material budget here? probably?
 
   if (!propagator->PropagateToXBxByBz(trk, o2::constants::geom::XTPCInnerRef, o2::base::Propagator::MAX_SIN_PHI, o2::base::Propagator::MAX_STEP, matCorr, &trk.getLTIntegralOut())) {

From d56140caadf9045d58f85836bc9a0faed6a1a4c4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Apr 2025 11:16:19 +0200
Subject: [PATCH 0296/1764] GPU CMake: some cleanup / simplification

---
 GPU/Common/CMakeLists.txt                     |  6 +---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  3 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  4 +--
 GPU/GPUTracking/Base/opencl/CMakeLists.txt    |  4 +--
 GPU/GPUTracking/CMakeLists.txt                | 33 +++++++++----------
 GPU/GPUTracking/Interface/CMakeLists.txt      |  2 +-
 GPU/GPUTracking/Standalone/CMakeLists.txt     |  1 +
 .../Standalone/tools/dumpGPUDefParam.C        |  2 +-
 GPU/GPUTracking/display/CMakeLists.txt        |  4 +--
 GPU/TPCFastTransformation/CMakeLists.txt      |  6 ++--
 GPU/Utils/CMakeLists.txt                      |  3 +-
 11 files changed, 32 insertions(+), 36 deletions(-)

diff --git a/GPU/Common/CMakeLists.txt b/GPU/Common/CMakeLists.txt
index 6951c3b2339b8..b1a4b2107019c 100644
--- a/GPU/Common/CMakeLists.txt
+++ b/GPU/Common/CMakeLists.txt
@@ -62,10 +62,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                 COMPONENT_NAME GPU
                 LABELS gpu)
   endif()
-  install(FILES ${HDRS_INSTALL} DESTINATION include/GPU)
 endif()
 
-if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
-  install(FILES ${HDRS_INSTALL}
-  DESTINATION include)
-endif()
+install(FILES ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index dbdf6b606df18..c31dd0c8d3fe2 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -120,7 +120,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       ${CMAKE_SOURCE_DIR}/DataFormats/Reconstruction/src
       ${CMAKE_CURRENT_SOURCE_DIR}
     TARGETVARNAME targetName)
-  install(FILES ${HDRS} DESTINATION include/GPU)
 endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
@@ -132,6 +131,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
+install(FILES ${HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
 if (onnxruntime_FOUND)
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 4689fee02d31e..6eded3499e46e 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -169,8 +169,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       ${GPUCA_HIP_SOURCE_DIR}
     TARGETVARNAME targetName)
 
-  install(FILES ${HDRS} DESTINATION include/GPU)
-
 #  o2_add_test(GPUsortHIP NAME test_GPUsortHIP
 #                  SOURCES test/testGPUsortHIP.hip
 #                  PUBLIC_LINK_LIBRARIES O2::GPUCommon hip::host hip::device hip::hipcub roc::rocthrust
@@ -187,6 +185,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   include_directories(${GPUCA_HIP_SOURCE_DIR})
 endif()
 
+install(FILES ${HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
 if (onnxruntime_FOUND)
diff --git a/GPU/GPUTracking/Base/opencl/CMakeLists.txt b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
index 7ab70553958ef..99ec36615a1d1 100644
--- a/GPU/GPUTracking/Base/opencl/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
@@ -96,8 +96,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   # the compile_defitions are not propagated automatically on purpose (they are
   # declared PRIVATE) so we are not leaking them outside of the GPU**
   # directories
-
-  install(FILES ${HDRS} DESTINATION include/GPU)
 endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
@@ -107,6 +105,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   set(targetName ${MODULE})
 endif()
 
+install(FILES ${HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+
 if(OPENCL_ENABLED_SPIRV)
   target_compile_definitions(${targetName} PRIVATE OPENCL_ENABLED_SPIRV)
 endif()
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 4c1de17025627..ec60d41484f81 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -242,12 +242,13 @@ set(TEMPLATE_HEADER_LIST Base/GPUReconstructionKernelList.template.h
                          Definitions/GPUDefParametersLoad.template.inc)
 set(GENERATED_HEADERS_LIST "")
 
-file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
+set(ON_THE_FLY_DIR ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
+file(MAKE_DIRECTORY ${ON_THE_FLY_DIR})
 foreach(TEMPLATE_FILE ${TEMPLATE_HEADER_LIST})
   get_filename_component(OUTPUT_FILE_NAME ${TEMPLATE_FILE} NAME)
   string(REPLACE ".template" "" OUTPUT_FILE_NAME ${OUTPUT_FILE_NAME})
-  file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/${OUTPUT_FILE_NAME} INPUT ${TEMPLATE_FILE})
-  list(APPEND GENERATED_HEADERS_LIST ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/${OUTPUT_FILE_NAME})
+  file(GENERATE OUTPUT ${ON_THE_FLY_DIR}/${OUTPUT_FILE_NAME} INPUT ${TEMPLATE_FILE})
+  list(APPEND GENERATED_HEADERS_LIST ${ON_THE_FLY_DIR}/${OUTPUT_FILE_NAME})
 endforeach()
 set(GPUDEFPARAMETERSLBLIST "$<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,LB_>,\n>\n")
 string(APPEND GPUDEFPARAMETERSLBLIST "$<JOIN:$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_PARAMS>,PREPEND,PAR_>,\n>\n")
@@ -256,14 +257,14 @@ file(GENERATE
      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase
      CONTENT ${GPUDEFPARAMETERSLBLIST})
 add_custom_command(
-  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h
-  COMMAND awk "{print(\"#ifndef GPUCA_\" $0 \"\\n#define GPUCA_\" $0 \" 0\\n#endif\")}" ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase > ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h
+  OUTPUT ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h
+  COMMAND awk "{print(\"#ifndef GPUCA_\" $0 \"\\n#define GPUCA_\" $0 \" 0\\n#endif\")}" ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase > ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h
   COMMENT "Generating GPUDefParametersLoadPrepare.h"
   DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/GPUDefParametersLoadPrepareBase
   VERBATIM
   COMMAND_EXPAND_LISTS
 )
-list(APPEND GENERATED_HEADERS_LIST ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly/GPUDefParametersLoadPrepare.h)
+list(APPEND GENERATED_HEADERS_LIST ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h)
 
 set(HDRS_INSTALL ${HDRS_INSTALL} ${GENERATED_HEADERS_LIST})
 include(kernels.cmake)
@@ -306,7 +307,7 @@ set(INCDIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/Debug
     ${CMAKE_CURRENT_SOURCE_DIR}/DataCompression
     ${CMAKE_CURRENT_SOURCE_DIR}/TPCClusterFinder
-    ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
+    ${ON_THE_FLY_DIR})
 
 # Main CMake part for O2
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
@@ -356,12 +357,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                             HEADERS ${HDRS_CINT_O2} ${HDRS_CINT_O2_ADDITIONAL}
                             LINKDEF GPUTrackingLinkDef_O2.h)
 
-  install(FILES ${HDRS_SRCS} ${HDRS_CINT_O2} ${HDRS_CINT_DATATYPES} ${HDRS_INSTALL}
-          DESTINATION include/GPU)
-  install(DIRECTORY utils
-          DESTINATION include/GPU
-          FILES_MATCHING PATTERN *.h)
-
   o2_add_test_root_macro(Standalone/tools/createGeo.C
                          PUBLIC_LINK_LIBRARIES O2::GPUTracking
                          LABELS its COMPILE_ONLY)
@@ -390,13 +385,15 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   else()
     target_compile_definitions(${targetName} PRIVATE GPUCA_NO_ROOT)
   endif()
-  install(FILES ${HDRS_SRCS} ${HDRS_CINT_O2} ${HDRS_CINT_DATATYPES} ${HDRS_INSTALL}
-          DESTINATION include)
-  install(DIRECTORY utils
-          DESTINATION include
-          FILES_MATCHING PATTERN *.h)
 endif()
 
+install(FILES ${HDRS_SRCS} ${HDRS_CINT_O2} ${HDRS_CINT_DATATYPES} ${HDRS_INSTALL}
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+install(DIRECTORY utils
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU
+        FILES_MATCHING PATTERN *.h)
+
+
 # GPUReconstructionLibrary needs to know which GPU backends are enabled for proper error messages
 configure_file(Base/GPUReconstructionAvailableBackends.template.h ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionAvailableBackends.h)
 set_source_files_properties(Base/GPUReconstructionLibrary.cxx
diff --git a/GPU/GPUTracking/Interface/CMakeLists.txt b/GPU/GPUTracking/Interface/CMakeLists.txt
index baec5b941b4b6..e532b24f97908 100644
--- a/GPU/GPUTracking/Interface/CMakeLists.txt
+++ b/GPU/GPUTracking/Interface/CMakeLists.txt
@@ -46,4 +46,4 @@ target_include_directories(${targetName}
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
 
-install(FILES ${HDRS} DESTINATION include/GPU)
+install(FILES ${HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 0859223187f00..088269ae73cab 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -13,6 +13,7 @@
 cmake_minimum_required(VERSION 3.27 FATAL_ERROR)
 project(GPUTrackingStandalone)
 include(FeatureSummary)
+include(GNUInstallDirs)
 set(CMAKE_INSTALL_MESSAGE LAZY)
 
 set(CMAKE_INSTALL_BINDIR "${CMAKE_INSTALL_PREFIX}")
diff --git a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
index 785c049816252..dcb12db6c9118 100644
--- a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
+++ b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 // Run e.g. as:
-// ROOT_INCLUDE_PATH="`pwd`/include" root -l -q -b src/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C'()'
+// ROOT_INCLUDE_PATH="`pwd`/include/GPU" root -l -q -b src/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C'()'
 
 // Logic for testing to load the default parameters
 /* #define GPUCA_GPUCODE
diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index 592ba3b38ff30..d7d08f7f06101 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -133,8 +133,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
 
   target_compile_definitions(${targetName} PRIVATE GPUCA_BUILD_EVENT_DISPLAY_GLFW GPUCA_DISPLAY_GL3W GPUCA_DISPLAY_OPENGL_CORE)
 
-  install(FILES ${HDRS} ${HDRS_INSTALL} DESTINATION include/GPU)
-
   o2_add_executable(field-uniform-exporter
           TARGETVARNAME exporterName
           COMPONENT_NAME gpu
@@ -157,6 +155,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/setinclude.sh PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE DESTINATION displayTrackFilter)
 endif()
 
+install(FILES ${HDRS} ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
 message(STATUS "Building GPU Event Display (Vulkan ${GPUCA_EVENT_DISPLAY_VULKAN}, Wayland ${GPUCA_EVENT_DISPLAY_WAYLAND}, Freetype ${GPUCA_EVENT_DISPLAY_FREETYPE}, Fontconfig ${Fontconfig_FOUND}, Qt ${GPUCA_EVENT_DISPLAY_QT})")
diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index c7869467d15b5..317169c05f731 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -64,7 +64,6 @@ if(${ALIGPU_BUILD_TYPE} STREQUAL "O2")
                             HEADERS ${HDRS_CINT_O2}
                             LINKDEF TPCFastTransformationLinkDef_O2.h)
 
-  install(FILES ${HDRS_CINT_O2} DESTINATION include/GPU)
   file(COPY ${HDRS_CINT_O2} DESTINATION ${CMAKE_BINARY_DIR}/stage/include/GPU)
 
   o2_add_test(${MODULE}
@@ -115,6 +114,8 @@ if(${ALIGPU_BUILD_TYPE} STREQUAL "O2")
                            LABELS gpu tpc)
   endforeach()
 
+  install (FILES macro/TPCFastTransformInit.C
+           DESTINATION share/macro/)
 endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
@@ -123,8 +124,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   target_include_directories(${targetName} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
-install (FILES macro/TPCFastTransformInit.C
-         DESTINATION share/macro/)
+install(FILES ${HDRS_CINT_O2} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
 
 #
 # FIXME: this one is misplaced : it depends (at least) on TPCSimulation which is
diff --git a/GPU/Utils/CMakeLists.txt b/GPU/Utils/CMakeLists.txt
index bf23c792c2034..5ea8b59db5cad 100644
--- a/GPU/Utils/CMakeLists.txt
+++ b/GPU/Utils/CMakeLists.txt
@@ -31,5 +31,6 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                             HEADERS ${HDRS_CINT}
                             LINKDEF GPUUtilsLinkDef.h)
 
-  install(FILES ${HDRS_CINT} ${HDRS_INSTALL} DESTINATION include/GPU)
 endif()
+
+install(FILES ${HDRS_CINT} ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)

From 68c73f4ca4c851d3542be7acbd217f3fd68a4127 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Apr 2025 11:17:39 +0200
Subject: [PATCH 0297/1764] GPU CMake: Create const param files for available
 default architectures to be loaded by RTC

---
 GPU/GPUTracking/CMakeLists.txt                | 24 +++++++++++++++++
 .../Definitions/GPUDefParametersDefaults.h    | 11 ++++----
 GPU/GPUTracking/Standalone/CMakeLists.txt     |  1 +
 .../Standalone/tools/dumpGPUDefParam.C        | 27 +++++++++----------
 GPU/GPUTracking/display/CMakeLists.txt        |  4 +--
 GPU/TPCFastTransformation/CMakeLists.txt      |  4 +--
 6 files changed, 47 insertions(+), 24 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index ec60d41484f81..b2852389398d0 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -407,6 +407,30 @@ target_sources(${targetName}
                FILES ${GENERATED_HEADERS_LIST}
                BASE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
 
+make_directory(${CMAKE_CURRENT_BINARY_DIR}/genGPUArch)
+set(GPU_CONST_PARAM_ARCHITECTUES AMPERE TURING VEGA MI2xx)
+set(GPU_CONST_PARAM_FILES "")
+foreach(GPU_ARCH ${GPU_CONST_PARAM_ARCHITECTUES})
+  set(PARAMFILE ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/gpu_const_param_${GPU_ARCH}.par)
+  add_custom_command(
+    OUTPUT ${PARAMFILE}
+    COMMAND bash -c
+            "echo -e '#define GPUCA_GPUTYPE_${GPU_ARCH}\\n#define PARAMETER_FILE \"GPUDefParametersDefaults.h\"\\ngInterpreter->AddIncludePath(\"${CMAKE_CURRENT_SOURCE_DIR}/Definitions\");\\ngInterpreter->AddIncludePath(\"${ON_THE_FLY_DIR}\");\\n.x ${CMAKE_CURRENT_SOURCE_DIR}/Standalone/tools/dumpGPUDefParam.C(\"${PARAMFILE}\")\\n.q\\n'"
+            | root -l -b > /dev/null
+    VERBATIM
+    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch
+    MAIN_DEPENDENCY Standalone/tools/dumpGPUDefParam.C
+    DEPENDS Definitions/GPUDefParametersDefaults.h
+            ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h
+            ${ON_THE_FLY_DIR}/GPUDefParametersLoad.inc
+    COMMENT "Generating GPU parameter set for architecture ${GPU_ARCH}")
+  LIST(APPEND GPU_CONST_PARAM_FILES ${PARAMFILE})
+endforeach()
+
+add_custom_target(${MODULE}_GPU_CONST_PARAM_ARCHS ALL DEPENDS ${GPU_CONST_PARAM_FILES})
+install(FILES ${GPU_CONST_PARAM_FILES} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/arch_param)
+
+
 # Add compile definitions and libraries depending on available optional dependencies
 if(GPUCA_QA)
   message(STATUS "Building GPU QA")
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index a56fb97771fe5..cdc5efd56ddfd 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -22,6 +22,7 @@
 
 // GPU Run Configuration
 #if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.
+  #define GPUCA_LB_SCAN 512
   // GPU-architecture-dependent default settings
   #if defined(GPUCA_GPUTYPE_MI2xx)
     #define GPUCA_WARP_SIZE 64
@@ -498,11 +499,11 @@
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression GPUCA_LB_GPUTPCNNClusterizerKernels
 
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_THREAD_COUNT_SCAN
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_THREAD_COUNT_SCAN
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_THREAD_COUNT_SCAN
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanDown GPUCA_THREAD_COUNT_SCAN
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits GPUCA_THREAD_COUNT_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_LB_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_LB_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_LB_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanDown GPUCA_LB_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits GPUCA_LB_SCAN
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered GPUCA_LB_COMPRESSION_GATHER
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered32 GPUCA_LB_COMPRESSION_GATHER
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64 GPUCA_LB_COMPRESSION_GATHER
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 088269ae73cab..c112be6abac11 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -242,3 +242,4 @@ install(TARGETS ca TPCFastTransformation standalone_support)
 install(FILES "cmake/makefile" DESTINATION "${CMAKE_INSTALL_PREFIX}")
 install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${O2_DIR} ${CMAKE_INSTALL_PREFIX}/src)")
 install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_BINARY_DIR}/config.cmake ${CMAKE_INSTALL_PREFIX}/config.cmake)")
+install(DIRECTORY tools DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU)
diff --git a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
index dcb12db6c9118..f82c537956ead 100644
--- a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
+++ b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
@@ -12,27 +12,24 @@
 /// \file dumpGPUDefParam.C
 /// \author David Rohr
 
-// Run e.g. as:
-// ROOT_INCLUDE_PATH="`pwd`/include/GPU" root -l -q -b src/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C'()'
+// Run e.g. as (replacing [FILE] and [OUTPUT]:
+// echo -e '#define PARAMETER_FILE "[FILE]]"\ngInterpreter->AddIncludePath("'`pwd`'/include/GPU");\n.x share/GPU/tools/dumpGPUDefParam.C("[OUTPUT]")\n.q\n' | root -l -b
+// To dump the defaults for AMPERE architecture, run
+// echo -e '#define GPUCA_GPUTYPE_AMPERE\n#define PARAMETER_FILE "GPUDefParametersDefaults.h"\ngInterpreter->AddIncludePath("'`pwd`'/include/GPU");\n.x share/GPU/tools/dumpGPUDefParam.C("default_AMPERE.par")\n.q\n' | root -l -b
 
-// Logic for testing to load the default parameters
-/* #define GPUCA_GPUCODE
-#define GPUCA_GPUTYPE_AMPERE
-#define GPUCA_MAXN 40
-#define GPUCA_ROW_COUNT 152
-#define GPUCA_TPC_COMP_CHUNK_SIZE 1024
-#include "GPUDefParametersConstants.h"
-#include "GPUDefParametersDefaults.h" */
+#ifndef PARAMETER_FILE
+#error Must provide the PARAMETER_FILE as preprocessor define, e.g. -DHEADER_TO_INCLUDE='"GPUDefParametersDefaults.h"'
+#endif
 
-// Alternatively, logic to load file that sets GPUDefParameters
-#include "testParam.h"
+#define GPUCA_GPUCODE
+#include PARAMETER_FILE
 
 #include "GPUDefParametersLoad.inc"
-void dumpGPUDefParam()
+void dumpGPUDefParam(const char* outputfile = "parameters.out")
 {
   auto param = o2::gpu::internal::GPUDefParametersLoad();
-  printf("Loaded params:\n%s", o2::gpu::internal::GPUDefParametersExport(param, false).c_str());
-  FILE* fp = fopen("parameters.out", "w+b");
+  printf("Loaded params:\n%s\nWriting them to %s\n", o2::gpu::internal::GPUDefParametersExport(param, false).c_str(), outputfile);
+  FILE* fp = fopen(outputfile, "w+b");
   fwrite(&param, 1, sizeof(param), fp);
   fclose(fp);
 }
diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index d7d08f7f06101..a59d5189d6235 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -149,10 +149,10 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   target_link_libraries(${targetName} PUBLIC O2::GPUTracking)
   install(TARGETS ${MODULE})
 
-  install(DIRECTORY filterMacros/ DESTINATION displayTrackFilter FILES_MATCHING PATTERN "*.C")
+  install(DIRECTORY filterMacros/ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/displayTrackFilter FILES_MATCHING PATTERN "*.C")
   get_property(GPU_DISPLAY_INCLUDE_PATH DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
   configure_file(filterMacros/setinclude.sh.in setinclude.sh @ONLY)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/setinclude.sh PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE DESTINATION displayTrackFilter)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/setinclude.sh PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/displayTrackFilter)
 endif()
 
 install(FILES ${HDRS} ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index 317169c05f731..182a66fb28296 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -114,8 +114,8 @@ if(${ALIGPU_BUILD_TYPE} STREQUAL "O2")
                            LABELS gpu tpc)
   endforeach()
 
-  install (FILES macro/TPCFastTransformInit.C
-           DESTINATION share/macro/)
+  install(FILES macro/TPCFastTransformInit.C
+          DESTINATION share/macro/)
 endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")

From 3684fcc3d08b87fd2a0ff2d9077586a15d191e77 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Apr 2025 13:59:44 +0200
Subject: [PATCH 0298/1764] GPU: Remove obsolete .gitignore files

---
 GPU/GPUTracking/.gitignore                  |  1 -
 GPU/GPUTracking/Standalone/.gitignore       |  5 -----
 GPU/GPUTracking/Standalone/tools/.gitignore |  5 -----
 GPU/GPUTracking/utils/.gitignore            | 17 -----------------
 4 files changed, 28 deletions(-)
 delete mode 100644 GPU/GPUTracking/.gitignore
 delete mode 100644 GPU/GPUTracking/Standalone/.gitignore
 delete mode 100644 GPU/GPUTracking/Standalone/tools/.gitignore
 delete mode 100644 GPU/GPUTracking/utils/.gitignore

diff --git a/GPU/GPUTracking/.gitignore b/GPU/GPUTracking/.gitignore
deleted file mode 100644
index 7669bc79c7059..0000000000000
--- a/GPU/GPUTracking/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-/utils/.svn
diff --git a/GPU/GPUTracking/Standalone/.gitignore b/GPU/GPUTracking/Standalone/.gitignore
deleted file mode 100644
index d0d3c34e96452..0000000000000
--- a/GPU/GPUTracking/Standalone/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-/config_options.mak
-/release
-/ca
-/ca.exe
-/libGPUTracking*.so
diff --git a/GPU/GPUTracking/Standalone/tools/.gitignore b/GPU/GPUTracking/Standalone/tools/.gitignore
deleted file mode 100644
index 6ddce7f156a23..0000000000000
--- a/GPU/GPUTracking/Standalone/tools/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-*.o
-*.bc
-*.cl
-*.spv
-*.spirv
diff --git a/GPU/GPUTracking/utils/.gitignore b/GPU/GPUTracking/utils/.gitignore
deleted file mode 100644
index ff145e23751f6..0000000000000
--- a/GPU/GPUTracking/utils/.gitignore
+++ /dev/null
@@ -1,17 +0,0 @@
-/get_private_profile.h
-/os_low_level_helper.h
-/affinity.cxx
-/affinity.h
-/qmath.h
-/qmultialloc.*
-/qmalloc.*
-/sched_affinity_win32_wrapper.h
-/switchtemplate.h
-/util_adl.cxx
-/util_adl.h
-/vecpodtest.cxx
-/*.cpp
-/*.sh
-/.svn
-/as
-/callvc.bat

From 32319712858a1882e8826a7e62129ac619a548f9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Apr 2025 22:45:14 +0200
Subject: [PATCH 0299/1764] Update / add documentation for FST

---
 .../documentation/dpl-workflow-options.md     |  55 ++++++++
 .../documentation/env-variables.md            |  51 +++++++
 .../full-system-test-as-stress-test.md        |  33 +++++
 .../documentation/full-system-test-setup.md   | 124 ++++++++++++++++++
 .../full-system-test.md}                      |   6 +-
 .../documentation/raw-data-simulation.md      |  43 ++++++
 6 files changed, 309 insertions(+), 3 deletions(-)
 create mode 100644 prodtests/full-system-test/documentation/dpl-workflow-options.md
 create mode 100644 prodtests/full-system-test/documentation/env-variables.md
 create mode 100644 prodtests/full-system-test/documentation/full-system-test-as-stress-test.md
 create mode 100644 prodtests/full-system-test/documentation/full-system-test-setup.md
 rename prodtests/full-system-test/{README.md => documentation/full-system-test.md} (95%)
 create mode 100644 prodtests/full-system-test/documentation/raw-data-simulation.md

diff --git a/prodtests/full-system-test/documentation/dpl-workflow-options.md b/prodtests/full-system-test/documentation/dpl-workflow-options.md
new file mode 100644
index 0000000000000..f79e481ce0723
--- /dev/null
+++ b/prodtests/full-system-test/documentation/dpl-workflow-options.md
@@ -0,0 +1,55 @@
+# Configuration options
+You can use the following options to change the workflow behavior:
+- `DDMODE` (default `processing`) : Must be `processing` (synchronous processing) or `processing-disk` (synchronous processing + storing of raw time frames to disk, note that this is the raw time frame not the CTF!). The `DDMODE` `discard` and `disk` are not compatible with the synchronous processing workflow, you must use the `no-processing.desc` workflow instead!.
+- `WORKFLOW_DETECTORS` (default `ALL`) : Comma-separated list of detectors for which the processing is enabled. If these are less detectors than participating in the run, data of the other detectors is ignored. If these are more detectors than participating in the run, the processes for the additional detectors will be started but will not do anything.
+- `WORKFLOW_DETECTORS_QC` (default `ALL`) : Comma-separated list of detectors for which to run QC, can be a subset of `WORKFLOW_DETECTORS` (for standalone detectors QC) and `WORKFLOW_DETECTORS_MATCHING` (for matching/vertexing QC). If a detector (matching/vertexing step) is not listed in `WORKFLOW_DETECTORS` (`WORKFLOW_DETECTORS_MATCHING`), the QC is automatically disabled for that detector. Only active if the `WORKFLOW_PARAMETER=QC` is set.
+- `WORKFLOW_DETECTORS_CALIB` (default `ALL`) : Comma-separated list of detectors for which to run calibration, can be a subset of `WORKFLOW_DETECTORS`. If a detector is not listed in `WORKFLOW_DETECTORS`, the calibration is automatically disabled for that detector. Only active if the `WORKFLOW_PARAMETER=CALIB` is set.
+- `WORKFLOW_DETECTORS_FLP_PROCESSING` (default `TOF` for sync processing on EPN, `NONE` otherwise) : Signals that these detectors have processing on the FLP enabled. The corresponding steps are thus inactive in the EPN epl-workflow, and the raw-proxy is configured to receive the FLP-processed data instead of the raw data in that case.
+- `WORKFLOW_DETECTORS_RECO` (default `ALL`) : Comma-separated list of detectors for which to run reconstruction.
+- `WORKFLOW_DETECTORS_CTF` (default `ALL`) : Comma-separated list of detectors to include in CTF.
+- `WORKFLOW_DETECTORS_MATCHING` (default selected corresponding to default workflow for sync or async mode respectively) : Comma-separated list of matching / vertexing algorithms to run. Use `ALL` to enable all of them. Currently supported options (see LIST_OF_GLORECO in common/setenv.h): `ITSTPC`, `TPCTRD`, `ITSTPCTRD`, `TPCTOF`, `ITSTPCTOF`, `MFTMCH`, `PRIMVTX`, `SECVTX`.
+- `WORKFLOW_EXTRA_PROCESSING_STEPS` Enable additional processing steps not in the preset for the SYNC / ASYNC mode. Possible values are: `MID_RECO` `MCH_RECO` `MFT_RECO` `FDD_RECO` `FV0_RECO` `ZDC_RECO` `ENTROPY_ENCODER` `MATCH_ITSTPC` `MATCH_TPCTRD` `MATCH_ITSTPCTRD` `MATCH_TPCTOF` `MATCH_ITSTPCTOF` `MATCH_MFTMCH` `MATCH_MFTMCH` `MATCH_PRIMVTX` `MATCH_SECVTX`. (Here `_RECO` means full async reconstruction, and can be used to enable it also in sync mode.)
+- `WORKFLOW_PARAMETERS` (default `NONE`) : Comma-separated list, enables additional features of the workflow. Currently the following features are available:
+  - `GPU` : Performs the TPC processing on the GPU, otherwise everything is processed on the CPU.
+  - `CTF` : Write the CTF to disk (CTF creation is always enabled, but if this parameter is missing, it is not stored).
+  - `EVENT_DISPLAY` : Enable JSON export for event display.
+  - `QC` : Enable QC.
+  - `CALIB` : Enable calibration (not yet working!)
+- `RECO_NUM_NODES_OVERRIDE` (default `0`) : Overrides the number of EPN nodes used for the reconstruction (`0` or empty means default).
+- `MULTIPLICITY_FACTOR_RAWDECODERS` (default `1`) : Scales the number of parallel processes used for raw decoding by this factor.
+- `MULTIPLICITY_FACTOR_CTFENCODERS` (default `1`) : Scales the number of parallel processes used for CTF encoding by this factor.
+- `MULTIPLICITY_FACTOR_REST` (default `1`) : Scales the number of other reconstruction processes by this factor.
+- `QC_JSON_EXTRA` (default `NONE`) : extra QC jsons to add (if does not fit to those defined in WORKFLOW_DETECTORS_QC & (WORKFLOW_DETECTORS | WORKFLOW_DETECTORS_MATCHING)
+Most of these settings are configurable in the AliECS GUI. But some of the uncommon settings (`WORKFLOW_DETECTORS_FLP_PROCESSING`, `WORKFLOW_DETECTORS_CTF`, `WORKFLOW_DETECTORS_RECO`, `WORKFLOW_DETECTORS_MATCHING`, `WORKFLOW_EXTRA_PROCESSING_STEPS`, advanced `MULTIPLICITY_FACTOR` settings) can only be set via the "Additional environment variables field" in the GUI using bash syntax, e.g. `WORKFLOW_DETECTORS_FLP_PROCESSING=TPC`.
+
+# Process multiplicity factors
+- The production workflow has internally a default value how many instances of a process to run in parallel (which was tuned for Pb-Pb processing)
+- Some critical processes for synchronous pp processing are automatically scaled by the inverse of the number of nodes, i.e. the multiplicity is increased by a factor of 2 if 125 instead of 250 nodes are used, to enable the processing using only a subset of the nodes.
+- Factors can be provided externally to scale the multiplicity of processes further. All these factors are multiplied.
+  - One factor can be provided based on the type of the processes: raw decoder (`MULTIPLICITY_FACTOR_RAWDECODERS`), CTF encoder (`MULTIPLICITY_FACTOR_CTFENCODERS`), or other reconstruction process (`MULTIPLICITY_FACTOR_REST`)
+  - One factor can be provided per detector via `MULTIPLICITY_FACTOR_DETECTOR_[DET]` using the 3 character detector representation, or `MATCH` for the global matching and vertexing workflows.
+  - One factor can be provided per process via `MULTIPLICITY_FACTOR_PROCESS_[PROCESS_NAME]`. In the process name, dashes `-` must be replaced by underscores `_`.
+- The multiplicity of an individual process can be overridden externally (this is an override, no scaling factor) by using `MULTIPLICITY_PROCESS_[PROCESS_NAME]`. In the process name, dashes `-` must be replaced by underscores `_`.
+- For example, creating the workflow with `MULTIPLICITY_FACTOR_RAWDECODERS=2 MULTIPLICITY_FACTOR_DETECTOR_ITS=3 MULTIPLICITY_FACTOR_PROCESS_mft_stf_decoder=5` will scale the number of ITS raw decoders by 6, of other ITS processes by 3, of other raw decoders by 2, and will run exactly 5 `mft-stf-decoder` processes.
+
+# Additional custom control variables
+For user modification of the workflow settings, the folloing *EXTRA* environment variables exist:
+- `ARGS_ALL_EXTRA` : Extra command line options added to all workflows
+- `ALL_EXTRA_CONFIG` : Extra config key values added to all workflows
+- `GPU_EXTRA_CONFIG` : Extra options added to the configKeyValues of the GPU workflow
+- `ARGS_EXTRA_PROCESS_[WORKFLOW_NAME]` : Extra command line arguments for the workflow binary `WORKFLOW_NAME`. Dashes `-` must be replaced by underscores `_` in the name! E.g. `ARGS_EXTRA_PROCESS_o2_tof_reco_workflow='--output-type clusters'`
+- `CONFIG_EXTRA_PROCESS_[WORKFLOW_NAME]` : Extra `--configKeyValues` arguments for the workflow binary `WORKFLOW_NAME`. Dashes `-` must be replaced by underscores `_` in the name! E.g. `CONFIG_EXTRA_PROCESS_o2_gpu_reco_workflow='GPU_proc.debugLevel=1;GPU_proc.ompKernels=0;'`
+
+**IMPORTANT:** When providing additional environment variables please always use single quotes `'` instead of double quotes `"`, because otherwise there can be issues with whitespaces. E.g. `ARGS_EXTRA_PROCESS_o2_eve_display='--filter-time-min 0 --filter-time-max 120'` does work while `ARGS_EXTRA_PROCESS_o2_eve_display="--filter-time-min 0 --filter-time-max 120"` does not.
+
+In case the CTF dictionaries were created from the data drastically different from the one being compressed, the default memory allocation for the CTF buffer might be insufficient. One can apply scaling factor to the buffer size estimate (default=1.5) of particular detector by defining variable e.g. `TPC_ENC_MEMFACT=3.5`
+
+# File input for ctf-reader / raw-tf-reader
+- The variable `$INPUT_FILE_LIST` can be a comma-seperated list of files, or a file with a file-list of CTFs/raw TFs.
+- The variable `$INPUT_FILE_COPY_CMD` can provide a custom copy command (default is to fetch the files from EOS).
+
+# Remarks on QC
+The JSON files for the individual detectors are merged into one JSON file, which is cached during the run on the shared EPN home folder.
+The default JSON file per detector is defined in `qc-workflow.sh`.
+JSONs per detector can be overridden by exporting `QC_JSON_[DETECTOR_NAME]`, e.g. `QC_JSON_TPC`, when creating the workflow.
+The global section of the merged qc JSON config is taken from qc-sync/qc-global.json
diff --git a/prodtests/full-system-test/documentation/env-variables.md b/prodtests/full-system-test/documentation/env-variables.md
new file mode 100644
index 0000000000000..b93622c0a0f94
--- /dev/null
+++ b/prodtests/full-system-test/documentation/env-variables.md
@@ -0,0 +1,51 @@
+The `setenv-sh` script sets the following environment options
+* `NTIMEFRAMES`: Number of time frames to process.
+* `TFDELAY`: Delay in seconds between publishing time frames (1 / rate).
+* `NGPUS`: Number of GPUs to use, data distributed round-robin.
+* `GPUTYPE`: GPU Tracking backend to use, can be CPU / CUDA / HIP / OCL / OCL2.
+* `SHMSIZE`: Size of the global shared memory segment.
+* `DDSHMSIZE`: Size of shared memory unmanaged region for DataDistribution Input.
+* `GPUMEMSIZE`: Size of allocated GPU memory (if GPUTYPE != CPU)
+* `HOSTMEMSIZE`: Size of allocated host memory for GPU reconstruction (0 = default).
+  * For `GPUTYPE = CPU`: TPC Tracking scratch memory size. (Default 0 -> dynamic allocation.)
+  * Otherwise : Size of page-locked host memory for GPU processing. (Defauls 0 -> 1 GB.)
+* `CREATECTFDICT`: Create CTF dictionary.
+* `SAVECTF`: Save the CTF to a root file.
+  * 0: Read `ctf_dictionary.root` as input.
+  * 1: Create `ctf_dictionary.root`. Note that this was already done automatically if the raw data was simulated with `full_system_test.sh`.
+* `SYNCMODE`: Run only reconstruction steps of the synchronous reconstruction.
+  * Note that there is no `ASYNCMODE` but instead the `CTFINPUT` option already enforces asynchronous processing.
+* `NUMAGPUIDS`: NUMAID-aware GPU id selection. Needed for the full EPN configuration with 8 GPUs, 2 NUMA domains, 4 GPUs per domain.
+  In this configuration, 2 instances of `dpl-workflow.sh` must run in parallel.
+  To be used in combination with `NUMAID` to select the id per workflow.
+  `start_tmux.sh` will set up these variables automatically.
+* `NUMAID`: SHM segment id to use for shipping data as well as set of GPUs to use (use `0` / `1` for 2 NUMA domains, 0 = GPUS `0` to `NGPUS - 1`, 1 = GPUS `NGPUS` to `2 * NGPUS - 1`)
+* 0: Runs all reconstruction steps, of sync and of async reconstruction, using raw data input.
+* 1: Runs only the steps of synchronous reconstruction, using raw data input.
+* `EXTINPUT`: Receive input from raw FMQ channel instead of running o2-raw-file-reader.
+  * 0: `dpl-workflow.sh` can run as standalone benchmark, and will read the input itself.
+  * 1: To be used in combination with either `datadistribution.sh` or `raw-reader.sh` or with another DataDistribution instance.
+* `CTFINPUT`: Read input from CTF ROOT file. This option is incompatible to EXTINPUT=1. The CTF ROOT file can be stored via SAVECTF=1.
+* `NHBPERTF`: Time frame length (in HBF)
+* `GLOBALDPLOPT`: Global DPL workflow options appended to o2-dpl-run.
+* `EPNPIPELINES`: Set default EPN pipeline multiplicities.
+  Normally the workflow will start 1 dpl device per processor.
+  For some of the CPU parts, this is insufficient to keep step with the GPU processing rate, e.g. one ITS-TPC matcher on the CPU is slower than the TPC tracking on multiple GPUs.
+  This option adds some multiplicies for CPU processes using DPL's pipeline feature.
+  The settings were tuned for EPN processing with 4 GPUs (i.e. the default multiplicities are per NUMA domain).
+  The multiplicities are scaled with the `NGPUS` setting, i.e. with 1 GPU only 1/4th are applied.
+  You can pass an option different to 1, and than it will be applied as factor on top of the multiplicities.
+  It is auto-selected by `start-tmux.sh`.
+* `SEVERITY`: Log verbosity (e.g. info or error, default: info)
+* `INFOLOGGER_SEVERITY`: Min severity for messages sent to Infologger. (default: `$SEVERITY`)
+* `SHMTHROW`: Throw exception when running out of SHM memory.
+  It is suggested to leave this enabled (default) on tests on the laptop to get an actual error when it runs out of memory.
+  This is disabled in `start_tmux.sh`, to avoid breaking the processing while there is a chance that another process might free memory and we can continue.
+* `NORATELOG`: Disable FairMQ Rate Logging.
+* `INRAWCHANNAME`: FairMQ channel name used by the raw proxy, must match the name used by DataDistribution.
+* `WORKFLOWMODE`: run (run the workflow (default)), print (print the command to stdout), dds (create partial DDS topology)
+* `FILEWORKDIR`: directory for all input / output files. E.g. grp / geometry / dictionaries etc. are read from here, and dictionaries / ctf / etc. are written to there.
+  Some files have more fine grained control via other environment variables (e.g. to store the CTF to somewhere else). Such variables are initialized to `$FILEWORKDIR` by default but can be overridden.
+* `EPNSYNCMODE`: Specify that this is a workflow running on the EPN for synchronous processing, e.g. logging goes to InfoLogger, DPL metrics to to the AliECS monitoring, etc.
+* `BEAMTYPE`: Beam type, must be PbPb, pp, pPb, cosmic, technical.
+* `IS_SIMULATED_DATA` : 1 for MC data, 0 for RAW data.
diff --git a/prodtests/full-system-test/documentation/full-system-test-as-stress-test.md b/prodtests/full-system-test/documentation/full-system-test-as-stress-test.md
new file mode 100644
index 0000000000000..0c4637ece0920
--- /dev/null
+++ b/prodtests/full-system-test/documentation/full-system-test-as-stress-test.md
@@ -0,0 +1,33 @@
+This is a quick summary how to run the full system test (FST) as stress test on the EPN. (For the full FST documentation, see https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test-setup.md and https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test.md)
+
+# Preparing the data set
+- I usually try to keep an up-to-date data set that can be used in `/home/drohr/alitest/tmp-fst*`. The folder with the highest number is the latest dataset. However, data formats are still evolving, and it requires rerunning the simulation regularly. I.e. please try my latest data set, if it doesn't work, please generate a new one as described below.
+- Short overview how to generate a FST Pb-Pb 128 orbit data set:
+  - The O2 binaries installed on the EPN via RPMs use the `o2-dataflow` defaults and cannot run the simulation, and also they lack readout. Thus you need to build `O2PDPSuite` and `Readout` (the version matching the O2PDPSuite RPM you want to use for running the test) yourself with `alibuild` on an EPN: `aliBuild --defaults o2 build O2PDPSuite Readout --jobs 32 --debug`. The flag `--jobs` configures the number of parallel jobs and can be changed.
+  - Enter the O2PDPSuite environment either vie `alienv enter O2PDPSuite/latest Readout/latest`.
+  - Go to an empty directory.
+  - Run the FST simulation via: `NEvents=650 NEventsQED=10000 SHMSIZE=128000000000 TPCTRACKERSCRATCHMEMORY=40000000000 SPLITTRDDIGI=0 GENERATE_ITSMFT_DICTIONARIES=1 $O2_ROOT/prodtests/full_system_test.sh`
+  - Get a current matbud.root (e.g. from here https://alice.its.cern.ch/jira/browse/O2-2288) and place it in that folder.
+  - Create a timeframe file from the raw files: `$O2_ROOT/prodtests/full-system-test/convert-raw-to-tf-file.sh`.
+  - Prepare the ramdisk folder: `mv raw/timeframe raw/timeframe-org; mkdir raw/timeframe-tmpfs; ln -s timeframe-tmpfs raw/timeframe`
+
+# Running the full system test
+- Enter the environment! On an EPN do `module load O2PDPSuite` (this will load the latest O2 software installed on that EPN).
+- Go into the folder with the data set (you might need to create one, see above).
+- Prepare the ramdisk with the data: `sudo mount -t tmpfs tmpfs raw/timeframe-tmpfs; sudo cp raw/timeframe-org/* raw/timeframe`
+  - (NOTE that the ramdisk might already be present from previous tests, or in a different folder. Check the mounted tmpfs filesystems (`mount | grep tmpfs`), and don't mount multiple of them since memory is critical!)
+  - If you do not have root permissions and cannot create a ramdisk, the test will also work without. In that case you should decrease the publishing rate below to `TFDELAY=5`.
+- Make sure disk caches are cleared: as ROOT do: `echo 1 > /proc/sys/vm/drop_caches`
+- In order to run the Full System Test, the workflow must be able to access the CCDB. Normally, if you run as user, you must make sure to have an alien token present. On the EPN, one can use the EPN-internal CCDB server instead, which does not require alien access. If you use the `start-tmux.sh`, the env variables are set automatically to access the EPN-internal CCDB server.
+- Start the FST with 2 NUMA domains: `TFDELAY=2.5 NTIMEFRAMES=1000000 $O2_ROOT/prodtests/full-system-test/start_tmux.sh dd`
+
+This will start a tmux session with 3 shells, the upper 2 shells are the 2 DPL workflows, one per NUMA domain, for the processing. The lower shell is the input with DataDistribution's StfBuilder. Leave it running and check that the StfBuilder doesn't complain that its buffer is full. Then the EPN can sustain the rate.
+
+# **NOTE**
+- Attached to this ticket is a screenshot of how the console should look like:
+  - The DD console (on the bottom) should not show warnings about full buffers.
+  - The other 2 consoles (1 per NUMA domain) should show the processing times per TF for the GPU reconstruction:
+    ```
+    [2974450:gpu-reconstruction_t3]: [10:50:38][INFO] GPU Reoncstruction time for this TF 26.77 s (cpu), 17.8823 s (wall)
+    ```
+    This should be 17 to 18 seconds, and you should see it for all 4 GPUs on both NUMA domains (`reconstruction_t0` to `reconstruction_t3`)
diff --git a/prodtests/full-system-test/documentation/full-system-test-setup.md b/prodtests/full-system-test/documentation/full-system-test-setup.md
new file mode 100644
index 0000000000000..82ef9b7d0c74f
--- /dev/null
+++ b/prodtests/full-system-test/documentation/full-system-test-setup.md
@@ -0,0 +1,124 @@
+This is some documentation for the full system test setup.
+
+If you just want to test a small dataset, you can skip the following steps, and jusddt skip to the end, where you will find a download with a prepared data set!
+
+# Requirements:
+- The FST needs a lot of memory. Please check the comments below, make sure your system has enough memory, and change the memory sizes in the command lines accordingly.
+- ulimits: The FST needs large ulimits for memory and virtual memory (`ulimit -m` / `ulimit -v`). This is usually no problem since they are usually unlimited. If GPUs are used, the FST also needs `ulimit -l` (for locked memory) unlimited, which is usualy not the system default. Finally, if data is replayed from raw files (not with DataDistribution), the FST will open many files, and `ulimit -n` should be at least 4096. Note that in most distributions the hard ulimits are configured in `/etc/security/limits.conf`.
+- The FST needs to access the CCDB. For this, you should run the FST with an alien token. Alternatively, if you are on the EPN you can use the EPN-internal CCDB server by exporting `ALL_EXTRA_CONFIG="NameConf.mCCDBServer=http://o2-ccdb.internal;"` and by setting the DPL CCDB backend on the command line. If you are using `start-tmux.sh` for the 8 GPU FST, the CCDB backends are set automatically.
+
+# Creating the raw data and run the FST:
+1. First some remarks on the number of events and the memory size:
+    - Generation (simulation) of the full time frame with ~550 collisions will need ~256 GB, processing will take less.
+    - Due to the sampling of the bunch crossings, the exact number of collissions that will be in the TF is not clear, thus one should simulate 600 collisions to generate a full 128 orbit TF.
+    - The default shared memory size is 2 GB, and must be increased significantly for large time frames, 128 GB is sufficient for 128 orbit TF, 160 GB is needed if MC labels are present in addition.
+    - The GPU memory allocation should be set to ~13 GB for 70 orbits and 21 GB for 128 orbits.
+    - I'd suggest to do a first small test with 1-5 events to check the machinery, 100 events is already a good size which should not exhaust the memory, I'd go to 600 only after 100 works.
+1. Compile O2 with GPU support, in addition you need O2sim, DataDistribution, and Readout (latest versions from alidist will do).
+ GPUs for O2 should be auto-detected, but you can set the environment variables ALIBUILD_ENABLE_CUDA / ALIBUILD_ENABLE_HIP to enforce it (and get a failure when detection fails). Look for CMake log messages "Building GPUTracking with CUDA support" (etc) to verify.
+ For more information, see https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/build.md
+1. Optionally place some binary configuration files in the simulation folder. Default objects will be used if no such files are placed. There are instructions at the end of this post how to generate these files. (Currently, these files are: matbud.root, ITSdictionary.bin, ctf_dictionary.root, tpctransform.root, dedxsplines.root, and tpcpadgaincalib.root)
+1. Load the O2sim environment (`alienv enter O2sim/latest`) and run the following full system test script for a full simulation and digits to raw conversion (this will already include 1 CPU reconstruction run):
+    ```
+    NEvents=600 NEventsQED=35000 SHMSIZE=128000000000 TPCTRACKERSCRATCHMEMORY=30000000000 $O2_ROOT/prodtests/full_system_test.sh
+    ```
+    - This create a full 128 orbit TF with 550 collisions and uses 35000 interactions for the QED background
+    - It uses 128 GB of shared memory
+    - The scratch memory size for the TPC reconstruction is set to 24 GB (Note, this is the CPU-equivalent of the GPU memory size, since this phase will only run on the CPU).
+1. Test of the workflow using the raw-file-reader: Run the so far largest workflow, The GPU and SHM memory sizes must be reasonably large (see above).
+    ```
+    SHMSIZE=128000000000 NTIMEFRAMES=10 TFDELAY=100 GPUTYPE=CPU $O2_ROOT/prodtests/full-system-test/dpl-workflow.sh
+    ```
+    Note that This uses 128 GB of SHM, runs only on the CPU, and processes the time frame 10 times in a loop with 100 s delay between the publiushing.
+    - For a documentation of the options, see https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test.md
+    - For running on the GPU (4 GPUs with the HIP backend), please do
+        ```
+        SHMSIZE=128000000000 NTIMEFRAMES=10 TFDELAY=10 GPUTYPE=HIP NGPUS=4 GPUMEMSIZE=22000000000 $O2_ROOT/prodtests/full-system-test/dpl-workflow.sh
+        ```
+This will use 4 GPU with the HIP backend and allocate 22 GB of scratch memory on the GPU (should be sufficient for 128 orbit TF). You can change the GPU type as indicated in the linked README.md above, e.g. `GPUTYPE=CUDA NGPUS=1` for 1 CUDA GPU.
+1. With this, the full chain is running inside O2 DPL. Next we are adding DataDistribution.
+    1. Ceate the TF files as explained in the subtask (https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/raw-data-simulation.md). For convenience, there is a script that should do it automatically, from a shell that has loaded both DataDistribution and Readout: `$O2_ROOT/prodtests/full-system-test/convert-raw-to-tf-file.sh`.
+    1. Enter the O2 environment, and run the following script (please adjust the variables as in the test before).
+        ```
+        EXTINPUT=1 SHMSIZE=128000000000 GPUTYPE=CPU $O2_ROOT/prodtests/full-system-test/dpl-workflow.sh
+        ```
+        - As a first optional test without DataDistribution, we can take the RawReader to feed the data in the way DataDistribution does. Run the following script in a second shell within the O2 environment. (Please adjust the variables as noted above)
+            ```
+            SHMSIZE=128000000000 NTIMEFRAMES=10 TFDELAY=100 $O2_ROOT/prodtests/full-system-test/raw-reader.sh
+            ```
+    1. In a second shell with DataDistribution, run the following script (adjust the 2 variables for memory size as needed for your data, and set the TF_DIR variable to the folder where you recorded the time frame). Make sure you start this script ONLY AFTER the DPL workflow has fully started! There is no number of timeframes, it will run in an endless loop
+        ```
+        SHMSIZE=128000000000 DDSHMSIZE=32000 TFDELAY=100 $O2_ROOT/prodtests/full-system-test/datadistribution.sh
+        ```
+1. The full chain that will be running on the EPN farm is a bit more complicated. It consists of:
+    - 2 instances of the dpl-workflow driving 4 GPUs each, one per NUMA domain.
+    - 1 instance of data distribution feeding a shared input buffer.
+        The following script runs the full system test in the 8 GPU EPN configuration using tmux with 3 sessions:{code}TFDELAY=2.8457 NTIMEFRAMES=128 $O2_ROOT/prodtests/full-system-test/start-tmux.sh dd{code}
+    - Note that number of GPUs / memory sizes are automatically set by start-tmux.sh.
+    - This TFDELAY is the rate for processing 1/250th of 50 kHz Pb-Pb with average time frames. Since the occupancy of your simulated timeframe will fluctuate, it is suggested to scale the TFDELAY linearly with the number of tpc clusters (shown in the console output of the dpl-workflow), with the average corresponding to 2.8457 s being 313028012 clusters.
+    - You can for testing alternatively use the rawreader instead of datadistribution as input in the start_tmux.sh script by passing rr instead of dd.
+1. On the EPN, an SHM management tool owns the memory in the background and keeps it locked. This is done in order to speed up the startup. This behavior can be reproduced in the full system test, by setting the env variable `SHM_MANAGER_SHMID` to the shm id to be used (must be set for both `start_tmux.sh` and `shm-tool.sh`) you can juse use `SHM_MANAGER_SHMID=1` for a test) and running in a separate shell before starting `start_tmux.sh`
+    ```
+    SHM_MANAGER_SHMID=1 SHMSIZE=$((128<<30)) DDSHMSIZE=$((128<<10)) $O2_ROOT/prodtests/full-system-test/shm-tool.sh
+    SHM_MANAGER_SHMID=1 TFDELAY=2.8457 NTIMEFRAMES=8 $O2_ROOT/prodtests/full-system-test/start-tmux.sh dd
+    ```
+
+---
+
+# Remarks for running with distortions:
+1. To run the digitization with distortions, add the following to the digitizer command (using map inputSCDensity3D_8000_0 from file../InputSCDensityHistograms_8000events.root):
+    ```
+    --distortionType 2 --initialSpaceChargeDensity=../InputSCDensityHistograms_8000events.root,inputSCDensity3D_8000_0
+    ```
+1. To rerun the digitization with the same BC sampling for the collisions add
+    ```
+    --incontext collisioncontext.root
+    ```
+1. To create the tpc fast transform map from the SCD object run:
+    ```
+    root -l -q -b ~/alice/O2/Detectors/TPC/reconstruction/macro/createTPCSpaceChargeCorrection.C++'("../InputSCDensityHistograms_8000events.root", "inputSCDensity3D_8000_0")'
+    ```
+1. In order to use the fast transform map for TPC tracking, add to the tpc-recop-workflow:
+    ```
+    --configKeyValues "GPU_global.transformationFile=tpctransform.root"
+    ```
+
+---
+
+# Remarks for creating other prerequisite binary files:
+1. To create the CTF dictionary: Run the full system test workflow once setting the env variable CREATECTFDICT=1:
+    ```
+    CREATECTFDICT=1 $O2_ROOT/prodtests/full-system-test/dpl-workflow.sh
+    ```
+1. Create the ITS pattern dictionary
+    ```
+    o2-its-reco-workflow --trackerCA --disable-mc --configKeyValues "fastMultConfig.cutMultClusLow=30000;fastMultConfig.cutMultClusHigh=2000000;fastMultConfig.cutMultVtxHigh=500"
+    root -b -q ~/alice/O2/Detectors/ITSMFT/ITS/macros/test/CheckTopologies.C++
+    ```
+    - Note that the ITS dictionary used for raw generation and for reconstruction must be the same. I.e., if you change this, you have to either restart from scratch with the new dictionary file or rerun the ITS raw generation part of `$O2_ROOT/prodtests/full_system_test.sh`.
+1. To create the material lookup table
+    ```
+    root -l -q -b $O2_ROOT/Detectors/Base/test/buildMatBudLUT.C
+    ```
+1. missing here: dedxsplines.root, tpcpadgaincalib.root
+
+---
+
+# Measuring startup time:
+- In order to measure the time for each individual GPU memory registration step, please add `CONFIG_EXTRA_PROCESS_o2_gpu_reco_workflow="GPU_global.benchmarkMemoryRegistration=1;"`. This should show you 2 times ~2 seconds per GPU process for the 2 large segments (DD and the global segment, could also report some additional smaller segments, only 1 in case you don't use the readout proxy).
+- In order to measure the total startup time, you can use the `start_tmux.sh` script with the option `FST_BENCHMARK_STARTUP=1`. It will print for both DPL chains 2 times at the beginning: The first is when it starts the workflow JSON generation, the second is after the JSON generation when the actual workflow is started. For the process startup time, you have to take the difference from that time until the time when the last process has reched the READY state. (Note that this should be done with the `$O2_ROOT/prodtests/full-system-test/shm-tool.sh` as instructed above.)
+    ```
+    Fri Jan 28 11:25:48 CET 2022
+    Fri Jan 28 11:25:56 CET 2022
+    [...]
+    [1456583:gpu-reconstruction_t0]: [11:26:18][INFO] fair::mq::Device running...
+    ```
+    - This corresponds to a JSON creation time of 8 seconds (will usually not cound for the startup since it is cached, and a process startup time of 22 seconds.
+---
+
+# Other remarks:# Other remarks:
+1. To run with low b-field, add to o2-sim:
+    ```
+    --field -2
+    ```
+1. To create a sample of multiple TF files for StfBuilder, use the script `$O2_ROOT/prodtests/full-system-test/generate_timeframe_files.sh`.
diff --git a/prodtests/full-system-test/README.md b/prodtests/full-system-test/documentation/full-system-test.md
similarity index 95%
rename from prodtests/full-system-test/README.md
rename to prodtests/full-system-test/documentation/full-system-test.md
index a52dfbc5d1203..80cc08baa2255 100644
--- a/prodtests/full-system-test/README.md
+++ b/prodtests/full-system-test/documentation/full-system-test.md
@@ -10,7 +10,7 @@ The full system test consists of 2 parts (detailed below):
 
 The relevant scripts are `/prodtests/full_system_test.sh` and all scripts in `/prodtests/full-system-test`.
 Note that by default the `full_system_test.sh` script will do both, run the generation and then the sysc and the async workflow.
-This is only a quickstart guide, for more information see https://alice.its.cern.ch/jira/browse/O2-1492.
+This is only a quickstart guide, for more information see https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test-setup.md.
 
 In order to run the full system test, you need to run in the O2sim environment (`alienv enter O2sim/latest`):
 ```
@@ -50,7 +50,7 @@ The generation part (in `prodtests/full_system_test.sh` runs the following steps
 The `prodtests/full_system_test.sh` uses `Utilities/Tools/jobutils.sh` for running the jobs, which creates a log file for each step, and which will automatically skip steps that have already succeeded if the test is rerun in the current folder. I.e. if you break the FST or it failed at some point, you can rerun the same command line and it will continue after the last successful step. See `Utilities/Tools/jobutils.sh` for details.
 
 Note that by default, the generation produces raw files, which can be consumed by the `raw-file-reader-workflow` and by `o2-readout-exe`.
-The files can be converted into timeframes files readable by the StfBuilder as described in https://alice.its.cern.ch/jira/browse/O2-1492.
+The files can be converted into timeframes files readable by the StfBuilder as described in https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test-setup.md.
 
 ## Full system test DPL-workflow configuration and scripts
 
@@ -80,7 +80,7 @@ The `dpl-workflow.sh` can run both the synchronous and the asynchronous workflow
 All settings are configured via environment variables.
 The default settings (if no env variable is exported) are defined in `setenv.sh` which is sourced by all other scripts.
 (Please note that `start_tmux.sh` overrides a couple of options with EPN defaults).
-The environment variables are documented here: https://github.com/AliceO2Group/O2DPG/blob/master/DATA/common/README.md
+The environment variables are documented here: https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test-env-variables.md
 
 ## Files produced / required by the full system test
 
diff --git a/prodtests/full-system-test/documentation/raw-data-simulation.md b/prodtests/full-system-test/documentation/raw-data-simulation.md
new file mode 100644
index 0000000000000..fbf6ace7d6934
--- /dev/null
+++ b/prodtests/full-system-test/documentation/raw-data-simulation.md
@@ -0,0 +1,43 @@
+This procedure will create (S)TF files from raw data prepared as described in the main ticket. The data must be using RDHv6.
+Create configuration for the readout.exe with all input files we want in the TF. This will create rdo_TF.cfg file.
+
+ 
+```
+ulimit -n 4096 # Make sure we can open sufficiently many files cd raw# ls raw: ITS TPC TOF ...
+
+# copy gen_rdo_cfg.sh script attached here to the raw directory
+# Run the script with number of HBF/TF and list directories you want to include in the TF
+
+~raw> ./gen_rdo_cfg.sh 128 TPC ITS TOF # ... others{code}
+``` 
+
+In a separate shell load a recent DataDistribution module and start StfBuilder to record the TF:
+```
+export TF_PATH=$(pwd)
+StfBuilder --id=stfb --detector-rdh=6 --detector-subspec=feeid --stand-alone  --channel-config "name=readout,type=pull,method=connect,address=ipc:///tmp/readout-to-datadist-0,transport=shmem,rateLogging=1" --data-sink-dir=${TF_PATH} --data-sink-sidecar --data-sink-enable
+```
+
+Start the readout.exe (at least v1.4.3) using the generated config file. The dataflow will have a 10-20 seconds of delay, in order to have all input files loaded.
+```
+ulimit -n 4096 # Make sure we can open sufficiently many files
+~raw> readout.exe file:rdo_TF.cfg{code}
+```
+ 
+Upon data transfer to StfBuilder, readout will print the stats, like:
+```
+2020-06-23 18:07:59.003364 Last interval (1.00s): blocksRx=0, block rate=0.00, bytesRx=0, rate=0.000 b/s
+2020-06-23 18:08:00.003382 Last interval (1.00s): blocksRx=2930, block rate=2930.00, bytesRx=1156508880, rate=9.252 Gb/s
+2020-06-23 18:08:01.003384 Last interval (1.00s): blocksRx=0, block rate=0.00, bytesRx=0, rate=0.000 b/s{noformat}
+```
+
+StfBuilder will print one warning regarding the timeout on the last received TF. This can be ignored in this case. The log should look like :
+
+``` 
+{noformat}[2020-06-23 18:07:59.928][I] readout[0]: in: 1224 (1156.52 MB) out: 0 (0 MB)
+[2020-06-23 18:08:01.733][W] READOUT INTERFACE: finishing STF on a timeout. stf_id=1 size=1156508880
+[2020-06-23 18:08:02.607][I] Sending STF out. stf_id=1 channel=standalone-chan[0] stf_size=1156508880 unique_equipments=1224{noformat}
+```
+
+After this, both processes can be closed with Ctrl-C. The resulting TFs are stored in a new directory under TF_PATH (the name of the dir is the time of running)
+
+ 

From 8ed4d1083b9403972662c8bcf0cec3a29487e244 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Apr 2025 22:55:03 +0200
Subject: [PATCH 0300/1764] GPU: Add documentation

---
 GPU/documentation/README.md           |  0
 GPU/documentation/build-O2.md         | 62 +++++++++++++++++++
 GPU/documentation/build-standalone.md | 86 +++++++++++++++++++++++++++
 3 files changed, 148 insertions(+)
 create mode 100644 GPU/documentation/README.md
 create mode 100644 GPU/documentation/build-O2.md
 create mode 100644 GPU/documentation/build-standalone.md

diff --git a/GPU/documentation/README.md b/GPU/documentation/README.md
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/GPU/documentation/build-O2.md b/GPU/documentation/build-O2.md
new file mode 100644
index 0000000000000..809d1fe0d5439
--- /dev/null
+++ b/GPU/documentation/build-O2.md
@@ -0,0 +1,62 @@
+This ticket will serve as documentation how to enable which GPU features and collect related issues.
+
+So far, the following features exist:
+ * GPU Tracking with CUDA
+ * GPU Tracking with HIP
+ * GPU Tracking with OpenCL (>= 2.1)
+ * OpenGL visualization of the tracking
+ * ITS GPU tracking
+
+GPU support should be detected and enabled automatically.
+If you just want to reproduce the GPU build locally without running it, it might be easiest to use the GPU CI container (see below).
+The provisioning script of the container also demonstrates which patches need to be applied such that everything works correctly.
+
+*GPU Tracking with CUDA*
+ * The CMake option -DENABLE_CUDA=ON/OFF/AUTO steers whether CUDA is forced enabled / unconditionally disabled / auto-detected.
+ * The CMake option -DCUDA_COMPUTETARGET= fixes a GPU target, e.g. 61 for PASCAL or 75 for Turing (if unset, it compiles for the lowest supported architecture)
+ * CUDA is detected via the CMake language feature, so essentially nvcc must be in the Path.
+ * We require CUDA version >= 11.2
+ * CMake will report "Building GPUTracking with CUDA support" when enabled.
+
+*GPU Tracking with HIP*
+ * HIP and HCC must be installed, and CMake must be able to detect HIP via find_package(hip).
+ * If HIP and HCC are not installed to /opt/rocm, the environment variables $HIP_PATH and $HCC_HOME must point to the installation directories.
+ * HIP from ROCm >= 4.0 is required.
+ * The CMake option -DHIP_AMDGPUTARGET= forces a GPU target, e.g. gfx906 for Radeon VII (if unset, it auto-detects the GPU).
+ * CMake will report "Building GPUTracking with HIP support" when enabled.
+ * It may be that some patches must be applied to ROCm after the installation. You find the details in the provisioning script of the GPU CI container below.
+
+*GPU Tracking with OpenCL (Needs Clang >= 18 for compilation)*
+ * Needs OpenCL library with version >= 2.1, detectable via CMake find_package(OpenCL).
+ * Needs the SPIR-V LLVM translator together with LLVM to create the SPIR-V binaries, also detectable via CMake.
+
+*OpenGL visualization of TPC tracking*
+ * Needs the following libraries (all detectable via CMake find_package): libOpenGL, libGLEW, libGLFW, libGLU.
+ * OpenGL must be at least version 4.5, but this is not detectable at CMake time. If the supported OpenGL version is below, the display is not/partially built, and not available at runtime. (Whether it is not or partially built depends on whether the maximum OpenGL version supported by GLEW or that of the system runtime in insufficient.)
+ * Note: If ROOT does not detect the system GLEW library, ROOT will install its own very outdated GLEW library, which will be insufficient for the display. Since the ROOT include path will come first in the order, this will prevent the display from being built.
+ * CMake will report "Building GPU Event Display" when enabled.
+
+*Vulkan visualization*
+ * similar to OpenCL visualization, but with Vulkan.
+
+*ITS GPU Tracking*
+ * So far supports only CUDA and HIP, support for OpenCL might come.
+ * The build is enabled when the "GPU Tracking with CUDA" (as explained above) detects CUDA, same for HIP.
+ * CMake will report "Building ITS CUDA tracker" when enabled, same for HIP.
+
+*Using the GPU CI container*
+ * Setting up everything locally might be somewhat time-consuming, instead you can use the GPU CI cdocker container.
+ * The docker images is `alisw/slc8-gpu-builder`.
+ * The container exports the `ALIBUILD_O2_FORCE_GPU` env variable, which force-enables all GPU builds.
+ * Note that it might not be possible out-of-the-box to run the GPU version from within the container. In case of HIP it should work when you forwards the necessary GPU devices in the container. For CUDA however, you would either need to (in addition to device forwarding) match the system CUDA driver and toolkit installation to the files present in the container, or you need to use the CUDA docker runtime, which is currently not installed in the container.
+ * There are currently some patches needed to install all the GPU backends in a proper way and together. Please refer to the container provisioning script https://github.com/alisw/docks/blob/master/slc9-gpu-builder/provision.sh. If you want to reproduce the installation locally, it is recommended to follow the steps from the script.
+
+*Summary*
+
+If you want to enforce the GPU builds on a system without GPU, please set the following CMake settings:
+ * ENABLE_CUDA=ON
+ * ENABLE_HIP=ON
+ * ENABLE_OPENCL=ON
+ * HIP_AMDGPUTARGET=gfx906;gfx908
+ * CUDA_COMPUTETARGET=86 89
+Alternatively you can set the environment variables ALIBUILD_ENABLE_CUDA and ALIBUILD_ENABLE_HIP to enforce building CUDA or HIP without modifying the alidist scripts.
diff --git a/GPU/documentation/build-standalone.md b/GPU/documentation/build-standalone.md
new file mode 100644
index 0000000000000..d4e9da5cd5bf3
--- /dev/null
+++ b/GPU/documentation/build-standalone.md
@@ -0,0 +1,86 @@
+This ticket describes how to build the O2 GPU TPC Standalone benchmark (in its 2 build types), and how to run it.
+
+The purpose of the standalone benchmark is to make the O2 GPU TPC reconstruction code available standalone. It provides
+- external tests when people do not have / want to build O2, have no access to alien for CCDB, etc.
+- fast standalone tests without running O2 workflows and overhead from CCTD.
+- faster build times than rebuilding O2 for development.
+
+# Compiling
+
+The standalone benchmark is build as part of O2, and it can be built standalone.
+
+As part of O2, it is available from the normal O2 build as the executable `o2-gpu-standalone-benchmark`, GPU support is available for all GPU types supported by the O2 build.
+
+Building it as standalone benchmark requires several dependencies, and provides more control which features to enable / disable.
+The dependencies can be taken from the system, or we can use alidist to build O2 and take the dependencies from there.
+
+In order to do the latter, please execute:
+```
+cd ~/alice # or your alice folder
+aliBuild build --defaults o2 O2
+source O2/GPU/GPUTracking/Standalone/cmake/prepare.sh
+```
+
+Then, in order to compile the standalone tool, assuming to have it in ~/standalone and build in ~/standalone/build, please run:
+```
+mkdir -p ~/standalone/build
+cd ~/standalone/build
+cmake -DCMAKE_INSTALL_PREFIX=../ ~/alice/O2/GPU/GPUTracking/Standalone/
+nano config.cmake # edit config file to enable / disable dependencies as needed. In case cmake failed, and you disabled the dependency, just rerun the above command.
+make install -j32
+```
+
+You can edit certain build settings in `config.cmake`. Some of them are identical to the GPU build settings for O2, as described in O2-786.
+And there are plenty of additional settings to enable/disable event display, qa, usage of ROOT, FMT, etc. libraries.
+
+This will create the `ca` binary in `~/standalone`, which is basically the same as the `o2-gpu-standalone-benchmark`, but built outside of O2.
+
+# Running
+
+The following command lines will use `./ca`, in case you use the executable from the O2 build, please replace by `o2-gpu-standalone-benchmark`.
+
+You can get a list of command line options by `./ca --help` and `./ca --helpall`.
+
+In order to run, you need a dataset. See the next section for how to create a dataset. Datasets are stored in `~/standalone/events`, and are identified by their folder names. The following commands assume a testdataset of name `o2-pbpb-100`.
+
+To run on that data, the simpled command is `./ca -e o2-pbpb-100`. This will automatically use a GPU if available, trying all backends, otherwise fall back to CPU.
+You can force using GPU or CPU with `-g` and `-c`.
+You can select the backend via `--gpuType CUDA|HIP|OCL|OCL2`, and inside the backend you can select the device number, if multiple devices exist, via `--gpuDevice i`.
+
+The flag `--debug` (-2 to 6) enables increasingly extensive debug output, and `--debug 6` stores full data dumpts of all intermediate steps to files.
+>= `--debug 1` has a performance impact since it adds serialization points for debugging. For timing individual kernels, `--debug 1` prints timing information for all kernels.
+An example line would .e.g. be
+```
+./ca -e o2-pbpb-100 -g --gpuType CUDA --gpuDevice 0 --debug 1
+```
+
+Some other noteworthy options are `--display` to run the GPU event display, `--qa` to run a QA task on MC data, `--runs` and `--runs2` to run multiple iterations of the benchmark, `--printSettings` to print all the settings that were used, `--memoryStat` to print memory statistics, `--sync` to run with settings for online reco, `--syncAsync` to run online reco first, and then offline reco on the produced TPC CTF data, `--setO2Settings` to use some defaults as they are in O2 not in the standalone version, `--PROCdoublePipeline` to enable the double-threaded pipeline for best performance (works only with multiple iterations, and not in async mode), and `--RTCenable` to enable the run time compilation improvements (check also `--RTCcacheOutput`).
+An example for a benchmark in online mode would be:
+```
+./ca -e o2-pbpb-100 -g --sync --setO2Settings --PROCdoublePipeline --RTCenable --runs 10
+```
+
+# Generating a dataset
+
+The standalone benchmark supports running on Run2 data exported from AliRoot, or to run on Run3 data from O2. This document covers only the O2 case.
+In o2, `o2-tpc-reco-workflow` and the `o2-gpu-reco-workflow` can dump event data with the `configKeyValue` `GPU_global.dump=1;`.
+This will dump the event data to the local folder, all dumped files have a `.dump` file extension. If there are multiple TFs/events processed, there will be multiple `event.i.dump` files. In order to create a standalone dataset out of these, just copy all the `.dump` files to a subfolder in `~/standalone/events/[FOLDERNAME]`.
+
+Data can be dumped from raw data, or from MC data, e.g. generated by the Full System Test. In case of MC data, also MC labels are dumped, such that they are used in the `./ca --qa` mode.
+
+To get a dump from simulated data, please run e.g. the FST simulation as described in O2-2633.
+A simple run as
+```
+DISABLE_PROCESSING=1 NEvents=5 NEventsQED=100 SHMSIZE=16000000000 $O2_ROOT/prodtests/full_system_test.sh
+```
+should be enough.
+
+Afterwards run the following command to dump the data:
+```
+SYNCMODE=1 CONFIG_EXTRA_PROCESS_o2_gpu_reco_workflow="GPU_global.dump=1;" WORKFLOW_DETECTORS=TPC SHMSIZE=16000000000 $O2_ROOT/prodtests/full-system-test/dpl-workflow.sh
+```
+
+To dump standalone data from CTF raw data in `myctf.root`, you can use the same script, e.g.:
+```
+CTFINPUT=1 INPUT_FILE_LIST=myctf.root CONFIG_EXTRA_PROCESS_o2_gpu_reco_workflow="GPU_global.dump=1;" WORKFLOW_DETECTORS=TPC SHMSIZE=16000000000 $O2_ROOT/prodtests/full-system-test/dpl-workflow.sh
+```

From 80a80a17f5a1d9cb77743e2a39b15b653fe1a4f9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Apr 2025 16:39:38 +0200
Subject: [PATCH 0301/1764] GPU: Make TPC CF CF_SCAN_WORKGROUP_SIZE
 configureable

---
 GPU/GPUTracking/Base/GPUProcessor.h           | 18 ++++++++++++++---
 .../Definitions/GPUDefParametersConstants.h   |  2 --
 .../Definitions/GPUDefParametersDefaults.h    | 17 ++++++++++------
 .../Global/GPUChainTrackingClusterizer.cxx    | 14 +++++++------
 .../GPUTPCCFStreamCompaction.cxx              | 14 +++++++++++--
 .../GPUTPCCFStreamCompaction.h                | 14 ++++++-------
 .../TPCClusterFinder/GPUTPCClusterFinder.cxx  | 20 +++++++++++--------
 .../TPCClusterFinder/GPUTPCClusterFinder.h    |  5 ++---
 GPU/GPUTracking/kernels.cmake                 |  3 ++-
 9 files changed, 69 insertions(+), 38 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUProcessor.h b/GPU/GPUTracking/Base/GPUProcessor.h
index 2e0e0a003f87d..df551c9f0330d 100644
--- a/GPU/GPUTracking/Base/GPUProcessor.h
+++ b/GPU/GPUTracking/Base/GPUProcessor.h
@@ -63,7 +63,7 @@ class GPUProcessor
   }
 
   template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
-  static inline size_t getAlignmentMod(size_t addr)
+  static constexpr inline size_t getAlignmentMod(size_t addr)
   {
     static_assert((alignment & (alignment - 1)) == 0, "Invalid alignment, not power of 2");
     if (alignment <= 1) {
@@ -72,7 +72,7 @@ class GPUProcessor
     return addr & (alignment - 1);
   }
   template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
-  static inline size_t getAlignment(size_t addr)
+  static constexpr inline size_t getAlignment(size_t addr)
   {
     size_t mod = getAlignmentMod<alignment>(addr);
     if (mod == 0) {
@@ -81,10 +81,22 @@ class GPUProcessor
     return (alignment - mod);
   }
   template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
-  static inline size_t nextMultipleOf(size_t size)
+  static constexpr inline size_t nextMultipleOf(size_t size)
   {
     return size + getAlignment<alignment>(size);
   }
+  static constexpr inline size_t nextMultipleOf(size_t size, size_t alignment)
+  {
+    if (alignment & (alignment - 1)) {
+      size_t tmp = size % alignment;
+      if (tmp) {
+        size += alignment - tmp;
+      }
+      return size;
+    } else {
+      return (size + alignment - 1) & ~(alignment - 1);
+    }
+  }
   template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
   static inline void* alignPointer(void* ptr)
   {
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
index dd4a5dcbe7ba8..78036e47fc49d 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
@@ -18,8 +18,6 @@
 #define GPUDEFPARAMETERSCONSTANTS_H
 // clang-format off
 
-#define GPUCA_THREAD_COUNT_SCAN 512 // TODO: WARNING!!! Must not be GPUTYPE-dependent right now! // TODO: Fix!
-
 #if defined(__CUDACC__) || defined(__HIPCC__)
   #define GPUCA_SPECIALIZE_THRUST_SORTS // Not compiled with RTC, so must be compile-time constant
 #endif
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index cdc5efd56ddfd..7879789bf91c8 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -22,7 +22,6 @@
 
 // GPU Run Configuration
 #if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.
-  #define GPUCA_LB_SCAN 512
   // GPU-architecture-dependent default settings
   #if defined(GPUCA_GPUTYPE_MI2xx)
     #define GPUCA_WARP_SIZE 64
@@ -499,11 +498,11 @@
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression GPUCA_LB_GPUTPCNNClusterizerKernels
 
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_LB_SCAN
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_LB_SCAN
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_LB_SCAN
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanDown GPUCA_LB_SCAN
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits GPUCA_LB_SCAN
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanDown GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
+  #define GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered GPUCA_LB_COMPRESSION_GATHER
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered32 GPUCA_LB_COMPRESSION_GATHER
   #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64 GPUCA_LB_COMPRESSION_GATHER
@@ -541,6 +540,9 @@
   #ifndef GPUCA_PAR_COMP_GATHER_MODE
     #define GPUCA_PAR_COMP_GATHER_MODE 2
   #endif
+  #ifndef GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
+    #define GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE 512
+  #endif
 #endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)
 
 #ifndef GPUCA_GPUCODE_GENRTC
@@ -578,6 +580,9 @@
   #ifndef GPUCA_PAR_NO_ATOMIC_PRECHECK
     #define GPUCA_PAR_NO_ATOMIC_PRECHECK 0
   #endif
+  #ifndef GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
+    #define GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE 0
+  #endif
   #ifndef GPUCA_PAR_DEDX_STORAGE_TYPE
     #define GPUCA_PAR_DEDX_STORAGE_TYPE float
   #endif
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 630c2200e5900..f188388e76a02 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -23,6 +23,7 @@
 #include "CfChargePos.h"
 #include "CfArray2D.h"
 #include "GPUGeneralKernels.h"
+#include "GPUDefParametersRuntime.h"
 #include "GPUTPCCFStreamCompaction.h"
 #include "GPUTPCCFChargeMapFiller.h"
 #include "GPUTPCCFDecodeZS.h"
@@ -402,27 +403,28 @@ void GPUChainTracking::RunTPCClusterizer_compactPeaks(GPUTPCClusterFinder& clust
       exit(1);
     }
 
+    int32_t scanWorkgroupSize = mRec->getGPUParameters(doGPU).par_CF_SCAN_WORKGROUP_SIZE;
     size_t tmpCount = count;
     if (nSteps > 1) {
       for (uint32_t i = 1; i < nSteps; i++) {
         counts.push_back(tmpCount);
         if (i == 1) {
-          runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::scanStart>({GetGrid(tmpCount, clusterer.mScanWorkGroupSize, lane), {iSector}}, i, stage);
+          runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::scanStart>({GetGrid(tmpCount, scanWorkgroupSize, lane), {iSector}}, i, stage);
         } else {
-          runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::scanUp>({GetGrid(tmpCount, clusterer.mScanWorkGroupSize, lane), {iSector}}, i, tmpCount);
+          runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::scanUp>({GetGrid(tmpCount, scanWorkgroupSize, lane), {iSector}}, i, tmpCount);
         }
-        tmpCount = (tmpCount + clusterer.mScanWorkGroupSize - 1) / clusterer.mScanWorkGroupSize;
+        tmpCount = (tmpCount + scanWorkgroupSize - 1) / scanWorkgroupSize;
       }
 
-      runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::scanTop>({GetGrid(tmpCount, clusterer.mScanWorkGroupSize, lane), {iSector}}, nSteps, tmpCount);
+      runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::scanTop>({GetGrid(tmpCount, scanWorkgroupSize, lane), {iSector}}, nSteps, tmpCount);
 
       for (uint32_t i = nSteps - 1; i > 1; i--) {
         tmpCount = counts[i - 1];
-        runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::scanDown>({GetGrid(tmpCount - clusterer.mScanWorkGroupSize, clusterer.mScanWorkGroupSize, lane), {iSector}}, i, clusterer.mScanWorkGroupSize, tmpCount);
+        runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::scanDown>({GetGrid(tmpCount - scanWorkgroupSize, scanWorkgroupSize, lane), {iSector}}, i, scanWorkgroupSize, tmpCount);
       }
     }
 
-    runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::compactDigits>({GetGrid(count, clusterer.mScanWorkGroupSize, lane), {iSector}}, 1, stage, in, out);
+    runKernel<GPUTPCCFStreamCompaction, GPUTPCCFStreamCompaction::compactDigits>({GetGrid(count, scanWorkgroupSize, lane), {iSector}}, 1, stage, in, out);
   } else {
     auto& nOut = stage ? clusterer.mPmemory->counters.nClusters : clusterer.mPmemory->counters.nPeaks;
     auto& nIn = stage ? clusterer.mPmemory->counters.nPeaks : clusterer.mPmemory->counters.nPositions;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
index 1da5a1158a8c2..d43e96b19c5d0 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
@@ -24,6 +24,7 @@ using namespace o2::gpu::tpccf;
 template <>
 GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanStart>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t iBuf, int32_t stage)
 {
+#ifdef GPUCA_GPUCODE
   int32_t nElems = CompactionElems(clusterer, stage);
 
   const auto* predicate = clusterer.mPisPeak;
@@ -35,17 +36,19 @@ GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanSta
     pred = predicate[iThreadGlobal];
   }
 
-  int32_t nElemsInBlock = CfUtils::blockPredicateSum<GPUCA_THREAD_COUNT_SCAN>(smem, pred);
+  int32_t nElemsInBlock = CfUtils::blockPredicateSum<GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE>(smem, pred);
 
   int32_t lastThread = nThreads - 1;
   if (iThread == lastThread) {
     scanOffset[iBlock] = nElemsInBlock;
   }
+#endif
 }
 
 template <>
 GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanUp>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t iBuf, int32_t nElems)
 {
+#ifdef GPUCA_GPUCODE
   auto* scanOffset = clusterer.GetScanBuffer(iBuf - 1);
   auto* scanOffsetNext = clusterer.GetScanBuffer(iBuf);
 
@@ -59,11 +62,13 @@ GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanUp>
   if (iThread == lastThread) {
     scanOffsetNext[iBlock] = offsetInBlock;
   }
+#endif
 }
 
 template <>
 GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanTop>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t iBuf, int32_t nElems)
 {
+#ifdef GPUCA_GPUCODE
   int32_t iThreadGlobal = get_global_id(0);
   int32_t* scanOffset = clusterer.GetScanBuffer(iBuf - 1);
 
@@ -74,11 +79,13 @@ GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanTop
   if (inBounds) {
     scanOffset[iThreadGlobal] = offsetInBlock;
   }
+#endif
 }
 
 template <>
 GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanDown>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& /*smem*/, processorType& clusterer, int32_t iBuf, uint32_t offset, int32_t nElems)
 {
+#ifdef GPUCA_GPUCODE
   int32_t iThreadGlobal = get_global_id(0) + offset;
 
   int32_t* scanOffsetPrev = clusterer.GetScanBuffer(iBuf - 1);
@@ -89,11 +96,13 @@ GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanDow
   if (iThreadGlobal < nElems) {
     scanOffsetPrev[iThreadGlobal] += shift;
   }
+#endif
 }
 
 template <>
 GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::compactDigits>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t iBuf, int32_t stage, CfChargePos* in, CfChargePos* out)
 {
+#ifdef GPUCA_GPUCODE
   uint32_t nElems = CompactionElems(clusterer, stage);
   SizeT bufferSize = (stage) ? clusterer.mNMaxClusters : clusterer.mNMaxPeaks;
 
@@ -105,7 +114,7 @@ GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::compact
   bool iAmDummy = (iThreadGlobal >= nElems);
 
   int32_t pred = (iAmDummy) ? 0 : predicate[iThreadGlobal];
-  int32_t offsetInBlock = CfUtils::blockPredicateScan<GPUCA_THREAD_COUNT_SCAN>(smem, pred);
+  int32_t offsetInBlock = CfUtils::blockPredicateScan<GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE>(smem, pred);
 
   SizeT globalOffsetOut = offsetInBlock;
   if (iBlock > 0) {
@@ -129,6 +138,7 @@ GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::compact
       clusterer.mPmemory->counters.nPeaks = nFinal;
     }
   }
+#endif
 }
 
 GPUdii() int32_t GPUTPCCFStreamCompaction::CompactionElems(processorType& clusterer, int32_t stage)
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
index a72907fe55e89..a5ea8b24e9522 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
@@ -35,14 +35,14 @@ class GPUTPCCFStreamCompaction : public GPUKernelTemplate
     compactDigits = 4,
   };
 
-  struct GPUSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<int32_t, GPUCA_THREAD_COUNT_SCAN> {
-  };
 #if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)
-  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanStart));
-  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanUp));
-  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanTop));
-  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanDown));
-  static_assert(GPUCA_THREAD_COUNT_SCAN == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits));
+  struct GPUSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<int32_t, GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE> {
+  };
+  static_assert(GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanStart));
+  static_assert(GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanUp));
+  static_assert(GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanTop));
+  static_assert(GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_scanDown));
+  static_assert(GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits));
 #endif
 
   typedef GPUTPCClusterFinder processorType;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
index 051391f12cc6d..541edaa689c6c 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
@@ -17,6 +17,7 @@
 #include "GPUMemorySizeScalers.h"
 #include "GPUHostDataTypes.h"
 #include "GPUSettings.h"
+#include "GPUDefParametersRuntime.h"
 
 #include "DataFormatsTPC/ClusterNative.h"
 #include "DataFormatsTPC/ZeroSuppression.h"
@@ -90,9 +91,10 @@ void* GPUTPCClusterFinder::SetPointersScratch(void* mem)
   computePointerWithAlignment(mem, mPisPeak, mNMaxDigitsFragment);
   computePointerWithAlignment(mem, mPchargeMap, TPCMapMemoryLayout<decltype(*mPchargeMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen));
   computePointerWithAlignment(mem, mPpeakMap, TPCMapMemoryLayout<decltype(*mPpeakMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen));
-  computePointerWithAlignment(mem, mPbuf, mBufSize * mNBufs);
   computePointerWithAlignment(mem, mPclusterByRow, GPUCA_ROW_COUNT * mNMaxClusterPerRow);
-
+  if ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding)) {
+    computePointerWithAlignment(mem, mPscanBuf, mBufSize * mNBufs);
+  }
   return mem;
 }
 
@@ -129,14 +131,15 @@ void GPUTPCClusterFinder::SetMaxData(const GPUTrackingInOutPointers& io)
   if (mRec->GetProcessingSettings().tpcIncreasedMinClustersPerRow) {
     mNMaxClusterPerRow = std::max<uint32_t>(mNMaxClusterPerRow, mRec->GetProcessingSettings().tpcIncreasedMinClustersPerRow);
   }
-
-  mBufSize = nextMultipleOf<std::max<int32_t>(GPUCA_MEMALIGN, mScanWorkGroupSize)>(mNMaxDigitsFragment);
-  mNBufs = getNSteps(mBufSize);
+  if ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding)) {
+    mBufSize = nextMultipleOf(mNMaxDigitsFragment, std::max<int32_t>(GPUCA_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
+    mNBufs = getNSteps(mBufSize);
+  }
 }
 
 void GPUTPCClusterFinder::SetNMaxDigits(size_t nDigits, size_t nPages, size_t nDigitsFragment, size_t nDigitsEndpointMax)
 {
-  mNMaxDigits = nextMultipleOf<std::max<int32_t>(GPUCA_MEMALIGN, mScanWorkGroupSize)>(nDigits);
+  mNMaxDigits = nextMultipleOf(nDigits, std::max<int32_t>(GPUCA_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
   mNMaxPages = nPages;
   mNMaxDigitsFragment = nDigitsFragment;
   mNMaxDigitsEndpoint = nDigitsEndpointMax;
@@ -148,9 +151,10 @@ uint32_t GPUTPCClusterFinder::getNSteps(size_t items) const
     return 0;
   }
   uint32_t c = 1;
-  size_t capacity = mScanWorkGroupSize;
+  const size_t scanWorkgroupSize = mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE;
+  size_t capacity = scanWorkgroupSize;
   while (items > capacity) {
-    capacity *= mScanWorkGroupSize;
+    capacity *= scanWorkgroupSize;
     c++;
   }
   return c;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
index 96efe08be6dc6..37399f5e4863f 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
@@ -111,10 +111,10 @@ class GPUTPCClusterFinder : public GPUProcessor
   uint32_t* mPclusterInRow = nullptr;
   tpc::ClusterNative* mPclusterByRow = nullptr;
   GPUTPCClusterMCInterimArray* mPlabelsByRow = nullptr;
-  int32_t* mPbuf = nullptr;
+  int32_t* mPscanBuf = nullptr;
   Memory* mPmemory = nullptr;
 
-  GPUdi() int32_t* GetScanBuffer(int32_t iBuf) const { return mPbuf + iBuf * mBufSize; }
+  GPUdi() int32_t* GetScanBuffer(int32_t iBuf) const { return mPscanBuf + iBuf * mBufSize; }
 
   o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> const* mPinputLabels = nullptr;
   uint32_t* mPlabelsInRow = nullptr;
@@ -122,7 +122,6 @@ class GPUTPCClusterFinder : public GPUProcessor
   uint32_t mPlabelsDataGlobalOffset = 0;
 
   int32_t mISector = 0;
-  constexpr static int32_t mScanWorkGroupSize = GPUCA_THREAD_COUNT_SCAN;
   uint32_t mNMaxClusterPerRow = 0;
   uint32_t mNMaxClusters = 0;
   uint32_t mNMaxPages = 0;
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 937a92fef33df..08d879fbb8e9a 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -146,7 +146,8 @@ o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP
                             NO_ATOMIC_PRECHECK
                             COMP_GATHER_KERNEL
                             COMP_GATHER_MODE
-                            SORT_STARTHITS)
+                            SORT_STARTHITS
+                            CF_SCAN_WORKGROUP_SIZE)
 
 o2_gpu_kernel_add_string_parameter(DEDX_STORAGE_TYPE
                                    MERGER_INTERPOLATION_ERROR_TYPE)

From f1e0a1298ca6a1ba2bea97e4e8b403487dbfa13f Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Fri, 25 Apr 2025 10:14:07 +0200
Subject: [PATCH 0302/1764] Update CODEOWNERS for ALICE3 (#14221)

@njacazio
---
 CODEOWNERS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CODEOWNERS b/CODEOWNERS
index a22b122d0e6cd..5337622522bbb 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -73,6 +73,7 @@
 /Detectors/TPC                     @davidrohr @wiechula @shahor02
 /Detectors/TRD                     @f3sch @bazinski @wille10
 /Detectors/Upgrades                @mconcas
+/Detectors/Upgrades/ALICE3         @mconcas @njacazio
 /Detectors/Upgrades/ITS3           @fgrosa @arossi81 @mconcas @f3sch
 /Detectors/ZDC                     @coppedis
 /Detectors/CTF                     @shahor02

From fc3ace17eca580c338751163ef4528e3ec47f9d6 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Fri, 25 Apr 2025 10:14:46 +0200
Subject: [PATCH 0303/1764] ALICE3-TRK: Add skeleton for the TRK reconstruction
 WF (#14222)

---------

Co-authored-by: ALICE Builder <alibuild@users.noreply.github.com>
---
 .../ALICE3/TRK/workflow/CMakeLists.txt        |  22 ++--
 .../include/TRKWorkflow/RecoWorkflow.h        |  33 +++++
 .../include/TRKWorkflow/TrackerSpec.h         |  56 +++++++++
 .../ALICE3/TRK/workflow/src/RecoWorkflow.cxx  |  31 +++++
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   | 116 ++++++++++++++++++
 .../TRK/workflow/src/trk-reco-workflow.cxx    |  80 ++++++++++++
 6 files changed, 326 insertions(+), 12 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx

diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
index c9f4099017717..e86ed7982c85b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
@@ -10,23 +10,21 @@
 # or submit itself to any jurisdiction.
 
 o2_add_library(TRKWorkflow
+               TARGETVARNAME targetName
                SOURCES src/DigitReaderSpec.cxx
                        src/DigitWriterSpec.cxx
-                    #    src/RecoWorkflow.cxx
-                    #    src/ClusterWriterWorkflow.cxx
-                    #    src/ClustererSpec.cxx
-                    #    src/ClusterWriterSpec.cxx
-                    #    src/TrackerSpec.cxx
-                    #    src/TrackWriterSpec.cxx
-                    #    src/TrackReaderSpec.cxx
-                    #    src/VertexReaderSpec.cxx
+                       src/TrackerSpec.cxx
+                       src/RecoWorkflow.cxx
                PUBLIC_LINK_LIBRARIES O2::Framework
+                                     O2::GPUWorkflow
                                      O2::SimConfig
                                      O2::DataFormatsITSMFT
                                      O2::SimulationDataFormat
                                      O2::DPLUtils)
 
-# o2_add_executable(reco-workflow
-#                   SOURCES src/trk-reco-workflow.cxx
-#                   COMPONENT_NAME alice3-trk
-#                   PUBLIC_LINK_LIBRARIES O2::TRKWorkflow)
\ No newline at end of file
+o2_add_executable(reco-workflow
+                  SOURCES src/trk-reco-workflow.cxx
+                  COMPONENT_NAME alice3-trk
+                  PUBLIC_LINK_LIBRARIES O2::TRKWorkflow
+                                        O2::TRKSimulation
+                                        O2::ITStracking)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
new file mode 100644
index 0000000000000..0c2489aa4b9c4
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
@@ -0,0 +1,33 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRK_RECOWORKFLOW_H
+#define O2_TRK_RECOWORKFLOW_H
+
+#include "Framework/WorkflowSpec.h"
+#include "GPUDataTypes.h"
+
+namespace o2::trk
+{
+namespace reco_workflow
+{
+
+o2::framework::WorkflowSpec getWorkflow(bool useMC,
+                                        bool upstreamDigits = false,
+                                        bool upstreamClusters = false,
+                                        bool disableRootOutput = false,
+                                        bool useGPUWF = false,
+                                        o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
+}
+
+} // namespace o2::trk
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
new file mode 100644
index 0000000000000..3c82a4fd7b89d
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
@@ -0,0 +1,56 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   TrackerSpec.h
+
+#ifndef O2_TRK_TRACKERDPL
+#define O2_TRK_TRACKERDPL
+
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/Task.h"
+
+#include "ITStracking/TrackingInterface.h"
+#include "GPUDataTypes.h"
+
+#include "DetectorsBase/GRPGeomHelper.h"
+
+#include "TStopwatch.h"
+
+namespace o2::trk
+{
+class TrackerDPL : public framework::Task
+{
+ public:
+  TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
+             bool isMC,
+             gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+  ~TrackerDPL() override = default;
+  void init(framework::InitContext& ic) final;
+  void run(framework::ProcessingContext& pc) final;
+  void endOfStream(framework::EndOfStreamContext& ec) final;
+  //   void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj) final;
+  void stop() final;
+
+ private:
+  void updateTimeDependentParams(framework::ProcessingContext& pc);
+  //   std::unique_ptr<o2::gpu::GPUReconstruction> mRecChain = nullptr;
+  //   std::unique_ptr<o2::gpu::GPUChainITS> mChainITS = nullptr;
+  //   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
+  //   ITSTrackingInterface mITSTrackingInterface;
+  TStopwatch mTimer;
+};
+
+framework::DataProcessorSpec getTrackerSpec(bool useMC, gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+
+} // namespace o2::trk
+#endif /* O2_TRK_TRACKERDPL */
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
new file mode 100644
index 0000000000000..3b2b44729b259
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
@@ -0,0 +1,31 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKWorkflow/RecoWorkflow.h"
+#include "TRKWorkflow/TrackerSpec.h"
+#include "Framework/CCDBParamSpec.h"
+
+namespace o2::trk::reco_workflow
+{
+
+framework::WorkflowSpec getWorkflow(bool useMC,
+                                    bool upstreamDigits,
+                                    bool upstreamClusters,
+                                    bool disableRootOutput,
+                                    bool useGPUWF,
+                                    o2::gpu::GPUDataTypes::DeviceType dtype)
+{
+  framework::WorkflowSpec specs;
+  specs.emplace_back(o2::trk::getTrackerSpec(useMC, dtype));
+  return specs;
+}
+
+} // namespace o2::trk::reco_workflow
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
new file mode 100644
index 0000000000000..4057bab3b948f
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -0,0 +1,116 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <vector>
+
+#include "Framework/ControlService.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/CCDBParamSpec.h"
+#include "TRKWorkflow/TrackerSpec.h"
+
+namespace o2
+{
+using namespace framework;
+namespace trk
+{
+using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
+
+TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
+                       bool isMC,
+                       o2::gpu::GPUDataTypes::DeviceType dType)
+{
+  // mITSTrackingInterface.setTrackingMode(trMode);
+}
+
+void TrackerDPL::init(InitContext& ic)
+{
+  // mTimer.Stop();
+  // mTimer.Reset();
+  // o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
+  // mChainITS.reset(mRecChain->AddChain<o2::gpu::GPUChainITS>());
+  // mITSTrackingInterface.setTraitsFromProvider(mChainITS->GetITSVertexerTraits(),
+  //                                             mChainITS->GetITSTrackerTraits(),
+  //                                             mChainITS->GetITSTimeframe());
+}
+
+void TrackerDPL::stop()
+{
+  LOGF(info, "CPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+}
+
+void TrackerDPL::run(ProcessingContext& pc)
+{
+  auto cput = mTimer.CpuTime();
+  auto realt = mTimer.RealTime();
+  mTimer.Start(false);
+  // mITSTrackingInterface.updateTimeDependentParams(pc);
+  // mITSTrackingInterface.run(pc);
+  mTimer.Stop();
+  LOGP(info, "CPU Reconstruction time for this TF {} s (cpu), {} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
+}
+
+// void TrackerDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+// {
+//   // mITSTrackingInterface.finaliseCCDB(matcher, obj);
+// }
+
+void TrackerDPL::endOfStream(EndOfStreamContext& ec)
+{
+  LOGF(info, "TRK CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+}
+
+DataProcessorSpec getTrackerSpec(bool useMC, o2::gpu::GPUDataTypes::DeviceType dType)
+{
+  std::vector<InputSpec> inputs;
+
+  // inputs.emplace_back("compClusters", "TRK", "COMPCLUSTERS", 0, Lifetime::Timeframe);
+  // inputs.emplace_back("patterns", "TRK", "PATTERNS", 0, Lifetime::Timeframe);
+  // inputs.emplace_back("ROframes", "TRK", "CLUSTERSROF", 0, Lifetime::Timeframe);
+
+  // inputs.emplace_back("itscldict", "TRK", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
+  // inputs.emplace_back("itsalppar", "TRK", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
+                                                              false,                          // GRPECS=true
+                                                              false,                          // GRPLHCIF
+                                                              false,                          // GRPMagField
+                                                              false,                          // askMatLUT
+                                                              o2::base::GRPGeomRequest::None, // geometry, but ignored until it will be put in the CCDB
+                                                              inputs,
+                                                              true);
+  std::vector<OutputSpec> outputs;
+  outputs.emplace_back("TRK", "TRACKS", 0, Lifetime::Timeframe);
+  // outputs.emplace_back("TRK", "TRACKCLSID", 0, Lifetime::Timeframe);
+  // outputs.emplace_back("TRK", "TRKTrackROF", 0, Lifetime::Timeframe);
+  // outputs.emplace_back("TRK", "VERTICES", 0, Lifetime::Timeframe);
+  // outputs.emplace_back("TRK", "VERTICESROF", 0, Lifetime::Timeframe);
+  // outputs.emplace_back("TRK", "IRFRAMES", 0, Lifetime::Timeframe);
+
+  if (useMC) {
+    // inputs.emplace_back("trkmclabels", "TRK", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
+    // inputs.emplace_back("TRKMC2ROframes", "TRK", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
+    // outputs.emplace_back("TRK", "VERTICESMCTR", 0, Lifetime::Timeframe);
+    // outputs.emplace_back("TRK", "VERTICESMCPUR", 0, Lifetime::Timeframe);
+    // outputs.emplace_back("TRK", "TRACKSMCTR", 0, Lifetime::Timeframe);
+    // outputs.emplace_back("TRK", "TRKTrackMC2ROF", 0, Lifetime::Timeframe);
+  }
+
+  return DataProcessorSpec{
+    "trk-tracker",
+    inputs,
+    outputs,
+    AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
+                                            useMC,
+                                            dType)},
+    Options{}};
+}
+
+} // namespace trk
+} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
new file mode 100644
index 0000000000000..0f75d42710400
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
@@ -0,0 +1,80 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKWorkflow/RecoWorkflow.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "ITStracking/TrackingConfigParam.h"
+#include "ITStracking/Configuration.h"
+
+#include "Framework/CallbacksPolicy.h"
+#include "Framework/ConfigContext.h"
+#include "Framework/CompletionPolicyHelpers.h"
+
+#include <vector>
+
+using namespace o2::framework;
+
+void customize(std::vector<CallbacksPolicy>& policies)
+{
+  // o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
+
+void customize(std::vector<CompletionPolicy>& policies)
+{
+  // ordered policies for the writers
+  policies.push_back(CompletionPolicyHelpers::consumeWhenAllOrdered(".*(?:TRK|trk).*[W,w]riter.*"));
+}
+
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  // option allowing to set parameters
+  std::vector<ConfigParamSpec> options{
+    {"digits-from-upstream", VariantType::Bool, false, {"digits will be provided from upstream, skip digits reader"}},
+    {"clusters-from-upstream", VariantType::Bool, false, {"clusters will be provided from upstream, skip clusterizer"}},
+    {"disable-root-output", VariantType::Bool, false, {"do not write output root files"}},
+    {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"disable-tracking", VariantType::Bool, false, {"disable tracking step"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    {"use-gpu-workflow", VariantType::Bool, false, {"use GPU workflow (default: false)"}},
+    {"gpu-device", VariantType::Int, 1, {"use gpu device: CPU=1,CUDA=2,HIP=3 (default: CPU)"}}};
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+#include "Framework/Logger.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
+{
+  // Update the (declared) parameters if changed from the command line
+  auto useMC = !configcontext.options().get<bool>("disable-mc");
+  auto useGpuWF = configcontext.options().get<bool>("use-gpu-workflow");
+  auto gpuDevice = static_cast<o2::gpu::GPUDataTypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
+  auto extDigits = configcontext.options().get<bool>("digits-from-upstream");
+  auto extClusters = configcontext.options().get<bool>("clusters-from-upstream");
+  auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
+  o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
+
+  // write the configuration used for the reco workflow
+  o2::conf::ConfigurableParam::writeINI("o2itsrecoflow_configuration.ini");
+
+  return o2::trk::reco_workflow::getWorkflow(useMC, extDigits, extClusters, disableRootOutput, useGpuWF, gpuDevice);
+}

From ec8cf07940d0e6faedce2cb9815bd2043a5a7028 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Tue, 22 Apr 2025 16:25:33 +0200
Subject: [PATCH 0304/1764] Fix energy values for special runs

---
 Generators/share/egconfig/pythia8_NeNe.cfg | 8 ++++----
 Generators/share/egconfig/pythia8_OO.cfg   | 2 +-
 Generators/share/egconfig/pythia8_pO.cfg   | 8 +++++---
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/Generators/share/egconfig/pythia8_NeNe.cfg b/Generators/share/egconfig/pythia8_NeNe.cfg
index fff1dbb5f3d59..75a77236f5b4e 100644
--- a/Generators/share/egconfig/pythia8_NeNe.cfg
+++ b/Generators/share/egconfig/pythia8_NeNe.cfg
@@ -1,8 +1,8 @@
 ### beams
 Beams:idA 1000100200	# Neon
-Beams:idB 1000100200    # Neon
-Beams:eCM 10720.	# GeV
+Beams:idB 1000100200	# Neon
+Beams:eCM 5360. 	# GeV
 
 ### decays
-ParticleDecays:limitTau0 on	
-ParticleDecays:tau0Max 10.	
+ParticleDecays:limitTau0 on
+ParticleDecays:tau0Max 10.
diff --git a/Generators/share/egconfig/pythia8_OO.cfg b/Generators/share/egconfig/pythia8_OO.cfg
index ff098e6b65135..9a4419309a800 100644
--- a/Generators/share/egconfig/pythia8_OO.cfg
+++ b/Generators/share/egconfig/pythia8_OO.cfg
@@ -1,7 +1,7 @@
 ### beams
 Beams:idA 1000080160    # Oxygen
 Beams:idB 1000080160    # Oxygen
-Beams:eCM 10720.        # GeV
+Beams:eCM 5360.         # GeV
 
 ### decays
 ParticleDecays:limitTau0 on	
diff --git a/Generators/share/egconfig/pythia8_pO.cfg b/Generators/share/egconfig/pythia8_pO.cfg
index aff9d3337cd9d..64efc6954b363 100644
--- a/Generators/share/egconfig/pythia8_pO.cfg
+++ b/Generators/share/egconfig/pythia8_pO.cfg
@@ -1,8 +1,10 @@
 ### beams
+Beams:frameType 2       # back-to-back beams of different energies and particles
 Beams:idA 2212          # proton
 Beams:idB 1000080160    # Oxygen
-Beams:eCM 13600.        # GeV
+Beams:eA 6800.          # Energy of proton beam in GeV moving in the +z direction
+Beams:eB 3400.          # Energy in GeV per Oxygen nucleon (6.8 Z TeV) moving in the -z direction
 
 ### decays
-ParticleDecays:limitTau0 on	
-ParticleDecays:tau0Max 10.	
+ParticleDecays:limitTau0 on
+ParticleDecays:tau0Max 10.
\ No newline at end of file

From 2a11afc3af82fde89b936c0bb86648326e34a08a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 25 Apr 2025 10:17:29 +0200
Subject: [PATCH 0305/1764] Improve / Add GPU documentation

---
 GPU/documentation/README.md                   | 13 ++++++++
 GPU/documentation/build-O2.md                 | 24 +++++++-------
 GPU/documentation/build-standalone.md         |  4 +--
 GPU/documentation/deterministic-mode.md       | 31 +++++++++++++++++++
 GPU/documentation/run-time-compilation.md     | 21 +++++++++++++
 .../full-system-test/documentation/README.md  | 17 ++++++++++
 .../documentation/env-variables.md            |  4 +--
 .../full-system-test-as-stress-test.md        |  2 +-
 .../documentation/full-system-test-setup.md   |  4 +--
 ...ata-simulation.md => raw-tf-conversion.md} |  0
 10 files changed, 101 insertions(+), 19 deletions(-)
 create mode 100644 GPU/documentation/deterministic-mode.md
 create mode 100644 GPU/documentation/run-time-compilation.md
 create mode 100644 prodtests/full-system-test/documentation/README.md
 rename prodtests/full-system-test/documentation/{raw-data-simulation.md => raw-tf-conversion.md} (100%)

diff --git a/GPU/documentation/README.md b/GPU/documentation/README.md
index e69de29bb2d1d..de888ab6e2436 100644
--- a/GPU/documentation/README.md
+++ b/GPU/documentation/README.md
@@ -0,0 +1,13 @@
+[build-O2.md](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/build-O2.md) :
+- Instructions how to build O2 with GPU support.
+- Description of the CMake variables used.
+
+[build-standalone.md](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/build-standalone.md) :
+- Instructions how to build and run the standalone benchmark.
+- Instructions how to extract data sets for the standalone benchmark from real data or using simulation.
+
+[deterministic-mode.md](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/deterministic-mode.md) :
+- Instructions how to use the deterministic mode for both the standalone benchmark and O2.
+
+[run-time-compilation.md](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/run-time-compilation.md) :
+- Instructions how to use run time compilation (RTC) for the GPU code.
diff --git a/GPU/documentation/build-O2.md b/GPU/documentation/build-O2.md
index 809d1fe0d5439..098629f45a832 100644
--- a/GPU/documentation/build-O2.md
+++ b/GPU/documentation/build-O2.md
@@ -12,17 +12,17 @@ If you just want to reproduce the GPU build locally without running it, it might
 The provisioning script of the container also demonstrates which patches need to be applied such that everything works correctly.
 
 *GPU Tracking with CUDA*
- * The CMake option -DENABLE_CUDA=ON/OFF/AUTO steers whether CUDA is forced enabled / unconditionally disabled / auto-detected.
- * The CMake option -DCUDA_COMPUTETARGET= fixes a GPU target, e.g. 61 for PASCAL or 75 for Turing (if unset, it compiles for the lowest supported architecture)
+ * The CMake option `-DENABLE_CUDA=ON/OFF/AUTO` steers whether CUDA is forced enabled / unconditionally disabled / auto-detected.
+ * The CMake option `-DCUDA_COMPUTETARGET=...` fixes a GPU target, e.g. 61 for PASCAL or 75 for Turing (if unset, it compiles for the lowest supported architecture)
  * CUDA is detected via the CMake language feature, so essentially nvcc must be in the Path.
- * We require CUDA version >= 11.2
+ * We require CUDA version >= 12.8
  * CMake will report "Building GPUTracking with CUDA support" when enabled.
 
 *GPU Tracking with HIP*
  * HIP and HCC must be installed, and CMake must be able to detect HIP via find_package(hip).
- * If HIP and HCC are not installed to /opt/rocm, the environment variables $HIP_PATH and $HCC_HOME must point to the installation directories.
+ * If HIP and HCC are not installed to /opt/rocm, the environment variables `$HIP_PATH` and `$HCC_HOME` must point to the installation directories.
  * HIP from ROCm >= 4.0 is required.
- * The CMake option -DHIP_AMDGPUTARGET= forces a GPU target, e.g. gfx906 for Radeon VII (if unset, it auto-detects the GPU).
+ * The CMake option `-DHIP_AMDGPUTARGET=...` forces a GPU target, e.g. gfx906 for Radeon VII (if unset, it auto-detects the GPU).
  * CMake will report "Building GPUTracking with HIP support" when enabled.
  * It may be that some patches must be applied to ROCm after the installation. You find the details in the provisioning script of the GPU CI container below.
 
@@ -49,14 +49,14 @@ The provisioning script of the container also demonstrates which patches need to
  * The docker images is `alisw/slc8-gpu-builder`.
  * The container exports the `ALIBUILD_O2_FORCE_GPU` env variable, which force-enables all GPU builds.
  * Note that it might not be possible out-of-the-box to run the GPU version from within the container. In case of HIP it should work when you forwards the necessary GPU devices in the container. For CUDA however, you would either need to (in addition to device forwarding) match the system CUDA driver and toolkit installation to the files present in the container, or you need to use the CUDA docker runtime, which is currently not installed in the container.
- * There are currently some patches needed to install all the GPU backends in a proper way and together. Please refer to the container provisioning script https://github.com/alisw/docks/blob/master/slc9-gpu-builder/provision.sh. If you want to reproduce the installation locally, it is recommended to follow the steps from the script.
+ * There are currently some patches needed to install all the GPU backends in a proper way and together. Please refer to the container provisioning script [provision.sh](https://github.com/alisw/docks/blob/master/slc9-gpu-builder/provision.sh). If you want to reproduce the installation locally, it is recommended to follow the steps from the script.
 
 *Summary*
 
 If you want to enforce the GPU builds on a system without GPU, please set the following CMake settings:
- * ENABLE_CUDA=ON
- * ENABLE_HIP=ON
- * ENABLE_OPENCL=ON
- * HIP_AMDGPUTARGET=gfx906;gfx908
- * CUDA_COMPUTETARGET=86 89
-Alternatively you can set the environment variables ALIBUILD_ENABLE_CUDA and ALIBUILD_ENABLE_HIP to enforce building CUDA or HIP without modifying the alidist scripts.
+ * `ENABLE_CUDA=ON`
+ * `ENABLE_HIP=ON`
+ * `ENABLE_OPENCL=ON
+ * `HIP_AMDGPUTARGET=default`
+ * `CUDA_COMPUTETARGET=default`
+Alternatively you can set the environment variables `ALIBUILD_ENABLE_CUDA=1` and `ALIBUILD_ENABLE_HIP=1` to enforce building CUDA or HIP without modifying the alidist scripts.
diff --git a/GPU/documentation/build-standalone.md b/GPU/documentation/build-standalone.md
index d4e9da5cd5bf3..891d16b4dc2c4 100644
--- a/GPU/documentation/build-standalone.md
+++ b/GPU/documentation/build-standalone.md
@@ -30,7 +30,7 @@ nano config.cmake # edit config file to enable / disable dependencies as needed.
 make install -j32
 ```
 
-You can edit certain build settings in `config.cmake`. Some of them are identical to the GPU build settings for O2, as described in O2-786.
+You can edit certain build settings in `config.cmake`. Some of them are identical to the GPU build settings for O2, as described in [build-O2.md](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/build-O2.md).
 And there are plenty of additional settings to enable/disable event display, qa, usage of ROOT, FMT, etc. libraries.
 
 This will create the `ca` binary in `~/standalone`, which is basically the same as the `o2-gpu-standalone-benchmark`, but built outside of O2.
@@ -68,7 +68,7 @@ This will dump the event data to the local folder, all dumped files have a `.dum
 
 Data can be dumped from raw data, or from MC data, e.g. generated by the Full System Test. In case of MC data, also MC labels are dumped, such that they are used in the `./ca --qa` mode.
 
-To get a dump from simulated data, please run e.g. the FST simulation as described in O2-2633.
+To get a dump from simulated data, please run e.g. the FST simulation as described in [full-system-test-setup.md](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test-setup.md).
 A simple run as
 ```
 DISABLE_PROCESSING=1 NEvents=5 NEventsQED=100 SHMSIZE=16000000000 $O2_ROOT/prodtests/full_system_test.sh
diff --git a/GPU/documentation/deterministic-mode.md b/GPU/documentation/deterministic-mode.md
new file mode 100644
index 0000000000000..9c8db2930ceaa
--- /dev/null
+++ b/GPU/documentation/deterministic-mode.md
@@ -0,0 +1,31 @@
+The TPC tracking code is not fully deterministic, i.e. running multiple times on the same data set might yield a slightly different number of tracks on the O(per mille) level.
+- This comes from concurrency, i.e. when tracks are processed in parallel, the output order might change, which might have small effects on the consecutive steps.
+- Also compile options and optimizations play a row, e.g. using ffast-math or fused-multiply-add might slightly change the rounding of floating point, and in rare cases lead to the acceptance or rejection of a track, and thus a different number of tracks.
+
+For debugging, testing, and validation, a deterministic mode is implemented, which should yield 100% reproducible results, on CPU and on GPU and when running multiple times.
+It uses a combination of
+- Compile time options, e.g. disabling all optimizations that change floating point rounding.
+- Run time options, e.g. to use deterministic sorting, and add additional sorting steps after kernels to make the output deterministic, also intermediate outputs.
+
+This is steered by 3 options:
+- The `-DGPUCA_DETERMINISTIC_MODE` Cmake setting : Compile-time setting.
+- The `--PROCdeterministicGPUReconstruction` command line option / `GPU_proc.deterministicGPUReconstruction` `--configKeyValue` setting : Run time setting.
+- The `--RTCdeterministic` command line option / `GPU_proc_rtc.deterministic` `--configKeyValue` setting. (Auto-enabled by the `deterministicGPUReconstruction` setting.) : Compile-time setting for RTC code.
+
+In order to be fully deterministic, all settings must be enabled, where the RTC setting is automatically enabled if not explicitly disabled.
+
+`GPUCA_DETERMINISTIC_MODE` has multiple levels, which are described here: [FindO2GPU.cmake](https://github.com/AliceO2Group/AliceO2/blob/80a80a17f5a1d9cb77743e2a39b15b653fe1a4f9/dependencies/FindO2GPU.cmake#L72).
+- In order to have fully deterministic GPUReconstruction (i.e. all algorithms that come with the GPUTracking library, like TPC tracking), the level `GPUCA_DETERMINISTIC_MODE=GPU` is needed.
+- In order to apply it to all of O2, e.g. for ITS tracking, please use `GPUCA_DETERMINISTIC_MODE=WHOLEO2`
+
+Enabling the options is a bit different for O2 and for the standalone benchmark:
+- For enabling it in the standalone benchmark, please set GPUCA_DETERMINISTIC_MODE=GPU in [config.cmake](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/GPUTracking/Standalone/cmake/config.cmake) and use the command line argument `--PROCdeterministicGPUReconstruction 1`.
+- For O2, Either add `set(GPUCA_DETERMINISTIC_MODE GPU)` to the beginning of the [GPU CMakeLists.txt](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/CMakeLists.txt) or add `set(GPUCA_DETERMINISTIC_MODE WHOLEO2)` to the beginning of the [Global CMakeLists.txt](https://github.com/AliceO2Group/AliceO2/blob/dev/CMakeLists.txt), and use the `configKeyValue` `GPU_proc.deterministicGPUReconstruction`. In order to enable this for the Full-System-Test or with [dpl-workflow.sh](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/dpl-workflow.sh), please export `CONFIG_EXTRA_PROCESS_o2_gpu_reco_workflow=GPU_proc.deterministicGPUReconstruction=1;`.
+
+With these settings, if one runs multiple times, the number of clusters and number of tracks should be always fully identical.
+Note that this yields a significant performance penalty during the processing, therefore the deterministic mode is not compiled in by default, but it must be enabled explicitly and code must be recompiled.
+
+Beyond comparing only the number of clusters and number of tracks, it is also possible to compare intermediate results. To do so, please use the standalone benchmark (either `./ca` or `o2-gpu-standalone-benchmark` binary) with the `--debug 6` option.
+It will create a dump container all (most) intermediate results in text form, which can be compared. The output files is called `CPU.out` if using the CPU backend, and `GPU.out` for the GPU backend.
+Note that the dump files will be huge and the processing will be slow and consume much more memory than normal with `--debug 6 . It has been tested with datasets containing up to 50 Pb-Pb collisions, and might fail for larger data.
+The dump files (if the deterministic mode is used with both compile- and runtime-activation), the files should be 100% identical and can just be compared with `diff`.
diff --git a/GPU/documentation/run-time-compilation.md b/GPU/documentation/run-time-compilation.md
new file mode 100644
index 0000000000000..accfceb47b870
--- /dev/null
+++ b/GPU/documentation/run-time-compilation.md
@@ -0,0 +1,21 @@
+Run time compilation is a feature of the GPUReconstruction library, which can recompile the GPU code for HIP and for CUDA at runtime, and apply some optimizations and changes. It is planned to add support for CPU code and OpenCL code in the future.
+
+The changes that can be applied are:
+- `constexpr` optimization: configuration values that are constant during the processing are replaced by `constexpr` expressions, which allows the compiler to optimize the code better. Benchmarks in 2024 habe shown 5% performance improvement with CUDA and 2% improvement with HIP.
+- Disabling of unused code, in particular this is currently used to remove the TPC code for V/M shape correction during online processing, simplifying the code, and yielding better compiler optimization, for a 20%-30% speedup on the MI50 GPUs.
+- Use different GPU constant parameters / launch bounds: These are tuning parameters, which are architecutre-dependent. The default values are taken from the first architecture the GPU code is compiled for in the normal compilation phase. If the architecture we are running on is different, different parameters can be loaded for RTC.
+- Compiling for different target architectures. This allows us to enable running on hardware, for which the code was not compiled in the original compilation.
+
+Generally, RTC is enabled via the `--RTCenable` flag for the standalone benchmark, or via the `GPU_proc_rtc.enable=1` `configKeyValue` for O2.
+For a list of RTC options, please see [GPUSettingsList.h](https://github.com/AliceO2Group/AliceO2/blob/80a80a17f5a1d9cb77743e2a39b15b653fe1a4f9/GPU/GPUTracking/Definitions/GPUSettingsList.h#L215).
+
+Caching the output:
+- The RTC output can be cached and reused, so that when running multiple times, compilation is not repeated. This is enabled via the `--RTCcacheOutput` setting. The folder to store the cache files can be selected via `--RTCTECHcacheFolder` and with `--RTCTECHcacheMutex` (default: enabled), a file-lock mutex can be used to synchronize access to the cache folder. The cached code is checked against the to-be-compiled source code with SHA1 hashes, and only if the code is not change the cache is used, otherwise the code is recompiled and the cache updated. It is possible to force using outdated cache files via the `--RTCTECHignoreCacheValid` option.
+
+For chaning the launch bounds and other parameters, please consider `--RTCTECHloadLaunchBoundsFromFile` (and `--RTCTECHprintLaunchBounds`), which can launch a parameter set which can be created via [dumpGPUDefParam.C](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C). A set of default parameters is stored in `[INSTALL_FOLDER]/share/GPU`.
+
+It is possible to select a different target architecture for the compilation via `--RTCTECHoverrideArchitecture`, and the compilation can be prepended by a command with `--RTCTECHprependCommand`, e.g. for CPU pinning. See for example [dpl-workflow.sh](https://github.com/AliceO2Group/AliceO2/blob/80a80a17f5a1d9cb77743e2a39b15b653fe1a4f9/prodtests/full-system-test/dpl-workflow.sh#L335).
+
+`--RTCdeterministic` enables the [Deterministic Mode](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/deterministic-mode.md) (compile-time setting) for RTC. Usually you don't need to bother, as for the deterministic mode it is autoenabled from `--PROCdeterministicGPUReconstruction`, but the explicit `--RTCdeterministic` is available for tests.
+
+Finally, `--RTCoptConstexpr` and `--RTCoptSpecialCode` enable the constexpr and code removal optimizations. For an example how the TPC V/M shape corrections are removed, see [TPCFastTransform.h](https://github.com/AliceO2Group/AliceO2/blob/fc3ace17eca580c338751163ef4528e3ec47f9d6/GPU/TPCFastTransformation/TPCFastTransform.h#L445).
diff --git a/prodtests/full-system-test/documentation/README.md b/prodtests/full-system-test/documentation/README.md
new file mode 100644
index 0000000000000..1fdef1da36ecd
--- /dev/null
+++ b/prodtests/full-system-test/documentation/README.md
@@ -0,0 +1,17 @@
+[full-system-test.md](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test.md) :
+- Full system test quick start guide
+
+[full-system-test-setup.md](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test-setup.md) :
+- More detailed description of full-system-test scripts, simulation of data set, and script to run the workflow
+
+[full-system-test-as-stress-test.md](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/full-system-test-as-stress-test.md) :
+- Details on how to use the full system test as stress test and for validation of an EPN online compute node
+
+[dpl-workflow-options.md](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/dpl-workflow-options.md) :
+- Description of the main workflow script [dpl-workflow.sh](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/dpl-workflow.sh) and its options.
+
+[env-variables.md](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/env-variables.md) :
+- List of common environment variables used by the workflow scripts (defaults set by https://github.com/davidrohr/O2DPG/blob/master/DATA/common/setenv.sh)
+
+[raw-tf-conversion.md](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/raw-tf-conversion.md) :
+- This is automated in a script now, but just in case details how readout files are converted to a .tf file for usage in the full system test with replay from DataDistribution.
diff --git a/prodtests/full-system-test/documentation/env-variables.md b/prodtests/full-system-test/documentation/env-variables.md
index b93622c0a0f94..5a13f2ee9e19d 100644
--- a/prodtests/full-system-test/documentation/env-variables.md
+++ b/prodtests/full-system-test/documentation/env-variables.md
@@ -1,4 +1,4 @@
-The `setenv-sh` script sets the following environment options
+The [setenv-sh](https://github.com/davidrohr/O2DPG/blob/master/DATA/common/setenv.sh) script sets the following environment options
 * `NTIMEFRAMES`: Number of time frames to process.
 * `TFDELAY`: Delay in seconds between publishing time frames (1 / rate).
 * `NGPUS`: Number of GPUs to use, data distributed round-robin.
@@ -25,7 +25,7 @@ The `setenv-sh` script sets the following environment options
 * `EXTINPUT`: Receive input from raw FMQ channel instead of running o2-raw-file-reader.
   * 0: `dpl-workflow.sh` can run as standalone benchmark, and will read the input itself.
   * 1: To be used in combination with either `datadistribution.sh` or `raw-reader.sh` or with another DataDistribution instance.
-* `CTFINPUT`: Read input from CTF ROOT file. This option is incompatible to EXTINPUT=1. The CTF ROOT file can be stored via SAVECTF=1.
+* `CTFINPUT`: Read input from CTF ROOT file. This option is incompatible to `EXTINPUT=1`. The CTF ROOT file can be stored via `SAVECTF=1`.
 * `NHBPERTF`: Time frame length (in HBF)
 * `GLOBALDPLOPT`: Global DPL workflow options appended to o2-dpl-run.
 * `EPNPIPELINES`: Set default EPN pipeline multiplicities.
diff --git a/prodtests/full-system-test/documentation/full-system-test-as-stress-test.md b/prodtests/full-system-test/documentation/full-system-test-as-stress-test.md
index 0c4637ece0920..c78d81b236c1c 100644
--- a/prodtests/full-system-test/documentation/full-system-test-as-stress-test.md
+++ b/prodtests/full-system-test/documentation/full-system-test-as-stress-test.md
@@ -7,7 +7,7 @@ This is a quick summary how to run the full system test (FST) as stress test on
   - Enter the O2PDPSuite environment either vie `alienv enter O2PDPSuite/latest Readout/latest`.
   - Go to an empty directory.
   - Run the FST simulation via: `NEvents=650 NEventsQED=10000 SHMSIZE=128000000000 TPCTRACKERSCRATCHMEMORY=40000000000 SPLITTRDDIGI=0 GENERATE_ITSMFT_DICTIONARIES=1 $O2_ROOT/prodtests/full_system_test.sh`
-  - Get a current matbud.root (e.g. from here https://alice.its.cern.ch/jira/browse/O2-2288) and place it in that folder.
+  - Material budget table (e.g. from here https://alice.its.cern.ch/jira/browse/O2-2288) now comes from CCDB, no need any more to pull it manually.
   - Create a timeframe file from the raw files: `$O2_ROOT/prodtests/full-system-test/convert-raw-to-tf-file.sh`.
   - Prepare the ramdisk folder: `mv raw/timeframe raw/timeframe-org; mkdir raw/timeframe-tmpfs; ln -s timeframe-tmpfs raw/timeframe`
 
diff --git a/prodtests/full-system-test/documentation/full-system-test-setup.md b/prodtests/full-system-test/documentation/full-system-test-setup.md
index 82ef9b7d0c74f..e90a3984dd3da 100644
--- a/prodtests/full-system-test/documentation/full-system-test-setup.md
+++ b/prodtests/full-system-test/documentation/full-system-test-setup.md
@@ -16,7 +16,7 @@ If you just want to test a small dataset, you can skip the following steps, and
     - I'd suggest to do a first small test with 1-5 events to check the machinery, 100 events is already a good size which should not exhaust the memory, I'd go to 600 only after 100 works.
 1. Compile O2 with GPU support, in addition you need O2sim, DataDistribution, and Readout (latest versions from alidist will do).
  GPUs for O2 should be auto-detected, but you can set the environment variables ALIBUILD_ENABLE_CUDA / ALIBUILD_ENABLE_HIP to enforce it (and get a failure when detection fails). Look for CMake log messages "Building GPUTracking with CUDA support" (etc) to verify.
- For more information, see https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/build.md
+ For more information, see https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/build-O2.md
 1. Optionally place some binary configuration files in the simulation folder. Default objects will be used if no such files are placed. There are instructions at the end of this post how to generate these files. (Currently, these files are: matbud.root, ITSdictionary.bin, ctf_dictionary.root, tpctransform.root, dedxsplines.root, and tpcpadgaincalib.root)
 1. Load the O2sim environment (`alienv enter O2sim/latest`) and run the following full system test script for a full simulation and digits to raw conversion (this will already include 1 CPU reconstruction run):
     ```
@@ -37,7 +37,7 @@ If you just want to test a small dataset, you can skip the following steps, and
         ```
 This will use 4 GPU with the HIP backend and allocate 22 GB of scratch memory on the GPU (should be sufficient for 128 orbit TF). You can change the GPU type as indicated in the linked README.md above, e.g. `GPUTYPE=CUDA NGPUS=1` for 1 CUDA GPU.
 1. With this, the full chain is running inside O2 DPL. Next we are adding DataDistribution.
-    1. Ceate the TF files as explained in the subtask (https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/raw-data-simulation.md). For convenience, there is a script that should do it automatically, from a shell that has loaded both DataDistribution and Readout: `$O2_ROOT/prodtests/full-system-test/convert-raw-to-tf-file.sh`.
+    1. Ceate the TF files as explained in the subtask ([raw-tf-conversion.md](https://github.com/AliceO2Group/AliceO2/blob/dev/prodtests/full-system-test/documentation/raw-tf-conversion.md)). For convenience, there is a script that should do it automatically, from a shell that has loaded both DataDistribution and Readout: `$O2_ROOT/prodtests/full-system-test/convert-raw-to-tf-file.sh`.
     1. Enter the O2 environment, and run the following script (please adjust the variables as in the test before).
         ```
         EXTINPUT=1 SHMSIZE=128000000000 GPUTYPE=CPU $O2_ROOT/prodtests/full-system-test/dpl-workflow.sh
diff --git a/prodtests/full-system-test/documentation/raw-data-simulation.md b/prodtests/full-system-test/documentation/raw-tf-conversion.md
similarity index 100%
rename from prodtests/full-system-test/documentation/raw-data-simulation.md
rename to prodtests/full-system-test/documentation/raw-tf-conversion.md

From 175d0147d5ecd5dcf776a774f8da28a6e893d509 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 25 Apr 2025 13:19:21 +0200
Subject: [PATCH 0306/1764] GPU: Add documentation for TPC Tracking QA

---
 GPU/documentation/README.md          |  3 ++
 GPU/documentation/tpc-tracking-qa.md | 78 ++++++++++++++++++++++++++++
 2 files changed, 81 insertions(+)
 create mode 100644 GPU/documentation/tpc-tracking-qa.md

diff --git a/GPU/documentation/README.md b/GPU/documentation/README.md
index de888ab6e2436..0f6ba79df63ce 100644
--- a/GPU/documentation/README.md
+++ b/GPU/documentation/README.md
@@ -11,3 +11,6 @@
 
 [run-time-compilation.md](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/run-time-compilation.md) :
 - Instructions how to use run time compilation (RTC) for the GPU code.
+
+[tpc-tracking-qa.md](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/documentation/tpc-tracking-qa.md) :
+- Instructions how to run the QA for TPC tracking (efficiency, resolution, etc.).
diff --git a/GPU/documentation/tpc-tracking-qa.md b/GPU/documentation/tpc-tracking-qa.md
new file mode 100644
index 0000000000000..4487d10d0fe70
--- /dev/null
+++ b/GPU/documentation/tpc-tracking-qa.md
@@ -0,0 +1,78 @@
+This is a quick documentation on the TPC Tracking QA for Resolution, Efficiency, and Cluster Attachment based on MC data.
+
+The TPC QA can produce 3 different output types:
+* *mergeble* histograms: A collection of ROOT histograms that can be merged from different inputs. The need to be postprocessed to get meaningful output.
+* *postprocessed* histograms: Histograms showing the efficiencies, resolutions etc. These histograms can no longer be merged from multiple inputs.
+* *layouts*: TCanvases with multiple postprocessed histograms arranged in reasonable layouts.
+
+The TPC Tracking QA consists of multiple QA subtasks ((de)activated via a bitmask):
+* *Efficiency* / *Clone Rate* / *Fake Rate* (1)
+* *Resolution* (2)
+* *Pulls* (4)
+* *Cluster Attachment Statistics* (8)
+* *nClusters and pt distribution* (16)
+* *Cluster rejection counts* (32) (both as aggregate text report and as histogram)
+
+The TPC QA can run in 3 different ways:
+* *Standalone* inside the tracking (o2-tpc-reco-workflow), it will write its output in pdf format to the plots folder in the current directory: supports *all subtasks* and will always produce the *layouts* output.
+* As *external source* to QC: the QA is running inside the o2-tpc-reco-workflow and ships the histograms to QC via DPL: supports *all subtasks*, can produce the *postprocessed* or the *layouts* output.
+* As *independent* QC tasks, operating on DPL input, that can e.g. be read from ROOT files: supports *subtasks* *1*, *2*, and *4*, currently is hardcoded to the *mergeable* output, but could be made configurable.
+_(Note: the reason that the independent QC supports fewer subtasks is that the other tasks require internal tracking data structures that are no available a posteriori.)_
+
+Remark on the *Cluster Rejection count histograms* for the *online QC*:
+* These are mainly meant for monitoring the TPC compression during data taking without MC information, while most other subtasks rely on MC information.
+* These are always in the mergeable format, the postprocessing will just forward them.
+* By default they are disabled and only aggregate text output shows the rejection ratios, they must be enabled explicitly as explained below.
+
+Running the TPC QA standalone:
+* It must be enabled via the configKeyValue GPU_proc.runQA in the o2-tpc-reco-workflow. The QA will run as part of the normal TPC tracking and will have access to all data structures of the tracking. Otherwise, the normal settings for the o2-tpc-reco-workflow apply.
+* Example to run on digits:
+{code}o2-tpc-reco-workflow -b --infile tpcdigits.root --configKeyValues "GPU_proc.runQA=1;" --output-type clusters,tracks{code}
+* Example to run on clusters:
+{code}o2-tpc-reco-workflow --input-type clusters --infile tpc-native-clusters.root --output-type tracks --configKeyValues "GPU_proc.runQA=1"{code}
+
+Running the TPC QA inside the o2-tpc-reco-workflow as external source for qc:
+* As in the standalone mode, the TPC Tracking QA will run as part of the o2-tpc-reco-workflow with full access to the tracking data structures.
+* The output is shipped to QC as external qc-input in the form of ROOT histograms, which disables some subtasks that do not produce ROOT histograms (such as the cluster counts (32)).
+* A merged workflow of the o2-tpc-reco-workflow and qc must be configures, such as:
+{code}o2-tpc-reco-workflow --input-type clusters --infile tpc-native-clusters.root --output-type tracks,qa | o2-qc --config json:/${QUALITYCONTROL_ROOT}/etc/tpcQCTrackingFromExternal_direct.json{code}
+(Note that by default, the output will be uploaded and visible at https://qcg-test.cern.ch/)
+* By default, this will create postprocessed histograms, and it can be switched via configKeyValues to layouts output via:
+{code}o2-tpc-reco-workflow --input-type clusters --infile tpc-native-clusters.root --output-type tracks,qa --configKeyValues "GPU_QA.shipToQCAsCanvas=true" | o2-qc --config json:/${QUALITYCONTROL_ROOT}/etc/tpcQCTrackingFromExternal_direct.json{code}
+* This mode can be combined with the standalone QA mode.
+* Running the *online cluster rejection histogram QA*:
+** This mode works also without MC information, it must be enabled explicitly. Irrespective of the output mode, it will always furnish the same mergeable histograms, since there is no postprocessing. An example to run them on ROOT files:
+{code}o2-tpc-reco-workflow --input-type clusters --infile tpc-native-clusters.root --output-type tracks,qa --disable-mc --configKeyValues "GPU_QA.clusterRejectionHistograms=1" | o2-qc --config json:/${QUALITYCONTROL_ROOT}/etc/tpcQCTrackingFromExternal_direct.json{code}
+** In order to set the x-axis scale (number of clusters), use the configKeyValue GPU_QA.histMaxNClusters.
+
+Running the QA as independent QC task:
+* In this mode, the QA runs independently from the o2-tpc-reco-workflow, getting clusters, tracks, and MC labels via DPL.
+* The example below uses the track reader and the reco workflow to fetch the input and ship them via DPL, but the inputs can of course also come from other sources.
+* This mode is mostly foreseen for the mergeble output. In this way, many instance can run in parallel and the output can be merged before being postprocessed.
+* Currently, the mergeble output is hardcoded, but the task could easily be extended for other outputs (see below).
+* To run the tasks on ROOT file input, you can use the following example:
+{code}o2-tpc-track-reader | o2-tpc-reco-workflow --input-type clusters --infile tpc-native-clusters.root --output-type disable-writer | o2-qc --config json:/${QUALITYCONTROL_ROOT}/etc/tpcQCTracking_direct.json{code}
+
+Postprocessing the mergeble output:
+* The o2::tpc::qc::Tracking class can be used for the postprocessing in a standalone way.
+* Initialize the class with the settings postprocessOnly = true and outputMode = outputPostprocessed or outputLayout.
+* Call the postprocess(...) function, passing in std::vectors of the 3 types of ROOT histograms (TH1F, TH2F, TH1D) which are used by the QA. Note that the order of the histograms must be the same as obtained in the mergeble output.
+* Depending on the outputMode setting, the class will fill the out object witl either the postprocessed histograms or the canvas layouts.
+
+The following classes in O2 / QC belong to the TPC tracking QA:
+* o2::gpu::GPUQA (O2/GPU/GPUTracking/Standalone/qa/GPUQA.cxx): The main QA class, which can produce the standalone output, or can run with external input driven from the o2::gpu::GPUO2InterfaceQA.
+* o2::gpu::GPUO2InterfaceQA (O2/GPU/GPUTracking/Interface/GPUO2InterfaceQA.cxx): Internal interface class, uses o2::gpu::GPUQA.
+* o2::tpc::qc::Tracking (O2/Detectors/TPC/qc/src/Tracking.cxx): The main QC class for running the TPC QA independent from the o2-tpc-reco-workflow, uses o2::gpu::GPUO2InterfaceQA.
+** Can produce all output types from tracks / clusters as input.
+** Can produce postprocessed / layout output from mergeble input.
+** Is limited to subtasks that do not require access to the internal tracking data structures.
+* o2::quality_control_modules::tpc::Tracking (QC/Modules/TPC/src/Tracking.cxx): Mostly a QC wrapper for o2::tpc::qc::Tracking, with the necessary framework code to receive clusters / tracks / MC labels via DPL.
+
+Several additional settings can be configured via configKeyValues as listed in https://github.com/AliceO2Group/AliceO2/blob/dev/Detectors/TPC/qc/include/TPCQC/Tracking.h#L44:
+* "GPU_QA.strict=[bool]"               Strict QA mode: Only consider resolution of tracks where the fit ended within 5 cm of the reference, and remove outliers. (Default: true)
+* "GPU_QA.qpt=[float]"                 Set cut for Q/Pt. (Default: 10.0)
+* "GPU_QA.recThreshold=[float]"        Compute the efficiency including impure tracks with fake contamination. (Default 0.9)
+* "GPU_QA.maxResX=[float]"             Maxmimum X (~radius) for reconstructed track position to take into accound for resolution QA in cm (Default: no limit)
+* "GPU_QA.nativeFitResolutions=[bool]" Create resolution histograms in the native fit units (sin(phi), tan(lambda), Q/Pt) (Default: false)
+* "GPU_QA.filterCharge=[int]"          Filter for positive (+1) or negative (-1) charge (Default: no filter)
+* "GPU_QA.filterPID=[int]"             Filter for Particle Type (0 Electron, 1 Muon, 2 Pion, 3 Kaon, 4 Proton) (Default: no filter)

From 3eadf367abe68bd24ac39c6eb3ea1470dd596663 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 29 Apr 2025 10:52:37 +0200
Subject: [PATCH 0307/1764] dpl-workflow.sh: Add GEN_TOPO_NO_TF_RATE_UPSCALING
 setting

---
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.h | 2 +-
 prodtests/full-system-test/dpl-workflow.sh  | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
index d2d06df7b5710..db7a3b5884a12 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
@@ -117,7 +117,7 @@ class GPUTPCGMPropagator
   GPUd() float PredictChi2(float posY, float posZ, float err2Y, float err2Z) const;
   GPUd() int32_t RejectCluster(float chiY, float chiZ, uint8_t clusterState)
   {
-    if (chiY > 9.f || chiZ > 9.f) {
+    if (chiY > 9.f || chiZ > 9.f) { // TODO: Check how a track can have chi2/ncl > 18
       return 2;
     }
     if ((chiY > 6.25f || chiZ > 6.25f) && (clusterState & (GPUTPCGMMergedTrackHit::flagSplit | GPUTPCGMMergedTrackHit::flagShared))) {
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index bb2712bedd92e..ebe6410d2c804 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -51,7 +51,11 @@ if [[ $EPNSYNCMODE == 1 ]] || type numactl >/dev/null 2>&1 && [[ `numactl -H | g
   [[ $NUMAGPUIDS != 0 ]] && ARGS_ALL+=" --child-driver 'numactl --membind $NUMAID --cpunodebind $NUMAID'"
 fi
 if [[ -z ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $DIGITINPUT != 1 ]]; then
-  RECO_NUM_NODES_WORKFLOW_CMP=$(($RECO_NUM_NODES_WORKFLOW > 15 ? ($RECO_NUM_NODES_WORKFLOW < 230 ? $RECO_NUM_NODES_WORKFLOW : 230) : 15))
+  if [[ ${GEN_TOPO_NO_TF_RATE_UPSCALING:-0} == 1 ]]; then
+    RECO_NUM_NODES_WORKFLOW_CMP=$RECO_NUM_NODES_WORKFLOW
+  else
+    RECO_NUM_NODES_WORKFLOW_CMP=$(($RECO_NUM_NODES_WORKFLOW > 15 ? ($RECO_NUM_NODES_WORKFLOW < 230 ? $RECO_NUM_NODES_WORKFLOW : 230) : 15))
+  fi
   TIMEFRAME_RATE_LIMIT=$((12 * 230 / ${RECO_NUM_NODES_WORKFLOW_CMP} * ($NUMAGPUIDS != 0 ? 1 : 2) * 128 / $NHBPERTF))
   [[ $BEAMTYPE != "PbPb" && ${HIGH_RATE_PP:-0} == 0 ]] && TIMEFRAME_RATE_LIMIT=$(($TIMEFRAME_RATE_LIMIT * 3))
   ! has_detector TPC && TIMEFRAME_RATE_LIMIT=$(($TIMEFRAME_RATE_LIMIT * 4))

From 2482a563ec50e43d51e1edba40dbfdf89ba36e21 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 30 Apr 2025 16:09:20 +0200
Subject: [PATCH 0308/1764] dpl-workflow.sh: make some MCH config key values
 fixed default

---
 prodtests/full-system-test/dpl-workflow.sh | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index ebe6410d2c804..b51594115154c 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -355,16 +355,14 @@ has_detector_reco MID && has_detector_matching MCHMID && MFTMCHConf="FwdMatching
 if has_processing_step MUON_SYNC_RECO; then
   [[ -z ${ARGS_EXTRA_PROCESS_o2_mid_reco_workflow:-} ]] && ARGS_EXTRA_PROCESS_o2_mid_reco_workflow="--mid-tracker-keep-best"
   [[ -z ${ARGS_EXTRA_PROCESS_o2_mch_reco_workflow:-} ]] && ARGS_EXTRA_PROCESS_o2_mch_reco_workflow="--digits"
-  if [[ -z ${CONFIG_EXTRA_PROCESS_o2_mch_reco_workflow:-} ]]; then
-    if [[ $IS_SIMULATED_DATA == 1 ]]; then
-      CONFIG_EXTRA_PROCESS_o2_mch_reco_workflow="MCHTimeClusterizer.peakSearchSignalOnly=false;MCHDigitFilter.rejectBackground=false;"
-    elif [[ $RUNTYPE == "PHYSICS" && $BEAMTYPE == "pp" ]] || [[ $RUNTYPE == "COSMICS" ]]; then
-      CONFIG_EXTRA_PROCESS_o2_mch_reco_workflow="MCHTracking.chamberResolutionX=0.4;MCHTracking.chamberResolutionY=0.4;MCHTracking.sigmaCutForTracking=7.;MCHTracking.sigmaCutForImprovement=6.;"
-    fi
-    has_detector_reco ITS && [[ $RUNTYPE != "COSMICS" ]] && CONFIG_EXTRA_PROCESS_o2_mch_reco_workflow+="MCHTimeClusterizer.irFramesOnly=true;"
-    [[ ! -z ${CUT_RANDOM_FRACTION_MCH:-} ]] && CONFIG_EXTRA_PROCESS_o2_mch_reco_workflow+="MCHTimeClusterizer.rofRejectionFraction=$CUT_RANDOM_FRACTION_MCH;"
-    CONFIG_EXTRA_PROCESS_o2_mch_reco_workflow+="MCHStatusMap.useHV=false;MCHDigitFilter.statusMask=3;"
+  if [[ $IS_SIMULATED_DATA == 1 ]]; then
+    MCH_CONFIG_KEY+="MCHTimeClusterizer.peakSearchSignalOnly=false;MCHDigitFilter.rejectBackground=false;"
+  elif [[ $RUNTYPE == "PHYSICS" && $BEAMTYPE == "pp" ]] || [[ $RUNTYPE == "COSMICS" ]]; then
+    MCH_CONFIG_KEY+="MCHTracking.chamberResolutionX=0.4;MCHTracking.chamberResolutionY=0.4;MCHTracking.sigmaCutForTracking=7.;MCHTracking.sigmaCutForImprovement=6.;"
   fi
+  has_detector_reco ITS && [[ $RUNTYPE != "COSMICS" ]] && MCH_CONFIG_KEY+="MCHTimeClusterizer.irFramesOnly=true;"
+  [[ ! -z ${CUT_RANDOM_FRACTION_MCH:-} ]] && MCH_CONFIG_KEY+="MCHTimeClusterizer.rofRejectionFraction=$CUT_RANDOM_FRACTION_MCH;"
+  MCH_CONFIG_KEY+="MCHStatusMap.useHV=false;MCHDigitFilter.statusMask=3;"
   [[ $RUNTYPE == "COSMICS" ]] && [[ -z ${CONFIG_EXTRA_PROCESS_o2_mft_reco_workflow:-} ]] && CONFIG_EXTRA_PROCESS_o2_mft_reco_workflow="MFTTracking.FullClusterScan=true"
 fi
 [[ $SYNCRAWMODE == 1 ]] && [[ -z ${CONFIG_EXTRA_PROCESS_o2_zdc_digits_reco:-} ]] && CONFIG_EXTRA_PROCESS_o2_zdc_digits_reco='RecoParamZDC.tdc_calib[9]=1;RecoParamZDC.tdc_calib[0]=1;RecoParamZDC.tdc_calib[8]=1;RecoParamZDC.tdc_calib[1]=1;RecoParamZDC.tdc_calib[3]=1;RecoParamZDC.tdc_calib[6]=1;RecoParamZDC.tdc_calib[5]=1;RecoParamZDC.tdc_calib[4]=1;RecoParamZDC.tdc_calib[2]=1;RecoParamZDC.tdc_calib[7]=1;RecoParamZDC.energy_calib[13]=1;RecoParamZDC.energy_calib[12]=1;RecoParamZDC.energy_calib[11]=1;RecoParamZDC.energy_calib[6]=1;RecoParamZDC.energy_calib[25]=1;RecoParamZDC.energy_calib[14]=1;RecoParamZDC.energy_calib[20]=1;RecoParamZDC.energy_calib[5]=1;RecoParamZDC.energy_calib[0]=1;RecoParamZDC.energy_calib[19]=1;RecoParamZDC.tower_calib[1]=1;RecoParamZDC.tower_calib[2]=1;RecoParamZDC.tower_calib[3]=1;RecoParamZDC.tower_calib[4]=1;RecoParamZDC.tower_calib[24]=1;RecoParamZDC.tower_calib[21]=1;RecoParamZDC.tower_calib[22]=1;RecoParamZDC.tower_calib[23]=1;RecoParamZDC.tower_calib[18]=1;RecoParamZDC.tower_calib[16]=1;RecoParamZDC.tower_calib[17]=1;RecoParamZDC.tower_calib[15]=1;RecoParamZDC.tower_calib[8]=1;RecoParamZDC.tower_calib[9]=1;RecoParamZDC.tower_calib[7]=1;RecoParamZDC.tower_calib[10]=1'

From 82782fd2272801c9b0a961a1b2204c949091dd69 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 2 May 2025 11:26:58 +0200
Subject: [PATCH 0309/1764] DPL Analysis: fix case in which booleans are stored
 in more than one chunk (#14230)

---
 Framework/AnalysisSupport/src/TTreePlugin.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/AnalysisSupport/src/TTreePlugin.cxx b/Framework/AnalysisSupport/src/TTreePlugin.cxx
index 4481c06a8c6d9..90b862e5fc8d1 100644
--- a/Framework/AnalysisSupport/src/TTreePlugin.cxx
+++ b/Framework/AnalysisSupport/src/TTreePlugin.cxx
@@ -209,7 +209,7 @@ auto readBoolValues = [](uint8_t* target, ReadOps& op, TBufferFile& rootBuffer)
   int readLast = 0;
   while (readEntries < op.rootBranchEntries) {
     auto beginValue = readLast;
-    auto readLast = op.branch->GetBulkRead().GetBulkEntries(readEntries, rootBuffer);
+    readLast = op.branch->GetBulkRead().GetBulkEntries(readEntries, rootBuffer);
     int size = readLast * op.listSize;
     readEntries += readLast;
     for (int i = beginValue; i < beginValue + size; ++i) {

From 77beb78fb1f066153157ee06738e1405544d381d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 2 May 2025 12:56:31 +0200
Subject: [PATCH 0310/1764] DPL Analysis: modernize expression parsing code
 (#14185)

---
 .../Core/include/Framework/Expressions.h      |  31 +++---
 Framework/Core/src/Expressions.cxx            | 100 ++++++++----------
 2 files changed, 65 insertions(+), 66 deletions(-)

diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index af89e56f85835..9e00388ee5df8 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -69,6 +69,7 @@ struct ExpressionInfo {
 
 namespace o2::framework::expressions
 {
+void unknownParameterUsed(const char* name);
 const char* stringType(atype::type t);
 
 template <typename... T>
@@ -147,7 +148,7 @@ struct PlaceholderNode : LiteralNode {
     if constexpr (variant_trait_v<typename std::decay<T>::type> != VariantType::Unknown) {
       retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{context.options().get<T>(name)}; };
     } else {
-      runtime_error("Unknown parameter used in expression.");
+      unknownParameterUsed(name.c_str());
     }
   }
 
@@ -188,6 +189,19 @@ struct ParameterNode : LiteralNode {
 struct ConditionalNode {
 };
 
+/// concepts
+template <typename T>
+concept is_literal_like = std::same_as<T, LiteralNode> || std::same_as<T, PlaceholderNode> || std::same_as<T, ParameterNode>;
+
+template <typename T>
+concept is_binding = std::same_as<T, BindingNode>;
+
+template <typename T>
+concept is_operation = std::same_as<T, OpNode>;
+
+template <typename T>
+concept is_conditional = std::same_as<T, ConditionalNode>;
+
 /// A generic tree node
 struct Node {
   Node(LiteralNode&& v) : self{std::forward<LiteralNode>(v)}, left{nullptr}, right{nullptr}, condition{nullptr}
@@ -267,7 +281,7 @@ struct NodeRecord {
 
 /// Tree-walker helper
 template <typename L>
-void walk(Node* head, L const& pred)
+void walk(Node* head, L&& pred)
 {
   std::stack<NodeRecord> path;
   path.emplace(head, 0);
@@ -512,16 +526,15 @@ inline Node binned(std::vector<T> const& binning, std::vector<T> const& paramete
 }
 
 template <typename T>
-Node updateParameters(Node const& pexp, int bins, std::vector<T> const& parameters, int bin)
+inline Node updateParameters(Node const& pexp, int bins, std::vector<T> const& parameters, int bin)
 {
   Node result{pexp};
-  auto updateParameter = [&bins, &parameters, &bin](Node* node) {
+  walk(&result, [&bins, &parameters, &bin](Node* node) {
     if (node->self.index() == 5) {
       auto* n = std::get_if<5>(&node->self);
       n->reset(parameters[n->index * bins + bin]);
     }
-  };
-  walk(&result, updateParameter);
+  });
   return result;
 }
 
@@ -594,12 +607,6 @@ gandiva::ExpressionPtr makeExpression(gandiva::NodePtr node, gandiva::FieldPtr r
 /// Update placeholder nodes from context
 void updatePlaceholders(Filter& filter, InitContext& context);
 
-template <typename... C>
-std::vector<expressions::Projector> makeProjectors(framework::pack<C...>)
-{
-  return {C::Projector()...};
-}
-
 std::shared_ptr<gandiva::Projector> createProjectorHelper(size_t nColumns, expressions::Projector* projectors,
                                                           std::shared_ptr<arrow::Schema> schema,
                                                           std::vector<std::shared_ptr<arrow::Field>> const& fields);
diff --git a/Framework/Core/src/Expressions.cxx b/Framework/Core/src/Expressions.cxx
index 6f646515b7837..94649f8639a0a 100644
--- a/Framework/Core/src/Expressions.cxx
+++ b/Framework/Core/src/Expressions.cxx
@@ -24,6 +24,10 @@ using namespace o2::framework;
 
 namespace o2::framework::expressions
 {
+void unknownParameterUsed(const char* name)
+{
+  runtime_error_f("Unknown parameter used in expression: %s", name);
+}
 
 /// a map between BasicOp and gandiva node definitions
 /// note that logical 'and' and 'or' are created separately
@@ -89,43 +93,41 @@ size_t Filter::designateSubtrees(Node* node, size_t index)
   return index;
 }
 
-namespace
+template <typename T>
+constexpr inline auto makeDatum(T const&)
 {
-struct LiteralNodeHelper {
-  DatumSpec operator()(LiteralNode const& node) const
-  {
-    return DatumSpec{node.value, node.type};
-  }
-};
+  return DatumSpec{};
+}
 
-struct BindingNodeHelper {
-  DatumSpec operator()(BindingNode const& node) const
-  {
-    return DatumSpec{node.name, node.hash, node.type};
-  }
-};
+template <is_literal_like T>
+constexpr inline auto makeDatum(T const& node)
+{
+  return DatumSpec{node.value, node.type};
+}
 
-struct OpNodeHelper {
-  ColumnOperationSpec operator()(OpNode const& node) const
-  {
-    return ColumnOperationSpec{node.op};
-  }
-};
+template <is_binding T>
+constexpr inline auto makeDatum(T const& node)
+{
+  return DatumSpec{node.name, node.hash, node.type};
+}
 
-struct PlaceholderNodeHelper {
-  DatumSpec operator()(PlaceholderNode const& node) const
-  {
-    return DatumSpec{node.value, node.type};
-  }
-};
+template <typename T>
+constexpr inline auto makeOp(T const&, size_t const&)
+{
+  return ColumnOperationSpec{};
+}
 
-struct ParameterNodeHelper {
-  DatumSpec operator()(ParameterNode const& node) const
-  {
-    return DatumSpec{node.value, node.type};
-  }
-};
-} // namespace
+template <is_operation T>
+constexpr inline auto makeOp(T const& node, size_t const& index)
+{
+  return ColumnOperationSpec{node.op, index};
+}
+
+template <is_conditional T>
+constexpr inline auto makeOp(T const&, size_t const& index)
+{
+  return ColumnOperationSpec{BasicOp::Conditional, index};
+}
 
 std::shared_ptr<arrow::DataType> concreteArrowType(atype::type type)
 {
@@ -169,7 +171,7 @@ std::string upcastTo(atype::type f)
     case atype::DOUBLE:
       return "castFLOAT8";
     default:
-      throw runtime_error_f("Do not know how to cast to %d", f);
+      throw runtime_error_f("Do not know how to cast to %s", stringType(f));
   }
 }
 
@@ -196,13 +198,11 @@ std::ostream& operator<<(std::ostream& os, DatumSpec const& spec)
 
 void updatePlaceholders(Filter& filter, InitContext& context)
 {
-  auto updateNode = [&](Node* node) {
+  expressions::walk(filter.node.get(), [&](Node* node) {
     if (node->self.index() == 3) {
       std::get_if<3>(&node->self)->reset(context);
     }
-  };
-
-  expressions::walk(filter.node.get(), updateNode);
+  });
 }
 
 const char* stringType(atype::type t)
@@ -246,12 +246,7 @@ Operations createOperations(Filter const& expression)
 
   auto processLeaf = [](Node const* const node) {
     return std::visit(
-      overloaded{
-        [lh = LiteralNodeHelper{}](LiteralNode const& node) { return lh(node); },
-        [bh = BindingNodeHelper{}](BindingNode const& node) { return bh(node); },
-        [ph = PlaceholderNodeHelper{}](PlaceholderNode const& node) { return ph(node); },
-        [pr = ParameterNodeHelper{}](ParameterNode const& node) { return pr(node); },
-        [](auto&&) { return DatumSpec{}; }},
+      [](auto const& n) { return makeDatum(n); },
       node->self);
   };
 
@@ -266,10 +261,7 @@ Operations createOperations(Filter const& expression)
     // create operation spec, pop the node and add its children
     auto operationSpec =
       std::visit(
-        overloaded{
-          [&](OpNode node) { return ColumnOperationSpec{node.op, top.node_ptr->index}; },
-          [&](ConditionalNode) { return ColumnOperationSpec{BasicOp::Conditional, top.node_ptr->index}; },
-          [](auto&&) { return ColumnOperationSpec{}; }},
+        [&](auto const& n) { return makeOp(n, top.node_ptr->index); },
         top.node_ptr->self);
 
     operationSpec.result = DatumSpec{top.index, operationSpec.type};
@@ -623,15 +615,15 @@ gandiva::NodePtr createExpressionTree(Operations const& opSpecs,
     auto rightNode = datumNode(it->right);
     auto condNode = datumNode(it->condition);
 
-    auto insertUpcastNode = [&](gandiva::NodePtr node, atype::type t) {
-      if (t != it->type) {
-        auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(it->type), {node}, concreteArrowType(it->type));
+    auto insertUpcastNode = [](gandiva::NodePtr node, atype::type t0, atype::type t) {
+      if (t != t0) {
+        auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(t0), {node}, concreteArrowType(t0));
         node = upcast;
       }
       return node;
     };
 
-    auto insertEqualizeUpcastNode = [&](gandiva::NodePtr& node1, gandiva::NodePtr& node2, atype::type t1, atype::type t2) {
+    auto insertEqualizeUpcastNode = [](gandiva::NodePtr& node1, gandiva::NodePtr& node2, atype::type t1, atype::type t2) {
       if (t2 > t1) {
         auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(t2), {node1}, concreteArrowType(t2));
         node1 = upcast;
@@ -656,14 +648,14 @@ gandiva::NodePtr createExpressionTree(Operations const& opSpecs,
       default:
         if (it->op < BasicOp::Sqrt) {
           if (it->type != atype::BOOL) {
-            leftNode = insertUpcastNode(leftNode, it->left.type);
-            rightNode = insertUpcastNode(rightNode, it->right.type);
+            leftNode = insertUpcastNode(leftNode, it->type, it->left.type);
+            rightNode = insertUpcastNode(rightNode, it->type, it->right.type);
           } else if (it->op == BasicOp::Equal || it->op == BasicOp::NotEqual) {
             insertEqualizeUpcastNode(leftNode, rightNode, it->left.type, it->right.type);
           }
           temp_node = gandiva::TreeExprBuilder::MakeFunction(basicOperationsMap[it->op], {leftNode, rightNode}, concreteArrowType(it->type));
         } else {
-          leftNode = insertUpcastNode(leftNode, it->left.type);
+          leftNode = insertUpcastNode(leftNode, it->type, it->left.type);
           temp_node = gandiva::TreeExprBuilder::MakeFunction(basicOperationsMap[it->op], {leftNode}, concreteArrowType(it->type));
         }
         break;

From e3fdb85e058e0112369e163260c6ca170e37365b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 2 May 2025 13:41:58 +0200
Subject: [PATCH 0311/1764] DPL: fix reading of booleans from branches with
 more than 2 baskets. (#14231)

---
 Framework/AnalysisSupport/src/TTreePlugin.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/AnalysisSupport/src/TTreePlugin.cxx b/Framework/AnalysisSupport/src/TTreePlugin.cxx
index 90b862e5fc8d1..28fd713112c94 100644
--- a/Framework/AnalysisSupport/src/TTreePlugin.cxx
+++ b/Framework/AnalysisSupport/src/TTreePlugin.cxx
@@ -208,7 +208,7 @@ auto readBoolValues = [](uint8_t* target, ReadOps& op, TBufferFile& rootBuffer)
   memset(target, 0, op.targetBuffer->size());
   int readLast = 0;
   while (readEntries < op.rootBranchEntries) {
-    auto beginValue = readLast;
+    auto beginValue = readEntries;
     readLast = op.branch->GetBulkRead().GetBulkEntries(readEntries, rootBuffer);
     int size = readLast * op.listSize;
     readEntries += readLast;

From 0938b3554fdce42d98b681bf173c9484b6b8784e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 5 May 2025 15:16:58 +0200
Subject: [PATCH 0312/1764] GPU Standalone: Build OrtInterface only when ONNX
 is available

---
 GPU/GPUTracking/Standalone/CMakeLists.txt          | 2 +-
 GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index c112be6abac11..8ce95c8e96d3a 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -139,7 +139,6 @@ endif()
 add_subdirectory(../../ GPU)
 add_library(standalone_support SHARED
             ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
-            ${O2_DIR}/Common/ML/src/OrtInterface.cxx
             ${O2_DIR}/Common/Utils/src/StringUtils.cxx
             ${O2_DIR}/DataFormats/Detectors/TPC/src/CompressedClusters.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
@@ -228,6 +227,7 @@ endif()
 
 if(GPUCA_CONFIG_ONNX)
   target_link_libraries(standalone_support PRIVATE onnxruntime::onnxruntime)
+  target_sources(standalone_support PRIVATE ${O2_DIR}/Common/ML/src/OrtInterface.cxx)
 endif()
 
 if (GPUCA_BUILD_DEBUG_SANITIZE AND CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
diff --git a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
index f82c537956ead..f6866bb80da05 100644
--- a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
+++ b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 // Run e.g. as (replacing [FILE] and [OUTPUT]:
-// echo -e '#define PARAMETER_FILE "[FILE]]"\ngInterpreter->AddIncludePath("'`pwd`'/include/GPU");\n.x share/GPU/tools/dumpGPUDefParam.C("[OUTPUT]")\n.q\n' | root -l -b
+// echo -e '#define PARAMETER_FILE "[FILE]"\ngInterpreter->AddIncludePath("'`pwd`'/include/GPU");\n.x share/GPU/tools/dumpGPUDefParam.C("[OUTPUT]")\n.q\n' | root -l -b
 // To dump the defaults for AMPERE architecture, run
 // echo -e '#define GPUCA_GPUTYPE_AMPERE\n#define PARAMETER_FILE "GPUDefParametersDefaults.h"\ngInterpreter->AddIncludePath("'`pwd`'/include/GPU");\n.x share/GPU/tools/dumpGPUDefParam.C("default_AMPERE.par")\n.q\n' | root -l -b
 

From e786dc0644d91601d319b6a2bc25aed40eb12769 Mon Sep 17 00:00:00 2001
From: Hadi Hassan <hadi.hassan@cern.ch>
Date: Tue, 6 May 2025 03:03:10 +0300
Subject: [PATCH 0313/1764] [FOCAL-55] Open the detector in the middle in x
 (#14232)

* Open the detector in the middle in x

* Formatting
---
 .../FOCAL/base/include/FOCALBase/Geometry.h   |  6 ++
 Detectors/FOCAL/base/src/Geometry.cxx         | 14 +++-
 .../geometryFiles/geometry_Spaghetti.txt      |  4 ++
 Detectors/FOCAL/simulation/src/Detector.cxx   | 72 +++++++++++++++----
 4 files changed, 80 insertions(+), 16 deletions(-)

diff --git a/Detectors/FOCAL/base/include/FOCALBase/Geometry.h b/Detectors/FOCAL/base/include/FOCALBase/Geometry.h
index 4938ebb1925dd..770c0aa3c1cf5 100644
--- a/Detectors/FOCAL/base/include/FOCALBase/Geometry.h
+++ b/Detectors/FOCAL/base/include/FOCALBase/Geometry.h
@@ -135,6 +135,9 @@ class Geometry
   bool getInsertFrontPadLayers() const { return mInsertFrontPadLayers; }
   bool getInsertHCalReadoutMaterial() const { return mInsertFrontHCalReadoutMaterial; }
 
+  float getDetectorOpeningRight() const { return mGlobal_DetectorOpening_Right; }
+  float getDetectorOpeningLeft() const { return mGlobal_DetectorOpening_Left; }
+
   std::vector<const Composition*> getFOCALMicroModule(int layer) const;
   const Composition* getComposition(int layer, int stack) const;
   std::string_view getTowerGapMaterial() const { return mGlobal_Gap_Material; }
@@ -175,6 +178,9 @@ class Geometry
   float mWaferSizeX = 0.0;      // Wafer X size
   float mWaferSizeY = 0.0;      // Wafer Y size
 
+  float mGlobal_DetectorOpening_Right = 0.0; // detector opening in X
+  float mGlobal_DetectorOpening_Left = 0.0;  // detector opening in Y
+
   // PIX setup
   float mGlobal_Pixel_Size = 0.0;  // pixel size
   float mGlobal_PIX_SizeX = 0.0;   // sensor size X
diff --git a/Detectors/FOCAL/base/src/Geometry.cxx b/Detectors/FOCAL/base/src/Geometry.cxx
index 94d8c2cee049c..db47816ba8537 100644
--- a/Detectors/FOCAL/base/src/Geometry.cxx
+++ b/Detectors/FOCAL/base/src/Geometry.cxx
@@ -351,6 +351,16 @@ void Geometry::setParameters(std::string geometryfile)
         LOG(debug) << "Z-Location of the FoCAL is set to : " << mGlobal_FOCAL_Z0;
       }
 
+      if (command.find("DetectorOpen_Right") != std::string::npos) {
+        mGlobal_DetectorOpening_Right = std::stof(tokens[1]);
+        LOG(debug) << "Detector opening on the right : " << mGlobal_DetectorOpening_Right;
+      }
+
+      if (command.find("DetectorOpen_Left") != std::string::npos) {
+        mGlobal_DetectorOpening_Left = std::stof(tokens[1]);
+        LOG(debug) << "Detector opening on the left : " << mGlobal_DetectorOpening_Left;
+      }
+
       if (command.find("HCAL_TOWER_SIZE") != std::string::npos) {
         mGlobal_HCAL_Tower_Size = std::stof(tokens[1]);
         LOG(debug) << "The size of the HCAL readout tower will be : " << mGlobal_HCAL_Tower_Size;
@@ -578,8 +588,8 @@ void Geometry::setParameters(std::string geometryfile)
             }
           }
         } // end for itowerY
-      }   // end for itowerX
-    }     // end else
+      } // end for itowerX
+    } // end else
     center_z += tmpComp.getThickness();
   } // end loop over pad layer compositions
   LOG(debug) << "============ Created all pad layer compositions (" << mPadCompositionBase.size() << " volumes)";
diff --git a/Detectors/FOCAL/simulation/geometryFiles/geometry_Spaghetti.txt b/Detectors/FOCAL/simulation/geometryFiles/geometry_Spaghetti.txt
index 5209204cc5eca..31f6940224337 100644
--- a/Detectors/FOCAL/simulation/geometryFiles/geometry_Spaghetti.txt
+++ b/Detectors/FOCAL/simulation/geometryFiles/geometry_Spaghetti.txt
@@ -59,6 +59,10 @@ COMMAND_INSERT_PIX_AT_L9
   GLOBAL_TOWER_TOLX       0.02  Air
   GLOBAL_TOWER_TOLY       0.8   Al
   GLOBAL_FOCAL_Z          763.5
+# Open the detector on the right and left in cm,
+# can only work if the GLOBAL_HCAL_TOWER_NY is odd number and GLOBAL_HCAL_TOWER_NX is even number
+#  GLOBAL_DetectorOpen_Right 5
+#  GLOBAL_DetectorOpen_Left  5
   GLOBAL_Tower_NX      2
   GLOBAL_Tower_NY      11
   GLOBAL_MIDDLE_TOWER_OFFSET 5
diff --git a/Detectors/FOCAL/simulation/src/Detector.cxx b/Detectors/FOCAL/simulation/src/Detector.cxx
index 08df253d49f83..dc71c1066afdf 100644
--- a/Detectors/FOCAL/simulation/src/Detector.cxx
+++ b/Detectors/FOCAL/simulation/src/Detector.cxx
@@ -539,6 +539,8 @@ void Detector::CreateHCALSpaghetti()
     }
   }
 
+  bool splitDet = mGeometry->getDetectorOpeningRight() > 0.0 || mGeometry->getDetectorOpeningLeft() > 0.0;
+
   double TowerSize = mGeometry->getHCALTowerSize();
   double CuBoxThickness = 0.3; // Thickness of the Cu box carrying capillary tubes
 
@@ -598,25 +600,57 @@ void Detector::CreateHCALSpaghetti()
   Columns = 0;
   RowPos = 0.;
   Int_t NumTowers = 1;
-  for (Rows = 0; Rows < nTowersY; Rows++) {
 
-    float ColumnPos = 0.;
-    RowPos = Rows * TowerSize;
-    for (Columns = 0; Columns < nTowersX; Columns++) {
-      ColumnPos = Columns * TowerSize;
-      TGeoTranslation* trans = new TGeoTranslation(ColumnPos - SizeXHCAL / 2 + TowerSize / 2, RowPos - SizeYHCAL / 2 + TowerSize / 2, 0.);
+  if (splitDet) {
+    SizeXHCAL = SizeXHCAL / 2;
 
-      // Remove the Towers that overlaps with the beam pipe
-      Double_t RadialDistance = TMath::Power(trans->GetTranslation()[0], 2) + TMath::Power(trans->GetTranslation()[1], 2);
+    TGeoVolumeAssembly* volHalfHCAL = new TGeoVolumeAssembly("HalfHCAL");
 
-      if (RadialDistance < MinRadius * MinRadius || TMath::Abs(trans->GetTranslation()[0]) > SizeXHCAL / 2) {
-        continue;
+    for (Rows = 0; Rows < nTowersY; Rows++) {
+
+      float ColumnPos = 0.;
+      RowPos = Rows * TowerSize;
+      for (Columns = 0; Columns < nTowersX / 2; Columns++) {
+        ColumnPos = Columns * TowerSize;
+        TGeoTranslation* trans = new TGeoTranslation(ColumnPos - SizeXHCAL / 2 + TowerSize / 2, RowPos - SizeYHCAL / 2 + TowerSize / 2, 0.);
+
+        // Shit the beampipe towers by TowerSize/2
+        if (Rows == nTowersY / 2) {
+          trans->SetDx(trans->GetTranslation()[0] + TowerSize / 2);
+        }
+
+        // Adding the Tower to the HCAL
+        volHalfHCAL->AddNode(volTowerHCAL, NumTowers, trans);
+
+        NumTowers++;
       }
+      volHCAL->AddNode(volHalfHCAL, 1, new TGeoTranslation(SizeXHCAL / 2 + mGeometry->getDetectorOpeningRight(), 0, 0));
+      TGeoRotation* rotFlipZ = new TGeoRotation();
+      rotFlipZ->RotateY(180); // Flip around Y to reverse Z
+      TGeoCombiTrans* combHalf = new TGeoCombiTrans(-SizeXHCAL / 2 - mGeometry->getDetectorOpeningLeft(), 0., 0., rotFlipZ);
+      volHCAL->AddNode(volHalfHCAL, 2, combHalf);
+    }
+  } else {
+    for (Rows = 0; Rows < nTowersY; Rows++) {
 
-      // Adding the Tower to the HCAL
-      volHCAL->AddNode(volTowerHCAL, NumTowers, trans);
+      float ColumnPos = 0.;
+      RowPos = Rows * TowerSize;
+      for (Columns = 0; Columns < nTowersX; Columns++) {
+        ColumnPos = Columns * TowerSize;
+        TGeoTranslation* trans = new TGeoTranslation(ColumnPos - SizeXHCAL / 2 + TowerSize / 2, RowPos - SizeYHCAL / 2 + TowerSize / 2, 0.);
 
-      NumTowers++;
+        // Remove the Towers that overlaps with the beam pipe
+        Double_t RadialDistance = TMath::Power(trans->GetTranslation()[0], 2) + TMath::Power(trans->GetTranslation()[1], 2);
+
+        if (RadialDistance < MinRadius * MinRadius || TMath::Abs(trans->GetTranslation()[0]) > SizeXHCAL / 2) {
+          continue;
+        }
+
+        // Adding the Tower to the HCAL
+        volHCAL->AddNode(volTowerHCAL, NumTowers, trans);
+
+        NumTowers++;
+      }
     }
   }
 
@@ -791,6 +825,8 @@ void Detector::CreateECALGeometry()
   // this shifts all the pixel layers to the center near the beampipe
   double pixshift = geom->getTowerSizeX() - (geom->getGlobalPixelWaferSizeX() * geom->getNumberOfPIXsInX());
 
+  bool splitDet = mGeometry->getDetectorOpeningRight() > 0.0 || mGeometry->getDetectorOpeningLeft() > 0.0;
+
   float offset = pars[2];
   // gMC->Gsvolu("EMSC1", "BOX", idtmed[3698], pars, 4);//Left towers (pixels shifted right)
   // gMC->Gsvolu("EMSC2", "BOX", idtmed[3698], pars, 4);//Right towers (pixels shifted left)
@@ -977,9 +1013,13 @@ void Detector::CreateECALGeometry()
     // const auto towerCenter = geom->getGeoTowerCenter(number); //only ECAL part, second parameter = -1 by default
     // xp = std::get<0>towerCenter;
     // std::tie(xp, yp, zp) = geom->getGeoTowerCenter(number);
-    const auto [xp, yp, zp] = geom->getGeoTowerCenter(number); // only ECAL part, second parameter = -1 by default
+    auto [xp, yp, zp] = geom->getGeoTowerCenter(number); // only ECAL part, second parameter = -1 by default
 
     if (itowerx == 0) {
+      if (splitDet) {
+        xp -= geom->getDetectorOpeningLeft();
+      }
+
       TVirtualMC::GetMC()->Gspos("EMSC1", number + 1, "ECAL", xp, yp, 0, 0, "ONLY");
       // Add the SiPad front volumes directly under the FOCAL volume
       if (geom->getInsertFrontPadLayers()) {
@@ -992,6 +1032,10 @@ void Detector::CreateECALGeometry()
       }
     }
     if (itowerx == 1) {
+      if (splitDet) {
+        xp += geom->getDetectorOpeningRight();
+      }
+
       TVirtualMC::GetMC()->Gspos("EMSC2", number + 1, "ECAL", xp, yp, 0, 0, "ONLY");
       // Add the SiPad front volumes directly under the FOCAL volume
       if (geom->getInsertFrontPadLayers()) {

From 69f1fd10feb52387174f8b5024d7a5afbdf02dd2 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 5 May 2025 22:00:05 +0800
Subject: [PATCH 0314/1764] ITS3: Fix APTS response file generation

Was unnecessarily generated on every built.
---
 Detectors/Upgrades/ITS3/data/CMakeLists.txt | 29 ++++++++++++++-------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/data/CMakeLists.txt b/Detectors/Upgrades/ITS3/data/CMakeLists.txt
index ba8b60c8aa7eb..7a807fd670370 100644
--- a/Detectors/Upgrades/ITS3/data/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/data/CMakeLists.txt
@@ -9,17 +9,26 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
+set(APTS_RESPONSE_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/APTSResponseData.root")
+
+add_custom_command(
+  OUTPUT ${APTS_RESPONSE_OUTPUT}
+  COMMAND ${CMAKE_BINARY_DIR}/stage/bin/o2-alpide-response-generator
+    -c APTS
+    -i ${ITSRESPONSE_DIR}/response/ITS3ChipResponseData/AptsResponseData/
+    -o ${CMAKE_CURRENT_BINARY_DIR}/
+  DEPENDS GenerateAlpideResponse
+          ${ITSRESPONSE_DIR}/response/ITS3ChipResponseData/AptsResponseData/
+  COMMENT "Generating APTSResponseData.root"
+  VERBATIM
+)
+
 add_custom_target(
   GenerateAPTSResponse ALL
-  COMMAND
-    ${CMAKE_BINARY_DIR}/stage/bin/o2-alpide-response-generator -c APTS -i
-    ${ITSRESPONSE_DIR}/response/ITS3ChipResponseData/AptsResponseData/ -o
-    ${CMAKE_CURRENT_BINARY_DIR}/
-  BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/APTSResponseData.root
-  DEPENDS GenerateAlpideResponse
-  COMMENT "Generating APTSResponseData.root")
+  DEPENDS ${APTS_RESPONSE_OUTPUT}
+)
+
 install(
-  FILES "${CMAKE_CURRENT_BINARY_DIR}/APTSResponseData.root"
-  DESTINATION
-    "${CMAKE_INSTALL_PREFIX}/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/"
+  FILES ${APTS_RESPONSE_OUTPUT}
+  DESTINATION "${CMAKE_INSTALL_PREFIX}/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/"
 )

From 15b4f5f19e1eef23d79bdb3225e36348a845722d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 6 May 2025 08:56:19 +0200
Subject: [PATCH 0315/1764] DPL Analysis: prevent slice cache from updating
 when not required by enabled process functions (#14057)

---
 Framework/Core/include/Framework/ASoA.h       | 12 ++---
 .../Core/include/Framework/AnalysisManagers.h | 14 ++++--
 .../Core/include/Framework/AnalysisTask.h     | 22 ++++-----
 .../Framework/ArrowTableSlicingCache.h        | 45 +++++++++++------
 .../Core/include/Framework/GroupSlicer.h      |  2 +-
 Framework/Core/src/ASoA.cxx                   |  2 +-
 Framework/Core/src/ArrowSupport.cxx           | 19 +++----
 Framework/Core/src/ArrowTableSlicingCache.cxx | 49 ++++++++++---------
 Framework/Core/test/test_GroupSlicer.cxx      |  4 +-
 9 files changed, 96 insertions(+), 73 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index e098cd89f6d5d..2e478a8ca64a6 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1400,10 +1400,10 @@ namespace o2::framework
 
 struct PreslicePolicyBase {
   const std::string binding;
-  StringPair bindingKey;
+  Entry bindingKey;
 
   bool isMissing() const;
-  StringPair const& getBindingKey() const;
+  Entry const& getBindingKey() const;
 };
 
 struct PreslicePolicySorted : public PreslicePolicyBase {
@@ -1428,7 +1428,7 @@ struct PresliceBase : public Policy {
   const std::string binding;
 
   PresliceBase(expressions::BindingNode index_)
-    : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, std::make_pair(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
+    : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, Entry(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
   {
   }
 
@@ -1508,7 +1508,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.second.c_str());
+      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.key.c_str());
     }
   }
   uint64_t offset = 0;
@@ -1545,7 +1545,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.second.c_str());
+      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.key.c_str());
     }
   }
   auto selection = container.getSliceFor(value);
@@ -1574,7 +1574,7 @@ auto doFilteredSliceBy(T const* table, o2::framework::PresliceBase<C, framework:
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<T>().data(), container.bindingKey.second.c_str());
+      missingOptionalPreslice(getLabelFromType<T>().data(), container.bindingKey.key.c_str());
     }
   }
   uint64_t offset = 0;
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 330eaf01f0be4..e310f3eef990c 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -534,39 +534,43 @@ static void setGroupedCombination(C& comb, TG& grouping, std::tuple<Ts...>& asso
 /// Preslice handling
 template <typename T>
   requires(!is_preslice<T>)
-bool registerCache(T&, std::vector<StringPair>&, std::vector<StringPair>&)
+bool registerCache(T&, Cache&, Cache&)
 {
   return false;
 }
 
 template <is_preslice T>
   requires std::same_as<typename T::policy_t, framework::PreslicePolicySorted>
-bool registerCache(T& preslice, std::vector<StringPair>& bsks, std::vector<StringPair>&)
+bool registerCache(T& preslice, Cache& bsks, Cache&)
 {
   if constexpr (T::optional) {
     if (preslice.binding == "[MISSING]") {
       return true;
     }
   }
-  auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); });
+  auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); });
   if (locate == bsks.end()) {
     bsks.emplace_back(preslice.getBindingKey());
+  } else if (locate->enabled == false) {
+    locate->enabled = true;
   }
   return true;
 }
 
 template <is_preslice T>
   requires std::same_as<typename T::policy_t, framework::PreslicePolicyGeneral>
-bool registerCache(T& preslice, std::vector<StringPair>&, std::vector<StringPair>& bsksU)
+bool registerCache(T& preslice, Cache&, Cache& bsksU)
 {
   if constexpr (T::optional) {
     if (preslice.binding == "[MISSING]") {
       return true;
     }
   }
-  auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); });
+  auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); });
   if (locate == bsksU.end()) {
     bsksU.emplace_back(preslice.getBindingKey());
+  } else if (locate->enabled == false) {
+    locate->enabled = true;
   }
   return true;
 }
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index c7f3da1948c62..9bd2e2af173cc 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -66,20 +66,20 @@ concept is_enumeration = is_enumeration_v<std::decay_t<T>>;
 namespace {
 struct AnalysisDataProcessorBuilder {
   template <typename G, typename... Args>
-  static void addGroupingCandidates(std::vector<StringPair>& bk, std::vector<StringPair>& bku)
+  static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled)
   {
-    [&bk, &bku]<typename... As>(framework::pack<As...>) mutable {
+    [&bk, &bku, enabled]<typename... As>(framework::pack<As...>) mutable {
       std::string key;
       if constexpr (soa::is_iterator<std::decay_t<G>>) {
         key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
       }
-      ([&bk, &bku, &key]() mutable {
+      ([&bk, &bku, &key, enabled]() mutable {
         if constexpr (soa::relatedByIndex<std::decay_t<G>, std::decay_t<As>>()) {
           auto binding = soa::getLabelFromTypeForKey<std::decay_t<As>>(key);
           if constexpr (o2::soa::is_smallgroups<std::decay_t<As>>) {
-            framework::updatePairList(bku, binding, key);
+            framework::updatePairList(bku, binding, key, enabled);
           } else {
-            framework::updatePairList(bk, binding, key);
+            framework::updatePairList(bk, binding, key, enabled);
           }
         }
       }(),
@@ -147,7 +147,7 @@ struct AnalysisDataProcessorBuilder {
   /// helper to parse the process arguments
   /// 1. enumeration (must be the only argument)
   template <typename R, typename C, is_enumeration A>
-  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&, std::vector<StringPair>&, std::vector<StringPair>&)
+  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&, Cache&, Cache&)
   {
     std::vector<ConfigParamSpec> inputMetadata;
     // FIXME: for the moment we do not support begin, end and step.
@@ -156,17 +156,17 @@ struct AnalysisDataProcessorBuilder {
 
   /// 2. grouping case - 1st argument is an iterator
   template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, std::vector<StringPair>& bk, std::vector<StringPair>& bku)
+  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, Cache& bk, Cache& bku)
     requires(std::is_lvalue_reference_v<A> && (std::is_lvalue_reference_v<Args> && ...))
   {
-    addGroupingCandidates<A, Args...>(bk, bku);
+    addGroupingCandidates<A, Args...>(bk, bku, value);
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(A, Args...)>();
     addInputsAndExpressions<typename std::decay_t<A>::parent_t, Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 3. generic case
   template <typename R, typename C, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, std::vector<StringPair>&, std::vector<StringPair>&)
+  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, Cache&, Cache&)
     requires(std::is_lvalue_reference_v<Args> && ...)
   {
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Args...)>();
@@ -480,8 +480,8 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<InputSpec> inputs;
   std::vector<ConfigParamSpec> options;
   std::vector<ExpressionInfo> expressionInfos;
-  std::vector<StringPair> bindingsKeys;
-  std::vector<StringPair> bindingsKeysUnsorted;
+  Cache bindingsKeys;
+  Cache bindingsKeysUnsorted;
 
   /// make sure options and configurables are set before expression infos are created
   homogeneous_apply_refs([&options, &hash](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
diff --git a/Framework/Core/include/Framework/ArrowTableSlicingCache.h b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
index 2edc23a63ce76..292a67023fc5e 100644
--- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h
+++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
@@ -34,51 +34,64 @@ struct SliceInfoUnsortedPtr {
   gsl::span<int64_t const> getSliceFor(int value) const;
 };
 
-using StringPair = std::pair<std::string, std::string>;
+struct Entry {
+  std::string binding;
+  std::string key;
+  bool enabled;
+
+  Entry(std::string b, std::string k, bool e = true)
+    : binding{b},
+      key{k},
+      enabled{e}
+  {
+  }
+};
+
+using Cache = std::vector<Entry>;
 
-void updatePairList(std::vector<StringPair>& list, std::string const& binding, std::string const& key);
+void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled);
 
 struct ArrowTableSlicingCacheDef {
   constexpr static ServiceKind service_kind = ServiceKind::Global;
-  std::vector<StringPair> bindingsKeys;
-  std::vector<StringPair> bindingsKeysUnsorted;
+  Cache bindingsKeys;
+  Cache bindingsKeysUnsorted;
 
-  void setCaches(std::vector<StringPair>&& bsks);
-  void setCachesUnsorted(std::vector<StringPair>&& bsks);
+  void setCaches(Cache&& bsks);
+  void setCachesUnsorted(Cache&& bsks);
 };
 
 struct ArrowTableSlicingCache {
   constexpr static ServiceKind service_kind = ServiceKind::Stream;
 
-  std::vector<StringPair> bindingsKeys;
+  Cache bindingsKeys;
   std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int32Type>>> values;
   std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int64Type>>> counts;
 
-  std::vector<StringPair> bindingsKeysUnsorted;
+  Cache bindingsKeysUnsorted;
   std::vector<std::vector<int>> valuesUnsorted;
   std::vector<ListVector> groups;
 
-  ArrowTableSlicingCache(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted = {});
+  ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted = {});
 
   // set caching information externally
-  void setCaches(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted = {});
+  void setCaches(Cache&& bsks, Cache&& bsksUnsorted = {});
 
   // update slicing info cache entry (assumes it is already present)
   arrow::Status updateCacheEntry(int pos, std::shared_ptr<arrow::Table> const& table);
   arrow::Status updateCacheEntryUnsorted(int pos, std::shared_ptr<arrow::Table> const& table);
 
   // helper to locate cache position
-  std::pair<int, bool> getCachePos(StringPair const& bindingKey) const;
-  int getCachePosSortedFor(StringPair const& bindingKey) const;
-  int getCachePosUnsortedFor(StringPair const& bindingKey) const;
+  std::pair<int, bool> getCachePos(Entry const& bindingKey) const;
+  int getCachePosSortedFor(Entry const& bindingKey) const;
+  int getCachePosUnsortedFor(Entry const& bindingKey) const;
 
   // get slice from cache for a given value
-  SliceInfoPtr getCacheFor(StringPair const& bindingKey) const;
-  SliceInfoUnsortedPtr getCacheUnsortedFor(StringPair const& bindingKey) const;
+  SliceInfoPtr getCacheFor(Entry const& bindingKey) const;
+  SliceInfoUnsortedPtr getCacheUnsortedFor(Entry const& bindingKey) const;
   SliceInfoPtr getCacheForPos(int pos) const;
   SliceInfoUnsortedPtr getCacheUnsortedForPos(int pos) const;
 
-  static void validateOrder(StringPair const& bindingKey, std::shared_ptr<arrow::Table> const& input);
+  static void validateOrder(Entry const& bindingKey, std::shared_ptr<arrow::Table> const& input);
 };
 } // namespace o2::framework
 
diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h
index 64b1d863c59e6..b8436314b057e 100644
--- a/Framework/Core/include/Framework/GroupSlicer.h
+++ b/Framework/Core/include/Framework/GroupSlicer.h
@@ -55,7 +55,7 @@ struct GroupSlicer {
     {
       constexpr auto index = framework::has_type_at_v<std::decay_t<T>>(associated_pack_t{});
       auto binding = o2::soa::getLabelFromTypeForKey<std::decay_t<T>>(mIndexColumnName);
-      auto bk = std::make_pair(binding, mIndexColumnName);
+      auto bk = Entry(binding, mIndexColumnName);
       if constexpr (!o2::soa::is_smallgroups<std::decay_t<T>>) {
         if (table.size() == 0) {
           return;
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index 810398747de88..5940bc0427225 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -197,7 +197,7 @@ bool PreslicePolicyBase::isMissing() const
   return binding == "[MISSING]";
 }
 
-StringPair const& PreslicePolicyBase::getBindingKey() const
+Entry const& PreslicePolicyBase::getBindingKey() const
 {
   return bindingKey;
 }
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 12a4c7131e828..3b13e30581f70 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -567,26 +567,27 @@ o2::framework::ServiceSpec ArrowSupport::arrowTableSlicingCacheSpec()
     .name = "arrow-slicing-cache",
     .uniqueId = CommonServices::simpleServiceId<ArrowTableSlicingCache>(),
     .init = [](ServiceRegistryRef services, DeviceState&, fair::mq::ProgOptions&) { return ServiceHandle{TypeIdHelpers::uniqueId<ArrowTableSlicingCache>(),
-                                                                                                         new ArrowTableSlicingCache(std::vector<std::pair<std::string, std::string>>{services.get<ArrowTableSlicingCacheDef>().bindingsKeys}, std::vector{services.get<ArrowTableSlicingCacheDef>().bindingsKeysUnsorted}),
+                                                                                                         new ArrowTableSlicingCache(Cache{services.get<ArrowTableSlicingCacheDef>().bindingsKeys},
+                                                                                                                                    Cache{services.get<ArrowTableSlicingCacheDef>().bindingsKeysUnsorted}),
                                                                                                          ServiceKind::Stream, typeid(ArrowTableSlicingCache).name()}; },
     .configure = CommonServices::noConfiguration(),
     .preProcessing = [](ProcessingContext& pc, void* service_ptr) {
       auto* service = static_cast<ArrowTableSlicingCache*>(service_ptr);
       auto& caches = service->bindingsKeys;
-      for (auto i = 0; i < caches.size(); ++i) {
-        if (pc.inputs().getPos(caches[i].first.c_str()) >= 0) {
-          auto status = service->updateCacheEntry(i, pc.inputs().get<TableConsumer>(caches[i].first.c_str())->asArrowTable());
+      for (auto i = 0u; i < caches.size(); ++i) {
+        if (caches[i].enabled && pc.inputs().getPos(caches[i].binding.c_str()) >= 0) {
+          auto status = service->updateCacheEntry(i, pc.inputs().get<TableConsumer>(caches[i].binding.c_str())->asArrowTable());
           if (!status.ok()) {
-            throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].first.c_str(), caches[i].second.c_str());
+            throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].binding.c_str(), caches[i].key.c_str());
           }
         }
       }
       auto& unsortedCaches = service->bindingsKeysUnsorted;
-      for (auto i = 0; i < unsortedCaches.size(); ++i) {
-        if (pc.inputs().getPos(unsortedCaches[i].first.c_str()) >= 0) {
-          auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get<TableConsumer>(unsortedCaches[i].first.c_str())->asArrowTable());
+      for (auto i = 0u; i < unsortedCaches.size(); ++i) {
+        if (unsortedCaches[i].enabled && pc.inputs().getPos(unsortedCaches[i].binding.c_str()) >= 0) {
+          auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get<TableConsumer>(unsortedCaches[i].binding.c_str())->asArrowTable());
           if (!status.ok()) {
-            throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].first.c_str(), unsortedCaches[i].second.c_str());
+            throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].binding.c_str(), unsortedCaches[i].key.c_str());
           }
         }
       } },
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 4b31f96e32fba..12df5ef6c080b 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -11,6 +11,7 @@
 
 #include "Framework/ArrowTableSlicingCache.h"
 #include "Framework/RuntimeError.h"
+#include "Framework/Logger.h"
 
 #include <arrow/compute/api_aggregate.h>
 #include <arrow/compute/kernel.h>
@@ -19,10 +20,10 @@
 namespace o2::framework
 {
 
-void updatePairList(std::vector<StringPair>& list, std::string const& binding, std::string const& key)
+void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled = true)
 {
-  if (std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.first == binding) && (entry.second == key); }) == list.end()) {
-    list.emplace_back(binding, key);
+  if (std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.binding == binding) && (entry.key == key); }) == list.end()) {
+    list.emplace_back(binding, key, enabled);
   }
 }
 
@@ -65,17 +66,17 @@ gsl::span<const int64_t> SliceInfoUnsortedPtr::getSliceFor(int value) const
   return {(*groups)[value].data(), (*groups)[value].size()};
 }
 
-void ArrowTableSlicingCacheDef::setCaches(std::vector<StringPair>&& bsks)
+void ArrowTableSlicingCacheDef::setCaches(Cache&& bsks)
 {
   bindingsKeys = bsks;
 }
 
-void ArrowTableSlicingCacheDef::setCachesUnsorted(std::vector<StringPair>&& bsks)
+void ArrowTableSlicingCacheDef::setCachesUnsorted(Cache&& bsks)
 {
   bindingsKeysUnsorted = bsks;
 }
 
-ArrowTableSlicingCache::ArrowTableSlicingCache(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted)
+ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted)
   : bindingsKeys{bsks},
     bindingsKeysUnsorted{bsksUnsorted}
 {
@@ -86,7 +87,7 @@ ArrowTableSlicingCache::ArrowTableSlicingCache(std::vector<StringPair>&& bsks, s
   groups.resize(bindingsKeysUnsorted.size());
 }
 
-void ArrowTableSlicingCache::setCaches(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted)
+void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted)
 {
   bindingsKeys = bsks;
   bindingsKeysUnsorted = bsksUnsorted;
@@ -111,7 +112,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
   arrow::Datum value_counts;
   auto options = arrow::compute::ScalarAggregateOptions::Defaults();
   ARROW_ASSIGN_OR_RAISE(value_counts,
-                        arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].second)},
+                        arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].key)},
                                                      &options));
   auto pair = static_cast<arrow::StructArray>(value_counts.array());
   values[pos].reset();
@@ -128,7 +129,11 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
   if (table->num_rows() == 0) {
     return arrow::Status::OK();
   }
-  auto& [b, k] = bindingsKeysUnsorted[pos];
+  auto& [b, k, e] = bindingsKeysUnsorted[pos];
+  if (!e) {
+    LOG(debug) << "Update of disabled cache requested";
+    return arrow::Status::OK();
+  }
   auto column = table->GetColumnByName(k);
   auto row = 0;
   for (auto iChunk = 0; iChunk < column->num_chunks(); ++iChunk) {
@@ -139,7 +144,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
         if (std::find(valuesUnsorted[pos].begin(), valuesUnsorted[pos].end(), v) == valuesUnsorted[pos].end()) {
           valuesUnsorted[pos].push_back(v);
         }
-        if (groups[pos].size() <= v) {
+        if ((int)groups[pos].size() <= v) {
           groups[pos].resize(v + 1);
         }
         (groups[pos])[v].push_back(row);
@@ -151,7 +156,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
   return arrow::Status::OK();
 }
 
-std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const StringPair& bindingKey) const
+std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const Entry& bindingKey) const
 {
   auto pos = getCachePosSortedFor(bindingKey);
   if (pos != -1) {
@@ -161,41 +166,41 @@ std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const StringPair& bindi
   if (pos != -1) {
     return {pos, false};
   }
-  throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
+  throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
 }
 
-int ArrowTableSlicingCache::getCachePosSortedFor(StringPair const& bindingKey) const
+int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const
 {
-  auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); });
+  auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); });
   if (locate != bindingsKeys.end()) {
     return std::distance(bindingsKeys.begin(), locate);
   }
   return -1;
 }
 
-int ArrowTableSlicingCache::getCachePosUnsortedFor(StringPair const& bindingKey) const
+int ArrowTableSlicingCache::getCachePosUnsortedFor(Entry const& bindingKey) const
 {
-  auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); });
+  auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); });
   if (locate_unsorted != bindingsKeysUnsorted.end()) {
     return std::distance(bindingsKeysUnsorted.begin(), locate_unsorted);
   }
   return -1;
 }
-SliceInfoPtr ArrowTableSlicingCache::getCacheFor(StringPair const& bindingKey) const
+SliceInfoPtr ArrowTableSlicingCache::getCacheFor(Entry const& bindingKey) const
 {
   auto [p, s] = getCachePos(bindingKey);
   if (!s) {
-    throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
+    throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
   }
 
   return getCacheForPos(p);
 }
 
-SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const StringPair& bindingKey) const
+SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const Entry& bindingKey) const
 {
   auto [p, s] = getCachePos(bindingKey);
   if (s) {
-    throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
+    throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
   }
 
   return getCacheUnsortedForPos(p);
@@ -224,9 +229,9 @@ SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedForPos(int pos) con
   };
 }
 
-void ArrowTableSlicingCache::validateOrder(StringPair const& bindingKey, const std::shared_ptr<arrow::Table>& input)
+void ArrowTableSlicingCache::validateOrder(Entry const& bindingKey, const std::shared_ptr<arrow::Table>& input)
 {
-  auto const& [target, key] = bindingKey;
+  auto const& [target, key, enabled] = bindingKey;
   auto column = input->GetColumnByName(key);
   auto array0 = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(0)->data());
   int32_t prev = 0;
diff --git a/Framework/Core/test/test_GroupSlicer.cxx b/Framework/Core/test/test_GroupSlicer.cxx
index 161939141e790..091c21eeae229 100644
--- a/Framework/Core/test/test_GroupSlicer.cxx
+++ b/Framework/Core/test/test_GroupSlicer.cxx
@@ -683,7 +683,7 @@ TEST_CASE("ArrowDirectSlicing")
 
   std::vector<arrow::Datum> slices;
   std::vector<uint64_t> offsts;
-  auto bk = std::make_pair(soa::getLabelFromType<aod::Events>(), "fID");
+  auto bk = Entry(soa::getLabelFromType<aod::Events>(), "fID");
   ArrowTableSlicingCache cache({bk});
   auto s = cache.updateCacheEntry(0, {evtTable});
   auto lcache = cache.getCacheFor(bk);
@@ -741,7 +741,7 @@ TEST_CASE("TestSlicingException")
   }
   auto evtTable = builderE.finalize();
 
-  auto bk = std::make_pair(soa::getLabelFromType<aod::Events>(), "fID");
+  auto bk = Entry(soa::getLabelFromType<aod::Events>(), "fID");
   ArrowTableSlicingCache cache({bk});
 
   try {

From a8f5897522519647699a774697325e5e663619f5 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Tue, 6 May 2025 11:43:50 +0200
Subject: [PATCH 0316/1764] Remove tmp file (#14239)

Trivial and unaffecting anything else, merging.
---
 .../src/.ThresholdCalibratorSpec.cxx.swo        | Bin 16384 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/workflow/src/.ThresholdCalibratorSpec.cxx.swo

diff --git a/Detectors/ITSMFT/ITS/workflow/src/.ThresholdCalibratorSpec.cxx.swo b/Detectors/ITSMFT/ITS/workflow/src/.ThresholdCalibratorSpec.cxx.swo
deleted file mode 100644
index 847bb24d5cf5f12814270f83c821f9c726d7964b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16384
zcmeHOUyK_^8DA&`N-2$s656V$6G!6g^v=G!w9vRo)I0m`;wX2%-uaTINpxE8j_pm>
zyW82Z@7yD8Xaf&CqoN`ncqoV`gb)IWr<NBa1XKcEK%h`SeL*Tn{OLc^^803IZJ*=2
zT+;Lf?JB?6-f!lcncsXf^L^j$RmV@1=Gnv9aRb*b!+7+cqWZHtA2RMgZ5WO)+h)kU
zx=F&VFQ;vKW3u6R=L6H;x|s2FPhrk<9gF9t=>PI$uE-^~q%Xo;sj@sjTcMBKnlH}R
zTz@SW3M*G>2p%?k*Dj!DRhTHe9B?aZt*>v>Vj@ZyNEqlbaEEbVazZWjeW|_d(|4`(
zM9H^=frNpCfrNpCfrNpCfrNpCfrNqodj@21hw%(X`C&cMK!1K{;PX9wx%&Q-1M+vZ
zJg)!80r?dzZ|eK=x`DWz|7!UeE&s`Y{2eWKw0w{5a9sawEw5_%GXwIswES@`e|13q
zrj{Sm@`JZTUt;}lX!)X+KQ|!%kCvCT{5J#ge{1<UEx+$0oAvAB#)OuCWk9ZPCm#s|
z2?GfO2?GfO2?GfO2?GfO2?GfO2?GfOH^cxvu)hyA-=siymtn;5`^$G4MiY1hco=y7
zQ-<+f;M>4S;5Oh-cNoTH;K#s^fG-1QfYZQH;0wSwkONWx1MUKL0e1o~ebO+V2LuoR
zcLRHX-N2RG4db`KuYqTQi@-C$IB*Z}^G_JYbHJB?`+?5__W{4W%`kolJPTX|Y5)fo
zfjn>!xEFZu<A(7n@KfMhz&C+!051T?fX@KCf!}}3Fn$Mo9cTk9Km|Ae+ymSV{QaY7
z7x)G6GVlU04dj3afc?NNz&p1Z#`l4*0>^-N5#zrNyaHSVz6fjpj{zm%R^T!c11|y=
zunOz}b_1^?fAJddBJea&1g>BX-vVeZ-=O*2?qckM!3M8Ghgj;2w}1bBR&+wM>N;MX
zjmS>GN0{TWCYPpdN|X658MGv;IW7-Vk0>?A%X8^9Q+TM6VWg(yQIWtDCaQ6vDvyyW
z=J}}Vw>&$AnirU5N~^)rp|taPzHaeAI=;s&-wWmE7|*Z`r5~@CgkwjV^XNi_lpJP`
zmGxEGFrCTPxjdvagi@djN75<ktZFZnp&m-nQJQi&HpgXeC~7>aTQ%V~F-r6rmdbQ{
zWi`^GBha8fna{VR<A(YCvK0Bez$+_GtplNYccqgatfLy<mgQwGC2_n|E>~h!?N}d^
zKFj8I%5O9$W2pVU2<{*7H5l%-IF#byW7^DeL{8t_l1W`3+hh^Cmg3u~v3Mf-L~QS2
zmde?@o%33*n~JPzM^i&~MEZwLPfz3Ztb!hK?`x|1hqtrk&}(?;jCF_FGr{50CHyrk
zeo4zF8aL}*wD#4ouqynz=RC#jQ5LuyFOsnqFk*9o7sjO1<|CtQ1Zwc%3pUblq=j99
z*274j(Q_eu5p5~DN$5u-`UjTk1;$+{-k@dMUAVK3)ceHIQl(H{S*Vm2=BTr}G?_`P
z?=WnmuXSY|!*$J;D%<FQzHRCjXO>DQrYfZqGo)g${T?gYIQw?9c&yjn^z?{mcF_j*
z<k__2)%;Ox$Cc$Fuh3z?b7VG~O^veVGIwhW*sM`^!)W`C&4$;>=c!V<g#QY@C;2+I
zX~)VKxtn?!2CdFb`vazQw&h{Z#qn^M(K-&Ki0seiE)JP^)9x!6iS-79`$wHnUb8Y4
zisz_TH8Q8e3^qX92YRPvk8f5O_2u;0u2{_l&Yc1lfnavWGn<Zu6R7En4yfLW<)?=W
z(!?|?@|xLlC9|=}a8QaCy*>GXOhMN!Fv`Ib5N+f1UX9M&bfMt{^JWlW0i)~rJkDgY
zr*vjZ^CLUm0FimtRF!=jMhJ@yU|6-RMf%h&Xow3;V;>nTLH9CS^0)<!iZ?QG^+GAU
z6>1Zf9DUhDvMTxkQY^S^36G^0R!a-VSdL9**nXCtU}LN@Z^}kKKO<`C^!obg@w2!G
zmkM7pD3=bO6f&(!)6I#qnT#UT_FGjPSX|Ur9oZ1+==XlMzCOz0@2H^0SgIUdqLR!B
znc!_MLT*QEZ)mTsyF=`O{&CTC_j<Q&$6(=(M}xrj&ua0yui=MsENG{Lq1|+o-!QN|
zc^H@$XO0Zf-`;P3(lGXM&vt6YKF71%md)8AzZqm3M{uKN^BOw|K3B_&GYj*0P}nV$
zD)`N&@2!yYn45(&vD^tIZ>rzfMyjtM?D1s$+Vhb8TD|g&3N&o?sB%jf+p3&;H5%nW
zS=g#J9Z3ViCQp8)>2=t-mT*GbQ5$NOHkG<Cv7g%{N8xIRwH+Z_@O)q$GGw7NWh-PR
z{&}o~lA`XzV7w;xr0KG<sGB(MakBd!X)AdQn}ORQ|CV-2M(=uiIH(IVOAD|=9x69s
z&4ed_0-Oc#3&2es0@JgZ(`>eI#yC8LHd1(8*KZ$S>AA(@>;#OJ&VmEj9xOj_&~tRB
ziVlz;uT(0AQiby3DV+W(HOLBeCG=|&(F&$GWHxqt;Z$2Ras(v^Rj4x<T{EPS(~r4@
z6+{gl7Z~Ou)|O-GE={>E6HdJWb||Xh>jB<U58Y0eN@@eQxM*`*HNVU`Ye*S{`CRl4
z{FpzPUE|fP1tziO<uH<tQi&J|rv<!E7){)fo{(OJ$M}`bLbuA~_{71n$??hYh-9Mi
zsw$*w>UgOz!^)FcgW~@c#G(%&KBf3Se*XL}V*V?@_kat)Dc~e<7}y2;3-SLyfY*S(
z0)GL%1{8s5;1=M|i1D8XiohF)>AwR!0h|Ip54?jo{w3fNPy%iTUO^21E8qt}8#o7?
z1?~kdA#Q&V_ygkdr+@>%WyIf?fWM*tXMiVwIe^CVAdp-M0|^5O0|^5+k%0>g$MGh=
zXy6WcPMfnU8!7G~p~%NV_yhO|ob@qj))9D~FogrZgTkwPe%kllQC2e%(2uf>)C$}M
zcq36&hVpgtCUAg7T5#w(VTVB%9r(6WcgPW;Q_u8F*RR8O2`$r0UBDGZf=plC?pSMM
zmM6!o2Di>%UuWPKs9N2#nf@@1;g8nn%tampjs)dN;6~90`e)iU+!;757!i3DNI8V)
z+9(2`-qr0G_ro3Z2WbR2q~#hClH7#b1J|hyhk=+LqS`|=z)kxq#c<|E*#r^3&}vrE
zapm`@qKFuDs0rN@Lv&KoD9W=AOeMO6$wKUhVQi>$Y&X}sm72c%)K<!R88^~ODX{*G
zbT@G|q=g+QN4Ax;ssICo!V!%s!L)RacZgo{IsK6DV6t?{SZUL@dy`a-QrR0DDT-{c
z76$co>FmoCQD>3VU{qeMlXWRf3%}z(mJCPP8bUy(6XkizB+-n<890{KvkMoxKLZw9
z<&<0Z1r#(X@Yn#=ft*E}ykdsu4-Jp2kHo=wMjLj-U>I4sO0VnhDVYD5)%|PE)f7TS
zmGqK+oKYB-3BYR6k!cZ+A{K>j!Q+np7*r)?bbDFe3|s_pt5wrFpQiK|2u(d!SgtJL
z%Miu1KWtmKP+piVPM^5J+Q=GJZm{ZdVQS$<>n<Vjd4tU&VYm%dYNp!i!N;MpdPqVh
zawMiu<-B^kTJIaBkZSZyi2k}apSLW#x=7E6sJ5D>oXW@KC>vu}n`V%roCflx^k60&
zm{lZZbRjZoSw`H1NscCJergc|A0I{7SmOu@akxNdv;&hd4p&I#h-y7$bJLXqqNV9U
zT@`3l<Jh`)>O2aU%Cnmk7E5z5#^~;*-tAc95Ov%4u79pd#A7s75d+HZF)0lk3>;6j
zXjKuBbf89*>cn4Mpx!Hiflx;0s)fjq`WwDIsA*RDv~5#wH#3#opUtAd_UDw5V#16+
z#Ul$&tGV2qHxH#Bq%+uZ0$<2Hc<$yyqlw33guOZsTp%A}#t$hwe2olxq?M8y#o{t{
mJwKo)k`3R^!?VH0)nS&4Gex-xt|>W^)^r}B!p*#hng0Qi4P(y$


From 1c7a558df3442e42971b3c4b03dace6796a6b946 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 6 May 2025 11:44:43 +0200
Subject: [PATCH 0317/1764] Fix typos in rANS AlignedArrayIterator

---
 .../include/rANS/internal/containers/AlignedArray.h  | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Utilities/rANS/include/rANS/internal/containers/AlignedArray.h b/Utilities/rANS/include/rANS/internal/containers/AlignedArray.h
index df4b0190cdc4f..c1f96df939809 100644
--- a/Utilities/rANS/include/rANS/internal/containers/AlignedArray.h
+++ b/Utilities/rANS/include/rANS/internal/containers/AlignedArray.h
@@ -107,16 +107,16 @@ class AlignedArrayIterator
 
   inline constexpr difference_type operator-(const AlignedArrayIterator& other) const noexcept
   {
-    return this->mIter - other.mIter;
+    return this->mIndex - other.mIndex;
   };
 
   // comparison
   inline constexpr bool operator==(const AlignedArrayIterator& other) const noexcept { return this->mIndex == other.mIndex; };
   inline constexpr bool operator!=(const AlignedArrayIterator& other) const noexcept { return this->mIndex != other.mIndex; };
-  inline constexpr bool operator<(const AlignedArrayIterator& other) const noexcept { return this->mIndex < other->mIndex; };
-  inline constexpr bool operator>(const AlignedArrayIterator& other) const noexcept { return this->mIndex > other->mIndex; };
-  inline constexpr bool operator>=(const AlignedArrayIterator& other) const noexcept { return this->mIndex >= other->mIndex; };
-  inline constexpr bool operator<=(const AlignedArrayIterator& other) const noexcept { return this->mIndex <= other->mIndex; };
+  inline constexpr bool operator<(const AlignedArrayIterator& other) const noexcept { return this->mIndex < other.mIndex; };
+  inline constexpr bool operator>(const AlignedArrayIterator& other) const noexcept { return this->mIndex > other.mIndex; };
+  inline constexpr bool operator>=(const AlignedArrayIterator& other) const noexcept { return this->mIndex >= other.mIndex; };
+  inline constexpr bool operator<=(const AlignedArrayIterator& other) const noexcept { return this->mIndex <= other.mIndex; };
 
   // dereference
   inline constexpr value_type operator*() const noexcept { return (*mContainer)[mIndex]; };
@@ -311,4 +311,4 @@ auto make_span(o2::rans::internal::simd::AlignedArray<T, width_V, size_V>& array
 
 } // namespace gsl
 
-#endif /* RANS_INTERNAL_CONTAINERS_ALIGNEDARRAY_H_ */
\ No newline at end of file
+#endif /* RANS_INTERNAL_CONTAINERS_ALIGNEDARRAY_H_ */

From c4f4364b1c819dac3581db77f89c0968c661c7d3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 6 May 2025 17:25:36 +0200
Subject: [PATCH 0318/1764] DPL: improve DataSpecUtils::describe API in case of
 buffers (#14238)

Just like snprintf, it makes sense to return the size of the formatted
output.
---
 .../Core/include/Framework/DataSpecUtils.h    | 17 +++---
 Framework/Core/src/DataSpecUtils.cxx          | 58 ++++++++-----------
 .../Core/test/unittest_DataSpecUtils.cxx      | 55 ++++++++++++++++++
 3 files changed, 88 insertions(+), 42 deletions(-)

diff --git a/Framework/Core/include/Framework/DataSpecUtils.h b/Framework/Core/include/Framework/DataSpecUtils.h
index 65f8585302aa7..588aa30da7e08 100644
--- a/Framework/Core/include/Framework/DataSpecUtils.h
+++ b/Framework/Core/include/Framework/DataSpecUtils.h
@@ -18,11 +18,12 @@
 
 #include <optional>
 
-namespace o2
-{
-namespace framework
+namespace o2::framework
 {
 
+template <typename T>
+concept HasMatcher = requires(T& t) { t.matcher; };
+
 struct DataSpecUtils {
   /// @return true if a given InputSpec @a spec matches with a @a target ConcreteDataMatcher
   static bool match(InputSpec const& spec, ConcreteDataMatcher const& target);
@@ -152,10 +153,8 @@ struct DataSpecUtils {
   static bool validate(OutputSpec const& output);
 
   /// Same as the other describe, but uses a buffer to reduce memory churn.
-  static void describe(char* buffer, size_t size, InputSpec const& spec);
-
-  /// Same as the other describe, but uses a buffer to reduce memory churn.
-  static void describe(char* buffer, size_t size, OutputSpec const& spec);
+  template <HasMatcher T>
+  static size_t describe(char* buffer, size_t size, T const& spec);
 
   /// If possible extract the ConcreteDataMatcher from an InputSpec. This
   /// can be done either if the InputSpec is defined in terms for a ConcreteDataMatcher
@@ -250,6 +249,6 @@ struct DataSpecUtils {
   static void updateOutputList(std::vector<OutputSpec>& list, OutputSpec&& input);
 };
 
-} // namespace framework
-} // namespace o2
+} // namespace o2::framework
+
 #endif // FRAMEWORK_DATASPECUTILS_H
diff --git a/Framework/Core/src/DataSpecUtils.cxx b/Framework/Core/src/DataSpecUtils.cxx
index 3babbaba2a6ca..48f5e6abcad5b 100644
--- a/Framework/Core/src/DataSpecUtils.cxx
+++ b/Framework/Core/src/DataSpecUtils.cxx
@@ -15,11 +15,13 @@
 #include "Framework/RuntimeError.h"
 #include "Headers/DataHeaderHelpers.h"
 
+#include <fmt/base.h>
 #include <fmt/format.h>
 #include <sstream>
 #include <cstring>
 #include <cinttypes>
 #include <regex>
+#include <stdexcept>
 
 namespace o2::framework
 {
@@ -87,39 +89,29 @@ std::string DataSpecUtils::describe(OutputSpec const& spec)
                     spec.matcher);
 }
 
-void DataSpecUtils::describe(char* buffer, size_t size, InputSpec const& spec)
-{
-  if (auto concrete = std::get_if<ConcreteDataMatcher>(&spec.matcher)) {
-    char origin[5];
-    origin[4] = 0;
-    char description[17];
-    description[16] = 0;
-    snprintf(buffer, size, "%s/%s/%" PRIu32, (strncpy(origin, concrete->origin.str, 4), origin),
-             (strncpy(description, concrete->description.str, 16), description), concrete->subSpec);
-  } else if (auto matcher = std::get_if<DataDescriptorMatcher>(&spec.matcher)) {
-    std::ostringstream ss;
-    ss << "<matcher query: " << *matcher << ">";
-    strncpy(buffer, ss.str().c_str(), size - 1);
-  } else {
-    throw runtime_error("Unsupported InputSpec");
-  }
-}
-
-void DataSpecUtils::describe(char* buffer, size_t size, OutputSpec const& spec)
-{
-  if (auto concrete = std::get_if<ConcreteDataMatcher>(&spec.matcher)) {
-    char origin[5];
-    origin[4] = 0;
-    char description[17];
-    description[16] = 0;
-    snprintf(buffer, size, "%s/%s/%" PRIu32, (strncpy(origin, concrete->origin.str, 4), origin),
-             (strncpy(description, concrete->description.str, 16), description), concrete->subSpec);
-  } else if (auto concrete = std::get_if<ConcreteDataTypeMatcher>(&spec.matcher)) {
-    fmt::format_to(buffer, "<matcher query: {}/{}>", concrete->origin, concrete->description);
-  } else {
-    throw runtime_error("Unsupported OutputSpec");
-  }
-}
+template <HasMatcher T>
+size_t DataSpecUtils::describe(char* buffer, size_t size, T const& spec)
+{
+  auto result = std::visit(overloaded{
+                             [buffer, size](ConcreteDataMatcher const& concrete) -> fmt::format_to_n_result<char*> {
+                               return fmt::format_to_n(buffer, size - 1, "{:.4}/{:.16}/{}", concrete.origin.str, concrete.description.str, concrete.subSpec);
+                             },
+                             [buffer, size](ConcreteDataTypeMatcher const& concrete) -> fmt::format_to_n_result<char*> {
+                               return fmt::format_to_n(buffer, size - 1, "<matcher query: {}/{}>", concrete.origin, concrete.description);
+                             },
+                             [buffer, size](DataDescriptorMatcher const& matcher) -> fmt::format_to_n_result<char*> {
+                               std::ostringstream ss;
+                               ss << "<matcher query: " << matcher << ">";
+                               return fmt::format_to_n(buffer, size - 1, "{}", ss.str());
+                             },
+                             [](...) -> fmt::format_to_n_result<char*> { throw std::runtime_error("Unsupported Input / Output Spec"); }},
+                           spec.matcher);
+  *result.out = '\0';
+  return result.out - buffer;
+}
+
+template size_t DataSpecUtils::describe(char* buffer, size_t size, InputSpec const& spec);
+template size_t DataSpecUtils::describe(char* buffer, size_t size, OutputSpec const& spec);
 
 std::string DataSpecUtils::label(InputSpec const& spec)
 {
diff --git a/Framework/Core/test/unittest_DataSpecUtils.cxx b/Framework/Core/test/unittest_DataSpecUtils.cxx
index e6b2f4a22c018..6128183aefa11 100644
--- a/Framework/Core/test/unittest_DataSpecUtils.cxx
+++ b/Framework/Core/test/unittest_DataSpecUtils.cxx
@@ -42,6 +42,7 @@ TEST_CASE("ConcreteData")
     CHECK(std::string(concrete.description.as<std::string>()) == "FOOO");
     CHECK(concrete.subSpec == 1);
     CHECK(DataSpecUtils::describe(spec) == "TEST/FOOO/1");
+    CHECK(DataSpecUtils::describe(spec) == "TEST/FOOO/1");
     CHECK(*DataSpecUtils::getOptionalSubSpec(spec) == 1);
 
     ConcreteDataTypeMatcher dataType = DataSpecUtils::asConcreteDataTypeMatcher(spec);
@@ -59,6 +60,44 @@ TEST_CASE("ConcreteData")
   }
 }
 
+TEST_CASE("DescribeUsingBuffer")
+{
+  o2::framework::clean_all_runtime_errors();
+  OutputSpec spec{
+    "TEST",
+    "FOOO",
+    1,
+    Lifetime::Timeframe};
+
+  InputSpec inputSpec{
+    "binding",
+    "TEST",
+    "FOOO",
+    1,
+    Lifetime::Timeframe};
+
+  REQUIRE(DataSpecUtils::validate(inputSpec));
+
+  {
+    char buffer[1024];
+
+    ConcreteDataMatcher concrete = DataSpecUtils::asConcreteDataMatcher(spec);
+    CHECK(std::string(concrete.origin.as<std::string>()) == "TEST");
+    CHECK(std::string(concrete.description.as<std::string>()) == "FOOO");
+    CHECK(concrete.subSpec == 1);
+    auto size = DataSpecUtils::describe(buffer, 1024, spec);
+    CHECK(std::string_view(buffer, size) == "TEST/FOOO/1");
+    size = DataSpecUtils::describe(buffer, 1024, spec);
+    CHECK(std::string_view(buffer, size) == "TEST/FOOO/1");
+    CHECK(*DataSpecUtils::getOptionalSubSpec(spec) == 1);
+
+    char buffer2[1024];
+    size = DataSpecUtils::describe(buffer2, 5, spec);
+    // We always nullterminate the string
+    CHECK(std::string_view(buffer2, size) == "TEST");
+  }
+}
+
 TEST_CASE("WithWildCards")
 {
   OutputSpec spec{
@@ -78,6 +117,22 @@ TEST_CASE("WithWildCards")
   CHECK(DataSpecUtils::getOptionalSubSpec(spec) == std::nullopt);
 }
 
+TEST_CASE("WithWildCardsBuffer")
+{
+  char buffer[1024];
+  OutputSpec spec{
+    {"TEST", "FOOO"},
+    Lifetime::Timeframe};
+
+  auto size = DataSpecUtils::describe(buffer, 1024, spec);
+  CHECK(std::string_view(buffer, size) == "<matcher query: TEST/FOOO>");
+
+  char buffer2[1024];
+  size = DataSpecUtils::describe(buffer2, 5, spec);
+  // We always null terminate the buffer.
+  CHECK(std::string_view(buffer2, size) == "<mat");
+}
+
 TEST_CASE("MatchingInputs")
 {
   OutputSpec fullySpecified{

From 992316d342fb505c3d9a7728378b67d3da9ac9da Mon Sep 17 00:00:00 2001
From: Chunzheng Wang <83008337+ChunzhengLab@users.noreply.github.com>
Date: Tue, 6 May 2025 17:26:41 +0200
Subject: [PATCH 0319/1764] ITS3: ITS3 Digitisation Development after TDR
 (#14145)

* ITS3 digitization: parameters, segmentation and container fixes

- Add digitization parameter sets
- Fix C2F/F2C conversion in SegmentationMosaix
- Set scale function for Alpide as IB
- Fix chip digits container initialization
- Correct ordering of maxRows and maxCols
- Add support for floating row/column numbers in D2L

* Introduce ChipSimResponse with response-centre extraction logic

Add more info in CreateDic macro

* Add a macro to compare ITS3 clusters and digits on a pixel array

Add the script to check hits and clusters on a track

Add script for visualizing chip responses

* Address reviewer comments
---
 .../ITSMFTSimulation/AlpideSimResponse.h      |   5 +-
 .../include/ITS3Base/SegmentationMosaix.h     |  89 +--
 .../ITS3/base/include/ITS3Base/SpecsV2.h      |   1 -
 .../Upgrades/ITS3/macros/test/CMakeLists.txt  |   3 +
 .../ITS3/macros/test/CheckChipResponseFile.C  | 192 ++++++
 .../ITS3/macros/test/CheckDigitsITS3.C        |   2 -
 .../test/CompareClustersAndDigitsOnChip.C     | 579 ++++++++++++++++
 .../ITS3/macros/test/CorrTracksClusters.C     | 638 ++++++++++++++++++
 .../ITS3/macros/test/CreateDictionariesITS3.C |  22 +-
 .../Upgrades/ITS3/simulation/CMakeLists.txt   |   8 +-
 .../ITS3Simulation/ChipDigitsContainer.h      |  59 ++
 .../include/ITS3Simulation/ChipSimResponse.h  |  41 ++
 .../include/ITS3Simulation/DigiParams.h       |  28 +-
 .../include/ITS3Simulation/Digitizer.h        |   9 +-
 .../ITS3Simulation/ITS3DPLDigitizerParam.h    |  32 +
 .../simulation/src/ChipDigitsContainer.cxx    |  63 ++
 .../ITS3/simulation/src/ChipSimResponse.cxx   |  62 ++
 .../ITS3/simulation/src/DigiParams.cxx        |  62 +-
 .../ITS3/simulation/src/Digitizer.cxx         |  84 ++-
 .../simulation/src/ITS3DPLDigitizerParam.cxx  |  14 +
 .../simulation/src/ITS3SimulationLinkDef.h    |   3 +
 .../src/ITS3DigitizerSpec.cxx                 |   7 +
 22 files changed, 1886 insertions(+), 117 deletions(-)
 create mode 100644 Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
 create mode 100644 Detectors/Upgrades/ITS3/macros/test/CompareClustersAndDigitsOnChip.C
 create mode 100644 Detectors/Upgrades/ITS3/macros/test/CorrTracksClusters.C
 create mode 100644 Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h
 create mode 100644 Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipSimResponse.h
 create mode 100644 Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3DPLDigitizerParam.h
 create mode 100644 Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
 create mode 100644 Detectors/Upgrades/ITS3/simulation/src/ChipSimResponse.cxx
 create mode 100644 Detectors/Upgrades/ITS3/simulation/src/ITS3DPLDigitizerParam.cxx

diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
index 92656a16257a1..5714b51d5aa45 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
@@ -38,7 +38,7 @@ class AlpideRespSimMat
   static int constexpr getNPix() { return NPix; }
 
   AlpideRespSimMat() = default;
-  ~AlpideRespSimMat() = default;
+  virtual ~AlpideRespSimMat() = default;
 
   void adopt(const AlpideRespSimMat& src, bool flipRow = false, bool flipCol = false)
   {
@@ -69,7 +69,7 @@ class AlpideRespSimMat
  private:
   std::array<float, MatSize> data;
 
-  ClassDefNV(AlpideRespSimMat, 1);
+  ClassDef(AlpideRespSimMat, 1);
 };
 
 /*
@@ -91,6 +91,7 @@ class AlpideSimResponse
   int getDepthBin(float pos) const;
   std::string composeDataName(int colBin, int rowBin);
 
+ protected:
   int mNBinCol = 0;                                   /// number of bins in X(col direction)
   int mNBinRow = 0;                                   /// number of bins in Y(row direction)
   int mNBinDpt = 0;                                   /// number of bins in Z(sensor dept)
diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
index f8d4a784120a0..fbf9a59e6da4b 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
@@ -12,12 +12,11 @@
 /// \file SegmentationMosaix.h
 /// \brief Definition of the SegmentationMosaix class
 /// \author felix.schlepper@cern.ch
+/// \author chunzheng.wang@cern.ch
 
 #ifndef ALICEO2_ITS3_SEGMENTATIONMOSAIX_H_
 #define ALICEO2_ITS3_SEGMENTATIONMOSAIX_H_
 
-#include <type_traits>
-
 #include "MathUtils/Cartesian.h"
 #include "ITS3Base/SpecsV2.h"
 
@@ -43,24 +42,22 @@ class SegmentationMosaix
   // 3. The detector coordinate system. Defined by the row and column segmentation
   //    defined at the upper edge in the flat coord.
 
-  // row,col=0
-  // |
-  // v
-  // x----------------------x
-  // |           |          |
-  // |           |          |
-  // |           |          |                        ^ x
-  // |           |          |                        |
-  // |           |          |                        |
-  // |           |          |                        |
-  // |-----------X----------|  X marks (x,z)=(0,0)   X----> z
-  // |           |          |
+  // O----------------------|
   // |           |          |
+  // |           |          |  ^ x
+  // |           |          |  |
+  // |           |          |  |
+  // |           |          |  |
+  // |           |          |  X----> z   X marks (x,z)=(0,0)
+  // |-----------X----------|
+  // |           |          |  O----> col O marks (row,col)=(0,0)
+  // |           |          |  |
+  // |           |          |  |
+  // |           |          |  v
+  // |           |          |  row
   // |           |          |
-  // |           |          |
-  // |           |          |
-  // |           |          |
-  // x----------------------x
+  // |----------------------|
+
  public:
   constexpr SegmentationMosaix(int layer) : mRadius(static_cast<float>(constants::radiiMiddle[layer])) {}
   constexpr ~SegmentationMosaix() = default;
@@ -79,7 +76,6 @@ class SegmentationMosaix
   static constexpr float PitchCol{constants::pixelarray::pixels::mosaix::pitchZ};
   static constexpr float PitchRow{constants::pixelarray::pixels::mosaix::pitchX};
   static constexpr float SensorLayerThickness{constants::totalThickness};
-  static constexpr float NominalYShift{constants::nominalYShift};
 
   /// Transformation from the curved surface to a flat surface.
   /// Additionally a shift in the flat coordinates must be applied because
@@ -102,10 +98,10 @@ class SegmentationMosaix
     // stack
     float dist = std::hypot(xCurved, yCurved);
     float phi = std::atan2(yCurved, xCurved);
-    xFlat = (mRadius * phi) - WidthH;
     // the y position is in the silicon volume however we need the chip volume (silicon+metalstack)
     // this is accounted by a y shift
-    yFlat = dist - mRadius + NominalYShift;
+    xFlat = WidthH - mRadius * phi;
+    yFlat = dist - mRadius;
   }
 
   /// Transformation from the flat surface to a curved surface
@@ -122,11 +118,12 @@ class SegmentationMosaix
   {
     // MUST align the flat surface with the curved surface with the original pixel array is on and account for metal
     // stack
+    float dist = yFlat + mRadius;
+    float phi = (WidthH - xFlat) / mRadius;
     // the y position is in the chip volume however we need the silicon volume
     // this is accounted by a -y shift
-    float dist = yFlat - NominalYShift + mRadius;
-    xCurved = dist * std::cos((xFlat + WidthH) / mRadius);
-    yCurved = dist * std::sin((xFlat + WidthH) / mRadius);
+    xCurved = dist * std::cos(phi);
+    yCurved = dist * std::sin(phi);
   }
 
   /// Transformation from Geant detector centered local coordinates (cm) to
@@ -142,8 +139,11 @@ class SegmentationMosaix
   /// \param int iCol Detector z cell coordinate.
   constexpr bool localToDetector(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
   {
+    if (!isValidLoc(xRow, zCol)) {
+      return false;
+    }
     localToDetectorUnchecked(xRow, zCol, iRow, iCol);
-    if (!isValid(iRow, iCol)) {
+    if (!isValidDet(iRow, iCol)) {
       iRow = iCol = -1;
       return false;
     }
@@ -167,49 +167,54 @@ class SegmentationMosaix
   /// center of the sensitive volume.
   /// If iRow and or iCol is outside of the segmentation range a value of -0.5*Dx()
   /// or -0.5*Dz() is returned.
-  constexpr bool detectorToLocal(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
+  bool detectorToLocal(float const row, float const col, float& xRow, float& zCol) const noexcept
   {
-    if (!isValid(iRow, iCol)) {
+    if (!isValidDet(row, col)) {
       return false;
     }
-    detectorToLocalUnchecked(iRow, iCol, xRow, zCol);
-    return isValid(xRow, zCol);
+    detectorToLocalUnchecked(row, col, xRow, zCol);
+    return isValidLoc(xRow, zCol);
   }
 
   // Same as detectorToLocal w.o. checks.
   // We position ourself in the middle of the pixel.
-  constexpr void detectorToLocalUnchecked(int const iRow, int const iCol, float& xRow, float& zCol) const noexcept
+  void detectorToLocalUnchecked(float const row, float const col, float& xRow, float& zCol) const noexcept
   {
-    xRow = -(static_cast<float>(iRow) + 0.5f) * PitchRow + WidthH;
-    zCol = (static_cast<float>(iCol) + 0.5f) * PitchCol - LengthH;
+    xRow = -(row + 0.5f) * PitchRow + WidthH;
+    zCol = (col + 0.5f) * PitchCol - LengthH;
   }
 
-  bool detectorToLocal(int const row, int const col, math_utils::Point3D<float>& loc) const noexcept
+  bool detectorToLocal(float const row, float const col, math_utils::Point3D<float>& loc) const noexcept
   {
     float xRow{0.}, zCol{0.};
     if (!detectorToLocal(row, col, xRow, zCol)) {
       return false;
     }
-    loc.SetCoordinates(xRow, NominalYShift, zCol);
+    loc.SetCoordinates(xRow, 0.0f, zCol);
     return true;
   }
 
-  void detectorToLocalUnchecked(int const row, int const col, math_utils::Point3D<float>& loc) const noexcept
+  void detectorToLocalUnchecked(float const row, float const col, math_utils::Point3D<float>& loc) const noexcept
   {
     float xRow{0.}, zCol{0.};
     detectorToLocalUnchecked(row, col, xRow, zCol);
-    loc.SetCoordinates(xRow, NominalYShift, zCol);
+    loc.SetCoordinates(xRow, 0.0f, zCol);
   }
 
  private:
+  // Check local coordinates (cm) validity.
   template <typename T>
-  [[nodiscard]] constexpr bool isValid(T const row, T const col) const noexcept
+  constexpr bool isValidLoc(T const x, T const z) const noexcept
   {
-    if constexpr (std::is_floating_point_v<T>) { // compares in local coord.
-      return (-WidthH < row && row < WidthH && -LengthH < col && col < LengthH);
-    } else { // compares in rows/cols
-      return !static_cast<bool>(row < 0 || row >= static_cast<int>(NRows) || col < 0 || col >= static_cast<int>(NCols));
-    }
+    return (-WidthH < x && x < WidthH && -LengthH < z && z < LengthH);
+  }
+
+  // Check detector coordinates validity.
+  template <typename T>
+  constexpr bool isValidDet(T const row, T const col) const noexcept
+  {
+    return (row >= 0 && row < static_cast<T>(NRows) &&
+            col >= 0 && col < static_cast<T>(NCols));
   }
 
   float mRadius;
diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
index fedaad9182cce..83db7632e72f4 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
@@ -134,7 +134,6 @@ constexpr std::array<double, nLayers> radii{19.0006 * mm, 25.228 * mm, 31.4554 *
 constexpr std::array<double, nLayers> radiiInner{radii[0] - silicon::thicknessIn, radii[1] - silicon::thicknessIn, radii[2] - silicon::thicknessIn};                 // inner silicon radius
 constexpr std::array<double, nLayers> radiiOuter{radii[0] + silicon::thicknessOut, radii[1] + silicon::thicknessOut, radii[2] + silicon::thicknessOut};              // outer silicon radius
 constexpr std::array<double, nLayers> radiiMiddle{(radiiInner[0] + radiiOuter[0]) / 2., (radiiInner[1] + radiiOuter[1]) / 2., (radiiInner[2] + radiiOuter[2]) / 2.}; // middle silicon radius
-constexpr double nominalYShift{-metalstack::thickness / 2.};                                                                                                         // shift to position in silicion volume to the chip volume (silicon+metalstack)
 
 // extra information of pixels and their response functions
 namespace pixelarray::pixels
diff --git a/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt b/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
index 39e435f0ba2e6..cb6812445283c 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
@@ -22,7 +22,10 @@ its3_add_macro(CompareClusterSize.C)
 its3_add_macro(CheckMosaixSegment.C)
 its3_add_macro(CheckMosaixSegmentTrans.C)
 its3_add_macro(CompareClustersAndDigits.C)
+its3_add_macro(CompareClustersAndDigitsOnChip.C)
 its3_add_macro(CheckROFs.C)
 its3_add_macro(CheckTileNumbering.C)
 its3_add_macro(CreateITS3StaticDeadMap.C)
 its3_add_macro(TestSensorGeometry.C)
+its3_add_macro(CorrTracksClusters.C)
+its3_add_macro(CheckChipResponseFile.C)
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C b/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
new file mode 100644
index 0000000000000..996a99d87ecbc
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
@@ -0,0 +1,192 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CheckChipResponseFile.C
+/// \brief Simple macro to check the chip response files
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <TFile.h>
+#include <TGraph.h>
+#include <TCanvas.h>
+#include <TH1.h>
+#include <TLegend.h>
+#include <iostream>
+#include <vector>
+#include <string>
+
+#define ENABLE_UPGRADES
+#include "ITSMFTSimulation/AlpideSimResponse.h"
+
+#include "ITS3Base/SegmentationMosaix.h"
+#include "fairlogger/Logger.h"
+#endif
+
+using SegmentationMosaix = o2::its3::SegmentationMosaix;
+
+double um2cm(double um) { return um * 1e-4; }
+double cm2um(double cm) { return cm * 1e+4; }
+
+o2::itsmft::AlpideSimResponse *mAlpSimResp0 = nullptr,
+                              *mAlpSimResp1 = nullptr,
+                              *mAptSimResp1 = nullptr;
+
+o2::itsmft::AlpideSimResponse* loadResponse(const std::string& fileName, const std::string& respName)
+{
+  TFile* f = TFile::Open(fileName.data());
+  if (!f) {
+    std::cerr << fileName << " not found" << std::endl;
+    return nullptr;
+  }
+  auto resp = (o2::itsmft::AlpideSimResponse*)f->Get(respName.data());
+  if (!resp)
+    std::cerr << respName << " not found in " << fileName << std::endl;
+  return resp;
+}
+
+void LoadRespFunc()
+{
+  std::string AptsFile = "$(O2_ROOT)/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/APTSResponseData.root";
+  std::string AlpideFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
+
+  mAlpSimResp0 = loadResponse(AlpideFile, "response0"); // Vbb=0V
+  LOG(info) << "ALPIDE Vbb=0V response" << std::endl;
+  mAlpSimResp0->print();
+  mAlpSimResp1 = loadResponse(AlpideFile, "response1"); // Vbb=-3V
+  LOG(info) << "ALPIDE Vbb=-3V response" << std::endl;
+  mAlpSimResp1->print();
+  mAptSimResp1 = loadResponse(AptsFile, "response1"); // APTS
+  LOG(info) << "APTS response" << std::endl;
+  mAptSimResp1->print();
+}
+
+std::vector<float> getCollectionSeediciencies(o2::itsmft::AlpideSimResponse* resp,
+                                              const std::vector<float>& depths)
+{
+  std::vector<float> seed;
+  bool flipRow = false, flipCol = false;
+  for (auto depth : depths) {
+    auto rspmat = resp->getResponse(0.0, 0.0,
+                                    um2cm(depth) + resp->getDepthMin() + 1.e-9,
+                                    flipRow, flipCol);
+    seed.push_back(rspmat ? rspmat->getValue(2, 2) : 0.f);
+  }
+  return seed;
+}
+
+std::vector<float> getShareValues(o2::itsmft::AlpideSimResponse* resp,
+                                  const std::vector<float>& depths)
+{
+  std::vector<float> share;
+  bool flipRow = false, flipCol = false;
+  for (auto depth : depths) {
+    auto rspmat = resp->getResponse(0.0, 0.0,
+                                    um2cm(depth) + resp->getDepthMin() + 1.e-9,
+                                    flipRow, flipCol);
+    float s = 0;
+    int npix = resp->getNPix();
+    if (rspmat) {
+      for (int i = 0; i < npix; ++i)
+        for (int j = 0; j < npix; ++j)
+          if (!(i == npix / 2 && j == npix / 2))
+            s += rspmat->getValue(i, j);
+    }
+    share.push_back(s);
+  }
+  return share;
+}
+
+std::vector<float> getEffValues(o2::itsmft::AlpideSimResponse* resp,
+                                const std::vector<float>& depths)
+{
+  std::vector<float> all;
+  bool flipRow = false, flipCol = false;
+  for (auto depth : depths) {
+    auto rspmat = resp->getResponse(0.0, 0.0,
+                                    um2cm(depth) + resp->getDepthMin() + 1.e-9,
+                                    flipRow, flipCol);
+    float s = 0;
+    int npix = resp->getNPix();
+    if (rspmat) {
+      for (int i = 0; i < npix; ++i)
+        for (int j = 0; j < npix; ++j)
+          s += rspmat->getValue(i, j);
+    }
+    all.push_back(s);
+  }
+  return all;
+}
+
+void CheckChipResponseFile()
+{
+  LoadRespFunc();
+  LOG(info) << "Response function loaded" << std::endl;
+
+  std::vector<float> vecDepth(50);
+  for (int i = 0; i < 50; ++i)
+    vecDepth[i] = i;
+
+  int colors[] = {kOrange + 7, kRed + 1, kAzure + 4};
+  struct RespInfo {
+    o2::itsmft::AlpideSimResponse* resp;
+    std::string title;
+    int color;
+  };
+  std::vector<RespInfo> responses = {
+    {mAptSimResp1, "APTS", colors[0]},
+    {mAlpSimResp0, "ALPIDE Vbb=0V", colors[1]},
+    {mAlpSimResp1, "ALPIDE Vbb=-3V", colors[2]}};
+
+  TCanvas* c1 = new TCanvas("c1", "c1", 800, 600);
+  TH1* frame = c1->DrawFrame(-1, -0.049, 50, 1.049);
+  frame->SetTitle(";Depth(um);Charge Collection Seed / Share / Eff");
+  TLegend* leg = new TLegend(0.15, 0.5, 0.4, 0.85);
+  leg->SetFillStyle(0);
+  leg->SetBorderSize(0);
+
+  for (auto& r : responses) {
+    if (!r.resp)
+      continue;
+    auto seed = getCollectionSeediciencies(r.resp, vecDepth);
+    auto shr = getShareValues(r.resp, vecDepth);
+    auto all = getEffValues(r.resp, vecDepth);
+
+    TGraph* grSeed = new TGraph(vecDepth.size(), vecDepth.data(), seed.data());
+    grSeed->SetTitle(Form("%s seed", r.title.c_str()));
+    grSeed->SetLineColor(r.color);
+    grSeed->SetLineWidth(2);
+    grSeed->SetMarkerColor(r.color);
+    grSeed->SetMarkerStyle(kFullCircle);
+    grSeed->SetMarkerSize(0.8);
+    grSeed->Draw("SAME LP");
+    leg->AddEntry(grSeed, Form("%s seed", r.title.c_str()), "lp");
+
+    TGraph* grShare = new TGraph(vecDepth.size(), vecDepth.data(), shr.data());
+    grShare->SetLineColor(r.color);
+    grShare->SetLineWidth(2);
+    grShare->SetMarkerColor(r.color);
+    grShare->SetMarkerStyle(kOpenSquare);
+    grShare->SetMarkerSize(1);
+    grShare->Draw("SAME LP");
+    leg->AddEntry(grShare, Form("%s share", r.title.c_str()), "p");
+
+    TGraph* grEff = new TGraph(vecDepth.size(), vecDepth.data(), all.data());
+    grEff->SetLineColor(r.color);
+    grEff->SetLineWidth(2);
+    grEff->SetMarkerColor(r.color);
+    grEff->SetMarkerStyle(kFullDiamond);
+    grEff->SetMarkerSize(1);
+    grEff->Draw("SAME LP");
+    leg->AddEntry(grEff, Form("%s eff", r.title.c_str()), "p");
+  }
+  leg->Draw();
+
+  c1->SaveAs("ChipResponse.pdf");
+}
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C b/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
index 1dc4a4e2d6b47..240b1bd344af5 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
@@ -80,8 +80,6 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
 
   int nevD = digTree->GetEntries(); // digits in cont. readout may be grouped as few events per entry
 
-  int lastReadHitEv = -1;
-
   int nDigitReadIB{0}, nDigitReadOB{0};
   int nDigitFilledIB{0}, nDigitFilledOB{0};
 
diff --git a/Detectors/Upgrades/ITS3/macros/test/CompareClustersAndDigitsOnChip.C b/Detectors/Upgrades/ITS3/macros/test/CompareClustersAndDigitsOnChip.C
new file mode 100644
index 0000000000000..310be8c5858ef
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/macros/test/CompareClustersAndDigitsOnChip.C
@@ -0,0 +1,579 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CompareClustersAndDigitsOnChip.C
+/// \brief Macro to compare ITS3 clusters and digits on a pixel array,
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <TCanvas.h>
+#include <TFile.h>
+#include <TGraph.h>
+#include <TH2F.h>
+#include <TLegend.h>
+#include <TNtuple.h>
+#include <TROOT.h>
+#include <TString.h>
+#include <TArrow.h>
+#include <TStyle.h>
+#include <TTree.h>
+#include <filesystem>
+#include <fstream>
+#include <regex>
+#include <set>
+#include <map>
+#endif
+
+#define ENABLE_UPGRADES
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "DetectorsCommonDataFormats/DetectorNameConf.h"
+#include "ITS3Base/SegmentationMosaix.h"
+#include "ITS3Base/SpecsV2.h"
+#include "ITS3Reconstruction/TopologyDictionary.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/ClusterTopology.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "ITSMFTBase/SegmentationAlpide.h"
+#include "ITSMFTSimulation/Hit.h"
+#include "MathUtils/Cartesian.h"
+#include "MathUtils/Utils.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/IOMCTruthContainerView.h"
+
+struct Data {
+  TH2F* pixelArray;
+  TGraph* hitS;
+  TGraph* hitM;
+  TGraph* hitE;
+  TGraph* clusS;
+  TGraph* cog;
+  TLegend* leg;
+  std::vector<TBox*>* vClusBox;
+  void clear()
+  {
+    delete pixelArray;
+    delete hitS;
+    delete hitM;
+    delete hitE;
+    delete clusS;
+    delete cog;
+    delete leg;
+    for (auto& b : *vClusBox) {
+      delete b;
+    }
+    delete vClusBox;
+  }
+};
+
+void CompareClustersAndDigitsOnChip(std::string clusfile = "o2clus_its.root",
+                                    std::string digifile = "it3digits.root",
+                                    std::string dictfile = "",
+                                    std::string hitfile = "o2sim_HitsIT3.root",
+                                    std::string inputGeom = "o2sim_geometry.root",
+                                    bool batch = true)
+{
+  TH1::AddDirectory(kFALSE);
+  gROOT->SetBatch(batch);
+  gStyle->SetPalette(kRainBow);
+  gStyle->SetOptStat(0);
+
+  using namespace o2::base;
+  using namespace o2::its;
+  using o2::itsmft::Hit;
+  using Segmentation = o2::itsmft::SegmentationAlpide;
+  using o2::itsmft::ClusterTopology;
+  using o2::itsmft::CompClusterExt;
+  using ROFRec = o2::itsmft::ROFRecord;
+  using MC2ROF = o2::itsmft::MC2ROFRecord;
+  using HitVec = std::vector<Hit>;
+  using MC2HITS_map = std::unordered_map<uint64_t, int>; // maps (track_ID<<16 + chip_ID) to entry in the hit vector
+  std::vector<HitVec*> hitVecPool;
+  std::vector<MC2HITS_map> mc2hitVec;
+
+  std::array<o2::its3::SegmentationMosaix, 3> mMosaixSegmentations{0, 1, 2};
+
+  // Geometry
+  o2::base::GeometryManager::loadGeometry(inputGeom);
+  auto gman = o2::its::GeometryTGeo::Instance();
+  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L,
+                                                 o2::math_utils::TransformType::T2GRot,
+                                                 o2::math_utils::TransformType::L2G)); // request cached transforms
+  const int nChips = gman->getNumberOfChips();
+
+  LOGP(info, "Total number of chips is {} in ITS3 (IB and OB)", nChips);
+
+  // Create all plots
+  LOGP(info, "Selecting chips to be visualised");
+  std::set<int> selectedChips;
+  std::map<std::string, std::vector<int>> chipGroups;
+
+  for (int chipID{0}; chipID < nChips; ++chipID) {
+    TString tpath = gman->getMatrixPath(chipID);
+    std::string path = tpath.Data();
+
+    std::vector<std::string> tokens;
+    std::istringstream iss(path);
+    std::string token;
+    while (std::getline(iss, token, '/')) {
+      if (!token.empty()) {
+        tokens.push_back(token);
+      }
+    }
+
+    std::string segmentName, staveName, carbonFormName;
+    for (const auto& t : tokens) {
+      if (t.find("ITS3Segment") != std::string::npos)
+        segmentName = t;
+      if (t.find("ITSUStave") != std::string::npos)
+        staveName = t;
+      if (t.find("ITS3CarbonForm") != std::string::npos)
+        carbonFormName = t;
+    }
+
+    std::string groupKey;
+    if (!segmentName.empty()) {
+      groupKey = segmentName + "_" + carbonFormName;
+    } else if (!staveName.empty()) {
+      groupKey = staveName;
+    } else {
+      continue;
+    }
+
+    chipGroups[groupKey].push_back(chipID);
+  }
+
+  LOGP(info, "From each IB Segment or OB Stave, 10 chipIDs are uniformly selected");
+  LOGP(info, "Selected chipID: ");
+  for (auto& [groupName, ids] : chipGroups) {
+    std::vector<int> sampled;
+    if (ids.size() <= 10) {
+      for (auto id : ids) {
+        selectedChips.insert(id);
+        sampled.push_back(id);
+      }
+    } else {
+      for (int i{0}; i < 10; ++i) {
+        int idx = i * (ids.size() - 1) / 9; // 9 intervals for 10 points
+        int id = ids[idx];
+        if (selectedChips.insert(id).second) {
+          sampled.push_back(id);
+        }
+      }
+    }
+
+    std::ostringstream oss;
+    std::string topOrBot = "N/A";
+    std::smatch match;
+    std::regex rgxSegment(R"(Segment(\d+)_(\d+)_ITS3CarbonForm\d+_(\d+))");
+    std::regex rgxStave(R"(Stave(\d+)_(\d+))");
+    if (std::regex_search(groupName, match, rgxSegment)) {
+      int layer = std::stoi(match[1]);
+      int segment = std::stoi(match[2]);
+      int carbonForm = std::stoi(match[3]);
+      topOrBot = (carbonForm == 0 ? "TOP" : "BOT");
+      oss << topOrBot << " segment " << segment << " at layer " << layer << ": ";
+    } else if (std::regex_search(groupName, match, rgxStave)) {
+      int layer = std::stoi(match[1]);
+      int stave = std::stoi(match[2]);
+      oss << "Stave " << stave << " at layer " << layer << ": ";
+    } else {
+      LOGP(error, "Cannot select the correct chipID in OB or IB");
+      return;
+    }
+    for (auto id : sampled) {
+      oss << id << " ";
+    }
+    LOG(info) << oss.str();
+  }
+  LOGP(info, "{} selected chips will be visualized and analyzed.", chipGroups.size());
+
+  // Hits
+  TFile fileH(hitfile.data());
+  auto* hitTree = dynamic_cast<TTree*>(fileH.Get("o2sim"));
+  std::vector<o2::itsmft::Hit>* hitArray = nullptr;
+  hitTree->SetBranchAddress("IT3Hit", &hitArray);
+  mc2hitVec.resize(hitTree->GetEntries());
+  hitVecPool.resize(hitTree->GetEntries(), nullptr);
+
+  // Digits
+  TFile* digFile = TFile::Open(digifile.data());
+  TTree* digTree = (TTree*)digFile->Get("o2sim");
+  std::vector<o2::itsmft::Digit>* digArr = nullptr;
+  digTree->SetBranchAddress("IT3Digit", &digArr);
+  o2::dataformats::IOMCTruthContainerView* plabels = nullptr;
+  digTree->SetBranchAddress("IT3DigitMCTruth", &plabels);
+
+  // Clusters
+  TFile fileC(clusfile.data());
+  auto* clusTree = dynamic_cast<TTree*>(fileC.Get("o2sim"));
+  std::vector<CompClusterExt>* clusArr = nullptr;
+  clusTree->SetBranchAddress("ITSClusterComp", &clusArr);
+  std::vector<unsigned char>* patternsPtr = nullptr;
+  auto pattBranch = clusTree->GetBranch("ITSClusterPatt");
+  if (pattBranch != nullptr) {
+    pattBranch->SetAddress(&patternsPtr);
+  }
+
+  // Topology dictionary
+  o2::its3::TopologyDictionary dict;
+  bool hasAvailableDict = false;
+  if (!dictfile.empty()) {
+    std::ifstream file(dictfile.c_str());
+    if (file.good()) {
+      LOGP(info, "Running with external topology dictionary: {}", dictfile);
+      dict.readFromFile(dictfile);
+      LOGP(info, "The IB dictionary size is {}, and the OB dictionary size is {}", dict.getSize(true), dict.getSize(false));
+      hasAvailableDict = dict.getSize(true) != 0 && dict.getSize(false) != 0;
+      if (hasAvailableDict) {
+        LOGP(info, "Dictionaries is vaild.");
+      } else {
+        LOGP(info, "Dictionaries is NOT vaild!");
+      }
+    } else {
+      LOGP(info, "Cannot open dictionary file: {}. Running without external dictionary!", dictfile);
+      dictfile = "";
+    }
+  } else {
+    LOGP(info, "Running without external topology dictionary!");
+  }
+
+  // ROFrecords
+  std::vector<ROFRec> rofRecVec, *rofRecVecP = &rofRecVec;
+  clusTree->SetBranchAddress("ITSClustersROF", &rofRecVecP);
+
+  // Cluster MC labels
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel>* clusLabArr = nullptr;
+  std::vector<MC2ROF> mc2rofVec, *mc2rofVecP = &mc2rofVec;
+  if ((hitTree != nullptr) && (clusTree->GetBranch("ITSClusterMCTruth") != nullptr)) {
+    clusTree->SetBranchAddress("ITSClusterMCTruth", &clusLabArr);
+    clusTree->SetBranchAddress("ITSClustersMC2ROF", &mc2rofVecP);
+  }
+
+  clusTree->GetEntry(0);
+  unsigned int nROFRec = (int)rofRecVec.size();
+  std::vector<int> mcEvMin(nROFRec, hitTree->GetEntries());
+  std::vector<int> mcEvMax(nROFRec, -1);
+
+  // Build min and max MC events used by each ROF
+  for (int imc = mc2rofVec.size(); imc--;) {
+    const auto& mc2rof = mc2rofVec[imc];
+    if (mc2rof.rofRecordID < 0) {
+      continue; // this MC event did not contribute to any ROF
+    }
+    for (unsigned int irfd = mc2rof.maxROF - mc2rof.minROF + 1; irfd--;) {
+      unsigned int irof = mc2rof.rofRecordID + irfd;
+      if (irof >= nROFRec) {
+        LOGP(error, "ROF = {} from MC2ROF record is >= N ROFs = {}", irof, nROFRec);
+      }
+      if (mcEvMin[irof] > imc) {
+        mcEvMin[irof] = imc;
+      }
+      if (mcEvMax[irof] < imc) {
+        mcEvMax[irof] = imc;
+      }
+    }
+  }
+
+  // Create all plots
+  LOGP(info, "Creating plots");
+  std::unordered_map<int, Data> data;
+  auto initData = [&](int chipID, Data& dat) {
+    if (dat.pixelArray)
+      return;
+
+    int nCol{0}, nRow{0};
+    float lengthPixArr{0}, widthPixArr{0};
+    bool isIB = o2::its3::constants::detID::isDetITS3(chipID);
+    int layer = gman->getLayer(chipID);
+    if (isIB) {
+      nCol = o2::its3::SegmentationMosaix::NCols;
+      nRow = o2::its3::SegmentationMosaix::NRows;
+      lengthPixArr = o2::its3::constants::pixelarray::pixels::mosaix::pitchZ * nCol;
+      widthPixArr = o2::its3::constants::pixelarray::pixels::mosaix::pitchX * nRow;
+    } else {
+      nCol = o2::itsmft::SegmentationAlpide::NCols;
+      nRow = o2::itsmft::SegmentationAlpide::NRows;
+      lengthPixArr = o2::itsmft::SegmentationAlpide::PitchCol * nCol;
+      widthPixArr = o2::itsmft::SegmentationAlpide::PitchRow * nRow;
+    }
+
+    dat.pixelArray = new TH2F(Form("histSensor_%d", chipID), Form("SensorID=%d;z(cm);x(cm)", chipID),
+                              nCol, -0.5 * lengthPixArr, 0.5 * lengthPixArr,
+                              nRow, -0.5 * widthPixArr, 0.5 * widthPixArr);
+    dat.hitS = new TGraph();
+    dat.hitS->SetMarkerStyle(kFullTriangleDown);
+    dat.hitS->SetMarkerColor(kGreen);
+    dat.hitM = new TGraph();
+    dat.hitM->SetMarkerStyle(kFullCircle);
+    dat.hitM->SetMarkerColor(kGreen + 3);
+    dat.hitE = new TGraph();
+    dat.hitE->SetMarkerStyle(kFullTriangleUp);
+    dat.hitE->SetMarkerColor(kGreen + 5);
+    dat.clusS = new TGraph();
+    dat.clusS->SetMarkerStyle(kFullSquare);
+    dat.clusS->SetMarkerColor(kBlue);
+    dat.cog = new TGraph();
+    dat.cog->SetMarkerStyle(kFullDiamond);
+    dat.cog->SetMarkerColor(kRed);
+    dat.leg = new TLegend(0.7, 0.7, 0.92, 0.92);
+    dat.leg->AddEntry(dat.hitS, "Hit Start");
+    dat.leg->AddEntry(dat.hitM, "Hit Middle");
+    dat.leg->AddEntry(dat.hitE, "Hit End");
+    dat.leg->AddEntry(dat.clusS, "Cluster Start");
+    dat.leg->AddEntry(dat.cog, "Cluster COG");
+    dat.vClusBox = new std::vector<TBox*>;
+  };
+
+  LOGP(info, "Filling digits");
+  for (int iDigit{0}; digTree->LoadTree(iDigit) >= 0; ++iDigit) {
+    digTree->GetEntry(iDigit);
+    for (const auto& digit : *digArr) {
+      const auto chipID = digit.getChipIndex();
+      if (!selectedChips.count(chipID))
+        continue;
+      const auto layer = gman->getLayer(chipID);
+      bool isIB = layer < 3;
+      float locDigiX{0}, locDigiZ{0};
+      if (isIB) {
+        mMosaixSegmentations[layer].detectorToLocal(digit.getRow(), digit.getColumn(), locDigiX, locDigiZ);
+      } else {
+        o2::itsmft::SegmentationAlpide::detectorToLocal(digit.getRow(), digit.getColumn(), locDigiX, locDigiZ);
+      }
+      auto& dat = data[chipID];
+      initData(chipID, dat);
+      data[chipID].pixelArray->Fill(locDigiZ, locDigiX);
+    }
+  }
+
+  LOGP(info, "Building min and max MC events used by each ROF, total ROFs {}", nROFRec);
+  auto pattIt = patternsPtr->cbegin();
+  bool isAllPattIDInvaild{true};
+  for (unsigned int irof{0}; irof < nROFRec; irof++) {
+    const auto& rofRec = rofRecVec[irof];
+    // >> read and map MC events contributing to this ROF
+    for (int im = mcEvMin[irof]; im <= mcEvMax[irof]; im++) {
+      if (hitVecPool[im] == nullptr) {
+        hitTree->SetBranchAddress("IT3Hit", &hitVecPool[im]);
+        hitTree->GetEntry(im);
+        auto& mc2hit = mc2hitVec[im];
+        const auto* hitArray = hitVecPool[im];
+        for (int ih = hitArray->size(); ih--;) {
+          const auto& hit = (*hitArray)[ih];
+          uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
+          mc2hit.emplace(key, ih);
+        }
+      }
+    }
+
+    // Clusters in this ROF
+    for (int icl{0}; icl < rofRec.getNEntries(); icl++) {
+      int clEntry = rofRec.getFirstEntry() + icl; // entry of icl-th cluster of this ROF in the vector of clusters
+      const auto& cluster = (*clusArr)[clEntry];
+      const auto chipID = cluster.getSensorID();
+      if (!selectedChips.count(chipID)) {
+        // Even if not selected, advance pattIt if patternID is InvalidPatternID
+        if (cluster.getPatternID() == o2::itsmft::CompCluster::InvalidPatternID) {
+          o2::itsmft::ClusterPattern::skipPattern(pattIt);
+        }
+        continue;
+      }
+      const auto pattID = cluster.getPatternID();
+      const bool isIB = o2::its3::constants::detID::isDetITS3(chipID);
+      const auto layer = gman->getLayer(chipID);
+      auto& dat = data[chipID];
+      initData(chipID, dat);
+      o2::itsmft::ClusterPattern pattern;
+      // Pattern extraction
+      if (cluster.getPatternID() != o2::itsmft::CompCluster::InvalidPatternID) {
+        isAllPattIDInvaild = false;
+        if (!hasAvailableDict) {
+          LOGP(error, "Encountered pattern ID {}, which is not equal to the invalid pattern ID {}", cluster.getPatternID(), o2::itsmft::CompCluster::InvalidPatternID);
+          LOGP(error, "Clusters have already been generated with a dictionary which was not provided properly!");
+          return;
+        }
+        if (dict.isGroup(cluster.getPatternID(), isIB)) {
+          pattern.acquirePattern(pattIt);
+        } else {
+          pattern = dict.getPattern(cluster.getPatternID(), isIB);
+        }
+      } else {
+        pattern.acquirePattern(pattIt);
+      }
+
+      // Hits
+      const auto& lab = (clusLabArr->getLabels(clEntry))[0];
+      if (!lab.isValid())
+        continue;
+      const int trID = lab.getTrackID();
+      const auto& mc2hit = mc2hitVec[lab.getEventID()];
+      const auto* hitArray = hitVecPool[lab.getEventID()];
+      uint64_t key = (uint64_t(trID) << 32) + chipID;
+      auto hitEntry = mc2hit.find(key);
+      if (hitEntry == mc2hit.end())
+        continue;
+      o2::math_utils::Point3D<float> locHMiddle;
+      const auto& hit = (*hitArray)[hitEntry->second];
+      auto locHEnd = gman->getMatrixL2G(chipID) ^ (hit.GetPos());
+      auto locHStart = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
+      if (isIB) {
+        float xFlat{0.}, yFlat{0.};
+        mMosaixSegmentations[layer].curvedToFlat(locHEnd.X(), locHEnd.Y(), xFlat, yFlat);
+        locHEnd.SetXYZ(xFlat, yFlat, locHEnd.Z());
+        mMosaixSegmentations[layer].curvedToFlat(locHStart.X(), locHStart.Y(), xFlat, yFlat);
+        locHStart.SetXYZ(xFlat, yFlat, locHStart.Z());
+      }
+      locHMiddle.SetXYZ(0.5f * (locHEnd.X() + locHStart.X()),
+                        0.5f * (locHEnd.Y() + locHStart.Y()),
+                        0.5f * (locHEnd.Z() + locHStart.Z()));
+      data[chipID].hitS->AddPoint(locHStart.Z(), locHStart.X());
+      data[chipID].hitM->AddPoint(locHMiddle.Z(), locHMiddle.X());
+      data[chipID].hitE->AddPoint(locHEnd.Z(), locHEnd.X());
+
+      // Cluster Start point
+      float locCluX{0}, locCluZ{0};
+      if (isIB) {
+        mMosaixSegmentations[layer].detectorToLocal(cluster.getRow(), cluster.getCol(), locCluX, locCluZ);
+      } else {
+        o2::itsmft::SegmentationAlpide::detectorToLocal(cluster.getRow(), cluster.getCol(), locCluX, locCluZ);
+      }
+      data[chipID].clusS->AddPoint(locCluZ, locCluX);
+
+      // COG
+      o2::math_utils::Point3D<float> locCOG;
+      // Cluster COG using dictionary (if available)
+      if (hasAvailableDict && (pattID != o2::itsmft::CompCluster::InvalidPatternID && !dict.isGroup(pattID, isIB))) {
+        locCOG = dict.getClusterCoordinates(cluster);
+      } else {
+        if (isIB) {
+          locCOG = o2::its3::TopologyDictionary::getClusterCoordinates(cluster, pattern, false);
+        } else {
+          locCOG = o2::itsmft::TopologyDictionary::getClusterCoordinates(cluster, pattern, false);
+        }
+      }
+      if (isIB) {
+        float flatX{0}, flatY{0};
+        mMosaixSegmentations[layer].curvedToFlat(locCOG.X(), locCOG.Y(), flatX, flatY);
+        locCOG.SetCoordinates(flatX, flatY, locCOG.Z());
+      }
+      data[chipID].cog->AddPoint(locCOG.Z(), locCOG.X());
+
+      // Cluster Box using dictionary if available, otherwise use raw pattern
+      float lowLeftX{0}, lowLeftZ{0}, topRightX{0}, topRightZ{0};
+      // Use dictionary-based cluster box
+      if (isIB) {
+        mMosaixSegmentations[layer].detectorToLocal(cluster.getRow(), cluster.getCol(), lowLeftX, lowLeftZ);
+        mMosaixSegmentations[layer].detectorToLocal(cluster.getRow() + pattern.getRowSpan() - 1,
+                                                    cluster.getCol() + pattern.getColumnSpan() - 1,
+                                                    topRightX, topRightZ);
+        lowLeftX += 0.5 * o2::its3::constants::pixelarray::pixels::mosaix::pitchX;
+        lowLeftZ -= 0.5 * o2::its3::constants::pixelarray::pixels::mosaix::pitchZ;
+        topRightX -= 0.5 * o2::its3::constants::pixelarray::pixels::mosaix::pitchX;
+        topRightZ += 0.5 * o2::its3::constants::pixelarray::pixels::mosaix::pitchZ;
+      } else {
+        o2::itsmft::SegmentationAlpide::detectorToLocal(cluster.getRow(), cluster.getCol(), lowLeftX, lowLeftZ);
+        o2::itsmft::SegmentationAlpide::detectorToLocal(cluster.getRow() + pattern.getRowSpan() - 1,
+                                                        cluster.getCol() + pattern.getColumnSpan() - 1,
+                                                        topRightX, topRightZ);
+        lowLeftX += 0.5 * o2::itsmft::SegmentationAlpide::PitchRow;
+        lowLeftZ -= 0.5 * o2::itsmft::SegmentationAlpide::PitchCol;
+        topRightX -= 0.5 * o2::itsmft::SegmentationAlpide::PitchRow;
+        topRightZ += 0.5 * o2::itsmft::SegmentationAlpide::PitchCol;
+      }
+      auto clusBox = new TBox(lowLeftZ, lowLeftX, topRightZ, topRightX);
+      clusBox->SetFillColorAlpha(0, 0);
+      clusBox->SetFillStyle(0);
+      clusBox->SetLineWidth(4);
+      clusBox->SetLineColor(kBlack);
+      data[chipID].vClusBox->push_back(clusBox);
+    }
+  }
+
+  if (isAllPattIDInvaild) {
+    LOGP(info, "Verified input cluster file was generated w/o topology dictionary");
+    if (!dictfile.empty()) {
+      LOGP(error, "Non-dictionary cluster file processed by external dictionary! Please adjust input.");
+      return;
+    }
+  }
+
+  LOGP(info, "Writing to root file");
+  double x1, y1, x2, y2;
+  auto oFileOut = TFile::Open("CompareClustersAndDigitsOnChip.root", "RECREATE");
+  oFileOut->cd();
+  for (int chipID{0}; chipID < nChips; chipID++) {
+    if (!selectedChips.count(chipID))
+      continue;
+    auto& dat = data[chipID];
+    TString tpath = gman->getMatrixPath(chipID);
+    const std::string cpath{tpath.Data() + 39, tpath.Data() + tpath.Length()};
+    const std::filesystem::path p{cpath};
+    std::string nestedDir = p.parent_path().string();
+    TDirectory* currentDir = oFileOut;
+    std::istringstream iss(nestedDir);
+    std::string token;
+    while (std::getline(iss, token, '/')) {
+      if (token.empty())
+        continue;
+      TDirectory* nextDir = currentDir->GetDirectory(token.c_str());
+      if (!nextDir) {
+        nextDir = currentDir->mkdir(token.c_str());
+      }
+      if (!nextDir) {
+        LOGP(error, "Cannot create subdirectory: %s", token.c_str());
+        break;
+      }
+      currentDir = nextDir;
+      currentDir->cd();
+    }
+    if (!currentDir) {
+      LOGP(error, "Failed to create nested directory for chip %d", chipID);
+      continue;
+    }
+
+    auto canv = new TCanvas(Form("%s_%d", p.filename().c_str(), chipID));
+    canv->SetTitle(Form("%s_%d", p.filename().c_str(), chipID));
+    canv->cd();
+    gPad->SetGrid(1, 1);
+    dat.pixelArray->Draw("colz");
+    dat.hitS->Draw("p;same");
+    dat.hitM->Draw("p;same");
+    dat.hitE->Draw("p;same");
+    auto arr = new TArrow();
+    arr->SetArrowSize(0.01);
+    for (int i{0}; i < dat.hitS->GetN(); ++i) {
+      dat.hitS->GetPoint(i, x1, y1);
+      dat.hitE->GetPoint(i, x2, y2);
+      arr->DrawArrow(x1, y1, x2, y2);
+    }
+    dat.clusS->Draw("p;same");
+    if (dat.cog->GetN() != 0)
+      dat.cog->Draw("p;same");
+    for (const auto& clusBox : *dat.vClusBox) {
+      clusBox->Draw();
+    }
+    dat.leg->Draw();
+    canv->SetEditable(false);
+
+    currentDir->WriteTObject(canv, canv->GetName());
+    dat.clear();
+    delete canv;
+    delete arr;
+    printf("\rWriting chip %05d", chipID);
+  }
+  printf("\n");
+  oFileOut->Write();
+  oFileOut->Close();
+  LOGP(info, "Finished writing selected chip visualizations.");
+}
\ No newline at end of file
diff --git a/Detectors/Upgrades/ITS3/macros/test/CorrTracksClusters.C b/Detectors/Upgrades/ITS3/macros/test/CorrTracksClusters.C
new file mode 100644
index 0000000000000..634d761366920
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/macros/test/CorrTracksClusters.C
@@ -0,0 +1,638 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <TROOT.h>
+#include "TEfficiency.h"
+#include <TFile.h>
+#include <TH2F.h>
+#include <TTree.h>
+
+#include "ITSMFTSimulation/Hit.h"
+#include "DataFormatsITS/TrackITS.h"
+#include "DetectorsBase/Propagator.h"
+#include "Field/MagneticField.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCEventHeader.h"
+#include "SimulationDataFormat/MCTrack.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "SimulationDataFormat/TrackReference.h"
+#include "ITS3Reconstruction/TopologyDictionary.h"
+#include "ITSMFTBase/SegmentationAlpide.h"
+#include "ITS3Base/SegmentationMosaix.h"
+
+#include <array>
+#include <cmath>
+#include <iostream>
+#include <vector>
+#endif
+
+using namespace std;
+using namespace o2::itsmft;
+using namespace o2::its;
+using SegmentationIB = o2::its3::SegmentationMosaix;
+using SegmentationOB = o2::itsmft::SegmentationAlpide;
+static constexpr int kNLayer = 7;
+static constexpr int INVALID_INT = -99;
+static constexpr float INVALID_FLOAT = -99.f;
+
+//______________________________________________________________________________
+// ParticleInfo structure
+struct ParticleInfo {
+  int event{};
+  int pdg{};
+  float pt{};
+  float recpt{};
+  float eta{};
+  float phi{};
+  float pvx{};
+  float pvy{};
+  float pvz{};
+  float dcaxy{};
+  float dcaz{};
+  int mother{};
+  int first{};
+  unsigned short clusters = 0u;
+  unsigned char isReco = 0u;
+  unsigned char isFake = 0u;
+  bool isPrimary = false;
+  unsigned char storedStatus = 2; /// not stored = 2, fake = 1, good = 0
+  std::array<int, kNLayer> clusterSize;
+  std::array<int, kNLayer> clusterPattern;
+  std::array<float, kNLayer> clusterLocX;
+  std::array<float, kNLayer> clusterLocZ;
+  std::array<float, kNLayer> hitLocX;
+  std::array<float, kNLayer> hitLocY;
+  std::array<float, kNLayer> hitLocZ;
+  o2::its::TrackITS track;
+  ParticleInfo()
+  {
+    clusterSize.fill(INVALID_INT);
+    clusterPattern.fill(INVALID_INT);
+    clusterLocX.fill(INVALID_FLOAT);
+    clusterLocZ.fill(INVALID_FLOAT);
+    hitLocX.fill(INVALID_FLOAT);
+    hitLocY.fill(INVALID_FLOAT);
+    hitLocZ.fill(INVALID_FLOAT);
+  }
+};
+
+//______________________________________________________________________________
+// Convert curved local coordinates to flat coordinates
+void CurvedLocalToFlat(o2::math_utils::Point3D<float>& point, const SegmentationIB& seg)
+{
+  float xFlat = 0.f, yFlat = 0.f;
+  seg.curvedToFlat(point.X(), point.Y(), xFlat, yFlat);
+  point.SetXYZ(xFlat, yFlat, point.Z());
+}
+
+//______________________________________________________________________________
+// Resolve pattern from patternID and iterator
+bool resolvePattern(const o2::itsmft::CompClusterExt& cluster,
+                    decltype(std::declval<std::vector<unsigned char>>().cbegin())& pattIt,
+                    const o2::its3::TopologyDictionary& dict,
+                    bool isIB,
+                    o2::itsmft::ClusterPattern& pattOut)
+{
+  auto pattID = cluster.getPatternID();
+  if (pattID != o2::itsmft::CompCluster::InvalidPatternID) {
+    if (!dict.getSize(true) && !dict.getSize(false)) {
+      LOGP(error, "Encountered non-invalid pattern ID {} but dictionary is missing!", pattID);
+      return false;
+    }
+    if (dict.isGroup(pattID, isIB)) {
+      pattOut.acquirePattern(pattIt);
+    } else {
+      pattOut = dict.getPattern(pattID, isIB);
+    }
+  } else {
+    pattOut.acquirePattern(pattIt);
+  }
+  return true;
+}
+
+//______________________________________________________________________________
+// Function to analyze reconstructed tracks
+void analyzeRecoTracks(TTree* recTree,
+                       const std::vector<o2::its::TrackITS>* recArr,
+                       const std::vector<o2::MCCompLabel>* trkLabArr,
+                       std::vector<std::vector<ParticleInfo>>& info,
+                       float bz,
+                       ULong_t& unaccounted,
+                       ULong_t& good,
+                       ULong_t& fakes,
+                       ULong_t& total)
+{
+  unaccounted = good = fakes = total = 0;
+  for (int frame = 0; frame < recTree->GetEntriesFast(); frame++) { // reco tracks frames
+    if (recTree->GetEvent(frame) == 0)
+      continue;
+    total += trkLabArr->size();
+    for (unsigned int iTrack = 0; iTrack < trkLabArr->size(); ++iTrack) {
+      auto lab = trkLabArr->at(iTrack);
+      if (!lab.isSet()) {
+        unaccounted++;
+        continue;
+      }
+      int trackID, evID, srcID;
+      bool fake;
+      lab.get(trackID, evID, srcID, fake);
+      if (evID < 0 || evID >= (int)info.size()) {
+        unaccounted++;
+        continue;
+      }
+      if (trackID < 0 || trackID >= (int)info[evID].size()) {
+        unaccounted++;
+        continue;
+      }
+      info[evID][trackID].isReco += !fake;
+      info[evID][trackID].isFake += fake;
+      if (recArr->at(iTrack).isBetter(info[evID][trackID].track, 1.e9)) {
+        info[evID][trackID].storedStatus = fake;
+        info[evID][trackID].track = recArr->at(iTrack);
+        float ip[2]{0., 0.};
+        info[evID][trackID].track.getImpactParams(info[evID][trackID].pvx,
+                                                  info[evID][trackID].pvy,
+                                                  info[evID][trackID].pvz, bz, ip);
+        info[evID][trackID].dcaxy = ip[0];
+        info[evID][trackID].dcaz = ip[1];
+        info[evID][trackID].recpt = info[evID][trackID].track.getPt();
+      }
+      fakes += static_cast<ULong_t>(fake);
+      good += static_cast<ULong_t>(!fake);
+    }
+  }
+  LOGP(info, "** Some statistics:");
+  LOGP(info, "\t- Total number of tracks: {}", total);
+  LOGP(info, "\t- Total number of tracks not corresponding to particles: {} ({:.2f}%)", unaccounted, unaccounted * 100. / total);
+  LOGP(info, "\t- Total number of fakes: {} ({:.2f}%)", fakes, fakes * 100. / total);
+  LOGP(info, "\t- Total number of good: {} ({:.2f}%)", good, good * 100. / total);
+}
+
+//______________________________________________________________________________
+// Read and map hit information from hitTree
+void mapHitsForMCEvents(TTree* hitTree,
+                        std::vector<std::vector<o2::itsmft::Hit>*>& hitVecPool,
+                        std::vector<std::unordered_map<uint64_t, int>>& mc2hitVec,
+                        const std::vector<int>& mcEvMin,
+                        const std::vector<int>& mcEvMax,
+                        size_t nROFRec)
+{
+  for (unsigned int irof = 0; irof < nROFRec; irof++) {
+    for (int im = mcEvMin[irof]; im <= mcEvMax[irof]; im++) {
+      if (!hitVecPool[im]) {
+        hitTree->SetBranchAddress("IT3Hit", &hitVecPool[im]);
+        hitTree->GetEntry(im);
+        auto& mc2hit = mc2hitVec[im];
+        const auto* hitArray = hitVecPool[im];
+        for (int ih = hitArray->size(); ih--;) {
+          const auto& hit = (*hitArray)[ih];
+          uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
+          mc2hit.emplace(key, ih);
+        }
+      }
+    }
+  }
+}
+
+//______________________________________________________________________________
+// Load geometry and magnetic field information
+void loadGeometryAndField(const std::string& magfile, const std::string& inputGeom, float& bz, o2::its::GeometryTGeo*& gman)
+{
+  o2::base::Propagator::initFieldFromGRP(magfile);
+  bz = o2::base::Propagator::Instance()->getNominalBz();
+  o2::base::GeometryManager::loadGeometry(inputGeom);
+  gman = o2::its::GeometryTGeo::Instance();
+  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L,
+                                                 o2::math_utils::TransformType::T2GRot,
+                                                 o2::math_utils::TransformType::L2G));
+}
+
+//______________________________________________________________________________
+// Load topology dictionary
+void loadTopologyDictionary(const std::string& dictfile, o2::its3::TopologyDictionary& dict)
+{
+  std::ifstream iofile(dictfile);
+  if (iofile.good()) {
+    LOG(info) << "Running with dictionary: " << dictfile;
+    dict.readFromFile(dictfile);
+  } else {
+    LOG(info) << "Dictionary file not found: " << dictfile;
+  }
+}
+
+//______________________________________________________________________________
+// Build ROF
+void buildMcEvRangePerROF(const std::vector<o2::itsmft::MC2ROFRecord>& mc2rofVec,
+                          size_t nROFRec,
+                          std::vector<int>& mcEvMin,
+                          std::vector<int>& mcEvMax)
+{
+  for (size_t imc = 0; imc < mc2rofVec.size(); ++imc) {
+    const auto& mc2rof = mc2rofVec[imc];
+    if (mc2rof.rofRecordID < 0)
+      continue;
+    for (size_t i = mc2rof.minROF; i <= mc2rof.maxROF; ++i) {
+      if (i >= nROFRec)
+        continue;
+      mcEvMin[i] = std::min(mcEvMin[i], static_cast<int>(imc));
+      mcEvMax[i] = std::max(mcEvMax[i], static_cast<int>(imc));
+    }
+  }
+}
+
+//______________________________________________________________________________
+// Load Hits data
+void prepareHitAccess(const std::string& hitfile,
+                      TTree*& hitTree,
+                      std::vector<std::vector<o2::itsmft::Hit>*>& hitVecPool,
+                      std::vector<std::unordered_map<uint64_t, int>>& mc2hitVec)
+{
+  TFile* fHit = TFile::Open(hitfile.data());
+  hitTree = (TTree*)fHit->Get("o2sim");
+  mc2hitVec.resize(hitTree->GetEntries());
+  hitVecPool.resize(hitTree->GetEntries(), nullptr);
+}
+
+void loadCluster(const std::string& clusfile,
+                 TTree*& clusTree,
+                 std::vector<o2::itsmft::CompClusterExt>*& clusArr,
+                 o2::dataformats::MCTruthContainer<o2::MCCompLabel>*& clusLabArr,
+                 std::vector<o2::itsmft::MC2ROFRecord>& mc2rofVec,
+                 std::vector<unsigned char>*& patternsPtr,
+                 std::vector<o2::itsmft::ROFRecord>& rofRecVec)
+{
+  // Open file and let it persist
+  TFile* fileC = TFile::Open(clusfile.data());
+  // Get tree
+  clusTree = dynamic_cast<TTree*>(fileC->Get("o2sim"));
+  // Cluster array
+  clusArr = nullptr;
+  clusTree->SetBranchAddress("ITSClusterComp", &clusArr);
+  // MC truth
+  clusLabArr = nullptr;
+  clusTree->SetBranchAddress("ITSClusterMCTruth", &clusLabArr);
+  clusTree->SetBranchAddress("ITSClusterPatt", &patternsPtr);
+  // ROF records
+  std::vector<o2::itsmft::ROFRecord>* rofRecVecP = &rofRecVec;
+  clusTree->SetBranchAddress("ITSClustersROF", &rofRecVecP);
+  // MC2ROF mapping
+  std::vector<o2::itsmft::MC2ROFRecord>* mc2rofVecP = &mc2rofVec;
+  clusTree->SetBranchAddress("ITSClustersMC2ROF", &mc2rofVecP);
+  clusTree->GetEntry(0);
+  // After setting all branch addresses, trigger preload of the first entr
+}
+
+//______________________________________________________________________________
+// Load Reconstructed Tracks data
+void loadRecoTracks(const std::string& tracfile,
+                    TTree*& recTree,
+                    std::vector<o2::its::TrackITS>*& recArr,
+                    std::vector<o2::MCCompLabel>*& trkLabArr)
+{
+  TFile* fTrk = TFile::Open(tracfile.data());
+  recTree = (TTree*)fTrk->Get("o2sim");
+  recTree->SetBranchAddress("ITSTrack", &recArr);
+  recTree->SetBranchAddress("ITSTrackMCTruth", &trkLabArr);
+}
+
+//______________________________________________________________________________
+// Load MC Track information
+void loadMCTrackInfo(const std::string& kinefile,
+                     std::vector<std::vector<ParticleInfo>>& info,
+                     std::vector<o2::MCTrack>*& mcArr,
+                     o2::dataformats::MCEventHeader*& mcEvent,
+                     TTree*& mcTree)
+{
+  TFile* kineFile = TFile::Open(kinefile.data());
+  mcTree = (TTree*)kineFile->Get("o2sim");
+  mcTree->SetBranchStatus("*", 0);
+  mcTree->SetBranchStatus("MCTrack*", 1);
+  mcTree->SetBranchStatus("MCEventHeader*", 1);
+  mcTree->SetBranchAddress("MCTrack", &mcArr);
+  mcTree->SetBranchAddress("MCEventHeader.", &mcEvent);
+
+  int nev = mcTree->GetEntriesFast();
+  info.resize(nev);
+  for (int n = 0; n < nev; n++) {
+    mcTree->GetEvent(n);
+    info[n].resize(mcArr->size());
+    for (unsigned int mcI = 0; mcI < mcArr->size(); ++mcI) {
+      auto part = mcArr->at(mcI);
+      info[n][mcI].pvx = mcEvent->GetX();
+      info[n][mcI].pvy = mcEvent->GetY();
+      info[n][mcI].pvz = mcEvent->GetZ();
+      info[n][mcI].event = n;
+      info[n][mcI].pdg = part.GetPdgCode();
+      info[n][mcI].pt = part.GetPt();
+      info[n][mcI].phi = part.GetPhi();
+      info[n][mcI].eta = part.GetEta();
+      info[n][mcI].isPrimary = part.isPrimary();
+    }
+  }
+}
+
+//______________________________________________________________________________
+// Main function CorrTracksClusters
+void CorrTracksClusters(const std::string& tracfile = "o2trac_its.root",
+                        const std::string& clusfile = "o2clus_its.root",
+                        const std::string& kinefile = "o2sim_Kine.root",
+                        const std::string& magfile = "o2sim_grp.root",
+                        const std::string& hitfile = "o2sim_HitsIT3.root",
+                        const std::string& dictfile = "IT3dictionary.root",
+                        const std::string& inputGeom = "",
+                        bool batch = false)
+{
+  gROOT->SetBatch(batch);
+
+  // Geo and Field
+  LOGP(info, "Geo and Field loading");
+  float bz{0.f};
+  o2::its::GeometryTGeo* gman = nullptr;
+  loadGeometryAndField(magfile, inputGeom, bz, gman);
+  LOGP(info, "Finished Geo and Field loading");
+
+  // MC tracks
+  LOGP(info, "MC Track Info loading");
+  std::vector<o2::MCTrack>* mcArr = nullptr;
+  o2::dataformats::MCEventHeader* mcEvent = nullptr;
+  TTree* mcTree = nullptr;
+  std::vector<std::vector<ParticleInfo>> info;
+  loadMCTrackInfo(kinefile, info, mcArr, mcEvent, mcTree);
+  LOGP(info, "Finished MC Track Info loading");
+
+  // Reconstructed tracks
+  LOGP(info, "Reco Tracks loading");
+  TTree* recTree = nullptr;
+  std::vector<o2::its::TrackITS>* recArr = nullptr;
+  std::vector<o2::MCCompLabel>* trkLabArr = nullptr;
+  loadRecoTracks(tracfile, recTree, recArr, trkLabArr);
+  LOGP(info, "Finished Reco Tracks loading");
+
+  // Run analyzeRecoTracks
+  LOGP(info, "Track analysis (analyzeRecoTracks)");
+  ULong_t unaccounted{0}, good{0}, fakes{0}, total{0};
+  analyzeRecoTracks(recTree, recArr, trkLabArr, info, bz, unaccounted, good, fakes, total);
+  LOGP(info, "Finished track analysis (analyzeRecoTracks)");
+
+  // Topology dictionary
+  LOGP(info, "Topology Dictionary loading");
+  o2::its3::TopologyDictionary dict;
+  loadTopologyDictionary(dictfile, dict);
+  LOGP(info, "Finished Topology Dictionary loading");
+
+  // Clusters
+  LOGP(info, "Cluster Data loading");
+  TTree* clusTree = nullptr;
+  std::vector<o2::itsmft::CompClusterExt>* clusArr = nullptr;
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel>* clusLabArr = nullptr;
+  std::vector<unsigned char>* patternsPtr = nullptr;
+  std::vector<o2::itsmft::MC2ROFRecord> mc2rofVec;
+  std::vector<o2::itsmft::ROFRecord> rofRecVec;
+  loadCluster(clusfile, clusTree, clusArr, clusLabArr, mc2rofVec, patternsPtr, rofRecVec);
+  LOGP(info, "Finished Cluster Data loading");
+  // clusTree->GetEntry(0);
+
+  // Hits
+  LOGP(info, "Hits loading");
+  TTree* hitTree = nullptr;
+  std::vector<std::vector<o2::itsmft::Hit>*> hitVecPool;
+  std::vector<std::unordered_map<uint64_t, int>> mc2hitVec;
+  prepareHitAccess(hitfile, hitTree, hitVecPool, mc2hitVec);
+  LOGP(info, "Finished Hits loading");
+
+  // Build min and max MC events used by each ROF
+  LOGP(info, "Building MC event ranges");
+  std::vector<int> mcEvMin, mcEvMax;
+  mcEvMin.assign(rofRecVec.size(), hitTree->GetEntries());
+  mcEvMax.assign(rofRecVec.size(), -1);
+  buildMcEvRangePerROF(mc2rofVec, rofRecVec.size(), mcEvMin, mcEvMax);
+  LOGP(info, "Initial MC event ranges built");
+  unsigned int nROFRec = rofRecVec.size();
+
+  // Map hits for MC events
+  LOGP(info, "Map hits for MC events");
+  mapHitsForMCEvents(hitTree, hitVecPool, mc2hitVec, mcEvMin, mcEvMax, nROFRec);
+  LOGP(info, "Mapped hits for MC events");
+
+  // Run cluster particle matching
+  auto pattIt = patternsPtr->cbegin();
+  for (unsigned int iClus = 0; iClus < clusArr->size(); ++iClus) {
+    auto lab = (clusLabArr->getLabels(iClus))[0];
+    const auto& c = (*clusArr)[iClus];
+    // Ensure pattIt is advanced even if cluster is skipped
+    if (!lab.isValid() || lab.getSourceID() != 0 || !lab.isCorrect()) {
+      if (c.getPatternID() == CompCluster::InvalidPatternID) {
+        o2::itsmft::ClusterPattern::skipPattern(pattIt);
+      }
+      continue;
+    }
+
+    int trackID{0}, evID{0}, srcID{0};
+    bool fake{false};
+    lab.get(trackID, evID, srcID, fake);
+    if (evID < 0 || static_cast<size_t>(evID) >= info.size() || trackID < 0 || static_cast<size_t>(trackID) >= info[evID].size()) {
+      if (c.getPatternID() == CompCluster::InvalidPatternID) {
+        o2::itsmft::ClusterPattern::skipPattern(pattIt);
+      }
+      continue;
+    }
+    UShort_t chipID = c.getSensorID();
+    int layer = gman->getLayer(chipID);
+    bool isIB = layer < 3;
+    info[evID][trackID].clusters |= 1 << layer;
+
+    o2::math_utils::Point3D<float> clusterPos;
+    int clusterSize;
+    auto pattID = c.getPatternID();
+    o2::itsmft::ClusterPattern patt;
+    if (!resolvePattern(c, pattIt, dict, isIB, patt)) {
+      continue;
+    }
+    clusterSize = patt.getNPixels();
+    clusterPos = dict.getClusterCoordinates(c, patt, false);
+
+    if (isIB) {
+      CurvedLocalToFlat(clusterPos, SegmentationIB(layer));
+    }
+
+    info[evID][trackID].clusterSize[layer] = clusterSize;
+    info[evID][trackID].clusterPattern[layer] = pattID;
+    info[evID][trackID].clusterLocX[layer] = clusterPos.X();
+    info[evID][trackID].clusterLocZ[layer] = clusterPos.Z();
+
+    const auto& mc2hit = mc2hitVec[lab.getEventID()];
+    const auto* hitArray = hitVecPool[lab.getEventID()];
+    uint64_t key = (uint64_t(trackID) << 32) + c.getSensorID();
+    auto hitIt = mc2hit.find(key);
+    if (hitIt == mc2hit.end())
+      continue;
+    const auto& hit = (*hitArray)[hitIt->second];
+
+    auto hitLocSta = gman->getMatrixL2G(chipID) ^ hit.GetPosStart();
+    auto hitLocEnd = gman->getMatrixL2G(chipID) ^ hit.GetPos();
+
+    if (isIB) {
+      CurvedLocalToFlat(hitLocSta, SegmentationIB(layer));
+      CurvedLocalToFlat(hitLocEnd, SegmentationIB(layer));
+      info[evID][trackID].hitLocX[layer] = 0.5f * (hitLocSta.X() + hitLocEnd.X());
+      info[evID][trackID].hitLocY[layer] = 0.5f * (hitLocSta.Y() + hitLocEnd.Y());
+      info[evID][trackID].hitLocZ[layer] = 0.5f * (hitLocSta.Z() + hitLocEnd.Z());
+    } else {
+      auto x0 = hitLocSta.X(), dx = hitLocEnd.X() - x0;
+      auto y0 = hitLocSta.Y(), dy = hitLocEnd.Y() - y0;
+      auto z0 = hitLocSta.Z(), dz = hitLocEnd.Z() - z0;
+      auto r = (0.5f * (SegmentationOB::SensorLayerThickness - SegmentationOB::SensorLayerThicknessEff) - y0) / dy;
+      info[evID][trackID].hitLocX[layer] = x0 + r * dx;
+      info[evID][trackID].hitLocY[layer] = y0 + r * dy;
+      info[evID][trackID].hitLocZ[layer] = z0 + r * dz;
+    }
+  }
+
+  LOGP(info, "Finished cluster-to-particle matching");
+
+  // The following part generates statistical histograms and outputs a TTree
+  int nb = 100;
+  double xbins[nb + 1], ptcutl = 0.01, ptcuth = 10.;
+  double a = std::log(ptcuth / ptcutl) / nb;
+  for (int i = 0; i <= nb; ++i) {
+    xbins[i] = ptcutl * std::exp(i * a);
+  }
+  auto* h_pt_num = new TH1D("h_pt_num", ";#it{p}_{T} (GeV/#it{c});Number of tracks", nb, xbins);
+  auto* h_pt_den = new TH1D("h_pt_den", ";#it{p}_{T} (GeV/#it{c});Number of generated primary particles", nb, xbins);
+  auto* h_pt_eff = new TEfficiency("h_pt_eff", "Tracking Efficiency;#it{p}_{T} (GeV/#it{c});Eff.", nb, xbins);
+
+  auto* h_eta_num = new TH1D("h_eta_num", ";#it{#eta};Number of tracks", 60, -3, 3);
+  auto* h_eta_den = new TH1D("h_eta_den", ";#it{#eta};Number of generated particles", 60, -3, 3);
+  auto* h_eta_eff = new TEfficiency("h_eta_eff", "Tracking Efficiency;#it{#eta};Eff.", 60, -3, 3);
+
+  auto* h_phi_num = new TH1D("h_phi_num", ";#varphi;Number of tracks", 360, 0., 2 * TMath::Pi());
+  auto* h_phi_den = new TH1D("h_phi_den", ";#varphi;Number of generated particles", 360, 0., 2 * TMath::Pi());
+  auto* h_phi_eff = new TEfficiency("h_phi_eff", "Tracking Efficiency;#varphi;Eff.", 360, 0., 2 * TMath::Pi());
+
+  auto* h_pt_fake = new TH1D("h_pt_fake", ";#it{p}_{T} (GeV/#it{c});Number of fake tracks", nb, xbins);
+  auto* h_pt_multifake = new TH1D("h_pt_multifake", ";#it{p}_{T} (GeV/#it{c});Number of multifake tracks", nb, xbins);
+  auto* h_pt_clones = new TH1D("h_pt_clones", ";#it{p}_{T} (GeV/#it{c});Number of cloned tracks", nb, xbins);
+  auto* h_dcaxy_vs_pt = new TH2D("h_dcaxy_vs_pt", ";#it{p}_{T} (GeV/#it{c});DCA_{xy} (#mum)", nb, xbins, 2000, -500., 500.);
+  auto* h_dcaxy_vs_eta = new TH2D("h_dcaxy_vs_eta", ";#it{#eta};DCA_{xy} (#mum)", 60, -3, 3, 2000, -500., 500.);
+  auto* h_dcaxy_vs_phi = new TH2D("h_dcaxy_vs_phi", ";#varphi;DCA_{xy} (#mum)", 360, 0., 2 * TMath::Pi(), 2000, -500., 500.);
+  auto* h_dcaz_vs_pt = new TH2D("h_dcaz_vs_pt", ";#it{p}_{T} (GeV/#it{c});DCA_{z} (#mum)", nb, xbins, 2000, -500., 500.);
+  auto* h_dcaz_vs_eta = new TH2D("h_dcaz_vs_eta", ";#it{#eta};DCA_{z} (#mum)", 60, -3, 3, 2000, -500., 500.);
+  auto* h_dcaz_vs_phi = new TH2D("h_dcaz_vs_phi", ";#varphi;DCA_{z} (#mum)", 360, 0., 2 * TMath::Pi(), 2000, -500., 500.);
+  auto* h_chi2 = new TH2D("h_chi2", ";#it{p}_{T} (GeV/#it{c});#chi^{2};Number of tracks", nb, xbins, 200, 0., 100.);
+
+  for (auto& evInfo : info) {
+    for (auto& part : evInfo) {
+      if ((part.clusters & 0x7f) != 0x7f) {
+        // part.clusters != 0x3f && part.clusters != 0x3f << 1 &&
+        // part.clusters != 0x1f && part.clusters != 0x1f << 1 && part.clusters
+        // != 0x1f << 2 && part.clusters != 0x0f && part.clusters != 0x0f << 1
+        // && part.clusters != 0x0f << 2 && part.clusters != 0x0f << 3) {
+        continue;
+      }
+      if (!part.isPrimary) {
+        continue;
+      }
+
+      h_pt_den->Fill(part.pt);
+      h_eta_den->Fill(part.eta);
+      h_phi_den->Fill(part.phi);
+
+      if (part.isReco != 0u) {
+        h_pt_num->Fill(part.pt);
+        h_eta_num->Fill(part.eta);
+        h_phi_num->Fill(part.phi);
+        if (std::abs(part.eta) < 0.5) {
+          h_dcaxy_vs_pt->Fill(part.pt, part.dcaxy * 10000);
+          h_dcaz_vs_pt->Fill(part.pt, part.dcaz * 10000);
+        }
+        h_dcaz_vs_eta->Fill(part.eta, part.dcaz * 10000);
+        h_dcaxy_vs_eta->Fill(part.eta, part.dcaxy * 10000);
+        h_dcaxy_vs_phi->Fill(part.phi, part.dcaxy * 10000);
+        h_dcaz_vs_phi->Fill(part.phi, part.dcaz * 10000);
+
+        h_chi2->Fill(part.pt, part.track.getChi2());
+
+        if (part.isReco > 1) {
+          for (int _i{0}; _i < part.isReco - 1; ++_i) {
+            h_pt_clones->Fill(part.pt);
+          }
+        }
+      }
+      if (part.isFake != 0u) {
+        h_pt_fake->Fill(part.pt);
+        if (part.isFake > 1) {
+          for (int _i{0}; _i < part.isFake - 1; ++_i) {
+            h_pt_multifake->Fill(part.pt);
+          }
+        }
+      }
+    }
+  }
+
+  LOGP(info, "Streaming output TTree to file");
+  TFile file("CorrTracksClusters.root", "recreate");
+  TTree tree("ParticleInfo", "ParticleInfo");
+  ParticleInfo pInfo;
+  tree.Branch("particle", &pInfo);
+  for (auto& event : info) {
+    for (auto& part : event) {
+      int nCl{0};
+      for (unsigned int bit{0}; bit < sizeof(pInfo.clusters) * 8; ++bit) {
+        nCl += bool(part.clusters & (1 << bit));
+      }
+      if (nCl < 3) {
+        continue;
+      }
+      pInfo = part;
+      tree.Fill();
+    }
+  }
+  tree.Write();
+  h_pt_num->Write();
+  h_eta_num->Write();
+  h_phi_num->Write();
+  h_pt_den->Write();
+  h_eta_den->Write();
+  h_phi_den->Write();
+  h_pt_multifake->Write();
+  h_pt_fake->Write();
+  h_dcaxy_vs_pt->Write();
+  h_dcaz_vs_pt->Write();
+  h_dcaxy_vs_eta->Write();
+  h_dcaxy_vs_phi->Write();
+  h_dcaz_vs_eta->Write();
+  h_dcaz_vs_phi->Write();
+  h_pt_clones->Write();
+  h_chi2->Write();
+
+  h_pt_eff->SetTotalHistogram(*h_pt_den, "");
+  h_pt_eff->SetPassedHistogram(*h_pt_num, "");
+  h_pt_eff->SetTitle("Tracking Efficiency;#it{p}_{T} (GeV/#it{c});Eff.");
+  h_pt_eff->Write();
+
+  h_phi_eff->SetTotalHistogram(*h_phi_den, "");
+  h_phi_eff->SetPassedHistogram(*h_phi_num, "");
+  h_phi_eff->SetTitle("Tracking Efficiency;#varphi;Eff.");
+  h_phi_eff->Write();
+
+  h_eta_eff->SetTotalHistogram(*h_eta_den, "");
+  h_eta_eff->SetPassedHistogram(*h_eta_num, "");
+  h_eta_eff->SetTitle("Tracking Efficiency;#it{#eta};Eff.");
+  h_eta_eff->Write();
+
+  file.Close();
+  LOGP(info, "Finished streaming output TTree to file");
+  LOGP(info, "done.");
+}
diff --git a/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C b/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
index cc241afb3357a..76d7bf09de77f 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
@@ -52,7 +52,7 @@
 
 #endif
 
-void CreateDictionariesITS3(bool saveDeltas = false,
+void CreateDictionariesITS3(bool saveDeltas = true,
                             float probThreshold = 1e-6,
                             std::string clusDictFile = "",
                             std::string clusfile = "o2clus_its.root",
@@ -94,7 +94,7 @@ void CreateDictionariesITS3(bool saveDeltas = false,
   TNtuple* nt = nullptr;
   if (saveDeltas) {
     fout = TFile::Open("CreateDictionaries.root", "recreate");
-    nt = new TNtuple("nt", "hashes ntuple", "hash:dx:dz");
+    nt = new TNtuple("nt", "hashes ntuple", "hash:layer:chipID:xhf:zhf:xcf:zcf:dx:dz:outlimDx:outlimDz");
   }
 
   const o2::steer::DigitizationContext* digContext = nullptr;
@@ -284,19 +284,25 @@ void CreateDictionariesITS3(bool saveDeltas = false,
                 dZ = xyzLocM.Z() - locC.Z();
                 dX /= (ib) ? o2::its3::SegmentationMosaix::PitchRow : o2::itsmft::SegmentationAlpide::PitchRow;
                 dZ /= (ib) ? o2::its3::SegmentationMosaix::PitchCol : o2::itsmft::SegmentationAlpide::PitchCol;
-                if (saveDeltas) {
-                  nt->Fill(topology.getHash(), dX, dZ);
-                }
+
+                float outLimitDx{-1}, outLimitDz{-1};
                 if (checkOutliers > 0.) {
-                  if (bool bX = std::abs(dX) > topology.getRowSpan() * checkOutliers, bZ = std::abs(dZ) > topology.getColumnSpan() * checkOutliers; bX || bZ) { // ignore outlier
+                  outLimitDx = topology.getRowSpan() * checkOutliers;
+                  outLimitDz = topology.getColumnSpan() * checkOutliers;
+                  bool isOutDx = std::abs(dX) > outLimitDx;
+                  bool isOutDz = std::abs(dZ) > outLimitDz;
+                  if (isOutDx || isOutDz) { // ignore outlier
                     (ib) ? ++cOutliersIB : ++cOutliersOB;
-                    LOGP(debug, "Ignored Value dX={} > {} * {} -> {}", dX, topology.getRowSpan(), checkOutliers, bX);
-                    LOGP(debug, "Ignored Value dZ={} > {} * {} -> {}", dZ, topology.getColumnSpan(), checkOutliers, bZ);
+                    LOGP(debug, "Ignored Value dX={} > {} * {} -> {}", dX, topology.getRowSpan(), checkOutliers, isOutDx);
+                    LOGP(debug, "Ignored Value dZ={} > {} * {} -> {}", dZ, topology.getColumnSpan(), checkOutliers, isOutDz);
                     dX = dZ = BuildTopologyDictionary::IgnoreVal;
                   } else {
                     (ib) ? ++cOkIB : ++cOkOB;
                   }
                 }
+                if (saveDeltas) {
+                  nt->Fill(topology.getHash(), layer, chipID, xyzLocM.X(), xyzLocM.Z(), locC.X(), locC.Z(), dX, dZ, outLimitDx, outLimitDz);
+                }
               }
             } else {
               /* LOGP(info, "  Failed to find MC hit entry for Tr: {} chipID: {}", trID, chipID); */
diff --git a/Detectors/Upgrades/ITS3/simulation/CMakeLists.txt b/Detectors/Upgrades/ITS3/simulation/CMakeLists.txt
index 2fad72a96426d..8c4722012224d 100644
--- a/Detectors/Upgrades/ITS3/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/simulation/CMakeLists.txt
@@ -15,8 +15,11 @@ o2_add_library(ITS3Simulation
                        src/DescriptorInnerBarrelITS3.cxx
                        src/Digitizer.cxx
                        src/DigiParams.cxx
+                       src/ITS3DPLDigitizerParam.cxx
+                       src/ChipDigitsContainer.cxx
+                       src/ChipSimResponse.cxx
                PUBLIC_LINK_LIBRARIES O2::SimulationDataFormat
-                                     O2::ITSBase O2::ITSMFTSimulation
+                                     O2::ITSBase O2::ITSMFTSimulation O2::ITSMFTBase
                                      ROOT::Physics)
 
 o2_target_root_dictionary(ITS3Simulation
@@ -25,6 +28,9 @@ o2_target_root_dictionary(ITS3Simulation
                                   include/ITS3Simulation/DescriptorInnerBarrelITS3.h
                                   include/ITS3Simulation/Digitizer.h
                                   include/ITS3Simulation/DigiParams.h
+                                  include/ITS3Simulation/ITS3DPLDigitizerParam.h
+                                  include/ITS3Simulation/ChipDigitsContainer.h
+                                  include/ITS3Simulation/ChipSimResponse.h
                                   )
 
 o2_data_file(COPY data  DESTINATION Detectors/ITS3/simulation)
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h
new file mode 100644
index 0000000000000..0c9627fe412c3
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h
@@ -0,0 +1,59 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_ITS3_CHIPDIGITSCONTAINER_
+#define ALICEO2_ITS3_CHIPDIGITSCONTAINER_
+
+#include "ITSMFTBase/SegmentationAlpide.h"        // Base class in o2::itsmft namespace
+#include "ITSMFTSimulation/ChipDigitsContainer.h" // Base class in o2::itsmft namespace
+#include "ITS3Base/SegmentationMosaix.h"          // OB segmentation implementation
+#include "ITS3Base/SpecsV2.h"                     // Provides SpecsV2::isDetITS3() interface
+#include "ITS3Simulation/DigiParams.h"            // ITS3-specific DigiParams interface
+#include <TRandom.h>
+
+namespace o2::its3
+{
+
+class ChipDigitsContainer : public o2::itsmft::ChipDigitsContainer
+{
+ private:
+  bool innerBarrel; ///< true if the chip belongs to the inner barrel (IB), false if outer barrel (OB)
+  int maxRows;      ///< maximum number of rows
+  int maxCols;      ///< maximum number of columns
+
+ public:
+  explicit ChipDigitsContainer(UShort_t idx = 0);
+
+  using SegmentationIB = SegmentationMosaix;
+  using SegmentationOB = o2::itsmft::SegmentationAlpide;
+
+  /// Returns whether the chip is in the inner barrel (IB)
+  void setChipIndex(UShort_t idx)
+  {
+    o2::itsmft::ChipDigitsContainer::setChipIndex(idx);
+    innerBarrel = constants::detID::isDetITS3(getChipIndex());
+    maxRows = innerBarrel ? SegmentationIB::NRows : SegmentationOB::NRows;
+    maxCols = innerBarrel ? SegmentationIB::NCols : SegmentationOB::NCols;
+  }
+
+  int getMaxRows() const { return maxRows; }
+  int getMaxCols() const { return maxCols; }
+  bool isIB() const;
+  /// Adds noise digits, deleted the one using the itsmft::DigiParams interface
+  void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::itsmft::DigiParams* params, int maxRows = o2::itsmft::SegmentationAlpide::NRows, int maxCols = o2::itsmft::SegmentationAlpide::NCols) = delete;
+  void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::its3::DigiParams* params);
+
+  ClassDefNV(ChipDigitsContainer, 1);
+};
+
+} // namespace o2::its3
+
+#endif // ALICEO2_ITS3_CHIPDIGITSCONTAINER_
\ No newline at end of file
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipSimResponse.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipSimResponse.h
new file mode 100644
index 0000000000000..f96fde9fb0d55
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipSimResponse.h
@@ -0,0 +1,41 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_ITS3SIMULATION_CHIPSIMRESPONSE_H
+#define ALICEO2_ITS3SIMULATION_CHIPSIMRESPONSE_H
+
+#include "ITSMFTSimulation/AlpideSimResponse.h"
+
+namespace o2
+{
+namespace its3
+{
+
+class ChipSimResponse : public o2::itsmft::AlpideSimResponse
+{
+ public:
+  ChipSimResponse() = default;
+  ChipSimResponse(const ChipSimResponse& other) = default;
+
+  float getRespCentreDep() const { return mRespCentreDep; }
+  void computeCentreFromData();
+  void initData(int tableNumber, std::string dataPath, const bool quiet = true);
+
+ private:
+  float mRespCentreDep = 0.f;
+
+  ClassDef(ChipSimResponse, 1);
+};
+
+} // namespace its3
+} // namespace o2
+
+#endif // ALICEO2_ITS3SIMULATION_CHIPSIMRESPONSE_H
\ No newline at end of file
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
index eca0a71949ba7..5764dfbd7d593 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
@@ -13,21 +13,43 @@
 #define ITS3_DIGIPARAMS_H
 
 #include "ITSMFTSimulation/DigiParams.h"
+#include "ITS3Simulation/ChipSimResponse.h"
 
 namespace o2::its3
 {
 
 class DigiParams final : public o2::itsmft::DigiParams
 {
+ private:
+  float mIBNoisePerPixel = 1.e-8;
+  int mIBChargeThreshold = 150;   ///< charge threshold in Nelectrons
+  int mIBMinChargeToAccount = 15; ///< minimum charge contribution to account
+  int mIBNSimSteps = 18;          ///< number of steps in response simulation
+  float mIBNSimStepsInv = 0;      ///< its inverse
+
  public:
+  DigiParams();
+
+  void setIBNoisePerPixel(float v) { mIBNoisePerPixel = v; }
+  float getIBNoisePerPixel() const { return mIBNoisePerPixel; }
+
+  void setIBChargeThreshold(int v, float frac2Account = 0.1);
+  int getIBChargeThreshold() const { return mIBChargeThreshold; }
+
+  void setIBNSimSteps(int v);
+  int getIBNSimSteps() const { return mIBNSimSteps; }
+  float getIBNSimStepsInv() const { return mIBNSimStepsInv; }
+
+  int getIBMinChargeToAccount() const { return mIBMinChargeToAccount; }
+
   const o2::itsmft::AlpideSimResponse* getAlpSimResponse() const = delete;
   void setAlpSimResponse(const o2::itsmft::AlpideSimResponse* par) = delete;
 
   const o2::itsmft::AlpideSimResponse* getOBSimResponse() const { return mOBSimResponse; }
   void setOBSimResponse(const o2::itsmft::AlpideSimResponse* response) { mOBSimResponse = response; }
 
-  const o2::itsmft::AlpideSimResponse* getIBSimResponse() const { return mIBSimResponse; }
-  void setIBSimResponse(const o2::itsmft::AlpideSimResponse* response) { mIBSimResponse = response; }
+  o2::its3::ChipSimResponse* getIBSimResponse() const { return mIBSimResponse; }
+  void setIBSimResponse(o2::its3::ChipSimResponse* response);
 
   bool hasResponseFunctions() const { return mIBSimResponse != nullptr && mOBSimResponse != nullptr; }
 
@@ -35,7 +57,7 @@ class DigiParams final : public o2::itsmft::DigiParams
 
  private:
   const o2::itsmft::AlpideSimResponse* mOBSimResponse = nullptr; //!< pointer to external response
-  const o2::itsmft::AlpideSimResponse* mIBSimResponse = nullptr; //!< pointer to external response
+  o2::its3::ChipSimResponse* mIBSimResponse = nullptr;           //!< pointer to external response
 
   ClassDef(DigiParams, 1);
 };
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
index 8d0f06a27343b..edc5583c03d5a 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
@@ -21,12 +21,13 @@
 #include "Rtypes.h"
 #include "TObject.h"
 
-#include "ITSMFTSimulation/ChipDigitsContainer.h"
 #include "ITSMFTSimulation/AlpideSimResponse.h"
 #include "ITSMFTSimulation/Hit.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITS3Base/SegmentationMosaix.h"
 #include "ITS3Simulation/DigiParams.h"
+#include "ITS3Simulation/ChipDigitsContainer.h"
+#include "ITS3Simulation/ChipSimResponse.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "CommonDataFormat/InteractionRecord.h"
@@ -78,7 +79,7 @@ class Digitizer : public TObject
 
  private:
   void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
-  void registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+  void registerDigits(o2::its3::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
                       uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
 
   ExtraDig* getExtraDigBuffer(uint32_t roFrame)
@@ -108,7 +109,7 @@ class Digitizer : public TObject
 
   static constexpr std::array<o2::its3::SegmentationMosaix, 3> mIBSegmentations{0, 1, 2};
 
-  o2::itsmft::AlpideSimResponse* mSimRespIB = nullptr; // simulated response for IB
+  o2::its3::ChipSimResponse* mSimRespIB = nullptr;     // simulated response for IB
   o2::itsmft::AlpideSimResponse* mSimRespOB = nullptr; // simulated response for OB
   bool mSimRespIBOrientation{false};                   // wether the orientation in the IB response function is flipped
   float mSimRespIBShift{0.f};                          // adjusting the Y-shift in the IB response function to match sensor local coord.
@@ -118,7 +119,7 @@ class Digitizer : public TObject
 
   const o2::its::GeometryTGeo* mGeometry = nullptr; ///< ITS3 geometry
 
-  std::vector<o2::itsmft::ChipDigitsContainer> mChips; ///< Array of chips digits containers
+  std::vector<o2::its3::ChipDigitsContainer> mChips;   ///< Array of chips digits containers
   std::deque<std::unique_ptr<ExtraDig>> mExtraBuff;    ///< burrer (per roFrame) for extra digits
 
   std::vector<o2::itsmft::Digit>* mDigits = nullptr;                       //! output digits
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3DPLDigitizerParam.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3DPLDigitizerParam.h
new file mode 100644
index 0000000000000..3192f73fb8f79
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3DPLDigitizerParam.h
@@ -0,0 +1,32 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_ITS3DPLDIGITIZERPARAM_H_
+#define ALICEO2_ITS3DPLDIGITIZERPARAM_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2::its3
+{
+
+struct ITS3DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<ITS3DPLDigitizerParam> {
+  float IBNoisePerPixel = 1.e-8; ///< MOSAIX Noise per channel
+  int IBChargeThreshold = 150;   ///< charge threshold in Nelectrons for IB
+  int IBMinChargeToAccount = 15; ///< minimum charge contribution to account for IB
+  int nIBSimSteps = 18;          ///< number of steps in response for IB
+
+  O2ParamDef(ITS3DPLDigitizerParam, "ITS3DPLDigitizerParam");
+};
+
+} // namespace o2::its3
+
+#endif
\ No newline at end of file
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx b/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
new file mode 100644
index 0000000000000..0611f7002f160
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
@@ -0,0 +1,63 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3Simulation/ChipDigitsContainer.h"
+
+namespace o2
+{
+namespace its3
+{
+
+ChipDigitsContainer::ChipDigitsContainer(UShort_t idx)
+  : o2::itsmft::ChipDigitsContainer(idx) {}
+
+bool ChipDigitsContainer::isIB() const
+{
+  return innerBarrel;
+}
+
+void ChipDigitsContainer::addNoise(UInt_t rofMin, UInt_t rofMax, const o2::its3::DigiParams* params)
+{
+  UInt_t row = 0;
+  UInt_t col = 0;
+  Int_t nhits = 0;
+  constexpr float ns2sec = 1e-9;
+  float mean = 0.f;
+  int nel = 0;
+
+  if (isIB()) {
+    // Inner barrel: use ITS3-specific noise interface with OB segmentation.
+    mean = params->getIBNoisePerPixel() * SegmentationOB::NPixels;
+    nel = static_cast<int>(params->getIBChargeThreshold() * 1.1);
+  } else {
+    // Outer barrel: use base class noise interface with IB segmentation.
+    mean = params->getNoisePerPixel() * SegmentationIB::NPixels;
+    nel = static_cast<int>(params->getChargeThreshold() * 1.1);
+  }
+
+  for (UInt_t rof = rofMin; rof <= rofMax; ++rof) {
+    nhits = gRandom->Poisson(mean);
+    for (Int_t i = 0; i < nhits; ++i) {
+      row = gRandom->Integer(maxRows);
+      col = gRandom->Integer(maxCols);
+      if (mNoiseMap && mNoiseMap->isNoisy(mChipIndex, row, col))
+        continue;
+      if (mDeadChanMap && mDeadChanMap->isNoisy(mChipIndex, row, col))
+        continue;
+      auto key = getOrderingKey(rof, row, col);
+      if (!findDigit(key))
+        addDigit(key, rof, row, col, nel, o2::MCCompLabel(true));
+    }
+  }
+}
+
+} // namespace its3
+} // namespace o2
\ No newline at end of file
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ChipSimResponse.cxx b/Detectors/Upgrades/ITS3/simulation/src/ChipSimResponse.cxx
new file mode 100644
index 0000000000000..1c482983f0d0a
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/simulation/src/ChipSimResponse.cxx
@@ -0,0 +1,62 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3Simulation/ChipSimResponse.h"
+#include <vector>
+#include <algorithm>
+
+using namespace o2::its3;
+
+ClassImp(o2::its3::ChipSimResponse);
+
+void ChipSimResponse::initData(int tableNumber, std::string dataPath, const bool quiet)
+{
+  AlpideSimResponse::initData(tableNumber, dataPath, quiet);
+  computeCentreFromData();
+}
+
+void ChipSimResponse::computeCentreFromData()
+{
+  std::vector<float> zVec, qVec;
+  const int npix = o2::itsmft::AlpideRespSimMat::getNPix();
+
+  for (int iz = 0; iz < mNBinDpt; ++iz) {
+    size_t bin = iz + mNBinDpt * (0 + mNBinRow * 0);
+    const auto& mat = mData[bin];
+    float val = mat.getValue(npix / 2, npix / 2);
+    float gz = mDptMin + iz / mStepInvDpt;
+    zVec.push_back(gz);
+    qVec.push_back(val);
+  }
+
+  std::vector<std::pair<float, float>> zqPairs;
+  for (size_t i = 0; i < zVec.size(); ++i) {
+    zqPairs.emplace_back(zVec[i], qVec[i]);
+  }
+  std::sort(zqPairs.begin(), zqPairs.end());
+  zVec.clear();
+  qVec.clear();
+  for (auto& p : zqPairs) {
+    zVec.push_back(p.first);
+    qVec.push_back(p.second);
+  }
+
+  float intQ = 0.f, intZQ = 0.f;
+  for (size_t i = 0; i + 1 < zVec.size(); ++i) {
+    float z0 = zVec[i], z1 = zVec[i + 1];
+    float q0 = qVec[i], q1 = qVec[i + 1];
+    float dz = z1 - z0;
+    intQ += 0.5f * (q0 + q1) * dz;
+    intZQ += 0.5f * (z0 * q0 + z1 * q1) * dz;
+  }
+
+  mRespCentreDep = (intQ > 0.f) ? intZQ / intQ : 0.f;
+}
diff --git a/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx b/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx
index a9f17a544b3c4..afa02ec44741d 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx
@@ -14,27 +14,67 @@
 
 #include "Framework/Logger.h"
 #include "ITS3Simulation/DigiParams.h"
+#include <cstdio>
 
 ClassImp(o2::its3::DigiParams);
 
 namespace o2::its3
 {
 
+DigiParams::DigiParams()
+{
+  // make sure the defaults are consistent
+  setIBNSimSteps(mIBNSimSteps);
+}
+
+void DigiParams::setIBNSimSteps(int v)
+{
+  // set number of sampling steps in silicon
+  mIBNSimSteps = v > 0 ? v : 1;
+  mIBNSimStepsInv = 1.f / mIBNSimSteps;
+}
+
+void DigiParams::setIBChargeThreshold(int v, float frac2Account)
+{
+  // set charge threshold for digits creation and its fraction to account
+  // contribution from single hit
+  mIBChargeThreshold = v;
+  mIBMinChargeToAccount = v * frac2Account;
+  if (mIBMinChargeToAccount < 0 || mIBMinChargeToAccount > mIBChargeThreshold) {
+    mIBMinChargeToAccount = mIBChargeThreshold;
+  }
+  LOG(info) << "Set Mosaix charge threshold to " << mIBChargeThreshold
+            << ", single hit will be accounted from " << mIBMinChargeToAccount
+            << " electrons";
+}
+
 void DigiParams::print() const
 {
   // print settings
-  LOGF(info, "ITS3 DigiParams settings:");
-  LOGF(info, "Continuous readout             : %s", isContinuous() ? "ON" : "OFF");
-  LOGF(info, "Readout Frame Length(ns)       : %f", getROFrameLength());
-  LOGF(info, "Strobe delay (ns)              : %f", getStrobeDelay());
-  LOGF(info, "Strobe length (ns)             : %f", getStrobeLength());
-  LOGF(info, "Threshold (N electrons)        : %d", getChargeThreshold());
-  LOGF(info, "Min N electrons to account     : %d", getMinChargeToAccount());
-  LOGF(info, "Number of charge sharing steps : %d", getNSimSteps());
-  LOGF(info, "ELoss to N electrons factor    : %e", getEnergyToNElectrons());
-  LOGF(info, "Noise level per pixel          : %e", getNoisePerPixel());
-  LOGF(info, "Charge time-response:\n");
+  printf("ITS3 DigiParams settings:\n");
+  printf("Continuous readout                   : %s\n", isContinuous() ? "ON" : "OFF");
+  printf("Readout Frame Length(ns)             : %f\n", getROFrameLength());
+  printf("Strobe delay (ns)                    : %f\n", getStrobeDelay());
+  printf("Strobe length (ns)                   : %f\n", getStrobeLength());
+  printf("IB Threshold (N electrons)           : %d\n", getIBChargeThreshold());
+  printf("OB Threshold (N electrons)           : %d\n", getChargeThreshold());
+  printf("Min N electrons to account for IB    : %d\n", getIBMinChargeToAccount());
+  printf("Min N electrons to account for OB    : %d\n", getMinChargeToAccount());
+  printf("Number of charge sharing steps of IB : %d\n", getIBNSimSteps());
+  printf("Number of charge sharing steps of OB : %d\n", getNSimSteps());
+  printf("ELoss to N electrons factor          : %e\n", getEnergyToNElectrons());
+  printf("Noise level per pixel of IB          : %e\n", getIBNoisePerPixel());
+  printf("Noise level per pixel of OB          : %e\n", getNoisePerPixel());
+  printf("Charge time-response:\n");
   getSignalShape().print();
 }
 
+void DigiParams::setIBSimResponse(o2::its3::ChipSimResponse* response)
+{
+  mIBSimResponse = response;
+  if (mIBSimResponse) {
+    mIBSimResponse->computeCentreFromData();
+  }
+}
+
 } // namespace o2::its3
diff --git a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
index 3c75bf3e8f680..1d1d15a91f89b 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
@@ -27,7 +27,8 @@
 #include <numeric>
 
 using o2::itsmft::Hit;
-using SegmentationAlpide = o2::itsmft::SegmentationAlpide;
+using SegmentationOB = o2::itsmft::SegmentationAlpide;
+using SegmentationIB = o2::its3::SegmentationMosaix;
 using o2::itsmft::AlpideRespSimMat;
 using o2::itsmft::PreDigit;
 
@@ -46,8 +47,8 @@ void Digitizer::init()
   }
 
   if (!mParams.hasResponseFunctions()) {
-    auto loadSetResponseFunc = [&](const char* name, const char* fileIB, const char* nameIB, const char* fileOB, const char* nameOB) {
-      LOGP(info, "Loading response function for {}: IB={}:{} ; OB={}:{}", name, nameIB, fileIB, nameOB, fileOB);
+    auto loadSetResponseFunc = [&](const char* fileIB, const char* nameIB, const char* fileOB, const char* nameOB) {
+      LOGP(info, "Loading response function IB={}:{} ; OB={}:{}", nameIB, fileIB, nameOB, fileOB);
       auto fIB = TFile::Open(fileIB, "READ");
       if (!fIB || fIB->IsZombie() || !fIB->IsOpen()) {
         LOGP(fatal, "Cannot open file {}", fileIB);
@@ -56,7 +57,7 @@ void Digitizer::init()
       if (!fOB || fOB->IsZombie() || !fOB->IsOpen()) {
         LOGP(fatal, "Cannot open file {}", fileOB);
       }
-      mParams.setIBSimResponse(mSimRespIB = fIB->Get<o2::itsmft::AlpideSimResponse>(nameIB));
+      mParams.setIBSimResponse(mSimRespIB = fIB->Get<o2::its3::ChipSimResponse>(nameIB));
       mParams.setOBSimResponse(mSimRespOB = fOB->Get<o2::itsmft::AlpideSimResponse>(nameOB));
       fIB->Close();
       fOB->Close();
@@ -64,25 +65,27 @@ void Digitizer::init()
 
     if (const auto& func = ITS3Params::Instance().chipResponseFunction; func == "Alpide") {
       constexpr const char* responseFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
-      loadSetResponseFunc("Alpide", responseFile, "response0", responseFile, "response1");
-      mSimRespIBShift = mSimRespIB->getDepthMax() - SegmentationMosaix::SensorLayerThickness / 2.f + 10.e-4f;
-      mSimRespOBShift = mSimRespOB->getDepthMax() - SegmentationAlpide::SensorLayerThickness / 2.f;
+      loadSetResponseFunc(responseFile, "response0", responseFile, "response0");
+      mSimRespIBScaleX = o2::itsmft::SegmentationAlpide::PitchRow / SegmentationIB::PitchRow;
+      mSimRespIBScaleZ = o2::itsmft::SegmentationAlpide::PitchCol / SegmentationIB::PitchCol;
     } else if (func == "APTS") {
       constexpr const char* responseFileIB = "$(O2_ROOT)/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/APTSResponseData.root";
       constexpr const char* responseFileOB = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
-      loadSetResponseFunc("APTS", responseFileIB, "response1", responseFileOB, "response1");
-      mSimRespIBShift = mSimRespIB->getDepthMax() + (float)constants::pixelarray::pixels::apts::responseYShift;
-      mSimRespOBShift = mSimRespOB->getDepthMax() - SegmentationAlpide::SensorLayerThickness / 2.f;
-      mSimRespIBScaleX = 0.5f * constants::pixelarray::pixels::apts::pitchX / SegmentationMosaix::PitchRow;
-      mSimRespIBScaleZ = 0.5f * constants::pixelarray::pixels::apts::pitchZ / SegmentationMosaix::PitchCol;
+      loadSetResponseFunc(responseFileIB, "response1", responseFileOB, "response0");
+      mSimRespIBScaleX = constants::pixelarray::pixels::apts::pitchX / SegmentationIB::PitchRow;
+      mSimRespIBScaleZ = constants::pixelarray::pixels::apts::pitchZ / SegmentationIB::PitchCol;
       mSimRespIBOrientation = true;
     } else {
       LOGP(fatal, "ResponseFunction '{}' not implemented!", func);
     }
+    mSimRespIBShift = mSimRespIB->getDepthMax() - constants::silicon::thickness / 2.f;
+    mSimRespOBShift = mSimRespOB->getDepthMax() - SegmentationOB::SensorLayerThickness / 2.f;
   }
+
   mParams.print();
-  LOGP(info, "IBShift = {} ; OBShift = {}", mSimRespIBShift, mSimRespOBShift);
-  LOGP(info, "IB-Scale: X={} ; Z={}", mSimRespIBScaleX, mSimRespIBScaleZ);
+  LOGP(info, "IB shift = {} ; OB shift = {}", mSimRespIBShift, mSimRespOBShift);
+  LOGP(info, "IB pixel scale on x = {} ; z = {}", mSimRespIBScaleX, mSimRespIBScaleZ);
+  LOGP(info, "IB response orientation: {}", mSimRespIBOrientation ? "flipped" : "normal");
   mIRFirstSampledTF = o2::raw::HBFUtils::Instance().getFirstSampledTFIR();
 }
 
@@ -173,11 +176,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
     auto& extra = *(mExtraBuff.front().get());
     for (size_t iChip{0}; iChip < mChips.size(); ++iChip) {
       auto& chip = mChips[iChip];
-      if (constants::detID::isDetITS3(iChip)) { // Check if this is a chip of ITS3
-        chip.addNoise(mROFrameMin, mROFrameMin, &mParams, SegmentationMosaix::NRows, SegmentationMosaix::NCols);
-      } else {
-        chip.addNoise(mROFrameMin, mROFrameMin, &mParams);
-      }
+      chip.addNoise(mROFrameMin, mROFrameMin, &mParams);
       auto& buffer = chip.getPreDigits();
       if (buffer.empty()) {
         continue;
@@ -190,7 +189,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
           break; // is the digit ROFrame from the key > the max requested frame
         }
         auto& preDig = iter->second; // preDigit
-        if (preDig.charge >= mParams.getChargeThreshold()) {
+        if (preDig.charge >= (chip.isIB() ? mParams.getIBChargeThreshold() : mParams.getChargeThreshold())) {
           int digID = mDigits->size();
           mDigits->emplace_back(chip.getChipIndex(), preDig.row, preDig.col, preDig.charge);
           mMCLabels->addElement(digID, preDig.labelRef.label);
@@ -257,16 +256,15 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   }
 
   // here we start stepping in the depth of the sensor to generate charge diffision
-  float nStepsInv = mParams.getNSimStepsInv();
-  int nSteps = mParams.getNSimSteps();
   int detID{hit.GetDetectorID()};
   int layer = mGeometry->getLayer(detID);
   const auto& matrix = mGeometry->getMatrixL2G(detID);
-  bool innerBarrel{layer < 3};
+  int nSteps = chip.isIB() ? mParams.getIBNSimSteps() : mParams.getNSimSteps();
+  float nStepsInv = chip.isIB() ? mParams.getIBNSimStepsInv() : mParams.getNSimStepsInv();
   math_utils::Vector3D<float> xyzLocS, xyzLocE;
   xyzLocS = matrix ^ (hit.GetPosStart()); // Global hit coordinates to local detector coordinates
   xyzLocE = matrix ^ (hit.GetPos());
-  if (innerBarrel) {
+  if (chip.isIB()) {
     // transform the point on the curved surface to a flat one
     float xFlatE{0.f}, yFlatE{0.f}, xFlatS{0.f}, yFlatS{0.f};
     mIBSegmentations[layer].curvedToFlat(xyzLocS.X(), xyzLocS.Y(), xFlatS, yFlatS);
@@ -284,7 +282,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   xyzLocS += stepH; // Adjust start position to the middle of the first step
   xyzLocE -= stepH; // Adjust end position to the middle of the last step
   int rowS = -1, colS = -1, rowE = -1, colE = -1, nSkip = 0;
-  if (innerBarrel) {
+  if (chip.isIB()) {
     // get entrance pixel row and col
     while (!mIBSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
       if (++nSkip >= nSteps) {
@@ -301,14 +299,14 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
     }
   } else {
     // get entrance pixel row and col
-    while (!SegmentationAlpide::localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
+    while (!SegmentationOB::localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
       if (++nSkip >= nSteps) {
         return; // did not enter to sensitive matrix
       }
       xyzLocS += step;
     }
     // get exit pixel row and col
-    while (!SegmentationAlpide::localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
+    while (!SegmentationOB::localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
       if (++nSkip >= nSteps) {
         return; // did not enter to sensitive matrix
       }
@@ -327,8 +325,8 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   rowE += AlpideRespSimMat::NPix / 2;
   rowS = std::max(rowS, 0);
 
-  const int maxNrows{innerBarrel ? SegmentationMosaix::NRows : SegmentationAlpide::NRows};
-  const int maxNcols{innerBarrel ? SegmentationMosaix::NCols : SegmentationAlpide::NCols};
+  const int maxNrows{chip.isIB() ? SegmentationIB::NRows : SegmentationOB::NRows};
+  const int maxNcols{chip.isIB() ? SegmentationIB::NCols : SegmentationOB::NCols};
 
   rowE = std::min(rowE, maxNrows - 1);
   colS -= AlpideRespSimMat::NPix / 2;
@@ -352,22 +350,22 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   // take into account that the AlpideSimResponse depth defintion has different min/max boundaries
   // although the max should coincide with the surface of the epitaxial layer, which in the chip
   // local coordinates has Y = +SensorLayerThickness/2
-  xyzLocS.SetY(xyzLocS.Y() + ((innerBarrel) ? mSimRespIBShift : mSimRespOBShift));
+  xyzLocS.SetY(xyzLocS.Y() + ((chip.isIB()) ? mSimRespIBShift : mSimRespOBShift));
 
   // collect charge in evey pixel which might be affected by the hit
   for (int iStep = nSteps; iStep--;) {
     // Get the pixel ID
-    if (innerBarrel) {
+    if (chip.isIB()) {
       mIBSegmentations[layer].localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
     } else {
-      SegmentationAlpide::localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
+      SegmentationOB::localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
     }
     if (row != rowPrev || col != colPrev) { // update pixel and coordinates of its center
-      if (innerBarrel) {
+      if (chip.isIB()) {
         if (!mIBSegmentations[layer].detectorToLocal(row, col, cRowPix, cColPix)) {
           continue;
         }
-      } else if (!SegmentationAlpide::detectorToLocal(row, col, cRowPix, cColPix)) {
+      } else if (!SegmentationOB::detectorToLocal(row, col, cRowPix, cColPix)) {
         continue; // should not happen
       }
       rowPrev = row;
@@ -377,13 +375,13 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
     // note that response needs coordinates along column row (locX) (locZ) then depth (locY)
     float rowMax{}, colMax{};
     const AlpideRespSimMat* rspmat{nullptr};
-    if (innerBarrel) {
-      rowMax = 0.5f * SegmentationMosaix::PitchRow;
-      colMax = 0.5f * SegmentationMosaix::PitchCol;
+    if (chip.isIB()) {
+      rowMax = 0.5f * SegmentationIB::PitchRow * mSimRespIBScaleX;
+      colMax = 0.5f * SegmentationIB::PitchCol * mSimRespIBScaleZ;
       rspmat = mSimRespIB->getResponse(mSimRespIBScaleX * (xyzLocS.X() - cRowPix), mSimRespIBScaleZ * (xyzLocS.Z() - cColPix), xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
     } else {
-      rowMax = 0.5f * SegmentationAlpide::PitchRow;
-      colMax = 0.5f * SegmentationAlpide::PitchCol;
+      rowMax = 0.5f * SegmentationOB::PitchRow;
+      colMax = 0.5f * SegmentationOB::PitchCol;
       rspmat = mSimRespOB->getResponse(xyzLocS.X() - cRowPix, xyzLocS.Z() - cColPix, xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
     }
 
@@ -402,7 +400,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
         if (colDest < 0 || colDest >= colSpan) {
           continue;
         }
-        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, ((innerBarrel && mSimRespIBOrientation) ? !flipRow : flipRow), flipCol);
+        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, ((chip.isIB() && mSimRespIBOrientation) ? !flipRow : flipRow), flipCol);
       }
     }
   }
@@ -419,7 +417,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
       }
       int nEle = gRandom->Poisson(nElectrons * nEleResp); // total charge in given pixel
       // ignore charge which have no chance to fire the pixel
-      if (nEle < mParams.getMinChargeToAccount()) {
+      if (nEle < (chip.isIB() ? mParams.getIBChargeThreshold() : mParams.getChargeThreshold())) {
         continue;
       }
       uint16_t colIS = icol + colS;
@@ -428,7 +426,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   }
 }
 
-void Digitizer::registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+void Digitizer::registerDigits(o2::its3::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
                                uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl)
 {
   // Register digits for given pixel, accounting for the possible signal contribution to
@@ -442,7 +440,7 @@ void Digitizer::registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t r
     tStrobe += mParams.getROFrameLength(); // for the next ROF
 
     // discard too small contributions, they have no chance to produce a digit
-    if (nEleROF < mParams.getMinChargeToAccount()) {
+    if (nEleROF < (chip.isIB() ? mParams.getIBChargeThreshold() : mParams.getChargeThreshold())) {
       continue;
     }
     if (roFr > mEventROFrameMax) {
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3DPLDigitizerParam.cxx b/Detectors/Upgrades/ITS3/simulation/src/ITS3DPLDigitizerParam.cxx
new file mode 100644
index 0000000000000..69314b8a0be9b
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3DPLDigitizerParam.cxx
@@ -0,0 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3Simulation/ITS3DPLDigitizerParam.h"
+
+O2ParamImpl(o2::its3::ITS3DPLDigitizerParam)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3SimulationLinkDef.h b/Detectors/Upgrades/ITS3/simulation/src/ITS3SimulationLinkDef.h
index fca3f5d63c2c4..921512193f98b 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ITS3SimulationLinkDef.h
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3SimulationLinkDef.h
@@ -20,5 +20,8 @@
 #pragma link C++ class o2::its3::DescriptorInnerBarrelITS3 + ;
 #pragma link C++ class o2::its3::DigiParams + ;
 #pragma link C++ class o2::its3::Digitizer + ;
+#pragma link C++ class o2::its3::ITS3DPLDigitizerParam + ;
+#pragma link C++ class o2::its3::ChipDigitsContainer + ;
+#pragma link C++ class o2::its3::ChipSimResponse + ;
 
 #endif
diff --git a/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
index 27f876f7bc24b..af0af091d40e8 100644
--- a/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
@@ -27,6 +27,7 @@
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITS3Simulation/Digitizer.h"
 #include "ITSMFTSimulation/DPLDigitizerParam.h"
+#include "ITS3Simulation/ITS3DPLDigitizerParam.h"
 #include "ITSMFTBase/DPLAlpideParam.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITS3Base/ITS3Params.h"
@@ -216,6 +217,7 @@ class ITS3DPLDigitizerTask : BaseDPLDigitizer
       mDigitizer.setGeometry(geom);
 
       const auto& dopt = o2::itsmft::DPLDigitizerParam<o2::detectors::DetID::ITS>::Instance();
+      const auto& doptIB = o2::its3::ITS3DPLDigitizerParam::Instance();
       pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("ITS_alppar");
       const auto& aopt = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
       digipar.setContinuous(dopt.continuous);
@@ -238,6 +240,11 @@ class ITS3DPLDigitizerTask : BaseDPLDigitizer
       digipar.setTimeOffset(dopt.timeOffset);
       digipar.setNSimSteps(dopt.nSimSteps);
 
+      // ITS3 inner barrel specific parameters
+      digipar.setIBChargeThreshold(doptIB.IBChargeThreshold);
+      digipar.setIBNSimSteps(doptIB.nIBSimSteps);
+      digipar.setIBNoisePerPixel(doptIB.IBNoisePerPixel);
+
       mROMode = digipar.isContinuous() ? o2::parameters::GRPObject::CONTINUOUS : o2::parameters::GRPObject::PRESENT;
       LOG(info) << mID.getName() << " simulated in "
                 << ((mROMode == o2::parameters::GRPObject::CONTINUOUS) ? "CONTINUOUS" : "TRIGGERED")

From e4399252ad5567ec680ed552fe5330ac9a51ce24 Mon Sep 17 00:00:00 2001
From: Hadi Hassan <hadi.hassan@cern.ch>
Date: Wed, 7 May 2025 13:09:49 +0300
Subject: [PATCH 0320/1764] Increasing the FOCAL volume based on the opening
 (#14241)

---
 Detectors/FOCAL/simulation/src/Detector.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/FOCAL/simulation/src/Detector.cxx b/Detectors/FOCAL/simulation/src/Detector.cxx
index dc71c1066afdf..164b531e60918 100644
--- a/Detectors/FOCAL/simulation/src/Detector.cxx
+++ b/Detectors/FOCAL/simulation/src/Detector.cxx
@@ -451,7 +451,7 @@ void Detector::ConstructGeometry()
   }
 
   float pars[4];
-  pars[0] = (mGeometry->getFOCALSizeX() + 2 * mGeometry->getMiddleTowerOffset()) / 2;
+  pars[0] = (mGeometry->getFOCALSizeX() + 2 * mGeometry->getMiddleTowerOffset() + mGeometry->getDetectorOpeningRight() + mGeometry->getDetectorOpeningLeft()) / 2;
   pars[1] = mGeometry->getFOCALSizeY() / 2;
   pars[2] = mGeometry->getFOCALSizeZ() / 2;
   // Add space to place 2 SiPad layers in front of ECAL
@@ -984,7 +984,7 @@ void Detector::CreateECALGeometry()
   // Place the towers in the ECAL
   // --- Place the ECAL in FOCAL
   float fcal_pars[4];
-  fcal_pars[0] = (geom->getFOCALSizeX() + 2. * geom->getMiddleTowerOffset()) / 2.;
+  fcal_pars[0] = (geom->getFOCALSizeX() + 2. * geom->getMiddleTowerOffset() + mGeometry->getDetectorOpeningRight() + mGeometry->getDetectorOpeningLeft()) / 2.;
   fcal_pars[1] = geom->getFOCALSizeY() / 2.;
   fcal_pars[2] = geom->getECALSizeZ() / 2.;
   fcal_pars[3] = 0.;

From a28ef94e0010e819d44d01b6dcdec64db75c6ff9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 7 May 2025 13:33:27 +0200
Subject: [PATCH 0321/1764] GPU TPC: Do not shift track in Z after the last fit

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 5bd8fd556aa3f..2524c01f0c00b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -407,7 +407,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         break; // bad chi2 for the whole track, stop the fit
       }
     }
-    if (((nWays - iWay) & 1) && (clusters[0].sector < 18) == (clusters[maxN - 1].sector < 18)) {
+    if (((nWays - iWay) & 1) && (iWay != nWays - 1) && (clusters[0].sector < 18) == (clusters[maxN - 1].sector < 18)) {
       ShiftZ2(clusters, clustersXYZ, merger, maxN);
     }
   }

From 8789c46104bc200f83a423b5840a783441e872fa Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 7 May 2025 16:02:04 +0200
Subject: [PATCH 0322/1764] GPU: Fix Debug Dump of deterministic mode without
 dEdx (was segfaulting in sync mode)

---
 GPU/GPUTracking/Base/GPUParam.cxx                 | 6 +++---
 GPU/GPUTracking/Base/GPUParam.h                   | 2 +-
 GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx         | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx     | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx       | 6 +++---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx     | 6 +++---
 7 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index b835e1b198eea..57f23792e472a 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -135,9 +135,9 @@ void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessi
     UpdateRun3ClusterErrors(p->param.tpcErrorParamY, p->param.tpcErrorParamZ);
   }
   if (w) {
-    par.dodEdx = dodEdxDownscaled = w->steps.isSet(GPUDataTypes::RecoStep::TPCdEdx);
-    if (par.dodEdx && p && p->tpcDownscaledEdx != 0) {
-      dodEdxDownscaled = (rand() % 100) < p->tpcDownscaledEdx;
+    par.dodEdx = dodEdxEnabled = w->steps.isSet(GPUDataTypes::RecoStep::TPCdEdx);
+    if (dodEdxEnabled && p && p->tpcDownscaledEdx != 0) {
+      dodEdxEnabled = (rand() % 100) < p->tpcDownscaledEdx;
     }
   }
   if (d) {
diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 4b77628c88775..076d25d72d178 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -54,7 +54,7 @@ struct GPUParam_t {
   float bzCLight;
   float qptB5Scaler;
 
-  int8_t dodEdxDownscaled;
+  int8_t dodEdxEnabled;
   int32_t continuousMaxTimeBin;
   int32_t tpcCutTimeBin;
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 84835a1695071..a38148ccb375a 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -256,7 +256,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
       }
       GPUMemCpy(RecoStep::TPCMerging, Merger.OutputTracks(), MergerShadowAll.OutputTracks(), Merger.NOutputTracks() * sizeof(*Merger.OutputTracks()), outputStream, 0, nullptr, waitEvent);
       waitEvent = nullptr;
-      if (param().dodEdxDownscaled) {
+      if (param().dodEdxEnabled) {
         GPUMemCpy(RecoStep::TPCMerging, Merger.OutputTracksdEdx(), MergerShadowAll.OutputTracksdEdx(), Merger.NOutputTracks() * sizeof(*Merger.OutputTracksdEdx()), outputStream, 0);
       }
       GPUMemCpy(RecoStep::TPCMerging, Merger.Clusters(), MergerShadowAll.Clusters(), Merger.NOutputTrackClusters() * sizeof(*Merger.Clusters()), outputStream, 0);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index b6241ad36b5de..6e7de7ee48ca6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -299,7 +299,7 @@ void* GPUTPCGMMerger::SetPointersRefitScratch(void* mem)
 void* GPUTPCGMMerger::SetPointersOutput(void* mem)
 {
   computePointerWithAlignment(mem, mOutputTracks, mNMaxTracks);
-  if (mRec->GetParam().dodEdxDownscaled) {
+  if (mRec->GetParam().dodEdxEnabled) {
     computePointerWithAlignment(mem, mOutputTracksdEdx, mNMaxTracks);
     computePointerWithAlignment(mem, mOutputTracksdEdxAlt, mNMaxTracks);
   }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 2f8fbecadce5f..ac55f423b1c42 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -203,7 +203,7 @@ void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
     const auto& p = trk.GetParam();
     const auto& po = trk.OuterParam();
     out << "  Track " << i << ": OK " << trk.OK() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTZOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << " / " << trk.NClustersFitted() << " Cov " << p.GetErr2Y() << "/" << p.GetErr2Z()
-        << " dEdx " << (trk.OK() ? mOutputTracksdEdx[i].dEdxTotTPC : -1.f) << "/" << (trk.OK() ? mOutputTracksdEdx[i].dEdxMaxTPC : -1.f)
+        << " dEdx " << (trk.OK() && Param().dodEdxEnabled ? mOutputTracksdEdx[i].dEdxTotTPC : -1.f) << "/" << (trk.OK() && Param().dodEdxEnabled ? mOutputTracksdEdx[i].dEdxMaxTPC : -1.f)
         << " Outer " << po.P[0] << "/" << po.P[1] << "/" << po.P[2] << "/" << po.P[3] << "/" << po.P[4] << "\n";
   }
   out << std::setprecision(ss);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index ea219a02a1887..9dc6ddc59c2b4 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -44,7 +44,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
 
   constexpr uint8_t flagsReject = getFlagsReject();
   const uint32_t flagsRequired = getFlagsRequired(merger.Param().rec);
-  bool cutOnTrackdEdx = merger.Param().par.dodEdx && merger.Param().dodEdxDownscaled && merger.Param().rec.tpc.minTrackdEdxMax2Tot > 0.f;
+  bool cutOnTrackdEdx = merger.Param().par.dodEdx && merger.Param().dodEdxEnabled && merger.Param().rec.tpc.minTrackdEdxMax2Tot > 0.f;
 
   GPUTPCGMMerger::tmpSort* GPUrestrict() trackSort = merger.TrackSortO2();
   uint2* GPUrestrict() tmpData = merger.ClusRefTmp();
@@ -130,7 +130,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
 
     oTrack.setChi2(tracks[i].GetParam().GetChi2());
     auto& outerPar = tracks[i].OuterParam();
-    if (merger.Param().par.dodEdx && merger.Param().dodEdxDownscaled) {
+    if (merger.Param().par.dodEdx && merger.Param().dodEdxEnabled) {
       oTrack.setdEdx(tracksdEdx[i]);
       oTrack.setdEdxAlt(tracksdEdxAlt[i]);
     }
@@ -148,7 +148,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
        outerPar.C[6], outerPar.C[7], outerPar.C[8], outerPar.C[9], outerPar.C[10], outerPar.C[11],
        outerPar.C[12], outerPar.C[13], outerPar.C[14]}));
 
-    if (merger.Param().par.dodEdx && merger.Param().dodEdxDownscaled && merger.Param().rec.tpc.enablePID) {
+    if (merger.Param().par.dodEdx && merger.Param().dodEdxEnabled && merger.Param().rec.tpc.enablePID) {
       PIDResponse pidResponse{};
       auto pid = pidResponse.getMostProbablePID(oTrack, merger.Param().rec.tpc.PID_EKrangeMin, merger.Param().rec.tpc.PID_EKrangeMax, merger.Param().rec.tpc.PID_EPrangeMin, merger.Param().rec.tpc.PID_EPrangeMax, merger.Param().rec.tpc.PID_EDrangeMin, merger.Param().rec.tpc.PID_EDrangeMax, merger.Param().rec.tpc.PID_ETrangeMin, merger.Param().rec.tpc.PID_ETrangeMax, merger.Param().rec.tpc.PID_useNsigma, merger.Param().rec.tpc.PID_sigma);
       auto pidRemap = merger.Param().rec.tpc.PID_remap[pid];
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 2524c01f0c00b..f5bfbe985fb8c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -216,7 +216,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           continue;
         }
       } else if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
-        bool dodEdx = param.par.dodEdx && param.dodEdxDownscaled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2 && cluster.leg == clusters[maxN - 1].leg;
+        bool dodEdx = param.par.dodEdx && param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2 && cluster.leg == clusters[maxN - 1].leg;
         dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, cluster.leg == clusters[maxN - 1].leg, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
         if (dodEdx) {
           dEdx.fillSubThreshold(lastRow - wayDirection);
@@ -367,7 +367,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           CADEBUG(printf("Reinit linearization\n"));
           prop.SetTrack(this, prop.GetAlpha());
         }
-        if (param.par.dodEdx && param.dodEdxDownscaled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg) { // TODO: Costimize flag to remove, and option to remove double-clusters
+        if (param.par.dodEdx && param.dodEdxEnabled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg) { // TODO: Costimize flag to remove, and option to remove double-clusters
           bool acc = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMask) == 0, accAlt = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) == 0;
           if (acc || accAlt) {
             float qtot = 0, qmax = 0, pad = 0, relTime = 0;
@@ -426,7 +426,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
   // TODO: we have looping tracks here with 0 accepted clusters in the primary leg. In that case we should refit the track using only the primary leg.
 
-  if (param.par.dodEdx && param.dodEdxDownscaled) {
+  if (param.par.dodEdx && param.dodEdxEnabled) {
     dEdx.computedEdx(merger->OutputTracksdEdx()[iTrk], param);
     dEdxAlt.computedEdx(merger->OutputTracksdEdxAlt()[iTrk], param);
   }

From 42e1f6ac595fe09ada3cf36ae4baddd2b03aba44 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 7 May 2025 20:00:01 +0200
Subject: [PATCH 0323/1764] GPU: debug files of multiple GPU Reconstruciton
 instances shall not overwrite each other

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx  | 1 +
 GPU/GPUTracking/Base/GPUReconstruction.h    | 2 ++
 GPU/GPUTracking/Global/GPUChainTracking.cxx | 3 ++-
 3 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index ad2ee2e840d00..3ef995b9f9561 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -87,6 +87,7 @@ GPUReconstruction::GPUReconstruction(const GPUSettingsDeviceBackend& cfg) : mHos
       throw std::invalid_argument("Cannot be slave to a slave");
     }
     mMaster = cfg.master;
+    mSlaveId = cfg.master->mSlaves.size();
     cfg.master->mSlaves.emplace_back(this);
   }
   param().SetDefaults(mGRPSettings.get());
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index f5b39cb370b9e..d5c0b8e828087 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -190,6 +190,7 @@ class GPUReconstruction
   // Helpers to fetch processors from other shared libraries
   virtual void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame>* timeFrame);
   bool slavesExist() { return mSlaves.size() || mMaster; }
+  int slaveId() { return mSlaveId; }
 
   // Getters / setters for parameters
   DeviceType GetDeviceType() const;
@@ -339,6 +340,7 @@ class GPUReconstruction
 
   GPUReconstruction* mMaster = nullptr;    // Ptr to a GPUReconstruction object serving as master, sharing GPU memory, events, etc.
   std::vector<GPUReconstruction*> mSlaves; // Ptr to slave GPUReconstructions
+  int mSlaveId = -1;                       // Id of this slave (-1 for master)
 
   // Others
   bool mInitialized = false;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index a3f9b996e070d..f8d4165477220 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -378,7 +378,8 @@ int32_t GPUChainTracking::Init()
   }
 
   if (GetProcessingSettings().debugLevel >= 6) {
-    mDebugFile->open(mRec->IsGPU() ? "GPU.out" : "CPU.out");
+    std::string filename = std::string(mRec->IsGPU() ? "GPU" : "CPU") + (mRec->slaveId() != -1 ? (std::string("_slave") + std::to_string(mRec->slaveId())) : std::string(mRec->slavesExist() ? "_master" : "")) + ".out";
+    mDebugFile->open(filename.c_str());
   }
 
   return 0;

From 689970d53e9172450ec9ee1b0c14e125df741e8a Mon Sep 17 00:00:00 2001
From: jokonig <jokonig@cern.ch>
Date: Wed, 7 May 2025 15:09:50 +0200
Subject: [PATCH 0324/1764] [EMCAL-539] Fix in trigger simulation to not accept
 every event as MB

- Only events where EMCal is triggered should be given the trigger flag. This was previously not the case
---
 .../include/EMCALSimulation/Digitizer.h         |  1 +
 .../EMCALSimulation/DigitsWriteoutBuffer.h      | 17 +++++++++++++++--
 .../EMCAL/workflow/src/EMCALDigitizerSpec.cxx   | 12 +++++++-----
 3 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/Detectors/EMCAL/simulation/include/EMCALSimulation/Digitizer.h b/Detectors/EMCAL/simulation/include/EMCALSimulation/Digitizer.h
index ad296a4d65a58..66f85184c98e6 100644
--- a/Detectors/EMCAL/simulation/include/EMCALSimulation/Digitizer.h
+++ b/Detectors/EMCAL/simulation/include/EMCALSimulation/Digitizer.h
@@ -72,6 +72,7 @@ class Digitizer : public TObject
   double getEventTime() const { return mDigits.getEventTime(); }
   bool isLive(double t) const { return mDigits.isLive(t); }
   bool isLive() const { return mDigits.isLive(); }
+  bool isCurrentEventTriggered() const { return mDigits.isCurrentEventTriggered(); }
 
   void setDebugStreaming(bool doStreaming) { mEnableDebugStreaming = doStreaming; }
 
diff --git a/Detectors/EMCAL/simulation/include/EMCALSimulation/DigitsWriteoutBuffer.h b/Detectors/EMCAL/simulation/include/EMCALSimulation/DigitsWriteoutBuffer.h
index b6f486ddf2add..5713f2ef18ad9 100644
--- a/Detectors/EMCAL/simulation/include/EMCALSimulation/DigitsWriteoutBuffer.h
+++ b/Detectors/EMCAL/simulation/include/EMCALSimulation/DigitsWriteoutBuffer.h
@@ -60,8 +60,21 @@ class DigitsWriteoutBuffer
 
   double getTriggerTime() const { return mTriggerTime; }
   double getEventTime() const { return mLastEventTime; }
-  bool isLive(double t) const { return ((t - mTriggerTime) < mLiveTime || (t - mTriggerTime) >= (mLiveTime + mBusyTime - mPreTriggerTime)); }
-  bool isLive() const { return ((mLastEventTime - mTriggerTime) < mLiveTime || (mLastEventTime - mTriggerTime) >= (mLiveTime + mBusyTime - mPreTriggerTime)); }
+  bool isLive(double t) const
+  {
+    return ((t - mTriggerTime) < mLiveTime || (t - mTriggerTime) >= (mLiveTime + mBusyTime - mPreTriggerTime));
+  }
+  bool isLive() const
+  {
+    return ((mLastEventTime - mTriggerTime) < (mLiveTime - mPreTriggerTime) || (mLastEventTime - mTriggerTime) >= (mLiveTime + mBusyTime - mPreTriggerTime));
+  }
+
+  /// Check if current collision was triggered
+  /// \return true if event was triggered
+  bool isCurrentEventTriggered() const
+  {
+    return mLastEventTime == mTriggerTime;
+  }
 
   // function returns true if the collision occurs 600ns before the readout window is open
   // Look here for more details https://alice.its.cern.ch/jira/browse/EMCAL-681
diff --git a/Detectors/EMCAL/workflow/src/EMCALDigitizerSpec.cxx b/Detectors/EMCAL/workflow/src/EMCALDigitizerSpec.cxx
index 5de966d1b6a4c..cabdb2c74d818 100644
--- a/Detectors/EMCAL/workflow/src/EMCALDigitizerSpec.cxx
+++ b/Detectors/EMCAL/workflow/src/EMCALDigitizerSpec.cxx
@@ -332,15 +332,17 @@ void DigitizerSpec::run(framework::ProcessingContext& ctx)
     if (!trigger.any()) {
       continue;
     }
-    // Trigger sim: Prepare CTP input digit
-    acceptedTriggers.push_back(std::make_tuple(timesview[collID], trigger));
-    LOG(debug) << "EMCAL TRU simulation: Sending trg = " << trigger << " to CTP";
 
     mDigitizer.setEventTime(timesview[collID], trigger.any());
-
-    if (!mDigitizer.isLive()) {
+    if (!mDigitizer.isCurrentEventTriggered()) {
+      LOG(debug) << "reject collision";
       continue;
     }
+    LOG(debug) << "accept collision";
+
+    // Trigger sim: Prepare CTP input digit
+    acceptedTriggers.push_back(std::make_tuple(timesview[collID], trigger));
+    LOG(debug) << "EMCAL TRU simulation: Sending trg = " << trigger << " to CTP";
 
     // for each collision, loop over the constituents event and source IDs
     // (background signal merging is basically taking place here)

From 440e50040510d18bcc9742e75bfc2a4898a17c8c Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 8 May 2025 18:18:01 +0200
Subject: [PATCH 0325/1764] =?UTF-8?q?Revert=20"DPL=20Analysis:=20prevent?=
 =?UTF-8?q?=20slice=20cache=20from=20updating=20when=20not=20required=20by?=
 =?UTF-8?q?=20=E2=80=A6"=20(#14252)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Framework/Core/include/Framework/ASoA.h       | 12 ++---
 .../Core/include/Framework/AnalysisManagers.h | 14 ++----
 .../Core/include/Framework/AnalysisTask.h     | 22 ++++-----
 .../Framework/ArrowTableSlicingCache.h        | 45 ++++++-----------
 .../Core/include/Framework/GroupSlicer.h      |  2 +-
 Framework/Core/src/ASoA.cxx                   |  2 +-
 Framework/Core/src/ArrowSupport.cxx           | 19 ++++---
 Framework/Core/src/ArrowTableSlicingCache.cxx | 49 +++++++++----------
 Framework/Core/test/test_GroupSlicer.cxx      |  4 +-
 9 files changed, 73 insertions(+), 96 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 2e478a8ca64a6..e098cd89f6d5d 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1400,10 +1400,10 @@ namespace o2::framework
 
 struct PreslicePolicyBase {
   const std::string binding;
-  Entry bindingKey;
+  StringPair bindingKey;
 
   bool isMissing() const;
-  Entry const& getBindingKey() const;
+  StringPair const& getBindingKey() const;
 };
 
 struct PreslicePolicySorted : public PreslicePolicyBase {
@@ -1428,7 +1428,7 @@ struct PresliceBase : public Policy {
   const std::string binding;
 
   PresliceBase(expressions::BindingNode index_)
-    : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, Entry(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
+    : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, std::make_pair(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
   {
   }
 
@@ -1508,7 +1508,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.key.c_str());
+      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.second.c_str());
     }
   }
   uint64_t offset = 0;
@@ -1545,7 +1545,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.key.c_str());
+      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.second.c_str());
     }
   }
   auto selection = container.getSliceFor(value);
@@ -1574,7 +1574,7 @@ auto doFilteredSliceBy(T const* table, o2::framework::PresliceBase<C, framework:
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<T>().data(), container.bindingKey.key.c_str());
+      missingOptionalPreslice(getLabelFromType<T>().data(), container.bindingKey.second.c_str());
     }
   }
   uint64_t offset = 0;
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index e310f3eef990c..330eaf01f0be4 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -534,43 +534,39 @@ static void setGroupedCombination(C& comb, TG& grouping, std::tuple<Ts...>& asso
 /// Preslice handling
 template <typename T>
   requires(!is_preslice<T>)
-bool registerCache(T&, Cache&, Cache&)
+bool registerCache(T&, std::vector<StringPair>&, std::vector<StringPair>&)
 {
   return false;
 }
 
 template <is_preslice T>
   requires std::same_as<typename T::policy_t, framework::PreslicePolicySorted>
-bool registerCache(T& preslice, Cache& bsks, Cache&)
+bool registerCache(T& preslice, std::vector<StringPair>& bsks, std::vector<StringPair>&)
 {
   if constexpr (T::optional) {
     if (preslice.binding == "[MISSING]") {
       return true;
     }
   }
-  auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); });
+  auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); });
   if (locate == bsks.end()) {
     bsks.emplace_back(preslice.getBindingKey());
-  } else if (locate->enabled == false) {
-    locate->enabled = true;
   }
   return true;
 }
 
 template <is_preslice T>
   requires std::same_as<typename T::policy_t, framework::PreslicePolicyGeneral>
-bool registerCache(T& preslice, Cache&, Cache& bsksU)
+bool registerCache(T& preslice, std::vector<StringPair>&, std::vector<StringPair>& bsksU)
 {
   if constexpr (T::optional) {
     if (preslice.binding == "[MISSING]") {
       return true;
     }
   }
-  auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); });
+  auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); });
   if (locate == bsksU.end()) {
     bsksU.emplace_back(preslice.getBindingKey());
-  } else if (locate->enabled == false) {
-    locate->enabled = true;
   }
   return true;
 }
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 9bd2e2af173cc..c7f3da1948c62 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -66,20 +66,20 @@ concept is_enumeration = is_enumeration_v<std::decay_t<T>>;
 namespace {
 struct AnalysisDataProcessorBuilder {
   template <typename G, typename... Args>
-  static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled)
+  static void addGroupingCandidates(std::vector<StringPair>& bk, std::vector<StringPair>& bku)
   {
-    [&bk, &bku, enabled]<typename... As>(framework::pack<As...>) mutable {
+    [&bk, &bku]<typename... As>(framework::pack<As...>) mutable {
       std::string key;
       if constexpr (soa::is_iterator<std::decay_t<G>>) {
         key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
       }
-      ([&bk, &bku, &key, enabled]() mutable {
+      ([&bk, &bku, &key]() mutable {
         if constexpr (soa::relatedByIndex<std::decay_t<G>, std::decay_t<As>>()) {
           auto binding = soa::getLabelFromTypeForKey<std::decay_t<As>>(key);
           if constexpr (o2::soa::is_smallgroups<std::decay_t<As>>) {
-            framework::updatePairList(bku, binding, key, enabled);
+            framework::updatePairList(bku, binding, key);
           } else {
-            framework::updatePairList(bk, binding, key, enabled);
+            framework::updatePairList(bk, binding, key);
           }
         }
       }(),
@@ -147,7 +147,7 @@ struct AnalysisDataProcessorBuilder {
   /// helper to parse the process arguments
   /// 1. enumeration (must be the only argument)
   template <typename R, typename C, is_enumeration A>
-  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&, Cache&, Cache&)
+  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&, std::vector<StringPair>&, std::vector<StringPair>&)
   {
     std::vector<ConfigParamSpec> inputMetadata;
     // FIXME: for the moment we do not support begin, end and step.
@@ -156,17 +156,17 @@ struct AnalysisDataProcessorBuilder {
 
   /// 2. grouping case - 1st argument is an iterator
   template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, Cache& bk, Cache& bku)
+  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, std::vector<StringPair>& bk, std::vector<StringPair>& bku)
     requires(std::is_lvalue_reference_v<A> && (std::is_lvalue_reference_v<Args> && ...))
   {
-    addGroupingCandidates<A, Args...>(bk, bku, value);
+    addGroupingCandidates<A, Args...>(bk, bku);
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(A, Args...)>();
     addInputsAndExpressions<typename std::decay_t<A>::parent_t, Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 3. generic case
   template <typename R, typename C, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, Cache&, Cache&)
+  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, std::vector<StringPair>&, std::vector<StringPair>&)
     requires(std::is_lvalue_reference_v<Args> && ...)
   {
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Args...)>();
@@ -480,8 +480,8 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<InputSpec> inputs;
   std::vector<ConfigParamSpec> options;
   std::vector<ExpressionInfo> expressionInfos;
-  Cache bindingsKeys;
-  Cache bindingsKeysUnsorted;
+  std::vector<StringPair> bindingsKeys;
+  std::vector<StringPair> bindingsKeysUnsorted;
 
   /// make sure options and configurables are set before expression infos are created
   homogeneous_apply_refs([&options, &hash](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
diff --git a/Framework/Core/include/Framework/ArrowTableSlicingCache.h b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
index 292a67023fc5e..2edc23a63ce76 100644
--- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h
+++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
@@ -34,64 +34,51 @@ struct SliceInfoUnsortedPtr {
   gsl::span<int64_t const> getSliceFor(int value) const;
 };
 
-struct Entry {
-  std::string binding;
-  std::string key;
-  bool enabled;
-
-  Entry(std::string b, std::string k, bool e = true)
-    : binding{b},
-      key{k},
-      enabled{e}
-  {
-  }
-};
-
-using Cache = std::vector<Entry>;
+using StringPair = std::pair<std::string, std::string>;
 
-void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled);
+void updatePairList(std::vector<StringPair>& list, std::string const& binding, std::string const& key);
 
 struct ArrowTableSlicingCacheDef {
   constexpr static ServiceKind service_kind = ServiceKind::Global;
-  Cache bindingsKeys;
-  Cache bindingsKeysUnsorted;
+  std::vector<StringPair> bindingsKeys;
+  std::vector<StringPair> bindingsKeysUnsorted;
 
-  void setCaches(Cache&& bsks);
-  void setCachesUnsorted(Cache&& bsks);
+  void setCaches(std::vector<StringPair>&& bsks);
+  void setCachesUnsorted(std::vector<StringPair>&& bsks);
 };
 
 struct ArrowTableSlicingCache {
   constexpr static ServiceKind service_kind = ServiceKind::Stream;
 
-  Cache bindingsKeys;
+  std::vector<StringPair> bindingsKeys;
   std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int32Type>>> values;
   std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int64Type>>> counts;
 
-  Cache bindingsKeysUnsorted;
+  std::vector<StringPair> bindingsKeysUnsorted;
   std::vector<std::vector<int>> valuesUnsorted;
   std::vector<ListVector> groups;
 
-  ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted = {});
+  ArrowTableSlicingCache(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted = {});
 
   // set caching information externally
-  void setCaches(Cache&& bsks, Cache&& bsksUnsorted = {});
+  void setCaches(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted = {});
 
   // update slicing info cache entry (assumes it is already present)
   arrow::Status updateCacheEntry(int pos, std::shared_ptr<arrow::Table> const& table);
   arrow::Status updateCacheEntryUnsorted(int pos, std::shared_ptr<arrow::Table> const& table);
 
   // helper to locate cache position
-  std::pair<int, bool> getCachePos(Entry const& bindingKey) const;
-  int getCachePosSortedFor(Entry const& bindingKey) const;
-  int getCachePosUnsortedFor(Entry const& bindingKey) const;
+  std::pair<int, bool> getCachePos(StringPair const& bindingKey) const;
+  int getCachePosSortedFor(StringPair const& bindingKey) const;
+  int getCachePosUnsortedFor(StringPair const& bindingKey) const;
 
   // get slice from cache for a given value
-  SliceInfoPtr getCacheFor(Entry const& bindingKey) const;
-  SliceInfoUnsortedPtr getCacheUnsortedFor(Entry const& bindingKey) const;
+  SliceInfoPtr getCacheFor(StringPair const& bindingKey) const;
+  SliceInfoUnsortedPtr getCacheUnsortedFor(StringPair const& bindingKey) const;
   SliceInfoPtr getCacheForPos(int pos) const;
   SliceInfoUnsortedPtr getCacheUnsortedForPos(int pos) const;
 
-  static void validateOrder(Entry const& bindingKey, std::shared_ptr<arrow::Table> const& input);
+  static void validateOrder(StringPair const& bindingKey, std::shared_ptr<arrow::Table> const& input);
 };
 } // namespace o2::framework
 
diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h
index b8436314b057e..64b1d863c59e6 100644
--- a/Framework/Core/include/Framework/GroupSlicer.h
+++ b/Framework/Core/include/Framework/GroupSlicer.h
@@ -55,7 +55,7 @@ struct GroupSlicer {
     {
       constexpr auto index = framework::has_type_at_v<std::decay_t<T>>(associated_pack_t{});
       auto binding = o2::soa::getLabelFromTypeForKey<std::decay_t<T>>(mIndexColumnName);
-      auto bk = Entry(binding, mIndexColumnName);
+      auto bk = std::make_pair(binding, mIndexColumnName);
       if constexpr (!o2::soa::is_smallgroups<std::decay_t<T>>) {
         if (table.size() == 0) {
           return;
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index 5940bc0427225..810398747de88 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -197,7 +197,7 @@ bool PreslicePolicyBase::isMissing() const
   return binding == "[MISSING]";
 }
 
-Entry const& PreslicePolicyBase::getBindingKey() const
+StringPair const& PreslicePolicyBase::getBindingKey() const
 {
   return bindingKey;
 }
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 3b13e30581f70..12a4c7131e828 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -567,27 +567,26 @@ o2::framework::ServiceSpec ArrowSupport::arrowTableSlicingCacheSpec()
     .name = "arrow-slicing-cache",
     .uniqueId = CommonServices::simpleServiceId<ArrowTableSlicingCache>(),
     .init = [](ServiceRegistryRef services, DeviceState&, fair::mq::ProgOptions&) { return ServiceHandle{TypeIdHelpers::uniqueId<ArrowTableSlicingCache>(),
-                                                                                                         new ArrowTableSlicingCache(Cache{services.get<ArrowTableSlicingCacheDef>().bindingsKeys},
-                                                                                                                                    Cache{services.get<ArrowTableSlicingCacheDef>().bindingsKeysUnsorted}),
+                                                                                                         new ArrowTableSlicingCache(std::vector<std::pair<std::string, std::string>>{services.get<ArrowTableSlicingCacheDef>().bindingsKeys}, std::vector{services.get<ArrowTableSlicingCacheDef>().bindingsKeysUnsorted}),
                                                                                                          ServiceKind::Stream, typeid(ArrowTableSlicingCache).name()}; },
     .configure = CommonServices::noConfiguration(),
     .preProcessing = [](ProcessingContext& pc, void* service_ptr) {
       auto* service = static_cast<ArrowTableSlicingCache*>(service_ptr);
       auto& caches = service->bindingsKeys;
-      for (auto i = 0u; i < caches.size(); ++i) {
-        if (caches[i].enabled && pc.inputs().getPos(caches[i].binding.c_str()) >= 0) {
-          auto status = service->updateCacheEntry(i, pc.inputs().get<TableConsumer>(caches[i].binding.c_str())->asArrowTable());
+      for (auto i = 0; i < caches.size(); ++i) {
+        if (pc.inputs().getPos(caches[i].first.c_str()) >= 0) {
+          auto status = service->updateCacheEntry(i, pc.inputs().get<TableConsumer>(caches[i].first.c_str())->asArrowTable());
           if (!status.ok()) {
-            throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].binding.c_str(), caches[i].key.c_str());
+            throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].first.c_str(), caches[i].second.c_str());
           }
         }
       }
       auto& unsortedCaches = service->bindingsKeysUnsorted;
-      for (auto i = 0u; i < unsortedCaches.size(); ++i) {
-        if (unsortedCaches[i].enabled && pc.inputs().getPos(unsortedCaches[i].binding.c_str()) >= 0) {
-          auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get<TableConsumer>(unsortedCaches[i].binding.c_str())->asArrowTable());
+      for (auto i = 0; i < unsortedCaches.size(); ++i) {
+        if (pc.inputs().getPos(unsortedCaches[i].first.c_str()) >= 0) {
+          auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get<TableConsumer>(unsortedCaches[i].first.c_str())->asArrowTable());
           if (!status.ok()) {
-            throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].binding.c_str(), unsortedCaches[i].key.c_str());
+            throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].first.c_str(), unsortedCaches[i].second.c_str());
           }
         }
       } },
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 12df5ef6c080b..4b31f96e32fba 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -11,7 +11,6 @@
 
 #include "Framework/ArrowTableSlicingCache.h"
 #include "Framework/RuntimeError.h"
-#include "Framework/Logger.h"
 
 #include <arrow/compute/api_aggregate.h>
 #include <arrow/compute/kernel.h>
@@ -20,10 +19,10 @@
 namespace o2::framework
 {
 
-void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled = true)
+void updatePairList(std::vector<StringPair>& list, std::string const& binding, std::string const& key)
 {
-  if (std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.binding == binding) && (entry.key == key); }) == list.end()) {
-    list.emplace_back(binding, key, enabled);
+  if (std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.first == binding) && (entry.second == key); }) == list.end()) {
+    list.emplace_back(binding, key);
   }
 }
 
@@ -66,17 +65,17 @@ gsl::span<const int64_t> SliceInfoUnsortedPtr::getSliceFor(int value) const
   return {(*groups)[value].data(), (*groups)[value].size()};
 }
 
-void ArrowTableSlicingCacheDef::setCaches(Cache&& bsks)
+void ArrowTableSlicingCacheDef::setCaches(std::vector<StringPair>&& bsks)
 {
   bindingsKeys = bsks;
 }
 
-void ArrowTableSlicingCacheDef::setCachesUnsorted(Cache&& bsks)
+void ArrowTableSlicingCacheDef::setCachesUnsorted(std::vector<StringPair>&& bsks)
 {
   bindingsKeysUnsorted = bsks;
 }
 
-ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted)
+ArrowTableSlicingCache::ArrowTableSlicingCache(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted)
   : bindingsKeys{bsks},
     bindingsKeysUnsorted{bsksUnsorted}
 {
@@ -87,7 +86,7 @@ ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorte
   groups.resize(bindingsKeysUnsorted.size());
 }
 
-void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted)
+void ArrowTableSlicingCache::setCaches(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted)
 {
   bindingsKeys = bsks;
   bindingsKeysUnsorted = bsksUnsorted;
@@ -112,7 +111,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
   arrow::Datum value_counts;
   auto options = arrow::compute::ScalarAggregateOptions::Defaults();
   ARROW_ASSIGN_OR_RAISE(value_counts,
-                        arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].key)},
+                        arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].second)},
                                                      &options));
   auto pair = static_cast<arrow::StructArray>(value_counts.array());
   values[pos].reset();
@@ -129,11 +128,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
   if (table->num_rows() == 0) {
     return arrow::Status::OK();
   }
-  auto& [b, k, e] = bindingsKeysUnsorted[pos];
-  if (!e) {
-    LOG(debug) << "Update of disabled cache requested";
-    return arrow::Status::OK();
-  }
+  auto& [b, k] = bindingsKeysUnsorted[pos];
   auto column = table->GetColumnByName(k);
   auto row = 0;
   for (auto iChunk = 0; iChunk < column->num_chunks(); ++iChunk) {
@@ -144,7 +139,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
         if (std::find(valuesUnsorted[pos].begin(), valuesUnsorted[pos].end(), v) == valuesUnsorted[pos].end()) {
           valuesUnsorted[pos].push_back(v);
         }
-        if ((int)groups[pos].size() <= v) {
+        if (groups[pos].size() <= v) {
           groups[pos].resize(v + 1);
         }
         (groups[pos])[v].push_back(row);
@@ -156,7 +151,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
   return arrow::Status::OK();
 }
 
-std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const Entry& bindingKey) const
+std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const StringPair& bindingKey) const
 {
   auto pos = getCachePosSortedFor(bindingKey);
   if (pos != -1) {
@@ -166,41 +161,41 @@ std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const Entry& bindingKey
   if (pos != -1) {
     return {pos, false};
   }
-  throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
+  throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
 }
 
-int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const
+int ArrowTableSlicingCache::getCachePosSortedFor(StringPair const& bindingKey) const
 {
-  auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); });
+  auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); });
   if (locate != bindingsKeys.end()) {
     return std::distance(bindingsKeys.begin(), locate);
   }
   return -1;
 }
 
-int ArrowTableSlicingCache::getCachePosUnsortedFor(Entry const& bindingKey) const
+int ArrowTableSlicingCache::getCachePosUnsortedFor(StringPair const& bindingKey) const
 {
-  auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); });
+  auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); });
   if (locate_unsorted != bindingsKeysUnsorted.end()) {
     return std::distance(bindingsKeysUnsorted.begin(), locate_unsorted);
   }
   return -1;
 }
-SliceInfoPtr ArrowTableSlicingCache::getCacheFor(Entry const& bindingKey) const
+SliceInfoPtr ArrowTableSlicingCache::getCacheFor(StringPair const& bindingKey) const
 {
   auto [p, s] = getCachePos(bindingKey);
   if (!s) {
-    throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
+    throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
   }
 
   return getCacheForPos(p);
 }
 
-SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const Entry& bindingKey) const
+SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const StringPair& bindingKey) const
 {
   auto [p, s] = getCachePos(bindingKey);
   if (s) {
-    throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
+    throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
   }
 
   return getCacheUnsortedForPos(p);
@@ -229,9 +224,9 @@ SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedForPos(int pos) con
   };
 }
 
-void ArrowTableSlicingCache::validateOrder(Entry const& bindingKey, const std::shared_ptr<arrow::Table>& input)
+void ArrowTableSlicingCache::validateOrder(StringPair const& bindingKey, const std::shared_ptr<arrow::Table>& input)
 {
-  auto const& [target, key, enabled] = bindingKey;
+  auto const& [target, key] = bindingKey;
   auto column = input->GetColumnByName(key);
   auto array0 = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(0)->data());
   int32_t prev = 0;
diff --git a/Framework/Core/test/test_GroupSlicer.cxx b/Framework/Core/test/test_GroupSlicer.cxx
index 091c21eeae229..161939141e790 100644
--- a/Framework/Core/test/test_GroupSlicer.cxx
+++ b/Framework/Core/test/test_GroupSlicer.cxx
@@ -683,7 +683,7 @@ TEST_CASE("ArrowDirectSlicing")
 
   std::vector<arrow::Datum> slices;
   std::vector<uint64_t> offsts;
-  auto bk = Entry(soa::getLabelFromType<aod::Events>(), "fID");
+  auto bk = std::make_pair(soa::getLabelFromType<aod::Events>(), "fID");
   ArrowTableSlicingCache cache({bk});
   auto s = cache.updateCacheEntry(0, {evtTable});
   auto lcache = cache.getCacheFor(bk);
@@ -741,7 +741,7 @@ TEST_CASE("TestSlicingException")
   }
   auto evtTable = builderE.finalize();
 
-  auto bk = Entry(soa::getLabelFromType<aod::Events>(), "fID");
+  auto bk = std::make_pair(soa::getLabelFromType<aod::Events>(), "fID");
   ArrowTableSlicingCache cache({bk});
 
   try {

From 9647d481ee3e039dec060e2f005a49617e21d4e5 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 8 May 2025 00:18:02 +0200
Subject: [PATCH 0326/1764] GPU: Add debug dumps for compressed / uncompressed
 TPC clusters

---
 GPU/GPUTracking/CMakeLists.txt                |  1 +
 .../DataCompression/GPUTPCCompression.cxx     | 56 +++++++++++++
 .../DataCompression/GPUTPCCompression.h       |  4 +
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 GPU/GPUTracking/Global/GPUChain.h             | 31 +++-----
 GPU/GPUTracking/Global/GPUChainTracking.h     |  1 +
 .../Global/GPUChainTrackingClusterizer.cxx    | 19 ++---
 .../Global/GPUChainTrackingCompression.cxx    |  3 +
 .../Global/GPUChainTrackingDebug.h            | 79 +++++++++++++++++++
 .../GPUChainTrackingDebugAndProfiling.cxx     | 15 ++++
 .../Global/GPUChainTrackingMerger.cxx         | 19 ++---
 .../Global/GPUChainTrackingSectorTracker.cxx  | 15 ++--
 .../TPCClusterFinder/GPUTPCClusterFinder.h    |  1 +
 .../GPUTPCClusterFinderDump.cxx               |  2 +-
 14 files changed, 201 insertions(+), 47 deletions(-)
 create mode 100644 GPU/GPUTracking/Global/GPUChainTrackingDebug.h

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index b2852389398d0..2e26622d05291 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -138,6 +138,7 @@ set(HDRS_INSTALL
     Definitions/GPULogging.h
     Definitions/GPUSettingsList.h
     Global/GPUChainTrackingDefs.h
+    Global/GPUChainTrackingDebug.h
     Global/GPUChainTrackingGetters.inc
     Global/GPUErrorCodes.h
     Merger/GPUTPCGMBorderTrack.h
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index 2a0c5b58d8a83..a107f749ddd77 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -130,3 +130,59 @@ void GPUTPCCompression::SetMaxData(const GPUTrackingInOutPointers& io)
     mMaxClusters += 16 - (mMaxClusters % 16);
   }
 }
+
+void GPUTPCCompression::DumpCompressedClusters(std::ostream& out)
+{
+  const o2::tpc::CompressedClusters O = *mOutputFlat;
+  out << "\n\nCompressed Clusters:\n";
+  out << O.nTracks << " Tracks\n";
+  out << "Slice Row Clusters:\n";
+  for (uint32_t i = 0; i < NSECTORS; i++) {
+    out << "Sector " << i << ": ";
+    for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      out << O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j] << ", ";
+    }
+    out << "\n";
+  }
+  out << "\nTrack Clusters:\n";
+  for (uint32_t i = 0; i < O.nTracks; i++) {
+    if (i && i % 100 == 0) {
+      out << "\n";
+    }
+    out << O.nTrackClusters[i] << ", ";
+  }
+  out << "\n\nUnattached Clusters\n";
+  uint32_t offset = 0;
+  for (uint32_t i = 0; i < NSECTORS; i++) {
+    for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      out << "Sector " << i << " Row " << j << ": ";
+      for (uint32_t k = 0; k < O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j]; k++) {
+        if (k && k % 10 == 0) {
+          out << "\n    ";
+        }
+        const uint32_t l = k + offset;
+        out << "[" << (uint32_t)O.qTotU[l] << ", " << (uint32_t)O.qMaxU[l] << ", " << (uint32_t)O.flagsU[l] << ", " << (int32_t)O.padDiffU[l] << ", " << (int32_t)O.timeDiffU[l] << ", " << (uint32_t)O.sigmaPadU[l] << ", " << (uint32_t)O.sigmaTimeU[l] << "] ";
+      }
+      offset += O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
+      out << "\n";
+    }
+  }
+  out << "\n\nAttached Clusters\n";
+  offset = 0;
+  for (uint32_t i = 0; i < O.nTracks; i++) {
+    out << "Track " << i << ": {" << (uint32_t)O.qPtA[i] << ", " << (uint32_t)O.rowA[i] << ", " << (uint32_t)O.sliceA[i] << ", " << (uint32_t)O.timeA[i] << ", " << (uint32_t)O.padA[i] << "} - ";
+    for (uint32_t k = 0; k < O.nTrackClusters[i]; k++) {
+      if (k && k % 10 == 0) {
+        out << "\n    ";
+      }
+      const uint32_t l1 = k + offset, l2 = k + offset - i;
+      out << "[";
+      if (k) {
+        out << (int32_t)O.rowDiffA[l2] << ", " << (int32_t)O.sliceLegDiffA[l2] << ", " << (uint32_t)O.padResA[l2] << ", " << (uint32_t)O.timeResA[l2] << ", ";
+      }
+      out << (uint32_t)O.qTotA[l1] << ", " << (uint32_t)O.qMaxA[l1] << ", " << (uint32_t)O.flagsA[l1] << ", " << (uint32_t)O.sigmaPadA[l1] << ", " << (uint32_t)O.sigmaTimeA[l1] << "] ";
+    }
+    offset += O.nTrackClusters[i];
+    out << "\n";
+  }
+}
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
index c1d9fe283fbea..52585b4c08b24 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
@@ -57,6 +57,10 @@ class GPUTPCCompression : public GPUProcessor
   GPUd() static void truncateSignificantBitsChargeMax(uint16_t& charge, const GPUParam& param) { truncateSignificantBits(charge, param.rec.tpc.sigBitsCharge, P_MAX_QMAX); }
   GPUd() static void truncateSignificantBitsWidth(uint8_t& width, const GPUParam& param) { truncateSignificantBits(width, param.rec.tpc.sigBitsWidth, P_MAX_SIGMA); }
 
+#ifndef GPUCA_GPUCODE
+  void DumpCompressedClusters(std::ostream& out);
+#endif
+
  protected:
   struct memory {
     uint32_t nStoredTracks = 0;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 4c32c3e46e3a7..638a3ed43d2aa 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -295,7 +295,7 @@ AddOption(trdNCandidates, int32_t, 3, "", 0, "Number of branching track candidat
 AddOption(trdTrackModelO2, bool, false, "", 0, "Use O2 track model instead of GPU track model for TRD tracking")
 AddOption(debugLevel, int32_t, -1, "debug", 'd', "Set debug level (-2 = silent, -1 = autoselect (-2 for O2, 0 for standalone))")
 AddOption(allocDebugLevel, int32_t, 0, "allocDebug", 0, "Some debug output for memory allocations (without messing with normal debug level)")
-AddOption(debugMask, int32_t, 262143, "", 0, "Mask for debug output dumps to file")
+AddOption(debugMask, uint32_t, 262143, "", 0, "Mask for debug output dumps to file")
 AddOption(serializeGPU, int8_t, 0, "", 0, "Synchronize after each kernel call (bit 1) and DMA transfer (bit 2) and identify failures")
 AddOption(recoTaskTiming, bool, 0, "", 0, "Perform summary timing after whole reconstruction tasks")
 AddOption(deterministicGPUReconstruction, int32_t, -1, "", 0, "Make CPU and GPU debug output comparable (sort / skip concurrent parts), -1 = automatic if debugLevel >= 6", def(1))
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index 5df324fcba648..aca1bb2420fb6 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -20,6 +20,7 @@
 #include "GPUKernelClassesFwd.h"
 
 #include <ctime>
+#include <functional>
 
 namespace o2::gpu
 {
@@ -226,12 +227,19 @@ class GPUChain
   virtual int32_t DoStuckProtection(int32_t stream, deviceEvent event) { return 0; }
 
   template <class T, class S, typename... Args>
-  bool DoDebugAndDump(RecoStep step, int32_t mask, T& processor, S T::*func, Args&&... args)
+  bool DoDebugAndDump(RecoStep step, uint32_t mask, T& processor, S T::*func, Args&&... args)
   {
     return DoDebugAndDump(step, mask, true, processor, func, args...);
   }
   template <class T, class S, typename... Args>
-  bool DoDebugAndDump(RecoStep step, int32_t mask, bool transfer, T& processor, S T::*func, Args&&... args);
+  bool DoDebugAndDump(RecoStep step, uint32_t mask, bool transfer, T& processor, S T::*func, Args&&... args);
+  template <typename... Args>
+  bool DoDebugDump(uint32_t mask, std::function<void(Args&...)> func, Args&... args);
+  template <class S, typename... Args>
+  bool DoDebugDump(uint32_t mask, S* func, Args&&... args)
+  {
+    return DoDebugDump(mask, std::function<void(Args && ...)>([&func](Args&&... args_tmp) { (*func)(args_tmp...); }), args...);
+  }
 
   template <class T, class S, typename... Args>
   int32_t runRecoStep(RecoStep step, S T::*func, Args... args);
@@ -278,24 +286,7 @@ inline void GPUChain::timeCpy(RecoStep step, int32_t toGPU, S T::*func, Args...
 }
 
 template <class T, class S, typename... Args>
-bool GPUChain::DoDebugAndDump(GPUChain::RecoStep step, int32_t mask, bool transfer, T& processor, S T::*func, Args&&... args)
-{
-  if (GetProcessingSettings().keepAllMemory) {
-    if (transfer) {
-      TransferMemoryResourcesToHost(step, &processor, -1, true);
-    }
-    if (GetProcessingSettings().debugLevel >= 6 && (mask == 0 || (GetProcessingSettings().debugMask & mask))) {
-      if (func) {
-        (processor.*func)(args...);
-      }
-      return true;
-    }
-  }
-  return false;
-}
-
-template <class T, class S, typename... Args>
-int32_t GPUChain::runRecoStep(RecoStep step, S T::*func, Args... args)
+inline int32_t GPUChain::runRecoStep(RecoStep step, S T::*func, Args... args)
 {
   if (GetRecoSteps().isSet(step)) {
     auto* timer = GetProcessingSettings().recoTaskTiming ? &mRec->getRecoStepTimer(step) : nullptr;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 8664652b549e3..13773a97d4e3d 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -234,6 +234,7 @@ class GPUChainTracking : public GPUChain
   void PrepareDebugOutput();
   void PrintDebugOutput();
   void PrintOutputStat();
+  static void DumpClusters(std::ostream& out, const o2::tpc::ClusterNativeAccess* clusters);
 
   bool ValidateSteps();
   bool ValidateSettings();
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index f188388e76a02..2cdd1bb76bf00 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -14,6 +14,7 @@
 
 #include "GPUChainTracking.h"
 #include "GPUChainTrackingDefs.h"
+#include "GPUChainTrackingDebug.h"
 #include "GPULogging.h"
 #include "GPUO2DataTypes.h"
 #include "GPUMemorySizeScalers.h"
@@ -813,7 +814,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         if (fragment.index == 0) {
           runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPpadIsNoisy, TPC_PADS_IN_SECTOR * sizeof(*clustererShadow.mPpadIsNoisy));
         }
-        DoDebugAndDump(RecoStep::TPCClusterFinding, 262144, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Zeroed Charges");
+        DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererZeroedCharges, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Zeroed Charges");
 
         if (doGPU) {
           if (mIOPtrs.tpcZS && mCFContext->nPagesSector[iSector] && mCFContext->zsVersion != -1) {
@@ -900,7 +901,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         if (!mIOPtrs.tpcZS) {
           runKernel<GPUTPCCFChargeMapFiller, GPUTPCCFChargeMapFiller::fillFromDigits>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
         }
-        if (DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 1, clusterer, &GPUTPCClusterFinder::DumpDigits, *mDebugFile)) {
+        if (DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererDigits, clusterer, &GPUTPCClusterFinder::DumpDigits, *mDebugFile)) {
           clusterer.DumpChargeMap(*mDebugFile, "Charges");
         }
 
@@ -919,13 +920,13 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         }
 
         runKernel<GPUTPCCFPeakFinder>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
-        if (DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 2, clusterer, &GPUTPCClusterFinder::DumpPeaks, *mDebugFile)) {
+        if (DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererPeaks, clusterer, &GPUTPCClusterFinder::DumpPeaks, *mDebugFile)) {
           clusterer.DumpPeakMap(*mDebugFile, "Peaks");
         }
 
         RunTPCClusterizer_compactPeaks(clusterer, clustererShadow, 0, doGPU, lane);
         TransferMemoryResourceLinkToHost(RecoStep::TPCClusterFinding, clusterer.mMemoryId, lane);
-        DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 2, clusterer, &GPUTPCClusterFinder::DumpPeaksCompacted, *mDebugFile); // clang-format off
+        DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererPeaks, clusterer, &GPUTPCClusterFinder::DumpPeaksCompacted, *mDebugFile); // clang-format off
       });
       mRec->runParallelOuterLoop(doGPU, maxLane, [&](uint32_t lane) {
         uint32_t iSector = iSectorBase + lane;
@@ -939,13 +940,13 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         }
         runKernel<GPUTPCCFNoiseSuppression, GPUTPCCFNoiseSuppression::noiseSuppression>({GetGrid(clusterer.mPmemory->counters.nPeaks, lane), {iSector}});
         runKernel<GPUTPCCFNoiseSuppression, GPUTPCCFNoiseSuppression::updatePeaks>({GetGrid(clusterer.mPmemory->counters.nPeaks, lane), {iSector}});
-        if (DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 3, clusterer, &GPUTPCClusterFinder::DumpSuppressedPeaks, *mDebugFile)) {
+        if (DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererSuppressedPeaks, clusterer, &GPUTPCClusterFinder::DumpSuppressedPeaks, *mDebugFile)) {
           clusterer.DumpPeakMap(*mDebugFile, "Suppressed Peaks");
         }
 
         RunTPCClusterizer_compactPeaks(clusterer, clustererShadow, 1, doGPU, lane);
         TransferMemoryResourceLinkToHost(RecoStep::TPCClusterFinding, clusterer.mMemoryId, lane);
-        DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 3, clusterer, &GPUTPCClusterFinder::DumpSuppressedPeaksCompacted, *mDebugFile); // clang-format off
+        DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererSuppressedPeaks, clusterer, &GPUTPCClusterFinder::DumpSuppressedPeaksCompacted, *mDebugFile); // clang-format off
       });
       mRec->runParallelOuterLoop(doGPU, maxLane, [&](uint32_t lane) {
         uint32_t iSector = iSectorBase + lane;
@@ -979,7 +980,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
           if (clustererNNShadow.mNnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
             runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
-            DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 4, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
+            DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
           }
 
           // float time_clusterizer = 0, time_fill = 0, time_networks = 0;
@@ -1092,7 +1093,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 #endif
         } else {
           runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
-          DoDebugAndDump(RecoStep::TPCClusterFinding, 262144 << 4, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
+          DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
           runKernel<GPUTPCCFClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), {iSector}}, 0);
         }
 
@@ -1111,7 +1112,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         TransferMemoryResourcesToHost(RecoStep::TPCClusterFinding, &clusterer, lane);
         laneHasData[lane] = true;
         // Include clusters in default debug mask, exclude other debug output by default
-        DoDebugAndDump(RecoStep::TPCClusterFinding, 131072, clusterer, &GPUTPCClusterFinder::DumpClusters, *mDebugFile); // clang-format off
+        DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererClusters, clusterer, &GPUTPCClusterFinder::DumpClusters, *mDebugFile); // clang-format off
       });
       mRec->SetNActiveThreadsOuterLoop(1);
     }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 24c74a661f18e..534c02a4c0a84 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingDebug.h"
 #include "GPULogging.h"
 #include "GPUO2DataTypes.h"
 #include "GPUTrackingInputProvider.h"
@@ -202,6 +203,7 @@ int32_t GPUChainTracking::RunTPCCompression()
     ((GPUChainTracking*)GetNextChainInQueue())->mRec->BlockStackedMemory(mRec);
   }
   mRec->PopNonPersistentMemory(RecoStep::TPCCompression, qStr2Tag("TPCCOMPR"));
+  DoDebugAndDump(RecoStep::TPCCompression, GPUChainTrackingDebugFlags::TPCCompressedClusters, Compressor, &GPUTPCCompression::DumpCompressedClusters, *mDebugFile);
   return 0;
 }
 
@@ -425,5 +427,6 @@ int32_t GPUChainTracking::RunTPCDecompression()
     }
     mRec->PopNonPersistentMemory(RecoStep::TPCDecompression, qStr2Tag("TPCDCMPR"));
   }
+  DoDebugDump(GPUChainTrackingDebugFlags::TPCDecompressedClusters, &GPUChainTracking::DumpClusters, *mDebugFile, mIOPtrs.clustersNative);
   return 0;
 }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebug.h b/GPU/GPUTracking/Global/GPUChainTrackingDebug.h
new file mode 100644
index 0000000000000..810f40a1d8654
--- /dev/null
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebug.h
@@ -0,0 +1,79 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUChainTrackingDEBUG.h
+/// \author David Rohr
+
+#ifndef GPUCHAINTRACKINGDEBUG_H
+#define GPUCHAINTRACKINGDEBUG_H
+
+#include <cstdint>
+#include <functional>
+#include <fstream>
+
+namespace o2::gpu
+{
+// NOTE: Values below 262144 are activated by default with --debug 6 in GPUSettingsList.h::debugMask
+enum GPUChainTrackingDebugFlags : uint32_t {
+  TPCSectorTrackingData = 1,
+  TPCPreLinks = 2,
+  TPCLinks = 4,
+  TPCStartHits = 8,
+  TPCTracklets = 16,
+  TPCSectorTracks = 32,
+  TPCHitWeights = 256,
+  TPCCompressedClusters = 512,
+  TPCDecompressedClusters = 1024,
+  TPCMergingRanges = 2048,
+  TPCMergingSectorTracks = 4096,
+  TPCMergingMergedTracks = 8192,
+  TPCMergingCollectedTracks = 16384,
+  TPCMergingCE = 32768,
+  TPCMergingRefit = 65536,
+  TPCClustererClusters = 131072,
+  TPCClusterer = 262144,
+  TPCClustererDigits = 262144 << 1,
+  TPCClustererPeaks = 262144 << 2,
+  TPCClustererSuppressedPeaks = 262144 << 3,
+  TPCClustererChargeMap = 262144 << 4,
+  TPCClustererZeroedCharges = 262144 << 5
+};
+
+template <class T, class S, typename... Args>
+inline bool GPUChain::DoDebugAndDump(GPUChain::RecoStep step, uint32_t mask, bool transfer, T& processor, S T::*func, Args&&... args)
+{
+  if (GetProcessingSettings().keepAllMemory) {
+    if (transfer) {
+      TransferMemoryResourcesToHost(step, &processor, -1, true);
+    }
+    std::function<void(Args && ...)> lambda = [&processor, &func](Args&... args_tmp) {
+      if (func) {
+        (processor.*func)(args_tmp...);
+      }
+    };
+    return DoDebugDump(mask, lambda, args...);
+  }
+  return false;
+}
+
+template <typename... Args>
+inline bool GPUChain::DoDebugDump(uint32_t mask, std::function<void(Args&...)> func, Args&... args)
+{
+  if (GetProcessingSettings().debugLevel >= 6 && (mask == 0 || (GetProcessingSettings().debugMask & mask))) {
+    func(args...);
+    return true;
+  }
+  return false;
+}
+
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 53bdfbadd4b25..903505068ad2c 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -333,3 +333,18 @@ void GPUChainTracking::RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* cluster
     }
   }
 }
+
+void GPUChainTracking::DumpClusters(std::ostream& out, const o2::tpc::ClusterNativeAccess* clusters)
+{
+  out << "\nTPC Clusters:\n";
+  for (uint32_t iSec = 0; iSec < GPUCA_NSECTORS; iSec++) {
+    out << "TPCClusters - Sector " << iSec << "\n";
+    for (uint32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+      out << "  Row: " << i << ": " << clusters->nClusters[iSec][i] << " clusters:\n";
+      for (uint32_t j = 0; j < clusters->nClusters[iSec][i]; j++) {
+        const auto& cl = clusters->clusters[iSec][i][j];
+        out << "    " << std::hex << cl.timeFlagsPacked << std::dec << " " << cl.padPacked << " " << int32_t{cl.sigmaTimePacked} << " " << int32_t{cl.sigmaPadPacked} << " " << cl.qMax << " " << cl.qTot << "\n";
+      }
+    }
+  }
+}
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index a38148ccb375a..6e86be03e7950 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingDebug.h"
 #include "GPULogging.h"
 #include "GPUDefParametersRuntime.h"
 #include "GPUO2DataTypes.h"
@@ -72,7 +73,7 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSecto
       runKernel<GPUTPCGMMergerMergeBorders, 2>(GetGridAuto(0, deviceType), i, withinSector, mergeMode);
     }
   }
-  DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPU, Merger, &GPUTPCGMMerger::DumpMergeRanges, *mDebugFile, withinSector, mergeMode);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRanges, doGPU, Merger, &GPUTPCGMMerger::DumpMergeRanges, *mDebugFile, withinSector, mergeMode);
   mRec->ReturnVolatileDeviceMemory();
 }
 
@@ -135,14 +136,14 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   if (GetProcessingSettings().deterministicGPUReconstruction) {
     runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::sectorTracks>({{GPUCA_NSECTORS, -WarpSize(), 0, deviceType}}, 1);
   }
-  DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPU, Merger, &GPUTPCGMMerger::DumpSectorTracks, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingSectorTracks, doGPU, Merger, &GPUTPCGMMerger::DumpSectorTracks, *mDebugFile);
 
   runKernel<GPUTPCGMMergerClearLinks>(GetGridAuto(0, deviceType), false);
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
   runKernel<GPUTPCGMMergerMergeWithinPrepare>(GetGridAuto(0, deviceType));
   RunTPCTrackingMerger_MergeBorderTracks(1, 0, deviceType);
   RunTPCTrackingMerger_Resolve(0, 1, deviceType);
-  DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPU, Merger, &GPUTPCGMMerger::DumpMergedWithinSectors, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingMergedTracks, doGPU, Merger, &GPUTPCGMMerger::DumpMergedWithinSectors, *mDebugFile);
 
   runKernel<GPUTPCGMMergerClearLinks>(GetGridAuto(0, deviceType), false);
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), 2 * NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
@@ -157,7 +158,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   runKernel<GPUTPCGMMergerMergeSectorsPrepare>(GetGridBlk(std::max(2u, numBlocks), 0, deviceType), 0, 1, 1);
   RunTPCTrackingMerger_MergeBorderTracks(0, -1, deviceType);
   RunTPCTrackingMerger_Resolve(0, 1, deviceType);
-  DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPU, Merger, &GPUTPCGMMerger::DumpMergedBetweenSectors, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingMergedTracks, doGPU, Merger, &GPUTPCGMMerger::DumpMergedBetweenSectors, *mDebugFile);
 
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), 2 * NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
 
@@ -167,14 +168,14 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::extrapolatedTracks1>({{1, -WarpSize(), 0, deviceType}}, 1);
     runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::extrapolatedTracks2>({{1, -WarpSize(), 0, deviceType}}, 1);
   }
-  DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPU, Merger, &GPUTPCGMMerger::DumpCollected, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingCollectedTracks, doGPU, Merger, &GPUTPCGMMerger::DumpCollected, *mDebugFile);
 
   if (param().rec.tpc.mergeCE) {
     runKernel<GPUTPCGMMergerClearLinks>(GetGridAuto(0, deviceType), true);
     RunTPCTrackingMerger_MergeBorderTracks(-1, 1, deviceType);
     RunTPCTrackingMerger_MergeBorderTracks(-1, 2, deviceType);
     runKernel<GPUTPCGMMergerMergeCE>(GetGridAuto(0, deviceType));
-    DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPU, Merger, &GPUTPCGMMerger::DumpMergeCE, *mDebugFile);
+    DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingCE, doGPU, Merger, &GPUTPCGMMerger::DumpMergeCE, *mDebugFile);
   }
   int32_t waitForTransfer = 0;
   if (doGPU) {
@@ -201,7 +202,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   runKernel<GPUTPCGMMergerPrepareClusters, 1>(GetGridAuto(0, deviceType));
   runKernel<GPUTPCGMMergerPrepareClusters, 2>(GetGridAuto(0, deviceType));
 
-  DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPU, Merger, &GPUTPCGMMerger::DumpFitPrepare, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRefit, doGPU, Merger, &GPUTPCGMMerger::DumpFitPrepare, *mDebugFile);
 
   if (doGPU) {
     CondWaitEvent(waitForTransfer, &mEvents->single);
@@ -227,7 +228,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     runKernel<GPUTPCGMMergerFollowLoopers>(GetGridAuto(0));
   }
 
-  DoDebugAndDump(RecoStep::TPCMerging, 2048, Merger, &GPUTPCGMMerger::DumpRefit, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRefit, Merger, &GPUTPCGMMerger::DumpRefit, *mDebugFile);
   runKernel<GPUTPCGMMergerFinalize, 0>(GetGridAuto(0, deviceType));
   runKernel<GPUTPCGMMergerFinalize, 1>(GetGridAuto(0, deviceType));
   runKernel<GPUTPCGMMergerFinalize, 2>(GetGridAuto(0, deviceType));
@@ -240,7 +241,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     runKernel<GPUTPCGMMergerMergeLoopers, 1>(GetGridAuto(0, deviceType));
     runKernel<GPUTPCGMMergerMergeLoopers, 2>(doGPU ? GetGrid(Merger.Memory()->nLooperMatchCandidates, 0, deviceType) : GetGridAuto(0, deviceType));
   }
-  DoDebugAndDump(RecoStep::TPCMerging, 2048, doGPU, Merger, &GPUTPCGMMerger::DumpFinal, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRefit, doGPU, Merger, &GPUTPCGMMerger::DumpFinal, *mDebugFile);
 
   if (doGPU) {
     RecordMarker(&mEvents->single, 0);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 635641c00ae14..ef38d53173c2b 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingDebug.h"
 #include "GPULogging.h"
 #include "GPUO2DataTypes.h"
 #include "GPUMemorySizeScalers.h"
@@ -176,7 +177,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
 
     if (GetProcessingSettings().debugLevel >= 6) {
       *mDebugFile << "\n\nReconstruction: Sector " << iSector << "/" << NSECTORS << std::endl;
-      if (GetProcessingSettings().debugMask & 1) {
+      if (GetProcessingSettings().debugMask & GPUChainTrackingDebugFlags::TPCSectorTrackingData) {
         if (doGPU) {
           TransferMemoryResourcesToHost(RecoStep::TPCSectorTracking, &trk, -1, true);
         }
@@ -191,13 +192,13 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     if (GetProcessingSettings().keepDisplayMemory) {
       TransferMemoryResourcesToHost(RecoStep::TPCSectorTracking, &trk, -1, true);
       memcpy(trk.LinkTmpMemory(), mRec->Res(trk.MemoryResLinks()).Ptr(), mRec->Res(trk.MemoryResLinks()).Size());
-      if (GetProcessingSettings().debugMask & 2) {
+      if (GetProcessingSettings().debugMask & GPUChainTrackingDebugFlags::TPCPreLinks) {
         trk.DumpLinks(*mDebugFile, 0);
       }
     }
 
     runKernel<GPUTPCNeighboursCleaner>({GetGridBlk(GPUCA_ROW_COUNT - 2, useStream), {iSector}});
-    DoDebugAndDump(RecoStep::TPCSectorTracking, 4, trk, &GPUTPCTracker::DumpLinks, *mDebugFile, 1);
+    DoDebugAndDump(RecoStep::TPCSectorTracking, GPUChainTrackingDebugFlags::TPCLinks, trk, &GPUTPCTracker::DumpLinks, *mDebugFile, 1);
 
     runKernel<GPUTPCStartHitsFinder>({GetGridBlk(GPUCA_ROW_COUNT - 6, useStream), {iSector}});
     if (mRec->getGPUParameters(doGPU).par_SORT_STARTHITS) {
@@ -206,7 +207,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     if (GetProcessingSettings().deterministicGPUReconstruction) {
       runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::startHits>({GetGrid(1, 1, useStream), {iSector}});
     }
-    DoDebugAndDump(RecoStep::TPCSectorTracking, 32, trk, &GPUTPCTracker::DumpStartHits, *mDebugFile);
+    DoDebugAndDump(RecoStep::TPCSectorTracking, GPUChainTrackingDebugFlags::TPCStartHits, trk, &GPUTPCTracker::DumpStartHits, *mDebugFile);
 
     if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
       trk.UpdateMaxData();
@@ -215,8 +216,8 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     }
 
     runKernel<GPUTPCTrackletConstructor>({GetGridAuto(useStream), {iSector}});
-    DoDebugAndDump(RecoStep::TPCSectorTracking, 128, trk, &GPUTPCTracker::DumpTrackletHits, *mDebugFile);
-    if (GetProcessingSettings().debugMask & 256 && GetProcessingSettings().deterministicGPUReconstruction < 2) {
+    DoDebugAndDump(RecoStep::TPCSectorTracking, GPUChainTrackingDebugFlags::TPCTracklets, trk, &GPUTPCTracker::DumpTrackletHits, *mDebugFile);
+    if (GetProcessingSettings().debugMask & GPUChainTrackingDebugFlags::TPCHitWeights && GetProcessingSettings().deterministicGPUReconstruction < 2) {
       trk.DumpHitWeights(*mDebugFile);
     }
 
@@ -230,7 +231,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     if (GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Sector %u, Number of tracks: %d", iSector, *trk.NTracks());
     }
-    DoDebugAndDump(RecoStep::TPCSectorTracking, 512, trk, &GPUTPCTracker::DumpTrackHits, *mDebugFile);
+    DoDebugAndDump(RecoStep::TPCSectorTracking, GPUChainTrackingDebugFlags::TPCSectorTracks, trk, &GPUTPCTracker::DumpTrackHits, *mDebugFile);
   });
   mRec->SetNActiveThreadsOuterLoop(1);
   if (error) {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
index 37399f5e4863f..35e2a7297338f 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
@@ -36,6 +36,7 @@ class ConstMCTruthContainerView;
 namespace tpc
 {
 struct ClusterNative;
+struct ClusterNativeAccess;
 class Digit;
 } // namespace tpc
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
index da30375149b7c..d676cf9cd3887 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
@@ -157,7 +157,7 @@ void GPUTPCClusterFinder::DumpClusters(std::ostream& out)
 {
   out << "\nClusterer - Clusters - Sector " << mISector << " - Fragment " << mPmemory->fragment.index << "\n";
 
-  for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+  for (uint32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
     size_t N = mPclusterInRow[i];
     const tpc::ClusterNative* row = &mPclusterByRow[i * mNMaxClusterPerRow];
 

From f1fbd3547c5f944b35e114a04a06f8a80367dcea Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Thu, 8 May 2025 21:41:40 +0200
Subject: [PATCH 0327/1764] ctpdev: consistencycheck debug and ctpcfg config
 added (#14247)

* dev: checkConsistency and ctp.cfg

* dev: consistency checker

* dev:ctpcfg to CCDB

* clang

* dev:ctpcfg

* clang

* fix

* fix

---------

Co-authored-by: Roman Lietava <rl@eduroam-174258829-1.dyndns.cern.ch>
---
 .../include/DataFormatsCTP/Configuration.h    |  13 +++
 .../Detectors/CTP/src/Configuration.cxx       |  65 +++++++++++
 .../Detectors/CTP/src/DataFormatsCTPLinkDef.h |   2 +
 .../CTPReconstruction/RawDataDecoder.h        |  14 ++-
 .../CTP/reconstruction/src/RawDataDecoder.cxx | 107 ++++++++----------
 Detectors/CTP/workflow/src/RawDecoderSpec.cxx |  17 ++-
 .../include/CTPWorkflowScalers/RunManager.h   |   2 +-
 .../CTPWorkflowScalers/ctpCCDBManager.h       |   7 +-
 .../CTP/workflowScalers/src/RunManager.cxx    |  10 +-
 .../CTP/workflowScalers/src/ctp-proxy.cxx     |   7 +-
 .../workflowScalers/src/ctpCCDBManager.cxx    |  30 +++++
 11 files changed, 205 insertions(+), 69 deletions(-)

diff --git a/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h b/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
index 4ff0256f33827..fdd73986f1eaf 100644
--- a/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
+++ b/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
@@ -173,6 +173,8 @@ class CTPConfiguration
   uint64_t getDecrtiptorInputsMask(const std::string& name) const;
   std::map<o2::detectors::DetID::ID, std::vector<CTPInput>> getDet2InputMap();
   uint64_t getTriggerClassMask() const;
+  uint64_t getTriggerClassMaskWInputs() const;
+  uint64_t getTriggerClassMaskWInputsNoTrgDets() const;
   std::vector<int> getTriggerClassList() const;
   uint32_t getRunNumber() { return mRunNumber; };
   std::vector<std::string> getDetectorList() const;
@@ -203,6 +205,17 @@ class CTPConfiguration
 
 std::ostream& operator<<(std::ostream& in, const CTPConfiguration& conf);
 
+struct CtpCfg {
+  CtpCfg() = default;
+  std::string filename = "ctp.cfg";
+  int readAndSave(std::string& path);
+  uint32_t TFOrbits = 0;
+  int ccdb = -1; // -1 means def constructor was called
+  uint32_t orbitShift = 0;
+  uint32_t irInputs_1_24 = 0;
+  uint32_t irInputs_25_48 = 0;
+  ClassDefNV(CtpCfg, 1)
+};
 } // namespace ctp
 } // namespace o2
 #endif //_CTP_CONFIGURATION_H_
diff --git a/DataFormats/Detectors/CTP/src/Configuration.cxx b/DataFormats/Detectors/CTP/src/Configuration.cxx
index 03f9b38db0e9f..38a49132db3d1 100644
--- a/DataFormats/Detectors/CTP/src/Configuration.cxx
+++ b/DataFormats/Detectors/CTP/src/Configuration.cxx
@@ -905,6 +905,30 @@ uint64_t CTPConfiguration::getTriggerClassMask() const
   }
   return clsmask;
 }
+uint64_t CTPConfiguration::getTriggerClassMaskWInputs() const
+{
+  uint64_t clsmask = 0;
+  for (auto const& cls : mCTPClasses) {
+    if (cls.name.find("TRUE") != std::string::npos) { // ignoring internal ctp generators
+      continue;
+    }
+    clsmask |= cls.classMask;
+  }
+  return clsmask;
+}
+uint64_t CTPConfiguration::getTriggerClassMaskWInputsNoTrgDets() const
+{
+  uint64_t clsmask = 0;
+  for (auto const& cls : mCTPClasses) {
+    bool exclude = cls.name.find("TRUE") != std::string::npos; // ignoring internal ctp generators
+    exclude += cls.name.find("EMC") != std::string::npos;
+    exclude += cls.name.find("TRD") != std::string::npos;
+    exclude += cls.name.find("HMP") != std::string::npos;
+    if (!exclude)
+      clsmask |= cls.classMask;
+  }
+  return clsmask;
+}
 // Hardware positions of classes
 std::vector<int> CTPConfiguration::getTriggerClassList() const
 {
@@ -1153,6 +1177,47 @@ int CTPInputsConfiguration::getInputIndexFromName(std::string& name)
   return 0xff;
 }
 
+int CtpCfg::readAndSave(std::string& path)
+{
+  std::string file = path + filename;
+  std::ifstream ctpcfg(file);
+  if (ctpcfg.is_open()) {
+    std::string line;
+    while (std::getline(ctpcfg, line)) {
+      o2::utils::Str::trim(line);
+      if (line.size() == 0) {
+        continue;
+      }
+      if (line[0] == '#') {
+        continue;
+      }
+      std::vector<std::string> tokens = o2::utils::Str::tokenize(line, ' ');
+      size_t ntokens = tokens.size();
+      if (ntokens < 2) {
+        LOG(warn) << "Not enough tokens";
+        continue;
+      }
+      if (tokens[0].find("TForbits") != std::string::npos) {
+        TFOrbits = std::atol(tokens[1].c_str());
+      } else if (tokens[0].find("ccdb") != std::string::npos) {
+        ccdb = std::atoi(tokens[1].c_str());
+      } else if (tokens[0].find("orbitshift") != std::string::npos) {
+        orbitShift = std::atol(tokens[1].c_str());
+      } else if (tokens[0].find("ir_inputs") != std::string::npos) {
+        irInputs_1_24 = std::stoul(tokens[2].c_str(), nullptr, 16);
+        irInputs_25_48 = std::stoul(tokens[1].c_str(), nullptr, 16);
+      } else {
+        LOG(warn) << " Token not found:" << tokens[0];
+      }
+    }
+    LOG(warn) << "Open file success:" << file;
+  } else {
+    LOG(warn) << "Can not open file:" << file;
+    return 1;
+  }
+  return 0;
+}
+
 std::ostream& o2::ctp::operator<<(std::ostream& in, const o2::ctp::CTPConfiguration& conf)
 {
   conf.printStream(in);
diff --git a/DataFormats/Detectors/CTP/src/DataFormatsCTPLinkDef.h b/DataFormats/Detectors/CTP/src/DataFormatsCTPLinkDef.h
index da21f779723f8..ac2a83d31edda 100644
--- a/DataFormats/Detectors/CTP/src/DataFormatsCTPLinkDef.h
+++ b/DataFormats/Detectors/CTP/src/DataFormatsCTPLinkDef.h
@@ -55,4 +55,6 @@
 #pragma link C++ class o2::ctp::TriggerOffsetsParam + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::ctp::TriggerOffsetsParam> + ;
 
+#pragma link C++ class o2::ctp::CtpCfg + ;
+
 #endif
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
index 7579e9dc1d6f5..8ebc7e0304561 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
@@ -55,7 +55,12 @@ class RawDataDecoder
   int init();
   static int shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit, std::bitset<48>& inpmask, int64_t shift, int level, std::map<o2::InteractionRecord, CTPDigit>& digmap);
   static int shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask = 0xffffffffffffffff);
-  int checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask = 0xffffffffffffffff);
+  int checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask = 0xffffffffffffffff, uint64_t trigclassmaskNoTrgDets = 0xffffffffffffffff);
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassErrorsA() { return mClassErrorsA; }
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassErrorsB() { return mClassErrorsB; }
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassCountersA() { return mClassCountersA; }
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassCountersB() { return mClassCountersB; }
+  int getLostDueToShift() { return mLostDueToShift; }
 
  private:
   static constexpr uint32_t TF_TRIGGERTYPE_MASK = 0x800;
@@ -83,8 +88,13 @@ class RawDataDecoder
   // error verbosness
   int mErrorIR = 0;
   int mErrorTCR = 0;
-  int mErrorMax = 3;
+  int mErrorMax = 5;
   bool mStickyError = false;
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClassErrorsA{};
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClassErrorsB{}; // from inputs
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClassCountersA{};
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClassCountersB{}; // from inputs
+  int mLostDueToShift = 0;
   CTPConfiguration mCTPConfig;
 };
 } // namespace ctp
diff --git a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
index fa7fd673c7e85..797dd0e300519 100644
--- a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
+++ b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
@@ -294,13 +294,17 @@ int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2
   }
   if (mDoDigits & mDecodeInps) {
     uint64_t trgclassmask = 0xffffffffffffffff;
+    uint64_t trgclassmaskNOTRGDet = 0xffffffffffffffff;
     if (mCTPConfig.getRunNumber() != 0) {
-      trgclassmask = mCTPConfig.getTriggerClassMask();
+      trgclassmask = mCTPConfig.getTriggerClassMaskWInputs();
+      trgclassmaskNOTRGDet = mCTPConfig.getTriggerClassMaskWInputsNoTrgDets();
+      // mCTPConfig.printStream(std::cout);
     }
     // std::cout << "trgclassmask:" << std::hex << trgclassmask << std::dec << std::endl;
-    ret = shiftInputs(digitsMap, digits, mTFOrbit, trgclassmask);
-    if (mCheckConsistency) {
-      ret = checkReadoutConsistentncy(digits, trgclassmask);
+    ret = shiftInputs(digitsMap, digits, mTFOrbit);
+    // if (mCheckConsistency) {
+    if (1) {
+      ret = checkReadoutConsistentncy(digits, trgclassmask, trgclassmaskNOTRGDet);
     }
   }
   if (mDoDigits && !mDecodeInps) {
@@ -530,12 +534,6 @@ int RawDataDecoder::shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit
 int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask)
 {
   // int nClasswoInp = 0; // counting classes without input which should never happen
-  int nLM = 0;
-  int nL0 = 0;
-  int nL1 = 0;
-  int nTwI = 0;
-  int nTwoI = 0;
-  int nTwoIlost = 0;
   std::map<o2::InteractionRecord, CTPDigit> digitsMapShifted;
   auto L0shift = o2::ctp::TriggerOffsetsParam::Instance().LM_L0;
   auto L1shift = L0shift + o2::ctp::TriggerOffsetsParam::Instance().L0_L1;
@@ -593,86 +591,77 @@ int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digit
     }
   }
   for (auto const& dig : digitsMapShifted) {
-    auto d = dig.second;
-    if ((d.CTPInputMask & LMMASKInputs).count()) {
-      nLM++;
-    }
-    if ((d.CTPInputMask & L0MASKInputs).count()) {
-      nL0++;
-    }
-    if ((d.CTPInputMask & L1MASKInputs).count()) {
-      nL1++;
-    }
-    if ((d.CTPClassMask).to_ulong() & trgclassmask) {
-      if (d.CTPInputMask.count()) {
-        nTwI++;
-      } else {
-        if (d.intRecord.bc == (o2::constants::lhc::LHCMaxBunches - L1shift)) { // input can be lost because latency class-l1input = 1
-          nTwoIlost++;
-        } else {
-          // LOG(error) << d.intRecord << " " << d.CTPClassMask << " " << d.CTPInputMask;
-          // std::cout << "ERROR:" << std::hex << d.CTPClassMask << " " << d.CTPInputMask << std::dec << std::endl;
-          nTwoI++;
-        }
-      }
-    }
     digits.push_back(dig.second);
   }
-  int ret = 0;
-  if (nTwoI) { // Trigger class wo Input
-    LOG(error) << "LM:" << nLM << " L0:" << nL0 << " L1:" << nL1 << " TwI:" << nTwI << " Trigger classes wo input:" << nTwoI;
-    ret = 64;
-  }
-  if (nTwoIlost) {
-    LOG(warn) << " Trigger classes wo input from diff latency 1:" << nTwoIlost;
-  }
-  return ret;
+  return 0;
 }
 //
-int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask)
+int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask, uint64_t trgclassmaskNoTrgDet)
 {
+  LOG(debug) << "Checking readout";
   int ret = 0;
-  int lost = 0;
+  static int nerror = 0;
   for (auto const& digit : digits) {
     // if class mask => inps
     for (int i = 0; i < digit.CTPClassMask.size(); i++) {
-      if (digit.CTPClassMask[i] & trgclassmask) {
+      bool trgcls = trgclassmask & (1ull << i);
+      if (digit.CTPClassMask[i] & trgcls) {
         const CTPClass* cls = mCTPConfig.getCTPClassFromHWIndex(i);
         if (cls == nullptr) {
-          LOG(error) << "Class mask index not found in CTP config:" << i;
+          if (nerror < mErrorMax) {
+            LOG(error) << "Class mask index not found in CTP config:" << i;
+            nerror++;
+          }
           ret = 128;
           continue;
         }
+        mClassCountersA[i]++;
+        if (cls->descriptor == nullptr)
+          continue;
         uint64_t clsinpmask = cls->descriptor->getInputsMask();
         uint64_t diginpmask = digit.CTPInputMask.to_ullong();
         if (!((clsinpmask & diginpmask) == clsinpmask)) {
-          LOG(error) << "CTP class:" << cls->name << " inpmask:" << clsinpmask << " not compatible with inputs mask:" << diginpmask;
+          if (nerror < mErrorMax) {
+            LOG(error) << "Cls=>Inps: CTP class:" << cls->name << " inpmask:" << clsinpmask << " not compatible with inputs mask:" << diginpmask;
+            nerror++;
+          }
+          mClassErrorsA[i]++;
           ret = 128;
         }
       }
     }
     // if inps => class mask
     for (auto const& cls : mCTPConfig.getCTPClasses()) {
-      uint64_t clsinpmask = cls.descriptor->getInputsMask();
+      // cls.printStream(std::cout);
+      if (cls.descriptor == nullptr)
+        continue;
+      uint64_t clsinpmask = cls.descriptor->getInputsMask(); // class definition
       uint64_t diginpmask = digit.CTPInputMask.to_ullong();
       uint64_t digclsmask = digit.CTPClassMask.to_ullong();
       if ((clsinpmask & diginpmask) == clsinpmask) {
-        if ((cls.classMask & digclsmask) == 0) {
-          int32_t BCShiftCorrection = -o2::ctp::TriggerOffsetsParam::Instance().customOffset[o2::detectors::DetID::CTP];
-          int32_t offset = BCShiftCorrection + o2::ctp::TriggerOffsetsParam::Instance().LM_L0 + o2::ctp::TriggerOffsetsParam::Instance().L0_L1_classes - 1;
-          offset = o2::constants::lhc::LHCMaxBunches - offset;
-          if (digit.intRecord.bc < offset) {
-            LOG(error) << "CTP class:" << cls.name << " inpmask:" << clsinpmask << " cls mask:" << cls.classMask << " not found in digit:" << digit;
-            ret = 256;
-          } else {
-            lost++;
+        if (cls.classMask & trgclassmask) {
+          mClassCountersB[cls.getIndex()]++;
+          if ((cls.classMask & digclsmask) == 0) {
+            int32_t BCShiftCorrection = -o2::ctp::TriggerOffsetsParam::Instance().customOffset[o2::detectors::DetID::CTP];
+            int32_t offset = BCShiftCorrection + o2::ctp::TriggerOffsetsParam::Instance().LM_L0 + o2::ctp::TriggerOffsetsParam::Instance().L0_L1_classes - 1;
+            offset = o2::constants::lhc::LHCMaxBunches - offset;
+            if (digit.intRecord.bc < offset) {
+              if ((nerror < mErrorMax) && (cls.classMask & ~trgclassmaskNoTrgDet)) {
+                LOG(info) << "Inp=>Cls: CTP class:" << cls.name << " inpmask:" << clsinpmask << " cls mask:" << cls.classMask << " not found in digit:" << digit;
+                nerror++;
+              }
+              mClassErrorsB[cls.getIndex()]++;
+              ret = 256;
+            } else {
+              mLostDueToShift++;
+            }
           }
         }
       }
     }
   }
-  if (lost) {
-    LOG(info) << "LOST classes because of shift:" << lost;
+  if (mLostDueToShift) {
+    LOG(debug) << "LOST classes because of shift:" << mLostDueToShift;
   }
   return ret;
 }
diff --git a/Detectors/CTP/workflow/src/RawDecoderSpec.cxx b/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
index 753f88114a14b..3f7c729b351a3 100644
--- a/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
+++ b/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
@@ -69,8 +69,21 @@ void RawDecoderSpec::endOfStream(framework::EndOfStreamContext& ec)
     o0 = TFOrbits[i];
   }
   std::cout << std::endl;
-  std::cout << "Number of missing TF:" << nmiss << std::endl;
-  std::cout << "# of IR errors:" << mDecoder.getErrorIR() << " TCR errors:" << mDecoder.getErrorTCR() << std::endl;
+  LOG(info) << " Lost due to the shift:" << mDecoder.getLostDueToShift();
+  LOG(info) << "Number of missing TF:" << nmiss << std::endl;
+  if (mDecoder.getErrorIR() || mDecoder.getErrorTCR())
+    LOG(error) << "# of IR errors:" << mDecoder.getErrorIR() << " TCR errors:" << mDecoder.getErrorTCR() << std::endl;
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsA = mDecoder.getClassCountersA();
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsB = mDecoder.getClassCountersB();
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsEA = mDecoder.getClassErrorsA();
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsEB = mDecoder.getClassErrorsB();
+
+  for (int i = 0; i < o2::ctp::CTP_NCLASSES; i++) {
+    bool print = clsA[i] > 0 || clsB[i] > 0 || clsEA[i] > 0 || clsEB[i] > 0;
+    if (clsEA[i])
+      LOG(error) << " Class without inputs:";
+    LOG(important) << "CLASS:" << i << " Cls=>Inp:" << clsA[i] << " Inp=>Cls:" << clsB[i] << "  ErrorsCls=>Inps:" << clsEA[i] << "  MissingInps=>Cls:" << clsEB[i];
+  }
 }
 void RawDecoderSpec::run(framework::ProcessingContext& ctx)
 {
diff --git a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
index 72fb9c2056367..6d2172e3da165 100644
--- a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
+++ b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/RunManager.h
@@ -72,7 +72,7 @@ class CTPRunManager : public ctpCCDBManager
   int mEOX = 0; // redundancy check
   int mNew = 1; // 1 - no CCDB: used for QC
   int mQCWritePeriod = 3; // Time in 10secs between two writes to QCCD
-  ClassDefNV(CTPRunManager, 7);
+  ClassDefNV(CTPRunManager, 8);
 };
 } // namespace ctp
 } // namespace o2
diff --git a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
index c968a83183624..4237ad4501fcc 100644
--- a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
+++ b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
@@ -29,11 +29,13 @@ class ctpCCDBManager
   int saveRunConfigToCCDB(CTPConfiguration* cfg, long timeStart);
   int saveSoxOrbit(uint32_t runNumber, uint32_t soxOrbit, long timeStart);
   int saveOrbitReset(long timeStamp);
+  int saveCtpCfg(uint32_t runNumber, long timeStamp);
   static CTPConfiguration getConfigFromCCDB(long timestamp, std::string run, bool& ok);
   static CTPConfiguration getConfigFromCCDB(long timestamp, std::string run);
   CTPRunScalers getScalersFromCCDB(long timestamp, std::string, bool& ok);
   static void setCCDBHost(std::string host) { mCCDBHost = host; };
   static void setQCDBHost(std::string host) { mQCDBHost = host; };
+  void setCtpCfgDir(std::string& ctpcfgdir) { mCtpCfgDir = ctpcfgdir; };
 
  protected:
   /// Database constants
@@ -46,7 +48,10 @@ class ctpCCDBManager
   const std::string mQCDBPathCTPScalers = "qc/CTP/Scalers";
   const std::string mCCDBPathSoxOrbit = "CTP/Calib/FirstRunOrbit";
   const std::string mCCDBPathOrbitReset = "CTP/Calib/OrbitReset";
-  ClassDefNV(ctpCCDBManager, 1);
+  const std::string mCCDBPathCtpCfg = "CTP/Config/CtpCfg";
+  std::string mCtpCfgDir;
+
+  ClassDefNV(ctpCCDBManager, 2);
 };
 } // namespace ctp
 } // namespace o2
diff --git a/Detectors/CTP/workflowScalers/src/RunManager.cxx b/Detectors/CTP/workflowScalers/src/RunManager.cxx
index 5d0b906e28088..054505aea7ba6 100644
--- a/Detectors/CTP/workflowScalers/src/RunManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/RunManager.cxx
@@ -87,6 +87,7 @@ void CTPRunManager::init()
   LOG(info) << "QCDB writing every:" << mQCWritePeriod << " 10 secs";
   LOG(info) << "CCDB host:" << mCCDBHost;
   LOG(info) << "CTP vNew cfg:" << mNew;
+  LOG(info) << "ctp.cfg dir:" << mCtpCfgDir;
   LOG(info) << "CTPRunManager initialised.";
 }
 int CTPRunManager::loadRun(const std::string& cfg)
@@ -106,7 +107,7 @@ int CTPRunManager::loadRun(const std::string& cfg)
       timeStamp = (tt * 1000.);
       LOG(info) << "Timestamp file:" << timeStamp;
       cfgmod = cfg.substr(pos, cfg.size());
-      LOG(info) << "ctpcfg: using ctp time";
+      LOG(info) << "ctpconfig: using ctp time";
     }
   }
   CTPActiveRun* activerun = new CTPActiveRun;
@@ -122,7 +123,9 @@ int CTPRunManager::loadRun(const std::string& cfg)
   //
   mRunsLoaded[runnumber] = activerun;
   saveRunConfigToCCDB(&activerun->cfg, timeStamp);
-
+  if (mCtpCfgDir != "none") {
+    saveCtpCfg(runnumber, timeStamp);
+  }
   return 0;
 }
 int CTPRunManager::setRunConfigBK(uint32_t runNumber, const std::string& cfg)
@@ -272,6 +275,9 @@ int CTPRunManager::processMessage(std::string& topic, const std::string& message
     }
     return ret;
   }
+  if (topic.find("rocnts") != std::string::npos) {
+    return 0;
+  }
   static int nerror = 0;
   if (topic.find("sox") != std::string::npos) {
     // get config
diff --git a/Detectors/CTP/workflowScalers/src/ctp-proxy.cxx b/Detectors/CTP/workflowScalers/src/ctp-proxy.cxx
index b2896215d1c6a..f8f8ad3c95fbb 100644
--- a/Detectors/CTP/workflowScalers/src/ctp-proxy.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctp-proxy.cxx
@@ -46,13 +46,14 @@
 #include "BookkeepingApi/BkpClient.h"
 using namespace o2::framework;
 using DetID = o2::detectors::DetID;
-InjectorFunction dcs2dpl(std::string& ccdbhost, std::string& bkhost, std::string& qchost, int qcwriteperiod)
+InjectorFunction dcs2dpl(std::string& ccdbhost, std::string& bkhost, std::string& qchost, int qcwriteperiod, std::string& ctpcfgdir)
 {
   auto runMgr = std::make_shared<o2::ctp::CTPRunManager>();
   runMgr->setCCDBHost(ccdbhost);
   runMgr->setBKHost(bkhost);
   runMgr->setQCDBHost(qchost);
   runMgr->setQCWritePeriod(qcwriteperiod);
+  runMgr->setCtpCfgDir(ctpcfgdir);
   runMgr->init();
   // runMgr->setClient(client);
   return [runMgr](TimingInfo&, ServiceRegistryRef const& services, fair::mq::Parts& parts, ChannelRetriever channelRetriever, size_t newTimesliceId, bool& stop) -> bool {
@@ -78,6 +79,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   workflowOptions.push_back(ConfigParamSpec{"ccdb-host", VariantType::String, "http://o2-ccdb.internal:8080", {"ccdb host"}});
   workflowOptions.push_back(ConfigParamSpec{"bk-host", VariantType::String, "none", {"bk host"}});
   workflowOptions.push_back(ConfigParamSpec{"qc-host", VariantType::String, "none", {"qc host"}});
+  workflowOptions.push_back(ConfigParamSpec{"ctpcfg-dir", VariantType::String, "none", {"ctp.cfg file directory"}});
   workflowOptions.push_back(ConfigParamSpec{"qc-writeperiod", VariantType::Int, 30, {"Period of writing to QCDB in units of 10secs, default = 30 (5 mins)"}});
 }
 
@@ -104,6 +106,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   std::string bkhost = config.options().get<std::string>("bk-host");
   std::string qchost = config.options().get<std::string>("qc-host");
   int qcwriteperiod = config.options().get<int>("qc-writeperiod");
+  std::string ctpcfgdir = config.options().get<std::string>("ctpcfg-dir");
   if (chan.empty()) {
     throw std::runtime_error("input channel is not provided");
   }
@@ -118,7 +121,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
     std::move(ctpCountersOutputs),
     // this is just default, can be overriden by --ctp-config-proxy '--channel-config..'
     chan.c_str(),
-    dcs2dpl(ccdbhost, bkhost, qchost, qcwriteperiod));
+    dcs2dpl(ccdbhost, bkhost, qchost, qcwriteperiod, ctpcfgdir));
   ctpProxy.labels.emplace_back(DataProcessorLabel{"input-proxy"});
   LOG(info) << "===> Proxy done";
   WorkflowSpec workflow;
diff --git a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
index cbe8fe5dd675f..58850d88eb2c6 100644
--- a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
@@ -167,6 +167,36 @@ int ctpCCDBManager::saveOrbitReset(long timeStamp)
   }
   return 0;
 }
+int ctpCCDBManager::saveCtpCfg(uint32_t runNumber, long timeStart)
+{
+  if (mCCDBHost == "none") {
+    LOG(info) << "CtpCfg not written to CCDB none";
+    return 0;
+  }
+  CtpCfg ctpcfg;
+  int ret = ctpcfg.readAndSave(mCtpCfgDir);
+  if (ret == 0) {
+    using namespace std::chrono_literals;
+    std::chrono::seconds days3 = 259200s;
+    std::chrono::seconds min10 = 600s;
+    long time3days = std::chrono::duration_cast<std::chrono::milliseconds>(days3).count();
+    long time10min = std::chrono::duration_cast<std::chrono::milliseconds>(min10).count();
+    long tmin = timeStart - time10min;
+    long tmax = timeStart + time3days;
+    o2::ccdb::CcdbApi api;
+    map<string, string> metadata; // can be empty
+    metadata["runNumber"] = std::to_string(runNumber);
+    api.init(mCCDBHost.c_str()); // or http://localhost:8080 for a local installation
+    // store abitrary user object in strongly typed manner
+    ret = api.storeAsTFileAny(&ctpcfg, mCCDBPathCtpCfg, metadata, tmin, tmax);
+    if (ret == 0) {
+      LOG(info) << "CtpCfg  saved in ccdb:" << mCCDBHost << " tmin:" << tmin << " tmax:" << tmax;
+    } else {
+      LOG(error) << "CtpCfg Problem writing to database ret:" << ret;
+    }
+  }
+  return ret;
+}
 CTPConfiguration ctpCCDBManager::getConfigFromCCDB(long timestamp, std::string run, bool& ok)
 {
   auto& mgr = o2::ccdb::BasicCCDBManager::instance();

From edea1644f2e9190af8aa8c50f372dc23a5902155 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 8 May 2025 21:16:48 +0200
Subject: [PATCH 0328/1764] GPU: Add debugSuffix option for debug files

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 1 +
 GPU/GPUTracking/Global/GPUChainTracking.cxx   | 6 +++---
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx | 2 --
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 638a3ed43d2aa..9e0aa32155f0d 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -296,6 +296,7 @@ AddOption(trdTrackModelO2, bool, false, "", 0, "Use O2 track model instead of GP
 AddOption(debugLevel, int32_t, -1, "debug", 'd', "Set debug level (-2 = silent, -1 = autoselect (-2 for O2, 0 for standalone))")
 AddOption(allocDebugLevel, int32_t, 0, "allocDebug", 0, "Some debug output for memory allocations (without messing with normal debug level)")
 AddOption(debugMask, uint32_t, 262143, "", 0, "Mask for debug output dumps to file")
+AddOption(debugLogSuffix, std::string, "", "debugSuffix", 0, "Suffix for debug log files with --debug 6")
 AddOption(serializeGPU, int8_t, 0, "", 0, "Synchronize after each kernel call (bit 1) and DMA transfer (bit 2) and identify failures")
 AddOption(recoTaskTiming, bool, 0, "", 0, "Perform summary timing after whole reconstruction tasks")
 AddOption(deterministicGPUReconstruction, int32_t, -1, "", 0, "Make CPU and GPU debug output comparable (sort / skip concurrent parts), -1 = automatic if debugLevel >= 6", def(1))
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index f8d4165477220..c1c3e368ce90c 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -378,7 +378,7 @@ int32_t GPUChainTracking::Init()
   }
 
   if (GetProcessingSettings().debugLevel >= 6) {
-    std::string filename = std::string(mRec->IsGPU() ? "GPU" : "CPU") + (mRec->slaveId() != -1 ? (std::string("_slave") + std::to_string(mRec->slaveId())) : std::string(mRec->slavesExist() ? "_master" : "")) + ".out";
+    std::string filename = std::string(mRec->IsGPU() ? "GPU" : "CPU") + (mRec->slaveId() != -1 ? (std::string("_slave") + std::to_string(mRec->slaveId())) : std::string(mRec->slavesExist() ? "_master" : "")) + GetProcessingSettings().debugLogSuffix + ".out";
     mDebugFile->open(filename.c_str());
   }
 
@@ -838,7 +838,7 @@ int32_t GPUChainTracking::RunChainFinalize()
 
     int32_t iKey;
     do {
-      Sleep(10);
+      usleep(10000);
       if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
         iKey = kbhit() ? getch() : 0;
         if (iKey == 27) {
@@ -847,7 +847,7 @@ int32_t GPUChainTracking::RunChainFinalize()
           break;
         } else if (iKey) {
           while (GetProcessingSettings().eventDisplay->getSendKey() != 0) {
-            Sleep(1);
+            usleep(1000);
           }
           GetProcessingSettings().eventDisplay->setSendKey(iKey);
         }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 5e7672022b3ff..035e257ca7952 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -47,8 +47,6 @@
 #include "TPCFastTransform.h"
 #include "CorrectionMapsHelper.h"
 
-#include "utils/linux_helpers.h"
-
 using namespace o2::gpu;
 
 #include "GPUO2DataTypes.h"

From 408bae4d0040288a7740d6b0b9328ea41e9585ff Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 8 May 2025 20:53:50 +0200
Subject: [PATCH 0329/1764] GPU: Add sorting of tracks of attached compressed
 clusters in deterministic mode

---
 .../DataCompression/GPUTPCCompression.cxx     | 26 ++++++------
 GPU/GPUTracking/Global/GPUChainTracking.h     |  1 +
 .../Global/GPUChainTrackingCompression.cxx    |  4 ++
 .../GPUChainTrackingDebugAndProfiling.cxx     | 42 +++++++++++++++++++
 4 files changed, 61 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index a107f749ddd77..82834a694d0ba 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -140,7 +140,7 @@ void GPUTPCCompression::DumpCompressedClusters(std::ostream& out)
   for (uint32_t i = 0; i < NSECTORS; i++) {
     out << "Sector " << i << ": ";
     for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-      out << O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j] << ", ";
+      out << (O.nSliceRowClusters ? O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j] : 0) << ", ";
     }
     out << "\n";
   }
@@ -153,18 +153,20 @@ void GPUTPCCompression::DumpCompressedClusters(std::ostream& out)
   }
   out << "\n\nUnattached Clusters\n";
   uint32_t offset = 0;
-  for (uint32_t i = 0; i < NSECTORS; i++) {
-    for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-      out << "Sector " << i << " Row " << j << ": ";
-      for (uint32_t k = 0; k < O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j]; k++) {
-        if (k && k % 10 == 0) {
-          out << "\n    ";
+  if (O.nSliceRowClusters) {
+    for (uint32_t i = 0; i < NSECTORS; i++) {
+      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+        out << "Sector " << i << " Row " << j << ": ";
+        for (uint32_t k = 0; k < O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j]; k++) {
+          if (k && k % 10 == 0) {
+            out << "\n    ";
+          }
+          const uint32_t l = k + offset;
+          out << "[" << (uint32_t)O.qTotU[l] << ", " << (uint32_t)O.qMaxU[l] << ", " << (uint32_t)O.flagsU[l] << ", " << (int32_t)O.padDiffU[l] << ", " << (int32_t)O.timeDiffU[l] << ", " << (uint32_t)O.sigmaPadU[l] << ", " << (uint32_t)O.sigmaTimeU[l] << "] ";
         }
-        const uint32_t l = k + offset;
-        out << "[" << (uint32_t)O.qTotU[l] << ", " << (uint32_t)O.qMaxU[l] << ", " << (uint32_t)O.flagsU[l] << ", " << (int32_t)O.padDiffU[l] << ", " << (int32_t)O.timeDiffU[l] << ", " << (uint32_t)O.sigmaPadU[l] << ", " << (uint32_t)O.sigmaTimeU[l] << "] ";
+        offset += O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
+        out << "\n";
       }
-      offset += O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
-      out << "\n";
     }
   }
   out << "\n\nAttached Clusters\n";
@@ -175,7 +177,7 @@ void GPUTPCCompression::DumpCompressedClusters(std::ostream& out)
       if (k && k % 10 == 0) {
         out << "\n    ";
       }
-      const uint32_t l1 = k + offset, l2 = k + offset - i;
+      const uint32_t l1 = offset + k, l2 = offset - i + k - 1;
       out << "[";
       if (k) {
         out << (int32_t)O.rowDiffA[l2] << ", " << (int32_t)O.sliceLegDiffA[l2] << ", " << (uint32_t)O.padResA[l2] << ", " << (uint32_t)O.timeResA[l2] << ", ";
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 13773a97d4e3d..2a2996895dbcf 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -235,6 +235,7 @@ class GPUChainTracking : public GPUChain
   void PrintDebugOutput();
   void PrintOutputStat();
   static void DumpClusters(std::ostream& out, const o2::tpc::ClusterNativeAccess* clusters);
+  static void DebugSortCompressedClusters(o2::tpc::CompressedClustersFlat* cls);
 
   bool ValidateSteps();
   bool ValidateSettings();
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 534c02a4c0a84..3bcd2390eae52 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -203,6 +203,10 @@ int32_t GPUChainTracking::RunTPCCompression()
     ((GPUChainTracking*)GetNextChainInQueue())->mRec->BlockStackedMemory(mRec);
   }
   mRec->PopNonPersistentMemory(RecoStep::TPCCompression, qStr2Tag("TPCCOMPR"));
+  if (GetProcessingSettings().deterministicGPUReconstruction) {
+    SynchronizeGPU();
+    DebugSortCompressedClusters(Compressor.mOutputFlat);
+  }
   DoDebugAndDump(RecoStep::TPCCompression, GPUChainTrackingDebugFlags::TPCCompressedClusters, Compressor, &GPUTPCCompression::DumpCompressedClusters, *mDebugFile);
   return 0;
 }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 903505068ad2c..00cf127162b94 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -20,6 +20,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <numeric>
 
 #ifdef GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE
 #include "bitmapfile.h"
@@ -348,3 +349,44 @@ void GPUChainTracking::DumpClusters(std::ostream& out, const o2::tpc::ClusterNat
     }
   }
 }
+
+void GPUChainTracking::DebugSortCompressedClusters(o2::tpc::CompressedClustersFlat* cls)
+{
+  o2::tpc::CompressedClusters c = *cls;
+  std::vector<uint32_t> sorted(c.nTracks), offsets(c.nTracks);
+  std::iota(sorted.begin(), sorted.end(), 0);
+  auto sorter = [&c](const auto a, const auto b) {
+    return std::tie(c.sliceA[a], c.rowA[a], c.timeA[a], c.padA[a], c.qPtA[a]) <
+           std::tie(c.sliceA[b], c.rowA[b], c.timeA[b], c.padA[b], c.qPtA[b]);
+  };
+  std::sort(sorted.begin(), sorted.end(), sorter);
+  uint32_t offset = 0;
+  for (uint32_t i = 0; i < c.nTracks; i++) {
+    offsets[i] = offset;
+    offset += c.nTrackClusters[i];
+  }
+
+  auto sortArray = [&c, &sorted, &offsets](auto* src, size_t totalSize, auto getOffset, auto getSize) {
+    auto buf = std::make_unique<std::remove_reference_t<decltype(src[0])>[]>(totalSize);
+    memcpy(buf.get(), src, totalSize * sizeof(*src));
+    uint32_t targetOffset = 0;
+    for (uint32_t i = 0; i < c.nTracks; i++) {
+      const uint32_t j = sorted[i];
+      memcpy(src + targetOffset, buf.get() + getOffset(offsets[j], j), getSize(j) * sizeof(*src));
+      targetOffset += getSize(j);
+    }
+  };
+  auto sortMultiple = [&sortArray](size_t totalSize, auto getOffset, auto getSize, auto&&... arrays) {
+    (..., sortArray(std::forward<decltype(arrays)>(arrays), totalSize, getOffset, getSize));
+  };
+  auto getFullOffset = [](uint32_t off, uint32_t ind) { return off; };
+  auto getReducedOffset = [](uint32_t off, uint32_t ind) { return off - ind; };
+  auto getIndex = [](uint32_t off, uint32_t ind) { return ind; };
+  auto getN = [&c](uint32_t j) { return c.nTrackClusters[j]; };
+  auto getN1 = [&c](uint32_t j) { return c.nTrackClusters[j] - 1; };
+  auto get1 = [](uint32_t j) { return 1; };
+
+  sortMultiple(c.nAttachedClusters, getFullOffset, getN, c.qTotA, c.qMaxA, c.flagsA, c.sigmaPadA, c.sigmaTimeA);
+  sortMultiple(c.nAttachedClustersReduced, getReducedOffset, getN1, c.rowDiffA, c.sliceLegDiffA, c.padResA, c.timeResA);
+  sortMultiple(c.nTracks, getIndex, get1, c.qPtA, c.rowA, c.sliceA, c.timeA, c.padA, c.nTrackClusters); // NOTE: This must be last, since nTrackClusters is used for handling the arrays above!
+}

From 64dd944342374edfef4da03b1e5b64c2cfb5bc3f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 8 May 2025 23:26:22 +0200
Subject: [PATCH 0330/1764] GPU: Make GPUCommonAlgorithm::sortInBlock
 deterministic with GPUCA_DETERMINISTIC_MODE

---
 GPU/Common/GPUCommonAlgorithm.h | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/GPU/Common/GPUCommonAlgorithm.h b/GPU/Common/GPUCommonAlgorithm.h
index 417c9e0d1f8c1..d0643391246a8 100644
--- a/GPU/Common/GPUCommonAlgorithm.h
+++ b/GPU/Common/GPUCommonAlgorithm.h
@@ -283,21 +283,29 @@ GPUdi() void GPUCommonAlgorithm::sortInBlock(T* begin, T* end, const S& comp)
 #ifndef GPUCA_GPUCODE
   GPUCommonAlgorithm::sort(begin, end, comp);
 #else
-  int32_t n = end - begin;
-  for (int32_t i = 0; i < n; i++) {
-    for (int32_t tIdx = get_local_id(0); tIdx < n; tIdx += get_local_size(0)) {
-      int32_t offset = i % 2;
-      int32_t curPos = 2 * tIdx + offset;
-      int32_t nextPos = curPos + 1;
-
-      if (nextPos < n) {
-        if (!comp(begin[curPos], begin[nextPos])) {
-          IterSwap(&begin[curPos], &begin[nextPos]);
+  GPUCA_DETERMINISTIC_CODE( // clang-format off
+    GPUbarrier();
+    if (get_local_id(0) == 0) {
+      GPUCommonAlgorithm::sort(begin, end, comp);
+    }
+    GPUbarrier();
+  , // !GPUCA_DETERMINISTIC_CODE
+    int32_t n = end - begin;
+    for (int32_t i = 0; i < n; i++) {
+      for (int32_t tIdx = get_local_id(0); tIdx < n; tIdx += get_local_size(0)) {
+        int32_t offset = i % 2;
+        int32_t curPos = 2 * tIdx + offset;
+        int32_t nextPos = curPos + 1;
+
+        if (nextPos < n) {
+          if (!comp(begin[curPos], begin[nextPos])) {
+            IterSwap(&begin[curPos], &begin[nextPos]);
+          }
         }
       }
+      GPUbarrier();
     }
-    GPUbarrier();
-  }
+  ) // clang-format on
 #endif
 }
 

From fff75cfa60148feb0a51b524e956aeec7167a572 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 8 May 2025 23:51:00 +0200
Subject: [PATCH 0331/1764] GPU: Use total sorting in deterministic mode for
 unattached clusters

---
 .../GPUTPCCompressionKernels.cxx              | 40 +++++++++++++------
 1 file changed, 28 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 5dbbf63ca8264..3b88c8764d0fd 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -148,19 +148,19 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
 }
 
 template <>
-GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<0>::operator()(uint32_t a, uint32_t b) const
+GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<GPUSettings::SortTime>::operator()(uint32_t a, uint32_t b) const
 {
   return mClsPtr[a].getTimePacked() < mClsPtr[b].getTimePacked();
 }
 
 template <>
-GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<1>::operator()(uint32_t a, uint32_t b) const
+GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<GPUSettings::SortPad>::operator()(uint32_t a, uint32_t b) const
 {
   return mClsPtr[a].padPacked < mClsPtr[b].padPacked;
 }
 
 template <>
-GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<2>::operator()(uint32_t a, uint32_t b) const
+GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<GPUSettings::SortZTimePad>::operator()(uint32_t a, uint32_t b) const
 {
   if (mClsPtr[a].getTimePacked() >> 3 == mClsPtr[b].getTimePacked() >> 3) {
     return mClsPtr[a].padPacked < mClsPtr[b].padPacked;
@@ -169,7 +169,7 @@ GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<2>::opera
 }
 
 template <>
-GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<3>::operator()(uint32_t a, uint32_t b) const
+GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>::operator()(uint32_t a, uint32_t b) const
 {
   if (mClsPtr[a].padPacked >> 3 == mClsPtr[b].padPacked >> 3) {
     return mClsPtr[a].getTimePacked() < mClsPtr[b].getTimePacked();
@@ -177,6 +177,18 @@ GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<3>::opera
   return mClsPtr[a].padPacked < mClsPtr[b].padPacked;
 }
 
+template <> // Deterministic comparison
+GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<4>::operator()(uint32_t a, uint32_t b) const
+{
+  if (mClsPtr[a].getTimePacked() != mClsPtr[b].getTimePacked()) {
+    return mClsPtr[a].getTimePacked() < mClsPtr[b].getTimePacked();
+  }
+  if (mClsPtr[a].padPacked != mClsPtr[b].padPacked) {
+    return mClsPtr[a].padPacked < mClsPtr[b].padPacked;
+  }
+  return mClsPtr[a].qTot < mClsPtr[b].qTot;
+}
+
 template <>
 GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1unattached>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() processors)
 {
@@ -261,15 +273,19 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
 #ifdef GPUCA_GPUCODE
         static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE);
 #endif
-        if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZPadTime) {
+        GPUCA_DETERMINISTIC_CODE( // clang-format off
           CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>(clusters->clusters[iSector][iRow]));
-        } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZTimePad) {
-          CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZTimePad>(clusters->clusters[iSector][iRow]));
-        } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortPad) {
-          CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortPad>(clusters->clusters[iSector][iRow]));
-        } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortTime) {
-          CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortTime>(clusters->clusters[iSector][iRow]));
-        }
+        , // !GPUCA_DETERMINISTIC_CODE
+          if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZPadTime) {
+            CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>(clusters->clusters[iSector][iRow]));
+          } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZTimePad) {
+            CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZTimePad>(clusters->clusters[iSector][iRow]));
+          } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortPad) {
+            CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortPad>(clusters->clusters[iSector][iRow]));
+          } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortTime) {
+            CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortTime>(clusters->clusters[iSector][iRow]));
+          }
+        ) // clang-format on
         GPUbarrier();
       }
 

From b1c76a5365321adbe8f61bd8085ccb258a6304f1 Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Fri, 9 May 2025 11:40:19 +0200
Subject: [PATCH 0332/1764] fix: remove debug

---
 Detectors/CTP/reconstruction/src/RawDataDecoder.cxx | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
index 797dd0e300519..74bd08ce943ee 100644
--- a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
+++ b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
@@ -302,8 +302,7 @@ int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2
     }
     // std::cout << "trgclassmask:" << std::hex << trgclassmask << std::dec << std::endl;
     ret = shiftInputs(digitsMap, digits, mTFOrbit);
-    // if (mCheckConsistency) {
-    if (1) {
+    if (mCheckConsistency) {
       ret = checkReadoutConsistentncy(digits, trgclassmask, trgclassmaskNOTRGDet);
     }
   }

From b1040ccee8df8978344aa9956f58b8ea57abdf56 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 9 May 2025 12:18:39 +0200
Subject: [PATCH 0333/1764] Avoid including BasicCCDBManager in headers exposed
 to ROOT. (#14254)

Root will happily embed references to curl.h and / or the kernel headers if found on the build machine
and die if they are not there on the node.
---
 .../CTP/include/DataFormatsCTP/CTPRateFetcher.h      | 12 +++++++-----
 DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx     |  1 +
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/DataFormats/Detectors/CTP/include/DataFormatsCTP/CTPRateFetcher.h b/DataFormats/Detectors/CTP/include/DataFormatsCTP/CTPRateFetcher.h
index 6b7802feb15ad..78c4245b16b20 100644
--- a/DataFormats/Detectors/CTP/include/DataFormatsCTP/CTPRateFetcher.h
+++ b/DataFormats/Detectors/CTP/include/DataFormatsCTP/CTPRateFetcher.h
@@ -14,14 +14,16 @@
 
 #include <string>
 
-#include "CCDB/BasicCCDBManager.h"
 #include "DataFormatsParameters/GRPLHCIFData.h"
 #include "DataFormatsCTP/Configuration.h"
 #include "DataFormatsCTP/Scalers.h"
 
-namespace o2
+namespace o2::ccdb
 {
-namespace ctp
+class BasicCCDBManager;
+}
+
+namespace o2::ctp
 {
 
 class CTPRateFetcher
@@ -54,7 +56,7 @@ class CTPRateFetcher
   o2::parameters::GRPLHCIFData mLHCIFdata{};
   ClassDefNV(CTPRateFetcher, 1);
 };
-} // namespace ctp
-} // namespace o2
+} // namespace o2::ctp
+
 
 #endif // COMMON_CCDB_CTPRATEFETCHER_H_
diff --git a/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx b/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
index 67e59aad3ea24..d899fcafec47d 100644
--- a/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
+++ b/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "DataFormatsCTP/CTPRateFetcher.h"
+#include "CCDB/BasicCCDBManager.h"
 
 #include <map>
 #include <vector>

From fb08c353c9118f73c75fd4a41c1545ca541aef57 Mon Sep 17 00:00:00 2001
From: ariedel-cern <85537041+ariedel-cern@users.noreply.github.com>
Date: Fri, 9 May 2025 19:23:07 +0200
Subject: [PATCH 0334/1764] TPC QC: Add getter for occupancy to Cluster class
 (#14251)

Feat: add getOccupancy method to Cluster class
---
 Detectors/TPC/qc/include/TPCQC/Clusters.h | 6 ++++--
 Detectors/TPC/qc/src/Clusters.cxx         | 9 +++++++++
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/Detectors/TPC/qc/include/TPCQC/Clusters.h b/Detectors/TPC/qc/include/TPCQC/Clusters.h
index ca9c53a43b3f6..b61c27e8bf0e6 100644
--- a/Detectors/TPC/qc/include/TPCQC/Clusters.h
+++ b/Detectors/TPC/qc/include/TPCQC/Clusters.h
@@ -17,10 +17,10 @@
 #ifndef AliceO2_TPC_CLUSTERS_H
 #define AliceO2_TPC_CLUSTERS_H
 
-//root includes
+// root includes
 #include "TCanvas.h"
 
-//o2 includes
+// o2 includes
 #include "TPCBase/CalDet.h"
 #include "TPCBase/Sector.h"
 #include "DataFormatsTPC/Defs.h"
@@ -75,6 +75,8 @@ class Clusters
   CalPad& getSigmaPad() { return mSigmaPad; }
   CalPad& getTimeBin() { return mTimeBin; }
 
+  CalPad getOccupancy(int nHBFPerTF = 32);
+
   void endTF() { ++mProcessedTFs; }
 
   size_t getProcessedTFs() { return mProcessedTFs; }
diff --git a/Detectors/TPC/qc/src/Clusters.cxx b/Detectors/TPC/qc/src/Clusters.cxx
index 3a7b1d8481b16..4bf59ced195ed 100644
--- a/Detectors/TPC/qc/src/Clusters.cxx
+++ b/Detectors/TPC/qc/src/Clusters.cxx
@@ -22,8 +22,10 @@
 #include "TPCBase/ROC.h"
 #include "TPCBase/CRU.h"
 #include "TPCBase/Mapper.h"
+#include "TPCBase/ParameterElectronics.h"
 #include "DataFormatsTPC/ClusterNative.h"
 #include "DataFormatsTPC/KrCluster.h"
+#include "CommonConstants/LHCConstants.h"
 
 ClassImp(o2::tpc::qc::Clusters);
 
@@ -152,6 +154,13 @@ void Clusters::reset()
   mProcessedTFs = 0;
 }
 
+//______________________________________________________________________________
+o2::tpc::CalPad Clusters::getOccupancy(int nHBFPerTF)
+{
+  o2::tpc::CalPad occupancy = mNClusters;
+  occupancy /= float(mProcessedTFs * (o2::constants::lhc::LHCMaxBunches * nHBFPerTF) / float(o2::tpc::ParameterElectronics::TIMEBININBC));
+  return occupancy;
+}
 //______________________________________________________________________________
 void Clusters::merge(Clusters& clusters)
 {

From a917b6b5c387e4a6ec2a232b317d5e7468b99091 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 9 May 2025 19:56:48 +0200
Subject: [PATCH 0335/1764] Add TPC occupancy in 10bins/drift in trackStudy

---
 .../study/src/TrackingStudy.cxx               | 76 ++++++++++++-------
 1 file changed, 47 insertions(+), 29 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index f206c43f7f57a..a74349bdeba15 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -95,7 +95,7 @@ class TrackingStudySpec : public Task
   std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
   std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOutVtx;
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter; ///< TPC refitter used for TPC tracks refit during the reconstruction
-  std::vector<float> mTBinClOccAft, mTBinClOccBef, mTBinClOccWgh; ///< TPC occupancy histo: i-th entry is the integrated occupancy for ~1 orbit starting/preceding from the TB = i*mNTPCOccBinLength
+  std::vector<float> mMltHistTB, mTBinClOccAft, mTBinClOccBef, mTBinClOccWgh; ///< TPC occupancy histo: i-th entry is the integrated occupancy for ~1 orbit starting/preceding from the TB = i*mNTPCOccBinLength
   std::unique_ptr<TF1> mOccWghFun;
   float mITSROFrameLengthMUS = 0.f;
   float mTPCTBinMUS = 0.f; // TPC bin in microseconds
@@ -107,6 +107,7 @@ class TrackingStudySpec : public Task
   float mMinX = 46.;
   float mMaxEta = 0.8;
   float mMinPt = 0.1;
+  int mNOccBinsDrift = 10;
   int mMinTPCClusters = 60;
   int mNTPCOccBinLength = 0; ///< TPC occ. histo bin length in TBs
   int mNHBPerTF = 0;
@@ -142,6 +143,10 @@ void TrackingStudySpec::init(InitContext& ic)
   mDCAYFormula = ic.options().get<std::string>("dcay-vs-pt");
   mDCAZFormula = ic.options().get<std::string>("dcaz-vs-pt");
   mDoPairsCorr = ic.options().get<bool>("pair-correlations");
+  mNOccBinsDrift = ic.options().get<int>("noccbins");
+  if (mNOccBinsDrift < 3) {
+    mNOccBinsDrift = 3;
+  }
   auto str = ic.options().get<std::string>("occ-weight-fun");
   if (!str.empty()) {
     mOccWghFun = std::make_unique<TF1>("occFun", str.c_str(), -100., 100.);
@@ -172,42 +177,23 @@ void TrackingStudySpec::run(ProcessingContext& pc)
     mTBinClOccAft.resize(nTPCOccBins);
     mTBinClOccBef.resize(nTPCOccBins);
     float sm = 0., tb = 0.5 * mNTPCOccBinLength;
-    /* // at the moment not used
-    if (mOccWghFun) {
-      mTBinClOccWgh.resize(nTPCBins);
-      float occBin2MUS = 8 * o2::constants::lhc::LHCBunchSpacingMUS;
-      int covWghTB = TMath::NInt(100./occBin2MUS); // coverage of weighted occ. in TBins
-      for (int i = 0; i < nTPCBins; i++) {
-  sm = 0.;
-  for (int j=-covWghTB;j<covWghTB;j++) {
-    if (j+i<0 || j+i>=nTPCBins) {
-      continue;
-    }
-    sm += mOccWghFun->Eval(j*occBin2MUS)*mTPCRefitter->getParam()->GetUnscaledMult(j+i);
-  }
-  mTBinClOccWgh[i] = sm;
-      }
-    } else {
-      mTBinClOccWgh.resize(1);
-    }
-    */
-    std::vector<float> mltHistTB(nTPCOccBins);
+    mMltHistTB.resize(nTPCOccBins);
     for (int i = 0; i < nTPCOccBins; i++) {
-      mltHistTB[i] = mTPCRefitter->getParam()->GetUnscaledMult(tb);
+      mMltHistTB[i] = mTPCRefitter->getParam()->GetUnscaledMult(tb);
       tb += mNTPCOccBinLength;
     }
     for (int i = nTPCOccBins; i--;) {
-      sm += mltHistTB[i];
+      sm += mMltHistTB[i];
       if (i + sumBins < nTPCOccBins) {
-        sm -= mltHistTB[i + sumBins];
+        sm -= mMltHistTB[i + sumBins];
       }
       mTBinClOccAft[i] = sm;
     }
     sm = 0;
     for (int i = 0; i < nTPCOccBins; i++) {
-      sm += mltHistTB[i];
+      sm += mMltHistTB[i];
       if (i - sumBins > 0) {
-        sm -= mltHistTB[i - sumBins];
+        sm -= mMltHistTB[i - sumBins];
       }
       mTBinClOccBef[i] = sm;
     }
@@ -271,13 +257,17 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
   o2::dataformats::PrimaryVertexExt pveDummy;
   o2::dataformats::PrimaryVertexExt vtxDummy(mMeanVtx.getPos(), {}, {}, 0);
   std::vector<o2::dataformats::PrimaryVertexExt> pveVec(nv);
+  std::vector<float> tpcOccAftV, tpcOccBefV;
   pveVec.back() = vtxDummy;
   const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
   float tBiasITS = alpParams.roFrameBiasInBC * o2::constants::lhc::LHCBunchSpacingMUS;
   const o2::ft0::InteractionTag& ft0Params = o2::ft0::InteractionTag::Instance();
   std::vector<o2::dataformats::TrackInfoExt> trcExtVec;
   std::vector<o2::trackstudy::TrackPairInfo> trcPairsVec;
-  auto vdrit = mTPCVDriftHelper.getVDriftObject().getVDrift();
+  auto vdrift = mTPCVDriftHelper.getVDriftObject().getVDrift();
+  float maxDriftTB = 250.f / vdrift / (o2::constants::lhc::LHCBunchSpacingMUS * 8);
+  int groupOcc = std::ceil(maxDriftTB / mNOccBinsDrift / mNTPCOccBinLength);
+
   bool tpcTrackOK = recoData.isTrackSourceLoaded(GTrackID::TPC);
 
   auto fillTPCClInfo = [&recoData, this](const o2::tpc::TrackTPC& trc, o2::dataformats::TrackInfoExt& trExt, float timestampTB = -1e9) {
@@ -391,6 +381,8 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
       }
     }
   };
+  tpcOccAftV.resize(mNOccBinsDrift);
+  tpcOccBefV.resize(mNOccBinsDrift);
 
   for (int iv = 0; iv < nv; iv++) {
     LOGP(debug, "processing PV {} of {}", iv, nv);
@@ -455,7 +447,7 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
           continue;
         }
         if (iv < nv - 1 && is == GTrackID::TPC && tpcTr && !tpcTr->hasBothSidesClusters()) { // for unconstrained TPC tracks correct track Z
-          float corz = vdrit * (tpcTr->getTime0() * mTPCTBinMUS - pvvec[iv].getTimeStamp().getTimeStamp());
+          float corz = vdrift * (tpcTr->getTime0() * mTPCTBinMUS - pvvec[iv].getTimeStamp().getTimeStamp());
           if (tpcTr->hasASideClustersOnly()) {
             corz = -corz; // A-side
           }
@@ -500,7 +492,7 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
             } else {
               o2::track::TrackParCov tmpTPC(*tpcTr);
               if (iv < nv - 1 && is == GTrackID::TPC && tpcTr && !tpcTr->hasBothSidesClusters()) { // for unconstrained TPC tracks correct track Z
-                float corz = vdrit * (tpcTr->getTime0() * mTPCTBinMUS - pvvec[iv].getTimeStamp().getTimeStamp());
+                float corz = vdrift * (tpcTr->getTime0() * mTPCTBinMUS - pvvec[iv].getTimeStamp().getTimeStamp());
                 if (tpcTr->hasASideClustersOnly()) {
                   corz = -corz; // A-side
                 }
@@ -554,10 +546,35 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
       int tb = pveVec[iv].getTimeStamp().getTimeStamp() * mTPCTBinMUSInv * mNTPCOccBinLengthInv;
       tpcOccBef = tb < 0 ? mTBinClOccBef[0] : (tb >= mTBinClOccBef.size() ? mTBinClOccBef.back() : mTBinClOccBef[tb]);
       tpcOccAft = tb < 0 ? mTBinClOccAft[0] : (tb >= mTBinClOccAft.size() ? mTBinClOccAft.back() : mTBinClOccAft[tb]);
+      int tbc = pveVec[iv].getTimeStamp().getTimeStamp() * mTPCTBinMUSInv * mNTPCOccBinLengthInv - groupOcc / 2.;
+      for (int iob = 0; iob < mNOccBinsDrift; iob++) {
+        float sm = 0;
+        for (int ig = 0; ig < groupOcc; ig++) {
+          int ocb = tbc + ig + groupOcc * iob;
+          if (ocb < 0 || ocb >= (int)mMltHistTB.size()) {
+            sm = -1;
+            break;
+          }
+          sm += mMltHistTB[ocb];
+        }
+        tpcOccAftV[iob] = sm;
+        //
+        sm = 0;
+        for (int ig = 0; ig < groupOcc; ig++) {
+          int ocb = tbc + ig - groupOcc * iob;
+          if (ocb < 0 || ocb >= (int)mMltHistTB.size()) {
+            sm = -1;
+            break;
+          }
+          sm += mMltHistTB[ocb];
+        }
+        tpcOccBefV[iob] = sm;
+      }
     }
     (*mDBGOut) << "trpv"
                << "orbit=" << recoData.startIR.orbit << "tfID=" << TFCount
                << "tpcOccBef=" << tpcOccBef << "tpcOccAft=" << tpcOccAft
+               << "tpcOccBefV=" << tpcOccBefV << "tpcOccAftV=" << tpcOccAftV
                << "pve=" << pveVec[iv] << "trc=" << trcExtVec << "\n";
 
     if (mDoPairsCorr) {
@@ -752,6 +769,7 @@ DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mas
     {"with-its-only", VariantType::Bool, false, {"Store tracks with ITS only"}},
     {"pair-correlations", VariantType::Bool, false, {"Do pairs correlation"}},
     {"occ-weight-fun", VariantType::String, "(x>=-40&&x<-5) ? (1./1225*pow(x+40,2)) : ((x>-5&&x<15) ? 1. : ((x>=15&&x<40) ? (-0.4/25*x+1.24 ) : ( (x>40&&x<100) ? -0.4/60*x+0.6+0.8/3 : 0)))", {"Occupancy weighting f-n vs time in musec"}},
+    {"noccbins", VariantType::Int, 10, {"Number of occupancy bins per full drift time"}},
     {"min-x-prop", VariantType::Float, 100.f, {"track should be propagated to this X at least"}},
   };
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);

From 1bcf367115a918253404a92a9537311646c895e1 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 11 May 2025 18:47:32 +0200
Subject: [PATCH 0336/1764] DPL: fix rate limiting handling (#14255)

On success, FairMQ returns a positive number of bytes, not 0.
---
 Framework/Core/src/CommonDataProcessors.cxx | 26 ++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/CommonDataProcessors.cxx b/Framework/Core/src/CommonDataProcessors.cxx
index 737e1b7e635c8..c2431b3ab068d 100644
--- a/Framework/Core/src/CommonDataProcessors.cxx
+++ b/Framework/Core/src/CommonDataProcessors.cxx
@@ -30,9 +30,11 @@
 #include "Framework/RuntimeError.h"
 #include "Framework/RateLimiter.h"
 #include "Framework/PluginManager.h"
+#include "Framework/Signpost.h"
 #include <Monitoring/Monitoring.h>
 
 #include <fairmq/Device.h>
+#include <uv.h>
 #include <fstream>
 #include <functional>
 #include <memory>
@@ -40,6 +42,9 @@
 
 using namespace o2::framework::data_matcher;
 
+// Special log to track callbacks we know about
+O2_DECLARE_DYNAMIC_LOG(callbacks);
+
 namespace o2::framework
 {
 
@@ -145,6 +150,10 @@ DataProcessorSpec CommonDataProcessors::getGlobalFairMQSink(std::vector<InputSpe
 
 void retryMetricCallback(uv_async_t* async)
 {
+  O2_SIGNPOST_ID_FROM_POINTER(cid, callbacks, async);
+  O2_SIGNPOST_EVENT_EMIT(callbacks, cid, "rate-limiting", "Attempting again propagating rate-limiting information.");
+
+  // Check if this is a source device
   static size_t lastTimeslice = -1;
   auto* services = (ServiceRegistryRef*)async->data;
   auto& timesliceIndex = services->get<TimesliceIndex>();
@@ -152,20 +161,35 @@ void retryMetricCallback(uv_async_t* async)
   auto channel = device->GetChannels().find("metric-feedback");
   auto oldestPossingTimeslice = timesliceIndex.getOldestPossibleOutput().timeslice.value;
   if (channel == device->GetChannels().end()) {
+    O2_SIGNPOST_EVENT_EMIT(callbacks, cid, "rate-limiting", "Could not find metric-feedback channel.");
     return;
   }
   fair::mq::MessagePtr payload(device->NewMessage());
   payload->Rebuild(&oldestPossingTimeslice, sizeof(int64_t), nullptr, nullptr);
   auto consumed = oldestPossingTimeslice;
 
+  size_t start = uv_hrtime();
   int64_t result = channel->second[0].Send(payload, 100);
+  size_t stop = uv_hrtime();
   // If the sending worked, we do not retry.
-  if (result != 0) {
+  if (result <= 0) {
+    // Forcefully slow down in case FairMQ returns earlier than expected...
+    int64_t ellapsed = (stop - start) / 1000000;
+    if (ellapsed < 100) {
+      O2_SIGNPOST_EVENT_EMIT(callbacks, cid, "rate-limiting",
+                             "FairMQ returned %llu earlier than expected. Sleeping %llu ms more before, retrying.",
+                             result, ellapsed);
+      uv_sleep(100 - ellapsed);
+    } else {
+      O2_SIGNPOST_EVENT_EMIT(callbacks, cid, "rate-limiting",
+                             "FairMQ returned %llu, unable to send last consumed timeslice to source for %llu ms, retrying.", result, ellapsed);
+    }
     // If the sending did not work, we keep trying until it actually works.
     // This will schedule other tasks in the queue, so the processing of the
     // data will still happen.
     uv_async_send(async);
   } else {
+    O2_SIGNPOST_EVENT_EMIT(callbacks, cid, "rate-limiting", "Send %llu bytes, Last timeslice now set to %zu.", result, consumed);
     lastTimeslice = consumed;
   }
 }

From f926be7e0b3e05ddce8e040f264b3eadf25a5a84 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 11 May 2025 15:37:02 +0200
Subject: [PATCH 0337/1764] Fix typo in the RecoContainer::getTrackTimeTPCTRD

Thanks for Felix for spotting
---
 DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx b/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
index 39cc05d8a69e7..d4b4e2b89cbb0 100644
--- a/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
+++ b/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
@@ -1594,7 +1594,7 @@ void RecoContainer::getTrackTimeITSTPCTRD(GTrackID gid, float& t, float& tErr) c
 //________________________________________________________
 void RecoContainer::getTrackTimeTPCTRD(GTrackID gid, float& t, float& tErr) const
 {
-  const auto trigTPCTRD = getITSTPCTRDTriggers();
+  const auto trigTPCTRD = getTPCTRDTriggers();
   // very slow: find the trigger this track belongs to
   for (const auto& trig : trigTPCTRD) {
     if (trig.getTrackRefs().getEntriesBound() > gid.getIndex()) {

From 04ba3bd18306dd47a245d32f6556eec86d546a4b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 12 May 2025 10:46:51 +0200
Subject: [PATCH 0338/1764] GPU: Fix performance regression: DETERMINISTIC CODE
 was used unintentionally in 2 places

---
 GPU/Common/GPUCommonAlgorithm.h               | 37 +++++++++----------
 .../Base/cuda/GPUReconstructionCUDArtc.cu     |  5 ++-
 .../GPUTPCCompressionKernels.cxx              | 24 ++++++------
 3 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/GPU/Common/GPUCommonAlgorithm.h b/GPU/Common/GPUCommonAlgorithm.h
index d0643391246a8..8cd53ec5e0609 100644
--- a/GPU/Common/GPUCommonAlgorithm.h
+++ b/GPU/Common/GPUCommonAlgorithm.h
@@ -282,30 +282,27 @@ GPUdi() void GPUCommonAlgorithm::sortInBlock(T* begin, T* end, const S& comp)
 {
 #ifndef GPUCA_GPUCODE
   GPUCommonAlgorithm::sort(begin, end, comp);
+#elif defined(GPUCA_DETERMINISTIC_MODE) // Not using GPUCA_DETERMINISTIC_CODE, which is enforced in TPC compression
+  if (get_local_id(0) == 0) {
+    GPUCommonAlgorithm::sort(begin, end, comp);
+  }
+  GPUbarrier();
 #else
-  GPUCA_DETERMINISTIC_CODE( // clang-format off
-    GPUbarrier();
-    if (get_local_id(0) == 0) {
-      GPUCommonAlgorithm::sort(begin, end, comp);
-    }
-    GPUbarrier();
-  , // !GPUCA_DETERMINISTIC_CODE
-    int32_t n = end - begin;
-    for (int32_t i = 0; i < n; i++) {
-      for (int32_t tIdx = get_local_id(0); tIdx < n; tIdx += get_local_size(0)) {
-        int32_t offset = i % 2;
-        int32_t curPos = 2 * tIdx + offset;
-        int32_t nextPos = curPos + 1;
-
-        if (nextPos < n) {
-          if (!comp(begin[curPos], begin[nextPos])) {
-            IterSwap(&begin[curPos], &begin[nextPos]);
-          }
+  int32_t n = end - begin;
+  for (int32_t i = 0; i < n; i++) {
+    for (int32_t tIdx = get_local_id(0); tIdx < n; tIdx += get_local_size(0)) {
+      int32_t offset = i % 2;
+      int32_t curPos = 2 * tIdx + offset;
+      int32_t nextPos = curPos + 1;
+
+      if (nextPos < n) {
+        if (!comp(begin[curPos], begin[nextPos])) {
+          IterSwap(&begin[curPos], &begin[nextPos]);
         }
       }
-      GPUbarrier();
     }
-  ) // clang-format on
+    GPUbarrier();
+  }
 #endif
 }
 
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
index 50a568ab345cf..805397c9b430e 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
@@ -14,9 +14,12 @@
 
 #define GPUCA_GPUCODE_GENRTC
 #define GPUCA_GPUCODE_COMPILEKERNELS
+
+// Keep some preprocessor calls unprocessed
 #define GPUCA_RTC_SPECIAL_CODE(...) GPUCA_RTC_SPECIAL_CODE(__VA_ARGS__)
 #define GPUCA_DETERMINISTIC_CODE(...) GPUCA_DETERMINISTIC_CODE(__VA_ARGS__)
-// GPUReconstructionCUDAIncludesSystem.h prependended without preprocessor running
+
+// GPUReconstructionCUDAIncludesSystem.h prependended by CMakewithout preprocessor running
 #include "GPUReconstructionCUDADef.h"
 #include "GPUReconstructionIncludesDeviceAll.h"
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 3b88c8764d0fd..bba97e9eace9b 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -273,19 +273,19 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
 #ifdef GPUCA_GPUCODE
         static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE);
 #endif
-        GPUCA_DETERMINISTIC_CODE( // clang-format off
+#ifdef GPUCA_DETERMINISTIC_MODE // Not using GPUCA_DETERMINISTIC_CODE, which is enforced in TPC compression
+        CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>(clusters->clusters[iSector][iRow]));
+#else  // GPUCA_DETERMINISTIC_MODE
+        if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZPadTime) {
           CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>(clusters->clusters[iSector][iRow]));
-        , // !GPUCA_DETERMINISTIC_CODE
-          if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZPadTime) {
-            CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>(clusters->clusters[iSector][iRow]));
-          } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZTimePad) {
-            CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZTimePad>(clusters->clusters[iSector][iRow]));
-          } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortPad) {
-            CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortPad>(clusters->clusters[iSector][iRow]));
-          } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortTime) {
-            CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortTime>(clusters->clusters[iSector][iRow]));
-          }
-        ) // clang-format on
+        } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZTimePad) {
+          CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZTimePad>(clusters->clusters[iSector][iRow]));
+        } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortPad) {
+          CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortPad>(clusters->clusters[iSector][iRow]));
+        } else if (param.rec.tpc.compressionSortOrder == GPUSettings::SortTime) {
+          CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortTime>(clusters->clusters[iSector][iRow]));
+        }
+#endif // GPUCA_DETERMINISTIC_MODE
         GPUbarrier();
       }
 

From ea6e536b48052186c6bd263cd9df1e83e3f16ce7 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 12 May 2025 20:49:42 +0200
Subject: [PATCH 0339/1764] DPL: do not create unneeded statics (#14261)

---
 .../Core/include/Framework/TableBuilder.h     | 28 ++++++++-----------
 Framework/Core/src/TableBuilder.cxx           |  4 +--
 2 files changed, 14 insertions(+), 18 deletions(-)

diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index 32fe78b852eff..936a8a04d5a5a 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -855,7 +855,7 @@ auto makeEmptyTable(const char* name, framework::pack<Cs...> p)
 }
 
 std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
-                                            expressions::Projector* projectors, std::vector<std::shared_ptr<arrow::Field>> const& fields, const char* name, std::shared_ptr<gandiva::Projector>& projector);
+                                            expressions::Projector* projectors, const char* name, std::shared_ptr<gandiva::Projector>& projector);
 
 /// Expression-based column generator to materialize columns
 template <aod::is_aod_hash D>
@@ -867,10 +867,9 @@ auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* na
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, placeholders_pack_t{});
   }
-  static auto fields = o2::soa::createFieldsFromColumns(placeholders_pack_t{});
-  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(placeholders_pack_t{}));
 
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(placeholders_pack_t{}), projectors, fields, name, projector);
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(placeholders_pack_t{}), projectors, name, projector);
 }
 
 template <aod::is_aod_hash D>
@@ -881,10 +880,9 @@ auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, o
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, placeholders_pack_t{});
   }
-  static auto fields = o2::soa::createFieldsFromColumns(placeholders_pack_t{});
-  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(placeholders_pack_t{}));
 
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(placeholders_pack_t{}), projectors, fields, name, projector);
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(placeholders_pack_t{}), projectors, name, projector);
 }
 
 template <aod::is_aod_hash D>
@@ -896,15 +894,15 @@ auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* na
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, expression_pack_t{});
   }
-  static auto fields = o2::soa::createFieldsFromColumns(expression_pack_t{});
-  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
+
   auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
   {
     return {{std::move(C::Projector())...}};
   }
   (expression_pack_t{});
 
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name, projector);
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), name, projector);
 }
 
 template <aod::is_aod_hash D>
@@ -915,15 +913,14 @@ auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, s
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, expression_pack_t{});
   }
-  static auto fields = o2::soa::createFieldsFromColumns(expression_pack_t{});
-  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
   auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
   {
     return {{std::move(C::Projector())...}};
   }
   (expression_pack_t{});
 
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), fields, name, projector);
+  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), name, projector);
 }
 
 template <typename... C>
@@ -933,10 +930,9 @@ auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::T
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, framework::pack<C...>{});
   }
-  static auto fields = o2::soa::createFieldsFromColumns(columns);
-  static auto new_schema = std::make_shared<arrow::Schema>(fields);
+  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(columns));
   std::array<expressions::Projector, sizeof...(C)> projectors{{std::move(C::Projector())...}};
-  return spawnerHelper(fullTable, new_schema, sizeof...(C), projectors.data(), fields, name, projector);
+  return spawnerHelper(fullTable, new_schema, sizeof...(C), projectors.data(), name, projector);
 }
 
 template <typename... T>
diff --git a/Framework/Core/src/TableBuilder.cxx b/Framework/Core/src/TableBuilder.cxx
index d9827559c2148..eb19f8d3fe642 100644
--- a/Framework/Core/src/TableBuilder.cxx
+++ b/Framework/Core/src/TableBuilder.cxx
@@ -85,11 +85,11 @@ void TableBuilder::setLabel(const char* label)
 }
 
 std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
-                                            expressions::Projector* projectors, std::vector<std::shared_ptr<arrow::Field>> const& fields, const char* name,
+                                            expressions::Projector* projectors, const char* name,
                                             std::shared_ptr<gandiva::Projector>& projector)
 {
   if (projector == nullptr) {
-    projector = framework::expressions::createProjectorHelper(nColumns, projectors, fullTable->schema(), fields);
+    projector = framework::expressions::createProjectorHelper(nColumns, projectors, fullTable->schema(), newSchema->fields());
   }
 
   arrow::TableBatchReader reader(*fullTable);

From 240812f69d5d2cb39cfc5b30ce9ef63a3254f394 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 12 May 2025 15:04:30 +0200
Subject: [PATCH 0340/1764] add TPC chi2 to trackstudy output

---
 .../study/include/GlobalTrackingStudy/TrackInfoExt.h           | 3 ++-
 Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx   | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
index 935e57873bbd9..26eeea858d14b 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
@@ -35,6 +35,7 @@ struct TrackInfoExt {
   float ttime = 0;
   float ttimeE = 0;
   float xmin = 0;
+  float chi2TPC = 0.f;
   float chi2ITSTPC = 0.f;
   float q2ptITS = 0.f;
   float q2ptTPC = 0.f;
@@ -56,7 +57,7 @@ struct TrackInfoExt {
   float getTPCInY0() const { return innerTPCPos0[1]; }
   float getTPCInZ0() const { return innerTPCPos0[2]; }
 
-  ClassDefNV(TrackInfoExt, 5);
+  ClassDefNV(TrackInfoExt, 6);
 };
 
 } // namespace dataformats
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index a74349bdeba15..a2bf6abd35fef 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -503,6 +503,7 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
               }
             }
             fillTPCClInfo(*tpcTr, trcExt, tsuse);
+            trcExt.chi2TPC = tpcTr->getChi2();
           }
           auto gidRefs = recoData.getSingleDetectorRefs(vid);
           if (gidRefs[GTrackID::ITS].isIndexSet()) {

From 751bb12f5b93dd6612ad15f470eec418db2800bb Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 13 May 2025 08:42:44 +0200
Subject: [PATCH 0341/1764] Move JSON parsing out of line (#14264)

---
 Framework/Core/CMakeLists.txt                 |   1 +
 .../include/Framework/VariantJSONHelpers.h    | 430 +---------------
 Framework/Core/src/VariantJSONHelpers.cxx     | 464 ++++++++++++++++++
 3 files changed, 468 insertions(+), 427 deletions(-)
 create mode 100644 Framework/Core/src/VariantJSONHelpers.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 2691d9d33a0c6..17320348d9272 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -140,6 +140,7 @@ o2_add_library(Framework
                        src/Task.cxx
                        src/Array2D.cxx
                        src/Variant.cxx
+                       src/VariantJSONHelpers.cxx
                        src/VariantPropertyTreeHelpers.cxx
                        src/WorkflowCustomizationHelpers.cxx
                        src/WorkflowHelpers.cxx
diff --git a/Framework/Core/include/Framework/VariantJSONHelpers.h b/Framework/Core/include/Framework/VariantJSONHelpers.h
index eab78d547ca13..811e6f13d4985 100644
--- a/Framework/Core/include/Framework/VariantJSONHelpers.h
+++ b/Framework/Core/include/Framework/VariantJSONHelpers.h
@@ -19,439 +19,15 @@
 #include <rapidjson/ostreamwrapper.h>
 #include <rapidjson/error/en.h>
 
-#include <stack>
-#include <iostream>
-#include <sstream>
+#include <iosfwd>
 
 namespace o2::framework
 {
-namespace
-{
-template <VariantType V>
-struct VariantReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, VariantReader<V>> {
-  using Ch = rapidjson::UTF8<>::Ch;
-  using SizeType = rapidjson::SizeType;
-
-  enum struct State {
-    IN_START,
-    IN_STOP,
-    IN_DATA,
-    IN_KEY,
-    IN_ARRAY,
-    IN_ROW,
-    IN_ERROR
-  };
-
-  VariantReader()
-    : states{},
-      rows{0},
-      cols{0}
-  {
-    debug << "Start" << std::endl;
-    states.push(State::IN_START);
-  }
-
-  bool Null()
-  {
-    debug << "Null value encountered" << std::endl;
-    return true;
-  }
-
-  bool Int(int i)
-  {
-    debug << "Int(" << i << ")" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      return false;
-    }
-    if constexpr (!std::is_same_v<int, variant_array_element_type_t<V>>) {
-      states.push(State::IN_ERROR);
-      return true;
-    } else {
-      if (states.top() == State::IN_ARRAY || states.top() == State::IN_ROW) {
-        debug << "added to array" << std::endl;
-        accumulatedData.push_back(i);
-        return true;
-      }
-    }
-    states.push(State::IN_ERROR);
-    return true;
-  }
-
-  bool Uint(unsigned i)
-  {
-    debug << "Uint -> Int" << std::endl;
-    return Int(static_cast<int>(i));
-  }
-
-  bool Int64(int64_t i)
-  {
-    debug << "Int64 -> Int" << std::endl;
-    return Int(static_cast<int>(i));
-  }
-
-  bool Uint64(uint64_t i)
-  {
-    debug << "Uint64 -> Int" << std::endl;
-    return Int(static_cast<int>(i));
-  }
-
-  bool Double(double d)
-  {
-    debug << "Double(" << d << ")" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      return false;
-    }
-    if constexpr (!(std::is_same_v<float, variant_array_element_type_t<V>> || std::is_same_v<double, variant_array_element_type_t<V>>)) {
-      states.push(State::IN_ERROR);
-      return true;
-    }
-    if (states.top() == State::IN_ARRAY || states.top() == State::IN_ROW) {
-      if constexpr (std::is_same_v<double, variant_array_element_type_t<V>>) {
-        debug << "added to array as double" << std::endl;
-        accumulatedData.push_back(d);
-        return true;
-      } else if constexpr (std::is_same_v<float, variant_array_element_type_t<V>>) {
-        debug << "added to array as float" << std::endl;
-        accumulatedData.push_back(static_cast<float>(d));
-        return true;
-      }
-    }
-    states.push(State::IN_ERROR);
-    return true;
-  }
-
-  bool Bool(bool b)
-  {
-    debug << "Bool(" << b << ")" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      return false;
-    }
-    if constexpr (!std::is_same_v<bool, variant_array_element_type_t<V>>) {
-      states.push(State::IN_ERROR);
-      return false;
-    } else {
-      if (states.top() == State::IN_ARRAY) {
-        debug << "added to array" << std::endl;
-        accumulatedData.push_back(b);
-        return true;
-      }
-      states.push(State::IN_ERROR);
-      return true;
-    }
-  }
-
-  bool String(const Ch* str, SizeType, bool)
-  {
-    debug << "String(" << str << ")" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      return false;
-    }
-    if constexpr (!(V == VariantType::ArrayString || isLabeledArray<V>())) {
-      states.push(State::IN_ERROR);
-      return true;
-    } else {
-      if (states.top() == State::IN_ARRAY || states.top() == State::IN_ROW) {
-        debug << "added to array" << std::endl;
-        if constexpr (isLabeledArray<V>()) {
-          if (currentKey == labels_rows_str) {
-            labels_rows.push_back(str);
-            return true;
-          }
-          if (currentKey == labels_cols_str) {
-            labels_cols.push_back(str);
-            return true;
-          }
-        }
-        if (currentKey == "values") {
-          if constexpr (std::is_same_v<std::string, variant_array_element_type_t<V>>) {
-            accumulatedData.push_back(str);
-          } else {
-            states.push(State::IN_ERROR);
-          }
-          return true;
-        }
-        return true;
-      }
-      states.push(State::IN_ERROR);
-      return true;
-    }
-  }
-
-  bool StartObject()
-  {
-    debug << "StartObject()" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      return false;
-    }
-    if (states.top() == State::IN_START) {
-      states.push(State::IN_DATA);
-      return true;
-    }
-    states.push(State::IN_ERROR);
-    return true;
-  }
-
-  bool Key(const Ch* str, SizeType, bool)
-  {
-    debug << "Key(" << str << ")" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      currentKey = str;
-      return false;
-    }
-    if (states.top() == State::IN_DATA) {
-      // no previous keys
-      states.push(State::IN_KEY);
-      currentKey = str;
-      return true;
-    }
-    if (states.top() == State::IN_KEY) {
-      currentKey = str;
-      if constexpr (!isLabeledArray<V>()) {
-        debug << "extra keys in a single-key variant" << std::endl;
-        states.push(State::IN_ERROR);
-        return true;
-      }
-      return true;
-    }
-    currentKey = str;
-    states.push(State::IN_ERROR);
-    return true;
-  }
-
-  bool EndObject(SizeType)
-  {
-    debug << "EndObject()" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      return false;
-    }
-    if (states.top() == State::IN_KEY) {
-      if constexpr (isArray<V>()) {
-        debug << "creating 1d-array variant" << std::endl;
-        result = Variant(accumulatedData);
-      } else if constexpr (isArray2D<V>()) {
-        debug << "creating 2d-array variant" << std::endl;
-        assert(accumulatedData.size() == rows * cols);
-        result = Variant(Array2D{accumulatedData, rows, cols});
-      } else if constexpr (isLabeledArray<V>()) {
-        debug << "creating labeled array variant" << std::endl;
-        assert(accumulatedData.size() == rows * cols);
-        if (labels_rows.empty() == false) {
-          assert(labels_rows.size() == rows);
-        }
-        if (labels_cols.empty() == false) {
-          assert(labels_cols.size() == cols);
-        }
-        result = Variant(LabeledArray{Array2D{accumulatedData, rows, cols}, labels_rows, labels_cols});
-      }
-      states.push(State::IN_STOP);
-      return true;
-    }
-    states.push(State::IN_ERROR);
-    return true;
-  }
-
-  bool StartArray()
-  {
-    debug << "StartArray()" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      return false;
-    }
-    if (states.top() == State::IN_KEY) {
-      states.push(State::IN_ARRAY);
-      return true;
-    } else if (states.top() == State::IN_ARRAY) {
-      if constexpr (isArray2D<V>() || isLabeledArray<V>()) {
-        states.push(State::IN_ROW);
-        return true;
-      }
-    }
-    states.push(State::IN_ERROR);
-    return true;
-  }
-
-  bool EndArray(SizeType elementCount)
-  {
-    debug << "EndArray()" << std::endl;
-    if (states.top() == State::IN_ERROR) {
-      debug << "In ERROR state" << std::endl;
-      return false;
-    }
-    if (states.top() == State::IN_ARRAY) {
-      // finish up array
-      states.pop();
-      if constexpr (isArray2D<V>() || isLabeledArray<V>()) {
-        rows = elementCount;
-      }
-      return true;
-    } else if (states.top() == State::IN_ROW) {
-      // finish up row
-      states.pop();
-      if constexpr (isArray2D<V>() || isLabeledArray<V>()) {
-        cols = elementCount;
-      }
-      return true;
-    }
-    states.push(State::IN_ERROR);
-    return true;
-  }
-
-  std::stack<State> states;
-  std::ostringstream debug;
-
-  uint32_t rows;
-  uint32_t cols;
-  std::string currentKey;
-  std::vector<variant_array_element_type_t<V>> accumulatedData;
-  std::vector<std::string> labels_rows;
-  std::vector<std::string> labels_cols;
-  Variant result;
-};
-
-template <VariantType V>
-void writeVariant(std::ostream& o, Variant const& v)
-{
-  if constexpr (isArray<V>() || isArray2D<V>() || isLabeledArray<V>()) {
-    using type = variant_array_element_type_t<V>;
-    rapidjson::OStreamWrapper osw(o);
-    rapidjson::Writer<rapidjson::OStreamWrapper> w(osw);
-
-    auto writeArray = [&](auto* values, size_t size) {
-      using T = std::remove_pointer_t<decltype(values)>;
-      w.StartArray();
-      for (auto i = 0u; i < size; ++i) {
-        if constexpr (std::is_same_v<int, T>) {
-          w.Int(values[i]);
-        } else if constexpr (std::is_same_v<float, T> || std::is_same_v<double, T>) {
-          w.Double(values[i]);
-        } else if constexpr (std::is_same_v<bool, T>) {
-          w.Bool(values[i]);
-        } else if constexpr (std::is_same_v<std::string, T>) {
-          w.String(values[i].c_str());
-        }
-      }
-      w.EndArray();
-    };
-
-    auto writeVector = [&](auto&& vector) {
-      return writeArray(vector.data(), vector.size());
-    };
-
-    auto writeArray2D = [&](auto&& array2d) {
-      using T = typename std::decay_t<decltype(array2d)>::element_t;
-      w.StartArray();
-      for (auto i = 0u; i < array2d.rows; ++i) {
-        w.StartArray();
-        for (auto j = 0u; j < array2d.cols; ++j) {
-          if constexpr (std::is_same_v<int, T>) {
-            w.Int(array2d(i, j));
-          } else if constexpr (std::is_same_v<float, T> || std::is_same_v<double, T>) {
-            w.Double(array2d(i, j));
-          } else if constexpr (std::is_same_v<std::string, T>) {
-            w.String(array2d(i, j).c_str());
-          }
-        }
-        w.EndArray();
-      }
-      w.EndArray();
-    };
-
-    auto writeLabeledArray = [&](auto&& array) {
-      w.Key(labels_rows_str);
-      writeVector(array.getLabelsRows());
-      w.Key(labels_cols_str);
-      writeVector(array.getLabelsCols());
-      w.Key("values");
-      writeArray2D(array.getData());
-    };
-
-    w.StartObject();
-    if constexpr (isArray<V>()) {
-      w.Key("values");
-      writeArray(v.get<type*>(), v.size());
-    } else if constexpr (isArray2D<V>()) {
-      w.Key("values");
-      writeArray2D(v.get<Array2D<type>>());
-    } else if constexpr (isLabeledArray<V>()) {
-      writeLabeledArray(v.get<LabeledArray<type>>());
-    } else if constexpr (V == VariantType::Dict) {
-      // nothing to do for dicts
-    }
-    w.EndObject();
-  }
-}
-} // namespace
-
 struct VariantJSONHelpers {
   template <VariantType V>
-  static Variant read(std::istream& s)
-  {
-    rapidjson::Reader reader;
-    rapidjson::IStreamWrapper isw(s);
-    VariantReader<V> vreader;
-    bool ok = reader.Parse(isw, vreader);
-
-    if (ok == false) {
-      std::stringstream error;
-      error << "Cannot parse serialized Variant, error: " << rapidjson::GetParseError_En(reader.GetParseErrorCode()) << " at offset: " << reader.GetErrorOffset();
-      throw std::runtime_error(error.str());
-    }
-    return vreader.result;
-  }
+  static Variant read(std::istream& s);
 
-  static void write(std::ostream& o, Variant const& v)
-  {
-    switch (v.type()) {
-      case VariantType::ArrayInt:
-        writeVariant<VariantType::ArrayInt>(o, v);
-        break;
-      case VariantType::ArrayFloat:
-        writeVariant<VariantType::ArrayFloat>(o, v);
-        break;
-      case VariantType::ArrayDouble:
-        writeVariant<VariantType::ArrayDouble>(o, v);
-        break;
-      case VariantType::ArrayBool:
-        throw std::runtime_error("Bool vectors not implemented yet");
-        //        writeVariant<VariantType::ArrayBool>(o, v);
-        break;
-      case VariantType::ArrayString:
-        writeVariant<VariantType::ArrayString>(o, v);
-        break;
-      case VariantType::Array2DInt:
-        writeVariant<VariantType::Array2DInt>(o, v);
-        break;
-      case VariantType::Array2DFloat:
-        writeVariant<VariantType::Array2DFloat>(o, v);
-        break;
-      case VariantType::Array2DDouble:
-        writeVariant<VariantType::Array2DDouble>(o, v);
-        break;
-      case VariantType::LabeledArrayInt:
-        writeVariant<VariantType::LabeledArrayInt>(o, v);
-        break;
-      case VariantType::LabeledArrayFloat:
-        writeVariant<VariantType::LabeledArrayFloat>(o, v);
-        break;
-      case VariantType::LabeledArrayDouble:
-        writeVariant<VariantType::LabeledArrayDouble>(o, v);
-        break;
-      case VariantType::LabeledArrayString:
-        writeVariant<VariantType::LabeledArrayString>(o, v);
-        break;
-      case VariantType::Dict:
-        writeVariant<VariantType::Dict>(o, v);
-      default:
-        break;
-    }
-  }
+  static void write(std::ostream& o, Variant const& v);
 };
 } // namespace o2::framework
 
diff --git a/Framework/Core/src/VariantJSONHelpers.cxx b/Framework/Core/src/VariantJSONHelpers.cxx
new file mode 100644
index 0000000000000..fbb5abb331867
--- /dev/null
+++ b/Framework/Core/src/VariantJSONHelpers.cxx
@@ -0,0 +1,464 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#include "Framework/VariantJSONHelpers.h"
+#include "Framework/Variant.h"
+
+#include <rapidjson/reader.h>
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/istreamwrapper.h>
+#include <rapidjson/ostreamwrapper.h>
+#include <rapidjson/error/en.h>
+
+#include <stack>
+#include <sstream>
+#include <istream>
+
+namespace o2::framework
+{
+namespace
+{
+template <VariantType V>
+struct VariantReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, VariantReader<V>> {
+  using Ch = rapidjson::UTF8<>::Ch;
+  using SizeType = rapidjson::SizeType;
+
+  enum struct State {
+    IN_START,
+    IN_STOP,
+    IN_DATA,
+    IN_KEY,
+    IN_ARRAY,
+    IN_ROW,
+    IN_ERROR
+  };
+
+  VariantReader()
+    : states{},
+      rows{0},
+      cols{0}
+  {
+    debug << "Start" << std::endl;
+    states.push(State::IN_START);
+  }
+
+  bool Null()
+  {
+    debug << "Null value encountered" << std::endl;
+    return true;
+  }
+
+  bool Int(int i)
+  {
+    debug << "Int(" << i << ")" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      return false;
+    }
+    if constexpr (!std::is_same_v<int, variant_array_element_type_t<V>>) {
+      states.push(State::IN_ERROR);
+      return true;
+    } else {
+      if (states.top() == State::IN_ARRAY || states.top() == State::IN_ROW) {
+        debug << "added to array" << std::endl;
+        accumulatedData.push_back(i);
+        return true;
+      }
+    }
+    states.push(State::IN_ERROR);
+    return true;
+  }
+
+  bool Uint(unsigned i)
+  {
+    debug << "Uint -> Int" << std::endl;
+    return Int(static_cast<int>(i));
+  }
+
+  bool Int64(int64_t i)
+  {
+    debug << "Int64 -> Int" << std::endl;
+    return Int(static_cast<int>(i));
+  }
+
+  bool Uint64(uint64_t i)
+  {
+    debug << "Uint64 -> Int" << std::endl;
+    return Int(static_cast<int>(i));
+  }
+
+  bool Double(double d)
+  {
+    debug << "Double(" << d << ")" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      return false;
+    }
+    if constexpr (!(std::is_same_v<float, variant_array_element_type_t<V>> || std::is_same_v<double, variant_array_element_type_t<V>>)) {
+      states.push(State::IN_ERROR);
+      return true;
+    }
+    if (states.top() == State::IN_ARRAY || states.top() == State::IN_ROW) {
+      if constexpr (std::is_same_v<double, variant_array_element_type_t<V>>) {
+        debug << "added to array as double" << std::endl;
+        accumulatedData.push_back(d);
+        return true;
+      } else if constexpr (std::is_same_v<float, variant_array_element_type_t<V>>) {
+        debug << "added to array as float" << std::endl;
+        accumulatedData.push_back(static_cast<float>(d));
+        return true;
+      }
+    }
+    states.push(State::IN_ERROR);
+    return true;
+  }
+
+  bool Bool(bool b)
+  {
+    debug << "Bool(" << b << ")" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      return false;
+    }
+    if constexpr (!std::is_same_v<bool, variant_array_element_type_t<V>>) {
+      states.push(State::IN_ERROR);
+      return false;
+    } else {
+      if (states.top() == State::IN_ARRAY) {
+        debug << "added to array" << std::endl;
+        accumulatedData.push_back(b);
+        return true;
+      }
+      states.push(State::IN_ERROR);
+      return true;
+    }
+  }
+
+  bool String(const Ch* str, SizeType, bool)
+  {
+    debug << "String(" << str << ")" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      return false;
+    }
+    if constexpr (!(V == VariantType::ArrayString || isLabeledArray<V>())) {
+      states.push(State::IN_ERROR);
+      return true;
+    } else {
+      if (states.top() == State::IN_ARRAY || states.top() == State::IN_ROW) {
+        debug << "added to array" << std::endl;
+        if constexpr (isLabeledArray<V>()) {
+          if (currentKey == labels_rows_str) {
+            labels_rows.push_back(str);
+            return true;
+          }
+          if (currentKey == labels_cols_str) {
+            labels_cols.push_back(str);
+            return true;
+          }
+        }
+        if (currentKey == "values") {
+          if constexpr (std::is_same_v<std::string, variant_array_element_type_t<V>>) {
+            accumulatedData.push_back(str);
+          } else {
+            states.push(State::IN_ERROR);
+          }
+          return true;
+        }
+        return true;
+      }
+      states.push(State::IN_ERROR);
+      return true;
+    }
+  }
+
+  bool StartObject()
+  {
+    debug << "StartObject()" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      return false;
+    }
+    if (states.top() == State::IN_START) {
+      states.push(State::IN_DATA);
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return true;
+  }
+
+  bool Key(const Ch* str, SizeType, bool)
+  {
+    debug << "Key(" << str << ")" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      currentKey = str;
+      return false;
+    }
+    if (states.top() == State::IN_DATA) {
+      // no previous keys
+      states.push(State::IN_KEY);
+      currentKey = str;
+      return true;
+    }
+    if (states.top() == State::IN_KEY) {
+      currentKey = str;
+      if constexpr (!isLabeledArray<V>()) {
+        debug << "extra keys in a single-key variant" << std::endl;
+        states.push(State::IN_ERROR);
+        return true;
+      }
+      return true;
+    }
+    currentKey = str;
+    states.push(State::IN_ERROR);
+    return true;
+  }
+
+  bool EndObject(SizeType)
+  {
+    debug << "EndObject()" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      return false;
+    }
+    if (states.top() == State::IN_KEY) {
+      if constexpr (isArray<V>()) {
+        debug << "creating 1d-array variant" << std::endl;
+        result = Variant(accumulatedData);
+      } else if constexpr (isArray2D<V>()) {
+        debug << "creating 2d-array variant" << std::endl;
+        assert(accumulatedData.size() == rows * cols);
+        result = Variant(Array2D{accumulatedData, rows, cols});
+      } else if constexpr (isLabeledArray<V>()) {
+        debug << "creating labeled array variant" << std::endl;
+        assert(accumulatedData.size() == rows * cols);
+        if (labels_rows.empty() == false) {
+          assert(labels_rows.size() == rows);
+        }
+        if (labels_cols.empty() == false) {
+          assert(labels_cols.size() == cols);
+        }
+        result = Variant(LabeledArray{Array2D{accumulatedData, rows, cols}, labels_rows, labels_cols});
+      }
+      states.push(State::IN_STOP);
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return true;
+  }
+
+  bool StartArray()
+  {
+    debug << "StartArray()" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      return false;
+    }
+    if (states.top() == State::IN_KEY) {
+      states.push(State::IN_ARRAY);
+      return true;
+    } else if (states.top() == State::IN_ARRAY) {
+      if constexpr (isArray2D<V>() || isLabeledArray<V>()) {
+        states.push(State::IN_ROW);
+        return true;
+      }
+    }
+    states.push(State::IN_ERROR);
+    return true;
+  }
+
+  bool EndArray(SizeType elementCount)
+  {
+    debug << "EndArray()" << std::endl;
+    if (states.top() == State::IN_ERROR) {
+      debug << "In ERROR state" << std::endl;
+      return false;
+    }
+    if (states.top() == State::IN_ARRAY) {
+      // finish up array
+      states.pop();
+      if constexpr (isArray2D<V>() || isLabeledArray<V>()) {
+        rows = elementCount;
+      }
+      return true;
+    } else if (states.top() == State::IN_ROW) {
+      // finish up row
+      states.pop();
+      if constexpr (isArray2D<V>() || isLabeledArray<V>()) {
+        cols = elementCount;
+      }
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return true;
+  }
+
+  std::stack<State> states;
+  std::ostringstream debug;
+
+  uint32_t rows;
+  uint32_t cols;
+  std::string currentKey;
+  std::vector<variant_array_element_type_t<V>> accumulatedData;
+  std::vector<std::string> labels_rows;
+  std::vector<std::string> labels_cols;
+  Variant result;
+};
+} // namespace
+
+template <VariantType V>
+Variant VariantJSONHelpers::read(std::istream& s)
+{
+  rapidjson::Reader reader;
+  rapidjson::IStreamWrapper isw(s);
+  VariantReader<V> vreader;
+  bool ok = reader.Parse(isw, vreader);
+
+  if (ok == false) {
+    std::stringstream error;
+    error << "Cannot parse serialized Variant, error: " << rapidjson::GetParseError_En(reader.GetParseErrorCode()) << " at offset: " << reader.GetErrorOffset();
+    throw std::runtime_error(error.str());
+  }
+  return vreader.result;
+}
+
+template <VariantType V>
+void writeVariant(std::ostream& o, Variant const& v)
+{
+  if constexpr (isArray<V>() || isArray2D<V>() || isLabeledArray<V>()) {
+    using type = variant_array_element_type_t<V>;
+    rapidjson::OStreamWrapper osw(o);
+    rapidjson::Writer<rapidjson::OStreamWrapper> w(osw);
+
+    auto writeArray = [&](auto* values, size_t size) {
+      using T = std::remove_pointer_t<decltype(values)>;
+      w.StartArray();
+      for (auto i = 0u; i < size; ++i) {
+        if constexpr (std::is_same_v<int, T>) {
+          w.Int(values[i]);
+        } else if constexpr (std::is_same_v<float, T> || std::is_same_v<double, T>) {
+          w.Double(values[i]);
+        } else if constexpr (std::is_same_v<bool, T>) {
+          w.Bool(values[i]);
+        } else if constexpr (std::is_same_v<std::string, T>) {
+          w.String(values[i].c_str());
+        }
+      }
+      w.EndArray();
+    };
+
+    auto writeVector = [&](auto&& vector) {
+      return writeArray(vector.data(), vector.size());
+    };
+
+    auto writeArray2D = [&](auto&& array2d) {
+      using T = typename std::decay_t<decltype(array2d)>::element_t;
+      w.StartArray();
+      for (auto i = 0u; i < array2d.rows; ++i) {
+        w.StartArray();
+        for (auto j = 0u; j < array2d.cols; ++j) {
+          if constexpr (std::is_same_v<int, T>) {
+            w.Int(array2d(i, j));
+          } else if constexpr (std::is_same_v<float, T> || std::is_same_v<double, T>) {
+            w.Double(array2d(i, j));
+          } else if constexpr (std::is_same_v<std::string, T>) {
+            w.String(array2d(i, j).c_str());
+          }
+        }
+        w.EndArray();
+      }
+      w.EndArray();
+    };
+
+    auto writeLabeledArray = [&](auto&& array) {
+      w.Key(labels_rows_str);
+      writeVector(array.getLabelsRows());
+      w.Key(labels_cols_str);
+      writeVector(array.getLabelsCols());
+      w.Key("values");
+      writeArray2D(array.getData());
+    };
+
+    w.StartObject();
+    if constexpr (isArray<V>()) {
+      w.Key("values");
+      writeArray(v.get<type*>(), v.size());
+    } else if constexpr (isArray2D<V>()) {
+      w.Key("values");
+      writeArray2D(v.get<Array2D<type>>());
+    } else if constexpr (isLabeledArray<V>()) {
+      writeLabeledArray(v.get<LabeledArray<type>>());
+    } else if constexpr (V == VariantType::Dict) {
+      // nothing to do for dicts
+    }
+    w.EndObject();
+  }
+}
+
+template Variant VariantJSONHelpers::read<VariantType::ArrayInt>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::ArrayFloat>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::ArrayDouble>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::ArrayString>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::Array2DInt>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::Array2DFloat>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::Array2DDouble>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::LabeledArrayInt>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::LabeledArrayFloat>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::LabeledArrayDouble>(std::istream& s);
+template Variant VariantJSONHelpers::read<VariantType::LabeledArrayString>(std::istream& s);
+
+void VariantJSONHelpers::write(std::ostream& o, Variant const& v)
+{
+  switch (v.type()) {
+    case VariantType::ArrayInt:
+      writeVariant<VariantType::ArrayInt>(o, v);
+      break;
+    case VariantType::ArrayFloat:
+      writeVariant<VariantType::ArrayFloat>(o, v);
+      break;
+    case VariantType::ArrayDouble:
+      writeVariant<VariantType::ArrayDouble>(o, v);
+      break;
+    case VariantType::ArrayBool:
+      throw std::runtime_error("Bool vectors not implemented yet");
+      //        writeVariant<VariantType::ArrayBool>(o, v);
+      break;
+    case VariantType::ArrayString:
+      writeVariant<VariantType::ArrayString>(o, v);
+      break;
+    case VariantType::Array2DInt:
+      writeVariant<VariantType::Array2DInt>(o, v);
+      break;
+    case VariantType::Array2DFloat:
+      writeVariant<VariantType::Array2DFloat>(o, v);
+      break;
+    case VariantType::Array2DDouble:
+      writeVariant<VariantType::Array2DDouble>(o, v);
+      break;
+    case VariantType::LabeledArrayInt:
+      writeVariant<VariantType::LabeledArrayInt>(o, v);
+      break;
+    case VariantType::LabeledArrayFloat:
+      writeVariant<VariantType::LabeledArrayFloat>(o, v);
+      break;
+    case VariantType::LabeledArrayDouble:
+      writeVariant<VariantType::LabeledArrayDouble>(o, v);
+      break;
+    case VariantType::LabeledArrayString:
+      writeVariant<VariantType::LabeledArrayString>(o, v);
+      break;
+    case VariantType::Dict:
+      writeVariant<VariantType::Dict>(o, v);
+    default:
+      break;
+  }
+}
+} // namespace o2::framework

From 8de719349f3dc57e670b7ebf6b8206dee1e426b7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 12 May 2025 11:43:12 +0200
Subject: [PATCH 0342/1764] GPU: Add GPUCA_RTC_CONSTEXPR macro for constexpr
 only in RTC

---
 GPU/Common/GPUCommonDef.h                                 | 4 ++++
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx | 1 +
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu     | 1 +
 3 files changed, 6 insertions(+)

diff --git a/GPU/Common/GPUCommonDef.h b/GPU/Common/GPUCommonDef.h
index d7e99f53d4ce8..d9a5bdf92b6ac 100644
--- a/GPU/Common/GPUCommonDef.h
+++ b/GPU/Common/GPUCommonDef.h
@@ -72,6 +72,10 @@
   #define GPUCA_RTC_SPECIAL_CODE(...)
 #endif
 
+#ifndef GPUCA_RTC_CONSTEXPR
+  #define GPUCA_RTC_CONSTEXPR
+#endif
+
 #ifndef GPUCA_DETERMINISTIC_CODE
   #ifdef GPUCA_DETERMINISTIC_MODE
     #define GPUCA_DETERMINISTIC_CODE(det, indet) det // In deterministic mode, take deterministic code path
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index 5706f32e73e96..acc77648d954b 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -38,6 +38,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
 {
   std::string rtcparam = std::string("#define GPUCA_RTC_CODE\n") +
                          std::string(GetProcessingSettings().rtc.optSpecialCode ? "#define GPUCA_RTC_SPECIAL_CODE(...) __VA_ARGS__\n" : "#define GPUCA_RTC_SPECIAL_CODE(...)\n") +
+                         std::string(GetProcessingSettings().rtc.optConstexpr ? "#define GPUCA_RTC_CONSTEXPR constexpr\n" : "#define GPUCA_RTC_CONSTEXPR\n") +
                          GPUParamRTC::generateRTCCode(param(), GetProcessingSettings().rtc.optConstexpr);
   if (filename == "") {
     filename = "/tmp/o2cagpu_rtc_";
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
index 805397c9b430e..66c02d6ed251c 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
@@ -18,6 +18,7 @@
 // Keep some preprocessor calls unprocessed
 #define GPUCA_RTC_SPECIAL_CODE(...) GPUCA_RTC_SPECIAL_CODE(__VA_ARGS__)
 #define GPUCA_DETERMINISTIC_CODE(...) GPUCA_DETERMINISTIC_CODE(__VA_ARGS__)
+#define GPUCA_RTC_CONSTEXPR GPUCA_RTC_CONSTEXPR
 
 // GPUReconstructionCUDAIncludesSystem.h prependended by CMakewithout preprocessor running
 #include "GPUReconstructionCUDADef.h"

From 1dc506884cf82e11378a33ad1621319e11a17402 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 12 May 2025 11:43:40 +0200
Subject: [PATCH 0343/1764] GPU TPC: Compute alternative dEdx only if it has
 different settings than normal dEdx

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  4 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   | 17 +++--
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 70 +++++++++++--------
 3 files changed, 55 insertions(+), 36 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 6e7de7ee48ca6..d2aba503be6a6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -301,7 +301,9 @@ void* GPUTPCGMMerger::SetPointersOutput(void* mem)
   computePointerWithAlignment(mem, mOutputTracks, mNMaxTracks);
   if (mRec->GetParam().dodEdxEnabled) {
     computePointerWithAlignment(mem, mOutputTracksdEdx, mNMaxTracks);
-    computePointerWithAlignment(mem, mOutputTracksdEdxAlt, mNMaxTracks);
+    if (mRec->GetParam().rec.tpc.dEdxClusterRejectionFlagMask != mRec->GetParam().rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+      computePointerWithAlignment(mem, mOutputTracksdEdxAlt, mNMaxTracks);
+    }
   }
   computePointerWithAlignment(mem, mClusters, mNMaxOutputTrackClusters);
   if (mRec->GetParam().par.earlyTpcTransform) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 9dc6ddc59c2b4..9ead17ea5c7c0 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -106,6 +106,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
   const uint32_t flagsRequired = getFlagsRequired(merger.Param().rec);
   TrackTPC* outputTracks = merger.OutputTracksTPCO2();
   uint32_t* clusRefs = merger.OutputClusRefsTPCO2();
+  const auto& param = merger.Param();
 
   GPUTPCGMMerger::tmpSort* GPUrestrict() trackSort = merger.TrackSortO2();
   uint2* GPUrestrict() tmpData = merger.ClusRefTmp();
@@ -130,9 +131,15 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
 
     oTrack.setChi2(tracks[i].GetParam().GetChi2());
     auto& outerPar = tracks[i].OuterParam();
-    if (merger.Param().par.dodEdx && merger.Param().dodEdxEnabled) {
-      oTrack.setdEdx(tracksdEdx[i]);
-      oTrack.setdEdxAlt(tracksdEdxAlt[i]);
+    if GPUCA_RTC_CONSTEXPR (param.par.dodEdx) {
+      if (param.dodEdxEnabled) {
+        oTrack.setdEdx(tracksdEdx[i]);
+        if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+          oTrack.setdEdxAlt(tracksdEdxAlt[i]);
+        } else {
+          oTrack.setdEdxAlt(tracksdEdx[i]);
+        }
+      }
     }
 
     auto snpOut = outerPar.P[2];
@@ -148,9 +155,9 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
        outerPar.C[6], outerPar.C[7], outerPar.C[8], outerPar.C[9], outerPar.C[10], outerPar.C[11],
        outerPar.C[12], outerPar.C[13], outerPar.C[14]}));
 
-    if (merger.Param().par.dodEdx && merger.Param().dodEdxEnabled && merger.Param().rec.tpc.enablePID) {
+    if (param.par.dodEdx && param.dodEdxEnabled && param.rec.tpc.enablePID) {
       PIDResponse pidResponse{};
-      auto pid = pidResponse.getMostProbablePID(oTrack, merger.Param().rec.tpc.PID_EKrangeMin, merger.Param().rec.tpc.PID_EKrangeMax, merger.Param().rec.tpc.PID_EPrangeMin, merger.Param().rec.tpc.PID_EPrangeMax, merger.Param().rec.tpc.PID_EDrangeMin, merger.Param().rec.tpc.PID_EDrangeMax, merger.Param().rec.tpc.PID_ETrangeMin, merger.Param().rec.tpc.PID_ETrangeMax, merger.Param().rec.tpc.PID_useNsigma, merger.Param().rec.tpc.PID_sigma);
+      auto pid = pidResponse.getMostProbablePID(oTrack, param.rec.tpc.PID_EKrangeMin, param.rec.tpc.PID_EKrangeMax, param.rec.tpc.PID_EPrangeMin, param.rec.tpc.PID_EPrangeMax, param.rec.tpc.PID_EDrangeMin, param.rec.tpc.PID_EDrangeMax, param.rec.tpc.PID_ETrangeMin, merger.Param().rec.tpc.PID_ETrangeMax, merger.Param().rec.tpc.PID_useNsigma, merger.Param().rec.tpc.PID_sigma);
       auto pidRemap = merger.Param().rec.tpc.PID_remap[pid];
       if (pidRemap >= 0) {
         pid = pidRemap;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index f5bfbe985fb8c..0d8547263207b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -216,11 +216,15 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           continue;
         }
       } else if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
-        bool dodEdx = param.par.dodEdx && param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2 && cluster.leg == clusters[maxN - 1].leg;
-        dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, cluster.leg == clusters[maxN - 1].leg, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
-        if (dodEdx) {
-          dEdx.fillSubThreshold(lastRow - wayDirection);
-          dEdxAlt.fillSubThreshold(lastRow - wayDirection);
+        if GPUCA_RTC_CONSTEXPR (param.par.dodEdx) {
+          bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2 && cluster.leg == clusters[maxN - 1].leg;
+          dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, cluster.leg == clusters[maxN - 1].leg, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
+          if (dodEdx) {
+            dEdx.fillSubThreshold(lastRow - wayDirection);
+            if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+              dEdxAlt.fillSubThreshold(lastRow - wayDirection);
+            }
+          }
         }
       }
 
@@ -367,31 +371,35 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           CADEBUG(printf("Reinit linearization\n"));
           prop.SetTrack(this, prop.GetAlpha());
         }
-        if (param.par.dodEdx && param.dodEdxEnabled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg) { // TODO: Costimize flag to remove, and option to remove double-clusters
-          bool acc = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMask) == 0, accAlt = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) == 0;
-          if (acc || accAlt) {
-            float qtot = 0, qmax = 0, pad = 0, relTime = 0;
-            const int32_t clusterCount = (ihit - ihitMergeFirst) * wayDirection + 1;
-            for (int32_t iTmp = ihitMergeFirst; iTmp != ihit + wayDirection; iTmp += wayDirection) {
-              if (merger->GetConstantMem()->ioPtrs.clustersNative == nullptr) {
-                qtot += clustersXYZ[ihit].amp;
-              } else {
-                const ClusterNative& cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num];
-                qtot += cl.qTot;
-                qmax = CAMath::Max<float>(qmax, cl.qMax);
-                pad += cl.getPad();
-                relTime += cl.getTime();
+        if GPUCA_RTC_CONSTEXPR (param.par.dodEdx) {
+          if (param.dodEdxEnabled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg) { // TODO: Costimize flag to remove, and option to remove double-clusters
+            bool acc = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMask) == 0, accAlt = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) == 0;
+            if (acc || accAlt) {
+              float qtot = 0, qmax = 0, pad = 0, relTime = 0;
+              const int32_t clusterCount = (ihit - ihitMergeFirst) * wayDirection + 1;
+              for (int32_t iTmp = ihitMergeFirst; iTmp != ihit + wayDirection; iTmp += wayDirection) {
+                if (merger->GetConstantMem()->ioPtrs.clustersNative == nullptr) {
+                  qtot += clustersXYZ[ihit].amp;
+                } else {
+                  const ClusterNative& cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num];
+                  qtot += cl.qTot;
+                  qmax = CAMath::Max<float>(qmax, cl.qMax);
+                  pad += cl.getPad();
+                  relTime += cl.getTime();
+                }
+              }
+              qtot /= clusterCount; // TODO: Weighted Average
+              pad /= clusterCount;
+              relTime /= clusterCount;
+              relTime = relTime - CAMath::Round(relTime);
+              if (acc) {
+                dEdx.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
+              }
+              if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+                if (accAlt) {
+                  dEdxAlt.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
+                }
               }
-            }
-            qtot /= clusterCount; // TODO: Weighted Average
-            pad /= clusterCount;
-            relTime /= clusterCount;
-            relTime = relTime - CAMath::Round(relTime);
-            if (acc) {
-              dEdx.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
-            }
-            if (accAlt) {
-              dEdxAlt.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
             }
           }
         }
@@ -428,7 +436,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
   if (param.par.dodEdx && param.dodEdxEnabled) {
     dEdx.computedEdx(merger->OutputTracksdEdx()[iTrk], param);
-    dEdxAlt.computedEdx(merger->OutputTracksdEdxAlt()[iTrk], param);
+    if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+      dEdxAlt.computedEdx(merger->OutputTracksdEdxAlt()[iTrk], param);
+    }
   }
   Alpha = prop.GetAlpha();
   MoveToReference(prop, param, Alpha);

From 760f73e62a3a7898c81eee53e1d67012c58c39be Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 12 May 2025 21:19:41 +0200
Subject: [PATCH 0344/1764] GPU CMake: If deterministic mode is set to
 MaxOptO2, do not impose -O2 when BUILD_TYPE is DEBUG

---
 GPU/GPUTracking/CMakeLists.txt | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 2e26622d05291..52848692e7516 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -16,11 +16,12 @@ set(MODULE GPUTracking)
 
 if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
   set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
+elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
   if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_OPTO2})
     set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O2")
+  else()
+    set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O3 -ffast-math")
   endif()
-elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
-  set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} -O3 -ffast-math")
 endif()
 set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${GPUCA_CXX_DENORMALS_FLAGS}")
 

From 89b35ba2d75113e60b2045ed01e169b28d860a07 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 12 May 2025 21:22:52 +0200
Subject: [PATCH 0345/1764] GPU: Workaround for Clang Frontend issue

This is fixed with Clang >= 20 and C++23 (P2280R4)
---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx | 4 ++++
 GPU/GPUTracking/Base/hip/CMakeLists.txt                   | 5 +++++
 2 files changed, 9 insertions(+)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index acc77648d954b..67ad608c13417 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -38,7 +38,11 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
 {
   std::string rtcparam = std::string("#define GPUCA_RTC_CODE\n") +
                          std::string(GetProcessingSettings().rtc.optSpecialCode ? "#define GPUCA_RTC_SPECIAL_CODE(...) __VA_ARGS__\n" : "#define GPUCA_RTC_SPECIAL_CODE(...)\n") +
+#ifndef GPUCA_HIP_WORKAROUND_CONSTEXPR // TODO: Fixme, once we have C++ P2280R4 in Clang
                          std::string(GetProcessingSettings().rtc.optConstexpr ? "#define GPUCA_RTC_CONSTEXPR constexpr\n" : "#define GPUCA_RTC_CONSTEXPR\n") +
+#else
+                         std::string("#define GPUCA_RTC_CONSTEXPR\n") +
+#endif
                          GPUParamRTC::generateRTCCode(param(), GetProcessingSettings().rtc.optConstexpr);
   if (filename == "") {
     filename = "/tmp/o2cagpu_rtc_";
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 6eded3499e46e..c89ef1769ad81 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -270,3 +270,8 @@ add_dependencies(GPUTrackingHIPExternalProvider O2::GPUTracking) # must not depe
 if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   add_dependencies(GPUTrackingHIPExternalProvider ${MODULE}_HIPIFIED)
 endif()
+
+set_source_files_properties("${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPGenRTC.cxx"
+TARGET_DIRECTORY O2::GPUTrackingHIP
+PROPERTIES
+COMPILE_DEFINITIONS "GPUCA_HIP_WORKAROUND_CONSTEXPR")

From 4b72f186ec6e2981cae50338b97855efde70dc8a Mon Sep 17 00:00:00 2001
From: tubagundem <tuba.gundem@cern.ch>
Date: Tue, 13 May 2025 11:20:40 +0200
Subject: [PATCH 0346/1764] TPC: Fix digitizer workflow to load GEM params from
 CCDB before creating Polya file

---
 .../DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx  | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
index 75141425f7c49..a04f73a62fbf8 100644
--- a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
+++ b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
@@ -286,7 +286,7 @@ int getNumTPCLanes(std::vector<int> const& sectors, ConfigContext const& configc
 
 // ------------------------------------------------------------------
 
-void initTPC()
+void initTPC(long timestamp)
 {
   // We only want to do this for the DPL master
   // I am not aware of an easy way to query if "I am DPL master" so
@@ -308,6 +308,12 @@ void initTPC()
 
   auto& cdb = o2::tpc::CDBInterface::instance();
   cdb.setUseDefaults();
+
+  // IMPORTANT: load ParameterGEM from CCDB
+  auto& ccdbManager = o2::ccdb::BasicCCDBManager::instance();
+  ccdbManager.getSpecific<o2::tpc::ParameterGEM>(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::ParGEM), timestamp);
+  LOGP(info, "initTPC: TPC GEM param updated for time {}", timestamp);
+  o2::tpc::ParameterGEM::Instance().printKeyValues(true, true);
   // by invoking this constructor we make sure that a common file will be created
   // in future we should take this from OCDB and just forward per message
   const static auto& ampl = o2::tpc::GEMAmplification::instance();
@@ -592,7 +598,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   if (isEnabled(o2::detectors::DetID::TPC)) {
     if (!helpasked && ismaster) {
-      initTPC();
+      initTPC(hbfu.startTime);
     }
 
     tpcsectors = o2::RangeTokenizer::tokenize<int>(configcontext.options().get<std::string>("tpc-sectors"));

From 947a1a8cc06cd2e694cb8e5beb561e9392629af5 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 10:12:57 +0200
Subject: [PATCH 0347/1764] GPU TPC: Remove some obsolete code and track
 members (leftover from Run 2 by Sergey and totally forgotten), which were
 wasting performance

---
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h  |  9 --------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 21 +------------------
 2 files changed, 1 insertion(+), 29 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 578fe1eeb4ca7..6ef2ed2ede668 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -41,9 +41,6 @@ class GPUTPCGMMergedTrack
   {
     return mAlpha;
   }
-  GPUd() float LastX() const { return mLastX; }
-  GPUd() float LastY() const { return mLastY; }
-  GPUd() float LastZ() const { return mLastZ; }
   GPUd() bool OK() const { return mFlags & 0x01; }
   GPUd() bool Looper() const { return mFlags & 0x02; }
   GPUd() bool CSide() const { return mFlags & 0x04; }
@@ -55,9 +52,6 @@ class GPUTPCGMMergedTrack
   GPUd() void SetFirstClusterRef(int32_t v) { mFirstClusterRef = v; }
   GPUd() void SetParam(const GPUTPCGMTrackParam& v) { mParam = v; }
   GPUd() void SetAlpha(float v) { mAlpha = v; }
-  GPUd() void SetLastX(float v) { mLastX = v; }
-  GPUd() void SetLastY(float v) { mLastY = v; }
-  GPUd() void SetLastZ(float v) { mLastZ = v; }
   GPUd() void SetOK(bool v)
   {
     if (v) {
@@ -110,9 +104,6 @@ class GPUTPCGMMergedTrack
   gputpcgmmergertypes::GPUTPCOuterParam mOuterParam; //* outer param
 
   float mAlpha;              //* alpha angle
-  float mLastX;              //* outer X
-  float mLastY;              //* outer Y
-  float mLastZ;              //* outer Z
   uint32_t mFirstClusterRef; //* index of the first track cluster in corresponding cluster arrays
   // TODO: Change to 8 bit
   uint32_t mNClusters;       //* number of track clusters
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 0d8547263207b..366f75cb05e56 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -1143,26 +1143,7 @@ GPUd() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict() tr
   track.Param() = t;
   track.Alpha() = Alpha;
 
-  if (track.OK()) {
-    int32_t ind = track.FirstClusterRef();
-    const GPUParam& GPUrestrict() param = merger->Param();
-    float alphaa = param.Alpha(merger->Clusters()[ind].sector);
-    float xx, yy, zz;
-    if (merger->Param().par.earlyTpcTransform) {
-      xx = merger->ClustersXYZ()[ind].x;
-      yy = merger->ClustersXYZ()[ind].y;
-      zz = merger->ClustersXYZ()[ind].z - track.Param().GetTZOffset();
-    } else {
-      const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[merger->Clusters()[ind].num];
-      merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(merger->Clusters()[ind].sector, merger->Clusters()[ind].row, cl.getPad(), cl.getTime(), xx, yy, zz, track.Param().GetTZOffset());
-    }
-    float sinA, cosA;
-    CAMath::SinCos(alphaa - track.Alpha(), sinA, cosA);
-    track.SetLastX(xx * cosA - yy * sinA);
-    track.SetLastY(xx * sinA + yy * cosA);
-    track.SetLastZ(zz);
-    // merger->DebugRefitMergedTrack(track);
-  }
+  // if (track.OK()) merger->DebugRefitMergedTrack(track);
 }
 
 GPUd() void GPUTPCGMTrackParam::Rotate(float alpha)

From f3f10a25f8abaf9dcf62e764a963f68dfefdc6b4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 10:17:56 +0200
Subject: [PATCH 0348/1764] GPU TPC: Rename some variables with misleading name

---
 ...GPUReconstructionCUDAKernelsSpecialize.inc |  4 +--
 .../DataCompression/GPUTPCCompression.cxx     |  2 +-
 .../GPUTPCCompressionKernels.cxx              | 10 +++---
 .../GPUChainTrackingDebugAndProfiling.cxx     |  4 +--
 .../Global/GPUChainTrackingMerger.cxx         | 12 +++----
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 32 +++++++++----------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  4 +--
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx | 14 ++++----
 GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx  |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  2 +-
 .../Merger/GPUTPCGMTracksToTPCSeeds.cxx       |  6 ++--
 .../Merger/GPUTPCGlobalDebugSortKernels.cxx   |  4 +--
 12 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
index 8796f063abdc5..d3dd561dcea2f 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
@@ -109,13 +109,13 @@ inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed
 template <>
 inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
 {
-  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NMergedTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 
 template <>
 inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
 {
-  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NOutputTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NMergedTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
 }
 
 template <>
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index 82834a694d0ba..ec1636dfe7f59 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -125,7 +125,7 @@ void GPUTPCCompression::SetMaxData(const GPUTrackingInOutPointers& io)
   mMaxClusterFactorBase1024 = mMaxClusters > 100000000 ? mRec->MemoryScalers()->NTPCUnattachedHitsBase1024(mRec->GetParam().rec.tpc.rejectionStrategy) : 1024;
   mMaxClustersInCache = mMaxClusters * mMaxClusterFactorBase1024 / 1024;
   mMaxTrackClusters = mRec->GetConstantMem().tpcMerger.NOutputTrackClusters(); // TODO: Why is this not using ioPtrs? Could remove GPUConstantMem.h include
-  mMaxTracks = mRec->GetConstantMem().tpcMerger.NOutputTracks();
+  mMaxTracks = mRec->GetConstantMem().tpcMerger.NMergedTracks();
   if (mMaxClusters % 16) {
     mMaxClusters += 16 - (mMaxClusters % 16);
   }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index bba97e9eace9b..73b195e8f4fe4 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -201,7 +201,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
     const uint32_t iSector = iSectorRow / GPUCA_ROW_COUNT;
     const uint32_t iRow = iSectorRow % GPUCA_ROW_COUNT;
     const uint32_t idOffset = clusters->clusterOffset[iSector][iRow];
-    const uint32_t idOffsetOut = clusters->clusterOffset[iSector][iRow] * compressor.mMaxClusterFactorBase1024 / 1024;
+    const uint32_t idOffsetOut = clusters->clusterOffset[iSector][iRow] * compressor.mMaxClusterFactorBase1024 / 1024;                           // 32 bit enough for number of clusters per row * 1024
     const uint32_t idOffsetOutMax = ((const uint32_t*)clusters->clusterOffset[iSector])[iRow + 1] * compressor.mMaxClusterFactorBase1024 / 1024; // Array out of bounds access is ok, since it goes to the correct nClustersTotal
     if (iThread == nThreads - 1) {
       smem.nCount = 0;
@@ -214,7 +214,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
     const uint32_t nn = CAMath::nextMultipleOf<GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached)>(clusters->nClusters[iSector][iRow]);
     for (uint32_t i = iThread; i < nn + nThreads; i += nThreads) {
       const int32_t idx = idOffset + i;
-      int32_t cidx = 0;
+      int32_t storeCluster = 0;
       do {
         if (i >= clusters->nClusters[iSector][iRow]) {
           break;
@@ -239,13 +239,13 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
             break;
           }
         }
-        cidx = 1;
+        storeCluster = 1;
       } while (false);
 
       GPUbarrier();
-      int32_t myIndex = work_group_scan_inclusive_add(cidx);
+      int32_t myIndex = work_group_scan_inclusive_add(storeCluster);
       int32_t storeLater = -1;
-      if (cidx) {
+      if (storeCluster) {
         if (smem.nCount + myIndex <= GPUCA_TPC_COMP_CHUNK_SIZE) {
           sortBuffer[smem.nCount + myIndex - 1] = i;
         } else {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 00cf127162b94..f72943e6bcd5a 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -153,7 +153,7 @@ void GPUChainTracking::PrintMemoryStatistics()
     addToMap("TPC Sector TrackHits", usageMap, *processors()->tpcTrackers[i].NTrackHits(), processors()->tpcTrackers[i].NMaxTrackHits());
   }
   addToMap("TPC Clusterer Clusters", usageMap, mRec->MemoryScalers()->nTPCHits, mRec->MemoryScalers()->NTPCClusters(mRec->MemoryScalers()->nTPCdigits));
-  addToMap("TPC Tracks", usageMap, processors()->tpcMerger.NOutputTracks(), processors()->tpcMerger.NMaxTracks());
+  addToMap("TPC Tracks", usageMap, processors()->tpcMerger.NMergedTracks(), processors()->tpcMerger.NMaxTracks());
   addToMap("TPC TrackHits", usageMap, processors()->tpcMerger.NOutputTrackClusters(), processors()->tpcMerger.NMaxOutputTrackClusters());
 
   if (mRec->GetProcessingSettings().createO2Output) {
@@ -181,7 +181,7 @@ void GPUChainTracking::PrintMemoryRelations()
     GPUInfo("MEMREL SectorTracks NCl %d NTrk %d", processors()->tpcTrackers[i].NHitsTotal(), *processors()->tpcTrackers[i].NTracks());
     GPUInfo("MEMREL SectorTrackHits NCl %d NTrkH %d", processors()->tpcTrackers[i].NHitsTotal(), *processors()->tpcTrackers[i].NTrackHits());
   }
-  GPUInfo("MEMREL Tracks NCl %d NTrk %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NOutputTracks());
+  GPUInfo("MEMREL Tracks NCl %d NTrk %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NMergedTracks());
   GPUInfo("MEMREL TrackHitss NCl %d NTrkH %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NOutputTrackClusters());
 }
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 6e86be03e7950..bd1fa7796dadf 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -220,7 +220,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     mOutputQueue.clear();
   }
 
-  runKernel<GPUTPCGMMergerTrackFit>(doGPU ? GetGrid(Merger.NOutputTracks(), 0) : GetGridAuto(0), mergerSortTracks ? 1 : 0);
+  runKernel<GPUTPCGMMergerTrackFit>(doGPU ? GetGrid(Merger.NMergedTracks(), 0) : GetGridAuto(0), mergerSortTracks ? 1 : 0);
   if (param().rec.tpc.retryRefit == 1) {
     runKernel<GPUTPCGMMergerTrackFit>(GetGridAuto(0), -1);
   }
@@ -233,7 +233,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   runKernel<GPUTPCGMMergerFinalize, 1>(GetGridAuto(0, deviceType));
   runKernel<GPUTPCGMMergerFinalize, 2>(GetGridAuto(0, deviceType));
   if (param().rec.tpc.mergeLoopersAfterburner) {
-    runKernel<GPUTPCGMMergerMergeLoopers, 0>(doGPU ? GetGrid(Merger.NOutputTracks(), 0, deviceType) : GetGridAuto(0, deviceType));
+    runKernel<GPUTPCGMMergerMergeLoopers, 0>(doGPU ? GetGrid(Merger.NMergedTracks(), 0, deviceType) : GetGridAuto(0, deviceType));
     if (doGPU) {
       TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResMemory(), 0);
       SynchronizeStream(0); // TODO: could probably synchronize on an event after runKernel<GPUTPCGMMergerMergeLoopers, 1>
@@ -255,10 +255,10 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
           throw std::runtime_error("QA Scratch buffer exceeded");
         }
       }
-      GPUMemCpy(RecoStep::TPCMerging, Merger.OutputTracks(), MergerShadowAll.OutputTracks(), Merger.NOutputTracks() * sizeof(*Merger.OutputTracks()), outputStream, 0, nullptr, waitEvent);
+      GPUMemCpy(RecoStep::TPCMerging, Merger.OutputTracks(), MergerShadowAll.OutputTracks(), Merger.NMergedTracks() * sizeof(*Merger.OutputTracks()), outputStream, 0, nullptr, waitEvent);
       waitEvent = nullptr;
       if (param().dodEdxEnabled) {
-        GPUMemCpy(RecoStep::TPCMerging, Merger.OutputTracksdEdx(), MergerShadowAll.OutputTracksdEdx(), Merger.NOutputTracks() * sizeof(*Merger.OutputTracksdEdx()), outputStream, 0);
+        GPUMemCpy(RecoStep::TPCMerging, Merger.OutputTracksdEdx(), MergerShadowAll.OutputTracksdEdx(), Merger.NMergedTracks() * sizeof(*Merger.OutputTracksdEdx()), outputStream, 0);
       }
       GPUMemCpy(RecoStep::TPCMerging, Merger.Clusters(), MergerShadowAll.Clusters(), Merger.NOutputTrackClusters() * sizeof(*Merger.Clusters()), outputStream, 0);
       if (param().par.earlyTpcTransform) {
@@ -326,7 +326,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   }
 
   mIOPtrs.mergedTracks = Merger.OutputTracks();
-  mIOPtrs.nMergedTracks = Merger.NOutputTracks();
+  mIOPtrs.nMergedTracks = Merger.NMergedTracks();
   mIOPtrs.mergedTrackHits = Merger.Clusters();
   mIOPtrs.mergedTrackHitsXYZ = Merger.ClustersXYZ();
   mIOPtrs.nMergedTrackHits = Merger.NOutputTrackClusters();
@@ -340,7 +340,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
 
   if (doGPU) {
     processorsShadow()->ioPtrs.mergedTracks = MergerShadow.OutputTracks();
-    processorsShadow()->ioPtrs.nMergedTracks = Merger.NOutputTracks();
+    processorsShadow()->ioPtrs.nMergedTracks = Merger.NMergedTracks();
     processorsShadow()->ioPtrs.mergedTrackHits = MergerShadow.Clusters();
     processorsShadow()->ioPtrs.mergedTrackHitsXYZ = MergerShadow.ClustersXYZ();
     processorsShadow()->ioPtrs.nMergedTrackHits = Merger.NOutputTrackClusters();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index d2aba503be6a6..e96bbeee774bf 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -415,7 +415,7 @@ int32_t GPUTPCGMMerger::CheckSectors()
 
 GPUd() void GPUTPCGMMerger::ClearTrackLinks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, bool output)
 {
-  const int32_t n = output ? mMemory->nOutputTracks : SectorTrackInfoLocalTotal();
+  const int32_t n = output ? mMemory->nMergedTracks : SectorTrackInfoLocalTotal();
   for (int32_t i = iBlock * nThreads + iThread; i < n; i += nThreads * nBlocks) {
     mTrackLinks[i] = -1;
   }
@@ -1271,7 +1271,7 @@ GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const
 GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
   const ClusterNative* cls = Param().par.earlyTpcTransform ? nullptr : mConstantMem->ioPtrs.clustersNative->clustersLinear;
-  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTracks; i += nThreads * nBlocks) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nThreads * nBlocks) {
     if (mOutputTracks[i].CSide() == 0 && mTrackLinks[i] >= 0) {
       if (mTrackLinks[mTrackLinks[i]] != (int32_t)i) {
         continue;
@@ -1392,7 +1392,7 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
     }
   }
 
-  // for (int32_t i = 0;i < mMemory->nOutputTracks;i++) {if (mOutputTracks[i].CCE() == false) {mOutputTracks[i].SetNClusters(0);mOutputTracks[i].SetOK(false);}} //Remove all non-CE tracks
+  // for (int32_t i = 0;i < mMemory->nMergedTracks;i++) {if (mOutputTracks[i].CCE() == false) {mOutputTracks[i].SetNClusters(0);mOutputTracks[i].SetOK(false);}} //Remove all non-CE tracks
 }
 
 namespace o2::gpu::internal
@@ -1533,7 +1533,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     nHits = 0;
     for (int32_t ipart = 0; ipart < nParts; ipart++) {
       const GPUTPCGMSectorTrack* t = trackParts[ipart];
-      CADEBUG(printf("Collect Track %d Part %d QPt %f DzDs %f\n", mMemory->nOutputTracks, ipart, t->QPt(), t->DzDs()));
+      CADEBUG(printf("Collect Track %d Part %d QPt %f DzDs %f\n", mMemory->nMergedTracks, ipart, t->QPt(), t->DzDs()));
       int32_t nTrackHits = t->NClusters();
       trackCluster* c2 = trackClusters + nHits + nTrackHits - 1;
       for (int32_t i = 0; i < nTrackHits; i++, c2--) {
@@ -1678,10 +1678,10 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       cl[i].leg = trackClusters[i].leg;
     }
 
-    uint32_t iOutputTrack = CAMath::AtomicAdd(&mMemory->nOutputTracks, 1u);
+    uint32_t iOutputTrack = CAMath::AtomicAdd(&mMemory->nMergedTracks, 1u);
     if (iOutputTrack >= mNMaxTracks) {
       raiseError(GPUErrors::ERROR_MERGER_TRACK_OVERFLOW, iOutputTrack, mNMaxTracks);
-      CAMath::AtomicExch(&mMemory->nOutputTracks, mNMaxTracks);
+      CAMath::AtomicExch(&mMemory->nMergedTracks, mNMaxTracks);
       continue;
     }
 
@@ -1718,9 +1718,9 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       p1.QPt() = 100.f / Param().rec.bz0Pt10MeV;
     }
 
-    // if (nParts > 1) printf("Merged %d: QPt %f %d parts %d hits\n", mMemory->nOutputTracks, p1.QPt(), nParts, nHits);
+    // if (nParts > 1) printf("Merged %d: QPt %f %d parts %d hits\n", mMemory->nMergedTracks, p1.QPt(), nParts, nHits);
 
-    /*if (GPUQA::QAAvailable() && mRec->GetQA() && mRec->GetQA()->SuppressTrack(mMemory->nOutputTracks))
+    /*if (GPUQA::QAAvailable() && mRec->GetQA() && mRec->GetQA()->SuppressTrack(mMemory->nMergedTracks))
     {
       mergedTrack.SetOK(0);
       mergedTrack.SetNClusters(0);
@@ -1742,14 +1742,14 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
 
 GPUd() void GPUTPCGMMerger::SortTracksPrepare(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTracks; i += nThreads * nBlocks) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nThreads * nBlocks) {
     mTrackOrderProcess[i] = i;
   }
 }
 
 GPUd() void GPUTPCGMMerger::PrepareClustersForFit0(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTracks; i += nBlocks * nThreads) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nBlocks * nThreads) {
     mTrackSort[i] = i;
   }
 }
@@ -1784,7 +1784,7 @@ GPUd() void GPUTPCGMMerger::SortTracks(int32_t nBlocks, int32_t nThreads, int32_
     ) // clang-format on
   };
 
-  GPUCommonAlgorithm::sortDeviceDynamic(mTrackOrderProcess, mTrackOrderProcess + mMemory->nOutputTracks, comp);
+  GPUCommonAlgorithm::sortDeviceDynamic(mTrackOrderProcess, mTrackOrderProcess + mMemory->nMergedTracks, comp);
 #endif
 }
 
@@ -1810,13 +1810,13 @@ GPUd() void GPUTPCGMMerger::SortTracksQPt(int32_t nBlocks, int32_t nThreads, int
     ) // clang-format on
   };
 
-  GPUCommonAlgorithm::sortDeviceDynamic(mTrackSort, mTrackSort + mMemory->nOutputTracks, comp);
+  GPUCommonAlgorithm::sortDeviceDynamic(mTrackSort, mTrackSort + mMemory->nMergedTracks, comp);
 #endif
 }
 
 GPUd() void GPUTPCGMMerger::PrepareClustersForFit1(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTracks; i += nBlocks * nThreads) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nBlocks * nThreads) {
     mTrackOrderAttach[mTrackSort[i]] = i;
     const GPUTPCGMMergedTrack& trk = mOutputTracks[i];
     if (trk.OK()) {
@@ -1848,7 +1848,7 @@ GPUd() void GPUTPCGMMerger::PrepareClustersForFit2(int32_t nBlocks, int32_t nThr
 
 GPUd() void GPUTPCGMMerger::Finalize0(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTracks; i += nThreads * nBlocks) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nThreads * nBlocks) {
     mTrackSort[mTrackOrderAttach[i]] = i;
   }
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTrackClusters; i += nThreads * nBlocks) {
@@ -1858,7 +1858,7 @@ GPUd() void GPUTPCGMMerger::Finalize0(int32_t nBlocks, int32_t nThreads, int32_t
 
 GPUd() void GPUTPCGMMerger::Finalize1(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTracks; i += nThreads * nBlocks) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nThreads * nBlocks) {
     const GPUTPCGMMergedTrack& trk = mOutputTracks[i];
     if (!trk.OK() || trk.NClusters() == 0) {
       continue;
@@ -1893,7 +1893,7 @@ GPUd() void GPUTPCGMMerger::Finalize2(int32_t nBlocks, int32_t nThreads, int32_t
 GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
   const float lowPtThresh = Param().rec.tpc.rejectQPtB5 * 1.1f; // Might need to merge tracks above the threshold with parts below the threshold
-  for (uint32_t i = get_global_id(0); i < mMemory->nOutputTracks; i += get_global_size(0)) {
+  for (uint32_t i = get_global_id(0); i < mMemory->nMergedTracks; i += get_global_size(0)) {
     const auto& trk = mOutputTracks[i];
     const auto& p = trk.GetParam();
     const float qptabs = CAMath::Abs(p.GetQPt());
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 6c6e0e02a2dc2..6c9c14b557798 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -69,7 +69,7 @@ class GPUTPCGMMerger : public GPUProcessor
     GPUAtomic(uint32_t) nRetryRefit;
     GPUAtomic(uint32_t) nLoopData;
     GPUAtomic(uint32_t) nUnpackedTracks;
-    GPUAtomic(uint32_t) nOutputTracks;
+    GPUAtomic(uint32_t) nMergedTracks;
     GPUAtomic(uint32_t) nOutputTrackClusters;
     GPUAtomic(uint32_t) nO2Tracks;
     GPUAtomic(uint32_t) nO2ClusRefs;
@@ -103,7 +103,7 @@ class GPUTPCGMMerger : public GPUProcessor
   void* SetPointersOutputState(void* mem);
   void* SetPointersMemory(void* mem);
 
-  GPUhdi() int32_t NOutputTracks() const { return mMemory->nOutputTracks; }
+  GPUhdi() int32_t NMergedTracks() const { return mMemory->nMergedTracks; }
   GPUhdi() const GPUTPCGMMergedTrack* OutputTracks() const { return mOutputTracks; }
   GPUhdi() GPUTPCGMMergedTrack* OutputTracks() { return mOutputTracks; }
   GPUhdi() const GPUdEdxInfo* OutputTracksdEdx() const { return mOutputTracksdEdx; }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index ac55f423b1c42..02d0ac98b05b0 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -94,7 +94,7 @@ void GPUTPCGMMerger::DumpMergeRanges(std::ostream& out, int32_t withinSector, in
 void GPUTPCGMMerger::DumpTrackLinks(std::ostream& out, bool output, const char* type) const
 {
   out << "\nTPC Merger Links " << type << "\n";
-  const int32_t n = output ? mMemory->nOutputTracks : SectorTrackInfoLocalTotal();
+  const int32_t n = output ? mMemory->nMergedTracks : SectorTrackInfoLocalTotal();
   for (int32_t i = 0; i < n; i++) {
     if (mTrackLinks[i] != -1) {
       out << "  " << i << ": " << mTrackLinks[i] << "\n";
@@ -138,7 +138,7 @@ void GPUTPCGMMerger::DumpCollected(std::ostream& out) const
   std::streamsize ss = out.precision();
   out << std::setprecision(2);
   out << "\nTPC Merger Collected Tracks\n";
-  for (uint32_t i = 0; i < mMemory->nOutputTracks; i++) {
+  for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mOutputTracks[i];
     const auto& p = trk.GetParam();
     out << "  Track " << i << ": Loop " << trk.Looper() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTZOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << "\n";
@@ -150,7 +150,7 @@ void GPUTPCGMMerger::DumpMergeCE(std::ostream& out) const
 {
   DumpTrackLinks(out, true, " for CE merging");
   out << "\nTPC Merger Merge CE\n";
-  for (uint32_t i = 0; i < mMemory->nOutputTracks; i++) {
+  for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mOutputTracks[i];
     if (trk.CCE()) {
       out << "  Track " << i << ": CCE\n";
@@ -162,11 +162,11 @@ void GPUTPCGMMerger::DumpFitPrepare(std::ostream& out) const
 {
   out << "\nTPC Merger Refit Prepare\n";
   out << "  Sort\n";
-  for (uint32_t i = 0; i < mMemory->nOutputTracks; i++) {
+  for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     out << "    " << i << ": " << mTrackOrderAttach[i] << "\n";
   }
   out << "  Clusters\n";
-  for (uint32_t j = 0; j < mMemory->nOutputTracks; j++) {
+  for (uint32_t j = 0; j < mMemory->nMergedTracks; j++) {
     const auto& trk = mOutputTracks[j];
     out << "  Track " << j << ": ";
     for (uint32_t i = trk.FirstClusterRef(); i < trk.FirstClusterRef() + trk.NClusters(); i++) {
@@ -195,7 +195,7 @@ void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
   std::streamsize ss = out.precision();
   out << std::setprecision(2);
   out << "\nTPC Merger Refit\n";
-  for (uint32_t i = 0; i < mMemory->nOutputTracks; i++) {
+  for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mOutputTracks[i];
     if (trk.NClusters() == 0) {
       continue;
@@ -212,7 +212,7 @@ void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
 void GPUTPCGMMerger::DumpFinal(std::ostream& out) const
 {
   out << "\nTPC Merger Finalized\n";
-  for (uint32_t j = 0; j < mMemory->nOutputTracks; j++) {
+  for (uint32_t j = 0; j < mMemory->nMergedTracks; j++) {
     const auto& trk = mOutputTracks[j];
     if (trk.NClusters() == 0) {
       continue;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
index d72d59a6250e7..68763b3549547 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
@@ -21,7 +21,7 @@ using namespace o2::gpu;
 template <>
 GPUdii() void GPUTPCGMMergerTrackFit::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int32_t mode)
 {
-  const int32_t iEnd = mode == -1 ? merger.Memory()->nRetryRefit : merger.NOutputTracks();
+  const int32_t iEnd = mode == -1 ? merger.Memory()->nRetryRefit : merger.NMergedTracks();
   GPUCA_TBB_KERNEL_LOOP(merger.GetRec(), int32_t, ii, iEnd, {
     const int32_t i = mode == -1 ? merger.RetryRefitIds()[ii] : mode ? merger.TrackOrderProcess()[ii] : ii;
     GPUTPCGMTrackParam::RefitTrack(merger.OutputTracks()[i], i, &merger, mode == -1);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 9ead17ea5c7c0..72e9f63e5da83 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -38,7 +38,7 @@ template <>
 GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
   const GPUTPCGMMergedTrack* tracks = merger.OutputTracks();
-  const uint32_t nTracks = merger.NOutputTracks();
+  const uint32_t nTracks = merger.NMergedTracks();
   const GPUTPCGMMergedTrackHit* trackClusters = merger.Clusters();
   const GPUdEdxInfo* tracksdEdx = merger.OutputTracksdEdx();
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.cxx
index 78eea63edecdd..ebc9d22560524 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.cxx
@@ -34,7 +34,7 @@ void GPUTPCGMTracksToTPCSeeds::CreateSeedsFromHLTTracks(TObjArray* seeds, AliTPC
   }
   seeds->Clear();
   int32_t index = 0;
-  for (int32_t i = 0; i < merger->NOutputTracks(); i++) {
+  for (int32_t i = 0; i < merger->NMergedTracks(); i++) {
     const GPUTPCGMMergedTrack& track = merger->OutputTracks()[i];
     if (!track.OK()) {
       continue;
@@ -112,7 +112,7 @@ void GPUTPCGMTracksToTPCSeeds::UpdateParamsOuter(TObjArray* seeds)
     return;
   }
   int32_t index = 0;
-  for (int32_t i = 0; i < merger->NOutputTracks(); i++) {
+  for (int32_t i = 0; i < merger->NMergedTracks(); i++) {
     const GPUTPCGMMergedTrack& track = merger->OutputTracks()[i];
     if (!track.OK()) {
       continue;
@@ -134,7 +134,7 @@ void GPUTPCGMTracksToTPCSeeds::UpdateParamsInner(TObjArray* seeds)
     return;
   }
   int32_t index = 0;
-  for (int32_t i = 0; i < merger->NOutputTracks(); i++) {
+  for (int32_t i = 0; i < merger->NMergedTracks(); i++) {
     const GPUTPCGMMergedTrack& track = merger->OutputTracks()[i];
     if (!track.OK()) {
       continue;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
index a21593b7ba9e9..e63bb82a9b09e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
@@ -100,7 +100,7 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
     return;
   }
   int32_t* GPUrestrict() tmp = merger.TmpSortMemory();
-  const int32_t n = merger.NOutputTracks();
+  const int32_t n = merger.NMergedTracks();
   for (int32_t j = 0; j < n; j++) {
     tmp[j] = j;
   }
@@ -117,7 +117,7 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
   if (iBlock) {
     return;
   }
-  const int32_t n = merger.NOutputTracks();
+  const int32_t n = merger.NMergedTracks();
   int32_t* GPUrestrict() tmp = merger.TmpSortMemory();
   int32_t* GPUrestrict() tmp2 = tmp + n;
   if (iThread == 0) {

From d929e0c4ead9661119fb4859b12b71591e02b76f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 10:25:11 +0200
Subject: [PATCH 0349/1764] GPU: Add additional optional debbug dumps for
 validation

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 .../Global/GPUChainTrackingDebug.h            | 45 ++++++++++---------
 .../Global/GPUChainTrackingMerger.cxx         |  7 +--
 .../Global/GPUChainTrackingSectorTracker.cxx  |  4 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h  |  1 +
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  1 +
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx | 15 ++++++-
 7 files changed, 47 insertions(+), 28 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 9e0aa32155f0d..9400a429fca81 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -295,7 +295,7 @@ AddOption(trdNCandidates, int32_t, 3, "", 0, "Number of branching track candidat
 AddOption(trdTrackModelO2, bool, false, "", 0, "Use O2 track model instead of GPU track model for TRD tracking")
 AddOption(debugLevel, int32_t, -1, "debug", 'd', "Set debug level (-2 = silent, -1 = autoselect (-2 for O2, 0 for standalone))")
 AddOption(allocDebugLevel, int32_t, 0, "allocDebug", 0, "Some debug output for memory allocations (without messing with normal debug level)")
-AddOption(debugMask, uint32_t, 262143, "", 0, "Mask for debug output dumps to file")
+AddOption(debugMask, uint32_t, (1 << 18) - 1, "debugMask", 0, "Mask for debug output dumps to file")
 AddOption(debugLogSuffix, std::string, "", "debugSuffix", 0, "Suffix for debug log files with --debug 6")
 AddOption(serializeGPU, int8_t, 0, "", 0, "Synchronize after each kernel call (bit 1) and DMA transfer (bit 2) and identify failures")
 AddOption(recoTaskTiming, bool, 0, "", 0, "Perform summary timing after whole reconstruction tasks")
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebug.h b/GPU/GPUTracking/Global/GPUChainTrackingDebug.h
index 810f40a1d8654..6c995f65f3dd3 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebug.h
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebug.h
@@ -23,28 +23,29 @@ namespace o2::gpu
 {
 // NOTE: Values below 262144 are activated by default with --debug 6 in GPUSettingsList.h::debugMask
 enum GPUChainTrackingDebugFlags : uint32_t {
-  TPCSectorTrackingData = 1,
-  TPCPreLinks = 2,
-  TPCLinks = 4,
-  TPCStartHits = 8,
-  TPCTracklets = 16,
-  TPCSectorTracks = 32,
-  TPCHitWeights = 256,
-  TPCCompressedClusters = 512,
-  TPCDecompressedClusters = 1024,
-  TPCMergingRanges = 2048,
-  TPCMergingSectorTracks = 4096,
-  TPCMergingMergedTracks = 8192,
-  TPCMergingCollectedTracks = 16384,
-  TPCMergingCE = 32768,
-  TPCMergingRefit = 65536,
-  TPCClustererClusters = 131072,
-  TPCClusterer = 262144,
-  TPCClustererDigits = 262144 << 1,
-  TPCClustererPeaks = 262144 << 2,
-  TPCClustererSuppressedPeaks = 262144 << 3,
-  TPCClustererChargeMap = 262144 << 4,
-  TPCClustererZeroedCharges = 262144 << 5
+  TPCSectorTrackingData = 1 << 0,
+  TPCPreLinks = 1 << 1,
+  TPCLinks = 1 << 2,
+  TPCStartHits = 1 << 3,
+  TPCTracklets = 1 << 4,
+  TPCSectorTracks = 1 << 5,
+  TPCHitWeights = 1 << 6,
+  TPCMergingRanges = 1 << 7,
+  TPCMergingSectorTracks = 1 << 8,
+  TPCMergingMatching = 1 << 9,
+  TPCMergingCollectedTracks = 1 << 10,
+  TPCMergingCE = 1 << 11,
+  TPCMergingPrepareFit = 1 << 12,
+  TPCMergingRefit = 1 << 13,
+  TPCMergingLoopers = 1 << 14,
+  TPCCompressedClusters = 1 << 15,
+  TPCDecompressedClusters = 1 << 16,
+  TPCClustererClusters = 1 << 17,
+  TPCClustererDigits = 1 << 18,
+  TPCClustererPeaks = 1 << 19,
+  TPCClustererSuppressedPeaks = 1 << 20,
+  TPCClustererChargeMap = 1 << 21,
+  TPCClustererZeroedCharges = 1 << 22
 };
 
 template <class T, class S, typename... Args>
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index bd1fa7796dadf..df80eabfb8761 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -143,7 +143,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   runKernel<GPUTPCGMMergerMergeWithinPrepare>(GetGridAuto(0, deviceType));
   RunTPCTrackingMerger_MergeBorderTracks(1, 0, deviceType);
   RunTPCTrackingMerger_Resolve(0, 1, deviceType);
-  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingMergedTracks, doGPU, Merger, &GPUTPCGMMerger::DumpMergedWithinSectors, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingMatching, doGPU, Merger, &GPUTPCGMMerger::DumpMergedWithinSectors, *mDebugFile);
 
   runKernel<GPUTPCGMMergerClearLinks>(GetGridAuto(0, deviceType), false);
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), 2 * NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
@@ -158,7 +158,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   runKernel<GPUTPCGMMergerMergeSectorsPrepare>(GetGridBlk(std::max(2u, numBlocks), 0, deviceType), 0, 1, 1);
   RunTPCTrackingMerger_MergeBorderTracks(0, -1, deviceType);
   RunTPCTrackingMerger_Resolve(0, 1, deviceType);
-  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingMergedTracks, doGPU, Merger, &GPUTPCGMMerger::DumpMergedBetweenSectors, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingMatching, doGPU, Merger, &GPUTPCGMMerger::DumpMergedBetweenSectors, *mDebugFile);
 
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), 2 * NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
 
@@ -202,7 +202,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   runKernel<GPUTPCGMMergerPrepareClusters, 1>(GetGridAuto(0, deviceType));
   runKernel<GPUTPCGMMergerPrepareClusters, 2>(GetGridAuto(0, deviceType));
 
-  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRefit, doGPU, Merger, &GPUTPCGMMerger::DumpFitPrepare, *mDebugFile);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingPrepareFit, doGPU, Merger, &GPUTPCGMMerger::DumpFitPrepare, *mDebugFile);
 
   if (doGPU) {
     CondWaitEvent(waitForTransfer, &mEvents->single);
@@ -240,6 +240,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     }
     runKernel<GPUTPCGMMergerMergeLoopers, 1>(GetGridAuto(0, deviceType));
     runKernel<GPUTPCGMMergerMergeLoopers, 2>(doGPU ? GetGrid(Merger.Memory()->nLooperMatchCandidates, 0, deviceType) : GetGridAuto(0, deviceType));
+    DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingLoopers, Merger, &GPUTPCGMMerger::DumpLoopers, *mDebugFile);
   }
   DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRefit, doGPU, Merger, &GPUTPCGMMerger::DumpFinal, *mDebugFile);
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index ef38d53173c2b..67ef402961a20 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -176,7 +176,9 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     }
 
     if (GetProcessingSettings().debugLevel >= 6) {
-      *mDebugFile << "\n\nReconstruction: Sector " << iSector << "/" << NSECTORS << std::endl;
+      if ((GetProcessingSettings().debugMask & 63)) {
+        *mDebugFile << "\n\nReconstruction: Sector " << iSector << "/" << NSECTORS << std::endl;
+      }
       if (GetProcessingSettings().debugMask & GPUChainTrackingDebugFlags::TPCSectorTrackingData) {
         if (doGPU) {
           TransferMemoryResourcesToHost(RecoStep::TPCSectorTracking, &trk, -1, true);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 6ef2ed2ede668..73b14ba1b2fdf 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -95,6 +95,7 @@ class GPUTPCGMMergedTrack
   GPUd() void SetFlags(uint8_t v) { mFlags = v; }
   GPUd() void SetLegs(uint8_t v) { mLegs = v; }
   GPUd() uint8_t Legs() const { return mLegs; }
+  GPUd() uint8_t Flags() const { return mFlags; }
 
   GPUd() const gputpcgmmergertypes::GPUTPCOuterParam& OuterParam() const { return mOuterParam; }
   GPUd() gputpcgmmergertypes::GPUTPCOuterParam& OuterParam() { return mOuterParam; }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 6c9c14b557798..ae85f20b17b48 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -201,6 +201,7 @@ class GPUTPCGMMerger : public GPUProcessor
   void DumpFitPrepare(std::ostream& out) const;
   void DumpRefit(std::ostream& out) const;
   void DumpFinal(std::ostream& out) const;
+  void DumpLoopers(std::ostream& out) const;
 
   template <int32_t mergeType>
   void MergedTrackStreamerInternal(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, int32_t mergeMode, float weight, float frac) const;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 02d0ac98b05b0..3be32a2d87610 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -204,11 +204,24 @@ void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
     const auto& po = trk.OuterParam();
     out << "  Track " << i << ": OK " << trk.OK() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTZOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << " / " << trk.NClustersFitted() << " Cov " << p.GetErr2Y() << "/" << p.GetErr2Z()
         << " dEdx " << (trk.OK() && Param().dodEdxEnabled ? mOutputTracksdEdx[i].dEdxTotTPC : -1.f) << "/" << (trk.OK() && Param().dodEdxEnabled ? mOutputTracksdEdx[i].dEdxMaxTPC : -1.f)
-        << " Outer " << po.P[0] << "/" << po.P[1] << "/" << po.P[2] << "/" << po.P[3] << "/" << po.P[4] << "\n";
+        << " Outer " << po.P[0] << "/" << po.P[1] << "/" << po.P[2] << "/" << po.P[3] << "/" << po.P[4]
+        << " NFitted " << trk.NClustersFitted() << " legs " << (int)trk.Legs() << " flags " << (int)trk.Flags() << "\n";
   }
   out << std::setprecision(ss);
 }
 
+void GPUTPCGMMerger::DumpLoopers(std::ostream& out) const
+{
+  out << "\n TPC Merger Looper Afterburner\n";
+  for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
+    if (i && i % 100 == 0) {
+      out << "\n";
+    }
+    out << (int)mOutputTracks[i].MergedLooper() << " ";
+  }
+  out << "\n";
+}
+
 void GPUTPCGMMerger::DumpFinal(std::ostream& out) const
 {
   out << "\nTPC Merger Finalized\n";

From d20b540fb0b5693ad6fa39b128d589160c91163f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 10:25:47 +0200
Subject: [PATCH 0350/1764] GPU TPC: Fix deterministic mode for TPC cluster
 compression / decompression / looper merging afterburner

---
 .../Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc      | 4 ++--
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx                     | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx                   | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
index d3dd561dcea2f..1d633eb5e748f 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
@@ -82,14 +82,14 @@ struct GPUTPCGMMergerSortTracksQPt_comp {
 struct GPUTPCGMMergerMergeLoopers_comp {
   GPUd() bool operator()(const MergeLooperParam& a, const MergeLooperParam& b)
   {
-    return CAMath::Abs(a.refz) < CAMath::Abs(b.refz);
+    return GPUCA_DETERMINISTIC_CODE(CAMath::Abs(a.refz) != CAMath::Abs(b.refz) ? CAMath::Abs(a.refz) < CAMath::Abs(b.refz) : a.id < b.id, CAMath::Abs(a.refz) < CAMath::Abs(b.refz));
   }
 };
 
 struct GPUTPCGMO2OutputSort_comp {
   GPUd() bool operator()(const GPUTPCGMMerger::tmpSort& a, const GPUTPCGMMerger::tmpSort& b)
   {
-    return (a.y > b.y);
+    return GPUCA_DETERMINISTIC_CODE(a.y != b.y ? a.y > b.y : a.x > b.x, a.y > b.y);
   }
 };
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index e96bbeee774bf..99ef548b2d78e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1948,7 +1948,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersSort(int32_t nBlocks, int32_t nThreads,
   if (iThread || iBlock) {
     return;
   }
-  auto comp = [](const MergeLooperParam& a, const MergeLooperParam& b) { return CAMath::Abs(a.refz) < CAMath::Abs(b.refz); };
+  auto comp = [](const MergeLooperParam& a, const MergeLooperParam& b) { return GPUCA_DETERMINISTIC_CODE(CAMath::Abs(a.refz) != CAMath::Abs(b.refz) ? CAMath::Abs(a.refz) < CAMath::Abs(b.refz) : a.id < b.id, CAMath::Abs(a.refz) < CAMath::Abs(b.refz)); };
   GPUCommonAlgorithm::sortDeviceDynamic(mLooperCandidates, mLooperCandidates + mMemory->nLooperMatchCandidates, comp);
 #endif
 }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 72e9f63e5da83..624c9ab487c8d 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -88,7 +88,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::sort>(int32_t nBlocks,
     return;
   }
   GPUTPCGMMerger::tmpSort* GPUrestrict() trackSort = merger.TrackSortO2();
-  auto comp = [](const auto& a, const auto& b) { return (a.y > b.y); };
+  auto comp = [](const auto& a, const auto& b) { return GPUCA_DETERMINISTIC_CODE(a.y != b.y ? a.y > b.y : a.x > b.x, a.y > b.y); };
   GPUCommonAlgorithm::sortDeviceDynamic(trackSort, trackSort + merger.Memory()->nO2Tracks, comp);
 #endif
 }

From 7732f5c426049d1eba9711b31626d4fb86d701b7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 10:51:13 +0200
Subject: [PATCH 0351/1764] GPU: Deduplicate sort comparisons: Use structs,
 since both hipcub and rocthrust do not work with lambdas for some reason

---
 ...GPUReconstructionCUDAKernelsSpecialize.inc |  82 ----------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 143 ++++++++++--------
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  20 ++-
 3 files changed, 98 insertions(+), 147 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
index 1d633eb5e748f..44cde3d4ac48a 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
@@ -14,88 +14,6 @@
 
 #if defined(GPUCA_SPECIALIZE_THRUST_SORTS) && !defined(GPUCA_GPUCODE_COMPILEKERNELS)
 
-namespace o2::gpu::internal
-{
-namespace // anonymous
-{
-struct MergeBorderTracks_compMax {
-  GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
-  {
-    return GPUCA_DETERMINISTIC_CODE((a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId), a.fMax < b.fMax);
-  }
-};
-struct MergeBorderTracks_compMin {
-  GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
-  {
-    return GPUCA_DETERMINISTIC_CODE((a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId), a.fMin < b.fMin);
-  }
-};
-
-struct GPUTPCGMMergerSortTracks_comp {
-  const GPUTPCGMMergedTrack* const mCmp;
-  GPUhd() GPUTPCGMMergerSortTracks_comp(GPUTPCGMMergedTrack* cmp) : mCmp(cmp) {}
-  GPUd() bool operator()(const int32_t aa, const int32_t bb)
-  {
-    const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
-    const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
-    if (a.CCE() != b.CCE()) {
-      return a.CCE() > b.CCE();
-    }
-    if (a.Legs() != b.Legs()) {
-      return a.Legs() > b.Legs();
-    }
-    GPUCA_DETERMINISTIC_CODE( // clang-format off
-      if (a.NClusters() != b.NClusters()) {
-        return a.NClusters() > b.NClusters();
-      } if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
-        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
-        return a.GetParam().GetY() > b.GetParam().GetY();
-      }
-      return aa > bb;
-    , // !GPUCA_DETERMINISTIC_CODE
-      return a.NClusters() > b.NClusters();
-    ) // clang-format on
-  }
-};
-
-struct GPUTPCGMMergerSortTracksQPt_comp {
-  const GPUTPCGMMergedTrack* const mCmp;
-  GPUhd() GPUTPCGMMergerSortTracksQPt_comp(GPUTPCGMMergedTrack* cmp) : mCmp(cmp) {}
-  GPUd() bool operator()(const int32_t aa, const int32_t bb)
-  {
-    const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
-    const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
-    GPUCA_DETERMINISTIC_CODE( // clang-format off
-      if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
-        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
-        return a.GetParam().GetY() > b.GetParam().GetY();
-      }
-      return a.GetParam().GetZ() > b.GetParam().GetZ();
-    , // !GPUCA_DETERMINISTIC_CODE
-      return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-    ) // clang-format on
-  }
-};
-
-struct GPUTPCGMMergerMergeLoopers_comp {
-  GPUd() bool operator()(const MergeLooperParam& a, const MergeLooperParam& b)
-  {
-    return GPUCA_DETERMINISTIC_CODE(CAMath::Abs(a.refz) != CAMath::Abs(b.refz) ? CAMath::Abs(a.refz) < CAMath::Abs(b.refz) : a.id < b.id, CAMath::Abs(a.refz) < CAMath::Abs(b.refz));
-  }
-};
-
-struct GPUTPCGMO2OutputSort_comp {
-  GPUd() bool operator()(const GPUTPCGMMerger::tmpSort& a, const GPUTPCGMMerger::tmpSort& b)
-  {
-    return GPUCA_DETERMINISTIC_CODE(a.y != b.y ? a.y > b.y : a.x > b.x, a.y > b.y);
-  }
-};
-
-} // anonymous namespace
-} // namespace o2::gpu::internal
-
 template <>
 inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerMergeBorders, 3>(const krnlSetupTime& _xyz, GPUTPCGMBorderRange* const& range, int32_t const& N, int32_t const& cmpMax)
 {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 99ef548b2d78e..b12375a10023a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -59,17 +59,13 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #endif
 
-namespace o2::gpu::internal
-{
-}
+static constexpr int32_t kMaxParts = 400;
+static constexpr int32_t kMaxClusters = GPUCA_MERGER_MAX_TRACK_CLUSTERS;
+
 using namespace o2::gpu;
-using namespace o2::gpu::internal;
 using namespace o2::tpc;
 using namespace gputpcgmmergertypes;
 
-static constexpr int32_t kMaxParts = 400;
-static constexpr int32_t kMaxClusters = GPUCA_MERGER_MAX_TRACK_CLUSTERS;
-
 namespace o2::gpu::internal
 {
 struct MergeLooperParam {
@@ -78,8 +74,79 @@ struct MergeLooperParam {
   float y;
   uint32_t id;
 };
+
+struct MergeBorderTracks_compMax {
+  GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
+  {
+    return GPUCA_DETERMINISTIC_CODE((a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId), a.fMax < b.fMax);
+  }
+};
+struct MergeBorderTracks_compMin {
+  GPUd() bool operator()(const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b)
+  {
+    return GPUCA_DETERMINISTIC_CODE((a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId), a.fMin < b.fMin);
+  }
+};
+
+struct GPUTPCGMMergerSortTracks_comp {
+  const GPUTPCGMMergedTrack* const mCmp;
+  GPUhd() GPUTPCGMMergerSortTracks_comp(GPUTPCGMMergedTrack* cmp) : mCmp(cmp) {}
+  GPUd() bool operator()(const int32_t aa, const int32_t bb)
+  {
+    const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
+    const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
+    if (a.CCE() != b.CCE()) {
+      return a.CCE() > b.CCE();
+    }
+    if (a.Legs() != b.Legs()) {
+      return a.Legs() > b.Legs();
+    }
+    GPUCA_DETERMINISTIC_CODE( // clang-format off
+      if (a.NClusters() != b.NClusters()) {
+        return a.NClusters() > b.NClusters();
+      } if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
+        return a.GetParam().GetY() > b.GetParam().GetY();
+      }
+      return aa > bb;
+    , // !GPUCA_DETERMINISTIC_CODE
+      return a.NClusters() > b.NClusters();
+    ) // clang-format on
+  }
+};
+
+struct GPUTPCGMMergerSortTracksQPt_comp {
+  const GPUTPCGMMergedTrack* const mCmp;
+  GPUhd() GPUTPCGMMergerSortTracksQPt_comp(GPUTPCGMMergedTrack* cmp) : mCmp(cmp) {}
+  GPUd() bool operator()(const int32_t aa, const int32_t bb)
+  {
+    const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
+    const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
+    GPUCA_DETERMINISTIC_CODE( // clang-format off
+      if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
+        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
+        return a.GetParam().GetY() > b.GetParam().GetY();
+      }
+      return a.GetParam().GetZ() > b.GetParam().GetZ();
+    , // !GPUCA_DETERMINISTIC_CODE
+      return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
+    ) // clang-format on
+  }
+};
+
+struct GPUTPCGMMergerMergeLoopers_comp {
+  GPUd() bool operator()(const MergeLooperParam& a, const MergeLooperParam& b)
+  {
+    return GPUCA_DETERMINISTIC_CODE(CAMath::Abs(a.refz) != CAMath::Abs(b.refz) ? CAMath::Abs(a.refz) < CAMath::Abs(b.refz) : a.id < b.id, CAMath::Abs(a.refz) < CAMath::Abs(b.refz));
+  }
+};
+
 } // namespace o2::gpu::internal
 
+using namespace o2::gpu::internal;
+
 #ifndef GPUCA_GPUCODE
 
 #include "GPUQA.h"
@@ -742,11 +809,11 @@ template <>
 GPUd() void GPUTPCGMMerger::MergeBorderTracks<3>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUTPCGMBorderRange* range, int32_t N, int32_t cmpMax)
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
-  if (iThread == 0) {
+  if (iThread == 0 && iBlock == 0) {
     if (cmpMax) {
-      GPUCommonAlgorithm::sortDeviceDynamic(range, range + N, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return GPUCA_DETERMINISTIC_CODE((a.fMax != b.fMax) ? (a.fMax < b.fMax) : (a.fId < b.fId), a.fMax < b.fMax); });
+      GPUCommonAlgorithm::sortDeviceDynamic(range, range + N, MergeBorderTracks_compMax());
     } else {
-      GPUCommonAlgorithm::sortDeviceDynamic(range, range + N, [](const GPUTPCGMBorderRange& a, const GPUTPCGMBorderRange& b) { return GPUCA_DETERMINISTIC_CODE((a.fMin != b.fMin) ? (a.fMin < b.fMin) : (a.fId < b.fId), a.fMin < b.fMin); });
+      GPUCommonAlgorithm::sortDeviceDynamic(range, range + N, MergeBorderTracks_compMin());
     }
   }
 #endif
@@ -1757,60 +1824,18 @@ GPUd() void GPUTPCGMMerger::PrepareClustersForFit0(int32_t nBlocks, int32_t nThr
 GPUd() void GPUTPCGMMerger::SortTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
-  if (iThread || iBlock) {
-    return;
+  if (iThread == 0 && iBlock == 0) {
+    GPUCommonAlgorithm::sortDeviceDynamic(mTrackOrderProcess, mTrackOrderProcess + mMemory->nMergedTracks, GPUTPCGMMergerSortTracks_comp(mOutputTracks));
   }
-  // TODO: Fix this: Have to duplicate sort comparison: Thrust cannot use the Lambda but OpenCL cannot use the object
-  auto comp = [cmp = mOutputTracks](const int32_t aa, const int32_t bb) {
-    const GPUTPCGMMergedTrack& GPUrestrict() a = cmp[aa];
-    const GPUTPCGMMergedTrack& GPUrestrict() b = cmp[bb];
-    if (a.CCE() != b.CCE()) {
-      return a.CCE() > b.CCE();
-    }
-    if (a.Legs() != b.Legs()) {
-      return a.Legs() > b.Legs();
-    }
-    GPUCA_DETERMINISTIC_CODE( // clang-format off
-      if (a.NClusters() != b.NClusters()) {
-        return a.NClusters() > b.NClusters();
-      } if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
-        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
-        return a.GetParam().GetY() > b.GetParam().GetY();
-      }
-      return aa > bb;
-    , // !GPUCA_DETERMINISTIC_CODE
-      return a.NClusters() > b.NClusters();
-    ) // clang-format on
-  };
-
-  GPUCommonAlgorithm::sortDeviceDynamic(mTrackOrderProcess, mTrackOrderProcess + mMemory->nMergedTracks, comp);
 #endif
 }
 
 GPUd() void GPUTPCGMMerger::SortTracksQPt(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
-  if (iThread || iBlock) {
-    return;
+  if (iThread == 0 && iBlock == 0) {
+    GPUCommonAlgorithm::sortDeviceDynamic(mTrackSort, mTrackSort + mMemory->nMergedTracks, GPUTPCGMMergerSortTracksQPt_comp(mOutputTracks));
   }
-  // TODO: Fix this: Have to duplicate sort comparison: Thrust cannot use the Lambda but OpenCL cannot use the object
-  auto comp = [cmp = mOutputTracks](const int32_t aa, const int32_t bb) {
-    const GPUTPCGMMergedTrack& GPUrestrict() a = cmp[aa];
-    const GPUTPCGMMergedTrack& GPUrestrict() b = cmp[bb];
-    GPUCA_DETERMINISTIC_CODE( // clang-format off
-      if (CAMath::Abs(a.GetParam().GetQPt()) != CAMath::Abs(b.GetParam().GetQPt())) {
-        return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-      } if (a.GetParam().GetY() != b.GetParam().GetY()) {
-        return a.GetParam().GetY() > b.GetParam().GetY();
-      }
-      return a.GetParam().GetZ() > b.GetParam().GetZ();
-    , // !GPUCA_DETERMINISTIC_CODE
-      return CAMath::Abs(a.GetParam().GetQPt()) > CAMath::Abs(b.GetParam().GetQPt());
-    ) // clang-format on
-  };
-
-  GPUCommonAlgorithm::sortDeviceDynamic(mTrackSort, mTrackSort + mMemory->nMergedTracks, comp);
 #endif
 }
 
@@ -1945,11 +1970,9 @@ GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads,
 GPUd() void GPUTPCGMMerger::MergeLoopersSort(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
-  if (iThread || iBlock) {
-    return;
+  if (iThread == 0 && iBlock == 0) {
+    GPUCommonAlgorithm::sortDeviceDynamic(mLooperCandidates, mLooperCandidates + mMemory->nLooperMatchCandidates, GPUTPCGMMergerMergeLoopers_comp());
   }
-  auto comp = [](const MergeLooperParam& a, const MergeLooperParam& b) { return GPUCA_DETERMINISTIC_CODE(CAMath::Abs(a.refz) != CAMath::Abs(b.refz) ? CAMath::Abs(a.refz) < CAMath::Abs(b.refz) : a.id < b.id, CAMath::Abs(a.refz) < CAMath::Abs(b.refz)); };
-  GPUCommonAlgorithm::sortDeviceDynamic(mLooperCandidates, mLooperCandidates + mMemory->nLooperMatchCandidates, comp);
 #endif
 }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 624c9ab487c8d..1e08058fb22dd 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -34,6 +34,18 @@ using namespace o2::tpc::constants;
 GPUdi() static constexpr uint8_t getFlagsReject() { return GPUTPCGMMergedTrackHit::flagReject | GPUTPCGMMergedTrackHit::flagNotFit; }
 GPUdi() static uint32_t getFlagsRequired(const GPUSettingsRec& rec) { return rec.tpc.dropSecondaryLegsInOutput ? gputpcgmmergertypes::attachGoodLeg : gputpcgmmergertypes::attachZero; }
 
+namespace o2::gpu::internal
+{
+
+struct GPUTPCGMO2OutputSort_comp {
+  GPUd() bool operator()(const GPUTPCGMMerger::tmpSort& a, const GPUTPCGMMerger::tmpSort& b)
+  {
+    return GPUCA_DETERMINISTIC_CODE(a.y != b.y ? a.y > b.y : a.x > b.x, a.y > b.y);
+  }
+};
+
+} // namespace o2::gpu::internal
+
 template <>
 GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
@@ -84,12 +96,10 @@ template <>
 GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::sort>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
-  if (iThread || iBlock) {
-    return;
+  if (iThread == 0 && iBlock == 0) {
+    GPUTPCGMMerger::tmpSort* GPUrestrict() trackSort = merger.TrackSortO2();
+    GPUCommonAlgorithm::sortDeviceDynamic(trackSort, trackSort + merger.Memory()->nO2Tracks, internal::GPUTPCGMO2OutputSort_comp());
   }
-  GPUTPCGMMerger::tmpSort* GPUrestrict() trackSort = merger.TrackSortO2();
-  auto comp = [](const auto& a, const auto& b) { return GPUCA_DETERMINISTIC_CODE(a.y != b.y ? a.y > b.y : a.x > b.x, a.y > b.y); };
-  GPUCommonAlgorithm::sortDeviceDynamic(trackSort, trackSort + merger.Memory()->nO2Tracks, comp);
 #endif
 }
 

From f75693ddbe0b19eb445da5a9d9972f73fdd86b96 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 11:04:35 +0200
Subject: [PATCH 0352/1764] GPU: Remove obsolete files used for tests in Run 2

---
 .../Merger/GPUTPCGMTracksToTPCSeeds.cxx       | 149 ------------------
 .../Merger/GPUTPCGMTracksToTPCSeeds.h         |  29 ----
 2 files changed, 178 deletions(-)
 delete mode 100644 GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.cxx
 delete mode 100644 GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.h

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.cxx
deleted file mode 100644
index ebc9d22560524..0000000000000
--- a/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.cxx
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCGMTracksToTPCSeeds.cxx
-/// \author David Rohr
-
-#include "GPUTPCGMTracksToTPCSeeds.h"
-#include "GPUTPCGlobalMergerComponent.h"
-#include "GPUTPCGMMergerTypes.h"
-#include "GPUTPCGMMerger.h"
-#include "GPULogging.h"
-#include "AliTPCtracker.h"
-#include "AliTPCtrack.h"
-#include "AliTPCseed.h"
-#include "AliTPCtrackerSector.h"
-#include "TObjArray.h"
-#include "AliTPCclusterMI.h"
-
-using namespace o2::gpu;
-
-void GPUTPCGMTracksToTPCSeeds::CreateSeedsFromHLTTracks(TObjArray* seeds, AliTPCtracker* tpctracker)
-{
-  const GPUTPCGMMerger* merger = GPUTPCGlobalMergerComponent::GetCurrentMerger();
-  if (merger == nullptr) {
-    return;
-  }
-  seeds->Clear();
-  int32_t index = 0;
-  for (int32_t i = 0; i < merger->NMergedTracks(); i++) {
-    const GPUTPCGMMergedTrack& track = merger->OutputTracks()[i];
-    if (!track.OK()) {
-      continue;
-    }
-
-    AliTPCtrack tr;
-    tr.Set(track.GetParam().GetX(), track.GetAlpha(), track.GetParam().GetPar(), track.GetParam().GetCov());
-    AliTPCseed* seed = new (tpctracker->NextFreeSeed()) AliTPCseed(tr);
-    for (int32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-      seed->SetClusterPointer(j, nullptr);
-      seed->SetClusterIndex(j, -1);
-    }
-    int32_t ncls = 0;
-    int32_t lastrow = -1;
-    int32_t lastleg = -1;
-    for (int32_t j = track.NClusters() - 1; j >= 0; j--) {
-      const GPUTPCGMMergedTrackHit& cls = merger->Clusters()[track.FirstClusterRef() + j];
-      if (cls.state & GPUTPCGMMergedTrackHit::flagReject) {
-        continue;
-      }
-      if (lastrow != -1 && (cls.row < lastrow || cls.leg != lastleg)) {
-        break;
-      }
-      if (cls.row == lastrow) {
-        continue;
-      }
-
-      AliTPCtrackerRow& row = tpctracker->GetRow(cls.sector % 18, cls.row);
-      uint32_t clIndexOffline = 0;
-      AliTPCclusterMI* clOffline = row.FindNearest2(cls.y, cls.z, 0.01f, 0.01f, clIndexOffline);
-      if (!clOffline) {
-        continue;
-      }
-      clIndexOffline = row.GetIndex(clIndexOffline);
-
-      clOffline->Use(10);
-      seed->SetClusterPointer(cls.row, clOffline);
-      seed->SetClusterIndex2(cls.row, clIndexOffline);
-
-      lastrow = cls.row;
-      lastleg = cls.leg;
-      ncls++;
-    }
-
-    seed->SetRelativeSector(track.GetAlpha() / (M_PI / 9.f));
-    seed->SetNumberOfClusters(ncls);
-    seed->SetNFoundable(ncls);
-    seed->SetChi2(track.GetParam().GetChi2());
-
-    float alpha = seed->GetAlpha();
-    if (alpha >= 2.f * M_PI) {
-      alpha -= 2.f * M_PI;
-    }
-    if (alpha < 0) {
-      alpha += 2.f * M_PI;
-    }
-    seed->SetRelativeSector(track.GetAlpha() / (M_PI / 9.f));
-
-    seed->SetPoolID(tpctracker->GetLastSeedId());
-    seed->SetIsSeeding(kTRUE);
-    seed->SetSeed1(GPUCA_ROW_COUNT - 1);
-    seed->SetSeed2(GPUCA_ROW_COUNT - 2);
-    seed->SetSeedType(0);
-    seed->SetFirstPoint(-1);
-    seed->SetLastPoint(-1);
-    seeds->AddLast(seed); // note, track is seed, don't free the seed
-    index++;
-  }
-}
-
-void GPUTPCGMTracksToTPCSeeds::UpdateParamsOuter(TObjArray* seeds)
-{
-  const GPUTPCGMMerger* merger = GPUTPCGlobalMergerComponent::GetCurrentMerger();
-  if (merger == nullptr) {
-    return;
-  }
-  int32_t index = 0;
-  for (int32_t i = 0; i < merger->NMergedTracks(); i++) {
-    const GPUTPCGMMergedTrack& track = merger->OutputTracks()[i];
-    if (!track.OK()) {
-      continue;
-    }
-    if (index > seeds->GetEntriesFast()) {
-      GPUError("Invalid number of offline seeds");
-      return;
-    }
-    AliTPCseed* seed = (AliTPCseed*)seeds->UncheckedAt(index++);
-    const gputpcgmmergertypes::GPUTPCOuterParam& param = track.OuterParam();
-    seed->Set(param.X, param.alpha, param.P, param.C);
-  }
-}
-
-void GPUTPCGMTracksToTPCSeeds::UpdateParamsInner(TObjArray* seeds)
-{
-  const GPUTPCGMMerger* merger = GPUTPCGlobalMergerComponent::GetCurrentMerger();
-  if (merger == nullptr) {
-    return;
-  }
-  int32_t index = 0;
-  for (int32_t i = 0; i < merger->NMergedTracks(); i++) {
-    const GPUTPCGMMergedTrack& track = merger->OutputTracks()[i];
-    if (!track.OK()) {
-      continue;
-    }
-    if (index > seeds->GetEntriesFast()) {
-      GPUError("Invalid number of offline seeds");
-      return;
-    }
-    AliTPCseed* seed = (AliTPCseed*)seeds->UncheckedAt(index++);
-    seed->Set(track.GetParam().GetX(), track.GetAlpha(), track.GetParam().GetPar(), track.GetParam().GetCov());
-  }
-}
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.h b/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.h
deleted file mode 100644
index 029cb108d4119..0000000000000
--- a/GPU/GPUTracking/Merger/GPUTPCGMTracksToTPCSeeds.h
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCGMTracksToTPCSeeds.h
-/// \author David Rohr
-
-#ifndef GPUTPCGMTRACKSTOTPCSEEDS_H
-#define GPUTPCGMTRACKSTOTPCSEEDS_H
-
-class TObjArray;
-class AliTPCtracker;
-
-class GPUTPCGMTracksToTPCSeeds
-{
- public:
-  static void CreateSeedsFromHLTTracks(TObjArray* seeds, AliTPCtracker* tpctracker);
-  static void UpdateParamsOuter(TObjArray* seeds);
-  static void UpdateParamsInner(TObjArray* seeds);
-};
-
-#endif

From 747fb860184729b2d219e7b0a044d09e15c7a1b5 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 11:04:56 +0200
Subject: [PATCH 0353/1764] GPU TPC: Some more member variable renaming

---
 ...GPUReconstructionCUDAKernelsSpecialize.inc |  4 +-
 .../Global/GPUChainTrackingMerger.cxx         |  8 ++--
 .../Global/GPUChainTrackingRefit.cxx          |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 38 +++++++++----------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       | 18 ++++-----
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx | 14 +++----
 GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx  |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   | 10 ++---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 12 +++---
 .../Merger/GPUTPCGlobalDebugSortKernels.cxx   | 10 ++---
 10 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
index 44cde3d4ac48a..85567d70d70d6 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernelsSpecialize.inc
@@ -27,13 +27,13 @@ inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed
 template <>
 inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerSortTracks, 0>(const krnlSetupTime& _xyz)
 {
-  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NMergedTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackOrderProcess(), processors()->tpcMerger.NMergedTracks(), GPUTPCGMMergerSortTracks_comp(mProcessorsShadow->tpcMerger.MergedTracks()));
 }
 
 template <>
 inline void GPUCA_M_CAT(GPUReconstruction, GPUCA_GPUTYPE)::runKernelBackendTimed<GPUTPCGMMergerSortTracksQPt, 0>(const krnlSetupTime& _xyz)
 {
-  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NMergedTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.OutputTracks()));
+  GPUCommonAlgorithm::sortOnDevice(this, _xyz.x.stream, mProcessorsShadow->tpcMerger.TrackSort(), processors()->tpcMerger.NMergedTracks(), GPUTPCGMMergerSortTracksQPt_comp(mProcessorsShadow->tpcMerger.MergedTracks()));
 }
 
 template <>
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index df80eabfb8761..2b3d719a27dea 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -256,10 +256,10 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
           throw std::runtime_error("QA Scratch buffer exceeded");
         }
       }
-      GPUMemCpy(RecoStep::TPCMerging, Merger.OutputTracks(), MergerShadowAll.OutputTracks(), Merger.NMergedTracks() * sizeof(*Merger.OutputTracks()), outputStream, 0, nullptr, waitEvent);
+      GPUMemCpy(RecoStep::TPCMerging, Merger.MergedTracks(), MergerShadowAll.MergedTracks(), Merger.NMergedTracks() * sizeof(*Merger.MergedTracks()), outputStream, 0, nullptr, waitEvent);
       waitEvent = nullptr;
       if (param().dodEdxEnabled) {
-        GPUMemCpy(RecoStep::TPCMerging, Merger.OutputTracksdEdx(), MergerShadowAll.OutputTracksdEdx(), Merger.NMergedTracks() * sizeof(*Merger.OutputTracksdEdx()), outputStream, 0);
+        GPUMemCpy(RecoStep::TPCMerging, Merger.MergedTracksdEdx(), MergerShadowAll.MergedTracksdEdx(), Merger.NMergedTracks() * sizeof(*Merger.MergedTracksdEdx()), outputStream, 0);
       }
       GPUMemCpy(RecoStep::TPCMerging, Merger.Clusters(), MergerShadowAll.Clusters(), Merger.NOutputTrackClusters() * sizeof(*Merger.Clusters()), outputStream, 0);
       if (param().par.earlyTpcTransform) {
@@ -326,7 +326,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     mRec->ReturnVolatileDeviceMemory();
   }
 
-  mIOPtrs.mergedTracks = Merger.OutputTracks();
+  mIOPtrs.mergedTracks = Merger.MergedTracks();
   mIOPtrs.nMergedTracks = Merger.NMergedTracks();
   mIOPtrs.mergedTrackHits = Merger.Clusters();
   mIOPtrs.mergedTrackHitsXYZ = Merger.ClustersXYZ();
@@ -340,7 +340,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   mIOPtrs.outputTracksTPCO2MC = Merger.OutputTracksTPCO2MC();
 
   if (doGPU) {
-    processorsShadow()->ioPtrs.mergedTracks = MergerShadow.OutputTracks();
+    processorsShadow()->ioPtrs.mergedTracks = MergerShadow.MergedTracks();
     processorsShadow()->ioPtrs.nMergedTracks = Merger.NMergedTracks();
     processorsShadow()->ioPtrs.mergedTrackHits = MergerShadow.Clusters();
     processorsShadow()->ioPtrs.mergedTrackHitsXYZ = MergerShadow.ClustersXYZ();
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx b/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
index 4662b5464f710..5ca20a39d0462 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
@@ -33,7 +33,7 @@ int32_t GPUChainTracking::RunRefit()
   SetupGPUProcessor(&Refit, false);
   RefitShadow.SetPtrsFromGPUConstantMem(processorsShadow(), doGPU ? &processorsDevice()->param : nullptr);
   RefitShadow.SetPropagator(doGPU ? processorsShadow()->calibObjects.o2Propagator : GetO2Propagator());
-  RefitShadow.mPTracks = (doGPU ? processorsShadow() : processors())->tpcMerger.OutputTracks();
+  RefitShadow.mPTracks = (doGPU ? processorsShadow() : processors())->tpcMerger.MergedTracks();
   WriteToConstantMemory(RecoStep::Refit, (char*)&processors()->trackingRefit - (char*)processors(), &RefitShadow, sizeof(RefitShadow), 0);
   // TransferMemoryResourcesToGPU(RecoStep::Refit, &Refit, 0);
   if (param().rec.trackingRefitGPUModel) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index b12375a10023a..f1a0816529c3a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -365,11 +365,11 @@ void* GPUTPCGMMerger::SetPointersRefitScratch(void* mem)
 
 void* GPUTPCGMMerger::SetPointersOutput(void* mem)
 {
-  computePointerWithAlignment(mem, mOutputTracks, mNMaxTracks);
+  computePointerWithAlignment(mem, mMergedTracks, mNMaxTracks);
   if (mRec->GetParam().dodEdxEnabled) {
-    computePointerWithAlignment(mem, mOutputTracksdEdx, mNMaxTracks);
+    computePointerWithAlignment(mem, mMergedTracksdEdx, mNMaxTracks);
     if (mRec->GetParam().rec.tpc.dEdxClusterRejectionFlagMask != mRec->GetParam().rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
-      computePointerWithAlignment(mem, mOutputTracksdEdxAlt, mNMaxTracks);
+      computePointerWithAlignment(mem, mMergedTracksdEdxAlt, mNMaxTracks);
     }
   }
   computePointerWithAlignment(mem, mClusters, mNMaxOutputTrackClusters);
@@ -1318,7 +1318,7 @@ GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const
     const float x0 = GPUTPCGeometry::Row2X(attempt == 0 ? 63 : cls.row);
     if (track->TransportToX(this, x0, Param().bzCLight, b, GPUCA_MAX_SIN_PHI_LOW)) {
       b.SetTrackID(itr);
-      b.SetNClusters(mOutputTracks[itr].NClusters());
+      b.SetNClusters(mMergedTracks[itr].NClusters());
       if (CAMath::Abs(b.Cov()[4]) >= 0.5f) {
         b.SetCov(4, 0.5f); // TODO: Is this needed and better than the cut in BorderTrack?
       }
@@ -1339,11 +1339,11 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
 {
   const ClusterNative* cls = Param().par.earlyTpcTransform ? nullptr : mConstantMem->ioPtrs.clustersNative->clustersLinear;
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nThreads * nBlocks) {
-    if (mOutputTracks[i].CSide() == 0 && mTrackLinks[i] >= 0) {
+    if (mMergedTracks[i].CSide() == 0 && mTrackLinks[i] >= 0) {
       if (mTrackLinks[mTrackLinks[i]] != (int32_t)i) {
         continue;
       }
-      GPUTPCGMMergedTrack* trk[2] = {&mOutputTracks[i], &mOutputTracks[mTrackLinks[i]]};
+      GPUTPCGMMergedTrack* trk[2] = {&mMergedTracks[i], &mMergedTracks[mTrackLinks[i]]};
 
       if (!trk[1]->OK() || trk[1]->CCE()) {
         continue;
@@ -1459,7 +1459,7 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
     }
   }
 
-  // for (int32_t i = 0;i < mMemory->nMergedTracks;i++) {if (mOutputTracks[i].CCE() == false) {mOutputTracks[i].SetNClusters(0);mOutputTracks[i].SetOK(false);}} //Remove all non-CE tracks
+  // for (int32_t i = 0;i < mMemory->nMergedTracks;i++) {if (mMergedTracks[i].CCE() == false) {mMergedTracks[i].SetNClusters(0);mMergedTracks[i].SetOK(false);}} //Remove all non-CE tracks
 }
 
 namespace o2::gpu::internal
@@ -1752,7 +1752,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       continue;
     }
 
-    GPUTPCGMMergedTrack& mergedTrack = mOutputTracks[iOutputTrack];
+    GPUTPCGMMergedTrack& mergedTrack = mMergedTracks[iOutputTrack];
 
     mergedTrack.SetFlags(0);
     mergedTrack.SetOK(1);
@@ -1825,7 +1825,7 @@ GPUd() void GPUTPCGMMerger::SortTracks(int32_t nBlocks, int32_t nThreads, int32_
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
   if (iThread == 0 && iBlock == 0) {
-    GPUCommonAlgorithm::sortDeviceDynamic(mTrackOrderProcess, mTrackOrderProcess + mMemory->nMergedTracks, GPUTPCGMMergerSortTracks_comp(mOutputTracks));
+    GPUCommonAlgorithm::sortDeviceDynamic(mTrackOrderProcess, mTrackOrderProcess + mMemory->nMergedTracks, GPUTPCGMMergerSortTracks_comp(mMergedTracks));
   }
 #endif
 }
@@ -1834,7 +1834,7 @@ GPUd() void GPUTPCGMMerger::SortTracksQPt(int32_t nBlocks, int32_t nThreads, int
 {
 #ifndef GPUCA_SPECIALIZE_THRUST_SORTS
   if (iThread == 0 && iBlock == 0) {
-    GPUCommonAlgorithm::sortDeviceDynamic(mTrackSort, mTrackSort + mMemory->nMergedTracks, GPUTPCGMMergerSortTracksQPt_comp(mOutputTracks));
+    GPUCommonAlgorithm::sortDeviceDynamic(mTrackSort, mTrackSort + mMemory->nMergedTracks, GPUTPCGMMergerSortTracksQPt_comp(mMergedTracks));
   }
 #endif
 }
@@ -1843,7 +1843,7 @@ GPUd() void GPUTPCGMMerger::PrepareClustersForFit1(int32_t nBlocks, int32_t nThr
 {
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nBlocks * nThreads) {
     mTrackOrderAttach[mTrackSort[i]] = i;
-    const GPUTPCGMMergedTrack& trk = mOutputTracks[i];
+    const GPUTPCGMMergedTrack& trk = mMergedTracks[i];
     if (trk.OK()) {
       for (uint32_t j = 0; j < trk.NClusters(); j++) {
         mClusterAttachment[mClusters[trk.FirstClusterRef() + j].num] = attachAttached | attachGood;
@@ -1884,7 +1884,7 @@ GPUd() void GPUTPCGMMerger::Finalize0(int32_t nBlocks, int32_t nThreads, int32_t
 GPUd() void GPUTPCGMMerger::Finalize1(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nThreads * nBlocks) {
-    const GPUTPCGMMergedTrack& trk = mOutputTracks[i];
+    const GPUTPCGMMergedTrack& trk = mMergedTracks[i];
     if (!trk.OK() || trk.NClusters() == 0) {
       continue;
     }
@@ -1919,7 +1919,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads,
 {
   const float lowPtThresh = Param().rec.tpc.rejectQPtB5 * 1.1f; // Might need to merge tracks above the threshold with parts below the threshold
   for (uint32_t i = get_global_id(0); i < mMemory->nMergedTracks; i += get_global_size(0)) {
-    const auto& trk = mOutputTracks[i];
+    const auto& trk = mMergedTracks[i];
     const auto& p = trk.GetParam();
     const float qptabs = CAMath::Abs(p.GetQPt());
     if (trk.NClusters() && qptabs * Param().qptB5Scaler > 5.f && qptabs * Param().qptB5Scaler <= lowPtThresh) {
@@ -1983,7 +1983,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
 #if GPUCA_MERGE_LOOPER_MC && !defined(GPUCA_GPUCODE)
   std::vector<int64_t> paramLabels(mMemory->nLooperMatchCandidates);
   for (uint32_t i = 0; i < mMemory->nLooperMatchCandidates; i++) {
-    paramLabels[i] = GetTrackLabel(mOutputTracks[params[i].id]);
+    paramLabels[i] = GetTrackLabel(mMergedTracks[params[i].id]);
   }
   /*std::vector<bool> dropped(mMemory->nLooperMatchCandidates);
   std::vector<bool> droppedMC(mMemory->nLooperMatchCandidates);
@@ -2005,8 +2005,8 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
         // bs |= 1;
         continue;
       }
-      const auto& trk1 = mOutputTracks[params[i].id];
-      const auto& trk2 = mOutputTracks[params[j].id];
+      const auto& trk1 = mMergedTracks[params[i].id];
+      const auto& trk2 = mMergedTracks[params[j].id];
       const auto& param1 = trk1.GetParam();
       const auto& param2 = trk2.GetParam();
       if (CAMath::Abs(param1.GetDzDs()) > 0.03f && CAMath::Abs(param2.GetDzDs()) > 0.03f && param1.GetDzDs() * param2.GetDzDs() * param1.GetQPt() * param2.GetQPt() < 0) {
@@ -2045,7 +2045,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
       const int64_t label2 = paramLabels[j];
       bool labelEQ = label1 != -1 && label1 == label2;
       if (1 || EQ || labelEQ) {
-        // printf("Matching track %d/%d %u-%u (%ld/%ld): dist %f side %d %d, tgl %f %f, qpt %f %f, x %f %f, y %f %f\n", (int32_t)EQ, (int32_t)labelEQ, i, j, label1, label2, d, (int32_t)mOutputTracks[params[i].id].CSide(), (int32_t)mOutputTracks[params[j].id].CSide(), params[i].tgl, params[j].tgl, params[i].qpt, params[j].qpt, params[i].x, params[j].x, params[i].y, params[j].y);
+        // printf("Matching track %d/%d %u-%u (%ld/%ld): dist %f side %d %d, tgl %f %f, qpt %f %f, x %f %f, y %f %f\n", (int32_t)EQ, (int32_t)labelEQ, i, j, label1, label2, d, (int32_t)mMergedTracks[params[i].id].CSide(), (int32_t)mMergedTracks[params[j].id].CSide(), params[i].tgl, params[j].tgl, params[i].qpt, params[j].qpt, params[i].x, params[j].x, params[i].y, params[j].y);
         static auto& tup = GPUROOTDump<TNtuple>::get("mergeloopers", "labeleq:sides:d2xy:tgl1:tgl2:qpt1:qpt2:dz:dzcorr:dtgl:dqpt:dznorm:bs");
         tup.Fill((float)labelEQ, (trk1.CSide() ? 1 : 0) | (trk2.CSide() ? 2 : 0), d2xy, param1.GetDzDs(), param2.GetDzDs(), param1.GetQPt(), param2.GetQPt(), CAMath::Abs(params[j].refz) - CAMath::Abs(params[i].refz), dzcorr, dtgl, dqpt, dznorm, bs);
         static auto tup2 = GPUROOTDump<TNtuple>::getNew("mergeloopers2", "labeleq:refz1:refz2:tgl1:tgl2:qpt1:qpt2:snp1:snp2:a1:a2:dzn:phasecor:phasedir:dzcorr");
@@ -2063,9 +2063,9 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
     }*/
 #endif
       if (EQ) {
-        mOutputTracks[params[j].id].SetMergedLooper(true);
+        mMergedTracks[params[j].id].SetMergedLooper(true);
         if (CAMath::Abs(param2.GetQPt() * Param().qptB5Scaler) >= Param().rec.tpc.rejectQPtB5) {
-          mOutputTracks[params[i].id].SetMergedLooper(true);
+          mMergedTracks[params[i].id].SetMergedLooper(true);
         }
       }
     }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index ae85f20b17b48..4487b6d937dc2 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -104,12 +104,12 @@ class GPUTPCGMMerger : public GPUProcessor
   void* SetPointersMemory(void* mem);
 
   GPUhdi() int32_t NMergedTracks() const { return mMemory->nMergedTracks; }
-  GPUhdi() const GPUTPCGMMergedTrack* OutputTracks() const { return mOutputTracks; }
-  GPUhdi() GPUTPCGMMergedTrack* OutputTracks() { return mOutputTracks; }
-  GPUhdi() const GPUdEdxInfo* OutputTracksdEdx() const { return mOutputTracksdEdx; }
-  GPUhdi() GPUdEdxInfo* OutputTracksdEdx() { return mOutputTracksdEdx; }
-  GPUhdi() const GPUdEdxInfo* OutputTracksdEdxAlt() const { return mOutputTracksdEdxAlt; }
-  GPUhdi() GPUdEdxInfo* OutputTracksdEdxAlt() { return mOutputTracksdEdxAlt; }
+  GPUhdi() const GPUTPCGMMergedTrack* MergedTracks() const { return mMergedTracks; }
+  GPUhdi() GPUTPCGMMergedTrack* MergedTracks() { return mMergedTracks; }
+  GPUhdi() const GPUdEdxInfo* MergedTracksdEdx() const { return mMergedTracksdEdx; }
+  GPUhdi() GPUdEdxInfo* MergedTracksdEdx() { return mMergedTracksdEdx; }
+  GPUhdi() const GPUdEdxInfo* MergedTracksdEdxAlt() const { return mMergedTracksdEdxAlt; }
+  GPUhdi() GPUdEdxInfo* MergedTracksdEdxAlt() { return mMergedTracksdEdxAlt; }
   GPUhdi() uint32_t NClusters() const { return mNClusters; }
   GPUhdi() uint32_t NMaxClusters() const { return mNMaxClusters; }
   GPUhdi() uint32_t NMaxTracks() const { return mNMaxTracks; }
@@ -262,9 +262,9 @@ class GPUTPCGMMerger : public GPUProcessor
   uint16_t mMemoryResOutputO2Scratch = (uint16_t)-1;
 
   int32_t mNClusters = 0;                           // Total number of incoming clusters (from sector tracks)
-  GPUTPCGMMergedTrack* mOutputTracks = nullptr;     //* array of output merged tracks
-  GPUdEdxInfo* mOutputTracksdEdx = nullptr;         //* dEdx information
-  GPUdEdxInfo* mOutputTracksdEdxAlt = nullptr;      //* dEdx alternative information
+  GPUTPCGMMergedTrack* mMergedTracks = nullptr;     //* array of output merged tracks
+  GPUdEdxInfo* mMergedTracksdEdx = nullptr;         //* dEdx information
+  GPUdEdxInfo* mMergedTracksdEdxAlt = nullptr;      //* dEdx alternative information
   GPUTPCGMSectorTrack* mSectorTrackInfos = nullptr; //* additional information for sector tracks
   int32_t* mSectorTrackInfoIndex = nullptr;
   GPUTPCGMMergedTrackHit* mClusters = nullptr;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 3be32a2d87610..9c924e74ec519 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -139,7 +139,7 @@ void GPUTPCGMMerger::DumpCollected(std::ostream& out) const
   out << std::setprecision(2);
   out << "\nTPC Merger Collected Tracks\n";
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
-    const auto& trk = mOutputTracks[i];
+    const auto& trk = mMergedTracks[i];
     const auto& p = trk.GetParam();
     out << "  Track " << i << ": Loop " << trk.Looper() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTZOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << "\n";
   }
@@ -151,7 +151,7 @@ void GPUTPCGMMerger::DumpMergeCE(std::ostream& out) const
   DumpTrackLinks(out, true, " for CE merging");
   out << "\nTPC Merger Merge CE\n";
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
-    const auto& trk = mOutputTracks[i];
+    const auto& trk = mMergedTracks[i];
     if (trk.CCE()) {
       out << "  Track " << i << ": CCE\n";
     }
@@ -167,7 +167,7 @@ void GPUTPCGMMerger::DumpFitPrepare(std::ostream& out) const
   }
   out << "  Clusters\n";
   for (uint32_t j = 0; j < mMemory->nMergedTracks; j++) {
-    const auto& trk = mOutputTracks[j];
+    const auto& trk = mMergedTracks[j];
     out << "  Track " << j << ": ";
     for (uint32_t i = trk.FirstClusterRef(); i < trk.FirstClusterRef() + trk.NClusters(); i++) {
       out << j << "/" << (i - trk.FirstClusterRef()) << ": " << mClusters[i].num << "/" << (int32_t)mClusters[i].state << ", ";
@@ -196,14 +196,14 @@ void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
   out << std::setprecision(2);
   out << "\nTPC Merger Refit\n";
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
-    const auto& trk = mOutputTracks[i];
+    const auto& trk = mMergedTracks[i];
     if (trk.NClusters() == 0) {
       continue;
     }
     const auto& p = trk.GetParam();
     const auto& po = trk.OuterParam();
     out << "  Track " << i << ": OK " << trk.OK() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTZOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << " / " << trk.NClustersFitted() << " Cov " << p.GetErr2Y() << "/" << p.GetErr2Z()
-        << " dEdx " << (trk.OK() && Param().dodEdxEnabled ? mOutputTracksdEdx[i].dEdxTotTPC : -1.f) << "/" << (trk.OK() && Param().dodEdxEnabled ? mOutputTracksdEdx[i].dEdxMaxTPC : -1.f)
+        << " dEdx " << (trk.OK() && Param().dodEdxEnabled ? mMergedTracksdEdx[i].dEdxTotTPC : -1.f) << "/" << (trk.OK() && Param().dodEdxEnabled ? mMergedTracksdEdx[i].dEdxMaxTPC : -1.f)
         << " Outer " << po.P[0] << "/" << po.P[1] << "/" << po.P[2] << "/" << po.P[3] << "/" << po.P[4]
         << " NFitted " << trk.NClustersFitted() << " legs " << (int)trk.Legs() << " flags " << (int)trk.Flags() << "\n";
   }
@@ -217,7 +217,7 @@ void GPUTPCGMMerger::DumpLoopers(std::ostream& out) const
     if (i && i % 100 == 0) {
       out << "\n";
     }
-    out << (int)mOutputTracks[i].MergedLooper() << " ";
+    out << (int)mMergedTracks[i].MergedLooper() << " ";
   }
   out << "\n";
 }
@@ -226,7 +226,7 @@ void GPUTPCGMMerger::DumpFinal(std::ostream& out) const
 {
   out << "\nTPC Merger Finalized\n";
   for (uint32_t j = 0; j < mMemory->nMergedTracks; j++) {
-    const auto& trk = mOutputTracks[j];
+    const auto& trk = mMergedTracks[j];
     if (trk.NClusters() == 0) {
       continue;
     }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
index 68763b3549547..1631777d80482 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
@@ -24,7 +24,7 @@ GPUdii() void GPUTPCGMMergerTrackFit::Thread<0>(int32_t nBlocks, int32_t nThread
   const int32_t iEnd = mode == -1 ? merger.Memory()->nRetryRefit : merger.NMergedTracks();
   GPUCA_TBB_KERNEL_LOOP(merger.GetRec(), int32_t, ii, iEnd, {
     const int32_t i = mode == -1 ? merger.RetryRefitIds()[ii] : mode ? merger.TrackOrderProcess()[ii] : ii;
-    GPUTPCGMTrackParam::RefitTrack(merger.OutputTracks()[i], i, &merger, mode == -1);
+    GPUTPCGMTrackParam::RefitTrack(merger.MergedTracks()[i], i, &merger, mode == -1);
   });
 }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 1e08058fb22dd..eb22ca49e9242 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -49,10 +49,10 @@ struct GPUTPCGMO2OutputSort_comp {
 template <>
 GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
-  const GPUTPCGMMergedTrack* tracks = merger.OutputTracks();
+  const GPUTPCGMMergedTrack* tracks = merger.MergedTracks();
   const uint32_t nTracks = merger.NMergedTracks();
   const GPUTPCGMMergedTrackHit* trackClusters = merger.Clusters();
-  const GPUdEdxInfo* tracksdEdx = merger.OutputTracksdEdx();
+  const GPUdEdxInfo* tracksdEdx = merger.MergedTracksdEdx();
 
   constexpr uint8_t flagsReject = getFlagsReject();
   const uint32_t flagsRequired = getFlagsRequired(merger.Param().rec);
@@ -107,9 +107,9 @@ template <>
 GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
   constexpr float MinDelta = 0.1f;
-  const GPUTPCGMMergedTrack* tracks = merger.OutputTracks();
-  GPUdEdxInfo* tracksdEdx = merger.OutputTracksdEdx();
-  GPUdEdxInfo* tracksdEdxAlt = merger.OutputTracksdEdxAlt();
+  const GPUTPCGMMergedTrack* tracks = merger.MergedTracks();
+  GPUdEdxInfo* tracksdEdx = merger.MergedTracksdEdx();
+  GPUdEdxInfo* tracksdEdxAlt = merger.MergedTracksdEdxAlt();
   const int32_t nTracks = merger.NOutputTracksTPCO2();
   const GPUTPCGMMergedTrackHit* trackClusters = merger.Clusters();
   constexpr uint8_t flagsReject = getFlagsReject();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 366f75cb05e56..4b616fce83f5f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -94,10 +94,10 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       storeOuter = 0;
       if (iWay == nWays - 1) {
         StoreOuter(outerParam, prop, 0);
-        if (merger->OutputTracks()[iTrk].Looper()) {
+        if (merger->MergedTracks()[iTrk].Looper()) {
           storeOuter = 1;
         }
-      } else if (iWay == nWays - 2 && merger->OutputTracks()[iTrk].Looper()) {
+      } else if (iWay == nWays - 2 && merger->MergedTracks()[iTrk].Looper()) {
         storeOuter = 2;
       }
     }
@@ -435,9 +435,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
   // TODO: we have looping tracks here with 0 accepted clusters in the primary leg. In that case we should refit the track using only the primary leg.
 
   if (param.par.dodEdx && param.dodEdxEnabled) {
-    dEdx.computedEdx(merger->OutputTracksdEdx()[iTrk], param);
+    dEdx.computedEdx(merger->MergedTracksdEdx()[iTrk], param);
     if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
-      dEdxAlt.computedEdx(merger->OutputTracksdEdxAlt()[iTrk], param);
+      dEdxAlt.computedEdx(merger->MergedTracksdEdxAlt()[iTrk], param);
     }
   }
   Alpha = prop.GetAlpha();
@@ -596,7 +596,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
     return -1e6f;
   }
 
-  const float zOffset = Merger->Param().par.earlyTpcTransform ? ((Merger->OutputTracks()[iTrack].CSide() ^ (sector >= 18)) ? -mTZOffset : mTZOffset) : Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTZOffset, Merger->Param().continuousMaxTimeBin);
+  const float zOffset = Merger->Param().par.earlyTpcTransform ? ((Merger->MergedTracks()[iTrack].CSide() ^ (sector >= 18)) ? -mTZOffset : mTZOffset) : Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTZOffset, Merger->Param().continuousMaxTimeBin);
   const float y0 = row.Grid().YMin();
   const float stepY = row.HstepY();
   const float z0 = row.Grid().ZMin() - zOffset; // We can use our own ZOffset, since this is only used temporarily anyway
@@ -1136,7 +1136,7 @@ GPUd() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict() tr
     t.QPt() = 1.e-4f;
   }
 
-  CADEBUG(if (t.GetX() > 250) { printf("ERROR, Track %d at impossible X %f, Pt %f, Looper %d\n", iTrk, t.GetX(), CAMath::Abs(1.f / t.QPt()), (int32_t)merger->OutputTracks()[iTrk].Looper()); });
+  CADEBUG(if (t.GetX() > 250) { printf("ERROR, Track %d at impossible X %f, Pt %f, Looper %d\n", iTrk, t.GetX(), CAMath::Abs(1.f / t.QPt()), (int32_t)merger->MergedTracks()[iTrk].Looper()); });
 
   track.SetOK(ok);
   track.SetNClustersFitted(nTrackHits);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
index e63bb82a9b09e..5af3ebb51b9d6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
@@ -105,8 +105,8 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
     tmp[j] = j;
   }
   GPUCommonAlgorithm::sortDeviceDynamic(tmp, tmp + n, [&merger](const int32_t& aa, const int32_t& bb) {
-    const GPUTPCGMMergedTrack& a = merger.OutputTracks()[aa];
-    const GPUTPCGMMergedTrack& b = merger.OutputTracks()[bb];
+    const GPUTPCGMMergedTrack& a = merger.MergedTracks()[aa];
+    const GPUTPCGMMergedTrack& b = merger.MergedTracks()[bb];
     return (a.GetAlpha() != b.GetAlpha()) ? (a.GetAlpha() < b.GetAlpha()) : (a.GetParam().GetX() != b.GetParam().GetX()) ? (a.GetParam().GetX() < b.GetParam().GetX()) : (a.GetParam().GetY() != b.GetParam().GetY()) ? (a.GetParam().GetY() < b.GetParam().GetY()) : (a.GetParam().GetZ() < b.GetParam().GetZ());
   });
 }
@@ -126,19 +126,19 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
         tmp2[j] = j;
       } else if (tmp[j] >= 0) {
         int32_t firstIdx = j;
-        auto firstItem = merger.OutputTracks()[firstIdx];
+        auto firstItem = merger.MergedTracks()[firstIdx];
         int32_t currIdx = firstIdx;
         int32_t sourceIdx = tmp[currIdx];
         tmp2[sourceIdx] = currIdx;
         do {
           tmp[currIdx] = -1;
-          merger.OutputTracks()[currIdx] = merger.OutputTracks()[sourceIdx];
+          merger.MergedTracks()[currIdx] = merger.MergedTracks()[sourceIdx];
           currIdx = sourceIdx;
           sourceIdx = tmp[currIdx];
           tmp2[sourceIdx] = currIdx;
         } while (sourceIdx != firstIdx);
         tmp[currIdx] = -1;
-        merger.OutputTracks()[currIdx] = firstItem;
+        merger.MergedTracks()[currIdx] = firstItem;
       }
     }
   }

From b0414adf124ee153273fd9fefc7080690119eb89 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 13 May 2025 23:00:50 +0200
Subject: [PATCH 0354/1764] Out of line FairTBuffer destructor (#14265)

---
 Framework/Core/include/Framework/TMessageSerializer.h | 3 +++
 Framework/Core/src/TMessageSerializer.cxx             | 3 +++
 2 files changed, 6 insertions(+)

diff --git a/Framework/Core/include/Framework/TMessageSerializer.h b/Framework/Core/include/Framework/TMessageSerializer.h
index 769d23a7a3427..b6e355638c1e3 100644
--- a/Framework/Core/include/Framework/TMessageSerializer.h
+++ b/Framework/Core/include/Framework/TMessageSerializer.h
@@ -40,6 +40,8 @@ class FairOutputTBuffer : public TBufferFile
     : TBufferFile(TBuffer::kWrite, msg.GetSize() - sizeof(char*), embedInItself(msg), false, fairMQrealloc)
   {
   }
+
+  ~FairOutputTBuffer() override;
   // Helper function to keep track of the FairMQ message that holds the data
   // in the data itself. We can use this to make sure the message can be reallocated
   // even if we simply have a pointer to the data. Hopefully ROOT will not play dirty
@@ -60,6 +62,7 @@ class FairInputTBuffer : public TBufferFile
     : TBufferFile(TBuffer::kRead, size - sizeof(char*), data + sizeof(char*), false, nullptr)
   {
   }
+  ~FairInputTBuffer() override;
 };
 
 struct TMessageSerializer {
diff --git a/Framework/Core/src/TMessageSerializer.cxx b/Framework/Core/src/TMessageSerializer.cxx
index c5da4cc576242..81a1c6e537d09 100644
--- a/Framework/Core/src/TMessageSerializer.cxx
+++ b/Framework/Core/src/TMessageSerializer.cxx
@@ -15,6 +15,9 @@
 
 using namespace o2::framework;
 
+FairOutputTBuffer::~FairOutputTBuffer() = default;
+FairInputTBuffer::~FairInputTBuffer() = default;
+
 void* FairOutputTBuffer::embedInItself(fair::mq::Message& msg)
 {
   // The first bytes of the message are used to store the pointer to the message itself

From f4a478c778dc6b2672f71096f7915c10d18543d2 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 13 May 2025 23:02:37 +0200
Subject: [PATCH 0355/1764] DPL: keep codechecker happy (#14270)

---
 Detectors/CTP/reconstruction/src/RawDataDecoder.cxx | 6 ++++--
 Detectors/CTP/workflow/src/RawDecoderSpec.cxx       | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
index 74bd08ce943ee..b216f5ec54570 100644
--- a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
+++ b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
@@ -615,8 +615,9 @@ int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits,
           continue;
         }
         mClassCountersA[i]++;
-        if (cls->descriptor == nullptr)
+        if (cls->descriptor == nullptr) {
           continue;
+        }
         uint64_t clsinpmask = cls->descriptor->getInputsMask();
         uint64_t diginpmask = digit.CTPInputMask.to_ullong();
         if (!((clsinpmask & diginpmask) == clsinpmask)) {
@@ -632,8 +633,9 @@ int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits,
     // if inps => class mask
     for (auto const& cls : mCTPConfig.getCTPClasses()) {
       // cls.printStream(std::cout);
-      if (cls.descriptor == nullptr)
+      if (cls.descriptor == nullptr) {
         continue;
+      }
       uint64_t clsinpmask = cls.descriptor->getInputsMask(); // class definition
       uint64_t diginpmask = digit.CTPInputMask.to_ullong();
       uint64_t digclsmask = digit.CTPClassMask.to_ullong();
diff --git a/Detectors/CTP/workflow/src/RawDecoderSpec.cxx b/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
index 3f7c729b351a3..2df6bc981ce44 100644
--- a/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
+++ b/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
@@ -71,8 +71,9 @@ void RawDecoderSpec::endOfStream(framework::EndOfStreamContext& ec)
   std::cout << std::endl;
   LOG(info) << " Lost due to the shift:" << mDecoder.getLostDueToShift();
   LOG(info) << "Number of missing TF:" << nmiss << std::endl;
-  if (mDecoder.getErrorIR() || mDecoder.getErrorTCR())
+  if (mDecoder.getErrorIR() || mDecoder.getErrorTCR()) {
     LOG(error) << "# of IR errors:" << mDecoder.getErrorIR() << " TCR errors:" << mDecoder.getErrorTCR() << std::endl;
+  }
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsA = mDecoder.getClassCountersA();
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsB = mDecoder.getClassCountersB();
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsEA = mDecoder.getClassErrorsA();
@@ -80,8 +81,9 @@ void RawDecoderSpec::endOfStream(framework::EndOfStreamContext& ec)
 
   for (int i = 0; i < o2::ctp::CTP_NCLASSES; i++) {
     bool print = clsA[i] > 0 || clsB[i] > 0 || clsEA[i] > 0 || clsEB[i] > 0;
-    if (clsEA[i])
+    if (clsEA[i]) {
       LOG(error) << " Class without inputs:";
+    }
     LOG(important) << "CLASS:" << i << " Cls=>Inp:" << clsA[i] << " Inp=>Cls:" << clsB[i] << "  ErrorsCls=>Inps:" << clsEA[i] << "  MissingInps=>Cls:" << clsEB[i];
   }
 }

From 17345d60e5a63f085e86d1064c315d6f88c326b3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 14 May 2025 19:29:47 +0200
Subject: [PATCH 0356/1764] DPL: Out of line NumericBuilders (#14273)

---
 Framework/Core/include/Framework/TableBuilder.h | 6 ++++++
 Framework/Core/src/TableBuilder.cxx             | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index 936a8a04d5a5a..8d7601cefc634 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -48,6 +48,12 @@ struct BulkInfo {
   size_t size;
 };
 
+extern template class arrow::NumericBuilder<arrow::UInt8Type>;
+extern template class arrow::NumericBuilder<arrow::UInt32Type>;
+extern template class arrow::NumericBuilder<arrow::FloatType>;
+extern template class arrow::NumericBuilder<arrow::Int32Type>;
+extern template class arrow::NumericBuilder<arrow::Int8Type>;
+
 namespace o2::framework
 {
 namespace detail
diff --git a/Framework/Core/src/TableBuilder.cxx b/Framework/Core/src/TableBuilder.cxx
index eb19f8d3fe642..2169722efa9da 100644
--- a/Framework/Core/src/TableBuilder.cxx
+++ b/Framework/Core/src/TableBuilder.cxx
@@ -131,3 +131,9 @@ std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const&
 }
 
 } // namespace o2::framework
+
+template class arrow::NumericBuilder<arrow::UInt8Type>;
+template class arrow::NumericBuilder<arrow::UInt32Type>;
+template class arrow::NumericBuilder<arrow::FloatType>;
+template class arrow::NumericBuilder<arrow::Int32Type>;
+template class arrow::NumericBuilder<arrow::Int8Type>;

From f44f2362e789b6e3a43214b5a0f48ba9c40838f7 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 14 May 2025 14:32:37 +0200
Subject: [PATCH 0357/1764] Update RecoContainer.cxx

---
 .../Detectors/GlobalTracking/src/RecoContainer.cxx       | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx b/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
index d4b4e2b89cbb0..dd206ffe3b70d 100644
--- a/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
+++ b/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
@@ -1440,8 +1440,7 @@ RecoContainer::GlobalIDSet RecoContainer::getSingleDetectorRefs(GTrackID gidx) c
     table[GTrackID::TRD] = parent0.getTrackRef();                 // there is no standalone TRD track, so use the index for the ITSTPCTRD track array
   } else if (src == GTrackID::TPCTRDTOF) {
     const auto& parent0 = getTOFMatch(gidx); // TPCTRD : TOF
-    const auto& parent1 = getITSTPCTRDTrack<o2::trd::TrackTRD>(parent0.getTrackRef());
-    const auto& parent2 = getTPCITSTrack(parent1.getRefGlobalTrackId());
+    const auto& parent1 = getTPCTRDTrack<o2::trd::TrackTRD>(parent0.getTrackRef());
     table[GTrackID::TPCTRD] = parent0.getTrackRef();
     table[GTrackID::TPC] = parent1.getRefGlobalTrackId();
     table[GTrackID::TOF] = {unsigned(parent0.getIdxTOFCl()), GTrackID::TOF};
@@ -1547,8 +1546,6 @@ const o2::dataformats::MCTruthContainer<o2::emcal::MCLabel>* RecoContainer::getE
 void RecoContainer::getTrackTimeITSTPCTRDTOF(GTrackID gid, float& t, float& tErr) const
 {
   const auto& match = getITSTPCTRDTOFMatches()[gid];
-  auto gidx = match.getTrackRef(); // this should be corresponding ITS-TPC-TRD track
-  //  const auto& tofCl = getTOFClusters()[match.getTOFClIndex()];
   t = (match.getSignal() - match.getLTIntegralOut().getTOF(o2::track::PID::Pion)) * PS2MUS; // tof time in \mus, FIXME: account for time of flight to R TOF
   tErr = 0.010f;
 }
@@ -1557,8 +1554,6 @@ void RecoContainer::getTrackTimeITSTPCTRDTOF(GTrackID gid, float& t, float& tErr
 void RecoContainer::getTrackTimeTPCTRDTOF(GTrackID gid, float& t, float& tErr) const
 {
   const auto& match = getTPCTRDTOFMatches()[gid];
-  auto gidx = match.getTrackRef(); // this should be corresponding ITS-TPC-TRD track
-  //  const auto& tofCl = getTOFClusters()[match.getTOFClIndex()];
   t = (match.getSignal() - match.getLTIntegralOut().getTOF(o2::track::PID::Pion)) * PS2MUS; // tof time in \mus, FIXME: account for time of flight to R TOF
   tErr = 0.010f;
 }
@@ -1567,8 +1562,6 @@ void RecoContainer::getTrackTimeTPCTRDTOF(GTrackID gid, float& t, float& tErr) c
 void RecoContainer::getTrackTimeITSTPCTOF(GTrackID gid, float& t, float& tErr) const
 {
   const auto& match = getITSTPCTOFMatches()[gid];
-  auto gidx = match.getTrackRef(); // this should be corresponding ITS-TPC track
-  //  const auto& tofCl = getTOFClusters()[match.getTOFClIndex()];
   t = (match.getSignal() - match.getLTIntegralOut().getTOF(o2::track::PID::Pion)) * PS2MUS; // tof time in \mus, FIXME: account for time of flight to R TOF
   tErr = 0.010f;
 }

From 07096be128091de462d688c88e5f4cf0f5866729 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 15:56:55 +0200
Subject: [PATCH 0358/1764] GPU: Add some more type trait templates for GPU
 code

---
 GPU/Common/GPUCommonTypeTraits.h | 44 +++++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/GPU/Common/GPUCommonTypeTraits.h b/GPU/Common/GPUCommonTypeTraits.h
index 6d72565d1f1fb..f837019c11875 100644
--- a/GPU/Common/GPUCommonTypeTraits.h
+++ b/GPU/Common/GPUCommonTypeTraits.h
@@ -22,7 +22,7 @@
 #include <type_traits>
 #endif
 #else
-// We just reimplement some type traits in std for the GPU
+// We just reimplement some type traits in std for the GPU // TODO: Check if meanwhile we can get rid of GPUCommonTypeTraits and GPUCommonArray, and just use the std headers.
 namespace std
 {
 template <bool B, class T, class F>
@@ -35,6 +35,7 @@ struct conditional<false, T, F> {
 };
 template <bool B, class T, class F>
 using contitional_t = typename conditional<B, T, F>::type;
+
 template <class T, class U>
 struct is_same {
   static constexpr bool value = false;
@@ -45,6 +46,7 @@ struct is_same<T, T> {
 };
 template <class T, class U>
 static constexpr bool is_same_v = is_same<T, U>::value;
+
 template <bool B, class T = void>
 struct enable_if {
 };
@@ -52,6 +54,7 @@ template <class T>
 struct enable_if<true, T> {
   typedef T type;
 };
+
 template <class T>
 struct remove_cv {
   typedef T type;
@@ -68,6 +71,9 @@ template <class T>
 struct remove_cv<const volatile T> {
   typedef T type;
 };
+template <class T>
+using remove_cv_t = typename remove_cv<T>::type;
+
 template <class T>
 struct remove_const {
   typedef T type;
@@ -76,6 +82,9 @@ template <class T>
 struct remove_const<const T> {
   typedef T type;
 };
+template <class T>
+using remove_const_t = typename remove_const<T>::type;
+
 template <class T>
 struct remove_volatile {
   typedef T type;
@@ -84,6 +93,9 @@ template <class T>
 struct remove_volatile<volatile T> {
   typedef T type;
 };
+template <class T>
+using remove_volatile_t = typename remove_volatile<T>::type;
+
 template <class T>
 struct is_pointer_t {
   static constexpr bool value = false;
@@ -95,6 +107,36 @@ struct is_pointer_t<T*> {
 template <class T>
 struct is_pointer : is_pointer_t<typename std::remove_cv<T>::type> {
 };
+
+template <class T>
+struct remove_reference {
+  typedef T type;
+};
+template <class T>
+struct remove_reference<T&> {
+  typedef T type;
+};
+template <class T>
+struct remove_reference<T&&> {
+  typedef T type;
+};
+template <class T>
+using remove_reference_t = typename remove_reference<T>::type;
+
+template <class T>
+struct is_member_pointer_helper {
+  static constexpr bool value = false;
+};
+template <class T, class U>
+struct is_member_pointer_helper<T U::*> {
+  static constexpr bool value = true;
+};
+template <class T>
+struct is_member_pointer : is_member_pointer_helper<typename std::remove_cv<T>::type> {
+};
+template <class T>
+static constexpr bool is_member_pointer_v = is_member_pointer<T>::value;
+
 } // namespace std
 #endif
 

From 4654958fe006df87ce60aaf48d61184db85e76d3 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 15:57:10 +0200
Subject: [PATCH 0359/1764] Revert "GPU: Workaround for Clang Frontend issue"

This reverts commit 89b35ba2d75113e60b2045ed01e169b28d860a07.
---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx | 4 ----
 GPU/GPUTracking/Base/hip/CMakeLists.txt                   | 5 -----
 2 files changed, 9 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index 67ad608c13417..acc77648d954b 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -38,11 +38,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
 {
   std::string rtcparam = std::string("#define GPUCA_RTC_CODE\n") +
                          std::string(GetProcessingSettings().rtc.optSpecialCode ? "#define GPUCA_RTC_SPECIAL_CODE(...) __VA_ARGS__\n" : "#define GPUCA_RTC_SPECIAL_CODE(...)\n") +
-#ifndef GPUCA_HIP_WORKAROUND_CONSTEXPR // TODO: Fixme, once we have C++ P2280R4 in Clang
                          std::string(GetProcessingSettings().rtc.optConstexpr ? "#define GPUCA_RTC_CONSTEXPR constexpr\n" : "#define GPUCA_RTC_CONSTEXPR\n") +
-#else
-                         std::string("#define GPUCA_RTC_CONSTEXPR\n") +
-#endif
                          GPUParamRTC::generateRTCCode(param(), GetProcessingSettings().rtc.optConstexpr);
   if (filename == "") {
     filename = "/tmp/o2cagpu_rtc_";
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index c89ef1769ad81..6eded3499e46e 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -270,8 +270,3 @@ add_dependencies(GPUTrackingHIPExternalProvider O2::GPUTracking) # must not depe
 if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   add_dependencies(GPUTrackingHIPExternalProvider ${MODULE}_HIPIFIED)
 endif()
-
-set_source_files_properties("${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPGenRTC.cxx"
-TARGET_DIRECTORY O2::GPUTrackingHIP
-PROPERTIES
-COMPILE_DEFINITIONS "GPUCA_HIP_WORKAROUND_CONSTEXPR")

From 46ef93fdb9436f1b1bcebd01a3458235ed918c80 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 18:52:29 +0200
Subject: [PATCH 0360/1764] GPU: Template workaround to get static constexpr
 values as constexpr from references

---
 GPU/GPUTracking/Definitions/GPUGetConstexpr.h | 67 +++++++++++++++++++
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  5 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 11 +--
 3 files changed, 76 insertions(+), 7 deletions(-)
 create mode 100644 GPU/GPUTracking/Definitions/GPUGetConstexpr.h

diff --git a/GPU/GPUTracking/Definitions/GPUGetConstexpr.h b/GPU/GPUTracking/Definitions/GPUGetConstexpr.h
new file mode 100644
index 0000000000000..8001b4e98c83f
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/GPUGetConstexpr.h
@@ -0,0 +1,67 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUGetConstexpr.h
+/// \author David Rohr
+
+#ifndef GPUGETCONSTEXPR_H
+#define GPUGETCONSTEXPR_H
+
+#include "GPUCommonDef.h"
+#include "GPUCommonTypeTraits.h"
+
+// This is a temporary workaround required for clang (with c++20), until we can go to C++23 with P2280R4, which allows getting constexpr static values from references
+
+#if defined(__clang__) && __cplusplus >= 202002L && __cplusplus < 202302L
+
+namespace o2::gpu::internal
+{
+
+#define GPUCA_GET_CONSTEXPR(obj, val) ( \
+  std::is_member_pointer_v<decltype(&std::remove_reference_t<decltype(obj)>::val)> ? o2::gpu::internal::getConstexpr(&std::remove_reference_t<decltype(obj)>::val, o2::gpu::internal::getConstexprHelper<decltype(&std::remove_reference_t<decltype(obj)>::val), decltype(&obj)>(&obj).value) : o2::gpu::internal::getConstexpr(&std::remove_reference_t<decltype(obj)>::val, o2::gpu::internal::getConstexprHelper<decltype(&std::remove_reference_t<decltype(obj)>::val), decltype(&obj)>().value))
+
+template <class T, class S>
+struct getConstexprHelper;
+
+template <class T, class S>
+  requires(!std::is_member_pointer_v<T>)
+struct getConstexprHelper<T, S> {
+  GPUdi() constexpr getConstexprHelper(const void* = nullptr) {}
+  static constexpr const void* value = nullptr;
+};
+
+template <class T, class S>
+  requires(std::is_member_pointer_v<T>)
+struct getConstexprHelper<T, S> {
+  GPUdi() constexpr getConstexprHelper(const S& v) : value(v) {}
+  GPUdDefault() constexpr getConstexprHelper() = default;
+  const S value = nullptr;
+};
+
+GPUdi() constexpr auto getConstexpr(const auto* v, const void* = nullptr)
+{
+  return *v;
+}
+
+GPUdi() constexpr auto getConstexpr(const auto v, const auto w)
+{
+  return w->*v;
+}
+
+} // namespace o2::gpu::internal
+
+#else // __clang__
+
+#define GPUCA_GET_CONSTEXPR(obj, val) (obj).val
+
+#endif
+
+#endif // GPUGETCONSTEXPR_H
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index eb22ca49e9242..7bb28a9f22e31 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -20,6 +20,7 @@
 #include "DataFormatsTPC/PIDResponse.h"
 #include "TPCFastTransform.h"
 #include "CorrectionMapsHelper.h"
+#include "GPUGetConstexpr.h"
 
 #ifndef GPUCA_GPUCODE
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
@@ -141,10 +142,10 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
 
     oTrack.setChi2(tracks[i].GetParam().GetChi2());
     auto& outerPar = tracks[i].OuterParam();
-    if GPUCA_RTC_CONSTEXPR (param.par.dodEdx) {
+    if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
       if (param.dodEdxEnabled) {
         oTrack.setdEdx(tracksdEdx[i]);
-        if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+        if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMask) != GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMaskAlt)) {
           oTrack.setdEdxAlt(tracksdEdxAlt[i]);
         } else {
           oTrack.setdEdxAlt(tracksdEdx[i]);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 4b616fce83f5f..1072e4b178bdf 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -39,6 +39,7 @@
 #include "GPUTPCConvertImpl.h"
 #include "GPUTPCGMMergerTypes.h"
 #include "GPUParam.inc"
+#include "GPUGetConstexpr.h"
 
 #ifdef GPUCA_CADEBUG_ENABLED
 #include "../utils/qconfig.h"
@@ -216,12 +217,12 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           continue;
         }
       } else if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
-        if GPUCA_RTC_CONSTEXPR (param.par.dodEdx) {
+        if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
           bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2 && cluster.leg == clusters[maxN - 1].leg;
           dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, cluster.leg == clusters[maxN - 1].leg, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
           if (dodEdx) {
             dEdx.fillSubThreshold(lastRow - wayDirection);
-            if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+            if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMask) != GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMaskAlt)) {
               dEdxAlt.fillSubThreshold(lastRow - wayDirection);
             }
           }
@@ -371,7 +372,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           CADEBUG(printf("Reinit linearization\n"));
           prop.SetTrack(this, prop.GetAlpha());
         }
-        if GPUCA_RTC_CONSTEXPR (param.par.dodEdx) {
+        if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
           if (param.dodEdxEnabled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg) { // TODO: Costimize flag to remove, and option to remove double-clusters
             bool acc = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMask) == 0, accAlt = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) == 0;
             if (acc || accAlt) {
@@ -395,7 +396,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
               if (acc) {
                 dEdx.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
               }
-              if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+              if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMask) != GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMaskAlt)) {
                 if (accAlt) {
                   dEdxAlt.fillCluster(qtot, qmax, cluster.row, cluster.sector, mP[2], mP[3], merger->GetConstantMem()->calibObjects, zz, pad, relTime);
                 }
@@ -436,7 +437,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
   if (param.par.dodEdx && param.dodEdxEnabled) {
     dEdx.computedEdx(merger->MergedTracksdEdx()[iTrk], param);
-    if GPUCA_RTC_CONSTEXPR (param.rec.tpc.dEdxClusterRejectionFlagMask != param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) {
+    if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMask) != GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMaskAlt)) {
       dEdxAlt.computedEdx(merger->MergedTracksdEdxAlt()[iTrk], param);
     }
   }

From 4d647840509e57b890f4ce71fdb062f2edf7b234 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 13 May 2025 18:52:48 +0200
Subject: [PATCH 0361/1764] GPU: Simplify some type_traits use, get rid of
 ::values and ::type

---
 .../Base/cuda/GPUReconstructionCUDAInternals.h            | 2 +-
 GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx      | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx                 | 4 ++--
 GPU/GPUTracking/qa/GPUQAHelper.h                          | 8 ++++----
 GPU/GPUTracking/utils/bitfield.h                          | 2 +-
 GPU/GPUTracking/utils/qconfig.cxx                         | 8 ++++----
 6 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
index 0813c9d22ea09..493c09e448e5e 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
@@ -79,7 +79,7 @@ class GPUDebugTiming
   bool mDo;
 };
 
-static_assert(std::is_convertible<cudaEvent_t, void*>::value, "CUDA event type incompatible to deviceEvent");
+static_assert(std::is_convertible_v<cudaEvent_t, void*>, "CUDA event type incompatible to deviceEvent");
 
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index 949dd6195b262..ce05e159461e5 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -18,7 +18,7 @@
 
 #include <map>
 
-static_assert(std::is_convertible<cl_event, void*>::value, "OpenCL event type incompatible to deviceEvent");
+static_assert(std::is_convertible_v<cl_event, void*>, "OpenCL event type incompatible to deviceEvent");
 
 #define GPUErrorReturn(...) \
   {                         \
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index f1a0816529c3a..73ca449252d1d 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -235,7 +235,7 @@ int64_t GPUTPCGMMerger::GetTrackLabelA(const S& trk) const
 {
   GPUTPCGMSectorTrack* sectorTrack = nullptr;
   int32_t nClusters = 0;
-  if constexpr (std::is_same<S, GPUTPCGMBorderTrack&>::value) {
+  if constexpr (std::is_same_v<S, GPUTPCGMBorderTrack&>) {
     sectorTrack = &mSectorTrackInfos[trk.TrackID()];
     nClusters = sectorTrack->OrigTrack()->NHits();
   } else {
@@ -244,7 +244,7 @@ int64_t GPUTPCGMMerger::GetTrackLabelA(const S& trk) const
   auto acc = GPUTPCTrkLbl<false, GPUTPCTrkLbl_ret>(resolveMCLabels<T>(GetConstantMem()->ioPtrs.clustersNative ? GetConstantMem()->ioPtrs.clustersNative->clustersMCTruth : nullptr, GetConstantMem()->ioPtrs.mcLabelsTPC), 0.5f);
   for (int32_t i = 0; i < nClusters; i++) {
     int32_t id;
-    if constexpr (std::is_same<S, GPUTPCGMBorderTrack&>::value) {
+    if constexpr (std::is_same_v<S, GPUTPCGMBorderTrack&>) {
       const GPUTPCTracker& tracker = GetConstantMem()->tpcTrackers[sectorTrack->Sector()];
       const GPUTPCHitId& ic = tracker.TrackHits()[sectorTrack->OrigTrack()->FirstHitID() + i];
       id = tracker.Data().ClusterDataIndex(tracker.Data().Row(ic.RowIndex()), ic.HitIndex()) + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[sectorTrack->Sector()][0];
diff --git a/GPU/GPUTracking/qa/GPUQAHelper.h b/GPU/GPUTracking/qa/GPUQAHelper.h
index a7811c6fd55ed..a830562119467 100644
--- a/GPU/GPUTracking/qa/GPUQAHelper.h
+++ b/GPU/GPUTracking/qa/GPUQAHelper.h
@@ -48,7 +48,7 @@ class GPUTPCTrkLbl
   }
   inline void addLabel(uint32_t elementId)
   {
-    if constexpr (std::is_same<T, AliHLTTPCClusterMCWeight>::value) {
+    if constexpr (std::is_same_v<T, AliHLTTPCClusterMCWeight>) {
       for (uint32_t i = 0; i < sizeof(mClusterLabels[elementId]) / sizeof(mClusterLabels[elementId].fClusterID[0]); i++) {
         const auto& element = mClusterLabels[elementId].fClusterID[i];
         if (element.fMCID >= 0) {
@@ -101,7 +101,7 @@ class GPUTPCTrkLbl
         }
       }
       auto& bestLabel = mLabels[bestLabelNum].first;
-      if constexpr (std::is_same<T, AliHLTTPCClusterMCWeight>::value && WEIGHT) {
+      if constexpr (std::is_same_v<T, AliHLTTPCClusterMCWeight> && WEIGHT) {
         *labelWeight = bestLabel.fWeight;
         *totalWeight = mTotalWeight;
         *maxCount = bestLabelCount;
@@ -147,7 +147,7 @@ struct GPUTPCTrkLbl_ret {
 template <bool WEIGHT = false, class U = void, class T, template <class> class S, typename... Args>
 static inline auto GPUTPCTrkLbl(const S<T>* x, Args... args)
 {
-  if constexpr (std::is_same<U, void>::value) {
+  if constexpr (std::is_same_v<U, void>) {
     return internal::GPUTPCTrkLbl<WEIGHT, T, S<T>>(x, args...);
   } else {
     return internal::GPUTPCTrkLbl<WEIGHT, T, S<T>, U>(x, args...);
@@ -159,7 +159,7 @@ static inline auto GPUTPCTrkLbl(const AliHLTTPCClusterMCLabel* x, Args... args)
 {
   using S = AliHLTTPCClusterMCLabel;
   using T = AliHLTTPCClusterMCWeight;
-  if constexpr (std::is_same<U, void>::value) {
+  if constexpr (std::is_same_v<U, void>) {
     return internal::GPUTPCTrkLbl<WEIGHT, T, S>(x, args...);
   } else {
     return internal::GPUTPCTrkLbl<WEIGHT, T, S, U>(x, args...);
diff --git a/GPU/GPUTracking/utils/bitfield.h b/GPU/GPUTracking/utils/bitfield.h
index 9730f6c6c234f..a3a3ac9a5bd95 100644
--- a/GPU/GPUTracking/utils/bitfield.h
+++ b/GPU/GPUTracking/utils/bitfield.h
@@ -93,7 +93,7 @@ class bitfield
   }
 
 #if !defined(GPUCA_GPUCODE_DEVICE)
-  static_assert(std::is_integral<S>::value, "Storage type non integral");
+  static_assert(std::is_integral_v<S>, "Storage type non integral");
   static_assert(sizeof(S) >= sizeof(T), "Storage type has insufficient capacity");
 #endif
 
diff --git a/GPU/GPUTracking/utils/qconfig.cxx b/GPU/GPUTracking/utils/qconfig.cxx
index cdb41ec5813f2..839954e52ded3 100644
--- a/GPU/GPUTracking/utils/qconfig.cxx
+++ b/GPU/GPUTracking/utils/qconfig.cxx
@@ -126,7 +126,7 @@ static inline int32_t qAddOptionMainTupleElem(qConfigSettings<typename qSettings
   qConfigSettings<T> settings = settingsTup;
   return (qAddOptionType<T>(settings, ref, i, argv, argc, def));
 }
-template <typename T, int32_t index = 0, int32_t left = std::tuple_size<T>::value>
+template <typename T, int32_t index = 0, int32_t left = std::tuple_size_v<T>>
 struct qAddOptionMainTupleStruct {
   static inline int32_t qAddOptionMainTuple(qConfigSettings<typename qSettingsType<T>::settingsType> settings, T& tup, int32_t& i, const char** argv, const int argc)
   {
@@ -157,13 +157,13 @@ struct qConfigType {
   // Recursive handling of additional settings
   static inline void qProcessSetting(qConfigSettings<T>& settings, qmin_t<T> minval)
   {
-    static_assert(!std::is_same<T, bool>::value, "min option not supported for boolean settings");
+    static_assert(!std::is_same_v<T, bool>, "min option not supported for boolean settings");
     settings.checkMin = true;
     settings.min = minval.v;
   }
   static inline void qProcessSetting(qConfigSettings<T>& settings, qmax_t<T> maxval)
   {
-    static_assert(!std::is_same<T, bool>::value, "max option not supported for boolean settings");
+    static_assert(!std::is_same_v<T, bool>, "max option not supported for boolean settings");
     settings.checkMax = true;
     settings.max = maxval.v;
   }
@@ -244,7 +244,7 @@ struct qConfigType {
   static inline void qConfigHelpOption(const char* name, const char* type, const char* def, const char* optname, char optnameshort, const char* preopt, char preoptshort, int32_t optionType, const char* help, Args&&... args)
   {
     auto settings = qConfigGetSettings(args...);
-    const bool boolType = optionType != 1 && std::is_same<T, bool>::value;
+    const bool boolType = optionType != 1 && std::is_same_v<T, bool>;
     const char* arguments = settings.doSet ? " (" : (settings.doDefault || optionType == 1 || boolType) ? " [arg] (" : optionType == 2 ? " [...] (" : " arg (";
     char argBuffer[4] = {0};
     uint32_t argBufferPos = 0;

From 073cd1697027762311775ec251cea232c701db80 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 14 May 2025 20:43:33 +0200
Subject: [PATCH 0362/1764] GPU CMake: Use CUDA/HIP compilers to preprocess
 CUDA/HIP RTC files

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt | 2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index c31dd0c8d3fe2..d9ee132d7c5f5 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -68,7 +68,7 @@ set(GPU_RTC_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionCUDArtc)
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.src
     COMMAND cp ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPU_RTC_BIN}.src
-    COMMAND ${CMAKE_CXX_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
+    COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -E -Xcompiler "-nostdinc -P" ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
     MAIN_DEPENDENCY ${GPU_RTC_SRC}
     IMPLICIT_DEPENDS CXX ${GPU_RTC_SRC}
     COMMAND_EXPAND_LISTS
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 6eded3499e46e..a47c659c8717d 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -115,7 +115,7 @@ set(GPU_RTC_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionHIPrtc)
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.src
     COMMAND cp ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPU_RTC_BIN}.src
-    COMMAND ${CMAKE_CXX_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
+    COMMAND ${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
     MAIN_DEPENDENCY ${GPU_RTC_SRC}
     IMPLICIT_DEPENDS CXX ${GPU_RTC_SRC}
     DEPENDS ${MODULE}_HIPIFIED

From 895906ee43086663b84232a35e935474a06d6cb7 Mon Sep 17 00:00:00 2001
From: Mario Sitta <mario6829@gmail.com>
Date: Thu, 15 May 2025 15:41:14 +0200
Subject: [PATCH 0363/1764] Implementation of MFT rails inside Cage

---
 .../simulation/include/ITSSimulation/V3Cage.h |  21 +++
 .../ITSMFT/ITS/simulation/src/V3Cage.cxx      | 146 ++++++++++++++++++
 2 files changed, 167 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Cage.h b/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Cage.h
index e90f0cfeb0aed..44d72284112c2 100644
--- a/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Cage.h
+++ b/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Cage.h
@@ -113,6 +113,16 @@ class V3Cage : public V11Geometry
   /// \param mgr  The GeoManager (used only to get the proper material)
   TGeoVolume* createCageClosingCross(const TGeoManager* mgr = gGeoManager);
 
+  /// Creates and places the MFT rails inside the Cage
+  /// \param mother The mother volume to place the rails into
+  /// \param mgr  The GeoManager (used only to get the proper material)
+  void createAndPlaceMFTRailsInsideCage(TGeoVolume* mother, const TGeoManager* mgr = gGeoManager);
+
+  /// Creates a pair of MFT rails inside the Cage
+  /// \param motmed  Medium material of the mother volume
+  /// \param mgr  The GeoManager (used only to get the proper material)
+  TGeoVolume* createMFTRailsPair(const TGeoMedium* motmed, const TGeoManager* mgr = gGeoManager);
+
   // Parameters
   static const Double_t sCageYInBarrel; ///< Global Y translation
 
@@ -244,6 +254,17 @@ class V3Cage : public V11Geometry
   static const Double_t sCageCrossBarThick;   ///< Closing cross bar thickness
   static const Double_t sCageCrossBarPhi;     ///< Closing cross bar angle
 
+  // MFT Rails inside the Cage
+  static const Double_t sCageMFTRailZLen;      ///< Total length of the rail
+  static const Double_t sCageMFTRailTotWidth;  ///< Total width of the rail
+  static const Double_t sCageMFTRailExtWidth;  ///< Width of the external part
+  static const Double_t sCageMFTRailIntWidth;  ///< Width of the internal part
+  static const Double_t sCageMFTRailBaseWidth; ///< Width of the rail base
+  static const Double_t sCageMFTRailTotHeight; ///< Total height of the rail
+  static const Double_t sCageMFTRailExtHeight; ///< Height of the external part
+  static const Double_t sCageMFTRailIntHeight; ///< Height of the internal part
+  static const Double_t sCageMFTRailsXDist;    ///< X distance between rails
+
   ClassDefOverride(V3Cage, 0); // ITS v3 support geometry
 };
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/simulation/src/V3Cage.cxx b/Detectors/ITSMFT/ITS/simulation/src/V3Cage.cxx
index 3b17d7afeef3d..528b74dc339f1 100644
--- a/Detectors/ITSMFT/ITS/simulation/src/V3Cage.cxx
+++ b/Detectors/ITSMFT/ITS/simulation/src/V3Cage.cxx
@@ -167,6 +167,16 @@ const Double_t V3Cage::sCageCrossZLength = 8 * sMm;
 const Double_t V3Cage::sCageCrossBarThick = 20 * sMm;
 const Double_t V3Cage::sCageCrossBarPhi = 25; // Deg
 
+const Double_t V3Cage::sCageMFTRailZLen = 1807 * sMm;
+const Double_t V3Cage::sCageMFTRailTotWidth = 27 * sMm;
+const Double_t V3Cage::sCageMFTRailExtWidth = 24 * sMm;
+const Double_t V3Cage::sCageMFTRailIntWidth = 17.5 * sMm;
+const Double_t V3Cage::sCageMFTRailBaseWidth = 22 * sMm;
+const Double_t V3Cage::sCageMFTRailTotHeight = 8.9 * sMm;
+const Double_t V3Cage::sCageMFTRailExtHeight = 5.9 * sMm;
+const Double_t V3Cage::sCageMFTRailIntHeight = 3.5 * sMm;
+const Double_t V3Cage::sCageMFTRailsXDist = 44 * sMm;
+
 ClassImp(V3Cage);
 
 V3Cage::V3Cage()
@@ -251,6 +261,9 @@ void V3Cage::createAndPlaceCage(TGeoVolume* mother, const TGeoManager* mgr)
   zpos = sBPSuppZPos + sBPSuppCollarBeamWid / 2;
   mother->AddNode(cageBPSupport, 1, new TGeoTranslation(0, ypos, zpos));
 
+  // The MFT Rails inside the Cage
+  createAndPlaceMFTRailsInsideCage(mother, mgr);
+
   return;
 }
 
@@ -1648,3 +1661,136 @@ TGeoVolume* V3Cage::createCageClosingCross(const TGeoManager* mgr)
   // Finally return the closing cross volume
   return closCrossVol;
 }
+
+void V3Cage::createAndPlaceMFTRailsInsideCage(TGeoVolume* mother, const TGeoManager* mgr)
+{
+  //
+  // Creates the MFT Rails located inside the Cage and place them
+  //
+  // Input:
+  //         motmat : the material of the mother volume (for the container box)
+  //         mgr : the GeoManager (used only to get the proper material)
+  //
+  // Output:
+  //
+  // Return:
+  //
+  // Created:      10 May 2025  Mario Sitta
+  //
+
+  // Local variables
+  Double_t rdist, rpos, xpos, ypos, alpha;
+  Double_t xbox, ybox;
+
+  // Create a pair of rails (a BBox container is returned)
+  TGeoVolume* cageMFTRails = createMFTRailsPair(mother->GetMedium(), mgr);
+
+  // Now compute the radial distance and the XY position of the box
+  xbox = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDX();
+  ybox = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDY();
+
+  rdist = TMath::Sqrt(sCageCoverRint * sCageCoverRint - xbox * xbox);
+  rpos = rdist - ybox;
+
+  // Finally place the four pairs of rails inside the mother volume
+  xpos = rpos * TMath::Sin(sCageEndCapCableCutPhi * TMath::DegToRad());
+  ypos = rpos * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) + sCageYInBarrel;
+
+  alpha = -sCageEndCapCableCutPhi + 180;
+  mother->AddNode(cageMFTRails, 1, new TGeoCombiTrans(xpos, ypos, 0, new TGeoRotation("", alpha, 0, 0)));
+  alpha = sCageEndCapCableCutPhi + 180;
+  mother->AddNode(cageMFTRails, 2, new TGeoCombiTrans(-xpos, ypos, 0, new TGeoRotation("", alpha, 0, 0)));
+
+  ypos = rpos * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) - sCageYInBarrel;
+
+  alpha = sCageEndCapCableCutPhi;
+  mother->AddNode(cageMFTRails, 3, new TGeoCombiTrans(xpos, -ypos, 0, new TGeoRotation("", alpha, 0, 0)));
+  alpha = -sCageEndCapCableCutPhi;
+  mother->AddNode(cageMFTRails, 4, new TGeoCombiTrans(-xpos, -ypos, 0, new TGeoRotation("", alpha, 0, 0)));
+
+  return;
+}
+
+TGeoVolume* V3Cage::createMFTRailsPair(const TGeoMedium* motmed, const TGeoManager* mgr)
+{
+  //
+  // Creates a pair of MFT Rails located inside the Cage (from drawings
+  // ALI-MFT-DF-0057 and elements therein)
+  // A box containing a pair of rails is returned (a physical box
+  // is preferred over an Assembly for better performance)
+  //
+  // Input:
+  //         motmat : the material of the mother volume (for the container box)
+  //         mgr : the GeoManager (used only to get the proper material)
+  //
+  // Output:
+  //
+  // Return:
+  //         A rail pair as a TGeoVolume
+  //
+  // Created:      10 May 2025  Mario Sitta
+  //
+
+  // Local variables
+  const Int_t nv = 16;
+  Double_t xv[nv], yv[nv];
+  Double_t deltah, xlen, ylen, zlen;
+  Double_t xpos, ypos;
+
+  // The shape of a single rail: a Xtru
+  xv[0] = sCageMFTRailBaseWidth / 2;
+  yv[0] = 0.;
+  xv[1] = xv[0];
+  yv[1] = sCageMFTRailTotHeight - sCageMFTRailExtHeight;
+  xv[2] = sCageMFTRailTotWidth / 2;
+  yv[2] = yv[1];
+  xv[3] = xv[2];
+  yv[3] = sCageMFTRailTotHeight;
+  xv[4] = sCageMFTRailIntWidth / 2;
+  yv[4] = yv[3];
+  deltah = (sCageMFTRailExtHeight - sCageMFTRailIntHeight) / 2;
+  xv[5] = xv[4];
+  yv[5] = yv[4] - deltah;
+  xv[6] = sCageMFTRailExtWidth / 2;
+  yv[6] = yv[5];
+  xv[7] = xv[6];
+  yv[7] = yv[6] - sCageMFTRailIntHeight;
+
+  for (Int_t i = 8; i < nv; i++) {
+    xv[i] = -xv[15 - i];
+    yv[i] = yv[15 - i];
+  }
+
+  zlen = sCageMFTRailZLen / 2;
+
+  TGeoXtru* mftRailSh = new TGeoXtru(2);
+  mftRailSh->SetName("mftrailshape");
+  mftRailSh->DefinePolygon(nv, xv, yv);
+  mftRailSh->DefineSection(0, -zlen);
+  mftRailSh->DefineSection(1, zlen);
+
+  // The air container: a BBox
+  xlen = 2 * sCageMFTRailTotWidth + sCageMFTRailsXDist;
+  ylen = sCageMFTRailTotHeight / 2;
+  zlen = sCageMFTRailZLen / 2;
+  TGeoBBox* mftRailBoxSh = new TGeoBBox(xlen / 2, ylen, zlen);
+
+  // We have the shape: now create the real volume
+  TGeoMedium* medAl = mgr->GetMedium(Form("%s_ALUMINUM$", GetDetName()));
+
+  TGeoVolume* mftRailVol = new TGeoVolume("MFTRailInsideCage", mftRailSh, medAl);
+  mftRailVol->SetFillColor(kGray);
+  mftRailVol->SetLineColor(kGray);
+
+  TGeoVolume* mftRailBoxVol = new TGeoVolume("MFTRailPairInsideCage", mftRailBoxSh, motmed);
+
+  // Put the two rails inside the holding box
+  // (rail Y origin is on its lower face)
+  xpos = mftRailBoxSh->GetDX() - 0.5 * sCageMFTRailTotWidth;
+  ypos = mftRailBoxSh->GetDY();
+  mftRailBoxVol->AddNode(mftRailVol, 1, new TGeoTranslation(xpos, -ypos, 0));
+  mftRailBoxVol->AddNode(mftRailVol, 2, new TGeoTranslation(-xpos, -ypos, 0));
+
+  // Finally return the rails volume
+  return mftRailBoxVol;
+}

From c2cd436aaed5b1e0e21ba831f22b37b7184cd9b3 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 15 May 2025 14:32:10 +0200
Subject: [PATCH 0364/1764] GPU: Some work to prepare using <type_traits> and
 <array> headers from system for GPU

---
 .../MathUtils/include/MathUtils/SMatrixGPU.h  |  4 ++-
 .../include/CommonDataFormat/AbstractRef.h    |  5 +++-
 Detectors/Raw/include/DetectorsRaw/RDHUtils.h |  6 +++--
 GPU/GPUTracking/Base/GPUStdSystemHeaders.h    | 25 +++++++++++++++++++
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  4 ++-
 .../GPUReconstructionCUDAIncludesSystem.h     |  7 +++---
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  3 ++-
 .../hip/GPUReconstructionHIPIncludesSystem.h  |  4 +++
 GPU/GPUTracking/Base/opencl/CMakeLists.txt    |  8 +++++-
 .../Base/opencl/GPUReconstructionOCL.cl       |  2 ++
 GPU/GPUTracking/DataTypes/GPUDataTypes.h      |  2 +-
 GPU/GPUTracking/Definitions/GPUGetConstexpr.h |  4 ++-
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |  5 +++-
 GPU/GPUTracking/Standalone/cmake/config.cmake |  2 +-
 .../TRDTracking/GPUTRDTrackerKernels.cxx      |  5 +++-
 GPU/GPUTracking/utils/bitfield.h              |  5 +---
 16 files changed, 72 insertions(+), 19 deletions(-)
 create mode 100644 GPU/GPUTracking/Base/GPUStdSystemHeaders.h

diff --git a/Common/MathUtils/include/MathUtils/SMatrixGPU.h b/Common/MathUtils/include/MathUtils/SMatrixGPU.h
index 5ecdcd75a9906..675719cfc0751 100644
--- a/Common/MathUtils/include/MathUtils/SMatrixGPU.h
+++ b/Common/MathUtils/include/MathUtils/SMatrixGPU.h
@@ -29,7 +29,9 @@
 #include "GPUCommonMath.h"
 #include "GPUCommonAlgorithm.h"
 #include "GPUCommonLogger.h"
-#include "GPUCommonTypeTraits.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits>
+#endif
 
 namespace o2::math_utils::detail
 {
diff --git a/DataFormats/common/include/CommonDataFormat/AbstractRef.h b/DataFormats/common/include/CommonDataFormat/AbstractRef.h
index 403bab3cbd62f..72c195cfb7bc8 100644
--- a/DataFormats/common/include/CommonDataFormat/AbstractRef.h
+++ b/DataFormats/common/include/CommonDataFormat/AbstractRef.h
@@ -18,7 +18,10 @@
 
 #include "GPUCommonDef.h"
 #include "GPUCommonRtypes.h"
-#include "GPUCommonTypeTraits.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits>
+#endif
+
 
 namespace o2::dataformats
 {
diff --git a/Detectors/Raw/include/DetectorsRaw/RDHUtils.h b/Detectors/Raw/include/DetectorsRaw/RDHUtils.h
index 2fac6f35d40c4..a5d8cc8615c79 100644
--- a/Detectors/Raw/include/DetectorsRaw/RDHUtils.h
+++ b/Detectors/Raw/include/DetectorsRaw/RDHUtils.h
@@ -19,13 +19,15 @@
 #include "GPUCommonRtypes.h"
 #include "Headers/RAWDataHeader.h"
 #include "Headers/RDHAny.h"
-#include "GPUCommonTypeTraits.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits>
+#endif
 #if !defined(GPUCA_GPUCODE)
 #include "CommonDataFormat/InteractionRecord.h"
 #endif
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 #include "Headers/DAQID.h"
-#endif // GPUCA_GPUCODE / GPUCA_STANDALONE
+#endif
 
 namespace o2
 {
diff --git a/GPU/GPUTracking/Base/GPUStdSystemHeaders.h b/GPU/GPUTracking/Base/GPUStdSystemHeaders.h
new file mode 100644
index 0000000000000..6598085d309c7
--- /dev/null
+++ b/GPU/GPUTracking/Base/GPUStdSystemHeaders.h
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUStdSystemHeaders.h
+/// \author David Rohr
+
+#ifndef GPUSTDSYSTEMHEADERS_H
+#define GPUSTDSYSTEMHEADERS_H
+
+#include <string>
+#include <cstddef>
+#include <cstdint>
+#include <cfloat>
+#include <cmath>
+#include <type_traits>
+
+#endif
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index d9ee132d7c5f5..97972265b3007 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -67,7 +67,9 @@ set(GPU_RTC_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionCUDArtc)
 # cmake-format: off
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.src
-    COMMAND cp ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPU_RTC_BIN}.src
+    COMMAND cp ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPU_RTC_BIN}.src
+    COMMAND cat ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h | grep -v GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
+    COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -E -Xcompiler "-nostdinc -P" ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
     MAIN_DEPENDENCY ${GPU_RTC_SRC}
     IMPLICIT_DEPENDS CXX ${GPU_RTC_SRC}
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
index 3f072059a9ad7..263d6939909c8 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAIncludesSystem.h
@@ -15,9 +15,10 @@
 #ifndef O2_GPU_GPURECONSTRUCTIONCUDAINCLUDESSYSTEM_H
 #define O2_GPU_GPURECONSTRUCTIONCUDAINCLUDESSYSTEM_H
 
-#include <cstdint>
-#include <type_traits>
-#include <string>
+#ifndef GPUCA_GPUCODE_GENRTC
+#include "GPUStdSystemHeaders.h"
+#endif
+
 #include <cuda_runtime.h>
 #include <cuda.h>
 #include <cooperative_groups.h>
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index a47c659c8717d..04a65922ad453 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -114,7 +114,8 @@ set(GPU_RTC_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionHIPrtc)
 # cmake-format: off
 add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.src
-    COMMAND cp ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPU_RTC_BIN}.src
+    COMMAND cp ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPU_RTC_BIN}.src
+    COMMAND cat ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h | grep -v GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND ${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
     MAIN_DEPENDENCY ${GPU_RTC_SRC}
     IMPLICIT_DEPENDS CXX ${GPU_RTC_SRC}
diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
index 1a3a1ff0108af..0228f993aaee3 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
@@ -15,6 +15,10 @@
 #ifndef O2_GPU_RECONSTRUCTIONHIPINCLUDESSYSTEM_H
 #define O2_GPU_RECONSTRUCTIONHIPINCLUDESSYSTEM_H
 
+#ifndef GPUCA_GPUCODE_GENRTC
+#include "GPUStdSystemHeaders.h"
+#endif
+
 #include <hip/hip_runtime.h>
 #include <hip/hip_ext.h>
 #include <hipcub/hipcub.hpp>
diff --git a/GPU/GPUTracking/Base/opencl/CMakeLists.txt b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
index 99ec36615a1d1..1a8a739adbecf 100644
--- a/GPU/GPUTracking/Base/opencl/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
@@ -23,7 +23,7 @@ endif()
 set(CL_SRC ${GPUDIR}/Base/opencl/GPUReconstructionOCL.cl)
 set(CL_BIN ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionOCLCode)
 
-set(OCL_FLAGS -Dcl_clang_storage_class_specifiers -cl-std=CLC++2021 ${GPUCA_OCL_DENORMALS_FLAGS})
+set(OCL_FLAGS -Dcl_clang_storage_class_specifiers -x cl -cl-std=CLC++2021 ${GPUCA_OCL_DENORMALS_FLAGS})
 if(NOT GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
   set(OCL_FLAGS ${OCL_FLAGS} -cl-mad-enable -cl-no-signed-zeros -cl-fast-relaxed-math)
 else()
@@ -43,6 +43,11 @@ if (NOT DEFINED GPUCA_OCL_SPIRV_VERSION)
   set(GPUCA_OCL_SPIRV_VERSION 1.2)
 endif()
 
+# execute_process(COMMAND bash -c "${LLVM_CLANG} -stdlib=libc++ -E -H -x c++ - <<< '#include <type_traits>' 2>&1 1>/dev/null | grep type_traits | head -n 1 | sed 's/^\\.* *//'"
+#                 OUTPUT_VARIABLE CLANG_STD_INCLUDE_DIR)
+# get_filename_component(CLANG_STD_INCLUDE_DIR "${CLANG_STD_INCLUDE_DIR}" DIRECTORY)
+# get_filename_component(CLANG_STD_INCLUDE_DIR "${CLANG_STD_INCLUDE_DIR}" ABSOLUTE) # TODO: For using <type_traits> in OpenCL, we would need to add -I${CLANG_STD_INCLUDE_DIR}
+
 if(OPENCL_ENABLED_SPIRV) # BUILD OpenCL intermediate code for SPIR-V target
   # executes clang to create llvm IL code
   # Add -fintegrated-objemitter once we switch to clang >= 17
@@ -71,6 +76,7 @@ if(OPENCL_ENABLED) # BUILD OpenCL source code for runtime compilation target
   add_custom_command(
       OUTPUT ${CL_BIN}.src
       COMMAND ${LLVM_CLANG}
+              -target spir64
               -Wno-unused-command-line-argument
               ${OCL_FLAGS}
               ${OCL_DEFINECL}
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
index ffdc34d6c9881..3f58c0fea75e9 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
@@ -70,6 +70,8 @@ typedef signed char int8_t;
 #endif
 #define assert(param)
 
+#include "GPUCommonDef.h"
+#include "GPUCommonTypeTraits.h" // TODO: Once possible in OpenCL, should use GPUStdSystemHeaders.h here
 #include "GPUConstantMem.h"
 #include "GPUReconstructionIncludesDeviceAll.h"
 
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.h b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
index 6cc1e7266e722..3e9623e23559b 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
@@ -20,9 +20,9 @@
 // These are basic and non-complex data types, which will also be visible on the GPU.
 // Please add complex data types required on the host but not GPU to GPUHostDataTypes.h and forward-declare!
 #ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits> // for bitfield below
 #include <cstddef>
 #endif
-#include "GPUCommonTypeTraits.h"
 #include "GPUTRDDef.h"
 
 struct AliHLTTPCClusterMCLabel;
diff --git a/GPU/GPUTracking/Definitions/GPUGetConstexpr.h b/GPU/GPUTracking/Definitions/GPUGetConstexpr.h
index 8001b4e98c83f..b70890738e1b7 100644
--- a/GPU/GPUTracking/Definitions/GPUGetConstexpr.h
+++ b/GPU/GPUTracking/Definitions/GPUGetConstexpr.h
@@ -16,7 +16,9 @@
 #define GPUGETCONSTEXPR_H
 
 #include "GPUCommonDef.h"
-#include "GPUCommonTypeTraits.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits>
+#endif
 
 // This is a temporary workaround required for clang (with c++20), until we can go to C++23 with P2280R4, which allows getting constexpr static values from references
 
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index 502a70cb57762..a1993ec4a0ffa 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -28,7 +28,10 @@
 #include "GPUCommonArray.h"
 #include "GPUParam.h"
 #include "GPUTrackParamConvert.h"
-#include "GPUCommonTypeTraits.h"
+
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits>
+#endif
 
 using namespace o2::gpu;
 using namespace o2::track;
diff --git a/GPU/GPUTracking/Standalone/cmake/config.cmake b/GPU/GPUTracking/Standalone/cmake/config.cmake
index 1de0cfa27d7ee..0c7544aff7035 100644
--- a/GPU/GPUTracking/Standalone/cmake/config.cmake
+++ b/GPU/GPUTracking/Standalone/cmake/config.cmake
@@ -30,7 +30,7 @@ set(GPUCA_BUILD_DEBUG 0)
 set(GPUCA_BUILD_DEBUG_SANITIZE 0)
 set(GPUCA_DETERMINISTIC_MODE 0)             # OFF / NO_FAST_MATH / OPTO2 / GPU / WHOLEO2
 #set(GPUCA_CUDA_GCCBIN c++-14)
-#set(GPUCA_OPENCL_CLANGBIN clang-19)
+#set(GPUCA_OPENCL_CLANGBIN clang-20)
 set(HIP_AMDGPUTARGET "default")             # "gfx906;gfx908;gfx90a"
 set(CUDA_COMPUTETARGET "default")           # 86 89
 #set(GPUCA_CUDA_COMPILE_MODE perkernel)     # onefile / perkernel / rtc
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.cxx b/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.cxx
index d18f04e554043..dea4cdbca430e 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.cxx
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.cxx
@@ -15,10 +15,13 @@
 #include "GPUTRDTrackerKernels.h"
 #include "GPUTRDGeometry.h"
 #include "GPUConstantMem.h"
-#include "GPUCommonTypeTraits.h"
 
 #include "GPUReconstructionThreading.h"
 
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits>
+#endif
+
 using namespace o2::gpu;
 
 template <int32_t I, class T>
diff --git a/GPU/GPUTracking/utils/bitfield.h b/GPU/GPUTracking/utils/bitfield.h
index a3a3ac9a5bd95..c5df80f1d6277 100644
--- a/GPU/GPUTracking/utils/bitfield.h
+++ b/GPU/GPUTracking/utils/bitfield.h
@@ -15,10 +15,6 @@
 #ifndef Q_BITFIELD_H
 #define Q_BITFIELD_H
 
-#if !defined(GPUCA_GPUCODE_DEVICE) && !defined(GPUCA_GPUCODE_COMPILEKERNELS)
-#include <type_traits>
-#endif
-
 template <class T, class S>
 class bitfield
 {
@@ -93,6 +89,7 @@ class bitfield
   }
 
 #if !defined(GPUCA_GPUCODE_DEVICE)
+  static_assert(std::is_void_v<void>, "type_traits header missing");
   static_assert(std::is_integral_v<S>, "Storage type non integral");
   static_assert(sizeof(S) >= sizeof(T), "Storage type has insufficient capacity");
 #endif

From a9e52c1e0175a24e673c74ec9bf2d8bf03017c0b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 15 May 2025 14:34:58 +0200
Subject: [PATCH 0365/1764] GPU: Rename some misleading flag names

---
 GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx          | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx        | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.h        | 8 ++++----
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx      | 6 +++---
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx         | 2 +-
 6 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h b/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
index 3c86dbfcd8d18..4ddd70efb5d1c 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
@@ -35,7 +35,7 @@ struct GPUTPCGMMergedTrackHit {
                   flagRejectDistance = 0x20,
                   flagRejectErr = 0x40,
                   flagReject = 0x60,
-                  flagNotFit = 0x80 };
+                  flagHighIncl = 0x80 };
 };
 
 struct GPUTPCGMMergedTrackHitXYZ {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 73ca449252d1d..1d5a7a0b1df47 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1895,7 +1895,7 @@ GPUd() void GPUTPCGMMerger::Finalize1(int32_t nBlocks, int32_t nThreads, int32_t
       uint8_t clusterState = mClusters[trk.FirstClusterRef() + j].state;
       if (!(clusterState & GPUTPCGMMergedTrackHit::flagReject)) {
         weight |= attachGood;
-      } else if (clusterState & GPUTPCGMMergedTrackHit::flagNotFit) {
+      } else if (clusterState & GPUTPCGMMergedTrackHit::flagHighIncl) {
         weight |= attachHighIncl;
       }
       if (mClusters[trk.FirstClusterRef() + j].leg == goodLeg) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 7bb28a9f22e31..74a8df388d163 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -32,7 +32,7 @@ using namespace o2::gpu;
 using namespace o2::tpc;
 using namespace o2::tpc::constants;
 
-GPUdi() static constexpr uint8_t getFlagsReject() { return GPUTPCGMMergedTrackHit::flagReject | GPUTPCGMMergedTrackHit::flagNotFit; }
+GPUdi() static constexpr uint8_t getFlagsReject() { return GPUTPCGMMergedTrackHit::flagReject | GPUTPCGMMergedTrackHit::flagHighIncl; }
 GPUdi() static uint32_t getFlagsRequired(const GPUSettingsRec& rec) { return rec.tpc.dropSecondaryLegsInOutput ? gputpcgmmergertypes::attachGoodLeg : gputpcgmmergertypes::attachZero; }
 
 namespace o2::gpu::internal
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
index db7a3b5884a12..97b307ce7a550 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
@@ -53,9 +53,9 @@ class GPUTPCGMPropagator
     updateErrorFitFailed = -1,
     updateErrorClusterRejected = 2,
     updateErrorClusterRejectedDistance = 2,
-    updateErrorEdgeCluster = 3,
-    updateErrorClusterRejectedInInterpolation = 4,
-    updateErrorClusterRejectedInUpdate = 5
+    updateErrorClusterRejectedInInterpolation = 3,
+    updateErrorClusterRejectedInUpdate = 4,
+    updateErrorClusterRejectedEdge = 5
   };
   enum RejectChi2Mode {
     rejectDirect = 1,
@@ -188,7 +188,7 @@ class GPUTPCGMPropagator
   GPUTPCGMPhysicalTrackModel mT0;
   MaterialCorrection mMaterial;
   FieldRegion mFieldRegion = TPC;
-  bool mSeedingErrors = 0;
+  bool mSeedingErrors = 0;    // TODO: Hide variable in Run3 mode
   bool mFitInProjections = 1; // fit (Y,SinPhi,QPt) and (Z,DzDs) paramteres separatelly
   bool mPropagateBzOnly = 0;  // Use Bz only in propagation
   bool mToyMCEvents = 0;      // events are simulated with simple home-made simulation
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 1072e4b178bdf..aed42e4f98f0c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -299,7 +299,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         if (mC[0] > param.rec.tpc.trackFitCovLimit || mC[2] > param.rec.tpc.trackFitCovLimit) {
           break;
         }
-        MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagNotFit);
+        MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagHighIncl);
         nMissed2++;
         NTolerated++;
         CADEBUG(printf(" --- break (%d, %d)\n", err, err2));
@@ -334,7 +334,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 #endif
         GPUCA_DEBUG_STREAMER_CHECK(GPUTPCGMPropagator::DebugStreamerVals debugVals;);
         if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowModification
-          retVal = GPUTPCGMPropagator::updateErrorEdgeCluster;
+          retVal = GPUTPCGMPropagator::updateErrorClusterRejectedEdge;
         } else {
           const float time = merger->GetConstantMem()->ioPtrs.clustersNative ? merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].getTime() : -1.f;
           const float invSqrtCharge = merger->GetConstantMem()->ioPtrs.clustersNative ? CAMath::InvSqrt(merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].qMax) : 0.f;
@@ -363,7 +363,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         lastUpdateX = mX;
         covYYUpd = mC[0];
         nMissed = nMissed2 = 0;
-        UnmarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagNotFit);
+        UnmarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagHighIncl);
         N++;
         ihitStart = ihit;
         float dy = mP[0] - prop.Model().Y();
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index a1993ec4a0ffa..b74c1bb6a4534 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -268,7 +268,7 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
         if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
           const auto& hit = mPtrackHits[trkX.FirstClusterRef() + i];
           cl = &mPclusterNative->clustersLinear[hit.num];
-          if (hit.state & (GPUTPCGMMergedTrackHit::flagReject | GPUTPCGMMergedTrackHit::flagNotFit)) {
+          if (hit.state & (GPUTPCGMMergedTrackHit::flagReject | GPUTPCGMMergedTrackHit::flagHighIncl)) {
             cl = nullptr;
             if (i + direction != stop) {
               i += direction;

From 132943deb4940ec93748ebbc419ccaa90ca29247 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 15 May 2025 14:57:54 +0200
Subject: [PATCH 0366/1764] GPU: Use <array> instead of GPUCommonArray for CUDA
 / ROCm, not yet for OpenCL...

---
 .../DCAFitter/include/DCAFitter/DCAFitterN.h  | 68 +++++++++----------
 .../MathUtils/include/MathUtils/SMatrixGPU.h  |  8 +--
 .../include/MathUtils/detail/basicMath.h      | 11 +--
 .../include/MathUtils/detail/trigonometric.h  | 13 ++--
 .../ITS/include/DataFormatsITS/TrackITS.h     |  8 +--
 .../include/ReconstructionDataFormats/DCA.h   |  4 +-
 .../TrackParametrization.h                    | 10 +--
 .../TrackParametrizationWithError.h           |  8 +--
 .../ReconstructionDataFormats/TrackUtils.h    |  6 +-
 .../ReconstructionDataFormats/Vertex.h        | 12 ++--
 .../src/TrackParametrization.cxx              |  6 +-
 .../src/TrackParametrizationWithError.cxx     | 10 +--
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx |  2 +-
 Detectors/Align/src/AlignableDetectorTPC.cxx  |  4 +-
 .../Base/include/DetectorsBase/Propagator.h   |  6 +-
 Detectors/Base/src/Propagator.cxx             |  8 +--
 .../postprocessing/studies/src/Efficiency.cxx | 12 ++--
 .../studies/src/ImpactParameter.cxx           |  2 +-
 .../GPU/ITStrackingGPU/VertexingKernels.h     |  4 +-
 .../ITS/tracking/GPU/cuda/VertexingKernels.cu |  4 +-
 .../tracking/include/ITStracking/Cluster.h    | 15 ++--
 .../tracking/include/ITStracking/Constants.h  | 28 ++++----
 Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx |  8 ++-
 Detectors/TPC/qc/src/Tracks.cxx               |  6 +-
 .../TPC/workflow/src/MIPTrackFilterSpec.cxx   |  2 +-
 Detectors/TPC/workflow/src/TPCRefitter.cxx    |  2 +-
 .../TPC/workflow/src/TPCTimeSeriesSpec.cxx    | 10 +--
 GPU/Common/GPUCommonArray.h                   | 12 ++--
 GPU/Common/GPUCommonTypeTraits.h              |  3 +-
 GPU/GPUTracking/Base/GPUStdSystemHeaders.h    |  1 +
 .../Base/opencl/GPUReconstructionOCL.cl       |  1 +
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |  4 +-
 .../TRDTracking/GPUTRDInterfaces.h            |  8 +--
 33 files changed, 156 insertions(+), 150 deletions(-)

diff --git a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
index 569b3ea49e515..aac451f1f8978 100644
--- a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
+++ b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
@@ -110,11 +110,11 @@ class DCAFitterN
   using MatSymND = o2::math_utils::SMatrix<double, N, N, o2::math_utils::MatRepSym<double, N>>;
   using MatStdND = o2::math_utils::SMatrix<double, N, N, o2::math_utils::MatRepStd<double, N>>;
   using TrackCoefVtx = MatStd3D;
-  using ArrTrack = o2::gpu::gpustd::array<Track, N>;         // container for prongs (tracks) at single vertex cand.
-  using ArrTrackCovI = o2::gpu::gpustd::array<TrackCovI, N>; // container for inv.cov.matrices at single vertex cand.
-  using ArrTrCoef = o2::gpu::gpustd::array<TrackCoefVtx, N>; // container of TrackCoefVtx coefficients at single vertex cand.
-  using ArrTrDer = o2::gpu::gpustd::array<TrackDeriv, N>;    // container of Track 1st and 2nd derivative over their X param
-  using ArrTrPos = o2::gpu::gpustd::array<Vec3D, N>;         // container of Track positions
+  using ArrTrack = std::array<Track, N>;         // container for prongs (tracks) at single vertex cand.
+  using ArrTrackCovI = std::array<TrackCovI, N>; // container for inv.cov.matrices at single vertex cand.
+  using ArrTrCoef = std::array<TrackCoefVtx, N>; // container of TrackCoefVtx coefficients at single vertex cand.
+  using ArrTrDer = std::array<TrackDeriv, N>;    // container of Track 1st and 2nd derivative over their X param
+  using ArrTrPos = std::array<Vec3D, N>;         // container of Track positions
 
  public:
   enum BadCovPolicy : uint8_t { // if encountering non-positive defined cov. matrix, the choice is:
@@ -158,7 +158,7 @@ class DCAFitterN
   GPUd() const auto getPCACandidatePos(int cand = 0) const
   {
     const auto& vd = mPCA[mOrder[cand]];
-    return o2::gpu::gpustd::array<float, 3>{static_cast<float>(vd[0]), static_cast<float>(vd[1]), static_cast<float>(vd[2])};
+    return std::array<float, 3>{static_cast<float>(vd[0]), static_cast<float>(vd[1]), static_cast<float>(vd[2])};
   }
 
   ///< return position of quality-ordered candidate in the internal structures
@@ -213,7 +213,7 @@ class DCAFitterN
 
   GPUd() MatSym3D calcPCACovMatrix(int cand = 0) const;
 
-  o2::gpu::gpustd::array<float, 6> calcPCACovMatrixFlat(int cand = 0) const
+  std::array<float, 6> calcPCACovMatrixFlat(int cand = 0) const
   {
     auto m = calcPCACovMatrix(cand);
     return {static_cast<float>(m(0, 0)), static_cast<float>(m(1, 0)), static_cast<float>(m(1, 1)), static_cast<float>(m(2, 0)), static_cast<float>(m(2, 1)), static_cast<float>(m(2, 2))};
@@ -364,39 +364,39 @@ class DCAFitterN
 
  private:
   // vectors of 1st derivatives of track local residuals over X parameters
-  o2::gpu::gpustd::array<o2::gpu::gpustd::array<Vec3D, N>, N> mDResidDx;
+  std::array<std::array<Vec3D, N>, N> mDResidDx;
   // vectors of 1nd derivatives of track local residuals over X parameters
   // (cross-derivatives DR/(dx_j*dx_k) = 0 for j!=k, therefore the hessian is diagonal)
-  o2::gpu::gpustd::array<o2::gpu::gpustd::array<Vec3D, N>, N> mD2ResidDx2;
+  std::array<std::array<Vec3D, N>, N> mD2ResidDx2;
   VecND mDChi2Dx;      // 1st derivatives of chi2 over tracks X params
   MatSymND mD2Chi2Dx2; // 2nd derivatives of chi2 over tracks X params (symmetric matrix)
   MatSymND mCosDif;    // matrix with cos(alp_j-alp_i) for j<i
   MatSymND mSinDif;    // matrix with sin(alp_j-alp_i) for j<i
-  o2::gpu::gpustd::array<const Track*, N> mOrigTrPtr;
-  o2::gpu::gpustd::array<TrackAuxPar, N> mTrAux; // Aux track info for each track at each cand. vertex
-  CrossInfo mCrossings;                          // info on track crossing
-
-  o2::gpu::gpustd::array<ArrTrackCovI, MAXHYP> mTrcEInv; // errors for each track at each cand. vertex
-  o2::gpu::gpustd::array<ArrTrack, MAXHYP> mCandTr;      // tracks at each cond. vertex (Note: Errors are at seed XY point)
-  o2::gpu::gpustd::array<ArrTrCoef, MAXHYP> mTrCFVT;     // TrackCoefVtx for each track at each cand. vertex
-  o2::gpu::gpustd::array<ArrTrDer, MAXHYP> mTrDer;       // Track derivativse
-  o2::gpu::gpustd::array<ArrTrPos, MAXHYP> mTrPos;       // Track positions
-  o2::gpu::gpustd::array<ArrTrPos, MAXHYP> mTrRes;       // Track residuals
-  o2::gpu::gpustd::array<Vec3D, MAXHYP> mPCA;            // PCA for each vertex candidate
-  o2::gpu::gpustd::array<float, MAXHYP> mChi2 = {0};     // Chi2 at PCA candidate
-  o2::gpu::gpustd::array<int, MAXHYP> mNIters;           // number of iterations for each seed
-  o2::gpu::gpustd::array<bool, MAXHYP> mTrPropDone{};    // Flag that the tracks are fully propagated to PCA
-  o2::gpu::gpustd::array<bool, MAXHYP> mPropFailed{};    // Flag that some propagation failed for this PCA candidate
+  std::array<const Track*, N> mOrigTrPtr;
+  std::array<TrackAuxPar, N> mTrAux; // Aux track info for each track at each cand. vertex
+  CrossInfo mCrossings;              // info on track crossing
+
+  std::array<ArrTrackCovI, MAXHYP> mTrcEInv; // errors for each track at each cand. vertex
+  std::array<ArrTrack, MAXHYP> mCandTr;      // tracks at each cond. vertex (Note: Errors are at seed XY point)
+  std::array<ArrTrCoef, MAXHYP> mTrCFVT;     // TrackCoefVtx for each track at each cand. vertex
+  std::array<ArrTrDer, MAXHYP> mTrDer;       // Track derivativse
+  std::array<ArrTrPos, MAXHYP> mTrPos;       // Track positions
+  std::array<ArrTrPos, MAXHYP> mTrRes;       // Track residuals
+  std::array<Vec3D, MAXHYP> mPCA;            // PCA for each vertex candidate
+  std::array<float, MAXHYP> mChi2 = {0};     // Chi2 at PCA candidate
+  std::array<int, MAXHYP> mNIters;           // number of iterations for each seed
+  std::array<bool, MAXHYP> mTrPropDone{};    // Flag that the tracks are fully propagated to PCA
+  std::array<bool, MAXHYP> mPropFailed{};    // Flag that some propagation failed for this PCA candidate
   LogLogThrottler mLoggerBadCov{};
   LogLogThrottler mLoggerBadInv{};
   LogLogThrottler mLoggerBadProp{};
   MatSym3D mWeightInv; // inverse weight of single track, [sum{M^T E M}]^-1 in EQ.T
-  o2::gpu::gpustd::array<int, MAXHYP> mOrder{0};
+  std::array<int, MAXHYP> mOrder{0};
   int mCurHyp = 0;
   int mCrossIDCur = 0;
   int mCrossIDAlt = -1;
   BadCovPolicy mBadCovPolicy{BadCovPolicy::Discard};                                              // what to do in case of non-pos-def. cov. matrix, see BadCovPolicy enum
-  o2::gpu::gpustd::array<FitStatus, MAXHYP> mFitStatus{};                                         // fit status of each hypothesis fit
+  std::array<FitStatus, MAXHYP> mFitStatus{};                                                     // fit status of each hypothesis fit
   bool mAllowAltPreference = true;                                                                // if the fit converges to alternative PCA seed, abandon the current one
   bool mUseAbsDCA = false;                                                                        // use abs. distance minimization rather than chi2
   bool mWeightedFinalPCA = false;                                                                 // recalculate PCA as a cov-matrix weighted mean, even if absDCA method was used
@@ -657,7 +657,7 @@ template <int N, typename... Args>
 GPUd() void DCAFitterN<N, Args...>::calcChi2Derivatives()
 {
   //< calculate 1st and 2nd derivatives of wighted DCA (chi2) over track parameters X, see EQ.Chi2 in the ref
-  o2::gpu::gpustd::array<o2::gpu::gpustd::array<Vec3D, N>, N> covIDrDx; // tempory vectors of covI_j * dres_j/dx_i
+  std::array<std::array<Vec3D, N>, N> covIDrDx; // tempory vectors of covI_j * dres_j/dx_i
 
   // chi2 1st derivative
   for (int i = N; i--;) {
@@ -1175,13 +1175,13 @@ GPUd() o2::track::TrackParCov DCAFitterN<N, Args...>::createParentTrackParCov(in
 {
   const auto& trP = getTrack(0, cand);
   const auto& trN = getTrack(1, cand);
-  o2::gpu::gpustd::array<float, 21> covV = {0.};
-  o2::gpu::gpustd::array<float, 3> pvecV = {0.};
+  std::array<float, 21> covV = {0.};
+  std::array<float, 3> pvecV = {0.};
   int q = 0;
   for (int it = 0; it < N; it++) {
     const auto& trc = getTrack(it, cand);
-    o2::gpu::gpustd::array<float, 3> pvecT = {0.};
-    o2::gpu::gpustd::array<float, 21> covT = {0.};
+    std::array<float, 3> pvecT = {0.};
+    std::array<float, 21> covT = {0.};
     trc.getPxPyPzGlo(pvecT);
     trc.getCovXYZPxPyPzGlo(covT);
     constexpr int MomInd[6] = {9, 13, 14, 18, 19, 20}; // cov matrix elements for momentum component
@@ -1210,18 +1210,18 @@ GPUd() o2::track::TrackPar DCAFitterN<N, Args...>::createParentTrackPar(int cand
   const auto& trP = getTrack(0, cand);
   const auto& trN = getTrack(1, cand);
   const auto& wvtx = getPCACandidate(cand);
-  o2::gpu::gpustd::array<float, 3> pvecV = {0.};
+  std::array<float, 3> pvecV = {0.};
   int q = 0;
   for (int it = 0; it < N; it++) {
     const auto& trc = getTrack(it, cand);
-    o2::gpu::gpustd::array<float, 3> pvecT = {0.};
+    std::array<float, 3> pvecT = {0.};
     trc.getPxPyPzGlo(pvecT);
     for (int i = 0; i < 3; i++) {
       pvecV[i] += pvecT[i];
     }
     q += trc.getCharge();
   }
-  const o2::gpu::gpustd::array<float, 3> vertex = {(float)wvtx[0], (float)wvtx[1], (float)wvtx[2]};
+  const std::array<float, 3> vertex = {(float)wvtx[0], (float)wvtx[1], (float)wvtx[2]};
   return o2::track::TrackPar(vertex, pvecV, q, sectorAlpha);
 }
 
diff --git a/Common/MathUtils/include/MathUtils/SMatrixGPU.h b/Common/MathUtils/include/MathUtils/SMatrixGPU.h
index 675719cfc0751..8158a93666a92 100644
--- a/Common/MathUtils/include/MathUtils/SMatrixGPU.h
+++ b/Common/MathUtils/include/MathUtils/SMatrixGPU.h
@@ -25,12 +25,12 @@
 #define ALICEO2_SMATRIX_GPU_H
 
 #include "GPUCommonDef.h"
-#include "GPUCommonArray.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonAlgorithm.h"
 #include "GPUCommonLogger.h"
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <type_traits>
+#include <array>
 #endif
 
 namespace o2::math_utils::detail
@@ -283,14 +283,14 @@ struct make_indices : make_indices_impl<0, indices<>, N> {
 };
 
 template <int I0, class F, int... I>
-constexpr auto do_make(F f, indices<I...>) -> gpu::gpustd::array<int, sizeof...(I)>
+constexpr auto do_make(F f, indices<I...>) -> std::array<int, sizeof...(I)>
 {
-  gpu::gpustd::array<int, sizeof...(I)> retarr = {f(I0 + I)...};
+  std::array<int, sizeof...(I)> retarr = {f(I0 + I)...};
   return retarr;
 }
 
 template <int N, int I0 = 0, class F>
-constexpr auto make(F f) -> gpu::gpustd::array<int, N>
+constexpr auto make(F f) -> std::array<int, N>
 {
   return do_make<I0>(f, typename make_indices<N>::type());
 }
diff --git a/Common/MathUtils/include/MathUtils/detail/basicMath.h b/Common/MathUtils/include/MathUtils/detail/basicMath.h
index 3565764435a68..1abe6ee878c39 100644
--- a/Common/MathUtils/include/MathUtils/detail/basicMath.h
+++ b/Common/MathUtils/include/MathUtils/detail/basicMath.h
@@ -16,14 +16,15 @@
 #ifndef MATHUTILS_INCLUDE_MATHUTILS_DETAIL_BASICMATH_H_
 #define MATHUTILS_INCLUDE_MATHUTILS_DETAIL_BASICMATH_H_
 
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
+#include "CommonConstants/MathConstants.h"
+
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <cmath>
 #include <tuple>
+#include <array>
 #endif
-#include "GPUCommonArray.h"
-#include "GPUCommonDef.h"
-#include "GPUCommonMath.h"
-#include "CommonConstants/MathConstants.h"
 
 namespace o2
 {
@@ -130,4 +131,4 @@ GPUdi() double log(double x)
 } // namespace math_utils
 } // namespace o2
 
-#endif /* MATHUTILS_INCLUDE_MATHUTILS_DETAIL_BASICMATH_H_ */
\ No newline at end of file
+#endif /* MATHUTILS_INCLUDE_MATHUTILS_DETAIL_BASICMATH_H_ */
diff --git a/Common/MathUtils/include/MathUtils/detail/trigonometric.h b/Common/MathUtils/include/MathUtils/detail/trigonometric.h
index 462affdceb17f..457210202ca54 100644
--- a/Common/MathUtils/include/MathUtils/detail/trigonometric.h
+++ b/Common/MathUtils/include/MathUtils/detail/trigonometric.h
@@ -16,16 +16,17 @@
 #ifndef MATHUTILS_INCLUDE_MATHUTILS_DETAIL_TRIGONOMETRIC_H_
 #define MATHUTILS_INCLUDE_MATHUTILS_DETAIL_TRIGONOMETRIC_H_
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <cmath>
-#include <tuple>
-#endif
-#include "GPUCommonArray.h"
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
 #include "CommonConstants/MathConstants.h"
 #include "MathUtils/detail/basicMath.h"
 
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <cmath>
+#include <tuple>
+#include <array>
+#endif
+
 namespace o2
 {
 namespace math_utils
@@ -156,7 +157,7 @@ GPUhdi() std::tuple<T, T> rotateZInv(T xG, T yG, T snAlp, T csAlp)
 #endif
 
 template <typename T>
-GPUhdi() void rotateZ(gpu::gpustd::array<T, 3>& xy, T alpha)
+GPUhdi() void rotateZ(std::array<T, 3>& xy, T alpha)
 {
   // transforms vector in tracking frame alpha to global frame
   T sin, cos;
diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
index e9931b89ecd4a..06d4fba51bd54 100644
--- a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
+++ b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
@@ -170,14 +170,14 @@ class TrackITSExt : public TrackITS
   using TrackITS::TrackITS;              // inherit base constructors
 
   GPUh() TrackITSExt(o2::track::TrackParCov&& parCov, short ncl, float chi2,
-                     o2::track::TrackParCov&& outer, o2::gpu::gpustd::array<int, MaxClusters> cls)
+                     o2::track::TrackParCov&& outer, std::array<int, MaxClusters> cls)
     : TrackITS(parCov, chi2, outer), mIndex{cls}
   {
     setNumberOfClusters(ncl);
   }
 
   GPUh() TrackITSExt(o2::track::TrackParCov& parCov, short ncl, float chi2, std::uint32_t rof,
-                     o2::track::TrackParCov& outer, o2::gpu::gpustd::array<int, MaxClusters> cls)
+                     o2::track::TrackParCov& outer, std::array<int, MaxClusters> cls)
     : TrackITS(parCov, chi2, outer), mIndex{cls}
   {
     setNumberOfClusters(ncl);
@@ -205,13 +205,13 @@ class TrackITSExt : public TrackITS
     mIndex[layer] = idx;
   }
 
-  GPUh() o2::gpu::gpustd::array<int, MaxClusters>& getClusterIndexes()
+  GPUh() std::array<int, MaxClusters>& getClusterIndexes()
   {
     return mIndex;
   }
 
  private:
-  o2::gpu::gpustd::array<int, MaxClusters> mIndex = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; ///< Indices of associated clusters
+  std::array<int, MaxClusters> mIndex = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; ///< Indices of associated clusters
   ClassDefNV(TrackITSExt, 2);
 };
 } // namespace its
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/DCA.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/DCA.h
index 922470f8992f5..6eb41b798e101 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/DCA.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/DCA.h
@@ -14,10 +14,10 @@
 
 #include "GPUCommonDef.h"
 #include "GPUCommonRtypes.h"
-#include "GPUCommonArray.h"
 
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <iosfwd>
+#include <array>
 #endif
 
 /// \author ruben.shahoyan@cern.ch
@@ -67,7 +67,7 @@ class DCA
  private:
   float mY = 0.f;
   float mZ = 0.f;
-  gpu::gpustd::array<float, 3> mCov; ///< s2y, syz, s2z
+  std::array<float, 3> mCov; ///< s2y, syz, s2z
 
   ClassDefNV(DCA, 1);
 };
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index bfd56eb8f024f..f240e34861eeb 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -29,7 +29,6 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonRtypes.h"
 #include "GPUCommonMath.h"
-#include "GPUCommonArray.h"
 #include "GPUROOTCartesianFwd.h"
 
 #ifndef GPUCA_GPUCODE_DEVICE
@@ -39,6 +38,7 @@
 #include <cstring>
 #include <iosfwd>
 #include <type_traits>
+#include <array>
 #endif
 
 #ifndef GPUCA_ALIGPUCODE // Used only by functions that are hidden on the GPU
@@ -128,9 +128,9 @@ class TrackParametrization
 
  public:
   using value_t = value_T;
-  using dim2_t = gpu::gpustd::array<value_t, 2>;
-  using dim3_t = gpu::gpustd::array<value_t, 3>;
-  using params_t = gpu::gpustd::array<value_t, kNParams>;
+  using dim2_t = std::array<value_t, 2>;
+  using dim3_t = std::array<value_t, 3>;
+  using params_t = std::array<value_t, kNParams>;
 
   struct yzerr_t { // 2 measurement with error
     dim2_t yz;
@@ -209,7 +209,7 @@ class TrackParametrization
   GPUd() math_utils::Point3D<value_t> getXYZGlo() const;
   GPUd() void getXYZGlo(dim3_t& xyz) const;
   GPUd() bool getPxPyPzGlo(dim3_t& pxyz) const;
-  GPUd() bool getPosDirGlo(gpu::gpustd::array<value_t, 9>& posdirp) const;
+  GPUd() bool getPosDirGlo(std::array<value_t, 9>& posdirp) const;
 
   // methods for track params estimate at other point
   GPUd() bool getYZAt(value_t xk, value_t b, value_t& y, value_t& z) const;
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
index cc783298e14cd..cd9d1517a81b1 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
@@ -38,14 +38,14 @@ class TrackParametrizationWithError : public TrackParametrization<value_T>
   static_assert(std::is_floating_point_v<value_t>);
 #endif
 
-  using covMat_t = gpu::gpustd::array<value_t, kCovMatSize>;
+  using covMat_t = std::array<value_t, kCovMatSize>;
   using MatrixDSym5 = o2::math_utils::SMatrix<double, kNParams, kNParams, o2::math_utils::MatRepSym<double, kNParams>>;
   using MatrixD5 = o2::math_utils::SMatrix<double, kNParams, kNParams, o2::math_utils::MatRepStd<double, kNParams, kNParams>>;
 
   GPUhd() TrackParametrizationWithError();
   GPUd() TrackParametrizationWithError(value_t x, value_t alpha, const params_t& par, const covMat_t& cov, int charge = 1, const PID pid = PID::Pion);
   GPUd() TrackParametrizationWithError(const dim3_t& xyz, const dim3_t& pxpypz,
-                                       const gpu::gpustd::array<value_t, kLabCovMatSize>& cv, int sign, bool sectorAlpha = true, const PID pid = PID::Pion);
+                                       const std::array<value_t, kLabCovMatSize>& cv, int sign, bool sectorAlpha = true, const PID pid = PID::Pion);
 
   GPUhdDefault() TrackParametrizationWithError(const TrackParametrizationWithError& src) = default;
   GPUdDefault() TrackParametrizationWithError(TrackParametrizationWithError&& src) = default;
@@ -57,7 +57,7 @@ class TrackParametrizationWithError : public TrackParametrization<value_T>
   using TrackParametrization<value_T>::set;
   GPUd() void set(value_t x, value_t alpha, const params_t& par, const covMat_t& cov, int charge = 1, const PID pid = PID::Pion);
   GPUd() void set(value_t x, value_t alpha, const value_t* par, const value_t* cov, int charge = 1, const PID pid = PID::Pion);
-  GPUd() void set(const dim3_t& xyz, const dim3_t& pxpypz, const gpu::gpustd::array<value_t, kLabCovMatSize>& cv, int sign, bool sectorAlpha = true, const PID pid = PID::Pion);
+  GPUd() void set(const dim3_t& xyz, const dim3_t& pxpypz, const std::array<value_t, kLabCovMatSize>& cv, int sign, bool sectorAlpha = true, const PID pid = PID::Pion);
   GPUd() const covMat_t& getCov() const;
   GPUd() value_t getSigmaY2() const;
   GPUd() value_t getSigmaZY() const;
@@ -77,7 +77,7 @@ class TrackParametrizationWithError : public TrackParametrization<value_T>
   GPUd() value_t getCovarElem(int i, int j) const;
   GPUd() value_t getDiagError2(int i) const;
 
-  GPUd() bool getCovXYZPxPyPzGlo(gpu::gpustd::array<value_t, kLabCovMatSize>& c) const;
+  GPUd() bool getCovXYZPxPyPzGlo(std::array<value_t, kLabCovMatSize>& c) const;
 
   GPUd() void print() const;
   GPUd() void printHexadecimal();
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackUtils.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackUtils.h
index 0ee0ca4461ab0..8a79130d64eda 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackUtils.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackUtils.h
@@ -18,9 +18,9 @@
 #define INCLUDE_RECONSTRUCTIONDATAFORMATS_TRACKUTILS_H_
 
 #include "GPUCommonRtypes.h"
-#include "GPUCommonArray.h"
 
 #ifndef GPUCA_GPUCODE_DEVICE
+#include <array>
 #include <cmath>
 #endif
 
@@ -39,11 +39,11 @@ template <typename value_T = float>
 GPUd() value_T BetheBlochSolidOpt(value_T bg);
 
 template <typename value_T = float>
-GPUd() void g3helx3(value_T qfield, value_T step, gpu::gpustd::array<value_T, 7>& vect);
+GPUd() void g3helx3(value_T qfield, value_T step, std::array<value_T, 7>& vect);
 
 //____________________________________________________
 template <typename value_T>
-GPUd() void g3helx3(value_T qfield, value_T step, gpu::gpustd::array<value_T, 7>& vect)
+GPUd() void g3helx3(value_T qfield, value_T step, std::array<value_T, 7>& vect)
 {
   /******************************************************************
    *                                                                *
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
index d14bc7ac786c8..fc89f162a0727 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
@@ -14,7 +14,6 @@
 
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
-#include "GPUCommonArray.h"
 #include <MathUtils/Cartesian.h>
 
 #include "CommonDataFormat/TimeStamp.h"
@@ -22,6 +21,7 @@
 #include <iosfwd>
 #include <string>
 #include <type_traits>
+#include <array>
 #endif
 
 namespace o2
@@ -42,7 +42,7 @@ class VertexBase
   static constexpr int kNCov = 6;
   GPUhdDefault() VertexBase() = default;
   GPUhdDefault() ~VertexBase() = default;
-  GPUhd() VertexBase(const math_utils::Point3D<float>& pos, const gpu::gpustd::array<float, kNCov>& cov) : mPos(pos), mCov(cov)
+  GPUhd() VertexBase(const math_utils::Point3D<float>& pos, const std::array<float, kNCov>& cov) : mPos(pos), mCov(cov)
   {
   }
 
@@ -65,7 +65,7 @@ class VertexBase
   GPUd() float getSigmaY() const { return gpu::CAMath::Sqrt(getSigmaY2()); }
   GPUd() float getSigmaZ() const { return gpu::CAMath::Sqrt(getSigmaZ2()); }
 
-  GPUd() const gpu::gpustd::array<float, kNCov>& getCov() const { return mCov; }
+  GPUd() const std::array<float, kNCov>& getCov() const { return mCov; }
 
   GPUd() math_utils::Point3D<float> getXYZ() const { return mPos; }
   GPUd() math_utils::Point3D<float>& getXYZ() { return mPos; }
@@ -101,14 +101,14 @@ class VertexBase
     setSigmaXZ(sxz);
     setSigmaYZ(syz);
   }
-  GPUd() void setCov(const gpu::gpustd::array<float, kNCov>& cov) { mCov = cov; }
+  GPUd() void setCov(const std::array<float, kNCov>& cov) { mCov = cov; }
 
   bool operator==(const VertexBase& other) const;
   bool operator!=(const VertexBase& other) const { return !(*this == other); }
 
  protected:
   math_utils::Point3D<float> mPos{0., 0., 0.}; ///< cartesian position
-  gpu::gpustd::array<float, kNCov> mCov{};     ///< errors, see CovElems enum
+  std::array<float, kNCov> mCov{};             ///< errors, see CovElems enum
 
   ClassDefNV(VertexBase, 1);
 };
@@ -130,7 +130,7 @@ class Vertex : public VertexBase
 
   GPUhdDefault() Vertex() = default;
   GPUhdDefault() ~Vertex() = default;
-  GPUhd() Vertex(const math_utils::Point3D<float>& pos, const gpu::gpustd::array<float, kNCov>& cov, ushort nCont, float chi2)
+  GPUhd() Vertex(const math_utils::Point3D<float>& pos, const std::array<float, kNCov>& cov, ushort nCont, float chi2)
     : VertexBase(pos, cov), mChi2(chi2), mNContributors(nCont)
   {
   }
diff --git a/DataFormats/Reconstruction/src/TrackParametrization.cxx b/DataFormats/Reconstruction/src/TrackParametrization.cxx
index 4b68ea425bfbd..1bdf9b55a60a0 100644
--- a/DataFormats/Reconstruction/src/TrackParametrization.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrization.cxx
@@ -130,7 +130,7 @@ GPUd() bool TrackParametrization<value_T>::getPxPyPzGlo(dim3_t& pxyz) const
 
 //____________________________________________________
 template <typename value_T>
-GPUd() bool TrackParametrization<value_T>::getPosDirGlo(gpu::gpustd::array<value_t, 9>& posdirp) const
+GPUd() bool TrackParametrization<value_T>::getPosDirGlo(std::array<value_t, 9>& posdirp) const
 {
   // fill vector with lab x,y,z,px/p,py/p,pz/p,p,sinAlpha,cosAlpha
   value_t ptI = getPtInv();
@@ -231,7 +231,7 @@ GPUd() bool TrackParametrization<value_T>::propagateParamTo(value_t xk, const di
   step *= gpu::CAMath::Sqrt(1.f + getTgl() * getTgl());
   //
   // get the track x,y,z,px/p,py/p,pz/p,p,sinAlpha,cosAlpha in the Global System
-  gpu::gpustd::array<value_t, 9> vecLab{0.f};
+  std::array<value_t, 9> vecLab{0.f};
   if (!getPosDirGlo(vecLab)) {
     return false;
   }
@@ -250,7 +250,7 @@ GPUd() bool TrackParametrization<value_T>::propagateParamTo(value_t xk, const di
     costet = b[2] / bb;
     sintet = bt / bb;
   }
-  gpu::gpustd::array<value_t, 7> vect{costet * cosphi * vecLab[0] + costet * sinphi * vecLab[1] - sintet * vecLab[2],
+  std::array<value_t, 7> vect{costet * cosphi * vecLab[0] + costet * sinphi * vecLab[1] - sintet * vecLab[2],
                                       -sinphi * vecLab[0] + cosphi * vecLab[1],
                                       sintet * cosphi * vecLab[0] + sintet * sinphi * vecLab[1] + costet * vecLab[2],
                                       costet * cosphi * vecLab[3] + costet * sinphi * vecLab[4] - sintet * vecLab[5],
diff --git a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
index 81963adf79938..aee24238f1247 100644
--- a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
@@ -259,7 +259,7 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateToDCA(const o2::dat
 //______________________________________________________________
 template <typename value_T>
 GPUd() TrackParametrizationWithError<value_T>::TrackParametrizationWithError(const dim3_t& xyz, const dim3_t& pxpypz,
-                                                                             const gpu::gpustd::array<value_t, kLabCovMatSize>& cv, int charge, bool sectorAlpha, const PID pid)
+                                                                             const std::array<value_t, kLabCovMatSize>& cv, int charge, bool sectorAlpha, const PID pid)
 {
   // construct track param and covariance from kinematics and lab errors
   set(xyz, pxpypz, cv, charge, sectorAlpha, pid);
@@ -268,7 +268,7 @@ GPUd() TrackParametrizationWithError<value_T>::TrackParametrizationWithError(con
 //______________________________________________________________
 template <typename value_T>
 GPUd() void TrackParametrizationWithError<value_T>::set(const dim3_t& xyz, const dim3_t& pxpypz,
-                                                        const gpu::gpustd::array<value_t, kLabCovMatSize>& cv, int charge, bool sectorAlpha, const PID pid)
+                                                        const std::array<value_t, kLabCovMatSize>& cv, int charge, bool sectorAlpha, const PID pid)
 {
   // set track param and covariance from kinematics and lab errors
 
@@ -475,7 +475,7 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, cons
   step *= gpu::CAMath::Sqrt(1.f + this->getTgl() * this->getTgl());
   //
   // get the track x,y,z,px/p,py/p,pz/p,p,sinAlpha,cosAlpha in the Global System
-  gpu::gpustd::array<value_t, 9> vecLab{0.f};
+  std::array<value_t, 9> vecLab{0.f};
   if (!this->getPosDirGlo(vecLab)) {
     return false;
   }
@@ -542,7 +542,7 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, cons
     costet = b[2] / bb;
     sintet = bt / bb;
   }
-  gpu::gpustd::array<value_t, 7> vect{costet * cosphi * vecLab[0] + costet * sinphi * vecLab[1] - sintet * vecLab[2],
+  std::array<value_t, 7> vect{costet * cosphi * vecLab[0] + costet * sinphi * vecLab[1] - sintet * vecLab[2],
                                       -sinphi * vecLab[0] + cosphi * vecLab[1],
                                       sintet * cosphi * vecLab[0] + sintet * sinphi * vecLab[1] + costet * vecLab[2],
                                       costet * cosphi * vecLab[3] + costet * sinphi * vecLab[4] - sintet * vecLab[5],
@@ -1115,7 +1115,7 @@ GPUd() bool TrackParametrizationWithError<value_T>::correctForMaterial(value_t x
 
 //______________________________________________________________
 template <typename value_T>
-GPUd() bool TrackParametrizationWithError<value_T>::getCovXYZPxPyPzGlo(gpu::gpustd::array<value_t, kLabCovMatSize>& cv) const
+GPUd() bool TrackParametrizationWithError<value_T>::getCovXYZPxPyPzGlo(std::array<value_t, kLabCovMatSize>& cv) const
 {
   //---------------------------------------------------------------------
   // This function returns the global covariance matrix of the track params
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 2b133770357fc..8fb2db9c3c9a6 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -2615,7 +2615,7 @@ AODProducerWorkflowDPL::TrackQA AODProducerWorkflowDPL::processBarrelTrackQA(int
     o2::track::TrackParametrization<float> tpcTMP = tpcOrig;                                             /// get backup of the track
     const o2::base::Propagator::MatCorrType mMatType = o2::base::Propagator::MatCorrType::USEMatCorrLUT; /// should be parameterized
     const o2::dataformats::VertexBase v = mVtx.getMeanVertex(collisionID < 0 ? 0.f : data.getPrimaryVertex(collisionID).getZ());
-    o2::gpu::gpustd::array<float, 2> dcaInfo{-999., -999.};
+    std::array<float, 2> dcaInfo{-999., -999.};
     if (prop->propagateToDCABxByBz({v.getX(), v.getY(), v.getZ()}, tpcTMP, 2.f, mMatType, &dcaInfo)) {
       trackQAHolder.tpcdcaR = 100. * dcaInfo[0] / sqrt(1. + trackPar.getQ2Pt() * trackPar.getQ2Pt());
       trackQAHolder.tpcdcaZ = 100. * dcaInfo[1] / sqrt(1. + trackPar.getQ2Pt() * trackPar.getQ2Pt());
diff --git a/Detectors/Align/src/AlignableDetectorTPC.cxx b/Detectors/Align/src/AlignableDetectorTPC.cxx
index f66d9e3f3ab95..b3d2102559974 100644
--- a/Detectors/Align/src/AlignableDetectorTPC.cxx
+++ b/Detectors/Align/src/AlignableDetectorTPC.cxx
@@ -214,8 +214,8 @@ int AlignableDetectorTPC::processPoints(GIndex gid, int npntCut, bool inv)
     auto* sectSensor = (AlignableSensorTPC*)getSensor(currentSector);
     const auto* sysE = sectSensor->getAddError(); // additional syst error
 
-    gpu::gpustd::array<float, 2> p = {y, z};
-    gpu::gpustd::array<float, 3> c = {0, 0, 0};
+    std::array<float, 2> p = {y, z};
+    std::array<float, 3> c = {0, 0, 0};
     mController->getTPCParam()->GetClusterErrors2(sector, currentRow, z, trkParam.getSnp(), trkParam.getTgl(), -1.f, 0.f, 0.f, c[0], c[2]); // TODO: Note this disables occupancy / charge components of the error estimation
     mController->getTPCParam()->UpdateClusterError2ByState(clusterState, c[0], c[2]);
     int nrComb = std::abs(row - currentRow) + 1;
diff --git a/Detectors/Base/include/DetectorsBase/Propagator.h b/Detectors/Base/include/DetectorsBase/Propagator.h
index a9e2ce6e0383d..dbdef47e4edc0 100644
--- a/Detectors/Base/include/DetectorsBase/Propagator.h
+++ b/Detectors/Base/include/DetectorsBase/Propagator.h
@@ -17,7 +17,6 @@
 #define ALICEO2_BASE_PROPAGATOR_
 
 #include "GPUCommonRtypes.h"
-#include "GPUCommonArray.h"
 #include "CommonConstants/PhysicsConstants.h"
 #include "ReconstructionDataFormats/Track.h"
 #include "ReconstructionDataFormats/DCA.h"
@@ -25,6 +24,7 @@
 #include "DetectorsBase/MatLayerCylSet.h"
 
 #ifndef GPUCA_GPUCODE
+#include <array>
 #include <string>
 #endif
 
@@ -111,12 +111,12 @@ class PropagatorImpl
 
   GPUd() bool propagateToDCA(const o2::math_utils::Point3D<value_type>& vtx, o2::track::TrackParametrization<value_type>& track, value_type bZ,
                              value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
-                             gpu::gpustd::array<value_type, 2>* dca = nullptr, track::TrackLTIntegral* tofInfo = nullptr,
+                             std::array<value_type, 2>* dca = nullptr, track::TrackLTIntegral* tofInfo = nullptr,
                              int signCorr = 0, value_type maxD = 999.f) const;
 
   GPUd() bool propagateToDCABxByBz(const o2::math_utils::Point3D<value_type>& vtx, o2::track::TrackParametrization<value_type>& track,
                                    value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
-                                   gpu::gpustd::array<value_type, 2>* dca = nullptr, track::TrackLTIntegral* tofInfo = nullptr,
+                                   std::array<value_type, 2>* dca = nullptr, track::TrackLTIntegral* tofInfo = nullptr,
                                    int signCorr = 0, value_type maxD = 999.f) const;
 
   PropagatorImpl(PropagatorImpl const&) = delete;
diff --git a/Detectors/Base/src/Propagator.cxx b/Detectors/Base/src/Propagator.cxx
index 754c0c14e6f60..1c44cea65c69c 100644
--- a/Detectors/Base/src/Propagator.cxx
+++ b/Detectors/Base/src/Propagator.cxx
@@ -170,7 +170,7 @@ GPUd() bool PropagatorImpl<value_T>::PropagateToXBxByBz(TrackParCov_t& track, va
     signCorr = -dir; // sign of eloss correction is not imposed
   }
 
-  gpu::gpustd::array<value_type, 3> b{};
+  std::array<value_type, 3> b{};
   while (math_utils::detail::abs<value_type>(dx) > Epsilon) {
     auto step = math_utils::detail::min<value_type>(math_utils::detail::abs<value_type>(dx), maxStep);
     if (dir < 0) {
@@ -239,7 +239,7 @@ GPUd() bool PropagatorImpl<value_T>::PropagateToXBxByBz(TrackPar_t& track, value
     signCorr = -dir; // sign of eloss correction is not imposed
   }
 
-  gpu::gpustd::array<value_type, 3> b{};
+  std::array<value_type, 3> b{};
   while (math_utils::detail::abs<value_type>(dx) > Epsilon) {
     auto step = math_utils::detail::min<value_type>(math_utils::detail::abs<value_type>(dx), maxStep);
     if (dir < 0) {
@@ -553,7 +553,7 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCABxByBz(const o2::dataformats:
 template <typename value_T>
 GPUd() bool PropagatorImpl<value_T>::propagateToDCA(const math_utils::Point3D<value_type>& vtx, TrackPar_t& track, value_type bZ,
                                                     value_type maxStep, PropagatorImpl<value_T>::MatCorrType matCorr,
-                                                    gpu::gpustd::array<value_type, 2>* dca, track::TrackLTIntegral* tofInfo,
+                                                    std::array<value_type, 2>* dca, track::TrackLTIntegral* tofInfo,
                                                     int signCorr, value_type maxD) const
 {
   // propagate track to DCA to the vertex
@@ -601,7 +601,7 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCA(const math_utils::Point3D<va
 template <typename value_T>
 GPUd() bool PropagatorImpl<value_T>::propagateToDCABxByBz(const math_utils::Point3D<value_type>& vtx, TrackPar_t& track,
                                                           value_type maxStep, PropagatorImpl<value_T>::MatCorrType matCorr,
-                                                          gpu::gpustd::array<value_type, 2>* dca, track::TrackLTIntegral* tofInfo,
+                                                          std::array<value_type, 2>* dca, track::TrackLTIntegral* tofInfo,
                                                           int signCorr, value_type maxD) const
 {
   // propagate track to DCA to the vertex
diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/Efficiency.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/Efficiency.cxx
index bca1ec1e85001..494603641cde5 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/Efficiency.cxx
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/Efficiency.cxx
@@ -593,7 +593,7 @@ int EfficiencyStudy::getDCAClusterTrackMC(int countDuplicated = 0)
   LOGP(info, "--------------- getDCAClusterTrackMC");
 
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
-  o2::gpu::gpustd::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
+  std::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
   auto propagator = o2::base::Propagator::Instance();
 
   auto bz = o2::base::Propagator::Instance()->getNominalBz();
@@ -833,7 +833,7 @@ void EfficiencyStudy::countDuplicatedAfterCuts()
   LOGP(info, "--------------- countDuplicatedAfterCuts");
 
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
-  o2::gpu::gpustd::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
+  std::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
   auto propagator = o2::base::Propagator::Instance();
 
   unsigned int rofIndexTrack = 0;
@@ -1019,7 +1019,7 @@ void EfficiencyStudy::studyDCAcutsMC()
   //  if not, keep it as a fake match -> increase the fake match counter
   //  the efficiency of each one will be match counter / total of the duplicated clusters
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
-  o2::gpu::gpustd::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
+  std::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
   auto propagator = o2::base::Propagator::Instance();
 
   unsigned int rofIndexTrack = 0;
@@ -1346,7 +1346,7 @@ void EfficiencyStudy::studyClusterSelectionMC()
   }
 
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
-  o2::gpu::gpustd::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
+  std::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
   auto propagator = o2::base::Propagator::Instance();
 
   unsigned int rofIndexTrack = 0;
@@ -2176,7 +2176,7 @@ void EfficiencyStudy::getEfficiency(bool isMC)
   LOGP(info, "getEfficiency()");
 
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
-  o2::gpu::gpustd::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
+  std::array<float, 2> clusOriginalDCA, clusDuplicatedDCA;
   auto propagator = o2::base::Propagator::Instance();
 
   unsigned int rofIndexTrack = 0;
@@ -2860,4 +2860,4 @@ DataProcessorSpec getEfficiencyStudy(mask_t srcTracksMask, mask_t srcClustersMas
     Options{}};
 }
 
-} // namespace o2::its::study
\ No newline at end of file
+} // namespace o2::its::study
diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ImpactParameter.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ImpactParameter.cxx
index 5ca1bf2bd5c8f..c0aaabddaca1b 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ImpactParameter.cxx
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ImpactParameter.cxx
@@ -358,7 +358,7 @@ void ImpactParameterStudy::process(o2::globaltracking::RecoContainer& recoData)
             auto trueID = trueVec_globID_contr[it];
             const o2::track::TrackParCov& trc = recoData.getTrackParam(trueID);
             auto pt = trc.getPt();
-            o2::gpu::gpustd::array<float, 2> dcaInfo{-999., -999.};
+            std::array<float, 2> dcaInfo{-999., -999.};
             // LOGP(info, " ---> Bz={}", o2::base::Propagator::Instance()->getNominalBz());
             o2::track::TrackPar trcTmp{trc};
             if (o2::base::Propagator::Instance()->propagateToDCABxByBz({Pvtx_refitted.getX(), Pvtx_refitted.getY(), Pvtx_refitted.getZ()}, trcTmp, 2.f, matCorr, &dcaInfo)) {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
index 6ae042d081688..059b1cdc29082 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
@@ -22,8 +22,6 @@
 #include "ITStrackingGPU/VertexerTraitsGPU.h"
 #include "ITStrackingGPU/TracerGPU.h"
 
-#include "GPUCommonArray.h"
-
 namespace o2::its::gpu
 {
 #ifdef GPUCA_GPUCODE // GPUg() global kernels must only when compiled by GPU compiler
@@ -56,4 +54,4 @@ void trackletFinderHandler(const Cluster* clustersNextLayer,    // 0 2
                            const float phiCut,
                            const size_t maxTrackletsPerCluster = 1e2);
 } // namespace o2::its::gpu
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
index 3aab0624ef556..acbd77585df37 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
@@ -564,7 +564,7 @@ GPUg() void computeVertexKernel(
           histZ[iBin] = 0;
         }
         if (sumWZ > minContributors || vertIndex == 0) {
-          new (vertices + vertIndex) Vertex{o2::math_utils::Point3D<float>(beamPosition[0], beamPosition[1], wZ / sumWZ), o2::gpu::gpustd::array<float, 6>{ex, 0, ey, 0, 0, ez}, static_cast<ushort>(sumWZ), 0};
+          new (vertices + vertIndex) Vertex{o2::math_utils::Point3D<float>(beamPosition[0], beamPosition[1], wZ / sumWZ), std::array<float, 6>{ex, 0, ey, 0, 0, ez}, static_cast<ushort>(sumWZ), 0};
         } else {
           new (vertices + vertIndex) Vertex{};
         }
@@ -577,4 +577,4 @@ GPUg() void computeVertexKernel(
 */
 } // namespace gpu
 } // namespace its
-} // namespace o2
\ No newline at end of file
+} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
index 0f136edfebfb3..2bf1316470316 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
@@ -16,15 +16,14 @@
 #ifndef TRACKINGITSU_INCLUDE_CACLUSTER_H_
 #define TRACKINGITSU_INCLUDE_CACLUSTER_H_
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <array>
-#endif
-
 #include "GPUCommonRtypes.h"
-#include "GPUCommonArray.h"
 #include "ITStracking/Definitions.h"
 #include "ITStracking/MathUtils.h"
 
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <array>
+#endif
+
 namespace o2
 {
 namespace its
@@ -61,15 +60,15 @@ GPUhdi() void Cluster::print() const
 
 struct TrackingFrameInfo {
   TrackingFrameInfo() = default;
-  TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, o2::gpu::gpustd::array<float, 2>&& posTF, o2::gpu::gpustd::array<float, 3>&& covTF);
+  TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, std::array<float, 2>&& posTF, std::array<float, 3>&& covTF);
 
   float xCoordinate;
   float yCoordinate;
   float zCoordinate;
   float xTrackingFrame;
   float alphaTrackingFrame;
-  o2::gpu::gpustd::array<float, 2> positionTrackingFrame = {-1., -1.};
-  o2::gpu::gpustd::array<float, 3> covarianceTrackingFrame = {999., 999., 999.};
+  std::array<float, 2> positionTrackingFrame = {-1., -1.};
+  std::array<float, 3> covarianceTrackingFrame = {999., 999., 999.};
   GPUdi() void print() const
   {
 #if !defined(GPUCA_GPUCODE_DEVICE) || (!defined(__OPENCL__) && defined(GPUCA_GPU_DEBUG_PRINT))
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index da02149fbc432..ec075b0f10d04 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -16,17 +16,17 @@
 #ifndef TRACKINGITSU_INCLUDE_CONSTANTS_H_
 #define TRACKINGITSU_INCLUDE_CONSTANTS_H_
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <climits>
-#include <vector>
-#endif
-
 #include "ITStracking/Definitions.h"
 #include "CommonConstants/MathConstants.h"
 
 #include "GPUCommonMath.h"
 #include "GPUCommonDef.h"
-#include "GPUCommonArray.h"
+
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <climits>
+#include <vector>
+#include <array>
+#endif
 
 namespace o2
 {
@@ -54,9 +54,9 @@ constexpr int ClustersPerCell{3};
 constexpr int UnusedIndex{-1};
 constexpr float Resolution{0.0005f};
 
-GPUhdi() constexpr o2::gpu::gpustd::array<float, 3> VertexerHistogramVolume()
+GPUhdi() constexpr std::array<float, 3> VertexerHistogramVolume()
 {
-  return o2::gpu::gpustd::array<float, 3>{{1.98, 1.98, 40.f}};
+  return std::array<float, 3>{{1.98, 1.98, 40.f}};
 }
 } // namespace its
 
@@ -66,24 +66,24 @@ constexpr int LayersNumber{7};
 constexpr int TrackletsPerRoad{LayersNumber - 1};
 constexpr int CellsPerRoad{LayersNumber - 2};
 
-GPUhdi() constexpr o2::gpu::gpustd::array<float, LayersNumber> LayersZCoordinate()
+GPUhdi() constexpr std::array<float, LayersNumber> LayersZCoordinate()
 {
   constexpr double s = 1.; // safety margin
-  return o2::gpu::gpustd::array<float, LayersNumber>{16.333f + s, 16.333f + s, 16.333f + s, 42.140f + s, 42.140f + s, 73.745f + s, 73.745f + s};
+  return std::array<float, LayersNumber>{16.333f + s, 16.333f + s, 16.333f + s, 42.140f + s, 42.140f + s, 73.745f + s, 73.745f + s};
 }
 
-GPUhdi() constexpr o2::gpu::gpustd::array<float, LayersNumber> LayersRCoordinate()
+GPUhdi() constexpr std::array<float, LayersNumber> LayersRCoordinate()
 {
-  return o2::gpu::gpustd::array<float, LayersNumber>{{2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f}};
+  return std::array<float, LayersNumber>{{2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f}};
 }
 
 constexpr int ZBins{256};
 constexpr int PhiBins{128};
 constexpr float InversePhiBinSize{PhiBins / constants::math::TwoPi};
-GPUhdi() constexpr o2::gpu::gpustd::array<float, LayersNumber> InverseZBinSize()
+GPUhdi() constexpr std::array<float, LayersNumber> InverseZBinSize()
 {
   constexpr auto zSize = LayersZCoordinate();
-  return o2::gpu::gpustd::array<float, LayersNumber>{0.5f * ZBins / (zSize[0]), 0.5f * ZBins / (zSize[1]), 0.5f * ZBins / (zSize[2]),
+  return std::array<float, LayersNumber>{0.5f * ZBins / (zSize[0]), 0.5f * ZBins / (zSize[1]), 0.5f * ZBins / (zSize[2]),
                                                      0.5f * ZBins / (zSize[3]), 0.5f * ZBins / (zSize[4]), 0.5f * ZBins / (zSize[5]),
                                                      0.5f * ZBins / (zSize[6])};
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
index 630ad9acf59d2..1557c636e2345 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
@@ -17,7 +17,9 @@
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/IndexTableUtils.h"
 
-#include "GPUCommonArray.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <array>
+#endif
 
 namespace o2
 {
@@ -92,8 +94,8 @@ bool Cluster::operator==(const Cluster& rhs) const
          this->indexTableBinIndex == rhs.indexTableBinIndex;
 }
 
-TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, o2::gpu::gpustd::array<float, 2>&& posTF,
-                                     o2::gpu::gpustd::array<float, 3>&& covTF)
+TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, std::array<float, 2>&& posTF,
+                                     std::array<float, 3>&& covTF)
   : xCoordinate{x}, yCoordinate{y}, zCoordinate{z}, xTrackingFrame{xTF}, alphaTrackingFrame{alpha}, positionTrackingFrame{posTF}, covarianceTrackingFrame{covTF}
 {
   // Nothing to do
diff --git a/Detectors/TPC/qc/src/Tracks.cxx b/Detectors/TPC/qc/src/Tracks.cxx
index 8e6f0d702df1b..5f29e80c89d2e 100644
--- a/Detectors/TPC/qc/src/Tracks.cxx
+++ b/Detectors/TPC/qc/src/Tracks.cxx
@@ -13,6 +13,7 @@
 
 #include <cmath>
 #include <memory>
+#include <array>
 
 // root includes
 #include "TFile.h"
@@ -21,7 +22,6 @@
 // o2 includes
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTPC/dEdxInfo.h"
-#include "GPUCommonArray.h"
 #include "DetectorsBase/Propagator.h"
 #include "TPCQC/Tracks.h"
 #include "TPCQC/Helpers.h"
@@ -179,7 +179,7 @@ bool Tracks::processTrack(const o2::tpc::TrackTPC& track)
 
       if (propagator->getMatLUT() && propagator->hasMagFieldSet()) {
         // ---| fill DCA histos |---
-        o2::gpu::gpustd::array<float, 2> dca;
+        std::array<float, 2> dca;
         o2::track::TrackPar propTrack(track);
         if (propagator->propagateToDCABxByBz(mPositionOfPV, propTrack, 2.f, o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca)) {
           const auto phi = o2::math_utils::to02PiGen(track.getPhi());
@@ -348,4 +348,4 @@ void Tracks::dumpToFile(std::string_view filename)
     arr.Write(arr.GetName(), TObject::kSingleKey);
   }
   f->Close();
-}
\ No newline at end of file
+}
diff --git a/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx b/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
index 1329dea236b1f..33b9039298264 100644
--- a/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
+++ b/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
@@ -178,7 +178,7 @@ bool MIPTrackFilterDevice::acceptDCA(const TrackTPC& track)
   }
 
   auto propagator = o2::base::Propagator::Instance();
-  o2::gpu::gpustd::array<float, 2> dca;
+  std::array<float, 2> dca;
   const o2::math_utils::Point3D<float> refPoint{0, 0, 0};
   o2::track::TrackPar propTrack(track);
   const auto ok = propagator->propagateToDCABxByBz(refPoint, propTrack, 2., o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca);
diff --git a/Detectors/TPC/workflow/src/TPCRefitter.cxx b/Detectors/TPC/workflow/src/TPCRefitter.cxx
index 3ebe32d12ddb8..b2e41c8e808da 100644
--- a/Detectors/TPC/workflow/src/TPCRefitter.cxx
+++ b/Detectors/TPC/workflow/src/TPCRefitter.cxx
@@ -421,7 +421,7 @@ void TPCRefitterSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 bool TPCRefitterSpec::getDCAs(const o2::track::TrackPar& track, float& dcar, float& dcaz)
 {
   auto propagator = o2::base::Propagator::Instance();
-  o2::gpu::gpustd::array<float, 2> dca;
+  std::array<float, 2> dca;
   const o2::math_utils::Point3D<float> refPoint{0, 0, 0};
   o2::track::TrackPar propTrack(track);
   const auto ok = propagator->propagateToDCABxByBz(refPoint, propTrack, 2., o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca);
diff --git a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
index 4d20654d07c83..a9f1e7d71da8e 100644
--- a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
@@ -1143,7 +1143,7 @@ class TPCTimeSeries : public Task
     auto propagator = o2::base::Propagator::Instance();
 
     // propagate track to DCA
-    o2::gpu::gpustd::array<float, 2> dca;
+    std::array<float, 2> dca;
     const o2::math_utils::Point3D<float> refPoint{0, 0, 0};
 
     // coarse propagation
@@ -1252,7 +1252,7 @@ class TPCTimeSeries : public Task
 
     // make propagation for ITS-TPC Track
     // check if the track was assigned to ITS track
-    o2::gpu::gpustd::array<float, 2> dcaITSTPC{0, 0};
+    std::array<float, 2> dcaITSTPC{0, 0};
     float deltaP0 = -999;
     float deltaP1 = -999;
     float deltaP2 = -999;
@@ -1270,7 +1270,7 @@ class TPCTimeSeries : public Task
           // store TPC only DCAs
           // propagate to vertex in case the track belongs to vertex
           const bool contributeToVertex = (idxITSTPC.back() != -1);
-          o2::gpu::gpustd::array<float, 2> dcaITSTPCTmp{-1, -1};
+          std::array<float, 2> dcaITSTPCTmp{-1, -1};
 
           if (contributeToVertex) {
             if (propagator->propagateToDCA(vertex.getXYZ(), trackITSTPCTmp, propagator->getNominalBz(), mFineStep, mMatType, &dcaITSTPCTmp)) {
@@ -1279,7 +1279,7 @@ class TPCTimeSeries : public Task
             }
 
             // propagate TPC track to vertex
-            o2::gpu::gpustd::array<float, 2> dcaTPCTmp{-1, -1};
+            std::array<float, 2> dcaTPCTmp{-1, -1};
             if (propagator->propagateToDCA(vertex.getXYZ(), track, propagator->getNominalBz(), mFineStep, mMatType, &dcaTPCTmp)) {
               dcaTPCAtVertex = dcaTPCTmp[0];
             }
@@ -1401,7 +1401,7 @@ class TPCTimeSeries : public Task
         const bool contributeToVertex = (idxITSTPC.back() != -1);
         if (hasITSTPC && contributeToVertex) {
           o2::track::TrackParCov trackITSTPCTmp = tracksITSTPC[idxITSTPC.front()];
-          o2::gpu::gpustd::array<float, 2> dcaITSTPCTmp{-1, -1};
+          std::array<float, 2> dcaITSTPCTmp{-1, -1};
           if (propagator->propagateToDCA(vertex.getXYZ(), trackITSTPCTmp, propagator->getNominalBz(), mFineStep, mMatType, &dcaITSTPCTmp)) {
             o2::track::TrackParCov trackTPC = tracksTPC[iTrk];
             if (trackTPC.rotate(trackITSTPCTmp.getAlpha()) && propagator->propagateTo(trackTPC, trackITSTPCTmp.getX(), false, mMaxSnp, mFineStep, mMatType)) {
diff --git a/GPU/Common/GPUCommonArray.h b/GPU/Common/GPUCommonArray.h
index c9babbf5548b4..e83ca8c4a69fc 100644
--- a/GPU/Common/GPUCommonArray.h
+++ b/GPU/Common/GPUCommonArray.h
@@ -15,12 +15,14 @@
 #ifndef GPUCOMMONARRAY_H
 #define GPUCOMMONARRAY_H
 
-#ifndef GPUCA_GPUCODE_DEVICE
+#if !defined(GPUCA_GPUCODE_DEVICE) || defined(__CUDACC__) || defined(__HIPCC__) // TODO: Get rid of GPUCommonArray once OpenCL supports <array>
+#ifndef GPUCA_GPUCODE_COMPILEKERNELS
 #include <array>
 #endif
+#else
 
 #include "GPUCommonDef.h"
-namespace o2::gpu::gpustd
+namespace std
 {
 #ifdef GPUCA_GPUCODE_DEVICE
 template <typename T, size_t N>
@@ -43,5 +45,7 @@ GPUd() array(T, E...)->array<T, 1 + sizeof...(E)>;
 template <typename T, size_t N>
 using array = std::array<T, N>;
 #endif
-} // namespace o2::gpu::gpustd
-#endif
\ No newline at end of file
+} // namespace std
+#endif
+
+#endif // GPUCOMMONARRAY_H
diff --git a/GPU/Common/GPUCommonTypeTraits.h b/GPU/Common/GPUCommonTypeTraits.h
index f837019c11875..a51a4ac50683f 100644
--- a/GPU/Common/GPUCommonTypeTraits.h
+++ b/GPU/Common/GPUCommonTypeTraits.h
@@ -17,12 +17,11 @@
 
 #include "GPUCommonDef.h"
 
-#if !defined(GPUCA_GPUCODE_DEVICE) || defined(__CUDACC__) || defined(__HIPCC__)
+#if !defined(GPUCA_GPUCODE_DEVICE) || defined(__CUDACC__) || defined(__HIPCC__) // TODO: Get rid of GPUCommonTypeTraits once OpenCL supports <type_traits>
 #ifndef GPUCA_GPUCODE_COMPILEKERNELS
 #include <type_traits>
 #endif
 #else
-// We just reimplement some type traits in std for the GPU // TODO: Check if meanwhile we can get rid of GPUCommonTypeTraits and GPUCommonArray, and just use the std headers.
 namespace std
 {
 template <bool B, class T, class F>
diff --git a/GPU/GPUTracking/Base/GPUStdSystemHeaders.h b/GPU/GPUTracking/Base/GPUStdSystemHeaders.h
index 6598085d309c7..08f9be7d98380 100644
--- a/GPU/GPUTracking/Base/GPUStdSystemHeaders.h
+++ b/GPU/GPUTracking/Base/GPUStdSystemHeaders.h
@@ -21,5 +21,6 @@
 #include <cfloat>
 #include <cmath>
 #include <type_traits>
+#include <array>
 
 #endif
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
index 3f58c0fea75e9..ea74c43703597 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cl
@@ -72,6 +72,7 @@ typedef signed char int8_t;
 
 #include "GPUCommonDef.h"
 #include "GPUCommonTypeTraits.h" // TODO: Once possible in OpenCL, should use GPUStdSystemHeaders.h here
+#include "GPUCommonArray.h"      // TODO: Same
 #include "GPUConstantMem.h"
 #include "GPUReconstructionIncludesDeviceAll.h"
 
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index b74c1bb6a4534..7c7ce8d07ffb9 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -387,8 +387,8 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
         TrackParCovChi2 = 0.f;
       }
       CADEBUG(printf("\t%21sPropaga Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Res %8.3f %8.3f   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", "", trk.getAlpha(), x, trk.getParams()[0], trk.getParams()[1], trk.getParams()[4], trk.getParams()[4], trk.getParams()[2], trk.getParams()[2], trk.getParams()[0] - y, trk.getParams()[1] - z, sqrtf(trk.getCov()[0]), sqrtf(trk.getCov()[2]), sqrtf(trk.getCov()[5]), sqrtf(trk.getCov()[14]), trk.getCov()[10]));
-      gpu::gpustd::array<float, 2> p = {y, z};
-      gpu::gpustd::array<float, 3> c = {0, 0, 0};
+      std::array<float, 2> p = {y, z};
+      std::array<float, 3> c = {0, 0, 0};
       GPUTPCGMPropagator::GetErr2(c[0], c[2], *mPparam, getPar(trk)[2], getPar(trk)[3], z, x, y, currentRow, clusterState, sector, time, invAvgCharge, invCharge, false);
       TrackParCovChi2 += trk.getPredictedChi2(p, c);
       if (!trk.update(p, c)) {
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
index f6b8bea29822a..d26d46495069b 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
@@ -59,8 +59,8 @@ class propagatorInterface<o2::base::Propagator>
   GPUdi() bool update(const float p[2], const float cov[3])
   {
     if (mParam) {
-      gpustd::array<float, 2> pTmp = {p[0], p[1]};
-      gpustd::array<float, 3> covTmp = {cov[0], cov[1], cov[2]};
+      std::array<float, 2> pTmp = {p[0], p[1]};
+      std::array<float, 3> covTmp = {cov[0], cov[1], cov[2]};
       return mParam->update(pTmp, covTmp);
     } else {
       return false;
@@ -69,8 +69,8 @@ class propagatorInterface<o2::base::Propagator>
   GPUdi() float getPredictedChi2(const float p[2], const float cov[3])
   {
     if (mParam) {
-      gpustd::array<float, 2> pTmp = {p[0], p[1]};
-      gpustd::array<float, 3> covTmp = {cov[0], cov[1], cov[2]};
+      std::array<float, 2> pTmp = {p[0], p[1]};
+      std::array<float, 3> covTmp = {cov[0], cov[1], cov[2]};
       return mParam->getPredictedChi2(pTmp, covTmp);
     } else {
       return 99999.f;

From a850e9eb3e6a634a1e87a70170c05ad6d8bce3af Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 15 May 2025 22:18:30 +0200
Subject: [PATCH 0367/1764] GPU Common: Workaround for removing gpustd::array,
 temporary alias for O2Physics

---
 .../ReconstructionDataFormats/TrackParametrization.h        | 1 +
 GPU/Common/GPUCommonArray.h                                 | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index f240e34861eeb..1d0a5f1a9f1fd 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -29,6 +29,7 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonRtypes.h"
 #include "GPUCommonMath.h"
+#include "GPUCommonArray.h"
 #include "GPUROOTCartesianFwd.h"
 
 #ifndef GPUCA_GPUCODE_DEVICE
diff --git a/GPU/Common/GPUCommonArray.h b/GPU/Common/GPUCommonArray.h
index e83ca8c4a69fc..fa86d7bb4a021 100644
--- a/GPU/Common/GPUCommonArray.h
+++ b/GPU/Common/GPUCommonArray.h
@@ -48,4 +48,10 @@ using array = std::array<T, N>;
 } // namespace std
 #endif
 
+namespace o2::gpu::gpustd
+{
+template <class T, size_t I>
+using array = ::std::array<T, I>; // temporary alias, to remove dependent types
+} // o2::gpu::gpustd
+
 #endif // GPUCOMMONARRAY_H

From b3c66e8a48c77a932a914a5adcb3562ebef3487a Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 16 May 2025 09:53:57 +0200
Subject: [PATCH 0368/1764] DPL: Drop obsolete API (#14279)

The new plugin based mechanism does not need the bulk insertion anymore.
---
 .../Core/include/Framework/TableBuilder.h     | 106 +-----------------
 .../Core/test/benchmark_TableBuilder.cxx      |  33 ------
 Framework/Core/test/test_TableBuilder.cxx     |  34 ------
 3 files changed, 4 insertions(+), 169 deletions(-)

diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index 8d7601cefc634..0b35d5be083e4 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -42,12 +42,6 @@ class Table;
 class Array;
 } // namespace arrow
 
-template <typename T>
-struct BulkInfo {
-  const T ptr;
-  size_t size;
-};
-
 extern template class arrow::NumericBuilder<arrow::UInt8Type>;
 extern template class arrow::NumericBuilder<arrow::UInt32Type>;
 extern template class arrow::NumericBuilder<arrow::FloatType>;
@@ -200,34 +194,6 @@ struct BuilderUtils {
     }
   }
 
-  template <typename HolderType, typename PTR>
-  static arrow::Status bulkAppend(HolderType& holder, size_t bulkSize, const PTR ptr)
-  {
-    return holder.builder->AppendValues(ptr, bulkSize, nullptr);
-  }
-
-  template <typename HolderType, typename PTR>
-  static arrow::Status bulkAppendChunked(HolderType& holder, BulkInfo<PTR> info)
-  {
-    // Appending nullptr is a no-op.
-    if (info.ptr == nullptr) {
-      return arrow::Status::OK();
-    }
-    if constexpr (std::is_same_v<decltype(holder.builder), std::unique_ptr<arrow::FixedSizeListBuilder>>) {
-      if (appendToList<std::remove_pointer_t<decltype(info.ptr)>>(holder.builder, info.ptr, info.size).ok() == false) {
-        throw runtime_error("Unable to append to column");
-      } else {
-        return arrow::Status::OK();
-      }
-    } else {
-      if (holder.builder->AppendValues(info.ptr, info.size, nullptr).ok() == false) {
-        throw runtime_error("Unable to append to column");
-      } else {
-        return arrow::Status::OK();
-      }
-    }
-  }
-
   template <typename HolderType, typename ITERATOR>
   static arrow::Status append(HolderType& holder, std::pair<ITERATOR, ITERATOR> ip)
   {
@@ -518,14 +484,6 @@ struct TableBuilderHelpers {
     return {BuilderTraits<ARGS>::make_datatype()...};
   }
 
-  template <typename... ARGS, size_t NCOLUMNS = sizeof...(ARGS)>
-  static std::vector<std::shared_ptr<arrow::Field>> makeFields(std::array<char const*, NCOLUMNS> const& names)
-  {
-    char const* const* names_ptr = names.data();
-    return {
-      std::make_shared<arrow::Field>(*names_ptr++, BuilderMaker<ARGS>::make_datatype(), true, nullptr)...};
-  }
-
   /// Invokes the append method for each entry in the tuple
   template <typename... Ts, typename VALUES>
   static bool append(std::tuple<Ts...>& holders, VALUES&& values)
@@ -542,19 +500,6 @@ struct TableBuilderHelpers {
     (BuilderUtils::unsafeAppend(std::get<Ts::index>(holders), std::get<Ts::index>(values)), ...);
   }
 
-  template <typename... Ts, typename PTRS>
-  static bool bulkAppend(std::tuple<Ts...>& holders, size_t bulkSize, PTRS ptrs)
-  {
-    return (BuilderUtils::bulkAppend(std::get<Ts::index>(holders), bulkSize, std::get<Ts::index>(ptrs)).ok() && ...);
-  }
-
-  /// Return true if all columns are done.
-  template <typename... Ts, typename INFOS>
-  static bool bulkAppendChunked(std::tuple<Ts...>& holders, INFOS infos)
-  {
-    return (BuilderUtils::bulkAppendChunked(std::get<Ts::index>(holders), std::get<Ts::index>(infos)).ok() && ...);
-  }
-
   /// Invokes the append method for each entry in the tuple
   template <typename... Ts>
   static bool finalize(std::vector<std::shared_ptr<arrow::Array>>& arrays, std::tuple<Ts...>& holders)
@@ -575,15 +520,9 @@ constexpr auto tuple_to_pack(std::tuple<ARGS...>&&)
   return framework::pack<ARGS...>{};
 }
 
-template <typename T>
-concept BulkInsertable = (std::integral<std::decay<T>> && !std::same_as<bool, std::decay_t<T>>);
-
 template <typename T>
 struct InsertionTrait {
-  static consteval DirectInsertion<T> policy()
-    requires(!BulkInsertable<T>);
-  static consteval CachedInsertion<T> policy()
-    requires(BulkInsertable<T>);
+  static consteval DirectInsertion<T> policy();
   using Policy = decltype(policy());
 };
 
@@ -658,7 +597,9 @@ class TableBuilder
   template <typename... ARGS, size_t I = sizeof...(ARGS)>
   auto makeBuilders(std::array<char const*, I> const& columnNames, size_t nRows)
   {
-    mSchema = std::make_shared<arrow::Schema>(TableBuilderHelpers::makeFields<ARGS...>(columnNames));
+    char const* const* names_ptr = columnNames.data();
+    mSchema = std::make_shared<arrow::Schema>(
+      std::vector<std::shared_ptr<arrow::Field>>({std::make_shared<arrow::Field>(*names_ptr++, BuilderMaker<ARGS>::make_datatype(), true, nullptr)...}));
 
     mHolders = makeHolders<ARGS...>(mMemoryPool, nRows);
     mFinalizer = [](std::vector<std::shared_ptr<arrow::Array>>& arrays, void* holders) -> bool {
@@ -768,45 +709,6 @@ class TableBuilder
     }(typename T::table_t::persistent_columns_t{});
   }
 
-  template <typename... ARGS, size_t NCOLUMNS = sizeof...(ARGS)>
-  auto preallocatedPersist(std::array<char const*, NCOLUMNS> const& columnNames, int nRows)
-  {
-    constexpr size_t nColumns = NCOLUMNS;
-    validate();
-    mArrays.resize(nColumns);
-    makeBuilders<ARGS...>(columnNames, nRows);
-
-    // Callback used to fill the builders
-    return [holders = mHolders](unsigned int /*slot*/, typename BuilderMaker<ARGS>::FillType... args) -> void {
-      TableBuilderHelpers::unsafeAppend(*(HoldersTupleIndexed<ARGS...>*)holders, std::forward_as_tuple(args...));
-    };
-  }
-
-  template <typename... ARGS, size_t NCOLUMNS = sizeof...(ARGS)>
-  auto bulkPersist(std::array<char const*, NCOLUMNS> const& columnNames, size_t nRows)
-  {
-    validate();
-    //  Should not be called more than once
-    mArrays.resize(NCOLUMNS);
-    makeBuilders<ARGS...>(columnNames, nRows);
-
-    return [holders = mHolders](unsigned int /*slot*/, size_t batchSize, typename BuilderMaker<ARGS>::FillType const*... args) -> void {
-      TableBuilderHelpers::bulkAppend(*(HoldersTupleIndexed<ARGS...>*)holders, batchSize, std::forward_as_tuple(args...));
-    };
-  }
-
-  template <typename... ARGS, size_t NCOLUMNS = sizeof...(ARGS)>
-  auto bulkPersistChunked(std::array<char const*, NCOLUMNS> const& columnNames, size_t nRows)
-  {
-    validate();
-    mArrays.resize(NCOLUMNS);
-    makeBuilders<ARGS...>(columnNames, nRows);
-
-    return [holders = mHolders](unsigned int /*slot*/, BulkInfo<typename BuilderMaker<ARGS>::STLValueType const*>... args) -> bool {
-      return TableBuilderHelpers::bulkAppendChunked(*(HoldersTupleIndexed<ARGS...>*)holders, std::forward_as_tuple(args...));
-    };
-  }
-
   /// Reserve method to expand the columns as needed.
   template <typename... Ts>
   auto reserveArrays(std::tuple<Ts...>& holders, int s)
diff --git a/Framework/Core/test/benchmark_TableBuilder.cxx b/Framework/Core/test/benchmark_TableBuilder.cxx
index 59d1450e895bd..5b9dee866c8a3 100644
--- a/Framework/Core/test/benchmark_TableBuilder.cxx
+++ b/Framework/Core/test/benchmark_TableBuilder.cxx
@@ -62,39 +62,6 @@ static void BM_TableBuilderScalarReserved(benchmark::State& state)
 BENCHMARK(BM_TableBuilderScalarReserved)->Arg(1 << 21);
 BENCHMARK(BM_TableBuilderScalarReserved)->Range(8, 8 << 16);
 
-static void BM_TableBuilderScalarPresized(benchmark::State& state)
-{
-  using namespace o2::framework;
-  for (auto _ : state) {
-    TableBuilder builder;
-    auto rowWriter = builder.preallocatedPersist<float>({"x"}, state.range(0));
-    for (auto i = 0; i < state.range(0); ++i) {
-      rowWriter(0, 0.f);
-    }
-    auto table = builder.finalize();
-  }
-}
-
-BENCHMARK(BM_TableBuilderScalarPresized)->Arg(1 << 20);
-BENCHMARK(BM_TableBuilderScalarPresized)->Range(8, 8 << 16);
-
-static void BM_TableBuilderScalarBulk(benchmark::State& state)
-{
-  using namespace o2::framework;
-  auto chunkSize = state.range(0) / 256;
-  std::vector<float> buffer(chunkSize, 0.); // We assume data is chunked in blocks 256th of the total size
-  for (auto _ : state) {
-    TableBuilder builder;
-    auto bulkWriter = builder.bulkPersist<float>({"x"}, state.range(0));
-    for (auto i = 0; i < state.range(0) / chunkSize; ++i) {
-      bulkWriter(0, chunkSize, buffer.data());
-    }
-    auto table = builder.finalize();
-  }
-}
-
-BENCHMARK(BM_TableBuilderScalarBulk)->Range(256, 1 << 20);
-
 static void BM_TableBuilderSimple(benchmark::State& state)
 {
   using namespace o2::framework;
diff --git a/Framework/Core/test/test_TableBuilder.cxx b/Framework/Core/test/test_TableBuilder.cxx
index b08fee5ad4e6a..00cbbbc59b725 100644
--- a/Framework/Core/test/test_TableBuilder.cxx
+++ b/Framework/Core/test/test_TableBuilder.cxx
@@ -162,30 +162,6 @@ TEST_CASE("TestTableBuilderStruct")
   }
 }
 
-TEST_CASE("TestTableBuilderBulk")
-{
-  using namespace o2::framework;
-  TableBuilder builder;
-  auto bulkWriter = builder.bulkPersist<int, int>({"x", "y"}, 10);
-  int x[] = {0, 1, 2, 3, 4, 5, 6, 7};
-  int y[] = {0, 1, 2, 3, 4, 5, 6, 7};
-
-  bulkWriter(0, 8, x, y);
-
-  auto table = builder.finalize();
-  REQUIRE(table->num_columns() == 2);
-  REQUIRE(table->num_rows() == 8);
-  REQUIRE(table->schema()->field(0)->name() == "x");
-  REQUIRE(table->schema()->field(1)->name() == "y");
-  REQUIRE(table->schema()->field(0)->type()->id() == arrow::int32()->id());
-  REQUIRE(table->schema()->field(1)->type()->id() == arrow::int32()->id());
-
-  for (int64_t i = 0; i < 8; ++i) {
-    auto p = std::dynamic_pointer_cast<arrow::NumericArray<arrow::Int32Type>>(table->column(0)->chunk(0));
-    REQUIRE(p->Value(i) == i);
-  }
-}
-
 TEST_CASE("TestTableBuilderMore")
 {
   using namespace o2::framework;
@@ -288,13 +264,3 @@ TEST_CASE("TestColumnCount")
   int count2 = TableBuilder::countColumns<float, int, char[3]>();
   REQUIRE(count2 == 3);
 }
-
-TEST_CASE("TestMakeFields")
-{
-  auto fields = TableBuilderHelpers::makeFields<int, float>({"i", "f"});
-  REQUIRE(fields.size() == 2);
-  REQUIRE(fields[0]->name() == "i");
-  REQUIRE(fields[1]->name() == "f");
-  REQUIRE(fields[0]->type()->name() == "int32");
-  REQUIRE(fields[1]->type()->name() == "float");
-}

From d89ef683194da14326ccc2915810cf402d6921d7 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 15 May 2025 23:29:48 +0200
Subject: [PATCH 0369/1764] Promote ITS/MFT wrong orbit/ROF count messages to
 critical

---
 Detectors/ITSMFT/common/reconstruction/src/RUDecodeData.cxx | 2 +-
 Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/common/reconstruction/src/RUDecodeData.cxx b/Detectors/ITSMFT/common/reconstruction/src/RUDecodeData.cxx
index a9ed2748ec004..187a1bc114ee7 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/RUDecodeData.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/RUDecodeData.cxx
@@ -125,7 +125,7 @@ bool RUDecodeData::checkLinkInSync(int icab, const o2::InteractionRecord ir)
     link->statistics.errorCounts[GBTLinkDecodingStat::ErrOldROF]++;
     linkHBFToDump[(uint64_t(link->subSpec) << 32) + link->hbfEntry] = link->irHBF.orbit;
     if (link->needToPrintError(link->statistics.errorCounts[GBTLinkDecodingStat::ErrOldROF]) && !ROFRampUpStage) {
-      LOGP(error, "{} (cable {}) has IR={} for current majority IR={} -> {}", link->describe(),
+      LOGP(critical, "{} (cable {}) has IR={} for current majority IR={} -> {}", link->describe(),
            cableHWID[icab], link->ir.asString(), ir.asString(), link->statistics.ErrNames[GBTLinkDecodingStat::ErrOldROF]);
     }
 #endif
diff --git a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
index 7042cb7433ac5..da1af34376ff1 100644
--- a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
@@ -202,7 +202,7 @@ void STFDecoder<Mapping>::run(ProcessingContext& pc)
     if ((expectedTFSize != nTriggersProcessed) && mROFErrRepIntervalMS > 0 && mTFCounter > 1 && nTriggersProcessed > 0) {
       long currTS = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
       if (currTS - lastErrReportTS > mROFErrRepIntervalMS) {
-        LOGP(error, "Inconsistent number of ROF per TF. From parameters: {} from readout: {} (muting further reporting for {} ms)", expectedTFSize, nTriggersProcessed, mROFErrRepIntervalMS);
+        LOGP(critical, "Inconsistent number of ROF per TF. From parameters: {} from readout: {} (muting further reporting for {} ms)", expectedTFSize, nTriggersProcessed, mROFErrRepIntervalMS);
         lastErrReportTS = currTS;
       }
     }

From 5b5f1d96e60af52e9bf70796b23e1a4f5f0c544c Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 16 May 2025 16:09:42 +0200
Subject: [PATCH 0370/1764] Include/adapt QED for special runs (#14242)

* Include QED for special runs
---
 Generators/include/Generators/QEDGenParam.h | 11 ++++++-----
 Generators/share/external/QEDepem.C         |  2 ++
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/Generators/include/Generators/QEDGenParam.h b/Generators/include/Generators/QEDGenParam.h
index 1c78b14cfc516..0a79f113fc4ac 100644
--- a/Generators/include/Generators/QEDGenParam.h
+++ b/Generators/include/Generators/QEDGenParam.h
@@ -24,11 +24,12 @@ namespace o2
 namespace eventgen
 {
 struct QEDGenParam : public o2::conf::ConfigurableParamHelper<QEDGenParam> {
-
-  float yMin = -6.f;    ///< min Y
-  float yMax = 6.f;     ///< max Y
-  float ptMin = 0.4e-3; ///< min pT
-  float ptMax = 10.f;   ///< min pT
+  float yMin = -6.f;       ///< min Y
+  float yMax = 6.f;        ///< max Y
+  float ptMin = 0.4e-3;    ///< min pT
+  float ptMax = 10.f;      ///< min pT
+  float cmEnergy = 5360.f; ///< center of mass energy per nucleon pair in GeV
+  float Z = 82.f;          ///< atomic number of the projectile/target (only symmetric systems are compatible for now)
   //
   float xSectionQED = -1; ///< estimated QED x-section in barns
   float xSectionHad = 8.; ///< reference hadronic x-section for the same system
diff --git a/Generators/share/external/QEDepem.C b/Generators/share/external/QEDepem.C
index 1e464ec69be00..d9103d1476df0 100644
--- a/Generators/share/external/QEDepem.C
+++ b/Generators/share/external/QEDepem.C
@@ -35,6 +35,8 @@ o2::eventgen::GeneratorTGenerator* QEDepem()
     genBg->SetPtRange(qedParam.ptMin, qedParam.ptMax);                               // Set pt limits (GeV) for e+-: 1MeV corresponds to max R=13.3mm at 5kGaus
     genBg->SetOrigin(diamond.position[0], diamond.position[1], diamond.position[2]); // vertex position in space
     genBg->SetSigma(diamond.width[0], diamond.width[1], diamond.width[2]);           // vertex sigma
+    genBg->SetCMEnergy(qedParam.cmEnergy);                                           // center of mass energy per nucleon pair in GeV
+    genBg->SetZ(qedParam.Z);                                                         // atomic number of the projectile/target (only symmetric systems are compatible for now)
     genBg->SetTimeOrigin(0.);                                                        // vertex position in time
     initialized = genBg->Init();
     if (!initialized) {

From 64315adcaddfc72a231bc8c15427b03d6f239e87 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 16 May 2025 15:43:44 +0200
Subject: [PATCH 0371/1764] GPU: Check that we do not optimize RTC when we have
 2 different GPUReconstruction instances

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 9 ++++++++-
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 1 +
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 3ef995b9f9561..c76bf11c3e25d 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -347,15 +347,22 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     mProcessingSettings->nTPCClustererLanes = GPUCA_NSECTORS;
   }
 
+  if (GetProcessingSettings().doublePipeline) {
+    mProcessingSettings->rtctech.allowOptimizedSlaveReconstruction = true;
+  }
   if (GetProcessingSettings().doublePipeline && (mChains.size() != 1 || mChains[0]->SupportsDoublePipeline() == false || !IsGPU() || GetProcessingSettings().memoryAllocationStrategy != GPUMemoryResource::ALLOCATION_GLOBAL)) {
     GPUError("Must use double pipeline mode only with exactly one chain that must support it");
     return 1;
   }
-
   if (mMaster == nullptr && GetProcessingSettings().doublePipeline) {
     mPipelineContext.reset(new GPUReconstructionPipelineContext);
   }
 
+  if (mMaster && GetProcessingSettings().rtc.enable && (GetProcessingSettings().rtc.optConstexpr || GetProcessingSettings().rtc.optSpecialCode) && !GetProcessingSettings().rtctech.allowOptimizedSlaveReconstruction) {
+    GPUError("Not allowed to create optimized RTC code with more than one GPUReconstruction instances");
+    return 1;
+  }
+
   mDeviceMemorySize = mHostMemorySize = 0;
   for (uint32_t i = 0; i < mChains.size(); i++) {
     if (mChains[i]->EarlyConfigure()) {
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 9400a429fca81..b9be1db881816 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -228,6 +228,7 @@ AddOption(runTest, int32_t, 0, "", 0, "Do not run the actual benchmark, but just
 AddOption(cacheMutex, bool, true, "", 0, "Use a file lock to serialize access to the cache folder")
 AddOption(ignoreCacheValid, bool, false, "", 0, "If set, allows to use RTC cached code files even if they are not valid for the current source code / parameters")
 AddOption(printLaunchBounds, bool, false, "", 0, "Print launch bounds used for RTC code as debugging option")
+AddOption(allowOptimizedSlaveReconstruction, bool, false, "", 0, "Allow RTC with slave GPUReconstruction instances with optConstexpr and optSpecialcode")
 AddOption(cacheFolder, std::string, "./rtccache/", "", 0, "Folder in which the cache file is stored")
 AddOption(prependCommand, std::string, "", "", 0, "Prepend RTC compilation commands by this string")
 AddOption(overrideArchitecture, std::string, "", "", 0, "Override arhcitecture part of RTC compilation command line") // Part of cmdLine, so checked against the cache

From dc60e3535f333042ef6dcb665cf4c3cfb5d95cfa Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 16 May 2025 13:22:19 +0200
Subject: [PATCH 0372/1764] By default process K0s only in the sync. svertexer

To rever to the full mode use define SECVTXK0ONLY=0
---
 .../include/DetectorsVertexing/SVertexHypothesis.h     |  4 ++--
 prodtests/full-system-test/dpl-workflow.sh             | 10 +++++++++-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h b/Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h
index 1450e0c15e98c..c3fd74aa7eeff 100644
--- a/Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h
+++ b/Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h
@@ -60,7 +60,7 @@ class SVertexHypothesis
 
   bool check(float p2Pos, float p2Neg, float p2V0, float ptV0) const
   { // check if given mass and pt is matching to hypothesis
-    return check(calcMass(p2Pos, p2Neg, p2V0), ptV0);
+    return mPars[SigmaM] > 0 && check(calcMass(p2Pos, p2Neg, p2V0), ptV0);
   }
   bool check(float mass, float pt) const
   { // check if given mass and pt is matching to hypothesis
@@ -151,7 +151,7 @@ class SVertex3Hypothesis
 
   bool check(float p2Pos, float p2Neg, float p2Bach, float p2Tot, float ptV0) const
   { // check if given mass and pt is matching to hypothesis
-    return check(calcMass(p2Pos, p2Neg, p2Bach, p2Tot), ptV0);
+    return mPars[SigmaM] > 0 && check(calcMass(p2Pos, p2Neg, p2Bach, p2Tot), ptV0);
   }
 
   bool check(float mass, float pt) const
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index b51594115154c..4e6cbbebe7db7 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -94,6 +94,7 @@ TPC_CORR_OPT=
 TPC_CORR_KEY=
 INTERACTION_TAG_CONFIG_KEY=
 EVE_OPT=" --jsons-folder $EDJSONS_DIR"
+: ${SECVTXK0ONLY:=}
 : ${EVE_CONFIG:=}
 : ${STRTRACKING:=}
 : ${ITSEXTRAERR:=}
@@ -591,7 +592,14 @@ has_detector_reco ITS && has_detector_gpu ITS TPC && [[ -z "$DISABLE_ROOT_OUTPUT
 has_detector_matching PRIMVTX && [[ ! -z "$VERTEXING_SOURCES" ]] && [[ $GLOBAL_READER_NEEDS_PV != 1 ]] && add_W o2-primary-vertexing-workflow "$DISABLE_MC $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $PVERTEX_CONFIG --pipeline $(get_N primary-vertexing MATCH REST 1 PRIMVTX),$(get_N pvertex-track-matching MATCH REST 1 PRIMVTXMATCH)" "${PVERTEXING_CONFIG_KEY};${INTERACTION_TAG_CONFIG_KEY};"
 
 if [[ $BEAMTYPE != "cosmic" ]] && has_detectors_reco ITS && has_detector_matching SECVTX && [[ ! -z "$SVERTEXING_SOURCES" ]]; then
-  [[ $GLOBAL_READER_NEEDS_SV != 1 ]] && add_W o2-secondary-vertexing-workflow "$DISABLE_MC $STRTRACKING $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $TPC_CORR_OPT --vertexing-sources $SVERTEXING_SOURCES --threads $SVERTEX_THREADS --pipeline $(get_N secondary-vertexing MATCH REST $SVERTEX_THREADS SECVTX)" "$TPC_CORR_KEY"
+  : ${REDUCESV_OPT:=}
+  : ${REDUCESV_CONF:=}
+  if [[ $SYNCMODE == 1 ]] && [[ $SECVTXK0ONLY != 0 ]] ; then
+    : ${STRTRACKING:=" --disable-strangeness-tracker "}
+    : ${REDUCESV_OPT:=" --disable-cascade-finder --disable-3body-finder "}
+    : ${REDUCESV_CONF:="svertexer.pidCutsPhoton[0]=-1;svertexer.pidCutsLambda[0]=-1;svertexer.pidCutsHTriton[0]=-1;svertexer.pidCutsHhydrog4[0]=-1;"}
+  fi
+  [[ $GLOBAL_READER_NEEDS_SV != 1 ]] && add_W o2-secondary-vertexing-workflow "$DISABLE_MC $STRTRACKING $REDUCESV_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $TPC_CORR_OPT --vertexing-sources $SVERTEXING_SOURCES --threads $SVERTEX_THREADS --pipeline $(get_N secondary-vertexing MATCH REST $SVERTEX_THREADS SECVTX)" "$TPC_CORR_KEY;$REDUCESV_CONF"
   SECTVTX_ON="1"
 else
   SECTVTX_ON="0"

From 966097b751dced62af09972912f8711dac66b7e4 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 16 May 2025 17:37:22 +0200
Subject: [PATCH 0373/1764] Possibility to define AlignParam as Local Delta

The constructors got extra argument convertLocalToGlobal (by default true) which tells
that if the provided parameters correspond to the local delta (i.e. argument global == false),
then it should be converted to global delta.
Otherwise, the delta being local or global is fully defined by the value of the global
argument. The AlignParam::applyToGeometry() accounts for the type of persistent type of delta
and avoids extra global -> local conversion if mIsGlobalDelta is false.
---
 .../DetectorsCommonDataFormats/AlignParam.h   | 17 +++++--
 .../Detectors/Common/src/AlignParam.cxx       | 46 +++++++++++--------
 2 files changed, 40 insertions(+), 23 deletions(-)

diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h
index c4e702c6ae27e..a93a37c1e36ab 100644
--- a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h
+++ b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h
@@ -37,9 +37,12 @@ class AlignParam
   AlignParam(const char* symname, int algID,       // volume symbolic name and its alignable ID
              double x, double y, double z,         // delta translation
              double psi, double theta, double phi, // delta rotation
-             bool global = true);                  // global (preferable) or local delta definition
+             bool global = true,                   // global (preferable) or local delta definition
+             bool convertLocalToGlobal = true);    // if local is provided, convert it to global
 
-  AlignParam(const char* symname, int algID, TGeoMatrix& m, bool global = true);
+  AlignParam(const char* symname, int algID, TGeoMatrix& m,
+             bool global = true,                // global (preferable) or local delta definition
+             bool convertLocalToGlobal = true); // if local is provided, convert it to global
 
   /// return symbolic name of the volume
   const std::string& getSymName() const { return mSymName; }
@@ -70,6 +73,9 @@ class AlignParam
   void setAlignableID(int id) { mAlignableID = id; }
   /// ================ methods for direct setting of delta params
 
+  /// set parameters
+  void setParams(double x, double y, double z, double psi, double theta, double phi);
+
   /// set parameters of global delta
   void setGlobalParams(double x, double y, double z, double psi, double theta, double phi);
 
@@ -114,6 +120,9 @@ class AlignParam
 
   int rectify(double zero = 1e-13);
 
+  bool isGlobal() const { return mIsGlobal; }
+  void setIsGlobal(bool v) { mIsGlobal = v; }
+
  protected:
   bool matrixToAngles(const double* rot, double& psi, double& theta, double& phi) const;
   void anglesToMatrix(double psi, double theta, double phi, double* rot) const;
@@ -123,8 +132,8 @@ class AlignParam
  private:
   std::string mSymName{};
 
+  bool mIsGlobal = true; /// is this global delta?
   int mAlignableID = -1; /// alignable ID (set for sensors only)
-
   double mX = 0.; ///< X translation of global delta
   double mY = 0.; ///< Y translation of global delta
   double mZ = 0.; ///< Z translation of global delta
@@ -133,7 +142,7 @@ class AlignParam
   double mTheta = 0.; ///< "roll"  : Euler angle of rotation around Y axis after 1st rotation (radians)
   double mPhi = 0.;   ///< "yaw"   : Euler angle of rotation around Z axis (radians)
 
-  ClassDefNV(AlignParam, 1);
+  ClassDefNV(AlignParam, 2);
 };
 
 } // namespace detectors
diff --git a/DataFormats/Detectors/Common/src/AlignParam.cxx b/DataFormats/Detectors/Common/src/AlignParam.cxx
index 90f2a349607a1..f20cf3dac4971 100644
--- a/DataFormats/Detectors/Common/src/AlignParam.cxx
+++ b/DataFormats/Detectors/Common/src/AlignParam.cxx
@@ -26,8 +26,9 @@ using namespace o2::detectors;
 AlignParam::AlignParam(const char* symname, int algID,       // volume symbolic name and its alignable ID
                        double x, double y, double z,         // delta translation
                        double psi, double theta, double phi, // delta rotation
-                       bool global)                          // global (preferable) or local delta definition
-  : mSymName(symname), mAlignableID(algID)
+                       bool global,                          // global (preferable) or local delta definition
+                       bool convertLocalToGlobal)            // if local is provided, convert it to global
+  : mSymName(symname), mIsGlobal(global || convertLocalToGlobal), mAlignableID(algID)
 {
   /// standard constructor with 3 translation + 3 rotation parameters
   /// If the user explicitly sets the global variable to false then the
@@ -35,23 +36,22 @@ AlignParam::AlignParam(const char* symname, int algID,       // volume symbolic
   /// This requires to have a gGeoMenager active instance, otherwise the
   /// constructor will fail (no object created)
 
-  if (global) {
-    setGlobalParams(x, y, z, psi, theta, phi);
-  } else {
+  setParams(x, y, z, psi, theta, phi);
+  if (!global && convertLocalToGlobal) {
     setLocalParams(x, y, z, psi, theta, phi);
   }
 }
 
 //___________________________________________________
-AlignParam::AlignParam(const char* symname, int algID, TGeoMatrix& m, bool global)
-  : mSymName(symname), mAlignableID(algID)
+AlignParam::AlignParam(const char* symname, int algID, TGeoMatrix& m, bool global, bool convertLocalToGlobal)
+  : mSymName(symname), mIsGlobal(global || convertLocalToGlobal), mAlignableID(algID)
 {
   setTranslation(m);
   if (!setRotation(m)) {
     const double* rot = m.GetRotationMatrix();
     throw std::runtime_error(fmt::format("Failed to extract roll-pitch-yall angles from [[{},{},{}], [{},{},{}], [{},{},{}] for {}", rot[0], rot[1], rot[2], rot[3], rot[4], rot[5], rot[6], rot[7], rot[8], symname));
   }
-  if (!global && !setLocalParams(mX, mY, mZ, mPsi, mTheta, mPhi)) {
+  if (!global && convertLocalToGlobal && !setLocalParams(mX, mY, mZ, mPsi, mTheta, mPhi)) {
     throw std::runtime_error(fmt::format("Alignment creation for {} failed: geomManager is absent", symname));
   }
 }
@@ -223,6 +223,10 @@ bool AlignParam::createLocalMatrix(TGeoHMatrix& m) const
   // In case that the TGeo was not initialized or not closed,
   // returns false and the object parameters are not set.
   //
+  m = createMatrix();
+  if (!mIsGlobal) {
+    return true;
+  }
   if (!gGeoManager || !gGeoManager->IsClosed()) {
     LOG(error) << "Can't get the local alignment object parameters! gGeoManager doesn't exist or it is still open!";
     return false;
@@ -247,7 +251,6 @@ bool AlignParam::createLocalMatrix(TGeoHMatrix& m) const
     LOG(error) << "Volume name or path " << symname << " is not valid!";
     return false;
   }
-  m = createMatrix();
   TGeoHMatrix gprime, gprimeinv;
   gprime = *node->GetMatrix();
   gprimeinv = gprime.Inverse();
@@ -302,18 +305,15 @@ bool AlignParam::applyToGeometry() const
   }
 
   //  double threshold = 0.001;
-
-  TGeoHMatrix gprime = *node->GetMatrix();
-  TGeoHMatrix align = createMatrix();
-  gprime.MultiplyLeft(&align);
-  TGeoHMatrix* ginv = new TGeoHMatrix; // TGeoPhysicalNode takes and manages raw pointer, need naked new!
-  TGeoHMatrix* g = node->GetMatrix(node->GetLevel() - 1);
-  *ginv = g->Inverse();
-  *ginv *= gprime;
-
+  TGeoHMatrix* align = new TGeoHMatrix(createMatrix());
+  if (mIsGlobal) {
+    align->Multiply(node->GetMatrix());
+    TGeoHMatrix* g = node->GetMatrix(node->GetLevel() - 1);
+    align->MultiplyLeft(node->GetMatrix(node->GetLevel() - 1)->Inverse());
+  }
   LOG(debug) << "Aligning volume " << symname;
 
-  node->Align(ginv);
+  node->Align(align);
 
   return true;
 }
@@ -359,6 +359,14 @@ void AlignParam::setGlobalParams(double x, double y, double z, double psi, doubl
   setRotation(psi, theta, phi);
 }
 
+//_____________________________________________________________________________
+void AlignParam::setParams(double x, double y, double z, double psi, double theta, double phi)
+{
+  /// set parameters of global delta
+  setTranslation(x, y, z);
+  setRotation(psi, theta, phi);
+}
+
 //_____________________________________________________________________________
 void AlignParam::setRotation(double psi, double theta, double phi)
 {

From a6af3174a7011e8a0620b71a14fee134275f3815 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Fri, 16 May 2025 22:13:05 +0200
Subject: [PATCH 0374/1764] TPC init: load more params from CCDB for GEMAmpl

---
 Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
index a04f73a62fbf8..b111d8f372967 100644
--- a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
+++ b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
@@ -309,11 +309,16 @@ void initTPC(long timestamp)
   auto& cdb = o2::tpc::CDBInterface::instance();
   cdb.setUseDefaults();
 
-  // IMPORTANT: load ParameterGEM from CCDB
+  // IMPORTANT: load ParameterGEM, ParameterGas and CalPadGainFull from CCDB to correctly init GEMAmplification
   auto& ccdbManager = o2::ccdb::BasicCCDBManager::instance();
   ccdbManager.getSpecific<o2::tpc::ParameterGEM>(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::ParGEM), timestamp);
-  LOGP(info, "initTPC: TPC GEM param updated for time {}", timestamp);
+  LOGP(info, "initTPC: TPC GEM param, Gas param + CalPadGainFull updated for time {}", timestamp);
+  ccdbManager.getSpecific<o2::tpc::CalPad>(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::CalPadGainFull), timestamp);
+  ccdbManager.getSpecific<o2::tpc::ParameterGas>(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::ParGas), timestamp);
+
   o2::tpc::ParameterGEM::Instance().printKeyValues(true, true);
+  o2::tpc::ParameterGas::Instance().printKeyValues(true, true);
+
   // by invoking this constructor we make sure that a common file will be created
   // in future we should take this from OCDB and just forward per message
   const static auto& ampl = o2::tpc::GEMAmplification::instance();

From 88baea9a23ba9f20083204b9ae46a63eaa19038b Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 19 May 2025 11:06:23 +0200
Subject: [PATCH 0375/1764] DPL Analysis: `as<T>(cfg)` for adjusting the types
 of configurables in expressions (#14276)

---
 .../Core/include/Framework/Expressions.h      | 22 +++++++++++++------
 Framework/Core/test/test_Expressions.cxx      |  9 ++++++++
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 9e00388ee5df8..18c930700a91d 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -12,13 +12,11 @@
 #define O2_FRAMEWORK_EXPRESSIONS_H_
 
 #include "Framework/BasicOps.h"
-#include "Framework/CompilerBuiltins.h"
 #include "Framework/Pack.h"
 #include "Framework/Configurable.h"
 #include "Framework/Variant.h"
 #include "Framework/InitContext.h"
 #include "Framework/ConfigParamRegistry.h"
-#include "Framework/RuntimeError.h"
 #include <arrow/type_fwd.h>
 #include <gandiva/gandiva_aliases.h>
 #include <arrow/type.h>
@@ -143,13 +141,17 @@ struct OpNode {
 /// A placeholder node for simple type configurable
 struct PlaceholderNode : LiteralNode {
   template <typename T>
+    requires(variant_trait_v<typename std::decay<T>::type> != VariantType::Unknown)
   PlaceholderNode(Configurable<T> const& v) : LiteralNode{v.value}, name{v.name}
   {
-    if constexpr (variant_trait_v<typename std::decay<T>::type> != VariantType::Unknown) {
-      retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{context.options().get<T>(name)}; };
-    } else {
-      unknownParameterUsed(name.c_str());
-    }
+    retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{context.options().get<T>(name)}; };
+  }
+
+  template <typename T, typename AT>
+    requires((std::convertible_to<T, AT>) && (variant_trait_v<typename std::decay<T>::type> != VariantType::Unknown))
+  PlaceholderNode(Configurable<T> const& v, AT*) : LiteralNode{static_cast<AT>(v.value)}, name{v.name}
+  {
+    retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{static_cast<AT>(context.options().get<T>(name))}; };
   }
 
   PlaceholderNode(PlaceholderNode const& other) = default;
@@ -163,6 +165,12 @@ struct PlaceholderNode : LiteralNode {
   LiteralNode::var_t (*retrieve)(InitContext&, char const*);
 };
 
+template <typename AT, typename T>
+PlaceholderNode as(Configurable<T> const& v)
+{
+  return PlaceholderNode(v, (AT*)nullptr);
+}
+
 /// A placeholder node for parameters taken from an array
 struct ParameterNode : LiteralNode {
   ParameterNode(int index_ = -1)
diff --git a/Framework/Core/test/test_Expressions.cxx b/Framework/Core/test/test_Expressions.cxx
index 2296b5dcbfbc4..6faa2fc352232 100644
--- a/Framework/Core/test/test_Expressions.cxx
+++ b/Framework/Core/test/test_Expressions.cxx
@@ -146,6 +146,15 @@ TEST_CASE("TestTreeParsing")
   REQUIRE(ptfilterspecs2[0].left == (DatumSpec{std::string{"fPt"}, typeid(o2::aod::track::Pt).hash_code(), atype::FLOAT}));
   REQUIRE(ptfilterspecs2[0].right == (DatumSpec{LiteralNode::var_t{1.0f}, atype::FLOAT}));
   REQUIRE(ptfilterspecs2[0].result == (DatumSpec{0u, atype::BOOL}));
+
+  Configurable<int> cvalue{"cvalue", 1, "test value"};
+  Filter testFilter = o2::aod::track::tpcNClsShared < as<uint8_t>(cvalue);
+  REQUIRE(testFilter.node->self.index() == 2);
+  REQUIRE(testFilter.node->left->self.index() == 1);
+  REQUIRE(testFilter.node->right->self.index() == 3);
+  REQUIRE(std::get<PlaceholderNode>(testFilter.node->right->self).name == "cvalue");
+  auto testSpecs = createOperations(testFilter);
+  REQUIRE(testSpecs[0].right == (DatumSpec{LiteralNode::var_t{(uint8_t)1}, atype::UINT8}));
 }
 
 TEST_CASE("TestGandivaTreeCreation")

From 4d20c8d9087a28bbd16984c36abef7b58b1f2802 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 19 May 2025 11:06:56 +0200
Subject: [PATCH 0376/1764] DPL Analysis: improve/fix join error by not relying
 on metadata (#14249)

---
 Framework/Core/include/Framework/ASoA.h           | 10 ++++++----
 .../Core/include/Framework/AnalysisManagers.h     |  8 ++++----
 Framework/Core/include/Framework/AnalysisTask.h   |  4 ++--
 Framework/Core/include/Framework/TableBuilder.h   |  7 ++++---
 Framework/Core/src/ASoA.cxx                       |  7 ++-----
 Framework/Core/test/test_ASoA.cxx                 | 15 +++++++++++++++
 6 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index e098cd89f6d5d..c13cfe912c814 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1245,7 +1245,7 @@ struct TableIterator : IP, C... {
 };
 
 struct ArrowHelpers {
-  static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
+  static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const char* const> labels);
   static std::shared_ptr<arrow::Table> concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
 };
 
@@ -1683,6 +1683,7 @@ class Table
   using table_t = self_t;
 
   static constexpr const auto originals = computeOriginals<ref, Ts...>();
+  static constexpr const auto originalLabels = []<size_t N, std::array<TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::array<const char*, N>{o2::aod::label<refs[Is]>()...}; }.template operator()<originals.size(), originals>(std::make_index_sequence<originals.size()>());
 
   template <size_t N, std::array<TableRef, N> bindings>
     requires(ref.origin_hash == "CONC"_h)
@@ -1931,7 +1932,7 @@ class Table
 
   Table(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
     requires(ref.origin_hash != "CONC"_h)
-    : Table(ArrowHelpers::joinTables(std::move(tables)), offset)
+    : Table(ArrowHelpers::joinTables(std::move(tables), std::span{originalLabels}), offset)
   {
   }
 
@@ -3213,7 +3214,7 @@ struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts.
     bindInternalIndicesTo(this);
   }
   JoinFull(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
-    : base{ArrowHelpers::joinTables(std::move(tables)), offset}
+    : base{ArrowHelpers::joinTables(std::move(tables), std::span{base::originalLabels}), offset}
   {
     bindInternalIndicesTo(this);
   }
@@ -3223,6 +3224,7 @@ struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts.
   using self_t = JoinFull<D, Ts...>;
   using table_t = base;
   static constexpr const auto originals = base::originals;
+  static constexpr const auto originalLabels = base::originalLabels;
   using columns_t = typename table_t::columns_t;
   using persistent_columns_t = typename table_t::persistent_columns_t;
   using iterator = table_t::template iterator_template<DefaultIndexPolicy, self_t, Ts...>;
@@ -3293,7 +3295,7 @@ using Join = JoinFull<o2::aod::Hash<"JOIN/0"_h>, Ts...>;
 template <typename... Ts>
 constexpr auto join(Ts const&... t)
 {
-  return Join<Ts...>(ArrowHelpers::joinTables({t.asArrowTable()...}));
+  return Join<Ts...>(ArrowHelpers::joinTables({t.asArrowTable()...}, std::span{Join<Ts...>::base::originalLabels}));
 }
 
 template <typename T>
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 330eaf01f0be4..b76d88ea5ee66 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -282,14 +282,14 @@ template <is_spawns T>
 bool prepareOutput(ProcessingContext& context, T& spawns)
 {
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
-  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context));
+  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
   if (originalTable->schema()->fields().empty() == true) {
     using base_table_t = typename T::base_table_t::table_t;
     originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
   }
 
   spawns.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>>(originalTable, o2::aod::label<metadata::extension_table_t::ref>(), spawns.projector));
-  spawns.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({spawns.extension->asArrowTable(), originalTable}));
+  spawns.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({spawns.extension->asArrowTable(), originalTable}, std::span{T::spawnable_t::table_t::originalLabels}));
   return true;
 }
 
@@ -304,14 +304,14 @@ template <is_defines T>
 bool prepareOutput(ProcessingContext& context, T& defines)
 {
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
-  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context));
+  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
   if (originalTable->schema()->fields().empty() == true) {
     using base_table_t = typename T::base_table_t::table_t;
     originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
   }
 
   defines.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>>(originalTable, o2::aod::label<metadata::extension_table_t::ref>(), defines.projectors.data(), defines.projector));
-  defines.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({defines.extension->asArrowTable(), originalTable}));
+  defines.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({defines.extension->asArrowTable(), originalTable}, std::span{T::spawnable_t::table_t::originalLabels}));
   return true;
 }
 
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index c7f3da1948c62..257a5358463c6 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -201,9 +201,9 @@ struct AnalysisDataProcessorBuilder {
     std::shared_ptr<arrow::Table> table = nullptr;
     auto joiner = [&record]<size_t N, std::array<soa::TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::vector{extractTableFromRecord<refs[Is]>(record)...}; };
     if constexpr (soa::is_iterator<T>) {
-      table = o2::soa::ArrowHelpers::joinTables(joiner.template operator()<T::parent_t::originals.size(), T::parent_t::originals>(std::make_index_sequence<T::parent_t::originals.size()>()));
+      table = o2::soa::ArrowHelpers::joinTables(joiner.template operator()<T::parent_t::originals.size(), T::parent_t::originals>(std::make_index_sequence<T::parent_t::originals.size()>()), std::span{T::parent_t::originalLabels});
     } else {
-      table = o2::soa::ArrowHelpers::joinTables(joiner.template operator()<T::originals.size(), T::originals>(std::make_index_sequence<T::originals.size()>()));
+      table = o2::soa::ArrowHelpers::joinTables(joiner.template operator()<T::originals.size(), T::originals>(std::make_index_sequence<T::originals.size()>()), std::span{T::originalLabels});
     }
     expressions::updateFilterInfo(info, table);
     if constexpr (!o2::soa::is_smallgroups<std::decay_t<T>>) {
diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index 0b35d5be083e4..e2d12789ef922 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -771,7 +771,7 @@ template <aod::is_aod_hash D>
 auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector)
 {
   using placeholders_pack_t = typename o2::aod::MetadataTrait<D>::metadata::placeholders_pack_t;
-  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{o2::aod::MetadataTrait<D>::metadata::base_table_t::originalLabels});
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, placeholders_pack_t{});
   }
@@ -798,7 +798,7 @@ template <aod::is_aod_hash D>
 auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, std::shared_ptr<gandiva::Projector>& projector)
 {
   using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
-  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{o2::aod::MetadataTrait<D>::metadata::base_table_t::originalLabels});
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, expression_pack_t{});
   }
@@ -834,7 +834,8 @@ auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, s
 template <typename... C>
 auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, std::shared_ptr<gandiva::Projector>& projector)
 {
-  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables));
+  std::array<const char*, 1> labels{"original"};
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span<const char* const>{labels});
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, framework::pack<C...>{});
   }
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index 810398747de88..bd6ca551d24ec 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -64,7 +64,7 @@ SelectionVector sliceSelection(gsl::span<int64_t const> const& mSelectedRows, in
   return slicedSelection;
 }
 
-std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables)
+std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const char* const> labels)
 {
   if (tables.size() == 1) {
     return tables[0];
@@ -72,10 +72,7 @@ std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_p
   for (auto i = 0U; i < tables.size() - 1; ++i) {
     if (tables[i]->num_rows() != tables[i + 1]->num_rows()) {
       throw o2::framework::runtime_error_f("Tables %s and %s have different sizes (%d vs %d) and cannot be joined!",
-                                           tables[i]->schema()->metadata()->Get("label").ValueOrDie().c_str(),
-                                           tables[i + 1]->schema()->metadata()->Get("label").ValueOrDie().c_str(),
-                                           tables[i]->num_rows(),
-                                           tables[i + 1]->num_rows());
+                                           labels[i], labels[i + 1], tables[i]->num_rows(), tables[i + 1]->num_rows());
     }
   }
   std::vector<std::shared_ptr<arrow::Field>> fields;
diff --git a/Framework/Core/test/test_ASoA.cxx b/Framework/Core/test/test_ASoA.cxx
index 6d9ee16fec84d..80519aebc9ee7 100644
--- a/Framework/Core/test/test_ASoA.cxx
+++ b/Framework/Core/test/test_ASoA.cxx
@@ -31,6 +31,7 @@ namespace test
 DECLARE_SOA_COLUMN(X, x, int);
 DECLARE_SOA_COLUMN(Y, y, int);
 DECLARE_SOA_COLUMN(Z, z, int);
+DECLARE_SOA_COLUMN(W, w, int);
 DECLARE_SOA_DYNAMIC_COLUMN(Sum, sum, [](int x, int y) { return x + y; });
 DECLARE_SOA_EXPRESSION_COLUMN(ESum, esum, int, test::x + test::y);
 } // namespace test
@@ -268,9 +269,17 @@ TEST_CASE("TestJoinedTables")
   rowWriterZ(0, 8);
   auto tableZ = builderZ.finalize();
 
+  TableBuilder builderW;
+  auto rowWriterW = builderW.persist<int32_t>({"fW"});
+  rowWriterW(0, 8);
+  rowWriterW(0, 8);
+  rowWriterW(0, 8);
+  auto tableW = builderW.finalize();
+
   using TestX = InPlaceTable<"A0"_h, o2::aod::test::X>;
   using TestY = InPlaceTable<"A1"_h, o2::aod::test::Y>;
   using TestZ = InPlaceTable<"A2"_h, o2::aod::test::Z>;
+  using TestW = InPlaceTable<"A3"_h, o2::aod::test::W>;
   using Test = Join<TestX, TestY>;
 
   REQUIRE(Test::contains<TestX>());
@@ -303,6 +312,12 @@ TEST_CASE("TestJoinedTables")
   for (auto& test : tests4) {
     REQUIRE(15 == test.x() + test.y() + test.z());
   }
+
+  try {
+    auto testF = join(TestZ{tableZ}, TestW{tableW});
+  } catch (RuntimeErrorRef ref) {
+    REQUIRE(std::string{error_from_ref(ref).what} == "Tables TEST and TEST have different sizes (8 vs 3) and cannot be joined!");
+  }
 }
 
 TEST_CASE("TestConcatTables")

From 35e208b13fb4c30c38ff4b3d05535fb370b53c0a Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 19 May 2025 11:07:42 +0200
Subject: [PATCH 0377/1764] DPL Analysis: prevent slice cache from updating
 unnecessarily (#14257)

* Cache setup now only happens after init when process configurables'
  values are final
* Add inline contrained functions to avoid using "overloaded"
* add error messages for unexpected situations
---
 Framework/Core/include/Framework/ASoA.h       |  12 +--
 .../Core/include/Framework/AnalysisManagers.h |  14 ++-
 .../Core/include/Framework/AnalysisTask.h     | 102 ++++++++++++------
 .../Framework/ArrowTableSlicingCache.h        |  45 +++++---
 .../Core/include/Framework/GroupSlicer.h      |   2 +-
 Framework/Core/src/ASoA.cxx                   |   2 +-
 Framework/Core/src/ArrowSupport.cxx           |  19 ++--
 Framework/Core/src/ArrowTableSlicingCache.cxx |  60 +++++++----
 Framework/Core/test/test_GroupSlicer.cxx      |   4 +-
 9 files changed, 167 insertions(+), 93 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index c13cfe912c814..4ed8e830fe137 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1400,10 +1400,10 @@ namespace o2::framework
 
 struct PreslicePolicyBase {
   const std::string binding;
-  StringPair bindingKey;
+  Entry bindingKey;
 
   bool isMissing() const;
-  StringPair const& getBindingKey() const;
+  Entry const& getBindingKey() const;
 };
 
 struct PreslicePolicySorted : public PreslicePolicyBase {
@@ -1428,7 +1428,7 @@ struct PresliceBase : public Policy {
   const std::string binding;
 
   PresliceBase(expressions::BindingNode index_)
-    : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, std::make_pair(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
+    : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, Entry(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
   {
   }
 
@@ -1508,7 +1508,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.second.c_str());
+      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.key.c_str());
     }
   }
   uint64_t offset = 0;
@@ -1545,7 +1545,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.second.c_str());
+      missingOptionalPreslice(getLabelFromType<std::decay_t<T>>().data(), container.bindingKey.key.c_str());
     }
   }
   auto selection = container.getSliceFor(value);
@@ -1574,7 +1574,7 @@ auto doFilteredSliceBy(T const* table, o2::framework::PresliceBase<C, framework:
 {
   if constexpr (OPT) {
     if (container.isMissing()) {
-      missingOptionalPreslice(getLabelFromType<T>().data(), container.bindingKey.second.c_str());
+      missingOptionalPreslice(getLabelFromType<T>().data(), container.bindingKey.key.c_str());
     }
   }
   uint64_t offset = 0;
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index b76d88ea5ee66..1d894b2b67948 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -534,39 +534,43 @@ static void setGroupedCombination(C& comb, TG& grouping, std::tuple<Ts...>& asso
 /// Preslice handling
 template <typename T>
   requires(!is_preslice<T>)
-bool registerCache(T&, std::vector<StringPair>&, std::vector<StringPair>&)
+bool registerCache(T&, Cache&, Cache&)
 {
   return false;
 }
 
 template <is_preslice T>
   requires std::same_as<typename T::policy_t, framework::PreslicePolicySorted>
-bool registerCache(T& preslice, std::vector<StringPair>& bsks, std::vector<StringPair>&)
+bool registerCache(T& preslice, Cache& bsks, Cache&)
 {
   if constexpr (T::optional) {
     if (preslice.binding == "[MISSING]") {
       return true;
     }
   }
-  auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); });
+  auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); });
   if (locate == bsks.end()) {
     bsks.emplace_back(preslice.getBindingKey());
+  } else if (locate->enabled == false) {
+    locate->enabled = true;
   }
   return true;
 }
 
 template <is_preslice T>
   requires std::same_as<typename T::policy_t, framework::PreslicePolicyGeneral>
-bool registerCache(T& preslice, std::vector<StringPair>&, std::vector<StringPair>& bsksU)
+bool registerCache(T& preslice, Cache&, Cache& bsksU)
 {
   if constexpr (T::optional) {
     if (preslice.binding == "[MISSING]") {
       return true;
     }
   }
-  auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.first == preslice.bindingKey.first) && (entry.second == preslice.bindingKey.second); });
+  auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); });
   if (locate == bsksU.end()) {
     bsksU.emplace_back(preslice.getBindingKey());
+  } else if (locate->enabled == false) {
+    locate->enabled = true;
   }
   return true;
 }
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 257a5358463c6..b53929f326712 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -65,21 +65,18 @@ concept is_enumeration = is_enumeration_v<std::decay_t<T>>;
 // the contents of an AnalysisTask...
 namespace {
 struct AnalysisDataProcessorBuilder {
-  template <typename G, typename... Args>
-  static void addGroupingCandidates(std::vector<StringPair>& bk, std::vector<StringPair>& bku)
+  template <soa::is_iterator G, typename... Args>
+  static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled)
   {
-    [&bk, &bku]<typename... As>(framework::pack<As...>) mutable {
-      std::string key;
-      if constexpr (soa::is_iterator<std::decay_t<G>>) {
-        key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
-      }
-      ([&bk, &bku, &key]() mutable {
+    [&bk, &bku, enabled]<typename... As>(framework::pack<As...>) mutable {
+      auto key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
+      ([&bk, &bku, &key, enabled]() mutable {
         if constexpr (soa::relatedByIndex<std::decay_t<G>, std::decay_t<As>>()) {
           auto binding = soa::getLabelFromTypeForKey<std::decay_t<As>>(key);
           if constexpr (o2::soa::is_smallgroups<std::decay_t<As>>) {
-            framework::updatePairList(bku, binding, key);
+            framework::updatePairList(bku, binding, key, enabled);
           } else {
-            framework::updatePairList(bk, binding, key);
+            framework::updatePairList(bk, binding, key, enabled);
           }
         }
       }(),
@@ -145,34 +142,72 @@ struct AnalysisDataProcessorBuilder {
   }
 
   /// helper to parse the process arguments
+  template <typename T>
+  inline static bool requestInputsFromArgs(T&, std::string const&, std::vector<InputSpec>&, std::vector<ExpressionInfo>&)
+  {
+    return false;
+  }
+  template <is_process_configurable T>
+  inline static bool requestInputsFromArgs(T& pc, std::string const& name, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eis)
+  {
+    AnalysisDataProcessorBuilder::inputsFromArgs(pc.process, (name + "/" + pc.name).c_str(), pc.value, inputs, eis);
+    return true;
+  }
+  template <typename T>
+  inline static bool requestCacheFromArgs(T&, Cache&, Cache&)
+  {
+    return false;
+  }
+  template <is_process_configurable T>
+  inline static bool requestCacheFromArgs(T& pc, Cache& bk, Cache& bku)
+  {
+    AnalysisDataProcessorBuilder::cacheFromArgs(pc.process, pc.value, bk, bku);
+    return true;
+  }
   /// 1. enumeration (must be the only argument)
   template <typename R, typename C, is_enumeration A>
-  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&, std::vector<StringPair>&, std::vector<StringPair>&)
+  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&) //, Cache&, Cache&)
   {
     std::vector<ConfigParamSpec> inputMetadata;
     // FIXME: for the moment we do not support begin, end and step.
     DataSpecUtils::updateInputList(inputs, InputSpec{"enumeration", "DPL", "ENUM", 0, Lifetime::Enumeration, inputMetadata});
   }
 
-  /// 2. grouping case - 1st argument is an iterator
+  /// 2. 1st argument is an iterator
   template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, std::vector<StringPair>& bk, std::vector<StringPair>& bku)
+  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache& bk, Cache& bku)
     requires(std::is_lvalue_reference_v<A> && (std::is_lvalue_reference_v<Args> && ...))
   {
-    addGroupingCandidates<A, Args...>(bk, bku);
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(A, Args...)>();
     addInputsAndExpressions<typename std::decay_t<A>::parent_t, Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 3. generic case
   template <typename R, typename C, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos, std::vector<StringPair>&, std::vector<StringPair>&)
+  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache&, Cache&)
     requires(std::is_lvalue_reference_v<Args> && ...)
   {
     constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Args...)>();
     addInputsAndExpressions<Args...>(hash, name, value, inputs, eInfos);
   }
 
+  /// 1. enumeration (no grouping)
+  template <typename R, typename C, is_enumeration A>
+  static void cacheFromArgs(R (C::*)(A), bool, Cache&, Cache&)
+  {
+  }
+  /// 2. iterator (the only grouping case)
+  template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
+  static void cacheFromArgs(R (C::*)(A, Args...), bool value, Cache& bk, Cache& bku)
+  {
+    addGroupingCandidates<A, Args...>(bk, bku, value);
+  }
+  /// 3. generic case (no grouping)
+  template <typename R, typename C, soa::is_table A, soa::is_table... Args>
+  static void cacheFromArgs(R (C::*)(A, Args...), bool, Cache&, Cache&)
+  {
+  }
+
   template <soa::TableRef R>
   static auto extractTableFromRecord(InputRecord& record)
   {
@@ -480,8 +515,6 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<InputSpec> inputs;
   std::vector<ConfigParamSpec> options;
   std::vector<ExpressionInfo> expressionInfos;
-  std::vector<StringPair> bindingsKeys;
-  std::vector<StringPair> bindingsKeysUnsorted;
 
   /// make sure options and configurables are set before expression infos are created
   homogeneous_apply_refs([&options, &hash](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
@@ -490,23 +523,15 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
 
   /// parse process functions defined by corresponding configurables
   if constexpr (requires { &T::process; }) {
-    AnalysisDataProcessorBuilder::inputsFromArgs(&T::process, "default", true, inputs, expressionInfos, bindingsKeys, bindingsKeysUnsorted);
+    AnalysisDataProcessorBuilder::inputsFromArgs(&T::process, "default", true, inputs, expressionInfos);
   }
   homogeneous_apply_refs(
-    overloaded{
-      [name = name_str, &expressionInfos, &inputs, &bindingsKeys, &bindingsKeysUnsorted](framework::is_process_configurable auto& x) mutable {
-        // this pushes (argumentIndex,processHash,schemaPtr,nullptr) into expressionInfos for arguments that are Filtered/filtered_iterators
-        AnalysisDataProcessorBuilder::inputsFromArgs(x.process, (name + "/" + x.name).c_str(), x.value, inputs, expressionInfos, bindingsKeys, bindingsKeysUnsorted);
-        return true;
-      },
-      [](auto&) {
-        return false;
-      }},
+    [name = name_str, &expressionInfos, &inputs](auto& x) mutable {
+      // this pushes (argumentIndex, processHash, schemaPtr, nullptr) into expressionInfos for arguments that are Filtered/filtered_iterators
+      return AnalysisDataProcessorBuilder::requestInputsFromArgs(x, name, inputs, expressionInfos);
+    },
     *task.get());
 
-  // add preslice declarations to slicing cache definition
-  homogeneous_apply_refs([&bindingsKeys, &bindingsKeysUnsorted](auto& element) { return analysis_task_parsers::registerCache(element, bindingsKeys, bindingsKeysUnsorted); }, *task.get());
-
   // request base tables for spawnable extended tables and indices to be built
   // this checks for duplications
   homogeneous_apply_refs([&inputs](auto& element) {
@@ -526,7 +551,12 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   requiredServices.insert(requiredServices.end(), arrowServices.begin(), arrowServices.end());
   homogeneous_apply_refs([&requiredServices](auto& element) { return analysis_task_parsers::addService(requiredServices, element); }, *task.get());
 
-  auto algo = AlgorithmSpec::InitCallback{[task = task, expressionInfos, bindingsKeys, bindingsKeysUnsorted](InitContext& ic) mutable {
+  auto algo = AlgorithmSpec::InitCallback{[task = task, expressionInfos](InitContext& ic) mutable {
+    Cache bindingsKeys;
+    Cache bindingsKeysUnsorted;
+    // add preslice declarations to slicing cache definition
+    homogeneous_apply_refs([&bindingsKeys, &bindingsKeysUnsorted](auto& element) { return analysis_task_parsers::registerCache(element, bindingsKeys, bindingsKeysUnsorted); }, *task.get());
+
     homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareOption(ic, element); }, *task.get());
     homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareService(ic, element); }, *task.get());
 
@@ -556,6 +586,16 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
       task->init(ic);
     }
 
+    /// parse process functions to enable requested grouping caches - note that at this state process configurables have their final values
+    if constexpr (requires { &T::process; }) {
+      AnalysisDataProcessorBuilder::cacheFromArgs(&T::process, true, bindingsKeys, bindingsKeysUnsorted);
+    }
+    homogeneous_apply_refs(
+      [&bindingsKeys, &bindingsKeysUnsorted](auto& x) mutable {
+        return AnalysisDataProcessorBuilder::requestCacheFromArgs(x, bindingsKeys, bindingsKeysUnsorted);
+      },
+      *task.get());
+
     ic.services().get<ArrowTableSlicingCacheDef>().setCaches(std::move(bindingsKeys));
     ic.services().get<ArrowTableSlicingCacheDef>().setCachesUnsorted(std::move(bindingsKeysUnsorted));
     // initialize global caches
diff --git a/Framework/Core/include/Framework/ArrowTableSlicingCache.h b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
index 2edc23a63ce76..292a67023fc5e 100644
--- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h
+++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
@@ -34,51 +34,64 @@ struct SliceInfoUnsortedPtr {
   gsl::span<int64_t const> getSliceFor(int value) const;
 };
 
-using StringPair = std::pair<std::string, std::string>;
+struct Entry {
+  std::string binding;
+  std::string key;
+  bool enabled;
+
+  Entry(std::string b, std::string k, bool e = true)
+    : binding{b},
+      key{k},
+      enabled{e}
+  {
+  }
+};
+
+using Cache = std::vector<Entry>;
 
-void updatePairList(std::vector<StringPair>& list, std::string const& binding, std::string const& key);
+void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled);
 
 struct ArrowTableSlicingCacheDef {
   constexpr static ServiceKind service_kind = ServiceKind::Global;
-  std::vector<StringPair> bindingsKeys;
-  std::vector<StringPair> bindingsKeysUnsorted;
+  Cache bindingsKeys;
+  Cache bindingsKeysUnsorted;
 
-  void setCaches(std::vector<StringPair>&& bsks);
-  void setCachesUnsorted(std::vector<StringPair>&& bsks);
+  void setCaches(Cache&& bsks);
+  void setCachesUnsorted(Cache&& bsks);
 };
 
 struct ArrowTableSlicingCache {
   constexpr static ServiceKind service_kind = ServiceKind::Stream;
 
-  std::vector<StringPair> bindingsKeys;
+  Cache bindingsKeys;
   std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int32Type>>> values;
   std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int64Type>>> counts;
 
-  std::vector<StringPair> bindingsKeysUnsorted;
+  Cache bindingsKeysUnsorted;
   std::vector<std::vector<int>> valuesUnsorted;
   std::vector<ListVector> groups;
 
-  ArrowTableSlicingCache(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted = {});
+  ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted = {});
 
   // set caching information externally
-  void setCaches(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted = {});
+  void setCaches(Cache&& bsks, Cache&& bsksUnsorted = {});
 
   // update slicing info cache entry (assumes it is already present)
   arrow::Status updateCacheEntry(int pos, std::shared_ptr<arrow::Table> const& table);
   arrow::Status updateCacheEntryUnsorted(int pos, std::shared_ptr<arrow::Table> const& table);
 
   // helper to locate cache position
-  std::pair<int, bool> getCachePos(StringPair const& bindingKey) const;
-  int getCachePosSortedFor(StringPair const& bindingKey) const;
-  int getCachePosUnsortedFor(StringPair const& bindingKey) const;
+  std::pair<int, bool> getCachePos(Entry const& bindingKey) const;
+  int getCachePosSortedFor(Entry const& bindingKey) const;
+  int getCachePosUnsortedFor(Entry const& bindingKey) const;
 
   // get slice from cache for a given value
-  SliceInfoPtr getCacheFor(StringPair const& bindingKey) const;
-  SliceInfoUnsortedPtr getCacheUnsortedFor(StringPair const& bindingKey) const;
+  SliceInfoPtr getCacheFor(Entry const& bindingKey) const;
+  SliceInfoUnsortedPtr getCacheUnsortedFor(Entry const& bindingKey) const;
   SliceInfoPtr getCacheForPos(int pos) const;
   SliceInfoUnsortedPtr getCacheUnsortedForPos(int pos) const;
 
-  static void validateOrder(StringPair const& bindingKey, std::shared_ptr<arrow::Table> const& input);
+  static void validateOrder(Entry const& bindingKey, std::shared_ptr<arrow::Table> const& input);
 };
 } // namespace o2::framework
 
diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h
index 64b1d863c59e6..b8436314b057e 100644
--- a/Framework/Core/include/Framework/GroupSlicer.h
+++ b/Framework/Core/include/Framework/GroupSlicer.h
@@ -55,7 +55,7 @@ struct GroupSlicer {
     {
       constexpr auto index = framework::has_type_at_v<std::decay_t<T>>(associated_pack_t{});
       auto binding = o2::soa::getLabelFromTypeForKey<std::decay_t<T>>(mIndexColumnName);
-      auto bk = std::make_pair(binding, mIndexColumnName);
+      auto bk = Entry(binding, mIndexColumnName);
       if constexpr (!o2::soa::is_smallgroups<std::decay_t<T>>) {
         if (table.size() == 0) {
           return;
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index bd6ca551d24ec..3a681ee931a2b 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -194,7 +194,7 @@ bool PreslicePolicyBase::isMissing() const
   return binding == "[MISSING]";
 }
 
-StringPair const& PreslicePolicyBase::getBindingKey() const
+Entry const& PreslicePolicyBase::getBindingKey() const
 {
   return bindingKey;
 }
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 12a4c7131e828..3b13e30581f70 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -567,26 +567,27 @@ o2::framework::ServiceSpec ArrowSupport::arrowTableSlicingCacheSpec()
     .name = "arrow-slicing-cache",
     .uniqueId = CommonServices::simpleServiceId<ArrowTableSlicingCache>(),
     .init = [](ServiceRegistryRef services, DeviceState&, fair::mq::ProgOptions&) { return ServiceHandle{TypeIdHelpers::uniqueId<ArrowTableSlicingCache>(),
-                                                                                                         new ArrowTableSlicingCache(std::vector<std::pair<std::string, std::string>>{services.get<ArrowTableSlicingCacheDef>().bindingsKeys}, std::vector{services.get<ArrowTableSlicingCacheDef>().bindingsKeysUnsorted}),
+                                                                                                         new ArrowTableSlicingCache(Cache{services.get<ArrowTableSlicingCacheDef>().bindingsKeys},
+                                                                                                                                    Cache{services.get<ArrowTableSlicingCacheDef>().bindingsKeysUnsorted}),
                                                                                                          ServiceKind::Stream, typeid(ArrowTableSlicingCache).name()}; },
     .configure = CommonServices::noConfiguration(),
     .preProcessing = [](ProcessingContext& pc, void* service_ptr) {
       auto* service = static_cast<ArrowTableSlicingCache*>(service_ptr);
       auto& caches = service->bindingsKeys;
-      for (auto i = 0; i < caches.size(); ++i) {
-        if (pc.inputs().getPos(caches[i].first.c_str()) >= 0) {
-          auto status = service->updateCacheEntry(i, pc.inputs().get<TableConsumer>(caches[i].first.c_str())->asArrowTable());
+      for (auto i = 0u; i < caches.size(); ++i) {
+        if (caches[i].enabled && pc.inputs().getPos(caches[i].binding.c_str()) >= 0) {
+          auto status = service->updateCacheEntry(i, pc.inputs().get<TableConsumer>(caches[i].binding.c_str())->asArrowTable());
           if (!status.ok()) {
-            throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].first.c_str(), caches[i].second.c_str());
+            throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].binding.c_str(), caches[i].key.c_str());
           }
         }
       }
       auto& unsortedCaches = service->bindingsKeysUnsorted;
-      for (auto i = 0; i < unsortedCaches.size(); ++i) {
-        if (pc.inputs().getPos(unsortedCaches[i].first.c_str()) >= 0) {
-          auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get<TableConsumer>(unsortedCaches[i].first.c_str())->asArrowTable());
+      for (auto i = 0u; i < unsortedCaches.size(); ++i) {
+        if (unsortedCaches[i].enabled && pc.inputs().getPos(unsortedCaches[i].binding.c_str()) >= 0) {
+          auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get<TableConsumer>(unsortedCaches[i].binding.c_str())->asArrowTable());
           if (!status.ok()) {
-            throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].first.c_str(), unsortedCaches[i].second.c_str());
+            throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].binding.c_str(), unsortedCaches[i].key.c_str());
           }
         }
       } },
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 4b31f96e32fba..e001e293c4733 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -19,10 +19,13 @@
 namespace o2::framework
 {
 
-void updatePairList(std::vector<StringPair>& list, std::string const& binding, std::string const& key)
+void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled = true)
 {
-  if (std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.first == binding) && (entry.second == key); }) == list.end()) {
-    list.emplace_back(binding, key);
+  auto locate = std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.binding == binding) && (entry.key == key); });
+  if (locate == list.end()) {
+    list.emplace_back(binding, key, enabled);
+  } else if (!locate->enabled && enabled) {
+    locate->enabled = true;
   }
 }
 
@@ -65,17 +68,17 @@ gsl::span<const int64_t> SliceInfoUnsortedPtr::getSliceFor(int value) const
   return {(*groups)[value].data(), (*groups)[value].size()};
 }
 
-void ArrowTableSlicingCacheDef::setCaches(std::vector<StringPair>&& bsks)
+void ArrowTableSlicingCacheDef::setCaches(Cache&& bsks)
 {
   bindingsKeys = bsks;
 }
 
-void ArrowTableSlicingCacheDef::setCachesUnsorted(std::vector<StringPair>&& bsks)
+void ArrowTableSlicingCacheDef::setCachesUnsorted(Cache&& bsks)
 {
   bindingsKeysUnsorted = bsks;
 }
 
-ArrowTableSlicingCache::ArrowTableSlicingCache(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted)
+ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorted)
   : bindingsKeys{bsks},
     bindingsKeysUnsorted{bsksUnsorted}
 {
@@ -86,7 +89,7 @@ ArrowTableSlicingCache::ArrowTableSlicingCache(std::vector<StringPair>&& bsks, s
   groups.resize(bindingsKeysUnsorted.size());
 }
 
-void ArrowTableSlicingCache::setCaches(std::vector<StringPair>&& bsks, std::vector<StringPair>&& bsksUnsorted)
+void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted)
 {
   bindingsKeys = bsks;
   bindingsKeysUnsorted = bsksUnsorted;
@@ -107,11 +110,15 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
     counts[pos].reset();
     return arrow::Status::OK();
   }
+  auto& [b, k, e] = bindingsKeys[pos];
+  if (!e) {
+    throw runtime_error_f("Disabled cache %s/%s update requested", b.c_str(), k.c_str());
+  }
   validateOrder(bindingsKeys[pos], table);
   arrow::Datum value_counts;
   auto options = arrow::compute::ScalarAggregateOptions::Defaults();
   ARROW_ASSIGN_OR_RAISE(value_counts,
-                        arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].second)},
+                        arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].key)},
                                                      &options));
   auto pair = static_cast<arrow::StructArray>(value_counts.array());
   values[pos].reset();
@@ -128,7 +135,10 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
   if (table->num_rows() == 0) {
     return arrow::Status::OK();
   }
-  auto& [b, k] = bindingsKeysUnsorted[pos];
+  auto& [b, k, e] = bindingsKeysUnsorted[pos];
+  if (!e) {
+    throw runtime_error_f("Disabled unsorted cache %s/%s update requested", b.c_str(), k.c_str());
+  }
   auto column = table->GetColumnByName(k);
   auto row = 0;
   for (auto iChunk = 0; iChunk < column->num_chunks(); ++iChunk) {
@@ -139,7 +149,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
         if (std::find(valuesUnsorted[pos].begin(), valuesUnsorted[pos].end(), v) == valuesUnsorted[pos].end()) {
           valuesUnsorted[pos].push_back(v);
         }
-        if (groups[pos].size() <= v) {
+        if ((int)groups[pos].size() <= v) {
           groups[pos].resize(v + 1);
         }
         (groups[pos])[v].push_back(row);
@@ -151,7 +161,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
   return arrow::Status::OK();
 }
 
-std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const StringPair& bindingKey) const
+std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const Entry& bindingKey) const
 {
   auto pos = getCachePosSortedFor(bindingKey);
   if (pos != -1) {
@@ -161,41 +171,47 @@ std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const StringPair& bindi
   if (pos != -1) {
     return {pos, false};
   }
-  throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
+  throw runtime_error_f("%s/%s not found neither in sorted or unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
 }
 
-int ArrowTableSlicingCache::getCachePosSortedFor(StringPair const& bindingKey) const
+int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const
 {
-  auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); });
+  auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); });
   if (locate != bindingsKeys.end()) {
     return std::distance(bindingsKeys.begin(), locate);
   }
   return -1;
 }
 
-int ArrowTableSlicingCache::getCachePosUnsortedFor(StringPair const& bindingKey) const
+int ArrowTableSlicingCache::getCachePosUnsortedFor(Entry const& bindingKey) const
 {
-  auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](StringPair const& bk) { return (bindingKey.first == bk.first) && (bindingKey.second == bk.second); });
+  auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); });
   if (locate_unsorted != bindingsKeysUnsorted.end()) {
     return std::distance(bindingsKeysUnsorted.begin(), locate_unsorted);
   }
   return -1;
 }
-SliceInfoPtr ArrowTableSlicingCache::getCacheFor(StringPair const& bindingKey) const
+SliceInfoPtr ArrowTableSlicingCache::getCacheFor(Entry const& bindingKey) const
 {
   auto [p, s] = getCachePos(bindingKey);
   if (!s) {
-    throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
+    throw runtime_error_f("%s/%s is found in unsorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
+  }
+  if (!bindingsKeys[p].enabled) {
+    throw runtime_error_f("Disabled cache %s/%s is requested", bindingKey.binding.c_str(), bindingKey.key.c_str());
   }
 
   return getCacheForPos(p);
 }
 
-SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const StringPair& bindingKey) const
+SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const Entry& bindingKey) const
 {
   auto [p, s] = getCachePos(bindingKey);
   if (s) {
-    throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.first.c_str(), bindingKey.second.c_str());
+    throw runtime_error_f("%s/%s is found in sorted cache", bindingKey.binding.c_str(), bindingKey.key.c_str());
+  }
+  if (!bindingsKeysUnsorted[p].enabled) {
+    throw runtime_error_f("Disabled unsorted cache %s/%s is requested", bindingKey.binding.c_str(), bindingKey.key.c_str());
   }
 
   return getCacheUnsortedForPos(p);
@@ -224,9 +240,9 @@ SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedForPos(int pos) con
   };
 }
 
-void ArrowTableSlicingCache::validateOrder(StringPair const& bindingKey, const std::shared_ptr<arrow::Table>& input)
+void ArrowTableSlicingCache::validateOrder(Entry const& bindingKey, const std::shared_ptr<arrow::Table>& input)
 {
-  auto const& [target, key] = bindingKey;
+  auto const& [target, key, enabled] = bindingKey;
   auto column = input->GetColumnByName(key);
   auto array0 = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(0)->data());
   int32_t prev = 0;
diff --git a/Framework/Core/test/test_GroupSlicer.cxx b/Framework/Core/test/test_GroupSlicer.cxx
index 161939141e790..091c21eeae229 100644
--- a/Framework/Core/test/test_GroupSlicer.cxx
+++ b/Framework/Core/test/test_GroupSlicer.cxx
@@ -683,7 +683,7 @@ TEST_CASE("ArrowDirectSlicing")
 
   std::vector<arrow::Datum> slices;
   std::vector<uint64_t> offsts;
-  auto bk = std::make_pair(soa::getLabelFromType<aod::Events>(), "fID");
+  auto bk = Entry(soa::getLabelFromType<aod::Events>(), "fID");
   ArrowTableSlicingCache cache({bk});
   auto s = cache.updateCacheEntry(0, {evtTable});
   auto lcache = cache.getCacheFor(bk);
@@ -741,7 +741,7 @@ TEST_CASE("TestSlicingException")
   }
   auto evtTable = builderE.finalize();
 
-  auto bk = std::make_pair(soa::getLabelFromType<aod::Events>(), "fID");
+  auto bk = Entry(soa::getLabelFromType<aod::Events>(), "fID");
   ArrowTableSlicingCache cache({bk});
 
   try {

From 0c5140edf08d83042e2b8362eb152db6e01e3177 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Mon, 19 May 2025 12:48:54 +0200
Subject: [PATCH 0378/1764] NN clustering: VRAM memory leak fix + (u)int ->
 (u)int32_t (#14272)

* VRAM memory leak fix + (u)int -> (u)int32_t

* Please consider the following formatting changes

* Fixing my own debug messages

* Making shared pointer for releasing

* Bug-fix

* Adding Davids patch

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Common/ML/include/ML/OrtInterface.h           |  14 +--
 Common/ML/src/OrtInterface.cxx                |  42 ++++---
 .../Global/GPUChainTrackingClusterizer.cxx    |  33 ++++--
 .../GPUTPCNNClusterizerHost.cxx               |  23 ++--
 .../GPUTPCNNClusterizerHost.h                 |   2 +-
 .../GPUTPCNNClusterizerKernels.cxx            | 108 +++++++++---------
 .../GPUTPCNNClusterizerKernels.h              |   7 +-
 7 files changed, 128 insertions(+), 101 deletions(-)

diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index b4f40f3f5c694..7224645425856 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -45,14 +45,10 @@ class OrtModel
 
  public:
   // Constructors & destructors
-  OrtModel() = default;
-  OrtModel(std::unordered_map<std::string, std::string> optionsMap) { init(optionsMap); }
-  void init(std::unordered_map<std::string, std::string> optionsMap)
-  {
-    initOptions(optionsMap);
-    initEnvironment();
-  }
-  virtual ~OrtModel() = default;
+  OrtModel();
+  OrtModel(std::unordered_map<std::string, std::string> optionsMap);
+  void init(std::unordered_map<std::string, std::string> optionsMap);
+  virtual ~OrtModel();
 
   // General purpose
   void initOptions(std::unordered_map<std::string, std::string> optionsMap);
@@ -113,7 +109,7 @@ class OrtModel
  private:
   // ORT variables -> need to be hidden as pImpl
   struct OrtVariables;
-  OrtVariables* mPImplOrt;
+  std::unique_ptr<OrtVariables> mPImplOrt;
 
   // Input & Output specifications of the loaded network
   std::vector<const char*> mInputNamesChar, mOutputNamesChar;
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index df7f0a2deba82..8f31761489997 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -27,11 +27,20 @@ namespace o2
 namespace ml
 {
 
+OrtModel::OrtModel() = default;
+OrtModel::OrtModel(std::unordered_map<std::string, std::string> optionsMap) { init(optionsMap); }
+OrtModel::~OrtModel() = default;
+void OrtModel::init(std::unordered_map<std::string, std::string> optionsMap)
+{
+  initOptions(optionsMap);
+  initEnvironment();
+}
+
 struct OrtModel::OrtVariables { // The actual implementation is hidden in the .cxx file
   // ORT runtime objects
   Ort::RunOptions runOptions;
-  std::shared_ptr<Ort::Env> env = nullptr;
-  std::shared_ptr<Ort::Session> session = nullptr; ///< ONNX session
+  std::unique_ptr<Ort::Env> env = nullptr;
+  std::unique_ptr<Ort::Session> session = nullptr; ///< ONNX session
   Ort::SessionOptions sessionOptions;
   Ort::AllocatorWithDefaultOptions allocator;
   Ort::MemoryInfo memoryInfo = Ort::MemoryInfo("Cpu", OrtAllocatorType::OrtDeviceAllocator, 0, OrtMemType::OrtMemTypeDefault);
@@ -41,7 +50,7 @@ struct OrtModel::OrtVariables { // The actual implementation is hidden in the .c
 // General purpose
 void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsMap)
 {
-  mPImplOrt = new OrtVariables();
+  mPImplOrt = std::make_unique<OrtVariables>();
 
   // Load from options map
   if (!optionsMap.contains("model-path")) {
@@ -101,7 +110,7 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
 
 void OrtModel::initEnvironment()
 {
-  mPImplOrt->env = std::make_shared<Ort::Env>(
+  mPImplOrt->env = std::make_unique<Ort::Env>(
     OrtLoggingLevel(mLoggingLevel),
     (mEnvName.empty() ? "ORT" : mEnvName.c_str()),
     // Integrate ORT logging into Fairlogger
@@ -129,7 +138,7 @@ void OrtModel::initSession()
   if (mAllocateDeviceMemory) {
     memoryOnDevice(mDeviceId);
   }
-  mPImplOrt->session = std::make_shared<Ort::Session>(*mPImplOrt->env, mModelPath.c_str(), mPImplOrt->sessionOptions);
+  mPImplOrt->session = std::make_unique<Ort::Session>(*mPImplOrt->env, mModelPath.c_str(), mPImplOrt->sessionOptions);
   mPImplOrt->ioBinding = std::make_unique<Ort::IoBinding>(*mPImplOrt->session);
 
   setIO();
@@ -147,12 +156,12 @@ void OrtModel::memoryOnDevice(int32_t deviceIndex)
     (mPImplOrt->sessionOptions).AddConfigEntry("session.use_env_allocators", "1");                    // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
     (mPImplOrt->sessionOptions).AddConfigEntry("session_options.enable_cpu_mem_arena", "0");          // This should enable to use the volatile memory allocation defined in O2/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx; not working yet: ONNX still assigns new memory at init time
     // Arena memory shrinkage comes at performance cost
-    /// For now prefer to use single allocation, enabled by O2/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu -> SetONNXGPUStream -> rocm_options.arena_extend_strategy = 0;
-    // (mPImplOrt->runOptions).AddConfigEntry("memory.enable_memory_arena_shrinkage", ("gpu:" + std::to_string(deviceIndex)).c_str()); // See kOrtRunOptionsConfigEnableMemoryArenaShrinkage, https://github.com/microsoft/onnxruntime/blob/90c263f471bbce724e77d8e62831d3a9fa838b2f/include/onnxruntime/core/session/onnxruntime_run_options_config_keys.h#L27
+    // For now prefer to use single allocation, enabled by O2/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu -> SetONNXGPUStream -> rocm_options.arena_extend_strategy = 0;
+    (mPImplOrt->runOptions).AddConfigEntry("memory.enable_memory_arena_shrinkage", ("gpu:" + std::to_string(deviceIndex)).c_str()); // See kOrtRunOptionsConfigEnableMemoryArenaShrinkage, https://github.com/microsoft/onnxruntime/blob/90c263f471bbce724e77d8e62831d3a9fa838b2f/include/onnxruntime/core/session/onnxruntime_run_options_config_keys.h#L27
 
     std::string dev_mem_str = "";
     if (mDeviceType == "ROCM") {
-      dev_mem_str = "Hip";
+      dev_mem_str = "HipPinned";
     }
     if (mDeviceType == "CUDA") {
       dev_mem_str = "Cuda";
@@ -166,7 +175,7 @@ void OrtModel::memoryOnDevice(int32_t deviceIndex)
 
 void OrtModel::resetSession()
 {
-  mPImplOrt->session = std::make_shared<Ort::Session>(*(mPImplOrt->env), mModelPath.c_str(), mPImplOrt->sessionOptions);
+  mPImplOrt->session = std::make_unique<Ort::Session>(*(mPImplOrt->env), mModelPath.c_str(), mPImplOrt->sessionOptions);
 }
 
 // Getters
@@ -252,7 +261,7 @@ void OrtModel::setIO()
 
 void OrtModel::setEnv(Ort::Env* env)
 {
-  mPImplOrt->env = std::shared_ptr<Ort::Env>(env);
+  mPImplOrt->env.reset(env);
 }
 
 // Inference
@@ -308,6 +317,14 @@ void OrtModel::inference(I* input, int64_t input_size, O* output)
   (mPImplOrt->ioBinding)->BindOutput(mOutputNames[0].c_str(), outputTensor);
 
   (mPImplOrt->session)->Run(mPImplOrt->runOptions, *mPImplOrt->ioBinding);
+  // mPImplOrt->session->Run(
+  //   mPImplOrt->runOptions,
+  //   mInputNamesChar.data(),
+  //   &inputTensor,
+  //   mInputNamesChar.size(),
+  //   mOutputNamesChar.data(),
+  //   &outputTensor,
+  //   mOutputNamesChar.size());
 }
 
 template void OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(OrtDataType::Float16_t*, int64_t, OrtDataType::Float16_t*);
@@ -427,10 +444,7 @@ template std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Fl
 // Release session
 void OrtModel::release(bool profilingEnabled)
 {
-  // if (profilingEnabled) {
-  //   mPImplOrt->session->EndProfiling();
-  // }
-  LOG(info) << "(ORT) Size of mPImplOrt: " << sizeof(*mPImplOrt) << " bytes";
+  mPImplOrt.reset();
 }
 
 // private
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 2cdd1bb76bf00..6c4e60a6025e1 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -659,7 +659,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         // But environment must be valid, so we init the model environment first and use it here afterwards.
         // Either this is done in one environment with lane == 0 or by recreating the allocator using recreateMemoryAllocator.
         // TODO: Volatile allocation works for reserving, but not yet for allocations when binding the input tensor
-        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        // if (lane == 0) {
+        //   nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        // }
         // recreateMemoryAllocator = true;
         (nnApplications[lane].mModelClass).initSession();
       }
@@ -671,7 +673,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         }
         // (nnApplications[lane].mModelReg1).setEnv((nnApplications[lane].mModelClass).getEnv());
         (nnApplications[lane].mModelReg1).initEnvironment();
-        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].mModelReg1).getEnv(), (nnApplications[lane].mModelReg1).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        // nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelReg1).getEnv(), (nnApplications[lane].mModelReg1).getMemoryInfo(), mRec, recreateMemoryAllocator);
         (nnApplications[lane].mModelReg1).initSession();
       }
       if (nnApplications[lane].mModelsUsed[2]) {
@@ -680,8 +682,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         if (nnApplications[lane].mModelReg2.getIntraOpNumThreads() > maxThreads) {
           nnApplications[lane].mModelReg2.setIntraOpNumThreads(maxThreads);
         }
+        // (nnApplications[lane].mModelReg2).setEnv((nnApplications[lane].mModelClass).getEnv());
         (nnApplications[lane].mModelReg2).initEnvironment();
-        // nnApplications[lane].volatileOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
+        // nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
         (nnApplications[lane].mModelReg2).initSession();
       }
       if (nn_settings.nnClusterizerVerbosity < 3) {
@@ -707,8 +710,6 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     if (doGPU) {
       WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->tpcNNClusterer - (char*)processors(), &processorsShadow()->tpcNNClusterer, sizeof(GPUTPCNNClusterizer) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);
     }
-    LOG(info) << "Size of nnApplications[lane]: " << sizeof(nnApplications[0]) << " bytes";
-    LOG(info) << "Size of nnApplications: " << sizeof(GPUTPCNNClusterizerHost) * GetProcessingSettings().nTPCClustererLanes << " bytes";
   }
 #endif
 
@@ -976,6 +977,15 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[lane] : clustererNN;
           GPUTPCNNClusterizerHost& nnApplication = nnApplications[lane];
 
+          // // bool recreateMemoryAllocator = false;
+          // if (lane == 0) {
+          //   (nnApplications[lane].mModelClass).initEnvironment();
+          //   nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, 0);
+          // }
+          // // recreateMemoryAllocator = true;
+          // (nnApplications[lane].mModelClass).initSession();
+          // (nnApplications[lane].mModelReg1).initSession();
+
           int withMC = (doGPU && propagateMCLabels);
 
           if (clustererNNShadow.mNnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
@@ -1188,12 +1198,13 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     }
   }
   for (int32_t i = 0; i < GetProcessingSettings().nTPCClustererLanes; i++) {
-    // if (GetProcessingSettings().nn.applyNNclusterizer) {
-    //   GPUTPCNNClusterizerHost& nnApplication = nnApplications[i];
-    //   nnApplication.mModelClass.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
-    //   nnApplication.mModelReg1.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
-    //   nnApplication.mModelReg2.release(GetProcessingSettings().nn.nnInferenceOrtProfiling);
-    // }
+    if (GetProcessingSettings().nn.applyNNclusterizer) {
+      LOG(info) << "(ORT) Environment releasing...";
+      GPUTPCNNClusterizerHost& nnApplication = nnApplications[i];
+      nnApplication.mModelClass.release(true);
+      nnApplication.mModelReg1.release(true);
+      nnApplication.mModelReg2.release(true);
+    }
     if (transferRunning[i]) {
       ReleaseEvent(mEvents->stream[i], doGPU);
     }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index ca2deec60601c..90f1d6e27246f 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -136,8 +136,8 @@ struct MockedOrtAllocator : OrtAllocator {
   std::atomic<size_t> memory_inuse{0};
   std::atomic<size_t> num_allocations{0};
   std::atomic<size_t> num_reserve_allocations{0};
-  OrtMemoryInfo* memory_info;
-  GPUReconstruction* rec;
+  OrtMemoryInfo* mMemoryInfoInternal;
+  GPUReconstruction* mRecInternal;
 };
 
 MockedOrtAllocator::MockedOrtAllocator(GPUReconstruction* r, OrtMemoryInfo* info)
@@ -147,37 +147,36 @@ MockedOrtAllocator::MockedOrtAllocator(GPUReconstruction* r, OrtMemoryInfo* info
   OrtAllocator::Free = [](OrtAllocator* this_, void* p) { static_cast<MockedOrtAllocator*>(this_)->Free(p); };
   OrtAllocator::Info = [](const OrtAllocator* this_) { return static_cast<const MockedOrtAllocator*>(this_)->Info(); };
   OrtAllocator::Reserve = [](OrtAllocator* this_, size_t size) { return static_cast<MockedOrtAllocator*>(this_)->Reserve(size); };
-  rec = r;
-  memory_info = info;
+  mRecInternal = r;
+  mMemoryInfoInternal = info;
 }
 
 MockedOrtAllocator::~MockedOrtAllocator()
 {
-  // Ort::GetApi().ReleaseMemoryInfo(memory_info);
+  // Ort::GetApi().ReleaseMemoryInfo(mMemoryInfoInternal);
   (void)0; // Suppress warning for empty destructor
 }
 
 void* MockedOrtAllocator::Alloc(size_t size)
 {
-  // LOG(info) << "(ORT) Allocating volatile memory of size " << size << " bytes";
-  return rec->AllocateVolatileDeviceMemory(size);
+  LOG(info) << "(ORT) Allocating direct memory of size " << size << " bytes";
+  return mRecInternal->AllocateDirectMemory(size, GPUMemoryResource::MEMORY_GPU | GPUMemoryResource::MEMORY_STACK);
 }
 
 void* MockedOrtAllocator::Reserve(size_t size)
 {
-  // LOG(info) << "(ORT) Reserving volatile memory of size " << size << " bytes";
-  return rec->AllocateVolatileDeviceMemory(size);
+  LOG(info) << "(ORT) Reserving direct memory of size " << size << " bytes";
+  return mRecInternal->AllocateDirectMemory(size, GPUMemoryResource::MEMORY_GPU | GPUMemoryResource::MEMORY_STACK);
 }
 
 void MockedOrtAllocator::Free(void* p)
 {
   // LOG(info) << "(ORT) Freeing volatile memory " << p;
-  rec->ReturnVolatileDeviceMemory();
 }
 
 const OrtMemoryInfo* MockedOrtAllocator::Info() const
 {
-  return memory_info;
+  return mMemoryInfoInternal;
 }
 
 size_t MockedOrtAllocator::NumAllocations() const
@@ -197,7 +196,7 @@ void MockedOrtAllocator::LeakCheck()
   }
 }
 
-void GPUTPCNNClusterizerHost::volatileOrtAllocator(Ort::Env* env, Ort::MemoryInfo* memInfo, GPUReconstruction* rec, bool recreate)
+void GPUTPCNNClusterizerHost::directOrtAllocator(Ort::Env* env, Ort::MemoryInfo* memInfo, GPUReconstruction* rec, bool recreate)
 {
   mMockedAlloc = std::make_shared<MockedOrtAllocator>(rec, (OrtMemoryInfo*)(*memInfo));
   if (recreate) {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
index e659753f21d7d..4334c3418eb09 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
@@ -53,7 +53,7 @@ class GPUTPCNNClusterizerHost
   void initClusterizer(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&);
 
   // ONNX
-  void volatileOrtAllocator(Ort::Env*, Ort::MemoryInfo*, GPUReconstruction*, bool = false);
+  void directOrtAllocator(Ort::Env*, Ort::MemoryInfo*, GPUReconstruction*, bool = false);
   MockedOrtAllocator* getMockedAllocator();
   const OrtMemoryInfo* getMockedMemoryInfo();
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 47bc5e8da80ca..8ca61602ab4e9 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -35,9 +35,9 @@ using namespace o2::gpu::tpccf;
 
 // Defining individual thread functions for data filling, determining the class label and running the CF clusterizer
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::runCfClusterizer>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::runCfClusterizer>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
-  uint glo_idx = get_global_id(0);
+  uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
   if (clustererNN.mOutputDataClass[glo_idx] == 0) { // default clusterizer should not be called in batched mode due to mess-up with thread indices
@@ -51,29 +51,29 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNN>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNN>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint32_t batchStart)
 {
-  uint glo_idx = get_global_id(0);
+  uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  uint write_idx = glo_idx * clustererNN.mNnClusterizerElementSize; // Potential optimization: Either choose mNnClusterizerBatchedMode as a power of 2 or calculate from threadId and blockId
+  uint32_t write_idx = glo_idx * clustererNN.mNnClusterizerElementSize; // Potential optimization: Either choose mNnClusterizerBatchedMode as a power of 2 or calculate from threadId and blockId
 
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
-  CfChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
-  int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad()), time = static_cast<int>(peak.time()); // Explicit casting to avoid conversion errors
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(glo_idx + batchStart, (uint32_t)(clusterer.mPmemory->counters.nClusters - 1))];
+  int32_t row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad()), time = static_cast<int>(peak.time()); // Explicit casting to avoid conversion errors
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
-  int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
+  int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
 
 #ifndef GPUCA_GPUCODE
   GPUCA_UNROLL(U(), U());
 #endif
-  for (int r = -clustererNN.mNnClusterizerSizeInputRow; r <= clustererNN.mNnClusterizerSizeInputRow; r++) {
+  for (int32_t r = -clustererNN.mNnClusterizerSizeInputRow; r <= clustererNN.mNnClusterizerSizeInputRow; r++) {
     bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
-    int pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, row + r);
-    for (int p = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; p++) {
+    int32_t pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, row + r);
+    for (int32_t p = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; p++) {
       bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow);
-      for (int t = -clustererNN.mNnClusterizerSizeInputTime; t <= clustererNN.mNnClusterizerSizeInputTime; t++) {
+      for (int32_t t = -clustererNN.mNnClusterizerSizeInputTime; t <= clustererNN.mNnClusterizerSizeInputTime; t++) {
         if (!is_boundary) {
           CfChargePos tmp_pos(row + r, pad + p, time + t);
           if (r == 0 && !clustererNN.mClusterFlags[2 * glo_idx] && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) { // ordering is done for short circuit optimization
@@ -111,21 +111,21 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNSingleElement>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNSingleElement>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint32_t batchStart)
 {
-  uint glo_idx = get_global_id(0);
+  uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  uint base_idx = CAMath::Floor(glo_idx / clustererNN.mNnClusterizerElementSize);
-  uint transient_index = glo_idx % clustererNN.mNnClusterizerElementSize;
+  uint32_t base_idx = CAMath::Floor(glo_idx / clustererNN.mNnClusterizerElementSize);
+  uint32_t transient_index = glo_idx - (base_idx * clustererNN.mNnClusterizerElementSize);
 
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
-  CfChargePos peak = clusterer.mPfilteredPeakPositions[base_idx + batchStart];
-  int row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad());
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(base_idx + batchStart, (uint32_t)(clusterer.mPmemory->counters.nClusters - 1))];
+  int32_t row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad());
 
   if (clustererNN.mNnClusterizerAddIndexData && (int32_t)transient_index == (clustererNN.mNnClusterizerElementSize - 1)) {
-    uint top_idx = (base_idx + 1) * clustererNN.mNnClusterizerElementSize;
+    uint32_t top_idx = (base_idx + 1) * clustererNN.mNnClusterizerElementSize;
     for (uint16_t i = 0; i < 8; i++) {
       Delta2 d = cfconsts::InnerNeighbors[i];
       CfChargePos tmp_pos = peak.delta(d);
@@ -142,8 +142,8 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
       clustererNN.mInputData_32[top_idx - 1] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
     }
   } else if ((int32_t)transient_index < (clustererNN.mNnClusterizerElementSize - 3)) {
-    int time = static_cast<int>(peak.time());
-    int r = CAMath::Floor(transient_index / ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1))) - clustererNN.mNnClusterizerSizeInputRow;
+    int32_t time = static_cast<int>(peak.time());
+    int32_t r = CAMath::Floor(transient_index / ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1))) - clustererNN.mNnClusterizerSizeInputRow;
     bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
     if (is_row_boundary) {
       if (dtype == 0) {
@@ -152,15 +152,16 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
         clustererNN.mInputData_32[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
       }
     } else {
-      int row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
-      int pad_offset = GPUTPCNNClusterizerKernels::padOffset(row, row + r);
-      int rest_1 = transient_index % ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1));
-      int p = CAMath::Floor(rest_1 / (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputPad + pad_offset;
-      bool is_boundary = GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow);
+      int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
+      int32_t pad_offset = GPUTPCNNClusterizerKernels::padOffset(row, row + r);
+      int32_t rest_1 = transient_index % ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1));
+      int32_t p = CAMath::Floor(rest_1 / (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputPad + pad_offset;
+      int32_t t = (rest_1 % (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputTime;
+
+      bool is_boundary = GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow) && (t < 0 || t >= TPC_MAX_FRAGMENT_LEN_GPU);
 
       if (!is_boundary) {
         float central_charge = static_cast<float>(chargeMap[peak].unpack());
-        int t = (rest_1 % (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputTime;
         CfChargePos tmp_pos(row + r, pad + p, time + t);
         if (dtype == 0) {
           clustererNN.mInputData_16[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
@@ -179,9 +180,9 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass1Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass1Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint32_t batchStart)
 {
-  uint glo_idx = get_global_id(0);
+  uint32_t glo_idx = get_global_id(0);
   if (dtype == 0) {
     processors.tpcNNClusterer[sector].mOutputDataClass[glo_idx + batchStart] = (int)((processors.tpcNNClusterer[sector].mModelProbabilities_16[glo_idx]).ToFloat() > processors.tpcNNClusterer[sector].mNnClassThreshold);
   } else if (dtype == 1) {
@@ -190,14 +191,14 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::det
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass2Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass2Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint32_t batchStart)
 {
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  uint glo_idx = get_global_id(0);
-  uint elem_iterator = glo_idx * clustererNN.mNnClusterizerModelClassNumOutputNodes;
+  uint32_t glo_idx = get_global_id(0);
+  uint32_t elem_iterator = glo_idx * clustererNN.mNnClusterizerModelClassNumOutputNodes;
   float current_max_prob = 0.f; // If the neural network doesn't contain the softmax as a last layer, the outputs can range in [-infty, infty]
-  uint class_label = 0;
-  for (uint pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes; pIdx++) {
+  uint32_t class_label = 0;
+  for (uint32_t pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes; pIdx++) {
     if (pIdx == elem_iterator) {
       if (dtype == 0) {
         current_max_prob = static_cast<float>(clustererNN.mModelProbabilities_16[pIdx]);
@@ -212,7 +213,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::det
       }
     }
   }
-  // uint class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
+  // uint32_t class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
   clustererNN.mOutputDataClass[glo_idx + batchStart] = class_label;
   if (class_label > 1) {
     clustererNN.mClusterFlags[2 * glo_idx] = 1;
@@ -221,25 +222,30 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::det
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass1Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass1Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
-  uint glo_idx = get_global_id(0);
+  uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
+  uint32_t maxClusterNum = clusterer.mPmemory->counters.nClusters;
+  uint32_t full_glo_idx = glo_idx + batchStart;
+  if (full_glo_idx >= maxClusterNum) {
+    return;
+  }
+  int32_t model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg1NumOutputNodes;
+
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  CfChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(full_glo_idx, maxClusterNum - 1)];
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
 
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
   tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
-  uint full_glo_idx = glo_idx + batchStart;
-  int model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg1NumOutputNodes;
 
   // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.mNnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
 
-  if (clustererNN.mOutputDataClass[full_glo_idx] == 1 || (clustererNN.mNnClusterizerModelReg2NumOutputNodes == -1 && clustererNN.mOutputDataClass[full_glo_idx] >= 1)) {
+  if (clustererNN.mOutputDataClass[full_glo_idx] == 1 || (clustererNN.mNnClusterizerModelReg2NumOutputNodes != -1 && clustererNN.mOutputDataClass[full_glo_idx] >= 1)) {
 
     ClusterAccumulator pc;
 
@@ -291,7 +297,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
       return;
     }
 
-    uint rowIndex = 0;
+    uint32_t rowIndex = 0;
     if (clusterOut != nullptr) {
       rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
         clusterer,
@@ -316,21 +322,21 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass2Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishClass2Regression>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
-  uint glo_idx = get_global_id(0);
+  uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  CfChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(glo_idx + batchStart, (uint32_t)(clusterer.mPmemory->counters.nClusters - 1))];
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
 
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
   tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
-  uint full_glo_idx = glo_idx + batchStart;
-  int model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg2NumOutputNodes;
+  uint32_t full_glo_idx = glo_idx + batchStart;
+  uint32_t model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg2NumOutputNodes;
 
   if (clustererNN.mOutputDataClass[full_glo_idx] > 0) {
 
@@ -384,7 +390,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
       return;
     }
 
-    uint rowIndex = 0;
+    uint32_t rowIndex = 0;
     if (clusterOut != nullptr) {
       rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
         clusterer,
@@ -452,17 +458,17 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 }
 
 // THe following arithmetic is done because the network is trained with a split between IROC and OROC boundary
-GPUd() int GPUTPCNNClusterizerKernels::padOffset(int row_ref, int row_current)
+GPUd() int32_t GPUTPCNNClusterizerKernels::padOffset(int32_t row_ref, int32_t row_current)
 {
   return (int)((GPUTPCGeometry::NPads(row_current) - GPUTPCGeometry::NPads(row_ref)) / 2);
 }
 
-GPUd() int GPUTPCNNClusterizerKernels::rowOffset(int row, int global_shift)
+GPUd() int32_t GPUTPCNNClusterizerKernels::rowOffset(int32_t row, int32_t global_shift)
 {
   return (row > 62 ? global_shift : 0);
 }
 
-GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int row, int pad, int global_shift)
+GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int32_t row, int32_t pad, int32_t global_shift)
 {
   if (pad < 0 || row < 0) { // Faster short-circuit
     return true;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index dc7f537c6c1e8..dac2bf9554849 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -73,11 +73,12 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
  private:
   static GPUd() void fillInputData(int32_t, int32_t, int32_t, int32_t, processorType&, uint8_t, int8_t, uint);
   static GPUd() void publishClustersReg1(uint, GPUSharedMemory&, processorType&, uint8_t, int8_t, int8_t, uint);
+  static GPUd() uint32_t sortIntoBuckets(GPUTPCClusterFinder&, const tpc::ClusterNative&, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*, uint32_t);
   static GPUd() void publishClustersReg2(uint, GPUSharedMemory&, processorType&, uint8_t, int8_t, int8_t, uint);
 
-  static GPUd() int padOffset(int, int);
-  static GPUd() int rowOffset(int, int);
-  static GPUd() bool isBoundary(int, int, int);
+  static GPUd() int32_t padOffset(int32_t, int32_t);
+  static GPUd() int32_t rowOffset(int32_t, int32_t);
+  static GPUd() bool isBoundary(int32_t, int32_t, int32_t);
 };
 
 } // namespace o2::gpu

From e7d217af61b67a12b508451c2f2ea925fda92f6e Mon Sep 17 00:00:00 2001
From: Marvin Hemmer <53471402+mhemmer-cern@users.noreply.github.com>
Date: Mon, 19 May 2025 14:29:21 +0200
Subject: [PATCH 0379/1764] [EMCAL-688] EMCAL: Add fCross to the
 AnalysisCluster (#14282)

- Add fCross the exoticity parameter to the AnalysisCluster so we can easily access it later in the emcalCorrectionTask in O2Physics
---
 .../EMCAL/include/DataFormatsEMCAL/AnalysisCluster.h |  8 ++++++--
 .../EMCAL/base/include/EMCALBase/ClusterFactory.h    |  5 +++--
 Detectors/EMCAL/base/src/ClusterFactory.cxx          | 12 ++++++++----
 3 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/AnalysisCluster.h b/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/AnalysisCluster.h
index 758e0a1fa0b47..e19fd17dea2ce 100644
--- a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/AnalysisCluster.h
+++ b/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/AnalysisCluster.h
@@ -182,6 +182,9 @@ class AnalysisCluster
   float getCoreEnergy() const { return mCoreEnergy; }
   void setCoreEnergy(float energy) { mCoreEnergy = energy; }
 
+  float getFCross() const { return mFCross; }
+  void setFCross(float fCross) { mFCross = fCross; }
+
   ///
   /// Returns TLorentzVector with momentum of the cluster. Only valid for clusters
   /// identified as photons or pi0 (overlapped gamma) produced on the vertex
@@ -223,12 +226,13 @@ class AnalysisCluster
   float mTime = 0.; ///<  Time of the digit/cell with maximal energy deposition
 
   bool mIsExotic = false; //!<! Cluster marked as "exotic" (high energy deposition concentrated in a single cell)
+  float mFCross = 0.f;    //! exoticity parameter (1-E_cross/E_cell^max)
 
   int mInputIndMax = -1; ///<  index of digit/cell with max energy
 
-  ClassDefNV(AnalysisCluster, 1);
+  ClassDefNV(AnalysisCluster, 2);
 };
 
 } // namespace emcal
 } // namespace o2
-#endif //ANALYSISCLUSTER_H
+#endif // ANALYSISCLUSTER_H
diff --git a/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h b/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
index 2957eacb8d050..3ce7003fe9814 100644
--- a/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
+++ b/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
@@ -277,9 +277,10 @@ class ClusterFactory
   /// \brief Look to cell neighbourhood and reject if it seems exotic
   /// \param towerId: tower ID of cell with largest energy fraction in cluster
   /// \param ecell: energy of the cell with largest energy fraction in cluster
-  /// \param exoticTime time of the cell with largest energy fraction in cluster
+  /// \param exoticTime: time of the cell with largest energy fraction in cluster
+  /// \param fCross: exoticity parameter (1-E_cross/E_cell^max) will be caluclated for this check
   /// \return bool true if cell is found exotic
-  bool isExoticCell(short towerId, float ecell, float const exoticTime) const;
+  bool isExoticCell(short towerId, float ecell, float const exoticTime, float& fCross) const;
 
   /// \brief Calculate the energy in the cross around the energy of a given cell.
   /// \param absID: controlled cell absolute ID number
diff --git a/Detectors/EMCAL/base/src/ClusterFactory.cxx b/Detectors/EMCAL/base/src/ClusterFactory.cxx
index 0c801de615487..342f54fd94591 100644
--- a/Detectors/EMCAL/base/src/ClusterFactory.cxx
+++ b/Detectors/EMCAL/base/src/ClusterFactory.cxx
@@ -73,8 +73,11 @@ o2::emcal::AnalysisCluster ClusterFactory<InputType>::buildCluster(int clusterIn
 
   float exoticTime = mInputsContainer[inputIndMax].getTimeStamp();
 
+  float fCross = 0.;
+
   try {
-    clusterAnalysis.setIsExotic(isExoticCell(towerId, inputEnergyMax, exoticTime));
+    clusterAnalysis.setIsExotic(isExoticCell(towerId, inputEnergyMax, exoticTime, fCross));
+    clusterAnalysis.setFCross(fCross);
   } catch (UninitLookUpTableException& e) {
     LOG(error) << e.what();
   }
@@ -253,7 +256,7 @@ void ClusterFactory<InputType>::evalLocalPosition(gsl::span<const int> inputsInd
         clRmsXYZ[i] += (w * xyzi[i] * xyzi[i]);
       }
     } // w > 0
-  }   // dig loop
+  } // dig loop
 
   //  cout << " wtot " << wtot << endl;
 
@@ -600,7 +603,7 @@ std::tuple<int, float, float, bool> ClusterFactory<InputType>::getMaximalEnergyI
 /// Look to cell neighbourhood and reject if it seems exotic
 //____________________________________________________________________________
 template <class InputType>
-bool ClusterFactory<InputType>::isExoticCell(short towerId, float ecell, float const exoticTime) const
+bool ClusterFactory<InputType>::isExoticCell(short towerId, float ecell, float const exoticTime, float& fCross) const
 {
   if (ecell < mExoticCellMinAmplitude) {
     return false; // do not reject low energy cells
@@ -612,8 +615,9 @@ bool ClusterFactory<InputType>::isExoticCell(short towerId, float ecell, float c
   }
 
   float eCross = getECross(towerId, ecell, exoticTime);
+  fCross = 1.f - eCross / ecell;
 
-  if (1 - eCross / ecell > mExoticCellFraction) {
+  if (fCross > mExoticCellFraction) {
     LOG(debug) << "EXOTIC CELL id " << towerId << ", eCell " << ecell << ", eCross " << eCross << ", 1-eCross/eCell " << 1 - eCross / ecell;
     return true;
   }

From 762cef75f0f7ce4c23c81e78efb439c72bdc7970 Mon Sep 17 00:00:00 2001
From: Marvin Hemmer <53471402+mhemmer-cern@users.noreply.github.com>
Date: Mon, 19 May 2025 14:30:02 +0200
Subject: [PATCH 0380/1764] [EMCAL-689] EMCAL/Geometry: Add function to load
 alignment matrix from CCDB (#14237)

- Add function `SetMisalMatrixFromCcdb` to set the missalignment matrices for the EMCal via the CCDB. This way they are not laoded from the GeoManager. The function expects a path inside the ccdb, which by default is set to `"Users/m/mhemmer/EMCAL/Config/GeometryAligned"` and the timestamp. Currently in the CCDB we only have the old Run 2 alignment object. Once we have the new alignment objects we can uplaod them and via the correct time stamp load them fittingly.
---
 .../EMCAL/base/include/EMCALBase/Geometry.h   |  9 +++++-
 Detectors/EMCAL/base/src/Geometry.cxx         | 31 +++++++++++++++++--
 2 files changed, 36 insertions(+), 4 deletions(-)

diff --git a/Detectors/EMCAL/base/include/EMCALBase/Geometry.h b/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
index 04dcaa3b802de..4d4a947de88ca 100644
--- a/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
+++ b/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
@@ -22,7 +22,9 @@
 #include <TNamed.h>
 #include <TParticle.h>
 #include <TVector3.h>
+#include <TObjArray.h>
 
+#include "CCDB/BasicCCDBManager.h"
 #include "DataFormatsEMCAL/Constants.h"
 #include "EMCALBase/GeometryBase.h"
 #include "MathUtils/Cartesian.h"
@@ -57,7 +59,7 @@ class Geometry
   /// | EMCAL_COMPLETE12SMV1_DCAL             | Full EMCAL, 10 DCAL Supermodules (not used in practice)  |
   /// | EMCAL_COMPLETE12SMV1_DCAL_8SM         | Full EMCAL, 8 DCAL Supermodules (run2)                   |
   /// | EMCAL_COMPLETE12SMV1_DCAL_DEV         | Full EMCAL, DCAL development geometry (not used)         |
-  Geometry(const std::string_view name, const std::string_view mcname = "", const std::string_view mctitle = "");
+  explicit Geometry(const std::string_view name, const std::string_view mcname = "", const std::string_view mctitle = "");
 
   /// \brief Copy constructor.
   Geometry(const Geometry& geom);
@@ -564,6 +566,11 @@ class Geometry
   ///
   void SetMisalMatrix(const TGeoHMatrix* m, Int_t smod) const;
 
+  ///
+  /// Method to set shift-rotational matrixes from CCDB
+  ///
+  void SetMisalMatrixFromCcdb(const char* path = "Users/m/mhemmer/EMCAL/Config/GeometryAligned", int timestamp = 10000) const;
+
   ///
   /// Transform clusters cell position into global with alternative method, taking into account the depth calculation.
   /// Input are:
diff --git a/Detectors/EMCAL/base/src/Geometry.cxx b/Detectors/EMCAL/base/src/Geometry.cxx
index 920dc24823e83..6eff6c161f2a1 100644
--- a/Detectors/EMCAL/base/src/Geometry.cxx
+++ b/Detectors/EMCAL/base/src/Geometry.cxx
@@ -8,16 +8,21 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
+#include "EMCALBase/Geometry.h"
+
+#include <fairlogger/Logger.h>
+
 #include <iomanip>
+#include <string>
+#include <algorithm>
+#include <cstdio>
+#include <tuple>
 
 #include <TGeoBBox.h>
 #include <TGeoManager.h>
 #include <TGeoMatrix.h>
 #include <TList.h>
 
-#include <fairlogger/Logger.h>
-
-#include "EMCALBase/Geometry.h"
 #include "EMCALBase/ShishKebabTrd1Module.h"
 
 #include <boost/algorithm/string/predicate.hpp>
@@ -1557,6 +1562,7 @@ const TGeoHMatrix* Geometry::GetMatrixForSuperModule(Int_t smod) const
 
   if (!SMODULEMATRIX[smod]) {
     if (gGeoManager) {
+      LOG(info) << "Loading EMCAL misalignment matrix for SM " << smod << " from GeoManager.";
       SetMisalMatrix(GetMatrixForSuperModuleFromGeoManager(smod), smod);
     } else {
       LOG(fatal) << "Cannot find EMCAL misalignment matrices! Recover them either: \n"
@@ -1762,6 +1768,25 @@ void Geometry::SetMisalMatrix(const TGeoHMatrix* m, Int_t smod) const
   }
 }
 
+void Geometry::SetMisalMatrixFromCcdb(const char* path, int timestamp) const
+{
+  LOG(info) << "Using CCDB to obtain EMCal alignment.";
+  o2::ccdb::CcdbApi api;
+  map<string, string> metadata; // can be empty
+  api.init("http://alice-ccdb.cern.ch");
+  TObjArray* matrices = api.retrieveFromTFileAny<TObjArray>(path, metadata, timestamp);
+
+  for (int iSM = 0; iSM < mNumberOfSuperModules; ++iSM) {
+    TGeoHMatrix* mat = reinterpret_cast<TGeoHMatrix*>(matrices->At(iSM));
+    if (mat) {
+
+      SetMisalMatrix(mat, iSM);
+    } else {
+      LOG(info) << "Could not obtain Alignment Matrix for SM " << iSM;
+    }
+  }
+}
+
 Bool_t Geometry::IsDCALSM(Int_t iSupMod) const
 {
   if (mEMCSMSystem[iSupMod] == DCAL_STANDARD || mEMCSMSystem[iSupMod] == DCAL_EXT) {

From e2f0fa3f1da3ecba8e1d446de4fd456fdd61b359 Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Mon, 19 May 2025 18:55:40 +0200
Subject: [PATCH 0381/1764] fix: suppressing excesive output from raw decoder
 (#14291)

* fix: suppressing excesive output from raw decoder

* clang

* fix

* fix
---
 .../include/DataFormatsCTP/Configuration.h    |  2 +-
 .../Detectors/CTP/src/Configuration.cxx       | 12 ++++-
 .../CTPReconstruction/RawDataDecoder.h        | 10 ++--
 .../CTP/reconstruction/src/RawDataDecoder.cxx | 32 ++++++------
 .../include/CTPWorkflow/RawDecoderSpec.h      | 11 ++++
 Detectors/CTP/workflow/src/RawDecoderSpec.cxx | 50 +++++++++++++------
 6 files changed, 79 insertions(+), 38 deletions(-)

diff --git a/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h b/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
index fdd73986f1eaf..e9464089d71fc 100644
--- a/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
+++ b/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
@@ -160,7 +160,7 @@ class CTPConfiguration
   const std::vector<CTPClass>& getCTPClasses() const { return mCTPClasses; } // Read-only interface
   uint64_t getInputMask(const std::string& name) const;
   int getInputIndex(const std::string& name) const;
-  std::string getClassNameFromIndex(int index) { return mCTPClasses[index].name; };
+  std::string getClassNameFromIndex(int index);
   std::string getClassNameFromHWIndex(int index);
   const CTPClass* getCTPClassFromHWIndex(const int index) const;
   bool isMaskInInputs(const uint64_t& mask) const;
diff --git a/DataFormats/Detectors/CTP/src/Configuration.cxx b/DataFormats/Detectors/CTP/src/Configuration.cxx
index 38a49132db3d1..61e51bcb20d91 100644
--- a/DataFormats/Detectors/CTP/src/Configuration.cxx
+++ b/DataFormats/Detectors/CTP/src/Configuration.cxx
@@ -780,6 +780,15 @@ int CTPConfiguration::getInputIndex(const std::string& name) const
   LOG(info) << "input:" << name << " index:" << index;
   return index;
 }
+std::string CTPConfiguration::getClassNameFromIndex(int index)
+{
+  if (index < (int)mCTPClasses.size()) {
+    return mCTPClasses[index].name;
+  } else {
+    std::string name = "Cls" + std::to_string(index);
+    return name;
+  }
+};
 std::string CTPConfiguration::getClassNameFromHWIndex(int index)
 {
   for (auto& cls : mCTPClasses) {
@@ -924,8 +933,9 @@ uint64_t CTPConfiguration::getTriggerClassMaskWInputsNoTrgDets() const
     exclude += cls.name.find("EMC") != std::string::npos;
     exclude += cls.name.find("TRD") != std::string::npos;
     exclude += cls.name.find("HMP") != std::string::npos;
-    if (!exclude)
+    if (!exclude) {
       clsmask |= cls.classMask;
+    }
   }
   return clsmask;
 }
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
index 8ebc7e0304561..53addf32c538f 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
@@ -60,7 +60,8 @@ class RawDataDecoder
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassErrorsB() { return mClassErrorsB; }
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassCountersA() { return mClassCountersA; }
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassCountersB() { return mClassCountersB; }
-  int getLostDueToShift() { return mLostDueToShift; }
+  int getLostDueToShiftCls() { return mLostDueToShiftCC; }
+  int getLostDueToShiftInp() { return mLostDueToShiftInps; }
 
  private:
   static constexpr uint32_t TF_TRIGGERTYPE_MASK = 0x800;
@@ -80,8 +81,8 @@ class RawDataDecoder
   gbtword80_t mTVXMask = 0x4;  // TVX is 3rd input
   gbtword80_t mVBAMask = 0x20; // VBA is 6 th input
   bool mVerbose = false;
-  uint32_t mIRRejected = 0;
-  uint32_t mTCRRejected = 0;
+  int mIRRejected = 0;
+  int mTCRRejected = 0;
   bool mPadding = true;
   uint32_t mTFOrbit = 0;
   std::vector<uint32_t> mTFOrbits;
@@ -94,7 +95,8 @@ class RawDataDecoder
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClassErrorsB{}; // from inputs
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClassCountersA{};
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClassCountersB{}; // from inputs
-  int mLostDueToShift = 0;
+  int mLostDueToShiftCC = 0;
+  int mLostDueToShiftInps = 0;
   CTPConfiguration mCTPConfig;
 };
 } // namespace ctp
diff --git a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
index b216f5ec54570..a062a262acf62 100644
--- a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
+++ b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
@@ -296,12 +296,12 @@ int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2
     uint64_t trgclassmask = 0xffffffffffffffff;
     uint64_t trgclassmaskNOTRGDet = 0xffffffffffffffff;
     if (mCTPConfig.getRunNumber() != 0) {
-      trgclassmask = mCTPConfig.getTriggerClassMaskWInputs();
+      trgclassmask = mCTPConfig.getTriggerClassMaskWInputs(); // classes triggered by internal ctp generators not here
       trgclassmaskNOTRGDet = mCTPConfig.getTriggerClassMaskWInputsNoTrgDets();
       // mCTPConfig.printStream(std::cout);
     }
     // std::cout << "trgclassmask:" << std::hex << trgclassmask << std::dec << std::endl;
-    ret = shiftInputs(digitsMap, digits, mTFOrbit);
+    mLostDueToShiftInps += shiftInputs(digitsMap, digits, mTFOrbit);
     if (mCheckConsistency) {
       ret = checkReadoutConsistentncy(digits, trgclassmask, trgclassmaskNOTRGDet);
     }
@@ -524,7 +524,9 @@ int RawDataDecoder::shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit
       digmap[ir] = digit;
     }
   } else {
-    LOG(info) << "LOST:" << irin << " shift:" << shift;
+    // LOG(info) << "LOST:" << irin << " shift:" << shift;
+    return 1;
+    ;
   }
   return 0;
 }
@@ -533,6 +535,7 @@ int RawDataDecoder::shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit
 int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask)
 {
   // int nClasswoInp = 0; // counting classes without input which should never happen
+  int lost = 0;
   std::map<o2::InteractionRecord, CTPDigit> digitsMapShifted;
   auto L0shift = o2::ctp::TriggerOffsetsParam::Instance().LM_L0;
   auto L1shift = L0shift + o2::ctp::TriggerOffsetsParam::Instance().L0_L1;
@@ -551,7 +554,7 @@ int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digit
     if (lut == 0 || lut == 1) { // no inps or LM
       digitsMapShifted[dig.first] = dig.second;
     } else if (lut == 2) { // L0
-      shiftNew(dig.first, TFOrbit, inpmask, L0shift, 0, digitsMapShifted);
+      lost += shiftNew(dig.first, TFOrbit, inpmask, L0shift, 0, digitsMapShifted);
       if (dig.second.CTPClassMask.count()) {
         // LOG(error) << "Adding class mask without input ?";
         //  This is not needed as it can happen; Full checj done below - see next LOG(error)
@@ -559,30 +562,30 @@ int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digit
         digitsMapShifted[dig.first] = digi;
       }
     } else if (lut == 4) { // L1
-      shiftNew(dig.first, TFOrbit, inpmask, L1shift, 1, digitsMapShifted);
+      lost += shiftNew(dig.first, TFOrbit, inpmask, L1shift, 1, digitsMapShifted);
       if (dig.second.CTPClassMask.count()) {
         CTPDigit digi = {dig.first, 0, dig.second.CTPClassMask};
         digitsMapShifted[dig.first] = digi;
       }
     } else if (lut == 6) { // L0 and L1
-      shiftNew(dig.first, TFOrbit, inpmask, L0shift, 0, digitsMapShifted);
-      shiftNew(dig.first, TFOrbit, inpmask, L1shift, 1, digitsMapShifted);
+      lost += shiftNew(dig.first, TFOrbit, inpmask, L0shift, 0, digitsMapShifted);
+      lost += shiftNew(dig.first, TFOrbit, inpmask, L1shift, 1, digitsMapShifted);
       if (dig.second.CTPClassMask.count()) {
         CTPDigit digi = {dig.first, 0, dig.second.CTPClassMask};
         digitsMapShifted[dig.first] = digi;
       }
     } else if (lut == 3) { // LM and L0
-      shiftNew(dig.first, TFOrbit, inpmask, L0shift, 0, digitsMapShifted);
+      lost += shiftNew(dig.first, TFOrbit, inpmask, L0shift, 0, digitsMapShifted);
       CTPDigit digi = {dig.first, inpmask & (~L0MASKInputs), dig.second.CTPClassMask};
       // if LM level do not need to add class as LM is not shifted;
       digitsMapShifted[dig.first] = digi;
     } else if (lut == 5) { // LM and L1
-      shiftNew(dig.first, TFOrbit, inpmask, L1shift, 1, digitsMapShifted);
+      lost += shiftNew(dig.first, TFOrbit, inpmask, L1shift, 1, digitsMapShifted);
       CTPDigit digi = {dig.first, inpmask & (~L1MASKInputs), dig.second.CTPClassMask};
       digitsMapShifted[dig.first] = digi;
     } else if (lut == 7) { // LM and L0 and L1
-      shiftNew(dig.first, TFOrbit, inpmask, L0shift, 0, digitsMapShifted);
-      shiftNew(dig.first, TFOrbit, inpmask, L1shift, 1, digitsMapShifted);
+      lost += shiftNew(dig.first, TFOrbit, inpmask, L0shift, 0, digitsMapShifted);
+      lost += shiftNew(dig.first, TFOrbit, inpmask, L1shift, 1, digitsMapShifted);
       CTPDigit digi = {dig.first, inpmaskLM, dig.second.CTPClassMask};
       digitsMapShifted[dig.first] = digi;
     } else {
@@ -592,7 +595,7 @@ int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digit
   for (auto const& dig : digitsMapShifted) {
     digits.push_back(dig.second);
   }
-  return 0;
+  return lost;
 }
 //
 int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask, uint64_t trgclassmaskNoTrgDet)
@@ -654,16 +657,13 @@ int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits,
               mClassErrorsB[cls.getIndex()]++;
               ret = 256;
             } else {
-              mLostDueToShift++;
+              mLostDueToShiftCC++;
             }
           }
         }
       }
     }
   }
-  if (mLostDueToShift) {
-    LOG(debug) << "LOST classes because of shift:" << mLostDueToShift;
-  }
   return ret;
 }
 //
diff --git a/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h b/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
index a5a1a75a0b594..3198e5c33e219 100644
--- a/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
+++ b/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
@@ -74,6 +74,17 @@ class RawDecoderSpec : public framework::Task
   std::deque<size_t> mHistoryT;
   std::deque<size_t> mHistoryV;
   RawDataDecoder mDecoder;
+  // Errors
+  int mLostDueToShiftInps = 0;
+  int mErrorIR = 0;
+  int mErrorTCR = 0;
+  int mIRRejected = 0;
+  int mTCRRejected = 0;
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClsEA{};
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClsEB{}; // from inputs
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClsA{};
+  std::array<uint64_t, o2::ctp::CTP_NCLASSES> mClsB{}; // from inputs
+  bool mCheckConsistency = false;
 };
 
 /// \brief Creating DataProcessorSpec for the CTP
diff --git a/Detectors/CTP/workflow/src/RawDecoderSpec.cxx b/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
index 2df6bc981ce44..041e6cb472ebb 100644
--- a/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
+++ b/Detectors/CTP/workflow/src/RawDecoderSpec.cxx
@@ -26,6 +26,8 @@ using namespace o2::ctp::reco_workflow;
 
 void RawDecoderSpec::init(framework::InitContext& ctx)
 {
+  mCheckConsistency = ctx.options().get<bool>("check-consistency");
+  mDecoder.setCheckConsistency(mCheckConsistency);
   mDecodeinputs = ctx.options().get<bool>("ctpinputs-decoding");
   mDecoder.setDecodeInps(mDecodeinputs);
   mNTFToIntegrate = ctx.options().get<int>("ntf-to-average");
@@ -43,7 +45,7 @@ void RawDecoderSpec::init(framework::InitContext& ctx)
   mOutputLumiInfo.inp2 = inp2;
   mMaxInputSize = ctx.options().get<int>("max-input-size");
   mMaxInputSizeFatal = ctx.options().get<bool>("max-input-size-fatal");
-  LOG(info) << "CTP reco init done. Inputs decoding here:" << mDecodeinputs << " DoLumi:" << mDoLumi << " DoDigits:" << mDoDigits << " NTF:" << mNTFToIntegrate << " Lumi inputs:" << lumiinp1 << ":" << inp1 << " " << lumiinp2 << ":" << inp2 << " Max errors:" << maxerrors << " Max input size:" << mMaxInputSize << " MaxInputSizeFatal:" << mMaxInputSizeFatal;
+  LOG(info) << "CTP reco init done. Inputs decoding here:" << mDecodeinputs << " DoLumi:" << mDoLumi << " DoDigits:" << mDoDigits << " NTF:" << mNTFToIntegrate << " Lumi inputs:" << lumiinp1 << ":" << inp1 << " " << lumiinp2 << ":" << inp2 << " Max errors:" << maxerrors << " Max input size:" << mMaxInputSize << " MaxInputSizeFatal:" << mMaxInputSizeFatal << " CheckConsistency:" << mCheckConsistency;
   // mOutputLumiInfo.printInputs();
 }
 void RawDecoderSpec::endOfStream(framework::EndOfStreamContext& ec)
@@ -69,22 +71,22 @@ void RawDecoderSpec::endOfStream(framework::EndOfStreamContext& ec)
     o0 = TFOrbits[i];
   }
   std::cout << std::endl;
-  LOG(info) << " Lost due to the shift:" << mDecoder.getLostDueToShift();
-  LOG(info) << "Number of missing TF:" << nmiss << std::endl;
-  if (mDecoder.getErrorIR() || mDecoder.getErrorTCR()) {
-    LOG(error) << "# of IR errors:" << mDecoder.getErrorIR() << " TCR errors:" << mDecoder.getErrorTCR() << std::endl;
+  LOG(info) << "Number of non continous TF:" << nmiss << std::endl;
+  LOG(info) << "Lost in shiftInputs:" << mLostDueToShiftInps;
+  LOG(info) << "Lost in addDigit Inputs:" << mIRRejected << " Classes:" << mTCRRejected;
+  if (mErrorIR || mErrorTCR) {
+    LOG(error) << "# of IR errors:" << mErrorIR << " TCR errors:" << mErrorTCR << std::endl;
   }
-  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsA = mDecoder.getClassCountersA();
-  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsB = mDecoder.getClassCountersB();
-  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsEA = mDecoder.getClassErrorsA();
-  std::array<uint64_t, o2::ctp::CTP_NCLASSES> clsEB = mDecoder.getClassErrorsB();
-
-  for (int i = 0; i < o2::ctp::CTP_NCLASSES; i++) {
-    bool print = clsA[i] > 0 || clsB[i] > 0 || clsEA[i] > 0 || clsEB[i] > 0;
-    if (clsEA[i]) {
-      LOG(error) << " Class without inputs:";
+  if (mCheckConsistency) {
+    LOG(info) << "Lost due to the shift Consistency Checker:" << mDecoder.getLostDueToShiftCls();
+    auto ctpcfg = mDecoder.getCTPConfig();
+    for (int i = 0; i < o2::ctp::CTP_NCLASSES; i++) {
+      std::string name = ctpcfg.getClassNameFromIndex(i);
+      if (mClsEA[i]) {
+        LOG(error) << " Class without inputs:";
+      }
+      LOG(important) << "CLASS:" << name << ":" << i << " Cls=>Inp:" << mClsA[i] << " Inp=>Cls:" << mClsB[i] << "  ErrorsCls=>Inps:" << mClsEA[i] << "  MissingInps=>Cls:" << mClsEB[i];
     }
-    LOG(important) << "CLASS:" << i << " Cls=>Inp:" << clsA[i] << " Inp=>Cls:" << clsB[i] << "  ErrorsCls=>Inps:" << clsEA[i] << "  MissingInps=>Cls:" << clsEB[i];
   }
 }
 void RawDecoderSpec::run(framework::ProcessingContext& ctx)
@@ -161,6 +163,21 @@ void RawDecoderSpec::run(framework::ProcessingContext& ctx)
   if (mDoDigits) {
     LOG(info) << "[CTPRawToDigitConverter - run] Writing " << mOutputDigits.size() << " digits. IR rejected:" << mDecoder.getIRRejected() << " TCR rejected:" << mDecoder.getTCRRejected();
     ctx.outputs().snapshot(o2::framework::Output{"CTP", "DIGITS", 0}, mOutputDigits);
+    mLostDueToShiftInps += mDecoder.getLostDueToShiftInp();
+    mErrorIR += mDecoder.getErrorIR();
+    mErrorTCR += mDecoder.getErrorTCR();
+    mIRRejected += mDecoder.getIRRejected();
+    mTCRRejected += mDecoder.getTCRRejected();
+    auto clsEA = mDecoder.getClassErrorsA();
+    auto clsEB = mDecoder.getClassErrorsB();
+    auto cntCA = mDecoder.getClassCountersA();
+    auto cntCB = mDecoder.getClassCountersB();
+    for (int i = 0; i < o2::ctp::CTP_NCLASSES; i++) {
+      mClsEA[i] += clsEA[i];
+      mClsEB[i] += clsEB[i];
+      mClsA[i] += cntCA[i];
+      mClsB[i] += cntCB[i];
+    }
   }
   if (mDoLumi) {
     uint32_t tfCountsT = 0;
@@ -236,7 +253,8 @@ o2::framework::DataProcessorSpec o2::ctp::reco_workflow::getRawDecoderSpec(bool
       {"lumi-inp2", o2::framework::VariantType::String, "VBA", {"The second input used for online lumi. Name in capital."}},
       {"use-verbose-mode", o2::framework::VariantType::Bool, false, {"Verbose logging"}},
       {"max-input-size", o2::framework::VariantType::Int, 0, {"Do not process input if bigger than max size, 0 - do not check"}},
-      {"max-input-size-fatal", o2::framework::VariantType::Bool, false, {"If true issue fatal error otherwise error on;y"}},
+      {"max-input-size-fatal", o2::framework::VariantType::Bool, false, {"If true issue fatal error otherwise error only"}},
+      {"check-consistency", o2::framework::VariantType::Bool, false, {"If true checks digits consistency using ctp config"}},
       {"ctpinputs-decoding", o2::framework::VariantType::Bool, false, {"Inputs alignment: true - raw decoder - has to be compatible with CTF decoder: allowed options: 10,01,00"}}}};
 }
 void RawDecoderSpec::updateTimeDependentParams(framework::ProcessingContext& pc)

From 769ba3364776be99859990b6523814297d207aec Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Mon, 19 May 2025 17:58:22 +0200
Subject: [PATCH 0382/1764] Fix units for GeneratorFromEventPool

---
 Generators/src/GeneratorFromFile.cxx | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Generators/src/GeneratorFromFile.cxx b/Generators/src/GeneratorFromFile.cxx
index e37a3886c24e1..66f7e03a4cf15 100644
--- a/Generators/src/GeneratorFromFile.cxx
+++ b/Generators/src/GeneratorFromFile.cxx
@@ -385,6 +385,11 @@ GeneratorFromEventPool::GeneratorFromEventPool(EventPoolGenConfig const& pars) :
 
 bool GeneratorFromEventPool::Init()
 {
+  // this simply passes tracks trough. Leave units intact.
+  setTimeUnit(1.);
+  setPositionUnit(1.);
+  setEnergyUnit(1.);
+
   // initialize the event pool
   if (mConfig.rngseed > 0) {
     mRandomEngine.seed(mConfig.rngseed);
@@ -588,4 +593,4 @@ std::vector<std::string> GeneratorFromEventPool::setupFileUniverse(std::string c
 
 ClassImp(o2::eventgen::GeneratorFromEventPool);
 ClassImp(o2::eventgen::GeneratorFromFile);
-ClassImp(o2::eventgen::GeneratorFromO2Kine);
\ No newline at end of file
+ClassImp(o2::eventgen::GeneratorFromO2Kine);

From 0a9fbfa7809b174632895e1e804ab0ae42c0e2f3 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 20 May 2025 10:39:14 +0200
Subject: [PATCH 0383/1764] DPL Analysis: fix ineffective function for Builds<>
 (#14297)

---
 Framework/Core/include/Framework/AnalysisManagers.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 1d894b2b67948..dfec2256875c9 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -294,7 +294,7 @@ bool prepareOutput(ProcessingContext& context, T& spawns)
 }
 
 template <is_builds T>
-bool prepareOuput(ProcessingContext& context, T& builds)
+bool prepareOutput(ProcessingContext& context, T& builds)
 {
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::buildable_t::ref.desc_hash>>::metadata;
   return builds.template build<typename T::buildable_t::indexing_t>(builds.pack(), extractOriginals<metadata::sources.size(), metadata::sources>(context));

From 128a030847822127c42ba6e92f606d2f87b55409 Mon Sep 17 00:00:00 2001
From: Sergio Garcia <47090312+singiamtel@users.noreply.github.com>
Date: Tue, 20 May 2025 11:19:39 +0200
Subject: [PATCH 0384/1764] Github Actions: Setup dependabot (#14292)

Related: https://github.com/AliceO2Group/O2Physics/pull/10660
---
 .github/dependabot.yml | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 .github/dependabot.yml

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000000..30ad6d8f005b3
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,10 @@
+---
+# Dependabot configuration
+# Reference: https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

From dbf8b73a42164b608f91ed2095f8550788672dea Mon Sep 17 00:00:00 2001
From: Daniel Battistini <60930860+danielbattistini@users.noreply.github.com>
Date: Tue, 20 May 2025 18:06:53 +0200
Subject: [PATCH 0385/1764] Fix the thickness of logical volumes for
 kTurboStaves and kStaggered configurations of the tracker (#14268)

---
 .../TRK/simulation/include/TRKSimulation/TRKLayer.h       | 3 +++
 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx | 8 ++++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
index ef355ec36ce2f..ba894f6d7a92b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
@@ -45,6 +45,9 @@ class TRKLayer
   void createLayer(TGeoVolume* motherVolume);
 
  private:
+  // TGeo objects outside logical volumes can cause errors. Only used in case of kStaggered and kTurboStaves layouts
+  static constexpr float mLogicalVolumeThickness = 1;
+
   int mLayerNumber;
   std::string mLayerName;
   float mInnerRadius;
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index e6b00f6e96425..a95418afbba25 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -120,7 +120,7 @@ TGeoVolume* TRKLayer::createStave(std::string type, double width)
     staveVol->AddNode(chipVol, 1, nullptr);
   } else if (type == "staggered") {
     double width = mModuleWidth * 2; // Each stave has two modules (based on the LOI design)
-    stave = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
+    stave = new TGeoBBox(width / 2, mLogicalVolumeThickness / 2, mZ / 2);
     TGeoVolume* chipVolLeft = createChip("flat", mModuleWidth);
     TGeoVolume* chipVolRight = createChip("flat", mModuleWidth);
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
@@ -152,7 +152,11 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
               chipName = o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber),
               sensName = Form("%s%d", GeometryTGeo::getTRKSensorPattern(), mLayerNumber);
 
-  TGeoTube* layer = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
+  double layerThickness = mChipThickness;
+  if (mLayout != eLayout::kCylinder) {
+    layerThickness = mLogicalVolumeThickness;
+  }
+  TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, mZ / 2);
 
   TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
   layerVol->SetLineColor(kYellow);

From 930d83707083b9916ee60c18fa1680e75f8ff5f8 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 20 May 2025 19:27:52 +0200
Subject: [PATCH 0386/1764] DPL Analysis: move spawner caches outside of the
 spawner function (#14281)

---
 .../Core/include/Framework/AnalysisHelpers.h  | 12 ++++-
 .../Core/include/Framework/AnalysisManagers.h | 14 ++++-
 .../Core/include/Framework/TableBuilder.h     | 53 +++++--------------
 Framework/Core/src/AODReaderHelpers.cxx       |  8 ++-
 Framework/Core/test/test_TableSpawner.cxx     |  7 ++-
 5 files changed, 45 insertions(+), 49 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 55d2490dff1bc..95be6c7e407b3 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -297,6 +297,7 @@ struct Spawns : decltype(transformBase<T>()) {
   using extension_t = typename metadata::extension_table_t;
   using base_table_t = typename metadata::base_table_t;
   using expression_pack_t = typename metadata::expression_pack_t;
+  static constexpr size_t N = framework::pack_size(expression_pack_t{});
 
   constexpr auto pack()
   {
@@ -318,7 +319,13 @@ struct Spawns : decltype(transformBase<T>()) {
   }
   std::shared_ptr<typename T::table_t> table = nullptr;
   std::shared_ptr<extension_t> extension = nullptr;
+  std::array<o2::framework::expressions::Projector, N> projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
+  {
+    return {{std::move(C::Projector())...}};
+  }
+  (expression_pack_t{});
   std::shared_ptr<gandiva::Projector> projector = nullptr;
+  std::shared_ptr<arrow::Schema> schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
 };
 
 template <typename T>
@@ -365,6 +372,7 @@ struct Defines : decltype(transformBase<T>()) {
 
   std::array<o2::framework::expressions::Projector, N> projectors;
   std::shared_ptr<gandiva::Projector> projector = nullptr;
+  std::shared_ptr<arrow::Schema> schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(placeholders_pack_t{}));
 };
 
 template <typename T>
@@ -828,8 +836,10 @@ template <soa::is_table T, soa::is_spawnable_column... Cs>
 auto Extend(T const& table)
 {
   using output_t = Join<T, soa::Table<o2::aod::Hash<"JOIN"_h>, o2::aod::Hash<"JOIN/0"_h>, o2::aod::Hash<"JOIN"_h>, Cs...>>;
+  static std::array<framework::expressions::Projector, sizeof...(Cs)> projectors{{std::move(Cs::Projector())...}};
   static std::shared_ptr<gandiva::Projector> projector = nullptr;
-  return output_t{{o2::framework::spawner(framework::pack<Cs...>{}, {table.asArrowTable()}, "dynamicExtension", projector), table.asArrowTable()}, 0};
+  static auto schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(framework::pack<Cs...>{}));
+  return output_t{{o2::framework::spawner(framework::pack<Cs...>{}, {table.asArrowTable()}, "dynamicExtension", projectors.data(), projector, schema), table.asArrowTable()}, 0};
 }
 
 /// Template function to attach dynamic columns on-the-fly (e.g. inside
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index dfec2256875c9..2a052c0b07218 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -287,8 +287,13 @@ bool prepareOutput(ProcessingContext& context, T& spawns)
     using base_table_t = typename T::base_table_t::table_t;
     originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
   }
+  using D = o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>;
 
-  spawns.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>>(originalTable, o2::aod::label<metadata::extension_table_t::ref>(), spawns.projector));
+  spawns.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<D>(originalTable,
+                                                                                         o2::aod::label<metadata::extension_table_t::ref>(),
+                                                                                         spawns.projectors.data(),
+                                                                                         spawns.projector,
+                                                                                         spawns.schema));
   spawns.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({spawns.extension->asArrowTable(), originalTable}, std::span{T::spawnable_t::table_t::originalLabels}));
   return true;
 }
@@ -309,8 +314,13 @@ bool prepareOutput(ProcessingContext& context, T& defines)
     using base_table_t = typename T::base_table_t::table_t;
     originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
   }
+  using D = o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>;
 
-  defines.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>>(originalTable, o2::aod::label<metadata::extension_table_t::ref>(), defines.projectors.data(), defines.projector));
+  defines.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<D>(originalTable,
+                                                                                          o2::aod::label<metadata::extension_table_t::ref>(),
+                                                                                          defines.projectors.data(),
+                                                                                          defines.projector,
+                                                                                          defines.schema));
   defines.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({defines.extension->asArrowTable(), originalTable}, std::span{T::spawnable_t::table_t::originalLabels}));
   return true;
 }
diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index e2d12789ef922..f941bf29bd8c8 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -768,80 +768,51 @@ std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const&
 /// Expression-based column generator to materialize columns
 template <aod::is_aod_hash D>
   requires(soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
-auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector)
+auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
 {
   using placeholders_pack_t = typename o2::aod::MetadataTrait<D>::metadata::placeholders_pack_t;
-  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{o2::aod::MetadataTrait<D>::metadata::base_table_t::originalLabels});
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, placeholders_pack_t{});
   }
-  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(placeholders_pack_t{}));
-
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(placeholders_pack_t{}), projectors, name, projector);
+  return spawnerHelper(fullTable, schema, framework::pack_size(placeholders_pack_t{}), projectors, name, projector);
 }
 
 template <aod::is_aod_hash D>
   requires(soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
-auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector)
+auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
 {
-  using placeholders_pack_t = typename o2::aod::MetadataTrait<D>::metadata::placeholders_pack_t;
-  if (fullTable->num_rows() == 0) {
-    return makeEmptyTable(name, placeholders_pack_t{});
-  }
-  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(placeholders_pack_t{}));
-
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(placeholders_pack_t{}), projectors, name, projector);
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{o2::aod::MetadataTrait<D>::metadata::base_table_t::originalLabels});
+  return spawner<D>(fullTable, name, projectors, projector, schema);
 }
 
 template <aod::is_aod_hash D>
   requires(soa::has_extension<typename o2::aod::MetadataTrait<D>::metadata> && !soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
-auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, std::shared_ptr<gandiva::Projector>& projector)
+auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
 {
   using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
-  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{o2::aod::MetadataTrait<D>::metadata::base_table_t::originalLabels});
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, expression_pack_t{});
   }
-  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
-
-  auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
-  {
-    return {{std::move(C::Projector())...}};
-  }
-  (expression_pack_t{});
-
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), name, projector);
+  return spawnerHelper(fullTable, schema, framework::pack_size(expression_pack_t{}), projectors, name, projector);
 }
 
 template <aod::is_aod_hash D>
   requires(soa::has_extension<typename o2::aod::MetadataTrait<D>::metadata> && !soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
-auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, std::shared_ptr<gandiva::Projector>& projector)
+auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
 {
-  using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
-  if (fullTable->num_rows() == 0) {
-    return makeEmptyTable(name, expression_pack_t{});
-  }
-  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
-  auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
-  {
-    return {{std::move(C::Projector())...}};
-  }
-  (expression_pack_t{});
-
-  return spawnerHelper(fullTable, new_schema, framework::pack_size(expression_pack_t{}), projectors.data(), name, projector);
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{o2::aod::MetadataTrait<D>::metadata::base_table_t::originalLabels});
+  return spawner<D>(fullTable, name, projectors, projector, schema);
 }
 
 template <typename... C>
-auto spawner(framework::pack<C...> columns, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, std::shared_ptr<gandiva::Projector>& projector)
+auto spawner(framework::pack<C...>, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
 {
   std::array<const char*, 1> labels{"original"};
   auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span<const char* const>{labels});
   if (fullTable->num_rows() == 0) {
     return makeEmptyTable(name, framework::pack<C...>{});
   }
-  static auto new_schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(columns));
-  std::array<expressions::Projector, sizeof...(C)> projectors{{std::move(C::Projector())...}};
-  return spawnerHelper(fullTable, new_schema, sizeof...(C), projectors.data(), name, projector);
+  return spawnerHelper(fullTable, schema, sizeof...(C), projectors, name, projector);
 }
 
 template <typename... T>
diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index c413f2520919d..4dbd2877476be 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -158,7 +158,13 @@ auto make_spawn(InputSpec const& input, ProcessingContext& pc)
   using metadata_t = o2::aod::MetadataTrait<D>::metadata;
   constexpr auto sources = metadata_t::sources;
   static std::shared_ptr<gandiva::Projector> projector = nullptr;
-  return o2::framework::spawner<D>(extractOriginals<sources.size(), sources>(pc), input.binding.c_str(), projector);
+  static std::shared_ptr<arrow::Schema> schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(typename metadata_t::expression_pack_t{}));
+  static auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
+  {
+    return {{std::move(C::Projector())...}};
+  }
+  (typename metadata_t::expression_pack_t{});
+  return o2::framework::spawner<D>(extractOriginals<sources.size(), sources>(pc), input.binding.c_str(), projectors.data(), projector, schema);
 }
 } // namespace
 
diff --git a/Framework/Core/test/test_TableSpawner.cxx b/Framework/Core/test/test_TableSpawner.cxx
index 2291ba5f4f787..e200adf37ccb4 100644
--- a/Framework/Core/test/test_TableSpawner.cxx
+++ b/Framework/Core/test/test_TableSpawner.cxx
@@ -50,10 +50,9 @@ TEST_CASE("TestTableSpawner")
   auto t1 = b1.finalize();
   Points st1{t1};
 
-  std::shared_ptr<gandiva::Projector> projector = nullptr;
-
   auto expoints_a = o2::soa::Extend<o2::aod::Points, test::Rsq, test::Sin>(st1);
-  auto extension = ExPointsExtension{o2::framework::spawner<o2::aod::Hash<"EXPTSNG/0"_h>>(t1, o2::aod::Hash<"ExPoints"_h>::str, projector)};
+  Spawns<ExPoints> s;
+  auto extension = ExPointsExtension{o2::framework::spawner<o2::aod::Hash<"EXPTSNG/0"_h>>(t1, o2::aod::Hash<"ExPoints"_h>::str, s.projectors.data(), s.projector, s.schema)};
   auto expoints = ExPoints{{t1, extension.asArrowTable()}, 0};
 
   REQUIRE(expoints_a.size() == 9);
@@ -81,7 +80,7 @@ TEST_CASE("TestTableSpawner")
   Defines<ExcPoints> excpts;
   excpts.projectors[0] = test::x * test::x + test::y * test::y + test::z * test::z;
 
-  auto extension_2 = ExcPointsCfgExtension{o2::framework::spawner<o2::aod::Hash<"EXCFGPTS/0"_h>>({t1}, o2::aod::Hash<"ExcPoints"_h>::str, excpts.projectors.data(), excpts.projector)};
+  auto extension_2 = ExcPointsCfgExtension{o2::framework::spawner<o2::aod::Hash<"EXCFGPTS/0"_h>>({t1}, o2::aod::Hash<"ExcPoints"_h>::str, excpts.projectors.data(), excpts.projector, excpts.schema)};
   auto excpoints = ExcPoints{{t1, extension_2.asArrowTable()}, 0};
 
   rex = extension.begin();

From 23781677b66c802d8f8ea8e2dbb390b425d91bec Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 20 May 2025 23:59:09 +0200
Subject: [PATCH 0387/1764] GPU TPC NN Clusterizer: Fix compilation without
 ONNX

---
 GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 6c4e60a6025e1..64e6f5a31aaa7 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -1198,6 +1198,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     }
   }
   for (int32_t i = 0; i < GetProcessingSettings().nTPCClustererLanes; i++) {
+#ifdef GPUCA_HAS_ONNX
     if (GetProcessingSettings().nn.applyNNclusterizer) {
       LOG(info) << "(ORT) Environment releasing...";
       GPUTPCNNClusterizerHost& nnApplication = nnApplications[i];
@@ -1205,6 +1206,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
       nnApplication.mModelReg1.release(true);
       nnApplication.mModelReg2.release(true);
     }
+#endif
     if (transferRunning[i]) {
       ReleaseEvent(mEvents->stream[i], doGPU);
     }

From 546f79341f0407ed993b08046b97ef3f7a34e8cd Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 21 May 2025 16:06:32 +0200
Subject: [PATCH 0388/1764] DPL: fix error reporting (#14306)

Any oldest possible timeframe message was accounted as error.

Maybe we should simply drop the metric...
---
 Framework/Core/src/DataProcessingDevice.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index ae25d8d3a915c..c303af4858234 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -2107,7 +2107,7 @@ void DataProcessingDevice::handleData(ServiceRegistryRef ref, InputChannelInfo&
           LOGP(debug, "Got DomainInfoHeader, new oldestPossibleTimeslice {} on channel {}", oldestPossibleTimeslice, info.id.value);
           parts.At(headerIndex).reset(nullptr);
           parts.At(payloadIndex).reset(nullptr);
-        }
+        } break;
         case InputType::Invalid: {
           reportError("Invalid part found.");
         } break;

From 981cd40881706e1cf56a2e99d2778c683835153f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 20 May 2025 16:07:57 +0200
Subject: [PATCH 0389/1764] GPU: Add possibility to dump raw data in case of
 error

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |   2 +
 GPU/GPUTracking/Base/GPUReconstruction.h      |  11 +
 .../Base/GPUReconstructionDebug.cxx           | 188 ++++++++++++++++++
 .../Base/GPUReconstructionLibrary.cxx         |   2 +-
 GPU/GPUTracking/CMakeLists.txt                |   1 +
 GPU/GPUTracking/Definitions/GPUSettingsList.h |   8 +
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  28 ++-
 GPU/GPUTracking/Global/GPUChainTracking.h     |   7 +-
 .../GPUChainTrackingDebugAndProfiling.cxx     |  24 ++-
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  81 ++++----
 GPU/GPUTracking/Global/GPUErrorCodes.h        |   1 +
 GPU/GPUTracking/Global/GPUErrors.cxx          |   8 +-
 GPU/GPUTracking/Global/GPUErrors.h            |   2 +-
 13 files changed, 313 insertions(+), 50 deletions(-)
 create mode 100644 GPU/GPUTracking/Base/GPUReconstructionDebug.cxx

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index c76bf11c3e25d..a4e5d5e1189f5 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -193,6 +193,7 @@ int32_t GPUReconstruction::Init()
     }
     mSlaves[i]->ClearAllocatedMemory();
   }
+  debugInit();
   return 0;
 }
 
@@ -469,6 +470,7 @@ int32_t GPUReconstruction::Exit()
   if (mInitialized) {
     ExitDevice();
   }
+  debugExit();
   mInitialized = false;
   return 0;
 }
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index d5c0b8e828087..e0c866fd9421b 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -22,6 +22,7 @@
 #include <memory>
 #include <iosfwd>
 #include <vector>
+#include <functional>
 #include <unordered_map>
 #include <unordered_set>
 
@@ -239,6 +240,9 @@ class GPUReconstruction
   virtual void PrintKernelOccupancies() {}
   double GetStatKernelTime() { return mStatKernelTime; }
   double GetStatWallTime() { return mStatWallTime; }
+  void setDebugDumpCallback(std::function<void()>&& callback = std::function<void()>(nullptr));
+  bool triggerDebugDump();
+  std::string getDebugFolder(const std::string& prefix = ""); // empty string = no debug
 
   // Threading
   std::shared_ptr<GPUReconstructionThreading> mThreading;
@@ -407,6 +411,13 @@ class GPUReconstruction
   };
   static std::shared_ptr<LibraryLoader> sLibCUDA, sLibHIP, sLibOCL;
 
+  // Debugging
+  struct debugInternal;
+  static std::unique_ptr<debugInternal> mDebugData;
+  bool mDebugEnabled = false;
+  void debugInit();
+  void debugExit();
+
   static GPUReconstruction* GPUReconstruction_Create_CPU(const GPUSettingsDeviceBackend& cfg);
 };
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx b/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx
new file mode 100644
index 0000000000000..c1c31eedde1b2
--- /dev/null
+++ b/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx
@@ -0,0 +1,188 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUReconstructionDebug.cxx
+/// \author David Rohr
+
+#include "GPUReconstruction.h"
+#include "GPULogging.h"
+#include "GPUSettings.h"
+
+#include <csignal>
+#include <functional>
+#include <unordered_map>
+#include <mutex>
+#include <filesystem>
+#include <chrono>
+#include <format>
+
+using namespace o2::gpu;
+
+struct GPUReconstruction::debugInternal {
+  std::function<void(int32_t, siginfo_t*, void*)> signalCallback;
+  std::function<void()> debugCallback = nullptr;
+  std::function<void()> reinstallCallback = nullptr;
+  std::unordered_map<int32_t, struct sigaction> oldActions;
+  size_t debugCount = 0;
+  static void globalCallback(int32_t signal, siginfo_t* info, void* ucontext)
+  {
+    GPUReconstruction::mDebugData->signalCallback(signal, info, ucontext);
+  }
+};
+
+std::unique_ptr<GPUReconstruction::debugInternal> GPUReconstruction::mDebugData;
+
+void GPUReconstruction::debugInit()
+{
+  if (GetProcessingSettings().debugOnFailure) {
+    static std::mutex initMutex;
+    {
+      std::lock_guard<std::mutex> guard(initMutex);
+      if (mDebugData) {
+        GPUFatal("Error handlers for debug dumps already set, cannot set them again");
+      }
+      mDebugData = std::make_unique<debugInternal>();
+    }
+    mDebugEnabled = true;
+    if ((GetProcessingSettings().debugOnFailure & 1) || (GetProcessingSettings().debugOnFailure & 2)) {
+      struct sigaction sa, oldsa;
+      memset(&sa, 0, sizeof(sa));
+      sa.sa_sigaction = GPUReconstruction::debugInternal::globalCallback;
+      sa.sa_flags = SA_SIGINFO;
+      uint32_t mask = GetProcessingSettings().debugOnFailureSignalMask == (uint32_t)-1 ? ((1 << SIGINT) | (1 << SIGABRT) | (1 << SIGBUS) | (1 << SIGTERM) | (1 << SIGSEGV)) : GetProcessingSettings().debugOnFailureSignalMask;
+      if (mask) {
+        for (uint32_t i = 0; i < sizeof(mask) * 8; i++) {
+          if (mask & (1 << i)) {
+            if (sigaction(i, &sa, &oldsa)) {
+              GPUFatal("Error installing signal handler for error dump on signal %d", i);
+            }
+            mDebugData->oldActions.emplace(i, oldsa);
+          }
+        }
+      }
+
+      mDebugData->signalCallback = [this, &oldActions = mDebugData->oldActions, myAction = std::move(sa)](int32_t signal, siginfo_t* info, void* ucontext) {
+        static std::mutex callbackMutex;
+        std::lock_guard<std::mutex> guard(callbackMutex);
+        if (mDebugData->debugCallback) {
+          GPUInfo("Running debug callback for signal %d", signal);
+          mDebugData->debugCallback();
+          mDebugData->debugCount++;
+        }
+        mDebugData->debugCallback = nullptr;
+        if (!GetProcessingSettings().debugOnFailureNoForwardSignal) {
+          sigaction(signal, &oldActions[signal], nullptr);
+          raise(signal);
+          mDebugData->reinstallCallback = [signal, myAction]() { sigaction(signal, &myAction, nullptr); };
+        }
+      };
+    }
+  }
+}
+
+void GPUReconstruction::debugExit()
+{
+  if (!mDebugEnabled) {
+    return;
+  }
+  if (mDebugData) {
+    for (auto& it : mDebugData->oldActions) {
+      if (sigaction(it.first, &it.second, nullptr)) {
+        GPUFatal("Error restoring signal handler for signal %d", it.first);
+      }
+    }
+  }
+  mDebugEnabled = false;
+}
+
+void GPUReconstruction::setDebugDumpCallback(std::function<void()>&& callback)
+{
+  if (mMaster) {
+    if (mDebugData->reinstallCallback) {
+      mDebugData->reinstallCallback();
+      mDebugData->reinstallCallback = nullptr;
+    }
+    mMaster->setDebugDumpCallback(std::move(callback));
+  } else if (mDebugEnabled && mDebugData) {
+    mDebugData->debugCallback = callback;
+  }
+}
+
+std::string GPUReconstruction::getDebugFolder(const std::string& prefix)
+{
+  const std::filesystem::path target_dir = GetProcessingSettings().debugOnFailureDirectory;
+
+  std::size_t total_size = 0;
+  std::size_t subfolder_count = 0;
+
+  if (!std::filesystem::exists(target_dir) || !std::filesystem::is_directory(target_dir)) {
+    GPUError("Invalid debugOnFailureDirectory %s", GetProcessingSettings().debugOnFailureDirectory.c_str());
+    return "";
+  }
+
+  for (const auto& entry : std::filesystem::directory_iterator(target_dir)) {
+    if (entry.is_directory()) {
+      subfolder_count++;
+
+      for (const auto& subentry : std::filesystem::directory_iterator(entry.path())) {
+        if (subentry.is_regular_file()) {
+          std::error_code ec;
+          auto size = std::filesystem::file_size(subentry.path(), ec);
+          if (!ec) {
+            total_size += size;
+          }
+        }
+      }
+    }
+  }
+
+  if ((GetProcessingSettings().debugOnFailureMaxFiles && subfolder_count >= GetProcessingSettings().debugOnFailureMaxFiles) || (GetProcessingSettings().debugOnFailureMaxSize && (total_size >> 30) >= GetProcessingSettings().debugOnFailureMaxSize)) {
+    GPUError("Cannot store debug dump files, target storage exceeded: %zu dumps, %zu bytes", subfolder_count, total_size);
+    return "";
+  }
+
+  auto currentTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
+  std::ostringstream dateTime;
+  dateTime << std::put_time(std::localtime(&currentTime), "%Y-%m-%d_%H-%M-%S");
+
+  int32_t attempt = 0;
+  std::string outname;
+  while (true) {
+    if (attempt++ >= 512) {
+      GPUError("Error creating debug dump folder");
+      return "";
+    }
+
+    outname = GetProcessingSettings().debugOnFailureDirectory + "/debug_" + prefix + (prefix == "" ? "" : "_") + dateTime.str() + "_" + std::to_string(attempt);
+    std::error_code ec;
+    bool created = std::filesystem::create_directory(outname, ec);
+    if (!ec && created) {
+      break;
+    }
+  }
+
+  GPUInfo("Debug dump to %s", outname.c_str());
+  return outname;
+}
+
+bool GPUReconstruction::triggerDebugDump()
+{
+  if (mMaster) {
+    return mMaster->triggerDebugDump();
+  } else if (mDebugEnabled && mDebugData && mDebugData->debugCallback) {
+    GPUInfo("Running triggered debug callback");
+    mDebugData->debugCallback();
+    mDebugData->debugCount++;
+    mDebugData->debugCallback = nullptr;
+    return true;
+  }
+  return false;
+}
diff --git a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
index 89517c612403b..64184dd724acd 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUReconstruction.cxx
+/// \file GPUReconstructionLibrary.cxx
 /// \author David Rohr
 
 #ifdef _WIN32
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 52848692e7516..1b108bc74190d 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -95,6 +95,7 @@ set(SRCS_NO_CINT
 set(SRCS_NO_H SectorTracker/GPUTPCTrackerDump.cxx
               Merger/GPUTPCGMMergerDump.cxx
               Base/GPUReconstructionLibrary.cxx
+              Base/GPUReconstructionDebug.cxx
               Global/GPUChainTrackingClusterizer.cxx
               Global/GPUChainTrackingTransformation.cxx
               Global/GPUChainTrackingTRD.cxx
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index b9be1db881816..12f40cda4c398 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -360,6 +360,14 @@ AddOption(oclCompileFromSources, bool, false, "", 0, "Compile OpenCL binary from
 AddOption(oclOverrideSourceBuildFlags, std::string, "", "", 0, "Override OCL build flags for compilation from source, put a space for empty options")
 AddOption(printSettings, bool, false, "", 0, "Print all settings when initializing")
 AddOption(tpcFreeAllocatedMemoryAfterProcessing, bool, false, "", 0, "Clean all memory allocated by TPC when TPC processing done, only data written to external output resources will remain")
+AddOption(debugOnFailure, int32_t, 0, "", 0, "Dump raw data in case an error occured, bit 1 enables all dumps, otherwise bitmask for: 2 = signal, 3 = GPUErrorCode", def(1))
+AddOption(debugOnFailureSignalMask, uint32_t, (uint32_t)-1, "", 0, "Mask of signals that trigger debug / dump")
+AddOption(debugOnFailureErrorMask, uint64_t, (uint64_t)-1, "", 0, "Mask of GPUCA_ERRORS that trigger debug / dump")
+AddOption(debugOnFailureNoForwardSignal, bool, false, "", 0, "Do not forward signal to original signal handler")
+AddOption(debugOnFailureMaxN, uint32_t, 1, "", 0, "Max number of times to run the debug / dump")
+AddOption(debugOnFailureMaxFiles, uint32_t, 0, "", 0, "Max number of files to have in the target folder")
+AddOption(debugOnFailureMaxSize, uint32_t, 0, "", 0, "Max size of existing dumps in the target folder in GB")
+AddOption(debugOnFailureDirectory, std::string, ".", "", 0, "Target folder for debug / dump")
 AddVariable(eventDisplay, o2::gpu::GPUDisplayFrontendInterface*, nullptr)
 AddSubConfig(GPUSettingsProcessingRTC, rtc)
 AddSubConfig(GPUSettingsProcessingRTCtechnical, rtctech)
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index c1c3e368ce90c..db84050772312 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -705,10 +705,14 @@ int32_t GPUChainTracking::RunChain()
   }
   mRec->getGeneralStepTimer(GeneralStep::Prepare).Stop();
 
-  PrepareDebugOutput();
+  PrepareKernelDebugOutput();
 
   SynchronizeStream(0); // Synchronize all init copies that might be ongoing
 
+  if (GetProcessingSettings().debugOnFailure) {
+    mRec->setDebugDumpCallback([this]() { DoDebugRawDump(); });
+  }
+
   if (mIOPtrs.tpcCompressedClusters) {
     if (runRecoStep(RecoStep::TPCDecompression, &GPUChainTracking::RunTPCDecompression)) {
       return 1;
@@ -775,7 +779,7 @@ int32_t GPUChainTracking::RunChain()
   }
 
   int32_t retVal = 0;
-  if (CheckErrorCodes(false, false, mRec->getErrorCodeOutput())) {
+  if (CheckErrorCodes(false, false, mRec->getErrorCodeOutput())) { // TODO: Eventually, we should use GPUReconstruction::CheckErrorCodes
     retVal = 3;
     if (!GetProcessingSettings().ignoreNonFatalGPUErrors) {
       return retVal;
@@ -815,7 +819,7 @@ int32_t GPUChainTracking::RunChainFinalize()
     PrintOutputStat();
   }
 
-  PrintDebugOutput();
+  PrintKernelDebugOutput();
 
   // PrintMemoryRelations();
 
@@ -884,6 +888,7 @@ int32_t GPUChainTracking::FinalizePipelinedProcessing()
 int32_t GPUChainTracking::CheckErrorCodes(bool cpuOnly, bool forceShowErrors, std::vector<std::array<uint32_t, 4>>* fillErrors)
 {
   int32_t retVal = 0;
+  bool hasDebugError = false;
   for (int32_t i = 0; i < 1 + (!cpuOnly && mRec->IsGPU()); i++) {
     if (i) {
       const auto& threadContext = GetThreadContext();
@@ -925,9 +930,26 @@ int32_t GPUChainTracking::CheckErrorCodes(bool cpuOnly, bool forceShowErrors, st
           fillErrors->emplace_back(std::array<uint32_t, 4>{pErrors[4 * j], pErrors[4 * j + 1], pErrors[4 * j + 2], pErrors[4 * j + 3]});
         }
       }
+      if ((GetProcessingSettings().debugOnFailure & 1) || (GetProcessingSettings().debugOnFailure & 4)) {
+        if (GetProcessingSettings().debugOnFailureErrorMask == (uint64_t)-1) {
+          hasDebugError = true;
+        } else {
+          uint32_t nErrors = processors()->errorCodes.getNErrors();
+          const uint32_t* pErrors = processors()->errorCodes.getErrorPtr();
+          for (uint32_t j = 0; j < nErrors; j++) {
+            if (GetProcessingSettings().debugOnFailureErrorMask & (1 << pErrors[4 * j])) {
+              hasDebugError = true;
+              break;
+            }
+          }
+        }
+      }
     }
   }
   ClearErrorCodes(cpuOnly);
+  if (hasDebugError) {
+    mRec->triggerDebugDump();
+  }
   return retVal;
 }
 
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 2a2996895dbcf..7d4adcd70af7f 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -134,7 +134,7 @@ class GPUChainTracking : public GPUChain
   void ClearIOPointers();
   void AllocateIOMemory();
   using GPUChain::DumpData;
-  void DumpData(const char* filename);
+  void DumpData(const char* filename, const GPUTrackingInOutPointers* ioPtrs = nullptr);
   using GPUChain::ReadData;
   int32_t ReadData(const char* filename);
   void DumpSettings(const char* dir = "") override;
@@ -231,11 +231,12 @@ class GPUChainTracking : public GPUChain
   int32_t DoProfile();
   void PrintMemoryRelations();
   void PrintMemoryStatistics() override;
-  void PrepareDebugOutput();
-  void PrintDebugOutput();
+  void PrepareKernelDebugOutput();
+  void PrintKernelDebugOutput();
   void PrintOutputStat();
   static void DumpClusters(std::ostream& out, const o2::tpc::ClusterNativeAccess* clusters);
   static void DebugSortCompressedClusters(o2::tpc::CompressedClustersFlat* cls);
+  void DoDebugRawDump();
 
   bool ValidateSteps();
   bool ValidateSettings();
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index f72943e6bcd5a..e9721ec9d12bf 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -185,7 +185,7 @@ void GPUChainTracking::PrintMemoryRelations()
   GPUInfo("MEMREL TrackHitss NCl %d NTrkH %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NOutputTrackClusters());
 }
 
-void GPUChainTracking::PrepareDebugOutput()
+void GPUChainTracking::PrepareKernelDebugOutput()
 {
 #ifdef GPUCA_KERNEL_DEBUGGER_OUTPUT
   const auto& threadContext = GetThreadContext();
@@ -198,7 +198,7 @@ void GPUChainTracking::PrepareDebugOutput()
 #endif
 }
 
-void GPUChainTracking::PrintDebugOutput()
+void GPUChainTracking::PrintKernelDebugOutput()
 {
 #ifdef GPUCA_KERNEL_DEBUGGER_OUTPUT
   const auto& threadContext = GetThreadContext();
@@ -390,3 +390,23 @@ void GPUChainTracking::DebugSortCompressedClusters(o2::tpc::CompressedClustersFl
   sortMultiple(c.nAttachedClustersReduced, getReducedOffset, getN1, c.rowDiffA, c.sliceLegDiffA, c.padResA, c.timeResA);
   sortMultiple(c.nTracks, getIndex, get1, c.qPtA, c.rowA, c.sliceA, c.timeA, c.padA, c.nTrackClusters); // NOTE: This must be last, since nTrackClusters is used for handling the arrays above!
 }
+
+void GPUChainTracking::DoDebugRawDump()
+{
+  std::string dirName = mRec->getDebugFolder("tpc_raw");
+  if (dirName == "") {
+    return;
+  }
+  GPUTrackingInOutPointers ioPtrs;
+  if (mIOPtrs.tpcZS) {
+    ioPtrs.tpcZS = mIOPtrs.tpcZS;
+  } else if (mIOPtrs.tpcPackedDigits) {
+    ioPtrs.tpcPackedDigits = mIOPtrs.tpcPackedDigits;
+  } else if (mIOPtrs.clustersNative) {
+    ioPtrs.clustersNative = mIOPtrs.clustersNative;
+  }
+
+  GPUInfo("Doing debug raw dump");
+  mRec->DumpSettings((dirName + "/").c_str());
+  DumpData((dirName + "/event.0.dump").c_str(), &ioPtrs);
+}
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 035e257ca7952..5a141cd08eb65 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -63,33 +63,36 @@ GPUChainTracking::InOutMemory::~InOutMemory() = default;
 GPUChainTracking::InOutMemory::InOutMemory(GPUChainTracking::InOutMemory&&) = default;
 GPUChainTracking::InOutMemory& GPUChainTracking::InOutMemory::operator=(GPUChainTracking::InOutMemory&&) = default; // NOLINT: False positive in clang-tidy
 
-void GPUChainTracking::DumpData(const char* filename)
+void GPUChainTracking::DumpData(const char* filename, const GPUTrackingInOutPointers* ioPtrs)
 {
   FILE* fp = fopen(filename, "w+b");
   if (fp == nullptr) {
     return;
   }
+  if (ioPtrs == nullptr) {
+    ioPtrs = &mIOPtrs;
+  }
   fwrite(DUMP_HEADER, 1, DUMP_HEADER_SIZE, fp);
   fwrite(&GPUReconstruction::geometryType, sizeof(GPUReconstruction::geometryType), 1, fp);
-  DumpData(fp, mIOPtrs.clusterData, mIOPtrs.nClusterData, InOutPointerType::CLUSTER_DATA);
-  DumpData(fp, mIOPtrs.rawClusters, mIOPtrs.nRawClusters, InOutPointerType::RAW_CLUSTERS);
-  if (mIOPtrs.clustersNative) {
-    if (DumpData(fp, &mIOPtrs.clustersNative->clustersLinear, &mIOPtrs.clustersNative->nClustersTotal, InOutPointerType::CLUSTERS_NATIVE)) {
-      fwrite(&mIOPtrs.clustersNative->nClusters[0][0], sizeof(mIOPtrs.clustersNative->nClusters[0][0]), NSECTORS * GPUCA_ROW_COUNT, fp);
-      if (mIOPtrs.clustersNative->clustersMCTruth) {
-        const auto& buffer = mIOPtrs.clustersNative->clustersMCTruth->getBuffer();
+  DumpData(fp, ioPtrs->clusterData, ioPtrs->nClusterData, InOutPointerType::CLUSTER_DATA);
+  DumpData(fp, ioPtrs->rawClusters, ioPtrs->nRawClusters, InOutPointerType::RAW_CLUSTERS);
+  if (ioPtrs->clustersNative) {
+    if (DumpData(fp, &ioPtrs->clustersNative->clustersLinear, &ioPtrs->clustersNative->nClustersTotal, InOutPointerType::CLUSTERS_NATIVE)) {
+      fwrite(&ioPtrs->clustersNative->nClusters[0][0], sizeof(ioPtrs->clustersNative->nClusters[0][0]), NSECTORS * GPUCA_ROW_COUNT, fp);
+      if (ioPtrs->clustersNative->clustersMCTruth) {
+        const auto& buffer = ioPtrs->clustersNative->clustersMCTruth->getBuffer();
         std::pair<const char*, size_t> tmp = {buffer.data(), buffer.size()};
         DumpData(fp, &tmp.first, &tmp.second, InOutPointerType::CLUSTER_NATIVE_MC);
       }
     }
   }
-  if (mIOPtrs.tpcPackedDigits) {
-    if (DumpData(fp, mIOPtrs.tpcPackedDigits->tpcDigits, mIOPtrs.tpcPackedDigits->nTPCDigits, InOutPointerType::TPC_DIGIT) && mIOPtrs.tpcPackedDigits->tpcDigitsMC) {
+  if (ioPtrs->tpcPackedDigits) {
+    if (DumpData(fp, ioPtrs->tpcPackedDigits->tpcDigits, ioPtrs->tpcPackedDigits->nTPCDigits, InOutPointerType::TPC_DIGIT) && ioPtrs->tpcPackedDigits->tpcDigitsMC) {
       const char* ptrs[NSECTORS];
       size_t sizes[NSECTORS];
       for (uint32_t i = 0; i < NSECTORS; i++) {
-        if (mIOPtrs.tpcPackedDigits->tpcDigitsMC->v[i]) {
-          const auto& buffer = mIOPtrs.tpcPackedDigits->tpcDigitsMC->v[i]->getBuffer();
+        if (ioPtrs->tpcPackedDigits->tpcDigitsMC->v[i]) {
+          const auto& buffer = ioPtrs->tpcPackedDigits->tpcDigitsMC->v[i]->getBuffer();
           ptrs[i] = buffer.data();
           sizes[i] = buffer.size();
         } else {
@@ -100,12 +103,12 @@ void GPUChainTracking::DumpData(const char* filename)
       DumpData(fp, ptrs, sizes, InOutPointerType::TPC_DIGIT_MC);
     }
   }
-  if (mIOPtrs.tpcZS) {
+  if (ioPtrs->tpcZS) {
     size_t total = 0;
     for (int32_t i = 0; i < NSECTORS; i++) {
       for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
-        for (uint32_t k = 0; k < mIOPtrs.tpcZS->sector[i].count[j]; k++) {
-          total += mIOPtrs.tpcZS->sector[i].nZSPtr[j][k];
+        for (uint32_t k = 0; k < ioPtrs->tpcZS->sector[i].count[j]; k++) {
+          total += ioPtrs->tpcZS->sector[i].nZSPtr[j][k];
         }
       }
     }
@@ -115,10 +118,10 @@ void GPUChainTracking::DumpData(const char* filename)
     total = 0;
     for (int32_t i = 0; i < NSECTORS; i++) {
       for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
-        for (uint32_t k = 0; k < mIOPtrs.tpcZS->sector[i].count[j]; k++) {
-          memcpy(&ptr[total * TPCZSHDR::TPC_ZS_PAGE_SIZE], mIOPtrs.tpcZS->sector[i].zsPtr[j][k], mIOPtrs.tpcZS->sector[i].nZSPtr[j][k] * TPCZSHDR::TPC_ZS_PAGE_SIZE);
-          counts.count[i][j] += mIOPtrs.tpcZS->sector[i].nZSPtr[j][k];
-          total += mIOPtrs.tpcZS->sector[i].nZSPtr[j][k];
+        for (uint32_t k = 0; k < ioPtrs->tpcZS->sector[i].count[j]; k++) {
+          memcpy(&ptr[total * TPCZSHDR::TPC_ZS_PAGE_SIZE], ioPtrs->tpcZS->sector[i].zsPtr[j][k], ioPtrs->tpcZS->sector[i].nZSPtr[j][k] * TPCZSHDR::TPC_ZS_PAGE_SIZE);
+          counts.count[i][j] += ioPtrs->tpcZS->sector[i].nZSPtr[j][k];
+          total += ioPtrs->tpcZS->sector[i].nZSPtr[j][k];
         }
       }
     }
@@ -127,33 +130,33 @@ void GPUChainTracking::DumpData(const char* filename)
       fwrite(&counts, sizeof(counts), 1, fp);
     }
   }
-  if (mIOPtrs.tpcCompressedClusters) {
-    if (mIOPtrs.tpcCompressedClusters->ptrForward) {
+  if (ioPtrs->tpcCompressedClusters) {
+    if (ioPtrs->tpcCompressedClusters->ptrForward) {
       throw std::runtime_error("Cannot dump non-flat compressed clusters");
     }
-    char* ptr = (char*)mIOPtrs.tpcCompressedClusters;
-    size_t size = mIOPtrs.tpcCompressedClusters->totalDataSize;
+    char* ptr = (char*)ioPtrs->tpcCompressedClusters;
+    size_t size = ioPtrs->tpcCompressedClusters->totalDataSize;
     DumpData(fp, &ptr, &size, InOutPointerType::TPC_COMPRESSED_CL);
   }
-  if (mIOPtrs.settingsTF) {
+  if (ioPtrs->settingsTF) {
     uint32_t n = 1;
-    DumpData(fp, &mIOPtrs.settingsTF, &n, InOutPointerType::TF_SETTINGS);
+    DumpData(fp, &ioPtrs->settingsTF, &n, InOutPointerType::TF_SETTINGS);
   }
-  DumpData(fp, mIOPtrs.sectorTracks, mIOPtrs.nSectorTracks, InOutPointerType::SECTOR_OUT_TRACK);
-  DumpData(fp, mIOPtrs.sectorClusters, mIOPtrs.nSectorClusters, InOutPointerType::SECTOR_OUT_CLUSTER);
-  DumpData(fp, &mIOPtrs.mcLabelsTPC, &mIOPtrs.nMCLabelsTPC, InOutPointerType::MC_LABEL_TPC);
-  DumpData(fp, &mIOPtrs.mcInfosTPC, &mIOPtrs.nMCInfosTPC, InOutPointerType::MC_INFO_TPC);
-  DumpData(fp, &mIOPtrs.mcInfosTPCCol, &mIOPtrs.nMCInfosTPCCol, InOutPointerType::MC_INFO_TPC);
-  DumpData(fp, &mIOPtrs.mergedTracks, &mIOPtrs.nMergedTracks, InOutPointerType::MERGED_TRACK);
-  DumpData(fp, &mIOPtrs.mergedTrackHits, &mIOPtrs.nMergedTrackHits, InOutPointerType::MERGED_TRACK_HIT);
-  DumpData(fp, &mIOPtrs.trdTracks, &mIOPtrs.nTRDTracks, InOutPointerType::TRD_TRACK);
-  DumpData(fp, &mIOPtrs.trdTracklets, &mIOPtrs.nTRDTracklets, InOutPointerType::TRD_TRACKLET);
-  if (mIOPtrs.trdSpacePoints) {
-    DumpData(fp, &mIOPtrs.trdSpacePoints, &mIOPtrs.nTRDTracklets, InOutPointerType::TRD_SPACEPOINT);
+  DumpData(fp, ioPtrs->sectorTracks, ioPtrs->nSectorTracks, InOutPointerType::SECTOR_OUT_TRACK);
+  DumpData(fp, ioPtrs->sectorClusters, ioPtrs->nSectorClusters, InOutPointerType::SECTOR_OUT_CLUSTER);
+  DumpData(fp, &ioPtrs->mcLabelsTPC, &ioPtrs->nMCLabelsTPC, InOutPointerType::MC_LABEL_TPC);
+  DumpData(fp, &ioPtrs->mcInfosTPC, &ioPtrs->nMCInfosTPC, InOutPointerType::MC_INFO_TPC);
+  DumpData(fp, &ioPtrs->mcInfosTPCCol, &ioPtrs->nMCInfosTPCCol, InOutPointerType::MC_INFO_TPC);
+  DumpData(fp, &ioPtrs->mergedTracks, &ioPtrs->nMergedTracks, InOutPointerType::MERGED_TRACK);
+  DumpData(fp, &ioPtrs->mergedTrackHits, &ioPtrs->nMergedTrackHits, InOutPointerType::MERGED_TRACK_HIT);
+  DumpData(fp, &ioPtrs->trdTracks, &ioPtrs->nTRDTracks, InOutPointerType::TRD_TRACK);
+  DumpData(fp, &ioPtrs->trdTracklets, &ioPtrs->nTRDTracklets, InOutPointerType::TRD_TRACKLET);
+  if (ioPtrs->trdSpacePoints) {
+    DumpData(fp, &ioPtrs->trdSpacePoints, &ioPtrs->nTRDTracklets, InOutPointerType::TRD_SPACEPOINT);
   }
-  DumpData(fp, &mIOPtrs.trdTriggerTimes, &mIOPtrs.nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
-  DumpData(fp, &mIOPtrs.trdTrackletIdxFirst, &mIOPtrs.nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
-  DumpData(fp, &mIOPtrs.trdTrigRecMask, &mIOPtrs.nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
+  DumpData(fp, &ioPtrs->trdTriggerTimes, &ioPtrs->nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
+  DumpData(fp, &ioPtrs->trdTrackletIdxFirst, &ioPtrs->nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
+  DumpData(fp, &ioPtrs->trdTrigRecMask, &ioPtrs->nTRDTriggerRecords, InOutPointerType::TRD_TRIGGERRECORDS);
   fclose(fp);
 }
 
diff --git a/GPU/GPUTracking/Global/GPUErrorCodes.h b/GPU/GPUTracking/Global/GPUErrorCodes.h
index f35f5fc81a382..8fec23be00a09 100644
--- a/GPU/GPUTracking/Global/GPUErrorCodes.h
+++ b/GPU/GPUTracking/Global/GPUErrorCodes.h
@@ -47,5 +47,6 @@ GPUCA_ERROR_CODE(26, ERROR_TPCZS_INVALID_ROW, SectorRow)
 GPUCA_ERROR_CODE(27, ERROR_TPCZS_INVALID_NADC, SectorCRU, SamplesInPage, SamplesWritten)  // Invalid number of ADC samples in header, existing samples were decoded
 GPUCA_ERROR_CODE(28, ERROR_TPCZS_INCOMPLETE_HBF, SectorCRU, PacketCount, NextPacketCount) // Part of HBF is missing, decoding incomplete
 GPUCA_ERROR_CODE(29, ERROR_TPCZS_INVALID_OFFSET, SectorEndpoint, Value, Expected)         // Raw page is skipped since it contains invalid payload offset
+GPUCA_ERROR_CODE(29, MAX_GPUCA_ERROR_NUMBER)
 
 // #define GPUCA_CHECK_TPCZS_CORRUPTION
diff --git a/GPU/GPUTracking/Global/GPUErrors.cxx b/GPU/GPUTracking/Global/GPUErrors.cxx
index 7f3ed1d8206d9..e9d5a74c6567a 100644
--- a/GPU/GPUTracking/Global/GPUErrors.cxx
+++ b/GPU/GPUTracking/Global/GPUErrors.cxx
@@ -54,12 +54,17 @@ static std::unordered_map<uint32_t, const char*> errorNames = {
 #undef GPUCA_ERROR_CODE
 };
 
-void GPUErrors::printErrors(bool silent)
+bool GPUErrors::printErrors(bool silent, uint64_t mask)
 {
+  bool retVal = 0;
   for (uint32_t i = 0; i < std::min(*mErrors, GPUCA_MAX_ERRORS); i++) {
     uint32_t errorCode = mErrors[4 * i + 1];
     const auto& it = errorNames.find(errorCode);
     const char* errorName = it == errorNames.end() ? "INVALID ERROR CODE" : it->second;
+    static_assert(MAX_GPUCA_ERROR_NUMBER <= sizeof(mask) * 8);
+    if (mask & (1 << errorCode)) {
+      retVal = 1;
+    }
     if (silent && i) {
       GPUWarning("GPU Error Code (%u:%u) %s : %u / %u / %u", i, errorCode, errorName, mErrors[4 * i + 2], mErrors[4 * i + 3], mErrors[4 * i + 4]);
     } else if (silent) {
@@ -75,6 +80,7 @@ void GPUErrors::printErrors(bool silent)
       GPUError("Additional errors occured (codes not stored)");
     }
   }
+  return retVal;
 }
 
 uint32_t GPUErrors::getNErrors() const
diff --git a/GPU/GPUTracking/Global/GPUErrors.h b/GPU/GPUTracking/Global/GPUErrors.h
index cd86390bc1b01..1cbc4a019601d 100644
--- a/GPU/GPUTracking/Global/GPUErrors.h
+++ b/GPU/GPUTracking/Global/GPUErrors.h
@@ -33,7 +33,7 @@ class GPUErrors
   GPUd() bool hasError() { return *mErrors > 0; }
   void setMemory(GPUglobalref() uint32_t* m) { mErrors = m; }
   void clear();
-  void printErrors(bool silent = false);
+  bool printErrors(bool silent = false, uint64_t mask = 0);
   uint32_t getNErrors() const;
   const uint32_t* getErrorPtr() const;
   static uint32_t getMaxErrors();

From bb048efab7be5df04ad93a974abef167f4c6e88a Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 21 May 2025 19:41:52 +0200
Subject: [PATCH 0390/1764] DPL Analysis: add `clamp` expression node to
 constrain a result of an expresison between two values (#14305)

---
 Framework/Core/include/Framework/Expressions.h | 8 ++++++++
 Framework/Core/test/test_Expressions.cxx       | 7 +++++++
 2 files changed, 15 insertions(+)

diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 18c930700a91d..9d6c3cfb7c66e 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -546,6 +546,14 @@ inline Node updateParameters(Node const& pexp, int bins, std::vector<T> const& p
   return result;
 }
 
+/// clamping functional
+template <typename T>
+inline Node clamp(Node&& expr, T low, T hi)
+{
+  auto copy = expr;
+  return ifnode(Node{copy} < LiteralNode{low}, LiteralNode{low}, ifnode(Node{copy} > LiteralNode{hi}, LiteralNode{hi}, Node{copy}));
+}
+
 /// A struct, containing the root of the expression tree
 struct Filter {
   Filter() = default;
diff --git a/Framework/Core/test/test_Expressions.cxx b/Framework/Core/test/test_Expressions.cxx
index 6faa2fc352232..e8cf43e03e11d 100644
--- a/Framework/Core/test/test_Expressions.cxx
+++ b/Framework/Core/test/test_Expressions.cxx
@@ -290,6 +290,13 @@ TEST_CASE("TestConditionalExpressions")
   auto gandiva_condition2 = makeCondition(gandiva_tree2);
   auto gandiva_filter2 = createFilter(schema2, gandiva_condition2);
   REQUIRE(gandiva_tree2->ToString() == "bool greater_than((float) fSigned1Pt, (const float) 0 raw(0)) && if (bool less_than(float absf((float) fEta), (const float) 1 raw(3f800000)) && if (bool less_than((float) fPt, (const float) 1 raw(3f800000))) { bool greater_than((float) fPhi, (const float) 1.5708 raw(3fc90fdb)) } else { bool less_than((float) fPhi, (const float) 1.5708 raw(3fc90fdb)) }) { bool greater_than(float absf((float) fX), (const float) 1 raw(3f800000)) } else { bool greater_than(float absf((float) fY), (const float) 1 raw(3f800000)) }");
+
+  // clamp
+  Projector clp = clamp(o2::aod::track::pt, 1.0f, 10.f);
+  auto clpspecs = createOperations(clp);
+  auto schemaclp = std::make_shared<arrow::Schema>(std::vector{o2::aod::track::Pt::asArrowField()});
+  auto gandiva_tree_clp = createExpressionTree(clpspecs, schemaclp);
+  REQUIRE(gandiva_tree_clp->ToString() == "if (bool less_than((float) fPt, (const float) 1 raw(3f800000))) { (const float) 1 raw(3f800000) } else { if (bool greater_than((float) fPt, (const float) 10 raw(41200000))) { (const float) 10 raw(41200000) } else { (float) fPt } }");
 }
 
 TEST_CASE("TestBinnedExpressions")

From 35ca22b3bde5014b40ebe1d823c6dc88a313ddbf Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 21 May 2025 19:54:16 +0200
Subject: [PATCH 0391/1764] DPL: fix merging of pipelined devices (#14307)

Sometimes we are just too smart. Multiple messages with the same
signature are coalesced in the same input if they are processed at the
same time. This explains why the sleep was improving behavior: it merely
staggers arrival, so that the optimisation cannot happen anymore.
---
 .../AnalysisSupport/src/AODWriterHelpers.cxx  | 254 +++++++++---------
 1 file changed, 129 insertions(+), 125 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index 2b1b4f880d1ee..40d2189ea96d0 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -269,145 +269,149 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 
     callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
     return [inputObjects, objmap, tskmap](ProcessingContext& pc) mutable -> void {
-      auto const& ref = pc.inputs().get("x");
-      if (!ref.header) {
-        LOG(error) << "Header not found";
-        return;
-      }
-      auto datah = o2::header::get<o2::header::DataHeader*>(ref.header);
-      if (!datah) {
-        LOG(error) << "No data header in stack";
-        return;
-      }
+      auto mergePart = [&inputObjects, &objmap, &tskmap](DataRef const& ref) {
+        if (!ref.header) {
+          LOG(error) << "Header not found";
+          return;
+        }
+        auto datah = o2::header::get<o2::header::DataHeader*>(ref.header);
+        if (!datah) {
+          LOG(error) << "No data header in stack";
+          return;
+        }
 
-      if (!ref.payload) {
-        LOGP(error, "Payload not found for {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
-        return;
-      }
+        if (!ref.payload) {
+          LOGP(error, "Payload not found for {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
+          return;
+        }
 
-      auto objh = o2::header::get<o2::framework::OutputObjHeader*>(ref.header);
-      if (!objh) {
-        LOGP(error, "No output object header in stack of {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
-        return;
-      }
+        auto objh = o2::header::get<o2::framework::OutputObjHeader*>(ref.header);
+        if (!objh) {
+          LOGP(error, "No output object header in stack of {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
+          return;
+        }
 
-      InputObject obj;
-      FairInputTBuffer tm(const_cast<char*>(ref.payload), static_cast<int>(datah->payloadSize));
-      tm.InitMap();
-      obj.kind = tm.ReadClass();
-      tm.SetBufferOffset(0);
-      tm.ResetMap();
-      if (obj.kind == nullptr) {
-        LOGP(error, "Cannot read class info from buffer of {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
-        return;
-      }
+        InputObject obj;
+        FairInputTBuffer tm(const_cast<char*>(ref.payload), static_cast<int>(datah->payloadSize));
+        tm.InitMap();
+        obj.kind = tm.ReadClass();
+        tm.SetBufferOffset(0);
+        tm.ResetMap();
+        if (obj.kind == nullptr) {
+          LOGP(error, "Cannot read class info from buffer of {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
+          return;
+        }
 
-      auto policy = objh->mPolicy;
-      auto sourceType = objh->mSourceType;
-      auto hash = objh->mTaskHash;
+        auto policy = objh->mPolicy;
+        auto sourceType = objh->mSourceType;
+        auto hash = objh->mTaskHash;
 
-      obj.obj = tm.ReadObjectAny(obj.kind);
-      auto* named = static_cast<TNamed*>(obj.obj);
-      obj.name = named->GetName();
-      auto hpos = std::find_if(tskmap.begin(), tskmap.end(), [&](auto&& x) { return x.id == hash; });
-      if (hpos == tskmap.end()) {
-        LOG(error) << "No task found for hash " << hash;
-        return;
-      }
-      auto taskname = hpos->name;
-      auto opos = std::find_if(objmap.begin(), objmap.end(), [&](auto&& x) { return x.id == hash; });
-      if (opos == objmap.end()) {
-        LOG(error) << "No object list found for task " << taskname << " (hash=" << hash << ")";
-        return;
-      }
-      auto objects = opos->bindings;
-      if (std::find(objects.begin(), objects.end(), obj.name) == objects.end()) {
-        LOG(error) << "No object " << obj.name << " in map for task " << taskname;
-        return;
-      }
-      auto nameHash = runtime_hash(obj.name.c_str());
-      InputObjectRoute key{obj.name, nameHash, taskname, hash, policy, sourceType};
-      auto existing = std::find_if(inputObjects->begin(), inputObjects->end(), [&](auto&& x) { return (x.first.uniqueId == nameHash) && (x.first.taskHash == hash); });
-      // If it's the first one, we just add it to the list.
-      if (existing == inputObjects->end()) {
-        obj.count = objh->mPipelineSize;
-        inputObjects->push_back(std::make_pair(key, obj));
-        existing = inputObjects->end() - 1;
-      } else {
-        obj.count = existing->second.count;
-        // Otherwise, we merge it with the existing one.
-        auto merger = existing->second.kind->GetMerge();
-        if (!merger) {
-          LOG(error) << "Already one unmergeable object found for " << obj.name;
+        obj.obj = tm.ReadObjectAny(obj.kind);
+        auto* named = static_cast<TNamed*>(obj.obj);
+        obj.name = named->GetName();
+        auto hpos = std::find_if(tskmap.begin(), tskmap.end(), [&](auto&& x) { return x.id == hash; });
+        if (hpos == tskmap.end()) {
+          LOG(error) << "No task found for hash " << hash;
           return;
         }
-        TList coll;
-        coll.Add(static_cast<TObject*>(obj.obj));
-        merger(existing->second.obj, &coll, nullptr);
-      }
-      // We expect as many objects as the pipeline size, for
-      // a given object name and task hash.
-      existing->second.count -= 1;
-
-      if (existing->second.count != 0) {
-        return;
-      }
-      // Write the object here.
-      auto route = existing->first;
-      auto entry = existing->second;
-      auto file = ROOTfileNames.find(route.policy);
-      if (file == ROOTfileNames.end()) {
-        return;
-      }
-      auto filename = file->second;
-      if (f[route.policy] == nullptr) {
-        f[route.policy] = TFile::Open(filename.c_str(), "RECREATE");
-      }
-      auto nextDirectory = route.directory;
-      if ((nextDirectory != currentDirectory) || (filename != currentFile)) {
-        if (!f[route.policy]->FindKey(nextDirectory.c_str())) {
-          f[route.policy]->mkdir(nextDirectory.c_str());
+        auto taskname = hpos->name;
+        auto opos = std::find_if(objmap.begin(), objmap.end(), [&](auto&& x) { return x.id == hash; });
+        if (opos == objmap.end()) {
+          LOG(error) << "No object list found for task " << taskname << " (hash=" << hash << ")";
+          return;
         }
-        currentDirectory = nextDirectory;
-        currentFile = filename;
-      }
+        auto objects = opos->bindings;
+        if (std::find(objects.begin(), objects.end(), obj.name) == objects.end()) {
+          LOG(error) << "No object " << obj.name << " in map for task " << taskname;
+          return;
+        }
+        auto nameHash = runtime_hash(obj.name.c_str());
+        InputObjectRoute key{obj.name, nameHash, taskname, hash, policy, sourceType};
+        auto existing = std::find_if(inputObjects->begin(), inputObjects->end(), [&](auto&& x) { return (x.first.uniqueId == nameHash) && (x.first.taskHash == hash); });
+        // If it's the first one, we just add it to the list.
+        if (existing == inputObjects->end()) {
+          obj.count = objh->mPipelineSize;
+          inputObjects->push_back(std::make_pair(key, obj));
+          existing = inputObjects->end() - 1;
+        } else {
+          obj.count = existing->second.count;
+          // Otherwise, we merge it with the existing one.
+          auto merger = existing->second.kind->GetMerge();
+          if (!merger) {
+            LOG(error) << "Already one unmergeable object found for " << obj.name;
+            return;
+          }
+          TList coll;
+          coll.Add(static_cast<TObject*>(obj.obj));
+          merger(existing->second.obj, &coll, nullptr);
+        }
+        // We expect as many objects as the pipeline size, for
+        // a given object name and task hash.
+        existing->second.count -= 1;
 
-      // translate the list-structure created by the registry into a directory structure within the file
-      std::function<void(TList*, TDirectory*)> writeListToFile;
-      writeListToFile = [&](TList* list, TDirectory* parentDir) {
-        TIter next(list);
-        TObject* object = nullptr;
-        while ((object = next())) {
-          if (object->InheritsFrom(TList::Class())) {
-            writeListToFile(static_cast<TList*>(object), parentDir->mkdir(object->GetName(), object->GetName(), true));
-          } else {
-            parentDir->WriteObjectAny(object, object->Class(), object->GetName());
-            auto* written = list->Remove(object);
-            delete written;
+        if (existing->second.count != 0) {
+          return;
+        }
+        // Write the object here.
+        auto route = existing->first;
+        auto entry = existing->second;
+        auto file = ROOTfileNames.find(route.policy);
+        if (file == ROOTfileNames.end()) {
+          return;
+        }
+        auto filename = file->second;
+        if (f[route.policy] == nullptr) {
+          f[route.policy] = TFile::Open(filename.c_str(), "RECREATE");
+        }
+        auto nextDirectory = route.directory;
+        if ((nextDirectory != currentDirectory) || (filename != currentFile)) {
+          if (!f[route.policy]->FindKey(nextDirectory.c_str())) {
+            f[route.policy]->mkdir(nextDirectory.c_str());
           }
+          currentDirectory = nextDirectory;
+          currentFile = filename;
         }
-      };
 
-      TDirectory* currentDir = f[route.policy]->GetDirectory(currentDirectory.c_str());
-      if (route.sourceType == OutputObjSourceType::HistogramRegistrySource) {
-        auto* outputList = static_cast<TList*>(entry.obj);
-        outputList->SetOwner(false);
+        // translate the list-structure created by the registry into a directory structure within the file
+        std::function<void(TList*, TDirectory*)> writeListToFile;
+        writeListToFile = [&](TList* list, TDirectory* parentDir) {
+          TIter next(list);
+          TObject* object = nullptr;
+          while ((object = next())) {
+            if (object->InheritsFrom(TList::Class())) {
+              writeListToFile(static_cast<TList*>(object), parentDir->mkdir(object->GetName(), object->GetName(), true));
+            } else {
+              parentDir->WriteObjectAny(object, object->Class(), object->GetName());
+              auto* written = list->Remove(object);
+              delete written;
+            }
+          }
+        };
+
+        TDirectory* currentDir = f[route.policy]->GetDirectory(currentDirectory.c_str());
+        if (route.sourceType == OutputObjSourceType::HistogramRegistrySource) {
+          auto* outputList = static_cast<TList*>(entry.obj);
+          outputList->SetOwner(false);
+
+          // if registry should live in dedicated folder a TNamed object is appended to the list
+          if (outputList->Last() && outputList->Last()->IsA() == TNamed::Class()) {
+            delete outputList->Last();
+            outputList->RemoveLast();
+            currentDir = currentDir->mkdir(outputList->GetName(), outputList->GetName(), true);
+          }
 
-        // if registry should live in dedicated folder a TNamed object is appended to the list
-        if (outputList->Last() && outputList->Last()->IsA() == TNamed::Class()) {
-          delete outputList->Last();
-          outputList->RemoveLast();
-          currentDir = currentDir->mkdir(outputList->GetName(), outputList->GetName(), true);
+          writeListToFile(outputList, currentDir);
+          outputList->SetOwner();
+          delete outputList;
+          entry.obj = nullptr;
+        } else {
+          currentDir->WriteObjectAny(entry.obj, entry.kind, entry.name.c_str());
+          delete (TObject*)entry.obj;
+          entry.obj = nullptr;
         }
-
-        writeListToFile(outputList, currentDir);
-        outputList->SetOwner();
-        delete outputList;
-        entry.obj = nullptr;
-      } else {
-        currentDir->WriteObjectAny(entry.obj, entry.kind, entry.name.c_str());
-        delete (TObject*)entry.obj;
-        entry.obj = nullptr;
+      };
+      for (int pi = 0; pi < pc.inputs().getNofParts(0); ++pi) {
+        mergePart(pc.inputs().get("x", pi));
       }
     };
   }};

From 0386f65567a1fcda173c9ae39304bbd284677774 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 19 May 2025 10:49:44 +0200
Subject: [PATCH 0392/1764] Revert "GPU Common: Workaround for removing
 gpustd::array, temporary alias for O2Physics"

This reverts commit a850e9eb3e6a634a1e87a70170c05ad6d8bce3af.
---
 .../ReconstructionDataFormats/TrackParametrization.h        | 1 -
 GPU/Common/GPUCommonArray.h                                 | 6 ------
 2 files changed, 7 deletions(-)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index 1d0a5f1a9f1fd..f240e34861eeb 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -29,7 +29,6 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonRtypes.h"
 #include "GPUCommonMath.h"
-#include "GPUCommonArray.h"
 #include "GPUROOTCartesianFwd.h"
 
 #ifndef GPUCA_GPUCODE_DEVICE
diff --git a/GPU/Common/GPUCommonArray.h b/GPU/Common/GPUCommonArray.h
index fa86d7bb4a021..e83ca8c4a69fc 100644
--- a/GPU/Common/GPUCommonArray.h
+++ b/GPU/Common/GPUCommonArray.h
@@ -48,10 +48,4 @@ using array = std::array<T, N>;
 } // namespace std
 #endif
 
-namespace o2::gpu::gpustd
-{
-template <class T, size_t I>
-using array = ::std::array<T, I>; // temporary alias, to remove dependent types
-} // o2::gpu::gpustd
-
 #endif // GPUCOMMONARRAY_H

From efff2f780c2b35603cdd6614f868100e94ba41e7 Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Wed, 21 May 2025 23:04:18 +0200
Subject: [PATCH 0393/1764] Add TPC cluster selector helper for tracking
 studies (#14308)

---
 .../study/CMakeLists.txt                      |   7 ++
 .../GlobalTrackingStudy/TPCClusSelector.h     |  92 ++++++++++++++
 .../study/src/GlobalTrackingStudyLinkDef.h    |   1 +
 .../study/src/TPCClusSelector.cxx             | 117 ++++++++++++++++++
 4 files changed, 217 insertions(+)
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCClusSelector.h
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/src/TPCClusSelector.cxx

diff --git a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
index 398e7eb215f2e..776d3946283c3 100644
--- a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
+++ b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
@@ -12,6 +12,7 @@
 #add_compile_options(-O0 -g -fPIC)
 
 o2_add_library(GlobalTrackingStudy
+               TARGETVARNAME targetName
                SOURCES src/TPCTrackStudy.cxx
                        src/TrackingStudy.cxx
                        src/SVStudy.cxx
@@ -23,6 +24,7 @@ o2_add_library(GlobalTrackingStudy
                        src/TrackInfoExt.cxx
                        src/TrackMCStudyConfig.cxx
                        src/TrackMCStudyTypes.cxx
+                       src/TPCClusSelector.cxx
                PUBLIC_LINK_LIBRARIES O2::GlobalTracking
                                      O2::GlobalTrackingWorkflowReaders
                                      O2::GlobalTrackingWorkflowHelpers
@@ -73,3 +75,8 @@ o2_add_executable(dump-workfow
                   COMPONENT_NAME bc-tracks
                   SOURCES src/track-dump-workflow.cxx
                   PUBLIC_LINK_LIBRARIES O2::GlobalTrackingStudy)
+
+if (OpenMP_CXX_FOUND)
+    target_compile_definitions(${targetName} PRIVATE WITH_OPENMP)
+    target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX)
+endif()
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCClusSelector.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCClusSelector.h
new file mode 100644
index 0000000000000..c1765558458c2
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCClusSelector.h
@@ -0,0 +1,92 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// helper class for TPC clusters selection
+
+#ifndef ALICEO2_TPCCLUSSELECTOR_H
+#define ALICEO2_TPCCLUSSELECTOR_H
+
+#include <vector>
+#include <array>
+#include <Rtypes.h>
+
+namespace o2::tpc
+{
+class ClusterNativeAccess;
+
+class TPCClusSelector
+{
+  // helper to select TPC cluster matching to certain timebin and optionally pads range
+  // example of usage:
+  /*
+    TPCClusSelector clSel;
+    o2::tpc::ClusterNativeHelper::Reader tcpClusterReader;
+    tcpClusterReader.init(native_clusters_file.c_str());
+    o2::tpc::ClusterNativeAccess tpcClusterIdxStruct;
+    std::unique_ptr<o2::tpc::ClusterNative[]> tpcClusterBuffer;       ///< buffer for clusters in tpcClusterIdxStruct
+    o2::tpc::ClusterNativeHelper::ConstMCLabelContainerViewWithBuffer tpcClusterMCBuffer;  ///< buffer for mc labels
+
+    tcpClusterReader.read(iTF);
+    tcpClusterReader.fillIndex(tpcClusterIdxStruct, tpcClusterBuffer, tpcClusterMCBuffer);
+
+    clSel.fill(tpcClusterIdxStruct); // Create sorted index
+    // to get i-th cluster in orderer timebins:
+    const auto& clus = tpcClusterIdxStruct.clusters[sector][row][  clSel.getIndex(sector, row, i)];
+
+    // to get sorted indices range of clusters in the tbmin:tbmax range
+    auto rng = clSel.findClustersRange(sector, row, tbmin, tbmax, tpcClusterIdxStruct);
+    if (rng.first>rng.second) { // nothing is found }
+    const auto& cln = tpcClusterIdxStruct.clusters[sector][row][clSel.getIndex(sector, row, rng.first )]; /...
+
+    // to get number of clusters in tbmin:tbmax, padmin:padmax range (and optionally get the list)
+    std::vector<int> cllist; // optional list
+    int nfnd = clSel.findClustersEntries(sector, row, tbmin, tbmax, padmin, padmax, tpcClusterIdxStruct, &cllist);
+    for (int i=0;i<nfnd;i++) {
+      const auto& cln = tpcClusterIdxStruct.clusters[sector][row][cllist[i]]; /...  direct indices!
+    }
+   */
+
+ public:
+  void clear()
+  {
+    for (auto& s : mSectors)
+      s.clear();
+  }
+  size_t getIndex(int sec, int row, uint32_t icl) const { return mSectors[sec].rows[row][icl]; }
+
+  std::pair<int, int> findClustersRange(int sec, int row, float tbmin, float tbmax, const o2::tpc::ClusterNativeAccess& tpcClusterIdxStruct);
+  int findClustersEntries(int sec, int row, float tbmin, float tbmax, float padmin, float padmax, const o2::tpc::ClusterNativeAccess& tpcClusterIdxStruct, std::vector<int>* clIDDirect = nullptr);
+  void fill(const o2::tpc::ClusterNativeAccess& tpcClusterIdxStruct);
+
+  int getNThreads() const { return mNThreads; }
+  void setNThreads(int n);
+
+ private:
+  struct Sector {
+    static constexpr int NRows = 152;
+    std::array<std::vector<uint16_t>, NRows> rows;
+    void clear()
+    {
+      for (auto& r : rows)
+        r.clear();
+    }
+  };
+
+  static constexpr int NSectors = 36;
+  std::array<Sector, NSectors> mSectors{};
+  int mNThreads = 1;
+
+  ClassDefNV(TPCClusSelector, 1);
+};
+
+} // namespace o2::tpc
+
+#endif
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h b/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
index f666132c9c1cf..f0d3e7d4d0b4e 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
+++ b/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
@@ -38,5 +38,6 @@
 #pragma link C++ class std::vector < o2::trackstudy::ClResTPCCont> + ;
 #pragma link C++ class o2::trackstudy::TrackPairInfo + ;
 #pragma link C++ class std::vector < o2::trackstudy::TrackPairInfo> + ;
+#pragma ling C++ class o2::tpc::TPCClusSelector + ;
 
 #endif
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TPCClusSelector.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TPCClusSelector.cxx
new file mode 100644
index 0000000000000..e5b28fb0fd62b
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TPCClusSelector.cxx
@@ -0,0 +1,117 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// helper class for TPC clusters selection
+#include "GlobalTrackingStudy/TPCClusSelector.h"
+#include "DataFormatsTPC/ClusterNativeHelper.h"
+#include "Framework/Logger.h"
+#include <numeric>
+#ifdef WITH_OPENMP
+#include <omp.h>
+#endif
+
+using namespace o2::tpc;
+
+void TPCClusSelector::setNThreads(int n)
+{
+#ifndef WITH_OPENMP
+  if (n > 1) {
+    LOGP(warn, "No OpenMP");
+  }
+  n = 1;
+#endif
+  mNThreads = n;
+}
+
+std::pair<int, int> TPCClusSelector::findClustersRange(int sec, int row, float tbmin, float tbmax, const o2::tpc::ClusterNativeAccess& tpcClusterIdxStruct)
+{
+  // find sorted indices of clusters in the [tbmin:tbmax] range, if not found, return {-1,-2}
+  const auto& vidx = mSectors[sec].rows[row];
+  const auto* clarr = tpcClusterIdxStruct.clusters[sec][row];
+  // use binary search to find 1st cluster with time >= tb
+  int ncl = vidx.size(), left = 0, right = ncl;
+  while (left < right) {
+    int mid = left + (right - left) / 2;
+    if (clarr[vidx[mid]].getTime() < tbmin) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+  if (left == ncl || clarr[vidx[left]].getTime() > tbmax) {
+    return {-1, -2}; // all clusters have time < tbmin or no clusters in the range [tbmin:tbmax]
+  }
+  int idmin = left, idmax = left, idtst = idmin;
+  // look at smaller times
+  while (++idtst < ncl && clarr[vidx[idtst]].getTime() <= tbmax) {
+    idmax = idtst;
+  }
+  return {idmin, idmax};
+}
+
+int TPCClusSelector::findClustersEntries(int sec, int row, float tbmin, float tbmax, float padmin, float padmax, const o2::tpc::ClusterNativeAccess& tpcClusterIdxStruct, std::vector<int>* clIDDirect)
+{
+  // find direct cluster indices for tbmin:tbmas / padmin/padmax range, fill clIDDirect vector if provided
+  const auto& vidx = mSectors[sec].rows[row];
+  const auto* clarr = tpcClusterIdxStruct.clusters[sec][row];
+  // use binary search to find 1st cluster with time >= tb
+  int ncl = vidx.size(), left = 0, right = ncl;
+  if (clIDDirect) {
+    clIDDirect->clear();
+  }
+  while (left < right) {
+    int mid = left + (right - left) / 2;
+    if (clarr[vidx[mid]].getTime() < tbmin) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+  if (left == ncl || clarr[vidx[left]].getTime() > tbmax) {
+    return 0; // all clusters have time < tbmin or no clusters in the range [tbmin:tbmax]
+  }
+  int nclf = 0;
+  while (left < ncl) {
+    const auto& cl = clarr[vidx[left]];
+    if (cl.getTime() > tbmax) {
+      break;
+    }
+    if (cl.getPad() >= padmin && cl.getPad() <= padmax) {
+      nclf++;
+      if (clIDDirect) {
+        clIDDirect->push_back(vidx[left]);
+      }
+    }
+  }
+  return nclf;
+}
+
+void TPCClusSelector::fill(const o2::tpc::ClusterNativeAccess& tpcClusterIdxStruct)
+{
+  for (int is = 0; is < NSectors; is++) {
+    auto& sect = mSectors[is];
+#ifdef WITH_OPENMP
+#pragma omp parallel for schedule(dynamic) num_threads(mNThreads)
+#endif
+    for (int ir = 0; ir < Sector::NRows; ir++) {
+      size_t ncl = tpcClusterIdxStruct.nClusters[is][ir];
+      if (ncl >= 0xffff) {
+        LOGP(error, "Row {} of sector {} has {} clusters, truncating to {}", ir, is, ncl, int(0xffff));
+        ncl = 0xffff;
+      }
+      auto& rowidx = sect.rows[ir];
+      rowidx.resize(ncl);
+      std::iota(rowidx.begin(), rowidx.end(), 0);
+      const auto* clus = tpcClusterIdxStruct.clusters[is][ir]; // C array of clusters
+      std::sort(rowidx.begin(), rowidx.end(), [&](size_t a, size_t b) { return clus[a].getTime() < clus[b].getTime(); });
+    }
+  }
+}

From 81b7a64680531129657f5a9eb2a222b3d0c779c1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 21 May 2025 19:06:16 +0200
Subject: [PATCH 0394/1764] GPU: Fix allocator / deallocator mismatch

---
 GPU/GPUTracking/Base/GPUReconstruction.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index e0c866fd9421b..06f1c27fb6c06 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -378,7 +378,7 @@ class GPUReconstruction
     std::vector<uint16_t> res;
   };
   struct alignedDeleter {
-    void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)); };
+    void operator()(void* ptr) { ::operator delete[](ptr, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)); };
   };
   std::unordered_map<GPUMemoryReuse::ID, MemoryReuseMeta> mMemoryReuse1to1;
   std::vector<std::tuple<void*, void*, size_t, size_t, uint64_t>> mNonPersistentMemoryStack; // hostPoolAddress, devicePoolAddress, individualAllocationCount, directIndividualAllocationCound, tag

From b8cacf6b25dbb22b30160821d70992cfac594f8b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 21 May 2025 19:16:30 +0200
Subject: [PATCH 0395/1764] GPU TPC Merger: Clarify more variable names

---
 .../DataCompression/GPUTPCCompression.cxx     |  2 +-
 .../GPUChainTrackingDebugAndProfiling.cxx     |  4 +-
 .../Global/GPUChainTrackingMerger.cxx         | 10 ++---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 40 +++++++++----------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  8 ++--
 GPU/GPUTracking/SectorTracker/GPUTPCTrack.h   |  3 --
 6 files changed, 32 insertions(+), 35 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index ec1636dfe7f59..61f8a614fbe6f 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -124,7 +124,7 @@ void GPUTPCCompression::SetMaxData(const GPUTrackingInOutPointers& io)
   mMaxClusters = io.clustersNative->nClustersTotal;
   mMaxClusterFactorBase1024 = mMaxClusters > 100000000 ? mRec->MemoryScalers()->NTPCUnattachedHitsBase1024(mRec->GetParam().rec.tpc.rejectionStrategy) : 1024;
   mMaxClustersInCache = mMaxClusters * mMaxClusterFactorBase1024 / 1024;
-  mMaxTrackClusters = mRec->GetConstantMem().tpcMerger.NOutputTrackClusters(); // TODO: Why is this not using ioPtrs? Could remove GPUConstantMem.h include
+  mMaxTrackClusters = mRec->GetConstantMem().tpcMerger.NMergedTrackClusters(); // TODO: Why is this not using ioPtrs? Could remove GPUConstantMem.h include
   mMaxTracks = mRec->GetConstantMem().tpcMerger.NMergedTracks();
   if (mMaxClusters % 16) {
     mMaxClusters += 16 - (mMaxClusters % 16);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index e9721ec9d12bf..173d2fb916239 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -154,7 +154,7 @@ void GPUChainTracking::PrintMemoryStatistics()
   }
   addToMap("TPC Clusterer Clusters", usageMap, mRec->MemoryScalers()->nTPCHits, mRec->MemoryScalers()->NTPCClusters(mRec->MemoryScalers()->nTPCdigits));
   addToMap("TPC Tracks", usageMap, processors()->tpcMerger.NMergedTracks(), processors()->tpcMerger.NMaxTracks());
-  addToMap("TPC TrackHits", usageMap, processors()->tpcMerger.NOutputTrackClusters(), processors()->tpcMerger.NMaxOutputTrackClusters());
+  addToMap("TPC TrackHits", usageMap, processors()->tpcMerger.NMergedTrackClusters(), processors()->tpcMerger.NMaxMergedTrackClusters());
 
   if (mRec->GetProcessingSettings().createO2Output) {
     addToMap("TPC O2 Tracks", usageMap, processors()->tpcMerger.NOutputTracksTPCO2(), processors()->tpcMerger.NOutputTracksTPCO2());
@@ -182,7 +182,7 @@ void GPUChainTracking::PrintMemoryRelations()
     GPUInfo("MEMREL SectorTrackHits NCl %d NTrkH %d", processors()->tpcTrackers[i].NHitsTotal(), *processors()->tpcTrackers[i].NTrackHits());
   }
   GPUInfo("MEMREL Tracks NCl %d NTrk %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NMergedTracks());
-  GPUInfo("MEMREL TrackHitss NCl %d NTrkH %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NOutputTrackClusters());
+  GPUInfo("MEMREL TrackHitss NCl %d NTrkH %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NMergedTrackClusters());
 }
 
 void GPUChainTracking::PrepareKernelDebugOutput()
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 2b3d719a27dea..118f0bf73a845 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -261,9 +261,9 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
       if (param().dodEdxEnabled) {
         GPUMemCpy(RecoStep::TPCMerging, Merger.MergedTracksdEdx(), MergerShadowAll.MergedTracksdEdx(), Merger.NMergedTracks() * sizeof(*Merger.MergedTracksdEdx()), outputStream, 0);
       }
-      GPUMemCpy(RecoStep::TPCMerging, Merger.Clusters(), MergerShadowAll.Clusters(), Merger.NOutputTrackClusters() * sizeof(*Merger.Clusters()), outputStream, 0);
+      GPUMemCpy(RecoStep::TPCMerging, Merger.Clusters(), MergerShadowAll.Clusters(), Merger.NMergedTrackClusters() * sizeof(*Merger.Clusters()), outputStream, 0);
       if (param().par.earlyTpcTransform) {
-        GPUMemCpy(RecoStep::TPCMerging, Merger.ClustersXYZ(), MergerShadowAll.ClustersXYZ(), Merger.NOutputTrackClusters() * sizeof(*Merger.ClustersXYZ()), outputStream, 0);
+        GPUMemCpy(RecoStep::TPCMerging, Merger.ClustersXYZ(), MergerShadowAll.ClustersXYZ(), Merger.NMergedTrackClusters() * sizeof(*Merger.ClustersXYZ()), outputStream, 0);
       }
       GPUMemCpy(RecoStep::TPCMerging, Merger.ClusterAttachment(), MergerShadowAll.ClusterAttachment(), Merger.NMaxClusters() * sizeof(*Merger.ClusterAttachment()), outputStream, 0);
     }
@@ -330,7 +330,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   mIOPtrs.nMergedTracks = Merger.NMergedTracks();
   mIOPtrs.mergedTrackHits = Merger.Clusters();
   mIOPtrs.mergedTrackHitsXYZ = Merger.ClustersXYZ();
-  mIOPtrs.nMergedTrackHits = Merger.NOutputTrackClusters();
+  mIOPtrs.nMergedTrackHits = Merger.NMergedTrackClusters();
   mIOPtrs.mergedTrackHitAttachment = Merger.ClusterAttachment();
   mIOPtrs.mergedTrackHitStates = Merger.ClusterStateExt();
   mIOPtrs.outputTracksTPCO2 = Merger.OutputTracksTPCO2();
@@ -344,7 +344,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     processorsShadow()->ioPtrs.nMergedTracks = Merger.NMergedTracks();
     processorsShadow()->ioPtrs.mergedTrackHits = MergerShadow.Clusters();
     processorsShadow()->ioPtrs.mergedTrackHitsXYZ = MergerShadow.ClustersXYZ();
-    processorsShadow()->ioPtrs.nMergedTrackHits = Merger.NOutputTrackClusters();
+    processorsShadow()->ioPtrs.nMergedTrackHits = Merger.NMergedTrackClusters();
     processorsShadow()->ioPtrs.mergedTrackHitAttachment = MergerShadow.ClusterAttachment();
     processorsShadow()->ioPtrs.mergedTrackHitStates = MergerShadow.ClusterStateExt();
     processorsShadow()->ioPtrs.outputTracksTPCO2 = MergerShadow.OutputTracksTPCO2();
@@ -355,7 +355,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   }
 
   if (GetProcessingSettings().debugLevel >= 2) {
-    GPUInfo("TPC Merger Finished (output clusters %d / input clusters %d)", Merger.NOutputTrackClusters(), Merger.NClusters());
+    GPUInfo("TPC Merger Finished (output clusters %d / input clusters %d)", Merger.NMergedTrackClusters(), Merger.NClusters());
   }
   return 0;
 }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 1d5a7a0b1df47..16182464c12fe 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -372,9 +372,9 @@ void* GPUTPCGMMerger::SetPointersOutput(void* mem)
       computePointerWithAlignment(mem, mMergedTracksdEdxAlt, mNMaxTracks);
     }
   }
-  computePointerWithAlignment(mem, mClusters, mNMaxOutputTrackClusters);
+  computePointerWithAlignment(mem, mClusters, mNMaxMergedTrackClusters);
   if (mRec->GetParam().par.earlyTpcTransform) {
-    computePointerWithAlignment(mem, mClustersXYZ, mNMaxOutputTrackClusters);
+    computePointerWithAlignment(mem, mClustersXYZ, mNMaxMergedTrackClusters);
   }
   computePointerWithAlignment(mem, mClusterAttachment, mNMaxClusters);
   return mem;
@@ -446,7 +446,7 @@ void GPUTPCGMMerger::SetMaxData(const GPUTrackingInOutPointers& io)
       mNMaxSingleSectorTracks = ntrk;
     }
   }
-  mNMaxOutputTrackClusters = mRec->MemoryScalers()->NTPCMergedTrackHits(mNClusters);
+  mNMaxMergedTrackClusters = mRec->MemoryScalers()->NTPCMergedTrackHits(mNClusters);
   if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (gpu_common_constants::kZeroFieldCut * gpu_common_constants::kCLight)) {
     mNMaxTracks = mRec->MemoryScalers()->getValue(mNTotalSectorTracks, mNTotalSectorTracks); // 0 magnetic field
   } else {
@@ -1354,14 +1354,14 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
         continue;
       }
 
-      uint32_t newRef = CAMath::AtomicAdd(&mMemory->nOutputTrackClusters, trk[0]->NClusters() + trk[1]->NClusters());
-      if (newRef + trk[0]->NClusters() + trk[1]->NClusters() >= mNMaxOutputTrackClusters) {
-        raiseError(GPUErrors::ERROR_MERGER_CE_HIT_OVERFLOW, newRef + trk[0]->NClusters() + trk[1]->NClusters(), mNMaxOutputTrackClusters);
-        for (uint32_t k = newRef; k < mNMaxOutputTrackClusters; k++) {
+      uint32_t newRef = CAMath::AtomicAdd(&mMemory->nMergedTrackClusters, trk[0]->NClusters() + trk[1]->NClusters());
+      if (newRef + trk[0]->NClusters() + trk[1]->NClusters() >= mNMaxMergedTrackClusters) {
+        raiseError(GPUErrors::ERROR_MERGER_CE_HIT_OVERFLOW, newRef + trk[0]->NClusters() + trk[1]->NClusters(), mNMaxMergedTrackClusters);
+        for (uint32_t k = newRef; k < mNMaxMergedTrackClusters; k++) {
           mClusters[k].num = 0;
           mClusters[k].state = 0;
         }
-        CAMath::AtomicExch(&mMemory->nOutputTrackClusters, mNMaxOutputTrackClusters);
+        CAMath::AtomicExch(&mMemory->nMergedTrackClusters, mNMaxMergedTrackClusters);
         return;
       }
 
@@ -1711,20 +1711,20 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       nHits = nFilteredHits;
     }
 
-    const uint32_t iOutTrackFirstCluster = CAMath::AtomicAdd(&mMemory->nOutputTrackClusters, (uint32_t)nHits);
-    if (iOutTrackFirstCluster >= mNMaxOutputTrackClusters) {
-      raiseError(GPUErrors::ERROR_MERGER_HIT_OVERFLOW, iOutTrackFirstCluster, mNMaxOutputTrackClusters);
-      CAMath::AtomicExch(&mMemory->nOutputTrackClusters, mNMaxOutputTrackClusters);
+    const uint32_t iMergedTrackFirstCluster = CAMath::AtomicAdd(&mMemory->nMergedTrackClusters, (uint32_t)nHits);
+    if (iMergedTrackFirstCluster >= mNMaxMergedTrackClusters) {
+      raiseError(GPUErrors::ERROR_MERGER_HIT_OVERFLOW, iMergedTrackFirstCluster, mNMaxMergedTrackClusters);
+      CAMath::AtomicExch(&mMemory->nMergedTrackClusters, mNMaxMergedTrackClusters);
       continue;
     }
 
-    GPUTPCGMMergedTrackHit* const cl = mClusters + iOutTrackFirstCluster;
+    GPUTPCGMMergedTrackHit* const cl = mClusters + iMergedTrackFirstCluster;
 
     for (int32_t i = 0; i < nHits; i++) {
       uint8_t state;
       if (Param().par.earlyTpcTransform) {
         const GPUTPCClusterData& c = GetConstantMem()->tpcTrackers[trackClusters[i].sector].ClusterData()[trackClusters[i].id - GetConstantMem()->tpcTrackers[trackClusters[i].sector].Data().ClusterIdOffset()];
-        GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iOutTrackFirstCluster;
+        GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iMergedTrackFirstCluster;
         clXYZ[i].x = c.x;
         clXYZ[i].y = c.y;
         clXYZ[i].z = c.z;
@@ -1759,13 +1759,13 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     mergedTrack.SetLooper(leg > 0);
     mergedTrack.SetLegs(leg);
     mergedTrack.SetNClusters(nHits);
-    mergedTrack.SetFirstClusterRef(iOutTrackFirstCluster);
+    mergedTrack.SetFirstClusterRef(iMergedTrackFirstCluster);
     GPUTPCGMTrackParam& p1 = mergedTrack.Param();
     const GPUTPCGMSectorTrack& p2 = *trackParts[firstTrackIndex];
     mergedTrack.SetCSide(p2.CSide());
 
     GPUTPCGMBorderTrack b;
-    const float toX = Param().par.earlyTpcTransform ? mClustersXYZ[iOutTrackFirstCluster].x : GPUTPCGeometry::Row2X(cl[0].row);
+    const float toX = Param().par.earlyTpcTransform ? mClustersXYZ[iMergedTrackFirstCluster].x : GPUTPCGeometry::Row2X(cl[0].row);
     if (p2.TransportToX(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
       p1.X() = toX;
       p1.Y() = b.Par()[0];
@@ -1796,13 +1796,13 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     if (Param().rec.tpc.mergeCE) {
       bool CEside;
       if (Param().par.earlyTpcTransform) {
-        const GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iOutTrackFirstCluster;
+        const GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iMergedTrackFirstCluster;
         CEside = (mergedTrack.CSide() != 0) ^ (clXYZ[0].z > clXYZ[nHits - 1].z);
       } else {
         auto& cls = mConstantMem->ioPtrs.clustersNative->clustersLinear;
         CEside = cls[cl[0].num].getTime() < cls[cl[nHits - 1].num].getTime();
       }
-      MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], Param().par.earlyTpcTransform ? &(mClustersXYZ + iOutTrackFirstCluster)[CEside ? (nHits - 1) : 0] : nullptr, iOutputTrack);
+      MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], Param().par.earlyTpcTransform ? &(mClustersXYZ + iMergedTrackFirstCluster)[CEside ? (nHits - 1) : 0] : nullptr, iOutputTrack);
     }
   } // itr
 }
@@ -1855,7 +1855,7 @@ GPUd() void GPUTPCGMMerger::PrepareClustersForFit1(int32_t nBlocks, int32_t nThr
 
 GPUd() void GPUTPCGMMerger::PrepareClustersForFit2(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTrackClusters; i += nBlocks * nThreads) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTrackClusters; i += nBlocks * nThreads) {
     if (mSharedCount[mClusters[i].num] > 1) {
       mClusters[i].state |= GPUTPCGMMergedTrackHit::flagShared;
     }
@@ -1876,7 +1876,7 @@ GPUd() void GPUTPCGMMerger::Finalize0(int32_t nBlocks, int32_t nThreads, int32_t
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nThreads * nBlocks) {
     mTrackSort[mTrackOrderAttach[i]] = i;
   }
-  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nOutputTrackClusters; i += nThreads * nBlocks) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTrackClusters; i += nThreads * nBlocks) {
     mClusterAttachment[mClusters[i].num] = 0; // Reset adjacent attachment for attached clusters, set correctly below
   }
 }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 4487b6d937dc2..54a541ebe0fd6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -70,7 +70,7 @@ class GPUTPCGMMerger : public GPUProcessor
     GPUAtomic(uint32_t) nLoopData;
     GPUAtomic(uint32_t) nUnpackedTracks;
     GPUAtomic(uint32_t) nMergedTracks;
-    GPUAtomic(uint32_t) nOutputTrackClusters;
+    GPUAtomic(uint32_t) nMergedTrackClusters;
     GPUAtomic(uint32_t) nO2Tracks;
     GPUAtomic(uint32_t) nO2ClusRefs;
     const GPUTPCTrack* firstExtrapolatedTracks[NSECTORS];
@@ -113,8 +113,8 @@ class GPUTPCGMMerger : public GPUProcessor
   GPUhdi() uint32_t NClusters() const { return mNClusters; }
   GPUhdi() uint32_t NMaxClusters() const { return mNMaxClusters; }
   GPUhdi() uint32_t NMaxTracks() const { return mNMaxTracks; }
-  GPUhdi() uint32_t NMaxOutputTrackClusters() const { return mNMaxOutputTrackClusters; }
-  GPUhdi() uint32_t NOutputTrackClusters() const { return mMemory->nOutputTrackClusters; }
+  GPUhdi() uint32_t NMaxMergedTrackClusters() const { return mNMaxMergedTrackClusters; }
+  GPUhdi() uint32_t NMergedTrackClusters() const { return mMemory->nMergedTrackClusters; }
   GPUhdi() const GPUTPCGMMergedTrackHit* Clusters() const { return mClusters; }
   GPUhdi() GPUTPCGMMergedTrackHit* Clusters() { return (mClusters); }
   GPUhdi() const GPUTPCGMMergedTrackHitXYZ* ClustersXYZ() const { return mClustersXYZ; }
@@ -249,7 +249,7 @@ class GPUTPCGMMerger : public GPUProcessor
   uint32_t mNTotalSectorTracks = 0;      // maximum number of incoming sector tracks
   uint32_t mNMaxTracks = 0;              // maximum number of output tracks
   uint32_t mNMaxSingleSectorTracks = 0;  // max N tracks in one sector
-  uint32_t mNMaxOutputTrackClusters = 0; // max number of clusters in output tracks (double-counting shared clusters)
+  uint32_t mNMaxMergedTrackClusters = 0; // max number of clusters in output tracks (double-counting shared clusters)
   uint32_t mNMaxClusters = 0;            // max total unique clusters (in event)
   uint32_t mNMaxLooperMatches = 0;       // Maximum number of candidate pairs for looper matching
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrack.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrack.h
index 225f5f0e2c7ad..7306c84cf949c 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrack.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrack.h
@@ -53,9 +53,6 @@ class GPUTPCTrack
   GPUhd() static int32_t GetSize(int32_t nClust) { return sizeof(GPUTPCTrack) + nClust * sizeof(GPUTPCSectorOutCluster); }
   GPUhd() const GPUTPCTrack* GetNextTrack() const { return (const GPUTPCTrack*)(((char*)this) + GetSize(mNHits)); }
   GPUhd() GPUTPCTrack* NextTrack() { return (GPUTPCTrack*)(((char*)this) + GetSize(mNHits)); }
-  GPUhd() void SetOutTrackCluster(int32_t i, const GPUTPCSectorOutCluster& v) { ((GPUTPCSectorOutCluster*)((char*)this + sizeof(*this)))[i] = v; }
-  GPUhd() const GPUTPCSectorOutCluster* OutTrackClusters() const { return (const GPUTPCSectorOutCluster*)((char*)this + sizeof(*this)); }
-  GPUhd() const GPUTPCSectorOutCluster& OutTrackCluster(int32_t i) const { return OutTrackClusters()[i]; }
 
  private:
   int32_t mFirstHitID;         // index of the first track cell in the track->cell pointer array

From c5498af7e0ed421d066b22fc36d34530bcd6c478 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 21 May 2025 19:43:59 +0200
Subject: [PATCH 0396/1764] GPU TPC Merger: Fix out of bounds check

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 16182464c12fe..533e697cc5852 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1513,7 +1513,6 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
   GPUTPCGMSectorTrack* trackParts[kMaxParts];
 
   for (int32_t itr = iBlock * nThreads + iThread; itr < SectorTrackInfoLocalTotal(); itr += nThreads * nBlocks) {
-
     GPUTPCGMSectorTrack& track = mSectorTrackInfos[itr];
 
     if (track.PrevSegmentNeighbour() >= 0) {
@@ -1712,7 +1711,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
     }
 
     const uint32_t iMergedTrackFirstCluster = CAMath::AtomicAdd(&mMemory->nMergedTrackClusters, (uint32_t)nHits);
-    if (iMergedTrackFirstCluster >= mNMaxMergedTrackClusters) {
+    if (iMergedTrackFirstCluster + nHits > mNMaxMergedTrackClusters) {
       raiseError(GPUErrors::ERROR_MERGER_HIT_OVERFLOW, iMergedTrackFirstCluster, mNMaxMergedTrackClusters);
       CAMath::AtomicExch(&mMemory->nMergedTrackClusters, mNMaxMergedTrackClusters);
       continue;

From 0a7f3df8bf7e24304a1d2882061f8589e746598f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 21 May 2025 21:06:40 +0200
Subject: [PATCH 0397/1764] GPU: Add memoryScaling fuzzing debug option

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  2 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  8 ++++++
 .../DataTypes/GPUMemorySizeScalers.cxx        | 26 +++++++++++++++++++
 .../DataTypes/GPUMemorySizeScalers.h          | 11 +++++---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 GPU/GPUTracking/Interface/GPUO2Interface.cxx  |  2 +-
 6 files changed, 45 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index a4e5d5e1189f5..ad7a31cbd7470 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -304,7 +304,7 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     mProcessingSettings->rtc.optConstexpr = false;
   }
 
-  mMemoryScalers->factor = GetProcessingSettings().memoryScalingFactor;
+  mMemoryScalers->scalingFactor = GetProcessingSettings().memoryScalingFactor;
   mMemoryScalers->conservative = GetProcessingSettings().conservativeMemoryEstimate;
   mMemoryScalers->returnMaxVal = GetProcessingSettings().forceMaxMemScalers != 0;
   if (GetProcessingSettings().forceMaxMemScalers > 1) {
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 5f80a56e9e64e..2d1061616d907 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -216,6 +216,14 @@ int32_t GPUReconstructionCPU::ExitDevice()
 int32_t GPUReconstructionCPU::RunChains()
 {
   mMemoryScalers->temporaryFactor = 1.;
+  if (GetProcessingSettings().memoryScalingFuzz) {
+    static std::mt19937 rng;
+    static std::uniform_int_distribution<uint64_t> dist(0, 1000000);
+    uint64_t fuzzFactor = GetProcessingSettings().memoryScalingFuzz == 1 ? dist(rng) : GetProcessingSettings().memoryScalingFuzz;
+    GPUInfo("Fuzzing memory scaling factor with %lu", fuzzFactor);
+    mMemoryScalers->fuzzScalingFactor(fuzzFactor);
+  }
+
   mStatNEvents++;
   mNEventsProcessed++;
 
diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
index 8b8fbc3ecae20..42ac2e8015f45 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
@@ -15,6 +15,8 @@
 #include "GPUMemorySizeScalers.h"
 #include "GPULogging.h"
 
+#include <random>
+
 using namespace o2::gpu;
 
 void GPUMemorySizeScalers::rescaleMaxMem(size_t newAvailableMemory)
@@ -36,3 +38,27 @@ void GPUMemorySizeScalers::rescaleMaxMem(size_t newAvailableMemory)
   tpcMaxMergedTrackHits = (double)tmp.tpcMaxMergedTrackHits * scaleFactor;
   availableMemory = newAvailableMemory;
 }
+
+double GPUMemorySizeScalers::getScalingFactor()
+{
+  if (!doFuzzing) {
+    return scalingFactor;
+  }
+  static std::uniform_int_distribution<uint32_t> dist(0, 1000000);
+  static std::mt19937 rng;
+  if (fuzzSeed) {
+    rng = std::mt19937(fuzzSeed);
+    fuzzLimit = dist(rng) / 10;
+    fuzzSeed = 0;
+  }
+  if (dist(rng) > fuzzLimit) {
+    return scalingFactor;
+  }
+  return scalingFactor * 0.000001 * dist(rng);
+}
+
+void GPUMemorySizeScalers::fuzzScalingFactor(uint64_t seed)
+{
+  fuzzSeed = seed;
+  doFuzzing = true;
+}
diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
index e5012d86742f8..164ecb32c26c7 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
@@ -28,7 +28,9 @@ struct GPUMemorySizeScalers {
   size_t nITSTracks = 0;
 
   // General scaling factor
-  double factor = 1;
+  double scalingFactor = 1;
+  uint64_t fuzzSeed = 0;
+  uint64_t fuzzLimit = 0;
   double temporaryFactor = 1;
   bool conservative = 0;
 
@@ -64,11 +66,14 @@ struct GPUMemorySizeScalers {
   size_t tpcMaxMergedTrackHits = 200000000;
   size_t availableMemory = 20500000000;
   bool returnMaxVal = false;
+  bool doFuzzing = false;
 
   void rescaleMaxMem(size_t newAvailableMemory);
+  double getScalingFactor();
+  void fuzzScalingFactor(uint64_t seed);
   inline size_t getValue(size_t maxVal, size_t val)
   {
-    return returnMaxVal ? maxVal : (std::min<size_t>(maxVal, offset + val) * factor * temporaryFactor);
+    return returnMaxVal ? maxVal : (std::min<size_t>(maxVal, offset + val) * (doFuzzing == 0 ? scalingFactor : getScalingFactor()) * temporaryFactor);
   }
 
   inline size_t NTPCPeaks(size_t tpcDigits, bool perSector = false) { return getValue(perSector ? tpcMaxPeaks : (GPUCA_NSECTORS * tpcMaxPeaks), hitOffset + tpcDigits * tpcPeaksPerDigit); }
@@ -81,7 +86,7 @@ struct GPUMemorySizeScalers {
   inline size_t NTPCSectorTrackHits(size_t tpcHits, uint8_t withRejection = 0) { return getValue(tpcMaxSectorTrackHits, tpcHits * (withRejection ? tpcSectorTrackHitsPerHitWithRejection : tpcSectorTrackHitsPerHit)); }
   inline size_t NTPCMergedTracks(size_t tpcSectorTracks) { return getValue(tpcMaxMergedTracks, tpcSectorTracks * (conservative ? 1.0 : tpcMergedTrackPerSectorTrack)); }
   inline size_t NTPCMergedTrackHits(size_t tpcSectorTrackHitss) { return getValue(tpcMaxMergedTrackHits, tpcSectorTrackHitss * tpcMergedTrackHitPerSectorHit); }
-  inline size_t NTPCUnattachedHitsBase1024(int32_t type) { return (returnMaxVal || conservative) ? 1024 : std::min<size_t>(1024, tpcCompressedUnattachedHitsBase1024[type] * factor * temporaryFactor); }
+  inline size_t NTPCUnattachedHitsBase1024(int32_t type) { return (returnMaxVal || conservative) ? 1024 : std::min<size_t>(1024, tpcCompressedUnattachedHitsBase1024[type] * (doFuzzing == 0 ? scalingFactor : getScalingFactor()) * temporaryFactor); }
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 12f40cda4c398..238994ee53af5 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -312,6 +312,7 @@ AddOption(memoryAllocationStrategy, int8_t, 0, "", 0, "Memory Allocation Strageg
 AddOption(forceMemoryPoolSize, uint64_t, 1, "memSize", 0, "Force size of allocated GPU / page locked host memory", min(0ul))
 AddOption(forceHostMemoryPoolSize, uint64_t, 0, "hostMemSize", 0, "Force size of allocated host page locked host memory (overriding memSize)", min(0ul))
 AddOption(memoryScalingFactor, float, 1.f, "", 0, "Factor to apply to all memory scalers")
+AddOption(memoryScalingFuzz, uint64_t, 0, "", 0, "Fuzz the memoryScalingFactor (0 disable, 1 enable, >1 set seed", def(1))
 AddOption(conservativeMemoryEstimate, bool, false, "", 0, "Use some more conservative defaults for larger buffers during TPC processing")
 AddOption(tpcInputWithClusterRejection, uint8_t, 0, "", 0, "Indicate whether the TPC input is CTF data with cluster rejection, to tune buffer estimations")
 AddOption(forceMaxMemScalers, uint64_t, 0, "", 0, "Force using the maximum values for all buffers, Set a value n > 1 to rescale all maximums to a memory size of n")
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index 81eb2c285192b..f7e972315a739 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -110,7 +110,7 @@ int32_t GPUO2Interface::Initialize(const GPUO2InterfaceConfiguration& config)
       return (1);
     }
     if (!mCtx[i].mRec->IsGPU() && mCtx[i].mRec->GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
-      mCtx[i].mRec->MemoryScalers()->factor *= 2;
+      mCtx[i].mRec->MemoryScalers()->scalingFactor *= 2;
     }
   }
   if (mConfig->configProcessing.doublePipeline) {

From 2673d512ffe9e1e1f658ace2ccf93ac799501b56 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 22 May 2025 11:17:08 +0200
Subject: [PATCH 0398/1764] Drop obsolete documentation (#14309)

---
 .cmake-format.py                    |   6 --
 Algorithm/CMakeLists.txt            |   3 -
 Algorithm/doc/Algorithm.3.in        |  12 ---
 Algorithm/doc/algorithm_parser.3.in | 135 ----------------------------
 CMakeLists.txt                      |   5 --
 Examples/Ex5/CMakeLists.txt         |   2 -
 Examples/Ex5/doc/ex5.7.in           |  62 -------------
 cmake/O2TargetManPage.cmake         |  79 ----------------
 doc/CMakeInstructions.md            |  18 ----
 doc/FairMQDevice.1.in               |  64 -------------
 doc/ManPages.md                     |  23 -----
 doc/o2-timeframe-file-format.1.in   |  27 ------
 doc/o2.1.in                         |  19 ----
 13 files changed, 455 deletions(-)
 delete mode 100644 Algorithm/doc/Algorithm.3.in
 delete mode 100644 Algorithm/doc/algorithm_parser.3.in
 delete mode 100644 Examples/Ex5/doc/ex5.7.in
 delete mode 100644 cmake/O2TargetManPage.cmake
 delete mode 100644 doc/FairMQDevice.1.in
 delete mode 100644 doc/ManPages.md
 delete mode 100644 doc/o2-timeframe-file-format.1.in
 delete mode 100644 doc/o2.1.in

diff --git a/.cmake-format.py b/.cmake-format.py
index 9827eecd329c4..ae092bc09f363 100644
--- a/.cmake-format.py
+++ b/.cmake-format.py
@@ -66,12 +66,6 @@
             "HEADERS": '*',
         }
     },
-    "o2_target_man_page": {
-        "kwargs": {
-            "NAME": '+',
-            "SECTION": '*',
-        }
-    },
     "add_root_dictionary": {
         "kwargs": {
             "LINKDEF": '+',
diff --git a/Algorithm/CMakeLists.txt b/Algorithm/CMakeLists.txt
index b245562c7cc93..ed7a42a96e528 100644
--- a/Algorithm/CMakeLists.txt
+++ b/Algorithm/CMakeLists.txt
@@ -11,9 +11,6 @@
 
 o2_add_header_only_library(Algorithm INTERFACE_LINK_LIBRARIES O2::Headers)
 
-o2_target_man_page(Algorithm NAME Algorithm SECTION 3)
-o2_target_man_page(Algorithm NAME algorithm_parser SECTION 3)
-
 o2_add_test(o2formatparser
             SOURCES test/o2formatparser.cxx
             COMPONENT_NAME Algorithm
diff --git a/Algorithm/doc/Algorithm.3.in b/Algorithm/doc/Algorithm.3.in
deleted file mode 100644
index eaf618ee68da2..0000000000000
--- a/Algorithm/doc/Algorithm.3.in
+++ /dev/null
@@ -1,12 +0,0 @@
-.\" Alice O2 manpage for module Algorithm
-.TH "AliceO2" 3 "17 Jan 2017" "1.0" "Algorithm man page"
-
-.SH NAME
-AliceO2 - module
-.B Algorithm
-
-.SH DESCRIPTION
-A collection of generic algorithms for Alice O2
-
-.SH SEE ALSO
-algorithm_parser(3)
diff --git a/Algorithm/doc/algorithm_parser.3.in b/Algorithm/doc/algorithm_parser.3.in
deleted file mode 100644
index 98f45df279669..0000000000000
--- a/Algorithm/doc/algorithm_parser.3.in
+++ /dev/null
@@ -1,135 +0,0 @@
-.\" Alice O2 manpage for parser algorithms
-.TH "AliceO2" 3 "17 Jan 2017" "1.0" "Algorithm Parser man page"
-
-.SH NAME
-AliceO2 - module
-.B Algorithm
-- data parsers
-
-.SH SYNOPSIS
-.B ForwardParser<
-.I SomeHeaderType
-,
-.I SomeTrailerType
-.B >
-
-.B ReverseParser<
-.I SomeHeaderType
-,
-.I SomeTrailerType
-.B >
-
-.SS Public types
-.TP 2
-// a compound of header, data, and trailer
-.B struct FrameInfo {
-  using PtrT = const PayloadType*;
-  const HeaderType* header = nullptr;
-  const TrailerType* trailer = nullptr;
-  PtrT payload = nullptr;
-  size_t length = 0;
-
-.B };
-
-.TP 2
-.B using CheckHeaderFct = std::function<bool(const HeaderType&)>;
-alias for callback checking the header, return true if the object is a valid header
-.TP 2
-.B using CheckTrailerFct = std::function<bool(const TrailerType&)>;
-alias for callback checking the trailer
-.TP 2
-.B using GetFrameSizeFct = std::function<size_t(const HeaderType& )>;
-alias for callback to get the complete frame size including header, trailer and the data
-.TP 2
-.B using InsertFct = std::function<bool(FrameInfo&)>;
-function callback to insert/handle one frame into, sequentially called for all frames if the whole block has a valid format
-
-.SS Public member functions
-.TP 2
-.B template<typename InputType>
-.B int parse(const InputType* \fIbuffer\fB, size_t \fIbufferSize\fB, CheckHeaderFct \fIcheckHeader\fB, CheckTrailerFct \fIcheckTrailer\fB, GetFrameSizeFct \fIgetFrameSize\fB, InsertFct \fIinsert\fB)
-
-.SS Public member variables
-.TP 2
-.B static const size_t headOffset = typesize<HeaderType>::size;
-the length offset due to header
-.TP 2
-.B static const size_t tailOffset = typesize<TrailerType>::size;
-the length offset due to trailer
-.TP 2
-.B static const size_t totalOffset = headOffset + tailOffset;
-total length offset due to header and trailer
-
-.SH DESCRIPTION
-Template utilities for parsing of data sequences. Each entry in the sequence consist of a header, variable payload, and optionally a trailer. The three parts are collected in the FrameInfo structure for every entry.
-
-Callback functions for checking header and trailer integrity, getting length of the current frame and handling of a frame.
-
-.SS ForwardParser
-The size is expected to be part of the header, parsing starts at beginning of buffer.
-Trailer type can be void, which is also the default template parameter. That
-allows to define a frame consisting of only header and data.
-
-.SS ReverseParser
-The size is expected to be part of the trailer, the parsing is thus in reverse direction. Also the insert callback is called with the entries starting form the end of the buffer.
-An easy extension can be to reverse the order of the inserts, meaning that the entries are read from the beginning.
-
-.SH EXAMPLES
-.SS ReverseParser example
-.EX
-using SomeParser = ReverseParser<SomeHeaderType, SomeTrailerType>;
-SomeParser parser;
-std::vector<typename SomeParser::FrameInfo> frames;
-parser.parse(ptr, size,
-             [] (const typename SomeParser::HeaderType& h) {
-               // check the header
-               return true;
-             },
-             [] (const typename SomeParser::TrailerType& t) {
-               // check the trailer
-               return true;
-             },
-             [] (const typename SomeParser::TrailerType& t) {
-               // get the size of the frame including payload
-               // and header and trailer size, e.g. payload size
-               // from a trailer member
-               return t.payloadSize + SomeParser::totalOffset;
-             },
-             [&frames] (typename SomeParser::FrameInfo& info) {
-               frames.emplace_back(info);
-               return true;
-             }
-             )
-.EE
-
-.SS ForwardParser example with frame consisting of header and payload
-.EX
-using SomeParser = ForwardParser<SomeHeaderType>;
-SomeParser parser;
-std::vector<typename SomeParser::FrameInfo> frames;
-parser.parse(ptr, size,
-             [] (const typename SomeParser::HeaderType& h) {
-               // check the header
-               return true;
-             },
-             [] (const typename SomeParser::HeaderType& h) {
-               // get the size of the frame including payload
-               // and header and trailer size, e.g. payload size
-               // from a header member
-               return h.payloadSize + SomeParser::totalOffset;
-             },
-             [&frames] (typename SomeParser::FrameInfo& info) {
-               frames.emplace_back(info);
-               return true;
-             }
-             )
-.EE
-
-.SH BUGS, CONTRIBUTIONS
-Please add an issue to
-.UR https://github.com/AliceO2Group/AliceO2/issues
-.UE
-
-.SH SEE ALSO
-.UR https://github.com/AliceO2Group/AliceO2/blob/dev/Algorithm/include/Algorithm/Parser.h
-.UE
diff --git a/CMakeLists.txt b/CMakeLists.txt
index b71d05175e9e9..adecffc0f4dbf 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -86,7 +86,6 @@ include(O2AddTestRootMacro)
 include(O2ReportNonTestedMacros)
 include(O2TargetRootDictionary)
 include(O2DataFile)
-include(O2TargetManPage)
 include(O2AddWorkflow)
 include(O2SetROOTPCMDependencies)
 include(O2AddHipifiedExecutable)
@@ -117,10 +116,6 @@ endif()
 
 add_subdirectory(config)
 
-add_custom_target(man ALL)
-o2_target_man_page(man NAME o2)
-o2_target_man_page(man NAME FairMQDevice)
-
 # Testing and packaging only needed if we are the top level directory
 if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   # Documentation
diff --git a/Examples/Ex5/CMakeLists.txt b/Examples/Ex5/CMakeLists.txt
index 3951709a8a050..f6216bcebdad2 100644
--- a/Examples/Ex5/CMakeLists.txt
+++ b/Examples/Ex5/CMakeLists.txt
@@ -12,5 +12,3 @@
 o2_add_executable(ex5
                   SOURCES src/run.cxx
                   COMPONENT_NAME example TARGETVARNAME targetName)
-
-o2_target_man_page(${targetName} NAME ex5 SECTION 7)
diff --git a/Examples/Ex5/doc/ex5.7.in b/Examples/Ex5/doc/ex5.7.in
deleted file mode 100644
index 5d346f7f4798d..0000000000000
--- a/Examples/Ex5/doc/ex5.7.in
+++ /dev/null
@@ -1,62 +0,0 @@
-.\" Manpage for ex5.
-
-.\" this file gives some basic introduction on how to use the
-.\" roff format to write man pages
-.\" NOTE: all formatting commands start with a dot and must be
-.\" at the beginning of the line
-
-.\" the header section
-.TH AliceO2 1 "07 July 2019" "1.0" "ex5 man page"
-
-.\" .SH starts a new section, NAME is the first section
-.SH NAME
-
-ex5 - A simple example for AliceO2 submodules
-
-.\" next is the SYNOPSIS section
-.SH SYNOPSIS
-
-.\" some bold formatted text
-.B ex5
-.\" alternate between roman and bold font, separated by blank, i.e. the
-.\" square backets in roman and the option in bold
-.RB [ --someoption ]
-.\" same here, in addition, the dots indicating the argument string are in
-.\" italic. Note: the quoted " [" makes sure there is a blank
-.RB [ --debug " [" --gdb=\fI...\fR ]]
-.\" italic formatting (underline in man)
-.I mandatory_argument
-.\" alternate roman and italic
-.RI [ further_arguments... ]
-
-
-.SH DESCRIPTION
-
-ex5 is an example to demonstrate the AliceO2 cmake setup of
-modules. This document illustrates creation of man pages. All options and
-arument are pure fictive.
-
-.SH OPTIONS
-
-.\" indented paragraph with label, indentation is set to the optional number
-.TP 5
-.B --someoption
-This is a fancy option of the example.
-
-.TP 5
-.B --debug
-Run everything with debugging options
-
-.TP 5
-.B --gdb=\fI...\fR
-Add additional information to run with gdb
-
-.SH SEE ALSO
-
-ex5(1)
-
-http://gnustep.made-it.com/man-groff.html
-
-.SH BUGS
-
-No known bugs
diff --git a/cmake/O2TargetManPage.cmake b/cmake/O2TargetManPage.cmake
deleted file mode 100644
index 5d29447c52536..0000000000000
--- a/cmake/O2TargetManPage.cmake
+++ /dev/null
@@ -1,79 +0,0 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-# All rights not expressly granted are reserved.
-#
-# This software is distributed under the terms of the GNU General Public
-# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-#
-# In applying this license CERN does not waive the privileges and immunities
-# granted to it by virtue of its status as an Intergovernmental Organization
-# or submit itself to any jurisdiction.
-
-include_guard()
-
-# Generate a man page
-#
-# Make sure we have nroff. If that is not the case we will not generate man
-# pages
-find_program(NROFF_FOUND nroff)
-
-function(o2_target_man_page target)
-  if(NOT NROFF_FOUND)
-    return()
-  endif()
-  cmake_parse_arguments(PARSE_ARGV
-                        1
-                        A
-                        ""
-                        "NAME;SECTION"
-                        "")
-
-  # check the target exists
-  if(NOT TARGET ${target})
-    # try with out naming conventions
-    set(baseTargetName ${target})
-    o2_name_target(${baseTargetName} NAME target)
-    if(NOT TARGET ${target})
-      # not a library, maybe an executable ?
-      o2_name_target(${baseTargetName} NAME target IS_EXE)
-      if(NOT TARGET ${target})
-        message(FATAL_ERROR "Target ${target} does not exist")
-      endif()
-    endif()
-  endif()
-
-  if(NOT A_SECTION)
-    set(A_SECTION 1)
-  endif()
-  if(NOT A_NAME)
-    message(
-      FATAL_ERROR
-        "You must provide the name of the input man file in doc/<name>.<section>.in"
-      )
-  endif()
-  if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/doc/${A_NAME}.${A_SECTION}.in)
-    message(
-      FATAL_ERROR
-        "Input file ${CMAKE_CURRENT_SOURCE_DIR}/doc/${A_NAME}.${A_SECTION}.in does not exist"
-      )
-  endif()
-  add_custom_command(
-    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${A_NAME}.${A_SECTION}
-    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/doc/${A_NAME}.${A_SECTION}.in
-    COMMAND nroff
-            -Tascii
-            -man
-            ${CMAKE_CURRENT_SOURCE_DIR}/doc/${A_NAME}.${A_SECTION}.in
-            >
-            ${CMAKE_CURRENT_BINARY_DIR}/${A_NAME}.${A_SECTION}
-    VERBATIM)
-  # the prefix man. for the target name avoids circular dependencies for the man
-  # pages added at top level. Simply droping the dependency for those does not
-  # invoke the custom command on all systems.
-  set(CUSTOM_TARGET_NAME man.${A_NAME}.${A_SECTION})
-  add_custom_target(${CUSTOM_TARGET_NAME}
-                    DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${A_NAME}.${A_SECTION})
-  add_dependencies(${target} ${CUSTOM_TARGET_NAME})
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${A_NAME}.${A_SECTION}
-          DESTINATION ${CMAKE_INSTALL_DATADIR}/man/man${A_SECTION})
-endfunction()
diff --git a/doc/CMakeInstructions.md b/doc/CMakeInstructions.md
index c4f55140f611c..e0438c985c41d 100644
--- a/doc/CMakeInstructions.md
+++ b/doc/CMakeInstructions.md
@@ -349,24 +349,6 @@ Note as well that some (very few) tests are ran only for some configurations
 ctest -C RelWithDebInfo
 ```
 
-#### [Ex5](../Examples/Ex5) Adding a man page
-
-If a module provides one or more executables, it might be of interest for the users of those executables to have access to a man page for them. Ex5 illustates that use case.
-
-    .
-    ├── CMakeLists.txt
-    ├── README.md
-    ├── doc
-    │   └── ex5.7.in
-    └── src
-        └── run.cxx
-
-The [man page](ManPages.md) is created using :
-
-    o2_target_man_page([targetName] NAME ex5 SECTION 7)
-
-where `NAME xx` refers to a file `doc/xx.[SECTION].in`, and the actual `targetName` can be found from the base target name (ex5 in that case) using the [o2_name_target](../cmake/O2NameTarget.cmake) function.
-
 ## CTest
 
 In the build directory of O2, if you launch the `ctest` command, all the O2 tests will be ran, which is not always what you want/need, in particular during development.
diff --git a/doc/FairMQDevice.1.in b/doc/FairMQDevice.1.in
deleted file mode 100644
index 4e33e3379ae82..0000000000000
--- a/doc/FairMQDevice.1.in
+++ /dev/null
@@ -1,64 +0,0 @@
-.\" Manpage for general FairMQ device properties and options.
-.TH AliceO2 1 "10 Apr 2022" "1.1" "FairMQ device man page"
-.SH NAME
-fair::mq::Device - The basis for software devices in O2
-
-.SH SYNOPSIS
-.I deviceapp
-.BI --id deviceid
-.BI --mq-config " configfile"
-|
-.BI --channel-config " config"
-|
-.BI --config-json-string " arg"
-|
-.BI --config-xml-string " arg"
-
-.SH DESCRIPTION
-All AliceO2 devices derive from fair::mq::Device which provides the
-transport functionality.
-
-.SH OPTIONS
-.SS Common FairMQ device options
-.TP 2
-.BI --id " id"
-A unique identifier of the device
-.TP 2
-.BI --verbosity " arg " \fR(=DEBUG)
-.RS
-Verbosity level :
-.B TRACE
-.B DEBUG
-.B RESULTS
-.B INFO
-.B WARN
-.B ERROR
-.B STATE
-.B NOLOG
-.RE
-
-.SS FairMQ device channel configuration
-.TP 2
-.BI --config-xml-string " arg "
-XML input as command line string.
-.TP 2
-.BI --config-json-string " arg "
-JSON input as command line string.
-.TP 2
-.BI --mq-config " arg "
-JSON/XML input as file. The configuration object will check xml or
-json file extention and will call the json or xml parser accordingly
-.TP 2
-.BI --channel-config  " args "
-channel configuration as comma separated key=\fIvalue\fR pairs
-.RS
-Valid Keys:
-.B name
-.B type
-.B method
-.B address
-.B property
-.RE
-
-.SH MORE OPTIONS
-Use '\fIdeviceapp\fR --help' to get a full list of options.
diff --git a/doc/ManPages.md b/doc/ManPages.md
deleted file mode 100644
index 8fb7b48b07beb..0000000000000
--- a/doc/ManPages.md
+++ /dev/null
@@ -1,23 +0,0 @@
-<!-- doxy
-\page refdocManPages Man Pages
-/doxy -->
-
-# Man Pages
-
-You can create man pages in nroff format under:
-
-    Subsystem/Module/docs/<man-page-name>.<section>.in
-
-and it will create a man page for you in:
-
-    ${CMAKE_BINARY_DIR}/stage/share/man/man<section>
-
-if you add:
-
-    o2_target_man_page(target NAME <man-page-name> SECTION <section>)
-
-to your `CMakeLists.txt`. Note the man page is "attached" to a given target.
-If `SECTION` is omitted it will default to 1
-(executables). For more informantion about nroff format you can look at:
-
-    http://www.linuxjournal.com/article/1158
diff --git a/doc/o2-timeframe-file-format.1.in b/doc/o2-timeframe-file-format.1.in
deleted file mode 100644
index df36ff7256e33..0000000000000
--- a/doc/o2-timeframe-file-format.1.in
+++ /dev/null
@@ -1,27 +0,0 @@
-.\" Manpage for O2.
-.TH man 1 "19 May 2017" "1.0" "Alice O2 Timeframe Format"
-
-.SH DESCRIPTION
-
-O2 is Alice next generation software framework to be used for RUN3. This is a
-quick desctiption of the timeframe file format as dumped by
-o2-timeframe-writer-device and read by the o2-timeframe-reader-device.
-
-The file format is simply a dump of the timeframe on disk. Multiple timeframes
-can be concatenated resulting in a valid file. The format is as follow:
-
-o2tf: Timeframe [Timeframe [..]]
-Timeframe: Subtimeframe [Subtimeframe [...]] TimeframeIndex
-Subtimeframe: Header Payload
-Header: DataHeader derived header stack
-Payload: binary blob
-TimeframeIndex: IndexElement [IndexElement [..]]
-IndexElement: DataHeader Payload <Position in Timeframe>
-Position in timeframe: int (4 bytes)
-DataHeader: only the DataHeader part
-Payload: binary blob
-
-.SH DISCLAIMER
-
-Notice that this file format is a work in progress and cannot be used for
-anything but debugging purposes.
diff --git a/doc/o2.1.in b/doc/o2.1.in
deleted file mode 100644
index 57d74acf1640d..0000000000000
--- a/doc/o2.1.in
+++ /dev/null
@@ -1,19 +0,0 @@
-.\" Manpage for O2.
-.TH man 1 "19 May 2017" "1.0" "Alice O2 man page"
-
-.SH NAME
-
-O2 is Alice next generation software framework to be used for RUN3.
-
-.SH DEVICES
-
-o2-alicehlt-wrapper-device(1), o2-subframebuilder-device(1)
-
-.\.SH TOOLS
-
-.SH SEE ALSO
-FairMQDevice(1)
-
-.SH BUGS
-
-No bugs whatsoever

From b41a2a1e13cd537654c05d5dedb25b9c63e473da Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 14:44:22 +0200
Subject: [PATCH 0399/1764] Update GPU documentation build-standalone.md

---
 GPU/documentation/build-standalone.md | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/GPU/documentation/build-standalone.md b/GPU/documentation/build-standalone.md
index 891d16b4dc2c4..bf84fd3edf0fb 100644
--- a/GPU/documentation/build-standalone.md
+++ b/GPU/documentation/build-standalone.md
@@ -55,9 +55,20 @@ An example line would .e.g. be
 ```
 
 Some other noteworthy options are `--display` to run the GPU event display, `--qa` to run a QA task on MC data, `--runs` and `--runs2` to run multiple iterations of the benchmark, `--printSettings` to print all the settings that were used, `--memoryStat` to print memory statistics, `--sync` to run with settings for online reco, `--syncAsync` to run online reco first, and then offline reco on the produced TPC CTF data, `--setO2Settings` to use some defaults as they are in O2 not in the standalone version, `--PROCdoublePipeline` to enable the double-threaded pipeline for best performance (works only with multiple iterations, and not in async mode), and `--RTCenable` to enable the run time compilation improvements (check also `--RTCcacheOutput`).
-An example for a benchmark in online mode would be:
+With `--memSize` you can control the amount of GPU memory to use, and with `--inputMemory` and `--outputMemory` GPU-registered input/output buffers can be preallocated (as is the SHM memory when running in O2).
+An example for a benchmark that runs with the same settings as in online data taking would be:
 ```
-./ca -e o2-pbpb-100 -g --sync --setO2Settings --PROCdoublePipeline --RTCenable --runs 10
+./ca -e o2-pbpb-100 -g --gpuType HIP --sync --setO2Settings --PROCdoublePipeline --RTCenable --runs 10 --memSize 15000000000 --inputMemory 6000000000 --outputMemory 10000000000
+```
+
+For setting a GPU device, you can use the `--gpuDevice` option with the GPU index.
+For ROCm with many GPUs, however, like on the EPNs with 8 GPUs, it is better to set the `ROCR_VISIBLE_DEVICES` env variable to the GPU you want to use.
+MAKE SURE TO CHECK IF IT IS ALREADY SET BY SLURM WHEN YOU GET THE NODE!!! IN THAT CASE, USE ONLY THE GPUS ASSIGNED TO YOU BY SLURM!
+
+Finally, also NUMA pinning can play a role. On the EPN, you should use memory and GPUs and CPU cores from the same NUMA domain.
+For a reaslistic benchmark using GPU 0 on the EPNs, please use:
+```
+ROCR_VISIBLE_DEVICES=0 numactl --membind 0 --cpunodebind 0 ./ca -e o2-pbpb-100 --gpuType HIP --memSize 15000000000 --inputMemory 6000000000 --outputMemory 10000000000 --sync --runs 10 --RTCenable --setO2Settings --PROCdoublePipeline
 ```
 
 # Generating a dataset
@@ -84,3 +95,5 @@ To dump standalone data from CTF raw data in `myctf.root`, you can use the same
 ```
 CTFINPUT=1 INPUT_FILE_LIST=myctf.root CONFIG_EXTRA_PROCESS_o2_gpu_reco_workflow="GPU_global.dump=1;" WORKFLOW_DETECTORS=TPC SHMSIZE=16000000000 $O2_ROOT/prodtests/full-system-test/dpl-workflow.sh
 ```
+
+On the EPNs, you can find some reference data sets at `/home/drohr/standalone/events`.

From 010f8676d1c1e4849281bc18405192dea0c9bc58 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 21 May 2025 09:47:17 +0200
Subject: [PATCH 0400/1764] dpl-workflow.sh: using MI100 serialization
 workaround by default again,  with option to disable it with env var

---
 prodtests/full-system-test/dpl-workflow.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 4e6cbbebe7db7..dd575099857f4 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -270,6 +270,7 @@ if [[ $GPUTYPE == "HIP" ]]; then
     TIMESLICEOFFSET=$(($GPU_FIRST_ID + ($NUMAGPUIDS != 0 ? ($NGPUS * $NUMAID) : 0)))
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
+  [[ $EPNSYNCMODE == 1 || ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else
   GPU_CONFIG_KEY+="GPU_proc.deviceNum=-2;"

From b6f15f87e212a896e8c56f3cf475d1ef2c677889 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 13:53:13 +0200
Subject: [PATCH 0401/1764] GPU RTC: Add keepTempFiles option

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu | 6 ++++--
 GPU/GPUTracking/Definitions/GPUSettingsList.h      | 1 +
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index c8e5420a8bcf3..907bd08779ec2 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -420,8 +420,10 @@ void GPUReconstructionCUDA::genAndLoadRTC()
       mInternals->kernelModules.emplace_back(std::make_unique<CUmodule>());
       GPUChkErr(cuModuleLoad(mInternals->kernelModules.back().get(), (filename + "_" + std::to_string(i) + mRtcBinExtension).c_str()));
     }
-    remove((filename + "_" + std::to_string(i) + mRtcSrcExtension).c_str());
-    remove((filename + "_" + std::to_string(i) + mRtcBinExtension).c_str());
+    if (!GetProcessingSettings().rtctech.keepTempFiles) {
+      remove((filename + "_" + std::to_string(i) + mRtcSrcExtension).c_str());
+      remove((filename + "_" + std::to_string(i) + mRtcBinExtension).c_str());
+    }
   }
   if (GetProcessingSettings().rtctech.runTest == 2) {
     return;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 238994ee53af5..8dabd17f95d23 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -233,6 +233,7 @@ AddOption(cacheFolder, std::string, "./rtccache/", "", 0, "Folder in which the c
 AddOption(prependCommand, std::string, "", "", 0, "Prepend RTC compilation commands by this string")
 AddOption(overrideArchitecture, std::string, "", "", 0, "Override arhcitecture part of RTC compilation command line") // Part of cmdLine, so checked against the cache
 AddOption(loadLaunchBoundsFromFile, std::string, "", "", 0, "Load a parameter object containing the launch bounds from a file")
+AddOption(keepTempFiles, bool, false, "", 0, "Keep temporary source and object files")
 AddHelp("help", 'h')
 EndConfig()
 

From e060099977dac22c9eea41bc27234e45ee590a27 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 10:16:48 +0200
Subject: [PATCH 0402/1764] GPU: Fix CUDA GetMemInfo must use correct device
 and simplify context creation / cleanup

---
 .../Base/cuda/GPUReconstructionCUDA.cu        | 35 +++++++------------
 1 file changed, 12 insertions(+), 23 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 907bd08779ec2..0d5666b8ee790 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -125,34 +125,25 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     }
     std::vector<bool> devicesOK(count, false);
     std::vector<size_t> devMemory(count, 0);
-    bool contextCreated = false;
+    std::vector<bool> contextCreated(count, false);
     for (int32_t i = 0; i < count; i++) {
       if (GetProcessingSettings().debugLevel >= 4) {
         GPUInfo("Examining device %d", i);
       }
       size_t free, total;
-#ifndef __HIPCC__ // CUDA
-      if (GPUChkErrI(cudaInitDevice(i, 0, 0))) {
-#else // HIP
-      if (GPUChkErrI(hipSetDevice(i))) {
-#endif
+      if (GPUChkErrI(cudaSetDevice(i))) {
         if (GetProcessingSettings().debugLevel >= 4) {
           GPUWarning("Couldn't create context for device %d. Skipping it.", i);
         }
         continue;
       }
-      contextCreated = true;
+      contextCreated[i] = true;
       if (GPUChkErrI(cudaMemGetInfo(&free, &total))) {
         if (GetProcessingSettings().debugLevel >= 4) {
           GPUWarning("Error obtaining CUDA memory info about device %d! Skipping it.", i);
         }
-        GPUChkErr(cudaDeviceReset());
         continue;
       }
-      if (count > 1) {
-        GPUChkErr(cudaDeviceReset());
-        contextCreated = false;
-      }
       if (GetProcessingSettings().debugLevel >= 4) {
         GPUInfo("Obtained current memory usage for device %d", i);
       }
@@ -212,13 +203,20 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
         bestDevice = GetProcessingSettings().deviceNum;
       }
     }
-    if (noDevice) {
-      if (contextCreated) {
+    for (int32_t i = 0; i < count; i++) {
+      if (contextCreated[i] && (noDevice || i != bestDevice)) {
+        GPUChkErrI(cudaSetDevice(i));
         GPUChkErrI(cudaDeviceReset());
       }
+    }
+    if (noDevice) {
       return (1);
     }
     mDeviceId = bestDevice;
+    if (GPUChkErrI(cudaSetDevice(mDeviceId))) {
+      GPUError("Could not set CUDA Device!");
+      return (1);
+    }
 
     GPUChkErrI(cudaGetDeviceProperties(&deviceProp, mDeviceId));
 
@@ -262,15 +260,6 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     }
 #endif
 
-#ifndef __HIPCC__ // CUDA
-    if (contextCreated == 0 && GPUChkErrI(cudaInitDevice(mDeviceId, 0, 0))) {
-#else // HIP
-    if (contextCreated == 0 && GPUChkErrI(hipSetDevice(mDeviceId))) {
-#endif
-      GPUError("Could not set CUDA Device!");
-      return (1);
-    }
-
 #ifndef __HIPCC__ // CUDA
     if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitStackSize, GPUCA_GPU_STACK_SIZE))) {
       GPUError("Error setting CUDA stack size");

From 52937edaf56f75f1e347141e4105a31a95c55fc9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 13:43:20 +0200
Subject: [PATCH 0403/1764] GPU Display: Store pointer to
 GPUSettingsProcessing, so we do not need to copy debugLevel to GPUParam

---
 .../Base/GPUReconstructionTimeframe.cxx        |  3 +--
 .../Interface/GPUO2InterfaceDisplay.cxx        |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx  |  2 +-
 GPU/GPUTracking/display/GPUDisplay.cxx         | 18 ++++++++++--------
 GPU/GPUTracking/display/GPUDisplay.h           |  8 +++++++-
 .../display/GPUDisplayInterface.cxx            |  4 ++--
 GPU/GPUTracking/display/GPUDisplayInterface.h  | 14 ++++++++++++--
 .../backend/GPUDisplayBackendOpenGL.cxx        |  2 +-
 .../backend/GPUDisplayBackendVulkan.cxx        |  8 ++++----
 .../frontend/GPUDisplayFrontendWayland.cxx     |  6 +++---
 .../display/helpers/GPUDisplayLoader.cxx       | 15 +++++++++++++--
 .../display/render/GPUDisplayDraw.cxx          |  2 +-
 GPU/GPUTracking/qa/GPUQA.cxx                   |  2 +-
 GPU/GPUTracking/qa/genEvents.cxx               |  3 +--
 14 files changed, 58 insertions(+), 31 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
index b25b93e957b15..fefcd0ac925fe 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
@@ -25,14 +25,13 @@
 #include "TPCFastTransform.h"
 #include "CorrectionMapsHelper.h"
 #include "GPUO2DataTypes.h"
+#include "GPUSettings.h"
 
 #include <cstdio>
 #include <exception>
 #include <memory>
 #include <cstring>
 
-#include "utils/qconfig.h"
-
 using namespace o2::gpu;
 
 namespace o2::gpu
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
index f84f29d826f1d..60d5eaf9ae162 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
@@ -35,7 +35,7 @@ GPUO2InterfaceDisplay::GPUO2InterfaceDisplay(const GPUO2InterfaceConfiguration*
     mQA.reset(new GPUQA(nullptr, &config->configQA, mParam.get()));
     mQA->InitO2MCData();
   }
-  mDisplay.reset(GPUDisplayInterface::getDisplay(mFrontend.get(), nullptr, mQA.get(), mParam.get(), &mConfig->configCalib, &mConfig->configDisplay));
+  mDisplay.reset(GPUDisplayInterface::getDisplay(mFrontend.get(), nullptr, mQA.get(), mParam.get(), &mConfig->configCalib, &mConfig->configDisplay, &mConfig->configProcessing));
 }
 
 GPUO2InterfaceDisplay::~GPUO2InterfaceDisplay() = default;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index aed42e4f98f0c..9fb12432e763a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -42,7 +42,7 @@
 #include "GPUGetConstexpr.h"
 
 #ifdef GPUCA_CADEBUG_ENABLED
-#include "../utils/qconfig.h"
+#include "GPUSettings.h"
 #include "AliHLTTPCClusterMCData.h"
 #endif
 
diff --git a/GPU/GPUTracking/display/GPUDisplay.cxx b/GPU/GPUTracking/display/GPUDisplay.cxx
index 5b0960919da15..136b1947f60ee 100644
--- a/GPU/GPUTracking/display/GPUDisplay.cxx
+++ b/GPU/GPUTracking/display/GPUDisplay.cxx
@@ -34,7 +34,7 @@
 #include "GPUTPCTracker.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUO2DataTypes.h"
-#include "utils/qconfig.h"
+#include "GPUSettings.h"
 
 #include "frontend/GPUDisplayFrontend.h"
 #include "backend/GPUDisplayBackend.h"
@@ -44,17 +44,19 @@ constexpr hmm_mat4 MY_HMM_IDENTITY = {{{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0},
 
 using namespace o2::gpu;
 
-static const GPUSettingsDisplay& GPUDisplay_GetConfig(GPUChainTracking* chain)
+const GPUSettingsDisplay& GPUDisplay::GetConfig(GPUChainTracking* chain)
 {
   static GPUSettingsDisplay defaultConfig;
-  if (chain && chain->mConfigDisplay) {
-    return *chain->mConfigDisplay;
-  } else {
-    return defaultConfig;
-  }
+  return (chain && chain->mConfigDisplay) ? *chain->mConfigDisplay : defaultConfig;
+}
+
+const GPUSettingsProcessing& GPUDisplay::GetProcessingConfig(GPUChainTracking* chain)
+{
+  static GPUSettingsProcessing defaultConfig;
+  return chain ? chain->GetProcessingSettings() : defaultConfig;
 }
 
-GPUDisplay::GPUDisplay(GPUDisplayFrontend* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param, const GPUCalibObjectsConst* calib, const GPUSettingsDisplay* config) : GPUDisplayInterface(), mFrontend(frontend), mChain(chain), mConfig(config ? *config : GPUDisplay_GetConfig(chain)), mQA(qa)
+GPUDisplay::GPUDisplay(GPUDisplayFrontend* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param, const GPUCalibObjectsConst* calib, const GPUSettingsDisplay* config, const GPUSettingsProcessing* proc) : GPUDisplayInterface(), mFrontend(frontend), mChain(chain), mConfig(config ? *config : GetConfig(chain)), mProcessingSettings(proc ? *proc : GetProcessingConfig(chain)), mQA(qa)
 {
   mParam = param ? param : &mChain->GetParam();
   mCalib = calib;
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index dbd90020698b2..06977c26e0b63 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -18,6 +18,7 @@
 #include "frontend/GPUDisplayFrontend.h"
 #include "backend/GPUDisplayBackend.h"
 #include "GPUDisplayInterface.h"
+#include "GPUSettings.h"
 
 #include "../utils/vecpod.h"
 #include "../utils/qsem.h"
@@ -37,7 +38,7 @@ class GPUTRDGeometry;
 class GPUDisplay : public GPUDisplayInterface
 {
  public:
-  GPUDisplay(GPUDisplayFrontend* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param = nullptr, const GPUCalibObjectsConst* calib = nullptr, const GPUSettingsDisplay* config = nullptr);
+  GPUDisplay(GPUDisplayFrontend* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param = nullptr, const GPUCalibObjectsConst* calib = nullptr, const GPUSettingsDisplay* config = nullptr, const GPUSettingsProcessing* proc = nullptr);
   GPUDisplay(const GPUDisplay&) = delete;
   ~GPUDisplay() override = default;
 
@@ -71,6 +72,7 @@ class GPUDisplay : public GPUDisplayInterface
   };
   vecpod<vtx>* vertexBuffer() { return mVertexBuffer; }
   const GPUParam* param() { return mParam; }
+  const GPUSettingsProcessing& GetProcessingSettings() const { return mProcessingSettings; }
   GPUDisplayFrontend* frontend() { return mFrontend; }
   bool drawTextInCompatMode() const { return mDrawTextInCompatMode; }
   int32_t& drawTextFontSize() { return mDrawTextFontSize; }
@@ -140,6 +142,9 @@ class GPUDisplay : public GPUDisplayInterface
     bool mVerbose = false;
   };
 
+  static const GPUSettingsDisplay& GetConfig(GPUChainTracking* chain);
+  static const GPUSettingsProcessing& GetProcessingConfig(GPUChainTracking* chain);
+
   void DrawGLScene_internal(float animateTime = -1.f, bool renderToMixBuffer = false);
   void DrawGLScene_updateEventData();
   void DrawGLScene_cameraAndAnimation(float animateTime, float& mixSlaveImage, hmm_mat4& nextViewMatrix);
@@ -214,6 +219,7 @@ class GPUDisplay : public GPUDisplayInterface
   GPUSettingsDisplayLight mCfgL;
   GPUSettingsDisplayHeavy mCfgH;
   GPUSettingsDisplayRenderer mCfgR;
+  const GPUSettingsProcessing& mProcessingSettings;
   GPUQA* mQA;
   qSem mSemLockDisplay;
 
diff --git a/GPU/GPUTracking/display/GPUDisplayInterface.cxx b/GPU/GPUTracking/display/GPUDisplayInterface.cxx
index 2f5cc9cbb5dd5..2eddef998fa8b 100644
--- a/GPU/GPUTracking/display/GPUDisplayInterface.cxx
+++ b/GPU/GPUTracking/display/GPUDisplayInterface.cxx
@@ -65,9 +65,9 @@ static void* loadUnloadLib(bool load)
   return nullptr;
 }
 
-GPUDisplayInterface* GPUDisplayInterface::getDisplay(GPUDisplayFrontendInterface* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param, const GPUCalibObjectsConst* calib, const GPUSettingsDisplay* config)
+GPUDisplayInterface* GPUDisplayInterface::getDisplay(GPUDisplayFrontendInterface* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param, const GPUCalibObjectsConst* calib, const GPUSettingsDisplay* config, const GPUSettingsProcessing* proc)
 {
-  std::tuple args = {frontend, chain, qa, param, calib, config};
+  std::tuple args = {frontend, chain, qa, param, calib, config, proc};
   auto func = (GPUDisplayInterface * (*)(const char*, void*)) loadUnloadLib(true);
   return func ? func("display", &args) : nullptr;
 }
diff --git a/GPU/GPUTracking/display/GPUDisplayInterface.h b/GPU/GPUTracking/display/GPUDisplayInterface.h
index 3c6928c78e5a1..574a8cffc71f0 100644
--- a/GPU/GPUTracking/display/GPUDisplayInterface.h
+++ b/GPU/GPUTracking/display/GPUDisplayInterface.h
@@ -15,7 +15,7 @@
 #ifndef GPUDISPLAYINTERFACE_H
 #define GPUDISPLAYINTERFACE_H
 
-#include "GPUSettings.h"
+#include <cstdint>
 
 namespace o2::gpu
 {
@@ -23,6 +23,16 @@ namespace o2::gpu
 class GPUChainTracking;
 class GPUQA;
 struct GPUParam;
+struct GPUTrackingInOutPointers;
+template <class T>
+struct ConstPtr;
+template <template <typename T> class S>
+struct GPUCalibObjectsTemplate;
+typedef GPUCalibObjectsTemplate<ConstPtr> GPUCalibObjectsConst;
+struct GPUDisplayFrontendInterface;
+struct GPUSettingsDisplay;
+struct GPUSettingsProcessing;
+
 class GPUDisplayInterface
 {
  public:
@@ -34,7 +44,7 @@ class GPUDisplayInterface
   virtual void SetCollisionFirstCluster(uint32_t collision, int32_t sector, int32_t cluster) = 0;
   virtual void UpdateCalib(const GPUCalibObjectsConst* calib) = 0;
   virtual void UpdateParam(const GPUParam* param) = 0;
-  static GPUDisplayInterface* getDisplay(GPUDisplayFrontendInterface* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param = nullptr, const GPUCalibObjectsConst* calib = nullptr, const GPUSettingsDisplay* config = nullptr);
+  static GPUDisplayInterface* getDisplay(GPUDisplayFrontendInterface* frontend, GPUChainTracking* chain, GPUQA* qa, const GPUParam* param = nullptr, const GPUCalibObjectsConst* calib = nullptr, const GPUSettingsDisplay* config = nullptr, const GPUSettingsProcessing* proc = nullptr);
 
  protected:
   GPUDisplayInterface();
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
index 25ae5e1f8055f..b9bd2731ac641 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
@@ -305,7 +305,7 @@ int32_t GPUDisplayBackendOpenGL::checkProgramStatus(uint32_t program)
 
 int32_t GPUDisplayBackendOpenGL::InitBackendA()
 {
-  if (mDisplay->param()->par.debugLevel >= 2) {
+  if (mDisplay->GetProcessingSettings().debugLevel >= 2) {
     auto renderer = glGetString(GL_RENDERER);
     GPUInfo("Renderer: %s", (const char*)renderer);
   }
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
index 93c19356ac062..a7e54db725ae0 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
@@ -414,7 +414,7 @@ void GPUDisplayBackendVulkan::createDevice()
     mDebugMessenger = mInstance.createDebugUtilsMessengerEXT(debugCreateInfo, nullptr);
   }
   std::vector<vk::ExtensionProperties> extensions = vk::enumerateInstanceExtensionProperties(nullptr);
-  if (mDisplay->param()->par.debugLevel >= 3) {
+  if (mDisplay->GetProcessingSettings().debugLevel >= 3) {
     std::cout << "available instance extensions: " << extensions.size() << "\n";
     for (const auto& extension : extensions) {
       std::cout << '\t' << extension.extensionName << '\n';
@@ -436,7 +436,7 @@ void GPUDisplayBackendVulkan::createDevice()
   double bestScore = -1.;
   for (uint32_t i = 0; i < devices.size(); i++) {
     double score = checkDevice(devices[i], reqDeviceExtensions);
-    if (mDisplay->param()->par.debugLevel >= 2) {
+    if (mDisplay->GetProcessingSettings().debugLevel >= 2) {
       vk::PhysicalDeviceProperties deviceProperties = devices[i].getProperties();
       GPUInfo("Available Vulkan device %d: %s - Score %f", i, &deviceProperties.deviceName[0], score);
     }
@@ -467,7 +467,7 @@ void GPUDisplayBackendVulkan::createDevice()
   mStencilSupported = (bool)(depth64FormatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment);
   mCubicFilterSupported = (bool)(formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eSampledImageFilterCubicEXT);
   bool mailboxSupported = std::find(mSwapChainDetails.presentModes.begin(), mSwapChainDetails.presentModes.end(), vk::PresentModeKHR::eMailbox) != mSwapChainDetails.presentModes.end();
-  if (mDisplay->param()->par.debugLevel >= 2) {
+  if (mDisplay->GetProcessingSettings().debugLevel >= 2) {
     GPUInfo("Max MSAA: %d, 32 bit Z buffer %d, 32 bit Z buffer + stencil buffer %d, Cubic Filtering %d, Mailbox present mode %d\n", (int32_t)mMaxMSAAsupported, (int32_t)mZSupported, (int32_t)mStencilSupported, (int32_t)mCubicFilterSupported, (int32_t)mailboxSupported);
   }
 
@@ -1406,7 +1406,7 @@ void GPUDisplayBackendVulkan::clearImage(VulkanImage& image)
 
 int32_t GPUDisplayBackendVulkan::InitBackendA()
 {
-  mEnableValidationLayers = mDisplay->param() && mDisplay->param()->par.debugLevel >= 2;
+  mEnableValidationLayers = mDisplay->param() && mDisplay->GetProcessingSettings().debugLevel >= 2;
   mFramesInFlight = 2;
 
   createDevice();
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
index d0aae2ffaad02..7a652297d89d7 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
@@ -290,7 +290,7 @@ int32_t GPUDisplayFrontendWayland::FrontendMain()
   auto seat_capabilities_c = internal::CCallWrapper<void, wl_seat*, uint32_t>{[seat_capabilities](wl_seat* seat, uint32_t capabilities) { seat_capabilities(seat, capabilities); }};
 
   auto seat_name = [](void* data, struct wl_seat* seat, const char* name) {
-    if (((GPUDisplayFrontendWayland*)data)->mDisplay->param()->par.debugLevel >= 2) {
+    if (((GPUDisplayFrontendWayland*)data)->mDisplay->GetProcessingSettings().debugLevel >= 2) {
       GPUInfo("Wayland seat: %s", name);
     }
   };
@@ -300,7 +300,7 @@ int32_t GPUDisplayFrontendWayland::FrontendMain()
   };
 
   auto registry_global = [&](wl_registry* registry, uint32_t name, const char* interface, uint32_t version) {
-    if (mDisplay->param()->par.debugLevel >= 3) {
+    if (mDisplay->GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Available interface %s", interface);
     }
     if (strcmp(interface, wl_output_interface.name) == 0) {
@@ -344,7 +344,7 @@ int32_t GPUDisplayFrontendWayland::FrontendMain()
 
   auto xdg_toplevel_handle_configure = [](void* data, xdg_toplevel* toplevel, int32_t width, int32_t height, wl_array* states) {
     GPUDisplayFrontendWayland* me = (GPUDisplayFrontendWayland*)data;
-    if (me->mDisplay->param()->par.debugLevel >= 3) {
+    if (me->mDisplay->GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Wayland surface resized to %d %d", width, height);
     }
     me->mWidthRequested = width;
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayLoader.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayLoader.cxx
index d31ee206f35e2..0f522f8fa1f7b 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayLoader.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayLoader.cxx
@@ -22,19 +22,28 @@
 
 using namespace o2::gpu;
 
+namespace o2::gpu
+{
+
 extern "C" void* GPUTrackingDisplayLoader(const char*, void*);
 
+namespace internal
+{
+namespace
+{
 template <class T, typename... Args>
 static inline T* createHelper(Args... args)
 {
   return new T(args...);
 }
+} // anonymous namespace
+} // namespace internal
 
 void* GPUTrackingDisplayLoader(const char* type, void* args)
 {
   if (strcmp(type, "display") == 0) {
-    auto x = (std::tuple<GPUDisplayFrontend*, GPUChainTracking*, GPUQA*, const GPUParam*, const GPUCalibObjectsConst*, const GPUSettingsDisplay*>*)args;
-    return std::apply([](auto&&... y) { return createHelper<GPUDisplay>(y...); }, *x);
+    auto x = (std::tuple<GPUDisplayFrontend*, GPUChainTracking*, GPUQA*, const GPUParam*, const GPUCalibObjectsConst*, const GPUSettingsDisplay*, const GPUSettingsProcessing*>*)args;
+    return std::apply([](auto&&... y) { return internal::createHelper<GPUDisplay>(y...); }, *x);
   } else if (strcmp(type, "frontend") == 0) {
     auto x = (std::tuple<const char*>*)args;
     return std::apply([](auto&&... y) { return GPUDisplayFrontend::getFrontend(y...); }, *x);
@@ -43,3 +52,5 @@ void* GPUTrackingDisplayLoader(const char* type, void* args)
   }
   return nullptr;
 }
+
+} // namespace o2::gpu
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index e1d63ea1a21e4..cbe385324ebbf 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -395,7 +395,7 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
         }
       };
       if (std::is_same_v<T, GPUTPCGMMergedTrack> || (!mIOPtrs->tpcLinkTRD && mIOPtrs->trdTracksO2)) {
-        if (mChain && ((int32_t)mConfig.showTPCTracksFromO2Format == (int32_t)mChain->GetProcessingSettings().trdTrackModelO2) && mTRDTrackIds[i] != -1 && mIOPtrs->nTRDTracklets) {
+        if (mChain && ((int32_t)mConfig.showTPCTracksFromO2Format == (int32_t)GetProcessingSettings().trdTrackModelO2) && mTRDTrackIds[i] != -1 && mIOPtrs->nTRDTracklets) {
           if (mIOPtrs->trdTracksO2) {
             tmpDoTRDTracklets(mIOPtrs->trdTracksO2[mTRDTrackIds[i]]);
           } else {
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 6a2623fb6e09d..45ccdc783891c 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -55,6 +55,7 @@
 #include "GPUROOTDump.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "SimulationDataFormat/MCCompLabel.h"
+#include "GPUSettings.h"
 #ifdef GPUCA_O2_LIB
 #include "DetectorsRaw/HBFUtils.h"
 #include "DataFormatsTPC/TrackTPC.h"
@@ -74,7 +75,6 @@
 #include <cstdio>
 #include <cinttypes>
 
-#include "utils/qconfig.h"
 #include "utils/timer.h"
 
 #include <oneapi/tbb.h>
diff --git a/GPU/GPUTracking/qa/genEvents.cxx b/GPU/GPUTracking/qa/genEvents.cxx
index 9c2220f9ef748..ca66f666f7f72 100644
--- a/GPU/GPUTracking/qa/genEvents.cxx
+++ b/GPU/GPUTracking/qa/genEvents.cxx
@@ -38,8 +38,7 @@
 #include "GPUTPCGMMerger.h"
 #include "GPUChainTracking.h"
 #include "GPUConstantMem.h"
-
-#include "../utils/qconfig.h"
+#include "GPUSettings.h"
 
 using namespace o2::gpu;
 using namespace std;

From 69169bad5b25033e8494331746ea02c202e36fbc Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 10:58:43 +0200
Subject: [PATCH 0404/1764] GPU: debugLevel is now only a runtime variable, not
 needed in compile-time parameters any more

---
 GPU/GPUTracking/Base/GPUParam.cxx             | 2 --
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 1 -
 2 files changed, 3 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index 57f23792e472a..85c1206d8df37 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -114,7 +114,6 @@ void GPUParam::SetDefaults(float solenoidBz)
   par.continuousTracking = false;
   continuousMaxTimeBin = 0;
   tpcCutTimeBin = 0;
-  par.debugLevel = 0;
   par.earlyTpcTransform = false;
 }
 
@@ -131,7 +130,6 @@ void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessi
   par.earlyTpcTransform = rec.tpc.forceEarlyTransform == -1 ? (!par.continuousTracking) : rec.tpc.forceEarlyTransform;
   qptB5Scaler = CAMath::Abs(bzkG) > 0.1f ? CAMath::Abs(bzkG) / 5.006680f : 1.f; // Repeat here, since passing in g is optional
   if (p) {
-    par.debugLevel = p->debugLevel;
     UpdateRun3ClusterErrors(p->param.tpcErrorParamY, p->param.tpcErrorParamZ);
   }
   if (w) {
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 8dabd17f95d23..3e7feeb122919 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -657,7 +657,6 @@ AddVariableRTC(toyMCEventsFlag, int8_t, 0)    // events were build with home-mad
 AddVariableRTC(continuousTracking, int8_t, 0) // Continuous tracking, estimate bz and errors for abs(z) = 125cm during seeding
 AddVariableRTC(dodEdx, int8_t, 0)             // Do dEdx computation
 AddVariableRTC(earlyTpcTransform, int8_t, 0)  // do Early TPC transformation
-AddVariableRTC(debugLevel, int8_t, 0)         // Debug level
 EndConfig()
 
 EndNamespace() // gpu

From 0b8dfcaf04486f7be5f7dcab476a8ad8b60bfc63 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 11:19:38 +0200
Subject: [PATCH 0405/1764] GPU: No need to store if Bz was constant as
 constant RTC param

---
 GPU/GPUTracking/Base/GPUParam.cxx                 | 14 ++++++--------
 GPU/GPUTracking/Base/GPUParam.h                   |  4 ++--
 GPU/GPUTracking/Definitions/GPUSettingsList.h     |  1 -
 GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx |  2 +-
 GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx |  2 +-
 5 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index 85c1206d8df37..b3090fdd36a51 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -30,7 +30,7 @@ using namespace o2::gpu;
 
 #include "utils/qconfigrtc.h"
 
-void GPUParam::SetDefaults(float solenoidBz)
+void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
 {
   memset((void*)this, 0, sizeof(*this));
   new (&rec) GPUSettingsRec;
@@ -84,7 +84,7 @@ void GPUParam::SetDefaults(float solenoidBz)
 #endif
 
   par.dAlpha = 0.349066f;
-  UpdateBzOnly(solenoidBz);
+  UpdateBzOnly(solenoidBz, assumeConstantBz);
   par.dodEdx = 0;
 
   constexpr float plusZmin = 0.0529937;
@@ -109,7 +109,6 @@ void GPUParam::SetDefaults(float solenoidBz)
     SectorParam[i].AngleMax = SectorParam[i].Alpha + par.dAlpha / 2.f;
   }
 
-  par.assumeConstantBz = false;
   par.toyMCEventsFlag = false;
   par.continuousTracking = false;
   continuousMaxTimeBin = 0;
@@ -120,8 +119,7 @@ void GPUParam::SetDefaults(float solenoidBz)
 void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p, const GPURecoStepConfiguration* w, const GPUSettingsRecDynamic* d)
 {
   if (g) {
-    UpdateBzOnly(g->solenoidBzNominalGPU);
-    par.assumeConstantBz = g->constBz;
+    UpdateBzOnly(g->solenoidBzNominalGPU, g->constBz);
     par.toyMCEventsFlag = g->homemadeEvents;
     par.continuousTracking = g->grpContinuousMaxTimeBin != 0;
     continuousMaxTimeBin = g->grpContinuousMaxTimeBin == -1 ? GPUSettings::TPC_MAX_TF_TIME_BIN : g->grpContinuousMaxTimeBin;
@@ -143,12 +141,12 @@ void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessi
   }
 }
 
-void GPUParam::UpdateBzOnly(float newSolenoidBz)
+void GPUParam::UpdateBzOnly(float newSolenoidBz, bool assumeConstantBz)
 {
   bzkG = newSolenoidBz;
   bzCLight = bzkG * o2::gpu::gpu_common_constants::kCLight;
   polynomialField.Reset();
-  if (par.assumeConstantBz) {
+  if (assumeConstantBz) {
     GPUTPCGMPolynomialFieldManager::GetPolynomialField(GPUTPCGMPolynomialFieldManager::kUniform, bzkG, polynomialField);
   } else {
     GPUTPCGMPolynomialFieldManager::GetPolynomialField(bzkG, polynomialField);
@@ -158,7 +156,7 @@ void GPUParam::UpdateBzOnly(float newSolenoidBz)
 
 void GPUParam::SetDefaults(const GPUSettingsGRP* g, const GPUSettingsRec* r, const GPUSettingsProcessing* p, const GPURecoStepConfiguration* w)
 {
-  SetDefaults(g->solenoidBzNominalGPU);
+  SetDefaults(g->solenoidBzNominalGPU, g->constBz);
   if (r) {
     rec = *r;
     if (rec.fitPropagateBzOnly == -1) {
diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 076d25d72d178..9b3340470a02f 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -77,10 +77,10 @@ struct GPUParam_t {
 struct GPUParam : public internal::GPUParam_t<GPUSettingsRec, GPUSettingsParam> {
 
 #ifndef GPUCA_GPUCODE
-  void SetDefaults(float solenoidBz);
+  void SetDefaults(float solenoidBz, bool assumeConstantBz);
   void SetDefaults(const GPUSettingsGRP* g, const GPUSettingsRec* r = nullptr, const GPUSettingsProcessing* p = nullptr, const GPURecoStepConfiguration* w = nullptr);
   void UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p = nullptr, const GPURecoStepConfiguration* w = nullptr, const GPUSettingsRecDynamic* d = nullptr);
-  void UpdateBzOnly(float newSolenoidBz);
+  void UpdateBzOnly(float newSolenoidBz, bool assumeConstantBz);
   void UpdateRun3ClusterErrors(const float* yErrorParam, const float* zErrorParam);
 #endif
 
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 3e7feeb122919..ac0fba1039da3 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -652,7 +652,6 @@ EndConfig()
 // Derrived parameters used in GPUParam
 BeginHiddenConfig(GPUSettingsParam, param)
 AddVariableRTC(dAlpha, float, 0.f)            // angular size
-AddVariableRTC(assumeConstantBz, int8_t, 0)   // Assume a constant magnetic field
 AddVariableRTC(toyMCEventsFlag, int8_t, 0)    // events were build with home-made event generator
 AddVariableRTC(continuousTracking, int8_t, 0) // Continuous tracking, estimate bz and errors for abs(z) = 125cm during seeding
 AddVariableRTC(dodEdx, int8_t, 0)             // Do dEdx computation
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
index 10a1a75368c96..f09c5d0a4b1cb 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
@@ -129,7 +129,7 @@ GPUO2InterfaceRefit::GPUO2InterfaceRefit(const ClusterNativeAccess* cl, const Co
 
 void GPUO2InterfaceRefit::updateCalib(const CorrectionMapsHelper* trans, float bzNominalGPU)
 {
-  mParam->UpdateBzOnly(bzNominalGPU);
+  mParam->UpdateBzOnly(bzNominalGPU, false);
   mRefit->SetFastTransformHelper(trans);
 }
 
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
index fa5705e903d1a..9454c9a2389ae 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
@@ -51,7 +51,7 @@ template <>
 void GPUO2InterfaceUtils::RunZSEncoder<DigitArray>(const DigitArray& in, std::unique_ptr<uint64_t[]>* outBuffer, uint32_t* outSizes, o2::raw::RawFileWriter* raw, const o2::InteractionRecord* ir, int32_t version, bool verify, float threshold, bool padding, std::function<void(std::vector<o2::tpc::Digit>&)> digitsFilter)
 {
   GPUParam param;
-  param.SetDefaults(5.00668);
+  param.SetDefaults(5.00668, false);
   o2::gpu::GPUReconstructionConvert::RunZSEncoder(in, outBuffer, outSizes, raw, ir, param, version, verify, threshold, padding, digitsFilter);
 }
 template <>

From 4f395b4248f9fbd30ba8d84e5a8cb54fcb7229d0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 11:23:21 +0200
Subject: [PATCH 0406/1764] GPU: Remove toyMC debug flag in propagator and RTC
 param

---
 GPU/GPUTracking/Base/GPUParam.cxx             |  2 --
 .../GPUTPCCompressionTrackModel.cxx           |  1 -
 GPU/GPUTracking/DataTypes/GPUSettings.h       |  2 +-
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 -
 GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx   |  1 -
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  1 -
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 21 +++----------------
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.h   |  2 --
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |  2 --
 .../Merger/macros/checkPropagation.C          |  1 -
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |  1 -
 .../Standalone/Benchmark/standalone.cxx       |  5 +----
 .../TRDTracking/GPUTRDInterfaces.h            |  1 -
 GPU/GPUTracking/qa/genEvents.cxx              |  1 -
 14 files changed, 5 insertions(+), 37 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index b3090fdd36a51..a4c4cb5844fa9 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -109,7 +109,6 @@ void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
     SectorParam[i].AngleMax = SectorParam[i].Alpha + par.dAlpha / 2.f;
   }
 
-  par.toyMCEventsFlag = false;
   par.continuousTracking = false;
   continuousMaxTimeBin = 0;
   tpcCutTimeBin = 0;
@@ -120,7 +119,6 @@ void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessi
 {
   if (g) {
     UpdateBzOnly(g->solenoidBzNominalGPU, g->constBz);
-    par.toyMCEventsFlag = g->homemadeEvents;
     par.continuousTracking = g->grpContinuousMaxTimeBin != 0;
     continuousMaxTimeBin = g->grpContinuousMaxTimeBin == -1 ? GPUSettings::TPC_MAX_TF_TIME_BIN : g->grpContinuousMaxTimeBin;
     tpcCutTimeBin = g->tpcCutTimeBin;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.cxx
index 1f84aa4599a27..ab7b0c99e09df 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.cxx
@@ -27,7 +27,6 @@ GPUd() void GPUTPCCompressionTrackModel::Init(float x, float y, float z, float a
 {
   mProp.SetMaterialTPC();
   mProp.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
-  mProp.SetToyMCEventsFlag(false);
   mProp.SetSeedingErrors(true); // Larger errors for seeds, better since we don't start with good hypothesis
   mProp.SetFitInProjections(true);
   mProp.SetPropagateBzOnly(true);
diff --git a/GPU/GPUTracking/DataTypes/GPUSettings.h b/GPU/GPUTracking/DataTypes/GPUSettings.h
index c81a8e20e9926..9e3a3e9bd6ce8 100644
--- a/GPU/GPUTracking/DataTypes/GPUSettings.h
+++ b/GPU/GPUTracking/DataTypes/GPUSettings.h
@@ -52,7 +52,7 @@ struct GPUSettingsGRP {
   // All new members must be sizeof(int32_t) resp. sizeof(float) for alignment reasons!, default value for newly added members for old data will be 0.
   float solenoidBzNominalGPU = -5.00668f; // solenoid field strength
   int32_t constBz = 0;                    // for test-MC events with constant Bz
-  int32_t homemadeEvents = 0;             // Toy-MC events
+  int32_t removed0 = 0;                   // Obsolete parameter, dummy value needed to support reading old dumps
   int32_t grpContinuousMaxTimeBin = -2;   // 0 for triggered events, -1 for automatic setting, -2 invalid default
   int32_t needsClusterer = 0;             // Set to true if the data requires the clusterizer
   int32_t doCompClusterDecode = 0;        // Set to true if the data contains compressed TPC clusters
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index ac0fba1039da3..14a1d1d263c26 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -652,7 +652,6 @@ EndConfig()
 // Derrived parameters used in GPUParam
 BeginHiddenConfig(GPUSettingsParam, param)
 AddVariableRTC(dAlpha, float, 0.f)            // angular size
-AddVariableRTC(toyMCEventsFlag, int8_t, 0)    // events were build with home-made event generator
 AddVariableRTC(continuousTracking, int8_t, 0) // Continuous tracking, estimate bz and errors for abs(z) = 125cm during seeding
 AddVariableRTC(dodEdx, int8_t, 0)             // Do dEdx computation
 AddVariableRTC(earlyTpcTransform, int8_t, 0)  // do Early TPC transformation
diff --git a/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx b/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
index 1601e11f2c6fa..798efb7d7964e 100644
--- a/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
+++ b/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
@@ -63,7 +63,6 @@ GPUdii() void GPUITSFitterKernels::Thread<0>(int32_t nBlocks, int32_t nThreads,
   GPUTPCGMPropagator prop;
   prop.SetPolynomialField(&processors.param.polynomialField);
   prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
-  prop.SetToyMCEventsFlag(0);
   prop.SetFitInProjections(1);
   float bz = -5.f; // FIXME
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 533e697cc5852..ebfc29cb6f749 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -493,7 +493,6 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
   GPUTPCGMPropagator prop;
   prop.SetMaterialTPC();
   prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
-  prop.SetToyMCEventsFlag(false);
   prop.SetSeedingErrors(true); // Larger errors for seeds, better since we don't start with good hypothesis
   prop.SetFitInProjections(false);
   prop.SetPolynomialField(&Param().polynomialField);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index 90612fc98f836..c0dd6cfbcf918 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -74,23 +74,10 @@ GPUd() void GPUTPCGMPropagator::GetBxByBzBase(float cosAlpha, float sinAlpha, fl
   B[0] = bb[0] * cosAlpha + bb[1] * sinAlpha;
   B[1] = -bb[0] * sinAlpha + bb[1] * cosAlpha;
   B[2] = bb[2];
-  /*if( mToyMCEvents ){ // special treatment for toy monte carlo
-    B[0] = 0;
-    B[1] = 0;
-    B[2] = mField->GetNominalBz();
-  }*/
 }
 
 GPUd() float GPUTPCGMPropagator::GetBzBase(float cosAlpha, float sinAlpha, float X, float Y, float Z) const
 {
-  if (mToyMCEvents) { // special treatment for toy monte carlo
-    float B[3];
-    GetBxByBzBase(cosAlpha, sinAlpha, X, Y, Z, B);
-    return B[2];
-  }
-
-  // get global coordinates
-
   float gx = getGlobalX(cosAlpha, sinAlpha, X, Y);
   float gy = getGlobalY(cosAlpha, sinAlpha, X, Y);
 
@@ -529,8 +516,7 @@ GPUd() int32_t GPUTPCGMPropagator::FollowLinearization(const GPUTPCGMPhysicalTra
   float dLabs = CAMath::Abs(dLmask);
 
   // Energy Loss
-
-  if (1 || !mToyMCEvents) {
+  if (true) {
     // std::cout<<"APPLY ENERGY LOSS!!!"<<std::endl;
     float corr = 1.f - mMaterial.EP2 * dLmask;
     float corrInv = 1.f / corr;
@@ -553,8 +539,7 @@ GPUd() int32_t GPUTPCGMPropagator::FollowLinearization(const GPUTPCGMPhysicalTra
   }
 
   //  Multiple Scattering
-
-  if (!mToyMCEvents) {
+  if (true) {
     mC22 += dLabs * mMaterial.k22 * mT0.CosPhi() * mT0.CosPhi();
     mC33 += dLabs * mMaterial.k33;
     mC43 += dLabs * mMaterial.k43;
@@ -1038,7 +1023,7 @@ GPUd() void GPUTPCGMPropagator::Mirror(bool inFlyDirection)
   ChangeDirection();
 
   // Energy Loss
-  if (1 || !mToyMCEvents) {
+  if (true) {
     // std::cout<<"MIRROR: APPLY ENERGY LOSS!!!"<<std::endl;
 
     float dL = CAMath::Abs(dS * mT0.GetDlDs());
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
index 97b307ce7a550..a6e2cbc6deb3b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
@@ -89,7 +89,6 @@ class GPUTPCGMPropagator
 
   GPUd() void SetFitInProjections(bool Flag) { mFitInProjections = Flag; }
   GPUd() void SetPropagateBzOnly(bool Flag) { mPropagateBzOnly = Flag; }
-  GPUd() void SetToyMCEventsFlag(bool Flag) { mToyMCEvents = Flag; }
   GPUd() void SetSeedingErrors(bool Flag) { mSeedingErrors = Flag; }
   GPUd() void SetMatLUT(const o2::base::MatLayerCylSet* lut) { mMatLUT = lut; }
 
@@ -191,7 +190,6 @@ class GPUTPCGMPropagator
   bool mSeedingErrors = 0;    // TODO: Hide variable in Run3 mode
   bool mFitInProjections = 1; // fit (Y,SinPhi,QPt) and (Z,DzDs) paramteres separatelly
   bool mPropagateBzOnly = 0;  // Use Bz only in propagation
-  bool mToyMCEvents = 0;      // events are simulated with simple home-made simulation
 };
 
 GPUdi() void GPUTPCGMPropagator::GetBxByBz(float Alpha, float X, float Y, float Z, float B[3]) const
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 9fb12432e763a..87486292eb034 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -67,7 +67,6 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
   prop.SetMaterialTPC();
   prop.SetPolynomialField(&param.polynomialField);
   prop.SetMaxSinPhi(maxSinPhi);
-  prop.SetToyMCEventsFlag(param.par.toyMCEventsFlag);
   if ((clusters[0].sector < 18) == (clusters[N - 1].sector < 18)) {
     ShiftZ2(clusters, clustersXYZ, merger, N);
   }
@@ -744,7 +743,6 @@ GPUdii() void GPUTPCGMTrackParam::RefitLoop(const GPUTPCGMMerger* GPUrestrict()
   prop.SetMaterialTPC();
   prop.SetPolynomialField(&Merger->Param().polynomialField);
   prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
-  prop.SetToyMCEventsFlag(Merger->Param().par.toyMCEventsFlag);
   prop.SetMatLUT(Merger->Param().rec.useMatLUT ? Merger->GetConstantMem()->calibObjects.matLUT : nullptr);
   prop.SetSeedingErrors(false);
   prop.SetFitInProjections(true);
diff --git a/GPU/GPUTracking/Merger/macros/checkPropagation.C b/GPU/GPUTracking/Merger/macros/checkPropagation.C
index fd32cf0bc3a85..3dc3193992d46 100644
--- a/GPU/GPUTracking/Merger/macros/checkPropagation.C
+++ b/GPU/GPUTracking/Merger/macros/checkPropagation.C
@@ -91,7 +91,6 @@ int32_t checkPropagation()
 
   GPUTPCGMPropagator prop;
   prop.SetPolynomialField(&field);
-  prop.SetToyMCEventsFlag(kTRUE);
 
   const int32_t nTracks = 1000;
 
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index 7c7ce8d07ffb9..3f342c6111f04 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -88,7 +88,6 @@ GPUd() void GPUTrackingRefit::initProp<GPUgeneric() GPUTPCGMPropagator>(GPUTPCGM
 {
   prop.SetMaterialTPC();
   prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
-  prop.SetToyMCEventsFlag(false);
   prop.SetSeedingErrors(false);
   prop.SetFitInProjections(mPparam->rec.fitInProjections != 0);
   prop.SetPropagateBzOnly(false);
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index d4c83f92a2157..5277195752c56 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -286,7 +286,7 @@ int32_t SetupReconstruction()
       printf("Error reading event config file\n");
       return 1;
     }
-    printf("Read event settings from dir %s (solenoidBz: %f, home-made events %d, constBz %d, maxTimeBin %d)\n", filename, rec->GetGRPSettings().solenoidBzNominalGPU, (int32_t)rec->GetGRPSettings().homemadeEvents, (int32_t)rec->GetGRPSettings().constBz, rec->GetGRPSettings().grpContinuousMaxTimeBin);
+    printf("Read event settings from dir %s (solenoidBz: %f, constBz %d, maxTimeBin %d)\n", filename, rec->GetGRPSettings().solenoidBzNominalGPU, (int32_t)rec->GetGRPSettings().constBz, rec->GetGRPSettings().grpContinuousMaxTimeBin);
     if (configStandalone.testSyncAsync) {
       recAsync->ReadSettings(filename);
     }
@@ -305,9 +305,6 @@ int32_t SetupReconstruction()
   procSet = configStandalone.proc;
   GPURecoStepConfiguration steps;
 
-  if (configStandalone.eventGenerator) {
-    grp.homemadeEvents = true;
-  }
   if (configStandalone.solenoidBzNominalGPU != -1e6f) {
     grp.solenoidBzNominalGPU = configStandalone.solenoidBzNominalGPU;
   }
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
index d26d46495069b..d45959f99b056 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
@@ -187,7 +187,6 @@ class propagatorInterface<GPUTPCGMPropagator> : public GPUTPCGMPropagator
     this->SetMaterialTPC();
     this->SetPolynomialField(pField);
     this->SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
-    this->SetToyMCEventsFlag(0);
     this->SetFitInProjections(0);
     this->SelectFieldRegion(GPUTPCGMPropagator::TRD);
   };
diff --git a/GPU/GPUTracking/qa/genEvents.cxx b/GPU/GPUTracking/qa/genEvents.cxx
index ca66f666f7f72..ea8a1976c1e5a 100644
--- a/GPU/GPUTracking/qa/genEvents.cxx
+++ b/GPU/GPUTracking/qa/genEvents.cxx
@@ -168,7 +168,6 @@ int32_t genEvents::GenerateEvent(const GPUParam& param, char* filename)
 
   GPUTPCGMPropagator prop;
   {
-    prop.SetToyMCEventsFlag(kTRUE);
     const GPUTPCGMMerger& merger = mRec->GetProcessors()->tpcMerger;
     prop.SetPolynomialField(&merger.Param().polynomialField);
   }

From 630393b32738dff1424f5d82e9ce8f9ef343d261 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 11:30:59 +0200
Subject: [PATCH 0407/1764] GPU: dAlpha can just be constexpr with OpenCL1 no
 longer used

---
 Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx      | 2 +-
 GPU/GPUTracking/Base/GPUParam.cxx                         | 7 +++----
 GPU/GPUTracking/Base/GPUParam.h                           | 4 +++-
 GPU/GPUTracking/Definitions/GPUSettingsList.h             | 1 -
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx                 | 2 +-
 .../SectorTracker/GPUTPCExtrapolationTracking.cxx         | 8 ++++----
 GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx      | 2 +-
 7 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
index cae835a99a2aa..7681380692033 100644
--- a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
+++ b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
@@ -265,7 +265,7 @@ void BarrelAlignmentSpec::updateTimeDependentParams(ProcessingContext& pc)
       prevField = newField;
       if (mDetMask[DetID::TPC]) {
         mTPCParam.reset(new o2::gpu::GPUParam);
-        mTPCParam->SetDefaults(o2::base::Propagator::Instance()->getNominalBz());
+        mTPCParam->SetDefaults(o2::base::Propagator::Instance()->getNominalBz(), false);
         mController->setTPCParam(mTPCParam.get());
       }
     }
diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index a4c4cb5844fa9..3062e1c4d2064 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -83,7 +83,6 @@ void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
   }
 #endif
 
-  par.dAlpha = 0.349066f;
   UpdateBzOnly(solenoidBz, assumeConstantBz);
   par.dodEdx = 0;
 
@@ -102,11 +101,11 @@ void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
     if (tmp >= GPUCA_NSECTORS / 4) {
       tmp -= GPUCA_NSECTORS / 2;
     }
-    SectorParam[i].Alpha = 0.174533f + par.dAlpha * tmp;
+    SectorParam[i].Alpha = 0.174533f + dAlpha * tmp;
     SectorParam[i].CosAlpha = CAMath::Cos(SectorParam[i].Alpha);
     SectorParam[i].SinAlpha = CAMath::Sin(SectorParam[i].Alpha);
-    SectorParam[i].AngleMin = SectorParam[i].Alpha - par.dAlpha / 2.f;
-    SectorParam[i].AngleMax = SectorParam[i].Alpha + par.dAlpha / 2.f;
+    SectorParam[i].AngleMin = SectorParam[i].Alpha - dAlpha / 2.f;
+    SectorParam[i].AngleMax = SectorParam[i].Alpha + dAlpha / 2.f;
   }
 
   par.continuousTracking = false;
diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 9b3340470a02f..2564fc9bf0462 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -47,6 +47,8 @@ namespace internal
 {
 template <class T, class S>
 struct GPUParam_t {
+  static constexpr float dAlpha = 0.349066f;
+
   T rec;
   S par;
 
@@ -92,7 +94,7 @@ struct GPUParam : public internal::GPUParam_t<GPUSettingsRec, GPUSettingsParam>
     if (iSector >= GPUCA_NSECTORS / 4) {
       iSector -= GPUCA_NSECTORS / 2;
     }
-    return 0.174533f + par.dAlpha * iSector;
+    return 0.174533f + dAlpha * iSector;
   }
   GPUd() float GetClusterErrorSeeding(int32_t yz, int32_t type, float zDiff, float angle2, float unscaledMult) const;
   GPUd() void GetClusterErrorsSeeding2(uint8_t sector, int32_t row, float z, float sinPhi, float DzDs, float time, float& ErrY2, float& ErrZ2) const;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 14a1d1d263c26..060c8495c1834 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -651,7 +651,6 @@ EndConfig()
 
 // Derrived parameters used in GPUParam
 BeginHiddenConfig(GPUSettingsParam, param)
-AddVariableRTC(dAlpha, float, 0.f)            // angular size
 AddVariableRTC(continuousTracking, int8_t, 0) // Continuous tracking, estimate bz and errors for abs(z) = 125cm during seeding
 AddVariableRTC(dodEdx, int8_t, 0)             // Do dEdx computation
 AddVariableRTC(earlyTpcTransform, int8_t, 0)  // do Early TPC transformation
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index ebfc29cb6f749..ab35e7f9a3c36 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -665,7 +665,7 @@ GPUd() void GPUTPCGMMerger::MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nT
 
   float fieldBz = Param().bzCLight;
 
-  float dAlpha = Param().par.dAlpha / 2;
+  float dAlpha = Param().dAlpha / 2;
   float x0 = 0;
 
   if (iBorder == 0) { // transport to the left edge of the sector and rotate horizontally
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
index 3ffead1c5902b..df998ca7cbb9a 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
@@ -129,11 +129,11 @@ GPUd() void GPUTPCExtrapolationTracking::PerformExtrapolationTracking(int32_t nB
         float Y = (float)tracker.Data().HitDataY(row, tracker.TrackHits()[tmpHit].HitIndex()) * row.HstepY() + row.Grid().YMin();
         if (!right && Y < -row.MaxY() * tracker.Param().rec.tpc.extrapolationTrackingYRangeLower) {
           // GPUInfo("Track %d, lower row %d, left border (%f of %f)", i, mTrackHits[tmpHit].RowIndex(), Y, -row.MaxY());
-          PerformExtrapolationTrackingRun(sectorTarget, smem, tracker, i, rowIndex, -tracker.Param().par.dAlpha, -1);
+          PerformExtrapolationTrackingRun(sectorTarget, smem, tracker, i, rowIndex, -tracker.Param().dAlpha, -1);
         }
         if (right && Y > row.MaxY() * tracker.Param().rec.tpc.extrapolationTrackingYRangeLower) {
           // GPUInfo("Track %d, lower row %d, right border (%f of %f)", i, mTrackHits[tmpHit].RowIndex(), Y, row.MaxY());
-          PerformExtrapolationTrackingRun(sectorTarget, smem, tracker, i, rowIndex, tracker.Param().par.dAlpha, -1);
+          PerformExtrapolationTrackingRun(sectorTarget, smem, tracker, i, rowIndex, tracker.Param().dAlpha, -1);
         }
       }
     }
@@ -146,11 +146,11 @@ GPUd() void GPUTPCExtrapolationTracking::PerformExtrapolationTracking(int32_t nB
         float Y = (float)tracker.Data().HitDataY(row, tracker.TrackHits()[tmpHit].HitIndex()) * row.HstepY() + row.Grid().YMin();
         if (!right && Y < -row.MaxY() * tracker.Param().rec.tpc.extrapolationTrackingYRangeUpper) {
           // GPUInfo("Track %d, upper row %d, left border (%f of %f)", i, mTrackHits[tmpHit].RowIndex(), Y, -row.MaxY());
-          PerformExtrapolationTrackingRun(sectorTarget, smem, tracker, i, rowIndex, -tracker.Param().par.dAlpha, 1);
+          PerformExtrapolationTrackingRun(sectorTarget, smem, tracker, i, rowIndex, -tracker.Param().dAlpha, 1);
         }
         if (right && Y > row.MaxY() * tracker.Param().rec.tpc.extrapolationTrackingYRangeUpper) {
           // GPUInfo("Track %d, upper row %d, right border (%f of %f)", i, mTrackHits[tmpHit].RowIndex(), Y, row.MaxY());
-          PerformExtrapolationTrackingRun(sectorTarget, smem, tracker, i, rowIndex, tracker.Param().par.dAlpha, 1);
+          PerformExtrapolationTrackingRun(sectorTarget, smem, tracker, i, rowIndex, tracker.Param().dAlpha, 1);
         }
       }
     }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
index 9a4d2eebcb953..6c3ffbb5120bc 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
@@ -41,7 +41,7 @@ void GPUTPCTrackingData::InitializeRows(const GPUParam& p)
   }
   for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
     mRows[i].mX = GPUTPCGeometry::Row2X(i);
-    mRows[i].mMaxY = CAMath::Tan(p.par.dAlpha / 2.f) * mRows[i].mX;
+    mRows[i].mMaxY = CAMath::Tan(p.dAlpha / 2.f) * mRows[i].mX;
   }
 }
 

From 8d032778d5522acb33fcdb1a3de9b8ce488f217a Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 23 May 2025 10:14:02 +0200
Subject: [PATCH 0408/1764] DPL: Explicitly printout the last file opened
 (#14318)

---
 .../AnalysisSupport/src/DataInputDirector.cxx  | 16 ++++++++++++++++
 .../AnalysisSupport/src/DataInputDirector.h    |  1 +
 Framework/AnalysisSupport/src/Plugin.cxx       | 18 ++++++++++++++++++
 3 files changed, 35 insertions(+)

diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index cfb5ca34b062b..16fe2fde412c4 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -146,6 +146,7 @@ bool DataInputDescriptor::setFile(int counter)
     throw std::runtime_error(fmt::format("Couldn't open file \"{}\"!", filename));
   }
   rootFS = std::dynamic_pointer_cast<TFileFileSystem>(mCurrentFilesystem);
+  printFileOpening();
 
   // get the parent file map if exists
   mParentFileMap = (TMap*)rootFS->GetFile()->Get("parentFiles"); // folder name (DF_XXX) --> parent file (absolute path)
@@ -297,6 +298,21 @@ int DataInputDescriptor::getReadTimeFramesInFile(int counter)
   return std::count(list.begin(), list.end(), true);
 }
 
+void DataInputDescriptor::printFileOpening()
+{
+  auto rootFS = std::dynamic_pointer_cast<TFileFileSystem>(mCurrentFilesystem);
+  auto f = dynamic_cast<TFile*>(rootFS->GetFile());
+  std::string monitoringInfo(fmt::format("lfn={},size={}", f->GetName(), f->GetSize()));
+#if __has_include(<TJAlienFile.h>)
+  auto alienFile = dynamic_cast<TJAlienFile*>(f);
+  if (alienFile) {
+    monitoringInfo += fmt::format(",se={},open_time={:.1f}", alienFile->GetSE(), alienFile->GetElapsed());
+  }
+#endif
+  mMonitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-open-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
+  LOGP(info, "Opening file: {}", monitoringInfo);
+}
+
 void DataInputDescriptor::printFileStatistics()
 {
   int64_t wait_time = (int64_t)uv_hrtime() - (int64_t)mCurrentFileStartedAt - (int64_t)mIOTime;
diff --git a/Framework/AnalysisSupport/src/DataInputDirector.h b/Framework/AnalysisSupport/src/DataInputDirector.h
index 9bab29db3ff24..94bdcf2c9368e 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.h
+++ b/Framework/AnalysisSupport/src/DataInputDirector.h
@@ -82,6 +82,7 @@ class DataInputDescriptor
 
   bool readTree(DataAllocator& outputs, header::DataHeader dh, int counter, int numTF, std::string treename, size_t& totalSizeCompressed, size_t& totalSizeUncompressed);
 
+  void printFileOpening();
   void printFileStatistics();
   void closeInputFile();
   bool isAlienSupportOn() { return mAlienSupport; }
diff --git a/Framework/AnalysisSupport/src/Plugin.cxx b/Framework/AnalysisSupport/src/Plugin.cxx
index 033adc461c600..68c4c1cb00d09 100644
--- a/Framework/AnalysisSupport/src/Plugin.cxx
+++ b/Framework/AnalysisSupport/src/Plugin.cxx
@@ -76,6 +76,24 @@ struct RunSummary : o2::framework::ServicePlugin {
               LOGP(info, "{}", files[fi % files.size()].data);
             }
           }
+          for (size_t li = 0; li < metrics.metricLabels.size(); ++li) {
+            MetricLabel const&label = metrics.metricLabels[li];
+            if (strcmp(label.label, "aod-file-open-info") != 0) {
+              continue;
+            }
+            MetricInfo const&metric = metrics.metrics[li];
+            auto &files = metrics.stringMetrics[metric.storeIdx];
+            if (metric.filledMetrics) {
+              LOGP(info, "### Files opened stats ###");
+            }
+            std::string lastFileRead;
+            for (size_t fi = 0; fi < metric.filledMetrics; ++fi) {
+              lastFileRead = files[fi % files.size()].data;
+            }
+            if (lastFileRead.empty() == false) {
+              LOGP(info, "Last file opened: {}", lastFileRead);
+            }
+          }
         } },
       .kind = ServiceKind::Serial};
   }

From a5bb3b42369cda6e802843f0515d3fbe2a8d91aa Mon Sep 17 00:00:00 2001
From: Marvin Hemmer <53471402+mhemmer-cern@users.noreply.github.com>
Date: Fri, 23 May 2025 11:56:27 +0200
Subject: [PATCH 0409/1764] [Run2,Converter]: fixes to naming to ensure
 compatibility (#14319)

PR #23830 from AliPhysics changed the name of the Mass column for OTFV0s. This PR changes the column name now here in O2.
---
 Framework/Core/include/Framework/AnalysisDataModel.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index 3216a24ed73a2..a2b0dc39950d4 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -1776,7 +1776,7 @@ DECLARE_SOA_COLUMN(Chi2NDF, chi2NDF, float);                            //! chi^
 DECLARE_SOA_COLUMN(PsiPair, psiPair, float);                            //! Psi pair
 DECLARE_SOA_COLUMN(DCAr, dcaR, float);                                  //! DCA in radial direction
 DECLARE_SOA_COLUMN(DCAz, dcaZ, float);                                  //! DCA in z direction
-DECLARE_SOA_COLUMN(Mass, mass, float);                                  //! mass of the conversion. Do NOT use for cut!
+DECLARE_SOA_COLUMN(MassInMeV, mass, float);                             //! mass of the conversion in MeV. Do NOT use for cut!
 } // namespace oftv0
 namespace pmd
 {
@@ -1824,7 +1824,7 @@ DECLARE_SOA_TABLE(Run2OTFV0s, "AOD", "Run2OTFV0", //! Run 2 V0 on the fly table
                   run2::oftv0::X, run2::oftv0::Y, run2::oftv0::Z,
                   run2::oftv0::Chi2NDF, run2::oftv0::PsiPair,
                   run2::oftv0::DCAr, run2::oftv0::DCAz,
-                  run2::oftv0::Mass);
+                  run2::oftv0::MassInMeV);
 
 using Run2OTFV0 = Run2OTFV0s::iterator;
 

From cc8a075c1325acafb372b2b679e0ba94e852d7b1 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 23 May 2025 12:34:55 +0200
Subject: [PATCH 0410/1764] Always check gGrid before calling TGrid::Connect to
 alien

Suppress local caches of the TGrid::Connect pointer. Muliple TGrid::Connect lead
to jalien connection loss.
---
 CCDB/src/CcdbApi.cxx                                |  8 ++++----
 Detectors/TRD/base/macros/OCDB2CCDB.C               | 13 ++++++++++++-
 Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C     | 13 ++++++++++++-
 Detectors/TRD/base/macros/PrintTrapConfig.C         | 13 ++++++++++++-
 Detectors/TRD/base/macros/Readocdb.C                | 13 ++++++++++++-
 Framework/AODMerger/src/aodMerger.cxx               |  4 +---
 Framework/AODMerger/src/aodThinner.cxx              |  2 +-
 Framework/AnalysisSupport/src/DataInputDirector.cxx |  2 +-
 Framework/AnalysisSupport/src/Plugin.cxx            |  4 ++--
 Generators/src/GeneratorFromFile.cxx                |  6 +++---
 10 files changed, 60 insertions(+), 18 deletions(-)

diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index c9d2fad882aa1..fa42d62cc3633 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -958,14 +958,14 @@ void* CcdbApi::extractFromLocalFile(std::string const& filename, std::type_info
 
 bool CcdbApi::initTGrid() const
 {
-  if (mNeedAlienToken && !mAlienInstance) {
+  if (mNeedAlienToken && !gGrid) {
     static bool allowNoToken = getenv("ALICEO2_CCDB_NOTOKENCHECK") && atoi(getenv("ALICEO2_CCDB_NOTOKENCHECK"));
     if (!allowNoToken && !checkAlienToken()) {
       LOG(fatal) << "Alien Token Check failed - Please get an alien token before running with https CCDB endpoint, or alice-ccdb.cern.ch!";
     }
-    mAlienInstance = TGrid::Connect("alien");
+    TGrid::Connect("alien");
     static bool errorShown = false;
-    if (!mAlienInstance && errorShown == false) {
+    if (!gGrid && errorShown == false) {
       if (allowNoToken) {
         LOG(error) << "TGrid::Connect returned nullptr. May be due to missing alien token";
       } else {
@@ -974,7 +974,7 @@ bool CcdbApi::initTGrid() const
       errorShown = true;
     }
   }
-  return mAlienInstance != nullptr;
+  return gGrid != nullptr;
 }
 
 void* CcdbApi::downloadFilesystemContent(std::string const& url, std::type_info const& tinfo, std::map<string, string>* headers) const
diff --git a/Detectors/TRD/base/macros/OCDB2CCDB.C b/Detectors/TRD/base/macros/OCDB2CCDB.C
index 0d7be94536bcd..f7723089bd5a6 100644
--- a/Detectors/TRD/base/macros/OCDB2CCDB.C
+++ b/Detectors/TRD/base/macros/OCDB2CCDB.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 // Use this macro to extract TRD calibration data from run2 for O2 calibrations class
 // Alot of this was taken from OCDBtoTree.C in AliRoot/TRD/macros/
 // Usage:
@@ -230,7 +241,7 @@ void OCDB2CCDB(long timeStamp = -1, TString ccdbPath = "http://localhost:8080",
   TTimeStamp jobStartTime;
   // if the storage is on alien than we need to do some extra stuff
   TString storageString(storageURI);
-  if (storageString.Contains("alien://")) {
+  if (storageString.Contains("alien://") && !gGrid) {
     TGrid::Connect("alien://");
   }
 
diff --git a/Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C b/Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C
index 36c8d7aa9aa1d..0b4d93906efb5 100644
--- a/Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C
+++ b/Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 // Use this macro to extract TRD calibration data from run2 for O2 calibrations class
 // Alot of this was taken from OCDBtoTree.C in AliRoot/TRD/macros/
 // Usage:
@@ -172,7 +183,7 @@ void OCDB2CCDBTrapConfig(TString ccdbPath = "http://localhost:8080", Int_t run =
   TTimeStamp jobStartTime;
   // if the storage is on alien than we need to do some extra stuff
   TString storageString(storageURI);
-  if (storageString.Contains("raw://")) {
+  if (storageString.Contains("raw://") && !gGrid) {
     TGrid::Connect("alien://");
   }
 
diff --git a/Detectors/TRD/base/macros/PrintTrapConfig.C b/Detectors/TRD/base/macros/PrintTrapConfig.C
index 949b8e4811b45..b9b0c3226dcc1 100644
--- a/Detectors/TRD/base/macros/PrintTrapConfig.C
+++ b/Detectors/TRD/base/macros/PrintTrapConfig.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 // Use this macro to extract TRD calibration data from run2 for O2 calibrations class
 // Alot of this was taken from OCDBtoTree.C in AliRoot/TRD/macros/
 // Usage:
@@ -200,7 +211,7 @@ void PrintTrapConfig(Int_t run, const Char_t* storageURI = "alien://folder=/alic
   TTimeStamp jobStartTime;
   // if the storage is on alien than we need to do some extra stuff
   TString storageString(storageURI);
-  if (storageString.Contains("alien://")) {
+  if (storageString.Contains("alien://") && !gGrid) {
     TGrid::Connect("alien://");
   }
 
diff --git a/Detectors/TRD/base/macros/Readocdb.C b/Detectors/TRD/base/macros/Readocdb.C
index c3e8c2978d789..55bea0c2e9cf2 100644
--- a/Detectors/TRD/base/macros/Readocdb.C
+++ b/Detectors/TRD/base/macros/Readocdb.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 // Use this macro to extract TRD calibration data from run2 for O2 calibrations class
 // Alot of this was taken from OCDBtoTree.C in AliRoot/TRD/macros/
 // Usage:
@@ -217,7 +228,7 @@ void Readocdb(Int_t run, const Char_t* storageURI = "alien://folder=/alice/data/
   TTimeStamp jobStartTime;
   // if the storage is on alien than we need to do some extra stuff
   TString storageString(storageURI);
-  if (storageString.Contains("alien://")) {
+  if (storageString.Contains("alien://") && !gGrid) {
     TGrid::Connect("alien://");
   }
 
diff --git a/Framework/AODMerger/src/aodMerger.cxx b/Framework/AODMerger/src/aodMerger.cxx
index aadf5cd2100c0..2be87274a928f 100644
--- a/Framework/AODMerger/src/aodMerger.cxx
+++ b/Framework/AODMerger/src/aodMerger.cxx
@@ -107,7 +107,6 @@ int main(int argc, char* argv[])
   std::ifstream in;
   in.open(inputCollection);
   TString line;
-  bool connectedToAliEn = false;
   TMap* metaData = nullptr;
   TMap* parentFiles = nullptr;
   int totalMergedDFs = 0;
@@ -119,10 +118,9 @@ int main(int argc, char* argv[])
       continue;
     }
 
-    if (line.BeginsWith("alien:") && !connectedToAliEn) {
+    if (line.BeginsWith("alien:") && !gGrid) {
       printf("Connecting to AliEn...");
       TGrid::Connect("alien:");
-      connectedToAliEn = true; // Only try once
     }
 
     printf("Processing input file: %s\n", line.Data());
diff --git a/Framework/AODMerger/src/aodThinner.cxx b/Framework/AODMerger/src/aodThinner.cxx
index 5da17032c80d4..e724595b94ba6 100644
--- a/Framework/AODMerger/src/aodThinner.cxx
+++ b/Framework/AODMerger/src/aodThinner.cxx
@@ -102,7 +102,7 @@ int main(int argc, char* argv[])
   }
   TDirectory* outputDir = nullptr;
 
-  if (inputFileName.find("alien:") == 0) {
+  if (inputFileName.find("alien:") == 0 && !gGrid) {
     printf("Connecting to AliEn...");
     TGrid::Connect("alien:");
   }
diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index 16fe2fde412c4..590329de146f7 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -114,7 +114,7 @@ void DataInputDescriptor::addFileNameHolder(FileNameHolder* fn)
   // remove leading file:// from file name
   if (fn->fileName.rfind("file://", 0) == 0) {
     fn->fileName.erase(0, 7);
-  } else if (!mAlienSupport && fn->fileName.rfind("alien://", 0) == 0) {
+  } else if (!mAlienSupport && fn->fileName.rfind("alien://", 0) == 0 && !gGrid) {
     LOGP(debug, "AliEn file requested. Enabling support.");
     TGrid::Connect("alien://");
     mAlienSupport = true;
diff --git a/Framework/AnalysisSupport/src/Plugin.cxx b/Framework/AnalysisSupport/src/Plugin.cxx
index 68c4c1cb00d09..548647c644636 100644
--- a/Framework/AnalysisSupport/src/Plugin.cxx
+++ b/Framework/AnalysisSupport/src/Plugin.cxx
@@ -192,7 +192,7 @@ struct DiscoverMetadataInAOD : o2::framework::ConfigDiscoveryPlugin {
           std::getline(file, filename);
           file.close();
         }
-        if (filename.rfind("alien://", 0) == 0) {
+        if (filename.rfind("alien://", 0) == 0 && !gGrid) {
           TGrid::Connect("alien://");
         }
         LOGP(info, "Loading metadata from file {} in PID {}", filename, getpid());
@@ -245,7 +245,7 @@ struct DiscoverMetadataInAOD : o2::framework::ConfigDiscoveryPlugin {
             }
           }
 
-          if (parentFilename.starts_with("alien://")) {
+          if (parentFilename.starts_with("alien://") && !gGrid) {
             TGrid::Connect("alien://");
           }
 
diff --git a/Generators/src/GeneratorFromFile.cxx b/Generators/src/GeneratorFromFile.cxx
index 66f7e03a4cf15..e2cd6d881b8b0 100644
--- a/Generators/src/GeneratorFromFile.cxx
+++ b/Generators/src/GeneratorFromFile.cxx
@@ -177,9 +177,9 @@ GeneratorFromO2Kine::GeneratorFromO2Kine(const char* name)
   setPositionUnit(1.);
   setTimeUnit(1.);
 
-  if (strncmp(name, "alien:/", 7) == 0) {
-    mAlienInstance = TGrid::Connect("alien");
-    if (!mAlienInstance) {
+  if (strncmp(name, "alien:/", 7) == 0 && !gGrid) {
+    TGrid::Connect("alien:");
+    if (!gGrid) {
       LOG(fatal) << "Could not connect to alien, did you check the alien token?";
       return;
     }

From f9c073b2ad4a4331d0cdcbd544812f7ba8745f0c Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Fri, 23 May 2025 17:52:13 +0200
Subject: [PATCH 0411/1764] Fix condition to disable V0/Cascade hypothesis in
 the SVertexer + other minor fix (#14324)

* Fix condition to disable V0/Cascade hypothesis in the SVertexer

* Fix some rejection status assignments
---
 Common/DCAFitter/include/DCAFitter/DCAFitterN.h             | 6 ++++--
 .../include/DetectorsVertexing/SVertexHypothesis.h          | 4 ++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
index aac451f1f8978..df732bd4bde63 100644
--- a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
+++ b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
@@ -142,6 +142,8 @@ class DCAFitterN
     FailInv2ndDeriv, // inversion of 2nd derivatives failed
     FailCorrTracks,  // correction of tracks to updated x failed
     FailCloserAlt,   // alternative PCA is closer
+    //
+    NStatusesDefined
   };
 
   static constexpr int getNProngs() { return N; }
@@ -989,7 +991,7 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2()
   }
 
   if (mMaxDZIni > 0 && !roughDZCut()) { // apply rough cut on tracks Z difference
-    mFitStatus[mCurHyp] = FitStatus::RejTrackX;
+    mFitStatus[mCurHyp] = FitStatus::RejTrackRoughZ;
     return false;
   }
 
@@ -1063,7 +1065,7 @@ GPUd() bool DCAFitterN<N, Args...>::minimizeChi2NoErr()
     setTrackPos(mTrPos[mCurHyp][i], mCandTr[mCurHyp][i]); // prepare positions
   }
   if (mMaxDZIni > 0 && !roughDZCut()) { // apply rough cut on tracks Z difference
-    mFitStatus[mCurHyp] = FitStatus::RejTrackX;
+    mFitStatus[mCurHyp] = FitStatus::RejTrackRoughZ;
     return false;
   }
 
diff --git a/Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h b/Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h
index c3fd74aa7eeff..bc6673288f752 100644
--- a/Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h
+++ b/Detectors/Vertexing/include/DetectorsVertexing/SVertexHypothesis.h
@@ -60,7 +60,7 @@ class SVertexHypothesis
 
   bool check(float p2Pos, float p2Neg, float p2V0, float ptV0) const
   { // check if given mass and pt is matching to hypothesis
-    return mPars[SigmaM] > 0 && check(calcMass(p2Pos, p2Neg, p2V0), ptV0);
+    return mPars[SigmaM] >= 0.f && check(calcMass(p2Pos, p2Neg, p2V0), ptV0);
   }
   bool check(float mass, float pt) const
   { // check if given mass and pt is matching to hypothesis
@@ -151,7 +151,7 @@ class SVertex3Hypothesis
 
   bool check(float p2Pos, float p2Neg, float p2Bach, float p2Tot, float ptV0) const
   { // check if given mass and pt is matching to hypothesis
-    return mPars[SigmaM] > 0 && check(calcMass(p2Pos, p2Neg, p2Bach, p2Tot), ptV0);
+    return mPars[SigmaM] >= 0.f && check(calcMass(p2Pos, p2Neg, p2Bach, p2Tot), ptV0);
   }
 
   bool check(float mass, float pt) const

From 396c94a4487f980bd8f69b87721013f88a42ebc9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 15:48:04 +0200
Subject: [PATCH 0412/1764] GPU Standalone: Add --absoluteEventsDir option

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  3 +-
 .../Standalone/Benchmark/standalone.cxx       | 32 ++++++++-----------
 GPU/GPUTracking/qa/genEvents.cxx              | 13 +++-----
 GPU/GPUTracking/qa/genEvents.h                |  8 ++---
 4 files changed, 24 insertions(+), 32 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 060c8495c1834..f7ff14ea188c4 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -556,7 +556,8 @@ AddOption(nEvents, int32_t, -1, "", 'n', "Number of events to process (-1; all)"
 AddOption(runs, int32_t, 1, "runs", 'r', "Number of iterations to perform (repeat each event)", min(0))
 AddOption(runs2, int32_t, 1, "runsExternal", 0, "Number of iterations to perform (repeat full processing)", min(1))
 AddOption(runsInit, int32_t, 1, "", 0, "Number of initial iterations excluded from average", min(0))
-AddOption(eventsDir, const char*, "pp", "events", 'e', "Directory with events to process", message("Reading events from Directory events/%s"))
+AddOption(eventsDir, const char*, "pp", "events", 'e', "Directory with events to process", message("Reading events from Directory %s"))
+AddOption(absoluteEventsDir, bool, false, "", 0, "Events directory is absolute, and not inside './events/'")
 AddOption(noEvents, bool, false, "", 0, "Run without data (e.g. for field visualization)")
 AddOption(eventDisplay, int32_t, 0, "display", 'd', "Show standalone event display", def(1))
 AddOption(eventGenerator, bool, false, "", 0, "Run event generator")
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 5277195752c56..95997a30034c9 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -74,6 +74,7 @@ extern GPUSettingsStandalone configStandalone;
 GPUReconstruction *rec, *recAsync, *recPipeline;
 GPUChainTracking *chainTracking, *chainTrackingAsync, *chainTrackingPipeline;
 GPUChainITS *chainITS, *chainITSAsync, *chainITSPipeline;
+std::string eventsDir;
 void unique_ptr_aligned_delete(char* v)
 {
   operator delete(v, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
@@ -277,21 +278,19 @@ int32_t ReadConfiguration(int argc, char** argv)
 int32_t SetupReconstruction()
 {
   if (!configStandalone.eventGenerator) {
-    char filename[256];
-    snprintf(filename, 256, "events/%s/", configStandalone.eventsDir);
     if (configStandalone.noEvents) {
-      configStandalone.eventsDir = "NON_EXISTING";
+      eventsDir = "NON_EXISTING";
       configStandalone.rundEdx = false;
-    } else if (rec->ReadSettings(filename)) {
+    } else if (rec->ReadSettings(eventsDir.c_str())) {
       printf("Error reading event config file\n");
       return 1;
     }
-    printf("Read event settings from dir %s (solenoidBz: %f, constBz %d, maxTimeBin %d)\n", filename, rec->GetGRPSettings().solenoidBzNominalGPU, (int32_t)rec->GetGRPSettings().constBz, rec->GetGRPSettings().grpContinuousMaxTimeBin);
+    printf("Read event settings from dir %s (solenoidBz: %f, constBz %d, maxTimeBin %d)\n", eventsDir.c_str(), rec->GetGRPSettings().solenoidBzNominalGPU, (int32_t)rec->GetGRPSettings().constBz, rec->GetGRPSettings().grpContinuousMaxTimeBin);
     if (configStandalone.testSyncAsync) {
-      recAsync->ReadSettings(filename);
+      recAsync->ReadSettings(eventsDir.c_str());
     }
     if (configStandalone.proc.doublePipeline) {
-      recPipeline->ReadSettings(filename);
+      recPipeline->ReadSettings(eventsDir.c_str());
     }
   }
 
@@ -504,23 +503,19 @@ int32_t SetupReconstruction()
 
 int32_t ReadEvent(int32_t n)
 {
-  char filename[256];
-  snprintf(filename, 256, "events/%s/" GPUCA_EVDUMP_FILE ".%d.dump", configStandalone.eventsDir, n);
   if (configStandalone.inputcontrolmem && !configStandalone.preloadEvents) {
     rec->SetInputControl(inputmemory.get(), configStandalone.inputcontrolmem);
   }
-  int32_t r = chainTracking->ReadData(filename);
+  int32_t r = chainTracking->ReadData((eventsDir + GPUCA_EVDUMP_FILE "." + std::to_string(n) + ".dump").c_str());
   if (r) {
     return r;
   }
 #if defined(GPUCA_TPC_GEOMETRY_O2) && defined(GPUCA_BUILD_QA) && !defined(GPUCA_O2_LIB)
   if ((configStandalone.proc.runQA || configStandalone.eventDisplay) && !configStandalone.QA.noMC) {
     chainTracking->ForceInitQA();
-    snprintf(filename, 256, "events/%s/mc.%d.dump", configStandalone.eventsDir, n);
     chainTracking->GetQA()->UpdateChain(chainTracking);
-    if (chainTracking->GetQA()->ReadO2MCData(filename)) {
-      snprintf(filename, 256, "events/%s/mc.%d.dump", configStandalone.eventsDir, 0);
-      if (chainTracking->GetQA()->ReadO2MCData(filename) && configStandalone.proc.runQA) {
+    if (chainTracking->GetQA()->ReadO2MCData((eventsDir + "mc." + std::to_string(n) + ".dump").c_str())) {
+      if (chainTracking->GetQA()->ReadO2MCData((eventsDir + "mc.0.dump").c_str()) && configStandalone.proc.runQA) {
         throw std::runtime_error("Error reading O2 MC dump");
       }
     }
@@ -725,6 +720,7 @@ int32_t main(int argc, char** argv)
   if (ReadConfiguration(argc, argv)) {
     return 1;
   }
+  eventsDir = std::string(configStandalone.absoluteEventsDir ? "" : "events/") + configStandalone.eventsDir + "/";
 
   GPUSettingsDeviceBackend deviceSet;
   deviceSet.deviceType = configStandalone.runGPU ? GPUDataTypes::GetDeviceType(configStandalone.gpuType.c_str()) : GPUDataTypes::DeviceType::CPU;
@@ -787,9 +783,7 @@ int32_t main(int argc, char** argv)
 
   for (nEventsInDirectory = 0; true; nEventsInDirectory++) {
     std::ifstream in;
-    char filename[256];
-    snprintf(filename, 256, "events/%s/" GPUCA_EVDUMP_FILE ".%d.dump", configStandalone.eventsDir, nEventsInDirectory);
-    in.open(filename, std::ifstream::binary);
+    in.open((eventsDir + GPUCA_EVDUMP_FILE "." + std::to_string(nEventsInDirectory) + ".dump").c_str(), std::ifstream::binary);
     if (in.fail()) {
       break;
     }
@@ -801,7 +795,7 @@ int32_t main(int argc, char** argv)
   }
 
   if (configStandalone.eventGenerator) {
-    genEvents::RunEventGenerator(chainTracking);
+    genEvents::RunEventGenerator(chainTracking, eventsDir);
     return 0;
   }
 
@@ -811,7 +805,7 @@ int32_t main(int argc, char** argv)
   } else {
     if (nEvents == -1 || nEvents > nEventsInDirectory) {
       if (nEvents >= 0) {
-        printf("Only %d events available in directors %s (%d events requested)\n", nEventsInDirectory, configStandalone.eventsDir, nEvents);
+        printf("Only %d events available in directory %s (%d events requested)\n", nEventsInDirectory, eventsDir.c_str(), nEvents);
       }
       nEvents = nEventsInDirectory;
     }
diff --git a/GPU/GPUTracking/qa/genEvents.cxx b/GPU/GPUTracking/qa/genEvents.cxx
index ea8a1976c1e5a..6832e48fe17da 100644
--- a/GPU/GPUTracking/qa/genEvents.cxx
+++ b/GPU/GPUTracking/qa/genEvents.cxx
@@ -149,7 +149,7 @@ void genEvents::FinishEventGenerator()
   }
 }
 
-int32_t genEvents::GenerateEvent(const GPUParam& param, char* filename)
+int32_t genEvents::GenerateEvent(const GPUParam& param, const char* filename)
 {
   mRec->ClearIOPointers();
   static int32_t iEvent = -1;
@@ -354,20 +354,17 @@ int32_t genEvents::GenerateEvent(const GPUParam& param, char* filename)
   return (0);
 }
 
-void genEvents::RunEventGenerator(GPUChainTracking* rec)
+void genEvents::RunEventGenerator(GPUChainTracking* rec, const std::string& dir)
 {
   std::unique_ptr<genEvents> gen(new genEvents(rec));
-  char dirname[256];
-  snprintf(dirname, 256, "events/%s/", configStandalone.eventsDir);
-  mkdir(dirname, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-  rec->DumpSettings(dirname);
+  mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+  rec->DumpSettings(dir.c_str());
 
   gen->InitEventGenerator();
 
   for (int32_t i = 0; i < (configStandalone.nEvents == -1 ? 10 : configStandalone.nEvents); i++) {
     GPUInfo("Generating event %d/%d", i, configStandalone.nEvents == -1 ? 10 : configStandalone.nEvents);
-    snprintf(dirname, 256, "events/%s/" GPUCA_EVDUMP_FILE ".%d.dump", configStandalone.eventsDir, i);
-    gen->GenerateEvent(rec->GetParam(), dirname);
+    gen->GenerateEvent(rec->GetParam(), (dir + GPUCA_EVDUMP_FILE "." + std::to_string(i) + ".dump").c_str());
   }
   gen->FinishEventGenerator();
 }
diff --git a/GPU/GPUTracking/qa/genEvents.h b/GPU/GPUTracking/qa/genEvents.h
index 43b946e6238b2..abf1742b48e88 100644
--- a/GPU/GPUTracking/qa/genEvents.h
+++ b/GPU/GPUTracking/qa/genEvents.h
@@ -28,10 +28,10 @@ class genEvents
  public:
   genEvents(GPUChainTracking* rec) {}
   void InitEventGenerator() {}
-  int32_t GenerateEvent(const GPUParam& sectorParam, char* filename) { return 1; }
+  int32_t GenerateEvent(const GPUParam& sectorParam, const char* filename) { return 1; }
   void FinishEventGenerator() {}
 
-  static void RunEventGenerator(GPUChainTracking* rec) {};
+  static void RunEventGenerator(GPUChainTracking* rec, const std::string& dir) {};
 };
 
 #else
@@ -41,10 +41,10 @@ class genEvents
  public:
   genEvents(GPUChainTracking* rec) : mRec(rec) {}
   void InitEventGenerator();
-  int32_t GenerateEvent(const GPUParam& sectorParam, char* filename);
+  int32_t GenerateEvent(const GPUParam& sectorParam, const char* filename);
   void FinishEventGenerator();
 
-  static void RunEventGenerator(GPUChainTracking* rec);
+  static void RunEventGenerator(GPUChainTracking* rec, const std::string& dir);
 
  private:
   int32_t GetSector(double GlobalPhi);

From e3829461a7f5df0eb3ad1854160e01e76feb911f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 22 May 2025 16:27:37 +0200
Subject: [PATCH 0413/1764] GPU: Add GPUCA_RTC_NO_COMPILED_KERNELS debug option

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      | 40 ++++++++--------
 .../Base/cuda/GPUReconstructionCUDA.cu        |  7 +++
 GPU/GPUTracking/Base/hip/CMakeLists.txt       | 46 ++++++++++---------
 GPU/GPUTracking/Standalone/cmake/config.cmake |  1 +
 4 files changed, 55 insertions(+), 39 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 97972265b3007..eff3e201f7863 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -159,25 +159,29 @@ endif()
 if(GPUCA_CUDA_COMPILE_MODE STREQUAL "onefile")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=0)
 elseif(GPUCA_CUDA_COMPILE_MODE STREQUAL "perkernel")
-  add_library(GPUTrackingCUDAKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.cu>, >)
-  set_property(TARGET GPUTrackingCUDAKernels PROPERTY CUDA_FATBIN_COMPILATION ON)
-  set_property(TARGET GPUTrackingCUDAKernels PROPERTY CUDA_SEPARABLE_COMPILATION OFF)
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=1)
-  target_compile_definitions(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},COMPILE_DEFINITIONS>)
-  target_include_directories(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},INCLUDE_DIRECTORIES>)
-  target_link_libraries(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},LINK_LIBRARIES>)
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/cuda_kernel_module_fatbin)
-  add_custom_command(
-    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o
-    COMMAND cp -u $<TARGET_OBJECTS:GPUTrackingCUDAKernels> ${CMAKE_CURRENT_BINARY_DIR}/cuda_kernel_module_fatbin/
-    COMMAND ${CMAKE_LINKER} -z noexecstack --relocatable --format binary --output ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o $<PATH:RELATIVE_PATH,$<LIST:TRANSFORM,$<PATH:GET_FILENAME,$<TARGET_OBJECTS:GPUTrackingCUDAKernels>>,PREPEND,${CMAKE_CURRENT_BINARY_DIR}/cuda_kernel_module_fatbin/>,${CMAKE_CURRENT_BINARY_DIR}>
-    DEPENDS GPUTrackingCUDAKernels $<TARGET_OBJECTS:GPUTrackingCUDAKernels>
-    COMMENT "Compiling fatbin kernels ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o"
-    VERBATIM
-    COMMAND_EXPAND_LISTS
-  )
-  target_sources(${targetName} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o)
-  set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o PROPERTIES EXTERNAL_OBJECT true GENERATED true)
+  if(NOT DEFINED GPUCA_RTC_NO_COMPILED_KERNELS OR NOT GPUCA_RTC_NO_COMPILED_KERNELS)
+    add_library(GPUTrackingCUDAKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.cu>, >)
+    set_property(TARGET GPUTrackingCUDAKernels PROPERTY CUDA_FATBIN_COMPILATION ON)
+    set_property(TARGET GPUTrackingCUDAKernels PROPERTY CUDA_SEPARABLE_COMPILATION OFF)
+    target_compile_definitions(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},COMPILE_DEFINITIONS>)
+    target_include_directories(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},INCLUDE_DIRECTORIES>)
+    target_link_libraries(GPUTrackingCUDAKernels PRIVATE $<TARGET_PROPERTY:${targetName},LINK_LIBRARIES>)
+    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/cuda_kernel_module_fatbin)
+    add_custom_command(
+      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o
+      COMMAND cp -u $<TARGET_OBJECTS:GPUTrackingCUDAKernels> ${CMAKE_CURRENT_BINARY_DIR}/cuda_kernel_module_fatbin/
+      COMMAND ${CMAKE_LINKER} -z noexecstack --relocatable --format binary --output ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o $<PATH:RELATIVE_PATH,$<LIST:TRANSFORM,$<PATH:GET_FILENAME,$<TARGET_OBJECTS:GPUTrackingCUDAKernels>>,PREPEND,${CMAKE_CURRENT_BINARY_DIR}/cuda_kernel_module_fatbin/>,${CMAKE_CURRENT_BINARY_DIR}>
+      DEPENDS GPUTrackingCUDAKernels $<TARGET_OBJECTS:GPUTrackingCUDAKernels>
+      COMMENT "Compiling fatbin kernels ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o"
+      VERBATIM
+      COMMAND_EXPAND_LISTS
+    )
+    target_sources(${targetName} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o)
+    set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingCUDAKernelModules.o PROPERTIES EXTERNAL_OBJECT true GENERATED true)
+  else()
+    set_source_files_properties(GPUReconstructionCUDA.cu PROPERTIES COMPILE_DEFINITIONS GPUCA_RTC_NO_COMPILED_KERNELS)
+  endif()
 
 elseif(GPUCA_CUDA_COMPILE_MODE STREQUAL "rdc")
   message(FATAL_ERROR "CUDA RDC compilation of GPUReconstruction ios not yet working!")
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 0d5666b8ee790..7552d22056c3c 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -34,7 +34,11 @@
 #else // HIP
 #define PER_KERNEL_OBJECT_EXT _hip_o
 #endif
+#ifdef GPUCA_RTC_NO_COMPILED_KERNELS
+#define GPUCA_KRNL(x_class, ...) static void* GPUCA_M_CAT3(_binary_cuda_kernel_module_fatbin_krnl_, GPUCA_M_KRNL_NAME(x_class), GPUCA_M_CAT(PER_KERNEL_OBJECT_EXT, _start)) = nullptr;
+#else
 #define GPUCA_KRNL(x_class, ...) QGET_LD_BINARY_SYMBOLS(GPUCA_M_CAT3(cuda_kernel_module_fatbin_krnl_, GPUCA_M_KRNL_NAME(x_class), PER_KERNEL_OBJECT_EXT))
+#endif
 #include "GPUReconstructionKernelList.h"
 #undef GPUCA_KRNL
 #endif
@@ -335,6 +339,9 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     }
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE == 1
     else {
+#ifdef GPUCA_RTC_NO_COMPILED_KERNELS
+      GPUFatal("Compiled with GPUCA_RTC_NO_COMPILED_KERNELS, must run RTC mode!");
+#endif
 #define GPUCA_KRNL(x_class, ...)                                        \
   mInternals->kernelModules.emplace_back(std::make_unique<CUmodule>()); \
   GPUChkErr(cuModuleLoadData(mInternals->kernelModules.back().get(), GPUCA_M_CAT3(_binary_cuda_kernel_module_fatbin_krnl_, GPUCA_M_KRNL_NAME(x_class), GPUCA_M_CAT(PER_KERNEL_OBJECT_EXT, _start))));
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 04a65922ad453..82922382deddc 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -223,29 +223,33 @@ endif()
 if(GPUCA_HIP_COMPILE_MODE STREQUAL "onefile")
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=0)
 elseif(GPUCA_HIP_COMPILE_MODE STREQUAL "perkernel")
-  add_library(GPUTrackingHIPKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.hip>, >)
-  target_compile_options(GPUTrackingHIPKernels PRIVATE "--cuda-device-only")
-  target_compile_options(GPUTrackingHIPKernels PRIVATE $<$<COMPILE_LANGUAGE:HIP>:-fno-gpu-rdc>)
-  target_link_options(GPUTrackingHIPKernels PRIVATE $<$<COMPILE_LANGUAGE:HIP>:-fno-gpu-rdc>)
   target_compile_definitions(${targetName} PRIVATE GPUCA_KERNEL_COMPILE_MODE=1)
-  target_compile_definitions(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},COMPILE_DEFINITIONS>)
-  target_include_directories(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},INCLUDE_DIRECTORIES>)
-  target_link_libraries(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},LINK_LIBRARIES>)
-  if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
-    add_dependencies(GPUTrackingHIPKernels ${MODULE}_HIPIFIED)
+  if(NOT DEFINED GPUCA_RTC_NO_COMPILED_KERNELS OR NOT GPUCA_RTC_NO_COMPILED_KERNELS)
+    add_library(GPUTrackingHIPKernels OBJECT $<JOIN:$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<LIST:TRANSFORM,$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNEL_NAMES>,REPLACE,[^A-Za-z0-9]+,_>,PREPEND,${O2_GPU_KERNEL_WRAPPER_FOLDER}/krnl_>,APPEND,.hip>, >)
+    target_compile_options(GPUTrackingHIPKernels PRIVATE "--cuda-device-only")
+    target_compile_options(GPUTrackingHIPKernels PRIVATE $<$<COMPILE_LANGUAGE:HIP>:-fno-gpu-rdc>)
+    target_link_options(GPUTrackingHIPKernels PRIVATE $<$<COMPILE_LANGUAGE:HIP>:-fno-gpu-rdc>)
+    target_compile_definitions(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},COMPILE_DEFINITIONS>)
+    target_include_directories(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},INCLUDE_DIRECTORIES>)
+    target_link_libraries(GPUTrackingHIPKernels PRIVATE $<TARGET_PROPERTY:${targetName},LINK_LIBRARIES>)
+    if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
+      add_dependencies(GPUTrackingHIPKernels ${MODULE}_HIPIFIED)
+    endif()
+    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/hip_kernel_module_fatbin)
+    add_custom_command(
+      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o
+      COMMAND cp -u $<TARGET_OBJECTS:GPUTrackingHIPKernels> ${CMAKE_CURRENT_BINARY_DIR}/hip_kernel_module_fatbin/
+      COMMAND ${CMAKE_LINKER} -z noexecstack --relocatable --format binary --output ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o $<PATH:RELATIVE_PATH,$<LIST:TRANSFORM,$<PATH:GET_FILENAME,$<TARGET_OBJECTS:GPUTrackingHIPKernels>>,PREPEND,${CMAKE_CURRENT_BINARY_DIR}/hip_kernel_module_fatbin/>,${CMAKE_CURRENT_BINARY_DIR}>
+      DEPENDS GPUTrackingHIPKernels $<TARGET_OBJECTS:GPUTrackingHIPKernels>
+      COMMENT "Compiling fatbin kernels ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o"
+      VERBATIM
+      COMMAND_EXPAND_LISTS
+    )
+    target_sources(${targetName} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o)
+    set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o PROPERTIES EXTERNAL_OBJECT true GENERATED true)
+  else()
+    set_source_files_properties(${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIP.hip PROPERTIES COMPILE_DEFINITIONS GPUCA_RTC_NO_COMPILED_KERNELS)
   endif()
-  file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/hip_kernel_module_fatbin)
-  add_custom_command(
-    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o
-    COMMAND cp -u $<TARGET_OBJECTS:GPUTrackingHIPKernels> ${CMAKE_CURRENT_BINARY_DIR}/hip_kernel_module_fatbin/
-    COMMAND ${CMAKE_LINKER} -z noexecstack --relocatable --format binary --output ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o $<PATH:RELATIVE_PATH,$<LIST:TRANSFORM,$<PATH:GET_FILENAME,$<TARGET_OBJECTS:GPUTrackingHIPKernels>>,PREPEND,${CMAKE_CURRENT_BINARY_DIR}/hip_kernel_module_fatbin/>,${CMAKE_CURRENT_BINARY_DIR}>
-    DEPENDS GPUTrackingHIPKernels $<TARGET_OBJECTS:GPUTrackingHIPKernels>
-    COMMENT "Compiling fatbin kernels ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o"
-    VERBATIM
-    COMMAND_EXPAND_LISTS
-  )
-  target_sources(${targetName} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o)
-  set_source_files_properties(${CMAKE_CURRENT_BINARY_DIR}/GPUTrackingHIPKernelModules.o PROPERTIES EXTERNAL_OBJECT true GENERATED true)
 
 elseif(GPUCA_HIP_COMPILE_MODE STREQUAL "rdc")
   message(FATAL_ERROR "HIP RDC compilation of GPUReconstruction ios not yet working!")
diff --git a/GPU/GPUTracking/Standalone/cmake/config.cmake b/GPU/GPUTracking/Standalone/cmake/config.cmake
index 0c7544aff7035..77ce9c9e77fca 100644
--- a/GPU/GPUTracking/Standalone/cmake/config.cmake
+++ b/GPU/GPUTracking/Standalone/cmake/config.cmake
@@ -35,6 +35,7 @@ set(HIP_AMDGPUTARGET "default")             # "gfx906;gfx908;gfx90a"
 set(CUDA_COMPUTETARGET "default")           # 86 89
 #set(GPUCA_CUDA_COMPILE_MODE perkernel)     # onefile / perkernel / rtc
 #set(GPUCA_HIP_COMPILE_MODE perkernel)
+#set(GPUCA_RTC_NO_COMPILED_KERNELS 1)
 #set(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE 1)
 #set(GPUCA_CONFIG_COMPILER gcc)             # gcc / clang
 #add_definitions(-DGPUCA_GPU_DEBUG_PRINT)

From 9babfd42523808f308e36d45f4739e07931b6902 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 23 May 2025 09:44:09 +0200
Subject: [PATCH 0414/1764] GPU CMake: Switch from IMPLICIT_DEPENDS to DEPFILE
 and -MT -MD -MF, as ninja does not support IMPLICIT_DEPENDS

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt               |  5 +++--
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx          |  2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt                |  8 ++++----
 GPU/GPUTracking/Base/opencl/CMakeLists.txt             | 10 ++++++----
 GPU/GPUTracking/cmake/vulkan_display.cmake             |  4 ++--
 5 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index eff3e201f7863..0e9831e26d494 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -70,9 +70,10 @@ add_custom_command(
     COMMAND cp ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPU_RTC_BIN}.src
     COMMAND cat ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h | grep -v GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
+    COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -M -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d ${GPU_RTC_SRC}
     COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -E -Xcompiler "-nostdinc -P" ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
-    MAIN_DEPENDENCY ${GPU_RTC_SRC}
-    IMPLICIT_DEPENDS CXX ${GPU_RTC_SRC}
+    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h
+    DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
     COMMENT "Preparing CUDA RTC source file ${GPU_RTC_BIN}.src"
 )
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index acc77648d954b..b5a3b1bb919b9 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -131,7 +131,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
           }
           return 0;
         };
-        if (checkSHA(shasource, "source") ||
+        if (checkSHA(shasource, "source") || // TODO: CHECK VERSION!
             checkSHA(shaparam, "param") ||
             checkSHA(shacmd, "command line") ||
             checkSHA(shakernels, "kernel definitions") ||
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 82922382deddc..5acbaa28bf36f 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -116,10 +116,10 @@ add_custom_command(
     OUTPUT ${GPU_RTC_BIN}.src
     COMMAND cp ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPU_RTC_BIN}.src
     COMMAND cat ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h | grep -v GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
-    COMMAND ${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
-    MAIN_DEPENDENCY ${GPU_RTC_SRC}
-    IMPLICIT_DEPENDS CXX ${GPU_RTC_SRC}
-    DEPENDS ${MODULE}_HIPIFIED
+    COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
+    COMMAND ${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d >> ${GPU_RTC_BIN}.src
+    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h ${MODULE}_HIPIFIED
+    DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
     COMMENT "Preparing HIP RTC source file ${GPU_RTC_BIN}.src"
 )
diff --git a/GPU/GPUTracking/Base/opencl/CMakeLists.txt b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
index 1a8a739adbecf..ef83afc9280c9 100644
--- a/GPU/GPUTracking/Base/opencl/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/opencl/CMakeLists.txt
@@ -61,9 +61,10 @@ if(OPENCL_ENABLED_SPIRV) # BUILD OpenCL intermediate code for SPIR-V target
               -ferror-limit=1000 -Wno-invalid-constexpr -Wno-unused-command-line-argument
               ${OCL_FLAGS}
               ${OCL_DEFINECL}
+              -MD -MT ${CL_BIN}.spirv -MF ${CL_BIN}.spirv.d
               -o ${CL_BIN}.spirv -c ${CL_SRC}
-      MAIN_DEPENDENCY ${CL_SRC}
-      IMPLICIT_DEPENDS CXX ${CL_SRC}
+      DEPENDS ${CL_SRC}
+      DEPFILE ${CL_BIN}.spirv.d
       COMMAND_EXPAND_LISTS
       COMMENT "Compiling OpenCL CL source file ${CL_SRC} to SPIRV ${CL_BIN}.spirv")
 
@@ -82,9 +83,10 @@ if(OPENCL_ENABLED) # BUILD OpenCL source code for runtime compilation target
               ${OCL_DEFINECL}
               -cl-no-stdinc
               -nostdinc
+              -MD -MT ${CL_BIN}.src -MF ${CL_BIN}.src.d
               -E -P ${CL_SRC} > ${CL_BIN}.src
-      MAIN_DEPENDENCY ${CL_SRC}
-      IMPLICIT_DEPENDS CXX ${CL_SRC}
+      DEPENDS ${CL_SRC}
+      DEPFILE ${CL_BIN}.src.d
       COMMAND_EXPAND_LISTS
       COMMENT "Preparing OpenCL CL source file for run time compilation ${CL_BIN}.src")
 
diff --git a/GPU/GPUTracking/cmake/vulkan_display.cmake b/GPU/GPUTracking/cmake/vulkan_display.cmake
index 0e033970623b7..7cbfd0328c323 100644
--- a/GPU/GPUTracking/cmake/vulkan_display.cmake
+++ b/GPU/GPUTracking/cmake/vulkan_display.cmake
@@ -25,9 +25,9 @@ function(add_glslc_shader TARGET SHADER)
 
     add_custom_command(
         OUTPUT ${spirv-file}
-        COMMAND ${Vulkan_GLSLC_EXECUTABLE} -o ${spirv-file} ${input-file-abs}
+        COMMAND ${Vulkan_GLSLC_EXECUTABLE} -o ${spirv-file} ${input-file-abs} -MD -MT ${spirv-file} -MF ${spirv-file}.d
         DEPENDS ${input-file-abs}
-        IMPLICIT_DEPENDS CXX ${input-file-abs}
+        DEPFILE ${input-file-abs}.d
         COMMENT "Compiling GLSL to SPIRV: ${SHADER}"
         VERBATIM
     )

From ab8bcd768ea614f0465c2f19cf223768c6d74486 Mon Sep 17 00:00:00 2001
From: Mario Sitta <mario6829@gmail.com>
Date: Thu, 22 May 2025 12:05:42 +0200
Subject: [PATCH 0415/1764] Barrel geometry: Implementation of MFT rail hinges

---
 .../simulation/include/ITSSimulation/V3Cage.h |  16 +++
 .../ITSMFT/ITS/simulation/src/V3Cage.cxx      | 136 ++++++++++++++++--
 2 files changed, 142 insertions(+), 10 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Cage.h b/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Cage.h
index 44d72284112c2..7844f42601a47 100644
--- a/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Cage.h
+++ b/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Cage.h
@@ -123,6 +123,10 @@ class V3Cage : public V11Geometry
   /// \param mgr  The GeoManager (used only to get the proper material)
   TGeoVolume* createMFTRailsPair(const TGeoMedium* motmed, const TGeoManager* mgr = gGeoManager);
 
+  /// Creates a hinge holding a pair of MFT rails inside the Cage
+  /// \param mgr  The GeoManager (used only to get the proper material)
+  TGeoVolume* createMFTRailsHinge(const TGeoManager* mgr = gGeoManager);
+
   // Parameters
   static const Double_t sCageYInBarrel; ///< Global Y translation
 
@@ -256,6 +260,7 @@ class V3Cage : public V11Geometry
 
   // MFT Rails inside the Cage
   static const Double_t sCageMFTRailZLen;      ///< Total length of the rail
+  static const Double_t sCageMFTRailZPos;      ///< Rail global Z position
   static const Double_t sCageMFTRailTotWidth;  ///< Total width of the rail
   static const Double_t sCageMFTRailExtWidth;  ///< Width of the external part
   static const Double_t sCageMFTRailIntWidth;  ///< Width of the internal part
@@ -265,6 +270,17 @@ class V3Cage : public V11Geometry
   static const Double_t sCageMFTRailIntHeight; ///< Height of the internal part
   static const Double_t sCageMFTRailsXDist;    ///< X distance between rails
 
+  // MFT Rail hinges
+  static const Double_t sCageMFTHingeTotWid;   ///< Total width of a hinge
+  static const Double_t sCageMFTHingeIntWid;   ///< Width of hinge inner part
+  static const Double_t sCageMFTHingeHeight;   ///< Total height of the rail
+  static const Double_t sCageMFTHingeIntHei;   ///< Height of hinge inner part
+  static const Double_t sCageMFTHingeTotLen;   ///< Total length of a hinge
+  static const Double_t sCageMFTHingeIntLen;   ///< Length of hinge inner part
+  static const Double_t sCageMFTHingeBulgeWid; ///< Width of a hinge bulge
+  static const Double_t sCageMFTHingeBulgeHei; ///< Height of a hinge bulge
+  static const Double_t sCageMFTHingeBulgePos; ///< X position of a hinge bulge
+
   ClassDefOverride(V3Cage, 0); // ITS v3 support geometry
 };
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/simulation/src/V3Cage.cxx b/Detectors/ITSMFT/ITS/simulation/src/V3Cage.cxx
index 528b74dc339f1..bd9ce1cd333a2 100644
--- a/Detectors/ITSMFT/ITS/simulation/src/V3Cage.cxx
+++ b/Detectors/ITSMFT/ITS/simulation/src/V3Cage.cxx
@@ -167,7 +167,9 @@ const Double_t V3Cage::sCageCrossZLength = 8 * sMm;
 const Double_t V3Cage::sCageCrossBarThick = 20 * sMm;
 const Double_t V3Cage::sCageCrossBarPhi = 25; // Deg
 
-const Double_t V3Cage::sCageMFTRailZLen = 1807 * sMm;
+// MFT rails inside Cage
+const Double_t V3Cage::sCageMFTRailZLen = 1874 * sMm;
+const Double_t V3Cage::sCageMFTRailZPos = 6.3 * sMm;
 const Double_t V3Cage::sCageMFTRailTotWidth = 27 * sMm;
 const Double_t V3Cage::sCageMFTRailExtWidth = 24 * sMm;
 const Double_t V3Cage::sCageMFTRailIntWidth = 17.5 * sMm;
@@ -177,6 +179,16 @@ const Double_t V3Cage::sCageMFTRailExtHeight = 5.9 * sMm;
 const Double_t V3Cage::sCageMFTRailIntHeight = 3.5 * sMm;
 const Double_t V3Cage::sCageMFTRailsXDist = 44 * sMm;
 
+const Double_t V3Cage::sCageMFTHingeTotWid = 164 * sMm;
+const Double_t V3Cage::sCageMFTHingeIntWid = 141.3 * sMm;
+const Double_t V3Cage::sCageMFTHingeHeight = 8 * sMm;
+const Double_t V3Cage::sCageMFTHingeIntHei = 6 * sMm;
+const Double_t V3Cage::sCageMFTHingeTotLen = 41 * sMm;
+const Double_t V3Cage::sCageMFTHingeIntLen = 28 * sMm;
+const Double_t V3Cage::sCageMFTHingeBulgeWid = 10 * sMm;
+const Double_t V3Cage::sCageMFTHingeBulgeHei = 10 * sMm;
+const Double_t V3Cage::sCageMFTHingeBulgePos = 7 * sMm;
+
 ClassImp(V3Cage);
 
 V3Cage::V3Cage()
@@ -1676,15 +1688,19 @@ void V3Cage::createAndPlaceMFTRailsInsideCage(TGeoVolume* mother, const TGeoMana
   // Return:
   //
   // Created:      10 May 2025  Mario Sitta
+  // Updated:      20 May 2025  Mario Sitta   Hinges added
   //
 
   // Local variables
-  Double_t rdist, rpos, xpos, ypos, alpha;
+  Double_t rdist, rpos, xpos, yposup, yposdw, zpos, alpha;
   Double_t xbox, ybox;
 
   // Create a pair of rails (a BBox container is returned)
   TGeoVolume* cageMFTRails = createMFTRailsPair(mother->GetMedium(), mgr);
 
+  // Create hinge holding a pair of rails
+  TGeoVolume* cageMFTRailsHinge = createMFTRailsHinge(mgr);
+
   // Now compute the radial distance and the XY position of the box
   xbox = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDX();
   ybox = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDY();
@@ -1694,19 +1710,39 @@ void V3Cage::createAndPlaceMFTRailsInsideCage(TGeoVolume* mother, const TGeoMana
 
   // Finally place the four pairs of rails inside the mother volume
   xpos = rpos * TMath::Sin(sCageEndCapCableCutPhi * TMath::DegToRad());
-  ypos = rpos * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) + sCageYInBarrel;
+  yposup = rpos * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) + sCageYInBarrel;
+  yposdw = rpos * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) - sCageYInBarrel;
+  zpos = sCageMFTRailZPos;
 
   alpha = -sCageEndCapCableCutPhi + 180;
-  mother->AddNode(cageMFTRails, 1, new TGeoCombiTrans(xpos, ypos, 0, new TGeoRotation("", alpha, 0, 0)));
+  mother->AddNode(cageMFTRails, 1, new TGeoCombiTrans(xpos, yposup, zpos, new TGeoRotation("", alpha, 0, 0)));
   alpha = sCageEndCapCableCutPhi + 180;
-  mother->AddNode(cageMFTRails, 2, new TGeoCombiTrans(-xpos, ypos, 0, new TGeoRotation("", alpha, 0, 0)));
-
-  ypos = rpos * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) - sCageYInBarrel;
+  mother->AddNode(cageMFTRails, 2, new TGeoCombiTrans(-xpos, yposup, zpos, new TGeoRotation("", alpha, 0, 0)));
 
   alpha = sCageEndCapCableCutPhi;
-  mother->AddNode(cageMFTRails, 3, new TGeoCombiTrans(xpos, -ypos, 0, new TGeoRotation("", alpha, 0, 0)));
+  mother->AddNode(cageMFTRails, 3, new TGeoCombiTrans(xpos, -yposdw, zpos, new TGeoRotation("", alpha, 0, 0)));
   alpha = -sCageEndCapCableCutPhi;
-  mother->AddNode(cageMFTRails, 4, new TGeoCombiTrans(-xpos, -ypos, 0, new TGeoRotation("", alpha, 0, 0)));
+  mother->AddNode(cageMFTRails, 4, new TGeoCombiTrans(-xpos, -yposdw, zpos, new TGeoRotation("", alpha, 0, 0)));
+
+  // And the hinges too
+  xpos = rdist * TMath::Sin(sCageEndCapCableCutPhi * TMath::DegToRad());
+  yposup = rdist * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) + sCageYInBarrel;
+  yposdw = rdist * TMath::Cos(sCageEndCapCableCutPhi * TMath::DegToRad()) - sCageYInBarrel;
+  zpos = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDZ() + sCageMFTRailZPos;
+
+  alpha = sCageEndCapCableCutPhi;
+  mother->AddNode(cageMFTRailsHinge, 1, new TGeoCombiTrans(xpos, yposup, zpos, new TGeoRotation("", -alpha, 0, 0)));
+  mother->AddNode(cageMFTRailsHinge, 2, new TGeoCombiTrans(-xpos, yposup, zpos, new TGeoRotation("", alpha, 0, 0)));
+
+  mother->AddNode(cageMFTRailsHinge, 3, new TGeoCombiTrans(xpos, -yposdw, zpos, new TGeoRotation("", 180 + alpha, 0, 0)));
+  mother->AddNode(cageMFTRailsHinge, 4, new TGeoCombiTrans(-xpos, -yposdw, zpos, new TGeoRotation("", 180 - alpha, 0, 0)));
+
+  zpos = (static_cast<TGeoBBox*>(cageMFTRails->GetShape()))->GetDZ() - sCageMFTRailZPos;
+  mother->AddNode(cageMFTRailsHinge, 5, new TGeoCombiTrans(xpos, yposup, -zpos, new TGeoRotation("", 90, 180, -90 + alpha))); // On Z<0 apply 180deg rotation on Y axis
+  mother->AddNode(cageMFTRailsHinge, 6, new TGeoCombiTrans(-xpos, yposup, -zpos, new TGeoRotation("", 90, 180, -90 - alpha)));
+
+  mother->AddNode(cageMFTRailsHinge, 7, new TGeoCombiTrans(xpos, -yposdw, -zpos, new TGeoRotation("", 90, 180, 90 - alpha)));
+  mother->AddNode(cageMFTRailsHinge, 8, new TGeoCombiTrans(-xpos, -yposdw, -zpos, new TGeoRotation("", 90, 180, 90 + alpha)));
 
   return;
 }
@@ -1720,7 +1756,7 @@ TGeoVolume* V3Cage::createMFTRailsPair(const TGeoMedium* motmed, const TGeoManag
   // is preferred over an Assembly for better performance)
   //
   // Input:
-  //         motmat : the material of the mother volume (for the container box)
+  //         motmed : the medium of the mother volume (for the container box)
   //         mgr : the GeoManager (used only to get the proper material)
   //
   // Output:
@@ -1794,3 +1830,83 @@ TGeoVolume* V3Cage::createMFTRailsPair(const TGeoMedium* motmed, const TGeoManag
   // Finally return the rails volume
   return mftRailBoxVol;
 }
+
+TGeoVolume* V3Cage::createMFTRailsHinge(const TGeoManager* mgr)
+{
+  //
+  // Creates a hinge holding a pair of MFT Rails to the Cage (from drawing
+  // ALIMFT-0042 and elements inside CAD files)
+  //
+  // Input:
+  //         mgr : the GeoManager (used only to get the proper material)
+  //
+  // Output:
+  //
+  // Return:
+  //         A rail hinge as a TGeoVolume
+  //
+  // Created:      19 May 2025  Mario Sitta
+  //
+
+  // Local variables
+  const Int_t nv = 6;
+  Double_t xv[nv], yv[nv];
+  Double_t xlen, ylen, zlen;
+  Double_t xpos, ypos, zpos;
+
+  TString compoShape;
+
+  // The main body: a Xtru
+  xv[0] = sCageMFTHingeTotWid / 2;
+  yv[0] = 0;
+  xv[1] = xv[0];
+  yv[1] = sCageMFTHingeIntHei;
+  xv[2] = sCageMFTHingeIntWid / 2;
+  yv[2] = sCageMFTHingeHeight;
+
+  for (Int_t i = 3; i < nv; i++) {
+    xv[i] = -xv[5 - i];
+    yv[i] = yv[5 - i];
+  }
+
+  zlen = sCageMFTHingeIntLen / 2;
+
+  TGeoXtru* mftHingeBodySh = new TGeoXtru(2);
+  mftHingeBodySh->SetName("mfthingebodyshape");
+  mftHingeBodySh->DefinePolygon(nv, xv, yv);
+  mftHingeBodySh->DefineSection(0, -zlen);
+  mftHingeBodySh->DefineSection(1, zlen);
+
+  // The bulge: a BBox
+  xlen = sCageMFTHingeBulgeWid / 2;
+  ylen = sCageMFTHingeBulgeHei / 2;
+  zlen = (sCageMFTHingeTotLen - sCageMFTHingeIntLen) / 2;
+  TGeoBBox* mftHingeBulgeSh = new TGeoBBox("mfthingebulgeshape", xlen, ylen, zlen);
+
+  // The actual hinge: a CompositeShape
+  xpos = mftHingeBodySh->GetX(0) - (sCageMFTHingeBulgePos + mftHingeBulgeSh->GetDX());
+  ypos = mftHingeBodySh->GetY(2) - mftHingeBulgeSh->GetDY();
+  zpos = mftHingeBodySh->GetZ(1) + mftHingeBulgeSh->GetDZ();
+
+  TGeoTranslation* bulgpos1 = new TGeoTranslation(xpos, ypos, zpos);
+  bulgpos1->SetName("bulge1pos");
+  bulgpos1->RegisterYourself();
+
+  TGeoTranslation* bulgpos2 = new TGeoTranslation(-xpos, ypos, zpos);
+  bulgpos2->SetName("bulge2pos");
+  bulgpos2->RegisterYourself();
+
+  compoShape = Form("mfthingebodyshape+mfthingebulgeshape:bulge1pos+mfthingebulgeshape:bulge2pos");
+
+  TGeoCompositeShape* mftRailHingeSh = new TGeoCompositeShape(compoShape);
+
+  // We have the shape: now create the real volume
+  TGeoMedium* medAl = mgr->GetMedium(Form("%s_ALUMINUM$", GetDetName()));
+
+  TGeoVolume* mftRailHingeVol = new TGeoVolume("MFTRailHingeInsideCage", mftRailHingeSh, medAl);
+  mftRailHingeVol->SetFillColor(kGreen);
+  mftRailHingeVol->SetLineColor(kGreen);
+
+  // Finally return the hinge volume
+  return mftRailHingeVol;
+}

From 492e244ed11590eb029c77f7495cc16ebfe0b584 Mon Sep 17 00:00:00 2001
From: Nicolo Valle <nicolo.valle@cern.ch>
Date: Thu, 15 May 2025 11:34:09 +0200
Subject: [PATCH 0416/1764] ITS no group chips in deadmap calib workflow

---
 prodtests/full-system-test/aggregator-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/aggregator-workflow.sh b/prodtests/full-system-test/aggregator-workflow.sh
index 90abe9786f89e..5783bb9a38ad6 100755
--- a/prodtests/full-system-test/aggregator-workflow.sh
+++ b/prodtests/full-system-test/aggregator-workflow.sh
@@ -236,7 +236,7 @@ if [[ $AGGREGATOR_TASKS == BARREL_TF ]] || [[ $AGGREGATOR_TASKS == ALL ]]; then
   fi
   # ITS
   if [[ $CALIB_ITS_DEADMAP_TIME == 1 ]]; then
-     add_W o2-itsmft-deadmap-builder-workflow "--ccdb-url $CCDB_POPULATOR_UPLOAD_PATH ${CALIB_ITS_DEADMAP_TIME_OPT:-}"
+     add_W o2-itsmft-deadmap-builder-workflow "--ccdb-url $CCDB_POPULATOR_UPLOAD_PATH ${CALIB_ITS_DEADMAP_TIME_OPT:---no-group-its-lanes --skip-static-map}"
   fi
   # MFT
   if [[ $CALIB_MFT_DEADMAP_TIME == 1 ]]; then

From 0c289252798aaf13173f08de6d95bf7401c9dcdf Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 26 May 2025 11:22:48 +0200
Subject: [PATCH 0417/1764] GPU: Tentative workaround for MI100 serialization
 bug

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h            | 1 +
 GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index f7ff14ea188c4..d8173a5b62a35 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -370,6 +370,7 @@ AddOption(debugOnFailureMaxN, uint32_t, 1, "", 0, "Max number of times to run th
 AddOption(debugOnFailureMaxFiles, uint32_t, 0, "", 0, "Max number of files to have in the target folder")
 AddOption(debugOnFailureMaxSize, uint32_t, 0, "", 0, "Max size of existing dumps in the target folder in GB")
 AddOption(debugOnFailureDirectory, std::string, ".", "", 0, "Target folder for debug / dump")
+AddOption(amdMI100SerializationWorkaround, bool, false, "", 0, "Enable workaround that mitigates MI100 serialization bug")
 AddVariable(eventDisplay, o2::gpu::GPUDisplayFrontendInterface*, nullptr)
 AddSubConfig(GPUSettingsProcessingRTC, rtc)
 AddSubConfig(GPUSettingsProcessingRTCtechnical, rtctech)
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 67ef402961a20..708037239071e 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -161,6 +161,9 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     GPUTPCTracker& trk = processors()->tpcTrackers[iSector];
     GPUTPCTracker& trkShadow = doGPU ? processorsShadow()->tpcTrackers[iSector] : trk;
     int32_t useStream = StreamForSector(iSector);
+    if (GetProcessingSettings().amdMI100SerializationWorkaround) {
+      SynchronizeStream(useStream); // TODO: Remove this workaround once fixed on MI100
+    }
 
     if (GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Creating Sector Data (Sector %d)", iSector);

From 011efa3aab09f214d409087b6efd5d4c166e3bce Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 27 May 2025 06:27:45 +0200
Subject: [PATCH 0418/1764] Get ROOT v6-36-00 to work. (#14331)

---
 Framework/AnalysisSupport/src/Plugin.cxx      |   5 +-
 .../AnalysisSupport/src/RNTuplePlugin.cxx     | 206 ++++++++++++------
 2 files changed, 144 insertions(+), 67 deletions(-)

diff --git a/Framework/AnalysisSupport/src/Plugin.cxx b/Framework/AnalysisSupport/src/Plugin.cxx
index 548647c644636..00a4cc6565494 100644
--- a/Framework/AnalysisSupport/src/Plugin.cxx
+++ b/Framework/AnalysisSupport/src/Plugin.cxx
@@ -121,7 +121,10 @@ std::vector<std::string> getListOfTables(std::unique_ptr<TFile>& f)
       break;
     }
 
-    void* v = f->GetObjectChecked(key->GetName(), TClass::GetClass("ROOT::Experimental::RNTuple"));
+    void* v = f->GetObjectChecked(key->GetName(), TClass::GetClass("ROOT::RNTuple"));
+    if (!v) {
+      v = f->GetObjectChecked(key->GetName(), TClass::GetClass("ROOT::Experimental::RNTuple"));
+    }
     if (v) {
       std::string s = key->GetName();
       size_t pos = s.find('-');
diff --git a/Framework/AnalysisSupport/src/RNTuplePlugin.cxx b/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
index a910964e6527c..2c6fffe872db3 100644
--- a/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
+++ b/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
@@ -32,8 +32,20 @@
 #include <arrow/array/builder_primitive.h>
 #include <arrow/dataset/file_base.h>
 
+#if __has_include(<ROOT/RFieldBase.hxx>)
+#include <ROOT/RFieldBase.hxx>
+namespace rns = ROOT;
+using DPLFieldToken = rns::RFieldToken;
+using DPLLocalIndex = rns::RNTupleLocalIndex;
+#else
+namespace rns = ROOT::Experimental;
+using DPLFieldToken = rns::REntry::RFieldToken;
+using DPLLocalIndex = rns::RClusterIndex;
+#endif
+
+
 template class
-  std::unique_ptr<ROOT::Experimental::RNTupleReader>;
+  std::unique_ptr<rns::RNTupleReader>;
 
 namespace o2::framework
 {
@@ -53,13 +65,13 @@ class RNTupleFileSystem : public VirtualRootFileSystemBase
  public:
   ~RNTupleFileSystem() override;
 
-  virtual ROOT::Experimental::RNTuple* GetRNTuple(arrow::dataset::FileSource source) = 0;
+  virtual rns::RNTuple* GetRNTuple(arrow::dataset::FileSource source) = 0;
 };
 
 class SingleRNTupleFileSystem : public RNTupleFileSystem
 {
  public:
-  SingleRNTupleFileSystem(ROOT::Experimental::RNTuple* tuple)
+  SingleRNTupleFileSystem(rns::RNTuple* tuple)
     : RNTupleFileSystem(),
       mTuple(tuple)
   {
@@ -72,14 +84,14 @@ class SingleRNTupleFileSystem : public RNTupleFileSystem
     return "rntuple";
   }
 
-  ROOT::Experimental::RNTuple* GetRNTuple(arrow::dataset::FileSource) override
+  rns::RNTuple* GetRNTuple(arrow::dataset::FileSource) override
   {
     // Simply return the only TTree we have
     return mTuple;
   }
 
  private:
-  ROOT::Experimental::RNTuple* mTuple;
+  rns::RNTuple* mTuple;
 };
 
 arrow::Result<arrow::fs::FileInfo> SingleRNTupleFileSystem::GetFileInfo(std::string const& path)
@@ -110,16 +122,16 @@ class RNTupleFileFragment : public arrow::dataset::FileFragment
                             handler->format->type_name().c_str(),
                             format->type_name().c_str());
     }
-    mNTuple = handler->GetObjectAsOwner<ROOT::Experimental::RNTuple>();
+    mNTuple = handler->GetObjectAsOwner<rns::RNTuple>();
   }
 
-  ROOT::Experimental::RNTuple* GetRNTuple()
+  rns::RNTuple* GetRNTuple()
   {
     return mNTuple.get();
   }
 
  private:
-  std::unique_ptr<ROOT::Experimental::RNTuple> mNTuple;
+  std::unique_ptr<rns::RNTuple> mNTuple;
 };
 
 class RNTupleFileFormat : public arrow::dataset::FileFormat
@@ -173,36 +185,77 @@ class RNTupleFileFormat : public arrow::dataset::FileFormat
     std::shared_ptr<arrow::Schema> physical_schema) override;
 };
 
-struct RootNTupleVisitor : public ROOT::Experimental::Detail::RFieldVisitor {
-  void VisitArrayField(const ROOT::Experimental::RArrayField& field) override
+template <typename T>
+requires requires (T&& f) { f.GetSubFields(); }
+auto getSubfields(T const&field) {
+    return field.GetSubFields();
+}
+
+template <typename T>
+requires requires (T&& f) { f.GetConstSubfields(); }
+auto getSubfields(T const&field) {
+    return field.GetConstSubfields();
+}
+
+struct RootNTupleVisitor : public rns::Detail::RFieldVisitor {
+  void VisitArrayField(const rns::RArrayField& field) override
   {
     int size = field.GetLength();
     RootNTupleVisitor valueVisitor{};
-    auto valueField = field.GetSubFields()[0];
+    auto valueField = getSubfields(field)[0];
     valueField->AcceptVisitor(valueVisitor);
     auto type = valueVisitor.datatype;
     this->datatype = arrow::fixed_size_list(type, size);
   }
 
-  void VisitRVecField(const ROOT::Experimental::RRVecField& field) override
+  void VisitRVecField(const rns::RRVecField& field) override
   {
     RootNTupleVisitor valueVisitor{};
-    auto valueField = field.GetSubFields()[0];
+    auto valueField = getSubfields(field)[0];
     valueField->AcceptVisitor(valueVisitor);
     auto type = valueVisitor.datatype;
     this->datatype = arrow::list(type);
   }
 
-  void VisitField(const ROOT::Experimental::RFieldBase& field) override
+  void VisitField(const rns::RFieldBase& field) override
   {
     throw o2::framework::runtime_error_f("Unknown field %s with type %s", field.GetFieldName().c_str(), field.GetTypeName().c_str());
   }
 
-  void VisitIntField(const ROOT::Experimental::RField<int>& field) override
+#if __has_include(<ROOT/RFieldBase.hxx>)
+  void VisitInt32Field(const rns::RIntegralField<int>& field) override
   {
     this->datatype = arrow::int32();
   }
+  void VisitInt8Field(const rns::RIntegralField<std::int8_t>& field) override
+  {
+    this->datatype = arrow::int8();
+  }
+
+  void VisitInt16Field(const rns::RIntegralField<std::int16_t>& field) override
+  {
+    this->datatype = arrow::int16();
+  }
+
+  void VisitUInt32Field(const rns::RIntegralField<std::uint32_t>& field) override
+  {
+    this->datatype = arrow::uint32();
+  }
 
+  void VisitUInt8Field(const rns::RIntegralField<std::uint8_t>& field) override
+  {
+    this->datatype = arrow::uint8();
+  }
+
+  void VisitUInt16Field(const rns::RIntegralField<std::uint16_t>& field) override
+  {
+    this->datatype = arrow::int16();
+  }
+#else
+  void VisitIntField(const rns::RField<int>& field) override
+  {
+    this->datatype = arrow::int32();
+  }
   void VisitInt8Field(const ROOT::Experimental::RField<std::int8_t>& field) override
   {
     this->datatype = arrow::int8();
@@ -227,18 +280,20 @@ struct RootNTupleVisitor : public ROOT::Experimental::Detail::RFieldVisitor {
   {
     this->datatype = arrow::int16();
   }
+#endif
+
 
-  void VisitBoolField(const ROOT::Experimental::RField<bool>& field) override
+  void VisitBoolField(const rns::RField<bool>& field) override
   {
     this->datatype = arrow::boolean();
   }
 
-  void VisitFloatField(const ROOT::Experimental::RField<float>& field) override
+  void VisitFloatField(const rns::RField<float>& field) override
   {
     this->datatype = arrow::float32();
   }
 
-  void VisitDoubleField(const ROOT::Experimental::RField<double>& field) override
+  void VisitDoubleField(const rns::RField<double>& field) override
   {
     this->datatype = arrow::float64();
   }
@@ -246,7 +301,7 @@ struct RootNTupleVisitor : public ROOT::Experimental::Detail::RFieldVisitor {
 };
 } // namespace o2::framework
 
-auto arrowTypeFromRNTuple(ROOT::Experimental::RFieldBase const& field, int size)
+auto arrowTypeFromRNTuple(rns::RFieldBase const& field, int size)
 {
   o2::framework::RootNTupleVisitor visitor;
   field.AcceptVisitor(visitor);
@@ -255,34 +310,34 @@ auto arrowTypeFromRNTuple(ROOT::Experimental::RFieldBase const& field, int size)
 
 namespace o2::framework
 {
-std::unique_ptr<ROOT::Experimental::RFieldBase> rootFieldFromArrow(std::shared_ptr<arrow::Field> field, std::string name)
+std::unique_ptr<rns::RFieldBase> rootFieldFromArrow(std::shared_ptr<arrow::Field> field, std::string name)
 {
   using namespace ROOT::Experimental;
   switch (field->type()->id()) {
     case arrow::Type::BOOL:
-      return std::make_unique<RField<bool>>(name);
+      return std::make_unique<rns::RField<bool>>(name);
     case arrow::Type::UINT8:
-      return std::make_unique<RField<uint8_t>>(name);
+      return std::make_unique<rns::RField<uint8_t>>(name);
     case arrow::Type::UINT16:
-      return std::make_unique<RField<uint16_t>>(name);
+      return std::make_unique<rns::RField<uint16_t>>(name);
     case arrow::Type::UINT32:
-      return std::make_unique<RField<uint32_t>>(name);
+      return std::make_unique<rns::RField<uint32_t>>(name);
     case arrow::Type::UINT64:
-      return std::make_unique<RField<uint64_t>>(name);
+      return std::make_unique<rns::RField<uint64_t>>(name);
     case arrow::Type::INT8:
-      return std::make_unique<RField<int8_t>>(name);
+      return std::make_unique<rns::RField<int8_t>>(name);
     case arrow::Type::INT16:
-      return std::make_unique<RField<int16_t>>(name);
+      return std::make_unique<rns::RField<int16_t>>(name);
     case arrow::Type::INT32:
-      return std::make_unique<RField<int32_t>>(name);
+      return std::make_unique<rns::RField<int32_t>>(name);
     case arrow::Type::INT64:
-      return std::make_unique<RField<int64_t>>(name);
+      return std::make_unique<rns::RField<int64_t>>(name);
     case arrow::Type::FLOAT:
-      return std::make_unique<RField<float>>(name);
+      return std::make_unique<rns::RField<float>>(name);
     case arrow::Type::DOUBLE:
-      return std::make_unique<RField<double>>(name);
+      return std::make_unique<rns::RField<double>>(name);
     case arrow::Type::STRING:
-      return std::make_unique<RField<std::string>>(name);
+      return std::make_unique<rns::RField<std::string>>(name);
     default:
       throw runtime_error("Unsupported arrow column type");
   }
@@ -290,7 +345,7 @@ std::unique_ptr<ROOT::Experimental::RFieldBase> rootFieldFromArrow(std::shared_p
 
 class RNTupleFileWriter : public arrow::dataset::FileWriter
 {
-  std::shared_ptr<ROOT::Experimental::RNTupleWriter> mWriter;
+  std::shared_ptr<rns::RNTupleWriter> mWriter;
   bool firstBatch = true;
   std::vector<std::shared_ptr<arrow::Array>> valueArrays;
   std::vector<std::shared_ptr<arrow::DataType>> valueTypes;
@@ -304,7 +359,7 @@ class RNTupleFileWriter : public arrow::dataset::FileWriter
   {
     using namespace ROOT::Experimental;
 
-    auto model = RNTupleModel::CreateBare();
+    auto model = rns::RNTupleModel::CreateBare();
     // Let's create a model from the physical schema
     for (auto i = 0u; i < schema->fields().size(); ++i) {
       auto& field = schema->field(i);
@@ -314,11 +369,11 @@ class RNTupleFileWriter : public arrow::dataset::FileWriter
         case arrow::Type::FIXED_SIZE_LIST: {
           auto list = std::static_pointer_cast<arrow::FixedSizeListType>(field->type());
           auto valueField = field->type()->field(0);
-          model->AddField(std::make_unique<RArrayField>(field->name(), rootFieldFromArrow(valueField, "_0"), list->list_size()));
+          model->AddField(std::make_unique<rns::RArrayField>(field->name(), rootFieldFromArrow(valueField, "_0"), list->list_size()));
         } break;
         case arrow::Type::LIST: {
           auto valueField = field->type()->field(0);
-          model->AddField(std::make_unique<RRVecField>(field->name(), rootFieldFromArrow(valueField, "_0")));
+          model->AddField(std::make_unique<rns::RRVecField>(field->name(), rootFieldFromArrow(valueField, "_0")));
         } break;
         default: {
           model->AddField(rootFieldFromArrow(field, field->name()));
@@ -327,7 +382,7 @@ class RNTupleFileWriter : public arrow::dataset::FileWriter
     }
     auto fileStream = std::dynamic_pointer_cast<TDirectoryFileOutputStream>(destination_);
     auto* file = dynamic_cast<TFile*>(fileStream->GetDirectory());
-    mWriter = RNTupleWriter::Append(std::move(model), destination_locator_.path, *file, {});
+    mWriter = rns::RNTupleWriter::Append(std::move(model), destination_locator_.path, *file, {});
   }
 
   arrow::Status Write(const std::shared_ptr<arrow::RecordBatch>& batch) override
@@ -413,7 +468,7 @@ class RNTupleFileWriter : public arrow::dataset::FileWriter
     int64_t pos = 0;
 
     auto entry = mWriter->CreateEntry();
-    std::vector<ROOT::Experimental::REntry::RFieldToken> tokens;
+    std::vector<DPLFieldToken> tokens;
     tokens.reserve(batch->num_columns());
     std::vector<size_t> typeIds;
     typeIds.reserve(batch->num_columns());
@@ -435,7 +490,7 @@ class RNTupleFileWriter : public arrow::dataset::FileWriter
             auto value_slice = list->value_slice(pos);
 
             valueCount[ci] = value_slice->length();
-            auto bindValue = [&vc = valueCount, ci, token](auto array, std::unique_ptr<ROOT::Experimental::REntry>& entry) -> void {
+            auto bindValue = [&vc = valueCount, ci, token](auto array, std::unique_ptr<rns::REntry>& entry) -> void {
               using value_type = std::decay_t<decltype(*array.get())>::value_type;
               auto v = std::make_shared<ROOT::VecOps::RVec<value_type>>((value_type*)array->raw_values(), vc[ci]);
               entry->BindValue(token, v);
@@ -504,6 +559,19 @@ class RNTupleFileWriter : public arrow::dataset::FileWriter
   };
 };
 
+template <typename T>
+requires requires (T const&m) { m.GetFieldZero(); }
+auto &getFieldZero(T const &m) {
+  return m.GetFieldZero();
+}
+
+template <typename T>
+requires requires (T const&m) { m.GetConstFieldZero(); }
+auto &getFieldZero(T const &m) {
+  return m.GetConstFieldZero();
+}
+
+
 arrow::Result<std::shared_ptr<arrow::Schema>> RNTupleFileFormat::Inspect(const arrow::dataset::FileSource& source) const
 {
 
@@ -514,15 +582,17 @@ arrow::Result<std::shared_ptr<arrow::Schema>> RNTupleFileFormat::Inspect(const a
     throw runtime_error_f("Unexpected kind of filesystem %s to handle payload %s.\n", source.filesystem()->type_name().c_str(), source.path().c_str());
   }
   // We know this is a RNTuple, so we can continue with the inspection.
-  auto rntuple = objectHandler->GetObjectAsOwner<ROOT::Experimental::RNTuple>().release();
-
-  auto inspector = ROOT::Experimental::RNTupleInspector::Create(rntuple);
+  auto rntuple = objectHandler->GetObjectAsOwner<rns::RNTuple>().release();
 
-  auto reader = ROOT::Experimental::RNTupleReader::Open(rntuple);
+#if __has_include(<ROOT/RFieldBase.hxx>)
+  auto reader = rns::RNTupleReader::Open(*rntuple);
+#else
+  auto reader = rns::RNTupleReader::Open(rntuple);
+#endif
 
-  auto& tupleField0 = reader->GetModel().GetFieldZero();
+  auto& tupleField0 = getFieldZero(reader->GetModel());
   std::vector<std::shared_ptr<arrow::Field>> fields;
-  for (auto& tupleField : tupleField0.GetSubFields()) {
+  for (auto& tupleField : getSubfields(tupleField0)) {
     auto field = std::make_shared<arrow::Field>(tupleField->GetFieldName(), arrowTypeFromRNTuple(*tupleField, tupleField->GetValueSize()));
     fields.push_back(field);
   }
@@ -544,8 +614,12 @@ arrow::Result<arrow::RecordBatchGenerator> RNTupleFileFormat::ScanBatchesAsync(
     std::vector<std::shared_ptr<arrow::Field>> fields = dataset_schema->fields();
 
     int64_t rows = -1;
-    ROOT::Experimental::RNTuple* rntuple = ntupleFragment->GetRNTuple();
-    auto reader = ROOT::Experimental::RNTupleReader::Open(rntuple);
+    rns::RNTuple* rntuple = ntupleFragment->GetRNTuple();
+#if __has_include(<ROOT/RFieldBase.hxx>)
+    auto reader = rns::RNTupleReader::Open(*rntuple);
+#else
+    auto reader = rns::RNTupleReader::Open(rntuple);
+#endif
     auto& model = reader->GetModel();
     for (auto& physicalField : fields) {
       auto bulk = model.CreateBulk(physicalField->name());
@@ -583,11 +657,11 @@ arrow::Result<arrow::RecordBatchGenerator> RNTupleFileFormat::ScanBatchesAsync(
           auto clusterIt = descriptor.FindClusterId(0, 0);
           // No adoption for now...
           // bulk.AdoptBuffer(buffer, totalEntries)
-          while (clusterIt != kInvalidDescriptorId) {
+          while (clusterIt != rns::kInvalidDescriptorId) {
             auto& index = descriptor.GetClusterDescriptor(clusterIt);
             auto mask = std::make_unique<bool[]>(index.GetNEntries());
             std::fill(mask.get(), mask.get() + index.GetNEntries(), true);
-            void* ptr = bulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries());
+            void* ptr = bulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries());
             int readLast = index.GetNEntries();
             readEntries += readLast;
             status &= static_cast<arrow::BooleanBuilder*>(valueBuilder)->AppendValues(reinterpret_cast<uint8_t const*>(ptr), readLast * listType->list_size());
@@ -614,11 +688,11 @@ arrow::Result<arrow::RecordBatchGenerator> RNTupleFileFormat::ScanBatchesAsync(
             throw runtime_error("Failed to reserve memory for array builder");
           }
           auto clusterIt = descriptor.FindClusterId(0, 0);
-          while (clusterIt != kInvalidDescriptorId) {
+          while (clusterIt != rns::kInvalidDescriptorId) {
             auto& index = descriptor.GetClusterDescriptor(clusterIt);
             auto mask = std::make_unique<bool[]>(index.GetNEntries());
             std::fill(mask.get(), mask.get() + index.GetNEntries(), true);
-            void* ptr = bulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries());
+            void* ptr = bulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries());
             int readLast = index.GetNEntries();
             readEntries += readLast;
             status &= valueBuilder->AppendValues(reinterpret_cast<uint8_t const*>(ptr), readLast);
@@ -659,11 +733,11 @@ arrow::Result<arrow::RecordBatchGenerator> RNTupleFileFormat::ScanBatchesAsync(
           listSize = fixedSizeList->list_size();
           typeSize = fixedSizeList->field(0)->type()->byte_width();
           auto clusterIt = descriptor.FindClusterId(0, 0);
-          while (clusterIt != kInvalidDescriptorId) {
+          while (clusterIt != rns::kInvalidDescriptorId) {
             auto& index = descriptor.GetClusterDescriptor(clusterIt);
             auto mask = std::make_unique<bool[]>(index.GetNEntries());
             std::fill(mask.get(), mask.get() + index.GetNEntries(), true);
-            void* inPtr = bulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries());
+            void* inPtr = bulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries());
 
             int readLast = index.GetNEntries();
             if (listSize == -1) {
@@ -719,41 +793,41 @@ arrow::Result<arrow::RecordBatchGenerator> RNTupleFileFormat::ScanBatchesAsync(
             }
           };
 
-          while (clusterIt != kInvalidDescriptorId) {
+          while (clusterIt != rns::kInvalidDescriptorId) {
             auto& index = descriptor.GetClusterDescriptor(clusterIt);
             auto mask = std::make_unique<bool[]>(index.GetNEntries());
             std::fill(mask.get(), mask.get() + index.GetNEntries(), true);
             int readLast = index.GetNEntries();
             switch (vlaListType->field(0)->type()->id()) {
               case arrow::Type::FLOAT: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<float>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<float>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::DOUBLE: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<double>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<double>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::INT8: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<int8_t>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<int8_t>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::INT16: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<int16_t>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<int16_t>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::INT32: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<int32_t>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<int32_t>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::INT64: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<int64_t>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<int64_t>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::UINT8: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<uint8_t>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<uint8_t>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::UINT16: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<uint16_t>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<uint16_t>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::UINT32: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<uint32_t>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<uint32_t>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               case arrow::Type::UINT64: {
-                copyOffsets((ROOT::Internal::VecOps::RVec<uint64_t>*)offsetBulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
+                copyOffsets((ROOT::Internal::VecOps::RVec<uint64_t>*)offsetBulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries()), readLast);
               } break;
               default: {
                 throw runtime_error("Unsupported kind of VLA");
@@ -765,11 +839,11 @@ arrow::Result<arrow::RecordBatchGenerator> RNTupleFileFormat::ScanBatchesAsync(
           }
         } else {
           auto clusterIt = descriptor.FindClusterId(0, 0);
-          while (clusterIt != kInvalidDescriptorId) {
+          while (clusterIt != rns::kInvalidDescriptorId) {
             auto& index = descriptor.GetClusterDescriptor(clusterIt);
             auto mask = std::make_unique<bool[]>(index.GetNEntries());
             std::fill(mask.get(), mask.get() + index.GetNEntries(), true);
-            void* inPtr = bulk.ReadBulk(RClusterIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries());
+            void* inPtr = bulk.ReadBulk(DPLLocalIndex(clusterIt, index.GetFirstEntryIndex()), mask.get(), index.GetNEntries());
 
             int readLast = index.GetNEntries();
             if (listSize == -1) {

From 3c38c31accea5abb74a34c59f75b63bb934c6529 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 27 May 2025 09:58:28 +0200
Subject: [PATCH 0419/1764] ITS: remove shipped nlohmann_json (#14295)

---
 .../ITS/tracking/include/ITStracking/json.h   | 16313 ----------------
 Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx |     5 -
 Detectors/TRD/workflow/CMakeLists.txt         |     5 +-
 .../TRDWorkflow/TRDEventDisplayFeedSpec.h     |     3 +-
 dependencies/O2Dependencies.cmake             |     3 +
 5 files changed, 7 insertions(+), 16322 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/json.h

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/json.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/json.h
deleted file mode 100644
index d1d246b329907..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/json.h
+++ /dev/null
@@ -1,16313 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/*
-    __ _____ _____ _____
- __|  |   __|     |   | |  JSON for Modern C++
-|  |  |__   |  |  | | | |  version 3.1.2
-|_____|_____|_____|_|___|  https://github.com/nlohmann/json
-
-Licensed under the MIT License <http://opensource.org/licenses/MIT>.
-Copyright (c) 2013-2018 Niels Lohmann <http://nlohmann.me>.
-
-Permission is hereby  granted, free of charge, to any  person obtaining a copy
-of this software and associated  documentation files (the "Software"), to deal
-in the Software  without restriction, including without  limitation the rights
-to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
-copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
-IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
-FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
-AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
-LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-#ifndef NLOHMANN_JSON_HPP
-#define NLOHMANN_JSON_HPP
-
-#define NLOHMANN_JSON_VERSION_MAJOR 3
-#define NLOHMANN_JSON_VERSION_MINOR 1
-#define NLOHMANN_JSON_VERSION_PATCH 2
-
-#include <algorithm>        // all_of, find, for_each
-#include <cassert>          // assert
-#include <ciso646>          // and, not, or
-#include <cstddef>          // nullptr_t, ptrdiff_t, size_t
-#include <functional>       // hash, less
-#include <initializer_list> // initializer_list
-#include <iosfwd>           // istream, ostream
-#include <iterator>         // iterator_traits, random_access_iterator_tag
-#include <numeric>          // accumulate
-#include <string>           // string, stoi, to_string
-#include <utility>          // declval, forward, move, pair, swap
-
-// #include <nlohmann/json_fwd.hpp>
-#ifndef NLOHMANN_JSON_FWD_HPP
-#define NLOHMANN_JSON_FWD_HPP
-
-#include <cstdint> // int64_t, uint64_t
-#include <map>     // map
-#include <memory>  // allocator
-#include <string>  // string
-#include <vector>  // vector
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-@since version 1.0.0
-*/
-namespace nlohmann
-{
-/*!
-@brief default JSONSerializer template argument
-
-This serializer ignores the template arguments and uses ADL
-([argument-dependent lookup](http://en.cppreference.com/w/cpp/language/adl))
-for serialization.
-*/
-template <typename = void, typename = void>
-struct adl_serializer;
-
-template <template <typename U, typename V, typename... Args> class ObjectType =
-            std::map,
-          template <typename U, typename... Args> class ArrayType = std::vector,
-          class StringType = std::string, class BooleanType = bool,
-          class NumberIntegerType = std::int64_t,
-          class NumberUnsignedType = std::uint64_t,
-          class NumberFloatType = double,
-          template <typename U> class AllocatorType = std::allocator,
-          template <typename T, typename SFINAE = void> class JSONSerializer =
-            adl_serializer>
-class basic_json;
-
-/*!
-@brief JSON Pointer
-
-A JSON pointer defines a string syntax for identifying a specific value
-within a JSON document. It can be used with functions `at` and
-`operator[]`. Furthermore, JSON pointers are the base for JSON patches.
-
-@sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
-
-@since version 2.0.0
-*/
-template <typename BasicJsonType>
-class json_pointer;
-
-/*!
-@brief default JSON class
-
-This type is the default specialization of the @ref basic_json class which
-uses the standard template types.
-
-@since version 1.0.0
-*/
-using json = basic_json<>;
-} // namespace nlohmann
-
-#endif
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// This file contains all internal macro definitions
-// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
-
-// exclude unsupported compilers
-#if defined(__clang__)
-#if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
-#error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
-#endif
-#elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
-#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40900
-#error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
-#endif
-#endif
-
-// disable float-equal warnings on GCC/clang
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wfloat-equal"
-#endif
-
-// disable documentation warnings on clang
-#if defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdocumentation"
-#endif
-
-// allow for portable deprecation warnings
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
-#define JSON_DEPRECATED __attribute__((deprecated))
-#elif defined(_MSC_VER)
-#define JSON_DEPRECATED __declspec(deprecated)
-#else
-#define JSON_DEPRECATED
-#endif
-
-// allow to disable exceptions
-#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
-#define JSON_THROW(exception) throw exception
-#define JSON_TRY try
-#define JSON_CATCH(exception) catch (exception)
-#else
-#define JSON_THROW(exception) std::abort()
-#define JSON_TRY if (true)
-#define JSON_CATCH(exception) if (false)
-#endif
-
-// override exception macros
-#if defined(JSON_THROW_USER)
-#undef JSON_THROW
-#define JSON_THROW JSON_THROW_USER
-#endif
-#if defined(JSON_TRY_USER)
-#undef JSON_TRY
-#define JSON_TRY JSON_TRY_USER
-#endif
-#if defined(JSON_CATCH_USER)
-#undef JSON_CATCH
-#define JSON_CATCH JSON_CATCH_USER
-#endif
-
-// manual branch prediction
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
-#define JSON_LIKELY(x) __builtin_expect(!!(x), 1)
-#define JSON_UNLIKELY(x) __builtin_expect(!!(x), 0)
-#else
-#define JSON_LIKELY(x) x
-#define JSON_UNLIKELY(x) x
-#endif
-
-// C++ language standard detection
-#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
-#define JSON_HAS_CPP_17
-#define JSON_HAS_CPP_14
-#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
-#define JSON_HAS_CPP_14
-#endif
-
-// Ugly macros to avoid uglier copy-paste when specializing basic_json. They
-// may be removed in the future once the class is split.
-
-#define NLOHMANN_BASIC_JSON_TPL_DECLARATION                               \
-  template <template <typename, typename, typename...> class ObjectType,  \
-            template <typename, typename...> class ArrayType,             \
-            class StringType, class BooleanType, class NumberIntegerType, \
-            class NumberUnsignedType, class NumberFloatType,              \
-            template <typename> class AllocatorType,                      \
-            template <typename, typename = void> class JSONSerializer>
-
-#define NLOHMANN_BASIC_JSON_TPL                                      \
-  basic_json<ObjectType, ArrayType, StringType, BooleanType,         \
-             NumberIntegerType, NumberUnsignedType, NumberFloatType, \
-             AllocatorType, JSONSerializer>
-
-/*!
-@brief Helper to determine whether there's a key_type for T.
-
-This helper is used to tell associative containers apart from other containers
-such as sequence containers. For instance, `std::map` passes the test as it
-contains a `mapped_type`, whereas `std::vector` fails the test.
-
-@sa http://stackoverflow.com/a/7728728/266378
-@since version 1.0.0, overworked in version 2.0.6
-*/
-#define NLOHMANN_JSON_HAS_HELPER(type)                              \
-  template <typename T>                                             \
-  struct has_##type {                                               \
-   private:                                                         \
-    template <typename U, typename = typename U::type>              \
-    static int detect(U&&);                                         \
-    static void detect(...);                                        \
-                                                                    \
-   public:                                                          \
-    static constexpr bool value =                                   \
-      std::is_integral<decltype(detect(std::declval<T>()))>::value; \
-  }
-
-// #include <nlohmann/detail/meta.hpp>
-
-#include <ciso646>     // not
-#include <cstddef>     // size_t
-#include <limits>      // numeric_limits
-#include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
-#include <utility>     // declval
-
-// #include <nlohmann/json_fwd.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-namespace nlohmann
-{
-/*!
-@brief detail namespace with internal helper functions
-
-This namespace collects functions that should not be exposed,
-implementations of some @ref basic_json methods, and meta-programming helpers.
-
-@since version 2.1.0
-*/
-namespace detail
-{
-/////////////
-// helpers //
-/////////////
-
-template <typename>
-struct is_basic_json : std::false_type {
-};
-
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {
-};
-
-// alias templates to reduce boilerplate
-template <bool B, typename T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-template <typename T>
-using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
-// implementation of C++14 index_sequence and affiliates
-// source: https://stackoverflow.com/a/32223343
-template <std::size_t... Ints>
-struct index_sequence {
-  using type = index_sequence;
-  using value_type = std::size_t;
-  static constexpr std::size_t size() noexcept
-  {
-    return sizeof...(Ints);
-  }
-};
-
-template <class Sequence1, class Sequence2>
-struct merge_and_renumber;
-
-template <std::size_t... I1, std::size_t... I2>
-struct merge_and_renumber<index_sequence<I1...>, index_sequence<I2...>>
-  : index_sequence<I1..., (sizeof...(I1) + I2)...> {
-};
-
-template <std::size_t N>
-struct make_index_sequence
-  : merge_and_renumber<typename make_index_sequence<N / 2>::type,
-                       typename make_index_sequence<N - N / 2>::type> {
-};
-
-template <>
-struct make_index_sequence<0> : index_sequence<> {
-};
-template <>
-struct make_index_sequence<1> : index_sequence<0> {
-};
-
-template <typename... Ts>
-using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-
-/*
-Implementation of two C++17 constructs: conjunction, negation. This is needed
-to avoid evaluating all the traits in a condition
-
-For example: not std::is_same<void, T>::value and has_value_type<T>::value
-will not compile when T = void (on MSVC at least). Whereas
-conjunction<negation<std::is_same<void, T>>, has_value_type<T>>::value will
-stop evaluating if negation<...>::value == false
-
-Please note that those constructs must be used with caution, since symbols can
-become very long quickly (which can slow down compilation and cause MSVC
-internal compiler errors). Only use it when you have to (see example ahead).
-*/
-template <class...>
-struct conjunction : std::true_type {
-};
-template <class B1>
-struct conjunction<B1> : B1 {
-};
-template <class B1, class... Bn>
-struct conjunction<B1, Bn...> : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {
-};
-
-template <class B>
-struct negation : std::integral_constant<bool, not B::value> {
-};
-
-// dispatch utility (taken from ranges-v3)
-template <unsigned N>
-struct priority_tag : priority_tag<N - 1> {
-};
-template <>
-struct priority_tag<0> {
-};
-
-////////////////////////
-// has_/is_ functions //
-////////////////////////
-
-// source: https://stackoverflow.com/a/37193089/4116453
-
-template <typename T, typename = void>
-struct is_complete_type : std::false_type {
-};
-
-template <typename T>
-struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {
-};
-
-NLOHMANN_JSON_HAS_HELPER(mapped_type);
-NLOHMANN_JSON_HAS_HELPER(key_type);
-NLOHMANN_JSON_HAS_HELPER(value_type);
-NLOHMANN_JSON_HAS_HELPER(iterator);
-
-template <bool B, class RealType, class CompatibleObjectType>
-struct is_compatible_object_type_impl : std::false_type {
-};
-
-template <class RealType, class CompatibleObjectType>
-struct is_compatible_object_type_impl<true, RealType, CompatibleObjectType> {
-  static constexpr auto value =
-    std::is_constructible<typename RealType::key_type, typename CompatibleObjectType::key_type>::value and
-    std::is_constructible<typename RealType::mapped_type, typename CompatibleObjectType::mapped_type>::value;
-};
-
-template <class BasicJsonType, class CompatibleObjectType>
-struct is_compatible_object_type {
-  static auto constexpr value = is_compatible_object_type_impl<
-    conjunction<negation<std::is_same<void, CompatibleObjectType>>,
-                has_mapped_type<CompatibleObjectType>,
-                has_key_type<CompatibleObjectType>>::value,
-    typename BasicJsonType::object_t, CompatibleObjectType>::value;
-};
-
-template <typename BasicJsonType, typename T>
-struct is_basic_json_nested_type {
-  static auto constexpr value = std::is_same<T, typename BasicJsonType::iterator>::value or
-                                std::is_same<T, typename BasicJsonType::const_iterator>::value or
-                                std::is_same<T, typename BasicJsonType::reverse_iterator>::value or
-                                std::is_same<T, typename BasicJsonType::const_reverse_iterator>::value;
-};
-
-template <class BasicJsonType, class CompatibleArrayType>
-struct is_compatible_array_type {
-  static auto constexpr value =
-    conjunction<negation<std::is_same<void, CompatibleArrayType>>,
-                negation<is_compatible_object_type<
-                  BasicJsonType, CompatibleArrayType>>,
-                negation<std::is_constructible<typename BasicJsonType::string_t,
-                                               CompatibleArrayType>>,
-                negation<is_basic_json_nested_type<BasicJsonType, CompatibleArrayType>>,
-                has_value_type<CompatibleArrayType>,
-                has_iterator<CompatibleArrayType>>::value;
-};
-
-template <bool, typename, typename>
-struct is_compatible_integer_type_impl : std::false_type {
-};
-
-template <typename RealIntegerType, typename CompatibleNumberIntegerType>
-struct is_compatible_integer_type_impl<true, RealIntegerType, CompatibleNumberIntegerType> {
-  // is there an assert somewhere on overflows?
-  using RealLimits = std::numeric_limits<RealIntegerType>;
-  using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
-
-  static constexpr auto value =
-    std::is_constructible<RealIntegerType, CompatibleNumberIntegerType>::value and
-    CompatibleLimits::is_integer and
-    RealLimits::is_signed == CompatibleLimits::is_signed;
-};
-
-template <typename RealIntegerType, typename CompatibleNumberIntegerType>
-struct is_compatible_integer_type {
-  static constexpr auto value =
-                          is_compatible_integer_type_impl <
-                            std::is_integral<CompatibleNumberIntegerType>::value and
-                          not std::is_same<bool, CompatibleNumberIntegerType>::value,
-                        RealIntegerType, CompatibleNumberIntegerType > ::value;
-};
-
-// trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
-template <typename BasicJsonType, typename T>
-struct has_from_json {
- private:
-  // also check the return type of from_json
-  template <typename U, typename = enable_if_t<std::is_same<void, decltype(uncvref_t<U>::from_json(
-                                                                    std::declval<BasicJsonType>(), std::declval<T&>()))>::value>>
-  static int detect(U&&);
-  static void detect(...);
-
- public:
-  static constexpr bool value = std::is_integral<decltype(
-    detect(std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
-};
-
-// This trait checks if JSONSerializer<T>::from_json(json const&) exists
-// this overload is used for non-default-constructible user-defined-types
-template <typename BasicJsonType, typename T>
-struct has_non_default_from_json {
- private:
-  template <
-    typename U,
-    typename = enable_if_t<std::is_same<
-      T, decltype(uncvref_t<U>::from_json(std::declval<BasicJsonType>()))>::value>>
-  static int detect(U&&);
-  static void detect(...);
-
- public:
-  static constexpr bool value = std::is_integral<decltype(detect(
-    std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
-};
-
-// This trait checks if BasicJsonType::json_serializer<T>::to_json exists
-template <typename BasicJsonType, typename T>
-struct has_to_json {
- private:
-  template <typename U, typename = decltype(uncvref_t<U>::to_json(
-                          std::declval<BasicJsonType&>(), std::declval<T>()))>
-  static int detect(U&&);
-  static void detect(...);
-
- public:
-  static constexpr bool value = std::is_integral<decltype(detect(
-    std::declval<typename BasicJsonType::template json_serializer<T, void>>()))>::value;
-};
-
-template <typename BasicJsonType, typename CompatibleCompleteType>
-struct is_compatible_complete_type {
-  static constexpr bool value =
-    not std::is_base_of<std::istream, CompatibleCompleteType>::value and
-    not is_basic_json<CompatibleCompleteType>::value and
-    not is_basic_json_nested_type<BasicJsonType, CompatibleCompleteType>::value and
-    has_to_json<BasicJsonType, CompatibleCompleteType>::value;
-};
-
-template <typename BasicJsonType, typename CompatibleType>
-struct is_compatible_type
-  : conjunction<is_complete_type<CompatibleType>,
-                is_compatible_complete_type<BasicJsonType, CompatibleType>> {
-};
-
-// taken from ranges-v3
-template <typename T>
-struct static_const {
-  static constexpr T value{};
-};
-
-template <typename T>
-constexpr T static_const<T>::value;
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-#include <exception> // exception
-#include <stdexcept> // runtime_error
-#include <string>    // to_string
-
-namespace nlohmann
-{
-namespace detail
-{
-////////////////
-// exceptions //
-////////////////
-
-/*!
-@brief general exception of the @ref basic_json class
-
-This class is an extension of `std::exception` objects with a member @a id for
-exception ids. It is used as the base class for all exceptions thrown by the
-@ref basic_json class. This class can hence be used as "wildcard" to catch
-exceptions.
-
-Subclasses:
-- @ref parse_error for exceptions indicating a parse error
-- @ref invalid_iterator for exceptions indicating errors with iterators
-- @ref type_error for exceptions indicating executing a member function with
-                  a wrong type
-- @ref out_of_range for exceptions indicating access out of the defined range
-- @ref other_error for exceptions indicating other library errors
-
-@internal
-@note To have nothrow-copy-constructible exceptions, we internally use
-      `std::runtime_error` which can cope with arbitrary-length error messages.
-      Intermediate strings are built with static functions and then passed to
-      the actual constructor.
-@endinternal
-
-@liveexample{The following code shows how arbitrary library exceptions can be
-caught.,exception}
-
-@since version 3.0.0
-*/
-class exception : public std::exception
-{
- public:
-  /// returns the explanatory string
-  const char* what() const noexcept override
-  {
-    return m.what();
-  }
-
-  /// the id of the exception
-  const int id;
-
- protected:
-  exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
-
-  static std::string name(const std::string& ename, int id_)
-  {
-    return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
-  }
-
- private:
-  /// an exception object as storage for error messages
-  std::runtime_error m;
-};
-
-/*!
-@brief exception indicating a parse error
-
-This exception is thrown by the library when a parse error occurs. Parse errors
-can occur during the deserialization of JSON text, CBOR, MessagePack, as well
-as when using JSON Patch.
-
-Member @a byte holds the byte index of the last read character in the input
-file.
-
-Exceptions have ids 1xx.
-
-name / id                      | example message | description
------------------------------- | --------------- | -------------------------
-json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.
-json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
-json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
-json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.
-json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.
-json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.
-json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.
-json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.
-json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.
-json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
-json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
-json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
-
-@note For an input with n bytes, 1 is the index of the first character and n+1
-      is the index of the terminating null byte or the end of file. This also
-      holds true when reading a byte vector (CBOR or MessagePack).
-
-@liveexample{The following code shows how a `parse_error` exception can be
-caught.,parse_error}
-
-@sa @ref exception for the base class of the library exceptions
-@sa @ref invalid_iterator for exceptions indicating errors with iterators
-@sa @ref type_error for exceptions indicating executing a member function with
-                    a wrong type
-@sa @ref out_of_range for exceptions indicating access out of the defined range
-@sa @ref other_error for exceptions indicating other library errors
-
-@since version 3.0.0
-*/
-class parse_error : public exception
-{
- public:
-  /*!
-    @brief create a parse error exception
-    @param[in] id_       the id of the exception
-    @param[in] byte_     the byte index where the error occurred (or 0 if the
-                         position cannot be determined)
-    @param[in] what_arg  the explanatory string
-    @return parse_error object
-    */
-  static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
-  {
-    std::string w = exception::name("parse_error", id_) + "parse error" +
-                    (byte_ != 0 ? (" at " + std::to_string(byte_)) : "") +
-                    ": " + what_arg;
-    return parse_error(id_, byte_, w.c_str());
-  }
-
-  /*!
-    @brief byte index of the parse error
-
-    The byte index of the last read character in the input file.
-
-    @note For an input with n bytes, 1 is the index of the first character and
-          n+1 is the index of the terminating null byte or the end of file.
-          This also holds true when reading a byte vector (CBOR or MessagePack).
-    */
-  const std::size_t byte;
-
- private:
-  parse_error(int id_, std::size_t byte_, const char* what_arg)
-    : exception(id_, what_arg), byte(byte_) {}
-};
-
-/*!
-@brief exception indicating errors with iterators
-
-This exception is thrown if iterators passed to a library function do not match
-the expected semantics.
-
-Exceptions have ids 2xx.
-
-name / id                           | example message | description
------------------------------------ | --------------- | -------------------------
-json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
-json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
-json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
-json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
-json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
-json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
-json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
-json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
-json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
-json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
-json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.
-json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.
-json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.
-json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().
-
-@liveexample{The following code shows how an `invalid_iterator` exception can be
-caught.,invalid_iterator}
-
-@sa @ref exception for the base class of the library exceptions
-@sa @ref parse_error for exceptions indicating a parse error
-@sa @ref type_error for exceptions indicating executing a member function with
-                    a wrong type
-@sa @ref out_of_range for exceptions indicating access out of the defined range
-@sa @ref other_error for exceptions indicating other library errors
-
-@since version 3.0.0
-*/
-class invalid_iterator : public exception
-{
- public:
-  static invalid_iterator create(int id_, const std::string& what_arg)
-  {
-    std::string w = exception::name("invalid_iterator", id_) + what_arg;
-    return invalid_iterator(id_, w.c_str());
-  }
-
- private:
-  invalid_iterator(int id_, const char* what_arg)
-    : exception(id_, what_arg) {}
-};
-
-/*!
-@brief exception indicating executing a member function with a wrong type
-
-This exception is thrown in case of a type error; that is, a library function is
-executed on a JSON value whose type does not match the expected semantics.
-
-Exceptions have ids 3xx.
-
-name / id                     | example message | description
------------------------------ | --------------- | -------------------------
-json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
-json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
-json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t&.
-json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.
-json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.
-json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.
-json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.
-json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.
-json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.
-json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.
-json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.
-json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.
-json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.
-json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
-json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
-json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
-
-@liveexample{The following code shows how a `type_error` exception can be
-caught.,type_error}
-
-@sa @ref exception for the base class of the library exceptions
-@sa @ref parse_error for exceptions indicating a parse error
-@sa @ref invalid_iterator for exceptions indicating errors with iterators
-@sa @ref out_of_range for exceptions indicating access out of the defined range
-@sa @ref other_error for exceptions indicating other library errors
-
-@since version 3.0.0
-*/
-class type_error : public exception
-{
- public:
-  static type_error create(int id_, const std::string& what_arg)
-  {
-    std::string w = exception::name("type_error", id_) + what_arg;
-    return type_error(id_, w.c_str());
-  }
-
- private:
-  type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
-};
-
-/*!
-@brief exception indicating access out of the defined range
-
-This exception is thrown in case a library function is called on an input
-parameter that exceeds the expected range, for instance in case of array
-indices or nonexisting object keys.
-
-Exceptions have ids 4xx.
-
-name / id                       | example message | description
-------------------------------- | --------------- | -------------------------
-json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.
-json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
-json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.
-json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
-json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
-json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
-json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON only supports integers numbers up to 9223372036854775807. |
-json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
-
-@liveexample{The following code shows how an `out_of_range` exception can be
-caught.,out_of_range}
-
-@sa @ref exception for the base class of the library exceptions
-@sa @ref parse_error for exceptions indicating a parse error
-@sa @ref invalid_iterator for exceptions indicating errors with iterators
-@sa @ref type_error for exceptions indicating executing a member function with
-                    a wrong type
-@sa @ref other_error for exceptions indicating other library errors
-
-@since version 3.0.0
-*/
-class out_of_range : public exception
-{
- public:
-  static out_of_range create(int id_, const std::string& what_arg)
-  {
-    std::string w = exception::name("out_of_range", id_) + what_arg;
-    return out_of_range(id_, w.c_str());
-  }
-
- private:
-  out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
-};
-
-/*!
-@brief exception indicating other library errors
-
-This exception is thrown in case of errors that cannot be classified with the
-other exception types.
-
-Exceptions have ids 5xx.
-
-name / id                      | example message | description
------------------------------- | --------------- | -------------------------
-json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
-
-@sa @ref exception for the base class of the library exceptions
-@sa @ref parse_error for exceptions indicating a parse error
-@sa @ref invalid_iterator for exceptions indicating errors with iterators
-@sa @ref type_error for exceptions indicating executing a member function with
-                    a wrong type
-@sa @ref out_of_range for exceptions indicating access out of the defined range
-
-@liveexample{The following code shows how an `other_error` exception can be
-caught.,other_error}
-
-@since version 3.0.0
-*/
-class other_error : public exception
-{
- public:
-  static other_error create(int id_, const std::string& what_arg)
-  {
-    std::string w = exception::name("other_error", id_) + what_arg;
-    return other_error(id_, w.c_str());
-  }
-
- private:
-  other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/value_t.hpp>
-
-#include <array>   // array
-#include <ciso646> // and
-#include <cstddef> // size_t
-#include <cstdint> // uint8_t
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////////////////////
-// JSON type enumeration //
-///////////////////////////
-
-/*!
-@brief the JSON type enumeration
-
-This enumeration collects the different JSON types. It is internally used to
-distinguish the stored values, and the functions @ref basic_json::is_null(),
-@ref basic_json::is_object(), @ref basic_json::is_array(),
-@ref basic_json::is_string(), @ref basic_json::is_boolean(),
-@ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
-@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
-@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
-@ref basic_json::is_structured() rely on it.
-
-@note There are three enumeration entries (number_integer, number_unsigned, and
-number_float), because the library distinguishes these three types for numbers:
-@ref basic_json::number_unsigned_t is used for unsigned integers,
-@ref basic_json::number_integer_t is used for signed integers, and
-@ref basic_json::number_float_t is used for floating-point numbers or to
-approximate integers which do not fit in the limits of their respective type.
-
-@sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
-value with the default value for a given type
-
-@since version 1.0.0
-*/
-enum class value_t : std::uint8_t {
-  null,            ///< null value
-  object,          ///< object (unordered set of name/value pairs)
-  array,           ///< array (ordered collection of values)
-  string,          ///< string value
-  boolean,         ///< boolean value
-  number_integer,  ///< number value (signed integer)
-  number_unsigned, ///< number value (unsigned integer)
-  number_float,    ///< number value (floating-point)
-  discarded        ///< discarded by the the parser callback function
-};
-
-/*!
-@brief comparison operator for JSON types
-
-Returns an ordering that is similar to Python:
-- order: null < boolean < number < object < array < string
-- furthermore, each type is not smaller than itself
-- discarded values are not comparable
-
-@since version 1.0.0
-*/
-inline bool operator<(const value_t lhs, const value_t rhs) noexcept
-{
-  static constexpr std::array<std::uint8_t, 8> order = {{
-    0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
-    1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */
-  }};
-
-  const auto l_index = static_cast<std::size_t>(lhs);
-  const auto r_index = static_cast<std::size_t>(rhs);
-  return l_index < order.size() and r_index < order.size() and order[l_index] < order[r_index];
-}
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/conversions/from_json.hpp>
-
-#include <algorithm>    // transform
-#include <array>        // array
-#include <ciso646>      // and, not
-#include <forward_list> // forward_list
-#include <iterator>     // inserter, front_inserter, end
-#include <string>       // string
-#include <tuple>        // tuple, make_tuple
-#include <type_traits>  // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
-#include <utility>      // pair, declval
-#include <valarray>     // valarray
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-// overloads for basic_json template parameters
-template <typename BasicJsonType, typename ArithmeticType,
-          enable_if_t<std::is_arithmetic<ArithmeticType>::value and
-                        not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
-                      int> = 0>
-void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
-{
-  switch (static_cast<value_t>(j)) {
-    case value_t::number_unsigned: {
-      val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
-      break;
-    }
-    case value_t::number_integer: {
-      val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
-      break;
-    }
-    case value_t::number_float: {
-      val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
-      break;
-    }
-
-    default:
-      JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
-  }
-}
-
-template <typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
-{
-  if (JSON_UNLIKELY(not j.is_boolean())) {
-    JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
-  }
-  b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
-}
-
-template <typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
-{
-  if (JSON_UNLIKELY(not j.is_string())) {
-    JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
-  }
-  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
-}
-
-template <typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
-{
-  get_arithmetic_value(j, val);
-}
-
-template <typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
-{
-  get_arithmetic_value(j, val);
-}
-
-template <typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
-{
-  get_arithmetic_value(j, val);
-}
-
-template <typename BasicJsonType, typename EnumType,
-          enable_if_t<std::is_enum<EnumType>::value, int> = 0>
-void from_json(const BasicJsonType& j, EnumType& e)
-{
-  typename std::underlying_type<EnumType>::type val;
-  get_arithmetic_value(j, val);
-  e = static_cast<EnumType>(val);
-}
-
-template <typename BasicJsonType>
-void from_json(const BasicJsonType& j, typename BasicJsonType::array_t& arr)
-{
-  if (JSON_UNLIKELY(not j.is_array())) {
-    JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
-  }
-  arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
-}
-
-// forward_list doesn't have an insert method
-template <typename BasicJsonType, typename T, typename Allocator,
-          enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
-void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
-{
-  if (JSON_UNLIKELY(not j.is_array())) {
-    JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
-  }
-  std::transform(j.rbegin(), j.rend(),
-                 std::front_inserter(l), [](const BasicJsonType& i) {
-                   return i.template get<T>();
-                 });
-}
-
-// valarray doesn't have an insert method
-template <typename BasicJsonType, typename T,
-          enable_if_t<std::is_convertible<BasicJsonType, T>::value, int> = 0>
-void from_json(const BasicJsonType& j, std::valarray<T>& l)
-{
-  if (JSON_UNLIKELY(not j.is_array())) {
-    JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
-  }
-  l.resize(j.size());
-  std::copy(j.m_value.array->begin(), j.m_value.array->end(), std::begin(l));
-}
-
-template <typename BasicJsonType, typename CompatibleArrayType>
-void from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<0> /*unused*/)
-{
-  using std::end;
-
-  std::transform(j.begin(), j.end(),
-                 std::inserter(arr, end(arr)), [](const BasicJsonType& i) {
-                   // get<BasicJsonType>() returns *this, this won't call a from_json
-                   // method when value_type is BasicJsonType
-                   return i.template get<typename CompatibleArrayType::value_type>();
-                 });
-}
-
-template <typename BasicJsonType, typename CompatibleArrayType>
-auto from_json_array_impl(const BasicJsonType& j, CompatibleArrayType& arr, priority_tag<1> /*unused*/)
-  -> decltype(
-    arr.reserve(std::declval<typename CompatibleArrayType::size_type>()),
-    void())
-{
-  using std::end;
-
-  arr.reserve(j.size());
-  std::transform(j.begin(), j.end(),
-                 std::inserter(arr, end(arr)), [](const BasicJsonType& i) {
-                   // get<BasicJsonType>() returns *this, this won't call a from_json
-                   // method when value_type is BasicJsonType
-                   return i.template get<typename CompatibleArrayType::value_type>();
-                 });
-}
-
-template <typename BasicJsonType, typename T, std::size_t N>
-void from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr, priority_tag<2> /*unused*/)
-{
-  for (std::size_t i = 0; i < N; ++i) {
-    arr[i] = j.at(i).template get<T>();
-  }
-}
-
-template <
-  typename BasicJsonType, typename CompatibleArrayType,
-  enable_if_t<
-    is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value and
-      not std::is_same<typename BasicJsonType::array_t,
-                       CompatibleArrayType>::value and
-      std::is_constructible<
-        BasicJsonType, typename CompatibleArrayType::value_type>::value,
-    int> = 0>
-void from_json(const BasicJsonType& j, CompatibleArrayType& arr)
-{
-  if (JSON_UNLIKELY(not j.is_array())) {
-    JSON_THROW(type_error::create(302, "type must be array, but is " +
-                                         std::string(j.type_name())));
-  }
-
-  from_json_array_impl(j, arr, priority_tag<2>{});
-}
-
-template <typename BasicJsonType, typename CompatibleObjectType,
-          enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>
-void from_json(const BasicJsonType& j, CompatibleObjectType& obj)
-{
-  if (JSON_UNLIKELY(not j.is_object())) {
-    JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
-  }
-
-  auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
-  using value_type = typename CompatibleObjectType::value_type;
-  std::transform(
-    inner_object->begin(), inner_object->end(),
-    std::inserter(obj, obj.begin()),
-    [](typename BasicJsonType::object_t::value_type const& p) {
-      return value_type(p.first, p.second.template get<typename CompatibleObjectType::mapped_type>());
-    });
-}
-
-// overload for arithmetic types, not chosen for basic_json template arguments
-// (BooleanType, etc..); note: Is it really necessary to provide explicit
-// overloads for boolean_t etc. in case of a custom BooleanType which is not
-// an arithmetic type?
-template <typename BasicJsonType, typename ArithmeticType,
-          enable_if_t<
-            std::is_arithmetic<ArithmeticType>::value and
-              not std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value and
-              not std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value and
-              not std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value and
-              not std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
-            int> = 0>
-void from_json(const BasicJsonType& j, ArithmeticType& val)
-{
-  switch (static_cast<value_t>(j)) {
-    case value_t::number_unsigned: {
-      val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
-      break;
-    }
-    case value_t::number_integer: {
-      val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
-      break;
-    }
-    case value_t::number_float: {
-      val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
-      break;
-    }
-    case value_t::boolean: {
-      val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
-      break;
-    }
-
-    default:
-      JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
-  }
-}
-
-template <typename BasicJsonType, typename A1, typename A2>
-void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
-{
-  p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
-}
-
-template <typename BasicJsonType, typename Tuple, std::size_t... Idx>
-void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...>)
-{
-  t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
-}
-
-template <typename BasicJsonType, typename... Args>
-void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
-{
-  from_json_tuple_impl(j, t, index_sequence_for<Args...>{});
-}
-
-struct from_json_fn {
- private:
-  template <typename BasicJsonType, typename T>
-  auto call(const BasicJsonType& j, T& val, priority_tag<1> /*unused*/) const
-    noexcept(noexcept(from_json(j, val)))
-      -> decltype(from_json(j, val), void())
-  {
-    return from_json(j, val);
-  }
-
-  template <typename BasicJsonType, typename T>
-  void call(const BasicJsonType& /*unused*/, T& /*unused*/, priority_tag<0> /*unused*/) const noexcept
-  {
-    static_assert(sizeof(BasicJsonType) == 0,
-                  "could not find from_json() method in T's namespace");
-#ifdef _MSC_VER
-    // MSVC does not show a stacktrace for the above assert
-    using decayed = uncvref_t<T>;
-    static_assert(sizeof(typename decayed::force_msvc_stacktrace) == 0,
-                  "forcing MSVC stacktrace to show which T we're talking about.");
-#endif
-  }
-
- public:
-  template <typename BasicJsonType, typename T>
-  void operator()(const BasicJsonType& j, T& val) const
-    noexcept(noexcept(std::declval<from_json_fn>().call(j, val, priority_tag<1>{})))
-  {
-    return call(j, val, priority_tag<1>{});
-  }
-};
-} // namespace detail
-
-/// namespace to hold default `from_json` function
-/// to see why this is required:
-/// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
-namespace
-{
-constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
-}
-} // namespace nlohmann
-
-// #include <nlohmann/detail/conversions/to_json.hpp>
-
-#include <ciso646>     // or, and, not
-#include <iterator>    // begin, end
-#include <tuple>       // tuple, get
-#include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
-#include <utility>     // move, forward, declval, pair
-#include <valarray>    // valarray
-#include <vector>      // vector
-
-// #include <nlohmann/detail/meta.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-//////////////////
-// constructors //
-//////////////////
-
-template <value_t>
-struct external_constructor;
-
-template <>
-struct external_constructor<value_t::boolean> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
-  {
-    j.m_type = value_t::boolean;
-    j.m_value = b;
-    j.assert_invariant();
-  }
-};
-
-template <>
-struct external_constructor<value_t::string> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
-  {
-    j.m_type = value_t::string;
-    j.m_value = s;
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
-  {
-    j.m_type = value_t::string;
-    j.m_value = std::move(s);
-    j.assert_invariant();
-  }
-};
-
-template <>
-struct external_constructor<value_t::number_float> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
-  {
-    j.m_type = value_t::number_float;
-    j.m_value = val;
-    j.assert_invariant();
-  }
-};
-
-template <>
-struct external_constructor<value_t::number_unsigned> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
-  {
-    j.m_type = value_t::number_unsigned;
-    j.m_value = val;
-    j.assert_invariant();
-  }
-};
-
-template <>
-struct external_constructor<value_t::number_integer> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
-  {
-    j.m_type = value_t::number_integer;
-    j.m_value = val;
-    j.assert_invariant();
-  }
-};
-
-template <>
-struct external_constructor<value_t::array> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
-  {
-    j.m_type = value_t::array;
-    j.m_value = arr;
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
-  {
-    j.m_type = value_t::array;
-    j.m_value = std::move(arr);
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType, typename CompatibleArrayType,
-            enable_if_t<not std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
-                        int> = 0>
-  static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
-  {
-    using std::begin;
-    using std::end;
-    j.m_type = value_t::array;
-    j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, const std::vector<bool>& arr)
-  {
-    j.m_type = value_t::array;
-    j.m_value = value_t::array;
-    j.m_value.array->reserve(arr.size());
-    for (const bool x : arr) {
-      j.m_value.array->push_back(x);
-    }
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType, typename T,
-            enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
-  static void construct(BasicJsonType& j, const std::valarray<T>& arr)
-  {
-    j.m_type = value_t::array;
-    j.m_value = value_t::array;
-    j.m_value.array->resize(arr.size());
-    std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
-    j.assert_invariant();
-  }
-};
-
-template <>
-struct external_constructor<value_t::object> {
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
-  {
-    j.m_type = value_t::object;
-    j.m_value = obj;
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType>
-  static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
-  {
-    j.m_type = value_t::object;
-    j.m_value = std::move(obj);
-    j.assert_invariant();
-  }
-
-  template <typename BasicJsonType, typename CompatibleObjectType,
-            enable_if_t<not std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int> = 0>
-  static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
-  {
-    using std::begin;
-    using std::end;
-
-    j.m_type = value_t::object;
-    j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
-    j.assert_invariant();
-  }
-};
-
-/////////////
-// to_json //
-/////////////
-
-template <typename BasicJsonType, typename T,
-          enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
-void to_json(BasicJsonType& j, T b) noexcept
-{
-  external_constructor<value_t::boolean>::construct(j, b);
-}
-
-template <typename BasicJsonType, typename CompatibleString,
-          enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
-void to_json(BasicJsonType& j, const CompatibleString& s)
-{
-  external_constructor<value_t::string>::construct(j, s);
-}
-
-template <typename BasicJsonType>
-void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
-{
-  external_constructor<value_t::string>::construct(j, std::move(s));
-}
-
-template <typename BasicJsonType, typename FloatType,
-          enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
-void to_json(BasicJsonType& j, FloatType val) noexcept
-{
-  external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
-}
-
-template <typename BasicJsonType, typename CompatibleNumberUnsignedType,
-          enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
-void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
-{
-  external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
-}
-
-template <typename BasicJsonType, typename CompatibleNumberIntegerType,
-          enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
-void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
-{
-  external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
-}
-
-template <typename BasicJsonType, typename EnumType,
-          enable_if_t<std::is_enum<EnumType>::value, int> = 0>
-void to_json(BasicJsonType& j, EnumType e) noexcept
-{
-  using underlying_type = typename std::underlying_type<EnumType>::type;
-  external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
-}
-
-template <typename BasicJsonType>
-void to_json(BasicJsonType& j, const std::vector<bool>& e)
-{
-  external_constructor<value_t::array>::construct(j, e);
-}
-
-template <typename BasicJsonType, typename CompatibleArrayType,
-          enable_if_t<is_compatible_array_type<BasicJsonType, CompatibleArrayType>::value or
-                        std::is_same<typename BasicJsonType::array_t, CompatibleArrayType>::value,
-                      int> = 0>
-void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
-{
-  external_constructor<value_t::array>::construct(j, arr);
-}
-
-template <typename BasicJsonType, typename T,
-          enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
-void to_json(BasicJsonType& j, std::valarray<T> arr)
-{
-  external_constructor<value_t::array>::construct(j, std::move(arr));
-}
-
-template <typename BasicJsonType>
-void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
-{
-  external_constructor<value_t::array>::construct(j, std::move(arr));
-}
-
-template <typename BasicJsonType, typename CompatibleObjectType,
-          enable_if_t<is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value, int> = 0>
-void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
-{
-  external_constructor<value_t::object>::construct(j, obj);
-}
-
-template <typename BasicJsonType>
-void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
-{
-  external_constructor<value_t::object>::construct(j, std::move(obj));
-}
-
-template <typename BasicJsonType, typename T, std::size_t N,
-          enable_if_t<not std::is_constructible<typename BasicJsonType::string_t, T (&)[N]>::value, int> = 0>
-void to_json(BasicJsonType& j, T (&arr)[N])
-{
-  external_constructor<value_t::array>::construct(j, arr);
-}
-
-template <typename BasicJsonType, typename... Args>
-void to_json(BasicJsonType& j, const std::pair<Args...>& p)
-{
-  j = {p.first, p.second};
-}
-
-template <typename BasicJsonType, typename Tuple, std::size_t... Idx>
-void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...>)
-{
-  j = {std::get<Idx>(t)...};
-}
-
-template <typename BasicJsonType, typename... Args>
-void to_json(BasicJsonType& j, const std::tuple<Args...>& t)
-{
-  to_json_tuple_impl(j, t, index_sequence_for<Args...>{});
-}
-
-struct to_json_fn {
- private:
-  template <typename BasicJsonType, typename T>
-  auto call(BasicJsonType& j, T&& val, priority_tag<1> /*unused*/) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
-    -> decltype(to_json(j, std::forward<T>(val)), void())
-  {
-    return to_json(j, std::forward<T>(val));
-  }
-
-  template <typename BasicJsonType, typename T>
-  void call(BasicJsonType& /*unused*/, T&& /*unused*/, priority_tag<0> /*unused*/) const noexcept
-  {
-    static_assert(sizeof(BasicJsonType) == 0,
-                  "could not find to_json() method in T's namespace");
-
-#ifdef _MSC_VER
-    // MSVC does not show a stacktrace for the above assert
-    using decayed = uncvref_t<T>;
-    static_assert(sizeof(typename decayed::force_msvc_stacktrace) == 0,
-                  "forcing MSVC stacktrace to show which T we're talking about.");
-#endif
-  }
-
- public:
-  template <typename BasicJsonType, typename T>
-  void operator()(BasicJsonType& j, T&& val) const
-    noexcept(noexcept(std::declval<to_json_fn>().call(j, std::forward<T>(val), priority_tag<1>{})))
-  {
-    return call(j, std::forward<T>(val), priority_tag<1>{});
-  }
-};
-} // namespace detail
-
-/// namespace to hold default `to_json` function
-namespace
-{
-constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
-}
-} // namespace nlohmann
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-#include <algorithm>   // min
-#include <array>       // array
-#include <cassert>     // assert
-#include <cstddef>     // size_t
-#include <cstring>     // strlen
-#include <ios>         // streamsize, streamoff, streampos
-#include <istream>     // istream
-#include <iterator>    // begin, end, iterator_traits, random_access_iterator_tag, distance, next
-#include <memory>      // shared_ptr, make_shared, addressof
-#include <numeric>     // accumulate
-#include <string>      // string, char_traits
-#include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
-#include <utility>     // pair, declval
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-////////////////////
-// input adapters //
-////////////////////
-
-/*!
-@brief abstract input adapter interface
-
-Produces a stream of std::char_traits<char>::int_type characters from a
-std::istream, a buffer, or some other input type.  Accepts the return of exactly
-one non-EOF character for future input.  The int_type characters returned
-consist of all valid char values as positive values (typically unsigned char),
-plus an EOF value outside that range, specified by the value of the function
-std::char_traits<char>::eof().  This value is typically -1, but could be any
-arbitrary value which is not a valid char value.
-*/
-struct input_adapter_protocol {
-  /// get a character [0,255] or std::char_traits<char>::eof().
-  virtual std::char_traits<char>::int_type get_character() = 0;
-  /// restore the last non-eof() character to input
-  virtual void unget_character() = 0;
-  virtual ~input_adapter_protocol() = default;
-};
-
-/// a type to simplify interfaces
-using input_adapter_t = std::shared_ptr<input_adapter_protocol>;
-
-/*!
-Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
-beginning of input. Does not support changing the underlying std::streambuf
-in mid-input. Maintains underlying std::istream and std::streambuf to support
-subsequent use of standard std::istream operations to process any input
-characters following those used in parsing the JSON input.  Clears the
-std::istream flags; any input errors (e.g., EOF) will be detected by the first
-subsequent call for input from the std::istream.
-*/
-class input_stream_adapter : public input_adapter_protocol
-{
- public:
-  ~input_stream_adapter() override
-  {
-    // clear stream flags; we use underlying streambuf I/O, do not
-    // maintain ifstream flags
-    is.clear();
-  }
-
-  explicit input_stream_adapter(std::istream& i)
-    : is(i), sb(*i.rdbuf())
-  {
-    // skip byte order mark
-    std::char_traits<char>::int_type c;
-    if ((c = get_character()) == 0xEF) {
-      if ((c = get_character()) == 0xBB) {
-        if ((c = get_character()) == 0xBF) {
-          return; // Ignore BOM
-        } else if (c != std::char_traits<char>::eof()) {
-          is.unget();
-        }
-        is.putback('\xBB');
-      } else if (c != std::char_traits<char>::eof()) {
-        is.unget();
-      }
-      is.putback('\xEF');
-    } else if (c != std::char_traits<char>::eof()) {
-      is.unget(); // no byte order mark; process as usual
-    }
-  }
-
-  // delete because of pointer members
-  input_stream_adapter(const input_stream_adapter&) = delete;
-  input_stream_adapter& operator=(input_stream_adapter&) = delete;
-
-  // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
-  // ensure that std::char_traits<char>::eof() and the character 0xFF do not
-  // end up as the same value, eg. 0xFFFFFFFF.
-  std::char_traits<char>::int_type get_character() override
-  {
-    return sb.sbumpc();
-  }
-
-  void unget_character() override
-  {
-    sb.sungetc(); // is.unget() avoided for performance
-  }
-
- private:
-  /// the associated input stream
-  std::istream& is;
-  std::streambuf& sb;
-};
-
-/// input adapter for buffer input
-class input_buffer_adapter : public input_adapter_protocol
-{
- public:
-  input_buffer_adapter(const char* b, const std::size_t l)
-    : cursor(b), limit(b + l), start(b)
-  {
-    // skip byte order mark
-    if (l >= 3 and b[0] == '\xEF' and b[1] == '\xBB' and b[2] == '\xBF') {
-      cursor += 3;
-    }
-  }
-
-  // delete because of pointer members
-  input_buffer_adapter(const input_buffer_adapter&) = delete;
-  input_buffer_adapter& operator=(input_buffer_adapter&) = delete;
-
-  std::char_traits<char>::int_type get_character() noexcept override
-  {
-    if (JSON_LIKELY(cursor < limit)) {
-      return std::char_traits<char>::to_int_type(*(cursor++));
-    }
-
-    return std::char_traits<char>::eof();
-  }
-
-  void unget_character() noexcept override
-  {
-    if (JSON_LIKELY(cursor > start)) {
-      --cursor;
-    }
-  }
-
- private:
-  /// pointer to the current character
-  const char* cursor;
-  /// pointer past the last character
-  const char* limit;
-  /// pointer to the first character
-  const char* start;
-};
-
-class input_adapter
-{
- public:
-  // native support
-
-  /// input adapter for input stream
-  input_adapter(std::istream& i)
-    : ia(std::make_shared<input_stream_adapter>(i)) {}
-
-  /// input adapter for input stream
-  input_adapter(std::istream&& i)
-    : ia(std::make_shared<input_stream_adapter>(i)) {}
-
-  /// input adapter for buffer
-  template <typename CharT,
-            typename std::enable_if<
-              std::is_pointer<CharT>::value and
-                std::is_integral<typename std::remove_pointer<CharT>::type>::value and
-                sizeof(typename std::remove_pointer<CharT>::type) == 1,
-              int>::type = 0>
-  input_adapter(CharT b, std::size_t l)
-    : ia(std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(b), l))
-  {
-  }
-
-  // derived support
-
-  /// input adapter for string literal
-  template <typename CharT,
-            typename std::enable_if<
-              std::is_pointer<CharT>::value and
-                std::is_integral<typename std::remove_pointer<CharT>::type>::value and
-                sizeof(typename std::remove_pointer<CharT>::type) == 1,
-              int>::type = 0>
-  input_adapter(CharT b)
-    : input_adapter(reinterpret_cast<const char*>(b),
-                    std::strlen(reinterpret_cast<const char*>(b)))
-  {
-  }
-
-  /// input adapter for iterator range with contiguous storage
-  template <class IteratorType,
-            typename std::enable_if<
-              std::is_same<typename std::iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
-              int>::type = 0>
-  input_adapter(IteratorType first, IteratorType last)
-  {
-    // assertion to check that the iterator range is indeed contiguous,
-    // see http://stackoverflow.com/a/35008842/266378 for more discussion
-    assert(std::accumulate(
-             first, last, std::pair<bool, int>(true, 0),
-             [&first](std::pair<bool, int> res, decltype(*first) val) {
-               res.first &= (val == *(std::next(std::addressof(*first), res.second++)));
-               return res;
-             })
-             .first);
-
-    // assertion to check that each element is 1 byte long
-    static_assert(
-      sizeof(typename std::iterator_traits<IteratorType>::value_type) == 1,
-      "each element in the iterator range must have the size of 1 byte");
-
-    const auto len = static_cast<size_t>(std::distance(first, last));
-    if (JSON_LIKELY(len > 0)) {
-      // there is at least one element: use the address of first
-      ia = std::make_shared<input_buffer_adapter>(reinterpret_cast<const char*>(&(*first)), len);
-    } else {
-      // the address of first cannot be used: use nullptr
-      ia = std::make_shared<input_buffer_adapter>(nullptr, len);
-    }
-  }
-
-  /// input adapter for array
-  template <class T, std::size_t N>
-  input_adapter(T (&array)[N])
-    : input_adapter(std::begin(array), std::end(array))
-  {
-  }
-
-  /// input adapter for contiguous container
-  template <class ContiguousContainer, typename std::enable_if<not std::is_pointer<ContiguousContainer>::value and
-                                                                 std::is_base_of<std::random_access_iterator_tag, typename std::iterator_traits<decltype(std::begin(std::declval<ContiguousContainer const>()))>::iterator_category>::value,
-                                                               int>::type = 0>
-  input_adapter(const ContiguousContainer& c)
-    : input_adapter(std::begin(c), std::end(c))
-  {
-  }
-
-  operator input_adapter_t()
-  {
-    return ia;
-  }
-
- private:
-  /// the actual adapter
-  input_adapter_t ia = nullptr;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/input/lexer.hpp>
-
-#include <clocale>          // localeconv
-#include <cstddef>          // size_t
-#include <cstdlib>          // strtof, strtod, strtold, strtoll, strtoull
-#include <initializer_list> // initializer_list
-#include <ios>              // hex, uppercase
-#include <iomanip>          // setw, setfill
-#include <sstream>          // stringstream
-#include <string>           // char_traits, string
-#include <vector>           // vector
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////
-// lexer //
-///////////
-
-/*!
-@brief lexical analysis
-
-This class organizes the lexical analysis during JSON deserialization.
-*/
-template <typename BasicJsonType>
-class lexer
-{
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-
- public:
-  /// token types for the parser
-  enum class token_type {
-    uninitialized,   ///< indicating the scanner is uninitialized
-    literal_true,    ///< the `true` literal
-    literal_false,   ///< the `false` literal
-    literal_null,    ///< the `null` literal
-    value_string,    ///< a string -- use get_string() for actual value
-    value_unsigned,  ///< an unsigned integer -- use get_number_unsigned() for actual value
-    value_integer,   ///< a signed integer -- use get_number_integer() for actual value
-    value_float,     ///< an floating point number -- use get_number_float() for actual value
-    begin_array,     ///< the character for array begin `[`
-    begin_object,    ///< the character for object begin `{`
-    end_array,       ///< the character for array end `]`
-    end_object,      ///< the character for object end `}`
-    name_separator,  ///< the name separator `:`
-    value_separator, ///< the value separator `,`
-    parse_error,     ///< indicating a parse error
-    end_of_input,    ///< indicating the end of the input buffer
-    literal_or_value ///< a literal or the begin of a value (only for diagnostics)
-  };
-
-  /// return name of values of type token_type (only used for errors)
-  static const char* token_type_name(const token_type t) noexcept
-  {
-    switch (t) {
-      case token_type::uninitialized:
-        return "<uninitialized>";
-      case token_type::literal_true:
-        return "true literal";
-      case token_type::literal_false:
-        return "false literal";
-      case token_type::literal_null:
-        return "null literal";
-      case token_type::value_string:
-        return "string literal";
-      case lexer::token_type::value_unsigned:
-      case lexer::token_type::value_integer:
-      case lexer::token_type::value_float:
-        return "number literal";
-      case token_type::begin_array:
-        return "'['";
-      case token_type::begin_object:
-        return "'{'";
-      case token_type::end_array:
-        return "']'";
-      case token_type::end_object:
-        return "'}'";
-      case token_type::name_separator:
-        return "':'";
-      case token_type::value_separator:
-        return "','";
-      case token_type::parse_error:
-        return "<parse error>";
-      case token_type::end_of_input:
-        return "end of input";
-      case token_type::literal_or_value:
-        return "'[', '{', or a literal";
-      default:                  // catch non-enum values
-        return "unknown token"; // LCOV_EXCL_LINE
-    }
-  }
-
-  explicit lexer(detail::input_adapter_t adapter)
-    : ia(std::move(adapter)), decimal_point_char(get_decimal_point()) {}
-
-  // delete because of pointer members
-  lexer(const lexer&) = delete;
-  lexer& operator=(lexer&) = delete;
-
- private:
-  /////////////////////
-  // locales
-  /////////////////////
-
-  /// return the locale-dependent decimal point
-  static char get_decimal_point() noexcept
-  {
-    const auto loc = localeconv();
-    assert(loc != nullptr);
-    return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
-  }
-
-  /////////////////////
-  // scan functions
-  /////////////////////
-
-  /*!
-    @brief get codepoint from 4 hex characters following `\u`
-
-    For input "\u c1 c2 c3 c4" the codepoint is:
-      (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
-    = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
-
-    Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
-    must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
-    conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
-    between the ASCII value of the character and the desired integer value.
-
-    @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
-            non-hex character)
-    */
-  int get_codepoint()
-  {
-    // this function only makes sense after reading `\u`
-    assert(current == 'u');
-    int codepoint = 0;
-
-    const auto factors = {12, 8, 4, 0};
-    for (const auto factor : factors) {
-      get();
-
-      if (current >= '0' and current <= '9') {
-        codepoint += ((current - 0x30) << factor);
-      } else if (current >= 'A' and current <= 'F') {
-        codepoint += ((current - 0x37) << factor);
-      } else if (current >= 'a' and current <= 'f') {
-        codepoint += ((current - 0x57) << factor);
-      } else {
-        return -1;
-      }
-    }
-
-    assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
-    return codepoint;
-  }
-
-  /*!
-    @brief check if the next byte(s) are inside a given range
-
-    Adds the current byte and, for each passed range, reads a new byte and
-    checks if it is inside the range. If a violation was detected, set up an
-    error message and return false. Otherwise, return true.
-
-    @param[in] ranges  list of integers; interpreted as list of pairs of
-                       inclusive lower and upper bound, respectively
-
-    @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
-         1, 2, or 3 pairs. This precondition is enforced by an assertion.
-
-    @return true if and only if no range violation was detected
-    */
-  bool next_byte_in_range(std::initializer_list<int> ranges)
-  {
-    assert(ranges.size() == 2 or ranges.size() == 4 or ranges.size() == 6);
-    add(current);
-
-    for (auto range = ranges.begin(); range != ranges.end(); ++range) {
-      get();
-      if (JSON_LIKELY(*range <= current and current <= *(++range))) {
-        add(current);
-      } else {
-        error_message = "invalid string: ill-formed UTF-8 byte";
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  /*!
-    @brief scan a string literal
-
-    This function scans a string according to Sect. 7 of RFC 7159. While
-    scanning, bytes are escaped and copied into buffer token_buffer. Then the
-    function returns successfully, token_buffer is *not* null-terminated (as it
-    may contain \0 bytes), and token_buffer.size() is the number of bytes in the
-    string.
-
-    @return token_type::value_string if string could be successfully scanned,
-            token_type::parse_error otherwise
-
-    @note In case of errors, variable error_message contains a textual
-          description.
-    */
-  token_type scan_string()
-  {
-    // reset token_buffer (ignore opening quote)
-    reset();
-
-    // we entered the function by reading an open quote
-    assert(current == '\"');
-
-    while (true) {
-      // get next character
-      switch (get()) {
-        // end of file while parsing string
-        case std::char_traits<char>::eof(): {
-          error_message = "invalid string: missing closing quote";
-          return token_type::parse_error;
-        }
-
-        // closing quote
-        case '\"': {
-          return token_type::value_string;
-        }
-
-        // escapes
-        case '\\': {
-          switch (get()) {
-            // quotation mark
-            case '\"':
-              add('\"');
-              break;
-            // reverse solidus
-            case '\\':
-              add('\\');
-              break;
-            // solidus
-            case '/':
-              add('/');
-              break;
-            // backspace
-            case 'b':
-              add('\b');
-              break;
-            // form feed
-            case 'f':
-              add('\f');
-              break;
-            // line feed
-            case 'n':
-              add('\n');
-              break;
-            // carriage return
-            case 'r':
-              add('\r');
-              break;
-            // tab
-            case 't':
-              add('\t');
-              break;
-
-            // unicode escapes
-            case 'u': {
-              const int codepoint1 = get_codepoint();
-              int codepoint = codepoint1; // start with codepoint1
-
-              if (JSON_UNLIKELY(codepoint1 == -1)) {
-                error_message = R"(invalid string: '\u' must be followed by 4 hex digits)";
-                return token_type::parse_error;
-              }
-
-              // check if code point is a high surrogate
-              if (0xD800 <= codepoint1 and codepoint1 <= 0xDBFF) {
-                // expect next \uxxxx entry
-                if (JSON_LIKELY(get() == '\\' and get() == 'u')) {
-                  const int codepoint2 = get_codepoint();
-
-                  if (JSON_UNLIKELY(codepoint2 == -1)) {
-                    error_message = R"(invalid string: '\u' must be followed by 4 hex digits)";
-                    return token_type::parse_error;
-                  }
-
-                  // check if codepoint2 is a low surrogate
-                  if (JSON_LIKELY(0xDC00 <= codepoint2 and codepoint2 <= 0xDFFF)) {
-                    // overwrite codepoint
-                    codepoint =
-                      // high surrogate occupies the most significant 22 bits
-                      (codepoint1 << 10)
-                      // low surrogate occupies the least significant 15 bits
-                      + codepoint2
-                      // there is still the 0xD800, 0xDC00 and 0x10000 noise
-                      // in the result so we have to subtract with:
-                      // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
-                      - 0x35FDC00;
-                  } else {
-                    error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
-                    return token_type::parse_error;
-                  }
-                } else {
-                  error_message = "invalid string: surrogate U+DC00..U+DFFF must be followed by U+DC00..U+DFFF";
-                  return token_type::parse_error;
-                }
-              } else {
-                if (JSON_UNLIKELY(0xDC00 <= codepoint1 and codepoint1 <= 0xDFFF)) {
-                  error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
-                  return token_type::parse_error;
-                }
-              }
-
-              // result of the above calculation yields a proper codepoint
-              assert(0x00 <= codepoint and codepoint <= 0x10FFFF);
-
-              // translate codepoint into bytes
-              if (codepoint < 0x80) {
-                // 1-byte characters: 0xxxxxxx (ASCII)
-                add(codepoint);
-              } else if (codepoint <= 0x7FF) {
-                // 2-byte characters: 110xxxxx 10xxxxxx
-                add(0xC0 | (codepoint >> 6));
-                add(0x80 | (codepoint & 0x3F));
-              } else if (codepoint <= 0xFFFF) {
-                // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
-                add(0xE0 | (codepoint >> 12));
-                add(0x80 | ((codepoint >> 6) & 0x3F));
-                add(0x80 | (codepoint & 0x3F));
-              } else {
-                // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-                add(0xF0 | (codepoint >> 18));
-                add(0x80 | ((codepoint >> 12) & 0x3F));
-                add(0x80 | ((codepoint >> 6) & 0x3F));
-                add(0x80 | (codepoint & 0x3F));
-              }
-
-              break;
-            }
-
-            // other characters after escape
-            default:
-              error_message = "invalid string: forbidden character after backslash";
-              return token_type::parse_error;
-          }
-
-          break;
-        }
-
-        // invalid control characters
-        case 0x00:
-        case 0x01:
-        case 0x02:
-        case 0x03:
-        case 0x04:
-        case 0x05:
-        case 0x06:
-        case 0x07:
-        case 0x08:
-        case 0x09:
-        case 0x0A:
-        case 0x0B:
-        case 0x0C:
-        case 0x0D:
-        case 0x0E:
-        case 0x0F:
-        case 0x10:
-        case 0x11:
-        case 0x12:
-        case 0x13:
-        case 0x14:
-        case 0x15:
-        case 0x16:
-        case 0x17:
-        case 0x18:
-        case 0x19:
-        case 0x1A:
-        case 0x1B:
-        case 0x1C:
-        case 0x1D:
-        case 0x1E:
-        case 0x1F: {
-          error_message = "invalid string: control character must be escaped";
-          return token_type::parse_error;
-        }
-
-        // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
-        case 0x20:
-        case 0x21:
-        case 0x23:
-        case 0x24:
-        case 0x25:
-        case 0x26:
-        case 0x27:
-        case 0x28:
-        case 0x29:
-        case 0x2A:
-        case 0x2B:
-        case 0x2C:
-        case 0x2D:
-        case 0x2E:
-        case 0x2F:
-        case 0x30:
-        case 0x31:
-        case 0x32:
-        case 0x33:
-        case 0x34:
-        case 0x35:
-        case 0x36:
-        case 0x37:
-        case 0x38:
-        case 0x39:
-        case 0x3A:
-        case 0x3B:
-        case 0x3C:
-        case 0x3D:
-        case 0x3E:
-        case 0x3F:
-        case 0x40:
-        case 0x41:
-        case 0x42:
-        case 0x43:
-        case 0x44:
-        case 0x45:
-        case 0x46:
-        case 0x47:
-        case 0x48:
-        case 0x49:
-        case 0x4A:
-        case 0x4B:
-        case 0x4C:
-        case 0x4D:
-        case 0x4E:
-        case 0x4F:
-        case 0x50:
-        case 0x51:
-        case 0x52:
-        case 0x53:
-        case 0x54:
-        case 0x55:
-        case 0x56:
-        case 0x57:
-        case 0x58:
-        case 0x59:
-        case 0x5A:
-        case 0x5B:
-        case 0x5D:
-        case 0x5E:
-        case 0x5F:
-        case 0x60:
-        case 0x61:
-        case 0x62:
-        case 0x63:
-        case 0x64:
-        case 0x65:
-        case 0x66:
-        case 0x67:
-        case 0x68:
-        case 0x69:
-        case 0x6A:
-        case 0x6B:
-        case 0x6C:
-        case 0x6D:
-        case 0x6E:
-        case 0x6F:
-        case 0x70:
-        case 0x71:
-        case 0x72:
-        case 0x73:
-        case 0x74:
-        case 0x75:
-        case 0x76:
-        case 0x77:
-        case 0x78:
-        case 0x79:
-        case 0x7A:
-        case 0x7B:
-        case 0x7C:
-        case 0x7D:
-        case 0x7E:
-        case 0x7F: {
-          add(current);
-          break;
-        }
-
-        // U+0080..U+07FF: bytes C2..DF 80..BF
-        case 0xC2:
-        case 0xC3:
-        case 0xC4:
-        case 0xC5:
-        case 0xC6:
-        case 0xC7:
-        case 0xC8:
-        case 0xC9:
-        case 0xCA:
-        case 0xCB:
-        case 0xCC:
-        case 0xCD:
-        case 0xCE:
-        case 0xCF:
-        case 0xD0:
-        case 0xD1:
-        case 0xD2:
-        case 0xD3:
-        case 0xD4:
-        case 0xD5:
-        case 0xD6:
-        case 0xD7:
-        case 0xD8:
-        case 0xD9:
-        case 0xDA:
-        case 0xDB:
-        case 0xDC:
-        case 0xDD:
-        case 0xDE:
-        case 0xDF: {
-          if (JSON_UNLIKELY(not next_byte_in_range({0x80, 0xBF}))) {
-            return token_type::parse_error;
-          }
-          break;
-        }
-
-        // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
-        case 0xE0: {
-          if (JSON_UNLIKELY(not(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF})))) {
-            return token_type::parse_error;
-          }
-          break;
-        }
-
-        // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
-        // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
-        case 0xE1:
-        case 0xE2:
-        case 0xE3:
-        case 0xE4:
-        case 0xE5:
-        case 0xE6:
-        case 0xE7:
-        case 0xE8:
-        case 0xE9:
-        case 0xEA:
-        case 0xEB:
-        case 0xEC:
-        case 0xEE:
-        case 0xEF: {
-          if (JSON_UNLIKELY(not(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF})))) {
-            return token_type::parse_error;
-          }
-          break;
-        }
-
-        // U+D000..U+D7FF: bytes ED 80..9F 80..BF
-        case 0xED: {
-          if (JSON_UNLIKELY(not(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF})))) {
-            return token_type::parse_error;
-          }
-          break;
-        }
-
-        // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
-        case 0xF0: {
-          if (JSON_UNLIKELY(not(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) {
-            return token_type::parse_error;
-          }
-          break;
-        }
-
-        // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
-        case 0xF1:
-        case 0xF2:
-        case 0xF3: {
-          if (JSON_UNLIKELY(not(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF})))) {
-            return token_type::parse_error;
-          }
-          break;
-        }
-
-        // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
-        case 0xF4: {
-          if (JSON_UNLIKELY(not(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF})))) {
-            return token_type::parse_error;
-          }
-          break;
-        }
-
-        // remaining bytes (80..C1 and F5..FF) are ill-formed
-        default: {
-          error_message = "invalid string: ill-formed UTF-8 byte";
-          return token_type::parse_error;
-        }
-      }
-    }
-  }
-
-  static void strtof(float& f, const char* str, char** endptr) noexcept
-  {
-    f = std::strtof(str, endptr);
-  }
-
-  static void strtof(double& f, const char* str, char** endptr) noexcept
-  {
-    f = std::strtod(str, endptr);
-  }
-
-  static void strtof(long double& f, const char* str, char** endptr) noexcept
-  {
-    f = std::strtold(str, endptr);
-  }
-
-  /*!
-    @brief scan a number literal
-
-    This function scans a string according to Sect. 6 of RFC 7159.
-
-    The function is realized with a deterministic finite state machine derived
-    from the grammar described in RFC 7159. Starting in state "init", the
-    input is read and used to determined the next state. Only state "done"
-    accepts the number. State "error" is a trap state to model errors. In the
-    table below, "anything" means any character but the ones listed before.
-
-    state    | 0        | 1-9      | e E      | +       | -       | .        | anything
-    ---------|----------|----------|----------|---------|---------|----------|-----------
-    init     | zero     | any1     | [error]  | [error] | minus   | [error]  | [error]
-    minus    | zero     | any1     | [error]  | [error] | [error] | [error]  | [error]
-    zero     | done     | done     | exponent | done    | done    | decimal1 | done
-    any1     | any1     | any1     | exponent | done    | done    | decimal1 | done
-    decimal1 | decimal2 | [error]  | [error]  | [error] | [error] | [error]  | [error]
-    decimal2 | decimal2 | decimal2 | exponent | done    | done    | done     | done
-    exponent | any2     | any2     | [error]  | sign    | sign    | [error]  | [error]
-    sign     | any2     | any2     | [error]  | [error] | [error] | [error]  | [error]
-    any2     | any2     | any2     | done     | done    | done    | done     | done
-
-    The state machine is realized with one label per state (prefixed with
-    "scan_number_") and `goto` statements between them. The state machine
-    contains cycles, but any cycle can be left when EOF is read. Therefore,
-    the function is guaranteed to terminate.
-
-    During scanning, the read bytes are stored in token_buffer. This string is
-    then converted to a signed integer, an unsigned integer, or a
-    floating-point number.
-
-    @return token_type::value_unsigned, token_type::value_integer, or
-            token_type::value_float if number could be successfully scanned,
-            token_type::parse_error otherwise
-
-    @note The scanner is independent of the current locale. Internally, the
-          locale's decimal point is used instead of `.` to work with the
-          locale-dependent converters.
-    */
-  token_type scan_number()
-  {
-    // reset token_buffer to store the number's bytes
-    reset();
-
-    // the type of the parsed number; initially set to unsigned; will be
-    // changed if minus sign, decimal point or exponent is read
-    token_type number_type = token_type::value_unsigned;
-
-    // state (init): we just found out we need to scan a number
-    switch (current) {
-      case '-': {
-        add(current);
-        goto scan_number_minus;
-      }
-
-      case '0': {
-        add(current);
-        goto scan_number_zero;
-      }
-
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        add(current);
-        goto scan_number_any1;
-      }
-
-      default: {
-        // all other characters are rejected outside scan_number()
-        assert(false); // LCOV_EXCL_LINE
-      }
-    }
-
-  scan_number_minus:
-    // state: we just parsed a leading minus sign
-    number_type = token_type::value_integer;
-    switch (get()) {
-      case '0': {
-        add(current);
-        goto scan_number_zero;
-      }
-
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        add(current);
-        goto scan_number_any1;
-      }
-
-      default: {
-        error_message = "invalid number; expected digit after '-'";
-        return token_type::parse_error;
-      }
-    }
-
-  scan_number_zero:
-    // state: we just parse a zero (maybe with a leading minus sign)
-    switch (get()) {
-      case '.': {
-        add(decimal_point_char);
-        goto scan_number_decimal1;
-      }
-
-      case 'e':
-      case 'E': {
-        add(current);
-        goto scan_number_exponent;
-      }
-
-      default:
-        goto scan_number_done;
-    }
-
-  scan_number_any1:
-    // state: we just parsed a number 0-9 (maybe with a leading minus sign)
-    switch (get()) {
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        add(current);
-        goto scan_number_any1;
-      }
-
-      case '.': {
-        add(decimal_point_char);
-        goto scan_number_decimal1;
-      }
-
-      case 'e':
-      case 'E': {
-        add(current);
-        goto scan_number_exponent;
-      }
-
-      default:
-        goto scan_number_done;
-    }
-
-  scan_number_decimal1:
-    // state: we just parsed a decimal point
-    number_type = token_type::value_float;
-    switch (get()) {
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        add(current);
-        goto scan_number_decimal2;
-      }
-
-      default: {
-        error_message = "invalid number; expected digit after '.'";
-        return token_type::parse_error;
-      }
-    }
-
-  scan_number_decimal2:
-    // we just parsed at least one number after a decimal point
-    switch (get()) {
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        add(current);
-        goto scan_number_decimal2;
-      }
-
-      case 'e':
-      case 'E': {
-        add(current);
-        goto scan_number_exponent;
-      }
-
-      default:
-        goto scan_number_done;
-    }
-
-  scan_number_exponent:
-    // we just parsed an exponent
-    number_type = token_type::value_float;
-    switch (get()) {
-      case '+':
-      case '-': {
-        add(current);
-        goto scan_number_sign;
-      }
-
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        add(current);
-        goto scan_number_any2;
-      }
-
-      default: {
-        error_message =
-          "invalid number; expected '+', '-', or digit after exponent";
-        return token_type::parse_error;
-      }
-    }
-
-  scan_number_sign:
-    // we just parsed an exponent sign
-    switch (get()) {
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        add(current);
-        goto scan_number_any2;
-      }
-
-      default: {
-        error_message = "invalid number; expected digit after exponent sign";
-        return token_type::parse_error;
-      }
-    }
-
-  scan_number_any2:
-    // we just parsed a number after the exponent or exponent sign
-    switch (get()) {
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9': {
-        add(current);
-        goto scan_number_any2;
-      }
-
-      default:
-        goto scan_number_done;
-    }
-
-  scan_number_done:
-    // unget the character after the number (we only read it to know that
-    // we are done scanning a number)
-    unget();
-
-    char* endptr = nullptr;
-    errno = 0;
-
-    // try to parse integers first and fall back to floats
-    if (number_type == token_type::value_unsigned) {
-      const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
-
-      // we checked the number format before
-      assert(endptr == token_buffer.data() + token_buffer.size());
-
-      if (errno == 0) {
-        value_unsigned = static_cast<number_unsigned_t>(x);
-        if (value_unsigned == x) {
-          return token_type::value_unsigned;
-        }
-      }
-    } else if (number_type == token_type::value_integer) {
-      const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
-
-      // we checked the number format before
-      assert(endptr == token_buffer.data() + token_buffer.size());
-
-      if (errno == 0) {
-        value_integer = static_cast<number_integer_t>(x);
-        if (value_integer == x) {
-          return token_type::value_integer;
-        }
-      }
-    }
-
-    // this code is reached if we parse a floating-point number or if an
-    // integer conversion above failed
-    strtof(value_float, token_buffer.data(), &endptr);
-
-    // we checked the number format before
-    assert(endptr == token_buffer.data() + token_buffer.size());
-
-    return token_type::value_float;
-  }
-
-  /*!
-    @param[in] literal_text  the literal text to expect
-    @param[in] length        the length of the passed literal text
-    @param[in] return_type   the token type to return on success
-    */
-  token_type scan_literal(const char* literal_text, const std::size_t length,
-                          token_type return_type)
-  {
-    assert(current == literal_text[0]);
-    for (std::size_t i = 1; i < length; ++i) {
-      if (JSON_UNLIKELY(get() != literal_text[i])) {
-        error_message = "invalid literal";
-        return token_type::parse_error;
-      }
-    }
-    return return_type;
-  }
-
-  /////////////////////
-  // input management
-  /////////////////////
-
-  /// reset token_buffer; current character is beginning of token
-  void reset() noexcept
-  {
-    token_buffer.clear();
-    token_string.clear();
-    token_string.push_back(std::char_traits<char>::to_char_type(current));
-  }
-
-  /*
-    @brief get next character from the input
-
-    This function provides the interface to the used input adapter. It does
-    not throw in case the input reached EOF, but returns a
-    `std::char_traits<char>::eof()` in that case.  Stores the scanned characters
-    for use in error messages.
-
-    @return character read from the input
-    */
-  std::char_traits<char>::int_type get()
-  {
-    ++chars_read;
-    current = ia->get_character();
-    if (JSON_LIKELY(current != std::char_traits<char>::eof())) {
-      token_string.push_back(std::char_traits<char>::to_char_type(current));
-    }
-    return current;
-  }
-
-  /// unget current character (return it again on next get)
-  void unget()
-  {
-    --chars_read;
-    if (JSON_LIKELY(current != std::char_traits<char>::eof())) {
-      ia->unget_character();
-      assert(token_string.size() != 0);
-      token_string.pop_back();
-    }
-  }
-
-  /// add a character to token_buffer
-  void add(int c)
-  {
-    token_buffer.push_back(std::char_traits<char>::to_char_type(c));
-  }
-
- public:
-  /////////////////////
-  // value getters
-  /////////////////////
-
-  /// return integer value
-  constexpr number_integer_t get_number_integer() const noexcept
-  {
-    return value_integer;
-  }
-
-  /// return unsigned integer value
-  constexpr number_unsigned_t get_number_unsigned() const noexcept
-  {
-    return value_unsigned;
-  }
-
-  /// return floating-point value
-  constexpr number_float_t get_number_float() const noexcept
-  {
-    return value_float;
-  }
-
-  /// return current string value (implicitly resets the token; useful only once)
-  string_t&& move_string()
-  {
-    return std::move(token_buffer);
-  }
-
-  /////////////////////
-  // diagnostics
-  /////////////////////
-
-  /// return position of last read token
-  constexpr std::size_t get_position() const noexcept
-  {
-    return chars_read;
-  }
-
-  /// return the last read token (for errors only).  Will never contain EOF
-  /// (an arbitrary value that is not a valid char value, often -1), because
-  /// 255 may legitimately occur.  May contain NUL, which should be escaped.
-  std::string get_token_string() const
-  {
-    // escape control characters
-    std::string result;
-    for (const auto c : token_string) {
-      if ('\x00' <= c and c <= '\x1F') {
-        // escape control characters
-        std::stringstream ss;
-        ss << "<U+" << std::setw(4) << std::uppercase << std::setfill('0')
-           << std::hex << static_cast<int>(c) << ">";
-        result += ss.str();
-      } else {
-        // add character as is
-        result.push_back(c);
-      }
-    }
-
-    return result;
-  }
-
-  /// return syntax error message
-  constexpr const char* get_error_message() const noexcept
-  {
-    return error_message;
-  }
-
-  /////////////////////
-  // actual scanner
-  /////////////////////
-
-  token_type scan()
-  {
-    // read next character and ignore whitespace
-    do {
-      get();
-    } while (current == ' ' or current == '\t' or current == '\n' or current == '\r');
-
-    switch (current) {
-      // structural characters
-      case '[':
-        return token_type::begin_array;
-      case ']':
-        return token_type::end_array;
-      case '{':
-        return token_type::begin_object;
-      case '}':
-        return token_type::end_object;
-      case ':':
-        return token_type::name_separator;
-      case ',':
-        return token_type::value_separator;
-
-      // literals
-      case 't':
-        return scan_literal("true", 4, token_type::literal_true);
-      case 'f':
-        return scan_literal("false", 5, token_type::literal_false);
-      case 'n':
-        return scan_literal("null", 4, token_type::literal_null);
-
-      // string
-      case '\"':
-        return scan_string();
-
-      // number
-      case '-':
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9':
-        return scan_number();
-
-      // end of input (the null byte is needed when parsing from
-      // string literals)
-      case '\0':
-      case std::char_traits<char>::eof():
-        return token_type::end_of_input;
-
-      // error
-      default:
-        error_message = "invalid literal";
-        return token_type::parse_error;
-    }
-  }
-
- private:
-  /// input adapter
-  detail::input_adapter_t ia = nullptr;
-
-  /// the current character
-  std::char_traits<char>::int_type current = std::char_traits<char>::eof();
-
-  /// the number of characters read
-  std::size_t chars_read = 0;
-
-  /// raw input token string (for error messages)
-  std::vector<char> token_string{};
-
-  /// buffer for variable-length tokens (numbers, strings)
-  string_t token_buffer{};
-
-  /// a description of occurred lexer errors
-  const char* error_message = "";
-
-  // number values
-  number_integer_t value_integer = 0;
-  number_unsigned_t value_unsigned = 0;
-  number_float_t value_float = 0;
-
-  /// the decimal point
-  const char decimal_point_char = '.';
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/input/parser.hpp>
-
-#include <cassert>    // assert
-#include <cmath>      // isfinite
-#include <cstdint>    // uint8_t
-#include <functional> // function
-#include <string>     // string
-#include <utility>    // move
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/input/lexer.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-////////////
-// parser //
-////////////
-
-/*!
-@brief syntax analysis
-
-This class implements a recursive decent parser.
-*/
-template <typename BasicJsonType>
-class parser
-{
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using string_t = typename BasicJsonType::string_t;
-  using lexer_t = lexer<BasicJsonType>;
-  using token_type = typename lexer_t::token_type;
-
- public:
-  enum class parse_event_t : uint8_t {
-    /// the parser read `{` and started to process a JSON object
-    object_start,
-    /// the parser read `}` and finished processing a JSON object
-    object_end,
-    /// the parser read `[` and started to process a JSON array
-    array_start,
-    /// the parser read `]` and finished processing a JSON array
-    array_end,
-    /// the parser read a key of a value in an object
-    key,
-    /// the parser finished reading a JSON value
-    value
-  };
-
-  using parser_callback_t =
-    std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
-
-  /// a parser reading from an input adapter
-  explicit parser(detail::input_adapter_t adapter,
-                  const parser_callback_t cb = nullptr,
-                  const bool allow_exceptions_ = true)
-    : callback(cb), m_lexer(adapter), allow_exceptions(allow_exceptions_)
-  {
-  }
-
-  /*!
-    @brief public parser interface
-
-    @param[in] strict      whether to expect the last token to be EOF
-    @param[in,out] result  parsed JSON value
-
-    @throw parse_error.101 in case of an unexpected token
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-    */
-  void parse(const bool strict, BasicJsonType& result)
-  {
-    // read first token
-    get_token();
-
-    parse_internal(true, result);
-    result.assert_invariant();
-
-    // in strict mode, input must be completely read
-    if (strict) {
-      get_token();
-      expect(token_type::end_of_input);
-    }
-
-    // in case of an error, return discarded value
-    if (errored) {
-      result = value_t::discarded;
-      return;
-    }
-
-    // set top-level value to null if it was discarded by the callback
-    // function
-    if (result.is_discarded()) {
-      result = nullptr;
-    }
-  }
-
-  /*!
-    @brief public accept interface
-
-    @param[in] strict  whether to expect the last token to be EOF
-    @return whether the input is a proper JSON text
-    */
-  bool accept(const bool strict = true)
-  {
-    // read first token
-    get_token();
-
-    if (not accept_internal()) {
-      return false;
-    }
-
-    // strict => last token must be EOF
-    return not strict or (get_token() == token_type::end_of_input);
-  }
-
- private:
-  /*!
-    @brief the actual parser
-    @throw parse_error.101 in case of an unexpected token
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-    */
-  void parse_internal(bool keep, BasicJsonType& result)
-  {
-    // never parse after a parse error was detected
-    assert(not errored);
-
-    // start with a discarded value
-    if (not result.is_discarded()) {
-      result.m_value.destroy(result.m_type);
-      result.m_type = value_t::discarded;
-    }
-
-    switch (last_token) {
-      case token_type::begin_object: {
-        if (keep) {
-          if (callback) {
-            keep = callback(depth++, parse_event_t::object_start, result);
-          }
-
-          if (not callback or keep) {
-            // explicitly set result to object to cope with {}
-            result.m_type = value_t::object;
-            result.m_value = value_t::object;
-          }
-        }
-
-        // read next token
-        get_token();
-
-        // closing } -> we are done
-        if (last_token == token_type::end_object) {
-          if (keep and callback and not callback(--depth, parse_event_t::object_end, result)) {
-            result.m_value.destroy(result.m_type);
-            result.m_type = value_t::discarded;
-          }
-          break;
-        }
-
-        // parse values
-        string_t key;
-        BasicJsonType value;
-        while (true) {
-          // store key
-          if (not expect(token_type::value_string)) {
-            return;
-          }
-          key = m_lexer.move_string();
-
-          bool keep_tag = false;
-          if (keep) {
-            if (callback) {
-              BasicJsonType k(key);
-              keep_tag = callback(depth, parse_event_t::key, k);
-            } else {
-              keep_tag = true;
-            }
-          }
-
-          // parse separator (:)
-          get_token();
-          if (not expect(token_type::name_separator)) {
-            return;
-          }
-
-          // parse and add value
-          get_token();
-          value.m_value.destroy(value.m_type);
-          value.m_type = value_t::discarded;
-          parse_internal(keep, value);
-
-          if (JSON_UNLIKELY(errored)) {
-            return;
-          }
-
-          if (keep and keep_tag and not value.is_discarded()) {
-            result.m_value.object->emplace(std::move(key), std::move(value));
-          }
-
-          // comma -> next value
-          get_token();
-          if (last_token == token_type::value_separator) {
-            get_token();
-            continue;
-          }
-
-          // closing }
-          if (not expect(token_type::end_object)) {
-            return;
-          }
-          break;
-        }
-
-        if (keep and callback and not callback(--depth, parse_event_t::object_end, result)) {
-          result.m_value.destroy(result.m_type);
-          result.m_type = value_t::discarded;
-        }
-        break;
-      }
-
-      case token_type::begin_array: {
-        if (keep) {
-          if (callback) {
-            keep = callback(depth++, parse_event_t::array_start, result);
-          }
-
-          if (not callback or keep) {
-            // explicitly set result to array to cope with []
-            result.m_type = value_t::array;
-            result.m_value = value_t::array;
-          }
-        }
-
-        // read next token
-        get_token();
-
-        // closing ] -> we are done
-        if (last_token == token_type::end_array) {
-          if (callback and not callback(--depth, parse_event_t::array_end, result)) {
-            result.m_value.destroy(result.m_type);
-            result.m_type = value_t::discarded;
-          }
-          break;
-        }
-
-        // parse values
-        BasicJsonType value;
-        while (true) {
-          // parse value
-          value.m_value.destroy(value.m_type);
-          value.m_type = value_t::discarded;
-          parse_internal(keep, value);
-
-          if (JSON_UNLIKELY(errored)) {
-            return;
-          }
-
-          if (keep and not value.is_discarded()) {
-            result.m_value.array->push_back(std::move(value));
-          }
-
-          // comma -> next value
-          get_token();
-          if (last_token == token_type::value_separator) {
-            get_token();
-            continue;
-          }
-
-          // closing ]
-          if (not expect(token_type::end_array)) {
-            return;
-          }
-          break;
-        }
-
-        if (keep and callback and not callback(--depth, parse_event_t::array_end, result)) {
-          result.m_value.destroy(result.m_type);
-          result.m_type = value_t::discarded;
-        }
-        break;
-      }
-
-      case token_type::literal_null: {
-        result.m_type = value_t::null;
-        break;
-      }
-
-      case token_type::value_string: {
-        result.m_type = value_t::string;
-        result.m_value = m_lexer.move_string();
-        break;
-      }
-
-      case token_type::literal_true: {
-        result.m_type = value_t::boolean;
-        result.m_value = true;
-        break;
-      }
-
-      case token_type::literal_false: {
-        result.m_type = value_t::boolean;
-        result.m_value = false;
-        break;
-      }
-
-      case token_type::value_unsigned: {
-        result.m_type = value_t::number_unsigned;
-        result.m_value = m_lexer.get_number_unsigned();
-        break;
-      }
-
-      case token_type::value_integer: {
-        result.m_type = value_t::number_integer;
-        result.m_value = m_lexer.get_number_integer();
-        break;
-      }
-
-      case token_type::value_float: {
-        result.m_type = value_t::number_float;
-        result.m_value = m_lexer.get_number_float();
-
-        // throw in case of infinity or NAN
-        if (JSON_UNLIKELY(not std::isfinite(result.m_value.number_float))) {
-          if (allow_exceptions) {
-            JSON_THROW(out_of_range::create(406, "number overflow parsing '" +
-                                                   m_lexer.get_token_string() + "'"));
-          }
-          expect(token_type::uninitialized);
-        }
-        break;
-      }
-
-      case token_type::parse_error: {
-        // using "uninitialized" to avoid "expected" message
-        if (not expect(token_type::uninitialized)) {
-          return;
-        }
-        break; // LCOV_EXCL_LINE
-      }
-
-      default: {
-        // the last token was unexpected; we expected a value
-        if (not expect(token_type::literal_or_value)) {
-          return;
-        }
-        break; // LCOV_EXCL_LINE
-      }
-    }
-
-    if (keep and callback and not callback(depth, parse_event_t::value, result)) {
-      result.m_value.destroy(result.m_type);
-      result.m_type = value_t::discarded;
-    }
-  }
-
-  /*!
-    @brief the actual acceptor
-
-    @invariant 1. The last token is not yet processed. Therefore, the caller
-                  of this function must make sure a token has been read.
-               2. When this function returns, the last token is processed.
-                  That is, the last read character was already considered.
-
-    This invariant makes sure that no token needs to be "unput".
-    */
-  bool accept_internal()
-  {
-    switch (last_token) {
-      case token_type::begin_object: {
-        // read next token
-        get_token();
-
-        // closing } -> we are done
-        if (last_token == token_type::end_object) {
-          return true;
-        }
-
-        // parse values
-        while (true) {
-          // parse key
-          if (last_token != token_type::value_string) {
-            return false;
-          }
-
-          // parse separator (:)
-          get_token();
-          if (last_token != token_type::name_separator) {
-            return false;
-          }
-
-          // parse value
-          get_token();
-          if (not accept_internal()) {
-            return false;
-          }
-
-          // comma -> next value
-          get_token();
-          if (last_token == token_type::value_separator) {
-            get_token();
-            continue;
-          }
-
-          // closing }
-          return (last_token == token_type::end_object);
-        }
-      }
-
-      case token_type::begin_array: {
-        // read next token
-        get_token();
-
-        // closing ] -> we are done
-        if (last_token == token_type::end_array) {
-          return true;
-        }
-
-        // parse values
-        while (true) {
-          // parse value
-          if (not accept_internal()) {
-            return false;
-          }
-
-          // comma -> next value
-          get_token();
-          if (last_token == token_type::value_separator) {
-            get_token();
-            continue;
-          }
-
-          // closing ]
-          return (last_token == token_type::end_array);
-        }
-      }
-
-      case token_type::value_float: {
-        // reject infinity or NAN
-        return std::isfinite(m_lexer.get_number_float());
-      }
-
-      case token_type::literal_false:
-      case token_type::literal_null:
-      case token_type::literal_true:
-      case token_type::value_integer:
-      case token_type::value_string:
-      case token_type::value_unsigned:
-        return true;
-
-      default: // the last token was unexpected
-        return false;
-    }
-  }
-
-  /// get next token from lexer
-  token_type get_token()
-  {
-    return (last_token = m_lexer.scan());
-  }
-
-  /*!
-    @throw parse_error.101 if expected token did not occur
-    */
-  bool expect(token_type t)
-  {
-    if (JSON_UNLIKELY(t != last_token)) {
-      errored = true;
-      expected = t;
-      if (allow_exceptions) {
-        throw_exception();
-      } else {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  [[noreturn]] void throw_exception() const
-  {
-    std::string error_msg = "syntax error - ";
-    if (last_token == token_type::parse_error) {
-      error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
-                   m_lexer.get_token_string() + "'";
-    } else {
-      error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
-    }
-
-    if (expected != token_type::uninitialized) {
-      error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
-    }
-
-    JSON_THROW(parse_error::create(101, m_lexer.get_position(), error_msg));
-  }
-
- private:
-  /// current level of recursion
-  int depth = 0;
-  /// callback function
-  const parser_callback_t callback = nullptr;
-  /// the type of the last read token
-  token_type last_token = token_type::uninitialized;
-  /// the lexer
-  lexer_t m_lexer;
-  /// whether a syntax error occurred
-  bool errored = false;
-  /// possible reason for the syntax error
-  token_type expected = token_type::uninitialized;
-  /// whether to throw exceptions in case of errors
-  const bool allow_exceptions = true;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-
-#include <cstddef> // ptrdiff_t
-#include <limits>  // numeric_limits
-
-namespace nlohmann
-{
-namespace detail
-{
-/*
-@brief an iterator for primitive JSON types
-
-This class models an iterator for primitive JSON types (boolean, number,
-string). It's only purpose is to allow the iterator/const_iterator classes
-to "iterate" over primitive values. Internally, the iterator is modeled by
-a `difference_type` variable. Value begin_value (`0`) models the begin,
-end_value (`1`) models past the end.
-*/
-class primitive_iterator_t
-{
- private:
-  using difference_type = std::ptrdiff_t;
-  static constexpr difference_type begin_value = 0;
-  static constexpr difference_type end_value = begin_value + 1;
-
-  /// iterator as signed integer type
-  difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
-
- public:
-  constexpr difference_type get_value() const noexcept
-  {
-    return m_it;
-  }
-
-  /// set iterator to a defined beginning
-  void set_begin() noexcept
-  {
-    m_it = begin_value;
-  }
-
-  /// set iterator to a defined past the end
-  void set_end() noexcept
-  {
-    m_it = end_value;
-  }
-
-  /// return whether the iterator can be dereferenced
-  constexpr bool is_begin() const noexcept
-  {
-    return m_it == begin_value;
-  }
-
-  /// return whether the iterator is at end
-  constexpr bool is_end() const noexcept
-  {
-    return m_it == end_value;
-  }
-
-  friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-  {
-    return lhs.m_it == rhs.m_it;
-  }
-
-  friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-  {
-    return lhs.m_it < rhs.m_it;
-  }
-
-  primitive_iterator_t operator+(difference_type n) noexcept
-  {
-    auto result = *this;
-    result += n;
-    return result;
-  }
-
-  friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
-  {
-    return lhs.m_it - rhs.m_it;
-  }
-
-  primitive_iterator_t& operator++() noexcept
-  {
-    ++m_it;
-    return *this;
-  }
-
-  primitive_iterator_t const operator++(int) noexcept
-  {
-    auto result = *this;
-    m_it++;
-    return result;
-  }
-
-  primitive_iterator_t& operator--() noexcept
-  {
-    --m_it;
-    return *this;
-  }
-
-  primitive_iterator_t const operator--(int) noexcept
-  {
-    auto result = *this;
-    m_it--;
-    return result;
-  }
-
-  primitive_iterator_t& operator+=(difference_type n) noexcept
-  {
-    m_it += n;
-    return *this;
-  }
-
-  primitive_iterator_t& operator-=(difference_type n) noexcept
-  {
-    m_it -= n;
-    return *this;
-  }
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/internal_iterator.hpp>
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-/*!
-@brief an iterator value
-
-@note This structure could easily be a union, but MSVC currently does not allow
-unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
-*/
-template <typename BasicJsonType>
-struct internal_iterator {
-  /// iterator for JSON objects
-  typename BasicJsonType::object_t::iterator object_iterator{};
-  /// iterator for JSON arrays
-  typename BasicJsonType::array_t::iterator array_iterator{};
-  /// generic iterator for all other types
-  primitive_iterator_t primitive_iterator{};
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/iter_impl.hpp>
-
-#include <ciso646>     // not
-#include <iterator>    // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
-#include <type_traits> // conditional, is_const, remove_const
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/iterators/internal_iterator.hpp>
-
-// #include <nlohmann/detail/iterators/primitive_iterator.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-// forward declare, to be able to friend it later on
-template <typename IteratorType>
-class iteration_proxy;
-
-/*!
-@brief a template for a bidirectional iterator for the @ref basic_json class
-
-This class implements a both iterators (iterator and const_iterator) for the
-@ref basic_json class.
-
-@note An iterator is called *initialized* when a pointer to a JSON value has
-      been set (e.g., by a constructor or a copy assignment). If the iterator is
-      default-constructed, it is *uninitialized* and most methods are undefined.
-      **The library uses assertions to detect calls on uninitialized iterators.**
-
-@requirement The class satisfies the following concept requirements:
--
-[BidirectionalIterator](http://en.cppreference.com/w/cpp/concept/BidirectionalIterator):
-  The iterator that can be moved can be moved in both directions (i.e.
-  incremented and decremented).
-
-@since version 1.0.0, simplified in version 2.0.9, change to bidirectional
-       iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
-*/
-template <typename BasicJsonType>
-class iter_impl
-{
-  /// allow basic_json to access private members
-  friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
-  friend BasicJsonType;
-  friend iteration_proxy<iter_impl>;
-
-  using object_t = typename BasicJsonType::object_t;
-  using array_t = typename BasicJsonType::array_t;
-  // make sure BasicJsonType is basic_json or const basic_json
-  static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
-                "iter_impl only accepts (const) basic_json");
-
- public:
-  /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
-  /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
-  /// A user-defined iterator should provide publicly accessible typedefs named
-  /// iterator_category, value_type, difference_type, pointer, and reference.
-  /// Note that value_type is required to be non-const, even for constant iterators.
-  using iterator_category = std::bidirectional_iterator_tag;
-
-  /// the type of the values when the iterator is dereferenced
-  using value_type = typename BasicJsonType::value_type;
-  /// a type to represent differences between iterators
-  using difference_type = typename BasicJsonType::difference_type;
-  /// defines a pointer to the type iterated over (value_type)
-  using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
-                                            typename BasicJsonType::const_pointer,
-                                            typename BasicJsonType::pointer>::type;
-  /// defines a reference to the type iterated over (value_type)
-  using reference =
-    typename std::conditional<std::is_const<BasicJsonType>::value,
-                              typename BasicJsonType::const_reference,
-                              typename BasicJsonType::reference>::type;
-
-  /// default constructor
-  iter_impl() = default;
-
-  /*!
-    @brief constructor for a given JSON instance
-    @param[in] object  pointer to a JSON object for this iterator
-    @pre object != nullptr
-    @post The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  explicit iter_impl(pointer object) noexcept : m_object(object)
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object: {
-        m_it.object_iterator = typename object_t::iterator();
-        break;
-      }
-
-      case value_t::array: {
-        m_it.array_iterator = typename array_t::iterator();
-        break;
-      }
-
-      default: {
-        m_it.primitive_iterator = primitive_iterator_t();
-        break;
-      }
-    }
-  }
-
-  /*!
-    @note The conventional copy constructor and copy assignment are implicitly
-          defined. Combined with the following converting constructor and
-          assignment, they support: (1) copy from iterator to iterator, (2)
-          copy from const iterator to const iterator, and (3) conversion from
-          iterator to const iterator. However conversion from const iterator
-          to iterator is not defined.
-    */
-
-  /*!
-    @brief converting constructor
-    @param[in] other  non-const iterator to copy from
-    @note It is not checked whether @a other is initialized.
-    */
-  iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
-    : m_object(other.m_object), m_it(other.m_it) {}
-
-  /*!
-    @brief converting assignment
-    @param[in,out] other  non-const iterator to copy from
-    @return const/non-const iterator
-    @note It is not checked whether @a other is initialized.
-    */
-  iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
-  {
-    m_object = other.m_object;
-    m_it = other.m_it;
-    return *this;
-  }
-
- private:
-  /*!
-    @brief set the iterator to the first value
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  void set_begin() noexcept
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object: {
-        m_it.object_iterator = m_object->m_value.object->begin();
-        break;
-      }
-
-      case value_t::array: {
-        m_it.array_iterator = m_object->m_value.array->begin();
-        break;
-      }
-
-      case value_t::null: {
-        // set to end so begin()==end() is true: null is empty
-        m_it.primitive_iterator.set_end();
-        break;
-      }
-
-      default: {
-        m_it.primitive_iterator.set_begin();
-        break;
-      }
-    }
-  }
-
-  /*!
-    @brief set the iterator past the last value
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  void set_end() noexcept
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object: {
-        m_it.object_iterator = m_object->m_value.object->end();
-        break;
-      }
-
-      case value_t::array: {
-        m_it.array_iterator = m_object->m_value.array->end();
-        break;
-      }
-
-      default: {
-        m_it.primitive_iterator.set_end();
-        break;
-      }
-    }
-  }
-
- public:
-  /*!
-    @brief return a reference to the value pointed to by the iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  reference operator*() const
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object: {
-        assert(m_it.object_iterator != m_object->m_value.object->end());
-        return m_it.object_iterator->second;
-      }
-
-      case value_t::array: {
-        assert(m_it.array_iterator != m_object->m_value.array->end());
-        return *m_it.array_iterator;
-      }
-
-      case value_t::null:
-        JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-
-      default: {
-        if (JSON_LIKELY(m_it.primitive_iterator.is_begin())) {
-          return *m_object;
-        }
-
-        JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-      }
-    }
-  }
-
-  /*!
-    @brief dereference the iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  pointer operator->() const
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object: {
-        assert(m_it.object_iterator != m_object->m_value.object->end());
-        return &(m_it.object_iterator->second);
-      }
-
-      case value_t::array: {
-        assert(m_it.array_iterator != m_object->m_value.array->end());
-        return &*m_it.array_iterator;
-      }
-
-      default: {
-        if (JSON_LIKELY(m_it.primitive_iterator.is_begin())) {
-          return m_object;
-        }
-
-        JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-      }
-    }
-  }
-
-  /*!
-    @brief post-increment (it++)
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  iter_impl const operator++(int)
-  {
-    auto result = *this;
-    ++(*this);
-    return result;
-  }
-
-  /*!
-    @brief pre-increment (++it)
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  iter_impl& operator++()
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object: {
-        std::advance(m_it.object_iterator, 1);
-        break;
-      }
-
-      case value_t::array: {
-        std::advance(m_it.array_iterator, 1);
-        break;
-      }
-
-      default: {
-        ++m_it.primitive_iterator;
-        break;
-      }
-    }
-
-    return *this;
-  }
-
-  /*!
-    @brief post-decrement (it--)
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  iter_impl const operator--(int)
-  {
-    auto result = *this;
-    --(*this);
-    return result;
-  }
-
-  /*!
-    @brief pre-decrement (--it)
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  iter_impl& operator--()
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object: {
-        std::advance(m_it.object_iterator, -1);
-        break;
-      }
-
-      case value_t::array: {
-        std::advance(m_it.array_iterator, -1);
-        break;
-      }
-
-      default: {
-        --m_it.primitive_iterator;
-        break;
-      }
-    }
-
-    return *this;
-  }
-
-  /*!
-    @brief  comparison: equal
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  bool operator==(const iter_impl& other) const
-  {
-    // if objects are not the same, the comparison is undefined
-    if (JSON_UNLIKELY(m_object != other.m_object)) {
-      JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
-    }
-
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object:
-        return (m_it.object_iterator == other.m_it.object_iterator);
-
-      case value_t::array:
-        return (m_it.array_iterator == other.m_it.array_iterator);
-
-      default:
-        return (m_it.primitive_iterator == other.m_it.primitive_iterator);
-    }
-  }
-
-  /*!
-    @brief  comparison: not equal
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  bool operator!=(const iter_impl& other) const
-  {
-    return not operator==(other);
-  }
-
-  /*!
-    @brief  comparison: smaller
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  bool operator<(const iter_impl& other) const
-  {
-    // if objects are not the same, the comparison is undefined
-    if (JSON_UNLIKELY(m_object != other.m_object)) {
-      JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
-    }
-
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object:
-        JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
-
-      case value_t::array:
-        return (m_it.array_iterator < other.m_it.array_iterator);
-
-      default:
-        return (m_it.primitive_iterator < other.m_it.primitive_iterator);
-    }
-  }
-
-  /*!
-    @brief  comparison: less than or equal
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  bool operator<=(const iter_impl& other) const
-  {
-    return not other.operator<(*this);
-  }
-
-  /*!
-    @brief  comparison: greater than
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  bool operator>(const iter_impl& other) const
-  {
-    return not operator<=(other);
-  }
-
-  /*!
-    @brief  comparison: greater than or equal
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  bool operator>=(const iter_impl& other) const
-  {
-    return not operator<(other);
-  }
-
-  /*!
-    @brief  add to iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  iter_impl& operator+=(difference_type i)
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object:
-        JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
-
-      case value_t::array: {
-        std::advance(m_it.array_iterator, i);
-        break;
-      }
-
-      default: {
-        m_it.primitive_iterator += i;
-        break;
-      }
-    }
-
-    return *this;
-  }
-
-  /*!
-    @brief  subtract from iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  iter_impl& operator-=(difference_type i)
-  {
-    return operator+=(-i);
-  }
-
-  /*!
-    @brief  add to iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  iter_impl operator+(difference_type i) const
-  {
-    auto result = *this;
-    result += i;
-    return result;
-  }
-
-  /*!
-    @brief  addition of distance and iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  friend iter_impl operator+(difference_type i, const iter_impl& it)
-  {
-    auto result = it;
-    result += i;
-    return result;
-  }
-
-  /*!
-    @brief  subtract from iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  iter_impl operator-(difference_type i) const
-  {
-    auto result = *this;
-    result -= i;
-    return result;
-  }
-
-  /*!
-    @brief  return difference
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  difference_type operator-(const iter_impl& other) const
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object:
-        JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
-
-      case value_t::array:
-        return m_it.array_iterator - other.m_it.array_iterator;
-
-      default:
-        return m_it.primitive_iterator - other.m_it.primitive_iterator;
-    }
-  }
-
-  /*!
-    @brief  access to successor
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  reference operator[](difference_type n) const
-  {
-    assert(m_object != nullptr);
-
-    switch (m_object->m_type) {
-      case value_t::object:
-        JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
-
-      case value_t::array:
-        return *std::next(m_it.array_iterator, n);
-
-      case value_t::null:
-        JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-
-      default: {
-        if (JSON_LIKELY(m_it.primitive_iterator.get_value() == -n)) {
-          return *m_object;
-        }
-
-        JSON_THROW(invalid_iterator::create(214, "cannot get value"));
-      }
-    }
-  }
-
-  /*!
-    @brief  return the key of an object iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  typename object_t::key_type key() const
-  {
-    assert(m_object != nullptr);
-
-    if (JSON_LIKELY(m_object->is_object())) {
-      return m_it.object_iterator->first;
-    }
-
-    JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
-  }
-
-  /*!
-    @brief  return the value of an iterator
-    @pre The iterator is initialized; i.e. `m_object != nullptr`.
-    */
-  reference value() const
-  {
-    return operator*();
-  }
-
- private:
-  /// associated JSON instance
-  pointer m_object = nullptr;
-  /// the actual iterator of the associated instance
-  internal_iterator<typename std::remove_const<BasicJsonType>::type> m_it;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/iteration_proxy.hpp>
-
-#include <cstddef> // size_t
-#include <string>  // string, to_string
-
-// #include <nlohmann/detail/value_t.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-/// proxy class for the items() function
-template <typename IteratorType>
-class iteration_proxy
-{
- private:
-  /// helper class for iteration
-  class iteration_proxy_internal
-  {
-   private:
-    /// the iterator
-    IteratorType anchor;
-    /// an index for arrays (used to create key names)
-    std::size_t array_index = 0;
-
-   public:
-    explicit iteration_proxy_internal(IteratorType it) noexcept : anchor(it) {}
-
-    /// dereference operator (needed for range-based for)
-    iteration_proxy_internal& operator*()
-    {
-      return *this;
-    }
-
-    /// increment operator (needed for range-based for)
-    iteration_proxy_internal& operator++()
-    {
-      ++anchor;
-      ++array_index;
-
-      return *this;
-    }
-
-    /// inequality operator (needed for range-based for)
-    bool operator!=(const iteration_proxy_internal& o) const noexcept
-    {
-      return anchor != o.anchor;
-    }
-
-    /// return key of the iterator
-    std::string key() const
-    {
-      assert(anchor.m_object != nullptr);
-
-      switch (anchor.m_object->type()) {
-        // use integer array index as key
-        case value_t::array:
-          return std::to_string(array_index);
-
-        // use key from the object
-        case value_t::object:
-          return anchor.key();
-
-        // use an empty key for all primitive types
-        default:
-          return "";
-      }
-    }
-
-    /// return value of the iterator
-    typename IteratorType::reference value() const
-    {
-      return anchor.value();
-    }
-  };
-
-  /// the container to iterate
-  typename IteratorType::reference container;
-
- public:
-  /// construct iteration proxy from a container
-  explicit iteration_proxy(typename IteratorType::reference cont) noexcept
-    : container(cont) {}
-
-  /// return iterator begin (needed for range-based for)
-  iteration_proxy_internal begin() noexcept
-  {
-    return iteration_proxy_internal(container.begin());
-  }
-
-  /// return iterator end (needed for range-based for)
-  iteration_proxy_internal end() noexcept
-  {
-    return iteration_proxy_internal(container.end());
-  }
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
-
-#include <cstddef>  // ptrdiff_t
-#include <iterator> // reverse_iterator
-#include <utility>  // declval
-
-namespace nlohmann
-{
-namespace detail
-{
-//////////////////////
-// reverse_iterator //
-//////////////////////
-
-/*!
-@brief a template for a reverse iterator class
-
-@tparam Base the base iterator type to reverse. Valid types are @ref
-iterator (to create @ref reverse_iterator) and @ref const_iterator (to
-create @ref const_reverse_iterator).
-
-@requirement The class satisfies the following concept requirements:
--
-[BidirectionalIterator](http://en.cppreference.com/w/cpp/concept/BidirectionalIterator):
-  The iterator that can be moved can be moved in both directions (i.e.
-  incremented and decremented).
-- [OutputIterator](http://en.cppreference.com/w/cpp/concept/OutputIterator):
-  It is possible to write to the pointed-to element (only if @a Base is
-  @ref iterator).
-
-@since version 1.0.0
-*/
-template <typename Base>
-class json_reverse_iterator : public std::reverse_iterator<Base>
-{
- public:
-  using difference_type = std::ptrdiff_t;
-  /// shortcut to the reverse iterator adapter
-  using base_iterator = std::reverse_iterator<Base>;
-  /// the reference type for the pointed-to element
-  using reference = typename Base::reference;
-
-  /// create reverse iterator from iterator
-  json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
-    : base_iterator(it) {}
-
-  /// create reverse iterator from base class
-  json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
-
-  /// post-increment (it++)
-  json_reverse_iterator const operator++(int)
-  {
-    return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
-  }
-
-  /// pre-increment (++it)
-  json_reverse_iterator& operator++()
-  {
-    return static_cast<json_reverse_iterator&>(base_iterator::operator++());
-  }
-
-  /// post-decrement (it--)
-  json_reverse_iterator const operator--(int)
-  {
-    return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
-  }
-
-  /// pre-decrement (--it)
-  json_reverse_iterator& operator--()
-  {
-    return static_cast<json_reverse_iterator&>(base_iterator::operator--());
-  }
-
-  /// add to iterator
-  json_reverse_iterator& operator+=(difference_type i)
-  {
-    return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
-  }
-
-  /// add to iterator
-  json_reverse_iterator operator+(difference_type i) const
-  {
-    return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
-  }
-
-  /// subtract from iterator
-  json_reverse_iterator operator-(difference_type i) const
-  {
-    return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
-  }
-
-  /// return difference
-  difference_type operator-(const json_reverse_iterator& other) const
-  {
-    return base_iterator(*this) - base_iterator(other);
-  }
-
-  /// access to successor
-  reference operator[](difference_type n) const
-  {
-    return *(this->operator+(n));
-  }
-
-  /// return the key of an object iterator
-  auto key() const -> decltype(std::declval<Base>().key())
-  {
-    auto it = --this->base();
-    return it.key();
-  }
-
-  /// return the value of an iterator
-  reference value() const
-  {
-    auto it = --this->base();
-    return it.operator*();
-  }
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-
-#include <algorithm> // copy
-#include <cstddef>   // size_t
-#include <ios>       // streamsize
-#include <iterator>  // back_inserter
-#include <memory>    // shared_ptr, make_shared
-#include <ostream>   // basic_ostream
-#include <string>    // basic_string
-#include <vector>    // vector
-
-namespace nlohmann
-{
-namespace detail
-{
-/// abstract output adapter interface
-template <typename CharType>
-struct output_adapter_protocol {
-  virtual void write_character(CharType c) = 0;
-  virtual void write_characters(const CharType* s, std::size_t length) = 0;
-  virtual ~output_adapter_protocol() = default;
-};
-
-/// a type to simplify interfaces
-template <typename CharType>
-using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
-
-/// output adapter for byte vectors
-template <typename CharType>
-class output_vector_adapter : public output_adapter_protocol<CharType>
-{
- public:
-  explicit output_vector_adapter(std::vector<CharType>& vec) : v(vec) {}
-
-  void write_character(CharType c) override
-  {
-    v.push_back(c);
-  }
-
-  void write_characters(const CharType* s, std::size_t length) override
-  {
-    std::copy(s, s + length, std::back_inserter(v));
-  }
-
- private:
-  std::vector<CharType>& v;
-};
-
-/// output adapter for output streams
-template <typename CharType>
-class output_stream_adapter : public output_adapter_protocol<CharType>
-{
- public:
-  explicit output_stream_adapter(std::basic_ostream<CharType>& s) : stream(s) {}
-
-  void write_character(CharType c) override
-  {
-    stream.put(c);
-  }
-
-  void write_characters(const CharType* s, std::size_t length) override
-  {
-    stream.write(s, static_cast<std::streamsize>(length));
-  }
-
- private:
-  std::basic_ostream<CharType>& stream;
-};
-
-/// output adapter for basic_string
-template <typename CharType, typename StringType = std::basic_string<CharType>>
-class output_string_adapter : public output_adapter_protocol<CharType>
-{
- public:
-  explicit output_string_adapter(StringType& s) : str(s) {}
-
-  void write_character(CharType c) override
-  {
-    str.push_back(c);
-  }
-
-  void write_characters(const CharType* s, std::size_t length) override
-  {
-    str.append(s, length);
-  }
-
- private:
-  StringType& str;
-};
-
-template <typename CharType, typename StringType = std::basic_string<CharType>>
-class output_adapter
-{
- public:
-  output_adapter(std::vector<CharType>& vec)
-    : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
-
-  output_adapter(std::basic_ostream<CharType>& s)
-    : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
-
-  output_adapter(StringType& s)
-    : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
-
-  operator output_adapter_t<CharType>()
-  {
-    return oa;
-  }
-
- private:
-  output_adapter_t<CharType> oa = nullptr;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/input/binary_reader.hpp>
-
-#include <algorithm> // generate_n
-#include <array>     // array
-#include <cassert>   // assert
-#include <cmath>     // ldexp
-#include <cstddef>   // size_t
-#include <cstdint>   // uint8_t, uint16_t, uint32_t, uint64_t
-#include <cstring>   // memcpy
-#include <iomanip>   // setw, setfill
-#include <ios>       // hex
-#include <iterator>  // back_inserter
-#include <limits>    // numeric_limits
-#include <sstream>   // stringstream
-#include <string>    // char_traits, string
-#include <utility>   // make_pair, move
-
-// #include <nlohmann/detail/input/input_adapters.hpp>
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////////////
-// binary reader //
-///////////////////
-
-/*!
-@brief deserialization of CBOR and MessagePack values
-*/
-template <typename BasicJsonType>
-class binary_reader
-{
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  using string_t = typename BasicJsonType::string_t;
-
- public:
-  /*!
-    @brief create a binary reader
-
-    @param[in] adapter  input adapter to read from
-    */
-  explicit binary_reader(input_adapter_t adapter) : ia(std::move(adapter))
-  {
-    assert(ia);
-  }
-
-  /*!
-    @brief create a JSON value from CBOR input
-
-    @param[in] strict  whether to expect the input to be consumed completed
-    @return JSON value created from CBOR input
-
-    @throw parse_error.110 if input ended unexpectedly or the end of file was
-                           not reached when @a strict was set to true
-    @throw parse_error.112 if unsupported byte was read
-    */
-  BasicJsonType parse_cbor(const bool strict)
-  {
-    const auto res = parse_cbor_internal();
-    if (strict) {
-      get();
-      expect_eof();
-    }
-    return res;
-  }
-
-  /*!
-    @brief create a JSON value from MessagePack input
-
-    @param[in] strict  whether to expect the input to be consumed completed
-    @return JSON value created from MessagePack input
-
-    @throw parse_error.110 if input ended unexpectedly or the end of file was
-                           not reached when @a strict was set to true
-    @throw parse_error.112 if unsupported byte was read
-    */
-  BasicJsonType parse_msgpack(const bool strict)
-  {
-    const auto res = parse_msgpack_internal();
-    if (strict) {
-      get();
-      expect_eof();
-    }
-    return res;
-  }
-
-  /*!
-    @brief create a JSON value from UBJSON input
-
-    @param[in] strict  whether to expect the input to be consumed completed
-    @return JSON value created from UBJSON input
-
-    @throw parse_error.110 if input ended unexpectedly or the end of file was
-                           not reached when @a strict was set to true
-    @throw parse_error.112 if unsupported byte was read
-    */
-  BasicJsonType parse_ubjson(const bool strict)
-  {
-    const auto res = parse_ubjson_internal();
-    if (strict) {
-      get_ignore_noop();
-      expect_eof();
-    }
-    return res;
-  }
-
-  /*!
-    @brief determine system byte order
-
-    @return true if and only if system's byte order is little endian
-
-    @note from http://stackoverflow.com/a/1001328/266378
-    */
-  static constexpr bool little_endianess(int num = 1) noexcept
-  {
-    return (*reinterpret_cast<char*>(&num) == 1);
-  }
-
- private:
-  /*!
-    @param[in] get_char  whether a new character should be retrieved from the
-                         input (true, default) or whether the last read
-                         character should be considered instead
-    */
-  BasicJsonType parse_cbor_internal(const bool get_char = true)
-  {
-    switch (get_char ? get() : current) {
-      // EOF
-      case std::char_traits<char>::eof():
-        JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
-
-      // Integer 0x00..0x17 (0..23)
-      case 0x00:
-      case 0x01:
-      case 0x02:
-      case 0x03:
-      case 0x04:
-      case 0x05:
-      case 0x06:
-      case 0x07:
-      case 0x08:
-      case 0x09:
-      case 0x0A:
-      case 0x0B:
-      case 0x0C:
-      case 0x0D:
-      case 0x0E:
-      case 0x0F:
-      case 0x10:
-      case 0x11:
-      case 0x12:
-      case 0x13:
-      case 0x14:
-      case 0x15:
-      case 0x16:
-      case 0x17:
-        return static_cast<number_unsigned_t>(current);
-
-      case 0x18: // Unsigned integer (one-byte uint8_t follows)
-        return get_number<uint8_t>();
-
-      case 0x19: // Unsigned integer (two-byte uint16_t follows)
-        return get_number<uint16_t>();
-
-      case 0x1A: // Unsigned integer (four-byte uint32_t follows)
-        return get_number<uint32_t>();
-
-      case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
-        return get_number<uint64_t>();
-
-      // Negative integer -1-0x00..-1-0x17 (-1..-24)
-      case 0x20:
-      case 0x21:
-      case 0x22:
-      case 0x23:
-      case 0x24:
-      case 0x25:
-      case 0x26:
-      case 0x27:
-      case 0x28:
-      case 0x29:
-      case 0x2A:
-      case 0x2B:
-      case 0x2C:
-      case 0x2D:
-      case 0x2E:
-      case 0x2F:
-      case 0x30:
-      case 0x31:
-      case 0x32:
-      case 0x33:
-      case 0x34:
-      case 0x35:
-      case 0x36:
-      case 0x37:
-        return static_cast<int8_t>(0x20 - 1 - current);
-
-      case 0x38: // Negative integer (one-byte uint8_t follows)
-      {
-        return static_cast<number_integer_t>(-1) - get_number<uint8_t>();
-      }
-
-      case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
-      {
-        return static_cast<number_integer_t>(-1) - get_number<uint16_t>();
-      }
-
-      case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
-      {
-        return static_cast<number_integer_t>(-1) - get_number<uint32_t>();
-      }
-
-      case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
-      {
-        return static_cast<number_integer_t>(-1) -
-               static_cast<number_integer_t>(get_number<uint64_t>());
-      }
-
-      // UTF-8 string (0x00..0x17 bytes follow)
-      case 0x60:
-      case 0x61:
-      case 0x62:
-      case 0x63:
-      case 0x64:
-      case 0x65:
-      case 0x66:
-      case 0x67:
-      case 0x68:
-      case 0x69:
-      case 0x6A:
-      case 0x6B:
-      case 0x6C:
-      case 0x6D:
-      case 0x6E:
-      case 0x6F:
-      case 0x70:
-      case 0x71:
-      case 0x72:
-      case 0x73:
-      case 0x74:
-      case 0x75:
-      case 0x76:
-      case 0x77:
-      case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
-      case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
-      case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
-      case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
-      case 0x7F: // UTF-8 string (indefinite length)
-      {
-        return get_cbor_string();
-      }
-
-      // array (0x00..0x17 data items follow)
-      case 0x80:
-      case 0x81:
-      case 0x82:
-      case 0x83:
-      case 0x84:
-      case 0x85:
-      case 0x86:
-      case 0x87:
-      case 0x88:
-      case 0x89:
-      case 0x8A:
-      case 0x8B:
-      case 0x8C:
-      case 0x8D:
-      case 0x8E:
-      case 0x8F:
-      case 0x90:
-      case 0x91:
-      case 0x92:
-      case 0x93:
-      case 0x94:
-      case 0x95:
-      case 0x96:
-      case 0x97: {
-        return get_cbor_array(current & 0x1F);
-      }
-
-      case 0x98: // array (one-byte uint8_t for n follows)
-      {
-        return get_cbor_array(get_number<uint8_t>());
-      }
-
-      case 0x99: // array (two-byte uint16_t for n follow)
-      {
-        return get_cbor_array(get_number<uint16_t>());
-      }
-
-      case 0x9A: // array (four-byte uint32_t for n follow)
-      {
-        return get_cbor_array(get_number<uint32_t>());
-      }
-
-      case 0x9B: // array (eight-byte uint64_t for n follow)
-      {
-        return get_cbor_array(get_number<uint64_t>());
-      }
-
-      case 0x9F: // array (indefinite length)
-      {
-        BasicJsonType result = value_t::array;
-        while (get() != 0xFF) {
-          result.push_back(parse_cbor_internal(false));
-        }
-        return result;
-      }
-
-      // map (0x00..0x17 pairs of data items follow)
-      case 0xA0:
-      case 0xA1:
-      case 0xA2:
-      case 0xA3:
-      case 0xA4:
-      case 0xA5:
-      case 0xA6:
-      case 0xA7:
-      case 0xA8:
-      case 0xA9:
-      case 0xAA:
-      case 0xAB:
-      case 0xAC:
-      case 0xAD:
-      case 0xAE:
-      case 0xAF:
-      case 0xB0:
-      case 0xB1:
-      case 0xB2:
-      case 0xB3:
-      case 0xB4:
-      case 0xB5:
-      case 0xB6:
-      case 0xB7: {
-        return get_cbor_object(current & 0x1F);
-      }
-
-      case 0xB8: // map (one-byte uint8_t for n follows)
-      {
-        return get_cbor_object(get_number<uint8_t>());
-      }
-
-      case 0xB9: // map (two-byte uint16_t for n follow)
-      {
-        return get_cbor_object(get_number<uint16_t>());
-      }
-
-      case 0xBA: // map (four-byte uint32_t for n follow)
-      {
-        return get_cbor_object(get_number<uint32_t>());
-      }
-
-      case 0xBB: // map (eight-byte uint64_t for n follow)
-      {
-        return get_cbor_object(get_number<uint64_t>());
-      }
-
-      case 0xBF: // map (indefinite length)
-      {
-        BasicJsonType result = value_t::object;
-        while (get() != 0xFF) {
-          auto key = get_cbor_string();
-          result[key] = parse_cbor_internal();
-        }
-        return result;
-      }
-
-      case 0xF4: // false
-      {
-        return false;
-      }
-
-      case 0xF5: // true
-      {
-        return true;
-      }
-
-      case 0xF6: // null
-      {
-        return value_t::null;
-      }
-
-      case 0xF9: // Half-Precision Float (two-byte IEEE 754)
-      {
-        const int byte1 = get();
-        unexpect_eof();
-        const int byte2 = get();
-        unexpect_eof();
-
-        // code from RFC 7049, Appendix D, Figure 3:
-        // As half-precision floating-point numbers were only added
-        // to IEEE 754 in 2008, today's programming platforms often
-        // still only have limited support for them. It is very
-        // easy to include at least decoding support for them even
-        // without such support. An example of a small decoder for
-        // half-precision floating-point numbers in the C language
-        // is shown in Fig. 3.
-        const int half = (byte1 << 8) + byte2;
-        const int exp = (half >> 10) & 0x1F;
-        const int mant = half & 0x3FF;
-        double val;
-        if (exp == 0) {
-          val = std::ldexp(mant, -24);
-        } else if (exp != 31) {
-          val = std::ldexp(mant + 1024, exp - 25);
-        } else {
-          val = (mant == 0) ? std::numeric_limits<double>::infinity()
-                            : std::numeric_limits<double>::quiet_NaN();
-        }
-        return (half & 0x8000) != 0 ? -val : val;
-      }
-
-      case 0xFA: // Single-Precision Float (four-byte IEEE 754)
-      {
-        return get_number<float>();
-      }
-
-      case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
-      {
-        return get_number<double>();
-      }
-
-      default: // anything else (0xFF is handled inside the other types)
-      {
-        std::stringstream ss;
-        ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-        JSON_THROW(parse_error::create(112, chars_read, "error reading CBOR; last byte: 0x" + ss.str()));
-      }
-    }
-  }
-
-  BasicJsonType parse_msgpack_internal()
-  {
-    switch (get()) {
-      // EOF
-      case std::char_traits<char>::eof():
-        JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
-
-      // positive fixint
-      case 0x00:
-      case 0x01:
-      case 0x02:
-      case 0x03:
-      case 0x04:
-      case 0x05:
-      case 0x06:
-      case 0x07:
-      case 0x08:
-      case 0x09:
-      case 0x0A:
-      case 0x0B:
-      case 0x0C:
-      case 0x0D:
-      case 0x0E:
-      case 0x0F:
-      case 0x10:
-      case 0x11:
-      case 0x12:
-      case 0x13:
-      case 0x14:
-      case 0x15:
-      case 0x16:
-      case 0x17:
-      case 0x18:
-      case 0x19:
-      case 0x1A:
-      case 0x1B:
-      case 0x1C:
-      case 0x1D:
-      case 0x1E:
-      case 0x1F:
-      case 0x20:
-      case 0x21:
-      case 0x22:
-      case 0x23:
-      case 0x24:
-      case 0x25:
-      case 0x26:
-      case 0x27:
-      case 0x28:
-      case 0x29:
-      case 0x2A:
-      case 0x2B:
-      case 0x2C:
-      case 0x2D:
-      case 0x2E:
-      case 0x2F:
-      case 0x30:
-      case 0x31:
-      case 0x32:
-      case 0x33:
-      case 0x34:
-      case 0x35:
-      case 0x36:
-      case 0x37:
-      case 0x38:
-      case 0x39:
-      case 0x3A:
-      case 0x3B:
-      case 0x3C:
-      case 0x3D:
-      case 0x3E:
-      case 0x3F:
-      case 0x40:
-      case 0x41:
-      case 0x42:
-      case 0x43:
-      case 0x44:
-      case 0x45:
-      case 0x46:
-      case 0x47:
-      case 0x48:
-      case 0x49:
-      case 0x4A:
-      case 0x4B:
-      case 0x4C:
-      case 0x4D:
-      case 0x4E:
-      case 0x4F:
-      case 0x50:
-      case 0x51:
-      case 0x52:
-      case 0x53:
-      case 0x54:
-      case 0x55:
-      case 0x56:
-      case 0x57:
-      case 0x58:
-      case 0x59:
-      case 0x5A:
-      case 0x5B:
-      case 0x5C:
-      case 0x5D:
-      case 0x5E:
-      case 0x5F:
-      case 0x60:
-      case 0x61:
-      case 0x62:
-      case 0x63:
-      case 0x64:
-      case 0x65:
-      case 0x66:
-      case 0x67:
-      case 0x68:
-      case 0x69:
-      case 0x6A:
-      case 0x6B:
-      case 0x6C:
-      case 0x6D:
-      case 0x6E:
-      case 0x6F:
-      case 0x70:
-      case 0x71:
-      case 0x72:
-      case 0x73:
-      case 0x74:
-      case 0x75:
-      case 0x76:
-      case 0x77:
-      case 0x78:
-      case 0x79:
-      case 0x7A:
-      case 0x7B:
-      case 0x7C:
-      case 0x7D:
-      case 0x7E:
-      case 0x7F:
-        return static_cast<number_unsigned_t>(current);
-
-      // fixmap
-      case 0x80:
-      case 0x81:
-      case 0x82:
-      case 0x83:
-      case 0x84:
-      case 0x85:
-      case 0x86:
-      case 0x87:
-      case 0x88:
-      case 0x89:
-      case 0x8A:
-      case 0x8B:
-      case 0x8C:
-      case 0x8D:
-      case 0x8E:
-      case 0x8F: {
-        return get_msgpack_object(current & 0x0F);
-      }
-
-      // fixarray
-      case 0x90:
-      case 0x91:
-      case 0x92:
-      case 0x93:
-      case 0x94:
-      case 0x95:
-      case 0x96:
-      case 0x97:
-      case 0x98:
-      case 0x99:
-      case 0x9A:
-      case 0x9B:
-      case 0x9C:
-      case 0x9D:
-      case 0x9E:
-      case 0x9F: {
-        return get_msgpack_array(current & 0x0F);
-      }
-
-      // fixstr
-      case 0xA0:
-      case 0xA1:
-      case 0xA2:
-      case 0xA3:
-      case 0xA4:
-      case 0xA5:
-      case 0xA6:
-      case 0xA7:
-      case 0xA8:
-      case 0xA9:
-      case 0xAA:
-      case 0xAB:
-      case 0xAC:
-      case 0xAD:
-      case 0xAE:
-      case 0xAF:
-      case 0xB0:
-      case 0xB1:
-      case 0xB2:
-      case 0xB3:
-      case 0xB4:
-      case 0xB5:
-      case 0xB6:
-      case 0xB7:
-      case 0xB8:
-      case 0xB9:
-      case 0xBA:
-      case 0xBB:
-      case 0xBC:
-      case 0xBD:
-      case 0xBE:
-      case 0xBF:
-        return get_msgpack_string();
-
-      case 0xC0: // nil
-        return value_t::null;
-
-      case 0xC2: // false
-        return false;
-
-      case 0xC3: // true
-        return true;
-
-      case 0xCA: // float 32
-        return get_number<float>();
-
-      case 0xCB: // float 64
-        return get_number<double>();
-
-      case 0xCC: // uint 8
-        return get_number<uint8_t>();
-
-      case 0xCD: // uint 16
-        return get_number<uint16_t>();
-
-      case 0xCE: // uint 32
-        return get_number<uint32_t>();
-
-      case 0xCF: // uint 64
-        return get_number<uint64_t>();
-
-      case 0xD0: // int 8
-        return get_number<int8_t>();
-
-      case 0xD1: // int 16
-        return get_number<int16_t>();
-
-      case 0xD2: // int 32
-        return get_number<int32_t>();
-
-      case 0xD3: // int 64
-        return get_number<int64_t>();
-
-      case 0xD9: // str 8
-      case 0xDA: // str 16
-      case 0xDB: // str 32
-        return get_msgpack_string();
-
-      case 0xDC: // array 16
-      {
-        return get_msgpack_array(get_number<uint16_t>());
-      }
-
-      case 0xDD: // array 32
-      {
-        return get_msgpack_array(get_number<uint32_t>());
-      }
-
-      case 0xDE: // map 16
-      {
-        return get_msgpack_object(get_number<uint16_t>());
-      }
-
-      case 0xDF: // map 32
-      {
-        return get_msgpack_object(get_number<uint32_t>());
-      }
-
-      // positive fixint
-      case 0xE0:
-      case 0xE1:
-      case 0xE2:
-      case 0xE3:
-      case 0xE4:
-      case 0xE5:
-      case 0xE6:
-      case 0xE7:
-      case 0xE8:
-      case 0xE9:
-      case 0xEA:
-      case 0xEB:
-      case 0xEC:
-      case 0xED:
-      case 0xEE:
-      case 0xEF:
-      case 0xF0:
-      case 0xF1:
-      case 0xF2:
-      case 0xF3:
-      case 0xF4:
-      case 0xF5:
-      case 0xF6:
-      case 0xF7:
-      case 0xF8:
-      case 0xF9:
-      case 0xFA:
-      case 0xFB:
-      case 0xFC:
-      case 0xFD:
-      case 0xFE:
-      case 0xFF:
-        return static_cast<int8_t>(current);
-
-      default: // anything else
-      {
-        std::stringstream ss;
-        ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-        JSON_THROW(parse_error::create(112, chars_read,
-                                       "error reading MessagePack; last byte: 0x" + ss.str()));
-      }
-    }
-  }
-
-  /*!
-    @param[in] get_char  whether a new character should be retrieved from the
-                         input (true, default) or whether the last read
-                         character should be considered instead
-    */
-  BasicJsonType parse_ubjson_internal(const bool get_char = true)
-  {
-    return get_ubjson_value(get_char ? get_ignore_noop() : current);
-  }
-
-  /*!
-    @brief get next character from the input
-
-    This function provides the interface to the used input adapter. It does
-    not throw in case the input reached EOF, but returns a -'ve valued
-    `std::char_traits<char>::eof()` in that case.
-
-    @return character read from the input
-    */
-  int get()
-  {
-    ++chars_read;
-    return (current = ia->get_character());
-  }
-
-  /*!
-    @return character read from the input after ignoring all 'N' entries
-    */
-  int get_ignore_noop()
-  {
-    do {
-      get();
-    } while (current == 'N');
-
-    return current;
-  }
-
-  /*
-    @brief read a number from the input
-
-    @tparam NumberType the type of the number
-
-    @return number of type @a NumberType
-
-    @note This function needs to respect the system's endianess, because
-          bytes in CBOR and MessagePack are stored in network order (big
-          endian) and therefore need reordering on little endian systems.
-
-    @throw parse_error.110 if input has less than `sizeof(NumberType)` bytes
-    */
-  template <typename NumberType>
-  NumberType get_number()
-  {
-    // step 1: read input into array with system's byte order
-    std::array<uint8_t, sizeof(NumberType)> vec;
-    for (std::size_t i = 0; i < sizeof(NumberType); ++i) {
-      get();
-      unexpect_eof();
-
-      // reverse byte order prior to conversion if necessary
-      if (is_little_endian) {
-        vec[sizeof(NumberType) - i - 1] = static_cast<uint8_t>(current);
-      } else {
-        vec[i] = static_cast<uint8_t>(current); // LCOV_EXCL_LINE
-      }
-    }
-
-    // step 2: convert array into number of type T and return
-    NumberType result;
-    std::memcpy(&result, vec.data(), sizeof(NumberType));
-    return result;
-  }
-
-  /*!
-    @brief create a string by reading characters from the input
-
-    @param[in] len number of bytes to read
-
-    @note We can not reserve @a len bytes for the result, because @a len
-          may be too large. Usually, @ref unexpect_eof() detects the end of
-          the input before we run out of string memory.
-
-    @return string created by reading @a len bytes
-
-    @throw parse_error.110 if input has less than @a len bytes
-    */
-  template <typename NumberType>
-  string_t get_string(const NumberType len)
-  {
-    string_t result;
-    std::generate_n(std::back_inserter(result), len, [this]() {
-      get();
-      unexpect_eof();
-      return static_cast<char>(current);
-    });
-    return result;
-  }
-
-  /*!
-    @brief reads a CBOR string
-
-    This function first reads starting bytes to determine the expected
-    string length and then copies this number of bytes into a string.
-    Additionally, CBOR's strings with indefinite lengths are supported.
-
-    @return string
-
-    @throw parse_error.110 if input ended
-    @throw parse_error.113 if an unexpected byte is read
-    */
-  string_t get_cbor_string()
-  {
-    unexpect_eof();
-
-    switch (current) {
-      // UTF-8 string (0x00..0x17 bytes follow)
-      case 0x60:
-      case 0x61:
-      case 0x62:
-      case 0x63:
-      case 0x64:
-      case 0x65:
-      case 0x66:
-      case 0x67:
-      case 0x68:
-      case 0x69:
-      case 0x6A:
-      case 0x6B:
-      case 0x6C:
-      case 0x6D:
-      case 0x6E:
-      case 0x6F:
-      case 0x70:
-      case 0x71:
-      case 0x72:
-      case 0x73:
-      case 0x74:
-      case 0x75:
-      case 0x76:
-      case 0x77: {
-        return get_string(current & 0x1F);
-      }
-
-      case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
-      {
-        return get_string(get_number<uint8_t>());
-      }
-
-      case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
-      {
-        return get_string(get_number<uint16_t>());
-      }
-
-      case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
-      {
-        return get_string(get_number<uint32_t>());
-      }
-
-      case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
-      {
-        return get_string(get_number<uint64_t>());
-      }
-
-      case 0x7F: // UTF-8 string (indefinite length)
-      {
-        string_t result;
-        while (get() != 0xFF) {
-          result.append(get_cbor_string());
-        }
-        return result;
-      }
-
-      default: {
-        std::stringstream ss;
-        ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-        JSON_THROW(parse_error::create(113, chars_read, "expected a CBOR string; last byte: 0x" + ss.str()));
-      }
-    }
-  }
-
-  template <typename NumberType>
-  BasicJsonType get_cbor_array(const NumberType len)
-  {
-    BasicJsonType result = value_t::array;
-    std::generate_n(std::back_inserter(*result.m_value.array), len, [this]() {
-      return parse_cbor_internal();
-    });
-    return result;
-  }
-
-  template <typename NumberType>
-  BasicJsonType get_cbor_object(const NumberType len)
-  {
-    BasicJsonType result = value_t::object;
-    std::generate_n(std::inserter(*result.m_value.object,
-                                  result.m_value.object->end()),
-                    len, [this]() {
-                      get();
-                      auto key = get_cbor_string();
-                      auto val = parse_cbor_internal();
-                      return std::make_pair(std::move(key), std::move(val));
-                    });
-    return result;
-  }
-
-  /*!
-    @brief reads a MessagePack string
-
-    This function first reads starting bytes to determine the expected
-    string length and then copies this number of bytes into a string.
-
-    @return string
-
-    @throw parse_error.110 if input ended
-    @throw parse_error.113 if an unexpected byte is read
-    */
-  string_t get_msgpack_string()
-  {
-    unexpect_eof();
-
-    switch (current) {
-      // fixstr
-      case 0xA0:
-      case 0xA1:
-      case 0xA2:
-      case 0xA3:
-      case 0xA4:
-      case 0xA5:
-      case 0xA6:
-      case 0xA7:
-      case 0xA8:
-      case 0xA9:
-      case 0xAA:
-      case 0xAB:
-      case 0xAC:
-      case 0xAD:
-      case 0xAE:
-      case 0xAF:
-      case 0xB0:
-      case 0xB1:
-      case 0xB2:
-      case 0xB3:
-      case 0xB4:
-      case 0xB5:
-      case 0xB6:
-      case 0xB7:
-      case 0xB8:
-      case 0xB9:
-      case 0xBA:
-      case 0xBB:
-      case 0xBC:
-      case 0xBD:
-      case 0xBE:
-      case 0xBF: {
-        return get_string(current & 0x1F);
-      }
-
-      case 0xD9: // str 8
-      {
-        return get_string(get_number<uint8_t>());
-      }
-
-      case 0xDA: // str 16
-      {
-        return get_string(get_number<uint16_t>());
-      }
-
-      case 0xDB: // str 32
-      {
-        return get_string(get_number<uint32_t>());
-      }
-
-      default: {
-        std::stringstream ss;
-        ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-        JSON_THROW(parse_error::create(113, chars_read,
-                                       "expected a MessagePack string; last byte: 0x" + ss.str()));
-      }
-    }
-  }
-
-  template <typename NumberType>
-  BasicJsonType get_msgpack_array(const NumberType len)
-  {
-    BasicJsonType result = value_t::array;
-    std::generate_n(std::back_inserter(*result.m_value.array), len, [this]() {
-      return parse_msgpack_internal();
-    });
-    return result;
-  }
-
-  template <typename NumberType>
-  BasicJsonType get_msgpack_object(const NumberType len)
-  {
-    BasicJsonType result = value_t::object;
-    std::generate_n(std::inserter(*result.m_value.object,
-                                  result.m_value.object->end()),
-                    len, [this]() {
-                      get();
-                      auto key = get_msgpack_string();
-                      auto val = parse_msgpack_internal();
-                      return std::make_pair(std::move(key), std::move(val));
-                    });
-    return result;
-  }
-
-  /*!
-    @brief reads a UBJSON string
-
-    This function is either called after reading the 'S' byte explicitly
-    indicating a string, or in case of an object key where the 'S' byte can be
-    left out.
-
-    @param[in] get_char  whether a new character should be retrieved from the
-                         input (true, default) or whether the last read
-                         character should be considered instead
-
-    @return string
-
-    @throw parse_error.110 if input ended
-    @throw parse_error.113 if an unexpected byte is read
-    */
-  string_t get_ubjson_string(const bool get_char = true)
-  {
-    if (get_char) {
-      get(); // TODO: may we ignore N here?
-    }
-
-    unexpect_eof();
-
-    switch (current) {
-      case 'U':
-        return get_string(get_number<uint8_t>());
-      case 'i':
-        return get_string(get_number<int8_t>());
-      case 'I':
-        return get_string(get_number<int16_t>());
-      case 'l':
-        return get_string(get_number<int32_t>());
-      case 'L':
-        return get_string(get_number<int64_t>());
-      default:
-        std::stringstream ss;
-        ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-        JSON_THROW(parse_error::create(113, chars_read,
-                                       "expected a UBJSON string; last byte: 0x" + ss.str()));
-    }
-  }
-
-  /*!
-    @brief determine the type and size for a container
-
-    In the optimized UBJSON format, a type and a size can be provided to allow
-    for a more compact representation.
-
-    @return pair of the size and the type
-    */
-  std::pair<std::size_t, int> get_ubjson_size_type()
-  {
-    std::size_t sz = string_t::npos;
-    int tc = 0;
-
-    get_ignore_noop();
-
-    if (current == '$') {
-      tc = get(); // must not ignore 'N', because 'N' maybe the type
-      unexpect_eof();
-
-      get_ignore_noop();
-      if (current != '#') {
-        std::stringstream ss;
-        ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-        JSON_THROW(parse_error::create(112, chars_read,
-                                       "expected '#' after UBJSON type information; last byte: 0x" + ss.str()));
-      }
-      sz = parse_ubjson_internal();
-    } else if (current == '#') {
-      sz = parse_ubjson_internal();
-    }
-
-    return std::make_pair(sz, tc);
-  }
-
-  BasicJsonType get_ubjson_value(const int prefix)
-  {
-    switch (prefix) {
-      case std::char_traits<char>::eof(): // EOF
-        JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
-
-      case 'T': // true
-        return true;
-      case 'F': // false
-        return false;
-
-      case 'Z': // null
-        return nullptr;
-
-      case 'U':
-        return get_number<uint8_t>();
-      case 'i':
-        return get_number<int8_t>();
-      case 'I':
-        return get_number<int16_t>();
-      case 'l':
-        return get_number<int32_t>();
-      case 'L':
-        return get_number<int64_t>();
-      case 'd':
-        return get_number<float>();
-      case 'D':
-        return get_number<double>();
-
-      case 'C': // char
-      {
-        get();
-        unexpect_eof();
-        if (JSON_UNLIKELY(current > 127)) {
-          std::stringstream ss;
-          ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-          JSON_THROW(parse_error::create(113, chars_read,
-                                         "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + ss.str()));
-        }
-        return string_t(1, static_cast<char>(current));
-      }
-
-      case 'S': // string
-        return get_ubjson_string();
-
-      case '[': // array
-        return get_ubjson_array();
-
-      case '{': // object
-        return get_ubjson_object();
-
-      default: // anything else
-        std::stringstream ss;
-        ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << current;
-        JSON_THROW(parse_error::create(112, chars_read,
-                                       "error reading UBJSON; last byte: 0x" + ss.str()));
-    }
-  }
-
-  BasicJsonType get_ubjson_array()
-  {
-    BasicJsonType result = value_t::array;
-    const auto size_and_type = get_ubjson_size_type();
-
-    if (size_and_type.first != string_t::npos) {
-      if (JSON_UNLIKELY(size_and_type.first > result.max_size())) {
-        JSON_THROW(out_of_range::create(408,
-                                        "excessive array size: " + std::to_string(size_and_type.first)));
-      }
-
-      if (size_and_type.second != 0) {
-        if (size_and_type.second != 'N') {
-          std::generate_n(std::back_inserter(*result.m_value.array),
-                          size_and_type.first, [this, size_and_type]() {
-                            return get_ubjson_value(size_and_type.second);
-                          });
-        }
-      } else {
-        std::generate_n(std::back_inserter(*result.m_value.array),
-                        size_and_type.first, [this]() {
-                          return parse_ubjson_internal();
-                        });
-      }
-    } else {
-      while (current != ']') {
-        result.push_back(parse_ubjson_internal(false));
-        get_ignore_noop();
-      }
-    }
-
-    return result;
-  }
-
-  BasicJsonType get_ubjson_object()
-  {
-    BasicJsonType result = value_t::object;
-    const auto size_and_type = get_ubjson_size_type();
-
-    if (size_and_type.first != string_t::npos) {
-      if (JSON_UNLIKELY(size_and_type.first > result.max_size())) {
-        JSON_THROW(out_of_range::create(408,
-                                        "excessive object size: " + std::to_string(size_and_type.first)));
-      }
-
-      if (size_and_type.second != 0) {
-        std::generate_n(std::inserter(*result.m_value.object,
-                                      result.m_value.object->end()),
-                        size_and_type.first, [this, size_and_type]() {
-                          auto key = get_ubjson_string();
-                          auto val = get_ubjson_value(size_and_type.second);
-                          return std::make_pair(std::move(key), std::move(val));
-                        });
-      } else {
-        std::generate_n(std::inserter(*result.m_value.object,
-                                      result.m_value.object->end()),
-                        size_and_type.first, [this]() {
-                          auto key = get_ubjson_string();
-                          auto val = parse_ubjson_internal();
-                          return std::make_pair(std::move(key), std::move(val));
-                        });
-      }
-    } else {
-      while (current != '}') {
-        auto key = get_ubjson_string(false);
-        result[std::move(key)] = parse_ubjson_internal();
-        get_ignore_noop();
-      }
-    }
-
-    return result;
-  }
-
-  /*!
-    @brief throw if end of input is not reached
-    @throw parse_error.110 if input not ended
-    */
-  void expect_eof() const
-  {
-    if (JSON_UNLIKELY(current != std::char_traits<char>::eof())) {
-      JSON_THROW(parse_error::create(110, chars_read, "expected end of input"));
-    }
-  }
-
-  /*!
-    @briefthrow if end of input is reached
-    @throw parse_error.110 if input ended
-    */
-  void unexpect_eof() const
-  {
-    if (JSON_UNLIKELY(current == std::char_traits<char>::eof())) {
-      JSON_THROW(parse_error::create(110, chars_read, "unexpected end of input"));
-    }
-  }
-
- private:
-  /// input adapter
-  input_adapter_t ia = nullptr;
-
-  /// the current character
-  int current = std::char_traits<char>::eof();
-
-  /// the number of characters read
-  std::size_t chars_read = 0;
-
-  /// whether we can assume little endianess
-  const bool is_little_endian = little_endianess();
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/output/binary_writer.hpp>
-
-#include <algorithm> // reverse
-#include <array>     // array
-#include <cstdint>   // uint8_t, uint16_t, uint32_t, uint64_t
-#include <cstring>   // memcpy
-#include <limits>    // numeric_limits
-
-// #include <nlohmann/detail/input/binary_reader.hpp>
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////////////
-// binary writer //
-///////////////////
-
-/*!
-@brief serialization to CBOR and MessagePack values
-*/
-template <typename BasicJsonType, typename CharType>
-class binary_writer
-{
- public:
-  /*!
-    @brief create a binary writer
-
-    @param[in] adapter  output adapter to write to
-    */
-  explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
-  {
-    assert(oa);
-  }
-
-  /*!
-    @brief[in] j  JSON value to serialize
-    */
-  void write_cbor(const BasicJsonType& j)
-  {
-    switch (j.type()) {
-      case value_t::null: {
-        oa->write_character(static_cast<CharType>(0xF6));
-        break;
-      }
-
-      case value_t::boolean: {
-        oa->write_character(j.m_value.boolean
-                              ? static_cast<CharType>(0xF5)
-                              : static_cast<CharType>(0xF4));
-        break;
-      }
-
-      case value_t::number_integer: {
-        if (j.m_value.number_integer >= 0) {
-          // CBOR does not differentiate between positive signed
-          // integers and unsigned integers. Therefore, we used the
-          // code from the value_t::number_unsigned case here.
-          if (j.m_value.number_integer <= 0x17) {
-            write_number(static_cast<uint8_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)()) {
-            oa->write_character(static_cast<CharType>(0x18));
-            write_number(static_cast<uint8_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_integer <= (std::numeric_limits<uint16_t>::max)()) {
-            oa->write_character(static_cast<CharType>(0x19));
-            write_number(static_cast<uint16_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_integer <= (std::numeric_limits<uint32_t>::max)()) {
-            oa->write_character(static_cast<CharType>(0x1A));
-            write_number(static_cast<uint32_t>(j.m_value.number_integer));
-          } else {
-            oa->write_character(static_cast<CharType>(0x1B));
-            write_number(static_cast<uint64_t>(j.m_value.number_integer));
-          }
-        } else {
-          // The conversions below encode the sign in the first
-          // byte, and the value is converted to a positive number.
-          const auto positive_number = -1 - j.m_value.number_integer;
-          if (j.m_value.number_integer >= -24) {
-            write_number(static_cast<uint8_t>(0x20 + positive_number));
-          } else if (positive_number <= (std::numeric_limits<uint8_t>::max)()) {
-            oa->write_character(static_cast<CharType>(0x38));
-            write_number(static_cast<uint8_t>(positive_number));
-          } else if (positive_number <= (std::numeric_limits<uint16_t>::max)()) {
-            oa->write_character(static_cast<CharType>(0x39));
-            write_number(static_cast<uint16_t>(positive_number));
-          } else if (positive_number <= (std::numeric_limits<uint32_t>::max)()) {
-            oa->write_character(static_cast<CharType>(0x3A));
-            write_number(static_cast<uint32_t>(positive_number));
-          } else {
-            oa->write_character(static_cast<CharType>(0x3B));
-            write_number(static_cast<uint64_t>(positive_number));
-          }
-        }
-        break;
-      }
-
-      case value_t::number_unsigned: {
-        if (j.m_value.number_unsigned <= 0x17) {
-          write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x18));
-          write_number(static_cast<uint8_t>(j.m_value.number_unsigned));
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x19));
-          write_number(static_cast<uint16_t>(j.m_value.number_unsigned));
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x1A));
-          write_number(static_cast<uint32_t>(j.m_value.number_unsigned));
-        } else {
-          oa->write_character(static_cast<CharType>(0x1B));
-          write_number(static_cast<uint64_t>(j.m_value.number_unsigned));
-        }
-        break;
-      }
-
-      case value_t::number_float: // Double-Precision Float
-      {
-        oa->write_character(static_cast<CharType>(0xFB));
-        write_number(j.m_value.number_float);
-        break;
-      }
-
-      case value_t::string: {
-        // step 1: write control byte and the string length
-        const auto N = j.m_value.string->size();
-        if (N <= 0x17) {
-          write_number(static_cast<uint8_t>(0x60 + N));
-        } else if (N <= (std::numeric_limits<uint8_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x78));
-          write_number(static_cast<uint8_t>(N));
-        } else if (N <= (std::numeric_limits<uint16_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x79));
-          write_number(static_cast<uint16_t>(N));
-        } else if (N <= (std::numeric_limits<uint32_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x7A));
-          write_number(static_cast<uint32_t>(N));
-        }
-        // LCOV_EXCL_START
-        else if (N <= (std::numeric_limits<uint64_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x7B));
-          write_number(static_cast<uint64_t>(N));
-        }
-        // LCOV_EXCL_STOP
-
-        // step 2: write the string
-        oa->write_characters(
-          reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
-          j.m_value.string->size());
-        break;
-      }
-
-      case value_t::array: {
-        // step 1: write control byte and the array size
-        const auto N = j.m_value.array->size();
-        if (N <= 0x17) {
-          write_number(static_cast<uint8_t>(0x80 + N));
-        } else if (N <= (std::numeric_limits<uint8_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x98));
-          write_number(static_cast<uint8_t>(N));
-        } else if (N <= (std::numeric_limits<uint16_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x99));
-          write_number(static_cast<uint16_t>(N));
-        } else if (N <= (std::numeric_limits<uint32_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x9A));
-          write_number(static_cast<uint32_t>(N));
-        }
-        // LCOV_EXCL_START
-        else if (N <= (std::numeric_limits<uint64_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0x9B));
-          write_number(static_cast<uint64_t>(N));
-        }
-        // LCOV_EXCL_STOP
-
-        // step 2: write each element
-        for (const auto& el : *j.m_value.array) {
-          write_cbor(el);
-        }
-        break;
-      }
-
-      case value_t::object: {
-        // step 1: write control byte and the object size
-        const auto N = j.m_value.object->size();
-        if (N <= 0x17) {
-          write_number(static_cast<uint8_t>(0xA0 + N));
-        } else if (N <= (std::numeric_limits<uint8_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0xB8));
-          write_number(static_cast<uint8_t>(N));
-        } else if (N <= (std::numeric_limits<uint16_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0xB9));
-          write_number(static_cast<uint16_t>(N));
-        } else if (N <= (std::numeric_limits<uint32_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0xBA));
-          write_number(static_cast<uint32_t>(N));
-        }
-        // LCOV_EXCL_START
-        else if (N <= (std::numeric_limits<uint64_t>::max)()) {
-          oa->write_character(static_cast<CharType>(0xBB));
-          write_number(static_cast<uint64_t>(N));
-        }
-        // LCOV_EXCL_STOP
-
-        // step 2: write each element
-        for (const auto& el : *j.m_value.object) {
-          write_cbor(el.first);
-          write_cbor(el.second);
-        }
-        break;
-      }
-
-      default:
-        break;
-    }
-  }
-
-  /*!
-    @brief[in] j  JSON value to serialize
-    */
-  void write_msgpack(const BasicJsonType& j)
-  {
-    switch (j.type()) {
-      case value_t::null: // nil
-      {
-        oa->write_character(static_cast<CharType>(0xC0));
-        break;
-      }
-
-      case value_t::boolean: // true and false
-      {
-        oa->write_character(j.m_value.boolean
-                              ? static_cast<CharType>(0xC3)
-                              : static_cast<CharType>(0xC2));
-        break;
-      }
-
-      case value_t::number_integer: {
-        if (j.m_value.number_integer >= 0) {
-          // MessagePack does not differentiate between positive
-          // signed integers and unsigned integers. Therefore, we used
-          // the code from the value_t::number_unsigned case here.
-          if (j.m_value.number_unsigned < 128) {
-            // positive fixnum
-            write_number(static_cast<uint8_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)()) {
-            // uint 8
-            oa->write_character(static_cast<CharType>(0xCC));
-            write_number(static_cast<uint8_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)()) {
-            // uint 16
-            oa->write_character(static_cast<CharType>(0xCD));
-            write_number(static_cast<uint16_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)()) {
-            // uint 32
-            oa->write_character(static_cast<CharType>(0xCE));
-            write_number(static_cast<uint32_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)()) {
-            // uint 64
-            oa->write_character(static_cast<CharType>(0xCF));
-            write_number(static_cast<uint64_t>(j.m_value.number_integer));
-          }
-        } else {
-          if (j.m_value.number_integer >= -32) {
-            // negative fixnum
-            write_number(static_cast<int8_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_integer >= (std::numeric_limits<int8_t>::min)() and
-                     j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)()) {
-            // int 8
-            oa->write_character(static_cast<CharType>(0xD0));
-            write_number(static_cast<int8_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_integer >= (std::numeric_limits<int16_t>::min)() and
-                     j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)()) {
-            // int 16
-            oa->write_character(static_cast<CharType>(0xD1));
-            write_number(static_cast<int16_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_integer >= (std::numeric_limits<int32_t>::min)() and
-                     j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)()) {
-            // int 32
-            oa->write_character(static_cast<CharType>(0xD2));
-            write_number(static_cast<int32_t>(j.m_value.number_integer));
-          } else if (j.m_value.number_integer >= (std::numeric_limits<int64_t>::min)() and
-                     j.m_value.number_integer <= (std::numeric_limits<int64_t>::max)()) {
-            // int 64
-            oa->write_character(static_cast<CharType>(0xD3));
-            write_number(static_cast<int64_t>(j.m_value.number_integer));
-          }
-        }
-        break;
-      }
-
-      case value_t::number_unsigned: {
-        if (j.m_value.number_unsigned < 128) {
-          // positive fixnum
-          write_number(static_cast<uint8_t>(j.m_value.number_integer));
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)()) {
-          // uint 8
-          oa->write_character(static_cast<CharType>(0xCC));
-          write_number(static_cast<uint8_t>(j.m_value.number_integer));
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint16_t>::max)()) {
-          // uint 16
-          oa->write_character(static_cast<CharType>(0xCD));
-          write_number(static_cast<uint16_t>(j.m_value.number_integer));
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint32_t>::max)()) {
-          // uint 32
-          oa->write_character(static_cast<CharType>(0xCE));
-          write_number(static_cast<uint32_t>(j.m_value.number_integer));
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint64_t>::max)()) {
-          // uint 64
-          oa->write_character(static_cast<CharType>(0xCF));
-          write_number(static_cast<uint64_t>(j.m_value.number_integer));
-        }
-        break;
-      }
-
-      case value_t::number_float: // float 64
-      {
-        oa->write_character(static_cast<CharType>(0xCB));
-        write_number(j.m_value.number_float);
-        break;
-      }
-
-      case value_t::string: {
-        // step 1: write control byte and the string length
-        const auto N = j.m_value.string->size();
-        if (N <= 31) {
-          // fixstr
-          write_number(static_cast<uint8_t>(0xA0 | N));
-        } else if (N <= (std::numeric_limits<uint8_t>::max)()) {
-          // str 8
-          oa->write_character(static_cast<CharType>(0xD9));
-          write_number(static_cast<uint8_t>(N));
-        } else if (N <= (std::numeric_limits<uint16_t>::max)()) {
-          // str 16
-          oa->write_character(static_cast<CharType>(0xDA));
-          write_number(static_cast<uint16_t>(N));
-        } else if (N <= (std::numeric_limits<uint32_t>::max)()) {
-          // str 32
-          oa->write_character(static_cast<CharType>(0xDB));
-          write_number(static_cast<uint32_t>(N));
-        }
-
-        // step 2: write the string
-        oa->write_characters(
-          reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
-          j.m_value.string->size());
-        break;
-      }
-
-      case value_t::array: {
-        // step 1: write control byte and the array size
-        const auto N = j.m_value.array->size();
-        if (N <= 15) {
-          // fixarray
-          write_number(static_cast<uint8_t>(0x90 | N));
-        } else if (N <= (std::numeric_limits<uint16_t>::max)()) {
-          // array 16
-          oa->write_character(static_cast<CharType>(0xDC));
-          write_number(static_cast<uint16_t>(N));
-        } else if (N <= (std::numeric_limits<uint32_t>::max)()) {
-          // array 32
-          oa->write_character(static_cast<CharType>(0xDD));
-          write_number(static_cast<uint32_t>(N));
-        }
-
-        // step 2: write each element
-        for (const auto& el : *j.m_value.array) {
-          write_msgpack(el);
-        }
-        break;
-      }
-
-      case value_t::object: {
-        // step 1: write control byte and the object size
-        const auto N = j.m_value.object->size();
-        if (N <= 15) {
-          // fixmap
-          write_number(static_cast<uint8_t>(0x80 | (N & 0xF)));
-        } else if (N <= (std::numeric_limits<uint16_t>::max)()) {
-          // map 16
-          oa->write_character(static_cast<CharType>(0xDE));
-          write_number(static_cast<uint16_t>(N));
-        } else if (N <= (std::numeric_limits<uint32_t>::max)()) {
-          // map 32
-          oa->write_character(static_cast<CharType>(0xDF));
-          write_number(static_cast<uint32_t>(N));
-        }
-
-        // step 2: write each element
-        for (const auto& el : *j.m_value.object) {
-          write_msgpack(el.first);
-          write_msgpack(el.second);
-        }
-        break;
-      }
-
-      default:
-        break;
-    }
-  }
-
-  /*!
-    @param[in] j  JSON value to serialize
-    @param[in] use_count   whether to use '#' prefixes (optimized format)
-    @param[in] use_type    whether to use '$' prefixes (optimized format)
-    @param[in] add_prefix  whether prefixes need to be used for this value
-    */
-  void write_ubjson(const BasicJsonType& j, const bool use_count,
-                    const bool use_type, const bool add_prefix = true)
-  {
-    switch (j.type()) {
-      case value_t::null: {
-        if (add_prefix) {
-          oa->write_character(static_cast<CharType>('Z'));
-        }
-        break;
-      }
-
-      case value_t::boolean: {
-        if (add_prefix) {
-          oa->write_character(j.m_value.boolean
-                                ? static_cast<CharType>('T')
-                                : static_cast<CharType>('F'));
-        }
-        break;
-      }
-
-      case value_t::number_integer: {
-        write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
-        break;
-      }
-
-      case value_t::number_unsigned: {
-        write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
-        break;
-      }
-
-      case value_t::number_float: {
-        write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
-        break;
-      }
-
-      case value_t::string: {
-        if (add_prefix) {
-          oa->write_character(static_cast<CharType>('S'));
-        }
-        write_number_with_ubjson_prefix(j.m_value.string->size(), true);
-        oa->write_characters(
-          reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
-          j.m_value.string->size());
-        break;
-      }
-
-      case value_t::array: {
-        if (add_prefix) {
-          oa->write_character(static_cast<CharType>('['));
-        }
-
-        bool prefix_required = true;
-        if (use_type and not j.m_value.array->empty()) {
-          assert(use_count);
-          const char first_prefix = ubjson_prefix(j.front());
-          const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
-                                               [this, first_prefix](const BasicJsonType& v) {
-                                                 return ubjson_prefix(v) == first_prefix;
-                                               });
-
-          if (same_prefix) {
-            prefix_required = false;
-            oa->write_character(static_cast<CharType>('$'));
-            oa->write_character(static_cast<CharType>(first_prefix));
-          }
-        }
-
-        if (use_count) {
-          oa->write_character(static_cast<CharType>('#'));
-          write_number_with_ubjson_prefix(j.m_value.array->size(), true);
-        }
-
-        for (const auto& el : *j.m_value.array) {
-          write_ubjson(el, use_count, use_type, prefix_required);
-        }
-
-        if (not use_count) {
-          oa->write_character(static_cast<CharType>(']'));
-        }
-
-        break;
-      }
-
-      case value_t::object: {
-        if (add_prefix) {
-          oa->write_character(static_cast<CharType>('{'));
-        }
-
-        bool prefix_required = true;
-        if (use_type and not j.m_value.object->empty()) {
-          assert(use_count);
-          const char first_prefix = ubjson_prefix(j.front());
-          const bool same_prefix = std::all_of(j.begin(), j.end(),
-                                               [this, first_prefix](const BasicJsonType& v) {
-                                                 return ubjson_prefix(v) == first_prefix;
-                                               });
-
-          if (same_prefix) {
-            prefix_required = false;
-            oa->write_character(static_cast<CharType>('$'));
-            oa->write_character(static_cast<CharType>(first_prefix));
-          }
-        }
-
-        if (use_count) {
-          oa->write_character(static_cast<CharType>('#'));
-          write_number_with_ubjson_prefix(j.m_value.object->size(), true);
-        }
-
-        for (const auto& el : *j.m_value.object) {
-          write_number_with_ubjson_prefix(el.first.size(), true);
-          oa->write_characters(
-            reinterpret_cast<const CharType*>(el.first.c_str()),
-            el.first.size());
-          write_ubjson(el.second, use_count, use_type, prefix_required);
-        }
-
-        if (not use_count) {
-          oa->write_character(static_cast<CharType>('}'));
-        }
-
-        break;
-      }
-
-      default:
-        break;
-    }
-  }
-
- private:
-  /*
-    @brief write a number to output input
-
-    @param[in] n number of type @a NumberType
-    @tparam NumberType the type of the number
-
-    @note This function needs to respect the system's endianess, because bytes
-          in CBOR, MessagePack, and UBJSON are stored in network order (big
-          endian) and therefore need reordering on little endian systems.
-    */
-  template <typename NumberType>
-  void write_number(const NumberType n)
-  {
-    // step 1: write number to array of length NumberType
-    std::array<CharType, sizeof(NumberType)> vec;
-    std::memcpy(vec.data(), &n, sizeof(NumberType));
-
-    // step 2: write array to output (with possible reordering)
-    if (is_little_endian) {
-      // reverse byte order prior to conversion if necessary
-      std::reverse(vec.begin(), vec.end());
-    }
-
-    oa->write_characters(vec.data(), sizeof(NumberType));
-  }
-
-  // UBJSON: write number (floating point)
-  template <typename NumberType, typename std::enable_if<
-                                   std::is_floating_point<NumberType>::value, int>::type = 0>
-  void write_number_with_ubjson_prefix(const NumberType n,
-                                       const bool add_prefix)
-  {
-    if (add_prefix) {
-      oa->write_character(static_cast<CharType>('D')); // float64
-    }
-    write_number(n);
-  }
-
-  // UBJSON: write number (unsigned integer)
-  template <typename NumberType, typename std::enable_if<
-                                   std::is_unsigned<NumberType>::value, int>::type = 0>
-  void write_number_with_ubjson_prefix(const NumberType n,
-                                       const bool add_prefix)
-  {
-    if (n <= static_cast<uint64_t>((std::numeric_limits<int8_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('i')); // int8
-      }
-      write_number(static_cast<uint8_t>(n));
-    } else if (n <= (std::numeric_limits<uint8_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('U')); // uint8
-      }
-      write_number(static_cast<uint8_t>(n));
-    } else if (n <= static_cast<uint64_t>((std::numeric_limits<int16_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('I')); // int16
-      }
-      write_number(static_cast<int16_t>(n));
-    } else if (n <= static_cast<uint64_t>((std::numeric_limits<int32_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('l')); // int32
-      }
-      write_number(static_cast<int32_t>(n));
-    } else if (n <= static_cast<uint64_t>((std::numeric_limits<int64_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('L')); // int64
-      }
-      write_number(static_cast<int64_t>(n));
-    } else {
-      JSON_THROW(out_of_range::create(407, "number overflow serializing " + std::to_string(n)));
-    }
-  }
-
-  // UBJSON: write number (signed integer)
-  template <typename NumberType, typename std::enable_if<
-                                   std::is_signed<NumberType>::value and
-                                     not std::is_floating_point<NumberType>::value,
-                                   int>::type = 0>
-  void write_number_with_ubjson_prefix(const NumberType n,
-                                       const bool add_prefix)
-  {
-    if ((std::numeric_limits<int8_t>::min)() <= n and n <= (std::numeric_limits<int8_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('i')); // int8
-      }
-      write_number(static_cast<int8_t>(n));
-    } else if (static_cast<int64_t>((std::numeric_limits<uint8_t>::min)()) <= n and n <= static_cast<int64_t>((std::numeric_limits<uint8_t>::max)())) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('U')); // uint8
-      }
-      write_number(static_cast<uint8_t>(n));
-    } else if ((std::numeric_limits<int16_t>::min)() <= n and n <= (std::numeric_limits<int16_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('I')); // int16
-      }
-      write_number(static_cast<int16_t>(n));
-    } else if ((std::numeric_limits<int32_t>::min)() <= n and n <= (std::numeric_limits<int32_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('l')); // int32
-      }
-      write_number(static_cast<int32_t>(n));
-    } else if ((std::numeric_limits<int64_t>::min)() <= n and n <= (std::numeric_limits<int64_t>::max)()) {
-      if (add_prefix) {
-        oa->write_character(static_cast<CharType>('L')); // int64
-      }
-      write_number(static_cast<int64_t>(n));
-    }
-    // LCOV_EXCL_START
-    else {
-      JSON_THROW(out_of_range::create(407, "number overflow serializing " + std::to_string(n)));
-    }
-    // LCOV_EXCL_STOP
-  }
-
-  /*!
-    @brief determine the type prefix of container values
-
-    @note This function does not need to be 100% accurate when it comes to
-          integer limits. In case a number exceeds the limits of int64_t,
-          this will be detected by a later call to function
-          write_number_with_ubjson_prefix. Therefore, we return 'L' for any
-          value that does not fit the previous limits.
-    */
-  char ubjson_prefix(const BasicJsonType& j) const noexcept
-  {
-    switch (j.type()) {
-      case value_t::null:
-        return 'Z';
-
-      case value_t::boolean:
-        return j.m_value.boolean ? 'T' : 'F';
-
-      case value_t::number_integer: {
-        if ((std::numeric_limits<int8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int8_t>::max)()) {
-          return 'i';
-        } else if ((std::numeric_limits<uint8_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<uint8_t>::max)()) {
-          return 'U';
-        } else if ((std::numeric_limits<int16_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int16_t>::max)()) {
-          return 'I';
-        } else if ((std::numeric_limits<int32_t>::min)() <= j.m_value.number_integer and j.m_value.number_integer <= (std::numeric_limits<int32_t>::max)()) {
-          return 'l';
-        } else // no check and assume int64_t (see note above)
-        {
-          return 'L';
-        }
-      }
-
-      case value_t::number_unsigned: {
-        if (j.m_value.number_unsigned <= (std::numeric_limits<int8_t>::max)()) {
-          return 'i';
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<uint8_t>::max)()) {
-          return 'U';
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<int16_t>::max)()) {
-          return 'I';
-        } else if (j.m_value.number_unsigned <= (std::numeric_limits<int32_t>::max)()) {
-          return 'l';
-        } else // no check and assume int64_t (see note above)
-        {
-          return 'L';
-        }
-      }
-
-      case value_t::number_float:
-        return 'D';
-
-      case value_t::string:
-        return 'S';
-
-      case value_t::array:
-        return '[';
-
-      case value_t::object:
-        return '{';
-
-      default: // discarded values
-        return 'N';
-    }
-  }
-
- private:
-  /// whether we can assume little endianess
-  const bool is_little_endian = binary_reader<BasicJsonType>::little_endianess();
-
-  /// the output
-  output_adapter_t<CharType> oa = nullptr;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/output/serializer.hpp>
-
-#include <algorithm>   // reverse, remove, fill, find, none_of
-#include <array>       // array
-#include <cassert>     // assert
-#include <ciso646>     // and, or
-#include <clocale>     // localeconv, lconv
-#include <cmath>       // labs, isfinite, isnan, signbit
-#include <cstddef>     // size_t, ptrdiff_t
-#include <cstdint>     // uint8_t
-#include <cstdio>      // snprintf
-#include <iomanip>     // setfill
-#include <iterator>    // next
-#include <limits>      // numeric_limits
-#include <string>      // string
-#include <sstream>     // stringstream
-#include <type_traits> // is_same
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/conversions/to_chars.hpp>
-
-#include <cassert> // assert
-#include <ciso646> // or, and, not
-#include <cmath>   // signbit, isfinite
-#include <cstdint> // intN_t, uintN_t
-#include <cstring> // memcpy, memmove
-
-namespace nlohmann
-{
-namespace detail
-{
-
-/*!
-@brief implements the Grisu2 algorithm for binary to decimal floating-point
-conversion.
-
-This implementation is a slightly modified version of the reference
-implementation which may be obtained from
-http://florian.loitsch.com/publications (bench.tar.gz).
-
-The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
-
-For a detailed description of the algorithm see:
-
-[1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
-    Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
-    Language Design and Implementation, PLDI 2010
-[2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
-    Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
-    Design and Implementation, PLDI 1996
-*/
-namespace dtoa_impl
-{
-
-template <typename Target, typename Source>
-Target reinterpret_bits(const Source source)
-{
-  static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
-
-  Target target;
-  std::memcpy(&target, &source, sizeof(Source));
-  return target;
-}
-
-struct diyfp // f * 2^e
-{
-  static constexpr int kPrecision = 64; // = q
-
-  uint64_t f;
-  int e;
-
-  constexpr diyfp() noexcept : f(0), e(0) {}
-  constexpr diyfp(uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
-
-  /*!
-    @brief returns x - y
-    @pre x.e == y.e and x.f >= y.f
-    */
-  static diyfp sub(const diyfp& x, const diyfp& y) noexcept
-  {
-    assert(x.e == y.e);
-    assert(x.f >= y.f);
-
-    return diyfp(x.f - y.f, x.e);
-  }
-
-  /*!
-    @brief returns x * y
-    @note The result is rounded. (Only the upper q bits are returned.)
-    */
-  static diyfp mul(const diyfp& x, const diyfp& y) noexcept
-  {
-    static_assert(kPrecision == 64, "internal error");
-
-    // Computes:
-    //  f = round((x.f * y.f) / 2^q)
-    //  e = x.e + y.e + q
-
-    // Emulate the 64-bit * 64-bit multiplication:
-    //
-    // p = u * v
-    //   = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
-    //   = (u_lo v_lo         ) + 2^32 ((u_lo v_hi         ) + (u_hi v_lo         )) + 2^64 (u_hi v_hi         )
-    //   = (p0                ) + 2^32 ((p1                ) + (p2                )) + 2^64 (p3                )
-    //   = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3                )
-    //   = (p0_lo             ) + 2^32 (p0_hi + p1_lo + p2_lo                      ) + 2^64 (p1_hi + p2_hi + p3)
-    //   = (p0_lo             ) + 2^32 (Q                                          ) + 2^64 (H                 )
-    //   = (p0_lo             ) + 2^32 (Q_lo + 2^32 Q_hi                           ) + 2^64 (H                 )
-    //
-    // (Since Q might be larger than 2^32 - 1)
-    //
-    //   = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
-    //
-    // (Q_hi + H does not overflow a 64-bit int)
-    //
-    //   = p_lo + 2^64 p_hi
-
-    const uint64_t u_lo = x.f & 0xFFFFFFFF;
-    const uint64_t u_hi = x.f >> 32;
-    const uint64_t v_lo = y.f & 0xFFFFFFFF;
-    const uint64_t v_hi = y.f >> 32;
-
-    const uint64_t p0 = u_lo * v_lo;
-    const uint64_t p1 = u_lo * v_hi;
-    const uint64_t p2 = u_hi * v_lo;
-    const uint64_t p3 = u_hi * v_hi;
-
-    const uint64_t p0_hi = p0 >> 32;
-    const uint64_t p1_lo = p1 & 0xFFFFFFFF;
-    const uint64_t p1_hi = p1 >> 32;
-    const uint64_t p2_lo = p2 & 0xFFFFFFFF;
-    const uint64_t p2_hi = p2 >> 32;
-
-    uint64_t Q = p0_hi + p1_lo + p2_lo;
-
-    // The full product might now be computed as
-    //
-    // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
-    // p_lo = p0_lo + (Q << 32)
-    //
-    // But in this particular case here, the full p_lo is not required.
-    // Effectively we only need to add the highest bit in p_lo to p_hi (and
-    // Q_hi + 1 does not overflow).
-
-    Q += uint64_t{1} << (64 - 32 - 1); // round, ties up
-
-    const uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32);
-
-    return diyfp(h, x.e + y.e + 64);
-  }
-
-  /*!
-    @brief normalize x such that the significand is >= 2^(q-1)
-    @pre x.f != 0
-    */
-  static diyfp normalize(diyfp x) noexcept
-  {
-    assert(x.f != 0);
-
-    while ((x.f >> 63) == 0) {
-      x.f <<= 1;
-      x.e--;
-    }
-
-    return x;
-  }
-
-  /*!
-    @brief normalize x such that the result has the exponent E
-    @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
-    */
-  static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
-  {
-    const int delta = x.e - target_exponent;
-
-    assert(delta >= 0);
-    assert(((x.f << delta) >> delta) == x.f);
-
-    return diyfp(x.f << delta, target_exponent);
-  }
-};
-
-struct boundaries {
-  diyfp w;
-  diyfp minus;
-  diyfp plus;
-};
-
-/*!
-Compute the (normalized) diyfp representing the input number 'value' and its
-boundaries.
-
-@pre value must be finite and positive
-*/
-template <typename FloatType>
-boundaries compute_boundaries(FloatType value)
-{
-  assert(std::isfinite(value));
-  assert(value > 0);
-
-  // Convert the IEEE representation into a diyfp.
-  //
-  // If v is denormal:
-  //      value = 0.F * 2^(1 - bias) = (          F) * 2^(1 - bias - (p-1))
-  // If v is normalized:
-  //      value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
-
-  static_assert(std::numeric_limits<FloatType>::is_iec559,
-                "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
-
-  constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
-  constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
-  constexpr int kMinExp = 1 - kBias;
-  constexpr uint64_t kHiddenBit = uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
-
-  using bits_type = typename std::conditional<kPrecision == 24, uint32_t, uint64_t>::type;
-
-  const uint64_t bits = reinterpret_bits<bits_type>(value);
-  const uint64_t E = bits >> (kPrecision - 1);
-  const uint64_t F = bits & (kHiddenBit - 1);
-
-  const bool is_denormal = (E == 0);
-  const diyfp v = is_denormal
-                    ? diyfp(F, kMinExp)
-                    : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
-
-  // Compute the boundaries m- and m+ of the floating-point value
-  // v = f * 2^e.
-  //
-  // Determine v- and v+, the floating-point predecessor and successor if v,
-  // respectively.
-  //
-  //      v- = v - 2^e        if f != 2^(p-1) or e == e_min                (A)
-  //         = v - 2^(e-1)    if f == 2^(p-1) and e > e_min                (B)
-  //
-  //      v+ = v + 2^e
-  //
-  // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
-  // between m- and m+ round to v, regardless of how the input rounding
-  // algorithm breaks ties.
-  //
-  //      ---+-------------+-------------+-------------+-------------+---  (A)
-  //         v-            m-            v             m+            v+
-  //
-  //      -----------------+------+------+-------------+-------------+---  (B)
-  //                       v-     m-     v             m+            v+
-
-  const bool lower_boundary_is_closer = (F == 0 and E > 1);
-  const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
-  const diyfp m_minus = lower_boundary_is_closer
-                          ? diyfp(4 * v.f - 1, v.e - 2)  // (B)
-                          : diyfp(2 * v.f - 1, v.e - 1); // (A)
-
-  // Determine the normalized w+ = m+.
-  const diyfp w_plus = diyfp::normalize(m_plus);
-
-  // Determine w- = m- such that e_(w-) = e_(w+).
-  const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
-
-  return {diyfp::normalize(v), w_minus, w_plus};
-}
-
-// Given normalized diyfp w, Grisu needs to find a (normalized) cached
-// power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
-// within a certain range [alpha, gamma] (Definition 3.2 from [1])
-//
-//      alpha <= e = e_c + e_w + q <= gamma
-//
-// or
-//
-//      f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
-//                          <= f_c * f_w * 2^gamma
-//
-// Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
-//
-//      2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
-//
-// or
-//
-//      2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
-//
-// The choice of (alpha,gamma) determines the size of the table and the form of
-// the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
-// in practice:
-//
-// The idea is to cut the number c * w = f * 2^e into two parts, which can be
-// processed independently: An integral part p1, and a fractional part p2:
-//
-//      f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
-//              = (f div 2^-e) + (f mod 2^-e) * 2^e
-//              = p1 + p2 * 2^e
-//
-// The conversion of p1 into decimal form requires a series of divisions and
-// modulos by (a power of) 10. These operations are faster for 32-bit than for
-// 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
-// achieved by choosing
-//
-//      -e >= 32   or   e <= -32 := gamma
-//
-// In order to convert the fractional part
-//
-//      p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
-//
-// into decimal form, the fraction is repeatedly multiplied by 10 and the digits
-// d[-i] are extracted in order:
-//
-//      (10 * p2) div 2^-e = d[-1]
-//      (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
-//
-// The multiplication by 10 must not overflow. It is sufficient to choose
-//
-//      10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
-//
-// Since p2 = f mod 2^-e < 2^-e,
-//
-//      -e <= 60   or   e >= -60 := alpha
-
-constexpr int kAlpha = -60;
-constexpr int kGamma = -32;
-
-struct cached_power // c = f * 2^e ~= 10^k
-{
-  uint64_t f;
-  int e;
-  int k;
-};
-
-/*!
-For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
-power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
-satisfies (Definition 3.2 from [1])
-
-     alpha <= e_c + e + q <= gamma.
-*/
-inline cached_power get_cached_power_for_binary_exponent(int e)
-{
-  // Now
-  //
-  //      alpha <= e_c + e + q <= gamma                                    (1)
-  //      ==> f_c * 2^alpha <= c * 2^e * 2^q
-  //
-  // and since the c's are normalized, 2^(q-1) <= f_c,
-  //
-  //      ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
-  //      ==> 2^(alpha - e - 1) <= c
-  //
-  // If c were an exakt power of ten, i.e. c = 10^k, one may determine k as
-  //
-  //      k = ceil( log_10( 2^(alpha - e - 1) ) )
-  //        = ceil( (alpha - e - 1) * log_10(2) )
-  //
-  // From the paper:
-  // "In theory the result of the procedure could be wrong since c is rounded,
-  //  and the computation itself is approximated [...]. In practice, however,
-  //  this simple function is sufficient."
-  //
-  // For IEEE double precision floating-point numbers converted into
-  // normalized diyfp's w = f * 2^e, with q = 64,
-  //
-  //      e >= -1022      (min IEEE exponent)
-  //           -52        (p - 1)
-  //           -52        (p - 1, possibly normalize denormal IEEE numbers)
-  //           -11        (normalize the diyfp)
-  //         = -1137
-  //
-  // and
-  //
-  //      e <= +1023      (max IEEE exponent)
-  //           -52        (p - 1)
-  //           -11        (normalize the diyfp)
-  //         = 960
-  //
-  // This binary exponent range [-1137,960] results in a decimal exponent
-  // range [-307,324]. One does not need to store a cached power for each
-  // k in this range. For each such k it suffices to find a cached power
-  // such that the exponent of the product lies in [alpha,gamma].
-  // This implies that the difference of the decimal exponents of adjacent
-  // table entries must be less than or equal to
-  //
-  //      floor( (gamma - alpha) * log_10(2) ) = 8.
-  //
-  // (A smaller distance gamma-alpha would require a larger table.)
-
-  // NB:
-  // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
-
-  constexpr int kCachedPowersSize = 79;
-  constexpr int kCachedPowersMinDecExp = -300;
-  constexpr int kCachedPowersDecStep = 8;
-
-  static constexpr cached_power kCachedPowers[] =
-    {
-      {0xAB70FE17C79AC6CA, -1060, -300},
-      {0xFF77B1FCBEBCDC4F, -1034, -292},
-      {0xBE5691EF416BD60C, -1007, -284},
-      {0x8DD01FAD907FFC3C, -980, -276},
-      {0xD3515C2831559A83, -954, -268},
-      {0x9D71AC8FADA6C9B5, -927, -260},
-      {0xEA9C227723EE8BCB, -901, -252},
-      {0xAECC49914078536D, -874, -244},
-      {0x823C12795DB6CE57, -847, -236},
-      {0xC21094364DFB5637, -821, -228},
-      {0x9096EA6F3848984F, -794, -220},
-      {0xD77485CB25823AC7, -768, -212},
-      {0xA086CFCD97BF97F4, -741, -204},
-      {0xEF340A98172AACE5, -715, -196},
-      {0xB23867FB2A35B28E, -688, -188},
-      {0x84C8D4DFD2C63F3B, -661, -180},
-      {0xC5DD44271AD3CDBA, -635, -172},
-      {0x936B9FCEBB25C996, -608, -164},
-      {0xDBAC6C247D62A584, -582, -156},
-      {0xA3AB66580D5FDAF6, -555, -148},
-      {0xF3E2F893DEC3F126, -529, -140},
-      {0xB5B5ADA8AAFF80B8, -502, -132},
-      {0x87625F056C7C4A8B, -475, -124},
-      {0xC9BCFF6034C13053, -449, -116},
-      {0x964E858C91BA2655, -422, -108},
-      {0xDFF9772470297EBD, -396, -100},
-      {0xA6DFBD9FB8E5B88F, -369, -92},
-      {0xF8A95FCF88747D94, -343, -84},
-      {0xB94470938FA89BCF, -316, -76},
-      {0x8A08F0F8BF0F156B, -289, -68},
-      {0xCDB02555653131B6, -263, -60},
-      {0x993FE2C6D07B7FAC, -236, -52},
-      {0xE45C10C42A2B3B06, -210, -44},
-      {0xAA242499697392D3, -183, -36},
-      {0xFD87B5F28300CA0E, -157, -28},
-      {0xBCE5086492111AEB, -130, -20},
-      {0x8CBCCC096F5088CC, -103, -12},
-      {0xD1B71758E219652C, -77, -4},
-      {0x9C40000000000000, -50, 4},
-      {0xE8D4A51000000000, -24, 12},
-      {0xAD78EBC5AC620000, 3, 20},
-      {0x813F3978F8940984, 30, 28},
-      {0xC097CE7BC90715B3, 56, 36},
-      {0x8F7E32CE7BEA5C70, 83, 44},
-      {0xD5D238A4ABE98068, 109, 52},
-      {0x9F4F2726179A2245, 136, 60},
-      {0xED63A231D4C4FB27, 162, 68},
-      {0xB0DE65388CC8ADA8, 189, 76},
-      {0x83C7088E1AAB65DB, 216, 84},
-      {0xC45D1DF942711D9A, 242, 92},
-      {0x924D692CA61BE758, 269, 100},
-      {0xDA01EE641A708DEA, 295, 108},
-      {0xA26DA3999AEF774A, 322, 116},
-      {0xF209787BB47D6B85, 348, 124},
-      {0xB454E4A179DD1877, 375, 132},
-      {0x865B86925B9BC5C2, 402, 140},
-      {0xC83553C5C8965D3D, 428, 148},
-      {0x952AB45CFA97A0B3, 455, 156},
-      {0xDE469FBD99A05FE3, 481, 164},
-      {0xA59BC234DB398C25, 508, 172},
-      {0xF6C69A72A3989F5C, 534, 180},
-      {0xB7DCBF5354E9BECE, 561, 188},
-      {0x88FCF317F22241E2, 588, 196},
-      {0xCC20CE9BD35C78A5, 614, 204},
-      {0x98165AF37B2153DF, 641, 212},
-      {0xE2A0B5DC971F303A, 667, 220},
-      {0xA8D9D1535CE3B396, 694, 228},
-      {0xFB9B7CD9A4A7443C, 720, 236},
-      {0xBB764C4CA7A44410, 747, 244},
-      {0x8BAB8EEFB6409C1A, 774, 252},
-      {0xD01FEF10A657842C, 800, 260},
-      {0x9B10A4E5E9913129, 827, 268},
-      {0xE7109BFBA19C0C9D, 853, 276},
-      {0xAC2820D9623BF429, 880, 284},
-      {0x80444B5E7AA7CF85, 907, 292},
-      {0xBF21E44003ACDD2D, 933, 300},
-      {0x8E679C2F5E44FF8F, 960, 308},
-      {0xD433179D9C8CB841, 986, 316},
-      {0x9E19DB92B4E31BA9, 1013, 324},
-    };
-
-  // This computation gives exactly the same results for k as
-  //      k = ceil((kAlpha - e - 1) * 0.30102999566398114)
-  // for |e| <= 1500, but doesn't require floating-point operations.
-  // NB: log_10(2) ~= 78913 / 2^18
-  assert(e >= -1500);
-  assert(e <= 1500);
-  const int f = kAlpha - e - 1;
-  const int k = (f * 78913) / (1 << 18) + (f > 0);
-
-  const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
-  assert(index >= 0);
-  assert(index < kCachedPowersSize);
-  static_cast<void>(kCachedPowersSize); // Fix warning.
-
-  const cached_power cached = kCachedPowers[index];
-  assert(kAlpha <= cached.e + e + 64);
-  assert(kGamma >= cached.e + e + 64);
-
-  return cached;
-}
-
-/*!
-For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
-For n == 0, returns 1 and sets pow10 := 1.
-*/
-inline int find_largest_pow10(const uint32_t n, uint32_t& pow10)
-{
-  // LCOV_EXCL_START
-  if (n >= 1000000000) {
-    pow10 = 1000000000;
-    return 10;
-  }
-  // LCOV_EXCL_STOP
-  else if (n >= 100000000) {
-    pow10 = 100000000;
-    return 9;
-  } else if (n >= 10000000) {
-    pow10 = 10000000;
-    return 8;
-  } else if (n >= 1000000) {
-    pow10 = 1000000;
-    return 7;
-  } else if (n >= 100000) {
-    pow10 = 100000;
-    return 6;
-  } else if (n >= 10000) {
-    pow10 = 10000;
-    return 5;
-  } else if (n >= 1000) {
-    pow10 = 1000;
-    return 4;
-  } else if (n >= 100) {
-    pow10 = 100;
-    return 3;
-  } else if (n >= 10) {
-    pow10 = 10;
-    return 2;
-  } else {
-    pow10 = 1;
-    return 1;
-  }
-}
-
-inline void grisu2_round(char* buf, int len, uint64_t dist, uint64_t delta,
-                         uint64_t rest, uint64_t ten_k)
-{
-  assert(len >= 1);
-  assert(dist <= delta);
-  assert(rest <= delta);
-  assert(ten_k > 0);
-
-  //               <--------------------------- delta ---->
-  //                                  <---- dist --------->
-  // --------------[------------------+-------------------]--------------
-  //               M-                 w                   M+
-  //
-  //                                  ten_k
-  //                                <------>
-  //                                       <---- rest ---->
-  // --------------[------------------+----+--------------]--------------
-  //                                  w    V
-  //                                       = buf * 10^k
-  //
-  // ten_k represents a unit-in-the-last-place in the decimal representation
-  // stored in buf.
-  // Decrement buf by ten_k while this takes buf closer to w.
-
-  // The tests are written in this order to avoid overflow in unsigned
-  // integer arithmetic.
-
-  while (rest < dist and delta - rest >= ten_k and (rest + ten_k < dist or dist - rest > rest + ten_k - dist)) {
-    assert(buf[len - 1] != '0');
-    buf[len - 1]--;
-    rest += ten_k;
-  }
-}
-
-/*!
-Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
-M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
-*/
-inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
-                             diyfp M_minus, diyfp w, diyfp M_plus)
-{
-  static_assert(kAlpha >= -60, "internal error");
-  static_assert(kGamma <= -32, "internal error");
-
-  // Generates the digits (and the exponent) of a decimal floating-point
-  // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
-  // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
-  //
-  //               <--------------------------- delta ---->
-  //                                  <---- dist --------->
-  // --------------[------------------+-------------------]--------------
-  //               M-                 w                   M+
-  //
-  // Grisu2 generates the digits of M+ from left to right and stops as soon as
-  // V is in [M-,M+].
-
-  assert(M_plus.e >= kAlpha);
-  assert(M_plus.e <= kGamma);
-
-  uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
-  uint64_t dist = diyfp::sub(M_plus, w).f;        // (significand of (M+ - w ), implicit exponent is e)
-
-  // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
-  //
-  //      M+ = f * 2^e
-  //         = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
-  //         = ((p1        ) * 2^-e + (p2        )) * 2^e
-  //         = p1 + p2 * 2^e
-
-  const diyfp one(uint64_t{1} << -M_plus.e, M_plus.e);
-
-  uint32_t p1 = static_cast<uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
-  uint64_t p2 = M_plus.f & (one.f - 1);                    // p2 = f mod 2^-e
-
-  // 1)
-  //
-  // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
-
-  assert(p1 > 0);
-
-  uint32_t pow10;
-  const int k = find_largest_pow10(p1, pow10);
-
-  //      10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
-  //
-  //      p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
-  //         = (d[k-1]         ) * 10^(k-1) + (p1 mod 10^(k-1))
-  //
-  //      M+ = p1                                             + p2 * 2^e
-  //         = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1))          + p2 * 2^e
-  //         = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
-  //         = d[k-1] * 10^(k-1) + (                         rest) * 2^e
-  //
-  // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
-  //
-  //      p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
-  //
-  // but stop as soon as
-  //
-  //      rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
-
-  int n = k;
-  while (n > 0) {
-    // Invariants:
-    //      M+ = buffer * 10^n + (p1 + p2 * 2^e)    (buffer = 0 for n = k)
-    //      pow10 = 10^(n-1) <= p1 < 10^n
-    //
-    const uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
-    const uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
-    //
-    //      M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
-    //         = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
-    //
-    assert(d <= 9);
-    buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
-    //
-    //      M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
-    //
-    p1 = r;
-    n--;
-    //
-    //      M+ = buffer * 10^n + (p1 + p2 * 2^e)
-    //      pow10 = 10^n
-    //
-
-    // Now check if enough digits have been generated.
-    // Compute
-    //
-    //      p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
-    //
-    // Note:
-    // Since rest and delta share the same exponent e, it suffices to
-    // compare the significands.
-    const uint64_t rest = (uint64_t{p1} << -one.e) + p2;
-    if (rest <= delta) {
-      // V = buffer * 10^n, with M- <= V <= M+.
-
-      decimal_exponent += n;
-
-      // We may now just stop. But instead look if the buffer could be
-      // decremented to bring V closer to w.
-      //
-      // pow10 = 10^n is now 1 ulp in the decimal representation V.
-      // The rounding procedure works with diyfp's with an implicit
-      // exponent of e.
-      //
-      //      10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
-      //
-      const uint64_t ten_n = uint64_t{pow10} << -one.e;
-      grisu2_round(buffer, length, dist, delta, rest, ten_n);
-
-      return;
-    }
-
-    pow10 /= 10;
-    //
-    //      pow10 = 10^(n-1) <= p1 < 10^n
-    // Invariants restored.
-  }
-
-  // 2)
-  //
-  // The digits of the integral part have been generated:
-  //
-  //      M+ = d[k-1]...d[1]d[0] + p2 * 2^e
-  //         = buffer            + p2 * 2^e
-  //
-  // Now generate the digits of the fractional part p2 * 2^e.
-  //
-  // Note:
-  // No decimal point is generated: the exponent is adjusted instead.
-  //
-  // p2 actually represents the fraction
-  //
-  //      p2 * 2^e
-  //          = p2 / 2^-e
-  //          = d[-1] / 10^1 + d[-2] / 10^2 + ...
-  //
-  // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
-  //
-  //      p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
-  //                      + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
-  //
-  // using
-  //
-  //      10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
-  //                = (                   d) * 2^-e + (                   r)
-  //
-  // or
-  //      10^m * p2 * 2^e = d + r * 2^e
-  //
-  // i.e.
-  //
-  //      M+ = buffer + p2 * 2^e
-  //         = buffer + 10^-m * (d + r * 2^e)
-  //         = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
-  //
-  // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
-
-  assert(p2 > delta);
-
-  int m = 0;
-  for (;;) {
-    // Invariant:
-    //      M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
-    //         = buffer * 10^-m + 10^-m * (p2                                 ) * 2^e
-    //         = buffer * 10^-m + 10^-m * (1/10 * (10 * p2)                   ) * 2^e
-    //         = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
-    //
-    assert(p2 <= UINT64_MAX / 10);
-    p2 *= 10;
-    const uint64_t d = p2 >> -one.e;     // d = (10 * p2) div 2^-e
-    const uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
-    //
-    //      M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
-    //         = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
-    //         = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
-    //
-    assert(d <= 9);
-    buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
-    //
-    //      M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
-    //
-    p2 = r;
-    m++;
-    //
-    //      M+ = buffer * 10^-m + 10^-m * p2 * 2^e
-    // Invariant restored.
-
-    // Check if enough digits have been generated.
-    //
-    //      10^-m * p2 * 2^e <= delta * 2^e
-    //              p2 * 2^e <= 10^m * delta * 2^e
-    //                    p2 <= 10^m * delta
-    delta *= 10;
-    dist *= 10;
-    if (p2 <= delta) {
-      break;
-    }
-  }
-
-  // V = buffer * 10^-m, with M- <= V <= M+.
-
-  decimal_exponent -= m;
-
-  // 1 ulp in the decimal representation is now 10^-m.
-  // Since delta and dist are now scaled by 10^m, we need to do the
-  // same with ulp in order to keep the units in sync.
-  //
-  //      10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
-  //
-  const uint64_t ten_m = one.f;
-  grisu2_round(buffer, length, dist, delta, p2, ten_m);
-
-  // By construction this algorithm generates the shortest possible decimal
-  // number (Loitsch, Theorem 6.2) which rounds back to w.
-  // For an input number of precision p, at least
-  //
-  //      N = 1 + ceil(p * log_10(2))
-  //
-  // decimal digits are sufficient to identify all binary floating-point
-  // numbers (Matula, "In-and-Out conversions").
-  // This implies that the algorithm does not produce more than N decimal
-  // digits.
-  //
-  //      N = 17 for p = 53 (IEEE double precision)
-  //      N = 9  for p = 24 (IEEE single precision)
-}
-
-/*!
-v = buf * 10^decimal_exponent
-len is the length of the buffer (number of decimal digits)
-The buffer must be large enough, i.e. >= max_digits10.
-*/
-inline void grisu2(char* buf, int& len, int& decimal_exponent,
-                   diyfp m_minus, diyfp v, diyfp m_plus)
-{
-  assert(m_plus.e == m_minus.e);
-  assert(m_plus.e == v.e);
-
-  //  --------(-----------------------+-----------------------)--------    (A)
-  //          m-                      v                       m+
-  //
-  //  --------------------(-----------+-----------------------)--------    (B)
-  //                      m-          v                       m+
-  //
-  // First scale v (and m- and m+) such that the exponent is in the range
-  // [alpha, gamma].
-
-  const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
-
-  const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
-
-  // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
-  const diyfp w = diyfp::mul(v, c_minus_k);
-  const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
-  const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
-
-  //  ----(---+---)---------------(---+---)---------------(---+---)----
-  //          w-                      w                       w+
-  //          = c*m-                  = c*v                   = c*m+
-  //
-  // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
-  // w+ are now off by a small amount.
-  // In fact:
-  //
-  //      w - v * 10^k < 1 ulp
-  //
-  // To account for this inaccuracy, add resp. subtract 1 ulp.
-  //
-  //  --------+---[---------------(---+---)---------------]---+--------
-  //          w-  M-                  w                   M+  w+
-  //
-  // Now any number in [M-, M+] (bounds included) will round to w when input,
-  // regardless of how the input rounding algorithm breaks ties.
-  //
-  // And digit_gen generates the shortest possible such number in [M-, M+].
-  // Note that this does not mean that Grisu2 always generates the shortest
-  // possible number in the interval (m-, m+).
-  const diyfp M_minus(w_minus.f + 1, w_minus.e);
-  const diyfp M_plus(w_plus.f - 1, w_plus.e);
-
-  decimal_exponent = -cached.k; // = -(-k) = k
-
-  grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
-}
-
-/*!
-v = buf * 10^decimal_exponent
-len is the length of the buffer (number of decimal digits)
-The buffer must be large enough, i.e. >= max_digits10.
-*/
-template <typename FloatType>
-void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
-{
-  static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
-                "internal error: not enough precision");
-
-  assert(std::isfinite(value));
-  assert(value > 0);
-
-// If the neighbors (and boundaries) of 'value' are always computed for double-precision
-// numbers, all float's can be recovered using strtod (and strtof). However, the resulting
-// decimal representations are not exactly "short".
-//
-// The documentation for 'std::to_chars' (http://en.cppreference.com/w/cpp/utility/to_chars)
-// says "value is converted to a string as if by std::sprintf in the default ("C") locale"
-// and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
-// does.
-// On the other hand, the documentation for 'std::to_chars' requires that "parsing the
-// representation using the corresponding std::from_chars function recovers value exactly". That
-// indicates that single precision floating-point numbers should be recovered using
-// 'std::strtof'.
-//
-// NB: If the neighbors are computed for single-precision numbers, there is a single float
-//     (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
-//     value is off by 1 ulp.
-#if 0
-    const boundaries w = compute_boundaries(static_cast<double>(value));
-#else
-  const boundaries w = compute_boundaries(value);
-#endif
-
-  grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
-}
-
-/*!
-@brief appends a decimal representation of e to buf
-@return a pointer to the element following the exponent.
-@pre -1000 < e < 1000
-*/
-inline char* append_exponent(char* buf, int e)
-{
-  assert(e > -1000);
-  assert(e < 1000);
-
-  if (e < 0) {
-    e = -e;
-    *buf++ = '-';
-  } else {
-    *buf++ = '+';
-  }
-
-  uint32_t k = static_cast<uint32_t>(e);
-  if (k < 10) {
-    // Always print at least two digits in the exponent.
-    // This is for compatibility with printf("%g").
-    *buf++ = '0';
-    *buf++ = static_cast<char>('0' + k);
-  } else if (k < 100) {
-    *buf++ = static_cast<char>('0' + k / 10);
-    k %= 10;
-    *buf++ = static_cast<char>('0' + k);
-  } else {
-    *buf++ = static_cast<char>('0' + k / 100);
-    k %= 100;
-    *buf++ = static_cast<char>('0' + k / 10);
-    k %= 10;
-    *buf++ = static_cast<char>('0' + k);
-  }
-
-  return buf;
-}
-
-/*!
-@brief prettify v = buf * 10^decimal_exponent
-
-If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
-notation. Otherwise it will be printed in exponential notation.
-
-@pre min_exp < 0
-@pre max_exp > 0
-*/
-inline char* format_buffer(char* buf, int len, int decimal_exponent,
-                           int min_exp, int max_exp)
-{
-  assert(min_exp < 0);
-  assert(max_exp > 0);
-
-  const int k = len;
-  const int n = len + decimal_exponent;
-
-  // v = buf * 10^(n-k)
-  // k is the length of the buffer (number of decimal digits)
-  // n is the position of the decimal point relative to the start of the buffer.
-
-  if (k <= n and n <= max_exp) {
-    // digits[000]
-    // len <= max_exp + 2
-
-    std::memset(buf + k, '0', static_cast<size_t>(n - k));
-    // Make it look like a floating-point number (#362, #378)
-    buf[n + 0] = '.';
-    buf[n + 1] = '0';
-    return buf + (n + 2);
-  }
-
-  if (0 < n and n <= max_exp) {
-    // dig.its
-    // len <= max_digits10 + 1
-
-    assert(k > n);
-
-    std::memmove(buf + (n + 1), buf + n, static_cast<size_t>(k - n));
-    buf[n] = '.';
-    return buf + (k + 1);
-  }
-
-  if (min_exp < n and n <= 0) {
-    // 0.[000]digits
-    // len <= 2 + (-min_exp - 1) + max_digits10
-
-    std::memmove(buf + (2 + -n), buf, static_cast<size_t>(k));
-    buf[0] = '0';
-    buf[1] = '.';
-    std::memset(buf + 2, '0', static_cast<size_t>(-n));
-    return buf + (2 + (-n) + k);
-  }
-
-  if (k == 1) {
-    // dE+123
-    // len <= 1 + 5
-
-    buf += 1;
-  } else {
-    // d.igitsE+123
-    // len <= max_digits10 + 1 + 5
-
-    std::memmove(buf + 2, buf + 1, static_cast<size_t>(k - 1));
-    buf[1] = '.';
-    buf += 1 + k;
-  }
-
-  *buf++ = 'e';
-  return append_exponent(buf, n - 1);
-}
-
-} // namespace dtoa_impl
-
-/*!
-@brief generates a decimal representation of the floating-point number value in [first, last).
-
-The format of the resulting decimal representation is similar to printf's %g
-format. Returns an iterator pointing past-the-end of the decimal representation.
-
-@note The input number must be finite, i.e. NaN's and Inf's are not supported.
-@note The buffer must be large enough.
-@note The result is NOT null-terminated.
-*/
-template <typename FloatType>
-char* to_chars(char* first, char* last, FloatType value)
-{
-  static_cast<void>(last); // maybe unused - fix warning
-  assert(std::isfinite(value));
-
-  // Use signbit(value) instead of (value < 0) since signbit works for -0.
-  if (std::signbit(value)) {
-    value = -value;
-    *first++ = '-';
-  }
-
-  if (value == 0) // +-0
-  {
-    *first++ = '0';
-    // Make it look like a floating-point number (#362, #378)
-    *first++ = '.';
-    *first++ = '0';
-    return first;
-  }
-
-  assert(last - first >= std::numeric_limits<FloatType>::max_digits10);
-
-  // Compute v = buffer * 10^decimal_exponent.
-  // The decimal digits are stored in the buffer, which needs to be interpreted
-  // as an unsigned decimal integer.
-  // len is the length of the buffer, i.e. the number of decimal digits.
-  int len = 0;
-  int decimal_exponent = 0;
-  dtoa_impl::grisu2(first, len, decimal_exponent, value);
-
-  assert(len <= std::numeric_limits<FloatType>::max_digits10);
-
-  // Format the buffer like printf("%.*g", prec, value)
-  constexpr int kMinExp = -4;
-  // Use digits10 here to increase compatibility with version 2.
-  constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
-
-  assert(last - first >= kMaxExp + 2);
-  assert(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
-  assert(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
-
-  return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
-}
-
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/meta.hpp>
-
-// #include <nlohmann/detail/output/output_adapters.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-namespace nlohmann
-{
-namespace detail
-{
-///////////////////
-// serialization //
-///////////////////
-
-template <typename BasicJsonType>
-class serializer
-{
-  using string_t = typename BasicJsonType::string_t;
-  using number_float_t = typename BasicJsonType::number_float_t;
-  using number_integer_t = typename BasicJsonType::number_integer_t;
-  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-  static constexpr uint8_t UTF8_ACCEPT = 0;
-  static constexpr uint8_t UTF8_REJECT = 1;
-
- public:
-  /*!
-    @param[in] s  output stream to serialize to
-    @param[in] ichar  indentation character to use
-    */
-  serializer(output_adapter_t<char> s, const char ichar)
-    : o(std::move(s)), loc(std::localeconv()), thousands_sep(loc->thousands_sep == nullptr ? '\0' : *(loc->thousands_sep)), decimal_point(loc->decimal_point == nullptr ? '\0' : *(loc->decimal_point)), indent_char(ichar), indent_string(512, indent_char)
-  {
-  }
-
-  // delete because of pointer members
-  serializer(const serializer&) = delete;
-  serializer& operator=(const serializer&) = delete;
-
-  /*!
-    @brief internal implementation of the serialization function
-
-    This function is called by the public member function dump and organizes
-    the serialization internally. The indentation level is propagated as
-    additional parameter. In case of arrays and objects, the function is
-    called recursively.
-
-    - strings and object keys are escaped using `escape_string()`
-    - integer numbers are converted implicitly via `operator<<`
-    - floating-point numbers are converted to a string using `"%g"` format
-
-    @param[in] val             value to serialize
-    @param[in] pretty_print    whether the output shall be pretty-printed
-    @param[in] indent_step     the indent level
-    @param[in] current_indent  the current indent level (only used internally)
-    */
-  void dump(const BasicJsonType& val, const bool pretty_print,
-            const bool ensure_ascii,
-            const unsigned int indent_step,
-            const unsigned int current_indent = 0)
-  {
-    switch (val.m_type) {
-      case value_t::object: {
-        if (val.m_value.object->empty()) {
-          o->write_characters("{}", 2);
-          return;
-        }
-
-        if (pretty_print) {
-          o->write_characters("{\n", 2);
-
-          // variable to hold indentation for recursive calls
-          const auto new_indent = current_indent + indent_step;
-          if (JSON_UNLIKELY(indent_string.size() < new_indent)) {
-            indent_string.resize(indent_string.size() * 2, ' ');
-          }
-
-          // first n-1 elements
-          auto i = val.m_value.object->cbegin();
-          for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i) {
-            o->write_characters(indent_string.c_str(), new_indent);
-            o->write_character('\"');
-            dump_escaped(i->first, ensure_ascii);
-            o->write_characters(R"(": )", 3);
-            dump(i->second, true, ensure_ascii, indent_step, new_indent);
-            o->write_characters(",\n", 2);
-          }
-
-          // last element
-          assert(i != val.m_value.object->cend());
-          assert(std::next(i) == val.m_value.object->cend());
-          o->write_characters(indent_string.c_str(), new_indent);
-          o->write_character('\"');
-          dump_escaped(i->first, ensure_ascii);
-          o->write_characters(R"(": )", 3);
-          dump(i->second, true, ensure_ascii, indent_step, new_indent);
-
-          o->write_character('\n');
-          o->write_characters(indent_string.c_str(), current_indent);
-          o->write_character('}');
-        } else {
-          o->write_character('{');
-
-          // first n-1 elements
-          auto i = val.m_value.object->cbegin();
-          for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i) {
-            o->write_character('\"');
-            dump_escaped(i->first, ensure_ascii);
-            o->write_characters(R"(":)", 2);
-            dump(i->second, false, ensure_ascii, indent_step, current_indent);
-            o->write_character(',');
-          }
-
-          // last element
-          assert(i != val.m_value.object->cend());
-          assert(std::next(i) == val.m_value.object->cend());
-          o->write_character('\"');
-          dump_escaped(i->first, ensure_ascii);
-          o->write_characters(R"(":)", 2);
-          dump(i->second, false, ensure_ascii, indent_step, current_indent);
-
-          o->write_character('}');
-        }
-
-        return;
-      }
-
-      case value_t::array: {
-        if (val.m_value.array->empty()) {
-          o->write_characters("[]", 2);
-          return;
-        }
-
-        if (pretty_print) {
-          o->write_characters("[\n", 2);
-
-          // variable to hold indentation for recursive calls
-          const auto new_indent = current_indent + indent_step;
-          if (JSON_UNLIKELY(indent_string.size() < new_indent)) {
-            indent_string.resize(indent_string.size() * 2, ' ');
-          }
-
-          // first n-1 elements
-          for (auto i = val.m_value.array->cbegin();
-               i != val.m_value.array->cend() - 1; ++i) {
-            o->write_characters(indent_string.c_str(), new_indent);
-            dump(*i, true, ensure_ascii, indent_step, new_indent);
-            o->write_characters(",\n", 2);
-          }
-
-          // last element
-          assert(not val.m_value.array->empty());
-          o->write_characters(indent_string.c_str(), new_indent);
-          dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
-
-          o->write_character('\n');
-          o->write_characters(indent_string.c_str(), current_indent);
-          o->write_character(']');
-        } else {
-          o->write_character('[');
-
-          // first n-1 elements
-          for (auto i = val.m_value.array->cbegin();
-               i != val.m_value.array->cend() - 1; ++i) {
-            dump(*i, false, ensure_ascii, indent_step, current_indent);
-            o->write_character(',');
-          }
-
-          // last element
-          assert(not val.m_value.array->empty());
-          dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
-
-          o->write_character(']');
-        }
-
-        return;
-      }
-
-      case value_t::string: {
-        o->write_character('\"');
-        dump_escaped(*val.m_value.string, ensure_ascii);
-        o->write_character('\"');
-        return;
-      }
-
-      case value_t::boolean: {
-        if (val.m_value.boolean) {
-          o->write_characters("true", 4);
-        } else {
-          o->write_characters("false", 5);
-        }
-        return;
-      }
-
-      case value_t::number_integer: {
-        dump_integer(val.m_value.number_integer);
-        return;
-      }
-
-      case value_t::number_unsigned: {
-        dump_integer(val.m_value.number_unsigned);
-        return;
-      }
-
-      case value_t::number_float: {
-        dump_float(val.m_value.number_float);
-        return;
-      }
-
-      case value_t::discarded: {
-        o->write_characters("<discarded>", 11);
-        return;
-      }
-
-      case value_t::null: {
-        o->write_characters("null", 4);
-        return;
-      }
-    }
-  }
-
- private:
-  /*!
-    @brief dump escaped string
-
-    Escape a string by replacing certain special characters by a sequence of an
-    escape character (backslash) and another character and other control
-    characters by a sequence of "\u" followed by a four-digit hex
-    representation. The escaped string is written to output stream @a o.
-
-    @param[in] s  the string to escape
-    @param[in] ensure_ascii  whether to escape non-ASCII characters with
-                             \uXXXX sequences
-
-    @complexity Linear in the length of string @a s.
-    */
-  void dump_escaped(const string_t& s, const bool ensure_ascii)
-  {
-    uint32_t codepoint;
-    uint8_t state = UTF8_ACCEPT;
-    std::size_t bytes = 0; // number of bytes written to string_buffer
-
-    for (std::size_t i = 0; i < s.size(); ++i) {
-      const auto byte = static_cast<uint8_t>(s[i]);
-
-      switch (decode(state, codepoint, byte)) {
-        case UTF8_ACCEPT: // decode found a new code point
-        {
-          switch (codepoint) {
-            case 0x08: // backspace
-            {
-              string_buffer[bytes++] = '\\';
-              string_buffer[bytes++] = 'b';
-              break;
-            }
-
-            case 0x09: // horizontal tab
-            {
-              string_buffer[bytes++] = '\\';
-              string_buffer[bytes++] = 't';
-              break;
-            }
-
-            case 0x0A: // newline
-            {
-              string_buffer[bytes++] = '\\';
-              string_buffer[bytes++] = 'n';
-              break;
-            }
-
-            case 0x0C: // formfeed
-            {
-              string_buffer[bytes++] = '\\';
-              string_buffer[bytes++] = 'f';
-              break;
-            }
-
-            case 0x0D: // carriage return
-            {
-              string_buffer[bytes++] = '\\';
-              string_buffer[bytes++] = 'r';
-              break;
-            }
-
-            case 0x22: // quotation mark
-            {
-              string_buffer[bytes++] = '\\';
-              string_buffer[bytes++] = '\"';
-              break;
-            }
-
-            case 0x5C: // reverse solidus
-            {
-              string_buffer[bytes++] = '\\';
-              string_buffer[bytes++] = '\\';
-              break;
-            }
-
-            default: {
-              // escape control characters (0x00..0x1F) or, if
-              // ensure_ascii parameter is used, non-ASCII characters
-              if ((codepoint <= 0x1F) or (ensure_ascii and (codepoint >= 0x7F))) {
-                if (codepoint <= 0xFFFF) {
-                  std::snprintf(string_buffer.data() + bytes, 7, R"(\u%04x)",
-                                static_cast<uint16_t>(codepoint));
-                  bytes += 6;
-                } else {
-                  std::snprintf(string_buffer.data() + bytes, 13, R"(\u%04x\u%04x)",
-                                static_cast<uint16_t>(0xD7C0 + (codepoint >> 10)),
-                                static_cast<uint16_t>(0xDC00 + (codepoint & 0x3FF)));
-                  bytes += 12;
-                }
-              } else {
-                // copy byte to buffer (all previous bytes
-                // been copied have in default case above)
-                string_buffer[bytes++] = s[i];
-              }
-              break;
-            }
-          }
-
-          // write buffer and reset index; there must be 13 bytes
-          // left, as this is the maximal number of bytes to be
-          // written ("\uxxxx\uxxxx\0") for one code point
-          if (string_buffer.size() - bytes < 13) {
-            o->write_characters(string_buffer.data(), bytes);
-            bytes = 0;
-          }
-          break;
-        }
-
-        case UTF8_REJECT: // decode found invalid UTF-8 byte
-        {
-          std::stringstream ss;
-          ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << static_cast<int>(byte);
-          JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + ss.str()));
-        }
-
-        default: // decode found yet incomplete multi-byte code point
-        {
-          if (not ensure_ascii) {
-            // code point will not be escaped - copy byte to buffer
-            string_buffer[bytes++] = s[i];
-          }
-          break;
-        }
-      }
-    }
-
-    if (JSON_LIKELY(state == UTF8_ACCEPT)) {
-      // write buffer
-      if (bytes > 0) {
-        o->write_characters(string_buffer.data(), bytes);
-      }
-    } else {
-      // we finish reading, but do not accept: string was incomplete
-      std::stringstream ss;
-      ss << std::setw(2) << std::uppercase << std::setfill('0') << std::hex << static_cast<int>(static_cast<uint8_t>(s.back()));
-      JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + ss.str()));
-    }
-  }
-
-  /*!
-    @brief dump an integer
-
-    Dump a given integer to output stream @a o. Works internally with
-    @a number_buffer.
-
-    @param[in] x  integer number (signed or unsigned) to dump
-    @tparam NumberType either @a number_integer_t or @a number_unsigned_t
-    */
-  template <typename NumberType, detail::enable_if_t<
-                                   std::is_same<NumberType, number_unsigned_t>::value or
-                                     std::is_same<NumberType, number_integer_t>::value,
-                                   int> = 0>
-  void dump_integer(NumberType x)
-  {
-    // special case for "0"
-    if (x == 0) {
-      o->write_character('0');
-      return;
-    }
-
-    const bool is_negative = (x <= 0) and (x != 0); // see issue #755
-    std::size_t i = 0;
-
-    while (x != 0) {
-      // spare 1 byte for '\0'
-      assert(i < number_buffer.size() - 1);
-
-      const auto digit = std::labs(static_cast<long>(x % 10));
-      number_buffer[i++] = static_cast<char>('0' + digit);
-      x /= 10;
-    }
-
-    if (is_negative) {
-      // make sure there is capacity for the '-'
-      assert(i < number_buffer.size() - 2);
-      number_buffer[i++] = '-';
-    }
-
-    std::reverse(number_buffer.begin(), number_buffer.begin() + i);
-    o->write_characters(number_buffer.data(), i);
-  }
-
-  /*!
-    @brief dump a floating-point number
-
-    Dump a given floating-point number to output stream @a o. Works internally
-    with @a number_buffer.
-
-    @param[in] x  floating-point number to dump
-    */
-  void dump_float(number_float_t x)
-  {
-    // NaN / inf
-    if (not std::isfinite(x)) {
-      o->write_characters("null", 4);
-      return;
-    }
-
-    // If number_float_t is an IEEE-754 single or double precision number,
-    // use the Grisu2 algorithm to produce short numbers which are
-    // guaranteed to round-trip, using strtof and strtod, resp.
-    //
-    // NB: The test below works if <long double> == <double>.
-    static constexpr bool is_ieee_single_or_double = (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 24 and std::numeric_limits<number_float_t>::max_exponent == 128) or
-                                                     (std::numeric_limits<number_float_t>::is_iec559 and std::numeric_limits<number_float_t>::digits == 53 and std::numeric_limits<number_float_t>::max_exponent == 1024);
-
-    dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
-  }
-
-  void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
-  {
-    char* begin = number_buffer.data();
-    char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
-
-    o->write_characters(begin, static_cast<size_t>(end - begin));
-  }
-
-  void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
-  {
-    // get number of digits for a float -> text -> float round-trip
-    static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
-
-    // the actual conversion
-    std::ptrdiff_t len = snprintf(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
-
-    // negative value indicates an error
-    assert(len > 0);
-    // check if buffer was large enough
-    assert(static_cast<std::size_t>(len) < number_buffer.size());
-
-    // erase thousands separator
-    if (thousands_sep != '\0') {
-      const auto end = std::remove(number_buffer.begin(),
-                                   number_buffer.begin() + len, thousands_sep);
-      std::fill(end, number_buffer.end(), '\0');
-      assert((end - number_buffer.begin()) <= len);
-      len = (end - number_buffer.begin());
-    }
-
-    // convert decimal point to '.'
-    if (decimal_point != '\0' and decimal_point != '.') {
-      const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
-      if (dec_pos != number_buffer.end()) {
-        *dec_pos = '.';
-      }
-    }
-
-    o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
-
-    // determine if need to append ".0"
-    const bool value_is_int_like =
-      std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
-                   [](char c) {
-                     return (c == '.' or c == 'e');
-                   });
-
-    if (value_is_int_like) {
-      o->write_characters(".0", 2);
-    }
-  }
-
-  /*!
-    @brief check whether a string is UTF-8 encoded
-
-    The function checks each byte of a string whether it is UTF-8 encoded. The
-    result of the check is stored in the @a state parameter. The function must
-    be called initially with state 0 (accept). State 1 means the string must
-    be rejected, because the current byte is not allowed. If the string is
-    completely processed, but the state is non-zero, the string ended
-    prematurely; that is, the last byte indicated more bytes should have
-    followed.
-
-    @param[in,out] state  the state of the decoding
-    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
-    @param[in] byte       next byte to decode
-    @return               new state
-
-    @note The function has been edited: a std::array is used.
-
-    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-    */
-  static uint8_t decode(uint8_t& state, uint32_t& codep, const uint8_t byte) noexcept
-  {
-    static const std::array<uint8_t, 400> utf8d =
-      {
-        {
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
-          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
-          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
-          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
-          8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
-          0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3,                 // E0..EF
-          0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8,                 // F0..FF
-          0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1,                 // s0..s0
-          1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
-          1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
-          1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
-          1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1  // s7..s8
-        }};
-
-    const uint8_t type = utf8d[byte];
-
-    codep = (state != UTF8_ACCEPT)
-              ? (byte & 0x3fu) | (codep << 6)
-              : static_cast<uint32_t>(0xff >> type) & (byte);
-
-    state = utf8d[256u + state * 16u + type];
-    return state;
-  }
-
- private:
-  /// the output of the serializer
-  output_adapter_t<char> o = nullptr;
-
-  /// a (hopefully) large enough character buffer
-  std::array<char, 64> number_buffer{{}};
-
-  /// the locale
-  const std::lconv* loc = nullptr;
-  /// the locale's thousand separator character
-  const char thousands_sep = '\0';
-  /// the locale's decimal point character
-  const char decimal_point = '\0';
-
-  /// string buffer
-  std::array<char, 512> string_buffer{{}};
-
-  /// the indentation character
-  const char indent_char;
-  /// the indentation string
-  string_t indent_string;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/json_ref.hpp>
-
-#include <initializer_list>
-#include <utility>
-
-namespace nlohmann
-{
-namespace detail
-{
-template <typename BasicJsonType>
-class json_ref
-{
- public:
-  using value_type = BasicJsonType;
-
-  json_ref(value_type&& value)
-    : owned_value(std::move(value)), value_ref(&owned_value), is_rvalue(true)
-  {
-  }
-
-  json_ref(const value_type& value)
-    : value_ref(const_cast<value_type*>(&value)), is_rvalue(false)
-  {
-  }
-
-  json_ref(std::initializer_list<json_ref> init)
-    : owned_value(init), value_ref(&owned_value), is_rvalue(true)
-  {
-  }
-
-  template <class... Args>
-  json_ref(Args&&... args)
-    : owned_value(std::forward<Args>(args)...), value_ref(&owned_value), is_rvalue(true)
-  {
-  }
-
-  // class should be movable only
-  json_ref(json_ref&&) = default;
-  json_ref(const json_ref&) = delete;
-  json_ref& operator=(const json_ref&) = delete;
-
-  value_type moved_or_copied() const
-  {
-    if (is_rvalue) {
-      return std::move(*value_ref);
-    }
-    return *value_ref;
-  }
-
-  value_type const& operator*() const
-  {
-    return *static_cast<value_type const*>(value_ref);
-  }
-
-  value_type const* operator->() const
-  {
-    return static_cast<value_type const*>(value_ref);
-  }
-
- private:
-  mutable value_type owned_value = nullptr;
-  value_type* value_ref = nullptr;
-  const bool is_rvalue;
-};
-} // namespace detail
-} // namespace nlohmann
-
-// #include <nlohmann/detail/json_pointer.hpp>
-
-#include <cassert> // assert
-#include <numeric> // accumulate
-#include <string>  // string
-#include <vector>  // vector
-
-// #include <nlohmann/detail/macro_scope.hpp>
-
-// #include <nlohmann/detail/exceptions.hpp>
-
-// #include <nlohmann/detail/value_t.hpp>
-
-namespace nlohmann
-{
-template <typename BasicJsonType>
-class json_pointer
-{
-  // allow basic_json to access private members
-  NLOHMANN_BASIC_JSON_TPL_DECLARATION
-  friend class basic_json;
-
- public:
-  /*!
-    @brief create JSON pointer
-
-    Create a JSON pointer according to the syntax described in
-    [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
-
-    @param[in] s  string representing the JSON pointer; if omitted, the empty
-                  string is assumed which references the whole JSON value
-
-    @throw parse_error.107 if the given JSON pointer @a s is nonempty and does
-                           not begin with a slash (`/`); see example below
-
-    @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is
-    not followed by `0` (representing `~`) or `1` (representing `/`); see
-    example below
-
-    @liveexample{The example shows the construction several valid JSON pointers
-    as well as the exceptional behavior.,json_pointer}
-
-    @since version 2.0.0
-    */
-  explicit json_pointer(const std::string& s = "")
-    : reference_tokens(split(s))
-  {
-  }
-
-  /*!
-    @brief return a string representation of the JSON pointer
-
-    @invariant For each JSON pointer `ptr`, it holds:
-    @code {.cpp}
-    ptr == json_pointer(ptr.to_string());
-    @endcode
-
-    @return a string representation of the JSON pointer
-
-    @liveexample{The example shows the result of `to_string`.,
-    json_pointer__to_string}
-
-    @since version 2.0.0
-    */
-  std::string to_string() const noexcept
-  {
-    return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
-                           std::string{},
-                           [](const std::string& a, const std::string& b) {
-                             return a + "/" + escape(b);
-                           });
-  }
-
-  /// @copydoc to_string()
-  operator std::string() const
-  {
-    return to_string();
-  }
-
-  /*!
-    @param[in] s  reference token to be converted into an array index
-
-    @return integer representation of @a s
-
-    @throw out_of_range.404 if string @a s could not be converted to an integer
-    */
-  static int array_index(const std::string& s)
-  {
-    std::size_t processed_chars = 0;
-    const int res = std::stoi(s, &processed_chars);
-
-    // check if the string was completely read
-    if (JSON_UNLIKELY(processed_chars != s.size())) {
-      JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
-    }
-
-    return res;
-  }
-
- private:
-  /*!
-    @brief remove and return last reference pointer
-    @throw out_of_range.405 if JSON pointer has no parent
-    */
-  std::string pop_back()
-  {
-    if (JSON_UNLIKELY(is_root())) {
-      JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
-    }
-
-    auto last = reference_tokens.back();
-    reference_tokens.pop_back();
-    return last;
-  }
-
-  /// return whether pointer points to the root document
-  bool is_root() const
-  {
-    return reference_tokens.empty();
-  }
-
-  json_pointer top() const
-  {
-    if (JSON_UNLIKELY(is_root())) {
-      JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
-    }
-
-    json_pointer result = *this;
-    result.reference_tokens = {reference_tokens[0]};
-    return result;
-  }
-
-  /*!
-    @brief create and return a reference to the pointed to value
-
-    @complexity Linear in the number of reference tokens.
-
-    @throw parse_error.109 if array index is not a number
-    @throw type_error.313 if value cannot be unflattened
-    */
-  BasicJsonType& get_and_create(BasicJsonType& j) const
-  {
-    using size_type = typename BasicJsonType::size_type;
-    auto result = &j;
-
-    // in case no reference tokens exist, return a reference to the JSON value
-    // j which will be overwritten by a primitive value
-    for (const auto& reference_token : reference_tokens) {
-      switch (result->m_type) {
-        case detail::value_t::null: {
-          if (reference_token == "0") {
-            // start a new array if reference token is 0
-            result = &result->operator[](0);
-          } else {
-            // start a new object otherwise
-            result = &result->operator[](reference_token);
-          }
-          break;
-        }
-
-        case detail::value_t::object: {
-          // create an entry in the object
-          result = &result->operator[](reference_token);
-          break;
-        }
-
-        case detail::value_t::array: {
-          // create an entry in the array
-          JSON_TRY
-          {
-            result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
-          }
-          JSON_CATCH(std::invalid_argument&)
-          {
-            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
-          }
-          break;
-        }
-
-        /*
-                The following code is only reached if there exists a reference
-                token _and_ the current value is primitive. In this case, we have
-                an error situation, because primitive values may only occur as
-                single value; that is, with an empty list of reference tokens.
-                */
-        default:
-          JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
-      }
-    }
-
-    return *result;
-  }
-
-  /*!
-    @brief return a reference to the pointed to value
-
-    @note This version does not throw if a value is not present, but tries to
-          create nested values instead. For instance, calling this function
-          with pointer `"/this/that"` on a null value is equivalent to calling
-          `operator[]("this").operator[]("that")` on that value, effectively
-          changing the null value to an object.
-
-    @param[in] ptr  a JSON value
-
-    @return reference to the JSON value pointed to by the JSON pointer
-
-    @complexity Linear in the length of the JSON pointer.
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-    */
-  BasicJsonType& get_unchecked(BasicJsonType* ptr) const
-  {
-    using size_type = typename BasicJsonType::size_type;
-    for (const auto& reference_token : reference_tokens) {
-      // convert null values to arrays or objects before continuing
-      if (ptr->m_type == detail::value_t::null) {
-        // check if reference token is a number
-        const bool nums =
-          std::all_of(reference_token.begin(), reference_token.end(),
-                      [](const char x) {
-                        return (x >= '0' and x <= '9');
-                      });
-
-        // change value to array for numbers or "-" or to object otherwise
-        *ptr = (nums or reference_token == "-")
-                 ? detail::value_t::array
-                 : detail::value_t::object;
-      }
-
-      switch (ptr->m_type) {
-        case detail::value_t::object: {
-          // use unchecked object access
-          ptr = &ptr->operator[](reference_token);
-          break;
-        }
-
-        case detail::value_t::array: {
-          // error condition (cf. RFC 6901, Sect. 4)
-          if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0')) {
-            JSON_THROW(detail::parse_error::create(106, 0,
-                                                   "array index '" + reference_token +
-                                                     "' must not begin with '0'"));
-          }
-
-          if (reference_token == "-") {
-            // explicitly treat "-" as index beyond the end
-            ptr = &ptr->operator[](ptr->m_value.array->size());
-          } else {
-            // convert array index to number; unchecked access
-            JSON_TRY
-            {
-              ptr = &ptr->operator[](
-                static_cast<size_type>(array_index(reference_token)));
-            }
-            JSON_CATCH(std::invalid_argument&)
-            {
-              JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
-            }
-          }
-          break;
-        }
-
-        default:
-          JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
-      }
-    }
-
-    return *ptr;
-  }
-
-  /*!
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.402  if the array index '-' is used
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-    */
-  BasicJsonType& get_checked(BasicJsonType* ptr) const
-  {
-    using size_type = typename BasicJsonType::size_type;
-    for (const auto& reference_token : reference_tokens) {
-      switch (ptr->m_type) {
-        case detail::value_t::object: {
-          // note: at performs range check
-          ptr = &ptr->at(reference_token);
-          break;
-        }
-
-        case detail::value_t::array: {
-          if (JSON_UNLIKELY(reference_token == "-")) {
-            // "-" always fails the range check
-            JSON_THROW(detail::out_of_range::create(402,
-                                                    "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                                      ") is out of range"));
-          }
-
-          // error condition (cf. RFC 6901, Sect. 4)
-          if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0')) {
-            JSON_THROW(detail::parse_error::create(106, 0,
-                                                   "array index '" + reference_token +
-                                                     "' must not begin with '0'"));
-          }
-
-          // note: at performs range check
-          JSON_TRY
-          {
-            ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
-          }
-          JSON_CATCH(std::invalid_argument&)
-          {
-            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
-          }
-          break;
-        }
-
-        default:
-          JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
-      }
-    }
-
-    return *ptr;
-  }
-
-  /*!
-    @brief return a const reference to the pointed to value
-
-    @param[in] ptr  a JSON value
-
-    @return const reference to the JSON value pointed to by the JSON
-    pointer
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.402  if the array index '-' is used
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-    */
-  const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
-  {
-    using size_type = typename BasicJsonType::size_type;
-    for (const auto& reference_token : reference_tokens) {
-      switch (ptr->m_type) {
-        case detail::value_t::object: {
-          // use unchecked object access
-          ptr = &ptr->operator[](reference_token);
-          break;
-        }
-
-        case detail::value_t::array: {
-          if (JSON_UNLIKELY(reference_token == "-")) {
-            // "-" cannot be used for const access
-            JSON_THROW(detail::out_of_range::create(402,
-                                                    "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                                      ") is out of range"));
-          }
-
-          // error condition (cf. RFC 6901, Sect. 4)
-          if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0')) {
-            JSON_THROW(detail::parse_error::create(106, 0,
-                                                   "array index '" + reference_token +
-                                                     "' must not begin with '0'"));
-          }
-
-          // use unchecked array access
-          JSON_TRY
-          {
-            ptr = &ptr->operator[](
-              static_cast<size_type>(array_index(reference_token)));
-          }
-          JSON_CATCH(std::invalid_argument&)
-          {
-            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
-          }
-          break;
-        }
-
-        default:
-          JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
-      }
-    }
-
-    return *ptr;
-  }
-
-  /*!
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.402  if the array index '-' is used
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-    */
-  const BasicJsonType& get_checked(const BasicJsonType* ptr) const
-  {
-    using size_type = typename BasicJsonType::size_type;
-    for (const auto& reference_token : reference_tokens) {
-      switch (ptr->m_type) {
-        case detail::value_t::object: {
-          // note: at performs range check
-          ptr = &ptr->at(reference_token);
-          break;
-        }
-
-        case detail::value_t::array: {
-          if (JSON_UNLIKELY(reference_token == "-")) {
-            // "-" always fails the range check
-            JSON_THROW(detail::out_of_range::create(402,
-                                                    "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
-                                                      ") is out of range"));
-          }
-
-          // error condition (cf. RFC 6901, Sect. 4)
-          if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0')) {
-            JSON_THROW(detail::parse_error::create(106, 0,
-                                                   "array index '" + reference_token +
-                                                     "' must not begin with '0'"));
-          }
-
-          // note: at performs range check
-          JSON_TRY
-          {
-            ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
-          }
-          JSON_CATCH(std::invalid_argument&)
-          {
-            JSON_THROW(detail::parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
-          }
-          break;
-        }
-
-        default:
-          JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
-      }
-    }
-
-    return *ptr;
-  }
-
-  /*!
-    @brief split the string input to reference tokens
-
-    @note This function is only called by the json_pointer constructor.
-          All exceptions below are documented there.
-
-    @throw parse_error.107  if the pointer is not empty or begins with '/'
-    @throw parse_error.108  if character '~' is not followed by '0' or '1'
-    */
-  static std::vector<std::string> split(const std::string& reference_string)
-  {
-    std::vector<std::string> result;
-
-    // special case: empty reference string -> no reference tokens
-    if (reference_string.empty()) {
-      return result;
-    }
-
-    // check if nonempty reference string begins with slash
-    if (JSON_UNLIKELY(reference_string[0] != '/')) {
-      JSON_THROW(detail::parse_error::create(107, 1,
-                                             "JSON pointer must be empty or begin with '/' - was: '" +
-                                               reference_string + "'"));
-    }
-
-    // extract the reference tokens:
-    // - slash: position of the last read slash (or end of string)
-    // - start: position after the previous slash
-    for (
-      // search for the first slash after the first character
-      std::size_t slash = reference_string.find_first_of('/', 1),
-                  // set the beginning of the first reference token
-      start = 1;
-      // we can stop if start == string::npos+1 = 0
-      start != 0;
-      // set the beginning of the next reference token
-      // (will eventually be 0 if slash == std::string::npos)
-      start = slash + 1,
-                  // find next slash
-      slash = reference_string.find_first_of('/', start)) {
-      // use the text between the beginning of the reference token
-      // (start) and the last slash (slash).
-      auto reference_token = reference_string.substr(start, slash - start);
-
-      // check reference tokens are properly escaped
-      for (std::size_t pos = reference_token.find_first_of('~');
-           pos != std::string::npos;
-           pos = reference_token.find_first_of('~', pos + 1)) {
-        assert(reference_token[pos] == '~');
-
-        // ~ must be followed by 0 or 1
-        if (JSON_UNLIKELY(pos == reference_token.size() - 1 or
-                          (reference_token[pos + 1] != '0' and
-                           reference_token[pos + 1] != '1'))) {
-          JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
-        }
-      }
-
-      // finally, store the reference token
-      unescape(reference_token);
-      result.push_back(reference_token);
-    }
-
-    return result;
-  }
-
-  /*!
-    @brief replace all occurrences of a substring by another string
-
-    @param[in,out] s  the string to manipulate; changed so that all
-                   occurrences of @a f are replaced with @a t
-    @param[in]     f  the substring to replace with @a t
-    @param[in]     t  the string to replace @a f
-
-    @pre The search string @a f must not be empty. **This precondition is
-    enforced with an assertion.**
-
-    @since version 2.0.0
-    */
-  static void replace_substring(std::string& s, const std::string& f,
-                                const std::string& t)
-  {
-    assert(not f.empty());
-    for (auto pos = s.find(f);            // find first occurrence of f
-         pos != std::string::npos;        // make sure f was found
-         s.replace(pos, f.size(), t),     // replace with t, and
-         pos = s.find(f, pos + t.size())) // find next occurrence of f
-    {
-    }
-  }
-
-  /// escape "~"" to "~0" and "/" to "~1"
-  static std::string escape(std::string s)
-  {
-    replace_substring(s, "~", "~0");
-    replace_substring(s, "/", "~1");
-    return s;
-  }
-
-  /// unescape "~1" to tilde and "~0" to slash (order is important!)
-  static void unescape(std::string& s)
-  {
-    replace_substring(s, "~1", "/");
-    replace_substring(s, "~0", "~");
-  }
-
-  /*!
-    @param[in] reference_string  the reference string to the current value
-    @param[in] value             the value to consider
-    @param[in,out] result        the result object to insert values to
-
-    @note Empty objects or arrays are flattened to `null`.
-    */
-  static void flatten(const std::string& reference_string,
-                      const BasicJsonType& value,
-                      BasicJsonType& result)
-  {
-    switch (value.m_type) {
-      case detail::value_t::array: {
-        if (value.m_value.array->empty()) {
-          // flatten empty array as null
-          result[reference_string] = nullptr;
-        } else {
-          // iterate array and use index as reference string
-          for (std::size_t i = 0; i < value.m_value.array->size(); ++i) {
-            flatten(reference_string + "/" + std::to_string(i),
-                    value.m_value.array->operator[](i), result);
-          }
-        }
-        break;
-      }
-
-      case detail::value_t::object: {
-        if (value.m_value.object->empty()) {
-          // flatten empty object as null
-          result[reference_string] = nullptr;
-        } else {
-          // iterate object and use keys as reference string
-          for (const auto& element : *value.m_value.object) {
-            flatten(reference_string + "/" + escape(element.first), element.second, result);
-          }
-        }
-        break;
-      }
-
-      default: {
-        // add primitive value with its reference string
-        result[reference_string] = value;
-        break;
-      }
-    }
-  }
-
-  /*!
-    @param[in] value  flattened JSON
-
-    @return unflattened JSON
-
-    @throw parse_error.109 if array index is not a number
-    @throw type_error.314  if value is not an object
-    @throw type_error.315  if object values are not primitive
-    @throw type_error.313  if value cannot be unflattened
-    */
-  static BasicJsonType
-    unflatten(const BasicJsonType& value)
-  {
-    if (JSON_UNLIKELY(not value.is_object())) {
-      JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
-    }
-
-    BasicJsonType result;
-
-    // iterate the JSON object values
-    for (const auto& element : *value.m_value.object) {
-      if (JSON_UNLIKELY(not element.second.is_primitive())) {
-        JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
-      }
-
-      // assign value to reference pointed to by JSON pointer; Note that if
-      // the JSON pointer is "" (i.e., points to the whole value), function
-      // get_and_create returns a reference to result itself. An assignment
-      // will then create a primitive value.
-      json_pointer(element.first).get_and_create(result) = element.second;
-    }
-
-    return result;
-  }
-
-  friend bool operator==(json_pointer const& lhs,
-                         json_pointer const& rhs) noexcept
-  {
-    return (lhs.reference_tokens == rhs.reference_tokens);
-  }
-
-  friend bool operator!=(json_pointer const& lhs,
-                         json_pointer const& rhs) noexcept
-  {
-    return not(lhs == rhs);
-  }
-
-  /// the reference tokens
-  std::vector<std::string> reference_tokens;
-};
-} // namespace nlohmann
-
-// #include <nlohmann/adl_serializer.hpp>
-
-#include <utility>
-
-// #include <nlohmann/detail/conversions/from_json.hpp>
-
-// #include <nlohmann/detail/conversions/to_json.hpp>
-
-namespace nlohmann
-{
-template <typename, typename>
-struct adl_serializer {
-  /*!
-    @brief convert a JSON value to any value type
-
-    This function is usually called by the `get()` function of the
-    @ref basic_json class (either explicit or via conversion operators).
-
-    @param[in] j         JSON value to read from
-    @param[in,out] val  value to write to
-    */
-  template <typename BasicJsonType, typename ValueType>
-  static void from_json(BasicJsonType&& j, ValueType& val) noexcept(
-    noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
-  {
-    ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
-  }
-
-  /*!
-    @brief convert any value type to a JSON value
-
-    This function is usually called by the constructors of the @ref basic_json
-    class.
-
-    @param[in,out] j  JSON value to write to
-    @param[in] val     value to read from
-    */
-  template <typename BasicJsonType, typename ValueType>
-  static void to_json(BasicJsonType& j, ValueType&& val) noexcept(
-    noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
-  {
-    ::nlohmann::to_json(j, std::forward<ValueType>(val));
-  }
-};
-} // namespace nlohmann
-
-/*!
-@brief namespace for Niels Lohmann
-@see https://github.com/nlohmann
-@since version 1.0.0
-*/
-namespace nlohmann
-{
-
-/*!
-@brief a class to store JSON values
-
-@tparam ObjectType type for JSON objects (`std::map` by default; will be used
-in @ref object_t)
-@tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
-in @ref array_t)
-@tparam StringType type for JSON strings and object keys (`std::string` by
-default; will be used in @ref string_t)
-@tparam BooleanType type for JSON booleans (`bool` by default; will be used
-in @ref boolean_t)
-@tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
-default; will be used in @ref number_integer_t)
-@tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
-`uint64_t` by default; will be used in @ref number_unsigned_t)
-@tparam NumberFloatType type for JSON floating-point numbers (`double` by
-default; will be used in @ref number_float_t)
-@tparam AllocatorType type of the allocator to use (`std::allocator` by
-default)
-@tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
-and `from_json()` (@ref adl_serializer by default)
-
-@requirement The class satisfies the following concept requirements:
-- Basic
- - [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible):
-   JSON values can be default constructed. The result will be a JSON null
-   value.
- - [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible):
-   A JSON value can be constructed from an rvalue argument.
- - [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible):
-   A JSON value can be copy-constructed from an lvalue expression.
- - [MoveAssignable](http://en.cppreference.com/w/cpp/concept/MoveAssignable):
-   A JSON value van be assigned from an rvalue argument.
- - [CopyAssignable](http://en.cppreference.com/w/cpp/concept/CopyAssignable):
-   A JSON value can be copy-assigned from an lvalue expression.
- - [Destructible](http://en.cppreference.com/w/cpp/concept/Destructible):
-   JSON values can be destructed.
-- Layout
- - [StandardLayoutType](http://en.cppreference.com/w/cpp/concept/StandardLayoutType):
-   JSON values have
-   [standard layout](http://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
-   All non-static data members are private and standard layout types, the
-   class has no virtual functions or (virtual) base classes.
-- Library-wide
- - [EqualityComparable](http://en.cppreference.com/w/cpp/concept/EqualityComparable):
-   JSON values can be compared with `==`, see @ref
-   operator==(const_reference,const_reference).
- - [LessThanComparable](http://en.cppreference.com/w/cpp/concept/LessThanComparable):
-   JSON values can be compared with `<`, see @ref
-   operator<(const_reference,const_reference).
- - [Swappable](http://en.cppreference.com/w/cpp/concept/Swappable):
-   Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
-   other compatible types, using unqualified function call @ref swap().
- - [NullablePointer](http://en.cppreference.com/w/cpp/concept/NullablePointer):
-   JSON values can be compared against `std::nullptr_t` objects which are used
-   to model the `null` value.
-- Container
- - [Container](http://en.cppreference.com/w/cpp/concept/Container):
-   JSON values can be used like STL containers and provide iterator access.
- - [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer);
-   JSON values can be used like STL containers and provide reverse iterator
-   access.
-
-@invariant The member variables @a m_value and @a m_type have the following
-relationship:
-- If `m_type == value_t::object`, then `m_value.object != nullptr`.
-- If `m_type == value_t::array`, then `m_value.array != nullptr`.
-- If `m_type == value_t::string`, then `m_value.string != nullptr`.
-The invariants are checked by member function assert_invariant().
-
-@internal
-@note ObjectType trick from http://stackoverflow.com/a/9860911
-@endinternal
-
-@see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
-Format](http://rfc7159.net/rfc7159)
-
-@since version 1.0.0
-
-@nosubgrouping
-*/
-NLOHMANN_BASIC_JSON_TPL_DECLARATION
-class basic_json
-{
- private:
-  template <detail::value_t>
-  friend struct detail::external_constructor;
-  friend ::nlohmann::json_pointer<basic_json>;
-  friend ::nlohmann::detail::parser<basic_json>;
-  friend ::nlohmann::detail::serializer<basic_json>;
-  template <typename BasicJsonType>
-  friend class ::nlohmann::detail::iter_impl;
-  template <typename BasicJsonType, typename CharType>
-  friend class ::nlohmann::detail::binary_writer;
-  template <typename BasicJsonType>
-  friend class ::nlohmann::detail::binary_reader;
-
-  /// workaround type for MSVC
-  using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
-
-  // convenience aliases for types residing in namespace detail;
-  using lexer = ::nlohmann::detail::lexer<basic_json>;
-  using parser = ::nlohmann::detail::parser<basic_json>;
-
-  using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
-  template <typename BasicJsonType>
-  using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
-  template <typename BasicJsonType>
-  using iter_impl = ::nlohmann::detail::iter_impl<BasicJsonType>;
-  template <typename Iterator>
-  using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
-  template <typename Base>
-  using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
-
-  template <typename CharType>
-  using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
-
-  using binary_reader = ::nlohmann::detail::binary_reader<basic_json>;
-  template <typename CharType>
-  using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
-
-  using serializer = ::nlohmann::detail::serializer<basic_json>;
-
- public:
-  using value_t = detail::value_t;
-  /// @copydoc nlohmann::json_pointer
-  using json_pointer = ::nlohmann::json_pointer<basic_json>;
-  template <typename T, typename SFINAE>
-  using json_serializer = JSONSerializer<T, SFINAE>;
-  /// helper type for initializer lists of basic_json values
-  using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
-
-  ////////////////
-  // exceptions //
-  ////////////////
-
-  /// @name exceptions
-  /// Classes to implement user-defined exceptions.
-  /// @{
-
-  /// @copydoc detail::exception
-  using exception = detail::exception;
-  /// @copydoc detail::parse_error
-  using parse_error = detail::parse_error;
-  /// @copydoc detail::invalid_iterator
-  using invalid_iterator = detail::invalid_iterator;
-  /// @copydoc detail::type_error
-  using type_error = detail::type_error;
-  /// @copydoc detail::out_of_range
-  using out_of_range = detail::out_of_range;
-  /// @copydoc detail::other_error
-  using other_error = detail::other_error;
-
-  /// @}
-
-  /////////////////////
-  // container types //
-  /////////////////////
-
-  /// @name container types
-  /// The canonic container types to use @ref basic_json like any other STL
-  /// container.
-  /// @{
-
-  /// the type of elements in a basic_json container
-  using value_type = basic_json;
-
-  /// the type of an element reference
-  using reference = value_type&;
-  /// the type of an element const reference
-  using const_reference = const value_type&;
-
-  /// a type to represent differences between iterators
-  using difference_type = std::ptrdiff_t;
-  /// a type to represent container sizes
-  using size_type = std::size_t;
-
-  /// the allocator type
-  using allocator_type = AllocatorType<basic_json>;
-
-  /// the type of an element pointer
-  using pointer = typename std::allocator_traits<allocator_type>::pointer;
-  /// the type of an element const pointer
-  using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
-
-  /// an iterator for a basic_json container
-  using iterator = iter_impl<basic_json>;
-  /// a const iterator for a basic_json container
-  using const_iterator = iter_impl<const basic_json>;
-  /// a reverse iterator for a basic_json container
-  using reverse_iterator = json_reverse_iterator<typename basic_json::iterator>;
-  /// a const reverse iterator for a basic_json container
-  using const_reverse_iterator = json_reverse_iterator<typename basic_json::const_iterator>;
-
-  /// @}
-
-  /*!
-    @brief returns the allocator associated with the container
-    */
-  static allocator_type get_allocator()
-  {
-    return allocator_type();
-  }
-
-  /*!
-    @brief returns version information on the library
-
-    This function returns a JSON object with information about the library,
-    including the version number and information on the platform and compiler.
-
-    @return JSON object holding version information
-    key         | description
-    ----------- | ---------------
-    `compiler`  | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
-    `copyright` | The copyright line for the library as string.
-    `name`      | The name of the library as string.
-    `platform`  | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
-    `url`       | The URL of the project as string.
-    `version`   | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
-
-    @liveexample{The following code shows an example output of the `meta()`
-    function.,meta}
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @complexity Constant.
-
-    @since 2.1.0
-    */
-  static basic_json meta()
-  {
-    basic_json result;
-
-    result["copyright"] = "(C) 2013-2017 Niels Lohmann";
-    result["name"] = "JSON for Modern C++";
-    result["url"] = "https://github.com/nlohmann/json";
-    result["version"]["string"] =
-      std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
-      std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
-      std::to_string(NLOHMANN_JSON_VERSION_PATCH);
-    result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
-    result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
-    result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
-
-#ifdef _WIN32
-    result["platform"] = "win32";
-#elif defined __linux__
-    result["platform"] = "linux";
-#elif defined __APPLE__
-    result["platform"] = "apple";
-#elif defined __unix__
-    result["platform"] = "unix";
-#else
-    result["platform"] = "unknown";
-#endif
-
-#if defined(__ICC) || defined(__INTEL_COMPILER)
-    result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
-#elif defined(__clang__)
-    result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
-#elif defined(__GNUC__) || defined(__GNUG__)
-    result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
-#elif defined(__HP_cc) || defined(__HP_aCC)
-    result["compiler"] = "hp"
-#elif defined(__IBMCPP__)
-    result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
-#elif defined(_MSC_VER)
-    result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
-#elif defined(__PGI)
-    result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
-#elif defined(__SUNPRO_CC)
-    result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
-#else
-    result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
-#endif
-
-#ifdef __cplusplus
-    result["compiler"]["c++"] = std::to_string(__cplusplus);
-#else
-    result["compiler"]["c++"] = "unknown";
-#endif
-    return result;
-  }
-
-  ///////////////////////////
-  // JSON value data types //
-  ///////////////////////////
-
-  /// @name JSON value data types
-  /// The data types to store a JSON value. These types are derived from
-  /// the template arguments passed to class @ref basic_json.
-  /// @{
-
-#if defined(JSON_HAS_CPP_14)
-  // Use transparent comparator if possible, combined with perfect forwarding
-  // on find() and count() calls prevents unnecessary string construction.
-  using object_comparator_t = std::less<>;
-#else
-  using object_comparator_t = std::less<StringType>;
-#endif
-
-  /*!
-    @brief a type for an object
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
-    > An object is an unordered collection of zero or more name/value pairs,
-    > where a name is a string and a value is a string, number, boolean, null,
-    > object, or array.
-
-    To store objects in C++, a type is defined by the template parameters
-    described below.
-
-    @tparam ObjectType  the container to store objects (e.g., `std::map` or
-    `std::unordered_map`)
-    @tparam StringType the type of the keys or names (e.g., `std::string`).
-    The comparison function `std::less<StringType>` is used to order elements
-    inside the container.
-    @tparam AllocatorType the allocator to use for objects (e.g.,
-    `std::allocator`)
-
-    #### Default type
-
-    With the default values for @a ObjectType (`std::map`), @a StringType
-    (`std::string`), and @a AllocatorType (`std::allocator`), the default
-    value for @a object_t is:
-
-    @code {.cpp}
-    std::map<
-      std::string, // key_type
-      basic_json, // value_type
-      std::less<std::string>, // key_compare
-      std::allocator<std::pair<const std::string, basic_json>> // allocator_type
-    >
-    @endcode
-
-    #### Behavior
-
-    The choice of @a object_t influences the behavior of the JSON class. With
-    the default type, objects have the following behavior:
-
-    - When all names are unique, objects will be interoperable in the sense
-      that all software implementations receiving that object will agree on
-      the name-value mappings.
-    - When the names within an object are not unique, it is unspecified which
-      one of the values for a given key will be chosen. For instance,
-      `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or
-      `{"key": 2}`.
-    - Internally, name/value pairs are stored in lexicographical order of the
-      names. Objects will also be serialized (see @ref dump) in this order.
-      For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
-      and serialized as `{"a": 2, "b": 1}`.
-    - When comparing objects, the order of the name/value pairs is irrelevant.
-      This makes objects interoperable in the sense that they will not be
-      affected by these differences. For instance, `{"b": 1, "a": 2}` and
-      `{"a": 2, "b": 1}` will be treated as equal.
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
-    > An implementation may set limits on the maximum depth of nesting.
-
-    In this class, the object's limit of nesting is not explicitly constrained.
-    However, a maximum depth of nesting may be introduced by the compiler or
-    runtime environment. A theoretical limit can be queried by calling the
-    @ref max_size function of a JSON object.
-
-    #### Storage
-
-    Objects are stored as pointers in a @ref basic_json type. That is, for any
-    access to object values, a pointer of type `object_t*` must be
-    dereferenced.
-
-    @sa @ref array_t -- type for an array value
-
-    @since version 1.0.0
-
-    @note The order name/value pairs are added to the object is *not*
-    preserved by the library. Therefore, iterating an object may return
-    name/value pairs in a different order than they were originally stored. In
-    fact, keys will be traversed in alphabetical order as `std::map` with
-    `std::less` is used by default. Please note this behavior conforms to [RFC
-    7159](http://rfc7159.net/rfc7159), because any order implements the
-    specified "unordered" nature of JSON objects.
-    */
-  using object_t = ObjectType<StringType,
-                              basic_json,
-                              object_comparator_t,
-                              AllocatorType<std::pair<const StringType,
-                                                      basic_json>>>;
-
-  /*!
-    @brief a type for an array
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
-    > An array is an ordered sequence of zero or more values.
-
-    To store objects in C++, a type is defined by the template parameters
-    explained below.
-
-    @tparam ArrayType  container type to store arrays (e.g., `std::vector` or
-    `std::list`)
-    @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
-
-    #### Default type
-
-    With the default values for @a ArrayType (`std::vector`) and @a
-    AllocatorType (`std::allocator`), the default value for @a array_t is:
-
-    @code {.cpp}
-    std::vector<
-      basic_json, // value_type
-      std::allocator<basic_json> // allocator_type
-    >
-    @endcode
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
-    > An implementation may set limits on the maximum depth of nesting.
-
-    In this class, the array's limit of nesting is not explicitly constrained.
-    However, a maximum depth of nesting may be introduced by the compiler or
-    runtime environment. A theoretical limit can be queried by calling the
-    @ref max_size function of a JSON array.
-
-    #### Storage
-
-    Arrays are stored as pointers in a @ref basic_json type. That is, for any
-    access to array values, a pointer of type `array_t*` must be dereferenced.
-
-    @sa @ref object_t -- type for an object value
-
-    @since version 1.0.0
-    */
-  using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
-
-  /*!
-    @brief a type for a string
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
-    > A string is a sequence of zero or more Unicode characters.
-
-    To store objects in C++, a type is defined by the template parameter
-    described below. Unicode values are split by the JSON class into
-    byte-sized characters during deserialization.
-
-    @tparam StringType  the container to store strings (e.g., `std::string`).
-    Note this container is used for keys/names in objects, see @ref object_t.
-
-    #### Default type
-
-    With the default values for @a StringType (`std::string`), the default
-    value for @a string_t is:
-
-    @code {.cpp}
-    std::string
-    @endcode
-
-    #### Encoding
-
-    Strings are stored in UTF-8 encoding. Therefore, functions like
-    `std::string::size()` or `std::string::length()` return the number of
-    bytes in the string rather than the number of characters or glyphs.
-
-    #### String comparison
-
-    [RFC 7159](http://rfc7159.net/rfc7159) states:
-    > Software implementations are typically required to test names of object
-    > members for equality. Implementations that transform the textual
-    > representation into sequences of Unicode code units and then perform the
-    > comparison numerically, code unit by code unit, are interoperable in the
-    > sense that implementations will agree in all cases on equality or
-    > inequality of two strings. For example, implementations that compare
-    > strings with escaped characters unconverted may incorrectly find that
-    > `"a\\b"` and `"a\u005Cb"` are not equal.
-
-    This implementation is interoperable as it does compare strings code unit
-    by code unit.
-
-    #### Storage
-
-    String values are stored as pointers in a @ref basic_json type. That is,
-    for any access to string values, a pointer of type `string_t*` must be
-    dereferenced.
-
-    @since version 1.0.0
-    */
-  using string_t = StringType;
-
-  /*!
-    @brief a type for a boolean
-
-    [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
-    type which differentiates the two literals `true` and `false`.
-
-    To store objects in C++, a type is defined by the template parameter @a
-    BooleanType which chooses the type to use.
-
-    #### Default type
-
-    With the default values for @a BooleanType (`bool`), the default value for
-    @a boolean_t is:
-
-    @code {.cpp}
-    bool
-    @endcode
-
-    #### Storage
-
-    Boolean values are stored directly inside a @ref basic_json type.
-
-    @since version 1.0.0
-    */
-  using boolean_t = BooleanType;
-
-  /*!
-    @brief a type for a number (integer)
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
-    > The representation of numbers is similar to that used in most
-    > programming languages. A number is represented in base 10 using decimal
-    > digits. It contains an integer component that may be prefixed with an
-    > optional minus sign, which may be followed by a fraction part and/or an
-    > exponent part. Leading zeros are not allowed. (...) Numeric values that
-    > cannot be represented in the grammar below (such as Infinity and NaN)
-    > are not permitted.
-
-    This description includes both integer and floating-point numbers.
-    However, C++ allows more precise storage if it is known whether the number
-    is a signed integer, an unsigned integer or a floating-point number.
-    Therefore, three different types, @ref number_integer_t, @ref
-    number_unsigned_t and @ref number_float_t are used.
-
-    To store integer numbers in C++, a type is defined by the template
-    parameter @a NumberIntegerType which chooses the type to use.
-
-    #### Default type
-
-    With the default values for @a NumberIntegerType (`int64_t`), the default
-    value for @a number_integer_t is:
-
-    @code {.cpp}
-    int64_t
-    @endcode
-
-    #### Default behavior
-
-    - The restrictions about leading zeros is not enforced in C++. Instead,
-      leading zeros in integer literals lead to an interpretation as octal
-      number. Internally, the value will be stored as decimal number. For
-      instance, the C++ integer literal `010` will be serialized to `8`.
-      During deserialization, leading zeros yield an error.
-    - Not-a-number (NaN) values will be serialized to `null`.
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
-    > An implementation may set limits on the range and precision of numbers.
-
-    When the default type is used, the maximal integer number that can be
-    stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
-    that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
-    that are out of range will yield over/underflow when used in a
-    constructor. During deserialization, too large or small integer numbers
-    will be automatically be stored as @ref number_unsigned_t or @ref
-    number_float_t.
-
-    [RFC 7159](http://rfc7159.net/rfc7159) further states:
-    > Note that when such software is used, numbers that are integers and are
-    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
-    > that implementations will agree exactly on their numeric values.
-
-    As this range is a subrange of the exactly supported range [INT64_MIN,
-    INT64_MAX], this class's integer type is interoperable.
-
-    #### Storage
-
-    Integer number values are stored directly inside a @ref basic_json type.
-
-    @sa @ref number_float_t -- type for number values (floating-point)
-
-    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
-
-    @since version 1.0.0
-    */
-  using number_integer_t = NumberIntegerType;
-
-  /*!
-    @brief a type for a number (unsigned)
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
-    > The representation of numbers is similar to that used in most
-    > programming languages. A number is represented in base 10 using decimal
-    > digits. It contains an integer component that may be prefixed with an
-    > optional minus sign, which may be followed by a fraction part and/or an
-    > exponent part. Leading zeros are not allowed. (...) Numeric values that
-    > cannot be represented in the grammar below (such as Infinity and NaN)
-    > are not permitted.
-
-    This description includes both integer and floating-point numbers.
-    However, C++ allows more precise storage if it is known whether the number
-    is a signed integer, an unsigned integer or a floating-point number.
-    Therefore, three different types, @ref number_integer_t, @ref
-    number_unsigned_t and @ref number_float_t are used.
-
-    To store unsigned integer numbers in C++, a type is defined by the
-    template parameter @a NumberUnsignedType which chooses the type to use.
-
-    #### Default type
-
-    With the default values for @a NumberUnsignedType (`uint64_t`), the
-    default value for @a number_unsigned_t is:
-
-    @code {.cpp}
-    uint64_t
-    @endcode
-
-    #### Default behavior
-
-    - The restrictions about leading zeros is not enforced in C++. Instead,
-      leading zeros in integer literals lead to an interpretation as octal
-      number. Internally, the value will be stored as decimal number. For
-      instance, the C++ integer literal `010` will be serialized to `8`.
-      During deserialization, leading zeros yield an error.
-    - Not-a-number (NaN) values will be serialized to `null`.
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) specifies:
-    > An implementation may set limits on the range and precision of numbers.
-
-    When the default type is used, the maximal integer number that can be
-    stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
-    number that can be stored is `0`. Integer numbers that are out of range
-    will yield over/underflow when used in a constructor. During
-    deserialization, too large or small integer numbers will be automatically
-    be stored as @ref number_integer_t or @ref number_float_t.
-
-    [RFC 7159](http://rfc7159.net/rfc7159) further states:
-    > Note that when such software is used, numbers that are integers and are
-    > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
-    > that implementations will agree exactly on their numeric values.
-
-    As this range is a subrange (when considered in conjunction with the
-    number_integer_t type) of the exactly supported range [0, UINT64_MAX],
-    this class's integer type is interoperable.
-
-    #### Storage
-
-    Integer number values are stored directly inside a @ref basic_json type.
-
-    @sa @ref number_float_t -- type for number values (floating-point)
-    @sa @ref number_integer_t -- type for number values (integer)
-
-    @since version 2.0.0
-    */
-  using number_unsigned_t = NumberUnsignedType;
-
-  /*!
-    @brief a type for a number (floating-point)
-
-    [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
-    > The representation of numbers is similar to that used in most
-    > programming languages. A number is represented in base 10 using decimal
-    > digits. It contains an integer component that may be prefixed with an
-    > optional minus sign, which may be followed by a fraction part and/or an
-    > exponent part. Leading zeros are not allowed. (...) Numeric values that
-    > cannot be represented in the grammar below (such as Infinity and NaN)
-    > are not permitted.
-
-    This description includes both integer and floating-point numbers.
-    However, C++ allows more precise storage if it is known whether the number
-    is a signed integer, an unsigned integer or a floating-point number.
-    Therefore, three different types, @ref number_integer_t, @ref
-    number_unsigned_t and @ref number_float_t are used.
-
-    To store floating-point numbers in C++, a type is defined by the template
-    parameter @a NumberFloatType which chooses the type to use.
-
-    #### Default type
-
-    With the default values for @a NumberFloatType (`double`), the default
-    value for @a number_float_t is:
-
-    @code {.cpp}
-    double
-    @endcode
-
-    #### Default behavior
-
-    - The restrictions about leading zeros is not enforced in C++. Instead,
-      leading zeros in floating-point literals will be ignored. Internally,
-      the value will be stored as decimal number. For instance, the C++
-      floating-point literal `01.2` will be serialized to `1.2`. During
-      deserialization, leading zeros yield an error.
-    - Not-a-number (NaN) values will be serialized to `null`.
-
-    #### Limits
-
-    [RFC 7159](http://rfc7159.net/rfc7159) states:
-    > This specification allows implementations to set limits on the range and
-    > precision of numbers accepted. Since software that implements IEEE
-    > 754-2008 binary64 (double precision) numbers is generally available and
-    > widely used, good interoperability can be achieved by implementations
-    > that expect no more precision or range than these provide, in the sense
-    > that implementations will approximate JSON numbers within the expected
-    > precision.
-
-    This implementation does exactly follow this approach, as it uses double
-    precision floating-point numbers. Note values smaller than
-    `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
-    will be stored as NaN internally and be serialized to `null`.
-
-    #### Storage
-
-    Floating-point number values are stored directly inside a @ref basic_json
-    type.
-
-    @sa @ref number_integer_t -- type for number values (integer)
-
-    @sa @ref number_unsigned_t -- type for number values (unsigned integer)
-
-    @since version 1.0.0
-    */
-  using number_float_t = NumberFloatType;
-
-  /// @}
-
- private:
-  /// helper for exception-safe object creation
-  template <typename T, typename... Args>
-  static T* create(Args&&... args)
-  {
-    AllocatorType<T> alloc;
-    using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
-
-    auto deleter = [&](T* object) {
-      AllocatorTraits::deallocate(alloc, object, 1);
-    };
-    std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
-    AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
-    assert(object != nullptr);
-    return object.release();
-  }
-
-  ////////////////////////
-  // JSON value storage //
-  ////////////////////////
-
-  /*!
-    @brief a JSON value
-
-    The actual storage for a JSON value of the @ref basic_json class. This
-    union combines the different storage types for the JSON value types
-    defined in @ref value_t.
-
-    JSON type | value_t type    | used type
-    --------- | --------------- | ------------------------
-    object    | object          | pointer to @ref object_t
-    array     | array           | pointer to @ref array_t
-    string    | string          | pointer to @ref string_t
-    boolean   | boolean         | @ref boolean_t
-    number    | number_integer  | @ref number_integer_t
-    number    | number_unsigned | @ref number_unsigned_t
-    number    | number_float    | @ref number_float_t
-    null      | null            | *no value is stored*
-
-    @note Variable-length types (objects, arrays, and strings) are stored as
-    pointers. The size of the union should not exceed 64 bits if the default
-    value types are used.
-
-    @since version 1.0.0
-    */
-  union json_value {
-    /// object (stored with pointer to save storage)
-    object_t* object;
-    /// array (stored with pointer to save storage)
-    array_t* array;
-    /// string (stored with pointer to save storage)
-    string_t* string;
-    /// boolean
-    boolean_t boolean;
-    /// number (integer)
-    number_integer_t number_integer;
-    /// number (unsigned integer)
-    number_unsigned_t number_unsigned;
-    /// number (floating-point)
-    number_float_t number_float;
-
-    /// default constructor (for null values)
-    json_value() = default;
-    /// constructor for booleans
-    json_value(boolean_t v) noexcept : boolean(v) {}
-    /// constructor for numbers (integer)
-    json_value(number_integer_t v) noexcept : number_integer(v) {}
-    /// constructor for numbers (unsigned)
-    json_value(number_unsigned_t v) noexcept : number_unsigned(v) {}
-    /// constructor for numbers (floating-point)
-    json_value(number_float_t v) noexcept : number_float(v) {}
-    /// constructor for empty values of a given type
-    json_value(value_t t)
-    {
-      switch (t) {
-        case value_t::object: {
-          object = create<object_t>();
-          break;
-        }
-
-        case value_t::array: {
-          array = create<array_t>();
-          break;
-        }
-
-        case value_t::string: {
-          string = create<string_t>("");
-          break;
-        }
-
-        case value_t::boolean: {
-          boolean = boolean_t(false);
-          break;
-        }
-
-        case value_t::number_integer: {
-          number_integer = number_integer_t(0);
-          break;
-        }
-
-        case value_t::number_unsigned: {
-          number_unsigned = number_unsigned_t(0);
-          break;
-        }
-
-        case value_t::number_float: {
-          number_float = number_float_t(0.0);
-          break;
-        }
-
-        case value_t::null: {
-          object = nullptr; // silence warning, see #821
-          break;
-        }
-
-        default: {
-          object = nullptr; // silence warning, see #821
-          if (JSON_UNLIKELY(t == value_t::null)) {
-            JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.1.2")); // LCOV_EXCL_LINE
-          }
-          break;
-        }
-      }
-    }
-
-    /// constructor for strings
-    json_value(const string_t& value)
-    {
-      string = create<string_t>(value);
-    }
-
-    /// constructor for rvalue strings
-    json_value(string_t&& value)
-    {
-      string = create<string_t>(std::move(value));
-    }
-
-    /// constructor for objects
-    json_value(const object_t& value)
-    {
-      object = create<object_t>(value);
-    }
-
-    /// constructor for rvalue objects
-    json_value(object_t&& value)
-    {
-      object = create<object_t>(std::move(value));
-    }
-
-    /// constructor for arrays
-    json_value(const array_t& value)
-    {
-      array = create<array_t>(value);
-    }
-
-    /// constructor for rvalue arrays
-    json_value(array_t&& value)
-    {
-      array = create<array_t>(std::move(value));
-    }
-
-    void destroy(value_t t) noexcept
-    {
-      switch (t) {
-        case value_t::object: {
-          AllocatorType<object_t> alloc;
-          std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
-          std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
-          break;
-        }
-
-        case value_t::array: {
-          AllocatorType<array_t> alloc;
-          std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
-          std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
-          break;
-        }
-
-        case value_t::string: {
-          AllocatorType<string_t> alloc;
-          std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
-          std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
-          break;
-        }
-
-        default: {
-          break;
-        }
-      }
-    }
-  };
-
-  /*!
-    @brief checks the class invariants
-
-    This function asserts the class invariants. It needs to be called at the
-    end of every constructor to make sure that created objects respect the
-    invariant. Furthermore, it has to be called each time the type of a JSON
-    value is changed, because the invariant expresses a relationship between
-    @a m_type and @a m_value.
-    */
-  void assert_invariant() const noexcept
-  {
-    assert(m_type != value_t::object or m_value.object != nullptr);
-    assert(m_type != value_t::array or m_value.array != nullptr);
-    assert(m_type != value_t::string or m_value.string != nullptr);
-  }
-
- public:
-  //////////////////////////
-  // JSON parser callback //
-  //////////////////////////
-
-  /*!
-    @brief parser event types
-
-    The parser callback distinguishes the following events:
-    - `object_start`: the parser read `{` and started to process a JSON object
-    - `key`: the parser read a key of a value in an object
-    - `object_end`: the parser read `}` and finished processing a JSON object
-    - `array_start`: the parser read `[` and started to process a JSON array
-    - `array_end`: the parser read `]` and finished processing a JSON array
-    - `value`: the parser finished reading a JSON value
-
-    @image html callback_events.png "Example when certain parse events are triggered"
-
-    @sa @ref parser_callback_t for more information and examples
-    */
-  using parse_event_t = typename parser::parse_event_t;
-
-  /*!
-    @brief per-element parser callback type
-
-    With a parser callback function, the result of parsing a JSON text can be
-    influenced. When passed to @ref parse, it is called on certain events
-    (passed as @ref parse_event_t via parameter @a event) with a set recursion
-    depth @a depth and context JSON value @a parsed. The return value of the
-    callback function is a boolean indicating whether the element that emitted
-    the callback shall be kept or not.
-
-    We distinguish six scenarios (determined by the event type) in which the
-    callback function can be called. The following table describes the values
-    of the parameters @a depth, @a event, and @a parsed.
-
-    parameter @a event | description | parameter @a depth | parameter @a parsed
-    ------------------ | ----------- | ------------------ | -------------------
-    parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
-    parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
-    parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
-    parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
-    parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
-    parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
-
-    @image html callback_events.png "Example when certain parse events are triggered"
-
-    Discarding a value (i.e., returning `false`) has different effects
-    depending on the context in which function was called:
-
-    - Discarded values in structured types are skipped. That is, the parser
-      will behave as if the discarded value was never read.
-    - In case a value outside a structured type is skipped, it is replaced
-      with `null`. This case happens if the top-level element is skipped.
-
-    @param[in] depth  the depth of the recursion during parsing
-
-    @param[in] event  an event of type parse_event_t indicating the context in
-    the callback function has been called
-
-    @param[in,out] parsed  the current intermediate parse result; note that
-    writing to this value has no effect for parse_event_t::key events
-
-    @return Whether the JSON value which called the function during parsing
-    should be kept (`true`) or not (`false`). In the latter case, it is either
-    skipped completely or replaced by an empty discarded object.
-
-    @sa @ref parse for examples
-
-    @since version 1.0.0
-    */
-  using parser_callback_t = typename parser::parser_callback_t;
-
-  //////////////////
-  // constructors //
-  //////////////////
-
-  /// @name constructors and destructors
-  /// Constructors of class @ref basic_json, copy/move constructor, copy
-  /// assignment, static functions creating objects, and the destructor.
-  /// @{
-
-  /*!
-    @brief create an empty value with a given type
-
-    Create an empty JSON value with a given type. The value will be default
-    initialized with an empty value which depends on the type:
-
-    Value type  | initial value
-    ----------- | -------------
-    null        | `null`
-    boolean     | `false`
-    string      | `""`
-    number      | `0`
-    object      | `{}`
-    array       | `[]`
-
-    @param[in] v  the type of the value to create
-
-    @complexity Constant.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The following code shows the constructor for different @ref
-    value_t values,basic_json__value_t}
-
-    @sa @ref clear() -- restores the postcondition of this constructor
-
-    @since version 1.0.0
-    */
-  basic_json(const value_t v)
-    : m_type(v), m_value(v)
-  {
-    assert_invariant();
-  }
-
-  /*!
-    @brief create a null object
-
-    Create a `null` JSON value. It either takes a null pointer as parameter
-    (explicitly creating `null`) or no parameter (implicitly creating `null`).
-    The passed null pointer itself is not read -- it is only used to choose
-    the right constructor.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this constructor never throws
-    exceptions.
-
-    @liveexample{The following code shows the constructor with and without a
-    null pointer parameter.,basic_json__nullptr_t}
-
-    @since version 1.0.0
-    */
-  basic_json(std::nullptr_t = nullptr) noexcept
-    : basic_json(value_t::null)
-  {
-    assert_invariant();
-  }
-
-  /*!
-    @brief create a JSON value
-
-    This is a "catch all" constructor for all compatible JSON types; that is,
-    types for which a `to_json()` method exists. The constructor forwards the
-    parameter @a val to that method (to `json_serializer<U>::to_json` method
-    with `U = uncvref_t<CompatibleType>`, to be exact).
-
-    Template type @a CompatibleType includes, but is not limited to, the
-    following types:
-    - **arrays**: @ref array_t and all kinds of compatible containers such as
-      `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
-      `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,
-      `std::multiset`, and `std::unordered_multiset` with a `value_type` from
-      which a @ref basic_json value can be constructed.
-    - **objects**: @ref object_t and all kinds of compatible associative
-      containers such as `std::map`, `std::unordered_map`, `std::multimap`,
-      and `std::unordered_multimap` with a `key_type` compatible to
-      @ref string_t and a `value_type` from which a @ref basic_json value can
-      be constructed.
-    - **strings**: @ref string_t, string literals, and all compatible string
-      containers can be used.
-    - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
-      @ref number_float_t, and all convertible number types such as `int`,
-      `size_t`, `int64_t`, `float` or `double` can be used.
-    - **boolean**: @ref boolean_t / `bool` can be used.
-
-    See the examples below.
-
-    @tparam CompatibleType a type such that:
-    - @a CompatibleType is not derived from `std::istream`,
-    - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
-         constructors),
-    - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)
-    - @a CompatibleType is not a @ref basic_json nested type (e.g.,
-         @ref json_pointer, @ref iterator, etc ...)
-    - @ref @ref json_serializer<U> has a
-         `to_json(basic_json_t&, CompatibleType&&)` method
-
-    @tparam U = `uncvref_t<CompatibleType>`
-
-    @param[in] val the value to be forwarded to the respective constructor
-
-    @complexity Usually linear in the size of the passed @a val, also
-                depending on the implementation of the called `to_json()`
-                method.
-
-    @exceptionsafety Depends on the called constructor. For types directly
-    supported by the library (i.e., all types for which no `to_json()` function
-    was provided), strong guarantee holds: if an exception is thrown, there are
-    no changes to any JSON value.
-
-    @liveexample{The following code shows the constructor with several
-    compatible types.,basic_json__CompatibleType}
-
-    @since version 2.1.0
-    */
-  template <typename CompatibleType,
-            typename U = detail::uncvref_t<CompatibleType>,
-            detail::enable_if_t<
-              detail::is_compatible_type<basic_json_t, U>::value, int> = 0>
-  basic_json(CompatibleType&& val) noexcept(noexcept(
-    JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
-                               std::forward<CompatibleType>(val))))
-  {
-    JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
-    assert_invariant();
-  }
-
-  /*!
-    @brief create a JSON value from an existing one
-
-    This is a constructor for existing @ref basic_json types.
-    It does not hijack copy/move constructors, since the parameter has different
-    template arguments than the current ones.
-
-    The constructor tries to convert the internal @ref m_value of the parameter.
-
-    @tparam BasicJsonType a type such that:
-    - @a BasicJsonType is a @ref basic_json type.
-    - @a BasicJsonType has different template arguments than @ref basic_json_t.
-
-    @param[in] val the @ref basic_json value to be converted.
-
-    @complexity Usually linear in the size of the passed @a val, also
-                depending on the implementation of the called `to_json()`
-                method.
-
-    @exceptionsafety Depends on the called constructor. For types directly
-    supported by the library (i.e., all types for which no `to_json()` function
-    was provided), strong guarantee holds: if an exception is thrown, there are
-    no changes to any JSON value.
-
-    @since version 3.1.2
-    */
-  template <typename BasicJsonType,
-            detail::enable_if_t<
-              detail::is_basic_json<BasicJsonType>::value and not std::is_same<basic_json, BasicJsonType>::value, int> = 0>
-  basic_json(const BasicJsonType& val)
-  {
-    using other_boolean_t = typename BasicJsonType::boolean_t;
-    using other_number_float_t = typename BasicJsonType::number_float_t;
-    using other_number_integer_t = typename BasicJsonType::number_integer_t;
-    using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
-    using other_string_t = typename BasicJsonType::string_t;
-    using other_object_t = typename BasicJsonType::object_t;
-    using other_array_t = typename BasicJsonType::array_t;
-
-    switch (val.type()) {
-      case value_t::boolean:
-        JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
-        break;
-      case value_t::number_float:
-        JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
-        break;
-      case value_t::number_integer:
-        JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
-        break;
-      case value_t::number_unsigned:
-        JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
-        break;
-      case value_t::string:
-        JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
-        break;
-      case value_t::object:
-        JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
-        break;
-      case value_t::array:
-        JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
-        break;
-      case value_t::null:
-        *this = nullptr;
-        break;
-      case value_t::discarded:
-        m_type = value_t::discarded;
-        break;
-    }
-    assert_invariant();
-  }
-
-  /*!
-    @brief create a container (array or object) from an initializer list
-
-    Creates a JSON value of type array or object from the passed initializer
-    list @a init. In case @a type_deduction is `true` (default), the type of
-    the JSON value to be created is deducted from the initializer list @a init
-    according to the following rules:
-
-    1. If the list is empty, an empty JSON object value `{}` is created.
-    2. If the list consists of pairs whose first element is a string, a JSON
-       object value is created where the first elements of the pairs are
-       treated as keys and the second elements are as values.
-    3. In all other cases, an array is created.
-
-    The rules aim to create the best fit between a C++ initializer list and
-    JSON values. The rationale is as follows:
-
-    1. The empty initializer list is written as `{}` which is exactly an empty
-       JSON object.
-    2. C++ has no way of describing mapped types other than to list a list of
-       pairs. As JSON requires that keys must be of type string, rule 2 is the
-       weakest constraint one can pose on initializer lists to interpret them
-       as an object.
-    3. In all other cases, the initializer list could not be interpreted as
-       JSON object type, so interpreting it as JSON array type is safe.
-
-    With the rules described above, the following JSON values cannot be
-    expressed by an initializer list:
-
-    - the empty array (`[]`): use @ref array(initializer_list_t)
-      with an empty initializer list in this case
-    - arrays whose elements satisfy rule 2: use @ref
-      array(initializer_list_t) with the same initializer list
-      in this case
-
-    @note When used without parentheses around an empty initializer list, @ref
-    basic_json() is called instead of this function, yielding the JSON null
-    value.
-
-    @param[in] init  initializer list with JSON values
-
-    @param[in] type_deduction internal parameter; when set to `true`, the type
-    of the JSON value is deducted from the initializer list @a init; when set
-    to `false`, the type provided via @a manual_type is forced. This mode is
-    used by the functions @ref array(initializer_list_t) and
-    @ref object(initializer_list_t).
-
-    @param[in] manual_type internal parameter; when @a type_deduction is set
-    to `false`, the created JSON value will use the provided type (only @ref
-    value_t::array and @ref value_t::object are valid); when @a type_deduction
-    is set to `true`, this parameter has no effect
-
-    @throw type_error.301 if @a type_deduction is `false`, @a manual_type is
-    `value_t::object`, but @a init contains an element which is not a pair
-    whose first element is a string. In this case, the constructor could not
-    create an object. If @a type_deduction would have be `true`, an array
-    would have been created. See @ref object(initializer_list_t)
-    for an example.
-
-    @complexity Linear in the size of the initializer list @a init.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The example below shows how JSON values are created from
-    initializer lists.,basic_json__list_init_t}
-
-    @sa @ref array(initializer_list_t) -- create a JSON array
-    value from an initializer list
-    @sa @ref object(initializer_list_t) -- create a JSON object
-    value from an initializer list
-
-    @since version 1.0.0
-    */
-  basic_json(initializer_list_t init,
-             bool type_deduction = true,
-             value_t manual_type = value_t::array)
-  {
-    // check if each element is an array with two elements whose first
-    // element is a string
-    bool is_an_object = std::all_of(init.begin(), init.end(),
-                                    [](const detail::json_ref<basic_json>& element_ref) {
-                                      return (element_ref->is_array() and element_ref->size() == 2 and (*element_ref)[0].is_string());
-                                    });
-
-    // adjust type if type deduction is not wanted
-    if (not type_deduction) {
-      // if array is wanted, do not create an object though possible
-      if (manual_type == value_t::array) {
-        is_an_object = false;
-      }
-
-      // if object is wanted but impossible, throw an exception
-      if (JSON_UNLIKELY(manual_type == value_t::object and not is_an_object)) {
-        JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
-      }
-    }
-
-    if (is_an_object) {
-      // the initializer list is a list of pairs -> create object
-      m_type = value_t::object;
-      m_value = value_t::object;
-
-      std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref) {
-        auto element = element_ref.moved_or_copied();
-        m_value.object->emplace(
-          std::move(*((*element.m_value.array)[0].m_value.string)),
-          std::move((*element.m_value.array)[1]));
-      });
-    } else {
-      // the initializer list describes an array -> create array
-      m_type = value_t::array;
-      m_value.array = create<array_t>(init.begin(), init.end());
-    }
-
-    assert_invariant();
-  }
-
-  /*!
-    @brief explicitly create an array from an initializer list
-
-    Creates a JSON array value from a given initializer list. That is, given a
-    list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
-    initializer list is empty, the empty array `[]` is created.
-
-    @note This function is only needed to express two edge cases that cannot
-    be realized with the initializer list constructor (@ref
-    basic_json(initializer_list_t, bool, value_t)). These cases
-    are:
-    1. creating an array whose elements are all pairs whose first element is a
-    string -- in this case, the initializer list constructor would create an
-    object, taking the first elements as keys
-    2. creating an empty array -- passing the empty initializer list to the
-    initializer list constructor yields an empty object
-
-    @param[in] init  initializer list with JSON values to create an array from
-    (optional)
-
-    @return JSON array value
-
-    @complexity Linear in the size of @a init.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The following code shows an example for the `array`
-    function.,array}
-
-    @sa @ref basic_json(initializer_list_t, bool, value_t) --
-    create a JSON value from an initializer list
-    @sa @ref object(initializer_list_t) -- create a JSON object
-    value from an initializer list
-
-    @since version 1.0.0
-    */
-  static basic_json array(initializer_list_t init = {})
-  {
-    return basic_json(init, false, value_t::array);
-  }
-
-  /*!
-    @brief explicitly create an object from an initializer list
-
-    Creates a JSON object value from a given initializer list. The initializer
-    lists elements must be pairs, and their first elements must be strings. If
-    the initializer list is empty, the empty object `{}` is created.
-
-    @note This function is only added for symmetry reasons. In contrast to the
-    related function @ref array(initializer_list_t), there are
-    no cases which can only be expressed by this function. That is, any
-    initializer list @a init can also be passed to the initializer list
-    constructor @ref basic_json(initializer_list_t, bool, value_t).
-
-    @param[in] init  initializer list to create an object from (optional)
-
-    @return JSON object value
-
-    @throw type_error.301 if @a init is not a list of pairs whose first
-    elements are strings. In this case, no object can be created. When such a
-    value is passed to @ref basic_json(initializer_list_t, bool, value_t),
-    an array would have been created from the passed initializer list @a init.
-    See example below.
-
-    @complexity Linear in the size of @a init.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The following code shows an example for the `object`
-    function.,object}
-
-    @sa @ref basic_json(initializer_list_t, bool, value_t) --
-    create a JSON value from an initializer list
-    @sa @ref array(initializer_list_t) -- create a JSON array
-    value from an initializer list
-
-    @since version 1.0.0
-    */
-  static basic_json object(initializer_list_t init = {})
-  {
-    return basic_json(init, false, value_t::object);
-  }
-
-  /*!
-    @brief construct an array with count copies of given value
-
-    Constructs a JSON array value by creating @a cnt copies of a passed value.
-    In case @a cnt is `0`, an empty array is created.
-
-    @param[in] cnt  the number of JSON copies of @a val to create
-    @param[in] val  the JSON value to copy
-
-    @post `std::distance(begin(),end()) == cnt` holds.
-
-    @complexity Linear in @a cnt.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The following code shows examples for the @ref
-    basic_json(size_type\, const basic_json&)
-    constructor.,basic_json__size_type_basic_json}
-
-    @since version 1.0.0
-    */
-  basic_json(size_type cnt, const basic_json& val)
-    : m_type(value_t::array)
-  {
-    m_value.array = create<array_t>(cnt, val);
-    assert_invariant();
-  }
-
-  /*!
-    @brief construct a JSON container given an iterator range
-
-    Constructs the JSON value with the contents of the range `[first, last)`.
-    The semantics depends on the different types a JSON value can have:
-    - In case of a null type, invalid_iterator.206 is thrown.
-    - In case of other primitive types (number, boolean, or string), @a first
-      must be `begin()` and @a last must be `end()`. In this case, the value is
-      copied. Otherwise, invalid_iterator.204 is thrown.
-    - In case of structured types (array, object), the constructor behaves as
-      similar versions for `std::vector` or `std::map`; that is, a JSON array
-      or object is constructed from the values in the range.
-
-    @tparam InputIT an input iterator type (@ref iterator or @ref
-    const_iterator)
-
-    @param[in] first begin of the range to copy from (included)
-    @param[in] last end of the range to copy from (excluded)
-
-    @pre Iterators @a first and @a last must be initialized. **This
-         precondition is enforced with an assertion (see warning).** If
-         assertions are switched off, a violation of this precondition yields
-         undefined behavior.
-
-    @pre Range `[first, last)` is valid. Usually, this precondition cannot be
-         checked efficiently. Only certain edge cases are detected; see the
-         description of the exceptions below. A violation of this precondition
-         yields undefined behavior.
-
-    @warning A precondition is enforced with a runtime assertion that will
-             result in calling `std::abort` if this precondition is not met.
-             Assertions can be disabled by defining `NDEBUG` at compile time.
-             See http://en.cppreference.com/w/cpp/error/assert for more
-             information.
-
-    @throw invalid_iterator.201 if iterators @a first and @a last are not
-    compatible (i.e., do not belong to the same JSON value). In this case,
-    the range `[first, last)` is undefined.
-    @throw invalid_iterator.204 if iterators @a first and @a last belong to a
-    primitive type (number, boolean, or string), but @a first does not point
-    to the first element any more. In this case, the range `[first, last)` is
-    undefined. See example code below.
-    @throw invalid_iterator.206 if iterators @a first and @a last belong to a
-    null value. In this case, the range `[first, last)` is undefined.
-
-    @complexity Linear in distance between @a first and @a last.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @liveexample{The example below shows several ways to create JSON values by
-    specifying a subrange with iterators.,basic_json__InputIt_InputIt}
-
-    @since version 1.0.0
-    */
-  template <class InputIT, typename std::enable_if<
-                             std::is_same<InputIT, typename basic_json_t::iterator>::value or
-                               std::is_same<InputIT, typename basic_json_t::const_iterator>::value,
-                             int>::type = 0>
-  basic_json(InputIT first, InputIT last)
-  {
-    assert(first.m_object != nullptr);
-    assert(last.m_object != nullptr);
-
-    // make sure iterator fits the current value
-    if (JSON_UNLIKELY(first.m_object != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
-    }
-
-    // copy type from first iterator
-    m_type = first.m_object->m_type;
-
-    // check if iterator range is complete for primitive values
-    switch (m_type) {
-      case value_t::boolean:
-      case value_t::number_float:
-      case value_t::number_integer:
-      case value_t::number_unsigned:
-      case value_t::string: {
-        if (JSON_UNLIKELY(not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())) {
-          JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
-        }
-        break;
-      }
-
-      default:
-        break;
-    }
-
-    switch (m_type) {
-      case value_t::number_integer: {
-        m_value.number_integer = first.m_object->m_value.number_integer;
-        break;
-      }
-
-      case value_t::number_unsigned: {
-        m_value.number_unsigned = first.m_object->m_value.number_unsigned;
-        break;
-      }
-
-      case value_t::number_float: {
-        m_value.number_float = first.m_object->m_value.number_float;
-        break;
-      }
-
-      case value_t::boolean: {
-        m_value.boolean = first.m_object->m_value.boolean;
-        break;
-      }
-
-      case value_t::string: {
-        m_value = *first.m_object->m_value.string;
-        break;
-      }
-
-      case value_t::object: {
-        m_value.object = create<object_t>(first.m_it.object_iterator,
-                                          last.m_it.object_iterator);
-        break;
-      }
-
-      case value_t::array: {
-        m_value.array = create<array_t>(first.m_it.array_iterator,
-                                        last.m_it.array_iterator);
-        break;
-      }
-
-      default:
-        JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
-                                                   std::string(first.m_object->type_name())));
-    }
-
-    assert_invariant();
-  }
-
-  ///////////////////////////////////////
-  // other constructors and destructor //
-  ///////////////////////////////////////
-
-  /// @private
-  basic_json(const detail::json_ref<basic_json>& ref)
-    : basic_json(ref.moved_or_copied())
-  {
-  }
-
-  /*!
-    @brief copy constructor
-
-    Creates a copy of a given JSON value.
-
-    @param[in] other  the JSON value to copy
-
-    @post `*this == other`
-
-    @complexity Linear in the size of @a other.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes to any JSON value.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is linear.
-    - As postcondition, it holds: `other == basic_json(other)`.
-
-    @liveexample{The following code shows an example for the copy
-    constructor.,basic_json__basic_json}
-
-    @since version 1.0.0
-    */
-  basic_json(const basic_json& other)
-    : m_type(other.m_type)
-  {
-    // check of passed value is valid
-    other.assert_invariant();
-
-    switch (m_type) {
-      case value_t::object: {
-        m_value = *other.m_value.object;
-        break;
-      }
-
-      case value_t::array: {
-        m_value = *other.m_value.array;
-        break;
-      }
-
-      case value_t::string: {
-        m_value = *other.m_value.string;
-        break;
-      }
-
-      case value_t::boolean: {
-        m_value = other.m_value.boolean;
-        break;
-      }
-
-      case value_t::number_integer: {
-        m_value = other.m_value.number_integer;
-        break;
-      }
-
-      case value_t::number_unsigned: {
-        m_value = other.m_value.number_unsigned;
-        break;
-      }
-
-      case value_t::number_float: {
-        m_value = other.m_value.number_float;
-        break;
-      }
-
-      default:
-        break;
-    }
-
-    assert_invariant();
-  }
-
-  /*!
-    @brief move constructor
-
-    Move constructor. Constructs a JSON value with the contents of the given
-    value @a other using move semantics. It "steals" the resources from @a
-    other and leaves it as JSON null value.
-
-    @param[in,out] other  value to move to this object
-
-    @post `*this` has the same value as @a other before the call.
-    @post @a other is a JSON null value.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this constructor never throws
-    exceptions.
-
-    @requirement This function helps `basic_json` satisfying the
-    [MoveConstructible](http://en.cppreference.com/w/cpp/concept/MoveConstructible)
-    requirements.
-
-    @liveexample{The code below shows the move constructor explicitly called
-    via std::move.,basic_json__moveconstructor}
-
-    @since version 1.0.0
-    */
-  basic_json(basic_json&& other) noexcept
-    : m_type(std::move(other.m_type)),
-      m_value(std::move(other.m_value))
-  {
-    // check that passed value is valid
-    other.assert_invariant();
-
-    // invalidate payload
-    other.m_type = value_t::null;
-    other.m_value = {};
-
-    assert_invariant();
-  }
-
-  /*!
-    @brief copy assignment
-
-    Copy assignment operator. Copies a JSON value via the "copy and swap"
-    strategy: It is expressed in terms of the copy constructor, destructor,
-    and the `swap()` member function.
-
-    @param[in] other  value to copy from
-
-    @complexity Linear.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is linear.
-
-    @liveexample{The code below shows and example for the copy assignment. It
-    creates a copy of value `a` which is then swapped with `b`. Finally\, the
-    copy of `a` (which is the null value after the swap) is
-    destroyed.,basic_json__copyassignment}
-
-    @since version 1.0.0
-    */
-  reference& operator=(basic_json other) noexcept(
-    std::is_nothrow_move_constructible<value_t>::value and
-      std::is_nothrow_move_assignable<value_t>::value and
-        std::is_nothrow_move_constructible<json_value>::value and
-          std::is_nothrow_move_assignable<json_value>::value)
-  {
-    // check that passed value is valid
-    other.assert_invariant();
-
-    using std::swap;
-    swap(m_type, other.m_type);
-    swap(m_value, other.m_value);
-
-    assert_invariant();
-    return *this;
-  }
-
-  /*!
-    @brief destructor
-
-    Destroys the JSON value and frees all allocated memory.
-
-    @complexity Linear.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is linear.
-    - All stored elements are destroyed and all memory is freed.
-
-    @since version 1.0.0
-    */
-  ~basic_json() noexcept
-  {
-    assert_invariant();
-    m_value.destroy(m_type);
-  }
-
-  /// @}
-
- public:
-  ///////////////////////
-  // object inspection //
-  ///////////////////////
-
-  /// @name object inspection
-  /// Functions to inspect the type of a JSON value.
-  /// @{
-
-  /*!
-    @brief serialization
-
-    Serialization function for JSON values. The function tries to mimic
-    Python's `json.dumps()` function, and currently supports its @a indent
-    and @a ensure_ascii parameters.
-
-    @param[in] indent If indent is nonnegative, then array elements and object
-    members will be pretty-printed with that indent level. An indent level of
-    `0` will only insert newlines. `-1` (the default) selects the most compact
-    representation.
-    @param[in] indent_char The character to use for indentation if @a indent is
-    greater than `0`. The default is ` ` (space).
-    @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
-    in the output are escaped with `\uXXXX` sequences, and the result consists
-    of ASCII characters only.
-
-    @return string containing the serialization of the JSON value
-
-    @throw type_error.316 if a string stored inside the JSON value is not
-                          UTF-8 encoded
-
-    @complexity Linear.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @liveexample{The following example shows the effect of different @a indent\,
-    @a indent_char\, and @a ensure_ascii parameters to the result of the
-    serialization.,dump}
-
-    @see https://docs.python.org/2/library/json.html#json.dump
-
-    @since version 1.0.0; indentation character @a indent_char, option
-           @a ensure_ascii and exceptions added in version 3.0.0
-    */
-  string_t dump(const int indent = -1, const char indent_char = ' ',
-                const bool ensure_ascii = false) const
-  {
-    string_t result;
-    serializer s(detail::output_adapter<char, string_t>(result), indent_char);
-
-    if (indent >= 0) {
-      s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
-    } else {
-      s.dump(*this, false, ensure_ascii, 0);
-    }
-
-    return result;
-  }
-
-  /*!
-    @brief return the type of the JSON value (explicit)
-
-    Return the type of the JSON value as a value from the @ref value_t
-    enumeration.
-
-    @return the type of the JSON value
-            Value type                | return value
-            ------------------------- | -------------------------
-            null                      | value_t::null
-            boolean                   | value_t::boolean
-            string                    | value_t::string
-            number (integer)          | value_t::number_integer
-            number (unsigned integer) | value_t::number_unsigned
-            number (floating-point)   | value_t::number_float
-            object                    | value_t::object
-            array                     | value_t::array
-            discarded                 | value_t::discarded
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `type()` for all JSON
-    types.,type}
-
-    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
-    @sa @ref type_name() -- return the type as string
-
-    @since version 1.0.0
-    */
-  constexpr value_t type() const noexcept
-  {
-    return m_type;
-  }
-
-  /*!
-    @brief return whether type is primitive
-
-    This function returns true if and only if the JSON type is primitive
-    (string, number, boolean, or null).
-
-    @return `true` if type is primitive (string, number, boolean, or null),
-    `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_primitive()` for all JSON
-    types.,is_primitive}
-
-    @sa @ref is_structured() -- returns whether JSON value is structured
-    @sa @ref is_null() -- returns whether JSON value is `null`
-    @sa @ref is_string() -- returns whether JSON value is a string
-    @sa @ref is_boolean() -- returns whether JSON value is a boolean
-    @sa @ref is_number() -- returns whether JSON value is a number
-
-    @since version 1.0.0
-    */
-  constexpr bool is_primitive() const noexcept
-  {
-    return is_null() or is_string() or is_boolean() or is_number();
-  }
-
-  /*!
-    @brief return whether type is structured
-
-    This function returns true if and only if the JSON type is structured
-    (array or object).
-
-    @return `true` if type is structured (array or object), `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_structured()` for all JSON
-    types.,is_structured}
-
-    @sa @ref is_primitive() -- returns whether value is primitive
-    @sa @ref is_array() -- returns whether value is an array
-    @sa @ref is_object() -- returns whether value is an object
-
-    @since version 1.0.0
-    */
-  constexpr bool is_structured() const noexcept
-  {
-    return is_array() or is_object();
-  }
-
-  /*!
-    @brief return whether value is null
-
-    This function returns true if and only if the JSON value is null.
-
-    @return `true` if type is null, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_null()` for all JSON
-    types.,is_null}
-
-    @since version 1.0.0
-    */
-  constexpr bool is_null() const noexcept
-  {
-    return (m_type == value_t::null);
-  }
-
-  /*!
-    @brief return whether value is a boolean
-
-    This function returns true if and only if the JSON value is a boolean.
-
-    @return `true` if type is boolean, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_boolean()` for all JSON
-    types.,is_boolean}
-
-    @since version 1.0.0
-    */
-  constexpr bool is_boolean() const noexcept
-  {
-    return (m_type == value_t::boolean);
-  }
-
-  /*!
-    @brief return whether value is a number
-
-    This function returns true if and only if the JSON value is a number. This
-    includes both integer (signed and unsigned) and floating-point values.
-
-    @return `true` if type is number (regardless whether integer, unsigned
-    integer or floating-type), `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_number()` for all JSON
-    types.,is_number}
-
-    @sa @ref is_number_integer() -- check if value is an integer or unsigned
-    integer number
-    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
-    number
-    @sa @ref is_number_float() -- check if value is a floating-point number
-
-    @since version 1.0.0
-    */
-  constexpr bool is_number() const noexcept
-  {
-    return is_number_integer() or is_number_float();
-  }
-
-  /*!
-    @brief return whether value is an integer number
-
-    This function returns true if and only if the JSON value is a signed or
-    unsigned integer number. This excludes floating-point values.
-
-    @return `true` if type is an integer or unsigned integer number, `false`
-    otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_number_integer()` for all
-    JSON types.,is_number_integer}
-
-    @sa @ref is_number() -- check if value is a number
-    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
-    number
-    @sa @ref is_number_float() -- check if value is a floating-point number
-
-    @since version 1.0.0
-    */
-  constexpr bool is_number_integer() const noexcept
-  {
-    return (m_type == value_t::number_integer or m_type == value_t::number_unsigned);
-  }
-
-  /*!
-    @brief return whether value is an unsigned integer number
-
-    This function returns true if and only if the JSON value is an unsigned
-    integer number. This excludes floating-point and signed integer values.
-
-    @return `true` if type is an unsigned integer number, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_number_unsigned()` for all
-    JSON types.,is_number_unsigned}
-
-    @sa @ref is_number() -- check if value is a number
-    @sa @ref is_number_integer() -- check if value is an integer or unsigned
-    integer number
-    @sa @ref is_number_float() -- check if value is a floating-point number
-
-    @since version 2.0.0
-    */
-  constexpr bool is_number_unsigned() const noexcept
-  {
-    return (m_type == value_t::number_unsigned);
-  }
-
-  /*!
-    @brief return whether value is a floating-point number
-
-    This function returns true if and only if the JSON value is a
-    floating-point number. This excludes signed and unsigned integer values.
-
-    @return `true` if type is a floating-point number, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_number_float()` for all
-    JSON types.,is_number_float}
-
-    @sa @ref is_number() -- check if value is number
-    @sa @ref is_number_integer() -- check if value is an integer number
-    @sa @ref is_number_unsigned() -- check if value is an unsigned integer
-    number
-
-    @since version 1.0.0
-    */
-  constexpr bool is_number_float() const noexcept
-  {
-    return (m_type == value_t::number_float);
-  }
-
-  /*!
-    @brief return whether value is an object
-
-    This function returns true if and only if the JSON value is an object.
-
-    @return `true` if type is object, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_object()` for all JSON
-    types.,is_object}
-
-    @since version 1.0.0
-    */
-  constexpr bool is_object() const noexcept
-  {
-    return (m_type == value_t::object);
-  }
-
-  /*!
-    @brief return whether value is an array
-
-    This function returns true if and only if the JSON value is an array.
-
-    @return `true` if type is array, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_array()` for all JSON
-    types.,is_array}
-
-    @since version 1.0.0
-    */
-  constexpr bool is_array() const noexcept
-  {
-    return (m_type == value_t::array);
-  }
-
-  /*!
-    @brief return whether value is a string
-
-    This function returns true if and only if the JSON value is a string.
-
-    @return `true` if type is string, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_string()` for all JSON
-    types.,is_string}
-
-    @since version 1.0.0
-    */
-  constexpr bool is_string() const noexcept
-  {
-    return (m_type == value_t::string);
-  }
-
-  /*!
-    @brief return whether value is discarded
-
-    This function returns true if and only if the JSON value was discarded
-    during parsing with a callback function (see @ref parser_callback_t).
-
-    @note This function will always be `false` for JSON values after parsing.
-    That is, discarded values can only occur during parsing, but will be
-    removed when inside a structured value or replaced by null in other cases.
-
-    @return `true` if type is discarded, `false` otherwise.
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies `is_discarded()` for all JSON
-    types.,is_discarded}
-
-    @since version 1.0.0
-    */
-  constexpr bool is_discarded() const noexcept
-  {
-    return (m_type == value_t::discarded);
-  }
-
-  /*!
-    @brief return the type of the JSON value (implicit)
-
-    Implicitly return the type of the JSON value as a value from the @ref
-    value_t enumeration.
-
-    @return the type of the JSON value
-
-    @complexity Constant.
-
-    @exceptionsafety No-throw guarantee: this member function never throws
-    exceptions.
-
-    @liveexample{The following code exemplifies the @ref value_t operator for
-    all JSON types.,operator__value_t}
-
-    @sa @ref type() -- return the type of the JSON value (explicit)
-    @sa @ref type_name() -- return the type as string
-
-    @since version 1.0.0
-    */
-  constexpr operator value_t() const noexcept
-  {
-    return m_type;
-  }
-
-  /// @}
-
- private:
-  //////////////////
-  // value access //
-  //////////////////
-
-  /// get a boolean (explicit)
-  boolean_t get_impl(boolean_t* /*unused*/) const
-  {
-    if (JSON_LIKELY(is_boolean())) {
-      return m_value.boolean;
-    }
-
-    JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
-  }
-
-  /// get a pointer to the value (object)
-  object_t* get_impl_ptr(object_t* /*unused*/) noexcept
-  {
-    return is_object() ? m_value.object : nullptr;
-  }
-
-  /// get a pointer to the value (object)
-  constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
-  {
-    return is_object() ? m_value.object : nullptr;
-  }
-
-  /// get a pointer to the value (array)
-  array_t* get_impl_ptr(array_t* /*unused*/) noexcept
-  {
-    return is_array() ? m_value.array : nullptr;
-  }
-
-  /// get a pointer to the value (array)
-  constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
-  {
-    return is_array() ? m_value.array : nullptr;
-  }
-
-  /// get a pointer to the value (string)
-  string_t* get_impl_ptr(string_t* /*unused*/) noexcept
-  {
-    return is_string() ? m_value.string : nullptr;
-  }
-
-  /// get a pointer to the value (string)
-  constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
-  {
-    return is_string() ? m_value.string : nullptr;
-  }
-
-  /// get a pointer to the value (boolean)
-  boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
-  {
-    return is_boolean() ? &m_value.boolean : nullptr;
-  }
-
-  /// get a pointer to the value (boolean)
-  constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
-  {
-    return is_boolean() ? &m_value.boolean : nullptr;
-  }
-
-  /// get a pointer to the value (integer number)
-  number_integer_t* get_impl_ptr(number_integer_t* /*unused*/) noexcept
-  {
-    return is_number_integer() ? &m_value.number_integer : nullptr;
-  }
-
-  /// get a pointer to the value (integer number)
-  constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
-  {
-    return is_number_integer() ? &m_value.number_integer : nullptr;
-  }
-
-  /// get a pointer to the value (unsigned number)
-  number_unsigned_t* get_impl_ptr(number_unsigned_t* /*unused*/) noexcept
-  {
-    return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
-  }
-
-  /// get a pointer to the value (unsigned number)
-  constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
-  {
-    return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
-  }
-
-  /// get a pointer to the value (floating-point number)
-  number_float_t* get_impl_ptr(number_float_t* /*unused*/) noexcept
-  {
-    return is_number_float() ? &m_value.number_float : nullptr;
-  }
-
-  /// get a pointer to the value (floating-point number)
-  constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
-  {
-    return is_number_float() ? &m_value.number_float : nullptr;
-  }
-
-  /*!
-    @brief helper function to implement get_ref()
-
-    This function helps to implement get_ref() without code duplication for
-    const and non-const overloads
-
-    @tparam ThisType will be deduced as `basic_json` or `const basic_json`
-
-    @throw type_error.303 if ReferenceType does not match underlying value
-    type of the current JSON
-    */
-  template <typename ReferenceType, typename ThisType>
-  static ReferenceType get_ref_impl(ThisType& obj)
-  {
-    // delegate the call to get_ptr<>()
-    auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
-
-    if (JSON_LIKELY(ptr != nullptr)) {
-      return *ptr;
-    }
-
-    JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
-  }
-
- public:
-  /// @name value access
-  /// Direct access to the stored value of a JSON value.
-  /// @{
-
-  /*!
-    @brief get special-case overload
-
-    This overloads avoids a lot of template boilerplate, it can be seen as the
-    identity method
-
-    @tparam BasicJsonType == @ref basic_json
-
-    @return a copy of *this
-
-    @complexity Constant.
-
-    @since version 2.1.0
-    */
-  template <typename BasicJsonType, detail::enable_if_t<
-                                      std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
-                                      int> = 0>
-  basic_json get() const
-  {
-    return *this;
-  }
-
-  /*!
-    @brief get special-case overload
-
-    This overloads converts the current @ref basic_json in a different
-    @ref basic_json type
-
-    @tparam BasicJsonType == @ref basic_json
-
-    @return a copy of *this, converted into @tparam BasicJsonType
-
-    @complexity Depending on the implementation of the called `from_json()`
-                method.
-
-    @since version 3.1.2
-    */
-  template <typename BasicJsonType, detail::enable_if_t<
-                                      not std::is_same<BasicJsonType, basic_json>::value and
-                                        detail::is_basic_json<BasicJsonType>::value,
-                                      int> = 0>
-  BasicJsonType get() const
-  {
-    return *this;
-  }
-
-  /*!
-    @brief get a value (explicit)
-
-    Explicit type conversion between the JSON value and a compatible value
-    which is [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible)
-    and [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible).
-    The value is converted by calling the @ref json_serializer<ValueType>
-    `from_json()` method.
-
-    The function is equivalent to executing
-    @code {.cpp}
-    ValueType ret;
-    JSONSerializer<ValueType>::from_json(*this, ret);
-    return ret;
-    @endcode
-
-    This overloads is chosen if:
-    - @a ValueType is not @ref basic_json,
-    - @ref json_serializer<ValueType> has a `from_json()` method of the form
-      `void from_json(const basic_json&, ValueType&)`, and
-    - @ref json_serializer<ValueType> does not have a `from_json()` method of
-      the form `ValueType from_json(const basic_json&)`
-
-    @tparam ValueTypeCV the provided value type
-    @tparam ValueType the returned value type
-
-    @return copy of the JSON value, converted to @a ValueType
-
-    @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
-    @liveexample{The example below shows several conversions from JSON values
-    to other types. There a few things to note: (1) Floating-point numbers can
-    be converted to integers\, (2) A JSON array can be converted to a standard
-    `std::vector<short>`\, (3) A JSON object can be converted to C++
-    associative containers such as `std::unordered_map<std::string\,
-    json>`.,get__ValueType_const}
-
-    @since version 2.1.0
-    */
-  template <typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
-            detail::enable_if_t<
-              not detail::is_basic_json<ValueType>::value and
-                detail::has_from_json<basic_json_t, ValueType>::value and
-                not detail::has_non_default_from_json<basic_json_t, ValueType>::value,
-              int> = 0>
-  ValueType get() const noexcept(noexcept(
-    JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
-  {
-    // we cannot static_assert on ValueTypeCV being non-const, because
-    // there is support for get<const basic_json_t>(), which is why we
-    // still need the uncvref
-    static_assert(not std::is_reference<ValueTypeCV>::value,
-                  "get() cannot be used with reference types, you might want to use get_ref()");
-    static_assert(std::is_default_constructible<ValueType>::value,
-                  "types must be DefaultConstructible when used with get()");
-
-    ValueType ret;
-    JSONSerializer<ValueType>::from_json(*this, ret);
-    return ret;
-  }
-
-  /*!
-    @brief get a value (explicit); special case
-
-    Explicit type conversion between the JSON value and a compatible value
-    which is **not** [CopyConstructible](http://en.cppreference.com/w/cpp/concept/CopyConstructible)
-    and **not** [DefaultConstructible](http://en.cppreference.com/w/cpp/concept/DefaultConstructible).
-    The value is converted by calling the @ref json_serializer<ValueType>
-    `from_json()` method.
-
-    The function is equivalent to executing
-    @code {.cpp}
-    return JSONSerializer<ValueTypeCV>::from_json(*this);
-    @endcode
-
-    This overloads is chosen if:
-    - @a ValueType is not @ref basic_json and
-    - @ref json_serializer<ValueType> has a `from_json()` method of the form
-      `ValueType from_json(const basic_json&)`
-
-    @note If @ref json_serializer<ValueType> has both overloads of
-    `from_json()`, this one is chosen.
-
-    @tparam ValueTypeCV the provided value type
-    @tparam ValueType the returned value type
-
-    @return copy of the JSON value, converted to @a ValueType
-
-    @throw what @ref json_serializer<ValueType> `from_json()` method throws
-
-    @since version 2.1.0
-    */
-  template <typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
-            detail::enable_if_t<not std::is_same<basic_json_t, ValueType>::value and
-                                  detail::has_non_default_from_json<basic_json_t, ValueType>::value,
-                                int> = 0>
-  ValueType get() const noexcept(noexcept(
-    JSONSerializer<ValueTypeCV>::from_json(std::declval<const basic_json_t&>())))
-  {
-    static_assert(not std::is_reference<ValueTypeCV>::value,
-                  "get() cannot be used with reference types, you might want to use get_ref()");
-    return JSONSerializer<ValueTypeCV>::from_json(*this);
-  }
-
-  /*!
-    @brief get a pointer value (explicit)
-
-    Explicit pointer access to the internally stored JSON value. No copies are
-    made.
-
-    @warning The pointer becomes invalid if the underlying JSON object
-    changes.
-
-    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
-    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
-    @ref number_unsigned_t, or @ref number_float_t.
-
-    @return pointer to the internally stored JSON value if the requested
-    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how pointers to internal values of a
-    JSON value can be requested. Note that no type conversions are made and a
-    `nullptr` is returned if the value and the requested pointer type does not
-    match.,get__PointerType}
-
-    @sa @ref get_ptr() for explicit pointer-member access
-
-    @since version 1.0.0
-    */
-  template <typename PointerType, typename std::enable_if<
-                                    std::is_pointer<PointerType>::value, int>::type = 0>
-  PointerType get() noexcept
-  {
-    // delegate the call to get_ptr
-    return get_ptr<PointerType>();
-  }
-
-  /*!
-    @brief get a pointer value (explicit)
-    @copydoc get()
-    */
-  template <typename PointerType, typename std::enable_if<
-                                    std::is_pointer<PointerType>::value, int>::type = 0>
-  constexpr const PointerType get() const noexcept
-  {
-    // delegate the call to get_ptr
-    return get_ptr<PointerType>();
-  }
-
-  /*!
-    @brief get a pointer value (implicit)
-
-    Implicit pointer access to the internally stored JSON value. No copies are
-    made.
-
-    @warning Writing data to the pointee of the result yields an undefined
-    state.
-
-    @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
-    object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
-    @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
-    assertion.
-
-    @return pointer to the internally stored JSON value if the requested
-    pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how pointers to internal values of a
-    JSON value can be requested. Note that no type conversions are made and a
-    `nullptr` is returned if the value and the requested pointer type does not
-    match.,get_ptr}
-
-    @since version 1.0.0
-    */
-  template <typename PointerType, typename std::enable_if<
-                                    std::is_pointer<PointerType>::value, int>::type = 0>
-  PointerType get_ptr() noexcept
-  {
-    // get the type of the PointerType (remove pointer and const)
-    using pointee_t = typename std::remove_const<typename std::remove_pointer<typename std::remove_const<PointerType>::type>::type>::type;
-    // make sure the type matches the allowed types
-    static_assert(
-      std::is_same<object_t, pointee_t>::value or std::is_same<array_t, pointee_t>::value or std::is_same<string_t, pointee_t>::value or std::is_same<boolean_t, pointee_t>::value or std::is_same<number_integer_t, pointee_t>::value or std::is_same<number_unsigned_t, pointee_t>::value or std::is_same<number_float_t, pointee_t>::value, "incompatible pointer type");
-
-    // delegate the call to get_impl_ptr<>()
-    return get_impl_ptr(static_cast<PointerType>(nullptr));
-  }
-
-  /*!
-    @brief get a pointer value (implicit)
-    @copydoc get_ptr()
-    */
-  template <typename PointerType, typename std::enable_if<
-                                    std::is_pointer<PointerType>::value and
-                                      std::is_const<typename std::remove_pointer<PointerType>::type>::value,
-                                    int>::type = 0>
-  constexpr const PointerType get_ptr() const noexcept
-  {
-    // get the type of the PointerType (remove pointer and const)
-    using pointee_t = typename std::remove_const<typename std::remove_pointer<typename std::remove_const<PointerType>::type>::type>::type;
-    // make sure the type matches the allowed types
-    static_assert(
-      std::is_same<object_t, pointee_t>::value or std::is_same<array_t, pointee_t>::value or std::is_same<string_t, pointee_t>::value or std::is_same<boolean_t, pointee_t>::value or std::is_same<number_integer_t, pointee_t>::value or std::is_same<number_unsigned_t, pointee_t>::value or std::is_same<number_float_t, pointee_t>::value, "incompatible pointer type");
-
-    // delegate the call to get_impl_ptr<>() const
-    return get_impl_ptr(static_cast<PointerType>(nullptr));
-  }
-
-  /*!
-    @brief get a reference value (implicit)
-
-    Implicit reference access to the internally stored JSON value. No copies
-    are made.
-
-    @warning Writing data to the referee of the result yields an undefined
-    state.
-
-    @tparam ReferenceType reference type; must be a reference to @ref array_t,
-    @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
-    @ref number_float_t. Enforced by static assertion.
-
-    @return reference to the internally stored JSON value if the requested
-    reference type @a ReferenceType fits to the JSON value; throws
-    type_error.303 otherwise
-
-    @throw type_error.303 in case passed type @a ReferenceType is incompatible
-    with the stored JSON value; see example below
-
-    @complexity Constant.
-
-    @liveexample{The example shows several calls to `get_ref()`.,get_ref}
-
-    @since version 1.1.0
-    */
-  template <typename ReferenceType, typename std::enable_if<
-                                      std::is_reference<ReferenceType>::value, int>::type = 0>
-  ReferenceType get_ref()
-  {
-    // delegate call to get_ref_impl
-    return get_ref_impl<ReferenceType>(*this);
-  }
-
-  /*!
-    @brief get a reference value (implicit)
-    @copydoc get_ref()
-    */
-  template <typename ReferenceType, typename std::enable_if<
-                                      std::is_reference<ReferenceType>::value and
-                                        std::is_const<typename std::remove_reference<ReferenceType>::type>::value,
-                                      int>::type = 0>
-  ReferenceType get_ref() const
-  {
-    // delegate call to get_ref_impl
-    return get_ref_impl<ReferenceType>(*this);
-  }
-
-  /*!
-    @brief get a value (implicit)
-
-    Implicit type conversion between the JSON value and a compatible value.
-    The call is realized by calling @ref get() const.
-
-    @tparam ValueType non-pointer type compatible to the JSON value, for
-    instance `int` for JSON integer numbers, `bool` for JSON booleans, or
-    `std::vector` types for JSON arrays. The character type of @ref string_t
-    as well as an initializer list of this type is excluded to avoid
-    ambiguities as these types implicitly convert to `std::string`.
-
-    @return copy of the JSON value, converted to type @a ValueType
-
-    @throw type_error.302 in case passed type @a ValueType is incompatible
-    to the JSON value type (e.g., the JSON value is of type boolean, but a
-    string is requested); see example below
-
-    @complexity Linear in the size of the JSON value.
-
-    @liveexample{The example below shows several conversions from JSON values
-    to other types. There a few things to note: (1) Floating-point numbers can
-    be converted to integers\, (2) A JSON array can be converted to a standard
-    `std::vector<short>`\, (3) A JSON object can be converted to C++
-    associative containers such as `std::unordered_map<std::string\,
-    json>`.,operator__ValueType}
-
-    @since version 1.0.0
-    */
-  template <typename ValueType, typename std::enable_if<
-                                  not std::is_pointer<ValueType>::value and
-                                    not std::is_same<ValueType, detail::json_ref<basic_json>>::value and
-                                    not std::is_same<ValueType, typename string_t::value_type>::value and
-                                    not detail::is_basic_json<ValueType>::value
-#ifndef _MSC_VER // fix for issue #167 operator<< ambiguity under VS2015
-                                    and not std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
-#endif
-#if defined(JSON_HAS_CPP_17)
-                                    and not std::is_same<ValueType, typename std::string_view>::value
-#endif
-                                  ,
-                                  int>::type = 0>
-  operator ValueType() const
-  {
-    // delegate the call to get<>() const
-    return get<ValueType>();
-  }
-
-  /// @}
-
-  ////////////////////
-  // element access //
-  ////////////////////
-
-  /// @name element access
-  /// Access to the JSON value.
-  /// @{
-
-  /*!
-    @brief access specified array element with bounds checking
-
-    Returns a reference to the element at specified location @a idx, with
-    bounds checking.
-
-    @param[in] idx  index of the element to access
-
-    @return reference to the element at index @a idx
-
-    @throw type_error.304 if the JSON value is not an array; in this case,
-    calling `at` with an index makes no sense. See example below.
-    @throw out_of_range.401 if the index @a idx is out of range of the array;
-    that is, `idx >= size()`. See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 1.0.0
-
-    @liveexample{The example below shows how array elements can be read and
-    written using `at()`. It also demonstrates the different exceptions that
-    can be thrown.,at__size_type}
-    */
-  reference at(size_type idx)
-  {
-    // at only works for arrays
-    if (JSON_LIKELY(is_array())) {
-      JSON_TRY
-      {
-        return m_value.array->at(idx);
-      }
-      JSON_CATCH(std::out_of_range&)
-      {
-        // create better exception explanation
-        JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
-      }
-    } else {
-      JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
-    }
-  }
-
-  /*!
-    @brief access specified array element with bounds checking
-
-    Returns a const reference to the element at specified location @a idx,
-    with bounds checking.
-
-    @param[in] idx  index of the element to access
-
-    @return const reference to the element at index @a idx
-
-    @throw type_error.304 if the JSON value is not an array; in this case,
-    calling `at` with an index makes no sense. See example below.
-    @throw out_of_range.401 if the index @a idx is out of range of the array;
-    that is, `idx >= size()`. See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 1.0.0
-
-    @liveexample{The example below shows how array elements can be read using
-    `at()`. It also demonstrates the different exceptions that can be thrown.,
-    at__size_type_const}
-    */
-  const_reference at(size_type idx) const
-  {
-    // at only works for arrays
-    if (JSON_LIKELY(is_array())) {
-      JSON_TRY
-      {
-        return m_value.array->at(idx);
-      }
-      JSON_CATCH(std::out_of_range&)
-      {
-        // create better exception explanation
-        JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
-      }
-    } else {
-      JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
-    }
-  }
-
-  /*!
-    @brief access specified object element with bounds checking
-
-    Returns a reference to the element at with specified key @a key, with
-    bounds checking.
-
-    @param[in] key  key of the element to access
-
-    @return reference to the element at key @a key
-
-    @throw type_error.304 if the JSON value is not an object; in this case,
-    calling `at` with a key makes no sense. See example below.
-    @throw out_of_range.403 if the key @a key is is not stored in the object;
-    that is, `find(key) == end()`. See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Logarithmic in the size of the container.
-
-    @sa @ref operator[](const typename object_t::key_type&) for unchecked
-    access by reference
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.0.0
-
-    @liveexample{The example below shows how object elements can be read and
-    written using `at()`. It also demonstrates the different exceptions that
-    can be thrown.,at__object_t_key_type}
-    */
-  reference at(const typename object_t::key_type& key)
-  {
-    // at only works for objects
-    if (JSON_LIKELY(is_object())) {
-      JSON_TRY
-      {
-        return m_value.object->at(key);
-      }
-      JSON_CATCH(std::out_of_range&)
-      {
-        // create better exception explanation
-        JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
-      }
-    } else {
-      JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
-    }
-  }
-
-  /*!
-    @brief access specified object element with bounds checking
-
-    Returns a const reference to the element at with specified key @a key,
-    with bounds checking.
-
-    @param[in] key  key of the element to access
-
-    @return const reference to the element at key @a key
-
-    @throw type_error.304 if the JSON value is not an object; in this case,
-    calling `at` with a key makes no sense. See example below.
-    @throw out_of_range.403 if the key @a key is is not stored in the object;
-    that is, `find(key) == end()`. See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Logarithmic in the size of the container.
-
-    @sa @ref operator[](const typename object_t::key_type&) for unchecked
-    access by reference
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.0.0
-
-    @liveexample{The example below shows how object elements can be read using
-    `at()`. It also demonstrates the different exceptions that can be thrown.,
-    at__object_t_key_type_const}
-    */
-  const_reference at(const typename object_t::key_type& key) const
-  {
-    // at only works for objects
-    if (JSON_LIKELY(is_object())) {
-      JSON_TRY
-      {
-        return m_value.object->at(key);
-      }
-      JSON_CATCH(std::out_of_range&)
-      {
-        // create better exception explanation
-        JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
-      }
-    } else {
-      JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
-    }
-  }
-
-  /*!
-    @brief access specified array element
-
-    Returns a reference to the element at specified location @a idx.
-
-    @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
-    then the array is silently filled up with `null` values to make `idx` a
-    valid reference to the last stored element.
-
-    @param[in] idx  index of the element to access
-
-    @return reference to the element at index @a idx
-
-    @throw type_error.305 if the JSON value is not an array or null; in that
-    cases, using the [] operator with an index makes no sense.
-
-    @complexity Constant if @a idx is in the range of the array. Otherwise
-    linear in `idx - size()`.
-
-    @liveexample{The example below shows how array elements can be read and
-    written using `[]` operator. Note the addition of `null`
-    values.,operatorarray__size_type}
-
-    @since version 1.0.0
-    */
-  reference operator[](size_type idx)
-  {
-    // implicitly convert null value to an empty array
-    if (is_null()) {
-      m_type = value_t::array;
-      m_value.array = create<array_t>();
-      assert_invariant();
-    }
-
-    // operator[] only works for arrays
-    if (JSON_LIKELY(is_array())) {
-      // fill up array with null values if given idx is outside range
-      if (idx >= m_value.array->size()) {
-        m_value.array->insert(m_value.array->end(),
-                              idx - m_value.array->size() + 1,
-                              basic_json());
-      }
-
-      return m_value.array->operator[](idx);
-    }
-
-    JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief access specified array element
-
-    Returns a const reference to the element at specified location @a idx.
-
-    @param[in] idx  index of the element to access
-
-    @return const reference to the element at index @a idx
-
-    @throw type_error.305 if the JSON value is not an array; in that case,
-    using the [] operator with an index makes no sense.
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how array elements can be read using
-    the `[]` operator.,operatorarray__size_type_const}
-
-    @since version 1.0.0
-    */
-  const_reference operator[](size_type idx) const
-  {
-    // const operator[] only works for arrays
-    if (JSON_LIKELY(is_array())) {
-      return m_value.array->operator[](idx);
-    }
-
-    JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief access specified object element
-
-    Returns a reference to the element at with specified key @a key.
-
-    @note If @a key is not found in the object, then it is silently added to
-    the object and filled with a `null` value to make `key` a valid reference.
-    In case the value was `null` before, it is converted to an object.
-
-    @param[in] key  key of the element to access
-
-    @return reference to the element at key @a key
-
-    @throw type_error.305 if the JSON value is not an object or null; in that
-    cases, using the [] operator with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be read and
-    written using the `[]` operator.,operatorarray__key_type}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.0.0
-    */
-  reference operator[](const typename object_t::key_type& key)
-  {
-    // implicitly convert null value to an empty object
-    if (is_null()) {
-      m_type = value_t::object;
-      m_value.object = create<object_t>();
-      assert_invariant();
-    }
-
-    // operator[] only works for objects
-    if (JSON_LIKELY(is_object())) {
-      return m_value.object->operator[](key);
-    }
-
-    JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief read-only access specified object element
-
-    Returns a const reference to the element at with specified key @a key. No
-    bounds checking is performed.
-
-    @warning If the element with key @a key does not exist, the behavior is
-    undefined.
-
-    @param[in] key  key of the element to access
-
-    @return const reference to the element at key @a key
-
-    @pre The element with key @a key must exist. **This precondition is
-         enforced with an assertion.**
-
-    @throw type_error.305 if the JSON value is not an object; in that case,
-    using the [] operator with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be read using
-    the `[]` operator.,operatorarray__key_type_const}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.0.0
-    */
-  const_reference operator[](const typename object_t::key_type& key) const
-  {
-    // const operator[] only works for objects
-    if (JSON_LIKELY(is_object())) {
-      assert(m_value.object->find(key) != m_value.object->end());
-      return m_value.object->find(key)->second;
-    }
-
-    JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief access specified object element
-
-    Returns a reference to the element at with specified key @a key.
-
-    @note If @a key is not found in the object, then it is silently added to
-    the object and filled with a `null` value to make `key` a valid reference.
-    In case the value was `null` before, it is converted to an object.
-
-    @param[in] key  key of the element to access
-
-    @return reference to the element at key @a key
-
-    @throw type_error.305 if the JSON value is not an object or null; in that
-    cases, using the [] operator with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be read and
-    written using the `[]` operator.,operatorarray__key_type}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.1.0
-    */
-  template <typename T>
-  reference operator[](T* key)
-  {
-    // implicitly convert null to object
-    if (is_null()) {
-      m_type = value_t::object;
-      m_value = value_t::object;
-      assert_invariant();
-    }
-
-    // at only works for objects
-    if (JSON_LIKELY(is_object())) {
-      return m_value.object->operator[](key);
-    }
-
-    JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief read-only access specified object element
-
-    Returns a const reference to the element at with specified key @a key. No
-    bounds checking is performed.
-
-    @warning If the element with key @a key does not exist, the behavior is
-    undefined.
-
-    @param[in] key  key of the element to access
-
-    @return const reference to the element at key @a key
-
-    @pre The element with key @a key must exist. **This precondition is
-         enforced with an assertion.**
-
-    @throw type_error.305 if the JSON value is not an object; in that case,
-    using the [] operator with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be read using
-    the `[]` operator.,operatorarray__key_type_const}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref value() for access by value with a default value
-
-    @since version 1.1.0
-    */
-  template <typename T>
-  const_reference operator[](T* key) const
-  {
-    // at only works for objects
-    if (JSON_LIKELY(is_object())) {
-      assert(m_value.object->find(key) != m_value.object->end());
-      return m_value.object->find(key)->second;
-    }
-
-    JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief access specified object element with default value
-
-    Returns either a copy of an object's element at the specified key @a key
-    or a given default value if no element with key @a key exists.
-
-    The function is basically equivalent to executing
-    @code {.cpp}
-    try {
-        return at(key);
-    } catch(out_of_range) {
-        return default_value;
-    }
-    @endcode
-
-    @note Unlike @ref at(const typename object_t::key_type&), this function
-    does not throw if the given key @a key was not found.
-
-    @note Unlike @ref operator[](const typename object_t::key_type& key), this
-    function does not implicitly add an element to the position defined by @a
-    key. This function is furthermore also applicable to const objects.
-
-    @param[in] key  key of the element to access
-    @param[in] default_value  the value to return if @a key is not found
-
-    @tparam ValueType type compatible to JSON values, for instance `int` for
-    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
-    JSON arrays. Note the type of the expected value at @a key and the default
-    value @a default_value must be compatible.
-
-    @return copy of the element at key @a key or @a default_value if @a key
-    is not found
-
-    @throw type_error.306 if the JSON value is not an object; in that case,
-    using `value()` with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be queried
-    with a default value.,basic_json__value}
-
-    @sa @ref at(const typename object_t::key_type&) for access by reference
-    with range checking
-    @sa @ref operator[](const typename object_t::key_type&) for unchecked
-    access by reference
-
-    @since version 1.0.0
-    */
-  template <class ValueType, typename std::enable_if<
-                               std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
-  ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
-  {
-    // at only works for objects
-    if (JSON_LIKELY(is_object())) {
-      // if key is found, return value and given default value otherwise
-      const auto it = find(key);
-      if (it != end()) {
-        return *it;
-      }
-
-      return default_value;
-    }
-
-    JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief overload for a default value of type const char*
-    @copydoc basic_json::value(const typename object_t::key_type&, ValueType) const
-    */
-  string_t value(const typename object_t::key_type& key, const char* default_value) const
-  {
-    return value(key, string_t(default_value));
-  }
-
-  /*!
-    @brief access specified object element via JSON Pointer with default value
-
-    Returns either a copy of an object's element at the specified key @a key
-    or a given default value if no element with key @a key exists.
-
-    The function is basically equivalent to executing
-    @code {.cpp}
-    try {
-        return at(ptr);
-    } catch(out_of_range) {
-        return default_value;
-    }
-    @endcode
-
-    @note Unlike @ref at(const json_pointer&), this function does not throw
-    if the given key @a key was not found.
-
-    @param[in] ptr  a JSON pointer to the element to access
-    @param[in] default_value  the value to return if @a ptr found no value
-
-    @tparam ValueType type compatible to JSON values, for instance `int` for
-    JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
-    JSON arrays. Note the type of the expected value at @a key and the default
-    value @a default_value must be compatible.
-
-    @return copy of the element at key @a key or @a default_value if @a key
-    is not found
-
-    @throw type_error.306 if the JSON value is not an objec; in that case,
-    using `value()` with a key makes no sense.
-
-    @complexity Logarithmic in the size of the container.
-
-    @liveexample{The example below shows how object elements can be queried
-    with a default value.,basic_json__value_ptr}
-
-    @sa @ref operator[](const json_pointer&) for unchecked access by reference
-
-    @since version 2.0.2
-    */
-  template <class ValueType, typename std::enable_if<
-                               std::is_convertible<basic_json_t, ValueType>::value, int>::type = 0>
-  ValueType value(const json_pointer& ptr, const ValueType& default_value) const
-  {
-    // at only works for objects
-    if (JSON_LIKELY(is_object())) {
-      // if pointer resolves a value, return it or use default value
-      JSON_TRY
-      {
-        return ptr.get_checked(this);
-      }
-      JSON_CATCH(out_of_range&)
-      {
-        return default_value;
-      }
-    }
-
-    JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief overload for a default value of type const char*
-    @copydoc basic_json::value(const json_pointer&, ValueType) const
-    */
-  string_t value(const json_pointer& ptr, const char* default_value) const
-  {
-    return value(ptr, string_t(default_value));
-  }
-
-  /*!
-    @brief access the first element
-
-    Returns a reference to the first element in the container. For a JSON
-    container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
-
-    @return In case of a structured type (array or object), a reference to the
-    first element is returned. In case of number, string, or boolean values, a
-    reference to the value is returned.
-
-    @complexity Constant.
-
-    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
-    or an empty array or object (undefined behavior, **guarded by
-    assertions**).
-    @post The JSON value remains unchanged.
-
-    @throw invalid_iterator.214 when called on `null` value
-
-    @liveexample{The following code shows an example for `front()`.,front}
-
-    @sa @ref back() -- access the last element
-
-    @since version 1.0.0
-    */
-  reference front()
-  {
-    return *begin();
-  }
-
-  /*!
-    @copydoc basic_json::front()
-    */
-  const_reference front() const
-  {
-    return *cbegin();
-  }
-
-  /*!
-    @brief access the last element
-
-    Returns a reference to the last element in the container. For a JSON
-    container `c`, the expression `c.back()` is equivalent to
-    @code {.cpp}
-    auto tmp = c.end();
-    --tmp;
-    return *tmp;
-    @endcode
-
-    @return In case of a structured type (array or object), a reference to the
-    last element is returned. In case of number, string, or boolean values, a
-    reference to the value is returned.
-
-    @complexity Constant.
-
-    @pre The JSON value must not be `null` (would throw `std::out_of_range`)
-    or an empty array or object (undefined behavior, **guarded by
-    assertions**).
-    @post The JSON value remains unchanged.
-
-    @throw invalid_iterator.214 when called on a `null` value. See example
-    below.
-
-    @liveexample{The following code shows an example for `back()`.,back}
-
-    @sa @ref front() -- access the first element
-
-    @since version 1.0.0
-    */
-  reference back()
-  {
-    auto tmp = end();
-    --tmp;
-    return *tmp;
-  }
-
-  /*!
-    @copydoc basic_json::back()
-    */
-  const_reference back() const
-  {
-    auto tmp = cend();
-    --tmp;
-    return *tmp;
-  }
-
-  /*!
-    @brief remove element given an iterator
-
-    Removes the element specified by iterator @a pos. The iterator @a pos must
-    be valid and dereferenceable. Thus the `end()` iterator (which is valid,
-    but is not dereferenceable) cannot be used as a value for @a pos.
-
-    If called on a primitive type other than `null`, the resulting JSON value
-    will be `null`.
-
-    @param[in] pos iterator to the element to remove
-    @return Iterator following the last removed element. If the iterator @a
-    pos refers to the last element, the `end()` iterator is returned.
-
-    @tparam IteratorType an @ref iterator or @ref const_iterator
-
-    @post Invalidates iterators and references at or after the point of the
-    erase, including the `end()` iterator.
-
-    @throw type_error.307 if called on a `null` value; example: `"cannot use
-    erase() with null"`
-    @throw invalid_iterator.202 if called on an iterator which does not belong
-    to the current JSON value; example: `"iterator does not fit current
-    value"`
-    @throw invalid_iterator.205 if called on a primitive type with invalid
-    iterator (i.e., any iterator which is not `begin()`); example: `"iterator
-    out of range"`
-
-    @complexity The complexity depends on the type:
-    - objects: amortized constant
-    - arrays: linear in distance between @a pos and the end of the container
-    - strings: linear in the length of the string
-    - other types: constant
-
-    @liveexample{The example shows the result of `erase()` for different JSON
-    types.,erase__IteratorType}
-
-    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
-    the given range
-    @sa @ref erase(const typename object_t::key_type&) -- removes the element
-    from an object at the given key
-    @sa @ref erase(const size_type) -- removes the element from an array at
-    the given index
-
-    @since version 1.0.0
-    */
-  template <class IteratorType, typename std::enable_if<
-                                  std::is_same<IteratorType, typename basic_json_t::iterator>::value or
-                                    std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
-                                  int>::type = 0>
-  IteratorType erase(IteratorType pos)
-  {
-    // make sure iterator fits the current value
-    if (JSON_UNLIKELY(this != pos.m_object)) {
-      JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-    }
-
-    IteratorType result = end();
-
-    switch (m_type) {
-      case value_t::boolean:
-      case value_t::number_float:
-      case value_t::number_integer:
-      case value_t::number_unsigned:
-      case value_t::string: {
-        if (JSON_UNLIKELY(not pos.m_it.primitive_iterator.is_begin())) {
-          JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
-        }
-
-        if (is_string()) {
-          AllocatorType<string_t> alloc;
-          std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
-          std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
-          m_value.string = nullptr;
-        }
-
-        m_type = value_t::null;
-        assert_invariant();
-        break;
-      }
-
-      case value_t::object: {
-        result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
-        break;
-      }
-
-      case value_t::array: {
-        result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
-        break;
-      }
-
-      default:
-        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
-    }
-
-    return result;
-  }
-
-  /*!
-    @brief remove elements given an iterator range
-
-    Removes the element specified by the range `[first; last)`. The iterator
-    @a first does not need to be dereferenceable if `first == last`: erasing
-    an empty range is a no-op.
-
-    If called on a primitive type other than `null`, the resulting JSON value
-    will be `null`.
-
-    @param[in] first iterator to the beginning of the range to remove
-    @param[in] last iterator past the end of the range to remove
-    @return Iterator following the last removed element. If the iterator @a
-    second refers to the last element, the `end()` iterator is returned.
-
-    @tparam IteratorType an @ref iterator or @ref const_iterator
-
-    @post Invalidates iterators and references at or after the point of the
-    erase, including the `end()` iterator.
-
-    @throw type_error.307 if called on a `null` value; example: `"cannot use
-    erase() with null"`
-    @throw invalid_iterator.203 if called on iterators which does not belong
-    to the current JSON value; example: `"iterators do not fit current value"`
-    @throw invalid_iterator.204 if called on a primitive type with invalid
-    iterators (i.e., if `first != begin()` and `last != end()`); example:
-    `"iterators out of range"`
-
-    @complexity The complexity depends on the type:
-    - objects: `log(size()) + std::distance(first, last)`
-    - arrays: linear in the distance between @a first and @a last, plus linear
-      in the distance between @a last and end of the container
-    - strings: linear in the length of the string
-    - other types: constant
-
-    @liveexample{The example shows the result of `erase()` for different JSON
-    types.,erase__IteratorType_IteratorType}
-
-    @sa @ref erase(IteratorType) -- removes the element at a given position
-    @sa @ref erase(const typename object_t::key_type&) -- removes the element
-    from an object at the given key
-    @sa @ref erase(const size_type) -- removes the element from an array at
-    the given index
-
-    @since version 1.0.0
-    */
-  template <class IteratorType, typename std::enable_if<
-                                  std::is_same<IteratorType, typename basic_json_t::iterator>::value or
-                                    std::is_same<IteratorType, typename basic_json_t::const_iterator>::value,
-                                  int>::type = 0>
-  IteratorType erase(IteratorType first, IteratorType last)
-  {
-    // make sure iterator fits the current value
-    if (JSON_UNLIKELY(this != first.m_object or this != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
-    }
-
-    IteratorType result = end();
-
-    switch (m_type) {
-      case value_t::boolean:
-      case value_t::number_float:
-      case value_t::number_integer:
-      case value_t::number_unsigned:
-      case value_t::string: {
-        if (JSON_LIKELY(not first.m_it.primitive_iterator.is_begin() or not last.m_it.primitive_iterator.is_end())) {
-          JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
-        }
-
-        if (is_string()) {
-          AllocatorType<string_t> alloc;
-          std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
-          std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
-          m_value.string = nullptr;
-        }
-
-        m_type = value_t::null;
-        assert_invariant();
-        break;
-      }
-
-      case value_t::object: {
-        result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
-                                                            last.m_it.object_iterator);
-        break;
-      }
-
-      case value_t::array: {
-        result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
-                                                          last.m_it.array_iterator);
-        break;
-      }
-
-      default:
-        JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
-    }
-
-    return result;
-  }
-
-  /*!
-    @brief remove element from a JSON object given a key
-
-    Removes elements from a JSON object with the key value @a key.
-
-    @param[in] key value of the elements to remove
-
-    @return Number of elements removed. If @a ObjectType is the default
-    `std::map` type, the return value will always be `0` (@a key was not
-    found) or `1` (@a key was found).
-
-    @post References and iterators to the erased elements are invalidated.
-    Other references and iterators are not affected.
-
-    @throw type_error.307 when called on a type other than JSON object;
-    example: `"cannot use erase() with null"`
-
-    @complexity `log(size()) + count(key)`
-
-    @liveexample{The example shows the effect of `erase()`.,erase__key_type}
-
-    @sa @ref erase(IteratorType) -- removes the element at a given position
-    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
-    the given range
-    @sa @ref erase(const size_type) -- removes the element from an array at
-    the given index
-
-    @since version 1.0.0
-    */
-  size_type erase(const typename object_t::key_type& key)
-  {
-    // this erase only works for objects
-    if (JSON_LIKELY(is_object())) {
-      return m_value.object->erase(key);
-    }
-
-    JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief remove element from a JSON array given an index
-
-    Removes element from a JSON array at the index @a idx.
-
-    @param[in] idx index of the element to remove
-
-    @throw type_error.307 when called on a type other than JSON object;
-    example: `"cannot use erase() with null"`
-    @throw out_of_range.401 when `idx >= size()`; example: `"array index 17
-    is out of range"`
-
-    @complexity Linear in distance between @a idx and the end of the container.
-
-    @liveexample{The example shows the effect of `erase()`.,erase__size_type}
-
-    @sa @ref erase(IteratorType) -- removes the element at a given position
-    @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
-    the given range
-    @sa @ref erase(const typename object_t::key_type&) -- removes the element
-    from an object at the given key
-
-    @since version 1.0.0
-    */
-  void erase(const size_type idx)
-  {
-    // this erase only works for arrays
-    if (JSON_LIKELY(is_array())) {
-      if (JSON_UNLIKELY(idx >= size())) {
-        JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
-      }
-
-      m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
-    } else {
-      JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
-    }
-  }
-
-  /// @}
-
-  ////////////
-  // lookup //
-  ////////////
-
-  /// @name lookup
-  /// @{
-
-  /*!
-    @brief find an element in a JSON object
-
-    Finds an element in a JSON object with key equivalent to @a key. If the
-    element is not found or the JSON value is not an object, end() is
-    returned.
-
-    @note This method always returns @ref end() when executed on a JSON type
-          that is not an object.
-
-    @param[in] key key value of the element to search for.
-
-    @return Iterator to an element with key equivalent to @a key. If no such
-    element is found or the JSON value is not an object, past-the-end (see
-    @ref end()) iterator is returned.
-
-    @complexity Logarithmic in the size of the JSON object.
-
-    @liveexample{The example shows how `find()` is used.,find__key_type}
-
-    @since version 1.0.0
-    */
-  template <typename KeyT>
-  iterator find(KeyT&& key)
-  {
-    auto result = end();
-
-    if (is_object()) {
-      result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
-    }
-
-    return result;
-  }
-
-  /*!
-    @brief find an element in a JSON object
-    @copydoc find(KeyT&&)
-    */
-  template <typename KeyT>
-  const_iterator find(KeyT&& key) const
-  {
-    auto result = cend();
-
-    if (is_object()) {
-      result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
-    }
-
-    return result;
-  }
-
-  /*!
-    @brief returns the number of occurrences of a key in a JSON object
-
-    Returns the number of elements with key @a key. If ObjectType is the
-    default `std::map` type, the return value will always be `0` (@a key was
-    not found) or `1` (@a key was found).
-
-    @note This method always returns `0` when executed on a JSON type that is
-          not an object.
-
-    @param[in] key key value of the element to count
-
-    @return Number of elements with key @a key. If the JSON value is not an
-    object, the return value will be `0`.
-
-    @complexity Logarithmic in the size of the JSON object.
-
-    @liveexample{The example shows how `count()` is used.,count}
-
-    @since version 1.0.0
-    */
-  template <typename KeyT>
-  size_type count(KeyT&& key) const
-  {
-    // return 0 for all nonobject types
-    return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
-  }
-
-  /// @}
-
-  ///////////////
-  // iterators //
-  ///////////////
-
-  /// @name iterators
-  /// @{
-
-  /*!
-    @brief returns an iterator to the first element
-
-    Returns an iterator to the first element.
-
-    @image html range-begin-end.svg "Illustration from cppreference.com"
-
-    @return iterator to the first element
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is constant.
-
-    @liveexample{The following code shows an example for `begin()`.,begin}
-
-    @sa @ref cbegin() -- returns a const iterator to the beginning
-    @sa @ref end() -- returns an iterator to the end
-    @sa @ref cend() -- returns a const iterator to the end
-
-    @since version 1.0.0
-    */
-  iterator begin() noexcept
-  {
-    iterator result(this);
-    result.set_begin();
-    return result;
-  }
-
-  /*!
-    @copydoc basic_json::cbegin()
-    */
-  const_iterator begin() const noexcept
-  {
-    return cbegin();
-  }
-
-  /*!
-    @brief returns a const iterator to the first element
-
-    Returns a const iterator to the first element.
-
-    @image html range-begin-end.svg "Illustration from cppreference.com"
-
-    @return const iterator to the first element
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
-
-    @liveexample{The following code shows an example for `cbegin()`.,cbegin}
-
-    @sa @ref begin() -- returns an iterator to the beginning
-    @sa @ref end() -- returns an iterator to the end
-    @sa @ref cend() -- returns a const iterator to the end
-
-    @since version 1.0.0
-    */
-  const_iterator cbegin() const noexcept
-  {
-    const_iterator result(this);
-    result.set_begin();
-    return result;
-  }
-
-  /*!
-    @brief returns an iterator to one past the last element
-
-    Returns an iterator to one past the last element.
-
-    @image html range-begin-end.svg "Illustration from cppreference.com"
-
-    @return iterator one past the last element
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is constant.
-
-    @liveexample{The following code shows an example for `end()`.,end}
-
-    @sa @ref cend() -- returns a const iterator to the end
-    @sa @ref begin() -- returns an iterator to the beginning
-    @sa @ref cbegin() -- returns a const iterator to the beginning
-
-    @since version 1.0.0
-    */
-  iterator end() noexcept
-  {
-    iterator result(this);
-    result.set_end();
-    return result;
-  }
-
-  /*!
-    @copydoc basic_json::cend()
-    */
-  const_iterator end() const noexcept
-  {
-    return cend();
-  }
-
-  /*!
-    @brief returns a const iterator to one past the last element
-
-    Returns a const iterator to one past the last element.
-
-    @image html range-begin-end.svg "Illustration from cppreference.com"
-
-    @return const iterator one past the last element
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
-
-    @liveexample{The following code shows an example for `cend()`.,cend}
-
-    @sa @ref end() -- returns an iterator to the end
-    @sa @ref begin() -- returns an iterator to the beginning
-    @sa @ref cbegin() -- returns a const iterator to the beginning
-
-    @since version 1.0.0
-    */
-  const_iterator cend() const noexcept
-  {
-    const_iterator result(this);
-    result.set_end();
-    return result;
-  }
-
-  /*!
-    @brief returns an iterator to the reverse-beginning
-
-    Returns an iterator to the reverse-beginning; that is, the last element.
-
-    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `reverse_iterator(end())`.
-
-    @liveexample{The following code shows an example for `rbegin()`.,rbegin}
-
-    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
-    @sa @ref rend() -- returns a reverse iterator to the end
-    @sa @ref crend() -- returns a const reverse iterator to the end
-
-    @since version 1.0.0
-    */
-  reverse_iterator rbegin() noexcept
-  {
-    return reverse_iterator(end());
-  }
-
-  /*!
-    @copydoc basic_json::crbegin()
-    */
-  const_reverse_iterator rbegin() const noexcept
-  {
-    return crbegin();
-  }
-
-  /*!
-    @brief returns an iterator to the reverse-end
-
-    Returns an iterator to the reverse-end; that is, one before the first
-    element.
-
-    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `reverse_iterator(begin())`.
-
-    @liveexample{The following code shows an example for `rend()`.,rend}
-
-    @sa @ref crend() -- returns a const reverse iterator to the end
-    @sa @ref rbegin() -- returns a reverse iterator to the beginning
-    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
-
-    @since version 1.0.0
-    */
-  reverse_iterator rend() noexcept
-  {
-    return reverse_iterator(begin());
-  }
-
-  /*!
-    @copydoc basic_json::crend()
-    */
-  const_reverse_iterator rend() const noexcept
-  {
-    return crend();
-  }
-
-  /*!
-    @brief returns a const reverse iterator to the last element
-
-    Returns a const iterator to the reverse-beginning; that is, the last
-    element.
-
-    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
-
-    @liveexample{The following code shows an example for `crbegin()`.,crbegin}
-
-    @sa @ref rbegin() -- returns a reverse iterator to the beginning
-    @sa @ref rend() -- returns a reverse iterator to the end
-    @sa @ref crend() -- returns a const reverse iterator to the end
-
-    @since version 1.0.0
-    */
-  const_reverse_iterator crbegin() const noexcept
-  {
-    return const_reverse_iterator(cend());
-  }
-
-  /*!
-    @brief returns a const reverse iterator to one before the first
-
-    Returns a const reverse iterator to the reverse-end; that is, one before
-    the first element.
-
-    @image html range-rbegin-rend.svg "Illustration from cppreference.com"
-
-    @complexity Constant.
-
-    @requirement This function helps `basic_json` satisfying the
-    [ReversibleContainer](http://en.cppreference.com/w/cpp/concept/ReversibleContainer)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
-
-    @liveexample{The following code shows an example for `crend()`.,crend}
-
-    @sa @ref rend() -- returns a reverse iterator to the end
-    @sa @ref rbegin() -- returns a reverse iterator to the beginning
-    @sa @ref crbegin() -- returns a const reverse iterator to the beginning
-
-    @since version 1.0.0
-    */
-  const_reverse_iterator crend() const noexcept
-  {
-    return const_reverse_iterator(cbegin());
-  }
-
- public:
-  /*!
-    @brief wrapper to access iterator member functions in range-based for
-
-    This function allows to access @ref iterator::key() and @ref
-    iterator::value() during range-based for loops. In these loops, a
-    reference to the JSON values is returned, so there is no access to the
-    underlying iterator.
-
-    For loop without iterator_wrapper:
-
-    @code{cpp}
-    for (auto it = j_object.begin(); it != j_object.end(); ++it)
-    {
-        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
-    }
-    @endcode
-
-    Range-based for loop without iterator proxy:
-
-    @code{cpp}
-    for (auto it : j_object)
-    {
-        // "it" is of type json::reference and has no key() member
-        std::cout << "value: " << it << '\n';
-    }
-    @endcode
-
-    Range-based for loop with iterator proxy:
-
-    @code{cpp}
-    for (auto it : json::iterator_wrapper(j_object))
-    {
-        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
-    }
-    @endcode
-
-    @note When iterating over an array, `key()` will return the index of the
-          element as string (see example).
-
-    @param[in] ref  reference to a JSON value
-    @return iteration proxy object wrapping @a ref with an interface to use in
-            range-based for loops
-
-    @liveexample{The following code shows how the wrapper is used,iterator_wrapper}
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @note The name of this function is not yet final and may change in the
-    future.
-
-    @deprecated This stream operator is deprecated and will be removed in
-                future 4.0.0 of the library. Please use @ref items() instead;
-                that is, replace `json::iterator_wrapper(j)` with `j.items()`.
-    */
-  JSON_DEPRECATED
-  static iteration_proxy<iterator> iterator_wrapper(reference ref) noexcept
-  {
-    return ref.items();
-  }
-
-  /*!
-    @copydoc iterator_wrapper(reference)
-    */
-  JSON_DEPRECATED
-  static iteration_proxy<const_iterator> iterator_wrapper(const_reference ref) noexcept
-  {
-    return ref.items();
-  }
-
-  /*!
-    @brief helper to access iterator member functions in range-based for
-
-    This function allows to access @ref iterator::key() and @ref
-    iterator::value() during range-based for loops. In these loops, a
-    reference to the JSON values is returned, so there is no access to the
-    underlying iterator.
-
-    For loop without `items()` function:
-
-    @code{cpp}
-    for (auto it = j_object.begin(); it != j_object.end(); ++it)
-    {
-        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
-    }
-    @endcode
-
-    Range-based for loop without `items()` function:
-
-    @code{cpp}
-    for (auto it : j_object)
-    {
-        // "it" is of type json::reference and has no key() member
-        std::cout << "value: " << it << '\n';
-    }
-    @endcode
-
-    Range-based for loop with `items()` function:
-
-    @code{cpp}
-    for (auto it : j_object.items())
-    {
-        std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
-    }
-    @endcode
-
-    @note When iterating over an array, `key()` will return the index of the
-          element as string (see example). For primitive types (e.g., numbers),
-          `key()` returns an empty string.
-
-    @return iteration proxy object wrapping @a ref with an interface to use in
-            range-based for loops
-
-    @liveexample{The following code shows how the function is used.,items}
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 3.x.x.
-    */
-  iteration_proxy<iterator> items() noexcept
-  {
-    return iteration_proxy<iterator>(*this);
-  }
-
-  /*!
-    @copydoc items()
-    */
-  iteration_proxy<const_iterator> items() const noexcept
-  {
-    return iteration_proxy<const_iterator>(*this);
-  }
-
-  /// @}
-
-  //////////////
-  // capacity //
-  //////////////
-
-  /// @name capacity
-  /// @{
-
-  /*!
-    @brief checks whether the container is empty.
-
-    Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).
-
-    @return The return value depends on the different types and is
-            defined as follows:
-            Value type  | return value
-            ----------- | -------------
-            null        | `true`
-            boolean     | `false`
-            string      | `false`
-            number      | `false`
-            object      | result of function `object_t::empty()`
-            array       | result of function `array_t::empty()`
-
-    @liveexample{The following code uses `empty()` to check if a JSON
-    object contains any elements.,empty}
-
-    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
-    the Container concept; that is, their `empty()` functions have constant
-    complexity.
-
-    @iterators No changes.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @note This function does not return whether a string stored as JSON value
-    is empty - it returns whether the JSON container itself is empty which is
-    false in the case of a string.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `begin() == end()`.
-
-    @sa @ref size() -- returns the number of elements
-
-    @since version 1.0.0
-    */
-  bool empty() const noexcept
-  {
-    switch (m_type) {
-      case value_t::null: {
-        // null values are empty
-        return true;
-      }
-
-      case value_t::array: {
-        // delegate call to array_t::empty()
-        return m_value.array->empty();
-      }
-
-      case value_t::object: {
-        // delegate call to object_t::empty()
-        return m_value.object->empty();
-      }
-
-      default: {
-        // all other types are nonempty
-        return false;
-      }
-    }
-  }
-
-  /*!
-    @brief returns the number of elements
-
-    Returns the number of elements in a JSON value.
-
-    @return The return value depends on the different types and is
-            defined as follows:
-            Value type  | return value
-            ----------- | -------------
-            null        | `0`
-            boolean     | `1`
-            string      | `1`
-            number      | `1`
-            object      | result of function object_t::size()
-            array       | result of function array_t::size()
-
-    @liveexample{The following code calls `size()` on the different value
-    types.,size}
-
-    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
-    the Container concept; that is, their size() functions have constant
-    complexity.
-
-    @iterators No changes.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @note This function does not return the length of a string stored as JSON
-    value - it returns the number of elements in the JSON value which is 1 in
-    the case of a string.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of `std::distance(begin(), end())`.
-
-    @sa @ref empty() -- checks whether the container is empty
-    @sa @ref max_size() -- returns the maximal number of elements
-
-    @since version 1.0.0
-    */
-  size_type size() const noexcept
-  {
-    switch (m_type) {
-      case value_t::null: {
-        // null values are empty
-        return 0;
-      }
-
-      case value_t::array: {
-        // delegate call to array_t::size()
-        return m_value.array->size();
-      }
-
-      case value_t::object: {
-        // delegate call to object_t::size()
-        return m_value.object->size();
-      }
-
-      default: {
-        // all other types have size 1
-        return 1;
-      }
-    }
-  }
-
-  /*!
-    @brief returns the maximum possible number of elements
-
-    Returns the maximum number of elements a JSON value is able to hold due to
-    system or library implementation limitations, i.e. `std::distance(begin(),
-    end())` for the JSON value.
-
-    @return The return value depends on the different types and is
-            defined as follows:
-            Value type  | return value
-            ----------- | -------------
-            null        | `0` (same as `size()`)
-            boolean     | `1` (same as `size()`)
-            string      | `1` (same as `size()`)
-            number      | `1` (same as `size()`)
-            object      | result of function `object_t::max_size()`
-            array       | result of function `array_t::max_size()`
-
-    @liveexample{The following code calls `max_size()` on the different value
-    types. Note the output is implementation specific.,max_size}
-
-    @complexity Constant, as long as @ref array_t and @ref object_t satisfy
-    the Container concept; that is, their `max_size()` functions have constant
-    complexity.
-
-    @iterators No changes.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @requirement This function helps `basic_json` satisfying the
-    [Container](http://en.cppreference.com/w/cpp/concept/Container)
-    requirements:
-    - The complexity is constant.
-    - Has the semantics of returning `b.size()` where `b` is the largest
-      possible JSON value.
-
-    @sa @ref size() -- returns the number of elements
-
-    @since version 1.0.0
-    */
-  size_type max_size() const noexcept
-  {
-    switch (m_type) {
-      case value_t::array: {
-        // delegate call to array_t::max_size()
-        return m_value.array->max_size();
-      }
-
-      case value_t::object: {
-        // delegate call to object_t::max_size()
-        return m_value.object->max_size();
-      }
-
-      default: {
-        // all other types have max_size() == size()
-        return size();
-      }
-    }
-  }
-
-  /// @}
-
-  ///////////////
-  // modifiers //
-  ///////////////
-
-  /// @name modifiers
-  /// @{
-
-  /*!
-    @brief clears the contents
-
-    Clears the content of a JSON value and resets it to the default value as
-    if @ref basic_json(value_t) would have been called with the current value
-    type from @ref type():
-
-    Value type  | initial value
-    ----------- | -------------
-    null        | `null`
-    boolean     | `false`
-    string      | `""`
-    number      | `0`
-    object      | `{}`
-    array       | `[]`
-
-    @post Has the same effect as calling
-    @code {.cpp}
-    *this = basic_json(type());
-    @endcode
-
-    @liveexample{The example below shows the effect of `clear()` to different
-    JSON types.,clear}
-
-    @complexity Linear in the size of the JSON value.
-
-    @iterators All iterators, pointers and references related to this container
-               are invalidated.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @sa @ref basic_json(value_t) -- constructor that creates an object with the
-        same value than calling `clear()`
-
-    @since version 1.0.0
-    */
-  void clear() noexcept
-  {
-    switch (m_type) {
-      case value_t::number_integer: {
-        m_value.number_integer = 0;
-        break;
-      }
-
-      case value_t::number_unsigned: {
-        m_value.number_unsigned = 0;
-        break;
-      }
-
-      case value_t::number_float: {
-        m_value.number_float = 0.0;
-        break;
-      }
-
-      case value_t::boolean: {
-        m_value.boolean = false;
-        break;
-      }
-
-      case value_t::string: {
-        m_value.string->clear();
-        break;
-      }
-
-      case value_t::array: {
-        m_value.array->clear();
-        break;
-      }
-
-      case value_t::object: {
-        m_value.object->clear();
-        break;
-      }
-
-      default:
-        break;
-    }
-  }
-
-  /*!
-    @brief add an object to an array
-
-    Appends the given element @a val to the end of the JSON value. If the
-    function is called on a JSON null value, an empty array is created before
-    appending @a val.
-
-    @param[in] val the value to add to the JSON array
-
-    @throw type_error.308 when called on a type other than JSON array or
-    null; example: `"cannot use push_back() with number"`
-
-    @complexity Amortized constant.
-
-    @liveexample{The example shows how `push_back()` and `+=` can be used to
-    add elements to a JSON array. Note how the `null` value was silently
-    converted to a JSON array.,push_back}
-
-    @since version 1.0.0
-    */
-  void push_back(basic_json&& val)
-  {
-    // push_back only works for null objects or arrays
-    if (JSON_UNLIKELY(not(is_null() or is_array()))) {
-      JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
-    }
-
-    // transform null object into an array
-    if (is_null()) {
-      m_type = value_t::array;
-      m_value = value_t::array;
-      assert_invariant();
-    }
-
-    // add element to array (move semantics)
-    m_value.array->push_back(std::move(val));
-    // invalidate object
-    val.m_type = value_t::null;
-  }
-
-  /*!
-    @brief add an object to an array
-    @copydoc push_back(basic_json&&)
-    */
-  reference operator+=(basic_json&& val)
-  {
-    push_back(std::move(val));
-    return *this;
-  }
-
-  /*!
-    @brief add an object to an array
-    @copydoc push_back(basic_json&&)
-    */
-  void push_back(const basic_json& val)
-  {
-    // push_back only works for null objects or arrays
-    if (JSON_UNLIKELY(not(is_null() or is_array()))) {
-      JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
-    }
-
-    // transform null object into an array
-    if (is_null()) {
-      m_type = value_t::array;
-      m_value = value_t::array;
-      assert_invariant();
-    }
-
-    // add element to array
-    m_value.array->push_back(val);
-  }
-
-  /*!
-    @brief add an object to an array
-    @copydoc push_back(basic_json&&)
-    */
-  reference operator+=(const basic_json& val)
-  {
-    push_back(val);
-    return *this;
-  }
-
-  /*!
-    @brief add an object to an object
-
-    Inserts the given element @a val to the JSON object. If the function is
-    called on a JSON null value, an empty object is created before inserting
-    @a val.
-
-    @param[in] val the value to add to the JSON object
-
-    @throw type_error.308 when called on a type other than JSON object or
-    null; example: `"cannot use push_back() with number"`
-
-    @complexity Logarithmic in the size of the container, O(log(`size()`)).
-
-    @liveexample{The example shows how `push_back()` and `+=` can be used to
-    add elements to a JSON object. Note how the `null` value was silently
-    converted to a JSON object.,push_back__object_t__value}
-
-    @since version 1.0.0
-    */
-  void push_back(const typename object_t::value_type& val)
-  {
-    // push_back only works for null objects or objects
-    if (JSON_UNLIKELY(not(is_null() or is_object()))) {
-      JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
-    }
-
-    // transform null object into an object
-    if (is_null()) {
-      m_type = value_t::object;
-      m_value = value_t::object;
-      assert_invariant();
-    }
-
-    // add element to array
-    m_value.object->insert(val);
-  }
-
-  /*!
-    @brief add an object to an object
-    @copydoc push_back(const typename object_t::value_type&)
-    */
-  reference operator+=(const typename object_t::value_type& val)
-  {
-    push_back(val);
-    return *this;
-  }
-
-  /*!
-    @brief add an object to an object
-
-    This function allows to use `push_back` with an initializer list. In case
-
-    1. the current value is an object,
-    2. the initializer list @a init contains only two elements, and
-    3. the first element of @a init is a string,
-
-    @a init is converted into an object element and added using
-    @ref push_back(const typename object_t::value_type&). Otherwise, @a init
-    is converted to a JSON value and added using @ref push_back(basic_json&&).
-
-    @param[in] init  an initializer list
-
-    @complexity Linear in the size of the initializer list @a init.
-
-    @note This function is required to resolve an ambiguous overload error,
-          because pairs like `{"key", "value"}` can be both interpreted as
-          `object_t::value_type` or `std::initializer_list<basic_json>`, see
-          https://github.com/nlohmann/json/issues/235 for more information.
-
-    @liveexample{The example shows how initializer lists are treated as
-    objects when possible.,push_back__initializer_list}
-    */
-  void push_back(initializer_list_t init)
-  {
-    if (is_object() and init.size() == 2 and (*init.begin())->is_string()) {
-      basic_json&& key = init.begin()->moved_or_copied();
-      push_back(typename object_t::value_type(
-        std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
-    } else {
-      push_back(basic_json(init));
-    }
-  }
-
-  /*!
-    @brief add an object to an object
-    @copydoc push_back(initializer_list_t)
-    */
-  reference operator+=(initializer_list_t init)
-  {
-    push_back(init);
-    return *this;
-  }
-
-  /*!
-    @brief add an object to an array
-
-    Creates a JSON value from the passed parameters @a args to the end of the
-    JSON value. If the function is called on a JSON null value, an empty array
-    is created before appending the value created from @a args.
-
-    @param[in] args arguments to forward to a constructor of @ref basic_json
-    @tparam Args compatible types to create a @ref basic_json object
-
-    @throw type_error.311 when called on a type other than JSON array or
-    null; example: `"cannot use emplace_back() with number"`
-
-    @complexity Amortized constant.
-
-    @liveexample{The example shows how `push_back()` can be used to add
-    elements to a JSON array. Note how the `null` value was silently converted
-    to a JSON array.,emplace_back}
-
-    @since version 2.0.8
-    */
-  template <class... Args>
-  void emplace_back(Args&&... args)
-  {
-    // emplace_back only works for null objects or arrays
-    if (JSON_UNLIKELY(not(is_null() or is_array()))) {
-      JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
-    }
-
-    // transform null object into an array
-    if (is_null()) {
-      m_type = value_t::array;
-      m_value = value_t::array;
-      assert_invariant();
-    }
-
-    // add element to array (perfect forwarding)
-    m_value.array->emplace_back(std::forward<Args>(args)...);
-  }
-
-  /*!
-    @brief add an object to an object if key does not exist
-
-    Inserts a new element into a JSON object constructed in-place with the
-    given @a args if there is no element with the key in the container. If the
-    function is called on a JSON null value, an empty object is created before
-    appending the value created from @a args.
-
-    @param[in] args arguments to forward to a constructor of @ref basic_json
-    @tparam Args compatible types to create a @ref basic_json object
-
-    @return a pair consisting of an iterator to the inserted element, or the
-            already-existing element if no insertion happened, and a bool
-            denoting whether the insertion took place.
-
-    @throw type_error.311 when called on a type other than JSON object or
-    null; example: `"cannot use emplace() with number"`
-
-    @complexity Logarithmic in the size of the container, O(log(`size()`)).
-
-    @liveexample{The example shows how `emplace()` can be used to add elements
-    to a JSON object. Note how the `null` value was silently converted to a
-    JSON object. Further note how no value is added if there was already one
-    value stored with the same key.,emplace}
-
-    @since version 2.0.8
-    */
-  template <class... Args>
-  std::pair<iterator, bool> emplace(Args&&... args)
-  {
-    // emplace only works for null objects or arrays
-    if (JSON_UNLIKELY(not(is_null() or is_object()))) {
-      JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
-    }
-
-    // transform null object into an object
-    if (is_null()) {
-      m_type = value_t::object;
-      m_value = value_t::object;
-      assert_invariant();
-    }
-
-    // add element to array (perfect forwarding)
-    auto res = m_value.object->emplace(std::forward<Args>(args)...);
-    // create result iterator and set iterator to the result of emplace
-    auto it = begin();
-    it.m_it.object_iterator = res.first;
-
-    // return pair of iterator and boolean
-    return {it, res.second};
-  }
-
-  /*!
-    @brief inserts element
-
-    Inserts element @a val before iterator @a pos.
-
-    @param[in] pos iterator before which the content will be inserted; may be
-    the end() iterator
-    @param[in] val element to insert
-    @return iterator pointing to the inserted @a val.
-
-    @throw type_error.309 if called on JSON values other than arrays;
-    example: `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
-    example: `"iterator does not fit current value"`
-
-    @complexity Constant plus linear in the distance between @a pos and end of
-    the container.
-
-    @liveexample{The example shows how `insert()` is used.,insert}
-
-    @since version 1.0.0
-    */
-  iterator insert(const_iterator pos, const basic_json& val)
-  {
-    // insert only works for arrays
-    if (JSON_LIKELY(is_array())) {
-      // check if iterator pos fits to this JSON value
-      if (JSON_UNLIKELY(pos.m_object != this)) {
-        JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-      }
-
-      // insert to array and return iterator
-      iterator result(this);
-      result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, val);
-      return result;
-    }
-
-    JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief inserts element
-    @copydoc insert(const_iterator, const basic_json&)
-    */
-  iterator insert(const_iterator pos, basic_json&& val)
-  {
-    return insert(pos, val);
-  }
-
-  /*!
-    @brief inserts elements
-
-    Inserts @a cnt copies of @a val before iterator @a pos.
-
-    @param[in] pos iterator before which the content will be inserted; may be
-    the end() iterator
-    @param[in] cnt number of copies of @a val to insert
-    @param[in] val element to insert
-    @return iterator pointing to the first element inserted, or @a pos if
-    `cnt==0`
-
-    @throw type_error.309 if called on JSON values other than arrays; example:
-    `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
-    example: `"iterator does not fit current value"`
-
-    @complexity Linear in @a cnt plus linear in the distance between @a pos
-    and end of the container.
-
-    @liveexample{The example shows how `insert()` is used.,insert__count}
-
-    @since version 1.0.0
-    */
-  iterator insert(const_iterator pos, size_type cnt, const basic_json& val)
-  {
-    // insert only works for arrays
-    if (JSON_LIKELY(is_array())) {
-      // check if iterator pos fits to this JSON value
-      if (JSON_UNLIKELY(pos.m_object != this)) {
-        JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-      }
-
-      // insert to array and return iterator
-      iterator result(this);
-      result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
-      return result;
-    }
-
-    JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-  }
-
-  /*!
-    @brief inserts elements
-
-    Inserts elements from range `[first, last)` before iterator @a pos.
-
-    @param[in] pos iterator before which the content will be inserted; may be
-    the end() iterator
-    @param[in] first begin of the range of elements to insert
-    @param[in] last end of the range of elements to insert
-
-    @throw type_error.309 if called on JSON values other than arrays; example:
-    `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
-    example: `"iterator does not fit current value"`
-    @throw invalid_iterator.210 if @a first and @a last do not belong to the
-    same JSON value; example: `"iterators do not fit"`
-    @throw invalid_iterator.211 if @a first or @a last are iterators into
-    container for which insert is called; example: `"passed iterators may not
-    belong to container"`
-
-    @return iterator pointing to the first element inserted, or @a pos if
-    `first==last`
-
-    @complexity Linear in `std::distance(first, last)` plus linear in the
-    distance between @a pos and end of the container.
-
-    @liveexample{The example shows how `insert()` is used.,insert__range}
-
-    @since version 1.0.0
-    */
-  iterator insert(const_iterator pos, const_iterator first, const_iterator last)
-  {
-    // insert only works for arrays
-    if (JSON_UNLIKELY(not is_array())) {
-      JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-    }
-
-    // check if iterator pos fits to this JSON value
-    if (JSON_UNLIKELY(pos.m_object != this)) {
-      JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-    }
-
-    // check if range iterators belong to the same JSON object
-    if (JSON_UNLIKELY(first.m_object != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
-    }
-
-    if (JSON_UNLIKELY(first.m_object == this)) {
-      JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
-    }
-
-    // insert to array and return iterator
-    iterator result(this);
-    result.m_it.array_iterator = m_value.array->insert(
-      pos.m_it.array_iterator,
-      first.m_it.array_iterator,
-      last.m_it.array_iterator);
-    return result;
-  }
-
-  /*!
-    @brief inserts elements
-
-    Inserts elements from initializer list @a ilist before iterator @a pos.
-
-    @param[in] pos iterator before which the content will be inserted; may be
-    the end() iterator
-    @param[in] ilist initializer list to insert the values from
-
-    @throw type_error.309 if called on JSON values other than arrays; example:
-    `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if @a pos is not an iterator of *this;
-    example: `"iterator does not fit current value"`
-
-    @return iterator pointing to the first element inserted, or @a pos if
-    `ilist` is empty
-
-    @complexity Linear in `ilist.size()` plus linear in the distance between
-    @a pos and end of the container.
-
-    @liveexample{The example shows how `insert()` is used.,insert__ilist}
-
-    @since version 1.0.0
-    */
-  iterator insert(const_iterator pos, initializer_list_t ilist)
-  {
-    // insert only works for arrays
-    if (JSON_UNLIKELY(not is_array())) {
-      JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-    }
-
-    // check if iterator pos fits to this JSON value
-    if (JSON_UNLIKELY(pos.m_object != this)) {
-      JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
-    }
-
-    // insert to array and return iterator
-    iterator result(this);
-    result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, ilist.begin(), ilist.end());
-    return result;
-  }
-
-  /*!
-    @brief inserts elements
-
-    Inserts elements from range `[first, last)`.
-
-    @param[in] first begin of the range of elements to insert
-    @param[in] last end of the range of elements to insert
-
-    @throw type_error.309 if called on JSON values other than objects; example:
-    `"cannot use insert() with string"`
-    @throw invalid_iterator.202 if iterator @a first or @a last does does not
-    point to an object; example: `"iterators first and last must point to
-    objects"`
-    @throw invalid_iterator.210 if @a first and @a last do not belong to the
-    same JSON value; example: `"iterators do not fit"`
-
-    @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number
-    of elements to insert.
-
-    @liveexample{The example shows how `insert()` is used.,insert__range_object}
-
-    @since version 3.0.0
-    */
-  void insert(const_iterator first, const_iterator last)
-  {
-    // insert only works for objects
-    if (JSON_UNLIKELY(not is_object())) {
-      JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
-    }
-
-    // check if range iterators belong to the same JSON object
-    if (JSON_UNLIKELY(first.m_object != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
-    }
-
-    // passed iterators must belong to objects
-    if (JSON_UNLIKELY(not first.m_object->is_object())) {
-      JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
-    }
-
-    m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
-  }
-
-  /*!
-    @brief updates a JSON object from another object, overwriting existing keys
-
-    Inserts all values from JSON object @a j and overwrites existing keys.
-
-    @param[in] j  JSON object to read values from
-
-    @throw type_error.312 if called on JSON values other than objects; example:
-    `"cannot use update() with string"`
-
-    @complexity O(N*log(size() + N)), where N is the number of elements to
-                insert.
-
-    @liveexample{The example shows how `update()` is used.,update}
-
-    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
-
-    @since version 3.0.0
-    */
-  void update(const_reference j)
-  {
-    // implicitly convert null value to an empty object
-    if (is_null()) {
-      m_type = value_t::object;
-      m_value.object = create<object_t>();
-      assert_invariant();
-    }
-
-    if (JSON_UNLIKELY(not is_object())) {
-      JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
-    }
-    if (JSON_UNLIKELY(not j.is_object())) {
-      JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
-    }
-
-    for (auto it = j.cbegin(); it != j.cend(); ++it) {
-      m_value.object->operator[](it.key()) = it.value();
-    }
-  }
-
-  /*!
-    @brief updates a JSON object from another object, overwriting existing keys
-
-    Inserts all values from from range `[first, last)` and overwrites existing
-    keys.
-
-    @param[in] first begin of the range of elements to insert
-    @param[in] last end of the range of elements to insert
-
-    @throw type_error.312 if called on JSON values other than objects; example:
-    `"cannot use update() with string"`
-    @throw invalid_iterator.202 if iterator @a first or @a last does does not
-    point to an object; example: `"iterators first and last must point to
-    objects"`
-    @throw invalid_iterator.210 if @a first and @a last do not belong to the
-    same JSON value; example: `"iterators do not fit"`
-
-    @complexity O(N*log(size() + N)), where N is the number of elements to
-                insert.
-
-    @liveexample{The example shows how `update()` is used__range.,update}
-
-    @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
-
-    @since version 3.0.0
-    */
-  void update(const_iterator first, const_iterator last)
-  {
-    // implicitly convert null value to an empty object
-    if (is_null()) {
-      m_type = value_t::object;
-      m_value.object = create<object_t>();
-      assert_invariant();
-    }
-
-    if (JSON_UNLIKELY(not is_object())) {
-      JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
-    }
-
-    // check if range iterators belong to the same JSON object
-    if (JSON_UNLIKELY(first.m_object != last.m_object)) {
-      JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
-    }
-
-    // passed iterators must belong to objects
-    if (JSON_UNLIKELY(not first.m_object->is_object() or not last.m_object->is_object())) {
-      JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
-    }
-
-    for (auto it = first; it != last; ++it) {
-      m_value.object->operator[](it.key()) = it.value();
-    }
-  }
-
-  /*!
-    @brief exchanges the values
-
-    Exchanges the contents of the JSON value with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other JSON value to exchange the contents with
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how JSON values can be swapped with
-    `swap()`.,swap__reference}
-
-    @since version 1.0.0
-    */
-  void swap(reference other) noexcept(
-    std::is_nothrow_move_constructible<value_t>::value and
-      std::is_nothrow_move_assignable<value_t>::value and
-        std::is_nothrow_move_constructible<json_value>::value and
-          std::is_nothrow_move_assignable<json_value>::value)
-  {
-    std::swap(m_type, other.m_type);
-    std::swap(m_value, other.m_value);
-    assert_invariant();
-  }
-
-  /*!
-    @brief exchanges the values
-
-    Exchanges the contents of a JSON array with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other array to exchange the contents with
-
-    @throw type_error.310 when JSON value is not an array; example: `"cannot
-    use swap() with string"`
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how arrays can be swapped with
-    `swap()`.,swap__array_t}
-
-    @since version 1.0.0
-    */
-  void swap(array_t& other)
-  {
-    // swap only works for arrays
-    if (JSON_LIKELY(is_array())) {
-      std::swap(*(m_value.array), other);
-    } else {
-      JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
-    }
-  }
-
-  /*!
-    @brief exchanges the values
-
-    Exchanges the contents of a JSON object with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other object to exchange the contents with
-
-    @throw type_error.310 when JSON value is not an object; example:
-    `"cannot use swap() with string"`
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how objects can be swapped with
-    `swap()`.,swap__object_t}
-
-    @since version 1.0.0
-    */
-  void swap(object_t& other)
-  {
-    // swap only works for objects
-    if (JSON_LIKELY(is_object())) {
-      std::swap(*(m_value.object), other);
-    } else {
-      JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
-    }
-  }
-
-  /*!
-    @brief exchanges the values
-
-    Exchanges the contents of a JSON string with those of @a other. Does not
-    invoke any move, copy, or swap operations on individual elements. All
-    iterators and references remain valid. The past-the-end iterator is
-    invalidated.
-
-    @param[in,out] other string to exchange the contents with
-
-    @throw type_error.310 when JSON value is not a string; example: `"cannot
-    use swap() with boolean"`
-
-    @complexity Constant.
-
-    @liveexample{The example below shows how strings can be swapped with
-    `swap()`.,swap__string_t}
-
-    @since version 1.0.0
-    */
-  void swap(string_t& other)
-  {
-    // swap only works for strings
-    if (JSON_LIKELY(is_string())) {
-      std::swap(*(m_value.string), other);
-    } else {
-      JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
-    }
-  }
-
-  /// @}
-
- public:
-  //////////////////////////////////////////
-  // lexicographical comparison operators //
-  //////////////////////////////////////////
-
-  /// @name lexicographical comparison operators
-  /// @{
-
-  /*!
-    @brief comparison: equal
-
-    Compares two JSON values for equality according to the following rules:
-    - Two JSON values are equal if (1) they are from the same type and (2)
-      their stored values are the same according to their respective
-      `operator==`.
-    - Integer and floating-point numbers are automatically converted before
-      comparison. Note than two NaN values are always treated as unequal.
-    - Two JSON null values are equal.
-
-    @note Floating-point inside JSON values numbers are compared with
-    `json::number_float_t::operator==` which is `double::operator==` by
-    default. To compare floating-point while respecting an epsilon, an alternative
-    [comparison function](https://github.com/mariokonrad/marnav/blob/master/src/marnav/math/floatingpoint.hpp#L34-#L39)
-    could be used, for instance
-    @code {.cpp}
-    template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
-    inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
-    {
-        return std::abs(a - b) <= epsilon;
-    }
-    @endcode
-
-    @note NaN values never compare equal to themselves or to other NaN values.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether the values @a lhs and @a rhs are equal
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @complexity Linear.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__equal}
-
-    @since version 1.0.0
-    */
-  friend bool operator==(const_reference lhs, const_reference rhs) noexcept
-  {
-    const auto lhs_type = lhs.type();
-    const auto rhs_type = rhs.type();
-
-    if (lhs_type == rhs_type) {
-      switch (lhs_type) {
-        case value_t::array:
-          return (*lhs.m_value.array == *rhs.m_value.array);
-
-        case value_t::object:
-          return (*lhs.m_value.object == *rhs.m_value.object);
-
-        case value_t::null:
-          return true;
-
-        case value_t::string:
-          return (*lhs.m_value.string == *rhs.m_value.string);
-
-        case value_t::boolean:
-          return (lhs.m_value.boolean == rhs.m_value.boolean);
-
-        case value_t::number_integer:
-          return (lhs.m_value.number_integer == rhs.m_value.number_integer);
-
-        case value_t::number_unsigned:
-          return (lhs.m_value.number_unsigned == rhs.m_value.number_unsigned);
-
-        case value_t::number_float:
-          return (lhs.m_value.number_float == rhs.m_value.number_float);
-
-        default:
-          return false;
-      }
-    } else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float) {
-      return (static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float);
-    } else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer) {
-      return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer));
-    } else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float) {
-      return (static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float);
-    } else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned) {
-      return (lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned));
-    } else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer) {
-      return (static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer);
-    } else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned) {
-      return (lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned));
-    }
-
-    return false;
-  }
-
-  /*!
-    @brief comparison: equal
-    @copydoc operator==(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
-  {
-    return (lhs == basic_json(rhs));
-  }
-
-  /*!
-    @brief comparison: equal
-    @copydoc operator==(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
-  {
-    return (basic_json(lhs) == rhs);
-  }
-
-  /*!
-    @brief comparison: not equal
-
-    Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether the values @a lhs and @a rhs are not equal
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__notequal}
-
-    @since version 1.0.0
-    */
-  friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
-  {
-    return not(lhs == rhs);
-  }
-
-  /*!
-    @brief comparison: not equal
-    @copydoc operator!=(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
-  {
-    return (lhs != basic_json(rhs));
-  }
-
-  /*!
-    @brief comparison: not equal
-    @copydoc operator!=(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
-  {
-    return (basic_json(lhs) != rhs);
-  }
-
-  /*!
-    @brief comparison: less than
-
-    Compares whether one JSON value @a lhs is less than another JSON value @a
-    rhs according to the following rules:
-    - If @a lhs and @a rhs have the same type, the values are compared using
-      the default `<` operator.
-    - Integer and floating-point numbers are automatically converted before
-      comparison
-    - In case @a lhs and @a rhs have different types, the values are ignored
-      and the order of the types is considered, see
-      @ref operator<(const value_t, const value_t).
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether @a lhs is less than @a rhs
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__less}
-
-    @since version 1.0.0
-    */
-  friend bool operator<(const_reference lhs, const_reference rhs) noexcept
-  {
-    const auto lhs_type = lhs.type();
-    const auto rhs_type = rhs.type();
-
-    if (lhs_type == rhs_type) {
-      switch (lhs_type) {
-        case value_t::array:
-          return (*lhs.m_value.array) < (*rhs.m_value.array);
-
-        case value_t::object:
-          return *lhs.m_value.object < *rhs.m_value.object;
-
-        case value_t::null:
-          return false;
-
-        case value_t::string:
-          return *lhs.m_value.string < *rhs.m_value.string;
-
-        case value_t::boolean:
-          return lhs.m_value.boolean < rhs.m_value.boolean;
-
-        case value_t::number_integer:
-          return lhs.m_value.number_integer < rhs.m_value.number_integer;
-
-        case value_t::number_unsigned:
-          return lhs.m_value.number_unsigned < rhs.m_value.number_unsigned;
-
-        case value_t::number_float:
-          return lhs.m_value.number_float < rhs.m_value.number_float;
-
-        default:
-          return false;
-      }
-    } else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_float) {
-      return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
-    } else if (lhs_type == value_t::number_float and rhs_type == value_t::number_integer) {
-      return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
-    } else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_float) {
-      return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
-    } else if (lhs_type == value_t::number_float and rhs_type == value_t::number_unsigned) {
-      return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
-    } else if (lhs_type == value_t::number_integer and rhs_type == value_t::number_unsigned) {
-      return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
-    } else if (lhs_type == value_t::number_unsigned and rhs_type == value_t::number_integer) {
-      return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
-    }
-
-    // We only reach this line if we cannot compare values. In that case,
-    // we compare types. Note we have to call the operator explicitly,
-    // because MSVC has problems otherwise.
-    return operator<(lhs_type, rhs_type);
-  }
-
-  /*!
-    @brief comparison: less than
-    @copydoc operator<(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
-  {
-    return (lhs < basic_json(rhs));
-  }
-
-  /*!
-    @brief comparison: less than
-    @copydoc operator<(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
-  {
-    return (basic_json(lhs) < rhs);
-  }
-
-  /*!
-    @brief comparison: less than or equal
-
-    Compares whether one JSON value @a lhs is less than or equal to another
-    JSON value by calculating `not (rhs < lhs)`.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether @a lhs is less than or equal to @a rhs
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__greater}
-
-    @since version 1.0.0
-    */
-  friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
-  {
-    return not(rhs < lhs);
-  }
-
-  /*!
-    @brief comparison: less than or equal
-    @copydoc operator<=(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
-  {
-    return (lhs <= basic_json(rhs));
-  }
-
-  /*!
-    @brief comparison: less than or equal
-    @copydoc operator<=(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
-  {
-    return (basic_json(lhs) <= rhs);
-  }
-
-  /*!
-    @brief comparison: greater than
-
-    Compares whether one JSON value @a lhs is greater than another
-    JSON value by calculating `not (lhs <= rhs)`.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether @a lhs is greater than to @a rhs
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__lessequal}
-
-    @since version 1.0.0
-    */
-  friend bool operator>(const_reference lhs, const_reference rhs) noexcept
-  {
-    return not(lhs <= rhs);
-  }
-
-  /*!
-    @brief comparison: greater than
-    @copydoc operator>(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
-  {
-    return (lhs > basic_json(rhs));
-  }
-
-  /*!
-    @brief comparison: greater than
-    @copydoc operator>(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
-  {
-    return (basic_json(lhs) > rhs);
-  }
-
-  /*!
-    @brief comparison: greater than or equal
-
-    Compares whether one JSON value @a lhs is greater than or equal to another
-    JSON value by calculating `not (lhs < rhs)`.
-
-    @param[in] lhs  first JSON value to consider
-    @param[in] rhs  second JSON value to consider
-    @return whether @a lhs is greater than or equal to @a rhs
-
-    @complexity Linear.
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @liveexample{The example demonstrates comparing several JSON
-    types.,operator__greaterequal}
-
-    @since version 1.0.0
-    */
-  friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
-  {
-    return not(lhs < rhs);
-  }
-
-  /*!
-    @brief comparison: greater than or equal
-    @copydoc operator>=(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
-  {
-    return (lhs >= basic_json(rhs));
-  }
-
-  /*!
-    @brief comparison: greater than or equal
-    @copydoc operator>=(const_reference, const_reference)
-    */
-  template <typename ScalarType, typename std::enable_if<
-                                   std::is_scalar<ScalarType>::value, int>::type = 0>
-  friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
-  {
-    return (basic_json(lhs) >= rhs);
-  }
-
-  /// @}
-
-  ///////////////////
-  // serialization //
-  ///////////////////
-
-  /// @name serialization
-  /// @{
-
-  /*!
-    @brief serialize to stream
-
-    Serialize the given JSON value @a j to the output stream @a o. The JSON
-    value will be serialized using the @ref dump member function.
-
-    - The indentation of the output can be controlled with the member variable
-      `width` of the output stream @a o. For instance, using the manipulator
-      `std::setw(4)` on @a o sets the indentation level to `4` and the
-      serialization result is the same as calling `dump(4)`.
-
-    - The indentation character can be controlled with the member variable
-      `fill` of the output stream @a o. For instance, the manipulator
-      `std::setfill('\\t')` sets indentation to use a tab character rather than
-      the default space character.
-
-    @param[in,out] o  stream to serialize to
-    @param[in] j  JSON value to serialize
-
-    @return the stream @a o
-
-    @throw type_error.316 if a string stored inside the JSON value is not
-                          UTF-8 encoded
-
-    @complexity Linear.
-
-    @liveexample{The example below shows the serialization with different
-    parameters to `width` to adjust the indentation level.,operator_serialize}
-
-    @since version 1.0.0; indentation character added in version 3.0.0
-    */
-  friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
-  {
-    // read width member and use it as indentation parameter if nonzero
-    const bool pretty_print = (o.width() > 0);
-    const auto indentation = (pretty_print ? o.width() : 0);
-
-    // reset width to 0 for subsequent calls to this stream
-    o.width(0);
-
-    // do the actual serialization
-    serializer s(detail::output_adapter<char>(o), o.fill());
-    s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
-    return o;
-  }
-
-  /*!
-    @brief serialize to stream
-    @deprecated This stream operator is deprecated and will be removed in
-                future 4.0.0 of the library. Please use
-                @ref operator<<(std::ostream&, const basic_json&)
-                instead; that is, replace calls like `j >> o;` with `o << j;`.
-    @since version 1.0.0; deprecated since version 3.0.0
-    */
-  JSON_DEPRECATED
-  friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
-  {
-    return o << j;
-  }
-
-  /// @}
-
-  /////////////////////
-  // deserialization //
-  /////////////////////
-
-  /// @name deserialization
-  /// @{
-
-  /*!
-    @brief deserialize from a compatible input
-
-    This function reads from a compatible input. Examples are:
-    - an array of 1-byte values
-    - strings with character/literal type with size of 1 byte
-    - input streams
-    - container with contiguous storage of 1-byte values. Compatible container
-      types include `std::vector`, `std::string`, `std::array`,
-      `std::valarray`, and `std::initializer_list`. Furthermore, C-style
-      arrays can be used with `std::begin()`/`std::end()`. User-defined
-      containers can be used as long as they implement random-access iterators
-      and a contiguous storage.
-
-    @pre Each element of the container has a size of 1 byte. Violating this
-    precondition yields undefined behavior. **This precondition is enforced
-    with a static assertion.**
-
-    @pre The container storage is contiguous. Violating this precondition
-    yields undefined behavior. **This precondition is enforced with an
-    assertion.**
-    @pre Each element of the container has a size of 1 byte. Violating this
-    precondition yields undefined behavior. **This precondition is enforced
-    with a static assertion.**
-
-    @warning There is no way to enforce all preconditions at compile-time. If
-             the function is called with a noncompliant container and with
-             assertions switched off, the behavior is undefined and will most
-             likely yield segmentation violation.
-
-    @param[in] i  input to read from
-    @param[in] cb  a parser callback function of type @ref parser_callback_t
-    which is used to control the deserialization by filtering unwanted values
-    (optional)
-
-    @return result of the deserialization
-
-    @throw parse_error.101 if a parse error occurs; example: `""unexpected end
-    of input; expected string literal""`
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-
-    @complexity Linear in the length of the input. The parser is a predictive
-    LL(1) parser. The complexity can be higher if the parser callback function
-    @a cb has a super-linear complexity.
-
-    @note A UTF-8 byte order mark is silently ignored.
-
-    @liveexample{The example below demonstrates the `parse()` function reading
-    from an array.,parse__array__parser_callback_t}
-
-    @liveexample{The example below demonstrates the `parse()` function with
-    and without callback function.,parse__string__parser_callback_t}
-
-    @liveexample{The example below demonstrates the `parse()` function with
-    and without callback function.,parse__istream__parser_callback_t}
-
-    @liveexample{The example below demonstrates the `parse()` function reading
-    from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
-
-    @since version 2.0.3 (contiguous containers)
-    */
-  static basic_json parse(detail::input_adapter i,
-                          const parser_callback_t cb = nullptr,
-                          const bool allow_exceptions = true)
-  {
-    basic_json result;
-    parser(i, cb, allow_exceptions).parse(true, result);
-    return result;
-  }
-
-  /*!
-    @copydoc basic_json parse(detail::input_adapter, const parser_callback_t)
-    */
-  static basic_json parse(detail::input_adapter& i,
-                          const parser_callback_t cb = nullptr,
-                          const bool allow_exceptions = true)
-  {
-    basic_json result;
-    parser(i, cb, allow_exceptions).parse(true, result);
-    return result;
-  }
-
-  static bool accept(detail::input_adapter i)
-  {
-    return parser(i).accept(true);
-  }
-
-  static bool accept(detail::input_adapter& i)
-  {
-    return parser(i).accept(true);
-  }
-
-  /*!
-    @brief deserialize from an iterator range with contiguous storage
-
-    This function reads from an iterator range of a container with contiguous
-    storage of 1-byte values. Compatible container types include
-    `std::vector`, `std::string`, `std::array`, `std::valarray`, and
-    `std::initializer_list`. Furthermore, C-style arrays can be used with
-    `std::begin()`/`std::end()`. User-defined containers can be used as long
-    as they implement random-access iterators and a contiguous storage.
-
-    @pre The iterator range is contiguous. Violating this precondition yields
-    undefined behavior. **This precondition is enforced with an assertion.**
-    @pre Each element in the range has a size of 1 byte. Violating this
-    precondition yields undefined behavior. **This precondition is enforced
-    with a static assertion.**
-
-    @warning There is no way to enforce all preconditions at compile-time. If
-             the function is called with noncompliant iterators and with
-             assertions switched off, the behavior is undefined and will most
-             likely yield segmentation violation.
-
-    @tparam IteratorType iterator of container with contiguous storage
-    @param[in] first  begin of the range to parse (included)
-    @param[in] last  end of the range to parse (excluded)
-    @param[in] cb  a parser callback function of type @ref parser_callback_t
-    which is used to control the deserialization by filtering unwanted values
-    (optional)
-    @param[in] allow_exceptions  whether to throw exceptions in case of a
-    parse error (optional, true by default)
-
-    @return result of the deserialization
-
-    @throw parse_error.101 in case of an unexpected token
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-
-    @complexity Linear in the length of the input. The parser is a predictive
-    LL(1) parser. The complexity can be higher if the parser callback function
-    @a cb has a super-linear complexity.
-
-    @note A UTF-8 byte order mark is silently ignored.
-
-    @liveexample{The example below demonstrates the `parse()` function reading
-    from an iterator range.,parse__iteratortype__parser_callback_t}
-
-    @since version 2.0.3
-    */
-  template <class IteratorType, typename std::enable_if<
-                                  std::is_base_of<
-                                    std::random_access_iterator_tag,
-                                    typename std::iterator_traits<IteratorType>::iterator_category>::value,
-                                  int>::type = 0>
-  static basic_json parse(IteratorType first, IteratorType last,
-                          const parser_callback_t cb = nullptr,
-                          const bool allow_exceptions = true)
-  {
-    basic_json result;
-    parser(detail::input_adapter(first, last), cb, allow_exceptions).parse(true, result);
-    return result;
-  }
-
-  template <class IteratorType, typename std::enable_if<
-                                  std::is_base_of<
-                                    std::random_access_iterator_tag,
-                                    typename std::iterator_traits<IteratorType>::iterator_category>::value,
-                                  int>::type = 0>
-  static bool accept(IteratorType first, IteratorType last)
-  {
-    return parser(detail::input_adapter(first, last)).accept(true);
-  }
-
-  /*!
-    @brief deserialize from stream
-    @deprecated This stream operator is deprecated and will be removed in
-                version 4.0.0 of the library. Please use
-                @ref operator>>(std::istream&, basic_json&)
-                instead; that is, replace calls like `j << i;` with `i >> j;`.
-    @since version 1.0.0; deprecated since version 3.0.0
-    */
-  JSON_DEPRECATED
-  friend std::istream& operator<<(basic_json& j, std::istream& i)
-  {
-    return operator>>(i, j);
-  }
-
-  /*!
-    @brief deserialize from stream
-
-    Deserializes an input stream to a JSON value.
-
-    @param[in,out] i  input stream to read a serialized JSON value from
-    @param[in,out] j  JSON value to write the deserialized input to
-
-    @throw parse_error.101 in case of an unexpected token
-    @throw parse_error.102 if to_unicode fails or surrogate error
-    @throw parse_error.103 if to_unicode fails
-
-    @complexity Linear in the length of the input. The parser is a predictive
-    LL(1) parser.
-
-    @note A UTF-8 byte order mark is silently ignored.
-
-    @liveexample{The example below shows how a JSON value is constructed by
-    reading a serialization from a stream.,operator_deserialize}
-
-    @sa parse(std::istream&, const parser_callback_t) for a variant with a
-    parser callback function to filter values while parsing
-
-    @since version 1.0.0
-    */
-  friend std::istream& operator>>(std::istream& i, basic_json& j)
-  {
-    parser(detail::input_adapter(i)).parse(false, j);
-    return i;
-  }
-
-  /// @}
-
-  ///////////////////////////
-  // convenience functions //
-  ///////////////////////////
-
-  /*!
-    @brief return the type as string
-
-    Returns the type name as string to be used in error messages - usually to
-    indicate that a function was called on a wrong JSON type.
-
-    @return a string representation of a the @a m_type member:
-            Value type  | return value
-            ----------- | -------------
-            null        | `"null"`
-            boolean     | `"boolean"`
-            string      | `"string"`
-            number      | `"number"` (for all number types)
-            object      | `"object"`
-            array       | `"array"`
-            discarded   | `"discarded"`
-
-    @exceptionsafety No-throw guarantee: this function never throws exceptions.
-
-    @complexity Constant.
-
-    @liveexample{The following code exemplifies `type_name()` for all JSON
-    types.,type_name}
-
-    @sa @ref type() -- return the type of the JSON value
-    @sa @ref operator value_t() -- return the type of the JSON value (implicit)
-
-    @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
-    since 3.0.0
-    */
-  const char* type_name() const noexcept
-  {
-    {
-      switch (m_type) {
-        case value_t::null:
-          return "null";
-        case value_t::object:
-          return "object";
-        case value_t::array:
-          return "array";
-        case value_t::string:
-          return "string";
-        case value_t::boolean:
-          return "boolean";
-        case value_t::discarded:
-          return "discarded";
-        default:
-          return "number";
-      }
-    }
-  }
-
- private:
-  //////////////////////
-  // member variables //
-  //////////////////////
-
-  /// the type of the current element
-  value_t m_type = value_t::null;
-
-  /// the value of the current element
-  json_value m_value = {};
-
-  //////////////////////////////////////////
-  // binary serialization/deserialization //
-  //////////////////////////////////////////
-
-  /// @name binary serialization/deserialization support
-  /// @{
-
- public:
-  /*!
-    @brief create a CBOR serialization of a given JSON value
-
-    Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
-    Binary Object Representation) serialization format. CBOR is a binary
-    serialization format which aims to be more compact than JSON itself, yet
-    more efficient to parse.
-
-    The library uses the following mapping from JSON values types to
-    CBOR types according to the CBOR specification (RFC 7049):
-
-    JSON value type | value/range                                | CBOR type                          | first byte
-    --------------- | ------------------------------------------ | ---------------------------------- | ---------------
-    null            | `null`                                     | Null                               | 0xF6
-    boolean         | `true`                                     | True                               | 0xF5
-    boolean         | `false`                                    | False                              | 0xF4
-    number_integer  | -9223372036854775808..-2147483649          | Negative integer (8 bytes follow)  | 0x3B
-    number_integer  | -2147483648..-32769                        | Negative integer (4 bytes follow)  | 0x3A
-    number_integer  | -32768..-129                               | Negative integer (2 bytes follow)  | 0x39
-    number_integer  | -128..-25                                  | Negative integer (1 byte follow)   | 0x38
-    number_integer  | -24..-1                                    | Negative integer                   | 0x20..0x37
-    number_integer  | 0..23                                      | Integer                            | 0x00..0x17
-    number_integer  | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
-    number_integer  | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
-    number_integer  | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
-    number_integer  | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
-    number_unsigned | 0..23                                      | Integer                            | 0x00..0x17
-    number_unsigned | 24..255                                    | Unsigned integer (1 byte follow)   | 0x18
-    number_unsigned | 256..65535                                 | Unsigned integer (2 bytes follow)  | 0x19
-    number_unsigned | 65536..4294967295                          | Unsigned integer (4 bytes follow)  | 0x1A
-    number_unsigned | 4294967296..18446744073709551615           | Unsigned integer (8 bytes follow)  | 0x1B
-    number_float    | *any value*                                | Double-Precision Float             | 0xFB
-    string          | *length*: 0..23                            | UTF-8 string                       | 0x60..0x77
-    string          | *length*: 23..255                          | UTF-8 string (1 byte follow)       | 0x78
-    string          | *length*: 256..65535                       | UTF-8 string (2 bytes follow)      | 0x79
-    string          | *length*: 65536..4294967295                | UTF-8 string (4 bytes follow)      | 0x7A
-    string          | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow)      | 0x7B
-    array           | *size*: 0..23                              | array                              | 0x80..0x97
-    array           | *size*: 23..255                            | array (1 byte follow)              | 0x98
-    array           | *size*: 256..65535                         | array (2 bytes follow)             | 0x99
-    array           | *size*: 65536..4294967295                  | array (4 bytes follow)             | 0x9A
-    array           | *size*: 4294967296..18446744073709551615   | array (8 bytes follow)             | 0x9B
-    object          | *size*: 0..23                              | map                                | 0xA0..0xB7
-    object          | *size*: 23..255                            | map (1 byte follow)                | 0xB8
-    object          | *size*: 256..65535                         | map (2 bytes follow)               | 0xB9
-    object          | *size*: 65536..4294967295                  | map (4 bytes follow)               | 0xBA
-    object          | *size*: 4294967296..18446744073709551615   | map (8 bytes follow)               | 0xBB
-
-    @note The mapping is **complete** in the sense that any JSON value type
-          can be converted to a CBOR value.
-
-    @note If NaN or Infinity are stored inside a JSON number, they are
-          serialized properly. This behavior differs from the @ref dump()
-          function which serializes NaN or Infinity to `null`.
-
-    @note The following CBOR types are not used in the conversion:
-          - byte strings (0x40..0x5F)
-          - UTF-8 strings terminated by "break" (0x7F)
-          - arrays terminated by "break" (0x9F)
-          - maps terminated by "break" (0xBF)
-          - date/time (0xC0..0xC1)
-          - bignum (0xC2..0xC3)
-          - decimal fraction (0xC4)
-          - bigfloat (0xC5)
-          - tagged items (0xC6..0xD4, 0xD8..0xDB)
-          - expected conversions (0xD5..0xD7)
-          - simple values (0xE0..0xF3, 0xF8)
-          - undefined (0xF7)
-          - half and single-precision floats (0xF9-0xFA)
-          - break (0xFF)
-
-    @param[in] j  JSON value to serialize
-    @return MessagePack serialization as byte vector
-
-    @complexity Linear in the size of the JSON value @a j.
-
-    @liveexample{The example shows the serialization of a JSON value to a byte
-    vector in CBOR format.,to_cbor}
-
-    @sa http://cbor.io
-    @sa @ref from_cbor(detail::input_adapter, const bool strict) for the
-        analogous deserialization
-    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
-    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
-             related UBJSON format
-
-    @since version 2.0.9
-    */
-  static std::vector<uint8_t> to_cbor(const basic_json& j)
-  {
-    std::vector<uint8_t> result;
-    to_cbor(j, result);
-    return result;
-  }
-
-  static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
-  {
-    binary_writer<uint8_t>(o).write_cbor(j);
-  }
-
-  static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
-  {
-    binary_writer<char>(o).write_cbor(j);
-  }
-
-  /*!
-    @brief create a MessagePack serialization of a given JSON value
-
-    Serializes a given JSON value @a j to a byte vector using the MessagePack
-    serialization format. MessagePack is a binary serialization format which
-    aims to be more compact than JSON itself, yet more efficient to parse.
-
-    The library uses the following mapping from JSON values types to
-    MessagePack types according to the MessagePack specification:
-
-    JSON value type | value/range                       | MessagePack type | first byte
-    --------------- | --------------------------------- | ---------------- | ----------
-    null            | `null`                            | nil              | 0xC0
-    boolean         | `true`                            | true             | 0xC3
-    boolean         | `false`                           | false            | 0xC2
-    number_integer  | -9223372036854775808..-2147483649 | int64            | 0xD3
-    number_integer  | -2147483648..-32769               | int32            | 0xD2
-    number_integer  | -32768..-129                      | int16            | 0xD1
-    number_integer  | -128..-33                         | int8             | 0xD0
-    number_integer  | -32..-1                           | negative fixint  | 0xE0..0xFF
-    number_integer  | 0..127                            | positive fixint  | 0x00..0x7F
-    number_integer  | 128..255                          | uint 8           | 0xCC
-    number_integer  | 256..65535                        | uint 16          | 0xCD
-    number_integer  | 65536..4294967295                 | uint 32          | 0xCE
-    number_integer  | 4294967296..18446744073709551615  | uint 64          | 0xCF
-    number_unsigned | 0..127                            | positive fixint  | 0x00..0x7F
-    number_unsigned | 128..255                          | uint 8           | 0xCC
-    number_unsigned | 256..65535                        | uint 16          | 0xCD
-    number_unsigned | 65536..4294967295                 | uint 32          | 0xCE
-    number_unsigned | 4294967296..18446744073709551615  | uint 64          | 0xCF
-    number_float    | *any value*                       | float 64         | 0xCB
-    string          | *length*: 0..31                   | fixstr           | 0xA0..0xBF
-    string          | *length*: 32..255                 | str 8            | 0xD9
-    string          | *length*: 256..65535              | str 16           | 0xDA
-    string          | *length*: 65536..4294967295       | str 32           | 0xDB
-    array           | *size*: 0..15                     | fixarray         | 0x90..0x9F
-    array           | *size*: 16..65535                 | array 16         | 0xDC
-    array           | *size*: 65536..4294967295         | array 32         | 0xDD
-    object          | *size*: 0..15                     | fix map          | 0x80..0x8F
-    object          | *size*: 16..65535                 | map 16           | 0xDE
-    object          | *size*: 65536..4294967295         | map 32           | 0xDF
-
-    @note The mapping is **complete** in the sense that any JSON value type
-          can be converted to a MessagePack value.
-
-    @note The following values can **not** be converted to a MessagePack value:
-          - strings with more than 4294967295 bytes
-          - arrays with more than 4294967295 elements
-          - objects with more than 4294967295 elements
-
-    @note The following MessagePack types are not used in the conversion:
-          - bin 8 - bin 32 (0xC4..0xC6)
-          - ext 8 - ext 32 (0xC7..0xC9)
-          - float 32 (0xCA)
-          - fixext 1 - fixext 16 (0xD4..0xD8)
-
-    @note Any MessagePack output created @ref to_msgpack can be successfully
-          parsed by @ref from_msgpack.
-
-    @note If NaN or Infinity are stored inside a JSON number, they are
-          serialized properly. This behavior differs from the @ref dump()
-          function which serializes NaN or Infinity to `null`.
-
-    @param[in] j  JSON value to serialize
-    @return MessagePack serialization as byte vector
-
-    @complexity Linear in the size of the JSON value @a j.
-
-    @liveexample{The example shows the serialization of a JSON value to a byte
-    vector in MessagePack format.,to_msgpack}
-
-    @sa http://msgpack.org
-    @sa @ref from_msgpack(const std::vector<uint8_t>&, const size_t) for the
-        analogous deserialization
-    @sa @ref to_cbor(const basic_json& for the related CBOR format
-    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
-             related UBJSON format
-
-    @since version 2.0.9
-    */
-  static std::vector<uint8_t> to_msgpack(const basic_json& j)
-  {
-    std::vector<uint8_t> result;
-    to_msgpack(j, result);
-    return result;
-  }
-
-  static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
-  {
-    binary_writer<uint8_t>(o).write_msgpack(j);
-  }
-
-  static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
-  {
-    binary_writer<char>(o).write_msgpack(j);
-  }
-
-  /*!
-    @brief create a UBJSON serialization of a given JSON value
-
-    Serializes a given JSON value @a j to a byte vector using the UBJSON
-    (Universal Binary JSON) serialization format. UBJSON aims to be more compact
-    than JSON itself, yet more efficient to parse.
-
-    The library uses the following mapping from JSON values types to
-    UBJSON types according to the UBJSON specification:
-
-    JSON value type | value/range                       | UBJSON type | marker
-    --------------- | --------------------------------- | ----------- | ------
-    null            | `null`                            | null        | `Z`
-    boolean         | `true`                            | true        | `T`
-    boolean         | `false`                           | false       | `F`
-    number_integer  | -9223372036854775808..-2147483649 | int64       | `L`
-    number_integer  | -2147483648..-32769               | int32       | `l`
-    number_integer  | -32768..-129                      | int16       | `I`
-    number_integer  | -128..127                         | int8        | `i`
-    number_integer  | 128..255                          | uint8       | `U`
-    number_integer  | 256..32767                        | int16       | `I`
-    number_integer  | 32768..2147483647                 | int32       | `l`
-    number_integer  | 2147483648..9223372036854775807   | int64       | `L`
-    number_unsigned | 0..127                            | int8        | `i`
-    number_unsigned | 128..255                          | uint8       | `U`
-    number_unsigned | 256..32767                        | int16       | `I`
-    number_unsigned | 32768..2147483647                 | int32       | `l`
-    number_unsigned | 2147483648..9223372036854775807   | int64       | `L`
-    number_float    | *any value*                       | float64     | `D`
-    string          | *with shortest length indicator*  | string      | `S`
-    array           | *see notes on optimized format*   | array       | `[`
-    object          | *see notes on optimized format*   | map         | `{`
-
-    @note The mapping is **complete** in the sense that any JSON value type
-          can be converted to a UBJSON value.
-
-    @note The following values can **not** be converted to a UBJSON value:
-          - strings with more than 9223372036854775807 bytes (theoretical)
-          - unsigned integer numbers above 9223372036854775807
-
-    @note The following markers are not used in the conversion:
-          - `Z`: no-op values are not created.
-          - `C`: single-byte strings are serialized with `S` markers.
-
-    @note Any UBJSON output created @ref to_ubjson can be successfully parsed
-          by @ref from_ubjson.
-
-    @note If NaN or Infinity are stored inside a JSON number, they are
-          serialized properly. This behavior differs from the @ref dump()
-          function which serializes NaN or Infinity to `null`.
-
-    @note The optimized formats for containers are supported: Parameter
-          @a use_size adds size information to the beginning of a container and
-          removes the closing marker. Parameter @a use_type further checks
-          whether all elements of a container have the same type and adds the
-          type marker to the beginning of the container. The @a use_type
-          parameter must only be used together with @a use_size = true. Note
-          that @a use_size = true alone may result in larger representations -
-          the benefit of this parameter is that the receiving side is
-          immediately informed on the number of elements of the container.
-
-    @param[in] j  JSON value to serialize
-    @param[in] use_size  whether to add size annotations to container types
-    @param[in] use_type  whether to add type annotations to container types
-                         (must be combined with @a use_size = true)
-    @return UBJSON serialization as byte vector
-
-    @complexity Linear in the size of the JSON value @a j.
-
-    @liveexample{The example shows the serialization of a JSON value to a byte
-    vector in UBJSON format.,to_ubjson}
-
-    @sa http://ubjson.org
-    @sa @ref from_ubjson(detail::input_adapter, const bool strict) for the
-        analogous deserialization
-    @sa @ref to_cbor(const basic_json& for the related CBOR format
-    @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
-
-    @since version 3.1.0
-    */
-  static std::vector<uint8_t> to_ubjson(const basic_json& j,
-                                        const bool use_size = false,
-                                        const bool use_type = false)
-  {
-    std::vector<uint8_t> result;
-    to_ubjson(j, result, use_size, use_type);
-    return result;
-  }
-
-  static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
-                        const bool use_size = false, const bool use_type = false)
-  {
-    binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
-  }
-
-  static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
-                        const bool use_size = false, const bool use_type = false)
-  {
-    binary_writer<char>(o).write_ubjson(j, use_size, use_type);
-  }
-
-  /*!
-    @brief create a JSON value from an input in CBOR format
-
-    Deserializes a given input @a i to a JSON value using the CBOR (Concise
-    Binary Object Representation) serialization format.
-
-    The library maps CBOR types to JSON value types as follows:
-
-    CBOR type              | JSON value type | first byte
-    ---------------------- | --------------- | ----------
-    Integer                | number_unsigned | 0x00..0x17
-    Unsigned integer       | number_unsigned | 0x18
-    Unsigned integer       | number_unsigned | 0x19
-    Unsigned integer       | number_unsigned | 0x1A
-    Unsigned integer       | number_unsigned | 0x1B
-    Negative integer       | number_integer  | 0x20..0x37
-    Negative integer       | number_integer  | 0x38
-    Negative integer       | number_integer  | 0x39
-    Negative integer       | number_integer  | 0x3A
-    Negative integer       | number_integer  | 0x3B
-    Negative integer       | number_integer  | 0x40..0x57
-    UTF-8 string           | string          | 0x60..0x77
-    UTF-8 string           | string          | 0x78
-    UTF-8 string           | string          | 0x79
-    UTF-8 string           | string          | 0x7A
-    UTF-8 string           | string          | 0x7B
-    UTF-8 string           | string          | 0x7F
-    array                  | array           | 0x80..0x97
-    array                  | array           | 0x98
-    array                  | array           | 0x99
-    array                  | array           | 0x9A
-    array                  | array           | 0x9B
-    array                  | array           | 0x9F
-    map                    | object          | 0xA0..0xB7
-    map                    | object          | 0xB8
-    map                    | object          | 0xB9
-    map                    | object          | 0xBA
-    map                    | object          | 0xBB
-    map                    | object          | 0xBF
-    False                  | `false`         | 0xF4
-    True                   | `true`          | 0xF5
-    Nill                   | `null`          | 0xF6
-    Half-Precision Float   | number_float    | 0xF9
-    Single-Precision Float | number_float    | 0xFA
-    Double-Precision Float | number_float    | 0xFB
-
-    @warning The mapping is **incomplete** in the sense that not all CBOR
-             types can be converted to a JSON value. The following CBOR types
-             are not supported and will yield parse errors (parse_error.112):
-             - byte strings (0x40..0x5F)
-             - date/time (0xC0..0xC1)
-             - bignum (0xC2..0xC3)
-             - decimal fraction (0xC4)
-             - bigfloat (0xC5)
-             - tagged items (0xC6..0xD4, 0xD8..0xDB)
-             - expected conversions (0xD5..0xD7)
-             - simple values (0xE0..0xF3, 0xF8)
-             - undefined (0xF7)
-
-    @warning CBOR allows map keys of any type, whereas JSON only allows
-             strings as keys in object values. Therefore, CBOR maps with keys
-             other than UTF-8 strings are rejected (parse_error.113).
-
-    @note Any CBOR output created @ref to_cbor can be successfully parsed by
-          @ref from_cbor.
-
-    @param[in] i  an input in CBOR format convertible to an input adapter
-    @param[in] strict  whether to expect the input to be consumed until EOF
-                       (true by default)
-    @return deserialized JSON value
-
-    @throw parse_error.110 if the given input ends prematurely or the end of
-    file was not reached when @a strict was set to true
-    @throw parse_error.112 if unsupported features from CBOR were
-    used in the given input @a v or if the input is not valid CBOR
-    @throw parse_error.113 if a string was expected as map key, but not found
-
-    @complexity Linear in the size of the input @a i.
-
-    @liveexample{The example shows the deserialization of a byte vector in CBOR
-    format to a JSON value.,from_cbor}
-
-    @sa http://cbor.io
-    @sa @ref to_cbor(const basic_json&) for the analogous serialization
-    @sa @ref from_msgpack(detail::input_adapter, const bool) for the
-        related MessagePack format
-    @sa @ref from_ubjson(detail::input_adapter, const bool) for the related
-        UBJSON format
-
-    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
-           consume input adapters, removed start_index parameter, and added
-           @a strict parameter since 3.0.0
-    */
-  static basic_json from_cbor(detail::input_adapter i,
-                              const bool strict = true)
-  {
-    return binary_reader(i).parse_cbor(strict);
-  }
-
-  /*!
-    @copydoc from_cbor(detail::input_adapter, const bool)
-    */
-  template <typename A1, typename A2,
-            detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
-  static basic_json from_cbor(A1&& a1, A2&& a2, const bool strict = true)
-  {
-    return binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).parse_cbor(strict);
-  }
-
-  /*!
-    @brief create a JSON value from an input in MessagePack format
-
-    Deserializes a given input @a i to a JSON value using the MessagePack
-    serialization format.
-
-    The library maps MessagePack types to JSON value types as follows:
-
-    MessagePack type | JSON value type | first byte
-    ---------------- | --------------- | ----------
-    positive fixint  | number_unsigned | 0x00..0x7F
-    fixmap           | object          | 0x80..0x8F
-    fixarray         | array           | 0x90..0x9F
-    fixstr           | string          | 0xA0..0xBF
-    nil              | `null`          | 0xC0
-    false            | `false`         | 0xC2
-    true             | `true`          | 0xC3
-    float 32         | number_float    | 0xCA
-    float 64         | number_float    | 0xCB
-    uint 8           | number_unsigned | 0xCC
-    uint 16          | number_unsigned | 0xCD
-    uint 32          | number_unsigned | 0xCE
-    uint 64          | number_unsigned | 0xCF
-    int 8            | number_integer  | 0xD0
-    int 16           | number_integer  | 0xD1
-    int 32           | number_integer  | 0xD2
-    int 64           | number_integer  | 0xD3
-    str 8            | string          | 0xD9
-    str 16           | string          | 0xDA
-    str 32           | string          | 0xDB
-    array 16         | array           | 0xDC
-    array 32         | array           | 0xDD
-    map 16           | object          | 0xDE
-    map 32           | object          | 0xDF
-    negative fixint  | number_integer  | 0xE0-0xFF
-
-    @warning The mapping is **incomplete** in the sense that not all
-             MessagePack types can be converted to a JSON value. The following
-             MessagePack types are not supported and will yield parse errors:
-              - bin 8 - bin 32 (0xC4..0xC6)
-              - ext 8 - ext 32 (0xC7..0xC9)
-              - fixext 1 - fixext 16 (0xD4..0xD8)
-
-    @note Any MessagePack output created @ref to_msgpack can be successfully
-          parsed by @ref from_msgpack.
-
-    @param[in] i  an input in MessagePack format convertible to an input
-                  adapter
-    @param[in] strict  whether to expect the input to be consumed until EOF
-                       (true by default)
-
-    @throw parse_error.110 if the given input ends prematurely or the end of
-    file was not reached when @a strict was set to true
-    @throw parse_error.112 if unsupported features from MessagePack were
-    used in the given input @a i or if the input is not valid MessagePack
-    @throw parse_error.113 if a string was expected as map key, but not found
-
-    @complexity Linear in the size of the input @a i.
-
-    @liveexample{The example shows the deserialization of a byte vector in
-    MessagePack format to a JSON value.,from_msgpack}
-
-    @sa http://msgpack.org
-    @sa @ref to_msgpack(const basic_json&) for the analogous serialization
-    @sa @ref from_cbor(detail::input_adapter, const bool) for the related CBOR
-        format
-    @sa @ref from_ubjson(detail::input_adapter, const bool) for the related
-        UBJSON format
-
-    @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
-           consume input adapters, removed start_index parameter, and added
-           @a strict parameter since 3.0.0
-    */
-  static basic_json from_msgpack(detail::input_adapter i,
-                                 const bool strict = true)
-  {
-    return binary_reader(i).parse_msgpack(strict);
-  }
-
-  /*!
-    @copydoc from_msgpack(detail::input_adapter, const bool)
-    */
-  template <typename A1, typename A2,
-            detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
-  static basic_json from_msgpack(A1&& a1, A2&& a2, const bool strict = true)
-  {
-    return binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).parse_msgpack(strict);
-  }
-
-  /*!
-    @brief create a JSON value from an input in UBJSON format
-
-    Deserializes a given input @a i to a JSON value using the UBJSON (Universal
-    Binary JSON) serialization format.
-
-    The library maps UBJSON types to JSON value types as follows:
-
-    UBJSON type | JSON value type                         | marker
-    ----------- | --------------------------------------- | ------
-    no-op       | *no value, next value is read*          | `N`
-    null        | `null`                                  | `Z`
-    false       | `false`                                 | `F`
-    true        | `true`                                  | `T`
-    float32     | number_float                            | `d`
-    float64     | number_float                            | `D`
-    uint8       | number_unsigned                         | `U`
-    int8        | number_integer                          | `i`
-    int16       | number_integer                          | `I`
-    int32       | number_integer                          | `l`
-    int64       | number_integer                          | `L`
-    string      | string                                  | `S`
-    char        | string                                  | `C`
-    array       | array (optimized values are supported)  | `[`
-    object      | object (optimized values are supported) | `{`
-
-    @note The mapping is **complete** in the sense that any UBJSON value can
-          be converted to a JSON value.
-
-    @param[in] i  an input in UBJSON format convertible to an input adapter
-    @param[in] strict  whether to expect the input to be consumed until EOF
-                       (true by default)
-
-    @throw parse_error.110 if the given input ends prematurely or the end of
-    file was not reached when @a strict was set to true
-    @throw parse_error.112 if a parse error occurs
-    @throw parse_error.113 if a string could not be parsed successfully
-
-    @complexity Linear in the size of the input @a i.
-
-    @liveexample{The example shows the deserialization of a byte vector in
-    UBJSON format to a JSON value.,from_ubjson}
-
-    @sa http://ubjson.org
-    @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
-             analogous serialization
-    @sa @ref from_cbor(detail::input_adapter, const bool) for the related CBOR
-        format
-    @sa @ref from_msgpack(detail::input_adapter, const bool) for the related
-        MessagePack format
-
-    @since version 3.1.0
-    */
-  static basic_json from_ubjson(detail::input_adapter i,
-                                const bool strict = true)
-  {
-    return binary_reader(i).parse_ubjson(strict);
-  }
-
-  template <typename A1, typename A2,
-            detail::enable_if_t<std::is_constructible<detail::input_adapter, A1, A2>::value, int> = 0>
-  static basic_json from_ubjson(A1&& a1, A2&& a2, const bool strict = true)
-  {
-    return binary_reader(detail::input_adapter(std::forward<A1>(a1), std::forward<A2>(a2))).parse_ubjson(strict);
-  }
-
-  /// @}
-
-  //////////////////////////
-  // JSON Pointer support //
-  //////////////////////////
-
-  /// @name JSON Pointer functions
-  /// @{
-
-  /*!
-    @brief access specified element via JSON Pointer
-
-    Uses a JSON pointer to retrieve a reference to the respective JSON value.
-    No bound checking is performed. Similar to @ref operator[](const typename
-    object_t::key_type&), `null` values are created in arrays and objects if
-    necessary.
-
-    In particular:
-    - If the JSON pointer points to an object key that does not exist, it
-      is created an filled with a `null` value before a reference to it
-      is returned.
-    - If the JSON pointer points to an array index that does not exist, it
-      is created an filled with a `null` value before a reference to it
-      is returned. All indices between the current maximum and the given
-      index are also filled with `null`.
-    - The special value `-` is treated as a synonym for the index past the
-      end.
-
-    @param[in] ptr  a JSON pointer
-
-    @return reference to the element pointed to by @a ptr
-
-    @complexity Constant.
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-
-    @liveexample{The behavior is shown in the example.,operatorjson_pointer}
-
-    @since version 2.0.0
-    */
-  reference operator[](const json_pointer& ptr)
-  {
-    return ptr.get_unchecked(this);
-  }
-
-  /*!
-    @brief access specified element via JSON Pointer
-
-    Uses a JSON pointer to retrieve a reference to the respective JSON value.
-    No bound checking is performed. The function does not change the JSON
-    value; no `null` values are created. In particular, the the special value
-    `-` yields an exception.
-
-    @param[in] ptr  JSON pointer to the desired element
-
-    @return const reference to the element pointed to by @a ptr
-
-    @complexity Constant.
-
-    @throw parse_error.106   if an array index begins with '0'
-    @throw parse_error.109   if an array index was not a number
-    @throw out_of_range.402  if the array index '-' is used
-    @throw out_of_range.404  if the JSON pointer can not be resolved
-
-    @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
-
-    @since version 2.0.0
-    */
-  const_reference operator[](const json_pointer& ptr) const
-  {
-    return ptr.get_unchecked(this);
-  }
-
-  /*!
-    @brief access specified element via JSON Pointer
-
-    Returns a reference to the element at with specified JSON pointer @a ptr,
-    with bounds checking.
-
-    @param[in] ptr  JSON pointer to the desired element
-
-    @return reference to the element pointed to by @a ptr
-
-    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
-    begins with '0'. See example below.
-
-    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
-    is not a number. See example below.
-
-    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
-    is out of range. See example below.
-
-    @throw out_of_range.402 if the array index '-' is used in the passed JSON
-    pointer @a ptr. As `at` provides checked access (and no elements are
-    implicitly inserted), the index '-' is always invalid. See example below.
-
-    @throw out_of_range.403 if the JSON pointer describes a key of an object
-    which cannot be found. See example below.
-
-    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
-    See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 2.0.0
-
-    @liveexample{The behavior is shown in the example.,at_json_pointer}
-    */
-  reference at(const json_pointer& ptr)
-  {
-    return ptr.get_checked(this);
-  }
-
-  /*!
-    @brief access specified element via JSON Pointer
-
-    Returns a const reference to the element at with specified JSON pointer @a
-    ptr, with bounds checking.
-
-    @param[in] ptr  JSON pointer to the desired element
-
-    @return reference to the element pointed to by @a ptr
-
-    @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
-    begins with '0'. See example below.
-
-    @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
-    is not a number. See example below.
-
-    @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
-    is out of range. See example below.
-
-    @throw out_of_range.402 if the array index '-' is used in the passed JSON
-    pointer @a ptr. As `at` provides checked access (and no elements are
-    implicitly inserted), the index '-' is always invalid. See example below.
-
-    @throw out_of_range.403 if the JSON pointer describes a key of an object
-    which cannot be found. See example below.
-
-    @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
-    See example below.
-
-    @exceptionsafety Strong guarantee: if an exception is thrown, there are no
-    changes in the JSON value.
-
-    @complexity Constant.
-
-    @since version 2.0.0
-
-    @liveexample{The behavior is shown in the example.,at_json_pointer_const}
-    */
-  const_reference at(const json_pointer& ptr) const
-  {
-    return ptr.get_checked(this);
-  }
-
-  /*!
-    @brief return flattened JSON value
-
-    The function creates a JSON object whose keys are JSON pointers (see [RFC
-    6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
-    primitive. The original JSON value can be restored using the @ref
-    unflatten() function.
-
-    @return an object that maps JSON pointers to primitive values
-
-    @note Empty objects and arrays are flattened to `null` and will not be
-          reconstructed correctly by the @ref unflatten() function.
-
-    @complexity Linear in the size the JSON value.
-
-    @liveexample{The following code shows how a JSON object is flattened to an
-    object whose keys consist of JSON pointers.,flatten}
-
-    @sa @ref unflatten() for the reverse function
-
-    @since version 2.0.0
-    */
-  basic_json flatten() const
-  {
-    basic_json result(value_t::object);
-    json_pointer::flatten("", *this, result);
-    return result;
-  }
-
-  /*!
-    @brief unflatten a previously flattened JSON value
-
-    The function restores the arbitrary nesting of a JSON value that has been
-    flattened before using the @ref flatten() function. The JSON value must
-    meet certain constraints:
-    1. The value must be an object.
-    2. The keys must be JSON pointers (see
-       [RFC 6901](https://tools.ietf.org/html/rfc6901))
-    3. The mapped values must be primitive JSON types.
-
-    @return the original JSON from a flattened version
-
-    @note Empty objects and arrays are flattened by @ref flatten() to `null`
-          values and can not unflattened to their original type. Apart from
-          this example, for a JSON value `j`, the following is always true:
-          `j == j.flatten().unflatten()`.
-
-    @complexity Linear in the size the JSON value.
-
-    @throw type_error.314  if value is not an object
-    @throw type_error.315  if object values are not primitive
-
-    @liveexample{The following code shows how a flattened JSON object is
-    unflattened into the original nested JSON object.,unflatten}
-
-    @sa @ref flatten() for the reverse function
-
-    @since version 2.0.0
-    */
-  basic_json unflatten() const
-  {
-    return json_pointer::unflatten(*this);
-  }
-
-  /// @}
-
-  //////////////////////////
-  // JSON Patch functions //
-  //////////////////////////
-
-  /// @name JSON Patch functions
-  /// @{
-
-  /*!
-    @brief applies a JSON patch
-
-    [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
-    expressing a sequence of operations to apply to a JSON) document. With
-    this function, a JSON Patch is applied to the current JSON value by
-    executing all operations from the patch.
-
-    @param[in] json_patch  JSON patch document
-    @return patched document
-
-    @note The application of a patch is atomic: Either all operations succeed
-          and the patched document is returned or an exception is thrown. In
-          any case, the original value is not changed: the patch is applied
-          to a copy of the value.
-
-    @throw parse_error.104 if the JSON patch does not consist of an array of
-    objects
-
-    @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory
-    attributes are missing); example: `"operation add must have member path"`
-
-    @throw out_of_range.401 if an array index is out of range.
-
-    @throw out_of_range.403 if a JSON pointer inside the patch could not be
-    resolved successfully in the current JSON value; example: `"key baz not
-    found"`
-
-    @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",
-    "move")
-
-    @throw other_error.501 if "test" operation was unsuccessful
-
-    @complexity Linear in the size of the JSON value and the length of the
-    JSON patch. As usually only a fraction of the JSON value is affected by
-    the patch, the complexity can usually be neglected.
-
-    @liveexample{The following code shows how a JSON patch is applied to a
-    value.,patch}
-
-    @sa @ref diff -- create a JSON patch by comparing two JSON values
-
-    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
-    @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
-
-    @since version 2.0.0
-    */
-  basic_json patch(const basic_json& json_patch) const
-  {
-    // make a working copy to apply the patch to
-    basic_json result = *this;
-
-    // the valid JSON Patch operations
-    enum class patch_operations { add,
-                                  remove,
-                                  replace,
-                                  move,
-                                  copy,
-                                  test,
-                                  invalid };
-
-    const auto get_op = [](const std::string& op) {
-      if (op == "add") {
-        return patch_operations::add;
-      }
-      if (op == "remove") {
-        return patch_operations::remove;
-      }
-      if (op == "replace") {
-        return patch_operations::replace;
-      }
-      if (op == "move") {
-        return patch_operations::move;
-      }
-      if (op == "copy") {
-        return patch_operations::copy;
-      }
-      if (op == "test") {
-        return patch_operations::test;
-      }
-
-      return patch_operations::invalid;
-    };
-
-    // wrapper for "add" operation; add value at ptr
-    const auto operation_add = [&result](json_pointer& ptr, basic_json val) {
-      // adding to the root of the target document means replacing it
-      if (ptr.is_root()) {
-        result = val;
-      } else {
-        // make sure the top element of the pointer exists
-        json_pointer top_pointer = ptr.top();
-        if (top_pointer != ptr) {
-          result.at(top_pointer);
-        }
-
-        // get reference to parent of JSON pointer ptr
-        const auto last_path = ptr.pop_back();
-        basic_json& parent = result[ptr];
-
-        switch (parent.m_type) {
-          case value_t::null:
-          case value_t::object: {
-            // use operator[] to add value
-            parent[last_path] = val;
-            break;
-          }
-
-          case value_t::array: {
-            if (last_path == "-") {
-              // special case: append to back
-              parent.push_back(val);
-            } else {
-              const auto idx = json_pointer::array_index(last_path);
-              if (JSON_UNLIKELY(static_cast<size_type>(idx) > parent.size())) {
-                // avoid undefined behavior
-                JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
-              } else {
-                // default case: insert add offset
-                parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
-              }
-            }
-            break;
-          }
-
-          default: {
-            // if there exists a parent it cannot be primitive
-            assert(false); // LCOV_EXCL_LINE
-          }
-        }
-      }
-    };
-
-    // wrapper for "remove" operation; remove value at ptr
-    const auto operation_remove = [&result](json_pointer& ptr) {
-      // get reference to parent of JSON pointer ptr
-      const auto last_path = ptr.pop_back();
-      basic_json& parent = result.at(ptr);
-
-      // remove child
-      if (parent.is_object()) {
-        // perform range check
-        auto it = parent.find(last_path);
-        if (JSON_LIKELY(it != parent.end())) {
-          parent.erase(it);
-        } else {
-          JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
-        }
-      } else if (parent.is_array()) {
-        // note erase performs range check
-        parent.erase(static_cast<size_type>(json_pointer::array_index(last_path)));
-      }
-    };
-
-    // type check: top level value must be an array
-    if (JSON_UNLIKELY(not json_patch.is_array())) {
-      JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
-    }
-
-    // iterate and apply the operations
-    for (const auto& val : json_patch) {
-      // wrapper to get a value for an operation
-      const auto get_value = [&val](const std::string& op,
-                                    const std::string& member,
-                                    bool string_type) -> basic_json& {
-        // find value
-        auto it = val.m_value.object->find(member);
-
-        // context-sensitive error message
-        const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
-
-        // check if desired value is present
-        if (JSON_UNLIKELY(it == val.m_value.object->end())) {
-          JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
-        }
-
-        // check if result is of type string
-        if (JSON_UNLIKELY(string_type and not it->second.is_string())) {
-          JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
-        }
-
-        // no error: return value
-        return it->second;
-      };
-
-      // type check: every element of the array must be an object
-      if (JSON_UNLIKELY(not val.is_object())) {
-        JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
-      }
-
-      // collect mandatory members
-      const std::string op = get_value("op", "op", true);
-      const std::string path = get_value(op, "path", true);
-      json_pointer ptr(path);
-
-      switch (get_op(op)) {
-        case patch_operations::add: {
-          operation_add(ptr, get_value("add", "value", false));
-          break;
-        }
-
-        case patch_operations::remove: {
-          operation_remove(ptr);
-          break;
-        }
-
-        case patch_operations::replace: {
-          // the "path" location must exist - use at()
-          result.at(ptr) = get_value("replace", "value", false);
-          break;
-        }
-
-        case patch_operations::move: {
-          const std::string from_path = get_value("move", "from", true);
-          json_pointer from_ptr(from_path);
-
-          // the "from" location must exist - use at()
-          basic_json v = result.at(from_ptr);
-
-          // The move operation is functionally identical to a
-          // "remove" operation on the "from" location, followed
-          // immediately by an "add" operation at the target
-          // location with the value that was just removed.
-          operation_remove(from_ptr);
-          operation_add(ptr, v);
-          break;
-        }
-
-        case patch_operations::copy: {
-          const std::string from_path = get_value("copy", "from", true);
-          const json_pointer from_ptr(from_path);
-
-          // the "from" location must exist - use at()
-          basic_json v = result.at(from_ptr);
-
-          // The copy is functionally identical to an "add"
-          // operation at the target location using the value
-          // specified in the "from" member.
-          operation_add(ptr, v);
-          break;
-        }
-
-        case patch_operations::test: {
-          bool success = false;
-          JSON_TRY
-          {
-            // check if "value" matches the one at "path"
-            // the "path" location must exist - use at()
-            success = (result.at(ptr) == get_value("test", "value", false));
-          }
-          JSON_CATCH(out_of_range&)
-          {
-            // ignore out of range errors: success remains false
-          }
-
-          // throw an exception if test fails
-          if (JSON_UNLIKELY(not success)) {
-            JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
-          }
-
-          break;
-        }
-
-        case patch_operations::invalid: {
-          // op must be "add", "remove", "replace", "move", "copy", or
-          // "test"
-          JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /*!
-    @brief creates a diff as a JSON patch
-
-    Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
-    be changed into the value @a target by calling @ref patch function.
-
-    @invariant For two JSON values @a source and @a target, the following code
-    yields always `true`:
-    @code {.cpp}
-    source.patch(diff(source, target)) == target;
-    @endcode
-
-    @note Currently, only `remove`, `add`, and `replace` operations are
-          generated.
-
-    @param[in] source  JSON value to compare from
-    @param[in] target  JSON value to compare against
-    @param[in] path    helper value to create JSON pointers
-
-    @return a JSON patch to convert the @a source to @a target
-
-    @complexity Linear in the lengths of @a source and @a target.
-
-    @liveexample{The following code shows how a JSON patch is created as a
-    diff for two JSON values.,diff}
-
-    @sa @ref patch -- apply a JSON patch
-    @sa @ref merge_patch -- apply a JSON Merge Patch
-
-    @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
-
-    @since version 2.0.0
-    */
-  static basic_json diff(const basic_json& source, const basic_json& target,
-                         const std::string& path = "")
-  {
-    // the patch
-    basic_json result(value_t::array);
-
-    // if the values are the same, return empty patch
-    if (source == target) {
-      return result;
-    }
-
-    if (source.type() != target.type()) {
-      // different types: replace value
-      result.push_back(
-        {{"op", "replace"}, {"path", path}, {"value", target}});
-    } else {
-      switch (source.type()) {
-        case value_t::array: {
-          // first pass: traverse common elements
-          std::size_t i = 0;
-          while (i < source.size() and i < target.size()) {
-            // recursive call to compare array values at index i
-            auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
-            result.insert(result.end(), temp_diff.begin(), temp_diff.end());
-            ++i;
-          }
-
-          // i now reached the end of at least one array
-          // in a second pass, traverse the remaining elements
-
-          // remove my remaining elements
-          const auto end_index = static_cast<difference_type>(result.size());
-          while (i < source.size()) {
-            // add operations in reverse order to avoid invalid
-            // indices
-            result.insert(result.begin() + end_index, object(
-                                                        {{"op", "remove"},
-                                                         {"path", path + "/" + std::to_string(i)}}));
-            ++i;
-          }
-
-          // add other remaining elements
-          while (i < target.size()) {
-            result.push_back(
-              {{"op", "add"},
-               {"path", path + "/" + std::to_string(i)},
-               {"value", target[i]}});
-            ++i;
-          }
-
-          break;
-        }
-
-        case value_t::object: {
-          // first pass: traverse this object's elements
-          for (auto it = source.cbegin(); it != source.cend(); ++it) {
-            // escape the key name to be used in a JSON patch
-            const auto key = json_pointer::escape(it.key());
-
-            if (target.find(it.key()) != target.end()) {
-              // recursive call to compare object values at key it
-              auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
-              result.insert(result.end(), temp_diff.begin(), temp_diff.end());
-            } else {
-              // found a key that is not in o -> remove it
-              result.push_back(object(
-                {{"op", "remove"}, {"path", path + "/" + key}}));
-            }
-          }
-
-          // second pass: traverse other object's elements
-          for (auto it = target.cbegin(); it != target.cend(); ++it) {
-            if (source.find(it.key()) == source.end()) {
-              // found a key that is not in this -> add it
-              const auto key = json_pointer::escape(it.key());
-              result.push_back(
-                {{"op", "add"}, {"path", path + "/" + key}, {"value", it.value()}});
-            }
-          }
-
-          break;
-        }
-
-        default: {
-          // both primitive type: replace value
-          result.push_back(
-            {{"op", "replace"}, {"path", path}, {"value", target}});
-          break;
-        }
-      }
-    }
-
-    return result;
-  }
-
-  /// @}
-
-  ////////////////////////////////
-  // JSON Merge Patch functions //
-  ////////////////////////////////
-
-  /// @name JSON Merge Patch functions
-  /// @{
-
-  /*!
-    @brief applies a JSON Merge Patch
-
-    The merge patch format is primarily intended for use with the HTTP PATCH
-    method as a means of describing a set of modifications to a target
-    resource's content. This function applies a merge patch to the current
-    JSON value.
-
-    The function implements the following algorithm from Section 2 of
-    [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):
-
-    ```
-    define MergePatch(Target, Patch):
-      if Patch is an Object:
-        if Target is not an Object:
-          Target = {} // Ignore the contents and set it to an empty Object
-        for each Name/Value pair in Patch:
-          if Value is null:
-            if Name exists in Target:
-              remove the Name/Value pair from Target
-          else:
-            Target[Name] = MergePatch(Target[Name], Value)
-        return Target
-      else:
-        return Patch
-    ```
-
-    Thereby, `Target` is the current object; that is, the patch is applied to
-    the current value.
-
-    @param[in] patch  the patch to apply
-
-    @complexity Linear in the lengths of @a patch.
-
-    @liveexample{The following code shows how a JSON Merge Patch is applied to
-    a JSON document.,merge_patch}
-
-    @sa @ref patch -- apply a JSON patch
-    @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
-
-    @since version 3.0.0
-    */
-  void merge_patch(const basic_json& patch)
-  {
-    if (patch.is_object()) {
-      if (not is_object()) {
-        *this = object();
-      }
-      for (auto it = patch.begin(); it != patch.end(); ++it) {
-        if (it.value().is_null()) {
-          erase(it.key());
-        } else {
-          operator[](it.key()).merge_patch(it.value());
-        }
-      }
-    } else {
-      *this = patch;
-    }
-  }
-
-  /// @}
-};
-} // namespace nlohmann
-
-///////////////////////
-// nonmember support //
-///////////////////////
-
-// specialization of std::swap, and std::hash
-namespace std
-{
-/*!
-@brief exchanges the values of two JSON objects
-
-@since version 1.0.0
-*/
-template <>
-inline void swap(nlohmann::json& j1,
-                 nlohmann::json& j2) noexcept(is_nothrow_move_constructible<nlohmann::json>::value and
-                                                is_nothrow_move_assignable<nlohmann::json>::value)
-{
-  j1.swap(j2);
-}
-
-/// hash value for JSON objects
-template <>
-struct hash<nlohmann::json> {
-  /*!
-    @brief return a hash value for a JSON object
-
-    @since version 1.0.0
-    */
-  std::size_t operator()(const nlohmann::json& j) const
-  {
-    // a naive hashing via the string representation
-    const auto& h = hash<nlohmann::json::string_t>();
-    return h(j.dump());
-  }
-};
-
-/// specialization for std::less<value_t>
-/// @note: do not remove the space after '<',
-///        see https://github.com/nlohmann/json/pull/679
-template <>
-struct less<::nlohmann::detail::value_t> {
-  /*!
-    @brief compare two value_t enum values
-    @since version 3.0.0
-    */
-  bool operator()(nlohmann::detail::value_t lhs,
-                  nlohmann::detail::value_t rhs) const noexcept
-  {
-    return nlohmann::detail::operator<(lhs, rhs);
-  }
-};
-
-} // namespace std
-
-/*!
-@brief user-defined string literal for JSON values
-
-This operator implements a user-defined string literal for JSON objects. It
-can be used by adding `"_json"` to a string literal and returns a JSON object
-if no parse error occurred.
-
-@param[in] s  a string representation of a JSON object
-@param[in] n  the length of string @a s
-@return a JSON object
-
-@since version 1.0.0
-*/
-inline nlohmann::json operator"" _json(const char* s, std::size_t n)
-{
-  return nlohmann::json::parse(s, s + n);
-}
-
-/*!
-@brief user-defined string literal for JSON pointer
-
-This operator implements a user-defined string literal for JSON Pointers. It
-can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
-object if no parse error occurred.
-
-@param[in] s  a string representation of a JSON Pointer
-@param[in] n  the length of string @a s
-@return a JSON pointer object
-
-@since version 2.0.0
-*/
-inline nlohmann::json::json_pointer operator"" _json_pointer(const char* s, std::size_t n)
-{
-  return nlohmann::json::json_pointer(std::string(s, n));
-}
-
-// #include <nlohmann/detail/macro_unscope.hpp>
-
-// restore GCC/clang diagnostic settings
-#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
-#pragma GCC diagnostic pop
-#endif
-#if defined(__clang__)
-#pragma GCC diagnostic pop
-#endif
-
-// clean up
-#undef JSON_CATCH
-#undef JSON_THROW
-#undef JSON_TRY
-#undef JSON_LIKELY
-#undef JSON_UNLIKELY
-#undef JSON_DEPRECATED
-#undef JSON_HAS_CPP_14
-#undef JSON_HAS_CPP_17
-#undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
-#undef NLOHMANN_BASIC_JSON_TPL
-#undef NLOHMANN_JSON_HAS_HELPER
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx b/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
index 2eec1959ab2cb..152d4e1be7d04 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
@@ -25,11 +25,9 @@
 
 #include "ITSBase/GeometryTGeo.h"
 #include "ITStracking/Constants.h"
-#include "ITStracking/json.h"
 #include "MathUtils/Utils.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
-#include "GPUCommonLogger.h"
 
 namespace
 {
@@ -42,9 +40,6 @@ namespace o2
 namespace its
 {
 
-void to_json(nlohmann::json& j, const TrackingParameters& par);
-void from_json(const nlohmann::json& j, TrackingParameters& par);
-
 /// convert compact clusters to 3D spacepoints
 void ioutils::convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
                                      gsl::span<const unsigned char>::iterator& pattIt,
diff --git a/Detectors/TRD/workflow/CMakeLists.txt b/Detectors/TRD/workflow/CMakeLists.txt
index 53bb79565c8c4..d28bea395e047 100644
--- a/Detectors/TRD/workflow/CMakeLists.txt
+++ b/Detectors/TRD/workflow/CMakeLists.txt
@@ -49,7 +49,8 @@ o2_add_library(TRDWorkflow
                                      O2::TPCWorkflow
                                      O2::TRDWorkflowIO
                                      O2::TRDPID
-                                     O2::DataFormatsFT0)
+                                     O2::DataFormatsFT0
+               PRIVATE_LINK_LIBRARIES nlohmann_json::nlohmann_json)
 
 o2_add_executable(trap-sim
                   COMPONENT_NAME trd
@@ -74,7 +75,7 @@ o2_add_executable(tracklet-transformer
 o2_add_executable(event-display-feed
                   COMPONENT_NAME trd
                   SOURCES src/TRDEventDisplayFeedWorkflow.cxx
-                  PUBLIC_LINK_LIBRARIES O2::TRDWorkflow)
+                  PUBLIC_LINK_LIBRARIES O2::TRDWorkflow nlohmann_json::nlohmann_json)
 
 o2_add_executable(trd-workflow
                   COMPONENT_NAME calibration
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDEventDisplayFeedSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDEventDisplayFeedSpec.h
index 74a0acdbdd354..3d04550f4f7f7 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDEventDisplayFeedSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDEventDisplayFeedSpec.h
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include <gsl/span>
+#include <nlohmann/json.hpp>
 
 #include "TRDBase/Geometry.h"
 #include "TRDBase/TrackletTransformer.h"
@@ -22,8 +23,6 @@
 #include "DataFormatsTRD/TriggerRecord.h"
 #include "DataFormatsTRD/Digit.h"
 
-#include "ITStracking/json.h"
-
 using json = nlohmann::json;
 
 namespace o2
diff --git a/dependencies/O2Dependencies.cmake b/dependencies/O2Dependencies.cmake
index 9020f99b4877b..0e0b1caf7d3ba 100644
--- a/dependencies/O2Dependencies.cmake
+++ b/dependencies/O2Dependencies.cmake
@@ -83,6 +83,9 @@ find_package(VMC MODULE)
 find_package(fmt)
 set_package_properties(fmt PROPERTIES TYPE REQUIRED)
 
+find_package(nlohmann_json)
+set_package_properties(nlohmann_json PROPERTIES TYPE REQUIRED)
+
 find_package(Boost 1.70
              COMPONENTS container
                         thread

From 359e28b71d2a79f66bb19487ebbb4f1583850787 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 27 May 2025 14:11:34 +0200
Subject: [PATCH 0420/1764] ITS: template Traits and TimeFrame (#14312)

* ITS: const log func

* ITS: apply virtual to vertexer

* ITS: template Traits and TimeFrame

* ITS: GPU: use non-templated trackinginterface

* ITS: GPU: user cpu vertexer until gpu finalized

* ITS: GPU: uses templated Traits/TimeFrame
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |   8 +-
 .../GPU/ITStrackingGPU/TrackerTraitsGPU.h     |  19 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |   8 +-
 .../GPU/ITStrackingGPU/VertexerTraitsGPU.h    |  31 +-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 184 ++++----
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  93 ++--
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  |  16 +-
 .../tracking/GPU/cuda/VertexerTraitsGPU.cxx   |   4 -
 .../tracking/include/ITStracking/TimeFrame.h  | 427 ++++++++----------
 .../tracking/include/ITStracking/Tracker.h    |  56 +--
 .../include/ITStracking/TrackerTraits.h       |  52 +--
 .../include/ITStracking/TrackingInterface.h   |   9 +-
 .../tracking/include/ITStracking/Vertexer.h   |  90 +---
 .../include/ITStracking/VertexerTraits.h      |  37 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 186 ++++----
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  73 +--
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 207 ++++-----
 .../ITS/tracking/src/TrackingInterface.cxx    |  20 +-
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      |  79 +---
 .../ITS/tracking/src/VertexerTraits.cxx       |   2 +-
 .../include/ITSWorkflow/TrackerSpec.h         |  11 +-
 .../include/ITS3Reconstruction/IOUtils.h      |   2 +-
 .../ITS3/reconstruction/src/IOUtils.cxx       |   2 +-
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |   6 +-
 GPU/GPUTracking/Base/GPUReconstruction.h      |   4 +-
 .../Base/GPUReconstructionIncludesITS.h       |   2 +
 .../Base/cuda/GPUReconstructionCUDA.cu        |   4 +-
 .../Base/cuda/GPUReconstructionCUDA.h         |   2 +-
 GPU/GPUTracking/Global/GPUChainITS.cxx        |   4 +-
 GPU/GPUTracking/Global/GPUChainITS.h          |   8 +-
 GPU/GPUTracking/Interface/GPUO2Interface.cxx  |   2 +-
 GPU/GPUTracking/Interface/GPUO2Interface.h    |   4 +-
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |   3 +-
 GPU/Workflow/src/GPUWorkflowITS.cxx           |   4 +-
 34 files changed, 674 insertions(+), 985 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 88666cdfdb7fb..14aa0ea5d67fb 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -30,7 +30,7 @@ class DefaultGPUAllocator : public ExternalAllocator
 };
 
 template <int nLayers = 7>
-class TimeFrameGPU : public TimeFrame
+class TimeFrameGPU : public TimeFrame<nLayers>
 {
  public:
   TimeFrameGPU();
@@ -205,14 +205,14 @@ class TimeFrameGPU : public TimeFrame
 template <int nLayers>
 inline int TimeFrameGPU<nLayers>::getNClustersInRofSpan(const int rofIdstart, const int rofSpanSize, const int layerId) const
 {
-  return static_cast<int>(mROFramesClusters[layerId][(rofIdstart + rofSpanSize) < mROFramesClusters.size() ? rofIdstart + rofSpanSize : mROFramesClusters.size() - 1] - mROFramesClusters[layerId][rofIdstart]);
+  return static_cast<int>(this->mROFramesClusters[layerId][(rofIdstart + rofSpanSize) < this->mROFramesClusters.size() ? rofIdstart + rofSpanSize : this->mROFramesClusters.size() - 1] - this->mROFramesClusters[layerId][rofIdstart]);
 }
 
 template <int nLayers>
 inline std::vector<unsigned int> TimeFrameGPU<nLayers>::getClusterSizes()
 {
-  std::vector<unsigned int> sizes(mUnsortedClusters.size());
-  std::transform(mUnsortedClusters.begin(), mUnsortedClusters.end(), sizes.begin(),
+  std::vector<unsigned int> sizes(this->mUnsortedClusters.size());
+  std::transform(this->mUnsortedClusters.begin(), this->mUnsortedClusters.end(), sizes.begin(),
                  [](const auto& v) { return static_cast<unsigned int>(v.size()); });
   return sizes;
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
index c765307473749..1654f8cc8cf94 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
@@ -16,19 +16,17 @@
 #include "ITStracking/TrackerTraits.h"
 #include "ITStrackingGPU/TimeFrameGPU.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 template <int nLayers = 7>
-class TrackerTraitsGPU final : public TrackerTraits
+class TrackerTraitsGPU final : public TrackerTraits<nLayers>
 {
  public:
   TrackerTraitsGPU() = default;
   ~TrackerTraitsGPU() override = default;
 
-  void adoptTimeFrame(TimeFrame* tf) final;
+  void adoptTimeFrame(TimeFrame<nLayers>* tf) final;
   void initialiseTimeFrame(const int iteration) final;
 
   void computeLayerTracklets(const int iteration, int, int) final;
@@ -54,13 +52,6 @@ class TrackerTraitsGPU final : public TrackerTraits
   gpu::TimeFrameGPU<7>* mTimeFrameGPU;
 };
 
-template <int nLayers>
-inline void TrackerTraitsGPU<nLayers>::adoptTimeFrame(TimeFrame* tf)
-{
-  mTimeFrameGPU = static_cast<gpu::TimeFrameGPU<nLayers>*>(tf);
-  mTimeFrame = static_cast<TimeFrame*>(tf);
-}
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 21b14fd9292d2..aabd3a940a532 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -73,8 +73,8 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  const float NSigmaCut,
                                  std::vector<float>& phiCuts,
                                  const float resolutionPV,
-                                 std::vector<float>& minR,
-                                 std::vector<float>& maxR,
+                                 std::array<float, nLayers>& minR,
+                                 std::array<float, nLayers>& maxR,
                                  std::vector<float>& resolutions,
                                  std::vector<float>& radii,
                                  std::vector<float>& mulScatAng,
@@ -106,8 +106,8 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    const float NSigmaCut,
                                    std::vector<float>& phiCuts,
                                    const float resolutionPV,
-                                   std::vector<float>& minR,
-                                   std::vector<float>& maxR,
+                                   std::array<float, nLayers>& minR,
+                                   std::array<float, nLayers>& maxR,
                                    std::vector<float>& resolutions,
                                    std::vector<float>& radii,
                                    std::vector<float>& mulScatAng,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
index eb4dc2179cdb4..a5c3709081a82 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
@@ -37,37 +37,30 @@ class ROframe;
 
 using constants::its2::InversePhiBinSize;
 
-class VertexerTraitsGPU : public VertexerTraits
+class VertexerTraitsGPU final : public VertexerTraits
 {
  public:
-  VertexerTraitsGPU();
-  ~VertexerTraitsGPU() = default;
-  void initialise(const TrackingParameters&, const int iteration = 0) override;
-  void adoptTimeFrame(TimeFrame*) override;
-  void computeTracklets(const int iteration = 0) override;
-  void computeTrackletMatching(const int iteration = 0) override;
-  void computeVertices(const int iteration = 0) override;
-  void updateVertexingParameters(const std::vector<VertexingParameters>&, const TimeFrameGPUParameters&) override;
-
-  // Hybrid
-  void initialiseHybrid(const TrackingParameters& pars, const int iteration = 0) override { VertexerTraits::initialise(pars, iteration); }
-  void computeTrackletsHybrid(const int iteration = 0) override { VertexerTraits::computeTracklets(iteration); }
-  void computeTrackletMatchingHybrid(const int iteration = 0) override { VertexerTraits::computeTrackletMatching(iteration); }
-  void computeVerticesHybrid(const int iteration = 0) override { VertexerTraits::computeVertices(iteration); }
-  void adoptTimeFrameHybrid(TimeFrame* tf) override { VertexerTraits::adoptTimeFrame(tf); }
-
+  void initialise(const TrackingParameters&, const int iteration = 0) final;
+  void adoptTimeFrame(TimeFrame<7>*) noexcept final;
+  void computeTracklets(const int iteration = 0) final;
+  void computeTrackletMatching(const int iteration = 0) final;
+  void computeVertices(const int iteration = 0) final;
+  void updateVertexingParameters(const std::vector<VertexingParameters>&, const TimeFrameGPUParameters&) final;
   void computeVerticesHist();
 
+  bool isGPU() const noexcept final { return true; }
+  const char* getName() const noexcept final { return "GPU"; }
+
  protected:
   IndexTableUtils* mDeviceIndexTableUtils;
   gpu::TimeFrameGPU<7>* mTimeFrameGPU;
   TimeFrameGPUParameters mTfGPUParams;
 };
 
-inline void VertexerTraitsGPU::adoptTimeFrame(TimeFrame* tf)
+inline void VertexerTraitsGPU::adoptTimeFrame(TimeFrame<7>* tf) noexcept
 {
   mTimeFrameGPU = static_cast<gpu::TimeFrameGPU<7>*>(tf);
-  mTimeFrame = static_cast<TimeFrame*>(tf);
+  mTimeFrame = static_cast<TimeFrame<7>*>(tf);
 }
 
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index ee99955ba6669..5a1e9148c0548 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -94,7 +94,7 @@ void* DefaultGPUAllocator::allocate(size_t size)
 template <int nLayers>
 TimeFrameGPU<nLayers>::TimeFrameGPU()
 {
-  mIsGPU = true;
+  this->mIsGPU = true;
 }
 
 template <int nLayers>
@@ -104,7 +104,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream* strPtr, bool extAllocator)
 {
   if (extAllocator) {
-    *ptr = mAllocator->allocate(size);
+    *ptr = this->mAllocator->allocate(size);
   } else {
     LOGP(debug, "Calling default CUDA allocator");
     GPUChkErrS(cudaMallocAsync(reinterpret_cast<void**>(ptr), size, strPtr->get()));
@@ -114,7 +114,7 @@ void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream* strPt
 template <int nLayers>
 void TimeFrameGPU<nLayers>::setDevicePropagator(const o2::base::PropagatorImpl<float>* propagator)
 {
-  mPropagatorDevice = propagator;
+  this->mPropagatorDevice = propagator;
 }
 
 template <int nLayers>
@@ -123,10 +123,10 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading indextable utils");
   if (!iteration) {
     LOGP(debug, "gpu-allocation: allocating IndexTableUtils buffer, for {} MB.", sizeof(IndexTableUtils) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), nullptr, this->getExtAllocator());
   }
   LOGP(debug, "gpu-transfer: loading IndexTableUtils object, for {} MB.", sizeof(IndexTableUtils) / MB);
-  GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &mIndexTableUtils, sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
@@ -136,12 +136,12 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
   if (!iteration) {
     START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading unsorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading {} unsorted clusters on layer {}, for {} MB.", mUnsortedClusters[iLayer].size(), iLayer, mUnsortedClusters[iLayer].size() * sizeof(Cluster) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), mUnsortedClusters[iLayer].size() * sizeof(Cluster), nullptr, getExtAllocator());
-      GPUChkErrS(cudaHostRegister(mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], mUnsortedClusters[iLayer].data(), mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      LOGP(debug, "gpu-transfer: loading {} unsorted clusters on layer {}, for {} MB.", this->mUnsortedClusters[iLayer].size(), iLayer, this->mUnsortedClusters[iLayer].size() * sizeof(Cluster) / MB);
+      allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), nullptr, this->getExtAllocator());
+      GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
+      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
@@ -154,12 +154,12 @@ void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
   if (!iteration) {
     START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading {} clusters on layer {}, for {} MB.", mClusters[iLayer].size(), iLayer, mClusters[iLayer].size() * sizeof(Cluster) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), mClusters[iLayer].size() * sizeof(Cluster), nullptr, getExtAllocator());
-      GPUChkErrS(cudaHostRegister(mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], mClusters[iLayer].data(), mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      LOGP(debug, "gpu-transfer: loading {} clusters on layer {}, for {} MB.", this->mClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(Cluster) / MB);
+      allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), this->mClusters[iLayer].size() * sizeof(Cluster), nullptr, this->getExtAllocator());
+      GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
+      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
@@ -172,11 +172,11 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
   if (!iteration) {
     START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading clusters indextable for layer {} with {} elements, for {} MB.", iLayer, mIndexTables[iLayer].size(), mIndexTables[iLayer].size() * sizeof(int) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), mIndexTables[iLayer].size() * sizeof(int), nullptr, getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], mIndexTables[iLayer].data(), mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      LOGP(debug, "gpu-transfer: loading clusters indextable for layer {} with {} elements, for {} MB.", iLayer, this->mIndexTables[iLayer].size(), this->mIndexTables[iLayer].size() * sizeof(int) / MB);
+      allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), this->mIndexTables[iLayer].size() * sizeof(int), nullptr, this->getExtAllocator());
+      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
@@ -188,11 +188,11 @@ void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
   if (!iteration) {
     START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating used clusters flags");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: creating {} used clusters flags on layer {}, for {} MB.", mUsedClusters[iLayer].size(), iLayer, mUsedClusters[iLayer].size() * sizeof(unsigned char) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), mUsedClusters[iLayer].size() * sizeof(unsigned char), nullptr, getExtAllocator());
-      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0]->get()));
+      LOGP(debug, "gpu-transfer: creating {} used clusters flags on layer {}, for {} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / MB);
+      allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), nullptr, this->getExtAllocator());
+      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0]->get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
@@ -203,8 +203,8 @@ void TimeFrameGPU<nLayers>::loadUsedClustersDevice()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading used clusters flags");
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading {} used clusters flags on layer {}, for {} MB.", mUsedClusters[iLayer].size(), iLayer, mClusters[iLayer].size() * sizeof(unsigned char) / MB);
-    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], mUsedClusters[iLayer].data(), mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    LOGP(debug, "gpu-transfer: loading {} used clusters flags on layer {}, for {} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(unsigned char) / MB);
+    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -215,11 +215,11 @@ void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
   if (!iteration) {
     START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading ROframe clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading {} ROframe clusters info on layer {}, for {} MB.", mROFramesClusters[iLayer].size(), iLayer, mROFramesClusters[iLayer].size() * sizeof(int) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), mROFramesClusters[iLayer].size() * sizeof(int), nullptr, getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], mROFramesClusters[iLayer].data(), mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      LOGP(debug, "gpu-transfer: loading {} ROframe clusters info on layer {}, for {} MB.", this->mROFramesClusters[iLayer].size(), iLayer, this->mROFramesClusters[iLayer].size() * sizeof(int) / MB);
+      allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), this->mROFramesClusters[iLayer].size() * sizeof(int), nullptr, this->getExtAllocator());
+      GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
@@ -231,12 +231,12 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading trackingframeinfo");
   if (!iteration) {
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading {} tfinfo on layer {}, for {} MB.", mTrackingFrameInfo[iLayer].size(), iLayer, mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), nullptr, getExtAllocator());
-      GPUChkErrS(cudaHostRegister(mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], mTrackingFrameInfo[iLayer].data(), mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      LOGP(debug, "gpu-transfer: loading {} tfinfo on layer {}, for {} MB.", this->mTrackingFrameInfo[iLayer].size(), iLayer, this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / MB);
+      allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), nullptr, this->getExtAllocator());
+      GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
+      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
@@ -248,9 +248,9 @@ void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
 {
   if (!iteration) {
     START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading multiplicity cut mask");
-    LOGP(debug, "gpu-transfer: loading multiplicity cut mask with {} elements, for {} MB.", mMultiplicityCutMask.size(), mMultiplicityCutMask.size() * sizeof(bool) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), mMultiplicityCutMask.size() * sizeof(uint8_t), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, mMultiplicityCutMask.data(), mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    LOGP(debug, "gpu-transfer: loading multiplicity cut mask with {} elements, for {} MB.", this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(bool) / MB);
+    allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), nullptr, this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
@@ -260,12 +260,12 @@ void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
 {
   if (!iteration) {
     START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading seeding vertices");
-    LOGP(debug, "gpu-transfer: loading {} ROframes vertices, for {} MB.", mROFramesPV.size(), mROFramesPV.size() * sizeof(int) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), mROFramesPV.size() * sizeof(int), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, mROFramesPV.data(), mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-    LOGP(debug, "gpu-transfer: loading {} seeding vertices, for {} MB.", mPrimaryVertices.size(), mPrimaryVertices.size() * sizeof(Vertex) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), mPrimaryVertices.size() * sizeof(Vertex), nullptr, getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, mPrimaryVertices.data(), mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    LOGP(debug, "gpu-transfer: loading {} ROframes vertices, for {} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / MB);
+    allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), nullptr, this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    LOGP(debug, "gpu-transfer: loading {} seeding vertices, for {} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / MB);
+    allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), nullptr, this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
     STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
   }
 }
@@ -276,13 +276,13 @@ void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating tracklets LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     if (!iteration) {
-      LOGP(debug, "gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {} MB.", mClusters[iLayer].size() + 1, iLayer, (mClusters[iLayer].size() + 1) * sizeof(int) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (mClusters[iLayer].size() + 1) * sizeof(int), nullptr, getExtAllocator());
+      LOGP(debug, "gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {} MB.", this->mClusters[iLayer].size() + 1, iLayer, (this->mClusters[iLayer].size() + 1) * sizeof(int) / MB);
+      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (this->mClusters[iLayer].size() + 1) * sizeof(int), nullptr, this->getExtAllocator());
     }
-    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0]->get()));
   }
   if (!iteration) {
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
@@ -294,11 +294,11 @@ void TimeFrameGPU<nLayers>::createTrackletsBuffers()
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells buffers");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     mNTracklets[iLayer] = 0;
-    GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost));
+    GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + this->mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost));
     LOGP(debug, "gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {} MB.", mNTracklets[iLayer], iLayer, mNTracklets[iLayer] * sizeof(Tracklet) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), nullptr, this->getExtAllocator());
   }
-  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), nullptr, getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), nullptr, this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
@@ -309,9 +309,9 @@ void TimeFrameGPU<nLayers>::loadTrackletsDevice()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading {} tracklets on layer {}, for {} MB.", mTracklets[iLayer].size(), iLayer, mTracklets[iLayer].size() * sizeof(Tracklet) / MB);
-    GPUChkErrS(cudaHostRegister(mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], mTracklets[iLayer].data(), mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    LOGP(debug, "gpu-transfer: loading {} tracklets on layer {}, for {} MB.", this->mTracklets[iLayer].size(), iLayer, this->mTracklets[iLayer].size() * sizeof(Tracklet) / MB);
+    GPUChkErrS(cudaHostRegister(this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -321,9 +321,9 @@ void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {} MB", mTrackletsLookupTable[iLayer].size(), iLayer + 1, mTrackletsLookupTable[iLayer].size() * sizeof(int) / MB);
-    GPUChkErrS(cudaHostRegister(mTrackletsLookupTable[iLayer].data(), mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], mTrackletsLookupTable[iLayer].data(), mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice));
+    LOGP(debug, "gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {} MB", this->mTrackletsLookupTable[iLayer].size(), iLayer + 1, this->mTrackletsLookupTable[iLayer].size() * sizeof(int) / MB);
+    GPUChkErrS(cudaHostRegister(this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice));
   }
   GPUChkErrS(cudaHostRegister(mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
@@ -335,12 +335,12 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells neighbours");
   // Here we do also the creation of the CellsDeviceArray, as the cells buffers are populated separately in the previous steps.
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0]->get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
@@ -351,7 +351,7 @@ void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const uns
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighboursLUT");
   LOGP(debug, "gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), nullptr, getExtAllocator()); // We need one element more to move exc -> inc
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), nullptr, this->getExtAllocator()); // We need one element more to move exc -> inc
   GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0]->get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -361,13 +361,13 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading cell seeds");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading {} cell seeds on layer {}, for {} MB.", mCells[iLayer].size(), iLayer, mCells[iLayer].size() * sizeof(CellSeed) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), mCells[iLayer].size() * sizeof(CellSeed), nullptr, getExtAllocator());
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mCells[iLayer].size() + 1) * sizeof(int), nullptr, getExtAllocator()); // accessory for the neigh. finding.
-    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0]->get()));
-    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], mCells[iLayer].data(), mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    LOGP(debug, "gpu-transfer: loading {} cell seeds on layer {}, for {} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeed) / MB);
+    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeed), nullptr, this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), nullptr, this->getExtAllocator()); // accessory for the neigh. finding.
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, this->getExtAllocator());
   GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -378,10 +378,10 @@ void TimeFrameGPU<nLayers>::createCellsLUTDevice()
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: creating cell LUT for {} elements on layer {}, for {} MB.", mNTracklets[iLayer] + 1, iLayer, (mNTracklets[iLayer] + 1) * sizeof(int) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), nullptr, getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0]->get()));
   }
-  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), nullptr, getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), nullptr, this->getExtAllocator());
   GPUChkErrS(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -393,7 +393,7 @@ void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
   mNCells[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost));
   LOGP(debug, "gpu-transfer: creating cell buffer for {} elements on layer {}, for {} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), nullptr, getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), nullptr, this->getExtAllocator());
 
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -403,9 +403,9 @@ void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading cells LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading cell LUT for {} elements on layer {}, for {} MB.", mCellsLookupTable[iLayer].size(), iLayer, mCellsLookupTable[iLayer].size() * sizeof(int) / MB);
-    GPUChkErrS(cudaHostRegister(mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], mCellsLookupTable[iLayer].data(), mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    LOGP(debug, "gpu-transfer: loading cell LUT for {} elements on layer {}, for {} MB.", this->mCellsLookupTable[iLayer].size(), iLayer, this->mCellsLookupTable[iLayer].size() * sizeof(int) / MB);
+    GPUChkErrS(cudaHostRegister(this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
+    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -413,10 +413,10 @@ void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadRoadsDevice()
 {
-  LOGP(debug, "gpu-transfer: loading {} roads, for {} MB.", mRoads.size(), mRoads.size() * sizeof(Road<nLayers - 2>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), mRoads.size() * sizeof(Road<nLayers - 2>), mGpuStreams[0], getExtAllocator());
-  GPUChkErrS(cudaHostRegister(mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, mRoads.data(), mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  LOGP(debug, "gpu-transfer: loading {} roads, for {} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / MB);
+  allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), mGpuStreams[0], this->getExtAllocator());
+  GPUChkErrS(cudaHostRegister(this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
 }
 
 template <int nLayers>
@@ -424,7 +424,7 @@ void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(std::vector<CellSeed>& seeds)
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading track seeds");
   LOGP(debug, "gpu-transfer: loading {} track seeds, for {} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), mGpuStreams[0], getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
@@ -435,10 +435,10 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, con
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0], getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0]->get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), mGpuStreams[0], getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), mGpuStreams[0], this->getExtAllocator());
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
@@ -446,13 +446,13 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, std::vector<std::pair<int, int>>& neighbours)
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
-  mCellsNeighbours[layer].clear();
-  mCellsNeighbours[layer].resize(neighbours.size());
+  this->mCellsNeighbours[layer].clear();
+  this->mCellsNeighbours[layer].resize(neighbours.size());
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0], getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0]->get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), mGpuStreams[0], getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
 
@@ -460,7 +460,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDeviceArray()
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -472,7 +472,7 @@ void TimeFrameGPU<nLayers>::createTrackITSExtDevice(std::vector<CellSeed>& seeds
   mTrackITSExt.clear();
   mTrackITSExt.resize(seeds.size());
   LOGP(debug, "gpu-allocation: reserving {} tracks, for {} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0], getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0]->get()));
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
@@ -484,8 +484,8 @@ void TimeFrameGPU<nLayers>::downloadCellsDevice()
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading cells");
   for (int iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading {} cells on layer: {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
-    mCells[iLayer].resize(mNCells[iLayer]);
-    GPUChkErrS(cudaMemcpyAsync(mCells[iLayer].data(), mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
+    this->mCells[iLayer].resize(mNCells[iLayer]);
+    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -496,8 +496,8 @@ void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading cell luts");
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading cells lut on layer {} for {} elements", iLayer, (mNTracklets[iLayer + 1] + 1));
-    mCellsLookupTable[iLayer].resize(mNTracklets[iLayer + 1] + 1);
-    GPUChkErrS(cudaMemcpyAsync(mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
+    this->mCellsLookupTable[iLayer].resize(mNTracklets[iLayer + 1] + 1);
+    GPUChkErrS(cudaMemcpyAsync(this->mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
@@ -545,9 +545,9 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
 {
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-    GPUChkErrS(cudaHostUnregister(mUnsortedClusters[iLayer].data()));
-    GPUChkErrS(cudaHostUnregister(mClusters[iLayer].data()));
-    GPUChkErrS(cudaHostUnregister(mTrackingFrameInfo[iLayer].data()));
+    GPUChkErrS(cudaHostUnregister(this->mUnsortedClusters[iLayer].data()));
+    GPUChkErrS(cudaHostUnregister(this->mClusters[iLayer].data()));
+    GPUChkErrS(cudaHostUnregister(this->mTrackingFrameInfo[iLayer].data()));
   }
   GPUChkErrS(cudaHostUnregister(mTrackingFrameInfoDevice.data()));
   GPUChkErrS(cudaHostUnregister(mUnsortedClustersDevice.data()));
@@ -565,7 +565,7 @@ void TimeFrameGPU<nLayers>::initialise(const int iteration,
   for (auto& str : mGpuStreams) {
     str = new Stream();
   }
-  o2::its::TimeFrame::initialise(iteration, trkParam, maxLayers);
+  o2::its::TimeFrame<nLayers>::initialise(iteration, trkParam, maxLayers);
 }
 
 template class TimeFrameGPU<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index f3b62ec8a6108..8741b42a697a8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -25,7 +25,7 @@ constexpr int UnusedIndex{-1};
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
 {
-  mTimeFrameGPU->initialise(iteration, mTrkParams[iteration], nLayers);
+  mTimeFrameGPU->initialise(iteration, this->mTrkParams[iteration], nLayers);
   mTimeFrameGPU->loadClustersDevice(iteration);
   mTimeFrameGPU->loadUnsortedClustersDevice(iteration);
   mTimeFrameGPU->loadClustersIndexTables(iteration);
@@ -37,23 +37,30 @@ void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
   mTimeFrameGPU->loadIndexTableUtils(iteration);
 }
 
+template <int nLayers>
+void TrackerTraitsGPU<nLayers>::adoptTimeFrame(TimeFrame<nLayers>* tf)
+{
+  mTimeFrameGPU = static_cast<gpu::TimeFrameGPU<nLayers>*>(tf);
+  this->mTimeFrame = static_cast<TimeFrame<nLayers>*>(tf);
+}
+
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   mTimeFrameGPU->createTrackletsLUTDevice(iteration);
 
-  const Vertex diamondVert({mTrkParams[iteration].Diamond[0], mTrkParams[iteration].Diamond[1], mTrkParams[iteration].Diamond[2]}, {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f}, 1, 1.f);
+  const Vertex diamondVert({this->mTrkParams[iteration].Diamond[0], this->mTrkParams[iteration].Diamond[1], this->mTrkParams[iteration].Diamond[2]}, {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f}, 1, 1.f);
   gsl::span<const Vertex> diamondSpan(&diamondVert, 1);
-  int startROF{mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * mTrkParams[iteration].nROFsPerIterations : 0};
-  int endROF{o2::gpu::CAMath::Min(mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * mTrkParams[iteration].nROFsPerIterations + mTrkParams[iteration].DeltaROF : mTimeFrameGPU->getNrof(), mTimeFrameGPU->getNrof())};
+  int startROF{this->mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * this->mTrkParams[iteration].nROFsPerIterations : 0};
+  int endROF{o2::gpu::CAMath::Min(this->mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * this->mTrkParams[iteration].nROFsPerIterations + this->mTrkParams[iteration].DeltaROF : mTimeFrameGPU->getNrof(), mTimeFrameGPU->getNrof())};
 
   countTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
                                        mTimeFrameGPU->getDeviceMultCutMask(),
                                        startROF,
                                        endROF,
                                        mTimeFrameGPU->getNrof(),
-                                       mTrkParams[iteration].DeltaROF,
+                                       this->mTrkParams[iteration].DeltaROF,
                                        iVertex,
                                        mTimeFrameGPU->getDeviceVertices(),
                                        mTimeFrameGPU->getDeviceROFramesPV(),
@@ -66,13 +73,13 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                        mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
                                        mTimeFrameGPU->getDeviceTrackletsLUTs(), // Required for the exclusive sums
                                        iteration,
-                                       mTrkParams[iteration].NSigmaCut,
+                                       this->mTrkParams[iteration].NSigmaCut,
                                        mTimeFrameGPU->getPhiCuts(),
-                                       mTrkParams[iteration].PVres,
+                                       this->mTrkParams[iteration].PVres,
                                        mTimeFrameGPU->getMinRs(),
                                        mTimeFrameGPU->getMaxRs(),
                                        mTimeFrameGPU->getPositionResolutions(),
-                                       mTrkParams[iteration].LayerRadii,
+                                       this->mTrkParams[iteration].LayerRadii,
                                        mTimeFrameGPU->getMSangles(),
                                        conf.nBlocks,
                                        conf.nThreads);
@@ -82,7 +89,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          startROF,
                                          endROF,
                                          mTimeFrameGPU->getNrof(),
-                                         mTrkParams[iteration].DeltaROF,
+                                         this->mTrkParams[iteration].DeltaROF,
                                          iVertex,
                                          mTimeFrameGPU->getDeviceVertices(),
                                          mTimeFrameGPU->getDeviceROFramesPV(),
@@ -98,13 +105,13 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
                                          mTimeFrameGPU->getDeviceTrackletsLUTs(),
                                          iteration,
-                                         mTrkParams[iteration].NSigmaCut,
+                                         this->mTrkParams[iteration].NSigmaCut,
                                          mTimeFrameGPU->getPhiCuts(),
-                                         mTrkParams[iteration].PVres,
+                                         this->mTrkParams[iteration].PVres,
                                          mTimeFrameGPU->getMinRs(),
                                          mTimeFrameGPU->getMaxRs(),
                                          mTimeFrameGPU->getPositionResolutions(),
-                                         mTrkParams[iteration].LayerRadii,
+                                         this->mTrkParams[iteration].LayerRadii,
                                          mTimeFrameGPU->getMSangles(),
                                          conf.nBlocks,
                                          conf.nThreads);
@@ -116,7 +123,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
   mTimeFrameGPU->createCellsLUTDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
+  for (int iLayer = 0; iLayer < this->mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
     if (!mTimeFrameGPU->getNTracklets()[iLayer + 1] || !mTimeFrameGPU->getNTracklets()[iLayer]) {
       continue;
     }
@@ -131,10 +138,10 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                       nullptr,
                       mTimeFrameGPU->getDeviceArrayCellsLUT(),
                       mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
-                      mBz,
-                      mTrkParams[iteration].MaxChi2ClusterAttachment,
-                      mTrkParams[iteration].CellDeltaTanLambdaSigma,
-                      mTrkParams[iteration].NSigmaCut,
+                      this->mBz,
+                      this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                      this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
+                      this->mTrkParams[iteration].NSigmaCut,
                       conf.nBlocks,
                       conf.nThreads);
     mTimeFrameGPU->createCellsBuffers(iLayer);
@@ -148,10 +155,10 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                         mTimeFrameGPU->getDeviceCells()[iLayer],
                         mTimeFrameGPU->getDeviceArrayCellsLUT(),
                         mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
-                        mBz,
-                        mTrkParams[iteration].MaxChi2ClusterAttachment,
-                        mTrkParams[iteration].CellDeltaTanLambdaSigma,
-                        mTrkParams[iteration].NSigmaCut,
+                        this->mBz,
+                        this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                        this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
+                        this->mTrkParams[iteration].NSigmaCut,
                         conf.nBlocks,
                         conf.nThreads);
   }
@@ -162,7 +169,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
 {
   mTimeFrameGPU->createNeighboursIndexTablesDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
-  for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
+  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
     const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};
 
     if (!nextLayerCellsNum) {
@@ -175,8 +182,8 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                                      mTimeFrameGPU->getDeviceArrayCellsLUT(),
                                                      mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                                      mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
-                                                     mTrkParams[0].MaxChi2ClusterAttachment,
-                                                     mBz,
+                                                     this->mTrkParams[0].MaxChi2ClusterAttachment,
+                                                     this->mBz,
                                                      iLayer,
                                                      mTimeFrameGPU->getNCells()[iLayer],
                                                      nextLayerCellsNum,
@@ -191,8 +198,8 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                  mTimeFrameGPU->getDeviceArrayCellsLUT(),
                                  mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                  mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
-                                 mTrkParams[0].MaxChi2ClusterAttachment,
-                                 mBz,
+                                 this->mTrkParams[0].MaxChi2ClusterAttachment,
+                                 this->mBz,
                                  iLayer,
                                  mTimeFrameGPU->getNCells()[iLayer],
                                  nextLayerCellsNum,
@@ -212,11 +219,11 @@ template <int nLayers>
 void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
-  for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
+  for (int startLevel{this->mTrkParams[iteration].CellsPerRoad()}; startLevel >= this->mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     const int minimumLayer{startLevel - 1};
     std::vector<CellSeed> trackSeeds;
-    for (int startLayer{mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= minimumLayer; --startLayer) {
-      if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
+    for (int startLayer{this->mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= minimumLayer; --startLayer) {
+      if ((this->mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
       }
       processNeighboursHandler<nLayers>(startLayer,
@@ -229,11 +236,11 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         mTimeFrameGPU->getDeviceNeighboursLUTs(),
                                         mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                                         trackSeeds,
-                                        mBz,
-                                        mTrkParams[0].MaxChi2ClusterAttachment,
-                                        mTrkParams[0].MaxChi2NDF,
+                                        this->mBz,
+                                        this->mTrkParams[0].MaxChi2ClusterAttachment,
+                                        this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
-                                        mCorrType,
+                                        this->mCorrType,
                                         conf.nBlocks,
                                         conf.nThreads);
     }
@@ -248,14 +255,14 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
     trackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),             // CellSeed* trackSeeds
                      mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(), // TrackingFrameInfo** foundTrackingFrameInfo
                      mTimeFrameGPU->getDeviceTrackITSExt(),            // o2::its::TrackITSExt* tracks
-                     mTrkParams[iteration].MinPt,                      // std::vector<float>& minPtsHost,
+                     this->mTrkParams[iteration].MinPt,                // std::vector<float>& minPtsHost,
                      trackSeeds.size(),                                // const size_t nSeeds
-                     mBz,                                              // const float Bz
+                     this->mBz,                                        // const float Bz
                      startLevel,                                       // const int startLevel,
-                     mTrkParams[0].MaxChi2ClusterAttachment,           // float maxChi2ClusterAttachment
-                     mTrkParams[0].MaxChi2NDF,                         // float maxChi2NDF
+                     this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
+                     this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
                      mTimeFrameGPU->getDevicePropagator(),             // const o2::base::Propagator* propagator
-                     mCorrType,                                        // o2::base::PropagatorImpl<float>::MatCorrType
+                     this->mCorrType,                                  // o2::base::PropagatorImpl<float>::MatCorrType
                      conf.nBlocks,
                      conf.nThreads);
 
@@ -269,7 +276,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
       }
       int nShared = 0;
       bool isFirstShared{false};
-      for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
+      for (int iLayer{0}; iLayer < this->mTrkParams[0].NLayers; ++iLayer) {
         if (track.getClusterIndex(iLayer) == UnusedIndex) {
           continue;
         }
@@ -277,12 +284,12 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
         isFirstShared |= !iLayer && mTimeFrameGPU->isClusterUsed(iLayer, track.getClusterIndex(iLayer));
       }
 
-      if (nShared > mTrkParams[0].ClusterSharing) {
+      if (nShared > this->mTrkParams[0].ClusterSharing) {
         continue;
       }
 
       std::array<int, 3> rofs{INT_MAX, INT_MAX, INT_MAX};
-      for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
+      for (int iLayer{0}; iLayer < this->mTrkParams[0].NLayers; ++iLayer) {
         if (track.getClusterIndex(iLayer) == UnusedIndex) {
           continue;
         }
@@ -307,7 +314,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
     }
     mTimeFrameGPU->loadUsedClustersDevice();
   }
-  if (iteration == mTrkParams.size() - 1) {
+  if (iteration == this->mTrkParams.size() - 1) {
     mTimeFrameGPU->unregisterHostMemory(0);
   }
 };
@@ -333,7 +340,7 @@ int TrackerTraitsGPU<nLayers>::getTFNumberOfCells() const
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::setBz(float bz)
 {
-  mBz = bz;
+  this->mBz = bz;
   mTimeFrameGPU->setBz(bz);
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index bb39e9e70341b..0dc5c28b3bc65 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -864,8 +864,8 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  const float NSigmaCut,
                                  std::vector<float>& phiCuts,
                                  const float resolutionPV,
-                                 std::vector<float>& minRs,
-                                 std::vector<float>& maxRs,
+                                 std::array<float, nLayers>& minRs,
+                                 std::array<float, nLayers>& maxRs,
                                  std::vector<float>& resolutions,
                                  std::vector<float>& radii,
                                  std::vector<float>& mulScatAng,
@@ -930,8 +930,8 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    const float NSigmaCut,
                                    std::vector<float>& phiCuts,
                                    const float resolutionPV,
-                                   std::vector<float>& minRs,
-                                   std::vector<float>& maxRs,
+                                   std::array<float, nLayers>& minRs,
+                                   std::array<float, nLayers>& maxRs,
                                    std::vector<float>& resolutions,
                                    std::vector<float>& radii,
                                    std::vector<float>& mulScatAng,
@@ -1318,8 +1318,8 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                              const float NSigmaCut,
                                              std::vector<float>& phiCuts,
                                              const float resolutionPV,
-                                             std::vector<float>& minRs,
-                                             std::vector<float>& maxRs,
+                                             std::array<float, 7>& minRs,
+                                             std::array<float, 7>& maxRs,
                                              std::vector<float>& resolutions,
                                              std::vector<float>& radii,
                                              std::vector<float>& mulScatAng,
@@ -1350,8 +1350,8 @@ template void computeTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                                const float NSigmaCut,
                                                std::vector<float>& phiCuts,
                                                const float resolutionPV,
-                                               std::vector<float>& minRs,
-                                               std::vector<float>& maxRs,
+                                               std::array<float, 7>& minRs,
+                                               std::array<float, 7>& maxRs,
                                                std::vector<float>& resolutions,
                                                std::vector<float>& radii,
                                                std::vector<float>& mulScatAng,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
index f630d2cdec76a..2a6debe8f652e 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
@@ -28,10 +28,6 @@
 
 namespace o2::its
 {
-VertexerTraitsGPU::VertexerTraitsGPU()
-{
-  setIsGPU(true);
-}
 
 void VertexerTraitsGPU::initialise(const TrackingParameters& trackingParams, const int iteration)
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 46c4a8e19fa47..19c24c743ff07 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -16,12 +16,9 @@
 #include <array>
 #include <vector>
 #include <utility>
+#include <algorithm>
 #include <numeric>
-#include <cassert>
 #include <gsl/gsl>
-#include <numeric>
-#include <iostream>
-#include <algorithm>
 
 #include "DataFormatsITS/TrackITS.h"
 
@@ -59,14 +56,19 @@ class ROFRecord;
 
 namespace its
 {
+namespace gpu
+{
+template <int>
+class TimeFrameGPU;
+}
 using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
-class TimeFrame
-{
- public:
-  friend class TimeFrameGPU;
-  TimeFrame(int nLayers = 7);
-  const Vertex& getPrimaryVertex(const int) const;
+template <int nLayers = 7>
+struct TimeFrame {
+  friend class gpu::TimeFrameGPU<nLayers>;
+  TimeFrame();
+  virtual ~TimeFrame();
+  const Vertex& getPrimaryVertex(const int ivtx) const { return mPrimaryVertices[ivtx]; }
   gsl::span<const Vertex> getPrimaryVertices(int rofId) const;
   gsl::span<const Vertex> getPrimaryVertices(int romin, int romax) const;
   gsl::span<const std::pair<MCCompLabel, float>> getPrimaryVerticesMCRecInfo(const int rofId) const;
@@ -91,11 +93,10 @@ class TimeFrame
 
   int getTotalClusters() const;
   std::vector<int>& getTotVertIteration() { return mTotVertPerIteration; }
-  bool empty() const;
-  bool isGPU() const { return mIsGPU; }
-  int getSortedIndex(int rofId, int layer, int i) const;
-  int getSortedStartIndex(const int, const int) const;
-  int getNrof() const;
+  bool empty() const { return getTotalClusters() == 0; }
+  int getSortedIndex(int rofId, int layer, int idx) const { return mROFramesClusters[layer][rofId] + idx; }
+  int getSortedStartIndex(const int rofId, const int layer) const { return mROFramesClusters[layer][rofId]; }
+  int getNrof() const { return mNrof; }
 
   void resetBeamXY(const float x, const float y, const float w = 0);
   void setBeamPosition(const float x, const float y, const float s2, const float base = 50.f, const float systematic = 0.f)
@@ -104,10 +105,10 @@ class TimeFrame
     resetBeamXY(x, y, s2 / o2::gpu::CAMath::Sqrt(base * base + systematic));
   }
 
-  float getBeamX() const;
-  float getBeamY() const;
-  std::vector<float>& getMinRs() { return mMinR; }
-  std::vector<float>& getMaxRs() { return mMaxR; }
+  float getBeamX() const { return mBeamPos[0]; }
+  float getBeamY() const { return mBeamPos[1]; }
+  auto& getMinRs() { return mMinR; }
+  auto& getMaxRs() { return mMaxR; }
   float getMinR(int layer) const { return mMinR[layer]; }
   float getMaxR(int layer) const { return mMaxR[layer]; }
   float getMSangle(int layer) const { return mMSangles[layer]; }
@@ -129,43 +130,43 @@ class TimeFrame
   gsl::span<const int> getIndexTablePerROFrange(int rofMin, int range, int layerId) const;
   gsl::span<int> getIndexTable(int rofId, int layerId);
   std::vector<int>& getIndexTableWhole(int layerId) { return mIndexTables[layerId]; }
-  const std::vector<TrackingFrameInfo>& getTrackingFrameInfoOnLayer(int layerId) const;
+  const std::vector<TrackingFrameInfo>& getTrackingFrameInfoOnLayer(int layerId) const { return mTrackingFrameInfo[layerId]; }
 
   const TrackingFrameInfo& getClusterTrackingFrameInfo(int layerId, const Cluster& cl) const;
-  const gsl::span<const MCCompLabel> getClusterLabels(int layerId, const Cluster& cl) const;
-  const gsl::span<const MCCompLabel> getClusterLabels(int layerId, const int clId) const;
-  int getClusterExternalIndex(int layerId, const int clId) const;
-  int getClusterSize(int clusterId) const;
-  void setClusterSize(const std::vector<uint8_t>& v) { mClusterSize = v; };
+  const gsl::span<const MCCompLabel> getClusterLabels(int layerId, const Cluster& cl) const { return getClusterLabels(layerId, cl.clusterId); }
+  const gsl::span<const MCCompLabel> getClusterLabels(int layerId, const int clId) const { return mClusterLabels->getLabels(mClusterExternalIndices[layerId][clId]); }
+  int getClusterExternalIndex(int layerId, const int clId) const { return mClusterExternalIndices[layerId][clId]; }
+  int getClusterSize(int clusterId) const { return mClusterSize[clusterId]; }
+  void setClusterSize(const std::vector<uint8_t>& v) { mClusterSize = v; }
 
   std::vector<MCCompLabel>& getTrackletsLabel(int layer) { return mTrackletLabels[layer]; }
   std::vector<MCCompLabel>& getCellsLabel(int layer) { return mCellLabels[layer]; }
 
-  bool hasMCinformation() const;
+  bool hasMCinformation() const { return mClusterLabels; }
   void initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers = 7, bool resetVertices = true);
   void resetRofPV()
   {
     deepVectorClear(mPrimaryVertices);
     mROFramesPV.resize(1, 0);
     mTotVertPerIteration.resize(1);
-  };
+  }
 
-  bool isClusterUsed(int layer, int clusterId) const;
-  void markUsedCluster(int layer, int clusterId);
+  bool isClusterUsed(int layer, int clusterId) const { return mUsedClusters[layer][clusterId]; }
+  void markUsedCluster(int layer, int clusterId) { mUsedClusters[layer][clusterId] = true; }
   gsl::span<unsigned char> getUsedClusters(const int layer);
 
-  std::vector<std::vector<Tracklet>>& getTracklets();
-  std::vector<std::vector<int>>& getTrackletsLookupTable();
+  auto& getTracklets() { return mTracklets; }
+  auto& getTrackletsLookupTable() { return mTrackletsLookupTable; }
 
-  std::vector<std::vector<Cluster>>& getClusters();
-  std::vector<std::vector<Cluster>>& getUnsortedClusters();
+  auto& getClusters() { return mClusters; }
+  auto& getUnsortedClusters() { return mUnsortedClusters; }
   int getClusterROF(int iLayer, int iCluster);
-  std::vector<std::vector<CellSeed>>& getCells();
+  auto& getCells() { return mCells; }
 
-  std::vector<std::vector<int>>& getCellsLookupTable();
-  std::vector<std::vector<int>>& getCellsNeighbours();
-  std::vector<std::vector<int>>& getCellsNeighboursLUT();
-  std::vector<Road<5>>& getRoads();
+  auto& getCellsLookupTable() { return mCellsLookupTable; }
+  auto& getCellsNeighbours() { return mCellsNeighbours; }
+  auto& getCellsNeighboursLUT() { return mCellsNeighboursLUT; }
+  std::vector<Road<nLayers - 2>>& getRoads() { return mRoads; }
   std::vector<TrackITSExt>& getTracks(int rofId) { return mTracks[rofId]; }
   std::vector<MCCompLabel>& getTracksLabel(const int rofId) { return mTracksLabel[rofId]; }
   std::vector<MCCompLabel>& getLinesLabel(const int rofId) { return mLinesLabels[rofId]; }
@@ -182,20 +183,20 @@ class TimeFrame
 
   bool checkMemory(unsigned long max) { return getArtefactsMemory() < max; }
   unsigned long getArtefactsMemory();
-  int getROFCutClusterMult() const { return mCutClusterMult; };
-  int getROFCutVertexMult() const { return mCutVertexMult; };
+  int getROFCutClusterMult() const { return mCutClusterMult; }
+  int getROFCutVertexMult() const { return mCutVertexMult; }
   int getROFCutAllMult() const { return mCutClusterMult + mCutVertexMult; }
 
   // Vertexer
   void computeTrackletsPerROFScans();
   void computeTracletsPerClusterScans();
-  int& getNTrackletsROF(int rofId, int combId);
-  std::vector<Line>& getLines(int rofId);
+  int& getNTrackletsROF(int rofId, int combId) { return mNTrackletsPerROF[combId][rofId]; }
+  std::vector<Line>& getLines(int rofId) { return mLines[rofId]; }
   int getNLinesTotal() const
   {
     return std::accumulate(mLines.begin(), mLines.end(), 0, [](int sum, const auto& l) { return sum + l.size(); });
   }
-  std::vector<ClusterLines>& getTrackletClusters(int rofId);
+  std::vector<ClusterLines>& getTrackletClusters(int rofId) { return mTrackletClusters[rofId]; }
   gsl::span<const Tracklet> getFoundTracklets(int rofId, int combId) const;
   gsl::span<Tracklet> getFoundTracklets(int rofId, int combId);
   gsl::span<const MCCompLabel> getLabelsFoundTracklets(int rofId, int combId) const;
@@ -210,8 +211,8 @@ class TimeFrame
 
   void initialiseRoadLabels();
   void setRoadLabel(int i, const unsigned long long& lab, bool fake);
-  const unsigned long long& getRoadLabel(int i) const;
-  bool isRoadFake(int i) const;
+  const unsigned long long& getRoadLabel(int i) const { return mRoadLabels[i].first; }
+  bool isRoadFake(int i) const { return mRoadLabels[i].second; }
 
   void setMultiplicityCutMask(const std::vector<uint8_t>& cutMask) { mMultiplicityCutMask = cutMask; }
   void setROFMask(const std::vector<uint8_t>& rofMask) { mROFMask = rofMask; }
@@ -222,33 +223,16 @@ class TimeFrame
   void setBz(float bz) { mBz = bz; }
   float getBz() const { return mBz; }
 
-  void setExternalAllocator(ExternalAllocator* allocator)
-  {
-    if (mIsGPU) {
-      LOGP(debug, "Setting timeFrame allocator to external");
-      mAllocator = allocator;
-      mExtAllocator = true; // to be removed
-    } else {
-      LOGP(debug, "External allocator is currently only supported for GPU");
-    }
-  }
-
-  virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>*)
-  {
-    return;
-  };
+  virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>*) { return; }
   const o2::base::PropagatorImpl<float>* getDevicePropagator() const { return mPropagatorDevice; }
 
   template <typename... T>
   void addClusterToLayer(int layer, T&&... args);
   template <typename... T>
   void addTrackingFrameInfoToLayer(int layer, T&&... args);
-  void addClusterExternalIndexToLayer(int layer, const int idx);
+  void addClusterExternalIndexToLayer(int layer, const int idx) { mClusterExternalIndices[layer].push_back(idx); }
 
-  void resizeVectors(int nLayers);
-
-  void setExtAllocator(bool ext) { mExtAllocator = ext; }
-  bool getExtAllocator() const { return mExtAllocator; }
+  void resetVectors();
 
   /// Debug and printing
   void checkTrackletLUTs();
@@ -265,17 +249,17 @@ class TimeFrame
 
   bool mIsGPU = false;
 
-  std::vector<std::vector<Cluster>> mClusters;
-  std::vector<std::vector<TrackingFrameInfo>> mTrackingFrameInfo;
-  std::vector<std::vector<int>> mClusterExternalIndices;
-  std::vector<std::vector<int>> mROFramesClusters;
+  std::array<std::vector<Cluster>, nLayers> mClusters;
+  std::array<std::vector<TrackingFrameInfo>, nLayers> mTrackingFrameInfo;
+  std::array<std::vector<int>, nLayers> mClusterExternalIndices;
+  std::array<std::vector<int>, nLayers> mROFramesClusters;
   const dataformats::MCTruthContainer<MCCompLabel>* mClusterLabels = nullptr;
   std::array<std::vector<int>, 2> mNTrackletsPerCluster;
   std::array<std::vector<int>, 2> mNTrackletsPerClusterSum;
-  std::vector<std::vector<int>> mNClustersPerROF;
+  std::array<std::vector<int>, nLayers> mNClustersPerROF;
   std::vector<std::vector<int>> mIndexTables;
   std::vector<std::vector<int>> mTrackletsLookupTable;
-  std::vector<std::vector<unsigned char>> mUsedClusters;
+  std::array<std::vector<uint8_t>, nLayers> mUsedClusters;
   int mNrof = 0;
   int mNExtendedTracks{0};
   int mNExtendedUsedClusters{0};
@@ -285,12 +269,25 @@ class TimeFrame
   // State if memory will be externally managed.
   bool mExtAllocator = false;
   ExternalAllocator* mAllocator = nullptr;
-  std::vector<std::vector<Cluster>> mUnsortedClusters;
+  void setExternalAllocator(ExternalAllocator* allocator)
+  {
+    if (mIsGPU) {
+      LOGP(debug, "Setting timeFrame allocator to external");
+      mAllocator = allocator;
+      mExtAllocator = true; // to be removed
+    } else {
+      LOGP(fatal, "External allocator is currently only supported for GPU");
+    }
+  }
+  void setExtAllocator(bool ext) { mExtAllocator = ext; }
+  bool getExtAllocator() const { return mExtAllocator; }
+
+  std::array<std::vector<Cluster>, nLayers> mUnsortedClusters;
   std::vector<std::vector<Tracklet>> mTracklets;
   std::vector<std::vector<CellSeed>> mCells;
   std::vector<std::vector<o2::track::TrackParCovF>> mCellSeeds;
   std::vector<std::vector<float>> mCellSeedsChi2;
-  std::vector<Road<5>> mRoads;
+  std::vector<Road<nLayers - 2>> mRoads;
   std::vector<std::vector<TrackITSExt>> mTracks;
   std::vector<std::vector<int>> mCellsNeighbours;
   std::vector<std::vector<int>> mCellsLookupTable;
@@ -318,8 +315,8 @@ class TimeFrame
   int mBeamPosWeight = 0;
   std::array<float, 2> mBeamPos = {0.f, 0.f};
   bool isBeamPositionOverridden = false;
-  std::vector<float> mMinR;
-  std::vector<float> mMaxR;
+  std::array<float, nLayers> mMinR;
+  std::array<float, nLayers> mMaxR;
   std::vector<float> mMSangles;
   std::vector<float> mPhiCuts;
   std::vector<float> mPositionResolution;
@@ -341,7 +338,7 @@ class TimeFrame
   std::vector<std::vector<int>> mNTrackletsPerROF;
   std::vector<std::vector<Line>> mLines;
   std::vector<std::vector<ClusterLines>> mTrackletClusters;
-  std::vector<std::vector<int>> mTrackletsIndexROF;
+  std::array<std::vector<int>, 2> mTrackletsIndexROF;
   std::vector<std::vector<MCCompLabel>> mLinesLabels;
   std::vector<std::pair<MCCompLabel, float>> mVerticesMCRecInfo;
   std::array<uint32_t, 2> mTotalTracklets = {0, 0};
@@ -350,9 +347,8 @@ class TimeFrame
   // \Vertexer
 };
 
-inline const Vertex& TimeFrame::getPrimaryVertex(const int vertexIndex) const { return mPrimaryVertices[vertexIndex]; }
-
-inline gsl::span<const Vertex> TimeFrame::getPrimaryVertices(int rofId) const
+template <int nLayers>
+inline gsl::span<const Vertex> TimeFrame<nLayers>::getPrimaryVertices(int rofId) const
 {
   const int start = mROFramesPV[rofId];
   const int stop_idx = rofId >= mNrof - 1 ? mNrof : rofId + 1;
@@ -360,7 +356,8 @@ inline gsl::span<const Vertex> TimeFrame::getPrimaryVertices(int rofId) const
   return {&mPrimaryVertices[start], static_cast<gsl::span<const Vertex>::size_type>(delta)};
 }
 
-inline gsl::span<const std::pair<MCCompLabel, float>> TimeFrame::getPrimaryVerticesMCRecInfo(const int rofId) const
+template <int nLayers>
+inline gsl::span<const std::pair<MCCompLabel, float>> TimeFrame<nLayers>::getPrimaryVerticesMCRecInfo(const int rofId) const
 {
   const int start = mROFramesPV[rofId];
   const int stop_idx = rofId >= mNrof - 1 ? mNrof : rofId + 1;
@@ -368,12 +365,14 @@ inline gsl::span<const std::pair<MCCompLabel, float>> TimeFrame::getPrimaryVerti
   return {&(mVerticesMCRecInfo[start]), static_cast<gsl::span<const std::pair<MCCompLabel, float>>::size_type>(delta)};
 }
 
-inline gsl::span<const Vertex> TimeFrame::getPrimaryVertices(int romin, int romax) const
+template <int nLayers>
+inline gsl::span<const Vertex> TimeFrame<nLayers>::getPrimaryVertices(int romin, int romax) const
 {
   return {&mPrimaryVertices[mROFramesPV[romin]], static_cast<gsl::span<const Vertex>::size_type>(mROFramesPV[romax + 1] - mROFramesPV[romin])};
 }
 
-inline gsl::span<const std::array<float, 2>> TimeFrame::getPrimaryVerticesXAlpha(int rofId) const
+template <int nLayers>
+inline gsl::span<const std::array<float, 2>> TimeFrame<nLayers>::getPrimaryVerticesXAlpha(int rofId) const
 {
   const int start = mROFramesPV[rofId];
   const int stop_idx = rofId >= mNrof - 1 ? mNrof : rofId + 1;
@@ -381,364 +380,290 @@ inline gsl::span<const std::array<float, 2>> TimeFrame::getPrimaryVerticesXAlpha
   return {&(mPValphaX[start]), static_cast<gsl::span<const std::array<float, 2>>::size_type>(delta)};
 }
 
-inline int TimeFrame::getPrimaryVerticesNum(int rofId) const
+template <int nLayers>
+inline int TimeFrame<nLayers>::getPrimaryVerticesNum(int rofId) const
 {
   return rofId < 0 ? mPrimaryVertices.size() : mROFramesPV[rofId + 1] - mROFramesPV[rofId];
 }
 
-inline bool TimeFrame::empty() const { return getTotalClusters() == 0; }
-
-inline int TimeFrame::getSortedIndex(int rofId, int layer, int index) const { return mROFramesClusters[layer][rofId] + index; }
-
-inline int TimeFrame::getSortedStartIndex(const int rofId, const int layer) const { return mROFramesClusters[layer][rofId]; }
-
-inline int TimeFrame::getNrof() const { return mNrof; }
-
-inline void TimeFrame::resetBeamXY(const float x, const float y, const float w)
+template <int nLayers>
+inline void TimeFrame<nLayers>::resetBeamXY(const float x, const float y, const float w)
 {
   mBeamPos[0] = x;
   mBeamPos[1] = y;
   mBeamPosWeight = w;
 }
 
-inline float TimeFrame::getBeamX() const { return mBeamPos[0]; }
-
-inline float TimeFrame::getBeamY() const { return mBeamPos[1]; }
-
-inline gsl::span<const int> TimeFrame::getROFrameClusters(int layerId) const
+template <int nLayers>
+inline gsl::span<const int> TimeFrame<nLayers>::getROFrameClusters(int layerId) const
 {
   return {&mROFramesClusters[layerId][0], static_cast<gsl::span<const int>::size_type>(mROFramesClusters[layerId].size())};
 }
 
-inline gsl::span<Cluster> TimeFrame::getClustersOnLayer(int rofId, int layerId)
+template <int nLayers>
+inline gsl::span<Cluster> TimeFrame<nLayers>::getClustersOnLayer(int rofId, int layerId)
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<Cluster>();
+    return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
   return {&mClusters[layerId][startIdx], static_cast<gsl::span<Cluster>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-inline gsl::span<const Cluster> TimeFrame::getClustersOnLayer(int rofId, int layerId) const
+template <int nLayers>
+inline gsl::span<const Cluster> TimeFrame<nLayers>::getClustersOnLayer(int rofId, int layerId) const
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<const Cluster>();
+    return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
   return {&mClusters[layerId][startIdx], static_cast<gsl::span<Cluster>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-inline gsl::span<unsigned char> TimeFrame::getUsedClustersROF(int rofId, int layerId)
+template <int nLayers>
+inline gsl::span<uint8_t> TimeFrame<nLayers>::getUsedClustersROF(int rofId, int layerId)
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<unsigned char>();
+    return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
-  return {&mUsedClusters[layerId][startIdx], static_cast<gsl::span<unsigned char>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
+  return {&mUsedClusters[layerId][startIdx], static_cast<gsl::span<uint8_t>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-inline gsl::span<const unsigned char> TimeFrame::getUsedClustersROF(int rofId, int layerId) const
+template <int nLayers>
+inline gsl::span<const uint8_t> TimeFrame<nLayers>::getUsedClustersROF(int rofId, int layerId) const
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<const unsigned char>();
+    return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
-  return {&mUsedClusters[layerId][startIdx], static_cast<gsl::span<unsigned char>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
+  return {&mUsedClusters[layerId][startIdx], static_cast<gsl::span<uint8_t>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-inline gsl::span<const Cluster> TimeFrame::getClustersPerROFrange(int rofMin, int range, int layerId) const
+template <int nLayers>
+inline gsl::span<const Cluster> TimeFrame<nLayers>::getClustersPerROFrange(int rofMin, int range, int layerId) const
 {
   if (rofMin < 0 || rofMin >= mNrof) {
-    return gsl::span<const Cluster>();
+    return {};
   }
   int startIdx{mROFramesClusters[layerId][rofMin]}; // First cluster of rofMin
   int endIdx{mROFramesClusters[layerId][o2::gpu::CAMath::Min(rofMin + range, mNrof)]};
   return {&mClusters[layerId][startIdx], static_cast<gsl::span<Cluster>::size_type>(endIdx - startIdx)};
 }
 
-inline gsl::span<const int> TimeFrame::getROFramesClustersPerROFrange(int rofMin, int range, int layerId) const
+template <int nLayers>
+inline gsl::span<const int> TimeFrame<nLayers>::getROFramesClustersPerROFrange(int rofMin, int range, int layerId) const
 {
   int chkdRange{o2::gpu::CAMath::Min(range, mNrof - rofMin)};
   return {&mROFramesClusters[layerId][rofMin], static_cast<gsl::span<int>::size_type>(chkdRange)};
 }
 
-inline gsl::span<const int> TimeFrame::getNClustersROFrange(int rofMin, int range, int layerId) const
+template <int nLayers>
+inline gsl::span<const int> TimeFrame<nLayers>::getNClustersROFrange(int rofMin, int range, int layerId) const
 {
   int chkdRange{o2::gpu::CAMath::Min(range, mNrof - rofMin)};
   return {&mNClustersPerROF[layerId][rofMin], static_cast<gsl::span<int>::size_type>(chkdRange)};
 }
 
-inline int TimeFrame::getTotalClustersPerROFrange(int rofMin, int range, int layerId) const
+template <int nLayers>
+inline int TimeFrame<nLayers>::getTotalClustersPerROFrange(int rofMin, int range, int layerId) const
 {
   int startIdx{rofMin}; // First cluster of rofMin
   int endIdx{o2::gpu::CAMath::Min(rofMin + range, mNrof)};
   return mROFramesClusters[layerId][endIdx] - mROFramesClusters[layerId][startIdx];
 }
 
-inline gsl::span<const int> TimeFrame::getIndexTablePerROFrange(int rofMin, int range, int layerId) const
+template <int nLayers>
+inline gsl::span<const int> TimeFrame<nLayers>::getIndexTablePerROFrange(int rofMin, int range, int layerId) const
 {
   const int iTableSize{mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1};
   int chkdRange{o2::gpu::CAMath::Min(range, mNrof - rofMin)};
   return {&mIndexTables[layerId][rofMin * iTableSize], static_cast<gsl::span<int>::size_type>(chkdRange * iTableSize)};
 }
 
-inline int TimeFrame::getClusterROF(int iLayer, int iCluster)
+template <int nLayers>
+inline int TimeFrame<nLayers>::getClusterROF(int iLayer, int iCluster)
 {
   return std::lower_bound(mROFramesClusters[iLayer].begin(), mROFramesClusters[iLayer].end(), iCluster + 1) - mROFramesClusters[iLayer].begin() - 1;
 }
 
-inline gsl::span<const Cluster> TimeFrame::getUnsortedClustersOnLayer(int rofId, int layerId) const
+template <int nLayers>
+inline gsl::span<const Cluster> TimeFrame<nLayers>::getUnsortedClustersOnLayer(int rofId, int layerId) const
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<const Cluster>();
+    return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
   return {&mUnsortedClusters[layerId][startIdx], static_cast<gsl::span<Cluster>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-inline const std::vector<TrackingFrameInfo>& TimeFrame::getTrackingFrameInfoOnLayer(int layerId) const
-{
-  return mTrackingFrameInfo[layerId];
-}
-
-inline const TrackingFrameInfo& TimeFrame::getClusterTrackingFrameInfo(int layerId, const Cluster& cl) const
-{
-  return mTrackingFrameInfo[layerId][cl.clusterId];
-}
-
-inline const gsl::span<const MCCompLabel> TimeFrame::getClusterLabels(int layerId, const Cluster& cl) const
-{
-  return getClusterLabels(layerId, cl.clusterId);
-}
-
-inline const gsl::span<const MCCompLabel> TimeFrame::getClusterLabels(int layerId, int clId) const
-{
-  return mClusterLabels->getLabels(mClusterExternalIndices[layerId][clId]);
-}
-
-inline int TimeFrame::getClusterSize(int clusterId) const
-{
-  return mClusterSize[clusterId];
-}
-
-inline int TimeFrame::getClusterExternalIndex(int layerId, const int clId) const
-{
-  return mClusterExternalIndices[layerId][clId];
-}
-
-inline gsl::span<int> TimeFrame::getIndexTable(int rofId, int layer)
+template <int nLayers>
+inline gsl::span<int> TimeFrame<nLayers>::getIndexTable(int rofId, int layer)
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<int>();
+    return {};
   }
   return {&mIndexTables[layer][rofId * (mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1)],
           static_cast<gsl::span<int>::size_type>(mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1)};
 }
 
-inline std::vector<Line>& TimeFrame::getLines(int rofId)
-{
-  return mLines[rofId];
-}
-
-inline std::vector<ClusterLines>& TimeFrame::getTrackletClusters(int rofId)
-{
-  return mTrackletClusters[rofId];
-}
-
+template <int nLayers>
 template <typename... T>
-void TimeFrame::addClusterToLayer(int layer, T&&... values)
+void TimeFrame<nLayers>::addClusterToLayer(int layer, T&&... values)
 {
   mUnsortedClusters[layer].emplace_back(std::forward<T>(values)...);
 }
 
+template <int nLayers>
 template <typename... T>
-void TimeFrame::addTrackingFrameInfoToLayer(int layer, T&&... values)
+void TimeFrame<nLayers>::addTrackingFrameInfoToLayer(int layer, T&&... values)
 {
   mTrackingFrameInfo[layer].emplace_back(std::forward<T>(values)...);
 }
 
-inline void TimeFrame::addClusterExternalIndexToLayer(int layer, const int idx)
+template <int nLayers>
+inline gsl::span<uint8_t> TimeFrame<nLayers>::getUsedClusters(const int layer)
 {
-  mClusterExternalIndices[layer].push_back(idx);
+  return {&mUsedClusters[layer][0], static_cast<gsl::span<uint8_t>::size_type>(mUsedClusters[layer].size())};
 }
 
-inline bool TimeFrame::hasMCinformation() const
-{
-  return mClusterLabels;
-}
-
-inline bool TimeFrame::isClusterUsed(int layer, int clusterId) const
-{
-  return mUsedClusters[layer][clusterId];
-}
-
-inline gsl::span<unsigned char> TimeFrame::getUsedClusters(const int layer)
-{
-  return {&mUsedClusters[layer][0], static_cast<gsl::span<unsigned char>::size_type>(mUsedClusters[layer].size())};
-}
-
-inline void TimeFrame::markUsedCluster(int layer, int clusterId) { mUsedClusters[layer][clusterId] = true; }
-
-inline std::vector<std::vector<Tracklet>>& TimeFrame::getTracklets()
-{
-  return mTracklets;
-}
-
-inline std::vector<std::vector<int>>& TimeFrame::getTrackletsLookupTable()
-{
-  return mTrackletsLookupTable;
-}
-
-inline void TimeFrame::initialiseRoadLabels()
+template <int nLayers>
+inline void TimeFrame<nLayers>::initialiseRoadLabels()
 {
   mRoadLabels.clear();
   mRoadLabels.resize(mRoads.size());
 }
 
-inline void TimeFrame::setRoadLabel(int i, const unsigned long long& lab, bool fake)
+template <int nLayers>
+inline void TimeFrame<nLayers>::setRoadLabel(int i, const unsigned long long& lab, bool fake)
 {
   mRoadLabels[i].first = lab;
   mRoadLabels[i].second = fake;
 }
 
-inline const unsigned long long& TimeFrame::getRoadLabel(int i) const
-{
-  return mRoadLabels[i].first;
-}
-
-inline gsl::span<int> TimeFrame::getNTrackletsCluster(int rofId, int combId)
+template <int nLayers>
+inline gsl::span<int> TimeFrame<nLayers>::getNTrackletsCluster(int rofId, int combId)
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<int>();
+    return {};
   }
   auto startIdx{mROFramesClusters[1][rofId]};
   return {&mNTrackletsPerCluster[combId][startIdx], static_cast<gsl::span<int>::size_type>(mROFramesClusters[1][rofId + 1] - startIdx)};
 }
 
-inline gsl::span<int> TimeFrame::getExclusiveNTrackletsCluster(int rofId, int combId)
+template <int nLayers>
+inline gsl::span<int> TimeFrame<nLayers>::getExclusiveNTrackletsCluster(int rofId, int combId)
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<int>();
+    return {};
   }
   auto clusStartIdx{mROFramesClusters[1][rofId]};
 
   return {&mNTrackletsPerClusterSum[combId][clusStartIdx], static_cast<gsl::span<int>::size_type>(mROFramesClusters[1][rofId + 1] - clusStartIdx)};
 }
 
-inline int& TimeFrame::getNTrackletsROF(int rofId, int combId)
-{
-  return mNTrackletsPerROF[combId][rofId];
-}
-
-inline bool TimeFrame::isRoadFake(int i) const
-{
-  return mRoadLabels[i].second;
-}
-
-inline std::vector<std::vector<Cluster>>& TimeFrame::getClusters()
-{
-  return mClusters;
-}
-
-inline std::vector<std::vector<Cluster>>& TimeFrame::getUnsortedClusters()
-{
-  return mUnsortedClusters;
-}
-
-inline std::vector<std::vector<CellSeed>>& TimeFrame::getCells() { return mCells; }
-
-inline std::vector<std::vector<int>>& TimeFrame::getCellsLookupTable()
-{
-  return mCellsLookupTable;
-}
-
-inline std::vector<std::vector<int>>& TimeFrame::getCellsNeighbours() { return mCellsNeighbours; }
-inline std::vector<std::vector<int>>& TimeFrame::getCellsNeighboursLUT() { return mCellsNeighboursLUT; }
-
-inline std::vector<Road<5>>& TimeFrame::getRoads() { return mRoads; }
-
-inline gsl::span<Tracklet> TimeFrame::getFoundTracklets(int rofId, int combId)
+template <int nLayers>
+inline gsl::span<Tracklet> TimeFrame<nLayers>::getFoundTracklets(int rofId, int combId)
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<Tracklet>();
+    return {};
   }
   auto startIdx{mNTrackletsPerROF[combId][rofId]};
   return {&mTracklets[combId][startIdx], static_cast<gsl::span<Tracklet>::size_type>(mNTrackletsPerROF[combId][rofId + 1] - startIdx)};
 }
 
-inline gsl::span<const Tracklet> TimeFrame::getFoundTracklets(int rofId, int combId) const
+template <int nLayers>
+inline gsl::span<const Tracklet> TimeFrame<nLayers>::getFoundTracklets(int rofId, int combId) const
 {
   if (rofId < 0 || rofId >= mNrof) {
-    return gsl::span<const Tracklet>();
+    return {};
   }
   auto startIdx{mNTrackletsPerROF[combId][rofId]};
   return {&mTracklets[combId][startIdx], static_cast<gsl::span<Tracklet>::size_type>(mNTrackletsPerROF[combId][rofId + 1] - startIdx)};
 }
 
-inline gsl::span<const MCCompLabel> TimeFrame::getLabelsFoundTracklets(int rofId, int combId) const
+template <int nLayers>
+inline gsl::span<const MCCompLabel> TimeFrame<nLayers>::getLabelsFoundTracklets(int rofId, int combId) const
 {
   if (rofId < 0 || rofId >= mNrof || !hasMCinformation()) {
-    return gsl::span<const MCCompLabel>();
+    return {};
   }
   auto startIdx{mNTrackletsPerROF[combId][rofId]};
   return {&mTrackletLabels[combId][startIdx], static_cast<gsl::span<Tracklet>::size_type>(mNTrackletsPerROF[combId][rofId + 1] - startIdx)};
 }
 
-inline int TimeFrame::getNumberOfClusters() const
+template <int nLayers>
+inline int TimeFrame<nLayers>::getTotalClusters() const
+{
+  size_t totalClusters{0};
+  for (const auto& clusters : mUnsortedClusters) {
+    totalClusters += clusters.size();
+  }
+  return int(totalClusters);
+}
+
+template <int nLayers>
+inline int TimeFrame<nLayers>::getNumberOfClusters() const
 {
   int nClusters = 0;
-  for (auto& layer : mClusters) {
+  for (const auto& layer : mClusters) {
     nClusters += layer.size();
   }
   return nClusters;
 }
 
-inline int TimeFrame::getNumberOfCells() const
+template <int nLayers>
+inline int TimeFrame<nLayers>::getNumberOfCells() const
 {
   int nCells = 0;
-  for (auto& layer : mCells) {
+  for (const auto& layer : mCells) {
     nCells += layer.size();
   }
   return nCells;
 }
 
-inline int TimeFrame::getNumberOfTracklets() const
+template <int nLayers>
+inline int TimeFrame<nLayers>::getNumberOfTracklets() const
 {
   int nTracklets = 0;
-  for (auto& layer : mTracklets) {
+  for (const auto& layer : mTracklets) {
     nTracklets += layer.size();
   }
   return nTracklets;
 }
 
-inline int TimeFrame::getNumberOfNeighbours() const
+template <int nLayers>
+inline int TimeFrame<nLayers>::getNumberOfNeighbours() const
 {
   int n{0};
-  for (auto& l : mCellsNeighbours) {
+  for (const auto& l : mCellsNeighbours) {
     n += l.size();
   }
   return n;
 }
 
-inline size_t TimeFrame::getNumberOfTracks() const
+template <int nLayers>
+inline size_t TimeFrame<nLayers>::getNumberOfTracks() const
 {
   int nTracks = 0;
-  for (auto& t : mTracks) {
+  for (const auto& t : mTracks) {
     nTracks += t.size();
   }
   return nTracks;
 }
 
-inline size_t TimeFrame::getNumberOfUsedClusters() const
+template <int nLayers>
+inline size_t TimeFrame<nLayers>::getNumberOfUsedClusters() const
 {
   size_t nClusters = 0;
-  for (auto& layer : mUsedClusters) {
+  for (const auto& layer : mUsedClusters) {
     nClusters += std::count(layer.begin(), layer.end(), true);
   }
   return nClusters;
 }
 
-inline void TimeFrame::insertPastVertex(const Vertex& vertex, const int iteration)
+template <int nLayers>
+inline void TimeFrame<nLayers>::insertPastVertex(const Vertex& vertex, const int iteration)
 {
   int rofId = vertex.getTimeStamp().getTimeStamp();
   mPrimaryVertices.insert(mPrimaryVertices.begin() + mROFramesPV[rofId], vertex);
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 8f0a471b40c59..2e535e2b6a644 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -32,6 +32,7 @@
 #include "ITStracking/ROframe.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/TimeFrame.h"
+#include "ITStracking/TrackerTraits.h"
 #include "ITStracking/Road.h"
 
 #include "DataFormatsITS/TrackITS.h"
@@ -46,48 +47,52 @@ class GPUChainITS;
 }
 namespace its
 {
-class TrackerTraits;
 
 class Tracker
 {
+  static constexpr int NLayers{7};
+  using TrackerTraits7 = TrackerTraits<NLayers>;
+  using TimeFrame7 = TimeFrame<NLayers>;
   using LogFunc = std::function<void(const std::string& s)>;
 
  public:
-  Tracker(TrackerTraits* traits);
+  Tracker(TrackerTraits<NLayers>* traits);
 
-  void adoptTimeFrame(TimeFrame& tf);
+  void adoptTimeFrame(TimeFrame<NLayers>& tf);
 
-  void clustersToTracks(LogFunc = [](std::string s) { std::cout << s << std::endl; }, LogFunc = [](std::string s) { std::cerr << s << std::endl; });
+  void clustersToTracks(
+    LogFunc = [](const std::string& s) { std::cout << s << '\n'; },
+    LogFunc = [](const std::string& s) { std::cerr << s << '\n'; });
 
-  void setParameters(const std::vector<TrackingParameters>&);
+  void setParameters(const std::vector<TrackingParameters>& p) { mTrkParams = p; }
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
   void getGlobalConfiguration();
-  void setBz(float);
-  void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type);
-  bool isMatLUT() const;
-  void setNThreads(int n);
-  int getNThreads() const;
+  void setBz(float bz) { mTraits->setBz(bz); }
+  void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mTraits->setCorrType(type); }
+  bool isMatLUT() const { return mTraits->isMatLUT(); }
+  void setNThreads(int n) { mTraits->setNThreads(n); }
+  int getNThreads() const { return mTraits->getNThreads(); }
   void printSummary() const;
 
  private:
-  void initialiseTimeFrame(int& iteration);
-  void computeTracklets(int& iteration, int& iROFslice, int& iVertex);
-  void computeCells(int& iteration);
-  void findCellsNeighbours(int& iteration);
-  void findRoads(int& iteration);
-  void findShortPrimaries();
-  void extendTracks(int& iteration);
+  void initialiseTimeFrame(int iteration) { mTraits->initialiseTimeFrame(iteration); }
+  void computeTracklets(int iteration, int iROFslice, int iVertex) { mTraits->computeLayerTracklets(iteration, iROFslice, iVertex); }
+  void computeCells(int iteration) { mTraits->computeLayerCells(iteration); }
+  void findCellsNeighbours(int iteration) { mTraits->findCellsNeighbours(iteration); }
+  void findRoads(int iteration) { mTraits->findRoads(iteration); }
+  void findShortPrimaries() { mTraits->findShortPrimaries(); }
+  void extendTracks(int iteration) { mTraits->extendTracks(iteration); }
 
   // MC interaction
   void computeRoadsMClabels();
   void computeTracksMClabels();
   void rectifyClusterIndices();
 
-  template <typename... T>
-  float evaluateTask(void (Tracker::*)(T...), const char*, LogFunc logger, T&&... args);
+  template <typename... T, typename... F>
+  float evaluateTask(void (Tracker::*task)(T...), const char* taskName, LogFunc logger, F&&... args);
 
-  TrackerTraits* mTraits = nullptr; /// Observer pointer, not owned by this class
-  TimeFrame* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
+  TrackerTraits7* mTraits = nullptr; /// Observer pointer, not owned by this class
+  TimeFrame7* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
 
   std::vector<TrackingParameters> mTrkParams;
   o2::gpu::GPUChainITS* mRecoChain = nullptr;
@@ -97,13 +102,8 @@ class Tracker
   double mTotalTime{0};
 };
 
-inline void Tracker::setParameters(const std::vector<TrackingParameters>& trkPars)
-{
-  mTrkParams = trkPars;
-}
-
-template <typename... T>
-float Tracker::evaluateTask(void (Tracker::*task)(T...), const char* taskName, LogFunc logger, T&&... args)
+template <typename... T, typename... F>
+float Tracker::evaluateTask(void (Tracker::*task)(T...), const char* taskName, LogFunc logger, F&&... args)
 {
   float diff{0.f};
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 6b514c6e8d000..7340f247e4cf2 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -35,12 +35,13 @@ namespace its
 {
 class TrackITSExt;
 
+template <int nLayers = 7>
 class TrackerTraits
 {
  public:
   virtual ~TrackerTraits() = default;
-  virtual void adoptTimeFrame(TimeFrame* tf);
-  virtual void initialiseTimeFrame(const int iteration);
+  virtual void adoptTimeFrame(TimeFrame<nLayers>* tf) { mTimeFrame = tf; }
+  virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers); }
 
   virtual void computeLayerTracklets(const int iteration, int iROFslice, int iVertex);
   virtual void computeLayerCells(const int iteration);
@@ -55,11 +56,11 @@ class TrackerTraits
   virtual bool trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration);
   virtual void processNeighbours(int iLayer, int iLevel, const std::vector<CellSeed>& currentCellSeed, const std::vector<int>& currentCellId, std::vector<CellSeed>& updatedCellSeed, std::vector<int>& updatedCellId);
 
-  void UpdateTrackingParameters(const std::vector<TrackingParameters>& trkPars);
-  TimeFrame* getTimeFrame() { return mTimeFrame; }
+  void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars) { mTrkParams = trkPars; }
+  TimeFrame<nLayers>* getTimeFrame() { return mTimeFrame; }
 
   virtual void setBz(float bz);
-  float getBz() const;
+  float getBz() const { return mBz; }
   void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mCorrType = type; }
   bool isMatLUT() const;
   virtual const char* getName() const noexcept { return "CPU"; }
@@ -67,8 +68,8 @@ class TrackerTraits
 
   // Others
   GPUhd() static consteval int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
-  const int4 getBinsRect(const Cluster&, int layer, float z1, float z2, float maxdeltaz, float maxdeltaphi) const noexcept;
-  const int4 getBinsRect(int layer, float phi, float maxdeltaphi, float z, float maxdeltaz) const noexcept;
+  const int4 getBinsRect(int layer, float phi, float maxdeltaphi, float z, float maxdeltaz) const noexcept { return getBinsRect(layer, phi, maxdeltaphi, z, z, maxdeltaz); }
+  const int4 getBinsRect(const Cluster& cls, int layer, float z1, float z2, float maxdeltaz, float maxdeltaphi) const noexcept { return getBinsRect(layer, cls.phi, maxdeltaphi, z1, z2, maxdeltaz); }
   const int4 getBinsRect(int layer, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept;
   void SetRecoChain(o2::gpu::GPUChainITS* chain) { mChain = chain; }
   void setSmoothing(bool v) { mApplySmoothing = v; }
@@ -79,9 +80,9 @@ class TrackerTraits
   o2::gpu::GPUChainITS* getChain() const { return mChain; }
 
   // TimeFrame information forwarding
-  virtual int getTFNumberOfClusters() const;
-  virtual int getTFNumberOfTracklets() const;
-  virtual int getTFNumberOfCells() const;
+  virtual int getTFNumberOfClusters() const { return mTimeFrame->getNumberOfClusters(); }
+  virtual int getTFNumberOfTracklets() const { return mTimeFrame->getNumberOfTracklets(); }
+  virtual int getTFNumberOfCells() const { return mTimeFrame->getNumberOfCells(); }
 
   float mBz = 5.f;
 
@@ -95,36 +96,12 @@ class TrackerTraits
  protected:
   o2::base::PropagatorImpl<float>::MatCorrType mCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
   o2::gpu::GPUChainITS* mChain = nullptr;
-  TimeFrame* mTimeFrame;
+  TimeFrame<nLayers>* mTimeFrame;
   std::vector<TrackingParameters> mTrkParams;
 };
 
-inline void TrackerTraits::initialiseTimeFrame(const int iteration)
-{
-  mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers);
-}
-
-inline float TrackerTraits::getBz() const
-{
-  return mBz;
-}
-
-inline void TrackerTraits::UpdateTrackingParameters(const std::vector<TrackingParameters>& trkPars)
-{
-  mTrkParams = trkPars;
-}
-
-inline const int4 TrackerTraits::getBinsRect(const int layerIndex, float phi, float maxdeltaphi, float z, float maxdeltaz) const noexcept
-{
-  return getBinsRect(layerIndex, phi, maxdeltaphi, z, z, maxdeltaz);
-}
-
-inline const int4 TrackerTraits::getBinsRect(const Cluster& currentCluster, int layerIndex, float z1, float z2, float maxdeltaz, float maxdeltaphi) const noexcept
-{
-  return getBinsRect(layerIndex, currentCluster.phi, maxdeltaphi, z1, z2, maxdeltaz);
-}
-
-inline const int4 TrackerTraits::getBinsRect(const int layerIndex, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept
+template <int nLayers>
+inline const int4 TrackerTraits<nLayers>::getBinsRect(const int layerIndex, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept
 {
   const float zRangeMin = o2::gpu::GPUCommonMath::Min(z1, z2) - maxdeltaz;
   const float phiRangeMin = (maxdeltaphi > constants::math::Pi) ? 0.f : phi - maxdeltaphi;
@@ -142,6 +119,7 @@ inline const int4 TrackerTraits::getBinsRect(const int layerIndex, float phi, fl
               o2::gpu::GPUCommonMath::Min(mTrkParams[0].ZBins - 1, utils.getZBinIndex(layerIndex, zRangeMax)), // /!\ trkParams can potentially change across iterations
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
 }
+
 } // namespace its
 } // namespace o2
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index 6eacb94ebb1ea..89b5527f5b2c9 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -31,6 +31,10 @@ namespace o2::its
 {
 class ITSTrackingInterface
 {
+  static constexpr int NLayers{7};
+  using TrackerTraits7 = TrackerTraits<NLayers>;
+  using TimeFrame7 = TimeFrame<NLayers>;
+
  public:
   ITSTrackingInterface(bool isMC,
                        int trgType,
@@ -52,7 +56,6 @@ class ITSTrackingInterface
   }
   // Task callbacks
   void initialise();
-  template <bool isGPU = false>
   void run(framework::ProcessingContext& pc);
   void printSummary() const;
 
@@ -60,7 +63,7 @@ class ITSTrackingInterface
   virtual void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj);
 
   // Custom
-  void setTraitsFromProvider(VertexerTraits*, TrackerTraits*, TimeFrame*);
+  void setTraitsFromProvider(VertexerTraits*, TrackerTraits7*, TimeFrame7*);
   void setTrackingMode(TrackingMode mode = TrackingMode::Unset)
   {
     if (mode == TrackingMode::Unset) {
@@ -72,7 +75,7 @@ class ITSTrackingInterface
   auto getTracker() const { return mTracker.get(); }
   auto getVertexer() const { return mVertexer.get(); }
 
-  TimeFrame* mTimeFrame = nullptr;
+  TimeFrame7* mTimeFrame = nullptr;
 
  protected:
   virtual void loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index ac0cf51921176..56cd286b509ad 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -35,74 +35,62 @@
 
 #include "GPUCommonLogger.h"
 
-class TTree;
-
-namespace o2
-{
-namespace its
+namespace o2::its
 {
-using TimeFrame = o2::its::TimeFrame;
+
 using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 class Vertexer
 {
+  static constexpr int NLayers{7};
+  using TimeFrame7 = TimeFrame<NLayers>;
+  using LogFunc = std::function<void(const std::string& s)>;
+
  public:
   Vertexer(VertexerTraits* traits);
   virtual ~Vertexer() = default;
   Vertexer(const Vertexer&) = delete;
   Vertexer& operator=(const Vertexer&) = delete;
 
-  void adoptTimeFrame(TimeFrame& tf);
-  std::vector<VertexingParameters>& getVertParameters() const;
-  void setParameters(std::vector<VertexingParameters>& vertParams);
+  void adoptTimeFrame(TimeFrame7& tf);
+  auto& getVertParameters() const { return mTraits->getVertexingParameters(); }
+  void setParameters(const std::vector<VertexingParameters>& vertParams) { mVertParams = vertParams; }
   void getGlobalConfiguration();
 
   std::vector<Vertex> exportVertices();
   VertexerTraits* getTraits() const { return mTraits; };
 
-  float clustersToVertices(std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; });
-  float clustersToVerticesHybrid(std::function<void(std::string s)> = [](std::string s) { std::cout << s << std::endl; });
+  float clustersToVertices(LogFunc = [](const std::string& s) { std::cout << s << '\n'; });
   void filterMCTracklets();
 
   template <typename... T>
   void findTracklets(T&&... args);
-  template <typename... T>
-  void findTrackletsHybrid(T&&... args);
-
   void findTrivialMCTracklets();
   template <typename... T>
   void validateTracklets(T&&... args);
   template <typename... T>
-  void validateTrackletsHybrid(T&&... args);
-  template <typename... T>
   void findVertices(T&&... args);
-  template <typename... T>
-  void findVerticesHybrid(T&&... args);
   void findHistVertices();
 
   template <typename... T>
   void initialiseVertexer(T&&... args);
   template <typename... T>
   void initialiseTimeFrame(T&&... args);
-  template <typename... T>
-  void initialiseVertexerHybrid(T&&... args);
-  template <typename... T>
-  void initialiseTimeFrameHybrid(T&&... args);
 
   // Utils
-  void dumpTraits();
+  void dumpTraits() { mTraits->dumpVertexerTraits(); }
   template <typename... T>
-  float evaluateTask(void (Vertexer::*)(T...), const char*, std::function<void(std::string s)> logger, T&&... args);
-  void printEpilog(std::function<void(std::string s)> logger,
-                   bool isHybrid,
-                   const unsigned int trackletN01, const unsigned int trackletN12, const unsigned selectedN, const unsigned int vertexN,
-                   const float initT, const float trackletT, const float selecT, const float vertexT);
+  float evaluateTask(void (Vertexer::*)(T...), const char*, LogFunc logger, T&&... args);
+  void printEpilog(LogFunc& logger,
+                   const unsigned int trackletN01, const unsigned int trackletN12,
+                   const unsigned selectedN, const unsigned int vertexN, const float initT,
+                   const float trackletT, const float selecT, const float vertexT);
 
  private:
   std::uint32_t mTimeFrameCounter = 0;
 
   VertexerTraits* mTraits = nullptr; /// Observer pointer, not owned by this class
-  TimeFrame* mTimeFrame = nullptr;   /// Observer pointer, not owned by this class
+  TimeFrame7* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
 
   std::vector<VertexingParameters> mVertParams;
 };
@@ -119,21 +107,6 @@ void Vertexer::findTracklets(T&&... args)
   mTraits->computeTracklets(std::forward<T>(args)...);
 }
 
-inline std::vector<VertexingParameters>& Vertexer::getVertParameters() const
-{
-  return mTraits->getVertexingParameters();
-}
-
-inline void Vertexer::setParameters(std::vector<VertexingParameters>& vertParams)
-{
-  mVertParams = vertParams;
-}
-
-inline void Vertexer::dumpTraits()
-{
-  mTraits->dumpVertexerTraits();
-}
-
 template <typename... T>
 inline void Vertexer::validateTracklets(T&&... args)
 {
@@ -147,31 +120,7 @@ inline void Vertexer::findVertices(T&&... args)
 }
 
 template <typename... T>
-void Vertexer::initialiseVertexerHybrid(T&&... args)
-{
-  mTraits->initialiseHybrid(std::forward<T>(args)...);
-}
-
-template <typename... T>
-void Vertexer::findTrackletsHybrid(T&&... args)
-{
-  mTraits->computeTrackletsHybrid(std::forward<T>(args)...);
-}
-
-template <typename... T>
-inline void Vertexer::validateTrackletsHybrid(T&&... args)
-{
-  mTraits->computeTrackletMatchingHybrid(std::forward<T>(args)...);
-}
-
-template <typename... T>
-inline void Vertexer::findVerticesHybrid(T&&... args)
-{
-  mTraits->computeVerticesHybrid(std::forward<T>(args)...);
-}
-
-template <typename... T>
-float Vertexer::evaluateTask(void (Vertexer::*task)(T...), const char* taskName, std::function<void(std::string s)> logger,
+float Vertexer::evaluateTask(void (Vertexer::*task)(T...), const char* taskName, LogFunc logger,
                              T&&... args)
 {
   float diff{0.f};
@@ -198,6 +147,5 @@ float Vertexer::evaluateTask(void (Vertexer::*task)(T...), const char* taskName,
   return diff;
 }
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index e27d74093aaca..bc7daf5e3ab24 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -47,33 +47,29 @@ enum class TrackletMode {
 
 class VertexerTraits
 {
+  static constexpr int NLayers{7};
+  using TimeFrame7 = TimeFrame<NLayers>;
+
  public:
   VertexerTraits() = default;
   virtual ~VertexerTraits() = default;
 
-  GPUhd() static constexpr int4 getEmptyBinsRect()
+  GPUhdi() static consteval int4 getEmptyBinsRect()
   {
     return int4{0, 0, 0, 0};
   }
   GPUhd() const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi);
-  GPUhd() const int2 getPhiBins(float phi, float deltaPhi);
-
   GPUhd() static const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi, const IndexTableUtils&);
   GPUhd() static const int2 getPhiBins(float phi, float deltaPhi, const IndexTableUtils&);
+  GPUhd() const int2 getPhiBins(float phi, float deltaPhi) { return getPhiBins(phi, deltaPhi, mIndexTableUtils); }
 
   // virtual vertexer interface
   virtual void initialise(const TrackingParameters& trackingParams, const int iteration = 0);
   virtual void computeTracklets(const int iteration = 0);
   virtual void computeTrackletMatching(const int iteration = 0);
   virtual void computeVertices(const int iteration = 0);
-  virtual void adoptTimeFrame(TimeFrame* tf);
+  virtual void adoptTimeFrame(TimeFrame7* tf) { mTimeFrame = tf; }
   virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& gpuTfPar);
-  // Hybrid
-  virtual void initialiseHybrid(const TrackingParameters& trackingParams, const int iteration = 0) { initialise(trackingParams, iteration); };
-  virtual void computeTrackletsHybrid(const int iteration = 0) { computeTracklets(iteration); };
-  virtual void computeTrackletMatchingHybrid(const int iteration = 0) { computeTrackletMatching(iteration); };
-  virtual void computeVerticesHybrid(const int iteration = 0) { computeVertices(iteration); };
-  virtual void adoptTimeFrameHybrid(TimeFrame* tf) { adoptTimeFrame(tf); };
 
   void computeVerticesInRof(int,
                             gsl::span<const o2::its::Line>&,
@@ -82,7 +78,7 @@ class VertexerTraits
                             std::array<float, 2>&,
                             std::vector<Vertex>&,
                             std::vector<int>&,
-                            TimeFrame*,
+                            TimeFrame7*,
                             std::vector<o2::MCCompLabel>*,
                             const int iteration = 0);
 
@@ -91,14 +87,14 @@ class VertexerTraits
                                                                const IndexTableUtils& utils);
 
   // utils
-  std::vector<VertexingParameters>& getVertexingParameters() { return mVrtParams; }
-  std::vector<VertexingParameters> getVertexingParameters() const { return mVrtParams; }
-  void setIsGPU(const unsigned char isgpu) { mIsGPU = isgpu; };
+  auto& getVertexingParameters() { return mVrtParams; }
+  auto getVertexingParameters() const { return mVrtParams; }
   void setVertexingParameters(std::vector<VertexingParameters>& vertParams) { mVrtParams = vertParams; }
-  unsigned char getIsGPU() const { return mIsGPU; };
   void dumpVertexerTraits();
   void setNThreads(int n);
   int getNThreads() const { return mNThreads; }
+  virtual bool isGPU() const noexcept { return false; }
+  virtual const char* getName() const noexcept { return "CPU"; }
 
   template <typename T = o2::MCCompLabel>
   static std::pair<T, float> computeMain(const std::vector<T>& elements)
@@ -116,25 +112,18 @@ class VertexerTraits
   }
 
  protected:
-  unsigned char mIsGPU;
   int mNThreads = 1;
 
   std::vector<VertexingParameters> mVrtParams;
   IndexTableUtils mIndexTableUtils;
 
   // Frame related quantities
-  TimeFrame* mTimeFrame = nullptr;
+  TimeFrame7* mTimeFrame = nullptr; // observer ptr
 };
 
 inline void VertexerTraits::initialise(const TrackingParameters& trackingParams, const int iteration)
 {
   mTimeFrame->initialise(0, trackingParams, 3, (bool)(!iteration)); // iteration for initialisation must be 0 for correctly resetting the frame, we need to pass the non-reset flag for vertices as well, tho.
-  setIsGPU(false);
-}
-
-GPUhdi() const int2 VertexerTraits::getPhiBins(float phi, float dPhi)
-{
-  return VertexerTraits::getPhiBins(phi, dPhi, mIndexTableUtils);
 }
 
 GPUhdi() const int2 VertexerTraits::getPhiBins(float phi, float dPhi, const IndexTableUtils& utils)
@@ -169,8 +158,6 @@ GPUhdi() const int4 VertexerTraits::getBinsRect(const Cluster& currentCluster, c
   return VertexerTraits::getBinsRect(currentCluster, layerIndex, directionZIntersection, maxdeltaz, maxdeltaphi, mIndexTableUtils);
 }
 
-inline void VertexerTraits::adoptTimeFrame(TimeFrame* tf) { mTimeFrame = tf; }
-
 } // namespace its
 } // namespace o2
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 506656e2777d1..80a6ef481fde6 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -50,9 +50,7 @@ float Sq(float v)
 
 } // namespace
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 constexpr float DefClusErrorRow = o2::itsmft::SegmentationAlpide::PitchRow * 0.5;
@@ -60,21 +58,20 @@ constexpr float DefClusErrorCol = o2::itsmft::SegmentationAlpide::PitchCol * 0.5
 constexpr float DefClusError2Row = DefClusErrorRow * DefClusErrorRow;
 constexpr float DefClusError2Col = DefClusErrorCol * DefClusErrorCol;
 
-TimeFrame::TimeFrame(int nLayers)
+template <int nLayers>
+TimeFrame<nLayers>::TimeFrame()
+{
+  resetVectors();
+}
+
+template <int nLayers>
+TimeFrame<nLayers>::~TimeFrame()
 {
-  mMinR.resize(nLayers, 10000.);
-  mMaxR.resize(nLayers, -1.);
-  mClusters.resize(nLayers);
-  mUnsortedClusters.resize(nLayers);
-  mTrackingFrameInfo.resize(nLayers);
-  mClusterExternalIndices.resize(nLayers);
-  mUsedClusters.resize(nLayers);
-  mROFramesClusters.resize(nLayers, {0}); /// TBC: if resetting the timeframe is required, then this has to be done
-  mNClustersPerROF.resize(nLayers);
-  mTrackletsIndexROF.resize(2, {0});
+  resetVectors();
 }
 
-void TimeFrame::addPrimaryVertices(const std::vector<Vertex>& vertices)
+template <int nLayers>
+void TimeFrame<nLayers>::addPrimaryVertices(const std::vector<Vertex>& vertices)
 {
   for (const auto& vertex : vertices) {
     mPrimaryVertices.emplace_back(vertex);
@@ -88,17 +85,20 @@ void TimeFrame::addPrimaryVertices(const std::vector<Vertex>& vertices)
   mROFramesPV.push_back(mPrimaryVertices.size());
 }
 
-void TimeFrame::addPrimaryVertices(const std::vector<Vertex>& vertices, const int rofId, const int iteration)
+template <int nLayers>
+void TimeFrame<nLayers>::addPrimaryVertices(const std::vector<Vertex>& vertices, const int rofId, const int iteration)
 {
   addPrimaryVertices(gsl::span<const Vertex>(vertices), rofId, iteration);
 }
 
-void TimeFrame::addPrimaryVerticesLabels(std::vector<std::pair<MCCompLabel, float>>& labels)
+template <int nLayers>
+void TimeFrame<nLayers>::addPrimaryVerticesLabels(std::vector<std::pair<MCCompLabel, float>>& labels)
 {
   mVerticesMCRecInfo.insert(mVerticesMCRecInfo.end(), labels.begin(), labels.end());
 }
 
-void TimeFrame::addPrimaryVerticesInROF(const std::vector<Vertex>& vertices, const int rofId, const int iteration)
+template <int nLayers>
+void TimeFrame<nLayers>::addPrimaryVerticesInROF(const std::vector<Vertex>& vertices, const int rofId, const int iteration)
 {
   mPrimaryVertices.insert(mPrimaryVertices.begin() + mROFramesPV[rofId], vertices.begin(), vertices.end());
   for (int i = rofId + 1; i < mROFramesPV.size(); ++i) {
@@ -107,12 +107,14 @@ void TimeFrame::addPrimaryVerticesInROF(const std::vector<Vertex>& vertices, con
   mTotVertPerIteration[iteration] += vertices.size();
 }
 
-void TimeFrame::addPrimaryVerticesLabelsInROF(const std::vector<std::pair<MCCompLabel, float>>& labels, const int rofId)
+template <int nLayers>
+void TimeFrame<nLayers>::addPrimaryVerticesLabelsInROF(const std::vector<std::pair<MCCompLabel, float>>& labels, const int rofId)
 {
   mVerticesMCRecInfo.insert(mVerticesMCRecInfo.begin() + mROFramesPV[rofId], labels.begin(), labels.end());
 }
 
-void TimeFrame::addPrimaryVertices(const gsl::span<const Vertex>& vertices, const int rofId, const int iteration)
+template <int nLayers>
+void TimeFrame<nLayers>::addPrimaryVertices(const gsl::span<const Vertex>& vertices, const int rofId, const int iteration)
 {
   std::vector<Vertex> futureVertices;
   for (const auto& vertex : vertices) {
@@ -133,57 +135,18 @@ void TimeFrame::addPrimaryVertices(const gsl::span<const Vertex>& vertices, cons
     }
   }
   mROFramesPV.push_back(mPrimaryVertices.size()); // current rof must have number of vertices up to present
-  if (futureVertices.size()) {                    // append future vertices. In the last rofId we cannot have ones from the next, so we are never here.
-    for (auto& vertex : futureVertices) {
-      mPrimaryVertices.emplace_back(vertex);
-      mTotVertPerIteration[iteration]++;
-    }
-  }
-}
-
-int TimeFrame::loadROFrameData(const o2::itsmft::ROFRecord& rof, gsl::span<const itsmft::Cluster> clusters,
-                               const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
-{
-  GeometryTGeo* geom = GeometryTGeo::Instance();
-  geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
-  int clusterId{0};
-
-  auto first = rof.getFirstEntry();
-  auto clusters_in_frame = rof.getROFData(clusters);
-  for (auto& c : clusters_in_frame) {
-    int layer = geom->getLayer(c.getSensorID());
-
-    /// Clusters are stored in the tracking frame
-    auto xyz = c.getXYZGloRot(*geom);
-    addTrackingFrameInfoToLayer(layer, xyz.x(), xyz.y(), xyz.z(), c.getX(), geom->getSensorRefAlpha(c.getSensorID()),
-                                std::array<float, 2>{c.getY(), c.getZ()},
-                                std::array<float, 3>{c.getSigmaY2(), c.getSigmaYZ(), c.getSigmaZ2()});
-
-    /// Rotate to the global frame
-    addClusterToLayer(layer, xyz.x(), xyz.y(), xyz.z(), mUnsortedClusters[layer].size());
-    addClusterExternalIndexToLayer(layer, first + clusterId);
-    clusterId++;
-  }
-
-  for (unsigned int iL{0}; iL < mUnsortedClusters.size(); ++iL) {
-    mNClustersPerROF[iL].push_back(mUnsortedClusters[iL].size() - mROFramesClusters[iL].back());
-    mROFramesClusters[iL].push_back(mUnsortedClusters[iL].size());
-    if (iL < 2) {
-      mTrackletsIndexROF[iL].push_back(mUnsortedClusters[1].size()); // Tracklets used in vertexer are always computed starting from L1
-    }
-  }
-  if (mcLabels) {
-    mClusterLabels = mcLabels;
+  for (auto& vertex : futureVertices) {
+    mPrimaryVertices.emplace_back(vertex);
+    mTotVertPerIteration[iteration]++;
   }
-  mNrof++;
-  return clusters_in_frame.size();
 }
 
-int TimeFrame::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
-                               gsl::span<const itsmft::CompClusterExt> clusters,
-                               gsl::span<const unsigned char>::iterator& pattIt,
-                               const itsmft::TopologyDictionary* dict,
-                               const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
+template <int nLayers>
+int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
+                                        gsl::span<const itsmft::CompClusterExt> clusters,
+                                        gsl::span<const unsigned char>::iterator& pattIt,
+                                        const itsmft::TopologyDictionary* dict,
+                                        const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
   for (int iLayer{0}; iLayer < mUnsortedClusters.size(); ++iLayer) {
     deepVectorClear(mUnsortedClusters[iLayer]);
@@ -260,22 +223,14 @@ int TimeFrame::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
     mNTrackletsPerClusterSum[i].resize(mUnsortedClusters[1].size() + 1); // Exc sum "prepends" a 0
   }
 
-  if (mcLabels) {
+  if (mcLabels != nullptr) {
     mClusterLabels = mcLabels;
   }
   return mNrof;
 }
 
-int TimeFrame::getTotalClusters() const
-{
-  size_t totalClusters{0};
-  for (auto& clusters : mUnsortedClusters) {
-    totalClusters += clusters.size();
-  }
-  return int(totalClusters);
-}
-
-void TimeFrame::prepareClusters(const TrackingParameters& trkParam, const int maxLayers)
+template <int nLayers>
+void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, const int maxLayers)
 {
   std::vector<ClusterHelper> cHelper;
   std::vector<int> clsPerBin(trkParam.PhiBins * trkParam.ZBins, 0);
@@ -342,7 +297,8 @@ void TimeFrame::prepareClusters(const TrackingParameters& trkParam, const int ma
   }
 }
 
-void TimeFrame::initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers, bool resetVertices)
+template <int nLayers>
+void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers, bool resetVertices)
 {
   if (iteration == 0) {
     if (maxLayers < trkParam.NLayers && resetVertices) {
@@ -451,7 +407,8 @@ void TimeFrame::initialise(const int iteration, const TrackingParameters& trkPar
   }
 }
 
-unsigned long TimeFrame::getArtefactsMemory()
+template <int nLayers>
+unsigned long TimeFrame<nLayers>::getArtefactsMemory()
 {
   unsigned long size{0};
   for (auto& trkl : mTracklets) {
@@ -463,10 +420,11 @@ unsigned long TimeFrame::getArtefactsMemory()
   for (auto& cellsN : mCellsNeighbours) {
     size += sizeof(int) * cellsN.size();
   }
-  return size + sizeof(Road<5>) * mRoads.size();
+  return size + sizeof(Road<nLayers - 2>) * mRoads.size();
 }
 
-void TimeFrame::fillPrimaryVerticesXandAlpha()
+template <int nLayers>
+void TimeFrame<nLayers>::fillPrimaryVerticesXandAlpha()
 {
   if (mPValphaX.size()) {
     mPValphaX.clear();
@@ -477,7 +435,8 @@ void TimeFrame::fillPrimaryVerticesXandAlpha()
   }
 }
 
-void TimeFrame::computeTrackletsPerROFScans()
+template <int nLayers>
+void TimeFrame<nLayers>::computeTrackletsPerROFScans()
 {
   for (ushort iLayer = 0; iLayer < 2; ++iLayer) {
     for (unsigned int iRof{0}; iRof < mNrof; ++iRof) {
@@ -490,7 +449,8 @@ void TimeFrame::computeTrackletsPerROFScans()
   }
 }
 
-void TimeFrame::checkTrackletLUTs()
+template <int nLayers>
+void TimeFrame<nLayers>::checkTrackletLUTs()
 {
   for (uint32_t iLayer{0}; iLayer < getTracklets().size(); ++iLayer) {
     int prev{-1};
@@ -522,21 +482,27 @@ void TimeFrame::checkTrackletLUTs()
   }
 }
 
-void TimeFrame::resizeVectors(int nLayers)
+template <int nLayers>
+void TimeFrame<nLayers>::resetVectors()
 {
-  mMinR.resize(nLayers, 10000.);
-  mMaxR.resize(nLayers, -1.);
-  mClusters.resize(nLayers);
-  mUnsortedClusters.resize(nLayers);
-  mTrackingFrameInfo.resize(nLayers);
-  mClusterExternalIndices.resize(nLayers);
-  mUsedClusters.resize(nLayers);
-  mROFramesClusters.resize(nLayers, {0});
-  mNClustersPerROF.resize(nLayers);
-  mTrackletsIndexROF.resize(2, {0});
+  mMinR.fill(10000.);
+  mMaxR.fill(-1.);
+  for (int iLayers{nLayers}; iLayers--;) {
+    mClusters[iLayers].clear();
+    mUnsortedClusters[iLayers].clear();
+    mTrackingFrameInfo[iLayers].clear();
+    mClusterExternalIndices[iLayers].clear();
+    mUsedClusters[iLayers].clear();
+    mROFramesClusters[iLayers].clear();
+    mNClustersPerROF[iLayers].clear();
+  }
+  for (int i{2}; i--;) {
+    mTrackletsIndexROF[i].clear();
+  }
 }
 
-void TimeFrame::printTrackletLUTonLayer(int i)
+template <int nLayers>
+void TimeFrame<nLayers>::printTrackletLUTonLayer(int i)
 {
   std::cout << "--------" << std::endl
             << "Tracklet LUT " << i << std::endl;
@@ -547,7 +513,8 @@ void TimeFrame::printTrackletLUTonLayer(int i)
             << std::endl;
 }
 
-void TimeFrame::printCellLUTonLayer(int i)
+template <int nLayers>
+void TimeFrame<nLayers>::printCellLUTonLayer(int i)
 {
   std::cout << "--------" << std::endl
             << "Cell LUT " << i << std::endl;
@@ -558,21 +525,24 @@ void TimeFrame::printCellLUTonLayer(int i)
             << std::endl;
 }
 
-void TimeFrame::printTrackletLUTs()
+template <int nLayers>
+void TimeFrame<nLayers>::printTrackletLUTs()
 {
   for (unsigned int i{0}; i < mTrackletsLookupTable.size(); ++i) {
     printTrackletLUTonLayer(i);
   }
 }
 
-void TimeFrame::printCellLUTs()
+template <int nLayers>
+void TimeFrame<nLayers>::printCellLUTs()
 {
   for (unsigned int i{0}; i < mCellsLookupTable.size(); ++i) {
     printCellLUTonLayer(i);
   }
 }
 
-void TimeFrame::printVertices()
+template <int nLayers>
+void TimeFrame<nLayers>::printVertices()
 {
   std::cout << "Vertices in ROF (nROF = " << mNrof << ", lut size = " << mROFramesPV.size() << ")" << std::endl;
   for (unsigned int iR{0}; iR < mROFramesPV.size(); ++iR) {
@@ -585,7 +555,8 @@ void TimeFrame::printVertices()
   std::cout << "--------" << std::endl;
 }
 
-void TimeFrame::printROFoffsets()
+template <int nLayers>
+void TimeFrame<nLayers>::printROFoffsets()
 {
   std::cout << "--------" << std::endl;
   for (unsigned int iLayer{0}; iLayer < mROFramesClusters.size(); ++iLayer) {
@@ -597,7 +568,8 @@ void TimeFrame::printROFoffsets()
   }
 }
 
-void TimeFrame::printNClsPerROF()
+template <int nLayers>
+void TimeFrame<nLayers>::printNClsPerROF()
 {
   std::cout << "--------" << std::endl;
   for (unsigned int iLayer{0}; iLayer < mNClustersPerROF.size(); ++iLayer) {
@@ -609,7 +581,8 @@ void TimeFrame::printNClsPerROF()
   }
 }
 
-void TimeFrame::printSliceInfo(const int startROF, const int sliceSize)
+template <int nLayers>
+void TimeFrame<nLayers>::printSliceInfo(const int startROF, const int sliceSize)
 {
   std::cout << "Dumping slice of " << sliceSize << " rofs:" << std::endl;
   for (int iROF{startROF}; iROF < startROF + sliceSize; ++iROF) {
@@ -625,5 +598,6 @@ void TimeFrame::printSliceInfo(const int startROF, const int sliceSize)
   }
 }
 
-} // namespace its
-} // namespace o2
+template class TimeFrame<7>;
+
+} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index c23ba0576c625..c452e20f7f707 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -30,13 +30,11 @@
 #include <string>
 #include <climits>
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 using o2::its::constants::GB;
 
-Tracker::Tracker(o2::its::TrackerTraits* traits) : mTraits(traits)
+Tracker::Tracker(TrackerTraits7* traits) : mTraits(traits)
 {
   /// Initialise standard configuration with 1 iteration
   mTrkParams.resize(1);
@@ -47,7 +45,7 @@ void Tracker::clustersToTracks(LogFunc logger, LogFunc error)
   LogFunc evalLog = [](const std::string&) {};
 
   double total{0};
-  mTraits->UpdateTrackingParameters(mTrkParams);
+  mTraits->updateTrackingParameters(mTrkParams);
   int maxNvertices{-1};
   if (mTrkParams[0].PerPrimaryVertexProcessing) {
     for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
@@ -149,41 +147,6 @@ void Tracker::clustersToTracks(LogFunc logger, LogFunc error)
   mTotalTime += total;
 }
 
-void Tracker::initialiseTimeFrame(int& iteration)
-{
-  mTraits->initialiseTimeFrame(iteration);
-}
-
-void Tracker::computeTracklets(int& iteration, int& iROFslice, int& iVertex)
-{
-  mTraits->computeLayerTracklets(iteration, iROFslice, iVertex);
-}
-
-void Tracker::computeCells(int& iteration)
-{
-  mTraits->computeLayerCells(iteration);
-}
-
-void Tracker::findCellsNeighbours(int& iteration)
-{
-  mTraits->findCellsNeighbours(iteration);
-}
-
-void Tracker::findRoads(int& iteration)
-{
-  mTraits->findRoads(iteration);
-}
-
-void Tracker::extendTracks(int& iteration)
-{
-  mTraits->extendTracks(iteration);
-}
-
-void Tracker::findShortPrimaries()
-{
-  mTraits->findShortPrimaries();
-}
-
 void Tracker::computeRoadsMClabels()
 {
   /// Moore's Voting Algorithm
@@ -427,41 +390,15 @@ void Tracker::getGlobalConfiguration()
   }
 }
 
-void Tracker::adoptTimeFrame(TimeFrame& tf)
+void Tracker::adoptTimeFrame(TimeFrame7& tf)
 {
   mTimeFrame = &tf;
   mTraits->adoptTimeFrame(&tf);
 }
 
-void Tracker::setBz(float bz)
-{
-  mTraits->setBz(bz);
-}
-
-void Tracker::setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type)
-{
-  mTraits->setCorrType(type);
-}
-
-bool Tracker::isMatLUT() const
-{
-  return mTraits->isMatLUT();
-}
-
-void Tracker::setNThreads(int n)
-{
-  mTraits->setNThreads(n);
-}
-
-int Tracker::getNThreads() const
-{
-  return mTraits->getNThreads();
-}
-
 void Tracker::printSummary() const
 {
   LOGP(info, "Tracker summary: Processed {} TFs (dropped {}) in TOT={:.2f} s, AVG/TF={:.2f} s", mTimeFrameCounter, mNumberOfDroppedTFs, mTotalTime * 1.e-3, mTotalTime * 1.e-3 / ((mTimeFrameCounter > 0) ? (double)mTimeFrameCounter : -1.0));
 }
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 987e8e3128fb4..da0eeb52156be 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -46,43 +46,41 @@ inline float Sq(float q)
 }
 } // namespace
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 constexpr int debugLevel{0};
 
-void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
+template <int nLayers>
+void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
 {
-  TimeFrame* tf = mTimeFrame;
-
 #ifdef OPTIMISATION_OUTPUT
   static int iter{0};
   std::ofstream off(std::format("tracklets{}.txt", iter++));
 #endif
 
   for (int iLayer = 0; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
-    tf->getTracklets()[iLayer].clear();
-    tf->getTrackletsLabel(iLayer).clear();
+    mTimeFrame->getTracklets()[iLayer].clear();
+    mTimeFrame->getTrackletsLabel(iLayer).clear();
     if (iLayer > 0) {
-      std::fill(tf->getTrackletsLookupTable()[iLayer - 1].begin(), tf->getTrackletsLookupTable()[iLayer - 1].end(), 0);
+      std::fill(mTimeFrame->getTrackletsLookupTable()[iLayer - 1].begin(),
+                mTimeFrame->getTrackletsLookupTable()[iLayer - 1].end(), 0);
     }
   }
 
   const Vertex diamondVert({mTrkParams[iteration].Diamond[0], mTrkParams[iteration].Diamond[1], mTrkParams[iteration].Diamond[2]}, {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f}, 1, 1.f);
   gsl::span<const Vertex> diamondSpan(&diamondVert, 1);
   int startROF{mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * mTrkParams[iteration].nROFsPerIterations : 0};
-  int endROF{gpu::GPUCommonMath::Min(mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * mTrkParams[iteration].nROFsPerIterations + mTrkParams[iteration].DeltaROF : tf->getNrof(), tf->getNrof())};
+  int endROF{o2::gpu::GPUCommonMath::Min(mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * mTrkParams[iteration].nROFsPerIterations + mTrkParams[iteration].DeltaROF : mTimeFrame->getNrof(), mTimeFrame->getNrof())};
   for (int rof0{startROF}; rof0 < endROF; ++rof0) {
-    gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : tf->getPrimaryVertices(rof0);
+    gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(rof0);
     const int startVtx{iVertex >= 0 ? iVertex : 0};
     const int endVtx{iVertex >= 0 ? o2::gpu::CAMath::Min(iVertex + 1, static_cast<int>(primaryVertices.size())) : static_cast<int>(primaryVertices.size())};
     int minRof = o2::gpu::CAMath::Max(startROF, rof0 - mTrkParams[iteration].DeltaROF);
     int maxRof = o2::gpu::CAMath::Min(endROF - 1, rof0 + mTrkParams[iteration].DeltaROF);
 #pragma omp parallel for num_threads(mNThreads)
     for (int iLayer = 0; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
-      gsl::span<const Cluster> layer0 = tf->getClustersOnLayer(rof0, iLayer);
+      gsl::span<const Cluster> layer0 = mTimeFrame->getClustersOnLayer(rof0, iLayer);
       if (layer0.empty()) {
         continue;
       }
@@ -91,9 +89,9 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
       const int currentLayerClustersNum{static_cast<int>(layer0.size())};
       for (int iCluster{0}; iCluster < currentLayerClustersNum; ++iCluster) {
         const Cluster& currentCluster{layer0[iCluster]};
-        const int currentSortedIndex{tf->getSortedIndex(rof0, iLayer, iCluster)};
+        const int currentSortedIndex{mTimeFrame->getSortedIndex(rof0, iLayer, iCluster)};
 
-        if (tf->isClusterUsed(iLayer, currentCluster.clusterId)) {
+        if (mTimeFrame->isClusterUsed(iLayer, currentCluster.clusterId)) {
           continue;
         }
         const float inverseR0{1.f / currentCluster.radius};
@@ -103,18 +101,17 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
           if (primaryVertex.isFlagSet(2) && iteration != 3) {
             continue;
           }
-          const float resolution = o2::gpu::CAMath::Sqrt(Sq(mTrkParams[iteration].PVres) / primaryVertex.getNContributors() + Sq(tf->getPositionResolution(iLayer)));
+          const float resolution = o2::gpu::CAMath::Sqrt(Sq(mTrkParams[iteration].PVres) / primaryVertex.getNContributors() + Sq(mTimeFrame->getPositionResolution(iLayer)));
 
           const float tanLambda{(currentCluster.zCoordinate - primaryVertex.getZ()) * inverseR0};
 
-          const float zAtRmin{tanLambda * (tf->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
-          const float zAtRmax{tanLambda * (tf->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
+          const float zAtRmin{tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
+          const float zAtRmax{tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
 
           const float sqInverseDeltaZ0{1.f / (Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
-          const float sigmaZ{o2::gpu::CAMath::Sqrt(Sq(resolution) * Sq(tanLambda) * ((Sq(inverseR0) + sqInverseDeltaZ0) * Sq(meanDeltaR) + 1.f) + Sq(meanDeltaR * tf->getMSangle(iLayer)))};
+          const float sigmaZ{o2::gpu::CAMath::Sqrt(Sq(resolution) * Sq(tanLambda) * ((Sq(inverseR0) + sqInverseDeltaZ0) * Sq(meanDeltaR) + 1.f) + Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)))};
 
-          const int4 selectedBinsRect{getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax,
-                                                  sigmaZ * mTrkParams[iteration].NSigmaCut, tf->getPhiCut(iLayer))};
+          const int4 selectedBinsRect{getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer))};
           if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
             continue;
           }
@@ -126,46 +123,46 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
           }
 
           for (int rof1{minRof}; rof1 <= maxRof; ++rof1) {
-            gsl::span<const Cluster> layer1 = tf->getClustersOnLayer(rof1, iLayer + 1);
+            auto layer1 = mTimeFrame->getClustersOnLayer(rof1, iLayer + 1);
             if (layer1.empty()) {
               continue;
             }
             for (int iPhiCount{0}; iPhiCount < phiBinsNum; iPhiCount++) {
               int iPhiBin = (selectedBinsRect.y + iPhiCount) % mTrkParams[iteration].PhiBins;
-              const int firstBinIndex{tf->mIndexTableUtils.getBinIndex(selectedBinsRect.x, iPhiBin)};
+              const int firstBinIndex{mTimeFrame->mIndexTableUtils.getBinIndex(selectedBinsRect.x, iPhiBin)};
               const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
               if constexpr (debugLevel) {
-                if (firstBinIndex < 0 || firstBinIndex > tf->getIndexTable(rof1, iLayer + 1).size() ||
-                    maxBinIndex < 0 || maxBinIndex > tf->getIndexTable(rof1, iLayer + 1).size()) {
-                  std::cout << iLayer << "\t" << iCluster << "\t" << zAtRmin << "\t" << zAtRmax << "\t" << sigmaZ * mTrkParams[iteration].NSigmaCut << "\t" << tf->getPhiCut(iLayer) << std::endl;
+                if (firstBinIndex < 0 || firstBinIndex > mTimeFrame->getIndexTable(rof1, iLayer + 1).size() ||
+                    maxBinIndex < 0 || maxBinIndex > mTimeFrame->getIndexTable(rof1, iLayer + 1).size()) {
+                  std::cout << iLayer << "\t" << iCluster << "\t" << zAtRmin << "\t" << zAtRmax << "\t" << sigmaZ * mTrkParams[iteration].NSigmaCut << "\t" << mTimeFrame->getPhiCut(iLayer) << std::endl;
                   std::cout << currentCluster.zCoordinate << "\t" << primaryVertex.getZ() << "\t" << currentCluster.radius << std::endl;
-                  std::cout << tf->getMinR(iLayer + 1) << "\t" << currentCluster.radius << "\t" << currentCluster.zCoordinate << std::endl;
+                  std::cout << mTimeFrame->getMinR(iLayer + 1) << "\t" << currentCluster.radius << "\t" << currentCluster.zCoordinate << std::endl;
                   std::cout << "Illegal access to IndexTable " << firstBinIndex << "\t" << maxBinIndex << "\t" << selectedBinsRect.z << "\t" << selectedBinsRect.x << std::endl;
                   exit(1);
                 }
               }
-              const int firstRowClusterIndex = tf->getIndexTable(rof1, iLayer + 1)[firstBinIndex];
-              const int maxRowClusterIndex = tf->getIndexTable(rof1, iLayer + 1)[maxBinIndex];
+              const int firstRowClusterIndex = mTimeFrame->getIndexTable(rof1, iLayer + 1)[firstBinIndex];
+              const int maxRowClusterIndex = mTimeFrame->getIndexTable(rof1, iLayer + 1)[maxBinIndex];
               for (int iNextCluster{firstRowClusterIndex}; iNextCluster < maxRowClusterIndex; ++iNextCluster) {
                 if (iNextCluster >= (int)layer1.size()) {
                   break;
                 }
 
                 const Cluster& nextCluster{layer1[iNextCluster]};
-                if (tf->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
+                if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
                   continue;
                 }
 
-                const float deltaPhi{gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi)};
-                const float deltaZ{gpu::GPUCommonMath::Abs(tanLambda * (nextCluster.radius - currentCluster.radius) +
-                                                           currentCluster.zCoordinate - nextCluster.zCoordinate)};
+                const float deltaPhi{o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi)};
+                const float deltaZ{o2::gpu::GPUCommonMath::Abs(tanLambda * (nextCluster.radius - currentCluster.radius) +
+                                                               currentCluster.zCoordinate - nextCluster.zCoordinate)};
 
 #ifdef OPTIMISATION_OUTPUT
                 MCCompLabel label;
                 int currentId{currentCluster.clusterId};
                 int nextId{nextCluster.clusterId};
-                for (auto& lab1 : tf->getClusterLabels(iLayer, currentId)) {
-                  for (auto& lab2 : tf->getClusterLabels(iLayer + 1, nextId)) {
+                for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
+                  for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
                     if (lab1 == lab2 && lab1.isValid()) {
                       label = lab1;
                       break;
@@ -179,16 +176,16 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
 #endif
 
                 if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
-                    (deltaPhi < tf->getPhiCut(iLayer) ||
-                     gpu::GPUCommonMath::Abs(deltaPhi - constants::math::TwoPi) < tf->getPhiCut(iLayer))) {
+                    (deltaPhi < mTimeFrame->getPhiCut(iLayer) ||
+                     o2::gpu::GPUCommonMath::Abs(deltaPhi - constants::math::TwoPi) < mTimeFrame->getPhiCut(iLayer))) {
                   if (iLayer > 0) {
-                    tf->getTrackletsLookupTable()[iLayer - 1][currentSortedIndex]++;
+                    mTimeFrame->getTrackletsLookupTable()[iLayer - 1][currentSortedIndex]++;
                   }
                   const float phi{o2::gpu::GPUCommonMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate,
                                                                 currentCluster.xCoordinate - nextCluster.xCoordinate)};
                   const float tanL{(currentCluster.zCoordinate - nextCluster.zCoordinate) /
                                    (currentCluster.radius - nextCluster.radius)};
-                  tf->getTracklets()[iLayer].emplace_back(currentSortedIndex, tf->getSortedIndex(rof1, iLayer + 1, iNextCluster), tanL, phi, rof0, rof1);
+                  mTimeFrame->getTracklets()[iLayer].emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(rof1, iLayer + 1, iNextCluster), tanL, phi, rof0, rof1);
                 }
               }
             }
@@ -197,19 +194,19 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
       }
     }
   }
-  if (!tf->checkMemory(mTrkParams[iteration].MaxMemory)) {
+  if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
     return;
   }
 
 #pragma omp parallel for num_threads(mNThreads)
   for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
     /// Sort tracklets
-    auto& trkl{tf->getTracklets()[iLayer + 1]};
+    auto& trkl{mTimeFrame->getTracklets()[iLayer + 1]};
     std::sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) {
       return a.firstClusterIndex < b.firstClusterIndex || (a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex < b.secondClusterIndex);
     });
     /// Remove duplicates
-    auto& lut{tf->getTrackletsLookupTable()[iLayer]};
+    auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer]};
     int id0{-1}, id1{-1};
     std::vector<Tracklet> newTrk;
     newTrk.reserve(trkl.size());
@@ -229,30 +226,30 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
     lut.push_back(trkl.size());
   }
   /// Layer 0 is done outside the loop
-  std::sort(tf->getTracklets()[0].begin(), tf->getTracklets()[0].end(), [](const Tracklet& a, const Tracklet& b) {
+  std::sort(mTimeFrame->getTracklets()[0].begin(), mTimeFrame->getTracklets()[0].end(), [](const Tracklet& a, const Tracklet& b) {
     return a.firstClusterIndex < b.firstClusterIndex || (a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex < b.secondClusterIndex);
   });
   int id0{-1}, id1{-1};
   std::vector<Tracklet> newTrk;
-  newTrk.reserve(tf->getTracklets()[0].size());
-  for (auto& trk : tf->getTracklets()[0]) {
+  newTrk.reserve(mTimeFrame->getTracklets()[0].size());
+  for (auto& trk : mTimeFrame->getTracklets()[0]) {
     if (trk.firstClusterIndex != id0 || trk.secondClusterIndex != id1) {
       id0 = trk.firstClusterIndex;
       id1 = trk.secondClusterIndex;
       newTrk.push_back(trk);
     }
   }
-  tf->getTracklets()[0].swap(newTrk);
+  mTimeFrame->getTracklets()[0].swap(newTrk);
 
   /// Create tracklets labels
-  if (tf->hasMCinformation()) {
+  if (mTimeFrame->hasMCinformation()) {
     for (int iLayer{0}; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
-      for (auto& trk : tf->getTracklets()[iLayer]) {
+      for (auto& trk : mTimeFrame->getTracklets()[iLayer]) {
         MCCompLabel label;
-        int currentId{tf->getClusters()[iLayer][trk.firstClusterIndex].clusterId};
-        int nextId{tf->getClusters()[iLayer + 1][trk.secondClusterIndex].clusterId};
-        for (auto& lab1 : tf->getClusterLabels(iLayer, currentId)) {
-          for (auto& lab2 : tf->getClusterLabels(iLayer + 1, nextId)) {
+        int currentId{mTimeFrame->getClusters()[iLayer][trk.firstClusterIndex].clusterId};
+        int nextId{mTimeFrame->getClusters()[iLayer + 1][trk.secondClusterIndex].clusterId};
+        for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
+          for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
             if (lab1 == lab2 && lab1.isValid()) {
               label = lab1;
               break;
@@ -262,13 +259,14 @@ void TrackerTraits::computeLayerTracklets(const int iteration, int iROFslice, in
             break;
           }
         }
-        tf->getTrackletsLabel(iLayer).emplace_back(label);
+        mTimeFrame->getTrackletsLabel(iLayer).emplace_back(label);
       }
     }
   }
 }
 
-void TrackerTraits::computeLayerCells(const int iteration)
+template <int nLayers>
+void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
 {
 #ifdef OPTIMISATION_OUTPUT
   static int iter{0};
@@ -283,12 +281,11 @@ void TrackerTraits::computeLayerCells(const int iteration)
     }
   }
 
-  TimeFrame* tf = mTimeFrame;
 #pragma omp parallel for num_threads(mNThreads)
   for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
 
-    if (tf->getTracklets()[iLayer + 1].empty() ||
-        tf->getTracklets()[iLayer].empty()) {
+    if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
+        mTimeFrame->getTracklets()[iLayer].empty()) {
       continue;
     }
 
@@ -296,29 +293,29 @@ void TrackerTraits::computeLayerCells(const int iteration)
     float resolution{o2::gpu::CAMath::Sqrt(0.5f * (mTrkParams[iteration].SystErrorZ2[iLayer] + mTrkParams[iteration].SystErrorZ2[iLayer + 1] + mTrkParams[iteration].SystErrorZ2[iLayer + 2] + mTrkParams[iteration].SystErrorY2[iLayer] + mTrkParams[iteration].SystErrorY2[iLayer + 1] + mTrkParams[iteration].SystErrorY2[iLayer + 2])) / mTrkParams[iteration].LayerResolution[iLayer]};
     resolution = resolution > 1.e-12 ? resolution : 1.f;
 #endif
-    const int currentLayerTrackletsNum{static_cast<int>(tf->getTracklets()[iLayer].size())};
+    const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
     for (int iTracklet{0}; iTracklet < currentLayerTrackletsNum; ++iTracklet) {
 
-      const Tracklet& currentTracklet{tf->getTracklets()[iLayer][iTracklet]};
+      const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
       const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
       const int nextLayerFirstTrackletIndex{
-        tf->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
+        mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
       const int nextLayerLastTrackletIndex{
-        tf->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
+        mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
 
       if (nextLayerFirstTrackletIndex == nextLayerLastTrackletIndex) {
         continue;
       }
 
       for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
-        if (tf->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
+        if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
           break;
         }
-        const Tracklet& nextTracklet{tf->getTracklets()[iLayer + 1][iNextTracklet]};
+        const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
         const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
 
 #ifdef OPTIMISATION_OUTPUT
-        bool good{tf->getTrackletsLabel(iLayer)[iTracklet] == tf->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
+        bool good{mTimeFrame->getTrackletsLabel(iLayer)[iTracklet] == mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
         float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
         off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
 #endif
@@ -367,41 +364,42 @@ void TrackerTraits::computeLayerCells(const int iteration)
           if (!good) {
             continue;
           }
-          if (iLayer > 0 && (int)tf->getCellsLookupTable()[iLayer - 1].size() <= iTracklet) {
-            tf->getCellsLookupTable()[iLayer - 1].resize(iTracklet + 1, tf->getCells()[iLayer].size());
+          if (iLayer > 0 && (int)mTimeFrame->getCellsLookupTable()[iLayer - 1].size() <= iTracklet) {
+            mTimeFrame->getCellsLookupTable()[iLayer - 1].resize(iTracklet + 1, mTimeFrame->getCells()[iLayer].size());
           }
-          tf->getCells()[iLayer].emplace_back(iLayer, clusId[0], clusId[1], clusId[2],
-                                              iTracklet, iNextTracklet, track, chi2);
+          mTimeFrame->getCells()[iLayer].emplace_back(iLayer, clusId[0], clusId[1], clusId[2],
+                                                      iTracklet, iNextTracklet, track, chi2);
         }
       }
     }
     if (iLayer > 0) {
-      tf->getCellsLookupTable()[iLayer - 1].resize(currentLayerTrackletsNum + 1, tf->getCells()[iLayer].size());
+      mTimeFrame->getCellsLookupTable()[iLayer - 1].resize(currentLayerTrackletsNum + 1, mTimeFrame->getCells()[iLayer].size());
     }
   }
-  if (!tf->checkMemory(mTrkParams[iteration].MaxMemory)) {
+  if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
     return;
   }
 
   /// Create cells labels
-  if (tf->hasMCinformation()) {
+  if (mTimeFrame->hasMCinformation()) {
     for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-      for (auto& cell : tf->getCells()[iLayer]) {
-        MCCompLabel currentLab{tf->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
-        MCCompLabel nextLab{tf->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
-        tf->getCellsLabel(iLayer).emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
+      for (auto& cell : mTimeFrame->getCells()[iLayer]) {
+        MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
+        MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
+        mTimeFrame->getCellsLabel(iLayer).emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
       }
     }
   }
 
   if constexpr (debugLevel) {
     for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-      std::cout << "Cells on layer " << iLayer << " " << tf->getCells()[iLayer].size() << std::endl;
+      std::cout << "Cells on layer " << iLayer << " " << mTimeFrame->getCells()[iLayer].size() << std::endl;
     }
   }
 }
 
-void TrackerTraits::findCellsNeighbours(const int iteration)
+template <int nLayers>
+void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
 {
 #ifdef OPTIMISATION_OUTPUT
   std::ofstream off(std::format("cellneighs{}.txt", iteration));
@@ -421,7 +419,6 @@ void TrackerTraits::findCellsNeighbours(const int iteration)
     cellsNeighbours.reserve(nextLayerCellsNum);
 
     for (int iCell{0}; iCell < layerCellsNum; ++iCell) {
-
       const auto& currentCellSeed{mTimeFrame->getCells()[iLayer][iCell]};
       const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
       const int nextLayerFirstCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex]};
@@ -469,7 +466,8 @@ void TrackerTraits::findCellsNeighbours(const int iteration)
   }
 }
 
-void TrackerTraits::processNeighbours(int iLayer, int iLevel, const std::vector<CellSeed>& currentCellSeed, const std::vector<int>& currentCellId, std::vector<CellSeed>& updatedCellSeeds, std::vector<int>& updatedCellsIds)
+template <int nLayers>
+void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const std::vector<CellSeed>& currentCellSeed, const std::vector<int>& currentCellId, std::vector<CellSeed>& updatedCellSeeds, std::vector<int>& updatedCellsIds)
 {
   bool print = iLayer == 3 && iLevel == 2;
   if (iLevel < 2 || iLayer < 1) {
@@ -568,7 +566,8 @@ void TrackerTraits::processNeighbours(int iLayer, int iLevel, const std::vector<
 #endif
 }
 
-void TrackerTraits::findRoads(const int iteration)
+template <int nLayers>
+void TrackerTraits<nLayers>::findRoads(const int iteration)
 {
   CA_DEBUGGER(std::cout << "Finding roads, iteration " << iteration << std::endl);
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
@@ -676,7 +675,8 @@ void TrackerTraits::findRoads(const int iteration)
   }
 }
 
-void TrackerTraits::extendTracks(const int iteration)
+template <int nLayers>
+void TrackerTraits<nLayers>::extendTracks(const int iteration)
 {
   for (int rof{0}; rof < mTimeFrame->getNrof(); ++rof) {
     for (auto& track : mTimeFrame->getTracks(rof)) {
@@ -724,7 +724,8 @@ void TrackerTraits::extendTracks(const int iteration)
   }
 }
 
-void TrackerTraits::findShortPrimaries()
+template <int nLayers>
+void TrackerTraits<nLayers>::findShortPrimaries()
 {
   const auto propagator = o2::base::Propagator::Instance();
   mTimeFrame->fillPrimaryVerticesXandAlpha();
@@ -812,7 +813,8 @@ void TrackerTraits::findShortPrimaries()
   }
 }
 
-bool TrackerTraits::fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut, float chi2ndfcut, float maxQoverPt, int nCl)
+template <int nLayers>
+bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut, float chi2ndfcut, float maxQoverPt, int nCl)
 {
   auto propInstance = o2::base::Propagator::Instance();
 
@@ -851,7 +853,8 @@ bool TrackerTraits::fitTrack(TrackITSExt& track, int start, int end, int step, f
   return std::abs(track.getQ2Pt()) < maxQoverPt && track.getChi2() < chi2ndfcut * (nCl * 2 - 5);
 }
 
-bool TrackerTraits::trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration)
+template <int nLayers>
+bool TrackerTraits<nLayers>::trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration)
 {
   auto propInstance = o2::base::Propagator::Instance();
   const int step = -1 + outward * 2;
@@ -966,7 +969,8 @@ bool TrackerTraits::trackFollowing(TrackITSExt* track, int rof, bool outward, co
 
 /// Clusters are given from inside outward (cluster3 is the outermost). The outermost cluster is given in the tracking
 /// frame coordinates whereas the others are referred to the global frame.
-track::TrackParCov TrackerTraits::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3)
+template <int nLayers>
+track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3)
 {
   const float ca = o2::gpu::CAMath::Cos(tf3.alphaTrackingFrame), sa = o2::gpu::CAMath::Sin(tf3.alphaTrackingFrame);
   const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
@@ -997,15 +1001,21 @@ track::TrackParCov TrackerTraits::buildTrackSeed(const Cluster& cluster1, const
                              0.f, 0.f, 0.f, 0.f, sg2q2pt});
 }
 
-void TrackerTraits::setBz(float bz)
+template <int nLayers>
+void TrackerTraits<nLayers>::setBz(float bz)
 {
   mBz = bz;
   mTimeFrame->setBz(bz);
 }
 
-bool TrackerTraits::isMatLUT() const { return o2::base::Propagator::Instance()->getMatLUT() && (mCorrType == o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT); }
+template <int nLayers>
+bool TrackerTraits<nLayers>::isMatLUT() const
+{
+  return o2::base::Propagator::Instance()->getMatLUT() && (mCorrType == o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT);
+}
 
-void TrackerTraits::setNThreads(int n)
+template <int nLayers>
+void TrackerTraits<nLayers>::setNThreads(int n)
 {
 #ifdef WITH_OPENMP
   mNThreads = n > 0 ? n : 1;
@@ -1014,25 +1024,6 @@ void TrackerTraits::setNThreads(int n)
 #endif
 }
 
-int TrackerTraits::getTFNumberOfClusters() const
-{
-  return mTimeFrame->getNumberOfClusters();
-}
-
-int TrackerTraits::getTFNumberOfTracklets() const
-{
-  return mTimeFrame->getNumberOfTracklets();
-}
-
-int TrackerTraits::getTFNumberOfCells() const
-{
-  return mTimeFrame->getNumberOfCells();
-}
-
-void TrackerTraits::adoptTimeFrame(TimeFrame* tf)
-{
-  mTimeFrame = tf;
-}
+template class TrackerTraits<7>;
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index f0dad2722a301..0df1899c9ab6a 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -139,7 +139,6 @@ void ITSTrackingInterface::initialise()
   mVertexer->setParameters(vertParams);
 }
 
-template <bool isGPU>
 void ITSTrackingInterface::run(framework::ProcessingContext& pc)
 {
   auto compClusters = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compClusters");
@@ -211,9 +210,9 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   loadROF(trackROFspan, compClusters, pattIt, labels);
   pattIt = patterns.begin();
   std::vector<int> savedROF;
-  auto logger = [&](std::string s) { LOG(info) << s; };
-  auto fatalLogger = [&](std::string s) { LOG(fatal) << s; };
-  auto errorLogger = [&](std::string s) { LOG(error) << s; };
+  auto logger = [&](const std::string& s) { LOG(info) << s; };
+  auto fatalLogger = [&](const std::string& s) { LOG(fatal) << s; };
+  auto errorLogger = [&](const std::string& s) { LOG(error) << s; };
 
   FastMultEst multEst; // mult estimator
   std::vector<uint8_t> processingMask, processUPCMask;
@@ -224,11 +223,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   if (mRunVertexer) {
     vertROFvec.reserve(trackROFvec.size());
     // Run seeding vertexer
-    if constexpr (isGPU) {
-      vertexerElapsedTime = mVertexer->clustersToVerticesHybrid(logger);
-    } else {
-      vertexerElapsedTime = mVertexer->clustersToVertices(logger);
-    }
+    vertexerElapsedTime = mVertexer->clustersToVertices(logger);
   } else { // cosmics
     mTimeFrame->resetRofPV();
   }
@@ -436,8 +431,8 @@ void ITSTrackingInterface::printSummary() const
 }
 
 void ITSTrackingInterface::setTraitsFromProvider(VertexerTraits* vertexerTraits,
-                                                 TrackerTraits* trackerTraits,
-                                                 TimeFrame* frame)
+                                                 TrackerTraits7* trackerTraits,
+                                                 TimeFrame7* frame)
 {
   mVertexer = std::make_unique<Vertexer>(vertexerTraits);
   mTracker = std::make_unique<Tracker>(trackerTraits);
@@ -453,8 +448,5 @@ void ITSTrackingInterface::loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
 {
   mTimeFrame->loadROFrameData(trackROFspan, clusters, pattIt, mDict, mcLabels);
 }
-
-template void ITSTrackingInterface::run<true>(framework::ProcessingContext& pc);
-template void ITSTrackingInterface::run<false>(framework::ProcessingContext& pc);
 } // namespace its
 } // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 13ce03e9fba4f..0b8d59f61eb8d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -21,76 +21,40 @@
 #include "ITStracking/VertexerTraits.h"
 #include "ITStracking/TrackingConfigParam.h"
 
-#include <array>
-
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
-Vertexer::Vertexer(VertexerTraits* traits)
+Vertexer::Vertexer(VertexerTraits* traits) : mTraits(traits)
 {
-  if (!traits) {
+  if (!mTraits) {
     LOG(fatal) << "nullptr passed to ITS vertexer construction.";
   }
   mVertParams.resize(1);
-  mTraits = traits;
 }
 
-float Vertexer::clustersToVertices(std::function<void(std::string s)> logger)
+float Vertexer::clustersToVertices(LogFunc logger)
 {
+  LogFunc evalLog = [](const std::string&) {};
   TrackingParameters trkPars;
   TimeFrameGPUParameters tfGPUpar;
   mTraits->updateVertexingParameters(mVertParams, tfGPUpar);
   float timeTracklet{0.f}, timeSelection{0.f}, timeVertexing{0.f}, timeInit{0.f};
   for (int iteration = 0; iteration < std::min(mVertParams[0].nIterations, (int)mVertParams.size()); ++iteration) {
-    unsigned int nTracklets01, nTracklets12;
-    logger(fmt::format("ITS Seeding vertexer iteration {} summary:", iteration));
+    unsigned int nTracklets01{0}, nTracklets12{0};
+    logger(fmt::format("=== ITS {} Seeding vertexer iteration {} summary:", mTraits->getName(), iteration));
     trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
     trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
     auto timeInitIteration = evaluateTask(
-      &Vertexer::initialiseVertexer, "Vertexer initialisation", [](std::string) {}, trkPars, iteration);
+      &Vertexer::initialiseVertexer, " - Vertexer initialisation", evalLog, trkPars, iteration);
     auto timeTrackletIteration = evaluateTask(
-      &Vertexer::findTracklets, "Vertexer tracklet finding", [](std::string) {}, iteration);
+      &Vertexer::findTracklets, " - Vertexer tracklet finding", evalLog, iteration);
     nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
     nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
     auto timeSelectionIteration = evaluateTask(
-      &Vertexer::validateTracklets, "Vertexer tracklets validation", [](std::string) {}, iteration);
+      &Vertexer::validateTracklets, " - Vertexer tracklets validation", evalLog, iteration);
     auto timeVertexingIteration = evaluateTask(
-      &Vertexer::findVertices, "Vertexer vertex finding", [](std::string) {}, iteration);
-    printEpilog(logger, false, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
-    timeInit += timeInitIteration;
-    timeTracklet += timeTrackletIteration;
-    timeSelection += timeSelectionIteration;
-    timeVertexing += timeVertexingIteration;
-  }
-
-  return timeInit + timeTracklet + timeSelection + timeVertexing;
-}
-
-float Vertexer::clustersToVerticesHybrid(std::function<void(std::string s)> logger)
-{
-  TrackingParameters trkPars;
-  TimeFrameGPUParameters tfGPUpar;
-  float timeTracklet, timeSelection, timeVertexing, timeInit;
-  mTraits->updateVertexingParameters(mVertParams, tfGPUpar);
-  for (int iteration = 0; iteration < std::min(mVertParams[0].nIterations, (int)mVertParams.size()); ++iteration) {
-    unsigned int nTracklets01, nTracklets12;
-    logger(fmt::format("ITS Hybrid seeding vertexer iteration {} summary:", iteration));
-    trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
-    trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
-    auto timeInitIteration = evaluateTask(
-      &Vertexer::initialiseVertexerHybrid, "Hybrid Vertexer initialisation", [](std::string) {}, trkPars, iteration);
-    auto timeTrackletIteration = evaluateTask(
-      &Vertexer::findTrackletsHybrid, "Hybrid Vertexer tracklet finding", [](std::string) {}, iteration);
-    nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
-    nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
-    auto timeSelectionIteration = evaluateTask(
-      &Vertexer::validateTrackletsHybrid, "Hybrid Vertexer adjacent tracklets validation", [](std::string) {}, iteration);
-    auto timeVertexingIteration = evaluateTask(
-      &Vertexer::findVerticesHybrid, "Hybrid Vertexer vertex finding", [](std::string) {}, iteration);
-
-    printEpilog(logger, true, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
+      &Vertexer::findVertices, " - Vertexer vertex finding", evalLog, iteration);
+    printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
     timeInit += timeInitIteration;
     timeTracklet += timeTrackletIteration;
     timeSelection += timeSelectionIteration;
@@ -129,23 +93,22 @@ void Vertexer::getGlobalConfiguration()
   mVertParams[0].PhiBins = vc.PhiBins;
 }
 
-void Vertexer::adoptTimeFrame(TimeFrame& tf)
+void Vertexer::adoptTimeFrame(TimeFrame7& tf)
 {
   mTimeFrame = &tf;
   mTraits->adoptTimeFrame(&tf);
 }
 
-void Vertexer::printEpilog(std::function<void(std::string s)> logger,
-                           bool isHybrid,
-                           const unsigned int trackletN01, const unsigned int trackletN12, const unsigned selectedN, const unsigned int vertexN,
-                           const float initT, const float trackletT, const float selecT, const float vertexT)
+void Vertexer::printEpilog(LogFunc& logger,
+                           const unsigned int trackletN01, const unsigned int trackletN12,
+                           const unsigned selectedN, const unsigned int vertexN, const float initT,
+                           const float trackletT, const float selecT, const float vertexT)
 {
   float total = initT + trackletT + selecT + vertexT;
-  logger(fmt::format(" - {}Vertexer: found {} | {} tracklets in: {} ms", isHybrid ? "Hybrid " : "", trackletN01, trackletN12, trackletT));
-  logger(fmt::format(" - {}Vertexer: selected {} tracklets in: {} ms", isHybrid ? "Hybrid " : "", selectedN, selecT));
-  logger(fmt::format(" - {}Vertexer: found {} vertices in: {} ms", isHybrid ? "Hybrid " : "", vertexN, vertexT));
+  logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
+  logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {} ms", mTraits->getName(), selectedN, selecT));
+  logger(fmt::format(" - {} Vertexer: found {} vertices in: {} ms", mTraits->getName(), vertexN, vertexT));
   // logger(fmt::format(" - Timeframe {} vertexing completed in: {} ms, using {} thread(s).", mTimeFrameCounter++, total, mTraits->getNThreads()));
 }
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 3ecf48771f42e..71b54d95d3f8d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -586,7 +586,7 @@ void VertexerTraits::computeVerticesInRof(int rofId,
                                           std::array<float, 2>& beamPosXY,
                                           std::vector<Vertex>& vertices,
                                           std::vector<int>& verticesInRof,
-                                          TimeFrame* tf,
+                                          TimeFrame7* tf,
                                           std::vector<o2::MCCompLabel>* labels,
                                           const int iteration)
 {
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
index be9965fc8be58..9160df6fc49fd 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
@@ -28,9 +28,7 @@
 
 #include "TStopwatch.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 class TrackerDPL : public framework::Task
@@ -41,7 +39,7 @@ class TrackerDPL : public framework::Task
              int trgType,
              const TrackingMode& trMode = TrackingMode::Unset,
              const bool overrBeamEst = false,
-             gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+             o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
   void init(framework::InitContext& ic) final;
   void run(framework::ProcessingContext& pc) final;
@@ -59,9 +57,8 @@ class TrackerDPL : public framework::Task
 };
 
 using o2::its::TrackingMode;
-framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, const std::string& trMode, const bool overrBeamEst = false, gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, const std::string& trMode, const bool overrBeamEst = false, o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 
 #endif /* O2_ITS_TRACKERDPL */
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
index b9e7fd0f6ec39..771b13539b759 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
@@ -71,7 +71,7 @@ void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
                             std::vector<o2::BaseCluster<float>>& output,
                             const its3::TopologyDictionary* dict);
 
-int loadROFrameDataITS3(its::TimeFrame* tf,
+int loadROFrameDataITS3(its::TimeFrame<7>* tf,
                         gsl::span<o2::itsmft::ROFRecord> rofs,
                         gsl::span<const itsmft::CompClusterExt> clusters,
                         gsl::span<const unsigned char>::iterator& pattIt,
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index 58dd56ac41f95..5c3b9670fbdb9 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -56,7 +56,7 @@ void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
   }
 }
 
-int loadROFrameDataITS3(its::TimeFrame* tf,
+int loadROFrameDataITS3(its::TimeFrame<7>* tf,
                         gsl::span<o2::itsmft::ROFRecord> rofs,
                         gsl::span<const itsmft::CompClusterExt> clusters,
                         gsl::span<const unsigned char>::iterator& pattIt,
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index ad7a31cbd7470..4a67fae3b6376 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -111,16 +111,16 @@ GPUReconstruction::~GPUReconstruction()
   }
 }
 
-void GPUReconstruction::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame>* timeFrame)
+void GPUReconstruction::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame)
 {
   if (trackerTraits) {
-    trackerTraits->reset(new o2::its::TrackerTraits);
+    trackerTraits->reset(new o2::its::TrackerTraits<7>);
   }
   if (vertexerTraits) {
     vertexerTraits->reset(new o2::its::VertexerTraits);
   }
   if (timeFrame) {
-    timeFrame->reset(new o2::its::TimeFrame);
+    timeFrame->reset(new o2::its::TimeFrame<7>);
   }
 }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 06f1c27fb6c06..99e780cb248a4 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -36,8 +36,10 @@
 
 namespace o2::its
 {
+template <int>
 class TrackerTraits;
 class VertexerTraits;
+template <int>
 class TimeFrame;
 } // namespace o2::its
 
@@ -189,7 +191,7 @@ class GPUReconstruction
   GPUMemorySizeScalers* MemoryScalers() { return mMemoryScalers.get(); }
 
   // Helpers to fetch processors from other shared libraries
-  virtual void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame>* timeFrame);
+  virtual void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame);
   bool slavesExist() { return mSlaves.size() || mMaster; }
   int slaveId() { return mSlaveId; }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
index 5891891d9da24..87829f5634375 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
@@ -30,9 +30,11 @@ namespace o2::its
 class VertexerTraits
 {
 };
+template <int>
 class TrackerTraits
 {
 };
+template <int>
 class TimeFrame
 {
 };
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 7552d22056c3c..dc904fa96fa2d 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -91,13 +91,13 @@ int32_t GPUReconstructionCUDA::GPUChkErrInternal(const int64_t error, const char
 
 GPUReconstruction* GPUReconstruction_Create_CUDA(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionCUDA(cfg); }
 
-void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame>* timeFrame)
+void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame)
 {
   if (trackerTraits) {
     trackerTraits->reset(new o2::its::TrackerTraitsGPU);
   }
   if (vertexerTraits) {
-    vertexerTraits->reset(new o2::its::VertexerTraitsGPU);
+    vertexerTraits->reset(new o2::its::VertexerTraits); // TODO gpu-code to be implemented
   }
   if (timeFrame) {
     timeFrame->reset(new o2::its::gpu::TimeFrameGPU);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 6c126d153d8ae..1cc7e0fc819ff 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -76,7 +76,7 @@ class GPUReconstructionCUDA : public GPUReconstructionProcessing::KernelInterfac
   void RecordMarker(deviceEvent* ev, int32_t stream) override;
   void SetONNXGPUStream(Ort::SessionOptions& session_options, int32_t stream, int32_t* deviceId) override;
 
-  void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame>* timeFrame) override;
+  void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame) override;
 
 #ifndef __HIPCC__ // CUDA
   bool CanQueryMaxMemory() override { return true; }
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index 5d36dc63ca85d..bcb99fff87a64 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -63,7 +63,7 @@ void GPUChainITS::MemorySize(size_t& gpuMem, size_t& pageLockedHostMem)
 
 int32_t GPUChainITS::Init() { return 0; }
 
-o2::its::TrackerTraits* GPUChainITS::GetITSTrackerTraits()
+o2::its::TrackerTraits<7>* GPUChainITS::GetITSTrackerTraits()
 {
   if (mITSTrackerTraits == nullptr) {
     mRec->GetITSTraits(&mITSTrackerTraits, nullptr, nullptr);
@@ -79,7 +79,7 @@ o2::its::VertexerTraits* GPUChainITS::GetITSVertexerTraits()
   return mITSVertexerTraits.get();
 }
 
-o2::its::TimeFrame* GPUChainITS::GetITSTimeframe()
+o2::its::TimeFrame<7>* GPUChainITS::GetITSTimeframe()
 {
   if (mITSTimeFrame == nullptr) {
     mRec->GetITSTraits(nullptr, nullptr, &mITSTimeFrame);
diff --git a/GPU/GPUTracking/Global/GPUChainITS.h b/GPU/GPUTracking/Global/GPUChainITS.h
index 37cd5acc5264c..150d66031d084 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.h
+++ b/GPU/GPUTracking/Global/GPUChainITS.h
@@ -43,15 +43,15 @@ class GPUChainITS : public GPUChain
   int32_t RunChain() override;
   void MemorySize(size_t& gpuMem, size_t& pageLockedHostMem) override;
 
-  o2::its::TrackerTraits* GetITSTrackerTraits();
+  o2::its::TrackerTraits<7>* GetITSTrackerTraits();
   o2::its::VertexerTraits* GetITSVertexerTraits();
-  o2::its::TimeFrame* GetITSTimeframe();
+  o2::its::TimeFrame<7>* GetITSTimeframe();
 
  protected:
   GPUChainITS(GPUReconstruction* rec, uint32_t maxTracks = GPUCA_MAX_ITS_FIT_TRACKS);
-  std::unique_ptr<o2::its::TrackerTraits> mITSTrackerTraits;
+  std::unique_ptr<o2::its::TrackerTraits<7>> mITSTrackerTraits;
   std::unique_ptr<o2::its::VertexerTraits> mITSVertexerTraits;
-  std::unique_ptr<o2::its::TimeFrame> mITSTimeFrame;
+  std::unique_ptr<o2::its::TimeFrame<7>> mITSTimeFrame;
   std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkAllocator;
 
   uint32_t mMaxTracks;
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index f7e972315a739..f1504a430db36 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -251,7 +251,7 @@ void GPUO2Interface::setErrorCodeOutput(std::vector<std::array<uint32_t, 4>>* v)
   }
 }
 
-void GPUO2Interface::GetITSTraits(o2::its::TrackerTraits*& trackerTraits, o2::its::VertexerTraits*& vertexerTraits, o2::its::TimeFrame*& timeFrame)
+void GPUO2Interface::GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame)
 {
   trackerTraits = mChainITS->GetITSTrackerTraits();
   vertexerTraits = mChainITS->GetITSVertexerTraits();
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.h b/GPU/GPUTracking/Interface/GPUO2Interface.h
index 3a819de7c7b7c..03b24c2b23877 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.h
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.h
@@ -43,8 +43,10 @@ struct ClusterNative;
 
 namespace o2::its
 {
+template <int>
 class TrackerTraits;
 class VertexerTraits;
+template <int>
 class TimeFrame;
 } // namespace o2::its
 
@@ -77,7 +79,7 @@ class GPUO2Interface
   void DumpEvent(int32_t nEvent, GPUTrackingInOutPointers* data);
   void DumpSettings();
 
-  void GetITSTraits(o2::its::TrackerTraits*& trackerTraits, o2::its::VertexerTraits*& vertexerTraits, o2::its::TimeFrame*& timeFrame);
+  void GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame);
   const o2::base::Propagator* GetDeviceO2Propagator(int32_t iThread = 0) const;
   void UseGPUPolynomialFieldInPropagator(o2::base::Propagator* prop) const;
 
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 73f1f208e8889..405f4a371f0cc 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -58,6 +58,7 @@ class GeometryFlat;
 
 namespace its
 {
+template <int>
 class TimeFrame;
 class ITSTrackingInterface;
 } // namespace its
@@ -214,7 +215,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   std::vector<int32_t> mTPCSectors;
   std::unique_ptr<o2::its::ITSTrackingInterface> mITSTrackingInterface;
   std::unique_ptr<gpurecoworkflow_internals::GPURecoWorkflowSpec_PipelineInternals> mPipeline;
-  o2::its::TimeFrame* mITSTimeFrame = nullptr;
+  o2::its::TimeFrame<7>* mITSTimeFrame = nullptr;
   std::vector<fair::mq::RegionInfo> mRegionInfos;
   const o2::itsmft::TopologyDictionary* mITSDict = nullptr;
   const o2::dataformats::MeanVertexObject* mMeanVertex;
diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index e56958cba2c9b..31ccaad8c2783 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -31,14 +31,14 @@ int32_t GPURecoWorkflowSpec::runITSTracking(o2::framework::ProcessingContext& pc
 {
   mITSTimeFrame->setDevicePropagator(mGPUReco->GetDeviceO2Propagator());
   LOGP(debug, "GPUChainITS is giving me device propagator: {}", (void*)mGPUReco->GetDeviceO2Propagator());
-  mITSTrackingInterface->run<true>(pc);
+  mITSTrackingInterface->run(pc);
   return 0;
 }
 
 void GPURecoWorkflowSpec::initFunctionITS(o2::framework::InitContext& ic)
 {
   o2::its::VertexerTraits* vtxTraits = nullptr;
-  o2::its::TrackerTraits* trkTraits = nullptr;
+  o2::its::TrackerTraits<7>* trkTraits = nullptr;
 #ifdef ENABLE_UPGRADES
   if (mSpecConfig.isITS3) {
     mITSTrackingInterface = std::make_unique<o2::its3::ITS3TrackingInterface>(mSpecConfig.processMC,

From a7534dbce5e6c209af507f96345e33eb77d049fb Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 26 May 2025 14:10:26 +0200
Subject: [PATCH 0421/1764] GPU RTC: Check that current compiler versions are
 the same as those used to create RTC code in cache

---
 GPU/GPUTracking/Base/GPUReconstruction.h              |  1 +
 .../GPUReconstructionAvailableBackends.template.h     |  3 +++
 GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx     |  5 +++++
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx         | 11 ++++++++---
 GPU/GPUTracking/CMakeLists.txt                        |  1 +
 dependencies/FindO2GPU.cmake                          |  6 +++---
 6 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 99e780cb248a4..70c504cdee6e1 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -275,6 +275,7 @@ class GPUReconstruction
 
   // Private helpers for library loading
   static std::shared_ptr<LibraryLoader>* GetLibraryInstance(DeviceType type, bool verbose);
+  static std::string getBackendVersions();
 
   // Private helper functions for memory management
   size_t AllocateRegisteredMemoryHelper(GPUMemoryResource* res, void*& ptr, void*& memorypool, void* memorybase, size_t memorysize, void* (GPUMemoryResource::*SetPointers)(void*), void*& memorypoolend, const char* device);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionAvailableBackends.template.h b/GPU/GPUTracking/Base/GPUReconstructionAvailableBackends.template.h
index 35892db121f50..aaf5f23b8d855 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionAvailableBackends.template.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionAvailableBackends.template.h
@@ -12,6 +12,9 @@
 /// \file GPUReconstructionAvailableBackends.h
 /// \author David Rohr
 
+// clang-format off
 #cmakedefine CUDA_ENABLED
 #cmakedefine HIP_ENABLED
 #cmakedefine OPENCL_ENABLED
+#cmakedefine GPUCA_COMPILER_VERSIONS @GPUCA_COMPILER_VERSIONS@
+// clang-format on
diff --git a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
index 64184dd724acd..c70c5d8c51d6f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
@@ -184,3 +184,8 @@ int32_t GPUReconstruction::LibraryLoader::CloseLibrary()
   mGPUEntry = nullptr;
   return 0;
 }
+
+std::string GPUReconstruction::getBackendVersions()
+{
+  return GPUCA_M_STR(GPUCA_COMPILER_VERSIONS);
+}
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index b5a3b1bb919b9..8c3fb92c11c9e 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -80,13 +80,16 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     GPUInfo("RTC Launch Bounds:\n%s", launchBounds.c_str());
   }
 
-  char shasource[21], shaparam[21], shacmd[21], shakernels[21], shabounds[21];
+  const std::string compilerVersions = getBackendVersions();
+
+  char shasource[21], shaparam[21], shacmd[21], shakernels[21], shabounds[21], shaversion[21];
   if (GetProcessingSettings().rtc.cacheOutput) {
     o2::framework::internal::SHA1(shasource, _binary_GPUReconstructionCUDArtc_src_start, _binary_GPUReconstructionCUDArtc_src_len);
     o2::framework::internal::SHA1(shaparam, rtcparam.c_str(), rtcparam.size());
     o2::framework::internal::SHA1(shacmd, baseCommand.c_str(), baseCommand.size());
     o2::framework::internal::SHA1(shakernels, kernelsall.c_str(), kernelsall.size());
     o2::framework::internal::SHA1(shabounds, launchBounds.c_str(), launchBounds.size());
+    o2::framework::internal::SHA1(shaversion, compilerVersions.c_str(), compilerVersions.size());
   }
 
   nCompile = GetProcessingSettings().rtc.compilePerKernel ? kernels.size() : 1;
@@ -131,11 +134,12 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
           }
           return 0;
         };
-        if (checkSHA(shasource, "source") || // TODO: CHECK VERSION!
+        if (checkSHA(shasource, "source") ||
             checkSHA(shaparam, "param") ||
             checkSHA(shacmd, "command line") ||
             checkSHA(shakernels, "kernel definitions") ||
-            checkSHA(shabounds, "launch bounds")) {
+            checkSHA(shabounds, "launch bounds") ||
+            checkSHA(shaversion, "compiler versions")) {
           break;
         }
         GPUSettingsProcessingRTC cachedSettings;
@@ -237,6 +241,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
           fwrite(shacmd, 1, 20, fp) != 20 ||
           fwrite(shakernels, 1, 20, fp) != 20 ||
           fwrite(shabounds, 1, 20, fp) != 20 ||
+          fwrite(shaversion, 1, 20, fp) != 20 ||
           fwrite(&GetProcessingSettings().rtc, sizeof(GetProcessingSettings().rtc), 1, fp) != 1) {
         throw std::runtime_error("Error writing cache file");
       }
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 1b108bc74190d..67db16ffe9607 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -396,6 +396,7 @@ install(DIRECTORY utils
         DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU
         FILES_MATCHING PATTERN *.h)
 
+set(GPUCA_COMPILER_VERSIONS "CUDA ${CMAKE_CUDA_COMPILER_VERSION} HIP ${hip_VERSION} ${CMAKE_HIP_COMPILER_VERSION} ROCM ${CMAKE_HIP_COMPILER_ROCM_ROOT} LLVM ${LLVM_PACKAGE_VERSION}")
 
 # GPUReconstructionLibrary needs to know which GPU backends are enabled for proper error messages
 configure_file(Base/GPUReconstructionAvailableBackends.template.h ${CMAKE_CURRENT_BINARY_DIR}/GPUReconstructionAvailableBackends.h)
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 33925e8cf1341..438ec5e04306f 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -139,8 +139,8 @@ if(ENABLE_CUDA)
       message(${FAILURE_SEVERITY} "CUDA found but thrust not available")
       set(CMAKE_CUDA_COMPILER OFF)
     endif()
-    if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "12.6")
-      message(${FAILURE_SEVERITY} "CUDA Version too old: ${CMAKE_CUDA_COMPILER_VERSION}, 12.6 required")
+    if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "12.8")
+      message(${FAILURE_SEVERITY} "CUDA Version too old: ${CMAKE_CUDA_COMPILER_VERSION}, 12.8 required")
       set(CMAKE_CUDA_COMPILER OFF)
     endif()
   endif()
@@ -279,7 +279,7 @@ if(ENABLE_HIP)
   elseif(NOT ENABLE_HIP STREQUAL "AUTO")
     message(FATAL_ERROR "HIP requested, but CMAKE_PREFIX_PATH env variable does not contain rocm folder!")
   endif()
-  if(hip_FOUND AND NOT hip_VERSION VERSION_GREATER_EQUAL "5.5")
+  if(hip_FOUND AND NOT hip_VERSION VERSION_GREATER_EQUAL "6.3")
     set(hip_FOUND 0)
   endif()
   if(hip_FOUND AND hipcub_FOUND AND rocthrust_FOUND AND rocprim_FOUND AND hip_HIPCC_EXECUTABLE AND hip_HIPIFY_PERL_EXECUTABLE)

From 807a6b12b429b67ea9814c5b68680e7586b6bf36 Mon Sep 17 00:00:00 2001
From: ddobrigk <david.dobrigkeit.chinellato@cern.ch>
Date: Tue, 27 May 2025 21:26:07 +0200
Subject: [PATCH 0422/1764] Add THL histograms to framework (#14333)

---
 Framework/Core/include/Framework/HistogramSpec.h | 6 ++++++
 Framework/Core/src/HistogramSpec.cxx             | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/Framework/Core/include/Framework/HistogramSpec.h b/Framework/Core/include/Framework/HistogramSpec.h
index 5b0c7931d1c65..bfd9ba702496d 100644
--- a/Framework/Core/include/Framework/HistogramSpec.h
+++ b/Framework/Core/include/Framework/HistogramSpec.h
@@ -38,16 +38,19 @@ enum HistType : unsigned int {
   kTH1D,
   kTH1F,
   kTH1I,
+  kTH1L,
   kTH1C,
   kTH1S,
   kTH2D,
   kTH2F,
   kTH2I,
+  kTH2L,
   kTH2C,
   kTH2S,
   kTH3D,
   kTH3F,
   kTH3I,
+  kTH3L,
   kTH3C,
   kTH3S,
   kTHnD,
@@ -227,16 +230,19 @@ struct HistFactory {
 DECLAREEXT(TH1D);
 DECLAREEXT(TH1F);
 DECLAREEXT(TH1I);
+DECLAREEXT(TH1L);
 DECLAREEXT(TH1C);
 DECLAREEXT(TH1S);
 DECLAREEXT(TH2D);
 DECLAREEXT(TH2F);
 DECLAREEXT(TH2I);
+DECLAREEXT(TH2L);
 DECLAREEXT(TH2C);
 DECLAREEXT(TH2S);
 DECLAREEXT(TH3D);
 DECLAREEXT(TH3F);
 DECLAREEXT(TH3I);
+DECLAREEXT(TH3L);
 DECLAREEXT(TH3C);
 DECLAREEXT(TH3S);
 DECLAREEXT(THnD);
diff --git a/Framework/Core/src/HistogramSpec.cxx b/Framework/Core/src/HistogramSpec.cxx
index 1ac3d2f920d5d..ef23a29c828f7 100644
--- a/Framework/Core/src/HistogramSpec.cxx
+++ b/Framework/Core/src/HistogramSpec.cxx
@@ -150,18 +150,21 @@ HistPtr HistFactory::createHistVariant(const HistogramSpec& histSpec)
     CREATE_HIST_CASE(TH1D, TH1)
     CREATE_HIST_CASE(TH1F, TH1)
     CREATE_HIST_CASE(TH1I, TH1)
+    CREATE_HIST_CASE(TH1L, TH1)
     CREATE_HIST_CASE(TH1C, TH1)
     CREATE_HIST_CASE(TH1S, TH1)
 
     CREATE_HIST_CASE(TH2D, TH2)
     CREATE_HIST_CASE(TH2F, TH2)
     CREATE_HIST_CASE(TH2I, TH2)
+    CREATE_HIST_CASE(TH2L, TH2)
     CREATE_HIST_CASE(TH2C, TH2)
     CREATE_HIST_CASE(TH2S, TH2)
 
     CREATE_HIST_CASE(TH3D, TH3)
     CREATE_HIST_CASE(TH3F, TH3)
     CREATE_HIST_CASE(TH3I, TH3)
+    CREATE_HIST_CASE(TH3L, TH3)
     CREATE_HIST_CASE(TH3C, TH3)
     CREATE_HIST_CASE(TH3S, TH3)
 
@@ -215,16 +218,19 @@ TAxis* HistFactory::getAxis(const int i, T* hist)
 EXPIMPL(TH1D);
 EXPIMPL(TH1F);
 EXPIMPL(TH1I);
+EXPIMPL(TH1L);
 EXPIMPL(TH1C);
 EXPIMPL(TH1S);
 EXPIMPL(TH2D);
 EXPIMPL(TH2F);
 EXPIMPL(TH2I);
+EXPIMPL(TH2L);
 EXPIMPL(TH2C);
 EXPIMPL(TH2S);
 EXPIMPL(TH3D);
 EXPIMPL(TH3F);
 EXPIMPL(TH3I);
+EXPIMPL(TH3L);
 EXPIMPL(TH3C);
 EXPIMPL(TH3S);
 EXPIMPL(THnD);

From 2d7a0bdc86c69d0af3f3af8e086599b69ce4cb91 Mon Sep 17 00:00:00 2001
From: Piotr Konopka <piotr.jan.konopka@cern.ch>
Date: Tue, 27 May 2025 22:57:09 +0200
Subject: [PATCH 0423/1764] QC-1287 Fix Mergers latency optimization with
 RoundRobin processing (#14328)

The optimization was correctly working when we split a range of InputSpecs between different Mergers in a layer, but not when they are time-pipelined.
In the commit, we modify the expected number of input messages per cycle to include time-pipeline parameter in the previous and current layer.
---
 Utilities/Mergers/src/MergerInfrastructureBuilder.cxx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Utilities/Mergers/src/MergerInfrastructureBuilder.cxx b/Utilities/Mergers/src/MergerInfrastructureBuilder.cxx
index 9fcb6aaa482dd..8719dfb9fe0ca 100644
--- a/Utilities/Mergers/src/MergerInfrastructureBuilder.cxx
+++ b/Utilities/Mergers/src/MergerInfrastructureBuilder.cxx
@@ -136,6 +136,7 @@ framework::WorkflowSpec MergerInfrastructureBuilder::generateInfrastructure()
   mergerBuilder.setName(mInfrastructureName);
   mergerBuilder.setOutputSpecMovingWindow(mOutputSpecMovingWindow);
 
+  size_t timePipelinePreviousLayer = 1;
   for (size_t layer = 1; layer < mergersPerLayer.size(); layer++) {
 
     size_t numberOfMergers = mergersPerLayer[layer];
@@ -166,7 +167,9 @@ framework::WorkflowSpec MergerInfrastructureBuilder::generateInfrastructure()
       if (layer > 1 && !expendable) {
         // we optimize the latency of higher Merger layers by publishing an object as soon as we get the expected number of inputs.
         // we can do that safely only if tasks are not expendable, i.e. we are guaranteed that workflow stops if a Merger crashes.
-        const auto inputNumber = std::distance(inputsRangeBegin, inputsRangeEnd);
+
+        // The formula below takes into account both ways of splitting inputs - by consuming a subset of InputSpecs and by using time-pipelined data processors.
+        const auto inputNumber = std::distance(inputsRangeBegin, inputsRangeEnd) * timePipelinePreviousLayer / timePipelineVal;
         assert(inputNumber != 0);
         layerConfig.publicationDecision = {PublicationDecision::EachNArrivals, inputNumber};
       }
@@ -185,6 +188,7 @@ framework::WorkflowSpec MergerInfrastructureBuilder::generateInfrastructure()
       inputsRangeBegin = inputsRangeEnd;
     }
     layerInputs = nextLayerInputs; // todo: could be optimised with pointers
+    timePipelinePreviousLayer = timePipelineVal;
   }
 
   return workflow;

From 606a14ea2611675acf8b68776d1a0ec93d6f95dc Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Wed, 28 May 2025 13:45:36 +0200
Subject: [PATCH 0424/1764] DPL: get flags from DataProcessingHeader in
 isCalibrationData check for new EoS (#14335)

---
 Framework/Core/src/DataRelayer.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index c6333350d6da7..6ddfa7597f7f6 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -418,8 +418,8 @@ void DataRelayer::pruneCache(TimesliceSlot slot, OnDropCallback onDrop)
 
 bool isCalibrationData(std::unique_ptr<fair::mq::Message>& first)
 {
-  auto* dh = o2::header::get<DataHeader*>(first->GetData());
-  return dh->flagsDerivedHeader & DataProcessingHeader::KEEP_AT_EOS_FLAG;
+  auto* dph = o2::header::get<DataProcessingHeader*>(first->GetData());
+  return static_cast<o2::header::BaseHeader const&>(*dph).flagsDerivedHeader & DataProcessingHeader::KEEP_AT_EOS_FLAG;
 }
 
 DataRelayer::RelayChoice

From 3641fdc58c05cef94417206701426ae5f0aac3ae Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 28 May 2025 13:06:11 +0200
Subject: [PATCH 0425/1764] Update GPU and FST documentation

---
 GPU/documentation/build-standalone.md                         | 2 ++
 .../full-system-test/documentation/full-system-test-setup.md  | 3 +++
 prodtests/full-system-test/documentation/full-system-test.md  | 4 ++++
 3 files changed, 9 insertions(+)

diff --git a/GPU/documentation/build-standalone.md b/GPU/documentation/build-standalone.md
index bf84fd3edf0fb..d6aa45d749568 100644
--- a/GPU/documentation/build-standalone.md
+++ b/GPU/documentation/build-standalone.md
@@ -71,6 +71,8 @@ For a reaslistic benchmark using GPU 0 on the EPNs, please use:
 ROCR_VISIBLE_DEVICES=0 numactl --membind 0 --cpunodebind 0 ./ca -e o2-pbpb-100 --gpuType HIP --memSize 15000000000 --inputMemory 6000000000 --outputMemory 10000000000 --sync --runs 10 --RTCenable --setO2Settings --PROCdoublePipeline
 ```
 
+Note that on the MI50 nodes, we use only <16 GB of memory, since there is a performance regression when using the upper half of the 32 GB. In order to fit in the 16 GB, we have reduced the time frame length to 32 orbits from 2024 onwards.
+
 # Generating a dataset
 
 The standalone benchmark supports running on Run2 data exported from AliRoot, or to run on Run3 data from O2. This document covers only the O2 case.
diff --git a/prodtests/full-system-test/documentation/full-system-test-setup.md b/prodtests/full-system-test/documentation/full-system-test-setup.md
index e90a3984dd3da..d64059925435b 100644
--- a/prodtests/full-system-test/documentation/full-system-test-setup.md
+++ b/prodtests/full-system-test/documentation/full-system-test-setup.md
@@ -63,6 +63,9 @@ This will use 4 GPU with the HIP backend and allocate 22 GB of scratch memory on
     SHM_MANAGER_SHMID=1 TFDELAY=2.8457 NTIMEFRAMES=8 $O2_ROOT/prodtests/full-system-test/start-tmux.sh dd
     ```
 
+Note that as of 2024, we are running with a TF length of 32 orbits.
+To simulate time frames accordingly, please set `NEVENTS=200 NHBPERTF=32` for full-system-test.sh.
+
 ---
 
 # Remarks for running with distortions:
diff --git a/prodtests/full-system-test/documentation/full-system-test.md b/prodtests/full-system-test/documentation/full-system-test.md
index 80cc08baa2255..624b2804b8094 100644
--- a/prodtests/full-system-test/documentation/full-system-test.md
+++ b/prodtests/full-system-test/documentation/full-system-test.md
@@ -30,6 +30,10 @@ For a simulation of a full 128 orbit time frame, run
 ```
 NEvents=650 NEventsQED=30000 SHMSIZE=128000000000 TPCTRACKERSCRATCHMEMORY=30000000000 $O2_ROOT/prodtests/full_system_test.sh
 ```
+As of 2024, we are using 32 orbit time frames. Fo doing so, please set:
+```
+NEVENTS=200 NHBPERTF=32
+```
 To simulate collisions with an embedded signal one can set 'D0_EMBEDDING=1' while also supplying a config file with the desired settings using 'FST_EMBEDDING_CONFIG'. For an example configuration see '/prodtests/full-system-test/pythia8.cfg' and to generate a specific configuration one can use '${O2DPG_ROOT}/MC/config/common/pythia8/utils/mkpy8cfg.py'. Additional examples can be found in '/run/SimExamples/'
 ```
 DO_EMBEDDING=1 NEvents=5 NEventsQED=100 $O2_ROOT/prodtests/full_system_test.sh

From cc47576d942b2d84e0cc59992cd2a78f6e4d47d0 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 28 May 2025 11:17:23 +0200
Subject: [PATCH 0426/1764] raw-file-reader: move run-number option from w-flow
 to device level

---
 Detectors/Raw/include/DetectorsRaw/RawFileReader.h | 1 -
 Detectors/Raw/src/RawFileReaderWorkflow.cxx        | 5 ++++-
 Detectors/Raw/src/rawfile-reader-workflow.cxx      | 2 --
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detectors/Raw/include/DetectorsRaw/RawFileReader.h b/Detectors/Raw/include/DetectorsRaw/RawFileReader.h
index 7deac03d663a6..6f51c2e38ec36 100644
--- a/Detectors/Raw/include/DetectorsRaw/RawFileReader.h
+++ b/Detectors/Raw/include/DetectorsRaw/RawFileReader.h
@@ -47,7 +47,6 @@ struct ReaderInp {
   size_t bufferSize = 1024L * 1024L;
   size_t minSHM = 0;
   int loop = 1;
-  int runNumber = 0;
   uint32_t delay_us = 0;
   uint32_t errMap = 0xffffffff;
   uint32_t minTF = 0;
diff --git a/Detectors/Raw/src/RawFileReaderWorkflow.cxx b/Detectors/Raw/src/RawFileReaderWorkflow.cxx
index a7313f3154ac2..217daaebff4bb 100644
--- a/Detectors/Raw/src/RawFileReaderWorkflow.cxx
+++ b/Detectors/Raw/src/RawFileReaderWorkflow.cxx
@@ -96,7 +96,7 @@ class RawReaderSpecs : public o2f::Task
 
 //___________________________________________________________
 RawReaderSpecs::RawReaderSpecs(const ReaderInp& rinp)
-  : mLoop(rinp.loop < 0 ? INT_MAX : (rinp.loop < 1 ? 1 : rinp.loop)), mDelayUSec(rinp.delay_us), mMinTFID(rinp.minTF), mMaxTFID(rinp.maxTF), mRunNumber(rinp.runNumber), mPartPerSP(rinp.partPerSP), mSup0xccdb(rinp.sup0xccdb), mReader(std::make_unique<o2::raw::RawFileReader>(rinp.inifile, 0, rinp.bufferSize, rinp.onlyDet)), mRawChannelName(rinp.rawChannelConfig), mPreferCalcTF(rinp.preferCalcTF), mMinSHM(rinp.minSHM)
+  : mLoop(rinp.loop < 0 ? INT_MAX : (rinp.loop < 1 ? 1 : rinp.loop)), mDelayUSec(rinp.delay_us), mMinTFID(rinp.minTF), mMaxTFID(rinp.maxTF), mPartPerSP(rinp.partPerSP), mSup0xccdb(rinp.sup0xccdb), mReader(std::make_unique<o2::raw::RawFileReader>(rinp.inifile, 0, rinp.bufferSize, rinp.onlyDet)), mRawChannelName(rinp.rawChannelConfig), mPreferCalcTF(rinp.preferCalcTF), mMinSHM(rinp.minSHM)
 {
   mReader->setCheckErrors(rinp.errMap);
   mReader->setMaxTFToRead(rinp.maxTF);
@@ -149,6 +149,7 @@ void RawReaderSpecs::init(o2f::InitContext& ic)
   mTimer.Start();
   mTimer.Stop();
   mVerbosity = ic.options().get<int>("verbosity-level");
+  mRunNumber = ic.options().get<int>("run-number");
   mReader->setVerbosity(mVerbosity);
   mReader->init();
   if (mMaxTFID >= mReader->getNTimeFrames()) {
@@ -418,6 +419,8 @@ o2f::DataProcessorSpec getReaderSpec(ReaderInp rinp)
 
   spec.algorithm = o2f::adaptFromTask<RawReaderSpecs>(rinp);
   spec.options.emplace_back(o2f::ConfigParamSpec{"verbosity-level", o2f::VariantType::Int, 0, {"verbosity level"}});
+  spec.options.emplace_back(o2f::ConfigParamSpec{"run-number", o2f::VariantType::Int, 0, {"impose run number"}});
+
   return spec;
 }
 
diff --git a/Detectors/Raw/src/rawfile-reader-workflow.cxx b/Detectors/Raw/src/rawfile-reader-workflow.cxx
index 3a5440f80ed2d..10de4a729168f 100644
--- a/Detectors/Raw/src/rawfile-reader-workflow.cxx
+++ b/Detectors/Raw/src/rawfile-reader-workflow.cxx
@@ -30,7 +30,6 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   options.push_back(ConfigParamSpec{"onlyDet", VariantType::String, "all", {"list of dectors"}});
   options.push_back(ConfigParamSpec{"min-tf", VariantType::Int64, 0L, {"min TF ID to process"}});
   options.push_back(ConfigParamSpec{"max-tf", VariantType::Int64, 0xffffffffL, {"max TF ID to process"}});
-  options.push_back(ConfigParamSpec{"run-number", VariantType::Int, 0, {"impose run number"}});
   options.push_back(ConfigParamSpec{"loop", VariantType::Int, 1, {"loop N times (infinite for N<0)"}});
   options.push_back(ConfigParamSpec{"delay", VariantType::Float, 0.f, {"delay in seconds between consecutive TFs sending"}});
   options.push_back(ConfigParamSpec{"buffer-size", VariantType::Int64, 5 * 1024L, {"buffer size for files preprocessing"}});
@@ -67,7 +66,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   rinp.onlyDet = configcontext.options().get<std::string>("onlyDet");
   rinp.maxTF = uint32_t(configcontext.options().get<int64_t>("max-tf"));
   rinp.minTF = uint32_t(configcontext.options().get<int64_t>("min-tf"));
-  rinp.runNumber = configcontext.options().get<int>("run-number");
   rinp.bufferSize = uint64_t(configcontext.options().get<int64_t>("buffer-size"));
   rinp.spSize = uint64_t(configcontext.options().get<int64_t>("super-page-size"));
   rinp.partPerSP = configcontext.options().get<bool>("part-per-sp");

From 49b2cd34011517fc1dbca01f1451460587eb69e4 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 27 May 2025 14:36:42 +0200
Subject: [PATCH 0427/1764] Only tracklets pT cut-off should not be touched for
 B=0

---
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 0df1899c9ab6a..b3bdd62e072fd 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -38,9 +38,7 @@ void ITSTrackingInterface::initialise()
   std::vector<TrackingParameters> trackParams;
   const auto& trackConf = o2::its::TrackerParamConfig::Instance();
   float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791;
-  if (bFactor < 0.01) {
-    bFactor = 1.;
-  }
+  float bFactorTracklets = bFactor < 0.01 ? 1. : bFactor; // for tracklets only
   if (mMode == TrackingMode::Unset) {
     mMode = (TrackingMode)(trackConf.trackingMode);
     LOGP(info, "Tracking mode not set, trying to fetch it from configurable params to: {}", asString(mMode));
@@ -129,7 +127,7 @@ void ITSTrackingInterface::initialise()
   // adjust pT settings to actual mag. field
   for (size_t ip = 0; ip < trackParams.size(); ip++) {
     auto& param = trackParams[ip];
-    param.TrackletMinPt *= bFactor;
+    param.TrackletMinPt *= bFactorTracklets;
     for (int ilg = trackConf.MaxTrackLength; ilg >= trackConf.MinTrackLength; ilg--) {
       int lslot = trackConf.MaxTrackLength - ilg;
       param.MinPt[lslot] *= bFactor;

From d2f7ad7d152d08bd282815ccb667ac45f8430312 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 29 May 2025 00:09:36 +0200
Subject: [PATCH 0428/1764] Add flags to TrackInfoExt

---
 .../GlobalTrackingStudy/TrackInfoExt.h        | 19 ++++++++++++++++++-
 .../study/src/TrackingStudy.cxx               |  6 ++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
index 26eeea858d14b..2eed64df3bfca 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
@@ -25,6 +25,9 @@ namespace dataformats
 {
 
 struct TrackInfoExt {
+  enum { TPCA = 0,
+         TPCC = 1,
+         kBitMask = 0xffff };
   o2::track::TrackParCov track;
   DCA dca{};
   DCA dcaTPC{};
@@ -43,6 +46,7 @@ struct TrackInfoExt {
   float q2ptITSTPCTRD = 0.f;
   uint16_t nClTPC = 0;
   uint16_t nClTPCShared = 0;
+  uint16_t flags = 0;
   uint8_t pattITS = 0;
   uint8_t nClITS = 0;
   uint8_t rowMinTPC = 0;
@@ -50,6 +54,14 @@ struct TrackInfoExt {
   uint8_t rowMaxTPC = 0;
   uint8_t rowCountTPC = 0;
 
+  void setTPCA() { setBit(int(TPCA)); }
+  void setTPCC() { setBit(int(TPCC)); }
+  void setTPCAC() { setBit(int(TPCC)); }
+
+  bool isTPCA() const { return isBitSet(int(TPCA)); }
+  bool isTPCC() const { return isBitSet(int(TPCC)); }
+  bool isTPCAC() const { return isBitSet(int(TPCA)) && isBitSet(int(TPCC)); }
+
   float getTPCInX() const { return innerTPCPos[0]; }
   float getTPCInY() const { return innerTPCPos[1]; }
   float getTPCInZ() const { return innerTPCPos[2]; }
@@ -57,7 +69,12 @@ struct TrackInfoExt {
   float getTPCInY0() const { return innerTPCPos0[1]; }
   float getTPCInZ0() const { return innerTPCPos0[2]; }
 
-  ClassDefNV(TrackInfoExt, 6);
+  void setBits(std::uint16_t b) { flags = b; }
+  void setBit(int bit) { flags |= kBitMask & (0x1 << bit); }
+  void resetBit(int bit) { flags &= ~(kBitMask & (0x1 << bit)); }
+  bool isBitSet(int bit) const { return flags & (kBitMask & (0x1 << bit)); }
+
+  ClassDefNV(TrackInfoExt, 7);
 };
 
 } // namespace dataformats
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index a2bf6abd35fef..97721a30b0ab8 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -486,6 +486,12 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
 
           if (tpcTr) {
             float tsuse = trcExt.ttime / (8 * o2::constants::lhc::LHCBunchSpacingMUS);
+            if (tpcTr->hasASideClusters()) {
+              trcExt.setTPCA();
+            }
+            if (tpcTr->hasCSideClusters()) {
+              trcExt.setTPCC();
+            }
             if (is == GTrackID::TPC) {
               trcExt.dcaTPC = dca;
               tsuse = -1e9;

From 49882f77f9f49fad39898733e0dcc54b819884ab Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 28 May 2025 09:48:08 +0200
Subject: [PATCH 0429/1764] GPU CMake: Some adaptions for gpu-systems package

---
 dependencies/FindO2GPU.cmake | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 438ec5e04306f..eb63a72b3f536 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -67,7 +67,7 @@ endfunction()
 # Need to strip c++17 imposed by alidist defaults
 STRING(REGEX REPLACE "\-std=[^ ]*" "" O2_GPU_CMAKE_CXX_FLAGS_NOSTD "${CMAKE_CXX_FLAGS}")
 
-# ---------------------------------- Fast Math / Deterministic Mode ----------------------------------
+# ================================== Fast Math / Deterministic Mode ==================================
 # set(GPUCA_DETERMINISTIC_MODE WHOLEO2)          # Override
 set(GPUCA_DETERMINISTIC_MODE_MAP_OFF 0)
 set(GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH 1) # No -ffast-math and similar compile flags for GPU folder
@@ -101,7 +101,7 @@ if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_WHOLEO2
 endif()
 
 
-# ---------------------------------- CUDA ----------------------------------
+# ================================== CUDA ==================================
 if(ENABLE_CUDA)
   if(CUDA_COMPUTETARGET)
     set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET})
@@ -180,7 +180,7 @@ if(ENABLE_CUDA)
   endif()
 endif()
 
-# ---------------------------------- OpenCL ----------------------------------
+# ================================== OpenCL ==================================
 if(ENABLE_OPENCL)
   find_package(OpenCL)
   if(ENABLE_OPENCL AND NOT ENABLE_OPENCL STREQUAL "AUTO")
@@ -188,9 +188,11 @@ if(ENABLE_OPENCL)
   else()
     set_package_properties(OpenCL PROPERTIES TYPE OPTIONAL)
   endif()
-  find_package(LLVM)
-  if(LLVM_FOUND)
-    find_package(Clang)
+  if(NOT OPENCL_COMPATIBLE_CLANG_FOUND)
+    find_package(LLVM)
+    if(LLVM_FOUND)
+      find_package(Clang)
+    endif()
   endif()
   if (GPUCA_OPENCL_CLANGBIN)
     set(LLVM_CLANG ${GPUCA_OPENCL_CLANGBIN})
@@ -225,7 +227,7 @@ if(ENABLE_OPENCL)
   endif()
 endif()
 
-# ---------------------------------- HIP ----------------------------------
+# ================================== HIP ==================================
 if(ENABLE_HIP)
   if(HIP_AMDGPUTARGET)
     set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}")
@@ -329,4 +331,6 @@ endif()
 
 # if we end up here without a FATAL, it means we have found the "O2GPU" package
 set(O2GPU_FOUND TRUE)
-include("${CMAKE_CURRENT_LIST_DIR}/../GPU/GPUTracking/cmake/kernel_helpers.cmake")
+if (NOT GPUCA_FINDO2GPU_CHECK_ONLY)
+  include("${CMAKE_CURRENT_LIST_DIR}/../GPU/GPUTracking/cmake/kernel_helpers.cmake")
+endif()

From e1f9cdca8064dbe0b9d0c8a7e06ce9dd1b1d3506 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 29 May 2025 14:17:46 +0200
Subject: [PATCH 0430/1764] DPL: adapt to arrow 20.0.0 (#14332)

---
 Framework/AnalysisSupport/src/RNTuplePlugin.cxx | 13 ++++++++-----
 Framework/AnalysisSupport/src/TTreePlugin.cxx   | 17 +++++++++++------
 Framework/Core/src/EmptyFragment.cxx            | 11 ++++++++---
 Framework/Core/test/o2AO2DToAO3D.cxx            |  1 +
 4 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/Framework/AnalysisSupport/src/RNTuplePlugin.cxx b/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
index 2c6fffe872db3..71719d712b6d3 100644
--- a/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
+++ b/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
@@ -30,6 +30,8 @@
 #include <arrow/array/array_primitive.h>
 #include <arrow/array/builder_nested.h>
 #include <arrow/array/builder_primitive.h>
+#include <arrow/array/util.h>
+#include <arrow/record_batch.h>
 #include <arrow/dataset/file_base.h>
 
 #if __has_include(<ROOT/RFieldBase.hxx>)
@@ -859,18 +861,19 @@ arrow::Result<arrow::RecordBatchGenerator> RNTupleFileFormat::ScanBatchesAsync(
         }
         switch (listSize) {
           case -1: {
-            auto varray = std::make_shared<arrow::PrimitiveArray>(physicalField->type()->field(0)->type(), totalSize, arrowValuesBuffer);
-            array = std::make_shared<arrow::ListArray>(physicalField->type(), readEntries, arrowOffsetBuffer, varray);
+            auto vdata = std::make_shared<arrow::ArrayData>(physicalField->type()->field(0)->type(), totalSize, std::vector<std::shared_ptr<arrow::Buffer>>{nullptr, arrowValuesBuffer});
+            array = std::make_shared<arrow::ListArray>(physicalField->type(), readEntries, arrowOffsetBuffer, arrow::MakeArray(vdata));
           } break;
           case 1: {
             totalSize = readEntries * listSize;
-            array = std::make_shared<arrow::PrimitiveArray>(physicalField->type(), readEntries, arrowValuesBuffer);
+            auto data = std::make_shared<arrow::ArrayData>(physicalField->type(), readEntries, std::vector<std::shared_ptr<arrow::Buffer>>{nullptr, arrowValuesBuffer});
+            array = arrow::MakeArray(data);
 
           } break;
           default: {
             totalSize = readEntries * listSize;
-            auto varray = std::make_shared<arrow::PrimitiveArray>(physicalField->type()->field(0)->type(), totalSize, arrowValuesBuffer);
-            array = std::make_shared<arrow::FixedSizeListArray>(physicalField->type(), readEntries, varray);
+            auto vdata = std::make_shared<arrow::ArrayData>(physicalField->type()->field(0)->type(), totalSize, std::vector<std::shared_ptr<arrow::Buffer>>{nullptr, arrowValuesBuffer});
+            array = std::make_shared<arrow::FixedSizeListArray>(physicalField->type(), readEntries, arrow::MakeArray(vdata));
           }
         }
       }
diff --git a/Framework/AnalysisSupport/src/TTreePlugin.cxx b/Framework/AnalysisSupport/src/TTreePlugin.cxx
index 28fd713112c94..4a51f4eac68f6 100644
--- a/Framework/AnalysisSupport/src/TTreePlugin.cxx
+++ b/Framework/AnalysisSupport/src/TTreePlugin.cxx
@@ -27,6 +27,8 @@
 #include <arrow/array/array_primitive.h>
 #include <arrow/array/builder_nested.h>
 #include <arrow/array/builder_primitive.h>
+#include <arrow/array/util.h>
+#include <arrow/record_batch.h>
 #include <TTree.h>
 #include <TBranch.h>
 #include <TFile.h>
@@ -35,7 +37,6 @@
 #include <cstdint>
 #include <memory>
 #include <stdexcept>
-#include <iostream>
 
 O2_DECLARE_DYNAMIC_LOG(root_arrow_fs);
 
@@ -729,8 +730,9 @@ arrow::Result<arrow::RecordBatchGenerator> TTreeFileFormat::ScanBatchesAsync(
       std::shared_ptr<arrow::Array> array;
 
       if (listType) {
-        auto varray = std::make_shared<arrow::PrimitiveArray>(datasetField->type()->field(0)->type(), valueOp.rootBranchEntries * valueOp.listSize, valueOp.targetBuffer);
-        array = std::make_shared<arrow::FixedSizeListArray>(datasetField->type(), valueOp.rootBranchEntries, varray);
+        auto vdata = std::make_shared<arrow::ArrayData>(datasetField->type()->field(0)->type(), valueOp.rootBranchEntries * valueOp.listSize,
+                                                        std::vector<std::shared_ptr<arrow::Buffer>>{nullptr, valueOp.targetBuffer});
+        array = std::make_shared<arrow::FixedSizeListArray>(datasetField->type(), valueOp.rootBranchEntries, arrow::MakeArray(vdata));
         // This is a vla, there is also an offset op
         O2_SIGNPOST_EVENT_EMIT(root_arrow_fs, tid, "Op", "Created op for branch %{public}s with %lli entries, size of the buffer %lli.",
                                valueOp.branch->GetName(),
@@ -738,9 +740,10 @@ arrow::Result<arrow::RecordBatchGenerator> TTreeFileFormat::ScanBatchesAsync(
                                valueOp.targetBuffer->size());
       } else if (mapping.vlaIdx != -1) {
         auto& offsetOp = ops[ops.size() - 2];
-        auto varray = std::make_shared<arrow::PrimitiveArray>(datasetField->type()->field(0)->type(), offsetOp.offsetCount, valueOp.targetBuffer);
+        auto vdata = std::make_shared<arrow::ArrayData>(datasetField->type()->field(0)->type(), offsetOp.offsetCount,
+                                                        std::vector<std::shared_ptr<arrow::Buffer>>{nullptr, valueOp.targetBuffer});
         // We have pushed an offset op if this was the case.
-        array = std::make_shared<arrow::ListArray>(datasetField->type(), offsetOp.rootBranchEntries, offsetOp.targetBuffer, varray);
+        array = std::make_shared<arrow::ListArray>(datasetField->type(), offsetOp.rootBranchEntries, offsetOp.targetBuffer, arrow::MakeArray(vdata));
         O2_SIGNPOST_EVENT_EMIT(root_arrow_fs, tid, "Op", "Created op for branch %{public}s with %lli entries, size of the buffer %lli.",
                                offsetOp.branch->GetName(), offsetOp.rootBranchEntries, offsetOp.targetBuffer->size());
         O2_SIGNPOST_EVENT_EMIT(root_arrow_fs, tid, "Op", "Created op for branch %{public}s with %lli entries, size of the buffer %lli.",
@@ -748,7 +751,9 @@ arrow::Result<arrow::RecordBatchGenerator> TTreeFileFormat::ScanBatchesAsync(
                                offsetOp.offsetCount,
                                valueOp.targetBuffer->size());
       } else {
-        array = std::make_shared<arrow::PrimitiveArray>(datasetField->type(), valueOp.rootBranchEntries, valueOp.targetBuffer);
+        auto data = std::make_shared<arrow::ArrayData>(datasetField->type(), valueOp.rootBranchEntries,
+                                                       std::vector<std::shared_ptr<arrow::Buffer>>{nullptr, valueOp.targetBuffer});
+        array = arrow::MakeArray(data);
         O2_SIGNPOST_EVENT_EMIT(root_arrow_fs, tid, "Op", "Created op for branch %{public}s with %lli entries, size of the buffer %lli.",
                                valueOp.branch->GetName(),
                                valueOp.rootBranchEntries,
diff --git a/Framework/Core/src/EmptyFragment.cxx b/Framework/Core/src/EmptyFragment.cxx
index 588f605fb429e..0d72a72a51891 100644
--- a/Framework/Core/src/EmptyFragment.cxx
+++ b/Framework/Core/src/EmptyFragment.cxx
@@ -9,9 +9,13 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 #include "Framework/EmptyFragment.h"
+#include <arrow/array/data.h>
 #include <arrow/type_fwd.h>
 #include <arrow/array/array_primitive.h>
 #include <arrow/array/array_nested.h>
+#include <arrow/record_batch.h>
+#include <arrow/type.h>
+#include <arrow/array/util.h>
 #include <memory>
 
 static constexpr int64_t kBufferMinimumSize = 256;
@@ -35,8 +39,8 @@ arrow::Result<arrow::RecordBatchGenerator> EmptyFragment::ScanBatchesAsync(
         } else {
           size *= field->type()->field(0)->type()->byte_width();
         }
-        auto varray = std::make_shared<arrow::PrimitiveArray>(field->type()->field(0)->type(), mRows * listType->list_size(), GetPlaceholderForOp(size));
-        columns.push_back(std::make_shared<arrow::FixedSizeListArray>(field->type(), (int32_t)mRows, varray));
+        auto vdata = std::make_shared<arrow::ArrayData>(field->type()->field(0)->type(), mRows * listType->list_size(), std::vector<std::shared_ptr<arrow::Buffer>>{nullptr, GetPlaceholderForOp(size)});
+        columns.push_back(std::make_shared<arrow::FixedSizeListArray>(field->type(), (int32_t)mRows, arrow::MakeArray(vdata)));
       } else {
         size_t size = mRows;
         if (field->type()->byte_width() == 0) {
@@ -44,7 +48,8 @@ arrow::Result<arrow::RecordBatchGenerator> EmptyFragment::ScanBatchesAsync(
         } else {
           size *= field->type()->byte_width();
         }
-        columns.push_back(std::make_shared<arrow::PrimitiveArray>(field->type(), mRows, GetPlaceholderForOp(size)));
+        auto data = std::make_shared<arrow::ArrayData>(field->type(), mRows, std::vector<std::shared_ptr<arrow::Buffer>>{nullptr, GetPlaceholderForOp(size)});
+        columns.push_back(arrow::MakeArray(data));
       }
     }
     return arrow::RecordBatch::Make(physical_schema_, mRows, columns);
diff --git a/Framework/Core/test/o2AO2DToAO3D.cxx b/Framework/Core/test/o2AO2DToAO3D.cxx
index 1f54a71fc3296..6475081640df6 100644
--- a/Framework/Core/test/o2AO2DToAO3D.cxx
+++ b/Framework/Core/test/o2AO2DToAO3D.cxx
@@ -18,6 +18,7 @@
 #include <TMap.h>
 #include <TTree.h>
 #include <fmt/format.h>
+#include <arrow/record_batch.h>
 
 int main(int argc, char** argv)
 {

From 6bb3383e2a2737948d83b4cb6b2609804b30e61e Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Fri, 30 May 2025 10:59:15 +0200
Subject: [PATCH 0431/1764] ALICE3-TRK: add GeometryTGeo methods to get volumes
 from the geometry (#14344)

---
 .../TRK/base/include/TRKBase/GeometryTGeo.h   | 109 +++-
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      | 602 +++++++++++++++++-
 .../src/TRKDigitizerSpec.cxx                  |   1 +
 3 files changed, 702 insertions(+), 10 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index 66326fe3c377d..852cb138e2be7 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -22,16 +22,98 @@ namespace trk
 class GeometryTGeo : public o2::detectors::DetMatrixCache
 {
  public:
+  using Mat3D = o2::math_utils::Transform3D;
+  using DetMatrixCache::getMatrixL2G;
+  using DetMatrixCache::getMatrixT2GRot;
+  using DetMatrixCache::getMatrixT2L;
+  // this method is not advised for ITS: for barrel detectors whose tracking frame is just a rotation
+  // it is cheaper to use T2GRot
+  using DetMatrixCache::getMatrixT2G;
   GeometryTGeo(bool build = false, int loadTrans = 0);
+  ~GeometryTGeo();
   void Build(int loadTrans);
   void fillMatrixCache(int mask);
-  static GeometryTGeo* Instance();
-
+  static GeometryTGeo* Instance()
+  {
+    if (!sInstance) {
+      sInstance = std::make_unique<GeometryTGeo>(true, 0);
+    }
+    return sInstance.get();
+  };
   static const char* getTRKVolPattern() { return sVolumeName.c_str(); }
   static const char* getTRKLayerPattern() { return sLayerName.c_str(); }
+  static const char* getTRKPetalPattern() { return sPetalName.c_str(); }
+  static const char* getTRKPetalDiskPattern() { return sPetalDiskName.c_str(); }
+  static const char* getTRKPetalLayerPattern() { return sPetalLayerName.c_str(); }
   static const char* getTRKStavePattern() { return sStaveName.c_str(); }
   static const char* getTRKChipPattern() { return sChipName.c_str(); }
   static const char* getTRKSensorPattern() { return sSensorName.c_str(); }
+  static const char* getTRKWrapVolPattern() { return sWrapperVolumeName.c_str(); }
+
+  int getNumberOfChips() const { return mSize; }
+
+  /// Determines the number of active parts in the Geometry
+  int extractNumberOfLayersMLOT();
+  int extractNumberOfLayersVD() const;
+  int extractNumberOfPetalsVD() const;
+  int extractNumberOfActivePartsVD() const;
+  int extractNumberOfDisksVD() const;
+  int extractNumberOfChipsPerPetalVD() const;
+  int extractNumberOfStavesMLOT(int lay) const;
+
+  /// Extract number following the prefix in the name string
+  int extractVolumeCopy(const char* name, const char* prefix) const;
+
+  int getNumberOfLayersMLOT() const { return mNumberOfLayersMLOT; }
+  int getNumberOffActivePartsVD() const { return mNumberOfActivePartsVD; }
+
+  bool isOwner() const { return mOwner; }
+  void setOwner(bool v) { mOwner = v; }
+
+  void Print(Option_t* opt = "") const;
+  void PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int indexRetrieved) const;
+
+  int getLayer(int index) const;
+  int getStave(int index) const;
+  int getSubDetID(int index) const;
+  int getPetalCase(int index) const;
+  int getDisk(int index) const;
+
+  /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave /// TODO: retrieve also from chip when chips will be available
+  /// in substave
+  /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
+  /// \param int petalcase The petal case number for VD, from 0 to 3
+  /// \param int disk The disk number for VD, from 0 to 5
+  /// \param int lay The layer number. Starting from 0 both for VD and MLOT
+  /// \param int stave The stave number for MLOT. Starting from 0
+  int getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave) const;
+
+  /// This routine computes subDetID, petal, disk, layer, stave given the chip index number /// TODO: copute also from chip when chips will be available
+  /// \param int index The chip index number, starting from 0
+  /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
+  /// \param int petalcase The petal case number for VD, from 0 to 3
+  /// \param int disk The disk number for VD, from 0 to 5
+  /// \param int lay The layer number. Starting from 0 both for VD and MLOT
+  /// \param int stave The stave number for MLOT. Starting from 0
+  bool getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave) const;
+
+  int getLastChipIndex(int lay) const { return mLastChipIndex[lay]; }
+  int getFirstChipIndex(int lay, int petalcase, int subDetID) const
+  {
+    /// Get the first chip index of the active petal (VD) or layer (MLOT)
+    if (subDetID == 0) { // VD
+      return (petalcase == 0) ? 0 : mLastChipIndexVD[petalcase - 1] + 1;
+    } else if (subDetID == 1) { // MLOT
+      return mLastChipIndex[lay + mNumberOfPetalsVD - 1] + 1;
+    }
+    return -1; // not found
+  }
+
+  /// Get the transformation matrix of the SENSOR (not necessary the same as the chip)
+  /// for a given chip 'index' by quering the TGeoManager
+  TGeoHMatrix* extractMatrixSensor(int index) const;
+
+  TString getMatrixPath(int index) const;
 
   static const char* composeSymNameTRK(int d)
   {
@@ -43,11 +125,34 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static const char* composeSymNameSensor(int d, int layer);
 
  protected:
+  static constexpr int MAXLAYERS = 20; ///< max number of active layers
+
   static std::string sVolumeName;
   static std::string sLayerName;
+  static std::string sPetalName;
+  static std::string sPetalDiskName;
+  static std::string sPetalLayerName;
   static std::string sStaveName;
   static std::string sChipName;
   static std::string sSensorName;
+  static std::string sWrapperVolumeName; ///< Wrapper volume name
+
+  Int_t mNumberOfLayersMLOT;                   ///< number of layers
+  Int_t mNumberOfActivePartsVD;                ///< number of layers
+  Int_t mNumberOfLayersVD;                     ///< number of layers
+  Int_t mNumberOfPetalsVD;                     ///< number of Petals = chip in each VD layer
+  Int_t mNumberOfDisksVD;                      ///< number of Disks = 6
+  std::vector<int> mLastChipIndex;             ///< max ID of the detctor in the petal(VD) or layer(MLOT)
+  std::vector<int> mLastChipIndexVD;           ///< max ID of the detctor in the layer for the VD
+  std::vector<int> mLastChipIndexMLOT;         ///< max ID of the detctor in the layer for the MLOT
+  std::vector<int> mNumberOfChipsPerLayerVD;   ///< number of chips per layer VD ( =  number of petals)
+  std::vector<int> mNumberOfChipsPerLayerMLOT; ///< number of chips per layer MLOT ( = 1 for the moment)
+  std::vector<int> mNumbersOfChipPerDiskVD;    ///< numbersOfChipPerDiskVD
+  std::vector<int> mNumberOfChipsPerPetalVD;   ///< numbersOfChipPerPetalVD
+  std::vector<int> mNumberOfStaves;            ///< Number Of Staves per layer in ML/OT
+  std::array<char, MAXLAYERS> mLayerToWrapper; ///< Layer to wrapper correspondence
+
+  bool mOwner = true; //! is it owned by the singleton?
 
  private:
   static std::unique_ptr<o2::trk::GeometryTGeo> sInstance;
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 525b40fe29c4f..4547225033498 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -11,6 +11,9 @@
 
 #include <TRKBase/GeometryTGeo.h>
 #include <TGeoManager.h>
+// #include "TRKBase/SegmentationChip.h"
+
+// using Segmentation = o2::trk::SegmentationChip;
 
 namespace o2
 {
@@ -20,46 +23,331 @@ std::unique_ptr<o2::trk::GeometryTGeo> GeometryTGeo::sInstance;
 
 // Names
 std::string GeometryTGeo::sVolumeName = "TRKV";
-std::string GeometryTGeo::sStaveName = "TRKStave";
 std::string GeometryTGeo::sLayerName = "TRKLayer";
+std::string GeometryTGeo::sPetalName = "PETALCASE";
+std::string GeometryTGeo::sPetalDiskName = "DISK";
+std::string GeometryTGeo::sPetalLayerName = "LAYER";
+std::string GeometryTGeo::sStaveName = "TRKStave";
 std::string GeometryTGeo::sChipName = "TRKChip";
 std::string GeometryTGeo::sSensorName = "TRKSensor";
+std::string GeometryTGeo::sWrapperVolumeName = "TRKUWrapVol"; ///< Wrapper volume name, not implemented at the moment
 
-GeometryTGeo::GeometryTGeo(bool build, int loadTrans) : DetMatrixCache()
+o2::trk::GeometryTGeo::~GeometryTGeo()
+{
+  if (!mOwner) {
+    mOwner = true;
+    sInstance.release();
+  }
+}
+GeometryTGeo::GeometryTGeo(bool build, int loadTrans) : DetMatrixCache(detectors::DetID::TRK)
 {
   if (sInstance) {
     LOGP(fatal, "Invalid use of public constructor: o2::trk::GeometryTGeo instance exists");
   }
+  mLayerToWrapper.fill(-1);
   if (build) {
     Build(loadTrans);
   }
 }
 
+//__________________________________________________________________________
 void GeometryTGeo::Build(int loadTrans)
 {
+  ///// current geometry organization:
+  ///// total elements = 258 = x staves * 8 layers ML+OT + 4 petal cases * (3 layers + 6 disks)
+  ///// indexing from 0 to 35: VD petals -> layers -> disks
+  ///// indexing from 36 to 257: MLOT staves
+
   if (isBuilt()) {
     LOGP(warning, "Already built");
     return; // already initialized
   }
 
-  if (!gGeoManager) {
+  if (gGeoManager == nullptr) {
     LOGP(fatal, "Geometry is not loaded");
   }
 
+  mNumberOfLayersMLOT = extractNumberOfLayersMLOT();
+  mNumberOfActivePartsVD = extractNumberOfActivePartsVD();
+  mNumberOfLayersVD = extractNumberOfLayersVD();
+  mNumberOfPetalsVD = extractNumberOfPetalsVD();
+  mNumberOfDisksVD = extractNumberOfDisksVD();
+
+  mNumberOfStaves.resize(mNumberOfLayersMLOT);
+  mLastChipIndex.resize(mNumberOfPetalsVD + mNumberOfLayersMLOT);
+  mLastChipIndexVD.resize(mNumberOfPetalsVD);
+  mLastChipIndexMLOT.resize(mNumberOfLayersMLOT); /// ML and OT are part of TRK as the same detector, without disks
+  mNumberOfChipsPerLayerVD.resize(mNumberOfLayersVD);
+  mNumberOfChipsPerLayerMLOT.resize(mNumberOfLayersMLOT);
+  mNumbersOfChipPerDiskVD.resize(mNumberOfDisksVD);
+  mNumberOfChipsPerPetalVD.resize(mNumberOfPetalsVD);
+
+  for (int i = 0; i < mNumberOfLayersMLOT; i++) {
+    std::cout << "Layer MLOT: " << i << std::endl;
+    mNumberOfStaves[i] = extractNumberOfStavesMLOT(i);
+  }
+
+  int numberOfChipsTotal = 0;
+
+  /// filling the information for the VD
+  for (int i = 0; i < mNumberOfPetalsVD; i++) {
+    mNumberOfChipsPerPetalVD[i] = extractNumberOfChipsPerPetalVD();
+    numberOfChipsTotal += mNumberOfChipsPerPetalVD[i];
+    mLastChipIndex[i] = numberOfChipsTotal - 1;
+    mLastChipIndexVD[i] = numberOfChipsTotal - 1;
+  }
+
+  /// filling the information for the MLOT
+  for (int i = 0; i < mNumberOfLayersMLOT; i++) {
+    mNumberOfChipsPerLayerMLOT[i] = extractNumberOfStavesMLOT(i); // for the moment, considering 1 stave = 1 chip. TODO: add the final segmentation in chips
+    numberOfChipsTotal += mNumberOfChipsPerLayerMLOT[i];
+    mLastChipIndex[i + mNumberOfPetalsVD] = numberOfChipsTotal - 1;
+    mLastChipIndexMLOT[i] = numberOfChipsTotal - 1;
+  }
+
+  // setSize(mNumberOfLayersMLOT + mNumberOfActivePartsVD); /// temporary, number of chips = number of layers and active parts
+  setSize(numberOfChipsTotal); /// temporary, number of chips = number of staves and active parts
   fillMatrixCache(loadTrans);
 }
 
-void GeometryTGeo::fillMatrixCache(int mask)
+//__________________________________________________________________________
+int GeometryTGeo::getSubDetID(int index) const
+{
+  if (index <= mLastChipIndexVD[mLastChipIndexVD.size() - 1]) {
+    return 0;
+  } else if (index > mLastChipIndexVD[mLastChipIndexVD.size() - 1]) {
+    return 1;
+  }
+  return -1; /// not found
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::getPetalCase(int index) const
 {
+  int petalcase = 0;
+
+  int subDetID = getSubDetID(index);
+  if (subDetID == 1) {
+    return -1;
+  }
+
+  else if (index <= mLastChipIndexVD[mNumberOfPetalsVD - 1]) {
+    while (index > mLastChipIndexVD[petalcase]) {
+      petalcase++;
+    }
+  }
+  return petalcase;
 }
 
-GeometryTGeo* GeometryTGeo::Instance()
+//__________________________________________________________________________
+int GeometryTGeo::getLayer(int index) const
 {
-  if (!sInstance) {
-    sInstance = std::unique_ptr<GeometryTGeo>(new GeometryTGeo(true, 0));
+  int subDetID = getSubDetID(index);
+  int petalcase = getPetalCase(index);
+  int lay = 0;
+
+  if (subDetID == 0) { /// VD
+    if (index % mNumberOfChipsPerPetalVD[petalcase] >= mNumberOfLayersVD) {
+      return -1; /// disks
+    }
+    return index % mNumberOfChipsPerPetalVD[petalcase];
+  } else if (subDetID == 1) { /// MLOT
+    while (index > mLastChipIndex[lay]) {
+      lay++;
+    }
+    return lay - mNumberOfPetalsVD; /// numeration of MLOT layesrs  starting from 1
   }
-  return sInstance.get();
+  return -1; /// -1 if not found
 }
+//__________________________________________________________________________
+int GeometryTGeo::getStave(int index) const
+{
+  int subDetID = getSubDetID(index);
+  int lay = getLayer(index);
+  int petalcase = getPetalCase(index);
+
+  if (subDetID == 0) { /// VD
+    return -1;
+  } else if (subDetID == 1) { /// MLOT
+    int lay = getLayer(index);
+    index -= getFirstChipIndex(lay, petalcase, subDetID);
+    return index; /// ||||
+  }
+  return -1; /// not found
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::getDisk(int index) const
+{
+  int subDetID = getSubDetID(index);
+  int petalcase = getPetalCase(index);
+
+  if (subDetID == 0) { /// VD
+    if (index % mNumberOfChipsPerPetalVD[petalcase] < mNumberOfLayersVD) {
+      return -1; /// layers
+    }
+    return (index % mNumberOfChipsPerPetalVD[petalcase]) - mNumberOfLayersVD;
+  }
+
+  return -1; /// not found or ML/OT
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave) const
+{
+  if (subDetID == 0) { // VD
+    if (lay == -1) {   // disk
+      return getFirstChipIndex(lay, petalcase, subDetID) + mNumberOfLayersVD + disk;
+    } else { // layer
+      return getFirstChipIndex(lay, petalcase, subDetID) + lay;
+    }
+  } else if (subDetID == 1) { // MLOT
+    return getFirstChipIndex(lay, petalcase, subDetID) + stave;
+  }
+  return -1; // not found
+}
+
+//__________________________________________________________________________
+bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave) const
+{
+  subDetID = getSubDetID(index);
+  petalcase = getPetalCase(index);
+  disk = getDisk(index);
+  lay = getLayer(index);
+  stave = getStave(index);
+
+  return kTRUE;
+}
+
+//__________________________________________________________________________
+TString GeometryTGeo::getMatrixPath(int index) const
+{
+
+  // int lay, hba, stav, sstav, mod, chipInMod;
+  int subDetID, petalcase, disk, lay, stave; //// TODO: add chips in a second step
+  getChipID(index, subDetID, petalcase, disk, lay, stave);
+
+  int indexRetrieved = getChipIndex(subDetID, petalcase, disk, lay, stave);
+
+  PrintChipID(index, subDetID, petalcase, disk, lay, stave, indexRetrieved);
+
+  // TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
+  TString path = "/cave_1/barrel_1/TRKV_2/TRKLayer0_1/TRKStave0_1/TRKChip0_1/TRKSensor0_1/"; /// dummy path, to be replaced
+
+  // if (wrID >= 0) {
+  //   path += Form("%s%d_1/", getITSWrapVolPattern(), wrID);
+  // }
+
+  // if (isVD) {
+  //   path += Form("%s%d_1/", getTRKPetalPattern(), index);
+
+  // } else {
+  // path += Form("%s%d_1/", getTRKLayerPattern(), index);
+  // }
+
+  // if (!mIsLayerITS3[lay]) {
+  //   path +=
+  //     Form("%s%d_1/", getITSLayerPattern(), lay);
+  //   if (mNumberOfHalfBarrels > 0) {
+  //     path += Form("%s%d_%d/", getITSHalfBarrelPattern(), lay, hba);
+  //   }
+  //   path +=
+  //     Form("%s%d_%d/", getITSStavePattern(), lay, stav);
+
+  //   if (mNumberOfHalfStaves[lay] > 0) {
+  //     path += Form("%s%d_%d/", getITSHalfStavePattern(), lay, sstav);
+  //   }
+  //   if (mNumberOfModules[lay] > 0) {
+  //     path += Form("%s%d_%d/", getITSModulePattern(), lay, mod);
+  //   }
+  //   path += Form("%s%d_%d/%s%d_1", getITSChipPattern(), lay, chipInMod, getITSSensorPattern(), lay);
+  // } else {
+  //   // hba = carbonform
+  //   // stav = 0
+  //   // sstav = segment
+  //   // mod = rsu
+  //   // chipInMod = tile
+  //   // sensor = pixelarray
+  //   path += Form("%s_0/", getITS3LayerPattern(lay));
+  //   path += Form("%s_%d/", getITS3CarbonFormPattern(lay), hba);
+  //   path += Form("%s_0/", getITS3ChipPattern(lay));
+  //   path += Form("%s_%d/", getITS3SegmentPattern(lay), sstav);
+  //   path += Form("%s_%d/", getITS3RSUPattern(lay), mod);
+  //   path += Form("%s_%d/", getITS3TilePattern(lay), chipInMod);
+  //   path += Form("%s_0", getITS3PixelArrayPattern(lay));
+  // }
+  return path;
+}
+
+//__________________________________________________________________________
+TGeoHMatrix* GeometryTGeo::extractMatrixSensor(int index) const
+{
+  // extract matrix transforming from the PHYSICAL sensor frame to global one
+  // Note, the if the effective sensitive layer thickness is smaller than the
+  // total physical sensor tickness, this matrix is biased and connot be used
+  // directly for transformation from sensor frame to global one.
+  //
+  // Therefore we need to add a shift
+  auto path = getMatrixPath(index);
+
+  static TGeoHMatrix matTmp;
+  gGeoManager->PushPath();
+
+  // if (!gGeoManager->cd(path.Data())) {
+  //   gGeoManager->PopPath();
+  //   LOG(error) << "Error in cd-ing to " << path.Data();
+  //   return nullptr;
+  // } // end if !gGeoManager
+
+  matTmp = *gGeoManager->GetCurrentMatrix(); // matrix may change after cd
+
+  // RSS
+  // printf("%d/%d/%d %s\n", lay, stav, detInSta, path.Data());
+  // matTmp.Print();
+  // Restore the modeler state.
+  gGeoManager->PopPath();
+
+  static int chipInGlo{0};
+
+  // account for the difference between physical sensitive layer (where charge collection is simulated) and effective sensor thicknesses
+  // in the ITS3 case this accounted by specialized functions
+  // double delta = Segmentation::SensorLayerThickness;
+  // static TGeoTranslation tra(0., 0.5 * delta, 0.);
+  // #ifdef ENABLE_UPGRADES // only apply for non ITS3 OB layers
+  //   if (!mIsLayerITS3[getLayer(index)]) {
+  //     matTmp *= tra;
+  //   }
+  // #else
+  //   matTmp *= tra;
+  // #endif
+
+  return &matTmp;
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::fillMatrixCache(int mask)
+{
+  if (mSize < 1) {
+    LOG(warning) << "The method Build was not called yet";
+    Build(mask);
+    return;
+  }
+
+  // build matrices
+  if ((mask & o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G)) && !getCacheL2G().isFilled()) {
+    // Matrices for Local (Sensor!!! rather than the full chip) to Global frame transformation
+    LOGP(info, "Loading {} L2G matrices from TGeo; there are {} matrices", getName(), mSize);
+    auto& cacheL2G = getCacheL2G();
+    cacheL2G.setSize(mSize);
+
+    for (int i = 0; i < mSize; i++) { /// here get the matrices for det ID between 0 and 257 (mSize = 258 at the moment)
+      TGeoHMatrix* hm = extractMatrixSensor(i);
+      cacheL2G.setMatrix(Mat3D(*hm), i);
+    }
+  }
+}
+
+//__________________________________________________________________________
 
 const char* GeometryTGeo::composeSymNameLayer(int d, int lr)
 {
@@ -81,5 +369,303 @@ const char* GeometryTGeo::composeSymNameSensor(int d, int lr)
   return Form("%s/%s%d", composeSymNameChip(d, lr), getTRKSensorPattern(), lr);
 }
 
+//__________________________________________________________________________
+int GeometryTGeo::extractVolumeCopy(const char* name, const char* prefix) const
+{
+  TString nms = name;
+  if (!nms.BeginsWith(prefix)) {
+    return -1;
+  }
+  nms.Remove(0, strlen(prefix));
+  if (!isdigit(nms.Data()[0])) {
+    return -1;
+  }
+  return nms.Atoi();
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfLayersMLOT()
+{
+  int numberOfLayers = 0;
+  TGeoVolume* trkV = gGeoManager->GetVolume(getTRKVolPattern());
+  if (trkV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  }
+
+  // Loop on all TRKV nodes, count Layer volumes by checking names
+  // Build on the fly layer - wrapper correspondence
+  TObjArray* nodes = trkV->GetNodes();
+  // nodes->Print();
+  int nNodes = nodes->GetEntriesFast();
+  for (int j = 0; j < nNodes; j++) {
+    int lrID = -1;
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+    const char* name = nd->GetName();
+    if (strstr(name, getTRKLayerPattern()) != nullptr) {
+      numberOfLayers++;
+      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKLayerPattern())) < 0) {
+        LOG(fatal) << "Failed to extract layer ID from the " << name;
+      }
+      mLayerToWrapper[lrID] = -1;                                 // not wrapped
+    } else if (strstr(name, getTRKWrapVolPattern()) != nullptr) { // this is a wrapper volume, may cointain layers
+      int wrID = -1;
+      if ((wrID = extractVolumeCopy(name, GeometryTGeo::getTRKWrapVolPattern())) < 0) {
+        LOG(fatal) << "Failed to extract wrapper ID from the " << name;
+      }
+      TObjArray* nodesW = nd->GetNodes();
+      int nNodesW = nodesW->GetEntriesFast();
+
+      for (int jw = 0; jw < nNodesW; jw++) {
+        auto ndW = dynamic_cast<TGeoNode*>(nodesW->At(jw))->GetName();
+        if (strstr(ndW, getTRKLayerPattern()) != nullptr) {
+          if ((lrID = extractVolumeCopy(ndW, GeometryTGeo::getTRKLayerPattern())) < 0) {
+            LOGP(fatal, "Failed to extract layer ID from wrapper volume '{}' from one of its nodes '{}'", name, ndW);
+          }
+          numberOfLayers++;
+          mLayerToWrapper[lrID] = wrID;
+        }
+      }
+    }
+  }
+  return numberOfLayers;
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfActivePartsVD() const
+{
+  // The number of active parts returned here is 36 = 4 petals * (3 layers + 6 disks)
+  int numberOfParts = 0;
+
+  TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
+  if (vdV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  }
+  LOG(info) << "Volume name: " << getTRKVolPattern();
+
+  // Loop on all TRKV nodes, count Layer volumes by checking names
+  TObjArray* nodes = vdV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+  for (int j = 0; j < nNodes; j++) {
+    int lrID = -1;
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+    const char* name = nd->GetName();
+
+    if (strstr(name, getTRKPetalPattern()) != nullptr && (strstr(name, getTRKPetalLayerPattern()) != nullptr || strstr(name, getTRKPetalDiskPattern()) != nullptr)) {
+      numberOfParts++;
+      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
+        LOG(fatal) << "Failed to extract layer ID from the " << name;
+      }
+    }
+  }
+  return numberOfParts;
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfDisksVD() const
+{
+  // The number of disks returned here is 6
+  int numberOfDisks = 0;
+
+  TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
+  if (vdV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  }
+  LOG(info) << "Volume name: " << getTRKVolPattern();
+
+  // Loop on all TRKV nodes, count Layer volumes by checking names
+  TObjArray* nodes = vdV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+  for (int j = 0; j < nNodes; j++) {
+    int lrID = -1;
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+    const char* name = nd->GetName();
+
+    if (strstr(name, Form("%s%s", getTRKPetalPattern(), "0")) != nullptr && (strstr(name, getTRKPetalDiskPattern()) != nullptr)) {
+      numberOfDisks++;
+      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
+        LOG(fatal) << "Failed to extract layer ID from the " << name;
+      }
+    }
+  }
+  return numberOfDisks;
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfPetalsVD() const
+{
+  // The number of petals returned here is 4 = number of petals
+  int numberOfChips = 0;
+
+  TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
+  if (vdV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  }
+  LOG(info) << "Volume name: " << getTRKVolPattern();
+
+  // Loop on all TRKV nodes, count Layer volumes by checking names
+  TObjArray* nodes = vdV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+  for (int j = 0; j < nNodes; j++) {
+    int lrID = -1;
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+    const char* name = nd->GetName();
+
+    if (strstr(name, getTRKPetalPattern()) != nullptr && (strstr(name, Form("%s%s", getTRKPetalLayerPattern(), "0")) != nullptr)) {
+      numberOfChips++;
+      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
+        LOG(fatal) << "Failed to extract layer ID from the " << name;
+      }
+    }
+  }
+  return numberOfChips;
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfLayersVD() const
+{
+  // The number of layers returned here is 3
+  int numberOfLayers = 0;
+
+  TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
+  if (vdV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  }
+  LOG(info) << "Volume name: " << getTRKVolPattern();
+
+  // Loop on all TRKV nodes, count Layer volumes by checking names
+  TObjArray* nodes = vdV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+  for (int j = 0; j < nNodes; j++) {
+    int lrID = -1;
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+    const char* name = nd->GetName();
+
+    if (strstr(name, Form("%s%s", getTRKPetalPattern(), "0")) != nullptr && strstr(name, getTRKPetalLayerPattern()) != nullptr) {
+      numberOfLayers++;
+      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
+        LOG(fatal) << "Failed to extract layer ID from the " << name;
+      }
+    }
+  }
+  return numberOfLayers;
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfChipsPerPetalVD() const
+{
+  // The number of chips per petal returned here is 9 for each layer = number of layers + number of quarters of disks per petal
+  int numberOfChips = 0;
+
+  TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
+  if (vdV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  }
+  LOG(info) << "Volume name: " << getTRKVolPattern();
+
+  // Loop on all TRKV nodes, count Layer volumes by checking names
+  TObjArray* nodes = vdV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+  for (int j = 0; j < nNodes; j++) {
+    int lrID = -1;
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+    const char* name = nd->GetName();
+
+    if (strstr(name, Form("%s%s", getTRKPetalPattern(), "0")) != nullptr && (strstr(name, getTRKPetalLayerPattern()) != nullptr || strstr(name, getTRKPetalDiskPattern()) != nullptr)) {
+      numberOfChips++;
+      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
+        LOG(fatal) << "Failed to extract layer ID from the " << name;
+      }
+    }
+  }
+  return numberOfChips;
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfStavesMLOT(int lay) const
+{
+  int numberOfStaves = 0;
+
+  std::string layName = Form("%s%d", getTRKLayerPattern(), lay);
+  TGeoVolume* layV = gGeoManager->GetVolume(layName.c_str());
+
+  if (layV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKLayerPattern() << " is not in the geometry";
+  }
+
+  // Loop on all layV nodes, count Layer volumes by checking names
+  TObjArray* nodes = layV->GetNodes();
+  // std::cout << "Printing nodes for layer " << lay << std::endl;
+  // nodes->Print();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j = 0; j < nNodes; j++) {
+    int lrID = -1;
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j)); /// layer node
+    const char* name = nd->GetName();
+    if (strstr(name, getTRKStavePattern()) != nullptr) {
+      numberOfStaves++;
+    }
+  }
+  return numberOfStaves;
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int indexRetrieved) const
+{
+  std::cout << "\nindex = " << index << std::endl;
+  std::cout << "subDetID = " << subDetID << std::endl;
+  std::cout << "petalcase = " << petalcase << std::endl;
+  std::cout << "layer = " << lay << std::endl;
+  std::cout << "disk = " << disk << std::endl;
+  std::cout << "first chip index = " << getFirstChipIndex(lay, petalcase, subDetID) << std::endl;
+  std::cout << "stave = " << stave << std::endl;
+  std::cout << "chck index Retrieved = " << indexRetrieved << std::endl;
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::Print(Option_t*) const
+{
+  if (!isBuilt()) {
+    LOGF(info, "Geometry not built yet!");
+    return;
+  }
+  std::cout << "Detector ID: " << sInstance.get()->getDetID() << std::endl;
+
+  LOGF(info, "Summary of GeometryTGeo: %s", getName());
+  LOGF(info, "Number of layers ML + OL: %d", mNumberOfLayersMLOT);
+  LOGF(info, "Number of active parts VD: %d", mNumberOfActivePartsVD);
+  LOGF(info, "Number of layers VD: %d", mNumberOfLayersVD);
+  LOGF(info, "Number of petals VD: %d", mNumberOfPetalsVD);
+  LOGF(info, "Number of disks VD: %d", mNumberOfDisksVD);
+  LOGF(info, "Number of chips per petal VD: ");
+  for (int i = 0; i < mNumberOfPetalsVD; i++) {
+    LOGF(info, "%d", mNumberOfChipsPerPetalVD[i]);
+  }
+  LOGF(info, "Number of staves per layer MLOT: ");
+  for (int i = 0; i < mNumberOfLayersMLOT; i++) {
+    std::string mlot = "";
+    mlot = (i < 5) ? "ML" : "OT";
+    LOGF(info, "Layer: %d, %s, %d staves", i, mlot.c_str(), mNumberOfStaves[i]);
+  }
+  LOGF(info, "Total number of chips: %d", getNumberOfChips());
+
+  std::cout << "mLastChipIndex = [";
+  for (int i = 0; i < mLastChipIndex.size(); i++) {
+    std::cout << mLastChipIndex[i];
+    if (i < mLastChipIndex.size() - 1) {
+      std::cout << ", ";
+    }
+  }
+  std::cout << "]" << std::endl;
+  std::cout << "mLastChipIndexVD = [";
+  for (int i = 0; i < mLastChipIndexVD.size(); i++) {
+    std::cout << mLastChipIndexVD[i];
+    if (i < mLastChipIndexVD.size() - 1) {
+      std::cout << ", ";
+    }
+  }
+  std::cout << "]" << std::endl;
+}
+
 } // namespace trk
 } // namespace o2
\ No newline at end of file
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
index f35b53a58fae4..cb375936744d5 100644
--- a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
@@ -207,6 +207,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       // configure digitizer
       o2::trk::GeometryTGeo* geom = o2::trk::GeometryTGeo::Instance();
       geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G)); // make sure L2G matrices are loaded
+      geom->Print();
       mDigitizer.setGeometry(geom);
 
       const auto& dopt = o2::trk::DPLDigitizerParam<o2::detectors::DetID::TRK>::Instance();

From 7335adce0b9f1b4dbb069a2ef8dac4225ac6ee32 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 30 May 2025 13:34:40 +0200
Subject: [PATCH 0432/1764] DPL: more fixes to handle the ROOT v6-36-00
 (#14341)

- More tweaks to get ROOT::Experimental out of the way
- RNTuples cannot have / as first character in name
---
 Framework/AnalysisSupport/src/Plugin.cxx      |  7 ++---
 .../AnalysisSupport/src/RNTuplePlugin.cxx     | 27 ++++++++++---------
 Framework/Core/src/Plugin.cxx                 | 21 ++++++++++++---
 Framework/Core/test/test_Root2ArrowTable.cxx  | 10 ++++++-
 4 files changed, 45 insertions(+), 20 deletions(-)

diff --git a/Framework/AnalysisSupport/src/Plugin.cxx b/Framework/AnalysisSupport/src/Plugin.cxx
index 00a4cc6565494..e39e76f01dbdd 100644
--- a/Framework/AnalysisSupport/src/Plugin.cxx
+++ b/Framework/AnalysisSupport/src/Plugin.cxx
@@ -121,10 +121,11 @@ std::vector<std::string> getListOfTables(std::unique_ptr<TFile>& f)
       break;
     }
 
+#if __has_include(<ROOT/RFieldBase.hxx>)
     void* v = f->GetObjectChecked(key->GetName(), TClass::GetClass("ROOT::RNTuple"));
-    if (!v) {
-      v = f->GetObjectChecked(key->GetName(), TClass::GetClass("ROOT::Experimental::RNTuple"));
-    }
+#else
+    void* v = f->GetObjectChecked(key->GetName(), TClass::GetClass("ROOT::Experimental::RNTuple"));
+#endif
     if (v) {
       std::string s = key->GetName();
       size_t pos = s.find('-');
diff --git a/Framework/AnalysisSupport/src/RNTuplePlugin.cxx b/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
index 71719d712b6d3..cd34f464dee51 100644
--- a/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
+++ b/Framework/AnalysisSupport/src/RNTuplePlugin.cxx
@@ -45,7 +45,6 @@ using DPLFieldToken = rns::REntry::RFieldToken;
 using DPLLocalIndex = rns::RClusterIndex;
 #endif
 
-
 template class
   std::unique_ptr<rns::RNTupleReader>;
 
@@ -188,15 +187,17 @@ class RNTupleFileFormat : public arrow::dataset::FileFormat
 };
 
 template <typename T>
-requires requires (T&& f) { f.GetSubFields(); }
-auto getSubfields(T const&field) {
-    return field.GetSubFields();
+  requires requires(T&& f) { f.GetSubFields(); }
+auto getSubfields(T const& field)
+{
+  return field.GetSubFields();
 }
 
 template <typename T>
-requires requires (T&& f) { f.GetConstSubfields(); }
-auto getSubfields(T const&field) {
-    return field.GetConstSubfields();
+  requires requires(T&& f) { f.GetConstSubfields(); }
+auto getSubfields(T const& field)
+{
+  return field.GetConstSubfields();
 }
 
 struct RootNTupleVisitor : public rns::Detail::RFieldVisitor {
@@ -284,7 +285,6 @@ struct RootNTupleVisitor : public rns::Detail::RFieldVisitor {
   }
 #endif
 
-
   void VisitBoolField(const rns::RField<bool>& field) override
   {
     this->datatype = arrow::boolean();
@@ -562,18 +562,19 @@ class RNTupleFileWriter : public arrow::dataset::FileWriter
 };
 
 template <typename T>
-requires requires (T const&m) { m.GetFieldZero(); }
-auto &getFieldZero(T const &m) {
+  requires requires(T const& m) { m.GetFieldZero(); }
+auto& getFieldZero(T const& m)
+{
   return m.GetFieldZero();
 }
 
 template <typename T>
-requires requires (T const&m) { m.GetConstFieldZero(); }
-auto &getFieldZero(T const &m) {
+  requires requires(T const& m) { m.GetConstFieldZero(); }
+auto& getFieldZero(T const& m)
+{
   return m.GetConstFieldZero();
 }
 
-
 arrow::Result<std::shared_ptr<arrow::Schema>> RNTupleFileFormat::Inspect(const arrow::dataset::FileSource& source) const
 {
 
diff --git a/Framework/Core/src/Plugin.cxx b/Framework/Core/src/Plugin.cxx
index 13b67e2a781ba..8ed683d501906 100644
--- a/Framework/Core/src/Plugin.cxx
+++ b/Framework/Core/src/Plugin.cxx
@@ -222,21 +222,36 @@ struct RNTupleObjectReadingCapability : o2::framework::RootObjectReadingCapabili
   {
     auto context = new ImplementationContext;
 
-    return new RootObjectReadingCapability{
+    return new RootObjectReadingCapability
+    {
       .name = "rntuple",
-      .lfn2objectPath = [](std::string s) {
+      .lfn2objectPath = [](std::string s) -> std::string {
          std::replace(s.begin()+1, s.end(), '/', '-');
+#if __has_include(<ROOT/RFieldBase.hxx>)
+         if (s.starts_with("/")) {
+          return std::string(s.begin() + 1, s.end());
+        } else {
+          return s;
+        } },
+#else
          if (s.starts_with("/")) {
           return s;
         } else {
           return "/" + s;
         } },
+#endif
+#if __has_include(<ROOT/RFieldBase.hxx>)
+      .getHandle = getHandleByClass("ROOT::RNTuple"),
+      .checkSupport = matchClassByName("ROOT::RNTuple"),
+#else
       .getHandle = getHandleByClass("ROOT::Experimental::RNTuple"),
       .checkSupport = matchClassByName("ROOT::Experimental::RNTuple"),
+#endif
       .factory = [context]() -> RootArrowFactory& {
         lazyLoadFactory(context->implementations, "O2FrameworkAnalysisRNTupleSupport:RNTupleObjectReadingImplementation");
         return context->implementations.back();
-      }};
+      }
+    };
   }
 };
 
diff --git a/Framework/Core/test/test_Root2ArrowTable.cxx b/Framework/Core/test/test_Root2ArrowTable.cxx
index 395048ae916d6..dacb54eb5ecdf 100644
--- a/Framework/Core/test/test_Root2ArrowTable.cxx
+++ b/Framework/Core/test/test_Root2ArrowTable.cxx
@@ -73,7 +73,7 @@ TEST_CASE("RootTree2Fragment")
   /// A directory holding a tree
 
   /// Create a simple TTree
-  TBufferFile* file = new TBufferFile(TBuffer::kWrite);
+  auto* file = new TBufferFile(TBuffer::kWrite);
 
   TTree t1("t1", "a simple Tree with simple variables");
   Float_t xyz[3];
@@ -519,7 +519,11 @@ TEST_CASE("RootTree2Dataset")
     validateContents(batch);
   }
 
+#if __has_include(<ROOT/RFieldBase.hxx>)
+  arrow::fs::FileLocator rnTupleLocator{outFs, "rntuple"};
+#else
   arrow::fs::FileLocator rnTupleLocator{outFs, "/rntuple"};
+#endif
   // We write an RNTuple in the same TMemFile, using /rntuple as a location
   auto rntupleDestination = std::dynamic_pointer_cast<TDirectoryFileOutputStream>(*destination);
 
@@ -530,7 +534,11 @@ TEST_CASE("RootTree2Dataset")
   }
 
   // And now we can read back the RNTuple into a RecordBatch
+#if __has_include(<ROOT/RFieldBase.hxx>)
+  arrow::dataset::FileSource writtenRntupleSource("rntuple", outFs);
+#else
   arrow::dataset::FileSource writtenRntupleSource("/rntuple", outFs);
+#endif
 
   REQUIRE(rNtupleFormat->IsSupported(writtenRntupleSource) == true);
 

From ddffd12a8caf4dc302f6c7dac39d955305f5893a Mon Sep 17 00:00:00 2001
From: Costin Grigoras <costing@gmail.com>
Date: Fri, 30 May 2025 11:03:34 +0200
Subject: [PATCH 0433/1764] Increase minimum read timeout to 5s in CcdbApi.cxx

Increase the minimum read timeout from 1 to 5s as this case is also used when reading from the production CCDB instance and 1s can be too little at times (especially at large RTTs). And there are no alternatives to use.
---
 CCDB/src/CcdbApi.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index fa42d62cc3633..bb2b69e84c4f7 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -232,7 +232,7 @@ void CcdbApi::init(std::string const& host)
                deploymentMode == o2::framework::DeploymentMode::FST) {
       mCurlTimeoutDownload = 15;
     } else if (deploymentMode == o2::framework::DeploymentMode::Local) {
-      mCurlTimeoutDownload = 1;
+      mCurlTimeoutDownload = 5;
     }
   }
 

From fc57e97b106cc31593d70b86ef259eb9048b9ae4 Mon Sep 17 00:00:00 2001
From: Fabrizio <fabrizio.grosa@cern.ch>
Date: Fri, 30 May 2025 14:57:46 +0200
Subject: [PATCH 0434/1764] Add Ds and Xic resonances not present in the PDG
 (#14325)

* Add Ds and Xi resonances not present in the PDG

* Revert changes in nuclei

* Apply naming conventions
---
 .../CommonConstants/PhysicsConstants.h        | 14 ++++++
 .../CommonConstants/make_pdg_header.py        |  7 +++
 .../SimulationDataFormat/O2DatabasePDG.h      | 43 +++++++++++++++++--
 3 files changed, 61 insertions(+), 3 deletions(-)

diff --git a/Common/Constants/include/CommonConstants/PhysicsConstants.h b/Common/Constants/include/CommonConstants/PhysicsConstants.h
index 5f169f799eb5b..71f978aa3d1f6 100644
--- a/Common/Constants/include/CommonConstants/PhysicsConstants.h
+++ b/Common/Constants/include/CommonConstants/PhysicsConstants.h
@@ -51,7 +51,10 @@ enum Pdg {
   kDSBar = -431,
   kDSStar = 433,
   kDS1 = 10433,
+  kDS1Star2700 = 30433,
+  kDS1Star2860 = 40433,
   kDS2Star = 435,
+  kDS3Star2860 = 437,
   kDStar = 413,
   kDStar0 = 423,
   kChiC1 = 20443,
@@ -72,6 +75,10 @@ enum Pdg {
   kXiCCPlusPlus = 4422,
   kXiCPlus = 4232,
   kXiC0 = 4132,
+  kXiC3055Plus = 4325,
+  kXiC3080Plus = 4326,
+  kXiC3055_0 = 4315,
+  kXiC3080_0 = 4316,
   kDeuteron = 1000010020,
   kTriton = 1000010030,
   kHelium3 = 1000020030,
@@ -104,7 +111,10 @@ constexpr double MassDS = 1.96835;
 constexpr double MassDSBar = 1.96835;
 constexpr double MassDSStar = 2.1122;
 constexpr double MassDS1 = 2.53511;
+constexpr double MassDS1Star2700 = 2.714;
+constexpr double MassDS1Star2860 = 2.859;
 constexpr double MassDS2Star = 2.5691;
+constexpr double MassDS3Star2860 = 2.86;
 constexpr double MassDStar = 2.01026;
 constexpr double MassDStar0 = 2.00685;
 constexpr double MassChiC1 = 3.51067;
@@ -125,6 +135,10 @@ constexpr double MassXiB0 = 5.7919;
 constexpr double MassXiCCPlusPlus = 3.62155;
 constexpr double MassXiCPlus = 2.46771;
 constexpr double MassXiC0 = 2.47044;
+constexpr double MassXiC3055Plus = 3.0559;
+constexpr double MassXiC3080Plus = 3.0772;
+constexpr double MassXiC3055_0 = 3.059;
+constexpr double MassXiC3080_0 = 3.0799;
 constexpr double MassDeuteron = 1.87561294257;
 constexpr double MassTriton = 2.80892113298;
 constexpr double MassHelium3 = 2.80839160743;
diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index 4fdfd052ff613..9f8e7ca6ec6da 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -106,7 +106,10 @@ class Pdg(Enum):
     kDSBar = -431
     kDSStar = 433
     kDS1 = 10433
+    kDS1Star2700 = 30433
+    kDS1Star2860 = 40433
     kDS2Star = 435
+    kDS3Star2860 = 437
     kDStar = 413
     kDStar0 = 423
     kChiC1 = 20443
@@ -127,6 +130,10 @@ class Pdg(Enum):
     kXiCCPlusPlus = 4422
     kXiCPlus = 4232
     kXiC0 = 4132
+    kXiC3055Plus = 4325
+    kXiC3080Plus = 4326
+    kXiC3055_0 = 4315
+    kXiC3080_0 = 4316
     kDeuteron = 1000010020
     kTriton = 1000010030
     kHelium3 = 1000020030
diff --git a/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h b/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
index 0ee5c06a74411..ec8e6db889167 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
@@ -640,10 +640,47 @@ inline void O2DatabasePDG::addALICEParticles(TDatabasePDG* db)
     db->AddParticle("Anti-Theta_c_3100", "Anti-Theta_c_3100", 3.099, kFALSE,
                     83.e-6, 0, "Resonance", ionCode); // same width as D*+ (83 keV)
   }
-  if (!db->GetParticle(-ionCode)) {
-    db->AddParticle("Theta_c_3100", "Theta_c_3100", 3.099, kFALSE,
-                    83.e-6, 0, "Resonance", -ionCode); // same width as D*+ (83 keV)
+  db->AddAntiParticle("Theta_c_3100", -ionCode);
+
+  // Charm resonances not present in PYTHIA (consistent with https://github.com/AliceO2Group/O2DPG/blob/master/MC/config/PWGHF/pythia8/generator/pythia8_charmhadronic_with_decays_DResoTrigger.cfg)
+  // Mesons
+  ionCode = 30433;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("D*_s1_Plus_2700", "D*_s1_Plus_2700", 2.714, false, 0.122, 3, "Resonance", ionCode);
+  }
+  db->AddAntiParticle("D*_s1_Minus_2700", -ionCode);
+  ionCode = 40433;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("D*_s1_Plus_2860", "D*_s1_Plus_2860", 2.859, false, 0.160, 3, "Resonance", ionCode);
+  }
+  db->AddAntiParticle("D*_s1_Minus_2860", -ionCode);
+  ionCode = 437;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("D*_s3_Plus_2860", "D*_s3_Plus_2860", 2.860, false, 0.053, 3, "Resonance", ionCode);
+  }
+  db->AddAntiParticle("D*_s3_Minus_2860", -ionCode);
+
+  // Baryons
+  ionCode = 4325;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("Xi_c_Plus_3055", "Xi_c_Plus_3055", 3.0559, false, 0.0078, 3, "Resonance", ionCode);
+  }
+  db->AddAntiParticle("Xi_c_Minus_3055", -ionCode);
+  ionCode = 4326;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("Xi_c_Plus_3080", "Xi_c_Plus_3080", 3.0772, false, 0.0036, 3, "Resonance", ionCode);
+  }
+  db->AddAntiParticle("Xi_c_Minus_3080", -ionCode);
+  ionCode = 4315;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("Xi_c_0_3055", "Xi_c_0_3055", 3.0590, false, 0.0064, 0, "Resonance", ionCode);
+  }
+  db->AddAntiParticle("Anti-Xi_c_0_3055", -ionCode);
+  ionCode = 4316;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("Xi_c_0_3080", "Xi_c_0_3080", 3.0799, false, 0.0056, 0, "Resonance", ionCode);
   }
+  db->AddAntiParticle("Anti-Xi_c_0_3080", -ionCode);
 
   // d*(2380) - dibaryon resonance
 

From a81a238fd09891c5ba901ac10f8a4f48d2021313 Mon Sep 17 00:00:00 2001
From: GiorgioAlbertoLucia <giogioalberto@gmail.com>
Date: Sun, 4 May 2025 16:18:32 +0200
Subject: [PATCH 0435/1764] Added Lithium4 - followed standard procedure

---
 .../include/CommonConstants/PhysicsConstants.h         | 10 ++++++----
 .../include/CommonConstants/make_pdg_header.py         |  1 +
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/Common/Constants/include/CommonConstants/PhysicsConstants.h b/Common/Constants/include/CommonConstants/PhysicsConstants.h
index 71f978aa3d1f6..da34230662ef6 100644
--- a/Common/Constants/include/CommonConstants/PhysicsConstants.h
+++ b/Common/Constants/include/CommonConstants/PhysicsConstants.h
@@ -83,6 +83,7 @@ enum Pdg {
   kTriton = 1000010030,
   kHelium3 = 1000020030,
   kAlpha = 1000020040,
+  kLithium4 = 1000030040,
   kHyperTriton = 1010010030,
   kHyperHydrogen4 = 1010010040,
   kHyperHelium4 = 1010020040,
@@ -143,10 +144,11 @@ constexpr double MassDeuteron = 1.87561294257;
 constexpr double MassTriton = 2.80892113298;
 constexpr double MassHelium3 = 2.80839160743;
 constexpr double MassAlpha = 3.7273794066;
-constexpr double MassHyperTriton = 2.99131;
-constexpr double MassHyperHydrogen4 = 3.9226;
-constexpr double MassHyperHelium4 = 3.9217;
-constexpr double MassHyperHelium5 = 4.841;
+constexpr double MassLithium4 = 3.7513;
+constexpr double MassHyperTriton = 2.991134;
+constexpr double MassHyperHydrogen4 = 3.922434;
+constexpr double MassHyperHelium4 = 3.921728;
+constexpr double MassHyperHelium5 = 4.839961;
 constexpr double MassHyperHelium4Sigma = 3.995;
 
 /// \brief Declarations of masses for particles in ROOT PDG_t
diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index 9f8e7ca6ec6da..b94cc34599d5e 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -138,6 +138,7 @@ class Pdg(Enum):
     kTriton = 1000010030
     kHelium3 = 1000020030
     kAlpha = 1000020040
+    kLithium4 = 1000030040
     kHyperTriton = 1010010030
     kHyperHydrogen4 = 1010010040
     kHyperHelium4 = 1010020040

From 13b695d140715db3473ec308e559ec0684576fd3 Mon Sep 17 00:00:00 2001
From: Marvin Hemmer <53471402+mhemmer-cern@users.noreply.github.com>
Date: Fri, 30 May 2025 16:27:11 +0200
Subject: [PATCH 0436/1764] [EMCAL-688] ClusterFactory: remove std::optional
 (#14314)

- std::optional creates copies, potentially slowing down the code and increase memory usage. Instead we just use a gsl::span here and check if it is empty or not.
---
 Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h b/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
index 3ce7003fe9814..a7e81d38838a3 100644
--- a/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
+++ b/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
@@ -12,7 +12,6 @@
 #define ALICEO2_EMCAL_CLUSTERFACTORY_H_
 #include <array>
 #include <vector>
-#include <optional>
 #include <utility>
 #include <gsl/span>
 #include "Rtypes.h"
@@ -336,7 +335,7 @@ class ClusterFactory
   bool getUseWeightExotic() const { return mUseWeightExotic; }
   void setUseWeightExotic(float useWeightExotic) { mUseWeightExotic = useWeightExotic; }
 
-  void setContainer(gsl::span<const o2::emcal::Cluster> clusterContainer, gsl::span<const InputType> cellContainer, gsl::span<const int> indicesContainer, std::optional<gsl::span<const o2::emcal::CellLabel>> cellLabelContainer = std::nullopt)
+  void setContainer(gsl::span<const o2::emcal::Cluster> clusterContainer, gsl::span<const InputType> cellContainer, gsl::span<const int> indicesContainer, gsl::span<const o2::emcal::CellLabel> cellLabelContainer = {})
   {
     mClustersContainer = clusterContainer;
     mInputsContainer = cellContainer;
@@ -344,8 +343,8 @@ class ClusterFactory
     if (!getLookUpInit()) {
       setLookUpTable();
     }
-    if (cellLabelContainer) {
-      mCellLabelContainer = cellLabelContainer.value();
+    if (!cellLabelContainer.empty()) {
+      mCellLabelContainer = cellLabelContainer;
     }
   }
 

From 60ed0d281a2240f714fea4cc139d1cdc655f7e2e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 29 May 2025 02:01:09 +0200
Subject: [PATCH 0437/1764] CTF: add shuffle TF option for debug

---
 .../include/CTFWorkflow/CTFReaderSpec.h       |  1 +
 Detectors/CTF/workflow/src/CTFReaderSpec.cxx  | 43 ++++++++++++++++---
 .../CTF/workflow/src/ctf-reader-workflow.cxx  |  2 +
 3 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h b/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
index b202013a6eea1..e753a8fbd767d 100644
--- a/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
+++ b/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
@@ -47,6 +47,7 @@ struct CTFReaderInp {
   unsigned int decSSpecEMC = 0;
   int tfRateLimit = -999;
   size_t minSHM = 0;
+  bool shuffle{false};
 };
 
 /// create a processor spec
diff --git a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
index aadc059ecd4fa..666a44b558030 100644
--- a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
+++ b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
@@ -11,9 +11,14 @@
 
 /// @file   CTFReaderSpec.cxx
 
+#include <random>
 #include <vector>
+#include <algorithm>
+#include <numeric>
+
 #include <TFile.h>
 #include <TTree.h>
+#include <TStopwatch.h>
 
 #include "Framework/Logger.h"
 #include "Framework/ControlService.h"
@@ -49,7 +54,6 @@
 #include "CCDB/BasicCCDBManager.h"
 #include "CommonConstants/LHCConstants.h"
 #include "Algorithm/RangeTokenizer.h"
-#include <TStopwatch.h>
 #include <fairmq/Device.h>
 
 using namespace o2::framework;
@@ -299,6 +303,27 @@ void CTFReaderSpec::openCTFFile(const std::string& flname)
     if (mCTFTree->GetEntries() < 1) {
       throw std::runtime_error(fmt::format("CTF tree in {} has 0 entries, skipping", flname));
     }
+    if (mInput.shuffle) {
+      if (mInput.ctfIDs.empty()) {
+        int entries = mCTFTree->GetEntries();
+        if (mInput.maxTFs > 0) {
+          entries = std::min(entries, mInput.maxTFs);
+        }
+        if (mInput.maxTFsPerFile > 0) {
+          entries = std::min(entries, mInput.maxTFsPerFile);
+        }
+        mInput.ctfIDs.clear();
+        mInput.ctfIDs.resize(entries);
+        std::iota(mInput.ctfIDs.begin(), mInput.ctfIDs.end(), 0);
+      }
+      std::random_device dev;
+      std::mt19937 gen{dev()};
+      std::shuffle(mInput.ctfIDs.begin(), mInput.ctfIDs.end(), gen);
+      LOGP(info, "will shuffle reading of CTF entries in this order:");
+      for (int i{0}; i < (int)mInput.ctfIDs.size(); ++i) {
+        LOGP(info, "\tTF {:02} -> {:02}", i, mInput.ctfIDs[i]);
+      }
+    }
   } catch (const std::exception& e) {
     LOG(error) << "Cannot process " << flname << ", reason: " << e.what();
     mCTFTree.reset();
@@ -322,9 +347,12 @@ void CTFReaderSpec::run(ProcessingContext& pc)
   long startWait = 0;
 
   while (mRunning) {
-    if (mCTFTree) { // there is a tree open with multiple CTF
-      if (mInput.ctfIDs.empty() || mInput.ctfIDs[mSelIDEntry] == mCTFCounter) { // no selection requested or matching CTF ID is found
+    if (mCTFTree) {                                                                               // there is a tree open with multiple CTF
+      if (mInput.ctfIDs.empty() || mInput.ctfIDs[mSelIDEntry] == mCTFCounter || mInput.shuffle) { // no selection requested or matching CTF ID is found
         LOG(debug) << "TF " << mCTFCounter << " of " << mInput.maxTFs << " loop " << mFileFetcher->getNLoops();
+        if (mInput.shuffle) {
+          mCurrTreeEntry = mInput.ctfIDs[mSelIDEntry];
+        }
         mSelIDEntry++;
         if (processTF(pc)) {
           break;
@@ -500,8 +528,13 @@ bool CTFReaderSpec::processTF(ProcessingContext& pc)
 ///_______________________________________
 void CTFReaderSpec::checkTreeEntries()
 {
-  // check if the tree has entries left, if needed, close current tree/file
-  if (++mCurrTreeEntry >= mCTFTree->GetEntries() || (mInput.maxTFsPerFile > 0 && mCurrTreeEntry >= mInput.maxTFsPerFile)) { // this file is done, check if there are other files
+  bool reachedEnd{false};
+  if (mInput.shuffle) { // last entry is last id
+    reachedEnd = (mCurrTreeEntry == mInput.ctfIDs.back());
+  } else { // check if the tree has entries left, if needed, close current tree/file
+    reachedEnd = (++mCurrTreeEntry >= mCTFTree->GetEntries());
+  }
+  if (reachedEnd || (mInput.maxTFsPerFile > 0 && mCurrTreeEntry >= mInput.maxTFsPerFile)) { // this file is done, check if there are other files
     mCTFTree.reset();
     mCTFFile->Close();
     mCTFFile.reset();
diff --git a/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx b/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
index 1f0ef9a3b871b..cddf694251a01 100644
--- a/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
+++ b/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
@@ -56,6 +56,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   options.push_back(ConfigParamSpec{"skipDet", VariantType::String, std::string{DetID::NONE}, {"comma-separate list of detectors to skip"}});
   options.push_back(ConfigParamSpec{"loop", VariantType::Int, 0, {"loop N times (infinite for N<0)"}});
   options.push_back(ConfigParamSpec{"delay", VariantType::Float, 0.f, {"delay in seconds between consecutive TFs sending"}});
+  options.push_back(ConfigParamSpec{"shuffle", VariantType::Bool, false, {"shuffle TF sending order (for debug)"}});
   options.push_back(ConfigParamSpec{"copy-cmd", VariantType::String, "alien_cp ?src file://?dst", {"copy command for remote files or no-copy to avoid copying"}}); // Use "XrdSecPROTOCOL=sss,unix xrdcp -N root://eosaliceo2.cern.ch/?src ?dst" for direct EOS access
   options.push_back(ConfigParamSpec{"ctf-file-regex", VariantType::String, ".*o2_ctf_run.+\\.root$", {"regex string to identify CTF files"}});
   options.push_back(ConfigParamSpec{"remote-regex", VariantType::String, "^(alien://|)/alice/data/.+", {"regex string to identify remote files"}}); // Use "^/eos/aliceo2/.+" for direct EOS access
@@ -120,6 +121,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   ctfInput.maxFileCache = std::max(1, configcontext.options().get<int>("max-cached-files"));
 
+  ctfInput.shuffle = configcontext.options().get<bool>("shuffle");
   ctfInput.copyCmd = configcontext.options().get<std::string>("copy-cmd");
   ctfInput.tffileRegex = configcontext.options().get<std::string>("ctf-file-regex");
   ctfInput.remoteRegex = configcontext.options().get<std::string>("remote-regex");

From 1dc08772feb402900d5e310009547940a30d8dfc Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 30 May 2025 21:13:34 +0200
Subject: [PATCH 0438/1764] CTF: add reverse opt for injected IDs

---
 .../CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h |  1 +
 Detectors/CTF/workflow/src/CTFReaderSpec.cxx         | 12 ++++++++----
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h b/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
index e753a8fbd767d..ab03649c0646b 100644
--- a/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
+++ b/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
@@ -33,6 +33,7 @@ struct CTFReaderInp {
   std::string fileIRFrames{};
   std::string fileRunTimeSpans{};
   std::vector<int> ctfIDs{};
+  bool reverseCTFIDs{false};
   bool skipSkimmedOutTF = false;
   bool invertIRFramesSelection = false;
   bool allowMissingDetectors = false;
diff --git a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
index 666a44b558030..e502b88611a3c 100644
--- a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
+++ b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
@@ -159,6 +159,9 @@ void CTFReaderSpec::stopReader()
 void CTFReaderSpec::init(InitContext& ic)
 {
   mInput.ctfIDs = o2::RangeTokenizer::tokenize<int>(ic.options().get<std::string>("select-ctf-ids"));
+  if ((mInput.reverseCTFIDs = ic.options().get<bool>("reverse-select-ctf-ids"))) {
+    std::reverse(mInput.ctfIDs.begin(), mInput.ctfIDs.end());
+  }
   mUseLocalTFCounter = ic.options().get<bool>("local-tf-counter");
   mImposeRunStartMS = ic.options().get<int64_t>("impose-run-start-timstamp");
   mInput.checkTFLimitBeforeReading = ic.options().get<bool>("limit-tf-before-reading");
@@ -347,10 +350,10 @@ void CTFReaderSpec::run(ProcessingContext& pc)
   long startWait = 0;
 
   while (mRunning) {
-    if (mCTFTree) {                                                                               // there is a tree open with multiple CTF
-      if (mInput.ctfIDs.empty() || mInput.ctfIDs[mSelIDEntry] == mCTFCounter || mInput.shuffle) { // no selection requested or matching CTF ID is found
+    if (mCTFTree) {                                                                                                       // there is a tree open with multiple CTF
+      if (mInput.ctfIDs.empty() || mInput.ctfIDs[mSelIDEntry] == mCTFCounter || mInput.shuffle || mInput.reverseCTFIDs) { // no selection requested or matching CTF ID is found
         LOG(debug) << "TF " << mCTFCounter << " of " << mInput.maxTFs << " loop " << mFileFetcher->getNLoops();
-        if (mInput.shuffle) {
+        if (mInput.shuffle || mInput.reverseCTFIDs) {
           mCurrTreeEntry = mInput.ctfIDs[mSelIDEntry];
         }
         mSelIDEntry++;
@@ -529,7 +532,7 @@ bool CTFReaderSpec::processTF(ProcessingContext& pc)
 void CTFReaderSpec::checkTreeEntries()
 {
   bool reachedEnd{false};
-  if (mInput.shuffle) { // last entry is last id
+  if (mInput.shuffle || mInput.reverseCTFIDs) { // last entry is last id
     reachedEnd = (mCurrTreeEntry == mInput.ctfIDs.back());
   } else { // check if the tree has entries left, if needed, close current tree/file
     reachedEnd = (++mCurrTreeEntry >= mCTFTree->GetEntries());
@@ -644,6 +647,7 @@ DataProcessorSpec getCTFReaderSpec(const CTFReaderInp& inp)
   }
 
   options.emplace_back(ConfigParamSpec{"select-ctf-ids", VariantType::String, "", {"comma-separated list CTF IDs to inject (from cumulative counter of CTFs seen)"}});
+  options.emplace_back(ConfigParamSpec{"reverse-select-ctf-ids", VariantType::Bool, false, {"reverse order of to inject CTF IDs"}});
   options.emplace_back(ConfigParamSpec{"impose-run-start-timstamp", VariantType::Int64, 0L, {"impose run start time stamp (ms), ignored if 0"}});
   options.emplace_back(ConfigParamSpec{"local-tf-counter", VariantType::Bool, false, {"reassign header.tfCounter from local TF counter"}});
   options.emplace_back(ConfigParamSpec{"fetch-failure-threshold", VariantType::Float, 0.f, {"Fail if too many failures( >0: fraction, <0: abs number, 0: no threshold)"}});

From 43994b3e9748daaafc3c8d9be2ae441c35baad6b Mon Sep 17 00:00:00 2001
From: Felix Schlepper <f3sch.git@outlook.com>
Date: Sun, 1 Jun 2025 12:32:56 +0200
Subject: [PATCH 0439/1764] GPU: CommonMath add remainderf

---
 GPU/Common/GPUCommonMath.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index 6d97250e7f2f4..350ef173467d5 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -96,6 +96,7 @@ class GPUCommonMath
   GPUd() constexpr static uint32_t Float2UIntRn(float x) { return (uint32_t)(int32_t)(x + 0.5f); }
   GPUd() constexpr static int32_t Float2IntRn(float x);
   GPUd() constexpr static float Modf(float x, float y);
+  GPUhdi() static float Remainderf(float x, float y);
   GPUd() constexpr static bool Finite(float x);
   GPUd() constexpr static bool IsNaN(float x);
   GPUd() constexpr static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
@@ -236,6 +237,7 @@ GPUdi() float2 GPUCommonMath::MakeFloat2(float x, float y)
 }
 
 GPUdi() constexpr float GPUCommonMath::Modf(float x, float y) { return GPUCA_CHOICE(fmodf(x, y), fmodf(x, y), fmod(x, y)); }
+GPUhdi() float GPUCommonMath::Remainderf(float x, float y) { return GPUCA_CHOICE(std::remainderf(x, y), remainderf(x, y), remainder(x, y)); }
 
 GPUdi() uint32_t GPUCommonMath::Float2UIntReint(const float& x)
 {

From 396cbe42e29c05d49d7c408f454c5373e0a018d6 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Wed, 28 May 2025 18:30:19 +0200
Subject: [PATCH 0440/1764] o2-sim: Harden sigkill

---
 run/o2sim_parallel.cxx | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/run/o2sim_parallel.cxx b/run/o2sim_parallel.cxx
index 24be9743e6a03..3e28428938b20 100644
--- a/run/o2sim_parallel.cxx
+++ b/run/o2sim_parallel.cxx
@@ -352,7 +352,9 @@ void launchShutdownThread()
     }
     LOG(info) << "Shutdown timer expired ... force killing remaining children";
     for (auto p : gChildProcesses) {
-      killpg(p, SIGKILL);
+      if (p != 0 && killpg(p, 0) == 0) { // see if process still exists
+        killpg(p, SIGKILL);
+      }
     }
   };
   threads.push_back(std::thread(lambda));
@@ -440,6 +442,12 @@ int main(int argc, char* argv[])
   // we enable the forked version of the code by default
   setenv("ALICE_SIMFORKINTERNAL", "ON", 1);
 
+  // force execution as own process group
+  if (setpgid(0, 0) == -1) {
+    perror("setpgid");
+    exit(1);
+  }
+
   TStopwatch timer;
   timer.Start();
   auto o2env = getenv("O2_ROOT");
@@ -703,7 +711,9 @@ int main(int argc, char* argv[])
           if (!shutdown_initiated) {
             shutdown_initiated = true;
             for (auto p : gChildProcesses) {
-              killpg(p, SIGTERM);
+              if (killpg(p, 0) == 0) {
+                killpg(p, SIGTERM);
+              }
             }
           }
         } else {
@@ -733,7 +743,9 @@ int main(int argc, char* argv[])
         LOG(info) << "Problem detected (or child received termination signal) ... shutting down whole system ";
         for (auto p : gChildProcesses) {
           LOG(info) << "TERMINATING " << p;
-          killpg(p, SIGTERM); // <--- makes sure to shutdown "unknown" child pids via the group property
+          if (killpg(p, 0) == 0) {
+            killpg(p, SIGTERM); // <--- makes sure to shutdown "unknown" child pids via the group property
+          }
         }
         LOG(error) << "SHUTTING DOWN DUE TO SIGNALED EXIT IN COMPONENT " << cpid;
         o2::simpubsub::publishMessage(externalpublishchannel, o2::simpubsub::simStatusString("O2SIM", "STATE", "FAILURE"));
@@ -751,7 +763,9 @@ int main(int argc, char* argv[])
     for (auto p : gChildProcesses) {
       if (p != mergerpid) {
         LOG(info) << "SHUTTING DOWN CHILD PROCESS (normal thread)" << p;
-        killpg(p, SIGTERM);
+        if (killpg(p, 0) == 0) {
+          killpg(p, SIGTERM);
+        }
       }
     }
   }

From 5817ed11babc13143f33def2ef509cee201892bd Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <weiglhofer@fias.uni-frankfurt.de>
Date: Mon, 2 Jun 2025 15:30:37 +0200
Subject: [PATCH 0441/1764] GPU: Fix standalone compilation with ITS code.

---
 GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
index 87829f5634375..f4ef3b464c24f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
@@ -42,13 +42,13 @@ class VertexerTraitsGPU : public VertexerTraits
 {
 };
 template <int32_t NLayers = 7>
-class TrackerTraitsGPU : public TrackerTraits
+class TrackerTraitsGPU : public TrackerTraits<NLayers>
 {
 };
 namespace gpu
 {
 template <int32_t NLayers = 7>
-class TimeFrameGPU : public TimeFrame
+class TimeFrameGPU : public TimeFrame<NLayers>
 {
 };
 } // namespace gpu

From b0d3802fecb202d34cf0e71c47a0b7ef0264a6d4 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 3 Jun 2025 15:55:57 +0200
Subject: [PATCH 0442/1764] Add IWYU export statements to avoid proliferation
 of headers (#14354)

---
 Framework/Core/include/Framework/ASoA.h | 34 ++++++++++++-------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 4ed8e830fe137..592864528244c 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -12,27 +12,27 @@
 #ifndef O2_FRAMEWORK_ASOA_H_
 #define O2_FRAMEWORK_ASOA_H_
 
-#include "Framework/Pack.h"
-#include "Framework/FunctionalHelpers.h"
-#include "Headers/DataHeader.h"
-#include "Headers/DataHeaderHelpers.h"
-#include "Framework/CompilerBuiltins.h"
-#include "Framework/Traits.h"
-#include "Framework/Expressions.h"
-#include "Framework/ArrowTypes.h"
-#include "Framework/ArrowTableSlicingCache.h"
-#include "Framework/SliceCache.h"
-#include "Framework/VariantHelpers.h"
-#include <arrow/table.h>
-#include <arrow/array.h>
-#include <arrow/util/config.h>
-#include <gandiva/selection_vector.h>
-#include <array>
+#include "Framework/Pack.h"                   // IWYU pragma: export
+#include "Framework/FunctionalHelpers.h"      // IWYU pragma: export
+#include "Headers/DataHeader.h"               // IWYU pragma: export
+#include "Headers/DataHeaderHelpers.h"        // IWYU pragma: export
+#include "Framework/CompilerBuiltins.h"       // IWYU pragma: export
+#include "Framework/Traits.h"                 // IWYU pragma: export
+#include "Framework/Expressions.h"            // IWYU pragma: export
+#include "Framework/ArrowTypes.h"             // IWYU pragma: export
+#include "Framework/ArrowTableSlicingCache.h" // IWYU pragma: export
+#include "Framework/SliceCache.h"             // IWYU pragma: export
+#include "Framework/VariantHelpers.h"         // IWYU pragma: export
+#include <arrow/table.h>                      // IWYU pragma: export
+#include <arrow/array.h>                      // IWYU pragma: export
+#include <arrow/util/config.h>                // IWYU pragma: export
+#include <gandiva/selection_vector.h>         // IWYU pragma: export
+#include <array>                              // IWYU pragma: export
 #include <cassert>
 #include <fmt/format.h>
 #include <concepts>
 #include <cstring>
-#include <gsl/span>
+#include <gsl/span> // IWYU pragma: export
 #include <limits>
 
 namespace o2::framework

From bf081c920aa9d270f744063aa147d57ec331e78f Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 3 Jun 2025 18:28:05 +0200
Subject: [PATCH 0443/1764] ITS3: fix topologydict generation + load APTS
 (#14330)

* ITS3: fix loading APTS repsonse function

* ITS3: fix topologydict generation

* ITS3: add braces and some reordering in ChipDigitsContainer
---
 .../ITSMFTSimulation/AlpideSimResponse.h      |  4 ++--
 .../ITS3/macros/test/CreateDictionariesITS3.C |  9 ++++----
 .../src/BuildTopologyDictionary.cxx           |  8 +++----
 .../ITS3Simulation/ChipDigitsContainer.h      | 22 +++++++++----------
 .../include/ITS3Simulation/ChipSimResponse.h  |  1 +
 .../include/ITS3Simulation/Digitizer.h        |  2 ++
 .../simulation/src/ChipDigitsContainer.cxx    | 18 +++++++--------
 .../ITS3/simulation/src/Digitizer.cxx         | 16 ++++++++++++--
 8 files changed, 46 insertions(+), 34 deletions(-)

diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
index 5714b51d5aa45..d79d2f33c6062 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/AlpideSimResponse.h
@@ -114,7 +114,7 @@ class AlpideSimResponse
 
  public:
   AlpideSimResponse() = default;
-  ~AlpideSimResponse() = default;
+  virtual ~AlpideSimResponse() = default;
 
   void initData(int tableNumber, std::string dataPath, const bool quiet = true);
 
@@ -145,7 +145,7 @@ class AlpideSimResponse
   const std::string& getColRowDataFmt() const { return mColRowDataFmt; }
   void print() const;
 
-  ClassDefNV(AlpideSimResponse, 2);
+  ClassDef(AlpideSimResponse, 2);
 };
 
 //-----------------------------------------------------
diff --git a/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C b/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
index 76d7bf09de77f..459e3c59d1e82 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
@@ -280,15 +280,16 @@ void CreateDictionariesITS3(bool saveDeltas = true,
                   mMosaixSegmentations[layer].curvedToFlat(locC.X(), locC.Y(), xFlat, yFlat);
                   locC.SetCoordinates(xFlat, yFlat, locC.Z());
                 }
+
+                auto pitchX = (ib) ? o2::its3::SegmentationMosaix::PitchRow : o2::itsmft::SegmentationAlpide::PitchRow;
+                auto pitchZ = (ib) ? o2::its3::SegmentationMosaix::PitchCol : o2::itsmft::SegmentationAlpide::PitchCol;
                 dX = xyzLocM.X() - locC.X();
                 dZ = xyzLocM.Z() - locC.Z();
-                dX /= (ib) ? o2::its3::SegmentationMosaix::PitchRow : o2::itsmft::SegmentationAlpide::PitchRow;
-                dZ /= (ib) ? o2::its3::SegmentationMosaix::PitchCol : o2::itsmft::SegmentationAlpide::PitchCol;
 
                 float outLimitDx{-1}, outLimitDz{-1};
                 if (checkOutliers > 0.) {
-                  outLimitDx = topology.getRowSpan() * checkOutliers;
-                  outLimitDz = topology.getColumnSpan() * checkOutliers;
+                  outLimitDx = topology.getRowSpan() * checkOutliers * pitchX;
+                  outLimitDz = topology.getColumnSpan() * checkOutliers * pitchZ;
                   bool isOutDx = std::abs(dX) > outLimitDx;
                   bool isOutDz = std::abs(dZ) > outLimitDz;
                   if (isOutDx || isOutDz) { // ignore outlier
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/BuildTopologyDictionary.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/BuildTopologyDictionary.cxx
index f7eec52f9434a..b7d1cda0d0c69 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/BuildTopologyDictionary.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/BuildTopologyDictionary.cxx
@@ -40,8 +40,6 @@ void BuildTopologyDictionary::accountTopologyImpl(const itsmft::ClusterTopology&
   ++tot;
   bool useDf = dX < IgnoreVal / 2; // we may need to account the frequency but to not update the centroid
 
-  // std::pair<unordered_map<unsigned long, itsmft::TopoStat>::iterator,bool> ret;
-  // auto ret = mTopologyMap.insert(std::make_pair(cluster.getHash(), std::make_pair(cluster, 1)));
   auto& topoStat = tstat[cluster.getHash()];
   topoStat.countsTotal++;
   if (topoStat.countsTotal == 1) { // a new topology is inserted
@@ -59,7 +57,7 @@ void BuildTopologyDictionary::accountTopologyImpl(const itsmft::ClusterTopology&
       topoStat.countsWithBias = 1;
     } else { // assign expected sigmas from the pixel X, Z sizes
       topInf.mXsigma2 = sigmaX * sigmaX / 12.f / (float)std::min(10, topInf.mSizeX);
-      topInf.mZsigma2 = sigmaZ * sigmaZ / (float)std::min(10, topInf.mSizeZ);
+      topInf.mZsigma2 = sigmaZ * sigmaZ / 12.f / (float)std::min(10, topInf.mSizeZ);
     }
     tinfo.emplace(cluster.getHash(), topInf);
   } else {
@@ -128,7 +126,7 @@ void BuildTopologyDictionary::setThresholdImpl(double thr, TopoFreq& tfreq, Topo
 {
   setNCommonImpl(0, tfreq, tstat, ncommon, ntot);
   freqthres = thr;
-  for (auto& q : tfreq) {
+  for (const auto& q : tfreq) {
     if (((double)q.first) / ntot > thr) {
       ++ncommon;
     } else {
@@ -205,7 +203,7 @@ void BuildTopologyDictionary::groupRareTopologiesImpl(TopoFreq& tfreq, TopoInfo&
     gr.mHash = tfreq[j].second;
     gr.mFrequency = ((double)(tfreq[j].first)) / ntot;
     totFreq += gr.mFrequency;
-    // rough estimation for the error considering a8 uniform distribution
+    // rough estimation for the error considering a uniform distribution
     const auto& topo = tinfo.find(gr.mHash)->second;
     gr.mErrX = std::sqrt(topo.mXsigma2);
     gr.mErrZ = std::sqrt(topo.mZsigma2);
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h
index 0c9627fe412c3..2caa381b3c385 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipDigitsContainer.h
@@ -12,11 +12,11 @@
 #ifndef ALICEO2_ITS3_CHIPDIGITSCONTAINER_
 #define ALICEO2_ITS3_CHIPDIGITSCONTAINER_
 
-#include "ITSMFTBase/SegmentationAlpide.h"        // Base class in o2::itsmft namespace
-#include "ITSMFTSimulation/ChipDigitsContainer.h" // Base class in o2::itsmft namespace
-#include "ITS3Base/SegmentationMosaix.h"          // OB segmentation implementation
-#include "ITS3Base/SpecsV2.h"                     // Provides SpecsV2::isDetITS3() interface
-#include "ITS3Simulation/DigiParams.h"            // ITS3-specific DigiParams interface
+#include "ITSMFTBase/SegmentationAlpide.h"
+#include "ITSMFTSimulation/ChipDigitsContainer.h"
+#include "ITS3Base/SegmentationMosaix.h"
+#include "ITS3Base/SpecsV2.h"
+#include "ITS3Simulation/DigiParams.h"
 #include <TRandom.h>
 
 namespace o2::its3
@@ -24,11 +24,6 @@ namespace o2::its3
 
 class ChipDigitsContainer : public o2::itsmft::ChipDigitsContainer
 {
- private:
-  bool innerBarrel; ///< true if the chip belongs to the inner barrel (IB), false if outer barrel (OB)
-  int maxRows;      ///< maximum number of rows
-  int maxCols;      ///< maximum number of columns
-
  public:
   explicit ChipDigitsContainer(UShort_t idx = 0);
 
@@ -51,9 +46,14 @@ class ChipDigitsContainer : public o2::itsmft::ChipDigitsContainer
   void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::itsmft::DigiParams* params, int maxRows = o2::itsmft::SegmentationAlpide::NRows, int maxCols = o2::itsmft::SegmentationAlpide::NCols) = delete;
   void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::its3::DigiParams* params);
 
+ private:
+  bool innerBarrel{false}; ///< true if the chip belongs to the inner barrel (IB), false if outer barrel (OB)
+  int maxRows{-1};         ///< maximum number of rows
+  int maxCols{-1};         ///< maximum number of columns
+
   ClassDefNV(ChipDigitsContainer, 1);
 };
 
 } // namespace o2::its3
 
-#endif // ALICEO2_ITS3_CHIPDIGITSCONTAINER_
\ No newline at end of file
+#endif // ALICEO2_ITS3_CHIPDIGITSCONTAINER_
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipSimResponse.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipSimResponse.h
index f96fde9fb0d55..6bcaf8bc35557 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipSimResponse.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ChipSimResponse.h
@@ -24,6 +24,7 @@ class ChipSimResponse : public o2::itsmft::AlpideSimResponse
  public:
   ChipSimResponse() = default;
   ChipSimResponse(const ChipSimResponse& other) = default;
+  ChipSimResponse(const o2::itsmft::AlpideSimResponse* base) : o2::itsmft::AlpideSimResponse(*base) {}
 
   float getRespCentreDep() const { return mRespCentreDep; }
   void computeCentreFromData();
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
index edc5583c03d5a..a2dd1102091da 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
@@ -42,6 +42,8 @@ class Digitizer : public TObject
   using ExtraDig = std::vector<itsmft::PreDigitLabelRef>; ///< container for extra contributions to PreDigits
 
  public:
+  ~Digitizer();
+
   void setDigits(std::vector<o2::itsmft::Digit>* dig) { mDigits = dig; }
   void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
   void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx b/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
index 0611f7002f160..102b15863683e 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
@@ -11,10 +11,7 @@
 
 #include "ITS3Simulation/ChipDigitsContainer.h"
 
-namespace o2
-{
-namespace its3
-{
+using namespace o2::its3;
 
 ChipDigitsContainer::ChipDigitsContainer(UShort_t idx)
   : o2::itsmft::ChipDigitsContainer(idx) {}
@@ -48,16 +45,17 @@ void ChipDigitsContainer::addNoise(UInt_t rofMin, UInt_t rofMax, const o2::its3:
     for (Int_t i = 0; i < nhits; ++i) {
       row = gRandom->Integer(maxRows);
       col = gRandom->Integer(maxCols);
-      if (mNoiseMap && mNoiseMap->isNoisy(mChipIndex, row, col))
+      if (mNoiseMap && mNoiseMap->isNoisy(mChipIndex, row, col)) {
         continue;
-      if (mDeadChanMap && mDeadChanMap->isNoisy(mChipIndex, row, col))
+      }
+      if (mDeadChanMap && mDeadChanMap->isNoisy(mChipIndex, row, col)) {
         continue;
+      }
       auto key = getOrderingKey(rof, row, col);
-      if (!findDigit(key))
+      if (!findDigit(key)) {
         addDigit(key, rof, row, col, nel, o2::MCCompLabel(true));
+      }
     }
   }
 }
-
-} // namespace its3
-} // namespace o2
\ No newline at end of file
+// namespace its3
diff --git a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
index 1d1d15a91f89b..b91e17890a6d8 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
@@ -12,6 +12,7 @@
 /// \file Digitizer.cxx
 /// \brief Implementation of the ITS3 digitizer
 
+#include "ITS3Simulation/ChipSimResponse.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "ITS3Simulation/Digitizer.h"
 #include "ITS3Base/ITS3Params.h"
@@ -34,6 +35,11 @@ using o2::itsmft::PreDigit;
 
 using namespace o2::its3;
 
+Digitizer::~Digitizer()
+{
+  delete mSimRespIB;
+}
+
 void Digitizer::init()
 {
   const int numOfChips = mGeometry->getNumberOfChips();
@@ -57,8 +63,14 @@ void Digitizer::init()
       if (!fOB || fOB->IsZombie() || !fOB->IsOpen()) {
         LOGP(fatal, "Cannot open file {}", fileOB);
       }
-      mParams.setIBSimResponse(mSimRespIB = fIB->Get<o2::its3::ChipSimResponse>(nameIB));
-      mParams.setOBSimResponse(mSimRespOB = fOB->Get<o2::itsmft::AlpideSimResponse>(nameOB));
+      if ((mSimRespIB = new o2::its3::ChipSimResponse(fIB->Get<o2::itsmft::AlpideSimResponse>(nameIB))) == nullptr) {
+        LOGP(fatal, "Cannot create response function for IB");
+      }
+      if ((mSimRespOB = fOB->Get<o2::itsmft::AlpideSimResponse>(nameOB)) == nullptr) {
+        LOGP(fatal, "Cannot create response function for OB");
+      }
+      mParams.setIBSimResponse(mSimRespIB);
+      mParams.setOBSimResponse(mSimRespOB);
       fIB->Close();
       fOB->Close();
     };

From bec22ff904ec66212f092bc6bfa6f1a65f27d385 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sawenzel@gmail.com>
Date: Tue, 3 Jun 2025 22:56:02 +0200
Subject: [PATCH 0444/1764] AOD: Introduce CreatedBy MetaData field (#14351)

* AOD: Introduce CreatedBy MetaData field

Allows to know who created this AOD, which in turn might
be used to lookup further MetaData from CCDB or just to know
whom to contact.
---
 .../include/AODProducerWorkflow/AODProducerWorkflowSpec.h   | 1 +
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx               | 6 ++++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index b89acaa41066f..1e3a4cf970d3b 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -271,6 +271,7 @@ class AODProducerWorkflowDPL : public Task
   TString mAnchorPass{""};
   TString mAnchorProd{""};
   TString mRecoPass{""};
+  TString mUser{"aliprod"}; // who created this AOD (aliprod, alidaq, individual users)
   TStopwatch mTimer;
   bool mEMCselectLeading{false};
   uint64_t mEMCALTrgClassMask = 0;
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 8fb2db9c3c9a6..105c0f60532d3 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -1675,6 +1675,7 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
   mLPMProdTag = ic.options().get<string>("lpmp-prod-tag");
   mAnchorPass = ic.options().get<string>("anchor-pass");
   mAnchorProd = ic.options().get<string>("anchor-prod");
+  mUser = ic.options().get<string>("created-by");
   mRecoPass = ic.options().get<string>("reco-pass");
   mTFNumber = ic.options().get<int64_t>("aod-timeframe-id");
   mRecoOnly = ic.options().get<int>("reco-mctracks-only");
@@ -2398,8 +2399,8 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
   TString dataType = mUseMC ? "MC" : "RAW";
   TString O2Version = o2::fullVersion();
   TString ROOTVersion = ROOT_RELEASE;
-  mMetaDataKeys = {"DataType", "Run", "O2Version", "ROOTVersion", "RecoPassName", "AnchorProduction", "AnchorPassName", "LPMProductionTag"};
-  mMetaDataVals = {dataType, "3", O2Version, ROOTVersion, mRecoPass, mAnchorProd, mAnchorPass, mLPMProdTag};
+  mMetaDataKeys = {"DataType", "Run", "O2Version", "ROOTVersion", "RecoPassName", "AnchorProduction", "AnchorPassName", "LPMProductionTag", "CreatedBy"};
+  mMetaDataVals = {dataType, "3", O2Version, ROOTVersion, mRecoPass, mAnchorProd, mAnchorPass, mLPMProdTag, mUser};
   pc.outputs().snapshot(Output{"AMD", "AODMetadataKeys", 0}, mMetaDataKeys);
   pc.outputs().snapshot(Output{"AMD", "AODMetadataVals", 0}, mMetaDataVals);
 
@@ -3256,6 +3257,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"anchor-pass", VariantType::String, "", {"AnchorPassName"}},
       ConfigParamSpec{"anchor-prod", VariantType::String, "", {"AnchorProduction"}},
       ConfigParamSpec{"reco-pass", VariantType::String, "", {"RecoPassName"}},
+      ConfigParamSpec{"created-by", VariantType::String, "", {"Who created this AO2D"}},
       ConfigParamSpec{"nthreads", VariantType::Int, std::max(1, int(std::thread::hardware_concurrency() / 2)), {"Number of threads"}},
       ConfigParamSpec{"reco-mctracks-only", VariantType::Int, 0, {"Store only reconstructed MC tracks and their mothers/daughters. 0 -- off, != 0 -- on"}},
       ConfigParamSpec{"ctpreadout-create", VariantType::Int, 0, {"Create CTP digits from detector readout and CTP inputs. !=1 -- off, 1 -- on"}},

From d121ffe0671046c829389073167adff3d9a60eb5 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 3 Jun 2025 23:19:01 +0200
Subject: [PATCH 0445/1764] Avoid having an explicit policy for the
 BuilderHolder (#14353)

Shortens the symbol name. We can still override the policy via template specialization.
---
 .../Core/include/Framework/TableBuilder.h     | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index f941bf29bd8c8..eb56791acfd3c 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -456,10 +456,16 @@ struct CachedInsertion {
   int pos = 0;
 };
 
-template <size_t I, typename T, typename P>
-struct BuilderHolder : P {
+template <typename T>
+struct InsertionTrait {
+  static consteval DirectInsertion<T> policy();
+  using Policy = decltype(policy());
+};
+
+template <size_t I, typename T>
+struct BuilderHolder : InsertionTrait<T>::Policy {
   static constexpr size_t index = I;
-  using Policy = P;
+  using Policy = typename InsertionTrait<T>::Policy;
   using ArrowType = typename detail::ConversionTraits<T>::ArrowType;
   using BuilderType = typename arrow::TypeTraits<ArrowType>::BuilderType;
 
@@ -520,12 +526,6 @@ constexpr auto tuple_to_pack(std::tuple<ARGS...>&&)
   return framework::pack<ARGS...>{};
 }
 
-template <typename T>
-struct InsertionTrait {
-  static consteval DirectInsertion<T> policy();
-  using Policy = decltype(policy());
-};
-
 /// Helper function to convert a brace-initialisable struct to
 /// a tuple.
 template <class T>
@@ -553,7 +553,7 @@ template <typename... ARGS>
 constexpr auto makeHolderTypes()
 {
   return []<std::size_t... Is>(std::index_sequence<Is...>) {
-    return std::tuple(BuilderHolder<Is, ARGS, typename InsertionTrait<ARGS>::Policy>(arrow::default_memory_pool())...);
+    return std::tuple(BuilderHolder<Is, ARGS>(arrow::default_memory_pool())...);
   }(std::make_index_sequence<sizeof...(ARGS)>{});
 }
 
@@ -561,7 +561,7 @@ template <typename... ARGS>
 auto makeHolders(arrow::MemoryPool* pool, size_t nRows)
 {
   return [pool, nRows]<std::size_t... Is>(std::index_sequence<Is...>) {
-    return new std::tuple(BuilderHolder<Is, ARGS, typename InsertionTrait<ARGS>::Policy>(pool, nRows)...);
+    return new std::tuple(BuilderHolder<Is, ARGS>(pool, nRows)...);
   }(std::make_index_sequence<sizeof...(ARGS)>{});
 }
 
@@ -579,7 +579,7 @@ class TableBuilder
   static void throwError(RuntimeErrorRef const& ref);
 
   template <typename... ARGS>
-  using HoldersTuple = typename std::tuple<BuilderHolder<0, ARGS, typename InsertionTrait<ARGS>::Policy>...>;
+  using HoldersTuple = typename std::tuple<BuilderHolder<0, ARGS>...>;
 
   template <typename... ARGS>
   using HoldersTupleIndexed = decltype(makeHolderTypes<ARGS...>());

From f248969308f39f36cdde0bceb5f05d877e579b1a Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 4 Jun 2025 09:01:29 +0200
Subject: [PATCH 0446/1764] ITS: track memory allocations + graceful of
 exceeding limit  (#14326)

* ITS: track and hard limit memory allocations + tbb

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix single threaded

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt  |  14 +-
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  15 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  14 +-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     |  13 +-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |   2 +-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  |  33 +-
 .../include/ITStracking/BoundedAllocator.h    | 179 +++++
 .../include/ITStracking/Configuration.h       |  21 +-
 .../tracking/include/ITStracking/Constants.h  |   4 +-
 .../tracking/include/ITStracking/TimeFrame.h  | 167 ++--
 .../tracking/include/ITStracking/Tracker.h    |  34 +-
 .../include/ITStracking/TrackerTraits.h       |  10 +-
 .../include/ITStracking/TrackingConfigParam.h |  30 +-
 .../include/ITStracking/TrackingInterface.h   |   2 +
 .../tracking/include/ITStracking/Vertexer.h   |  31 +-
 .../include/ITStracking/VertexerTraits.h      |  28 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 212 ++++--
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx | 161 ++--
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 716 +++++++++---------
 .../ITS/tracking/src/TrackingInterface.cxx    |  42 +-
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      |  66 +-
 .../ITS/tracking/src/VertexerTraits.cxx       | 322 ++++----
 .../ITS3/reconstruction/src/IOUtils.cxx       |   4 +-
 23 files changed, 1273 insertions(+), 847 deletions(-)
 create mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h

diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index f8c71e27d0058..d6540cdeaf910 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -9,6 +9,7 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
+#add_compile_options(-O0 -g -fPIC -fno-omit-frame-pointer)
 o2_add_library(ITStracking
                TARGETVARNAME targetName
                SOURCES src/ClusterLines.cxx
@@ -35,12 +36,8 @@ o2_add_library(ITStracking
                        O2::ITSBase
                        O2::ITSReconstruction
                        O2::ITSMFTReconstruction
-                       O2::DataFormatsITS)
-
-if (OpenMP_CXX_FOUND)
-        target_compile_definitions(${targetName} PRIVATE WITH_OPENMP)
-        target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX)
-endif()
+                       O2::DataFormatsITS
+               PRIVATE_LINK_LIBRARIES TBB::tbb)
 
 o2_add_library(ITSTrackingInterface
                TARGETVARNAME targetName
@@ -50,11 +47,6 @@ o2_add_library(ITSTrackingInterface
                        O2::Framework
                        O2::GPUTracking)
 
-if (OpenMP_CXX_FOUND)
-        target_compile_definitions(${targetName} PRIVATE WITH_OPENMP)
-        target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX)
-endif()
-
 o2_target_root_dictionary(ITStracking
                           HEADERS include/ITStracking/ClusterLines.h
                                   include/ITStracking/Tracklet.h
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 14aa0ea5d67fb..82101dba4c02d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -13,6 +13,7 @@
 #ifndef TRACKINGITSGPU_INCLUDE_TIMEFRAMEGPU_H
 #define TRACKINGITSGPU_INCLUDE_TIMEFRAMEGPU_H
 
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Configuration.h"
 #include "ITStrackingGPU/Utils.h"
@@ -62,7 +63,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void loadTrackSeedsDevice();
   void loadTrackSeedsChi2Device();
   void loadRoadsDevice();
-  void loadTrackSeedsDevice(std::vector<CellSeed>&);
+  void loadTrackSeedsDevice(bounded_vector<CellSeed>&);
   void createTrackletsBuffers();
   void createCellsBuffers(const int);
   void createCellsDevice();
@@ -72,10 +73,10 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void createNeighboursDevice(const unsigned int layer, std::vector<std::pair<int, int>>& neighbours);
   void createNeighboursLUTDevice(const int, const unsigned int);
   void createNeighboursDeviceArray();
-  void createTrackITSExtDevice(std::vector<CellSeed>&);
-  void downloadTrackITSExtDevice(std::vector<CellSeed>&);
-  void downloadCellsNeighboursDevice(std::vector<std::vector<std::pair<int, int>>>&, const int);
-  void downloadNeighboursLUTDevice(std::vector<int>&, const int);
+  void createTrackITSExtDevice(bounded_vector<CellSeed>&);
+  void downloadTrackITSExtDevice(bounded_vector<CellSeed>&);
+  void downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>&, const int);
+  void downloadNeighboursLUTDevice(bounded_vector<int>&, const int);
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
   void unregisterRest();
@@ -90,7 +91,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   int getNClustersInRofSpan(const int, const int, const int) const;
   IndexTableUtils* getDeviceIndexTableUtils() { return mIndexTableUtilsDevice; }
   int* getDeviceROFramesClusters(const int layer) { return mROFramesClustersDevice[layer]; }
-  std::vector<o2::its::TrackITSExt>& getTrackITSExt() { return mTrackITSExt; }
+  auto& getTrackITSExt() { return mTrackITSExt; }
   Vertex* getDeviceVertices() { return mPrimaryVerticesDevice; }
   int* getDeviceROFramesPV() { return mROFramesPVDevice; }
   unsigned char* getDeviceUsedClusters(const int);
@@ -199,7 +200,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   bool mFirstInit = true;
 
   // Temporary buffer for storing output tracks from GPU tracking
-  std::vector<TrackITSExt> mTrackITSExt;
+  bounded_vector<TrackITSExt> mTrackITSExt;
 };
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index aabd3a940a532..54aa0e01c8a78 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -71,13 +71,13 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  gsl::span<int*> trackletsLUTsHost,
                                  const int iteration,
                                  const float NSigmaCut,
-                                 std::vector<float>& phiCuts,
+                                 bounded_vector<float>& phiCuts,
                                  const float resolutionPV,
                                  std::array<float, nLayers>& minR,
                                  std::array<float, nLayers>& maxR,
-                                 std::vector<float>& resolutions,
+                                 bounded_vector<float>& resolutions,
                                  std::vector<float>& radii,
-                                 std::vector<float>& mulScatAng,
+                                 bounded_vector<float>& mulScatAng,
                                  const int nBlocks,
                                  const int nThreads);
 
@@ -104,13 +104,13 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    gsl::span<int*> trackletsLUTsHost,
                                    const int iteration,
                                    const float NSigmaCut,
-                                   std::vector<float>& phiCuts,
+                                   bounded_vector<float>& phiCuts,
                                    const float resolutionPV,
                                    std::array<float, nLayers>& minR,
                                    std::array<float, nLayers>& maxR,
-                                   std::vector<float>& resolutions,
+                                   bounded_vector<float>& resolutions,
                                    std::vector<float>& radii,
-                                   std::vector<float>& mulScatAng,
+                                   bounded_vector<float>& mulScatAng,
                                    const int nBlocks,
                                    const int nThreads);
 
@@ -190,7 +190,7 @@ void processNeighboursHandler(const int startLayer,
                               std::array<int*, nLayers - 2>& neighbours,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                              std::vector<CellSeed>& seedsHost,
+                              bounded_vector<CellSeed>& seedsHost,
                               const float bz,
                               const float MaxChi2ClusterAttachment,
                               const float maxChi2NDF,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 5a1e9148c0548..8380533a28e04 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -420,7 +420,7 @@ void TimeFrameGPU<nLayers>::loadRoadsDevice()
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(std::vector<CellSeed>& seeds)
+void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeed>& seeds)
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading track seeds");
   LOGP(debug, "gpu-transfer: loading {} track seeds, for {} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / MB);
@@ -466,11 +466,10 @@ void TimeFrameGPU<nLayers>::createNeighboursDeviceArray()
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackITSExtDevice(std::vector<CellSeed>& seeds)
+void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving tracks");
-  mTrackITSExt.clear();
-  mTrackITSExt.resize(seeds.size());
+  mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
   LOGP(debug, "gpu-allocation: reserving {} tracks, for {} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0]->get()));
@@ -503,7 +502,7 @@ void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<std::vector<std::pair<int, int>>>& neighbours, const int layer)
+void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>& neighbours, const int layer)
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), fmt::format("downloading neighbours from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading {} neighbours, for {} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / MB);
@@ -512,7 +511,7 @@ void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<std::vecto
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(std::vector<int>& lut, const int layer)
+void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut, const int layer)
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), fmt::format("downloading neighbours LUT from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {} MB.", lut.size(), layer, lut.size() * sizeof(int) / MB);
@@ -521,7 +520,7 @@ void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(std::vector<int>& lut, c
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(std::vector<CellSeed>& seeds)
+void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
   START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading tracks");
   LOGP(debug, "gpu-transfer: downloading {} tracks, for {} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / MB);
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 8741b42a697a8..871fd7a95f890 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -221,7 +221,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   for (int startLevel{this->mTrkParams[iteration].CellsPerRoad()}; startLevel >= this->mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     const int minimumLayer{startLevel - 1};
-    std::vector<CellSeed> trackSeeds;
+    bounded_vector<CellSeed> trackSeeds(this->getMemoryPool().get());
     for (int startLayer{this->mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= minimumLayer; --startLayer) {
       if ((this->mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 0dc5c28b3bc65..301f37767c160 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -862,13 +862,13 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  gsl::span<int*> trackletsLUTsHost,
                                  const int iteration,
                                  const float NSigmaCut,
-                                 std::vector<float>& phiCuts,
+                                 bounded_vector<float>& phiCuts,
                                  const float resolutionPV,
                                  std::array<float, nLayers>& minRs,
                                  std::array<float, nLayers>& maxRs,
-                                 std::vector<float>& resolutions,
+                                 bounded_vector<float>& resolutions,
                                  std::vector<float>& radii,
-                                 std::vector<float>& mulScatAng,
+                                 bounded_vector<float>& mulScatAng,
                                  const int nBlocks,
                                  const int nThreads)
 {
@@ -928,13 +928,13 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    gsl::span<int*> trackletsLUTsHost,
                                    const int iteration,
                                    const float NSigmaCut,
-                                   std::vector<float>& phiCuts,
+                                   bounded_vector<float>& phiCuts,
                                    const float resolutionPV,
                                    std::array<float, nLayers>& minRs,
                                    std::array<float, nLayers>& maxRs,
-                                   std::vector<float>& resolutions,
+                                   bounded_vector<float>& resolutions,
                                    std::vector<float>& radii,
-                                   std::vector<float>& mulScatAng,
+                                   bounded_vector<float>& mulScatAng,
                                    const int nBlocks,
                                    const int nThreads)
 {
@@ -1139,7 +1139,7 @@ void processNeighboursHandler(const int startLayer,
                               std::array<int*, nLayers - 2>& neighbours,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                              std::vector<CellSeed>& seedsHost,
+                              bounded_vector<CellSeed>& seedsHost,
                               const float bz,
                               const float maxChi2ClusterAttachment,
                               const float maxChi2NDF,
@@ -1257,9 +1257,8 @@ void processNeighboursHandler(const int startLayer,
   thrust::device_vector<CellSeed> outSeeds(updatedCellSeed.size());
   auto end = thrust::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
   auto s{end - outSeeds.begin()};
-  std::vector<CellSeed> outSeedsHost(s);
-  thrust::copy(outSeeds.begin(), outSeeds.begin() + s, outSeedsHost.begin());
-  seedsHost.insert(seedsHost.end(), outSeedsHost.begin(), outSeedsHost.end());
+  seedsHost.reserve(seedsHost.size() + s);
+  thrust::copy(outSeeds.begin(), outSeeds.begin() + s, std::back_inserter(seedsHost));
 }
 
 void trackSeedHandler(CellSeed* trackSeeds,
@@ -1316,13 +1315,13 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                              gsl::span<int*> trackletsLUTsHost,
                                              const int iteration,
                                              const float NSigmaCut,
-                                             std::vector<float>& phiCuts,
+                                             bounded_vector<float>& phiCuts,
                                              const float resolutionPV,
                                              std::array<float, 7>& minRs,
                                              std::array<float, 7>& maxRs,
-                                             std::vector<float>& resolutions,
+                                             bounded_vector<float>& resolutions,
                                              std::vector<float>& radii,
-                                             std::vector<float>& mulScatAng,
+                                             bounded_vector<float>& mulScatAng,
                                              const int nBlocks,
                                              const int nThreads);
 
@@ -1348,13 +1347,13 @@ template void computeTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                                gsl::span<int*> trackletsLUTsHost,
                                                const int iteration,
                                                const float NSigmaCut,
-                                               std::vector<float>& phiCuts,
+                                               bounded_vector<float>& phiCuts,
                                                const float resolutionPV,
                                                std::array<float, 7>& minRs,
                                                std::array<float, 7>& maxRs,
-                                               std::vector<float>& resolutions,
+                                               bounded_vector<float>& resolutions,
                                                std::vector<float>& radii,
-                                               std::vector<float>& mulScatAng,
+                                               bounded_vector<float>& mulScatAng,
                                                const int nBlocks,
                                                const int nThreads);
 
@@ -1367,7 +1366,7 @@ template void processNeighboursHandler<7>(const int startLayer,
                                           std::array<int*, 5>& neighbours,
                                           gsl::span<int*> neighboursDeviceLUTs,
                                           const TrackingFrameInfo** foundTrackingFrameInfo,
-                                          std::vector<CellSeed>& seedsHost,
+                                          bounded_vector<CellSeed>& seedsHost,
                                           const float bz,
                                           const float maxChi2ClusterAttachment,
                                           const float maxChi2NDF,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
new file mode 100644
index 0000000000000..eced0c64c73a5
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
@@ -0,0 +1,179 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file BoundedAllocator.h
+/// \brief
+///
+
+#ifndef TRACKINGITSU_INCLUDE_BOUNDEDALLOCATOR_H_
+#define TRACKINGITSU_INCLUDE_BOUNDEDALLOCATOR_H_
+
+#include <limits>
+#include <memory_resource>
+#include <atomic>
+#include <new>
+#include <vector>
+
+#include "GPUCommonLogger.h"
+
+namespace o2::its
+{
+
+class BoundedMemoryResource final : public std::pmr::memory_resource
+{
+ public:
+  class MemoryLimitExceeded final : public std::bad_alloc
+  {
+   public:
+    MemoryLimitExceeded(size_t attempted, size_t used, size_t max)
+      : mAttempted(attempted), mUsed(used), mMax(max) {}
+    const char* what() const noexcept final
+    {
+      static thread_local char msg[256];
+      if (mAttempted != 0) {
+        snprintf(msg, sizeof(msg),
+                 "Reached set memory limit (attempted: %zu, used: %zu, max: %zu)",
+                 mAttempted, mUsed, mMax);
+      } else {
+        snprintf(msg, sizeof(msg),
+                 "New set maximum below current used (newMax: %zu, used: %zu)",
+                 mMax, mUsed);
+      }
+      return msg;
+    }
+
+   private:
+    size_t mAttempted{0}, mUsed{0}, mMax{0};
+  };
+
+  BoundedMemoryResource(size_t maxBytes = std::numeric_limits<size_t>::max(), std::pmr::memory_resource* upstream = std::pmr::get_default_resource())
+    : mMaxMemory(maxBytes), mUpstream(upstream) {}
+
+  void* do_allocate(size_t bytes, size_t alignment) final
+  {
+    size_t new_used{0}, current_used{mUsedMemory.load(std::memory_order_relaxed)};
+    do {
+      new_used = current_used + bytes;
+      if (new_used > mMaxMemory) {
+        ++mCountThrow;
+        throw MemoryLimitExceeded(new_used, current_used, mMaxMemory);
+      }
+    } while (!mUsedMemory.compare_exchange_weak(current_used, new_used,
+                                                std::memory_order_acq_rel,
+                                                std::memory_order_relaxed));
+    return mUpstream->allocate(bytes, alignment);
+  }
+
+  void do_deallocate(void* p, size_t bytes, size_t alignment) final
+  {
+    mUpstream->deallocate(p, bytes, alignment);
+    mUsedMemory.fetch_sub(bytes, std::memory_order_relaxed);
+  }
+
+  bool do_is_equal(const std::pmr::memory_resource& other) const noexcept final
+  {
+    return this == &other;
+  }
+
+  size_t getUsedMemory() const noexcept { return mUsedMemory.load(); }
+  size_t getMaxMemory() const noexcept { return mMaxMemory; }
+  void setMaxMemory(size_t max)
+  {
+    if (mUsedMemory > max) {
+      ++mCountThrow;
+      throw MemoryLimitExceeded(0, mUsedMemory, max);
+    }
+    mMaxMemory = max;
+  }
+
+  void print() const
+  {
+#if !defined(GPUCA_GPUCODE_DEVICE)
+    constexpr double GB{1024 * 1024 * 1024};
+    auto throw_ = mCountThrow.load(std::memory_order_relaxed);
+    auto used = static_cast<double>(mUsedMemory.load(std::memory_order_relaxed));
+    LOGP(info, "maxthrow={} maxmem={:.2f} GB used={:.2f} ({:.2f}%)",
+         throw_, (double)mMaxMemory / GB, used / GB, 100. * used / (double)mMaxMemory);
+#endif
+  }
+
+ private:
+  size_t mMaxMemory{std::numeric_limits<size_t>::max()};
+  std::atomic<size_t> mCountThrow{0};
+  std::atomic<size_t> mUsedMemory{0};
+  std::pmr::memory_resource* mUpstream;
+};
+
+template <typename T>
+using bounded_vector = std::pmr::vector<T>;
+
+template <typename T>
+void deepVectorClear(std::vector<T>& vec)
+{
+  std::vector<T>().swap(vec);
+}
+
+template <typename T>
+inline void deepVectorClear(bounded_vector<T>& vec, BoundedMemoryResource* bmr = nullptr)
+{
+  vec.~bounded_vector<T>();
+  if (bmr == nullptr) {
+    auto alloc = vec.get_allocator().resource();
+    new (&vec) bounded_vector<T>(alloc);
+  } else {
+    new (&vec) bounded_vector<T>(bmr);
+  }
+}
+
+template <typename T>
+void deepVectorClear(std::vector<bounded_vector<T>>& vec, BoundedMemoryResource* bmr = nullptr)
+{
+  for (auto& v : vec) {
+    deepVectorClear(v, bmr);
+  }
+}
+
+template <typename T, size_t S>
+void deepVectorClear(std::array<bounded_vector<T>, S>& arr, BoundedMemoryResource* bmr = nullptr)
+{
+  for (size_t i{0}; i < S; ++i) {
+    deepVectorClear(arr[i], bmr);
+  }
+}
+
+template <typename T>
+void clearResizeBoundedVector(bounded_vector<T>& vec, size_t size, BoundedMemoryResource* bmr, T def = T())
+{
+  vec.~bounded_vector<T>();
+  new (&vec) bounded_vector<T>(size, def, bmr);
+}
+
+template <typename T>
+void clearResizeBoundedVector(std::vector<bounded_vector<T>>& vec, size_t size, BoundedMemoryResource* bmr)
+{
+  vec.clear();
+  vec.reserve(size);
+  for (size_t i{0}; i < size; ++i) {
+    vec.emplace_back(bmr);
+  }
+}
+
+template <typename T, size_t S>
+void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size, BoundedMemoryResource* bmr, T def = T())
+{
+  for (size_t i{0}; i < S; ++i) {
+    clearResizeBoundedVector(arr[i], size, bmr, def);
+  }
+}
+
+} // namespace o2::its
+
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index b63a01cb8cd29..d6c552935dd93 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -58,9 +58,7 @@ class Configuration : public Param
 };
 
 struct TrackingParameters {
-  TrackingParameters& operator=(const TrackingParameters& t) = default;
-
-  int CellMinimumLevel();
+  int CellMinimumLevel() { return MinTrackLength - constants::its::ClustersPerCell + 1; }
   int CellsPerRoad() const { return NLayers - 2; }
   int TrackletsPerRoad() const { return NLayers - 1; }
   std::string asString() const;
@@ -92,7 +90,6 @@ struct TrackingParameters {
   float CellsPerClusterLimit = 2.f;
   /// Fitter parameters
   o2::base::PropagatorImpl<float>::MatCorrType CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
-  unsigned long MaxMemory = 12000000000UL;
   float MaxChi2ClusterAttachment = 60.f;
   float MaxChi2NDF = 30.f;
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
@@ -102,7 +99,6 @@ struct TrackingParameters {
   bool SaveTimeBenchmarks = false;
   bool DoUPCIteration = false;
   bool FataliseUponFailure = true;
-  bool DropTFUponFailure = false;
   /// Cluster attachment
   bool UseTrackFollower = false;
   bool UseTrackFollowerTop = false;
@@ -110,12 +106,11 @@ struct TrackingParameters {
   bool UseTrackFollowerMix = false;
   float TrackFollowerNSigmaCutZ = 1.f;
   float TrackFollowerNSigmaCutPhi = 1.f;
-};
 
-inline int TrackingParameters::CellMinimumLevel()
-{
-  return MinTrackLength - constants::its::ClustersPerCell + 1;
-}
+  bool PrintMemory = false; // print allocator usage in epilog report
+  size_t MaxMemory = 12000000000UL;
+  bool DropTFUponFailure = false;
+};
 
 struct VertexingParameters {
   int nIterations = 1;         // Number of vertexing passes to perform
@@ -141,13 +136,15 @@ struct VertexingParameters {
   int maxTrackletsPerCluster = 2e3;
   int phiSpan = -1;
   int zSpan = -1;
+  bool SaveTimeBenchmarks = false;
 
   int nThreads = 1;
+  bool PrintMemory = false; // print allocator usage in epilog report
+  size_t MaxMemory = 12000000000UL;
+  bool DropTFUponFailure = false;
 };
 
 struct TimeFrameGPUParameters {
-  TimeFrameGPUParameters() = default;
-
   size_t tmpCUBBufferSize = 1e5; // In average in pp events there are required 4096 bytes
   size_t maxTrackletsPerCluster = 1e2;
   size_t clustersPerLayerCapacity = 2.5e5;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index ec075b0f10d04..c29ad2e01c588 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -84,8 +84,8 @@ GPUhdi() constexpr std::array<float, LayersNumber> InverseZBinSize()
 {
   constexpr auto zSize = LayersZCoordinate();
   return std::array<float, LayersNumber>{0.5f * ZBins / (zSize[0]), 0.5f * ZBins / (zSize[1]), 0.5f * ZBins / (zSize[2]),
-                                                     0.5f * ZBins / (zSize[3]), 0.5f * ZBins / (zSize[4]), 0.5f * ZBins / (zSize[5]),
-                                                     0.5f * ZBins / (zSize[6])};
+                                         0.5f * ZBins / (zSize[3]), 0.5f * ZBins / (zSize[4]), 0.5f * ZBins / (zSize[5]),
+                                         0.5f * ZBins / (zSize[6])};
 }
 
 GPUhdi() constexpr float getInverseZCoordinate(const int layerIndex)
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 19c24c743ff07..f6bb9a9b11e66 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -32,6 +32,7 @@
 #include "ITStracking/Tracklet.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/ExternalAllocator.h"
+#include "ITStracking/BoundedAllocator.h"
 
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
@@ -75,12 +76,12 @@ struct TimeFrame {
   gsl::span<const std::array<float, 2>> getPrimaryVerticesXAlpha(int rofId) const;
   void fillPrimaryVerticesXandAlpha();
   int getPrimaryVerticesNum(int rofId = -1) const;
-  void addPrimaryVertices(const std::vector<Vertex>& vertices);
-  void addPrimaryVerticesLabels(std::vector<std::pair<MCCompLabel, float>>& labels);
-  void addPrimaryVertices(const std::vector<Vertex>& vertices, const int rofId, const int iteration);
+  void addPrimaryVertices(const bounded_vector<Vertex>& vertices);
+  void addPrimaryVerticesLabels(bounded_vector<std::pair<MCCompLabel, float>>& labels);
+  void addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration);
   void addPrimaryVertices(const gsl::span<const Vertex>& vertices, const int rofId, const int iteration);
-  void addPrimaryVerticesInROF(const std::vector<Vertex>& vertices, const int rofId, const int iteration);
-  void addPrimaryVerticesLabelsInROF(const std::vector<std::pair<MCCompLabel, float>>& labels, const int rofId);
+  void addPrimaryVerticesInROF(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration);
+  void addPrimaryVerticesLabelsInROF(const bounded_vector<std::pair<MCCompLabel, float>>& labels, const int rofId);
   void removePrimaryVerticesInROf(const int rofId);
   int loadROFrameData(const o2::itsmft::ROFRecord& rof, gsl::span<const itsmft::Cluster> clusters,
                       const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
@@ -92,7 +93,7 @@ struct TimeFrame {
                       const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
 
   int getTotalClusters() const;
-  std::vector<int>& getTotVertIteration() { return mTotVertPerIteration; }
+  auto& getTotVertIteration() { return mTotVertPerIteration; }
   bool empty() const { return getTotalClusters() == 0; }
   int getSortedIndex(int rofId, int layer, int idx) const { return mROFramesClusters[layer][rofId] + idx; }
   int getSortedStartIndex(const int rofId, const int layer) const { return mROFramesClusters[layer][rofId]; }
@@ -112,35 +113,35 @@ struct TimeFrame {
   float getMinR(int layer) const { return mMinR[layer]; }
   float getMaxR(int layer) const { return mMaxR[layer]; }
   float getMSangle(int layer) const { return mMSangles[layer]; }
-  std::vector<float>& getMSangles() { return mMSangles; }
+  auto& getMSangles() { return mMSangles; }
   float getPhiCut(int layer) const { return mPhiCuts[layer]; }
-  std::vector<float>& getPhiCuts() { return mPhiCuts; }
+  auto& getPhiCuts() { return mPhiCuts; }
   float getPositionResolution(int layer) const { return mPositionResolution[layer]; }
-  std::vector<float>& getPositionResolutions() { return mPositionResolution; }
+  auto& getPositionResolutions() { return mPositionResolution; }
 
   gsl::span<Cluster> getClustersOnLayer(int rofId, int layerId);
   gsl::span<const Cluster> getClustersOnLayer(int rofId, int layerId) const;
   gsl::span<const Cluster> getClustersPerROFrange(int rofMin, int range, int layerId) const;
   gsl::span<const Cluster> getUnsortedClustersOnLayer(int rofId, int layerId) const;
-  gsl::span<unsigned char> getUsedClustersROF(int rofId, int layerId);
-  gsl::span<const unsigned char> getUsedClustersROF(int rofId, int layerId) const;
+  gsl::span<uint8_t> getUsedClustersROF(int rofId, int layerId);
+  gsl::span<const uint8_t> getUsedClustersROF(int rofId, int layerId) const;
   gsl::span<const int> getROFramesClustersPerROFrange(int rofMin, int range, int layerId) const;
   gsl::span<const int> getROFrameClusters(int layerId) const;
   gsl::span<const int> getNClustersROFrange(int rofMin, int range, int layerId) const;
   gsl::span<const int> getIndexTablePerROFrange(int rofMin, int range, int layerId) const;
   gsl::span<int> getIndexTable(int rofId, int layerId);
-  std::vector<int>& getIndexTableWhole(int layerId) { return mIndexTables[layerId]; }
-  const std::vector<TrackingFrameInfo>& getTrackingFrameInfoOnLayer(int layerId) const { return mTrackingFrameInfo[layerId]; }
+  auto& getIndexTableWhole(int layerId) { return mIndexTables[layerId]; }
+  const auto& getTrackingFrameInfoOnLayer(int layerId) const { return mTrackingFrameInfo[layerId]; }
 
   const TrackingFrameInfo& getClusterTrackingFrameInfo(int layerId, const Cluster& cl) const;
-  const gsl::span<const MCCompLabel> getClusterLabels(int layerId, const Cluster& cl) const { return getClusterLabels(layerId, cl.clusterId); }
-  const gsl::span<const MCCompLabel> getClusterLabels(int layerId, const int clId) const { return mClusterLabels->getLabels(mClusterExternalIndices[layerId][clId]); }
+  gsl::span<const MCCompLabel> getClusterLabels(int layerId, const Cluster& cl) const { return getClusterLabels(layerId, cl.clusterId); }
+  gsl::span<const MCCompLabel> getClusterLabels(int layerId, const int clId) const { return mClusterLabels->getLabels(mClusterExternalIndices[layerId][clId]); }
   int getClusterExternalIndex(int layerId, const int clId) const { return mClusterExternalIndices[layerId][clId]; }
   int getClusterSize(int clusterId) const { return mClusterSize[clusterId]; }
-  void setClusterSize(const std::vector<uint8_t>& v) { mClusterSize = v; }
+  void setClusterSize(const bounded_vector<uint8_t>& v) { mClusterSize = v; }
 
-  std::vector<MCCompLabel>& getTrackletsLabel(int layer) { return mTrackletLabels[layer]; }
-  std::vector<MCCompLabel>& getCellsLabel(int layer) { return mCellLabels[layer]; }
+  auto& getTrackletsLabel(int layer) { return mTrackletLabels[layer]; }
+  auto& getCellsLabel(int layer) { return mCellLabels[layer]; }
 
   bool hasMCinformation() const { return mClusterLabels; }
   void initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers = 7, bool resetVertices = true);
@@ -166,11 +167,11 @@ struct TimeFrame {
   auto& getCellsLookupTable() { return mCellsLookupTable; }
   auto& getCellsNeighbours() { return mCellsNeighbours; }
   auto& getCellsNeighboursLUT() { return mCellsNeighboursLUT; }
-  std::vector<Road<nLayers - 2>>& getRoads() { return mRoads; }
-  std::vector<TrackITSExt>& getTracks(int rofId) { return mTracks[rofId]; }
-  std::vector<MCCompLabel>& getTracksLabel(const int rofId) { return mTracksLabel[rofId]; }
-  std::vector<MCCompLabel>& getLinesLabel(const int rofId) { return mLinesLabels[rofId]; }
-  std::vector<std::pair<MCCompLabel, float>>& getVerticesMCRecInfo() { return mVerticesMCRecInfo; }
+  auto& getRoads() { return mRoads; }
+  auto& getTracks(int rofId) { return mTracks[rofId]; }
+  auto& getTracksLabel(const int rofId) { return mTracksLabel[rofId]; }
+  auto& getLinesLabel(const int rofId) { return mLinesLabels[rofId]; }
+  auto& getVerticesMCRecInfo() { return mVerticesMCRecInfo; }
 
   int getNumberOfClusters() const;
   int getNumberOfCells() const;
@@ -181,22 +182,28 @@ struct TimeFrame {
   auto getNumberOfExtendedTracks() const { return mNExtendedTracks; }
   auto getNumberOfUsedExtendedClusters() const { return mNExtendedUsedClusters; }
 
+  /// memory management
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool);
+  auto& getMemoryPool() const noexcept { return mMemoryPool; }
   bool checkMemory(unsigned long max) { return getArtefactsMemory() < max; }
-  unsigned long getArtefactsMemory();
-  int getROFCutClusterMult() const { return mCutClusterMult; }
-  int getROFCutVertexMult() const { return mCutVertexMult; }
+  unsigned long getArtefactsMemory() const;
+  void printArtefactsMemory() const;
+
+  /// ROF cuts
+  int getROFCutClusterMult() const { return mCutClusterMult; };
+  int getROFCutVertexMult() const { return mCutVertexMult; };
   int getROFCutAllMult() const { return mCutClusterMult + mCutVertexMult; }
 
   // Vertexer
   void computeTrackletsPerROFScans();
   void computeTracletsPerClusterScans();
   int& getNTrackletsROF(int rofId, int combId) { return mNTrackletsPerROF[combId][rofId]; }
-  std::vector<Line>& getLines(int rofId) { return mLines[rofId]; }
+  auto& getLines(int rofId) { return mLines[rofId]; }
   int getNLinesTotal() const
   {
     return std::accumulate(mLines.begin(), mLines.end(), 0, [](int sum, const auto& l) { return sum + l.size(); });
   }
-  std::vector<ClusterLines>& getTrackletClusters(int rofId) { return mTrackletClusters[rofId]; }
+  auto& getTrackletClusters(int rofId) { return mTrackletClusters[rofId]; }
   gsl::span<const Tracklet> getFoundTracklets(int rofId, int combId) const;
   gsl::span<Tracklet> getFoundTracklets(int rofId, int combId);
   gsl::span<const MCCompLabel> getLabelsFoundTracklets(int rofId, int combId) const;
@@ -233,6 +240,7 @@ struct TimeFrame {
   void addClusterExternalIndexToLayer(int layer, const int idx) { mClusterExternalIndices[layer].push_back(idx); }
 
   void resetVectors();
+  void resetTracklets();
 
   /// Debug and printing
   void checkTrackletLUTs();
@@ -249,22 +257,22 @@ struct TimeFrame {
 
   bool mIsGPU = false;
 
-  std::array<std::vector<Cluster>, nLayers> mClusters;
-  std::array<std::vector<TrackingFrameInfo>, nLayers> mTrackingFrameInfo;
-  std::array<std::vector<int>, nLayers> mClusterExternalIndices;
-  std::array<std::vector<int>, nLayers> mROFramesClusters;
+  std::array<bounded_vector<Cluster>, nLayers> mClusters;
+  std::array<bounded_vector<TrackingFrameInfo>, nLayers> mTrackingFrameInfo;
+  std::array<bounded_vector<int>, nLayers> mClusterExternalIndices;
+  std::array<bounded_vector<int>, nLayers> mROFramesClusters;
   const dataformats::MCTruthContainer<MCCompLabel>* mClusterLabels = nullptr;
-  std::array<std::vector<int>, 2> mNTrackletsPerCluster;
-  std::array<std::vector<int>, 2> mNTrackletsPerClusterSum;
-  std::array<std::vector<int>, nLayers> mNClustersPerROF;
-  std::vector<std::vector<int>> mIndexTables;
-  std::vector<std::vector<int>> mTrackletsLookupTable;
-  std::array<std::vector<uint8_t>, nLayers> mUsedClusters;
+  std::array<bounded_vector<int>, 2> mNTrackletsPerCluster;
+  std::array<bounded_vector<int>, 2> mNTrackletsPerClusterSum;
+  std::array<bounded_vector<int>, nLayers> mNClustersPerROF;
+  std::array<bounded_vector<int>, nLayers> mIndexTables;
+  std::vector<bounded_vector<int>> mTrackletsLookupTable;
+  std::array<bounded_vector<uint8_t>, nLayers> mUsedClusters;
   int mNrof = 0;
   int mNExtendedTracks{0};
   int mNExtendedUsedClusters{0};
-  std::vector<int> mROFramesPV = {0};
-  std::vector<Vertex> mPrimaryVertices;
+  bounded_vector<int> mROFramesPV;
+  bounded_vector<Vertex> mPrimaryVertices;
 
   // State if memory will be externally managed.
   bool mExtAllocator = false;
@@ -282,31 +290,20 @@ struct TimeFrame {
   void setExtAllocator(bool ext) { mExtAllocator = ext; }
   bool getExtAllocator() const { return mExtAllocator; }
 
-  std::array<std::vector<Cluster>, nLayers> mUnsortedClusters;
-  std::vector<std::vector<Tracklet>> mTracklets;
-  std::vector<std::vector<CellSeed>> mCells;
-  std::vector<std::vector<o2::track::TrackParCovF>> mCellSeeds;
-  std::vector<std::vector<float>> mCellSeedsChi2;
-  std::vector<Road<nLayers - 2>> mRoads;
-  std::vector<std::vector<TrackITSExt>> mTracks;
-  std::vector<std::vector<int>> mCellsNeighbours;
-  std::vector<std::vector<int>> mCellsLookupTable;
+  std::array<bounded_vector<Cluster>, nLayers> mUnsortedClusters;
+  std::vector<bounded_vector<Tracklet>> mTracklets;
+  std::vector<bounded_vector<CellSeed>> mCells;
+  std::vector<bounded_vector<o2::track::TrackParCovF>> mCellSeeds;
+  std::vector<bounded_vector<float>> mCellSeedsChi2;
+  bounded_vector<Road<nLayers - 2>> mRoads;
+  std::vector<bounded_vector<TrackITSExt>> mTracks;
+  std::vector<bounded_vector<int>> mCellsNeighbours;
+  std::vector<bounded_vector<int>> mCellsLookupTable;
   std::vector<uint8_t> mMultiplicityCutMask;
 
   const o2::base::PropagatorImpl<float>* mPropagatorDevice = nullptr; // Needed only for GPU
-  void dropTracks()
-  {
-    for (auto& v : mTracks) {
-      deepVectorClear(v);
-    }
-  }
 
- protected:
-  template <typename T>
-  void deepVectorClear(std::vector<T>& vec)
-  {
-    std::vector<T>().swap(vec);
-  }
+  void wipe();
 
  private:
   void prepareClusters(const TrackingParameters& trkParam, const int maxLayers);
@@ -317,39 +314,44 @@ struct TimeFrame {
   bool isBeamPositionOverridden = false;
   std::array<float, nLayers> mMinR;
   std::array<float, nLayers> mMaxR;
-  std::vector<float> mMSangles;
-  std::vector<float> mPhiCuts;
-  std::vector<float> mPositionResolution;
-  std::vector<uint8_t> mClusterSize;
+  bounded_vector<float> mMSangles;
+  bounded_vector<float> mPhiCuts;
+  bounded_vector<float> mPositionResolution;
+  bounded_vector<uint8_t> mClusterSize;
 
   std::vector<uint8_t> mROFMask;
-  std::vector<std::array<float, 2>> mPValphaX; /// PV x and alpha for track propagation
-  std::vector<std::vector<MCCompLabel>> mTrackletLabels;
-  std::vector<std::vector<MCCompLabel>> mCellLabels;
-  std::vector<std::vector<int>> mCellsNeighboursLUT;
-  std::vector<std::vector<MCCompLabel>> mTracksLabel;
-  std::vector<int> mBogusClusters; /// keep track of clusters with wild coordinates
-
-  std::vector<std::pair<unsigned long long, bool>> mRoadLabels;
+  bounded_vector<std::array<float, 2>> mPValphaX; /// PV x and alpha for track propagation
+  std::vector<bounded_vector<MCCompLabel>> mTrackletLabels;
+  std::vector<bounded_vector<MCCompLabel>> mCellLabels;
+  std::vector<bounded_vector<int>> mCellsNeighboursLUT;
+  std::vector<bounded_vector<MCCompLabel>> mTracksLabel;
+  bounded_vector<int> mBogusClusters; /// keep track of clusters with wild coordinates
+
+  bounded_vector<std::pair<unsigned long long, bool>> mRoadLabels;
   int mCutClusterMult;
   int mCutVertexMult;
 
   // Vertexer
-  std::vector<std::vector<int>> mNTrackletsPerROF;
-  std::vector<std::vector<Line>> mLines;
-  std::vector<std::vector<ClusterLines>> mTrackletClusters;
-  std::array<std::vector<int>, 2> mTrackletsIndexROF;
-  std::vector<std::vector<MCCompLabel>> mLinesLabels;
+  std::vector<bounded_vector<int>> mNTrackletsPerROF;
+  std::vector<bounded_vector<Line>> mLines;
+  std::vector<bounded_vector<ClusterLines>> mTrackletClusters;
+  std::array<bounded_vector<int>, 2> mTrackletsIndexROF;
+  std::vector<bounded_vector<MCCompLabel>> mLinesLabels;
   std::vector<std::pair<MCCompLabel, float>> mVerticesMCRecInfo;
   std::array<uint32_t, 2> mTotalTracklets = {0, 0};
   unsigned int mNoVertexROF = 0;
-  std::vector<int> mTotVertPerIteration;
+  bounded_vector<int> mTotVertPerIteration;
   // \Vertexer
+
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
 };
 
 template <int nLayers>
 inline gsl::span<const Vertex> TimeFrame<nLayers>::getPrimaryVertices(int rofId) const
 {
+  if (mPrimaryVertices.empty()) {
+    return {};
+  }
   const int start = mROFramesPV[rofId];
   const int stop_idx = rofId >= mNrof - 1 ? mNrof : rofId + 1;
   int delta = mMultiplicityCutMask[rofId] ? mROFramesPV[stop_idx] - start : 0; // return empty span if Rof is excluded
@@ -368,6 +370,9 @@ inline gsl::span<const std::pair<MCCompLabel, float>> TimeFrame<nLayers>::getPri
 template <int nLayers>
 inline gsl::span<const Vertex> TimeFrame<nLayers>::getPrimaryVertices(int romin, int romax) const
 {
+  if (mPrimaryVertices.empty()) {
+    return {};
+  }
   return {&mPrimaryVertices[mROFramesPV[romin]], static_cast<gsl::span<const Vertex>::size_type>(mROFramesPV[romax + 1] - mROFramesPV[romin])};
 }
 
@@ -417,7 +422,7 @@ inline gsl::span<const Cluster> TimeFrame<nLayers>::getClustersOnLayer(int rofId
     return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
-  return {&mClusters[layerId][startIdx], static_cast<gsl::span<Cluster>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
+  return {&mClusters[layerId][startIdx], static_cast<gsl::span<const Cluster>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
 template <int nLayers>
@@ -437,7 +442,7 @@ inline gsl::span<const uint8_t> TimeFrame<nLayers>::getUsedClustersROF(int rofId
     return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
-  return {&mUsedClusters[layerId][startIdx], static_cast<gsl::span<uint8_t>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
+  return {&mUsedClusters[layerId][startIdx], static_cast<gsl::span<const uint8_t>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 2e535e2b6a644..d8236fed51240 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -23,6 +23,7 @@
 #include <iomanip>
 #include <iosfwd>
 #include <memory>
+#include <string_view>
 #include <utility>
 #include <sstream>
 
@@ -34,6 +35,7 @@
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITStracking/Road.h"
+#include "ITStracking/BoundedAllocator.h"
 
 #include "DataFormatsITS/TrackITS.h"
 #include "SimulationDataFormat/MCCompLabel.h"
@@ -65,6 +67,7 @@ class Tracker
     LogFunc = [](const std::string& s) { std::cerr << s << '\n'; });
 
   void setParameters(const std::vector<TrackingParameters>& p) { mTrkParams = p; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
   void getGlobalConfiguration();
   void setBz(float bz) { mTraits->setBz(bz); }
@@ -89,7 +92,7 @@ class Tracker
   void rectifyClusterIndices();
 
   template <typename... T, typename... F>
-  float evaluateTask(void (Tracker::*task)(T...), const char* taskName, LogFunc logger, F&&... args);
+  float evaluateTask(void (Tracker::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args);
 
   TrackerTraits7* mTraits = nullptr; /// Observer pointer, not owned by this class
   TimeFrame7* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
@@ -100,23 +103,35 @@ class Tracker
   unsigned int mNumberOfDroppedTFs{0};
   unsigned int mTimeFrameCounter{0};
   double mTotalTime{0};
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+
+  enum State {
+    TFInit = 0,
+    Trackleting,
+    Celling,
+    Neighbouring,
+    Roading,
+    NStates,
+  };
+  State mCurState;
+  static constexpr std::array<const char*, NStates> StateNames{"TimeFrame initialisation", "Tracklet finding", "Cell finding", "Neighbour finding", "Road finding"};
 };
 
 template <typename... T, typename... F>
-float Tracker::evaluateTask(void (Tracker::*task)(T...), const char* taskName, LogFunc logger, F&&... args)
+float Tracker::evaluateTask(void (Tracker::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args)
 {
   float diff{0.f};
 
   if constexpr (constants::DoTimeBenchmarks) {
     auto start = std::chrono::high_resolution_clock::now();
-    (this->*task)(std::forward<T>(args)...);
+    (this->*task)(std::forward<F>(args)...);
     auto end = std::chrono::high_resolution_clock::now();
 
     std::chrono::duration<double, std::milli> diff_t{end - start};
     diff = diff_t.count();
 
     std::stringstream sstream;
-    if (taskName == nullptr) {
+    if (taskName.empty()) {
       sstream << diff << "\t";
     } else {
       sstream << std::setw(2) << " - " << taskName << " completed in: " << diff << " ms";
@@ -124,20 +139,17 @@ float Tracker::evaluateTask(void (Tracker::*task)(T...), const char* taskName, L
     logger(sstream.str());
 
     if (mTrkParams[0].SaveTimeBenchmarks) {
-      std::stringstream str2file;
       std::string taskNameStr(taskName);
       std::transform(taskNameStr.begin(), taskNameStr.end(), taskNameStr.begin(),
                      [](unsigned char c) { return std::tolower(c); });
       std::replace(taskNameStr.begin(), taskNameStr.end(), ' ', '_');
-      str2file << taskNameStr << "\t" << diff;
-      std::ofstream file;
-      file.open("its_time_benchmarks.txt", std::ios::app);
-      file << str2file.str() << std::endl;
-      file.close();
+      if (std::ofstream file{"its_time_benchmarks.txt", std::ios::app}) {
+        file << "trk:" << iteration << '\t' << taskNameStr << '\t' << diff << '\n';
+      }
     }
 
   } else {
-    (this->*task)(std::forward<T>(args)...);
+    (this->*task)(std::forward<F>(args)...);
   }
 
   return diff;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 7340f247e4cf2..22af80e544c86 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -22,6 +22,10 @@
 #include "ITStracking/Configuration.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/TimeFrame.h"
+#include "ITStracking/BoundedAllocator.h"
+
+#include <oneapi/tbb.h>
+#include <oneapi/tbb/partitioner.h>
 
 // #define OPTIMISATION_OUTPUT
 
@@ -54,7 +58,7 @@ class TrackerTraits
   virtual void findShortPrimaries();
 
   virtual bool trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration);
-  virtual void processNeighbours(int iLayer, int iLevel, const std::vector<CellSeed>& currentCellSeed, const std::vector<int>& currentCellId, std::vector<CellSeed>& updatedCellSeed, std::vector<int>& updatedCellId);
+  virtual void processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeed>& updatedCellSeed, bounded_vector<int>& updatedCellId);
 
   void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars) { mTrkParams = trkPars; }
   TimeFrame<nLayers>* getTimeFrame() { return mTimeFrame; }
@@ -65,6 +69,8 @@ class TrackerTraits
   bool isMatLUT() const;
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool isGPU() const noexcept { return false; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) noexcept { mMemoryPool = pool; }
+  auto getMemoryPool() const noexcept { return mMemoryPool; }
 
   // Others
   GPUhd() static consteval int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
@@ -92,6 +98,8 @@ class TrackerTraits
 
   int mNThreads = 1;
   bool mApplySmoothing = false;
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  tbb::task_arena mTaskArena;
 
  protected:
   o2::base::PropagatorImpl<float>::MatCorrType mCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index cb6512248bf0c..72301cd2851b3 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -15,12 +15,11 @@
 #include "CommonUtils/ConfigurableParam.h"
 #include "CommonUtils/ConfigurableParamHelper.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerParamConfig> {
+  bool saveTimeBenchmarks = false; // dump metrics on file
 
   int nIterations = 1;                     // Number of vertexing passes to perform.
   int vertPerRofThreshold = 0;             // Maximum number of vertices per ROF to trigger second a iteration.
@@ -49,6 +48,9 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   int PhiBins = 128; // z-phi index table configutation: number of phi bins
 
   int nThreads = 1;
+  bool printMemory = false;
+  size_t maxMemory = 12000000000UL;
+  bool dropTFUponFailure = false;
 
   O2ParamDef(VertexerParamConfig, "ITSVertexerParam");
 };
@@ -58,14 +60,14 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   static const int MaxIter = 4;
   static const int MinTrackLength = 4;
   static const int MaxTrackLength = 7;
-  bool useMatCorrTGeo = false;  // use full geometry to corect for material budget accounting in the fits. Default is to use the material budget LUT.
-  bool useFastMaterial = false; // use faster material approximation for material budget accounting in the fits.
-  int deltaRof = 0;             // configure the width of the window in ROFs to be considered for the tracking.
+  bool useMatCorrTGeo = false;                                              // use full geometry to corect for material budget accounting in the fits. Default is to use the material budget LUT.
+  bool useFastMaterial = false;                                             // use faster material approximation for material budget accounting in the fits.
+  int deltaRof = 0;                                                         // configure the width of the window in ROFs to be considered for the tracking.
   int minTrackLgtIter[MaxIter] = {};                                        // minimum track length at each iteration, used only if >0, otherwise use code defaults
   uint8_t startLayerMask[MaxIter] = {};                                     // mask of start layer for this iteration (if >0)
   float minPtIterLgt[MaxIter * (MaxTrackLength - MinTrackLength + 1)] = {}; // min.pT for given track length at this iteration, used only if >0, otherwise use code defaults
-  float sysErrY2[7] = {0};      // systematic error^2 in Y per layer
-  float sysErrZ2[7] = {0};      // systematic error^2 in Z per layer
+  float sysErrY2[7] = {0};                                                  // systematic error^2 in Y per layer
+  float sysErrZ2[7] = {0};                                                  // systematic error^2 in Z per layer
   float maxChi2ClusterAttachment = -1.f;
   float maxChi2NDF = -1.f;
   float nSigmaCut = -1.f;
@@ -76,14 +78,12 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   int LUTbinsZ = -1;
   float diamondPos[3] = {0.f, 0.f, 0.f}; // override the position of the vertex
   bool useDiamond = false;               // enable overriding the vertex position
-  unsigned long maxMemory = 0;           // override default protections on the maximum memory to be used by the tracking
   int useTrackFollower = -1;             // bit 0: allow mixing implies bits 1&2; bit 1: topwards; bit2: downwards; => 0 off
   float trackFollowerNSigmaZ = 1.f;      // sigma in z-cut for track-following search rectangle
   float trackFollowerNSigmaPhi = 1.f;    // sigma in phi-cut for track-following search rectangle
   float cellsPerClusterLimit = -1.f;
   float trackletsPerClusterLimit = -1.f;
   int findShortTracks = -1;
-  int nThreads = 1;                        // number of threads to perform the operations in parallel.
   int nROFsPerIterations = 0;              // size of the slice of ROFs to be processed at a time, preferably integer divisors of nROFs per TF, to balance the iterations.
   int nOrbitsPerIterations = 0;            // not implemented: size of the slice of ROFs to be processed at a time, computed using the number of ROFs per orbit.
   bool perPrimaryVertexProcessing = false; // perform the full tracking considering the vertex hypotheses one at the time.
@@ -91,21 +91,23 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   bool overrideBeamEstimation = false;     // use beam position from meanVertex CCDB object
   int trackingMode = -1;                   // -1: unset, 0=sync, 1=async, 2=cosmics used by gpuwf only
   bool doUPCIteration = false;             // Perform an additional iteration for UPC events on tagged vertices. You want to combine this config with VertexerParamConfig.nIterations=2
-  bool fataliseUponFailure = true;         // granular management of the fatalisation in async mode
+
+  int nThreads = 1;
+  bool printMemory = false;
+  size_t maxMemory = 12000000000UL;
   bool dropTFUponFailure = false;
+  bool fataliseUponFailure = true; // granular management of the fatalisation in async mode
 
   O2ParamDef(TrackerParamConfig, "ITSCATrackerParam");
 };
 
 struct ITSGpuTrackingParamConfig : public o2::conf::ConfigurableParamHelper<ITSGpuTrackingParamConfig> {
   // GPU-specific parameters
-  unsigned int tmpCUBBufferSize = 1e5; // In average in pp events there are required 4096 bytes
   int nBlocks = 20;
   int nThreads = 256;
 
   O2ParamDef(ITSGpuTrackingParamConfig, "ITSGpuTrackingParam");
 };
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index 89b5527f5b2c9..cff6d215e5e3b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -19,6 +19,7 @@
 #include "ITStracking/TrackerTraits.h"
 #include "ITStracking/Vertexer.h"
 #include "ITStracking/VertexerTraits.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "DataFormatsCalibration/MeanVertexObject.h"
@@ -95,6 +96,7 @@ class ITSTrackingInterface
   std::unique_ptr<Tracker> mTracker = nullptr;
   std::unique_ptr<Vertexer> mVertexer = nullptr;
   const o2::dataformats::MeanVertexObject* mMeanVertex;
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 56cd286b509ad..77b21b58b967b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -27,6 +27,7 @@
 #include "ITStracking/Configuration.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/VertexerTraits.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "ReconstructionDataFormats/Vertex.h"
 
 #include "ITStracking/ClusterLines.h"
@@ -56,6 +57,7 @@ class Vertexer
   auto& getVertParameters() const { return mTraits->getVertexingParameters(); }
   void setParameters(const std::vector<VertexingParameters>& vertParams) { mVertParams = vertParams; }
   void getGlobalConfiguration();
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
 
   std::vector<Vertex> exportVertices();
   VertexerTraits* getTraits() const { return mTraits; };
@@ -80,7 +82,8 @@ class Vertexer
   // Utils
   void dumpTraits() { mTraits->dumpVertexerTraits(); }
   template <typename... T>
-  float evaluateTask(void (Vertexer::*)(T...), const char*, LogFunc logger, T&&... args);
+  float evaluateTask(void (Vertexer::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args);
+
   void printEpilog(LogFunc& logger,
                    const unsigned int trackletN01, const unsigned int trackletN12,
                    const unsigned selectedN, const unsigned int vertexN, const float initT,
@@ -93,6 +96,17 @@ class Vertexer
   TimeFrame7* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
 
   std::vector<VertexingParameters> mVertParams;
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+
+  enum State {
+    Init = 0,
+    Trackleting,
+    Validating,
+    Finding,
+    NStates,
+  };
+  State mCurState;
+  static constexpr std::array<const char*, NStates> StateNames{"Initialisation", "Tracklet finding", "Tracklet validation", "Vertex finding"};
 };
 
 template <typename... T>
@@ -120,8 +134,7 @@ inline void Vertexer::findVertices(T&&... args)
 }
 
 template <typename... T>
-float Vertexer::evaluateTask(void (Vertexer::*task)(T...), const char* taskName, LogFunc logger,
-                             T&&... args)
+float Vertexer::evaluateTask(void (Vertexer::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args)
 {
   float diff{0.f};
 
@@ -134,12 +147,22 @@ float Vertexer::evaluateTask(void (Vertexer::*task)(T...), const char* taskName,
     diff = diff_t.count();
 
     std::stringstream sstream;
-    if (taskName == nullptr) {
+    if (taskName.empty()) {
       sstream << diff << "\t";
     } else {
       sstream << std::setw(2) << " - " << taskName << " completed in: " << diff << " ms";
     }
     logger(sstream.str());
+
+    if (mVertParams[0].SaveTimeBenchmarks) {
+      std::string taskNameStr(taskName);
+      std::transform(taskNameStr.begin(), taskNameStr.end(), taskNameStr.begin(),
+                     [](unsigned char c) { return std::tolower(c); });
+      std::replace(taskNameStr.begin(), taskNameStr.end(), ' ', '_');
+      if (std::ofstream file{"its_time_benchmarks.txt", std::ios::app}) {
+        file << "vtx:" << iteration << '\t' << taskNameStr << '\t' << diff << '\n';
+      }
+    }
   } else {
     (this->*task)(std::forward<T>(args)...);
   }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index bc7daf5e3ab24..ae92fda292df3 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -20,6 +20,7 @@
 #include <string>
 #include <vector>
 
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/Cluster.h"
 #include "ITStracking/ClusterLines.h"
 #include "ITStracking/Configuration.h"
@@ -31,6 +32,8 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
 
+#include <oneapi/tbb/task_arena.h>
+
 namespace o2
 {
 class MCCompLabel;
@@ -68,23 +71,23 @@ class VertexerTraits
   virtual void computeTracklets(const int iteration = 0);
   virtual void computeTrackletMatching(const int iteration = 0);
   virtual void computeVertices(const int iteration = 0);
-  virtual void adoptTimeFrame(TimeFrame7* tf) { mTimeFrame = tf; }
+  virtual void adoptTimeFrame(TimeFrame7* tf) noexcept { mTimeFrame = tf; }
   virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& gpuTfPar);
 
   void computeVerticesInRof(int,
                             gsl::span<const o2::its::Line>&,
-                            std::vector<bool>&,
-                            std::vector<o2::its::ClusterLines>&,
+                            bounded_vector<bool>&,
+                            bounded_vector<o2::its::ClusterLines>&,
                             std::array<float, 2>&,
-                            std::vector<Vertex>&,
-                            std::vector<int>&,
+                            bounded_vector<Vertex>&,
+                            bounded_vector<int>&,
                             TimeFrame7*,
-                            std::vector<o2::MCCompLabel>*,
+                            bounded_vector<o2::MCCompLabel>*,
                             const int iteration = 0);
 
-  static const std::vector<std::pair<int, int>> selectClusters(const int* indexTable,
-                                                               const std::array<int, 4>& selectedBinsRect,
-                                                               const IndexTableUtils& utils);
+  const bounded_vector<std::pair<int, int>> selectClusters(const int* indexTable,
+                                                           const std::array<int, 4>& selectedBinsRect,
+                                                           const IndexTableUtils& utils);
 
   // utils
   auto& getVertexingParameters() { return mVrtParams; }
@@ -95,9 +98,11 @@ class VertexerTraits
   int getNThreads() const { return mNThreads; }
   virtual bool isGPU() const noexcept { return false; }
   virtual const char* getName() const noexcept { return "CPU"; }
+  virtual bool usesMemoryPool() const noexcept { return true; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
 
   template <typename T = o2::MCCompLabel>
-  static std::pair<T, float> computeMain(const std::vector<T>& elements)
+  static std::pair<T, float> computeMain(const bounded_vector<T>& elements)
   {
     T elem;
     size_t maxCount = 0;
@@ -119,6 +124,9 @@ class VertexerTraits
 
   // Frame related quantities
   TimeFrame7* mTimeFrame = nullptr; // observer ptr
+ private:
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  tbb::task_arena mTaskArena;
 };
 
 inline void VertexerTraits::initialise(const TrackingParameters& trackingParams, const int iteration)
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 80a6ef481fde6..eb7834da740d0 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -20,14 +20,11 @@
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/TrackingConfigParam.h"
 
 #include <iostream>
 
-#ifdef WITH_OPENMP
-#include <omp.h>
-#endif
-
 namespace
 {
 struct ClusterHelper {
@@ -71,7 +68,7 @@ TimeFrame<nLayers>::~TimeFrame()
 }
 
 template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVertices(const std::vector<Vertex>& vertices)
+void TimeFrame<nLayers>::addPrimaryVertices(const bounded_vector<Vertex>& vertices)
 {
   for (const auto& vertex : vertices) {
     mPrimaryVertices.emplace_back(vertex);
@@ -86,19 +83,19 @@ void TimeFrame<nLayers>::addPrimaryVertices(const std::vector<Vertex>& vertices)
 }
 
 template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVertices(const std::vector<Vertex>& vertices, const int rofId, const int iteration)
+void TimeFrame<nLayers>::addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration)
 {
   addPrimaryVertices(gsl::span<const Vertex>(vertices), rofId, iteration);
 }
 
 template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVerticesLabels(std::vector<std::pair<MCCompLabel, float>>& labels)
+void TimeFrame<nLayers>::addPrimaryVerticesLabels(bounded_vector<std::pair<MCCompLabel, float>>& labels)
 {
   mVerticesMCRecInfo.insert(mVerticesMCRecInfo.end(), labels.begin(), labels.end());
 }
 
 template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVerticesInROF(const std::vector<Vertex>& vertices, const int rofId, const int iteration)
+void TimeFrame<nLayers>::addPrimaryVerticesInROF(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration)
 {
   mPrimaryVertices.insert(mPrimaryVertices.begin() + mROFramesPV[rofId], vertices.begin(), vertices.end());
   for (int i = rofId + 1; i < mROFramesPV.size(); ++i) {
@@ -108,7 +105,7 @@ void TimeFrame<nLayers>::addPrimaryVerticesInROF(const std::vector<Vertex>& vert
 }
 
 template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVerticesLabelsInROF(const std::vector<std::pair<MCCompLabel, float>>& labels, const int rofId)
+void TimeFrame<nLayers>::addPrimaryVerticesLabelsInROF(const bounded_vector<std::pair<MCCompLabel, float>>& labels, const int rofId)
 {
   mVerticesMCRecInfo.insert(mVerticesMCRecInfo.begin() + mROFramesPV[rofId], labels.begin(), labels.end());
 }
@@ -116,7 +113,7 @@ void TimeFrame<nLayers>::addPrimaryVerticesLabelsInROF(const std::vector<std::pa
 template <int nLayers>
 void TimeFrame<nLayers>::addPrimaryVertices(const gsl::span<const Vertex>& vertices, const int rofId, const int iteration)
 {
-  std::vector<Vertex> futureVertices;
+  bounded_vector<Vertex> futureVertices(mMemoryPool.get());
   for (const auto& vertex : vertices) {
     if (vertex.getTimeStamp().getTimeStamp() < rofId) { // put a copy in the past
       insertPastVertex(vertex, iteration);
@@ -148,16 +145,16 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
                                         const itsmft::TopologyDictionary* dict,
                                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  for (int iLayer{0}; iLayer < mUnsortedClusters.size(); ++iLayer) {
-    deepVectorClear(mUnsortedClusters[iLayer]);
-    deepVectorClear(mTrackingFrameInfo[iLayer]);
-    deepVectorClear(mClusterExternalIndices[iLayer]);
-    mROFramesClusters[iLayer].resize(1, 0);
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    deepVectorClear(mUnsortedClusters[iLayer], mMemoryPool.get());
+    deepVectorClear(mTrackingFrameInfo[iLayer], mMemoryPool.get());
+    deepVectorClear(mClusterExternalIndices[iLayer], mMemoryPool.get());
+    clearResizeBoundedVector(mROFramesClusters[iLayer], 1, mMemoryPool.get(), 0);
 
     if (iLayer < 2) {
-      deepVectorClear(mTrackletsIndexROF[iLayer]);
-      deepVectorClear(mNTrackletsPerCluster[iLayer]);
-      deepVectorClear(mNTrackletsPerClusterSum[iLayer]);
+      deepVectorClear(mTrackletsIndexROF[iLayer], mMemoryPool.get());
+      deepVectorClear(mNTrackletsPerCluster[iLayer], mMemoryPool.get());
+      deepVectorClear(mNTrackletsPerClusterSum[iLayer], mMemoryPool.get());
     }
   }
 
@@ -165,8 +162,7 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
 
   mNrof = 0;
-  deepVectorClear(mClusterSize);
-  mClusterSize.reserve(clusters.size());
+  clearResizeBoundedVector(mClusterSize, clusters.size(), mMemoryPool.get());
   for (auto& rof : rofs) {
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {
       auto& c = clusters[clusterId];
@@ -193,11 +189,7 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
         locXYZ = dict->getClusterCoordinates(c, patt, false);
         clusterSize = patt.getNPixels();
       }
-      if (clusterSize < 255) {
-        mClusterSize.push_back(clusterSize);
-      } else {
-        mClusterSize.push_back(255);
-      }
+      mClusterSize.push_back(std::clamp(clusterSize, 0u, 255u));
       auto sensorID = c.getSensorID();
       // Inverse transformation to the local --> tracking
       auto trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;
@@ -226,14 +218,15 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
   if (mcLabels != nullptr) {
     mClusterLabels = mcLabels;
   }
+
   return mNrof;
 }
 
 template <int nLayers>
 void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, const int maxLayers)
 {
-  std::vector<ClusterHelper> cHelper;
-  std::vector<int> clsPerBin(trkParam.PhiBins * trkParam.ZBins, 0);
+  bounded_vector<ClusterHelper> cHelper(mMemoryPool.get());
+  bounded_vector<int> clsPerBin(trkParam.PhiBins * trkParam.ZBins, 0, mMemoryPool.get());
   for (int rof{0}; rof < mNrof; ++rof) {
     if ((int)mMultiplicityCutMask.size() == mNrof && !mMultiplicityCutMask[rof]) {
       continue;
@@ -270,7 +263,7 @@ void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, con
         h.bin = bin;
         h.ind = clsPerBin[bin]++;
       }
-      std::vector<int> lutPerBin(clsPerBin.size());
+      bounded_vector<int> lutPerBin(clsPerBin.size(), 0, mMemoryPool.get());
       lutPerBin[0] = 0;
       for (unsigned int iB{1}; iB < lutPerBin.size(); ++iB) {
         lutPerBin[iB] = lutPerBin[iB - 1] + clsPerBin[iB - 1];
@@ -286,7 +279,6 @@ void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, con
         c.radius = h.r;
         c.indexTableBinIndex = h.bin;
       }
-
       for (unsigned int iB{0}; iB < clsPerBin.size(); ++iB) {
         mIndexTables[iLayer][rof * (trkParam.ZBins * trkParam.PhiBins + 1) + iB] = lutPerBin[iB];
       }
@@ -307,37 +299,34 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     }
     deepVectorClear(mTracks);
     deepVectorClear(mTracksLabel);
+    deepVectorClear(mLines);
     deepVectorClear(mLinesLabels);
     if (resetVertices) {
       deepVectorClear(mVerticesMCRecInfo);
     }
-    mTracks.resize(mNrof);
-    mTracksLabel.resize(mNrof);
-    mLinesLabels.resize(mNrof);
-    mCells.resize(trkParam.CellsPerRoad());
-    mCellsLookupTable.resize(trkParam.CellsPerRoad() - 1);
-    mCellsNeighbours.resize(trkParam.CellsPerRoad() - 1);
-    mCellsNeighboursLUT.resize(trkParam.CellsPerRoad() - 1);
-    mCellLabels.resize(trkParam.CellsPerRoad());
-    mTracklets.resize(std::min(trkParam.TrackletsPerRoad(), maxLayers - 1));
-    mTrackletLabels.resize(trkParam.TrackletsPerRoad());
-    mTrackletsLookupTable.resize(trkParam.CellsPerRoad());
+    clearResizeBoundedVector(mTracks, mNrof, mMemoryPool.get());
+    clearResizeBoundedVector(mTracksLabel, mNrof, mMemoryPool.get());
+    clearResizeBoundedVector(mLinesLabels, mNrof, mMemoryPool.get());
+    clearResizeBoundedVector(mCells, trkParam.CellsPerRoad(), mMemoryPool.get());
+    clearResizeBoundedVector(mCellsLookupTable, trkParam.CellsPerRoad() - 1, mMemoryPool.get());
+    clearResizeBoundedVector(mCellsNeighbours, trkParam.CellsPerRoad() - 1, mMemoryPool.get());
+    clearResizeBoundedVector(mCellsNeighboursLUT, trkParam.CellsPerRoad() - 1, mMemoryPool.get());
+    clearResizeBoundedVector(mCellLabels, trkParam.CellsPerRoad(), mMemoryPool.get());
+    clearResizeBoundedVector(mTracklets, std::min(trkParam.TrackletsPerRoad(), maxLayers - 1), mMemoryPool.get());
+    clearResizeBoundedVector(mTrackletLabels, trkParam.TrackletsPerRoad(), mMemoryPool.get());
+    clearResizeBoundedVector(mTrackletsLookupTable, trkParam.TrackletsPerRoad(), mMemoryPool.get());
     mIndexTableUtils.setTrackingParameters(trkParam);
-    mPositionResolution.resize(trkParam.NLayers);
-    mBogusClusters.resize(trkParam.NLayers, 0);
-    deepVectorClear(mLines);
+    clearResizeBoundedVector(mPositionResolution, trkParam.NLayers, mMemoryPool.get());
+    clearResizeBoundedVector(mBogusClusters, trkParam.NLayers, mMemoryPool.get());
     deepVectorClear(mTrackletClusters);
     for (unsigned int iLayer{0}; iLayer < std::min((int)mClusters.size(), maxLayers); ++iLayer) {
-      deepVectorClear(mClusters[iLayer]);
-      mClusters[iLayer].resize(mUnsortedClusters[iLayer].size());
-      deepVectorClear(mUsedClusters[iLayer]);
-      mUsedClusters[iLayer].resize(mUnsortedClusters[iLayer].size(), false);
+      clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), mMemoryPool.get());
+      clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), mMemoryPool.get());
       mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5 * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
     }
-    deepVectorClear(mIndexTables);
-    mIndexTables.resize(mClusters.size(), std::vector<int>(mNrof * (trkParam.ZBins * trkParam.PhiBins + 1), 0));
-    mLines.resize(mNrof);
-    mTrackletClusters.resize(mNrof);
+    clearResizeBoundedArray(mIndexTables, mNrof * (trkParam.ZBins * trkParam.PhiBins + 1), mMemoryPool.get());
+    clearResizeBoundedVector(mLines, mNrof, mMemoryPool.get());
+    clearResizeBoundedVector(mTrackletClusters, mNrof, mMemoryPool.get());
 
     for (int iLayer{0}; iLayer < trkParam.NLayers; ++iLayer) {
       if (trkParam.SystErrorY2[iLayer] > 0.f || trkParam.SystErrorZ2[iLayer] > 0.f) {
@@ -351,7 +340,7 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
   }
   mNTrackletsPerROF.resize(2);
   for (auto& v : mNTrackletsPerROF) {
-    v = std::vector<int>(mNrof + 1, 0);
+    v = bounded_vector<int>(mNrof + 1, 0, mMemoryPool.get());
   }
   if (iteration == 0 || iteration == 3) {
     prepareClusters(trkParam, maxLayers);
@@ -360,7 +349,7 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
   if (maxLayers < trkParam.NLayers) { // Vertexer only, but in both iterations
     for (size_t iLayer{0}; iLayer < maxLayers; ++iLayer) {
       deepVectorClear(mUsedClusters[iLayer]);
-      mUsedClusters[iLayer].resize(mUnsortedClusters[iLayer].size(), false);
+      clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), mMemoryPool.get());
     }
   }
 
@@ -408,7 +397,7 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
 }
 
 template <int nLayers>
-unsigned long TimeFrame<nLayers>::getArtefactsMemory()
+unsigned long TimeFrame<nLayers>::getArtefactsMemory() const
 {
   unsigned long size{0};
   for (auto& trkl : mTracklets) {
@@ -423,6 +412,12 @@ unsigned long TimeFrame<nLayers>::getArtefactsMemory()
   return size + sizeof(Road<nLayers - 2>) * mRoads.size();
 }
 
+template <int nLayers>
+void TimeFrame<nLayers>::printArtefactsMemory() const
+{
+  LOGP(info, "TimeFrame: Artefacts occupy {:.2f} MB", getArtefactsMemory() / constants::MB);
+}
+
 template <int nLayers>
 void TimeFrame<nLayers>::fillPrimaryVerticesXandAlpha()
 {
@@ -501,6 +496,15 @@ void TimeFrame<nLayers>::resetVectors()
   }
 }
 
+template <int nLayers>
+void TimeFrame<nLayers>::resetTracklets()
+{
+  for (auto& trkl : mTracklets) {
+    deepVectorClear(trkl);
+  }
+  deepVectorClear(mTrackletsLookupTable);
+}
+
 template <int nLayers>
 void TimeFrame<nLayers>::printTrackletLUTonLayer(int i)
 {
@@ -598,6 +602,106 @@ void TimeFrame<nLayers>::printSliceInfo(const int startROF, const int sliceSize)
   }
 }
 
+template <int nLayers>
+void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool)
+{
+  wipe();
+  mMemoryPool = pool;
+
+  auto initVector = [&]<typename T>(bounded_vector<T>& vec) {
+    auto alloc = vec.get_allocator().resource();
+    if (alloc != mMemoryPool.get()) {
+      vec = bounded_vector<T>(mMemoryPool.get());
+    }
+  };
+  auto initArrays = [&]<typename T, size_t S>(std::array<bounded_vector<T>, S>& arr) {
+    for (size_t i{0}; i < S; ++i) {
+      auto alloc = arr[i].get_allocator().resource();
+      if (alloc != mMemoryPool.get()) {
+        arr[i] = bounded_vector<T>(mMemoryPool.get());
+      }
+    }
+  };
+  auto initVectors = [&]<typename T>(std::vector<bounded_vector<T>>& vec) {
+    for (size_t i{0}; i < vec.size(); ++i) {
+      auto alloc = vec[i].get_allocator().resource();
+      if (alloc != mMemoryPool.get()) {
+        vec[i] = bounded_vector<T>(mMemoryPool.get());
+      }
+    }
+  };
+
+  initVector(mTotVertPerIteration);
+  initVector(mPrimaryVertices);
+  initVector(mROFramesPV);
+  initArrays(mClusters);
+  initArrays(mTrackingFrameInfo);
+  initArrays(mClusterExternalIndices);
+  initArrays(mROFramesClusters);
+  initArrays(mNTrackletsPerCluster);
+  initArrays(mNTrackletsPerClusterSum);
+  initArrays(mNClustersPerROF);
+  initArrays(mIndexTables);
+  initArrays(mUsedClusters);
+  initArrays(mUnsortedClusters);
+  initVector(mROFramesPV);
+  initVector(mPrimaryVertices);
+  initVector(mRoads);
+  initVector(mRoadLabels);
+  initVector(mMSangles);
+  initVector(mPhiCuts);
+  initVector(mPositionResolution);
+  initVector(mClusterSize);
+  initVector(mPValphaX);
+  initVector(mBogusClusters);
+  initArrays(mTrackletsIndexROF);
+  initVectors(mTracks);
+  initVectors(mTracklets);
+  initVectors(mCells);
+  initVectors(mCellSeeds);
+  initVectors(mCellSeedsChi2);
+  initVectors(mCellsNeighbours);
+  initVectors(mCellsLookupTable);
+}
+
+template <int nLayers>
+void TimeFrame<nLayers>::wipe()
+{
+  deepVectorClear(mUnsortedClusters);
+  deepVectorClear(mTracks);
+  deepVectorClear(mTracklets);
+  deepVectorClear(mCells);
+  deepVectorClear(mCellSeeds);
+  deepVectorClear(mCellSeedsChi2);
+  deepVectorClear(mRoads);
+  deepVectorClear(mCellsNeighbours);
+  deepVectorClear(mCellsLookupTable);
+  deepVectorClear(mTotVertPerIteration);
+  deepVectorClear(mPrimaryVertices);
+  deepVectorClear(mROFramesPV);
+  deepVectorClear(mClusters);
+  deepVectorClear(mTrackingFrameInfo);
+  deepVectorClear(mClusterExternalIndices);
+  deepVectorClear(mROFramesClusters);
+  deepVectorClear(mNTrackletsPerCluster);
+  deepVectorClear(mNTrackletsPerClusterSum);
+  deepVectorClear(mNClustersPerROF);
+  deepVectorClear(mIndexTables);
+  deepVectorClear(mUsedClusters);
+  deepVectorClear(mUnsortedClusters);
+  deepVectorClear(mROFramesPV);
+  deepVectorClear(mPrimaryVertices);
+  deepVectorClear(mRoads);
+  deepVectorClear(mRoadLabels);
+  deepVectorClear(mMSangles);
+  deepVectorClear(mPhiCuts);
+  deepVectorClear(mPositionResolution);
+  deepVectorClear(mClusterSize);
+  deepVectorClear(mPValphaX);
+  deepVectorClear(mBogusClusters);
+  deepVectorClear(mTrackletsIndexROF);
+}
+
 template class TimeFrame<7>;
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index c452e20f7f707..e354792620436 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -15,6 +15,7 @@
 
 #include "ITStracking/Tracker.h"
 
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/Cell.h"
 #include "ITStracking/Constants.h"
 #include "ITStracking/IndexTableUtils.h"
@@ -53,90 +54,96 @@ void Tracker::clustersToTracks(LogFunc logger, LogFunc error)
     }
   }
 
-  bool dropTF = false;
-  for (int iteration = 0; iteration < (int)mTrkParams.size(); ++iteration) {
-    if (iteration == 3 && mTrkParams[0].DoUPCIteration) {
-      mTimeFrame->swapMasks();
+  int iteration{0}, iROFs{0}, iVertex{0};
+  auto handleException = [&](const auto& err) {
+    LOGP(error, "Too much memory used during {} in iteration {} in ROF span {}-{} iVtx={}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
+         StateNames[mCurState], iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, iVertex,
+         (double)mTimeFrame->getArtefactsMemory() / GB, (double)mTrkParams[iteration].MaxMemory / GB);
+    LOGP(error, "Exception: {}", err.what());
+    if (mTrkParams[iteration].DropTFUponFailure) {
+      mTimeFrame->wipe();
+      mMemoryPool->print();
+      ++mNumberOfDroppedTFs;
+      error("...Dropping Timeframe...");
+    } else {
+      throw err;
     }
-    double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
-    int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
-    int nROFsIterations = mTrkParams[iteration].nROFsPerIterations > 0 ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
-    int iVertex{std::min(maxNvertices, 0)};
-    logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
-
-    total += evaluateTask(&Tracker::initialiseTimeFrame, "Timeframe initialisation", logger, iteration);
-    do {
-      for (int iROFs{0}; iROFs < nROFsIterations; ++iROFs) {
-        timeTracklets += evaluateTask(&Tracker::computeTracklets, "Tracklet finding", evalLog, iteration, iROFs, iVertex);
-        nTracklets += mTraits->getTFNumberOfTracklets();
-        if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
-          mTimeFrame->printSliceInfo(iROFs, mTrkParams[iteration].nROFsPerIterations);
-          error(std::format("Too much memory used during trackleting in iteration {} in ROF span {}-{}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
-                            iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTimeFrame->getArtefactsMemory() / GB, mTrkParams[iteration].MaxMemory / GB));
-          if (mTrkParams[iteration].DropTFUponFailure) {
-            dropTF = true;
-          }
-          break;
-        }
-        float trackletsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfTracklets()) / mTraits->getTFNumberOfClusters() : 0.f;
-        if (trackletsPerCluster > mTrkParams[iteration].TrackletsPerClusterLimit) {
-          error(std::format("Too many tracklets per cluster ({}) in iteration {} in ROF span {}-{}:, check the detector status and/or the selections. Current limit is {}",
-                            trackletsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].TrackletsPerClusterLimit));
-          break;
-        }
+  };
 
-        timeCells += evaluateTask(&Tracker::computeCells, "Cell finding", evalLog, iteration);
-        nCells += mTraits->getTFNumberOfCells();
-        if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
-          mTimeFrame->printSliceInfo(iROFs, mTrkParams[iteration].nROFsPerIterations);
-          error(std::format("Too much memory used during cell finding in iteration {} in ROF span {}-{}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
-                            iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTimeFrame->getArtefactsMemory() / GB, mTrkParams[iteration].MaxMemory / GB));
-          if (mTrkParams[iteration].DropTFUponFailure) {
-            dropTF = true;
+  try {
+    for (iteration = 0; iteration < (int)mTrkParams.size(); ++iteration) {
+      mMemoryPool->setMaxMemory(mTrkParams[iteration].MaxMemory);
+      if (iteration == 3 && mTrkParams[0].DoUPCIteration) {
+        mTimeFrame->swapMasks();
+      }
+      double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
+      int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
+      int nROFsIterations = mTrkParams[iteration].nROFsPerIterations > 0 ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
+      int iVertex{std::min(maxNvertices, 0)};
+      logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
+
+      total += evaluateTask(&Tracker::initialiseTimeFrame, StateNames[mCurState = TFInit], iteration, logger, iteration);
+      do {
+        for (iROFs = 0; iROFs < nROFsIterations; ++iROFs) {
+          timeTracklets += evaluateTask(&Tracker::computeTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration, iROFs, iVertex);
+          nTracklets += mTraits->getTFNumberOfTracklets();
+          float trackletsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfTracklets()) / float(mTraits->getTFNumberOfClusters()) : 0.f;
+          if (trackletsPerCluster > mTrkParams[iteration].TrackletsPerClusterLimit) {
+            error(std::format("Too many tracklets per cluster ({}) in iteration {} in ROF span {}-{}:, check the detector status and/or the selections. Current limit is {}",
+                              trackletsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].TrackletsPerClusterLimit));
+            break;
           }
-          break;
-        }
-        float cellsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfCells()) / mTraits->getTFNumberOfClusters() : 0.f;
-        if (cellsPerCluster > mTrkParams[iteration].CellsPerClusterLimit) {
-          error(std::format("Too many cells per cluster ({}) in iteration {} in ROF span {}-{}, check the detector status and/or the selections. Current limit is {}",
-                            cellsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].CellsPerClusterLimit));
-          break;
+          timeCells += evaluateTask(&Tracker::computeCells, StateNames[mCurState = Celling], iteration, evalLog, iteration);
+          nCells += mTraits->getTFNumberOfCells();
+          float cellsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfCells()) / float(mTraits->getTFNumberOfClusters()) : 0.f;
+          if (cellsPerCluster > mTrkParams[iteration].CellsPerClusterLimit) {
+            error(std::format("Too many cells per cluster ({}) in iteration {} in ROF span {}-{}, check the detector status and/or the selections. Current limit is {}",
+                              cellsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].CellsPerClusterLimit));
+            break;
+          }
+          timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, StateNames[mCurState = Neighbouring], iteration, evalLog, iteration);
+          nNeighbours += mTimeFrame->getNumberOfNeighbours();
+          timeRoads += evaluateTask(&Tracker::findRoads, StateNames[mCurState = Roading], iteration, evalLog, iteration);
         }
-
-        timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, "Neighbour finding", evalLog, iteration);
-        nNeighbours += mTimeFrame->getNumberOfNeighbours();
-        timeRoads += evaluateTask(&Tracker::findRoads, "Road finding", evalLog, iteration);
+        iVertex++;
+      } while (iVertex < maxNvertices);
+      logger(std::format(" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
+      logger(std::format(" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
+      logger(std::format(" - Neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
+      logger(std::format(" - Track finding: {} tracks found in {:.2f} ms", nTracks + mTimeFrame->getNumberOfTracks(), timeRoads));
+      total += timeTracklets + timeCells + timeNeighbours + timeRoads;
+      if (mTraits->supportsExtendTracks() && mTrkParams[iteration].UseTrackFollower) {
+        int nExtendedTracks{-mTimeFrame->mNExtendedTracks}, nExtendedClusters{-mTimeFrame->mNExtendedUsedClusters};
+        auto timeExtending = evaluateTask(&Tracker::extendTracks, "Extending tracks", iteration, evalLog, iteration);
+        total += timeExtending;
+        logger(std::format(" - Extending Tracks: {} extended tracks using {} clusters found in {:.2f} ms", nExtendedTracks + mTimeFrame->mNExtendedTracks, nExtendedClusters + mTimeFrame->mNExtendedUsedClusters, timeExtending));
       }
-      iVertex++;
-    } while (iVertex < maxNvertices && !dropTF);
-    logger(std::format(" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
-    logger(std::format(" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
-    logger(std::format(" - Neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
-    logger(std::format(" - Track finding: {} tracks found in {:.2f} ms", nTracks + mTimeFrame->getNumberOfTracks(), timeRoads));
-    total += timeTracklets + timeCells + timeNeighbours + timeRoads;
-    if (mTraits->supportsExtendTracks() && mTrkParams[iteration].UseTrackFollower && !dropTF) {
-      int nExtendedTracks{-mTimeFrame->mNExtendedTracks}, nExtendedClusters{-mTimeFrame->mNExtendedUsedClusters};
-      auto timeExtending = evaluateTask(&Tracker::extendTracks, "Extending tracks", [](const std::string&) {}, iteration);
-      total += timeExtending;
-      logger(std::format(" - Extending Tracks: {} extended tracks using {} clusters found in {:.2f} ms", nExtendedTracks + mTimeFrame->mNExtendedTracks, nExtendedClusters + mTimeFrame->mNExtendedUsedClusters, timeExtending));
     }
-    if (dropTF) {
-      error("...Dropping Timeframe...");
-      mTimeFrame->dropTracks();
-      ++mNumberOfDroppedTFs;
-      return;
+    if (mTraits->supportsFindShortPrimaries() && mTrkParams[0].FindShortTracks) {
+      auto nTracksB = mTimeFrame->getNumberOfTracks();
+      total += evaluateTask(&Tracker::findShortPrimaries, "Short primaries finding", 0, logger);
+      auto nTracksA = mTimeFrame->getNumberOfTracks();
+      logger(std::format("  `-> found {} additional tracks", nTracksA - nTracksB));
     }
+    if (mTrkParams[iteration].PrintMemory) {
+      mMemoryPool->print();
+    }
+    if constexpr (constants::DoTimeBenchmarks) {
+      logger(std::format("=== TimeFrame {} processing completed in: {:.2f} ms using {} thread(s) ===", mTimeFrameCounter, total, mTraits->getNThreads()));
+    }
+  } catch (const BoundedMemoryResource::MemoryLimitExceeded& err) {
+    handleException(err);
+    return;
+  } catch (const std::bad_alloc& err) {
+    handleException(err);
+    return;
+  } catch (...) {
+    error("Uncaught exception, all bets are off...");
   }
 
-  if (mTraits->supportsFindShortPrimaries() && mTrkParams[0].FindShortTracks) {
-    auto nTracksB = mTimeFrame->getNumberOfTracks();
-    total += evaluateTask(&Tracker::findShortPrimaries, "Short primaries finding", logger);
-    auto nTracksA = mTimeFrame->getNumberOfTracks();
-    logger(std::format("  `-> found {} additional tracks", nTracksA - nTracksB));
-  }
-
-  if constexpr (constants::DoTimeBenchmarks) {
-    logger(std::format("=== TimeFrame {} processing completed in: {:.2f} ms using {} thread(s) ===", mTimeFrameCounter, total, mTraits->getNThreads()));
+  if (mTrkParams[0].PrintMemory) {
+    mTimeFrame->printArtefactsMemory();
+    mMemoryPool->print();
   }
 
   if (mTimeFrame->hasMCinformation()) {
@@ -398,7 +405,9 @@ void Tracker::adoptTimeFrame(TimeFrame7& tf)
 
 void Tracker::printSummary() const
 {
-  LOGP(info, "Tracker summary: Processed {} TFs (dropped {}) in TOT={:.2f} s, AVG/TF={:.2f} s", mTimeFrameCounter, mNumberOfDroppedTFs, mTotalTime * 1.e-3, mTotalTime * 1.e-3 / ((mTimeFrameCounter > 0) ? (double)mTimeFrameCounter : -1.0));
+  auto avgTF = mTotalTime * 1.e-3 / ((mTimeFrameCounter > 0) ? (double)mTimeFrameCounter : -1.0);
+  auto avgTFwithDropped = mTotalTime * 1.e-3 / (((mTimeFrameCounter + mNumberOfDroppedTFs) > 0) ? (double)(mTimeFrameCounter + mNumberOfDroppedTFs) : -1.0);
+  LOGP(info, "Tracker summary: Processed {} TFs (dropped {}) in TOT={:.2f} s, AVG/TF={:.2f} ({:.2f}) s", mTimeFrameCounter, mNumberOfDroppedTFs, mTotalTime * 1.e-3, avgTF, avgTFwithDropped);
 }
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index da0eeb52156be..97a679689e4a9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -12,9 +12,6 @@
 /// \file TrackerTraits.cxx
 /// \brief
 ///
-
-#include "ITStracking/TrackerTraits.h"
-
 #include <algorithm>
 #include <cassert>
 #include <iostream>
@@ -23,19 +20,20 @@
 #include <format>
 #endif
 
+#include <oneapi/tbb/combinable.h>
+#include <oneapi/tbb/parallel_sort.h>
+
 #include "CommonConstants/MathConstants.h"
 #include "DetectorsBase/Propagator.h"
 #include "GPUCommonMath.h"
 #include "ITStracking/Cell.h"
 #include "ITStracking/Constants.h"
+#include "ITStracking/TrackerTraits.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/Tracklet.h"
 #include "ReconstructionDataFormats/Track.h"
 
-#ifdef WITH_OPENMP
-#include <omp.h>
-#endif
-
 using o2::base::PropagatorF;
 
 namespace
@@ -78,168 +76,168 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
     const int endVtx{iVertex >= 0 ? o2::gpu::CAMath::Min(iVertex + 1, static_cast<int>(primaryVertices.size())) : static_cast<int>(primaryVertices.size())};
     int minRof = o2::gpu::CAMath::Max(startROF, rof0 - mTrkParams[iteration].DeltaROF);
     int maxRof = o2::gpu::CAMath::Min(endROF - 1, rof0 + mTrkParams[iteration].DeltaROF);
-#pragma omp parallel for num_threads(mNThreads)
-    for (int iLayer = 0; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
-      gsl::span<const Cluster> layer0 = mTimeFrame->getClustersOnLayer(rof0, iLayer);
-      if (layer0.empty()) {
-        continue;
-      }
-      float meanDeltaR{mTrkParams[iteration].LayerRadii[iLayer + 1] - mTrkParams[iteration].LayerRadii[iLayer]};
 
-      const int currentLayerClustersNum{static_cast<int>(layer0.size())};
-      for (int iCluster{0}; iCluster < currentLayerClustersNum; ++iCluster) {
-        const Cluster& currentCluster{layer0[iCluster]};
-        const int currentSortedIndex{mTimeFrame->getSortedIndex(rof0, iLayer, iCluster)};
-
-        if (mTimeFrame->isClusterUsed(iLayer, currentCluster.clusterId)) {
-          continue;
-        }
-        const float inverseR0{1.f / currentCluster.radius};
-
-        for (int iV{startVtx}; iV < endVtx; ++iV) {
-          auto& primaryVertex{primaryVertices[iV]};
-          if (primaryVertex.isFlagSet(2) && iteration != 3) {
-            continue;
-          }
-          const float resolution = o2::gpu::CAMath::Sqrt(Sq(mTrkParams[iteration].PVres) / primaryVertex.getNContributors() + Sq(mTimeFrame->getPositionResolution(iLayer)));
+    mTaskArena.execute([&] {
+      tbb::parallel_for(
+        tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
+        [&](const tbb::blocked_range<int>& Layers) {
+          for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
+            gsl::span<const Cluster> layer0 = mTimeFrame->getClustersOnLayer(rof0, iLayer);
+            if (layer0.empty()) {
+              continue;
+            }
+            float meanDeltaR{mTrkParams[iteration].LayerRadii[iLayer + 1] - mTrkParams[iteration].LayerRadii[iLayer]};
 
-          const float tanLambda{(currentCluster.zCoordinate - primaryVertex.getZ()) * inverseR0};
+            const int currentLayerClustersNum{static_cast<int>(layer0.size())};
+            for (int iCluster{0}; iCluster < currentLayerClustersNum; ++iCluster) {
+              const Cluster& currentCluster{layer0[iCluster]};
+              const int currentSortedIndex{mTimeFrame->getSortedIndex(rof0, iLayer, iCluster)};
 
-          const float zAtRmin{tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
-          const float zAtRmax{tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
+              if (mTimeFrame->isClusterUsed(iLayer, currentCluster.clusterId)) {
+                continue;
+              }
+              const float inverseR0{1.f / currentCluster.radius};
 
-          const float sqInverseDeltaZ0{1.f / (Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
-          const float sigmaZ{o2::gpu::CAMath::Sqrt(Sq(resolution) * Sq(tanLambda) * ((Sq(inverseR0) + sqInverseDeltaZ0) * Sq(meanDeltaR) + 1.f) + Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)))};
+              for (int iV{startVtx}; iV < endVtx; ++iV) {
+                auto& primaryVertex{primaryVertices[iV]};
+                if (primaryVertex.isFlagSet(2) && iteration != 3) {
+                  continue;
+                }
+                const float resolution = o2::gpu::CAMath::Sqrt(Sq(mTrkParams[iteration].PVres) / primaryVertex.getNContributors() + Sq(mTimeFrame->getPositionResolution(iLayer)));
 
-          const int4 selectedBinsRect{getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer))};
-          if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
-            continue;
-          }
+                const float tanLambda{(currentCluster.zCoordinate - primaryVertex.getZ()) * inverseR0};
 
-          int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
+                const float zAtRmin{tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
+                const float zAtRmax{tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
 
-          if (phiBinsNum < 0) {
-            phiBinsNum += mTrkParams[iteration].PhiBins;
-          }
+                const float sqInverseDeltaZ0{1.f / (Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
+                const float sigmaZ{o2::gpu::CAMath::Sqrt(Sq(resolution) * Sq(tanLambda) * ((Sq(inverseR0) + sqInverseDeltaZ0) * Sq(meanDeltaR) + 1.f) + Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)))};
 
-          for (int rof1{minRof}; rof1 <= maxRof; ++rof1) {
-            auto layer1 = mTimeFrame->getClustersOnLayer(rof1, iLayer + 1);
-            if (layer1.empty()) {
-              continue;
-            }
-            for (int iPhiCount{0}; iPhiCount < phiBinsNum; iPhiCount++) {
-              int iPhiBin = (selectedBinsRect.y + iPhiCount) % mTrkParams[iteration].PhiBins;
-              const int firstBinIndex{mTimeFrame->mIndexTableUtils.getBinIndex(selectedBinsRect.x, iPhiBin)};
-              const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
-              if constexpr (debugLevel) {
-                if (firstBinIndex < 0 || firstBinIndex > mTimeFrame->getIndexTable(rof1, iLayer + 1).size() ||
-                    maxBinIndex < 0 || maxBinIndex > mTimeFrame->getIndexTable(rof1, iLayer + 1).size()) {
-                  std::cout << iLayer << "\t" << iCluster << "\t" << zAtRmin << "\t" << zAtRmax << "\t" << sigmaZ * mTrkParams[iteration].NSigmaCut << "\t" << mTimeFrame->getPhiCut(iLayer) << std::endl;
-                  std::cout << currentCluster.zCoordinate << "\t" << primaryVertex.getZ() << "\t" << currentCluster.radius << std::endl;
-                  std::cout << mTimeFrame->getMinR(iLayer + 1) << "\t" << currentCluster.radius << "\t" << currentCluster.zCoordinate << std::endl;
-                  std::cout << "Illegal access to IndexTable " << firstBinIndex << "\t" << maxBinIndex << "\t" << selectedBinsRect.z << "\t" << selectedBinsRect.x << std::endl;
-                  exit(1);
-                }
-              }
-              const int firstRowClusterIndex = mTimeFrame->getIndexTable(rof1, iLayer + 1)[firstBinIndex];
-              const int maxRowClusterIndex = mTimeFrame->getIndexTable(rof1, iLayer + 1)[maxBinIndex];
-              for (int iNextCluster{firstRowClusterIndex}; iNextCluster < maxRowClusterIndex; ++iNextCluster) {
-                if (iNextCluster >= (int)layer1.size()) {
-                  break;
+                const int4 selectedBinsRect{getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer))};
+                if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
+                  continue;
                 }
 
-                const Cluster& nextCluster{layer1[iNextCluster]};
-                if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
-                  continue;
+                int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
+
+                if (phiBinsNum < 0) {
+                  phiBinsNum += mTrkParams[iteration].PhiBins;
                 }
 
-                const float deltaPhi{o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi)};
-                const float deltaZ{o2::gpu::GPUCommonMath::Abs(tanLambda * (nextCluster.radius - currentCluster.radius) +
-                                                               currentCluster.zCoordinate - nextCluster.zCoordinate)};
+                for (int rof1{minRof}; rof1 <= maxRof; ++rof1) {
+                  auto layer1 = mTimeFrame->getClustersOnLayer(rof1, iLayer + 1);
+                  if (layer1.empty()) {
+                    continue;
+                  }
+                  for (int iPhiCount{0}; iPhiCount < phiBinsNum; iPhiCount++) {
+                    int iPhiBin = (selectedBinsRect.y + iPhiCount) % mTrkParams[iteration].PhiBins;
+                    const int firstBinIndex{mTimeFrame->mIndexTableUtils.getBinIndex(selectedBinsRect.x, iPhiBin)};
+                    const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
+                    if constexpr (debugLevel) {
+                      if (firstBinIndex < 0 || firstBinIndex > mTimeFrame->getIndexTable(rof1, iLayer + 1).size() ||
+                          maxBinIndex < 0 || maxBinIndex > mTimeFrame->getIndexTable(rof1, iLayer + 1).size()) {
+                        std::cout << iLayer << "\t" << iCluster << "\t" << zAtRmin << "\t" << zAtRmax << "\t" << sigmaZ * mTrkParams[iteration].NSigmaCut << "\t" << mTimeFrame->getPhiCut(iLayer) << std::endl;
+                        std::cout << currentCluster.zCoordinate << "\t" << primaryVertex.getZ() << "\t" << currentCluster.radius << std::endl;
+                        std::cout << mTimeFrame->getMinR(iLayer + 1) << "\t" << currentCluster.radius << "\t" << currentCluster.zCoordinate << std::endl;
+                        std::cout << "Illegal access to IndexTable " << firstBinIndex << "\t" << maxBinIndex << "\t" << selectedBinsRect.z << "\t" << selectedBinsRect.x << std::endl;
+                        exit(1);
+                      }
+                    }
+                    const int firstRowClusterIndex = mTimeFrame->getIndexTable(rof1, iLayer + 1)[firstBinIndex];
+                    const int maxRowClusterIndex = mTimeFrame->getIndexTable(rof1, iLayer + 1)[maxBinIndex];
+                    for (int iNextCluster{firstRowClusterIndex}; iNextCluster < maxRowClusterIndex; ++iNextCluster) {
+                      if (iNextCluster >= (int)layer1.size()) {
+                        break;
+                      }
+
+                      const Cluster& nextCluster{layer1[iNextCluster]};
+                      if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
+                        continue;
+                      }
+
+                      const float deltaPhi{o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi)};
+                      const float deltaZ{o2::gpu::GPUCommonMath::Abs(tanLambda * (nextCluster.radius - currentCluster.radius) +
+                                                                     currentCluster.zCoordinate - nextCluster.zCoordinate)};
 
 #ifdef OPTIMISATION_OUTPUT
-                MCCompLabel label;
-                int currentId{currentCluster.clusterId};
-                int nextId{nextCluster.clusterId};
-                for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
-                  for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
-                    if (lab1 == lab2 && lab1.isValid()) {
-                      label = lab1;
-                      break;
-                    }
-                  }
-                  if (label.isValid()) {
-                    break;
-                  }
-                }
-                off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
+                      MCCompLabel label;
+                      int currentId{currentCluster.clusterId};
+                      int nextId{nextCluster.clusterId};
+                      for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
+                        for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
+                          if (lab1 == lab2 && lab1.isValid()) {
+                            label = lab1;
+                            break;
+                          }
+                        }
+                        if (label.isValid()) {
+                          break;
+                        }
+                      }
+                      off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
 #endif
 
-                if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
-                    (deltaPhi < mTimeFrame->getPhiCut(iLayer) ||
-                     o2::gpu::GPUCommonMath::Abs(deltaPhi - constants::math::TwoPi) < mTimeFrame->getPhiCut(iLayer))) {
-                  if (iLayer > 0) {
-                    mTimeFrame->getTrackletsLookupTable()[iLayer - 1][currentSortedIndex]++;
+                      if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
+                          (deltaPhi < mTimeFrame->getPhiCut(iLayer) ||
+                           o2::gpu::GPUCommonMath::Abs(deltaPhi - constants::math::TwoPi) < mTimeFrame->getPhiCut(iLayer))) {
+                        if (iLayer > 0) {
+                          mTimeFrame->getTrackletsLookupTable()[iLayer - 1][currentSortedIndex]++;
+                        }
+                        const float phi{o2::gpu::GPUCommonMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate,
+                                                                      currentCluster.xCoordinate - nextCluster.xCoordinate)};
+                        const float tanL{(currentCluster.zCoordinate - nextCluster.zCoordinate) /
+                                         (currentCluster.radius - nextCluster.radius)};
+                        mTimeFrame->getTracklets()[iLayer].emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(rof1, iLayer + 1, iNextCluster), tanL, phi, rof0, rof1);
+                      }
+                    }
                   }
-                  const float phi{o2::gpu::GPUCommonMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate,
-                                                                currentCluster.xCoordinate - nextCluster.xCoordinate)};
-                  const float tanL{(currentCluster.zCoordinate - nextCluster.zCoordinate) /
-                                   (currentCluster.radius - nextCluster.radius)};
-                  mTimeFrame->getTracklets()[iLayer].emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(rof1, iLayer + 1, iNextCluster), tanL, phi, rof0, rof1);
                 }
               }
             }
           }
-        }
-      }
-    }
-  }
-  if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
-    return;
-  }
-
-#pragma omp parallel for num_threads(mNThreads)
-  for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-    /// Sort tracklets
-    auto& trkl{mTimeFrame->getTracklets()[iLayer + 1]};
-    std::sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) {
-      return a.firstClusterIndex < b.firstClusterIndex || (a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex < b.secondClusterIndex);
+        });
     });
-    /// Remove duplicates
-    auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer]};
-    int id0{-1}, id1{-1};
-    std::vector<Tracklet> newTrk;
-    newTrk.reserve(trkl.size());
-    for (auto& trk : trkl) {
-      if (trk.firstClusterIndex == id0 && trk.secondClusterIndex == id1) {
-        lut[id0]--;
-      } else {
-        id0 = trk.firstClusterIndex;
-        id1 = trk.secondClusterIndex;
-        newTrk.push_back(trk);
-      }
-    }
-    trkl.swap(newTrk);
-
-    /// Compute LUT
-    std::exclusive_scan(lut.begin(), lut.end(), lut.begin(), 0);
-    lut.push_back(trkl.size());
   }
-  /// Layer 0 is done outside the loop
-  std::sort(mTimeFrame->getTracklets()[0].begin(), mTimeFrame->getTracklets()[0].end(), [](const Tracklet& a, const Tracklet& b) {
+
+  auto sortTracklets = [](const Tracklet& a, const Tracklet& b) -> bool {
     return a.firstClusterIndex < b.firstClusterIndex || (a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex < b.secondClusterIndex);
+  };
+  auto equalTracklets = [](const Tracklet& a, const Tracklet& b) -> bool {
+    return a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex == b.secondClusterIndex;
+  };
+
+  mTaskArena.execute([&] {
+    tbb::parallel_for(
+      tbb::blocked_range<int>(0, mTrkParams[iteration].CellsPerRoad()),
+      [&](const tbb::blocked_range<int>& Layers) {
+        for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
+          /// Sort tracklets
+          auto& trkl{mTimeFrame->getTracklets()[iLayer + 1]};
+          tbb::parallel_sort(trkl.begin(), trkl.end(), sortTracklets);
+          /// Remove duplicates
+          trkl.erase(std::unique(trkl.begin(), trkl.end(), equalTracklets), trkl.end());
+          trkl.shrink_to_fit();
+          /// recalculate lut
+          auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer]};
+          std::fill(lut.begin(), lut.end(), 0);
+          if (trkl.empty()) {
+            return;
+          }
+          for (const auto& tkl : trkl) {
+            lut[tkl.firstClusterIndex]++;
+          }
+          std::exclusive_scan(lut.begin(), lut.end(), lut.begin(), 0);
+          lut.push_back(trkl.size());
+        }
+      });
   });
-  int id0{-1}, id1{-1};
-  std::vector<Tracklet> newTrk;
-  newTrk.reserve(mTimeFrame->getTracklets()[0].size());
-  for (auto& trk : mTimeFrame->getTracklets()[0]) {
-    if (trk.firstClusterIndex != id0 || trk.secondClusterIndex != id1) {
-      id0 = trk.firstClusterIndex;
-      id1 = trk.secondClusterIndex;
-      newTrk.push_back(trk);
-    }
-  }
-  mTimeFrame->getTracklets()[0].swap(newTrk);
+
+  /// Layer 0 is done outside the loop
+  // in-place deduplication
+  auto& trklt0 = mTimeFrame->getTracklets()[0];
+  mTaskArena.execute([&] { tbb::parallel_sort(trklt0.begin(), trklt0.end(), sortTracklets); });
+  trklt0.erase(std::unique(trklt0.begin(), trklt0.end(), equalTracklets), trklt0.end());
+  trklt0.shrink_to_fit();
 
   /// Create tracklets labels
   if (mTimeFrame->hasMCinformation()) {
@@ -281,104 +279,107 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
     }
   }
 
-#pragma omp parallel for num_threads(mNThreads)
-  for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
+  mTaskArena.execute([&] {
+    tbb::parallel_for(
+      tbb::blocked_range<int>(0, mTrkParams[iteration].CellsPerRoad()),
+      [&](const tbb::blocked_range<int>& Layers) {
+        for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
 
-    if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
-        mTimeFrame->getTracklets()[iLayer].empty()) {
-      continue;
-    }
+          if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
+              mTimeFrame->getTracklets()[iLayer].empty()) {
+            continue;
+          }
 
 #ifdef OPTIMISATION_OUTPUT
-    float resolution{o2::gpu::CAMath::Sqrt(0.5f * (mTrkParams[iteration].SystErrorZ2[iLayer] + mTrkParams[iteration].SystErrorZ2[iLayer + 1] + mTrkParams[iteration].SystErrorZ2[iLayer + 2] + mTrkParams[iteration].SystErrorY2[iLayer] + mTrkParams[iteration].SystErrorY2[iLayer + 1] + mTrkParams[iteration].SystErrorY2[iLayer + 2])) / mTrkParams[iteration].LayerResolution[iLayer]};
-    resolution = resolution > 1.e-12 ? resolution : 1.f;
+          float resolution{o2::gpu::CAMath::Sqrt(0.5f * (mTrkParams[iteration].SystErrorZ2[iLayer] + mTrkParams[iteration].SystErrorZ2[iLayer + 1] + mTrkParams[iteration].SystErrorZ2[iLayer + 2] + mTrkParams[iteration].SystErrorY2[iLayer] + mTrkParams[iteration].SystErrorY2[iLayer + 1] + mTrkParams[iteration].SystErrorY2[iLayer + 2])) / mTrkParams[iteration].LayerResolution[iLayer]};
+          resolution = resolution > 1.e-12 ? resolution : 1.f;
 #endif
-    const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
-    for (int iTracklet{0}; iTracklet < currentLayerTrackletsNum; ++iTracklet) {
 
-      const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
-      const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
-      const int nextLayerFirstTrackletIndex{
-        mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
-      const int nextLayerLastTrackletIndex{
-        mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
+          const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
+          for (int iTracklet{0}; iTracklet < currentLayerTrackletsNum; ++iTracklet) {
 
-      if (nextLayerFirstTrackletIndex == nextLayerLastTrackletIndex) {
-        continue;
-      }
+            const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
+            const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
+            const int nextLayerFirstTrackletIndex{
+              mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
+            const int nextLayerLastTrackletIndex{
+              mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
 
-      for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
-        if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
-          break;
-        }
-        const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
-        const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
+            if (nextLayerFirstTrackletIndex == nextLayerLastTrackletIndex) {
+              continue;
+            }
+
+            for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
+              if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
+                break;
+              }
+              const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
+              const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
 
 #ifdef OPTIMISATION_OUTPUT
-        bool good{mTimeFrame->getTrackletsLabel(iLayer)[iTracklet] == mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
-        float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
-        off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
+              bool good{mTimeFrame->getTrackletsLabel(iLayer)[iTracklet] == mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
+              float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
+              off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
 #endif
 
-        if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
+              if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
 
-          /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
-          const int clusId[3]{
-            mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
-            mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
-            mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
-          const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer].at(clusId[0]);
-          const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1].at(clusId[1]);
-          const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2).at(clusId[2]);
-          auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
+                /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
+                const int clusId[3]{
+                  mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
+                  mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
+                  mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
+                const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer].at(clusId[0]);
+                const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1].at(clusId[1]);
+                const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2).at(clusId[2]);
+                auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
 
-          float chi2{0.f};
-          bool good{false};
-          for (int iC{2}; iC--;) {
-            const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC).at(clusId[iC]);
+                float chi2{0.f};
+                bool good{false};
+                for (int iC{2}; iC--;) {
+                  const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC).at(clusId[iC]);
 
-            if (!track.rotate(trackingHit.alphaTrackingFrame)) {
-              break;
-            }
+                  if (!track.rotate(trackingHit.alphaTrackingFrame)) {
+                    break;
+                  }
 
-            if (!track.propagateTo(trackingHit.xTrackingFrame, getBz())) {
-              break;
-            }
+                  if (!track.propagateTo(trackingHit.xTrackingFrame, getBz())) {
+                    break;
+                  }
 
-            constexpr float radl = 9.36f; // Radiation length of Si [cm]
-            constexpr float rho = 2.33f;  // Density of Si [g/cm^3]
-            if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * radl * rho, true)) {
-              break;
-            }
+                  constexpr float radl = 9.36f; // Radiation length of Si [cm]
+                  constexpr float rho = 2.33f;  // Density of Si [g/cm^3]
+                  if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * radl * rho, true)) {
+                    break;
+                  }
 
-            auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
-            if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
-              break;
-            }
-            if (!iC && predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
-              break;
+                  auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
+                  if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
+                    break;
+                  }
+                  if (!iC && predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
+                    break;
+                  }
+                  good = !iC;
+                  chi2 += predChi2;
+                }
+                if (!good) {
+                  continue;
+                }
+                if (iLayer > 0 && (int)mTimeFrame->getCellsLookupTable()[iLayer - 1].size() <= iTracklet) {
+                  mTimeFrame->getCellsLookupTable()[iLayer - 1].resize(iTracklet + 1, mTimeFrame->getCells()[iLayer].size());
+                }
+                mTimeFrame->getCells()[iLayer].emplace_back(iLayer, clusId[0], clusId[1], clusId[2],
+                                                            iTracklet, iNextTracklet, track, chi2);
+              }
             }
-            good = !iC;
-            chi2 += predChi2;
           }
-          if (!good) {
-            continue;
-          }
-          if (iLayer > 0 && (int)mTimeFrame->getCellsLookupTable()[iLayer - 1].size() <= iTracklet) {
-            mTimeFrame->getCellsLookupTable()[iLayer - 1].resize(iTracklet + 1, mTimeFrame->getCells()[iLayer].size());
+          if (iLayer > 0) {
+            mTimeFrame->getCellsLookupTable()[iLayer - 1].resize(currentLayerTrackletsNum + 1, mTimeFrame->getCells()[iLayer].size());
           }
-          mTimeFrame->getCells()[iLayer].emplace_back(iLayer, clusId[0], clusId[1], clusId[2],
-                                                      iTracklet, iNextTracklet, track, chi2);
         }
-      }
-    }
-    if (iLayer > 0) {
-      mTimeFrame->getCellsLookupTable()[iLayer - 1].resize(currentLayerTrackletsNum + 1, mTimeFrame->getCells()[iLayer].size());
-    }
-  }
-  if (!mTimeFrame->checkMemory(mTrkParams[iteration].MaxMemory)) {
-    return;
-  }
+      });
+  });
 
   /// Create cells labels
   if (mTimeFrame->hasMCinformation()) {
@@ -415,7 +416,7 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
     }
 
     int layerCellsNum{static_cast<int>(mTimeFrame->getCells()[iLayer].size())};
-    std::vector<std::pair<int, int>> cellsNeighbours;
+    bounded_vector<std::pair<int, int>> cellsNeighbours(mMemoryPool.get());
     cellsNeighbours.reserve(nextLayerCellsNum);
 
     for (int iCell{0}; iCell < layerCellsNum; ++iCell) {
@@ -467,13 +468,8 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
 }
 
 template <int nLayers>
-void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const std::vector<CellSeed>& currentCellSeed, const std::vector<int>& currentCellId, std::vector<CellSeed>& updatedCellSeeds, std::vector<int>& updatedCellsIds)
+void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeed>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
 {
-  bool print = iLayer == 3 && iLevel == 2;
-  if (iLevel < 2 || iLayer < 1) {
-    std::cout << "Error: layer " << iLayer << " or level " << iLevel << " cannot be processed by processNeighbours" << std::endl;
-    exit(1);
-  }
   CA_DEBUGGER(std::cout << "Processing neighbours layer " << iLayer << " level " << iLevel << ", size of the cell seeds: " << currentCellSeed.size() << std::endl);
   updatedCellSeeds.reserve(mTimeFrame->getCellsNeighboursLUT()[iLayer - 1].size()); /// This is not the correct value, we could do a loop to count the number of neighbours
   updatedCellsIds.reserve(updatedCellSeeds.size());
@@ -482,79 +478,98 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const std
   int failed[5]{0, 0, 0, 0, 0}, attempts{0}, failedByMismatch{0};
 #endif
 
-#pragma omp parallel for num_threads(mNThreads)
-  for (unsigned int iCell = 0; iCell < currentCellSeed.size(); ++iCell) {
-    const CellSeed& currentCell{currentCellSeed[iCell]};
-    if (currentCell.getLevel() != iLevel) {
-      continue;
-    }
-    if (currentCellId.empty() && (mTimeFrame->isClusterUsed(iLayer, currentCell.getFirstClusterIndex()) ||
-                                  mTimeFrame->isClusterUsed(iLayer + 1, currentCell.getSecondClusterIndex()) ||
-                                  mTimeFrame->isClusterUsed(iLayer + 2, currentCell.getThirdClusterIndex()))) {
-      continue; /// this we do only on the first iteration, hence the check on currentCellId
-    }
-    const int cellId = currentCellId.empty() ? iCell : currentCellId[iCell];
-    const int startNeighbourId{cellId ? mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId - 1] : 0};
-    const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId]};
-
-    for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
-      CA_DEBUGGER(attempts++);
-      const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
-      const CellSeed& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
-      if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
-        CA_DEBUGGER(failedByMismatch++);
-        continue;
-      }
-      if (mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex())) {
-        continue;
-      }
-      if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
-        CA_DEBUGGER(failed[0]++);
-        continue;
-      }
-      /// Let's start the fitting procedure
-      CellSeed seed{currentCell};
-      auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1).at(neighbourCell.getFirstClusterIndex());
+  mTaskArena.execute([&] {
+    // TODO better to use concurrent vector?
+    tbb::combinable<std::pair<bounded_vector<int>, bounded_vector<CellSeed>>> locUpdatedData([&] {
+      return std::make_pair(bounded_vector<int>(mMemoryPool.get()), bounded_vector<CellSeed>(mMemoryPool.get()));
+    });
 
-      if (!seed.rotate(trHit.alphaTrackingFrame)) {
-        CA_DEBUGGER(failed[1]++);
-        continue;
-      }
+    tbb::parallel_for(
+      tbb::blocked_range<int>(0, (int)currentCellSeed.size()),
+      [&](const tbb::blocked_range<int>& Cells) {
+        auto& [locUpdatedCellsIds, locUpdatedCellSeeds] = locUpdatedData.local();
 
-      if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
-        CA_DEBUGGER(failed[2]++);
-        continue;
-      }
+        for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
+          const CellSeed& currentCell{currentCellSeed[iCell]};
+          if (currentCell.getLevel() != iLevel) {
+            continue;
+          }
+          if (currentCellId.empty() && (mTimeFrame->isClusterUsed(iLayer, currentCell.getFirstClusterIndex()) ||
+                                        mTimeFrame->isClusterUsed(iLayer + 1, currentCell.getSecondClusterIndex()) ||
+                                        mTimeFrame->isClusterUsed(iLayer + 2, currentCell.getThirdClusterIndex()))) {
+            continue; /// this we do only on the first iteration, hence the check on currentCellId
+          }
+          const int cellId = currentCellId.empty() ? iCell : currentCellId[iCell];
+          const int startNeighbourId{cellId ? mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId - 1] : 0};
+          const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId]};
+
+          for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
+            CA_DEBUGGER(attempts++);
+            const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
+            const CellSeed& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
+            if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
+              CA_DEBUGGER(failedByMismatch++);
+              continue;
+            }
+            if (mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex())) {
+              continue;
+            }
+            if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
+              CA_DEBUGGER(failed[0]++);
+              continue;
+            }
+            /// Let's start the fitting procedure
+            CellSeed seed{currentCell};
+            auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1).at(neighbourCell.getFirstClusterIndex());
 
-      if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-        float radl = 9.36f; // Radiation length of Si [cm]
-        float rho = 2.33f;  // Density of Si [g/cm^3]
-        if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * radl * rho, true)) {
-          continue;
+            if (!seed.rotate(trHit.alphaTrackingFrame)) {
+              CA_DEBUGGER(failed[1]++);
+              continue;
+            }
+
+            if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
+              CA_DEBUGGER(failed[2]++);
+              continue;
+            }
+
+            if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+              float radl = 9.36f; // Radiation length of Si [cm]
+              float rho = 2.33f;  // Density of Si [g/cm^3]
+              if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * radl * rho, true)) {
+                continue;
+              }
+            }
+
+            auto predChi2{seed.getPredictedChi2Quiet(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)};
+            if ((predChi2 > mTrkParams[0].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
+              CA_DEBUGGER(failed[3]++);
+              continue;
+            }
+            seed.setChi2(seed.getChi2() + predChi2);
+            if (!seed.o2::track::TrackParCov::update(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)) {
+              CA_DEBUGGER(failed[4]++);
+              continue;
+            }
+            seed.getClusters()[iLayer - 1] = neighbourCell.getFirstClusterIndex();
+            seed.setLevel(neighbourCell.getLevel());
+            seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
+            seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
+
+            locUpdatedCellSeeds.push_back(seed);
+            locUpdatedCellsIds.push_back(neighbourCellId);
+          }
         }
-      }
+      });
+
+    locUpdatedData.combine_each([&](const auto& localData) {
+      const auto& [ids, seeds] = localData;
+      updatedCellsIds.insert(updatedCellsIds.begin(), ids.begin(), ids.end());
+      updatedCellSeeds.insert(updatedCellSeeds.begin(), seeds.begin(), seeds.end());
+    });
+  });
+  updatedCellSeeds.shrink_to_fit();
+  updatedCellsIds.shrink_to_fit();
 
-      auto predChi2{seed.getPredictedChi2Quiet(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)};
-      if ((predChi2 > mTrkParams[0].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
-        CA_DEBUGGER(failed[3]++);
-        continue;
-      }
-      seed.setChi2(seed.getChi2() + predChi2);
-      if (!seed.o2::track::TrackParCov::update(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)) {
-        CA_DEBUGGER(failed[4]++);
-        continue;
-      }
-      seed.getClusters()[iLayer - 1] = neighbourCell.getFirstClusterIndex();
-      seed.setLevel(neighbourCell.getLevel());
-      seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
-      seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
-#pragma omp critical
-      {
-        updatedCellsIds.push_back(neighbourCellId);
-        updatedCellSeeds.push_back(seed);
-      }
-    }
-  }
 #ifdef CA_DEBUG
   std::cout << "\t\t- Found " << updatedCellSeeds.size() << " cell seeds out of " << attempts << " attempts" << std::endl;
   std::cout << "\t\t\t> " << failed[0] << " failed because of level" << std::endl;
@@ -570,17 +585,17 @@ template <int nLayers>
 void TrackerTraits<nLayers>::findRoads(const int iteration)
 {
   CA_DEBUGGER(std::cout << "Finding roads, iteration " << iteration << std::endl);
+
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     CA_DEBUGGER(std::cout << "\t > Processing level " << startLevel << std::endl);
-    const int minimumLayer{startLevel - 1};
-    std::vector<CellSeed> trackSeeds;
-    for (int startLayer{mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= minimumLayer; --startLayer) {
+    bounded_vector<CellSeed> trackSeeds(mMemoryPool.get());
+    for (int startLayer{mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= startLevel - 1; --startLayer) {
       if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
       }
       CA_DEBUGGER(std::cout << "\t\t > Starting processing layer " << startLayer << std::endl);
-      std::vector<int> lastCellId, updatedCellId;
-      std::vector<CellSeed> lastCellSeed, updatedCellSeed;
+      bounded_vector<int> lastCellId(mMemoryPool.get()), updatedCellId(mMemoryPool.get());
+      bounded_vector<CellSeed> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
 
       processNeighbours(startLayer, startLevel, mTimeFrame->getCells()[startLayer], lastCellId, updatedCellSeed, updatedCellId);
 
@@ -588,47 +603,64 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
       for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
         lastCellSeed.swap(updatedCellSeed);
         lastCellId.swap(updatedCellId);
-        std::vector<CellSeed>().swap(updatedCellSeed); /// tame the memory peaks
-        updatedCellId.clear();
+        deepVectorClear(updatedCellSeed); /// tame the memory peaks
+        deepVectorClear(updatedCellId);   /// tame the memory peaks
         processNeighbours(iLayer, --level, lastCellSeed, lastCellId, updatedCellSeed, updatedCellId);
       }
-      for (auto& seed : updatedCellSeed) {
-        if (seed.getQ2Pt() > 1.e3 || seed.getChi2() > mTrkParams[0].MaxChi2NDF * ((startLevel + 2) * 2 - 5)) {
-          continue;
-        }
-        trackSeeds.push_back(seed);
-      }
+      std::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), std::back_inserter(trackSeeds), [&](const CellSeed& seed) {
+        return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[0].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
+      });
     }
 
-    std::vector<TrackITSExt> tracks(trackSeeds.size());
-    std::atomic<size_t> trackIndex{0};
-#pragma omp parallel for num_threads(mNThreads)
-    for (size_t seedId = 0; seedId < trackSeeds.size(); ++seedId) {
-      const CellSeed& seed{trackSeeds[seedId]};
-      TrackITSExt temporaryTrack{seed};
-      temporaryTrack.resetCovariance();
-      temporaryTrack.setChi2(0);
-      for (int iL{0}; iL < 7; ++iL) {
-        temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::its::UnusedIndex);
-      }
-
-      bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
-      if (!fitSuccess) {
-        continue;
-      }
-      temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
-      temporaryTrack.resetCovariance();
-      temporaryTrack.setChi2(0);
-      fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f);
-      if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
-        continue;
-      }
-      tracks[trackIndex++] = temporaryTrack;
+    if (trackSeeds.empty()) {
+      continue;
     }
 
-    tracks.resize(trackIndex);
-    std::sort(tracks.begin(), tracks.end(), [](const TrackITSExt& a, const TrackITSExt& b) {
-      return a.getChi2() < b.getChi2();
+    bounded_vector<TrackITSExt> tracks(mMemoryPool.get());
+    tracks.reserve(trackSeeds.size());
+    mTaskArena.execute([&] {
+      tbb::combinable<bounded_vector<TrackITSExt>> locTracksData([&] {
+        return bounded_vector<TrackITSExt>(mMemoryPool.get());
+      });
+
+      tbb::parallel_for(
+        tbb::blocked_range<size_t>(size_t(0), trackSeeds.size()),
+        [&](const tbb::blocked_range<size_t>& Seeds) {
+          for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
+            auto& localTracks = locTracksData.local();
+            localTracks.reserve(Seeds.size());
+
+            const CellSeed& seed{trackSeeds[iSeed]};
+            TrackITSExt temporaryTrack{seed};
+            temporaryTrack.resetCovariance();
+            temporaryTrack.setChi2(0);
+            for (int iL{0}; iL < 7; ++iL) {
+              temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::its::UnusedIndex);
+            }
+
+            bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
+            if (!fitSuccess) {
+              continue;
+            }
+            temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+            temporaryTrack.resetCovariance();
+            temporaryTrack.setChi2(0);
+            fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f);
+            if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
+              continue;
+            }
+            localTracks.push_back(temporaryTrack);
+          }
+        });
+
+      locTracksData.combine_each([&](const bounded_vector<TrackITSExt>& localTracks) {
+        tracks.insert(tracks.end(), localTracks.begin(), localTracks.end());
+      });
+      tracks.shrink_to_fit();
+
+      tbb::parallel_sort(tracks.begin(), tracks.end(), [](const auto& a, const auto& b) {
+        return a.getChi2() < b.getChi2();
+      });
     });
 
     for (auto& track : tracks) {
@@ -859,7 +891,7 @@ bool TrackerTraits<nLayers>::trackFollowing(TrackITSExt* track, int rof, bool ou
   auto propInstance = o2::base::Propagator::Instance();
   const int step = -1 + outward * 2;
   const int end = outward ? mTrkParams[iteration].NLayers - 1 : 0;
-  std::vector<TrackITSExt> hypotheses(1, *track); // possibly avoid reallocation
+  bounded_vector<TrackITSExt> hypotheses(1, *track, mMemoryPool.get()); // possibly avoid reallocation
   for (size_t iHypo{0}; iHypo < hypotheses.size(); ++iHypo) {
     auto hypo{hypotheses[iHypo]};
     int iLayer = static_cast<int>(outward ? hypo.getLastClusterLayer() : hypo.getFirstClusterLayer());
@@ -1017,11 +1049,15 @@ bool TrackerTraits<nLayers>::isMatLUT() const
 template <int nLayers>
 void TrackerTraits<nLayers>::setNThreads(int n)
 {
-#ifdef WITH_OPENMP
+  if (mNThreads == n && mTaskArena.is_active()) {
+    return;
+  }
   mNThreads = n > 0 ? n : 1;
-#else
-  mNThreads = 1;
+#if defined(OPTIMISATION_OUTPUT) || defined(CA_DEBUG)
+  mNThreads = 1; // only works while serial
 #endif
+  mTaskArena.initialize(mNThreads);
+  LOGP(info, "Setting tracker with {} threads.", mNThreads);
 }
 
 template class TrackerTraits<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index b3bdd62e072fd..0907253e24580 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -16,26 +16,27 @@
 #include "ITSReconstruction/FastMultEst.h"
 
 #include "ITStracking/TrackingInterface.h"
+#include <memory>
 
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "DataFormatsITSMFT/PhysTrigger.h"
 #include "DataFormatsTRD/TriggerRecord.h"
 #include "CommonDataFormat/IRFrame.h"
 #include "DetectorsBase/GRPGeomHelper.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/TrackingConfigParam.h"
 #include "Framework/DeviceSpec.h"
 
-namespace o2
-{
-using namespace framework;
-namespace its
-{
+using namespace o2::framework;
+using namespace o2::its;
+
 void ITSTrackingInterface::initialise()
 {
   mRunVertexer = true;
   mCosmicsProcessing = false;
   std::vector<VertexingParameters> vertParams;
   std::vector<TrackingParameters> trackParams;
+  const auto& vertConf = o2::its::VertexerParamConfig::Instance();
   const auto& trackConf = o2::its::TrackerParamConfig::Instance();
   float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791;
   float bFactorTracklets = bFactor < 0.01 ? 1. : bFactor; // for tracklets only
@@ -121,6 +122,18 @@ void ITSTrackingInterface::initialise()
     throw std::runtime_error(fmt::format("Unsupported ITS tracking mode {:s} ", asString(mMode)));
   }
 
+  // TODO this imposes the same memory limits on each iteration
+  for (auto& p : vertParams) {
+    p.PrintMemory = vertConf.printMemory;
+    p.MaxMemory = vertConf.maxMemory;
+    p.DropTFUponFailure = vertConf.dropTFUponFailure;
+  }
+  for (auto& p : trackParams) {
+    p.PrintMemory = trackConf.printMemory;
+    p.MaxMemory = trackConf.maxMemory;
+    p.DropTFUponFailure = trackConf.dropTFUponFailure;
+  }
+
   for (auto& params : trackParams) {
     params.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT;
   }
@@ -237,7 +250,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
         vMCRecInfo = mTimeFrame->getPrimaryVerticesMCRecInfo(iRof);
       }
       if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
-        if (vtxSpan.size()) {
+        if (!vtxSpan.empty()) {
           if (vtxSpan[0].isFlagSet(Vertex::UPCMode) == 1) { // at least one vertex in this ROF and it is from second vertex iteration
             LOGP(debug, "ROF {} rejected as vertices are from the UPC iteration", iRof);
             processUPCMask[iRof] = true;
@@ -253,7 +266,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
         vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
       }
       vtxROF.setNEntries(vtxSpan.size());
-      bool selROF = vtxSpan.size() == 0;
+      bool selROF = vtxSpan.empty();
       for (auto iV{0}; iV < vtxSpan.size(); ++iV) {
         auto& v = vtxSpan[iV];
         if (multEstConf.isVtxMultCutRequested() && !multEstConf.isPassingVtxMultCut(v.getNContributors())) {
@@ -272,7 +285,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
         cutVertexMult++;
       }
     } else { // cosmics
-      vtxVecLoc.emplace_back(Vertex());
+      vtxVecLoc.emplace_back();
       vtxVecLoc.back().setNContributors(1);
       vtxROF.setNEntries(vtxVecLoc.size());
       for (auto& v : vtxVecLoc) {
@@ -425,6 +438,7 @@ void ITSTrackingInterface::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 
 void ITSTrackingInterface::printSummary() const
 {
+  mMemoryPool->print();
   mTracker->printSummary();
 }
 
@@ -437,6 +451,16 @@ void ITSTrackingInterface::setTraitsFromProvider(VertexerTraits* vertexerTraits,
   mTimeFrame = frame;
   mVertexer->adoptTimeFrame(*mTimeFrame);
   mTracker->adoptTimeFrame(*mTimeFrame);
+
+  // set common memory resource
+  if (!mMemoryPool) {
+    mMemoryPool = std::make_shared<BoundedMemoryResource>();
+  }
+  vertexerTraits->setMemoryPool(mMemoryPool);
+  trackerTraits->setMemoryPool(mMemoryPool);
+  mTimeFrame->setMemoryPool(mMemoryPool);
+  mTracker->setMemoryPool(mMemoryPool);
+  mVertexer->setMemoryPool(mMemoryPool);
 }
 
 void ITSTrackingInterface::loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
@@ -446,5 +470,3 @@ void ITSTrackingInterface::loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
 {
   mTimeFrame->loadROFrameData(trackROFspan, clusters, pattIt, mDict, mcLabels);
 }
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 0b8d59f61eb8d..8ab8c1a9e2e3c 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -14,6 +14,7 @@
 ///
 
 #include "ITStracking/Vertexer.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/Cluster.h"
 #include "ITStracking/ROframe.h"
 #include "ITStracking/ClusterLines.h"
@@ -38,27 +39,46 @@ float Vertexer::clustersToVertices(LogFunc logger)
   TrackingParameters trkPars;
   TimeFrameGPUParameters tfGPUpar;
   mTraits->updateVertexingParameters(mVertParams, tfGPUpar);
+
+  auto handleException = [&](const auto& err) {
+    LOGP(error, "Encountered critical error in step {}, stopping further processing of this TF: {}", StateNames[mCurState], err.what());
+    if (!mVertParams[0].DropTFUponFailure) {
+      throw err;
+    } else {
+      LOGP(error, "Dropping this TF!");
+      mTimeFrame->resetTracklets();
+    }
+  };
+
   float timeTracklet{0.f}, timeSelection{0.f}, timeVertexing{0.f}, timeInit{0.f};
-  for (int iteration = 0; iteration < std::min(mVertParams[0].nIterations, (int)mVertParams.size()); ++iteration) {
-    unsigned int nTracklets01{0}, nTracklets12{0};
-    logger(fmt::format("=== ITS {} Seeding vertexer iteration {} summary:", mTraits->getName(), iteration));
-    trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
-    trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
-    auto timeInitIteration = evaluateTask(
-      &Vertexer::initialiseVertexer, " - Vertexer initialisation", evalLog, trkPars, iteration);
-    auto timeTrackletIteration = evaluateTask(
-      &Vertexer::findTracklets, " - Vertexer tracklet finding", evalLog, iteration);
-    nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
-    nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
-    auto timeSelectionIteration = evaluateTask(
-      &Vertexer::validateTracklets, " - Vertexer tracklets validation", evalLog, iteration);
-    auto timeVertexingIteration = evaluateTask(
-      &Vertexer::findVertices, " - Vertexer vertex finding", evalLog, iteration);
-    printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
-    timeInit += timeInitIteration;
-    timeTracklet += timeTrackletIteration;
-    timeSelection += timeSelectionIteration;
-    timeVertexing += timeVertexingIteration;
+  try {
+    for (int iteration = 0; iteration < std::min(mVertParams[0].nIterations, (int)mVertParams.size()); ++iteration) {
+      mMemoryPool->setMaxMemory(mVertParams[iteration].MaxMemory);
+      unsigned int nTracklets01{0}, nTracklets12{0};
+      logger(fmt::format("=== ITS {} Seeding vertexer iteration {} summary:", mTraits->getName(), iteration));
+      trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
+      trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
+      auto timeInitIteration = evaluateTask(
+        &Vertexer::initialiseVertexer, StateNames[mCurState = Init], iteration, evalLog, trkPars, iteration);
+      auto timeTrackletIteration = evaluateTask(
+        &Vertexer::findTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration);
+      nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
+      nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
+      auto timeSelectionIteration = evaluateTask(
+        &Vertexer::validateTracklets, StateNames[mCurState = Validating], iteration, evalLog, iteration);
+      auto timeVertexingIteration = evaluateTask(&Vertexer::findVertices, StateNames[mCurState = Finding], iteration, evalLog, iteration);
+      printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
+      timeInit += timeInitIteration;
+      timeTracklet += timeTrackletIteration;
+      timeSelection += timeSelectionIteration;
+      timeVertexing += timeVertexingIteration;
+    }
+  } catch (const BoundedMemoryResource::MemoryLimitExceeded& err) {
+    handleException(err);
+  } catch (const std::bad_alloc& err) {
+    handleException(err);
+  } catch (...) {
+    LOGP(fatal, "Uncaught exception!");
   }
 
   return timeInit + timeTracklet + timeSelection + timeVertexing;
@@ -91,6 +111,7 @@ void Vertexer::getGlobalConfiguration()
   mVertParams[0].nThreads = vc.nThreads;
   mVertParams[0].ZBins = vc.ZBins;
   mVertParams[0].PhiBins = vc.PhiBins;
+  mVertParams[0].SaveTimeBenchmarks = vc.saveTimeBenchmarks;
 }
 
 void Vertexer::adoptTimeFrame(TimeFrame7& tf)
@@ -108,7 +129,10 @@ void Vertexer::printEpilog(LogFunc& logger,
   logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
   logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {} ms", mTraits->getName(), selectedN, selecT));
   logger(fmt::format(" - {} Vertexer: found {} vertices in: {} ms", mTraits->getName(), vertexN, vertexT));
-  // logger(fmt::format(" - Timeframe {} vertexing completed in: {} ms, using {} thread(s).", mTimeFrameCounter++, total, mTraits->getNThreads()));
+  if (mVertParams[0].PrintMemory) {
+    mTimeFrame->printArtefactsMemory();
+    mMemoryPool->print();
+  }
 }
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 71b54d95d3f8d..6fd3d99ffe58d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -10,13 +10,15 @@
 // or submit itself to any jurisdiction.
 ///
 
-#include <boost/histogram.hpp>
-#include <boost/format.hpp>
 #include <iostream>
 #include <string>
 #include <chrono>
 
+#include <oneapi/tbb/blocked_range.h>
+#include <oneapi/tbb/parallel_for.h>
+
 #include "ITStracking/VertexerTraits.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/ClusterLines.h"
 #include "ITStracking/Tracklet.h"
 
@@ -27,16 +29,7 @@
 #include <ostream>
 #endif
 
-#ifdef WITH_OPENMP
-#include <omp.h>
-#endif
-
-namespace o2
-{
-namespace its
-{
-using boost::histogram::indexed;
-using constants::math::TwoPi;
+using namespace o2::its;
 
 float smallestAngleDifference(float a, float b)
 {
@@ -46,12 +39,12 @@ float smallestAngleDifference(float a, float b)
 
 template <TrackletMode Mode, bool EvalRun>
 void trackleterKernelHost(
-  const gsl::span<const Cluster>& clustersNextLayer,     // 0 2
-  const gsl::span<const Cluster>& clustersCurrentLayer,  // 1 1
-  const gsl::span<unsigned char>& usedClustersNextLayer, // 0 2
+  const gsl::span<const Cluster>& clustersNextLayer,    // 0 2
+  const gsl::span<const Cluster>& clustersCurrentLayer, // 1 1
+  const gsl::span<uint8_t>& usedClustersNextLayer,      // 0 2
   int* indexTableNext,
   const float phiCut,
-  std::vector<Tracklet>& tracklets,
+  bounded_vector<Tracklet>& tracklets,
   gsl::span<int> foundTracklets,
   const IndexTableUtils& utils,
   const short pivotRof,
@@ -112,12 +105,12 @@ void trackletSelectionKernelHost(
   gsl::span<unsigned char> usedClusters2,   // Layer 2
   const gsl::span<const Tracklet>& tracklets01,
   const gsl::span<const Tracklet>& tracklets12,
-  std::vector<bool>& usedTracklets,
+  bounded_vector<uint8_t>& usedTracklets,
   const gsl::span<int> foundTracklets01,
   const gsl::span<int> foundTracklets12,
-  std::vector<Line>& lines,
-  const gsl::span<const MCCompLabel>& trackletLabels,
-  std::vector<MCCompLabel>& linesLabels,
+  bounded_vector<Line>& lines,
+  const gsl::span<const o2::MCCompLabel>& trackletLabels,
+  bounded_vector<o2::MCCompLabel>& linesLabels,
   const short pivotRofId,
   const short targetRofId,
   const float tanLambdaCut = 0.025f,
@@ -141,7 +134,7 @@ void trackletSelectionKernelHost(
           usedClusters2[tracklet12.secondClusterIndex] = true;
           usedTracklets[iTracklet01] = true;
           lines.emplace_back(tracklet01, clusters0.data(), clusters1.data());
-          if (trackletLabels.size()) {
+          if (!trackletLabels.empty()) {
             linesLabels.emplace_back(trackletLabels[iTracklet01]);
           }
           ++validTracklets;
@@ -153,11 +146,11 @@ void trackletSelectionKernelHost(
   }
 }
 
-const std::vector<std::pair<int, int>> VertexerTraits::selectClusters(const int* indexTable,
-                                                                      const std::array<int, 4>& selectedBinsRect,
-                                                                      const IndexTableUtils& utils)
+const bounded_vector<std::pair<int, int>> VertexerTraits::selectClusters(const int* indexTable,
+                                                                         const std::array<int, 4>& selectedBinsRect,
+                                                                         const IndexTableUtils& utils)
 {
-  std::vector<std::pair<int, int>> filteredBins{};
+  bounded_vector<std::pair<int, int>> filteredBins{mMemoryPool.get()};
   int phiBinsNum{selectedBinsRect[3] - selectedBinsRect[1] + 1};
   if (phiBinsNum < 0) {
     phiBinsNum += utils.getNphiBins();
@@ -187,93 +180,98 @@ void VertexerTraits::updateVertexingParameters(const std::vector<VertexingParame
 // Main functions
 void VertexerTraits::computeTracklets(const int iteration)
 {
-#pragma omp parallel num_threads(mNThreads)
-  {
-#pragma omp for schedule(dynamic)
-    for (short pivotRofId = 0; pivotRofId < mTimeFrame->getNrof(); ++pivotRofId) { // Pivot rofId: the rof for which the tracklets are computed
-      bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
-      short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
-      short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-      for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
-        trackleterKernelHost<TrackletMode::Layer0Layer1, true>(
-          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(), // Clusters to be matched with the next layer in target rof
-          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),  // Clusters to be matched with the current layer in pivot rof
-          mTimeFrame->getUsedClustersROF(targetRofId, 0),                                   // Span of the used clusters in the target rof
-          mTimeFrame->getIndexTable(targetRofId, 0).data(),                                 // Index table to access the data on the next layer in target rof
-          mVrtParams[iteration].phiCut,
-          mTimeFrame->getTracklets()[0],                   // Flat tracklet buffer
-          mTimeFrame->getNTrackletsCluster(pivotRofId, 0), // Span of the number of tracklets per each cluster in pivot rof
-          mIndexTableUtils,
-          pivotRofId,
-          targetRofId,
-          gsl::span<int>(), // Offset in the tracklet buffer
-          mVrtParams[iteration].maxTrackletsPerCluster);
-        trackleterKernelHost<TrackletMode::Layer1Layer2, true>(
-          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
-          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
-          mTimeFrame->getUsedClustersROF(targetRofId, 2),
-          mTimeFrame->getIndexTable(targetRofId, 2).data(),
-          mVrtParams[iteration].phiCut,
-          mTimeFrame->getTracklets()[1],
-          mTimeFrame->getNTrackletsCluster(pivotRofId, 1), // Span of the number of tracklets per each cluster in pivot rof
-          mIndexTableUtils,
-          pivotRofId,
-          targetRofId,
-          gsl::span<int>(), // Offset in the tracklet buffer
-          mVrtParams[iteration].maxTrackletsPerCluster);
-      }
-      mTimeFrame->getNTrackletsROF(pivotRofId, 0) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 0).end(), 0);
-      mTimeFrame->getNTrackletsROF(pivotRofId, 1) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 1).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 1).end(), 0);
-    }
-#pragma omp single
-    mTimeFrame->computeTrackletsPerROFScans();
-#pragma omp single
-    mTimeFrame->getTracklets()[0].resize(mTimeFrame->getTotalTrackletsTF(0));
-#pragma omp single
-    mTimeFrame->getTracklets()[1].resize(mTimeFrame->getTotalTrackletsTF(1));
+  mTaskArena.execute([&] {
+    tbb::parallel_for(
+      tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
+      [&](const tbb::blocked_range<short>& Rofs) {
+        for (short pivotRofId = Rofs.begin(); pivotRofId < Rofs.end(); ++pivotRofId) {
+          bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
+          short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
+          short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
+          for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
+            trackleterKernelHost<TrackletMode::Layer0Layer1, true>(
+              !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(), // Clusters to be matched with the next layer in target rof
+              !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),  // Clusters to be matched with the current layer in pivot rof
+              mTimeFrame->getUsedClustersROF(targetRofId, 0),                                   // Span of the used clusters in the target rof
+              mTimeFrame->getIndexTable(targetRofId, 0).data(),                                 // Index table to access the data on the next layer in target rof
+              mVrtParams[iteration].phiCut,
+              mTimeFrame->getTracklets()[0],                   // Flat tracklet buffer
+              mTimeFrame->getNTrackletsCluster(pivotRofId, 0), // Span of the number of tracklets per each cluster in pivot rof
+              mIndexTableUtils,
+              pivotRofId,
+              targetRofId,
+              gsl::span<int>(), // Offset in the tracklet buffer
+              mVrtParams[iteration].maxTrackletsPerCluster);
+            trackleterKernelHost<TrackletMode::Layer1Layer2, true>(
+              !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
+              !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+              mTimeFrame->getUsedClustersROF(targetRofId, 2),
+              mTimeFrame->getIndexTable(targetRofId, 2).data(),
+              mVrtParams[iteration].phiCut,
+              mTimeFrame->getTracklets()[1],
+              mTimeFrame->getNTrackletsCluster(pivotRofId, 1), // Span of the number of tracklets per each cluster in pivot rof
+              mIndexTableUtils,
+              pivotRofId,
+              targetRofId,
+              gsl::span<int>(), // Offset in the tracklet buffer
+              mVrtParams[iteration].maxTrackletsPerCluster);
+          }
+          mTimeFrame->getNTrackletsROF(pivotRofId, 0) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 0).end(), 0);
+          mTimeFrame->getNTrackletsROF(pivotRofId, 1) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 1).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 1).end(), 0);
+        }
+      });
+  });
 
-#pragma omp for schedule(dynamic)
-    for (int pivotRofId = 0; pivotRofId < mTimeFrame->getNrof(); ++pivotRofId) {
-      bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
-      short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
-      short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-      auto mobileOffset0 = mTimeFrame->getNTrackletsROF(pivotRofId, 0);
-      auto mobileOffset1 = mTimeFrame->getNTrackletsROF(pivotRofId, 1);
-      for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
-        trackleterKernelHost<TrackletMode::Layer0Layer1, false>(
-          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(),
-          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
-          mTimeFrame->getUsedClustersROF(targetRofId, 0),
-          mTimeFrame->getIndexTable(targetRofId, 0).data(),
-          mVrtParams[iteration].phiCut,
-          mTimeFrame->getTracklets()[0],
-          mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
-          mIndexTableUtils,
-          pivotRofId,
-          targetRofId,
-          mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 0),
-          mVrtParams[iteration].maxTrackletsPerCluster);
-        trackleterKernelHost<TrackletMode::Layer1Layer2, false>(
-          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
-          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
-          mTimeFrame->getUsedClustersROF(targetRofId, 2),
-          mTimeFrame->getIndexTable(targetRofId, 2).data(),
-          mVrtParams[iteration].phiCut,
-          mTimeFrame->getTracklets()[1],
-          mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
-          mIndexTableUtils,
-          pivotRofId,
-          targetRofId,
-          mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 1),
-          mVrtParams[iteration].maxTrackletsPerCluster);
-      }
-    }
-  }
+  mTimeFrame->computeTrackletsPerROFScans();
+  mTimeFrame->getTracklets()[0].resize(mTimeFrame->getTotalTrackletsTF(0));
+  mTimeFrame->getTracklets()[1].resize(mTimeFrame->getTotalTrackletsTF(1));
+
+  mTaskArena.execute([&] {
+    tbb::parallel_for(
+      tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
+      [&](const tbb::blocked_range<short>& Rofs) {
+        for (short pivotRofId = Rofs.begin(); pivotRofId < Rofs.end(); ++pivotRofId) {
+          bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
+          short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
+          short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
+          auto mobileOffset0 = mTimeFrame->getNTrackletsROF(pivotRofId, 0);
+          auto mobileOffset1 = mTimeFrame->getNTrackletsROF(pivotRofId, 1);
+          for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
+            trackleterKernelHost<TrackletMode::Layer0Layer1, false>(
+              !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(),
+              !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+              mTimeFrame->getUsedClustersROF(targetRofId, 0),
+              mTimeFrame->getIndexTable(targetRofId, 0).data(),
+              mVrtParams[iteration].phiCut,
+              mTimeFrame->getTracklets()[0],
+              mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
+              mIndexTableUtils,
+              pivotRofId,
+              targetRofId,
+              mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 0),
+              mVrtParams[iteration].maxTrackletsPerCluster);
+            trackleterKernelHost<TrackletMode::Layer1Layer2, false>(
+              !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
+              !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+              mTimeFrame->getUsedClustersROF(targetRofId, 2),
+              mTimeFrame->getIndexTable(targetRofId, 2).data(),
+              mVrtParams[iteration].phiCut,
+              mTimeFrame->getTracklets()[1],
+              mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
+              mIndexTableUtils,
+              pivotRofId,
+              targetRofId,
+              mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 1),
+              mVrtParams[iteration].maxTrackletsPerCluster);
+          }
+        }
+      });
+  });
 
   /// Create tracklets labels for L0-L1, information is as flat as in tracklets vector (no rofId)
   if (mTimeFrame->hasMCinformation()) {
     for (auto& trk : mTimeFrame->getTracklets()[0]) {
-      MCCompLabel label;
+      o2::MCCompLabel label;
       int sortedId0{mTimeFrame->getSortedIndex(trk.rof[0], 0, trk.firstClusterIndex)};
       int sortedId1{mTimeFrame->getSortedIndex(trk.rof[1], 1, trk.secondClusterIndex)};
       for (auto& lab0 : mTimeFrame->getClusterLabels(0, mTimeFrame->getClusters()[0][sortedId0].clusterId)) {
@@ -333,39 +331,44 @@ void VertexerTraits::computeTracklets(const int iteration)
   out01.close();
   out12.close();
 #endif
-} // namespace its
+}
 
 void VertexerTraits::computeTrackletMatching(const int iteration)
 {
-#pragma omp parallel for num_threads(mNThreads) schedule(dynamic)
-  for (int pivotRofId = 0; pivotRofId < mTimeFrame->getNrof(); ++pivotRofId) {
-    if (iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold) {
-      continue;
-    }
-    mTimeFrame->getLines(pivotRofId).reserve(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).size());
-    std::vector<bool> usedTracklets(mTimeFrame->getFoundTracklets(pivotRofId, 0).size(), false);
-    int startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
-    int endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-    for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
-      trackletSelectionKernelHost(
-        mTimeFrame->getClustersOnLayer(targetRofId, 0),
-        mTimeFrame->getClustersOnLayer(pivotRofId, 1),
-        mTimeFrame->getUsedClustersROF(targetRofId, 0),
-        mTimeFrame->getUsedClustersROF(targetRofId, 2),
-        mTimeFrame->getFoundTracklets(pivotRofId, 0),
-        mTimeFrame->getFoundTracklets(pivotRofId, 1),
-        usedTracklets,
-        mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
-        mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
-        mTimeFrame->getLines(pivotRofId),
-        mTimeFrame->getLabelsFoundTracklets(pivotRofId, 0),
-        mTimeFrame->getLinesLabel(pivotRofId),
-        pivotRofId,
-        targetRofId,
-        mVrtParams[iteration].tanLambdaCut,
-        mVrtParams[iteration].phiCut);
-    }
-  }
+  mTaskArena.execute([&] {
+    tbb::parallel_for(
+      tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
+      [&](const tbb::blocked_range<short>& Rofs) {
+        for (short pivotRofId = Rofs.begin(); pivotRofId < Rofs.end(); ++pivotRofId) {
+          if (iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold) {
+            continue;
+          }
+          mTimeFrame->getLines(pivotRofId).reserve(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).size());
+          bounded_vector<uint8_t> usedTracklets(mTimeFrame->getFoundTracklets(pivotRofId, 0).size(), false, mMemoryPool.get());
+          short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
+          short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
+          for (short targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
+            trackletSelectionKernelHost(
+              mTimeFrame->getClustersOnLayer(targetRofId, 0),
+              mTimeFrame->getClustersOnLayer(pivotRofId, 1),
+              mTimeFrame->getUsedClustersROF(targetRofId, 0),
+              mTimeFrame->getUsedClustersROF(targetRofId, 2),
+              mTimeFrame->getFoundTracklets(pivotRofId, 0),
+              mTimeFrame->getFoundTracklets(pivotRofId, 1),
+              usedTracklets,
+              mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
+              mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
+              mTimeFrame->getLines(pivotRofId),
+              mTimeFrame->getLabelsFoundTracklets(pivotRofId, 0),
+              mTimeFrame->getLinesLabel(pivotRofId),
+              pivotRofId,
+              targetRofId,
+              mVrtParams[iteration].tanLambdaCut,
+              mVrtParams[iteration].phiCut);
+          }
+        }
+      });
+  });
 
 #ifdef VTX_DEBUG
   TFile* trackletFile = TFile::Open("artefacts_tf.root", "update");
@@ -401,19 +404,19 @@ void VertexerTraits::computeTrackletMatching(const int iteration)
 void VertexerTraits::computeVertices(const int iteration)
 {
   auto nsigmaCut{std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f)};
-  std::vector<Vertex> vertices;
-  std::vector<std::pair<o2::MCCompLabel, float>> polls;
+  bounded_vector<Vertex> vertices(mMemoryPool.get());
+  bounded_vector<std::pair<o2::MCCompLabel, float>> polls(mMemoryPool.get());
 #ifdef VTX_DEBUG
   std::vector<std::vector<ClusterLines>> dbg_clusLines(mTimeFrame->getNrof());
 #endif
-  std::vector<int> noClustersVec(mTimeFrame->getNrof(), 0);
+  bounded_vector<int> noClustersVec(mTimeFrame->getNrof(), 0, mMemoryPool.get());
   for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
     if (iteration && (int)mTimeFrame->getPrimaryVertices(rofId).size() > mVrtParams[iteration].vertPerRofThreshold) {
       continue;
     }
     const int numTracklets{static_cast<int>(mTimeFrame->getLines(rofId).size())};
 
-    std::vector<bool> usedTracklets(numTracklets, false);
+    bounded_vector<bool> usedTracklets(numTracklets, false, mMemoryPool.get());
     for (int line1{0}; line1 < numTracklets; ++line1) {
       if (usedTracklets[line1]) {
         continue;
@@ -522,7 +525,7 @@ void VertexerTraits::computeVertices(const int iteration)
         }
         vertices.back().setTimeStamp(mTimeFrame->getTrackletClusters(rofId)[iCluster].getROF());
         if (mTimeFrame->hasMCinformation()) {
-          std::vector<o2::MCCompLabel> labels;
+          bounded_vector<o2::MCCompLabel> labels(mMemoryPool.get());
           for (auto& index : mTimeFrame->getTrackletClusters(rofId)[iCluster].getLabels()) {
             labels.push_back(mTimeFrame->getLinesLabel(rofId)[index]); // then we can use nContributors from vertices to get the labels
           }
@@ -569,25 +572,15 @@ void VertexerTraits::computeVertices(const int iteration)
 #endif
 }
 
-void VertexerTraits::setNThreads(int n)
-{
-#ifdef WITH_OPENMP
-  mNThreads = n > 0 ? n : 1;
-#else
-  mNThreads = 1;
-#endif
-  LOGP(info, "Setting seeding vertexer with {} threads.", mNThreads);
-}
-
 void VertexerTraits::computeVerticesInRof(int rofId,
                                           gsl::span<const o2::its::Line>& lines,
-                                          std::vector<bool>& usedLines,
-                                          std::vector<o2::its::ClusterLines>& clusterLines,
+                                          bounded_vector<bool>& usedLines,
+                                          bounded_vector<o2::its::ClusterLines>& clusterLines,
                                           std::array<float, 2>& beamPosXY,
-                                          std::vector<Vertex>& vertices,
-                                          std::vector<int>& verticesInRof,
+                                          bounded_vector<Vertex>& vertices,
+                                          bounded_vector<int>& verticesInRof,
                                           TimeFrame7* tf,
-                                          std::vector<o2::MCCompLabel>* labels,
+                                          bounded_vector<o2::MCCompLabel>* labels,
                                           const int iteration)
 {
   int foundVertices{0};
@@ -699,5 +692,16 @@ void VertexerTraits::computeVerticesInRof(int rofId,
   }
   verticesInRof.push_back(foundVertices);
 }
-} // namespace its
-} // namespace o2
+
+void VertexerTraits::setNThreads(int n)
+{
+  if (mNThreads == n && mTaskArena.is_active()) {
+    return;
+  }
+  mNThreads = n > 0 ? n : 1;
+#if defined(VTX_DEBUG)
+  mNThreads = 1;
+#endif
+  mTaskArena.initialize(mNThreads);
+  LOGP(info, "Setting seeding vertexer with {} threads.", mNThreads);
+}
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index 5c3b9670fbdb9..a01eb77af1677 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -12,6 +12,7 @@
 #include "ITS3Reconstruction/IOUtils.h"
 #include "ITStracking/IOUtils.h"
 #include "ITStracking/TimeFrame.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITS3Reconstruction/TopologyDictionary.h"
@@ -68,8 +69,7 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
 
   tf->mNrof = 0;
 
-  std::vector<uint8_t> clusterSizeVec;
-  clusterSizeVec.reserve(clusters.size());
+  its::bounded_vector<uint8_t> clusterSizeVec(clusters.size(), tf->getMemoryPool().get());
 
   for (auto& rof : rofs) {
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {

From c11eff3662d300e5dcca3b670be49336248c7e50 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 3 Jun 2025 15:18:40 +0200
Subject: [PATCH 0447/1764] ITS should check MeanVertex (if enabled) at every
 TF

---
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 0907253e24580..6bceb1cd86073 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -374,6 +374,9 @@ void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContex
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   static bool initOnceDone = false;
+  if (mOverrideBeamEstimation) {
+    pc.inputs().get<o2::dataformats::MeanVertexObject*>("meanvtx");
+  }
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
     pc.inputs().get<o2::itsmft::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
@@ -402,9 +405,6 @@ void ITSTrackingInterface::getConfiguration(framework::ProcessingContext& pc)
 {
   mVertexer->getGlobalConfiguration();
   mTracker->getGlobalConfiguration();
-  if (mOverrideBeamEstimation) {
-    pc.inputs().get<o2::dataformats::MeanVertexObject*>("meanvtx");
-  }
 }
 
 void ITSTrackingInterface::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)

From 108aeca747006abdf88a66c14959b0efe65a0a3e Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 3 Jun 2025 18:04:57 +0200
Subject: [PATCH 0448/1764] Use --ccdb-meanvertex-seed in the async ITS reco
 mode

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index dd575099857f4..b83c12d9ef313 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -177,7 +177,7 @@ if [[ $BEAMTYPE == "cosmic" ]]; then
 elif [[ $SYNCMODE == 1 ]]; then
   [[ -z ${ITS_CONFIG+x} ]] && ITS_CONFIG=" --tracking-mode sync"
 else
-  [[ -z ${ITS_CONFIG+x} ]] && ITS_CONFIG=" --tracking-mode async"
+  [[ -z ${ITS_CONFIG+x} ]] && ITS_CONFIG=" --tracking-mode async --ccdb-meanvertex-seed"
 fi
 
 if [[ $SYNCMODE == 1 ]] && [[ ${PRESCALE_ITS_WO_TRIGGER:-} != 1 ]]; then

From 1e1904719a7a57239bbd22aae6ef9bb4a0e30f0d Mon Sep 17 00:00:00 2001
From: jokonig <jokonig@cern.ch>
Date: Tue, 3 Jun 2025 11:38:50 +0200
Subject: [PATCH 0449/1764] [EMCAL-539] Fix min. bias trigger handling for
 EMCal in simulation

- Bug introduced in https://github.com/AliceO2Group/AliceO2/pull/13227 : The decision of the fake trigger bit (if (ctpinpmask[CTP_NINPUTS - 1]) ) was always overwritten as the else case was removed completely.
- This PR reverts this change. Hence the trigger flag used for analyis kTVXInEMC is now again only true when EMCal was in readout. Before it was always set when TVX fired.
- Some more changes due to clang-format
---
 Detectors/CTP/simulation/src/Digitizer.cxx | 45 +++++++++++-----------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/Detectors/CTP/simulation/src/Digitizer.cxx b/Detectors/CTP/simulation/src/Digitizer.cxx
index 2f033b8a01462..55893cb0269da 100644
--- a/Detectors/CTP/simulation/src/Digitizer.cxx
+++ b/Detectors/CTP/simulation/src/Digitizer.cxx
@@ -83,16 +83,16 @@ std::vector<CTPDigit> Digitizer::process(const gsl::span<o2::ctp::CTPInputDigit>
             emcMBaccept.set(CTP_NINPUTS - 1, 1);
             inpmaskcoll |= emcMBaccept;
           } // else { // needs to be done always, remove else
-            for (auto const& ctpinp : det2ctpinp[o2::detectors::DetID::EMC]) {
-              uint64_t mask = inpmaskdebug & detInputName2Mask[ctpinp.name];
-              // uint64_t mask = (inp->inputsMask).to_ullong() & detInputName2Mask[ctpinp.name];
-              if (mask) {
-                inpmaskcoll |= std::bitset<CTP_NINPUTS>(ctpinp.inputMask);
-              }
+          for (auto const& ctpinp : det2ctpinp[o2::detectors::DetID::EMC]) {
+            uint64_t mask = inpmaskdebug & detInputName2Mask[ctpinp.name];
+            // uint64_t mask = (inp->inputsMask).to_ullong() & detInputName2Mask[ctpinp.name];
+            if (mask) {
+              inpmaskcoll |= std::bitset<CTP_NINPUTS>(ctpinp.inputMask);
             }
-            // }
-            // LOG(info) << "EMC input mask:" << inpmaskcoll << " with IR = " << currentIR.bc << ", orbit = " << currentIR.orbit;
-            break;
+          }
+          // }
+          // LOG(info) << "EMC input mask:" << inpmaskcoll << " with IR = " << currentIR.bc << ", orbit = " << currentIR.orbit;
+          break;
         }
         case o2::detectors::DetID::PHS: {
           for (auto const& ctpinp : det2ctpinp[o2::detectors::DetID::PHS]) {
@@ -153,21 +153,20 @@ void Digitizer::calculateClassMask(const std::bitset<CTP_NINPUTS> ctpinpmask, st
       if (clustername == "emc") {
         tvxMBemc |= tcl.name.find("minbias_TVX_L0") != std::string::npos; // 2022
       }
-      if (tvxMBemc || (ctpinpmask.to_ullong() & tcl.descriptor->getInputsMask()) == tcl.descriptor->getInputsMask()) {
-        // require real physics input in any case
-        if (tvxMBemc) {
-          // if the class is a min. bias class accept it only if the MB-accept bit is set in addition
-          // (fake trigger input)
-          if (ctpinpmask[CTP_NINPUTS - 1]) {
-            classmask |= tcl.classMask;
-            LOG(info) << "adding MBA:" << tcl.name;
-          }
-        } // else {
-          // EMCAL rare triggers - physical trigger input
-          // class identification can be handled like in the case of the other
-          // classes as EMCAL trigger input is required
+      // require real physics input in any case
+      if (tvxMBemc) {
+        // if the class is a min. bias class accept it only if the MB-accept bit is set in addition
+        // (fake trigger input)
+        if (ctpinpmask[CTP_NINPUTS - 1]) {
           classmask |= tcl.classMask;
-          // }
+          LOG(info) << "adding MBA:" << tcl.name;
+        }
+      } else if ((ctpinpmask.to_ullong() & tcl.descriptor->getInputsMask()) == tcl.descriptor->getInputsMask()) {
+        // EMCAL rare triggers - physical trigger input
+        // class identification can be handled like in the case of the other
+        // classes as EMCAL trigger input is required
+        LOG(info) << "adding EMCal rare trigger:" << tcl.name;
+        classmask |= tcl.classMask;
       }
     } else {
       if (tcl.descriptor && ((ctpinpmask.to_ullong() & tcl.descriptor->getInputsMask()) == tcl.descriptor->getInputsMask())) {

From 0c08a1f19cd74ff540088d3438688f6170d9af3a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 4 Jun 2025 11:31:19 +0200
Subject: [PATCH 0450/1764] Add a version number to FindO2GPU.cmake and remark
 to keep it in sync with alidist

---
 dependencies/FindO2GPU.cmake | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index eb63a72b3f536..20e351a68c271 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -9,6 +9,9 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
+# NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
+# FindO2GPU.cmake Version 1
+
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
 endif()

From d22033cb4f8f91670ce89a19c8ae24a63f2c9409 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 4 Jun 2025 16:20:27 +0200
Subject: [PATCH 0451/1764] GPU: Add script for standalone build in the CI

---
 GPU/GPUTracking/Standalone/cmake/build.sh | 18 ++++++++++++++++++
 GPU/documentation/build-standalone.md     |  2 ++
 GPU/documentation/deterministic-mode.md   |  1 +
 3 files changed, 21 insertions(+)
 create mode 100755 GPU/GPUTracking/Standalone/cmake/build.sh

diff --git a/GPU/GPUTracking/Standalone/cmake/build.sh b/GPU/GPUTracking/Standalone/cmake/build.sh
new file mode 100755
index 0000000000000..d2e4ae08c1575
--- /dev/null
+++ b/GPU/GPUTracking/Standalone/cmake/build.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+if [[ -z $1 ]]; then
+  echo "Please provide Sourcedir as command line argument"
+  exit 1
+fi
+mkdir -p standalone/build
+pushd standalone/build
+cp $1/GPU/GPUTracking/Standalone/cmake/config.cmake .
+cat >> config.cmake << "EOF"
+set(ENABLE_CUDA 1)
+set(ENABLE_HIP 1)
+set(ENABLE_OPENCL 1)
+set(GPUCA_CONFIG_ONNX 1)
+set(GPUCA_BUILD_EVENT_DISPLAY 0)
+EOF
+cmake -DCMAKE_INSTALL_PREFIX=../ $1/GPU/GPUTracking/Standalone
+make ${JOBS+-j $JOBS} install
+popd
diff --git a/GPU/documentation/build-standalone.md b/GPU/documentation/build-standalone.md
index d6aa45d749568..451ce659dc7f0 100644
--- a/GPU/documentation/build-standalone.md
+++ b/GPU/documentation/build-standalone.md
@@ -35,6 +35,8 @@ And there are plenty of additional settings to enable/disable event display, qa,
 
 This will create the `ca` binary in `~/standalone`, which is basically the same as the `o2-gpu-standalone-benchmark`, but built outside of O2.
 
+As an exacmple you can also have a look at [build.sh](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/GPUTracking/Standalone/cmake/build.sh), which is used by the CI.
+
 # Running
 
 The following command lines will use `./ca`, in case you use the executable from the O2 build, please replace by `o2-gpu-standalone-benchmark`.
diff --git a/GPU/documentation/deterministic-mode.md b/GPU/documentation/deterministic-mode.md
index 9c8db2930ceaa..53f8a1eb27711 100644
--- a/GPU/documentation/deterministic-mode.md
+++ b/GPU/documentation/deterministic-mode.md
@@ -12,6 +12,7 @@ This is steered by 3 options:
 - The `--PROCdeterministicGPUReconstruction` command line option / `GPU_proc.deterministicGPUReconstruction` `--configKeyValue` setting : Run time setting.
 - The `--RTCdeterministic` command line option / `GPU_proc_rtc.deterministic` `--configKeyValue` setting. (Auto-enabled by the `deterministicGPUReconstruction` setting.) : Compile-time setting for RTC code.
 
+Note that enabling a single setting will not result in fully deterministic behavior! Each setting enables different deterministic aspects!
 In order to be fully deterministic, all settings must be enabled, where the RTC setting is automatically enabled if not explicitly disabled.
 
 `GPUCA_DETERMINISTIC_MODE` has multiple levels, which are described here: [FindO2GPU.cmake](https://github.com/AliceO2Group/AliceO2/blob/80a80a17f5a1d9cb77743e2a39b15b653fe1a4f9/dependencies/FindO2GPU.cmake#L72).

From 81604b4d553866bed980fa5587b98bd4c2884c06 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 4 Jun 2025 09:53:33 +0200
Subject: [PATCH 0452/1764] dpl-workflow.sh: use different MI100 serialization
 workaround with better performance

---
 prodtests/full-system-test/dpl-workflow.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index b83c12d9ef313..202352730ddc7 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -270,7 +270,8 @@ if [[ $GPUTYPE == "HIP" ]]; then
     TIMESLICEOFFSET=$(($GPU_FIRST_ID + ($NUMAGPUIDS != 0 ? ($NGPUS * $NUMAID) : 0)))
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
-  [[ $EPNSYNCMODE == 1 || ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
+  # serialization workaround for MI100 nodes: remove it again if the problem will be fixed in ROCm, then also remove the DISABLE_MI100_SERIALIZATION flag in the O2DPG parse script
+  [[ $EPNSYNCMODE == 1 || ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.amdMI100SerializationWorkaround=1;"
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else
   GPU_CONFIG_KEY+="GPU_proc.deviceNum=-2;"

From 5bf1302c65ceca1a9629c6c98e0ab27cbaf64425 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 5 Jun 2025 09:35:34 +0200
Subject: [PATCH 0453/1764] DPL Analysis: add protect0 node for preventing
 division by 0 in expressions (#14338)

---
 Framework/Core/include/Framework/Expressions.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 9d6c3cfb7c66e..4163a73f83983 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -17,6 +17,7 @@
 #include "Framework/Variant.h"
 #include "Framework/InitContext.h"
 #include "Framework/ConfigParamRegistry.h"
+#include "CommonConstants/MathConstants.h"
 #include <arrow/type_fwd.h>
 #include <gandiva/gandiva_aliases.h>
 #include <arrow/type.h>
@@ -554,6 +555,13 @@ inline Node clamp(Node&& expr, T low, T hi)
   return ifnode(Node{copy} < LiteralNode{low}, LiteralNode{low}, ifnode(Node{copy} > LiteralNode{hi}, LiteralNode{hi}, Node{copy}));
 }
 
+/// division by 0 protector
+inline Node protect0(Node&& expr)
+{
+  auto copy = expr;
+  return ifnode(nabs(Node{copy}) < o2::constants::math::Almost0, o2::constants::math::Almost0, Node{copy});
+}
+
 /// A struct, containing the root of the expression tree
 struct Filter {
   Filter() = default;

From f14f14437ed0fd9d60455f3b4e206270d2f1b4ff Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Thu, 5 Jun 2025 12:22:24 +0200
Subject: [PATCH 0454/1764] TPC: demote errors about IDC CRU orbit/packets
 mismatches from critical to error (#14365)

---
 Detectors/TPC/workflow/src/IDCToVectorSpec.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx b/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
index e9433c775a02a..27dbcf5d85bbf 100644
--- a/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
+++ b/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
@@ -405,7 +405,7 @@ class IDCToVectorDevice : public o2::framework::Task
 
       for (const auto& inf : infVec) {
         if (!inf.hasBothEPs()) {
-          LOGP(critical, "IDC CRU {:3}: data missing at ({:8}, {:4}) for one or both end points {:02b} in TF {}", cru, inf.heartbeatOrbit, inf.heartbeatBC, inf.epSeen, tfCounter);
+          LOGP(error, "IDC CRU {:3}: data missing at ({:8}, {:4}) for one or both end points {:02b} in TF {}", cru, inf.heartbeatOrbit, inf.heartbeatBC, inf.epSeen, tfCounter);
           hasErrors = true;
         }
       }
@@ -417,12 +417,12 @@ class IDCToVectorDevice : public o2::framework::Task
       }
 
       if (packetsInTF != infVec.size()) {
-        LOGP(critical, "IDC CRU {:3}: number of IDC packets {} does not match max over all CRUs {} in TF {}", cru, packetsInTF, infVec.size(), tfCounter);
+        LOGP(error, "IDC CRU {:3}: number of IDC packets {} does not match max over all CRUs {} in TF {}", cru, packetsInTF, infVec.size(), tfCounter);
         hasErrors = true;
       }
 
       if (!std::equal(infVecComp->begin(), infVecComp->end(), infVec.begin())) {
-        LOGP(critical, "IDC CRU {:3}: mismatch in orbit numbers", cru);
+        LOGP(error, "IDC CRU {:3}: mismatch in orbit numbers", cru);
         hasErrors = true;
       }
     }

From d19711a93160ed1761a7e574d941c26d23900a05 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 5 Jun 2025 12:22:47 +0200
Subject: [PATCH 0455/1764] If the tree is setup and empty, ROOT 6.36.00
 returns 0 (#14360)

---
 .../Raw/Encoder/Digit/testDigitTreeReader.cxx  | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Detectors/MUON/MCH/Raw/Encoder/Digit/testDigitTreeReader.cxx b/Detectors/MUON/MCH/Raw/Encoder/Digit/testDigitTreeReader.cxx
index 12d2dddfdd326..c09b5c2a5e88d 100644
--- a/Detectors/MUON/MCH/Raw/Encoder/Digit/testDigitTreeReader.cxx
+++ b/Detectors/MUON/MCH/Raw/Encoder/Digit/testDigitTreeReader.cxx
@@ -119,15 +119,15 @@ BOOST_AUTO_TEST_CASE(DigitTreeReaderMustThrowIfRofBranchIsOfTheWrongType)
   BOOST_CHECK_THROW(DigitTreeReader dtr(&invalidRofs), std::invalid_argument);
 }
 
-BOOST_AUTO_TEST_CASE(DigitTreeReaderMustThrowIfNoEntry)
-{
-  TTree noEntry("noEntry", "All branches correct but no entry");
-  std::vector<o2::mch::Digit> digits;
-  std::vector<o2::mch::ROFRecord> rofs;
-  noEntry.Branch("MCHDigit", &digits);
-  noEntry.Branch("MCHROFRecords", &rofs);
-  BOOST_CHECK_THROW(DigitTreeReader dtr(&noEntry), std::invalid_argument);
-}
+//BOOST_AUTO_TEST_CASE(DigitTreeReaderMustThrowIfNoEntry)
+//{
+//  TTree noEntry("noEntry", "All branches correct but no entry");
+//  std::vector<o2::mch::Digit> digits;
+//  std::vector<o2::mch::ROFRecord> rofs;
+//  noEntry.Branch("MCHDigit", &digits);
+//  noEntry.Branch("MCHROFRecords", &rofs);
+//  BOOST_CHECK_NO_THROW(DigitTreeReader dtr(&noEntry));
+//}
 
 BOOST_AUTO_TEST_CASE(DigitTreeReaderMustNotThrowIfInputTreeHasAllBranchesAndAtLeastOneEntry)
 {

From 364c0bcaef4ded8ab18f2ec1c8c103d1f4d092dd Mon Sep 17 00:00:00 2001
From: Peter Hristov <pzhristov@users.noreply.github.com>
Date: Thu, 5 Jun 2025 14:50:28 +0200
Subject: [PATCH 0456/1764] Preparation for Pythia8315 (#14286)

Preparations for Pythia8315

* Ignore nuclei isospin only if equal to 9.
* Do not change the PDG code of beam remnants
---
 Generators/src/GeneratorPythia8.cxx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Generators/src/GeneratorPythia8.cxx b/Generators/src/GeneratorPythia8.cxx
index e883ceb6470a9..becc810644f24 100644
--- a/Generators/src/GeneratorPythia8.cxx
+++ b/Generators/src/GeneratorPythia8.cxx
@@ -657,7 +657,7 @@ Bool_t
     auto st = o2::mcgenstatus::MCGenStatusEncoding(particle.statusHepMC(), //
                                                    particle.status())      //
                 .fullEncoding;
-    mParticles.push_back(TParticle(particle.id(),            // Particle type
+    mParticles.push_back(TParticle(pdg,                      // Particle type
                                    st,                       // status
                                    particle.mother1() - 1,   // first mother
                                    particle.mother2() - 1,   // second mother
@@ -776,7 +776,11 @@ void GeneratorPythia8::updateHeader(o2::dataformats::MCEventHeader* eventHeader)
                               hiinfo->nAbsProj() + hiinfo->nDiffProj());
     eventHeader->putInfo<int>(Key::nPartTarget,
                               hiinfo->nAbsTarg() + hiinfo->nDiffTarg());
+#if PYTHIA_VERSION_INTEGER >= 8313
+    eventHeader->putInfo<int>(Key::nCollHard, hiinfo->nCollND());
+#else
     eventHeader->putInfo<int>(Key::nCollHard, hiinfo->nCollNDTot());
+#endif
   }
 }
 

From b10112dc16ce1fada03c6caae163fd0519af17dd Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 6 Jun 2025 09:18:00 +0200
Subject: [PATCH 0457/1764] ITS: print vtx param and remove duplicates (#14356)

* ITS: Tracker iteration print memory

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: print vtx param

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: align print statement

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: remove duplicate param instances

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITStracking/Configuration.h       |  4 +++
 .../tracking/include/ITStracking/Vertexer.h   |  1 +
 .../ITSMFT/ITS/tracking/src/Configuration.cxx | 25 ++++++++++++++-----
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  3 +++
 .../ITS/tracking/src/TrackingConfigParam.cxx  | 11 --------
 .../ITS/tracking/src/TrackingInterface.cxx    |  7 +++++-
 6 files changed, 33 insertions(+), 18 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index d6c552935dd93..d3f7597ae314b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -113,6 +113,8 @@ struct TrackingParameters {
 };
 
 struct VertexingParameters {
+  std::string asString() const;
+
   int nIterations = 1;         // Number of vertexing passes to perform
   int vertPerRofThreshold = 0; // Maximum number of vertices per ROF to trigger second a round
   bool allowSingleContribClusters = false;
@@ -145,6 +147,8 @@ struct VertexingParameters {
 };
 
 struct TimeFrameGPUParameters {
+  std::string asString() const;
+
   size_t tmpCUBBufferSize = 1e5; // In average in pp events there are required 4096 bytes
   size_t maxTrackletsPerCluster = 1e2;
   size_t clustersPerLayerCapacity = 2.5e5;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 77b21b58b967b..07d9d60243a95 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -56,6 +56,7 @@ class Vertexer
   void adoptTimeFrame(TimeFrame7& tf);
   auto& getVertParameters() const { return mTraits->getVertexingParameters(); }
   void setParameters(const std::vector<VertexingParameters>& vertParams) { mVertParams = vertParams; }
+  const auto& getParameters() const noexcept { return mVertParams; }
   void getGlobalConfiguration();
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 7d348505c61d3..d1cddc1819a0b 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -9,10 +9,14 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <format>
+#include "ITStracking/Constants.h"
+
 #include "ITStracking/Configuration.h"
 
 namespace o2::its
 {
+
 std::string asString(TrackingMode mode)
 {
   switch (mode) {
@@ -28,9 +32,15 @@ std::string asString(TrackingMode mode)
   return "unknown";
 }
 
+std::ostream& operator<<(std::ostream& os, TrackingMode v)
+{
+  os << asString(v);
+  return os;
+}
+
 std::string TrackingParameters::asString() const
 {
-  std::string str = fmt::format("NZb:{} NPhB:{} NROFIt:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{}",
+  std::string str = std::format("NZb:{} NPhB:{} NROFIt:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{}",
                                 ZBins, PhiBins, nROFsPerIterations, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength);
   bool first = true;
   for (int il = NLayers; il >= MinTrackLength; il--) {
@@ -40,19 +50,22 @@ std::string TrackingParameters::asString() const
         first = false;
         str += " MinPt: ";
       }
-      str += fmt::format("L{}:{:.2f} ", il, MinPt[slot]);
+      str += std::format("L{}:{:.2f} ", il, MinPt[slot]);
     }
   }
   str += " SystErrY/Z:";
   for (size_t i = 0; i < SystErrorY2.size(); i++) {
-    str += fmt::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);
+    str += std::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);
   }
+  str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
   return str;
 }
 
-std::ostream& operator<<(std::ostream& os, TrackingMode v)
+std::string VertexingParameters::asString() const
 {
-  os << asString(v);
-  return os;
+  std::string str = std::format("NZb:{} NPhB:{} DRof:{} ClsCont:{} MaxTrkltCls:{} ZCut:{} PhCut:{}", ZBins, PhiBins, deltaRof, clusterContributorsCut, maxTrackletsPerCluster, zCut, phiCut);
+  str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
+  return str;
 }
+
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index e354792620436..5565026ab11cf 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -118,6 +118,9 @@ void Tracker::clustersToTracks(LogFunc logger, LogFunc error)
         total += timeExtending;
         logger(std::format(" - Extending Tracks: {} extended tracks using {} clusters found in {:.2f} ms", nExtendedTracks + mTimeFrame->mNExtendedTracks, nExtendedClusters + mTimeFrame->mNExtendedUsedClusters, timeExtending));
       }
+      if (mTrkParams[iteration].PrintMemory) {
+        mMemoryPool->print();
+      }
     }
     if (mTraits->supportsFindShortPrimaries() && mTrkParams[0].FindShortTracks) {
       auto nTracksB = mTimeFrame->getNumberOfTracks();
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
index 33edd140dd234..b5fbedcc89339 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
@@ -10,18 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "ITStracking/TrackingConfigParam.h"
-#include "ITStracking/Configuration.h"
-
-namespace o2
-{
-namespace its
-{
-static auto& sVertexerParamITS = o2::its::VertexerParamConfig::Instance();
-static auto& sCATrackerParamITS = o2::its::TrackerParamConfig::Instance();
-static auto& sGpuRecoParamITS = o2::its::ITSGpuTrackingParamConfig::Instance();
 
 O2ParamImpl(o2::its::VertexerParamConfig);
 O2ParamImpl(o2::its::TrackerParamConfig);
 O2ParamImpl(o2::its::ITSGpuTrackingParamConfig);
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 6bceb1cd86073..05b2ec57ecc6d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -302,7 +302,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
                              o2::its::VertexerParamConfig::Instance().nIterations > 1 ? mTimeFrame->getTotVertIteration()[1] : 0,
                              trackROFspan.size() - mTimeFrame->getNoVertexROF(),
                              trackROFspan.size());
-    LOG(info) << fmt::format("FastMultEst: rejected {}/{} ROFs: random/mult.sel:{} (seed {}), vtx.sel:{}", cutRandomMult + cutVertexMult, trackROFspan.size(), cutRandomMult, multEst.lastRandomSeed, cutVertexMult);
+    LOG(info) << fmt::format(" - FastMultEst: rejected {}/{} ROFs: random/mult.sel:{} (seed {}), vtx.sel:{}", cutRandomMult + cutVertexMult, trackROFspan.size(), cutRandomMult, multEst.lastRandomSeed, cutVertexMult);
   }
   if (mOverrideBeamEstimation) {
     LOG(info) << fmt::format(" - Beam position set to: {}, {} from meanvertex object", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
@@ -392,6 +392,11 @@ void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContex
     if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
       o2::its::VertexerParamConfig::Instance().printKeyValues();
       o2::its::TrackerParamConfig::Instance().printKeyValues();
+      const auto& vtxParams = mVertexer->getParameters();
+      for (size_t it = 0; it < vtxParams.size(); it++) {
+        const auto& par = vtxParams[it];
+        LOGP(info, "vtxIter#{} : {}", it, par.asString());
+      }
       const auto& trParams = mTracker->getParameters();
       for (size_t it = 0; it < trParams.size(); it++) {
         const auto& par = trParams[it];

From 1fb877f3db16aa11962424f582c29cae51a7189a Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <48915672+matthias-kleiner@users.noreply.github.com>
Date: Fri, 6 Jun 2025 09:18:38 +0200
Subject: [PATCH 0458/1764] TPC: Adding workflow to provide pressure and
 temperature (#14357)

* TPC: Adding workflow to provide pressure and temperature

- will be used for scaling of vdrift and gain

Optimizing temperature processing
- move fitting of temperature to definition of temperature struct
- optimize fit procedure by merging last interval in case it is needed

Adding processing of DCS pressure values and storage in CCDB
- first pressure sensor in the cavern serves as the reference
- second pressure sensor in the cavern and third sensor at the surface are normalized
to reference pressure sensor

* adding helper to extract pressure and temperature from CCDB
---
 Common/MathUtils/include/MathUtils/fit.h      | 178 +++++++-
 Common/MathUtils/src/MathUtilsLinkDef.h       |   2 +
 DataFormats/Detectors/TPC/CMakeLists.txt      |   3 +-
 .../TPC/include/DataFormatsTPC/DCS.h          | 140 +++++-
 DataFormats/Detectors/TPC/src/DCS.cxx         | 415 ++++++++++++++++++
 .../Detectors/TPC/src/DataFormatsTPCLinkDef.h |   2 +
 .../testWorkflow/src/DCSDataReplaySpec.cxx    |  57 ++-
 Detectors/TPC/base/include/TPCBase/CDBTypes.h |   2 +
 Detectors/TPC/calibration/CMakeLists.txt      |   4 +-
 .../PressureTemperatureHelper.h               |  84 ++++
 .../src/PressureTemperatureHelper.cxx         | 119 +++++
 .../calibration/src/TPCCalibrationLinkDef.h   |   1 +
 Detectors/TPC/dcs/CMakeLists.txt              |   3 +-
 .../TPC/dcs/include/TPCdcs/DCSProcessor.h     |  66 +--
 Detectors/TPC/dcs/src/DCSDPHints.cxx          |   5 +
 Detectors/TPC/dcs/src/DCSProcessor.cxx        |  98 ++---
 Detectors/TPC/dcs/src/DCSSpec.cxx             |  28 +-
 Detectors/TPC/workflow/CMakeLists.txt         |   6 +
 .../TPCWorkflow/TPCPressureTemperatureSpec.h  |  28 ++
 .../src/TPCPressureTemperatureSpec.cxx        | 115 +++++
 .../workflow/src/tpc-pressure-temperature.cxx |  36 ++
 21 files changed, 1256 insertions(+), 136 deletions(-)
 create mode 100644 Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
 create mode 100644 Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
 create mode 100644 Detectors/TPC/workflow/include/TPCWorkflow/TPCPressureTemperatureSpec.h
 create mode 100644 Detectors/TPC/workflow/src/TPCPressureTemperatureSpec.cxx
 create mode 100644 Detectors/TPC/workflow/src/tpc-pressure-temperature.cxx

diff --git a/Common/MathUtils/include/MathUtils/fit.h b/Common/MathUtils/include/MathUtils/fit.h
index 00c39486a4ba0..cd5cb415070d3 100644
--- a/Common/MathUtils/include/MathUtils/fit.h
+++ b/Common/MathUtils/include/MathUtils/fit.h
@@ -20,6 +20,7 @@
 #include <algorithm>
 #include <vector>
 #include <array>
+#include <thread>
 
 #include "Rtypes.h"
 #include "TLinearFitter.h"
@@ -69,9 +70,9 @@ TFitResultPtr fit(const size_t nBins, const T* arr, const T xMin, const T xMax,
   // create an empty TFitResult
   std::shared_ptr<TFitResult> tfr(new TFitResult());
   // create the fitter from an empty fit result
-  //std::shared_ptr<ROOT::Fit::Fitter> fitter(new ROOT::Fit::Fitter(std::static_pointer_cast<ROOT::Fit::FitResult>(tfr) ) );
+  // std::shared_ptr<ROOT::Fit::Fitter> fitter(new ROOT::Fit::Fitter(std::static_pointer_cast<ROOT::Fit::FitResult>(tfr) ) );
   ROOT::Fit::Fitter fitter(tfr);
-  //ROOT::Fit::FitConfig & fitConfig = fitter->Config();
+  // ROOT::Fit::FitConfig & fitConfig = fitter->Config();
 
   const double binWidth = double(xMax - xMin) / double(nBins);
 
@@ -225,8 +226,8 @@ bool medmadGaus(size_t nBins, const T* arr, const T xMin, const T xMax, std::arr
 ///          -1: only one point has been used for the calculation - center of gravity was uesed for calculation
 ///          -4: invalid result!!
 ///
-//template <typename T>
-//Double_t  fitGaus(const size_t nBins, const T *arr, const T xMin, const T xMax, std::vector<T>& param);
+// template <typename T>
+// Double_t  fitGaus(const size_t nBins, const T *arr, const T xMin, const T xMax, std::vector<T>& param);
 template <typename T>
 Double_t fitGaus(const size_t nBins, const T* arr, const T xMin, const T xMax, std::vector<T>& param)
 {
@@ -301,7 +302,7 @@ Double_t fitGaus(const size_t nBins, const T* arr, const T xMin, const T xMax, s
   Double_t chi2 = 0;
   if (npoints >= 3) {
     if (npoints == 3) {
-      //analytic calculation of the parameters for three points
+      // analytic calculation of the parameters for three points
       A.Invert();
       TMatrixD res(1, 3);
       res.Mult(A, b);
@@ -334,7 +335,7 @@ Double_t fitGaus(const size_t nBins, const T* arr, const T xMin, const T xMax, s
   }
 
   if (npoints == 2) {
-    //use center of gravity for 2 points
+    // use center of gravity for 2 points
     meanCOG /= sumCOG;
     rms2COG /= sumCOG;
     param[0] = max;
@@ -524,7 +525,7 @@ R median(std::vector<T> v)
   auto n = v.size() / 2;
   nth_element(v.begin(), v.begin() + n, v.end());
   auto med = R{v[n]};
-  if (!(v.size() & 1)) { //If the set size is even
+  if (!(v.size() & 1)) { // If the set size is even
     auto max_it = max_element(v.begin(), v.begin() + n);
     med = R{(*max_it + med) / 2.0};
   }
@@ -788,6 +789,169 @@ T MAD2Sigma(int np, T* y)
   return median * 1.4826; // convert to Gaussian sigma
 }
 
+/// \return returns the index of the closest timestamps to the left and right of the given timestamp
+/// \param timestamps vector of timestamps
+/// \param timestamp the timestamp to find the closest timestamps for
+template <typename DataTimeType, typename DataTime>
+std::optional<std::pair<size_t, size_t>> findClosestIndices(const std::vector<DataTimeType>& timestamps, DataTime timestamp)
+{
+  if (timestamps.empty()) {
+    LOGP(warning, "Timestamp vector is empty!");
+    return std::nullopt;
+  }
+
+  if (timestamp <= timestamps.front()) {
+    return std::pair{0, 0};
+  } else if (timestamp >= timestamps.back()) {
+    return std::pair{timestamps.size() - 1, timestamps.size() - 1};
+  }
+
+  const auto it = std::lower_bound(timestamps.begin(), timestamps.end(), timestamp);
+  const size_t idx = std::distance(timestamps.begin(), it);
+  const auto prevTimestamp = timestamps[idx - 1];
+  const auto nextTimestamp = timestamps[idx];
+  return std::pair{(idx - 1), idx};
+}
+
+struct RollingStats {
+  RollingStats() = default;
+  RollingStats(const int nValues)
+  {
+    median.resize(nValues);
+    std.resize(nValues);
+    nPoints.resize(nValues);
+    closestDistanceL.resize(nValues);
+    closestDistanceR.resize(nValues);
+  }
+
+  std::vector<float> median;           ///< median of rolling data
+  std::vector<float> std;              ///< std of rolling data
+  std::vector<int> nPoints;            ///< number of points used for the calculation
+  std::vector<float> closestDistanceL; ///< distance of closest point to the left
+  std::vector<float> closestDistanceR; ///< distance of closest point to the right
+
+  ClassDefNV(RollingStats, 1);
+};
+
+/// \brief calculates the rolling statistics of the input data
+/// \return returns the rolling statistics
+/// \param timeData times of the input data (assumed to be sorted)
+/// \param data values of the input data
+/// \param times times for which to calculate the rolling statistics
+/// \param deltaMax time range for which the rolling statistics is calculated
+/// \param mNthreads number of threads to use for the calculation
+/// \param minPoints minimum number of points to use for the calculation of the statistics - otherwise use nearest nClosestPoints points weighted with distance
+/// \param nClosestPoints number of closest points in case of number of points in given range is smaller than minPoints
+template <typename DataTimeType, typename DataType, typename DataTime>
+RollingStats getRollingStatistics(const DataTimeType& timeData, const DataType& data, const DataTime& times, const double deltaMax, const int mNthreads, const size_t minPoints = 4, const size_t nClosestPoints = 4)
+{
+  // output statistics
+  const size_t vecSize = times.size();
+  RollingStats stats(vecSize);
+
+  if (!std::is_sorted(timeData.begin(), timeData.end())) {
+    LOGP(error, "Input data is NOT sorted!");
+    return stats;
+  }
+
+  if (timeData.empty()) {
+    LOGP(error, "Input data is empty!");
+    return stats;
+  }
+
+  const size_t dataSize = data.size();
+  const size_t timeDataSize = timeData.size();
+  if (timeDataSize != dataSize) {
+    LOGP(error, "Input data has different sizes {}!={}", timeDataSize, dataSize);
+    return stats;
+  }
+
+  auto myThread = [&](int iThread) {
+    // data in given time window for median calculation
+    DataType window;
+    for (size_t i = iThread; i < vecSize; i += mNthreads) {
+      const double timeI = times[i];
+
+      // lower index
+      const double timeStampLower = timeI - deltaMax;
+      const auto lower = std::lower_bound(timeData.begin(), timeData.end(), timeStampLower);
+      size_t idxStart = std::distance(timeData.begin(), lower);
+
+      // upper index
+      const double timeStampUpper = timeI + deltaMax;
+      const auto upper = std::lower_bound(timeData.begin(), timeData.end(), timeStampUpper);
+      size_t idxEnd = std::distance(timeData.begin(), upper);
+
+      // closest data point
+      if (auto idxClosest = findClosestIndices(timeData, timeI)) {
+        auto [idxLeft, idxRight] = *idxClosest;
+        const auto closestL = std::abs(timeData[idxLeft] - timeI);
+        const auto closestR = std::abs(timeData[idxRight] - timeI);
+        stats.closestDistanceL[i] = closestL;
+        stats.closestDistanceR[i] = closestR;
+
+        // if no points are in the range use the n closest points - n from the left and n from the right
+        const size_t reqSize = idxEnd - idxStart;
+        if (reqSize < minPoints) {
+          // calculate weighted average
+          idxStart = (idxRight > nClosestPoints) ? (idxRight - nClosestPoints) : 0;
+          idxEnd = std::min(data.size(), idxRight + nClosestPoints);
+          constexpr float epsilon = 1e-6f;
+          double weightedSum = 0.0;
+          double weightTotal = 0.0;
+          for (size_t j = idxStart; j < idxEnd; ++j) {
+            const double dist = std::abs(timeI - timeData[j]);
+            const double weight = 1.0 / (dist + epsilon);
+            weightedSum += weight * data[j];
+            weightTotal += weight;
+          }
+          stats.median[i] = (weightTotal > 0.) ? (weightedSum / weightTotal) : 0.0f;
+        } else {
+          // calculate statistics
+          stats.nPoints[i] = reqSize;
+
+          if (idxStart >= data.size()) {
+            stats.median[i] = data.back();
+            continue;
+          }
+
+          if (reqSize <= 1) {
+            stats.median[i] = data[idxStart];
+            continue;
+          }
+
+          // calculate median
+          window.clear();
+          if (reqSize > window.capacity()) {
+            window.reserve(static_cast<size_t>(reqSize * 1.5));
+          }
+          window.insert(window.end(), data.begin() + idxStart, data.begin() + idxEnd);
+          const size_t middle = window.size() / 2;
+          std::nth_element(window.begin(), window.begin() + middle, window.end());
+          stats.median[i] = (window.size() % 2 == 1) ? window[middle] : ((window[middle - 1] + window[middle]) / 2.0);
+
+          // calculate the stdev
+          const float mean = std::accumulate(window.begin(), window.end(), 0.0f) / window.size();
+          std::transform(window.begin(), window.end(), window.begin(), [mean](const float val) { return val - mean; });
+          const float sqsum = std::inner_product(window.begin(), window.end(), window.begin(), 0.0f);
+          const float stdev = std::sqrt(sqsum / window.size());
+          stats.std[i] = stdev;
+        }
+      }
+    }
+  };
+
+  std::vector<std::thread> threads(mNthreads);
+  for (int i = 0; i < mNthreads; i++) {
+    threads[i] = std::thread(myThread, i);
+  }
+
+  for (auto& th : threads) {
+    th.join();
+  }
+  return stats;
+}
+
 } // namespace math_utils
 } // namespace o2
 #endif
diff --git a/Common/MathUtils/src/MathUtilsLinkDef.h b/Common/MathUtils/src/MathUtilsLinkDef.h
index 6067dd540110c..0b070e537afcd 100644
--- a/Common/MathUtils/src/MathUtilsLinkDef.h
+++ b/Common/MathUtils/src/MathUtilsLinkDef.h
@@ -46,4 +46,6 @@
 #pragma link C++ class o2::math_utils::Legendre1DPolynominal + ;
 #pragma link C++ class o2::math_utils::Legendre2DPolynominal + ;
 
+#pragma link C++ class o2::math_utils::RollingStats + ;
+
 #endif
diff --git a/DataFormats/Detectors/TPC/CMakeLists.txt b/DataFormats/Detectors/TPC/CMakeLists.txt
index 81b1d5efad59a..2cc69e16001a6 100644
--- a/DataFormats/Detectors/TPC/CMakeLists.txt
+++ b/DataFormats/Detectors/TPC/CMakeLists.txt
@@ -35,7 +35,8 @@ o2_add_library(
                         O2::CommonDataFormat
                         O2::Headers
                         O2::DataSampling
-                        O2::Algorithm)
+                        O2::Algorithm
+                        ROOT::Minuit)
 
 o2_target_root_dictionary(
   DataFormatsTPC
diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/DCS.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/DCS.h
index 2f9f17f164872..3608fdc390203 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/DCS.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/DCS.h
@@ -30,9 +30,13 @@
 
 #include "Framework/Logger.h"
 #include "DataFormatsTPC/Defs.h"
+#include "MathUtils/fit.h"
 
 using namespace o2::tpc;
 
+class TLinearFitter;
+class TTree;
+
 namespace o2::tpc::dcs
 {
 
@@ -66,6 +70,19 @@ struct DataPointVector {
   uint32_t sensorNumber{};
   std::vector<DPType> data;
 
+  /// \brief convert data points to a vector of pairs: pair.first -> data and pair.second -> time
+  auto getPairOfVector() const
+  {
+    std::pair<std::vector<T>, std::vector<TimeStampType>> pairs;
+    pairs.first.reserve(data.size());
+    pairs.second.reserve(data.size());
+    for (const auto& dp : data) {
+      pairs.first.emplace_back(dp.value);
+      pairs.second.emplace_back(dp.time);
+    }
+    return pairs;
+  }
+
   void fill(const TimeStampType time, const T& value) { data.emplace_back(DPType{time, value}); }
 
   void fill(const DPType& dataPoint) { data.emplace_back(dataPoint); }
@@ -169,6 +186,45 @@ const T getAverageValueForTime(const std::vector<dcs::DataPointVector<T>>& dpVec
   return (nPoints > 0) ? ret / static_cast<float>(nPoints) : T{};
 }
 
+template <typename T>
+dcs::TimeStampType getMinTime(const std::vector<dcs::DataPointVector<T>>& data, const bool roundToInterval, dcs::TimeStampType fitInterval)
+{
+  constexpr auto max = std::numeric_limits<dcs::TimeStampType>::max();
+  dcs::TimeStampType firstTime = std::numeric_limits<dcs::TimeStampType>::max();
+  for (const auto& sensor : data) {
+    const auto time = sensor.data.size() ? sensor.data.front().time : max;
+    firstTime = std::min(firstTime, time);
+  }
+
+  // mFitInterval is is seconds. Round to full amount.
+  // if e.g. mFitInterval = 5min, then round 10:07:20.510 to 10:05:00.000
+  if (roundToInterval) {
+    firstTime -= (firstTime % fitInterval);
+  }
+
+  return firstTime;
+}
+
+template <typename T>
+dcs::TimeStampType getMaxTime(const std::vector<dcs::DataPointVector<T>>& data)
+{
+  constexpr auto min = 0;
+  dcs::TimeStampType lastTime = 0;
+  for (const auto& sensor : data) {
+    const auto time = sensor.data.size() ? sensor.data.back().time : 0;
+    lastTime = std::max(lastTime, time);
+  }
+
+  // mFitInterval is is seconds. Round to full amount.
+  // if e.g. mFitInterval = 5min, then round 10:07:20.510 to 10:05:00.000
+  // TODO: fix this
+  // if (mRoundToInterval) {
+  // lastTime -= (lastTime % mFitInterval);
+  //}
+
+  return lastTime;
+}
+
 using RawDPsF = DataPointVector<float>;
 // using RawDPsI = DataPointVector<int>;
 
@@ -210,6 +266,12 @@ struct Temperature {
 
   static constexpr auto& getSensorPosition(const size_t sensor) { return SensorPosition[sensor]; }
 
+  /// \brief make fit of the mean temperature and gradients in time intervals
+  /// \param Side TPC side for which to make the fit
+  /// \param fitInterval time interval for the fits
+  /// \param roundToInterval round min time
+  void fitTemperature(Side side, dcs::TimeStampType fitInterval = 5 * 60 * 1000, const bool roundToInterval = false);
+
   struct Stats {
     DataType mean{};  ///< average temperature in K
     DataType gradX{}; ///< horizontal temperature gradient in K/cm
@@ -262,6 +324,9 @@ struct Temperature {
     doAppend(raw, other.raw);
   }
 
+ private:
+  bool makeFit(TLinearFitter& fitter, const int nDim, std::vector<double>& xVals, std::vector<double>& temperatures);
+
   ClassDefNV(Temperature, 1);
 };
 
@@ -270,8 +335,7 @@ struct Temperature {
 ///
 struct HV {
 
-  HV()
-  noexcept;
+  HV() noexcept;
 
   // Exmple strings
   // TPC_HV_A03_I_G1B_I
@@ -483,5 +547,77 @@ struct Gas {
   ClassDefNV(Gas, 1);
 };
 
+struct RobustPressure {
+  using Stats = o2::math_utils::RollingStats;
+  Stats surfaceAtmosPressure;        ///< rolling statistics of surface sensor
+  Stats cavernAtmosPressure;         ///< rolling statistics of cavern sensor 1
+  Stats cavernAtmosPressure2;        ///< rolling statistics of cavern sensor 2
+  Stats cavernAtmosPressure12;       ///< rolling statistics of cavernAtmosPressure/cavernAtmosPressure2
+  Stats cavernAtmosPressure1S;       ///< rolling statistics of cavernAtmosPressure/surfaceAtmosPressure
+  Stats cavernAtmosPressure2S;       ///< rolling statistics of cavernAtmosPressure2/surfaceAtmosPressure
+  std::vector<uint8_t> isOk;         ///< bit mask of valid sensors: cavernBit 0, cavern2Bit = 1, surfaceBit = 2
+  std::vector<float> robustPressure; ///< combined robust pressure value that should be used
+  std::vector<TimeStampType> time;   ///< time stamps of all pressure values
+  TimeStampType timeInterval;        ///< time interval used for rolling statistics
+  TimeStampType timeIntervalRef;     ///< reference time interval used for normalization of pressure sensors
+  float maxDist{};                   ///< maximum allowed time distance between sensors to be accepted for robust pressure calculation
+  float maxDiff{0.2f};               ///< maximum allowed pressure difference between sensors to be accepted for robust pressure calculation
+
+  ClassDefNV(RobustPressure, 1);
+};
+
+struct Pressure {
+
+  /// \brief fill pressure data
+  /// \param sensor name of the sensor from DCS data stream
+  /// \param time measurement time
+  /// \param value pressure value
+  void fill(std::string_view sensor, const TimeStampType time, const DataType value);
+
+  /// sort pressure values and remove obvious outliers
+  /// \param pMin min accepted pressure
+  /// \param pMax max accepted pressure
+  void sortAndClean(float pMin = 800, float pMax = 1100);
+
+  /// \clear all stored data except the buffer
+  void clear();
+
+  /// append other pressure values
+  void append(const Pressure& other);
+
+  /// \return get minimum time of stored data
+  TimeStampType getMinTime() const;
+
+  /// \return get maximum time of stored data
+  TimeStampType getMaxTime() const;
+
+  /// \brief average pressure values for given time interval
+  /// \param timeInterval time interval for which the pressure values are averaged
+  /// \param timeIntervalRef time interval used to calculate the normalization values for the pressure
+  /// \param tStart min time of the data
+  /// \param tEnd max time of the data
+  /// \param nthreads numbe rof threads used for some calculations
+  void makeRobustPressure(TimeStampType timeInterval = 100 * 1000, TimeStampType timeIntervalRef = 24 * 60 * 1000, TimeStampType tStart = 1, TimeStampType tEnd = 0, const int nthreads = 1);
+
+  /// set aliases for the cuts used in the calculation of the robust pressure
+  static void setAliases(TTree* tree);
+
+  RawDPsF cavernAtmosPressure{};   ///< raw pressure in the cavern from sensor 1
+  RawDPsF cavernAtmosPressure2{};  ///< raw pressure in the cavern from sensor 2
+  RawDPsF surfaceAtmosPressure{};  ///< raw pressure at the surface
+  RobustPressure robustPressure{}; ///< combined robust pressure estimator from all three sensors
+
+  std::pair<std::vector<float>, std::vector<TimeStampType>> mCavernAtmosPressure1Buff{}; ///<! buffer for the pressure cavern 1 sensor
+  std::pair<std::vector<float>, std::vector<TimeStampType>> mCavernAtmosPressure2Buff{}; ///<! buffer for the pressure cavern 2 sensor
+  std::pair<std::vector<float>, std::vector<TimeStampType>> mSurfaceAtmosPressureBuff{}; ///<! buffer for the pressure surface sensort
+
+  std::pair<std::vector<float>, std::vector<TimeStampType>> mPressure12Buff{}; ///<! buffer for normalizing the pressure cavern 1 / cavern 2
+  std::pair<std::vector<float>, std::vector<TimeStampType>> mPressure1SBuff{}; ///<! buffer for normalizing the pressure cavern 1 / surface
+  std::pair<std::vector<float>, std::vector<TimeStampType>> mPressure2SBuff{}; ///<! buffer for normalizing the pressure cavern 2 / surface
+
+  std::pair<std::vector<float>, std::vector<TimeStampType>> mRobPressureBuff{}; ///<! buffer for the robust pressure
+  ClassDefNV(Pressure, 1);
+};
+
 } // namespace o2::tpc::dcs
 #endif
diff --git a/DataFormats/Detectors/TPC/src/DCS.cxx b/DataFormats/Detectors/TPC/src/DCS.cxx
index 131f6c9526647..3c2524b6ed0fe 100644
--- a/DataFormats/Detectors/TPC/src/DCS.cxx
+++ b/DataFormats/Detectors/TPC/src/DCS.cxx
@@ -16,6 +16,8 @@
 #include <limits>
 
 #include "DataFormatsTPC/DCS.h"
+#include "TLinearFitter.h"
+#include "TTree.h"
 
 using namespace o2::tpc::dcs;
 
@@ -117,3 +119,416 @@ TimeStampType Gas::getMaxTime() const
 
   return *std::max_element(times.begin(), times.end());
 }
+
+TimeStampType Pressure::getMinTime() const
+{
+  constexpr auto max = std::numeric_limits<dcs::TimeStampType>::max();
+  const std::vector<TimeStampType> times{
+    cavernAtmosPressure.data.size() ? cavernAtmosPressure.data.front().time : max,
+    cavernAtmosPressure2.data.size() ? cavernAtmosPressure2.data.front().time : max,
+    surfaceAtmosPressure.data.size() ? surfaceAtmosPressure.data.front().time : max,
+  };
+
+  return *std::min_element(times.begin(), times.end());
+}
+
+TimeStampType Pressure::getMaxTime() const
+{
+  constexpr auto min = 0;
+  const std::vector<TimeStampType> times{
+    cavernAtmosPressure.data.size() ? cavernAtmosPressure.data.back().time : min,
+    cavernAtmosPressure2.data.size() ? cavernAtmosPressure2.data.back().time : min,
+    surfaceAtmosPressure.data.size() ? surfaceAtmosPressure.data.back().time : min,
+  };
+
+  return *std::max_element(times.begin(), times.end());
+}
+
+bool Temperature::makeFit(TLinearFitter& fitter, const int nDim, std::vector<double>& xVals, std::vector<double>& temperatures)
+{
+  const int minPointsForFit = 5;
+  if (temperatures.empty() || (temperatures.size() < minPointsForFit)) {
+    LOGP(warning, "Number of points {} for fit smaller than minimum of {}!", temperatures.size(), minPointsForFit);
+    return false;
+  }
+
+  fitter.ClearPoints();
+  fitter.AssignData(temperatures.size(), nDim, xVals.data(), temperatures.data());
+  int status = fitter.Eval();
+  if (status == 1) {
+    LOGP(warning, "Fit failed!");
+    return false;
+  }
+  return true;
+}
+
+void Temperature::fitTemperature(Side side, dcs::TimeStampType fitInterval, const bool roundToInterval)
+{
+  // clear old data
+  auto& stats = (side == Side::A) ? statsA : statsC;
+  stats.clear();
+
+  // temperature fits in x-y
+  const int nDim = 2;
+  TLinearFitter fitter(nDim, "1 ++ x0 ++ x1", "");
+  std::array<size_t, dcs::Temperature::SensorsPerSide> startPos{};
+  const size_t sensorOffset = (side == Side::C) ? dcs::Temperature::SensorsPerSide : 0;
+
+  const dcs::TimeStampType refTime = getMinTime(raw, fitInterval, roundToInterval);
+  const dcs::TimeStampType refTimeMax = getMaxTime(raw);
+
+  // calculate number of intervals and see if the last interval should be merged into the previous one
+  const int lastIntervalDuration = (refTimeMax - refTime) % fitInterval;
+
+  // process the last interval only if it contains more than 50% of the interval duration
+  const bool procLastInt = (lastIntervalDuration / fitInterval > 0.5);
+  int numIntervals = (refTimeMax - refTime) / fitInterval + procLastInt;
+  if (numIntervals == 0) {
+    numIntervals = 1;
+  }
+
+  // buffer for fit values
+  std::vector<double> xVals;
+  std::vector<double> temperatures;
+  xVals.reserve(2 * 1000);
+  temperatures.reserve(1000);
+
+  for (int interval = 0; interval < numIntervals; ++interval) {
+    const dcs::TimeStampType timeStart = refTime + interval * fitInterval;
+
+    // clear buffer
+    xVals.clear();
+    temperatures.clear();
+
+    // TODO: check if we should use refTime
+    dcs::TimeStampType firstTime = std::numeric_limits<dcs::TimeStampType>::max();
+    dcs::TimeStampType LastTime = 0;
+
+    for (size_t iSensor = 0; iSensor < dcs::Temperature::SensorsPerSide; ++iSensor) {
+      const auto& sensor = raw[iSensor + sensorOffset];
+
+      LOGP(debug, "sensor {}, start {}, size {}", sensor.sensorNumber, startPos[iSensor], sensor.data.size());
+      while (startPos[iSensor] < sensor.data.size()) {
+        const auto& dataPoint = sensor.data[startPos[iSensor]];
+        if (((dataPoint.time - timeStart) >= fitInterval) && (interval != numIntervals - 1)) {
+          LOGP(debug, "sensor {}, {} - {} >= {}", sensor.sensorNumber, dataPoint.time, timeStart, fitInterval);
+          break;
+        }
+        firstTime = std::min(firstTime, dataPoint.time);
+        LastTime = std::max(LastTime, dataPoint.time);
+        const auto temperature = dataPoint.value;
+        // sanity check
+        ++startPos[iSensor];
+        if (temperature < 15 || temperature > 25) {
+          continue;
+        }
+        const auto& pos = dcs::Temperature::SensorPosition[iSensor + sensorOffset];
+        xVals.emplace_back(pos.x);
+        xVals.emplace_back(pos.y);
+        temperatures.emplace_back(temperature);
+      }
+    }
+    if (firstTime < std::numeric_limits<dcs::TimeStampType>::max() && !temperatures.empty()) {
+      const bool fitOk = makeFit(fitter, nDim, xVals, temperatures);
+      if (!fitOk) {
+        continue;
+      }
+      auto& stat = stats.data.emplace_back();
+      stat.time = (firstTime + LastTime) / 2;
+      stat.value.mean = fitter.GetParameter(0);
+      stat.value.gradX = fitter.GetParameter(1);
+      stat.value.gradY = fitter.GetParameter(2);
+
+      // check if data contains outliers
+      const float maxDeltaT = 1;
+      const float meanTemp = fitter.GetParameter(0);
+      const bool isDataGood = std::all_of(temperatures.begin(), temperatures.end(), [meanTemp, maxDeltaT](double t) { return std::abs(t - meanTemp) < maxDeltaT; });
+
+      // do second iteration only in case of outliers
+      if (!isDataGood) {
+        std::vector<double> xVals2;
+        std::vector<double> temperatures2;
+        xVals2.reserve(xVals.size());
+        temperatures2.reserve(temperatures.size());
+        for (int i = 0; i < temperatures.size(); ++i) {
+          if (std::abs(temperatures[i] - meanTemp) < maxDeltaT) {
+            const int idx = 2 * i;
+            xVals2.emplace_back(xVals[idx]);
+            xVals2.emplace_back(xVals[idx + 1]);
+            temperatures2.emplace_back(temperatures[i]);
+          }
+        }
+        const bool fitOk2 = makeFit(fitter, nDim, xVals2, temperatures2);
+        if (fitOk2) {
+          stat.value.mean = fitter.GetParameter(0);
+          stat.value.gradX = fitter.GetParameter(1);
+          stat.value.gradY = fitter.GetParameter(2);
+        }
+      }
+    }
+  }
+}
+
+void Pressure::fill(std::string_view sensor, const TimeStampType time, const DataType value)
+{
+  if (sensor == "CavernAtmosPressure") {
+    cavernAtmosPressure.fill(time, value);
+  } else if (sensor == "CavernAtmosPressure2") {
+    cavernAtmosPressure2.fill(time, value);
+  } else if (sensor == "SurfaceAtmosPressure") {
+    surfaceAtmosPressure.fill(time, value);
+  } else {
+    LOGP(warning, "Unknown pressure sensor {}", sensor);
+  }
+}
+
+void Pressure::sortAndClean(float pMin, float pMax)
+{
+  cavernAtmosPressure.sortAndClean();
+  cavernAtmosPressure2.sortAndClean();
+  surfaceAtmosPressure.sortAndClean();
+
+  auto removeOutliers = [](auto& dataVec, auto minVal, auto maxVal) {
+    dataVec.erase(
+      std::remove_if(dataVec.begin(), dataVec.end(),
+                     [minVal, maxVal](const auto& dp) {
+                       return (dp.value < minVal || dp.value > maxVal);
+                     }),
+      dataVec.end());
+  };
+
+  removeOutliers(cavernAtmosPressure.data, pMin, pMax);
+  removeOutliers(cavernAtmosPressure2.data, pMin, pMax);
+  removeOutliers(surfaceAtmosPressure.data, pMin, pMax);
+}
+
+void Pressure::clear()
+{
+  cavernAtmosPressure.clear();
+  cavernAtmosPressure2.clear();
+  surfaceAtmosPressure.clear();
+  robustPressure = RobustPressure();
+}
+
+void Pressure::append(const Pressure& other)
+{
+  cavernAtmosPressure.append(other.cavernAtmosPressure);
+  cavernAtmosPressure2.append(other.cavernAtmosPressure2);
+  surfaceAtmosPressure.append(other.surfaceAtmosPressure);
+}
+
+void fillBuffer(std::pair<std::vector<float>, std::vector<TimeStampType>>& buffer, const std::pair<std::vector<float>, std::vector<TimeStampType>>& values, TimeStampType tStart, const int minPoints)
+{
+  const auto itStartBuff = std::lower_bound(buffer.second.begin(), buffer.second.end(), tStart);
+  size_t idxStartBuffer = std::distance(buffer.second.begin(), itStartBuff);
+  if (buffer.first.size() - idxStartBuffer < minPoints) {
+    if (buffer.first.size() < minPoints) {
+      idxStartBuffer = 0;
+    } else {
+      idxStartBuffer = buffer.first.size() - minPoints;
+    }
+  }
+
+  std::pair<std::vector<float>, std::vector<TimeStampType>> buffTmp{
+    std::vector<float>(buffer.first.begin() + idxStartBuffer, buffer.first.end()),
+    std::vector<TimeStampType>(buffer.second.begin() + idxStartBuffer, buffer.second.end())};
+
+  buffTmp.first.insert(buffTmp.first.end(), values.first.begin(), values.first.end());
+  buffTmp.second.insert(buffTmp.second.end(), values.second.begin(), values.second.end());
+
+  buffer = std::move(buffTmp);
+}
+
+void Pressure::makeRobustPressure(TimeStampType timeInterval, TimeStampType timeIntervalRef, TimeStampType tStart, TimeStampType tEnd, const int nthreads)
+{
+  const auto surfaceAtmosPressurePair = surfaceAtmosPressure.getPairOfVector();
+  const auto cavernAtmosPressurePair = cavernAtmosPressure.getPairOfVector();
+  const auto cavernAtmosPressure2Pair = cavernAtmosPressure2.getPairOfVector();
+
+  // round to second
+  tStart = tStart / 1000 * 1000;
+  const TimeStampType tStartRef = (tStart - timeIntervalRef);
+  const int minPointsRef = 50;
+  fillBuffer(mCavernAtmosPressure1Buff, cavernAtmosPressurePair, tStartRef, minPointsRef);
+  fillBuffer(mCavernAtmosPressure2Buff, cavernAtmosPressure2Pair, tStartRef, minPointsRef);
+  fillBuffer(mSurfaceAtmosPressureBuff, surfaceAtmosPressurePair, tStartRef, minPointsRef);
+
+  int nIntervals = std::round((tEnd - tStart) / timeInterval);
+  if (nIntervals == 0) {
+    nIntervals = 1; // at least one interval
+  }
+  std::vector<TimeStampType> times;
+  times.reserve(nIntervals);
+  for (int i = 0; i < nIntervals; ++i) {
+    times.emplace_back(tStart + (i + 0.5) * timeInterval);
+  }
+
+  /// minimum number of points in the interval - otherwise use the n closest points
+  const int minPoints = 4;
+  const auto cavernAtmosPressureStats = o2::math_utils::getRollingStatistics(mCavernAtmosPressure1Buff.second, mCavernAtmosPressure1Buff.first, times, timeInterval, nthreads, minPoints, minPoints);
+  const auto cavernAtmosPressure2Stats = o2::math_utils::getRollingStatistics(mCavernAtmosPressure2Buff.second, mCavernAtmosPressure2Buff.first, times, timeInterval, nthreads, minPoints, minPoints);
+  const auto surfaceAtmosPressureStats = o2::math_utils::getRollingStatistics(mSurfaceAtmosPressureBuff.second, mSurfaceAtmosPressureBuff.first, times, timeInterval, nthreads, minPoints, minPoints);
+
+  // subtract the moving median values from the different sensors if they are ok
+  std::pair<std::vector<float>, std::vector<TimeStampType>> cavernAtmosPressure12;
+  std::pair<std::vector<float>, std::vector<TimeStampType>> cavernAtmosPressure1S;
+  std::pair<std::vector<float>, std::vector<TimeStampType>> cavernAtmosPressure2S;
+  cavernAtmosPressure12.first.reserve(nIntervals);
+  cavernAtmosPressure1S.first.reserve(nIntervals);
+  cavernAtmosPressure2S.first.reserve(nIntervals);
+  cavernAtmosPressure12.second.reserve(nIntervals);
+  cavernAtmosPressure1S.second.reserve(nIntervals);
+  cavernAtmosPressure2S.second.reserve(nIntervals);
+
+  for (int i = 0; i < nIntervals; i++) {
+    // coarse check if data is close by
+    const int maxDist = 600 * 1000;
+    const bool cavernOk = (cavernAtmosPressureStats.median[i] > 0) && (cavernAtmosPressureStats.closestDistanceL[i] < maxDist) && (cavernAtmosPressureStats.closestDistanceR[i] < maxDist);
+    const bool cavern2Ok = (cavernAtmosPressure2Stats.median[i] > 0) && (cavernAtmosPressure2Stats.closestDistanceL[i] < maxDist) && (cavernAtmosPressure2Stats.closestDistanceR[i] < maxDist);
+    const bool surfaceOk = (surfaceAtmosPressureStats.median[i] > 0) && (surfaceAtmosPressureStats.closestDistanceL[i] < maxDist) && (surfaceAtmosPressureStats.closestDistanceR[i] < maxDist);
+
+    if (cavernOk && cavern2Ok) {
+      cavernAtmosPressure12.first.emplace_back(cavernAtmosPressureStats.median[i] - cavernAtmosPressure2Stats.median[i]);
+      cavernAtmosPressure12.second.emplace_back(times[i]);
+    }
+    if (cavernOk && surfaceOk) {
+      cavernAtmosPressure1S.first.emplace_back(cavernAtmosPressureStats.median[i] - surfaceAtmosPressureStats.median[i]);
+      cavernAtmosPressure1S.second.emplace_back(times[i]);
+    }
+    if (cavern2Ok && surfaceOk) {
+      cavernAtmosPressure2S.first.emplace_back(cavernAtmosPressure2Stats.median[i] - surfaceAtmosPressureStats.median[i]);
+      cavernAtmosPressure2S.second.emplace_back(times[i]);
+    }
+  }
+
+  fillBuffer(mPressure12Buff, cavernAtmosPressure12, tStartRef, minPointsRef);
+  fillBuffer(mPressure1SBuff, cavernAtmosPressure1S, tStartRef, minPointsRef);
+  fillBuffer(mPressure2SBuff, cavernAtmosPressure2S, tStartRef, minPointsRef);
+
+  // get long term median of diffs - this is used for normalization of the pressure values -
+  const auto cavernAtmosPressure12Stats = o2::math_utils::getRollingStatistics(mPressure12Buff.second, mPressure12Buff.first, times, timeIntervalRef, nthreads, 3, minPointsRef);
+  const auto cavernAtmosPressure1SStats = o2::math_utils::getRollingStatistics(mPressure1SBuff.second, mPressure1SBuff.first, times, timeIntervalRef, nthreads, 3, minPointsRef);
+  const auto cavernAtmosPressure2SStats = o2::math_utils::getRollingStatistics(mPressure2SBuff.second, mPressure2SBuff.first, times, timeIntervalRef, nthreads, 3, minPointsRef);
+
+  // calculate diffs of median values
+  const float maxDist = 20 * timeInterval;
+  const float maxDiff = 0.2;
+  std::pair<std::vector<float>, std::vector<TimeStampType>> robustPressureTmp;
+  robustPressureTmp.first.reserve(nIntervals);
+  robustPressureTmp.second.reserve(nIntervals);
+  std::vector<uint8_t> isOk(nIntervals);
+
+  for (int i = 0; i < nIntervals; ++i) {
+    // difference beween pressure values corrected for the long term median
+    const float delta12 = cavernAtmosPressureStats.median[i] - cavernAtmosPressure2Stats.median[i] - cavernAtmosPressure12Stats.median[i];
+    const float delta1S = cavernAtmosPressureStats.median[i] - surfaceAtmosPressureStats.median[i] - cavernAtmosPressure1SStats.median[i];
+    const float delta2S = cavernAtmosPressure2Stats.median[i] - surfaceAtmosPressureStats.median[i] - cavernAtmosPressure2SStats.median[i];
+
+    const auto distCavernAtmosPressureL = cavernAtmosPressureStats.closestDistanceL[i];
+    const auto distCavernAtmosPressure2L = cavernAtmosPressure2Stats.closestDistanceL[i];
+    const auto distSurfaceAtmosPressureL = surfaceAtmosPressureStats.closestDistanceL[i];
+    const auto distCavernAtmosPressureR = cavernAtmosPressureStats.closestDistanceR[i];
+    const auto distCavernAtmosPressure2R = cavernAtmosPressure2Stats.closestDistanceR[i];
+    const auto distSurfaceAtmosPressureR = surfaceAtmosPressureStats.closestDistanceR[i];
+
+    // check if data is ok
+    const bool cavernDistOk = (cavernAtmosPressureStats.median[i] > 0) && ((distCavernAtmosPressureL < maxDist) || (distCavernAtmosPressureR < maxDist));
+    const bool cavern2DistOk = (cavernAtmosPressure2Stats.median[i] > 0) && ((distCavernAtmosPressure2L < maxDist) || (distCavernAtmosPressure2R < maxDist));
+    const bool surfaceDistOk = (surfaceAtmosPressureStats.median[i] > 0) && ((distSurfaceAtmosPressureL < maxDist) || (distSurfaceAtmosPressureR < maxDist));
+    const bool onlyOneSensor = (cavernDistOk + cavern2DistOk + surfaceDistOk) == 1; // check if only 1 sensor exists, if so use that sensor
+
+    uint8_t maskIsOkTmp = 0;
+    const int cavernBit = 0;  // val 1
+    const int cavern2Bit = 1; // val 2
+    const int surfaceBit = 2; // val 4
+
+    // check if ratio sensor 1 and 2 are good
+    // maskIsOkTmp = 3
+    if (((std::abs(delta12) < maxDiff) && (cavernDistOk && cavern2DistOk)) || onlyOneSensor) {
+      if (cavernDistOk) {
+        maskIsOkTmp |= (1 << cavernBit);
+      }
+      if (cavern2DistOk) {
+        maskIsOkTmp |= (1 << cavern2Bit);
+      }
+    }
+
+    // check if ratio sensor 1 and surface are good
+    // maskIsOkTmp = 5
+    if ((std::abs(delta1S) < maxDiff) && ((cavernDistOk && surfaceDistOk)) || onlyOneSensor) {
+      if (cavernDistOk) {
+        maskIsOkTmp |= (1 << cavernBit);
+      }
+      if (surfaceDistOk) {
+        maskIsOkTmp |= (1 << surfaceBit);
+      }
+    }
+
+    // check if ratio sensor 2 and surface are good
+    // maskIsOkTmp = 6
+    if ((std::abs(delta2S) < maxDiff) && ((cavern2DistOk && surfaceDistOk)) || onlyOneSensor) {
+      if (cavern2DistOk) {
+        maskIsOkTmp |= (1 << cavern2Bit);
+      }
+      if (surfaceDistOk) {
+        maskIsOkTmp |= (1 << surfaceBit);
+      }
+    }
+
+    // calculate robust pressure
+    float pressure = 0;
+    int pressureCount = 0;
+    if ((maskIsOkTmp >> cavernBit) & 1) {
+      pressure += cavernAtmosPressureStats.median[i];
+      pressureCount++;
+    }
+
+    if ((maskIsOkTmp >> cavern2Bit) & 1) {
+      pressure += cavernAtmosPressure2Stats.median[i] + cavernAtmosPressure12Stats.median[i];
+      pressureCount++;
+    }
+
+    if ((maskIsOkTmp >> surfaceBit) & 1) {
+      pressure += surfaceAtmosPressureStats.median[i] + cavernAtmosPressure1SStats.median[i];
+      pressureCount++;
+    }
+
+    isOk[i] = maskIsOkTmp;
+    if (pressureCount > 0) {
+      pressure /= pressureCount;
+      robustPressureTmp.first.emplace_back(pressure);
+      robustPressureTmp.second.emplace_back(times[i]);
+    }
+  }
+
+  fillBuffer(mRobPressureBuff, robustPressureTmp, tStartRef, minPointsRef);
+
+  RobustPressure& pOut = robustPressure;
+  pOut.surfaceAtmosPressure = std::move(surfaceAtmosPressureStats);
+  pOut.cavernAtmosPressure2 = std::move(cavernAtmosPressure2Stats);
+  pOut.cavernAtmosPressure = std::move(cavernAtmosPressureStats);
+  pOut.cavernAtmosPressure12 = std::move(cavernAtmosPressure12Stats);
+  pOut.cavernAtmosPressure1S = std::move(cavernAtmosPressure1SStats);
+  pOut.cavernAtmosPressure2S = std::move(cavernAtmosPressure2SStats);
+  pOut.isOk = std::move(isOk);
+  pOut.robustPressure = o2::math_utils::getRollingStatistics(mRobPressureBuff.second, mRobPressureBuff.first, times, timeInterval, nthreads, 1, 5).median;
+  pOut.time = std::move(times);
+  pOut.timeInterval = timeInterval;
+  pOut.timeIntervalRef = timeIntervalRef;
+  pOut.maxDist = maxDist;
+  pOut.maxDiff = maxDiff;
+}
+
+void Pressure::setAliases(TTree* tree)
+{
+  tree->SetAlias("cavernDistOk", "robustPressure.cavernAtmosPressure.median>0 && (robustPressure.cavernAtmosPressure.closestDistanceR<robustPressure.maxDist || robustPressure.cavernAtmosPressure.closestDistanceL<robustPressure.maxDist)");
+  tree->SetAlias("cavern2DistOk", "robustPressure.cavernAtmosPressure2.median>0 && (robustPressure.cavernAtmosPressure2.closestDistanceR<robustPressure.maxDist || robustPressure.cavernAtmosPressure2.closestDistanceL<robustPressure.maxDist)");
+  tree->SetAlias("surfaceDistOk", "robustPressure.surfaceAtmosPressure.median>0 && (robustPressure.surfaceAtmosPressure.closestDistanceR<robustPressure.maxDist || robustPressure.surfaceAtmosPressure.closestDistanceL<robustPressure.maxDist)");
+  tree->SetAlias("onlyOneSensor", "(cavernDistOk + cavern2DistOk + surfaceDistOk) == 1");
+  tree->SetAlias("delta12", "robustPressure.cavernAtmosPressure.median - robustPressure.cavernAtmosPressure2.median - robustPressure.cavernAtmosPressure12.median");
+  tree->SetAlias("delta1S", "robustPressure.cavernAtmosPressure.median - robustPressure.surfaceAtmosPressure.median - robustPressure.cavernAtmosPressure1S.median");
+  tree->SetAlias("delta2S", "robustPressure.surfaceAtmosPressure.median - robustPressure.cavernAtmosPressure2.median - robustPressure.cavernAtmosPressure2S.median");
+  tree->SetAlias("delta12_Ok", "abs(delta12)<robustPressure.maxDiff");
+  tree->SetAlias("delta1S_Ok", "abs(delta1S)<robustPressure.maxDiff");
+  tree->SetAlias("delta2S_Ok", "abs(delta2S)<robustPressure.maxDiff");
+}
diff --git a/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h b/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
index f248a74950a1f..fd5abca99cb0f 100644
--- a/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
+++ b/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
@@ -69,6 +69,8 @@
 #pragma link C++ class o2::tpc::dcs::DataPoint < o2::tpc::dcs::HV::StackState> + ;
 #pragma link C++ class o2::tpc::dcs::DataPointVector < o2::tpc::dcs::HV::StackState> + ;
 #pragma link C++ class o2::tpc::dcs::Gas + ;
+#pragma link C++ class o2::tpc::dcs::Pressure + ;
+#pragma link C++ class o2::tpc::dcs::RobustPressure + ;
 #pragma link C++ class o2::tpc::PIDResponse + ;
 #pragma link C++ class o2::tpc::TriggerWordDLBZS + ;
 #pragma link C++ class o2::tpc::TriggerInfoDLBZS + ;
diff --git a/Detectors/DCS/testWorkflow/src/DCSDataReplaySpec.cxx b/Detectors/DCS/testWorkflow/src/DCSDataReplaySpec.cxx
index 783f6ae76e707..8dc003fc176f3 100644
--- a/Detectors/DCS/testWorkflow/src/DCSDataReplaySpec.cxx
+++ b/Detectors/DCS/testWorkflow/src/DCSDataReplaySpec.cxx
@@ -46,6 +46,10 @@ class DCSDataReplayer : public o2::framework::Task
   char mAlias[50];
   uint64_t mMaxTF;
   uint64_t mTFs = 0;
+  int deltaTimeSendData = -1;
+  uint32_t startTime = -1;
+  uint32_t endTime = 0;
+  std::vector<std::vector<int>> dataIndicesPerTF;
   TTree mInputData;
   std::vector<o2::dcs::test::HintType> mDataPointHints;
   o2::header::DataDescription mDataDescription;
@@ -59,6 +63,7 @@ void DCSDataReplayer::init(o2::framework::InitContext& ic)
 {
   mMaxTF = ic.options().get<int64_t>("max-timeframes");
   mInputFileName = ic.options().get<std::string>("input-file");
+  deltaTimeSendData = ic.options().get<int>("delta-time-send-data");
   mInputData.ReadFile(mInputFileName.data(), "time/D:alias/C:value/D", ';');
   mInputData.SetBranchAddress("time", &mTime);
   mInputData.SetBranchAddress("value", &mValue);
@@ -73,16 +78,61 @@ void DCSDataReplayer::run(o2::framework::ProcessingContext& pc)
     LOG(info) << "Data generator reached TF " << tfid << ", stopping";
     pc.services().get<o2::framework::ControlService>().endOfStream();
     pc.services().get<o2::framework::ControlService>().readyToQuit(o2::framework::QuitRequest::Me);
+    return;
   }
 
   std::vector<o2::dcs::DataPointCompositeObject> dpcoms;
+
   for (Long64_t iEntry = 0; iEntry < mInputData.GetEntries(); ++iEntry) {
-    mInputData.GetEntry(iEntry);
+    int entryTree = iEntry;
+
+    // load only releavant entries if requested
+    if (deltaTimeSendData > 0 && tfid > 2) {
+
+      if (tfid - 1 >= dataIndicesPerTF.size()) {
+        LOGP(warning, "TF ID {} is larger than the number of TFs in dataIndicesPerTF: {}", tfid, dataIndicesPerTF.size());
+        break;
+      }
+
+      if (iEntry >= dataIndicesPerTF[tfid - 1].size()) {
+        break;
+      } else {
+        entryTree = dataIndicesPerTF[tfid - 1][iEntry];
+      }
+    }
+
+    mInputData.GetEntry(entryTree);
     const auto ultime = uint64_t(std::round(mTime * 1000));
     const auto seconds = uint32_t(ultime / 1000);
     const auto msec = uint16_t(ultime % 1000);
-
-    dpcoms.emplace_back(o2::dcs::createDataPointCompositeObject(mAlias, float(mValue), seconds, msec));
+    if (deltaTimeSendData > 0) {
+      // send data in packages
+      if (tfid == 0) {
+        startTime = std::min(startTime, seconds);
+        endTime = std::max(endTime, seconds);
+        if (iEntry == mInputData.GetEntries() - 1) {
+          const int totalTFs = (endTime - startTime) / deltaTimeSendData + 1;
+          dataIndicesPerTF.resize(totalTFs);
+          LOGP(info, "Sending data from {} to {} with {} TFs", startTime, endTime, totalTFs);
+        }
+      } else {
+        if (tfid == 1) {
+          const int index = (seconds - startTime) / deltaTimeSendData;
+          dataIndicesPerTF[index].emplace_back(iEntry);
+        }
+        const uint64_t startTimeTF = startTime + (tfid - 1) * deltaTimeSendData;
+        const uint64_t endTimeTF = startTimeTF + deltaTimeSendData;
+        if (seconds >= startTimeTF && seconds < endTimeTF) {
+          dpcoms.emplace_back(o2::dcs::createDataPointCompositeObject(mAlias, float(mValue), seconds, msec));
+          // check if all data has been processed
+          if (seconds == endTime) {
+            mMaxTF = tfid;
+          }
+        }
+      }
+    } else {
+      dpcoms.emplace_back(o2::dcs::createDataPointCompositeObject(mAlias, float(mValue), seconds, msec));
+    }
   }
   // auto dpcoms = generate(mDataPointHints, fraction, tfid);
 
@@ -113,6 +163,7 @@ o2::framework::DataProcessorSpec getDCSDataReplaySpec(std::vector<o2::dcs::test:
     Options{
       {"max-timeframes", VariantType::Int64, 99999999999ll, {"max TimeFrames to generate"}},
       {"delta-fraction", VariantType::Float, 0.05f, {"fraction of data points to put in the delta"}},
+      {"delta-time-send-data", VariantType::Int, -1, {"if larger than zero the data will be send in time intervals of this size"}},
       {"input-file", VariantType::String, "", {"Input file with data to play back"}}}};
 }
 } // namespace o2::dcs::test
diff --git a/Detectors/TPC/base/include/TPCBase/CDBTypes.h b/Detectors/TPC/base/include/TPCBase/CDBTypes.h
index 8cf27330b8fc5..d721a063c1830 100644
--- a/Detectors/TPC/base/include/TPCBase/CDBTypes.h
+++ b/Detectors/TPC/base/include/TPCBase/CDBTypes.h
@@ -38,6 +38,7 @@ enum class CDBType {
   CalGas,               ///< DCS gas measurements
   CalTemperature,       ///< DCS temperature measurements
   CalHV,                ///< DCS HV measurements
+  CalPressure,          ///< DCS pressure measurements
   CalTopologyGain,      ///< Q cluster topology correction
                         ///
   ConfigFEEPad,         ///< FEE pad-by-pad configuration map
@@ -106,6 +107,7 @@ const std::unordered_map<CDBType, const std::string> CDBTypeMap{
   {CDBType::CalGas, "TPC/Calib/Gas"},
   {CDBType::CalTemperature, "TPC/Calib/Temperature"},
   {CDBType::CalHV, "TPC/Calib/HV"},
+  {CDBType::CalPressure, "TPC/Calib/Pressure"},
   {CDBType::CalTopologyGain, "TPC/Calib/TopologyGainPiecewise"},
   {CDBType::CalVDriftTgl, "TPC/Calib/VDriftTgl"},
   //
diff --git a/Detectors/TPC/calibration/CMakeLists.txt b/Detectors/TPC/calibration/CMakeLists.txt
index 7722fc4e2884f..8bcb3254edb32 100644
--- a/Detectors/TPC/calibration/CMakeLists.txt
+++ b/Detectors/TPC/calibration/CMakeLists.txt
@@ -58,6 +58,7 @@ o2_add_library(TPCCalibration
                        src/TPCMShapeCorrection.cxx
                        src/DigitAdd.cxx
                        src/CorrectdEdxDistortions.cxx
+                       src/PressureTemperatureHelper.cxx
                PUBLIC_LINK_LIBRARIES O2::DataFormatsTPC O2::TPCBase
                                      O2::TPCReconstruction ROOT::Minuit
                                      Microsoft.GSL::GSL
@@ -115,7 +116,8 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/CorrMapParam.h
                                   include/TPCCalibration/TPCMShapeCorrection.h
                                   include/TPCCalibration/DigitAdd.h
-                                  include/TPCCalibration/CorrectdEdxDistortions.h)
+                                  include/TPCCalibration/CorrectdEdxDistortions.h
+                                  include/TPCCalibration/PressureTemperatureHelper.h)
 
 o2_add_test_root_macro(macro/comparePedestalsAndNoise.C
                        PUBLIC_LINK_LIBRARIES O2::TPCBase
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
new file mode 100644
index 0000000000000..b636fdd2f296d
--- /dev/null
+++ b/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
@@ -0,0 +1,84 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file PressureTemperatureHelper.h
+/// \brief Helper class to extract pressure and temperature
+/// \author Matthias Kleiner <mkleiner@ikf.uni-frankfurt.de>
+
+#ifndef PRESSURETEMPERATUREHELPER_H_
+#define PRESSURETEMPERATUREHELPER_H_
+
+#include "GPUCommonRtypes.h"
+#include "Headers/DataHeader.h"
+#include "CommonDataFormat/Pair.h"
+
+namespace o2::framework
+{
+class ProcessingContext;
+class ConcreteDataMatcher;
+class InputSpec;
+class OutputSpec;
+} // namespace o2::framework
+
+namespace o2::tpc
+{
+
+class PressureTemperatureHelper
+{
+ public:
+  PressureTemperatureHelper() = default;
+
+  /// check for new CCDB objects
+  bool accountCCDBInputs(const o2::framework::ConcreteDataMatcher& matcher, void* obj);
+
+  /// trigger checking for CCDB objects
+  void extractCCDBInputs(o2::framework::ProcessingContext& pc) const;
+
+  // add required inputs
+  static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs);
+
+  /// define outputs in case pressure and temperature will be send
+  static void setOutputs(std::vector<o2::framework::OutputSpec>& outputs);
+
+  /// send temperature and pressure for given time stamp
+  void sendPTForTS(o2::framework::ProcessingContext& pc, const uint64_t timestamp) const;
+
+  /// set fit interval range for temperature in ms
+  void setFitIntervalTemp(const int fitIntervalMS) { mFitIntervalMS = fitIntervalMS; }
+
+  /// \brief interpolate input values for given timestamp
+  /// \param timestamps time stamps of the data
+  /// \param values data points
+  /// \param timestamp time where to interpolate the values
+  float interpolate(const std::vector<uint64_t>& timestamps, const std::vector<float>& values, uint64_t timestamp) const;
+
+  /// get pressure for given time stamp in ms
+  float getPressure(const uint64_t timestamp) const { return interpolate(mPressure.second, mPressure.first, timestamp); }
+
+  /// get temperature for given time stamp in ms
+  dataformats::Pair<float, float> getTemperature(const uint64_t timestamp) const { return dataformats::Pair<float, float>{interpolate(mTemperatureA.second, mTemperatureA.first, timestamp), interpolate(mTemperatureC.second, mTemperatureC.first, timestamp)}; }
+
+  static constexpr o2::header::DataDescription getDataDescriptionPressure() { return o2::header::DataDescription{"pressure"}; }
+  static constexpr o2::header::DataDescription getDataDescriptionTemperature() { return o2::header::DataDescription{"temperature"}; }
+
+ protected:
+  static void addInput(std::vector<o2::framework::InputSpec>& inputs, o2::framework::InputSpec&& isp);
+  static void addOutput(std::vector<o2::framework::OutputSpec>& outputs, o2::framework::OutputSpec&& osp);
+
+  std::pair<std::vector<float>, std::vector<uint64_t>> mPressure;     ///< pressure values for both measurements
+  std::pair<std::vector<float>, std::vector<uint64_t>> mTemperatureA; ///< temperature values A-side
+  std::pair<std::vector<float>, std::vector<uint64_t>> mTemperatureC; ///< temperature values C-side
+  int mFitIntervalMS{5 * 60 * 1000};                                  ///< fit interval for the temperature
+
+  ClassDefNV(PressureTemperatureHelper, 1);
+};
+} // namespace o2::tpc
+#endif
diff --git a/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx b/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
new file mode 100644
index 0000000000000..54145f0ecfaf1
--- /dev/null
+++ b/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
@@ -0,0 +1,119 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file PressureTemperatureHelper.cxx
+/// \brief Helper class to extract pressure and temperature
+/// \author Matthias Kleiner <mkleiner@ikf.uni-frankfurt.de>
+
+#include "TPCCalibration/PressureTemperatureHelper.h"
+#include "TPCBase/CDBInterface.h"
+#include "Framework/ProcessingContext.h"
+#include "DataFormatsTPC/DCS.h"
+#include "Framework/InputRecord.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/DataAllocator.h"
+
+using namespace o2::tpc;
+using namespace o2::framework;
+
+void PressureTemperatureHelper::extractCCDBInputs(ProcessingContext& pc) const
+{
+  pc.inputs().get<dcs::Pressure*>("pressure");
+  pc.inputs().get<dcs::Temperature*>("temperature");
+}
+
+bool PressureTemperatureHelper::accountCCDBInputs(const ConcreteDataMatcher& matcher, void* obj)
+{
+  if (matcher == ConcreteDataMatcher(o2::header::gDataOriginTPC, "PRESSURECCDB", 0)) {
+    LOGP(info, "Updating pressure");
+    const auto& pressure = ((dcs::Pressure*)obj);
+    mPressure.second = pressure->robustPressure.time;
+    mPressure.first = pressure->robustPressure.robustPressure;
+    return true;
+  }
+
+  if (matcher == ConcreteDataMatcher(o2::header::gDataOriginTPC, "TEMPERATURECCDB", 0)) {
+    LOGP(info, "Updating temperature");
+    auto temp = *(dcs::Temperature*)obj;
+    temp.fitTemperature(o2::tpc::Side::A, mFitIntervalMS, false);
+    temp.fitTemperature(o2::tpc::Side::C, mFitIntervalMS, false);
+
+    mTemperatureA.first.clear();
+    mTemperatureC.first.clear();
+    mTemperatureA.second.clear();
+    mTemperatureC.second.clear();
+
+    for (const auto& dp : temp.statsA.data) {
+      mTemperatureA.first.emplace_back(dp.value.mean);
+      mTemperatureA.second.emplace_back(dp.time);
+    }
+
+    for (const auto& dp : temp.statsC.data) {
+      mTemperatureC.first.emplace_back(dp.value.mean);
+      mTemperatureC.second.emplace_back(dp.time);
+    }
+    return true;
+  }
+  return false;
+}
+
+void PressureTemperatureHelper::requestCCDBInputs(std::vector<InputSpec>& inputs)
+{
+  addInput(inputs, {"pressure", o2::header::gDataOriginTPC, "PRESSURECCDB", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalPressure), {}, 1)});
+  addInput(inputs, {"temperature", o2::header::gDataOriginTPC, "TEMPERATURECCDB", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalTemperature), {}, 1)});
+}
+
+void PressureTemperatureHelper::addInput(std::vector<InputSpec>& inputs, InputSpec&& isp)
+{
+  if (std::find(inputs.begin(), inputs.end(), isp) == inputs.end()) {
+    inputs.emplace_back(isp);
+  }
+}
+
+void PressureTemperatureHelper::setOutputs(std::vector<OutputSpec>& outputs)
+{
+  addOutput(outputs, {o2::header::gDataOriginTPC, o2::tpc::PressureTemperatureHelper::getDataDescriptionPressure(), 0, Lifetime::Timeframe});
+  addOutput(outputs, {o2::header::gDataOriginTPC, o2::tpc::PressureTemperatureHelper::getDataDescriptionTemperature(), 0, Lifetime::Timeframe});
+}
+
+void PressureTemperatureHelper::addOutput(std::vector<OutputSpec>& outputs, OutputSpec&& osp)
+{
+  if (std::find(outputs.begin(), outputs.end(), osp) == outputs.end()) {
+    outputs.emplace_back(osp);
+  }
+}
+
+float PressureTemperatureHelper::interpolate(const std::vector<uint64_t>& timestamps, const std::vector<float>& values, uint64_t timestamp) const
+{
+  if (auto idxClosest = o2::math_utils::findClosestIndices(timestamps, timestamp)) {
+    auto [idxLeft, idxRight] = *idxClosest;
+    if (idxRight > idxLeft) {
+      const uint64_t x0 = timestamps[idxLeft];
+      const uint64_t x1 = timestamps[idxRight];
+      const float y0 = values[idxLeft];
+      const float y1 = values[idxRight];
+      const float y = (y0 * (x1 - timestamp) + y1 * (timestamp - x0)) / (x1 - x0);
+      return y;
+    } else {
+      return values[idxLeft];
+    }
+  }
+  return 0; // this should never happen
+}
+
+void PressureTemperatureHelper::sendPTForTS(o2::framework::ProcessingContext& pc, const uint64_t timestamp) const
+{
+  const float pressure = getPressure(timestamp);
+  const auto temp = getTemperature(timestamp);
+  LOGP(info, "Sending pressure {}, temperature A {} and temperature C {} for timestamp {}", pressure, temp.first, temp.second, timestamp);
+  pc.outputs().snapshot(Output{o2::header::gDataOriginTPC, o2::tpc::PressureTemperatureHelper::getDataDescriptionTemperature()}, temp);
+  pc.outputs().snapshot(Output{o2::header::gDataOriginTPC, o2::tpc::PressureTemperatureHelper::getDataDescriptionPressure()}, pressure);
+}
diff --git a/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h b/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
index d42627197cd7f..6e15e2dd0427a 100644
--- a/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
+++ b/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
@@ -122,4 +122,5 @@
 #pragma link C++ struct o2::tpc::BoundaryPotentialIFC + ;
 #pragma link C++ class o2::tpc::DigitAdd + ;
 #pragma link C++ class std::vector < o2::tpc::DigitAdd> + ;
+#pragma link C++ class o2::tpc::PressureTemperatureHelper + ;
 #endif
diff --git a/Detectors/TPC/dcs/CMakeLists.txt b/Detectors/TPC/dcs/CMakeLists.txt
index 9db4e26a7429d..31524dd5f2c2f 100644
--- a/Detectors/TPC/dcs/CMakeLists.txt
+++ b/Detectors/TPC/dcs/CMakeLists.txt
@@ -18,8 +18,7 @@ o2_add_library(TPCdcs
                PUBLIC_LINK_LIBRARIES O2::Framework
                                      O2::DetectorsDCS
                                      O2::DataFormatsTPC
-                                     O2::TPCBase
-                                     ROOT::Minuit)
+                                     O2::TPCBase)
 
 o2_target_root_dictionary(TPCdcs
                           HEADERS include/TPCdcs/DCSProcessor.h)
diff --git a/Detectors/TPC/dcs/include/TPCdcs/DCSProcessor.h b/Detectors/TPC/dcs/include/TPCdcs/DCSProcessor.h
index 23c6df26c0fd7..e6ead9b0cb302 100644
--- a/Detectors/TPC/dcs/include/TPCdcs/DCSProcessor.h
+++ b/Detectors/TPC/dcs/include/TPCdcs/DCSProcessor.h
@@ -46,22 +46,14 @@ class DCSProcessor
   void fillTemperature(const DPCOM& dp);
   void fillHV(const DPCOM& dp);
   void fillGas(const DPCOM& dp);
+  void fillPressure(const DPCOM& dp);
   void finalizeSlot();
   void finalize();
 
   void finalizeTemperature();
   void finalizeHighVoltage();
   void finalizeGas();
-
-  void fitTemperature(Side side);
-
-  /// get minimum time over all sensors. Assumes data is sorted in time
-  template <typename T>
-  dcs::TimeStampType getMinTime(const std::vector<dcs::DataPointVector<T>>& data);
-
-  /// get maximum time over all sensors. Assumes data is sorted in time
-  template <typename T>
-  dcs::TimeStampType getMaxTime(const std::vector<dcs::DataPointVector<T>>& data);
+  void finalizePressure();
 
   /// name of the debug output tree
   void setDebugOutputName(std::string_view name) { mDebugOutputName = name; }
@@ -75,9 +67,17 @@ class DCSProcessor
   /// set the fit interval
   void setFitInterval(dcs::TimeStampType interval) { mFitInterval = interval; }
 
+  /// set the interval for averaging the pressure values
+  void setPressureInterval(dcs::TimeStampType interval) { mPressureInterval = interval; }
+
+  void setRefPressureInterval(dcs::TimeStampType interval) { mPressureIntervalRef = interval; }
+
   /// get fit interval
   auto getFitInterval() const { return mFitInterval; }
 
+  /// get fit interval
+  auto getPressureInterval() const { return mPressureInterval; }
+
   /// round to fit interval
   void setRoundToInterval(const bool round = true) { mRoundToInterval = round; }
 
@@ -87,6 +87,7 @@ class DCSProcessor
     mTemperature.clear();
     mHighVoltage.clear();
     mGas.clear();
+    mPressure.clear();
 
     mTimeTemperature = {};
     mTimeHighVoltage = {};
@@ -99,21 +100,27 @@ class DCSProcessor
   const auto& getTimeTemperature() const { return mTimeTemperature; }
   const auto& getTimeHighVoltage() const { return mTimeHighVoltage; }
   const auto& getTimeGas() const { return mTimeGas; }
+  const auto& getTimePressure() const { return mTimePressure; }
 
   auto& getTemperature() { return mTemperature; }
   auto& getHighVoltage() { return mHighVoltage; }
   auto& getGas() { return mGas; }
+  auto& getPressure() { return mPressure; }
 
  private:
   dcs::Temperature mTemperature; ///< temperature value store
   dcs::HV mHighVoltage;          ///< HV value store
   dcs::Gas mGas;                 ///< Gas value store
+  dcs::Pressure mPressure;       ///< Pressure value
 
   TimeRange mTimeTemperature; ///< Time range for temperature values
   TimeRange mTimeHighVoltage; ///< Time range for high voltage values
   TimeRange mTimeGas;         ///< Time range for gas values
+  TimeRange mTimePressure;    ///< Time range for pressure values
 
   dcs::TimeStampType mFitInterval{5 * 60 * 1000};                ///< fit interval (ms) e.g. for temparature data
+  dcs::TimeStampType mPressureInterval{200 * 1000};              ///< interval (ms) for averaging pressure values
+  dcs::TimeStampType mPressureIntervalRef{60 * 60 * 1000};       ///< interval (ms) for averaging pressure values for longer reference time interval
   bool mWriteDebug{false};                                       ///< switch to dump debug tree
   bool mRoundToInterval{false};                                  ///< round to full fit interval e.g. full minute
   bool mHasData{false};                                          ///< if there are data to process
@@ -123,44 +130,5 @@ class DCSProcessor
   ClassDefNV(DCSProcessor, 0);
 };
 
-template <typename T>
-dcs::TimeStampType DCSProcessor::getMinTime(const std::vector<dcs::DataPointVector<T>>& data)
-{
-  constexpr auto max = std::numeric_limits<dcs::TimeStampType>::max();
-  dcs::TimeStampType firstTime = std::numeric_limits<dcs::TimeStampType>::max();
-  for (const auto& sensor : data) {
-    const auto time = sensor.data.size() ? sensor.data.front().time : max;
-    firstTime = std::min(firstTime, time);
-  }
-
-  // mFitInterval is is seconds. Round to full amount.
-  // if e.g. mFitInterval = 5min, then round 10:07:20.510 to 10:05:00.000
-  if (mRoundToInterval) {
-    firstTime -= (firstTime % mFitInterval);
-  }
-
-  return firstTime;
-}
-
-template <typename T>
-dcs::TimeStampType DCSProcessor::getMaxTime(const std::vector<dcs::DataPointVector<T>>& data)
-{
-  constexpr auto min = 0;
-  dcs::TimeStampType lastTime = 0;
-  for (const auto& sensor : data) {
-    const auto time = sensor.data.size() ? sensor.data.back().time : 0;
-    lastTime = std::max(lastTime, time);
-  }
-
-  // mFitInterval is is seconds. Round to full amount.
-  // if e.g. mFitInterval = 5min, then round 10:07:20.510 to 10:05:00.000
-  // TODO: fix this
-  // if (mRoundToInterval) {
-  // lastTime -= (lastTime % mFitInterval);
-  //}
-
-  return lastTime;
-}
-
 } // namespace o2::tpc
 #endif
diff --git a/Detectors/TPC/dcs/src/DCSDPHints.cxx b/Detectors/TPC/dcs/src/DCSDPHints.cxx
index 00ca097a455eb..02ada7d588f9b 100644
--- a/Detectors/TPC/dcs/src/DCSDPHints.cxx
+++ b/Detectors/TPC/dcs/src/DCSDPHints.cxx
@@ -98,5 +98,10 @@ std::vector<o2::dcs::test::HintType> o2::tpc::dcs::getTPCDCSDPHints(const int ma
   dphints.emplace_back(o2::dcs::test::DataPointHint<int32_t>{fmt::format("TPC_HV_C[00..{:02}]_I_STATUS", maxSectors), 0, 29});
   dphints.emplace_back(o2::dcs::test::DataPointHint<int32_t>{fmt::format("TPC_HV_C[00..{:02}]_O[1..3]_STATUS", maxSectors), 0, 29});
 
+  // ===| pressure values |=======================================================
+  dphints.emplace_back(o2::dcs::test::DataPointHint<double>{"CavernAtmosPressure", 850., 1050.});
+  dphints.emplace_back(o2::dcs::test::DataPointHint<double>{"CavernAtmosPressure2", 850., 1050.});
+  dphints.emplace_back(o2::dcs::test::DataPointHint<double>{"SurfaceAtmosPressure", 850., 1050.});
+
   return dphints;
 }
diff --git a/Detectors/TPC/dcs/src/DCSProcessor.cxx b/Detectors/TPC/dcs/src/DCSProcessor.cxx
index a26bce43e5c2e..4c9d196432687 100644
--- a/Detectors/TPC/dcs/src/DCSProcessor.cxx
+++ b/Detectors/TPC/dcs/src/DCSProcessor.cxx
@@ -15,10 +15,6 @@
 
 #include <string_view>
 
-// ROOT includes
-#include "TLinearFitter.h"
-#include "TVectorD.h"
-
 // O2 includes
 #include "DetectorsDCS/DataPointIdentifier.h"
 #include "DetectorsDCS/DataPointValue.h"
@@ -43,6 +39,8 @@ void DCSProcessor::process(const gsl::span<const DPCOM> dps)
   constexpr auto HV_ID{"TPC_HV"sv};
   constexpr auto GAS_ID1{"TPC_GC"sv};
   constexpr auto GAS_ID2{"TPC_An"sv};
+  constexpr auto PRESS_ID1{"Cavern"sv};
+  constexpr auto PRESS_ID2{"Surfac"sv};
 
   for (const auto& dp : dps) {
     const std::string_view alias(dp.id.get_alias());
@@ -56,8 +54,11 @@ void DCSProcessor::process(const gsl::span<const DPCOM> dps)
     } else if (id == GAS_ID1 || id == GAS_ID2) {
       LOGP(debug, "Gas DP: {}", alias);
       fillGas(dp);
+    } else if (id == PRESS_ID1 || id == PRESS_ID2) {
+      LOGP(debug, "Pressure DP: {}", alias);
+      fillPressure(dp);
     } else {
-      LOGP(warning, "Unknown data point: {}", alias);
+      LOGP(warning, "Unknown data point: {} with id {}", alias, id);
     }
   }
 }
@@ -125,84 +126,38 @@ void DCSProcessor::fillGas(const DPCOM& dp)
   mGas.fill(alias, time, value);
 }
 
+void DCSProcessor::fillPressure(const DPCOM& dp)
+{
+  const std::string_view alias(dp.id.get_alias());
+  const auto value = getValueF(dp);
+  const auto time = dp.data.get_epoch_time();
+  mPressure.fill(alias, time, value);
+}
+
 void DCSProcessor::finalizeSlot()
 {
   finalizeTemperature();
   finalizeHighVoltage();
   finalizeGas();
+  finalizePressure();
   mHasData = false;
 }
 
-void DCSProcessor::fitTemperature(Side side)
-{
-  //// temperature fits in x-y
-  TLinearFitter fitter(3, "x0 ++ x1 ++ x2");
-  bool nextInterval = true;
-  std::array<size_t, dcs::Temperature::SensorsPerSide> startPos{};
-  const size_t sensorOffset = (side == Side::C) ? dcs::Temperature::SensorsPerSide : 0;
-  dcs::TimeStampType refTime = getMinTime(mTemperature.raw);
-
-  while (nextInterval) {
-    // TODO: check if we should use refTime
-    dcs::TimeStampType firstTime = std::numeric_limits<dcs::TimeStampType>::max();
-
-    nextInterval = false;
-    for (size_t iSensor = 0; iSensor < dcs::Temperature::SensorsPerSide; ++iSensor) {
-      const auto& sensor = mTemperature.raw[iSensor + sensorOffset];
-
-      LOGP(debug, "sensor {}, start {}, size {}", sensor.sensorNumber, startPos[iSensor], sensor.data.size());
-      while (startPos[iSensor] < sensor.data.size()) {
-        const auto& dataPoint = sensor.data[startPos[iSensor]];
-        if ((dataPoint.time - refTime) >= mFitInterval) {
-          LOGP(debug, "sensor {}, {} - {} >= {}", sensor.sensorNumber, dataPoint.time, refTime, mFitInterval);
-          break;
-        }
-        nextInterval = true;
-        firstTime = std::min(firstTime, dataPoint.time);
-        const auto temperature = dataPoint.value;
-        // sanity check
-        if (temperature < 15 || temperature > 25) {
-          ++startPos[iSensor];
-          continue;
-        }
-        const auto& pos = dcs::Temperature::SensorPosition[iSensor + sensorOffset];
-        double x[] = {1., double(pos.x), double(pos.y)};
-        fitter.AddPoint(x, temperature, 1);
-        ++startPos[iSensor];
-      }
-    }
-    if (firstTime < std::numeric_limits<dcs::TimeStampType>::max()) {
-      fitter.Eval();
-      LOGP(info, "Side {}, fit interval {} - {} with {} points", int(side), refTime, refTime + mFitInterval - 1, fitter.GetNpoints());
-
-      auto& stats = (side == Side::A) ? mTemperature.statsA : mTemperature.statsC;
-      auto& stat = stats.data.emplace_back();
-      stat.time = firstTime;
-      stat.value.mean = fitter.GetParameter(0);
-      stat.value.gradX = fitter.GetParameter(1);
-      stat.value.gradY = fitter.GetParameter(2);
-
-      fitter.ClearPoints();
-      refTime += mFitInterval;
-    }
-  }
-}
-
 void DCSProcessor::finalizeTemperature()
 {
   mTemperature.sortAndClean();
-  fitTemperature(Side::A);
-  fitTemperature(Side::C);
-  mTimeTemperature = {getMinTime(mTemperature.raw), getMaxTime(mTemperature.raw)};
+  mTemperature.fitTemperature(Side::A, mFitInterval, mRoundToInterval);
+  mTemperature.fitTemperature(Side::C, mFitInterval, mRoundToInterval);
+  mTimeTemperature = {getMinTime(mTemperature.raw, mRoundToInterval, mFitInterval), getMaxTime(mTemperature.raw)};
 }
 
 void DCSProcessor::finalizeHighVoltage()
 {
   mHighVoltage.sortAndClean();
 
-  auto minTime = getMinTime(mHighVoltage.currents);
-  minTime = std::min(minTime, getMinTime(mHighVoltage.voltages));
-  minTime = std::min(minTime, getMinTime(mHighVoltage.states));
+  auto minTime = getMinTime(mHighVoltage.currents, mRoundToInterval, mFitInterval);
+  minTime = std::min(minTime, getMinTime(mHighVoltage.voltages, mRoundToInterval, mFitInterval));
+  minTime = std::min(minTime, getMinTime(mHighVoltage.states, mRoundToInterval, mFitInterval));
 
   auto maxTime = getMaxTime(mHighVoltage.currents);
   maxTime = std::max(maxTime, getMaxTime(mHighVoltage.voltages));
@@ -217,6 +172,16 @@ void DCSProcessor::finalizeGas()
   mTimeGas = {mGas.getMinTime(), mGas.getMaxTime()};
 }
 
+void DCSProcessor::finalizePressure()
+{
+  mPressure.sortAndClean();
+  mTimePressure = {mPressure.getMinTime(), mPressure.getMaxTime()};
+  // if there is data perform the processing
+  if (mTimePressure.last > 0) {
+    mPressure.makeRobustPressure(mPressureInterval, mPressureIntervalRef, mTimePressure.first, mTimePressure.last);
+  }
+}
+
 void DCSProcessor::writeDebug()
 {
   if (!mDebugStream) {
@@ -227,6 +192,7 @@ void DCSProcessor::writeDebug()
                 << "Temperature=" << mTemperature
                 << "HV=" << mHighVoltage
                 << "Gas=" << mGas
+                << "Pressure=" << mPressure
                 << "\n";
 }
 
diff --git a/Detectors/TPC/dcs/src/DCSSpec.cxx b/Detectors/TPC/dcs/src/DCSSpec.cxx
index f99ff8f8aaaab..1b64ff7a75ba4 100644
--- a/Detectors/TPC/dcs/src/DCSSpec.cxx
+++ b/Detectors/TPC/dcs/src/DCSSpec.cxx
@@ -48,7 +48,7 @@ const std::unordered_map<CDBType, o2::header::DataDescription> CDBDescMap{
   {CDBType::CalTemperature, o2::header::DataDescription{"TPC_Temperature"}},
   {CDBType::CalHV, o2::header::DataDescription{"TPC_HighVoltage"}},
   {CDBType::CalGas, o2::header::DataDescription{"TPC_Gas"}},
-};
+  {CDBType::CalPressure, o2::header::DataDescription{"TPC_Pressure"}}};
 
 class DCSDevice : public o2::framework::Task
 {
@@ -105,6 +105,7 @@ class DCSDevice : public o2::framework::Task
   bool mDebugWritten{false};
   bool mWriteDebug{false};
   bool mReportTiming{false};
+  int mUpdateIntervalnTFs{-1};
 };
 
 void DCSDevice::init(o2::framework::InitContext& ic)
@@ -112,6 +113,8 @@ void DCSDevice::init(o2::framework::InitContext& ic)
   mWriteDebug = ic.options().get<bool>("write-debug");
   mCCDBupdateInterval = ic.options().get<int>("update-interval");
   mFitInterval = ic.options().get<int>("fit-interval");
+  const int pressureInterval = ic.options().get<int>("pressure-interval");
+  const int pressureIntervalRef = ic.options().get<int>("pressure-ref-interval");
   if (mCCDBupdateInterval < 0) {
     mCCDBupdateInterval = 0;
   }
@@ -119,15 +122,18 @@ void DCSDevice::init(o2::framework::InitContext& ic)
     LOGP(info, "fit interval {} >= ccdb update interval {}, making them identical", mFitInterval, mCCDBupdateInterval);
     mFitInterval = mCCDBupdateInterval;
   }
+  mUpdateIntervalnTFs = ic.options().get<int>("update-interval-nTFs");
 
   mDCS.setFitInterval(mFitInterval * 1000); // in ms in mDCS
+  mDCS.setPressureInterval(pressureInterval * 1000);
+  mDCS.setRefPressureInterval(pressureIntervalRef * 1000);
   mDCS.setRoundToInterval(ic.options().get<bool>("round-to-interval"));
 
   // set default meta data
   mCDBStorage.setResponsible("Jens Wiechula (jens.wiechula@cern.ch)");
   mCDBStorage.setIntervention(CDBIntervention::Automatic);
   mCDBStorage.setReason("DCS workflow upload");
-  mReportTiming = ic.options().get<bool>("report-timing") || mWriteDebug;
+  mReportTiming = ic.options().get<bool>("report-timing");
 }
 
 void DCSDevice::run(o2::framework::ProcessingContext& pc)
@@ -137,10 +143,16 @@ void DCSDevice::run(o2::framework::ProcessingContext& pc)
   if (mUpdateIntervalStart == 0) {
     mUpdateIntervalStart = mLastCreationTime;
   }
-  if (mLastCreationTime - mUpdateIntervalStart >= uint64_t(mCCDBupdateInterval * 1000)) {
+  if (mUpdateIntervalnTFs > 0 && (pc.services().get<o2::framework::TimingInfo>().tfCounter % mUpdateIntervalnTFs == 0)) {
+    // finalize DCS for every n-TFs (useful for testing purpose when reading in data from local file)
     finalizeDCS(pc.outputs());
-    mUpdateIntervalStart = mLastCreationTime;
+  } else {
+    if (mLastCreationTime - mUpdateIntervalStart >= uint64_t(mCCDBupdateInterval * 1000)) {
+      finalizeDCS(pc.outputs());
+      mUpdateIntervalStart = mLastCreationTime;
+    }
   }
+
   auto dps = pc.inputs().get<gsl::span<DPCOM>>("input");
   mDCS.process(dps);
   sw.Stop();
@@ -170,6 +182,7 @@ void DCSDevice::updateCCDB(DataAllocator& output)
   sendObject(output, mDCS.getTemperature(), CDBType::CalTemperature);
   sendObject(output, mDCS.getHighVoltage(), CDBType::CalHV);
   sendObject(output, mDCS.getGas(), CDBType::CalGas);
+  sendObject(output, mDCS.getPressure(), CDBType::CalPressure);
 }
 
 /// ===| create DCS processor |=================================================
@@ -188,6 +201,9 @@ DataProcessorSpec getDCSSpec()
   outputs.emplace_back(ConcreteDataTypeMatcher{CDBPayload, CDBDescMap.at(CDBType::CalGas)}, Lifetime::Sporadic);
   outputs.emplace_back(ConcreteDataTypeMatcher{CDBWrapper, CDBDescMap.at(CDBType::CalGas)}, Lifetime::Sporadic);
 
+  outputs.emplace_back(ConcreteDataTypeMatcher{CDBPayload, CDBDescMap.at(CDBType::CalPressure)}, Lifetime::Sporadic);
+  outputs.emplace_back(ConcreteDataTypeMatcher{CDBWrapper, CDBDescMap.at(CDBType::CalPressure)}, Lifetime::Sporadic);
+
   return DataProcessorSpec{
     "tpc-dcs",
     Inputs{{"input", "DCS", "TPCDATAPOINTS"}},
@@ -199,7 +215,9 @@ DataProcessorSpec getDCSSpec()
       {"update-interval", VariantType::Int, 60 * 15, {"update interval in seconds for which ccdb entries are written"}},
       {"fit-interval", VariantType::Int, 60 * 5, {"interval in seconds for which to e.g. perform fits of the temperature sensors"}},
       {"round-to-interval", VariantType::Bool, false, {"round fit interval to fixed times e.g. to every 5min in the hour"}},
-    } // end Options
+      {"pressure-interval", VariantType::Int, 100, {"interval in seconds for which to average the pressure values"}},
+      {"pressure-ref-interval", VariantType::Int, 24 * 60 * 60, {"interval in seconds for which to calculate the reference pressure values"}},
+      {"update-interval-nTFs", VariantType::Int, -1, {"only used when larger than 0: update interval in nTFs for which ccdb entries are written "}}} // end Options
   }; // end DataProcessorSpec
 }
 
diff --git a/Detectors/TPC/workflow/CMakeLists.txt b/Detectors/TPC/workflow/CMakeLists.txt
index 3b05e5067108c..fe7c9175968b5 100644
--- a/Detectors/TPC/workflow/CMakeLists.txt
+++ b/Detectors/TPC/workflow/CMakeLists.txt
@@ -44,6 +44,7 @@ o2_add_library(TPCWorkflow
                        src/TPCTimeSeriesSpec.cxx
                        src/TPCTimeSeriesWriterSpec.cxx
                        src/TPCScalerSpec.cxx
+                       src/TPCPressureTemperatureSpec.cxx
                TARGETVARNAME targetName
                PUBLIC_LINK_LIBRARIES O2::Framework O2::DataFormatsTPC
                                      O2::DPLUtils O2::TPCReconstruction
@@ -293,4 +294,9 @@ o2_add_executable(refitter
                   COMPONENT_NAME tpc
                   PUBLIC_LINK_LIBRARIES O2::TPCWorkflowStudies)
 
+o2_add_executable(pressure-temperature
+                  COMPONENT_NAME tpc
+                  SOURCES src/tpc-pressure-temperature.cxx
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+
 add_subdirectory(readers)
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCPressureTemperatureSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCPressureTemperatureSpec.h
new file mode 100644
index 0000000000000..45a29e3010b33
--- /dev/null
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCPressureTemperatureSpec.h
@@ -0,0 +1,28 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TPC_TPCPRESSURETEMPERATURE_SPEC
+#define O2_TPC_TPCPRESSURETEMPERATURE_SPEC
+
+#include "Framework/DataProcessorSpec.h"
+#include "DetectorsBase/Propagator.h"
+
+namespace o2
+{
+namespace tpc
+{
+
+o2::framework::DataProcessorSpec getTPCPressureTemperatureSpec();
+
+} // end namespace tpc
+} // end namespace o2
+
+#endif
diff --git a/Detectors/TPC/workflow/src/TPCPressureTemperatureSpec.cxx b/Detectors/TPC/workflow/src/TPCPressureTemperatureSpec.cxx
new file mode 100644
index 0000000000000..e03a0ffe4308b
--- /dev/null
+++ b/Detectors/TPC/workflow/src/TPCPressureTemperatureSpec.cxx
@@ -0,0 +1,115 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TPCPressureTemperatureSpec.cxx
+/// \brief device for providing pressure and temperature values
+/// \author Matthias Kleiner <mkleiner@ikf.uni-frankfurt.de>
+/// \date Jun 4, 2025
+
+#include "TPCWorkflow/TPCPressureTemperatureSpec.h"
+#include "Framework/Task.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "CommonUtils/TreeStreamRedirector.h"
+#include "TPCCalibration/PressureTemperatureHelper.h"
+
+using namespace o2::framework;
+
+namespace o2
+{
+namespace tpc
+{
+
+class PressureTemperatureDevice : public o2::framework::Task
+{
+ public:
+  PressureTemperatureDevice(std::shared_ptr<o2::base::GRPGeomRequest> req) : mCCDBRequest(req){};
+  void init(o2::framework::InitContext& ic) final
+  {
+    o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
+    const int intInterval = ic.options().get<int>("fit-interval");
+    mPTHelper.setFitIntervalTemp(intInterval * 1000);
+    const bool enableDebugTree = ic.options().get<bool>("enable-root-output");
+    if (enableDebugTree) {
+      mStreamer = std::make_unique<o2::utils::TreeStreamRedirector>("pt.root", "recreate");
+    }
+  };
+
+  void endOfStream(EndOfStreamContext& eos) final
+  {
+    if (mStreamer) {
+      mStreamer->Close();
+    }
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+    mPTHelper.extractCCDBInputs(pc);
+    const auto orbitResetTimeMS = o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS();
+    const auto firstTFOrbit = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
+    const uint64_t timestamp = orbitResetTimeMS + firstTFOrbit * o2::constants::lhc::LHCOrbitMUS * 0.001;
+    mPTHelper.sendPTForTS(pc, timestamp);
+
+    if (mStreamer) {
+      const float pressure = mPTHelper.getPressure(timestamp);
+      const auto temp = mPTHelper.getTemperature(timestamp);
+      (*mStreamer) << "pt"
+                   << "pressure=" << pressure
+                   << "temperatureA=" << temp.first
+                   << "temperatureC=" << temp.second
+                   << "time=" << timestamp
+                   << "\n";
+    }
+  }
+
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
+  {
+    o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
+    mPTHelper.accountCCDBInputs(matcher, obj);
+  }
+
+ private:
+  PressureTemperatureHelper mPTHelper;
+  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;     ///< info for CCDB request
+  std::unique_ptr<o2::utils::TreeStreamRedirector> mStreamer; ///< debug streamer
+};
+
+o2::framework::DataProcessorSpec getTPCPressureTemperatureSpec()
+{
+  std::vector<InputSpec> inputs;
+  std::vector<OutputSpec> outputs;
+  o2::header::DataDescription dataDescription;
+
+  PressureTemperatureHelper::requestCCDBInputs(inputs);
+  PressureTemperatureHelper::setOutputs(outputs);
+
+  auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true,                           // orbitResetTime
+                                                                false,                          // GRPECS=true for nHBF per TF
+                                                                false,                          // GRPLHCIF
+                                                                false,                          // GRPMagField
+                                                                false,                          // askMatLUT
+                                                                o2::base::GRPGeomRequest::None, // geometry
+                                                                inputs);
+  return DataProcessorSpec{
+    "tpc-pressure-temperature",
+    inputs,
+    outputs,
+    AlgorithmSpec{adaptFromTask<PressureTemperatureDevice>(ccdbRequest)},
+    Options{
+      {"enable-root-output", VariantType::Bool, false, {"Enable root-files output writers"}},
+      {"fit-interval", VariantType::Int, 300, {"interval in seconds for which to e.g. perform fits of the temperature sensors"}}} // end Options
+  };
+}
+
+} // end namespace tpc
+} // end namespace o2
diff --git a/Detectors/TPC/workflow/src/tpc-pressure-temperature.cxx b/Detectors/TPC/workflow/src/tpc-pressure-temperature.cxx
new file mode 100644
index 0000000000000..a56067c9d843c
--- /dev/null
+++ b/Detectors/TPC/workflow/src/tpc-pressure-temperature.cxx
@@ -0,0 +1,36 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   tpc-pressure-temperature.cxx
+/// \author Matthias Kleiner, mkleiner@ikf.uni-frankfurt.de
+
+#include "TPCWorkflow/TPCPressureTemperatureSpec.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/ConfigParamSpec.h"
+
+using namespace o2::framework;
+
+void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
+{
+  // option allowing to set parameters
+  std::vector<ConfigParamSpec> options{ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& config)
+{
+  WorkflowSpec workflow;
+  o2::conf::ConfigurableParam::updateFromString(config.options().get<std::string>("configKeyValues"));
+  workflow.emplace_back(o2::tpc::getTPCPressureTemperatureSpec());
+  return workflow;
+}

From 5f7e9fb5eb006671b3238f1c881ccb5428153095 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 28 May 2025 17:00:51 +0200
Subject: [PATCH 0459/1764] ITS: stream comp processNeighbours

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 86 +++++++++++++++----
 1 file changed, 67 insertions(+), 19 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 97a679689e4a9..fa9891706d472 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -471,26 +471,20 @@ template <int nLayers>
 void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeed>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
 {
   CA_DEBUGGER(std::cout << "Processing neighbours layer " << iLayer << " level " << iLevel << ", size of the cell seeds: " << currentCellSeed.size() << std::endl);
-  updatedCellSeeds.reserve(mTimeFrame->getCellsNeighboursLUT()[iLayer - 1].size()); /// This is not the correct value, we could do a loop to count the number of neighbours
-  updatedCellsIds.reserve(updatedCellSeeds.size());
   auto propagator = o2::base::Propagator::Instance();
+
 #ifdef CA_DEBUG
   int failed[5]{0, 0, 0, 0, 0}, attempts{0}, failedByMismatch{0};
 #endif
 
   mTaskArena.execute([&] {
-    // TODO better to use concurrent vector?
-    tbb::combinable<std::pair<bounded_vector<int>, bounded_vector<CellSeed>>> locUpdatedData([&] {
-      return std::make_pair(bounded_vector<int>(mMemoryPool.get()), bounded_vector<CellSeed>(mMemoryPool.get()));
-    });
-
+    bounded_vector<int> perCellCount(currentCellSeed.size() + 1, 0, mMemoryPool.get());
     tbb::parallel_for(
       tbb::blocked_range<int>(0, (int)currentCellSeed.size()),
       [&](const tbb::blocked_range<int>& Cells) {
-        auto& [locUpdatedCellsIds, locUpdatedCellSeeds] = locUpdatedData.local();
-
         for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
           const CellSeed& currentCell{currentCellSeed[iCell]};
+          int foundSeeds{0};
           if (currentCell.getLevel() != iLevel) {
             continue;
           }
@@ -550,25 +544,79 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
               CA_DEBUGGER(failed[4]++);
               continue;
             }
+            ++foundSeeds;
+          }
+          perCellCount[iCell] = foundSeeds;
+        }
+      });
+
+    std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
+    auto totalNeighbours{perCellCount.back()};
+    if (totalNeighbours == 0) {
+      return;
+    }
+    updatedCellSeeds.resize(totalNeighbours);
+    updatedCellsIds.resize(totalNeighbours);
+
+    tbb::parallel_for(
+      tbb::blocked_range<int>(0, (int)currentCellSeed.size()),
+      [&](const tbb::blocked_range<int>& Cells) {
+        for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
+          if (perCellCount[iCell] == perCellCount[iCell + 1]) {
+            continue;
+          }
+          // no need for further checks on cell level
+
+          const CellSeed& currentCell{currentCellSeed[iCell]};
+          const int cellId = currentCellId.empty() ? iCell : currentCellId[iCell];
+          const int startNeighbourId{cellId ? mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId - 1] : 0};
+          const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId]};
+
+          int offset = perCellCount[iCell];
+          for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
+            const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
+            const CellSeed& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
+            if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex() ||
+                mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex()) ||
+                currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
+              continue;
+            }
+
+            auto seed = currentCell;
+
+            const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1).at(neighbourCell.getFirstClusterIndex());
+            if (!seed.rotate(trHit.alphaTrackingFrame) || !propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
+              continue;
+            }
+
+            if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+              float radl = 9.36f; // Radiation length of Si [cm]
+              float rho = 2.33f;  // Density of Si [g/cm^3]
+              if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * radl * rho, true)) {
+                continue;
+              }
+            }
+
+            auto predChi2{seed.getPredictedChi2Quiet(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)};
+            if ((predChi2 > mTrkParams[0].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
+              continue;
+            }
+            seed.setChi2(seed.getChi2() + predChi2);
+            if (!seed.o2::track::TrackParCov::update(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)) {
+              continue;
+            }
+
             seed.getClusters()[iLayer - 1] = neighbourCell.getFirstClusterIndex();
             seed.setLevel(neighbourCell.getLevel());
             seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
             seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
 
-            locUpdatedCellSeeds.push_back(seed);
-            locUpdatedCellsIds.push_back(neighbourCellId);
+            updatedCellSeeds[offset] = seed;
+            updatedCellsIds[offset++] = neighbourCellId;
           }
         }
       });
-
-    locUpdatedData.combine_each([&](const auto& localData) {
-      const auto& [ids, seeds] = localData;
-      updatedCellsIds.insert(updatedCellsIds.begin(), ids.begin(), ids.end());
-      updatedCellSeeds.insert(updatedCellSeeds.begin(), seeds.begin(), seeds.end());
-    });
   });
-  updatedCellSeeds.shrink_to_fit();
-  updatedCellsIds.shrink_to_fit();
 
 #ifdef CA_DEBUG
   std::cout << "\t\t- Found " << updatedCellSeeds.size() << " cell seeds out of " << attempts << " attempts" << std::endl;

From 188af4a28b7b4ef61752dbe679cbba82a8a50e8b Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 28 May 2025 17:01:21 +0200
Subject: [PATCH 0460/1764] ITS: stream comp findRoads

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 60 ++++++++++++++-----
 1 file changed, 44 insertions(+), 16 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index fa9891706d472..afee2aaa6fe96 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -636,6 +636,9 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
 
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     CA_DEBUGGER(std::cout << "\t > Processing level " << startLevel << std::endl);
+    auto seedFilter = [&](const CellSeed& seed) {
+      return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[0].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
+    };
     bounded_vector<CellSeed> trackSeeds(mMemoryPool.get());
     for (int startLayer{mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= startLevel - 1; --startLayer) {
       if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
@@ -655,9 +658,13 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         deepVectorClear(updatedCellId);   /// tame the memory peaks
         processNeighbours(iLayer, --level, lastCellSeed, lastCellId, updatedCellSeed, updatedCellId);
       }
-      std::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), std::back_inserter(trackSeeds), [&](const CellSeed& seed) {
-        return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[0].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
-      });
+      deepVectorClear(lastCellId);   /// tame the memory peaks
+      deepVectorClear(lastCellSeed); /// tame the memory peaks
+
+      if (!updatedCellSeed.empty()) {
+        trackSeeds.reserve(trackSeeds.size() + std::count_if(updatedCellSeed.begin(), updatedCellSeed.end(), seedFilter));
+        std::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), std::back_inserter(trackSeeds), seedFilter);
+      }
     }
 
     if (trackSeeds.empty()) {
@@ -665,19 +672,12 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
     }
 
     bounded_vector<TrackITSExt> tracks(mMemoryPool.get());
-    tracks.reserve(trackSeeds.size());
     mTaskArena.execute([&] {
-      tbb::combinable<bounded_vector<TrackITSExt>> locTracksData([&] {
-        return bounded_vector<TrackITSExt>(mMemoryPool.get());
-      });
-
+      bounded_vector<int> perSeedCount(trackSeeds.size() + 1, 0, mMemoryPool.get());
       tbb::parallel_for(
         tbb::blocked_range<size_t>(size_t(0), trackSeeds.size()),
         [&](const tbb::blocked_range<size_t>& Seeds) {
           for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
-            auto& localTracks = locTracksData.local();
-            localTracks.reserve(Seeds.size());
-
             const CellSeed& seed{trackSeeds[iSeed]};
             TrackITSExt temporaryTrack{seed};
             temporaryTrack.resetCovariance();
@@ -697,15 +697,43 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
             if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
               continue;
             }
-            localTracks.push_back(temporaryTrack);
+            ++perSeedCount[iSeed];
           }
         });
+      std::exclusive_scan(perSeedCount.begin(), perSeedCount.end(), perSeedCount.begin(), 0);
+      auto totalTracks{perSeedCount.back()};
+      if (totalTracks == 0) {
+        return;
+      }
+      tracks.resize(totalTracks);
 
-      locTracksData.combine_each([&](const bounded_vector<TrackITSExt>& localTracks) {
-        tracks.insert(tracks.end(), localTracks.begin(), localTracks.end());
-      });
-      tracks.shrink_to_fit();
+      tbb::parallel_for(
+        tbb::blocked_range<int>(0, (int)trackSeeds.size()),
+        [&](const tbb::blocked_range<int>& Seeds) {
+          for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
+            if (perSeedCount[iSeed] == perSeedCount[iSeed + 1]) {
+              continue;
+            }
+            const CellSeed& seed{trackSeeds[iSeed]};
+            auto& trk = tracks[perSeedCount[iSeed]] = TrackITSExt(seed);
+            trk.resetCovariance();
+            trk.setChi2(0);
+            for (int iL{0}; iL < 7; ++iL) {
+              trk.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::its::UnusedIndex);
+            }
+
+            bool fitSuccess = fitTrack(trk, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
+            if (!fitSuccess) {
+              continue;
+            }
+            trk.getParamOut() = trk.getParamIn();
+            trk.resetCovariance();
+            trk.setChi2(0);
+            fitTrack(trk, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f);
+          }
+        });
 
+      deepVectorClear(trackSeeds);
       tbb::parallel_sort(tracks.begin(), tracks.end(), [](const auto& a, const auto& b) {
         return a.getChi2() < b.getChi2();
       });

From bfa2ec23843f1cea7b388affbe929c1f3c9f312a Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 28 May 2025 23:28:04 +0200
Subject: [PATCH 0461/1764] ITS: stream comp computeLayerCells

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 221 ++++++++++++------
 1 file changed, 156 insertions(+), 65 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index afee2aaa6fe96..f4cdd191ec6eb 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -271,11 +271,16 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
   std::ofstream off(std::format("cells{}.txt", iter++));
 #endif
 
+  constexpr float radl = 9.36f; // Radiation length of Si [cm]
+  constexpr float rho = 2.33f;  // Density of Si [g/cm^3]
+
   for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-    mTimeFrame->getCells()[iLayer].clear();
-    mTimeFrame->getCellsLabel(iLayer).clear();
+    deepVectorClear(mTimeFrame->getCells()[iLayer]);
     if (iLayer > 0) {
-      mTimeFrame->getCellsLookupTable()[iLayer - 1].clear();
+      deepVectorClear(mTimeFrame->getCellsLookupTable()[iLayer - 1]);
+    }
+    if (mTimeFrame->hasMCinformation()) {
+      deepVectorClear(mTimeFrame->getCellsLabel(iLayer));
     }
   }
 
@@ -295,87 +300,173 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
           resolution = resolution > 1.e-12 ? resolution : 1.f;
 #endif
 
+          // count number of cells found
           const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
-          for (int iTracklet{0}; iTracklet < currentLayerTrackletsNum; ++iTracklet) {
-
-            const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
-            const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
-            const int nextLayerFirstTrackletIndex{
-              mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
-            const int nextLayerLastTrackletIndex{
-              mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
-
-            if (nextLayerFirstTrackletIndex == nextLayerLastTrackletIndex) {
-              continue;
-            }
+          bounded_vector<int> perTrackletCount(currentLayerTrackletsNum + 1, 0, mMemoryPool.get());
+          tbb::parallel_for(
+            tbb::blocked_range<int>(0, currentLayerTrackletsNum),
+            [&](const tbb::blocked_range<int>& Tracklets) {
+              for (int iTracklet = Tracklets.begin(); iTracklet < Tracklets.end(); ++iTracklet) {
+                const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
+                const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
+                const int nextLayerFirstTrackletIndex{
+                  mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
+                const int nextLayerLastTrackletIndex{
+                  mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
+
+                if (nextLayerFirstTrackletIndex == nextLayerLastTrackletIndex) {
+                  continue;
+                }
 
-            for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
-              if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
-                break;
-              }
-              const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
-              const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
+                int foundCells{0};
+                for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
+                  if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
+                    break;
+                  }
+                  const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
+                  const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
 
 #ifdef OPTIMISATION_OUTPUT
-              bool good{mTimeFrame->getTrackletsLabel(iLayer)[iTracklet] == mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
-              float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
-              off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
+                  bool good{mTimeFrame->getTrackletsLabel(iLayer)[iTracklet] == mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
+                  float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
+                  off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
 #endif
 
-              if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
+                  if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
 
-                /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
-                const int clusId[3]{
-                  mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
-                  mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
-                  mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
-                const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer].at(clusId[0]);
-                const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1].at(clusId[1]);
-                const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2).at(clusId[2]);
-                auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
+                    /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
+                    const int clusId[3]{
+                      mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
+                      mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
+                      mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
+                    const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer].at(clusId[0]);
+                    const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1].at(clusId[1]);
+                    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2).at(clusId[2]);
+                    auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
 
-                float chi2{0.f};
-                bool good{false};
-                for (int iC{2}; iC--;) {
-                  const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC).at(clusId[iC]);
+                    float chi2{0.f};
+                    bool good{false};
+                    for (int iC{2}; iC--;) {
+                      const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC).at(clusId[iC]);
 
-                  if (!track.rotate(trackingHit.alphaTrackingFrame)) {
-                    break;
-                  }
+                      if (!track.rotate(trackingHit.alphaTrackingFrame)) {
+                        break;
+                      }
 
-                  if (!track.propagateTo(trackingHit.xTrackingFrame, getBz())) {
-                    break;
-                  }
+                      if (!track.propagateTo(trackingHit.xTrackingFrame, getBz())) {
+                        break;
+                      }
 
-                  constexpr float radl = 9.36f; // Radiation length of Si [cm]
-                  constexpr float rho = 2.33f;  // Density of Si [g/cm^3]
-                  if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * radl * rho, true)) {
-                    break;
-                  }
+                      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * radl * rho, true)) {
+                        break;
+                      }
 
-                  auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
-                  if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
-                    break;
-                  }
-                  if (!iC && predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
-                    break;
+                      const auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
+                      if (!iC && predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
+                        break;
+                      }
+
+                      if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
+                        break;
+                      }
+
+                      good = !iC;
+                      chi2 += predChi2;
+                    }
+                    if (good) {
+                      ++foundCells;
+                    }
                   }
-                  good = !iC;
-                  chi2 += predChi2;
                 }
-                if (!good) {
+                perTrackletCount[iTracklet] = foundCells;
+              }
+            });
+
+          // calculate offset table and check if any cells where found
+          std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
+          auto totalCells{perTrackletCount.back()};
+          if (totalCells == 0) {
+            continue;
+          }
+          auto& layerCells = mTimeFrame->getCells()[iLayer];
+          layerCells.resize(totalCells);
+
+          tbb::parallel_for(
+            tbb::blocked_range<int>(0, currentLayerTrackletsNum),
+            [&](const tbb::blocked_range<int>& Tracklets) {
+              for (int iTracklet = Tracklets.begin(); iTracklet < Tracklets.end(); ++iTracklet) {
+                if (perTrackletCount[iTracklet] == perTrackletCount[iTracklet + 1]) {
                   continue;
                 }
-                if (iLayer > 0 && (int)mTimeFrame->getCellsLookupTable()[iLayer - 1].size() <= iTracklet) {
-                  mTimeFrame->getCellsLookupTable()[iLayer - 1].resize(iTracklet + 1, mTimeFrame->getCells()[iLayer].size());
+
+                const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
+                const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
+                const int nextLayerFirstTrackletIndex{
+                  mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
+                const int nextLayerLastTrackletIndex{
+                  mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
+
+                int position = perTrackletCount[iTracklet];
+                for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
+                  if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
+                    break;
+                  }
+                  const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
+                  const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
+
+                  if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
+
+                    /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
+                    const int clusId[3]{
+                      mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
+                      mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
+                      mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
+                    const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer].at(clusId[0]);
+                    const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1].at(clusId[1]);
+                    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2).at(clusId[2]);
+                    auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
+
+                    float chi2{0.f};
+                    bool good{false};
+                    for (int iC{2}; iC--;) {
+                      const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC).at(clusId[iC]);
+
+                      if (!track.rotate(trackingHit.alphaTrackingFrame)) {
+                        break;
+                      }
+
+                      if (!track.propagateTo(trackingHit.xTrackingFrame, getBz())) {
+                        break;
+                      }
+
+                      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * radl * rho, true)) {
+                        break;
+                      }
+
+                      const auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
+                      if (!iC && predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
+                        break;
+                      }
+
+                      if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
+                        break;
+                      }
+
+                      good = !iC;
+                      chi2 += predChi2;
+                    }
+                    if (good) {
+                      layerCells[position++] = CellSeed(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
+                    }
+                  }
                 }
-                mTimeFrame->getCells()[iLayer].emplace_back(iLayer, clusId[0], clusId[1], clusId[2],
-                                                            iTracklet, iNextTracklet, track, chi2);
               }
-            }
-          }
+            });
+
           if (iLayer > 0) {
-            mTimeFrame->getCellsLookupTable()[iLayer - 1].resize(currentLayerTrackletsNum + 1, mTimeFrame->getCells()[iLayer].size());
+            auto& lut = mTimeFrame->getCellsLookupTable()[iLayer - 1];
+            lut.resize(currentLayerTrackletsNum + 1);
+            std::copy_n(perTrackletCount.begin(), currentLayerTrackletsNum + 1, lut.begin());
           }
         }
       });

From 6c94101a98736d56bf02a95997ae43dfd775f456 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 29 May 2025 01:00:52 +0200
Subject: [PATCH 0462/1764] ITS: stream comp findCellsNeighbours

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 150 +++++++++++++-----
 1 file changed, 107 insertions(+), 43 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index f4cdd191ec6eb..a66583f1b12f5 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -12,9 +12,11 @@
 /// \file TrackerTraits.cxx
 /// \brief
 ///
+
 #include <algorithm>
-#include <cassert>
 #include <iostream>
+#include <iterator>
+#include <ranges>
 
 #ifdef OPTIMISATION_OUTPUT
 #include <format>
@@ -498,63 +500,125 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
 #endif
   for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
     const int nextLayerCellsNum{static_cast<int>(mTimeFrame->getCells()[iLayer + 1].size())};
-    mTimeFrame->getCellsNeighboursLUT()[iLayer].clear();
-    mTimeFrame->getCellsNeighboursLUT()[iLayer].resize(nextLayerCellsNum, 0);
+    deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
+    deepVectorClear(mTimeFrame->getCellsNeighboursLUT()[iLayer]);
     if (mTimeFrame->getCells()[iLayer + 1].empty() ||
         mTimeFrame->getCellsLookupTable()[iLayer].empty()) {
-      mTimeFrame->getCellsNeighbours()[iLayer].clear();
       continue;
     }
 
-    int layerCellsNum{static_cast<int>(mTimeFrame->getCells()[iLayer].size())};
-    bounded_vector<std::pair<int, int>> cellsNeighbours(mMemoryPool.get());
-    cellsNeighbours.reserve(nextLayerCellsNum);
-
-    for (int iCell{0}; iCell < layerCellsNum; ++iCell) {
-      const auto& currentCellSeed{mTimeFrame->getCells()[iLayer][iCell]};
-      const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
-      const int nextLayerFirstCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex]};
-      const int nextLayerLastCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex + 1]};
-      for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
+    mTaskArena.execute([&] {
+      int layerCellsNum{static_cast<int>(mTimeFrame->getCells()[iLayer].size())};
 
-        auto nextCellSeed{mTimeFrame->getCells()[iLayer + 1][iNextCell]}; /// copy
-        if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) {
-          break;
-        }
+      bounded_vector<int> perCellCount(layerCellsNum + 1, 0, mMemoryPool.get());
+      tbb::parallel_for(
+        tbb::blocked_range<int>(0, layerCellsNum),
+        [&](const tbb::blocked_range<int>& Cells) {
+          for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
+            const auto& currentCellSeed{mTimeFrame->getCells()[iLayer][iCell]};
+            const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
+            const int nextLayerFirstCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex]};
+            const int nextLayerLastCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex + 1]};
+
+            int foundNextCells{0};
+            for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
+              auto nextCellSeed{mTimeFrame->getCells()[iLayer + 1][iNextCell]}; /// copy
+              if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) {
+                break;
+              }
 
-        if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
-            !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
-          continue;
-        }
-        float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
+              if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
+                  !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
+                continue;
+              }
+              float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
 
 #ifdef OPTIMISATION_OUTPUT
-        bool good{mTimeFrame->getCellsLabel(iLayer)[iCell] == mTimeFrame->getCellsLabel(iLayer + 1)[iNextCell]};
-        off << std::format("{}\t{:d}\t{}", iLayer, good, chi2) << std::endl;
+              bool good{mTimeFrame->getCellsLabel(iLayer)[iCell] == mTimeFrame->getCellsLabel(iLayer + 1)[iNextCell]};
+              off << std::format("{}\t{:d}\t{}", iLayer, good, chi2) << std::endl;
 #endif
 
-        if (chi2 > mTrkParams[0].MaxChi2ClusterAttachment) {
-          continue;
-        }
+              if (chi2 > mTrkParams[0].MaxChi2ClusterAttachment) {
+                continue;
+              }
+              ++foundNextCells;
+            }
+            perCellCount[iCell] = foundNextCells;
+          }
+        });
 
-        mTimeFrame->getCellsNeighboursLUT()[iLayer][iNextCell]++;
-        cellsNeighbours.push_back(std::make_pair(iCell, iNextCell));
-        const int currentCellLevel{currentCellSeed.getLevel()};
+      std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
+      int totalCellNeighbours = perCellCount.back();
+      if (totalCellNeighbours == 0) {
+        deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
+        return;
+      }
 
-        if (currentCellLevel >= nextCellSeed.getLevel()) {
-          mTimeFrame->getCells()[iLayer + 1][iNextCell].setLevel(currentCellLevel + 1);
-        }
+      struct Neighbor {
+        int cell{-1}, nextCell{-1}, level{-1};
+      };
+      bounded_vector<Neighbor> cellsNeighbours(mMemoryPool.get());
+      cellsNeighbours.resize(totalCellNeighbours);
+
+      tbb::parallel_for(
+        tbb::blocked_range<int>(0, layerCellsNum),
+        [&](const tbb::blocked_range<int>& Cells) {
+          for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
+            if (perCellCount[iCell] == perCellCount[iCell + 1]) {
+              continue;
+            }
+            const auto& currentCellSeed{mTimeFrame->getCells()[iLayer][iCell]};
+            const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
+            const int nextLayerFirstCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex]};
+            const int nextLayerLastCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex + 1]};
+
+            int position = perCellCount[iCell];
+            for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
+              auto nextCellSeed{mTimeFrame->getCells()[iLayer + 1][iNextCell]}; /// copy
+              if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) {
+                break;
+              }
+
+              if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
+                  !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
+                continue;
+              }
+
+              float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
+              if (chi2 > mTrkParams[0].MaxChi2ClusterAttachment) {
+                continue;
+              }
+
+              cellsNeighbours[position++] = {iCell, iNextCell, currentCellSeed.getLevel() + 1};
+            }
+          }
+        });
+
+      tbb::parallel_sort(cellsNeighbours.begin(), cellsNeighbours.end(), [](const auto& a, const auto& b) {
+        return a.nextCell < b.nextCell;
+      });
+
+      auto& cellsNeighbourLUT = mTimeFrame->getCellsNeighboursLUT()[iLayer];
+      cellsNeighbourLUT.assign(nextLayerCellsNum, 0);
+      for (const auto& neigh : cellsNeighbours) {
+        ++cellsNeighbourLUT[neigh.nextCell];
+      }
+      std::inclusive_scan(cellsNeighbourLUT.begin(), cellsNeighbourLUT.end(), cellsNeighbourLUT.begin());
+
+      mTimeFrame->getCellsNeighbours()[iLayer].reserve(totalCellNeighbours);
+      std::ranges::transform(cellsNeighbours, std::back_inserter(mTimeFrame->getCellsNeighbours()[iLayer]), [](const auto& neigh) { return neigh.cell; });
+
+      auto it = cellsNeighbours.begin();
+      while (it != cellsNeighbours.end()) {
+        const int current_nextCell = it->nextCell;
+        auto group_end = std::find_if_not(it, cellsNeighbours.end(),
+                                          [current_nextCell](const auto& nb) { return nb.nextCell == current_nextCell; });
+        const auto max_level_it = std::max_element(it, group_end,
+                                                   [](const auto& a, const auto& b) { return a.level < b.level; });
+        mTimeFrame->getCells()[iLayer + 1][current_nextCell].setLevel(max_level_it->level);
+        it = group_end;
       }
-    }
-    std::sort(cellsNeighbours.begin(), cellsNeighbours.end(), [](const std::pair<int, int>& a, const std::pair<int, int>& b) {
-      return a.second < b.second;
     });
-    mTimeFrame->getCellsNeighbours()[iLayer].clear();
-    mTimeFrame->getCellsNeighbours()[iLayer].reserve(cellsNeighbours.size());
-    for (auto& cellNeighboursIndex : cellsNeighbours) {
-      mTimeFrame->getCellsNeighbours()[iLayer].push_back(cellNeighboursIndex.first);
-    }
-    std::inclusive_scan(mTimeFrame->getCellsNeighboursLUT()[iLayer].begin(), mTimeFrame->getCellsNeighboursLUT()[iLayer].end(), mTimeFrame->getCellsNeighboursLUT()[iLayer].begin());
   }
 }
 

From d5e06188b598e451f5da40d6318374718b3efb86 Mon Sep 17 00:00:00 2001
From: Marvin Hemmer <53471402+mhemmer-cern@users.noreply.github.com>
Date: Fri, 6 Jun 2025 11:16:11 +0200
Subject: [PATCH 0463/1764] [EMCAL-1154] Add functionality for cross talk
 emulation (#14369)

Geometry:
  - Add `areAbsIDsFromSameTCard` which checks if two cells are within the same T-Card

CellLabel:
  - Add `GetLabels` which returns the span of all labels
  - Add `GetAmplitudeFractions` which return the span of all amplitude fractions
  - Add `GetLeadingMCLabel` which returns the label with the largest amplitude fraction
---
 .../include/DataFormatsEMCAL/CellLabel.h      | 14 ++++-
 DataFormats/Detectors/EMCAL/src/CellLabel.cxx | 18 ++++++
 .../EMCAL/base/include/EMCALBase/Geometry.h   | 16 +++--
 Detectors/EMCAL/base/src/Geometry.cxx         | 61 ++++++++++++++++++-
 4 files changed, 101 insertions(+), 8 deletions(-)

diff --git a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/CellLabel.h b/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/CellLabel.h
index f0181e01f84c5..81766a3a59cdc 100644
--- a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/CellLabel.h
+++ b/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/CellLabel.h
@@ -12,10 +12,9 @@
 #ifndef ALICEO2_EMCAL_CELLLABEL_H_
 #define ALICEO2_EMCAL_CELLLABEL_H_
 
-#include <fairlogger/Logger.h>
+#include <cstddef>
+#include <cstdint>
 #include <gsl/span>
-#include <vector>
-#include "Rtypes.h"
 
 namespace o2
 {
@@ -52,10 +51,19 @@ class CellLabel
   /// \param index index which label to get
   int32_t GetLabel(size_t index) const { return mLabels[index]; }
 
+  /// \brief Getter for labels
+  gsl::span<const int32_t> GetLabels() const { return mLabels; }
+
   /// \brief Getter for amplitude fraction
   /// \param index index which amplitude fraction to get
   float GetAmplitudeFraction(size_t index) const { return mAmplitudeFraction[index]; }
 
+  /// \brief Getter for amplitude fractions
+  gsl::span<const float> GetAmplitudeFractions() const { return mAmplitudeFraction; }
+
+  /// \brief Getter for label with leading amplitude fraction
+  int32_t GetLeadingMCLabel() const;
+
  protected:
   gsl::span<const int32_t> mLabels;          ///< List of MC particles that generated the cluster, ordered in deposited energy.
   gsl::span<const float> mAmplitudeFraction; ///< List of the fraction of the cell energy coming from a MC particle. Index aligns with mLabels!
diff --git a/DataFormats/Detectors/EMCAL/src/CellLabel.cxx b/DataFormats/Detectors/EMCAL/src/CellLabel.cxx
index 8dde7ea90c435..e37368ea181d7 100644
--- a/DataFormats/Detectors/EMCAL/src/CellLabel.cxx
+++ b/DataFormats/Detectors/EMCAL/src/CellLabel.cxx
@@ -12,6 +12,10 @@
 /// \file CellLabel.cxx
 
 #include "DataFormatsEMCAL/CellLabel.h"
+#include "fairlogger/Logger.h"
+#include <cstddef>
+#include <cstdint>
+#include <gsl/span>
 
 using namespace o2::emcal;
 
@@ -21,3 +25,17 @@ CellLabel::CellLabel(const gsl::span<const int> labels, const gsl::span<const fl
     LOG(error) << "Size of labels " << labels.size() << " does not match size of amplitude fraction " << amplitudeFractions.size() << " !";
   }
 }
+
+int32_t CellLabel::GetLeadingMCLabel() const
+{
+  size_t maxIndex = 0;
+  float maxFraction = mAmplitudeFraction[0];
+
+  for (size_t i = 1; i < mAmplitudeFraction.size(); ++i) {
+    if (mAmplitudeFraction[i] > maxFraction) {
+      maxFraction = mAmplitudeFraction[i];
+      maxIndex = i;
+    }
+  }
+  return mLabels[maxIndex];
+}
diff --git a/Detectors/EMCAL/base/include/EMCALBase/Geometry.h b/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
index 4d4a947de88ca..b4621d4b6e434 100644
--- a/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
+++ b/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
@@ -12,19 +12,19 @@
 #ifndef ALICEO2_EMCAL_GEOMETRY_H_
 #define ALICEO2_EMCAL_GEOMETRY_H_
 
-#include <exception>
+#include <array>
 #include <string>
+#include <string_view>
 #include <tuple>
 #include <vector>
 
 #include <RStringView.h>
+#include <RtypesCore.h>
 #include <TGeoMatrix.h>
-#include <TNamed.h>
+#include <TMath.h>
 #include <TParticle.h>
 #include <TVector3.h>
-#include <TObjArray.h>
 
-#include "CCDB/BasicCCDBManager.h"
 #include "DataFormatsEMCAL/Constants.h"
 #include "EMCALBase/GeometryBase.h"
 #include "MathUtils/Cartesian.h"
@@ -515,6 +515,14 @@ class Geometry
   /// \return col
   std::tuple<int, int, int> getOnlineID(int towerID);
 
+  ///  \brief Check if 2 cells belong to the same T-Card
+  ///  \param absId1: Reference absId cell
+  ///  \param absId2: Cross checked cell absId
+  ///  \return true if belong to same TCard else false
+  ///  \return rowDiff: Distance in rows
+  ///  \return colDiff: Distance in columns
+  std::tuple<bool, int, int> areAbsIDsFromSameTCard(int absId1, int absId2) const;
+
   /// \brief Temporary link assignment (till final link assignment is known -
   /// \brief eventually taken from CCDB)
   /// \brief Current mapping can be found under https://alice.its.cern.ch/jira/browse/EMCAL-660
diff --git a/Detectors/EMCAL/base/src/Geometry.cxx b/Detectors/EMCAL/base/src/Geometry.cxx
index 6eff6c161f2a1..6039c18dd34e4 100644
--- a/Detectors/EMCAL/base/src/Geometry.cxx
+++ b/Detectors/EMCAL/base/src/Geometry.cxx
@@ -10,20 +10,38 @@
 // or submit itself to any jurisdiction.
 #include "EMCALBase/Geometry.h"
 
+#include <RtypesCore.h>
+#include <TMath.h>
+#include <TVector3.h>
+#include <TMathBase.h>
+#include <TVector2.h>
+#include <TParticle.h>
+#include <TString.h>
+#include <TGeoNode.h>
+#include <TJAlienCredentials.h>
+#include <TObjArray.h>
 #include <fairlogger/Logger.h>
 
+#include <cstring>
+#include <cctype>
+#include <cmath>
 #include <iomanip>
+#include <ostream>
 #include <string>
 #include <algorithm>
 #include <cstdio>
+#include <string_view>
 #include <tuple>
 
 #include <TGeoBBox.h>
 #include <TGeoManager.h>
 #include <TGeoMatrix.h>
-#include <TList.h>
 
+#include "DataFormatsEMCAL/Constants.h"
+#include "EMCALBase/GeometryBase.h"
+#include "CCDB/CcdbApi.h"
 #include "EMCALBase/ShishKebabTrd1Module.h"
+#include "GPUROOTCartesianFwd.h"
 
 #include <boost/algorithm/string/predicate.hpp>
 
@@ -1859,3 +1877,44 @@ std::tuple<int, int, int> Geometry::getOnlineID(int towerID)
 
   return std::make_tuple(supermoduleID * 2 + ddlInSupermoudel, row, col);
 }
+
+std::tuple<bool, int, int> Geometry::areAbsIDsFromSameTCard(int absId1, int absId2) const
+{
+
+  int rowDiff = -100;
+  int colDiff = -100;
+
+  if (absId1 == absId2) {
+    return {false, rowDiff, colDiff};
+  }
+
+  // Check if in same SM, if not for sure not same TCard
+  const int sm1 = GetSuperModuleNumber(absId1);
+  const int sm2 = GetSuperModuleNumber(absId2);
+  if (sm1 != sm2) {
+    return {false, rowDiff, colDiff};
+  }
+
+  // Get the column and row of each absId
+  const auto [_, iTower1, iIphi1, iIeta1] = GetCellIndex(absId1);
+  const auto [row1, col1] = GetCellPhiEtaIndexInSModule(sm1, iTower1, iIphi1, iIeta1);
+
+  const auto [__, iTower2, iIphi2, iIeta2] = GetCellIndex(absId2);
+  const auto [row2, col2] = GetCellPhiEtaIndexInSModule(sm2, iTower2, iIphi2, iIeta2);
+
+  // Define corner of TCard for absId1
+  const int tcardRow0 = row1 - row1 % 8;
+  const int tcardCol0 = col1 - col1 % 2;
+
+  // Difference of absId2 from corner of absId1's TCard
+  const int rowOffset = row2 - tcardRow0;
+  const int colOffset = col2 - tcardCol0;
+
+  // Differences between the two cells directly
+  rowDiff = row1 - row2;
+  colDiff = col1 - col2;
+
+  const bool sameTCard = (rowOffset >= 0 && rowOffset < 8 &&
+                          colOffset >= 0 && colOffset < 2);
+  return {sameTCard, rowDiff, colDiff};
+}

From 33ad8d468b3d6b526af72a7db178916bf3e8055a Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 6 Jun 2025 16:26:33 +0200
Subject: [PATCH 0464/1764] Add Helium-Oxygen collision systems (#14368)

---
 Generators/share/egconfig/pythia8_HeO.cfg | 10 ++++++++++
 Generators/share/egconfig/pythia8_OHe.cfg | 10 ++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 Generators/share/egconfig/pythia8_HeO.cfg
 create mode 100644 Generators/share/egconfig/pythia8_OHe.cfg

diff --git a/Generators/share/egconfig/pythia8_HeO.cfg b/Generators/share/egconfig/pythia8_HeO.cfg
new file mode 100644
index 0000000000000..6b5b01269fd5d
--- /dev/null
+++ b/Generators/share/egconfig/pythia8_HeO.cfg
@@ -0,0 +1,10 @@
+### beams
+Beams:frameType 2       # back-to-back beams of different energies and particles
+Beams:idA 1000020040    # Helium
+Beams:idB 1000080160    # Oxygen
+Beams:eA 3400.          # Energy in GeV per Helium nucleon (6.8 Z TeV) moving in the +z direction
+Beams:eB 3400.          # Energy in GeV per Oxygen nucleon (6.8 Z TeV) moving in the -z direction
+
+### decays
+ParticleDecays:limitTau0 on
+ParticleDecays:tau0Max 10.
\ No newline at end of file
diff --git a/Generators/share/egconfig/pythia8_OHe.cfg b/Generators/share/egconfig/pythia8_OHe.cfg
new file mode 100644
index 0000000000000..90f3c06a74d8c
--- /dev/null
+++ b/Generators/share/egconfig/pythia8_OHe.cfg
@@ -0,0 +1,10 @@
+### beams
+Beams:frameType 2       # back-to-back beams of different energies and particles
+Beams:idA 1000080160    # Oxygen
+Beams:idB 1000020040    # Helium
+Beams:eA 3400.          # Energy in GeV per Oxygen nucleon (6.8 Z TeV) moving in the +z direction
+Beams:eB 3400.          # Energy in GeV per Helium nucleon (6.8 Z TeV) moving in the -z direction
+
+### decays
+ParticleDecays:limitTau0 on
+ParticleDecays:tau0Max 10.
\ No newline at end of file

From ec14f04b7bec8ff51e520080ad3285a72ef7ed59 Mon Sep 17 00:00:00 2001
From: Hadi Hassan <hadi.hassan@cern.ch>
Date: Fri, 6 Jun 2025 17:27:51 +0300
Subject: [PATCH 0465/1764] [FOCAL-87] Implementing a new design for the HCAL
 (#14367)

* Implementing a new design for the HCAL.

* Formatting
---
 .../FOCAL/base/include/FOCALBase/Geometry.h   |  18 +-
 Detectors/FOCAL/base/src/Geometry.cxx         | 164 ++++++++----
 .../geometryFiles/geometry_Sheets.txt         |  86 +++++++
 .../include/FOCALSimulation/Detector.h        |  12 +
 Detectors/FOCAL/simulation/src/Detector.cxx   | 235 +++++++++++++++++-
 macro/build_geometry.C                        |   2 +-
 run/O2HitMerger.h                             |   2 +-
 7 files changed, 465 insertions(+), 54 deletions(-)
 create mode 100644 Detectors/FOCAL/simulation/geometryFiles/geometry_Sheets.txt

diff --git a/Detectors/FOCAL/base/include/FOCALBase/Geometry.h b/Detectors/FOCAL/base/include/FOCALBase/Geometry.h
index 770c0aa3c1cf5..3414d84b5298f 100644
--- a/Detectors/FOCAL/base/include/FOCALBase/Geometry.h
+++ b/Detectors/FOCAL/base/include/FOCALBase/Geometry.h
@@ -59,6 +59,12 @@ class VirtualSegment
 class Geometry
 {
  public:
+  enum HCALDesgin {
+    Sandwich = 0,  // Sandwich HCAL design
+    Spaghetti = 1, // Spaghetti design
+    Sheets = 2     // Sheets design
+  };
+
   Geometry() = default;
   Geometry(Geometry* geo);
   Geometry(const Geometry& geo) = default;
@@ -134,6 +140,8 @@ class Geometry
   float getMiddleTowerOffset() const { return mGlobal_Middle_Tower_Offset; }
   bool getInsertFrontPadLayers() const { return mInsertFrontPadLayers; }
   bool getInsertHCalReadoutMaterial() const { return mInsertFrontHCalReadoutMaterial; }
+  float getHCALPitchSize() const { return mGlobal_HCAL_Pitch_Size; }
+  float getHCALBeamPipeHoleSize() const { return mGlobal_HCAL_BeamPipeHole_Size; }
 
   float getDetectorOpeningRight() const { return mGlobal_DetectorOpening_Right; }
   float getDetectorOpeningLeft() const { return mGlobal_DetectorOpening_Left; }
@@ -158,7 +166,7 @@ class Geometry
   void setUpLayerSegmentMap();
   void setUpTowerWaferSize();
 
-  bool getUseHCALSandwich() { return mUseSandwichHCAL; }
+  HCALDesgin getHCALDesign() const { return mHCALDesign; }
 
  protected:
   std::vector<Composition> mGeometryComposition;
@@ -206,9 +214,11 @@ class Geometry
   std::string mGlobal_Gap_Material;         // gap filling material NOTE: currently not used
 
   float mGlobal_HCAL_Tower_Size = 0.0;
-  int mGlobal_HCAL_Tower_NX = 0; // Number of HCAL towers on X
-  int mGlobal_HCAL_Tower_NY = 0; // Number of HCAL towers on Y
-  bool mUseSandwichHCAL = false;
+  int mGlobal_HCAL_Tower_NX = 0;              // Number of HCAL towers on X
+  int mGlobal_HCAL_Tower_NY = 0;              // Number of HCAL towers on Y
+  float mGlobal_HCAL_Pitch_Size = 0.0;        // Distance between two fibers
+  float mGlobal_HCAL_BeamPipeHole_Size = 0.0; // beam pipe hole size in HCAL
+  HCALDesgin mHCALDesign = Sandwich;          // HCAL design type
 
   float mGlobal_FOCAL_Z0 = 0.0;
 
diff --git a/Detectors/FOCAL/base/src/Geometry.cxx b/Detectors/FOCAL/base/src/Geometry.cxx
index db47816ba8537..2699ab5c7d602 100644
--- a/Detectors/FOCAL/base/src/Geometry.cxx
+++ b/Detectors/FOCAL/base/src/Geometry.cxx
@@ -366,6 +366,11 @@ void Geometry::setParameters(std::string geometryfile)
         LOG(debug) << "The size of the HCAL readout tower will be : " << mGlobal_HCAL_Tower_Size;
       }
 
+      if (command.find("HCAL_PITCH_SIZE") != std::string::npos) {
+        mGlobal_HCAL_Pitch_Size = std::stof(tokens[1]);
+        LOG(debug) << "The distance between fibers is : " << mGlobal_HCAL_Pitch_Size;
+      }
+
       if (command.find("HCAL_TOWER_NX") != std::string::npos) {
         mGlobal_HCAL_Tower_NX = std::stoi(tokens[1]);
         LOG(debug) << "The number of the HCAL readout towers in X will be : " << mGlobal_HCAL_Tower_NX;
@@ -376,6 +381,11 @@ void Geometry::setParameters(std::string geometryfile)
         LOG(debug) << "The number of the HCAL readout towers in Y will be : " << mGlobal_HCAL_Tower_NY;
       }
 
+      if (command.find("HCAL_BEAMPIPE") != std::string::npos) {
+        mGlobal_HCAL_BeamPipeHole_Size = std::stof(tokens[1]);
+        LOG(debug) << "The HCAL beam pipe openning : " << mGlobal_HCAL_BeamPipeHole_Size;
+      }
+
       if (command.find("PIX_OffsetX") != std::string::npos) {
         mGlobal_PIX_OffsetX = std::stof(tokens[1]);
         LOG(debug) << "Pixel offset from the beam pipe will be: " << mGlobal_PIX_OffsetX;
@@ -429,11 +439,6 @@ void Geometry::setParameters(std::string geometryfile)
       if (command.find("NUMBER_OF_HCAL_LAYERS") != std::string::npos) {
         mNHCalLayers = std::stoi(tokens[1]);
         LOG(debug) << "Number of HCAL layers " << mNHCalLayers;
-        if (mNHCalLayers == 1) {
-          mUseSandwichHCAL = false;
-        } else {
-          mUseSandwichHCAL = true;
-        }
       }
 
       if (command.find("NUMBER_OF_SEGMENTS") != std::string::npos) {
@@ -640,6 +645,14 @@ void Geometry::setParameters(std::string geometryfile)
   mHCalLayerThickness = center_z;
   center_z = 0;
 
+  if (mNHCalLayers == 1 && hHCal > 2) {
+    mHCALDesign = Geometry::HCALDesgin::Sheets;
+  } else if (mNHCalLayers == 1 && hHCal == 2) {
+    mHCALDesign = Geometry::HCALDesgin::Spaghetti;
+  } else {
+    mHCALDesign = Geometry::HCALDesgin::Sandwich;
+  }
+
   mFrontMatterLayerThickness = center_z;
   LOG(debug) << " end of SetParameters ";
 }
@@ -702,27 +715,34 @@ std::tuple<double, double, double> Geometry::getGeoTowerCenter(int tower, int se
     int ix = id % nCols;
     int iy = id / nRows;
 
-    if (mUseSandwichHCAL) {
-      float padSize = mVirtualSegmentComposition[segment].mPadSize;
-      double hCALsizeX = nCols * padSize;
-      double hCALsizeY = nRows * padSize;
-      x = ix * padSize + 0.5 * padSize - 0.5 * hCALsizeX;
-      y = iy * padSize + 0.5 * padSize - 0.5 * hCALsizeY;
-    } else {
-      nCols = std::floor(getFOCALSizeX() / getHCALTowerSize() + 0.001) + 1;
-      nRows = std::floor(getFOCALSizeY() / getHCALTowerSize() + 0.001);
-      ix = id % nCols;
-      iy = id / nRows;
-      double beamPipeRadius = 3.6;                                 // in cm   TODO: check if this is OK
-      double towerHalfDiag = std::sqrt(2) * 0.5 * getTowerSizeX(); // tower half diagonal
-      double minRadius = beamPipeRadius + towerHalfDiag;
-
-      float towerSize = getHCALTowerSize() / 7; // To be set from outside (number of channels on x & y)
-      y = iy * towerSize + 0.5 * towerSize - 0.5 * towerSize * nRows;
-      x = ix * towerSize + 0.5 * towerSize - 0.5 * towerSize * nCols;
-      if (y < minRadius && y > -minRadius) {
-        x = int(x) <= 0 ? x - (minRadius - towerSize) : x + (minRadius - towerSize);
+    switch (mHCALDesign) {
+      case HCALDesgin::Sandwich: {
+        float padSize = mVirtualSegmentComposition[segment].mPadSize;
+        double hCALsizeX = nCols * padSize;
+        double hCALsizeY = nRows * padSize;
+
+        x = ix * padSize + 0.5 * padSize - 0.5 * hCALsizeX;
+        y = iy * padSize + 0.5 * padSize - 0.5 * hCALsizeY;
+        break;
       }
+      case HCALDesgin::Spaghetti: {
+        float towerSize = getHCALTowerSize() / 7; // To be set from outside (number of channels on x & y)
+        y = iy * towerSize + 0.5 * towerSize - 0.5 * towerSize * nRows;
+        x = ix * towerSize + 0.5 * towerSize - 0.5 * towerSize * nCols;
+        break;
+      }
+      case HCALDesgin::Sheets: {
+        Composition comp1 = mHCalCompositionBase[0];
+        Composition comp2 = mHCalCompositionBase[2];
+        double hCALsizeX = comp1.sizeX() * 2;                                        // Size of two sheet in X
+        double hCALsizeY = getHCALTowersInY() * (comp1.sizeY() + comp2.sizeY()) * 2; // To be set in a better way
+
+        x = ix * hCALsizeX / getHCALTowersInX() + 0.5 * hCALsizeX / getHCALTowersInX() - 0.5 * hCALsizeX;
+        y = iy * hCALsizeY / getHCALTowersInY() + 0.5 * hCALsizeY / getHCALTowersInY() - 0.5 * hCALsizeY;
+        break;
+      }
+      default:
+        break;
     }
   }
 
@@ -1118,12 +1138,41 @@ std::tuple<bool, int, int, int, int> Geometry::getVirtualInfo(double x, double y
       x = x < 0 ? x - 0.001 : x + 0.001;
       y = y < 0 ? y - 0.001 : y + 0.001;
     }
-    if (!mUseSandwichHCAL) {
-      row = (int)((y + hCALsizeY / 2) / (towerSize / 7));
-      col = (int)((x + hCALsizeX / 2) / (towerSize / 7));
-    } else {
-      row = (int)((y + hCALsizeY / 2) / (towerSize));
-      col = (int)((x + hCALsizeX / 2) / (towerSize));
+
+    switch (mHCALDesign) {
+      case HCALDesgin::Sandwich: {
+        row = (int)((y + hCALsizeY / 2) / (towerSize));
+        col = (int)((x + hCALsizeX / 2) / (towerSize));
+        break;
+      }
+      case HCALDesgin::Spaghetti: {
+        row = (int)((y + hCALsizeY / 2) / (towerSize / 7));
+        col = (int)((x + hCALsizeX / 2) / (towerSize / 7));
+        break;
+      }
+      case HCALDesgin::Sheets: {
+        Composition comp1 = mHCalCompositionBase[0];
+        Composition comp2 = mHCalCompositionBase[2];
+        double hCALsizeX = comp1.sizeX() * 2;                                        // Size of two sheet in X
+        double hCALsizeY = getHCALTowersInY() * (comp1.sizeY() + comp2.sizeY()) * 2; // To be set in a better way
+
+        if (y < getHCALBeamPipeHoleSize() / 2 && y > -getHCALBeamPipeHoleSize() / 2) {
+          if (x < 0) {
+            x += 1.0; // remove the offset around the beam pipe
+          } else {
+            x -= 1.0; // remove the offset around the beam pipe
+          }
+        }
+
+        row = (int)((y + hCALsizeY / 2) / (hCALsizeY / getHCALTowersInY()));
+        if (x > 0) {
+          x = x - 0.15 - 0.06;
+        }
+        col = (int)((x - 0.15 + hCALsizeX / 2) / ((hCALsizeX - 0.15 * 2 - 0.06 * 2) / getHCALTowersInX()));
+        break;
+      }
+      default:
+        break;
     }
   } else {
     row = (int)((y + getFOCALSizeY() / 2) / mVirtualSegmentComposition[segment].mPadSize);
@@ -1150,12 +1199,29 @@ std::tuple<bool, double, double, double> Geometry::getXYZFromColRowSeg(int col,
     double hCALsizeX = getHCALTowersInX() * towerSize;
     double hCALsizeY = getHCALTowersInY() * towerSize;
 
-    if (!mUseSandwichHCAL) {
-      y = -1 * hCALsizeY / 2 + ((float)row + 0.5) * (towerSize / 7);
-      x = -1 * hCALsizeX / 2 + ((float)col + 0.5) * (towerSize / 7);
-    } else {
-      y = -1 * hCALsizeY / 2 + ((float)row + 0.5) * (towerSize);
-      x = -1 * hCALsizeX / 2 + ((float)col + 0.5) * (towerSize);
+    switch (mHCALDesign) {
+      case HCALDesgin::Sandwich: {
+        y = -1 * hCALsizeY / 2 + ((float)row + 0.5) * (towerSize);
+        x = -1 * hCALsizeX / 2 + ((float)col + 0.5) * (towerSize);
+        break;
+      }
+      case HCALDesgin::Spaghetti: {
+        y = -1 * hCALsizeY / 2 + ((float)row + 0.5) * (towerSize / 7);
+        x = -1 * hCALsizeX / 2 + ((float)col + 0.5) * (towerSize / 7);
+        break;
+      }
+      case HCALDesgin::Sheets: {
+        Composition comp1 = mHCalCompositionBase[0];
+        Composition comp2 = mHCalCompositionBase[2];
+        double hCALsizeX = comp1.sizeX() * 2;                                        // Size of two sheet in X
+        double hCALsizeY = getHCALTowersInY() * (comp1.sizeY() + comp2.sizeY()) * 2; // To be set in a better way
+
+        y = -1 * hCALsizeY / 2 + ((float)row + 0.5) * (hCALsizeY / getHCALTowersInY());
+        x = -1 * hCALsizeX / 2 + ((float)col + 0.5) * (hCALsizeX / getHCALTowersInX());
+        break;
+      }
+      default:
+        break;
     }
   } else {
     y = -1 * getFOCALSizeY() / 2 + ((float)row + 0.5) * mVirtualSegmentComposition[segment].mPadSize;
@@ -1191,12 +1257,24 @@ std::tuple<bool, int, int> Geometry::getVirtualNColRow(int segment) const
   nCol = (int)(getFOCALSizeX() / mVirtualSegmentComposition[segment].mPadSize + 0.001);
   nRow = (int)(getFOCALSizeY() / mVirtualSegmentComposition[segment].mPadSize + 0.001);
   if (getVirtualIsHCal(segment)) {
-    if (!mUseSandwichHCAL) {
-      nCol = getHCALTowersInX() * 7; // To be set from outside (number of channels in each tower on x)
-      nRow = getHCALTowersInY() * 7; // To be set from outside (number of channels in each tower on y)
-    } else {
-      nCol = getHCALTowersInX();
-      nRow = getHCALTowersInY();
+    switch (mHCALDesign) {
+      case HCALDesgin::Sandwich: {
+        nCol = getHCALTowersInX();
+        nRow = getHCALTowersInY();
+        break;
+      }
+      case HCALDesgin::Spaghetti: {
+        nCol = getHCALTowersInX() * 7; // To be set from outside (number of channels in each tower on x)
+        nRow = getHCALTowersInY() * 7; // To be set from outside (number of channels in each tower on y)
+        break;
+      }
+      case HCALDesgin::Sheets: {
+        nCol = getHCALTowersInX();
+        nRow = getHCALTowersInY();
+        break;
+      }
+      default:
+        break;
     }
   }
   return {true, nCol, nRow};
diff --git a/Detectors/FOCAL/simulation/geometryFiles/geometry_Sheets.txt b/Detectors/FOCAL/simulation/geometryFiles/geometry_Sheets.txt
new file mode 100644
index 0000000000000..358fcef2cd29d
--- /dev/null
+++ b/Detectors/FOCAL/simulation/geometryFiles/geometry_Sheets.txt
@@ -0,0 +1,86 @@
+# Volume Name            Material     C-X   C-Y    X      Y       Z
+  COMPOSITION_PAD_S0       Alloy       0     0     9.     8.      0.35
+  COMPOSITION_PAD_S1       G10         0     0     9.     8.      0.08
+  COMPOSITION_PAD_S2       SiPad       0     0     9.     8.      0.03
+  COMPOSITION_PAD_S3       G10         0     0     9.     8.      0.08
+  COMPOSITION_PAD_S4       Cu          0     0     9.     8.      0.014
+  COMPOSITION_PAD_S5       Air         0     0     9.     8.      0.296
+  # Replica of above pad layers to 50 layers
+  COMMAND_NUMBER_OF_PAD_LAYERS 18
+# HCAL layers
+# Volume Name              Material     C-X   C-Y     X       Y        Z
+  COMPOSITION_HCAL_S0       CuHCAL       0     0     49.81   0.20     110
+  COMPOSITION_HCAL_S1       Scint        0     0     0.1     0.1      110
+  COMPOSITION_HCAL_S2       CuHCAL       0     0     49.81   0.15     110
+  COMMAND_NUMBER_OF_HCAL_LAYERS 1
+  COMMAND_NUMBER_OF_SEGMENTS 21
+# Strip sectors
+# Volume Name             Material    C-X   C-Y     X       Y         Z
+  COMPOSITION_PIX_S0       Alloy       0     0     3.0     2.74      0.35
+  COMPOSITION_PIX_S1       G10         0     0     3.0     2.74      0.1
+  COMPOSITION_PIX_S2       Si          0     0     3.0     2.74      0.047
+  COMPOSITION_PIX_S3       SiPix       0     0     3.0     2.74      0.003
+  COMPOSITION_PIX_S4       G10         0     0     3.0     2.74      0.1
+  COMPOSITION_PIX_S5       Cu          0     0     3.0     2.74      0.001
+  COMPOSITION_PIX_S6       Air         0     0     3.0     2.74      0.249
+COMMAND_INSERT_PIX_AT_L4
+COMMAND_INSERT_PIX_AT_L9
+# COMMAND_INSERT_STR_AT_L4
+# COMMAND_INSERT_STR_AT_L6
+# COMMAND_INSERT_STR_AT_L8
+#Front Matter definition
+  COMPOSITION_FM_S0        G10         0     0     5.    5.      0.01
+  COMPOSITION_FM_S1        SiStripX    0     0     5.    5.      0.05
+  COMPOSITION_FM_S2        G10         0     0     5.    5.      0.05
+  COMPOSITION_FM_S3        Air         0     0     5.    5.      0.01
+  COMPOSITION_FM_S4        G10         0     0     5.    5.      0.01
+  COMPOSITION_FM_S5        SiStripY    0     0     5.    5.      0.05
+  COMPOSITION_FM_S6        G10         0     0     5.    5.      0.05
+# PIXEL readout
+  GLOBAL_PIX_NX                  15
+  GLOBAL_PIX_NY                  3
+  GLOBAL_PIX_OffsetX             1.2
+  GLOBAL_PIX_OffsetY             0.09
+  GLOBAL_PIX_SKIN                0.004
+#  pxel size in cm
+  COMMAND_PIXEL_READOUT_ON       0.005
+# Pad information
+  GLOBAL_PAD_SIZE_X_Y            1
+  GLOBAL_PAD_NX_NY               8
+  GLOBAL_PAD_NX                  9
+  GLOBAL_PAD_NY                  8
+  GLOBAL_PAD_PPTOL               0.
+  GLOBAL_PAD_SKIN                0.2
+# Global information (TOL:1cm of T-T space filled with "AIR")
+  GLOBAL_PAD_SUPERMODULE_X 5
+  GLOBAL_PAD_SUPERMODULE_Y 1
+  GLOBAL_SUPERMODULE_TOLX 0. Air
+  GLOBAL_SUPERMODULE_TOLY 0. Air
+  GLOBAL_TOWER_TOL        0.    Air
+  GLOBAL_TOWER_TOLX       0.02  Air
+  GLOBAL_TOWER_TOLY       0.8   Al
+  GLOBAL_FOCAL_Z          764.47
+  GLOBAL_Tower_NX      2
+  GLOBAL_Tower_NY      11
+  GLOBAL_MIDDLE_TOWER_OFFSET 5
+  GLOBAL_NSTRIPS	        128
+  GLOBAL_STRIPSIZE_LONG   9.0
+  GLOBAL_STRIPSIZE_WIDTH  0.07
+  GLOBAL_HCAL_PITCH_SIZE  0.4
+  GLOBAL_HCAL_TOWER_NY  72
+  GLOBAL_HCAL_TOWER_NX  62
+  GLOBAL_HCAL_BEAMPIPE  8.4
+# COMMAND_INSERT_FRONT_PAD_LAYERS
+# COMMAND_INSERT_HCAL_READOUT
+# New VIRTUAL settings
+  VIRTUAL_N_SEGMENTS      7
+  #                            N   Start End   PadSize  RelThickness  IsPixel    PixelTreshold [eV]
+  #                                Layer Layer
+  VIRTUAL_SEGMENT_LAYOUT_N0       0    3           1.0           1.0       0                  300000
+  VIRTUAL_SEGMENT_LAYOUT_N1       4    4           0.05          1.0       1                  4000
+  VIRTUAL_SEGMENT_LAYOUT_N2       5    8           1.0           1.0       0                  300000
+  VIRTUAL_SEGMENT_LAYOUT_N3       9    9           0.05          1.0       1                  4000
+  VIRTUAL_SEGMENT_LAYOUT_N4      10   14           1.0           1.0       0                  375000
+  VIRTUAL_SEGMENT_LAYOUT_N5      15   19           1.0           1.0       0                  375000
+  VIRTUAL_SEGMENT_LAYOUT_N6      20   20           0.4           1.0       2                  5000
+#EOF
diff --git a/Detectors/FOCAL/simulation/include/FOCALSimulation/Detector.h b/Detectors/FOCAL/simulation/include/FOCALSimulation/Detector.h
index e7b887d206831..5f6bed3a037b0 100644
--- a/Detectors/FOCAL/simulation/include/FOCALSimulation/Detector.h
+++ b/Detectors/FOCAL/simulation/include/FOCALSimulation/Detector.h
@@ -17,6 +17,7 @@
 #include "DetectorsBase/Detector.h"
 #include "FOCALBase/Hit.h"
 #include "FOCALBase/Geometry.h"
+#include "TGeoManager.h"
 
 class FairVolume;
 
@@ -157,6 +158,17 @@ class Detector : public o2::base::DetImpl<Detector>
 
   virtual void CreateHCALSpaghetti();
   virtual void CreateHCALSandwich();
+  virtual void CreateHCALSheets();
+
+  TGeoVolumeAssembly* CreatePitchAssembly(double Lx = 498.1,
+                                          double Ly1 = 2.0,
+                                          double Ly2 = 1.5,
+                                          double Lz = 1100.0,
+                                          double hole_diameter = 1.1,
+                                          double hole_spacing = 4.0,
+                                          int nholes = 124,
+                                          double fiber_radius = 0.5,
+                                          std::string suffix = "");
 
   /// \brief Generate ECAL geometry
   void CreateECALGeometry();
diff --git a/Detectors/FOCAL/simulation/src/Detector.cxx b/Detectors/FOCAL/simulation/src/Detector.cxx
index 164b531e60918..464e57c07e676 100644
--- a/Detectors/FOCAL/simulation/src/Detector.cxx
+++ b/Detectors/FOCAL/simulation/src/Detector.cxx
@@ -480,11 +480,23 @@ void Detector::ConstructGeometry()
   CreateECALGeometry();
 
   // HCAL part
-  if (mGeometry->getUseHCALSandwich()) {
-    CreateHCALSandwich();
-  } else {
-    CreateHCALSpaghetti();
+  switch (mGeometry->getHCALDesign()) {
+    case Geometry::HCALDesgin::Sandwich:
+      CreateHCALSandwich();
+      break;
+
+    case Geometry::HCALDesgin::Spaghetti:
+      CreateHCALSpaghetti();
+      break;
+
+    case Geometry::HCALDesgin::Sheets:
+      CreateHCALSheets();
+      break;
+
+    default:
+      break;
   }
+
   // const float z0 = 1312.5; // center of barrel mother volume
   TVirtualMC::GetMC()->Gspos("FOCAL", 1, "barrel", 0, 30., mGeometry->getFOCALZ0() - (mGeometry->getInsertFrontPadLayers() ? 2.0 : 0.0) + (mGeometry->getInsertHCalReadoutMaterial() ? 1.5 : 0.0), 0, "ONLY");
 }
@@ -681,6 +693,219 @@ void Detector::CreateHCALSpaghetti()
   TVirtualMC::GetMC()->Gspos("HCAL", 1, "FOCAL", 0, 0, mGeometry->getHCALCenterZ() - mGeometry->getFOCALSizeZ() / 2 + 0.01 + (mGeometry->getInsertFrontPadLayers() ? 2.0 : 0.0) - (mGeometry->getInsertHCalReadoutMaterial() ? 1.5 : 0.0), 0, "ONLY");
 }
 
+//_____________________________________________________________________________
+TGeoVolumeAssembly* Detector::CreatePitchAssembly(double Lx,
+                                                  double Ly1,
+                                                  double Ly2,
+                                                  double Lz,
+                                                  double hole_diameter,
+                                                  double hole_spacing,
+                                                  int nholes,
+                                                  double fiber_radius,
+                                                  std::string suffix)
+{
+
+  // Z-alignment doesn't change
+  double zpos = 0;
+
+  TGeoMedium* copper = gGeoManager->GetMedium(getMediumID(ID_COPPER));
+  TGeoMedium* scint = gGeoManager->GetMedium(getMediumID(ID_SC));
+
+  TGeoVolumeAssembly* pitchAssembly = new TGeoVolumeAssembly("pitchAssembly");
+
+  // Hardcoded values for hole placement, to be set from outside
+  float holeStart = 0.15; // cm
+  float holeEnd = 0.35;   // cm
+
+  TGeoVolumeAssembly* volLowerSheetwHoles = new TGeoVolumeAssembly(Form("volLowerSheetwHoles_%s", suffix.c_str()));
+  TGeoVolume* cuSheet = gGeoManager->MakeBox("cuSheet", copper, Lx / 2, (Ly1 - fiber_radius * 2) / 2, Lz / 2);
+  cuSheet->SetLineColor(kOrange + 2);
+  mSensitive.push_back(cuSheet->GetName());
+  TGeoVolume* boxbegin = gGeoManager->MakeBox("BoxBegin", copper, holeStart / 2, fiber_radius, Lz / 2);
+  boxbegin->SetLineColor(kOrange + 2);
+  mSensitive.push_back(boxbegin->GetName());
+  TGeoVolume* boxMiddle = gGeoManager->MakeBox("BoxMiddle", copper, (hole_spacing - hole_diameter) / 2, fiber_radius, Lz / 2);
+  boxMiddle->SetLineColor(kOrange + 2);
+  mSensitive.push_back(boxMiddle->GetName());
+  TGeoVolume* boxEnd = gGeoManager->MakeBox("BoxEnd", copper, holeEnd / 2, fiber_radius, Lz / 2);
+  boxEnd->SetLineColor(kOrange + 2);
+  mSensitive.push_back(boxEnd->GetName());
+
+  double yPlacement = Ly1 / 2 - fiber_radius;
+
+  // -----------------
+  // Layer 1: Lower sheet with holes (y = 0)
+  // -----------------
+
+  volLowerSheetwHoles->AddNode(cuSheet, 0, new TGeoTranslation(0, -Ly1 / 2 + (Ly1 - fiber_radius * 2) / 2, zpos));
+
+  // Add holes starting at x = 1.5 mm
+  float start_x = -Lx / 2 + holeStart;
+
+  for (int ihole = 0; ihole < nholes; ++ihole) {
+    float holePlacement = start_x + ihole * hole_spacing + hole_diameter / 2;
+    if (ihole == 0) {
+      volLowerSheetwHoles->AddNode(boxbegin, ihole, new TGeoTranslation(holePlacement - holeStart / 2 - hole_diameter / 2, yPlacement, zpos));
+      volLowerSheetwHoles->AddNode(boxMiddle, ihole, new TGeoTranslation(holePlacement + hole_diameter / 2 + (hole_spacing - hole_diameter) / 2, yPlacement, zpos));
+    } else if (ihole == nholes - 1) {
+      if ((holePlacement + hole_diameter / 2 + holeStart) < Lx / 2 - 0.005) {
+        volLowerSheetwHoles->AddNode(boxEnd, ihole, new TGeoTranslation(holePlacement + hole_diameter / 2 + holeEnd / 2, yPlacement, zpos));
+      } else {
+        volLowerSheetwHoles->AddNode(boxbegin, ihole, new TGeoTranslation(holePlacement + hole_diameter / 2 + holeStart / 2, yPlacement, zpos));
+      }
+    } else {
+      volLowerSheetwHoles->AddNode(boxMiddle, ihole, new TGeoTranslation(holePlacement + hole_diameter / 2 + (hole_spacing - hole_diameter) / 2, yPlacement, zpos));
+    }
+  }
+
+  pitchAssembly->AddNode(volLowerSheetwHoles, 0, new TGeoTranslation(0, Ly1 / 2, zpos)); // Add Ly1 / 2 so the lower edge of the sheets start y=0
+
+  // -----------------
+  // Layer 2: Full copper sheet
+  // -----------------
+  TGeoVolume* fullSheet1 = gGeoManager->MakeBox("FullSheet1", copper, Lx / 2, Ly2 / 2, Lz / 2);
+  fullSheet1->SetLineColor(kOrange + 2);
+  mSensitive.push_back(fullSheet1->GetName());
+  pitchAssembly->AddNode(fullSheet1, 0, new TGeoTranslation(0, Ly1 / 2 + Ly2 / 2 + Ly1 / 2, zpos)); // Add Ly1 / 2 so the lower edge of the sheets start y=0
+
+  // -----------------
+  // Layer 3: Upper sheet with holes (shifted)
+  // -----------------
+
+  TGeoVolumeAssembly* volUpperSheetwHoles = new TGeoVolumeAssembly(Form("volUpperSheetwHoles_%s", suffix.c_str()));
+
+  volUpperSheetwHoles->AddNode(cuSheet, 0, new TGeoTranslation(0, -Ly1 / 2 + (Ly1 - fiber_radius * 2) / 2, zpos));
+
+  // Add holes starting at x = 3.5 mm
+  float start_x2 = -Lx / 2 + holeEnd;
+
+  for (int ihole = 0; ihole < nholes; ++ihole) {
+    float holePlacement = start_x2 + ihole * hole_spacing + hole_diameter / 2;
+    if (ihole == 0) {
+      volUpperSheetwHoles->AddNode(boxEnd, ihole, new TGeoTranslation(holePlacement - hole_diameter / 2 - holeEnd / 2, yPlacement, zpos));
+      volUpperSheetwHoles->AddNode(boxMiddle, ihole, new TGeoTranslation(holePlacement + hole_diameter / 2 + (hole_spacing - hole_diameter) / 2, yPlacement, zpos));
+    } else if (ihole == nholes - 1) {
+      volUpperSheetwHoles->AddNode(boxbegin, ihole, new TGeoTranslation(holePlacement + holeStart / 2 + hole_diameter / 2, yPlacement, zpos));
+    } else {
+      if ((holePlacement + hole_spacing + hole_diameter / 2) < Lx / 2 - 0.005) {
+        volUpperSheetwHoles->AddNode(boxMiddle, ihole, new TGeoTranslation(holePlacement + hole_diameter / 2 + (hole_spacing - hole_diameter) / 2, yPlacement, zpos));
+      } else {
+        volUpperSheetwHoles->AddNode(boxEnd, ihole, new TGeoTranslation(holePlacement + hole_diameter / 2 + holeEnd / 2, yPlacement, zpos));
+        break;
+      }
+    }
+  }
+
+  pitchAssembly->AddNode(volUpperSheetwHoles, 0, new TGeoTranslation(0, Ly1 / 2 + Ly2 + Ly1 / 2 + Ly1 / 2, zpos)); // Add Ly1 / 2 so the lower edge of the sheets start y=0
+
+  // -----------------
+  // Layer 4: Full copper sheet
+  // -----------------
+  pitchAssembly->AddNode(fullSheet1, 1, new TGeoTranslation(0, Ly1 / 2 + Ly2 + Ly1 + Ly2 / 2 + Ly1 / 2, zpos)); // Add Ly1 / 2 so the lower edge of the sheets start y=0
+
+  // -----------------
+  // Scintillator Fibers
+  // -----------------
+  // Lower set of fibers
+  TGeoVolume* fiber = gGeoManager->MakeTube("Fiber", scint, 0, fiber_radius, Lz / 2);
+  fiber->SetLineColor(kBlue);
+  mSensitive.push_back(fiber->GetName());
+  for (int i = 0; i < nholes; ++i) {
+    float x_fiber = start_x + i * hole_spacing + hole_diameter / 2;
+    pitchAssembly->AddNode(fiber, i, new TGeoTranslation(x_fiber, Ly1 / 2 - fiber_radius + Ly1 / 2, zpos));
+  }
+
+  // Upper set of fibers
+  for (int i = 0; i < nholes; ++i) {
+    float x_fiber = start_x2 + i * hole_spacing + hole_diameter / 2;
+    if (x_fiber > Lx / 2 - 0.05) {
+      break;
+    }
+    pitchAssembly->AddNode(fiber, i + nholes, new TGeoTranslation(x_fiber, Ly1 / 2 + Ly2 + Ly1 / 2 + Ly1 / 2 - fiber_radius + Ly1 / 2, zpos));
+  }
+
+  return pitchAssembly;
+}
+
+//_____________________________________________________________________________
+void Detector::CreateHCALSheets()
+{
+  TGeoVolumeAssembly* volHCAL = new TGeoVolumeAssembly("HCAL");
+
+  // Dimensions
+  double Lx = 49.81; // cm
+  double Ly1 = 0.20; // cm (sheets with holes)
+  double Ly2 = 0.15; // cm (full sheets)
+  double Lz = 110.0; // cm
+
+  double fiber_radius = 0.05;
+
+  // HCal materials
+  int icomp = 0;
+  for (auto& comp : mGeoCompositions) {
+    Lz = comp->sizeZ();
+
+    if (comp->material() == "Scint") {
+      fiber_radius = comp->sizeX() / 2;
+    }
+    if (comp->material() == "CuHCAL" && icomp == 0) {
+      Lx = comp->sizeX();
+      Ly1 = comp->sizeY();
+    }
+    if (comp->material() == "CuHCAL" && icomp == 2) {
+      Ly2 = comp->sizeY();
+    }
+    icomp++;
+  }
+
+  double hole_diameter = fiber_radius * 2 + 0.01; // hole radius
+  double hole_spacing = mGeometry->getHCALPitchSize();
+  int nholes = (int)(Lx / hole_spacing); // Number of holes in one HCAL sheet
+
+  double beamPipeHole = mGeometry->getHCALBeamPipeHoleSize();         // cm The size of the beam pipe opening
+  int nBeamPipeHoles = (int)((Lx - beamPipeHole / 2) / hole_spacing); // Number of beam pipe holes
+
+  // Compute module height (two sheets with holes + two full sheets)
+  float pitch_height = Ly1 + Ly2 + Ly1 + Ly2;
+
+  int totalNumberOfPitches = mGeometry->getHCALTowersInY() * 2;                  // Number of pitches in the whole HCAL
+  int numberOfPitchesBeamPipe = (int)((beamPipeHole + 0.001) / pitch_height);    // Number of pitches in the beam pipe region
+  int numberofPitchesOnYaxis = (totalNumberOfPitches - numberOfPitchesBeamPipe); // Number of pitches in the HCAL ouside the beam pipe region
+
+  TGeoVolumeAssembly* pitchAssembly = CreatePitchAssembly(Lx, Ly1, Ly2, Lz, hole_diameter, hole_spacing, nholes, fiber_radius, "Main");
+  pitchAssembly->SetVisibility(true);
+  TGeoVolumeAssembly* beamPipeAssembly = CreatePitchAssembly(Lx - beamPipeHole / 2, Ly1, Ly2, Lz, hole_diameter, hole_spacing, nBeamPipeHoles, fiber_radius, "BeamPipe");
+  beamPipeAssembly->SetVisibility(true);
+
+  TGeoVolumeAssembly* HalfHCAL = new TGeoVolumeAssembly("HalfHCAL");
+
+  for (int iPitch = 0; iPitch < numberofPitchesOnYaxis; iPitch++) {
+    float placement = iPitch * pitch_height - pitch_height * (totalNumberOfPitches) / 2.0;
+    if (placement < -beamPipeHole / 2.0) {
+      HalfHCAL->AddNode(pitchAssembly, iPitch, new TGeoTranslation(0, placement, 0.));
+    } else {
+      placement += beamPipeHole;
+      HalfHCAL->AddNode(pitchAssembly, iPitch, new TGeoTranslation(0, placement, 0.));
+    }
+  }
+
+  for (int iPitch = 0; iPitch < numberOfPitchesBeamPipe; iPitch++) {
+    float placement = iPitch * pitch_height - beamPipeHole / 2.0;
+    HalfHCAL->AddNode(beamPipeAssembly, iPitch, new TGeoTranslation(-beamPipeHole / 4, placement, 0.));
+  }
+
+  HalfHCAL->SetVisibility(true);
+  HalfHCAL->SetVisDaughters(true);
+
+  volHCAL->AddNode(HalfHCAL, 0, new TGeoTranslation(-Lx / 2, 0, 0.));
+  TGeoRotation* rotFlipZ = new TGeoRotation();
+  rotFlipZ->RotateY(180); // Flip around Y to reverse Z
+  TGeoCombiTrans* combHalf = new TGeoCombiTrans(Lx / 2, 0., 0., rotFlipZ);
+  volHCAL->AddNode(HalfHCAL, 1, combHalf);
+
+  gMC->Gspos("HCAL", 1, "FOCAL", 0, 0, mGeometry->getHCALCenterZ() - mGeometry->getFOCALSizeZ() / 2 + 0.01 + (mGeometry->getInsertFrontPadLayers() ? 2.0 : 0.0) - (mGeometry->getInsertHCalReadoutMaterial() ? 1.5 : 0.0), 0, "ONLY");
+}
+
 //_____________________________________________________________________________
 void Detector::CreateHCALSandwich()
 {
@@ -819,7 +1044,7 @@ void Detector::CreateECALGeometry()
   double pars[4]; // this is EMSC Assembly
   pars[0] = geom->getTowerSizeX() / 2. + geom->getTowerGapSizeX() / 2.;
   pars[1] = geom->getTowerSizeY() / 2. + geom->getTowerGapSizeY() / 2.;
-  // pars[2] = fGeom->GetFOCALSizeZ() / 2;
+  // pars[2] = mGeometry->GetFOCALSizeZ() / 2;
   pars[2] = geom->getECALSizeZ() / 2;
   pars[3] = 0;
   // this shifts all the pixel layers to the center near the beampipe
diff --git a/macro/build_geometry.C b/macro/build_geometry.C
index 93b06eb4bfeae..fde043256046a 100644
--- a/macro/build_geometry.C
+++ b/macro/build_geometry.C
@@ -333,7 +333,7 @@ void build_geometry(FairRunSim* run = nullptr)
 
   if (isActivated("FOC")) {
     // FOCAL
-    addReadoutDetector(new o2::focal::Detector(isReadout("FOC"), gSystem->ExpandPathName("$O2_ROOT/share/Detectors/Geometry/FOC/geometryFiles/geometry_Spaghetti.txt")));
+    addReadoutDetector(new o2::focal::Detector(isReadout("FOC"), gSystem->ExpandPathName("$O2_ROOT/share/Detectors/Geometry/FOC/geometryFiles/geometry_Sheets.txt")));
   }
 
   if (geomonly) {
diff --git a/run/O2HitMerger.h b/run/O2HitMerger.h
index bd905548b58f3..c2a094bfc9e54 100644
--- a/run/O2HitMerger.h
+++ b/run/O2HitMerger.h
@@ -984,7 +984,7 @@ void O2HitMerger::initDetInstances()
       counter++;
     }
     if (i == DetID::FOC) {
-      mDetectorInstances[i] = std::move(std::make_unique<o2::focal::Detector>(true, gSystem->ExpandPathName("$O2_ROOT/share/Detectors/Geometry/FOC/geometryFiles/geometry_Spaghetti.txt")));
+      mDetectorInstances[i] = std::move(std::make_unique<o2::focal::Detector>(true, gSystem->ExpandPathName("$O2_ROOT/share/Detectors/Geometry/FOC/geometryFiles/geometry_Sheets.txt")));
       counter++;
     }
 #ifdef ENABLE_UPGRADES

From 893836d5f4b2851aa3e7eac51e583fc1211d164d Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sawenzel@gmail.com>
Date: Fri, 6 Jun 2025 16:30:19 +0200
Subject: [PATCH 0466/1764] AOD: Possibility to inject additional meta data
 (#14362)

Commit provides possibility to inject additional (non-hard-coded)
meta data into AOD. This could be used by MC to add information about
timeframe length used or other specific configurations etc.

The commit relates to https://its.cern.ch/jira/browse/O2-6027

By default this does not change any production behaviour. Existing
meta data is not touched.

This works by generating a simple key-value json (foo.json) like
```
{
  "ALIEN_JDL_MC_ORBITS_PER_TF": "4",
  "ALIEN_JDL_ANCHOR_SIM_OPTIONS": "-gen pythia8"
}
```

and then exporting an environment variable pointing to this json.

```
export AOD_ADDITIONAL_METADATA_FILE=${PWD}/foo.json
```
---
 Detectors/AOD/CMakeLists.txt                  |  7 ++--
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 36 +++++++++++++++++++
 2 files changed, 40 insertions(+), 3 deletions(-)

diff --git a/Detectors/AOD/CMakeLists.txt b/Detectors/AOD/CMakeLists.txt
index acd703dcc6be7..7ab36d260e480 100644
--- a/Detectors/AOD/CMakeLists.txt
+++ b/Detectors/AOD/CMakeLists.txt
@@ -42,14 +42,14 @@ o2_add_executable(
   COMPONENT_NAME aod-producer
   TARGETVARNAME targetName
   SOURCES src/aod-producer-workflow.cxx src/AODProducerWorkflowSpec.cxx src/AODMcProducerHelpers.cxx
-  PUBLIC_LINK_LIBRARIES internal::AODProducerWorkflow O2::Version
+  PUBLIC_LINK_LIBRARIES internal::AODProducerWorkflow O2::Version nlohmann_json::nlohmann_json
 )
 
 o2_add_executable(
   workflow
   COMPONENT_NAME aod-mc-producer
   SOURCES src/aod-mc-producer-workflow.cxx src/AODMcProducerWorkflowSpec.cxx src/AODMcProducerHelpers.cxx
-  PUBLIC_LINK_LIBRARIES internal::AODProducerWorkflow O2::Version
+  PUBLIC_LINK_LIBRARIES internal::AODProducerWorkflow O2::Version nlohmann_json::nlohmann_json
 )
 
 o2_add_executable(
@@ -75,7 +75,8 @@ o2_add_executable(
         O2::DataFormatsFT0
         O2::Steer
         O2::ZDCBase
-)
+        nlohmann_json::nlohmann_json
+        )
 
 if (OpenMP_CXX_FOUND)
   target_compile_definitions(${targetName} PRIVATE WITH_OPENMP)
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 105c0f60532d3..1cc89d54a030d 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -102,6 +102,8 @@
 #ifdef WITH_OPENMP
 #include <omp.h>
 #endif
+#include <filesystem>
+#include <nlohmann/json.hpp>
 
 using namespace o2::framework;
 using namespace o2::math_utils::detail;
@@ -1793,6 +1795,38 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
   }
 }
 
+namespace
+{
+void add_additional_meta_info(std::vector<TString>& keys, std::vector<TString>& values)
+{
+  // see if we should put additional meta info (e.g. from MC)
+  auto aod_external_meta_info_file = getenv("AOD_ADDITIONAL_METADATA_FILE");
+  if (aod_external_meta_info_file != nullptr) {
+    LOG(info) << "Trying to inject additional AOD meta-data from " << aod_external_meta_info_file;
+    if (std::filesystem::exists(aod_external_meta_info_file)) {
+      std::ifstream input_file(aod_external_meta_info_file);
+      if (input_file) {
+        nlohmann::json json_data;
+        try {
+          input_file >> json_data;
+        } catch (nlohmann::json::parse_error& e) {
+          std::cerr << "JSON Parse Error: " << e.what() << "\n";
+          std::cerr << "Exception ID: " << e.id << "\n";
+          std::cerr << "Byte position: " << e.byte << "\n";
+          return;
+        }
+        // If parsing succeeds, iterate over key-value pairs
+        for (const auto& [key, value] : json_data.items()) {
+          LOG(info) << "Adding AOD MetaData" << key << " : " << value;
+          keys.push_back(key.c_str());
+          values.push_back(value.get<std::string>());
+        }
+      }
+    }
+  }
+}
+} // namespace
+
 void AODProducerWorkflowDPL::run(ProcessingContext& pc)
 {
   mTimer.Start(false);
@@ -2401,6 +2435,8 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
   TString ROOTVersion = ROOT_RELEASE;
   mMetaDataKeys = {"DataType", "Run", "O2Version", "ROOTVersion", "RecoPassName", "AnchorProduction", "AnchorPassName", "LPMProductionTag", "CreatedBy"};
   mMetaDataVals = {dataType, "3", O2Version, ROOTVersion, mRecoPass, mAnchorProd, mAnchorPass, mLPMProdTag, mUser};
+  add_additional_meta_info(mMetaDataKeys, mMetaDataVals);
+
   pc.outputs().snapshot(Output{"AMD", "AODMetadataKeys", 0}, mMetaDataKeys);
   pc.outputs().snapshot(Output{"AMD", "AODMetadataVals", 0}, mMetaDataVals);
 

From cd40d12a1e5139f07d2e9302472fa6a89e934d4d Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 6 Jun 2025 20:25:02 +0200
Subject: [PATCH 0467/1764] ITS: buildSeeds check only once of b=0 (#14370)

---
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt  |   1 -
 .../ITS/tracking/include/ITStracking/Cell.h   |  84 +++++++--------
 .../tracking/include/ITStracking/Cluster.h    | 101 +++++++++---------
 .../ITS/tracking/include/ITStracking/Road.h   |  69 ++++--------
 .../include/ITStracking/TrackerTraits.h       |   5 +-
 .../tracking/include/ITStracking/Tracklet.h   |  17 ++-
 .../include/ITStracking/VertexerTraits.h      |   1 +
 Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx |  54 ++++------
 Detectors/ITSMFT/ITS/tracking/src/Road.cxx    |  18 ----
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |   5 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  61 ++++++-----
 .../ITSMFT/ITS/tracking/src/TrackingLinkDef.h |  12 ++-
 12 files changed, 182 insertions(+), 246 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/src/Road.cxx

diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index d6540cdeaf910..d3871b9e75d70 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -19,7 +19,6 @@ o2_add_library(ITStracking
                        src/TimeFrame.cxx
                        src/IOUtils.cxx
                        src/Label.cxx
-                       src/Road.cxx
                        src/Tracker.cxx
                        src/TrackerTraits.cxx
                        src/TrackingConfigParam.cxx
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index 9ed5daed447df..097499c05bd3b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -23,16 +23,27 @@
 
 #include "GPUCommonDef.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 class Cell final
 {
  public:
-  GPUhd() Cell();
-  GPUd() Cell(const int, const int, const int, const int, const int);
+  GPUhdDefault() Cell() = default;
+  GPUhd() Cell(const int firstClusterIndex, const int secondClusterIndex, const int thirdClusterIndex,
+               const int firstTrackletIndex, const int secondTrackletIndex)
+    : mFirstClusterIndex(firstClusterIndex),
+      mSecondClusterIndex(secondClusterIndex),
+      mThirdClusterIndex(thirdClusterIndex),
+      mFirstTrackletIndex(firstTrackletIndex),
+      mSecondTrackletIndex(secondTrackletIndex),
+      mLevel(1) {}
+  GPUhdDefault() Cell(const Cell&) = default;
+  GPUhdDefault() Cell(Cell&&) = default;
+  GPUhdDefault() ~Cell() = default;
+
+  GPUhdDefault() Cell& operator=(const Cell&) = default;
+  GPUhdDefault() Cell& operator=(Cell&&) noexcept = default;
 
   GPUhd() int getFirstClusterIndex() const { return mFirstClusterIndex; };
   GPUhd() int getSecondClusterIndex() const { return mSecondClusterIndex; };
@@ -44,44 +55,19 @@ class Cell final
   GPUhd() int* getLevelPtr() { return &mLevel; }
 
  private:
-  const int mFirstClusterIndex;
-  const int mSecondClusterIndex;
-  const int mThirdClusterIndex;
-  const int mFirstTrackletIndex;
-  const int mSecondTrackletIndex;
-  int mLevel;
+  int mFirstClusterIndex{0};
+  int mSecondClusterIndex{0};
+  int mThirdClusterIndex{0};
+  int mFirstTrackletIndex{0};
+  int mSecondTrackletIndex{0};
+  int mLevel{0};
 };
 
-GPUhdi() Cell::Cell()
-  : mFirstClusterIndex{0},
-    mSecondClusterIndex{0},
-    mThirdClusterIndex{0},
-    mFirstTrackletIndex{0},
-    mSecondTrackletIndex{0},
-    mLevel{0}
-{
-  // Nothing to do
-}
-
-GPUdi() Cell::Cell(const int firstClusterIndex, const int secondClusterIndex, const int thirdClusterIndex,
-                   const int firstTrackletIndex, const int secondTrackletIndex)
-  : mFirstClusterIndex{firstClusterIndex},
-    mSecondClusterIndex{secondClusterIndex},
-    mThirdClusterIndex{thirdClusterIndex},
-    mFirstTrackletIndex{firstTrackletIndex},
-    mSecondTrackletIndex{secondTrackletIndex},
-    mLevel{1}
-{
-  // Nothing to do
-}
-
 class CellSeed final : public o2::track::TrackParCovF
 {
  public:
   GPUhdDefault() CellSeed() = default;
-  GPUhdDefault() CellSeed(const CellSeed&) = default;
-  GPUhdDefault() ~CellSeed() = default;
-  GPUd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2) : o2::track::TrackParCovF{tpc}, mLevel{1}, mChi2{chi2}
+  GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2) : o2::track::TrackParCovF{tpc}, mLevel{1}, mChi2{chi2}
   {
     setUserField(innerL);
     mClusters[innerL + 0] = cl0;
@@ -90,6 +76,12 @@ class CellSeed final : public o2::track::TrackParCovF
     mTracklets[0] = trkl0;
     mTracklets[1] = trkl1;
   }
+  GPUhdDefault() CellSeed(const CellSeed&) = default;
+  GPUhdDefault() ~CellSeed() = default;
+  // GPUhdDefault() CellSeed(CellSeed&&) = default; TODO cannot use this yet since TrackPar only has device
+  GPUhdDefault() CellSeed& operator=(const CellSeed&) = default;
+  GPUhdDefault() CellSeed& operator=(CellSeed&&) = default;
+
   GPUhd() int getFirstClusterIndex() const { return mClusters[getUserField()]; };
   GPUhd() int getSecondClusterIndex() const { return mClusters[getUserField() + 1]; };
   GPUhd() int getThirdClusterIndex() const { return mClusters[getUserField() + 2]; };
@@ -104,20 +96,18 @@ class CellSeed final : public o2::track::TrackParCovF
   GPUhd() int* getLevelPtr() { return &mLevel; }
   GPUhd() int* getClusters() { return mClusters; }
   GPUhd() int getCluster(int i) const { return mClusters[i]; }
-  GPUhdi() void printCell() const;
+  GPUhd() void printCell() const
+  {
+    printf("trkl: %d, %d\t lvl: %d\t chi2: %f\n", mTracklets[0], mTracklets[1], mLevel, mChi2);
+  }
 
  private:
-  int mClusters[7] = {-1, -1, -1, -1, -1, -1, -1};
-  int mTracklets[2] = {-1, -1};
-  int mLevel = 0;
   float mChi2 = 0.f;
+  int mLevel = 0;
+  int mTracklets[2] = {-1, -1};
+  int mClusters[7] = {-1, -1, -1, -1, -1, -1, -1};
 };
 
-GPUhdi() void CellSeed::printCell() const
-{
-  printf("trkl: %d, %d\t lvl: %d\t chi2: %f\n", mTracklets[0], mTracklets[1], mLevel, mChi2);
-}
+} // namespace o2::its
 
-} // namespace its
-} // namespace o2
 #endif /* TRACKINGITSU_INCLUDE_CACELL_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
index 2bf1316470316..eaefbee5e2aaa 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
@@ -17,71 +17,74 @@
 #define TRACKINGITSU_INCLUDE_CACLUSTER_H_
 
 #include "GPUCommonRtypes.h"
-#include "ITStracking/Definitions.h"
-#include "ITStracking/MathUtils.h"
+#include "GPUCommonArray.h"
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <array>
-#endif
-
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 class IndexTableUtils;
 
 struct Cluster final {
-  Cluster() = default;
-  Cluster(const float x, const float y, const float z, const int idx);
-  Cluster(const int, const IndexTableUtils& utils, const Cluster&);
-  Cluster(const int, const float3&, const IndexTableUtils& utils, const Cluster&);
-  void Init(const int, const float3&, const IndexTableUtils& utils, const Cluster&);
-  bool operator==(const Cluster&) const;
+  GPUhdDefault() Cluster() = default;
+  GPUhd() Cluster(const float x, const float y, const float z, const int idx);
+  GPUhd() Cluster(const int, const IndexTableUtils& utils, const Cluster&);
+  GPUhd() Cluster(const int, const float3&, const IndexTableUtils& utils, const Cluster&);
+  GPUhdDefault() Cluster(const Cluster&) = default;
+  GPUhdDefault() Cluster(Cluster&&) noexcept = default;
+  GPUhdDefault() ~Cluster() = default;
+
+  GPUhdDefault() Cluster& operator=(const Cluster&) = default;
+  GPUhdDefault() Cluster& operator=(Cluster&&) noexcept = default;
+
+  // TODO
+  /*GPUhdDefault() bool operator==(const Cluster&) const = default;*/
+  GPUhd() bool operator==(const Cluster& other) const
+  {
+    return xCoordinate == other.xCoordinate &&
+           yCoordinate == other.yCoordinate &&
+           zCoordinate == other.zCoordinate &&
+           phi == other.phi &&
+           radius == other.radius &&
+           clusterId == other.clusterId &&
+           indexTableBinIndex == other.indexTableBinIndex;
+  }
+
   GPUhd() void print() const;
 
-  float xCoordinate;      // = -999.f;
-  float yCoordinate;      // = -999.f;
-  float zCoordinate;      // = -999.f;
-  float phi;              // = -999.f;
-  float radius;           // = -999.f;
-  int clusterId;          // = -1;
-  int indexTableBinIndex; // = -1;
+  float xCoordinate{-999.f};
+  float yCoordinate{-999.f};
+  float zCoordinate{-999.f};
+  float phi{-999.f};
+  float radius{-999.f};
+  int clusterId{-1};
+  int indexTableBinIndex{-1};
 
   ClassDefNV(Cluster, 1);
 };
 
-GPUhdi() void Cluster::print() const
-{
-#if !defined(GPUCA_GPUCODE_DEVICE) || (!defined(__OPENCL__) && defined(GPUCA_GPU_DEBUG_PRINT))
-  printf("Cluster: %f %f %f %f %f %d %d\n", xCoordinate, yCoordinate, zCoordinate, phi, radius, clusterId, indexTableBinIndex);
-#endif
-}
-
-struct TrackingFrameInfo {
-  TrackingFrameInfo() = default;
-  TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, std::array<float, 2>&& posTF, std::array<float, 3>&& covTF);
-
-  float xCoordinate;
-  float yCoordinate;
-  float zCoordinate;
-  float xTrackingFrame;
-  float alphaTrackingFrame;
+struct TrackingFrameInfo final {
+  GPUhdDefault() TrackingFrameInfo() = default;
+  GPUhd() TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, std::array<float, 2>&& posTF, std::array<float, 3>&& covTF);
+  GPUhdDefault() TrackingFrameInfo(const TrackingFrameInfo&) = default;
+  GPUhdDefault() TrackingFrameInfo(TrackingFrameInfo&&) noexcept = default;
+  GPUhdDefault() ~TrackingFrameInfo() = default;
+
+  GPUhdDefault() TrackingFrameInfo& operator=(const TrackingFrameInfo&) = default;
+  GPUhdDefault() TrackingFrameInfo& operator=(TrackingFrameInfo&&) = default;
+
+  GPUhd() void print() const;
+
+  float xCoordinate{-999.f};
+  float yCoordinate{-999.f};
+  float zCoordinate{-999.f};
+  float xTrackingFrame{-999.f};
+  float alphaTrackingFrame{-999.f};
   std::array<float, 2> positionTrackingFrame = {-1., -1.};
   std::array<float, 3> covarianceTrackingFrame = {999., 999., 999.};
-  GPUdi() void print() const
-  {
-#if !defined(GPUCA_GPUCODE_DEVICE) || (!defined(__OPENCL__) && defined(GPUCA_GPU_DEBUG_PRINT))
-    printf("x: %f y: %f z: %f xTF: %f alphaTF: %f posTF: %f %f covTF: %f %f %f\n",
-           xCoordinate, yCoordinate, zCoordinate, xTrackingFrame, alphaTrackingFrame,
-           positionTrackingFrame[0], positionTrackingFrame[1],
-           covarianceTrackingFrame[0], covarianceTrackingFrame[1], covarianceTrackingFrame[2]);
-#endif
-  }
 
   ClassDefNV(TrackingFrameInfo, 1);
 };
-} // namespace its
-} // namespace o2
+
+} // namespace o2::its
 
 #endif /* TRACKINGITSU_INCLUDE_CACLUSTER_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
index bc3786ba612b9..e9cd306e63bc5 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
@@ -16,32 +16,31 @@
 #ifndef TRACKINGCA_INCLUDE_ROAD_H
 #define TRACKINGCA_INCLUDE_ROAD_H
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <array>
-#endif
-
 #include "ITStracking/Constants.h"
 #include "GPUCommonDef.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 template <unsigned char maxRoadSize = 5>
 class Road final
 {
  public:
-  GPUhd() Road() : mCellIds{}, mRoadSize{}, mIsFakeRoad{} { resetRoad(); }
+  GPUhdDefault() Road() = default;
   GPUhd() Road(int cellLayer, int cellId) : Road() { addCell(cellLayer, cellId); }
 
-  GPUhd() int getRoadSize() const;
-  int getLabel() const;
-  void setLabel(const int);
-  GPUhd() bool isFakeRoad() const;
-  void setFakeRoad(const bool);
-  GPUhd() int& operator[](const int&);
-  GPUhd() int operator[](const int&) const;
+  GPUhdDefault() Road(const Road&) = default;
+  GPUhdDefault() Road(Road&&) noexcept = default;
+  GPUhdDefault() ~Road() = default;
+
+  GPUhdDefault() Road& operator=(const Road&) = default;
+  GPUhdDefault() Road& operator=(Road&&) noexcept = default;
+
+  GPUhdi() uint8_t getRoadSize() const { return mRoadSize; }
+  GPUhdi() bool isFakeRoad() const { return mIsFakeRoad; }
+  GPUhdi() void setFakeRoad(const bool fake) { mIsFakeRoad = fake; }
+  GPUhdi() int& operator[](const int& i) { return mCellIds[i]; }
+  GPUhdi() int operator[](const int& i) const { return mCellIds[i]; }
 
   GPUhd() void resetRoad()
   {
@@ -61,42 +60,12 @@ class Road final
   }
 
  private:
-  int mCellIds[maxRoadSize];
+  int mCellIds[maxRoadSize]{constants::its::UnusedIndex};
   // int mLabel;
-  unsigned char mRoadSize;
-  bool mIsFakeRoad;
+  unsigned char mRoadSize{0};
+  bool mIsFakeRoad{false};
 };
 
-template <unsigned char maxRoadSize>
-GPUhdi() int Road<maxRoadSize>::getRoadSize() const
-{
-  return mRoadSize;
-}
-
-template <unsigned char maxRoadSize>
-GPUhdi() int& Road<maxRoadSize>::operator[](const int& i)
-{
-  return mCellIds[i];
-}
+} // namespace o2::its
 
-template <unsigned char maxRoadSize>
-GPUhdi() int Road<maxRoadSize>::operator[](const int& i) const
-{
-  return mCellIds[i];
-}
-
-template <unsigned char maxRoadSize>
-GPUhdi() bool Road<maxRoadSize>::isFakeRoad() const
-{
-  return mIsFakeRoad;
-}
-
-template <unsigned char maxRoadSize>
-inline void Road<maxRoadSize>::setFakeRoad(const bool isFakeRoad)
-{
-  mIsFakeRoad = isFakeRoad;
-}
-} // namespace its
-} // namespace o2
-
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 22af80e544c86..5f4e40b92ba82 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -90,8 +90,6 @@ class TrackerTraits
   virtual int getTFNumberOfTracklets() const { return mTimeFrame->getNumberOfTracklets(); }
   virtual int getTFNumberOfCells() const { return mTimeFrame->getNumberOfCells(); }
 
-  float mBz = 5.f;
-
  private:
   track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3);
   bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0);
@@ -106,6 +104,9 @@ class TrackerTraits
   o2::gpu::GPUChainITS* mChain = nullptr;
   TimeFrame<nLayers>* mTimeFrame;
   std::vector<TrackingParameters> mTrkParams;
+
+  float mBz{-999.f};
+  bool mIsZeroField{false};
 };
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
index 92984c9755ed4..e0ae23c8bedde 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
@@ -13,11 +13,11 @@
 /// \brief
 ///
 
-#ifndef TRACKINGITSU_INCLUDE_TRACKLET_H_
-#define TRACKINGITSU_INCLUDE_TRACKLET_H_
+#ifndef TRACKINGITS_INCLUDE_TRACKLET_H_
+#define TRACKINGITS_INCLUDE_TRACKLET_H_
 
 #include "ITStracking/Cluster.h"
-#include <iostream>
+#include "GPUCommonRtypes.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonDef.h"
 
@@ -25,9 +25,7 @@
 #include <string>
 #endif
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
 struct Tracklet final {
@@ -59,6 +57,8 @@ struct Tracklet final {
   float tanLambda;
   float phi;
   short rof[2];
+
+  ClassDefNV(Tracklet, 1);
 };
 
 GPUhdi() Tracklet::Tracklet() : firstClusterIndex{-1}, secondClusterIndex{-1}, tanLambda{0.0f}, phi{0.0f}
@@ -136,7 +136,6 @@ GPUhdi() void Tracklet::dump() const
   printf("fClIdx: %d sClIdx: %d  rof1: %hu rof2: %hu\n", firstClusterIndex, secondClusterIndex, rof[0], rof[1]);
 }
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 
-#endif /* TRACKINGITSU_INCLUDE_TRACKLET_H_ */
+#endif /* TRACKINGITS_INCLUDE_TRACKLET_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index ae92fda292df3..1ec6adc9efab4 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -28,6 +28,7 @@
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Tracklet.h"
+#include "ITStracking/MathUtils.h"
 
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
index 1557c636e2345..beac55579656f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
@@ -12,19 +12,15 @@
 /// \file Cluster.cxx
 /// \brief
 ///
+#include "GPUCommonMath.h"
+#include "GPUCommonArray.h"
 
 #include "ITStracking/Cluster.h"
+#include "ITStracking/Definitions.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/IndexTableUtils.h"
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <array>
-#endif
-
-namespace o2
-{
-namespace its
-{
+using namespace o2::its;
 
 using math_utils::computePhi;
 using math_utils::getNormalizedPhi;
@@ -35,7 +31,7 @@ Cluster::Cluster(const float x, const float y, const float z, const int index)
     yCoordinate{y},
     zCoordinate{z},
     phi{getNormalizedPhi(computePhi(x, y))},
-    radius{hypot(x, y)},
+    radius{o2::gpu::GPUCommonMath::Hypot(x, y)},
     clusterId{index},
     indexTableBinIndex{0}
 {
@@ -47,7 +43,7 @@ Cluster::Cluster(const int layerIndex, const IndexTableUtils& utils, const Clust
     yCoordinate{other.yCoordinate},
     zCoordinate{other.zCoordinate},
     phi{getNormalizedPhi(computePhi(other.xCoordinate, other.yCoordinate))},
-    radius{hypot(other.xCoordinate, other.yCoordinate)},
+    radius{o2::gpu::GPUCommonMath::Hypot(other.xCoordinate, other.yCoordinate)},
     clusterId{other.clusterId},
     indexTableBinIndex{utils.getBinIndex(utils.getZBinIndex(layerIndex, zCoordinate),
                                          utils.getPhiBinIndex(phi))}
@@ -62,7 +58,7 @@ Cluster::Cluster(const int layerIndex, const float3& primaryVertex, const IndexT
     zCoordinate{other.zCoordinate},
     phi{getNormalizedPhi(
       computePhi(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y))},
-    radius{hypot(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y)},
+    radius{o2::gpu::GPUCommonMath::Hypot(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y)},
     clusterId{other.clusterId},
     indexTableBinIndex{utils.getBinIndex(utils.getZBinIndex(layerIndex, zCoordinate),
                                          utils.getPhiBinIndex(phi))}
@@ -70,28 +66,11 @@ Cluster::Cluster(const int layerIndex, const float3& primaryVertex, const IndexT
   // Nothing to do
 }
 
-void Cluster::Init(const int layerIndex, const float3& primaryVertex, const IndexTableUtils& utils, const Cluster& other)
+GPUhd() void Cluster::print() const
 {
-  xCoordinate = other.xCoordinate;
-  yCoordinate = other.yCoordinate;
-  zCoordinate = other.zCoordinate;
-  phi = getNormalizedPhi(
-    computePhi(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y));
-  radius = hypot(xCoordinate - primaryVertex.x, yCoordinate - primaryVertex.y);
-  clusterId = other.clusterId;
-  indexTableBinIndex = utils.getBinIndex(utils.getZBinIndex(layerIndex, zCoordinate),
-                                         utils.getPhiBinIndex(phi));
-}
-
-bool Cluster::operator==(const Cluster& rhs) const
-{
-  return this->xCoordinate == rhs.xCoordinate &&
-         this->yCoordinate == rhs.yCoordinate &&
-         this->zCoordinate == rhs.zCoordinate &&
-         this->phi == rhs.phi &&
-         this->radius == rhs.radius &&
-         this->clusterId == rhs.clusterId &&
-         this->indexTableBinIndex == rhs.indexTableBinIndex;
+#if !defined(GPUCA_GPUCODE_DEVICE) || (!defined(__OPENCL__) && defined(GPUCA_GPU_DEBUG_PRINT))
+  printf("Cluster: %f %f %f %f %f %d %d\n", xCoordinate, yCoordinate, zCoordinate, phi, radius, clusterId, indexTableBinIndex);
+#endif
 }
 
 TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, std::array<float, 2>&& posTF,
@@ -101,5 +80,12 @@ TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float
   // Nothing to do
 }
 
-} // namespace its
-} // namespace o2
+GPUhd() void TrackingFrameInfo::print() const
+{
+#if !defined(GPUCA_GPUCODE_DEVICE) || (!defined(__OPENCL__) && defined(GPUCA_GPU_DEBUG_PRINT))
+  printf("x: %f y: %f z: %f xTF: %f alphaTF: %f posTF: %f %f covTF: %f %f %f\n",
+         xCoordinate, yCoordinate, zCoordinate, xTrackingFrame, alphaTrackingFrame,
+         positionTrackingFrame[0], positionTrackingFrame[1],
+         covarianceTrackingFrame[0], covarianceTrackingFrame[1], covarianceTrackingFrame[2]);
+#endif
+}
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Road.cxx b/Detectors/ITSMFT/ITS/tracking/src/Road.cxx
deleted file mode 100644
index cb6cf47307398..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/src/Road.cxx
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "ITStracking/Road.h"
-namespace o2
-{
-namespace its
-{
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index eb7834da740d0..6dd11b2b659c7 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -14,6 +14,7 @@
 ///
 
 #include "ITStracking/TimeFrame.h"
+#include "ITStracking/MathUtils.h"
 #include "DataFormatsITSMFT/Cluster.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
@@ -34,13 +35,13 @@ struct ClusterHelper {
   int ind;
 };
 
-float MSangle(float mass, float p, float xX0)
+inline float MSangle(float mass, float p, float xX0)
 {
   float beta = p / o2::gpu::CAMath::Hypot(mass, p);
   return 0.0136f * o2::gpu::CAMath::Sqrt(xX0) * (1.f + 0.038f * o2::gpu::CAMath::Log(xX0)) / (beta * p);
 }
 
-float Sq(float v)
+inline float Sq(float v)
 {
   return v * v;
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index a66583f1b12f5..bdd8578e35d48 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -341,15 +341,15 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
                       mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
                       mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
                       mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
-                    const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer].at(clusId[0]);
-                    const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1].at(clusId[1]);
-                    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2).at(clusId[2]);
+                    const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer][clusId[0]];
+                    const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1][clusId[1]];
+                    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2)[clusId[2]];
                     auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
 
                     float chi2{0.f};
                     bool good{false};
                     for (int iC{2}; iC--;) {
-                      const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC).at(clusId[iC]);
+                      const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC)[clusId[iC]];
 
                       if (!track.rotate(trackingHit.alphaTrackingFrame)) {
                         break;
@@ -423,15 +423,15 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
                       mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
                       mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
                       mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
-                    const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer].at(clusId[0]);
-                    const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1].at(clusId[1]);
-                    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2).at(clusId[2]);
+                    const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer][clusId[0]];
+                    const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1][clusId[1]];
+                    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2)[clusId[2]];
                     auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
 
                     float chi2{0.f};
                     bool good{false};
                     for (int iC{2}; iC--;) {
-                      const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC).at(clusId[iC]);
+                      const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC)[clusId[iC]];
 
                       if (!track.rotate(trackingHit.alphaTrackingFrame)) {
                         break;
@@ -669,7 +669,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
             }
             /// Let's start the fitting procedure
             CellSeed seed{currentCell};
-            auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1).at(neighbourCell.getFirstClusterIndex());
+            auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
 
             if (!seed.rotate(trHit.alphaTrackingFrame)) {
               CA_DEBUGGER(failed[1]++);
@@ -739,7 +739,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
 
             auto seed = currentCell;
 
-            const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1).at(neighbourCell.getFirstClusterIndex());
+            const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
             if (!seed.rotate(trHit.alphaTrackingFrame) || !propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
               continue;
             }
@@ -1019,7 +1019,7 @@ void TrackerTraits<nLayers>::findShortPrimaries()
     auto pvs{mTimeFrame->getPrimaryVertices(rof)};
     auto pvsXAlpha{mTimeFrame->getPrimaryVerticesXAlpha(rof)};
 
-    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(2).at(cluster3_glo.clusterId);
+    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(2)[cluster3_glo.clusterId];
     TrackITSExt temporaryTrack{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
     temporaryTrack.setExternalClusterIndex(0, cluster1_glo.clusterId, true);
     temporaryTrack.setExternalClusterIndex(1, cluster2_glo.clusterId, true);
@@ -1085,7 +1085,7 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
     if (track.getClusterIndex(iLayer) == constants::its::UnusedIndex) {
       continue;
     }
-    const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer).at(track.getClusterIndex(iLayer));
+    const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer)[track.getClusterIndex(iLayer)];
 
     if (!track.rotate(trackingHit.alphaTrackingFrame)) {
       return false;
@@ -1189,7 +1189,7 @@ bool TrackerTraits<nLayers>::trackFollowing(TrackITSExt* track, int rof, bool ou
             continue;
           }
 
-          const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer).at(nextCluster.clusterId);
+          const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer)[nextCluster.clusterId];
 
           auto tbupdated{hypo};
           auto& tbuParams = outward ? tbupdated.getParamOut() : tbupdated.getParamIn();
@@ -1235,7 +1235,8 @@ bool TrackerTraits<nLayers>::trackFollowing(TrackITSExt* track, int rof, bool ou
 template <int nLayers>
 track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3)
 {
-  const float ca = o2::gpu::CAMath::Cos(tf3.alphaTrackingFrame), sa = o2::gpu::CAMath::Sin(tf3.alphaTrackingFrame);
+  float ca{-999.f}, sa{-999.f};
+  o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
   const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
   const float y1 = -cluster1.xCoordinate * sa + cluster1.yCoordinate * ca;
   const float z1 = cluster1.zCoordinate;
@@ -1245,29 +1246,27 @@ track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster
   const float x3 = tf3.xTrackingFrame;
   const float y3 = tf3.positionTrackingFrame[0];
   const float z3 = tf3.positionTrackingFrame[1];
-
-  const bool zeroField{std::abs(getBz()) < o2::constants::math::Almost0};
-  const float tgp = zeroField ? o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1) : 1.f;
-  const float crv = zeroField ? 1.f : math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
-  const float snp = zeroField ? tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp) : crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
-  const float tgl12 = math_utils::computeTanDipAngle(x1, y1, x2, y2, z1, z2);
-  const float tgl23 = math_utils::computeTanDipAngle(x2, y2, x3, y3, z2, z3);
-  const float q2pt = zeroField ? 1.f / o2::track::kMostProbablePt : crv / (getBz() * o2::constants::math::B2C);
-  const float q2pt2 = crv * crv;
-  const float sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005 ? (q2pt2 < 1 ? q2pt2 : 1) : 0.0005);
-  return track::TrackParCov(tf3.xTrackingFrame, tf3.alphaTrackingFrame,
-                            {y3, z3, snp, 0.5f * (tgl12 + tgl23), q2pt},
-                            {tf3.covarianceTrackingFrame[0],
-                             tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2],
-                             0.f, 0.f, track::kCSnp2max,
-                             0.f, 0.f, 0.f, track::kCTgl2max,
-                             0.f, 0.f, 0.f, 0.f, sg2q2pt});
+  float tgp{1.f}, crv{1.f}, snp{-999.f}, tgl12{-999.f}, tgl23{-999.f}, q2pt{1.f / track::kMostProbablePt}, q2pt2{1.f}, sg2q2pt{-999.f};
+  if (mIsZeroField) {
+    tgp = o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
+    snp = tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
+  } else {
+    crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
+    snp = crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
+    q2pt = crv / (mBz * o2::constants::math::B2C);
+    q2pt2 = crv * crv;
+  }
+  tgl12 = math_utils::computeTanDipAngle(x1, y1, x2, y2, z1, z2);
+  tgl23 = math_utils::computeTanDipAngle(x2, y2, x3, y3, z2, z3);
+  sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005f ? (q2pt2 < 1.f ? q2pt2 : 1.f) : 0.0005f);
+  return {tf3.xTrackingFrame, tf3.alphaTrackingFrame, {y3, z3, snp, 0.5f * (tgl12 + tgl23), q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
 }
 
 template <int nLayers>
 void TrackerTraits<nLayers>::setBz(float bz)
 {
   mBz = bz;
+  mIsZeroField = std::abs(mBz) < 0.01;
   mTimeFrame->setBz(bz);
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h b/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
index b06a4fd7d7d62..2fe70e96248f9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
@@ -15,13 +15,19 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class o2::its::ClusterLines + ;
 #pragma link C++ class o2::its::Tracklet + ;
-#pragma link C++ class o2::its::Line + ;
 #pragma link C++ class std::vector < o2::its::Tracklet> + ;
-#pragma link C++ class std::vector < o2::its::Line> + ;
+
 #pragma link C++ class o2::its::Cluster + ;
 #pragma link C++ class std::vector < o2::its::Cluster> + ;
+
+#pragma link C++ class o2::its::TrackingFrameInfo + ;
+#pragma link C++ class std::vector < o2::its::TrackingFrameInfo> + ;
+
+#pragma link C++ class o2::its::Line + ;
+#pragma link C++ class std::vector < o2::its::Line> + ;
+
+#pragma link C++ class o2::its::ClusterLines + ;
 #pragma link C++ class std::vector < o2::its::ClusterLines> + ;
 
 #pragma link C++ class o2::its::VertexerParamConfig + ;

From 7e04ea5acd4eaacecfd2dc8fd3a7fc3b27401dda Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 7 Jun 2025 08:07:21 +0200
Subject: [PATCH 0468/1764] Do not look for macros in hidden folders (#14374)

---
 cmake/O2GetListOfMacros.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/O2GetListOfMacros.cmake b/cmake/O2GetListOfMacros.cmake
index adadbe06af6fa..e7316d5076622 100644
--- a/cmake/O2GetListOfMacros.cmake
+++ b/cmake/O2GetListOfMacros.cmake
@@ -18,7 +18,7 @@ include_guard()
 function(o2_get_list_of_macros dir varname)
   file(GLOB_RECURSE listOfMacros RELATIVE ${CMAKE_SOURCE_DIR} ${dir}/*.C)
   # Case sensitive filtering of .C files (to avoid .c files on Mac)
-  list(FILTER listOfMacros INCLUDE REGEX "^.*\\.C$")
+  list(FILTER listOfMacros INCLUDE REGEX "^[^.].*\\.C$")
   # Remove macros that were copied to the build directory, to deal with
   # the (non-recommended-but-can-happen) case where the build directory
   # is a subdirectory of the source dir

From 8e0693280e134e41f0fe3d253bdda26b49831a80 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Fri, 6 Jun 2025 20:51:52 +0200
Subject: [PATCH 0469/1764] GPU: remove Road.cxx from standalone build

---
 GPU/GPUTracking/Standalone/CMakeLists.txt | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 8ce95c8e96d3a..0b37ce38b79f7 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -151,8 +151,7 @@ add_library(standalone_support SHARED
             ${O2_DIR}/Detectors/Base/src/MatLayerCylSet.cxx
             ${O2_DIR}/Detectors/Base/src/MatLayerCyl.cxx
             ${O2_DIR}/Detectors/Base/src/Ray.cxx
-            ${O2_DIR}/Detectors/Base/src/Propagator.cxx
-            ${O2_DIR}/Detectors/ITSMFT/ITS/tracking/src/Road.cxx)
+            ${O2_DIR}/Detectors/Base/src/Propagator.cxx)
 
 target_compile_definitions(standalone_support PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 target_include_directories(standalone_support PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,INCLUDE_DIRECTORIES>)

From c587bac190a5293bbffbb4581dc9e9a24c1ff9f9 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Tue, 10 Jun 2025 09:46:02 +0200
Subject: [PATCH 0470/1764] Use typed custom allocator for some thrust
 containers (#14371)

---
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  5 +-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  5 +-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 60 +++++++++++++++----
 .../include/ITStracking/ExternalAllocator.h   |  2 +-
 .../tracking/include/ITStracking/TimeFrame.h  | 29 +++++----
 GPU/GPUTracking/Global/GPUChainITS.cxx        |  2 +-
 6 files changed, 74 insertions(+), 29 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 54aa0e01c8a78..09c8c39725efa 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -19,6 +19,7 @@
 namespace o2::its
 {
 class CellSeed;
+class ExternalAllocator;
 namespace gpu
 {
 #ifdef GPUCA_GPUCODE // GPUg() global kernels must only when compiled by GPU compiler
@@ -178,7 +179,8 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
 
 int filterCellNeighboursHandler(gpuPair<int, int>*,
                                 int*,
-                                unsigned int);
+                                unsigned int,
+                                o2::its::ExternalAllocator* = nullptr);
 
 template <int nLayers = 7>
 void processNeighboursHandler(const int startLayer,
@@ -191,6 +193,7 @@ void processNeighboursHandler(const int startLayer,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
                               bounded_vector<CellSeed>& seedsHost,
+                              o2::its::ExternalAllocator*,
                               const float bz,
                               const float MaxChi2ClusterAttachment,
                               const float maxChi2NDF,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 871fd7a95f890..89d2b5aeffe63 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -18,6 +18,7 @@
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
 #include "ITStrackingGPU/TrackingKernels.h"
 #include "ITStracking/TrackingConfigParam.h"
+
 namespace o2::its
 {
 constexpr int UnusedIndex{-1};
@@ -209,7 +210,8 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
 
     filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                 mTimeFrameGPU->getDeviceNeighbours(iLayer),
-                                nNeigh);
+                                nNeigh,
+                                mTimeFrameGPU->getExternalAllocator());
   }
   mTimeFrameGPU->createNeighboursDeviceArray();
   mTimeFrameGPU->unregisterRest();
@@ -236,6 +238,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         mTimeFrameGPU->getDeviceNeighboursLUTs(),
                                         mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                                         trackSeeds,
+                                        mTimeFrameGPU->getExternalAllocator(),
                                         this->mBz,
                                         this->mTrkParams[0].MaxChi2ClusterAttachment,
                                         this->mTrkParams[0].MaxChi2NDF,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 301f37767c160..18c89d39adda0 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -28,6 +28,7 @@
 #include "ITStracking/Constants.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/MathUtils.h"
+#include "ITStracking/ExternalAllocator.h"
 #include "DataFormatsITS/TrackITS.h"
 #include "ReconstructionDataFormats/Vertex.h"
 
@@ -35,8 +36,6 @@
 #include "ITStrackingGPU/TrackingKernels.h"
 #include "ITStrackingGPU/Utils.h"
 
-#include "GPUCommonHelpers.h"
-
 #ifndef __HIPCC__
 #define THRUST_NAMESPACE thrust::cuda
 #else
@@ -64,6 +63,37 @@ GPUdii() float Sq(float v)
 namespace gpu
 {
 
+template <typename T>
+class TypedAllocator : public thrust::device_allocator<T>
+{
+ public:
+  using value_type = T;
+  using pointer = T*;
+
+  template <typename U>
+  struct rebind {
+    using other = TypedAllocator<U>;
+  };
+
+  explicit TypedAllocator(ExternalAllocator* allocPtr)
+    : mInternalAllocator(allocPtr) {}
+
+  T* allocate(size_t n)
+  {
+    return reinterpret_cast<T*>(mInternalAllocator->allocate(n * sizeof(T)));
+  }
+
+  void deallocate(T* p, size_t n)
+  {
+    char* raw_ptr = reinterpret_cast<char*>(p);
+    size_t bytes = n * sizeof(T);
+    mInternalAllocator->deallocate(raw_ptr, bytes); // redundant as internal dealloc is no-op.
+  }
+
+ private:
+  ExternalAllocator* mInternalAllocator;
+};
+
 GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
                               const o2::its::IndexTableUtils& utils,
                               const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
@@ -1117,7 +1147,8 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
 
 int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
                                 int* cellNeighbours,
-                                unsigned int nNeigh)
+                                unsigned int nNeigh,
+                                o2::its::ExternalAllocator* allocator)
 {
   thrust::device_ptr<gpuPair<int, int>> neighVectorPairs(cellNeighbourPairs);
   thrust::device_ptr<int> validNeighs(cellNeighbours);
@@ -1140,6 +1171,7 @@ void processNeighboursHandler(const int startLayer,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
                               bounded_vector<CellSeed>& seedsHost,
+                              o2::its::ExternalAllocator* allocator,
                               const float bz,
                               const float maxChi2ClusterAttachment,
                               const float maxChi2NDF,
@@ -1148,8 +1180,10 @@ void processNeighboursHandler(const int startLayer,
                               const int nBlocks,
                               const int nThreads)
 {
-  thrust::device_vector<int> foundSeedsTable(nCells[startLayer] + 1); // Shortcut: device_vector skips central memory management, we are relying on the contingency.
-                                                                      // TODO: fix this.
+  auto allocInt = gpu::TypedAllocator<int>(allocator);
+  auto allocCellSeed = gpu::TypedAllocator<CellSeed>(allocator);
+  thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt); // Shortcut: device_vector skips central memory management, we are relying on the contingency.
+                                                                                                             // TODO: fix this.
 
   gpu::processNeighboursKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
                                        o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
@@ -1172,8 +1206,8 @@ void processNeighboursHandler(const int startLayer,
     matCorrType);
   gpu::cubExclusiveScanInPlace(foundSeedsTable, nCells[startLayer] + 1);
 
-  thrust::device_vector<int> updatedCellId(foundSeedsTable.back());
-  thrust::device_vector<CellSeed> updatedCellSeed(foundSeedsTable.back());
+  thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
+  thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
   gpu::processNeighboursKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
                                         o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
     startLayer,
@@ -1195,13 +1229,13 @@ void processNeighboursHandler(const int startLayer,
     matCorrType);
 
   int level = startLevel;
-  thrust::device_vector<int> lastCellId;
-  thrust::device_vector<CellSeed> lastCellSeed;
+  thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
+  thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> lastCellSeed(allocCellSeed);
   for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
     lastCellSeed.swap(updatedCellSeed);
     lastCellId.swap(updatedCellId);
-    thrust::device_vector<CellSeed>().swap(updatedCellSeed);
-    thrust::device_vector<int>().swap(updatedCellId);
+    thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>>(allocCellSeed).swap(updatedCellSeed);
+    thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellId);
     auto lastCellSeedSize{lastCellSeed.size()};
     foundSeedsTable.resize(lastCellSeedSize + 1);
     thrust::fill(foundSeedsTable.begin(), foundSeedsTable.end(), 0);
@@ -1253,8 +1287,7 @@ void processNeighboursHandler(const int startLayer,
       propagator,
       matCorrType);
   }
-
-  thrust::device_vector<CellSeed> outSeeds(updatedCellSeed.size());
+  thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> outSeeds(updatedCellSeed.size(), allocCellSeed);
   auto end = thrust::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
   auto s{end - outSeeds.begin()};
   seedsHost.reserve(seedsHost.size() + s);
@@ -1367,6 +1400,7 @@ template void processNeighboursHandler<7>(const int startLayer,
                                           gsl::span<int*> neighboursDeviceLUTs,
                                           const TrackingFrameInfo** foundTrackingFrameInfo,
                                           bounded_vector<CellSeed>& seedsHost,
+                                          o2::its::ExternalAllocator*,
                                           const float bz,
                                           const float maxChi2ClusterAttachment,
                                           const float maxChi2NDF,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
index 9bdb2905ba9ba..1628bbc52776b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
@@ -23,8 +23,8 @@ class ExternalAllocator
 {
  public:
   virtual void* allocate(size_t) = 0;
+  virtual void deallocate(char*, size_t) = 0;
 };
-
 } // namespace o2::its
 
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index f6bb9a9b11e66..c3eb25f8d0699 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -230,7 +230,23 @@ struct TimeFrame {
   void setBz(float bz) { mBz = bz; }
   float getBz() const { return mBz; }
 
-  virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>*) { return; }
+  void setExternalAllocator(ExternalAllocator* allocator)
+  {
+    if (mIsGPU) {
+      LOGP(debug, "Setting timeFrame allocator to external");
+      mAllocator = allocator;
+      mExtAllocator = true; // to be removed
+    } else {
+      LOGP(fatal, "External allocator is currently only supported for GPU");
+    }
+  }
+
+  ExternalAllocator* getExternalAllocator() { return mAllocator; }
+
+  virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>*)
+  {
+    return;
+  };
   const o2::base::PropagatorImpl<float>* getDevicePropagator() const { return mPropagatorDevice; }
 
   template <typename... T>
@@ -277,17 +293,6 @@ struct TimeFrame {
   // State if memory will be externally managed.
   bool mExtAllocator = false;
   ExternalAllocator* mAllocator = nullptr;
-  void setExternalAllocator(ExternalAllocator* allocator)
-  {
-    if (mIsGPU) {
-      LOGP(debug, "Setting timeFrame allocator to external");
-      mAllocator = allocator;
-      mExtAllocator = true; // to be removed
-    } else {
-      LOGP(fatal, "External allocator is currently only supported for GPU");
-    }
-  }
-  void setExtAllocator(bool ext) { mExtAllocator = ext; }
   bool getExtAllocator() const { return mExtAllocator; }
 
   std::array<bounded_vector<Cluster>, nLayers> mUnsortedClusters;
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index bcb99fff87a64..cbc19100fe4fa 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -30,7 +30,7 @@ class GPUFrameworkExternalAllocator final : public o2::its::ExternalAllocator
   {
     return mFWReco->AllocateDirectMemory(size, GPUMemoryResource::MEMORY_GPU);
   }
-
+  void deallocate(char* ptr, size_t) override {}
   void setReconstructionFramework(o2::gpu::GPUReconstruction* fwr) { mFWReco = fwr; }
 
  private:

From 3d2a03c131a498addd742a957ae376d622f11a44 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 10 Jun 2025 10:22:19 +0200
Subject: [PATCH 0471/1764] ITS: fix Cell reorder

---
 Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index 097499c05bd3b..fc3656aef800c 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -67,7 +67,7 @@ class CellSeed final : public o2::track::TrackParCovF
 {
  public:
   GPUhdDefault() CellSeed() = default;
-  GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2) : o2::track::TrackParCovF{tpc}, mLevel{1}, mChi2{chi2}
+  GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2) : o2::track::TrackParCovF(tpc), mChi2(chi2), mLevel(1)
   {
     setUserField(innerL);
     mClusters[innerL + 0] = cl0;

From fdab6dbdadf7b90707ebfbd5c99c932c97fc0f90 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 10 Jun 2025 13:06:55 +0200
Subject: [PATCH 0472/1764] ITS: make clang-tidy happy (#14372)

* ITS: selective clang-tidy finds

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: IOUtils remove obsolte functions

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../tracking/include/ITStracking/IOUtils.h    |   4 -
 .../tracking/include/ITStracking/TimeFrame.h  |   4 +-
 .../tracking/include/ITStracking/Tracker.h    |   6 +-
 .../tracking/include/ITStracking/Vertexer.h   |   2 +-
 .../include/ITStracking/VertexerTraits.h      |   6 +-
 Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx |   1 -
 Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx | 123 ++----------------
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |  20 ++-
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  14 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |   6 +-
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      |   1 -
 .../ITS/tracking/src/VertexerTraits.cxx       |  14 +-
 12 files changed, 49 insertions(+), 152 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h
index 57cc44291ba09..0ada9dfbc6188 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h
@@ -72,10 +72,6 @@ inline static const o2::itsmft::ChipMappingITS& getChipMappingITS()
   return MP;
 }
 
-std::vector<std::unordered_map<int, Label>> loadLabels(const int, const std::string&);
-void writeRoadsReport(std::ofstream&, std::ofstream&, std::ofstream&, const std::vector<std::vector<Road<5>>>&,
-                      const std::unordered_map<int, Label>&);
-
 template <class iterator, typename T>
 o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, iterator& iter, const itsmft::TopologyDictionary* dict, T& sig2y, T& sig2z)
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index c3eb25f8d0699..1620350c68034 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -333,8 +333,8 @@ struct TimeFrame {
   bounded_vector<int> mBogusClusters; /// keep track of clusters with wild coordinates
 
   bounded_vector<std::pair<unsigned long long, bool>> mRoadLabels;
-  int mCutClusterMult;
-  int mCutVertexMult;
+  int mCutClusterMult{-999};
+  int mCutVertexMult{-999};
 
   // Vertexer
   std::vector<bounded_vector<int>> mNTrackletsPerROF;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index d8236fed51240..b393d743809fd 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -63,8 +63,8 @@ class Tracker
   void adoptTimeFrame(TimeFrame<NLayers>& tf);
 
   void clustersToTracks(
-    LogFunc = [](const std::string& s) { std::cout << s << '\n'; },
-    LogFunc = [](const std::string& s) { std::cerr << s << '\n'; });
+    const LogFunc& = [](const std::string& s) { std::cout << s << '\n'; },
+    const LogFunc& = [](const std::string& s) { std::cerr << s << '\n'; });
 
   void setParameters(const std::vector<TrackingParameters>& p) { mTrkParams = p; }
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
@@ -113,7 +113,7 @@ class Tracker
     Roading,
     NStates,
   };
-  State mCurState;
+  State mCurState{TFInit};
   static constexpr std::array<const char*, NStates> StateNames{"TimeFrame initialisation", "Tracklet finding", "Cell finding", "Neighbour finding", "Road finding"};
 };
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 07d9d60243a95..63dd41b4a0a8f 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -106,7 +106,7 @@ class Vertexer
     Finding,
     NStates,
   };
-  State mCurState;
+  State mCurState{Init};
   static constexpr std::array<const char*, NStates> StateNames{"Initialisation", "Tracklet finding", "Tracklet validation", "Vertex finding"};
 };
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 1ec6adc9efab4..e4ecced6d67fb 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -86,9 +86,9 @@ class VertexerTraits
                             bounded_vector<o2::MCCompLabel>*,
                             const int iteration = 0);
 
-  const bounded_vector<std::pair<int, int>> selectClusters(const int* indexTable,
-                                                           const std::array<int, 4>& selectedBinsRect,
-                                                           const IndexTableUtils& utils);
+  bounded_vector<std::pair<int, int>> selectClusters(const int* indexTable,
+                                                     const std::array<int, 4>& selectedBinsRect,
+                                                     const IndexTableUtils& utils);
 
   // utils
   auto& getVertexingParameters() { return mVrtParams; }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
index beac55579656f..78f6683675947 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
@@ -24,7 +24,6 @@ using namespace o2::its;
 
 using math_utils::computePhi;
 using math_utils::getNormalizedPhi;
-using math_utils::hypot;
 
 Cluster::Cluster(const float x, const float y, const float z, const int index)
   : xCoordinate{x},
diff --git a/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx b/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
index 152d4e1be7d04..2638b437d61f8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
@@ -15,12 +15,15 @@
 
 #include "ITStracking/IOUtils.h"
 
+#include <gsl/span>
+#include <vector>
+#include <array>
+#include <string>
 #include <iostream>
 #include <cstdlib>
 #include <fstream>
 #include <sstream>
 #include <tuple>
-#include <unordered_set>
 #include <utility>
 
 #include "ITSBase/GeometryTGeo.h"
@@ -35,10 +38,7 @@ constexpr int PrimaryVertexLayerId{-1};
 constexpr int EventLabelsSeparator{-1};
 } // namespace
 
-namespace o2
-{
-namespace its
-{
+using namespace o2::its;
 
 /// convert compact clusters to 3D spacepoints
 void ioutils::convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
@@ -57,8 +57,8 @@ void ioutils::convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clu
     }
   }
 
-  for (auto& c : clusters) {
-    float sigmaY2, sigmaZ2, sigmaYZ = 0;
+  for (const auto& c : clusters) {
+    float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
     auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2);
     auto& cl3d = output.emplace_back(c.getSensorID(), geom->getMatrixT2L(c.getSensorID()) ^ locXYZ); // local --> tracking
     if (applyMisalignment) {
@@ -83,9 +83,9 @@ void ioutils::loadEventData(ROframe& event, gsl::span<const itsmft::CompClusterE
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
   int clusterId{0};
 
-  for (auto& c : clusters) {
-    int layer = geom->getLayer(c.getSensorID());
-    float sigmaY2, sigmaZ2, sigmaYZ = 0;
+  for (const auto& c : clusters) {
+    const int layer = geom->getLayer(c.getSensorID());
+    float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
     auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2);
     auto sensorID = c.getSensorID();
     // Inverse transformation to the local --> tracking
@@ -118,9 +118,9 @@ int ioutils::loadROFrameData(const o2::itsmft::ROFRecord& rof, ROframe& event, g
 
   auto first = rof.getFirstEntry();
   auto clusters_in_frame = rof.getROFData(clusters);
-  for (auto& c : clusters_in_frame) {
-    int layer = geom->getLayer(c.getSensorID());
-    float sigmaY2, sigmaZ2, sigmaYZ = 0;
+  for (const auto& c : clusters_in_frame) {
+    const int layer = geom->getLayer(c.getSensorID());
+    float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
     auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2);
     auto sensorID = c.getSensorID();
     // Inverse transformation to the local --> tracking
@@ -141,100 +141,5 @@ int ioutils::loadROFrameData(const o2::itsmft::ROFRecord& rof, ROframe& event, g
     event.addClusterExternalIndexToLayer(layer, first + clusterId);
     clusterId++;
   }
-  return clusters_in_frame.size();
+  return (int)clusters_in_frame.size();
 }
-
-std::vector<std::unordered_map<int, Label>> ioutils::loadLabels(const int eventsNum, const std::string& fileName)
-{
-  std::vector<std::unordered_map<int, Label>> labelsMap{};
-  std::unordered_map<int, Label> currentEventLabelsMap{};
-  std::ifstream inputStream{};
-  std::string line{};
-  int monteCarloId{}, pdgCode{}, numberOfClusters{};
-  float transverseMomentum{}, phi{}, pseudorapidity{};
-
-  labelsMap.reserve(eventsNum);
-
-  inputStream.open(fileName);
-  std::getline(inputStream, line);
-
-  while (std::getline(inputStream, line)) {
-
-    std::istringstream inputStringStream(line);
-
-    if (inputStringStream >> monteCarloId) {
-
-      if (monteCarloId == EventLabelsSeparator) {
-
-        labelsMap.emplace_back(currentEventLabelsMap);
-        currentEventLabelsMap.clear();
-
-      } else {
-
-        if (inputStringStream >> transverseMomentum >> phi >> pseudorapidity >> pdgCode >> numberOfClusters) {
-
-          if (std::abs(pdgCode) == constants::pdgcodes::PionCode && numberOfClusters == 7) {
-
-            currentEventLabelsMap.emplace(std::piecewise_construct, std::forward_as_tuple(monteCarloId),
-                                          std::forward_as_tuple(monteCarloId, transverseMomentum, phi,
-                                                                pseudorapidity, pdgCode, numberOfClusters));
-          }
-        }
-      }
-    }
-  }
-
-  labelsMap.emplace_back(currentEventLabelsMap);
-
-  return labelsMap;
-}
-
-// void ioutils::writeRoadsReport(std::ofstream& correctRoadsOutputStream, std::ofstream& duplicateRoadsOutputStream,
-//                                std::ofstream& fakeRoadsOutputStream, const std::vector<std::vector<Road<5>>>& roads,
-//                                const std::unordered_map<int, Label>& labelsMap)
-// {
-//   const int numVertices{static_cast<int>(roads.size())};
-//   std::unordered_set<int> foundMonteCarloIds{};
-
-//   correctRoadsOutputStream << EventLabelsSeparator << std::endl;
-//   fakeRoadsOutputStream << EventLabelsSeparator << std::endl;
-
-//   for (int iVertex{0}; iVertex < numVertices; ++iVertex) {
-
-//     const std::vector<Road<5>>& currentVertexRoads{roads[iVertex]};
-//     const int numRoads{static_cast<int>(currentVertexRoads.size())};
-
-//     for (int iRoad{0}; iRoad < numRoads; ++iRoad) {
-
-//       const Road<5>& currentRoad{currentVertexRoads[iRoad]};
-//       const int currentRoadLabel{currentRoad.getLabel()};
-
-//       if (!labelsMap.count(currentRoadLabel)) {
-
-//         continue;
-//       }
-
-//       const Label& currentLabel{labelsMap.at(currentRoadLabel)};
-
-//       if (currentRoad.isFakeRoad()) {
-
-//         fakeRoadsOutputStream << currentLabel << std::endl;
-
-//       } else {
-
-//         if (foundMonteCarloIds.count(currentLabel.monteCarloId)) {
-
-//           duplicateRoadsOutputStream << currentLabel << std::endl;
-
-//         } else {
-
-//           correctRoadsOutputStream << currentLabel << std::endl;
-//           foundMonteCarloIds.emplace(currentLabel.monteCarloId);
-//         }
-//       }
-//     }
-//   }
-// }
-
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 6dd11b2b659c7..34d8967c6a5bb 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -74,7 +74,7 @@ void TimeFrame<nLayers>::addPrimaryVertices(const bounded_vector<Vertex>& vertic
   for (const auto& vertex : vertices) {
     mPrimaryVertices.emplace_back(vertex);
     if (!isBeamPositionOverridden) {
-      const int w{vertex.getNContributors()};
+      const float w = vertex.getNContributors();
       mBeamPos[0] = (mBeamPos[0] * mBeamPosWeight + vertex.getX() * w) / (mBeamPosWeight + w);
       mBeamPos[1] = (mBeamPos[1] * mBeamPosWeight + vertex.getY() * w) / (mBeamPosWeight + w);
       mBeamPosWeight += w;
@@ -126,7 +126,7 @@ void TimeFrame<nLayers>::addPrimaryVertices(const gsl::span<const Vertex>& verti
     mPrimaryVertices.emplace_back(vertex); // put a copy in the present
     mTotVertPerIteration[iteration]++;
     if (!isBeamPositionOverridden) { // beam position is updated only at first occurrence of the vertex. A bit sketchy if we have past/future vertices, it should not impact too much.
-      const int w{vertex.getNContributors()};
+      const float w = vertex.getNContributors();
       mBeamPos[0] = (mBeamPos[0] * mBeamPosWeight + vertex.getX() * w) / (mBeamPosWeight + w);
       mBeamPos[1] = (mBeamPos[1] * mBeamPosWeight + vertex.getY() * w) / (mBeamPosWeight + w);
       mBeamPosWeight += w;
@@ -166,7 +166,7 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
   clearResizeBoundedVector(mClusterSize, clusters.size(), mMemoryPool.get());
   for (auto& rof : rofs) {
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {
-      auto& c = clusters[clusterId];
+      const auto& c = clusters[clusterId];
 
       int layer = geom->getLayer(c.getSensorID());
 
@@ -280,7 +280,7 @@ void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, con
         c.radius = h.r;
         c.indexTableBinIndex = h.bin;
       }
-      for (unsigned int iB{0}; iB < clsPerBin.size(); ++iB) {
+      for (int iB{0}; iB < (int)clsPerBin.size(); ++iB) {
         mIndexTables[iLayer][rof * (trkParam.ZBins * trkParam.PhiBins + 1) + iB] = lutPerBin[iB];
       }
       for (auto iB{clsPerBin.size()}; iB < (trkParam.ZBins * trkParam.PhiBins + 1); iB++) {
@@ -374,7 +374,7 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
       const float cosTheta1half = o2::gpu::CAMath::Sqrt(1.f - Sq(0.5f * r1 * oneOverR));
       const float cosTheta2half = o2::gpu::CAMath::Sqrt(1.f - Sq(0.5f * r2 * oneOverR));
       float x = r2 * cosTheta1half - r1 * cosTheta2half;
-      float delta = o2::gpu::CAMath::Sqrt(1. / (1.f - 0.25f * Sq(x * oneOverR)) * (Sq(0.25f * r1 * r2 * Sq(oneOverR) / cosTheta2half + cosTheta1half) * Sq(res1) + Sq(0.25f * r1 * r2 * Sq(oneOverR) / cosTheta1half + cosTheta2half) * Sq(res2)));
+      float delta = o2::gpu::CAMath::Sqrt(1.f / (1.f - 0.25f * Sq(x * oneOverR)) * (Sq(0.25f * r1 * r2 * Sq(oneOverR) / cosTheta2half + cosTheta1half) * Sq(res1) + Sq(0.25f * r1 * r2 * Sq(oneOverR) / cosTheta1half + cosTheta2half) * Sq(res2)));
       mPhiCuts[iLayer] = std::min(o2::gpu::CAMath::ASin(0.5f * x * oneOverR) + 2.f * mMSangles[iLayer] + delta, constants::math::Pi * 0.5f);
     }
   }
@@ -401,13 +401,13 @@ template <int nLayers>
 unsigned long TimeFrame<nLayers>::getArtefactsMemory() const
 {
   unsigned long size{0};
-  for (auto& trkl : mTracklets) {
+  for (const auto& trkl : mTracklets) {
     size += sizeof(Tracklet) * trkl.size();
   }
-  for (auto& cells : mCells) {
+  for (const auto& cells : mCells) {
     size += sizeof(CellSeed) * cells.size();
   }
-  for (auto& cellsN : mCellsNeighbours) {
+  for (const auto& cellsN : mCellsNeighbours) {
     size += sizeof(int) * cellsN.size();
   }
   return size + sizeof(Road<nLayers - 2>) * mRoads.size();
@@ -422,9 +422,7 @@ void TimeFrame<nLayers>::printArtefactsMemory() const
 template <int nLayers>
 void TimeFrame<nLayers>::fillPrimaryVerticesXandAlpha()
 {
-  if (mPValphaX.size()) {
-    mPValphaX.clear();
-  }
+  deepVectorClear(mPValphaX);
   mPValphaX.reserve(mPrimaryVertices.size());
   for (auto& pv : mPrimaryVertices) {
     mPValphaX.emplace_back(std::array<float, 2>{o2::gpu::CAMath::Hypot(pv.getX(), pv.getY()), math_utils::computePhi(pv.getX(), pv.getY())});
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 5565026ab11cf..75c265dbdb703 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -41,7 +41,7 @@ Tracker::Tracker(TrackerTraits7* traits) : mTraits(traits)
   mTrkParams.resize(1);
 }
 
-void Tracker::clustersToTracks(LogFunc logger, LogFunc error)
+void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
 {
   LogFunc evalLog = [](const std::string&) {};
 
@@ -195,7 +195,7 @@ void Tracker::computeRoadsMClabels()
         bool found{false};
         for (size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
           std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
-          for (auto& label : cl0labs) {
+          for (const auto& label : cl0labs) {
             if (label == occurrence.first) {
               ++occurrence.second;
               found = true;
@@ -204,7 +204,7 @@ void Tracker::computeRoadsMClabels()
           }
         }
         if (!found) {
-          for (auto& label : cl0labs) {
+          for (const auto& label : cl0labs) {
             occurrences.emplace_back(label, 1);
           }
         }
@@ -277,7 +277,7 @@ void Tracker::computeTracksMClabels()
         bool found{false};
         for (size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
           std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
-          for (auto& label : labels) {
+          for (const auto& label : labels) {
             if (label == occurrence.first) {
               ++occurrence.second;
               found = true;
@@ -286,7 +286,7 @@ void Tracker::computeTracksMClabels()
           }
         }
         if (!found) {
-          for (auto& label : labels) {
+          for (const auto& label : labels) {
             occurrences.emplace_back(label, 1);
           }
         }
@@ -302,7 +302,7 @@ void Tracker::computeTracksMClabels()
         auto clid = track.getClusterIndex(ic);
         if (clid != constants::its::UnusedIndex) {
           auto labelsSpan = mTimeFrame->getClusterLabels(ic, clid);
-          for (auto& currentLabel : labelsSpan) {
+          for (const auto& currentLabel : labelsSpan) {
             if (currentLabel == maxOccurrencesValue) {
               pattern |= 0x1 << (16 + ic); // set bit if correct
               break;
@@ -335,7 +335,7 @@ void Tracker::rectifyClusterIndices()
 
 void Tracker::getGlobalConfiguration()
 {
-  auto& tc = o2::its::TrackerParamConfig::Instance();
+  const auto& tc = o2::its::TrackerParamConfig::Instance();
   if (tc.useMatCorrTGeo) {
     mTraits->setCorrType(o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrTGeo);
   } else if (tc.useFastMaterial) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index bdd8578e35d48..766dc25cd6d8e 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -101,7 +101,7 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
               const float inverseR0{1.f / currentCluster.radius};
 
               for (int iV{startVtx}; iV < endVtx; ++iV) {
-                auto& primaryVertex{primaryVertices[iV]};
+                const auto& primaryVertex{primaryVertices[iV]};
                 if (primaryVertex.isFlagSet(2) && iteration != 3) {
                   continue;
                 }
@@ -830,8 +830,8 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
     mTaskArena.execute([&] {
       bounded_vector<int> perSeedCount(trackSeeds.size() + 1, 0, mMemoryPool.get());
       tbb::parallel_for(
-        tbb::blocked_range<size_t>(size_t(0), trackSeeds.size()),
-        [&](const tbb::blocked_range<size_t>& Seeds) {
+        tbb::blocked_range<int>(0, (int)trackSeeds.size()),
+        [&](const tbb::blocked_range<int>& Seeds) {
           for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
             const CellSeed& seed{trackSeeds[iSeed]};
             TrackITSExt temporaryTrack{seed};
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 8ab8c1a9e2e3c..a1a1a90da8963 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -125,7 +125,6 @@ void Vertexer::printEpilog(LogFunc& logger,
                            const unsigned selectedN, const unsigned int vertexN, const float initT,
                            const float trackletT, const float selecT, const float vertexT)
 {
-  float total = initT + trackletT + selecT + vertexT;
   logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
   logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {} ms", mTraits->getName(), selectedN, selecT));
   logger(fmt::format(" - {} Vertexer: found {} vertices in: {} ms", mTraits->getName(), vertexN, vertexT));
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 6fd3d99ffe58d..fe1619efaa192 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -146,9 +146,9 @@ void trackletSelectionKernelHost(
   }
 }
 
-const bounded_vector<std::pair<int, int>> VertexerTraits::selectClusters(const int* indexTable,
-                                                                         const std::array<int, 4>& selectedBinsRect,
-                                                                         const IndexTableUtils& utils)
+bounded_vector<std::pair<int, int>> VertexerTraits::selectClusters(const int* indexTable,
+                                                                   const std::array<int, 4>& selectedBinsRect,
+                                                                   const IndexTableUtils& utils)
 {
   bounded_vector<std::pair<int, int>> filteredBins{mMemoryPool.get()};
   int phiBinsNum{selectedBinsRect[3] - selectedBinsRect[1] + 1};
@@ -270,12 +270,12 @@ void VertexerTraits::computeTracklets(const int iteration)
 
   /// Create tracklets labels for L0-L1, information is as flat as in tracklets vector (no rofId)
   if (mTimeFrame->hasMCinformation()) {
-    for (auto& trk : mTimeFrame->getTracklets()[0]) {
+    for (const auto& trk : mTimeFrame->getTracklets()[0]) {
       o2::MCCompLabel label;
       int sortedId0{mTimeFrame->getSortedIndex(trk.rof[0], 0, trk.firstClusterIndex)};
       int sortedId1{mTimeFrame->getSortedIndex(trk.rof[1], 1, trk.secondClusterIndex)};
-      for (auto& lab0 : mTimeFrame->getClusterLabels(0, mTimeFrame->getClusters()[0][sortedId0].clusterId)) {
-        for (auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
+      for (const auto& lab0 : mTimeFrame->getClusterLabels(0, mTimeFrame->getClusters()[0][sortedId0].clusterId)) {
+        for (const auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
           if (lab0 == lab1 && lab0.isValid()) {
             label = lab0;
             break;
@@ -544,7 +544,7 @@ void VertexerTraits::computeVertices(const int iteration)
         mTimeFrame->addPrimaryVerticesLabelsInROF(polls, rofId);
       }
     }
-    if (!vertices.size() && !(iteration && (int)mTimeFrame->getPrimaryVertices(rofId).size() > mVrtParams[iteration].vertPerRofThreshold)) {
+    if (vertices.empty() && !(iteration && (int)mTimeFrame->getPrimaryVertices(rofId).size() > mVrtParams[iteration].vertPerRofThreshold)) {
       mTimeFrame->getNoVertexROF()++;
     }
   }

From 69bdaa0fc1857aa177529ca4f6c87ba46888e034 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 6 Jun 2025 17:33:26 +0200
Subject: [PATCH 0473/1764] Standalone CI build must fail with errors

---
 GPU/GPUTracking/Standalone/cmake/build.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/Standalone/cmake/build.sh b/GPU/GPUTracking/Standalone/cmake/build.sh
index d2e4ae08c1575..9fe650fd30905 100755
--- a/GPU/GPUTracking/Standalone/cmake/build.sh
+++ b/GPU/GPUTracking/Standalone/cmake/build.sh
@@ -3,6 +3,7 @@ if [[ -z $1 ]]; then
   echo "Please provide Sourcedir as command line argument"
   exit 1
 fi
+set -e
 mkdir -p standalone/build
 pushd standalone/build
 cp $1/GPU/GPUTracking/Standalone/cmake/config.cmake .

From 84e43136cbd915d903e8ce276bb7dfb8631ca1e1 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 10 Jun 2025 18:02:19 +0200
Subject: [PATCH 0474/1764] Fix abuse of o2::framework::Output (#14384)

This prevents support for std::pmr, because it implies movable outputs (which are not).

Use the ConcreteDataTypeMatcher instead, which represents a query (matcher) on the data.
---
 Detectors/TPC/workflow/src/TrackReaderWorkflow.cxx |  4 ++--
 Detectors/TPC/workflow/src/tpc-reco-workflow.cxx   | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Detectors/TPC/workflow/src/TrackReaderWorkflow.cxx b/Detectors/TPC/workflow/src/TrackReaderWorkflow.cxx
index b51fba091b190..b5f1db99cfc5a 100644
--- a/Detectors/TPC/workflow/src/TrackReaderWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/TrackReaderWorkflow.cxx
@@ -36,7 +36,7 @@
 
 // we need a global variable to propagate the type the message dispatching of the
 // publisher will trigger on. This is dependent on the input type
-o2::framework::Output gDispatchTrigger{"", ""};
+o2::framework::ConcreteDataTypeMatcher gDispatchTrigger{"", ""};
 
 void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
 {
@@ -96,7 +96,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     // nothing to do we leave the matcher empty which will suppress the dispatch
     // trigger and all messages will be sent out together at end of computation
   } else if (inputType == "tracks") {
-    gDispatchTrigger = o2::framework::Output{"TPC", "TRACKS"};
+    gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "TRACKS"};
   }
 
   bool doMC = not cfgc.options().get<bool>("disable-mc");
diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index 4d364e74bb620..9d7ab63b0c2a0 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -39,7 +39,7 @@
 
 // we need a global variable to propagate the type the message dispatching of the
 // publisher will trigger on. This is dependent on the input type
-static o2::framework::Output gDispatchTrigger{"", ""};
+static o2::framework::ConcreteDataTypeMatcher gDispatchTrigger{"", ""};
 
 // Global variable used to transport data to the completion policy
 static o2::tpc::reco_workflow::CompletionPolicyData gPolicyData;
@@ -152,13 +152,13 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     // nothing to do we leave the matcher empty which will suppress the dispatch
     // trigger and all messages will be sent out together at end of computation
   } else if (inputType == "digits") {
-    gDispatchTrigger = o2::framework::Output{"TPC", "DIGITS"};
+    gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "DIGITS"};
   } else if (inputType == "clustershw") {
-    gDispatchTrigger = o2::framework::Output{"TPC", "CLUSTERHW"};
+    gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "CLUSTERHW"};
   } else if (inputType == "clustersnative") {
-    gDispatchTrigger = o2::framework::Output{"TPC", "CLUSTERNATIVE"};
+    gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "CLUSTERNATIVE"};
   } else if (inputType == "zsraw") {
-    gDispatchTrigger = o2::framework::Output{"TPC", "RAWDATA"};
+    gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "RAWDATA"};
   }
   // set up configuration
   o2::conf::ConfigurableParam::updateFromFile(cfgc.options().get<std::string>("configFile"));

From 73b259292c546287874c301d5e84c40afe999c81 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 10 Jun 2025 23:27:51 +0200
Subject: [PATCH 0475/1764] Fix ClusterDecoderRawSpec to work with std::pmr
 (#14386)

---
 .../workflow/src/ClusterDecoderRawSpec.cxx    | 30 +++++++------------
 1 file changed, 11 insertions(+), 19 deletions(-)

diff --git a/Detectors/TPC/workflow/src/ClusterDecoderRawSpec.cxx b/Detectors/TPC/workflow/src/ClusterDecoderRawSpec.cxx
index 9e2e70e8dde46..c5c444e077703 100644
--- a/Detectors/TPC/workflow/src/ClusterDecoderRawSpec.cxx
+++ b/Detectors/TPC/workflow/src/ClusterDecoderRawSpec.cxx
@@ -43,6 +43,7 @@ namespace o2
 {
 namespace tpc
 {
+
 /// create the processor spec for TPC raw cluster decoder converting TPC raw to native clusters
 /// Input: raw pages of TPC raw clusters
 /// Output: vector of containers with clusters in ClusterNative format, one container per
@@ -79,27 +80,18 @@ DataProcessorSpec getClusterDecoderRawSpec(bool sendMC)
       // init the stacks for forwarding the sector header
       // FIXME check if there is functionality in the DPL to forward the stack
       // FIXME make one function
-      o2::header::Stack rawHeaderStack;
-      o2::header::Stack mcHeaderStack;
       o2::tpc::TPCSectorHeader const* sectorHeaderMC = nullptr;
       if (DataRefUtils::isValid(mclabelref)) {
         sectorHeaderMC = DataRefUtils::getHeader<o2::tpc::TPCSectorHeader*>(mclabelref);
-        if (sectorHeaderMC) {
-          o2::header::Stack actual{*sectorHeaderMC};
-          std::swap(mcHeaderStack, actual);
-          if (sectorHeaderMC->sector() < 0) {
-            pc.outputs().snapshot(Output{gDataOriginTPC, DataDescription("CLNATIVEMCLBL"), fanSpec, std::move(mcHeaderStack)}, fanSpec);
-          }
-        }
+      }
+
+      if (sectorHeaderMC && sectorHeaderMC->sector() < 0) {
+        pc.outputs().snapshot(Output{gDataOriginTPC, DataDescription("CLNATIVEMCLBL"), fanSpec, {*sectorHeaderMC}}, fanSpec);
       }
       auto const* sectorHeader = DataRefUtils::getHeader<o2::tpc::TPCSectorHeader*>(ref);
-      if (sectorHeader) {
-        o2::header::Stack actual{*sectorHeader};
-        std::swap(rawHeaderStack, actual);
-        if (sectorHeader->sector() < 0) {
-          pc.outputs().snapshot(Output{gDataOriginTPC, DataDescription("CLUSTERNATIVE"), fanSpec, std::move(rawHeaderStack)}, fanSpec);
-          return;
-        }
+      if (sectorHeader && sectorHeader->sector() < 0) {
+        pc.outputs().snapshot(Output{gDataOriginTPC, DataDescription("CLUSTERNATIVE"), fanSpec, {*sectorHeader}}, fanSpec);
+        return;
       }
       assert(sectorHeaderMC == nullptr || sectorHeader->sector() == sectorHeaderMC->sector());
 
@@ -166,8 +158,8 @@ DataProcessorSpec getClusterDecoderRawSpec(bool sendMC)
       // output of the decoder is sorted in (sector,globalPadRow) coordinates, individual
       // containers are created for clusters and MC labels per (sector,globalPadRow) address
       char* outputBuffer = nullptr;
-      auto outputAllocator = [&pc, &fanSpec, &outputBuffer, &rawHeaderStack](size_t size) -> char* {
-        outputBuffer = pc.outputs().newChunk(Output{gDataOriginTPC, DataDescription("CLUSTERNATIVE"), fanSpec, std::move(rawHeaderStack)}, size).data();
+      auto outputAllocator = [&pc, &fanSpec, &outputBuffer, sectorHeader](size_t size) -> char* {
+        outputBuffer = pc.outputs().newChunk(Output{gDataOriginTPC, DataDescription("CLUSTERNATIVE"), fanSpec, sectorHeader ? o2::header::Stack{*sectorHeader} : o2::header::Stack{}}, size).data();
         return outputBuffer;
       };
       MCLabelContainer mcout;
@@ -188,7 +180,7 @@ DataProcessorSpec getClusterDecoderRawSpec(bool sendMC)
         // serialize the complete list of MC label containers
         ConstMCLabelContainer labelsFlat;
         mcout.flatten_to(labelsFlat);
-        pc.outputs().snapshot(Output{gDataOriginTPC, DataDescription("CLNATIVEMCLBL"), fanSpec, std::move(mcHeaderStack)}, labelsFlat);
+        pc.outputs().snapshot(Output{gDataOriginTPC, DataDescription("CLNATIVEMCLBL"), fanSpec, sectorHeaderMC ? o2::header::Stack{*sectorHeaderMC} : o2::header::Stack{}}, labelsFlat);
       }
     };
 

From 136d7dc385cd91ec5b1828b8a09cbe653347ebca Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Tue, 10 Jun 2025 15:52:41 +0200
Subject: [PATCH 0476/1764] Fix MCKinematicsReader for QED events when using
 collisioncontext

---
 DataFormats/simulation/src/DigitizationContext.cxx | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index 499a478bc5148..e5b4d6e706732 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -151,6 +151,19 @@ bool DigitizationContext::initSimKinematicsChains(std::vector<TChain*>& simkinem
     // add signal files
     simkinematicschains.back()->AddFile(o2::base::NameConf::getMCKinematicsFileName(mSimPrefixes[source].data()).c_str());
   }
+
+  // we add QED, if used in the digitization context
+  if (mEventRecordsWithQED.size() > 0) {
+    if (mSimPrefixes.size() >= QEDSOURCEID) {
+      LOG(fatal) << "Too many signal chains; crashes with QED source ID";
+    }
+
+    // it might be better to use an unordered_map for the simchains but this requires interface changes
+    simkinematicschains.resize(QEDSOURCEID + 1, nullptr);
+    simkinematicschains[QEDSOURCEID] = new TChain("o2sim");
+    simkinematicschains[QEDSOURCEID]->AddFile(o2::base::DetectorNameConf::getMCKinematicsFileName(mQEDSimPrefix).c_str());
+  }
+
   return true;
 }
 

From 89020a5507b53590af46a214f3f4902c89b7eabb Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 10 Jun 2025 12:53:06 +0200
Subject: [PATCH 0477/1764] GPU Math: Suppress compiler warnings about NaN in
 ffast-math

---
 GPU/Common/GPUCommonMath.h               | 5 +++++
 GPU/GPUTracking/Definitions/GPULogging.h | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index 350ef173467d5..01067ca032650 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -99,7 +99,12 @@ class GPUCommonMath
   GPUhdi() static float Remainderf(float x, float y);
   GPUd() constexpr static bool Finite(float x);
   GPUd() constexpr static bool IsNaN(float x);
+#pragma GCC diagnostic push
+#if defined(__FAST_MATH__) && defined(__clang__)
+#pragma GCC diagnostic ignored "-Wnan-infinity-disabled"
+#endif
   GPUd() constexpr static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
+#pragma GCC diagnostic pop
   GPUd() constexpr static uint32_t Clz(uint32_t val);
   GPUd() constexpr static uint32_t Popcount(uint32_t val);
 
diff --git a/GPU/GPUTracking/Definitions/GPULogging.h b/GPU/GPUTracking/Definitions/GPULogging.h
index c8ba635d1af7a..800890045ec45 100644
--- a/GPU/GPUTracking/Definitions/GPULogging.h
+++ b/GPU/GPUTracking/Definitions/GPULogging.h
@@ -28,7 +28,12 @@
   #define GPUFatal(...)
 #elif defined(GPUCA_STANDALONE) && !defined(GPUCA_GPUCODE_DEVICE) && !defined(GPUCA_NO_FMT)
   #include <cstdio>
+  #pragma GCC diagnostic push
+  #if defined(__FAST_MATH__) && defined(__clang__)
+  #pragma GCC diagnostic ignored "-Wnan-infinity-disabled"
+  #endif
   #include <fmt/printf.h>
+  #pragma GCC diagnostic pop
   #define GPUInfo(string, ...)                 \
     {                                          \
       fmt::printf(string "\n", ##__VA_ARGS__); \

From 418a85fc58fdd772177a6c22f1fa7267e571f2c9 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 11 Jun 2025 09:31:19 +0200
Subject: [PATCH 0478/1764] ITS: simplify constants + mathutils (#14383)

---
 .../GPU/ITStrackingGPU/TrackingKernels.h      |   4 +
 .../GPU/ITStrackingGPU/VertexerTraitsGPU.h    |  12 +-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  |  30 ++---
 .../tracking/GPU/cuda/VertexerTraitsGPU.cxx   |   2 +-
 .../ITS/tracking/GPU/cuda/VertexingKernels.cu |   8 --
 .../include/ITStracking/Configuration.h       |   6 +-
 .../tracking/include/ITStracking/Constants.h  | 103 ++---------------
 .../include/ITStracking/IndexTableUtils.h     |   4 +-
 .../tracking/include/ITStracking/MathUtils.h  | 109 +++++++++---------
 .../include/ITStracking/TrackerTraits.h       |   4 +-
 .../include/ITStracking/VertexerTraits.h      |   2 -
 .../ITSMFT/ITS/tracking/src/Smoother.cxx      |   4 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |  24 +---
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |   8 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  55 +++------
 .../ITS/tracking/src/VertexerTraits.cxx       |  12 +-
 16 files changed, 122 insertions(+), 265 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 09c8c39725efa..b847aacd9bba5 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -22,7 +22,11 @@ class CellSeed;
 class ExternalAllocator;
 namespace gpu
 {
+
 #ifdef GPUCA_GPUCODE // GPUg() global kernels must only when compiled by GPU compiler
+
+GPUdi() int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
+
 GPUd() bool fitTrack(TrackITSExt& track,
                      int start,
                      int end,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
index a5c3709081a82..5b1d9194e1174 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
@@ -18,7 +18,6 @@
 #define ITSTRACKINGGPU_VERTEXERTRAITSGPU_H_
 
 #include <vector>
-#include <array>
 
 #include "ITStracking/VertexerTraits.h"
 #include "ITStracking/Configuration.h"
@@ -29,13 +28,8 @@
 
 #include "ITStrackingGPU/TimeFrameGPU.h"
 
-namespace o2
+namespace o2::its
 {
-namespace its
-{
-class ROframe;
-
-using constants::its2::InversePhiBinSize;
 
 class VertexerTraitsGPU final : public VertexerTraits
 {
@@ -63,6 +57,6 @@ inline void VertexerTraitsGPU::adoptTimeFrame(TimeFrame<7>* tf) noexcept
   mTimeFrame = static_cast<TimeFrame<7>*>(tf);
 }
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
+
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 18c89d39adda0..2191880374548 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -52,14 +52,8 @@ using namespace o2::track;
 
 namespace o2::its
 {
-using namespace constants::its2;
 using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
-GPUdii() float Sq(float v)
-{
-  return v * v;
-}
-
 namespace gpu
 {
 
@@ -99,9 +93,9 @@ GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerInde
                               const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
 {
   const float zRangeMin = o2::gpu::CAMath::Min(z1, z2) - maxdeltaz;
-  const float phiRangeMin = (maxdeltaphi > constants::math::Pi) ? 0.f : currentCluster.phi - maxdeltaphi;
+  const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : currentCluster.phi - maxdeltaphi;
   const float zRangeMax = o2::gpu::CAMath::Max(z1, z2) + maxdeltaz;
-  const float phiRangeMax = (maxdeltaphi > constants::math::Pi) ? constants::math::TwoPi : currentCluster.phi + maxdeltaphi;
+  const float phiRangeMax = (maxdeltaphi > o2::constants::math::PI) ? o2::constants::math::TwoPI : currentCluster.phi + maxdeltaphi;
 
   if (zRangeMax < -utils.getLayerZ(layerIndex) ||
       zRangeMin > utils.getLayerZ(layerIndex) || zRangeMin > zRangeMax) {
@@ -129,7 +123,7 @@ GPUd() bool fitTrack(TrackITSExt& track,
                      o2::base::PropagatorF::MatCorrType matCorrType)
 {
   for (int iLayer{start}; iLayer != end; iLayer += step) {
-    if (track.getClusterIndex(iLayer) == constants::its::UnusedIndex) {
+    if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
       continue;
     }
     const TrackingFrameInfo& trackingHit = tfInfos[iLayer][track.getClusterIndex(iLayer)];
@@ -316,7 +310,7 @@ GPUg() void fitTrackSeedsKernel(
     temporaryTrack.setChi2(0);
     int* clusters = seed.getClusters();
     for (int iL{0}; iL < 7; ++iL) {
-      temporaryTrack.setExternalClusterIndex(iL, clusters[iL], clusters[iL] != constants::its::UnusedIndex);
+      temporaryTrack.setExternalClusterIndex(iL, clusters[iL], clusters[iL] != constants::UnusedIndex);
     }
     bool fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
                                0,                            // int lastLayer,
@@ -422,8 +416,6 @@ GPUg() void computeLayerCellsKernel(
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut)
 {
-  constexpr float radl = 9.36f;                                                           // Radiation length of Si [cm].
-  constexpr float rho = 2.33f;                                                            // Density of Si [g/cm^3].
   constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // Hardcoded here for the moment.
   for (int iCurrentTrackletIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentTrackletIndex < nTrackletsCurrent; iCurrentTrackletIndex += blockDim.x * gridDim.x) {
     const Tracklet& currentTracklet = tracklets[layer][iCurrentTrackletIndex];
@@ -462,7 +454,7 @@ GPUg() void computeLayerCellsKernel(
             break;
           }
 
-          if (!track.correctForMaterial(layerxX0[layer + iC], layerxX0[layer] * radl * rho, true)) {
+          if (!track.correctForMaterial(layerxX0[layer + iC], layerxX0[layer] * constants::Radl * constants::Rho, true)) {
             break;
           }
 
@@ -548,12 +540,12 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
         if (primaryVertex.isFlagSet(2) && iteration != 3) {
           continue;
         }
-        const float resolution = o2::gpu::CAMath::Sqrt(Sq(resolutionPV) / primaryVertex.getNContributors() + Sq(positionResolution));
+        const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(resolutionPV) / primaryVertex.getNContributors() + math_utils::Sq(positionResolution));
         const float tanLambda{(currentCluster.zCoordinate - primaryVertex.getZ()) * inverseR0};
         const float zAtRmin{tanLambda * (minR - currentCluster.radius) + currentCluster.zCoordinate};
         const float zAtRmax{tanLambda * (maxR - currentCluster.radius) + currentCluster.zCoordinate};
-        const float sqInverseDeltaZ0{1.f / (Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
-        const float sigmaZ{o2::gpu::CAMath::Sqrt(Sq(resolution) * Sq(tanLambda) * ((Sq(inverseR0) + sqInverseDeltaZ0) * Sq(meanDeltaR) + 1.f) + Sq(meanDeltaR * MSAngle))};
+        const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
+        const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * MSAngle))};
         const int4 selectedBinsRect{getBinsRect(currentCluster, layerIndex + 1, *utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
         if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
           continue;
@@ -587,7 +579,7 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
               const float deltaPhi{o2::gpu::CAMath::Abs(currentCluster.phi - nextCluster.phi)};
               const float deltaZ{o2::gpu::CAMath::Abs(tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate)};
               const int nextSortedIndex{ROFClusters[layerIndex + 1][rof1] + nextClusterIndex};
-              if (deltaZ / sigmaZ < NSigmaCut && (deltaPhi < phiCut || o2::gpu::CAMath::Abs(deltaPhi - constants::math::TwoPi) < phiCut)) {
+              if (deltaZ / sigmaZ < NSigmaCut && (deltaPhi < phiCut || o2::gpu::CAMath::Abs(deltaPhi - o2::constants::math::TwoPI) < phiCut)) {
                 if constexpr (initRun) {
                   trackletsLUT[layerIndex][currentSortedIndex]++; // we need l0 as well for usual exclusive sums.
                 } else {
@@ -634,8 +626,6 @@ GPUg() void processNeighboursKernel(const int layer,
                                     const o2::base::Propagator* propagator,
                                     const o2::base::PropagatorF::MatCorrType matCorrType)
 {
-  constexpr float radl = 9.36f;                                                           // Radiation length of Si [cm].
-  constexpr float rho = 2.33f;                                                            // Density of Si [g/cm^3].
   constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // Hardcoded here for the moment.
   for (unsigned int iCurrentCell = blockIdx.x * blockDim.x + threadIdx.x; iCurrentCell < nCurrentCells; iCurrentCell += blockDim.x * gridDim.x) {
     int foundSeeds{0};
@@ -678,7 +668,7 @@ GPUg() void processNeighboursKernel(const int layer,
       }
 
       if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-        if (!seed.correctForMaterial(layerxX0[layer - 1], layerxX0[layer - 1] * radl * rho, true)) {
+        if (!seed.correctForMaterial(layerxX0[layer - 1], layerxX0[layer - 1] * constants::Radl * constants::Rho, true)) {
           continue;
         }
       }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
index 2a6debe8f652e..90d654a26a43d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
@@ -40,7 +40,7 @@ void VertexerTraitsGPU::updateVertexingParameters(const std::vector<VertexingPar
   mTfGPUParams = tfPar;
   mIndexTableUtils.setTrackingParameters(vrtPar[0]);
   for (auto& par : mVrtParams) {
-    par.phiSpan = static_cast<int>(std::ceil(mIndexTableUtils.getNphiBins() * par.phiCut / constants::math::TwoPi));
+    par.phiSpan = static_cast<int>(std::ceil(mIndexTableUtils.getNphiBins() * par.phiCut / o2::constants::math::TwoPI));
     par.zSpan = static_cast<int>(std::ceil(par.zCut * mIndexTableUtils.getInverseZCoordinate(0)));
   }
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
index acbd77585df37..126e799efce5d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
@@ -20,10 +20,7 @@ namespace o2
 {
 namespace its
 {
-using constants::its::VertexerHistogramVolume;
-using constants::math::TwoPi;
 using math_utils::getNormalizedPhi;
-using namespace constants::its2;
 
 namespace gpu
 {
@@ -58,11 +55,6 @@ void trackletFinderHandler(const Cluster* clustersNextLayer,    // 0 2
     maxTrackletsPerCluster); // const unsigned int maxTrackletsPerCluster = 1e2
 }
 /*
-GPUd() float smallestAngleDifference(float a, float b)
-{
-  float diff = fmod(b - a + constants::math::Pi, constants::math::TwoPi) - constants::math::Pi;
-  return (diff < -constants::math::Pi) ? diff + constants::math::TwoPi : ((diff > constants::math::Pi) ? diff - constants::math::TwoPi : diff);
-}
 
 GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
                               const float z1, float maxdeltaz, float maxdeltaphi)
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index d3f7597ae314b..14edd0b81e049 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -58,9 +58,9 @@ class Configuration : public Param
 };
 
 struct TrackingParameters {
-  int CellMinimumLevel() { return MinTrackLength - constants::its::ClustersPerCell + 1; }
-  int CellsPerRoad() const { return NLayers - 2; }
-  int TrackletsPerRoad() const { return NLayers - 1; }
+  int CellMinimumLevel() const noexcept { return MinTrackLength - constants::ClustersPerCell + 1; }
+  int CellsPerRoad() const noexcept { return NLayers - 2; }
+  int TrackletsPerRoad() const noexcept { return NLayers - 1; }
   std::string asString() const;
 
   int NLayers = 7;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index c29ad2e01c588..48cc45e44cf1c 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -17,112 +17,25 @@
 #define TRACKINGITSU_INCLUDE_CONSTANTS_H_
 
 #include "ITStracking/Definitions.h"
-#include "CommonConstants/MathConstants.h"
 
-#include "GPUCommonMath.h"
-#include "GPUCommonDef.h"
-
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <climits>
-#include <vector>
-#include <array>
-#endif
-
-namespace o2
-{
-namespace its
-{
-
-namespace constants
+namespace o2::its::constants
 {
 constexpr float MB = 1024.f * 1024.f;
 constexpr float GB = 1024.f * 1024.f * 1024.f;
 constexpr bool DoTimeBenchmarks = true;
 constexpr bool SaveTimeBenchmarks = false;
 
-namespace math
-{
-constexpr float Pi{3.14159265359f};
-constexpr float TwoPi{2.0f * Pi};
-constexpr float FloatMinThreshold{1e-20f};
-} // namespace math
-
-namespace its
-{
-constexpr int LayersNumberVertexer{3};
+constexpr float Tolerance{1e-12}; // numerical tolerance
 constexpr int ClustersPerCell{3};
 constexpr int UnusedIndex{-1};
 constexpr float Resolution{0.0005f};
-
-GPUhdi() constexpr std::array<float, 3> VertexerHistogramVolume()
-{
-  return std::array<float, 3>{{1.98, 1.98, 40.f}};
-}
-} // namespace its
-
-namespace its2
-{
-constexpr int LayersNumber{7};
-constexpr int TrackletsPerRoad{LayersNumber - 1};
-constexpr int CellsPerRoad{LayersNumber - 2};
-
-GPUhdi() constexpr std::array<float, LayersNumber> LayersZCoordinate()
-{
-  constexpr double s = 1.; // safety margin
-  return std::array<float, LayersNumber>{16.333f + s, 16.333f + s, 16.333f + s, 42.140f + s, 42.140f + s, 73.745f + s, 73.745f + s};
-}
-
-GPUhdi() constexpr std::array<float, LayersNumber> LayersRCoordinate()
+constexpr float Radl = 9.36f; // Radiation length of Si [cm]
+constexpr float Rho = 2.33f;  // Density of Si [g/cm^3]
+namespace its                 // to be removed
 {
-  return std::array<float, LayersNumber>{{2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f}};
-}
-
-constexpr int ZBins{256};
-constexpr int PhiBins{128};
-constexpr float InversePhiBinSize{PhiBins / constants::math::TwoPi};
-GPUhdi() constexpr std::array<float, LayersNumber> InverseZBinSize()
-{
-  constexpr auto zSize = LayersZCoordinate();
-  return std::array<float, LayersNumber>{0.5f * ZBins / (zSize[0]), 0.5f * ZBins / (zSize[1]), 0.5f * ZBins / (zSize[2]),
-                                         0.5f * ZBins / (zSize[3]), 0.5f * ZBins / (zSize[4]), 0.5f * ZBins / (zSize[5]),
-                                         0.5f * ZBins / (zSize[6])};
-}
-
-GPUhdi() constexpr float getInverseZCoordinate(const int layerIndex)
-{
-  return 0.5f * ZBins / LayersZCoordinate()[layerIndex];
-}
-
-GPUhdi() int getZBinIndex(const int layerIndex, const float zCoordinate)
-{
-  return (zCoordinate + LayersZCoordinate()[layerIndex]) *
-         InverseZBinSize()[layerIndex];
-}
-
-GPUhdi() int getPhiBinIndex(const float currentPhi)
-{
-  return (currentPhi * InversePhiBinSize);
-}
-
-GPUhdi() int getBinIndex(const int zIndex, const int phiIndex)
-{
-  return o2::gpu::GPUCommonMath::Min(phiIndex * ZBins + zIndex,
-                                     ZBins * PhiBins - 1);
-}
-
-GPUhdi() constexpr int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
-
-} // namespace its2
-
-namespace pdgcodes
-{
-constexpr int PionCode{211};
-}
-} // namespace constants
-#ifndef GPUCA_GPUCODE_DEVICE
-typedef std::vector<std::vector<int>> index_table_t;
-#endif
+constexpr int UnusedIndex{-1};
+constexpr float Resolution{0.0005f};
 } // namespace its
-} // namespace o2
+} // namespace o2::its::constants
 
 #endif /* TRACKINGITSU_INCLUDE_CONSTANTS_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
index ed4027f77f360..61072cb2410b7 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
@@ -16,9 +16,9 @@
 #ifndef TRACKINGITSU_INCLUDE_INDEXTABLEUTILS_H_
 #define TRACKINGITSU_INCLUDE_INDEXTABLEUTILS_H_
 
-#include "ITStracking/Constants.h"
 #include "ITStracking/Configuration.h"
 #include "ITStracking/Definitions.h"
+#include "CommonConstants/MathConstants.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonDef.h"
 
@@ -55,7 +55,7 @@ class IndexTableUtils
 template <class T>
 inline void IndexTableUtils::setTrackingParameters(const T& params)
 {
-  mInversePhiBinSize = params.PhiBins / constants::math::TwoPi;
+  mInversePhiBinSize = params.PhiBins / o2::constants::math::TwoPI;
   mNzBins = params.ZBins;
   mNphiBins = params.PhiBins;
   for (int iLayer{0}; iLayer < params.LayerZ.size(); ++iLayer) {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
index 9093609144283..c5c1e4a8ce220 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
@@ -13,92 +13,95 @@
 /// \brief
 ///
 
-#ifndef TRACKINGITSU_INCLUDE_CAUTILS_H_
-#define TRACKINGITSU_INCLUDE_CAUTILS_H_
+#ifndef O2_ITS_TRACKING_MATHUTILS_H_
+#define O2_ITS_TRACKING_MATHUTILS_H_
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <array>
-#include <cmath>
-#include <cassert>
-#include <iostream>
-#endif
-
-#include "MathUtils/Utils.h"
+#include "CommonConstants/MathConstants.h"
 #include "ITStracking/Constants.h"
+#include "MathUtils/Utils.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonDef.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its::math_utils
 {
 
-namespace math_utils
+GPUhdi() float computePhi(float x, float y)
 {
-GPUhdni() float computePhi(const float, const float);
-GPUhdni() float hypot(const float, const float);
-GPUhdni() constexpr float getNormalizedPhi(const float);
-GPUhdni() constexpr float3 crossProduct(const float3&, const float3&);
-GPUhdni() float computeCurvature(float x1, float y1, float x2, float y2, float x3, float y3);
-GPUhdni() float computeCurvatureCentreX(float x1, float y1, float x2, float y2, float x3, float y3);
-GPUhdni() float computeTanDipAngle(float x1, float y1, float x2, float y2, float z1, float z2);
-
-} // namespace math_utils
-
-GPUhdi() float math_utils::computePhi(const float x, const float y)
-{
-  //return o2::gpu::CAMath::ATan2(-yCoordinate, -xCoordinate) + constants::math::Pi;
-  return o2::math_utils::fastATan2(-y, -x) + constants::math::Pi;
-}
-
-GPUhdi() float math_utils::hypot(const float x, const float y)
-{
-  return o2::gpu::CAMath::Sqrt(x * x + y * y);
+  return o2::math_utils::fastATan2(-y, -x) + o2::constants::math::PI;
 }
 
-GPUhdi() constexpr float math_utils::getNormalizedPhi(const float phi)
+GPUhdi() constexpr float hypot(float x, float y)
 {
-  return (phi < 0) ? phi + constants::math::TwoPi : (phi > constants::math::TwoPi) ? phi - constants::math::TwoPi
-                                                                                   : phi;
+  return o2::gpu::CAMath::Hypot(x, y);
 }
 
-GPUhdi() constexpr float3 math_utils::crossProduct(const float3& firstVector, const float3& secondVector)
+GPUhdi() constexpr float getNormalizedPhi(float phi)
 {
-
-  return float3{(firstVector.y * secondVector.z) - (firstVector.z * secondVector.y),
-                (firstVector.z * secondVector.x) - (firstVector.x * secondVector.z),
-                (firstVector.x * secondVector.y) - (firstVector.y * secondVector.x)};
+  phi -= o2::constants::math::TwoPI * o2::gpu::CAMath::Floor(phi * (1.f / o2::constants::math::TwoPI));
+  return phi;
 }
 
-GPUhdi() float math_utils::computeCurvature(float x1, float y1, float x2, float y2, float x3, float y3)
+GPUhdi() float computeCurvature(float x1, float y1, float x2, float y2, float x3, float y3)
 {
+  // in case the triangle is degenerate we return infinite curvature.
   const float d = (x2 - x1) * (y3 - y2) - (x3 - x2) * (y2 - y1);
+  if (o2::gpu::CAMath::Abs(d) < o2::its::constants::Tolerance) {
+    return 0.f;
+  }
   const float a =
     0.5f * ((y3 - y2) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1) - (y2 - y1) * (y3 * y3 - y2 * y2 + x3 * x3 - x2 * x2));
   const float b =
     0.5f * ((x2 - x1) * (y3 * y3 - y2 * y2 + x3 * x3 - x2 * x2) - (x3 - x2) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1));
-  const float den2 = (d * x1 - a) * (d * x1 - a) + (d * y1 - b) * (d * y1 - b);
-  return den2 > 0.f ? -1.f * d / o2::gpu::CAMath::Sqrt(den2) : 0.f;
+  const float den = o2::gpu::CAMath::Hypot(d * x1 - a, d * y1 - b);
+  if (den < o2::its::constants::Tolerance) {
+    return 0.f;
+  }
+  return -d / den;
 }
 
-GPUhdi() float math_utils::computeCurvatureCentreX(float x1, float y1, float x2, float y2, float x3, float y3)
+GPUhdi() float computeCurvatureCentreX(float x1, float y1, float x2, float y2, float x3, float y3)
 {
+  // in case the triangle is degenerate we return set the centre to infinity.
   float dx21 = x2 - x1, dx32 = x3 - x2;
-  if (dx21 == 0.f || dx32 == 0.f) { // add small offset
+  if (o2::gpu::CAMath::Abs(dx21) < o2::its::constants::Tolerance ||
+      o2::gpu::CAMath::Abs(dx32) < o2::its::constants::Tolerance) { // add small offset
     x2 += 1e-4;
     dx21 = x2 - x1;
     dx32 = x3 - x2;
   }
-  float k1 = (y2 - y1) / dx21, k2 = (y3 - y2) / dx32;
-  return (k1 != k2) ? 0.5f * (k1 * k2 * (y1 - y3) + k2 * (x1 + x2) - k1 * (x2 + x3)) / (k2 - k1) : 1e5;
+  const float k1 = (y2 - y1) / dx21, k2 = (y3 - y2) / dx32;
+  if (o2::gpu::CAMath::Abs(k2 - k1) < o2::its::constants::Tolerance) {
+    return o2::constants::math::VeryBig;
+  }
+  return 0.5f * (k1 * k2 * (y1 - y3) + k2 * (x1 + x2) - k1 * (x2 + x3)) / (k2 - k1);
 }
 
-GPUhdi() float math_utils::computeTanDipAngle(float x1, float y1, float x2, float y2, float z1, float z2)
+GPUhdi() float computeTanDipAngle(float x1, float y1, float x2, float y2, float z1, float z2)
 {
-  return (z1 - z2) / o2::gpu::CAMath::Sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
+  // in case the points vertically align we go to pos/neg inifinity.
+  const float d = o2::gpu::CAMath::Hypot(x1 - x2, y1 - y2);
+  if (o2::gpu::CAMath::Abs(d) < o2::its::constants::Tolerance) {
+    return ((z1 > z2) ? -1.f : 1.f) * o2::constants::math::VeryBig;
+  }
+  return (z1 - z2) / d;
 }
 
-} // namespace its
-} // namespace o2
+GPUhdi() float smallestAngleDifference(float a, float b)
+{
+  return o2::gpu::CAMath::Remainderf(b - a, o2::constants::math::TwoPI);
+}
 
-#endif /* TRACKINGITSU_INCLUDE_CAUTILS_H_ */
+GPUhdi() float Sq(float v)
+{
+  return v * v;
+}
+
+GPUhdi() float MSangle(float mass, float p, float xX0)
+{
+  float beta = p / o2::gpu::CAMath::Hypot(mass, p);
+  return 0.0136f * o2::gpu::CAMath::Sqrt(xX0) * (1.f + 0.038f * o2::gpu::CAMath::Log(xX0)) / (beta * p);
+}
+
+} // namespace o2::its::math_utils
+
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 5f4e40b92ba82..36956a5206277 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -113,9 +113,9 @@ template <int nLayers>
 inline const int4 TrackerTraits<nLayers>::getBinsRect(const int layerIndex, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept
 {
   const float zRangeMin = o2::gpu::GPUCommonMath::Min(z1, z2) - maxdeltaz;
-  const float phiRangeMin = (maxdeltaphi > constants::math::Pi) ? 0.f : phi - maxdeltaphi;
+  const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : phi - maxdeltaphi;
   const float zRangeMax = o2::gpu::GPUCommonMath::Max(z1, z2) + maxdeltaz;
-  const float phiRangeMax = (maxdeltaphi > constants::math::Pi) ? constants::math::TwoPi : phi + maxdeltaphi;
+  const float phiRangeMax = (maxdeltaphi > o2::constants::math::PI) ? o2::constants::math::TwoPI : phi + maxdeltaphi;
 
   if (zRangeMax < -mTrkParams[0].LayerZ[layerIndex] ||
       zRangeMin > mTrkParams[0].LayerZ[layerIndex] || zRangeMin > zRangeMax) {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index e4ecced6d67fb..e1e1d44e8ead9 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -41,8 +41,6 @@ class MCCompLabel;
 
 namespace its
 {
-class ROframe;
-using constants::its::LayersNumberVertexer;
 
 enum class TrackletMode {
   Layer0Layer1 = 0,
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx b/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
index 6259e20a02dfb..9bc65161c3cbb 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
@@ -50,7 +50,7 @@ Smoother<D>::Smoother(TrackITSExt& track, size_t smoothingLayer, const ROframe&
   //////////////////////
   // Outward propagation
   for (size_t iLayer{0}; iLayer < mLayerToSmooth; ++iLayer) {
-    if (mOutwardsTrack.getClusterIndex(iLayer) == constants::its::UnusedIndex) { // Shorter tracks
+    if (mOutwardsTrack.getClusterIndex(iLayer) == constants::UnusedIndex) { // Shorter tracks
       continue;
     }
     const TrackingFrameInfo& tF = event.getTrackingFrameInfoOnLayer(iLayer).at(mOutwardsTrack.getClusterIndex(iLayer));
@@ -78,7 +78,7 @@ Smoother<D>::Smoother(TrackITSExt& track, size_t smoothingLayer, const ROframe&
   /////////////////////
   // Inward propagation
   for (size_t iLayer{D - 1}; iLayer > mLayerToSmooth; --iLayer) {
-    if (mInwardsTrack.getClusterIndex(iLayer) == constants::its::UnusedIndex) { // Shorter tracks
+    if (mInwardsTrack.getClusterIndex(iLayer) == constants::UnusedIndex) { // Shorter tracks
       continue;
     }
     const TrackingFrameInfo& tF = event.getTrackingFrameInfoOnLayer(iLayer).at(mInwardsTrack.getClusterIndex(iLayer));
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 34d8967c6a5bb..80dbae42fc387 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -34,18 +34,6 @@ struct ClusterHelper {
   int bin;
   int ind;
 };
-
-inline float MSangle(float mass, float p, float xX0)
-{
-  float beta = p / o2::gpu::CAMath::Hypot(mass, p);
-  return 0.0136f * o2::gpu::CAMath::Sqrt(xX0) * (1.f + 0.038f * o2::gpu::CAMath::Log(xX0)) / (beta * p);
-}
-
-inline float Sq(float v)
-{
-  return v * v;
-}
-
 } // namespace
 
 namespace o2::its
@@ -323,7 +311,7 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     for (unsigned int iLayer{0}; iLayer < std::min((int)mClusters.size(), maxLayers); ++iLayer) {
       clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), mMemoryPool.get());
       clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), mMemoryPool.get());
-      mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5 * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
+      mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
     }
     clearResizeBoundedArray(mIndexTables, mNrof * (trkParam.ZBins * trkParam.PhiBins + 1), mMemoryPool.get());
     clearResizeBoundedVector(mLines, mNrof, mMemoryPool.get());
@@ -364,18 +352,18 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
 
   float oneOverR{0.001f * 0.3f * std::abs(mBz) / trkParam.TrackletMinPt};
   for (unsigned int iLayer{0}; iLayer < mClusters.size(); ++iLayer) {
-    mMSangles[iLayer] = MSangle(0.14f, trkParam.TrackletMinPt, trkParam.LayerxX0[iLayer]);
+    mMSangles[iLayer] = math_utils::MSangle(0.14f, trkParam.TrackletMinPt, trkParam.LayerxX0[iLayer]);
     mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
     if (iLayer < mClusters.size() - 1) {
       const float& r1 = trkParam.LayerRadii[iLayer];
       const float& r2 = trkParam.LayerRadii[iLayer + 1];
       const float res1 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[iLayer]);
       const float res2 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[iLayer + 1]);
-      const float cosTheta1half = o2::gpu::CAMath::Sqrt(1.f - Sq(0.5f * r1 * oneOverR));
-      const float cosTheta2half = o2::gpu::CAMath::Sqrt(1.f - Sq(0.5f * r2 * oneOverR));
+      const float cosTheta1half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r1 * oneOverR));
+      const float cosTheta2half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r2 * oneOverR));
       float x = r2 * cosTheta1half - r1 * cosTheta2half;
-      float delta = o2::gpu::CAMath::Sqrt(1.f / (1.f - 0.25f * Sq(x * oneOverR)) * (Sq(0.25f * r1 * r2 * Sq(oneOverR) / cosTheta2half + cosTheta1half) * Sq(res1) + Sq(0.25f * r1 * r2 * Sq(oneOverR) / cosTheta1half + cosTheta2half) * Sq(res2)));
-      mPhiCuts[iLayer] = std::min(o2::gpu::CAMath::ASin(0.5f * x * oneOverR) + 2.f * mMSangles[iLayer] + delta, constants::math::Pi * 0.5f);
+      float delta = o2::gpu::CAMath::Sqrt(1.f / (1.f - 0.25f * math_utils::Sq(x * oneOverR)) * (math_utils::Sq(0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta2half + cosTheta1half) * math_utils::Sq(res1) + math_utils::Sq(0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta1half + cosTheta2half) * math_utils::Sq(res2)));
+      mPhiCuts[iLayer] = std::min(o2::gpu::CAMath::ASin(0.5f * x * oneOverR) + 2.f * mMSangles[iLayer] + delta, o2::constants::math::PI * 0.5f);
     }
   }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 75c265dbdb703..f4da1a86818bb 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -178,7 +178,7 @@ void Tracker::computeRoadsMClabels()
     for (int iCell{0}; iCell < mTrkParams[0].CellsPerRoad(); ++iCell) {
       const int currentCellIndex{currentRoad[iCell]};
 
-      if (currentCellIndex == constants::its::UnusedIndex) {
+      if (currentCellIndex == constants::UnusedIndex) {
         if (isFirstRoadCell) {
           continue;
         } else {
@@ -270,7 +270,7 @@ void Tracker::computeTracksMClabels()
 
       for (int iCluster = 0; iCluster < TrackITSExt::MaxClusters; ++iCluster) {
         const int index = track.getClusterIndex(iCluster);
-        if (index == constants::its::UnusedIndex) {
+        if (index == constants::UnusedIndex) {
           continue;
         }
         auto labels = mTimeFrame->getClusterLabels(iCluster, index);
@@ -300,7 +300,7 @@ void Tracker::computeTracksMClabels()
       // set fake clusters pattern
       for (int ic{TrackITSExt::MaxClusters}; ic--;) {
         auto clid = track.getClusterIndex(ic);
-        if (clid != constants::its::UnusedIndex) {
+        if (clid != constants::UnusedIndex) {
           auto labelsSpan = mTimeFrame->getClusterLabels(ic, clid);
           for (const auto& currentLabel : labelsSpan) {
             if (currentLabel == maxOccurrencesValue) {
@@ -325,7 +325,7 @@ void Tracker::rectifyClusterIndices()
     for (auto& track : mTimeFrame->getTracks(iROF)) {
       for (int iCluster = 0; iCluster < TrackITSExt::MaxClusters; ++iCluster) {
         const int index = track.getClusterIndex(iCluster);
-        if (index != constants::its::UnusedIndex) {
+        if (index != constants::UnusedIndex) {
           track.setExternalClusterIndex(iCluster, mTimeFrame->getClusterExternalIndex(iCluster, index));
         }
       }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 766dc25cd6d8e..36636069137f3 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -22,7 +22,7 @@
 #include <format>
 #endif
 
-#include <oneapi/tbb/combinable.h>
+#include <oneapi/tbb/blocked_range.h>
 #include <oneapi/tbb/parallel_sort.h>
 
 #include "CommonConstants/MathConstants.h"
@@ -38,18 +38,10 @@
 
 using o2::base::PropagatorF;
 
-namespace
-{
-inline float Sq(float q)
-{
-  return q * q;
-}
-} // namespace
-
 namespace o2::its
 {
 
-constexpr int debugLevel{0};
+static constexpr int debugLevel{0};
 
 template <int nLayers>
 void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
@@ -105,15 +97,15 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
                 if (primaryVertex.isFlagSet(2) && iteration != 3) {
                   continue;
                 }
-                const float resolution = o2::gpu::CAMath::Sqrt(Sq(mTrkParams[iteration].PVres) / primaryVertex.getNContributors() + Sq(mTimeFrame->getPositionResolution(iLayer)));
+                const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTrkParams[iteration].PVres) / primaryVertex.getNContributors() + math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)));
 
                 const float tanLambda{(currentCluster.zCoordinate - primaryVertex.getZ()) * inverseR0};
 
                 const float zAtRmin{tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
                 const float zAtRmax{tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
 
-                const float sqInverseDeltaZ0{1.f / (Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
-                const float sigmaZ{o2::gpu::CAMath::Sqrt(Sq(resolution) * Sq(tanLambda) * ((Sq(inverseR0) + sqInverseDeltaZ0) * Sq(meanDeltaR) + 1.f) + Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)))};
+                const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
+                const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)))};
 
                 const int4 selectedBinsRect{getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer))};
                 if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
@@ -181,7 +173,7 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
 
                       if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
                           (deltaPhi < mTimeFrame->getPhiCut(iLayer) ||
-                           o2::gpu::GPUCommonMath::Abs(deltaPhi - constants::math::TwoPi) < mTimeFrame->getPhiCut(iLayer))) {
+                           o2::gpu::GPUCommonMath::Abs(deltaPhi - o2::constants::math::TwoPI) < mTimeFrame->getPhiCut(iLayer))) {
                         if (iLayer > 0) {
                           mTimeFrame->getTrackletsLookupTable()[iLayer - 1][currentSortedIndex]++;
                         }
@@ -273,9 +265,6 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
   std::ofstream off(std::format("cells{}.txt", iter++));
 #endif
 
-  constexpr float radl = 9.36f; // Radiation length of Si [cm]
-  constexpr float rho = 2.33f;  // Density of Si [g/cm^3]
-
   for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
     deepVectorClear(mTimeFrame->getCells()[iLayer]);
     if (iLayer > 0) {
@@ -359,7 +348,7 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
                         break;
                       }
 
-                      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * radl * rho, true)) {
+                      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
                         break;
                       }
 
@@ -441,7 +430,7 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
                         break;
                       }
 
-                      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * radl * rho, true)) {
+                      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
                         break;
                       }
 
@@ -682,9 +671,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
             }
 
             if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-              float radl = 9.36f; // Radiation length of Si [cm]
-              float rho = 2.33f;  // Density of Si [g/cm^3]
-              if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * radl * rho, true)) {
+              if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
                 continue;
               }
             }
@@ -745,9 +732,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
             }
 
             if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-              float radl = 9.36f; // Radiation length of Si [cm]
-              float rho = 2.33f;  // Density of Si [g/cm^3]
-              if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * radl * rho, true)) {
+              if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
                 continue;
               }
             }
@@ -838,7 +823,7 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
             temporaryTrack.resetCovariance();
             temporaryTrack.setChi2(0);
             for (int iL{0}; iL < 7; ++iL) {
-              temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::its::UnusedIndex);
+              temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
             }
 
             bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
@@ -874,7 +859,7 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
             trk.resetCovariance();
             trk.setChi2(0);
             for (int iL{0}; iL < 7; ++iL) {
-              trk.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::its::UnusedIndex);
+              trk.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
             }
 
             bool fitSuccess = fitTrack(trk, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
@@ -898,7 +883,7 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
       int nShared = 0;
       bool isFirstShared{false};
       for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == constants::its::UnusedIndex) {
+        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
           continue;
         }
         nShared += int(mTimeFrame->isClusterUsed(iLayer, track.getClusterIndex(iLayer)));
@@ -911,7 +896,7 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
 
       std::array<int, 3> rofs{INT_MAX, INT_MAX, INT_MAX};
       for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == constants::its::UnusedIndex) {
+        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
           continue;
         }
         mTimeFrame->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
@@ -977,7 +962,7 @@ void TrackerTraits<nLayers>::extendTracks(const int iteration)
         track.setPattern(pattern);
         /// Make sure that the newly attached clusters get marked as used
         for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
-          if (track.getClusterIndex(iLayer) == constants::its::UnusedIndex) {
+          if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
             continue;
           }
           mTimeFrame->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
@@ -1082,7 +1067,7 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
   auto propInstance = o2::base::Propagator::Instance();
 
   for (int iLayer{start}; iLayer != end; iLayer += step) {
-    if (track.getClusterIndex(iLayer) == constants::its::UnusedIndex) {
+    if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
       continue;
     }
     const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer)[track.getClusterIndex(iLayer)];
@@ -1096,9 +1081,7 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
     }
 
     if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-      constexpr float radl = 9.36f; // Radiation length of Si [cm]
-      constexpr float rho = 2.33f;  // Density of Si [g/cm^3]
-      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer], mTrkParams[0].LayerxX0[iLayer] * radl * rho, true)) {
+      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
         continue;
       }
     }
@@ -1143,9 +1126,7 @@ bool TrackerTraits<nLayers>::trackFollowing(TrackITSExt* track, int rof, bool ou
       }
 
       if (mTrkParams[iteration].CorrType == PropagatorF::MatCorrType::USEMatCorrNONE) { // account for material affects if propagator does not
-        constexpr float radl = 9.36f;                                                   // Radiation length of Si [cm]
-        constexpr float rho = 2.33f;                                                    // Density of Si [g/cm^3]
-        if (!hypoParam.correctForMaterial(mTrkParams[iteration].LayerxX0[iLayer], mTrkParams[iteration].LayerxX0[iLayer] * radl * rho, true)) {
+        if (!hypoParam.correctForMaterial(mTrkParams[iteration].LayerxX0[iLayer], mTrkParams[iteration].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
           continue;
         }
       }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index fe1619efaa192..37b650c05bd61 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -31,12 +31,6 @@
 
 using namespace o2::its;
 
-float smallestAngleDifference(float a, float b)
-{
-  float diff = fmod(b - a + constants::math::Pi, constants::math::TwoPi) - constants::math::Pi;
-  return (diff < -constants::math::Pi) ? diff + constants::math::TwoPi : ((diff > constants::math::Pi) ? diff - constants::math::TwoPi : diff);
-}
-
 template <TrackletMode Mode, bool EvalRun>
 void trackleterKernelHost(
   const gsl::span<const Cluster>& clustersNextLayer,    // 0 2
@@ -75,7 +69,7 @@ void trackleterKernelHost(
             continue;
           }
           const Cluster& nextCluster{clustersNextLayer[iNextLayerClusterIndex]};
-          if (o2::gpu::GPUCommonMath::Abs(smallestAngleDifference(currentCluster.phi, nextCluster.phi)) < phiCut) {
+          if (o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(currentCluster.phi, nextCluster.phi)) < phiCut) {
             if (storedTracklets < maxTrackletsPerCluster) {
               if constexpr (!EvalRun) {
                 if constexpr (Mode == TrackletMode::Layer0Layer1) {
@@ -128,7 +122,7 @@ void trackletSelectionKernelHost(
           continue;
         }
         const float deltaTanLambda{o2::gpu::GPUCommonMath::Abs(tracklet01.tanLambda - tracklet12.tanLambda)};
-        const float deltaPhi{o2::gpu::GPUCommonMath::Abs(smallestAngleDifference(tracklet01.phi, tracklet12.phi))};
+        const float deltaPhi{o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(tracklet01.phi, tracklet12.phi))};
         if (!usedTracklets[iTracklet01] && deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets != maxTracklets) {
           usedClusters0[tracklet01.firstClusterIndex] = true;
           usedClusters2[tracklet12.secondClusterIndex] = true;
@@ -171,7 +165,7 @@ void VertexerTraits::updateVertexingParameters(const std::vector<VertexingParame
   mVrtParams = vrtPar;
   mIndexTableUtils.setTrackingParameters(vrtPar[0]);
   for (auto& par : mVrtParams) {
-    par.phiSpan = static_cast<int>(std::ceil(mIndexTableUtils.getNphiBins() * par.phiCut / constants::math::TwoPi));
+    par.phiSpan = static_cast<int>(std::ceil(mIndexTableUtils.getNphiBins() * par.phiCut / o2::constants::math::TwoPI));
     par.zSpan = static_cast<int>(std::ceil(par.zCut * mIndexTableUtils.getInverseZCoordinate(0)));
   }
   setNThreads(vrtPar[0].nThreads);

From bb75239cef8addcc693f52f1f9dcb65b83ce9f21 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 11 Jun 2025 17:10:51 +0200
Subject: [PATCH 0479/1764] Export fairlogger/Logger.h to avoid disseminating
 it everywhere. (#14391)

---
 Framework/Logger/include/Framework/Logger.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Logger/include/Framework/Logger.h b/Framework/Logger/include/Framework/Logger.h
index 5b3cd832d60a1..3bd977d14c735 100644
--- a/Framework/Logger/include/Framework/Logger.h
+++ b/Framework/Logger/include/Framework/Logger.h
@@ -11,7 +11,7 @@
 #ifndef O2_FRAMEWORK_LOGGER_H_
 #define O2_FRAMEWORK_LOGGER_H_
 
-#include <fairlogger/Logger.h>
+#include <fairlogger/Logger.h> // IWYU pragma: export
 
 #define O2DEBUG(...) LOGF(debug, __VA_ARGS__)
 #define O2INFO(...) LOGF(info, __VA_ARGS__)

From 892c49cd9f8e0ec5a65061aabfb36a7422c841f3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 11 Jun 2025 17:30:45 +0200
Subject: [PATCH 0480/1764] IWYU: avoid spurious unused include report (#14392)

Using WorkflowSpec without an AlgorithmSpec does not make much sense.
---
 Framework/Core/include/Framework/WorkflowSpec.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/WorkflowSpec.h b/Framework/Core/include/Framework/WorkflowSpec.h
index bdc4ea6302da1..d778463eeb1d2 100644
--- a/Framework/Core/include/Framework/WorkflowSpec.h
+++ b/Framework/Core/include/Framework/WorkflowSpec.h
@@ -12,7 +12,7 @@
 #define O2_FRAMEWORK_WORKFLOWSPEC_H_
 
 #include "Framework/DataProcessorSpec.h"
-#include "Framework/AlgorithmSpec.h"
+#include "Framework/AlgorithmSpec.h" // IWYU pragma: export
 
 #include <vector>
 #include <functional>

From 3a8de5599d75cf26c194d4dc23460e9a640c1ad9 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 11 Jun 2025 17:51:49 +0200
Subject: [PATCH 0481/1764] IWYU: export commonly used headers (#14393)

- Avoid fairlogger/Logger.h suggested everywhere
- Avoid exposing WorkflowSpec.h everywhere we have a runDataProcessing.h
- Cannot use AnalysisDataModel without ASoA.h
---
 Framework/Core/include/Framework/AnalysisDataModel.h | 2 +-
 Framework/Core/include/Framework/runDataProcessing.h | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index a2b0dc39950d4..e34b8210a0178 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -11,7 +11,7 @@
 #ifndef O2_FRAMEWORK_ANALYSISDATAMODEL_H_
 #define O2_FRAMEWORK_ANALYSISDATAMODEL_H_
 
-#include "Framework/ASoA.h"
+#include "Framework/ASoA.h" // IWYU pragma: export
 
 #include <cmath>
 #include <bitset>
diff --git a/Framework/Core/include/Framework/runDataProcessing.h b/Framework/Core/include/Framework/runDataProcessing.h
index 07083314af12e..e756c9f4b1d26 100644
--- a/Framework/Core/include/Framework/runDataProcessing.h
+++ b/Framework/Core/include/Framework/runDataProcessing.h
@@ -21,12 +21,12 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/DataAllocator.h"
 #include "Framework/SendingPolicy.h"
-#include "Framework/WorkflowSpec.h"
+#include "Framework/WorkflowSpec.h" // IWYU pragma: export
 #include "Framework/ConfigContext.h"
 #include "Framework/CustomWorkflowTerminationHook.h"
 #include "Framework/CommonServices.h"
 #include "Framework/WorkflowCustomizationHelpers.h"
-#include "Framework/Logger.h"
+#include "Framework/Logger.h" // IWYU pragma: export
 #include "Framework/CheckTypes.h"
 #include "Framework/StructToTuple.h"
 #include "ResourcePolicy.h"

From b9b561d346384f18558c09efd156da2007cbb0e2 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 12 Jun 2025 08:04:04 +0200
Subject: [PATCH 0482/1764] ITS: tracker shadowed variable  (#14390)

* ITS: set default mem to high

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix output crash if zero tracks where found

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: tracker fix shadowed variable

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: minor adjustments in TF

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITStracking/Configuration.h       |   6 +-
 .../tracking/include/ITStracking/TimeFrame.h  |   4 +-
 .../include/ITStracking/TrackingConfigParam.h |   5 +-
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |   8 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 126 +++++++++---------
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |   5 +-
 .../ITS/tracking/src/TrackingInterface.cxx    |  68 +++++-----
 7 files changed, 111 insertions(+), 111 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 14edd0b81e049..2a40b817a7005 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -18,7 +18,7 @@
 
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <array>
-#include <climits>
+#include <limits>
 #include <vector>
 #include <cmath>
 #endif
@@ -108,7 +108,7 @@ struct TrackingParameters {
   float TrackFollowerNSigmaCutPhi = 1.f;
 
   bool PrintMemory = false; // print allocator usage in epilog report
-  size_t MaxMemory = 12000000000UL;
+  size_t MaxMemory = std::numeric_limits<size_t>::max();
   bool DropTFUponFailure = false;
 };
 
@@ -142,7 +142,7 @@ struct VertexingParameters {
 
   int nThreads = 1;
   bool PrintMemory = false; // print allocator usage in epilog report
-  size_t MaxMemory = 12000000000UL;
+  size_t MaxMemory = std::numeric_limits<size_t>::max();
   bool DropTFUponFailure = false;
 };
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 1620350c68034..248e63aef382c 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -298,8 +298,6 @@ struct TimeFrame {
   std::array<bounded_vector<Cluster>, nLayers> mUnsortedClusters;
   std::vector<bounded_vector<Tracklet>> mTracklets;
   std::vector<bounded_vector<CellSeed>> mCells;
-  std::vector<bounded_vector<o2::track::TrackParCovF>> mCellSeeds;
-  std::vector<bounded_vector<float>> mCellSeedsChi2;
   bounded_vector<Road<nLayers - 2>> mRoads;
   std::vector<bounded_vector<TrackITSExt>> mTracks;
   std::vector<bounded_vector<int>> mCellsNeighbours;
@@ -311,7 +309,7 @@ struct TimeFrame {
   void wipe();
 
  private:
-  void prepareClusters(const TrackingParameters& trkParam, const int maxLayers);
+  void prepareClusters(const TrackingParameters& trkParam, const int maxLayers = nLayers);
   float mBz = 5.;
   unsigned int mNTotalLowPtVertices = 0;
   int mBeamPosWeight = 0;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 72301cd2851b3..039fe0756d6f6 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -12,6 +12,7 @@
 #ifndef ALICEO2_ITSDPLTRACKINGPARAM_H_
 #define ALICEO2_ITSDPLTRACKINGPARAM_H_
 
+#include <limits>
 #include "CommonUtils/ConfigurableParam.h"
 #include "CommonUtils/ConfigurableParamHelper.h"
 
@@ -49,7 +50,7 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
 
   int nThreads = 1;
   bool printMemory = false;
-  size_t maxMemory = 12000000000UL;
+  size_t maxMemory = std::numeric_limits<size_t>::max();
   bool dropTFUponFailure = false;
 
   O2ParamDef(VertexerParamConfig, "ITSVertexerParam");
@@ -94,7 +95,7 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
 
   int nThreads = 1;
   bool printMemory = false;
-  size_t maxMemory = 12000000000UL;
+  size_t maxMemory = std::numeric_limits<size_t>::max();
   bool dropTFUponFailure = false;
   bool fataliseUponFailure = true; // granular management of the fatalisation in async mode
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index d1cddc1819a0b..9e631ad6afb7f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -57,14 +57,18 @@ std::string TrackingParameters::asString() const
   for (size_t i = 0; i < SystErrorY2.size(); i++) {
     str += std::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);
   }
-  str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
+  if (std::numeric_limits<size_t>::max() != MaxMemory) {
+    str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
+  }
   return str;
 }
 
 std::string VertexingParameters::asString() const
 {
   std::string str = std::format("NZb:{} NPhB:{} DRof:{} ClsCont:{} MaxTrkltCls:{} ZCut:{} PhCut:{}", ZBins, PhiBins, deltaRof, clusterContributorsCut, maxTrackletsPerCluster, zCut, phiCut);
-  str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
+  if (std::numeric_limits<size_t>::max() != MaxMemory) {
+    str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
+  }
   return str;
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 80dbae42fc387..dbb1631a4eb10 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -13,6 +13,10 @@
 /// \brief
 ///
 
+#include <numeric>
+#include <sstream>
+
+#include "Framework/Logger.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/MathUtils.h"
 #include "DataFormatsITSMFT/Cluster.h"
@@ -24,8 +28,6 @@
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/TrackingConfigParam.h"
 
-#include <iostream>
-
 namespace
 {
 struct ClusterHelper {
@@ -53,7 +55,7 @@ TimeFrame<nLayers>::TimeFrame()
 template <int nLayers>
 TimeFrame<nLayers>::~TimeFrame()
 {
-  resetVectors();
+  wipe();
 }
 
 template <int nLayers>
@@ -214,34 +216,34 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
 template <int nLayers>
 void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, const int maxLayers)
 {
+  const int numBins{trkParam.PhiBins * trkParam.ZBins};
+  const int stride{numBins + 1};
   bounded_vector<ClusterHelper> cHelper(mMemoryPool.get());
-  bounded_vector<int> clsPerBin(trkParam.PhiBins * trkParam.ZBins, 0, mMemoryPool.get());
+  bounded_vector<int> clsPerBin(numBins, 0, mMemoryPool.get());
+  bounded_vector<int> lutPerBin(numBins, 0, mMemoryPool.get());
   for (int rof{0}; rof < mNrof; ++rof) {
     if ((int)mMultiplicityCutMask.size() == mNrof && !mMultiplicityCutMask[rof]) {
       continue;
     }
-    for (int iLayer{0}; iLayer < std::min(trkParam.NLayers, maxLayers); ++iLayer) {
-      std::fill(clsPerBin.begin(), clsPerBin.end(), 0);
-      const auto unsortedClusters{getUnsortedClustersOnLayer(rof, iLayer)};
+    for (int iLayer{0}, stopLayer = std::min(trkParam.NLayers, maxLayers); iLayer < stopLayer; ++iLayer) {
+      const auto& unsortedClusters{getUnsortedClustersOnLayer(rof, iLayer)};
       const int clustersNum{static_cast<int>(unsortedClusters.size())};
+      auto* tableBase = mIndexTables[iLayer].data() + rof * stride;
 
-      deepVectorClear(cHelper);
       cHelper.resize(clustersNum);
 
       for (int iCluster{0}; iCluster < clustersNum; ++iCluster) {
-
         const Cluster& c = unsortedClusters[iCluster];
         ClusterHelper& h = cHelper[iCluster];
-        float x = c.xCoordinate - mBeamPos[0];
-        float y = c.yCoordinate - mBeamPos[1];
-        const float& z = c.zCoordinate;
+
+        const float x = c.xCoordinate - mBeamPos[0];
+        const float y = c.yCoordinate - mBeamPos[1];
+        const float z = c.zCoordinate;
+
         float phi = math_utils::computePhi(x, y);
         int zBin{mIndexTableUtils.getZBinIndex(iLayer, z)};
-        if (zBin < 0) {
-          zBin = 0;
-          mBogusClusters[iLayer]++;
-        } else if (zBin >= trkParam.ZBins) {
-          zBin = trkParam.ZBins - 1;
+        if (zBin < 0 || zBin >= trkParam.ZBins) {
+          zBin = std::clamp(zBin, 0, trkParam.ZBins - 1);
           mBogusClusters[iLayer]++;
         }
         int bin = mIndexTableUtils.getBinIndex(zBin, mIndexTableUtils.getPhiBinIndex(phi));
@@ -252,28 +254,23 @@ void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, con
         h.bin = bin;
         h.ind = clsPerBin[bin]++;
       }
-      bounded_vector<int> lutPerBin(clsPerBin.size(), 0, mMemoryPool.get());
-      lutPerBin[0] = 0;
-      for (unsigned int iB{1}; iB < lutPerBin.size(); ++iB) {
-        lutPerBin[iB] = lutPerBin[iB - 1] + clsPerBin[iB - 1];
-      }
+      std::exclusive_scan(clsPerBin.begin(), clsPerBin.end(), lutPerBin.begin(), 0);
 
       auto clusters2beSorted{getClustersOnLayer(rof, iLayer)};
       for (int iCluster{0}; iCluster < clustersNum; ++iCluster) {
         const ClusterHelper& h = cHelper[iCluster];
-
         Cluster& c = clusters2beSorted[lutPerBin[h.bin] + h.ind];
+
         c = unsortedClusters[iCluster];
         c.phi = h.phi;
         c.radius = h.r;
         c.indexTableBinIndex = h.bin;
       }
-      for (int iB{0}; iB < (int)clsPerBin.size(); ++iB) {
-        mIndexTables[iLayer][rof * (trkParam.ZBins * trkParam.PhiBins + 1) + iB] = lutPerBin[iB];
-      }
-      for (auto iB{clsPerBin.size()}; iB < (trkParam.ZBins * trkParam.PhiBins + 1); iB++) {
-        mIndexTables[iLayer][rof * (trkParam.ZBins * trkParam.PhiBins + 1) + iB] = clustersNum;
-      }
+      std::copy_n(lutPerBin.data(), clsPerBin.size(), tableBase);
+      std::fill_n(tableBase + clsPerBin.size(), stride - clsPerBin.size(), clustersNum);
+
+      std::fill(clsPerBin.begin(), clsPerBin.end(), 0);
+      cHelper.clear();
     }
   }
 }
@@ -351,7 +348,7 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
   mPhiCuts.resize(mClusters.size() - 1, 0.f);
 
   float oneOverR{0.001f * 0.3f * std::abs(mBz) / trkParam.TrackletMinPt};
-  for (unsigned int iLayer{0}; iLayer < mClusters.size(); ++iLayer) {
+  for (unsigned int iLayer{0}; iLayer < nLayers; ++iLayer) {
     mMSangles[iLayer] = math_utils::MSangle(0.14f, trkParam.TrackletMinPt, trkParam.LayerxX0[iLayer]);
     mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
     if (iLayer < mClusters.size() - 1) {
@@ -441,14 +438,14 @@ void TimeFrame<nLayers>::checkTrackletLUTs()
       auto& trk = getTracklets()[iLayer][iTracklet];
       int currentId{trk.firstClusterIndex};
       if (currentId < prev) {
-        std::cout << "First Cluster Index not increasing monotonically on L:T:ID:Prev " << iLayer << "\t" << iTracklet << "\t" << currentId << "\t" << prev << std::endl;
+        LOG(info) << "First Cluster Index not increasing monotonically on L:T:ID:Prev " << iLayer << "\t" << iTracklet << "\t" << currentId << "\t" << prev;
       } else if (currentId == prev) {
         count++;
       } else {
         if (iLayer > 0) {
           auto& lut{getTrackletsLookupTable()[iLayer - 1]};
           if (count != lut[prev + 1] - lut[prev]) {
-            std::cout << "LUT count broken " << iLayer - 1 << "\t" << prev << "\t" << count << "\t" << lut[prev + 1] << "\t" << lut[prev] << std::endl;
+            LOG(info) << "LUT count broken " << iLayer - 1 << "\t" << prev << "\t" << count << "\t" << lut[prev + 1] << "\t" << lut[prev];
           }
         }
         count = 1;
@@ -457,7 +454,7 @@ void TimeFrame<nLayers>::checkTrackletLUTs()
       if (iLayer > 0) {
         auto& lut{getTrackletsLookupTable()[iLayer - 1]};
         if (iTracklet >= (uint32_t)(lut[currentId + 1]) || iTracklet < (uint32_t)(lut[currentId])) {
-          std::cout << "LUT broken: " << iLayer - 1 << "\t" << currentId << "\t" << iTracklet << std::endl;
+          LOG(info) << "LUT broken: " << iLayer - 1 << "\t" << currentId << "\t" << iTracklet;
         }
       }
     }
@@ -495,25 +492,25 @@ void TimeFrame<nLayers>::resetTracklets()
 template <int nLayers>
 void TimeFrame<nLayers>::printTrackletLUTonLayer(int i)
 {
-  std::cout << "--------" << std::endl
-            << "Tracklet LUT " << i << std::endl;
+  LOG(info) << "-------- Tracklet LUT " << i;
+  std::stringstream s;
   for (int j : mTrackletsLookupTable[i]) {
-    std::cout << j << "\t";
+    s << j << "\t";
   }
-  std::cout << "\n--------" << std::endl
-            << std::endl;
+  LOG(info) << s.str();
+  LOG(info) << "--------";
 }
 
 template <int nLayers>
 void TimeFrame<nLayers>::printCellLUTonLayer(int i)
 {
-  std::cout << "--------" << std::endl
-            << "Cell LUT " << i << std::endl;
+  LOG(info) << "-------- Cell LUT " << i;
+  std::stringstream s;
   for (int j : mCellsLookupTable[i]) {
-    std::cout << j << "\t";
+    s << j << "\t";
   }
-  std::cout << "\n--------" << std::endl
-            << std::endl;
+  LOG(info) << s.str();
+  LOG(info) << "--------";
 }
 
 template <int nLayers>
@@ -535,56 +532,58 @@ void TimeFrame<nLayers>::printCellLUTs()
 template <int nLayers>
 void TimeFrame<nLayers>::printVertices()
 {
-  std::cout << "Vertices in ROF (nROF = " << mNrof << ", lut size = " << mROFramesPV.size() << ")" << std::endl;
+  LOG(info) << "Vertices in ROF (nROF = " << mNrof << ", lut size = " << mROFramesPV.size() << ")";
   for (unsigned int iR{0}; iR < mROFramesPV.size(); ++iR) {
-    std::cout << mROFramesPV[iR] << "\t";
+    LOG(info) << mROFramesPV[iR] << "\t";
   }
-  std::cout << "\n\n Vertices:" << std::endl;
+  LOG(info) << "\n\n Vertices:";
   for (unsigned int iV{0}; iV < mPrimaryVertices.size(); ++iV) {
-    std::cout << mPrimaryVertices[iV].getX() << "\t" << mPrimaryVertices[iV].getY() << "\t" << mPrimaryVertices[iV].getZ() << std::endl;
+    LOG(info) << mPrimaryVertices[iV].getX() << "\t" << mPrimaryVertices[iV].getY() << "\t" << mPrimaryVertices[iV].getZ();
   }
-  std::cout << "--------" << std::endl;
+  LOG(info) << "--------";
 }
 
 template <int nLayers>
 void TimeFrame<nLayers>::printROFoffsets()
 {
-  std::cout << "--------" << std::endl;
+  LOG(info) << "--------";
   for (unsigned int iLayer{0}; iLayer < mROFramesClusters.size(); ++iLayer) {
-    std::cout << "Layer " << iLayer << std::endl;
+    LOG(info) << "Layer " << iLayer;
+    std::stringstream s;
     for (auto value : mROFramesClusters[iLayer]) {
-      std::cout << value << "\t";
+      s << value << "\t";
     }
-    std::cout << std::endl;
+    LOG(info) << s.str();
   }
 }
 
 template <int nLayers>
 void TimeFrame<nLayers>::printNClsPerROF()
 {
-  std::cout << "--------" << std::endl;
+  LOG(info) << "--------";
   for (unsigned int iLayer{0}; iLayer < mNClustersPerROF.size(); ++iLayer) {
-    std::cout << "Layer " << iLayer << std::endl;
+    LOG(info) << "Layer " << iLayer;
+    std::stringstream s;
     for (auto& value : mNClustersPerROF[iLayer]) {
-      std::cout << value << "\t";
+      s << value << "\t";
     }
-    std::cout << std::endl;
+    LOG(info) << s.str();
   }
 }
 
 template <int nLayers>
 void TimeFrame<nLayers>::printSliceInfo(const int startROF, const int sliceSize)
 {
-  std::cout << "Dumping slice of " << sliceSize << " rofs:" << std::endl;
+  LOG(info) << "Dumping slice of " << sliceSize << " rofs:";
   for (int iROF{startROF}; iROF < startROF + sliceSize; ++iROF) {
-    std::cout << "ROF " << iROF << " dump:" << std::endl;
+    LOG(info) << "ROF " << iROF << " dump:";
     for (unsigned int iLayer{0}; iLayer < mClusters.size(); ++iLayer) {
-      std::cout << "Layer " << iLayer << " has: " << getClustersOnLayer(iROF, iLayer).size() << " clusters." << std::endl;
+      LOG(info) << "Layer " << iLayer << " has: " << getClustersOnLayer(iROF, iLayer).size() << " clusters.";
     }
-    std::cout << "Number of seeding vertices: " << getPrimaryVertices(iROF).size() << std::endl;
+    LOG(info) << "Number of seeding vertices: " << getPrimaryVertices(iROF).size();
     int iVertex{0};
     for (auto& v : getPrimaryVertices(iROF)) {
-      std::cout << "\t vertex " << iVertex++ << ": x=" << v.getX() << " " << " y=" << v.getY() << " z=" << v.getZ() << " has " << v.getNContributors() << " contributors." << std::endl;
+      LOG(info) << "\t vertex " << iVertex++ << ": x=" << v.getX() << " " << " y=" << v.getY() << " z=" << v.getZ() << " has " << v.getNContributors() << " contributors.";
     }
   }
 }
@@ -645,8 +644,6 @@ void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource>& p
   initVectors(mTracks);
   initVectors(mTracklets);
   initVectors(mCells);
-  initVectors(mCellSeeds);
-  initVectors(mCellSeedsChi2);
   initVectors(mCellsNeighbours);
   initVectors(mCellsLookupTable);
 }
@@ -658,8 +655,6 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mTracks);
   deepVectorClear(mTracklets);
   deepVectorClear(mCells);
-  deepVectorClear(mCellSeeds);
-  deepVectorClear(mCellSeedsChi2);
   deepVectorClear(mRoads);
   deepVectorClear(mCellsNeighbours);
   deepVectorClear(mCellsLookupTable);
@@ -687,6 +682,7 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mPValphaX);
   deepVectorClear(mBogusClusters);
   deepVectorClear(mTrackletsIndexROF);
+  deepVectorClear(mPrimaryVertices);
 }
 
 template class TimeFrame<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index f4da1a86818bb..c92d1e8505356 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -79,7 +79,7 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
       double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
       int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
       int nROFsIterations = mTrkParams[iteration].nROFsPerIterations > 0 ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
-      int iVertex{std::min(maxNvertices, 0)};
+      iVertex = std::min(maxNvertices, 0);
       logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
 
       total += evaluateTask(&Tracker::initialiseTimeFrame, StateNames[mCurState = TFInit], iteration, logger, iteration);
@@ -105,8 +105,7 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
           nNeighbours += mTimeFrame->getNumberOfNeighbours();
           timeRoads += evaluateTask(&Tracker::findRoads, StateNames[mCurState = Roading], iteration, evalLog, iteration);
         }
-        iVertex++;
-      } while (iVertex < maxNvertices);
+      } while (++iVertex < maxNvertices);
       logger(std::format(" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
       logger(std::format(" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
       logger(std::format(" - Neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 05b2ec57ecc6d..c70108b4f8a30 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -322,43 +322,45 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       mTracker->clustersToTracks(logger, errorLogger);
     }
     size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
-    allTracks.reserve(totTracks);
-    allClusIdx.reserve(totClusIDs);
+    if (totTracks) {
+      allTracks.reserve(totTracks);
+      allClusIdx.reserve(totClusIDs);
 
-    if (mTimeFrame->hasBogusClusters()) {
-      LOG(warning) << fmt::format(" - The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
-    }
-
-    for (unsigned int iROF{0}; iROF < trackROFvec.size(); ++iROF) {
-      auto& tracksROF{trackROFvec[iROF]};
-      auto& vtxROF = vertROFvec[iROF];
-      auto& tracks = mTimeFrame->getTracks(iROF);
-      auto number{tracks.size()};
-      auto first{allTracks.size()};
-      int offset = -tracksROF.getFirstEntry(); // cluster entry!!!
-      tracksROF.setFirstEntry(first);
-      tracksROF.setNEntries(number);
-      tracksROF.setFlags(vtxROF.getFlags()); // copies 0xffffffff if cosmics
-      if (processingMask[iROF]) {
-        irFrames.emplace_back(tracksROF.getBCData(), tracksROF.getBCData() + nBCPerTF - 1).info = tracks.size();
+      if (mTimeFrame->hasBogusClusters()) {
+        LOG(warning) << fmt::format(" - The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
       }
-      allTrackLabels.reserve(mTimeFrame->getTracksLabel(iROF).size()); // should be 0 if not MC
-      std::copy(mTimeFrame->getTracksLabel(iROF).begin(), mTimeFrame->getTracksLabel(iROF).end(), std::back_inserter(allTrackLabels));
-      // Some conversions that needs to be moved in the tracker internals
-      for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
-        auto& trc{tracks[iTrk]};
-        trc.setFirstClusterEntry(allClusIdx.size()); // before adding tracks, create final cluster indices
-        int ncl = trc.getNumberOfClusters(), nclf = 0;
-        for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
-          auto clid = trc.getClusterIndex(ic);
-          if (clid >= 0) {
-            trc.setClusterSize(ic, mTimeFrame->getClusterSize(clid));
-            allClusIdx.push_back(clid);
-            nclf++;
+
+      for (unsigned int iROF{0}; iROF < trackROFvec.size(); ++iROF) {
+        auto& tracksROF{trackROFvec[iROF]};
+        auto& vtxROF = vertROFvec[iROF];
+        auto& tracks = mTimeFrame->getTracks(iROF);
+        auto number{tracks.size()};
+        auto first{allTracks.size()};
+        int offset = -tracksROF.getFirstEntry(); // cluster entry!!!
+        tracksROF.setFirstEntry(first);
+        tracksROF.setNEntries(number);
+        tracksROF.setFlags(vtxROF.getFlags()); // copies 0xffffffff if cosmics
+        if (processingMask[iROF]) {
+          irFrames.emplace_back(tracksROF.getBCData(), tracksROF.getBCData() + nBCPerTF - 1).info = tracks.size();
+        }
+        allTrackLabels.reserve(mTimeFrame->getTracksLabel(iROF).size()); // should be 0 if not MC
+        std::copy(mTimeFrame->getTracksLabel(iROF).begin(), mTimeFrame->getTracksLabel(iROF).end(), std::back_inserter(allTrackLabels));
+        // Some conversions that needs to be moved in the tracker internals
+        for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
+          auto& trc{tracks[iTrk]};
+          trc.setFirstClusterEntry(allClusIdx.size()); // before adding tracks, create final cluster indices
+          int ncl = trc.getNumberOfClusters(), nclf = 0;
+          for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
+            auto clid = trc.getClusterIndex(ic);
+            if (clid >= 0) {
+              trc.setClusterSize(ic, mTimeFrame->getClusterSize(clid));
+              allClusIdx.push_back(clid);
+              nclf++;
+            }
           }
+          assert(ncl == nclf);
+          allTracks.emplace_back(trc);
         }
-        assert(ncl == nclf);
-        allTracks.emplace_back(trc);
       }
     }
     LOGP(info, "ITSTracker pushed {} tracks and {} vertices", allTracks.size(), vertices.size());

From ad4cc98f67cebe5ef7fb56be8ac56dee76ee578b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 12 Jun 2025 09:28:46 +0200
Subject: [PATCH 0483/1764] Add compatibility with std::pmr (#14379)

The move assign operator is deleted is std::pmr::polymorphic_allocator so we cannot iterate
anymore at runtime on the headers in the stack and move them.
---
 .../include/DataSampling/Dispatcher.h         |  1 -
 Utilities/DataSampling/src/Dispatcher.cxx     | 54 +++++++++++++------
 2 files changed, 38 insertions(+), 17 deletions(-)

diff --git a/Utilities/DataSampling/include/DataSampling/Dispatcher.h b/Utilities/DataSampling/include/DataSampling/Dispatcher.h
index 1d34269f87536..c38ece1436bc0 100644
--- a/Utilities/DataSampling/include/DataSampling/Dispatcher.h
+++ b/Utilities/DataSampling/include/DataSampling/Dispatcher.h
@@ -65,7 +65,6 @@ class Dispatcher : public framework::Task
 
  private:
   DataSamplingHeader prepareDataSamplingHeader(const DataSamplingPolicy& policy, header::DataHeader const& original);
-  header::Stack extractAdditionalHeaders(const char* inputHeaderStack) const;
   void reportStats(monitoring::Monitoring& monitoring) const;
   void send(framework::DataAllocator& dataAllocator, const framework::DataRef& inputData, const framework::Output& output) const;
 
diff --git a/Utilities/DataSampling/src/Dispatcher.cxx b/Utilities/DataSampling/src/Dispatcher.cxx
index 38ad15f5fd752..bc79be2771316 100644
--- a/Utilities/DataSampling/src/Dispatcher.cxx
+++ b/Utilities/DataSampling/src/Dispatcher.cxx
@@ -29,6 +29,7 @@
 
 #include <Configuration/ConfigurationInterface.h>
 #include <Configuration/ConfigurationFactory.h>
+#include <stdexcept>
 
 using namespace o2::configuration;
 using namespace o2::monitoring;
@@ -77,6 +78,42 @@ void Dispatcher::init(InitContext& ctx)
   mDeviceID.runtimeInit(spec.id.substr(0, DataSamplingHeader::deviceIDTypeSize).c_str());
 }
 
+header::Stack extractAdditionalHeaders(const char* inputHeaderStack)
+{
+  std::array<header::BaseHeader const*, 5> headers;
+  int count = 0;
+  const auto* first = header::BaseHeader::get(reinterpret_cast<const std::byte*>(inputHeaderStack));
+  for (const auto* current = first; current != nullptr; current = current->next()) {
+    if (current->description != header::DataHeader::sHeaderType && current->description != DataProcessingHeader::sHeaderType) {
+      headers[count++] = current;
+    }
+  }
+
+  // Poor man runtime pack expansion.
+  switch (count) {
+    case 0:
+      return header::Stack{};
+    case 1:
+      return header::Stack{*headers[0]};
+    case 2:
+      return header::Stack{*headers[0], *headers[1]};
+    case 3:
+      return header::Stack{*headers[0], *headers[1], *headers[2]};
+    case 4:
+      return header::Stack{*headers[0], *headers[1], *headers[2], *headers[3]};
+    case 5:
+      return header::Stack{*headers[0], *headers[1], *headers[2], *headers[3], *headers[4]};
+    case 6:
+      return header::Stack{*headers[0], *headers[1], *headers[2], *headers[3], *headers[4], *headers[5]};
+    case 7:
+      return header::Stack{*headers[0], *headers[1], *headers[2], *headers[3], *headers[4], *headers[5], *headers[6]};
+    case 8:
+      return header::Stack{*headers[0], *headers[1], *headers[2], *headers[3], *headers[4], *headers[5], *headers[6], *headers[7]};
+    default:
+      throw std::runtime_error(fmt::format("Too many headers to copy {}", count));
+  }
+}
+
 void Dispatcher::run(ProcessingContext& ctx)
 {
   // todo: consider matching (and deciding) in completion policy to save some time
@@ -106,7 +143,7 @@ void Dispatcher::run(ProcessingContext& ctx)
             // so that custom data-dependent headers are passed forward,
             // and we add a DataSamplingHeader.
             header::Stack headerStack{
-              std::move(extractAdditionalHeaders(part.header)),
+              extractAdditionalHeaders(part.header),
               dsheader};
             const auto* partInputHeader = DataRefUtils::getHeader<header::DataHeader*>(part);
 
@@ -156,21 +193,6 @@ DataSamplingHeader Dispatcher::prepareDataSamplingHeader(const DataSamplingPolic
     original};
 }
 
-header::Stack Dispatcher::extractAdditionalHeaders(const char* inputHeaderStack) const
-{
-  header::Stack headerStack;
-
-  const auto* first = header::BaseHeader::get(reinterpret_cast<const std::byte*>(inputHeaderStack));
-  for (const auto* current = first; current != nullptr; current = current->next()) {
-    if (current->description != header::DataHeader::sHeaderType &&
-        current->description != DataProcessingHeader::sHeaderType) {
-      headerStack = std::move(header::Stack{std::move(headerStack), *current});
-    }
-  }
-
-  return headerStack;
-}
-
 void Dispatcher::send(DataAllocator& dataAllocator, const DataRef& inputData, const Output& output) const
 {
   const auto* inputHeader = DataRefUtils::getHeader<header::DataHeader*>(inputData);

From dbacf7b1c659b7a18690f2616e20ed9c8f36502b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 12 Jun 2025 17:12:03 +0200
Subject: [PATCH 0484/1764] Remove references to boost::container::pmr (#14395)

Use fair::mq::pmr instead, so that we can then easily migrate fair::mq to std::pmr
while still having backward compatibility.
---
 DataFormats/Headers/include/Headers/Stack.h   | 32 ++++++++-----------
 DataFormats/Headers/test/testDataHeader.cxx   |  8 ++---
 .../include/MemoryResources/MemoryResources.h | 18 +++++------
 .../test/testMemoryResources.cxx              |  2 +-
 Framework/Core/include/Framework/Output.h     | 11 ++-----
 Framework/Core/test/test_FairMQ.cxx           |  2 +-
 6 files changed, 31 insertions(+), 42 deletions(-)

diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index 259a445f18cf8..40987c483e1b8 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -14,10 +14,7 @@
 #include "MemoryResources/MemoryResources.h"
 #include "Headers/DataHeader.h"
 
-namespace o2
-{
-
-namespace header
+namespace o2::header
 {
 //__________________________________________________________________________________________________
 /// @struct Stack
@@ -45,20 +42,20 @@ struct Stack {
   };
 
  public:
-  using allocator_type = boost::container::pmr::polymorphic_allocator<std::byte>;
+  using allocator_type = fair::mq::pmr::polymorphic_allocator<std::byte>;
   using value_type = std::byte;
-  using BufferType = std::unique_ptr<value_type[], freeobj>; //this gives us proper default move semantics for free
+  using BufferType = std::unique_ptr<value_type[], freeobj>; // this gives us proper default move semantics for free
 
   Stack() = default;
   Stack(Stack&&) = default;
   Stack(Stack&) = delete;
   Stack& operator=(Stack&) = delete;
-  Stack& operator=(Stack&&) = default;
+  Stack& operator=(Stack&&) = delete;
 
-  value_type* data() const { return buffer.get(); }
-  size_t size() const { return bufferSize; }
+  [[nodiscard]] value_type* data() const { return buffer.get(); }
+  [[nodiscard]] size_t size() const { return bufferSize; }
   allocator_type get_allocator() const { return allocator; }
-  const BaseHeader* first() const { return reinterpret_cast<const BaseHeader*>(this->data()); }
+  [[nodiscard]] const BaseHeader* first() const { return reinterpret_cast<const BaseHeader*>(this->data()); }
   static const BaseHeader* firstHeader(std::byte const* buf) { return BaseHeader::get(buf); }
   static const BaseHeader* lastHeader(std::byte const* buf)
   {
@@ -90,9 +87,9 @@ struct Stack {
   /// all headers must derive from BaseHeader, in addition also other stacks can be passed to ctor.
   template <typename FirstArgType, typename... Headers,
             typename std::enable_if_t<
-              !std::is_convertible<FirstArgType, boost::container::pmr::polymorphic_allocator<std::byte>>::value, int> = 0>
+              !std::is_convertible<FirstArgType, fair::mq::pmr::polymorphic_allocator<std::byte>>::value, int> = 0>
   Stack(FirstArgType&& firstHeader, Headers&&... headers)
-    : Stack(boost::container::pmr::new_delete_resource(), std::forward<FirstArgType>(firstHeader),
+    : Stack(fair::mq::pmr::new_delete_resource(), std::forward<FirstArgType>(firstHeader),
             std::forward<Headers>(headers)...)
   {
   }
@@ -122,7 +119,7 @@ struct Stack {
   template <typename T>
   constexpr static size_t calculateSize(T&& h) noexcept
   {
-    //if it's a pointer (to a stack) traverse it
+    // if it's a pointer (to a stack) traverse it
     if constexpr (std::is_convertible_v<T, std::byte*>) {
       const BaseHeader* next = BaseHeader::get(std::forward<T>(h));
       if (!next) {
@@ -133,17 +130,17 @@ struct Stack {
         size += next->size();
       }
       return size;
-      //otherwise get the size directly
+      // otherwise get the size directly
     } else {
       return h.size();
     }
   }
 
-  //recursion terminator
+  // recursion terminator
   constexpr static size_t calculateSize() { return 0; }
 
  private:
-  allocator_type allocator{boost::container::pmr::new_delete_resource()};
+  allocator_type allocator{fair::mq::pmr::new_delete_resource()};
   size_t bufferSize{0};
   BufferType buffer{nullptr, freeobj{allocator.resource()}};
 
@@ -231,7 +228,6 @@ struct Stack {
   }
 };
 
-} // namespace header
-} // namespace o2
+} // namespace o2::header
 
 #endif // HEADERS_STACK_H
diff --git a/DataFormats/Headers/test/testDataHeader.cxx b/DataFormats/Headers/test/testDataHeader.cxx
index 0703fc6c3ae71..2403c1a6230be 100644
--- a/DataFormats/Headers/test/testDataHeader.cxx
+++ b/DataFormats/Headers/test/testDataHeader.cxx
@@ -280,8 +280,8 @@ BOOST_AUTO_TEST_CASE(headerStack_test)
   Stack s2{s1, meta};
   BOOST_CHECK(s2.size() == s1.size() + sizeof(decltype(meta)));
 
-  //check dynamic construction - where we don't have the type information and need to
-  //work with BaseHeader pointers
+  // check dynamic construction - where we don't have the type information and need to
+  // work with BaseHeader pointers
   const test::MetaHeader thead{2};
   o2::header::BaseHeader const* bname = reinterpret_cast<BaseHeader const*>(&thead);
   Stack ds2(s1, *bname);
@@ -313,8 +313,8 @@ BOOST_AUTO_TEST_CASE(headerStack_test)
   BOOST_REQUIRE(h3 != nullptr);
   BOOST_CHECK(h3->secret == 42);
 
-  //test constructing from a buffer and an additional header
-  using namespace boost::container::pmr;
+  // test constructing from a buffer and an additional header
+  using namespace fair::mq::pmr;
   Stack s5(new_delete_resource(), s1.data(), Stack{}, meta);
   BOOST_CHECK(s5.size() == s1.size() + sizeof(meta));
   // check if we can find the header even though there was an empty stack in the middle
diff --git a/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h b/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
index 42dd69aff38e3..eba309e38ad83 100644
--- a/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
+++ b/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
@@ -115,7 +115,7 @@ class MessageResource : public FairMQMemoryResource
 // A spectator pmr memory resource which only watches the memory of the underlying buffer, does not
 // carry out real allocation. It owns the underlying buffer which is destroyed on deallocation.
 template <typename BufferType>
-class SpectatorMemoryResource : public boost::container::pmr::memory_resource
+class SpectatorMemoryResource : public fair::mq::pmr::memory_resource
 {
  public:
   using buffer_type = BufferType;
@@ -183,10 +183,10 @@ class SpectatorMemoryResource : public boost::container::pmr::memory_resource
 // This in general (as in STL) is a bad idea, but here it is safe to inherit from an allocator since we
 // have no additional data and only override some methods so we don't get into slicing and other problems.
 template <typename T>
-class SpectatorAllocator : public boost::container::pmr::polymorphic_allocator<T>
+class SpectatorAllocator : public fair::mq::pmr::polymorphic_allocator<T>
 {
  public:
-  using boost::container::pmr::polymorphic_allocator<T>::polymorphic_allocator;
+  using fair::mq::pmr::polymorphic_allocator<T>::polymorphic_allocator;
   using propagate_on_container_move_assignment = std::true_type;
 
   // skip default construction of empty elements
@@ -243,7 +243,7 @@ class OwningMessageSpectatorAllocator
     return OwningMessageSpectatorAllocator();
   }
 
-  boost::container::pmr::memory_resource* resource() { return &mResource; }
+  fair::mq::pmr::memory_resource* resource() { return &mResource; }
 
   // skip default construction of empty elements
   // this is important for two reasons: one: it allows us to adopt an existing buffer (e.g. incoming message) and
@@ -269,14 +269,14 @@ class OwningMessageSpectatorAllocator
 
 // The NoConstructAllocator behaves like the normal pmr vector but does not call constructors / destructors
 template <typename T>
-class NoConstructAllocator : public boost::container::pmr::polymorphic_allocator<T>
+class NoConstructAllocator : public fair::mq::pmr::polymorphic_allocator<T>
 {
  public:
-  using boost::container::pmr::polymorphic_allocator<T>::polymorphic_allocator;
+  using fair::mq::pmr::polymorphic_allocator<T>::polymorphic_allocator;
   using propagate_on_container_move_assignment = std::true_type;
 
   template <typename... Args>
-  NoConstructAllocator(Args&&... args) : boost::container::pmr::polymorphic_allocator<T>(std::forward<Args>(args)...)
+  NoConstructAllocator(Args&&... args) : fair::mq::pmr::polymorphic_allocator<T>(std::forward<Args>(args)...)
   {
   }
 
@@ -302,9 +302,9 @@ class NoConstructAllocator : public boost::container::pmr::polymorphic_allocator
 //__________________________________________________________________________________________________
 
 using ByteSpectatorAllocator = SpectatorAllocator<std::byte>;
-using BytePmrAllocator = boost::container::pmr::polymorphic_allocator<std::byte>;
+using BytePmrAllocator = fair::mq::pmr::polymorphic_allocator<std::byte>;
 template <class T>
-using vector = std::vector<T, o2::pmr::polymorphic_allocator<T>>;
+using vector = std::vector<T, fair::mq::pmr::polymorphic_allocator<T>>;
 
 //__________________________________________________________________________________________________
 /// Return a std::vector spanned over the contents of the message, takes ownership of the message
diff --git a/DataFormats/MemoryResources/test/testMemoryResources.cxx b/DataFormats/MemoryResources/test/testMemoryResources.cxx
index 264fe59b1caac..6bbafa3a82f4f 100644
--- a/DataFormats/MemoryResources/test/testMemoryResources.cxx
+++ b/DataFormats/MemoryResources/test/testMemoryResources.cxx
@@ -60,7 +60,7 @@ BOOST_AUTO_TEST_CASE(transportallocatormap_test)
   BOOST_CHECK(_tmp == allocZMQ);
 }
 
-using namespace boost::container::pmr;
+using namespace fair::mq::pmr;
 
 BOOST_AUTO_TEST_CASE(allocator_test)
 {
diff --git a/Framework/Core/include/Framework/Output.h b/Framework/Core/include/Framework/Output.h
index a2abf5f7600a9..73b04c56f3c4d 100644
--- a/Framework/Core/include/Framework/Output.h
+++ b/Framework/Core/include/Framework/Output.h
@@ -59,14 +59,7 @@ struct Output {
 
   Output& operator=(const Output&) = delete;
 
-  Output& operator=(Output&& rhs)
-  {
-    origin = rhs.origin;
-    description = rhs.description;
-    subSpec = rhs.subSpec;
-    metaHeader = std::move(rhs.metaHeader);
-    return *this;
-  }
+  Output& operator=(Output&& rhs) = delete;
 
   bool operator==(const Output& that) const
   {
@@ -74,5 +67,5 @@ struct Output {
   }
 };
 
-} // namespace o2
+} // namespace o2::framework
 #endif
diff --git a/Framework/Core/test/test_FairMQ.cxx b/Framework/Core/test/test_FairMQ.cxx
index 0ccfbf58f7576..f11d98505298f 100644
--- a/Framework/Core/test/test_FairMQ.cxx
+++ b/Framework/Core/test/test_FairMQ.cxx
@@ -174,7 +174,7 @@ TEST_CASE("addDataBlockForEach_test")
       int i;
       int j;
     };
-    using namespace boost::container::pmr;
+    using namespace fair::mq::pmr;
     fair::mq::Parts message;
     std::vector<elem, polymorphic_allocator<elem>> vec(polymorphic_allocator<elem>{allocZMQ});
     vec.reserve(100);

From c4bca1460aabde0594cc19b6de6715852ff18475 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Thu, 12 Jun 2025 11:36:20 +0200
Subject: [PATCH 0485/1764] Improve exit handling of O2HitMerger

So far, the exit status of O2HitMerger was not analysed.
This could lead to situations where O2HitMerger was killed by the OS
due to out-of-memory, yet the o2-sim simulator still exited as "successfull".

This commit improves the handling. Problems in O2HitMerger will lead
to exit code 1 of o2-sim.
---
 run/O2HitMerger.h      | 11 -----------
 run/o2sim_parallel.cxx | 27 ++++++++++++++++++++++++++-
 2 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/run/O2HitMerger.h b/run/O2HitMerger.h
index c2a094bfc9e54..520873e7aaafe 100644
--- a/run/O2HitMerger.h
+++ b/run/O2HitMerger.h
@@ -87,15 +87,6 @@ namespace o2
 namespace devices
 {
 
-// signal handler
-void sighandler(int signal)
-{
-  if (signal == SIGSEGV) {
-    LOG(warn) << "segmentation violation ... just exit without coredump in order not to hang";
-    raise(SIGKILL);
-  }
-}
-
 class O2HitMerger : public fair::mq::Device
 {
 
@@ -130,7 +121,6 @@ class O2HitMerger : public fair::mq::Device
   void InitTask() final
   {
     LOG(info) << "INIT HIT MERGER";
-    // signal(SIGSEGV, sighandler);
     ROOT::EnableThreadSafety();
 
     std::string outfilename("o2sim_merged_hits.root"); // default name
@@ -764,7 +754,6 @@ class O2HitMerger : public fair::mq::Device
         eventheader->putInfo("prims_eta_0.8_pi", eta0Point8CounterPi);
         eventheader->putInfo("prims_total", prims);
       };
-
       reorderAndMergeMCTracks(flusheventID, mOutTree, nprimaries, subevOrdered, mcheaderhook, eventheader);
 
       if (mOutTree) {
diff --git a/run/o2sim_parallel.cxx b/run/o2sim_parallel.cxx
index 3e28428938b20..22c6b37e6d9aa 100644
--- a/run/o2sim_parallel.cxx
+++ b/run/o2sim_parallel.cxx
@@ -732,7 +732,12 @@ int main(int argc, char* argv[])
   int status, cpid;
   // wait just blocks and waits until any child returns; but we make sure to wait until merger is here
   bool errored = false;
-  while ((cpid = wait(&status)) != mergerpid) {
+  // wait at least until mergerpid is reaped
+  while ((cpid = wait(&status)) != -1) {
+    if (cpid == mergerpid) {
+      break; // Defer handling of mergerpid exit status until after the loop
+    }
+
     if (WEXITSTATUS(status) || WIFSIGNALED(status)) {
       if (!shutdown_initiated) {
         LOG(info) << "Process " << cpid << " EXITED WITH CODE " << WEXITSTATUS(status) << " SIGNALED "
@@ -753,6 +758,26 @@ int main(int argc, char* argv[])
       }
     }
   }
+
+  // Handle mergerpid status separately
+  if (cpid == mergerpid) {
+    if (WIFEXITED(status)) {
+      // anything other than 128 is indicative of error
+      if (WEXITSTATUS(status) != 128) {
+        LOG(error) << "Merger process exited with abnormal code " << WEXITSTATUS(status);
+        errored = true;
+      }
+    } else if (WIFSIGNALED(status)) {
+      auto sig = WTERMSIG(status);
+      if (sig == SIGKILL || sig == SIGBUS || sig == SIGSEGV || sig == SIGABRT) {
+        LOG(error) << "Merger process terminated through abnormal signal " << WTERMSIG(status);
+        errored = true;
+      }
+    } else {
+      LOG(warning) << "Merger process exited with unexpected status.";
+    }
+  }
+
   // This marks the actual end of the computation (since results are available)
   LOG(info) << "Merger process " << mergerpid << " returned";
   LOG(info) << "Simulation process took " << timer.RealTime() << " s";

From 121ee3ab45981e61fddb850852ff4ace8bcaee73 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 13 Jun 2025 11:05:36 +0200
Subject: [PATCH 0486/1764] Export tuple to avoid IWYU adding it everywhere
 (#14403)

---
 Framework/Core/include/Framework/AnalysisTask.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index b53929f326712..30b31ea4799f5 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -33,6 +33,8 @@
 #include <type_traits>
 #include <utility>
 #include <memory>
+#include <tuple> // IWYU pragma: export
+
 namespace o2::framework
 {
 /// A more familiar task API for the DPL analysis framework.

From 73bc03d1e9d5568983a86d02efa31858cfe9b616 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Thu, 12 Jun 2025 14:51:40 +0200
Subject: [PATCH 0487/1764] TPC: changing uint64_t to unsigned long long for
 compatibility with Mac

---
 .../Detectors/TPC/include/DataFormatsTPC/DCS.h   |  4 ++--
 DataFormats/Detectors/TPC/src/DCS.cxx            |  2 +-
 .../TPCCalibration/PressureTemperatureHelper.h   | 16 ++++++++--------
 .../src/PressureTemperatureHelper.cxx            |  8 ++++----
 .../workflow/src/TPCPressureTemperatureSpec.cxx  |  2 +-
 5 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/DCS.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/DCS.h
index 3608fdc390203..d40b07c48e314 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/DCS.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/DCS.h
@@ -557,13 +557,13 @@ struct RobustPressure {
   Stats cavernAtmosPressure2S;       ///< rolling statistics of cavernAtmosPressure2/surfaceAtmosPressure
   std::vector<uint8_t> isOk;         ///< bit mask of valid sensors: cavernBit 0, cavern2Bit = 1, surfaceBit = 2
   std::vector<float> robustPressure; ///< combined robust pressure value that should be used
-  std::vector<TimeStampType> time;   ///< time stamps of all pressure values
+  std::vector<ULong64_t> time;       ///< time stamps of all pressure values
   TimeStampType timeInterval;        ///< time interval used for rolling statistics
   TimeStampType timeIntervalRef;     ///< reference time interval used for normalization of pressure sensors
   float maxDist{};                   ///< maximum allowed time distance between sensors to be accepted for robust pressure calculation
   float maxDiff{0.2f};               ///< maximum allowed pressure difference between sensors to be accepted for robust pressure calculation
 
-  ClassDefNV(RobustPressure, 1);
+  ClassDefNV(RobustPressure, 2);
 };
 
 struct Pressure {
diff --git a/DataFormats/Detectors/TPC/src/DCS.cxx b/DataFormats/Detectors/TPC/src/DCS.cxx
index 3c2524b6ed0fe..14c3887f8e8ae 100644
--- a/DataFormats/Detectors/TPC/src/DCS.cxx
+++ b/DataFormats/Detectors/TPC/src/DCS.cxx
@@ -357,7 +357,7 @@ void Pressure::makeRobustPressure(TimeStampType timeInterval, TimeStampType time
   if (nIntervals == 0) {
     nIntervals = 1; // at least one interval
   }
-  std::vector<TimeStampType> times;
+  std::vector<ULong64_t> times;
   times.reserve(nIntervals);
   for (int i = 0; i < nIntervals; ++i) {
     times.emplace_back(tStart + (i + 0.5) * timeInterval);
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
index b636fdd2f296d..671c2efb78a8f 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
@@ -49,7 +49,7 @@ class PressureTemperatureHelper
   static void setOutputs(std::vector<o2::framework::OutputSpec>& outputs);
 
   /// send temperature and pressure for given time stamp
-  void sendPTForTS(o2::framework::ProcessingContext& pc, const uint64_t timestamp) const;
+  void sendPTForTS(o2::framework::ProcessingContext& pc, const ULong64_t timestamp) const;
 
   /// set fit interval range for temperature in ms
   void setFitIntervalTemp(const int fitIntervalMS) { mFitIntervalMS = fitIntervalMS; }
@@ -58,13 +58,13 @@ class PressureTemperatureHelper
   /// \param timestamps time stamps of the data
   /// \param values data points
   /// \param timestamp time where to interpolate the values
-  float interpolate(const std::vector<uint64_t>& timestamps, const std::vector<float>& values, uint64_t timestamp) const;
+  float interpolate(const std::vector<ULong64_t>& timestamps, const std::vector<float>& values, ULong64_t timestamp) const;
 
   /// get pressure for given time stamp in ms
-  float getPressure(const uint64_t timestamp) const { return interpolate(mPressure.second, mPressure.first, timestamp); }
+  float getPressure(const ULong64_t timestamp) const { return interpolate(mPressure.second, mPressure.first, timestamp); }
 
   /// get temperature for given time stamp in ms
-  dataformats::Pair<float, float> getTemperature(const uint64_t timestamp) const { return dataformats::Pair<float, float>{interpolate(mTemperatureA.second, mTemperatureA.first, timestamp), interpolate(mTemperatureC.second, mTemperatureC.first, timestamp)}; }
+  dataformats::Pair<float, float> getTemperature(const ULong64_t timestamp) const { return dataformats::Pair<float, float>{interpolate(mTemperatureA.second, mTemperatureA.first, timestamp), interpolate(mTemperatureC.second, mTemperatureC.first, timestamp)}; }
 
   static constexpr o2::header::DataDescription getDataDescriptionPressure() { return o2::header::DataDescription{"pressure"}; }
   static constexpr o2::header::DataDescription getDataDescriptionTemperature() { return o2::header::DataDescription{"temperature"}; }
@@ -73,10 +73,10 @@ class PressureTemperatureHelper
   static void addInput(std::vector<o2::framework::InputSpec>& inputs, o2::framework::InputSpec&& isp);
   static void addOutput(std::vector<o2::framework::OutputSpec>& outputs, o2::framework::OutputSpec&& osp);
 
-  std::pair<std::vector<float>, std::vector<uint64_t>> mPressure;     ///< pressure values for both measurements
-  std::pair<std::vector<float>, std::vector<uint64_t>> mTemperatureA; ///< temperature values A-side
-  std::pair<std::vector<float>, std::vector<uint64_t>> mTemperatureC; ///< temperature values C-side
-  int mFitIntervalMS{5 * 60 * 1000};                                  ///< fit interval for the temperature
+  std::pair<std::vector<float>, std::vector<ULong64_t>> mPressure;     ///< pressure values for both measurements
+  std::pair<std::vector<float>, std::vector<ULong64_t>> mTemperatureA; ///< temperature values A-side
+  std::pair<std::vector<float>, std::vector<ULong64_t>> mTemperatureC; ///< temperature values C-side
+  int mFitIntervalMS{5 * 60 * 1000};                                   ///< fit interval for the temperature
 
   ClassDefNV(PressureTemperatureHelper, 1);
 };
diff --git a/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx b/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
index 54145f0ecfaf1..d9a55e4aed2b9 100644
--- a/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
+++ b/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
@@ -91,13 +91,13 @@ void PressureTemperatureHelper::addOutput(std::vector<OutputSpec>& outputs, Outp
   }
 }
 
-float PressureTemperatureHelper::interpolate(const std::vector<uint64_t>& timestamps, const std::vector<float>& values, uint64_t timestamp) const
+float PressureTemperatureHelper::interpolate(const std::vector<ULong64_t>& timestamps, const std::vector<float>& values, ULong64_t timestamp) const
 {
   if (auto idxClosest = o2::math_utils::findClosestIndices(timestamps, timestamp)) {
     auto [idxLeft, idxRight] = *idxClosest;
     if (idxRight > idxLeft) {
-      const uint64_t x0 = timestamps[idxLeft];
-      const uint64_t x1 = timestamps[idxRight];
+      const auto x0 = timestamps[idxLeft];
+      const auto x1 = timestamps[idxRight];
       const float y0 = values[idxLeft];
       const float y1 = values[idxRight];
       const float y = (y0 * (x1 - timestamp) + y1 * (timestamp - x0)) / (x1 - x0);
@@ -109,7 +109,7 @@ float PressureTemperatureHelper::interpolate(const std::vector<uint64_t>& timest
   return 0; // this should never happen
 }
 
-void PressureTemperatureHelper::sendPTForTS(o2::framework::ProcessingContext& pc, const uint64_t timestamp) const
+void PressureTemperatureHelper::sendPTForTS(o2::framework::ProcessingContext& pc, const ULong64_t timestamp) const
 {
   const float pressure = getPressure(timestamp);
   const auto temp = getTemperature(timestamp);
diff --git a/Detectors/TPC/workflow/src/TPCPressureTemperatureSpec.cxx b/Detectors/TPC/workflow/src/TPCPressureTemperatureSpec.cxx
index e03a0ffe4308b..4cb25471b55f8 100644
--- a/Detectors/TPC/workflow/src/TPCPressureTemperatureSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCPressureTemperatureSpec.cxx
@@ -57,7 +57,7 @@ class PressureTemperatureDevice : public o2::framework::Task
     mPTHelper.extractCCDBInputs(pc);
     const auto orbitResetTimeMS = o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS();
     const auto firstTFOrbit = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
-    const uint64_t timestamp = orbitResetTimeMS + firstTFOrbit * o2::constants::lhc::LHCOrbitMUS * 0.001;
+    const ULong64_t timestamp = orbitResetTimeMS + firstTFOrbit * o2::constants::lhc::LHCOrbitMUS * 0.001;
     mPTHelper.sendPTForTS(pc, timestamp);
 
     if (mStreamer) {

From b0a856379ccf01cbb8cf5ec7ddb6f4cad939c1ca Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 10 Jun 2025 11:48:56 +0200
Subject: [PATCH 0488/1764] Add some more O2 settings to --setO2Settings of
 standalone benchmark

---
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 95997a30034c9..792f72220e597 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -223,6 +223,14 @@ int32_t ReadConfiguration(int argc, char** argv)
     configStandalone.rec.tpc.nWaysOuter = 1;
     configStandalone.rec.tpc.trackReferenceX = 83;
     configStandalone.proc.outputSharedClusterMap = 1;
+    configStandalone.proc.clearO2OutputFromGPU = 1;
+    configStandalone.QA.clusterRejectionHistograms = 1;
+    configStandalone.proc.tpcIncreasedMinClustersPerRow = 500000;
+    configStandalone.proc.ignoreNonFatalGPUErrors = 1;
+    // TODO: rundEdx=1
+    // GPU_proc.qcRunFraction=$TPC_TRACKING_QC_RUN_FRACTION;"
+    // [[ $CTFINPUT == 1 ]] && GPU_CONFIG_KEY+="GPU_proc.tpcInputWithClusterRejection=1;"
+    // double pipeline / rtc
   }
 
   if (configStandalone.outputcontrolmem) {

From 5ef3da96782ef0bdb971a23c245bedd8e407603e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 10 Jun 2025 15:35:18 +0200
Subject: [PATCH 0489/1764] GPU Standalone: No need for warmup iteration of
 double-pipeline with debugging enabled

---
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 792f72220e597..a624e1e55ed4b 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -901,7 +901,7 @@ int32_t main(int argc, char** argv)
       double pipelineWalltime = 1.;
       if (configStandalone.proc.doublePipeline) {
         HighResTimer timerPipeline;
-        if (RunBenchmark(rec, chainTracking, 1, iEvent, &nTracksTotal, &nClustersTotal) || RunBenchmark(recPipeline, chainTrackingPipeline, 2, iEvent, &nTracksTotal, &nClustersTotal)) {
+        if (configStandalone.proc.debugLevel < 2 && (RunBenchmark(rec, chainTracking, 1, iEvent, &nTracksTotal, &nClustersTotal) || RunBenchmark(recPipeline, chainTrackingPipeline, 2, iEvent, &nTracksTotal, &nClustersTotal))) {
           goto breakrun;
         }
         auto pipeline1 = std::async(std::launch::async, RunBenchmark, rec, chainTracking, configStandalone.runs, iEvent, &nTracksTotal, &nClustersTotal, 0, &timerPipeline);

From 6c537d744bd933e32baee2a0a6795e3ca5093aa1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 11 Jun 2025 09:26:49 +0200
Subject: [PATCH 0490/1764] GPU Standalone: CI build should use -Werror

---
 GPU/GPUTracking/Standalone/CMakeLists.txt     |  7 ++++++-
 GPU/GPUTracking/Standalone/cmake/build.sh     | 15 +++++++++------
 GPU/GPUTracking/Standalone/cmake/config.cmake |  1 +
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 0b37ce38b79f7..48fbd77c62786 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -65,7 +65,12 @@ if (GPUCA_BUILD_DEBUG_SANITIZE)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -shared-libasan")
   endif()
 endif()
-string(APPEND CMAKE_CXX_FLAGS " -Wno-error -Wall -Wextra -Wshadow -Wno-unused-function -Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unknown-pragmas -Wno-write-strings")
+if(GPUCA_CONFIG_WERROR)
+  string(APPEND CMAKE_CXX_FLAGS " -Werror -Wno-unknown-warning-option")
+else()
+  string(APPEND CMAKE_CXX_FLAGS " -Wno-error")
+endif()
+string(APPEND CMAKE_CXX_FLAGS " -Wall -Wextra -Wshadow -Wno-unused-function -Wno-unused-parameter -Wno-unused-local-typedefs -Wno-unknown-pragmas -Wno-write-strings")
 string(APPEND CMAKE_SHARED_LINKER_FLAGS " -rdynamic -Wl,--no-undefined")
 if(CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
   string(APPEND CMAKE_CXX_FLAGS " -Wno-vla-cxx-extension")
diff --git a/GPU/GPUTracking/Standalone/cmake/build.sh b/GPU/GPUTracking/Standalone/cmake/build.sh
index 9fe650fd30905..2698a5bad3950 100755
--- a/GPU/GPUTracking/Standalone/cmake/build.sh
+++ b/GPU/GPUTracking/Standalone/cmake/build.sh
@@ -7,13 +7,16 @@ set -e
 mkdir -p standalone/build
 pushd standalone/build
 cp $1/GPU/GPUTracking/Standalone/cmake/config.cmake .
-cat >> config.cmake << "EOF"
-set(ENABLE_CUDA 1)
-set(ENABLE_HIP 1)
-set(ENABLE_OPENCL 1)
-set(GPUCA_CONFIG_ONNX 1)
-set(GPUCA_BUILD_EVENT_DISPLAY 0)
+if [[ $GPUCA_STANDALONE_CI == 1 ]]; then
+  cat >> config.cmake << "EOF"
+  set(ENABLE_CUDA 1)
+  set(ENABLE_HIP 1)
+  set(ENABLE_OPENCL 1)
+  set(GPUCA_CONFIG_ONNX 1)
+  set(GPUCA_BUILD_EVENT_DISPLAY 0)
+  set(GPUCA_CONFIG_WERROR 1)
 EOF
+fi
 cmake -DCMAKE_INSTALL_PREFIX=../ $1/GPU/GPUTracking/Standalone
 make ${JOBS+-j $JOBS} install
 popd
diff --git a/GPU/GPUTracking/Standalone/cmake/config.cmake b/GPU/GPUTracking/Standalone/cmake/config.cmake
index 77ce9c9e77fca..88fe418d40e5b 100644
--- a/GPU/GPUTracking/Standalone/cmake/config.cmake
+++ b/GPU/GPUTracking/Standalone/cmake/config.cmake
@@ -38,4 +38,5 @@ set(CUDA_COMPUTETARGET "default")           # 86 89
 #set(GPUCA_RTC_NO_COMPILED_KERNELS 1)
 #set(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE 1)
 #set(GPUCA_CONFIG_COMPILER gcc)             # gcc / clang
+#set(GPUCA_CONFIG_WERROR 1)
 #add_definitions(-DGPUCA_GPU_DEBUG_PRINT)

From d50b3b029cab92906d63d4714ebd3c8af68d9978 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 11 Jun 2025 15:09:46 +0200
Subject: [PATCH 0491/1764] GPU: Hide Vc correctly from ROOT

---
 GPU/Common/GPUCommonDef.h                                  | 2 +-
 GPU/Common/GPUCommonMath.h                                 | 2 +-
 GPU/TPCFastTransformation/Spline2D.h                       | 2 +-
 GPU/TPCFastTransformation/Spline2DSpec.h                   | 2 +-
 GPU/TPCFastTransformation/SplineSpec.h                     | 2 +-
 GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.h   | 4 ++--
 GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h | 4 ++--
 7 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/GPU/Common/GPUCommonDef.h b/GPU/Common/GPUCommonDef.h
index d9a5bdf92b6ac..ffe5551f02f1b 100644
--- a/GPU/Common/GPUCommonDef.h
+++ b/GPU/Common/GPUCommonDef.h
@@ -30,7 +30,7 @@
 //Some GPU configuration settings, must be included first
 #include "GPUCommonDefSettings.h"
 
-#if !(defined(__CLING__) || defined(__ROOTCLING__) || defined(G__ROOT)) // No GPU code for ROOT
+#if !defined(__CLING__) && !defined(G__ROOT) // No GPU code for ROOT
   #if defined(__CUDACC__) || defined(__OPENCL__) || defined(__HIPCC__) || defined(__OPENCL_HOST__)
     #define GPUCA_GPUCODE // Compiled by GPU compiler
   #endif
diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index 01067ca032650..b448a30107dad 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -521,7 +521,7 @@ GPUdi() void GPUCommonMath::AtomicMinInternal(S* addr, T val)
 #endif // GPUCA_GPUCODE
 }
 
-#if (defined(__CUDACC__) || defined(__HIPCC__)) && !defined(G__ROOT)
+#if (defined(__CUDACC__) || defined(__HIPCC__)) && !defined(G__ROOT) && !defined(__CLING__)
 #define GPUCA_HAVE_ATOMIC_MINMAX_FLOAT
 template <>
 GPUdii() void GPUCommonMath::AtomicMaxInternal(GPUglobalref() GPUgeneric() GPUAtomic(float) * addr, float val)
diff --git a/GPU/TPCFastTransformation/Spline2D.h b/GPU/TPCFastTransformation/Spline2D.h
index 788816f73d6dd..19f9fc7b55b91 100644
--- a/GPU/TPCFastTransformation/Spline2D.h
+++ b/GPU/TPCFastTransformation/Spline2D.h
@@ -22,7 +22,7 @@
 #include "FlatObject.h"
 #include "GPUCommonDef.h"
 
-#if !defined(__ROOTCLING__) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
+#if !defined(__CLING__) && !defined(G__ROOT) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
 #include <Vc/Vc>
 #include <Vc/SimdArray>
 #endif
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index e7a9db8e6ae9c..b4d351e8d0407 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -22,7 +22,7 @@
 #include "GPUCommonDef.h"
 #include "SplineUtil.h"
 
-#if !defined(__ROOTCLING__) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
+#if !defined(__CLING__) && !defined(G__ROOT) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
 #include <Vc/Vc>
 #include <Vc/SimdArray>
 #endif
diff --git a/GPU/TPCFastTransformation/SplineSpec.h b/GPU/TPCFastTransformation/SplineSpec.h
index 1af427dee503b..744be943181db 100644
--- a/GPU/TPCFastTransformation/SplineSpec.h
+++ b/GPU/TPCFastTransformation/SplineSpec.h
@@ -22,7 +22,7 @@
 #include "GPUCommonDef.h"
 #include "SplineUtil.h"
 
-#if !defined(__ROOTCLING__) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
+#if !defined(__CLING__) && !defined(G__ROOT) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
 #include <Vc/Vc>
 #include <Vc/SimdArray>
 #endif
diff --git a/GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.h b/GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.h
index d60326ddf76ab..33d6874f40aae 100644
--- a/GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.h
+++ b/GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.h
@@ -21,7 +21,7 @@
 #include "FlatObject.h"
 #include "GPUCommonDef.h"
 
-#if !defined(__ROOTCLING__) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
+#if !defined(__CLING__) && !defined(G__ROOT) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
 #include <Vc/Vc>
 #include <Vc/SimdArray>
 #endif
@@ -329,7 +329,7 @@ GPUdi() void IrregularSpline2D3D::getSplineVec(const float* correctedData, float
   // Same as getSpline, but using vectorized calculation.
   // \param correctedData should be at least 128-bit aligned
 
-#if !defined(__ROOTCLING__) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
+#if !defined(__CLING__) && !defined(G__ROOT) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
   const IrregularSpline1D& gridU = getGridU();
   const IrregularSpline1D& gridV = getGridV();
   int32_t nu = gridU.getNumberOfKnots();
diff --git a/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h b/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h
index 954738fa74f1b..835a525239346 100644
--- a/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h
+++ b/GPU/TPCFastTransformation/devtools/SemiregularSpline2D3D.h
@@ -23,7 +23,7 @@
 #include "RegularSpline1D.h"
 #include "FlatObject.h"
 
-#if !defined(__ROOTCLING__) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
+#if !defined(__CLING__) && !defined(G__ROOT) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
 #include <Vc/Vc>
 #include <Vc/SimdArray>
 #endif
@@ -398,7 +398,7 @@ inline void SemiregularSpline2D3D::getSplineVec(const float* correctedData, floa
   // Same as getSpline, but using vectorized calculation.
   // \param correctedData should be at least 128-bit aligned
 
-#if !defined(__ROOTCLING__) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
+#if !defined(__CLING__) && !defined(G__ROOT) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
   //&& !defined(__CLING__)
   /*
     Idea: There are 16 knots important for (u, v).

From 54e61bf02df939c8e54bf2447fa71c15da03a74b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 12 Jun 2025 07:54:40 +0200
Subject: [PATCH 0492/1764] GPU: Remove obsolete
 GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME

---
 GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h       | 4 ----
 GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h | 1 -
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx                | 4 ----
 GPU/GPUTracking/SectorTracker/GPUTPCDef.h                | 3 ---
 GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx       | 4 ----
 5 files changed, 16 deletions(-)

diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h b/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
index 4ddd70efb5d1c..a5f0c1a55e2b9 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
@@ -41,10 +41,6 @@ struct GPUTPCGMMergedTrackHit {
 struct GPUTPCGMMergedTrackHitXYZ {
   float x, y, z;
   uint16_t amp;
-#ifdef GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME
-  float pad;
-  float time;
-#endif
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index 48218dd7859e6..9a8b9b8536fb0 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -68,7 +68,6 @@
 
 //#define GPUCA_MERGER_BY_MC_LABEL                    // Use MC labels for TPC track merging - for performance studies // TODO: Cleanup unneeded options
 //#define GPUCA_FULL_CLUSTERDATA                      // Store all cluster information in the cluster data, also those not needed for tracking.
-//#define GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME        // Propagate Pad, Row, Time cluster information to GM
 //#define GPUCA_GM_USE_FULL_FIELD                     // Use offline magnetic field during GMPropagator prolongation
 
 // clang-format on
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index ab35e7f9a3c36..338ecae4f9b95 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1727,10 +1727,6 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         clXYZ[i].y = c.y;
         clXYZ[i].z = c.z;
         clXYZ[i].amp = c.amp;
-#ifdef GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME
-        clXYZ[i].pad = c.mPad;
-        clXYZ[i].time = c.mTime;
-#endif
         state = c.flags;
       } else {
         const ClusterNative& c = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[trackClusters[i].id];
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCDef.h b/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
index 84ea8e836007c..04042bb4a6632 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
@@ -33,9 +33,6 @@ typedef uint32_t cahit;
 struct cahit2 { cahit x, y; };
 } // namespace o2::GPU
 
-#ifdef GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME // Needs full clusterdata
-  #define GPUCA_FULL_CLUSTERDATA
-#endif
 
 #if defined(GPUCA_STANDALONE) || defined(GPUCA_GPUCODE) // No support for Full Field Propagator or Statistical errors
   #ifdef GPUCA_GM_USE_FULL_FIELD
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx b/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx
index e17bfc1dff025..806a06dfbbe02 100644
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx
+++ b/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx
@@ -44,9 +44,5 @@ GPUdii() void GPUTPCConvertKernel::Thread<0>(int32_t nBlocks, int32_t nThreads,
     clout.amp = clin.qTot;
     clout.flags = clin.getFlags();
     clout.id = idOffset + k;
-#ifdef GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME
-    clout.pad = clin.getPad();
-    clout.time = clin.getTime();
-#endif
   }
 }

From 1250d5e8c6aa21dac259189bf7928e4f7e511c01 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 12 Jun 2025 07:55:07 +0200
Subject: [PATCH 0493/1764] GPU: Remove obsolete GPUCA_FULL_CLUSTERDATA

---
 GPU/GPUTracking/Definitions/GPUDef.h                     | 6 +-----
 GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h | 1 -
 GPU/GPUTracking/SectorTracker/GPUTPCClusterData.h        | 7 -------
 3 files changed, 1 insertion(+), 13 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDef.h b/GPU/GPUTracking/Definitions/GPUDef.h
index 69723813d384f..e1b34af55d62d 100644
--- a/GPU/GPUTracking/Definitions/GPUDef.h
+++ b/GPU/GPUTracking/Definitions/GPUDef.h
@@ -34,11 +34,7 @@
   #define GPUPtr2(a, b) b
 #endif
 
-#ifdef GPUCA_FULL_CLUSTERDATA
-  #define GPUCA_EVDUMP_FILE "event_full"
-#else
-  #define GPUCA_EVDUMP_FILE "event"
-#endif
+#define GPUCA_EVDUMP_FILE "event_full"
 
 #ifdef GPUCA_GPUCODE
   #define CA_MAKE_SHARED_REF(vartype, varname, varglobal, varshared) const GPUsharedref() vartype& __restrict__ varname = varshared;
diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index 9a8b9b8536fb0..f33dfad02e7e5 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -67,7 +67,6 @@
 #endif
 
 //#define GPUCA_MERGER_BY_MC_LABEL                    // Use MC labels for TPC track merging - for performance studies // TODO: Cleanup unneeded options
-//#define GPUCA_FULL_CLUSTERDATA                      // Store all cluster information in the cluster data, also those not needed for tracking.
 //#define GPUCA_GM_USE_FULL_FIELD                     // Use offline magnetic field during GMPropagator prolongation
 
 // clang-format on
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCClusterData.h b/GPU/GPUTracking/SectorTracker/GPUTPCClusterData.h
index cf269a27bd6a5..fbaeeb294df88 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCClusterData.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCClusterData.h
@@ -27,13 +27,6 @@ struct GPUTPCClusterData {
   float y;
   float z;
   float amp;
-#ifdef GPUCA_FULL_CLUSTERDATA
-  float pad;
-  float time;
-  float ampMax;
-  float sigmaPad2;
-  float sigmaTime2;
-#endif
 };
 } // namespace o2::gpu
 

From 5b6fccc8b8d331205d1f60b0031717ec597ad726 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 12 Jun 2025 07:56:07 +0200
Subject: [PATCH 0494/1764] GPU: Remove obsolete GPUCA_GM_USE_FULL_FIELD

---
 .../Definitions/GPUDefConstantsAndSettings.h  |  1 -
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 33 -------------------
 GPU/GPUTracking/SectorTracker/GPUTPCDef.h     |  7 ----
 3 files changed, 41 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index f33dfad02e7e5..46988208256fc 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -67,7 +67,6 @@
 #endif
 
 //#define GPUCA_MERGER_BY_MC_LABEL                    // Use MC labels for TPC track merging - for performance studies // TODO: Cleanup unneeded options
-//#define GPUCA_GM_USE_FULL_FIELD                     // Use offline magnetic field during GMPropagator prolongation
 
 // clang-format on
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index c0dd6cfbcf918..2d612254ba001 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -22,11 +22,6 @@
 #include "GPUDebugStreamer.h"
 #include "GPUTPCGMMerger.h"
 
-#if defined(GPUCA_GM_USE_FULL_FIELD)
-#include "AliTracker.h"
-#include "AliMagF.h"
-#endif
-
 using namespace o2::gpu;
 
 GPUd() void GPUTPCGMPropagator::GetBxByBzBase(float cosAlpha, float sinAlpha, float X, float Y, float Z, float B[3]) const
@@ -36,24 +31,6 @@ GPUd() void GPUTPCGMPropagator::GetBxByBzBase(float cosAlpha, float sinAlpha, fl
   float gx = getGlobalX(cosAlpha, sinAlpha, X, Y);
   float gy = getGlobalY(cosAlpha, sinAlpha, X, Y);
 
-#if defined(GPUCA_GM_USE_FULL_FIELD)
-  const float kCLight = gpu_common_constants::kCLight;
-  double r[3] = {gx, gy, Z};
-  double bb[3];
-  AliTracker::GetBxByBz(r, bb);
-  bb[0] *= kCLight;
-  bb[1] *= kCLight;
-  bb[2] *= kCLight;
-/*
-  cout<<"AliTracker::GetBz()= "<<AliTracker::GetBz()<<endl;
-  cout<<"AliTracker::UniformField() "<<AliTracker::UniformField()<<endl;
-  AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
-  cout<<"Fast field = "<<(void*) fld->GetFastField()<<endl;
-  AliMagF::BMap_t  type = fld->GetMapType() ;
-  cout<<"Field type: "<<type<<endl;
-  //  fMapType==k2BMap_t
-*/
-#else
   float bb[3];
   switch (mFieldRegion) {
     case ITS:
@@ -67,8 +44,6 @@ GPUd() void GPUTPCGMPropagator::GetBxByBzBase(float cosAlpha, float sinAlpha, fl
       mField->GetField(gx, gy, Z, bb);
   }
 
-#endif
-
   // rotate field to local coordinates
 
   B[0] = bb[0] * cosAlpha + bb[1] * sinAlpha;
@@ -81,13 +56,6 @@ GPUd() float GPUTPCGMPropagator::GetBzBase(float cosAlpha, float sinAlpha, float
   float gx = getGlobalX(cosAlpha, sinAlpha, X, Y);
   float gy = getGlobalY(cosAlpha, sinAlpha, X, Y);
 
-#if defined(GPUCA_GM_USE_FULL_FIELD)
-  const float kCLight = gpu_common_constants::kCLight;
-  double r[3] = {gx, gy, Z};
-  double bb[3];
-  AliTracker::GetBxByBz(r, bb);
-  return bb[2] * kCLight;
-#else
   switch (mFieldRegion) {
     case ITS:
       return mField->GetFieldItsBz(gx, gy, Z);
@@ -97,7 +65,6 @@ GPUd() float GPUTPCGMPropagator::GetBzBase(float cosAlpha, float sinAlpha, float
     default:
       return mField->GetFieldBz(gx, gy, Z);
   }
-#endif
 }
 
 GPUd() int32_t GPUTPCGMPropagator::RotateToAlpha(float newAlpha)
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCDef.h b/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
index 04042bb4a6632..e64937eec0ede 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
@@ -33,12 +33,5 @@ typedef uint32_t cahit;
 struct cahit2 { cahit x, y; };
 } // namespace o2::GPU
 
-
-#if defined(GPUCA_STANDALONE) || defined(GPUCA_GPUCODE) // No support for Full Field Propagator or Statistical errors
-  #ifdef GPUCA_GM_USE_FULL_FIELD
-    #undef GPUCA_GM_USE_FULL_FIELD
-  #endif
-#endif
-
 #endif //GPUDTPCEF_H
 // clang-format on

From 74db0b59fd7e17ab5cc322b7bc101e8621ae785f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 12 Jun 2025 07:59:33 +0200
Subject: [PATCH 0495/1764] GPU: Delete obsolete class GPUTPCSectorOutCluster

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  1 -
 GPU/GPUTracking/CMakeLists.txt                |  1 -
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  1 -
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  1 -
 .../SectorTracker/GPUTPCSectorOutCluster.h    | 66 -------------------
 GPU/GPUTracking/SectorTracker/GPUTPCTrack.h   |  6 --
 6 files changed, 76 deletions(-)
 delete mode 100644 GPU/GPUTracking/SectorTracker/GPUTPCSectorOutCluster.h

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 2d1061616d907..d29fc09f32f63 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -18,7 +18,6 @@
 #include "GPUChain.h"
 #include "GPUDefParametersRuntime.h"
 #include "GPUTPCClusterData.h"
-#include "GPUTPCSectorOutCluster.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUTPCGMMergedTrackHit.h"
 #include "GPUTRDTrackletWord.h"
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 67db16ffe9607..87b202ec607ae 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -155,7 +155,6 @@ set(HDRS_INSTALL
     SectorTracker/GPUTPCHit.h
     SectorTracker/GPUTPCHitId.h
     SectorTracker/GPUTPCMCInfo.h
-    SectorTracker/GPUTPCSectorOutCluster.h
     SectorTracker/GPUTPCTracklet.h
     SectorTracker/GPUTPCTrackLinearisation.h
     TPCConvert/GPUTPCConvertImpl.h
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index db84050772312..423f0b782d095 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -22,7 +22,6 @@
 #include "GPUReconstructionIO.h"
 #include "GPUChainTrackingDefs.h"
 #include "GPUTPCClusterData.h"
-#include "GPUTPCSectorOutCluster.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUTPCGMMergedTrackHit.h"
 #include "GPUTPCTrack.h"
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 5a141cd08eb65..dd11e9989f684 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -15,7 +15,6 @@
 #include "GPUChainTracking.h"
 #include "GPUReconstructionIO.h"
 #include "GPUTPCClusterData.h"
-#include "GPUTPCSectorOutCluster.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUTPCGMMergedTrackHit.h"
 #include "GPUTPCTrack.h"
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutCluster.h b/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutCluster.h
deleted file mode 100644
index 2c62a2ca184b2..0000000000000
--- a/GPU/GPUTracking/SectorTracker/GPUTPCSectorOutCluster.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCSectorOutCluster.h
-/// \author Sergey Gorbunov, David Rohr
-
-#ifndef GPUTPCSECTOROUTCLUSTER_H
-#define GPUTPCSECTOROUTCLUSTER_H
-
-#include "GPUTPCDef.h"
-
-namespace o2::gpu
-{
-/**
- * @class GPUTPCSectorOutCluster
- * GPUTPCSectorOutCluster class contains clusters which are assigned to sector tracks.
- * It is used to send the data from TPC sector trackers to the GlobalMerger
- */
-class GPUTPCSectorOutCluster
-{
- public:
-  GPUhd() void Set(uint32_t id, uint8_t row, uint8_t flags, uint16_t amp, float x, float y, float z)
-  {
-    mRow = row;
-    mFlags = flags;
-    mId = id;
-    mAmp = amp;
-    mX = x;
-    mY = y;
-    mZ = z;
-  }
-
-  GPUhd() float GetX() const { return mX; }
-  GPUhd() float GetY() const { return mY; }
-  GPUhd() float GetZ() const { return mZ; }
-  GPUhd() uint16_t GetAmp() const { return mAmp; }
-  GPUhd() uint32_t GetId() const { return mId; }
-  GPUhd() uint8_t GetRow() const { return mRow; }
-  GPUhd() uint8_t GetFlags() const { return mFlags; }
-
- private:
-  uint32_t mId;   // Id
-  uint8_t mRow;   // row
-  uint8_t mFlags; // flags
-  uint16_t mAmp;  // amplitude
-  float mX;       // coordinates
-  float mY;       // coordinates
-  float mZ;       // coordinates
-
-#ifdef GPUCA_TPC_RAW_PROPAGATE_PAD_ROW_TIME
- public:
-  float mPad;
-  float mTime;
-#endif
-};
-} // namespace o2::gpu
-
-#endif
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrack.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrack.h
index 7306c84cf949c..d67903f00acfa 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrack.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrack.h
@@ -17,7 +17,6 @@
 
 #include "GPUTPCBaseTrackParam.h"
 #include "GPUTPCDef.h"
-#include "GPUTPCSectorOutCluster.h"
 
 namespace o2::gpu
 {
@@ -49,11 +48,6 @@ class GPUTPCTrack
 
   GPUhd() void SetParam(const GPUTPCBaseTrackParam& v) { mParam = v; }
 
-  // Only if used as replacement for SectorOutTrack
-  GPUhd() static int32_t GetSize(int32_t nClust) { return sizeof(GPUTPCTrack) + nClust * sizeof(GPUTPCSectorOutCluster); }
-  GPUhd() const GPUTPCTrack* GetNextTrack() const { return (const GPUTPCTrack*)(((char*)this) + GetSize(mNHits)); }
-  GPUhd() GPUTPCTrack* NextTrack() { return (GPUTPCTrack*)(((char*)this) + GetSize(mNHits)); }
-
  private:
   int32_t mFirstHitID;         // index of the first track cell in the track->cell pointer array
   int32_t mNHits;              // number of track cells

From d4fb131cbd800bc825034264d89fed32ce2a578a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 15 Jun 2025 14:51:24 +0200
Subject: [PATCH 0496/1764] GPU CMake: Switch from deprecated AMDGPU_TARGETS to
 GPU_TARGETS

---
 dependencies/FindO2GPU.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 20e351a68c271..f9c549905f178 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -234,7 +234,7 @@ endif()
 if(ENABLE_HIP)
   if(HIP_AMDGPUTARGET)
     set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}")
-    set(AMDGPU_TARGETS "${HIP_AMDGPUTARGET}")
+    set(GPU_TARGETS "${HIP_AMDGPUTARGET}")
   endif()
   if(NOT "$ENV{CMAKE_PREFIX_PATH}" MATCHES "rocm" AND NOT CMAKE_PREFIX_PATH MATCHES "rocm" AND EXISTS "/opt/rocm/lib/cmake/")
     list(APPEND CMAKE_PREFIX_PATH "/opt/rocm/lib/cmake")

From 86b1969df0001f1534e16689ad9bb98b20d255ed Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Mon, 16 Jun 2025 09:18:18 +0200
Subject: [PATCH 0497/1764] NN clusterizer: Bug-fixes and addition of
 deconvolution kernel (#14378)

* First bug-fixes and optimizations for deconvolution flags

* Adding publishing logic for deconvolution flags

* Adjusting kernels.cmake

* Please consider the following formatting changes

* Bug-fix for time-position and boundary check in fillInputSingleElement

* Fix for kernels.cmake and naming

* Changing to uint8_t

* Adding kernel definition

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../Definitions/GPUDefParametersDefaults.h    |  1 +
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 .../Global/GPUChainTrackingClusterizer.cxx    | 10 ++-
 .../GPUTPCCFDeconvolution.cxx                 | 16 +++--
 .../TPCClusterFinder/GPUTPCCFDeconvolution.h  |  2 +-
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |  1 +
 .../GPUTPCNNClusterizerHost.cxx               |  1 +
 .../GPUTPCNNClusterizerKernels.cxx            | 65 ++++++++++++++-----
 .../GPUTPCNNClusterizerKernels.h              |  1 +
 GPU/GPUTracking/kernels.cmake                 | 17 ++---
 10 files changed, 81 insertions(+), 34 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 7879789bf91c8..8fe8e8ca68e44 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -497,6 +497,7 @@
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishDeconvolutionFlags GPUCA_LB_GPUTPCNNClusterizerKernels
 
   #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
   #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index d8173a5b62a35..e75d5a5890e4b 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -269,6 +269,7 @@ AddOption(nnClusterizerBatchedMode, unsigned int, 1, "", 0, "(int, default = 1)
 AddOption(nnClusterizerVerbosity, int, -1, "", 0, "(int, default = -1) If >0, logging messages of the clusterizer will be displayed")
 AddOption(nnClusterizerBoundaryFillValue, int, -1, "", 0, "Fill value for the boundary of the input to the NN")
 AddOption(nnClusterizerApplyNoiseSuppression, int, 1, "", 0, "Applies the NoiseSuppression kernel before the digits to the network are filled")
+AddOption(nnClusterizerSetDeconvolutionFlags, int, 1, "", 0, "Runs the deconvolution kernel without overwriting the charge in order to make cluster-to-track attachment identical to heuristic CF")
 AddOption(nnClassificationPath, std::string, "network_class.onnx", "", 0, "The classification network path")
 AddOption(nnClassThreshold, float, 0.5, "", 0, "The cutoff at which clusters will be accepted / rejected.")
 AddOption(nnRegressionPath, std::string, "network_reg.onnx", "", 0, "The regression network path")
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 64e6f5a31aaa7..816ee43d50b15 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -989,8 +989,10 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           int withMC = (doGPU && propagateMCLabels);
 
           if (clustererNNShadow.mNnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
-            runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
+            runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, true);
             DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
+          } else if (clustererNNShadow.mNnClusterizerSetDeconvolutionFlags) {
+            runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, false);
           }
 
           // float time_clusterizer = 0, time_fill = 0, time_networks = 0;
@@ -1001,6 +1003,10 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             // auto start0 = std::chrono::high_resolution_clock::now();
             runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNSingleElement>({GetGrid(iSize * clustererNNShadow.mNnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, batchStart); // Filling the data
 
+            if (clustererNNShadow.mNnClusterizerSetDeconvolutionFlags) {
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, batchStart); // Filling the regression data
+            }
+
             // auto stop0 = std::chrono::high_resolution_clock::now();
             // auto start1 = std::chrono::high_resolution_clock::now();
 
@@ -1102,7 +1108,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           GPUFatal("Project not compiled with neural network clusterization. Aborting.");
 #endif
         } else {
-          runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
+          runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, true);
           DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
           runKernel<GPUTPCCFClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), {iSector}}, 0);
         }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.cxx
index 429d51685e504..d6b8703a9b35d 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.cxx
@@ -22,18 +22,19 @@ using namespace o2::gpu;
 using namespace o2::gpu::tpccf;
 
 template <>
-GPUdii() void GPUTPCCFDeconvolution::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
+GPUdii() void GPUTPCCFDeconvolution::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, uint8_t overwriteCharge)
 {
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
-  GPUTPCCFDeconvolution::deconvolutionImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), smem, isPeakMap, chargeMap, clusterer.mPpositions, clusterer.mPmemory->counters.nPositions);
+  GPUTPCCFDeconvolution::deconvolutionImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), smem, isPeakMap, chargeMap, clusterer.mPpositions, clusterer.mPmemory->counters.nPositions, overwriteCharge);
 }
 
 GPUdii() void GPUTPCCFDeconvolution::deconvolutionImpl(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem,
                                                        const CfArray2D<uint8_t>& peakMap,
                                                        CfArray2D<PackedCharge>& chargeMap,
                                                        const CfChargePos* positions,
-                                                       const uint32_t digitnum)
+                                                       const uint32_t digitnum,
+                                                       uint8_t overwriteCharge)
 {
   SizeT idx = get_global_id(0);
 
@@ -111,9 +112,14 @@ GPUdii() void GPUTPCCFDeconvolution::deconvolutionImpl(int32_t nBlocks, int32_t
   peakCount = (peakCount == 0) ? 1 : peakCount;
 
   PackedCharge charge = chargeMap[pos];
-  PackedCharge p(charge.unpack() / peakCount, has3x3, split);
 
-  chargeMap[pos] = p;
+  if (overwriteCharge) {
+    PackedCharge p(charge.unpack() / peakCount, has3x3, split);
+    chargeMap[pos] = p;
+  } else {
+    PackedCharge p(charge.unpack(), has3x3, split);
+    chargeMap[pos] = p;
+  }
 }
 
 GPUdi() uint8_t GPUTPCCFDeconvolution::countPeaksInner(
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
index e971a042e95a4..902e3a28fd21b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
@@ -51,7 +51,7 @@ class GPUTPCCFDeconvolution : public GPUKernelTemplate
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, Args... args);
 
  private:
-  static GPUd() void deconvolutionImpl(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, const CfArray2D<uint8_t>&, CfArray2D<PackedCharge>&, const CfChargePos*, const uint32_t);
+  static GPUd() void deconvolutionImpl(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, const CfArray2D<uint8_t>&, CfArray2D<PackedCharge>&, const CfChargePos*, const uint32_t, uint8_t);
 
   static GPUdi() uint8_t countPeaksInner(uint16_t, const uint8_t*, uint8_t*);
   static GPUdi() uint8_t countPeaksOuter(uint16_t, uint8_t, const uint8_t*);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index f7c2d13407b0e..980c0977aca65 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -44,6 +44,7 @@ class GPUTPCNNClusterizer : public GPUProcessor
   bool mNnClusterizerAddIndexData = true;
   float mNnClassThreshold = 0.01;
   bool mNnSigmoidTrafoClassThreshold = 1;
+  bool mNnClusterizerSetDeconvolutionFlags = true;
   int mNnClusterizerUseCfRegression = 0;
   int mNnClusterizerBatchedMode = 1;
   int mNnClusterizerTotalClusters = 1;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index 90f1d6e27246f..124320396d0d4 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -92,6 +92,7 @@ void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclust
   clustererNN.mNnClusterizerBatchedMode = settings.nnClusterizerBatchedMode;
   clustererNN.mNnClusterizerBoundaryFillValue = settings.nnClusterizerBoundaryFillValue;
   clustererNN.mNnSigmoidTrafoClassThreshold = settings.nnSigmoidTrafoClassThreshold;
+  clustererNN.mNnClusterizerSetDeconvolutionFlags = (bool)settings.nnClusterizerSetDeconvolutionFlags;
   if (clustererNN.mNnSigmoidTrafoClassThreshold) {
     clustererNN.mNnClassThreshold = (float)std::log(settings.nnClassThreshold / (1.f - settings.nnClassThreshold));
   } else {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 8ca61602ab4e9..58dd49630d8e6 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -51,7 +51,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNN>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint32_t batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNN>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
@@ -111,7 +111,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNSingleElement>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint32_t batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNSingleElement>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
@@ -126,11 +126,13 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
 
   if (clustererNN.mNnClusterizerAddIndexData && (int32_t)transient_index == (clustererNN.mNnClusterizerElementSize - 1)) {
     uint32_t top_idx = (base_idx + 1) * clustererNN.mNnClusterizerElementSize;
-    for (uint16_t i = 0; i < 8; i++) {
-      Delta2 d = cfconsts::InnerNeighbors[i];
-      CfChargePos tmp_pos = peak.delta(d);
-      clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
-      clustererNN.mClusterFlags[2 * glo_idx + 1] = clustererNN.mClusterFlags[2 * glo_idx];
+    if (!clustererNN.mNnClusterizerSetDeconvolutionFlags) { // Only if deconvolution flags are not set
+      for (uint16_t i = 0; i < 8; i++) {                    // This solution needs testing. It is not the same as the deconvolution flags
+        Delta2 d = cfconsts::InnerNeighbors[i];
+        CfChargePos tmp_pos = peak.delta(d);
+        clustererNN.mClusterFlags[2 * base_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
+      }
+      clustererNN.mClusterFlags[2 * base_idx + 1] = clustererNN.mClusterFlags[2 * base_idx];
     }
     if (dtype == 0) {
       clustererNN.mInputData_16[top_idx - 3] = (OrtDataType::Float16_t)(sector / 36.f);
@@ -147,32 +149,32 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
     bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
     if (is_row_boundary) {
       if (dtype == 0) {
-        clustererNN.mInputData_16[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
+        clustererNN.mInputData_16[glo_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
       } else {
-        clustererNN.mInputData_32[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
+        clustererNN.mInputData_32[glo_idx] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
       }
     } else {
       int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
       int32_t pad_offset = GPUTPCNNClusterizerKernels::padOffset(row, row + r);
       int32_t rest_1 = transient_index % ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1));
       int32_t p = CAMath::Floor(rest_1 / (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputPad + pad_offset;
-      int32_t t = (rest_1 % (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputTime;
+      int32_t time_pos = (rest_1 % (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputTime + time;
 
-      bool is_boundary = GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow) && (t < 0 || t >= TPC_MAX_FRAGMENT_LEN_GPU);
+      bool is_boundary = GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow) && (time_pos < 0 || time_pos >= TPC_MAX_FRAGMENT_LEN_GPU);
 
       if (!is_boundary) {
         float central_charge = static_cast<float>(chargeMap[peak].unpack());
-        CfChargePos tmp_pos(row + r, pad + p, time + t);
+        CfChargePos tmp_pos(row + r, pad + p, time_pos);
         if (dtype == 0) {
-          clustererNN.mInputData_16[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
+          clustererNN.mInputData_16[glo_idx] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
         } else if (dtype == 1) {
-          clustererNN.mInputData_32[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+          clustererNN.mInputData_32[glo_idx] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
         }
       } else {
         if (dtype == 0) {
-          clustererNN.mInputData_16[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
+          clustererNN.mInputData_16[glo_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
         } else {
-          clustererNN.mInputData_32[base_idx * clustererNN.mNnClusterizerElementSize + transient_index] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
+          clustererNN.mInputData_32[glo_idx] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
         }
       }
     }
@@ -180,7 +182,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass1Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint32_t batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass1Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   uint32_t glo_idx = get_global_id(0);
   if (dtype == 0) {
@@ -191,7 +193,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::det
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass2Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t onlyMC, uint32_t batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass2Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   auto& clustererNN = processors.tpcNNClusterer[sector];
   uint32_t glo_idx = get_global_id(0);
@@ -457,6 +459,33 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   }
 }
 
+// ---------------------------------
+template <>
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint batchStart)
+{
+  // Implements identical publishing logic as the heuristic clusterizer and deconvolution kernel
+  uint32_t idx = get_global_id(0);
+  auto& clusterer = processors.tpcClusterer[sector];
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[idx + batchStart];
+
+  for (int i = 0; i < 8; i++) {
+    Delta2 d = cfconsts::InnerNeighbors[i];
+    CfChargePos tmp_pos = peak.delta(d);
+    PackedCharge charge = chargeMap[tmp_pos];
+    clustererNN.mClusterFlags[2 * idx] += (d.y != 0 && charge.isSplit());
+    clustererNN.mClusterFlags[2 * idx + 1] += (d.x != 0 && charge.isSplit());
+  }
+  for (int i = 0; i < 16; i++) {
+    Delta2 d = cfconsts::OuterNeighbors[i];
+    CfChargePos tmp_pos = peak.delta(d);
+    PackedCharge charge = chargeMap[tmp_pos];
+    clustererNN.mClusterFlags[2 * idx] += (d.y != 0 && charge.isSplit() && !charge.has3x3Peak());
+    clustererNN.mClusterFlags[2 * idx + 1] += (d.x != 0 && charge.isSplit() && !charge.has3x3Peak());
+  }
+}
+
 // THe following arithmetic is done because the network is trained with a split between IROC and OROC boundary
 GPUd() int32_t GPUTPCNNClusterizerKernels::padOffset(int32_t row_ref, int32_t row_current)
 {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index dac2bf9554849..179eb483cdf6b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -65,6 +65,7 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
     determineClass2Labels = 4,
     publishClass1Regression = 5,
     publishClass2Regression = 6,
+    publishDeconvolutionFlags = 7
   };
 
   template <int32_t iKernel = defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 08d879fbb8e9a..2a59f98a6d5b4 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -111,7 +111,7 @@ o2_gpu_add_kernel("GPUTPCCFChargeMapFiller, findFragmentStart"            "= TPC
 o2_gpu_add_kernel("GPUTPCCFPeakFinder"                                    "= TPCCLUSTERFINDER"                                    LB)
 o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, noiseSuppression"            "= TPCCLUSTERFINDER"                                    LB)
 o2_gpu_add_kernel("GPUTPCCFNoiseSuppression, updatePeaks"                 "= TPCCLUSTERFINDER"                                    LB)
-o2_gpu_add_kernel("GPUTPCCFDeconvolution"                                 "= TPCCLUSTERFINDER"                                    LB)
+o2_gpu_add_kernel("GPUTPCCFDeconvolution"                                 "= TPCCLUSTERFINDER"                                    LB uint8_t overwriteCharge)
 o2_gpu_add_kernel("GPUTPCCFClusterizer"                                   "= TPCCLUSTERFINDER"                                    LB int8_t onlyMC)
 o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, setRowOffsets"               "= TPCCLUSTERFINDER")
 o2_gpu_add_kernel("GPUTPCCFMCLabelFlattener, flatten"                     "= TPCCLUSTERFINDER"                                    NO GPUTPCLinearLabels* out)
@@ -127,13 +127,14 @@ o2_gpu_add_kernel("GPUTPCCFGather"                                        "="
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                    "= GLOBALREFIT "                                        LB)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"            "= GLOBALREFIT "                                        LB)
 if(onnxruntime_FOUND)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, runCfClusterizer"          "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNN"               "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNNSingleElement"  "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass1Labels"     "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass2Labels"     "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass1Regression"   "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass2Regression"   "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t onlyMC uint batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, runCfClusterizer"          "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNN"               "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNNSingleElement"  "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass1Labels"     "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass2Labels"     "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass1Regression"   "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass2Regression"   "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishDeconvolutionFlags" "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
 endif()
 
 o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP

From 614bce287a8cb2a416f62538f7ccea8dcc80d001 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 10 Jun 2025 11:19:15 +0200
Subject: [PATCH 0498/1764] ITS: after processing cleanup memory remnants

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/include/ITStracking/TrackingInterface.h | 1 +
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx  | 5 +++++
 .../ITS/workflow/include/ITSWorkflow/TrackerSpec.h       | 1 +
 Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx        | 9 +++++++--
 4 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index cff6d215e5e3b..732efcb9e0861 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -59,6 +59,7 @@ class ITSTrackingInterface
   void initialise();
   void run(framework::ProcessingContext& pc);
   void printSummary() const;
+  void end();
 
   virtual void updateTimeDependentParams(framework::ProcessingContext& pc);
   virtual void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index c70108b4f8a30..b6b4796690905 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -449,6 +449,11 @@ void ITSTrackingInterface::printSummary() const
   mTracker->printSummary();
 }
 
+void ITSTrackingInterface::end()
+{
+  mTimeFrame->wipe();
+}
+
 void ITSTrackingInterface::setTraitsFromProvider(VertexerTraits* vertexerTraits,
                                                  TrackerTraits7* trackerTraits,
                                                  TimeFrame7* frame)
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
index 9160df6fc49fd..27c4174fab244 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
@@ -48,6 +48,7 @@ class TrackerDPL : public framework::Task
   void stop() final;
 
  private:
+  void end();
   void updateTimeDependentParams(framework::ProcessingContext& pc);
   std::unique_ptr<o2::gpu::GPUReconstruction> mRecChain = nullptr;
   std::unique_ptr<o2::gpu::GPUChainITS> mChainITS = nullptr;
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index abbb88aea42fa..9f84ee6522567 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -48,8 +48,7 @@ void TrackerDPL::init(InitContext& ic)
 
 void TrackerDPL::stop()
 {
-  mITSTrackingInterface.printSummary();
-  LOGF(info, "CPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+  end();
 }
 
 void TrackerDPL::run(ProcessingContext& pc)
@@ -70,6 +69,12 @@ void TrackerDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 
 void TrackerDPL::endOfStream(EndOfStreamContext& ec)
 {
+  end();
+}
+
+void TrackerDPL::end()
+{
+  mITSTrackingInterface.end();
   mITSTrackingInterface.printSummary();
   LOGF(info, "ITS CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }

From b911f95c1582dd0cb59afa99022f4b74594290fc Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 16 Jun 2025 10:05:06 +0200
Subject: [PATCH 0499/1764] Fix typo while adapting for std::pmr (#14408)

---
 Utilities/DataSampling/src/Dispatcher.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Utilities/DataSampling/src/Dispatcher.cxx b/Utilities/DataSampling/src/Dispatcher.cxx
index bc79be2771316..3ff0ba661fd93 100644
--- a/Utilities/DataSampling/src/Dispatcher.cxx
+++ b/Utilities/DataSampling/src/Dispatcher.cxx
@@ -80,7 +80,7 @@ void Dispatcher::init(InitContext& ctx)
 
 header::Stack extractAdditionalHeaders(const char* inputHeaderStack)
 {
-  std::array<header::BaseHeader const*, 5> headers;
+  std::array<header::BaseHeader const*, 8> headers;
   int count = 0;
   const auto* first = header::BaseHeader::get(reinterpret_cast<const std::byte*>(inputHeaderStack));
   for (const auto* current = first; current != nullptr; current = current->next()) {

From 56bfdbe23b8c8d6cde5bf656f9b843691d74d168 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Fri, 13 Jun 2025 12:21:47 +0200
Subject: [PATCH 0500/1764] Optional InteractionSampler sampling overwrite

Allow to overwrite InteractionSampler by means of virtualizing
sampling function.

Used in CollisionContextTool do allow putting collisions at fixed N intervals (export mode)
for the purpose of systematic studies / debugging.

- To use this feature say `export ALICEO2_ENFORCE_TRIVIAL_BC_SAMPLER="2:5"
  to put 5 collisions into every 2nd bunch-crossing (within the bunch filling scheme)
---
 .../SimulationDataFormat/InteractionSampler.h | 21 ++++++++++--
 .../simulation/src/InteractionSampler.cxx     | 18 ++++++++++
 .../simulation/src/SimulationDataLinkDef.h    |  1 +
 Steer/src/CollisionContextTool.cxx            | 33 ++++++++++++++-----
 4 files changed, 63 insertions(+), 10 deletions(-)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/InteractionSampler.h b/DataFormats/simulation/include/SimulationDataFormat/InteractionSampler.h
index 13fe099aa344a..d2ccec147cc4f 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/InteractionSampler.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/InteractionSampler.h
@@ -67,7 +67,7 @@ class InteractionSampler
   void print() const;
 
  protected:
-  int simulateInteractingBC();
+  virtual int simulateInteractingBC();
   void nextCollidingBC(int n);
 
   o2::math_utils::RandomRing<10000> mBCJumpGenerator;  // generator of random jumps in BC
@@ -89,7 +89,7 @@ class InteractionSampler
 
   static constexpr float DefIntRate = 50e3; ///< default interaction rate
 
-  ClassDefNV(InteractionSampler, 1);
+  ClassDef(InteractionSampler, 1);
 };
 
 //_________________________________________________
@@ -113,6 +113,23 @@ inline void InteractionSampler::nextCollidingBC(int n)
   mIR.bc = mInteractingBCs[mCurrBCIdx];
 }
 
+// Special case of InteractionSampler without actual sampling.
+// Engineers interaction sequence by putting one in each N-th BC with multiplicity mult.
+class FixedSkipBC_InteractionSampler : public InteractionSampler
+{
+
+ public:
+  FixedSkipBC_InteractionSampler(int every_n, int mult) : mEveryN{every_n}, mMultiplicity{mult}, InteractionSampler() {}
+
+ protected:
+  int simulateInteractingBC() override;
+
+ private:
+  int mEveryN;       // the skip number ---> fills every N-th BC in the bunch filling scheme
+  int mMultiplicity; // how many events to put if bc is filled
+  ClassDef(FixedSkipBC_InteractionSampler, 1);
+};
+
 } // namespace steer
 } // namespace o2
 
diff --git a/DataFormats/simulation/src/InteractionSampler.cxx b/DataFormats/simulation/src/InteractionSampler.cxx
index 1936bf7dc06a9..5e14e22e5f8db 100644
--- a/DataFormats/simulation/src/InteractionSampler.cxx
+++ b/DataFormats/simulation/src/InteractionSampler.cxx
@@ -130,6 +130,24 @@ int InteractionSampler::simulateInteractingBC()
   return ncoll;
 }
 
+//_________________________________________________
+int FixedSkipBC_InteractionSampler::simulateInteractingBC()
+{
+  // Returns number of collisions assigned to selected BC
+
+  nextCollidingBC(mEveryN);  // we jump regular intervals
+  int ncoll = mMultiplicity; // well defined pileup
+
+  // assign random time withing a bunch
+  for (int i = ncoll; i--;) {
+    mTimeInBC.push_back(mCollTimeGenerator.getNextValue());
+  }
+  if (ncoll > 1) { // sort in DECREASING time order (we are reading vector from the end)
+    std::sort(mTimeInBC.begin(), mTimeInBC.end(), [](const float a, const float b) { return a > b; });
+  }
+  return ncoll;
+}
+
 //_________________________________________________
 void InteractionSampler::setBunchFilling(const std::string& bcFillingFile)
 {
diff --git a/DataFormats/simulation/src/SimulationDataLinkDef.h b/DataFormats/simulation/src/SimulationDataLinkDef.h
index 8a1e0c536c089..15abe9d50390f 100644
--- a/DataFormats/simulation/src/SimulationDataLinkDef.h
+++ b/DataFormats/simulation/src/SimulationDataLinkDef.h
@@ -24,6 +24,7 @@
 #pragma link off all functions;
 
 #pragma link C++ class o2::steer::InteractionSampler + ;
+#pragma link C++ class o2::steer::FixedSkipBC_InteractionSampler + ;
 #pragma link C++ class o2::sim::StackParam + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::sim::StackParam> + ;
 #pragma link C++ class o2::MCTrackT < double> + ;
diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index 6dffdc921d651..e2f7c0fce3d67 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -302,17 +302,34 @@ int main(int argc, char* argv[])
   for (int id = 0; id < ispecs.size(); ++id) {
     auto mode = ispecs[id].syncmode;
     if (mode == InteractionLockMode::NOLOCK) {
-      o2::steer::InteractionSampler sampler;
-      sampler.setInteractionRate(ispecs[id].interactionRate);
+      auto sampler = std::make_unique<o2::steer::InteractionSampler>();
+
+      // for debug purposes: allows to instantiate trivial sampler
+      if (const char* env = getenv("ALICEO2_ENFORCE_TRIVIAL_BC_SAMPLER")) {
+        std::string spec(env);
+        std::regex re(R"((\d+):(\d+))");
+        std::smatch match;
+        int every_n = 1, mult = 1;
+        if (std::regex_match(spec, match, re)) {
+          every_n = std::stoi(match[1]);
+          mult = std::stoi(match[2]);
+        } else {
+          LOG(error) << "ALICEO2_ENFORCE_TRIVIAL_BC_SAMPLER format invalid, expected NUMBER_1:NUMBER_2";
+          exit(1);
+        }
+        sampler.reset(new o2::steer::FixedSkipBC_InteractionSampler(every_n, mult));
+      }
+
+      sampler->setInteractionRate(ispecs[id].interactionRate);
       if (!options.bcpatternfile.empty()) {
-        setBCFillingHelper(sampler, options.bcpatternfile);
+        setBCFillingHelper(*sampler, options.bcpatternfile);
       }
       o2::InteractionTimeRecord record;
       // this loop makes sure that the first collision is within the range of orbits asked (if noEmptyTF is enabled)
       do {
-        sampler.setFirstIR(o2::InteractionRecord(options.firstBC, orbitstart));
-        sampler.init();
-        record = sampler.generateCollisionTime();
+        sampler->setFirstIR(o2::InteractionRecord(options.firstBC, orbitstart));
+        sampler->init();
+        record = sampler->generateCollisionTime();
       } while (options.noEmptyTF && usetimeframelength && record.orbit >= orbitstart + orbits_total);
       int count = 0;
       do {
@@ -325,7 +342,7 @@ int main(int argc, char* argv[])
         std::pair<o2::InteractionTimeRecord, std::vector<o2::steer::EventPart>> insertvalue(record, parts);
         auto iter = std::lower_bound(collisions.begin(), collisions.end(), insertvalue, [](std::pair<o2::InteractionTimeRecord, std::vector<o2::steer::EventPart>> const& a, std::pair<o2::InteractionTimeRecord, std::vector<o2::steer::EventPart>> const& b) { return a.first < b.first; });
         collisions.insert(iter, insertvalue);
-        record = sampler.generateCollisionTime();
+        record = sampler->generateCollisionTime();
         count++;
       } while ((ispecs[id].mcnumberasked > 0 && count < ispecs[id].mcnumberasked)); // TODO: this loop should probably be replaced by a condition with usetimeframelength and number of orbits
 
@@ -360,7 +377,7 @@ int main(int argc, char* argv[])
       }
 
       // keep bunch filling information produced by these samplers
-      bunchFillings.push_back(sampler.getBunchFilling());
+      bunchFillings.push_back(sampler->getBunchFilling());
 
     } else {
       // we are in some lock/sync mode and modify existing collisions

From fe8111b67df30bbec6be873c5bd221a724b1ae91 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 16 Jun 2025 10:08:35 +0200
Subject: [PATCH 0501/1764] GPU CUDA CMake: Do not print warnings that
 architectures will be depreacted

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt | 4 ++--
 dependencies/FindO2GPU.cmake             | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 0e9831e26d494..7f595b28a582a 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -70,8 +70,8 @@ add_custom_command(
     COMMAND cp ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPU_RTC_BIN}.src
     COMMAND cat ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h | grep -v GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
-    COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -M -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d ${GPU_RTC_SRC}
-    COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -D__CUDACC__ -x c++ -E -Xcompiler "-nostdinc -P" ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
+    COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -Wno-deprecated-gpu-targets -D__CUDACC__ -x c++ -M -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d ${GPU_RTC_SRC}
+    COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -Wno-deprecated-gpu-targets -D__CUDACC__ -x c++ -E -Xcompiler "-nostdinc -P" ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
     DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h
     DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index f9c549905f178..633d1220575db 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -148,7 +148,7 @@ if(ENABLE_CUDA)
     endif()
   endif()
   if(CMAKE_CUDA_COMPILER)
-    set(CMAKE_CUDA_FLAGS "-Xcompiler \"${O2_GPU_CMAKE_CXX_FLAGS_NOSTD}\" ${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr --extended-lambda -Xcompiler -Wno-attributes ${GPUCA_CUDA_DENORMALS_FLAGS}")
+    set(CMAKE_CUDA_FLAGS "-Xcompiler \"${O2_GPU_CMAKE_CXX_FLAGS_NOSTD}\" ${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr --extended-lambda -Xcompiler -Wno-attributes -Wno-deprecated-gpu-targets ${GPUCA_CUDA_DENORMALS_FLAGS}")
     set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "-Xcompiler \"${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}\" ${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
     if(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE)
       string(APPEND CMAKE_CUDA_FLAGS " -Xptxas -v")

From d449a51ab3a69fd9f5d41a0c5fff74d9b1b8be9e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 16 Jun 2025 14:16:39 +0200
Subject: [PATCH 0502/1764] DataModel: remove unsupported classes (#14400)

The code in question conflicts with the modern / standardized specification of std::pmr where the polymorphic_allocators cannot be moved.

Given we are not actually using those classes in any case, I am removing
them. If we will need the functionality in the future, we will in any case
need to reimplement / rethink / verify them.
---
 .../include/MemoryResources/MemoryResources.h | 167 ------------------
 .../test/testMemoryResources.cxx              |  76 --------
 2 files changed, 243 deletions(-)

diff --git a/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h b/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
index eba309e38ad83..b52f5c715575e 100644
--- a/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
+++ b/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
@@ -111,162 +111,6 @@ class MessageResource : public FairMQMemoryResource
   }
 };
 
-//__________________________________________________________________________________________________
-// A spectator pmr memory resource which only watches the memory of the underlying buffer, does not
-// carry out real allocation. It owns the underlying buffer which is destroyed on deallocation.
-template <typename BufferType>
-class SpectatorMemoryResource : public fair::mq::pmr::memory_resource
-{
- public:
-  using buffer_type = BufferType;
-
-  SpectatorMemoryResource() noexcept = delete;
-  SpectatorMemoryResource(const SpectatorMemoryResource&) noexcept = delete;
-  SpectatorMemoryResource(SpectatorMemoryResource&&) noexcept = default;
-  SpectatorMemoryResource& operator=(const SpectatorMemoryResource&) = delete;
-  SpectatorMemoryResource& operator=(SpectatorMemoryResource&&) = default;
-  ~SpectatorMemoryResource() noexcept override = default;
-
-  // the resource is the pointer managed by unique_ptr
-  template <typename T>
-  SpectatorMemoryResource(std::unique_ptr<T, typename buffer_type::deleter_type>&& buffer, size_t size)
-    : mBuffer{std::move(buffer)}, mPointer{mBuffer.get()}, mSize{size}
-  {
-  }
-
-  // the resource is the data of the vector managed by unique ptr
-  template <typename T>
-  SpectatorMemoryResource(std::unique_ptr<std::vector<T>, typename buffer_type::deleter_type>&& buffer)
-    : mBuffer{std::move(buffer)}, mPointer{mBuffer->data()}, mSize{mBuffer->size() * sizeof(T)}
-  {
-  }
-
-  // TODO: the underlying resource can be directly the vector or the read only buffer
- protected:
-  void* do_allocate(std::size_t bytes, std::size_t /*alignment*/) override
-  {
-    if (mSize > 0) {
-      if (bytes > mSize) {
-        throw std::bad_alloc();
-      }
-      mSize = 0;
-      return mPointer;
-    }
-    throw std::runtime_error("Can not allocate: this memory resource is only supposed to provide spectator access to external buffer");
-  }
-
-  void do_deallocate(void* p, std::size_t /*bytes*/, std::size_t /*alignment*/) override
-  {
-    if (p == mPointer) {
-      mBuffer.reset();
-      mPointer = nullptr;
-    } else if (mPointer == nullptr) {
-      // there is an error in the logic flow, this should never be called more than once
-      throw std::logic_error("underlying controlled resource has been released already");
-    } else {
-      throw std::logic_error("this resource can only deallocate the controlled resource pointer");
-    }
-  }
-  bool do_is_equal(const memory_resource& /*other*/) const noexcept override
-  {
-    // uniquely owns the underlying resource, can never be equal to any other instance
-    return false;
-  }
-
- private:
-  buffer_type mBuffer;
-  void* mPointer = nullptr;
-  size_t mSize = 0;
-};
-
-//__________________________________________________________________________________________________
-// This in general (as in STL) is a bad idea, but here it is safe to inherit from an allocator since we
-// have no additional data and only override some methods so we don't get into slicing and other problems.
-template <typename T>
-class SpectatorAllocator : public fair::mq::pmr::polymorphic_allocator<T>
-{
- public:
-  using fair::mq::pmr::polymorphic_allocator<T>::polymorphic_allocator;
-  using propagate_on_container_move_assignment = std::true_type;
-
-  // skip default construction of empty elements
-  // this is important for two reasons: one: it allows us to adopt an existing buffer (e.g. incoming message) and
-  // quickly construct large vectors while skipping the element initialization.
-  template <class U>
-  void construct(U*)
-  {
-  }
-
-  // dont try to call destructors, makes no sense since resource is managed externally AND allowed
-  // types cannot have side effects
-  template <typename U>
-  void destroy(U*)
-  {
-  }
-
-  T* allocate(size_t size) { return reinterpret_cast<T*>(this->resource()->allocate(size * sizeof(T), 64)); }
-  void deallocate(T* ptr, size_t size)
-  {
-    this->resource()->deallocate(const_cast<typename std::remove_cv<T>::type*>(ptr), size);
-  }
-};
-
-//__________________________________________________________________________________________________
-/// This allocator has a pmr-like interface, but keeps the unique MessageResource as internal state,
-/// allowing full resource (associated message) management internally without any global state.
-template <typename T>
-class OwningMessageSpectatorAllocator
-{
- public:
-  using value_type = T;
-
-  MessageResource mResource;
-
-  OwningMessageSpectatorAllocator() noexcept = default;
-  OwningMessageSpectatorAllocator(const OwningMessageSpectatorAllocator&) noexcept = default;
-  OwningMessageSpectatorAllocator(OwningMessageSpectatorAllocator&&) noexcept = default;
-  OwningMessageSpectatorAllocator(MessageResource&& resource) noexcept : mResource{resource} {}
-
-  template <class U>
-  OwningMessageSpectatorAllocator(const OwningMessageSpectatorAllocator<U>& other) noexcept : mResource(other.mResource)
-  {
-  }
-
-  OwningMessageSpectatorAllocator& operator=(const OwningMessageSpectatorAllocator& other)
-  {
-    mResource = other.mResource;
-    return *this;
-  }
-
-  OwningMessageSpectatorAllocator select_on_container_copy_construction() const
-  {
-    return OwningMessageSpectatorAllocator();
-  }
-
-  fair::mq::pmr::memory_resource* resource() { return &mResource; }
-
-  // skip default construction of empty elements
-  // this is important for two reasons: one: it allows us to adopt an existing buffer (e.g. incoming message) and
-  // quickly construct large vectors while skipping the element initialization.
-  template <class U>
-  void construct(U*)
-  {
-  }
-
-  // dont try to call destructors, makes no sense since resource is managed externally AND allowed
-  // types cannot have side effects
-  template <typename U>
-  void destroy(U*)
-  {
-  }
-
-  T* allocate(size_t size) { return reinterpret_cast<T*>(mResource.allocate(size * sizeof(T), 64)); }
-  void deallocate(T* ptr, size_t size)
-  {
-    mResource.deallocate(const_cast<typename std::remove_cv<T>::type*>(ptr), size);
-  }
-};
-
 // The NoConstructAllocator behaves like the normal pmr vector but does not call constructors / destructors
 template <typename T>
 class NoConstructAllocator : public fair::mq::pmr::polymorphic_allocator<T>
@@ -301,21 +145,10 @@ class NoConstructAllocator : public fair::mq::pmr::polymorphic_allocator<T>
 //__________________________________________________________________________________________________
 //__________________________________________________________________________________________________
 
-using ByteSpectatorAllocator = SpectatorAllocator<std::byte>;
 using BytePmrAllocator = fair::mq::pmr::polymorphic_allocator<std::byte>;
 template <class T>
 using vector = std::vector<T, fair::mq::pmr::polymorphic_allocator<T>>;
 
-//__________________________________________________________________________________________________
-/// Return a std::vector spanned over the contents of the message, takes ownership of the message
-template <typename ElemT>
-auto adoptVector(size_t nelem, fair::mq::MessagePtr message)
-{
-  static_assert(std::is_trivially_destructible<ElemT>::value);
-  return std::vector<ElemT, OwningMessageSpectatorAllocator<ElemT>>(
-    nelem, OwningMessageSpectatorAllocator<ElemT>(MessageResource{std::move(message)}));
-};
-
 //__________________________________________________________________________________________________
 /// Get the allocator associated to a transport factory
 inline static FairMQMemoryResource* getTransportAllocator(fair::mq::TransportFactory* factory)
diff --git a/DataFormats/MemoryResources/test/testMemoryResources.cxx b/DataFormats/MemoryResources/test/testMemoryResources.cxx
index 6bbafa3a82f4f..a49cd00d75255 100644
--- a/DataFormats/MemoryResources/test/testMemoryResources.cxx
+++ b/DataFormats/MemoryResources/test/testMemoryResources.cxx
@@ -88,15 +88,6 @@ BOOST_AUTO_TEST_CASE(allocator_test)
   }
 
   testData::nconstructions = 0;
-  {
-    std::vector<testData, SpectatorAllocator<testData>> v(SpectatorAllocator<testData>{allocZMQ});
-    v.reserve(3);
-    BOOST_CHECK(allocZMQ->getNumberOfMessages() == 1);
-    v.emplace_back(1);
-    v.emplace_back(2);
-    v.emplace_back(3);
-    BOOST_CHECK(testData::nconstructions == 3);
-  }
   BOOST_CHECK(allocZMQ->getNumberOfMessages() == 0);
 }
 
@@ -147,73 +138,6 @@ BOOST_AUTO_TEST_CASE(getMessage_test)
   messageArray = static_cast<int*>(message->GetData());
   BOOST_CHECK(messageArray[0] == 4 && messageArray[1] == 5 && messageArray[2] == 6);
 
-  {
-    std::vector<testData, SpectatorAllocator<testData>> v(SpectatorAllocator<testData>{allocSHM});
-  }
-}
-
-BOOST_AUTO_TEST_CASE(adoptVector_test)
-{
-  size_t session{(size_t)getpid() * 1000 + 3};
-  fair::mq::ProgOptions config;
-  config.SetProperty<std::string>("session", std::to_string(session));
-
-  auto factoryZMQ = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
-  auto factorySHM = fair::mq::TransportFactory::CreateTransportFactory("shmem", "adoptVector_test", &config);
-  auto allocZMQ = getTransportAllocator(factoryZMQ.get());
-  auto allocSHM = getTransportAllocator(factorySHM.get());
-
-  testData::nconstructions = 0;
-
-  // Create a bogus message
-  auto message = factoryZMQ->CreateMessage(3 * sizeof(testData));
-  auto messageAddr = message.get();
-  testData tmpBuf[3] = {3, 2, 1};
-  std::memcpy(message->GetData(), tmpBuf, 3 * sizeof(testData));
-
-  auto adoptedOwner = adoptVector<testData>(3, std::move(message));
-  BOOST_CHECK(adoptedOwner[0].i == 3);
-  BOOST_CHECK(adoptedOwner[1].i == 2);
-  BOOST_CHECK(adoptedOwner[2].i == 1);
-
-  auto reclaimedMessage = o2::pmr::getMessage(std::move(adoptedOwner));
-  BOOST_CHECK(reclaimedMessage.get() == messageAddr);
-  BOOST_CHECK(adoptedOwner.size() == 0);
-
-  auto modified = adoptVector<testData>(3, std::move(reclaimedMessage));
-  modified.emplace_back(9);
-  BOOST_CHECK(modified[3].i == 9);
-  BOOST_CHECK(modified.size() == 4);
-  BOOST_CHECK(testData::nconstructions == 7);
-  auto modifiedMessage = getMessage(std::move(modified));
-  BOOST_CHECK(modifiedMessage != nullptr);
-  BOOST_CHECK(modifiedMessage.get() != messageAddr);
-}
-
-BOOST_AUTO_TEST_CASE(test_SpectatorMemoryResource)
-{
-  constexpr int size = 5;
-  auto buffer = std::make_unique<int[]>(size);
-  auto const* bufferdata = buffer.get();
-  SpectatorMemoryResource<decltype(buffer)> resource(std::move(buffer), size * sizeof(int));
-  std::vector<int, o2::pmr::SpectatorAllocator<int>> bufferclone(size, o2::pmr::SpectatorAllocator<int>(&resource));
-  BOOST_CHECK(bufferclone.data() == bufferdata);
-  BOOST_CHECK(bufferclone.size() == size);
-  BOOST_CHECK_THROW(bufferclone.resize(2 * size), std::runtime_error);
-
-  auto vecbuf = std::make_unique<std::vector<int>>(size);
-  auto const* vectordata = vecbuf->data();
-  SpectatorMemoryResource<decltype(vecbuf)> vecresource(std::move(vecbuf));
-  std::vector<int, o2::pmr::SpectatorAllocator<int>> vecclone(size, o2::pmr::SpectatorAllocator<int>(&vecresource));
-  BOOST_CHECK(vecclone.data() == vectordata);
-  BOOST_CHECK(vecclone.size() == size);
-  BOOST_CHECK_THROW(vecclone.resize(2 * size), std::runtime_error);
-
-  std::vector<int, o2::pmr::SpectatorAllocator<int>> vecmove;
-  vecmove = std::move(vecclone);
-  BOOST_CHECK(vecclone.size() == 0);
-  BOOST_CHECK(vecmove.data() == vectordata);
-  BOOST_CHECK(vecmove.size() == size);
 }
 
 }; // namespace o2::pmr

From aaa0cf536b309262cf03ed50fefc55c84e836ae0 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 13 Jun 2025 14:37:42 +0200
Subject: [PATCH 0503/1764] Make TPC resid.extracton to work in runs w/o TRD or
 TOF

---
 .../TPC/calibration/SpacePoints/src/TrackInterpolation.cxx      | 2 +-
 prodtests/full-system-test/calib-workflow.sh                    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index 7c2110fd5b4e7..d13f24ad728fd 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -148,7 +148,7 @@ void TrackInterpolation::prepareInputTrackSample(const o2::globaltracking::RecoC
   auto trackIndex = mRecoCont->getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
   auto vtxRefs = mRecoCont->getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
   int nv = vtxRefs.size() - 1;
-  GTrackID::mask_t allowedSources = GTrackID::getSourcesMask("ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
+  GTrackID::mask_t allowedSources = GTrackID::getSourcesMask("ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF") & mSourcesConfigured;
   constexpr std::array<int, 3> SrcFast = {int(GTrackID::ITSTPCTRD), int(GTrackID::ITSTPCTOF), int(GTrackID::ITSTPCTRDTOF)};
 
   for (int iv = 0; iv < nv; iv++) {
diff --git a/prodtests/full-system-test/calib-workflow.sh b/prodtests/full-system-test/calib-workflow.sh
index 3dcd95fd04b54..94e95eaab6567 100755
--- a/prodtests/full-system-test/calib-workflow.sh
+++ b/prodtests/full-system-test/calib-workflow.sh
@@ -23,7 +23,7 @@ fi
 if [[ "${CALIB_TPC_SCDCALIB_SENDTRKDATA:-}" == "1" ]]; then ENABLE_TRKDATA_OUTPUT="--send-track-data"; else ENABLE_TRKDATA_OUTPUT=""; fi
 
 # specific calibration workflows
-if [[ $CALIB_TPC_SCDCALIB == 1 ]]; then add_W o2-tpc-scdcalib-interpolation-workflow "--vtx-sources $VERTEX_TRACK_MATCHING_SOURCES ${CALIB_TPC_SCDCALIB_SLOTLENGTH:+"--sec-per-slot $CALIB_TPC_SCDCALIB_SLOTLENGTH"} $ENABLE_TRKDATA_OUTPUT $DISABLE_ROOT_OUTPUT --disable-root-input --pipeline $(get_N tpc-track-interpolation TPC REST)"; fi
+if [[ $CALIB_TPC_SCDCALIB == 1 ]]; then add_W o2-tpc-scdcalib-interpolation-workflow "--vtx-sources $VERTEX_TRACK_MATCHING_SOURCES --tracking-sources $TRACK_SOURCES ${CALIB_TPC_SCDCALIB_SLOTLENGTH:+"--sec-per-slot $CALIB_TPC_SCDCALIB_SLOTLENGTH"} $ENABLE_TRKDATA_OUTPUT $DISABLE_ROOT_OUTPUT --disable-root-input --pipeline $(get_N tpc-track-interpolation TPC REST)"; fi
 if [[ $CALIB_TPC_TIMEGAIN == 1 ]]; then
   : ${SCALEEVENTS_TPC_TIMEGAIN:=40}
   : ${SCALETRACKS_TPC_TIMEGAIN:=1000}

From 9ca2abd0972e87c6193c0bd1543031d4670f3cd4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Mon, 16 Jun 2025 20:40:31 +0200
Subject: [PATCH 0504/1764] [ALICE3] Add Copper stabilizers for A3 Magnet
 (#14410)

---
 .../Upgrades/ALICE3/Passive/CMakeLists.txt    |  2 +
 .../Alice3DetectorsPassive/PassiveBaseParam.h | 43 +++++++++++++++++++
 .../Upgrades/ALICE3/Passive/src/Magnet.cxx    | 33 +++++++++++---
 .../ALICE3/Passive/src/PassiveBaseParam.cxx   | 13 ++++++
 .../ALICE3/Passive/src/PassiveLinkDef.h       |  1 +
 5 files changed, 87 insertions(+), 5 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/PassiveBaseParam.h
 create mode 100644 Detectors/Upgrades/ALICE3/Passive/src/PassiveBaseParam.cxx

diff --git a/Detectors/Upgrades/ALICE3/Passive/CMakeLists.txt b/Detectors/Upgrades/ALICE3/Passive/CMakeLists.txt
index 2689130c495d9..2bd732dfe3b31 100644
--- a/Detectors/Upgrades/ALICE3/Passive/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/Passive/CMakeLists.txt
@@ -12,6 +12,7 @@
 o2_add_library(Alice3DetectorsPassive
                SOURCES src/Pipe.cxx
                        src/PassiveBase.cxx
+                       src/PassiveBaseParam.cxx
                        src/Absorber.cxx
                        src/Magnet.cxx
                PUBLIC_LINK_LIBRARIES O2::Field O2::DetectorsBase O2::SimConfig)
@@ -19,6 +20,7 @@ o2_add_library(Alice3DetectorsPassive
 o2_target_root_dictionary(Alice3DetectorsPassive
                           HEADERS include/Alice3DetectorsPassive/Pipe.h
                                   include/Alice3DetectorsPassive/PassiveBase.h
+                                  include/Alice3DetectorsPassive/PassiveBaseParam.h
                                   include/Alice3DetectorsPassive/Absorber.h
                                   include/Alice3DetectorsPassive/Magnet.h
                           LINKDEF src/PassiveLinkDef.h)
diff --git a/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/PassiveBaseParam.h b/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/PassiveBaseParam.h
new file mode 100644
index 0000000000000..3ac53c1bfb92b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/PassiveBaseParam.h
@@ -0,0 +1,43 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_PASSIVE_BASEPARAM_H_
+#define ALICEO2_PASSIVE_BASEPARAM_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2
+{
+namespace passive
+{
+
+// **
+// ** Parameters for Passive base configuration
+// **
+
+enum MagnetLayout : int {
+  AluminiumStabilizer = 0,
+  CopperStabilizer = 1
+};
+
+struct Alice3PassiveBaseParam : public o2::conf::ConfigurableParamHelper<Alice3PassiveBaseParam> {
+  // Geometry Builder parameters
+
+  int mLayout = MagnetLayout::AluminiumStabilizer;
+
+  O2ParamDef(Alice3PassiveBaseParam, "Alice3PassiveBase");
+};
+
+} // namespace passive
+} // end namespace o2
+
+#endif // ALICEO2_PASSIVE_BASEPARAM_H_
diff --git a/Detectors/Upgrades/ALICE3/Passive/src/Magnet.cxx b/Detectors/Upgrades/ALICE3/Passive/src/Magnet.cxx
index 3e3e6590720cf..5c94c3e31a244 100644
--- a/Detectors/Upgrades/ALICE3/Passive/src/Magnet.cxx
+++ b/Detectors/Upgrades/ALICE3/Passive/src/Magnet.cxx
@@ -12,6 +12,7 @@
 #include <DetectorsBase/Detector.h>
 #include <DetectorsBase/MaterialManager.h>
 #include <Alice3DetectorsPassive/Magnet.h>
+#include <Alice3DetectorsPassive/PassiveBaseParam.h>
 #include <TGeoCompositeShape.h>
 #include <TGeoManager.h>
 #include <TGeoMatrix.h>
@@ -54,11 +55,24 @@ void Alice3Magnet::createMaterials()
   // | Support cylinder |           20            |  8.896   | 0.225  |
   // | Al-strip         |            1            |  8.896   | 0.011  |
   // | NbTi/Cu          |            3            |  1.598   | 0.188  |
-  // | Insulation       |           11            | 17.64    | 0.062  |
+  // | Insulation       |           11            |  17.64   | 0.062  |
   // | Al-stabiliser    |           33            |  8.896   | 0.371  |
   // | Inner cryostat   |           10            |  8.896   | 0.112  |
   // | Outer cryostat   |           30            |  8.896   | 0.337  |
   // +------------------+-------------------------+----------+--------+
+  // Update: 2025-06-16 enabledby setting Alice3PassiveBase.mLayout=1
+  // +------------------+-------------------------+----------+--------+
+  // |  layer           | effective thickness [mm]|  X0 [cm] | X0 [%] |
+  // +------------------+-------------------------+----------+--------+
+  // | Support cylinder |           20            | 8.896 | 0.225     |
+  // | Al-strip         |            1            | 8.896 | 0.011     |
+  // | NbTi/Cu          |            3            | 1.598 | 0.188     |
+  // | Insulation       |           11            | 17.64 | 0.062     |
+  // | Cu-stabiliser    |           22            | 1.436 | 1.532     |
+  // | Inner cryostat   |           10            | 8.896 | 0.112     |
+  // | Outer cryostat   |           30            | 8.896 | 0.337     |
+  // | total            |                         |       | 2.468     |
+  // +------------------+-------------------------+----------+--------+
   // Geometry will be oversimplified in two wrapping cylindrical Al layers (symmetric for the time being) with a Copper layer in between.
 
   //
@@ -90,6 +104,15 @@ void Alice3Magnet::ConstructGeometry()
 {
   createMaterials();
 
+  // Passive Base configuration parameters
+  auto& passiveBaseParam = Alice3PassiveBaseParam::Instance();
+  const bool doCopperStabilizer = (passiveBaseParam.mLayout == o2::passive::MagnetLayout::CopperStabilizer);
+  if (doCopperStabilizer) {
+    mRestMaterialThickness -= 3.3; // cm Remove the Aluminium stabiliser
+    mRestMaterialThickness += 2.2; // cm Add the Copper stabiliser
+    LOG(debug) << "Alice 3 magnet: using Copper Stabilizer with thickness " << mRestMaterialThickness << " cm";
+  }
+
   TGeoManager* geoManager = gGeoManager;
   TGeoVolume* barrel = geoManager->GetVolume("barrel");
   if (!barrel) {
@@ -102,22 +125,22 @@ void Alice3Magnet::ConstructGeometry()
   auto kMedVac = matmgr.getTGeoMedium("ALICE3_MAGNET_VACUUM");
 
   // inner wrap
-  LOGP(debug, "Alice 3 magnet: creating inner wrap with inner radius {} and thickness {}", mInnerWrapInnerRadius, mInnerWrapThickness);
+  LOGP(debug, "Alice 3 magnet: creating inner wrap with inner radius {} cm and thickness {} cm", mInnerWrapInnerRadius, mInnerWrapThickness);
   TGeoTube* innerLayer = new TGeoTube(mInnerWrapInnerRadius, mInnerWrapInnerRadius + mInnerWrapThickness, mZLength / 2);
   TGeoTube* innerVacuum = new TGeoTube(mInnerWrapInnerRadius + mInnerWrapThickness, mCoilInnerRadius, mZLength / 2);
   // coils layer
-  LOGP(debug, "Alice 3 magnet: creating coils layer with inner radius {} and thickness {}", mCoilInnerRadius, mCoilThickness);
+  LOGP(debug, "Alice 3 magnet: creating coils layer with inner radius {} cm and thickness {} cm", mCoilInnerRadius, mCoilThickness);
   TGeoTube* coilsLayer = new TGeoTube(mCoilInnerRadius, mCoilInnerRadius + mCoilThickness, mZLength / 2);
   TGeoTube* restMaterial = new TGeoTube(mRestMaterialRadius, mRestMaterialRadius + mRestMaterialThickness, mZLength / 2);
   TGeoTube* outerVacuum = new TGeoTube(mRestMaterialRadius + mRestMaterialThickness, mOuterWrapInnerRadius, mZLength / 2);
   // outer wrap
-  LOGP(debug, "Alice 3 magnet: creating outer wrap with inner radius {} and thickness {}", mOuterWrapInnerRadius, mOuterWrapThickness);
+  LOGP(debug, "Alice 3 magnet: creating outer wrap with inner radius {} cm and thickness {} cm", mOuterWrapInnerRadius, mOuterWrapThickness);
   TGeoTube* outerLayer = new TGeoTube(mOuterWrapInnerRadius, mOuterWrapInnerRadius + mOuterWrapThickness, mZLength / 2);
 
   TGeoVolume* innerWrapVol = new TGeoVolume("innerWrap", innerLayer, kMedAl);
   TGeoVolume* innerVacuumVol = new TGeoVolume("innerVacuum", innerVacuum, kMedVac);
   TGeoVolume* coilsVol = new TGeoVolume("coils", coilsLayer, kMedCu);
-  TGeoVolume* restMaterialVol = new TGeoVolume("restMaterial", restMaterial, kMedAl);
+  TGeoVolume* restMaterialVol = new TGeoVolume("restMaterial", restMaterial, doCopperStabilizer ? kMedCu : kMedAl);
   TGeoVolume* outerVacuumVol = new TGeoVolume("outerVacuum", outerVacuum, kMedVac);
   TGeoVolume* outerWrapVol = new TGeoVolume("outerWrap", outerLayer, kMedAl);
 
diff --git a/Detectors/Upgrades/ALICE3/Passive/src/PassiveBaseParam.cxx b/Detectors/Upgrades/ALICE3/Passive/src/PassiveBaseParam.cxx
new file mode 100644
index 0000000000000..6b6a6191f0bf5
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/Passive/src/PassiveBaseParam.cxx
@@ -0,0 +1,13 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Alice3DetectorsPassive/PassiveBaseParam.h"
+O2ParamImpl(o2::passive::Alice3PassiveBaseParam);
diff --git a/Detectors/Upgrades/ALICE3/Passive/src/PassiveLinkDef.h b/Detectors/Upgrades/ALICE3/Passive/src/PassiveLinkDef.h
index daac6de56a124..803d308671536 100644
--- a/Detectors/Upgrades/ALICE3/Passive/src/PassiveLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/Passive/src/PassiveLinkDef.h
@@ -16,6 +16,7 @@
 #pragma link off all functions;
 
 #pragma link C++ class o2::passive::Alice3PassiveBase + ;
+#pragma link C++ class o2::passive::Alice3PassiveBaseParam + ;
 #pragma link C++ class o2::passive::Alice3Pipe + ;
 #pragma link C++ class o2::passive::Alice3Absorber + ;
 #pragma link C++ class o2::passive::Alice3Magnet + ;

From 0bbb3da1f6f0ef498ac992f40d09c5d8d3e24a83 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 17 Jun 2025 06:25:11 +0200
Subject: [PATCH 0505/1764] ITS: fix clusterSize propagation (#14412)

---
 Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index dbb1631a4eb10..1a3132413c450 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -180,7 +180,7 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
         locXYZ = dict->getClusterCoordinates(c, patt, false);
         clusterSize = patt.getNPixels();
       }
-      mClusterSize.push_back(std::clamp(clusterSize, 0u, 255u));
+      mClusterSize[clusterId] = std::clamp(clusterSize, 0u, 255u);
       auto sensorID = c.getSensorID();
       // Inverse transformation to the local --> tracking
       auto trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;

From d1fa18a7e41cfbc59840eab174bc9e07981feb59 Mon Sep 17 00:00:00 2001
From: Marvin Hemmer <53471402+mhemmer-cern@users.noreply.github.com>
Date: Tue, 17 Jun 2025 10:31:31 +0200
Subject: [PATCH 0506/1764] [EMCAL-1154] Adjust CellLabels for cross talk
 emulation (#14385)

- The CellLabel class used gsl::span as its members to store the mcLabels and amplitude fractions. However, when we want to use the cross talk emulation, we want to add new cells which happens inside the cross talk emulation function. Outside of this function the newley added CellLabels would point to dangling memory. That's why the members needed to be changed to std::vectors. Also a move constructor was added.
---
 .../EMCAL/include/DataFormatsEMCAL/CellLabel.h | 18 ++++++++++++------
 DataFormats/Detectors/EMCAL/src/CellLabel.cxx  | 11 ++++++++++-
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/CellLabel.h b/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/CellLabel.h
index 81766a3a59cdc..543e49fb06dd8 100644
--- a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/CellLabel.h
+++ b/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/CellLabel.h
@@ -15,6 +15,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <gsl/span>
+#include <vector>
 
 namespace o2
 {
@@ -34,10 +35,15 @@ class CellLabel
  public:
   // CellLabel() = default;
 
-  /// \brief Constructor
+  /// \brief Constructor using std::vector by moving NOT copying
   /// \param labels list of mc labels
   /// \param amplitudeFractions list of amplitude fractions
-  CellLabel(const gsl::span<const int> labels, const gsl::span<const float> amplitudeFractions);
+  CellLabel(std::vector<int> labels, std::vector<float> amplitudeFractions);
+
+  /// \brief Constructor using gsl::span
+  /// \param labels list of mc labels
+  /// \param amplitudeFractions list of amplitude fractions
+  CellLabel(gsl::span<const int> labels, gsl::span<const float> amplitudeFractions);
 
   // ~CellLabel() = default;
   // CellLabel(const CellLabel& clus) = default;
@@ -52,21 +58,21 @@ class CellLabel
   int32_t GetLabel(size_t index) const { return mLabels[index]; }
 
   /// \brief Getter for labels
-  gsl::span<const int32_t> GetLabels() const { return mLabels; }
+  std::vector<int32_t> GetLabels() const { return mLabels; }
 
   /// \brief Getter for amplitude fraction
   /// \param index index which amplitude fraction to get
   float GetAmplitudeFraction(size_t index) const { return mAmplitudeFraction[index]; }
 
   /// \brief Getter for amplitude fractions
-  gsl::span<const float> GetAmplitudeFractions() const { return mAmplitudeFraction; }
+  std::vector<float> GetAmplitudeFractions() const { return mAmplitudeFraction; }
 
   /// \brief Getter for label with leading amplitude fraction
   int32_t GetLeadingMCLabel() const;
 
  protected:
-  gsl::span<const int32_t> mLabels;          ///< List of MC particles that generated the cluster, ordered in deposited energy.
-  gsl::span<const float> mAmplitudeFraction; ///< List of the fraction of the cell energy coming from a MC particle. Index aligns with mLabels!
+  std::vector<int32_t> mLabels;          ///< List of MC particles that generated the cluster, ordered in deposited energy.
+  std::vector<float> mAmplitudeFraction; ///< List of the fraction of the cell energy coming from a MC particle. Index aligns with mLabels!
 };
 
 } // namespace emcal
diff --git a/DataFormats/Detectors/EMCAL/src/CellLabel.cxx b/DataFormats/Detectors/EMCAL/src/CellLabel.cxx
index e37368ea181d7..70a1a642c5449 100644
--- a/DataFormats/Detectors/EMCAL/src/CellLabel.cxx
+++ b/DataFormats/Detectors/EMCAL/src/CellLabel.cxx
@@ -16,10 +16,19 @@
 #include <cstddef>
 #include <cstdint>
 #include <gsl/span>
+#include <vector>
+#include <utility>
 
 using namespace o2::emcal;
 
-CellLabel::CellLabel(const gsl::span<const int> labels, const gsl::span<const float> amplitudeFractions) : mLabels(labels), mAmplitudeFraction(amplitudeFractions)
+CellLabel::CellLabel(std::vector<int> labels, std::vector<float> amplitudeFractions) : mLabels(std::move(labels)), mAmplitudeFraction(std::move(amplitudeFractions))
+{
+  if (labels.size() != amplitudeFractions.size()) {
+    LOG(error) << "Size of labels " << labels.size() << " does not match size of amplitude fraction " << amplitudeFractions.size() << " !";
+  }
+}
+
+CellLabel::CellLabel(gsl::span<const int> labels, gsl::span<const float> amplitudeFractions) : mLabels(labels.begin(), labels.end()), mAmplitudeFraction(amplitudeFractions.begin(), amplitudeFractions.end())
 {
   if (labels.size() != amplitudeFractions.size()) {
     LOG(error) << "Size of labels " << labels.size() << " does not match size of amplitude fraction " << amplitudeFractions.size() << " !";

From ace4b6b0b9feae9dfcb6ffd5e7132a811066faa3 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 5 Jun 2025 08:46:28 +0200
Subject: [PATCH 0507/1764] full_system_test.sh: allow to set RUNNUMBER and
 extra SIMOPTKEY options for beam types other than pp or PbPb

---
 prodtests/full_system_test.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 5c7157f93c652..e8b298cc08d8c 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -67,7 +67,7 @@ if [[ $BEAMTYPE == "PbPb" ]]; then
 else
   FST_GENERATOR=${FST_GENERATOR:-pythia8pp}
   FST_COLRATE=${FST_COLRATE:-400000}
-  RUNNUMBER=303000 # a default un-anchored pp run number
+  RUNNUMBER=${RUNNUMBER:-303000} # a default un-anchored pp run number
 fi
 FST_MC_ENGINE=${FST_MC_ENGINE:-TGeant4}
 FST_EMBEDDING_CONFIG=${FST_EMBEDDING_CONFIG:-GeneratorPythia8.config=$O2_ROOT/prodtests/full-system-test/pythia8.cfg}
@@ -107,7 +107,7 @@ if [[ $BEAMTYPE == "PbPb" && -z $FST_QED ]]; then
   FST_QED=1
 fi
 DIGIQED=
-SIMOPTKEY="Diamond.width[2]=6.;"
+SIMOPTKEY+="Diamond.width[2]=6.;"
 if [[ $FST_QED == 1 ]]; then
   mkdir -p qed
   cd qed

From 79f11174e8b97ddca2f2e3a397cf893d4cb47327 Mon Sep 17 00:00:00 2001
From: Andrea Giovanni Riffero <andrea.giovanni.riffero@cern.ch>
Date: Tue, 17 Jun 2025 12:32:10 +0200
Subject: [PATCH 0508/1764] [MID] Improve the macro for the reject list
 (#14411)

Allow to put custom timestamps in the json used to build the manual reject list.
---
 .../MUON/MID/Calibration/macros/README.md     |  4 ++
 .../MID/Calibration/macros/build_rejectlist.C | 45 +++++++++++++++----
 2 files changed, 40 insertions(+), 9 deletions(-)

diff --git a/Detectors/MUON/MID/Calibration/macros/README.md b/Detectors/MUON/MID/Calibration/macros/README.md
index 83e88f18ecf48..f2cf2aa8bf78b 100644
--- a/Detectors/MUON/MID/Calibration/macros/README.md
+++ b/Detectors/MUON/MID/Calibration/macros/README.md
@@ -72,6 +72,8 @@ This can be done with a json file in the form:
 {
     "startRun": 557251,
     "endRun": 557926,
+    "startTT": 1726300235000,
+    "endTT": 1726324000000,
     "rejectList": [
         {
             "deId": 4,
@@ -99,6 +101,8 @@ This can be done with a json file in the form:
 }
 ```
 
+Where `startTT` and `endTT` are the timestamps in which the manual reject list will be built. To use the timestamps of start/end of the specified runs set `startTT` and `endTT` to 0 (or do not include them in the json).
+
 The path to the file is then given to the macro with:
 
 ```shell
diff --git a/Detectors/MUON/MID/Calibration/macros/build_rejectlist.C b/Detectors/MUON/MID/Calibration/macros/build_rejectlist.C
index 48391b4460687..5cec2c611bcf8 100644
--- a/Detectors/MUON/MID/Calibration/macros/build_rejectlist.C
+++ b/Detectors/MUON/MID/Calibration/macros/build_rejectlist.C
@@ -316,25 +316,52 @@ RejectListStruct load_from_json(const o2::ccdb::CcdbApi& ccdbApi, const char* fi
 {
   // Open the JSON file
   std::cout << "Reading reject list from file " << filename << std::endl;
-  RejectListStruct rl;
   std::ifstream inFile(filename);
   if (!inFile.is_open()) {
     std::cerr << "Could not open the file!" << std::endl;
-    return rl;
+    return {};
   }
 
   // Create an IStreamWrapper for file input stream
   rapidjson::IStreamWrapper isw(inFile);
-
   rapidjson::Document doc;
   if (doc.ParseStream(isw).HasParseError()) {
     std::cerr << "Problem parsing " << filename << std::endl;
-    return rl;
+    return {};
   }
-  auto startRange = o2::ccdb::BasicCCDBManager::getRunDuration(ccdbApi, doc["startRun"].GetInt());
-  auto endRange = o2::ccdb::BasicCCDBManager::getRunDuration(ccdbApi, doc["endRun"].GetInt());
-  rl.start = startRange.first;
-  rl.end = endRange.second;
+
+  // manual-validity interval in ms:
+  int64_t startTSms = 0;
+  int64_t endTSms = 0;
+
+  // run numbers from the json
+  int startRun = doc["startRun"].GetInt();
+  int endRun = doc["endRun"].GetInt();
+
+  // check if there are non-zero timestamps in the json
+  bool hasStartTT = doc.HasMember("startTT") && doc["startTT"].IsInt64() && doc["startTT"].GetInt64() != 0;
+  bool hasEndTT = doc.HasMember("endTT") && doc["endTT"].IsInt64() && doc["endTT"].GetInt64() != 0;
+  if (hasStartTT && hasEndTT) {
+    startTSms = doc["startTT"].GetInt64();
+    endTSms = doc["endTT"].GetInt64();
+
+    // sanity check against the run boundaries
+    auto runStart = o2::ccdb::BasicCCDBManager::getRunDuration(ccdbApi, startRun).first;
+    auto runEnd = o2::ccdb::BasicCCDBManager::getRunDuration(ccdbApi, endRun).second;
+    if (startTSms < runStart || endTSms > runEnd) {
+      std::cout
+        << "\n\nWarning: manual timestamps [" << startTSms << " - " << endTSms
+        << "] lie outside run interval [" << runStart << " - " << runEnd << "]\n\n\n";
+    }
+  } else {
+    // use run start/end if there are no timestamps in the json
+    startTSms = o2::ccdb::BasicCCDBManager::getRunDuration(ccdbApi, startRun).first;
+    endTSms = o2::ccdb::BasicCCDBManager::getRunDuration(ccdbApi, endRun).second;
+  }
+
+  RejectListStruct rl;
+  rl.start = startTSms;
+  rl.end = endTSms;
   std::cout << "Manual RL validity: " << timeRangeToString(rl.start, rl.end) << std::endl;
   auto rlArray = doc["rejectList"].GetArray();
   for (auto& ar : rlArray) {
@@ -453,4 +480,4 @@ void build_rejectlist(long start, long end, const char* qcdbUrl = "http://ali-qc
       outCCDBApi.storeAsTFileAny(&rl.rejectList, "MID/Calib/RejectList", metadata, rl.start, rl.end);
     }
   }
-}
\ No newline at end of file
+}

From d493ded804afcecf95e45565bfca0b48352f7300 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 17 Jun 2025 14:38:25 +0200
Subject: [PATCH 0509/1764] GPU Display: Use 1-argument Vulkan loader which
 might be compatible to more Vulkan implementations

---
 .../display/backend/GPUDisplayBackendOpenGL.cxx   | 15 +++++----------
 .../display/backend/GPUDisplayBackendVulkan.cxx   |  5 ++---
 2 files changed, 7 insertions(+), 13 deletions(-)

diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
index b9bd2731ac641..664734fe6dff0 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
@@ -61,28 +61,23 @@ GPUDisplayBackendOpenGL::GPUDisplayBackendOpenGL()
   mBackendName = "OpenGL";
 }
 
-#ifdef GPUCA_DISPLAY_GL3W
 int32_t GPUDisplayBackendOpenGL::ExtInit()
 {
+#ifdef GPUCA_DISPLAY_GL3W
   return gl3wInit();
-}
 #else
-int32_t GPUDisplayBackendOpenGL::ExtInit()
-{
   return glewInit();
-}
 #endif
-#ifdef GPUCA_DISPLAY_OPENGL_CORE
+}
+
 bool GPUDisplayBackendOpenGL::CoreProfile()
 {
+#ifdef GPUCA_DISPLAY_OPENGL_CORE
   return true;
-}
 #else
-bool GPUDisplayBackendOpenGL::CoreProfile()
-{
   return false;
-}
 #endif
+}
 
 // #define CHKERR(cmd) {cmd;}
 #define CHKERR(cmd)                                                                                                 \
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
index a7e54db725ae0..0c2af55121b7d 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
@@ -340,7 +340,7 @@ double GPUDisplayBackendVulkan::checkDevice(vk::PhysicalDevice device, const std
 
 void GPUDisplayBackendVulkan::createDevice()
 {
-  VULKAN_HPP_DEFAULT_DISPATCHER.init();
+  VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr);
   vk::ApplicationInfo appInfo{};
   appInfo.pApplicationName = "GPU CA Standalone display";
   appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
@@ -355,8 +355,7 @@ void GPUDisplayBackendVulkan::createDevice()
   uint32_t frontendExtensionCount = mDisplay->frontend()->getReqVulkanExtensions(frontendExtensions);
   std::vector<const char*> reqInstanceExtensions(frontendExtensions, frontendExtensions + frontendExtensionCount);
 
-  const std::vector<const char*> reqValidationLayers = {
-    "VK_LAYER_KHRONOS_validation"};
+  const std::vector<const char*> reqValidationLayers = {"VK_LAYER_KHRONOS_validation"};
   auto debugCallback = [](vk::DebugUtilsMessageSeverityFlagBitsEXT messageSeverity, vk::DebugUtilsMessageTypeFlagsEXT messageType, const vk::DebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData) -> VkBool32 {
     static int32_t throwOnError = getenv("GPUCA_VULKAN_VALIDATION_THROW") ? atoi(getenv("GPUCA_VULKAN_VALIDATION_THROW")) : 0;
     static bool showVulkanValidationInfo = getenv("GPUCA_VULKAN_VALIDATION_INFO") && atoi(getenv("GPUCA_VULKAN_VALIDATION_INFO"));

From e2a6098acc7dc7bc1c9c48d76ff9dbc1d4732726 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 17 Jun 2025 15:45:47 +0200
Subject: [PATCH 0510/1764] GPU Display: Add CMake option to disable building
 the display

---
 GPU/GPUTracking/CMakeLists.txt         | 2 +-
 GPU/GPUTracking/display/CMakeLists.txt | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 87b202ec607ae..0560ea2dd12d2 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -27,7 +27,7 @@ set(CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_T
 
 include(cmake/helpers.cmake)
 
-if((ALIGPU_BUILD_TYPE STREQUAL "Standalone" AND GPUCA_BUILD_EVENT_DISPLAY) OR (ALIGPU_BUILD_TYPE STREQUAL "O2" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND TARGET AliceO2::DebugGUI AND OPENGL_FOUND AND GLFW_FOUND))
+if((ALIGPU_BUILD_TYPE STREQUAL "Standalone" AND GPUCA_BUILD_EVENT_DISPLAY) OR (ALIGPU_BUILD_TYPE STREQUAL "O2" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND TARGET AliceO2::DebugGUI AND OPENGL_FOUND AND GLFW_FOUND AND (NOT DEFINED GPUCA_BUILD_EVENT_DISPLAY OR NOT GPUCA_BUILD_EVENT_DISPLAY)))
   set(GPUCA_EVENT_DISPLAY ON)
 endif()
 if(ROOT_FOUND)
diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index a59d5189d6235..513d9b6122c68 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -159,7 +159,7 @@ install(FILES ${HDRS} ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GP
 
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
-message(STATUS "Building GPU Event Display (Vulkan ${GPUCA_EVENT_DISPLAY_VULKAN}, Wayland ${GPUCA_EVENT_DISPLAY_WAYLAND}, Freetype ${GPUCA_EVENT_DISPLAY_FREETYPE}, Fontconfig ${Fontconfig_FOUND}, Qt ${GPUCA_EVENT_DISPLAY_QT})")
+message(STATUS "Building GPU Event Display (Vulkan ${GPUCA_EVENT_DISPLAY_VULKAN} ${Vulkan_VERSION}, Wayland ${GPUCA_EVENT_DISPLAY_WAYLAND}, Freetype ${GPUCA_EVENT_DISPLAY_FREETYPE}, Fontconfig ${Fontconfig_FOUND}, Qt ${GPUCA_EVENT_DISPLAY_QT})")
 target_link_libraries(${targetName} PUBLIC ${GLFW_LIBRARIES} OpenGL::GL)
 target_include_directories(${targetName} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
 

From a1d15805280db0d7f2f3d79771f912049b9499f1 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 17 Jun 2025 20:00:01 +0200
Subject: [PATCH 0511/1764] ITS: GPU accept mc in config

---
 Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index b03d1dccfb8e7..05e873c18b898 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -63,6 +63,7 @@ framework::WorkflowSpec getWorkflow(bool useMC,
         cfg.runITSTracking = true;
         cfg.itsTriggerType = useTrig;
         cfg.itsOverrBeamEst = overrideBeamPosition;
+        cfg.processMC = useMC;
 
         Inputs ggInputs;
         auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true,

From c978bd4476552065eaf31ae2948add3a13840278 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 18 Jun 2025 09:22:28 +0200
Subject: [PATCH 0512/1764] Run the workflow json creation with error severity
 (#14079)

---
 cmake/O2AddWorkflow.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/O2AddWorkflow.cmake b/cmake/O2AddWorkflow.cmake
index b952890921f45..4d47e85420cdf 100644
--- a/cmake/O2AddWorkflow.cmake
+++ b/cmake/O2AddWorkflow.cmake
@@ -53,7 +53,7 @@ function(o2_add_dpl_workflow baseTargetName)
 
   add_custom_command(
     TARGET ${targetExeName} POST_BUILD
-    COMMAND ${CMAKE_COMMAND} -E env ASAN_OPTIONS=detect_leaks=0,detect_container_overflow=0,detect_odr_violation=0 "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}:$$LD_LIBRARY_PATH" $<TARGET_FILE:${targetExeName}> -b --dump-workflow --dump-workflow-file ${jsonFile})
+    COMMAND ${CMAKE_COMMAND} -E env ASAN_OPTIONS=detect_leaks=0,detect_container_overflow=0,detect_odr_violation=0 "LD_LIBRARY_PATH=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}:$$LD_LIBRARY_PATH" $<TARGET_FILE:${targetExeName}> --severity error -b --dump-workflow --dump-workflow-file ${jsonFile})
   add_dependencies(${targetExeName} O2::FrameworkAnalysisSupport O2::FrameworkCCDBSupport)
 
   install(

From 3fa3fe8636e2cb5431a55f7513702834cf25e506 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 18 Jun 2025 18:07:36 +0200
Subject: [PATCH 0513/1764] Add support for ONNXRuntime 1.22.00 (#14419)

---
 Common/ML/include/ML/OrtInterface.h                      | 9 ++-------
 Common/ML/src/OrtInterface.cxx                           | 6 +++---
 .../TPCClusterFinder/GPUTPCNNClusterizerHost.h           | 2 --
 3 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index 7224645425856..0c498e33d2e2c 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -34,10 +34,7 @@ struct MemoryInfo;
 struct Env;
 } // namespace Ort
 
-namespace o2
-{
-
-namespace ml
+namespace o2::ml
 {
 
 class OrtModel
@@ -127,8 +124,6 @@ class OrtModel
   std::string printShape(const std::vector<std::vector<int64_t>>&, std::vector<std::string>&);
 };
 
-} // namespace ml
-
-} // namespace o2
+} // namespace o2::ml
 
 #endif // O2_ML_ORTINTERFACE_H
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index 8f31761489997..1cd9913efb6aa 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -287,9 +287,9 @@ std::vector<O> OrtModel::inference(std::vector<I>& input)
   return outputValuesVec;
 }
 
-template std::vector<float> OrtModel::inference<float, float>(std::vector<float>&);
-template std::vector<float> OrtModel::inference<OrtDataType::Float16_t, float>(std::vector<OrtDataType::Float16_t>&);
-template std::vector<OrtDataType::Float16_t> OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(std::vector<OrtDataType::Float16_t>&);
+template std::vector<float> o2::ml::OrtModel::inference<float, float>(std::vector<float>&);
+template std::vector<float> o2::ml::OrtModel::inference<OrtDataType::Float16_t, float>(std::vector<OrtDataType::Float16_t>&);
+template std::vector<OrtDataType::Float16_t> o2::ml::OrtModel::inference<OrtDataType::Float16_t, OrtDataType::Float16_t>(std::vector<OrtDataType::Float16_t>&);
 
 template <class I, class O>
 void OrtModel::inference(I* input, int64_t input_size, O* output)
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
index 4334c3418eb09..a4449165261be 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
@@ -20,8 +20,6 @@
 #include <vector>
 #include "ML/OrtInterface.h"
 
-using namespace o2::ml;
-
 class OrtMemoryInfo;
 class OrtAllocator;
 struct MockedOrtAllocator;

From ad782f93a74ca0d35c0ce31a1896ea0e27a64c24 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 18 Jun 2025 22:35:59 +0200
Subject: [PATCH 0514/1764] Hide NaN code with -ffast-math

---
 Common/ML/include/ML/3rdparty/GPUORTFloat16.h | 2 ++
 GPU/Common/GPUCommonMath.h                    | 7 ++-----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/Common/ML/include/ML/3rdparty/GPUORTFloat16.h b/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
index 3bf2f465b2a35..75e146d872cd1 100644
--- a/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
+++ b/Common/ML/include/ML/3rdparty/GPUORTFloat16.h
@@ -568,9 +568,11 @@ GPUdi() uint16_t BFloat16Impl<Derived>::ToUint16Impl(float v) noexcept
 template <class Derived>
 GPUdi() float BFloat16Impl<Derived>::ToFloatImpl() const noexcept
 {
+#ifndef __FAST_MATH__
   if (IsNaN()) {
     return o2::gpu::CAMath::QuietNaN();
   }
+#endif
   float result;
   char* const first = reinterpret_cast<char*>(&result);
   char* const second = first + sizeof(uint16_t);
diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index b448a30107dad..372e067b14aff 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -99,12 +99,9 @@ class GPUCommonMath
   GPUhdi() static float Remainderf(float x, float y);
   GPUd() constexpr static bool Finite(float x);
   GPUd() constexpr static bool IsNaN(float x);
-#pragma GCC diagnostic push
-#if defined(__FAST_MATH__) && defined(__clang__)
-#pragma GCC diagnostic ignored "-Wnan-infinity-disabled"
-#endif
+#ifndef __FAST_MATH__
   GPUd() constexpr static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
-#pragma GCC diagnostic pop
+#endif
   GPUd() constexpr static uint32_t Clz(uint32_t val);
   GPUd() constexpr static uint32_t Popcount(uint32_t val);
 

From 1d90dc8f18f27f706ca269958cfe479c0fdab1e9 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 19 Jun 2025 15:48:13 +0200
Subject: [PATCH 0515/1764] Misc fixes for TrackMCStudy workflow

---
 .../GlobalTrackingStudy/TrackMCStudyConfig.h  |  2 +-
 .../GlobalTrackingStudy/TrackMCStudyTypes.h   |  6 ++++--
 .../study/src/TrackMCStudy.cxx                | 20 ++++++++++++++-----
 3 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
index 7d89928a20b37..3c04affd99cb2 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
@@ -28,7 +28,7 @@ struct TrackMCStudyConfig : o2::conf::ConfigurableParamHelper<TrackMCStudyConfig
   bool requireITSorTPCTrackRefs = true;
   bool requireTopBottomRefs = false;
   int minTPCRefsToExtractClRes = 2;
-  float rejectClustersResStat = 0.;
+  float rejectClustersResStat = 0.1;
   float maxTPCRefExtrap = 2;                   // max dX to extrapolate the track ref when extrapolating track true posions
   int decayPDG[5] = {310, 3122, 411, 421, -1}; // decays to study, must end by -1
   O2ParamDef(TrackMCStudyConfig, "trmcconf");
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
index 5b1217f9a6539..5d5cfd9c93523 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
@@ -52,7 +52,8 @@ struct MCTrackInfo {
   uint8_t maxTPCRowSect = -1;
   int8_t nITSCl = 0;
   int8_t pattITSCl = 0;
-  ClassDefNV(MCTrackInfo, 4);
+  bool addedAtRecStage = false;
+  ClassDefNV(MCTrackInfo, 5);
 };
 
 struct RecTrack {
@@ -75,6 +76,7 @@ struct RecTrack {
   uint8_t nClTPC = 0;
   uint8_t pattITS = 0;
   int8_t lowestPadRow = -1;
+  int8_t padFromEdge = -1;
 
   bool isFakeGLO() const { return flags & FakeGLO; }
   bool isFakeITS() const { return flags & FakeITS; }
@@ -83,7 +85,7 @@ struct RecTrack {
   bool isFakeTOF() const { return flags & FakeTOF; }
   bool isFakeITSTPC() const { return flags & FakeITSTPC; }
 
-  ClassDefNV(RecTrack, 1);
+  ClassDefNV(RecTrack, 2);
 };
 
 struct TrackPairInfo {
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index d380a4f05cedf..7c53cf1467494 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -122,6 +122,7 @@ class TrackMCStudy : public Task
   std::vector<float> mTPCOcc;    ///< TPC occupancy for this interaction time
   std::vector<int> mITSOcc;      //< N ITS clusters in the ROF containing collision
   bool mCheckSV = false;         //< check SV binding (apart from prongs availability)
+  bool mRecProcStage = false;    //< flag that the MC particle was added only at the stage of reco tracks processing
   int mNTPCOccBinLength = 0;     ///< TPC occ. histo bin length in TBs
   float mNTPCOccBinLengthInv;
   int mVerbose = 0;
@@ -185,6 +186,7 @@ void TrackMCStudy::run(ProcessingContext& pc)
 
   recoData.collectData(pc, *mDataRequest.get()); // select tracks of needed type, with minimal cuts, the real selected will be done in the vertexer
   updateTimeDependentParams(pc);                 // Make sure this is called after recoData.collectData, which may load some conditions
+  mRecProcStage = false;
   process(recoData);
 }
 
@@ -278,15 +280,21 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
     return patt;
   };
 
-  auto getLowestPadrow = [&recoData](const o2::tpc::TrackTPC& trc) {
+  auto getLowestPadrow = [&recoData](const o2::tpc::TrackTPC& trc, RecTrack& tref) {
     if (recoData.inputsTPCclusters) {
       uint8_t clSect = 0, clRow = 0;
       uint32_t clIdx = 0;
       const auto clRefs = recoData.getTPCTracksClusterRefs();
+      const auto tpcClusAcc = recoData.getTPCClusters();
       trc.getClusterReference(clRefs, trc.getNClusterReferences() - 1, clSect, clRow, clIdx);
-      return int(clRow);
+      const auto& clus = tpcClusAcc.clusters[clSect][clRow][clIdx];
+      int padFromEdge = int(clus.getPad()), npads = o2::gpu::GPUTPCGeometry::NPads(clRow);
+      if (padFromEdge > npads / 2) {
+        padFromEdge = npads - 1 - padFromEdge;
+      }
+      tref.padFromEdge = uint8_t(padFromEdge);
+      tref.lowestPadRow = clRow;
     }
-    return -1;
   };
 
   auto flagTPCClusters = [&recoData](const o2::tpc::TrackTPC& trc, o2::MCCompLabel lbTrc) {
@@ -352,7 +360,7 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
     int nev = mcReader.getNEvents(curSrcMC);
     bool okAccVtx = true;
     if (nev != (int)mMCVtVec.size()) {
-      LOGP(error, "source {} has {} events while {} MC vertices were booked", curSrcMC, nev, mMCVtVec.size());
+      LOGP(debug, "source {} has {} events while {} MC vertices were booked", curSrcMC, nev, mMCVtVec.size());
       okAccVtx = false;
     }
     for (curEvMC = 0; curEvMC < nev; curEvMC++) {
@@ -382,6 +390,7 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
   }
 
   // add reconstruction info to MC particles. If MC particle was not selected before but was reconstrected, account MC info
+  mRecProcStage = true; // MC particles accepted only at this stage will be flagged
   for (int iv = 0; iv < nv; iv++) {
     if (mVerbose > 1) {
       LOGP(info, "processing PV {} of {}", iv, nv);
@@ -532,7 +541,7 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
         if (msk[DetID::TPC]) {
           const auto& trtpc = recoData.getTPCTrack(gidSet[GTrackID::TPC]);
           tref.nClTPC = trtpc.getNClusters();
-          tref.lowestPadRow = getLowestPadrow(trtpc);
+          getLowestPadrow(trtpc, tref);
           flagTPCClusters(trtpc, entry.first);
           if (trackFam.entTPC < 0) {
             trackFam.entTPC = tcnt;
@@ -1088,6 +1097,7 @@ bool TrackMCStudy::addMCParticle(const MCTrack& mcPart, const o2::MCCompLabel& l
   mcEntry.mcTrackInfo.bcInTF = mIntBC[lb.getEventID()];
   mcEntry.mcTrackInfo.occTPC = mTPCOcc[lb.getEventID()];
   mcEntry.mcTrackInfo.occITS = mITSOcc[lb.getEventID()];
+  mcEntry.mcTrackInfo.addedAtRecStage = mRecProcStage;
   int moth = -1;
   o2::MCCompLabel mclbPar;
   if ((moth = mcPart.getMotherTrackId()) >= 0) {

From 52d7d5820abf5e051711d4bbd5dea4ac3ee3badf Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 20 Jun 2025 07:19:08 +0200
Subject: [PATCH 0516/1764] ITS: allow sharing of arena in Tracker & Vertexer
 (#14394)

---
 .../tracking/include/ITStracking/Tracker.h    |   5 +-
 .../include/ITStracking/TrackerTraits.h       |   7 +-
 .../include/ITStracking/TrackingInterface.h   |   3 +
 .../tracking/include/ITStracking/Vertexer.h   |   5 +
 .../include/ITStracking/VertexerTraits.h      |   9 +-
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |   1 -
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 891 +++++++++---------
 .../ITS/tracking/src/TrackingInterface.cxx    |  15 +
 .../ITS/tracking/src/VertexerTraits.cxx       |  26 +-
 9 files changed, 467 insertions(+), 495 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index b393d743809fd..5ba9b5039f808 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -27,6 +27,8 @@
 #include <utility>
 #include <sstream>
 
+#include <oneapi/tbb/task_arena.h>
+
 #include "ITStracking/Configuration.h"
 #include "CommonConstants/MathConstants.h"
 #include "ITStracking/Definitions.h"
@@ -73,8 +75,7 @@ class Tracker
   void setBz(float bz) { mTraits->setBz(bz); }
   void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mTraits->setCorrType(type); }
   bool isMatLUT() const { return mTraits->isMatLUT(); }
-  void setNThreads(int n) { mTraits->setNThreads(n); }
-  int getNThreads() const { return mTraits->getNThreads(); }
+  void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena) { mTraits->setNThreads(n, arena); }
   void printSummary() const;
 
  private:
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 36956a5206277..7ba67a01fce13 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -80,8 +80,8 @@ class TrackerTraits
   void SetRecoChain(o2::gpu::GPUChainITS* chain) { mChain = chain; }
   void setSmoothing(bool v) { mApplySmoothing = v; }
   bool getSmoothing() const { return mApplySmoothing; }
-  void setNThreads(int n);
-  int getNThreads() const { return mNThreads; }
+  void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena);
+  int getNThreads() { return mTaskArena->max_concurrency(); }
 
   o2::gpu::GPUChainITS* getChain() const { return mChain; }
 
@@ -94,10 +94,9 @@ class TrackerTraits
   track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3);
   bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0);
 
-  int mNThreads = 1;
   bool mApplySmoothing = false;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
-  tbb::task_arena mTaskArena;
+  std::shared_ptr<tbb::task_arena> mTaskArena;
 
  protected:
   o2::base::PropagatorImpl<float>::MatCorrType mCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index 732efcb9e0861..64fd4f8156cca 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -28,6 +28,8 @@
 #include "GPUO2Interface.h"
 #include "GPUChainITS.h"
 
+#include <oneapi/tbb/task_arena.h>
+
 namespace o2::its
 {
 class ITSTrackingInterface
@@ -98,6 +100,7 @@ class ITSTrackingInterface
   std::unique_ptr<Vertexer> mVertexer = nullptr;
   const o2::dataformats::MeanVertexObject* mMeanVertex;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  std::shared_ptr<tbb::task_arena> mTaskArena;
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 63dd41b4a0a8f..98bcb95ef65df 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -21,6 +21,9 @@
 #include <iomanip>
 #include <array>
 #include <iosfwd>
+#include <memory>
+
+#include <oneapi/tbb/task_arena.h>
 
 #include "ITStracking/ROframe.h"
 #include "ITStracking/Constants.h"
@@ -90,6 +93,8 @@ class Vertexer
                    const unsigned selectedN, const unsigned int vertexN, const float initT,
                    const float trackletT, const float selecT, const float vertexT);
 
+  void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena) { mTraits->setNThreads(n, arena); }
+
  private:
   std::uint32_t mTimeFrameCounter = 0;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index e1e1d44e8ead9..6554e53fa2ee8 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -17,6 +17,7 @@
 #define O2_ITS_TRACKING_VERTEXER_TRAITS_H_
 
 #include <array>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -93,8 +94,8 @@ class VertexerTraits
   auto getVertexingParameters() const { return mVrtParams; }
   void setVertexingParameters(std::vector<VertexingParameters>& vertParams) { mVrtParams = vertParams; }
   void dumpVertexerTraits();
-  void setNThreads(int n);
-  int getNThreads() const { return mNThreads; }
+  void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena);
+  int getNThreads() { return mTaskArena->max_concurrency(); }
   virtual bool isGPU() const noexcept { return false; }
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool usesMemoryPool() const noexcept { return true; }
@@ -116,8 +117,6 @@ class VertexerTraits
   }
 
  protected:
-  int mNThreads = 1;
-
   std::vector<VertexingParameters> mVrtParams;
   IndexTableUtils mIndexTableUtils;
 
@@ -125,7 +124,7 @@ class VertexerTraits
   TimeFrame7* mTimeFrame = nullptr; // observer ptr
  private:
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
-  tbb::task_arena mTaskArena;
+  std::shared_ptr<tbb::task_arena> mTaskArena;
 };
 
 inline void VertexerTraits::initialise(const TrackingParameters& trackingParams, const int iteration)
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index c92d1e8505356..09d9cee06d9f9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -342,7 +342,6 @@ void Tracker::getGlobalConfiguration()
   } else {
     mTraits->setCorrType(o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT);
   }
-  setNThreads(tc.nThreads);
   int nROFsPerIterations = tc.nROFsPerIterations > 0 ? tc.nROFsPerIterations : -1;
   if (tc.nOrbitsPerIterations > 0) {
     /// code to be used when the number of ROFs per orbit is known, this gets priority over the number of ROFs per iteration
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 36636069137f3..8dd6b9870115c 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -17,6 +17,7 @@
 #include <iostream>
 #include <iterator>
 #include <ranges>
+#include <type_traits>
 
 #ifdef OPTIMISATION_OUTPUT
 #include <format>
@@ -43,6 +44,12 @@ namespace o2::its
 
 static constexpr int debugLevel{0};
 
+struct PassMode {
+  using OnePass = std::integral_constant<int, 0>;
+  using TwoPassCount = std::integral_constant<int, 1>;
+  using TwoPassInsert = std::integral_constant<int, 2>;
+};
+
 template <int nLayers>
 void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
 {
@@ -64,14 +71,15 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
   gsl::span<const Vertex> diamondSpan(&diamondVert, 1);
   int startROF{mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * mTrkParams[iteration].nROFsPerIterations : 0};
   int endROF{o2::gpu::GPUCommonMath::Min(mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * mTrkParams[iteration].nROFsPerIterations + mTrkParams[iteration].DeltaROF : mTimeFrame->getNrof(), mTimeFrame->getNrof())};
-  for (int rof0{startROF}; rof0 < endROF; ++rof0) {
-    gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(rof0);
-    const int startVtx{iVertex >= 0 ? iVertex : 0};
-    const int endVtx{iVertex >= 0 ? o2::gpu::CAMath::Min(iVertex + 1, static_cast<int>(primaryVertices.size())) : static_cast<int>(primaryVertices.size())};
-    int minRof = o2::gpu::CAMath::Max(startROF, rof0 - mTrkParams[iteration].DeltaROF);
-    int maxRof = o2::gpu::CAMath::Min(endROF - 1, rof0 + mTrkParams[iteration].DeltaROF);
-
-    mTaskArena.execute([&] {
+
+  mTaskArena->execute([&] {
+    for (int rof0{startROF}; rof0 < endROF; ++rof0) {
+      gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(rof0);
+      const int startVtx{iVertex >= 0 ? iVertex : 0};
+      const int endVtx{iVertex >= 0 ? o2::gpu::CAMath::Min(iVertex + 1, static_cast<int>(primaryVertices.size())) : static_cast<int>(primaryVertices.size())};
+      int minRof = o2::gpu::CAMath::Max(startROF, rof0 - mTrkParams[iteration].DeltaROF);
+      int maxRof = o2::gpu::CAMath::Min(endROF - 1, rof0 + mTrkParams[iteration].DeltaROF);
+
       tbb::parallel_for(
         tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
         [&](const tbb::blocked_range<int>& Layers) {
@@ -190,49 +198,39 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
             }
           }
         });
-    });
-  }
-
-  auto sortTracklets = [](const Tracklet& a, const Tracklet& b) -> bool {
-    return a.firstClusterIndex < b.firstClusterIndex || (a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex < b.secondClusterIndex);
-  };
-  auto equalTracklets = [](const Tracklet& a, const Tracklet& b) -> bool {
-    return a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex == b.secondClusterIndex;
-  };
+    }
 
-  mTaskArena.execute([&] {
     tbb::parallel_for(
-      tbb::blocked_range<int>(0, mTrkParams[iteration].CellsPerRoad()),
+      tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
       [&](const tbb::blocked_range<int>& Layers) {
         for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
           /// Sort tracklets
-          auto& trkl{mTimeFrame->getTracklets()[iLayer + 1]};
-          tbb::parallel_sort(trkl.begin(), trkl.end(), sortTracklets);
+          auto& trkl{mTimeFrame->getTracklets()[iLayer]};
+          tbb::parallel_sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
+            return a.firstClusterIndex < b.firstClusterIndex || (a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex < b.secondClusterIndex);
+          });
           /// Remove duplicates
-          trkl.erase(std::unique(trkl.begin(), trkl.end(), equalTracklets), trkl.end());
+          trkl.erase(std::unique(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
+                       return a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex == b.secondClusterIndex;
+                     }),
+                     trkl.end());
           trkl.shrink_to_fit();
-          /// recalculate lut
-          auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer]};
-          std::fill(lut.begin(), lut.end(), 0);
-          if (trkl.empty()) {
-            return;
-          }
-          for (const auto& tkl : trkl) {
-            lut[tkl.firstClusterIndex]++;
+          if (iLayer > 0) { /// recalculate lut
+            auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer - 1]};
+            std::fill(lut.begin(), lut.end(), 0);
+            if (trkl.empty()) {
+              return;
+            }
+            for (const auto& tkl : trkl) {
+              lut[tkl.firstClusterIndex]++;
+            }
+            std::exclusive_scan(lut.begin(), lut.end(), lut.begin(), 0);
+            lut.push_back(trkl.size());
           }
-          std::exclusive_scan(lut.begin(), lut.end(), lut.begin(), 0);
-          lut.push_back(trkl.size());
         }
       });
   });
 
-  /// Layer 0 is done outside the loop
-  // in-place deduplication
-  auto& trklt0 = mTimeFrame->getTracklets()[0];
-  mTaskArena.execute([&] { tbb::parallel_sort(trklt0.begin(), trklt0.end(), sortTracklets); });
-  trklt0.erase(std::unique(trklt0.begin(), trklt0.end(), equalTracklets), trklt0.end());
-  trklt0.shrink_to_fit();
-
   /// Create tracklets labels
   if (mTimeFrame->hasMCinformation()) {
     for (int iLayer{0}; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
@@ -275,184 +273,134 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
     }
   }
 
-  mTaskArena.execute([&] {
-    tbb::parallel_for(
-      tbb::blocked_range<int>(0, mTrkParams[iteration].CellsPerRoad()),
-      [&](const tbb::blocked_range<int>& Layers) {
-        for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
-
-          if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
-              mTimeFrame->getTracklets()[iLayer].empty()) {
-            continue;
-          }
-
-#ifdef OPTIMISATION_OUTPUT
-          float resolution{o2::gpu::CAMath::Sqrt(0.5f * (mTrkParams[iteration].SystErrorZ2[iLayer] + mTrkParams[iteration].SystErrorZ2[iLayer + 1] + mTrkParams[iteration].SystErrorZ2[iLayer + 2] + mTrkParams[iteration].SystErrorY2[iLayer] + mTrkParams[iteration].SystErrorY2[iLayer + 1] + mTrkParams[iteration].SystErrorY2[iLayer + 2])) / mTrkParams[iteration].LayerResolution[iLayer]};
-          resolution = resolution > 1.e-12 ? resolution : 1.f;
-#endif
-
-          // count number of cells found
-          const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
-          bounded_vector<int> perTrackletCount(currentLayerTrackletsNum + 1, 0, mMemoryPool.get());
-          tbb::parallel_for(
-            tbb::blocked_range<int>(0, currentLayerTrackletsNum),
-            [&](const tbb::blocked_range<int>& Tracklets) {
-              for (int iTracklet = Tracklets.begin(); iTracklet < Tracklets.end(); ++iTracklet) {
-                const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
-                const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
-                const int nextLayerFirstTrackletIndex{
-                  mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
-                const int nextLayerLastTrackletIndex{
-                  mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
-
-                if (nextLayerFirstTrackletIndex == nextLayerLastTrackletIndex) {
-                  continue;
-                }
-
-                int foundCells{0};
-                for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
-                  if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
-                    break;
-                  }
-                  const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
-                  const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
+  mTaskArena->execute([&] {
+    auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeed>& layerCells, int iTracklet, int offset = 0) -> int {
+      const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
+      const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
+      const int nextLayerFirstTrackletIndex{
+        mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
+      const int nextLayerLastTrackletIndex{
+        mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
+
+      int foundCells{0};
+      for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
+        if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
+          break;
+        }
+        const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
+        const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
 
 #ifdef OPTIMISATION_OUTPUT
-                  bool good{mTimeFrame->getTrackletsLabel(iLayer)[iTracklet] == mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
-                  float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
-                  off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
+        float resolution{o2::gpu::CAMath::Sqrt(0.5f * (mTrkParams[iteration].SystErrorZ2[iLayer] + mTrkParams[iteration].SystErrorZ2[iLayer + 1] + mTrkParams[iteration].SystErrorZ2[iLayer + 2] + mTrkParams[iteration].SystErrorY2[iLayer] + mTrkParams[iteration].SystErrorY2[iLayer + 1] + mTrkParams[iteration].SystErrorY2[iLayer + 2])) / mTrkParams[iteration].LayerResolution[iLayer]};
+        resolution = resolution > 1.e-12 ? resolution : 1.f;
+        bool good{mTimeFrame->getTrackletsLabel(iLayer)[iTracklet] == mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
+        float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
+        off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
 #endif
 
-                  if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
+        if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
 
-                    /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
-                    const int clusId[3]{
-                      mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
-                      mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
-                      mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
-                    const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer][clusId[0]];
-                    const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1][clusId[1]];
-                    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2)[clusId[2]];
-                    auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
+          /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
+          const int clusId[3]{
+            mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
+            mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
+            mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
+          const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer][clusId[0]];
+          const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1][clusId[1]];
+          const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2)[clusId[2]];
+          auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
 
-                    float chi2{0.f};
-                    bool good{false};
-                    for (int iC{2}; iC--;) {
-                      const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC)[clusId[iC]];
+          float chi2{0.f};
+          bool good{false};
+          for (int iC{2}; iC--;) {
+            const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC)[clusId[iC]];
 
-                      if (!track.rotate(trackingHit.alphaTrackingFrame)) {
-                        break;
-                      }
+            if (!track.rotate(trackingHit.alphaTrackingFrame)) {
+              break;
+            }
 
-                      if (!track.propagateTo(trackingHit.xTrackingFrame, getBz())) {
-                        break;
-                      }
+            if (!track.propagateTo(trackingHit.xTrackingFrame, getBz())) {
+              break;
+            }
 
-                      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
-                        break;
-                      }
+            if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
+              break;
+            }
 
-                      const auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
-                      if (!iC && predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
-                        break;
-                      }
+            const auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
+            if (!iC && predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
+              break;
+            }
 
-                      if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
-                        break;
-                      }
+            if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
+              break;
+            }
 
-                      good = !iC;
-                      chi2 += predChi2;
-                    }
-                    if (good) {
-                      ++foundCells;
-                    }
-                  }
-                }
-                perTrackletCount[iTracklet] = foundCells;
-              }
-            });
+            good = !iC;
+            chi2 += predChi2;
+          }
+          if (good) {
+            if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
+              layerCells.emplace_back(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
+              ++foundCells;
+            } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
+              ++foundCells;
+            } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
+              layerCells[offset++] = CellSeed(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
+            } else {
+              static_assert(false, "Unknown mode!");
+            }
+          }
+        }
+      }
+      return foundCells;
+    };
 
-          // calculate offset table and check if any cells where found
-          std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
-          auto totalCells{perTrackletCount.back()};
-          if (totalCells == 0) {
+    tbb::parallel_for(
+      tbb::blocked_range<int>(0, mTrkParams[iteration].CellsPerRoad()),
+      [&](const tbb::blocked_range<int>& Layers) {
+        for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
+          if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
+              mTimeFrame->getTracklets()[iLayer].empty()) {
             continue;
           }
-          auto& layerCells = mTimeFrame->getCells()[iLayer];
-          layerCells.resize(totalCells);
 
-          tbb::parallel_for(
-            tbb::blocked_range<int>(0, currentLayerTrackletsNum),
-            [&](const tbb::blocked_range<int>& Tracklets) {
-              for (int iTracklet = Tracklets.begin(); iTracklet < Tracklets.end(); ++iTracklet) {
-                if (perTrackletCount[iTracklet] == perTrackletCount[iTracklet + 1]) {
-                  continue;
+          auto& layerCells = mTimeFrame->getCells()[iLayer];
+          const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
+          bounded_vector<int> perTrackletCount(currentLayerTrackletsNum + 1, 0, mMemoryPool.get());
+          if (mTaskArena->max_concurrency() <= 1) {
+            for (int iTracklet{0}; iTracklet < currentLayerTrackletsNum; ++iTracklet) {
+              perTrackletCount[iTracklet] = forTrackletCells(PassMode::OnePass{}, iLayer, layerCells, iTracklet);
+            }
+            std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
+          } else {
+            tbb::parallel_for(
+              tbb::blocked_range<int>(0, currentLayerTrackletsNum),
+              [&](const tbb::blocked_range<int>& Tracklets) {
+                for (int iTracklet = Tracklets.begin(); iTracklet < Tracklets.end(); ++iTracklet) {
+                  perTrackletCount[iTracklet] = forTrackletCells(PassMode::TwoPassCount{}, iLayer, layerCells, iTracklet);
                 }
+              });
 
-                const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
-                const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
-                const int nextLayerFirstTrackletIndex{
-                  mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
-                const int nextLayerLastTrackletIndex{
-                  mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
-
-                int position = perTrackletCount[iTracklet];
-                for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
-                  if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
-                    break;
-                  }
-                  const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
-                  const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
-
-                  if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
-
-                    /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
-                    const int clusId[3]{
-                      mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
-                      mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
-                      mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
-                    const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer][clusId[0]];
-                    const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1][clusId[1]];
-                    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2)[clusId[2]];
-                    auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
-
-                    float chi2{0.f};
-                    bool good{false};
-                    for (int iC{2}; iC--;) {
-                      const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC)[clusId[iC]];
-
-                      if (!track.rotate(trackingHit.alphaTrackingFrame)) {
-                        break;
-                      }
-
-                      if (!track.propagateTo(trackingHit.xTrackingFrame, getBz())) {
-                        break;
-                      }
-
-                      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
-                        break;
-                      }
-
-                      const auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
-                      if (!iC && predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
-                        break;
-                      }
-
-                      if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
-                        break;
-                      }
-
-                      good = !iC;
-                      chi2 += predChi2;
-                    }
-                    if (good) {
-                      layerCells[position++] = CellSeed(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
-                    }
+            std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
+            auto totalCells{perTrackletCount.back()};
+            if (totalCells == 0) {
+              continue;
+            }
+            layerCells.resize(totalCells);
+
+            tbb::parallel_for(
+              tbb::blocked_range<int>(0, currentLayerTrackletsNum),
+              [&](const tbb::blocked_range<int>& Tracklets) {
+                for (int iTracklet = Tracklets.begin(); iTracklet < Tracklets.end(); ++iTracklet) {
+                  int offset = perTrackletCount[iTracklet];
+                  if (offset == perTrackletCount[iTracklet + 1]) {
+                    continue;
                   }
+                  forTrackletCells(PassMode::TwoPassInsert{}, iLayer, layerCells, iTracklet, offset);
                 }
-              }
-            });
+              });
+          }
 
           if (iLayer > 0) {
             auto& lut = mTimeFrame->getCellsLookupTable()[iLayer - 1];
@@ -487,128 +435,132 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
 #ifdef OPTIMISATION_OUTPUT
   std::ofstream off(std::format("cellneighs{}.txt", iteration));
 #endif
-  for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
-    const int nextLayerCellsNum{static_cast<int>(mTimeFrame->getCells()[iLayer + 1].size())};
-    deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
-    deepVectorClear(mTimeFrame->getCellsNeighboursLUT()[iLayer]);
-    if (mTimeFrame->getCells()[iLayer + 1].empty() ||
-        mTimeFrame->getCellsLookupTable()[iLayer].empty()) {
-      continue;
-    }
 
-    mTaskArena.execute([&] {
-      int layerCellsNum{static_cast<int>(mTimeFrame->getCells()[iLayer].size())};
+  struct Neighbor {
+    int cell{-1}, nextCell{-1}, level{-1};
+  };
 
-      bounded_vector<int> perCellCount(layerCellsNum + 1, 0, mMemoryPool.get());
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, layerCellsNum),
-        [&](const tbb::blocked_range<int>& Cells) {
-          for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
-            const auto& currentCellSeed{mTimeFrame->getCells()[iLayer][iCell]};
-            const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
-            const int nextLayerFirstCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex]};
-            const int nextLayerLastCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex + 1]};
-
-            int foundNextCells{0};
-            for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
-              auto nextCellSeed{mTimeFrame->getCells()[iLayer + 1][iNextCell]}; /// copy
-              if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) {
-                break;
-              }
+  mTaskArena->execute([&] {
+    for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
+      deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
+      deepVectorClear(mTimeFrame->getCellsNeighboursLUT()[iLayer]);
+      if (mTimeFrame->getCells()[iLayer + 1].empty() ||
+          mTimeFrame->getCellsLookupTable()[iLayer].empty()) {
+        continue;
+      }
 
-              if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
-                  !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
-                continue;
-              }
-              float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
+      int nCells{static_cast<int>(mTimeFrame->getCells()[iLayer].size())};
+      bounded_vector<Neighbor> cellsNeighbours(mMemoryPool.get());
+
+      auto forCellNeighbour = [&](auto Tag, int iCell, int offset = 0) -> int {
+        const auto& currentCellSeed{mTimeFrame->getCells()[iLayer][iCell]};
+        const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
+        const int nextLayerFirstCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex]};
+        const int nextLayerLastCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex + 1]};
+        int foundNextCells{0};
+        for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
+          auto nextCellSeed{mTimeFrame->getCells()[iLayer + 1][iNextCell]}; /// copy
+          if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) {
+            break;
+          }
+
+          if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
+              !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
+            continue;
+          }
+          float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
 
 #ifdef OPTIMISATION_OUTPUT
-              bool good{mTimeFrame->getCellsLabel(iLayer)[iCell] == mTimeFrame->getCellsLabel(iLayer + 1)[iNextCell]};
-              off << std::format("{}\t{:d}\t{}", iLayer, good, chi2) << std::endl;
+          bool good{mTimeFrame->getCellsLabel(iLayer)[iCell] == mTimeFrame->getCellsLabel(iLayer + 1)[iNextCell]};
+          off << std::format("{}\t{:d}\t{}", iLayer, good, chi2) << std::endl;
 #endif
 
-              if (chi2 > mTrkParams[0].MaxChi2ClusterAttachment) {
-                continue;
-              }
-              ++foundNextCells;
-            }
-            perCellCount[iCell] = foundNextCells;
+          if (chi2 > mTrkParams[0].MaxChi2ClusterAttachment) {
+            continue;
           }
-        });
 
-      std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
-      int totalCellNeighbours = perCellCount.back();
-      if (totalCellNeighbours == 0) {
-        deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
-        return;
-      }
-
-      struct Neighbor {
-        int cell{-1}, nextCell{-1}, level{-1};
+          if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
+            cellsNeighbours.emplace_back(iCell, iNextCell, currentCellSeed.getLevel() + 1);
+          } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
+            ++foundNextCells;
+          } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
+            cellsNeighbours[offset++] = {iCell, iNextCell, currentCellSeed.getLevel() + 1};
+          } else {
+            static_assert(false, "Unknown mode!");
+          }
+        }
+        return foundNextCells;
       };
-      bounded_vector<Neighbor> cellsNeighbours(mMemoryPool.get());
-      cellsNeighbours.resize(totalCellNeighbours);
 
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, layerCellsNum),
-        [&](const tbb::blocked_range<int>& Cells) {
-          for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
-            if (perCellCount[iCell] == perCellCount[iCell + 1]) {
-              continue;
+      if (mTaskArena->max_concurrency() <= 1) {
+        for (int iCell{0}; iCell < nCells; ++iCell) {
+          forCellNeighbour(PassMode::OnePass{}, iCell);
+        }
+      } else {
+        bounded_vector<int> perCellCount(nCells + 1, 0, mMemoryPool.get());
+        tbb::parallel_for(
+          tbb::blocked_range<int>(0, nCells),
+          [&](const tbb::blocked_range<int>& Cells) {
+            for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
+              perCellCount[iCell] = forCellNeighbour(PassMode::TwoPassCount{}, iCell);
             }
-            const auto& currentCellSeed{mTimeFrame->getCells()[iLayer][iCell]};
-            const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
-            const int nextLayerFirstCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex]};
-            const int nextLayerLastCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex + 1]};
-
-            int position = perCellCount[iCell];
-            for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
-              auto nextCellSeed{mTimeFrame->getCells()[iLayer + 1][iNextCell]}; /// copy
-              if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) {
-                break;
-              }
+          });
 
-              if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
-                  !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
-                continue;
-              }
-
-              float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
-              if (chi2 > mTrkParams[0].MaxChi2ClusterAttachment) {
+        std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
+        int totalCellNeighbours = perCellCount.back();
+        if (totalCellNeighbours == 0) {
+          deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
+          continue;
+        }
+        cellsNeighbours.resize(totalCellNeighbours);
+
+        tbb::parallel_for(
+          tbb::blocked_range<int>(0, nCells),
+          [&](const tbb::blocked_range<int>& Cells) {
+            for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
+              int offset = perCellCount[iCell];
+              if (offset == perCellCount[iCell + 1]) {
                 continue;
               }
-
-              cellsNeighbours[position++] = {iCell, iNextCell, currentCellSeed.getLevel() + 1};
+              forCellNeighbour(PassMode::TwoPassInsert{}, iCell, offset);
             }
-          }
-        });
+          });
+      }
+
+      if (cellsNeighbours.empty()) {
+        continue;
+      }
 
       tbb::parallel_sort(cellsNeighbours.begin(), cellsNeighbours.end(), [](const auto& a, const auto& b) {
         return a.nextCell < b.nextCell;
       });
 
       auto& cellsNeighbourLUT = mTimeFrame->getCellsNeighboursLUT()[iLayer];
-      cellsNeighbourLUT.assign(nextLayerCellsNum, 0);
+      cellsNeighbourLUT.assign(mTimeFrame->getCells()[iLayer + 1].size(), 0);
       for (const auto& neigh : cellsNeighbours) {
         ++cellsNeighbourLUT[neigh.nextCell];
       }
       std::inclusive_scan(cellsNeighbourLUT.begin(), cellsNeighbourLUT.end(), cellsNeighbourLUT.begin());
 
-      mTimeFrame->getCellsNeighbours()[iLayer].reserve(totalCellNeighbours);
+      mTimeFrame->getCellsNeighbours()[iLayer].reserve(cellsNeighbours.size());
       std::ranges::transform(cellsNeighbours, std::back_inserter(mTimeFrame->getCellsNeighbours()[iLayer]), [](const auto& neigh) { return neigh.cell; });
 
       auto it = cellsNeighbours.begin();
-      while (it != cellsNeighbours.end()) {
-        const int current_nextCell = it->nextCell;
-        auto group_end = std::find_if_not(it, cellsNeighbours.end(),
-                                          [current_nextCell](const auto& nb) { return nb.nextCell == current_nextCell; });
-        const auto max_level_it = std::max_element(it, group_end,
-                                                   [](const auto& a, const auto& b) { return a.level < b.level; });
-        mTimeFrame->getCells()[iLayer + 1][current_nextCell].setLevel(max_level_it->level);
-        it = group_end;
+      int current = it->nextCell;
+      int maxLvl = it->level;
+      ++it;
+      for (; it != cellsNeighbours.end(); ++it) {
+        if (it->nextCell == current) {
+          maxLvl = std::max(maxLvl, it->level);
+        } else {
+          mTimeFrame->getCells()[iLayer + 1][current].setLevel(maxLvl);
+          current = it->nextCell;
+          maxLvl = it->level;
+        }
       }
-    });
-  }
+      mTimeFrame->getCells()[iLayer + 1][current].setLevel(maxLvl);
+    }
+  });
 }
 
 template <int nLayers>
@@ -621,141 +573,128 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
   int failed[5]{0, 0, 0, 0, 0}, attempts{0}, failedByMismatch{0};
 #endif
 
-  mTaskArena.execute([&] {
-    bounded_vector<int> perCellCount(currentCellSeed.size() + 1, 0, mMemoryPool.get());
-    tbb::parallel_for(
-      tbb::blocked_range<int>(0, (int)currentCellSeed.size()),
-      [&](const tbb::blocked_range<int>& Cells) {
-        for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
-          const CellSeed& currentCell{currentCellSeed[iCell]};
-          int foundSeeds{0};
-          if (currentCell.getLevel() != iLevel) {
-            continue;
-          }
-          if (currentCellId.empty() && (mTimeFrame->isClusterUsed(iLayer, currentCell.getFirstClusterIndex()) ||
-                                        mTimeFrame->isClusterUsed(iLayer + 1, currentCell.getSecondClusterIndex()) ||
-                                        mTimeFrame->isClusterUsed(iLayer + 2, currentCell.getThirdClusterIndex()))) {
-            continue; /// this we do only on the first iteration, hence the check on currentCellId
-          }
-          const int cellId = currentCellId.empty() ? iCell : currentCellId[iCell];
-          const int startNeighbourId{cellId ? mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId - 1] : 0};
-          const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId]};
-
-          for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
-            CA_DEBUGGER(attempts++);
-            const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
-            const CellSeed& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
-            if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
-              CA_DEBUGGER(failedByMismatch++);
-              continue;
-            }
-            if (mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex())) {
-              continue;
-            }
-            if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
-              CA_DEBUGGER(failed[0]++);
-              continue;
-            }
-            /// Let's start the fitting procedure
-            CellSeed seed{currentCell};
-            auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
-
-            if (!seed.rotate(trHit.alphaTrackingFrame)) {
-              CA_DEBUGGER(failed[1]++);
-              continue;
-            }
+  mTaskArena->execute([&] {
+    auto forCellNeighbours = [&](auto Tag, int iCell, int offset = 0) -> int {
+      const CellSeed& currentCell{currentCellSeed[iCell]};
 
-            if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
-              CA_DEBUGGER(failed[2]++);
-              continue;
-            }
+      if constexpr (decltype(Tag)::value != PassMode::TwoPassInsert::value) {
+        if (currentCell.getLevel() != iLevel) {
+          return 0;
+        }
+        if (currentCellId.empty() && (mTimeFrame->isClusterUsed(iLayer, currentCell.getFirstClusterIndex()) ||
+                                      mTimeFrame->isClusterUsed(iLayer + 1, currentCell.getSecondClusterIndex()) ||
+                                      mTimeFrame->isClusterUsed(iLayer + 2, currentCell.getThirdClusterIndex()))) {
+          return 0; /// this we do only on the first iteration, hence the check on currentCellId
+        }
+      }
 
-            if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-              if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
-                continue;
-              }
-            }
+      const int cellId = currentCellId.empty() ? iCell : currentCellId[iCell];
+      const int startNeighbourId{cellId ? mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId - 1] : 0};
+      const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId]};
+      int foundSeeds{0};
+      for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
+        CA_DEBUGGER(attempts++);
+        const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
+        const CellSeed& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
+        if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
+          CA_DEBUGGER(failedByMismatch++);
+          continue;
+        }
+        if (mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex())) {
+          continue;
+        }
+        if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
+          CA_DEBUGGER(failed[0]++);
+          continue;
+        }
+        /// Let's start the fitting procedure
+        CellSeed seed{currentCell};
+        const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
 
-            auto predChi2{seed.getPredictedChi2Quiet(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)};
-            if ((predChi2 > mTrkParams[0].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
-              CA_DEBUGGER(failed[3]++);
-              continue;
-            }
-            seed.setChi2(seed.getChi2() + predChi2);
-            if (!seed.o2::track::TrackParCov::update(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)) {
-              CA_DEBUGGER(failed[4]++);
-              continue;
-            }
-            ++foundSeeds;
-          }
-          perCellCount[iCell] = foundSeeds;
+        if (!seed.rotate(trHit.alphaTrackingFrame)) {
+          CA_DEBUGGER(failed[1]++);
+          continue;
         }
-      });
 
-    std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
-    auto totalNeighbours{perCellCount.back()};
-    if (totalNeighbours == 0) {
-      return;
-    }
-    updatedCellSeeds.resize(totalNeighbours);
-    updatedCellsIds.resize(totalNeighbours);
+        if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
+          CA_DEBUGGER(failed[2]++);
+          continue;
+        }
 
-    tbb::parallel_for(
-      tbb::blocked_range<int>(0, (int)currentCellSeed.size()),
-      [&](const tbb::blocked_range<int>& Cells) {
-        for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
-          if (perCellCount[iCell] == perCellCount[iCell + 1]) {
+        if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+          if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
             continue;
           }
-          // no need for further checks on cell level
-
-          const CellSeed& currentCell{currentCellSeed[iCell]};
-          const int cellId = currentCellId.empty() ? iCell : currentCellId[iCell];
-          const int startNeighbourId{cellId ? mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId - 1] : 0};
-          const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId]};
-
-          int offset = perCellCount[iCell];
-          for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
-            const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
-            const CellSeed& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
-            if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex() ||
-                mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex()) ||
-                currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
-              continue;
-            }
+        }
 
-            auto seed = currentCell;
+        auto predChi2{seed.getPredictedChi2Quiet(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)};
+        if ((predChi2 > mTrkParams[0].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
+          CA_DEBUGGER(failed[3]++);
+          continue;
+        }
+        seed.setChi2(seed.getChi2() + predChi2);
+        if (!seed.o2::track::TrackParCov::update(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)) {
+          CA_DEBUGGER(failed[4]++);
+          continue;
+        }
 
-            const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
-            if (!seed.rotate(trHit.alphaTrackingFrame) || !propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
-              continue;
-            }
+        if constexpr (decltype(Tag)::value != PassMode::TwoPassCount::value) {
+          seed.getClusters()[iLayer - 1] = neighbourCell.getFirstClusterIndex();
+          seed.setLevel(neighbourCell.getLevel());
+          seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
+          seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
+        }
 
-            if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-              if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
-                continue;
-              }
-            }
+        if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
+          updatedCellSeeds.push_back(seed);
+          updatedCellsIds.push_back(neighbourCellId);
+        } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
+          ++foundSeeds;
+        } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
+          updatedCellSeeds[offset] = seed;
+          updatedCellsIds[offset++] = neighbourCellId;
+        } else {
+          static_assert(false, "Unknown mode!");
+        }
+      }
+      return foundSeeds;
+    };
 
-            auto predChi2{seed.getPredictedChi2Quiet(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)};
-            if ((predChi2 > mTrkParams[0].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
-              continue;
-            }
-            seed.setChi2(seed.getChi2() + predChi2);
-            if (!seed.o2::track::TrackParCov::update(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)) {
-              continue;
-            }
+    const int nCells = static_cast<int>(currentCellSeed.size());
+    if (mTaskArena->max_concurrency() <= 1) {
+      for (int iCell{0}; iCell < nCells; ++iCell) {
+        forCellNeighbours(PassMode::OnePass{}, iCell);
+      }
+    } else {
+      bounded_vector<int> perCellCount(nCells + 1, 0, mMemoryPool.get());
+      tbb::parallel_for(
+        tbb::blocked_range<int>(0, nCells),
+        [&](const tbb::blocked_range<int>& Cells) {
+          for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
+            perCellCount[iCell] = forCellNeighbours(PassMode::TwoPassCount{}, iCell);
+          }
+        });
 
-            seed.getClusters()[iLayer - 1] = neighbourCell.getFirstClusterIndex();
-            seed.setLevel(neighbourCell.getLevel());
-            seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
-            seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
+      std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
+      auto totalNeighbours{perCellCount.back()};
+      if (totalNeighbours == 0) {
+        return;
+      }
+      updatedCellSeeds.resize(totalNeighbours);
+      updatedCellsIds.resize(totalNeighbours);
 
-            updatedCellSeeds[offset] = seed;
-            updatedCellsIds[offset++] = neighbourCellId;
+      tbb::parallel_for(
+        tbb::blocked_range<int>(0, nCells),
+        [&](const tbb::blocked_range<int>& Cells) {
+          for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
+            int offset = perCellCount[iCell];
+            if (offset == perCellCount[iCell + 1]) {
+              continue;
+            }
+            forCellNeighbours(PassMode::TwoPassInsert{}, iCell, offset);
           }
-        }
-      });
+        });
+    }
   });
 
 #ifdef CA_DEBUG
@@ -812,66 +751,74 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
     }
 
     bounded_vector<TrackITSExt> tracks(mMemoryPool.get());
-    mTaskArena.execute([&] {
-      bounded_vector<int> perSeedCount(trackSeeds.size() + 1, 0, mMemoryPool.get());
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, (int)trackSeeds.size()),
-        [&](const tbb::blocked_range<int>& Seeds) {
-          for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
-            const CellSeed& seed{trackSeeds[iSeed]};
-            TrackITSExt temporaryTrack{seed};
-            temporaryTrack.resetCovariance();
-            temporaryTrack.setChi2(0);
-            for (int iL{0}; iL < 7; ++iL) {
-              temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
-            }
+    mTaskArena->execute([&] {
+      auto forSeed = [&](auto Tag, int iSeed, int offset = 0) {
+        const CellSeed& seed{trackSeeds[iSeed]};
+        TrackITSExt temporaryTrack{seed};
+        temporaryTrack.resetCovariance();
+        temporaryTrack.setChi2(0);
+        for (int iL{0}; iL < 7; ++iL) {
+          temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
+        }
 
-            bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
-            if (!fitSuccess) {
-              continue;
-            }
-            temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
-            temporaryTrack.resetCovariance();
-            temporaryTrack.setChi2(0);
-            fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f);
-            if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
-              continue;
-            }
-            ++perSeedCount[iSeed];
-          }
-        });
-      std::exclusive_scan(perSeedCount.begin(), perSeedCount.end(), perSeedCount.begin(), 0);
-      auto totalTracks{perSeedCount.back()};
-      if (totalTracks == 0) {
-        return;
-      }
-      tracks.resize(totalTracks);
+        bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
+        if (!fitSuccess) {
+          return 0;
+        }
 
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, (int)trackSeeds.size()),
-        [&](const tbb::blocked_range<int>& Seeds) {
-          for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
-            if (perSeedCount[iSeed] == perSeedCount[iSeed + 1]) {
-              continue;
-            }
-            const CellSeed& seed{trackSeeds[iSeed]};
-            auto& trk = tracks[perSeedCount[iSeed]] = TrackITSExt(seed);
-            trk.resetCovariance();
-            trk.setChi2(0);
-            for (int iL{0}; iL < 7; ++iL) {
-              trk.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
+        temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+        temporaryTrack.resetCovariance();
+        temporaryTrack.setChi2(0);
+        fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f);
+        if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
+          return 0;
+        }
+
+        if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
+          tracks.push_back(temporaryTrack);
+        } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
+          // nothing to do
+        } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
+          tracks[offset] = temporaryTrack;
+        } else {
+          static_assert(false, "Unknown mode!");
+        }
+        return 1;
+      };
+
+      const int nSeeds = static_cast<int>(trackSeeds.size());
+      if (mTaskArena->max_concurrency() <= 1) {
+        for (int iSeed{0}; iSeed < nSeeds; ++iSeed) {
+          forSeed(PassMode::OnePass{}, iSeed);
+        }
+      } else {
+        bounded_vector<int> perSeedCount(nSeeds + 1, 0, mMemoryPool.get());
+        tbb::parallel_for(
+          tbb::blocked_range<int>(0, nSeeds),
+          [&](const tbb::blocked_range<int>& Seeds) {
+            for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
+              perSeedCount[iSeed] = forSeed(PassMode::TwoPassCount{}, iSeed);
             }
+          });
 
-            bool fitSuccess = fitTrack(trk, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
-            if (!fitSuccess) {
-              continue;
+        std::exclusive_scan(perSeedCount.begin(), perSeedCount.end(), perSeedCount.begin(), 0);
+        auto totalTracks{perSeedCount.back()};
+        if (totalTracks == 0) {
+          return;
+        }
+        tracks.resize(totalTracks);
+
+        tbb::parallel_for(
+          tbb::blocked_range<int>(0, nSeeds),
+          [&](const tbb::blocked_range<int>& Seeds) {
+            for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
+              if (perSeedCount[iSeed] == perSeedCount[iSeed + 1]) {
+                continue;
+              }
+              forSeed(PassMode::TwoPassInsert{}, iSeed, perSeedCount[iSeed]);
             }
-            trk.getParamOut() = trk.getParamIn();
-            trk.resetCovariance();
-            trk.setChi2(0);
-            fitTrack(trk, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f);
-          }
-        });
+          });
+      }
 
       deepVectorClear(trackSeeds);
       tbb::parallel_sort(tracks.begin(), tracks.end(), [](const auto& a, const auto& b) {
@@ -1258,17 +1205,19 @@ bool TrackerTraits<nLayers>::isMatLUT() const
 }
 
 template <int nLayers>
-void TrackerTraits<nLayers>::setNThreads(int n)
+void TrackerTraits<nLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
 {
-  if (mNThreads == n && mTaskArena.is_active()) {
-    return;
-  }
-  mNThreads = n > 0 ? n : 1;
 #if defined(OPTIMISATION_OUTPUT) || defined(CA_DEBUG)
-  mNThreads = 1; // only works while serial
+  mTaskArena = std::make_shared<tbb::task_arena>(1);
+#else
+  if (arena == nullptr) {
+    mTaskArena = std::make_shared<tbb::task_arena>(std::abs(n));
+    LOGP(info, "Setting tracker with {} threads.", n);
+  } else {
+    mTaskArena = arena;
+    LOGP(info, "Attaching tracker to calling thread's arena");
+  }
 #endif
-  mTaskArena.initialize(mNThreads);
-  LOGP(info, "Setting tracker with {} threads.", mNThreads);
 }
 
 template class TrackerTraits<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index b6b4796690905..15348bca9fde7 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -16,6 +16,7 @@
 #include "ITSReconstruction/FastMultEst.h"
 
 #include "ITStracking/TrackingInterface.h"
+#include <oneapi/tbb/task_arena.h>
 #include <memory>
 
 #include "DataFormatsITSMFT/ROFRecord.h"
@@ -148,6 +149,20 @@ void ITSTrackingInterface::initialise()
   }
   mTracker->setParameters(trackParams);
   mVertexer->setParameters(vertParams);
+  if (trackConf.nThreads == vertConf.nThreads) {
+    bool clamped{false};
+    int nThreads = trackConf.nThreads;
+    if (nThreads > 0) {
+      const int hw = std::thread::hardware_concurrency();
+      const int maxThreads = (hw == 0 ? 1 : hw);
+      nThreads = std::clamp(nThreads, 1, maxThreads);
+      clamped = trackConf.nThreads > maxThreads;
+    }
+    LOGP(info, "Tracker and Vertexer will share the task arena with {} thread(s){}", nThreads, (clamped) ? " (clamped)" : "");
+    mTaskArena = std::make_shared<tbb::task_arena>(std::abs(nThreads));
+  }
+  mVertexer->setNThreads(vertConf.nThreads, mTaskArena);
+  mTracker->setNThreads(trackConf.nThreads, mTaskArena);
 }
 
 void ITSTrackingInterface::run(framework::ProcessingContext& pc)
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 37b650c05bd61..51cd98aa1366d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -11,6 +11,7 @@
 ///
 
 #include <iostream>
+#include <memory>
 #include <string>
 #include <chrono>
 
@@ -168,13 +169,12 @@ void VertexerTraits::updateVertexingParameters(const std::vector<VertexingParame
     par.phiSpan = static_cast<int>(std::ceil(mIndexTableUtils.getNphiBins() * par.phiCut / o2::constants::math::TwoPI));
     par.zSpan = static_cast<int>(std::ceil(par.zCut * mIndexTableUtils.getInverseZCoordinate(0)));
   }
-  setNThreads(vrtPar[0].nThreads);
 }
 
 // Main functions
 void VertexerTraits::computeTracklets(const int iteration)
 {
-  mTaskArena.execute([&] {
+  mTaskArena->execute([&] {
     tbb::parallel_for(
       tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
       [&](const tbb::blocked_range<short>& Rofs) {
@@ -220,7 +220,7 @@ void VertexerTraits::computeTracklets(const int iteration)
   mTimeFrame->getTracklets()[0].resize(mTimeFrame->getTotalTrackletsTF(0));
   mTimeFrame->getTracklets()[1].resize(mTimeFrame->getTotalTrackletsTF(1));
 
-  mTaskArena.execute([&] {
+  mTaskArena->execute([&] {
     tbb::parallel_for(
       tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
       [&](const tbb::blocked_range<short>& Rofs) {
@@ -329,7 +329,7 @@ void VertexerTraits::computeTracklets(const int iteration)
 
 void VertexerTraits::computeTrackletMatching(const int iteration)
 {
-  mTaskArena.execute([&] {
+  mTaskArena->execute([&] {
     tbb::parallel_for(
       tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
       [&](const tbb::blocked_range<short>& Rofs) {
@@ -687,15 +687,17 @@ void VertexerTraits::computeVerticesInRof(int rofId,
   verticesInRof.push_back(foundVertices);
 }
 
-void VertexerTraits::setNThreads(int n)
+void VertexerTraits::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
 {
-  if (mNThreads == n && mTaskArena.is_active()) {
-    return;
-  }
-  mNThreads = n > 0 ? n : 1;
 #if defined(VTX_DEBUG)
-  mNThreads = 1;
+  mTaskArena = std::make_shared<tbb::task_arena>(1);
+#else
+  if (arena == nullptr) {
+    mTaskArena = std::make_shared<tbb::task_arena>(std::abs(n));
+    LOGP(info, "Setting seeding vertexer with {} threads.", n);
+  } else {
+    mTaskArena = arena;
+    LOGP(info, "Attaching vertexer to calling thread's arena");
+  }
 #endif
-  mTaskArena.initialize(mNThreads);
-  LOGP(info, "Setting seeding vertexer with {} threads.", mNThreads);
 }

From b8829ab72db3a170dad0ba0f7c6ff77d5d81fff7 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 20 Jun 2025 01:27:37 +0200
Subject: [PATCH 0517/1764] Add more info to MCStudy w-flow

---
 .../GlobalTrackingStudy/TrackMCStudyConfig.h  |  2 +
 .../GlobalTrackingStudy/TrackMCStudyTypes.h   | 25 ++++++++--
 .../study/src/TrackMCStudy.cxx                | 48 ++++++++++++++-----
 3 files changed, 58 insertions(+), 17 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
index 3c04affd99cb2..74d77eb3d53de 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
@@ -28,6 +28,8 @@ struct TrackMCStudyConfig : o2::conf::ConfigurableParamHelper<TrackMCStudyConfig
   bool requireITSorTPCTrackRefs = true;
   bool requireTopBottomRefs = false;
   int minTPCRefsToExtractClRes = 2;
+  int nOccBinsDrift = 10; // number of bins for TPC max drift time, where we integrate the occupancies
+  int nTBPerOccBin = 48;  // number of TB per occ bin
   float rejectClustersResStat = 0.1;
   float maxTPCRefExtrap = 2;                   // max dX to extrapolate the track ref when extrapolating track true posions
   int decayPDG[5] = {310, 3122, 411, 421, -1}; // decays to study, must end by -1
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
index 5d5cfd9c93523..47fed477f98bd 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
@@ -32,7 +32,7 @@ struct MCTrackInfo {
   int getNITSClusForAB() const;
   int getLowestITSLayer() const;
   int getHighestITSLayer() const;
-
+  std::vector<float> occTPCV{};
   o2::track::TrackPar track{};
   o2::MCCompLabel label{};
   float occTPC = -1.f;
@@ -52,8 +52,24 @@ struct MCTrackInfo {
   uint8_t maxTPCRowSect = -1;
   int8_t nITSCl = 0;
   int8_t pattITSCl = 0;
-  bool addedAtRecStage = false;
-  ClassDefNV(MCTrackInfo, 5);
+  uint8_t flags = 0;
+
+  enum Flags : uint32_t { Primary = 0,
+                          AddedAtRecStage = 2,
+                          BitMask = 0xff };
+
+  bool isPrimary() const { return isBitSet(Primary); }
+  bool isAddedAtRecStage() const { return isBitSet(AddedAtRecStage); }
+  void setPrimary() { setBit(Primary); }
+  void setAddedAtRecStage() { setBit(AddedAtRecStage); }
+
+  uint8_t getBits() const { return flags; }
+  bool isBitSet(int bit) const { return flags & (0xff & (0x1 << bit)); }
+  void setBits(std::uint8_t b) { flags = b; }
+  void setBit(int bit) { flags |= BitMask & (0x1 << bit); }
+  void resetBit(int bit) { flags &= ~(BitMask & (0x1 << bit)); }
+
+  ClassDefNV(MCTrackInfo, 7);
 };
 
 struct RecTrack {
@@ -272,7 +288,8 @@ struct MCVertex {
   int nTrackSel = 0; // number of selected MC charged tracks
   int ID = -1;
   std::vector<RecPV> recVtx{};
-  ClassDefNV(MCVertex, 1);
+  std::vector<float> occTPCV{};
+  ClassDefNV(MCVertex, 2);
 };
 
 } // namespace o2::trackstudy
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 7c53cf1467494..fa8cadf3a115c 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -109,7 +109,7 @@ class TrackMCStudy : public Task
   void updateTimeDependentParams(ProcessingContext& pc);
   float getDCAYCut(float pt) const;
 
-  gsl::span<const MCTrack> mCurrMCTracks;
+  const std::vector<o2::MCTrack>* mCurrMCTracks = nullptr;
   TVector3 mCurrMCVertex;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
   o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
@@ -124,7 +124,7 @@ class TrackMCStudy : public Task
   bool mCheckSV = false;         //< check SV binding (apart from prongs availability)
   bool mRecProcStage = false;    //< flag that the MC particle was added only at the stage of reco tracks processing
   int mNTPCOccBinLength = 0;     ///< TPC occ. histo bin length in TBs
-  float mNTPCOccBinLengthInv;
+  float mNTPCOccBinLengthInv = -1.f;
   int mVerbose = 0;
   float mITSTimeBiasMUS = 0.f;
   float mITSROFrameLengthMUS = 0.f; ///< ITS RO frame in mus
@@ -182,7 +182,7 @@ void TrackMCStudy::run(ProcessingContext& pc)
   }
   mDecProdLblPool.clear();
   mMCVtVec.clear();
-  mCurrMCTracks = {};
+  mCurrMCTracks = nullptr;
 
   recoData.collectData(pc, *mDataRequest.get()); // select tracks of needed type, with minimal cuts, the real selected will be done in the vertexer
   updateTimeDependentParams(pc);                 // Make sure this is called after recoData.collectData, which may load some conditions
@@ -346,6 +346,21 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
         }
         break;
       }
+      if (mNTPCOccBinLengthInv > 0.f) {
+        mcVtx.occTPCV.resize(params.nOccBinsDrift);
+        int grp = TMath::Max(1, TMath::Nint(params.nTBPerOccBin * mNTPCOccBinLengthInv));
+        for (int ib = 0; ib < params.nOccBinsDrift; ib++) {
+          float smb = 0;
+          int tbs = occBin + TMath::Nint(ib * params.nTBPerOccBin * mNTPCOccBinLengthInv);
+          for (int ig = 0; ig < grp; ig++) {
+            if (tbs >= 0 && tbs < int(mTBinClOccHist.size())) {
+              smb += mTBinClOccHist[tbs];
+            }
+            tbs++;
+          }
+          mcVtx.occTPCV[ib] = smb;
+        }
+      }
       if (rofCount >= ITSClusROFRec.size()) {
         mITSOcc.push_back(0); // IR after the last ROF
       }
@@ -362,13 +377,15 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
     if (nev != (int)mMCVtVec.size()) {
       LOGP(debug, "source {} has {} events while {} MC vertices were booked", curSrcMC, nev, mMCVtVec.size());
       okAccVtx = false;
+      if (nev > (int)mMCVtVec.size()) { // QED
+        continue;
+      }
     }
     for (curEvMC = 0; curEvMC < nev; curEvMC++) {
       if (mVerbose > 1) {
         LOGP(info, "Event {}", curEvMC);
       }
-      const auto& mt = mcReader.getTracks(curSrcMC, curEvMC);
-      mCurrMCTracks = gsl::span<const MCTrack>(mt.data(), mt.size());
+      mCurrMCTracks = &mcReader.getTracks(curSrcMC, curEvMC);
       const_cast<o2::dataformats::MCEventHeader&>(mcReader.getMCEventHeader(curSrcMC, curEvMC)).GetVertex(mCurrMCVertex);
       if (okAccVtx) {
         auto& pos = mMCVtVec[curEvMC].pos;
@@ -378,7 +395,7 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
           pos[2] = mCurrMCVertex.Z();
         }
       }
-      for (int itr = 0; itr < mCurrMCTracks.size(); itr++) {
+      for (int itr = 0; itr < mCurrMCTracks->size(); itr++) {
         processMCParticle(curSrcMC, curEvMC, itr);
       }
     }
@@ -425,11 +442,10 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
             if (lbl.getSourceID() != curSrcMC || lbl.getEventID() != curEvMC) {
               curSrcMC = lbl.getSourceID();
               curEvMC = lbl.getEventID();
-              const auto& mt = mcReader.getTracks(curSrcMC, curEvMC);
-              mCurrMCTracks = gsl::span<const MCTrack>(mt.data(), mt.size());
+              mCurrMCTracks = &mcReader.getTracks(curSrcMC, curEvMC);
               const_cast<o2::dataformats::MCEventHeader&>(mcReader.getMCEventHeader(curSrcMC, curEvMC)).GetVertex(mCurrMCVertex);
             }
-            if (!acceptMCCharged(mCurrMCTracks[lbl.getTrackID()], lbl)) {
+            if (!acceptMCCharged((*mCurrMCTracks)[lbl.getTrackID()], lbl)) {
               continue;
             }
             entry = mSelMCTracks.find(lbl);
@@ -977,7 +993,7 @@ float TrackMCStudy::getDCAYCut(float pt) const
 
 bool TrackMCStudy::processMCParticle(int src, int ev, int trid)
 {
-  const auto& mcPart = mCurrMCTracks[trid];
+  const auto& mcPart = (*mCurrMCTracks)[trid];
   int pdg = mcPart.GetPdgCode();
   bool res = false;
   while (true) {
@@ -999,7 +1015,7 @@ bool TrackMCStudy::processMCParticle(int src, int ev, int trid)
           break;
         }
         for (int idd = idd0; idd <= idd1; idd++) {
-          const auto& product = mCurrMCTracks[idd];
+          const auto& product = (*mCurrMCTracks)[idd];
           auto lbld = o2::MCCompLabel(idd, ev, src);
           if (!acceptMCCharged(product, lbld, decay)) {
             decay = -1; // discard decay
@@ -1097,11 +1113,17 @@ bool TrackMCStudy::addMCParticle(const MCTrack& mcPart, const o2::MCCompLabel& l
   mcEntry.mcTrackInfo.bcInTF = mIntBC[lb.getEventID()];
   mcEntry.mcTrackInfo.occTPC = mTPCOcc[lb.getEventID()];
   mcEntry.mcTrackInfo.occITS = mITSOcc[lb.getEventID()];
-  mcEntry.mcTrackInfo.addedAtRecStage = mRecProcStage;
+  mcEntry.mcTrackInfo.occTPCV = mMCVtVec[lb.getEventID()].occTPCV;
+  if (mRecProcStage) {
+    mcEntry.mcTrackInfo.setAddedAtRecStage();
+  }
+  if (o2::mcutils::MCTrackNavigator::isPhysicalPrimary(mcPart, *mCurrMCTracks)) {
+    mcEntry.mcTrackInfo.setPrimary();
+  }
   int moth = -1;
   o2::MCCompLabel mclbPar;
   if ((moth = mcPart.getMotherTrackId()) >= 0) {
-    const auto& mcPartPar = mCurrMCTracks[moth];
+    const auto& mcPartPar = (*mCurrMCTracks)[moth];
     mcEntry.mcTrackInfo.pdgParent = mcPartPar.GetPdgCode();
   }
   if (mcPart.isPrimary() && mcReader.getNEvents(lb.getSourceID()) == mMCVtVec.size()) {

From b71ab71489436b1d57c807d6a04557b0eb4a6f7a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 19 Jun 2025 14:11:51 +0200
Subject: [PATCH 0518/1764] GPU TPC QA: Ignore fake tracks for clone track
 computation

---
 GPU/GPUTracking/qa/GPUQA.cxx | 16 +++++++++++-----
 GPU/GPUTracking/qa/GPUQA.h   |  2 +-
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 45ccdc783891c..e65246968cefa 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -165,7 +165,7 @@ static constexpr bool CLUST_HIST_INT_SUM = false;
 
 static constexpr const int32_t COLORCOUNT = 12;
 
-static const constexpr char* EFF_TYPES[4] = {"Rec", "Clone", "Fake", "All"};
+static const constexpr char* EFF_TYPES[5] = {"Rec", "Clone", "Fake", "All", "RecAndClone"};
 static const constexpr char* FINDABLE_NAMES[2] = {"", "Findable"};
 static const constexpr char* PRIM_NAMES[2] = {"Prim", "Sec"};
 static const constexpr char* PARAMETER_NAMES[5] = {"Y", "Z", "#Phi", "#lambda", "Relative #it{p}_{T}"};
@@ -439,7 +439,7 @@ int32_t GPUQA::InitQACreateHistograms()
   char name[2048], fname[1024];
   if (mQATasks & taskTrackingEff) {
     // Create Efficiency Histograms
-    for (int32_t i = 0; i < 4; i++) {
+    for (int32_t i = 0; i < 5; i++) {
       for (int32_t j = 0; j < 2; j++) {
         for (int32_t k = 0; k < 2; k++) {
           for (int32_t l = 0; l < 5; l++) {
@@ -454,7 +454,9 @@ int32_t GPUQA::InitQACreateHistograms()
               mEff[i][j][k][l]->Sumw2();
             }
             strcat(name, "_eff");
-            createHist(mEffResult[i][j][k][l], name);
+            if (i < 4) {
+              createHist(mEffResult[i][j][k][l], name);
+            }
           }
         }
       }
@@ -2122,15 +2124,18 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
                 gErrorIgnoreLevel = kError;
                 mEffResult[0][j / 2][j % 2][i]->Divide(mEff[l][j / 2][j % 2][i], mEff[3][j / 2][j % 2][i], "cl=0.683 b(1,1) mode");
                 gErrorIgnoreLevel = oldLevel;
-                mEff[3][j / 2][j % 2][i]->Reset(); // Sum up rec + clone + fake for clone/fake rate
+                mEff[3][j / 2][j % 2][i]->Reset(); // Sum up rec + clone + fake for fake rate
                 mEff[3][j / 2][j % 2][i]->Add(mEff[0][j / 2][j % 2][i]);
                 mEff[3][j / 2][j % 2][i]->Add(mEff[1][j / 2][j % 2][i]);
                 mEff[3][j / 2][j % 2][i]->Add(mEff[2][j / 2][j % 2][i]);
+                mEff[4][j / 2][j % 2][i]->Reset(); // Sum up rec + clone for clone rate
+                mEff[4][j / 2][j % 2][i]->Add(mEff[0][j / 2][j % 2][i]);
+                mEff[4][j / 2][j % 2][i]->Add(mEff[1][j / 2][j % 2][i]);
               } else {
                 // Divide fake/clone
                 auto oldLevel = gErrorIgnoreLevel;
                 gErrorIgnoreLevel = kError;
-                mEffResult[l][j / 2][j % 2][i]->Divide(mEff[l][j / 2][j % 2][i], mEff[3][j / 2][j % 2][i], "cl=0.683 b(1,1) mode");
+                mEffResult[l][j / 2][j % 2][i]->Divide(mEff[l][j / 2][j % 2][i], mEff[l == 1 ? 4 : 3][j / 2][j % 2][i], "cl=0.683 b(1,1) mode");
                 gErrorIgnoreLevel = oldLevel;
               }
             }
@@ -2143,6 +2148,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
                 e->Write();
                 if (l == 2) {
                   mEff[3][j / 2][j % 2][i]->Write(); // Store also all histogram!
+                  mEff[4][j / 2][j % 2][i]->Write(); // Store also all histogram!
                 }
               }
             } else if (GetHist(e, tin, k, nNewInput) == nullptr) {
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 87900b5279ec0..3d5030e20dba5 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -258,7 +258,7 @@ class GPUQA
   std::vector<additionalClusterParameters> mClusterParam;
   int32_t mNTotalFakes = 0;
 
-  TH1F* mEff[4][2][2][5]; // eff,clone,fake,all - findable - secondaries - y,z,phi,eta,pt - work,result
+  TH1F* mEff[5][2][2][5]; // eff,clone,fake,all,all-fake - findable - secondaries - y,z,phi,eta,pt - work,result
   TGraphAsymmErrors* mEffResult[4][2][2][5];
   TCanvas* mCEff[6];
   TPad* mPEff[6][4];

From 269941bd68af8bbd1d72ab48569867ddc55686eb Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 17 Jun 2025 14:13:20 +0200
Subject: [PATCH 0519/1764] gpu-reco-workflow should never add readers, remove
 leftover when copying from tpc-reco-workflow

---
 GPU/Workflow/src/gpu-reco-workflow.cxx | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index 4583e138b7579..0e7ec38962b11 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -220,12 +220,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
       taskPrepare->options()});
   }
 
-  if (!cfgc.options().get<bool>("ignore-dist-stf")) {
-    GlobalTrackID::mask_t srcTrk = GlobalTrackID::getSourcesMask("none");
-    GlobalTrackID::mask_t srcCl = GlobalTrackID::getSourcesMask("TPC");
-    o2::globaltracking::InputHelper::addInputSpecs(cfgc, specs, srcCl, srcTrk, srcTrk, doMC);
-  }
-
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(cfgc, specs);
 

From de3063cf8200c0e83b353f417578eeb0bf6b99c6 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 17 Jun 2025 14:14:28 +0200
Subject: [PATCH 0520/1764] GPUWorkflow: fix decompressTPCFromROOT option

---
 GPU/Workflow/src/gpu-reco-workflow.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index 0e7ec38962b11..561d537b5c251 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -166,8 +166,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   cfg.lumiScaleMode = sclOpt.lumiMode;
   cfg.enableMShape = sclOpt.enableMShapeCorrection;
   cfg.enableCTPLumi = sclOpt.requestCTPLumi;
-  cfg.decompressTPC = isEnabled(inputTypes, ioType::CompClustCTF);
   cfg.decompressTPCFromROOT = isEnabled(inputTypes, ioType::CompClustROOT);
+  cfg.decompressTPC = isEnabled(inputTypes, ioType::CompClustCTF) || cfg.decompressTPCFromROOT;
   cfg.zsDecoder = isEnabled(inputTypes, ioType::ZSRaw);
   cfg.zsOnTheFly = isEnabled(inputTypes, ioType::ZSRawOTF);
   cfg.caClusterer = cfg.zsDecoder || cfg.zsOnTheFly || isEnabled(inputTypes, ioType::Digits);

From bef11c6b01f476c798e763a011f18fb2295fd67d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 19 Jun 2025 16:03:06 +0200
Subject: [PATCH 0521/1764] GPU Workflow: Do not request TPC Cluster MC labels
 if we do not run TPC tracking

---
 GPU/Workflow/src/GPUWorkflowSpec.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 8a755a703705f..6293fce842231 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -1193,7 +1193,7 @@ Inputs GPURecoWorkflowSpec::inputs()
         inputs.emplace_back(InputSpec{"mclblin", ConcreteDataTypeMatcher{gDataOriginTPC, "DIGITSMCTR"}, Lifetime::Timeframe});
         mPolicyData->emplace_back(o2::framework::InputSpec{"digitsmc", o2::framework::ConcreteDataTypeMatcher{"TPC", "DIGITSMCTR"}});
       }
-    } else {
+    } else if (mSpecConfig.runTPCTracking) {
       inputs.emplace_back(InputSpec{"mclblin", ConcreteDataTypeMatcher{gDataOriginTPC, "CLNATIVEMCLBL"}, Lifetime::Timeframe});
       mPolicyData->emplace_back(o2::framework::InputSpec{"clustersmc", o2::framework::ConcreteDataTypeMatcher{"TPC", "CLNATIVEMCLBL"}});
     }

From 4f406ccad4cafa9afc201cda81b9232a2bd517c8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 20 Jun 2025 09:45:23 +0200
Subject: [PATCH 0522/1764] GPU Display Vulkan: Workaround for bogus old Vulkan
 versions that report the patch version as vulkan version

---
 GPU/GPUTracking/display/CMakeLists.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index 513d9b6122c68..3280a0655ce9f 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -31,7 +31,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
 endif()
 
 if(Vulkan_FOUND)
-  if(NOT ${Vulkan_VERSION} VERSION_GREATER_EQUAL "1.3.0" OR Vulkan_GLSLC_EXECUTABLE STREQUAL "Vulkan_GLSLC_EXECUTABLE-NOTFOUND")
+  string(FIND "${Vulkan_VERSION}" "." vulkan_dot_index)
+  if(NOT ${Vulkan_VERSION} VERSION_GREATER_EQUAL "1.3.0" OR dot_index EQUAL -1 OR Vulkan_GLSLC_EXECUTABLE STREQUAL "Vulkan_GLSLC_EXECUTABLE-NOTFOUND")
     set(Vulkan_FOUND 0)
   endif()
 endif()

From ece12c56cf83a7be9e4b92d8c1b7721820b0aef9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 20 Jun 2025 15:31:23 +0200
Subject: [PATCH 0523/1764] GPU Standalone: Fix typo for event dump file name

---
 GPU/GPUTracking/Definitions/GPUDef.h                |  2 +-
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 10 ++++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDef.h b/GPU/GPUTracking/Definitions/GPUDef.h
index e1b34af55d62d..8ca361dd5003a 100644
--- a/GPU/GPUTracking/Definitions/GPUDef.h
+++ b/GPU/GPUTracking/Definitions/GPUDef.h
@@ -34,7 +34,7 @@
   #define GPUPtr2(a, b) b
 #endif
 
-#define GPUCA_EVDUMP_FILE "event_full"
+#define GPUCA_EVDUMP_FILE "event"
 
 #ifdef GPUCA_GPUCODE
   #define CA_MAKE_SHARED_REF(vartype, varname, varglobal, varshared) const GPUsharedref() vartype& __restrict__ varname = varshared;
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index a624e1e55ed4b..ae02f9e9051c4 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -522,10 +522,9 @@ int32_t ReadEvent(int32_t n)
   if ((configStandalone.proc.runQA || configStandalone.eventDisplay) && !configStandalone.QA.noMC) {
     chainTracking->ForceInitQA();
     chainTracking->GetQA()->UpdateChain(chainTracking);
-    if (chainTracking->GetQA()->ReadO2MCData((eventsDir + "mc." + std::to_string(n) + ".dump").c_str())) {
-      if (chainTracking->GetQA()->ReadO2MCData((eventsDir + "mc.0.dump").c_str()) && configStandalone.proc.runQA) {
-        throw std::runtime_error("Error reading O2 MC dump");
-      }
+    if (chainTracking->GetQA()->ReadO2MCData((eventsDir + "mc." + std::to_string(n) + ".dump").c_str()) &&
+        chainTracking->GetQA()->ReadO2MCData((eventsDir + "mc.0.dump").c_str()) && configStandalone.proc.runQA) {
+      throw std::runtime_error("Error reading O2 MC dump");
     }
   }
 #endif
@@ -817,6 +816,9 @@ int32_t main(int argc, char** argv)
       }
       nEvents = nEventsInDirectory;
     }
+    if (nEvents == 0 && !configStandalone.noEvents) {
+      printf("No event data found in event folder\n");
+    }
     if (configStandalone.TF.nMerge > 1) {
       nEvents /= configStandalone.TF.nMerge;
     }

From f2417fb6a6f7da32f544a820825664ffe35fe165 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 23 Jun 2025 09:53:51 +0200
Subject: [PATCH 0524/1764] ITS3: fix tracking after refactor (#14433)

---
 .../tracking/include/ITStracking/TimeFrame.h  |  3 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 30 +++++++++++--------
 .../ITS3/reconstruction/src/IOUtils.cxx       |  2 ++
 3 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 248e63aef382c..8b857df7cdd80 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -91,6 +91,7 @@ struct TimeFrame {
                       gsl::span<const unsigned char>::iterator& pattIt,
                       const itsmft::TopologyDictionary* dict,
                       const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
+  void resetROFrameData();
 
   int getTotalClusters() const;
   auto& getTotVertIteration() { return mTotVertPerIteration; }
@@ -138,7 +139,7 @@ struct TimeFrame {
   gsl::span<const MCCompLabel> getClusterLabels(int layerId, const int clId) const { return mClusterLabels->getLabels(mClusterExternalIndices[layerId][clId]); }
   int getClusterExternalIndex(int layerId, const int clId) const { return mClusterExternalIndices[layerId][clId]; }
   int getClusterSize(int clusterId) const { return mClusterSize[clusterId]; }
-  void setClusterSize(const bounded_vector<uint8_t>& v) { mClusterSize = v; }
+  void setClusterSize(bounded_vector<uint8_t>& v) { mClusterSize = std::move(v); }
 
   auto& getTrackletsLabel(int layer) { return mTrackletLabels[layer]; }
   auto& getCellsLabel(int layer) { return mCellLabels[layer]; }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 1a3132413c450..9c683112791ab 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -136,18 +136,7 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
                                         const itsmft::TopologyDictionary* dict,
                                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
-    deepVectorClear(mUnsortedClusters[iLayer], mMemoryPool.get());
-    deepVectorClear(mTrackingFrameInfo[iLayer], mMemoryPool.get());
-    deepVectorClear(mClusterExternalIndices[iLayer], mMemoryPool.get());
-    clearResizeBoundedVector(mROFramesClusters[iLayer], 1, mMemoryPool.get(), 0);
-
-    if (iLayer < 2) {
-      deepVectorClear(mTrackletsIndexROF[iLayer], mMemoryPool.get());
-      deepVectorClear(mNTrackletsPerCluster[iLayer], mMemoryPool.get());
-      deepVectorClear(mNTrackletsPerClusterSum[iLayer], mMemoryPool.get());
-    }
-  }
+  resetROFrameData();
 
   GeometryTGeo* geom = GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
@@ -213,6 +202,23 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
   return mNrof;
 }
 
+template <int nLayers>
+void TimeFrame<nLayers>::resetROFrameData()
+{
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    deepVectorClear(mUnsortedClusters[iLayer], mMemoryPool.get());
+    deepVectorClear(mTrackingFrameInfo[iLayer], mMemoryPool.get());
+    deepVectorClear(mClusterExternalIndices[iLayer], mMemoryPool.get());
+    clearResizeBoundedVector(mROFramesClusters[iLayer], 1, mMemoryPool.get(), 0);
+
+    if (iLayer < 2) {
+      deepVectorClear(mTrackletsIndexROF[iLayer], mMemoryPool.get());
+      deepVectorClear(mNTrackletsPerCluster[iLayer], mMemoryPool.get());
+      deepVectorClear(mNTrackletsPerClusterSum[iLayer], mMemoryPool.get());
+    }
+  }
+}
+
 template <int nLayers>
 void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, const int maxLayers)
 {
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index a01eb77af1677..acba8022e376f 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -64,6 +64,8 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
                         const its3::TopologyDictionary* dict,
                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
+  tf->resetROFrameData();
+
   auto geom = its::GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
 

From ead329bb619c79251b1b2aba50556364198ecfe5 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 5 Jun 2025 11:04:27 +0200
Subject: [PATCH 0525/1764] EPNstderrMonitor: remove static declaration of
 InfoLoggerMessageOption when sending messages to IL

---
 Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx b/Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx
index d7a7282a78684..035cbd705d769 100644
--- a/Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx
+++ b/Utilities/EPNMonitoring/src/EPNstderrMonitor.cxx
@@ -133,7 +133,7 @@ void EPNMonitor::sendLog(const std::string& file, const std::string& message, co
   if (mInfoLoggerActive) {
     mLoggerContext->setField(InfoLogger::InfoLoggerContext::FieldName::Facility, ("stderr/" + file).substr(0, 31));
     mLoggerContext->setField(InfoLogger::InfoLoggerContext::FieldName::Run, mRunNumber != 0 ? std::to_string(mRunNumber) : "unspecified");
-    static const InfoLogger::InfoLogger::InfoLoggerMessageOption opt = {severity, level, InfoLogger::InfoLogger::undefinedMessageOption.errorCode, InfoLogger::InfoLogger::undefinedMessageOption.sourceFile, InfoLogger::InfoLogger::undefinedMessageOption.sourceLine};
+    const InfoLogger::InfoLogger::InfoLoggerMessageOption opt = {severity, level, InfoLogger::InfoLogger::undefinedMessageOption.errorCode, InfoLogger::InfoLogger::undefinedMessageOption.sourceFile, InfoLogger::InfoLogger::undefinedMessageOption.sourceLine};
     mLogger->log(opt, *mLoggerContext, "stderr: %s", file == "SYSLOG" ? (std::string("[GLOBAL SYSLOG]: ") + message).c_str() : message.c_str());
   } else {
     printf("stderr: [%c] %s: %s\n", severity, file.c_str(), message.c_str());

From 3c55949a494894a76e5ef22efddfe251e37bb176 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 24 Jun 2025 10:15:07 +0200
Subject: [PATCH 0526/1764] ITS: GPU add needed synchronization (#14439)

---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 2191880374548..8c6367c221583 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -1217,6 +1217,8 @@ void processNeighboursHandler(const int startLayer,
     maxChi2ClusterAttachment,
     propagator,
     matCorrType);
+  GPUChkErrS(cudaPeekAtLastError());
+  GPUChkErrS(cudaDeviceSynchronize());
 
   int level = startLevel;
   thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
@@ -1276,6 +1278,8 @@ void processNeighboursHandler(const int startLayer,
       maxChi2ClusterAttachment,
       propagator,
       matCorrType);
+    GPUChkErrS(cudaPeekAtLastError());
+    GPUChkErrS(cudaDeviceSynchronize());
   }
   thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> outSeeds(updatedCellSeed.size(), allocCellSeed);
   auto end = thrust::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));

From e1a32f71dac4b04be3f4001d864b641e554a76f3 Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Tue, 24 Jun 2025 14:29:58 +0200
Subject: [PATCH 0527/1764] DPL: enable new EoS by default and set data
 processing and exit transition timeouts (#14429)

* DPL: set data processing and exit transition timeouts by default to enable new EoS

* adjust data processing and exit transition timeouts in O2Control test
---
 Framework/Core/src/O2ControlHelpers.cxx          |  4 ++--
 Framework/Core/src/runDataProcessing.cxx         |  6 ++++--
 .../test/test_FrameworkDataFlowToO2Control.cxx   | 16 ++++++++--------
 3 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/src/O2ControlHelpers.cxx b/Framework/Core/src/O2ControlHelpers.cxx
index 48d564e4ee4f0..273950e5047f0 100644
--- a/Framework/Core/src/O2ControlHelpers.cxx
+++ b/Framework/Core/src/O2ControlHelpers.cxx
@@ -369,8 +369,8 @@ void dumpTask(std::ostream& dumpOut, const DeviceSpec& spec, const DeviceExecuti
   dumpOut << indLevel << "defaults:\n";
   dumpOut << indLevel << indScheme << "log_task_stdout: none\n";
   dumpOut << indLevel << indScheme << "log_task_stderr: none\n";
-  std::string exitTransitionTimeout = "15"; // Allow 15 seconds to finish processing and calibrations
-  std::string dataProcessingTimeout = "10"; // Allow only ten seconds to finish processing
+  std::string exitTransitionTimeout = "25"; // Allow 25 seconds to finish processing and calibrations
+  std::string dataProcessingTimeout = "20"; // Allow only 20 seconds to finish processing
   if (execution.args.size() > 2) {
     for (size_t i = 0; i < execution.args.size() - 1; ++i) {
       if (strcmp(execution.args[i], "--exit-transition-timeout") == 0) {
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index a7e80134a2cc0..f1111da79edd5 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1033,10 +1033,12 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
     std::string defaultInfologgerMode = "";
     o2::framework::DeploymentMode deploymentMode = o2::framework::DefaultsHelpers::deploymentMode();
     if (deploymentMode == o2::framework::DeploymentMode::OnlineDDS) {
-      defaultExitTransitionTimeout = "20";
+      defaultExitTransitionTimeout = "40";
+      defaultDataProcessingTimeout = "20";
       defaultInfologgerMode = "infoLoggerD";
     } else if (deploymentMode == o2::framework::DeploymentMode::OnlineECS) {
-      defaultExitTransitionTimeout = "20";
+      defaultExitTransitionTimeout = "25";
+      defaultDataProcessingTimeout = "20";
     }
     boost::program_options::options_description optsDesc;
     ConfigParamsHelper::populateBoostProgramOptions(optsDesc, spec.options, gHiddenDeviceOptions);
diff --git a/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx b/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
index 9cdbc357f9674..32dd0b5922a4f 100644
--- a/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
+++ b/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
@@ -138,8 +138,8 @@ const std::vector expectedTasks{
 defaults:
   log_task_stdout: none
   log_task_stderr: none
-  exit_transition_timeout: 15
-  data_processing_timeout: 10
+  exit_transition_timeout: 25
+  data_processing_timeout: 20
   _module_cmdline: >-
     source /etc/profile.d/modules.sh && MODULEPATH={{ modulepath }} module load O2 QualityControl Control-OCCPlugin &&
     {{ dpl_command }} | bcsadc/foo
@@ -236,8 +236,8 @@ const std::vector expectedTasks{
 defaults:
   log_task_stdout: none
   log_task_stderr: none
-  exit_transition_timeout: 15
-  data_processing_timeout: 10
+  exit_transition_timeout: 25
+  data_processing_timeout: 20
   _module_cmdline: >-
     source /etc/profile.d/modules.sh && MODULEPATH={{ modulepath }} module load O2 QualityControl Control-OCCPlugin &&
     {{ dpl_command }} | foo
@@ -336,8 +336,8 @@ const std::vector expectedTasks{
 defaults:
   log_task_stdout: none
   log_task_stderr: none
-  exit_transition_timeout: 15
-  data_processing_timeout: 10
+  exit_transition_timeout: 25
+  data_processing_timeout: 20
   _module_cmdline: >-
     source /etc/profile.d/modules.sh && MODULEPATH={{ modulepath }} module load O2 QualityControl Control-OCCPlugin &&
     {{ dpl_command }} | foo
@@ -436,8 +436,8 @@ const std::vector expectedTasks{
 defaults:
   log_task_stdout: none
   log_task_stderr: none
-  exit_transition_timeout: 15
-  data_processing_timeout: 10
+  exit_transition_timeout: 25
+  data_processing_timeout: 20
   _module_cmdline: >-
     source /etc/profile.d/modules.sh && MODULEPATH={{ modulepath }} module load O2 QualityControl Control-OCCPlugin &&
     {{ dpl_command }} | foo

From 0d55348cf853b6bdab626f20890f48d99695210e Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Tue, 24 Jun 2025 10:28:43 +0200
Subject: [PATCH 0528/1764] DigiContext: Bugfix for start of history effect

Under certain circumstances, we got a wrong
interactions included for the timeframe history effect.
This was essentially due to wrong variable initialization and is now fixed.
---
 DataFormats/simulation/src/DigitizationContext.cxx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index e5b4d6e706732..d840809a4c446 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -452,18 +452,18 @@ std::vector<std::tuple<int, int, int>> getTimeFrameBoundaries(std::vector<o2::In
       // in this range search the smallest index which precedes
       // timeframe ti by not more than "orbitsEarly" orbits
       // (could probably use binary search, in case optimization becomes necessary)
-      int earlyOrbitIndex = prev_tf_range.second;
+      int earlyOrbitIndex = -1; // init to start of this timeframe ... there may not be early orbits
 
       // this is the orbit of the ti-th timeframe start
       auto orbit_timeframe_start = startOrbit + ti * orbitsPerTF;
 
-      auto orbit_timeframe_early_fractional = orbit_timeframe_start - orbitsEarly;
-      auto orbit_timeframe_early_integral = (uint32_t)(orbit_timeframe_early_fractional);
+      auto orbit_timeframe_early_fractional = 1. * orbit_timeframe_start - orbitsEarly;
+      auto orbit_timeframe_early_integral = static_cast<long>(std::floor(orbit_timeframe_early_fractional));
 
       auto bc_early = (uint32_t)((orbit_timeframe_early_fractional - orbit_timeframe_early_integral) * o2::constants::lhc::LHCMaxBunches);
 
       // this is the interaction record of the ti-th timeframe start
-      o2::InteractionRecord timeframe_start_record(0, orbit_timeframe_early_integral);
+      o2::InteractionRecord timeframe_start_record(0, orbit_timeframe_start);
       // this is the interaction record in some previous timeframe after which interactions could still
       // influence the ti-th timeframe according to orbitsEarly
       o2::InteractionRecord timeframe_early_record(bc_early, orbit_timeframe_early_integral);

From 41279c2f65c0d7c8cba2d50dfde764e4f809f26d Mon Sep 17 00:00:00 2001
From: Chunzheng Wang <83008337+ChunzhengLab@users.noreply.github.com>
Date: Tue, 24 Jun 2025 18:29:12 +0200
Subject: [PATCH 0529/1764] ITS3: move the energy deposition wrt. centre of
 response (#14415)

* move the energy deposition wrt. centre of response

* fix the order of IB/OB for noise seeding

* print out the resp centre in the CheckChipResponseFile

* find the real centre

* should use the total eff but not only seed
---
 .../ITS3/macros/test/CheckChipResponseFile.C  | 68 ++++++++++-------
 .../simulation/src/ChipDigitsContainer.cxx    |  8 +-
 .../ITS3/simulation/src/ChipSimResponse.cxx   | 76 +++++++++++++------
 3 files changed, 97 insertions(+), 55 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C b/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
index 996a99d87ecbc..32d5bad87ce21 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
@@ -24,6 +24,7 @@
 
 #define ENABLE_UPGRADES
 #include "ITSMFTSimulation/AlpideSimResponse.h"
+#include "ITS3Simulation/ChipSimResponse.h"
 
 #include "ITS3Base/SegmentationMosaix.h"
 #include "fairlogger/Logger.h"
@@ -34,21 +35,21 @@ using SegmentationMosaix = o2::its3::SegmentationMosaix;
 double um2cm(double um) { return um * 1e-4; }
 double cm2um(double cm) { return cm * 1e+4; }
 
-o2::itsmft::AlpideSimResponse *mAlpSimResp0 = nullptr,
-                              *mAlpSimResp1 = nullptr,
-                              *mAptSimResp1 = nullptr;
+std::unique_ptr<o2::its3::ChipSimResponse> mAlpSimResp0, mAlpSimResp1, mAptSimResp1;
 
-o2::itsmft::AlpideSimResponse* loadResponse(const std::string& fileName, const std::string& respName)
+std::unique_ptr<o2::its3::ChipSimResponse> loadResponse(const std::string& fileName, const std::string& respName)
 {
   TFile* f = TFile::Open(fileName.data());
   if (!f) {
     std::cerr << fileName << " not found" << std::endl;
     return nullptr;
   }
-  auto resp = (o2::itsmft::AlpideSimResponse*)f->Get(respName.data());
-  if (!resp)
+  auto base = f->Get<o2::itsmft::AlpideSimResponse>(respName.c_str());
+  if (!base) {
     std::cerr << respName << " not found in " << fileName << std::endl;
-  return resp;
+    return nullptr;
+  }
+  return std::make_unique<o2::its3::ChipSimResponse>(base);
 }
 
 void LoadRespFunc()
@@ -56,39 +57,49 @@ void LoadRespFunc()
   std::string AptsFile = "$(O2_ROOT)/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/APTSResponseData.root";
   std::string AlpideFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
 
+  std::cout << "=====================\n";
+  LOGP(info, "ALPIDE Vbb=0V response");
   mAlpSimResp0 = loadResponse(AlpideFile, "response0"); // Vbb=0V
-  LOG(info) << "ALPIDE Vbb=0V response" << std::endl;
+  mAlpSimResp0->computeCentreFromData();
   mAlpSimResp0->print();
+  LOGP(info, "Response Centre {}", mAlpSimResp0->getRespCentreDep());
+  std::cout << "=====================\n";
+  LOGP(info, "ALPIDE Vbb=-3V response");
   mAlpSimResp1 = loadResponse(AlpideFile, "response1"); // Vbb=-3V
-  LOG(info) << "ALPIDE Vbb=-3V response" << std::endl;
+  mAlpSimResp1->computeCentreFromData();
   mAlpSimResp1->print();
+  LOGP(info, "Response Centre {}", mAlpSimResp1->getRespCentreDep());
+  std::cout << "=====================\n";
+  LOGP(info, "APTS response");
   mAptSimResp1 = loadResponse(AptsFile, "response1"); // APTS
-  LOG(info) << "APTS response" << std::endl;
+  mAptSimResp1->computeCentreFromData();
   mAptSimResp1->print();
+  LOGP(info, "Response Centre {}", mAptSimResp1->getRespCentreDep());
+  std::cout << "=====================\n";
 }
 
-std::vector<float> getCollectionSeediciencies(o2::itsmft::AlpideSimResponse* resp,
+std::vector<float> getCollectionSeediciencies(o2::its3::ChipSimResponse* resp,
                                               const std::vector<float>& depths)
 {
   std::vector<float> seed;
   bool flipRow = false, flipCol = false;
   for (auto depth : depths) {
     auto rspmat = resp->getResponse(0.0, 0.0,
-                                    um2cm(depth) + resp->getDepthMin() + 1.e-9,
+                                    um2cm(depth) + 1.e-9,
                                     flipRow, flipCol);
     seed.push_back(rspmat ? rspmat->getValue(2, 2) : 0.f);
   }
   return seed;
 }
 
-std::vector<float> getShareValues(o2::itsmft::AlpideSimResponse* resp,
+std::vector<float> getShareValues(o2::its3::ChipSimResponse* resp,
                                   const std::vector<float>& depths)
 {
   std::vector<float> share;
   bool flipRow = false, flipCol = false;
   for (auto depth : depths) {
     auto rspmat = resp->getResponse(0.0, 0.0,
-                                    um2cm(depth) + resp->getDepthMin() + 1.e-9,
+                                    um2cm(depth) + 1.e-9,
                                     flipRow, flipCol);
     float s = 0;
     int npix = resp->getNPix();
@@ -103,14 +114,14 @@ std::vector<float> getShareValues(o2::itsmft::AlpideSimResponse* resp,
   return share;
 }
 
-std::vector<float> getEffValues(o2::itsmft::AlpideSimResponse* resp,
+std::vector<float> getEffValues(o2::its3::ChipSimResponse* resp,
                                 const std::vector<float>& depths)
 {
   std::vector<float> all;
   bool flipRow = false, flipCol = false;
   for (auto depth : depths) {
     auto rspmat = resp->getResponse(0.0, 0.0,
-                                    um2cm(depth) + resp->getDepthMin() + 1.e-9,
+                                    um2cm(depth) + 1.e-9,
                                     flipRow, flipCol);
     float s = 0;
     int npix = resp->getNPix();
@@ -129,13 +140,16 @@ void CheckChipResponseFile()
   LoadRespFunc();
   LOG(info) << "Response function loaded" << std::endl;
 
-  std::vector<float> vecDepth(50);
-  for (int i = 0; i < 50; ++i)
-    vecDepth[i] = i;
+  std::vector<float> vecDepth;
+  int numPoints = 100;
+  for (int i = 0; i < numPoints; ++i) {
+    float value = -50 + i * (100.0f / (numPoints - 1));
+    vecDepth.push_back(value);
+  }
 
   int colors[] = {kOrange + 7, kRed + 1, kAzure + 4};
   struct RespInfo {
-    o2::itsmft::AlpideSimResponse* resp;
+    std::unique_ptr<o2::its3::ChipSimResponse>& resp;
     std::string title;
     int color;
   };
@@ -145,7 +159,7 @@ void CheckChipResponseFile()
     {mAlpSimResp1, "ALPIDE Vbb=-3V", colors[2]}};
 
   TCanvas* c1 = new TCanvas("c1", "c1", 800, 600);
-  TH1* frame = c1->DrawFrame(-1, -0.049, 50, 1.049);
+  TH1* frame = c1->DrawFrame(-50, -0.049, 50, 1.049);
   frame->SetTitle(";Depth(um);Charge Collection Seed / Share / Eff");
   TLegend* leg = new TLegend(0.15, 0.5, 0.4, 0.85);
   leg->SetFillStyle(0);
@@ -154,11 +168,11 @@ void CheckChipResponseFile()
   for (auto& r : responses) {
     if (!r.resp)
       continue;
-    auto seed = getCollectionSeediciencies(r.resp, vecDepth);
-    auto shr = getShareValues(r.resp, vecDepth);
-    auto all = getEffValues(r.resp, vecDepth);
+    auto seed = getCollectionSeediciencies(r.resp.get(), vecDepth);
+    auto shr = getShareValues(r.resp.get(), vecDepth);
+    auto all = getEffValues(r.resp.get(), vecDepth);
 
-    TGraph* grSeed = new TGraph(vecDepth.size(), vecDepth.data(), seed.data());
+    auto grSeed = new TGraph(vecDepth.size(), vecDepth.data(), seed.data());
     grSeed->SetTitle(Form("%s seed", r.title.c_str()));
     grSeed->SetLineColor(r.color);
     grSeed->SetLineWidth(2);
@@ -168,7 +182,7 @@ void CheckChipResponseFile()
     grSeed->Draw("SAME LP");
     leg->AddEntry(grSeed, Form("%s seed", r.title.c_str()), "lp");
 
-    TGraph* grShare = new TGraph(vecDepth.size(), vecDepth.data(), shr.data());
+    auto grShare = new TGraph(vecDepth.size(), vecDepth.data(), shr.data());
     grShare->SetLineColor(r.color);
     grShare->SetLineWidth(2);
     grShare->SetMarkerColor(r.color);
@@ -177,7 +191,7 @@ void CheckChipResponseFile()
     grShare->Draw("SAME LP");
     leg->AddEntry(grShare, Form("%s share", r.title.c_str()), "p");
 
-    TGraph* grEff = new TGraph(vecDepth.size(), vecDepth.data(), all.data());
+    auto grEff = new TGraph(vecDepth.size(), vecDepth.data(), all.data());
     grEff->SetLineColor(r.color);
     grEff->SetLineWidth(2);
     grEff->SetMarkerColor(r.color);
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx b/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
index 102b15863683e..efe878536687d 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ChipDigitsContainer.cxx
@@ -31,12 +31,12 @@ void ChipDigitsContainer::addNoise(UInt_t rofMin, UInt_t rofMax, const o2::its3:
   int nel = 0;
 
   if (isIB()) {
-    // Inner barrel: use ITS3-specific noise interface with OB segmentation.
-    mean = params->getIBNoisePerPixel() * SegmentationOB::NPixels;
+    // Inner barrel: use ITS3-specific noise interface with IB segmentation.
+    mean = params->getIBNoisePerPixel() * SegmentationIB::NPixels;
     nel = static_cast<int>(params->getIBChargeThreshold() * 1.1);
   } else {
-    // Outer barrel: use base class noise interface with IB segmentation.
-    mean = params->getNoisePerPixel() * SegmentationIB::NPixels;
+    // Outer barrel: use base class noise interface with OB segmentation.
+    mean = params->getNoisePerPixel() * SegmentationOB::NPixels;
     nel = static_cast<int>(params->getChargeThreshold() * 1.1);
   }
 
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ChipSimResponse.cxx b/Detectors/Upgrades/ITS3/simulation/src/ChipSimResponse.cxx
index 1c482983f0d0a..72b291fb0d653 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ChipSimResponse.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ChipSimResponse.cxx
@@ -25,38 +25,66 @@ void ChipSimResponse::initData(int tableNumber, std::string dataPath, const bool
 
 void ChipSimResponse::computeCentreFromData()
 {
-  std::vector<float> zVec, qVec;
   const int npix = o2::itsmft::AlpideRespSimMat::getNPix();
+  std::vector<float> zVec, effVec;
+  zVec.reserve(mNBinDpt);
+  effVec.reserve(mNBinDpt);
 
   for (int iz = 0; iz < mNBinDpt; ++iz) {
-    size_t bin = iz + mNBinDpt * (0 + mNBinRow * 0);
-    const auto& mat = mData[bin];
-    float val = mat.getValue(npix / 2, npix / 2);
-    float gz = mDptMin + iz / mStepInvDpt;
-    zVec.push_back(gz);
-    qVec.push_back(val);
+    int rev = mNBinDpt - 1 - iz;
+    float z = mDptMin + iz / mStepInvDpt;
+    float sum = 0.f;
+    const auto& mat = mData[rev];
+    for (int ix = 0; ix < npix; ++ix) {
+      for (int iy = 0; iy < npix; ++iy) {
+        sum += mat.getValue(ix, iy);
+      }
+    }
+    zVec.push_back(z);
+    effVec.push_back(sum);
   }
 
-  std::vector<std::pair<float, float>> zqPairs;
-  for (size_t i = 0; i < zVec.size(); ++i) {
-    zqPairs.emplace_back(zVec[i], qVec[i]);
-  }
-  std::sort(zqPairs.begin(), zqPairs.end());
-  zVec.clear();
-  qVec.clear();
-  for (auto& p : zqPairs) {
-    zVec.push_back(p.first);
-    qVec.push_back(p.second);
-  }
+  struct Bin {
+    float z0, z1, q0, q1, dq;
+  };
+  std::vector<Bin> bins;
+  bins.reserve(zVec.size() - 1);
 
-  float intQ = 0.f, intZQ = 0.f;
+  float totQ = 0.f;
   for (size_t i = 0; i + 1 < zVec.size(); ++i) {
     float z0 = zVec[i], z1 = zVec[i + 1];
-    float q0 = qVec[i], q1 = qVec[i + 1];
-    float dz = z1 - z0;
-    intQ += 0.5f * (q0 + q1) * dz;
-    intZQ += 0.5f * (z0 * q0 + z1 * q1) * dz;
+    float q0 = effVec[i], q1 = effVec[i + 1];
+    float dq = 0.5f * (q0 + q1) * (z1 - z0);
+    bins.push_back({z0, z1, q0, q1, dq});
+    totQ += dq;
+  }
+
+  if (totQ <= 0.f) {
+    mRespCentreDep = mDptMin;
+    return;
+  }
+
+  float halfQ = 0.5f * totQ;
+  float cumQ = 0.f;
+  for (auto& b : bins) {
+    if (cumQ + b.dq < halfQ) {
+      cumQ += b.dq;
+      continue;
+    }
+    float dz = b.z1 - b.z0;
+    float slope = (b.q1 - b.q0) / dz;
+    float disc = b.q0 * b.q0 - 2.f * slope * (cumQ - halfQ);
+
+    float x;
+    if (disc >= 0.f && std::abs(slope) > 1e-6f) {
+      x = (-b.q0 + std::sqrt(disc)) / slope;
+    } else {
+      x = (halfQ - cumQ) / b.q0;
+    }
+    x = std::clamp(x, 0.f, dz);
+    mRespCentreDep = b.z0 + x;
+    return;
   }
 
-  mRespCentreDep = (intQ > 0.f) ? intZQ / intQ : 0.f;
+  mRespCentreDep = mDptMax;
 }

From 2008bc4e50ef7e927242bc1a74c7b81156a7122e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 24 Jun 2025 19:04:36 +0200
Subject: [PATCH 0530/1764] ITS: GPU report found neighbours (#14438)

---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         | 21 +++++++++++++++++--
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     |  3 +++
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 11 +++++-----
 .../tracking/include/ITStracking/TimeFrame.h  |  6 +++---
 4 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 82101dba4c02d..d41591e6ff25c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -130,7 +130,9 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   // Host-specific getters
   gsl::span<int, nLayers - 1> getNTracklets() { return mNTracklets; }
   gsl::span<int, nLayers - 2> getNCells() { return mNCells; }
-  std::array<int, nLayers - 2>& getArrayNCells() { return mNCells; }
+  auto& getArrayNCells() { return mNCells; }
+  gsl::span<int, nLayers - 3> getNNeighbours() { return mNNeighbours; }
+  auto& getArrayNNeighbours() { return mNNeighbours; }
 
   // Host-available device getters
   gsl::span<int*> getDeviceTrackletsLUTs() { return mTrackletsLUTDevice; }
@@ -139,7 +141,9 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   gsl::span<CellSeed*> getDeviceCells() { return mCellsDevice; }
 
   // Overridden getters
-  int getNumberOfCells() const;
+  int getNumberOfTracklets() const final;
+  int getNumberOfCells() const final;
+  int getNumberOfNeighbours() const final;
 
  private:
   void allocMemAsync(void**, size_t, Stream*, bool); // Abstract owned and unowned memory allocations
@@ -149,6 +153,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   // Host-available device buffer sizes
   std::array<int, nLayers - 1> mNTracklets;
   std::array<int, nLayers - 2> mNCells;
+  std::array<int, nLayers - 3> mNNeighbours;
 
   // Device pointers
   IndexTableUtils* mIndexTableUtilsDevice;
@@ -218,12 +223,24 @@ inline std::vector<unsigned int> TimeFrameGPU<nLayers>::getClusterSizes()
   return sizes;
 }
 
+template <int nLayers>
+inline int TimeFrameGPU<nLayers>::getNumberOfTracklets() const
+{
+  return std::accumulate(mNTracklets.begin(), mNTracklets.end(), 0);
+}
+
 template <int nLayers>
 inline int TimeFrameGPU<nLayers>::getNumberOfCells() const
 {
   return std::accumulate(mNCells.begin(), mNCells.end(), 0);
 }
 
+template <int nLayers>
+inline int TimeFrameGPU<nLayers>::getNumberOfNeighbours() const
+{
+  return std::accumulate(mNNeighbours.begin(), mNNeighbours.end(), 0);
+}
+
 } // namespace o2::its::gpu
 
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 8380533a28e04..b336073604b62 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -342,6 +342,9 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
     LOGP(debug, "gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), nullptr, this->getExtAllocator());
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0]->get()));
+    if (iLayer < nLayers - 3) {
+      mNNeighbours[iLayer] = 0;
+    }
   }
   STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 89d2b5aeffe63..b32189f3fabe3 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -169,7 +169,7 @@ template <int nLayers>
 void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
 {
   mTimeFrameGPU->createNeighboursIndexTablesDevice();
-  auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
+  const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   for (int iLayer{0}; iLayer < this->mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
     const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};
 
@@ -208,10 +208,11 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                  conf.nBlocks,
                                  conf.nThreads);
 
-    filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
-                                mTimeFrameGPU->getDeviceNeighbours(iLayer),
-                                nNeigh,
-                                mTimeFrameGPU->getExternalAllocator());
+    nNeigh = filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
+                                         mTimeFrameGPU->getDeviceNeighbours(iLayer),
+                                         nNeigh,
+                                         mTimeFrameGPU->getExternalAllocator());
+    mTimeFrameGPU->getArrayNNeighbours()[iLayer] = nNeigh;
   }
   mTimeFrameGPU->createNeighboursDeviceArray();
   mTimeFrameGPU->unregisterRest();
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 8b857df7cdd80..230a46681385d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -175,9 +175,9 @@ struct TimeFrame {
   auto& getVerticesMCRecInfo() { return mVerticesMCRecInfo; }
 
   int getNumberOfClusters() const;
-  int getNumberOfCells() const;
-  int getNumberOfTracklets() const;
-  int getNumberOfNeighbours() const;
+  virtual int getNumberOfCells() const;
+  virtual int getNumberOfTracklets() const;
+  virtual int getNumberOfNeighbours() const;
   size_t getNumberOfTracks() const;
   size_t getNumberOfUsedClusters() const;
   auto getNumberOfExtendedTracks() const { return mNExtendedTracks; }

From 2ca4db7b14535d5fe17397367baa54849ecbde2b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 24 Jun 2025 19:51:50 +0200
Subject: [PATCH 0531/1764] DPL: make sure Lifetime::Sporadic is kept (#14434)

---
 Framework/Core/include/Framework/FairMQDeviceProxy.h | 2 ++
 Framework/Core/src/DataAllocator.cxx                 | 7 ++++++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/FairMQDeviceProxy.h b/Framework/Core/include/Framework/FairMQDeviceProxy.h
index 46b35f54f21ba..ab0d094c18486 100644
--- a/Framework/Core/include/Framework/FairMQDeviceProxy.h
+++ b/Framework/Core/include/Framework/FairMQDeviceProxy.h
@@ -40,6 +40,8 @@ class FairMQDeviceProxy
   void bind(std::vector<OutputRoute> const& outputs, std::vector<InputRoute> const& inputs,
             std::vector<ForwardRoute> const& forwards, fair::mq::Device& device);
 
+  /// Retrieve the transport associated to a given route.
+  [[nodiscard]] OutputRoute const& getOutputRoute(RouteIndex routeIndex) const { return mOutputs.at(routeIndex.value); }
   /// Retrieve the transport associated to a given route.
   [[nodiscard]] fair::mq::TransportFactory* getOutputTransport(RouteIndex routeIndex) const;
   /// Retrieve the transport associated to a given route.
diff --git a/Framework/Core/src/DataAllocator.cxx b/Framework/Core/src/DataAllocator.cxx
index ca35089fdfaab..4b559ef26191e 100644
--- a/Framework/Core/src/DataAllocator.cxx
+++ b/Framework/Core/src/DataAllocator.cxx
@@ -9,6 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 #include "Framework/CompilerBuiltins.h"
+#include "Framework/Lifetime.h"
 #include "Framework/TableBuilder.h"
 #include "Framework/TableTreeHelpers.h"
 #include "Framework/DataAllocator.h"
@@ -121,8 +122,12 @@ fair::mq::MessagePtr DataAllocator::headerMessageFromOutput(Output const& spec,
   dh.runNumber = timingInfo.runNumber;
 
   DataProcessingHeader dph{timingInfo.timeslice, 1, timingInfo.creation};
-  static_cast<o2::header::BaseHeader&>(dph).flagsDerivedHeader |= timingInfo.keepAtEndOfStream ? DataProcessingHeader::KEEP_AT_EOS_FLAG : 0;
   auto& proxy = mRegistry.get<FairMQDeviceProxy>();
+  auto lifetime = proxy.getOutputRoute(routeIndex).matcher.lifetime;
+  static_cast<o2::header::BaseHeader&>(dph).flagsDerivedHeader |= timingInfo.keepAtEndOfStream ? DataProcessingHeader::KEEP_AT_EOS_FLAG : 0;
+  // Messages associated to sporatic output we always keep, since they are most likely histograms / condition
+  // objects which need to be kept at the end of stream.
+  static_cast<o2::header::BaseHeader&>(dph).flagsDerivedHeader |= (lifetime == Lifetime::Sporadic) ? DataProcessingHeader::KEEP_AT_EOS_FLAG : 0;
   auto* transport = proxy.getOutputTransport(routeIndex);
 
   auto channelAlloc = o2::pmr::getTransportAllocator(transport);

From 907144be68eda1c0a4d1a9f6be4ef6283a6fe4d7 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 25 Jun 2025 00:43:34 +0200
Subject: [PATCH 0532/1764] Fix using namespace arrow, arrow::io (#14442)

---
 .../include/Framework/FairMQResizableBuffer.h | 25 ++++++++-----------
 Framework/Core/src/FairMQResizableBuffer.cxx  | 14 ++++++-----
 2 files changed, 19 insertions(+), 20 deletions(-)

diff --git a/Framework/Core/include/Framework/FairMQResizableBuffer.h b/Framework/Core/include/Framework/FairMQResizableBuffer.h
index cdf2a22a2a56b..fc86d8d5dd753 100644
--- a/Framework/Core/include/Framework/FairMQResizableBuffer.h
+++ b/Framework/Core/include/Framework/FairMQResizableBuffer.h
@@ -24,13 +24,10 @@
 namespace o2::framework
 {
 
-using namespace arrow;
-using namespace arrow::io;
-
-class FairMQOutputStream : public OutputStream
+class FairMQOutputStream : public arrow::io::OutputStream
 {
  public:
-  explicit FairMQOutputStream(const std::shared_ptr<ResizableBuffer>& buffer);
+  explicit FairMQOutputStream(const std::shared_ptr<arrow::ResizableBuffer>& buffer);
 
   /// \brief Create in-memory output stream with indicated capacity using a
   /// memory pool
@@ -38,8 +35,8 @@ class FairMQOutputStream : public OutputStream
   /// the OutputStream
   /// \param[in,out] pool a MemoryPool to use for allocations
   /// \return the created stream
-  static Result<std::shared_ptr<FairMQOutputStream>> Create(
-    int64_t initial_capacity = 4096, MemoryPool* pool = default_memory_pool());
+  static arrow::Result<std::shared_ptr<FairMQOutputStream>> Create(
+    int64_t initial_capacity = 4096, arrow::MemoryPool* pool = arrow::default_memory_pool());
 
   // By the time we call the destructor, the contents
   // of the buffer are already moved to fairmq
@@ -49,24 +46,24 @@ class FairMQOutputStream : public OutputStream
   // Implement the OutputStream interface
 
   /// Close the stream, preserving the buffer (retrieve it with Finish()).
-  Status Close() override;
+  arrow::Status Close() override;
   [[nodiscard]] bool closed() const override;
-  [[nodiscard]] Result<int64_t> Tell() const override;
-  Status Write(const void* data, int64_t nbytes) override;
+  [[nodiscard]] arrow::Result<int64_t> Tell() const override;
+  arrow::Status Write(const void* data, int64_t nbytes) override;
 
   /// \cond FALSE
   using OutputStream::Write;
   /// \endcond
 
   /// Close the stream and return the buffer
-  Result<std::shared_ptr<Buffer>> Finish();
+  arrow::Result<std::shared_ptr<arrow::Buffer>> Finish();
 
   /// \brief Initialize state of OutputStream with newly allocated memory and
   /// set position to 0
   /// \param[in] initial_capacity the starting allocated capacity
   /// \param[in,out] pool the memory pool to use for allocations
   /// \return Status
-  Status Reset(int64_t initial_capacity = 1024, MemoryPool* pool = default_memory_pool());
+  arrow::Status Reset(int64_t initial_capacity = 1024, arrow::MemoryPool* pool = arrow::default_memory_pool());
 
   [[nodiscard]] int64_t capacity() const { return capacity_; }
 
@@ -74,9 +71,9 @@ class FairMQOutputStream : public OutputStream
   FairMQOutputStream();
 
   // Ensures there is sufficient space available to write nbytes
-  Status Reserve(int64_t nbytes);
+  arrow::Status Reserve(int64_t nbytes);
 
-  std::shared_ptr<ResizableBuffer> buffer_;
+  std::shared_ptr<arrow::ResizableBuffer> buffer_;
   bool is_open_;
   int64_t capacity_;
   int64_t position_;
diff --git a/Framework/Core/src/FairMQResizableBuffer.cxx b/Framework/Core/src/FairMQResizableBuffer.cxx
index 9fe1cc882b6ae..592dfcb4376e9 100644
--- a/Framework/Core/src/FairMQResizableBuffer.cxx
+++ b/Framework/Core/src/FairMQResizableBuffer.cxx
@@ -16,6 +16,8 @@
 #include <cassert>
 #include <utility>
 
+using arrow::Status;
+
 namespace arrow::io::internal
 {
 void CloseFromDestructor(FileInterface* file);
@@ -28,15 +30,15 @@ static constexpr int64_t kBufferMinimumSize = 256;
 FairMQOutputStream::FairMQOutputStream()
   : is_open_(false), capacity_(0), position_(0), mutable_data_(nullptr) {}
 
-FairMQOutputStream::FairMQOutputStream(const std::shared_ptr<ResizableBuffer>& buffer)
+FairMQOutputStream::FairMQOutputStream(const std::shared_ptr<arrow::ResizableBuffer>& buffer)
   : buffer_(buffer),
     is_open_(true),
     capacity_(buffer->size()),
     position_(0),
     mutable_data_(buffer->mutable_data()) {}
 
-Result<std::shared_ptr<FairMQOutputStream>> FairMQOutputStream::Create(
-  int64_t initial_capacity, MemoryPool* pool)
+arrow::Result<std::shared_ptr<FairMQOutputStream>> FairMQOutputStream::Create(
+  int64_t initial_capacity, arrow::MemoryPool* pool)
 {
   // ctor is private, so cannot use make_shared
   auto ptr = std::shared_ptr<FairMQOutputStream>(new FairMQOutputStream);
@@ -44,7 +46,7 @@ Result<std::shared_ptr<FairMQOutputStream>> FairMQOutputStream::Create(
   return ptr;
 }
 
-Status FairMQOutputStream::Reset(int64_t initial_capacity, MemoryPool* pool)
+Status FairMQOutputStream::Reset(int64_t initial_capacity, arrow::MemoryPool* pool)
 {
   ARROW_ASSIGN_OR_RAISE(buffer_, AllocateResizableBuffer(initial_capacity, pool));
   is_open_ = true;
@@ -67,7 +69,7 @@ Status FairMQOutputStream::Close()
 
 bool FairMQOutputStream::closed() const { return !is_open_; }
 
-Result<std::shared_ptr<Buffer>> FairMQOutputStream::Finish()
+arrow::Result<std::shared_ptr<arrow::Buffer>> FairMQOutputStream::Finish()
 {
   RETURN_NOT_OK(Close());
   buffer_->ZeroPadding();
@@ -75,7 +77,7 @@ Result<std::shared_ptr<Buffer>> FairMQOutputStream::Finish()
   return std::move(buffer_);
 }
 
-Result<int64_t> FairMQOutputStream::Tell() const { return position_; }
+arrow::Result<int64_t> FairMQOutputStream::Tell() const { return position_; }
 
 Status FairMQOutputStream::Write(const void* data, int64_t nbytes)
 {

From 19e73ce40c0dfa6fc33cfc373e572049c98aa43d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?= <vit.kucera@cern.ch>
Date: Wed, 25 Jun 2025 10:23:32 +0200
Subject: [PATCH 0533/1764] IWYU: BinningPolicy.h (#14323)

---
 Framework/Core/include/Framework/BinningPolicy.h | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index b5e9ba546c4d9..73548cbd6c6ed 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -12,8 +12,13 @@
 #ifndef FRAMEWORK_BINNINGPOLICY_H
 #define FRAMEWORK_BINNINGPOLICY_H
 
+#include "Framework/ASoA.h"
 #include "Framework/HistogramSpec.h" // only for VARIABLE_WIDTH
-#include "Framework/Pack.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <tuple>
+#include <vector>
 
 namespace o2::framework
 {

From 92f546664861cb867defb425cde8f17cec686518 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 25 Jun 2025 16:22:00 +0200
Subject: [PATCH 0534/1764] Avoid missing dictionary (#14443)

---
 DataFormats/simulation/test/testBasicHits.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/simulation/test/testBasicHits.cxx b/DataFormats/simulation/test/testBasicHits.cxx
index e81c173fedae8..ccd16ae7a3671 100644
--- a/DataFormats/simulation/test/testBasicHits.cxx
+++ b/DataFormats/simulation/test/testBasicHits.cxx
@@ -66,7 +66,7 @@ BOOST_AUTO_TEST_CASE(BasicXYZHit_ROOTIO)
   }
 
   // same for double valued hits
-  using HitTypeD = BasicXYZEHit<double, double>;
+  using HitTypeD = BasicXYZEHit<double, double, double>;
   HitTypeD hitD(1., 2., 3., 0.01, -1.1, -1, 1);
 
   // try writing hit to a TBuffer

From fa3dd7bc0eec6c3faf34bb8fdca6010c07609d97 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 24 Jun 2025 21:29:36 +0200
Subject: [PATCH 0535/1764] ITS: redefine seeding vertex label

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITStracking/VertexerTraits.h      | 20 ++++++++++++-------
 .../ITS/tracking/src/VertexerTraits.cxx       | 18 ++++++++---------
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 6554e53fa2ee8..a842f04abfc62 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -101,19 +101,25 @@ class VertexerTraits
   virtual bool usesMemoryPool() const noexcept { return true; }
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
 
-  template <typename T = o2::MCCompLabel>
-  static std::pair<T, float> computeMain(const bounded_vector<T>& elements)
+  static std::pair<o2::MCCompLabel, float> computeMain(const bounded_vector<o2::MCCompLabel>& elements)
   {
-    T elem;
+    // we only care about the source&event of the tracks, not the trackId
+    auto composeVtxLabel = [](const o2::MCCompLabel& lbl) -> o2::MCCompLabel {
+      return {o2::MCCompLabel::maxTrackID(), lbl.getEventID(), lbl.getSourceID(), lbl.isFake()};
+    };
+    std::unordered_map<o2::MCCompLabel, size_t> frequency;
+    for (const auto& element : elements) {
+      ++frequency[composeVtxLabel(element)];
+    }
+    o2::MCCompLabel elem{};
     size_t maxCount = 0;
-    for (auto& element : elements) {
-      size_t count = std::count(elements.begin(), elements.end(), element);
+    for (const auto& [key, count] : frequency) {
       if (count > maxCount) {
         maxCount = count;
-        elem = element;
+        elem = key;
       }
     }
-    return std::make_pair(elem, static_cast<float>(maxCount) / elements.size());
+    return std::make_pair(elem, static_cast<float>(maxCount) / static_cast<float>(elements.size()));
   }
 
  protected:
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 51cd98aa1366d..11304e17d234a 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -506,18 +506,18 @@ void VertexerTraits::computeVertices(const int iteration)
 
       if (beamDistance2 < nsigmaCut && o2::gpu::GPUCommonMath::Abs(mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[2]) < mVrtParams[iteration].maxZPositionAllowed) {
         atLeastOneFound = true;
-        vertices.emplace_back(o2::math_utils::Point3D<float>(mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[0],
-                                                             mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[1],
-                                                             mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[2]),
-                              mTimeFrame->getTrackletClusters(rofId)[iCluster].getRMS2(),          // Symm matrix. Diagonal: RMS2 components,
-                                                                                                   // off-diagonal: square mean of projections on planes.
-                              mTimeFrame->getTrackletClusters(rofId)[iCluster].getSize(),          // Contributors
-                              mTimeFrame->getTrackletClusters(rofId)[iCluster].getAvgDistance2()); // In place of chi2
+        auto& vertex = vertices.emplace_back(o2::math_utils::Point3D<float>(mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[0],
+                                                                            mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[1],
+                                                                            mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[2]),
+                                             mTimeFrame->getTrackletClusters(rofId)[iCluster].getRMS2(),          // Symm matrix. Diagonal: RMS2 components,
+                                                                                                                  // off-diagonal: square mean of projections on planes.
+                                             mTimeFrame->getTrackletClusters(rofId)[iCluster].getSize(),          // Contributors
+                                             mTimeFrame->getTrackletClusters(rofId)[iCluster].getAvgDistance2()); // In place of chi2
 
         if (iteration) {
-          vertices.back().setFlags(Vertex::UPCMode);
+          vertex.setFlags(Vertex::UPCMode);
         }
-        vertices.back().setTimeStamp(mTimeFrame->getTrackletClusters(rofId)[iCluster].getROF());
+        vertex.setTimeStamp(mTimeFrame->getTrackletClusters(rofId)[iCluster].getROF());
         if (mTimeFrame->hasMCinformation()) {
           bounded_vector<o2::MCCompLabel> labels(mMemoryPool.get());
           for (auto& index : mTimeFrame->getTrackletClusters(rofId)[iCluster].getLabels()) {

From ecb7932a38cc2ba37066efc3a8899b60d189df07 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 23 Jun 2025 15:27:53 +0200
Subject: [PATCH 0536/1764] Move bulk of the code to cxx to not expose extra
 headers

---
 .../Detectors/ITSMFT/common/CMakeLists.txt    |   9 +-
 .../include/DataFormatsITSMFT/TimeDeadMap.h   |  95 ++---------------
 .../ITSMFT/common/src/TimeDeadMap.cxx         | 100 ++++++++++++++++++
 3 files changed, 113 insertions(+), 91 deletions(-)
 create mode 100644 DataFormats/Detectors/ITSMFT/common/src/TimeDeadMap.cxx

diff --git a/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt b/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
index 62fc09ffcad00..96d376526a1a4 100644
--- a/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
+++ b/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
@@ -18,6 +18,7 @@ o2_add_library(DataFormatsITSMFT
                        src/ClusterPattern.cxx
                        src/ClusterTopology.cxx
                        src/TopologyDictionary.cxx
+                       src/TimeDeadMap.cxx
                        src/CTF.cxx
                PUBLIC_LINK_LIBRARIES O2::ITSMFTBase
                        O2::ReconstructionDataFormats
@@ -25,10 +26,10 @@ o2_add_library(DataFormatsITSMFT
 
 o2_target_root_dictionary(DataFormatsITSMFT
                           HEADERS include/DataFormatsITSMFT/ROFRecord.h
-                                 include/DataFormatsITSMFT/Digit.h
-                                 include/DataFormatsITSMFT/GBTCalibData.h
-                                 include/DataFormatsITSMFT/NoiseMap.h
-                                 include/DataFormatsITSMFT/TimeDeadMap.h
+                                  include/DataFormatsITSMFT/Digit.h
+                                  include/DataFormatsITSMFT/GBTCalibData.h
+                                  include/DataFormatsITSMFT/NoiseMap.h
+                                  include/DataFormatsITSMFT/TimeDeadMap.h
                                   include/DataFormatsITSMFT/Cluster.h
                                   include/DataFormatsITSMFT/CompCluster.h
                                   include/DataFormatsITSMFT/ClusterPattern.h
diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h
index a0b214f705d7c..5a93cbb712931 100644
--- a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h
@@ -15,8 +15,6 @@
 #define ALICEO2_ITSMFT_TIMEDEADMAP_H
 
 #include "Rtypes.h"
-#include "DetectorsCommonDataFormats/DetID.h"
-#include <iostream>
 #include <vector>
 #include <map>
 
@@ -26,6 +24,8 @@ namespace o2
 namespace itsmft
 {
 
+class NoiseMap;
+
 class TimeDeadMap
 {
  public:
@@ -56,96 +56,17 @@ class TimeDeadMap
     mStaticDeadMap.clear();
   }
 
-  void decodeMap(o2::itsmft::NoiseMap& noisemap)
-  { // for static part only
-    if (mMAP_VERSION == "3") {
-      LOG(error) << "Trying to decode static part of deadmap version " << mMAP_VERSION << ". Not implemented, doing nothing.";
-      return;
-    }
-    for (int iel = 0; iel < mStaticDeadMap.size(); iel++) {
-      uint16_t w = mStaticDeadMap[iel];
-      noisemap.maskFullChip(w & 0x7FFF);
-      if (w & 0x8000) {
-        for (int w2 = (w & 0x7FFF) + 1; w2 < mStaticDeadMap.at(iel + 1); w2++) {
-          noisemap.maskFullChip(w2);
-        }
-      }
-    }
-  }
-
-  void decodeMap(unsigned long orbit, o2::itsmft::NoiseMap& noisemap, bool includeStaticMap = true, long orbitGapAllowed = 330000)
-  { // for time-dependent and (optionally) static part. Use orbitGapAllowed = -1 to ignore check on orbit difference
-
-    if (mMAP_VERSION != "3" && mMAP_VERSION != "4") {
-      LOG(error) << "Trying to decode time-dependent deadmap version " << mMAP_VERSION << ". Not implemented, doing nothing.";
-      return;
-    }
-
-    if (mEvolvingDeadMap.empty()) {
-      LOG(warning) << "Time-dependent dead map is empty. Doing nothing.";
-      return;
-    }
-
-    std::vector<uint16_t> closestVec;
-    long dT = getMapAtOrbit(orbit, closestVec);
-
-    if (orbitGapAllowed >= 0 && std::abs(dT) > orbitGapAllowed) {
-      LOG(warning) << "Requested orbit " << orbit << ", found " << orbit - dT << ". Orbit gap is too high, skipping time-dependent map.";
-      closestVec.clear();
-    }
-
-    // add static part if requested. something may be masked twice
-    if (includeStaticMap && mMAP_VERSION != "3") {
-      closestVec.insert(closestVec.end(), mStaticDeadMap.begin(), mStaticDeadMap.end());
-    }
-
-    // vector encoding: if 1<<15 = 0x8000 is set, the word encodes the first element of a range, with mask (1<<15)-1 = 0x7FFF. The last element of the range is the next in the vector.
-
-    for (int iel = 0; iel < closestVec.size(); iel++) {
-      uint16_t w = closestVec.at(iel);
-      noisemap.maskFullChip(w & 0x7FFF);
-      if (w & 0x8000) {
-        for (int w2 = (w & 0x7FFF) + 1; w2 < closestVec.at(iel + 1); w2++) {
-          noisemap.maskFullChip(w2);
-        }
-      }
-    }
-  };
-
+  void decodeMap(NoiseMap& noisemap) const;
+  void decodeMap(unsigned long orbit, o2::itsmft::NoiseMap& noisemap, bool includeStaticMap = true, long orbitGapAllowed = 330000) const;
   std::string getMapVersion() const { return mMAP_VERSION; };
 
   unsigned long getEvolvingMapSize() const { return mEvolvingDeadMap.size(); };
-
-  std::vector<unsigned long> getEvolvingMapKeys()
-  {
-    std::vector<unsigned long> keys;
-    std::transform(mEvolvingDeadMap.begin(), mEvolvingDeadMap.end(), std::back_inserter(keys),
-                   [](const auto& O) { return O.first; });
-    return keys;
-  }
-
-  void getStaticMap(std::vector<uint16_t>& mmap) { mmap = mStaticDeadMap; };
-
-  long getMapAtOrbit(unsigned long orbit, std::vector<uint16_t>& mmap)
-  { // fills mmap and returns requested_orbit - found_orbit. Found orbit is the highest key lower or equal to the requested one
-    if (mEvolvingDeadMap.empty()) {
-      LOG(warning) << "Requested orbit " << orbit << "from an empty time-dependent map. Doing nothing";
-      return (long)orbit;
-    }
-    auto closest = mEvolvingDeadMap.upper_bound(orbit);
-    if (closest != mEvolvingDeadMap.begin()) {
-      --closest;
-      mmap = closest->second;
-      return (long)orbit - closest->first;
-    } else {
-      mmap = mEvolvingDeadMap.begin()->second;
-      return (long)(orbit)-mEvolvingDeadMap.begin()->first;
-    }
-  }
-
+  std::vector<unsigned long> getEvolvingMapKeys() const;
+  void getStaticMap(std::vector<uint16_t>& mmap) const { mmap = mStaticDeadMap; };
+  long getMapAtOrbit(unsigned long orbit, std::vector<uint16_t>& mmap) const;
   void setMapVersion(std::string version) { mMAP_VERSION = version; };
 
-  bool isDefault() { return mIsDefaultObject; };
+  bool isDefault() const { return mIsDefaultObject; };
   void setAsDefault(bool isdef = true) { mIsDefaultObject = isdef; };
 
  private:
diff --git a/DataFormats/Detectors/ITSMFT/common/src/TimeDeadMap.cxx b/DataFormats/Detectors/ITSMFT/common/src/TimeDeadMap.cxx
new file mode 100644
index 0000000000000..e3df8e7f91f86
--- /dev/null
+++ b/DataFormats/Detectors/ITSMFT/common/src/TimeDeadMap.cxx
@@ -0,0 +1,100 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TimeDeadMap.cxx
+/// \brief Implementation of the time-dependent map
+
+#include "DataFormatsITSMFT/TimeDeadMap.h"
+#include "DataFormatsITSMFT/NoiseMap.h"
+#include "Framework/Logger.h"
+
+using namespace o2::itsmft;
+
+void TimeDeadMap::decodeMap(o2::itsmft::NoiseMap& noisemap) const
+{ // for static part only
+  if (mMAP_VERSION == "3") {
+    LOG(error) << "Trying to decode static part of deadmap version " << mMAP_VERSION << ". Not implemented, doing nothing.";
+    return;
+  }
+  for (int iel = 0; iel < mStaticDeadMap.size(); iel++) {
+    uint16_t w = mStaticDeadMap[iel];
+    noisemap.maskFullChip(w & 0x7FFF);
+    if (w & 0x8000) {
+      for (int w2 = (w & 0x7FFF) + 1; w2 < mStaticDeadMap.at(iel + 1); w2++) {
+        noisemap.maskFullChip(w2);
+      }
+    }
+  }
+}
+
+void TimeDeadMap::decodeMap(unsigned long orbit, o2::itsmft::NoiseMap& noisemap, bool includeStaticMap, long orbitGapAllowed) const
+{ // for time-dependent and (optionally) static part. Use orbitGapAllowed = -1 to ignore check on orbit difference
+
+  if (mMAP_VERSION != "3" && mMAP_VERSION != "4") {
+    LOG(error) << "Trying to decode time-dependent deadmap version " << mMAP_VERSION << ". Not implemented, doing nothing.";
+    return;
+  }
+
+  if (mEvolvingDeadMap.empty()) {
+    LOG(warning) << "Time-dependent dead map is empty. Doing nothing.";
+    return;
+  }
+
+  std::vector<uint16_t> closestVec;
+  long dT = getMapAtOrbit(orbit, closestVec);
+
+  if (orbitGapAllowed >= 0 && std::abs(dT) > orbitGapAllowed) {
+    LOG(warning) << "Requested orbit " << orbit << ", found " << orbit - dT << ". Orbit gap is too high, skipping time-dependent map.";
+    closestVec.clear();
+  }
+
+  // add static part if requested. something may be masked twice
+  if (includeStaticMap && mMAP_VERSION != "3") {
+    closestVec.insert(closestVec.end(), mStaticDeadMap.begin(), mStaticDeadMap.end());
+  }
+
+  // vector encoding: if 1<<15 = 0x8000 is set, the word encodes the first element of a range, with mask (1<<15)-1 = 0x7FFF. The last element of the range is the next in the vector.
+
+  for (int iel = 0; iel < closestVec.size(); iel++) {
+    uint16_t w = closestVec.at(iel);
+    noisemap.maskFullChip(w & 0x7FFF);
+    if (w & 0x8000) {
+      for (int w2 = (w & 0x7FFF) + 1; w2 < closestVec.at(iel + 1); w2++) {
+        noisemap.maskFullChip(w2);
+      }
+    }
+  }
+}
+
+std::vector<unsigned long> TimeDeadMap::getEvolvingMapKeys() const
+{
+  std::vector<unsigned long> keys;
+  std::transform(mEvolvingDeadMap.begin(), mEvolvingDeadMap.end(), std::back_inserter(keys),
+                 [](const auto& O) { return O.first; });
+  return keys;
+}
+
+long TimeDeadMap::getMapAtOrbit(unsigned long orbit, std::vector<uint16_t>& mmap) const
+{ // fills mmap and returns requested_orbit - found_orbit. Found orbit is the highest key lower or equal to the requested one
+  if (mEvolvingDeadMap.empty()) {
+    LOG(warning) << "Requested orbit " << orbit << "from an empty time-dependent map. Doing nothing";
+    return (long)orbit;
+  }
+  auto closest = mEvolvingDeadMap.upper_bound(orbit);
+  if (closest != mEvolvingDeadMap.begin()) {
+    --closest;
+    mmap = closest->second;
+    return (long)orbit - closest->first;
+  } else {
+    mmap = mEvolvingDeadMap.begin()->second;
+    return (long)(orbit)-mEvolvingDeadMap.begin()->first;
+  }
+}

From a096a62bb2c719f93ab6be6600d48e015ffc0f4d Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <weiglhofer@fias.uni-frankfurt.de>
Date: Fri, 20 Jun 2025 16:28:14 +0200
Subject: [PATCH 0537/1764] GPU/TPCClusterFinder: Fix out-of-bounds write.

---
 .../TPCClusterFinder/GPUTPCCFStreamCompaction.cxx            | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
index d43e96b19c5d0..0f2fd235dc0d0 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.cxx
@@ -55,8 +55,9 @@ GPUdii() void GPUTPCCFStreamCompaction::Thread<GPUTPCCFStreamCompaction::scanUp>
   int32_t iThreadGlobal = get_global_id(0);
   int32_t offsetInBlock = work_group_scan_inclusive_add((iThreadGlobal < nElems) ? scanOffset[iThreadGlobal] : 0);
 
-  // TODO: This write isn't needed??
-  scanOffset[iThreadGlobal] = offsetInBlock;
+  if (iThreadGlobal < nElems) {
+    scanOffset[iThreadGlobal] = offsetInBlock;
+  }
 
   int32_t lastThread = nThreads - 1;
   if (iThread == lastThread) {

From 53b81b8262ec8c1d428fe66d5180a488d7c50013 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Wed, 25 Jun 2025 22:23:23 +0200
Subject: [PATCH 0538/1764] Fix for cluster flags

---
 .../TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx           | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 58dd49630d8e6..bc8d26954b5dc 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -127,6 +127,8 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   if (clustererNN.mNnClusterizerAddIndexData && (int32_t)transient_index == (clustererNN.mNnClusterizerElementSize - 1)) {
     uint32_t top_idx = (base_idx + 1) * clustererNN.mNnClusterizerElementSize;
     if (!clustererNN.mNnClusterizerSetDeconvolutionFlags) { // Only if deconvolution flags are not set
+      clustererNN.mClusterFlags[2 * base_idx] = 0;
+      clustererNN.mClusterFlags[2 * base_idx + 1] = 0;
       for (uint16_t i = 0; i < 8; i++) {                    // This solution needs testing. It is not the same as the deconvolution flags
         Delta2 d = cfconsts::InnerNeighbors[i];
         CfChargePos tmp_pos = peak.delta(d);
@@ -470,6 +472,8 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfChargePos peak = clusterer.mPfilteredPeakPositions[idx + batchStart];
 
+  clustererNN.mClusterFlags[2 * idx] = 0;
+  clustererNN.mClusterFlags[2 * idx + 1] = 0;
   for (int i = 0; i < 8; i++) {
     Delta2 d = cfconsts::InnerNeighbors[i];
     CfChargePos tmp_pos = peak.delta(d);

From 312ae1311c7629d37f972bbcf3deaa95ab7f16ed Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Wed, 25 Jun 2025 22:32:07 +0200
Subject: [PATCH 0539/1764] Cleanup + handling of deconvolution

---
 .../Global/GPUChainTrackingClusterizer.cxx    | 53 +++----------------
 1 file changed, 6 insertions(+), 47 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 816ee43d50b15..b85505ccf5fda 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -977,20 +977,10 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[lane] : clustererNN;
           GPUTPCNNClusterizerHost& nnApplication = nnApplications[lane];
 
-          // // bool recreateMemoryAllocator = false;
-          // if (lane == 0) {
-          //   (nnApplications[lane].mModelClass).initEnvironment();
-          //   nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, 0);
-          // }
-          // // recreateMemoryAllocator = true;
-          // (nnApplications[lane].mModelClass).initSession();
-          // (nnApplications[lane].mModelReg1).initSession();
-
           int withMC = (doGPU && propagateMCLabels);
 
-          if (clustererNNShadow.mNnClusterizerUseCfRegression || (int)(nn_settings.nnClusterizerApplyCfDeconvolution)) {
+          if (nn_settings.nnClusterizerApplyCfDeconvolution) {
             runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, true);
-            DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
           } else if (clustererNNShadow.mNnClusterizerSetDeconvolutionFlags) {
             runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, false);
           }
@@ -1007,9 +997,6 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
               runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, batchStart); // Filling the regression data
             }
 
-            // auto stop0 = std::chrono::high_resolution_clock::now();
-            // auto start1 = std::chrono::high_resolution_clock::now();
-
             // NN evaluations
             if (clustererNNShadow.mNnInferenceInputDType == 0) {
               if (clustererNNShadow.mNnInferenceOutputDType == 0) {
@@ -1055,8 +1042,6 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
               }
             }
 
-            // auto stopNNs = std::chrono::high_resolution_clock::now();
-
             // Publishing kernels
             if (nnApplication.mModelClass.getNumOutputNodes()[0][1] == 1) {
               runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Assigning class labels
@@ -1069,41 +1054,15 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                 runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Publishing class 2 regression results
               }
             }
-
-            // for(int i = 0; i < iSize; ++i) {
-            //   if(clustererNNShadow.mOutputDataClass[i + batchStart] > 1) {
-            //     LOG(info) << "WARNING ORT: Output of  " << i + batchStart << " / " << clusterer.mPmemory->counters.nClusters << " is " << clustererNNShadow.mModelProbabilities_16[i].ToFloat() << " and " << clustererNNShadow.mOutputDataClass[i + batchStart] << " thresh " << clustererNNShadow.mNnClassThreshold << " instead of 0 or 1. Please check the model and the input data.";
-            //     // std::string input = "[";
-            //     // for(int j = 0; j < clustererNNShadow.mNnClusterizerElementSize; j++){
-            //     //   input += std::to_string(clustererNNShadow.mInputData_16[i * clustererNNShadow.mNnClusterizerElementSize + j].ToFloat()) + ", ";
-            //     // }
-            //     // input += "]";
-            //     // LOG(info) << "Input is: " << input;
-            //   }
-            // }
-
-            // auto stop1 = std::chrono::high_resolution_clock::now();
-
-            // time_networks += std::chrono::duration_cast<std::chrono::nanoseconds>(stopNNs - start1).count() / 1e9;
-            // time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
-            // time_fill += std::chrono::duration_cast<std::chrono::nanoseconds>(stop0 - start0).count() / 1e9;
           }
+
           if (clustererNNShadow.mNnClusterizerUseCfRegression) {
-            // auto start1 = std::chrono::high_resolution_clock::now();
+            if(!nn_settings.nnClusterizerApplyCfDeconvolution) {
+              runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, true);
+            }
+            DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
             runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
-            // auto stop1 = std::chrono::high_resolution_clock::now();
-            // time_clusterizer += std::chrono::duration_cast<std::chrono::nanoseconds>(stop1 - start1).count() / 1e9;
           }
-          // if (clustererNNShadow.mNnClusterizerVerbosity < 3) {
-          //   int acceptedClusters = 0;
-          //   for (size_t i = 0; i < clusterer.mPmemory->counters.nClusters; ++i) {
-          //     if(clustererNNShadow.mOutputDataClass[i] > 1 || clustererNNShadow.mOutputDataClass[i] < 0) {
-          //       LOG(info) << "WARNING ORT 2: " << clustererNNShadow.mOutputDataClass[i] << " for index " << i << " / " << clusterer.mPmemory->counters.nClusters;
-          //     }
-          //     acceptedClusters += clustererNNShadow.mOutputDataClass[i];
-          //   }
-          //   LOG(info) << "[NN CF] Apply NN (fragment " << fragment.index << ", lane: " << lane << ", sector: " << iSector << "): filling data " << time_fill << "s ; networks: " << time_networks << "s ; clusterizer: " << time_clusterizer << "s ; " << clusterer.mPmemory->counters.nClusters << " clusters, " << acceptedClusters << " accepted. --> " << (int32_t)clusterer.mPmemory->counters.nClusters / (time_fill + time_clusterizer) << " clusters/s";
-          // }
 #else
           GPUFatal("Project not compiled with neural network clusterization. Aborting.");
 #endif

From eb292d802118b31a7afbe0670565da4f558efd5e Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Wed, 25 Jun 2025 22:33:58 +0200
Subject: [PATCH 0540/1764] Using only propagateMcLabels

---
 .../Global/GPUChainTrackingClusterizer.cxx       | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index b85505ccf5fda..dd4cd6ef0be96 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -977,7 +977,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[lane] : clustererNN;
           GPUTPCNNClusterizerHost& nnApplication = nnApplications[lane];
 
-          int withMC = (doGPU && propagateMCLabels);
+          // int withMC = (doGPU && propagateMCLabels);
 
           if (nn_settings.nnClusterizerApplyCfDeconvolution) {
             runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, true);
@@ -991,10 +991,10 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             size_t iSize = CAMath::Min((uint)clustererNNShadow.mNnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
 
             // auto start0 = std::chrono::high_resolution_clock::now();
-            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNSingleElement>({GetGrid(iSize * clustererNNShadow.mNnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, batchStart); // Filling the data
+            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNSingleElement>({GetGrid(iSize * clustererNNShadow.mNnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart); // Filling the data
 
             if (clustererNNShadow.mNnClusterizerSetDeconvolutionFlags) {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, batchStart); // Filling the regression data
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart); // Filling the regression data
             }
 
             // NN evaluations
@@ -1044,14 +1044,14 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
             // Publishing kernels
             if (nnApplication.mModelClass.getNumOutputNodes()[0][1] == 1) {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Assigning class labels
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, propagateMCLabels, batchStart); // Assigning class labels
             } else {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass2Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Assigning class labels
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass2Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, propagateMCLabels, batchStart); // Assigning class labels
             }
             if (!clustererNNShadow.mNnClusterizerUseCfRegression) {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass1Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Publishing class 1 regression results
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass1Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, propagateMCLabels, batchStart); // Publishing class 1 regression results
               if (nnApplication.mModelClass.getNumOutputNodes()[0][1] > 1 && nnApplication.mModelReg2.isInitialized()) {
-                runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, withMC, batchStart); // Publishing class 2 regression results
+                runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, propagateMCLabels, batchStart); // Publishing class 2 regression results
               }
             }
           }
@@ -1061,7 +1061,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
               runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, true);
             }
             DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
-            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, withMC, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
+            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
           }
 #else
           GPUFatal("Project not compiled with neural network clusterization. Aborting.");

From d8dbc60590cb60cbe3398b20da6bb714bf28c4a4 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 23 Jun 2025 10:12:48 +0200
Subject: [PATCH 0541/1764] ITS: cleanup unused GPU code

---
 .../ITS/tracking/include/ITStracking/Cell.h   |  16 --
 .../tracking/include/ITStracking/Constants.h  |   5 -
 .../ITS/tracking/include/ITStracking/Road.h   |   7 +-
 GPU/GPUTracking/Base/GPUConstantMem.h         |   2 -
 GPU/GPUTracking/CMakeLists.txt                |   4 -
 .../Definitions/GPUDefParametersConstants.h   |   1 -
 .../Definitions/GPUDefParametersDefaults.h    |   3 -
 GPU/GPUTracking/Global/GPUChainITS.cxx        |  17 +-
 GPU/GPUTracking/Global/GPUChainITS.h          |  13 +-
 GPU/GPUTracking/ITS/GPUITSFitter.cxx          |  64 ------
 GPU/GPUTracking/ITS/GPUITSFitter.h            | 102 ---------
 GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx   | 201 ------------------
 GPU/GPUTracking/ITS/GPUITSFitterKernels.h     |  42 ----
 GPU/GPUTracking/ITS/GPUITSTrack.h             |  32 ---
 .../Standalone/Benchmark/standalone.cxx       |   4 +-
 GPU/GPUTracking/kernels.cmake                 |   1 -
 16 files changed, 12 insertions(+), 502 deletions(-)
 delete mode 100644 GPU/GPUTracking/ITS/GPUITSFitter.cxx
 delete mode 100644 GPU/GPUTracking/ITS/GPUITSFitter.h
 delete mode 100644 GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
 delete mode 100644 GPU/GPUTracking/ITS/GPUITSFitterKernels.h
 delete mode 100644 GPU/GPUTracking/ITS/GPUITSTrack.h

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index fc3656aef800c..d81ba4426ca55 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -29,22 +29,6 @@ namespace o2::its
 class Cell final
 {
  public:
-  GPUhdDefault() Cell() = default;
-  GPUhd() Cell(const int firstClusterIndex, const int secondClusterIndex, const int thirdClusterIndex,
-               const int firstTrackletIndex, const int secondTrackletIndex)
-    : mFirstClusterIndex(firstClusterIndex),
-      mSecondClusterIndex(secondClusterIndex),
-      mThirdClusterIndex(thirdClusterIndex),
-      mFirstTrackletIndex(firstTrackletIndex),
-      mSecondTrackletIndex(secondTrackletIndex),
-      mLevel(1) {}
-  GPUhdDefault() Cell(const Cell&) = default;
-  GPUhdDefault() Cell(Cell&&) = default;
-  GPUhdDefault() ~Cell() = default;
-
-  GPUhdDefault() Cell& operator=(const Cell&) = default;
-  GPUhdDefault() Cell& operator=(Cell&&) noexcept = default;
-
   GPUhd() int getFirstClusterIndex() const { return mFirstClusterIndex; };
   GPUhd() int getSecondClusterIndex() const { return mSecondClusterIndex; };
   GPUhd() int getThirdClusterIndex() const { return mThirdClusterIndex; };
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index 48cc45e44cf1c..ab9d0c2e4d1a6 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -31,11 +31,6 @@ constexpr int UnusedIndex{-1};
 constexpr float Resolution{0.0005f};
 constexpr float Radl = 9.36f; // Radiation length of Si [cm]
 constexpr float Rho = 2.33f;  // Density of Si [g/cm^3]
-namespace its                 // to be removed
-{
-constexpr int UnusedIndex{-1};
-constexpr float Resolution{0.0005f};
-} // namespace its
 } // namespace o2::its::constants
 
 #endif /* TRACKINGITSU_INCLUDE_CONSTANTS_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
index e9cd306e63bc5..75f187f31652b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
@@ -45,14 +45,14 @@ class Road final
   GPUhd() void resetRoad()
   {
     for (int i = 0; i < maxRoadSize; i++) {
-      mCellIds[i] = constants::its::UnusedIndex;
+      mCellIds[i] = constants::UnusedIndex;
     }
     mRoadSize = 0;
   }
 
   GPUhd() void addCell(int cellLayer, int cellId)
   {
-    if (mCellIds[cellLayer] == constants::its::UnusedIndex) {
+    if (mCellIds[cellLayer] == constants::UnusedIndex) {
       ++mRoadSize;
     }
 
@@ -60,8 +60,7 @@ class Road final
   }
 
  private:
-  int mCellIds[maxRoadSize]{constants::its::UnusedIndex};
-  // int mLabel;
+  int mCellIds[maxRoadSize]{constants::UnusedIndex};
   unsigned char mRoadSize{0};
   bool mIsFakeRoad{false};
 };
diff --git a/GPU/GPUTracking/Base/GPUConstantMem.h b/GPU/GPUTracking/Base/GPUConstantMem.h
index 532c270431d99..ffb17997b9190 100644
--- a/GPU/GPUTracking/Base/GPUConstantMem.h
+++ b/GPU/GPUTracking/Base/GPUConstantMem.h
@@ -26,7 +26,6 @@
 #include "GPUTPCConvert.h"
 #include "GPUTPCCompression.h"
 #include "GPUTPCDecompression.h"
-#include "GPUITSFitter.h"
 #include "GPUTPCClusterFinder.h"
 #include "GPUTrackingRefit.h"
 
@@ -50,7 +49,6 @@ struct GPUConstantMem {
   GPUTRDTrackerGPU trdTrackerGPU;
   GPUTRDTracker trdTrackerO2;
   GPUTPCClusterFinder tpcClusterer[GPUCA_NSECTORS];
-  GPUITSFitter itsFitter;
   GPUTrackingRefitProcessor trackingRefit;
   GPUTrackingInOutPointers ioPtrs;
   GPUCalibObjectsConst calibObjects;
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 0560ea2dd12d2..a7159549322a0 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -173,8 +173,6 @@ set(SRCS_NO_CINT ${SRCS_NO_CINT} display/GPUDisplayInterface.cxx)
 
 set(SRCS_NO_CINT ${SRCS_NO_CINT}
     Global/GPUChainITS.cxx
-    ITS/GPUITSFitter.cxx
-    ITS/GPUITSFitterKernels.cxx
     dEdx/GPUdEdx.cxx
     TPCConvert/GPUTPCConvert.cxx
     TPCConvert/GPUTPCConvertKernel.cxx
@@ -220,7 +218,6 @@ set(SRCS_NO_H ${SRCS_NO_H}
     TPCClusterFinder/GPUTPCClusterFinderDump.cxx)
 
 set(HDRS_INSTALL ${HDRS_INSTALL}
-                  ITS/GPUITSTrack.h
                   TPCClusterFinder/CfArray2D.h
                   TPCClusterFinder/CfConsts.h
                   TPCClusterFinder/CfFragment.h
@@ -298,7 +295,6 @@ set(INCDIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/SectorTracker
     ${CMAKE_CURRENT_SOURCE_DIR}/TPCConvert
     ${CMAKE_CURRENT_SOURCE_DIR}/dEdx
-    ${CMAKE_CURRENT_SOURCE_DIR}/ITS
     ${CMAKE_CURRENT_SOURCE_DIR}/TRDTracking
     ${CMAKE_CURRENT_SOURCE_DIR}/qa
     ${CMAKE_CURRENT_SOURCE_DIR}/Global
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
index 78036e47fc49d..747ee84a906a6 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
@@ -32,7 +32,6 @@
 // Default maximum numbers
 #define GPUCA_MAX_CLUSTERS           ((size_t)     1024 * 1024 * 1024) // Maximum number of TPC clusters
 #define GPUCA_MAX_TRD_TRACKLETS      ((size_t)             128 * 1024) // Maximum number of TRD tracklets
-#define GPUCA_MAX_ITS_FIT_TRACKS     ((size_t)              96 * 1024) // Max number of tracks for ITS track fit
 #define GPUCA_MEMORY_SIZE            ((size_t) 6 * 1024 * 1024 * 1024) // Size of memory allocated on Device
 #define GPUCA_HOST_MEMORY_SIZE       ((size_t) 1 * 1024 * 1024 * 1024) // Size of memory allocated on Host
 #define GPUCA_GPU_STACK_SIZE         ((size_t)               8 * 1024) // Stack size per GPU thread
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 8fe8e8ca68e44..0591ac8c58630 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -438,9 +438,6 @@
   #ifndef GPUCA_LB_GPUTPCGMO2Output_output
     #define GPUCA_LB_GPUTPCGMO2Output_output 256
   #endif
-  #ifndef GPUCA_LB_GPUITSFitterKernels
-    #define GPUCA_LB_GPUITSFitterKernels 256
-  #endif
   #ifndef GPUCA_LB_GPUTPCStartHitsFinder
     #define GPUCA_LB_GPUTPCStartHitsFinder 256
   #endif
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index cbc19100fe4fa..18fb5ff1de939 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -44,22 +44,7 @@ GPUChainITS::~GPUChainITS()
   mITSVertexerTraits.reset();
 }
 
-GPUChainITS::GPUChainITS(GPUReconstruction* rec, uint32_t maxTracks) : GPUChain(rec), mMaxTracks(maxTracks) {}
-
-void GPUChainITS::RegisterPermanentMemoryAndProcessors() { mRec->RegisterGPUProcessor(&processors()->itsFitter, GetRecoStepsGPU() & RecoStep::ITSTracking); }
-
-void GPUChainITS::RegisterGPUProcessors()
-{
-  if (GetRecoStepsGPU() & RecoStep::ITSTracking) {
-    mRec->RegisterGPUDeviceProcessor(&processorsShadow()->itsFitter, &processors()->itsFitter);
-  }
-}
-
-void GPUChainITS::MemorySize(size_t& gpuMem, size_t& pageLockedHostMem)
-{
-  gpuMem = mMaxTracks * sizeof(GPUITSTrack) + GPUCA_MEMALIGN;
-  pageLockedHostMem = gpuMem;
-}
+GPUChainITS::GPUChainITS(GPUReconstruction* rec) : GPUChain(rec) {}
 
 int32_t GPUChainITS::Init() { return 0; }
 
diff --git a/GPU/GPUTracking/Global/GPUChainITS.h b/GPU/GPUTracking/Global/GPUChainITS.h
index 150d66031d084..6821f63845b95 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.h
+++ b/GPU/GPUTracking/Global/GPUChainITS.h
@@ -29,32 +29,31 @@ class GPUFrameworkExternalAllocator;
 
 namespace o2::gpu
 {
-class GPUChainITS : public GPUChain
+class GPUChainITS final : public GPUChain
 {
   friend class GPUReconstruction;
 
  public:
   ~GPUChainITS() override;
-  void RegisterPermanentMemoryAndProcessors() override;
-  void RegisterGPUProcessors() override;
   int32_t Init() override;
   int32_t PrepareEvent() override;
   int32_t Finalize() override;
   int32_t RunChain() override;
-  void MemorySize(size_t& gpuMem, size_t& pageLockedHostMem) override;
+
+  void RegisterPermanentMemoryAndProcessors() final {};
+  void RegisterGPUProcessors() final {};
+  void MemorySize(size_t&, size_t&) final {};
 
   o2::its::TrackerTraits<7>* GetITSTrackerTraits();
   o2::its::VertexerTraits* GetITSVertexerTraits();
   o2::its::TimeFrame<7>* GetITSTimeframe();
 
  protected:
-  GPUChainITS(GPUReconstruction* rec, uint32_t maxTracks = GPUCA_MAX_ITS_FIT_TRACKS);
+  GPUChainITS(GPUReconstruction* rec);
   std::unique_ptr<o2::its::TrackerTraits<7>> mITSTrackerTraits;
   std::unique_ptr<o2::its::VertexerTraits> mITSVertexerTraits;
   std::unique_ptr<o2::its::TimeFrame<7>> mITSTimeFrame;
   std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkAllocator;
-
-  uint32_t mMaxTracks;
 };
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/ITS/GPUITSFitter.cxx b/GPU/GPUTracking/ITS/GPUITSFitter.cxx
deleted file mode 100644
index a954d430f7ac3..0000000000000
--- a/GPU/GPUTracking/ITS/GPUITSFitter.cxx
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUITSFitter.cxx
-/// \author David Rohr, Maximiliano Puccio
-
-#include "GPUITSFitter.h"
-
-#include "ITStracking/Road.h"
-#include "ITStracking/Cluster.h"
-#include "GPUITSTrack.h"
-#include "GPUReconstruction.h"
-
-using namespace o2::gpu;
-
-#ifndef GPUCA_GPUCODE
-void GPUITSFitter::InitializeProcessor()
-{
-}
-
-void* GPUITSFitter::SetPointersInput(void* mem)
-{
-  computePointerWithAlignment(mem, mRoads, mNumberOfRoads);
-  for (int32_t i = 0; i < 7; i++) {
-    computePointerWithAlignment(mem, mTF[i], mNTF[i]);
-  }
-  return mem;
-}
-
-void* GPUITSFitter::SetPointersTracks(void* mem)
-{
-  computePointerWithAlignment(mem, mTracks, mNMaxTracks);
-  return mem;
-}
-
-void* GPUITSFitter::SetPointersMemory(void* mem)
-{
-  computePointerWithAlignment(mem, mMemory, 1);
-  return mem;
-}
-
-void GPUITSFitter::RegisterMemoryAllocation()
-{
-  AllocateAndInitializeLate();
-  mMemoryResInput = mRec->RegisterMemoryAllocation(this, &GPUITSFitter::SetPointersInput, GPUMemoryResource::MEMORY_INPUT, "ITSInput");
-  mMemoryResTracks = mRec->RegisterMemoryAllocation(this, &GPUITSFitter::SetPointersTracks, GPUMemoryResource::MEMORY_OUTPUT, "ITSTracks");
-  mMemoryResMemory = mRec->RegisterMemoryAllocation(this, &GPUITSFitter::SetPointersMemory, GPUMemoryResource::MEMORY_PERMANENT, "ITSMemory");
-}
-
-void GPUITSFitter::SetMaxData(const GPUTrackingInOutPointers& io) { mNMaxTracks = mNumberOfRoads; }
-#endif
-
-void GPUITSFitter::clearMemory()
-{
-  new (mMemory) Memory;
-}
diff --git a/GPU/GPUTracking/ITS/GPUITSFitter.h b/GPU/GPUTracking/ITS/GPUITSFitter.h
deleted file mode 100644
index 9c0995a80749f..0000000000000
--- a/GPU/GPUTracking/ITS/GPUITSFitter.h
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUITSFitter.h
-/// \author David Rohr, Maximiliano Puccio
-
-#ifndef GPUITSFITTER_H
-#define GPUITSFITTER_H
-
-#include "GPUProcessor.h"
-#include "GPUITSTrack.h"
-
-namespace o2::its
-{
-template <uint8_t N>
-class Road;
-struct TrackingFrameInfo;
-struct Cluster;
-class Cell;
-} // namespace o2::its
-
-namespace o2::gpu
-{
-class GPUITSTrack;
-
-class GPUITSFitter : public GPUProcessor
-{
- public:
-#ifndef GPUCA_GPUCODE
-  void InitializeProcessor();
-  void RegisterMemoryAllocation();
-  void SetMaxData(const GPUTrackingInOutPointers& io);
-
-  void* SetPointersInput(void* mem);
-  void* SetPointersTracks(void* mem);
-  void* SetPointersMemory(void* mem);
-#endif
-
-  GPUd() o2::its::Road<5>* roads()
-  {
-    return mRoads;
-  }
-  GPUd() void SetNumberOfRoads(int32_t v) { mNumberOfRoads = v; }
-  GPUd() int32_t NumberOfRoads() { return mNumberOfRoads; }
-  GPUd() GPUITSTrack* tracks()
-  {
-    return mTracks;
-  }
-  GPUd() GPUAtomic(uint32_t) & NumberOfTracks()
-  {
-    return mMemory->mNumberOfTracks;
-  }
-  GPUd() void SetNumberOfLayers(int32_t i) { mNumberOfLayers = i; }
-  GPUd() int32_t NumberOfLayers() { return mNumberOfLayers; }
-  GPUd() void SetNumberTF(int32_t i, int32_t v) { mNTF[i] = v; }
-  GPUd() o2::its::TrackingFrameInfo** trackingFrame()
-  {
-    return mTF;
-  }
-  GPUd() const o2::its::Cluster** clusters()
-  {
-    return mClusterPtrs;
-  }
-  GPUd() const o2::its::Cell** cells()
-  {
-    return mCellPtrs;
-  }
-
-  void clearMemory();
-
-  struct Memory {
-    GPUAtomic(uint32_t) mNumberOfTracks = 0;
-  };
-
- protected:
-  int32_t mNumberOfLayers;
-  int32_t mNumberOfRoads = 0;
-  int32_t mNMaxTracks = 0;
-  int32_t* mNTF = nullptr;
-  Memory* mMemory = nullptr;
-  o2::its::Road<5>* mRoads = nullptr;
-  o2::its::TrackingFrameInfo** mTF = {nullptr};
-  GPUITSTrack* mTracks = nullptr;
-
-  const o2::its::Cluster** mClusterPtrs;
-  const o2::its::Cell** mCellPtrs;
-
-  int16_t mMemoryResInput = -1;
-  int16_t mMemoryResTracks = -1;
-  int16_t mMemoryResMemory = -1;
-};
-} // namespace o2::gpu
-
-#endif
diff --git a/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx b/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
deleted file mode 100644
index 798efb7d7964e..0000000000000
--- a/GPU/GPUTracking/ITS/GPUITSFitterKernels.cxx
+++ /dev/null
@@ -1,201 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUITSFitterKernels.cxx
-/// \author David Rohr, Maximiliano Puccio
-
-#include "GPUITSFitterKernels.h"
-#include "GPUConstantMem.h"
-
-#include "ITStracking/Constants.h"
-#include "ITStracking/MathUtils.h"
-#include "ITStracking/Road.h"
-#include "ITStracking/Cluster.h"
-#include "ITStracking/Cell.h"
-#include "CommonConstants/MathConstants.h"
-
-#if defined(CA_DEBUG) && !defined(GPUCA_GPUCODE_DEVICE)
-#include <cstdio>
-#endif
-
-using namespace o2::gpu;
-using namespace o2;
-using namespace o2::its;
-
-GPUdii() bool GPUITSFitterKernels::fitTrack(GPUITSFitter& GPUrestrict() Fitter, GPUTPCGMPropagator& GPUrestrict() prop, GPUITSTrack& GPUrestrict() track, int32_t start, int32_t end, int32_t step)
-{
-  for (int32_t iLayer{start}; iLayer != end; iLayer += step) {
-    if (track.mClusters[iLayer] == o2::its::constants::its::UnusedIndex) {
-      continue;
-    }
-    const TrackingFrameInfo& GPUrestrict() trackingHit = Fitter.trackingFrame()[iLayer][track.mClusters[iLayer]];
-
-    if (prop.PropagateToXAlpha(trackingHit.xTrackingFrame, trackingHit.alphaTrackingFrame, step > 0)) {
-      return false;
-    }
-
-    if (prop.Update(trackingHit.positionTrackingFrame[0], trackingHit.positionTrackingFrame[1], 0, false, trackingHit.covarianceTrackingFrame[0], trackingHit.covarianceTrackingFrame[2])) {
-      return false;
-    }
-
-    /*const float xx0 = (iLayer > 2) ? 0.008f : 0.003f; // Rough layer thickness //FIXME
-                constexpr float radiationLength = 9.36f;          // Radiation length of Si [cm]
-                constexpr float density = 2.33f;                  // Density of Si [g/cm^3]
-                if (!track.correctForMaterial(xx0, xx0 * radiationLength * density, true))
-                  return false;*/
-  }
-  return true;
-}
-
-template <>
-GPUdii() void GPUITSFitterKernels::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() processors)
-{
-  GPUITSFitter& Fitter = processors.itsFitter;
-
-  GPUTPCGMPropagator prop;
-  prop.SetPolynomialField(&processors.param.polynomialField);
-  prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
-  prop.SetFitInProjections(1);
-  float bz = -5.f; // FIXME
-
-#ifdef CA_DEBUG
-  int32_t roadCounters[4]{0, 0, 0, 0};
-  int32_t fitCounters[4]{0, 0, 0, 0};
-  int32_t backpropagatedCounters[4]{0, 0, 0, 0};
-  int32_t refitCounters[4]{0, 0, 0, 0};
-#endif
-  for (int32_t iRoad = get_global_id(0); iRoad < Fitter.NumberOfRoads(); iRoad += get_global_size(0)) {
-    Road<5>& road = Fitter.roads()[iRoad];
-    int32_t clusters[7] = {o2::its::constants::its::UnusedIndex, o2::its::constants::its::UnusedIndex, o2::its::constants::its::UnusedIndex, o2::its::constants::its::UnusedIndex, o2::its::constants::its::UnusedIndex, o2::its::constants::its::UnusedIndex, o2::its::constants::its::UnusedIndex};
-    int32_t lastCellLevel = o2::its::constants::its::UnusedIndex;
-    CA_DEBUGGER(int32_t nClusters = 2);
-
-    for (int32_t iCell{0}; iCell < Fitter.NumberOfLayers() - 2; ++iCell) {
-      const int32_t cellIndex = road[iCell];
-      if (cellIndex == o2::its::constants::its::UnusedIndex) {
-        continue;
-      } else {
-        clusters[iCell] = Fitter.cells()[iCell][cellIndex].getFirstClusterIndex();
-        clusters[iCell + 1] = Fitter.cells()[iCell][cellIndex].getSecondClusterIndex();
-        clusters[iCell + 2] = Fitter.cells()[iCell][cellIndex].getThirdClusterIndex();
-        lastCellLevel = iCell;
-        CA_DEBUGGER(nClusters++);
-      }
-    }
-
-    CA_DEBUGGER(roadCounters[nClusters - 4]++);
-
-    if (lastCellLevel == o2::its::constants::its::UnusedIndex) {
-      continue;
-    }
-
-    /// From primary vertex context index to event index (== the one used as input of the tracking code)
-    for (int32_t iC{0}; iC < 7; iC++) {
-      if (clusters[iC] != o2::its::constants::its::UnusedIndex) {
-        clusters[iC] = Fitter.clusters()[iC][clusters[iC]].clusterId;
-      }
-    }
-    /// Track seed preparation. Clusters are numbered progressively from the outermost to the innermost.
-    const auto& cluster1 = Fitter.trackingFrame()[lastCellLevel + 2][clusters[lastCellLevel + 2]];
-    const auto& cluster2 = Fitter.trackingFrame()[lastCellLevel + 1][clusters[lastCellLevel + 1]];
-    const auto& cluster3 = Fitter.trackingFrame()[lastCellLevel][clusters[lastCellLevel]];
-
-    GPUITSTrack temporaryTrack;
-    {
-      const float ca = CAMath::Cos(cluster3.alphaTrackingFrame), sa = CAMath::Sin(cluster3.alphaTrackingFrame);
-      const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
-      const float y1 = -cluster1.xCoordinate * sa + cluster1.yCoordinate * ca;
-      const float z1 = cluster1.zCoordinate;
-      const float x2 = cluster2.xCoordinate * ca + cluster2.yCoordinate * sa;
-      const float y2 = -cluster2.xCoordinate * sa + cluster2.yCoordinate * ca;
-      const float z2 = cluster2.zCoordinate;
-      const float x3 = cluster3.xTrackingFrame;
-      const float y3 = cluster3.positionTrackingFrame[0];
-      const float z3 = cluster3.positionTrackingFrame[1];
-
-      const float crv = o2::its::math_utils::computeCurvature(x1, y1, x2, y2, x3, y3);
-      const float x0 = o2::its::math_utils::computeCurvatureCentreX(x1, y1, x2, y2, x3, y3);
-      const float tgl12 = o2::its::math_utils::computeTanDipAngle(x1, y1, x2, y2, z1, z2);
-      const float tgl23 = o2::its::math_utils::computeTanDipAngle(x2, y2, x3, y3, z2, z3);
-
-      const float r2 = CAMath::Sqrt(cluster2.xCoordinate * cluster2.xCoordinate + cluster2.yCoordinate * cluster2.yCoordinate);
-      const float r3 = CAMath::Sqrt(cluster3.xCoordinate * cluster3.xCoordinate + cluster3.yCoordinate * cluster3.yCoordinate);
-      const float fy = 1.f / (r2 - r3);
-      const float& tz = fy;
-      const float cy = (o2::its::math_utils::computeCurvature(x1, y1, x2, y2 + o2::its::constants::its::Resolution, x3, y3) - crv) / (o2::its::constants::its::Resolution * bz * constants::math::B2C) * 20.f; // FIXME: MS contribution to the cov[14] (*20 added)
-      constexpr float s2 = o2::its::constants::its::Resolution * o2::its::constants::its::Resolution;
-
-      temporaryTrack.X() = cluster3.xTrackingFrame;
-      temporaryTrack.Y() = y3;
-      temporaryTrack.Z() = z3;
-      temporaryTrack.SinPhi() = crv * (x3 - x0);
-      temporaryTrack.DzDs() = 0.5f * (tgl12 + tgl23);
-      temporaryTrack.QPt() = CAMath::Abs(bz) < constants::math::Almost0 ? constants::math::Almost0 : crv / (bz * constants::math::B2C);
-      temporaryTrack.TZOffset() = 0;
-      temporaryTrack.Cov()[0] = s2;
-      temporaryTrack.Cov()[1] = 0.f;
-      temporaryTrack.Cov()[2] = s2;
-      temporaryTrack.Cov()[3] = s2 * fy;
-      temporaryTrack.Cov()[4] = 0.f;
-      temporaryTrack.Cov()[5] = s2 * fy * fy;
-      temporaryTrack.Cov()[6] = 0.f;
-      temporaryTrack.Cov()[7] = s2 * tz;
-      temporaryTrack.Cov()[8] = 0.f;
-      temporaryTrack.Cov()[9] = s2 * tz * tz;
-      temporaryTrack.Cov()[10] = s2 * cy;
-      temporaryTrack.Cov()[11] = 0.f;
-      temporaryTrack.Cov()[12] = s2 * fy * cy;
-      temporaryTrack.Cov()[13] = 0.f;
-      temporaryTrack.Cov()[14] = s2 * cy * cy;
-      temporaryTrack.SetChi2(0);
-      temporaryTrack.SetNDF(-5);
-
-      prop.SetTrack(&temporaryTrack, cluster3.alphaTrackingFrame);
-    }
-
-    for (size_t iC = 0; iC < 7; ++iC) {
-      temporaryTrack.mClusters[iC] = clusters[iC];
-    }
-    bool fitSuccess = fitTrack(Fitter, prop, temporaryTrack, Fitter.NumberOfLayers() - 4, -1, -1);
-    if (!fitSuccess) {
-      continue;
-    }
-    CA_DEBUGGER(fitCounters[nClusters - 4]++);
-    temporaryTrack.ResetCovariance();
-    fitSuccess = fitTrack(Fitter, prop, temporaryTrack, 0, Fitter.NumberOfLayers(), 1);
-    if (!fitSuccess) {
-      continue;
-    }
-    CA_DEBUGGER(backpropagatedCounters[nClusters - 4]++);
-    for (int32_t k = 0; k < 5; k++) {
-      temporaryTrack.mOuterParam.P[k] = temporaryTrack.Par()[k];
-    }
-    for (int32_t k = 0; k < 15; k++) {
-      temporaryTrack.mOuterParam.C[k] = temporaryTrack.Cov()[k];
-    }
-    temporaryTrack.mOuterParam.X = temporaryTrack.X();
-    temporaryTrack.mOuterParam.alpha = prop.GetAlpha();
-    temporaryTrack.ResetCovariance();
-    fitSuccess = fitTrack(Fitter, prop, temporaryTrack, Fitter.NumberOfLayers() - 1, -1, -1);
-    if (!fitSuccess) {
-      continue;
-    }
-    CA_DEBUGGER(refitCounters[nClusters - 4]++);
-    int32_t trackId = CAMath::AtomicAdd(&Fitter.NumberOfTracks(), 1u);
-    Fitter.tracks()[trackId] = temporaryTrack;
-  }
-#ifdef CA_DEBUG
-  GPUInfo("Roads: %i %i %i %i", roadCounters[0], roadCounters[1], roadCounters[2], roadCounters[3]);
-  GPUInfo("Fitted tracks: %i %i %i %i", fitCounters[0], fitCounters[1], fitCounters[2], fitCounters[3]);
-  GPUInfo("Backpropagated tracks: %i %i %i %i", backpropagatedCounters[0], backpropagatedCounters[1], backpropagatedCounters[2], backpropagatedCounters[3]);
-  GPUInfo("Refitted tracks: %i %i %i %i", refitCounters[0], refitCounters[1], refitCounters[2], refitCounters[3]);
-#endif
-}
diff --git a/GPU/GPUTracking/ITS/GPUITSFitterKernels.h b/GPU/GPUTracking/ITS/GPUITSFitterKernels.h
deleted file mode 100644
index 5a2a30de28823..0000000000000
--- a/GPU/GPUTracking/ITS/GPUITSFitterKernels.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUITSFitterKernels.h
-/// \author David Rohr, Maximiliano Puccio
-
-#ifndef GPUITSFITTERKERNELS_H
-#define GPUITSFITTERKERNELS_H
-
-#include "GPUGeneralKernels.h"
-namespace o2::its
-{
-struct TrackingFrameInfo;
-} // namespace o2::its
-
-namespace o2::gpu
-{
-class GPUTPCGMPropagator;
-class GPUITSFitter;
-class GPUITSTrack;
-
-class GPUITSFitterKernels : public GPUKernelTemplate
-{
- public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::ITSTracking; }
-  template <int32_t iKernel = defaultKernel>
-  GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors);
-
- protected:
-  GPUd() static bool fitTrack(GPUITSFitter& Fitter, GPUTPCGMPropagator& prop, GPUITSTrack& track, int32_t start, int32_t end, int32_t step);
-};
-} // namespace o2::gpu
-
-#endif
diff --git a/GPU/GPUTracking/ITS/GPUITSTrack.h b/GPU/GPUTracking/ITS/GPUITSTrack.h
deleted file mode 100644
index 5063985692a43..0000000000000
--- a/GPU/GPUTracking/ITS/GPUITSTrack.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUITSTrack.h
-/// \author David Rohr, Maximiliano Puccio
-
-#ifndef GPUITSTRACK_H
-#define GPUITSTRACK_H
-
-#include "GPUTPCGMMergerTypes.h"
-#include "GPUTPCGMTrackParam.h"
-
-namespace o2::gpu
-{
-class GPUITSTrack : public GPUTPCGMTrackParam
-{
- public:
-  gputpcgmmergertypes::GPUTPCOuterParam mOuterParam;
-  float mAlpha;
-  int32_t mClusters[7];
-};
-} // namespace o2::gpu
-
-#endif
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index ae02f9e9051c4..fed4610b2f13a 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -765,9 +765,9 @@ int32_t main(int argc, char** argv)
     chainTrackingPipeline->SetQAFromForeignChain(chainTracking);
   }
   if (!configStandalone.proc.doublePipeline) {
-    chainITS = rec->AddChain<GPUChainITS>(0);
+    chainITS = rec->AddChain<GPUChainITS>();
     if (configStandalone.testSyncAsync) {
-      chainITSAsync = recAsync->AddChain<GPUChainITS>(0);
+      chainITSAsync = recAsync->AddChain<GPUChainITS>();
     }
   }
 
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 2a59f98a6d5b4..52cda3e8ff416 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -90,7 +90,6 @@ o2_gpu_add_kernel("GPUTPCGMO2Output, output"                              "= TPC
 o2_gpu_add_kernel("GPUTPCGMO2Output, mc"                                  "= TPCMERGER")
 o2_gpu_add_kernel("GPUTRDTrackerKernels, gpuVersion"                      "= TRDTRACKER MATLUT TPCMERGER"                         LB GPUTRDTrackerGPU* externalInstance)
 o2_gpu_add_kernel("GPUTRDTrackerKernels, o2Version"                       "= TRDTRACKER MATLUT O2PROPAGATOR"                      LB GPUTRDTracker* externalInstance)
-o2_gpu_add_kernel("GPUITSFitterKernels"                                   "= TPCMERGER MATLUT"                                    LB)
 o2_gpu_add_kernel("GPUTPCConvertKernel"                                   "="                                                     LB)
 o2_gpu_add_kernel("GPUTPCCompressionKernels, step0attached"               "= TPCCOMPRESSION"                                      LB)
 o2_gpu_add_kernel("GPUTPCCompressionKernels, step1unattached"             "= ERRORS"                                              LB)

From 96dafaa247e464c3f611bd5c306fe6d13fa76c87 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 19 Jun 2025 21:02:18 +0200
Subject: [PATCH 0542/1764] ITS: GPU add missing output to GPUWorkflowSpec

was missed initially. compliments #14425 and should now allow ITS MC to be run standalone on gpu.
thanks @davidrohr!
---
 GPU/Workflow/src/GPUWorkflowSpec.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 6293fce842231..6aa4b753f9300 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -1305,6 +1305,7 @@ Outputs GPURecoWorkflowSpec::outputs()
 
     if (mSpecConfig.processMC) {
       outputSpecs.emplace_back(gDataOriginITS, "VERTICESMCTR", 0, Lifetime::Timeframe);
+      outputSpecs.emplace_back(gDataOriginITS, "VERTICESMCPUR", 0, Lifetime::Timeframe);
       outputSpecs.emplace_back(gDataOriginITS, "TRACKSMCTR", 0, Lifetime::Timeframe);
       outputSpecs.emplace_back(gDataOriginITS, "ITSTrackMC2ROF", 0, Lifetime::Timeframe);
     }

From 38acc6f71a196ebdf8494d7b56c402dcaa299cde Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 26 Jun 2025 13:14:30 +0200
Subject: [PATCH 0543/1764] DPL Analysis: add `DefinesDelayed`

Add `DefinesDelayed` allowing to set the expressions in a process function, e.g. after calculating some required input values
---
 .../Core/include/Framework/AnalysisHelpers.h  | 16 +++++++-
 .../Core/include/Framework/AnalysisManagers.h | 37 +++++++++++++++++++
 .../Core/include/Framework/AnalysisTask.h     |  2 +
 Framework/Core/test/test_Concepts.cxx         | 14 +++++++
 4 files changed, 68 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 95be6c7e407b3..6e9b1e211bb76 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -340,8 +340,9 @@ concept is_spawns = requires(T t) {
 /// The actual expressions have to be set in init() for the configurable expression
 /// columns, used to define the table
 
-template <is_dynamically_spawnable T>
+template <is_dynamically_spawnable T, bool DELAYED = false>
 struct Defines : decltype(transformBase<T>()) {
+  static constexpr bool delayed = DELAYED;
   using spawnable_t = T;
   using metadata = decltype(transformBase<T>())::metadata;
   using extension_t = typename metadata::extension_table_t;
@@ -373,13 +374,26 @@ struct Defines : decltype(transformBase<T>()) {
   std::array<o2::framework::expressions::Projector, N> projectors;
   std::shared_ptr<gandiva::Projector> projector = nullptr;
   std::shared_ptr<arrow::Schema> schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(placeholders_pack_t{}));
+  std::shared_ptr<arrow::Schema> inputSchema = nullptr;
+
+  bool needRecompilation = false;
+
+  void recompile()
+  {
+    projector = framework::expressions::createProjectorHelper(N, projectors.data(), inputSchema, schema->fields());
+  }
 };
 
+template <is_dynamically_spawnable T>
+using DefinesDelayed = Defines<T, true>;
+
 template <typename T>
 concept is_defines = requires(T t) {
   typename T::metadata;
   requires std::same_as<decltype(t.pack()), typename T::placeholders_pack_t>;
   requires std::same_as<decltype(t.projector), std::shared_ptr<gandiva::Projector>>;
+  requires std::same_as<decltype(t.needRecompilation), bool>;
+  &T::recompile;
 };
 
 /// Policy to control index building
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 2a052c0b07218..7717d5cb3a6a2 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -307,6 +307,7 @@ bool prepareOutput(ProcessingContext& context, T& builds)
 
 template <is_defines T>
 bool prepareOutput(ProcessingContext& context, T& defines)
+  requires(T::delayed == false)
 {
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
   auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
@@ -314,6 +315,42 @@ bool prepareOutput(ProcessingContext& context, T& defines)
     using base_table_t = typename T::base_table_t::table_t;
     originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
   }
+  if (defines.inputSchema == nullptr) {
+    defines.inputSchema = originalTable->schema();
+  }
+  using D = o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>;
+
+  defines.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<D>(originalTable,
+                                                                                          o2::aod::label<metadata::extension_table_t::ref>(),
+                                                                                          defines.projectors.data(),
+                                                                                          defines.projector,
+                                                                                          defines.schema));
+  defines.table = std::make_shared<typename T::spawnable_t::table_t>(soa::ArrowHelpers::joinTables({defines.extension->asArrowTable(), originalTable}, std::span{T::spawnable_t::table_t::originalLabels}));
+  return true;
+}
+
+template <typename T>
+bool prepareDelayedOutput(ProcessingContext&, T&)
+{
+  return false;
+}
+
+template <is_defines T>
+  requires(T::delayed == true)
+bool prepareDelayedOutput(ProcessingContext& context, T& defines)
+{
+  if (defines.needRecompilation) {
+    defines.recompile();
+  }
+  using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
+  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
+  if (originalTable->schema()->fields().empty() == true) {
+    using base_table_t = typename T::base_table_t::table_t;
+    originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
+  }
+  if (defines.inputSchema == nullptr) {
+    defines.inputSchema = originalTable->schema();
+  }
   using D = o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>;
 
   defines.extension = std::make_shared<typename T::extension_t>(o2::framework::spawner<D>(originalTable,
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 30b31ea4799f5..892948582b3cc 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -645,6 +645,8 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
           return false;
         },
         *task.get());
+      // prepare delayed outputs
+      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::prepareDelayedOutput(pc, element); }, *task.get());
       // finalize outputs
       homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::finalizeOutput(pc, element); }, *task.get());
     };
diff --git a/Framework/Core/test/test_Concepts.cxx b/Framework/Core/test/test_Concepts.cxx
index 4bf4f977ec3a8..5e2ad6d96b30f 100644
--- a/Framework/Core/test/test_Concepts.cxx
+++ b/Framework/Core/test/test_Concepts.cxx
@@ -32,6 +32,15 @@ struct P {
   PROCESS_SWITCH(P, process1, "", true);
 };
 
+namespace o2::aod
+{
+namespace ct
+{
+DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(Test, test, float, "test");
+}
+DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(TracksMore, TracksIU, "TRKMORE", ct::Test);
+} // namespace o2::aod
+
 TEST_CASE("IdentificationConcepts")
 {
   // ASoA
@@ -122,6 +131,11 @@ TEST_CASE("IdentificationConcepts")
   Builds<o2::aod::Run3MatchedSparse> bld;
   REQUIRE(is_builds<decltype(bld)>);
 
+  Defines<o2::aod::TracksMore> def;
+  DefinesDelayed<o2::aod::TracksMore> ddef;
+  REQUIRE(is_defines<decltype(def)>);
+  REQUIRE(is_defines<decltype(ddef)>);
+
   OutputObj<TH1F> oo{"test"};
   REQUIRE(is_outputobj<decltype(oo)>);
 

From aa1ca7a221450cd6e36825c6f23bb61fb2b869de Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 26 Jun 2025 15:08:35 +0200
Subject: [PATCH 0544/1764] DPL: improve logs for new calibration scheme
 (#14030)

- Report correct timeout for readers.
- Improve message when dropping data which is not going to be processed by
  the CalibrationOnly mode.
---
 Framework/Core/src/DataProcessingDevice.cxx | 11 ++++++++---
 Framework/Core/src/DataRelayer.cxx          | 18 ++++++++++++++++--
 2 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index c303af4858234..ba3fc2cd1bedd 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1400,10 +1400,15 @@ void DataProcessingDevice::Run()
           O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for exitTransitionTimeout.",
                                  deviceContext.exitTransitionTimeout);
           uv_timer_start(deviceContext.gracePeriodTimer, on_transition_requested_expired, deviceContext.exitTransitionTimeout * 1000, 0);
-          if (mProcessingPolicies.termination == TerminationPolicy::QUIT) {
-            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. Waiting for %d seconds before quitting.", (int)deviceContext.exitTransitionTimeout);
+          bool onlyGenerated = hasOnlyGenerated(spec);
+          int timeout = onlyGenerated ? deviceContext.dataProcessingTimeout : deviceContext.exitTransitionTimeout;
+          if (mProcessingPolicies.termination == TerminationPolicy::QUIT && DefaultsHelpers::onlineDeploymentMode() == false) {
+            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. Waiting for %d seconds before quitting.", timeout);
           } else {
-            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. Waiting for %d seconds before switching to READY state.", (int)deviceContext.exitTransitionTimeout);
+            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop",
+                                        "New state requested. Waiting for %d seconds before %{public}s",
+                                        timeout,
+                                        onlyGenerated ? "dropping remaining input and switching to READY state." : "switching to READY state.");
           }
         } else {
           state.transitionHandling = TransitionHandlingState::Expired;
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 6ddfa7597f7f6..dc820fb5232d1 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -8,6 +8,7 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
+#include "Framework/DeviceState.h"
 #include "Framework/RootSerializationSupport.h"
 #include "Framework/DataRelayer.h"
 #include "Framework/DataProcessingStats.h"
@@ -43,6 +44,7 @@
 #include <Monitoring/Metric.h>
 #include <Monitoring/Monitoring.h>
 
+#include <fairlogger/Logger.h>
 #include <fairmq/Channel.h>
 #include <functional>
 #if __has_include(<fairmq/shmem/Message.h>)
@@ -347,9 +349,21 @@ void DataRelayer::setOldestPossibleInput(TimesliceId proposed, ChannelIndex chan
         if (element.size() == 0) {
           auto& state = mContext.get<DeviceState>();
           if (state.transitionHandling != TransitionHandlingState::NoTransition && DefaultsHelpers::onlineDeploymentMode()) {
-            LOGP(warning, "Missing {} (lifetime:{}) while dropping incomplete data in slot {} with timestamp {} < {}.", DataSpecUtils::describe(input), input.lifetime, si, timestamp.value, newOldest.timeslice.value);
+            if (state.allowedProcessing == DeviceState::CalibrationOnly) {
+              O2_SIGNPOST_ID_GENERATE(cid, calibration);
+              O2_SIGNPOST_EVENT_EMIT(calibration, cid, "expected_missing_data", "Expected missing %{public}s (lifetime:%d) while dropping non-calibration data in slot %zu with timestamp %zu < %zu.",
+                                     DataSpecUtils::describe(input).c_str(), (int)input.lifetime, si, timestamp.value, newOldest.timeslice.value);
+            } else {
+              LOGP(info, "Missing {} (lifetime:{}) while dropping incomplete data in slot {} with timestamp {} < {}.", DataSpecUtils::describe(input), input.lifetime, si, timestamp.value, newOldest.timeslice.value);
+            }
           } else {
-            LOGP(error, "Missing {} (lifetime:{}) while dropping incomplete data in slot {} with timestamp {} < {}.", DataSpecUtils::describe(input), input.lifetime, si, timestamp.value, newOldest.timeslice.value);
+            if (state.allowedProcessing == DeviceState::CalibrationOnly) {
+              O2_SIGNPOST_ID_GENERATE(cid, calibration);
+              O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "expected_missing_data", "Not processing in calibration mode: missing %s (lifetime:%d) while dropping incomplete data in slot %zu with timestamp %zu < %zu.",
+                                          DataSpecUtils::describe(input).c_str(), (int)input.lifetime, si, timestamp.value, newOldest.timeslice.value);
+            } else {
+              LOGP(error, "Missing {} (lifetime:{}) while dropping incomplete data in slot {} with timestamp {} < {}.", DataSpecUtils::describe(input), input.lifetime, si, timestamp.value, newOldest.timeslice.value);
+            }
           }
         }
       }

From cc7a23dc59e8e99857850ab740f978fb4553e6ca Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Thu, 26 Jun 2025 12:50:04 +0200
Subject: [PATCH 0545/1764] jobutils: Sanitize return code treatment

hopefully fixing a bug where the return code seems
to have contained additional characters (hidden) which confused
the return code analysis and provides printouts (or bash errors) like:

```
line 336: [: 0
0: integer expression expected
```
---
 Utilities/Tools/jobutils2.sh | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/Utilities/Tools/jobutils2.sh b/Utilities/Tools/jobutils2.sh
index eec71c33ffea5..ba96b97da090b 100644
--- a/Utilities/Tools/jobutils2.sh
+++ b/Utilities/Tools/jobutils2.sh
@@ -328,9 +328,14 @@ EOF
   # ?? should directly exit here?
   wait $PID || QUERY_RC_FROM_LOG="ON"
 
-  # query return code from log (seems to be safer as sometimes the wait issues "PID" not a child of this shell)
-  RC=$(awk '/TASK-EXIT-CODE:/{print $2}' ${logfile})
-  if [ ! "${RC}" ]; then
+  # query return code from log and sanitize (seems to be safer as sometimes the wait issues "PID" not a child of this shell)
+  RC=$(awk '/TASK-EXIT-CODE:/{print $2; exit}' "${logfile}" | tr -d '[:space:]' | tr -d '\r')
+  if [ -z "${RC}" ]; then
+    RC=1
+  fi
+  # check that RC is an integer
+  if ! [[ "$RC" =~ ^[0-9]+$ ]]; then
+    echo "Malformed TASK-EXIT-CODE: '${RC}'"
     RC=1
   fi
   if [ "${RC}" -eq "0" ]; then

From e4108ce9fe092b28bead4cbbf3a0d0c8f69a4081 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Thu, 26 Jun 2025 22:12:08 +0200
Subject: [PATCH 0546/1764] A3: Add sensitive RICH layers to geometry (#14450)

---
 .../ALICE3/RICH/base/src/GeometryTGeo.cxx     |  2 +-
 .../include/RICHSimulation/RICHRing.h         |  2 +
 .../ALICE3/RICH/simulation/src/Detector.cxx   | 57 +++++++++++--------
 .../ALICE3/RICH/simulation/src/RICHRing.cxx   |  2 +-
 4 files changed, 36 insertions(+), 27 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/RICH/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/RICH/base/src/GeometryTGeo.cxx
index ebe6dcfbdc79a..01d242d6c64cd 100644
--- a/Detectors/Upgrades/ALICE3/RICH/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/RICH/base/src/GeometryTGeo.cxx
@@ -21,7 +21,7 @@ std::unique_ptr<o2::rich::GeometryTGeo> GeometryTGeo::sInstance;
 std::string GeometryTGeo::sVolumeName = "RICHV";
 std::string GeometryTGeo::sRingName = "RICHRing";
 std::string GeometryTGeo::sChipName = "RICHChip";
-std::string GeometryTGeo::sSensorName = "RICHSensor";
+std::string GeometryTGeo::sSensorName = "RICHPhotoTile";
 std::string GeometryTGeo::sSensorFWDName = "FWDRICHSensor"; // only one big sensor for now
 std::string GeometryTGeo::sSensorBWDName = "BWDRICHSensor"; // only one big sensor for now
 
diff --git a/Detectors/Upgrades/ALICE3/RICH/simulation/include/RICHSimulation/RICHRing.h b/Detectors/Upgrades/ALICE3/RICH/simulation/include/RICHSimulation/RICHRing.h
index a7892c210e310..296e24cbd8f06 100644
--- a/Detectors/Upgrades/ALICE3/RICH/simulation/include/RICHSimulation/RICHRing.h
+++ b/Detectors/Upgrades/ALICE3/RICH/simulation/include/RICHSimulation/RICHRing.h
@@ -54,6 +54,8 @@ class Ring
 
   auto getDeltaPhiPos() const { return TMath::TwoPi() / mNTiles; }
   void createRing(TGeoVolume* motherVolume);
+  int getPosId() const { return mPosId; }
+  int getNTiles() const { return mNTiles; }
 
  private:
   int mPosId;           // id of the ring
diff --git a/Detectors/Upgrades/ALICE3/RICH/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/RICH/simulation/src/Detector.cxx
index de5c1817a515a..02719d6f93a00 100644
--- a/Detectors/Upgrades/ALICE3/RICH/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/RICH/simulation/src/Detector.cxx
@@ -145,29 +145,29 @@ void Detector::createGeometry()
   vRICH->SetTitle(vstrng);
   auto& richPars = RICHBaseParam::Instance();
 
-  prepareLayout();
+  prepareLayout(); // Preparing the positions of the rings and tiles
 
   for (int iRing{0}; iRing < richPars.nRings; ++iRing) {
     if (!richPars.oddGeom && iRing == (richPars.nRings / 2)) {
       continue;
     }
-    mRings[iRing] = Ring{iRing,
-                         richPars.nTiles,
-                         richPars.rMin,
-                         richPars.rMax,
-                         richPars.radiatorThickness,
-                         (float)mVTile1[iRing],
-                         (float)mVTile2[iRing],
-                         (float)mLAerogelZ[iRing],
-                         richPars.detectorThickness,
-                         (float)mVMirror1[iRing],
-                         (float)mVMirror2[iRing],
-                         richPars.zBaseSize,
-                         (float)mR0Radiator[iRing],
-                         (float)mR0PhotoDet[iRing],
-                         (float)mTRplusG[iRing],
-                         (float)mThetaBi[iRing],
-                         GeometryTGeo::getRICHVolPattern()};
+    mRings[iRing] = o2::rich::Ring{iRing,
+                                   richPars.nTiles,
+                                   richPars.rMin,
+                                   richPars.rMax,
+                                   richPars.radiatorThickness,
+                                   (float)mVTile1[iRing],
+                                   (float)mVTile2[iRing],
+                                   (float)mLAerogelZ[iRing],
+                                   richPars.detectorThickness,
+                                   (float)mVMirror1[iRing],
+                                   (float)mVMirror2[iRing],
+                                   richPars.zBaseSize,
+                                   (float)mR0Radiator[iRing],
+                                   (float)mR0PhotoDet[iRing],
+                                   (float)mTRplusG[iRing],
+                                   (float)mThetaBi[iRing],
+                                   GeometryTGeo::getRICHVolPattern()};
   }
 
   if (richPars.enableFWDRich) {
@@ -182,7 +182,7 @@ void Detector::InitializeO2Detector()
 {
   LOG(info) << "Initialize RICH O2Detector";
   mGeometryTGeo = GeometryTGeo::Instance();
-  // defineSensitiveVolumes();
+  defineSensitiveVolumes();
 }
 
 void Detector::defineSensitiveVolumes()
@@ -194,12 +194,19 @@ void Detector::defineSensitiveVolumes()
   LOGP(info, "Adding RICH Sensitive Volumes");
 
   // The names of the RICH sensitive volumes have the format: Ring(0...mRings.size()-1)
-  for (int j{0}; j < mRings.size(); j++) {
-    volumeName = GeometryTGeo::getRICHSensorPattern() + TString::Itoa(j, 10);
-    LOGP(info, "Trying {}", volumeName.Data());
-    v = geoManager->GetVolume(volumeName.Data());
-    LOGP(info, "Adding RICH Sensitive Volume {}", v->GetName());
-    AddSensitiveVolume(v);
+  for (auto ring : mRings) {
+    for (int j = 0; j < ring.getNTiles(); j++) {
+      volumeName = Form("%s_%d_%d", GeometryTGeo::getRICHSensorPattern(), ring.getPosId(), j);
+      LOGP(info, "Trying {}", volumeName.Data());
+      v = geoManager->GetVolume(volumeName.Data());
+      if (!v) {
+        LOG(error) << "Geometry does not contain volume " << volumeName.Data();
+        geoManager->GetListOfVolumes()->Print();
+        LOG(fatal) << "Could not find volume " << volumeName.Data() << " in the geometry";
+      }
+      LOGP(info, "Adding RICH Sensitive Volume {}", v->GetName());
+      AddSensitiveVolume(v);
+    }
   }
 }
 
diff --git a/Detectors/Upgrades/ALICE3/RICH/simulation/src/RICHRing.cxx b/Detectors/Upgrades/ALICE3/RICH/simulation/src/RICHRing.cxx
index 27890dc0c4c06..1c6c9612795a0 100644
--- a/Detectors/Upgrades/ALICE3/RICH/simulation/src/RICHRing.cxx
+++ b/Detectors/Upgrades/ALICE3/RICH/simulation/src/RICHRing.cxx
@@ -106,7 +106,7 @@ Ring::Ring(int rPosId,
     photoTile->SetVertex(6, photThick / 2, photYmax / 2);
     photoTile->SetVertex(7, photThick / 2, -photYmax / 2);
 
-    TGeoVolume* photoTileVol = new TGeoVolume(Form("photoTile_%d_%d", rPosId, photTileCount), photoTile, medSi);
+    TGeoVolume* photoTileVol = new TGeoVolume(Form("%s_%d_%d", GeometryTGeo::getRICHSensorPattern(), rPosId, photTileCount), photoTile, medSi);
     photoTileVol->SetLineColor(kOrange - 8);
     photoTileVol->SetLineWidth(1);
 

From 8d6b1cc999f4ec7dd49841655c52970ff08e5ae9 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 26 Jun 2025 23:44:09 +0200
Subject: [PATCH 0547/1764] DPL: avoid unintialised member (#14449)

Not actually used in this particular case, however better safe than sorry.
---
 Framework/Core/src/DataRelayer.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index dc820fb5232d1..092e8340a934a 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -692,7 +692,7 @@ DataRelayer::RelayChoice
       }
       index.publishSlot(slot);
       index.markAsDirty(slot, true);
-      return RelayChoice{.type = RelayChoice::Type::WillRelay};
+      return RelayChoice{.type = RelayChoice::Type::WillRelay, .timeslice = timeslice};
   }
   O2_BUILTIN_UNREACHABLE();
 }

From bb740a43b7a42b06e721658399e5fe927fa890a3 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 26 Jun 2025 23:45:52 +0200
Subject: [PATCH 0548/1764] Replace type name hash with a different string hash
 in preparation for string-based expressions (#14398)

---
 Framework/Core/include/Framework/ASoA.h       | 415 +++++++++---------
 .../Core/include/Framework/StringHelpers.h    |  13 +
 .../include/Framework/TypeIdHelpers.h         |   5 +-
 3 files changed, 232 insertions(+), 201 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 592864528244c..0e4c2b82ffa8f 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -34,6 +34,7 @@
 #include <cstring>
 #include <gsl/span> // IWYU pragma: export
 #include <limits>
+#include <ranges>
 
 namespace o2::framework
 {
@@ -694,6 +695,7 @@ struct DynamicColumn {
 template <typename INHERIT>
 struct IndexColumn {
   using inherited_t = INHERIT;
+  static constexpr const uint32_t hash = 0;
 
   static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
 };
@@ -701,6 +703,7 @@ struct IndexColumn {
 template <typename INHERIT>
 struct MarkerColumn {
   using inherited_t = INHERIT;
+  static constexpr const uint32_t hash = 0;
 
   static constexpr const char* const& columnLabel() { return INHERIT::mLabel; }
 };
@@ -1907,7 +1910,7 @@ class Table
 
   static constexpr auto hashes()
   {
-    return []<typename... C>(framework::pack<C...>) { return std::set{{o2::framework::TypeIdHelpers::uniqueId<C>()...}}; }(columns_t{});
+    return []<typename... C>(framework::pack<C...>) { return std::set{{C::hash...}}; }(columns_t{});
   }
 
   Table(std::shared_ptr<arrow::Table> table, uint64_t offset = 0)
@@ -2279,6 +2282,17 @@ O2ORIGIN("TEST");
 O2HASH("TEST/0");
 } // namespace o2::aod
 
+namespace
+{
+template <typename T>
+consteval static std::string_view namespace_prefix()
+{
+  constexpr auto name = o2::framework::type_name<T>();
+  const auto pos = name.rfind(std::string_view{":"});
+  return name.substr(0, pos - 1);
+}
+} // namespace
+
 #define DECLARE_EQUIVALENT_FOR_INDEX(_Base_, _Equiv_)                                                     \
   template <>                                                                                             \
   struct EquivalentIndexNG<o2::aod::Hash<_Base_::ref.desc_hash>, o2::aod::Hash<_Equiv_::ref.desc_hash>> { \
@@ -2294,6 +2308,7 @@ O2HASH("TEST/0");
 #define DECLARE_SOA_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_)                                                                                                                \
   struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                                                                                               \
     static constexpr const char* mLabel = _Label_;                                                                                                                                \
+    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_});                                                                        \
     static_assert(!((*(mLabel + 1) == 'I' && *(mLabel + 2) == 'n' && *(mLabel + 3) == 'd' && *(mLabel + 4) == 'e' && *(mLabel + 5) == 'x')), "Index is not a valid column name"); \
     using base = o2::soa::Column<_Type_, _Name_>;                                                                                                                                 \
     using type = _Type_;                                                                                                                                                          \
@@ -2317,8 +2332,7 @@ O2HASH("TEST/0");
       return _Getter_();                                                                                                                                                          \
     }                                                                                                                                                                             \
   };                                                                                                                                                                              \
-  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(),                                 \
-                                                                                       o2::framework::expressions::selectArrowType<_Type_>() }
+  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, _Name_::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 #define DECLARE_SOA_COLUMN(_Name_, _Getter_, _Type_) \
   DECLARE_SOA_COLUMN_FULL(_Name_, _Getter_, _Type_, "f" #_Name_)
@@ -2330,6 +2344,7 @@ O2HASH("TEST/0");
 #define DECLARE_SOA_BITMAP_COLUMN_FULL(_Name_, _Getter_, _Size_, _Label_)                                                                                                         \
   struct _Name_ : o2::soa::Column<MAKEINT(_Size_), _Name_> {                                                                                                                      \
     static constexpr const char* mLabel = _Label_;                                                                                                                                \
+    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_});                                                                        \
     static_assert(!((*(mLabel + 1) == 'I' && *(mLabel + 2) == 'n' && *(mLabel + 3) == 'd' && *(mLabel + 4) == 'e' && *(mLabel + 5) == 'x')), "Index is not a valid column name"); \
     using base = o2::soa::Column<MAKEINT(_Size_), _Name_>;                                                                                                                        \
     using type = MAKEINT(_Size_);                                                                                                                                                 \
@@ -2352,82 +2367,81 @@ O2HASH("TEST/0");
       return (*mColumnIterator & (static_cast<type>(1) << bit)) >> bit;                                                                                                           \
     }                                                                                                                                                                             \
   };                                                                                                                                                                              \
-  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(),                                 \
-                                                                                       o2::framework::expressions::selectArrowType<MAKEINT(_Size_)>() }
+  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, _Name_::hash, o2::framework::expressions::selectArrowType<MAKEINT(_Size_)>() }
 
 #define DECLARE_SOA_BITMAP_COLUMN(_Name_, _Getter_, _Size_) \
   DECLARE_SOA_BITMAP_COLUMN_FULL(_Name_, _Getter_, _Size_, "f" #_Name_)
 
 /// An 'expression' column. i.e. a column that can be calculated from other
 /// columns with gandiva based on static C++ expression.
-#define DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_, _Expression_)                                                       \
-  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                                                               \
-    static constexpr const char* mLabel = _Label_;                                                                                                \
-    using base = o2::soa::Column<_Type_, _Name_>;                                                                                                 \
-    using type = _Type_;                                                                                                                          \
-    using column_t = _Name_;                                                                                                                      \
-    using spawnable_t = std::true_type;                                                                                                           \
-    _Name_(arrow::ChunkedArray const* column)                                                                                                     \
-      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                                                                    \
-    {                                                                                                                                             \
-    }                                                                                                                                             \
-                                                                                                                                                  \
-    _Name_() = default;                                                                                                                           \
-    _Name_(_Name_ const& other) = default;                                                                                                        \
-    _Name_& operator=(_Name_ const& other) = default;                                                                                             \
-                                                                                                                                                  \
-    decltype(auto) _Getter_() const                                                                                                               \
-    {                                                                                                                                             \
-      return *mColumnIterator;                                                                                                                    \
-    }                                                                                                                                             \
-                                                                                                                                                  \
-    decltype(auto) get() const                                                                                                                    \
-    {                                                                                                                                             \
-      return _Getter_();                                                                                                                          \
-    }                                                                                                                                             \
-                                                                                                                                                  \
-    static o2::framework::expressions::Projector Projector()                                                                                      \
-    {                                                                                                                                             \
-      return _Expression_;                                                                                                                        \
-    }                                                                                                                                             \
-  };                                                                                                                                              \
-  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(), \
-                                                                                       o2::framework::expressions::selectArrowType<_Type_>() }
+#define DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_, _Expression_)                \
+  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                        \
+    static constexpr const char* mLabel = _Label_;                                                         \
+    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_}); \
+    using base = o2::soa::Column<_Type_, _Name_>;                                                          \
+    using type = _Type_;                                                                                   \
+    using column_t = _Name_;                                                                               \
+    using spawnable_t = std::true_type;                                                                    \
+    _Name_(arrow::ChunkedArray const* column)                                                              \
+      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                             \
+    {                                                                                                      \
+    }                                                                                                      \
+                                                                                                           \
+    _Name_() = default;                                                                                    \
+    _Name_(_Name_ const& other) = default;                                                                 \
+    _Name_& operator=(_Name_ const& other) = default;                                                      \
+                                                                                                           \
+    decltype(auto) _Getter_() const                                                                        \
+    {                                                                                                      \
+      return *mColumnIterator;                                                                             \
+    }                                                                                                      \
+                                                                                                           \
+    decltype(auto) get() const                                                                             \
+    {                                                                                                      \
+      return _Getter_();                                                                                   \
+    }                                                                                                      \
+                                                                                                           \
+    static o2::framework::expressions::Projector Projector()                                               \
+    {                                                                                                      \
+      return _Expression_;                                                                                 \
+    }                                                                                                      \
+  };                                                                                                       \
+  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, _Name_::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 #define DECLARE_SOA_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Expression_) \
   DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, "f" #_Name_, _Expression_);
 
 /// A configurable 'expression' column. i.e. a column that can be calculated from other
 /// columns with gandiva based on dynamically supplied C++ expression or a string definition.
-#define DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Label_)                                                             \
-  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                                                               \
-    static constexpr const char* mLabel = _Label_;                                                                                                \
-    static constexpr const int32_t mHash = _Label_ ""_h;                                                                                          \
-    using base = o2::soa::Column<_Type_, _Name_>;                                                                                                 \
-    using type = _Type_;                                                                                                                          \
-    using column_t = _Name_;                                                                                                                      \
-    using spawnable_t = std::true_type;                                                                                                           \
-    _Name_(arrow::ChunkedArray const* column)                                                                                                     \
-      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                                                                    \
-    {                                                                                                                                             \
-    }                                                                                                                                             \
-                                                                                                                                                  \
-    _Name_() = default;                                                                                                                           \
-    _Name_(_Name_ const& other) = default;                                                                                                        \
-    _Name_& operator=(_Name_ const& other) = default;                                                                                             \
-                                                                                                                                                  \
-    decltype(auto) _Getter_() const                                                                                                               \
-    {                                                                                                                                             \
-      return *mColumnIterator;                                                                                                                    \
-    }                                                                                                                                             \
-                                                                                                                                                  \
-    decltype(auto) get() const                                                                                                                    \
-    {                                                                                                                                             \
-      return _Getter_();                                                                                                                          \
-    }                                                                                                                                             \
-  };                                                                                                                                              \
-  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_>(), \
-                                                                                       o2::framework::expressions::selectArrowType<_Type_>() }
+#define DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Label_)                      \
+  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                        \
+    static constexpr const char* mLabel = _Label_;                                                         \
+    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_}); \
+    static constexpr const int32_t mHash = _Label_ ""_h;                                                   \
+    using base = o2::soa::Column<_Type_, _Name_>;                                                          \
+    using type = _Type_;                                                                                   \
+    using column_t = _Name_;                                                                               \
+    using spawnable_t = std::true_type;                                                                    \
+    _Name_(arrow::ChunkedArray const* column)                                                              \
+      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                             \
+    {                                                                                                      \
+    }                                                                                                      \
+                                                                                                           \
+    _Name_() = default;                                                                                    \
+    _Name_(_Name_ const& other) = default;                                                                 \
+    _Name_& operator=(_Name_ const& other) = default;                                                      \
+                                                                                                           \
+    decltype(auto) _Getter_() const                                                                        \
+    {                                                                                                      \
+      return *mColumnIterator;                                                                             \
+    }                                                                                                      \
+                                                                                                           \
+    decltype(auto) get() const                                                                             \
+    {                                                                                                      \
+      return _Getter_();                                                                                   \
+    }                                                                                                      \
+  };                                                                                                       \
+  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, _Name_::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 /// An index column is a column of indices to elements / of another table named
 /// _Name_##s. The column name will be _Name_##Id and will always be stored in
@@ -2461,6 +2475,7 @@ consteval auto getIndexTargets()
     static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                            \
     static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _");              \
     static constexpr const char* mLabel = "fIndexSlice" _Label_ _Suffix_;                                \
+    static constexpr const uint32_t hash = 0;                                                            \
     using base = o2::soa::Column<_Type_[2], _Name_##IdSlice>;                                            \
     using type = _Type_[2];                                                                              \
     using column_t = _Name_##IdSlice;                                                                    \
@@ -2547,6 +2562,7 @@ consteval auto getIndexTargets()
     static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                            \
     static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _");              \
     static constexpr const char* mLabel = "fIndexArray" _Label_ _Suffix_;                                \
+    static constexpr const uint32_t hash = 0;                                                            \
     using base = o2::soa::Column<std::vector<_Type_>, _Name_##Ids>;                                      \
     using type = std::vector<_Type_>;                                                                    \
     using column_t = _Name_##Ids;                                                                        \
@@ -2697,143 +2713,143 @@ consteval auto getIndexTargets()
 #define DECLARE_SOA_ARRAY_INDEX_COLUMN_CUSTOM(_Name_, _Getter_, _Label_) DECLARE_SOA_ARRAY_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, int32_t, _Name_##s, _Label_, "")
 
 /// NORMAL
-#define DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, _Label_, _Suffix_)                                                                           \
-  struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                                                                                  \
-    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                                                                                \
-    static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _");                                                                                  \
-    static constexpr const char* mLabel = "fIndex" _Label_ _Suffix_;                                                                                                         \
-    using base = o2::soa::Column<_Type_, _Name_##Id>;                                                                                                                        \
-    using type = _Type_;                                                                                                                                                     \
-    using column_t = _Name_##Id;                                                                                                                                             \
-    using binding_t = _Table_;                                                                                                                                               \
-    static constexpr auto index_targets = getIndexTargets<_Table_>();                                                                                                        \
-    _Name_##Id(arrow::ChunkedArray const* column)                                                                                                                            \
-      : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                                                                           \
-    {                                                                                                                                                                        \
-    }                                                                                                                                                                        \
-                                                                                                                                                                             \
-    _Name_##Id() = default;                                                                                                                                                  \
-    _Name_##Id(_Name_##Id const& other) = default;                                                                                                                           \
-    _Name_##Id& operator=(_Name_##Id const& other) = default;                                                                                                                \
-    type inline getId() const                                                                                                                                                \
-    {                                                                                                                                                                        \
-      return _Getter_##Id();                                                                                                                                                 \
-    }                                                                                                                                                                        \
-                                                                                                                                                                             \
-    type _Getter_##Id() const                                                                                                                                                \
-    {                                                                                                                                                                        \
-      return *mColumnIterator;                                                                                                                                               \
-    }                                                                                                                                                                        \
-                                                                                                                                                                             \
-    bool has_##_Getter_() const                                                                                                                                              \
-    {                                                                                                                                                                        \
-      return *mColumnIterator >= 0;                                                                                                                                          \
-    }                                                                                                                                                                        \
-                                                                                                                                                                             \
-    template <typename T>                                                                                                                                                    \
-    auto _Getter_##_as() const                                                                                                                                               \
-    {                                                                                                                                                                        \
-      if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                                                                                    \
-        o2::soa::notBoundTable(#_Table_);                                                                                                                                    \
-      }                                                                                                                                                                      \
-      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                                                                                          \
-        o2::soa::accessingInvalidIndexFor(#_Getter_);                                                                                                                        \
-      }                                                                                                                                                                      \
-      auto t = mBinding.get<T>();                                                                                                                                            \
-      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                                                                                               \
-        o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                                                                                              \
-      }                                                                                                                                                                      \
-      return t->rawIteratorAt(*mColumnIterator);                                                                                                                             \
-    }                                                                                                                                                                        \
-                                                                                                                                                                             \
-    auto _Getter_() const                                                                                                                                                    \
-    {                                                                                                                                                                        \
-      return _Getter_##_as<binding_t>();                                                                                                                                     \
-    }                                                                                                                                                                        \
-                                                                                                                                                                             \
-    template <typename T>                                                                                                                                                    \
-    bool setCurrent(T* current)                                                                                                                                              \
-    {                                                                                                                                                                        \
-      if constexpr (o2::soa::is_binding_compatible_v<T, binding_t>()) {                                                                                                      \
-        assert(current != nullptr);                                                                                                                                          \
-        this->mBinding.bind(current);                                                                                                                                        \
-        return true;                                                                                                                                                         \
-      }                                                                                                                                                                      \
-      return false;                                                                                                                                                          \
-    }                                                                                                                                                                        \
-                                                                                                                                                                             \
-    bool setCurrentRaw(o2::soa::Binding current)                                                                                                                             \
-    {                                                                                                                                                                        \
-      this->mBinding = current;                                                                                                                                              \
-      return true;                                                                                                                                                           \
-    }                                                                                                                                                                        \
-    binding_t const* getCurrent() const { return mBinding.get<binding_t>(); }                                                                                                \
-    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                                                                              \
-    o2::soa::Binding mBinding;                                                                                                                                               \
-  };                                                                                                                                                                         \
-  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" #_Table_ _Suffix_, o2::framework::TypeIdHelpers::uniqueId<_Name_##Id>(), \
-                                                                                           o2::framework::expressions::selectArrowType<_Type_>() }
+#define DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, _Label_, _Suffix_)                  \
+  struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                         \
+    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                       \
+    static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _");                         \
+    static constexpr const char* mLabel = "fIndex" _Label_ _Suffix_;                                                \
+    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_##Id>(), std::string_view{#_Getter_ "Id"}); \
+    using base = o2::soa::Column<_Type_, _Name_##Id>;                                                               \
+    using type = _Type_;                                                                                            \
+    using column_t = _Name_##Id;                                                                                    \
+    using binding_t = _Table_;                                                                                      \
+    static constexpr auto index_targets = getIndexTargets<_Table_>();                                               \
+    _Name_##Id(arrow::ChunkedArray const* column)                                                                   \
+      : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                  \
+    {                                                                                                               \
+    }                                                                                                               \
+                                                                                                                    \
+    _Name_##Id() = default;                                                                                         \
+    _Name_##Id(_Name_##Id const& other) = default;                                                                  \
+    _Name_##Id& operator=(_Name_##Id const& other) = default;                                                       \
+    type inline getId() const                                                                                       \
+    {                                                                                                               \
+      return _Getter_##Id();                                                                                        \
+    }                                                                                                               \
+                                                                                                                    \
+    type _Getter_##Id() const                                                                                       \
+    {                                                                                                               \
+      return *mColumnIterator;                                                                                      \
+    }                                                                                                               \
+                                                                                                                    \
+    bool has_##_Getter_() const                                                                                     \
+    {                                                                                                               \
+      return *mColumnIterator >= 0;                                                                                 \
+    }                                                                                                               \
+                                                                                                                    \
+    template <typename T>                                                                                           \
+    auto _Getter_##_as() const                                                                                      \
+    {                                                                                                               \
+      if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                           \
+        o2::soa::notBoundTable(#_Table_);                                                                           \
+      }                                                                                                             \
+      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                                 \
+        o2::soa::accessingInvalidIndexFor(#_Getter_);                                                               \
+      }                                                                                                             \
+      auto t = mBinding.get<T>();                                                                                   \
+      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                                      \
+        o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                                     \
+      }                                                                                                             \
+      return t->rawIteratorAt(*mColumnIterator);                                                                    \
+    }                                                                                                               \
+                                                                                                                    \
+    auto _Getter_() const                                                                                           \
+    {                                                                                                               \
+      return _Getter_##_as<binding_t>();                                                                            \
+    }                                                                                                               \
+                                                                                                                    \
+    template <typename T>                                                                                           \
+    bool setCurrent(T* current)                                                                                     \
+    {                                                                                                               \
+      if constexpr (o2::soa::is_binding_compatible_v<T, binding_t>()) {                                             \
+        assert(current != nullptr);                                                                                 \
+        this->mBinding.bind(current);                                                                               \
+        return true;                                                                                                \
+      }                                                                                                             \
+      return false;                                                                                                 \
+    }                                                                                                               \
+                                                                                                                    \
+    bool setCurrentRaw(o2::soa::Binding current)                                                                    \
+    {                                                                                                               \
+      this->mBinding = current;                                                                                     \
+      return true;                                                                                                  \
+    }                                                                                                               \
+    binding_t const* getCurrent() const { return mBinding.get<binding_t>(); }                                       \
+    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                     \
+    o2::soa::Binding mBinding;                                                                                      \
+  };                                                                                                                \
+  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" #_Table_ _Suffix_, _Name_##Id::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 #define DECLARE_SOA_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Table_, _Suffix_) DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, #_Table_, _Suffix_)
 #define DECLARE_SOA_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, _Name_##s, "")
 #define DECLARE_SOA_INDEX_COLUMN_CUSTOM(_Name_, _Getter_, _Label_) DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, int32_t, _Name_##s, _Label_, "")
 
 /// SELF
-#define DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_)                                                                   \
-  struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                                                                        \
-    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                                                                      \
-    static constexpr const char* mLabel = "fIndex" _Label_;                                                                                                        \
-    using base = o2::soa::Column<_Type_, _Name_##Id>;                                                                                                              \
-    using type = _Type_;                                                                                                                                           \
-    using column_t = _Name_##Id;                                                                                                                                   \
-    using self_index_t = std::true_type;                                                                                                                           \
-    using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>;                                                           \
-    _Name_##Id(arrow::ChunkedArray const* column)                                                                                                                  \
-      : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                                                                 \
-    {                                                                                                                                                              \
-    }                                                                                                                                                              \
-                                                                                                                                                                   \
-    _Name_##Id() = default;                                                                                                                                        \
-    _Name_##Id(_Name_##Id const& other) = default;                                                                                                                 \
-    _Name_##Id& operator=(_Name_##Id const& other) = default;                                                                                                      \
-    type inline getId() const                                                                                                                                      \
-    {                                                                                                                                                              \
-      return _Getter_##Id();                                                                                                                                       \
-    }                                                                                                                                                              \
-                                                                                                                                                                   \
-    type _Getter_##Id() const                                                                                                                                      \
-    {                                                                                                                                                              \
-      return *mColumnIterator;                                                                                                                                     \
-    }                                                                                                                                                              \
-                                                                                                                                                                   \
-    bool has_##_Getter_() const                                                                                                                                    \
-    {                                                                                                                                                              \
-      return *mColumnIterator >= 0;                                                                                                                                \
-    }                                                                                                                                                              \
-                                                                                                                                                                   \
-    template <typename T>                                                                                                                                          \
-    auto _Getter_##_as() const                                                                                                                                     \
-    {                                                                                                                                                              \
-      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                                                                                \
-        o2::soa::accessingInvalidIndexFor(#_Getter_);                                                                                                              \
-      }                                                                                                                                                            \
-      auto t = mBinding.get<T>();                                                                                                                                  \
-      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                                                                                     \
-        o2::soa::dereferenceWithWrongType(#_Getter_, "self");                                                                                                      \
-      }                                                                                                                                                            \
-      return t->rawIteratorAt(*mColumnIterator);                                                                                                                   \
-    }                                                                                                                                                              \
-                                                                                                                                                                   \
-    bool setCurrentRaw(o2::soa::Binding current)                                                                                                                   \
-    {                                                                                                                                                              \
-      this->mBinding = current;                                                                                                                                    \
-      return true;                                                                                                                                                 \
-    }                                                                                                                                                              \
-    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                                                                    \
-    o2::soa::Binding mBinding;                                                                                                                                     \
-  };                                                                                                                                                               \
-  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" _Label_, o2::framework::TypeIdHelpers::uniqueId<_Name_##Id>(), \
-                                                                                           o2::framework::expressions::selectArrowType<_Type_>() }
+#define DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_)                    \
+  struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                         \
+    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                       \
+    static constexpr const char* mLabel = "fIndex" _Label_;                                                         \
+    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_##Id>(), std::string_view{#_Getter_ "Id"}); \
+    using base = o2::soa::Column<_Type_, _Name_##Id>;                                                               \
+    using type = _Type_;                                                                                            \
+    using column_t = _Name_##Id;                                                                                    \
+    using self_index_t = std::true_type;                                                                            \
+    using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>;            \
+    _Name_##Id(arrow::ChunkedArray const* column)                                                                   \
+      : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                  \
+    {                                                                                                               \
+    }                                                                                                               \
+                                                                                                                    \
+    _Name_##Id() = default;                                                                                         \
+    _Name_##Id(_Name_##Id const& other) = default;                                                                  \
+    _Name_##Id& operator=(_Name_##Id const& other) = default;                                                       \
+    type inline getId() const                                                                                       \
+    {                                                                                                               \
+      return _Getter_##Id();                                                                                        \
+    }                                                                                                               \
+                                                                                                                    \
+    type _Getter_##Id() const                                                                                       \
+    {                                                                                                               \
+      return *mColumnIterator;                                                                                      \
+    }                                                                                                               \
+                                                                                                                    \
+    bool has_##_Getter_() const                                                                                     \
+    {                                                                                                               \
+      return *mColumnIterator >= 0;                                                                                 \
+    }                                                                                                               \
+                                                                                                                    \
+    template <typename T>                                                                                           \
+    auto _Getter_##_as() const                                                                                      \
+    {                                                                                                               \
+      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                                 \
+        o2::soa::accessingInvalidIndexFor(#_Getter_);                                                               \
+      }                                                                                                             \
+      auto t = mBinding.get<T>();                                                                                   \
+      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                                      \
+        o2::soa::dereferenceWithWrongType(#_Getter_, "self");                                                       \
+      }                                                                                                             \
+      return t->rawIteratorAt(*mColumnIterator);                                                                    \
+    }                                                                                                               \
+                                                                                                                    \
+    bool setCurrentRaw(o2::soa::Binding current)                                                                    \
+    {                                                                                                               \
+      this->mBinding = current;                                                                                     \
+      return true;                                                                                                  \
+    }                                                                                                               \
+    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                     \
+    o2::soa::Binding mBinding;                                                                                      \
+  };                                                                                                                \
+  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" _Label_, _Name_##Id::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 #define DECLARE_SOA_SELF_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, void)
 #define DECLARE_SOA_SELF_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_SELF_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, #_Name_)
@@ -2842,6 +2858,7 @@ consteval auto getIndexTargets()
   struct _Name_##IdSlice : o2::soa::Column<_Type_[2], _Name_##IdSlice> {                                 \
     static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                            \
     static constexpr const char* mLabel = "fIndexSlice" _Label_;                                         \
+    static constexpr const uint32_t hash = 0;                                                            \
     using base = o2::soa::Column<_Type_[2], _Name_##IdSlice>;                                            \
     using type = _Type_[2];                                                                              \
     using column_t = _Name_##IdSlice;                                                                    \
@@ -2905,6 +2922,7 @@ consteval auto getIndexTargets()
   struct _Name_##Ids : o2::soa::Column<std::vector<_Type_>, _Name_##Ids> {                               \
     static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                            \
     static constexpr const char* mLabel = "fIndexArray" _Label_;                                         \
+    static constexpr const uint32_t hash = 0;                                                            \
     using base = o2::soa::Column<std::vector<_Type_>, _Name_##Ids>;                                      \
     using type = std::vector<_Type_>;                                                                    \
     using column_t = _Name_##Ids;                                                                        \
@@ -3021,6 +3039,7 @@ consteval auto getIndexTargets()
     using callback_holder_t = _Name_##Callback;                                                                            \
     using callable_t = helper::callable_t;                                                                                 \
     using callback_t = callable_t::type;                                                                                   \
+    static constexpr const uint32_t hash = 0;                                                                              \
                                                                                                                            \
     _Name_(arrow::ChunkedArray const*)                                                                                     \
     {                                                                                                                      \
diff --git a/Framework/Core/include/Framework/StringHelpers.h b/Framework/Core/include/Framework/StringHelpers.h
index 3da10fb0f561d..e450764576c29 100644
--- a/Framework/Core/include/Framework/StringHelpers.h
+++ b/Framework/Core/include/Framework/StringHelpers.h
@@ -13,9 +13,11 @@
 #define O2_FRAMEWORK_STRINGHELPERS_H_
 
 #include <cstdint>
+#include <ranges>
 #include <utility>
 #include <type_traits>
 #include <string_view>
+#include <vector>
 
 // CRC32 Table (zlib polynomial) static
 constexpr uint32_t crc_table[256] = {0x0L, 0x77073096L, 0xee0e612cL,
@@ -72,6 +74,17 @@ consteval uint32_t crc32(char const* str, int length)
   return crc;
 }
 
+template <typename... Ts>
+  requires(std::same_as<Ts, std::string_view> && ...)
+consteval uint32_t crc32(Ts... Vs)
+{
+  uint32_t crc = 0xFFFFFFFF;
+  for (auto& c : std::vector{Vs...} | std::ranges::views::join) {
+    crc = (crc >> 8) ^ crc_table[(crc ^ static_cast<unsigned int>(c)) & 0x000000FF];
+  }
+  return crc;
+}
+
 consteval uint32_t compile_time_hash(char const* str)
 {
   return crc32(str, static_cast<int>(__builtin_strlen(str)) - 1) ^ 0xFFFFFFFF;
diff --git a/Framework/Foundation/include/Framework/TypeIdHelpers.h b/Framework/Foundation/include/Framework/TypeIdHelpers.h
index d4f72b8f3f7ff..5eaac2151b909 100644
--- a/Framework/Foundation/include/Framework/TypeIdHelpers.h
+++ b/Framework/Foundation/include/Framework/TypeIdHelpers.h
@@ -75,10 +75,9 @@ struct TypeIdHelpers {
   constexpr static uint32_t uniqueId()
   {
 #ifdef __CLING__
-    constexpr uint32_t r = crc32(unique_type_id_v<T>.data(), unique_type_id_v<T>.size());
-    return r;
+    return crc32(unique_type_id_v<T>.data(), unique_type_id_v<T>.size());
 #else
-    return compile_time_hash(type_name<T>().data());
+    return crc32(type_name<T>().data(), type_name<T>().size());
 #endif
   }
 };

From e2c787371e4385e13feadb2605f9b9fa21c18dc2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 27 Jun 2025 14:57:18 +0200
Subject: [PATCH 0549/1764] Bump actions/setup-python from 2 to 5 (#14299)

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/datamodel-doc.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/datamodel-doc.yml b/.github/workflows/datamodel-doc.yml
index 294fc2e50f50b..dc8facb307409 100644
--- a/.github/workflows/datamodel-doc.yml
+++ b/.github/workflows/datamodel-doc.yml
@@ -40,7 +40,7 @@ jobs:
           git checkout -B auto-datamodel-doc
 
       - name: Set up Python
-        uses: actions/setup-python@v2
+        uses: actions/setup-python@v5
         with:
           python-version: 3.x
 

From 6df9860cd7d8e488e0fcaf936f71de98bc32e5ea Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 May 2025 09:20:27 +0000
Subject: [PATCH 0550/1764] Bump actions/stale from 1 to 9

Bumps [actions/stale](https://github.com/actions/stale) from 1 to 9.
- [Release notes](https://github.com/actions/stale/releases)
- [Changelog](https://github.com/actions/stale/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/stale/compare/v1...v9)

---
updated-dependencies:
- dependency-name: actions/stale
  dependency-version: '9'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/stale.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
index 1f1387d4868ae..b1be426cdfc77 100644
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -7,7 +7,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v1
+    - uses: actions/stale@v9
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         stale-pr-message: 'This PR did not have any update in the last 30 days. Is it still needed? Unless further action in will be closed in 5 days.'

From f3a41fc59d80d750596aad2f32427945525db00f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 20 May 2025 09:20:22 +0000
Subject: [PATCH 0551/1764] Bump actions/checkout from 3 to 4

Bumps [actions/checkout](https://github.com/actions/checkout) from 3 to 4.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v3...v4)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: '4'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/code-transformations.yml | 2 +-
 .github/workflows/datamodel-doc.yml        | 6 +++---
 .github/workflows/doxygen.yml              | 2 +-
 .github/workflows/release.yml              | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/code-transformations.yml b/.github/workflows/code-transformations.yml
index 4b5e55fcc2941..bfc60fdfcbe44 100644
--- a/.github/workflows/code-transformations.yml
+++ b/.github/workflows/code-transformations.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         ref: ${{ github.event.pull_request.head.sha }}
         persist-credentials: false
diff --git a/.github/workflows/datamodel-doc.yml b/.github/workflows/datamodel-doc.yml
index dc8facb307409..51789c9697196 100644
--- a/.github/workflows/datamodel-doc.yml
+++ b/.github/workflows/datamodel-doc.yml
@@ -10,20 +10,20 @@ jobs:
     steps:
 
       - name: Checkout O2
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           path: O2
           persist-credentials: false
 
       - name: Checkout O2Physics
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           repository: AliceO2Group/O2Physics
           path: O2Physics
           persist-credentials: false
 
       - name: Checkout documentation
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           repository: AliceO2Group/analysis-framework
           path: analysis-framework
diff --git a/.github/workflows/doxygen.yml b/.github/workflows/doxygen.yml
index 38da67c793799..ae867739eba62 100644
--- a/.github/workflows/doxygen.yml
+++ b/.github/workflows/doxygen.yml
@@ -13,7 +13,7 @@ jobs:
       run: |
         sudo apt-get update -y
         sudo apt-get install -y doxygen doxygen-doc doxygen-latex doxygen-gui graphviz cmake
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         ref: "dev"
         persist-credentials: false
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 894ff2e0bb49b..a401af1ba39e2 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -18,7 +18,7 @@ jobs:
         branch=$(echo ${{ github.event.inputs.tag }}-patches | tr . - | sed -e's/-[0-9]*-patches$/-patches/')
         EOF
       id: decide_release_branch
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
       with:
         ref: "dev"
     - name: Tag branch (or create one before tagging if does not exists)

From cddd9286104d04bb1b259a7e738ba886af514190 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Fri, 27 Jun 2025 10:21:58 +0200
Subject: [PATCH 0552/1764] Fix vertex copying for last timeframe in
 collisioncontext

When construction individual-TF collisioncontexts, there was a problem
copying assigned vertices for the last timeframe due to a simple index
comparison error.

This is fixed in this commit.
---
 DataFormats/simulation/src/DigitizationContext.cxx | 2 +-
 Steer/src/CollisionContextTool.cxx                 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index d840809a4c446..dc3c560a1485b 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -705,7 +705,7 @@ DigitizationContext DigitizationContext::extractSingleTimeframe(int timeframeid,
     }
     std::copy(mEventRecords.begin() + startindex, mEventRecords.begin() + endindex, std::back_inserter(r.mEventRecords));
     std::copy(mEventParts.begin() + startindex, mEventParts.begin() + endindex, std::back_inserter(r.mEventParts));
-    if (mInteractionVertices.size() > endindex) {
+    if (mInteractionVertices.size() >= endindex) {
       std::copy(mInteractionVertices.begin() + startindex, mInteractionVertices.begin() + endindex, std::back_inserter(r.mInteractionVertices));
     }
 
diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index e2f7c0fce3d67..9fc3e548ff213 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -594,7 +594,7 @@ int main(int argc, char* argv[])
         std::stringstream str;
         str << path_prefix << tf_output_counter++ << "/collisioncontext.root";
         copy.saveToFile(str.str());
-        LOG(info) << "----";
+        LOG(info) << "---- CollisionContext for timeframe " << tf_id << " -----";
         copy.printCollisionSummary();
       }
     }

From 50d26e30079bfa5be388b7aaf511c367ca66d350 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Fri, 27 Jun 2025 10:25:47 +0200
Subject: [PATCH 0553/1764] o2-sim: Fix for merger exit status analysis

---
 run/o2sim_parallel.cxx | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/run/o2sim_parallel.cxx b/run/o2sim_parallel.cxx
index 22c6b37e6d9aa..c060059ce4d6b 100644
--- a/run/o2sim_parallel.cxx
+++ b/run/o2sim_parallel.cxx
@@ -762,9 +762,8 @@ int main(int argc, char* argv[])
   // Handle mergerpid status separately
   if (cpid == mergerpid) {
     if (WIFEXITED(status)) {
-      // anything other than 128 is indicative of error
-      if (WEXITSTATUS(status) != 128) {
-        LOG(error) << "Merger process exited with abnormal code " << WEXITSTATUS(status);
+      if (WEXITSTATUS(status) != 0 || WEXITSTATUS(status) != 128) {
+        LOG(error) << "Merger process exited with abnormal exit status " << WEXITSTATUS(status);
         errored = true;
       }
     } else if (WIFSIGNALED(status)) {

From 6f78cf38c2cb16f01d130beb6dfa50008c63ccc0 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 30 Jun 2025 09:23:27 +0200
Subject: [PATCH 0554/1764] DPL Analysis: add `PresliceGroup` (#14418)

---
 Framework/Core/include/Framework/ASoA.h        | 18 ++++++++++++++++++
 .../Core/include/Framework/AnalysisManagers.h  | 18 ++++++++++++++++--
 Framework/Core/test/test_AnalysisTask.cxx      | 15 +++++++++++++++
 Framework/Core/test/test_Concepts.cxx          |  9 +++++++++
 4 files changed, 58 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 0e4c2b82ffa8f..ccf2cab5e6807 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1468,6 +1468,24 @@ using PresliceOptional = PresliceBase<T, PreslicePolicySorted, true>;
 template <typename T>
 concept is_preslice = std::derived_from<T, PreslicePolicyBase>;
 
+/// Can be user to group together a number of Preslice declaration
+/// to avoid the limit of 100 data members per task
+///
+/// struct MyTask
+///   struct : public PresliceGroup {
+///     Preslice<aod::Tracks> perCol = aod::track::collisonId;
+///     Preslice<aod::McParticles> perMcCol = aod::mcparticle::mcCollisionId;
+///   } preslices;
+///
+/// individual components can be access with
+///
+/// preslices.perCol;
+struct PresliceGroup {
+};
+
+template <typename T>
+concept is_preslice_group = std::derived_from<T, PresliceGroup>;
+
 } // namespace o2::framework
 
 namespace o2::soa
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 7717d5cb3a6a2..02d252970d731 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -580,7 +580,7 @@ static void setGroupedCombination(C& comb, TG& grouping, std::tuple<Ts...>& asso
 
 /// Preslice handling
 template <typename T>
-  requires(!is_preslice<T>)
+  requires(!is_preslice<T> && !is_preslice_group<T>)
 bool registerCache(T&, Cache&, Cache&)
 {
   return false;
@@ -622,8 +622,15 @@ bool registerCache(T& preslice, Cache&, Cache& bsksU)
   return true;
 }
 
+template <is_preslice_group T>
+bool registerCache(T& presliceGroup, Cache& bsks, Cache& bsksU)
+{
+  homogeneous_apply_refs<true>([&bsks, &bsksU](auto& preslice) { return registerCache(preslice, bsks, bsksU); }, presliceGroup);
+  return true;
+}
+
 template <typename T>
-  requires(!is_preslice<T>)
+  requires(!is_preslice<T> && !is_preslice_group<T>)
 bool updateSliceInfo(T&, ArrowTableSlicingCache&)
 {
   return false;
@@ -655,6 +662,13 @@ static bool updateSliceInfo(T& preslice, ArrowTableSlicingCache& cache)
   return true;
 }
 
+template <is_preslice_group T>
+static bool updateSliceInfo(T& presliceGroup, ArrowTableSlicingCache& cache)
+{
+  homogeneous_apply_refs<true>([&cache](auto& preslice) { return updateSliceInfo(preslice, cache); }, presliceGroup);
+  return true;
+}
+
 /// Process switches handling
 template <typename T>
 static bool setProcessSwitch(std::pair<std::string, bool>, T&)
diff --git a/Framework/Core/test/test_AnalysisTask.cxx b/Framework/Core/test/test_AnalysisTask.cxx
index ff0f7da1acaab..f5d8c4c43bc38 100644
--- a/Framework/Core/test/test_AnalysisTask.cxx
+++ b/Framework/Core/test/test_AnalysisTask.cxx
@@ -13,6 +13,7 @@
 #include "TestClasses.h"
 #include "Framework/AnalysisTask.h"
 #include "Framework/AnalysisDataModel.h"
+#include <iostream>
 
 #include <catch_amalgamated.hpp>
 
@@ -185,6 +186,17 @@ struct LTask {
   void process(aod::McCollision const&, soa::SmallGroups<soa::Join<aod::Collisions, aod::McCollisionLabels>> const&) {}
 };
 
+struct MTask {
+  SliceCache cache;
+  struct : public PresliceGroup {
+    Preslice<aod::Tracks> perCol = aod::track::collisionId;
+    PresliceOptional<aod::Tracks> perPart = aod::mctracklabel::mcParticleId;
+    PresliceUnsorted<aod::McCollisionLabels> perMcCol = aod::mccollisionlabel::mcCollisionId;
+    PresliceUnsortedOptional<aod::Collisions> perMcColopt = aod::mccollisionlabel::mcCollisionId;
+  } foo;
+  void process(aod::McCollision const&, soa::SmallGroups<soa::Join<aod::Collisions, aod::McCollisionLabels>> const&) {}
+};
+
 TEST_CASE("AdaptorCompilation")
 {
   auto cfgc = makeEmptyConfigContext();
@@ -258,6 +270,9 @@ TEST_CASE("AdaptorCompilation")
 
   auto task12 = adaptAnalysisTask<LTask>(*cfgc, TaskName{"test12"});
   REQUIRE(task12.inputs.size() == 3);
+
+  auto task13 = adaptAnalysisTask<MTask>(*cfgc, TaskName{"test13"});
+  REQUIRE(task13.inputs.size() == 3);
 }
 
 TEST_CASE("TestPartitionIteration")
diff --git a/Framework/Core/test/test_Concepts.cxx b/Framework/Core/test/test_Concepts.cxx
index 5e2ad6d96b30f..ea94c4dfffe5a 100644
--- a/Framework/Core/test/test_Concepts.cxx
+++ b/Framework/Core/test/test_Concepts.cxx
@@ -96,6 +96,14 @@ TEST_CASE("IdentificationConcepts")
   Preslice<o2::aod::Tracks> ps = o2::aod::track::collisionId;
   REQUIRE(is_preslice<decltype(ps)>);
 
+  struct : PresliceGroup {
+    Preslice<o2::aod::Tracks> pc = o2::aod::track::collisionId;
+    Preslice<o2::aod::McParticles> pmcc = o2::aod::mcparticle::mcCollisionId;
+  } preslices;
+  REQUIRE(is_preslice_group<decltype(preslices)>);
+  REQUIRE(is_preslice<decltype(preslices.pc)>);
+  REQUIRE(is_preslice<decltype(preslices.pmcc)>);
+
   REQUIRE(has_filtered_policy<soa::Filtered<o2::aod::Tracks>::iterator>);
 
   REQUIRE(is_filtered_iterator<soa::Filtered<o2::aod::Tracks>::iterator>);
@@ -176,6 +184,7 @@ TEST_CASE("IdentificationConcepts")
   expressions::Filter f = o2::aod::track::pt > 1.0f;
   REQUIRE(expressions::is_filter<decltype(f)>);
 
+  // Combinations
   using C = SameKindPair<aod::Collisions, aod::Tracks, ColumnBinningPolicy<aod::collision::PosZ>>;
   REQUIRE(is_combinations_generator<C>);
 }

From 11329f61884cc17f82132960c1a62f8f0244dd1b Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Mon, 30 Jun 2025 22:53:32 +0200
Subject: [PATCH 0555/1764] Improve filling kernel speed by 20x using for-loop
 fill on CPU

---
 .../Definitions/GPUDefParametersDefaults.h    |  4 ++--
 .../Global/GPUChainTrackingClusterizer.cxx    | 16 ++++++++++-----
 .../GPUTPCNNClusterizerKernels.cxx            | 20 +++++++++++++------
 .../GPUTPCNNClusterizerKernels.h              |  8 ++++----
 GPU/GPUTracking/kernels.cmake                 |  4 ++--
 5 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 0591ac8c58630..48d00b274dc9c 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -488,8 +488,8 @@
   #define GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks GPUCA_LB_GPUTPCCFNoiseSuppression
 
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNSingleElement GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNCPU GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNGPU GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index dd4cd6ef0be96..25bfe37f0db30 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -990,11 +990,17 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             uint batchStart = batch * clustererNNShadow.mNnClusterizerBatchedMode;
             size_t iSize = CAMath::Min((uint)clustererNNShadow.mNnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
 
-            // auto start0 = std::chrono::high_resolution_clock::now();
-            runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNSingleElement>({GetGrid(iSize * clustererNNShadow.mNnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart); // Filling the data
+            // Filling the data
+            if (mRec->IsGPU()) {
+              // Fills element by element of each input matrix -> better parallelizability, but worse on CPU due to unnecessary computations
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNGPU>({GetGrid(iSize * clustererNNShadow.mNnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
+            } else {
+              // Fills the whole input matrix at once -> better performance on CPU, but worse parallelizability
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNCPU>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
+            }
 
             if (clustererNNShadow.mNnClusterizerSetDeconvolutionFlags) {
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart); // Filling the regression data
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart); // Publishing the deconvolution flags
             }
 
             // NN evaluations
@@ -1042,7 +1048,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
               }
             }
 
-            // Publishing kernels
+            // Publishing kernels for class labels and regression results
             if (nnApplication.mModelClass.getNumOutputNodes()[0][1] == 1) {
               runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, propagateMCLabels, batchStart); // Assigning class labels
             } else {
@@ -1057,7 +1063,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           }
 
           if (clustererNNShadow.mNnClusterizerUseCfRegression) {
-            if(!nn_settings.nnClusterizerApplyCfDeconvolution) {
+            if(!nn_settings.nnClusterizerApplyCfDeconvolution) { // If it is already applied don't do it twice, otherwise apply now
               runKernel<GPUTPCCFDeconvolution>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}}, true);
             }
             DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index bc8d26954b5dc..8cdc0684ad588 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -51,7 +51,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNN>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNCPU>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
@@ -65,16 +65,14 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
   int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
 
-#ifndef GPUCA_GPUCODE
-  GPUCA_UNROLL(U(), U());
-#endif
   for (int32_t r = -clustererNN.mNnClusterizerSizeInputRow; r <= clustererNN.mNnClusterizerSizeInputRow; r++) {
     bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
     int32_t pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, row + r);
     for (int32_t p = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; p++) {
       bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow);
       for (int32_t t = -clustererNN.mNnClusterizerSizeInputTime; t <= clustererNN.mNnClusterizerSizeInputTime; t++) {
-        if (!is_boundary) {
+        int32_t time_pos = time + t;
+        if (!is_boundary && (time_pos >= 0) && (time_pos < TPC_MAX_FRAGMENT_LEN_GPU)) {
           CfChargePos tmp_pos(row + r, pad + p, time + t);
           if (r == 0 && !clustererNN.mClusterFlags[2 * glo_idx] && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) { // ordering is done for short circuit optimization
             clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
@@ -108,10 +106,20 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
       clustererNN.mInputData_32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
     }
   }
+  if (!clustererNN.mNnClusterizerSetDeconvolutionFlags) {
+    clustererNN.mClusterFlags[2 * glo_idx] = 0;
+    clustererNN.mClusterFlags[2 * glo_idx + 1] = 0;
+    for (uint16_t i = 0; i < 8; i++) {
+      Delta2 d = cfconsts::InnerNeighbors[i];
+      CfChargePos tmp_pos = peak.delta(d);
+      clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
+    }
+    clustererNN.mClusterFlags[2 * glo_idx + 1] = clustererNN.mClusterFlags[2 * glo_idx];
+  }
 }
 
 template <>
-GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNSingleElement>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
+GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNGPU>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index 179eb483cdf6b..a3858d47eb99b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -38,8 +38,8 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
 {
  public:
   // Must all have same number of threads, since they use a common SCRATCH_PAD_WORK_GROUP_SIZE below
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNN) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNSingleElement) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNCPU) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNGPU) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
   static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
   static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
   static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
@@ -59,8 +59,8 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
 
   enum K : int32_t {
     runCfClusterizer = 0,
-    fillInputNN = 1,
-    fillInputNNSingleElement = 2,
+    fillInputNNCPU = 1,
+    fillInputNNGPU = 2,
     determineClass1Labels = 3,
     determineClass2Labels = 4,
     publishClass1Regression = 5,
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 52cda3e8ff416..7ebe631d86e92 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -127,8 +127,8 @@ o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                    "= GLO
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"            "= GLOBALREFIT "                                        LB)
 if(onnxruntime_FOUND)
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, runCfClusterizer"          "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNN"               "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
-o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNNSingleElement"  "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNNCPU"            "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
+o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, fillInputNNGPU"            "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass1Labels"     "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, determineClass2Labels"     "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass1Regression"   "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)

From fe73d1b146e575fe980b3ba2e1726a8c9297390f Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Thu, 26 Jun 2025 13:51:33 +0200
Subject: [PATCH 0556/1764] TPC reco: Only read CTP digits when tracking

should prevent reading CTP digits when merely clusterizing
---
 Detectors/TPC/workflow/src/RecoWorkflow.cxx | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index 0edd23de7c57d..0ccc3d73f115c 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -159,6 +159,8 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
 
   WorkflowSpec specs;
 
+  bool produceTracks = isEnabled(OutputType::Tracks);
+
   // We provide a special publishing method for labels which have been stored in a split format and need
   // to be transformed into a contiguous shareable container before publishing. For other branches/types this returns
   // false and the generic RootTreeWriter publishing proceeds
@@ -196,7 +198,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
       if (sclOpts.needTPCScalersWorkflow()) { // for standalone tpc-reco workflow
         specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpts.lumiType == 2, sclOpts.enableMShapeCorrection));
       }
-      if (sclOpts.requestCTPLumi) { // need CTP digits (lumi) reader
+      if (produceTracks && sclOpts.requestCTPLumi) { // need CTP digits (lumi) reader
         specs.emplace_back(o2::ctp::getDigitsReaderSpec(false));
       }
     } else if (inputType == InputType::ClustersHardware) {
@@ -247,7 +249,6 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   // Note: the ClusterHardware format is probably a deprecated legacy format and also the
   // ClusterDecoderRawSpec
   bool produceCompClusters = isEnabled(OutputType::CompClusters);
-  bool produceTracks = isEnabled(OutputType::Tracks);
   bool runGPUReco = (produceTracks || produceCompClusters || (isEnabled(OutputType::Clusters) && caClusterer) || inputType == InputType::CompClustersCTF) && inputType != InputType::CompClustersFlat;
   bool runHWDecoder = !caClusterer && (runGPUReco || isEnabled(OutputType::Clusters));
   bool runClusterer = !caClusterer && (runHWDecoder || isEnabled(OutputType::ClustersHardware));

From bb7db6d0ddeab602325fd0e3b10822433134d0d6 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <f3sch.git@outlook.com>
Date: Sat, 17 May 2025 15:47:16 +0200
Subject: [PATCH 0557/1764] ITS: GPU: print kernel params

prints gpu kernel params

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 09d9cee06d9f9..5c3a43540f833 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -39,6 +39,9 @@ Tracker::Tracker(TrackerTraits7* traits) : mTraits(traits)
 {
   /// Initialise standard configuration with 1 iteration
   mTrkParams.resize(1);
+  if (traits->isGPU()) {
+    ITSGpuTrackingParamConfig::Instance().printKeyValues(true, true);
+  }
 }
 
 void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)

From 2bf4a1549ed9f65e700b5c96f82cc92fd9b5da62 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 30 Jun 2025 14:55:45 +0200
Subject: [PATCH 0558/1764] ITS: GPU use ms for tracklets

uses multiple streams for trackleting

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  11 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |   6 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   |  90 ++++--
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 303 ++++++++----------
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |   8 +-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  |  88 ++---
 6 files changed, 269 insertions(+), 237 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index d41591e6ff25c..8b3e9bddd18d6 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -23,8 +23,6 @@
 namespace o2::its::gpu
 {
 
-class Stream;
-
 class DefaultGPUAllocator : public ExternalAllocator
 {
   void* allocate(size_t size) override;
@@ -81,10 +79,11 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void downloadCellsLUTDevice();
   void unregisterRest();
   template <Task task>
-  Stream& getStream(const size_t stream)
+  auto& getStream(const size_t stream)
   {
-    return *mGpuStreams[stream];
+    return mGpuStreams[stream];
   }
+  auto& getStreams() { return mGpuStreams; }
   void wipe(const int);
 
   /// interface
@@ -146,7 +145,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   int getNumberOfNeighbours() const final;
 
  private:
-  void allocMemAsync(void**, size_t, Stream*, bool); // Abstract owned and unowned memory allocations
+  void allocMemAsync(void**, size_t, Stream&, bool); // Abstract owned and unowned memory allocations
   bool mHostRegistered = false;
   TimeFrameGPUParameters mGpuParams;
 
@@ -200,7 +199,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
   // State
-  std::vector<Stream*> mGpuStreams;
+  Streams mGpuStreams;
   size_t mAvailMemGB;
   bool mFirstInit = true;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index b847aacd9bba5..a058f7e5fab0c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -84,7 +84,8 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  std::vector<float>& radii,
                                  bounded_vector<float>& mulScatAng,
                                  const int nBlocks,
-                                 const int nThreads);
+                                 const int nThreads,
+                                 gpu::Streams& streams);
 
 template <int nLayers = 7>
 void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
@@ -117,7 +118,8 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    std::vector<float>& radii,
                                    bounded_vector<float>& mulScatAng,
                                    const int nBlocks,
-                                   const int nThreads);
+                                   const int nThreads,
+                                   gpu::Streams& streams);
 
 void countCellsHandler(const Cluster** sortedClusters,
                        const Cluster** unsortedClusters,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index 74c118009d67d..454e39e04a661 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -16,12 +16,14 @@
 #ifndef ITSTRACKINGGPU_UTILS_H_
 #define ITSTRACKINGGPU_UTILS_H_
 
+#include <vector>
+
 #include "GPUCommonDef.h"
+#include "GPUCommonHelpers.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
+
 template <typename T1, typename T2>
 struct gpuPair {
   T1 first;
@@ -31,11 +33,6 @@ struct gpuPair {
 namespace gpu
 {
 
-template <typename T>
-void discardResult(const T&)
-{
-}
-
 // Poor man implementation of a span-like struct. It is very limited.
 template <typename T>
 struct gpuSpan {
@@ -85,19 +82,74 @@ enum class Task {
   Vertexer = 1
 };
 
-template <class T>
-GPUhd() T* getPtrFromRuler(int index, T* src, const int* ruler, const int stride = 1)
+// Abstract stream class
+class Stream
 {
-  return src + ruler[index] * stride;
-}
+ public:
+#if defined(__HIPCC__)
+  using Handle = hipStream_t;
+  static constexpr Handle Default = 0;
+#elif defined(__CUDACC__)
+  using Handle = cudaStream_t;
+  static constexpr Handle Default = 0;
+#else
+  using Handle = void*;
+  static constexpr Handle Default = nullptr;
+#endif
+
+  Stream(unsigned int flags = 0)
+  {
+#if defined(__HIPCC__)
+    GPUChkErrS(hipStreamCreateWithFlags(&mHandle, flags));
+#elif defined(__CUDACC__)
+    GPUChkErrS(cudaStreamCreateWithFlags(&mHandle, flags));
+#endif
+  }
 
-template <class T>
-GPUhd() const T* getPtrFromRuler(int index, const T* src, const int* ruler, const int stride = 1)
+  Stream(Handle h) : mHandle(h) {}
+  ~Stream()
+  {
+    if (mHandle != Default) {
+#if defined(__HIPCC__)
+      GPUChkErrS(hipStreamDestroy(mHandle));
+#elif defined(__CUDACC__)
+      GPUChkErrS(cudaStreamDestroy(mHandle));
+#endif
+    }
+  }
+
+  operator bool() const { return mHandle != Default; }
+  const Handle& get() { return mHandle; }
+  void sync() const
+  {
+#if defined(__HIPCC__)
+    GPUChkErrS(hipStreamSynchronize(mHandle));
+#elif defined(__CUDACC__)
+    GPUChkErrS(cudaStreamSynchronize(mHandle));
+#endif
+  }
+
+ private:
+  Handle mHandle{Default};
+};
+static_assert(sizeof(Stream) == sizeof(void*), "Stream type must match pointer type!");
+
+// Abstract vector for streams.
+// Handles specifically wrap around.
+class Streams
 {
-  return src + ruler[index] * stride;
-}
+ public:
+  size_t size() const noexcept { return mStreams.size(); }
+  void resize(size_t n) { mStreams.resize(n); }
+  void clear() { mStreams.clear(); }
+  auto& operator[](size_t i) { return mStreams[i % mStreams.size()]; }
+  void push_back(const Stream& stream) { mStreams.push_back(stream); }
+
+ private:
+  std::vector<Stream> mStreams;
+};
+
 } // namespace gpu
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index b336073604b62..13851b4cdc1aa 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -58,38 +58,6 @@ using constants::MB;
 
 namespace gpu
 {
-class Stream final
-{
- public:
-  Stream();
-  ~Stream();
-
-  [[nodiscard]] const cudaStream_t& get() const;
-
- private:
-  cudaStream_t mStream;
-};
-
-Stream::Stream()
-{
-  GPUChkErrS(cudaStreamCreate(&mStream));
-}
-
-Stream::~Stream()
-{
-  GPUChkErrS(cudaStreamDestroy(mStream));
-}
-
-const cudaStream_t& Stream::get() const
-{
-  return mStream;
-}
-
-void* DefaultGPUAllocator::allocate(size_t size)
-{
-  LOGP(fatal, "Called DefaultGPUAllocator::allocate with size {}", size);
-  return nullptr; // to be implemented
-}
 
 template <int nLayers>
 TimeFrameGPU<nLayers>::TimeFrameGPU()
@@ -101,13 +69,13 @@ template <int nLayers>
 TimeFrameGPU<nLayers>::~TimeFrameGPU() = default;
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream* strPtr, bool extAllocator)
+void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& stream, bool extAllocator)
 {
   if (extAllocator) {
     *ptr = this->mAllocator->allocate(size);
   } else {
     LOGP(debug, "Calling default CUDA allocator");
-    GPUChkErrS(cudaMallocAsync(reinterpret_cast<void**>(ptr), size, strPtr->get()));
+    GPUChkErrS(cudaMallocAsync(reinterpret_cast<void**>(ptr), size, stream.get()));
   }
 }
 
@@ -120,31 +88,31 @@ void TimeFrameGPU<nLayers>::setDevicePropagator(const o2::base::PropagatorImpl<f
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading indextable utils");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading indextable utils");
   if (!iteration) {
     LOGP(debug, "gpu-allocation: allocating IndexTableUtils buffer, for {} MB.", sizeof(IndexTableUtils) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), nullptr, this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), mGpuStreams[0], this->getExtAllocator());
   }
   LOGP(debug, "gpu-transfer: loading IndexTableUtils object, for {} MB.", sizeof(IndexTableUtils) / MB);
-  GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading unsorted clusters");
+    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading unsorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} unsorted clusters on layer {}, for {} MB.", this->mUnsortedClusters[iLayer].size(), iLayer, this->mUnsortedClusters[iLayer].size() * sizeof(Cluster) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), nullptr, this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[0], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+    GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
@@ -152,17 +120,17 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading sorted clusters");
+    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} clusters on layer {}, for {} MB.", this->mClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(Cluster) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), this->mClusters[iLayer].size() * sizeof(Cluster), nullptr, this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), this->mClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[0], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), nullptr, this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+    GPUChkErrS(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
@@ -170,15 +138,15 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading sorted clusters");
+    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading clusters indextable for layer {} with {} elements, for {} MB.", iLayer, this->mIndexTables[iLayer].size(), this->mIndexTables[iLayer].size() * sizeof(int) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), this->mIndexTables[iLayer].size() * sizeof(int), nullptr, this->getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), this->mIndexTables[iLayer].size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
+      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
@@ -186,72 +154,72 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating used clusters flags");
+    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating used clusters flags");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: creating {} used clusters flags on layer {}, for {} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), nullptr, this->getExtAllocator());
-      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0]->get()));
+      allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0], this->getExtAllocator());
+      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadUsedClustersDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading used clusters flags");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading used clusters flags");
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} used clusters flags on layer {}, for {} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(unsigned char) / MB);
-    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading ROframe clusters");
+    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading ROframe clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} ROframe clusters info on layer {}, for {} MB.", this->mROFramesClusters[iLayer].size(), iLayer, this->mROFramesClusters[iLayer].size() * sizeof(int) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), this->mROFramesClusters[iLayer].size() * sizeof(int), nullptr, this->getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), this->mROFramesClusters[iLayer].size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
+      GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+    allocMemAsync(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading trackingframeinfo");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading trackingframeinfo");
   if (!iteration) {
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} tfinfo on layer {}, for {} MB.", this->mTrackingFrameInfo[iLayer].size(), iLayer, this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), nullptr, this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), mGpuStreams[0], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), nullptr, this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading multiplicity cut mask");
+    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading multiplicity cut mask");
     LOGP(debug, "gpu-transfer: loading multiplicity cut mask with {} elements, for {} MB.", this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(bool) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+    allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
@@ -259,67 +227,67 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading seeding vertices");
+    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading seeding vertices");
     LOGP(debug, "gpu-transfer: loading {} ROframes vertices, for {} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     LOGP(debug, "gpu-transfer: loading {} seeding vertices, for {} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+    allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating tracklets LUTs");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating tracklets LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     if (!iteration) {
       LOGP(debug, "gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {} MB.", this->mClusters[iLayer].size() + 1, iLayer, (this->mClusters[iLayer].size() + 1) * sizeof(int) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (this->mClusters[iLayer].size() + 1) * sizeof(int), nullptr, this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator());
     }
-    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
   }
   if (!iteration) {
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsBuffers()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells buffers");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells buffers");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     mNTracklets[iLayer] = 0;
     GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + this->mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost));
     LOGP(debug, "gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {} MB.", mNTracklets[iLayer], iLayer, mNTracklets[iLayer] * sizeof(Tracklet) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), nullptr, this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), mGpuStreams[0], this->getExtAllocator());
   }
-  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), nullptr, this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  GPUChkErrS(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackletsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading tracklets");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} tracklets on layer {}, for {} MB.", this->mTracklets[iLayer].size(), iLayer, this->mTracklets[iLayer].size() * sizeof(Tracklet) / MB);
     GPUChkErrS(cudaHostRegister(this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading tracklets");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {} MB", this->mTrackletsLookupTable[iLayer].size(), iLayer + 1, this->mTrackletsLookupTable[iLayer].size() * sizeof(int) / MB);
     GPUChkErrS(cudaHostRegister(this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
@@ -327,90 +295,90 @@ void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
   }
   GPUChkErrS(cudaHostRegister(mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells neighbours");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells neighbours");
   // Here we do also the creation of the CellsDeviceArray, as the cells buffers are populated separately in the previous steps.
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0]->get()));
+    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
     if (iLayer < nLayers - 3) {
       mNNeighbours[iLayer] = 0;
     }
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const unsigned int nCells)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighboursLUT");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighboursLUT");
   LOGP(debug, "gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), nullptr, this->getExtAllocator()); // We need one element more to move exc -> inc
-  GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0]->get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator()); // We need one element more to move exc -> inc
+  GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0].get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadCellsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading cell seeds");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading cell seeds");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} cell seeds on layer {}, for {} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeed) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeed), nullptr, this->getExtAllocator());
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), nullptr, this->getExtAllocator()); // accessory for the neigh. finding.
-    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0]->get()));
-    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator()); // accessory for the neigh. finding.
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), nullptr, this->getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), mGpuStreams[0], this->getExtAllocator());
+  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells LUTs");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: creating cell LUT for {} elements on layer {}, for {} MB.", mNTracklets[iLayer] + 1, iLayer, (mNTracklets[iLayer] + 1) * sizeof(int) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), nullptr, this->getExtAllocator());
-    GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0]->get()));
+    allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator());
+    GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
   }
-  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), nullptr, this->getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
+  GPUChkErrS(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "creating cells buffers");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells buffers");
   mNCells[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost));
   LOGP(debug, "gpu-transfer: creating cell buffer for {} elements on layer {}, for {} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), nullptr, this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
 
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading cells LUTs");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading cells LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading cell LUT for {} elements on layer {}, for {} MB.", this->mCellsLookupTable[iLayer].size(), iLayer, this->mCellsLookupTable[iLayer].size() * sizeof(int) / MB);
     GPUChkErrS(cudaHostRegister(this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
@@ -419,128 +387,128 @@ void TimeFrameGPU<nLayers>::loadRoadsDevice()
   LOGP(debug, "gpu-transfer: loading {} roads, for {} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
+  GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "loading track seeds");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading track seeds");
   LOGP(debug, "gpu-transfer: loading {} track seeds, for {} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, const unsigned int nNeighbours)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0]->get()));
+  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, std::vector<std::pair<int, int>>& neighbours)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
   this->mCellsNeighbours[layer].clear();
   this->mCellsNeighbours[layer].resize(neighbours.size());
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0]->get()));
+  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDeviceArray()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving neighbours");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0]->get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  GPUChkErrS(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "reserving tracks");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving tracks");
   mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
   LOGP(debug, "gpu-allocation: reserving {} tracks, for {} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0]->get()));
+  GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0].get()));
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading cells");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading cells");
   for (int iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading {} cells on layer: {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
     this->mCells[iLayer].resize(mNCells[iLayer]);
-    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading cell luts");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading cell luts");
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading cells lut on layer {} for {} elements", iLayer, (mNTracklets[iLayer + 1] + 1));
     this->mCellsLookupTable[iLayer].resize(mNTracklets[iLayer + 1] + 1);
-    GPUChkErrS(cudaMemcpyAsync(this->mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
+    GPUChkErrS(cudaMemcpyAsync(this->mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>& neighbours, const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), fmt::format("downloading neighbours from layer {}", layer));
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), fmt::format("downloading neighbours from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading {} neighbours, for {} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / MB);
   // TODO: something less dangerous than assuming the same memory layout of std::pair and gpuPair... or not? :)
-  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
+  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut, const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), fmt::format("downloading neighbours LUT from layer {}", layer));
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), fmt::format("downloading neighbours LUT from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {} MB.", lut.size(), layer, lut.size() * sizeof(int) / MB);
-  GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "downloading tracks");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading tracks");
   LOGP(debug, "gpu-transfer: downloading {} tracks, for {} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / MB);
-  GPUChkErrS(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0]->get()));
+  GPUChkErrS(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
   GPUChkErrS(cudaHostUnregister(mTrackITSExt.data()));
   GPUChkErrS(cudaHostUnregister(seeds.data()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterRest()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0]->get(), "unregistering rest of the host memory");
+  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "unregistering rest of the host memory");
   LOGP(debug, "unregistering rest of the host memory...");
   GPUChkErrS(cudaHostUnregister(mCellsDevice.data()));
   GPUChkErrS(cudaHostUnregister(mTrackletsDevice.data()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0]->get());
+  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
@@ -563,10 +531,7 @@ void TimeFrameGPU<nLayers>::initialise(const int iteration,
                                        IndexTableUtils* utils,
                                        const TimeFrameGPUParameters* gpuParam)
 {
-  mGpuStreams.resize(mGpuParams.nTimeFrameChunks);
-  for (auto& str : mGpuStreams) {
-    str = new Stream();
-  }
+  mGpuStreams.resize(nLayers);
   o2::its::TimeFrame<nLayers>::initialise(iteration, trkParam, maxLayers);
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index b32189f3fabe3..d804d0062764f 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -49,13 +49,13 @@ template <int nLayers>
 void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
-  mTimeFrameGPU->createTrackletsLUTDevice(iteration);
 
   const Vertex diamondVert({this->mTrkParams[iteration].Diamond[0], this->mTrkParams[iteration].Diamond[1], this->mTrkParams[iteration].Diamond[2]}, {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f}, 1, 1.f);
   gsl::span<const Vertex> diamondSpan(&diamondVert, 1);
   int startROF{this->mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * this->mTrkParams[iteration].nROFsPerIterations : 0};
   int endROF{o2::gpu::CAMath::Min(this->mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * this->mTrkParams[iteration].nROFsPerIterations + this->mTrkParams[iteration].DeltaROF : mTimeFrameGPU->getNrof(), mTimeFrameGPU->getNrof())};
 
+  mTimeFrameGPU->createTrackletsLUTDevice(iteration);
   countTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
                                        mTimeFrameGPU->getDeviceMultCutMask(),
                                        startROF,
@@ -83,7 +83,8 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                        this->mTrkParams[iteration].LayerRadii,
                                        mTimeFrameGPU->getMSangles(),
                                        conf.nBlocks,
-                                       conf.nThreads);
+                                       conf.nThreads,
+                                       mTimeFrameGPU->getStreams());
   mTimeFrameGPU->createTrackletsBuffers();
   computeTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
                                          mTimeFrameGPU->getDeviceMultCutMask(),
@@ -115,7 +116,8 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          this->mTrkParams[iteration].LayerRadii,
                                          mTimeFrameGPU->getMSangles(),
                                          conf.nBlocks,
-                                         conf.nThreads);
+                                         conf.nThreads,
+                                         mTimeFrameGPU->getStreams());
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 8c6367c221583..8245aee33718c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -890,11 +890,14 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  std::vector<float>& radii,
                                  bounded_vector<float>& mulScatAng,
                                  const int nBlocks,
-                                 const int nThreads)
+                                 const int nThreads,
+                                 gpu::Streams& streams)
 {
   for (int iLayer = 0; iLayer < nLayers - 1; ++iLayer) {
     gpu::computeLayerTrackletsMultiROFKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                                     o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+                                                     o2::gpu::CAMath::Min(nThreads, GPU_THREADS),
+                                                     0,
+                                                     streams[iLayer].get()>>>(
       utils,
       multMask,
       iLayer,
@@ -921,7 +924,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
       resolutions[iLayer],
       radii[iLayer + 1] - radii[iLayer],
       mulScatAng[iLayer]);
-    gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1);
+    gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get());
   }
 }
 
@@ -956,45 +959,52 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    std::vector<float>& radii,
                                    bounded_vector<float>& mulScatAng,
                                    const int nBlocks,
-                                   const int nThreads)
+                                   const int nThreads,
+                                   gpu::Streams& streams)
 {
   for (int iLayer = 0; iLayer < nLayers - 1; ++iLayer) {
-    gpu::computeLayerTrackletsMultiROFKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS), o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(utils,
-                                                                                                                                                multMask,
-                                                                                                                                                iLayer,
-                                                                                                                                                startROF,
-                                                                                                                                                endROF,
-                                                                                                                                                maxROF,
-                                                                                                                                                deltaROF,
-                                                                                                                                                vertices,
-                                                                                                                                                rofPV,
-                                                                                                                                                nVertices,
-                                                                                                                                                vertexId,
-                                                                                                                                                clusters,
-                                                                                                                                                ROFClusters,
-                                                                                                                                                usedClusters,
-                                                                                                                                                clustersIndexTables,
-                                                                                                                                                tracklets,
-                                                                                                                                                trackletsLUTs,
-                                                                                                                                                iteration,
-                                                                                                                                                NSigmaCut,
-                                                                                                                                                phiCuts[iLayer],
-                                                                                                                                                resolutionPV,
-                                                                                                                                                minRs[iLayer + 1],
-                                                                                                                                                maxRs[iLayer + 1],
-                                                                                                                                                resolutions[iLayer],
-                                                                                                                                                radii[iLayer + 1] - radii[iLayer],
-                                                                                                                                                mulScatAng[iLayer]);
+    gpu::computeLayerTrackletsMultiROFKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
+                                                      o2::gpu::CAMath::Min(nThreads, GPU_THREADS),
+                                                      0,
+                                                      streams[iLayer].get()>>>(
+      utils,
+      multMask,
+      iLayer,
+      startROF,
+      endROF,
+      maxROF,
+      deltaROF,
+      vertices,
+      rofPV,
+      nVertices,
+      vertexId,
+      clusters,
+      ROFClusters,
+      usedClusters,
+      clustersIndexTables,
+      tracklets,
+      trackletsLUTs,
+      iteration,
+      NSigmaCut,
+      phiCuts[iLayer],
+      resolutionPV,
+      minRs[iLayer + 1],
+      maxRs[iLayer + 1],
+      resolutions[iLayer],
+      radii[iLayer + 1] - radii[iLayer],
+      mulScatAng[iLayer]);
     thrust::device_ptr<Tracklet> tracklets_ptr(spanTracklets[iLayer]);
-    thrust::sort(thrust::device, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::sort_tracklets());
-    auto unique_end = thrust::unique(thrust::device, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::equal_tracklets());
+    auto nosync_policy = THRUST_NAMESPACE::par_nosync.on(streams[iLayer].get());
+    thrust::sort(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::sort_tracklets());
+    auto unique_end = thrust::unique(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::equal_tracklets());
     nTracklets[iLayer] = unique_end - tracklets_ptr;
     if (iLayer > 0) {
-      GPUChkErrS(cudaMemset(trackletsLUTsHost[iLayer], 0, nClusters[iLayer] * sizeof(int)));
+      GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[iLayer], 0, nClusters[iLayer] * sizeof(int), streams[iLayer].get()));
       gpu::compileTrackletsLookupTableKernel<<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                               o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
-        spanTracklets[iLayer], trackletsLUTsHost[iLayer], nTracklets[iLayer]);
-      gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1);
+                                               o2::gpu::CAMath::Min(nThreads, GPU_THREADS),
+                                               0,
+                                               streams[iLayer].get()>>>(spanTracklets[iLayer], trackletsLUTsHost[iLayer], nTracklets[iLayer]);
+      gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get());
     }
   }
 }
@@ -1350,7 +1360,8 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                              std::vector<float>& radii,
                                              bounded_vector<float>& mulScatAng,
                                              const int nBlocks,
-                                             const int nThreads);
+                                             const int nThreads,
+                                             gpu::Streams& streams);
 
 template void computeTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                                const uint8_t* multMask,
@@ -1382,7 +1393,8 @@ template void computeTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                                std::vector<float>& radii,
                                                bounded_vector<float>& mulScatAng,
                                                const int nBlocks,
-                                               const int nThreads);
+                                               const int nThreads,
+                                               gpu::Streams& streams);
 
 template void processNeighboursHandler<7>(const int startLayer,
                                           const int startLevel,

From fdc30b14b75630ec1f6769a152852f3a9e3c8089 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <f3sch.git@outlook.com>
Date: Mon, 9 Jun 2025 11:35:44 +0200
Subject: [PATCH 0559/1764] ITS: add GPUTimer and use streams

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 211 ++++++++++--------
 1 file changed, 114 insertions(+), 97 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 13851b4cdc1aa..d5ea573a2f0e8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -14,6 +14,7 @@
 #include <thrust/execution_policy.h>
 
 #include "ITStracking/Constants.h"
+#include "ITStracking/BoundedAllocator.h"
 
 #include "ITStrackingGPU/Utils.h"
 #include "ITStrackingGPU/TimeFrameGPU.h"
@@ -21,6 +22,8 @@
 
 #include <unistd.h>
 #include <thread>
+#include <tuple>
+#include <vector>
 #include <fmt/format.h>
 
 #include "GPUCommonDef.h"
@@ -28,27 +31,6 @@
 #include "GPUCommonLogger.h"
 #include "GPUCommonHelpers.h"
 
-#ifdef ITS_MEASURE_GPU_TIME
-#define START_GPU_STREAM_TIMER(stream, name)        \
-  cudaEvent_t event_start, event_stop;              \
-  GPUChkErrS(cudaEventCreate(&event_start));        \
-  GPUChkErrS(cudaEventCreate(&event_stop));         \
-  GPUChkErrS(cudaEventRecord(event_start, stream)); \
-  const std::string task_name = name;
-
-#define STOP_GPU_STREAM_TIMER(stream)                                                \
-  GPUChkErrS(cudaEventRecord(event_stop, stream));                                   \
-  GPUChkErrS(cudaEventSynchronize(event_stop));                                      \
-  float ms;                                                                          \
-  GPUChkErrS(cudaEventElapsedTime(&ms, event_start, event_stop));                    \
-  std::cout << "Elapsed time for " << task_name << ": " << ms << " ms" << std::endl; \
-  GPUChkErrS(cudaEventDestroy(event_start));                                         \
-  GPUChkErrS(cudaEventDestroy(event_stop));
-#else
-#define START_GPU_STREAM_TIMER(stream, name)
-#define STOP_GPU_STREAM_TIMER(stream)
-#endif
-
 namespace o2
 {
 namespace its
@@ -59,6 +41,71 @@ using constants::MB;
 namespace gpu
 {
 
+#ifdef ITS_MEASURE_GPU_TIME
+class GPUTimer
+{
+ public:
+  GPUTimer(Streams& streams, const std::string& name)
+    : mName(name)
+  {
+    for (size_t i{0}; i < streams.size(); ++i) {
+      mStreams.push_back(streams[i].get());
+    }
+    startTimers();
+  }
+  GPUTimer(Streams& streams, const std::string& name, size_t end, size_t start = 0)
+    : mName(name)
+  {
+    for (size_t sta{start}; sta < end; ++sta) {
+      mStreams.push_back(streams[sta].get());
+    }
+    startTimers();
+  }
+  GPUTimer(Stream& stream, const std::string& name)
+    : mName(name)
+  {
+    mStreams.push_back(stream.get());
+    startTimers();
+  }
+  ~GPUTimer()
+  {
+    for (size_t i{0}; i < mStreams.size(); ++i) {
+      GPUChkErrS(cudaEventRecord(mStops[i], mStreams[i]));
+      GPUChkErrS(cudaEventSynchronize(mStops[i]));
+      float ms = 0.0f;
+      GPUChkErrS(cudaEventElapsedTime(&ms, mStarts[i], mStops[i]));
+      LOGP(info, "Elapsed time for {}:{} {} ms", mName, i, ms);
+      GPUChkErrS(cudaEventDestroy(mStarts[i]));
+      GPUChkErrS(cudaEventDestroy(mStops[i]));
+    }
+  }
+
+  void startTimers()
+  {
+    mStarts.resize(mStreams.size());
+    mStops.resize(mStreams.size());
+    for (size_t i{0}; i < mStreams.size(); ++i) {
+      GPUChkErrS(cudaEventCreate(&mStarts[i]));
+      GPUChkErrS(cudaEventCreate(&mStops[i]));
+      GPUChkErrS(cudaEventRecord(mStarts[i], mStreams[i]));
+    }
+  }
+
+ private:
+  std::string mName;
+  std::vector<cudaEvent_t> mStarts, mStops;
+  std::vector<cudaStream_t> mStreams;
+};
+#else // ITS_MEASURE_GPU_TIME not defined
+class GPUTimer
+{
+ public:
+  GPUTimer(Stream&, const std::string&) {}
+  GPUTimer(Streams&, const std::string&) {}
+  GPUTimer(Streams&, const std::string&, int, int = 0) {}
+};
+#endif
+
 template <int nLayers>
 TimeFrameGPU<nLayers>::TimeFrameGPU()
 {
@@ -88,21 +135,20 @@ void TimeFrameGPU<nLayers>::setDevicePropagator(const o2::base::PropagatorImpl<f
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading indextable utils");
+  GPUTimer timer(mGpuStreams[0], "loading indextable utils");
   if (!iteration) {
     LOGP(debug, "gpu-allocation: allocating IndexTableUtils buffer, for {} MB.", sizeof(IndexTableUtils) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), mGpuStreams[0], this->getExtAllocator());
   }
   LOGP(debug, "gpu-transfer: loading IndexTableUtils object, for {} MB.", sizeof(IndexTableUtils) / MB);
   GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading unsorted clusters");
+    GPUTimer timer(mGpuStreams[0], "loading unsorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} unsorted clusters on layer {}, for {} MB.", this->mUnsortedClusters[iLayer].size(), iLayer, this->mUnsortedClusters[iLayer].size() * sizeof(Cluster) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[0], this->getExtAllocator());
@@ -112,7 +158,6 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
     allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
@@ -120,7 +165,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading sorted clusters");
+    GPUTimer timer(mGpuStreams[0], "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} clusters on layer {}, for {} MB.", this->mClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(Cluster) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), this->mClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[0], this->getExtAllocator());
@@ -130,7 +175,6 @@ void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
     allocMemAsync(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
@@ -138,7 +182,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading sorted clusters");
+    GPUTimer timer(mGpuStreams[0], "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading clusters indextable for layer {} with {} elements, for {} MB.", iLayer, this->mIndexTables[iLayer].size(), this->mIndexTables[iLayer].size() * sizeof(int) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), this->mIndexTables[iLayer].size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
@@ -146,7 +190,6 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
     }
     allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
@@ -154,7 +197,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating used clusters flags");
+    GPUTimer timer(mGpuStreams[0], "creating used clusters flags");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: creating {} used clusters flags on layer {}, for {} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0], this->getExtAllocator());
@@ -162,26 +205,24 @@ void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
     }
     allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadUsedClustersDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading used clusters flags");
+  GPUTimer timer(mGpuStreams[0], "loading used clusters flags");
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} used clusters flags on layer {}, for {} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(unsigned char) / MB);
     GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading ROframe clusters");
+    GPUTimer timer(mGpuStreams[0], "loading ROframe clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} ROframe clusters info on layer {}, for {} MB.", this->mROFramesClusters[iLayer].size(), iLayer, this->mROFramesClusters[iLayer].size() * sizeof(int) / MB);
       allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), this->mROFramesClusters[iLayer].size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
@@ -189,14 +230,13 @@ void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
     }
     allocMemAsync(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading trackingframeinfo");
+  GPUTimer timer(mGpuStreams[0], "loading trackingframeinfo");
   if (!iteration) {
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       LOGP(debug, "gpu-transfer: loading {} tfinfo on layer {}, for {} MB.", this->mTrackingFrameInfo[iLayer].size(), iLayer, this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / MB);
@@ -208,18 +248,16 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
     GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading multiplicity cut mask");
+    GPUTimer timer(mGpuStreams[0], "loading multiplicity cut mask");
     LOGP(debug, "gpu-transfer: loading multiplicity cut mask with {} elements, for {} MB.", this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(bool) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
@@ -227,81 +265,76 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
 {
   if (!iteration) {
-    START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading seeding vertices");
+    GPUTimer timer(mGpuStreams[0], "loading seeding vertices");
     LOGP(debug, "gpu-transfer: loading {} ROframes vertices, for {} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     LOGP(debug, "gpu-transfer: loading {} seeding vertices, for {} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / MB);
     allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating tracklets LUTs");
+  GPUTimer timer(mGpuStreams, "creating tracklets LUTs", nLayers - 1);
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     if (!iteration) {
       LOGP(debug, "gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {} MB.", this->mClusters[iLayer].size() + 1, iLayer, (this->mClusters[iLayer].size() + 1) * sizeof(int) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
     }
-    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
   }
   if (!iteration) {
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsBuffers()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells buffers");
+  GPUTimer timer(mGpuStreams, "creating cells buffers", nLayers - 1);
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     mNTracklets[iLayer] = 0;
     GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + this->mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost));
     LOGP(debug, "gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {} MB.", mNTracklets[iLayer], iLayer, mNTracklets[iLayer] * sizeof(Tracklet) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), mGpuStreams[0], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), mGpuStreams[iLayer], this->getExtAllocator());
   }
   allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackletsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading tracklets");
+  GPUTimer timer(mGpuStreams, "loading tracklets", nLayers - 1);
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} tracklets on layer {}, for {} MB.", this->mTracklets[iLayer].size(), iLayer, this->mTracklets[iLayer].size() * sizeof(Tracklet) / MB);
     GPUChkErrS(cudaHostRegister(this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading tracklets");
+  GPUTimer timer(mGpuStreams, "loading tracklets", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {} MB", this->mTrackletsLookupTable[iLayer].size(), iLayer + 1, this->mTrackletsLookupTable[iLayer].size() * sizeof(int) / MB);
     GPUChkErrS(cudaHostRegister(this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice));
+    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
   GPUChkErrS(cudaHostRegister(mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells neighbours");
+  GPUTimer timer(mGpuStreams[0], "creating cells neighbours");
   // Here we do also the creation of the CellsDeviceArray, as the cells buffers are populated separately in the previous steps.
   allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaHostRegisterPortable));
@@ -314,76 +347,70 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
       mNNeighbours[iLayer] = 0;
     }
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const unsigned int nCells)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighboursLUT");
+  GPUTimer timer(mGpuStreams[0], "reserving neighboursLUT");
   LOGP(debug, "gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator()); // We need one element more to move exc -> inc
   GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadCellsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading cell seeds");
+  GPUTimer timer(mGpuStreams, "loading cell seeds", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading {} cell seeds on layer {}, for {} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeed) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator()); // accessory for the neigh. finding.
-    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[0].get()));
-    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeed), mGpuStreams[iLayer], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator()); // accessory for the neigh. finding.
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
   allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells LUTs");
+  GPUTimer timer(mGpuStreams, "creating cells LUTs", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: creating cell LUT for {} elements on layer {}, for {} MB.", mNTracklets[iLayer] + 1, iLayer, (mNTracklets[iLayer] + 1) * sizeof(int) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-    GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
+    allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
+    GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer].get()));
   }
   allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "creating cells buffers");
+  GPUTimer timer(mGpuStreams[0], "creating cells buffers");
   mNCells[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost));
   LOGP(debug, "gpu-transfer: creating cell buffer for {} elements on layer {}, for {} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
-
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading cells LUTs");
+  GPUTimer timer(mGpuStreams, "loading cells LUTs", nLayers - 3);
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: loading cell LUT for {} elements on layer {}, for {} MB.", this->mCellsLookupTable[iLayer].size(), iLayer, this->mCellsLookupTable[iLayer].size() * sizeof(int) / MB);
     GPUChkErrS(cudaHostRegister(this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadRoadsDevice()
 {
+  GPUTimer timer(mGpuStreams[0], "loading roads device");
   LOGP(debug, "gpu-transfer: loading {} roads, for {} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
@@ -393,30 +420,28 @@ void TimeFrameGPU<nLayers>::loadRoadsDevice()
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "loading track seeds");
+  GPUTimer timer(mGpuStreams[0], "loading track seeds");
   LOGP(debug, "gpu-transfer: loading {} track seeds, for {} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, const unsigned int nNeighbours)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
+  GPUTimer timer(mGpuStreams[0], "reserving neighbours");
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, std::vector<std::pair<int, int>>& neighbours)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
+  GPUTimer timer(mGpuStreams[0], "reserving neighbours");
   this->mCellsNeighbours[layer].clear();
   this->mCellsNeighbours[layer].resize(neighbours.size());
   LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
@@ -424,58 +449,53 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, std
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
   LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDeviceArray()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving neighbours");
+  GPUTimer timer(mGpuStreams[0], "reserving neighbours");
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "reserving tracks");
+  GPUTimer timer(mGpuStreams[0], "reserving tracks");
   mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
   LOGP(debug, "gpu-allocation: reserving {} tracks, for {} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0].get()));
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading cells");
+  GPUTimer timer(mGpuStreams, "downloading cells", nLayers - 2);
   for (int iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading {} cells on layer: {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
     this->mCells[iLayer].resize(mNCells[iLayer]);
-    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading cell luts");
+  GPUTimer timer(mGpuStreams, "downloading cell luts", nLayers - 3);
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
     LOGP(debug, "gpu-transfer: downloading cells lut on layer {} for {} elements", iLayer, (mNTracklets[iLayer + 1] + 1));
     this->mCellsLookupTable[iLayer].resize(mNTracklets[iLayer + 1] + 1);
-    GPUChkErrS(cudaMemcpyAsync(this->mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpyAsync(this->mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
   }
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>& neighbours, const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), fmt::format("downloading neighbours from layer {}", layer));
+  GPUTimer timer(mGpuStreams[0], fmt::format("downloading neighbours from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading {} neighbours, for {} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / MB);
   // TODO: something less dangerous than assuming the same memory layout of std::pair and gpuPair... or not? :)
   GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
@@ -484,31 +504,28 @@ void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<bounded_ve
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut, const int layer)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), fmt::format("downloading neighbours LUT from layer {}", layer));
+  GPUTimer timer(mGpuStreams[0], fmt::format("downloading neighbours LUT from layer {}", layer));
   LOGP(debug, "gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {} MB.", lut.size(), layer, lut.size() * sizeof(int) / MB);
   GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "downloading tracks");
+  GPUTimer timer(mGpuStreams[0], "downloading tracks");
   LOGP(debug, "gpu-transfer: downloading {} tracks, for {} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / MB);
   GPUChkErrS(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
   GPUChkErrS(cudaHostUnregister(mTrackITSExt.data()));
   GPUChkErrS(cudaHostUnregister(seeds.data()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterRest()
 {
-  START_GPU_STREAM_TIMER(mGpuStreams[0].get(), "unregistering rest of the host memory");
+  GPUTimer timer(mGpuStreams[0], "unregistering rest of the host memory");
   LOGP(debug, "unregistering rest of the host memory...");
   GPUChkErrS(cudaHostUnregister(mCellsDevice.data()));
   GPUChkErrS(cudaHostUnregister(mTrackletsDevice.data()));
-  STOP_GPU_STREAM_TIMER(mGpuStreams[0].get());
 }
 
 template <int nLayers>

From 4cfc7e41b257c04ab83ecc641296f4d92bd0f622 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 1 Jul 2025 21:51:22 +0200
Subject: [PATCH 0560/1764] DPL: make sure devices with Sporadic inputs get
 sorted last, if possible (#14459)

---
 Framework/Core/src/TopologyPolicy.cxx | 81 +++++++++++++++++++++++++--
 1 file changed, 77 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/TopologyPolicy.cxx b/Framework/Core/src/TopologyPolicy.cxx
index e209c2702031e..5458d9d65da4a 100644
--- a/Framework/Core/src/TopologyPolicy.cxx
+++ b/Framework/Core/src/TopologyPolicy.cxx
@@ -69,6 +69,40 @@ bool dataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
   return false;
 }
 
+// This is to make sure that if a device has sporadic / timer inputs
+// it gets sorted after one which does not, in case there is no other
+// dependencies between the two.
+bool sporadicDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
+{
+  auto checkSporadic = [](InputSpec const& input) {
+    return input.lifetime == Lifetime::Sporadic;
+  };
+  bool isBWithSporadicInput = std::find_if(b.inputs.begin(), b.inputs.end(), checkSporadic) != b.inputs.end();
+  bool isAWithSporadicInput = std::find_if(a.inputs.begin(), a.inputs.end(), checkSporadic) != a.inputs.end();
+  // If neither has sporadic inputs, we return false and sort as usual
+  if (!isAWithSporadicInput && !isBWithSporadicInput) {
+    return false;
+  }
+  // If both have sporadic inputs, we return false and sort as usual.
+  if (isAWithSporadicInput && isBWithSporadicInput) {
+    return false;
+  }
+  // If a has sporadic inputs
+  if (isAWithSporadicInput && isBWithSporadicInput) {
+    return false;
+  }
+
+  // We have a with sporadic inputs. We sort it later, unless there was already some actual
+  // dependency between A and B.
+  if (isAWithSporadicInput) {
+    bool hasDependency = dataDeps(b, a);
+    return !hasDependency;
+  }
+
+  // b is has sporadic inputs and a does not. We are fine as it is.
+  return false;
+}
+
 bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
 {
   O2_SIGNPOST_ID_GENERATE(sid, topology);
@@ -93,7 +127,7 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
     return true;
   }
   // If we are here we do not have any data dependency,
-  // however we strill consider a dependent on b if
+  // however we still consider a dependent on b if
   // a has the "expendable" label and b does not.
   auto checkExpendable = [](DataProcessorLabel const& label) {
     if (label.value == "expendable") {
@@ -108,26 +142,45 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
     }
     return false;
   };
+
   bool isBExpendable = std::find_if(b.labels.begin(), b.labels.end(), checkExpendable) != b.labels.end();
   bool isAExpendable = std::find_if(a.labels.begin(), a.labels.end(), checkExpendable) != a.labels.end();
   bool bResilient = std::find_if(b.labels.begin(), b.labels.end(), checkResilient) != b.labels.end();
 
   // If none is expendable. We simply return false and sort as usual.
   if (!isAExpendable && !isBExpendable) {
+    bool sporadic = sporadicDataDeps(a, b);
+    if (sporadic) {
+      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. Neither %s nor %s are expendable. However the former has sporadic inputs so we sort it after.",
+                      a.name.c_str(), b.name.c_str());
+      return true;
+    }
     O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. Neither %s nor %s are expendable. No dependency beyond data deps.",
                     a.name.c_str(), b.name.c_str());
     return false;
   }
   // If both are expendable. We return false and sort as usual.
   if (isAExpendable && isBExpendable) {
+    bool sporadic = sporadicDataDeps(a, b);
+    if (sporadic) {
+      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. Both %s and %s are expendable. However the former has sporadic inputs, so we sort it after.",
+                      a.name.c_str(), b.name.c_str());
+      return true;
+    }
     O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. Both %s and %s are expendable. No dependency.",
                     a.name.c_str(), b.name.c_str());
     return false;
   }
 
-  // If b is expendable but b is resilient, we can keep the same order.
+  // If a is expendable but b is resilient, we can keep the same order.
   if (isAExpendable && bResilient) {
-    O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. %s is expendable but %s is resilient, no need to add an unneeded dependency",
+    bool sporadic = sporadicDataDeps(a, b);
+    if (sporadic) {
+      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. %s is expendable but %s is resilient, however the former also has sporadic inputs, so we sort it after.",
+                      a.name.c_str(), b.name.c_str());
+      return true;
+    }
+    O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. %s is expendable but %s is resilient. No need to do do anything.",
                     a.name.c_str(), b.name.c_str());
     return false;
   }
@@ -138,11 +191,31 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
     O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "%s is expendable. %s from %s to %s => %s.",
                     a.name.c_str(), hasDependency ? "There is however an inverse dependency" : "No inverse dependency", b.name.c_str(), a.name.c_str(),
                     !hasDependency ? "true" : "false");
-    return !hasDependency;
+    if (!hasDependency) {
+      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "%s is expendable. There is however an inverse dependecy from %s to %s => true.",
+                      a.name.c_str(), b.name.c_str(), a.name.c_str());
+      return true;
+    }
+    bool sporadic = sporadicDataDeps(a, b);
+    if (sporadic) {
+      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "%s is expendable. No inverse dependency from %s to %s. However the former has an occasioanl input => true.",
+                      a.name.c_str(), b.name.c_str(), a.name.c_str());
+    }
+    O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "%s is expendable. No inverse dependency from %s to %s => false.",
+                    a.name.c_str(), b.name.c_str(), a.name.c_str());
+    return false;
+  }
+  // b is expendable and a is not. We are fine with no dependency.
+  bool sporadic = sporadicDataDeps(a, b);
+  if (sporadic) {
+    O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. %s is expendable but %s is not. However the former has an sporadic input => true.",
+                    b.name.c_str(), a.name.c_str());
+    return true;
   }
   // b is expendable and a is not. We are fine with no dependency.
   O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. %s is expendable but %s is not. No need to add an unneeded dependency.",
                   b.name.c_str(), a.name.c_str());
+
   return false;
 };
 

From bf8eb6f134eea9d19ac81a2832d6bb1e95cdcb8d Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <weiglhofer@fias.uni-frankfurt.de>
Date: Tue, 1 Jul 2025 16:55:10 +0200
Subject: [PATCH 0561/1764] OpenCL: Propagate number of host threads to PoCL
 runtime.

---
 GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index ce05e159461e5..49533216869d2 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -63,6 +63,13 @@ int32_t GPUReconstructionOCL::GPUChkErrInternal(const int64_t error, const char*
 
 int32_t GPUReconstructionOCL::InitDevice_Runtime()
 {
+  // Propagate processing settings to PoCL runtime.
+  // Won't affect other OpenCL runtimes.
+  if (int nThreads = mProcessingSettings->nHostThreads; nThreads > 0) {
+    auto nThreadsStr = std::to_string(nThreads);
+    setenv("POCL_CPU_MAX_CU_COUNT", nThreadsStr.c_str(), 1);
+  }
+
   if (mMaster == nullptr) {
     cl_int ocl_error;
     cl_uint num_platforms;

From 678b1ae8cb1592f5511357a928a212c99479a5c2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 2 Jul 2025 18:25:54 +0200
Subject: [PATCH 0562/1764] GPU Display: Fix typo in Vulkan version check

---
 GPU/GPUTracking/display/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index 3280a0655ce9f..25b028d573bcf 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -32,7 +32,7 @@ endif()
 
 if(Vulkan_FOUND)
   string(FIND "${Vulkan_VERSION}" "." vulkan_dot_index)
-  if(NOT ${Vulkan_VERSION} VERSION_GREATER_EQUAL "1.3.0" OR dot_index EQUAL -1 OR Vulkan_GLSLC_EXECUTABLE STREQUAL "Vulkan_GLSLC_EXECUTABLE-NOTFOUND")
+  if(NOT ${Vulkan_VERSION} VERSION_GREATER_EQUAL "1.3.0" OR vulkan_dot_index EQUAL -1 OR Vulkan_GLSLC_EXECUTABLE STREQUAL "Vulkan_GLSLC_EXECUTABLE-NOTFOUND")
     set(Vulkan_FOUND 0)
   endif()
 endif()

From af304dee4ac1ca8b5d7e32cf7a7bdd5b7b752b54 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 2 Jul 2025 21:58:07 +0200
Subject: [PATCH 0563/1764] DPL: add signposts replacement for LOG(alarm) /
 LOG(important) (#14468)

---
 .../Foundation/include/Framework/Signpost.h   | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/Framework/Foundation/include/Framework/Signpost.h b/Framework/Foundation/include/Framework/Signpost.h
index 53cc4d914a73b..781a2242375c8 100644
--- a/Framework/Foundation/include/Framework/Signpost.h
+++ b/Framework/Foundation/include/Framework/Signpost.h
@@ -562,6 +562,26 @@ void o2_debug_log_set_stacktrace(_o2_log_t* log, int stacktrace)
   O2_LOG_MACRO_RAW(critical, remove_engineering_type(format).data(), ##__VA_ARGS__);                                \
 })
 
+// Similar to the above, however it will also print a normal alarm message regardless of the signpost being enabled or not.
+#define O2_SIGNPOST_EVENT_EMIT_ALARM(log, id, name, format, ...) __extension__({                                    \
+  if (O2_BUILTIN_UNLIKELY(O2_SIGNPOST_ENABLED_MAC(log))) {                                                          \
+    O2_SIGNPOST_EVENT_EMIT_MAC(log, id, name, format, ##__VA_ARGS__);                                               \
+  } else if (O2_BUILTIN_UNLIKELY(private_o2_log_##log->stacktrace)) {                                               \
+    _o2_signpost_event_emit(private_o2_log_##log, id, name, remove_engineering_type(format).data(), ##__VA_ARGS__); \
+  }                                                                                                                 \
+  O2_LOG_MACRO_RAW(alarm, remove_engineering_type(format).data(), ##__VA_ARGS__);                                   \
+})
+
+// Similar to the above, however it will also print a normal alarm message regardless of the signpost being enabled or not.
+#define O2_SIGNPOST_EVENT_EMIT_IMPORTANT(log, id, name, format, ...) __extension__({                                \
+  if (O2_BUILTIN_UNLIKELY(O2_SIGNPOST_ENABLED_MAC(log))) {                                                          \
+    O2_SIGNPOST_EVENT_EMIT_MAC(log, id, name, format, ##__VA_ARGS__);                                               \
+  } else if (O2_BUILTIN_UNLIKELY(private_o2_log_##log->stacktrace)) {                                               \
+    _o2_signpost_event_emit(private_o2_log_##log, id, name, remove_engineering_type(format).data(), ##__VA_ARGS__); \
+  }                                                                                                                 \
+  O2_LOG_MACRO_RAW(important, remove_engineering_type(format).data(), ##__VA_ARGS__);                               \
+})
+
 #define O2_SIGNPOST_START(log, id, name, format, ...)                                                                   \
   if (O2_BUILTIN_UNLIKELY(O2_SIGNPOST_ENABLED_MAC(log))) {                                                              \
     O2_SIGNPOST_START_MAC(log, id, name, format, ##__VA_ARGS__);                                                        \

From 76543b9985775e548a9bcc0c2b7de0858ac1c41a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 2 Jul 2025 12:26:29 +0200
Subject: [PATCH 0564/1764] Reset ITS tracks ROF counters if not tracks found

---
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 15348bca9fde7..4f4941aca9f4d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -377,6 +377,11 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
           allTracks.emplace_back(trc);
         }
       }
+    } else {
+      for (auto& r : trackROFvec) { // reset data copied from the clusters
+        r.setFirstEntry(0);
+        r.setNEntries(0);
+      }
     }
     LOGP(info, "ITSTracker pushed {} tracks and {} vertices", allTracks.size(), vertices.size());
     if (mIsMC) {

From 5b28f57c3d9bf060c980374ec3203f185dc414c4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 1 Jul 2025 09:56:35 +0200
Subject: [PATCH 0565/1764] CommonUtils: Don't use ROOT TGrid if we build
 standalone benchmark

---
 Common/Utils/CMakeLists.txt                             | 2 +-
 Common/Utils/include/CommonUtils/StringUtils.h          | 3 +--
 Common/Utils/src/StringUtils.cxx                        | 5 +++++
 GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx | 6 ++----
 4 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/Common/Utils/CMakeLists.txt b/Common/Utils/CMakeLists.txt
index 18f2aa7c1b6ed..def743d11791c 100644
--- a/Common/Utils/CMakeLists.txt
+++ b/Common/Utils/CMakeLists.txt
@@ -26,7 +26,7 @@ o2_add_library(CommonUtils
                        src/DebugStreamer.cxx
                        src/DLLoaderBase.cxx
                PUBLIC_LINK_LIBRARIES ROOT::Hist ROOT::Tree Boost::iostreams O2::CommonDataFormat O2::Headers
-                                     FairLogger::FairLogger O2::MathUtils TBB::tbb)
+                                     FairLogger::FairLogger O2::MathUtils TBB::tbb O2::GPUCommon)
 
 o2_target_root_dictionary(CommonUtils
                           HEADERS include/CommonUtils/TreeStream.h
diff --git a/Common/Utils/include/CommonUtils/StringUtils.h b/Common/Utils/include/CommonUtils/StringUtils.h
index c68e441d5b1c4..710632fc7dbfe 100644
--- a/Common/Utils/include/CommonUtils/StringUtils.h
+++ b/Common/Utils/include/CommonUtils/StringUtils.h
@@ -20,8 +20,7 @@
 #include <sstream>
 #include <vector>
 #include <algorithm>
-#include <fmt/format.h>
-#include <Rtypes.h>
+#include "GPUCommonRtypes.h"
 
 namespace o2
 {
diff --git a/Common/Utils/src/StringUtils.cxx b/Common/Utils/src/StringUtils.cxx
index 4c0dd30ae6211..687225d069ed2 100644
--- a/Common/Utils/src/StringUtils.cxx
+++ b/Common/Utils/src/StringUtils.cxx
@@ -12,7 +12,10 @@
 #include "CommonUtils/StringUtils.h"
 #include <cstdlib>
 #include <filesystem>
+#ifndef GPUCA_STANDALONE
 #include <TGrid.h>
+#include <fmt/format.h>
+#endif
 #include <unistd.h>
 
 using namespace o2::utils;
@@ -77,6 +80,7 @@ std::string Str::getFullPath(const std::string_view p)
   return std::filesystem::canonical(std::string{p}).string();
 }
 
+#ifndef GPUCA_STANDALONE
 std::string Str::rectifyDirectory(const std::string_view p)
 {
   std::string dir(p);
@@ -104,6 +108,7 @@ std::string Str::rectifyDirectory(const std::string_view p)
   }
   return dir;
 }
+#endif
 
 // Create unique non-existing path name starting with prefix. Loose equivalent of boost::filesystem::unique_path()
 // The prefix can be either existing directory or just a string to add in front of the random part
diff --git a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
index 4e093da5d2cf6..1f6d6709e0ab0 100644
--- a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
+++ b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
@@ -9,16 +9,14 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#ifndef GPUCA_NO_VC
+#ifndef GPUCA_STANDALONE
 #include "Rtypes.h"
+#include "TFile.h"
 #endif
 #include "CalibdEdxTrackTopologyPol.h"
 
 #include <cstddef>
 #include <string_view>
-#if !defined(GPUCA_STANDALONE)
-#include "TFile.h"
-#endif
 
 using namespace o2::tpc;
 

From 925c580e1275856021d24b9f6ffed0c982d7384b Mon Sep 17 00:00:00 2001
From: Jan Fiete <jgrosseo@cern.ch>
Date: Thu, 3 Jul 2025 09:15:01 +0200
Subject: [PATCH 0566/1764] Fix bug in weight filling (#14461)

---
 Framework/Core/src/StepTHn.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/StepTHn.cxx b/Framework/Core/src/StepTHn.cxx
index a091c304f425a..ac5da966f6ad4 100644
--- a/Framework/Core/src/StepTHn.cxx
+++ b/Framework/Core/src/StepTHn.cxx
@@ -441,7 +441,7 @@ void StepTHn::Fill(int iStep, int nParams, double positionAndWeight[])
   if (weight != 1.) {
     // initialize with already filled entries (which have been filled with weight == 1), in this case mSumw2 := mValues
     if (!mSumw2[iStep]) {
-      mSumw2[iStep] = createArray();
+      mSumw2[iStep] = createArray(mValues[iStep]);
       LOGF(info, "Created sumw2 container for step %d", iStep);
     }
   }
@@ -449,7 +449,7 @@ void StepTHn::Fill(int iStep, int nParams, double positionAndWeight[])
   // TODO probably slow; add StepTHnT::add ?
   mValues[iStep]->SetAt(mValues[iStep]->GetAt(bin) + weight, bin);
   if (mSumw2[iStep]) {
-    mSumw2[iStep]->SetAt(mSumw2[iStep]->GetAt(bin) + weight, bin);
+    mSumw2[iStep]->SetAt(mSumw2[iStep]->GetAt(bin) + weight * weight, bin);
   }
 }
 

From 9fa8cf58b183291ca50ac46f19c23105a4787879 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 2 Jul 2025 23:05:54 +0200
Subject: [PATCH 0567/1764] =?UTF-8?q?GPU=20QA:=20Add=20Correctly=20Attache?=
 =?UTF-8?q?d=20non-fake=20normalized=20cluster=20count=C2=A7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 GPU/GPUTracking/qa/GPUQA.cxx | 58 ++++++++++++++++++++++++++++--------
 GPU/GPUTracking/qa/GPUQA.h   |  2 +-
 2 files changed, 47 insertions(+), 13 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index e65246968cefa..b32ef80c7c87a 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -1660,6 +1660,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
 
   if (mQATasks & taskTrackStatistics) {
     // Fill track statistic histograms
+    std::vector<std::array<float, 2>> clusterAttachCounts;
+    if (mcAvail) {
+      clusterAttachCounts.resize(GetNMCLabels(), {0.f, 0.f});
+    }
     for (uint32_t i = 0; i < nReconstructedTracks; i++) {
       const GPUTPCGMMergedTrack& track = mTracking->mIOPtrs.mergedTracks[i];
       if (!track.OK()) {
@@ -1668,21 +1672,38 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       mTracks->Fill(1.f / fabsf(track.GetParam().GetQPt()));
       mNCl[0]->Fill(track.NClustersFitted());
       uint32_t nClCorrected = 0;
-      int32_t lastSector = -1, lastRow = -1;
       const auto& trackClusters = mTracking->mIOPtrs.mergedTrackHits;
-      for (uint32_t j = 0; j < track.NClusters(); j++) {
-        if (trackClusters[track.FirstClusterRef() + j].state & GPUTPCGMMergedTrackHit::flagReject) {
-          continue;
+      uint32_t jNext = 0;
+      for (uint32_t j = 0; j < track.NClusters(); j = jNext) {
+        uint32_t rowClCount = !(trackClusters[track.FirstClusterRef() + j].state & GPUTPCGMMergedTrackHit::flagReject);
+        for (jNext = j + 1; j < track.NClusters(); jNext++) {
+          if (trackClusters[track.FirstClusterRef() + j].sector != trackClusters[track.FirstClusterRef() + jNext].sector || trackClusters[track.FirstClusterRef() + j].row != trackClusters[track.FirstClusterRef() + jNext].row) {
+            break;
+          }
+          rowClCount += !(trackClusters[track.FirstClusterRef() + jNext].state & GPUTPCGMMergedTrackHit::flagReject);
         }
-        if (trackClusters[track.FirstClusterRef() + j].sector == lastSector && trackClusters[track.FirstClusterRef() + j].row == lastRow) {
-          continue;
+        if (trackClusters[track.FirstClusterRef() + j].leg == trackClusters[track.FirstClusterRef() + track.NClusters() - 1].leg && rowClCount) {
+          nClCorrected++;
         }
-        if (trackClusters[track.FirstClusterRef() + j].leg != trackClusters[track.FirstClusterRef() + track.NClusters() - 1].leg) {
-          continue;
+        if (mcAvail && rowClCount) {
+          for (uint32_t k = j; k < jNext; k++) {
+            const auto& cl = trackClusters[track.FirstClusterRef() + k];
+            if (cl.state & GPUTPCGMMergedTrackHit::flagReject) {
+              continue;
+            }
+            bool labelOk = false;
+            if (mTrackMCLabels[i].isValid() && !mTrackMCLabels[i].isFake()) {
+              for (int32_t l = 0; l < GetMCLabelNID(cl.num); l++) {
+                if (GetMCLabel(cl.num, l) == mTrackMCLabels[i]) {
+                  labelOk = true;
+                  break;
+                }
+              }
+            }
+            clusterAttachCounts[cl.num][0] += (float)labelOk / rowClCount;
+            clusterAttachCounts[cl.num][1] += 1.0f;
+          }
         }
-        nClCorrected++;
-        lastSector = trackClusters[track.FirstClusterRef() + j].sector;
-        lastRow = trackClusters[track.FirstClusterRef() + j].sector;
       }
       mNCl[1]->Fill(nClCorrected);
     }
@@ -1699,6 +1720,16 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
     }
+    if (mcAvail) {
+      double clusterAttachNormalizedCount = 0;
+      for (uint32_t i = 0; i < clusterAttachCounts.size(); i++) {
+        if (clusterAttachCounts[i][1]) {
+          clusterAttachNormalizedCount += clusterAttachCounts[i][0] / clusterAttachCounts[i][1];
+        }
+      }
+      mClusterCounts.nCorrectlyAttachedNormalized = clusterAttachNormalizedCount;
+      clusterAttachCounts.clear();
+    }
 
     if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
       GPUInfo("QA Time: Fill track statistics:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
@@ -2824,7 +2855,7 @@ void GPUQA::PrintClusterCount(int32_t mode, int32_t& num, const char* name, uint
     createHist(mHistClusterCount[num], name2, name, 1000, 0, mConfig.histMaxNClusters, 1000, 0, 100);
   } else if (mode == 0) {
     if (normalization && mConfig.enableLocalOutput) {
-      printf("\t%35s: %'12" PRIu64 " (%6.2f%%)\n", name, n, 100.f * n / normalization);
+      printf("\t%40s: %'12" PRIu64 " (%6.2f%%)\n", name, n, 100.f * n / normalization);
     }
     if (mConfig.clusterRejectionHistograms) {
       float ratio = 100.f * n / std::max<uint64_t>(normalization, 1);
@@ -2869,6 +2900,9 @@ int32_t GPUQA::DoClusterCounts(uint64_t* attachClusterCounts, int32_t mode)
     PrintClusterCount(mode, num, "Tracks < 40 MeV", mClusterCounts.nBelow40, mClusterCounts.nTotal);
     PrintClusterCount(mode, num, "Fake Protect (< 40 MeV)", mClusterCounts.nFakeProtect40, mClusterCounts.nBelow40);
   }
+  if (mcPresent() && (mQATasks & taskTrackStatistics)) {
+    PrintClusterCount(mode, num, "Correctly Attached non-fake normalized", mClusterCounts.nCorrectlyAttachedNormalized, mClusterCounts.nTotal);
+  }
   return num;
 }
 
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 3d5030e20dba5..9e137f6a6b34c 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -290,7 +290,7 @@ class GPUQA
   TLegend* mLClust[N_CLS_TYPE];
 
   struct counts_t {
-    int64_t nRejected = 0, nTube = 0, nTube200 = 0, nLoopers = 0, nLowPt = 0, n200MeV = 0, nPhysics = 0, nProt = 0, nUnattached = 0, nTotal = 0, nHighIncl = 0, nAbove400 = 0, nFakeRemove400 = 0, nFullFakeRemove400 = 0, nBelow40 = 0, nFakeProtect40 = 0, nMergedLooper = 0;
+    int64_t nRejected = 0, nTube = 0, nTube200 = 0, nLoopers = 0, nLowPt = 0, n200MeV = 0, nPhysics = 0, nProt = 0, nUnattached = 0, nTotal = 0, nHighIncl = 0, nAbove400 = 0, nFakeRemove400 = 0, nFullFakeRemove400 = 0, nBelow40 = 0, nFakeProtect40 = 0, nMergedLooper = 0, nCorrectlyAttachedNormalized = 0;
     double nUnaccessible = 0;
   } mClusterCounts;
 

From e629c0a34361a178a722b1ed56a15f2aaf10a2a2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 2 Jul 2025 18:40:57 +0200
Subject: [PATCH 0568/1764] GPU Standalone CI: Test also build without
 ROOT/VC/FMT/ONNX

---
 GPU/GPUTracking/Standalone/cmake/build.sh | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/GPU/GPUTracking/Standalone/cmake/build.sh b/GPU/GPUTracking/Standalone/cmake/build.sh
index 2698a5bad3950..cf03539d5c3f4 100755
--- a/GPU/GPUTracking/Standalone/cmake/build.sh
+++ b/GPU/GPUTracking/Standalone/cmake/build.sh
@@ -19,4 +19,16 @@ EOF
 fi
 cmake -DCMAKE_INSTALL_PREFIX=../ $1/GPU/GPUTracking/Standalone
 make ${JOBS+-j $JOBS} install
+if [[ $GPUCA_STANDALONE_CI == 1 ]]; then
+  cat >> config.cmake << "EOF"
+  set(ENABLE_CUDA 0)
+  set(ENABLE_HIP 0)
+  set(ENABLE_OPENCL 0)
+  set(GPUCA_CONFIG_ONNX 0)
+  set(GPUCA_CONFIG_VC 0)
+  set(GPUCA_CONFIG_FMT 0)
+  set(GPUCA_CONFIG_ROOT 0)
+EOF
+  make ${JOBS+-j $JOBS} install
+fi
 popd

From e68f2070d344622d1d97e9af28339c4c90ec4d78 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 2 Jul 2025 14:54:42 +0200
Subject: [PATCH 0569/1764] DPL: improve debugging for rate limiting

---
 Framework/Core/src/ArrowSupport.cxx | 44 ++++++++++++++++++++++-------
 1 file changed, 34 insertions(+), 10 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 3b13e30581f70..3a7699fb6876d 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -33,6 +33,7 @@
 #include "Framework/AnalysisSupportHelpers.h"
 #include "Framework/ServiceRegistryRef.h"
 #include "Framework/ServiceRegistryHelpers.h"
+#include "Framework/Signpost.h"
 
 #include "CommonMessageBackendsHelpers.h"
 #include <Monitoring/Monitoring.h>
@@ -46,6 +47,8 @@
 #include <boost/program_options/variables_map.hpp>
 #include <csignal>
 
+O2_DECLARE_DYNAMIC_LOG(rate_limiting);
+
 namespace o2::framework
 {
 
@@ -132,6 +135,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        auto &allDeviceMetrics = sm.deviceMetricsInfos;
                        auto &specs = sm.deviceSpecs;
                        auto &infos = sm.deviceInfos;
+                       O2_SIGNPOST_ID_FROM_POINTER(sid, rate_limiting, &sm);
 
                        static auto stateMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "rate-limit-state");
                        static auto totalBytesCreatedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-arrow-bytes-created");
@@ -298,14 +302,17 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        for (size_t di = 0; di < specs.size(); di++) {
                          if (availableSharedMemory < possibleOffer) {
                            if (lowSharedMemoryCount == 0) {
-                             LOGP(detail, "We do not have enough shared memory ({}MB) to offer {}MB. Total offerings {}", availableSharedMemory, possibleOffer, offeredSharedMemory);
+                             O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "not enough",
+                                                    "We do not have enough shared memory (%{bytes}llu MB) to offer %{bytes}llu MB. Total offerings %{bytes}llu",
+                                                    availableSharedMemory, possibleOffer, offeredSharedMemory);
                            }
                            lowSharedMemoryCount++;
                            enoughSharedMemoryCount = 0;
                            break;
                          } else {
                            if (enoughSharedMemoryCount == 0) {
-                             LOGP(detail, "We are back in a state where we enough shared memory: {}MB", availableSharedMemory);
+                             O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "enough",
+                                                    "We are back in a state where we enough shared memory: %{bytes}llu MB", availableSharedMemory);
                            }
                            enoughSharedMemoryCount++;
                            lowSharedMemoryCount = 0;
@@ -323,7 +330,9 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                            continue;
                          }
                          possibleOffer = std::min(MAX_QUANTUM_SHARED_MEMORY, availableSharedMemory);
-                         LOGP(detail, "Offering {}MB out of {} to {}", possibleOffer, availableSharedMemory, specs[candidate].id);
+                         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                                                "Offering %{bytes}llu MB out of %{bytes}llu to %{public}s",
+                                                possibleOffer, availableSharedMemory, specs[candidate].id.c_str());
                          manager.queueMessage(specs[candidate].id.c_str(), fmt::format("/shm-offer {}", possibleOffer).data());
                          availableSharedMemory -= possibleOffer;
                          offeredSharedMemory += possibleOffer;
@@ -341,12 +350,15 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        static int64_t lastShmOfferConsumed = 0;
                        static int64_t lastUnusedOfferedMemory = 0;
                        if (shmOfferBytesConsumed != lastShmOfferConsumed) {
-                         LOGP(detail, "Offer consumed so far {}", shmOfferBytesConsumed);
+                         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                                                "Offer consumed so far %{bytes}llu", shmOfferBytesConsumed);
                          lastShmOfferConsumed = shmOfferBytesConsumed;
                        }
                        int unusedOfferedMemory = (offeredSharedMemory - (totalBytesExpired + shmOfferBytesConsumed) / 1000000);
                        if (lastUnusedOfferedMemory != unusedOfferedMemory) {
-                         LOGP(detail, "unusedOfferedMemory:{} = offered:{} - (expired:{} + consumed:{}) / 1000000", unusedOfferedMemory, offeredSharedMemory, totalBytesExpired / 1000000, shmOfferBytesConsumed / 1000000);
+                         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                                                "unusedOfferedMemory:%{bytes}d = offered:%{bytes}llu - (expired:%{bytes}llu + consumed:%{bytes}llu) / 1000000",
+                                                 unusedOfferedMemory, offeredSharedMemory, totalBytesExpired / 1000000, shmOfferBytesConsumed / 1000000);
                          lastUnusedOfferedMemory = unusedOfferedMemory;
                        }
                        // availableSharedMemory is the amount of memory which we know is available to be offered.
@@ -362,6 +374,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        auto* arrow = reinterpret_cast<ArrowContext*>(service);
                        auto totalBytes = 0;
                        auto totalMessages = 0;
+                       O2_SIGNPOST_ID_FROM_POINTER(sid, rate_limiting, &arrow);
                        for (auto& input : ctx.inputs()) {
                          if (input.header == nullptr) {
                            continue;
@@ -369,7 +382,9 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                          auto const* dh = DataRefUtils::getHeader<DataHeader*>(input);
                          auto payloadSize = DataRefUtils::getPayloadSize(input);
                          if (dh->serialization != o2::header::gSerializationMethodArrow) {
-                           LOGP(debug, "Message {}/{} is not of kind arrow, therefore we are not accounting its shared memory", dh->dataOrigin, dh->dataDescription);
+                           O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                                                  "Message %{public}.4s/%{public}.16s is not of kind arrow, therefore we are not accounting its shared memory.",
+                                                  dh->dataOrigin.str, dh->dataDescription.str);
                            continue;
                          }
                          bool forwarded = false;
@@ -380,15 +395,21 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                            }
                          }
                          if (forwarded) {
-                           LOGP(debug, "Message {}/{} is forwarded so we are not returning its memory.", dh->dataOrigin, dh->dataDescription);
+                           O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                                                  "Message %{public}.4s/%{public}16.s is forwarded so we are not returning its memory.",
+                                                  dh->dataOrigin.str, dh->dataDescription.str);
                            continue;
                          }
-                         LOGP(debug, "Message {}/{} is being deleted. We will return {}MB.", dh->dataOrigin, dh->dataDescription, payloadSize / 1000000.);
+                         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                                                "Message %{public}.4s/%{public}.16s is being deleted. We will return %{bytes}f MB.",
+                                                dh->dataOrigin.str, dh->dataDescription.str, payloadSize / 1000000.);
                          totalBytes += payloadSize;
                          totalMessages += 1;
                        }
                        arrow->updateBytesDestroyed(totalBytes);
-                       LOGP(debug, "{}MB bytes being given back to reader, totaling {}MB", totalBytes / 1000000., arrow->bytesDestroyed() / 1000000.);
+                       O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "give back",
+                                              "%{bytes}f MB bytes being given back to reader, totaling %{bytes}f MB",
+                                              totalBytes / 1000000., arrow->bytesDestroyed() / 1000000.);
                        arrow->updateMessagesDestroyed(totalMessages);
                        auto& stats = ctx.services().get<DataProcessingStats>();
                        stats.updateStats({static_cast<short>(ProcessingStatsId::ARROW_BYTES_DESTROYED), DataProcessingStats::Op::Set, static_cast<int64_t>(arrow->bytesDestroyed())});
@@ -410,7 +431,10 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        static bool once = false;
                        // Until we guarantee this is called only once...
                        if (!once) {
-                         LOGP(info, "Rate limiting set up at {}MB distributed over {} readers", config->maxMemory, readers);
+                         O2_SIGNPOST_ID_GENERATE(sid, rate_limiting);
+                         O2_SIGNPOST_EVENT_EMIT_INFO(rate_limiting, sid, "setup",
+                                                     "Rate limiting set up at %{bytes}llu MB distributed over %d readers",
+                                                     config->maxMemory, readers);
                          registry.registerService(ServiceRegistryHelpers::handleForService<RateLimitConfig>(config));
                          once = true;
                        } },

From eb67b94958158840fe04b4fe9a944af560c93d98 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 2 Jul 2025 16:54:59 +0200
Subject: [PATCH 0570/1764] DPL: move rate limiter to use signposts rather than
 log messages.

---
 Framework/Core/src/RateLimiter.cxx | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/RateLimiter.cxx b/Framework/Core/src/RateLimiter.cxx
index f381148223280..e0a320c8b9c9c 100644
--- a/Framework/Core/src/RateLimiter.cxx
+++ b/Framework/Core/src/RateLimiter.cxx
@@ -16,6 +16,8 @@
 #include "Framework/DataTakingContext.h"
 #include "Framework/DeviceState.h"
 #include "Framework/DeviceContext.h"
+#include "Framework/Signpost.h"
+
 #include <fairmq/Device.h>
 #include <uv.h>
 #include <fairmq/shmem/Monitor.h>
@@ -23,10 +25,13 @@
 #include <chrono>
 #include <thread>
 
+O2_DECLARE_DYNAMIC_LOG(rate_limiting);
+
 using namespace o2::framework;
 
 int RateLimiter::check(ProcessingContext& ctx, int maxInFlight, size_t minSHM)
 {
+  O2_SIGNPOST_ID_GENERATE(sid, rate_limiting);
   if (!maxInFlight && !minSHM) {
     return 0;
   }
@@ -45,9 +50,13 @@ int RateLimiter::check(ProcessingContext& ctx, int maxInFlight, size_t minSHM)
     while ((mSentTimeframes - mConsumedTimeframes) >= maxInFlight) {
       if (recvTimeout != 0 && !waitMessage && (timeoutForMessage == false || std::chrono::duration_cast<std::chrono::duration<float>>(std::chrono::system_clock::now() - startTime).count() > MESSAGE_DELAY_TIME)) {
         if (dtc.deploymentMode == DeploymentMode::OnlineDDS || dtc.deploymentMode == DeploymentMode::OnlineECS || dtc.deploymentMode == DeploymentMode::FST) {
-          LOG(alarm) << "Maximum number of TF in flight reached (" << maxInFlight << ": published " << mSentTimeframes << " - finished " << mConsumedTimeframes << "), waiting";
+          O2_SIGNPOST_EVENT_EMIT_ALARM(rate_limiting, sid, "timeframe_ratelimit",
+                                       "Maximum number of TF in flight reached (%d: published %llu - finished %llu), waiting",
+                                       maxInFlight, mSentTimeframes, mConsumedTimeframes);
         } else {
-          LOG(info) << "Maximum number of TF in flight reached (" << maxInFlight << ": published " << mSentTimeframes << " - finished " << mConsumedTimeframes << "), waiting";
+          O2_SIGNPOST_EVENT_EMIT_INFO(rate_limiting, sid, "timeframe_ratelimit",
+                                       "Maximum number of TF in flight reached (%d: published %llu - finished %llu), waiting",
+                                       maxInFlight, mSentTimeframes, mConsumedTimeframes);
         }
         waitMessage = true;
         timeoutForMessage = false;
@@ -67,12 +76,19 @@ int RateLimiter::check(ProcessingContext& ctx, int maxInFlight, size_t minSHM)
       }
       assert(msg->GetSize() == 8);
       mConsumedTimeframes = *(int64_t*)msg->GetData();
+      O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "timeframe_ratelimit",
+                             "Received %llu as consumed timeframes",
+                             mConsumedTimeframes);
     }
     if (waitMessage) {
       if (dtc.deploymentMode == DeploymentMode::OnlineDDS || dtc.deploymentMode == DeploymentMode::OnlineECS || dtc.deploymentMode == DeploymentMode::FST) {
-        LOG(important) << (mSentTimeframes - mConsumedTimeframes) << " / " << maxInFlight << " TF in flight, continuing to publish";
+        O2_SIGNPOST_EVENT_EMIT_IMPORTANT(rate_limiting, sid, "timeframe_ratelimit",
+                                         "%lli / %d TF in flight, continue to publish",
+                                         (mSentTimeframes - mConsumedTimeframes), maxInFlight);
       } else {
-        LOG(info) << (mSentTimeframes - mConsumedTimeframes) << " / " << maxInFlight << " TF in flight, continuing to publish";
+        O2_SIGNPOST_EVENT_EMIT_INFO(rate_limiting, sid, "timeframe_ratelimit",
+                                         "%lli / %d TF in flight, continue to publish",
+                                         (mSentTimeframes - mConsumedTimeframes), maxInFlight);
       }
     }
 

From ad445652650c15dc876c23b8bd0cc387ee2ffc7d Mon Sep 17 00:00:00 2001
From: jokonig <jokonig@cern.ch>
Date: Tue, 1 Jul 2025 20:18:49 +0200
Subject: [PATCH 0571/1764] [EMCAL-567] Add class to handle EMCal temperature
 calibration

- Gain of EMCal cell is temperature dependent.
- The temperature is stored in the ccdb about every 3min for 8 sensors per SM
- New class downloads temperature values from ccdb and averages them per SM
- Per cell, the energy dependence was determined in run2. These values are stored in the ccdb and also read in at initializeFromCCDB
- As the temperature values are accumulated per run, the end of run timestamp is taken - 60s of safety margin
---
 Detectors/EMCAL/calibration/CMakeLists.txt    |   2 +
 .../EMCALTempCalibExtractor.h                 |  93 +++++++++++++
 .../src/EMCALTempCalibExtractor.cxx           | 127 ++++++++++++++++++
 3 files changed, 222 insertions(+)
 create mode 100644 Detectors/EMCAL/calibration/include/EMCALCalibration/EMCALTempCalibExtractor.h
 create mode 100644 Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx

diff --git a/Detectors/EMCAL/calibration/CMakeLists.txt b/Detectors/EMCAL/calibration/CMakeLists.txt
index 68c8fd1eb69c7..7fec9fcef0f93 100644
--- a/Detectors/EMCAL/calibration/CMakeLists.txt
+++ b/Detectors/EMCAL/calibration/CMakeLists.txt
@@ -20,6 +20,7 @@ o2_add_library(EMCALCalibration
                         src/PedestalCalibDevice.cxx
                         src/PedestalProcessorDevice.cxx
                         src/PedestalProcessorData.cxx
+                        src/EMCALTempCalibExtractor.cxx
                PUBLIC_LINK_LIBRARIES O2::CCDB O2::EMCALBase
                                      O2::EMCALCalib
                                      O2::EMCALReconstruction
@@ -46,6 +47,7 @@ o2_target_root_dictionary(EMCALCalibration
                                   include/EMCALCalibration/EMCDCSProcessor.h
                                   include/EMCALCalibration/EMCALPedestalHelper.h
                                   include/EMCALCalibration/PedestalProcessorData.h
+                                  include/EMCALCalibration/EMCALTempCalibExtractor.h
                           LINKDEF src/EMCALCalibrationLinkDef.h)
 
 o2_add_executable(emcal-channel-calib-workflow
diff --git a/Detectors/EMCAL/calibration/include/EMCALCalibration/EMCALTempCalibExtractor.h b/Detectors/EMCAL/calibration/include/EMCALCalibration/EMCALTempCalibExtractor.h
new file mode 100644
index 0000000000000..5dbaec4c933f8
--- /dev/null
+++ b/Detectors/EMCAL/calibration/include/EMCALCalibration/EMCALTempCalibExtractor.h
@@ -0,0 +1,93 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \class EMCALTempCalibExtractor
+/// \brief  Calculate gain correction factors based on the temperature and the cell-by-cell temperature dependent correction factors (slope and intercept)
+/// \author Joshua König
+/// \ingroup EMCALCalib
+/// \since June 30, 2025
+
+#ifndef EMCALTEMPCALIBEXTRACTOR_H_
+#define EMCALTEMPCALIBEXTRACTOR_H_
+
+#include <algorithm>
+#include <cmath>
+#include <iostream>
+#include "CCDB/BasicCCDBManager.h"
+#include "EMCALCalib/ElmbData.h"
+#include "EMCALCalib/TempCalibrationParams.h"
+#include "EMCALBase/Geometry.h"
+
+namespace o2
+{
+namespace emcal
+{
+
+class EMCALTempCalibExtractor
+{
+
+ public:
+  /// \brief Constructor
+  EMCALTempCalibExtractor()
+  {
+    LOG(info) << "initialized EMCALTempCalibExtractor";
+    try {
+      // Try to access geometry initialized ountside
+      mGeometry = o2::emcal::Geometry::GetInstance();
+    } catch (o2::emcal::GeometryNotInitializedException& e) {
+      mGeometry = o2::emcal::Geometry::GetInstanceFromRunNumber(300000); // fallback option
+    }
+  };
+  /// \brief Destructor
+  ~EMCALTempCalibExtractor() = default;
+
+  /// \brief Initialize temperature data and slope for each cell from the ccdb
+  /// \param path path to the slope data
+  /// \param timestamp timestamp for the ccdb objects or runnumber (will detect automatically if its a runnumber and convert it)
+  void InitializeFromCCDB(std::string path, uint64_t timestamp);
+
+  /// \brief get average temperature in a supermodule
+  /// \param iSM SM number
+  /// \param ElmbData object where temperature sensor values are stored
+  /// \return average temperature in a supermodule
+  float getTemperatureForSM(const unsigned short iSM, o2::emcal::ElmbData* ElmbData) const;
+
+  /// \brief get gain calibration factor depending on the temperature and the slope of the cell
+  /// \param cellID cell ID
+  /// \return gain calibration factor
+  float getGainCalibFactor(const unsigned short cellID) const;
+
+  /// \brief set temperature range in which sensor ddata is assumed to be good
+  /// \param low lower temperature
+  /// \param high upper temperature
+  void setAcceptedEnergyRange(float low, float high);
+
+  /// \brief set if median (true) or mean (false) should be used for averaging of the temperature in a SM
+  void setUseMedian(const bool tmp) { mUseMedian = tmp; }
+
+  /// \brief get sensor IDs for a specific supermodule
+  /// \param iSM SM number
+  /// \return vector of sensor IDs
+  std::vector<unsigned short> getSensorsForSM(const unsigned short iSM) const;
+
+ private:
+  static constexpr unsigned short mNCells = 17664;      ///< Number of EMCal cells
+  std::array<float, mNCells> mGainCalibFactors;         ///< gain calibration factors that are calculated based on the temperature and the slopes for each cell
+  o2::emcal::Geometry* mGeometry;                       ///< pointer to the EMCal geometry
+  std::array<float, 2> mAcceptedTempRange = {15., 30.}; ///< Temperature range where sensors are believed to send good data. Temperatures outside this range will be rejected
+  bool mUseMedian = true;                               /// switch to decide if temperature within a SM should be calculated as the mean or the median of the individual sensor data
+};
+
+} // namespace emcal
+
+} // namespace o2
+
+#endif
\ No newline at end of file
diff --git a/Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx b/Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx
new file mode 100644
index 0000000000000..b6dc2b0a7c0a7
--- /dev/null
+++ b/Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx
@@ -0,0 +1,127 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "EMCALCalibration/EMCALTempCalibExtractor.h"
+#include "EMCALCalib/CalibDB.h"
+#include "CCDB/CcdbApi.h"
+#include "CCDB/BasicCCDBManager.h"
+#include <numeric>
+
+namespace o2
+{
+namespace emcal
+{
+
+void EMCALTempCalibExtractor::InitializeFromCCDB(std::string path, uint64_t timestamp)
+{
+
+  auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance();
+  uint64_t maxRunNr = 1000000;
+  if (timestamp < maxRunNr) {
+    LOG(info) << "assuming input is run " << timestamp << " will convert it to timstamp";
+    auto [sor, eor] = ccdbMgr.getRunDuration(timestamp);
+    uint64_t sixtySec = 60000;
+    timestamp = eor - sixtySec; // safety margin of 1min at EOR
+    LOG(info) << "set timestamp to " << timestamp;
+  }
+
+  o2::emcal::CalibDB calibdb("http://alice-ccdb.cern.ch");
+  std::map<std::string, std::string> metadata;
+  auto tempSensorData = calibdb.readTemperatureSensorData(timestamp, metadata);
+
+  // also obtain cell dependent correction factors
+  TempCalibrationParams* params = ccdbMgr.getForTimeStamp<o2::emcal::TempCalibrationParams>(path, timestamp);
+
+  std::map<unsigned short, float> mapSMTemperature;
+  for (unsigned short i = 0; i < mNCells; ++i) {
+    const unsigned short iSM = mGeometry->GetSuperModuleNumber(i);
+    if (mapSMTemperature.count(iSM) == 0) {
+      mapSMTemperature[iSM] = getTemperatureForSM(iSM, tempSensorData);
+    }
+    float corrFac = params->getTempCalibParamA0(i) + params->getTempCalibParamSlope(i) * mapSMTemperature[iSM];
+    mGainCalibFactors[i] = corrFac;
+  }
+}
+
+float EMCALTempCalibExtractor::getTemperatureForSM(const unsigned short iSM, o2::emcal::ElmbData* ElmbData) const
+{
+  if (iSM < 0 || iSM > 20) {
+    LOG(error) << "SM " << iSM << "does not exist!"; // could be replaced with a proper exception
+    return 0.;
+  }
+  std::vector<unsigned short> vecSensorID = getSensorsForSM(iSM);
+
+  // Obtain temperature for these sensors
+  std::vector<float> vecTemperature;
+  for (const auto& iSensor : vecSensorID) {
+    float temp = ElmbData->getMean(iSensor);
+    if (temp < mAcceptedTempRange[0] || temp > mAcceptedTempRange[1]) {
+      continue;
+    }
+    vecTemperature.push_back(temp);
+  }
+
+  const unsigned int nEntries = vecTemperature.size();
+  if (nEntries == 0) {
+    LOG(warning) << "No sensor data between " << mAcceptedTempRange[0] << " and " << mAcceptedTempRange[1] << "degree found... for SM " << iSM << "  Setting to default 20 degree";
+    return 20.; //
+  }
+
+  // get median energy
+  float tempSM = 0.;
+  if (mUseMedian) {
+    std::sort(vecTemperature.begin(), vecTemperature.end());
+    if (nEntries % 2 == 0) {
+      // even number of elements: average the two middle ones
+      tempSM = (vecTemperature[nEntries / 2 - 1] + vecTemperature[nEntries / 2]) / 2.0;
+    } else {
+      // odd number of elements: return the middle one
+      tempSM = vecTemperature[nEntries / 2];
+    }
+  } else { // use Mean temperature
+    float sum = std::accumulate(vecTemperature.begin(), vecTemperature.end(), 0.0);
+    tempSM = sum / vecTemperature.size();
+  }
+  return tempSM;
+}
+
+float EMCALTempCalibExtractor::getGainCalibFactor(const unsigned short cellID) const
+{
+  if (cellID >= mNCells) {
+    LOG(error) << "cell ID" << cellID << " does not exist";
+    return 1.;
+  }
+  return mGainCalibFactors[cellID];
+}
+
+std::vector<unsigned short> EMCALTempCalibExtractor::getSensorsForSM(const unsigned short iSM) const
+{
+  unsigned short nSensors = 8;
+  if (iSM == 10 || iSM == 11 || iSM == 19 || iSM == 20) {
+    nSensors = 4;
+  }
+
+  std::vector<unsigned short> vecSensorID;
+  for (unsigned short iELMBSensor = iSM * 8; iELMBSensor < iSM * 8 + nSensors; iELMBSensor++) {
+    vecSensorID.push_back(iELMBSensor);
+  }
+  return vecSensorID;
+}
+
+void EMCALTempCalibExtractor::setAcceptedEnergyRange(float low, float high)
+{
+  mAcceptedTempRange[0] = low;
+  mAcceptedTempRange[1] = high;
+}
+
+} // namespace emcal
+
+} // namespace o2
\ No newline at end of file

From 8c105b5a103f32ee86ea8f79f09325f732137fc0 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sawenzel@gmail.com>
Date: Wed, 2 Jul 2025 10:29:41 +0200
Subject: [PATCH 0572/1764] Update CODEOWNERS

updates for EMCAL
---
 CODEOWNERS | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 5337622522bbb..117ff0d92b272 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -28,9 +28,9 @@
 /DataFormats/Detectors/Common                  @shahor02
 /DataFormats/Detectors/CPV                     @peressounko @kharlov
 /DataFormats/Detectors/CTP                     @lietava
-/DataFormats/Detectors/EMCAL                   @mfasDa @jokonig
+/DataFormats/Detectors/EMCAL                   @nstrangm @jokonig
 /DataFormats/Detectors/FIT                     @jotwinow @afurs @andreasmolander @sahilupadhyaya92
-/DataFormats/Detectors/FOCAL                   @maxrauch @mfasDa @iarsene @matthiasrichter
+/DataFormats/Detectors/FOCAL                   @maxrauch @iarsene @matthiasrichter
 /DataFormats/Detectors/GlobalTracking          @shahor02
 /DataFormats/Detectors/GlobalTrackingWorkflow  @shahor02
 /DataFormats/Detectors/HMPID                   @gvolpe79
@@ -58,9 +58,9 @@
 /Detectors/Base                    @sawenzel @shahor02
 /Detectors/Calibration             @chiarazampolli @shahor02
 /Detectors/CPV                     @peressounko @kharlov
-/Detectors/EMCAL                   @mfasDa @jokonig
+/Detectors/EMCAL                   @nstrangm @jokonig
 /Detectors/FIT                     @jotwinow @afurs @andreasmolander @sahilupadhyaya92
-/Detectors/FOCAL                   @maxrauch @mfasDa @iarsene @matthiasrichter
+/Detectors/FOCAL                   @maxrauch @iarsene @matthiasrichter
 /Detectors/Geometry                @sawenzel @shahor02
 /Detectors/GlobalTracking          @shahor02
 /Detectors/GlobalTrackingWorkflow  @shahor02

From 434fb2768278842a8c626d44a880fb2ba6c20cba Mon Sep 17 00:00:00 2001
From: Joshua Koenig <joshua.konig@cern.ch>
Date: Thu, 3 Jul 2025 19:05:23 +0200
Subject: [PATCH 0573/1764] [EMCAL-567] Fix 1/3 SM numbers (#14477)

- SM20 -> SM19. SM20 does not exist

Co-authored-by: jokonig <jokonig@cern.ch>
---
 Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx b/Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx
index b6dc2b0a7c0a7..02e25696f161d 100644
--- a/Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx
+++ b/Detectors/EMCAL/calibration/src/EMCALTempCalibExtractor.cxx
@@ -105,7 +105,7 @@ float EMCALTempCalibExtractor::getGainCalibFactor(const unsigned short cellID) c
 std::vector<unsigned short> EMCALTempCalibExtractor::getSensorsForSM(const unsigned short iSM) const
 {
   unsigned short nSensors = 8;
-  if (iSM == 10 || iSM == 11 || iSM == 19 || iSM == 20) {
+  if (iSM == 10 || iSM == 11 || iSM == 18 || iSM == 19) { // 1/3 SM of EMCal only have 4 sensors
     nSensors = 4;
   }
 

From ab99262d3197ddf2d66fd1a7e68f022683e56d27 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 3 Jul 2025 10:59:06 +0200
Subject: [PATCH 0574/1764] GPU Standalone CI: Build also event display

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 2 +-
 GPU/GPUTracking/Standalone/cmake/build.sh     | 5 ++++-
 GPU/GPUTracking/Standalone/cmake/prepare.sh   | 2 +-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index e75d5a5890e4b..0ff8adb1cb957 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -73,7 +73,7 @@ AddOptionRTC(tubeMaxSize2, float, 2.5f * 2.5f, "", 0, "Square of max tube size (
 AddOptionRTC(clustersShiftTimebins, float, 0, "", 0, "Shift of TPC clusters (applied during CTF cluster decoding)")
 AddOptionRTC(clustersShiftTimebinsClusterizer, float, 0, "", 0, "Shift of TPC clusters (applied during CTF clusterization)")
 AddOptionRTC(clustersEdgeFixDistance, float, 0.f, "", 0, "If >0, revert cluster.flag edge bit distance to edge exceeds this parameter (fixed during CTF decoding)")
-AddOptionRTC(defaultZOffsetOverR, float, 0.5210953f, "", 0, "Shift of TPC clusters (applied during CTF cluster decoding)")
+AddOptionRTC(defaultZOffsetOverR, float, 0.5210953f, "", 0, "ZOffset for secondary tracks, multiple of radius")
 AddOptionRTC(PID_EKrangeMin, float, 0.47f, "", 0, "min P of electron/K BB bands crossing")
 AddOptionRTC(PID_EKrangeMax, float, 0.57f, "", 0, "max P of electron/K BB bands crossing")
 AddOptionRTC(PID_EPrangeMin, float, 0.93f, "", 0, "min P of electron/p BB bands crossing")
diff --git a/GPU/GPUTracking/Standalone/cmake/build.sh b/GPU/GPUTracking/Standalone/cmake/build.sh
index cf03539d5c3f4..1f7f446a336ac 100755
--- a/GPU/GPUTracking/Standalone/cmake/build.sh
+++ b/GPU/GPUTracking/Standalone/cmake/build.sh
@@ -13,7 +13,9 @@ if [[ $GPUCA_STANDALONE_CI == 1 ]]; then
   set(ENABLE_HIP 1)
   set(ENABLE_OPENCL 1)
   set(GPUCA_CONFIG_ONNX 1)
-  set(GPUCA_BUILD_EVENT_DISPLAY 0)
+  set(GPUCA_BUILD_EVENT_DISPLAY_VULKAN 0)
+  set(GPUCA_BUILD_EVENT_DISPLAY_WAYLAND 0)
+  set(GPUCA_BUILD_EVENT_DISPLAY_QT 0)
   set(GPUCA_CONFIG_WERROR 1)
 EOF
 fi
@@ -24,6 +26,7 @@ if [[ $GPUCA_STANDALONE_CI == 1 ]]; then
   set(ENABLE_CUDA 0)
   set(ENABLE_HIP 0)
   set(ENABLE_OPENCL 0)
+  set(GPUCA_BUILD_EVENT_DISPLAY 0)
   set(GPUCA_CONFIG_ONNX 0)
   set(GPUCA_CONFIG_VC 0)
   set(GPUCA_CONFIG_FMT 0)
diff --git a/GPU/GPUTracking/Standalone/cmake/prepare.sh b/GPU/GPUTracking/Standalone/cmake/prepare.sh
index 121245e23dc65..a7b2ff1f7db35 100755
--- a/GPU/GPUTracking/Standalone/cmake/prepare.sh
+++ b/GPU/GPUTracking/Standalone/cmake/prepare.sh
@@ -11,6 +11,6 @@ else
 fi
 eval "`alienv shell-helper`"
 # alienv load O2/latest
-for i in Vc boost fmt CMake ms_gsl Clang ninja TBB ROOT ONNXRuntime; do
+for i in Vc boost fmt CMake ms_gsl Clang ninja TBB ROOT ONNXRuntime GLFW; do
   source sw/$ALIARCH/$i/latest/etc/profile.d/init.sh
 done

From 0c3f2b5b0b72a7ef653c54787192851f1b8bfaa1 Mon Sep 17 00:00:00 2001
From: Anton Riedel <anton.riedel@cern.ch>
Date: Fri, 14 Feb 2025 14:02:39 +0100
Subject: [PATCH 0575/1764] Feat: add skeleton for GPUErrorQA task

---
 Detectors/TPC/qc/CMakeLists.txt             |  4 +-
 Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h | 69 +++++++++++++++++++++
 Detectors/TPC/qc/src/GPUErrorQA.cxx         | 55 ++++++++++++++++
 Detectors/TPC/qc/src/TPCQCLinkDef.h         |  1 +
 4 files changed, 128 insertions(+), 1 deletion(-)
 create mode 100644 Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
 create mode 100644 Detectors/TPC/qc/src/GPUErrorQA.cxx

diff --git a/Detectors/TPC/qc/CMakeLists.txt b/Detectors/TPC/qc/CMakeLists.txt
index 6bb4c726a90fa..60195ed6d451a 100644
--- a/Detectors/TPC/qc/CMakeLists.txt
+++ b/Detectors/TPC/qc/CMakeLists.txt
@@ -19,6 +19,7 @@ o2_add_library(TPCQC
                        src/SACs.cxx
                        src/IDCsVsSACs.cxx
                        src/TrackClusters.cxx
+		       src/GPUErrorQA.cxx
                PUBLIC_LINK_LIBRARIES O2::TPCBase
                                      O2::DataFormatsTPC
                                      O2::GPUO2Interface
@@ -36,7 +37,8 @@ o2_target_root_dictionary(TPCQC
                                   include/TPCQC/DCSPTemperature.h
                                   include/TPCQC/SACs.h
                                   include/TPCQC/IDCsVsSACs.h
-                                  include/TPCQC/TrackClusters.h)
+                                  include/TPCQC/TrackClusters.h
+				  include/TPCQC/GPUErrorQA.h)
 
 o2_add_test(PID
             COMPONENT_NAME tpc
diff --git a/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h b/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
new file mode 100644
index 0000000000000..e9ddcfb66d594
--- /dev/null
+++ b/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
@@ -0,0 +1,69 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// @file   GPUErrorQA.h
+/// @author Anton Riedel, anton.riedel@cern.ch
+///
+
+#ifndef AliceO2_TPC_QC_GPUERRORQA_H
+#define AliceO2_TPC_QC_GPUERRORQA_H
+
+#include <memory>
+#include <gsl/span>
+
+// root includes
+#include "TH1.h"
+
+// o2 includes
+// #include "DataFormatsTPC/Defs.h"
+
+namespace o2
+{
+namespace tpc
+{
+namespace qc
+{
+
+/// @brief  TPC QC task for errors from GPU reconstruction
+///
+/// This class is used to retrieve and visualize GPU errors
+/// according to corresponding error code and location.
+///
+/// origin: TPC
+/// @author Anton Riedel, anton.riedel@cern.ch
+class GPUErrorQA
+{
+ public:
+  /// \brief Constructor.
+  GPUErrorQA() = default;
+
+  /// process gpu error reported by the reconstruction workflow
+  void processErrors(gsl::span<const std::array<uint32_t, 4>> errors);
+
+  /// Initialize all histograms
+  void initializeHistograms();
+
+  /// Reset all histograms
+  void resetHistograms();
+
+  /// Dump results to a file
+  void dumpToFile(std::string filename);
+
+ private:
+  std::unique_ptr<TH1F> mHist;
+  ClassDefNV(GPUErrorQA, 1)
+};
+} // namespace qc
+} // namespace tpc
+} // namespace o2
+
+#endif // AliceO2_TPC_QC_GPUERRORQA_H
diff --git a/Detectors/TPC/qc/src/GPUErrorQA.cxx b/Detectors/TPC/qc/src/GPUErrorQA.cxx
new file mode 100644
index 0000000000000..876c63d6e89f5
--- /dev/null
+++ b/Detectors/TPC/qc/src/GPUErrorQA.cxx
@@ -0,0 +1,55 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#define _USE_MATH_DEFINES
+
+#include <cmath>
+#include <memory>
+
+// root includes
+#include "TFile.h"
+#include <TH1.h>
+
+// o2 includes
+#include "TPCQC/GPUErrorQA.h"
+#include "GPUErrors.h"
+
+ClassImp(o2::tpc::qc::GPUErrorQA);
+
+using namespace o2::tpc::qc;
+
+//______________________________________________________________________________
+void GPUErrorQA::initializeHistograms()
+{
+  TH1::AddDirectory(false);
+  mHist = std::make_unique<TH1F>("ErrorCounter", "ErrorCounter", o2::gpu::GPUErrors::getMaxErrors(), 0, o2::gpu::GPUErrors::getMaxErrors());
+}
+//______________________________________________________________________________
+void GPUErrorQA::resetHistograms()
+{
+  mHist->Reset();
+}
+//______________________________________________________________________________
+void GPUErrorQA::processErrors(gsl::span<const std::array<uint32_t, 4>> errors)
+{
+  for (const auto& error : errors) {
+    uint32_t errorCode = error[0];
+    mHist->Fill(static_cast<float>(errorCode));
+  }
+}
+
+//______________________________________________________________________________
+void GPUErrorQA::dumpToFile(const std::string filename)
+{
+  auto f = std::unique_ptr<TFile>(TFile::Open(filename.c_str(), "recreate"));
+  mHist->Write();
+  f->Close();
+}
diff --git a/Detectors/TPC/qc/src/TPCQCLinkDef.h b/Detectors/TPC/qc/src/TPCQCLinkDef.h
index c227ebcad8c09..3921d7dfe5649 100644
--- a/Detectors/TPC/qc/src/TPCQCLinkDef.h
+++ b/Detectors/TPC/qc/src/TPCQCLinkDef.h
@@ -24,6 +24,7 @@
 #pragma link C++ class o2::tpc::qc::SACs + ;
 #pragma link C++ class o2::tpc::qc::IDCsVsSACs + ;
 #pragma link C++ class o2::tpc::qc::TrackClusters + ;
+#pragma link C++ class o2::tpc::qc::GPUErrorQA + ;
 #pragma link C++ function o2::tpc::qc::helpers::makeLogBinning + ;
 #pragma link C++ function o2::tpc::qc::helpers::setStyleHistogram1D + ;
 #pragma link C++ function o2::tpc::qc::helpers::setStyleHistogram2D + ;

From b83d67398f86951e3b58799e7aa663d9d27eda70 Mon Sep 17 00:00:00 2001
From: Anton Riedel <anton.riedel@cern.ch>
Date: Thu, 6 Mar 2025 10:26:24 +0100
Subject: [PATCH 0576/1764] Feat: add GPUErrorQA class

---
 Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h | 28 ++++++-------
 Detectors/TPC/qc/src/GPUErrorQA.cxx         | 44 +++++++++++++++------
 2 files changed, 46 insertions(+), 26 deletions(-)

diff --git a/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h b/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
index e9ddcfb66d594..797e5da0223b7 100644
--- a/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
+++ b/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
@@ -18,22 +18,20 @@
 #define AliceO2_TPC_QC_GPUERRORQA_H
 
 #include <memory>
-#include <gsl/span>
+#include <string>
+#include <vector>
+#include <unordered_map>
 
 // root includes
-#include "TH1.h"
 
 // o2 includes
 // #include "DataFormatsTPC/Defs.h"
 
-namespace o2
-{
-namespace tpc
-{
-namespace qc
+class TH1;
+namespace o2::tpc::qc
 {
 
-/// @brief  TPC QC task for errors from GPU reconstruction
+/// @brief TPC QC task for errors from GPU reconstruction
 ///
 /// This class is used to retrieve and visualize GPU errors
 /// according to corresponding error code and location.
@@ -47,7 +45,7 @@ class GPUErrorQA
   GPUErrorQA() = default;
 
   /// process gpu error reported by the reconstruction workflow
-  void processErrors(gsl::span<const std::array<uint32_t, 4>> errors);
+  void processErrors(std::vector<std::array<uint32_t, 4>> errors);
 
   /// Initialize all histograms
   void initializeHistograms();
@@ -55,15 +53,17 @@ class GPUErrorQA
   /// Reset all histograms
   void resetHistograms();
 
+  /// return histograms
+  const std::unordered_map<std::string, std::unique_ptr<TH1>>& getMapHist() const { return mMapHist; };
+
   /// Dump results to a file
   void dumpToFile(std::string filename);
 
  private:
-  std::unique_ptr<TH1F> mHist;
-  ClassDefNV(GPUErrorQA, 1)
+  std::unordered_map<std::string, std::unique_ptr<TH1>> mMapHist;
+
+  ClassDefNV(GPUErrorQA, 1);
 };
-} // namespace qc
-} // namespace tpc
-} // namespace o2
+} // namespace o2::tpc::qc
 
 #endif // AliceO2_TPC_QC_GPUERRORQA_H
diff --git a/Detectors/TPC/qc/src/GPUErrorQA.cxx b/Detectors/TPC/qc/src/GPUErrorQA.cxx
index 876c63d6e89f5..f59332b658466 100644
--- a/Detectors/TPC/qc/src/GPUErrorQA.cxx
+++ b/Detectors/TPC/qc/src/GPUErrorQA.cxx
@@ -11,16 +11,13 @@
 
 #define _USE_MATH_DEFINES
 
-#include <cmath>
-#include <memory>
-
 // root includes
 #include "TFile.h"
-#include <TH1.h>
+#include "TH1I.h"
 
 // o2 includes
 #include "TPCQC/GPUErrorQA.h"
-#include "GPUErrors.h"
+#include "GPUDefMacros.h"
 
 ClassImp(o2::tpc::qc::GPUErrorQA);
 
@@ -30,26 +27,49 @@ using namespace o2::tpc::qc;
 void GPUErrorQA::initializeHistograms()
 {
   TH1::AddDirectory(false);
-  mHist = std::make_unique<TH1F>("ErrorCounter", "ErrorCounter", o2::gpu::GPUErrors::getMaxErrors(), 0, o2::gpu::GPUErrors::getMaxErrors());
+
+  // get gpu error names
+  // copied from GPUErrors.h
+  static std::unordered_map<uint32_t, const char*> errorNames = {
+#define GPUCA_ERROR_CODE(num, name, ...) {num, GPUCA_M_STR(name)},
+#include "GPUErrorCodes.h"
+#undef GPUCA_ERROR_CODE
+  };
+
+  // 1D histogram counting all reported errors
+  mMapHist["ErrorCounter"] = std::make_unique<TH1I>("ErrorCounter", "ErrorCounter", errorNames.size(), -0.5, errorNames.size() - 0.5);
+  mMapHist["ErrorCounter"]->GetXaxis()->SetTitle("Error Codes");
+  mMapHist["ErrorCounter"]->GetYaxis()->SetTitle("Entries");
+  // for convienence, label each bin with the error name
+  for (size_t bin = 1; bin < mMapHist["ErrorCounter"]->GetNbinsX(); bin++) {
+    auto const& it = errorNames.find(bin);
+    mMapHist["ErrorCounter"]->GetXaxis()->SetBinLabel(bin, it->second);
+  }
 }
 //______________________________________________________________________________
 void GPUErrorQA::resetHistograms()
 {
-  mHist->Reset();
+  for (const auto& pair : mMapHist) {
+    pair.second->Reset();
+  }
 }
 //______________________________________________________________________________
-void GPUErrorQA::processErrors(gsl::span<const std::array<uint32_t, 4>> errors)
+void GPUErrorQA::processErrors(std::vector<std::array<uint32_t, 4>> errors)
 {
   for (const auto& error : errors) {
     uint32_t errorCode = error[0];
-    mHist->Fill(static_cast<float>(errorCode));
+    mMapHist["ErrorCounter"]->AddBinContent(errorCode);
   }
 }
 
 //______________________________________________________________________________
 void GPUErrorQA::dumpToFile(const std::string filename)
 {
-  auto f = std::unique_ptr<TFile>(TFile::Open(filename.c_str(), "recreate"));
-  mHist->Write();
-  f->Close();
+  auto f = std::unique_ptr<TFile>(TFile::Open(filename.data(), "recreate"));
+  TObjArray arr;
+  arr.SetName("GPUErrorQA_Hists");
+  for (const auto& [name, hist] : mMapHist) {
+    arr.Add(hist.get());
+  }
+  arr.Write(arr.GetName(), TObject::kSingleKey);
 }

From 7b8b2e7cd1742d6a2ea9ca536cfceda95fbc77ff Mon Sep 17 00:00:00 2001
From: Anton Riedel <anton.riedel@cern.ch>
Date: Thu, 12 Jun 2025 15:14:07 +0200
Subject: [PATCH 0577/1764] Feat: movde error names to GPUErrors.h

---
 Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h |  4 ++--
 Detectors/TPC/qc/src/GPUErrorQA.cxx         | 16 ++++------------
 GPU/GPUTracking/Global/GPUErrors.cxx        |  7 -------
 GPU/GPUTracking/Global/GPUErrors.h          |  8 ++++++++
 4 files changed, 14 insertions(+), 21 deletions(-)

diff --git a/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h b/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
index 797e5da0223b7..ec171a6925a98 100644
--- a/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
+++ b/Detectors/TPC/qc/include/TPCQC/GPUErrorQA.h
@@ -54,7 +54,7 @@ class GPUErrorQA
   void resetHistograms();
 
   /// return histograms
-  const std::unordered_map<std::string, std::unique_ptr<TH1>>& getMapHist() const { return mMapHist; };
+  const std::unordered_map<std::string, std::unique_ptr<TH1>>& getMapHist() const { return mMapHist; }
 
   /// Dump results to a file
   void dumpToFile(std::string filename);
@@ -62,7 +62,7 @@ class GPUErrorQA
  private:
   std::unordered_map<std::string, std::unique_ptr<TH1>> mMapHist;
 
-  ClassDefNV(GPUErrorQA, 1);
+  ClassDefNV(GPUErrorQA, 2);
 };
 } // namespace o2::tpc::qc
 
diff --git a/Detectors/TPC/qc/src/GPUErrorQA.cxx b/Detectors/TPC/qc/src/GPUErrorQA.cxx
index f59332b658466..912b036a6cccf 100644
--- a/Detectors/TPC/qc/src/GPUErrorQA.cxx
+++ b/Detectors/TPC/qc/src/GPUErrorQA.cxx
@@ -17,7 +17,7 @@
 
 // o2 includes
 #include "TPCQC/GPUErrorQA.h"
-#include "GPUDefMacros.h"
+#include "GPUErrors.h"
 
 ClassImp(o2::tpc::qc::GPUErrorQA);
 
@@ -28,21 +28,13 @@ void GPUErrorQA::initializeHistograms()
 {
   TH1::AddDirectory(false);
 
-  // get gpu error names
-  // copied from GPUErrors.h
-  static std::unordered_map<uint32_t, const char*> errorNames = {
-#define GPUCA_ERROR_CODE(num, name, ...) {num, GPUCA_M_STR(name)},
-#include "GPUErrorCodes.h"
-#undef GPUCA_ERROR_CODE
-  };
-
   // 1D histogram counting all reported errors
-  mMapHist["ErrorCounter"] = std::make_unique<TH1I>("ErrorCounter", "ErrorCounter", errorNames.size(), -0.5, errorNames.size() - 0.5);
+  mMapHist["ErrorCounter"] = std::make_unique<TH1I>("ErrorCounter", "ErrorCounter", o2::gpu::errorNames.size(), -0.5, o2::gpu::errorNames.size() - 0.5);
   mMapHist["ErrorCounter"]->GetXaxis()->SetTitle("Error Codes");
   mMapHist["ErrorCounter"]->GetYaxis()->SetTitle("Entries");
   // for convienence, label each bin with the error name
   for (size_t bin = 1; bin < mMapHist["ErrorCounter"]->GetNbinsX(); bin++) {
-    auto const& it = errorNames.find(bin);
+    auto const& it = o2::gpu::errorNames.find(bin);
     mMapHist["ErrorCounter"]->GetXaxis()->SetBinLabel(bin, it->second);
   }
 }
@@ -68,7 +60,7 @@ void GPUErrorQA::dumpToFile(const std::string filename)
   auto f = std::unique_ptr<TFile>(TFile::Open(filename.data(), "recreate"));
   TObjArray arr;
   arr.SetName("GPUErrorQA_Hists");
-  for (const auto& [name, hist] : mMapHist) {
+  for ([[maybe_unused]] const auto& [name, hist] : mMapHist) {
     arr.Add(hist.get());
   }
   arr.Write(arr.GetName(), TObject::kSingleKey);
diff --git a/GPU/GPUTracking/Global/GPUErrors.cxx b/GPU/GPUTracking/Global/GPUErrors.cxx
index e9d5a74c6567a..ed4ca892cc331 100644
--- a/GPU/GPUTracking/Global/GPUErrors.cxx
+++ b/GPU/GPUTracking/Global/GPUErrors.cxx
@@ -36,7 +36,6 @@ GPUd() void GPUErrors::raiseError(uint32_t code, uint32_t param1, uint32_t param
 #ifndef GPUCA_GPUCODE
 
 #include <cstring>
-#include <unordered_map>
 
 uint32_t GPUErrors::getMaxErrors()
 {
@@ -48,12 +47,6 @@ void GPUErrors::clear()
   memset(mErrors, 0, GPUCA_MAX_ERRORS * sizeof(*mErrors));
 }
 
-static std::unordered_map<uint32_t, const char*> errorNames = {
-#define GPUCA_ERROR_CODE(num, name, ...) {num, GPUCA_M_STR(name)},
-#include "GPUErrorCodes.h"
-#undef GPUCA_ERROR_CODE
-};
-
 bool GPUErrors::printErrors(bool silent, uint64_t mask)
 {
   bool retVal = 0;
diff --git a/GPU/GPUTracking/Global/GPUErrors.h b/GPU/GPUTracking/Global/GPUErrors.h
index 1cbc4a019601d..698c0ef0c026c 100644
--- a/GPU/GPUTracking/Global/GPUErrors.h
+++ b/GPU/GPUTracking/Global/GPUErrors.h
@@ -16,10 +16,18 @@
 #define GPUERRORS_H
 
 #include "GPUCommonDef.h"
+#include "GPUDefMacros.h"
+#include <unordered_map>
 
 namespace o2::gpu
 {
 
+static std::unordered_map<uint32_t, const char*> errorNames = {
+#define GPUCA_ERROR_CODE(num, name, ...) {num, GPUCA_M_STR(name)},
+#include "GPUErrorCodes.h"
+#undef GPUCA_ERROR_CODE
+};
+
 class GPUErrors
 {
  public:

From 8aec6f6b787090654e13adc5474fa5ea4f4a5fd0 Mon Sep 17 00:00:00 2001
From: Anton Riedel <anton.riedel@cern.ch>
Date: Tue, 17 Jun 2025 16:49:10 +0200
Subject: [PATCH 0578/1764] Fix: expose gpu error names with static function

---
 GPU/GPUTracking/Global/GPUErrors.cxx | 12 ++++++++++++
 GPU/GPUTracking/Global/GPUErrors.h   | 11 ++++-------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUErrors.cxx b/GPU/GPUTracking/Global/GPUErrors.cxx
index ed4ca892cc331..4baa299c6b976 100644
--- a/GPU/GPUTracking/Global/GPUErrors.cxx
+++ b/GPU/GPUTracking/Global/GPUErrors.cxx
@@ -36,6 +36,7 @@ GPUd() void GPUErrors::raiseError(uint32_t code, uint32_t param1, uint32_t param
 #ifndef GPUCA_GPUCODE
 
 #include <cstring>
+#include <unordered_map>
 
 uint32_t GPUErrors::getMaxErrors()
 {
@@ -47,9 +48,20 @@ void GPUErrors::clear()
   memset(mErrors, 0, GPUCA_MAX_ERRORS * sizeof(*mErrors));
 }
 
+const std::unordered_map<uint32_t, const char*>& GPUErrors::getErrorNames()
+{
+  static std::unordered_map<uint32_t, const char*> errorNames = {
+#define GPUCA_ERROR_CODE(num, name, ...) {num, GPUCA_M_STR(name)},
+#include "GPUErrorCodes.h"
+#undef GPUCA_ERROR_CODE
+  };
+  return errorNames;
+}
+
 bool GPUErrors::printErrors(bool silent, uint64_t mask)
 {
   bool retVal = 0;
+  const auto& errorNames = getErrorNames();
   for (uint32_t i = 0; i < std::min(*mErrors, GPUCA_MAX_ERRORS); i++) {
     uint32_t errorCode = mErrors[4 * i + 1];
     const auto& it = errorNames.find(errorCode);
diff --git a/GPU/GPUTracking/Global/GPUErrors.h b/GPU/GPUTracking/Global/GPUErrors.h
index 698c0ef0c026c..d14c9ffaeda96 100644
--- a/GPU/GPUTracking/Global/GPUErrors.h
+++ b/GPU/GPUTracking/Global/GPUErrors.h
@@ -16,18 +16,14 @@
 #define GPUERRORS_H
 
 #include "GPUCommonDef.h"
-#include "GPUDefMacros.h"
+
+#ifndef GPUCA_GPUCODE
 #include <unordered_map>
+#endif
 
 namespace o2::gpu
 {
 
-static std::unordered_map<uint32_t, const char*> errorNames = {
-#define GPUCA_ERROR_CODE(num, name, ...) {num, GPUCA_M_STR(name)},
-#include "GPUErrorCodes.h"
-#undef GPUCA_ERROR_CODE
-};
-
 class GPUErrors
 {
  public:
@@ -42,6 +38,7 @@ class GPUErrors
   void setMemory(GPUglobalref() uint32_t* m) { mErrors = m; }
   void clear();
   bool printErrors(bool silent = false, uint64_t mask = 0);
+  static const std::unordered_map<uint32_t, const char*>& getErrorNames();
   uint32_t getNErrors() const;
   const uint32_t* getErrorPtr() const;
   static uint32_t getMaxErrors();

From 7b5af49b2a59c92f29463e6c9d36bc57d2785edc Mon Sep 17 00:00:00 2001
From: Anton Riedel <anton.riedel@cern.ch>
Date: Tue, 17 Jun 2025 17:12:50 +0200
Subject: [PATCH 0579/1764] Feat: account for missing error codes

---
 Detectors/TPC/qc/src/GPUErrorQA.cxx | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/qc/src/GPUErrorQA.cxx b/Detectors/TPC/qc/src/GPUErrorQA.cxx
index 912b036a6cccf..d4848aaefecb7 100644
--- a/Detectors/TPC/qc/src/GPUErrorQA.cxx
+++ b/Detectors/TPC/qc/src/GPUErrorQA.cxx
@@ -28,14 +28,27 @@ void GPUErrorQA::initializeHistograms()
 {
   TH1::AddDirectory(false);
 
+  auto const& errorNames = o2::gpu::GPUErrors::getErrorNames();
+
+  int maxErrorCode = 1;
+  for (const auto& [key, _] : errorNames) {
+    if (static_cast<int>(key) > maxErrorCode) {
+      maxErrorCode = key;
+    }
+  }
+
   // 1D histogram counting all reported errors
-  mMapHist["ErrorCounter"] = std::make_unique<TH1I>("ErrorCounter", "ErrorCounter", o2::gpu::errorNames.size(), -0.5, o2::gpu::errorNames.size() - 0.5);
+  mMapHist["ErrorCounter"] = std::make_unique<TH1I>("ErrorCounter", "ErrorCounter", maxErrorCode, -0.5, maxErrorCode - 0.5);
   mMapHist["ErrorCounter"]->GetXaxis()->SetTitle("Error Codes");
   mMapHist["ErrorCounter"]->GetYaxis()->SetTitle("Entries");
   // for convienence, label each bin with the error name
-  for (size_t bin = 1; bin < mMapHist["ErrorCounter"]->GetNbinsX(); bin++) {
-    auto const& it = o2::gpu::errorNames.find(bin);
-    mMapHist["ErrorCounter"]->GetXaxis()->SetBinLabel(bin, it->second);
+  for (size_t bin = 1; bin <= maxErrorCode; bin++) {
+    auto const& it = errorNames.find(bin);
+    if (it != errorNames.end()) {
+      mMapHist["ErrorCounter"]->GetXaxis()->SetBinLabel(bin, it->second);
+    } else {
+      mMapHist["ErrorCounter"]->GetXaxis()->SetBinLabel(bin, "NO_DEF");
+    }
   }
 }
 //______________________________________________________________________________

From c2f066ac14c1e7d40c322a46f2c9ceed67dc2d11 Mon Sep 17 00:00:00 2001
From: Anton Riedel <anton.riedel@cern.ch>
Date: Thu, 3 Jul 2025 16:32:01 +0200
Subject: [PATCH 0580/1764] Fix: add header guard

---
 GPU/GPUTracking/Global/GPUErrors.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Global/GPUErrors.h b/GPU/GPUTracking/Global/GPUErrors.h
index d14c9ffaeda96..535364bf08ce1 100644
--- a/GPU/GPUTracking/Global/GPUErrors.h
+++ b/GPU/GPUTracking/Global/GPUErrors.h
@@ -16,7 +16,6 @@
 #define GPUERRORS_H
 
 #include "GPUCommonDef.h"
-
 #ifndef GPUCA_GPUCODE
 #include <unordered_map>
 #endif
@@ -38,7 +37,9 @@ class GPUErrors
   void setMemory(GPUglobalref() uint32_t* m) { mErrors = m; }
   void clear();
   bool printErrors(bool silent = false, uint64_t mask = 0);
+#ifndef GPUCA_GPUCODE
   static const std::unordered_map<uint32_t, const char*>& getErrorNames();
+#endif
   uint32_t getNErrors() const;
   const uint32_t* getErrorPtr() const;
   static uint32_t getMaxErrors();

From bc3e04cb1ce8030d05de09271fafdb0557241d69 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 4 Jul 2025 10:47:37 +0200
Subject: [PATCH 0581/1764] GPU: Update build documentation for new
 gpu-system.sh package

---
 GPU/documentation/build-O2.md | 56 ++++++++++++++++++++++++++---------
 1 file changed, 42 insertions(+), 14 deletions(-)

diff --git a/GPU/documentation/build-O2.md b/GPU/documentation/build-O2.md
index 098629f45a832..dd21f7e154a63 100644
--- a/GPU/documentation/build-O2.md
+++ b/GPU/documentation/build-O2.md
@@ -11,6 +11,36 @@ GPU support should be detected and enabled automatically.
 If you just want to reproduce the GPU build locally without running it, it might be easiest to use the GPU CI container (see below).
 The provisioning script of the container also demonstrates which patches need to be applied such that everything works correctly.
 
+In a nutshell, all is steered via CMake variables, and the `ALIBUILD_O2_FORCE_GPU...` environment variables exist to steer what [alidist/o2.sh](https://github.com/alisw/alidist/blob/master/o2.sh) puts as CMake defaults.
+We try to run the same CMake GPU detection as in O2 ([FindO2GPU.cmake](https://github.com/AliceO2Group/AliceO2/blob/dev/dependencies/FindO2GPU.cmake)) during the aliBuild `prefer_system_check` ([gpu-system.sh](https://github.com/alisw/alidist/blob/master/gpu-system.sh)), such that all GPU features / versions / architectures can become part of the `gpu-system` version, which avoid inconsistencies between different packages we build.
+
+All is steered via environment variables, which will go into the version and thus the hash:
+- `ALIBUILD_O2_FORCE_GPU=...` sets the mode
+- `ALIBUILD_O2_FORCE_GPU_CUDA=1` can force-enable (`=1`) or disable (`=0`) backends, even if they were not detected. Same for `..._HIP` and `..._OPENCL`.
+- `ALIBUILD_O2_FORCE_GPU_CUDA_ARCH=...` can override the architecture to cross-compile, e.g. `ALIBUILD_O2_FORCE_GPU_CUDA_ARCH="86;89"`. Same for `..._HIP_ARCH`.
+
+Modes for `ALIBUILD_O2_FORCE_GPU`
+- `force` / `1` / `ci`: Force that all backends / features are detected, fail if not. GPU architectures are set to the default ones if not specified by environment variables.
+CI is currently identical to force, but should allow special behavior when running in the CI.
+- `auto`: check for supported system-cmake version, fail if not found. Auto-detect GPU backends / features and architectures. Selected features can be force-enabled on top via env variable. But not selectively disabled. (But one can use the manual mode below.)
+- `onthefly`: Don't detect GPUs at alidist levels. gPUs disabled in ONNX. GPUs auto-detcted in O2 CMake during build as before, but this means the O2 build hash does not depend on GPU features, so we also have the same problems as before. This is just a fallback, to allow users to build with GPUs if they don't have a compatible system CMake.
+- `fullauto`: Detect supported system-cmake. If found, behave as Auto. If not found behave as OnTheFly.
+- `disabled`: Disable all GPU builds. No extra time during aliBuild command.
+- `manual`: all GPU builds disabled by default, to  be enabled manually via env variable. No extra time during aliBuild command.
+
+*Additional reasoning for this approach*
+Advantages:
+- O2 hash and ONNX hash depend on available GPU backends, detected features (like tensorrt for ML) and on the detected GPU architectures and librar versions. I.e. when you plug in a new GPU or update the CUDA version, the O2 hash will change and this will trigger a rebuild. Otherwise, the build could just fail due to stale settings in CMakeCache.
+- We can have binary tarballs depending on the enabled backends.
+- O2 and ONNX are always in sync.
+- Same detection during aliBuild as in O2 CMake.
+- One can see enabled GPU features / versions / architectures in the version string of `gpu-system`.
+
+Disadvantages:
+- Need system `CMake` >= `3.26` for the detsction at aliBuild level.
+- `FindO2GPU.cmake` is duplicated in O2 and alidist and must be kept in sync. But at least this is checked and gives an error otherwise.
+- Running cmake during the system check takes around 5 sec for every aliBuild command involving O2 or ONNX.
+
 *GPU Tracking with CUDA*
  * The CMake option `-DENABLE_CUDA=ON/OFF/AUTO` steers whether CUDA is forced enabled / unconditionally disabled / auto-detected.
  * The CMake option `-DCUDA_COMPUTETARGET=...` fixes a GPU target, e.g. 61 for PASCAL or 75 for Turing (if unset, it compiles for the lowest supported architecture)
@@ -19,10 +49,9 @@ The provisioning script of the container also demonstrates which patches need to
  * CMake will report "Building GPUTracking with CUDA support" when enabled.
 
 *GPU Tracking with HIP*
- * HIP and HCC must be installed, and CMake must be able to detect HIP via find_package(hip).
- * If HIP and HCC are not installed to /opt/rocm, the environment variables `$HIP_PATH` and `$HCC_HOME` must point to the installation directories.
- * HIP from ROCm >= 4.0 is required.
- * The CMake option `-DHIP_AMDGPUTARGET=...` forces a GPU target, e.g. gfx906 for Radeon VII (if unset, it auto-detects the GPU).
+ * HIP must be installed, and CMake must be able to detect HIP via find_package(hip) and enable language(hip).
+ * For the minimum ROCm / HIP version, please check [FindO2GPU.cmake](https://github.com/AliceO2Group/AliceO2/blob/dev/dependencies/FindO2GPU.cmake#L287).
+ * The CMake option `-DHIP_AMDGPUTARGET=...` / env variable `ALIBUILD_O2_FORCE_GPU_HIP_ARCH=...` forces a GPU target, e.g. gfx906 for MI50 (if unset, it auto-detects the GPU).
  * CMake will report "Building GPUTracking with HIP support" when enabled.
  * It may be that some patches must be applied to ROCm after the installation. You find the details in the provisioning script of the GPU CI container below.
 
@@ -31,7 +60,7 @@ The provisioning script of the container also demonstrates which patches need to
  * Needs the SPIR-V LLVM translator together with LLVM to create the SPIR-V binaries, also detectable via CMake.
 
 *OpenGL visualization of TPC tracking*
- * Needs the following libraries (all detectable via CMake find_package): libOpenGL, libGLEW, libGLFW, libGLU.
+ * Needs the following libraries (all detectable via CMake find_package): libOpenGL, libGLEW or libGLFW (default), libGLU.
  * OpenGL must be at least version 4.5, but this is not detectable at CMake time. If the supported OpenGL version is below, the display is not/partially built, and not available at runtime. (Whether it is not or partially built depends on whether the maximum OpenGL version supported by GLEW or that of the system runtime in insufficient.)
  * Note: If ROOT does not detect the system GLEW library, ROOT will install its own very outdated GLEW library, which will be insufficient for the display. Since the ROOT include path will come first in the order, this will prevent the display from being built.
  * CMake will report "Building GPU Event Display" when enabled.
@@ -46,17 +75,16 @@ The provisioning script of the container also demonstrates which patches need to
 
 *Using the GPU CI container*
  * Setting up everything locally might be somewhat time-consuming, instead you can use the GPU CI cdocker container.
- * The docker images is `alisw/slc8-gpu-builder`.
- * The container exports the `ALIBUILD_O2_FORCE_GPU` env variable, which force-enables all GPU builds.
+ * The docker images is `alisw/slc9-gpu-builder`.
+ * The container exports the `ALIBUILD_O2_FORCE_GPU=1` env variable, which force-enables all GPU builds.
  * Note that it might not be possible out-of-the-box to run the GPU version from within the container. In case of HIP it should work when you forwards the necessary GPU devices in the container. For CUDA however, you would either need to (in addition to device forwarding) match the system CUDA driver and toolkit installation to the files present in the container, or you need to use the CUDA docker runtime, which is currently not installed in the container.
  * There are currently some patches needed to install all the GPU backends in a proper way and together. Please refer to the container provisioning script [provision.sh](https://github.com/alisw/docks/blob/master/slc9-gpu-builder/provision.sh). If you want to reproduce the installation locally, it is recommended to follow the steps from the script.
 
 *Summary*
 
-If you want to enforce the GPU builds on a system without GPU, please set the following CMake settings:
- * `ENABLE_CUDA=ON`
- * `ENABLE_HIP=ON`
- * `ENABLE_OPENCL=ON
- * `HIP_AMDGPUTARGET=default`
- * `CUDA_COMPUTETARGET=default`
-Alternatively you can set the environment variables `ALIBUILD_ENABLE_CUDA=1` and `ALIBUILD_ENABLE_HIP=1` to enforce building CUDA or HIP without modifying the alidist scripts.
+If you want to enforce the GPU builds on a system without GPU, please export the following environment variables:
+ * `ALIBUILD_O2_FORCE_GPU_CUDA=ON`
+ * `ALIBUILD_O2_FORCE_GPU_HIP=ON`
+ * `ALIBUILD_O2_FORCE_GPU_OPENCL=ON`
+ * `ALIBUILD_O2_FORCE_GPU_CUDA_ARCH=default`
+ * `ALIBUILD_O2_FORCE_GPU_HIP_ARCH=default`

From e2894300f0fd042c199037143254353be46b726e Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 1 Jul 2025 16:53:39 +0200
Subject: [PATCH 0582/1764] Add/use in TPCFastTransform mean IDC data member on
 top of Lumi

Nominally both IDC (setIDC(val)) and Lumi (setLumi(val)) info of the map should be filled at the creation time.
Depending what is used for the corrections (accoding to --lumi-type value: 1 for CTP lumi or 2  for IDC scaler)
the getLumi or getIDC will be used. For the old maps, where the mIDC is absent (i.e. default value -1 returned by
getIDC()) but the Lumi was used to stored the IDC mean value, we check if getLumi() is below the threshold
TPCCorrMap.CTP2IDCFallBackThreshold (by default set to 30). If this is a case, the getLumi() value will be used as
IDC scale, otherwise a Fatal will be thrown.
Note that the inverse check is not done: if CTP Lumi scaling is requested for the old map where getLumi returns IDC,
a wrong scale will be accepted.
---
 .../include/TPCCalibration/CorrMapParam.h     |  1 +
 .../TPCCalibration/CorrectionMapsLoader.h     |  1 +
 .../src/CorrectdEdxDistortions.cxx            |  4 +-
 .../calibration/src/CorrectionMapsLoader.cxx  | 44 ++++++++++++++++---
 .../TPCFastTransform.cxx                      | 35 ++++++++++++++-
 GPU/TPCFastTransformation/TPCFastTransform.h  | 25 ++++++++++-
 6 files changed, 98 insertions(+), 12 deletions(-)

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrMapParam.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrMapParam.h
index 147e5587accbb..4ce0e642f4ea3 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CorrMapParam.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CorrMapParam.h
@@ -29,6 +29,7 @@ struct CorrMapParam : public o2::conf::ConfigurableParamHelper<CorrMapParam> {
   float lumiMean = 0.;       // override TPC corr.map mean lumi (if > 0), disable corrections if < 0
   float lumiMeanRef = 0.;    // override TPC corr.mapRef mean lumi (if > 0)"
   float lumiInstFactor = 1.; // scaling to apply to instantaneous lumi from CTP (but not to IDC scaler)
+  float CTP2IDCFallBackThreshold = 30.; // if needed, interpret map->getLumi() as map->getIDC(), provided map->getLumi() is below this threshold
   int ctpLumiSource = 0;     // CTP lumi source: 0 = LumiInfo.getLumi(), 1 = LumiInfo.getLumiAlt()
 
   O2ParamDef(CorrMapParam, "TPCCorrMap");
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
index 90dc84e618cec..41e3ed6d3dcd5 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
@@ -63,6 +63,7 @@ class CorrectionMapsLoader : public o2::gpu::CorrectionMapsHelper
   void init(o2::framework::InitContext& ic);
   void copySettings(const CorrectionMapsLoader& src);
   void updateInverse(); /// recalculate inverse correction
+  float getMapMeanRate(const o2::gpu::TPCFastTransform* mp, bool lumiOverridden) const;
 
   static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, const CorrectionMapsLoaderGloOpts& gloOpts);
   static void addGlobalOptions(std::vector<o2::framework::ConfigParamSpec>& options);
diff --git a/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx b/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
index e5d1f32ad5661..73599e744483c 100644
--- a/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
+++ b/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
@@ -70,8 +70,8 @@ void o2::tpc::CorrectdEdxDistortions::setLumi(float lumi)
     LOGP(warn, "Nullptr detected in accessing the correction maps");
     return;
   }
-  const float lumiAvg = mCorrAvg->getLumi();
-  const float lumiDer = mCorrDer->getLumi();
+  const float lumiAvg = mCorrAvg->getIDC();
+  const float lumiDer = mCorrDer->getIDC();
   mScaleDer = (lumi - lumiAvg) / lumiDer;
   LOGP(info, "Setting mScaleDer: {} for inst lumi: {}  avg lumi: {}  deriv. lumi: {}", mScaleDer, lumi, lumiAvg, lumiDer);
 }
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index e13f887cbdc21..d1e1f60d4b801 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -176,20 +176,52 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
   if (matcher == ConcreteDataMatcher("TPC", "CorrMap", 0)) {
     setCorrMap((o2::gpu::TPCFastTransform*)obj);
     mCorrMap->rectifyAfterReadingFromFile();
-    if (getMeanLumiOverride() == 0 && mCorrMap->getLumi() > 0.) {
-      setMeanLumi(mCorrMap->getLumi(), false);
+    mCorrMap->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
+    if (getMeanLumiOverride() != 0) {
+      if (getLumiScaleType() == 1) {
+        mCorrMap->setLumi(getMeanLumiOverride());
+        LOGP(info, "CorrMap mean lumi rate is overridden to {}", mCorrMap->getLumi());
+      } else if (getLumiScaleType() == 2) {
+        mCorrMap->setIDC(getMeanLumiOverride());
+        LOGP(info, "CorrMap mean IDC rate is overridden to {}", mCorrMap->getIDC());
+      }
+    }
+    float mapMeanRate = 0;
+    if (getLumiScaleType() == 1) {
+      mapMeanRate = mCorrMap->getLumi();
+    } else if (getLumiScaleType() == 2) {
+      mapMeanRate = mCorrMap->getIDC();
+    }
+    if (getMeanLumiOverride() == 0 && mapMeanRate > 0.) {
+      setMeanLumi(mapMeanRate, false);
     }
-    LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mCorrMap->getLumi(), getMeanLumi());
+    LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mapMeanRate, getMeanLumi());
     setUpdatedMap();
     return true;
   }
   if (matcher == ConcreteDataMatcher("TPC", "CorrMapRef", 0)) {
     setCorrMapRef((o2::gpu::TPCFastTransform*)obj);
     mCorrMapRef->rectifyAfterReadingFromFile();
+    mCorrMapRef->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
+    if (getMeanLumiRefOverride() != 0) {
+      if (getLumiScaleType() == 1) {
+        mCorrMapRef->setLumi(getMeanLumiRefOverride());
+        LOGP(info, "CorrMapRef mean lumi rate is overridden to {}", mCorrMapRef->getLumi());
+      } else if (getLumiScaleType() == 2) {
+        mCorrMapRef->setIDC(getMeanLumiRefOverride());
+        LOGP(info, "CorrMapRef mean IDC rate is overridden to {}", mCorrMapRef->getIDC());
+      }
+    }
+    float mapRefMeanRate = 0;
+    if (getLumiScaleType() == 1) {
+      mapRefMeanRate = mCorrMapRef->getLumi();
+    } else if (getLumiScaleType() == 2) {
+      mapRefMeanRate = mCorrMapRef->getIDC();
+    }
     if (getMeanLumiRefOverride() == 0) {
-      setMeanLumiRef(mCorrMapRef->getLumi());
+      setMeanLumiRef(mapRefMeanRate);
     }
-    LOGP(debug, "MeanLumiRefOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiRefOverride(), mCorrMapRef->getLumi(), getMeanLumiRef());
+    LOGP(debug, "MeanLumiRefOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiRefOverride(), mapRefMeanRate, getMeanLumiRef());
     setUpdatedMapRef();
     return true;
   }
@@ -217,7 +249,7 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     int scaleType = getLumiScaleType();
     const std::array<std::string, 3> lumiS{"OFF", "CTP", "TPC scaler"};
     if (scaleType >= lumiS.size()) {
-      LOGP(fatal, "Wrong lumi-scale-type provided!");
+      LOGP(fatal, "Wrong corrmap-lumi-mode provided!");
     }
 
     LOGP(info, "TPC correction map params updated: SP corrections: {} (corr.map scaling type={}, override values: lumiMean={} lumiRefMean={} lumiScaleMode={}), CTP Lumi: source={} lumiInstOverride={} , LumiInst scale={} ",
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.cxx b/GPU/TPCFastTransformation/TPCFastTransform.cxx
index aea6589761403..bd29a760615ad 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransform.cxx
@@ -37,7 +37,7 @@
 using namespace o2::gpu;
 
 TPCFastTransform::TPCFastTransform()
-  : FlatObject(), mTimeStamp(0), mCorrection(), mApplyCorrection(1), mT0(0.f), mVdrift(0.f), mVdriftCorrY(0.f), mLdriftCorr(0.f), mTOFcorr(0.f), mPrimVtxZ(0.f), mLumi(0.f), mLumiError(0.f), mLumiScaleFactor(1.0f)
+  : FlatObject(), mTimeStamp(0), mCorrection(), mApplyCorrection(1), mT0(0.f), mVdrift(0.f), mVdriftCorrY(0.f), mLdriftCorr(0.f), mTOFcorr(0.f), mPrimVtxZ(0.f), mLumi(TPCFastTransform::DEFLUMI), mLumiError(0.f), mLumiScaleFactor(1.0f), mIDC(TPCFastTransform::DEFIDC), mIDCError(0.f), mCTP2IDCFallBackThreshold(30.f)
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -60,6 +60,9 @@ void TPCFastTransform::cloneFromObject(const TPCFastTransform& obj, char* newFla
   mPrimVtxZ = obj.mPrimVtxZ;
   mLumi = obj.mLumi;
   mLumiError = obj.mLumiError;
+  mIDC = obj.mIDC;
+  mIDCError = obj.mIDCError;
+  mCTP2IDCFallBackThreshold = obj.mCTP2IDCFallBackThreshold;
   mLumiScaleFactor = obj.mLumiScaleFactor;
   // variable-size data
 
@@ -108,8 +111,11 @@ void TPCFastTransform::startConstruction(const TPCFastSpaceChargeCorrection& cor
   mLdriftCorr = 0.f;
   mTOFcorr = 0.f;
   mPrimVtxZ = 0.f;
-  mLumi = 0.f;
+  mLumi = DEFLUMI;
   mLumiError = 0.f;
+  mIDC = DEFIDC;
+  mIDCError = 0.f;
+  mCTP2IDCFallBackThreshold = 30.f;
   mLumiScaleFactor = 1.f;
 
   // variable-size data
@@ -160,6 +166,9 @@ void TPCFastTransform::print() const
   LOG(info) << "mPrimVtxZ = " << mPrimVtxZ;
   LOG(info) << "mLumi = " << mLumi;
   LOG(info) << "mLumiError = " << mLumiError;
+  LOG(info) << "mIDC = " << mIDC;
+  LOG(info) << "mIDCError = " << mIDCError;
+  LOG(info) << "mCTP2IDCFallBackThreshold = " << mCTP2IDCFallBackThreshold;
   LOG(info) << "mLumiScaleFactor = " << mLumiScaleFactor;
   mCorrection.print();
 #endif
@@ -251,3 +260,25 @@ void TPCFastTransform::setSlowTPCSCCorrection(TFile& inpf)
   mCorrectionSlow->mCorr->setGlobalCorrectionsFromFile<float>(inpf, o2::tpc::Side::C);
 }
 #endif
+
+float TPCFastTransform::getIDC() const
+{
+  auto val = mIDC;
+  if (!isIDCSet()) {
+    if (mLumi < mCTP2IDCFallBackThreshold) {
+#if !defined(GPUCA_GPUCODE)
+      bool static report = true;
+      if (report) {
+        report = false;
+        LOG(warn) << "IDC scaling is requested but map IDC record is empty. Since map Lumi " << mLumi << " is less than fall-back threshold " << mCTP2IDCFallBackThreshold << ", interpret Lumi record as IDC";
+      }
+#endif
+      val = mLumi;
+    } else {
+#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+      LOG(fatal) << "IDC scaling is requested but map IDC record is empty. The map Lumi " << mLumi << " exceeds Lumi->IDC fall-back threshold " << mCTP2IDCFallBackThreshold;
+#endif
+    }
+  }
+  return val;
+}
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 4e0403422ee06..14cd892b2554a 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -96,6 +96,9 @@ struct TPCSlowSpaceChargeCorrection {
 class TPCFastTransform : public FlatObject
 {
  public:
+  static constexpr float DEFLUMI = -1e6f; // default value to check if member was set
+  static constexpr float DEFIDC = -1e6f;  // default value to check if member was set
+
   /// _____________  Constructors / destructors __________________________
 
   /// Default constructor: creates an empty uninitialized object
@@ -162,7 +165,9 @@ class TPCFastTransform : public FlatObject
   void setLumi(float l) { mLumi = l; }
   void setLumiError(float e) { mLumiError = e; }
   void setLumiScaleFactor(float s) { mLumiScaleFactor = s; }
-
+  void setIDC(float l) { mIDC = l; }
+  void setIDCError(float e) { mIDCError = e; }
+  void setCTP2IDCFallBackThreshold(float v) { mCTP2IDCFallBackThreshold = v; }
   /// Sets the time stamp of the current calibaration
   void setTimeStamp(int64_t v) { mTimeStamp = v; }
 
@@ -251,9 +256,21 @@ class TPCFastTransform : public FlatObject
   /// Return map lumi
   GPUd() float getLumi() const { return mLumi; }
 
+  GPUd() float isLumiSet() const { return mLumi != DEFLUMI; }
+
   /// Return map lumi error
   GPUd() float getLumiError() const { return mLumiError; }
 
+  /// Return map lumi
+  GPUd() float getIDC() const;
+
+  GPUd() bool isIDCSet() const { return mIDC != DEFIDC; }
+
+  /// Return map lumi error
+  GPUd() float getIDCError() const { return mIDCError; }
+
+  GPUd() float getCTP2IDCFallBackThreshold() const { return mCTP2IDCFallBackThreshold; }
+
   /// Return map user defined lumi scale factor
   GPUd() float getLumiScaleFactor() const { return mLumiScaleFactor; }
 
@@ -334,12 +351,16 @@ class TPCFastTransform : public FlatObject
   float mLumiError;       ///< error on luminosity
   float mLumiScaleFactor; ///< user correction factor for lumi (e.g. normalization, efficiency correction etc.)
 
+  float mIDC;                      ///< IDC estimator
+  float mIDCError;                 ///< error on IDC
+  float mCTP2IDCFallBackThreshold; ///< if IDC is not set but requested, use Lumi if it does not exceed this threshold
+
   /// Correction of (x,u,v) with tricubic interpolator on a regular grid
   TPCSlowSpaceChargeCorrection* mCorrectionSlow{nullptr}; ///< reference space charge corrections
 
   GPUd() void TransformInternal(int32_t slice, int32_t row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const;
 
-  ClassDefNV(TPCFastTransform, 3);
+  ClassDefNV(TPCFastTransform, 4);
 };
 
 // =======================================================================

From b562533593101251481e099e9ddf554c80433b2a Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Fri, 4 Jul 2025 08:51:12 +0200
Subject: [PATCH 0583/1764] TRD: decrease default --max-delay for gain, t0,
 vdexb calibrations

---
 Detectors/TRD/workflow/include/TRDWorkflow/GainCalibSpec.h    | 4 ++--
 Detectors/TRD/workflow/include/TRDWorkflow/T0FitSpec.h        | 4 ++--
 .../TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h      | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/GainCalibSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/GainCalibSpec.h
index 295ce0bf1d0ac..1c60a05462508 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/GainCalibSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/GainCalibSpec.h
@@ -45,7 +45,7 @@ class GainCalibDevice : public o2::framework::Task
   {
     o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
     auto slotL = ic.options().get<uint32_t>("sec-per-slot");
-    auto delay = ic.options().get<uint32_t>("max-delay");
+    auto delay = ic.options().get<float>("max-delay");
     mCalibrator = std::make_unique<o2::trd::CalibratorGain>();
     mCalibrator->setSlotLengthInSeconds(slotL);
     mCalibrator->setMaxSlotsDelay(delay);
@@ -155,7 +155,7 @@ DataProcessorSpec getTRDGainCalibSpec()
     AlgorithmSpec{adaptFromTask<o2::calibration::GainCalibDevice>(ccdbRequest)},
     Options{
       {"sec-per-slot", VariantType::UInt32, 900u, {"number of seconds per calibration time slot"}},
-      {"max-delay", VariantType::UInt32, 2u, {"number of slots in past to consider"}},
+      {"max-delay", VariantType::Float, 0.05f, {"number of slots in past to consider"}},
       {"enable-root-output", VariantType::Bool, false, {"output tprofiles and fits to root file"}},
     }};
 }
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/T0FitSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/T0FitSpec.h
index 3f4fc7a1e69fd..f39174b95ba64 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/T0FitSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/T0FitSpec.h
@@ -46,7 +46,7 @@ class T0FitDevice : public o2::framework::Task
   {
     o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
     auto slotL = ic.options().get<uint32_t>("sec-per-slot");
-    auto delay = ic.options().get<uint32_t>("max-delay");
+    auto delay = ic.options().get<float>("max-delay");
 
     mFitInstance = std::make_unique<o2::trd::T0Fit>();
     mFitInstance->setSlotLengthInSeconds(slotL);
@@ -159,7 +159,7 @@ DataProcessorSpec getTRDT0FitSpec()
     AlgorithmSpec{adaptFromTask<device>(ccdbRequest)},
     Options{
       {"sec-per-slot", VariantType::UInt32, 900u, {"number of seconds per calibration time slot"}},
-      {"max-delay", VariantType::UInt32, 2u, {"number of slots in past to consider"}},
+      {"max-delay", VariantType::Float, 0.05f, {"number of slots in past to consider"}},
       {"enable-root-output", VariantType::Bool, false, {"output t0 values to root file"}},
     }};
 }
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h
index cddbb45e169da..f45b7a1808287 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h
@@ -45,7 +45,7 @@ class VdAndExBCalibDevice : public o2::framework::Task
   {
     o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
     auto slotL = ic.options().get<uint32_t>("sec-per-slot");
-    auto delay = ic.options().get<uint32_t>("max-delay");
+    auto delay = ic.options().get<float>("max-delay");
     mCalibrator = std::make_unique<o2::trd::CalibratorVdExB>();
     mCalibrator->setSlotLengthInSeconds(slotL);
     mCalibrator->setMaxSlotsDelay(delay);
@@ -158,7 +158,7 @@ DataProcessorSpec getTRDVdAndExBCalibSpec()
     AlgorithmSpec{adaptFromTask<device>(ccdbRequest)},
     Options{
       {"sec-per-slot", VariantType::UInt32, 900u, {"number of seconds per calibration time slot"}},
-      {"max-delay", VariantType::UInt32, 2u, {"number of slots in past to consider"}},
+      {"max-delay", VariantType::Float, 0.05f, {"number of slots in past to consider"}},
       {"enable-root-output", VariantType::Bool, false, {"output tprofiles and fits to root file"}},
     }};
 }

From 8b07c99a8252c952c9a104d34bd461797f77138f Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 24 Jun 2025 21:09:16 +0200
Subject: [PATCH 0584/1764] Vtx: make class printable

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ReconstructionDataFormats/Vertex.h        | 55 ++++++++++++++++++-
 DataFormats/Reconstruction/src/Vertex.cxx     |  4 +-
 2 files changed, 55 insertions(+), 4 deletions(-)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
index fc89f162a0727..2d13e029f8c00 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
@@ -18,10 +18,13 @@
 
 #include "CommonDataFormat/TimeStamp.h"
 #ifndef GPUCA_GPUCODE_DEVICE
-#include <iosfwd>
-#include <string>
 #include <type_traits>
 #include <array>
+#ifndef GPUCA_NO_FMT
+#include <sstream>
+#include <string>
+#include <fmt/format.h>
+#endif
 #endif
 
 namespace o2
@@ -135,6 +138,11 @@ class Vertex : public VertexBase
   {
   }
 
+#if !defined(GPUCA_NO_FMT) && !defined(GPUCA_GPUCODE_DEVICE)
+  void print() const;
+  std::string asString() const;
+#endif
+
   GPUd() ushort getNContributors() const { return mNContributors; }
   GPUd() void setNContributors(ushort v) { mNContributors = v; }
   GPUd() void addContributor() { mNContributors++; }
@@ -162,6 +170,49 @@ class Vertex : public VertexBase
 
 #if !defined(GPUCA_GPUCODE_DEVICE) && !defined(GPUCA_NO_FMT)
 std::ostream& operator<<(std::ostream& os, const o2::dataformats::VertexBase& v);
+
+namespace detail
+{
+template <typename T>
+concept Streamable = requires(std::ostream& os, const T& a) {
+  { os << a } -> std::same_as<std::ostream&>;
+};
+
+template <typename T>
+concept HasFormattableTimeStamp = requires(const T& t) {
+  { fmt::format("{}", t.getTimeStamp()) } -> std::convertible_to<std::string>;
+};
+} // namespace detail
+
+template <typename Stamp>
+inline std::string Vertex<Stamp>::asString() const
+{
+  const std::string stamp = [&]() -> std::string {
+    if constexpr (detail::Streamable<Stamp>) {
+      std::ostringstream oss;
+      oss << mTimeStamp;
+      return oss.str();
+    } else if constexpr (detail::HasFormattableTimeStamp<Stamp>) {
+      return fmt::format("{}", mTimeStamp.getTimeStamp());
+    } else {
+      return "X";
+    }
+  }();
+  return fmt::format("{} NContrib:{} Chi2:{:.2f} Flags:{:b} Stamp:{}", VertexBase::asString(), mNContributors, mChi2, mBits, stamp);
+}
+
+template <typename Stamp>
+inline std::ostream& operator<<(std::ostream& os, const o2::dataformats::Vertex<Stamp>& v)
+{
+  os << v.asString();
+  return os;
+}
+
+template <typename Stamp>
+inline void Vertex<Stamp>::print() const
+{
+  std::cout << *this << '\n';
+}
 #endif
 
 } // namespace dataformats
diff --git a/DataFormats/Reconstruction/src/Vertex.cxx b/DataFormats/Reconstruction/src/Vertex.cxx
index b902e9972a13d..85145683ddd97 100644
--- a/DataFormats/Reconstruction/src/Vertex.cxx
+++ b/DataFormats/Reconstruction/src/Vertex.cxx
@@ -10,9 +10,9 @@
 // or submit itself to any jurisdiction.
 
 #include "ReconstructionDataFormats/Vertex.h"
-#include <iostream>
 #ifndef GPUCA_NO_FMT
-#include <fmt/printf.h>
+#include <iostream>
+#include <fmt/format.h>
 #endif
 
 namespace o2

From 9cef6de4f9d3e8cc1957836c43eb82ebe93a837e Mon Sep 17 00:00:00 2001
From: mcoquet642 <74600025+mcoquet642@users.noreply.github.com>
Date: Fri, 4 Jul 2025 13:03:01 +0200
Subject: [PATCH 0585/1764] Computation of DCAxyz for forward tracks (#14460)

* Computation of 3D DCA for forward tracks

* clang format

---------

Co-authored-by: Maurice Coquet <mcoquet@lxplus955.cern.ch>
---
 .../ReconstructionDataFormats/TrackFwd.h      |  1 +
 DataFormats/Reconstruction/src/TrackFwd.cxx   | 69 +++++++++++++++++++
 2 files changed, 70 insertions(+)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h
index 76ca8473553cd..50ed36d466d25 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h
@@ -161,6 +161,7 @@ class TrackParCovFwd : public TrackParFwd
   void propagateToZquadratic(double zEnd, double zField);
   void propagateToZhelix(double zEnd, double zField);
   void propagateToZ(double zEnd, double zField); // Parameters: helix; errors: quadratic
+  void propagateToDCAhelix(double zField, const std::array<double, 3>& p, std::array<double, 3>& dca);
 
   // Add Multiple Coulomb Scattering effects
   void addMCSEffect(double x2X0);
diff --git a/DataFormats/Reconstruction/src/TrackFwd.cxx b/DataFormats/Reconstruction/src/TrackFwd.cxx
index 3c45a8ecb6ec2..dfe72c5b2ccc4 100644
--- a/DataFormats/Reconstruction/src/TrackFwd.cxx
+++ b/DataFormats/Reconstruction/src/TrackFwd.cxx
@@ -11,6 +11,7 @@
 
 #include "ReconstructionDataFormats/TrackFwd.h"
 #include "Math/MatrixFunctions.h"
+#include <GPUCommonLogger.h>
 
 namespace o2
 {
@@ -503,5 +504,73 @@ bool TrackParCovFwd::getCovXYZPxPyPzGlo(std::array<float, 21>& cv) const
   return true;
 }
 
+//________________________________________________________________
+
+void TrackParCovFwd::propagateToDCAhelix(double zField, const std::array<double, 3>& p, std::array<double, 3>& dca)
+{
+  // Computing DCA of fwd track w.r.t vertex in helix track model, using Newton-Raphson minimization
+
+  auto x0 = mParameters(0);
+  auto y0 = mParameters(1);
+  auto z0 = mZ;
+  auto phi0 = mParameters(2);
+  auto tanl = mParameters(3);
+  auto qOverPt = mParameters(4);
+  auto k = TMath::Abs(o2::constants::math::B2C * zField);
+  auto qpt = 1.0 / qOverPt;
+  auto qR = qpt / std::fabs(k);
+  auto invtanl = 1.0 / tanl;
+  auto Hz = std::copysign(1, zField);
+
+  auto xPV = p[0];
+  auto yPV = p[1];
+  auto zPV = p[2];
+
+  auto qRtanl = qR * tanl;
+  auto invqRtanl = 1.0 / qRtanl;
+  auto [sinp, cosp] = o2::math_utils::sincosd(phi0);
+
+  auto z = zPV;
+  double tol = 1e-4;
+  int max_iter = 10;
+  int iter = 0;
+
+  while (iter++ < max_iter) {
+    double theta = (z0 - z) * invqRtanl;
+    double phi_theta = phi0 + Hz * theta;
+    double sin_phi_theta = sin(phi_theta);
+    double cos_phi_theta = cos(phi_theta);
+
+    double DX = x0 - Hz * qR * (sin_phi_theta - sinp) - xPV;
+    double DY = y0 + Hz * qR * (cos_phi_theta - cosp) - yPV;
+    double DZ = z - zPV;
+
+    double dD2_dZ =
+      2 * DX * cos_phi_theta * invtanl +
+      2 * DY * sin_phi_theta * invtanl +
+      2 * DZ;
+
+    double d2D2_dZ2 =
+      2 * invtanl * invtanl +
+      2 * invtanl * (DX * Hz * sin_phi_theta - DY * Hz * cos_phi_theta) * invqRtanl +
+      2;
+
+    double z_new = z - dD2_dZ / d2D2_dZ2;
+
+    if (std::abs(z_new - z) < tol) {
+      z = z_new;
+      this->propagateToZhelix(z, zField);
+      dca[0] = this->getX() - xPV;
+      dca[1] = this->getY() - yPV;
+      dca[2] = this->getZ() - zPV;
+      LOG(debug) << "Converged after " << iter << " iterations for vertex X=" << p[0] << ", Y=" << p[1] << ", Z = " << p[2];
+      return;
+    }
+    z = z_new;
+  }
+  LOG(debug) << "Failed to converge after " << iter << " iterations for vertex X=" << p[0] << ", Y=" << p[1] << ", Z = " << p[2];
+  return;
+}
+
 } // namespace track
 } // namespace o2

From 9ce304b4e99f5f721c1eac92194f282cb732d0bd Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Fri, 4 Jul 2025 20:30:24 +0200
Subject: [PATCH 0586/1764] ALICE3-TRK: detector ID used to fill Hit
 information correctly retrieved according to the chosen geometry (#14480)

* ALICE3-TRK: Detector.cxx modified to retrieve the correct Detector ID following the chosen indexing scheme

* ALICE3-TRK: considering half staves for the staggered geometry for ML/OT

* ALICE3-TRK: indexing scheme now working independently from the chosen geometry layout

* minor fixes
---
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |  23 +++-
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      | 117 ++++++++++++++----
 .../include/TRKSimulation/Detector.h          |  15 +++
 .../ALICE3/TRK/simulation/src/Detector.cxx    |  90 ++++++++++++--
 4 files changed, 203 insertions(+), 42 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index 852cb138e2be7..cfd991728d09b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -60,33 +60,44 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   int extractNumberOfDisksVD() const;
   int extractNumberOfChipsPerPetalVD() const;
   int extractNumberOfStavesMLOT(int lay) const;
+  int extractNumberOfHalfStavesMLOT(int lay) const;
 
   /// Extract number following the prefix in the name string
   int extractVolumeCopy(const char* name, const char* prefix) const;
 
   int getNumberOfLayersMLOT() const { return mNumberOfLayersMLOT; }
-  int getNumberOffActivePartsVD() const { return mNumberOfActivePartsVD; }
+  int getNumberOfActivePartsVD() const { return mNumberOfActivePartsVD; }
+  int getNumberOfHalfStaves(int lay) const { return mNumberOfHalfStaves[lay]; }
 
   bool isOwner() const { return mOwner; }
   void setOwner(bool v) { mOwner = v; }
 
   void Print(Option_t* opt = "") const;
-  void PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int indexRetrieved) const;
+  void PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int indexRetrieved) const;
 
   int getLayer(int index) const;
   int getStave(int index) const;
+  int getHalfStave(int index) const;
   int getSubDetID(int index) const;
   int getPetalCase(int index) const;
   int getDisk(int index) const;
 
   /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave /// TODO: retrieve also from chip when chips will be available
-  /// in substave
   /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
   /// \param int petalcase The petal case number for VD, from 0 to 3
   /// \param int disk The disk number for VD, from 0 to 5
   /// \param int lay The layer number. Starting from 0 both for VD and MLOT
   /// \param int stave The stave number for MLOT. Starting from 0
-  int getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave) const;
+  /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
+  int getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const;
+
+  /// This routine computes the chip index number from the subDetID, volume, layer, stave /// TODO: retrieve also from chip when chips will be available
+  /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
+  /// \param int volume is needed only with the current configuration for VD where each single element is a volume. // TODO: when the geometry naming scheme will be changed, change this method
+  /// \param int lay The layer number for the MLOT. In the current configuration for VD this is not needed. // TODO: when the geometry naming scheme will be changed, change this method
+  /// \param int stave The stave number in each layer for MLOT. Starting from 0.
+  /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
+  int getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave) const;
 
   /// This routine computes subDetID, petal, disk, layer, stave given the chip index number /// TODO: copute also from chip when chips will be available
   /// \param int index The chip index number, starting from 0
@@ -95,7 +106,8 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   /// \param int disk The disk number for VD, from 0 to 5
   /// \param int lay The layer number. Starting from 0 both for VD and MLOT
   /// \param int stave The stave number for MLOT. Starting from 0
-  bool getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave) const;
+  /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
+  bool getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave) const;
 
   int getLastChipIndex(int lay) const { return mLastChipIndex[lay]; }
   int getFirstChipIndex(int lay, int petalcase, int subDetID) const
@@ -150,6 +162,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   std::vector<int> mNumbersOfChipPerDiskVD;    ///< numbersOfChipPerDiskVD
   std::vector<int> mNumberOfChipsPerPetalVD;   ///< numbersOfChipPerPetalVD
   std::vector<int> mNumberOfStaves;            ///< Number Of Staves per layer in ML/OT
+  std::vector<int> mNumberOfHalfStaves;        ///< Number Of Staves in each stave of the layer in ML/OT
   std::array<char, MAXLAYERS> mLayerToWrapper; ///< Layer to wrapper correspondence
 
   bool mOwner = true; //! is it owned by the singleton?
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 4547225033498..69bae0fad9cee 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -54,9 +54,9 @@ GeometryTGeo::GeometryTGeo(bool build, int loadTrans) : DetMatrixCache(detectors
 void GeometryTGeo::Build(int loadTrans)
 {
   ///// current geometry organization:
-  ///// total elements = 258 = x staves * 8 layers ML+OT + 4 petal cases * (3 layers + 6 disks)
+  ///// total elements = x staves (*2 half staves if staggered geometry) * 8 layers ML+OT + 4 petal cases * (3 layers + 6 disks)
   ///// indexing from 0 to 35: VD petals -> layers -> disks
-  ///// indexing from 36 to 257: MLOT staves
+  ///// indexing from 36 to y: MLOT staves
 
   if (isBuilt()) {
     LOGP(warning, "Already built");
@@ -74,6 +74,7 @@ void GeometryTGeo::Build(int loadTrans)
   mNumberOfDisksVD = extractNumberOfDisksVD();
 
   mNumberOfStaves.resize(mNumberOfLayersMLOT);
+  mNumberOfHalfStaves.resize(mNumberOfLayersMLOT);
   mLastChipIndex.resize(mNumberOfPetalsVD + mNumberOfLayersMLOT);
   mLastChipIndexVD.resize(mNumberOfPetalsVD);
   mLastChipIndexMLOT.resize(mNumberOfLayersMLOT); /// ML and OT are part of TRK as the same detector, without disks
@@ -85,6 +86,7 @@ void GeometryTGeo::Build(int loadTrans)
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
     std::cout << "Layer MLOT: " << i << std::endl;
     mNumberOfStaves[i] = extractNumberOfStavesMLOT(i);
+    mNumberOfHalfStaves[i] = extractNumberOfHalfStavesMLOT(i);
   }
 
   int numberOfChipsTotal = 0;
@@ -99,13 +101,12 @@ void GeometryTGeo::Build(int loadTrans)
 
   /// filling the information for the MLOT
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
-    mNumberOfChipsPerLayerMLOT[i] = extractNumberOfStavesMLOT(i); // for the moment, considering 1 stave = 1 chip. TODO: add the final segmentation in chips
+    mNumberOfChipsPerLayerMLOT[i] = extractNumberOfStavesMLOT(i) * extractNumberOfHalfStavesMLOT(i); // for the moment, considering 1 half stave = 1 chip. TODO: add the final segmentation in chips
     numberOfChipsTotal += mNumberOfChipsPerLayerMLOT[i];
     mLastChipIndex[i + mNumberOfPetalsVD] = numberOfChipsTotal - 1;
     mLastChipIndexMLOT[i] = numberOfChipsTotal - 1;
   }
 
-  // setSize(mNumberOfLayersMLOT + mNumberOfActivePartsVD); /// temporary, number of chips = number of layers and active parts
   setSize(numberOfChipsTotal); /// temporary, number of chips = number of staves and active parts
   fillMatrixCache(loadTrans);
 }
@@ -155,7 +156,7 @@ int GeometryTGeo::getLayer(int index) const
     while (index > mLastChipIndex[lay]) {
       lay++;
     }
-    return lay - mNumberOfPetalsVD; /// numeration of MLOT layesrs  starting from 1
+    return lay - mNumberOfPetalsVD; /// numeration of MLOT layesrs  starting from 0
   }
   return -1; /// -1 if not found
 }
@@ -170,8 +171,26 @@ int GeometryTGeo::getStave(int index) const
     return -1;
   } else if (subDetID == 1) { /// MLOT
     int lay = getLayer(index);
-    index -= getFirstChipIndex(lay, petalcase, subDetID);
-    return index; /// ||||
+    index -= getFirstChipIndex(lay, petalcase, subDetID); // get the index of the sensing element in the layer
+    return index / mNumberOfHalfStaves[lay];
+  }
+  return -1; /// not found
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::getHalfStave(int index) const
+{
+  int subDetID = getSubDetID(index);
+  int lay = getLayer(index);
+  int petalcase = getPetalCase(index);
+  int stave = getStave(index);
+
+  if (subDetID == 0) { /// VD
+    return -1;
+  } else if (subDetID == 1) { /// MLOT
+    int lay = getLayer(index);
+    index -= getFirstChipIndex(lay, petalcase, subDetID); // get the index of the sensing element in the layer
+    return index % 2;                                     /// 0 = half stave left, 1 = half stave right, as geometry is filled /// TODO: generalize once chips will be in place. Can it be working also with chips?
   }
   return -1; /// not found
 }
@@ -193,7 +212,7 @@ int GeometryTGeo::getDisk(int index) const
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave) const
+int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const
 {
   if (subDetID == 0) { // VD
     if (lay == -1) {   // disk
@@ -201,20 +220,41 @@ int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, i
     } else { // layer
       return getFirstChipIndex(lay, petalcase, subDetID) + lay;
     }
-  } else if (subDetID == 1) { // MLOT
-    return getFirstChipIndex(lay, petalcase, subDetID) + stave;
+  } else if (subDetID == 1) {            // MLOT
+    if (mNumberOfHalfStaves[lay] == 2) { // staggered geometry
+      return getFirstChipIndex(lay, petalcase, subDetID) + stave * mNumberOfHalfStaves[lay] + halfstave;
+    } else if (mNumberOfHalfStaves[lay] == 1) { // turbo geometry
+      return getFirstChipIndex(lay, petalcase, subDetID) + stave;
+    }
+  }
+  return -1; // not found
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave) const
+{
+  if (subDetID == 0) { // VD
+    return volume;     /// In the current configuration for VD, each volume is the sensor element = chip. // TODO: when the geometry naming scheme will be changed, change this method
+
+  } else if (subDetID == 1) {            // MLOT
+    if (mNumberOfHalfStaves[lay] == 2) { // staggered geometry
+      return getFirstChipIndex(lay, -1, subDetID) + stave * mNumberOfHalfStaves[lay] + halfstave;
+    } else if (mNumberOfHalfStaves[lay] == 1) { // turbo geometry
+      return getFirstChipIndex(lay, -1, subDetID) + stave;
+    }
   }
   return -1; // not found
 }
 
 //__________________________________________________________________________
-bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave) const
+bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave) const
 {
   subDetID = getSubDetID(index);
   petalcase = getPetalCase(index);
   disk = getDisk(index);
   lay = getLayer(index);
   stave = getStave(index);
+  halfstave = getHalfStave(index);
 
   return kTRUE;
 }
@@ -223,13 +263,12 @@ bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk
 TString GeometryTGeo::getMatrixPath(int index) const
 {
 
-  // int lay, hba, stav, sstav, mod, chipInMod;
-  int subDetID, petalcase, disk, lay, stave; //// TODO: add chips in a second step
-  getChipID(index, subDetID, petalcase, disk, lay, stave);
+  int subDetID, petalcase, disk, lay, stave, halfstave; //// TODO: add chips in a second step
+  getChipID(index, subDetID, petalcase, disk, lay, stave, halfstave);
 
-  int indexRetrieved = getChipIndex(subDetID, petalcase, disk, lay, stave);
+  int indexRetrieved = getChipIndex(subDetID, petalcase, disk, lay, stave, halfstave);
 
-  PrintChipID(index, subDetID, petalcase, disk, lay, stave, indexRetrieved);
+  PrintChipID(index, subDetID, petalcase, disk, lay, stave, halfstave, indexRetrieved);
 
   // TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
   TString path = "/cave_1/barrel_1/TRKV_2/TRKLayer0_1/TRKStave0_1/TRKChip0_1/TRKSensor0_1/"; /// dummy path, to be replaced
@@ -291,7 +330,7 @@ TGeoHMatrix* GeometryTGeo::extractMatrixSensor(int index) const
   auto path = getMatrixPath(index);
 
   static TGeoHMatrix matTmp;
-  gGeoManager->PushPath();
+  // gGeoManager->PushPath(); // Preserve the modeler state.
 
   // if (!gGeoManager->cd(path.Data())) {
   //   gGeoManager->PopPath();
@@ -440,7 +479,6 @@ int GeometryTGeo::extractNumberOfActivePartsVD() const
   if (vdV == nullptr) {
     LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
   }
-  LOG(info) << "Volume name: " << getTRKVolPattern();
 
   // Loop on all TRKV nodes, count Layer volumes by checking names
   TObjArray* nodes = vdV->GetNodes();
@@ -470,7 +508,6 @@ int GeometryTGeo::extractNumberOfDisksVD() const
   if (vdV == nullptr) {
     LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
   }
-  LOG(info) << "Volume name: " << getTRKVolPattern();
 
   // Loop on all TRKV nodes, count Layer volumes by checking names
   TObjArray* nodes = vdV->GetNodes();
@@ -500,7 +537,6 @@ int GeometryTGeo::extractNumberOfPetalsVD() const
   if (vdV == nullptr) {
     LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
   }
-  LOG(info) << "Volume name: " << getTRKVolPattern();
 
   // Loop on all TRKV nodes, count Layer volumes by checking names
   TObjArray* nodes = vdV->GetNodes();
@@ -530,7 +566,6 @@ int GeometryTGeo::extractNumberOfLayersVD() const
   if (vdV == nullptr) {
     LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
   }
-  LOG(info) << "Volume name: " << getTRKVolPattern();
 
   // Loop on all TRKV nodes, count Layer volumes by checking names
   TObjArray* nodes = vdV->GetNodes();
@@ -560,7 +595,6 @@ int GeometryTGeo::extractNumberOfChipsPerPetalVD() const
   if (vdV == nullptr) {
     LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
   }
-  LOG(info) << "Volume name: " << getTRKVolPattern();
 
   // Loop on all TRKV nodes, count Layer volumes by checking names
   TObjArray* nodes = vdV->GetNodes();
@@ -610,7 +644,35 @@ int GeometryTGeo::extractNumberOfStavesMLOT(int lay) const
 }
 
 //__________________________________________________________________________
-void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int indexRetrieved) const
+int GeometryTGeo::extractNumberOfHalfStavesMLOT(int lay) const
+{
+  int numberOfHalfStaves = 0;
+
+  std::string staveName = Form("%s%d", getTRKStavePattern(), lay);
+  TGeoVolume* staveV = gGeoManager->GetVolume(staveName.c_str());
+
+  if (staveV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKStavePattern() << " is not in the geometry";
+  }
+
+  // Loop on all layV nodes, count Layer volumes by checking names
+  TObjArray* nodes = staveV->GetNodes();
+  // std::cout << "Printing nodes for layer " << lay << std::endl;
+  // nodes->Print();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j = 0; j < nNodes; j++) {
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j)); /// layer node
+    const char* name = nd->GetName();
+    if (strstr(name, getTRKChipPattern()) != nullptr) {
+      numberOfHalfStaves++;
+    }
+  }
+  return numberOfHalfStaves;
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int indexRetrieved) const
 {
   std::cout << "\nindex = " << index << std::endl;
   std::cout << "subDetID = " << subDetID << std::endl;
@@ -619,7 +681,8 @@ void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk,
   std::cout << "disk = " << disk << std::endl;
   std::cout << "first chip index = " << getFirstChipIndex(lay, petalcase, subDetID) << std::endl;
   std::cout << "stave = " << stave << std::endl;
-  std::cout << "chck index Retrieved = " << indexRetrieved << std::endl;
+  std::cout << "halfstave = " << halfstave << std::endl;
+  std::cout << "check index Retrieved = " << indexRetrieved << std::endl;
 }
 
 //__________________________________________________________________________
@@ -641,11 +704,11 @@ void GeometryTGeo::Print(Option_t*) const
   for (int i = 0; i < mNumberOfPetalsVD; i++) {
     LOGF(info, "%d", mNumberOfChipsPerPetalVD[i]);
   }
-  LOGF(info, "Number of staves per layer MLOT: ");
+  LOGF(info, "Number of staves and half staves per layer MLOT: ");
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
     std::string mlot = "";
-    mlot = (i < 5) ? "ML" : "OT";
-    LOGF(info, "Layer: %d, %s, %d staves", i, mlot.c_str(), mNumberOfStaves[i]);
+    mlot = (i < 4) ? "ML" : "OT";
+    LOGF(info, "Layer: %d, %s, %d staves, %d half staves per stave", i, mlot.c_str(), mNumberOfStaves[i], mNumberOfHalfStaves[i]);
   }
   LOGF(info, "Total number of chips: %d", getNumberOfChips());
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
index 31f3da7a00bb4..8ed5737abcb35 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
@@ -31,6 +31,9 @@ namespace trk
 class Detector : public o2::base::DetImpl<Detector>
 {
  public:
+  static constexpr Int_t mNumberOfVolumes = 44;   /// hardcoded for the current geometry = 8 MLOT layers + 36 volumes in the VD. TODO: automatize or change according to the current geometry
+  static constexpr Int_t mNumberOfVolumesVD = 36; /// hardcoded for the current geometry = 36 volumes in the VD. TODO: automatize or change according to the current geometry
+
   Detector(bool active);
   Detector();
   ~Detector();
@@ -96,6 +99,18 @@ class Detector : public o2::base::DetImpl<Detector>
 
   void defineSensitiveVolumes();
 
+ protected:
+  std::vector<int> mSensorID;       //! layer identifiers
+  std::vector<TString> mSensorName; //! layer names
+
+ public:
+  static constexpr Int_t sNumberVDPetalCases = 4;          //! Number of VD petals
+  int getNumberOfLayers() const { return mLayers.size(); } //! Number of TRK layers
+  int getNumberOfLayersVD() const { return mPetalCases[0].mPetalLayers.size(); }
+  int getNumberOfDisksVD() const { return mPetalCases[0].mPetalDisks.size(); }
+
+  void Print(FairVolume* vol, int volume, int subDetID, int layer, int stave, int halfstave, int chipID) const;
+
   template <typename Det>
   friend class o2::base::DetImpl;
   ClassDefOverride(Detector, 1);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 9b8ffc07b2d0e..f5027310fa66d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -53,6 +53,28 @@ Detector::Detector(bool active)
     configServices();
   }
 
+  mSensorName.resize(mNumberOfVolumes); // hardcoded. TODO: change size when a different naming scheme for VD is in place. Ideally could be 4 petals + 8 layers = 12
+  int VDvolume = 0;
+  for (int i = 0; i < 4; i++) { /// VD
+    for (int j = 0; j < 3; j++) {
+      mSensorName[VDvolume].Form("%s%d_%s%d_%s%d", GeometryTGeo::getTRKPetalPattern(), i, GeometryTGeo::getTRKPetalLayerPattern(), j, GeometryTGeo::getTRKSensorPattern(), j);
+      VDvolume++;
+    }
+    for (int j = 0; j < 6; j++) {
+      mSensorName[VDvolume].Form("%s%d_%s%d_%s%d", GeometryTGeo::getTRKPetalPattern(), i, GeometryTGeo::getTRKPetalDiskPattern(), j, GeometryTGeo::getTRKSensorPattern(), j);
+      VDvolume++;
+    }
+  }
+
+  for (int i = 0; i < 8; i++) { /// MLOT
+    mSensorName[VDvolume].Form("%s%d", GeometryTGeo::getTRKSensorPattern(), i);
+    VDvolume++;
+  }
+
+  for (auto vd : mSensorName) {
+    std::cout << "Volume name: " << vd << std::endl;
+  }
+
   LOGP(info, "Summary of TRK configuration:");
   for (auto& layer : mLayers) {
     LOGP(info, "Layer: {} name: {} r: {} cm | z: {} cm | thickness: {} cm", layer.getNumber(), layer.getName(), layer.getInnerRadius(), layer.getZ(), layer.getChipThickness());
@@ -241,7 +263,7 @@ void Detector::createGeometry()
   mPetalCases.clear();
   // Add petal cases (the sensitive layers inside the petal cases get constructed here too)
   auto& trkPars = TRKBaseParam::Instance();
-  for (Int_t petalCaseNumber = 0; petalCaseNumber < 4; ++petalCaseNumber) {
+  for (Int_t petalCaseNumber = 0; petalCaseNumber < sNumberVDPetalCases; ++petalCaseNumber) {
     mPetalCases.emplace_back(petalCaseNumber, vTRK, trkPars.irisOpen);
     mServices.excavateFromVacuum(mPetalCases[petalCaseNumber].getFullName());
   }
@@ -253,6 +275,12 @@ void Detector::InitializeO2Detector()
   LOG(info) << "Initialize TRK O2Detector";
   mGeometryTGeo = GeometryTGeo::Instance();
   defineSensitiveVolumes();
+
+  mSensorID.resize(mNumberOfVolumes); // hardcoded. TODO: change size when a different namingh scheme for VD is in place. Ideally could be 4 petals + 8 layers = 12
+  for (int i = 0; i < mNumberOfVolumes; i++) {
+    mSensorID[i] = gMC ? TVirtualMC::GetMC()->VolId(mSensorName[i]) : 0; // Volume ID from the Geant geometry
+    LOGP(info, "{}: mSensorID={}", i, mSensorID[i]);
+  }
 }
 
 void Detector::defineSensitiveVolumes()
@@ -264,7 +292,7 @@ void Detector::defineSensitiveVolumes()
   LOGP(info, "Adding TRK Sensitive Volumes");
 
   // Add petal case sensitive volumes
-  for (int petalCase = 0; petalCase < 4; ++petalCase) {
+  for (int petalCase = 0; petalCase < sNumberVDPetalCases; ++petalCase) {
     // Petal layers
     for (int petalLayer = 0; petalLayer < mPetalCases[petalCase].mPetalLayers.size(); ++petalLayer) {
       volumeName = mPetalCases[petalCase].mPetalLayers[petalLayer].getSensorName();
@@ -338,9 +366,28 @@ bool Detector::ProcessHits(FairVolume* vol)
     return false;
   }
 
-  int lay = vol->getVolumeId();
+  int subDetID = -1;
+  int layer = -1;
+  int volume = 0;
+  int stave = -1;
   int volID = vol->getMCid();
 
+  bool notSens = false;
+  while ((volume < mNumberOfVolumes) && (notSens = (volID != mSensorID[volume]))) {
+    ++volume; /// there are 44 volumes, 36 for the VD (1 for each sensing element) and 8 for the MLOT (1 for each layer)
+  }
+
+  if (notSens) {
+    return kFALSE; // RS: can this happen? This method must be called for sensors only?
+  }
+
+  if (volume < mNumberOfVolumesVD) {
+    subDetID = 0; // VD. For the moment each "chip" is a volume./// TODO: change this logic once the naming scheme is changed
+  } else {
+    subDetID = 1; // MLOT
+    layer = volume - mNumberOfVolumesVD;
+  }
+
   // Is it needed to keep a track reference when the outer ITS volume is encountered?
   auto stack = (o2::data::Stack*)fMC->GetStack();
   // if (fMC->IsTrackExiting() && (lay == 0 || lay == mLayers.size() - 1)) {
@@ -348,7 +395,7 @@ bool Detector::ProcessHits(FairVolume* vol)
     // Keep the track refs for the innermost and outermost layers only
     o2::TrackReference tr(*fMC, GetDetId());
     tr.setTrackID(stack->GetCurrentTrackNumber());
-    tr.setUserId(lay);
+    tr.setUserId(volume);
     stack->addTrackReference(tr);
   }
   bool startHit = false, stopHit = false;
@@ -398,13 +445,17 @@ bool Detector::ProcessHits(FairVolume* vol)
     TLorentzVector positionStop;
     fMC->TrackPosition(positionStop);
     // Retrieve the indices with the volume path
-    int stave(0), halfstave(0), chipinmodule(0), module;
-    fMC->CurrentVolOffID(1, chipinmodule);
-    fMC->CurrentVolOffID(2, module);
-    fMC->CurrentVolOffID(3, halfstave);
-    fMC->CurrentVolOffID(4, stave);
+    int stave(0), halfstave(0);
+    if (subDetID == 1) {
+      fMC->CurrentVolOffID(1, halfstave);
+      fMC->CurrentVolOffID(2, stave);
+    } /// if VD, for the moment the volume is the "chipID" so no need to retrieve other elments
+
+    int chipID = mGeometryTGeo->getChipIndex(subDetID, volume, layer, stave, halfstave);
+
+    Print(vol, volume, subDetID, layer, stave, halfstave, chipID);
 
-    Hit* p = addHit(stack->GetCurrentTrackNumber(), lay, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
+    Hit* p = addHit(stack->GetCurrentTrackNumber(), chipID, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
                     mTrackData.mMomentumStart.Vect(), mTrackData.mMomentumStart.E(), positionStop.T(),
                     mTrackData.mEnergyLoss, mTrackData.mTrkStatusStart, status);
     // p->SetTotalEnergy(vmc->Etot());
@@ -424,6 +475,25 @@ o2::itsmft::Hit* Detector::addHit(int trackID, int detID, const TVector3& startP
   mHits->emplace_back(trackID, detID, startPos, endPos, startMom, startE, endTime, eLoss, startStatus, endStatus);
   return &(mHits->back());
 }
+
+void Detector::Print(FairVolume* vol, int volume, int subDetID, int layer, int stave, int halfstave, int chipID) const
+{
+  int currentVol(0);
+  LOG(info) << "Current volume name: " << fMC->CurrentVolName() << " and ID " << fMC->CurrentVolID(currentVol);
+  LOG(info) << "volume: " << volume << "/" << mNumberOfVolumes - 1;
+  if (subDetID == 1 && mGeometryTGeo->getNumberOfHalfStaves(layer) == 2) { // staggered geometry
+    LOG(info) << "off volume name 1 " << fMC->CurrentVolOffName(1) << "  halfstave: " << halfstave;
+    LOG(info) << "off volume name 2  " << fMC->CurrentVolOffName(2) << "  stave: " << stave;
+    LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  staveinLayer: " << stave << "  Chip ID: " << chipID;
+  } else if (subDetID == 1 && mGeometryTGeo->getNumberOfHalfStaves(layer) == 1) { // turbo geometry
+    LOG(info) << "off volume name 2  " << fMC->CurrentVolOffName(2) << "  stave: " << stave;
+    LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  staveinLayer: " << stave << "  Chip ID: " << chipID;
+  } else {
+    LOG(info) << "SubDetector ID: " << subDetID << "  Chip ID: " << chipID;
+  }
+  LOG(info);
+}
+
 } // namespace trk
 } // namespace o2
 

From 7bbe96466276bf222374d5067be35d5080ee69b5 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 4 Jul 2025 22:07:03 +0200
Subject: [PATCH 0587/1764] DPL: rename log stream to check sockets activity

---
 Framework/Core/src/DataProcessingDevice.cxx | 30 +++++++++++----------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index ba3fc2cd1bedd..a902ed9326e07 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -86,6 +86,8 @@ struct formatter<o2::framework::CompletionPolicy::CompletionOp> : ostream_format
 
 // A log to use for general device logging
 O2_DECLARE_DYNAMIC_LOG(device);
+// A log to use for general device logging
+O2_DECLARE_DYNAMIC_LOG(sockets);
 // Special log to keep track of the lifetime of the parts
 O2_DECLARE_DYNAMIC_LOG(parts);
 // Stream which keeps track of the calibration lifetime logic
@@ -339,21 +341,21 @@ void on_socket_polled(uv_poll_t* poller, int status, int events)
 {
   auto* context = (PollerContext*)poller->data;
   assert(context);
-  O2_SIGNPOST_ID_FROM_POINTER(sid, device, poller);
+  O2_SIGNPOST_ID_FROM_POINTER(sid, sockets, poller);
   context->state->loopReason |= DeviceState::DATA_SOCKET_POLLED;
   switch (events) {
     case UV_READABLE: {
-      O2_SIGNPOST_EVENT_EMIT(device, sid, "socket_state", "Data pending on socket for channel %{public}s", context->name);
+      O2_SIGNPOST_EVENT_EMIT(sockets, sid, "socket_state", "Data pending on socket for channel %{public}s", context->name);
       context->state->loopReason |= DeviceState::DATA_INCOMING;
     } break;
     case UV_WRITABLE: {
-      O2_SIGNPOST_END(device, sid, "socket_state", "Socket connected for channel %{public}s", context->name);
+      O2_SIGNPOST_END(sockets, sid, "socket_state", "Socket connected for channel %{public}s", context->name);
       if (context->read) {
-        O2_SIGNPOST_START(device, sid, "socket_state", "Socket connected for read in context %{public}s", context->name);
+        O2_SIGNPOST_START(sockets, sid, "socket_state", "Socket connected for read in context %{public}s", context->name);
         uv_poll_start(poller, UV_READABLE | UV_DISCONNECT | UV_PRIORITIZED, &on_socket_polled);
         context->state->loopReason |= DeviceState::DATA_CONNECTED;
       } else {
-        O2_SIGNPOST_START(device, sid, "socket_state", "Socket connected for write for channel %{public}s", context->name);
+        O2_SIGNPOST_START(sockets, sid, "socket_state", "Socket connected for write for channel %{public}s", context->name);
         context->state->loopReason |= DeviceState::DATA_OUTGOING;
         // If the socket is writable, fairmq will handle the rest, so we can stop polling and
         // just wait for the disconnect.
@@ -362,10 +364,10 @@ void on_socket_polled(uv_poll_t* poller, int status, int events)
       context->pollerState = PollerContext::PollerState::Connected;
     } break;
     case UV_DISCONNECT: {
-      O2_SIGNPOST_END(device, sid, "socket_state", "Socket disconnected in context %{public}s", context->name);
+      O2_SIGNPOST_END(sockets, sid, "socket_state", "Socket disconnected in context %{public}s", context->name);
     } break;
     case UV_PRIORITIZED: {
-      O2_SIGNPOST_EVENT_EMIT(device, sid, "socket_state", "Socket prioritized for context %{public}s", context->name);
+      O2_SIGNPOST_EVENT_EMIT(sockets, sid, "socket_state", "Socket prioritized for context %{public}s", context->name);
     } break;
   }
   // We do nothing, all the logic for now stays in DataProcessingDevice::doRun()
@@ -373,7 +375,7 @@ void on_socket_polled(uv_poll_t* poller, int status, int events)
 
 void on_out_of_band_polled(uv_poll_t* poller, int status, int events)
 {
-  O2_SIGNPOST_ID_FROM_POINTER(sid, device, poller);
+  O2_SIGNPOST_ID_FROM_POINTER(sid, sockets, poller);
   auto* context = (PollerContext*)poller->data;
   context->state->loopReason |= DeviceState::OOB_ACTIVITY;
   if (status < 0) {
@@ -382,27 +384,27 @@ void on_out_of_band_polled(uv_poll_t* poller, int status, int events)
   }
   switch (events) {
     case UV_READABLE: {
-      O2_SIGNPOST_EVENT_EMIT(device, sid, "socket_state", "Data pending on socket for channel %{public}s", context->name);
+      O2_SIGNPOST_EVENT_EMIT(sockets, sid, "socket_state", "Data pending on socket for channel %{public}s", context->name);
       context->state->loopReason |= DeviceState::DATA_INCOMING;
       assert(context->channelInfo);
       context->channelInfo->readPolled = true;
     } break;
     case UV_WRITABLE: {
-      O2_SIGNPOST_END(device, sid, "socket_state", "OOB socket connected for channel %{public}s", context->name);
+      O2_SIGNPOST_END(sockets, sid, "socket_state", "OOB socket connected for channel %{public}s", context->name);
       if (context->read) {
-        O2_SIGNPOST_START(device, sid, "socket_state", "OOB socket connected for read in context %{public}s", context->name);
+        O2_SIGNPOST_START(sockets, sid, "socket_state", "OOB socket connected for read in context %{public}s", context->name);
         uv_poll_start(poller, UV_READABLE | UV_DISCONNECT | UV_PRIORITIZED, &on_out_of_band_polled);
       } else {
-        O2_SIGNPOST_START(device, sid, "socket_state", "OOB socket connected for write for channel %{public}s", context->name);
+        O2_SIGNPOST_START(sockets, sid, "socket_state", "OOB socket connected for write for channel %{public}s", context->name);
         context->state->loopReason |= DeviceState::DATA_OUTGOING;
       }
     } break;
     case UV_DISCONNECT: {
-      O2_SIGNPOST_END(device, sid, "socket_state", "OOB socket disconnected in context %{public}s", context->name);
+      O2_SIGNPOST_END(sockets, sid, "socket_state", "OOB socket disconnected in context %{public}s", context->name);
       uv_poll_start(poller, UV_WRITABLE, &on_out_of_band_polled);
     } break;
     case UV_PRIORITIZED: {
-      O2_SIGNPOST_EVENT_EMIT(device, sid, "socket_state", "OOB socket prioritized for context %{public}s", context->name);
+      O2_SIGNPOST_EVENT_EMIT(sockets, sid, "socket_state", "OOB socket prioritized for context %{public}s", context->name);
     } break;
   }
   // We do nothing, all the logic for now stays in DataProcessingDevice::doRun()

From d807214812da4d6d571b34ebcbc5d5fae2dfb1ff Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 5 Jul 2025 11:22:58 +0200
Subject: [PATCH 0588/1764] DPL: add signposts with log-level detail.

---
 Framework/Foundation/include/Framework/Signpost.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/Framework/Foundation/include/Framework/Signpost.h b/Framework/Foundation/include/Framework/Signpost.h
index 781a2242375c8..0ea0a1f5ec75b 100644
--- a/Framework/Foundation/include/Framework/Signpost.h
+++ b/Framework/Foundation/include/Framework/Signpost.h
@@ -532,6 +532,17 @@ void o2_debug_log_set_stacktrace(_o2_log_t* log, int stacktrace)
   }                                                                                                                 \
 })
 
+// Similar to the above, however it will print a normal info message if the signpost is not enabled.
+#define O2_SIGNPOST_EVENT_EMIT_DETAIL(log, id, name, format, ...) __extension__({                                   \
+  if (O2_BUILTIN_UNLIKELY(O2_SIGNPOST_ENABLED_MAC(log))) {                                                          \
+    O2_SIGNPOST_EVENT_EMIT_MAC(log, id, name, format, ##__VA_ARGS__);                                               \
+  } else if (O2_BUILTIN_UNLIKELY(private_o2_log_##log->stacktrace)) {                                               \
+    _o2_signpost_event_emit(private_o2_log_##log, id, name, remove_engineering_type(format).data(), ##__VA_ARGS__); \
+  } else {                                                                                                          \
+    O2_LOG_MACRO_RAW(detail, remove_engineering_type(format).data(), ##__VA_ARGS__);                                \
+  }                                                                                                                 \
+})
+
 // Similar to the above, however it will always print a normal error message regardless of the signpost being enabled or not.
 #define O2_SIGNPOST_EVENT_EMIT_ERROR(log, id, name, format, ...) __extension__({                                    \
   if (O2_BUILTIN_UNLIKELY(O2_SIGNPOST_ENABLED_MAC(log))) {                                                          \

From 2a7442d525a673398d5f972b9ca3267f90101c40 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 4 Jul 2025 09:37:31 +0200
Subject: [PATCH 0589/1764] GPU Standalone CI: With the new build container, we
 can also build Vulkan and Wayland front/backends

---
 GPU/GPUTracking/Standalone/cmake/build.sh | 2 --
 1 file changed, 2 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/cmake/build.sh b/GPU/GPUTracking/Standalone/cmake/build.sh
index 1f7f446a336ac..8128603b6e923 100755
--- a/GPU/GPUTracking/Standalone/cmake/build.sh
+++ b/GPU/GPUTracking/Standalone/cmake/build.sh
@@ -13,8 +13,6 @@ if [[ $GPUCA_STANDALONE_CI == 1 ]]; then
   set(ENABLE_HIP 1)
   set(ENABLE_OPENCL 1)
   set(GPUCA_CONFIG_ONNX 1)
-  set(GPUCA_BUILD_EVENT_DISPLAY_VULKAN 0)
-  set(GPUCA_BUILD_EVENT_DISPLAY_WAYLAND 0)
   set(GPUCA_BUILD_EVENT_DISPLAY_QT 0)
   set(GPUCA_CONFIG_WERROR 1)
 EOF

From d9d6894dc2b8990a93444ec7a1dbcc9307502f6e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 6 Jul 2025 19:49:52 +0200
Subject: [PATCH 0590/1764] TPC QA: Separate normalized attached counts for
 non-fake and all tracks

---
 GPU/GPUTracking/qa/GPUQA.cxx | 31 +++++++++++++++++++++----------
 GPU/GPUTracking/qa/GPUQA.h   |  3 ++-
 2 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index b32ef80c7c87a..6f640578a8804 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -234,6 +234,7 @@ inline float GPUQA::GetMCLabelWeight(const mcLabel_t& label) { return 1; }
 inline bool GPUQA::mcPresent() { return !mConfig.noMC && mTracking && mClNative && mClNative->clustersMCTruth && mMCInfos.size(); }
 uint32_t GPUQA::GetMCLabelCol(const mcLabel_t& label) const { return !label.isValid() ? 0 : (mMCEventOffset[label.getSourceID()] + label.getEventID()); }
 GPUQA::mcLabelI_t GPUQA::GetMCTrackLabel(uint32_t trackId) const { return trackId >= mTrackMCLabels.size() ? MCCompLabel() : mTrackMCLabels[trackId]; }
+bool GPUQA::CompareIgnoreFake(const mcLabelI_t& l1, const mcLabelI_t& l2) { return l1.compare(l2) >= 0; }
 #define TRACK_EXPECTED_REFERENCE_X 78
 #else
 inline GPUQA::mcLabelI_t::mcLabelI_t(const GPUQA::mcLabel_t& l) : track(l.fMCID) {}
@@ -263,6 +264,7 @@ inline int32_t GPUQA::AbsLabelID(int32_t id) { return id >= 0 ? id : (-id - 2);
 inline bool GPUQA::mcPresent() { return !mConfig.noMC && mTracking && GetNMCLabels() && GetNMCTracks(0); }
 uint32_t GPUQA::GetMCLabelCol(const mcLabel_t& label) const { return 0; }
 GPUQA::mcLabelI_t GPUQA::GetMCTrackLabel(uint32_t trackId) const { return trackId >= mTrackMCLabels.size() ? mcLabelI_t() : mTrackMCLabels[trackId]; }
+bool GPUQA::CompareIgnoreFake(const mcLabelI_t& l1, const mcLabelI_t& l2) { return AbsLabelID(l1) == AbsLabelID(l2); }
 #define TRACK_EXPECTED_REFERENCE_X TRACK_EXPECTED_REFERENCE_X_DEFAULT
 #endif
 template <class T>
@@ -1660,7 +1662,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
 
   if (mQATasks & taskTrackStatistics) {
     // Fill track statistic histograms
-    std::vector<std::array<float, 2>> clusterAttachCounts;
+    std::vector<std::array<float, 3>> clusterAttachCounts;
     if (mcAvail) {
       clusterAttachCounts.resize(GetNMCLabels(), {0.f, 0.f});
     }
@@ -1691,17 +1693,23 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             if (cl.state & GPUTPCGMMergedTrackHit::flagReject) {
               continue;
             }
-            bool labelOk = false;
-            if (mTrackMCLabels[i].isValid() && !mTrackMCLabels[i].isFake()) {
+            bool labelOk = false, labelOkNonFake = false;
+            const mcLabelI_t& trkLabel = mTrackMCLabels[i];
+            if (trkLabel.isValid() && !trkLabel.isNoise()) {
               for (int32_t l = 0; l < GetMCLabelNID(cl.num); l++) {
-                if (GetMCLabel(cl.num, l) == mTrackMCLabels[i]) {
+                const mcLabelI_t& clLabel = GetMCLabel(cl.num, l);
+                if (clLabel.isValid() && !clLabel.isNoise() && CompareIgnoreFake(trkLabel, clLabel)) {
                   labelOk = true;
+                  if (!trkLabel.isFake()) {
+                    labelOkNonFake = true;
+                  }
                   break;
                 }
               }
             }
-            clusterAttachCounts[cl.num][0] += (float)labelOk / rowClCount;
-            clusterAttachCounts[cl.num][1] += 1.0f;
+            clusterAttachCounts[cl.num][0] += 1.0f;
+            clusterAttachCounts[cl.num][1] += (float)labelOk / rowClCount;
+            clusterAttachCounts[cl.num][2] += (float)labelOkNonFake / rowClCount;
           }
         }
       }
@@ -1721,13 +1729,15 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       }
     }
     if (mcAvail) {
-      double clusterAttachNormalizedCount = 0;
+      double clusterAttachNormalizedCount = 0, clusterAttachNormalizedCountNonFake = 0;
       for (uint32_t i = 0; i < clusterAttachCounts.size(); i++) {
-        if (clusterAttachCounts[i][1]) {
-          clusterAttachNormalizedCount += clusterAttachCounts[i][0] / clusterAttachCounts[i][1];
+        if (clusterAttachCounts[i][0]) {
+          clusterAttachNormalizedCount += clusterAttachCounts[i][1] / clusterAttachCounts[i][0];
+          clusterAttachNormalizedCountNonFake += clusterAttachCounts[i][2] / clusterAttachCounts[i][0];
         }
       }
       mClusterCounts.nCorrectlyAttachedNormalized = clusterAttachNormalizedCount;
+      mClusterCounts.nCorrectlyAttachedNormalizedNonFake = clusterAttachNormalizedCountNonFake;
       clusterAttachCounts.clear();
     }
 
@@ -2901,7 +2911,8 @@ int32_t GPUQA::DoClusterCounts(uint64_t* attachClusterCounts, int32_t mode)
     PrintClusterCount(mode, num, "Fake Protect (< 40 MeV)", mClusterCounts.nFakeProtect40, mClusterCounts.nBelow40);
   }
   if (mcPresent() && (mQATasks & taskTrackStatistics)) {
-    PrintClusterCount(mode, num, "Correctly Attached non-fake normalized", mClusterCounts.nCorrectlyAttachedNormalized, mClusterCounts.nTotal);
+    PrintClusterCount(mode, num, "Correctly Attached all-trk normalized", mClusterCounts.nCorrectlyAttachedNormalized, mClusterCounts.nTotal);
+    PrintClusterCount(mode, num, "Correctly Attached non-fake normalized", mClusterCounts.nCorrectlyAttachedNormalizedNonFake, mClusterCounts.nTotal);
   }
   return num;
 }
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 9e137f6a6b34c..e587b15f68d80 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -226,6 +226,7 @@ class GPUQA
   float GetMCLabelWeight(uint32_t i, uint32_t j);
   float GetMCLabelWeight(const mcLabels_t& label, uint32_t j);
   float GetMCLabelWeight(const mcLabel_t& label);
+  static bool CompareIgnoreFake(const mcLabelI_t& l1, const mcLabelI_t& l2);
   const auto& GetClusterLabels();
   bool mcPresent();
 
@@ -290,7 +291,7 @@ class GPUQA
   TLegend* mLClust[N_CLS_TYPE];
 
   struct counts_t {
-    int64_t nRejected = 0, nTube = 0, nTube200 = 0, nLoopers = 0, nLowPt = 0, n200MeV = 0, nPhysics = 0, nProt = 0, nUnattached = 0, nTotal = 0, nHighIncl = 0, nAbove400 = 0, nFakeRemove400 = 0, nFullFakeRemove400 = 0, nBelow40 = 0, nFakeProtect40 = 0, nMergedLooper = 0, nCorrectlyAttachedNormalized = 0;
+    int64_t nRejected = 0, nTube = 0, nTube200 = 0, nLoopers = 0, nLowPt = 0, n200MeV = 0, nPhysics = 0, nProt = 0, nUnattached = 0, nTotal = 0, nHighIncl = 0, nAbove400 = 0, nFakeRemove400 = 0, nFullFakeRemove400 = 0, nBelow40 = 0, nFakeProtect40 = 0, nMergedLooper = 0, nCorrectlyAttachedNormalized = 0, nCorrectlyAttachedNormalizedNonFake = 0;
     double nUnaccessible = 0;
   } mClusterCounts;
 

From b05744ad5c006ba9aad2827b6f1ca7115574f3ae Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 8 Jul 2025 11:53:02 +0200
Subject: [PATCH 0591/1764] DPL: improve debug information in case of circular
 dependencies.

---
 Framework/Core/src/runDataProcessing.cxx | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index f1111da79edd5..d691041a366cf 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -2835,6 +2835,20 @@ std::unique_ptr<o2::framework::ServiceRegistry> createRegistry()
   return std::make_unique<o2::framework::ServiceRegistry>();
 }
 
+void describeDataProcessorSpec(std::ostream& stream, DataProcessorSpec const& spec)
+{
+  stream << spec.name;
+  if (!spec.labels.empty()) {
+    stream << "(";
+    bool first = false;
+    for (auto& label : spec.labels) {
+      stream << (first ? "" : ",") << label.value;
+      first = true;
+    }
+    stream << ")";
+  }
+}
+
 // This is a toy executor for the workflow spec
 // What it needs to do is:
 //
@@ -3059,18 +3073,22 @@ int doMain(int argc, char** argv, o2::framework::WorkflowSpec const& workflow,
           edges.emplace_back(i, j);
           if (both) {
             std::ostringstream str;
+            describeDataProcessorSpec(str, physicalWorkflow[i]);
+            str << " has circular dependency with ";
+            describeDataProcessorSpec(str, physicalWorkflow[j]);
+            str << ":\n";
             for (auto x : {i, j}) {
               str << physicalWorkflow[x].name << ":\n";
               str << "inputs:\n";
               for (auto& input : physicalWorkflow[x].inputs) {
-                str << "- " << input << "\n";
+                str << "- " << input << " " << (int)input.lifetime << "\n";
               }
               str << "outputs:\n";
               for (auto& output : physicalWorkflow[x].outputs) {
-                str << "- " << output << "\n";
+                str << "- " << output << " " << (int)output.lifetime << "\n";
               }
             }
-            throw std::runtime_error(physicalWorkflow[i].name + " has circular dependency with " + physicalWorkflow[j].name + ":\n" + str.str());
+            throw std::runtime_error(str.str());
           }
         }
       }

From dd12eda43a3bd84124d7957b0af06a8a26de993c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 8 Jul 2025 12:16:05 +0200
Subject: [PATCH 0592/1764] DPL: remove duplicate branch.

---
 Framework/Core/src/TopologyPolicy.cxx | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/Framework/Core/src/TopologyPolicy.cxx b/Framework/Core/src/TopologyPolicy.cxx
index 5458d9d65da4a..5cdef818f3aaf 100644
--- a/Framework/Core/src/TopologyPolicy.cxx
+++ b/Framework/Core/src/TopologyPolicy.cxx
@@ -87,10 +87,6 @@ bool sporadicDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
   if (isAWithSporadicInput && isBWithSporadicInput) {
     return false;
   }
-  // If a has sporadic inputs
-  if (isAWithSporadicInput && isBWithSporadicInput) {
-    return false;
-  }
 
   // We have a with sporadic inputs. We sort it later, unless there was already some actual
   // dependency between A and B.

From 1071e77be9a714d13b026278aadcc53c694b25c7 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 8 Jul 2025 12:20:21 +0200
Subject: [PATCH 0593/1764] DPL: fix missing return true in ToologyPolicy

---
 Framework/Core/src/TopologyPolicy.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Framework/Core/src/TopologyPolicy.cxx b/Framework/Core/src/TopologyPolicy.cxx
index 5cdef818f3aaf..a36f478909d6b 100644
--- a/Framework/Core/src/TopologyPolicy.cxx
+++ b/Framework/Core/src/TopologyPolicy.cxx
@@ -196,6 +196,7 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
     if (sporadic) {
       O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "%s is expendable. No inverse dependency from %s to %s. However the former has an occasioanl input => true.",
                       a.name.c_str(), b.name.c_str(), a.name.c_str());
+      return true;
     }
     O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "%s is expendable. No inverse dependency from %s to %s => false.",
                     a.name.c_str(), b.name.c_str(), a.name.c_str());

From 1f08dbe505b1a01fe5d6c290c6f82d5995695fe1 Mon Sep 17 00:00:00 2001
From: Fabrizio <fabrizio.grosa@cern.ch>
Date: Tue, 8 Jul 2025 17:11:56 +0200
Subject: [PATCH 0594/1764] [ITS3] Fix Y position of ITS3 clusters and hits
 (#14483)

* Fix Y position of ITS3 clusters and hits

* Please consider the following formatting changes

* Fix namespace

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../ITS3/base/include/ITS3Base/SpecsV2.h      |  3 +-
 .../ITS3/macros/test/CheckClustersITS3.C      | 45 ++++++++++---------
 .../ITS3/macros/test/CreateDictionariesITS3.C | 35 ++++++++++++---
 .../reconstruction/src/TopologyDictionary.cxx |  2 +
 4 files changed, 58 insertions(+), 27 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
index 83db7632e72f4..cb6af1dcfc5b7 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
@@ -147,8 +147,7 @@ namespace apts
 {
 constexpr double pitchX{15.0 * mu};
 constexpr double pitchZ{15.0 * mu};
-constexpr double responseUpperLimit{10 * mu};
-constexpr double responseYShift{responseUpperLimit - silicon::thicknessOut};
+constexpr double responseYShift{15.5 * mu};
 } // namespace apts
 namespace moss
 {
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C b/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
index 006271a1ea7bd..f245a047377ae 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
@@ -225,28 +225,33 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
       locH = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
       locHsta = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
 
-      float x0 = locHsta.X(), dltx = locH.X() - x0;
-      float y0 = locHsta.Y(), dlty = locH.Y() - y0;
-      float z0 = locHsta.Z(), dltz = locH.Z() - z0;
-      auto r = (0.5 * (Segmentation::SensorLayerThickness - Segmentation::SensorLayerThicknessEff) - y0) / dlty;
-
-      if (!isIB) {
-        locH.SetXYZ(x0 + r * dltx, y0 + r * dlty, z0 + r * dltz);
+      float x0, y0, z0, dltx, dlty, dltz, r;
+      if (isIB) {
+        float xFlat{0.}, yFlat{0.};
+        mMosaixSegmentations[layer].curvedToFlat(locC.X(), locC.Y(), xFlat, yFlat);
+        locC.SetCoordinates(xFlat, yFlat, locC.Z());
+        mMosaixSegmentations[layer].curvedToFlat(locH.X(), locH.Y(), xFlat, yFlat);
+        locH.SetCoordinates(xFlat, yFlat, locH.Z());
+        mMosaixSegmentations[layer].curvedToFlat(locHsta.X(), locHsta.Y(), xFlat, yFlat);
+        locHsta.SetCoordinates(xFlat, yFlat, locHsta.Z());
+        x0 = locHsta.X();
+        dltx = locH.X() - x0;
+        y0 = locHsta.Y();
+        dlty = locH.Y() - y0;
+        z0 = locHsta.Z();
+        dltz = locH.Z() - z0;
+        r = (o2::its3::constants::pixelarray::pixels::apts::responseYShift - y0) / dlty;
       } else {
-        // compare in local flat coordinates
-        float xFlatEnd{0.}, yFlatEnd{0.};
-        mMosaixSegmentations[layer].curvedToFlat(locH.X(), locH.Y(), xFlatEnd, yFlatEnd);
-        locH.SetXYZ(xFlatEnd, yFlatEnd, locH.Z());
-        float xFlatSta{0.}, yFlatSta{0.};
-        mMosaixSegmentations[layer].curvedToFlat(locHsta.X(), locHsta.Y(), xFlatSta, yFlatSta);
-        locHsta.SetXYZ(xFlatSta, yFlatSta, locHsta.Z());
-
-        // not really precise, but okish
-        locH.SetXYZ(0.5f * (locH.X() + locHsta.X()), 0.5f * (locH.Y() + locHsta.Y()), 0.5f * (locH.Z() + locHsta.Z()));
-
-        mMosaixSegmentations[layer].curvedToFlat(locC.X(), locC.Y(), xFlatSta, yFlatSta);
-        locC.SetXYZ(xFlatSta, yFlatSta, locC.Z());
+        x0 = locHsta.X();
+        dltx = locH.X() - x0;
+        y0 = locHsta.Y();
+        dlty = locH.Y() - y0;
+        z0 = locHsta.Z();
+        dltz = locH.Z() - z0;
+        r = (0.5 * (Segmentation::SensorLayerThickness - Segmentation::SensorLayerThicknessEff) - y0) / dlty;
       }
+      locH.SetXYZ(x0 + r * dltx, y0 + r * dlty, z0 + r * dltz);
+
       float theta = std::acos(gloC.Z() / gloC.Rho());
       float eta = -std::log(std::tan(theta / 2));
 
diff --git a/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C b/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
index 459e3c59d1e82..c02b4bc238955 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CreateDictionariesITS3.C
@@ -33,6 +33,7 @@
 #define ENABLE_UPGRADES
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "ITSBase/GeometryTGeo.h"
+#include "ITS3Base/SpecsV2.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "ITS3Base/SegmentationMosaix.h"
 #include "DataFormatsITSMFT/CompCluster.h"
@@ -94,7 +95,7 @@ void CreateDictionariesITS3(bool saveDeltas = true,
   TNtuple* nt = nullptr;
   if (saveDeltas) {
     fout = TFile::Open("CreateDictionaries.root", "recreate");
-    nt = new TNtuple("nt", "hashes ntuple", "hash:layer:chipID:xhf:zhf:xcf:zcf:dx:dz:outlimDx:outlimDz");
+    nt = new TNtuple("nt", "hashes ntuple", "hash:layer:chipID:xhf:zhf:xcf:zcf:dx:dz:outlimDx:outlimDz:clusterSize:eta");
   }
 
   const o2::steer::DigitizationContext* digContext = nullptr;
@@ -270,16 +271,34 @@ void CreateDictionariesITS3(bool saveDeltas = true,
                 auto xyzLocE = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
                 auto xyzLocS = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
                 o2::math_utils::Vector3D<float> xyzLocM;
-                xyzLocM.SetCoordinates(0.5f * (xyzLocE.X() + xyzLocS.X()), 0.5f * (xyzLocE.Y() + xyzLocS.Y()), 0.5f * (xyzLocE.Z() + xyzLocS.Z()));
                 auto locC = o2::its3::TopologyDictionary::getClusterCoordinates(cluster, pattern, false);
                 int layer = gman->getLayer(chipID);
+                float x0, y0, z0, dltx, dlty, dltz, r;
                 if (ib) {
                   float xFlat{0.}, yFlat{0.};
-                  mMosaixSegmentations[layer].curvedToFlat(xyzLocM.X(), xyzLocM.Y(), xFlat, yFlat);
-                  xyzLocM.SetCoordinates(xFlat, yFlat, xyzLocM.Z());
                   mMosaixSegmentations[layer].curvedToFlat(locC.X(), locC.Y(), xFlat, yFlat);
                   locC.SetCoordinates(xFlat, yFlat, locC.Z());
+                  mMosaixSegmentations[layer].curvedToFlat(xyzLocE.X(), xyzLocE.Y(), xFlat, yFlat);
+                  xyzLocE.SetCoordinates(xFlat, yFlat, xyzLocE.Z());
+                  mMosaixSegmentations[layer].curvedToFlat(xyzLocS.X(), xyzLocS.Y(), xFlat, yFlat);
+                  xyzLocS.SetCoordinates(xFlat, yFlat, xyzLocS.Z());
+                  x0 = xyzLocS.X();
+                  dltx = xyzLocE.X() - x0;
+                  y0 = xyzLocS.Y();
+                  dlty = xyzLocE.Y() - y0;
+                  z0 = xyzLocS.Z();
+                  dltz = xyzLocE.Z() - z0;
+                  r = (o2::its3::constants::pixelarray::pixels::apts::responseYShift - y0) / dlty;
+                } else {
+                  x0 = xyzLocS.X();
+                  dltx = xyzLocE.X() - x0;
+                  y0 = xyzLocS.Y();
+                  dlty = xyzLocE.Y() - y0;
+                  z0 = xyzLocS.Z();
+                  dltz = xyzLocE.Z() - z0;
+                  r = (0.5 * (Segmentation::SensorLayerThickness - Segmentation::SensorLayerThicknessEff) - y0) / dlty;
                 }
+                xyzLocM.SetXYZ(x0 + r * dltx, y0 + r * dlty, z0 + r * dltz);
 
                 auto pitchX = (ib) ? o2::its3::SegmentationMosaix::PitchRow : o2::itsmft::SegmentationAlpide::PitchRow;
                 auto pitchZ = (ib) ? o2::its3::SegmentationMosaix::PitchCol : o2::itsmft::SegmentationAlpide::PitchCol;
@@ -302,7 +321,13 @@ void CreateDictionariesITS3(bool saveDeltas = true,
                   }
                 }
                 if (saveDeltas) {
-                  nt->Fill(topology.getHash(), layer, chipID, xyzLocM.X(), xyzLocM.Z(), locC.X(), locC.Z(), dX, dZ, outLimitDx, outLimitDz);
+                  auto vectDiff = xyzLocE - xyzLocS;
+                  auto theta = std::acos(vectDiff.Z() / std::hypot(vectDiff.X(), vectDiff.Y(), vectDiff.Z()));
+                  auto eta = -std::log(std::tan(theta / 2));
+                  if (ib) {
+                    LOGP(info, "Yhit flat start: {}, end: {}, middle: {}", xyzLocS.Y(), xyzLocE.Y(), xyzLocM.Y());
+                  }
+                  nt->Fill(topology.getHash(), layer, chipID, xyzLocM.X(), xyzLocM.Z(), locC.X(), locC.Z(), dX, dZ, outLimitDx, outLimitDz, pattern.getNPixels(), eta);
                 }
               }
             } else {
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
index 61ab051ffb565..0d1deb77b7c2e 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
@@ -13,6 +13,7 @@
 
 #include "ITS3Reconstruction/TopologyDictionary.h"
 #include "ITS3Base/SegmentationMosaix.h"
+#include "ITS3Base/SpecsV2.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "CommonUtils/StringUtils.h"
 #include <TFile.h>
@@ -202,6 +203,7 @@ math_utils::Point3D<T> TopologyDictionary::getClusterCoordinates(const itsmft::C
     auto layer = its3::constants::detID::getDetID2Layer(cl.getSensorID());
     mIBSegmentations[layer].detectorToLocalUnchecked(cl.getRow(), cl.getCol(), locCl);
     locCl.SetX(locCl.X() + this->getXCOG(cl.getPatternID(), true) * its3::SegmentationMosaix::PitchRow);
+    locCl.SetY(its3::constants::pixelarray::pixels::apts::responseYShift);
     locCl.SetZ(locCl.Z() + this->getZCOG(cl.getPatternID(), true) * its3::SegmentationMosaix::PitchCol);
     float xCurved{0.f}, yCurved{0.f};
     mIBSegmentations[layer].flatToCurved(locCl.X(), locCl.Y(), xCurved, yCurved);

From 5a776fffb8429a9dcdc86873a70f34171f41ee67 Mon Sep 17 00:00:00 2001
From: Anton Riedel <anton.riedel@cern.ch>
Date: Fri, 4 Jul 2025 14:03:01 +0200
Subject: [PATCH 0595/1764] Feat: add ratio plots to TrackClusters QA task

---
 Detectors/TPC/qc/src/TrackClusters.cxx | 12 ++++++++++--
 Detectors/TPC/qc/src/Tracks.cxx        |  2 +-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/Detectors/TPC/qc/src/TrackClusters.cxx b/Detectors/TPC/qc/src/TrackClusters.cxx
index bcc071920e2e9..f57a35c395d58 100644
--- a/Detectors/TPC/qc/src/TrackClusters.cxx
+++ b/Detectors/TPC/qc/src/TrackClusters.cxx
@@ -35,16 +35,21 @@ struct binning {
   double max;
 };
 
+const binning binsClusters{160, 0., 160.};
 const binning binsSharedClusters{160, 0., 160.};
 const binning binsFoundClusters{160, 0., 160.};
 const binning binsCrossedRows{160, 0., 160.};
+const binning binsRatio{150, 0., 1.5};
 
 //______________________________________________________________________________
 void TrackClusters::initializeHistograms()
 {
   TH1::AddDirectory(false);
+  mMapHist["clusters"].emplace_back(std::make_unique<TH1F>("clusters", "Clusters;NClusters;Entries", binsClusters.bins, binsClusters.min, binsClusters.max));
   mMapHist["sharedClusters"].emplace_back(std::make_unique<TH1F>("sharedClusters", "sharedClusters;NSharedClusters;Entries", binsSharedClusters.bins, binsSharedClusters.min, binsSharedClusters.max));
-  mMapHist["crossedRows"].emplace_back(std::make_unique<TH1F>("crossedRows", "crossedRows;crossedRows;Entries", binsCrossedRows.bins, binsCrossedRows.min, binsCrossedRows.max));
+  mMapHist["crossedRows"].emplace_back(std::make_unique<TH1F>("crossedRows", "crossedRows;NCrossedRows;Entries", binsCrossedRows.bins, binsCrossedRows.min, binsCrossedRows.max));
+  mMapHist["sharedClustersOverClusters"].emplace_back(std::make_unique<TH1F>("sharedClustersOverClusters", "sharedClustersOverClusters;NSharedClusters/NClusters;Entries", binsRatio.bins, binsRatio.min, binsRatio.max));
+  mMapHist["clustersOverCrossedRow"].emplace_back(std::make_unique<TH1F>("clustersOverCrossedRow", "clustersOverCrossedRow;NClusters/NCrossedRows;Entries", binsRatio.bins, binsRatio.min, binsRatio.max));
 }
 
 //______________________________________________________________________________
@@ -71,7 +76,7 @@ bool TrackClusters::processTrackAndClusters(const std::vector<o2::tpc::TrackTPC>
     const auto nCls = uint8_t(track.getNClusters());
     const auto eta = track.getEta();
 
-    if (nCls < mCutMinNCls || dEdxTot < mCutMindEdxTot || abs(eta) > mCutAbsEta) {
+    if (nCls < mCutMinNCls || dEdxTot < mCutMindEdxTot || std::fabs(eta) > mCutAbsEta) {
       continue;
     }
 
@@ -79,8 +84,11 @@ bool TrackClusters::processTrackAndClusters(const std::vector<o2::tpc::TrackTPC>
 
     o2::TrackMethods::countTPCClusters(track, *clusRefs, mBufVec, *clusterIndex, shared, found, crossed);
 
+    mMapHist["clusters"][0]->Fill(found);
     mMapHist["sharedClusters"][0]->Fill(shared);
     mMapHist["crossedRows"][0]->Fill(crossed);
+    mMapHist["sharedClustersOverClusters"][0]->Fill(static_cast<float>(shared) / static_cast<float>(found));
+    mMapHist["clustersOverCrossedRow"][0]->Fill(static_cast<float>(found) / static_cast<float>(crossed));
   }
 
   return true;
diff --git a/Detectors/TPC/qc/src/Tracks.cxx b/Detectors/TPC/qc/src/Tracks.cxx
index 5f29e80c89d2e..dd74502540fb9 100644
--- a/Detectors/TPC/qc/src/Tracks.cxx
+++ b/Detectors/TPC/qc/src/Tracks.cxx
@@ -38,7 +38,7 @@ struct binning {
 const std::vector<std::string_view> types{"A_Pos", "A_Neg", "C_Pos", "C_Neg"};
 const binning binsDCAr{200, -5., 5.};
 const binning binsDCArLargerRange{400, -10., 10.};
-const binning binsEta{200, -1., 1.};
+const binning binsEta{300, -1.5, 1.5};
 const binning binsClus{120, 60., 180.};
 const binning binsClusLargerRange{140, 60., 200.};
 //______________________________________________________________________________

From 00b201b7926db4e5f4c22fb4763502170926b105 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Tue, 3 Jun 2025 16:22:59 +0200
Subject: [PATCH 0596/1764] New methods to query AggregatedRunInfo for MC

This commit is

* slightly changing BasicCCDBManager to be able to
  - retrieve meta information headers
  - retrieve the underlying CCDB api for reuse

* offering an API to build AggregatedRunInfo with values overwritten from
  specific MC production settings

  - This could be used from the analysis side. Analysis needs to identify
    if AOD is from MC, and use the MC production tag (lpm_prod_tag) in the query.

This needs separate upload of MCProdInfo meta-information to CCDB.

Relates to https://its.cern.ch/jira/browse/O2-6027
---
 CCDB/include/CCDB/BasicCCDBManager.h          | 19 ++++--
 .../DataFormatsParameters/AggregatedRunInfo.h | 24 ++++++-
 .../Parameters/src/AggregatedRunInfo.cxx      | 66 ++++++++++++++++++-
 3 files changed, 99 insertions(+), 10 deletions(-)

diff --git a/CCDB/include/CCDB/BasicCCDBManager.h b/CCDB/include/CCDB/BasicCCDBManager.h
index b7bf6920a5c7c..9668097c39473 100644
--- a/CCDB/include/CCDB/BasicCCDBManager.h
+++ b/CCDB/include/CCDB/BasicCCDBManager.h
@@ -108,16 +108,20 @@ class CCDBManagerInstance
 
   /// retrieve an object of type T from CCDB as stored under path, timestamp and metaData
   template <typename T>
-  T* getSpecific(std::string const& path, long timestamp = -1, MD metaData = MD())
+  T* getSpecific(std::string const& path, long timestamp = -1, MD metaData = MD(), std::map<std::string, std::string>* headers = nullptr)
   {
     // TODO: add some error info/handling when failing
     mMetaData = metaData;
-    return getForTimeStamp<T>(path, timestamp);
+    auto obj = getForTimeStamp<T>(path, timestamp);
+    if (headers) {
+      *headers = mHeaders;
+    }
+    return obj;
   }
 
   /// retrieve an object of type T from CCDB as stored under path and using the timestamp in the middle of the run + metadata. The run number is provided separately to conform to typical analysis use (in which case metadata does not include runNumber)
   template <typename T>
-  T* getSpecificForRun(std::string const& path, int runNumber, MD metaData = MD());
+  T* getSpecificForRun(std::string const& path, int runNumber, MD const& metaData = MD());
 
   /// detect online processing modes (i.e. CCDB objects may be updated in the lifetime of the manager)
   bool isOnline() const { return mDeplMode == o2::framework::DeploymentMode::OnlineAUX || mDeplMode == o2::framework::DeploymentMode::OnlineDDS || mDeplMode == o2::framework::DeploymentMode::OnlineECS; }
@@ -129,6 +133,9 @@ class CCDBManagerInstance
     return getForTimeStamp<T>(path, mTimestamp);
   }
 
+  // gain access to underlaying CCDB layer (to allow for more complex queries without need to reinit another API)
+  CcdbApi& getCCDBAccessor() { return mCCDBAccessor; }
+
   bool isHostReachable() const { return mCCDBAccessor.isHostReachable(); }
 
   /// clear all entries in the cache
@@ -230,11 +237,12 @@ class CCDBManagerInstance
 template <typename T>
 T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp)
 {
+  mHeaders.clear(); // we clear at the beginning; to allow to retrieve the header information in a subsequent call
   T* ptr = nullptr;
   mQueries++;
   auto start = std::chrono::system_clock::now();
   if (!isCachingEnabled()) {
-    ptr = mCCDBAccessor.retrieveFromTFileAny<T>(path, mMetaData, timestamp, nullptr, "",
+    ptr = mCCDBAccessor.retrieveFromTFileAny<T>(path, mMetaData, timestamp, &mHeaders, "",
                                                 mCreatedNotAfter ? std::to_string(mCreatedNotAfter) : "",
                                                 mCreatedNotBefore ? std::to_string(mCreatedNotBefore) : "");
     if (!ptr) {
@@ -305,7 +313,6 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp)
     } else {
       cached.cacheValidUntil = -1;
     }
-    mHeaders.clear();
     mMetaData.clear();
     if (!ptr) {
       if (mFatalWhenNull) {
@@ -328,7 +335,7 @@ T* CCDBManagerInstance::getForRun(std::string const& path, int runNumber, bool s
 }
 
 template <typename T>
-T* CCDBManagerInstance::getSpecificForRun(std::string const& path, int runNumber, MD metaData)
+T* CCDBManagerInstance::getSpecificForRun(std::string const& path, int runNumber, MD const& metaData)
 {
   auto [start, stop] = getRunDuration(runNumber, mFatalWhenNull);
   if (start < 0 || stop < 0) {
diff --git a/DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h b/DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h
index e509be97a14fa..bd2cb0c5cbb27 100644
--- a/DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h
+++ b/DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h
@@ -32,7 +32,7 @@ struct AggregatedRunInfo {
   int runNumber = 0;       // run number
   int64_t sor = 0;         // best known timestamp for the start of run
   int64_t eor = 0;         // best known timestamp for end of run
-  int64_t orbitsPerTF = 0; // number of orbits per TF
+  int64_t orbitsPerTF = 0; // number of orbits per TF (takes precedence over that in GRPECS)
   int64_t orbitReset = 0;  // timestamp of orbit reset before run
   int64_t orbitSOR = 0;    // orbit when run starts after orbit reset
   int64_t orbitEOR = 0;    // orbit when run ends after orbit reset
@@ -40,9 +40,27 @@ struct AggregatedRunInfo {
   // we may have pointers to actual data source objects GRPECS, ...
   const o2::parameters::GRPECSObject* grpECS = nullptr; // pointer to GRPECSobject (fetched during struct building)
 
-  // fills and returns AggregatedRunInfo for a given run number.
-  static AggregatedRunInfo buildAggregatedRunInfo(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber);
   static AggregatedRunInfo buildAggregatedRunInfo(int runnumber, long sorMS, long eorMS, long orbitResetMUS, const o2::parameters::GRPECSObject* grpecs, const std::vector<Long64_t>* ctfFirstRunOrbitVec);
+
+  // fills and returns AggregatedRunInfo for a given data run number.
+  static AggregatedRunInfo buildAggregatedRunInfo_DATA(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber);
+
+  // Returns the meta-data (MCProdInfo) associated to production lpm_prod_tag (performed by username)
+  static std::map<std::string, std::string> getMCProdInfo(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber,
+                                                          std::string const& lpm_prod_tag, std::string const& username = "aliprod");
+
+  // function that adjusts with values from MC
+  void adjust_from_MC(o2::ccdb::CCDBManagerInstance& ccdb, int run_number, std::string const& lpm_prod_tag, std::string const& username = "aliprod");
+
+  // Fills and returns AggregatedRunInfo for a given run number.
+  // If a non-empty lpm_prod_tag is given, it will potentially override values with specifics from a
+  // MC production identified by that tag and username.
+  static AggregatedRunInfo buildAggregatedRunInfo(o2::ccdb::CCDBManagerInstance& ccdb,
+                                                  int runnumber,
+                                                  std::string const& lpm_prod_tag = "",
+                                                  std::string const& username = "aliprod");
+
+  ClassDefNV(AggregatedRunInfo, 1);
 };
 
 } // namespace o2::parameters
diff --git a/DataFormats/Parameters/src/AggregatedRunInfo.cxx b/DataFormats/Parameters/src/AggregatedRunInfo.cxx
index 22ce362b5d85a..f8f6439eded83 100644
--- a/DataFormats/Parameters/src/AggregatedRunInfo.cxx
+++ b/DataFormats/Parameters/src/AggregatedRunInfo.cxx
@@ -21,7 +21,7 @@
 
 using namespace o2::parameters;
 
-o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber)
+o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo_DATA(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber)
 {
   // TODO: could think about caching results per runnumber to
   // avoid going to CCDB multiple times ---> but should be done inside the CCDBManagerInstance
@@ -83,3 +83,67 @@ o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(int
   }
   return AggregatedRunInfo{runnumber, sorMS, eorMS, nOrbitsPerTF, orbitResetMUS, orbitSOR, orbitEOR, grpecs};
 }
+
+namespace
+{
+
+// get path where to find MC production info
+std::string getFullPath_MC(std::string const& username, std::string const& lpm_prod_tag)
+{
+  // construct the path where to lookup
+  std::string path = "/Users/" + std::string(1, username[0]) + "/" + username;
+  std::string fullpath = path + "/" + "MCProdInfo/" + lpm_prod_tag;
+  return fullpath;
+}
+
+} // namespace
+
+std::map<std::string, std::string> AggregatedRunInfo::getMCProdInfo(o2::ccdb::CCDBManagerInstance& ccdb,
+                                                                    int run_number,
+                                                                    std::string const& lpm_prod_tag,
+                                                                    std::string const& username)
+{
+  std::map<std::string, std::string> metaDataFilter;
+  metaDataFilter["lpm_prod_tag"] = lpm_prod_tag;
+
+  // fetch the meta information for MC productions
+  auto header_data = ccdb.getCCDBAccessor().retrieveHeaders(getFullPath_MC(username, lpm_prod_tag), metaDataFilter, run_number);
+  return header_data;
+}
+
+void AggregatedRunInfo::adjust_from_MC(o2::ccdb::CCDBManagerInstance& ccdb,
+                                       int run_number,
+                                       std::string const& lpm_prod_tag,
+                                       std::string const& username)
+{
+  auto header_data = AggregatedRunInfo::getMCProdInfo(ccdb, run_number, lpm_prod_tag, username);
+
+  // adjust timeframe length if we find entry for MC production
+  auto iter = header_data.find("OrbitsPerTF");
+  if (iter != header_data.end()) {
+    auto mc_orbitsPerTF = std::stoi(iter->second);
+    if (mc_orbitsPerTF != orbitsPerTF) {
+      LOG(info) << "Adjusting OrbitsPerTF from " << orbitsPerTF << " to " << mc_orbitsPerTF << " based on differing MC info";
+      orbitsPerTF = mc_orbitsPerTF;
+    }
+  } else {
+    LOG(warn) << "No OrbitsPerTF information found for MC production " << lpm_prod_tag << " and run number " << run_number;
+  }
+}
+
+AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(o2::ccdb::CCDBManagerInstance& ccdb, int run_number, std::string const& lpm_prod_tag, std::string const& username)
+{
+  // (a) lookup the AggregatedRunInfo for the data run
+  // (b) modify/overwrite the info object with MC specific settings if lpm_prod_tag is given
+
+  auto original_info = buildAggregatedRunInfo_DATA(ccdb, run_number);
+
+  if (lpm_prod_tag.size() == 0) {
+    return original_info;
+  }
+
+  // in this case we adjust the info from MC
+  original_info.adjust_from_MC(ccdb, run_number, lpm_prod_tag, username);
+
+  return original_info;
+}

From 2dbe3ffc0a5b5a0ed954d12ed7c830c9eff7f963 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Tue, 8 Jul 2025 14:46:29 +0200
Subject: [PATCH 0597/1764] Update AggregatedRunInfo.cxx

---
 DataFormats/Parameters/src/AggregatedRunInfo.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/Parameters/src/AggregatedRunInfo.cxx b/DataFormats/Parameters/src/AggregatedRunInfo.cxx
index f8f6439eded83..5495ae73bd6ca 100644
--- a/DataFormats/Parameters/src/AggregatedRunInfo.cxx
+++ b/DataFormats/Parameters/src/AggregatedRunInfo.cxx
@@ -104,7 +104,7 @@ std::map<std::string, std::string> AggregatedRunInfo::getMCProdInfo(o2::ccdb::CC
                                                                     std::string const& username)
 {
   std::map<std::string, std::string> metaDataFilter;
-  metaDataFilter["lpm_prod_tag"] = lpm_prod_tag;
+  metaDataFilter["LPMProductionTag"] = lpm_prod_tag;
 
   // fetch the meta information for MC productions
   auto header_data = ccdb.getCCDBAccessor().retrieveHeaders(getFullPath_MC(username, lpm_prod_tag), metaDataFilter, run_number);

From 1013f6968d56097dcffb42fd5b2fa8881a48b119 Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Wed, 9 Jul 2025 18:15:37 +0200
Subject: [PATCH 0598/1764] Make O and Ne nuclei known to LHCIF processor
 (#14494)

---
 DataFormats/Parameters/src/GRPLHCIFData.cxx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/DataFormats/Parameters/src/GRPLHCIFData.cxx b/DataFormats/Parameters/src/GRPLHCIFData.cxx
index 8e779ef452191..d39569f79376b 100644
--- a/DataFormats/Parameters/src/GRPLHCIFData.cxx
+++ b/DataFormats/Parameters/src/GRPLHCIFData.cxx
@@ -28,6 +28,8 @@ using namespace o2::constants::lhc;
 const std::unordered_map<unsigned int, unsigned int> GRPLHCIFData::mZtoA =
   {
     {1, 1},
+    {8, 16},
+    {10, 20},
     {82, 208}};
 
 //_______________________________________________

From 9d56f5d35568383e11776f8b532cd36c4c2ac1ea Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 9 Jul 2025 09:24:46 +0200
Subject: [PATCH 0599/1764] DPL: fixes for dependency checks of devices with
 sporadic inputs in TopologyPolicy

---
 Framework/Core/src/TopologyPolicy.cxx | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/src/TopologyPolicy.cxx b/Framework/Core/src/TopologyPolicy.cxx
index a36f478909d6b..23e2a2eac0c5c 100644
--- a/Framework/Core/src/TopologyPolicy.cxx
+++ b/Framework/Core/src/TopologyPolicy.cxx
@@ -147,7 +147,7 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
   if (!isAExpendable && !isBExpendable) {
     bool sporadic = sporadicDataDeps(a, b);
     if (sporadic) {
-      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. Neither %s nor %s are expendable. However the former has sporadic inputs so we sort it after.",
+      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "true. Neither %s nor %s are expendable. However the former has sporadic inputs so we sort it after.",
                       a.name.c_str(), b.name.c_str());
       return true;
     }
@@ -159,7 +159,7 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
   if (isAExpendable && isBExpendable) {
     bool sporadic = sporadicDataDeps(a, b);
     if (sporadic) {
-      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. Both %s and %s are expendable. However the former has sporadic inputs, so we sort it after.",
+      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "true. Both %s and %s are expendable. However the former has sporadic inputs, so we sort it after.",
                       a.name.c_str(), b.name.c_str());
       return true;
     }
@@ -172,7 +172,7 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
   if (isAExpendable && bResilient) {
     bool sporadic = sporadicDataDeps(a, b);
     if (sporadic) {
-      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. %s is expendable but %s is resilient, however the former also has sporadic inputs, so we sort it after.",
+      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "true. %s is expendable but %s is resilient, however the former also has sporadic inputs, so we sort it after.",
                       a.name.c_str(), b.name.c_str());
       return true;
     }
@@ -188,8 +188,6 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
                     a.name.c_str(), hasDependency ? "There is however an inverse dependency" : "No inverse dependency", b.name.c_str(), a.name.c_str(),
                     !hasDependency ? "true" : "false");
     if (!hasDependency) {
-      O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "%s is expendable. There is however an inverse dependecy from %s to %s => true.",
-                      a.name.c_str(), b.name.c_str(), a.name.c_str());
       return true;
     }
     bool sporadic = sporadicDataDeps(a, b);
@@ -203,13 +201,6 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
     return false;
   }
   // b is expendable and a is not. We are fine with no dependency.
-  bool sporadic = sporadicDataDeps(a, b);
-  if (sporadic) {
-    O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. %s is expendable but %s is not. However the former has an sporadic input => true.",
-                    b.name.c_str(), a.name.c_str());
-    return true;
-  }
-  // b is expendable and a is not. We are fine with no dependency.
   O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "false. %s is expendable but %s is not. No need to add an unneeded dependency.",
                   b.name.c_str(), a.name.c_str());
 
@@ -270,6 +261,12 @@ TopologyPolicy::DependencyChecker TopologyPolicyHelpers::alwaysDependent()
                       hasDependency ? "true" : "false", dependent.name.c_str(), hasDependency ? "has" : "has not", ancestor.name.c_str());
       return hasDependency;
     }
+
+    if (sporadicDataDeps(ancestor, dependent)) {
+      O2_SIGNPOST_END(topology, sid, "alwaysDependent", "false. Dependent %s is an output proxy and ancestor %s has sporadic inputs", dependent.name.c_str(), ancestor.name.c_str());
+      return false;
+    }
+
     O2_SIGNPOST_END(topology, sid, "alwaysDependent", "true by default. Ancestor %s is not an output proxy.", ancestor.name.c_str());
     return true;
   };

From fe1d400db39904b1ff0d290a50de9d6902409e4d Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 9 Jul 2025 10:52:29 +0200
Subject: [PATCH 0600/1764] keeping the previous logic that output-proxies
 should be last

---
 Framework/Core/src/TopologyPolicy.cxx | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/Framework/Core/src/TopologyPolicy.cxx b/Framework/Core/src/TopologyPolicy.cxx
index 23e2a2eac0c5c..f5a378e983b08 100644
--- a/Framework/Core/src/TopologyPolicy.cxx
+++ b/Framework/Core/src/TopologyPolicy.cxx
@@ -142,11 +142,14 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
   bool isBExpendable = std::find_if(b.labels.begin(), b.labels.end(), checkExpendable) != b.labels.end();
   bool isAExpendable = std::find_if(a.labels.begin(), a.labels.end(), checkExpendable) != a.labels.end();
   bool bResilient = std::find_if(b.labels.begin(), b.labels.end(), checkResilient) != b.labels.end();
+  const std::regex matcher(".*output-proxy.*");
+  std::cmatch m;
+  bool isBOutputProxy = std::regex_match(b.name.data(), m, matcher);
 
   // If none is expendable. We simply return false and sort as usual.
   if (!isAExpendable && !isBExpendable) {
     bool sporadic = sporadicDataDeps(a, b);
-    if (sporadic) {
+    if (sporadic && !isBOutputProxy) {
       O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "true. Neither %s nor %s are expendable. However the former has sporadic inputs so we sort it after.",
                       a.name.c_str(), b.name.c_str());
       return true;
@@ -158,7 +161,7 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
   // If both are expendable. We return false and sort as usual.
   if (isAExpendable && isBExpendable) {
     bool sporadic = sporadicDataDeps(a, b);
-    if (sporadic) {
+    if (sporadic && !isBOutputProxy) {
       O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "true. Both %s and %s are expendable. However the former has sporadic inputs, so we sort it after.",
                       a.name.c_str(), b.name.c_str());
       return true;
@@ -171,7 +174,7 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
   // If a is expendable but b is resilient, we can keep the same order.
   if (isAExpendable && bResilient) {
     bool sporadic = sporadicDataDeps(a, b);
-    if (sporadic) {
+    if (sporadic && !isBOutputProxy) {
       O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "true. %s is expendable but %s is resilient, however the former also has sporadic inputs, so we sort it after.",
                       a.name.c_str(), b.name.c_str());
       return true;
@@ -191,7 +194,7 @@ bool expendableDataDeps(DataProcessorSpec const& a, DataProcessorSpec const& b)
       return true;
     }
     bool sporadic = sporadicDataDeps(a, b);
-    if (sporadic) {
+    if (sporadic && !isBOutputProxy) {
       O2_SIGNPOST_END(topology, sid, "expendableDataDeps", "%s is expendable. No inverse dependency from %s to %s. However the former has an occasioanl input => true.",
                       a.name.c_str(), b.name.c_str(), a.name.c_str());
       return true;
@@ -262,11 +265,6 @@ TopologyPolicy::DependencyChecker TopologyPolicyHelpers::alwaysDependent()
       return hasDependency;
     }
 
-    if (sporadicDataDeps(ancestor, dependent)) {
-      O2_SIGNPOST_END(topology, sid, "alwaysDependent", "false. Dependent %s is an output proxy and ancestor %s has sporadic inputs", dependent.name.c_str(), ancestor.name.c_str());
-      return false;
-    }
-
     O2_SIGNPOST_END(topology, sid, "alwaysDependent", "true by default. Ancestor %s is not an output proxy.", ancestor.name.c_str());
     return true;
   };

From aee683345c296c798a4d7f6b299d405dd0c78140 Mon Sep 17 00:00:00 2001
From: Jan Fiete <jgrosseo@cern.ch>
Date: Thu, 10 Jul 2025 15:33:37 +0200
Subject: [PATCH 0601/1764] explicit call to Sumw2 (cosmetic only)

---
 Framework/Core/src/StepTHn.cxx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Framework/Core/src/StepTHn.cxx b/Framework/Core/src/StepTHn.cxx
index ac5da966f6ad4..4b2e81f02e1a2 100644
--- a/Framework/Core/src/StepTHn.cxx
+++ b/Framework/Core/src/StepTHn.cxx
@@ -327,6 +327,8 @@ void StepTHn::createTarget(Int_t step, Bool_t sparse)
   }
 
   THnBase* target = mTarget[step];
+  if (mSumw2[step])
+    target->Sumw2();
 
   Int_t* binIdx = new Int_t[mNVars];
   Int_t* nBins = new Int_t[mNVars];

From 2f7ce66c03f7ca552f96e6c6605b4afe540d158c Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <weiglhofer@fias.uni-frankfurt.de>
Date: Mon, 23 Jun 2025 10:10:26 +0200
Subject: [PATCH 0602/1764] GPU: Use warp barriers in ZS decoder.

---
 GPU/Common/GPUCommonAlgorithm.h                    | 12 ++++++------
 GPU/Common/GPUCommonDefAPI.h                       |  6 +++---
 GPU/GPUTracking/TPCClusterFinder/CfUtils.h         | 10 ++++------
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx          | 14 ++++++++------
 4 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/GPU/Common/GPUCommonAlgorithm.h b/GPU/Common/GPUCommonAlgorithm.h
index 8cd53ec5e0609..db57e7ec06d4b 100644
--- a/GPU/Common/GPUCommonAlgorithm.h
+++ b/GPU/Common/GPUCommonAlgorithm.h
@@ -331,28 +331,28 @@ GPUdi() void GPUCommonAlgorithm::swap(T& a, T& b)
 #pragma OPENCL EXTENSION cl_khr_subgroups : enable
 
 template <class T>
-GPUdi() T work_group_scan_inclusive_add_FUNC(T v)
+GPUdi() T warp_scan_inclusive_add_FUNC(T v)
 {
   return sub_group_scan_inclusive_add(v);
 }
 template <> // FIXME: It seems OpenCL does not support 8 and 16 bit subgroup operations
-GPUdi() uint8_t work_group_scan_inclusive_add_FUNC<uint8_t>(uint8_t v)
+GPUdi() uint8_t warp_scan_inclusive_add_FUNC<uint8_t>(uint8_t v)
 {
   return sub_group_scan_inclusive_add((uint32_t)v);
 }
 template <class T>
-GPUdi() T work_group_broadcast_FUNC(T v, int32_t i)
+GPUdi() T warp_broadcast_FUNC(T v, int32_t i)
 {
   return sub_group_broadcast(v, i);
 }
 template <>
-GPUdi() uint8_t work_group_broadcast_FUNC<uint8_t>(uint8_t v, int32_t i)
+GPUdi() uint8_t warp_broadcast_FUNC<uint8_t>(uint8_t v, int32_t i)
 {
   return sub_group_broadcast((uint32_t)v, i);
 }
 
-#define warp_scan_inclusive_add(v) work_group_scan_inclusive_add_FUNC(v)
-#define warp_broadcast(v, i) work_group_broadcast_FUNC(v, i)
+#define warp_scan_inclusive_add(v) warp_scan_inclusive_add_FUNC(v)
+#define warp_broadcast(v, i) warp_broadcast_FUNC(v, i)
 
 #elif (defined(__CUDACC__) || defined(__HIPCC__))
 // CUDA and HIP work the same way using cub, need just different header
diff --git a/GPU/Common/GPUCommonDefAPI.h b/GPU/Common/GPUCommonDefAPI.h
index b029038a3b521..2494cd8dd6fe5 100644
--- a/GPU/Common/GPUCommonDefAPI.h
+++ b/GPU/Common/GPUCommonDefAPI.h
@@ -96,13 +96,13 @@
   #define GPUgeneric() __generic
   #define GPUconstexprref() GPUconstexpr()
   #if defined(__OPENCL__) && !defined(__clang__)
-    #define GPUbarrier() work_group_barrier(mem_fence::global | mem_fence::local);
-    #define GPUbarrierWarp()
+    #define GPUbarrier() work_group_barrier(mem_fence::global | mem_fence::local)
+    #define GPUbarrierWarp() sub_group_barrier(mem_fence::global | mem_fence::local)
     #define GPUAtomic(type) atomic<type>
     static_assert(sizeof(atomic<uint32_t>) == sizeof(uint32_t), "Invalid size of atomic type");
   #else
     #define GPUbarrier() barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE)
-    #define GPUbarrierWarp()
+    #define GPUbarrierWarp() sub_group_barrier(CLK_LOCAL_MEM_FENCE | CLK_GLOBAL_MEM_FENCE)
     #if defined(__OPENCL__) && defined(GPUCA_OPENCL_CLANG_C11_ATOMICS)
       namespace o2 { namespace gpu {
       template <class T> struct oclAtomic;
diff --git a/GPU/GPUTracking/TPCClusterFinder/CfUtils.h b/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
index 96f4893c74af3..f9e3f7a304d84 100644
--- a/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
+++ b/GPU/GPUTracking/TPCClusterFinder/CfUtils.h
@@ -58,10 +58,9 @@ class CfUtils
     *sum = __popc(waveMask);
     return myOffset;
 #else // CPU / OpenCL fallback
-    int32_t myOffset = warp_scan_inclusive_add(pred ? 1 : 0);
+    int32_t myOffset = warp_scan_inclusive_add(!!pred);
     *sum = warp_broadcast(myOffset, GPUCA_WARP_SIZE - 1);
-    myOffset--;
-    return myOffset;
+    return myOffset - !!pred;
 #endif
   }
 
@@ -111,8 +110,7 @@ class CfUtils
     if (sum != nullptr) {
       *sum = work_group_broadcast(lpos, BlockSize - 1);
     }
-    lpos--;
-    return lpos;
+    return lpos - !!pred;
 #endif
   }
 
@@ -149,7 +147,7 @@ class CfUtils
 
     return sum;
 #else // CPU / OpenCL fallback
-    return work_group_reduce_add(pred ? 1 : 0);
+    return work_group_reduce_add(!!pred);
 #endif
   }
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index 312085d2947ab..f7bb64106fe4f 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -224,7 +224,7 @@ GPUd() size_t GPUTPCCFDecodeZSLink::DecodePage(GPUSharedMemory& smem, processorT
     return pageDigitOffset;
   }
 
-  int32_t nDecoded = 0;
+  [[maybe_unused]] int32_t nDecoded = 0;
   const auto* decHdr = ConsumeHeader<TPCZSHDRV2>(page);
   ConsumeBytes(page, decHdr->firstZSDataOffset * 16);
 
@@ -275,7 +275,7 @@ GPUd() size_t GPUTPCCFDecodeZSLink::DecodePage(GPUSharedMemory& smem, processorT
 #endif
     pageDigitOffset += nAdc;
   } // for (uint32_t t = 0; t < decHdr->nTimebinHeaders; t++)
-  (void)nDecoded;
+
 #ifdef GPUCA_CHECK_TPCZS_CORRUPTION
   if (iThread == 0 && nDecoded != decHdr->nADCsamples) {
     clusterer.raiseError(GPUErrors::ERROR_TPCZS_INVALID_NADC, clusterer.mISector * 1000 + decHdr->cruID, decHdr->nADCsamples, nDecoded);
@@ -566,6 +566,7 @@ GPUd() void GPUTPCCFDecodeZSLinkBase::WriteCharge(processorType& clusterer, floa
   positions[positionOffset] = pos;
 
   charge *= clusterer.GetConstantMem()->calibObjects.tpcPadGain->getGainCorrection(sector, padAndRow.getRow(), padAndRow.getPad());
+
   chargeMap[pos] = PackedCharge(charge);
 }
 
@@ -615,6 +616,7 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
   ConsumeBytes(page, decHeader->firstZSDataOffset - sizeof(o2::header::RAWDataHeader));
 
   for (uint16_t i = 0; i < decHeader->nTimebinHeaders; i++) {
+
     [[maybe_unused]] ptrdiff_t sizeLeftInPage = payloadEnd - page;
     assert(sizeLeftInPage > 0);
 
@@ -728,8 +730,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   uint16_t nSamplesInTB = 0;
 
-  GPUbarrier();
-
   // Read timebin link headers
   for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++) {
     uint8_t timebinLinkHeaderStart = ConsumeByte(page);
@@ -777,6 +777,8 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   } // for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++)
 
+  GPUbarrierWarp(); // Ensure all writes to shared memory are finished, before reading it
+
   const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
   MAYBE_PAGE_OVERFLOW(page); // TODO: We don't need this check?
 
@@ -784,8 +786,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
     return FillWithInvalid(clusterer, iThread, NTHREADS, pageDigitOffset, nSamplesInTB);
   }
 
-  GPUbarrier();
-
   // Unpack ADC
   int32_t iLink = 0;
   for (uint16_t sample = iThread; sample < nSamplesInTB; sample += NTHREADS) {
@@ -819,6 +819,8 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   } // for (uint16_t sample = iThread; sample < nSamplesInTB; sample += NTHREADS)
 
+  GPUbarrierWarp(); // Ensure all reads to shared memory are finished, before decoding next header into shmem
+
   assert(PayloadExtendsToNextPage || adcData <= page);
   assert(PayloadExtendsToNextPage || page <= payloadEnd);
 

From 7d9bcd8d3571395cfaa89f1d867cf488d53aa8b6 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 26 Jun 2025 10:20:36 +0200
Subject: [PATCH 0603/1764] ITS: fix seeding vertex labels

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 11304e17d234a..e6c7884588f18 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -482,7 +482,6 @@ void VertexerTraits::computeVertices(const int iteration)
     }
   }
   for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    vertices.clear();
     std::sort(mTimeFrame->getTrackletClusters(rofId).begin(), mTimeFrame->getTrackletClusters(rofId).end(),
               [](ClusterLines& cluster1, ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); }); // ensure clusters are ordered by contributors, so that we can cat after the first.
 #ifdef VTX_DEBUG
@@ -541,6 +540,8 @@ void VertexerTraits::computeVertices(const int iteration)
     if (vertices.empty() && !(iteration && (int)mTimeFrame->getPrimaryVertices(rofId).size() > mVrtParams[iteration].vertPerRofThreshold)) {
       mTimeFrame->getNoVertexROF()++;
     }
+    vertices.clear();
+    polls.clear();
   }
 #ifdef VTX_DEBUG
   TFile* dbg_file = TFile::Open("artefacts_tf.root", "update");

From 1232a9503c49119d61b6501df888311c127932ad Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 18 Jun 2025 13:41:06 +0200
Subject: [PATCH 0604/1764] ITS: Vertexer return early and only one arena

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/src/VertexerTraits.cxx       | 33 +++++++++++--------
 1 file changed, 19 insertions(+), 14 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index e6c7884588f18..a7487200886e6 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -214,13 +214,16 @@ void VertexerTraits::computeTracklets(const int iteration)
           mTimeFrame->getNTrackletsROF(pivotRofId, 1) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 1).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 1).end(), 0);
         }
       });
-  });
 
-  mTimeFrame->computeTrackletsPerROFScans();
-  mTimeFrame->getTracklets()[0].resize(mTimeFrame->getTotalTrackletsTF(0));
-  mTimeFrame->getTracklets()[1].resize(mTimeFrame->getTotalTrackletsTF(1));
+    mTimeFrame->computeTrackletsPerROFScans();
+    if (auto tot0 = mTimeFrame->getTotalTrackletsTF(0), tot1 = mTimeFrame->getTotalTrackletsTF(1);
+        tot0 == 0 || tot1 == 0) {
+      return;
+    } else {
+      mTimeFrame->getTracklets()[0].resize(tot0);
+      mTimeFrame->getTracklets()[1].resize(tot1);
+    }
 
-  mTaskArena->execute([&] {
     tbb::parallel_for(
       tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
       [&](const tbb::blocked_range<short>& Rofs) {
@@ -266,18 +269,20 @@ void VertexerTraits::computeTracklets(const int iteration)
   if (mTimeFrame->hasMCinformation()) {
     for (const auto& trk : mTimeFrame->getTracklets()[0]) {
       o2::MCCompLabel label;
-      int sortedId0{mTimeFrame->getSortedIndex(trk.rof[0], 0, trk.firstClusterIndex)};
-      int sortedId1{mTimeFrame->getSortedIndex(trk.rof[1], 1, trk.secondClusterIndex)};
-      for (const auto& lab0 : mTimeFrame->getClusterLabels(0, mTimeFrame->getClusters()[0][sortedId0].clusterId)) {
-        for (const auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
-          if (lab0 == lab1 && lab0.isValid()) {
-            label = lab0;
+      if (!trk.isEmpty()) {
+        int sortedId0{mTimeFrame->getSortedIndex(trk.rof[0], 0, trk.firstClusterIndex)};
+        int sortedId1{mTimeFrame->getSortedIndex(trk.rof[1], 1, trk.secondClusterIndex)};
+        for (const auto& lab0 : mTimeFrame->getClusterLabels(0, mTimeFrame->getClusters()[0][sortedId0].clusterId)) {
+          for (const auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
+            if (lab0 == lab1 && lab0.isValid()) {
+              label = lab0;
+              break;
+            }
+          }
+          if (label.isValid()) {
             break;
           }
         }
-        if (label.isValid()) {
-          break;
-        }
       }
       mTimeFrame->getTrackletsLabel(0).emplace_back(label);
     }

From 6522275f8f8bf10c189194f76059890f1db246b1 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sun, 8 Jun 2025 13:38:08 +0200
Subject: [PATCH 0605/1764] ITS: unify configuration of algorithms

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |   4 +-
 .../include/ITStracking/Configuration.h       |  51 ++--
 .../tracking/include/ITStracking/Tracker.h    |   2 -
 .../include/ITStracking/TrackerTraits.h       |   2 -
 .../include/ITStracking/TrackingInterface.h   |  11 +-
 .../tracking/include/ITStracking/Vertexer.h   |   1 -
 .../ITSMFT/ITS/tracking/src/Configuration.cxx | 274 ++++++++++++++++--
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  66 -----
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  10 +-
 .../ITS/tracking/src/TrackingInterface.cxx    | 131 +--------
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      |  30 --
 .../include/ITSWorkflow/CookedTrackerSpec.h   |   6 +-
 .../include/ITSWorkflow/RecoWorkflow.h        |   4 +-
 .../include/ITSWorkflow/TrackerSpec.h         |   5 +-
 .../ITS/workflow/src/CookedTrackerSpec.cxx    |  11 +-
 .../ITSMFT/ITS/workflow/src/RecoWorkflow.cxx  |   4 +-
 .../ITSMFT/ITS/workflow/src/TrackerSpec.cxx   |   7 +-
 .../ITS/workflow/src/its-reco-workflow.cxx    |   8 +-
 .../reconstruction/src/TrackingInterface.cxx  |   1 -
 .../include/ITS3Workflow/RecoWorkflow.h       |   4 +-
 .../include/ITS3Workflow/TrackerSpec.h        |   4 +-
 .../ITS3/workflow/src/RecoWorkflow.cxx        |   4 +-
 .../ITS3/workflow/src/TrackerSpec.cxx         |   9 +-
 .../ITS3/workflow/src/its3-reco-workflow.cxx  |   3 +-
 24 files changed, 322 insertions(+), 330 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index d804d0062764f..1b1c4af682dc5 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -246,7 +246,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         this->mTrkParams[0].MaxChi2ClusterAttachment,
                                         this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
-                                        this->mCorrType,
+                                        this->mTrkParams[0].CorrType,
                                         conf.nBlocks,
                                         conf.nThreads);
     }
@@ -268,7 +268,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                      this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
                      this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
                      mTimeFrameGPU->getDevicePropagator(),             // const o2::base::Propagator* propagator
-                     this->mCorrType,                                  // o2::base::PropagatorImpl<float>::MatCorrType
+                     this->mTrkParams[0].CorrType,                     // o2::base::PropagatorImpl<float>::MatCorrType
                      conf.nBlocks,
                      conf.nThreads);
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 2a40b817a7005..34b2d11fc16e6 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -26,36 +26,8 @@
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Constants.h"
 
-namespace o2
+namespace o2::its
 {
-namespace its
-{
-
-enum class TrackingMode {
-  Sync,
-  Async,
-  Cosmics,
-  Unset, // Special value to leave a default in case we want to override via Configurable Params
-};
-
-std::string asString(TrackingMode mode);
-std::ostream& operator<<(std::ostream& os, TrackingMode v);
-
-template <typename Param>
-class Configuration : public Param
-{
- public:
-  static Configuration<Param>& getInstance()
-  {
-    static Configuration<Param> instance;
-    return instance;
-  }
-  Configuration(const Configuration<Param>&) = delete;
-  const Configuration<Param>& operator=(const Configuration<Param>&) = delete;
-
- private:
-  Configuration() = default;
-};
 
 struct TrackingParameters {
   int CellMinimumLevel() const noexcept { return MinTrackLength - constants::ClustersPerCell + 1; }
@@ -166,7 +138,24 @@ struct TimeFrameGPUParameters {
   int maxGPUMemoryGB = -1;
 };
 
-} // namespace its
-} // namespace o2
+namespace TrackingMode
+{
+enum Type : int8_t {
+  Unset = -1, // Special value to leave a default in case we want to override via Configurable Params
+  Sync = 0,
+  Async = 1,
+  Cosmics = 2,
+  Off = 3,
+};
+
+Type fromString(std::string_view str);
+std::string toString(Type mode);
+
+std::vector<TrackingParameters> getTrackingParameters(Type mode);
+std::vector<VertexingParameters> getVertexingParameters(Type mode);
+
+}; // namespace TrackingMode
+
+} // namespace o2::its
 
 #endif /* TRACKINGITSU_INCLUDE_CONFIGURATION_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 5ba9b5039f808..78c290374a67d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -71,9 +71,7 @@ class Tracker
   void setParameters(const std::vector<TrackingParameters>& p) { mTrkParams = p; }
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
-  void getGlobalConfiguration();
   void setBz(float bz) { mTraits->setBz(bz); }
-  void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mTraits->setCorrType(type); }
   bool isMatLUT() const { return mTraits->isMatLUT(); }
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena) { mTraits->setNThreads(n, arena); }
   void printSummary() const;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 7ba67a01fce13..cba536324edeb 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -65,7 +65,6 @@ class TrackerTraits
 
   virtual void setBz(float bz);
   float getBz() const { return mBz; }
-  void setCorrType(const o2::base::PropagatorImpl<float>::MatCorrType type) { mCorrType = type; }
   bool isMatLUT() const;
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool isGPU() const noexcept { return false; }
@@ -99,7 +98,6 @@ class TrackerTraits
   std::shared_ptr<tbb::task_arena> mTaskArena;
 
  protected:
-  o2::base::PropagatorImpl<float>::MatCorrType mCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
   o2::gpu::GPUChainITS* mChain = nullptr;
   TimeFrame<nLayers>* mTimeFrame;
   std::vector<TrackingParameters> mTrkParams;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index 64fd4f8156cca..bf9cb79169566 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -68,13 +68,7 @@ class ITSTrackingInterface
 
   // Custom
   void setTraitsFromProvider(VertexerTraits*, TrackerTraits7*, TimeFrame7*);
-  void setTrackingMode(TrackingMode mode = TrackingMode::Unset)
-  {
-    if (mode == TrackingMode::Unset) {
-      LOGP(fatal, "ITS Tracking mode Unset is meant to be a default. Specify the mode");
-    }
-    mMode = mode;
-  }
+  void setTrackingMode(TrackingMode::Type mode = TrackingMode::Unset) { mMode = mode; }
 
   auto getTracker() const { return mTracker.get(); }
   auto getVertexer() const { return mVertexer.get(); }
@@ -86,14 +80,13 @@ class ITSTrackingInterface
                        gsl::span<const itsmft::CompClusterExt> clusters,
                        gsl::span<const unsigned char>::iterator& pattIt,
                        const dataformats::MCTruthContainer<MCCompLabel>* mcLabels);
-  void getConfiguration(framework::ProcessingContext& pc);
 
  private:
   bool mIsMC = false;
   bool mRunVertexer = true;
   bool mCosmicsProcessing = false;
   int mUseTriggers = 0;
-  TrackingMode mMode = TrackingMode::Unset;
+  TrackingMode::Type mMode = TrackingMode::Unset;
   bool mOverrideBeamEstimation = false;
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
   std::unique_ptr<Tracker> mTracker = nullptr;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 98bcb95ef65df..285e4d7e9547d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -60,7 +60,6 @@ class Vertexer
   auto& getVertParameters() const { return mTraits->getVertexingParameters(); }
   void setParameters(const std::vector<VertexingParameters>& vertParams) { mVertParams = vertParams; }
   const auto& getParameters() const noexcept { return mVertParams; }
-  void getGlobalConfiguration();
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
 
   std::vector<Vertex> exportVertices();
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 9e631ad6afb7f..56aa52b25940e 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -9,34 +9,18 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <algorithm>
 #include <format>
-#include "ITStracking/Constants.h"
+#include <limits>
+#include <string_view>
+#include <vector>
 
+#include "Framework/Logger.h"
+#include "ITStracking/Constants.h"
 #include "ITStracking/Configuration.h"
+#include "ITStracking/TrackingConfigParam.h"
 
-namespace o2::its
-{
-
-std::string asString(TrackingMode mode)
-{
-  switch (mode) {
-    case TrackingMode::Sync:
-      return "sync";
-    case TrackingMode::Async:
-      return "async";
-    case TrackingMode::Cosmics:
-      return "cosmics";
-    case TrackingMode::Unset:
-      return "unset";
-  }
-  return "unknown";
-}
-
-std::ostream& operator<<(std::ostream& os, TrackingMode v)
-{
-  os << asString(v);
-  return os;
-}
+using namespace o2::its;
 
 std::string TrackingParameters::asString() const
 {
@@ -72,4 +56,244 @@ std::string VertexingParameters::asString() const
   return str;
 }
 
-} // namespace o2::its
+namespace
+{
+constexpr bool iequals(std::string_view a, std::string_view b)
+{
+  return std::equal(a.begin(), a.end(), b.begin(), b.end(),
+                    [](char x, char y) { return std::tolower(x) == std::tolower(y); });
+}
+} // namespace
+
+TrackingMode::Type TrackingMode::fromString(std::string_view str)
+{
+  constexpr std::array smodes = {
+    std::pair{"sync", Sync},
+    std::pair{"async", Async},
+    std::pair{"cosmics", Cosmics},
+    std::pair{"unset", Unset},
+    std::pair{"off", Off}};
+
+  auto it = std::find_if(smodes.begin(), smodes.end(), [&str](const auto& pair) {
+    return iequals(str, pair.first);
+  });
+  if (it == smodes.end()) {
+    LOGP(fatal, "Unrecognized tracking mode '{}'", str);
+  }
+  return it->second;
+}
+
+std::string TrackingMode::toString(TrackingMode::Type mode)
+{
+  if (mode == TrackingMode::Sync) {
+    return "sync";
+  } else if (mode == TrackingMode::Async) {
+    return "async";
+  } else if (mode == TrackingMode::Cosmics) {
+    return "cosmics";
+  } else if (mode == TrackingMode::Unset) {
+    return "unset";
+  } else if (mode == TrackingMode::Off) {
+    return "off";
+  }
+  LOGP(fatal, "Unrecognized tracking mode '{}'", (int)mode);
+  return ""; // not reachable
+}
+
+std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode::Type mode)
+{
+  const auto& tc = o2::its::TrackerParamConfig::Instance();
+  std::vector<TrackingParameters> trackParams;
+
+  if (mode == TrackingMode::Async) {
+    trackParams.resize(tc.doUPCIteration ? 4 : 3);
+    trackParams[1].TrackletMinPt = 0.2f;
+    trackParams[1].CellDeltaTanLambdaSigma *= 2.;
+    trackParams[2].TrackletMinPt = 0.1f;
+    trackParams[2].CellDeltaTanLambdaSigma *= 4.;
+
+    trackParams[0].MinPt[0] = 1.f / 12; // 7cl
+    trackParams[1].MinPt[0] = 1.f / 12; // 7cl
+
+    trackParams[2].MinTrackLength = 4;
+    trackParams[2].MinPt[0] = 1.f / 12; // 7cl
+    trackParams[2].MinPt[1] = 1.f / 5;  // 6cl
+    trackParams[2].MinPt[2] = 1.f / 1;  // 5cl
+    trackParams[2].MinPt[3] = 1.f / 6;  // 4cl
+
+    trackParams[2].StartLayerMask = (1 << 6) + (1 << 3);
+    if (tc.doUPCIteration) {
+      trackParams[3].MinTrackLength = 4;
+      trackParams[3].TrackletMinPt = 0.1f;
+      trackParams[3].CellDeltaTanLambdaSigma *= 4.;
+      trackParams[3].DeltaROF = 0; // UPC specific setting
+    }
+    for (size_t ip = 0; ip < trackParams.size(); ip++) {
+      auto& param = trackParams[ip];
+      param.ZBins = 64;
+      param.PhiBins = 32;
+      param.CellsPerClusterLimit = 1.e3f;
+      param.TrackletsPerClusterLimit = 1.e3f;
+      // check if something was overridden via configurable params
+      if (ip < tc.MaxIter) {
+        if (tc.startLayerMask[ip] > 0) {
+          trackParams[2].StartLayerMask = tc.startLayerMask[ip];
+        }
+        if (tc.minTrackLgtIter[ip] > 0) {
+          param.MinTrackLength = tc.minTrackLgtIter[ip];
+        }
+        for (int ilg = tc.MaxTrackLength; ilg >= tc.MinTrackLength; ilg--) {
+          int lslot0 = (tc.MaxTrackLength - ilg), lslot = lslot0 + ip * (tc.MaxTrackLength - tc.MinTrackLength + 1);
+          if (tc.minPtIterLgt[lslot] > 0.) {
+            param.MinPt[lslot0] = tc.minPtIterLgt[lslot];
+          }
+        }
+      }
+    }
+  } else if (mode == TrackingMode::Sync) {
+    trackParams.resize(1);
+    trackParams[0].ZBins = 64;
+    trackParams[0].PhiBins = 32;
+    trackParams[0].MinTrackLength = 4;
+  } else if (mode == TrackingMode::Cosmics) {
+    trackParams.resize(1);
+    trackParams[0].MinTrackLength = 4;
+    trackParams[0].CellDeltaTanLambdaSigma *= 10;
+    trackParams[0].PhiBins = 4;
+    trackParams[0].ZBins = 16;
+    trackParams[0].PVres = 1.e5f;
+    trackParams[0].MaxChi2ClusterAttachment = 60.;
+    trackParams[0].MaxChi2NDF = 40.;
+    trackParams[0].TrackletsPerClusterLimit = 100.;
+    trackParams[0].CellsPerClusterLimit = 100.;
+  } else {
+    LOGP(fatal, "Unsupported ITS tracking mode {} ", toString(mode));
+  }
+
+  float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791;
+  float bFactorTracklets = bFactor < 0.01 ? 1. : bFactor; // for tracklets only
+  int nROFsPerIterations = tc.nROFsPerIterations > 0 ? tc.nROFsPerIterations : -1;
+
+  if (tc.nOrbitsPerIterations > 0) {
+    /// code to be used when the number of ROFs per orbit is known, this gets priority over the number of ROFs per iteration
+  }
+
+  // global parameters set for every iteration
+  for (auto& p : trackParams) {
+    // adjust pT settings to actual mag. field
+    p.TrackletMinPt *= bFactorTracklets;
+    for (int ilg = tc.MaxTrackLength; ilg >= tc.MinTrackLength; ilg--) {
+      int lslot = tc.MaxTrackLength - ilg;
+      p.MinPt[lslot] *= bFactor;
+    }
+
+    p.PrintMemory = tc.printMemory;
+    p.MaxMemory = tc.maxMemory;
+    p.DropTFUponFailure = tc.dropTFUponFailure;
+    p.SaveTimeBenchmarks = tc.saveTimeBenchmarks;
+    p.FataliseUponFailure = tc.fataliseUponFailure;
+
+    if (tc.useMatCorrTGeo) {
+      p.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrTGeo;
+    } else if (tc.useFastMaterial) {
+      p.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
+    } else {
+      p.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT;
+    }
+
+    if (p.NLayers == 7) {
+      for (int i{0}; i < 7; ++i) {
+        p.SystErrorY2[i] = tc.sysErrY2[i] > 0 ? tc.sysErrY2[i] : p.SystErrorY2[i];
+        p.SystErrorZ2[i] = tc.sysErrZ2[i] > 0 ? tc.sysErrZ2[i] : p.SystErrorZ2[i];
+      }
+    }
+    p.DeltaROF = tc.deltaRof;
+    p.DoUPCIteration = tc.doUPCIteration;
+    p.MaxChi2ClusterAttachment = tc.maxChi2ClusterAttachment > 0 ? tc.maxChi2ClusterAttachment : p.MaxChi2ClusterAttachment;
+    p.MaxChi2NDF = tc.maxChi2NDF > 0 ? tc.maxChi2NDF : p.MaxChi2NDF;
+    p.PhiBins = tc.LUTbinsPhi > 0 ? tc.LUTbinsPhi : p.PhiBins;
+    p.ZBins = tc.LUTbinsZ > 0 ? tc.LUTbinsZ : p.ZBins;
+    p.PVres = tc.pvRes > 0 ? tc.pvRes : p.PVres;
+    p.NSigmaCut *= tc.nSigmaCut > 0 ? tc.nSigmaCut : 1.f;
+    p.CellDeltaTanLambdaSigma *= tc.deltaTanLres > 0 ? tc.deltaTanLres : 1.f;
+    p.TrackletMinPt *= tc.minPt > 0 ? tc.minPt : 1.f;
+    p.nROFsPerIterations = nROFsPerIterations;
+    p.PerPrimaryVertexProcessing = tc.perPrimaryVertexProcessing;
+    for (int iD{0}; iD < 3; ++iD) {
+      p.Diamond[iD] = tc.diamondPos[iD];
+    }
+    p.UseDiamond = tc.useDiamond;
+    if (tc.useTrackFollower > 0) {
+      p.UseTrackFollower = true;
+      // Bit 0: Allow for mixing of top&bot extension --> implies Bits 1&2 set
+      // Bit 1: Allow for top extension
+      // Bit 2: Allow for bot extension
+      p.UseTrackFollowerMix = ((tc.useTrackFollower & (1 << 0)) != 0);
+      p.UseTrackFollowerTop = ((tc.useTrackFollower & (1 << 1)) != 0);
+      p.UseTrackFollowerBot = ((tc.useTrackFollower & (1 << 2)) != 0);
+      p.TrackFollowerNSigmaCutZ = tc.trackFollowerNSigmaZ;
+      p.TrackFollowerNSigmaCutPhi = tc.trackFollowerNSigmaPhi;
+    }
+    if (tc.cellsPerClusterLimit >= 0) {
+      p.CellsPerClusterLimit = tc.cellsPerClusterLimit;
+    }
+    if (tc.trackletsPerClusterLimit >= 0) {
+      p.TrackletsPerClusterLimit = tc.trackletsPerClusterLimit;
+    }
+    if (tc.findShortTracks >= 0) {
+      p.FindShortTracks = tc.findShortTracks;
+    }
+  }
+
+  return trackParams;
+}
+
+std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMode::Type mode)
+{
+  const auto& vc = o2::its::VertexerParamConfig::Instance();
+  std::vector<VertexingParameters> vertParams;
+  if (mode == TrackingMode::Async) {
+    vertParams.resize(2); // The number of actual iterations will be set as a configKeyVal to allow for pp/PbPb choice
+    vertParams[1].phiCut = 0.015f;
+    vertParams[1].tanLambdaCut = 0.015f;
+    vertParams[1].vertPerRofThreshold = 0;
+    vertParams[1].deltaRof = 0;
+  } else if (mode == TrackingMode::Sync) {
+    vertParams.resize(1);
+  } else if (mode == TrackingMode::Cosmics) {
+    vertParams.resize(1);
+  } else {
+    LOGP(fatal, "Unsupported ITS vertexing mode {} ", toString(mode));
+  }
+
+  // global parameters set for every iteration
+  for (auto& p : vertParams) {
+    p.SaveTimeBenchmarks = vc.saveTimeBenchmarks;
+    p.PrintMemory = vc.printMemory;
+    p.MaxMemory = vc.maxMemory;
+    p.DropTFUponFailure = vc.dropTFUponFailure;
+    p.nIterations = vc.nIterations;
+    p.deltaRof = vc.deltaRof;
+    p.allowSingleContribClusters = vc.allowSingleContribClusters;
+    p.trackletSigma = vc.trackletSigma;
+    p.maxZPositionAllowed = vc.maxZPositionAllowed;
+    p.clusterContributorsCut = vc.clusterContributorsCut;
+    p.phiSpan = vc.phiSpan;
+    p.nThreads = vc.nThreads;
+    p.ZBins = vc.ZBins;
+    p.PhiBins = vc.PhiBins;
+  }
+  // set for now outside to not disturb status quo
+  vertParams[0].vertNsigmaCut = vc.vertNsigmaCut;
+  vertParams[0].vertRadiusSigma = vc.vertRadiusSigma;
+  vertParams[0].maxTrackletsPerCluster = vc.maxTrackletsPerCluster;
+  vertParams[0].lowMultBeamDistCut = vc.lowMultBeamDistCut;
+  vertParams[0].zCut = vc.zCut;
+  vertParams[0].phiCut = vc.phiCut;
+  vertParams[0].pairCut = vc.pairCut;
+  vertParams[0].clusterCut = vc.clusterCut;
+  vertParams[0].histPairCut = vc.histPairCut;
+  vertParams[0].tanLambdaCut = vc.tanLambdaCut;
+
+  return vertParams;
+}
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 5c3a43540f833..e0bd94ed223c0 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -335,72 +335,6 @@ void Tracker::rectifyClusterIndices()
   }
 }
 
-void Tracker::getGlobalConfiguration()
-{
-  const auto& tc = o2::its::TrackerParamConfig::Instance();
-  if (tc.useMatCorrTGeo) {
-    mTraits->setCorrType(o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrTGeo);
-  } else if (tc.useFastMaterial) {
-    mTraits->setCorrType(o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE);
-  } else {
-    mTraits->setCorrType(o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT);
-  }
-  int nROFsPerIterations = tc.nROFsPerIterations > 0 ? tc.nROFsPerIterations : -1;
-  if (tc.nOrbitsPerIterations > 0) {
-    /// code to be used when the number of ROFs per orbit is known, this gets priority over the number of ROFs per iteration
-  }
-  for (auto& params : mTrkParams) {
-    if (params.NLayers == 7) {
-      for (int i{0}; i < 7; ++i) {
-        params.SystErrorY2[i] = tc.sysErrY2[i] > 0 ? tc.sysErrY2[i] : params.SystErrorY2[i];
-        params.SystErrorZ2[i] = tc.sysErrZ2[i] > 0 ? tc.sysErrZ2[i] : params.SystErrorZ2[i];
-      }
-    }
-    params.DeltaROF = tc.deltaRof;
-    params.DoUPCIteration = tc.doUPCIteration;
-    params.MaxChi2ClusterAttachment = tc.maxChi2ClusterAttachment > 0 ? tc.maxChi2ClusterAttachment : params.MaxChi2ClusterAttachment;
-    params.MaxChi2NDF = tc.maxChi2NDF > 0 ? tc.maxChi2NDF : params.MaxChi2NDF;
-    params.PhiBins = tc.LUTbinsPhi > 0 ? tc.LUTbinsPhi : params.PhiBins;
-    params.ZBins = tc.LUTbinsZ > 0 ? tc.LUTbinsZ : params.ZBins;
-    params.PVres = tc.pvRes > 0 ? tc.pvRes : params.PVres;
-    params.NSigmaCut *= tc.nSigmaCut > 0 ? tc.nSigmaCut : 1.f;
-    params.CellDeltaTanLambdaSigma *= tc.deltaTanLres > 0 ? tc.deltaTanLres : 1.f;
-    params.TrackletMinPt *= tc.minPt > 0 ? tc.minPt : 1.f;
-    params.nROFsPerIterations = nROFsPerIterations;
-    params.PerPrimaryVertexProcessing = tc.perPrimaryVertexProcessing;
-    params.SaveTimeBenchmarks = tc.saveTimeBenchmarks;
-    params.FataliseUponFailure = tc.fataliseUponFailure;
-    params.DropTFUponFailure = tc.dropTFUponFailure;
-    for (int iD{0}; iD < 3; ++iD) {
-      params.Diamond[iD] = tc.diamondPos[iD];
-    }
-    params.UseDiamond = tc.useDiamond;
-    if (tc.maxMemory) {
-      params.MaxMemory = tc.maxMemory;
-    }
-    if (tc.useTrackFollower > 0) {
-      params.UseTrackFollower = true;
-      // Bit 0: Allow for mixing of top&bot extension --> implies Bits 1&2 set
-      // Bit 1: Allow for top extension
-      // Bit 2: Allow for bot extension
-      params.UseTrackFollowerMix = ((tc.useTrackFollower & (1 << 0)) != 0);
-      params.UseTrackFollowerTop = ((tc.useTrackFollower & (1 << 1)) != 0);
-      params.UseTrackFollowerBot = ((tc.useTrackFollower & (1 << 2)) != 0);
-      params.TrackFollowerNSigmaCutZ = tc.trackFollowerNSigmaZ;
-      params.TrackFollowerNSigmaCutPhi = tc.trackFollowerNSigmaPhi;
-    }
-    if (tc.cellsPerClusterLimit >= 0) {
-      params.CellsPerClusterLimit = tc.cellsPerClusterLimit;
-    }
-    if (tc.trackletsPerClusterLimit >= 0) {
-      params.TrackletsPerClusterLimit = tc.trackletsPerClusterLimit;
-    }
-    if (tc.findShortTracks >= 0) {
-      params.FindShortTracks = tc.findShortTracks;
-    }
-  }
-}
-
 void Tracker::adoptTimeFrame(TimeFrame7& tf)
 {
   mTimeFrame = &tf;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 8dd6b9870115c..da7f31bd678b5 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -616,12 +616,12 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
           continue;
         }
 
-        if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
+        if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
           CA_DEBUGGER(failed[2]++);
           continue;
         }
 
-        if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+        if (mTrkParams[0].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
           if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
             continue;
           }
@@ -1023,11 +1023,11 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
       return false;
     }
 
-    if (!propInstance->propagateToX(track, trackingHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mCorrType)) {
+    if (!propInstance->propagateToX(track, trackingHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
       return false;
     }
 
-    if (mCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+    if (mTrkParams[0].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
       if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
         continue;
       }
@@ -1201,7 +1201,7 @@ void TrackerTraits<nLayers>::setBz(float bz)
 template <int nLayers>
 bool TrackerTraits<nLayers>::isMatLUT() const
 {
-  return o2::base::Propagator::Instance()->getMatLUT() && (mCorrType == o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT);
+  return o2::base::Propagator::Instance()->getMatLUT() && (mTrkParams[0].CorrType == o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT);
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 4f4941aca9f4d..4bdd2060d2110 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -33,122 +33,26 @@ using namespace o2::its;
 
 void ITSTrackingInterface::initialise()
 {
-  mRunVertexer = true;
-  mCosmicsProcessing = false;
-  std::vector<VertexingParameters> vertParams;
-  std::vector<TrackingParameters> trackParams;
-  const auto& vertConf = o2::its::VertexerParamConfig::Instance();
+  // get parameters
   const auto& trackConf = o2::its::TrackerParamConfig::Instance();
-  float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791;
-  float bFactorTracklets = bFactor < 0.01 ? 1. : bFactor; // for tracklets only
+  const auto& vertConf = o2::its::VertexerParamConfig::Instance();
   if (mMode == TrackingMode::Unset) {
-    mMode = (TrackingMode)(trackConf.trackingMode);
-    LOGP(info, "Tracking mode not set, trying to fetch it from configurable params to: {}", asString(mMode));
-  }
-  if (mMode == TrackingMode::Async) {
-    trackParams.resize(trackConf.doUPCIteration ? 4 : 3);
-    vertParams.resize(2); // The number of actual iterations will be set as a configKeyVal to allow for pp/PbPb choice
-    trackParams[1].TrackletMinPt = 0.2f;
-    trackParams[1].CellDeltaTanLambdaSigma *= 2.;
-    trackParams[2].TrackletMinPt = 0.1f;
-    trackParams[2].CellDeltaTanLambdaSigma *= 4.;
-
-    trackParams[0].MinPt[0] = 1.f / 12; // 7cl
-
-    trackParams[1].MinPt[0] = 1.f / 12; // 7cl
-
-    trackParams[2].MinTrackLength = 4;
-    trackParams[2].MinPt[0] = 1.f / 12; // 7cl
-    trackParams[2].MinPt[1] = 1.f / 5;  // 6cl
-    trackParams[2].MinPt[2] = 1.f / 1;  // 5cl
-    trackParams[2].MinPt[3] = 1.f / 6;  // 4cl
-
-    trackParams[2].StartLayerMask = (1 << 6) + (1 << 3);
-    if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
-      trackParams[3].MinTrackLength = 4;
-      trackParams[3].TrackletMinPt = 0.1f;
-      trackParams[3].CellDeltaTanLambdaSigma *= 4.;
-      trackParams[3].DeltaROF = 0; // UPC specific setting
-    }
-    for (size_t ip = 0; ip < trackParams.size(); ip++) {
-      auto& param = trackParams[ip];
-      param.ZBins = 64;
-      param.PhiBins = 32;
-      param.CellsPerClusterLimit = 1.e3f;
-      param.TrackletsPerClusterLimit = 1.e3f;
-      // check if something was overridden via configurable params
-      if (ip < trackConf.MaxIter) {
-        if (trackConf.startLayerMask[ip] > 0) {
-          trackParams[2].StartLayerMask = trackConf.startLayerMask[ip];
-        }
-        if (trackConf.minTrackLgtIter[ip] > 0) {
-          param.MinTrackLength = trackConf.minTrackLgtIter[ip];
-        }
-        for (int ilg = trackConf.MaxTrackLength; ilg >= trackConf.MinTrackLength; ilg--) {
-          int lslot0 = (trackConf.MaxTrackLength - ilg), lslot = lslot0 + ip * (trackConf.MaxTrackLength - trackConf.MinTrackLength + 1);
-          if (trackConf.minPtIterLgt[lslot] > 0.) {
-            param.MinPt[lslot0] = trackConf.minPtIterLgt[lslot];
-          }
-        }
-      }
-    }
-    LOGP(info, "Initializing tracker in async. phase reconstruction with {} passes for tracking and {}/{} for vertexing", trackParams.size(), o2::its::VertexerParamConfig::Instance().nIterations, vertParams.size());
-    vertParams[1].phiCut = 0.015f;
-    vertParams[1].tanLambdaCut = 0.015f;
-    vertParams[1].vertPerRofThreshold = 0;
-    vertParams[1].deltaRof = 0;
-  } else if (mMode == TrackingMode::Sync) {
-    trackParams.resize(1);
-    trackParams[0].ZBins = 64;
-    trackParams[0].PhiBins = 32;
-    trackParams[0].MinTrackLength = 4;
-    LOGP(info, "Initializing tracker in sync. phase reconstruction with {} passes", trackParams.size());
-    vertParams.resize(1);
-  } else if (mMode == TrackingMode::Cosmics) {
-    mCosmicsProcessing = true;
-    mRunVertexer = false;
-    trackParams.resize(1);
-    trackParams[0].MinTrackLength = 4;
-    trackParams[0].CellDeltaTanLambdaSigma *= 10;
-    trackParams[0].PhiBins = 4;
-    trackParams[0].ZBins = 16;
-    trackParams[0].PVres = 1.e5f;
-    trackParams[0].MaxChi2ClusterAttachment = 60.;
-    trackParams[0].MaxChi2NDF = 40.;
-    trackParams[0].TrackletsPerClusterLimit = 100.;
-    trackParams[0].CellsPerClusterLimit = 100.;
-    LOGP(info, "Initializing tracker in reconstruction for cosmics with {} passes", trackParams.size());
-
-  } else {
-    throw std::runtime_error(fmt::format("Unsupported ITS tracking mode {:s} ", asString(mMode)));
+    mMode = (TrackingMode::Type)trackConf.trackingMode;
+    LOGP(info, "Tracking mode not set, trying to fetch it from configurable params to: {}", TrackingMode::toString(mMode));
   }
+  auto trackParams = TrackingMode::getTrackingParameters(mMode);
+  auto vertParams = TrackingMode::getVertexingParameters(mMode);
+  LOGP(info, "Initializing tracker in {} phase reconstruction with {} passes for tracking and {}/{} for vertexing", TrackingMode::toString(mMode), trackParams.size(), o2::its::VertexerParamConfig::Instance().nIterations, vertParams.size());
+  mTracker->setParameters(trackParams);
+  mVertexer->setParameters(vertParams);
 
-  // TODO this imposes the same memory limits on each iteration
-  for (auto& p : vertParams) {
-    p.PrintMemory = vertConf.printMemory;
-    p.MaxMemory = vertConf.maxMemory;
-    p.DropTFUponFailure = vertConf.dropTFUponFailure;
-  }
-  for (auto& p : trackParams) {
-    p.PrintMemory = trackConf.printMemory;
-    p.MaxMemory = trackConf.maxMemory;
-    p.DropTFUponFailure = trackConf.dropTFUponFailure;
+  if (mMode == TrackingMode::Cosmics) {
+    mRunVertexer = false;
+    mCosmicsProcessing = true;
+    LOGP(info, "Cosmic mode enabled, will skip vertexing");
   }
 
-  for (auto& params : trackParams) {
-    params.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT;
-  }
-  // adjust pT settings to actual mag. field
-  for (size_t ip = 0; ip < trackParams.size(); ip++) {
-    auto& param = trackParams[ip];
-    param.TrackletMinPt *= bFactorTracklets;
-    for (int ilg = trackConf.MaxTrackLength; ilg >= trackConf.MinTrackLength; ilg--) {
-      int lslot = trackConf.MaxTrackLength - ilg;
-      param.MinPt[lslot] *= bFactor;
-    }
-  }
-  mTracker->setParameters(trackParams);
-  mVertexer->setParameters(vertParams);
+  // threading
   if (trackConf.nThreads == vertConf.nThreads) {
     bool clamped{false};
     int nThreads = trackConf.nThreads;
@@ -409,7 +313,6 @@ void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContex
     GeometryTGeo* geom = GeometryTGeo::Instance();
     geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G));
     initialise();
-    getConfiguration(pc);
 
     if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
       o2::its::VertexerParamConfig::Instance().printKeyValues();
@@ -428,12 +331,6 @@ void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContex
   }
 }
 
-void ITSTrackingInterface::getConfiguration(framework::ProcessingContext& pc)
-{
-  mVertexer->getGlobalConfiguration();
-  mTracker->getGlobalConfiguration();
-}
-
 void ITSTrackingInterface::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 {
   if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index a1a1a90da8963..bd9d1402a1ebf 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -84,36 +84,6 @@ float Vertexer::clustersToVertices(LogFunc logger)
   return timeInit + timeTracklet + timeSelection + timeVertexing;
 }
 
-void Vertexer::getGlobalConfiguration()
-{
-  auto& vc = o2::its::VertexerParamConfig::Instance();
-  auto& grc = o2::its::ITSGpuTrackingParamConfig::Instance();
-
-  // This is odd: we override only the parameters for the first iteration.
-  // Variations for the next iterations are set in the trackingInterfrace.
-  mVertParams[0].nIterations = vc.nIterations;
-  mVertParams[0].deltaRof = vc.deltaRof;
-  mVertParams[0].allowSingleContribClusters = vc.allowSingleContribClusters;
-  mVertParams[0].zCut = vc.zCut;
-  mVertParams[0].phiCut = vc.phiCut;
-  mVertParams[0].pairCut = vc.pairCut;
-  mVertParams[0].clusterCut = vc.clusterCut;
-  mVertParams[0].histPairCut = vc.histPairCut;
-  mVertParams[0].tanLambdaCut = vc.tanLambdaCut;
-  mVertParams[0].lowMultBeamDistCut = vc.lowMultBeamDistCut;
-  mVertParams[0].vertNsigmaCut = vc.vertNsigmaCut;
-  mVertParams[0].vertRadiusSigma = vc.vertRadiusSigma;
-  mVertParams[0].trackletSigma = vc.trackletSigma;
-  mVertParams[0].maxZPositionAllowed = vc.maxZPositionAllowed;
-  mVertParams[0].clusterContributorsCut = vc.clusterContributorsCut;
-  mVertParams[0].maxTrackletsPerCluster = vc.maxTrackletsPerCluster;
-  mVertParams[0].phiSpan = vc.phiSpan;
-  mVertParams[0].nThreads = vc.nThreads;
-  mVertParams[0].ZBins = vc.ZBins;
-  mVertParams[0].PhiBins = vc.PhiBins;
-  mVertParams[0].SaveTimeBenchmarks = vc.saveTimeBenchmarks;
-}
-
 void Vertexer::adoptTimeFrame(TimeFrame7& tf)
 {
   mTimeFrame = &tf;
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
index 02e278eeedda9..88e4b06a5c8ce 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
@@ -35,7 +35,7 @@ namespace its
 class CookedTrackerDPL : public Task
 {
  public:
-  CookedTrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, int trgType, const TrackingMode& trMode);
+  CookedTrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, int trgType, TrackingMode::Type trMode);
   ~CookedTrackerDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -51,7 +51,7 @@ class CookedTrackerDPL : public Task
   bool mUseMC = true;
   bool mRunVertexer = true;
   int mUseTriggers = 0;
-  TrackingMode mMode = TrackingMode::Sync;
+  TrackingMode::Type mMode = TrackingMode::Sync;
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
   std::unique_ptr<o2::parameters::GRPObject> mGRP = nullptr;
   o2::its::CookedTracker mTracker;
@@ -62,7 +62,7 @@ class CookedTrackerDPL : public Task
 
 /// create a processor spec
 /// run ITS CookedMatrix tracker
-framework::DataProcessorSpec getCookedTrackerSpec(bool useMC, bool useGeom, int useTrig, const std::string& trMode);
+framework::DataProcessorSpec getCookedTrackerSpec(bool useMC, bool useGeom, int useTrig, TrackingMode::Type trMode);
 
 } // namespace its
 } // namespace o2
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
index 7f9efa2098893..0ab48d713f7c7 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
@@ -15,7 +15,7 @@
 /// @file   RecoWorkflow.h
 
 #include "Framework/WorkflowSpec.h"
-
+#include "ITStracking/Configuration.h"
 #include "GPUDataTypes.h"
 
 namespace o2
@@ -26,7 +26,7 @@ namespace its
 namespace reco_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC, bool useCAtracker, const std::string& trmode, const bool overrideBeamPosition = false,
+framework::WorkflowSpec getWorkflow(bool useMC, bool useCAtracker, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
                                     bool upstreamDigits = false, bool upstreamClusters = false, bool disableRootOutput = false, bool useGeom = false, int useTrig = 0,
                                     bool useGPUWF = false, o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
index 27c4174fab244..ee5ba4d5cc61c 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
@@ -37,7 +37,7 @@ class TrackerDPL : public framework::Task
   TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
              bool isMC,
              int trgType,
-             const TrackingMode& trMode = TrackingMode::Unset,
+             const TrackingMode::Type trMode = TrackingMode::Unset,
              const bool overrBeamEst = false,
              o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
@@ -57,8 +57,7 @@ class TrackerDPL : public framework::Task
   TStopwatch mTimer;
 };
 
-using o2::its::TrackingMode;
-framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, const std::string& trMode, const bool overrBeamEst = false, o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, TrackingMode::Type trMode, const bool overrBeamEst = false, o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
 
 } // namespace o2::its
 
diff --git a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
index 4a0470adcf07a..640265f881749 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
@@ -52,7 +52,7 @@ namespace its
 
 using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
-CookedTrackerDPL::CookedTrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, int trgType, const TrackingMode& trMode) : mGGCCDBRequest(gr), mUseMC(useMC), mUseTriggers{trgType}, mMode(trMode)
+CookedTrackerDPL::CookedTrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, int trgType, TrackingMode::Type trMode) : mGGCCDBRequest(gr), mUseMC(useMC), mUseTriggers{trgType}, mMode(trMode)
 {
   mVertexerTraitsPtr = std::make_unique<VertexerTraits>();
   mVertexerPtr = std::make_unique<Vertexer>(mVertexerTraitsPtr.get());
@@ -225,13 +225,13 @@ void CookedTrackerDPL::updateTimeDependentParams(ProcessingContext& pc)
     if (pc.inputs().getPos("itsTGeo") >= 0) {
       pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
     }
-    mVertexerPtr->getGlobalConfiguration();
+    mVertexerPtr->setParameters(TrackingMode::getVertexingParameters(mMode));
     o2::its::GeometryTGeo* geom = o2::its::GeometryTGeo::Instance();
     geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot,
                                                    o2::math_utils::TransformType::T2G));
     mTracker.setGeometry(geom);
     mTracker.setConfigParams();
-    LOG(info) << "Tracking mode " << mMode;
+    LOG(info) << "Tracking mode " << TrackingMode::toString(mMode);
     if (mMode == TrackingMode::Cosmics) {
       LOG(info) << "Setting cosmics parameters...";
       mTracker.setParametersCosmics();
@@ -269,7 +269,7 @@ void CookedTrackerDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   }
 }
 
-DataProcessorSpec getCookedTrackerSpec(bool useMC, bool useGeom, int trgType, const std::string& trModeS)
+DataProcessorSpec getCookedTrackerSpec(bool useMC, bool useGeom, int trgType, TrackingMode::Type trmode)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("compClusters", "ITS", "COMPCLUSTERS", 0, Lifetime::Timeframe);
@@ -315,8 +315,7 @@ DataProcessorSpec getCookedTrackerSpec(bool useMC, bool useGeom, int trgType, co
     AlgorithmSpec{adaptFromTask<CookedTrackerDPL>(ggRequest,
                                                   useMC,
                                                   trgType,
-                                                  trModeS == "sync" ? o2::its::TrackingMode::Sync : trModeS == "async" ? o2::its::TrackingMode::Async
-                                                                                                                       : o2::its::TrackingMode::Cosmics)},
+                                                  trmode)},
     Options{{"nthreads", VariantType::Int, 1, {"Number of threads"}}}};
 }
 
diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index 05e873c18b898..a72c26a3681e1 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -36,7 +36,7 @@ namespace reco_workflow
 
 framework::WorkflowSpec getWorkflow(bool useMC,
                                     bool useCAtracker,
-                                    const std::string& trmode,
+                                    TrackingMode::Type trmode,
                                     const bool overrideBeamPosition,
                                     bool upstreamDigits,
                                     bool upstreamClusters,
@@ -56,7 +56,7 @@ framework::WorkflowSpec getWorkflow(bool useMC,
   if (!disableRootOutput) {
     specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
   }
-  if (!trmode.empty()) {
+  if (trmode != TrackingMode::Off) {
     if (useCAtracker) {
       if (useGPUWF) {
         o2::gpu::GPURecoWorkflowSpec::Config cfg;
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index 9f84ee6522567..fedc42c017f7e 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -26,7 +26,7 @@ using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        bool isMC,
                        int trgType,
-                       const TrackingMode& trMode,
+                       const TrackingMode::Type trMode,
                        const bool overrBeamEst,
                        o2::gpu::GPUDataTypes::DeviceType dType) : mGGCCDBRequest(gr),
                                                                   mRecChain{o2::gpu::GPUReconstruction::CreateInstance(dType, true)},
@@ -79,7 +79,7 @@ void TrackerDPL::end()
   LOGF(info, "ITS CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, const std::string& trModeS, const bool overrBeamEst, o2::gpu::GPUDataTypes::DeviceType dType)
+DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::GPUDataTypes::DeviceType dType)
 {
   std::vector<InputSpec> inputs;
 
@@ -132,8 +132,7 @@ DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, const st
     AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
                                             useMC,
                                             trgType,
-                                            trModeS == "sync" ? o2::its::TrackingMode::Sync : trModeS == "async" ? o2::its::TrackingMode::Async
-                                                                                                                 : o2::its::TrackingMode::Cosmics,
+                                            trMode,
                                             overrBeamEst,
                                             dType)},
     Options{}};
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
index 168e1363d6fb5..b7d72eb3618db 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
@@ -11,7 +11,6 @@
 
 #include "ITSWorkflow/RecoWorkflow.h"
 #include "CommonUtils/ConfigurableParam.h"
-#include "ITStracking/TrackingConfigParam.h"
 #include "ITStracking/Configuration.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
@@ -45,7 +44,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"trackerCA", o2::framework::VariantType::Bool, false, {"use trackerCA (default: trackerCM)"}},
     {"ccdb-meanvertex-seed", o2::framework::VariantType::Bool, false, {"use MeanVertex from CCDB if available to provide beam position seed (default: false)"}},
     {"select-with-triggers", o2::framework::VariantType::String, "none", {"use triggers to prescale processed ROFs: phys, trd, none"}},
-    {"tracking-mode", o2::framework::VariantType::String, "sync", {"sync,async,cosmics"}},
+    {"tracking-mode", o2::framework::VariantType::String, "sync", {"sync,async,cosmics,unset,off"}},
     {"disable-tracking", o2::framework::VariantType::Bool, false, {"disable tracking step"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight ITS part"}},
@@ -75,9 +74,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
   if (configcontext.options().get<bool>("disable-tracking")) {
-    trmode = "";
+    trmode = "off";
   }
-  std::transform(trmode.begin(), trmode.end(), trmode.begin(), [](unsigned char c) { return std::tolower(c); });
 
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
   int trType = 0;
@@ -92,7 +90,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   }
   auto wf = o2::its::reco_workflow::getWorkflow(useMC,
                                                 useCAtracker,
-                                                trmode,
+                                                o2::its::TrackingMode::fromString(trmode),
                                                 beamPosOVerride,
                                                 extDigits,
                                                 extClusters,
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
index afb276e956e76..99ac05e61baf8 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
@@ -33,7 +33,6 @@ void ITS3TrackingInterface::updateTimeDependentParams(framework::ProcessingConte
     auto geom = its::GeometryTGeo::Instance();
     geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G));
     initialise();
-    getConfiguration(pc);
     if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
       o2::its::VertexerParamConfig::Instance().printKeyValues();
       o2::its::TrackerParamConfig::Instance().printKeyValues();
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
index 1760aa1d850eb..592a34d94a3ca 100644
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
+++ b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
@@ -15,7 +15,7 @@
 /// @file   RecoWorkflow.h
 
 #include "Framework/WorkflowSpec.h"
-
+#include "ITStracking/Configuration.h"
 #include "GPUO2Interface.h"
 #include "GPUReconstruction.h"
 #include "GPUChainITS.h"
@@ -24,7 +24,7 @@ namespace o2::its3::reco_workflow
 {
 
 framework::WorkflowSpec getWorkflow(bool useMC,
-                                    const std::string& trmode,
+                                    its::TrackingMode::Type trmode,
                                     o2::gpu::GPUDataTypes::DeviceType dtype,
                                     bool useGPUWorkflow,
                                     bool upstreamDigits,
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h
index f5c1d7bf0e947..42f71b6ccebe0 100644
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h
+++ b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h
@@ -37,7 +37,7 @@ class TrackerDPL : public framework::Task
   TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
              bool isMC,
              int trgType,
-             const its::TrackingMode& trMode = its::TrackingMode::Unset,
+             its::TrackingMode::Type trmode = its::TrackingMode::Unset,
              const bool overrBeamEst = false,
              gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
@@ -63,7 +63,7 @@ class TrackerDPL : public framework::Task
 
 /// create a processor spec
 /// run ITS CA tracker
-framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, const std::string& trMode, const bool overrBeamEst = false, gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, its::TrackingMode::Type trMode, const bool overrBeamEst = false, gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
 
 } // namespace o2::its3
 
diff --git a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
index 947e53f80ddf1..8a1c1ef73cf2b 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
@@ -26,7 +26,7 @@ static std::shared_ptr<o2::gpu::GPURecoWorkflowSpec> gTask;
 namespace o2::its3::reco_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC, const std::string& trmode, o2::gpu::GPUDataTypes::DeviceType dtype, bool useGPUWorkflow,
+framework::WorkflowSpec getWorkflow(bool useMC, its::TrackingMode::Type trmode, o2::gpu::GPUDataTypes::DeviceType dtype, bool useGPUWorkflow,
                                     bool upstreamDigits, bool upstreamClusters, bool disableRootOutput, bool useGeom, int useTrig, bool overrideBeamPosition)
 {
   framework::WorkflowSpec specs;
@@ -43,7 +43,7 @@ framework::WorkflowSpec getWorkflow(bool useMC, const std::string& trmode, o2::g
     specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
   }
 
-  if (trmode != "off") {
+  if (trmode != its::TrackingMode::Off) {
     if (useGPUWorkflow) {
       o2::gpu::GPURecoWorkflowSpec::Config cfg;
       cfg.runITSTracking = true;
diff --git a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
index 5b710a3d11fef..7945f8e0af1df 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
@@ -49,7 +49,7 @@ using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        bool isMC,
                        int trgType,
-                       const its::TrackingMode& trMode,
+                       its::TrackingMode::Type trMode,
                        const bool overrBeamEst,
                        o2::gpu::GPUDataTypes::DeviceType dType) : mGGCCDBRequest(gr),
                                                                   mRecChain{o2::gpu::GPUReconstruction::CreateInstance(dType, true)},
@@ -95,7 +95,7 @@ void TrackerDPL::endOfStream(EndOfStreamContext& ec)
   LOGF(info, "ITS3 CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, const std::string& trModeS, const bool overrBeamEst, o2::gpu::GPUDataTypes::DeviceType dType)
+DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, its::TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::GPUDataTypes::DeviceType dType)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("compClusters", "ITS", "COMPCLUSTERS", 0, Lifetime::Timeframe);
@@ -145,10 +145,7 @@ DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, const st
     "its3-tracker",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest, useMC, trgType,
-                                            trModeS == "sync" ? o2::its::TrackingMode::Sync : trModeS == "async" ? o2::its::TrackingMode::Async
-                                                                                                                 : o2::its::TrackingMode::Cosmics,
-                                            overrBeamEst, dType)},
+    AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest, useMC, trgType, trMode, overrBeamEst, dType)},
     Options{}};
 }
 
diff --git a/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
index 2f0eda73742cb..e4c78b3323a5e 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
@@ -69,7 +69,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
   auto useGPUWfx = configcontext.options().get<bool>("use-gpu-workflow");
-  std::transform(trmode.begin(), trmode.end(), trmode.begin(), [](unsigned char c) { return std::tolower(c); });
 
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
   int trType = 0;
@@ -82,7 +81,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
       LOG(fatal) << "Unknown trigger type requested for events prescaling: " << selTrig;
     }
   }
-  auto wf = o2::its3::reco_workflow::getWorkflow(useMC, trmode, gpuDevice, useGPUWfx, extDigits, extClusters, disableRootOutput, useGeom, trType, beamPosOVerride);
+  auto wf = o2::its3::reco_workflow::getWorkflow(useMC, o2::its::TrackingMode::fromString(trmode), gpuDevice, useGPUWfx, extDigits, extClusters, disableRootOutput, useGeom, trType, beamPosOVerride);
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, wf);

From 82d072d317b0342bda21e92e35e89ef16f3176e1 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sun, 8 Jun 2025 14:13:03 +0200
Subject: [PATCH 0606/1764] ITS: prefer config params over cli

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 4bdd2060d2110..604c6ad88080f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -36,9 +36,9 @@ void ITSTrackingInterface::initialise()
   // get parameters
   const auto& trackConf = o2::its::TrackerParamConfig::Instance();
   const auto& vertConf = o2::its::VertexerParamConfig::Instance();
-  if (mMode == TrackingMode::Unset) {
-    mMode = (TrackingMode::Type)trackConf.trackingMode;
-    LOGP(info, "Tracking mode not set, trying to fetch it from configurable params to: {}", TrackingMode::toString(mMode));
+  if (auto parmode = (TrackingMode::Type)trackConf.trackingMode; mMode == TrackingMode::Unset || (parmode != TrackingMode::Unset && mMode != parmode)) {
+    LOGP(info, "Tracking mode overwritten by configurable params from {} to {}", TrackingMode::toString(mMode), TrackingMode::toString(parmode));
+    mMode = parmode;
   }
   auto trackParams = TrackingMode::getTrackingParameters(mMode);
   auto vertParams = TrackingMode::getVertexingParameters(mMode);

From 980e564044e8dc68a6bee7243d1e23c456c9eae3 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Wed, 9 Jul 2025 18:06:37 +0200
Subject: [PATCH 0607/1764] TrackReference: possibility to have unknown
 DetectorID

We've been using 0 as detectorID in generic "Stopping" TrackReferences.
Unfortunately, 0 is also the ID of the ITS sensitive detector according to
o2::detectors::DetID class.
The commit changes this to using -1, where -1 means simply means "unknown".
---
 .../simulation/include/SimulationDataFormat/TrackReference.h    | 2 +-
 Detectors/gconfig/src/StandardSteppingTrackRefHook.macro        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/TrackReference.h b/DataFormats/simulation/include/SimulationDataFormat/TrackReference.h
index f3d41a17208f0..34d1c57aa9f0b 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/TrackReference.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/TrackReference.h
@@ -171,7 +171,7 @@ class TrackReference
   float mTrackLength = 0; ///< track length from its origin in cm
   float mTof = 0;         ///< time of flight in cm
   Int_t mUserId = 0;      ///< optional Id defined by user
-  Int_t mDetectorId = 0;  ///< Detector Id
+  Int_t mDetectorId = -1; ///< sensitive Detector Id (-1 if unknown or in passive material)
   SimTrackStatus mStatus; ///< encoding the track status
 
   friend std::ostream& operator<<(std::ostream&, const TrackReference&);
diff --git a/Detectors/gconfig/src/StandardSteppingTrackRefHook.macro b/Detectors/gconfig/src/StandardSteppingTrackRefHook.macro
index e408bbff420b5..3888d3c74ca8d 100644
--- a/Detectors/gconfig/src/StandardSteppingTrackRefHook.macro
+++ b/Detectors/gconfig/src/StandardSteppingTrackRefHook.macro
@@ -8,7 +8,7 @@ o2::steer::O2MCApplicationBase::TrackRefFcn trackRefHook() {
     if (vmc->IsTrackStop() && stack->currentTrackLeftTrackRef()) {
        // we add a stopping TrackRef when the current track already
        // registered previous TrackRefs
-       stack->addTrackReference(o2::TrackReference(*vmc, 0));
+       stack->addTrackReference(o2::TrackReference(*vmc, -1));
     }
   };
 }
\ No newline at end of file

From 0d508b3a38af55d5adb4e1623e6aa6b24cafb400 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 9 Jul 2025 08:36:45 +0200
Subject: [PATCH 0608/1764] AOD: TrackQA use outer ITS ref. for residuals to
 TPC

@miranov25 after taking to @mpuccio and @hscheid, I realised that the current residuals are biased since they the take the innermost representation of the track while one should take the outermost one to compare to TPC.
---
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 1cc89d54a030d..ac7fc06a2d5da 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -2717,7 +2717,7 @@ AODProducerWorkflowDPL::TrackQA AODProducerWorkflowDPL::processBarrelTrackQA(int
     if (auto itsContGID = data.getITSContributorGID(trackIndex); itsContGID.isIndexSet() && itsContGID.getSource() != GIndex::ITSAB) {
       const auto& itsOrig = data.getITSTrack(itsContGID);
       o2::track::TrackPar gloCopy = trackPar;
-      o2::track::TrackPar itsCopy = itsOrig;
+      o2::track::TrackPar itsCopy = itsOrig.getParamOut();
       o2::track::TrackPar tpcCopy = tpcOrig;
       if (prop->propagateToX(gloCopy, o2::aod::track::trackQARefRadius, prop->getNominalBz(), o2::base::Propagator::MAX_SIN_PHI, o2::base::Propagator::MAX_STEP, mMatCorr) &&
           prop->propagateToAlphaX(tpcCopy, gloCopy.getAlpha(), o2::aod::track::trackQARefRadius, false, o2::base::Propagator::MAX_SIN_PHI, o2::base::Propagator::MAX_STEP, 1, mMatCorr) &&

From c26672b91edfd935ef3e40a324c7a4353334ab2c Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 24 Jun 2025 21:32:35 +0200
Subject: [PATCH 0609/1764] ITS: remove some printing

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx           | 3 ---
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx | 1 -
 2 files changed, 4 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index e0bd94ed223c0..7a2e883e1b5e6 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -130,9 +130,6 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
       auto nTracksA = mTimeFrame->getNumberOfTracks();
       logger(std::format("  `-> found {} additional tracks", nTracksA - nTracksB));
     }
-    if (mTrkParams[iteration].PrintMemory) {
-      mMemoryPool->print();
-    }
     if constexpr (constants::DoTimeBenchmarks) {
       logger(std::format("=== TimeFrame {} processing completed in: {:.2f} ms using {} thread(s) ===", mTimeFrameCounter, total, mTraits->getNThreads()));
     }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 604c6ad88080f..29dc55337bfc3 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -362,7 +362,6 @@ void ITSTrackingInterface::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 
 void ITSTrackingInterface::printSummary() const
 {
-  mMemoryPool->print();
   mTracker->printSummary();
 }
 

From 6665ddd4f5b46f5f64d016335b5758a6421c96a7 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <fschlepp@aliceml.cern.ch>
Date: Wed, 9 Jul 2025 07:51:48 +0200
Subject: [PATCH 0610/1764] ITS: fix TypedAllocator for cuda thrust

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 43 ++++++++++++-------
 1 file changed, 28 insertions(+), 15 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 8245aee33718c..38c59d520aa76 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -58,30 +58,43 @@ namespace gpu
 {
 
 template <typename T>
-class TypedAllocator : public thrust::device_allocator<T>
-{
- public:
+struct TypedAllocator {
   using value_type = T;
-  using pointer = T*;
+  using pointer = thrust::device_ptr<T>;
+  using const_pointer = thrust::device_ptr<const T>;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  TypedAllocator() noexcept : mInternalAllocator(nullptr) {}
+  explicit TypedAllocator(ExternalAllocator* a) noexcept : mInternalAllocator(a) {}
 
   template <typename U>
-  struct rebind {
-    using other = TypedAllocator<U>;
-  };
+  TypedAllocator(const TypedAllocator<U>& o) noexcept : mInternalAllocator(o.mInternalAllocator)
+  {
+  }
 
-  explicit TypedAllocator(ExternalAllocator* allocPtr)
-    : mInternalAllocator(allocPtr) {}
+  pointer allocate(size_type n)
+  {
+    void* raw = mInternalAllocator->allocate(n * sizeof(T));
+    return thrust::device_pointer_cast(static_cast<T*>(raw));
+  }
 
-  T* allocate(size_t n)
+  void deallocate(pointer p, size_type n) noexcept
   {
-    return reinterpret_cast<T*>(mInternalAllocator->allocate(n * sizeof(T)));
+    if (!p) {
+      return;
+    }
+    void* raw = thrust::raw_pointer_cast(p);
+    mInternalAllocator->deallocate(static_cast<char*>(raw), n * sizeof(T));
   }
 
-  void deallocate(T* p, size_t n)
+  bool operator==(TypedAllocator const& o) const noexcept
+  {
+    return mInternalAllocator == o.mInternalAllocator;
+  }
+  bool operator!=(TypedAllocator const& o) const noexcept
   {
-    char* raw_ptr = reinterpret_cast<char*>(p);
-    size_t bytes = n * sizeof(T);
-    mInternalAllocator->deallocate(raw_ptr, bytes); // redundant as internal dealloc is no-op.
+    return !(*this == o);
   }
 
  private:

From 53be5c459c07a60bcc202494990330d3d7d80d07 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 11 Jul 2025 10:47:45 +0200
Subject: [PATCH 0611/1764] GPU Display OpenGL Backend: Use nullptr instead of
 0

---
 GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
index 664734fe6dff0..0d9a6f052d617 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
@@ -330,9 +330,9 @@ int32_t GPUDisplayBackendOpenGL::InitBackendA()
 #if defined(GL_VERSION_4_6) && GL_VERSION_4_6 == 1 && defined(GPUCA_BUILD_EVENT_DISPLAY_VULKAN)
   if (getenv("USE_SPIRV_SHADERS") && atoi(getenv("USE_SPIRV_SHADERS"))) {
     CHKERR(glShaderBinary(1, &mVertexShader, GL_SHADER_BINARY_FORMAT_SPIR_V_ARB, _binary_shaders_shaders_vertex_vert_spv_start, _binary_shaders_shaders_vertex_vert_spv_len));
-    CHKERR(glSpecializeShader(mVertexShader, "main", 0, 0, 0));
+    CHKERR(glSpecializeShader(mVertexShader, "main", 0, nullptr, nullptr));
     CHKERR(glShaderBinary(1, &mFragmentShader, GL_SHADER_BINARY_FORMAT_SPIR_V_ARB, _binary_shaders_shaders_fragmentUniform_frag_spv_start, _binary_shaders_shaders_fragmentUniform_frag_spv_len));
-    CHKERR(glSpecializeShader(mFragmentShader, "main", 0, 0, 0));
+    CHKERR(glSpecializeShader(mFragmentShader, "main", 0, nullptr, nullptr));
     GPUInfo("Using SPIR-V shaders");
     mSPIRVShaders = true;
   } else

From 28d2dc3ceba7767be7e318ea6acca2cfa0152a0f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 11 Jul 2025 15:30:51 +0200
Subject: [PATCH 0612/1764] GPU QA: Make cluster cuts setable and adust
 defaults

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  3 +++
 GPU/GPUTracking/qa/GPUQA.cxx                  | 15 ++++++---------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 0ff8adb1cb957..51a0add7dbeea 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -512,6 +512,9 @@ AddOption(shipToQC, bool, false, "", 0, "Do not write output files but ship hist
 AddOption(shipToQCAsCanvas, bool, false, "", 0, "Send TCanvases with full layout to QC instead of individual histograms")
 AddOption(clusterRejectionHistograms, bool, false, "", 0, "Fill histograms with cluster rejection statistics")
 AddOption(histMaxNClusters, uint32_t, 500000000, "", 0, "Maximum number of clusters in rejection histograms")
+AddOption(minNClFindable, uint32_t, 70, "", 0, "Minimum number of (weighted) MC clusters for a track to count as findable")
+AddOption(minNClEff, uint32_t, 10, "", 0, "Minimum number of (weighted) MC clusters for a track to contribute to all-tracks efficiency histogramm")
+AddOption(minNClRes, uint32_t, 40, "", 0, "Minimum number of (weighted) MC clusters for a track to contribute to resolution histogram")
 AddShortcut("compare", 0, "--QAinput", "Compare QA histograms", "--qa", "--QAinputHistogramsOnly")
 AddHelp("help", 'h')
 EndConfig()
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 6f640578a8804..2e9c3a1870385 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -158,15 +158,12 @@ static constexpr float PT_MAX = 20;
 static constexpr float ETA_MAX = 1.5;
 static constexpr float ETA_MAX2 = 0.9;
 
-static constexpr float MIN_WEIGHT_CLS = 40;
-static constexpr float FINDABLE_WEIGHT_CLS = 70;
-
 static constexpr bool CLUST_HIST_INT_SUM = false;
 
 static constexpr const int32_t COLORCOUNT = 12;
 
 static const constexpr char* EFF_TYPES[5] = {"Rec", "Clone", "Fake", "All", "RecAndClone"};
-static const constexpr char* FINDABLE_NAMES[2] = {"", "Findable"};
+static const constexpr char* FINDABLE_NAMES[2] = {"All", "Findable"};
 static const constexpr char* PRIM_NAMES[2] = {"Prim", "Sec"};
 static const constexpr char* PARAMETER_NAMES[5] = {"Y", "Z", "#Phi", "#lambda", "Relative #it{p}_{T}"};
 static const constexpr char* PARAMETER_NAMES_NATIVE[5] = {"Y", "Z", "sin(#Phi)", "tan(#lambda)", "q/#it{p}_{T} (curvature)"};
@@ -1185,10 +1182,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           if (info.primDaughters) {
             continue;
           }
-          if (mc2.nWeightCls < MIN_WEIGHT_CLS) {
+          if (mc2.nWeightCls < mConfig.minNClEff) {
             continue;
           }
-          int32_t findable = mc2.nWeightCls >= FINDABLE_WEIGHT_CLS;
+          int32_t findable = mc2.nWeightCls >= mConfig.minNClFindable;
           if (info.pid < 0) {
             continue;
           }
@@ -1217,9 +1214,9 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           float localY = -info.x * s + info.y * c;
 
           if (mConfig.dumpToROOT) {
-            static auto effdump = GPUROOTDump<TNtuple>::getNew("eff", "alpha:x:y:z:mcphi:mceta:mcpt:rec:fake:findable:prim");
+            static auto effdump = GPUROOTDump<TNtuple>::getNew("eff", "alpha:x:y:z:mcphi:mceta:mcpt:rec:fake:findable:prim:ncls");
             float localX = info.x * c + info.y * s;
-            effdump.Fill(alpha, localX, localY, info.z, mcphi, mceta, mcpt, mRecTracks[iCol][i], mFakeTracks[iCol][i], findable, info.prim);
+            effdump.Fill(alpha, localX, localY, info.z, mcphi, mceta, mcpt, mRecTracks[iCol][i], mFakeTracks[iCol][i], findable, info.prim, mc2.nWeightCls);
           }
 
           for (int32_t j = 0; j < 4; j++) {
@@ -1304,7 +1301,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         if (mConfig.filterPID >= 0 && mc1.pid != mConfig.filterPID) {
           continue;
         }
-        if (mc2.nWeightCls < MIN_WEIGHT_CLS) {
+        if (mc2.nWeightCls < mConfig.minNClRes) {
           continue;
         }
         if (mConfig.resPrimaries == 1 && !mc1.prim) {

From 662f8647889e81814428fdf6d1703440939b6f54 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 19 Jun 2025 11:00:22 +0200
Subject: [PATCH 0613/1764] ITS: add truth seeding

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt  |  4 +-
 .../include/ITStracking/Configuration.h       |  2 +
 .../include/ITStracking/TrackingConfigParam.h |  2 +
 .../tracking/include/ITStracking/Vertexer.h   |  6 +-
 .../include/ITStracking/VertexerTraits.h      |  2 +
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |  2 +
 .../ITS/tracking/src/TrackingInterface.cxx    |  4 +-
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      | 14 +++--
 .../ITS/tracking/src/VertexerTraits.cxx       | 62 ++++++++++++++++++-
 9 files changed, 84 insertions(+), 14 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index d3871b9e75d70..45080e19cacff 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -36,7 +36,9 @@ o2_add_library(ITStracking
                        O2::ITSReconstruction
                        O2::ITSMFTReconstruction
                        O2::DataFormatsITS
-               PRIVATE_LINK_LIBRARIES TBB::tbb)
+               PRIVATE_LINK_LIBRARIES
+                       O2::Steer
+                       TBB::tbb)
 
 o2_add_library(ITSTrackingInterface
                TARGETVARNAME targetName
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 34b2d11fc16e6..8c46b2e72078a 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -112,6 +112,8 @@ struct VertexingParameters {
   int zSpan = -1;
   bool SaveTimeBenchmarks = false;
 
+  bool useTruthSeeding = false; // overwrite found vertices with MC events
+
   int nThreads = 1;
   bool PrintMemory = false; // print allocator usage in epilog report
   size_t MaxMemory = std::numeric_limits<size_t>::max();
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 039fe0756d6f6..8de80d5e4cd07 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -48,6 +48,8 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   int ZBins = 1;     // z-phi index table configutation: number of z bins
   int PhiBins = 128; // z-phi index table configutation: number of phi bins
 
+  bool useTruthSeeding{false}; // overwrite seeding vertices with MC truth
+
   int nThreads = 1;
   bool printMemory = false;
   size_t maxMemory = std::numeric_limits<size_t>::max();
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 285e4d7e9547d..c8b3b0d4138d4 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -75,7 +75,8 @@ class Vertexer
   void validateTracklets(T&&... args);
   template <typename... T>
   void findVertices(T&&... args);
-  void findHistVertices();
+
+  void addTruthSeeds() { mTraits->addTruthSeedingVertices(); }
 
   template <typename... T>
   void initialiseVertexer(T&&... args);
@@ -108,10 +109,11 @@ class Vertexer
     Trackleting,
     Validating,
     Finding,
+    TruthSeeding,
     NStates,
   };
   State mCurState{Init};
-  static constexpr std::array<const char*, NStates> StateNames{"Initialisation", "Tracklet finding", "Tracklet validation", "Vertex finding"};
+  static constexpr std::array<const char*, NStates> StateNames{"Initialisation", "Tracklet finding", "Tracklet validation", "Vertex finding", "Truth seeding"};
 };
 
 template <typename... T>
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index a842f04abfc62..a2429fe7270a8 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -73,6 +73,8 @@ class VertexerTraits
   virtual void computeVertices(const int iteration = 0);
   virtual void adoptTimeFrame(TimeFrame7* tf) noexcept { mTimeFrame = tf; }
   virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& gpuTfPar);
+  // truth tracking
+  void addTruthSeedingVertices();
 
   void computeVerticesInRof(int,
                             gsl::span<const o2::its::Line>&,
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 56aa52b25940e..1c2857413789b 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -282,6 +282,8 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
     p.nThreads = vc.nThreads;
     p.ZBins = vc.ZBins;
     p.PhiBins = vc.PhiBins;
+
+    p.useTruthSeeding = vc.useTruthSeeding;
   }
   // set for now outside to not disturb status quo
   vertParams[0].vertNsigmaCut = vc.vertNsigmaCut;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 29dc55337bfc3..31dc68d03a7e8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -187,13 +187,13 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       vtxROF.setNEntries(vtxSpan.size());
       bool selROF = vtxSpan.empty();
       for (auto iV{0}; iV < vtxSpan.size(); ++iV) {
-        auto& v = vtxSpan[iV];
+        const auto& v = vtxSpan[iV];
         if (multEstConf.isVtxMultCutRequested() && !multEstConf.isPassingVtxMultCut(v.getNContributors())) {
           continue; // skip vertex of unwanted multiplicity
         }
         selROF = true;
         vertices.push_back(v);
-        if (mIsMC) {
+        if (mIsMC && !VertexerParamConfig::Instance().useTruthSeeding) {
           allVerticesLabels.push_back(vMCRecInfo[iV].first);
           allVerticesPurities.push_back(vMCRecInfo[iV].second);
         }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index bd9d1402a1ebf..16de3d075ef75 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -36,6 +36,11 @@ Vertexer::Vertexer(VertexerTraits* traits) : mTraits(traits)
 float Vertexer::clustersToVertices(LogFunc logger)
 {
   LogFunc evalLog = [](const std::string&) {};
+
+  if (mTimeFrame->hasMCinformation() && mVertParams[0].useTruthSeeding) {
+    return evaluateTask(&Vertexer::addTruthSeeds, StateNames[mCurState = TruthSeeding], 0, evalLog);
+  }
+
   TrackingParameters trkPars;
   TimeFrameGPUParameters tfGPUpar;
   mTraits->updateVertexingParameters(mVertParams, tfGPUpar);
@@ -58,14 +63,11 @@ float Vertexer::clustersToVertices(LogFunc logger)
       logger(fmt::format("=== ITS {} Seeding vertexer iteration {} summary:", mTraits->getName(), iteration));
       trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
       trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
-      auto timeInitIteration = evaluateTask(
-        &Vertexer::initialiseVertexer, StateNames[mCurState = Init], iteration, evalLog, trkPars, iteration);
-      auto timeTrackletIteration = evaluateTask(
-        &Vertexer::findTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration);
+      auto timeInitIteration = evaluateTask(&Vertexer::initialiseVertexer, StateNames[mCurState = Init], iteration, evalLog, trkPars, iteration);
+      auto timeTrackletIteration = evaluateTask(&Vertexer::findTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration);
       nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
       nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
-      auto timeSelectionIteration = evaluateTask(
-        &Vertexer::validateTracklets, StateNames[mCurState = Validating], iteration, evalLog, iteration);
+      auto timeSelectionIteration = evaluateTask(&Vertexer::validateTracklets, StateNames[mCurState = Validating], iteration, evalLog, iteration);
       auto timeVertexingIteration = evaluateTask(&Vertexer::findVertices, StateNames[mCurState = Finding], iteration, evalLog, iteration);
       printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
       timeInit += timeInitIteration;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index a7487200886e6..a0f044c5f62ca 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -10,10 +10,10 @@
 // or submit itself to any jurisdiction.
 ///
 
-#include <iostream>
 #include <memory>
-#include <string>
-#include <chrono>
+#include <ranges>
+#include <map>
+#include <algorithm>
 
 #include <oneapi/tbb/blocked_range.h>
 #include <oneapi/tbb/parallel_for.h>
@@ -22,6 +22,9 @@
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/ClusterLines.h"
 #include "ITStracking/Tracklet.h"
+#include "SimulationDataFormat/DigitizationContext.h"
+#include "Steer/MCKinematicsReader.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
 
 #ifdef VTX_DEBUG
 #include "TTree.h"
@@ -693,6 +696,59 @@ void VertexerTraits::computeVerticesInRof(int rofId,
   verticesInRof.push_back(foundVertices);
 }
 
+void VertexerTraits::addTruthSeedingVertices()
+{
+  LOGP(info, "Using truth seeds as vertices; will skip computations");
+  mTimeFrame->resetRofPV();
+  const auto dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
+  const auto irs = dc->getEventRecords();
+  int64_t roFrameBiasInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC;
+  int64_t roFrameLengthInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameLengthInBC;
+  o2::steer::MCKinematicsReader mcReader(dc);
+  std::map<int, bounded_vector<Vertex>> vertices;
+  for (int iSrc{0}; iSrc < mcReader.getNSources(); ++iSrc) {
+    auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
+    for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
+      const auto& ir = irs[eveId2colId[iEve]];
+      if (!ir.isDummy()) { // do we need this, is this for diffractive events?
+        const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
+        int rofId = (ir.toLong() - roFrameBiasInBC) / roFrameLengthInBC;
+        if (!vertices.contains(rofId)) {
+          vertices[rofId] = bounded_vector<Vertex>(mMemoryPool.get());
+        }
+        Vertex vert;
+        vert.setTimeStamp(rofId);
+        vert.setNContributors(std::ranges::count_if(mcReader.getTracks(iSrc, iEve), [](const auto& trk) {
+          return trk.isPrimary() && trk.GetPt() > 0.2 && std::abs(trk.GetEta()) < 1.3;
+        }));
+        vert.setXYZ((float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ());
+        vert.setChi2(1);
+        constexpr float cov = 50e-9;
+        vert.setCov(cov, cov, cov, cov, cov, cov);
+        vertices[rofId].push_back(vert);
+      }
+    }
+  }
+  size_t nVerts{0};
+  for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
+    bounded_vector<Vertex> verts(mMemoryPool.get());
+    bounded_vector<std::pair<o2::MCCompLabel, float>> polls(mMemoryPool.get());
+    if (vertices.contains(iROF)) {
+      verts = vertices[iROF];
+      nVerts += verts.size();
+      for (size_t i{0}; i < verts.size(); ++i) {
+        o2::MCCompLabel lbl; // unset label for now
+        polls.emplace_back(lbl, 1.f);
+      }
+    } else {
+      mTimeFrame->getNoVertexROF()++;
+    }
+    mTimeFrame->addPrimaryVertices(verts, iROF, 0);
+    mTimeFrame->addPrimaryVerticesLabels(polls);
+  }
+  LOGP(info, "Found {}/{} ROFs with {} vertices -> <NV>={:.2f}", vertices.size(), mTimeFrame->getNrof(), nVerts, (float)nVerts / (float)vertices.size());
+}
+
 void VertexerTraits::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
 {
 #if defined(VTX_DEBUG)

From 0c0f2b98ef96d31e3f6de4ced5263f0b27d20442 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 14 Jul 2025 09:35:29 +0200
Subject: [PATCH 0614/1764] ITS: Vertexer remove unused code (#14508)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITStracking/VertexerTraits.h      |  16 +-
 .../ITS/tracking/src/VertexerTraits.cxx       | 141 ------------------
 2 files changed, 1 insertion(+), 156 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index a2429fe7270a8..54424136fcfe1 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -73,24 +73,10 @@ class VertexerTraits
   virtual void computeVertices(const int iteration = 0);
   virtual void adoptTimeFrame(TimeFrame7* tf) noexcept { mTimeFrame = tf; }
   virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& gpuTfPar);
+
   // truth tracking
   void addTruthSeedingVertices();
 
-  void computeVerticesInRof(int,
-                            gsl::span<const o2::its::Line>&,
-                            bounded_vector<bool>&,
-                            bounded_vector<o2::its::ClusterLines>&,
-                            std::array<float, 2>&,
-                            bounded_vector<Vertex>&,
-                            bounded_vector<int>&,
-                            TimeFrame7*,
-                            bounded_vector<o2::MCCompLabel>*,
-                            const int iteration = 0);
-
-  bounded_vector<std::pair<int, int>> selectClusters(const int* indexTable,
-                                                     const std::array<int, 4>& selectedBinsRect,
-                                                     const IndexTableUtils& utils);
-
   // utils
   auto& getVertexingParameters() { return mVrtParams; }
   auto getVertexingParameters() const { return mVrtParams; }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index a0f044c5f62ca..bf421a8f8d59d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -144,26 +144,6 @@ void trackletSelectionKernelHost(
   }
 }
 
-bounded_vector<std::pair<int, int>> VertexerTraits::selectClusters(const int* indexTable,
-                                                                   const std::array<int, 4>& selectedBinsRect,
-                                                                   const IndexTableUtils& utils)
-{
-  bounded_vector<std::pair<int, int>> filteredBins{mMemoryPool.get()};
-  int phiBinsNum{selectedBinsRect[3] - selectedBinsRect[1] + 1};
-  if (phiBinsNum < 0) {
-    phiBinsNum += utils.getNphiBins();
-  }
-  filteredBins.reserve(phiBinsNum);
-  for (int iPhiBin{selectedBinsRect[1]}, iPhiCount{0}; iPhiCount < phiBinsNum;
-       iPhiBin = ++iPhiBin == utils.getNphiBins() ? 0 : iPhiBin, iPhiCount++) {
-    const int firstBinIndex{utils.getBinIndex(selectedBinsRect[0], iPhiBin)};
-    filteredBins.emplace_back(
-      indexTable[firstBinIndex],
-      utils.countRowSelectedBins(indexTable, iPhiBin, selectedBinsRect[0], selectedBinsRect[2]));
-  }
-  return filteredBins;
-}
-
 void VertexerTraits::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& tfPar)
 {
   mVrtParams = vrtPar;
@@ -575,127 +555,6 @@ void VertexerTraits::computeVertices(const int iteration)
 #endif
 }
 
-void VertexerTraits::computeVerticesInRof(int rofId,
-                                          gsl::span<const o2::its::Line>& lines,
-                                          bounded_vector<bool>& usedLines,
-                                          bounded_vector<o2::its::ClusterLines>& clusterLines,
-                                          std::array<float, 2>& beamPosXY,
-                                          bounded_vector<Vertex>& vertices,
-                                          bounded_vector<int>& verticesInRof,
-                                          TimeFrame7* tf,
-                                          bounded_vector<o2::MCCompLabel>* labels,
-                                          const int iteration)
-{
-  int foundVertices{0};
-  auto nsigmaCut{std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f)};
-  const int numTracklets{static_cast<int>(lines.size())};
-  for (int line1{0}; line1 < numTracklets; ++line1) {
-    if (usedLines[line1]) {
-      continue;
-    }
-    for (int line2{line1 + 1}; line2 < numTracklets; ++line2) {
-      if (usedLines[line2]) {
-        continue;
-      }
-      auto dca{Line::getDCA(lines[line1], lines[line2])};
-      if (dca < mVrtParams[iteration].pairCut) {
-        clusterLines.emplace_back(line1, lines[line1], line2, lines[line2]);
-        std::array<float, 3> tmpVertex{clusterLines.back().getVertex()};
-        if (tmpVertex[0] * tmpVertex[0] + tmpVertex[1] * tmpVertex[1] > 4.f) {
-          clusterLines.pop_back();
-          break;
-        }
-        usedLines[line1] = true;
-        usedLines[line2] = true;
-        for (int tracklet3{0}; tracklet3 < numTracklets; ++tracklet3) {
-          if (usedLines[tracklet3]) {
-            continue;
-          }
-          if (Line::getDistanceFromPoint(lines[tracklet3], tmpVertex) < mVrtParams[iteration].pairCut) {
-            clusterLines.back().add(tracklet3, lines[tracklet3]);
-            usedLines[tracklet3] = true;
-            tmpVertex = clusterLines.back().getVertex();
-          }
-        }
-        break;
-      }
-    }
-  }
-
-  if (mVrtParams[iteration].allowSingleContribClusters) {
-    auto beamLine = Line{{tf->getBeamX(), tf->getBeamY(), -50.f}, {tf->getBeamX(), tf->getBeamY(), 50.f}}; // use beam position as contributor
-    for (size_t iLine{0}; iLine < numTracklets; ++iLine) {
-      if (!usedLines[iLine]) {
-        auto dca = Line::getDCA(lines[iLine], beamLine);
-        if (dca < mVrtParams[iteration].pairCut) {
-          clusterLines.emplace_back(iLine, lines[iLine], -1, beamLine); // beamline must be passed as second line argument
-        }
-      }
-    }
-  }
-
-  // Cluster merging
-  std::sort(clusterLines.begin(), clusterLines.end(), [](ClusterLines& cluster1, ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); });
-  size_t nClusters{clusterLines.size()};
-  for (int iCluster1{0}; iCluster1 < nClusters; ++iCluster1) {
-    std::array<float, 3> vertex1{clusterLines[iCluster1].getVertex()};
-    std::array<float, 3> vertex2{};
-    for (int iCluster2{iCluster1 + 1}; iCluster2 < nClusters; ++iCluster2) {
-      vertex2 = clusterLines[iCluster2].getVertex();
-      if (o2::gpu::GPUCommonMath::Abs(vertex1[2] - vertex2[2]) < mVrtParams[iteration].clusterCut) {
-        float distance{(vertex1[0] - vertex2[0]) * (vertex1[0] - vertex2[0]) +
-                       (vertex1[1] - vertex2[1]) * (vertex1[1] - vertex2[1]) +
-                       (vertex1[2] - vertex2[2]) * (vertex1[2] - vertex2[2])};
-        if (distance < mVrtParams[iteration].pairCut * mVrtParams[iteration].pairCut) {
-          for (auto label : clusterLines[iCluster2].getLabels()) {
-            clusterLines[iCluster1].add(label, lines[label]);
-            vertex1 = clusterLines[iCluster1].getVertex();
-          }
-          clusterLines.erase(clusterLines.begin() + iCluster2);
-          --iCluster2;
-          --nClusters;
-        }
-      }
-    }
-  }
-
-  std::sort(clusterLines.begin(), clusterLines.end(),
-            [](ClusterLines& cluster1, ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); }); // ensure clusters are ordered by contributors, so that we can cut after the first.
-  bool atLeastOneFound{false};
-  for (int iCluster{0}; iCluster < nClusters; ++iCluster) {
-    bool lowMultCandidate{false};
-    double beamDistance2{(tf->getBeamX() - clusterLines[iCluster].getVertex()[0]) * (tf->getBeamX() - clusterLines[iCluster].getVertex()[0]) +
-                         (tf->getBeamY() - clusterLines[iCluster].getVertex()[1]) * (tf->getBeamY() - clusterLines[iCluster].getVertex()[1])};
-
-    if (atLeastOneFound && (lowMultCandidate = clusterLines[iCluster].getSize() < mVrtParams[iteration].clusterContributorsCut)) { // We might have pile up with nContr > cut.
-      lowMultCandidate &= (beamDistance2 < mVrtParams[iteration].lowMultBeamDistCut * mVrtParams[iteration].lowMultBeamDistCut);
-      if (!lowMultCandidate) { // Not the first cluster and not a low multiplicity candidate, we can remove it
-        clusterLines.erase(clusterLines.begin() + iCluster);
-        nClusters--;
-        continue;
-      }
-    }
-    if (beamDistance2 < nsigmaCut && o2::gpu::GPUCommonMath::Abs(clusterLines[iCluster].getVertex()[2]) < mVrtParams[iteration].maxZPositionAllowed) {
-      atLeastOneFound = true;
-      ++foundVertices;
-      vertices.emplace_back(o2::math_utils::Point3D<float>(clusterLines[iCluster].getVertex()[0],
-                                                           clusterLines[iCluster].getVertex()[1],
-                                                           clusterLines[iCluster].getVertex()[2]),
-                            clusterLines[iCluster].getRMS2(),          // Symm matrix. Diagonal: RMS2 components,
-                                                                       // off-diagonal: square mean of projections on planes.
-                            clusterLines[iCluster].getSize(),          // Contributors
-                            clusterLines[iCluster].getAvgDistance2()); // In place of chi2
-      vertices.back().setTimeStamp(clusterLines[iCluster].getROF());
-      if (labels) {
-        for (auto& index : clusterLines[iCluster].getLabels()) {
-          labels->push_back(tf->getLinesLabel(rofId)[index]); // then we can use nContributors from vertices to get the labels
-        }
-      }
-    }
-  }
-  verticesInRof.push_back(foundVertices);
-}
-
 void VertexerTraits::addTruthSeedingVertices()
 {
   LOGP(info, "Using truth seeds as vertices; will skip computations");

From 6d2c1d30e73406b86f8ccd335ef4b0de87311330 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 14 Jul 2025 09:41:08 +0200
Subject: [PATCH 0615/1764] ITS: opt. vertex cont. output (#14507)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITStracking/Configuration.h       |  1 +
 .../tracking/include/ITStracking/TimeFrame.h  | 20 +++++++++++++++++
 .../include/ITStracking/TrackingConfigParam.h |  3 ++-
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |  1 +
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 22 +++++++++++++++++++
 .../ITS/tracking/src/TrackingInterface.cxx    | 16 +++++++++++++-
 .../ITS/tracking/src/VertexerTraits.cxx       | 10 +++++++++
 .../ITS/workflow/src/TrackWriterSpec.cxx      |  7 ++++++
 .../ITSMFT/ITS/workflow/src/TrackerSpec.cxx   |  1 +
 9 files changed, 79 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 8c46b2e72078a..19c4617426304 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -113,6 +113,7 @@ struct VertexingParameters {
   bool SaveTimeBenchmarks = false;
 
   bool useTruthSeeding = false; // overwrite found vertices with MC events
+  bool outputContLabels = false;
 
   int nThreads = 1;
   bool PrintMemory = false; // print allocator usage in epilog report
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 230a46681385d..9434fc2292750 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -73,15 +73,18 @@ struct TimeFrame {
   gsl::span<const Vertex> getPrimaryVertices(int rofId) const;
   gsl::span<const Vertex> getPrimaryVertices(int romin, int romax) const;
   gsl::span<const std::pair<MCCompLabel, float>> getPrimaryVerticesMCRecInfo(const int rofId) const;
+  gsl::span<const MCCompLabel> getPrimaryVerticesContributors(const int rofId) const;
   gsl::span<const std::array<float, 2>> getPrimaryVerticesXAlpha(int rofId) const;
   void fillPrimaryVerticesXandAlpha();
   int getPrimaryVerticesNum(int rofId = -1) const;
   void addPrimaryVertices(const bounded_vector<Vertex>& vertices);
   void addPrimaryVerticesLabels(bounded_vector<std::pair<MCCompLabel, float>>& labels);
+  void addPrimaryVerticesContributorLabels(bounded_vector<MCCompLabel>& labels);
   void addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration);
   void addPrimaryVertices(const gsl::span<const Vertex>& vertices, const int rofId, const int iteration);
   void addPrimaryVerticesInROF(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration);
   void addPrimaryVerticesLabelsInROF(const bounded_vector<std::pair<MCCompLabel, float>>& labels, const int rofId);
+  void addPrimaryVerticesContributorLabelsInROF(const bounded_vector<MCCompLabel>& labels, const int rofId);
   void removePrimaryVerticesInROf(const int rofId);
   int loadROFrameData(const o2::itsmft::ROFRecord& rof, gsl::span<const itsmft::Cluster> clusters,
                       const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
@@ -342,6 +345,7 @@ struct TimeFrame {
   std::array<bounded_vector<int>, 2> mTrackletsIndexROF;
   std::vector<bounded_vector<MCCompLabel>> mLinesLabels;
   std::vector<std::pair<MCCompLabel, float>> mVerticesMCRecInfo;
+  bounded_vector<MCCompLabel> mVerticesContributorLabels;
   std::array<uint32_t, 2> mTotalTracklets = {0, 0};
   unsigned int mNoVertexROF = 0;
   bounded_vector<int> mTotVertPerIteration;
@@ -371,6 +375,22 @@ inline gsl::span<const std::pair<MCCompLabel, float>> TimeFrame<nLayers>::getPri
   return {&(mVerticesMCRecInfo[start]), static_cast<gsl::span<const std::pair<MCCompLabel, float>>::size_type>(delta)};
 }
 
+template <int nLayers>
+inline gsl::span<const MCCompLabel> TimeFrame<nLayers>::getPrimaryVerticesContributors(const int rofId) const
+{
+  // count the number of cont. in rofs before target rof
+  unsigned int start{0}, delta{0};
+  const auto& pvsBefore = getPrimaryVertices(0, rofId - 1);
+  for (const auto& pv : pvsBefore) {
+    start += pv.getNContributors();
+  }
+  const auto& pvsIn = getPrimaryVertices(rofId);
+  for (const auto& pv : pvsIn) {
+    delta += pv.getNContributors();
+  }
+  return {&(mVerticesContributorLabels[start]), static_cast<gsl::span<const MCCompLabel>::size_type>(delta)};
+}
+
 template <int nLayers>
 inline gsl::span<const Vertex> TimeFrame<nLayers>::getPrimaryVertices(int romin, int romax) const
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 8de80d5e4cd07..dacc2019356f4 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -48,7 +48,8 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   int ZBins = 1;     // z-phi index table configutation: number of z bins
   int PhiBins = 128; // z-phi index table configutation: number of phi bins
 
-  bool useTruthSeeding{false}; // overwrite seeding vertices with MC truth
+  bool useTruthSeeding{false};  // overwrite seeding vertices with MC truth
+  bool outputContLabels{false}; // output additioanlly for each vertex its contributing line labels
 
   int nThreads = 1;
   bool printMemory = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 1c2857413789b..f19ceb55c52b3 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -284,6 +284,7 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
     p.PhiBins = vc.PhiBins;
 
     p.useTruthSeeding = vc.useTruthSeeding;
+    p.outputContLabels = vc.outputContLabels;
   }
   // set for now outside to not disturb status quo
   vertParams[0].vertNsigmaCut = vc.vertNsigmaCut;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 9c683112791ab..ea57e5fa8e3b9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -85,6 +85,12 @@ void TimeFrame<nLayers>::addPrimaryVerticesLabels(bounded_vector<std::pair<MCCom
   mVerticesMCRecInfo.insert(mVerticesMCRecInfo.end(), labels.begin(), labels.end());
 }
 
+template <int nLayers>
+void TimeFrame<nLayers>::addPrimaryVerticesContributorLabels(bounded_vector<MCCompLabel>& labels)
+{
+  mVerticesContributorLabels.insert(mVerticesContributorLabels.end(), labels.begin(), labels.end());
+}
+
 template <int nLayers>
 void TimeFrame<nLayers>::addPrimaryVerticesInROF(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration)
 {
@@ -101,6 +107,18 @@ void TimeFrame<nLayers>::addPrimaryVerticesLabelsInROF(const bounded_vector<std:
   mVerticesMCRecInfo.insert(mVerticesMCRecInfo.begin() + mROFramesPV[rofId], labels.begin(), labels.end());
 }
 
+template <int nLayers>
+void TimeFrame<nLayers>::addPrimaryVerticesContributorLabelsInROF(const bounded_vector<MCCompLabel>& labels, const int rofId)
+{
+  // count the number of cont. in rofs before and including the target rof
+  unsigned int n{0};
+  const auto& pvs = getPrimaryVertices(0, rofId);
+  for (const auto& pv : pvs) {
+    n += pv.getNContributors();
+  }
+  mVerticesContributorLabels.insert(mVerticesContributorLabels.begin() + n, labels.begin(), labels.end());
+}
+
 template <int nLayers>
 void TimeFrame<nLayers>::addPrimaryVertices(const gsl::span<const Vertex>& vertices, const int rofId, const int iteration)
 {
@@ -295,6 +313,7 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     deepVectorClear(mLinesLabels);
     if (resetVertices) {
       deepVectorClear(mVerticesMCRecInfo);
+      deepVectorClear(mVerticesContributorLabels);
     }
     clearResizeBoundedVector(mTracks, mNrof, mMemoryPool.get());
     clearResizeBoundedVector(mTracksLabel, mNrof, mMemoryPool.get());
@@ -646,6 +665,7 @@ void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource>& p
   initVector(mClusterSize);
   initVector(mPValphaX);
   initVector(mBogusClusters);
+  initVector(mVerticesContributorLabels);
   initArrays(mTrackletsIndexROF);
   initVectors(mTracks);
   initVectors(mTracklets);
@@ -689,6 +709,8 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mBogusClusters);
   deepVectorClear(mTrackletsIndexROF);
   deepVectorClear(mPrimaryVertices);
+  deepVectorClear(mTrackletClusters);
+  deepVectorClear(mVerticesContributorLabels);
 }
 
 template class TimeFrame<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 31dc68d03a7e8..f5fa195983240 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -117,6 +117,8 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   static pmr::vector<float> dummyMCPurVerts;
   auto& allTrackLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "TRACKSMCTR", 0}) : dummyMCLabTracks;
   auto& allVerticesLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTR", 0}) : dummyMCLabVerts;
+  bool writeContLabels = mIsMC && o2::its::VertexerParamConfig::Instance().outputContLabels;
+  auto& allVerticesContLabels = writeContLabels ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTRCONT", 0}) : dummyMCLabVerts;
   auto& allVerticesPurities = mIsMC ? pc.outputs().make<std::vector<float>>(Output{"ITS", "VERTICESMCPUR", 0}) : dummyMCPurVerts;
 
   std::uint32_t roFrame = 0;
@@ -159,6 +161,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   }
   const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
   gsl::span<const std::pair<MCCompLabel, float>> vMCRecInfo;
+  gsl::span<const MCCompLabel> vMCContLabels;
   for (auto iRof{0}; iRof < trackROFspan.size(); ++iRof) {
     std::vector<Vertex> vtxVecLoc;
     auto& vtxROF = vertROFvec.emplace_back(trackROFspan[iRof]);
@@ -167,6 +170,9 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       auto vtxSpan = mTimeFrame->getPrimaryVertices(iRof);
       if (mIsMC) {
         vMCRecInfo = mTimeFrame->getPrimaryVerticesMCRecInfo(iRof);
+        if (o2::its::VertexerParamConfig::Instance().outputContLabels) {
+          vMCContLabels = mTimeFrame->getPrimaryVerticesContributors(iRof);
+        }
       }
       if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
         if (!vtxSpan.empty()) {
@@ -186,9 +192,10 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       }
       vtxROF.setNEntries(vtxSpan.size());
       bool selROF = vtxSpan.empty();
-      for (auto iV{0}; iV < vtxSpan.size(); ++iV) {
+      for (int iV{0}, iVC{0}; iV < vtxSpan.size(); ++iV) {
         const auto& v = vtxSpan[iV];
         if (multEstConf.isVtxMultCutRequested() && !multEstConf.isPassingVtxMultCut(v.getNContributors())) {
+          iVC += v.getNContributors();
           continue; // skip vertex of unwanted multiplicity
         }
         selROF = true;
@@ -196,7 +203,11 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
         if (mIsMC && !VertexerParamConfig::Instance().useTruthSeeding) {
           allVerticesLabels.push_back(vMCRecInfo[iV].first);
           allVerticesPurities.push_back(vMCRecInfo[iV].second);
+          if (o2::its::VertexerParamConfig::Instance().outputContLabels) {
+            allVerticesContLabels.insert(allVerticesContLabels.end(), vMCContLabels.begin() + iVC, vMCContLabels.begin() + iVC + v.getNContributors());
+          }
         }
+        iVC += v.getNContributors();
       }
       if (processingMask[iRof] && !selROF) { // passed selection in clusters and not in vertex multiplicity
         LOGP(info, "ROF {} rejected by the vertex multiplicity selection [{},{}]", iRof, multEstConf.cutMultVtxLow, multEstConf.cutMultVtxHigh);
@@ -291,6 +302,9 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     if (mIsMC) {
       LOGP(info, "ITSTracker pushed {} track labels", allTrackLabels.size());
       LOGP(info, "ITSTracker pushed {} vertex labels", allVerticesLabels.size());
+      if (!allVerticesContLabels.empty()) {
+        LOGP(info, "ITSTracker pushed {} vertex contributor labels", allVerticesContLabels.size());
+      }
       LOGP(info, "ITSTracker pushed {} vertex purities", allVerticesPurities.size());
     }
   }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index bf421a8f8d59d..409ce8895aa36 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -388,6 +388,7 @@ void VertexerTraits::computeVertices(const int iteration)
   auto nsigmaCut{std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f)};
   bounded_vector<Vertex> vertices(mMemoryPool.get());
   bounded_vector<std::pair<o2::MCCompLabel, float>> polls(mMemoryPool.get());
+  bounded_vector<o2::MCCompLabel> contLabels(mMemoryPool.get());
 #ifdef VTX_DEBUG
   std::vector<std::vector<ClusterLines>> dbg_clusLines(mTimeFrame->getNrof());
 #endif
@@ -511,6 +512,9 @@ void VertexerTraits::computeVertices(const int iteration)
             labels.push_back(mTimeFrame->getLinesLabel(rofId)[index]); // then we can use nContributors from vertices to get the labels
           }
           polls.push_back(computeMain(labels));
+          if (mVrtParams[iteration].outputContLabels) {
+            contLabels.insert(contLabels.end(), labels.begin(), labels.end());
+          }
         }
       }
     }
@@ -518,11 +522,17 @@ void VertexerTraits::computeVertices(const int iteration)
       mTimeFrame->addPrimaryVertices(vertices, rofId, iteration);
       if (mTimeFrame->hasMCinformation()) {
         mTimeFrame->addPrimaryVerticesLabels(polls);
+        if (mVrtParams[iteration].outputContLabels) {
+          mTimeFrame->addPrimaryVerticesContributorLabels(contLabels);
+        }
       }
     } else {
       mTimeFrame->addPrimaryVerticesInROF(vertices, rofId, iteration);
       if (mTimeFrame->hasMCinformation()) {
         mTimeFrame->addPrimaryVerticesLabelsInROF(polls, rofId);
+        if (mVrtParams[iteration].outputContLabels) {
+          mTimeFrame->addPrimaryVerticesContributorLabelsInROF(contLabels, rofId);
+        }
       }
     }
     if (vertices.empty() && !(iteration && (int)mTimeFrame->getPrimaryVertices(rofId).size() > mVrtParams[iteration].vertPerRofThreshold)) {
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
index 5cb6aa199ab64..9fbb138b376b2 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
@@ -20,6 +20,7 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "ReconstructionDataFormats/Vertex.h"
+#include "ITStracking/TrackingConfigParam.h"
 
 using namespace o2::framework;
 
@@ -39,6 +40,7 @@ DataProcessorSpec getTrackWriterSpec(bool useMC)
 {
   // Spectators for logging
   // this is only to restore the original behavior
+  const auto writeContLabels = VertexerParamConfig::Instance().outputContLabels && useMC;
   auto tracksSize = std::make_shared<int>(0);
   auto tracksSizeGetter = [tracksSize](std::vector<o2::its::TrackITS> const& tracks) {
     *tracksSize = tracks.size();
@@ -69,6 +71,11 @@ DataProcessorSpec getTrackWriterSpec(bool useMC)
                                                              "ITSVertexMCTruth",
                                                              (useMC ? 1 : 0), // one branch if mc labels enabled
                                                              ""},
+                                BranchDefinition<LabelsType>{InputSpec{"labelsVerticesContributors", "ITS", "VERTICESMCTRCONT", 0},
+                                                             "ITSVertexMCTruthCont",
+                                                             (writeContLabels ? 1 : 0), // one branch if
+                                                                                        // requested
+                                                             ""},
                                 BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", "ITS", "ITSTrackMC2ROF", 0},
                                                              "ITSTracksMC2ROF",
                                                              (useMC ? 1 : 0), // one branch if mc labels enabled
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index fedc42c017f7e..c8a785b6a3627 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -120,6 +120,7 @@ DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, Tracking
     inputs.emplace_back("itsmclabels", "ITS", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
     inputs.emplace_back("ITSMC2ROframes", "ITS", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "VERTICESMCTR", 0, Lifetime::Timeframe);
+    outputs.emplace_back("ITS", "VERTICESMCTRCONT", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "VERTICESMCPUR", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "TRACKSMCTR", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "ITSTrackMC2ROF", 0, Lifetime::Timeframe);

From 3c7f5313b86998ce2774f40a2ddd7f82e01d05ec Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 1 Jul 2025 15:25:53 +0200
Subject: [PATCH 0616/1764] ITS: allow overriding number of iterations for
 tracker

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/include/ITStracking/TrackingConfigParam.h    | 1 +
 Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx           | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index dacc2019356f4..ef6f925f1c29f 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -95,6 +95,7 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   bool overrideBeamEstimation = false;     // use beam position from meanVertex CCDB object
   int trackingMode = -1;                   // -1: unset, 0=sync, 1=async, 2=cosmics used by gpuwf only
   bool doUPCIteration = false;             // Perform an additional iteration for UPC events on tagged vertices. You want to combine this config with VertexerParamConfig.nIterations=2
+  int nIterations = MaxIter;               // overwrite the number of iterations
 
   int nThreads = 1;
   bool printMemory = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index f19ceb55c52b3..6b2d80424b5bb 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -245,6 +245,10 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     }
   }
 
+  if (trackParams.size() > tc.nIterations) {
+    trackParams.resize(tc.nIterations);
+  }
+
   return trackParams;
 }
 

From 30b301e4c44f2cb50ae6ef626cedbaaf5ee0ec88 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 4 Jul 2025 09:46:20 +0200
Subject: [PATCH 0617/1764] ITS: disable reco via configParams

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/workflow/src/RecoWorkflow.cxx  | 41 ++++++++-----------
 1 file changed, 17 insertions(+), 24 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index a72c26a3681e1..948d2c1b53009 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -17,21 +17,15 @@
 #include "ITSWorkflow/TrackerSpec.h"
 #include "ITSWorkflow/CookedTrackerSpec.h"
 #include "ITSWorkflow/TrackWriterSpec.h"
+#include "ITStracking/TrackingConfigParam.h"
 #include "ITSMFTWorkflow/DigitReaderSpec.h"
 #include "GlobalTrackingWorkflowWriters/IRFrameWriterSpec.h"
 #include "GPUWorkflow/GPUWorkflowSpec.h"
 #include "Framework/CCDBParamSpec.h"
 
 // Dummy TPC completion policy data
-using CompletionPolicyData = std::vector<InputSpec>;
-static CompletionPolicyData gPolicyData;
-static std::shared_ptr<o2::gpu::GPURecoWorkflowSpec> gTask;
 
-namespace o2
-{
-namespace its
-{
-namespace reco_workflow
+namespace o2::its::reco_workflow
 {
 
 framework::WorkflowSpec getWorkflow(bool useMC,
@@ -56,14 +50,15 @@ framework::WorkflowSpec getWorkflow(bool useMC,
   if (!disableRootOutput) {
     specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
   }
-  if (trmode != TrackingMode::Off) {
+  if ((trmode != TrackingMode::Off) && (TrackerParamConfig::Instance().trackingMode != TrackingMode::Off)) {
     if (useCAtracker) {
       if (useGPUWF) {
-        o2::gpu::GPURecoWorkflowSpec::Config cfg;
-        cfg.runITSTracking = true;
-        cfg.itsTriggerType = useTrig;
-        cfg.itsOverrBeamEst = overrideBeamPosition;
-        cfg.processMC = useMC;
+        o2::gpu::GPURecoWorkflowSpec::Config cfg{
+          .itsTriggerType = useTrig,
+          .processMC = useMC,
+          .runITSTracking = true,
+          .itsOverrBeamEst = overrideBeamPosition,
+        };
 
         Inputs ggInputs;
         auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true,
@@ -73,18 +68,18 @@ framework::WorkflowSpec getWorkflow(bool useMC,
           ggRequest->addInput({"itsTGeo", "ITS", "GEOMTGEO", 0, Lifetime::Condition, framework::ccdbParamSpec("ITS/Config/Geometry")}, ggInputs);
         }
 
-        auto task = std::make_shared<o2::gpu::GPURecoWorkflowSpec>(&gPolicyData, cfg, std::vector<int>(), 0, ggRequest);
-        gTask = task;
+        static std::vector<InputSpec> policyData;
+        static std::shared_ptr<o2::gpu::GPURecoWorkflowSpec> task = std::make_shared<o2::gpu::GPURecoWorkflowSpec>(&policyData, cfg, std::vector<int>(), 0, ggRequest);
         Inputs taskInputs = task->inputs();
         Options taskOptions = task->options();
         std::move(ggInputs.begin(), ggInputs.end(), std::back_inserter(taskInputs));
 
         specs.emplace_back(DataProcessorSpec{
-          "its-gpu-tracker",
-          taskInputs,
-          task->outputs(),
-          AlgorithmSpec{adoptTask<o2::gpu::GPURecoWorkflowSpec>(task)},
-          taskOptions});
+          .name = "its-gpu-tracker",
+          .inputs = taskInputs,
+          .outputs = task->outputs(),
+          .algorithm = AlgorithmSpec{adoptTask<o2::gpu::GPURecoWorkflowSpec>(task)},
+          .options = taskOptions});
       } else {
         specs.emplace_back(o2::its::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
       }
@@ -99,6 +94,4 @@ framework::WorkflowSpec getWorkflow(bool useMC,
   return specs;
 }
 
-} // namespace reco_workflow
-} // namespace its
-} // namespace o2
+} // namespace o2::its::reco_workflow

From 5b80babd7f2d5abe97c585e0c5085a05d90c1e62 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Tue, 15 Jul 2025 19:49:12 +0800
Subject: [PATCH 0618/1764] Add missing TPCNClsPID dynamic columns (#14503)

When the data member was inserted, we forgot to add the corresponding dynamic column in the table.
---
 Framework/Core/include/Framework/AnalysisDataModel.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index e34b8210a0178..2a9e1b61ee6df 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -621,6 +621,7 @@ DECLARE_SOA_TABLE_FULL_VERSIONED(StoredTracksExtra_002, "TracksExtra", "AOD", "T
                                  track::HasITS<track::v001::DetectorMap>, track::HasTPC<track::v001::DetectorMap>,
                                  track::HasTRD<track::v001::DetectorMap>, track::HasTOF<track::v001::DetectorMap>,
                                  track::TPCNClsFound<track::TPCNClsFindable, track::TPCNClsFindableMinusFound>,
+                                 track::TPCNClsPID<track::TPCNClsFindable, track::TPCNClsFindableMinusPID>,
                                  track::TPCNClsCrossedRows<track::TPCNClsFindable, track::TPCNClsFindableMinusCrossedRows>,
                                  track::v001::ITSClusterMap<track::ITSClusterSizes>, track::v001::ITSNCls<track::ITSClusterSizes>, track::v001::ITSNClsInnerBarrel<track::ITSClusterSizes>,
                                  track::v001::ITSClsSizeInLayer<track::ITSClusterSizes>,

From 0c69826c1eddc7c295e0b13421fb5b3be8a37fc3 Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Sat, 12 Jul 2025 17:31:26 +0200
Subject: [PATCH 0619/1764] HepMC: Remove default backgrounding mode

Removing the default & at the end of HepMC child processes.
This should not be needed and actually leads to children be executed
outside of the process tree of simulation. This in turn corrupts
CPU and MEM monitoring in O2DPG MC workflows.

Changing default for now but maybe we can eventually get rid of this completely.
---
 Generators/include/Generators/GeneratorFileOrCmdParam.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Generators/include/Generators/GeneratorFileOrCmdParam.h b/Generators/include/Generators/GeneratorFileOrCmdParam.h
index d4023d01e6ac2..72bc3d00141fe 100644
--- a/Generators/include/Generators/GeneratorFileOrCmdParam.h
+++ b/Generators/include/Generators/GeneratorFileOrCmdParam.h
@@ -35,7 +35,7 @@ struct GeneratorFileOrCmdParam : public o2::conf::ConfigurableParamHelper<Genera
   std::string seedSwitch = "-s";
   std::string bMaxSwitch = "-b";
   std::string nEventsSwitch = "-n";
-  std::string backgroundSwitch = "&";
+  std::string backgroundSwitch = ""; // SW: might not be relevant at all since we launch inside fork+exec
   O2ParamDef(GeneratorFileOrCmdParam, "GeneratorFileOrCmd");
 };
 

From 38e8f24bab35aa3c3d41ccb41026a6df9d5f4717 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 15 Jul 2025 15:18:45 +0200
Subject: [PATCH 0620/1764] DPL: drop unneeded headers.

---
 Framework/Core/src/AODReaderHelpers.cxx | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index 4dbd2877476be..ba68cbf15a6e9 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -10,29 +10,21 @@
 // or submit itself to any jurisdiction.
 
 #include "Framework/AODReaderHelpers.h"
-#include "Framework/TableTreeHelpers.h"
 #include "Framework/AnalysisHelpers.h"
 #include "Framework/AnalysisDataModelHelpers.h"
 #include "Framework/DataProcessingHelpers.h"
 #include "Framework/ExpressionHelpers.h"
 #include "Framework/AlgorithmSpec.h"
-#include "Framework/ConfigParamRegistry.h"
 #include "Framework/ControlService.h"
 #include "Framework/CallbackService.h"
 #include "Framework/EndOfStreamContext.h"
-#include "Framework/DeviceSpec.h"
-#include "Framework/RawDeviceService.h"
 #include "Framework/DataSpecUtils.h"
-#include "Framework/SourceInfoHeader.h"
-#include "Framework/ChannelInfo.h"
-#include "Framework/Logger.h"
 
 #include <Monitoring/Monitoring.h>
 
 #include <TGrid.h>
 #include <TFile.h>
 #include <TTreeCache.h>
-#include <TTreePerfStats.h>
 
 #include <arrow/ipc/reader.h>
 #include <arrow/ipc/writer.h>
@@ -40,8 +32,6 @@
 #include <arrow/table.h>
 #include <arrow/util/key_value_metadata.h>
 
-#include <thread>
-
 namespace o2::framework::readers
 {
 auto setEOSCallback(InitContext& ic)

From 36f656bafe7cf6e496d3dd7f84959636d228e211 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 16 Jul 2025 00:53:33 +0200
Subject: [PATCH 0621/1764] Add LIGHTNUCLEI flag, extend pp settings on
 BEAMTYPE leading to LIGHTNUCLEI=1

---
 prodtests/full-system-test/dpl-workflow.sh | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 202352730ddc7..ed9a230670c02 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -29,6 +29,8 @@ fi
 : ${CTF_FREE_DISK_WAIT:="10"}         # if disk on EPNs is close to full, wait X seconds before retrying to write
 : ${CTF_MAX_FREE_DISK_WAIT:="600"}    # if not enough disk space after this time throw error
 
+[[ -z ${LIGHTNUCLEI:-} ]] && export LIGHTNUCLEI="0" # temporarily, in case O2DPG is not synced yet to the version knowing LIGHTNUCLEI
+
 # entropy encoding/decoding mode, '' is equivalent to '--ans-version compat' (compatible with < 09/2023 data),
 # use '--ans-version 1.0 --ctf-dict none' for the new per-TF dictionary mode
 : ${RANS_OPT:="--ans-version 1.0 --ctf-dict none"}
@@ -118,7 +120,7 @@ if [[ $SYNCMODE == 1 ]]; then
     ITS_CONFIG_KEY+="fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:-100};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:-200};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:-20};"
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=50000;MCHTracking.maxTrackingDuration=20;"
     MFT_CONFIG_KEY+="MFTTracking.cutMultClusLow=0;MFTTracking.cutMultClusHigh=20000;"
-  elif [[ $BEAMTYPE == "pp" ]]; then
+  elif [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then
     ITS_CONFIG_KEY+="fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:--1};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:--1};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:--1};ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;"
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=20000;MCHTracking.maxTrackingDuration=10;"
     MFT_CONFIG_KEY+="MFTTracking.cutMultClusLow=0;MFTTracking.cutMultClusHigh=3000;"
@@ -147,7 +149,7 @@ if [[ $SYNCMODE == 1 ]]; then
   has_detector ITS && TRD_FILTER_CONFIG+=" --filter-trigrec"
 else
   has_detectors_gpu TPC ITS && ITS_CONFIG_KEY+="ITSCATrackerParam.trackingMode=1;" # sets ITS gpu reco to async
-  if [[ $BEAMTYPE == "pp" ]]; then
+  if [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then
     ITS_CONFIG_KEY+="ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;"
   elif [[ $BEAMTYPE == "PbPb" ]]; then
     ITS_CONFIG_KEY+="ITSVertexerParam.lowMultBeamDistCut=0;"
@@ -169,6 +171,8 @@ if [[ $BEAMTYPE == "PbPb" ]]; then
   INTERACTION_TAG_CONFIG_KEY="ft0tag.minAmplitudeA=${INT_TAG_FT0A:-5};ft0tag.minAmplitudeC=${INT_TAG_FT0C:-5};ft0tag.minAmplitudeAC=${INT_TAG_FT0AC:-20};"
 elif [[ $BEAMTYPE == "pp" ]]; then
   PVERTEXING_CONFIG_KEY+="pvertexer.maxChi2TZDebris=10;"
+elif [[ $LIGHTNUCLEI == "1" ]]; then
+  PVERTEXING_CONFIG_KEY+="pvertexer.maxChi2TZDebris=100;"
 fi
 
 if [[ $BEAMTYPE == "cosmic" ]]; then
@@ -360,7 +364,7 @@ if has_processing_step MUON_SYNC_RECO; then
   [[ -z ${ARGS_EXTRA_PROCESS_o2_mch_reco_workflow:-} ]] && ARGS_EXTRA_PROCESS_o2_mch_reco_workflow="--digits"
   if [[ $IS_SIMULATED_DATA == 1 ]]; then
     MCH_CONFIG_KEY+="MCHTimeClusterizer.peakSearchSignalOnly=false;MCHDigitFilter.rejectBackground=false;"
-  elif [[ $RUNTYPE == "PHYSICS" && $BEAMTYPE == "pp" ]] || [[ $RUNTYPE == "COSMICS" ]]; then
+  elif [[ $RUNTYPE == "PHYSICS" && $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]] || [[ $RUNTYPE == "COSMICS" ]]; then
     MCH_CONFIG_KEY+="MCHTracking.chamberResolutionX=0.4;MCHTracking.chamberResolutionY=0.4;MCHTracking.sigmaCutForTracking=7.;MCHTracking.sigmaCutForImprovement=6.;"
   fi
   has_detector_reco ITS && [[ $RUNTYPE != "COSMICS" ]] && MCH_CONFIG_KEY+="MCHTimeClusterizer.irFramesOnly=true;"

From 664d682cbd5d7edc89a46a878c7b46b21888a6a8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 16 Jul 2025 17:46:11 +0200
Subject: [PATCH 0622/1764] dpl-workflow: Fix logic to mlock shm segments

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index ed9a230670c02..486be1a9160cd 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -48,7 +48,7 @@ source $GEN_TOPO_MYDIR/getCommonArgs.sh || { echo "getCommonArgs.sh failed" 1>&2
 workflow_has_parameter CALIB && { source $O2DPG_ROOT/DATA/common/setenv_calib.sh; [[ $? != 0 ]] && echo "setenv_calib.sh failed" 1>&2 && exit 1; }
 
 [[ -z ${SHM_MANAGER_SHMID:-} ]] && ( [[ $EXTINPUT == 1 ]] || [[ $NUMAGPUIDS != 0 ]] ) && ARGS_ALL+=" --no-cleanup"
-[[ $GPUTYPE != "CPU" || ( ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} && -z ${SETENV_NO_ULIMIT:-} ) ]] && ARGS_ALL+=" --shm-mlock-segment-on-creation 1"
+[[ ( $GPUTYPE != "CPU" || -n ${OPTIMIZED_PARALLEL_ASYNC:-} ) && ${SETENV_NO_ULIMIT:-0} == 0 ]] && ARGS_ALL+=" --shm-mlock-segment-on-creation 1"
 if [[ $EPNSYNCMODE == 1 ]] || type numactl >/dev/null 2>&1 && [[ `numactl -H | grep "node . size" | wc -l` -ge 2 ]]; then
   [[ $NUMAGPUIDS != 0 ]] && ARGS_ALL+=" --child-driver 'numactl --membind $NUMAID --cpunodebind $NUMAID'"
 fi

From 92375f9f0b675e4ba21426e524635fd633dd7214 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 16 Jul 2025 16:40:05 +0200
Subject: [PATCH 0623/1764] Extend run-time-span-file and
 invert-irframe-selection TF selections to raw-tf-reader

---
 Detectors/CTF/workflow/src/CTFReaderSpec.cxx  |   6 +-
 Detectors/Raw/TFReaderDD/CMakeLists.txt       |   1 +
 Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx | 142 +++++++++++++++++-
 Detectors/Raw/TFReaderDD/src/TFReaderSpec.h   |   2 +
 .../Raw/TFReaderDD/src/tf-reader-workflow.cxx |   5 +-
 5 files changed, 147 insertions(+), 9 deletions(-)

diff --git a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
index e502b88611a3c..3810230637e5f 100644
--- a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
+++ b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
@@ -112,7 +112,7 @@ class CTFReaderSpec : public o2::framework::Task
   int mCTFCounterAcc = 0;
   int mNFailedFiles = 0;
   int mFilesRead = 0;
-  int mTFLength = 128;
+  int mTFLength = 32;
   int mNWaits = 0;
   int mRunNumberPrev = -1;
   long mTotalWaitTime = 0;
@@ -234,7 +234,7 @@ void CTFReaderSpec::loadRunTimeSpans(const std::string& flname)
 {
   std::ifstream inputFile(flname);
   if (!inputFile) {
-    LOGP(fatal, "Failed to open selected run/timespans file {}", mInput.fileRunTimeSpans);
+    LOGP(fatal, "Failed to open selected run/timespans file {}", flname);
   }
   std::string line;
   size_t cntl = 0, cntr = 0;
@@ -286,7 +286,7 @@ void CTFReaderSpec::loadRunTimeSpans(const std::string& flname)
       logError();
     }
   }
-  LOGP(info, "Read {} time-spans for {} runs from {}", cntr, mRunTimeRanges.size(), mInput.fileRunTimeSpans);
+  LOGP(info, "Read {} time-spans for {} runs from {}", cntr, mRunTimeRanges.size(), flname);
   inputFile.close();
 }
 
diff --git a/Detectors/Raw/TFReaderDD/CMakeLists.txt b/Detectors/Raw/TFReaderDD/CMakeLists.txt
index e58f0d50115f7..12ecc9ca8795d 100644
--- a/Detectors/Raw/TFReaderDD/CMakeLists.txt
+++ b/Detectors/Raw/TFReaderDD/CMakeLists.txt
@@ -16,6 +16,7 @@ o2_add_library(TFReaderDD
                                      O2::Headers
                                      O2::Framework
                                      O2::DetectorsRaw
+                                     O2::DataFormatsParameters
                                      O2::CommonUtils
                                      O2::Algorithm
                                      FairMQ::FairMQ)
diff --git a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
index 07a62a7fd4a58..f4cd64377034e 100644
--- a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
+++ b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
@@ -31,8 +31,14 @@
 #include "TFReaderSpec.h"
 #include "TFReaderDD/SubTimeFrameFileReader.h"
 #include "TFReaderDD/SubTimeFrameFile.h"
+#include "CommonUtils/StringUtils.h"
 #include "CommonUtils/FileFetcher.h"
 #include "CommonUtils/FIFO.h"
+#include "CommonUtils/IRFrameSelector.h"
+#include "DataFormatsParameters/AggregatedRunInfo.h"
+#include "CCDB/BasicCCDBManager.h"
+#include "CommonConstants/LHCConstants.h"
+#include "Algorithm/RangeTokenizer.h"
 #include <unistd.h>
 #include <algorithm>
 #include <unordered_map>
@@ -66,6 +72,8 @@ class TFReaderSpec : public o2f::Task
   void endOfStream(o2f::EndOfStreamContext& ec) final;
 
  private:
+  void loadRunTimeSpans(const std::string& flname);
+  void runTimeRangesToIRFrameSelector(int runNumber);
   void stopProcessing(o2f::ProcessingContext& ctx);
   void TFBuilder();
 
@@ -76,9 +84,13 @@ class TFReaderSpec : public o2f::Task
   o2::utils::FIFO<std::unique_ptr<TFMap>> mTFQueue{}; // queued TFs
   //  std::unordered_map<o2h::DataIdentifier, SubSpecCount, std::hash<o2h::DataIdentifier>> mSeenOutputMap;
   std::unordered_map<o2h::DataIdentifier, SubSpecCount> mSeenOutputMap;
+  std::map<int, std::vector<std::pair<long, long>>> mRunTimeRanges;
+  o2::utils::IRFrameSelector mIRFrameSelector; // optional IR frames selector
+  int mConvRunTimeRangesToOrbits = -1;         // not defined yet
   int mTFCounter = 0;
   int mTFBuilderCounter = 0;
   int mNWaits = 0;
+  int mTFLength = 32;
   long mTotalWaitTime = 0;
   size_t mSelIDEntry = 0; // next TFID to select from the mInput.tfIDs (if non-empty)
   bool mRunning = false;
@@ -105,6 +117,9 @@ void TFReaderSpec::init(o2f::InitContext& ic)
   mInput.maxTFsPerFile = mInput.maxTFsPerFile > 0 ? mInput.maxTFsPerFile : 0x7fffffff;
   mInput.maxTFCache = std::max(1, ic.options().get<int>("max-cached-tf"));
   mInput.maxFileCache = std::max(1, ic.options().get<int>("max-cached-files"));
+  if (!mInput.fileRunTimeSpans.empty()) {
+    loadRunTimeSpans(mInput.fileRunTimeSpans);
+  }
   mFileFetcher = std::make_unique<o2::utils::FileFetcher>(mInput.inpdata, mInput.tffileRegex, mInput.remoteRegex, mInput.copyCmd);
   mFileFetcher->setMaxFilesInQueue(mInput.maxFileCache);
   mFileFetcher->setMaxLoops(mInput.maxLoops);
@@ -142,10 +157,6 @@ void TFReaderSpec::run(o2f::ProcessingContext& ctx)
       if (verbose && mInput.verbosity > 0) {
         LOGP(info, "Acknowledge: part {}/{} {}/{}/{:#x} size:{} split {}/{}", ip, np, hd->dataOrigin.as<std::string>(), hd->dataDescription.as<std::string>(), hd->subSpecification, msgh.GetSize() + parts[ip + 1].GetSize(), hd->splitPayloadIndex, hd->splitPayloadParts);
       }
-      if (dph->startTime != this->mTFCounter) {
-        LOGP(fatal, "Local tf counter {} != TF timeslice {} for {}", this->mTFCounter, dph->startTime,
-             o2::framework::DataSpecUtils::describe(o2::framework::OutputSpec{hd->dataOrigin, hd->dataDescription, hd->subSpecification}));
-      }
       if (hd->splitPayloadIndex == 0) { // check the 1st one only
         auto& entry = this->mSeenOutputMap[{hd->dataDescription.str, hd->dataOrigin.str}];
         if (entry.count != this->mTFCounter) {
@@ -412,8 +423,25 @@ void TFReaderSpec::TFBuilder()
         auto tf = reader.read(mDevice, mOutputRoutes, mInput.rawChannelConfig, mSelIDEntry, mInput.sup0xccdb, mInput.verbosity);
         bool acceptTF = true;
         if (tf) {
+          if (mRunTimeRanges.size()) {
+            const auto* dataptr = (*tf->begin()->second.get())[0].GetData();
+            const auto* hd0 = o2h::get<o2h::DataHeader*>(dataptr);
+            static int runNumberPrev = -1;
+            if (runNumberPrev != hd0->runNumber) {
+              runNumberPrev = hd0->runNumber;
+              runTimeRangesToIRFrameSelector(runNumberPrev);
+            }
+            if (mIRFrameSelector.isSet()) {
+              o2::InteractionRecord ir0(0, hd0->firstTForbit);
+              o2::InteractionRecord ir1(o2::constants::lhc::LHCMaxBunches - 1, hd0->firstTForbit < 0xffffffff - (mTFLength - 1) ? hd0->firstTForbit + (mTFLength - 1) : 0xffffffff);
+              auto irSpan = mIRFrameSelector.getMatchingFrames({ir0, ir1});
+              acceptTF = (irSpan.size() > 0) ? !mInput.invertIRFramesSelection : mInput.invertIRFramesSelection;
+              LOGP(info, "IRFrame selection contains {} frames for TF [{}] : [{}]: {}use this TF (selection inversion mode is {})",
+                   irSpan.size(), ir0.asString(), ir1.asString(), acceptTF ? "" : "do not ", mInput.invertIRFramesSelection ? "ON" : "OFF");
+            }
+          }
           locID++;
-          if (!mInput.tfIDs.empty()) {
+          if (!mInput.tfIDs.empty() && acceptTF) {
             acceptTF = false;
             if (mInput.tfIDs[mSelIDEntry] == mTFBuilderCounter) {
               mWaitSendingLast = false;
@@ -448,6 +476,110 @@ void TFReaderSpec::TFBuilder()
   }
 }
 
+//_________________________________________________________
+void TFReaderSpec::loadRunTimeSpans(const std::string& flname)
+{
+  std::ifstream inputFile(flname);
+  if (!inputFile) {
+    LOGP(fatal, "Failed to open selected run/timespans file {}", flname);
+  }
+  std::string line;
+  size_t cntl = 0, cntr = 0;
+  while (std::getline(inputFile, line)) {
+    cntl++;
+    for (char& ch : line) { // Replace semicolons and tabs with spaces for uniform processing
+      if (ch == ';' || ch == '\t' || ch == ',') {
+        ch = ' ';
+      }
+    }
+    o2::utils::Str::trim(line);
+    if (line.size() < 1 || line[0] == '#') {
+      continue;
+    }
+    auto tokens = o2::utils::Str::tokenize(line, ' ');
+    auto logError = [&cntl, &line]() { LOGP(error, "Expected format for selection is tripplet <run> <range_min> <range_max>, failed on line#{}: {}", cntl, line); };
+    if (tokens.size() >= 3) {
+      int run = 0;
+      long rmin, rmax;
+      try {
+        run = std::stoi(tokens[0]);
+        rmin = std::stol(tokens[1]);
+        rmax = std::stol(tokens[2]);
+      } catch (...) {
+        logError();
+        continue;
+      }
+
+      constexpr long ISTimeStamp = 1514761200000L;
+      int convmn = rmin > ISTimeStamp ? 1 : 0, convmx = rmax > ISTimeStamp ? 1 : 0; // values above ISTimeStamp are timestamps (need to be converted to orbits)
+      if (rmin > rmax) {
+        LOGP(fatal, "Provided range limits are not in increasing order, entry is {}", line);
+      }
+      if (mConvRunTimeRangesToOrbits == -1) {
+        if (convmn != convmx) {
+          LOGP(fatal, "Provided range limits should be both consistent either with orbit number or with unix timestamp in ms, entry is {}", line);
+        }
+        mConvRunTimeRangesToOrbits = convmn; // need to convert to orbit if time
+        LOGP(info, "Interpret selected time-spans input as {}", mConvRunTimeRangesToOrbits == 1 ? "timstamps(ms)" : "orbits");
+      } else {
+        if (mConvRunTimeRangesToOrbits != convmn || mConvRunTimeRangesToOrbits != convmx) {
+          LOGP(fatal, "Provided range limits should are not consistent with previously determined {} input, entry is {}", mConvRunTimeRangesToOrbits == 1 ? "timestamps" : "orbits", line);
+        }
+      }
+
+      mRunTimeRanges[run].emplace_back(rmin, rmax);
+      cntr++;
+    } else {
+      logError();
+    }
+  }
+  LOGP(info, "Read {} time-spans for {} runs from {}", cntr, mRunTimeRanges.size(), flname);
+  inputFile.close();
+}
+
+//_________________________________________________________
+void TFReaderSpec::runTimeRangesToIRFrameSelector(int runNumber)
+{
+  // convert entries in the runTimeRanges to IRFrameSelector, if needed, convert time to orbit
+  mIRFrameSelector.clear();
+  auto ent = mRunTimeRanges.find(runNumber);
+  if (ent == mRunTimeRanges.end()) {
+    LOGP(info, "RunTimeRanges selection was provided but run {} has no entries, all TFs will be processed", runNumber);
+    return;
+  }
+  o2::parameters::AggregatedRunInfo rinfo;
+  auto& ccdb = o2::ccdb::BasicCCDBManager::instance();
+  rinfo = o2::parameters::AggregatedRunInfo::buildAggregatedRunInfo(ccdb, runNumber);
+  if (rinfo.runNumber != runNumber || rinfo.orbitsPerTF < 1) {
+    LOGP(fatal, "failed to extract AggregatedRunInfo for run {}", runNumber);
+  }
+  mTFLength = rinfo.orbitsPerTF;
+  std::vector<o2::dataformats::IRFrame> frames;
+  for (const auto& rng : ent->second) {
+    long orbMin = 0, orbMax = 0;
+    if (mConvRunTimeRangesToOrbits > 0) {
+      orbMin = rinfo.orbitSOR + (rng.first - rinfo.sor) / (o2::constants::lhc::LHCOrbitMUS * 0.001);
+      orbMax = rinfo.orbitSOR + (rng.second - rinfo.sor) / (o2::constants::lhc::LHCOrbitMUS * 0.001);
+    } else {
+      orbMin = rng.first;
+      orbMax = rng.second;
+    }
+    if (orbMin < 0) {
+      orbMin = 0;
+    }
+    if (orbMax < 0) {
+      orbMax = 0;
+    }
+    if (runNumber > 523897) {
+      orbMin = (orbMin / rinfo.orbitsPerTF) * rinfo.orbitsPerTF;
+      orbMax = (orbMax / rinfo.orbitsPerTF + 1) * rinfo.orbitsPerTF - 1;
+    }
+    LOGP(info, "TFs overlapping with orbits {}:{} will be {}", orbMin, orbMax, mInput.invertIRFramesSelection ? "rejected" : "selected");
+    frames.emplace_back(o2::InteractionRecord{0, uint32_t(orbMin)}, o2::InteractionRecord{o2::constants::lhc::LHCMaxBunches, uint32_t(orbMax)});
+  }
+  mIRFrameSelector.setOwnList(frames, true);
+}
+
 //_________________________________________________________
 o2f::DataProcessorSpec o2::rawdd::getTFReaderSpec(o2::rawdd::TFReaderInp& rinp)
 {
diff --git a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
index e3a5b5c920010..9db18768c1bfe 100644
--- a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
+++ b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
@@ -32,6 +32,7 @@ struct TFReaderInp {
   std::string tffileRegex{};
   std::string remoteRegex{};
   std::string metricChannel{};
+  std::string fileRunTimeSpans{};
   o2::detectors::DetID::mask_t detMask{};
   o2::detectors::DetID::mask_t detMaskRawOnly{};
   o2::detectors::DetID::mask_t detMaskNonRawOnly{};
@@ -46,6 +47,7 @@ struct TFReaderInp {
   int maxTFsPerFile = -1;
   bool sendDummyForMissing = true;
   bool sup0xccdb = false;
+  bool invertIRFramesSelection = false;
   std::vector<o2::header::DataHeader> hdVec;
   std::vector<int> tfIDs{};
 };
diff --git a/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx b/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
index 7d8ee09fe474f..bc682127b0d3f 100644
--- a/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
+++ b/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
@@ -39,6 +39,8 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   options.push_back(ConfigParamSpec{"disable-dummy-output", VariantType::Bool, false, {"Disable sending empty output if corresponding data is not found in the data"}});
   options.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {"semicolon separated key=value strings"}});
   options.push_back(ConfigParamSpec{"timeframes-shm-limit", VariantType::String, "0", {"Minimum amount of SHM required in order to publish data"}});
+  options.push_back(ConfigParamSpec{"run-time-span-file", VariantType::String, "", {"If non empty, inject selected IRFrames from this text file (run, min/max orbit or unix time)"}});
+  options.push_back(ConfigParamSpec{"invert-irframe-selection", VariantType::Bool, false, {"Select only frames mentioned in ir-frames-file (skip-skimmed-out-tf applied to TF not selected!)"}});
   options.push_back(ConfigParamSpec{"metric-feedback-channel-format", VariantType::String, "name=metric-feedback,type=pull,method=connect,address=ipc://{}metric-feedback-{},transport=shmem,rateLogging=0", {"format for the metric-feedback channel for TF rate limiting"}});
 
   // options for error-check suppression
@@ -80,7 +82,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   if (rateLimitingIPCID > -1 && !chanFmt.empty()) {
     rinp.metricChannel = fmt::format(fmt::runtime(chanFmt), o2::framework::ChannelSpecHelpers::defaultIPCFolder(), rateLimitingIPCID);
   }
-
+  rinp.fileRunTimeSpans = configcontext.options().get<std::string>("run-time-span-file");
+  rinp.invertIRFramesSelection = configcontext.options().get<bool>("invert-irframe-selection");
   WorkflowSpec specs;
   specs.emplace_back(o2::rawdd::getTFReaderSpec(rinp));
   return specs;

From dfd37f923994aef7a4284935be75e426961523e7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 16 Jul 2025 17:46:38 +0200
Subject: [PATCH 0624/1764] GPU: Fix checking for dmaTransferType with GPU
 memory registration disabled

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 423f0b782d095..9d2578731a30c 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -273,8 +273,8 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("NStreams of %d insufficient for %d nTPCClustererLanes", mRec->NStreams(), (int32_t)GetProcessingSettings().nTPCClustererLanes);
     return false;
   }
-  if (GetProcessingSettings().noGPUMemoryRegistration && gatherMode != 3) {
-    GPUError("noGPUMemoryRegistration only possible with gather mode 3");
+  if ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && GetProcessingSettings().noGPUMemoryRegistration && gatherMode != 3) {
+    GPUError("noGPUMemoryRegistration only possible with gather mode 3 (set to %d / %d)", mRec->GetProcessingSettings().tpcCompressionGatherMode, gatherMode);
     return false;
   }
   if (GetProcessingSettings().doublePipeline) {

From bbb5bb8e7405dda61337ffa83c8ae6e8de66f8c9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 17 Jul 2025 13:58:32 +0200
Subject: [PATCH 0625/1764] GPU: Fix typo in getting default number of threads
 from env variables

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 4a67fae3b6376..c7b61a976021a 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -209,7 +209,7 @@ static uint32_t getDefaultNThreads()
   const char* ompEnv = getenv("OMP_NUM_THREADS");
   uint32_t ompNum = ompEnv ? atoi(ompEnv) : 0;
   if (ompNum) {
-    return tbbNum;
+    return ompNum;
   }
   return tbb::info::default_concurrency();
 }

From d238d41c803bdae4a00834c8f9093725dced52f4 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <9267733+fweig@users.noreply.github.com>
Date: Thu, 17 Jul 2025 23:06:44 +0200
Subject: [PATCH 0626/1764] TPCFastTransformation: Resolve recursion at compile
 time with templates. (#14462)

* TPCFastTransformation: Resolve recursion at compile time with templates.

* TPCFastTransformation: Fix runtime parameters on CPU for polynoms.

* Fix failing unittest.
---
 GPU/Common/GPUCommonDefAPI.h                  |   2 +-
 .../DataTypes/CalibdEdxTrackTopologyPol.h     |   5 +-
 .../MultivariatePolynomial.h                  |   2 +-
 .../MultivariatePolynomialHelper.h            | 164 ++++++++++++++----
 .../NDPiecewisePolynomials.h                  |  25 ++-
 .../NDPiecewisePolynomials.inc                |   4 +-
 6 files changed, 157 insertions(+), 45 deletions(-)

diff --git a/GPU/Common/GPUCommonDefAPI.h b/GPU/Common/GPUCommonDefAPI.h
index 2494cd8dd6fe5..4d4e04f10b2fa 100644
--- a/GPU/Common/GPUCommonDefAPI.h
+++ b/GPU/Common/GPUCommonDefAPI.h
@@ -79,7 +79,7 @@
   #define GPUdDefault()
   #define GPUhdDefault()
   #define GPUdi() inline
-  #define GPUdii() inline
+  #define GPUdii() __attribute__((always_inline)) inline
   #define GPUdni()
   #define GPUdnii()
   #define GPUh() INVALID_TRIGGER_ERROR_NO_HOST_CODE
diff --git a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.h b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.h
index a50cf63698a78..0a3816f9ddbd2 100644
--- a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.h
+++ b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.h
@@ -62,7 +62,10 @@ class CalibdEdxTrackTopologyPol : public o2::gpu::FlatObject
   /// \param region region of the TPC
   /// \param charge correction for maximum or total charge
   /// \param x coordinates where the correction is evaluated
-  GPUd() float getCorrection(const int32_t region, const ChargeType charge, float x[/*inpXdim*/]) const { return (charge == ChargeType::Tot) ? mCalibPolsqTot[region].eval(x) : mCalibPolsqMax[region].eval(x); }
+  GPUd() float getCorrection(const int32_t region, const ChargeType charge, float x[/*inpXdim*/]) const
+  {
+    return (charge == ChargeType::Tot) ? mCalibPolsqTot[region].eval(x) : mCalibPolsqMax[region].eval(x);
+  }
 
   /// \return returns the track topology correction
   /// \param region region of the TPC
diff --git a/GPU/TPCFastTransformation/MultivariatePolynomial.h b/GPU/TPCFastTransformation/MultivariatePolynomial.h
index 4fd2157409133..1454194f9e3b4 100644
--- a/GPU/TPCFastTransformation/MultivariatePolynomial.h
+++ b/GPU/TPCFastTransformation/MultivariatePolynomial.h
@@ -56,7 +56,7 @@ class MultivariatePolynomial : public FlatObject, public MultivariatePolynomialH
 
   /// constructor for compile time evaluation of polynomial formula
   template <bool IsEnabled = true, typename std::enable_if<(IsEnabled && (Dim != 0 && Degree != 0)), int32_t>::type = 0>
-  MultivariatePolynomial() : mNParams{this->getNParameters(Degree, Dim, InteractionOnly)}
+  MultivariatePolynomial() : mNParams{this->template getNParameters<Degree, Dim, InteractionOnly>()}
   {
     construct();
   }
diff --git a/GPU/TPCFastTransformation/MultivariatePolynomialHelper.h b/GPU/TPCFastTransformation/MultivariatePolynomialHelper.h
index 52c30b3241adc..2dd186a859ab0 100644
--- a/GPU/TPCFastTransformation/MultivariatePolynomialHelper.h
+++ b/GPU/TPCFastTransformation/MultivariatePolynomialHelper.h
@@ -57,15 +57,63 @@ struct MultivariatePolynomialContainer {
 class MultivariatePolynomialParametersHelper
 {
  public:
+  /// \returns number of parameters for given dimension and degree of polynomials at compile time
+  /// calculates the number of parameters for a multivariate polynomial for given degree: nParameters = (n+d-1 d) -> binomial coefficient
+  /// see: https://mathoverflow.net/questions/225953/number-of-polynomial-terms-for-certain-degree-and-certain-number-of-variables
+  template <uint32_t Degree, uint32_t Dim>
+  GPUd() static constexpr uint32_t getNParametersAllTerms()
+  {
+    if constexpr (Degree == 0) {
+      return binomialCoeff<Dim - 1, 0>();
+    } else {
+      return binomialCoeff<Dim - 1 + Degree, Degree>() + getNParametersAllTerms<Degree - 1, Dim>();
+    }
+  }
+
   /// \returns number of parameters for given dimension and degree of polynomials
   /// calculates the number of parameters for a multivariate polynomial for given degree: nParameters = (n+d-1 d) -> binomial coefficient
   /// see: https://mathoverflow.net/questions/225953/number-of-polynomial-terms-for-certain-degree-and-certain-number-of-variables
-  GPUd() static constexpr uint32_t getNParametersAllTerms(const uint32_t degree, const uint32_t dim) { return (degree == 0) ? binomialCoeff(dim - 1, 0) : binomialCoeff(dim - 1 + degree, degree) + getNParametersAllTerms(degree - 1, dim); }
+  GPUd() static constexpr uint32_t getNParametersAllTerms(uint32_t degree, uint32_t dim)
+  {
+    if (degree == 0) {
+      return binomialCoeff(dim - 1, 0);
+    } else {
+      return binomialCoeff(dim - 1 + degree, degree) + getNParametersAllTerms(degree - 1, dim);
+    }
+  }
+
+  /// \returns the number of parameters at compile time for interaction terms only (see: https://en.wikipedia.org/wiki/Combination)
+  template <uint32_t Degree, uint32_t Dim>
+  GPUd() static constexpr uint32_t getNParametersInteractionOnly()
+  {
+    if constexpr (Degree == 0) {
+      return binomialCoeff<Dim - 1, 0>();
+    } else {
+      return binomialCoeff<Dim, Degree>() + getNParametersInteractionOnly<Degree - 1, Dim>();
+    }
+  }
 
   /// \returns the number of parameters for interaction terms only (see: https://en.wikipedia.org/wiki/Combination)
-  GPUd() static constexpr uint32_t getNParametersInteractionOnly(const uint32_t degree, const uint32_t dim) { return (degree == 0) ? binomialCoeff(dim - 1, 0) : binomialCoeff(dim, degree) + getNParametersInteractionOnly(degree - 1, dim); }
+  GPUd() static constexpr uint32_t getNParametersInteractionOnly(uint32_t degree, uint32_t dim)
+  {
+    if (degree == 0) {
+      return binomialCoeff(dim - 1, 0);
+    } else {
+      return binomialCoeff(dim, degree) + getNParametersInteractionOnly(degree - 1, dim);
+    }
+  }
+
+  template <uint32_t Degree, uint32_t Dim, bool InteractionOnly>
+  GPUd() static constexpr uint32_t getNParameters()
+  {
+    if constexpr (InteractionOnly) {
+      return getNParametersInteractionOnly<Degree, Dim>();
+    } else {
+      return getNParametersAllTerms<Degree, Dim>();
+    }
+  }
 
-  GPUd() static constexpr uint32_t getNParameters(const uint32_t degree, const uint32_t dim, const bool interactionOnly)
+  GPUd() static constexpr uint32_t getNParameters(uint32_t degree, uint32_t dim, bool interactionOnly)
   {
     if (interactionOnly) {
       return getNParametersInteractionOnly(degree, dim);
@@ -75,13 +123,36 @@ class MultivariatePolynomialParametersHelper
   }
 
  private:
+  /// calculate factorial of n at compile time
+  /// \return returns n!
+  template <uint32_t N>
+  GPUd() static constexpr uint32_t factorial()
+  {
+    if constexpr (N == 0 || N == 1) {
+      return 1;
+    } else {
+      return N * factorial<N - 1>();
+    }
+  }
+
   /// calculate factorial of n
   /// \return returns n!
-  GPUd() static constexpr uint32_t factorial(const uint32_t n) { return (n == 0) || (n == 1) ? 1 : n * factorial(n - 1); }
+  GPUd() static constexpr uint32_t factorial(uint32_t n) { return n == 0 || n == 1 ? 1 : n * factorial(n - 1); }
+
+  /// calculates binomial coefficient at compile time
+  /// \return returns (n k)
+  template <uint32_t N, uint32_t K>
+  GPUd() static constexpr uint32_t binomialCoeff()
+  {
+    return factorial<N>() / (factorial<K>() * factorial<N - K>());
+  }
 
   /// calculates binomial coefficient
   /// \return returns (n k)
-  GPUd() static constexpr uint32_t binomialCoeff(const uint32_t n, const uint32_t k) { return factorial(n) / (factorial(k) * factorial(n - k)); }
+  GPUd() static constexpr uint32_t binomialCoeff(uint32_t n, uint32_t k)
+  {
+    return factorial(n) / (factorial(k) * factorial(n - k));
+  }
 };
 
 /// Helper struct for evaluating a multidimensional polynomial using compile time evaluated formula
@@ -103,7 +174,10 @@ class MultivariatePolynomialHelper : public MultivariatePolynomialParametersHelp
   /// evaluates the polynomial for given parameters and coordinates
   /// \param par parameters of the polynomials
   /// \param x input coordinates
-  GPUd() static constexpr float evalPol(GPUgeneric() const float par[/*number of parameters*/], const float x[/*number of dimensions*/]) { return par[0] + loopDegrees<1>(par, x); }
+  GPUd() static constexpr float evalPol(GPUgeneric() const float par[/*number of parameters*/], const float x[/*number of dimensions*/])
+  {
+    return par[0] + loopDegrees<1>(par, x);
+  }
 
   /// \return returns number of dimensions of the polynomials
   GPUd() static constexpr uint32_t getDim() { return Dim; }
@@ -118,19 +192,36 @@ class MultivariatePolynomialHelper : public MultivariatePolynomialParametersHelp
   /// computes power of 10
   GPUd() static constexpr uint32_t pow10(const uint32_t n) { return n == 0 ? 1 : 10 * pow10(n - 1); }
 
+  template <uint32_t N>
+  GPUd() static constexpr uint32_t pow10()
+  {
+    if constexpr (N == 0) {
+      return 1;
+    } else {
+      return 10 * pow10<N - 1>();
+    }
+  }
+
   /// helper for modulo to extract the digit in an integer a at position b (can be obtained with pow10(digitposition)): e.g. a=1234 b=pow10(2)=100 -> returns 2
   GPUd() static constexpr uint32_t mod10(const uint32_t a, const uint32_t b) { return (a / b) % 10; }
 
+  template <uint32_t A, uint32_t B>
+  GPUd() static constexpr uint32_t mod10()
+  {
+    return (A / B) % 10;
+  }
+
   /// resetting digits of pos for given position to refDigit
   GPUd() static constexpr uint32_t resetIndices(const uint32_t degreePol, const uint32_t pos, const uint32_t leftDigit, const uint32_t iter, const uint32_t refDigit);
 
-  GPUd() static constexpr uint32_t getNewPos(const uint32_t degreePol, const uint32_t pos, const uint32_t digitPos);
+  template <uint32_t DegreePol, uint32_t Pos, uint32_t DigitPos>
+  GPUd() static constexpr uint32_t getNewPos();
 
   /// calculates term e.g. x^3*y
   /// \tparam DegreePol max degree of the polynomials
   /// \pos decoded information about the current term e.g. 1233 -> x[1]*x[2]*x[3]*x[3] (otherwise an array could be used)
-  template <uint32_t DegreePol>
-  GPUd() static constexpr float prodTerm(const float x[], const uint32_t pos);
+  template <uint32_t DegreePol, uint32_t Pos>
+  GPUd() static constexpr float prodTerm(const float x[]);
 
   /// helper function for checking for interaction terms
   template <uint32_t DegreePol, uint32_t posNew>
@@ -203,7 +294,10 @@ class MultivariatePolynomialHelper<0, 0, false> : public MultivariatePolynomialP
   /// evaluating the polynomial
   /// \param par coefficients of the polynomial
   /// \param x input coordinates
-  float evalPol(const float par[/*number of parameters*/], const float x[/*number of dimensions*/]) const { return evalPol(par, x, mDegree, mDim, mInteractionOnly); }
+  float evalPol(const float par[/*number of parameters*/], const float x[/*number of dimensions*/]) const
+  {
+    return evalPol(par, x, mDegree, mDim, mInteractionOnly);
+  }
 
   /// evalutes the polynomial
   float evalPol(const float par[], const float x[], const uint32_t degree, const uint32_t dim, const bool interactionOnly) const;
@@ -248,35 +342,39 @@ GPUd() constexpr uint32_t MultivariatePolynomialHelper<Dim, Degree, InteractionO
 }
 
 template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
-GPUd() constexpr uint32_t MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::getNewPos(const uint32_t degreePol, const uint32_t pos, const uint32_t digitPos)
+template <uint32_t DegreePol, uint32_t Pos, uint32_t DigitPos>
+GPUd() constexpr uint32_t MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::getNewPos()
 {
-  if (degreePol > digitPos) {
+  if constexpr (DegreePol > DigitPos) {
     // check if digit of current position is at is max position
-    if (mod10(pos, pow10(digitPos)) == Dim) {
+    if constexpr (mod10<Pos, pow10<DigitPos>()>() == Dim) {
       // increase digit of left position
-      const uint32_t leftDigit = digitPos + 1;
-      const uint32_t posTmp = pos + pow10(leftDigit);
-      const uint32_t refDigit = mod10(posTmp, pow10(digitPos + 1));
+      constexpr uint32_t LeftDigit = DigitPos + 1;
+      constexpr uint32_t PowLeftDigit = pow10<LeftDigit>();
+      constexpr uint32_t PosTmp = Pos + PowLeftDigit;
+      constexpr uint32_t RefDigit = mod10<PosTmp, PowLeftDigit>();
 
       // resetting digits to the right if digit exceeds number of dimensions
-      const uint32_t posReset = resetIndices(degreePol, posTmp, leftDigit - 1, degreePol - digitPos, refDigit);
+      constexpr uint32_t PosReset = resetIndices(DegreePol, PosTmp, LeftDigit - 1, DegreePol - DigitPos, RefDigit);
 
       // check next digit
-      return getNewPos(degreePol, posReset, digitPos + 1);
+      return getNewPos<DegreePol, PosReset, DigitPos + 1>();
+    } else {
+      return getNewPos<DegreePol, Pos, DigitPos + 1>();
     }
-    return getNewPos(degreePol, pos, digitPos + 1);
+  } else {
+    return Pos;
   }
-  return pos;
 }
 
 template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
-template <uint32_t DegreePol>
-GPUd() constexpr float MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::prodTerm(const float x[], const uint32_t pos)
+template <uint32_t DegreePol, uint32_t Pos>
+GPUd() constexpr float MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::prodTerm(const float x[])
 {
   if constexpr (DegreePol > 0) {
     // extract index of the dimension which is decoded in the digit
-    const uint32_t index = mod10(pos, pow10(DegreePol - 1));
-    return x[index] * prodTerm<DegreePol - 1>(x, pos);
+    const uint32_t index = mod10<Pos, pow10<DegreePol - 1>()>();
+    return x[index] * prodTerm<DegreePol - 1, Pos>(x);
   }
   return 1;
 }
@@ -286,7 +384,7 @@ template <uint32_t DegreePol, uint32_t posNew>
 constexpr bool MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::checkInteraction()
 {
   if constexpr (DegreePol > 1) {
-    constexpr bool isInteraction = mod10(posNew, pow10(DegreePol - 1)) == mod10(posNew, pow10(DegreePol - 2));
+    constexpr bool isInteraction = mod10<posNew, pow10<DegreePol - 1>()>() == mod10<posNew, pow10<DegreePol - 2>()>();
     if constexpr (isInteraction) {
       return true;
     }
@@ -300,16 +398,16 @@ template <uint32_t DegreePol, uint32_t Pos, uint32_t Index>
 GPUd() constexpr float MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::sumTerms(GPUgeneric() const float par[], const float x[])
 {
   // checking if the current position is reasonable e.g. if the max dimension is x[4]: for Pos=15 -> x[1]*x[5] the position is set to 22 -> x[2]*x[2]
-  constexpr uint32_t posNew = getNewPos(DegreePol, Pos, 0);
-  if constexpr (mod10(posNew, pow10(DegreePol)) != 1) {
+  constexpr uint32_t PosNew = getNewPos<DegreePol, Pos, 0>();
+  if constexpr (mod10<PosNew, pow10<DegreePol>()>() != 1) {
 
     // check if all digits in posNew are unequal: For interaction_only terms with x[Dim]*x[Dim]... etc. can be skipped
-    if constexpr (InteractionOnly && checkInteraction<DegreePol, posNew>()) {
-      return sumTerms<DegreePol, posNew + 1, Index>(par, x);
+    if constexpr (InteractionOnly && checkInteraction<DegreePol, PosNew>()) {
+      return sumTerms<DegreePol, PosNew + 1, Index>(par, x);
+    } else {
+      // sum up the term for corrent term and set posotion for next combination
+      return par[Index] * prodTerm<DegreePol, PosNew>(x) + sumTerms<DegreePol, PosNew + 1, Index + 1>(par, x);
     }
-
-    // sum up the term for corrent term and set posotion for next combination
-    return par[Index] * prodTerm<DegreePol>(x, posNew) + sumTerms<DegreePol, posNew + 1, Index + 1>(par, x);
   }
   return 0;
 }
@@ -319,7 +417,7 @@ template <uint32_t DegreePol>
 GPUd() constexpr float MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::loopDegrees(GPUgeneric() const float par[], const float x[])
 {
   if constexpr (DegreePol <= Degree) {
-    constexpr uint32_t index{getNParameters(DegreePol - 1, Dim, InteractionOnly)}; // offset of the index for accessing the parameters
+    constexpr uint32_t index{getNParameters<DegreePol - 1, Dim, InteractionOnly>()}; // offset of the index for accessing the parameters
     return sumTerms<DegreePol, 0, index>(par, x) + loopDegrees<DegreePol + 1>(par, x);
   }
   return 0;
diff --git a/GPU/TPCFastTransformation/NDPiecewisePolynomials.h b/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
index e750bffd28f4b..0d56b65aa89b8 100644
--- a/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
+++ b/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
@@ -141,7 +141,10 @@ class NDPiecewisePolynomials : public FlatObject
   /// evaluate specific polynomial at given index for given coordinate
   /// \param x coordinates where to interpolate
   /// \param index index of the polynomial
-  GPUd() float evalPol(const float x[/* Dim */], const int32_t index[/* Dim */]) const { return MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::evalPol(getParameters(index), x); }
+  GPUd() float evalPol(const float x[/* Dim */], const int32_t index[/* Dim */]) const
+  {
+    return MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::evalPol(getParameters(index), x);
+  }
 
   /// \return returns min range for given dimension
   GPUd() float getXMin(const uint32_t dim) const { return mMin[dim]; }
@@ -215,7 +218,7 @@ class NDPiecewisePolynomials : public FlatObject
 #endif // !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 
   /// \return returns the total number of stored parameters
-  uint32_t getNParameters() const { return getNPolynomials() * MultivariatePolynomialParametersHelper::getNParameters(Degree, Dim, InteractionOnly); }
+  uint32_t getNParameters() const { return getNPolynomials() * MultivariatePolynomialParametersHelper::getNParameters<Degree, Dim, InteractionOnly>(); }
 
   /// \return returns number of dimensions of the polynomials
   GPUd() static constexpr uint32_t getDim() { return Dim; }
@@ -241,11 +244,19 @@ class NDPiecewisePolynomials : public FlatObject
 
   /// returns terms which are needed to calculate the index for the grid for given dimension
   /// \param dim dimension
-  GPUd() uint32_t getTerms(const uint32_t dim) const { return (dim == 0) ? 1 : (mN[dim - 1] - 1) * getTerms(dim - 1); }
+  template <uint32_t TermDim>
+  GPUd() uint32_t getTerms() const
+  {
+    if constexpr (TermDim == 0) {
+      return 1;
+    } else {
+      return (mN[TermDim - 1] - 1) * getTerms<TermDim - 1>();
+    }
+  }
 
   /// returns index for accessing the parameter on the grid
   /// \param ix index per dimension
-  GPUd() uint32_t getDataIndex(const int32_t ix[/* Dim */]) const { return getDataIndex<Dim - 1>(ix) * MultivariatePolynomialParametersHelper::getNParameters(Degree, Dim, InteractionOnly); }
+  GPUd() uint32_t getDataIndex(const int32_t ix[/* Dim */]) const { return getDataIndex<Dim - 1>(ix) * MultivariatePolynomialParametersHelper::getNParameters<Degree, Dim, InteractionOnly>(); }
 
   /// helper function to get the index
   template <uint32_t DimTmp>
@@ -325,7 +336,7 @@ void NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::setFromContainer(cons
 template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
 void NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::setDefault()
 {
-  const auto nParamsPerPol = MultivariatePolynomialParametersHelper::getNParameters(Degree, Dim, InteractionOnly);
+  const auto nParamsPerPol = MultivariatePolynomialParametersHelper::getNParameters<Degree, Dim, InteractionOnly>();
   const auto nPols = getNPolynomials();
   std::vector<float> params(nParamsPerPol);
   params.front() = 1;
@@ -429,10 +440,10 @@ void NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::setFutureBufferAddres
 
 template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
 template <uint32_t DimTmp>
-GPUdi() uint32_t NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::getDataIndex(const int32_t ix[/* Dim */]) const
+GPUd() uint32_t NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::getDataIndex(const int32_t ix[/* Dim */]) const
 {
   if constexpr (DimTmp > 0) {
-    return ix[DimTmp] * getTerms(DimTmp) + getDataIndex<DimTmp - 1>(ix);
+    return ix[DimTmp] * getTerms<DimTmp>() + getDataIndex<DimTmp - 1>(ix);
   }
   return ix[DimTmp];
 }
diff --git a/GPU/TPCFastTransformation/NDPiecewisePolynomials.inc b/GPU/TPCFastTransformation/NDPiecewisePolynomials.inc
index 2538e30056448..1cbcf9cd8e23e 100644
--- a/GPU/TPCFastTransformation/NDPiecewisePolynomials.inc
+++ b/GPU/TPCFastTransformation/NDPiecewisePolynomials.inc
@@ -165,7 +165,7 @@ void NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::performFits(const std
     // check if data points are in the grid
     if (index == indexClamped) {
       // index of the polyniomial
-      const uint32_t idx = getDataIndex(index.data()) / MultivariatePolynomialParametersHelper::getNParameters(Degree, Dim, InteractionOnly);
+      const uint32_t idx = getDataIndex(index.data()) / MultivariatePolynomialParametersHelper::getNParameters<Degree, Dim, InteractionOnly>();
 
       // store index to data point
       dataPointsIndices[idx].emplace_back(i);
@@ -216,7 +216,7 @@ void NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::performFits(const std
     const auto params = MultivariatePolynomialHelper<0, 0, false>::fit(fitter, xCords, response, error, true);
 
     // store parameters
-    std::copy(params.begin(), params.end(), &mParams[i * MultivariatePolynomialParametersHelper::getNParameters(Degree, Dim, InteractionOnly)]);
+    std::copy(params.begin(), params.end(), &mParams[i * MultivariatePolynomialParametersHelper::getNParameters<Degree, Dim, InteractionOnly>()]);
   }
 }
 

From 5d72482ed5c4c5a8bdaacc2b35d6b181ccfac85d Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 2 Jul 2025 10:41:38 +0200
Subject: [PATCH 0627/1764] ITS: cleanup unused classes

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt  |   2 -
 .../tracking/include/ITStracking/ArrayUtils.h |  53 ----
 .../tracking/include/ITStracking/IOUtils.h    |  43 +--
 .../ITS/tracking/include/ITStracking/Label.h  |  41 ---
 .../tracking/include/ITStracking/ROframe.h    | 190 -------------
 .../tracking/include/ITStracking/Smoother.h   |   5 +-
 .../tracking/include/ITStracking/Tracker.h    |   1 -
 .../tracking/include/ITStracking/Vertexer.h   |   7 -
 Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx |  89 +-----
 Detectors/ITSMFT/ITS/tracking/src/Label.cxx   |  42 ---
 Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx |  65 -----
 .../ITSMFT/ITS/tracking/src/Smoother.cxx      | 256 +++++++++---------
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |   1 -
 .../ITS/tracking/src/TrackingInterface.cxx    |   8 +-
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      |   3 +-
 .../ITS/workflow/src/CookedTrackerSpec.cxx    |   2 -
 .../reconstruction/src/TrackingInterface.cxx  |   1 +
 17 files changed, 144 insertions(+), 665 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/ArrayUtils.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/Label.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROframe.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/src/Label.cxx
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx

diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index 45080e19cacff..f9565307d35f6 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -15,10 +15,8 @@ o2_add_library(ITStracking
                SOURCES src/ClusterLines.cxx
                        src/Cluster.cxx
                        src/Configuration.cxx
-                       src/ROframe.cxx
                        src/TimeFrame.cxx
                        src/IOUtils.cxx
-                       src/Label.cxx
                        src/Tracker.cxx
                        src/TrackerTraits.cxx
                        src/TrackingConfigParam.cxx
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ArrayUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ArrayUtils.h
deleted file mode 100644
index 971ae6a7fe83a..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ArrayUtils.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file ArrayUtils.h
-/// \brief
-///
-
-#ifndef TRACKINGITSU_INCLUDE_ARRAYUTILS_H_
-#define TRACKINGITSU_INCLUDE_ARRAYUTILS_H_
-
-#include <array>
-#include <cstddef>
-#include <utility>
-
-namespace o2
-{
-namespace its
-{
-namespace CA
-{
-
-namespace ArrayUtils
-{
-template <typename T, std::size_t... Is, typename Initializer>
-constexpr std::array<T, sizeof...(Is)> fillArray(Initializer, std::index_sequence<Is...>);
-template <typename T, std::size_t N, typename Initializer>
-constexpr std::array<T, N> fillArray(Initializer);
-} // namespace ArrayUtils
-
-template <typename T, std::size_t... Is, typename Initializer>
-constexpr std::array<T, sizeof...(Is)> ArrayUtils::fillArray(Initializer initializer, std::index_sequence<Is...>)
-{
-  return std::array<T, sizeof...(Is)>{{initializer(Is)...}};
-}
-
-template <typename T, std::size_t N, typename Initializer>
-constexpr std::array<T, N> ArrayUtils::fillArray(Initializer initializer)
-{
-  return ArrayUtils::fillArray<T>(initializer, std::make_index_sequence<N>{});
-}
-} // namespace CA
-} // namespace its
-} // namespace o2
-
-#endif /* TRACKINGITSU_INCLUDE_ARRAYUTILS_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h
index 0ada9dfbc6188..8adacdf58d74d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IOUtils.h
@@ -16,62 +16,27 @@
 #ifndef TRACKINGITSU_INCLUDE_EVENTLOADER_H_
 #define TRACKINGITSU_INCLUDE_EVENTLOADER_H_
 
-#include <iosfwd>
-#include <string>
-#include <unordered_map>
 #include <vector>
 
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "ITStracking/Configuration.h"
-#include "ITStracking/ROframe.h"
-#include "ITStracking/Label.h"
-#include "ITStracking/Road.h"
-#include "ITStracking/TrackingConfigParam.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "ReconstructionDataFormats/BaseCluster.h"
-#include "ITSMFTReconstruction/ChipMappingITS.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "DataFormatsITSMFT/ROFRecord.h" // TODO this is just included since the alignment code include it now
 
-namespace o2
+namespace o2::its::ioutils
 {
 
-class MCCompLabel;
-
-namespace dataformats
-{
-template <typename T>
-class MCTruthContainer;
-}
-
-namespace its
-{
-
-namespace ioutils
-{
 constexpr float DefClusErrorRow = o2::itsmft::SegmentationAlpide::PitchRow * 0.5;
 constexpr float DefClusErrorCol = o2::itsmft::SegmentationAlpide::PitchCol * 0.5;
 constexpr float DefClusError2Row = DefClusErrorRow * DefClusErrorRow;
 constexpr float DefClusError2Col = DefClusErrorCol * DefClusErrorCol;
 
-void loadEventData(ROframe& events, gsl::span<const itsmft::CompClusterExt> clusters,
-                   gsl::span<const unsigned char>::iterator& pattIt, const itsmft::TopologyDictionary* dict,
-                   const dataformats::MCTruthContainer<MCCompLabel>* clsLabels = nullptr);
-int loadROFrameData(const o2::itsmft::ROFRecord& rof, ROframe& events, gsl::span<const itsmft::CompClusterExt> clusters,
-                    gsl::span<const unsigned char>::iterator& pattIt, const itsmft::TopologyDictionary* dict,
-                    const dataformats::MCTruthContainer<MCCompLabel>* mClsLabels = nullptr);
-
 void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
                             gsl::span<const unsigned char>::iterator& pattIt,
                             std::vector<o2::BaseCluster<float>>& output,
                             const itsmft::TopologyDictionary* dict);
 
-inline static const o2::itsmft::ChipMappingITS& getChipMappingITS()
-{
-  static const o2::itsmft::ChipMappingITS MP;
-  return MP;
-}
-
 template <class iterator, typename T>
 o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, iterator& iter, const itsmft::TopologyDictionary* dict, T& sig2y, T& sig2z)
 {
@@ -115,8 +80,6 @@ std::array<T, 3> extractClusterDataA(const itsmft::CompClusterExt& c, iterator&
   }
 }
 
-} // namespace ioutils
-} // namespace its
-} // namespace o2
+} // namespace o2::its::ioutils
 
 #endif /* TRACKINGITSU_INCLUDE_EVENTLOADER_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Label.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Label.h
deleted file mode 100644
index ec45e6587a974..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Label.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file Label.h
-/// \brief
-///
-
-#ifndef TRACKINGITSU_INCLUDE_LABEL_H_
-#define TRACKINGITSU_INCLUDE_LABEL_H_
-
-#include <ostream>
-
-namespace o2
-{
-namespace its
-{
-
-struct Label final {
-  Label(const int, const float, const float, const float, const int, const int);
-
-  int monteCarloId;
-  float transverseMomentum;
-  float phi;
-  float pseudorapidity;
-  int pdgCode;
-  int numberOfClusters;
-
-  friend std::ostream& operator<<(std::ostream&, const Label&);
-};
-} // namespace its
-} // namespace o2
-
-#endif /* TRACKINGITSU_INCLUDE_LABEL_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROframe.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROframe.h
deleted file mode 100644
index d35e5bc545904..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROframe.h
+++ /dev/null
@@ -1,190 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file ROframe.h
-/// \brief
-///
-
-#ifndef TRACKINGITSU_INCLUDE_ROFRAME_H_
-#define TRACKINGITSU_INCLUDE_ROFRAME_H_
-
-#include <array>
-#include <vector>
-#include <utility>
-#include <cassert>
-#include <gsl/gsl>
-
-#include "ITStracking/Cluster.h"
-#include "ITStracking/Constants.h"
-
-#include "ReconstructionDataFormats/Vertex.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-
-namespace o2
-{
-namespace its
-{
-
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
-class ROframe final
-{
- public:
-  ROframe(int ROframeId, int nLayers);
-  int getROFrameId() const;
-  const float3& getPrimaryVertex(const int) const;
-  int getPrimaryVerticesNum() const;
-  void addPrimaryVertex(const float, const float, const float);
-  void addPrimaryVertices(std::vector<Vertex> vertices);
-  void addPrimaryReconstructedVertex(const float, const float, const float);
-  void printPrimaryVertices() const;
-  int getTotalClusters() const;
-  bool empty() const;
-
-  const auto& getClusters() const { return mClusters; }
-  const std::vector<Cluster>& getClustersOnLayer(int layerId) const;
-  const std::vector<TrackingFrameInfo>& getTrackingFrameInfoOnLayer(int layerId) const;
-  const auto& getTrackingFrameInfo() const { return mTrackingFrameInfo; }
-
-  const TrackingFrameInfo& getClusterTrackingFrameInfo(int layerId, const Cluster& cl) const;
-  const MCCompLabel& getClusterFirstLabel(int layerId, const Cluster& cl) const;
-  const MCCompLabel& getClusterFirstLabel(int layerId, const int clId) const;
-  const gsl::span<const o2::MCCompLabel> getClusterLabels(int layerId, const int clId) const;
-  const gsl::span<const o2::MCCompLabel> getClusterLabels(int layerId, const Cluster& cl) const;
-  int getClusterExternalIndex(int layerId, const int clId) const;
-  std::vector<int> getTracksId(const int layerId, const std::vector<Cluster>& cl);
-
-  template <typename... T>
-  void addClusterToLayer(int layer, T&&... args);
-  template <typename... T>
-  void addTrackingFrameInfoToLayer(int layer, T&&... args);
-  void setMClabelsContainer(const dataformats::MCTruthContainer<MCCompLabel>* ptr);
-  void addClusterExternalIndexToLayer(int layer, const int idx);
-  bool hasMCinformation() const;
-
-  void clear();
-
- private:
-  const int mROframeId;
-  const o2::dataformats::MCTruthContainer<MCCompLabel>* mMClabels = nullptr;
-  std::vector<float3> mPrimaryVertices;
-  std::vector<std::vector<Cluster>> mClusters;
-  std::vector<std::vector<TrackingFrameInfo>> mTrackingFrameInfo;
-  std::vector<std::vector<int>> mClusterExternalIndices;
-};
-
-inline int ROframe::getROFrameId() const { return mROframeId; }
-
-inline const float3& ROframe::getPrimaryVertex(const int vertexIndex) const { return mPrimaryVertices[vertexIndex]; }
-
-inline int ROframe::getPrimaryVerticesNum() const { return mPrimaryVertices.size(); }
-
-inline bool ROframe::empty() const { return getTotalClusters() == 0; }
-
-inline const std::vector<Cluster>& ROframe::getClustersOnLayer(int layerId) const
-{
-  return mClusters[layerId];
-}
-
-inline const std::vector<TrackingFrameInfo>& ROframe::getTrackingFrameInfoOnLayer(int layerId) const
-{
-  return mTrackingFrameInfo[layerId];
-}
-
-inline const TrackingFrameInfo& ROframe::getClusterTrackingFrameInfo(int layerId, const Cluster& cl) const
-{
-  return mTrackingFrameInfo[layerId][cl.clusterId];
-}
-
-inline const MCCompLabel& ROframe::getClusterFirstLabel(int layerId, const Cluster& cl) const
-{
-  return getClusterFirstLabel(layerId, cl.clusterId);
-}
-
-inline const MCCompLabel& ROframe::getClusterFirstLabel(int layerId, const int clId) const
-{
-  return *(mMClabels->getLabels(getClusterExternalIndex(layerId, clId)).begin());
-}
-
-inline const gsl::span<const o2::MCCompLabel> ROframe::getClusterLabels(int layerId, const int clId) const
-{
-  return mMClabels->getLabels(getClusterExternalIndex(layerId, clId));
-}
-
-inline const gsl::span<const o2::MCCompLabel> ROframe::getClusterLabels(int layerId, const Cluster& cl) const
-{
-  return getClusterLabels(layerId, cl.clusterId);
-}
-
-inline int ROframe::getClusterExternalIndex(int layerId, const int clId) const
-{
-  return mClusterExternalIndices[layerId][clId];
-}
-
-inline std::vector<int> ROframe::getTracksId(const int layerId, const std::vector<Cluster>& cl)
-{
-  std::vector<int> tracksId;
-  for (auto& cluster : cl) {
-    tracksId.push_back(getClusterFirstLabel(layerId, cluster).isNoise() ? -1 : getClusterFirstLabel(layerId, cluster).getTrackID());
-  }
-  return tracksId;
-}
-
-template <typename... T>
-void ROframe::addClusterToLayer(int layer, T&&... values)
-{
-  mClusters[layer].emplace_back(std::forward<T>(values)...);
-}
-
-template <typename... T>
-void ROframe::addTrackingFrameInfoToLayer(int layer, T&&... values)
-{
-  mTrackingFrameInfo[layer].emplace_back(std::forward<T>(values)...);
-}
-
-inline void ROframe::setMClabelsContainer(const dataformats::MCTruthContainer<MCCompLabel>* ptr)
-{
-  mMClabels = ptr;
-}
-
-inline void ROframe::addClusterExternalIndexToLayer(int layer, const int idx)
-{
-  mClusterExternalIndices[layer].push_back(idx);
-}
-
-inline void ROframe::clear()
-{
-  for (unsigned int iL = 0; iL < mClusters.size(); ++iL) {
-    mClusters[iL].clear();
-    mTrackingFrameInfo[iL].clear();
-    // mClusterLabels[iL].clear();
-    mClusterExternalIndices[iL].clear();
-  }
-  mPrimaryVertices.clear();
-  mMClabels = nullptr;
-}
-
-inline bool ROframe::hasMCinformation() const
-{
-  // for (const auto& vect : mClusterLabels) {
-  //   if (!vect.empty()) {
-  //     return true;
-  //   }
-  // }
-  // return false;
-  return mMClabels;
-}
-
-} // namespace its
-} // namespace o2
-
-#endif /* TRACKINGITSU_INCLUDE_ROFRAME_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Smoother.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Smoother.h
index 2dcd521797837..101f4b8d72601 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Smoother.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Smoother.h
@@ -17,7 +17,6 @@
 #include "ReconstructionDataFormats/Track.h"
 #include "DataFormatsITS/TrackITS.h"
 #include "DetectorsBase/Propagator.h"
-#include "ITStracking/ROframe.h"
 
 namespace o2
 {
@@ -28,14 +27,14 @@ template <unsigned int D>
 class Smoother
 {
  public:
-  Smoother(TrackITSExt& track, size_t layer, const ROframe& event, float bZ, o2::base::PropagatorF::MatCorrType corr);
+  // Smoother(TrackITSExt& track, size_t layer, const ROframe& event, float bZ, o2::base::PropagatorF::MatCorrType corr);
   ~Smoother();
 
   bool isValidInit() const
   {
     return mInitStatus;
   }
-  bool testCluster(const int clusterId, const ROframe& event);
+  // bool testCluster(const int clusterId, const ROframe& event);
   bool getSmoothedTrack();
   float getChi2() const { return mBestChi2; }
   float getLastChi2() const { return mLastChi2; }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 78c290374a67d..3f80d239946b1 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -32,7 +32,6 @@
 #include "ITStracking/Configuration.h"
 #include "CommonConstants/MathConstants.h"
 #include "ITStracking/Definitions.h"
-#include "ITStracking/ROframe.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/TrackerTraits.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index c8b3b0d4138d4..2b9bfabd80128 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -25,7 +25,6 @@
 
 #include <oneapi/tbb/task_arena.h>
 
-#include "ITStracking/ROframe.h"
 #include "ITStracking/Constants.h"
 #include "ITStracking/Configuration.h"
 #include "ITStracking/TimeFrame.h"
@@ -33,12 +32,6 @@
 #include "ITStracking/BoundedAllocator.h"
 #include "ReconstructionDataFormats/Vertex.h"
 
-#include "ITStracking/ClusterLines.h"
-#include "ITStracking/Tracklet.h"
-#include "ITStracking/Cluster.h"
-
-#include "GPUCommonLogger.h"
-
 namespace o2::its
 {
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx b/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
index 2638b437d61f8..e2ce374ed1600 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/IOUtils.cxx
@@ -17,20 +17,11 @@
 
 #include <gsl/span>
 #include <vector>
-#include <array>
-#include <string>
-#include <iostream>
 #include <cstdlib>
-#include <fstream>
-#include <sstream>
-#include <tuple>
-#include <utility>
 
 #include "ITSBase/GeometryTGeo.h"
-#include "ITStracking/Constants.h"
-#include "MathUtils/Utils.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
+#include "ITStracking/TrackingConfigParam.h"
+#include "ITSMFTReconstruction/ChipMappingITS.h"
 
 namespace
 {
@@ -46,10 +37,10 @@ void ioutils::convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clu
                                      std::vector<o2::BaseCluster<float>>& output,
                                      const itsmft::TopologyDictionary* dict)
 {
+  static const o2::itsmft::ChipMappingITS chmap;
   GeometryTGeo* geom = GeometryTGeo::Instance();
   bool applyMisalignment = false;
   const auto& conf = TrackerParamConfig::Instance();
-  const auto& chmap = getChipMappingITS();
   for (int il = 0; il < chmap.NLayers; il++) {
     if (conf.sysErrY2[il] > 0.f || conf.sysErrZ2[il] > 0.f) {
       applyMisalignment = true;
@@ -69,77 +60,3 @@ void ioutils::convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clu
     cl3d.setErrors(sigmaY2, sigmaZ2, sigmaYZ);
   }
 }
-
-void ioutils::loadEventData(ROframe& event, gsl::span<const itsmft::CompClusterExt> clusters,
-                            gsl::span<const unsigned char>::iterator& pattIt, const itsmft::TopologyDictionary* dict,
-                            const dataformats::MCTruthContainer<MCCompLabel>* clsLabels)
-{
-  if (clusters.empty()) {
-    std::cerr << "Missing clusters." << std::endl;
-    return;
-  }
-  event.clear();
-  GeometryTGeo* geom = GeometryTGeo::Instance();
-  geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
-  int clusterId{0};
-
-  for (const auto& c : clusters) {
-    const int layer = geom->getLayer(c.getSensorID());
-    float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
-    auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2);
-    auto sensorID = c.getSensorID();
-    // Inverse transformation to the local --> tracking
-    auto trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;
-    // Transformation to the local --> global
-    auto gloXYZ = geom->getMatrixL2G(sensorID) * locXYZ;
-
-    event.addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), geom->getSensorRefAlpha(sensorID),
-                                      std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
-                                      std::array<float, 3>{sigmaY2, sigmaYZ, sigmaZ2});
-
-    /// Rotate to the global frame
-    event.addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), event.getClustersOnLayer(layer).size());
-    if (clsLabels) {
-      // event.addClusterLabelToLayer(layer, *(clsLabels->getLabels(clusterId).begin()));
-      event.setMClabelsContainer(clsLabels);
-    }
-    event.addClusterExternalIndexToLayer(layer, clusterId);
-    clusterId++;
-  }
-}
-
-int ioutils::loadROFrameData(const o2::itsmft::ROFRecord& rof, ROframe& event, gsl::span<const itsmft::CompClusterExt> clusters, gsl::span<const unsigned char>::iterator& pattIt, const itsmft::TopologyDictionary* dict,
-                             const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
-{
-  event.clear();
-  GeometryTGeo* geom = GeometryTGeo::Instance();
-  geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
-  int clusterId{0};
-
-  auto first = rof.getFirstEntry();
-  auto clusters_in_frame = rof.getROFData(clusters);
-  for (const auto& c : clusters_in_frame) {
-    const int layer = geom->getLayer(c.getSensorID());
-    float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
-    auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2);
-    auto sensorID = c.getSensorID();
-    // Inverse transformation to the local --> tracking
-    auto trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;
-    // Transformation to the local --> global
-    auto gloXYZ = geom->getMatrixL2G(sensorID) * locXYZ;
-
-    event.addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), geom->getSensorRefAlpha(sensorID),
-                                      std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
-                                      std::array<float, 3>{sigmaY2, sigmaYZ, sigmaZ2});
-
-    /// Rotate to the global frame
-    event.addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), event.getClustersOnLayer(layer).size());
-    if (mcLabels) {
-      // event.addClusterLabelToLayer(layer, *(mcLabels->getLabels(first + clusterId).begin()));
-      event.setMClabelsContainer(mcLabels);
-    }
-    event.addClusterExternalIndexToLayer(layer, first + clusterId);
-    clusterId++;
-  }
-  return (int)clusters_in_frame.size();
-}
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Label.cxx b/Detectors/ITSMFT/ITS/tracking/src/Label.cxx
deleted file mode 100644
index e195318828f51..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/src/Label.cxx
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file Label.cxx
-/// \brief
-///
-
-#include "ITStracking/Label.h"
-
-namespace o2
-{
-namespace its
-{
-
-Label::Label(const int mcId, const float pT, const float phi, const float eta, const int pdg, const int ncl)
-  : monteCarloId{mcId},
-    transverseMomentum{pT},
-    phi{phi},
-    pseudorapidity{eta},
-    pdgCode{pdg},
-    numberOfClusters{ncl}
-{
-  // Nothing to do
-}
-
-std::ostream& operator<<(std::ostream& outputStream, const Label& label)
-{
-  outputStream << label.monteCarloId << "\t" << label.transverseMomentum << "\t" << label.phi << "\t"
-               << label.pseudorapidity << "\t" << label.pdgCode << "\t" << label.numberOfClusters;
-
-  return outputStream;
-}
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx b/Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx
deleted file mode 100644
index ee885db3c49ea..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/src/ROframe.cxx
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file ROframe.cxx
-/// \brief
-///
-
-#include "ITStracking/ROframe.h"
-
-#include <iostream>
-
-namespace o2
-{
-namespace its
-{
-
-ROframe::ROframe(int ROframeId, int nLayers) : mROframeId{ROframeId}
-{
-  mClusters.resize(nLayers);
-  mTrackingFrameInfo.resize(nLayers);
-  // mClusterLabels.resize(nLayers);
-  mClusterExternalIndices.resize(nLayers);
-}
-
-void ROframe::addPrimaryVertex(const float xCoordinate, const float yCoordinate, const float zCoordinate)
-{
-  mPrimaryVertices.emplace_back(float3{xCoordinate, yCoordinate, zCoordinate});
-}
-
-void ROframe::addPrimaryVertices(std::vector<Vertex> vertices)
-{
-  for (Vertex& vertex : vertices) {
-    mPrimaryVertices.emplace_back(float3{vertex.getX(), vertex.getY(), vertex.getZ()});
-  }
-}
-
-void ROframe::printPrimaryVertices() const
-{
-  const int verticesNum{static_cast<int>(mPrimaryVertices.size())};
-
-  for (int iVertex{0}; iVertex < verticesNum; ++iVertex) {
-
-    const float3& currentVertex = mPrimaryVertices[iVertex];
-    std::cout << "-1\t" << currentVertex.x << "\t" << currentVertex.y << "\t" << currentVertex.z << std::endl;
-  }
-}
-
-int ROframe::getTotalClusters() const
-{
-  size_t totalClusters{0};
-  for (auto& clusters : mClusters) {
-    totalClusters += clusters.size();
-  }
-  return int(totalClusters);
-}
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx b/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
index 9bc65161c3cbb..f2f7dbc81398f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
@@ -25,92 +25,92 @@ constexpr std::array<double, 3> getInverseSymm2D(const std::array<double, 3>& ma
 }
 
 // Smoother
-template <unsigned int D>
-Smoother<D>::Smoother(TrackITSExt& track, size_t smoothingLayer, const ROframe& event, float bZ, o2::base::PropagatorF::MatCorrType corr) : mLayerToSmooth{smoothingLayer},
-                                                                                                                                            mBz(bZ),
-                                                                                                                                            mCorr(corr)
-{
-
-  auto propInstance = o2::base::Propagator::Instance();
-  const TrackingFrameInfo& originalTf = event.getTrackingFrameInfoOnLayer(mLayerToSmooth).at(track.getClusterIndex(mLayerToSmooth));
-
-  mOutwardsTrack = track;               // This track will be propagated outwards inside the smoother! (as last step of fitting did inward propagation)
-  mInwardsTrack = {track.getParamOut(), // This track will be propagated inwards inside the smoother!
-                   static_cast<short>(mOutwardsTrack.getNumberOfClusters()), -999, static_cast<std::uint32_t>(event.getROFrameId()),
-                   mOutwardsTrack.getParamOut(), mOutwardsTrack.getClusterIndexes()};
-
-  mOutwardsTrack.resetCovariance();
-  mOutwardsTrack.setChi2(0);
-  mInwardsTrack.resetCovariance();
-  mInwardsTrack.setChi2(0);
-
-  bool statusOutw{false};
-  bool statusInw{false};
-
-  //////////////////////
-  // Outward propagation
-  for (size_t iLayer{0}; iLayer < mLayerToSmooth; ++iLayer) {
-    if (mOutwardsTrack.getClusterIndex(iLayer) == constants::UnusedIndex) { // Shorter tracks
-      continue;
-    }
-    const TrackingFrameInfo& tF = event.getTrackingFrameInfoOnLayer(iLayer).at(mOutwardsTrack.getClusterIndex(iLayer));
-    statusOutw = mOutwardsTrack.rotate(tF.alphaTrackingFrame);
-    statusOutw &= propInstance->propagateToX(mOutwardsTrack,
-                                             tF.xTrackingFrame,
-                                             mBz,
-                                             o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                                             o2::base::PropagatorImpl<float>::MAX_STEP,
-                                             mCorr);
-    mOutwardsTrack.setChi2(mOutwardsTrack.getChi2() + mOutwardsTrack.getPredictedChi2(tF.positionTrackingFrame, tF.covarianceTrackingFrame));
-    statusOutw &= mOutwardsTrack.o2::track::TrackParCov::update(tF.positionTrackingFrame, tF.covarianceTrackingFrame);
-    // LOG(info) << "Outwards loop on inwards track, layer: " << iLayer << " x: " << mOutwardsTrack.getX();
-  }
-
-  // Prediction on the previously outwards-propagated track is done on a copy, as the process seems to be not reversible
-  auto outwardsClone = mOutwardsTrack;
-  statusOutw = outwardsClone.rotate(originalTf.alphaTrackingFrame);
-  statusOutw &= propInstance->propagateToX(outwardsClone,
-                                           originalTf.xTrackingFrame,
-                                           mBz,
-                                           o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                                           o2::base::PropagatorImpl<float>::MAX_STEP,
-                                           mCorr);
-  /////////////////////
-  // Inward propagation
-  for (size_t iLayer{D - 1}; iLayer > mLayerToSmooth; --iLayer) {
-    if (mInwardsTrack.getClusterIndex(iLayer) == constants::UnusedIndex) { // Shorter tracks
-      continue;
-    }
-    const TrackingFrameInfo& tF = event.getTrackingFrameInfoOnLayer(iLayer).at(mInwardsTrack.getClusterIndex(iLayer));
-    statusInw = mInwardsTrack.rotate(tF.alphaTrackingFrame);
-    statusInw &= propInstance->propagateToX(mInwardsTrack,
-                                            tF.xTrackingFrame,
-                                            mBz,
-                                            o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                                            o2::base::PropagatorImpl<float>::MAX_STEP,
-                                            mCorr);
-    mInwardsTrack.setChi2(mInwardsTrack.getChi2() + mInwardsTrack.getPredictedChi2(tF.positionTrackingFrame, tF.covarianceTrackingFrame));
-    statusInw &= mInwardsTrack.o2::track::TrackParCov::update(tF.positionTrackingFrame, tF.covarianceTrackingFrame);
-    // LOG(info) << "Inwards loop on outwards track, layer: " << iLayer << " x: " << mInwardsTrack.getX();
-  }
-
-  // Prediction on the previously inwards-propagated track is done on a copy, as the process seems to be not revesible
-  auto inwardsClone = mInwardsTrack;
-  statusInw = inwardsClone.rotate(originalTf.alphaTrackingFrame);
-  statusInw &= propInstance->propagateToX(inwardsClone,
-                                          originalTf.xTrackingFrame,
-                                          mBz,
-                                          o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                                          o2::base::PropagatorImpl<float>::MAX_STEP,
-                                          mCorr);
-  // Compute weighted local chi2
-  mInitStatus = statusInw && statusOutw;
-  if (mInitStatus) {
-    mBestChi2 = computeSmoothedPredictedChi2(inwardsClone, outwardsClone, originalTf.positionTrackingFrame, originalTf.covarianceTrackingFrame);
-    mLastChi2 = mBestChi2;
-    LOG(info) << "Smoothed chi2 on original cluster: " << mBestChi2;
-  }
-}
+// template <unsigned int D>
+// Smoother<D>::Smoother(TrackITSExt& track, size_t smoothingLayer, const ROframe& event, float bZ, o2::base::PropagatorF::MatCorrType corr) : mLayerToSmooth{smoothingLayer},
+//                                                                                                                                             mBz(bZ),
+//                                                                                                                                             mCorr(corr)
+// {
+//
+//   auto propInstance = o2::base::Propagator::Instance();
+//   const TrackingFrameInfo& originalTf = event.getTrackingFrameInfoOnLayer(mLayerToSmooth).at(track.getClusterIndex(mLayerToSmooth));
+//
+//   mOutwardsTrack = track;               // This track will be propagated outwards inside the smoother! (as last step of fitting did inward propagation)
+//   mInwardsTrack = {track.getParamOut(), // This track will be propagated inwards inside the smoother!
+//                    static_cast<short>(mOutwardsTrack.getNumberOfClusters()), -999, static_cast<std::uint32_t>(event.getROFrameId()),
+//                    mOutwardsTrack.getParamOut(), mOutwardsTrack.getClusterIndexes()};
+//
+//   mOutwardsTrack.resetCovariance();
+//   mOutwardsTrack.setChi2(0);
+//   mInwardsTrack.resetCovariance();
+//   mInwardsTrack.setChi2(0);
+//
+//   bool statusOutw{false};
+//   bool statusInw{false};
+//
+//   //////////////////////
+//   // Outward propagation
+//   for (size_t iLayer{0}; iLayer < mLayerToSmooth; ++iLayer) {
+//     if (mOutwardsTrack.getClusterIndex(iLayer) == constants::UnusedIndex) { // Shorter tracks
+//       continue;
+//     }
+//     const TrackingFrameInfo& tF = event.getTrackingFrameInfoOnLayer(iLayer).at(mOutwardsTrack.getClusterIndex(iLayer));
+//     statusOutw = mOutwardsTrack.rotate(tF.alphaTrackingFrame);
+//     statusOutw &= propInstance->propagateToX(mOutwardsTrack,
+//                                              tF.xTrackingFrame,
+//                                              mBz,
+//                                              o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+//                                              o2::base::PropagatorImpl<float>::MAX_STEP,
+//                                              mCorr);
+//     mOutwardsTrack.setChi2(mOutwardsTrack.getChi2() + mOutwardsTrack.getPredictedChi2(tF.positionTrackingFrame, tF.covarianceTrackingFrame));
+//     statusOutw &= mOutwardsTrack.o2::track::TrackParCov::update(tF.positionTrackingFrame, tF.covarianceTrackingFrame);
+//     // LOG(info) << "Outwards loop on inwards track, layer: " << iLayer << " x: " << mOutwardsTrack.getX();
+//   }
+//
+//   // Prediction on the previously outwards-propagated track is done on a copy, as the process seems to be not reversible
+//   auto outwardsClone = mOutwardsTrack;
+//   statusOutw = outwardsClone.rotate(originalTf.alphaTrackingFrame);
+//   statusOutw &= propInstance->propagateToX(outwardsClone,
+//                                            originalTf.xTrackingFrame,
+//                                            mBz,
+//                                            o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+//                                            o2::base::PropagatorImpl<float>::MAX_STEP,
+//                                            mCorr);
+//   /////////////////////
+//   // Inward propagation
+//   for (size_t iLayer{D - 1}; iLayer > mLayerToSmooth; --iLayer) {
+//     if (mInwardsTrack.getClusterIndex(iLayer) == constants::UnusedIndex) { // Shorter tracks
+//       continue;
+//     }
+//     const TrackingFrameInfo& tF = event.getTrackingFrameInfoOnLayer(iLayer).at(mInwardsTrack.getClusterIndex(iLayer));
+//     statusInw = mInwardsTrack.rotate(tF.alphaTrackingFrame);
+//     statusInw &= propInstance->propagateToX(mInwardsTrack,
+//                                             tF.xTrackingFrame,
+//                                             mBz,
+//                                             o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+//                                             o2::base::PropagatorImpl<float>::MAX_STEP,
+//                                             mCorr);
+//     mInwardsTrack.setChi2(mInwardsTrack.getChi2() + mInwardsTrack.getPredictedChi2(tF.positionTrackingFrame, tF.covarianceTrackingFrame));
+//     statusInw &= mInwardsTrack.o2::track::TrackParCov::update(tF.positionTrackingFrame, tF.covarianceTrackingFrame);
+//     // LOG(info) << "Inwards loop on outwards track, layer: " << iLayer << " x: " << mInwardsTrack.getX();
+//   }
+//
+//   // Prediction on the previously inwards-propagated track is done on a copy, as the process seems to be not revesible
+//   auto inwardsClone = mInwardsTrack;
+//   statusInw = inwardsClone.rotate(originalTf.alphaTrackingFrame);
+//   statusInw &= propInstance->propagateToX(inwardsClone,
+//                                           originalTf.xTrackingFrame,
+//                                           mBz,
+//                                           o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+//                                           o2::base::PropagatorImpl<float>::MAX_STEP,
+//                                           mCorr);
+//   // Compute weighted local chi2
+//   mInitStatus = statusInw && statusOutw;
+//   if (mInitStatus) {
+//     mBestChi2 = computeSmoothedPredictedChi2(inwardsClone, outwardsClone, originalTf.positionTrackingFrame, originalTf.covarianceTrackingFrame);
+//     mLastChi2 = mBestChi2;
+//     LOG(info) << "Smoothed chi2 on original cluster: " << mBestChi2;
+//   }
+// }
 
 template <unsigned int D>
 Smoother<D>::~Smoother() = default;
@@ -173,48 +173,48 @@ float Smoother<D>::computeSmoothedPredictedChi2(const o2::track::TrackParCov& fi
   return chi2;
 }
 
-template <unsigned int D>
-bool Smoother<D>::testCluster(const int clusterId, const ROframe& event)
-{
-  if (!mInitStatus) {
-    return false;
-  }
-  auto propInstance = o2::base::Propagator::Instance();
-  const TrackingFrameInfo& testTf = event.getTrackingFrameInfoOnLayer(mLayerToSmooth).at(clusterId);
-
-  bool statusOutw{false};
-  bool statusInw{false};
-
-  // Prediction on the previously outwards-propagated track is done on a copy, as the process seems to be not reversible
-  auto outwardsClone = mOutwardsTrack;
-  statusOutw = outwardsClone.rotate(testTf.alphaTrackingFrame);
-  statusOutw &= propInstance->propagateToX(outwardsClone,
-                                           testTf.xTrackingFrame,
-                                           mBz,
-                                           o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                                           o2::base::PropagatorImpl<float>::MAX_STEP,
-                                           mCorr);
-
-  // Prediction on the previously inwards-propagated track is done on a copy, as the process seems to be not reversible
-  auto inwardsClone = mInwardsTrack;
-  statusInw = inwardsClone.rotate(testTf.alphaTrackingFrame);
-  statusInw &= propInstance->propagateToX(inwardsClone,
-                                          testTf.xTrackingFrame,
-                                          mBz,
-                                          o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                                          o2::base::PropagatorImpl<float>::MAX_STEP,
-                                          mCorr);
-  if (!(statusOutw && statusInw)) {
-    LOG(warning) << "Failed propagation in smoother!";
-    return false;
-  }
-
-  // Compute weighted local chi2
-  mLastChi2 = computeSmoothedPredictedChi2(inwardsClone, outwardsClone, testTf.positionTrackingFrame, testTf.covarianceTrackingFrame);
-  LOG(info) << "Smoothed chi2 on tested cluster: " << mLastChi2;
-
-  return true;
-}
+// template <unsigned int D>
+// bool Smoother<D>::testCluster(const int clusterId, const ROframe& event)
+// {
+//   if (!mInitStatus) {
+//     return false;
+//   }
+//   auto propInstance = o2::base::Propagator::Instance();
+//   const TrackingFrameInfo& testTf = event.getTrackingFrameInfoOnLayer(mLayerToSmooth).at(clusterId);
+//
+//   bool statusOutw{false};
+//   bool statusInw{false};
+//
+//   // Prediction on the previously outwards-propagated track is done on a copy, as the process seems to be not reversible
+//   auto outwardsClone = mOutwardsTrack;
+//   statusOutw = outwardsClone.rotate(testTf.alphaTrackingFrame);
+//   statusOutw &= propInstance->propagateToX(outwardsClone,
+//                                            testTf.xTrackingFrame,
+//                                            mBz,
+//                                            o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+//                                            o2::base::PropagatorImpl<float>::MAX_STEP,
+//                                            mCorr);
+//
+//   // Prediction on the previously inwards-propagated track is done on a copy, as the process seems to be not reversible
+//   auto inwardsClone = mInwardsTrack;
+//   statusInw = inwardsClone.rotate(testTf.alphaTrackingFrame);
+//   statusInw &= propInstance->propagateToX(inwardsClone,
+//                                           testTf.xTrackingFrame,
+//                                           mBz,
+//                                           o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+//                                           o2::base::PropagatorImpl<float>::MAX_STEP,
+//                                           mCorr);
+//   if (!(statusOutw && statusInw)) {
+//     LOG(warning) << "Failed propagation in smoother!";
+//     return false;
+//   }
+//
+//   // Compute weighted local chi2
+//   mLastChi2 = computeSmoothedPredictedChi2(inwardsClone, outwardsClone, testTf.positionTrackingFrame, testTf.covarianceTrackingFrame);
+//   LOG(info) << "Smoothed chi2 on tested cluster: " << mLastChi2;
+//
+//   return true;
+// }
 
 template class Smoother<7>;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 7a2e883e1b5e6..aa93e32e1db9c 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -19,7 +19,6 @@
 #include "ITStracking/Cell.h"
 #include "ITStracking/Constants.h"
 #include "ITStracking/IndexTableUtils.h"
-#include "ITStracking/Smoother.h"
 #include "ITStracking/Tracklet.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITStracking/TrackingConfigParam.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index f5fa195983240..a908f8b2a1f1e 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -9,15 +9,18 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <memory>
+
+#include <oneapi/tbb/task_arena.h>
+
 #include "ITSMFTBase/DPLAlpideParam.h"
 #include "ITSBase/GeometryTGeo.h"
 
 #include "ITSReconstruction/FastMultEstConfig.h"
 #include "ITSReconstruction/FastMultEst.h"
 
+#include "ITStracking/TrackingConfigParam.h"
 #include "ITStracking/TrackingInterface.h"
-#include <oneapi/tbb/task_arena.h>
-#include <memory>
 
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "DataFormatsITSMFT/PhysTrigger.h"
@@ -25,7 +28,6 @@
 #include "CommonDataFormat/IRFrame.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "ITStracking/BoundedAllocator.h"
-#include "ITStracking/TrackingConfigParam.h"
 #include "Framework/DeviceSpec.h"
 
 using namespace o2::framework;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 16de3d075ef75..94d69f7968ac8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -16,8 +16,9 @@
 #include "ITStracking/Vertexer.h"
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/Cluster.h"
-#include "ITStracking/ROframe.h"
+
 #include "ITStracking/ClusterLines.h"
+#include "ITStracking/Tracklet.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/VertexerTraits.h"
 #include "ITStracking/TrackingConfigParam.h"
diff --git a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
index 640265f881749..8a415d269d7f5 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
@@ -34,7 +34,6 @@
 #include "DetectorsBase/Propagator.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "CommonDataFormat/IRFrame.h"
-#include "ITStracking/ROframe.h"
 #include "ITStracking/IOUtils.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
 #include "CommonUtils/StringUtils.h"
@@ -113,7 +112,6 @@ void CookedTrackerDPL::run(ProcessingContext& pc)
     mTracker.setMCTruthContainers(labels.get(), &trackLabels);
   }
 
-  o2::its::ROframe event(0, 7);
   mVertexerPtr->adoptTimeFrame(mTimeFrame);
 
   auto& vertROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "VERTICESROF", 0});
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
index 99ac05e61baf8..3d18ab267bd46 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
@@ -12,6 +12,7 @@
 #include "ITS3Reconstruction/TrackingInterface.h"
 #include "ITS3Reconstruction/IOUtils.h"
 #include "ITSBase/GeometryTGeo.h"
+#include "ITStracking/TrackingConfigParam.h"
 #include "ITSMFTBase/DPLAlpideParam.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "Framework/DeviceSpec.h"

From 5074d714f0c459c75c06dbdd361a3e81516195d1 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sun, 13 Jul 2025 09:46:22 +0200
Subject: [PATCH 0628/1764] TRD: fix missing include

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index b5a1530e83d8c..598ce3c35c98c 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -18,6 +18,7 @@
 #include "DetectorsBase/GlobalParams.h"
 #include "DetectorsBase/Propagator.h"
 #include "ReconstructionDataFormats/TrackTPCITS.h"
+#include "ReconstructionDataFormats/Vertex.h"
 #include "DataFormatsTRD/Tracklet64.h"
 #include "DataFormatsTRD/CalibratedTracklet.h"
 #include "DataFormatsTRD/TriggerRecord.h"

From 5cdac2fee9655731decf176af40be1303377addb Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 14 Jul 2025 11:12:02 +0200
Subject: [PATCH 0629/1764] ITS: fix CookedTracker due to memory refactor

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h    | 5 +++++
 Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx     | 6 ++++++
 2 files changed, 11 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
index 88e4b06a5c8ce..eb55081889c12 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
@@ -19,12 +19,15 @@
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Vertexer.h"
 #include "ITStracking/VertexerTraits.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "Framework/Task.h"
 #include "TStopwatch.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 
+#include <oneapi/tbb/task_arena.h>
+
 using namespace o2::framework;
 
 namespace o2
@@ -57,6 +60,8 @@ class CookedTrackerDPL : public Task
   o2::its::CookedTracker mTracker;
   std::unique_ptr<VertexerTraits> mVertexerTraitsPtr = nullptr;
   std::unique_ptr<Vertexer> mVertexerPtr = nullptr;
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  std::shared_ptr<tbb::task_arena> mTaskArena;
   TStopwatch mTimer;
 };
 
diff --git a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
index 8a415d269d7f5..98662e46269d1 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
@@ -64,6 +64,11 @@ void CookedTrackerDPL::init(InitContext& ic)
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
   auto nthreads = ic.options().get<int>("nthreads");
   mTracker.setNumberOfThreads(nthreads);
+  mTaskArena = std::make_shared<tbb::task_arena>(nthreads);
+  mMemoryPool = std::make_unique<BoundedMemoryResource>();
+  mVertexerPtr->setMemoryPool(mMemoryPool);
+  mVertexerPtr->setNThreads(nthreads, mTaskArena);
+  mVertexerTraitsPtr->setMemoryPool(mMemoryPool);
 }
 
 void CookedTrackerDPL::run(ProcessingContext& pc)
@@ -104,6 +109,7 @@ void CookedTrackerDPL::run(ProcessingContext& pc)
     mc2rofs = pc.inputs().get<gsl::span<itsmft::MC2ROFRecord>>("MC2ROframes");
   }
   TimeFrame mTimeFrame;
+  mTimeFrame.setMemoryPool(mMemoryPool);
 
   LOG(info) << "ITSCookedTracker pulled " << compClusters.size() << " clusters, in " << rofs.size() << " RO frames";
 

From aaf3d53e45066f0b0137b91f7ccc6a042fff6b31 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 17 Jul 2025 16:26:35 +0200
Subject: [PATCH 0630/1764] DPL: get rid of gsl::span.

---
 .../Core/include/Framework/DeviceMetricsInfo.h  |  4 ++--
 .../GUISupport/src/FrameworkGUIDebugger.cxx     | 17 ++++++++---------
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/Framework/Core/include/Framework/DeviceMetricsInfo.h b/Framework/Core/include/Framework/DeviceMetricsInfo.h
index 30387f4e6becf..d55f1cb44f71d 100644
--- a/Framework/Core/include/Framework/DeviceMetricsInfo.h
+++ b/Framework/Core/include/Framework/DeviceMetricsInfo.h
@@ -18,7 +18,7 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <gsl/span>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -217,7 +217,7 @@ struct DeviceMetricsInfoHelpers {
       info.changed.clear();
     }
   }
-  static size_t metricsStorageSize(gsl::span<DeviceMetricsInfo const> infos)
+  static size_t metricsStorageSize(std::span<DeviceMetricsInfo const> infos)
   {
     // Count the size of the metrics storage
     size_t totalSize = 0;
diff --git a/Framework/GUISupport/src/FrameworkGUIDebugger.cxx b/Framework/GUISupport/src/FrameworkGUIDebugger.cxx
index 112797d357458..33e7f794972ad 100644
--- a/Framework/GUISupport/src/FrameworkGUIDebugger.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDebugger.cxx
@@ -30,7 +30,6 @@
 
 #include <algorithm>
 #include <iostream>
-#include <set>
 #include <string>
 #include <cinttypes>
 #include <numeric>
@@ -210,8 +209,8 @@ enum MetricTypes {
 // so that we can display driver and device metrics in the same plot
 // without an if.
 struct AllMetricsStore {
-  gsl::span<DeviceMetricsInfo const> metrics[TOTAL_TYPES_OF_METRICS];
-  gsl::span<TopologyNodeInfo const> specs[TOTAL_TYPES_OF_METRICS];
+  std::span<DeviceMetricsInfo const> metrics[TOTAL_TYPES_OF_METRICS];
+  std::span<TopologyNodeInfo const> specs[TOTAL_TYPES_OF_METRICS];
 };
 
 void displaySparks(
@@ -376,8 +375,8 @@ void displayDeviceMetrics(const char* label,
   ImPlotAxisFlags axisFlags = 0;
 
   for (size_t si = 0; si < TOTAL_TYPES_OF_METRICS; ++si) {
-    gsl::span<DeviceMetricsInfo const> metricsInfos = metricStore.metrics[si];
-    gsl::span<TopologyNodeInfo const> specs = metricStore.specs[si];
+    std::span<DeviceMetricsInfo const> metricsInfos = metricStore.metrics[si];
+    std::span<TopologyNodeInfo const> specs = metricStore.specs[si];
     for (int di = 0; di < metricsInfos.size(); ++di) {
       for (size_t mi = 0; mi < metricsInfos[di].metrics.size(); ++mi) {
         if (state[gmi].visible == false) {
@@ -1175,10 +1174,10 @@ std::function<void(void)> getGUIDebugger(std::vector<DeviceInfo> const& infos,
 
     AllMetricsStore metricsStore;
 
-    metricsStore.metrics[DEVICE_METRICS] = gsl::span(metricsInfos);
-    metricsStore.metrics[DRIVER_METRICS] = gsl::span(&driverInfo.metrics, 1);
-    metricsStore.specs[DEVICE_METRICS] = gsl::span(deviceNodesInfos);
-    metricsStore.specs[DRIVER_METRICS] = gsl::span(driverNodesInfos);
+    metricsStore.metrics[DEVICE_METRICS] = std::span(metricsInfos);
+    metricsStore.metrics[DRIVER_METRICS] = std::span(&driverInfo.metrics, 1);
+    metricsStore.specs[DEVICE_METRICS] = std::span(deviceNodesInfos);
+    metricsStore.specs[DRIVER_METRICS] = std::span(driverNodesInfos);
     displayMetrics(guiState, driverInfo, infos, metadata, controls, metricsStore);
     displayDriverInfo(driverInfo, driverControl);
 

From 2db94469033eb065f1a07629d97ebac464199a3d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 16 Jul 2025 15:10:40 +0200
Subject: [PATCH 0631/1764] DPL: move topological sort in a separate file

Simplifies testing.
---
 Framework/Core/CMakeLists.txt                 |  2 +
 .../include/Framework/TopologyPolicyHelpers.h | 23 +++++
 Framework/Core/src/TopologyPolicyHelpers.cxx  | 92 +++++++++++++++++++
 Framework/Core/src/runDataProcessing.cxx      | 70 +-------------
 Framework/Core/test/test_TopologyPolicies.cxx | 59 ++++++++++++
 5 files changed, 178 insertions(+), 68 deletions(-)
 create mode 100644 Framework/Core/include/Framework/TopologyPolicyHelpers.h
 create mode 100644 Framework/Core/src/TopologyPolicyHelpers.cxx
 create mode 100644 Framework/Core/test/test_TopologyPolicies.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 17320348d9272..d69194c83285e 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -133,6 +133,7 @@ o2_add_library(Framework
                        src/TableConsumer.cxx
                        src/TableTreeHelpers.cxx
                        src/TopologyPolicy.cxx
+                       src/TopologyPolicyHelpers.cxx
                        src/TextDriverClient.cxx
                        src/TimesliceIndex.cxx
                        src/TimingHelpers.cxx
@@ -248,6 +249,7 @@ add_executable(o2-test-framework-core
               test/test_TimeParallelPipelining.cxx
               test/test_TimesliceIndex.cxx
               test/test_TypeTraits.cxx
+              test/test_TopologyPolicies.cxx
               test/test_Variants.cxx
               test/test_WorkflowHelpers.cxx
               test/test_WorkflowSerialization.cxx
diff --git a/Framework/Core/include/Framework/TopologyPolicyHelpers.h b/Framework/Core/include/Framework/TopologyPolicyHelpers.h
new file mode 100644
index 0000000000000..71d40755f2d50
--- /dev/null
+++ b/Framework/Core/include/Framework/TopologyPolicyHelpers.h
@@ -0,0 +1,23 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_FRAMEWORK_TOPOLOGYPOLICYHELPERS_H_
+#define O2_FRAMEWORK_TOPOLOGYPOLICYHELPERS_H_
+#include "Framework/WorkflowSpec.h"
+#include <vector>
+
+namespace o2::framework
+{
+struct TopologyPolicyHelpers {
+  static auto buildEdges(WorkflowSpec& physicalWorkflow) -> std::vector<std::pair<int, int>>;
+};
+} // namespace o2::framework
+#endif // O2_FRAMEWORK_TOPOLOGYPOLICYHELPERS_H_
diff --git a/Framework/Core/src/TopologyPolicyHelpers.cxx b/Framework/Core/src/TopologyPolicyHelpers.cxx
new file mode 100644
index 0000000000000..31423bf27e0ff
--- /dev/null
+++ b/Framework/Core/src/TopologyPolicyHelpers.cxx
@@ -0,0 +1,92 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Framework/TopologyPolicyHelpers.h"
+#include "Framework/TopologyPolicy.h"
+
+namespace o2::framework
+{
+namespace
+{
+void describeDataProcessorSpec(std::ostream& stream, DataProcessorSpec const& spec)
+{
+  stream << spec.name;
+  if (!spec.labels.empty()) {
+    stream << "(";
+    bool first = false;
+    for (auto& label : spec.labels) {
+      stream << (first ? "" : ",") << label.value;
+      first = true;
+    }
+    stream << ")";
+  }
+}
+} // namespace
+
+auto TopologyPolicyHelpers::buildEdges(WorkflowSpec& physicalWorkflow) -> std::vector<std::pair<int, int>>
+{
+  std::vector<TopologyPolicy> topologyPolicies = TopologyPolicy::createDefaultPolicies();
+  std::vector<TopologyPolicy::DependencyChecker> dependencyCheckers;
+  dependencyCheckers.reserve(physicalWorkflow.size());
+
+  for (auto& spec : physicalWorkflow) {
+    for (auto& policy : topologyPolicies) {
+      if (policy.matcher(spec)) {
+        dependencyCheckers.push_back(policy.checkDependency);
+        break;
+      }
+    }
+  }
+  assert(dependencyCheckers.size() == physicalWorkflow.size());
+  // check if DataProcessorSpec at i depends on j
+  auto checkDependencies = [&workflow = physicalWorkflow,
+                            &dependencyCheckers](int i, int j) {
+    TopologyPolicy::DependencyChecker& checker = dependencyCheckers[i];
+    return checker(workflow[i], workflow[j]);
+  };
+  std::vector<std::pair<int, int>> edges;
+  for (size_t i = 0; i < physicalWorkflow.size() - 1; ++i) {
+    for (size_t j = i; j < physicalWorkflow.size(); ++j) {
+      if (i == j && checkDependencies(i, j)) {
+        throw std::runtime_error(physicalWorkflow[i].name + " depends on itself");
+      }
+      bool both = false;
+      if (checkDependencies(i, j)) {
+        edges.emplace_back(j, i);
+        both = true;
+      }
+      if (checkDependencies(j, i)) {
+        edges.emplace_back(i, j);
+        if (both) {
+          std::ostringstream str;
+          describeDataProcessorSpec(str, physicalWorkflow[i]);
+          str << " has circular dependency with ";
+          describeDataProcessorSpec(str, physicalWorkflow[j]);
+          str << ":\n";
+          for (auto x : {i, j}) {
+            str << physicalWorkflow[x].name << ":\n";
+            str << "inputs:\n";
+            for (auto& input : physicalWorkflow[x].inputs) {
+              str << "- " << input << " " << (int)input.lifetime << "\n";
+            }
+            str << "outputs:\n";
+            for (auto& output : physicalWorkflow[x].outputs) {
+              str << "- " << output << " " << (int)output.lifetime << "\n";
+            }
+          }
+          throw std::runtime_error(str.str());
+        }
+      }
+    }
+  }
+  return edges;
+};
+} // namespace o2::framework
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index d691041a366cf..59bacc67fef31 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -9,6 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 #include <memory>
+#include "Framework/TopologyPolicyHelpers.h"
 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
 #include <stdexcept>
 #include "Framework/BoostOptionsRetriever.h"
@@ -2835,20 +2836,6 @@ std::unique_ptr<o2::framework::ServiceRegistry> createRegistry()
   return std::make_unique<o2::framework::ServiceRegistry>();
 }
 
-void describeDataProcessorSpec(std::ostream& stream, DataProcessorSpec const& spec)
-{
-  stream << spec.name;
-  if (!spec.labels.empty()) {
-    stream << "(";
-    bool first = false;
-    for (auto& label : spec.labels) {
-      stream << (first ? "" : ",") << label.value;
-      first = true;
-    }
-    stream << ")";
-  }
-}
-
 // This is a toy executor for the workflow spec
 // What it needs to do is:
 //
@@ -3034,65 +3021,12 @@ int doMain(int argc, char** argv, o2::framework::WorkflowSpec const& workflow,
                      [](OutputSpec const& a, OutputSpec const& b) { return DataSpecUtils::describe(a) < DataSpecUtils::describe(b); });
   }
 
-  std::vector<TopologyPolicy> topologyPolicies = TopologyPolicy::createDefaultPolicies();
-  std::vector<TopologyPolicy::DependencyChecker> dependencyCheckers;
-  dependencyCheckers.reserve(physicalWorkflow.size());
-
-  for (auto& spec : physicalWorkflow) {
-    for (auto& policy : topologyPolicies) {
-      if (policy.matcher(spec)) {
-        dependencyCheckers.push_back(policy.checkDependency);
-        break;
-      }
-    }
-  }
-  assert(dependencyCheckers.size() == physicalWorkflow.size());
-  // check if DataProcessorSpec at i depends on j
-  auto checkDependencies = [&workflow = physicalWorkflow,
-                            &dependencyCheckers](int i, int j) {
-    TopologyPolicy::DependencyChecker& checker = dependencyCheckers[i];
-    return checker(workflow[i], workflow[j]);
-  };
-
   // Create a list of all the edges, so that we can do a topological sort
   // before we create the graph.
   std::vector<std::pair<int, int>> edges;
 
   if (physicalWorkflow.size() > 1) {
-    for (size_t i = 0; i < physicalWorkflow.size() - 1; ++i) {
-      for (size_t j = i; j < physicalWorkflow.size(); ++j) {
-        if (i == j && checkDependencies(i, j)) {
-          throw std::runtime_error(physicalWorkflow[i].name + " depends on itself");
-        }
-        bool both = false;
-        if (checkDependencies(i, j)) {
-          edges.emplace_back(j, i);
-          both = true;
-        }
-        if (checkDependencies(j, i)) {
-          edges.emplace_back(i, j);
-          if (both) {
-            std::ostringstream str;
-            describeDataProcessorSpec(str, physicalWorkflow[i]);
-            str << " has circular dependency with ";
-            describeDataProcessorSpec(str, physicalWorkflow[j]);
-            str << ":\n";
-            for (auto x : {i, j}) {
-              str << physicalWorkflow[x].name << ":\n";
-              str << "inputs:\n";
-              for (auto& input : physicalWorkflow[x].inputs) {
-                str << "- " << input << " " << (int)input.lifetime << "\n";
-              }
-              str << "outputs:\n";
-              for (auto& output : physicalWorkflow[x].outputs) {
-                str << "- " << output << " " << (int)output.lifetime << "\n";
-              }
-            }
-            throw std::runtime_error(str.str());
-          }
-        }
-      }
-    }
+    edges = TopologyPolicyHelpers::buildEdges(physicalWorkflow);
 
     auto topoInfos = WorkflowHelpers::topologicalSort(physicalWorkflow.size(), &edges[0].first, &edges[0].second, sizeof(std::pair<int, int>), edges.size());
     if (topoInfos.size() != physicalWorkflow.size()) {
diff --git a/Framework/Core/test/test_TopologyPolicies.cxx b/Framework/Core/test/test_TopologyPolicies.cxx
new file mode 100644
index 0000000000000..82344c292ab15
--- /dev/null
+++ b/Framework/Core/test/test_TopologyPolicies.cxx
@@ -0,0 +1,59 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Mocking.h"
+#include <catch_amalgamated.hpp>
+#include "Framework/ChannelSpecHelpers.h"
+#include "../src/DeviceSpecHelpers.h"
+#include "../src/GraphvizHelpers.h"
+#include "../src/WorkflowHelpers.h"
+#include "Framework/DeviceSpec.h"
+#include "Framework/WorkflowSpec.h"
+#include "Framework/DataSpecUtils.h"
+#include "../src/SimpleResourceManager.h"
+#include "../src/ComputingResourceHelpers.h"
+#include "test_HelperMacros.h"
+#include "Framework/TopologyPolicyHelpers.h"
+
+using namespace o2::framework;
+
+// This is how you can define your processing in a declarative way
+WorkflowSpec defineDataProcessingWithSporadic()
+{
+  return {
+    {.name = "input-proxy", .outputs = {OutputSpec{"QEMC", "CELL", 1}, OutputSpec{"CTF", "DONE", 0}}},
+    {.name = "EMC-Cell-proxy", .inputs = Inputs{InputSpec{"a", "QEMC", "CELL", 1, Lifetime::Sporadic}}},
+    {.name = "calib-output-proxy-barrel-tf", .inputs = {InputSpec{"a", "CTF", "DONE", 0}}}};
+}
+
+TEST_CASE("TestBrokenSporadic")
+{
+  auto workflow = defineDataProcessingWithSporadic();
+  auto configContext = makeEmptyConfigContext();
+  auto channelPolicies = ChannelConfigurationPolicy::createDefaultPolicies(*configContext);
+  auto completionPolicies = CompletionPolicy::createDefaultPolicies();
+  auto callbacksPolicies = CallbacksPolicy::createDefaultPolicies();
+  REQUIRE(channelPolicies.empty() == false);
+  REQUIRE(completionPolicies.empty() == false);
+  std::vector<DeviceSpec> devices;
+
+  std::vector<ComputingResource> resources{ComputingResourceHelpers::getLocalhostResource()};
+  REQUIRE(resources.size() == 1);
+  REQUIRE(resources[0].startPort == 22000);
+  SimpleResourceManager rm(resources);
+  auto offers = rm.getAvailableOffers();
+  REQUIRE(offers.size() == 1);
+  REQUIRE(offers[0].startPort == 22000);
+  REQUIRE(offers[0].rangeSize == 5000);
+
+  DeviceSpecHelpers::dataProcessorSpecs2DeviceSpecs(workflow, channelPolicies, completionPolicies, callbacksPolicies, devices, rm, "workflow-id", *configContext);
+  TopologyPolicyHelpers::buildEdges(workflow);
+}

From 9b9ef9a39e8da8a75e7c07111f5fb236c439ec82 Mon Sep 17 00:00:00 2001
From: nivram-phy <nramasub@cern.ch>
Date: Fri, 18 Jul 2025 15:28:49 +0200
Subject: [PATCH 0632/1764] Propagating merged noise map to DCS (#14515)

* Propagating merged noise map to DCS

* adding some definitions in NoiseCalibratorSpec.h

---------

Co-authored-by: Niveditha Ramasubramanian <nramasubramanian@lyodhc13.in2p3.fr>
---
 .../MFTCalibration/NoiseCalibratorSpec.h      |  4 +-
 .../calibration/src/NoiseCalibratorSpec.cxx   | 92 ++++++++++++++++---
 2 files changed, 83 insertions(+), 13 deletions(-)

diff --git a/Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseCalibratorSpec.h b/Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseCalibratorSpec.h
index c28e5d82ca46f..dee8fa4531bed 100644
--- a/Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseCalibratorSpec.h
+++ b/Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseCalibratorSpec.h
@@ -56,17 +56,17 @@ class NoiseCalibratorSpec : public Task
   void sendOutputCcdbMerge(DataAllocator& output);
   void sendOutputCcdbDcs(DataAllocator& output);
   void sendOutputDcs(DataAllocator& output);
+  void sendOutputDcsMerge(DataAllocator& output);
   void setOutputDcs(const o2::itsmft::NoiseMap& payload);
   o2::itsmft::NoiseMap mNoiseMap{936};
   std::unique_ptr<CALIBRATOR> mCalibrator = nullptr;
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
   std::string mPath;
-  std::string mPathMerge;
+  std::string mPathSingle;
   std::string mMeta;
 
   std::vector<std::array<int, 3>> mNoiseMapForDcs;
   std::string mPathDcs;
-  std::string mPathDcsMerge;
   std::string mOutputType;
 
   double mThresh;
diff --git a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
index a34d8cc5f2975..e958e6b1ba113 100644
--- a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
@@ -48,7 +48,7 @@ void NoiseCalibratorSpec::init(InitContext& ic)
   LOGP(info, "Setting the probability threshold to {} with relative error {}", probT, probTRelErr);
   mStopMeOnly = ic.options().get<bool>("stop-me-only");
   mPath = ic.options().get<std::string>("path-CCDB");
-  mPathMerge = ic.options().get<std::string>("path-CCDB-merge");
+  mPathSingle = ic.options().get<std::string>("path-CCDB-single");
 
   mMeta = ic.options().get<std::string>("meta");
   mStart = ic.options().get<int64_t>("tstart");
@@ -173,7 +173,7 @@ void NoiseCalibratorSpec::sendOutputCcdbDcs(DataAllocator& output)
   const auto& payload = mCalibrator->getNoiseMap();
   //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
 
-  o2::ccdb::CcdbObjectInfo info(mPath, "NoiseMap", "noise.root", meta, tstart, tend);
+  o2::ccdb::CcdbObjectInfo info(mPathSingle, "NoiseMap", "noise.root", meta, tstart, tend);
   auto flName = o2::ccdb::CcdbApi::generateFileName("noise");
   auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info);
   info.setFileName(flName);
@@ -244,7 +244,7 @@ void NoiseCalibratorSpec::sendOutputCcdb(DataAllocator& output)
   const auto& payload = mCalibrator->getNoiseMap();
   //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
 
-  o2::ccdb::CcdbObjectInfo info(mPath, "NoiseMap", "noise.root", meta, tstart, tend);
+  o2::ccdb::CcdbObjectInfo info(mPathSingle, "NoiseMap", "noise.root", meta, tstart, tend);
   auto flName = o2::ccdb::CcdbApi::generateFileName("noise");
   auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, &info);
   info.setFileName(flName);
@@ -301,16 +301,16 @@ void NoiseCalibratorSpec::sendOutputCcdbMerge(DataAllocator& output)
   //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
   map<string, string> headers;
   map<std::string, std::string> filter;
-  auto* payloadPrev1 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPath, filter, -1, &headers);
+  auto* payloadPrev1 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, -1, &headers);
   long validtime = std::stol(headers["Valid-From"]);
   auto mergedPL = payload;
   if (validtime > 0) {
     validtime = validtime - 1;
-    auto* payloadPrev2 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPath, filter, validtime, &headers);
+    auto* payloadPrev2 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, validtime, &headers);
     auto bufferPL = payloadPrev2->merge(payloadPrev1);
     mergedPL = payload.merge(&bufferPL);
   }
-  o2::ccdb::CcdbObjectInfo info(mPathMerge, "NoiseMap", "noise.root", meta, tstart, tend);
+  o2::ccdb::CcdbObjectInfo info(mPath, "NoiseMap", "noise.root", meta, tstart, tend);
   auto flName = o2::ccdb::CcdbApi::generateFileName("noise");
   auto image = o2::ccdb::CcdbApi::createObjectImage(&mergedPL, &info);
   info.setFileName(flName);
@@ -382,6 +382,75 @@ void NoiseCalibratorSpec::sendOutputDcs(DataAllocator& output)
   output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 0}, infoDcs);
 }
 
+void NoiseCalibratorSpec::sendOutputDcsMerge(DataAllocator& output)
+{
+
+  LOG(info) << "DCS mode";
+
+  static bool done = false;
+  if (done) {
+    return;
+  }
+  done = true;
+
+  mCalibrator->finalize();
+
+  long tstart = mStart;
+  if (tstart == -1) {
+    tstart = o2::ccdb::getCurrentTimestamp();
+  }
+  long tend = mEnd;
+  if (tend == -1) {
+    constexpr long SECONDSPERYEAR = 365 * 24 * 60 * 60;
+    tend = o2::ccdb::getFutureTimestamp(SECONDSPERYEAR);
+  }
+
+  std::map<std::string, std::string> meta;
+  auto toKeyValPairs = [&meta](std::vector<std::string> const& tokens) {
+    for (auto& token : tokens) {
+      auto keyval = Str::tokenize(token, '=', false);
+      if (keyval.size() != 2) {
+        LOG(error) << "Illegal command-line key/value string: " << token;
+        continue;
+      }
+      Str::trim(keyval[1]);
+      meta[keyval[0]] = keyval[1];
+    }
+  };
+  toKeyValPairs(Str::tokenize(mMeta, ';', true));
+
+  long startTF, endTF;
+
+  auto payload = mCalibrator->getNoiseMap();
+  //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
+
+  map<string, string> headers;
+  map<std::string, std::string> filter;
+  auto* payloadPrev1 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, -1, &headers);
+  long validtime = std::stol(headers["Valid-From"]);
+  auto mergedPL = payload;
+  if (validtime > 0) {
+    validtime = validtime - 1;
+    auto* payloadPrev2 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, validtime, &headers);
+    auto bufferPL = payloadPrev2->merge(payloadPrev1);
+    mergedPL = payload.merge(&bufferPL);
+  }
+
+  setOutputDcs(mergedPL);
+  o2::ccdb::CcdbObjectInfo infoDcs(mPathDcs, "NoiseMap", "noise.root", meta, tstart, tend);
+  auto flNameDcs = o2::ccdb::CcdbApi::generateFileName("noise");
+  auto imageDcs = o2::ccdb::CcdbApi::createObjectImage(&mNoiseMapForDcs, &infoDcs);
+  infoDcs.setFileName(flNameDcs);
+  LOG(info) << "Sending object " << infoDcs.getPath() << "/" << infoDcs.getFileName()
+            << " of size " << imageDcs->size()
+            << " bytes, valid for " << infoDcs.getStartValidityTimestamp()
+            << " : " << infoDcs.getEndValidityTimestamp();
+
+  using clbUtilsDcs = o2::calibration::Utils;
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 0}, *imageDcs.get());
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 0}, infoDcs);
+}
+
 void NoiseCalibratorSpec::endOfStream(o2::framework::EndOfStreamContext& ec)
 {
   if (mOutputType.compare("CCDB") == 0) {
@@ -390,11 +459,12 @@ void NoiseCalibratorSpec::endOfStream(o2::framework::EndOfStreamContext& ec)
     LOG(info) << "Sending an object to Production-CCDB-Merge";
     sendOutputCcdbMerge(ec.outputs());
   } else if (mOutputType.compare("DCS") == 0) {
-    LOG(info) << "Sending an object to DCS-CCDB";
-    sendOutputDcs(ec.outputs());
+    LOG(info) << "Sending an object to DCS-Merge";
+    sendOutputDcsMerge(ec.outputs());
   } else {
-    LOG(info) << "Sending an object to Production-CCDB and DCS-CCDB";
-    sendOutputCcdbDcs(ec.outputs());
+    LOG(info) << "Sending an object to Production-CCDB, Production-CCDB-Merge and DCS-Merge";
+    sendOutputCcdb(ec.outputs());
+    sendOutputDcsMerge(ec.outputs());
     sendOutputCcdbMerge(ec.outputs());
   }
 }
@@ -454,7 +524,7 @@ DataProcessorSpec getNoiseCalibratorSpec(bool useDigits)
       {"tstart", VariantType::Int64, -1ll, {"Start of validity timestamp"}},
       {"tend", VariantType::Int64, -1ll, {"End of validity timestamp"}},
       {"path-CCDB", VariantType::String, "/MFT/Calib/NoiseMap", {"Path to write to in CCDB"}},
-      {"path-CCDB-merge", VariantType::String, "/MFT/Calib/NoiseMapMerged", {"Path to write merged file to in CCDB"}},
+      {"path-CCDB-single", VariantType::String, "/MFT/Calib/NoiseMapSingle", {"Path to write merged file to in CCDB"}},
       {"path-DCS", VariantType::String, "/MFT/Config/NoiseMap", {"Path to write to in DCS"}},
       {"meta", VariantType::String, "", {"meta data to write in CCDB"}},
       {"send-to-server", VariantType::String, "CCDB-DCS", {"meta data to write in DCS-CCDB"}},

From da3a178e22d4303230413ddeafa3ac4a7b5c0bd5 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Fri, 18 Jul 2025 16:29:02 +0200
Subject: [PATCH 0633/1764] NN clusterizer: Improve filling kernel speed
 (#14510)

* First version of lookup tables

* Simplifying computations + bug-fixes

* Fixes for indexing and offsets

* Adjusting CPU kernel

* Please consider the following formatting changes

* Fix for row-number access

* Please consider the following formatting changes

* Improve kernel speed by ~15%. Next test: for-loop in pad direction for coallesced access

* IMproving kernel speed by 30% compared to original version. Next try: for-loop over row dimension as access is somewhat coalsced too

* Please consider the following formatting changes

* Minor improvements for MC handling

* Beautifications to trigger the CI

* Compile-fix

* Fix int32_t error in fullCI build

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../Global/GPUChainTrackingClusterizer.cxx    |   2 +
 .../TPCClusterFinder/GPUTPCNNClusterizer.cxx  |  27 --
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |  62 ++--
 .../GPUTPCNNClusterizerHost.cxx               |  49 ++-
 .../GPUTPCNNClusterizerHost.h                 |   2 +
 .../GPUTPCNNClusterizerKernels.cxx            | 285 ++++++++++++------
 .../GPUTPCNNClusterizerKernels.h              |   2 +-
 7 files changed, 289 insertions(+), 140 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 25bfe37f0db30..13455efe6cb47 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -706,6 +706,8 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         nnApplications[lane].initClusterizer(nn_settings, clustererNNShadow);
       }
       AllocateRegisteredMemory(clustererNN.mMemoryId);
+      // nnApplications[lane].createBoundary(clustererNNShadow);
+      // nnApplications[lane].createIndexLookup(clustererNNShadow);
     });
     if (doGPU) {
       WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->tpcNNClusterer - (char*)processors(), &processorsShadow()->tpcNNClusterer, sizeof(GPUTPCNNClusterizer) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
index da37c0771fe84..3dd8b0d621a56 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
@@ -65,33 +65,6 @@ void* GPUTPCNNClusterizer::setIOPointers(void* mem)
   return mem;
 }
 
-// std::vector<int32_t> GPUTPCNNClusterizer::pointerSizes() {
-//   std::vector<int32_t> sizes(7, -1);
-//   if (mNnClusterizerBatchedMode > 0) {
-//     if (mNnInferenceInputDType == 0 && mNnClusterizerElementSize > 0) {
-//       sizes[0] = mNnClusterizerBatchedMode * mNnClusterizerElementSize; // inputData16
-//     } else if (mNnInferenceInputDType == 1 && mNnClusterizerElementSize > 0) {
-//       sizes[1] = mNnClusterizerBatchedMode * mNnClusterizerElementSize; // inputData32
-//     }
-//     sizes[2] = 2 * mNnClusterizerBatchedMode; // mClusterFlags
-//     if (mNnClusterizerModelClassNumOutputNodes > 0) {
-//       sizes[3] = mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes; // modelProbabilities
-//     }
-//     if (!mNnClusterizerUseCfRegression) {
-//       if (mNnClusterizerModelReg1NumOutputNodes > 0) {
-//         sizes[4] = mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes; // outputDataReg1
-//       }
-//       if (mNnClusterizerModelReg2NumOutputNodes > 0) {
-//         sizes[5] = mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes; // outputDataReg2
-//       }
-//     }
-//   }
-//   if (mNnClusterizerTotalClusters > 0) {
-//     sizes[6] = mNnClusterizerTotalClusters; // mOutputDataClass
-//   }
-//   return sizes;
-// }
-
 void GPUTPCNNClusterizer::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index 980c0977aca65..7c22d8123fdec 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -37,31 +37,51 @@ class GPUTPCNNClusterizer : public GPUProcessor
 
   // Neural network clusterization
 
-  int mNnClusterizerSizeInputRow = 3;
-  int mNnClusterizerSizeInputPad = 3;
-  int mNnClusterizerSizeInputTime = 3;
-  int mNnClusterizerElementSize = -1;
-  bool mNnClusterizerAddIndexData = true;
+  int32_t mNnClusterizerSizeInputRow = 3;
+  int32_t mNnClusterizerSizeInputPad = 3;
+  int32_t mNnClusterizerSizeInputTime = 3;
+  int32_t mNnClusterizerChargeArraySize = -1;
+  int32_t mNnClusterizerElementSize = -1;
+  int8_t mNnClusterizerAddIndexData = 1;
   float mNnClassThreshold = 0.01;
-  bool mNnSigmoidTrafoClassThreshold = 1;
-  bool mNnClusterizerSetDeconvolutionFlags = true;
-  int mNnClusterizerUseCfRegression = 0;
-  int mNnClusterizerBatchedMode = 1;
-  int mNnClusterizerTotalClusters = 1;
-  int mNnClusterizerVerbosity = 0;
-  int mNnClusterizerBoundaryFillValue = -1;
-  int mNnClusterizerModelClassNumOutputNodes = -1;
-  int mNnClusterizerModelReg1NumOutputNodes = -1;
-  int mNnClusterizerModelReg2NumOutputNodes = -1;
-  int mNnInferenceInputDType = 0;  // 0: float16, 1: float32
-  int mNnInferenceOutputDType = 0; // 0: float16, 1: float32
-  int mISector = -1;
-  int mDeviceId = -1;
+  int8_t mNnSigmoidTrafoClassThreshold = 1;
+  int8_t mNnClusterizerSetDeconvolutionFlags = 1;
+  int32_t mNnClusterizerUseCfRegression = 0;
+  int32_t mNnClusterizerBatchedMode = 1;
+  int32_t mNnClusterizerTotalClusters = 1;
+  int32_t mNnClusterizerVerbosity = 0;
+  int32_t mNnClusterizerBoundaryFillValue = -1;
+  int32_t mNnClusterizerModelClassNumOutputNodes = -1;
+  int32_t mNnClusterizerModelReg1NumOutputNodes = -1;
+  int32_t mNnClusterizerModelReg2NumOutputNodes = -1;
+  int32_t mNnInferenceInputDType = 0;  // 0: float16, 1: float32
+  int32_t mNnInferenceOutputDType = 0; // 0: float16, 1: float32
+  int32_t mISector = -1;
+  int32_t mDeviceId = -1;
+
+  // GPU optimizations
+  uint32_t mNnClusterizerFullRowSize = 0;
+  uint32_t mNnClusterizerFullPadSize = 0;
+  uint32_t mNnClusterizerFullTimeSize = 0;
+  uint32_t mNnClusterizerPadTimeSize = 0;
+  uint32_t mNnClusterizerRowTimeSize = 0;
+  uint32_t mNnClusterizerRowTimeSizeFull = 0;
+
+  // Boundary lookup table
+  // int32_t mBoundaryMapSizeRow = 0;
+  // int32_t mBoundaryMapSizePadsPerRow = 0;
+  // int32_t mBoundaryMapSize = 0;
+  // int32_t mBoundaryPadding = 11; // Padding on each side of the boundary map to account for pad_offset
+  // int8_t* mIsBoundary = nullptr;
+
+  // Index lookup table
+  // int32_t mIndexLookupSize = 0;
+  // int32_t* mIndexLookup = nullptr;
 
   // Memory allocation for neural network
 
-  bool* mClusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptr
-  int* mOutputDataClass = nullptr;
+  int8_t* mClusterFlags = nullptr; // mSplitInTime, mSplitInPad. Techincally both flags are set in the same way -> ClusterAccumulator.cx=nullptr
+  int32_t* mOutputDataClass = nullptr;
 
   // FP32
   float* mInputData_32 = nullptr;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index 124320396d0d4..fd56d49de7921 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -19,6 +19,8 @@
 #include "GPUSettings.h"
 #include "ML/3rdparty/GPUORTFloat16.h"
 #include "GPUReconstruction.h"
+#include "GPUTPCGeometry.h"
+#include "DataFormatsTPC/Constants.h"
 
 #ifdef GPUCA_HAS_ONNX
 #include <onnxruntime_cxx_api.h>
@@ -87,8 +89,20 @@ void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclust
   clustererNN.mNnClusterizerSizeInputRow = settings.nnClusterizerSizeInputRow;
   clustererNN.mNnClusterizerSizeInputPad = settings.nnClusterizerSizeInputPad;
   clustererNN.mNnClusterizerSizeInputTime = settings.nnClusterizerSizeInputTime;
+  clustererNN.mNnClusterizerFullRowSize = 2 * settings.nnClusterizerSizeInputRow + 1;
+  clustererNN.mNnClusterizerFullPadSize = 2 * settings.nnClusterizerSizeInputPad + 1;
+  clustererNN.mNnClusterizerFullTimeSize = 2 * settings.nnClusterizerSizeInputTime + 1;
+  clustererNN.mNnClusterizerChargeArraySize = clustererNN.mNnClusterizerFullRowSize * clustererNN.mNnClusterizerFullPadSize * clustererNN.mNnClusterizerFullTimeSize;
+  clustererNN.mNnClusterizerPadTimeSize = clustererNN.mNnClusterizerFullPadSize * clustererNN.mNnClusterizerFullTimeSize;
+  clustererNN.mNnClusterizerRowTimeSize = clustererNN.mNnClusterizerFullRowSize * clustererNN.mNnClusterizerFullTimeSize;
+  clustererNN.mNnClusterizerRowTimeSizeFull = clustererNN.mNnClusterizerRowTimeSize + (settings.nnClusterizerAddIndexData ? 3 : 0);
+  clustererNN.mNnClusterizerElementSize = clustererNN.mNnClusterizerChargeArraySize + (settings.nnClusterizerAddIndexData ? 3 : 0);
+  // clustererNN.mBoundaryMapSizeRow = 3 * clustererNN.mNnClusterizerSizeInputRow + o2::tpc::constants::MAXGLOBALPADROW;
+  // clustererNN.mBoundaryPadding = 11; // padding on each side to account for pad_offset. N=11 since then mIsBoundary = 24320 ~< (1.5 x 2^14 = 24576) && N must be bigger than (NPads[row(end_iroc + 1)] - NPads[row(end_iroc)])/2 (=6) for pad_offset to work
+  // clustererNN.mBoundaryMapSizePadsPerRow = GPUTPCGeometry::NPads(o2::tpc::constants::MAXGLOBALPADROW - 1) + 2 * clustererNN.mBoundaryPadding;
+  // clustererNN.mBoundaryMapSize = clustererNN.mBoundaryMapSizeRow * clustererNN.mBoundaryMapSizePadsPerRow;
+  // clustererNN.mIndexLookupSize = 3 * clustererNN.mNnClusterizerChargeArraySize; // local row, pad, time shift from flat index
   clustererNN.mNnClusterizerAddIndexData = settings.nnClusterizerAddIndexData;
-  clustererNN.mNnClusterizerElementSize = ((2 * settings.nnClusterizerSizeInputRow + 1) * (2 * settings.nnClusterizerSizeInputPad + 1) * (2 * settings.nnClusterizerSizeInputTime + 1)) + (settings.nnClusterizerAddIndexData ? 3 : 0);
   clustererNN.mNnClusterizerBatchedMode = settings.nnClusterizerBatchedMode;
   clustererNN.mNnClusterizerBoundaryFillValue = settings.nnClusterizerBoundaryFillValue;
   clustererNN.mNnSigmoidTrafoClassThreshold = settings.nnSigmoidTrafoClassThreshold;
@@ -116,6 +130,39 @@ void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclust
   }
 }
 
+// void GPUTPCNNClusterizerHost::createBoundary(GPUTPCNNClusterizer& clustererNN)
+// {
+//   // Call after init of the clustererNN elements
+//   for (int r = 0; r < clustererNN.mBoundaryMapSizeRow; r++) {
+//     int8_t skipCheckInRow = 0;
+//     for (int p = 0; p < clustererNN.mBoundaryMapSizePadsPerRow; p++) {
+//       int32_t i = r * clustererNN.mBoundaryMapSizePadsPerRow + p;
+//       clustererNN.mIsBoundary[i] = 1;
+//       if (!skipCheckInRow && (p >= clustererNN.mBoundaryPadding || r >= clustererNN.mNnClusterizerSizeInputRow)) {
+//         if (r < (GPUTPCGeometry::EndIROC() + clustererNN.mNnClusterizerSizeInputRow)) {
+//           clustererNN.mIsBoundary[i] = (int32_t)((p - clustererNN.mBoundaryPadding) >= static_cast<int>(GPUTPCGeometry::NPads(r - clustererNN.mNnClusterizerSizeInputRow)));
+//         } else if (r >= (GPUTPCGeometry::EndIROC() + 2 * clustererNN.mNnClusterizerSizeInputRow) && r < (o2::tpc::constants::MAXGLOBALPADROW + 2 * clustererNN.mNnClusterizerSizeInputRow)) {
+//           clustererNN.mIsBoundary[i] = (int32_t)((p - clustererNN.mBoundaryPadding) >= static_cast<int>(GPUTPCGeometry::NPads(r - 2 * clustererNN.mNnClusterizerSizeInputRow)));
+//         }
+//         skipCheckInRow = (clustererNN.mIsBoundary[i] == 1); // No need to check further pads in this row
+//       }
+//     }
+//   }
+// }
+
+// void GPUTPCNNClusterizerHost::createIndexLookup(GPUTPCNNClusterizer& clustererNN)
+// {
+//   for (int32_t i = 0; i < clustererNN.mNnClusterizerChargeArraySize; i++) {
+//     int32_t r = CAMath::Floor(i / ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1))) - clustererNN.mNnClusterizerSizeInputRow;
+//     int32_t rest_1 = i % ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1));
+//     int32_t p = CAMath::Floor(rest_1 / (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputPad;
+//     int32_t t = (rest_1 % (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputTime;
+//     clustererNN.mIndexLookup[3 * i] = r;
+//     clustererNN.mIndexLookup[3 * i + 1] = p;
+//     clustererNN.mIndexLookup[3 * i + 2] = t;
+//   }
+// }
+
 // MockedOrtAllocator implementation to be able to use volatile assignment
 struct MockedOrtAllocator : OrtAllocator {
   MockedOrtAllocator(GPUReconstruction* = nullptr, OrtMemoryInfo* = nullptr);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
index a4449165261be..ed3c80320b632 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
@@ -49,6 +49,8 @@ class GPUTPCNNClusterizerHost
 
   void init(const GPUSettingsProcessingNNclusterizer&);
   void initClusterizer(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&);
+  void createBoundary(GPUTPCNNClusterizer&);
+  void createIndexLookup(GPUTPCNNClusterizer&);
 
   // ONNX
   void directOrtAllocator(Ort::Env*, Ort::MemoryInfo*, GPUReconstruction*, bool = false);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 8cdc0684ad588..4cd0c094398df 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -53,63 +53,90 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
 template <>
 GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNCPU>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
-  uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  uint32_t write_idx = glo_idx * clustererNN.mNnClusterizerElementSize; // Potential optimization: Either choose mNnClusterizerBatchedMode as a power of 2 or calculate from threadId and blockId
+
+  uint32_t glo_idx = get_global_id(0);
+  if (glo_idx + batchStart >= clusterer.mPmemory->counters.nClusters) {
+    return;
+  }
+
+  uint32_t write_idx = glo_idx * clustererNN.mNnClusterizerElementSize;
 
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(glo_idx + batchStart, (uint32_t)(clusterer.mPmemory->counters.nClusters - 1))];
-  int32_t row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad()), time = static_cast<int>(peak.time()); // Explicit casting to avoid conversion errors
+  int32_t row = static_cast<int>(peak.row());
+  int32_t pad = static_cast<int>(peak.pad());
+  int32_t time = static_cast<int>(peak.time());
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
   int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
 
-  for (int32_t r = -clustererNN.mNnClusterizerSizeInputRow; r <= clustererNN.mNnClusterizerSizeInputRow; r++) {
-    bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
-    int32_t pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, row + r);
-    for (int32_t p = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; p++) {
-      bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow);
-      for (int32_t t = -clustererNN.mNnClusterizerSizeInputTime; t <= clustererNN.mNnClusterizerSizeInputTime; t++) {
-        int32_t time_pos = time + t;
-        if (!is_boundary && (time_pos >= 0) && (time_pos < TPC_MAX_FRAGMENT_LEN_GPU)) {
-          CfChargePos tmp_pos(row + r, pad + p, time + t);
-          if (r == 0 && !clustererNN.mClusterFlags[2 * glo_idx] && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) { // ordering is done for short circuit optimization
-            clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
-            clustererNN.mClusterFlags[2 * glo_idx + 1] = clustererNN.mClusterFlags[2 * glo_idx];
-          }
+  for (int32_t r = -clustererNN.mNnClusterizerSizeInputRow; r <= clustererNN.mNnClusterizerSizeInputRow; ++r) {
+    int32_t target_row = row + r;
+    bool is_row_boundary = (target_row < 0) || (target_row >= o2::tpc::constants::MAXGLOBALPADROW);
+    int32_t pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, target_row);
+
+    for (int32_t p = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; ++p) {
+      int32_t target_pad = pad + p;
+      bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(target_row + row_offset, target_pad, clustererNN.mNnClusterizerSizeInputRow);
+
+      for (int32_t t = -clustererNN.mNnClusterizerSizeInputTime; t <= clustererNN.mNnClusterizerSizeInputTime; ++t) {
+        int32_t target_time = time + t;
+
+        if (is_boundary || target_time < 0 || target_time >= TPC_MAX_FRAGMENT_LEN_GPU) {
+          // Fill boundary value
+          float boundary_value = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
           if (dtype == 0) {
-            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
-          } else if (dtype == 1) {
-            clustererNN.mInputData_32[write_idx] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)boundary_value;
+          } else {
+            clustererNN.mInputData_32[write_idx] = boundary_value;
           }
         } else {
-          // Filling boundary just to make sure that no values are left unintentionally
+          CfChargePos tmp_pos(target_row, target_pad, target_time);
+          float normalized_charge = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+
+          if (!clustererNN.mNnClusterizerSetDeconvolutionFlags && r == 0 && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) {
+            clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
+            clustererNN.mClusterFlags[2 * glo_idx + 1] = clustererNN.mClusterFlags[2 * glo_idx];
+          }
+
           if (dtype == 0) {
-            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
+            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)normalized_charge;
           } else {
-            clustererNN.mInputData_32[write_idx] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
+            clustererNN.mInputData_32[write_idx] = normalized_charge;
           }
         }
+        // if((CAMath::Abs(static_cast<float>(clustererNN.mInputData_16_Test[write_idx]) - static_cast<float>(clustererNN.mInputData_16[write_idx])) > 1e-4) && ((glo_idx + batchStart) < clusterer.mPmemory->counters.nClusters)) {
+        //   printf("Warning: Input data mismatch at index %d, %d - row, pad, time: %d, %d, %d : %f -> %f\n", glo_idx, glo_idx + batchStart, r, p, t,
+        //          static_cast<float>(clustererNN.mInputData_16_Test[write_idx]), static_cast<float>(clustererNN.mInputData_16[write_idx]));
+        // }
         write_idx++;
       }
     }
   }
+
   if (clustererNN.mNnClusterizerAddIndexData) {
+    float sector_norm = sector / 36.f;
+    float row_norm = row / 152.f;
+    float pad_norm = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+
     if (dtype == 0) {
-      clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(sector / 36.f);
-      clustererNN.mInputData_16[write_idx + 1] = (OrtDataType::Float16_t)(row / 152.f);
-      clustererNN.mInputData_16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
+      clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)sector_norm;
+      clustererNN.mInputData_16[write_idx + 1] = (OrtDataType::Float16_t)row_norm;
+      clustererNN.mInputData_16[write_idx + 2] = (OrtDataType::Float16_t)pad_norm;
     } else {
-      clustererNN.mInputData_32[write_idx] = sector / 36.f;
-      clustererNN.mInputData_32[write_idx + 1] = row / 152.f;
-      clustererNN.mInputData_32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+      clustererNN.mInputData_32[write_idx] = sector_norm;
+      clustererNN.mInputData_32[write_idx + 1] = row_norm;
+      clustererNN.mInputData_32[write_idx + 2] = pad_norm;
     }
   }
+
   if (!clustererNN.mNnClusterizerSetDeconvolutionFlags) {
     clustererNN.mClusterFlags[2 * glo_idx] = 0;
     clustererNN.mClusterFlags[2 * glo_idx + 1] = 0;
-    for (uint16_t i = 0; i < 8; i++) {
+
+    for (uint16_t i = 0; i < 8; ++i) {
       Delta2 d = cfconsts::InnerNeighbors[i];
       CfChargePos tmp_pos = peak.delta(d);
       clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
@@ -122,71 +149,111 @@ template <>
 GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNGPU>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   uint32_t glo_idx = get_global_id(0);
+
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  uint32_t base_idx = CAMath::Floor(glo_idx / clustererNN.mNnClusterizerElementSize);
-  uint32_t transient_index = glo_idx - (base_idx * clustererNN.mNnClusterizerElementSize);
 
+  // Optimized division using bit operations
+  uint32_t base_idx = glo_idx / clustererNN.mNnClusterizerRowTimeSizeFull;
+  uint32_t transient_index = glo_idx - (base_idx * clustererNN.mNnClusterizerRowTimeSizeFull);
+
+  // Early exit for out-of-bounds threads
+  if (base_idx + batchStart >= clusterer.mPmemory->counters.nClusters) {
+    return;
+  }
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
+
+  // Use dedicated neural network shared memory arrays for warp-level caching
+  // First thread in each warp loads shared data
   CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(base_idx + batchStart, (uint32_t)(clusterer.mPmemory->counters.nClusters - 1))];
-  int32_t row = static_cast<int>(peak.row()), pad = static_cast<int>(peak.pad());
-
-  if (clustererNN.mNnClusterizerAddIndexData && (int32_t)transient_index == (clustererNN.mNnClusterizerElementSize - 1)) {
-    uint32_t top_idx = (base_idx + 1) * clustererNN.mNnClusterizerElementSize;
-    if (!clustererNN.mNnClusterizerSetDeconvolutionFlags) { // Only if deconvolution flags are not set
-      clustererNN.mClusterFlags[2 * base_idx] = 0;
-      clustererNN.mClusterFlags[2 * base_idx + 1] = 0;
-      for (uint16_t i = 0; i < 8; i++) {                    // This solution needs testing. It is not the same as the deconvolution flags
-        Delta2 d = cfconsts::InnerNeighbors[i];
-        CfChargePos tmp_pos = peak.delta(d);
-        clustererNN.mClusterFlags[2 * base_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
-      }
-      clustererNN.mClusterFlags[2 * base_idx + 1] = clustererNN.mClusterFlags[2 * base_idx];
-    }
+  float central_charge = static_cast<float>(chargeMap[peak].unpack());
+  int32_t row = static_cast<int>(peak.row());
+  int32_t pad = static_cast<int>(peak.pad());
+  int32_t time = static_cast<int>(peak.time());
+
+  // Handle index data with fewer branches
+  if (clustererNN.mNnClusterizerAddIndexData && transient_index >= clustererNN.mNnClusterizerRowTimeSize) {
+    int32_t data_idx = transient_index - clustererNN.mNnClusterizerRowTimeSize;
+    uint32_t write_idx = base_idx * clustererNN.mNnClusterizerElementSize + clustererNN.mNnClusterizerChargeArraySize + data_idx;
+
+    float index_values[3] = {
+      sector / 36.f,
+      row / 152.f,
+      static_cast<float>(pad) / GPUTPCGeometry::NPads(row)};
+
     if (dtype == 0) {
-      clustererNN.mInputData_16[top_idx - 3] = (OrtDataType::Float16_t)(sector / 36.f);
-      clustererNN.mInputData_16[top_idx - 2] = (OrtDataType::Float16_t)(row / 152.f);
-      clustererNN.mInputData_16[top_idx - 1] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
+      clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)index_values[data_idx];
     } else {
-      clustererNN.mInputData_32[top_idx - 3] = sector / 36.f;
-      clustererNN.mInputData_32[top_idx - 2] = row / 152.f;
-      clustererNN.mInputData_32[top_idx - 1] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+      clustererNN.mInputData_32[write_idx] = index_values[data_idx];
     }
-  } else if ((int32_t)transient_index < (clustererNN.mNnClusterizerElementSize - 3)) {
-    int32_t time = static_cast<int>(peak.time());
-    int32_t r = CAMath::Floor(transient_index / ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1))) - clustererNN.mNnClusterizerSizeInputRow;
-    bool is_row_boundary = ((row + r) > (o2::tpc::constants::MAXGLOBALPADROW - 1)) || ((row + r) < 0);
-    if (is_row_boundary) {
-      if (dtype == 0) {
-        clustererNN.mInputData_16[glo_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
-      } else {
-        clustererNN.mInputData_32[glo_idx] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
-      }
-    } else {
-      int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
-      int32_t pad_offset = GPUTPCNNClusterizerKernels::padOffset(row, row + r);
-      int32_t rest_1 = transient_index % ((2 * clustererNN.mNnClusterizerSizeInputPad + 1) * (2 * clustererNN.mNnClusterizerSizeInputTime + 1));
-      int32_t p = CAMath::Floor(rest_1 / (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputPad + pad_offset;
-      int32_t time_pos = (rest_1 % (2 * clustererNN.mNnClusterizerSizeInputTime + 1)) - clustererNN.mNnClusterizerSizeInputTime + time;
 
-      bool is_boundary = GPUTPCNNClusterizerKernels::isBoundary(row + r + row_offset, pad + p, clustererNN.mNnClusterizerSizeInputRow) && (time_pos < 0 || time_pos >= TPC_MAX_FRAGMENT_LEN_GPU);
+    // Handle deconvolution flags only once per cluster (last thread in element)
+    if (data_idx == 2 && !clustererNN.mNnClusterizerSetDeconvolutionFlags) {
+      uint8_t cluster_flags = 0;
+      for (uint16_t i = 0; i < 8; i++) {
+        Delta2 d = cfconsts::InnerNeighbors[i];
+        CfChargePos tmp_pos = peak.delta(d);
+        cluster_flags += CfUtils::isPeak(isPeakMap[tmp_pos]);
+      }
+      clustererNN.mClusterFlags[2 * base_idx] = cluster_flags;
+      clustererNN.mClusterFlags[2 * base_idx + 1] = cluster_flags;
+    }
+    return;
+  }
 
-      if (!is_boundary) {
-        float central_charge = static_cast<float>(chargeMap[peak].unpack());
-        CfChargePos tmp_pos(row + r, pad + p, time_pos);
-        if (dtype == 0) {
-          clustererNN.mInputData_16[glo_idx] = (OrtDataType::Float16_t)(static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge);
-        } else if (dtype == 1) {
-          clustererNN.mInputData_32[glo_idx] = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
-        }
-      } else {
+  // Main data processing - optimize index calculations
+  if (transient_index < clustererNN.mNnClusterizerRowTimeSize) {
+    // Optimize 3D index calculation
+    int32_t row_idx = transient_index / clustererNN.mNnClusterizerFullTimeSize;
+    int32_t r_local = row_idx - clustererNN.mNnClusterizerSizeInputRow;
+    int32_t time_idx = transient_index - row_idx * clustererNN.mNnClusterizerFullTimeSize;
+    int32_t t_local = time_idx - clustererNN.mNnClusterizerSizeInputTime;
+    int32_t write_idx = base_idx * clustererNN.mNnClusterizerElementSize + row_idx * clustererNN.mNnClusterizerPadTimeSize + time_idx;
+
+    // Early boundary check for row
+    int32_t target_row = row + r_local;
+    int8_t is_row_boundary = (target_row < 0) || (target_row > (o2::tpc::constants::MAXGLOBALPADROW - 1));
+
+    // Calculate offsets
+    int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
+    int32_t pad_offset = GPUTPCNNClusterizerKernels::padOffset(row, target_row);
+    for (int32_t p_local = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p_local <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; p_local++) {
+      if (is_row_boundary) {
+        // Use boundary fill value
+        float boundary_val = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
         if (dtype == 0) {
-          clustererNN.mInputData_16[glo_idx] = (OrtDataType::Float16_t)(static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue));
+          clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)boundary_val;
         } else {
-          clustererNN.mInputData_32[glo_idx] = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
+          clustererNN.mInputData_32[write_idx] = boundary_val;
         }
+        write_idx += clustererNN.mNnClusterizerFullTimeSize; // Move to next pad position
+        continue;
       }
+
+      // Calculate target pad and time
+      int32_t target_pad = pad + p_local;
+      int32_t target_time = time + t_local;
+
+      // Optimized boundary check
+      int8_t is_boundary = GPUTPCNNClusterizerKernels::isBoundary(target_row + row_offset, target_pad, clustererNN.mNnClusterizerSizeInputRow) || (target_time < 0) || (target_time >= TPC_MAX_FRAGMENT_LEN_GPU);
+
+      float output_value;
+      if (is_boundary) {
+        output_value = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
+      } else {
+        // Coalesced memory access - create position and read charge
+        CfChargePos tmp_pos(target_row, target_pad, target_time);
+        output_value = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge; // Normalize by central charge
+      }
+
+      // Write output with reduced branching
+      if (dtype == 0) {
+        clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)output_value;
+      } else {
+        clustererNN.mInputData_32[write_idx] = output_value;
+      }
+      write_idx += clustererNN.mNnClusterizerFullTimeSize; // Move to next pad position
     }
   }
 }
@@ -242,9 +309,6 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
   uint32_t maxClusterNum = clusterer.mPmemory->counters.nClusters;
   uint32_t full_glo_idx = glo_idx + batchStart;
-  if (full_glo_idx >= maxClusterNum) {
-    return;
-  }
   int32_t model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg1NumOutputNodes;
 
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
@@ -253,6 +317,24 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
+
+  if (full_glo_idx >= maxClusterNum) {
+    if (withMC) {
+      ClusterAccumulator dummy_pc;
+      CPU_ONLY(labelAcc->collect(peak, central_charge));
+      GPUTPCCFClusterizer::buildCluster(
+        clusterer.Param().rec,
+        chargeMap,
+        peak,
+        smem.posBcast,
+        smem.buf,
+        smem.innerAboveThreshold,
+        &dummy_pc,
+        labelAcc);
+    }
+    return;
+  }
+
   tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
 
   // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.mNnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
@@ -340,6 +422,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
+  uint32_t maxClusterNum = clusterer.mPmemory->counters.nClusters;
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(glo_idx + batchStart, (uint32_t)(clusterer.mPmemory->counters.nClusters - 1))];
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
@@ -348,6 +431,24 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
   tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
   uint32_t full_glo_idx = glo_idx + batchStart;
+
+  if (full_glo_idx >= maxClusterNum) {
+    if (withMC) {
+      ClusterAccumulator dummy_pc;
+      CPU_ONLY(labelAcc->collect(peak, central_charge));
+      GPUTPCCFClusterizer::buildCluster(
+        clusterer.Param().rec,
+        chargeMap,
+        peak,
+        smem.posBcast,
+        smem.buf,
+        smem.innerAboveThreshold,
+        &dummy_pc,
+        labelAcc);
+    }
+    return;
+  }
+
   uint32_t model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg2NumOutputNodes;
 
   if (clustererNN.mOutputDataClass[full_glo_idx] > 0) {
@@ -501,24 +602,28 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 // THe following arithmetic is done because the network is trained with a split between IROC and OROC boundary
 GPUd() int32_t GPUTPCNNClusterizerKernels::padOffset(int32_t row_ref, int32_t row_current)
 {
-  return (int)((GPUTPCGeometry::NPads(row_current) - GPUTPCGeometry::NPads(row_ref)) / 2);
+  if (row_current < 0 || row_current >= o2::tpc::constants::MAXGLOBALPADROW) {
+    return 0; // Short-circuit for negative rows
+  } else {
+    return (int)((GPUTPCGeometry::NPads(row_current) - GPUTPCGeometry::NPads(row_ref)) / 2);
+  }
 }
 
-GPUd() int32_t GPUTPCNNClusterizerKernels::rowOffset(int32_t row, int32_t global_shift)
+GPUd() int32_t GPUTPCNNClusterizerKernels::rowOffset(int32_t row, int32_t offset)
 {
-  return (row > 62 ? global_shift : 0);
+  return (row > 62 ? offset : 0);
 }
 
-GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int32_t row, int32_t pad, int32_t global_shift)
+GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int32_t row, int32_t pad, int32_t offset)
 {
   if (pad < 0 || row < 0) { // Faster short-circuit
     return true;
   } else if (row < 63) {
-    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row)));
-  } else if (row < (63 + global_shift)) { // to account for the gap between IROC and OROC. Charge will be set to -1 in order to signal boundary to the neural network
+    return ((pad < 0) || (pad >= static_cast<int>(GPUTPCGeometry::NPads(row))));
+  } else if (row < (63 + offset)) { // to account for the gap between IROC and OROC. Charge will be set to the boundary fill value in order to signal boundaries to the neural network
     return true;
-  } else if (row < (o2::tpc::constants::MAXGLOBALPADROW + global_shift)) {
-    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row - global_shift)));
+  } else if (row < (o2::tpc::constants::MAXGLOBALPADROW + offset)) {
+    return ((pad < 0) || (pad >= static_cast<int>(GPUTPCGeometry::NPads(row - offset))));
   } else {
     return true;
   }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index a3858d47eb99b..5659c61894c85 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -65,7 +65,7 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
     determineClass2Labels = 4,
     publishClass1Regression = 5,
     publishClass2Regression = 6,
-    publishDeconvolutionFlags = 7
+    publishDeconvolutionFlags = 7,
   };
 
   template <int32_t iKernel = defaultKernel, typename... Args>

From 51d4f860b1e6cec83dd9fb797d787aa9384a2e48 Mon Sep 17 00:00:00 2001
From: Martin Eide <43970264+mrtineide@users.noreply.github.com>
Date: Fri, 18 Jul 2025 16:11:11 +0200
Subject: [PATCH 0634/1764] Add fully qualified names for std::string and
 std::map

The header TJAlienCredentials.h polluted the global namespace, included usually with CCDB
or something related.

Many source files in O2 took advantage of this.
This commit prepares for the removal of the polluted namespace.
The libraries/repo with TJAlienCredentials is JAliEn-ROOT and libjalieno2.
The problem was first noticed by @vkucera.
---
 CCDB/include/CCDB/CcdbApi.h                   |  2 +-
 CCDB/src/CcdbApi.cxx                          | 68 +++++++++----------
 CCDB/test/testBasicCCDBManager.cxx            |  4 +-
 CCDB/test/testCcdbApi.cxx                     | 30 ++++----
 CCDB/test/testCcdbApiMultipleUrls.cxx         | 10 +--
 CCDB/test/testCcdbApi_ConfigParam.cxx         | 10 +--
 CCDB/test/testCcdbApi_alien.cxx               |  4 +-
 .../Detectors/CTP/src/CTPRateFetcher.cxx      |  2 +-
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 10 +--
 .../calib/macros/makeBadMapFromPedestalRun.C  |  2 +-
 Detectors/CTP/macro/GetAndSave.C              |  2 +-
 Detectors/CTP/macro/SaveInputsConfig.C        |  2 +-
 Detectors/CTP/macro/TestFetcher.C             |  2 +-
 Detectors/CTP/simulation/src/Digitizer.cxx    |  2 +-
 .../workflowScalers/src/ctpCCDBManager.cxx    | 16 ++---
 Detectors/EMCAL/base/src/Geometry.cxx         |  2 +-
 Detectors/FIT/FT0/macros/FT0Misaligner.C      |  2 +-
 ...dChannelTimeOffsetFV0CalibObjectFromCCDB.C |  4 +-
 Detectors/FIT/FV0/macros/FV0Misaligner.C      |  2 +-
 .../FITDCSConfigProcessorSpec.h               |  2 +-
 .../calibration/src/GRPDCSDPsProcessor.cxx    |  6 +-
 .../GRP/workflows/src/create-grp-ecs.cxx      | 12 ++--
 .../src/tpc-residual-aggregator.cxx           |  2 +-
 .../src/TestDataReader.cxx                    |  4 +-
 .../ITSMFT/ITS/macros/test/ITSMisaligner.C    |  2 +-
 .../include/ITSWorkflow/DCSParserSpec.h       |  2 +-
 .../ITSMFT/ITS/workflow/src/DCSParserSpec.cxx |  8 +--
 .../calibration/src/NoiseCalibratorSpec.cxx   |  8 +--
 .../MFT/condition/macros/readAlpideCCDB.C     |  2 +-
 .../MUON/MCH/Align/src/AlignRecordSpec.cxx    |  6 +-
 .../MUON/MCH/Align/src/AlignmentSpec.cxx      | 16 ++---
 Detectors/MUON/MCH/Geometry/Test/Helpers.cxx  |  2 +-
 Detectors/MUON/MCH/Geometry/Test/misAlign.C   |  2 +-
 .../TPC/calibration/src/CalculatedEdx.cxx     |  6 +-
 .../TPCWorkflow/TPCCalibPadGainTracksSpec.h   |  2 +-
 Detectors/TRD/base/macros/OCDB2CCDB.C         |  2 +-
 .../TRD/base/macros/OCDB2CCDBTrapConfig.C     |  2 +-
 Detectors/TRD/base/macros/PrintTrapConfig.C   |  2 +-
 Detectors/TRD/base/macros/Readocdb.C          |  2 +-
 .../include/TRDCalibration/DCSProcessor.h     |  4 +-
 .../TRD/calibration/src/DCSProcessor.cxx      |  8 +--
 Detectors/ZDC/macro/CreateBaselineCalib.C     |  2 +-
 .../ZDC/macro/CreateBaselineCalibConfig.C     |  2 +-
 Detectors/ZDC/macro/CreateEnergyCalib.C       |  2 +-
 Detectors/ZDC/macro/CreateInterCalibConfig.C  |  2 +-
 Detectors/ZDC/macro/CreateModuleConfig.C      |  2 +-
 Detectors/ZDC/macro/CreateRecoConfigZDC.C     |  2 +-
 Detectors/ZDC/macro/CreateSimCondition.C      |  2 +-
 Detectors/ZDC/macro/CreateSimCondition_pp.C   |  2 +-
 Detectors/ZDC/macro/CreateTDCCalib.C          |  2 +-
 Detectors/ZDC/macro/CreateTDCCalibConfig.C    |  2 +-
 Detectors/ZDC/macro/CreateTDCCorr.C           |  2 +-
 Detectors/ZDC/macro/CreateTowerCalib.C        |  2 +-
 .../View/src/EventManagerFrame.cxx            |  4 +-
 GPU/Workflow/src/GPUWorkflowTPC.cxx           |  4 +-
 macro/CreateCTPOrbitResetObject.C             |  2 +-
 macro/UploadDummyAlignment.C                  |  2 +-
 macro/UploadMatBudLUT.C                       |  2 +-
 58 files changed, 158 insertions(+), 158 deletions(-)

diff --git a/CCDB/include/CCDB/CcdbApi.h b/CCDB/include/CCDB/CcdbApi.h
index 1308742b57fd0..cc8312d0bef0a 100644
--- a/CCDB/include/CCDB/CcdbApi.h
+++ b/CCDB/include/CCDB/CcdbApi.h
@@ -556,7 +556,7 @@ class CcdbApi //: public DatabaseInterface
    * @param tcl The TClass object describing the serialized type
    * @return raw pointer to created object
    */
-  void* downloadFilesystemContent(std::string const& fullUrl, std::type_info const& tinfo, std::map<string, string>* headers) const;
+  void* downloadFilesystemContent(std::string const& fullUrl, std::type_info const& tinfo, std::map<std::string, std::string>* headers) const;
 
   // initialize the TGrid (Alien connection)
   bool initTGrid() const;
diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index bb2b69e84c4f7..f187fbf57f558 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -297,7 +297,7 @@ void CcdbApi::updateMetaInformationInLocalFile(std::string const& filename, std:
  */
 std::string sanitizeObjectName(const std::string& objectName)
 {
-  string tmpObjectName = objectName;
+  std::string tmpObjectName = objectName;
   tmpObjectName.erase(std::remove_if(tmpObjectName.begin(), tmpObjectName.end(),
                                      [](auto const& c) -> bool { return (!std::isalnum(c) && c != '_' && c != '/' && c != '.'); }),
                       tmpObjectName.end());
@@ -431,7 +431,7 @@ int CcdbApi::storeAsBinaryFile(const char* buffer, size_t size, const std::strin
     CURLcode res = CURL_LAST;
 
     for (size_t hostIndex = 0; hostIndex < hostsPool.size() && res > 0; hostIndex++) {
-      string fullUrl = getFullUrlForStorage(curl, path, objectType, metadata, sanitizedStartValidityTimestamp, sanitizedEndValidityTimestamp, hostIndex);
+      std::string fullUrl = getFullUrlForStorage(curl, path, objectType, metadata, sanitizedStartValidityTimestamp, sanitizedEndValidityTimestamp, hostIndex);
       LOG(debug3) << "Full URL Encoded: " << fullUrl;
       /* what URL that receives this POST */
       curl_easy_setopt(curl, CURLOPT_URL, fullUrl.c_str());
@@ -476,30 +476,30 @@ int CcdbApi::storeAsTFile(const TObject* rootObject, std::string const& path, st
   return storeAsBinaryFile(img->data(), img->size(), info.getFileName(), info.getObjectType(), path, metadata, startValidityTimestamp, endValidityTimestamp, maxSize);
 }
 
-string CcdbApi::getFullUrlForStorage(CURL* curl, const string& path, const string& objtype,
-                                     const map<string, string>& metadata,
-                                     long startValidityTimestamp, long endValidityTimestamp, int hostIndex) const
+std::string CcdbApi::getFullUrlForStorage(CURL* curl, const std::string& path, const std::string& objtype,
+                                          const std::map<std::string, std::string>& metadata,
+                                          long startValidityTimestamp, long endValidityTimestamp, int hostIndex) const
 {
   // Prepare timestamps
-  string startValidityString = getTimestampString(startValidityTimestamp < 0 ? getCurrentTimestamp() : startValidityTimestamp);
-  string endValidityString = getTimestampString(endValidityTimestamp < 0 ? getFutureTimestamp(60 * 60 * 24 * 1) : endValidityTimestamp);
+  std::string startValidityString = getTimestampString(startValidityTimestamp < 0 ? getCurrentTimestamp() : startValidityTimestamp);
+  std::string endValidityString = getTimestampString(endValidityTimestamp < 0 ? getFutureTimestamp(60 * 60 * 24 * 1) : endValidityTimestamp);
   // Get url
-  string url = getHostUrl(hostIndex);
+  std::string url = getHostUrl(hostIndex);
   // Build URL
-  string fullUrl = url + "/" + path + "/" + startValidityString + "/" + endValidityString + "/";
+  std::string fullUrl = url + "/" + path + "/" + startValidityString + "/" + endValidityString + "/";
   // Add type as part of metadata
   // we need to URL encode the object type, since in case it has special characters (like the "<", ">" for templated classes) it won't work otherwise
   char* objtypeEncoded = curl_easy_escape(curl, objtype.c_str(), objtype.size());
-  fullUrl += "ObjectType=" + string(objtypeEncoded) + "/";
+  fullUrl += "ObjectType=" + std::string(objtypeEncoded) + "/";
   curl_free(objtypeEncoded);
   // Add general metadata
   for (auto& kv : metadata) {
-    string mfirst = kv.first;
-    string msecond = kv.second;
+    std::string mfirst = kv.first;
+    std::string msecond = kv.second;
     // same trick for the metadata as for the object type
     char* mfirstEncoded = curl_easy_escape(curl, mfirst.c_str(), mfirst.size());
     char* msecondEncoded = curl_easy_escape(curl, msecond.c_str(), msecond.size());
-    fullUrl += string(mfirstEncoded) + "=" + string(msecondEncoded) + "/";
+    fullUrl += std::string(mfirstEncoded) + "=" + std::string(msecondEncoded) + "/";
     curl_free(mfirstEncoded);
     curl_free(msecondEncoded);
   }
@@ -507,26 +507,26 @@ string CcdbApi::getFullUrlForStorage(CURL* curl, const string& path, const strin
 }
 
 // todo make a single method of the one above and below
-string CcdbApi::getFullUrlForRetrieval(CURL* curl, const string& path, const map<string, string>& metadata, long timestamp, int hostIndex) const
+std::string CcdbApi::getFullUrlForRetrieval(CURL* curl, const std::string& path, const std::map<std::string, std::string>& metadata, long timestamp, int hostIndex) const
 {
   if (mInSnapshotMode) {
     return getSnapshotFile(mSnapshotTopPath, path);
   }
 
   // Prepare timestamps
-  string validityString = getTimestampString(timestamp < 0 ? getCurrentTimestamp() : timestamp);
+  std::string validityString = getTimestampString(timestamp < 0 ? getCurrentTimestamp() : timestamp);
   // Get host url
-  string hostUrl = getHostUrl(hostIndex);
+  std::string hostUrl = getHostUrl(hostIndex);
   // Build URL
-  string fullUrl = hostUrl + "/" + path + "/" + validityString + "/";
+  std::string fullUrl = hostUrl + "/" + path + "/" + validityString + "/";
   // Add metadata
   for (auto& kv : metadata) {
-    string mfirst = kv.first;
-    string msecond = kv.second;
+    std::string mfirst = kv.first;
+    std::string msecond = kv.second;
     // trick for the metadata in case it contains special characters
     char* mfirstEncoded = curl_easy_escape(curl, mfirst.c_str(), mfirst.size());
     char* msecondEncoded = curl_easy_escape(curl, msecond.c_str(), msecond.size());
-    fullUrl += string(mfirstEncoded) + "=" + string(msecondEncoded) + "/";
+    fullUrl += std::string(mfirstEncoded) + "=" + std::string(msecondEncoded) + "/";
     curl_free(mfirstEncoded);
     curl_free(msecondEncoded);
   }
@@ -755,7 +755,7 @@ bool CcdbApi::receiveObject(void* dataHolder, std::string const& path, std::map<
     CURLcode curlResultCode = CURL_LAST;
 
     for (size_t hostIndex = 0; hostIndex < hostsPool.size() && (responseCode >= 400 || curlResultCode > 0); hostIndex++) {
-      string fullUrl = getFullUrlForRetrieval(curlHandle, path, metadata, timestamp, hostIndex);
+      std::string fullUrl = getFullUrlForRetrieval(curlHandle, path, metadata, timestamp, hostIndex);
       curl_easy_setopt(curlHandle, CURLOPT_URL, fullUrl.c_str());
 
       curlResultCode = CURL_perform(curlHandle);
@@ -885,7 +885,7 @@ void CcdbApi::snapshot(std::string const& ccdbrootpath, std::string const& local
 {
   // query all subpaths to ccdbrootpath
   const auto allfolders = getAllFolders(ccdbrootpath);
-  std::map<string, string> metadata;
+  std::map<std::string, std::string> metadata;
   for (auto& folder : allfolders) {
     retrieveBlob(folder, localDir, metadata, timestamp);
   }
@@ -977,7 +977,7 @@ bool CcdbApi::initTGrid() const
   return gGrid != nullptr;
 }
 
-void* CcdbApi::downloadFilesystemContent(std::string const& url, std::type_info const& tinfo, std::map<string, string>* headers) const
+void* CcdbApi::downloadFilesystemContent(std::string const& url, std::type_info const& tinfo, std::map<std::string, std::string>* headers) const
 {
   if ((url.find("alien:/", 0) != std::string::npos) && !initTGrid()) {
     return nullptr;
@@ -1016,7 +1016,7 @@ void* CcdbApi::interpretAsTMemFileAndExtract(char* contentptr, size_t contentsiz
 }
 
 // navigate sequence of URLs until TFile content is found; object is extracted and returned
-void* CcdbApi::navigateURLsAndRetrieveContent(CURL* curl_handle, std::string const& url, std::type_info const& tinfo, std::map<string, string>* headers) const
+void* CcdbApi::navigateURLsAndRetrieveContent(CURL* curl_handle, std::string const& url, std::type_info const& tinfo, std::map<std::string, std::string>* headers) const
 {
   // a global internal data structure that can be filled with HTTP header information
   // static --> to avoid frequent alloc/dealloc as optimization
@@ -1164,7 +1164,7 @@ void* CcdbApi::retrieveFromTFile(std::type_info const& tinfo, std::string const&
 
   CURL* curl_handle = curl_easy_init();
   curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, mUniqueAgentID.c_str());
-  string fullUrl = getFullUrlForRetrieval(curl_handle, path, metadata, timestamp); // todo check if function still works correctly in case mInSnapshotMode
+  std::string fullUrl = getFullUrlForRetrieval(curl_handle, path, metadata, timestamp); // todo check if function still works correctly in case mInSnapshotMode
   // if we are in snapshot mode we can simply open the file; extract the object and return
   if (mInSnapshotMode) {
     auto res = extractFromLocalFile(fullUrl, tinfo, headers);
@@ -1218,8 +1218,8 @@ std::string CcdbApi::list(std::string const& path, bool latestOnly, std::string
     curl_easy_setopt(curl, CURLOPT_USERAGENT, mUniqueAgentID.c_str());
 
     struct curl_slist* headers = nullptr;
-    headers = curl_slist_append(headers, (string("Accept: ") + returnFormat).c_str());
-    headers = curl_slist_append(headers, (string("Content-Type: ") + returnFormat).c_str());
+    headers = curl_slist_append(headers, (std::string("Accept: ") + returnFormat).c_str());
+    headers = curl_slist_append(headers, (std::string("Content-Type: ") + returnFormat).c_str());
     if (createdNotAfter >= 0) {
       headers = curl_slist_append(headers, ("If-Not-After: " + std::to_string(createdNotAfter)).c_str());
     }
@@ -1230,7 +1230,7 @@ std::string CcdbApi::list(std::string const& path, bool latestOnly, std::string
 
     curlSetSSLOptions(curl);
 
-    string fullUrl;
+    std::string fullUrl;
     // Perform the request, res will get the return code
     for (size_t hostIndex = 0; hostIndex < hostsPool.size() && res != CURLE_OK; hostIndex++) {
       fullUrl = getHostUrl(hostIndex);
@@ -1290,7 +1290,7 @@ void CcdbApi::truncate(std::string const& path) const
   CURLcode res;
   stringstream fullUrl;
   for (size_t i = 0; i < hostsPool.size(); i++) {
-    string url = getHostUrl(i);
+    std::string url = getHostUrl(i);
     fullUrl << url << "/truncate/" << path;
 
     curl = curl_easy_init();
@@ -1436,7 +1436,7 @@ std::map<std::string, std::string> CcdbApi::retrieveHeaders(std::string const& p
   auto do_remote_header_call = [this, &path, &metadata, timestamp]() -> std::map<std::string, std::string> {
     CURL* curl = curl_easy_init();
     CURLcode res = CURL_LAST;
-    string fullUrl = getFullUrlForRetrieval(curl, path, metadata, timestamp);
+    std::string fullUrl = getFullUrlForRetrieval(curl, path, metadata, timestamp);
     std::map<std::string, std::string> headers;
 
     if (curl != nullptr) {
@@ -1632,12 +1632,12 @@ int CcdbApi::updateMetadata(std::string const& path, std::map<std::string, std::
       fullUrl << "?";
 
       for (auto& kv : metadata) {
-        string mfirst = kv.first;
-        string msecond = kv.second;
+        std::string mfirst = kv.first;
+        std::string msecond = kv.second;
         // same trick for the metadata as for the object type
         char* mfirstEncoded = curl_easy_escape(curl, mfirst.c_str(), mfirst.size());
         char* msecondEncoded = curl_easy_escape(curl, msecond.c_str(), msecond.size());
-        fullUrl << string(mfirstEncoded) + "=" + string(msecondEncoded) + "&";
+        fullUrl << std::string(mfirstEncoded) + "=" + std::string(msecondEncoded) + "&";
         curl_free(mfirstEncoded);
         curl_free(msecondEncoded);
       }
@@ -1728,7 +1728,7 @@ void CcdbApi::scheduleDownload(RequestContext& requestContext, size_t* requestCo
 
   CURL* curl_handle = curl_easy_init();
   curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, mUniqueAgentID.c_str());
-  string fullUrl = getFullUrlForRetrieval(curl_handle, requestContext.path, requestContext.metadata, requestContext.timestamp);
+  std::string fullUrl = getFullUrlForRetrieval(curl_handle, requestContext.path, requestContext.metadata, requestContext.timestamp);
   curl_slist* options_list = nullptr;
   initCurlHTTPHeaderOptionsForRetrieve(curl_handle, options_list, requestContext.timestamp, &requestContext.headers,
                                        requestContext.etag, requestContext.createdNotAfter, requestContext.createdNotBefore);
diff --git a/CCDB/test/testBasicCCDBManager.cxx b/CCDB/test/testBasicCCDBManager.cxx
index 7cd143f655547..6359bf2f5ccf4 100644
--- a/CCDB/test/testBasicCCDBManager.cxx
+++ b/CCDB/test/testBasicCCDBManager.cxx
@@ -26,7 +26,7 @@
 
 using namespace o2::ccdb;
 
-static string basePath;
+static std::string basePath;
 std::string ccdbUrl = "http://ccdb-test.cern.ch:8080";
 bool hostReachable = false;
 
@@ -43,7 +43,7 @@ struct Fixture {
     std::cout << "Is host reachable ? --> " << hostReachable << std::endl;
     char hostname[_POSIX_HOST_NAME_MAX];
     gethostname(hostname, _POSIX_HOST_NAME_MAX);
-    basePath = string("Test/") + hostname + "/pid" + getpid() + "/BasicCCDBManager/";
+    basePath = std::string("Test/") + hostname + "/pid" + getpid() + "/BasicCCDBManager/";
     std::cout << "Path we will use in this test suite : " + basePath << std::endl;
   }
   ~Fixture()
diff --git a/CCDB/test/testCcdbApi.cxx b/CCDB/test/testCcdbApi.cxx
index c834f2f30f64a..0ba037710cf62 100644
--- a/CCDB/test/testCcdbApi.cxx
+++ b/CCDB/test/testCcdbApi.cxx
@@ -45,8 +45,8 @@ using namespace o2::ccdb;
 namespace utf = boost::unit_test;
 namespace tt = boost::test_tools;
 
-static string ccdbUrl;
-static string basePath;
+static std::string ccdbUrl;
+static std::string basePath;
 bool hostReachable = false;
 
 /**
@@ -63,7 +63,7 @@ struct Fixture {
     cout << "Is host reachable ? --> " << hostReachable << endl;
     char hostname[_POSIX_HOST_NAME_MAX];
     gethostname(hostname, _POSIX_HOST_NAME_MAX);
-    basePath = string("Test/TestCcdbApi/") + hostname + "/pid" + getpid() + "/";
+    basePath = std::string("Test/TestCcdbApi/") + hostname + "/pid" + getpid() + "/";
     // Replace dashes by underscores to avoid problems in the creation of local directories
     std::replace(basePath.begin(), basePath.end(), '-','_');
     cout << "Path we will use in this test suite : " + basePath << endl;
@@ -72,7 +72,7 @@ struct Fixture {
   {
     if (hostReachable) {
       CcdbApi api;
-      map<string, string> metadata;
+      std::map<std::string, std::string> metadata;
       api.init(ccdbUrl);
       api.truncate(basePath + "*");
       cout << "Test data truncated (" << basePath << ")" << endl;
@@ -104,7 +104,7 @@ struct test_fixture {
   ~test_fixture() = default;
 
   CcdbApi api;
-  map<string, string> metadata;
+  std::map<std::string, std::string> metadata;
 };
 
 BOOST_AUTO_TEST_CASE(storeTMemFile_test, *utf::precondition(if_reachable()))
@@ -153,7 +153,7 @@ BOOST_AUTO_TEST_CASE(store_retrieve_TMemFile_templated_test, *utf::precondition(
   BOOST_CHECK(f.api.retrieveFromTFileAny<o2::utils::RootChain>(basePath + "CCDBPath", f.metadata) == nullptr);
 
   // try to get the headers back and to find the metadata
-  map<string, string> md;
+  std::map<std::string, std::string> md;
   path2 = f.api.retrieveFromTFileAny<o2::ccdb::IdPath>(basePath + "CCDBPath", f.metadata, -1, &md);
   BOOST_CHECK_EQUAL(md.count("Hello"), 1);
   BOOST_CHECK_EQUAL(md["Hello"], "World");
@@ -345,7 +345,7 @@ BOOST_AUTO_TEST_CASE(delete_test, *utf::precondition(if_reachable()))
   BOOST_CHECK(h2 == nullptr);
 }
 
-void countItems(const string& s, int& countObjects, int& countSubfolders)
+void countItems(const std::string& s, int& countObjects, int& countSubfolders)
 {
   countObjects = 0;
   countSubfolders = 0;
@@ -368,7 +368,7 @@ BOOST_AUTO_TEST_CASE(list_test, *utf::precondition(if_reachable()))
   test_fixture f;
 
   // test non-empty top dir
-  string s = f.api.list("", "application/json"); // top dir
+  std::string s = f.api.list("", "application/json"); // top dir
   long nbLines = std::count(s.begin(), s.end(), '\n') + 1;
   BOOST_CHECK(nbLines > 5);
 
@@ -436,7 +436,7 @@ BOOST_AUTO_TEST_CASE(TestHeaderParsing)
 BOOST_AUTO_TEST_CASE(TestFetchingHeaders, *utf::precondition(if_reachable()))
 {
   // first store the object
-  string objectPath = basePath + "objectETag";
+  std::string objectPath = basePath + "objectETag";
   test_fixture f;
   TH1F h1("objectETag", "objectETag", 100, 0, 99);
   f.api.storeAsTFile(&h1, objectPath, f.metadata);
@@ -445,7 +445,7 @@ BOOST_AUTO_TEST_CASE(TestFetchingHeaders, *utf::precondition(if_reachable()))
   std::string etag;
   std::vector<std::string> headers;
   std::vector<std::string> pfns;
-  string path = objectPath + "/" + std::to_string(getCurrentTimestamp());
+  std::string path = objectPath + "/" + std::to_string(getCurrentTimestamp());
   auto updated = CcdbApi::getCCDBEntryHeaders("http://ccdb-test.cern.ch:8080/" + path, etag, headers);
   BOOST_CHECK_EQUAL(updated, true);
   BOOST_REQUIRE(headers.size() != 0);
@@ -462,7 +462,7 @@ BOOST_AUTO_TEST_CASE(TestRetrieveHeaders, *utf::precondition(if_reachable()))
 
   TH1F h1("object1", "object1", 100, 0, 99);
   cout << "storing object 1 in " << basePath << "Test" << endl;
-  map<string, string> metadata;
+  std::map<std::string, std::string> metadata;
   metadata["custom"] = "whatever";
   f.api.storeAsTFile(&h1, basePath + "Test", metadata);
 
@@ -498,7 +498,7 @@ BOOST_AUTO_TEST_CASE(TestUpdateMetadata, *utf::precondition(if_reachable()))
   // upload an object
   TH1F h1("object1", "object1", 100, 0, 99);
   cout << "storing object 1 in " << basePath << "Test" << endl;
-  map<string, string> metadata;
+  std::map<std::string, std::string> metadata;
   metadata["custom"] = "whatever";
   metadata["id"] = "first";
   f.api.storeAsTFile(&h1, basePath + "Test", metadata);
@@ -507,10 +507,10 @@ BOOST_AUTO_TEST_CASE(TestUpdateMetadata, *utf::precondition(if_reachable()))
   std::map<std::string, std::string> headers = f.api.retrieveHeaders(basePath + "Test", metadata);
   BOOST_CHECK(headers.count("custom") > 0);
   BOOST_CHECK(headers.at("custom") == "whatever");
-  string firstID = headers.at("ETag");
+  std::string firstID = headers.at("ETag");
   firstID.erase(std::remove(firstID.begin(), firstID.end(), '"'), firstID.end());
 
-  map<string, string> newMetadata;
+  std::map<std::string, std::string> newMetadata;
   newMetadata["custom"] = "somethingelse";
 
   // update the metadata and check
@@ -529,7 +529,7 @@ BOOST_AUTO_TEST_CASE(TestUpdateMetadata, *utf::precondition(if_reachable()))
   // get id
   cout << "get id" << endl;
   headers = f.api.retrieveHeaders(basePath + "Test", metadata);
-  string secondID = headers.at("ETag");
+  std::string secondID = headers.at("ETag");
   secondID.erase(std::remove(secondID.begin(), secondID.end(), '"'), secondID.end());
 
   // update the metadata by id
diff --git a/CCDB/test/testCcdbApiMultipleUrls.cxx b/CCDB/test/testCcdbApiMultipleUrls.cxx
index 331d0553c3aec..07ab0ddcb4dcf 100644
--- a/CCDB/test/testCcdbApiMultipleUrls.cxx
+++ b/CCDB/test/testCcdbApiMultipleUrls.cxx
@@ -24,8 +24,8 @@ using namespace o2::ccdb;
 namespace utf = boost::unit_test;
 namespace tt = boost::test_tools;
 
-static string ccdbUrl;
-static string basePath;
+static std::string ccdbUrl;
+static std::string basePath;
 bool hostReachable = false;
 
 /**
@@ -40,14 +40,14 @@ struct Fixture {
     cout << "ccdb url: " << ccdbUrl << endl;
     hostReachable = api.isHostReachable();
     cout << "Is host reachable ? --> " << hostReachable << endl;
-    basePath = string("Test/pid") + getpid() + "/";
+    basePath = std::string("Test/pid") + getpid() + "/";
     cout << "Path we will use in this test suite : " + basePath << endl;
   }
   ~Fixture()
   {
     if (hostReachable) {
       CcdbApi api;
-      map<string, string> metadata;
+      std::map<std::string, std::string> metadata;
       api.init(ccdbUrl);
       api.truncate(basePath + "*");
       cout << "Test data truncated (" << basePath << ")" << endl;
@@ -79,7 +79,7 @@ struct test_fixture {
   ~test_fixture() = default;
 
   CcdbApi api;
-  map<string, string> metadata;
+  std::map<std::string, std::string> metadata;
 };
 
 BOOST_AUTO_TEST_CASE(storeAndRetrieve, *utf::precondition(if_reachable()))
diff --git a/CCDB/test/testCcdbApi_ConfigParam.cxx b/CCDB/test/testCcdbApi_ConfigParam.cxx
index 8b3521bfd468a..568669d05978f 100644
--- a/CCDB/test/testCcdbApi_ConfigParam.cxx
+++ b/CCDB/test/testCcdbApi_ConfigParam.cxx
@@ -47,8 +47,8 @@ using namespace o2::ccdb;
 namespace utf = boost::unit_test;
 namespace tt = boost::test_tools;
 
-static string ccdbUrl;
-static string basePath;
+static std::string ccdbUrl;
+static std::string basePath;
 bool hostReachable = false;
 
 /**
@@ -64,14 +64,14 @@ struct Fixture {
     hostReachable = api.isHostReachable();
     char hostname[_POSIX_HOST_NAME_MAX];
     gethostname(hostname, _POSIX_HOST_NAME_MAX);
-    basePath = string("Test/") + hostname + "/pid" + getpid() + "/";
+    basePath = std::string("Test/") + hostname + "/pid" + getpid() + "/";
     cout << "Path we will use in this test suite : " + basePath << endl;
   }
   ~Fixture()
   {
     if (hostReachable) {
       CcdbApi api;
-      map<string, string> metadata;
+      std::map<std::string, std::string> metadata;
       api.init(ccdbUrl);
       api.truncate(basePath + "*");
       cout << "Test data truncated (" << basePath << ")" << endl;
@@ -103,7 +103,7 @@ struct test_fixture {
   ~test_fixture() = default;
 
   CcdbApi api;
-  map<string, string> metadata;
+  std::map<std::string, std::string> metadata;
 };
 
 BOOST_AUTO_TEST_CASE(testConfigParamRetrieval, *utf::precondition(if_reachable()))
diff --git a/CCDB/test/testCcdbApi_alien.cxx b/CCDB/test/testCcdbApi_alien.cxx
index f11f579346524..c50f83466fe06 100644
--- a/CCDB/test/testCcdbApi_alien.cxx
+++ b/CCDB/test/testCcdbApi_alien.cxx
@@ -29,7 +29,7 @@ using namespace o2::ccdb;
 namespace utf = boost::unit_test;
 namespace tt = boost::test_tools;
 
-static string ccdbUrl;
+static std::string ccdbUrl;
 bool hostReachable = false;
 
 /**
@@ -71,7 +71,7 @@ struct test_fixture {
   ~test_fixture() = default;
 
   CcdbApi api;
-  map<string, string> metadata;
+  std::map<std::string, std::string> metadata;
 };
 
 // handle the case where the object comes from alien and redirect does not work with curl
diff --git a/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx b/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
index d899fcafec47d..5f31fe5741240 100644
--- a/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
+++ b/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
@@ -254,7 +254,7 @@ void CTPRateFetcher::setupRun(int runNumber, o2::ccdb::BasicCCDBManager* ccdb, u
     return;
   }
   mLHCIFdata = *ptrLHCIFdata;
-  std::map<string, string> metadata;
+  std::map<std::string, std::string> metadata;
   metadata["runNumber"] = std::to_string(mRunNumber);
   auto ptrConfig = ccdb->getSpecific<ctp::CTPConfiguration>("CTP/Config/Config", timeStamp, metadata);
   if (ptrConfig == nullptr) {
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index ac7fc06a2d5da..7d9b6c7902360 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -1674,11 +1674,11 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
 {
   mTimer.Stop();
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
-  mLPMProdTag = ic.options().get<string>("lpmp-prod-tag");
-  mAnchorPass = ic.options().get<string>("anchor-pass");
-  mAnchorProd = ic.options().get<string>("anchor-prod");
-  mUser = ic.options().get<string>("created-by");
-  mRecoPass = ic.options().get<string>("reco-pass");
+  mLPMProdTag = ic.options().get<std::string>("lpmp-prod-tag");
+  mAnchorPass = ic.options().get<std::string>("anchor-pass");
+  mAnchorProd = ic.options().get<std::string>("anchor-prod");
+  mUser = ic.options().get<std::string>("created-by");
+  mRecoPass = ic.options().get<std::string>("reco-pass");
   mTFNumber = ic.options().get<int64_t>("aod-timeframe-id");
   mRecoOnly = ic.options().get<int>("reco-mctracks-only");
   mTruncate = ic.options().get<int>("enable-truncation");
diff --git a/Detectors/CPV/calib/macros/makeBadMapFromPedestalRun.C b/Detectors/CPV/calib/macros/makeBadMapFromPedestalRun.C
index 3b5af09190fe7..9d62cf1a13baa 100644
--- a/Detectors/CPV/calib/macros/makeBadMapFromPedestalRun.C
+++ b/Detectors/CPV/calib/macros/makeBadMapFromPedestalRun.C
@@ -75,7 +75,7 @@ void makeBadMapFromPedestalRun(const char* ccdbURI = "http://ccdb-test.cern.ch:8
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdbURI);            // or http://localhost:8080 for a local installation
   api.storeAsTFileAny(&badMap, "CPV/Calib/BadChannelMap", metadata, timeStamp, timeStamp + 31536000000);
 }
diff --git a/Detectors/CTP/macro/GetAndSave.C b/Detectors/CTP/macro/GetAndSave.C
index 345bb1caf4a96..ff70a3055c957 100644
--- a/Detectors/CTP/macro/GetAndSave.C
+++ b/Detectors/CTP/macro/GetAndSave.C
@@ -44,7 +44,7 @@ void GetAndSave(std::string ccdbHost = "http://ccdb-test.cern.ch:8080")
   for (auto const& run : runs) {
     CTPConfiguration ctpcfg;
     CTPRunScalers scl;
-    map<string, string> metadata; // can be empty
+    std::map<std::string, std::string> metadata; // can be empty
     metadata["runNumber"] = run;
     CTPRunScalers* ctpscalers = mgr.getSpecific<CTPRunScalers>(CCDBPathCTPScalers, timestamps[i], metadata);
     if (ctpscalers == nullptr) {
diff --git a/Detectors/CTP/macro/SaveInputsConfig.C b/Detectors/CTP/macro/SaveInputsConfig.C
index 99cae77905541..459fbf4024c95 100644
--- a/Detectors/CTP/macro/SaveInputsConfig.C
+++ b/Detectors/CTP/macro/SaveInputsConfig.C
@@ -41,7 +41,7 @@ void SaveInputsConfig(std::string filename = "inputs.cfg", std::string ccdbHost
   long tmax = timeStamp + time365days;
   o2::ccdb::CcdbApi api;
   api.init(ccdbHost);           // or http://localhost:8080 for a local installation
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   // store abitrary user object in strongly typed manner
   api.storeAsTFileAny(&ctpcfginps, "CTP/Calib/Inputs", metadata, tmin, tmax);
 }
diff --git a/Detectors/CTP/macro/TestFetcher.C b/Detectors/CTP/macro/TestFetcher.C
index 2d73b83cd174e..b2b6912f49911 100644
--- a/Detectors/CTP/macro/TestFetcher.C
+++ b/Detectors/CTP/macro/TestFetcher.C
@@ -27,7 +27,7 @@ void TestFetcher(int runNumber = 557251)
   fetcher.setupRun(runNumber, &ccdb, ts, 0);
   ccdb.setURL("http://ali-qcdb-gpn.cern.ch:8083/");
   std::string QCDBPathCTPScalers = "qc/CTP/Scalers";
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   std::string run = std::to_string(runNumber);
   metadata["runNumber"] = run;
   CTPRunScalers* ctpscalers = ccdb.getSpecific<CTPRunScalers>(QCDBPathCTPScalers, ts, metadata);
diff --git a/Detectors/CTP/simulation/src/Digitizer.cxx b/Detectors/CTP/simulation/src/Digitizer.cxx
index 55893cb0269da..b1d4ef40b7b0e 100644
--- a/Detectors/CTP/simulation/src/Digitizer.cxx
+++ b/Detectors/CTP/simulation/src/Digitizer.cxx
@@ -194,7 +194,7 @@ o2::ctp::CTPConfiguration* Digitizer::getDefaultCTPConfiguration()
   }
   auto& mgr = o2::ccdb::BasicCCDBManager::instance();
   mgr.setURL(mCCDBServer);
-  map<string, string> metadata = {};
+  std::map<std::string, std::string> metadata = {};
   long timestamp = 1546300800000;
 
   auto config = mgr.getSpecific<CTPConfiguration>(o2::ctp::CCDBPathCTPConfig, timestamp, metadata);
diff --git a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
index 58850d88eb2c6..77d3f03bbbde2 100644
--- a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
@@ -40,7 +40,7 @@ int ctpCCDBManager::saveRunScalersToCCDB(CTPRunScalers& scalers, long timeStart,
   long tmin = timeStart - time10min;
   long tmax = timeStop + time3days;
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   metadata["runNumber"] = std::to_string(scalers.getRunNumber());
   api.init(mCCDBHost.c_str()); // or http://localhost:8080 for a local installation
   // store abitrary user object in strongly typed manner
@@ -68,7 +68,7 @@ int ctpCCDBManager::saveRunScalersToQCDB(CTPRunScalers& scalers, long timeStart,
   long tmin = timeStart - time10min;
   long tmax = timeStop + time3days;
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   metadata["runNumber"] = std::to_string(scalers.getRunNumber());
   api.init(mQCDBHost.c_str()); // or http://localhost:8080 for a local installation
   // store abitrary user object in strongly typed manner
@@ -95,7 +95,7 @@ int ctpCCDBManager::saveRunConfigToCCDB(CTPConfiguration* cfg, long timeStart)
   long tmin = timeStart - time10min;
   long tmax = timeStart + time3days;
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   metadata["runNumber"] = std::to_string(cfg->getRunNumber());
   api.init(mCCDBHost.c_str()); // or http://localhost:8080 for a local installation
   // store abitrary user object in strongly typed manner
@@ -125,7 +125,7 @@ int ctpCCDBManager::saveSoxOrbit(uint32_t runNumber, uint32_t soxOrbit, long tim
   long tmin = timestamp / 1000;
   long tmax = tmin + 381928219;
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   metadata["runNumber"] = std::to_string(runNumber);
   api.init(mCCDBHost.c_str()); // or http://localhost:8080 for a local installation
 
@@ -155,7 +155,7 @@ int ctpCCDBManager::saveOrbitReset(long timeStamp)
   long tmin = timeStamp / 1000;
   long tmax = tmin + 381928219;
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(mCCDBHost.c_str());  // or http://localhost:8080 for a local installation
 
   // store abitrary user object in strongly typed manner
@@ -184,7 +184,7 @@ int ctpCCDBManager::saveCtpCfg(uint32_t runNumber, long timeStart)
     long tmin = timeStart - time10min;
     long tmax = timeStart + time3days;
     o2::ccdb::CcdbApi api;
-    map<string, string> metadata; // can be empty
+    std::map<std::string, std::string> metadata; // can be empty
     metadata["runNumber"] = std::to_string(runNumber);
     api.init(mCCDBHost.c_str()); // or http://localhost:8080 for a local installation
     // store abitrary user object in strongly typed manner
@@ -201,7 +201,7 @@ CTPConfiguration ctpCCDBManager::getConfigFromCCDB(long timestamp, std::string r
 {
   auto& mgr = o2::ccdb::BasicCCDBManager::instance();
   mgr.setURL(mCCDBHost);
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   metadata["runNumber"] = run;
   auto ctpconfigdb = mgr.getSpecific<CTPConfiguration>(CCDBPathCTPConfig, timestamp, metadata);
   if (ctpconfigdb == nullptr) {
@@ -228,7 +228,7 @@ CTPRunScalers ctpCCDBManager::getScalersFromCCDB(long timestamp, std::string run
 {
   auto& mgr = o2::ccdb::BasicCCDBManager::instance();
   mgr.setURL(mCCDBHost);
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   metadata["runNumber"] = run;
   auto ctpscalers = mgr.getSpecific<CTPRunScalers>(mCCDBPathCTPScalers, timestamp, metadata);
   if (ctpscalers == nullptr) {
diff --git a/Detectors/EMCAL/base/src/Geometry.cxx b/Detectors/EMCAL/base/src/Geometry.cxx
index 6039c18dd34e4..c194f570e47d1 100644
--- a/Detectors/EMCAL/base/src/Geometry.cxx
+++ b/Detectors/EMCAL/base/src/Geometry.cxx
@@ -1790,7 +1790,7 @@ void Geometry::SetMisalMatrixFromCcdb(const char* path, int timestamp) const
 {
   LOG(info) << "Using CCDB to obtain EMCal alignment.";
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init("http://alice-ccdb.cern.ch");
   TObjArray* matrices = api.retrieveFromTFileAny<TObjArray>(path, metadata, timestamp);
 
diff --git a/Detectors/FIT/FT0/macros/FT0Misaligner.C b/Detectors/FIT/FT0/macros/FT0Misaligner.C
index 9621d1a079bc9..16476ae3b8ccc 100644
--- a/Detectors/FIT/FT0/macros/FT0Misaligner.C
+++ b/Detectors/FIT/FT0/macros/FT0Misaligner.C
@@ -55,7 +55,7 @@ void FT0Misaligner(const std::string& ccdbHost = "http://ccdb-test.cern.ch:8080"
     std::string path = objectPath.empty() ? o2::base::DetectorNameConf::getAlignmentPath(detFT0) : objectPath;
     LOGP(info, "Storing alignment object on {}/{}", ccdbHost, path);
     o2::ccdb::CcdbApi api;
-    map<string, string> metadata; // can be empty
+    std::map<std::string, std::string> metadata; // can be empty
     api.init(ccdbHost.c_str());   // or http://localhost:8080 for a local installation
     // store abitrary user object in strongly typed manner
     api.storeAsTFileAny(&params, path, metadata, tmin, tmax);
diff --git a/Detectors/FIT/FV0/calibration/macros/readChannelTimeOffsetFV0CalibObjectFromCCDB.C b/Detectors/FIT/FV0/calibration/macros/readChannelTimeOffsetFV0CalibObjectFromCCDB.C
index 06b86e3c5015d..3f42c0219b101 100644
--- a/Detectors/FIT/FV0/calibration/macros/readChannelTimeOffsetFV0CalibObjectFromCCDB.C
+++ b/Detectors/FIT/FV0/calibration/macros/readChannelTimeOffsetFV0CalibObjectFromCCDB.C
@@ -22,8 +22,8 @@ int readChannelTimeOffsetFV0CalibObjectFromCCDB(const std::string url = "http://
 {
   o2::ccdb::CcdbApi api;
   api.init(url);
-  map<string, string> metadata;
-  map<string, string> headers;
+  std::map<std::string, std::string> metadata;
+  std::map<std::string, std::string> headers;
   auto retrieved = api.retrieveFromTFileAny<o2::fv0::FV0ChannelTimeCalibrationObject>("FV0/Calib/ChannelTimeOffset", metadata, -1, &headers);
 
   std::cout << "--- HEADERS ---" << std::endl;
diff --git a/Detectors/FIT/FV0/macros/FV0Misaligner.C b/Detectors/FIT/FV0/macros/FV0Misaligner.C
index 88f7a0b82b8b3..61be50b48dede 100644
--- a/Detectors/FIT/FV0/macros/FV0Misaligner.C
+++ b/Detectors/FIT/FV0/macros/FV0Misaligner.C
@@ -54,7 +54,7 @@ void FV0Misaligner(const std::string& ccdbHost = "http://ccdb-test.cern.ch:8080"
     std::string path = objectPath.empty() ? o2::base::DetectorNameConf::getAlignmentPath(detFV0) : objectPath;
     LOGP(info, "Storing alignment object on {}/{}", ccdbHost, path);
     o2::ccdb::CcdbApi api;
-    map<string, string> metadata; // can be empty
+    std::map<std::string, std::string> metadata; // can be empty
     api.init(ccdbHost.c_str());   // or http://localhost:8080 for a local installation
     // store abitrary user object in strongly typed manner
     api.storeAsTFileAny(&params, path, metadata, tmin, tmax);
diff --git a/Detectors/FIT/common/dcsmonitoring/include/FITDCSMonitoring/FITDCSConfigProcessorSpec.h b/Detectors/FIT/common/dcsmonitoring/include/FITDCSMonitoring/FITDCSConfigProcessorSpec.h
index f3ed3229d9e55..18c0b593b0a02 100644
--- a/Detectors/FIT/common/dcsmonitoring/include/FITDCSMonitoring/FITDCSConfigProcessorSpec.h
+++ b/Detectors/FIT/common/dcsmonitoring/include/FITDCSMonitoring/FITDCSConfigProcessorSpec.h
@@ -47,7 +47,7 @@ class FITDCSConfigProcessor : public o2::framework::Task
   void init(o2::framework::InitContext& ic) final
   {
     initDCSConfigReader();
-    mDCSConfigReader->setFileNameDChM(ic.options().get<string>("filename-dchm"));
+    mDCSConfigReader->setFileNameDChM(ic.options().get<std::string>("filename-dchm"));
     mDCSConfigReader->setValidDaysDChM(ic.options().get<uint>("valid-days-dchm"));
     mDCSConfigReader->setCcdbPathDChM(mDetectorName + "/Calib/DeadChannelMap");
     mVerbose = ic.options().get<bool>("use-verbose-mode");
diff --git a/Detectors/GRP/calibration/src/GRPDCSDPsProcessor.cxx b/Detectors/GRP/calibration/src/GRPDCSDPsProcessor.cxx
index c8fa7c2bff38b..aec4241f4f8db 100644
--- a/Detectors/GRP/calibration/src/GRPDCSDPsProcessor.cxx
+++ b/Detectors/GRP/calibration/src/GRPDCSDPsProcessor.cxx
@@ -277,13 +277,13 @@ bool GRPDCSDPsProcessor::processLHCIFDPs(const DPCOM& dpcom)
   }
 
   for (int ibeam = 0; ibeam < GRPLHCInfo::BeamAliases::NBeamAliases; ++ibeam) {
-    if (aliasStr.find(static_cast<std::string>(GRPLHCInfo::beamAliases[ibeam])) != string::npos) {
+    if (aliasStr.find(static_cast<std::string>(GRPLHCInfo::beamAliases[ibeam])) != std::string::npos) {
       updateVector(dpid, mLHCInfo.mIntensityBeam[ibeam], aliasStr, dpcomdata.get_epoch_time(), val);
       return true;
     }
   }
 
-  if (aliasStr.find("BPTX") != string::npos) {
+  if (aliasStr.find("BPTX") != std::string::npos) {
     if (aliasStr == static_cast<std::string>(GRPLHCInfo::bptxAliases[GRPLHCInfo::BPTXAliases::BPTX_deltaT_B1_B2])) {
       updateVector(dpid, mLHCInfo.mBPTXdeltaT, aliasStr, dpcomdata.get_epoch_time(), val);
       return true;
@@ -318,7 +318,7 @@ bool GRPDCSDPsProcessor::processLHCIFDPs(const DPCOM& dpcom)
   }
 
   for (int ibkg = 0; ibkg < 3; ++ibkg) {
-    if (aliasStr.find(static_cast<std::string>(GRPLHCInfo::bkgAliases[ibkg])) != string::npos) {
+    if (aliasStr.find(static_cast<std::string>(GRPLHCInfo::bkgAliases[ibkg])) != std::string::npos) {
       updateVector(dpid, mLHCInfo.mBackground[ibkg], aliasStr, dpcomdata.get_epoch_time(), val);
       return true;
     }
diff --git a/Detectors/GRP/workflows/src/create-grp-ecs.cxx b/Detectors/GRP/workflows/src/create-grp-ecs.cxx
index 873133e0dd46b..d9a73f0737799 100644
--- a/Detectors/GRP/workflows/src/create-grp-ecs.cxx
+++ b/Detectors/GRP/workflows/src/create-grp-ecs.cxx
@@ -268,10 +268,10 @@ int main(int argc, char** argv)
     add_option("run,r", bpo::value<int>(), "run number");
     add_option("run-type,t", bpo::value<int>()->default_value(int(GRPECSObject::RunType::NONE)), "run type");
     add_option("hbf-per-tf,n", bpo::value<int>()->default_value(128), "number of HBFs per TF");
-    add_option("detectors,d", bpo::value<string>()->default_value("all"), "comma separated list of detectors");
-    add_option("continuous,c", bpo::value<string>()->default_value("ITS,TPC,TOF,MFT,MCH,MID,ZDC,FT0,FV0,FDD,CTP"), "comma separated list of detectors in continuous readout mode");
-    add_option("triggering,g", bpo::value<string>()->default_value("FT0,FV0"), "comma separated list of detectors providing a trigger");
-    add_option("flps,f", bpo::value<string>()->default_value(""), "comma separated list of FLPs in the data taking");
+    add_option("detectors,d", bpo::value<std::string>()->default_value("all"), "comma separated list of detectors");
+    add_option("continuous,c", bpo::value<std::string>()->default_value("ITS,TPC,TOF,MFT,MCH,MID,ZDC,FT0,FV0,FDD,CTP"), "comma separated list of detectors in continuous readout mode");
+    add_option("triggering,g", bpo::value<std::string>()->default_value("FT0,FV0"), "comma separated list of detectors providing a trigger");
+    add_option("flps,f", bpo::value<std::string>()->default_value(""), "comma separated list of FLPs in the data taking");
     add_option("start-time,s", bpo::value<long>()->default_value(0), "ECS run start time in ms, now() if 0");
     add_option("end-time,e", bpo::value<long>()->default_value(0), "ECS run end time in ms, start-time+3days is used if 0");
     add_option("start-time-ctp", bpo::value<long>()->default_value(0), "run start CTP time in ms, same as ECS if not set or 0");
@@ -279,7 +279,7 @@ int main(int argc, char** argv)
     add_option("ccdb-server", bpo::value<std::string>()->default_value("http://alice-ccdb.cern.ch"), "CCDB server for upload, local file if empty");
     add_option("ccdb-server-input", bpo::value<std::string>()->default_value(""), "CCDB server for inputs (if needed, e.g. CTPConfig), dy default ccdb-server is used");
     add_option("meta-data,m", bpo::value<std::string>()->default_value("")->implicit_value(""), "metadata as key1=value1;key2=value2;..");
-    add_option("refresh", bpo::value<string>()->default_value("")->implicit_value("async"), R"(refresh server cache after upload: "none" (or ""), "async" (non-blocking) and "sync" (blocking))");
+    add_option("refresh", bpo::value<std::string>()->default_value("")->implicit_value("async"), R"(refresh server cache after upload: "none" (or ""), "async" (non-blocking) and "sync" (blocking))");
     add_option("marginSOR", bpo::value<long>()->default_value(4 * o2::ccdb::CcdbObjectInfo::DAY), "validity at SOR");
     add_option("marginEOR", bpo::value<long>()->default_value(10 * o2::ccdb::CcdbObjectInfo::MINUTE), "validity margin to add after EOR");
     add_option("original-run,o", bpo::value<int>()->default_value(0), "if >0, use as the source run to create CTP/Config/Config object");
@@ -313,7 +313,7 @@ int main(int argc, char** argv)
     std::cerr << opt_general << std::endl;
     exit(3);
   }
-  std::string refreshStr = vm["refresh"].as<string>();
+  std::string refreshStr = vm["refresh"].as<std::string>();
   CCDBRefreshMode refresh = CCDBRefreshMode::NONE;
   if (!refreshStr.empty() && refreshStr != "none") {
     if (refreshStr == "async") {
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx
index a127cf313d0e1..bd21b8ac22116 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx
@@ -43,7 +43,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   bool writeUnbinnedResiduals = false;
   bool writeBinnedResiduals = false;
   bool writeTrackData = false;
-  auto outputType = configcontext.options().get<string>("output-type");
+  auto outputType = configcontext.options().get<std::string>("output-type");
   std::vector<std::string> outputTypes;
   size_t pos = 0;
   while ((pos = outputType.find(",")) != std::string::npos) {
diff --git a/Detectors/ITSMFT/ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx b/Detectors/ITSMFT/ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx
index 964f342c58b15..1fc4442e3bdbf 100644
--- a/Detectors/ITSMFT/ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx
+++ b/Detectors/ITSMFT/ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx
@@ -210,7 +210,7 @@ void TestDataReader::run(ProcessingContext& pc)
 
     size_t pos = mNowFolderNames[i].find_last_of("/");
 
-    if (pos != string::npos) {
+    if (pos != std::string::npos) {
       mRunID = mNowFolderNames[i].substr(pos + 1);
     }
 
@@ -232,7 +232,7 @@ void TestDataReader::run(ProcessingContext& pc)
       // Getting the FileID
       string FileIDS;
       pos = mDiffFileNames[i][0].find_last_of("/");
-      if (pos != string::npos) {
+      if (pos != std::string::npos) {
         FileIDS = mDiffFileNames[i][0].substr(pos + 1);
       }
 
diff --git a/Detectors/ITSMFT/ITS/macros/test/ITSMisaligner.C b/Detectors/ITSMFT/ITS/macros/test/ITSMisaligner.C
index e04c2ca572804..eb6cb7a39b41c 100644
--- a/Detectors/ITSMFT/ITS/macros/test/ITSMisaligner.C
+++ b/Detectors/ITSMFT/ITS/macros/test/ITSMisaligner.C
@@ -78,7 +78,7 @@ void ITSMisaligner(const std::string& ccdbHost = "http://localhost:8080", long t
     std::string path = objectPath.empty() ? o2::base::DetectorNameConf::getAlignmentPath(detITS) : objectPath;
     LOGP(info, "Storing alignment object on {}/{}", ccdbHost, path);
     o2::ccdb::CcdbApi api;
-    map<string, string> metadata; // can be empty
+    std::map<std::string, std::string> metadata; // can be empty
     api.init(ccdbHost.c_str());   // or http://localhost:8080 for a local installation
     // store abitrary user object in strongly typed manner
     api.storeAsTFileAny(&params, path, metadata, tmin, tmax);
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/DCSParserSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/DCSParserSpec.h
index eaacfab10f886..cd18fd459546d 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/DCSParserSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/DCSParserSpec.h
@@ -136,7 +136,7 @@ class ITSDCSParser : public Task
   std::string mCcdbUrl = "";
 
   // Vector containing all the staves listed in the EOR file
-  std::vector<string> mSavedStaves = {};
+  std::vector<std::string> mSavedStaves = {};
 
   // Disabled chip map
   o2::itsmft::NoiseMap mDeadMap;
diff --git a/Detectors/ITSMFT/ITS/workflow/src/DCSParserSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/DCSParserSpec.cxx
index a9e1121077f02..d504640588023 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/DCSParserSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/DCSParserSpec.cxx
@@ -386,9 +386,9 @@ void ITSDCSParser::saveToOutput()
 void ITSDCSParser::saveMissingToOutput()
 {
   // Loop on the missing staves
-  std::vector<string> missingStaves;
-  std::vector<string> listStaves = this->listStaves();
-  std::vector<string> savedStaves = this->mSavedStaves;
+  std::vector<std::string> missingStaves;
+  std::vector<std::string> listStaves = this->listStaves();
+  std::vector<std::string> savedStaves = this->mSavedStaves;
   std::sort(savedStaves.begin(), savedStaves.end());
   std::set_difference(listStaves.begin(), listStaves.end(), savedStaves.begin(), savedStaves.end(),
                       std::inserter(missingStaves, missingStaves.begin()));
@@ -557,7 +557,7 @@ std::vector<std::string> ITSDCSParser::listStaves()
   std::string stavenum = "";
   for (int i = 0; i < 7; i++) {
     for (int j = 0; j < stavesPerLayer[i]; j++) {
-      string stavestring = std::to_string(j);
+      std::string stavestring = std::to_string(j);
       int precision = 2 - std::min(2, (int)(stavestring.size()));
       stavenum = std::string(precision, '0').append(std::to_string(j));
       std::string stave = "L" + std::to_string(i) + "_" + stavenum;
diff --git a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
index e958e6b1ba113..8359d6c89ab60 100644
--- a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
@@ -299,8 +299,8 @@ void NoiseCalibratorSpec::sendOutputCcdbMerge(DataAllocator& output)
 
   auto payload = mCalibrator->getNoiseMap();
   //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
-  map<string, string> headers;
-  map<std::string, std::string> filter;
+  std::map<std::string, std::string> headers;
+  std::map<std::string, std::string> filter;
   auto* payloadPrev1 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, -1, &headers);
   long validtime = std::stol(headers["Valid-From"]);
   auto mergedPL = payload;
@@ -424,8 +424,8 @@ void NoiseCalibratorSpec::sendOutputDcsMerge(DataAllocator& output)
   auto payload = mCalibrator->getNoiseMap();
   //  const auto& payload = mCalibrator->getNoiseMap(starTF, endTF); //For TimeSlot calibration
 
-  map<string, string> headers;
-  map<std::string, std::string> filter;
+  std::map<std::string, std::string> headers;
+  std::map<std::string, std::string> filter;
   auto* payloadPrev1 = api.retrieveFromTFileAny<o2::itsmft::NoiseMap>(mPathSingle, filter, -1, &headers);
   long validtime = std::stol(headers["Valid-From"]);
   auto mergedPL = payload;
diff --git a/Detectors/ITSMFT/MFT/condition/macros/readAlpideCCDB.C b/Detectors/ITSMFT/MFT/condition/macros/readAlpideCCDB.C
index 31b8028e2b7ee..adc8aaa16ed70 100644
--- a/Detectors/ITSMFT/MFT/condition/macros/readAlpideCCDB.C
+++ b/Detectors/ITSMFT/MFT/condition/macros/readAlpideCCDB.C
@@ -14,7 +14,7 @@ void readAlpideCCDB(long timestamp = -1, float thresh = 0)
   o2::ccdb::CcdbApi api;
   // api.init("alice-ccdb.cern.ch");
   api.init("ccdb-test.cern.ch");
-  map<string, string> headers;
+  std::map<std::string, std::string> headers;
   map<std::string, std::string> filter;
   auto calib = api.retrieveFromTFileAny<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>>("MFT/Config/AlpideParam/", filter, timestamp, &headers);
   calib->printKeyValues();
diff --git a/Detectors/MUON/MCH/Align/src/AlignRecordSpec.cxx b/Detectors/MUON/MCH/Align/src/AlignRecordSpec.cxx
index 0a61d38a36b2a..690a17952b033 100644
--- a/Detectors/MUON/MCH/Align/src/AlignRecordSpec.cxx
+++ b/Detectors/MUON/MCH/Align/src/AlignRecordSpec.cxx
@@ -121,7 +121,7 @@ class AlignRecordTask
     mImproveCutChi2 = 2. * trackerParam.sigmaCutForImprovement * trackerParam.sigmaCutForImprovement;
 
     // Configuration for chamber fixing
-    auto input_fixchambers = ic.options().get<string>("fix-chamber");
+    auto input_fixchambers = ic.options().get<std::string>("fix-chamber");
     std::stringstream string_chambers(input_fixchambers);
     string_chambers >> std::ws;
     while (string_chambers.good()) {
@@ -132,8 +132,8 @@ class AlignRecordTask
     }
 
     // Init for output saving
-    auto OutputRecFileName = ic.options().get<string>("output-record-data");
-    auto OutputConsFileName = ic.options().get<string>("output-record-constraint");
+    auto OutputRecFileName = ic.options().get<std::string>("output-record-data");
+    auto OutputConsFileName = ic.options().get<std::string>("output-record-constraint");
     mAlign.init(OutputRecFileName, OutputConsFileName);
 
     ic.services().get<CallbackService>().set<CallbackService::Id::Stop>([this]() {
diff --git a/Detectors/MUON/MCH/Align/src/AlignmentSpec.cxx b/Detectors/MUON/MCH/Align/src/AlignmentSpec.cxx
index 9d92f18024d88..828cb0cb80242 100644
--- a/Detectors/MUON/MCH/Align/src/AlignmentSpec.cxx
+++ b/Detectors/MUON/MCH/Align/src/AlignmentSpec.cxx
@@ -167,7 +167,7 @@ class AlignmentTask
 
       LOG(info) << "Loading magnetic field and reference geometry from input files";
 
-      auto grpFile = ic.options().get<string>("grp-file");
+      auto grpFile = ic.options().get<std::string>("grp-file");
       if (std::filesystem::exists(grpFile)) {
         const auto grp = parameters::GRPObject::loadFrom(grpFile);
         base::Propagator::initFieldFromGRP(grp);
@@ -178,7 +178,7 @@ class AlignmentTask
         LOG(fatal) << "No GRP file";
       }
 
-      IdealGeoFileName = ic.options().get<string>("geo-file-ideal");
+      IdealGeoFileName = ic.options().get<std::string>("geo-file-ideal");
       if (std::filesystem::exists(IdealGeoFileName)) {
         base::GeometryManager::loadGeometry(IdealGeoFileName.c_str());
         transformation = geo::transformationFromTGeoManager(*gGeoManager);
@@ -190,7 +190,7 @@ class AlignmentTask
         LOG(fatal) << "No ideal geometry";
       }
 
-      RefGeoFileName = ic.options().get<string>("geo-file-ref");
+      RefGeoFileName = ic.options().get<std::string>("geo-file-ref");
       if (std::filesystem::exists(RefGeoFileName)) {
         base::GeometryManager::loadGeometry(RefGeoFileName.c_str());
         transformation = geo::transformationFromTGeoManager(*gGeoManager);
@@ -205,7 +205,7 @@ class AlignmentTask
       if (doReAlign) {
         LOG(info) << "Re-alignment mode";
         LOG(info) << "Loading re-alignment geometry";
-        NewGeoFileName = ic.options().get<string>("geo-file-new");
+        NewGeoFileName = ic.options().get<std::string>("geo-file-new");
         if (std::filesystem::exists(NewGeoFileName)) {
           base::GeometryManager::loadGeometry(NewGeoFileName.c_str());
           transformation = geo::transformationFromTGeoManager(*gGeoManager);
@@ -246,7 +246,7 @@ class AlignmentTask
     mImproveCutChi2 = 2. * trackerParam.sigmaCutForImprovement * trackerParam.sigmaCutForImprovement;
 
     // Fix chambers
-    TString chambersString = ic.options().get<string>("fix-chamber");
+    TString chambersString = ic.options().get<std::string>("fix-chamber");
     std::unique_ptr<TObjArray> objArray(chambersString.Tokenize(","));
     if (objArray->GetEntries() > 0) {
       for (int iVar = 0; iVar < objArray->GetEntries(); ++iVar) {
@@ -256,8 +256,8 @@ class AlignmentTask
     }
 
     // Fix DEs
-    TString DEString = ic.options().get<string>("fix-de");
-    TString MaskDEString = ic.options().get<string>("mask-fix-de");
+    TString DEString = ic.options().get<std::string>("fix-de");
+    TString MaskDEString = ic.options().get<std::string>("mask-fix-de");
     std::unique_ptr<TObjArray> objArrayDE(DEString.Tokenize(","));
     std::unique_ptr<TObjArray> objArrayMask(MaskDEString.Tokenize(","));
     if (objArrayDE->GetEntries() > 0) {
@@ -271,7 +271,7 @@ class AlignmentTask
     }
 
     doMatched = ic.options().get<bool>("matched");
-    outFileName = ic.options().get<string>("output");
+    outFileName = ic.options().get<std::string>("output");
     readFromRec = ic.options().get<bool>("use-record");
 
     if (readFromRec) {
diff --git a/Detectors/MUON/MCH/Geometry/Test/Helpers.cxx b/Detectors/MUON/MCH/Geometry/Test/Helpers.cxx
index 685971a026b27..d5bf4cad2142d 100644
--- a/Detectors/MUON/MCH/Geometry/Test/Helpers.cxx
+++ b/Detectors/MUON/MCH/Geometry/Test/Helpers.cxx
@@ -166,7 +166,7 @@ void zeroMisAlignGeometry(const std::string& ccdbHost, const std::string& fileNa
     std::string path = objectPath.empty() ? o2::base::DetectorNameConf::getAlignmentPath(detMCH) : objectPath;
     LOGP(info, "Storing alignment object on {}/{}", ccdbHost, path);
     o2::ccdb::CcdbApi api;
-    map<string, string> metadata; // can be empty
+    std::map<std::string, std::string> metadata; // can be empty
     api.init(ccdbHost.c_str());   // or http://localhost:8080 for a local installation
     // store abitrary user object in strongly typed manner
     api.storeAsTFileAny(&params, path, metadata, tmin, tmax);
diff --git a/Detectors/MUON/MCH/Geometry/Test/misAlign.C b/Detectors/MUON/MCH/Geometry/Test/misAlign.C
index c49fe5717a36b..41312b1f223d4 100644
--- a/Detectors/MUON/MCH/Geometry/Test/misAlign.C
+++ b/Detectors/MUON/MCH/Geometry/Test/misAlign.C
@@ -89,7 +89,7 @@ void misAlign(Double_t xcartmisaligm = 0.01, Double_t xcartmisaligw = 0.0,
     std::string path = objectPath.empty() ? o2::base::DetectorNameConf::getAlignmentPath(detMCH) : objectPath;
     LOGP(info, "Storing alignment object on {}/{}", ccdbHost, path);
     o2::ccdb::CcdbApi api;
-    map<string, string> metadata; // can be empty
+    std::map<std::string, std::string> metadata; // can be empty
     api.init(ccdbHost.c_str());   // or http://localhost:8080 for a local installation
     // store abitrary user object in strongly typed manner
     api.storeAsTFileAny(&params, path, metadata, tmin, tmax);
diff --git a/Detectors/TPC/calibration/src/CalculatedEdx.cxx b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
index 60e9ada7794d3..11f83f1c7189e 100644
--- a/Detectors/TPC/calibration/src/CalculatedEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
@@ -566,7 +566,7 @@ void CalculatedEdx::loadCalibsFromCCDB(long runNumberOrTimeStamp, const bool isM
   mCalibCont.setResidualCorrection(*residualCorr);
 
   // set the zero supression threshold map
-  std::unordered_map<string, o2::tpc::CalDet<float>>* zeroSupressionThresholdMap = cm.getForTimeStamp<std::unordered_map<string, o2::tpc::CalDet<float>>>(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::ConfigFEEPad), tRun);
+  std::unordered_map<std::string, o2::tpc::CalDet<float>>* zeroSupressionThresholdMap = cm.getForTimeStamp<std::unordered_map<std::string, o2::tpc::CalDet<float>>>(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::ConfigFEEPad), tRun);
   mCalibCont.setZeroSupresssionThreshold(zeroSupressionThresholdMap->at("ThresholdMap"));
 
   // set the magnetic field
@@ -624,7 +624,7 @@ void CalculatedEdx::setGainMapResidualFromFile(const char* folder, const char* f
   std::unique_ptr<TFile> gainMapResidualFile(TFile::Open(fmt::format("{}{}", folder, file).data()));
   if (!gainMapResidualFile->IsZombie()) {
     LOGP(info, "Using file: {}", gainMapResidualFile->GetName());
-    std::unordered_map<string, o2::tpc::CalDet<float>>* gainMapResidual = (std::unordered_map<string, o2::tpc::CalDet<float>>*)gainMapResidualFile->Get(object);
+    std::unordered_map<std::string, o2::tpc::CalDet<float>>* gainMapResidual = (std::unordered_map<std::string, o2::tpc::CalDet<float>>*)gainMapResidualFile->Get(object);
     mCalibCont.setGainMapResidual(gainMapResidual->at("GainMap"));
   }
 }
@@ -644,7 +644,7 @@ void CalculatedEdx::setZeroSuppressionThresholdFromFile(const char* folder, cons
   std::unique_ptr<TFile> zeroSuppressionFile(TFile::Open(fmt::format("{}{}", folder, file).data()));
   if (!zeroSuppressionFile->IsZombie()) {
     LOGP(info, "Using file: {}", zeroSuppressionFile->GetName());
-    std::unordered_map<string, o2::tpc::CalDet<float>>* zeroSupressionThresholdMap = (std::unordered_map<string, o2::tpc::CalDet<float>>*)zeroSuppressionFile->Get(object);
+    std::unordered_map<std::string, o2::tpc::CalDet<float>>* zeroSupressionThresholdMap = (std::unordered_map<std::string, o2::tpc::CalDet<float>>*)zeroSuppressionFile->Get(object);
     mCalibCont.setZeroSupresssionThreshold(zeroSupressionThresholdMap->at("ThresholdMap"));
   }
 }
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
index 7afc973d7a3ab..c5af27da7b8f7 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
@@ -139,7 +139,7 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
     if (matcher == ConcreteDataMatcher(gDataOriginTPC, "RESIDUALGAINMAP", 0)) {
       if (!mUsingDefaultGainMapForFirstIter) {
         LOGP(info, "Updating reference gain map from previous iteration from CCDB");
-        const auto* gainMapResidual = static_cast<std::unordered_map<string, o2::tpc::CalDet<float>>*>(obj);
+        const auto* gainMapResidual = static_cast<std::unordered_map<std::string, o2::tpc::CalDet<float>>*>(obj);
         mPadGainTracks.setRefGainMap(gainMapResidual->at("GainMap"));
       } else {
         // just skip for the first time asking for an object -> not gain map will be used as reference
diff --git a/Detectors/TRD/base/macros/OCDB2CCDB.C b/Detectors/TRD/base/macros/OCDB2CCDB.C
index f7723089bd5a6..35cf86d05d22f 100644
--- a/Detectors/TRD/base/macros/OCDB2CCDB.C
+++ b/Detectors/TRD/base/macros/OCDB2CCDB.C
@@ -266,7 +266,7 @@ void OCDB2CCDB(long timeStamp = -1, TString ccdbPath = "http://localhost:8080",
   //Connect to CCDB
   //
   o2::ccdb::CcdbApi ccdb;
-  map<string, string> metadata;               // do we want to store any meta data?
+  std::map<std::string, std::string> metadata; // do we want to store any meta data?
   ccdb.init(ccdbPath.Data());
 
   AliTRDCalChamberStatus* chamberStatus = 0;
diff --git a/Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C b/Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C
index 0b4d93906efb5..edf8bfff15129 100644
--- a/Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C
+++ b/Detectors/TRD/base/macros/OCDB2CCDBTrapConfig.C
@@ -206,7 +206,7 @@ void OCDB2CCDBTrapConfig(TString ccdbPath = "http://localhost:8080", Int_t run =
   //Connect to CCDB
   //
   o2::ccdb::CcdbApi ccdb;
-  map<string, string> metadata;               // do we want to store any meta data?
+  std::map<std::string, std::string> metadata; // do we want to store any meta data?
   metadata.emplace(std::make_pair("UploadedBy", "marten"));
   metadata.emplace(std::make_pair("Description", "Default TRAP config for Run 3 simulations in LS2"));
   ccdb.init(ccdbPath.Data());
diff --git a/Detectors/TRD/base/macros/PrintTrapConfig.C b/Detectors/TRD/base/macros/PrintTrapConfig.C
index b9b0c3226dcc1..5ed22c32d45aa 100644
--- a/Detectors/TRD/base/macros/PrintTrapConfig.C
+++ b/Detectors/TRD/base/macros/PrintTrapConfig.C
@@ -236,7 +236,7 @@ void PrintTrapConfig(Int_t run, const Char_t* storageURI = "alien://folder=/alic
   //Connect to CCDB
   //
   o2::ccdb::CcdbApi ccdb;
-  map<string, string> metadata;               // do we want to store any meta data?
+  std::map<std::string, std::string> metadata; // do we want to store any meta data?
   ccdb.init("http://ccdb-test.cern.ch:8080"); // or http://localhost:8080 for a local installation
 
   /*
diff --git a/Detectors/TRD/base/macros/Readocdb.C b/Detectors/TRD/base/macros/Readocdb.C
index 55bea0c2e9cf2..4839f11a41590 100644
--- a/Detectors/TRD/base/macros/Readocdb.C
+++ b/Detectors/TRD/base/macros/Readocdb.C
@@ -251,7 +251,7 @@ void Readocdb(Int_t run, const Char_t* storageURI = "alien://folder=/alice/data/
   //Connect to CCDB
   //
   o2::ccdb::CcdbApi ccdb;
-  map<string, string> metadata;               // do we want to store any meta data?
+  std::map<std::string, std::string> metadata; // do we want to store any meta data?
   ccdb.init("http://ccdb-test.cern.ch:8080"); // or http://localhost:8080 for a local installation
 
   AliTRDCalChamberStatus* chamberStatus = 0;
diff --git a/Detectors/TRD/calibration/include/TRDCalibration/DCSProcessor.h b/Detectors/TRD/calibration/include/TRDCalibration/DCSProcessor.h
index 27cba85a89941..8e4a99e5e85d3 100644
--- a/Detectors/TRD/calibration/include/TRDCalibration/DCSProcessor.h
+++ b/Detectors/TRD/calibration/include/TRDCalibration/DCSProcessor.h
@@ -96,7 +96,7 @@ class DCSProcessor
   const std::unordered_map<DPID, TRDDCSMinMaxMeanInfo>& getTRDCurrentsDPsInfo() const { return mTRDDCSCurrents; }
   const std::unordered_map<DPID, TRDDCSMinMaxMeanInfo>& getTRDEnvDPsInfo() const { return mTRDDCSEnv; }
   const std::array<int, constants::MAXCHAMBER>& getTRDFedChamberStatusDPsInfo() const { return mTRDDCSFedChamberStatus; }
-  const std::array<string, constants::MAXCHAMBER>& getTRDFedCFGtagDPsInfo() const { return mTRDDCSFedCFGtag; }
+  const std::array<std::string, constants::MAXCHAMBER>& getTRDFedCFGtagDPsInfo() const { return mTRDDCSFedCFGtag; }
 
   // settings
   void setCurrentTS(TFType tf) { mCurrentTS = tf; }
@@ -124,7 +124,7 @@ class DCSProcessor
   std::unordered_map<DPID, float> mTRDDCSVoltages;                ///< anode and drift voltages
   std::unordered_map<DPID, TRDDCSMinMaxMeanInfo> mTRDDCSEnv;      ///< environment parameters (temperatures, pressures, humidity)
   std::array<int, constants::MAXCHAMBER> mTRDDCSFedChamberStatus; ///< fed chamber status
-  std::array<string, constants::MAXCHAMBER> mTRDDCSFedCFGtag;     ///< fed config tag
+  std::array<std::string, constants::MAXCHAMBER> mTRDDCSFedCFGtag; ///< fed config tag
 
   // helper variables
   std::unordered_map<DPID, bool> mPids;                 ///< flag for each DP whether it has been processed at least once
diff --git a/Detectors/TRD/calibration/src/DCSProcessor.cxx b/Detectors/TRD/calibration/src/DCSProcessor.cxx
index 165bbbd6a6148..f110ba844791e 100644
--- a/Detectors/TRD/calibration/src/DCSProcessor.cxx
+++ b/Detectors/TRD/calibration/src/DCSProcessor.cxx
@@ -120,7 +120,7 @@ int DCSProcessor::processDP(const DPCOM& dpcom)
     } else if (type == DPVAL_INT) {
       LOG(info) << "Processing DP = " << dpcom << ", with value = " << o2::dcs::getValue<int32_t>(dpcom);
     } else if (type == DPVAL_STRING) {
-      LOG(info) << "Processing DP = " << dpcom << ", with value = " << o2::dcs::getValue<string>(dpcom);
+      LOG(info) << "Processing DP = " << dpcom << ", with value = " << o2::dcs::getValue<std::string>(dpcom);
     }
   }
   auto flags = dpcom.data.get_flags();
@@ -265,15 +265,15 @@ int DCSProcessor::processDP(const DPCOM& dpcom)
         int chamberId = getChamberIdFromAlias(dpid.get_alias());
         auto& dpInfoFedCFGtag = mTRDDCSFedCFGtag[chamberId];
         if (etime != mLastDPTimeStamps[dpid]) {
-          if (dpInfoFedCFGtag != o2::dcs::getValue<string>(dpcom)) {
+          if (dpInfoFedCFGtag != o2::dcs::getValue<std::string>(dpcom)) {
             // If value changes after processing and DPs should not be updated, log change as warning (for now)
             if (mPids[dpid] && !(mFedCFGtagCompleteDPs && mFirstRunEntryForFedCFGtagUpdate)) {
               // Issue an alarm if counter is lower than maximum, warning otherwise
               if (mFedCFGtagAlarmCounter < mFedAlarmCounterMax) {
-                LOG(alarm) << "CFGtag change " << dpid.get_alias() << " : " << dpInfoFedCFGtag << " -> " << o2::dcs::getValue<string>(dpcom) << ", run = " << mCurrentRunNumber;
+                LOG(alarm) << "CFGtag change " << dpid.get_alias() << " : " << dpInfoFedCFGtag << " -> " << o2::dcs::getValue<std::string>(dpcom) << ", run = " << mCurrentRunNumber;
                 mFedCFGtagAlarmCounter++;
               } else if (mVerbosity > 0) {
-                LOG(warn) << "CFGtag change " << dpid.get_alias() << " : " << dpInfoFedCFGtag << " -> " << o2::dcs::getValue<string>(dpcom) << ", run = " << mCurrentRunNumber;
+                LOG(warn) << "CFGtag change " << dpid.get_alias() << " : " << dpInfoFedCFGtag << " -> " << o2::dcs::getValue<std::string>(dpcom) << ", run = " << mCurrentRunNumber;
               }
             }
           }
diff --git a/Detectors/ZDC/macro/CreateBaselineCalib.C b/Detectors/ZDC/macro/CreateBaselineCalib.C
index e6f2be3cb0f93..d04543fb52091 100644
--- a/Detectors/ZDC/macro/CreateBaselineCalib.C
+++ b/Detectors/ZDC/macro/CreateBaselineCalib.C
@@ -79,7 +79,7 @@ void CreateBaselineCalib(long tmin = 0, long tmax = -1, std::string ccdbHost = "
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateBaselineCalibConfig.C b/Detectors/ZDC/macro/CreateBaselineCalibConfig.C
index be31f65941baa..c2fde8f1ab1a8 100644
--- a/Detectors/ZDC/macro/CreateBaselineCalibConfig.C
+++ b/Detectors/ZDC/macro/CreateBaselineCalibConfig.C
@@ -48,7 +48,7 @@ void CreateBaselineCalibConfig(long tmin = 0, long tmax = -1, std::string ccdbHo
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateEnergyCalib.C b/Detectors/ZDC/macro/CreateEnergyCalib.C
index 23befda355768..3ff5ff5537cf7 100644
--- a/Detectors/ZDC/macro/CreateEnergyCalib.C
+++ b/Detectors/ZDC/macro/CreateEnergyCalib.C
@@ -58,7 +58,7 @@ void CreateEnergyCalib(long tmin = 0, long tmax = -1, std::string ccdbHost = "")
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateInterCalibConfig.C b/Detectors/ZDC/macro/CreateInterCalibConfig.C
index 915b55b42d2eb..ce81b7f9ee3b5 100644
--- a/Detectors/ZDC/macro/CreateInterCalibConfig.C
+++ b/Detectors/ZDC/macro/CreateInterCalibConfig.C
@@ -61,7 +61,7 @@ void CreateInterCalibConfig(long tmin = 0, long tmax = -1, std::string ccdbHost
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateModuleConfig.C b/Detectors/ZDC/macro/CreateModuleConfig.C
index 2d5fde58e3c41..d9d76dd85deb1 100644
--- a/Detectors/ZDC/macro/CreateModuleConfig.C
+++ b/Detectors/ZDC/macro/CreateModuleConfig.C
@@ -150,7 +150,7 @@ void CreateModuleConfig(long tmin = 0, long tmax = -1, std::string ccdbHost = ""
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateRecoConfigZDC.C b/Detectors/ZDC/macro/CreateRecoConfigZDC.C
index c504241346787..838cd93b944c4 100644
--- a/Detectors/ZDC/macro/CreateRecoConfigZDC.C
+++ b/Detectors/ZDC/macro/CreateRecoConfigZDC.C
@@ -150,7 +150,7 @@ void CreateRecoConfigZDC(long tmin = 0, long tmax = -1, std::string ccdbHost = "
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateSimCondition.C b/Detectors/ZDC/macro/CreateSimCondition.C
index 6349adbf5b66e..9f29aafc979bb 100644
--- a/Detectors/ZDC/macro/CreateSimCondition.C
+++ b/Detectors/ZDC/macro/CreateSimCondition.C
@@ -148,7 +148,7 @@ void CreateSimCondition(long tmin = 0, long tmax = -1, std::string ccdbHost = ""
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateSimCondition_pp.C b/Detectors/ZDC/macro/CreateSimCondition_pp.C
index 6d3c530b6772b..f38634ef18fac 100644
--- a/Detectors/ZDC/macro/CreateSimCondition_pp.C
+++ b/Detectors/ZDC/macro/CreateSimCondition_pp.C
@@ -101,7 +101,7 @@ void CreateSimCondition_pp(long tmin = 0, long tmax = -1, std::string ccdbHost =
   conf.print();
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   if (ccdbHost.size() == 0 || ccdbHost == "external") {
     ccdbHost = "http://alice-ccdb.cern.ch:8080";
   } else if (ccdbHost == "internal") {
diff --git a/Detectors/ZDC/macro/CreateTDCCalib.C b/Detectors/ZDC/macro/CreateTDCCalib.C
index 1591e1e31f699..44e94f84334b1 100644
--- a/Detectors/ZDC/macro/CreateTDCCalib.C
+++ b/Detectors/ZDC/macro/CreateTDCCalib.C
@@ -63,7 +63,7 @@ void CreateTDCCalib(long tmin = 0, long tmax = -1, std::string ccdbHost = "", fl
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "Storing " << o2::zdc::CCDBPathTDCCalib << " on CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateTDCCalibConfig.C b/Detectors/ZDC/macro/CreateTDCCalibConfig.C
index 4aafbf555f088..2511e4f832add 100644
--- a/Detectors/ZDC/macro/CreateTDCCalibConfig.C
+++ b/Detectors/ZDC/macro/CreateTDCCalibConfig.C
@@ -60,7 +60,7 @@ void CreateTDCCalibConfig(long tmin = 0, long tmax = -1, std::string ccdbHost =
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateTDCCorr.C b/Detectors/ZDC/macro/CreateTDCCorr.C
index 9c089f532a408..45845dd669a81 100644
--- a/Detectors/ZDC/macro/CreateTDCCorr.C
+++ b/Detectors/ZDC/macro/CreateTDCCorr.C
@@ -99,7 +99,7 @@ void CreateTDCCorr(long tmin = 0, long tmax = -1, std::string ccdbHost = "")
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/Detectors/ZDC/macro/CreateTowerCalib.C b/Detectors/ZDC/macro/CreateTowerCalib.C
index 16e67e448cd65..18e7dc145c154 100644
--- a/Detectors/ZDC/macro/CreateTowerCalib.C
+++ b/Detectors/ZDC/macro/CreateTowerCalib.C
@@ -75,7 +75,7 @@ void CreateTowerCalib(long tmin = 0, long tmax = -1, std::string ccdbHost = "")
   }
 
   o2::ccdb::CcdbApi api;
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   api.init(ccdb_host.c_str());
   LOG(info) << "CCDB server: " << api.getURL();
   // store abitrary user object in strongly typed manner
diff --git a/EventVisualisation/View/src/EventManagerFrame.cxx b/EventVisualisation/View/src/EventManagerFrame.cxx
index 6af49953d7e40..6c9796be94ee0 100644
--- a/EventVisualisation/View/src/EventManagerFrame.cxx
+++ b/EventVisualisation/View/src/EventManagerFrame.cxx
@@ -398,12 +398,12 @@ void EventManagerFrame::createOutreachScreenshot()
   if (skipCounter > 0) {
     skipCounter--;
   } else {
-    string fileName = this->mEventManager->getInstance().getDataSource()->getEventName();
+    std::string fileName = this->mEventManager->getInstance().getDataSource()->getEventName();
     if (fileName.size() < 5) {
       return;
     }
 
-    string imageFolder = ConfigurationManager::getScreenshotPath("outreach");
+    std::string imageFolder = ConfigurationManager::getScreenshotPath("outreach");
     if (!std::filesystem::is_directory(imageFolder)) {
       std::filesystem::create_directory(imageFolder);
     }
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index 319d084cbcc6a..a0ed5813d90ca 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -250,14 +250,14 @@ void GPURecoWorkflowSpec::finaliseCCDBTPC(ConcreteDataMatcher& matcher, void* ob
   } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "PADGAINRESIDUAL", 0)) {
     LOGP(info, "Updating residual gain map from CCDB");
     copyCalibsToBuffer();
-    const auto* gainMapResidual = static_cast<std::unordered_map<string, o2::tpc::CalDet<float>>*>(obj);
+    const auto* gainMapResidual = static_cast<std::unordered_map<std::string, o2::tpc::CalDet<float>>*>(obj);
     const float minResidualGain = 0.7f;
     const float maxResidualGain = 1.3f;
     mdEdxCalibContainerBufferNew.get()->setGainMapResidual(gainMapResidual->at("GainMap"), minResidualGain, maxResidualGain);
   } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "PADTHRESHOLD", 0)) {
     LOGP(info, "Updating threshold map from CCDB");
     copyCalibsToBuffer();
-    const auto* thresholdMap = static_cast<std::unordered_map<string, o2::tpc::CalDet<float>>*>(obj);
+    const auto* thresholdMap = static_cast<std::unordered_map<std::string, o2::tpc::CalDet<float>>*>(obj);
     mdEdxCalibContainerBufferNew.get()->setZeroSupresssionThreshold(thresholdMap->at("ThresholdMap"));
   } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "TOPOLOGYGAIN", 0) && !(dEdxCalibContainer->isTopologyCorrectionSplinesSet())) {
     LOGP(info, "Updating Q topology correction from CCDB");
diff --git a/macro/CreateCTPOrbitResetObject.C b/macro/CreateCTPOrbitResetObject.C
index 4243ecd9f74d6..65649b5c112b0 100644
--- a/macro/CreateCTPOrbitResetObject.C
+++ b/macro/CreateCTPOrbitResetObject.C
@@ -17,7 +17,7 @@ void CreateCTPOrbitResetObject(const std::string& ccdbHost = "http://ccdb-test.c
   const std::string objName{"CTP/Calib/OrbitReset"};
   o2::ccdb::CcdbApi api;
   api.init(ccdbHost.c_str());   // or http://localhost:8080 for a local installation
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   metadata["comment"] = "CTP Orbit reset";
   api.storeAsTFileAny(&rt, objName, metadata, tmin, tmax);
   LOGP(info, "Uploaded CTP Oribt reset time {} to {}", t, objName);
diff --git a/macro/UploadDummyAlignment.C b/macro/UploadDummyAlignment.C
index f140737098519..a46f5e7f8c61f 100644
--- a/macro/UploadDummyAlignment.C
+++ b/macro/UploadDummyAlignment.C
@@ -24,7 +24,7 @@ void UploadDummyAlignment(const std::string& ccdbHost = "http://ccdb-test.cern.c
     if (!dets[id]) {
       continue;
     }
-    map<string, string> metadata; // can be empty
+    std::map<std::string, std::string> metadata; // can be empty
     DetID det(id);
     metadata["comment"] = fmt::format("Empty alignment object for {}", det.getName());
     metadata["default"] = "true"; // tag default objects
diff --git a/macro/UploadMatBudLUT.C b/macro/UploadMatBudLUT.C
index 8952074336ea5..e452cb06e713f 100644
--- a/macro/UploadMatBudLUT.C
+++ b/macro/UploadMatBudLUT.C
@@ -21,7 +21,7 @@ bool UploadMatBudLUT(const std::string& matLUTFile, long tmin = 0, long tmax = -
 
   o2::ccdb::CcdbApi api;
   api.init(ccdbHost.c_str());   // or http://localhost:8080 for a local installation
-  map<string, string> metadata; // can be empty
+  std::map<std::string, std::string> metadata; // can be empty
   metadata["comment"] = "Material lookup table";
   api.storeAsTFileAny(lut, url, metadata, tmin, tmax);
   return true;

From c1b57b102085a926fc2b083dffa950cab843a67b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 18 Jul 2025 13:06:06 +0200
Subject: [PATCH 0635/1764] Script cleanup: use -n instead of ! -z

---
 .../full-system-test/aggregator-workflow.sh   | 36 +++++------
 prodtests/full-system-test/calib-workflow.sh  | 22 +++----
 .../full-system-test/datadistribution.sh      |  4 +-
 prodtests/full-system-test/dpl-workflow.sh    | 64 +++++++++----------
 .../run-workflow-on-inputlist.sh              |  4 +-
 prodtests/full-system-test/start_tmux.sh      |  2 +-
 prodtests/full-system-test/tf-reader.sh       |  2 +-
 prodtests/full_system_test.sh                 |  6 +-
 8 files changed, 70 insertions(+), 70 deletions(-)

diff --git a/prodtests/full-system-test/aggregator-workflow.sh b/prodtests/full-system-test/aggregator-workflow.sh
index 5783bb9a38ad6..bd0c9fea2a31a 100755
--- a/prodtests/full-system-test/aggregator-workflow.sh
+++ b/prodtests/full-system-test/aggregator-workflow.sh
@@ -145,11 +145,11 @@ fi
 # adding input proxies
 if workflow_has_parameter CALIB_PROXIES; then
   if [[ $AGGREGATOR_TASKS == BARREL_TF ]]; then
-    if [[ ! -z ${CALIBDATASPEC_BARREL_TF:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_BARREL_TF:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_BARREL_TF\" $(get_proxy_connection barrel_tf input timeframe)" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == BARREL_SPORADIC ]]; then
-    if [[ ! -z ${CALIBDATASPEC_BARREL_SPORADIC:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_BARREL_SPORADIC:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_BARREL_SPORADIC\" $(get_proxy_connection barrel_sp input sporadic)" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC ]]; then
@@ -158,7 +158,7 @@ if workflow_has_parameter CALIB_PROXIES; then
     fi
     CHANNELS_LIST=
     [[ $EPNSYNCMODE == 0 ]] && FLP_ADDRESS="tcp://localhost:29950"
-    if [[ ! -z ${CALIBDATASPEC_TPCIDC_A:-} ]] || [[ ! -z ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_TPCIDC_A:-} ]] || [[ -n ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
       # define port for FLP
       : ${TPC_IDC_FLP_PORT:=29950}
       # expand FLPs; TPC uses from 001 to 145, but 145 is reserved for SAC
@@ -173,47 +173,47 @@ if workflow_has_parameter CALIB_PROXIES; then
         done
       fi
     fi
-    if [[ ! -z ${CALIBDATASPEC_TPCSAC:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_TPCSAC:-} ]]; then
       # define port for FLP
       [[ -z ${TPC_SAC_FLP_PORT:-} ]] && TPC_SAC_FLP_PORT=29951
       [[ $EPNSYNCMODE == 1 ]] && FLP_ADDRESS="tcp://alio2-cr1-flp145-ib:${TPC_SAC_FLP_PORT}"
       CHANNELS_LIST+="type=pull,name=tpcidc_sac,transport=zeromq,address=$FLP_ADDRESS,method=connect,rateLogging=10;"
     fi
-    if [[ ! -z $CHANNELS_LIST ]]; then
+    if [[ -n $CHANNELS_LIST ]]; then
       DATASPEC_LIST=
-      if [[ ! -z ${CALIBDATASPEC_TPCIDC_A:-} ]]; then
+      if [[ -n ${CALIBDATASPEC_TPCIDC_A:-} ]]; then
         add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCIDC_A\""
       fi
-      if [[ ! -z ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
+      if [[ -n ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
         add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCIDC_C\""
       fi
-      if [[ ! -z ${CALIBDATASPEC_TPCSAC:-} ]]; then
+      if [[ -n ${CALIBDATASPEC_TPCSAC:-} ]]; then
         add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCSAC\""
       fi
       add_W o2-dpl-raw-proxy "--proxy-name tpcidc --io-threads 2 --dataspec \"$DATASPEC_LIST\" --sporadic-outputs --channel-config \"$CHANNELS_LIST\" ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} $TIMEFRAME_SHM_LIMIT" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == CALO_TF ]]; then
-    if [[ ! -z ${CALIBDATASPEC_CALO_TF:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_CALO_TF:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_CALO_TF\" $(get_proxy_connection calo_tf input timeframe)" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == CALO_SPORADIC ]]; then
-    if [[ ! -z ${CALIBDATASPEC_CALO_SPORADIC:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_CALO_SPORADIC:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_CALO_SPORADIC\" $(get_proxy_connection calo_sp input sporadic)" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == MUON_TF ]]; then
-    if [[ ! -z ${CALIBDATASPEC_MUON_TF:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_MUON_TF:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_MUON_TF\" $(get_proxy_connection muon_tf input timeframe)" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == MUON_SPORADIC ]]; then
-    if [[ ! -z ${CALIBDATASPEC_MUON_SPORADIC:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_MUON_SPORADIC:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_MUON_SPORADIC\" $(get_proxy_connection muon_sp input sporadic)" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == FORWARD_TF ]]; then
-    if [[ ! -z ${CALIBDATASPEC_FORWARD_TF:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_FORWARD_TF:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_FORWARD_TF\" $(get_proxy_connection fwd_tf input timeframe)" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == FORWARD_SPORADIC ]]; then
-    if [[ ! -z ${CALIBDATASPEC_FORWARD_SPORADIC:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_FORWARD_SPORADIC:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_FORWARD_SPORADIC\" $(get_proxy_connection fwd_sp input sporadic)" "" 0
     fi
   fi
@@ -273,7 +273,7 @@ if [[ $AGGREGATOR_TASKS == BARREL_TF ]] || [[ $AGGREGATOR_TASKS == ALL ]]; then
   if [[ $CALIB_TRD_T0 == 1 ]]; then
     TRD_CALIB_CONFIG+=" --t0"
   fi
-  if [[ ! -z ${TRD_CALIB_CONFIG} ]]; then
+  if [[ -n ${TRD_CALIB_CONFIG} ]]; then
     add_W o2-calibration-trd-workflow "${TRD_CALIB_CONFIG}"
   fi
 fi
@@ -404,13 +404,13 @@ if [[ "${GEN_TOPO_VERBOSE:-}" == "1" ]]; then
   fi
 fi
 
-if [[ $CCDB_POPULATOR_UPLOAD_PATH != "none" ]] && [[ ! -z $WORKFLOW ]] && [[ $WORKFLOW != "echo '{}' | " ]]; then add_W o2-calibration-ccdb-populator-workflow "--ccdb-path $CCDB_POPULATOR_UPLOAD_PATH --environment \"DPL_DONT_DROP_OLD_TIMESLICE=1\" --sspec-min $CCDBPRO_SUBSPEC_MIN --sspec-max $CCDBPRO_SUBSPEC_MAX"; fi
+if [[ $CCDB_POPULATOR_UPLOAD_PATH != "none" ]] && [[ -n $WORKFLOW ]] && [[ $WORKFLOW != "echo '{}' | " ]]; then add_W o2-calibration-ccdb-populator-workflow "--ccdb-path $CCDB_POPULATOR_UPLOAD_PATH --environment \"DPL_DONT_DROP_OLD_TIMESLICE=1\" --sspec-min $CCDBPRO_SUBSPEC_MIN --sspec-max $CCDBPRO_SUBSPEC_MAX"; fi
 
-if [[ $CCDB_DCS_POPULATOR_UPLOAD_PATH != "none" ]] && [[ ! -z $WORKFLOW ]] && [[ $WORKFLOW != "echo '{}' | " ]] && [[ $NEED_DCS_CCDB_POPULATOR != 0 ]]; then add_W o2-calibration-ccdb-populator-workflow "--ccdb-path $CCDB_DCS_POPULATOR_UPLOAD_PATH --environment \"DPL_DONT_DROP_OLD_TIMESLICE=1\" --sspec-min $CCDBDCS_SUBSPEC_MIN --sspec-max $CCDBDCS_SUBSPEC_MAX --name-extention dcs"; fi
+if [[ $CCDB_DCS_POPULATOR_UPLOAD_PATH != "none" ]] && [[ -n $WORKFLOW ]] && [[ $WORKFLOW != "echo '{}' | " ]] && [[ $NEED_DCS_CCDB_POPULATOR != 0 ]]; then add_W o2-calibration-ccdb-populator-workflow "--ccdb-path $CCDB_DCS_POPULATOR_UPLOAD_PATH --environment \"DPL_DONT_DROP_OLD_TIMESLICE=1\" --sspec-min $CCDBDCS_SUBSPEC_MIN --sspec-max $CCDBDCS_SUBSPEC_MAX --name-extention dcs"; fi
 
 if ! workflow_has_parameter CALIB_LOCAL_INTEGRATED_AGGREGATOR; then
   WORKFLOW+="o2-dpl-run $ARGS_ALL $GLOBALDPLOPT"
   [[ $WORKFLOWMODE != "print" ]] && WORKFLOW+=" --${WORKFLOWMODE} ${WORKFLOWMODE_FILE:-}"
   [[ $WORKFLOWMODE == "print" || "${PRINT_WORKFLOW:-}" == "1" ]] && echo "#Aggregator Workflow command:\n\n${WORKFLOW}\n" | sed -e "s/\\\\n/\n/g" -e"s/| */| \\\\\n/g" | eval cat $( [[ $WORKFLOWMODE == "dds" ]] && echo '1>&2')
-  if [[ $WORKFLOWMODE != "print" ]] && [[ ! -z $WORKFLOW ]] && [[ $WORKFLOW != "echo '{}' | " ]]; then eval $WORKFLOW; else true; fi
+  if [[ $WORKFLOWMODE != "print" ]] && [[ -n $WORKFLOW ]] && [[ $WORKFLOW != "echo '{}' | " ]]; then eval $WORKFLOW; else true; fi
 fi
diff --git a/prodtests/full-system-test/calib-workflow.sh b/prodtests/full-system-test/calib-workflow.sh
index 94e95eaab6567..3c05ca6cda303 100755
--- a/prodtests/full-system-test/calib-workflow.sh
+++ b/prodtests/full-system-test/calib-workflow.sh
@@ -55,14 +55,14 @@ if [[ $CALIB_ASYNC_EXTRACTTPCCURRENTS == 1 ]]; then
 fi
 if [[ $CALIB_ASYNC_EXTRACTTIMESERIES == 1 ]] ; then
   : ${CALIB_ASYNC_SAMPLINGFACTORTIMESERIES:=0.001}
-  if [[ ! -z ${CALIB_ASYNC_ENABLEUNBINNEDTIMESERIES:-} ]]; then
+  if [[ -n ${CALIB_ASYNC_ENABLEUNBINNEDTIMESERIES:-} ]]; then
     CONFIG_TPCTIMESERIES+=" --enable-unbinned-root-output --sample-unbinned-tsallis --threads ${TPCTIMESERIES_THREADS:-1}"
   fi
-  if [[ $ON_SKIMMED_DATA == 1 ]] || [[ ! -z "$CALIB_ASYNC_SAMPLINGFACTORTIMESERIES" ]]; then
+  if [[ $ON_SKIMMED_DATA == 1 ]] || [[ -n "$CALIB_ASYNC_SAMPLINGFACTORTIMESERIES" ]]; then
     if [[ $ON_SKIMMED_DATA == 1 ]]; then
       SAMPLINGFACTORTIMESERIES=0.1
     fi
-    if [[ ! -z "$CALIB_ASYNC_SAMPLINGFACTORTIMESERIES" ]]; then # this takes priority, even if we were on skimmed data
+    if [[ -n "$CALIB_ASYNC_SAMPLINGFACTORTIMESERIES" ]]; then # this takes priority, even if we were on skimmed data
       SAMPLINGFACTORTIMESERIES=${CALIB_ASYNC_SAMPLINGFACTORTIMESERIES}
     fi
     CONFIG_TPCTIMESERIES+=" --sampling-factor ${SAMPLINGFACTORTIMESERIES}"
@@ -74,28 +74,28 @@ fi
 
 # output-proxy for aggregator
 if workflow_has_parameter CALIB_PROXIES; then
-  if [[ ! -z ${CALIBDATASPEC_BARREL_TF:-} ]]; then
+  if [[ -n ${CALIBDATASPEC_BARREL_TF:-} ]]; then
     add_W o2-dpl-output-proxy "--dataspec \"$CALIBDATASPEC_BARREL_TF\" $(get_proxy_connection barrel_tf output timeframe)" "" 0
   fi
-  if [[ ! -z ${CALIBDATASPEC_BARREL_SPORADIC:-} ]]; then
+  if [[ -n ${CALIBDATASPEC_BARREL_SPORADIC:-} ]]; then
     add_W o2-dpl-output-proxy "--dataspec \"$CALIBDATASPEC_BARREL_SPORADIC\" $(get_proxy_connection barrel_sp output sporadic)" "" 0
   fi
-  if [[ ! -z ${CALIBDATASPEC_CALO_TF:-} ]]; then
+  if [[ -n ${CALIBDATASPEC_CALO_TF:-} ]]; then
     add_W o2-dpl-output-proxy "--dataspec \"$CALIBDATASPEC_CALO_TF\" $(get_proxy_connection calo_tf output timeframe)" "" 0
   fi
-  if [[ ! -z ${CALIBDATASPEC_CALO_SPORADIC:-} ]]; then
+  if [[ -n ${CALIBDATASPEC_CALO_SPORADIC:-} ]]; then
     add_W o2-dpl-output-proxy "--dataspec \"$CALIBDATASPEC_CALO_SPORADIC\" $(get_proxy_connection calo_sp output sporadic)" "" 0
   fi
-  if [[ ! -z ${CALIBDATASPEC_MUON_TF:-} ]]; then
+  if [[ -n ${CALIBDATASPEC_MUON_TF:-} ]]; then
     add_W o2-dpl-output-proxy "--dataspec \"$CALIBDATASPEC_MUON_TF\" $(get_proxy_connection muon_tf output timeframe)" "" 0
   fi
-  if [[ ! -z ${CALIBDATASPEC_MUON_SPORADIC:-} ]]; then
+  if [[ -n ${CALIBDATASPEC_MUON_SPORADIC:-} ]]; then
     add_W o2-dpl-output-proxy "--dataspec \"$CALIBDATASPEC_MUON_SPORADIC\" $(get_proxy_connection muon_sp output sporadic)" "" 0
   fi
-  if [[ ! -z ${CALIBDATASPEC_FORWARD_TF:-} ]]; then
+  if [[ -n ${CALIBDATASPEC_FORWARD_TF:-} ]]; then
     add_W o2-dpl-output-proxy "--dataspec \"$CALIBDATASPEC_FORWARD_TF\" $(get_proxy_connection fwd_tf output timeframe)" "" 0
   fi
-  if [[ ! -z ${CALIBDATASPEC_FORWARD_SPORADIC:-} ]]; then
+  if [[ -n ${CALIBDATASPEC_FORWARD_SPORADIC:-} ]]; then
     add_W o2-dpl-output-proxy "--dataspec \"$CALIBDATASPEC_FORWARD_SPORADIC\" $(get_proxy_connection fwd_sp output sporadic)" "" 0
   fi
 fi
diff --git a/prodtests/full-system-test/datadistribution.sh b/prodtests/full-system-test/datadistribution.sh
index 40fda852a7a6e..657d38b954583 100755
--- a/prodtests/full-system-test/datadistribution.sh
+++ b/prodtests/full-system-test/datadistribution.sh
@@ -11,7 +11,7 @@ fi
 # For benchmark only, do NOT copy&paste!
 [[ $NUMAGPUIDS == 1 ]] && [[ -z $SHM_MANAGER_SHMID ]] && export DATADIST_SHM_DELAY=10
 
-if [[ ! -z $DD_STARTUP_DELAY ]]; then
+if [[ -n $DD_STARTUP_DELAY ]]; then
   sleep $DD_STARTUP_DELAY
 fi
 
@@ -34,7 +34,7 @@ export TFRATE=$(awk "BEGIN {printf \"%.6f\",1/$TFDELAY}")
 
 ARGS_ALL="--session ${OVERRIDE_SESSION:-default} --severity $SEVERITY --shm-segment-id 2 --shm-segment-size 1000000 --no-cleanup"
 
-[[ ! -z $SHM_MANAGER_SHMID ]] && SHM_TOOL_OPTIONS=" --shmid $SHM_MANAGER_SHMID --data-source-region-shmid 100 --data-source-header-shmid 101"
+[[ -n $SHM_MANAGER_SHMID ]] && SHM_TOOL_OPTIONS=" --shmid $SHM_MANAGER_SHMID --data-source-region-shmid 100 --data-source-header-shmid 101"
 
 eval StfBuilder --id stfb --discovery-partition FST --transport shmem \
   --dpl-channel-name dpl-chan --channel-config "name=dpl-chan,type=push,method=bind,address=ipc://${UDS_PREFIX}${INRAWCHANNAME},transport=shmem,rateLogging=1" \
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 486be1a9160cd..55186dbff9c84 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -61,10 +61,10 @@ if [[ -z ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $DIGITINPUT != 1 ]]; then
   TIMEFRAME_RATE_LIMIT=$((12 * 230 / ${RECO_NUM_NODES_WORKFLOW_CMP} * ($NUMAGPUIDS != 0 ? 1 : 2) * 128 / $NHBPERTF))
   [[ $BEAMTYPE != "PbPb" && ${HIGH_RATE_PP:-0} == 0 ]] && TIMEFRAME_RATE_LIMIT=$(($TIMEFRAME_RATE_LIMIT * 3))
   ! has_detector TPC && TIMEFRAME_RATE_LIMIT=$(($TIMEFRAME_RATE_LIMIT * 4))
-  [[ ! -z ${EPN_GLOBAL_SCALING:-} ]] && TIMEFRAME_RATE_LIMIT=$(($TIMEFRAME_RATE_LIMIT * $EPN_GLOBAL_SCALING))
+  [[ -n ${EPN_GLOBAL_SCALING:-} ]] && TIMEFRAME_RATE_LIMIT=$(($TIMEFRAME_RATE_LIMIT * $EPN_GLOBAL_SCALING))
   [[ ${TIMEFRAME_RATE_LIMIT} -ge 512 ]] && TIMEFRAME_RATE_LIMIT=512
 fi
-[[ ! -z ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $TIMEFRAME_RATE_LIMIT != 0 ]] && ARGS_ALL+=" --timeframes-rate-limit $TIMEFRAME_RATE_LIMIT --timeframes-rate-limit-ipcid ${O2JOBID:-$NUMAID}"
+[[ -n ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $TIMEFRAME_RATE_LIMIT != 0 ]] && ARGS_ALL+=" --timeframes-rate-limit $TIMEFRAME_RATE_LIMIT --timeframes-rate-limit-ipcid ${O2JOBID:-$NUMAID}"
 if [[ $EPNSYNCMODE == 1 ]]; then
   SYNCRAWMODE=1
 elif [[ -z ${SYNCRAWMODE:-} ]]; then
@@ -125,7 +125,7 @@ if [[ $SYNCMODE == 1 ]]; then
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=20000;MCHTracking.maxTrackingDuration=10;"
     MFT_CONFIG_KEY+="MFTTracking.cutMultClusLow=0;MFTTracking.cutMultClusHigh=3000;"
   fi
-  [[ ! -z ${CUT_RANDOM_FRACTION_ITS:-} ]] && ITS_CONFIG_KEY+="fastMultConfig.cutRandomFraction=$CUT_RANDOM_FRACTION_ITS;"
+  [[ -n ${CUT_RANDOM_FRACTION_ITS:-} ]] && ITS_CONFIG_KEY+="fastMultConfig.cutRandomFraction=$CUT_RANDOM_FRACTION_ITS;"
   ITS_CONFIG_KEY+="ITSCATrackerParam.trackletsPerClusterLimit=${CUT_TRACKLETSPERCLUSTER_MAX_ITS:--1};ITSCATrackerParam.cellsPerClusterLimit=${CUT_CELLSPERCLUSTER_MAX_ITS:--1};"
   if has_detector_reco ITS; then
     [[ $RUNTYPE != "COSMICS" ]] && MFT_CONFIG_KEY+="MFTTracking.irFramesOnly=1;"
@@ -161,9 +161,9 @@ else
   fi
 fi
 [[ $CTFINPUT == 1 ]] && GPU_CONFIG_KEY+="GPU_proc.tpcInputWithClusterRejection=1;"
-[[ ! -z $NTRDTRKTHREADS ]] && TRD_CONFIG_KEY+="GPU_proc.ompThreads=$NTRDTRKTHREADS;"
-[[ ! -z $NGPURECOTHREADS ]] && GPU_CONFIG_KEY+="GPU_proc.ompThreads=$NGPURECOTHREADS;"
-[[ ! -z $NMFTTHREADS ]] && MFT_CONFIG+=" --nThreads $NMFTTHREADS"
+[[ -n $NTRDTRKTHREADS ]] && TRD_CONFIG_KEY+="GPU_proc.ompThreads=$NTRDTRKTHREADS;"
+[[ -n $NGPURECOTHREADS ]] && GPU_CONFIG_KEY+="GPU_proc.ompThreads=$NGPURECOTHREADS;"
+[[ -n $NMFTTHREADS ]] && MFT_CONFIG+=" --nThreads $NMFTTHREADS"
 [[ $ITSTRK_THREADS != 1 ]] && ITS_CONFIG_KEY+="ITSVertexerParam.nThreads=$ITSTRK_THREADS;ITSCATrackerParam.nThreads=$ITSTRK_THREADS;"
 
 if [[ $BEAMTYPE == "PbPb" ]]; then
@@ -185,7 +185,7 @@ else
 fi
 
 if [[ $SYNCMODE == 1 ]] && [[ ${PRESCALE_ITS_WO_TRIGGER:-} != 1 ]]; then
-  if has_detector TRD && [[ ! -z ${PRESCALE_ITS_WITH_TRD:-} ]]; then
+  if has_detector TRD && [[ -n ${PRESCALE_ITS_WITH_TRD:-} ]]; then
     ITS_CONFIG+=" --select-with-triggers trd "
   else
     ITS_CONFIG+=" --select-with-triggers phys "
@@ -248,7 +248,7 @@ if [[ $SYNCMODE == 1 && "0${ED_NO_ITS_ROF_FILTER:-}" != "01" && $BEAMTYPE == "Pb
   EVE_CONFIG+=";eveconf.filterITSROF=true;"
 fi
 
-if [[ ! -z ${EVE_NTH_EVENT:-} ]]; then
+if [[ -n ${EVE_NTH_EVENT:-} ]]; then
   EVE_CONFIG+=";eveconf.onlyNthEvent=$EVE_NTH_EVENT;"
 fi
 
@@ -275,13 +275,13 @@ if [[ $GPUTYPE == "HIP" ]]; then
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
   # serialization workaround for MI100 nodes: remove it again if the problem will be fixed in ROCm, then also remove the DISABLE_MI100_SERIALIZATION flag in the O2DPG parse script
-  [[ $EPNSYNCMODE == 1 || ! -z ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.amdMI100SerializationWorkaround=1;"
+  [[ $EPNSYNCMODE == 1 || -n ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.amdMI100SerializationWorkaround=1;"
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else
   GPU_CONFIG_KEY+="GPU_proc.deviceNum=-2;"
 fi
 
-if [[ ! -z ${GPU_NUM_MEM_REG_CALLBACKS:-} ]]; then
+if [[ -n ${GPU_NUM_MEM_REG_CALLBACKS:-} ]]; then
   GPU_CONFIG+=" --expected-region-callbacks $GPU_NUM_MEM_REG_CALLBACKS"
 fi
 
@@ -352,7 +352,7 @@ fi
 
 ( workflow_has_parameter AOD || [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-emcal-cell-writer-workflow ) && has_detector EMC && RAW_EMC_SUBSPEC=" --subspecification 1 "
 has_detector_reco MID && has_detector_matching MCHMID && MFTMCHConf="FwdMatching.useMIDMatch=true;" || MFTMCHConf="FwdMatching.useMIDMatch=false;"
-[[ ! -z ${MFTMCH_NCANDIDATES_OPT:-} ]] && MFTMCHConf+="${MFTMCH_NCANDIDATES_OPT}"
+[[ -n ${MFTMCH_NCANDIDATES_OPT:-} ]] && MFTMCHConf+="${MFTMCH_NCANDIDATES_OPT}"
 
 [[ $IS_SIMULATED_DATA == "1" ]] && EMCRAW2C_CONFIG+=" --no-checkactivelinks"
 
@@ -368,12 +368,12 @@ if has_processing_step MUON_SYNC_RECO; then
     MCH_CONFIG_KEY+="MCHTracking.chamberResolutionX=0.4;MCHTracking.chamberResolutionY=0.4;MCHTracking.sigmaCutForTracking=7.;MCHTracking.sigmaCutForImprovement=6.;"
   fi
   has_detector_reco ITS && [[ $RUNTYPE != "COSMICS" ]] && MCH_CONFIG_KEY+="MCHTimeClusterizer.irFramesOnly=true;"
-  [[ ! -z ${CUT_RANDOM_FRACTION_MCH:-} ]] && MCH_CONFIG_KEY+="MCHTimeClusterizer.rofRejectionFraction=$CUT_RANDOM_FRACTION_MCH;"
+  [[ -n ${CUT_RANDOM_FRACTION_MCH:-} ]] && MCH_CONFIG_KEY+="MCHTimeClusterizer.rofRejectionFraction=$CUT_RANDOM_FRACTION_MCH;"
   MCH_CONFIG_KEY+="MCHStatusMap.useHV=false;MCHDigitFilter.statusMask=3;"
   [[ $RUNTYPE == "COSMICS" ]] && [[ -z ${CONFIG_EXTRA_PROCESS_o2_mft_reco_workflow:-} ]] && CONFIG_EXTRA_PROCESS_o2_mft_reco_workflow="MFTTracking.FullClusterScan=true"
 fi
 [[ $SYNCRAWMODE == 1 ]] && [[ -z ${CONFIG_EXTRA_PROCESS_o2_zdc_digits_reco:-} ]] && CONFIG_EXTRA_PROCESS_o2_zdc_digits_reco='RecoParamZDC.tdc_calib[9]=1;RecoParamZDC.tdc_calib[0]=1;RecoParamZDC.tdc_calib[8]=1;RecoParamZDC.tdc_calib[1]=1;RecoParamZDC.tdc_calib[3]=1;RecoParamZDC.tdc_calib[6]=1;RecoParamZDC.tdc_calib[5]=1;RecoParamZDC.tdc_calib[4]=1;RecoParamZDC.tdc_calib[2]=1;RecoParamZDC.tdc_calib[7]=1;RecoParamZDC.energy_calib[13]=1;RecoParamZDC.energy_calib[12]=1;RecoParamZDC.energy_calib[11]=1;RecoParamZDC.energy_calib[6]=1;RecoParamZDC.energy_calib[25]=1;RecoParamZDC.energy_calib[14]=1;RecoParamZDC.energy_calib[20]=1;RecoParamZDC.energy_calib[5]=1;RecoParamZDC.energy_calib[0]=1;RecoParamZDC.energy_calib[19]=1;RecoParamZDC.tower_calib[1]=1;RecoParamZDC.tower_calib[2]=1;RecoParamZDC.tower_calib[3]=1;RecoParamZDC.tower_calib[4]=1;RecoParamZDC.tower_calib[24]=1;RecoParamZDC.tower_calib[21]=1;RecoParamZDC.tower_calib[22]=1;RecoParamZDC.tower_calib[23]=1;RecoParamZDC.tower_calib[18]=1;RecoParamZDC.tower_calib[16]=1;RecoParamZDC.tower_calib[17]=1;RecoParamZDC.tower_calib[15]=1;RecoParamZDC.tower_calib[8]=1;RecoParamZDC.tower_calib[9]=1;RecoParamZDC.tower_calib[7]=1;RecoParamZDC.tower_calib[10]=1'
-[[ $RUNTYPE != "COSMICS" ]] && [[ $RUNTYPE != "TECHNICAL" ]] && has_detectors_reco ITS && has_detector_matching PRIMVTX && [[ ! -z "$VERTEXING_SOURCES" ]] && EVE_CONFIG+=";eveconf.PVMode=true;"
+[[ $RUNTYPE != "COSMICS" ]] && [[ $RUNTYPE != "TECHNICAL" ]] && has_detectors_reco ITS && has_detector_matching PRIMVTX && [[ -n "$VERTEXING_SOURCES" ]] && EVE_CONFIG+=";eveconf.PVMode=true;"
 [[ $SYNCRAWMODE == 1 ]] && [[ -z ${CONFIG_EXTRA_PROCESS_o2_trd_global_tracking:-} ]] && CONFIG_EXTRA_PROCESS_o2_trd_global_tracking='GPU_rec_trd.maxChi2=25;GPU_rec_trd.penaltyChi2=20;GPU_rec_trd.extraRoadY=4;GPU_rec_trd.extraRoadZ=10;GPU_rec_trd.applyDeflectionCut=0;GPU_rec_trd.trkltResRPhiIdeal=1'
 [[ $SYNCRAWMODE == 1 ]] && [[ -z ${ARGS_EXTRA_PROCESS_o2_phos_reco_workflow:-} ]] && ARGS_EXTRA_PROCESS_o2_phos_reco_workflow='--presamples 2 --fitmethod semigaus'
 [[ $SYNCRAWMODE == 1 ]] && [[ $BEAMTYPE == "PbPb" ]] && [[ -z ${CONFIG_EXTRA_PROCESS_o2_calibration_emcal_channel_calib_workflow:-} ]] && CONFIG_EXTRA_PROCESS_o2_calibration_emcal_channel_calib_workflow='EMCALCalibParams.selectedClassMasks=C0TVX-NONE-NOPF-EMC:c0tvxtsc-b-nopf-emc:C0TVXTCE-B-NOPF-EMC;EMCALCalibParams.fractionEvents_bc=0.3'
@@ -390,7 +390,7 @@ INPUT_DETECTOR_LIST=$WORKFLOW_DETECTORS
 : ${GLOBAL_READER_OPTIONS:=}
 : ${GLOBAL_READER_NEEDS_PV:=}
 : ${GLOBAL_READER_NEEDS_SV:=}
-if [[ ! -z ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS} ]] || [[ ! -z ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_CLUSTERS} ]]; then
+if [[ -n ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS} ]] || [[ -n ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_CLUSTERS} ]]; then
   for i in ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS//,/ }; do
     export INPUT_DETECTOR_LIST=$(echo $INPUT_DETECTOR_LIST | sed -e "s/,$i,/,/g" -e "s/^$i,//" -e "s/,$i"'$'"//" -e "s/^$i"'$'"//")
   done
@@ -402,7 +402,7 @@ if [[ ! -z ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS} ]] || [[ ! -z ${WORKFL
   [[ $GLOBAL_READER_NEEDS_PV == 1 ]] && GLOBAL_READER_OPTIONS+=" --primary-vertices"
   [[ $GLOBAL_READER_NEEDS_SV == 1 ]] && GLOBAL_READER_OPTIONS+=" --secondary-vertices"
 
-  if [[ ! -z ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $TIMEFRAME_RATE_LIMIT != 0 ]]; then
+  if [[ -n ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $TIMEFRAME_RATE_LIMIT != 0 ]]; then
     HBFINI_OPTIONS=" --hbfutils-config o2_tfidinfo.root,upstream "
     add_W o2-reader-driver-workflow "$HBFINI_OPTIONS"
   else
@@ -417,17 +417,17 @@ if [[ ! -z ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS} ]] || [[ ! -z ${WORKFL
   has_detector MCH && has_detector_from_global_reader MCH && add_W o2-mch-clusters-reader-workflow "$HBFINI_OPTIONS" "" 0
   has_detector MCH && has_detector_from_global_reader MCH && add_W o2-mch-preclusters-reader-workflow "$HBFINI_OPTIONS" "" 0
   has_detector TRD && has_detector_from_global_reader TRD && add_W o2-trd-digit-reader-workflow "$DISABLE_MC --digit-subspec 0 --disable-trigrec $HBFINI_OPTIONS"
-  has_detector TRD && has_detector_from_global_reader TRD && [[ ! -z "$TRD_SOURCES" ]] && has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-calib-reader-workflow "--trd-calib-infile trdcaliboutput.root $HBFINI_OPTIONS"
+  has_detector TRD && has_detector_from_global_reader TRD && [[ -n "$TRD_SOURCES" ]] && has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-calib-reader-workflow "--trd-calib-infile trdcaliboutput.root $HBFINI_OPTIONS"
   has_detector TOF && has_detector_from_global_reader TOF && add_W o2-tof-reco-workflow "$DISABLE_MC --input-type digits --output-type NONE $HBFINI_OPTIONS"
 fi
 
-if [[ ! -z $INPUT_DETECTOR_LIST ]]; then
+if [[ -n $INPUT_DETECTOR_LIST ]]; then
   if [[ $CTFINPUT == 1 ]]; then
     GPU_INPUT=compressed-clusters-ctf
     TOF_INPUT=digits
     CTFName=`ls -t $RAWINPUTDIR/o2_ctf_*.root 2> /dev/null | head -n1`
     [[ -z $CTFName && $WORKFLOWMODE == "print" ]] && CTFName='$CTFName'
-    [[ ! -z ${INPUT_FILE_LIST:-} ]] && CTFName=$INPUT_FILE_LIST
+    [[ -n ${INPUT_FILE_LIST:-} ]] && CTFName=$INPUT_FILE_LIST
     if [[ -z $CTFName && $WORKFLOWMODE != "print" ]]; then echo "No CTF file given!"; exit 1; fi
     if [[ $NTIMEFRAMES == -1 ]]; then NTIMEFRAMES_CMD= ; else NTIMEFRAMES_CMD="--max-tf $NTIMEFRAMES"; fi
     CTF_EMC_SUBSPEC=
@@ -436,7 +436,7 @@ if [[ ! -z $INPUT_DETECTOR_LIST ]]; then
   elif [[ $RAWTFINPUT == 1 ]]; then
     TFName=`ls -t $RAWINPUTDIR/o2_*.tf 2> /dev/null | head -n1`
     [[ -z $TFName && $WORKFLOWMODE == "print" ]] && TFName='$TFName'
-    [[ ! -z ${INPUT_FILE_LIST:-} ]] && TFName=$INPUT_FILE_LIST
+    [[ -n ${INPUT_FILE_LIST:-} ]] && TFName=$INPUT_FILE_LIST
     if [[ -z $TFName && $WORKFLOWMODE != "print" ]]; then echo "No raw file given!"; exit 1; fi
     if [[ $NTIMEFRAMES == -1 ]]; then NTIMEFRAMES_CMD= ; else NTIMEFRAMES_CMD="--max-tf $NTIMEFRAMES"; fi
     if [[ -z $WORKFLOW_DETECTORS_FLP_PROCESSING || $WORKFLOW_DETECTORS_FLP_PROCESSING == "NONE" ]]; then
@@ -479,7 +479,7 @@ if [[ ! -z $INPUT_DETECTOR_LIST ]]; then
         PROXY_INSPEC+=";$PROXY_INNAME:$i/$j"
       done
     done
-    [[ ! -z ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $TIMEFRAME_RATE_LIMIT != 0 ]] && PROXY_CHANNEL+=";name=metric-feedback,type=pull,method=connect,address=ipc://${UDS_PREFIX}metric-feedback-${O2JOBID:-$NUMAID},transport=shmem,rateLogging=0"
+    [[ -n ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $TIMEFRAME_RATE_LIMIT != 0 ]] && PROXY_CHANNEL+=";name=metric-feedback,type=pull,method=connect,address=ipc://${UDS_PREFIX}metric-feedback-${O2JOBID:-$NUMAID},transport=shmem,rateLogging=0"
     if [[ $EPNSYNCMODE == 1 ]]; then
       RAWPROXY_CONFIG="--print-input-sizes 1000"
     else
@@ -505,7 +505,7 @@ fi
 if [[ -z ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS} ]] && [[ -z ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_CLUSTERS} ]]; then
   # if root output is requested, record info of processed TFs DataHeader for replay of root files
   ROOT_OUTPUT_ASKED=`declare -p | cut -d' ' -f3 | cut -d'=' -f1 | grep ENABLE_ROOT_OUTPUT_`
-  [[ -z "$DISABLE_ROOT_OUTPUT" ]] || [[ ! -z $ROOT_OUTPUT_ASKED ]] && add_W o2-tfidinfo-writer-workflow
+  [[ -z "$DISABLE_ROOT_OUTPUT" ]] || [[ -n $ROOT_OUTPUT_ASKED ]] && add_W o2-tfidinfo-writer-workflow
 fi
 
 # if TPC correction with IDC from CCDB was requested
@@ -551,8 +551,8 @@ fi
 has_detector_reco FT0 && ! has_detector_from_global_reader FT0 && add_W o2-ft0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N ft0-reconstructor FT0 REST 1)"
 has_detector_reco TRD && ! has_detector_from_global_reader TRD && add_W o2-trd-tracklet-transformer "--disable-irframe-reader $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_FILTER_CONFIG --pipeline $(get_N TRDTRACKLETTRANSFORMER TRD REST 1 TRDTRKTRANS)"
 has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $SEND_ITSTPC_DTGL  $TPC_CORR_OPT --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
-has_detector_reco TRD && [[ ! -z "$TRD_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-global-tracking "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_CONFIG $TRD_FILTER_CONFIG $TPC_CORR_OPT --track-sources $TRD_SOURCES --pipeline $(get_N trd-globaltracking_TPC_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_CTP_ TRD REST 1 TRDTRK)" "$TRD_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
-has_detector_reco TOF && [[ ! -z "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TPC_CORR_OPT ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
+has_detector_reco TRD && [[ -n "$TRD_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-global-tracking "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_CONFIG $TRD_FILTER_CONFIG $TPC_CORR_OPT --track-sources $TRD_SOURCES --pipeline $(get_N trd-globaltracking_TPC_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_CTP_ TRD REST 1 TRDTRK)" "$TRD_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
+has_detector_reco TOF && [[ -n "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TPC_CORR_OPT ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
 has_detectors TPC && [[ -z "$DISABLE_ROOT_OUTPUT" && "${SKIP_TPC_CLUSTERSTRACKS_OUTPUT:-}" != 1 ]] && ! has_detector_from_global_reader TPC && add_W o2-tpc-reco-workflow "--input-type pass-through --output-type clusters,tpc-triggers,tracks,send-clusters-per-sector $DISABLE_MC"
 
 # ---------------------------------------------------------------------------------------------------------------------
@@ -564,7 +564,7 @@ has_detector FDD && ! has_detector_from_global_reader FDD && has_processing_step
 has_detector FV0 && ! has_detector_from_global_reader FV0 && has_processing_step FV0_RECO && add_W o2-fv0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC"
 has_detector ZDC && ! has_detector_from_global_reader ZDC && has_processing_step ZDC_RECO && add_W o2-zdc-digits-reco "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC"
 has_detector HMP && ! has_detector_from_global_reader HMP && has_processing_step HMP_RECO && add_W o2-hmpid-digits-to-clusters-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT --pipeline $(get_N HMP-Clusterization HMP REST 1 HMPCLUS)"
-has_detector HMP && [[ ! -z "$HMP_SOURCES" ]] && has_detector_matching HMP && ! has_detector_from_global_reader_tracks HMP && add_W o2-hmpid-matcher-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --track-sources $HMP_SOURCES --pipeline $(get_N hmp-matcher HMP REST 1 HMPMATCH)"
+has_detector HMP && [[ -n "$HMP_SOURCES" ]] && has_detector_matching HMP && ! has_detector_from_global_reader_tracks HMP && add_W o2-hmpid-matcher-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --track-sources $HMP_SOURCES --pipeline $(get_N hmp-matcher HMP REST 1 HMPMATCH)"
 has_detectors_reco MCH MID && has_detector_matching MCHMID && ! has_detector_from_global_reader_tracks "MCH-MID" && add_W o2-muon-tracks-matcher-workflow "$DISABLE_ROOT_INPUT $DISABLE_MC $DISABLE_ROOT_OUTPUT --pipeline $(get_N muon-track-matcher MATCH REST 1)"
 has_detectors_reco MFT MCH && has_detector_matching MFTMCH && ! has_detector_from_global_reader_tracks "MFT-MCH" && add_W o2-globalfwd-matcher-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N globalfwd-track-matcher MATCH REST 1 FWDMATCH)" "$MFTMCHConf"
 
@@ -595,9 +595,9 @@ has_detector_reco ITS && has_detector_gpu ITS TPC && [[ -z "$DISABLE_ROOT_OUTPUT
 
 # always run vertexing if requested and if there are some sources, but in cosmic mode we work in pass-trough mode (create record for non-associated tracks)
 ( [[ $BEAMTYPE == "cosmic" ]] || ! has_detector_reco ITS) && PVERTEX_CONFIG+=" --skip"
-has_detector_matching PRIMVTX && [[ ! -z "$VERTEXING_SOURCES" ]] && [[ $GLOBAL_READER_NEEDS_PV != 1 ]] && add_W o2-primary-vertexing-workflow "$DISABLE_MC $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $PVERTEX_CONFIG --pipeline $(get_N primary-vertexing MATCH REST 1 PRIMVTX),$(get_N pvertex-track-matching MATCH REST 1 PRIMVTXMATCH)" "${PVERTEXING_CONFIG_KEY};${INTERACTION_TAG_CONFIG_KEY};"
+has_detector_matching PRIMVTX && [[ -n "$VERTEXING_SOURCES" ]] && [[ $GLOBAL_READER_NEEDS_PV != 1 ]] && add_W o2-primary-vertexing-workflow "$DISABLE_MC $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $PVERTEX_CONFIG --pipeline $(get_N primary-vertexing MATCH REST 1 PRIMVTX),$(get_N pvertex-track-matching MATCH REST 1 PRIMVTXMATCH)" "${PVERTEXING_CONFIG_KEY};${INTERACTION_TAG_CONFIG_KEY};"
 
-if [[ $BEAMTYPE != "cosmic" ]] && has_detectors_reco ITS && has_detector_matching SECVTX && [[ ! -z "$SVERTEXING_SOURCES" ]]; then
+if [[ $BEAMTYPE != "cosmic" ]] && has_detectors_reco ITS && has_detector_matching SECVTX && [[ -n "$SVERTEXING_SOURCES" ]]; then
   : ${REDUCESV_OPT:=}
   : ${REDUCESV_CONF:=}
   if [[ $SYNCMODE == 1 ]] && [[ $SECVTXK0ONLY != 0 ]] ; then
@@ -613,7 +613,7 @@ fi
 
 # ---------------------------------------------------------------------------------------------------------------------
 # Entropy encoding / ctf creation workflows - disabled in async mode
-if has_processing_step ENTROPY_ENCODER && [[ ! -z "$WORKFLOW_DETECTORS_CTF" ]] && [[ $WORKFLOW_DETECTORS_CTF != "NONE" ]]; then
+if has_processing_step ENTROPY_ENCODER && [[ -n "$WORKFLOW_DETECTORS_CTF" ]] && [[ $WORKFLOW_DETECTORS_CTF != "NONE" ]]; then
   # Entropy encoder workflows
   has_detector_ctf MFT && add_W o2-itsmft-entropy-encoder-workflow "$RANS_OPT --mem-factor ${MFT_ENC_MEMFACT:-1.5} --runmft true --pipeline $(get_N mft-entropy-encoder MFT CTF 1)"
   has_detector_ctf FT0 && add_W o2-ft0-entropy-encoder-workflow "$RANS_OPT --mem-factor ${FT0_ENC_MEMFACT:-1.5} --pipeline $(get_N ft0-entropy-encoder FT0 CTF 1)"
@@ -660,7 +660,7 @@ workflow_has_parameters CALIB CALIB_LOCAL_INTEGRATED_AGGREGATOR && { source ${CA
 # RS this is a temporary setting
 : ${ED_TRACKS:=$TRACK_SOURCES}
 : ${ED_CLUSTERS:=$TRACK_SOURCES}
-workflow_has_parameter EVENT_DISPLAY && [[ $NUMAID == 0 ]] && [[ ! -z "$ED_TRACKS" ]] && [[ ! -z "$ED_CLUSTERS" ]] && [[ $EPNSYNCMODE == 0 || ${EPN_NODE_MI100:-0} == 0 ]] && add_W o2-eve-export-workflow "--display-tracks $ED_TRACKS --display-clusters $ED_CLUSTERS --skipOnEmptyInput $DISABLE_ROOT_INPUT $EVE_OPT $DISABLE_MC" "$ITSMFT_STROBES;$EVE_CONFIG"
+workflow_has_parameter EVENT_DISPLAY && [[ $NUMAID == 0 ]] && [[ -n "$ED_TRACKS" ]] && [[ -n "$ED_CLUSTERS" ]] && [[ $EPNSYNCMODE == 0 || ${EPN_NODE_MI100:-0} == 0 ]] && add_W o2-eve-export-workflow "--display-tracks $ED_TRACKS --display-clusters $ED_CLUSTERS --skipOnEmptyInput $DISABLE_ROOT_INPUT $EVE_OPT $DISABLE_MC" "$ITSMFT_STROBES;$EVE_CONFIG"
 
 workflow_has_parameter GPU_DISPLAY && [[ $NUMAID == 0 ]] && add_W o2-gpu-display "${ED_TRACKS+--display-tracks} $ED_TRACKS ${ED_CLUSTERS+--display-clusters} $ED_CLUSTERS"
 
@@ -668,7 +668,7 @@ workflow_has_parameter GPU_DISPLAY && [[ $NUMAID == 0 ]] && add_W o2-gpu-display
 # AOD
 [[ ${SECTVTX_ON:-} != "1" ]] && AODPROD_OPT+=" --disable-secondary-vertices "
 AODPROD_OPT+=" $STRTRACKING "
-workflow_has_parameter AOD && [[ ! -z "$AOD_SOURCES" ]] && add_W o2-aod-producer-workflow "$AODPROD_OPT --info-sources $AOD_SOURCES $DISABLE_ROOT_INPUT --aod-writer-keep dangling --aod-writer-resfile \"AO2D\" --aod-writer-resmode UPDATE $DISABLE_MC --pipeline $(get_N aod-producer-workflow AOD REST 1 AODPROD)"
+workflow_has_parameter AOD && [[ -n "$AOD_SOURCES" ]] && add_W o2-aod-producer-workflow "$AODPROD_OPT --info-sources $AOD_SOURCES $DISABLE_ROOT_INPUT --aod-writer-keep dangling --aod-writer-resfile \"AO2D\" --aod-writer-resmode UPDATE $DISABLE_MC --pipeline $(get_N aod-producer-workflow AOD REST 1 AODPROD)"
 
 # extra workflows in case we want to extra ITS/MFT info for dead channel maps to then go to CCDB for MC
 : ${ALIEN_JDL_PROCESSITSDEADMAP:=}
@@ -681,15 +681,15 @@ workflow_has_parameter AOD && [[ ! -z "$AOD_SOURCES" ]] && add_W o2-aod-producer
 # Quality Control
 workflow_has_parameter QC && { source $O2DPG_ROOT/DATA/production/qc-workflow.sh; [[ $? != 0 ]] && echo "qc-workflow.sh failed" 1>&2 && exit 1; }
 
-if [[ ! -z "${EXTRA_WORKFLOW:-}" ]]; then
+if [[ -n "${EXTRA_WORKFLOW:-}" ]]; then
   WORKFLOW+="$EXTRA_WORKFLOW"
 fi
 
-if [[ ! -z "${ADD_EXTRA_WORKFLOW:-}" ]]; then
+if [[ -n "${ADD_EXTRA_WORKFLOW:-}" ]]; then
   OLD_IFS=$IFS
   IFS=','
   for wf in $ADD_EXTRA_WORKFLOW; do
-    [[ ! -z "$wf" ]] && add_W $wf
+    [[ -n "$wf" ]] && add_W $wf
   done
   IFS="$OLD_IFS"
 fi
diff --git a/prodtests/full-system-test/run-workflow-on-inputlist.sh b/prodtests/full-system-test/run-workflow-on-inputlist.sh
index 63a2e3344428a..6622866afa745 100755
--- a/prodtests/full-system-test/run-workflow-on-inputlist.sh
+++ b/prodtests/full-system-test/run-workflow-on-inputlist.sh
@@ -18,7 +18,7 @@ if [[ $2 != "LOCAL" && ! -f $2 ]]; then
 fi
 
 for i in EXTINPUT CTFINPUT RAWTFINPUT DIGITINPUT; do
-  [[ ! -z ${!i} ]] && { echo "$i must not be set!"; exit 1; }
+  [[ -n ${!i} ]] && { echo "$i must not be set!"; exit 1; }
 done
 
 NUM_PROCS=0
@@ -87,7 +87,7 @@ fi
 TIMEOUT_PHASE=0
 while [[ `jobs -rl | grep -v " $PID_LOG Running" | wc -l` -ne 0 ]]; do
   sleep 1
-  if [[ ! -z $3 && $(date +%s) -ge $(($START_TIME + $TIMEOUT_PHASE * 20 + $3)) ]]; then
+  if [[ -n $3 && $(date +%s) -ge $(($START_TIME + $TIMEOUT_PHASE * 20 + $3)) ]]; then
     RETVAL=1
     let TIMEOUT_PHASE=$TIMEOUT_PHASE+1
     echo "Timeout reached ($3 seconds) - Sending SIGINT signal"
diff --git a/prodtests/full-system-test/start_tmux.sh b/prodtests/full-system-test/start_tmux.sh
index 3048943241627..39922ea5503d2 100755
--- a/prodtests/full-system-test/start_tmux.sh
+++ b/prodtests/full-system-test/start_tmux.sh
@@ -107,7 +107,7 @@ if [[ -z $SHM_MANAGER_SHMID ]]; then
   fi
 fi
 [[ ${O2_GPU_RTC:-0} == 1 ]] && FST_SLEEP2=60
-[[ ! -z $FST_TMUX_DD_WAIT ]] && FST_SLEEP2=$FST_TMUX_DD_WAIT
+[[ -n $FST_TMUX_DD_WAIT ]] && FST_SLEEP2=$FST_TMUX_DD_WAIT
 
 if workflow_has_parameter CALIB_PROXIES; then
   CALIB_COMMAND="$GEN_TOPO_MYDIR/aggregator-workflow.sh"
diff --git a/prodtests/full-system-test/tf-reader.sh b/prodtests/full-system-test/tf-reader.sh
index 84b5877d194a2..d9740df7e6530 100755
--- a/prodtests/full-system-test/tf-reader.sh
+++ b/prodtests/full-system-test/tf-reader.sh
@@ -21,7 +21,7 @@ fi
 
 TFName=`ls -t $RAWINPUTDIR/o2_*.tf 2> /dev/null | head -n1`
 [[ -z $TFName && $WORKFLOWMODE == "print" ]] && TFName='$TFName'
-[[ ! -z $INPUT_FILE_LIST ]] && TFName=$INPUT_FILE_LIST
+[[ -n $INPUT_FILE_LIST ]] && TFName=$INPUT_FILE_LIST
 if [[ -z $TFName && $WORKFLOWMODE != "print" ]]; then echo "No raw file given!"; exit 1; fi
 
 o2-raw-tf-reader-workflow $ARGS_ALL --loop $NTIMEFRAMES --delay $TFDELAY --input-data ${TFName} ${INPUT_FILE_COPY_CMD+--copy-cmd} ${INPUT_FILE_COPY_CMD} --onlyDet $WORKFLOW_DETECTORS --raw-channel-config "name=dpl-chan,type=push,method=bind,address=ipc://${UDS_PREFIX}${INRAWCHANNAME},transport=shmem,rateLogging=0" $GLOBALDPLOPT --run
diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index e8b298cc08d8c..6100e3ed87a2c 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -122,8 +122,8 @@ fi
 DIGITOPT=
 DIGITOPTKEYTRD="TRDSimParams.digithreads=${NJOBS};"
 DIGITOPTKEY=${HBFUTILPARAMS}
-[[ ! -z $ITS_STROBE ]] && DIGITOPTKEY+="ITSAlpideParam.roFrameLengthInBC=$ITS_STROBE;"
-[[ ! -z $MFT_STROBE ]] && DIGITOPTKEY+="MFTAlpideParam.roFrameLengthInBC=$MFT_STROBE;"
+[[ -n $ITS_STROBE ]] && DIGITOPTKEY+="ITSAlpideParam.roFrameLengthInBC=$ITS_STROBE;"
+[[ -n $MFT_STROBE ]] && DIGITOPTKEY+="MFTAlpideParam.roFrameLengthInBC=$MFT_STROBE;"
 if [ $SPLITTRDDIGI == "1" ]; then
   DIGITOPT+=" --skipDet TRD"
   DIGITOPTKEYTRD+=${HBFUTILPARAMS}
@@ -202,7 +202,7 @@ STAGES+=" ASYNC"
 if [[ ${RANS_OPT:-} =~ (--ans-version +)(compat) ]] ; then
   # Give a possibility to run the FST with external existing dictionary (i.e. with CREATECTFDICT=0 full_system_test.sh)
   # In order to use CCDB dictionaries, pass CTFDICTFILE=ccdb CREATECTFDICT=0
-  [[ ! -z "$CREATECTFDICT" ]] && SYNCMODEDOCTFDICT="$CREATECTFDICT" || SYNCMODEDOCTFDICT=1
+  [[ -n "$CREATECTFDICT" ]] && SYNCMODEDOCTFDICT="$CREATECTFDICT" || SYNCMODEDOCTFDICT=1
 
   # this is default local tree-based CTF dictionary file
   [[ -z "$CTFDICTFILE" ]] && CTFDICTFILE="ctf_dictionary.root"

From 7423aa7f192cf59887d7d453aae9dff1f94add33 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 18 Jul 2025 14:13:25 +0200
Subject: [PATCH 0636/1764] TPC: Avoid using deprecated fmt::localtime

---
 Detectors/TPC/base/src/CDBInterface.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/TPC/base/src/CDBInterface.cxx b/Detectors/TPC/base/src/CDBInterface.cxx
index 605413b205c2a..06f6a360670dc 100644
--- a/Detectors/TPC/base/src/CDBInterface.cxx
+++ b/Detectors/TPC/base/src/CDBInterface.cxx
@@ -722,6 +722,8 @@ void CDBStorage::printObjectSummary(std::string_view name, CDBType const type, M
 {
   std::time_t tstart(start / 1000);
   std::time_t tend(end / 1000);
+  std::tm ttstart = *std::localtime(&tstart);
+  std::tm ttend = *std::localtime(&tend);
   auto tstartms = start % 1000;
   auto tendms = end % 1000;
 
@@ -729,7 +731,7 @@ void CDBStorage::printObjectSummary(std::string_view name, CDBType const type, M
                         fmt::format("          to storage '{}'\n", mCCDB.getURL()) +
                         fmt::format("          into path '{}'\n", CDBTypeMap.at(type)) +
                         fmt::format("          with validity [{}, {}] :", start, end) +
-                        fmt::format("          [{:%d.%m.%Y %H:%M:%S}.{:03d}, {:%d.%m.%Y %H:%M:%S}.{:03d}]\n", fmt::localtime(tstart), tstartms, fmt::localtime(tend), tendms) +
+                        fmt::format("          [{:%d.%m.%Y %H:%M:%S}.{:03d}, {:%d.%m.%Y %H:%M:%S}.{:03d}]\n", ttstart, tstartms, ttend, tendms) +
                         std::string("          Meta data:\n");
 
   for (const auto& [key, value] : metadata) {

From 8252a1f46af3e24c0d691a261f578942c1905e15 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 18 Jul 2025 23:59:47 +0200
Subject: [PATCH 0637/1764] DPL: out of line metrics related methods

---
 .../include/Framework/DeviceMetricsInfo.h     | 60 +------------------
 Framework/Core/src/DeviceMetricsInfo.cxx      | 58 ++++++++++++++++++
 2 files changed, 61 insertions(+), 57 deletions(-)

diff --git a/Framework/Core/include/Framework/DeviceMetricsInfo.h b/Framework/Core/include/Framework/DeviceMetricsInfo.h
index d55f1cb44f71d..ad143b7ef9373 100644
--- a/Framework/Core/include/Framework/DeviceMetricsInfo.h
+++ b/Framework/Core/include/Framework/DeviceMetricsInfo.h
@@ -12,7 +12,6 @@
 #ifndef O2_FRAMEWORK_DEVICEMETRICSINFO_H_
 #define O2_FRAMEWORK_DEVICEMETRICSINFO_H_
 
-#include "Framework/RuntimeError.h"
 #include "Framework/CompilerBuiltins.h"
 #include "Framework/Traits.h"
 #include <array>
@@ -21,6 +20,7 @@
 #include <span>
 #include <string>
 #include <vector>
+#include <iosfwd>
 
 namespace o2::framework
 {
@@ -191,62 +191,8 @@ struct DeviceMetricsInfoHelpers {
     }
   }
 
-  static void clearMetrics(std::vector<DeviceMetricsInfo>& infos)
-  {
-    for (auto& info : infos) {
-      info.intMetrics.clear();
-      info.uint64Metrics.clear();
-      info.stringMetrics.clear(); // We do not keep so many strings as metrics as history is less relevant.
-      info.floatMetrics.clear();
-      info.enumMetrics.clear();
-      info.intTimestamps.clear();
-      info.uint64Timestamps.clear();
-      info.floatTimestamps.clear();
-      info.stringTimestamps.clear();
-      info.enumTimestamps.clear();
-      info.max.clear();
-      info.min.clear();
-      info.average.clear();
-      info.minDomain.clear();
-      info.maxDomain.clear();
-      info.metricLabels.clear();
-      info.metricPrefixes.clear();
-      info.metricLabelsAlphabeticallySortedIdx.clear();
-      info.metricLabelsPrefixesSortedIdx.clear();
-      info.metrics.clear();
-      info.changed.clear();
-    }
-  }
-  static size_t metricsStorageSize(std::span<DeviceMetricsInfo const> infos)
-  {
-    // Count the size of the metrics storage
-    size_t totalSize = 0;
-    for (auto& info : infos) {
-      totalSize += info.intMetrics.size() * sizeof(MetricsStorage<int>);
-      totalSize += info.uint64Metrics.size() * sizeof(MetricsStorage<uint64_t>);
-      totalSize += info.stringMetrics.size() * sizeof(MetricsStorage<StringMetric>);
-      totalSize += info.floatMetrics.size() * sizeof(MetricsStorage<float>);
-      totalSize += info.enumMetrics.size() * sizeof(MetricsStorage<int8_t>);
-      totalSize += info.intTimestamps.size() * sizeof(TimestampsStorage<int>);
-      totalSize += info.uint64Timestamps.size() * sizeof(TimestampsStorage<uint64_t>);
-      totalSize += info.floatTimestamps.size() * sizeof(TimestampsStorage<float>);
-      totalSize += info.stringTimestamps.size() * sizeof(TimestampsStorage<StringMetric>);
-      totalSize += info.enumTimestamps.size() * sizeof(TimestampsStorage<int8_t>);
-      totalSize += info.max.size() * sizeof(float);
-      totalSize += info.min.size() * sizeof(float);
-      totalSize += info.average.size() * sizeof(float);
-      totalSize += info.minDomain.size() * sizeof(size_t);
-      totalSize += info.maxDomain.size() * sizeof(size_t);
-      totalSize += info.metricLabels.size() * sizeof(MetricLabel);
-      totalSize += info.metricPrefixes.size() * sizeof(MetricPrefix);
-      totalSize += info.metricLabelsAlphabeticallySortedIdx.size() * sizeof(MetricLabelIndex);
-      totalSize += info.metricLabelsPrefixesSortedIdx.size() * sizeof(MetricPrefixIndex);
-      totalSize += info.metrics.size() * sizeof(MetricInfo);
-      totalSize += info.changed.size() * sizeof(bool);
-    }
-
-    return totalSize;
-  }
+  static void clearMetrics(std::vector<DeviceMetricsInfo>& infos);
+  static size_t metricsStorageSize(std::span<DeviceMetricsInfo const> infos);
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/DeviceMetricsInfo.cxx b/Framework/Core/src/DeviceMetricsInfo.cxx
index 9a208c4535554..ccb8d5d2e6d8f 100644
--- a/Framework/Core/src/DeviceMetricsInfo.cxx
+++ b/Framework/Core/src/DeviceMetricsInfo.cxx
@@ -50,4 +50,62 @@ std::ostream& operator<<(std::ostream& oss, MetricType const& val)
   return oss;
 }
 
+void DeviceMetricsInfoHelpers::clearMetrics(std::vector<DeviceMetricsInfo>& infos)
+{
+  for (auto& info : infos) {
+    info.intMetrics.clear();
+    info.uint64Metrics.clear();
+    info.stringMetrics.clear(); // We do not keep so many strings as metrics as history is less relevant.
+    info.floatMetrics.clear();
+    info.enumMetrics.clear();
+    info.intTimestamps.clear();
+    info.uint64Timestamps.clear();
+    info.floatTimestamps.clear();
+    info.stringTimestamps.clear();
+    info.enumTimestamps.clear();
+    info.max.clear();
+    info.min.clear();
+    info.average.clear();
+    info.minDomain.clear();
+    info.maxDomain.clear();
+    info.metricLabels.clear();
+    info.metricPrefixes.clear();
+    info.metricLabelsAlphabeticallySortedIdx.clear();
+    info.metricLabelsPrefixesSortedIdx.clear();
+    info.metrics.clear();
+    info.changed.clear();
+  }
+}
+
+size_t DeviceMetricsInfoHelpers::metricsStorageSize(std::span<DeviceMetricsInfo const> infos)
+{
+  // Count the size of the metrics storage
+  size_t totalSize = 0;
+  for (auto& info : infos) {
+    totalSize += info.intMetrics.size() * sizeof(MetricsStorage<int>);
+    totalSize += info.uint64Metrics.size() * sizeof(MetricsStorage<uint64_t>);
+    totalSize += info.stringMetrics.size() * sizeof(MetricsStorage<StringMetric>);
+    totalSize += info.floatMetrics.size() * sizeof(MetricsStorage<float>);
+    totalSize += info.enumMetrics.size() * sizeof(MetricsStorage<int8_t>);
+    totalSize += info.intTimestamps.size() * sizeof(TimestampsStorage<int>);
+    totalSize += info.uint64Timestamps.size() * sizeof(TimestampsStorage<uint64_t>);
+    totalSize += info.floatTimestamps.size() * sizeof(TimestampsStorage<float>);
+    totalSize += info.stringTimestamps.size() * sizeof(TimestampsStorage<StringMetric>);
+    totalSize += info.enumTimestamps.size() * sizeof(TimestampsStorage<int8_t>);
+    totalSize += info.max.size() * sizeof(float);
+    totalSize += info.min.size() * sizeof(float);
+    totalSize += info.average.size() * sizeof(float);
+    totalSize += info.minDomain.size() * sizeof(size_t);
+    totalSize += info.maxDomain.size() * sizeof(size_t);
+    totalSize += info.metricLabels.size() * sizeof(MetricLabel);
+    totalSize += info.metricPrefixes.size() * sizeof(MetricPrefix);
+    totalSize += info.metricLabelsAlphabeticallySortedIdx.size() * sizeof(MetricLabelIndex);
+    totalSize += info.metricLabelsPrefixesSortedIdx.size() * sizeof(MetricPrefixIndex);
+    totalSize += info.metrics.size() * sizeof(MetricInfo);
+    totalSize += info.changed.size() * sizeof(bool);
+  }
+
+  return totalSize;
+}
+
 } // namespace o2::framework

From b8d64940c709e422fbc62dd7e7c555cdaef87348 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 21 Jul 2025 10:27:54 +0200
Subject: [PATCH 0638/1764] ITS: cleanup lines and tracklet/clusterlines
 changes (#14511)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

FullCi is green, merging.
---
 .../include/ITStracking/ClusterLines.h        | 128 +++++++-----------
 .../tracking/include/ITStracking/Tracklet.h   |  61 ++-------
 .../ITSMFT/ITS/tracking/src/ClusterLines.cxx  |  49 ++++---
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |   2 +
 4 files changed, 86 insertions(+), 154 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
index 3377b88e89069..3ffeda9adcfd5 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
@@ -15,25 +15,25 @@
 #include <array>
 #include <vector>
 #include "ITStracking/Cluster.h"
-#include "ITStracking/Definitions.h"
+#include "ITStracking/Constants.h"
 #include "ITStracking/Tracklet.h"
+#include "GPUCommonRtypes.h"
 #include "GPUCommonMath.h"
 
 namespace o2::its
 {
 struct Line final {
-  GPUhd() Line();
+  GPUhdDefault() Line() = default;
   GPUhd() Line(const Line&);
   Line(std::array<float, 3> firstPoint, std::array<float, 3> secondPoint);
-  GPUhd() Line(const float firstPoint[3], const float secondPoint[3]);
   GPUhd() Line(const Tracklet&, const Cluster*, const Cluster*);
 
   static float getDistanceFromPoint(const Line& line, const std::array<float, 3>& point);
   GPUhd() static float getDistanceFromPoint(const Line& line, const float point[3]);
   static std::array<float, 6> getDCAComponents(const Line& line, const std::array<float, 3> point);
   GPUhd() static void getDCAComponents(const Line& line, const float point[3], float destArray[6]);
-  GPUhd() static float getDCA(const Line&, const Line&, const float precision = 1e-14);
-  static bool areParallel(const Line&, const Line&, const float precision = 1e-14);
+  GPUhd() static float getDCA(const Line&, const Line&, const float precision = constants::Tolerance);
+  static bool areParallel(const Line&, const Line&, const float precision = constants::Tolerance);
   GPUhd() unsigned char isEmpty() const { return (originPoint[0] == 0.f && originPoint[1] == 0.f && originPoint[2] == 0.f) &&
                                                  (cosinesDirector[0] == 0.f && cosinesDirector[1] == 0.f && cosinesDirector[2] == 0.f); }
   GPUhdi() auto getDeltaROF() const { return rof[1] - rof[0]; }
@@ -42,8 +42,9 @@ struct Line final {
   bool operator!=(const Line&) const;
   short getMinROF() const { return rof[0] < rof[1] ? rof[0] : rof[1]; }
 
-  float originPoint[3], cosinesDirector[3];
-  float weightMatrix[6] = {1., 0., 0., 1., 0., 1.};
+  float originPoint[3] = {0};
+  float cosinesDirector[3] = {0};
+  // float weightMatrix[6] = {1., 0., 0., 1., 0., 1.};
   // weightMatrix is a symmetric matrix internally stored as
   //    0 --> row = 0, col = 0
   //    1 --> 0,1
@@ -51,14 +52,10 @@ struct Line final {
   //    3 --> 1,1
   //    4 --> 1,2
   //    5 --> 2,2
-  short rof[2];
-};
+  short rof[2] = {-1, -1};
 
-GPUhdi() Line::Line() : weightMatrix{1., 0., 0., 1., 0., 1.}
-{
-  rof[0] = -1;
-  rof[1] = -1;
-}
+  ClassDefNV(Line, 1);
+};
 
 GPUhdi() Line::Line(const Line& other)
 {
@@ -66,32 +63,14 @@ GPUhdi() Line::Line(const Line& other)
     originPoint[i] = other.originPoint[i];
     cosinesDirector[i] = other.cosinesDirector[i];
   }
-  for (int i{0}; i < 6; ++i) {
-    weightMatrix[i] = other.weightMatrix[i];
-  }
+  // for (int i{0}; i < 6; ++i) {
+  //   weightMatrix[i] = other.weightMatrix[i];
+  // }
   for (int i{0}; i < 2; ++i) {
     rof[i] = other.rof[i];
   }
 }
 
-GPUhdi() Line::Line(const float firstPoint[3], const float secondPoint[3])
-{
-  for (int i{0}; i < 3; ++i) {
-    originPoint[i] = firstPoint[i];
-    cosinesDirector[i] = secondPoint[i] - firstPoint[i];
-  }
-
-  float inverseNorm{1.f / o2::gpu::CAMath::Sqrt(cosinesDirector[0] * cosinesDirector[0] + cosinesDirector[1] * cosinesDirector[1] +
-                                                cosinesDirector[2] * cosinesDirector[2])};
-
-  for (int index{0}; index < 3; ++index) {
-    cosinesDirector[index] *= inverseNorm;
-  }
-
-  rof[0] = -1;
-  rof[1] = -1;
-}
-
 GPUhdi() Line::Line(const Tracklet& tracklet, const Cluster* innerClusters, const Cluster* outerClusters)
 {
   originPoint[0] = innerClusters[tracklet.firstClusterIndex].xCoordinate;
@@ -102,12 +81,10 @@ GPUhdi() Line::Line(const Tracklet& tracklet, const Cluster* innerClusters, cons
   cosinesDirector[1] = outerClusters[tracklet.secondClusterIndex].yCoordinate - innerClusters[tracklet.firstClusterIndex].yCoordinate;
   cosinesDirector[2] = outerClusters[tracklet.secondClusterIndex].zCoordinate - innerClusters[tracklet.firstClusterIndex].zCoordinate;
 
-  float inverseNorm{1.f / o2::gpu::CAMath::Sqrt(cosinesDirector[0] * cosinesDirector[0] + cosinesDirector[1] * cosinesDirector[1] +
-                                                cosinesDirector[2] * cosinesDirector[2])};
-
-  for (int index{0}; index < 3; ++index) {
-    cosinesDirector[index] *= inverseNorm;
-  }
+  float inverseNorm{1.f / o2::gpu::CAMath::Hypot(cosinesDirector[0], cosinesDirector[1], cosinesDirector[2])};
+  cosinesDirector[0] *= inverseNorm;
+  cosinesDirector[1] *= inverseNorm;
+  cosinesDirector[2] *= inverseNorm;
 
   rof[0] = tracklet.rof[0];
   rof[1] = tracklet.rof[1];
@@ -130,47 +107,38 @@ inline float Line::getDistanceFromPoint(const Line& line, const std::array<float
 
 GPUhdi() float Line::getDistanceFromPoint(const Line& line, const float point[3])
 {
-  float DCASquared{0};
-  float cdelta{0};
-  for (int i{0}; i < 3; ++i) {
-    cdelta -= line.cosinesDirector[i] * (line.originPoint[i] - point[i]);
-  }
-  for (int i{0}; i < 3; ++i) {
-    DCASquared += (line.originPoint[i] - point[i] + line.cosinesDirector[i] * cdelta) *
-                  (line.originPoint[i] - point[i] + line.cosinesDirector[i] * cdelta);
-  }
-  return o2::gpu::CAMath::Sqrt(DCASquared);
+  const float dx = point[0] - line.originPoint[0];
+  const float dy = point[1] - line.originPoint[1];
+  const float dz = point[2] - line.originPoint[2];
+  const float d = (dx * line.cosinesDirector[0]) + (dy * line.cosinesDirector[1]) + (dz * line.cosinesDirector[2]);
+
+  const float vx = dx - (d * line.cosinesDirector[0]);
+  const float vy = dy - (d * line.cosinesDirector[1]);
+  const float vz = dz - (d * line.cosinesDirector[2]);
+
+  return o2::gpu::CAMath::Hypot(vx, vy, vz);
 }
 
 GPUhdi() float Line::getDCA(const Line& firstLine, const Line& secondLine, const float precision)
 {
-  float normalVector[3];
-  normalVector[0] = firstLine.cosinesDirector[1] * secondLine.cosinesDirector[2] -
-                    firstLine.cosinesDirector[2] * secondLine.cosinesDirector[1];
-  normalVector[1] = -firstLine.cosinesDirector[0] * secondLine.cosinesDirector[2] +
-                    firstLine.cosinesDirector[2] * secondLine.cosinesDirector[0];
-  normalVector[2] = firstLine.cosinesDirector[0] * secondLine.cosinesDirector[1] -
-                    firstLine.cosinesDirector[1] * secondLine.cosinesDirector[0];
-
-  float norm{0.f}, distance{0.f};
-  for (int i{0}; i < 3; ++i) {
-    norm += normalVector[i] * normalVector[i];
-    distance += (secondLine.originPoint[i] - firstLine.originPoint[i]) * normalVector[i];
-  }
-  if (norm > precision) {
-    return o2::gpu::CAMath::Abs(distance / o2::gpu::CAMath::Sqrt(norm));
-  } else {
-#if defined(__CUDACC__) || defined(__HIPCC__)
-    float stdOriginPoint[3];
-    for (int i{0}; i < 3; ++i) {
-      stdOriginPoint[i] = secondLine.originPoint[1];
-    }
-#else
-    std::array<float, 3> stdOriginPoint = {};
-    std::copy_n(secondLine.originPoint, 3, stdOriginPoint.begin());
-#endif
-    return getDistanceFromPoint(firstLine, stdOriginPoint);
+  const float nx = (firstLine.cosinesDirector[1] * secondLine.cosinesDirector[2]) -
+                   (firstLine.cosinesDirector[2] * secondLine.cosinesDirector[1]);
+  const float ny = -(firstLine.cosinesDirector[0] * secondLine.cosinesDirector[2]) +
+                   (firstLine.cosinesDirector[2] * secondLine.cosinesDirector[0]);
+  const float nz = (firstLine.cosinesDirector[0] * secondLine.cosinesDirector[1]) -
+                   (firstLine.cosinesDirector[1] * secondLine.cosinesDirector[0]);
+  const float norm2 = (nx * nx) + (ny * ny) + (nz * nz);
+
+  if (norm2 <= precision * precision) {
+    return getDistanceFromPoint(firstLine, secondLine.originPoint);
   }
+
+  const float dx = secondLine.originPoint[0] - firstLine.originPoint[0];
+  const float dy = secondLine.originPoint[1] - firstLine.originPoint[1];
+  const float dz = secondLine.originPoint[2] - firstLine.originPoint[2];
+  const float triple = (dx * nx) + (dy * ny) + (dz * nz);
+
+  return o2::gpu::CAMath::Abs(triple) / o2::gpu::CAMath::Sqrt(norm2);
 }
 
 GPUhdi() void Line::getDCAComponents(const Line& line, const float point[3], float destArray[6])
@@ -199,11 +167,7 @@ inline bool Line::operator==(const Line& rhs) const
 
 inline bool Line::operator!=(const Line& rhs) const
 {
-  bool val;
-  for (int i{0}; i < 3; ++i) {
-    val &= this->originPoint[i] != rhs.originPoint[i];
-  }
-  return val;
+  return !(*this == rhs);
 }
 
 GPUhdi() void Line::print() const
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
index e0ae23c8bedde..ba3474e6e86c6 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
@@ -20,53 +20,48 @@
 #include "GPUCommonRtypes.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonDef.h"
+#include "GPUCommonLogger.h"
 
 #ifndef GPUCA_GPUCODE_DEVICE
+#ifndef GPU_NO_FMT
 #include <string>
+#include <fmt/format.h>
+#endif
 #endif
 
 namespace o2::its
 {
 
 struct Tracklet final {
-  GPUhdi() Tracklet();
+  GPUhdDefault() Tracklet() = default;
   GPUhdi() Tracklet(const int, const int, const Cluster&, const Cluster&, short rof0, short rof1);
   GPUhdi() Tracklet(const int, const int, float tanL, float phi, short rof0, short rof1);
-  GPUhdi() bool operator==(const Tracklet&) const;
-  GPUhdi() bool operator!=(const Tracklet&) const;
+  GPUhdDefault() bool operator==(const Tracklet&) const = default;
   GPUhdi() unsigned char isEmpty() const
   {
     return firstClusterIndex < 0 || secondClusterIndex < 0;
   }
   GPUhdi() auto getDeltaRof() const { return rof[1] - rof[0]; }
-  GPUhdi() void dump();
   GPUhdi() void dump() const;
-  GPUhdi() void dump(const int, const int);
   GPUhdi() void dump(const int, const int) const;
   GPUhdi() unsigned char operator<(const Tracklet&) const;
-#ifndef GPUCA_GPUCODE_DEVICE
+#if !defined(GPUCA_NO_FMT) && !defined(GPUCA_GPUCODE_DEVICE)
   std::string asString() const
   {
-    return "fClIdx: " + std::to_string(firstClusterIndex) + " sClIdx: " + std::to_string(secondClusterIndex) +
-           " rof1: " + std::to_string(rof[0]) + " rof2: " + std::to_string(rof[1]) + " delta: " + std::to_string(getDeltaRof());
+    return fmt::format("fClIdx:{} fROF:{} sClIdx:{} sROF:{} (DROF:{})", firstClusterIndex, rof[0], secondClusterIndex, rof[1], getDeltaRof());
   }
+  void print() const { LOG(info) << asString(); }
 #endif
 
-  int firstClusterIndex;
-  int secondClusterIndex;
-  float tanLambda;
-  float phi;
-  short rof[2];
+  int firstClusterIndex{-1};
+  int secondClusterIndex{-1};
+  float tanLambda{-999};
+  float phi{-999};
+  short rof[2] = {-1, -1};
 
   ClassDefNV(Tracklet, 1);
 };
 
-GPUhdi() Tracklet::Tracklet() : firstClusterIndex{-1}, secondClusterIndex{-1}, tanLambda{0.0f}, phi{0.0f}
-{
-  rof[0] = -1;
-  rof[1] = -1;
-}
-
 GPUhdi() Tracklet::Tracklet(const int firstClusterOrderingIndex, const int secondClusterOrderingIndex,
                             const Cluster& firstCluster, const Cluster& secondCluster, short rof0 = -1, short rof1 = -1)
   : firstClusterIndex{firstClusterOrderingIndex},
@@ -90,24 +85,6 @@ GPUhdi() Tracklet::Tracklet(const int idx0, const int idx1, float tanL, float ph
   // Nothing to do
 }
 
-GPUhdi() bool Tracklet::operator==(const Tracklet& rhs) const
-{
-  return this->firstClusterIndex == rhs.firstClusterIndex &&
-         this->secondClusterIndex == rhs.secondClusterIndex &&
-         this->tanLambda == rhs.tanLambda &&
-         this->phi == rhs.phi &&
-         this->rof[0] == rhs.rof[0] &&
-         this->rof[1] == rhs.rof[1];
-}
-
-GPUhdi() bool Tracklet::operator!=(const Tracklet& rhs) const
-{
-  return this->firstClusterIndex != rhs.firstClusterIndex ||
-         this->secondClusterIndex != rhs.secondClusterIndex ||
-         this->tanLambda != rhs.tanLambda ||
-         this->phi != rhs.phi;
-}
-
 GPUhdi() unsigned char Tracklet::operator<(const Tracklet& t) const
 {
   if (isEmpty()) {
@@ -116,21 +93,11 @@ GPUhdi() unsigned char Tracklet::operator<(const Tracklet& t) const
   return true;
 }
 
-GPUhdi() void Tracklet::dump(const int offsetFirst, const int offsetSecond)
-{
-  printf("fClIdx: %d sClIdx: %d  rof1: %hu rof2: %hu\n", firstClusterIndex + offsetFirst, secondClusterIndex + offsetSecond, rof[0], rof[1]);
-}
-
 GPUhdi() void Tracklet::dump(const int offsetFirst, const int offsetSecond) const
 {
   printf("fClIdx: %d sClIdx: %d  rof1: %hu rof2: %hu\n", firstClusterIndex + offsetFirst, secondClusterIndex + offsetSecond, rof[0], rof[1]);
 }
 
-GPUhdi() void Tracklet::dump()
-{
-  printf("fClIdx: %d sClIdx: %d  rof1: %hu rof2: %hu\n", firstClusterIndex, secondClusterIndex, rof[0], rof[1]);
-}
-
 GPUhdi() void Tracklet::dump() const
 {
   printf("fClIdx: %d sClIdx: %d  rof1: %hu rof2: %hu\n", firstClusterIndex, secondClusterIndex, rof[0], rof[1]);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx b/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
index 570f58ca2695d..1a0fa1d3908a4 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
@@ -19,7 +19,6 @@ namespace its
 {
 
 Line::Line(std::array<float, 3> firstPoint, std::array<float, 3> secondPoint)
-  : weightMatrix{1., 0., 0., 1., 0., 1.} // dummy, ATM
 {
   for (int index{0}; index < 3; ++index) {
     originPoint[index] = firstPoint.data()[index];
@@ -95,9 +94,9 @@ ClusterLines::ClusterLines(const int firstLabel, const Line& firstLine, const in
   std::array<float, 3> covarianceFirst{1., 1., 1.};
   std::array<float, 3> covarianceSecond{1., 1., 1.};
 
-  for (int i{0}; i < 6; ++i) {
-    mWeightMatrix[i] = firstLine.weightMatrix[i] + secondLine.weightMatrix[i];
-  }
+  // for (int i{0}; i < 6; ++i) {
+  //   mWeightMatrix[i] = firstLine.weightMatrix[i] + secondLine.weightMatrix[i];
+  // }
 
   float determinantFirst =
     firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[0] * covarianceFirst[1] +
@@ -193,9 +192,9 @@ ClusterLines::ClusterLines(const Line& firstLine, const Line& secondLine)
   std::array<float, 3> covarianceSecond{1., 1., 1.};
   updateROFPoll(firstLine);
   updateROFPoll(secondLine);
-  for (int i{0}; i < 6; ++i) {
-    mWeightMatrix[i] = firstLine.weightMatrix[i] + secondLine.weightMatrix[i];
-  }
+  // for (int i{0}; i < 6; ++i) {
+  //   mWeightMatrix[i] = firstLine.weightMatrix[i] + secondLine.weightMatrix[i];
+  // }
 
   float determinantFirst =
     firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[0] * covarianceFirst[1] +
@@ -281,9 +280,9 @@ void ClusterLines::add(const int& lineLabel, const Line& line, const bool& weigh
   updateROFPoll(line);
   std::array<float, 3> covariance{1., 1., 1.};
 
-  for (int i{0}; i < 6; ++i) {
-    mWeightMatrix[i] += line.weightMatrix[i];
-  }
+  // for (int i{0}; i < 6; ++i) {
+  //   mWeightMatrix[i] += line.weightMatrix[i];
+  // }
   // if(weight) line->GetSigma2P0(covariance);
 
   double determinant{line.cosinesDirector[2] * line.cosinesDirector[2] * covariance[0] * covariance[1] +
@@ -370,25 +369,25 @@ bool ClusterLines::operator==(const ClusterLines& rhs) const
 GPUhdi() void ClusterLines::updateROFPoll(const Line& line)
 {
   // option 1: Boyer-Moore voting for rof label
-  // if (mROFWeight == 0) {
-  //   mROF = line.getMinROF();
-  //   mROFWeight = 1;
-  // } else {
-  //   if (mROF == line.getMinROF()) {
-  //     mROFWeight++;
-  //   } else {
-  //     mROFWeight--;
-  //   }
-  // }
-
-  // option 2
-  if (mROF == -1) {
+  if (mROFWeight == 0) {
     mROF = line.getMinROF();
+    mROFWeight = 1;
   } else {
-    if (line.getMinROF() < mROF) {
-      mROF = line.getMinROF();
+    if (mROF == line.getMinROF()) {
+      mROFWeight++;
+    } else {
+      mROFWeight--;
     }
   }
+
+  // option 2
+  // if (mROF == -1) {
+  //   mROF = line.getMinROF();
+  // } else {
+  //   if (line.getMinROF() < mROF) {
+  //     mROF = line.getMinROF();
+  //   }
+  // }
 }
 
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index ea57e5fa8e3b9..4115726756e73 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -711,6 +711,8 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mPrimaryVertices);
   deepVectorClear(mTrackletClusters);
   deepVectorClear(mVerticesContributorLabels);
+  deepVectorClear(mLines);
+  deepVectorClear(mLinesLabels);
 }
 
 template class TimeFrame<7>;

From d53e9d97c47971cd0bd2089475c2fa52e94729f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?= <vit.kucera@cern.ch>
Date: Wed, 9 Jul 2025 17:49:12 +0200
Subject: [PATCH 0639/1764] IWYU: TimeDeadMap.h

---
 .../ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h  | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h
index 5a93cbb712931..6c7c01dc888b7 100644
--- a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TimeDeadMap.h
@@ -14,9 +14,12 @@
 #ifndef ALICEO2_ITSMFT_TIMEDEADMAP_H
 #define ALICEO2_ITSMFT_TIMEDEADMAP_H
 
-#include "Rtypes.h"
-#include <vector>
+#include <Rtypes.h>
+
+#include <cstdint>
 #include <map>
+#include <string>
+#include <vector>
 
 namespace o2
 {

From ac2ac36b5eb805be6b82622aa30eecea7a096a75 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 22 Jul 2025 11:06:51 +0200
Subject: [PATCH 0640/1764] ITS: print deltaRof option (#14531)

---
 Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 6b2d80424b5bb..144b9a1dfc7c4 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -24,8 +24,8 @@ using namespace o2::its;
 
 std::string TrackingParameters::asString() const
 {
-  std::string str = std::format("NZb:{} NPhB:{} NROFIt:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{}",
-                                ZBins, PhiBins, nROFsPerIterations, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength);
+  std::string str = std::format("NZb:{} NPhB:{} NROFIt:{} DRof:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{}",
+                                ZBins, PhiBins, nROFsPerIterations, DeltaROF, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength);
   bool first = true;
   for (int il = NLayers; il >= MinTrackLength; il--) {
     int slot = NLayers - il;

From 3922d501a300cb3ebeb557de4af898ae5b779622 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 22 Jul 2025 11:07:19 +0200
Subject: [PATCH 0641/1764] ITS: add CheckDROF macro (#14533)

---
 .../ITSMFT/ITS/macros/test/CMakeLists.txt     |    5 +
 Detectors/ITSMFT/ITS/macros/test/CheckDROF.C  | 1426 +++++++++++++++++
 2 files changed, 1431 insertions(+)
 create mode 100644 Detectors/ITSMFT/ITS/macros/test/CheckDROF.C

diff --git a/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt b/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
index 2ed11fc852c8b..dd6aacf65db99 100644
--- a/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
@@ -113,3 +113,8 @@ o2_add_test_root_macro(CheckDuplicates.C
                        PUBLIC_LINK_LIBRARIES O2::DataFormatsITS
                                              O2::DataFormatsITSMFT
                        LABELS its)
+
+o2_add_test_root_macro(CheckDROF.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsITS
+                                             O2::DataFormatsITSMFT
+                       LABELS its)
diff --git a/Detectors/ITSMFT/ITS/macros/test/CheckDROF.C b/Detectors/ITSMFT/ITS/macros/test/CheckDROF.C
new file mode 100644
index 0000000000000..21428ea4fcbc2
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/macros/test/CheckDROF.C
@@ -0,0 +1,1426 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <iostream>
+#include <vector>
+
+#include <TFile.h>
+#include <TTree.h>
+#include <TClonesArray.h>
+#include "TH1F.h"
+#include <TH2F.h>
+#include "TH2D.h"
+#include "TH3D.h"
+#include <TProfile.h>
+#include <TCanvas.h>
+#include <THStack.h>
+#include <TLegend.h>
+#include <TPad.h>
+#include <TRatioPlot.h>
+
+#include "ITSBase/GeometryTGeo.h"
+#include "SimulationDataFormat/MCEventHeader.h"
+#include "DetectorsBase/Propagator.h"
+#include "SimulationDataFormat/TrackReference.h"
+#include "SimulationDataFormat/MCTrack.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "SimulationDataFormat/DigitizationContext.h"
+
+#endif
+
+using namespace std;
+using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
+
+void plotHistos(TFile* fWO, TFile* f, const char* append = "");
+
+struct ParticleInfo { // particle level information for tracks
+  int event;
+  int pdg;
+  float pt;
+  float eta;
+  float phi;
+  int mother;
+  int first;
+  float pvx{};
+  float pvy{};
+  float pvz{};
+  float dcaxy;
+  float dcaz;
+  unsigned short clusters = 0u;
+  unsigned char isReco = 0u;
+  unsigned char isFake = 0u;
+  bool isPrimary = false;
+  int bcInROF{-1};
+  int rofId{-1};
+  unsigned char storedStatus = 2; /// not stored = 2, fake = 1, good = 0
+  o2::its::TrackITS track;
+
+  void print() const
+  {
+    LOGP(info, "event={} pdg={} pt={} eta={} phi={} mother={} clusters={:7b} isReco={} isFake={} isPrimary={} bcInROF={} rofId={} | {}", event, pdg, pt, eta, phi, mother, clusters, isReco, isFake, isPrimary, bcInROF, rofId, track.asString());
+  }
+
+  int getNClusters() const noexcept
+  {
+    int nCl{0};
+    for (unsigned int bit{0}; bit < sizeof(ParticleInfo::clusters) * 8; ++bit) {
+      nCl += bool(clusters & (1 << bit));
+    }
+    return nCl;
+  }
+
+  bool isReconstructable() const noexcept
+  {
+    return isPrimary && (7 == getNClusters()) && bcInROF >= 0;
+  }
+};
+#pragma link C++ class ParticleInfo + ;
+#pragma link C++ class std::vector < ParticleInfo> + ;
+
+struct VertexInfo { // Vertex level info
+  float purity;     // fraction of main cont. labels to all
+  Vertex vertex;    // reconstructed vertex
+  int bcInROF{-1};
+  int rofId{-1};
+  int event{-1};                       // corresponding MC event
+  std::vector<o2::MCCompLabel> labels; // contributor labels
+  o2::MCCompLabel mainLabel;           // main label
+
+  void computeMain()
+  {
+    std::unordered_map<o2::MCCompLabel, size_t> freq;
+    size_t totalSet = 0;
+
+    // Count frequencies of set labels
+    for (auto const& lab : labels) {
+      if (lab.isSet()) {
+        ++freq[lab];
+        ++totalSet;
+      }
+    }
+    if (totalSet == 0) {
+      return;
+    }
+    // Find the label with maximum count
+    auto best = std::max_element(freq.begin(), freq.end(), [](auto const& a, auto const& b) { return a.second < b.second; });
+    size_t maxCount = best->second;
+
+    // If there's no majority (all counts == 1), fall back to first set label
+    o2::MCCompLabel mainLab;
+    if (maxCount == 1) {
+      for (auto const& lab : labels) {
+        if (lab.isSet()) {
+          mainLab = lab;
+          break;
+        }
+      }
+    } else {
+      mainLab = best->first;
+    }
+    purity = (float)maxCount / (float)labels.size();
+  }
+};
+#pragma link C++ class VertexInfo + ;
+
+using namespace o2::itsmft;
+using namespace o2::its;
+
+void CheckDROF(bool plot = false, bool write = false, const std::string& tracfile = "o2trac_its.root",
+               const std::string& magfile = "o2sim_grp.root",
+               const std::string& clusfile = "o2clus_its.root",
+               const std::string& kinefile = "o2sim_Kine.root")
+{
+  constexpr int64_t roFrameLengthInBC = 198; // for pp=198
+  constexpr int64_t roFrameBiasInBC = 64;    // ITS delay accounted for in digitization
+  constexpr float roFbins{roFrameLengthInBC + 2.f};
+  constexpr int bcValStart{60}, bcValEnd{140}; // adjustable region of validation train
+
+  if (!plot) {
+    int trackID, evID, srcID;
+    bool fake;
+
+    // Magnetic field and Propagator
+    o2::base::Propagator::initFieldFromGRP(magfile);
+    float bz = o2::base::Propagator::Instance()->getNominalBz();
+
+    // Geometry
+    o2::base::GeometryManager::loadGeometry();
+    auto gman = o2::its::GeometryTGeo::Instance();
+
+    // MC tracks
+    TFile* file0 = TFile::Open(kinefile.data());
+    TTree* mcTree = (TTree*)gFile->Get("o2sim");
+    mcTree->SetBranchStatus("*", 0); // disable all branches
+    mcTree->SetBranchStatus("MCTrack*", 1);
+    mcTree->SetBranchStatus("MCEventHeader*", 1);
+    std::vector<o2::MCTrack>* mcArr = nullptr;
+    mcTree->SetBranchAddress("MCTrack", &mcArr);
+    o2::dataformats::MCEventHeader* mcEvent = nullptr;
+    mcTree->SetBranchAddress("MCEventHeader.", &mcEvent);
+
+    auto* dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
+    const auto& irs = dc->getEventRecords();
+    dc->printCollisionSummary(false, 20);
+
+    // Clusters
+    TFile::Open(clusfile.data());
+    TTree* clusTree = (TTree*)gFile->Get("o2sim");
+    std::vector<CompClusterExt>* clusArr = nullptr;
+    clusTree->SetBranchAddress("ITSClusterComp", &clusArr);
+
+    // Cluster MC labels
+    o2::dataformats::MCTruthContainer<o2::MCCompLabel>* clusLabArr = nullptr;
+    clusTree->SetBranchAddress("ITSClusterMCTruth", &clusLabArr);
+
+    // Reconstructed tracks
+    TFile* file1 = TFile::Open(tracfile.data());
+    TTree* recTree = (TTree*)gFile->Get("o2sim");
+    std::vector<TrackITS>* recArr = nullptr;
+    recTree->SetBranchAddress("ITSTrack", &recArr);
+    // Track MC labels
+    std::vector<o2::MCCompLabel>* trkLabArr = nullptr;
+    recTree->SetBranchAddress("ITSTrackMCTruth", &trkLabArr);
+    std::vector<o2::itsmft::ROFRecord> rofRecVec, *rofRecVecP = &rofRecVec;
+    recTree->SetBranchAddress("ITSTracksROF", &rofRecVecP);
+    // Vertices
+    std::vector<Vertex>* recVerArr = nullptr;
+    recTree->SetBranchAddress("Vertices", &recVerArr);
+    std::vector<ROFRecord>* recVerROFArr = nullptr;
+    recTree->SetBranchAddress("VerticesROF", &recVerROFArr);
+    std::vector<o2::MCCompLabel>* recVerLabelsArr = nullptr;
+    recTree->SetBranchAddress("ITSVertexMCTruth", &recVerLabelsArr);
+    std::vector<float>* recVerPurityArr = nullptr;
+    recTree->SetBranchAddress("ITSVertexMCPurity", &recVerPurityArr);
+
+    std::cout << "** Filling particle table ... " << std::flush;
+    int lastEventIDcl = -1, cf = 0;
+    const int nev = mcTree->GetEntriesFast();
+    std::vector<std::vector<ParticleInfo>> info;
+    info.resize(nev);
+    TH1D* hZvertex = new TH1D("hZvertex", "Z vertex", 100, -20, 20);
+    for (int n = 0; n < nev; n++) { // loop over MC events
+      mcTree->GetEvent(n);
+      info[n].resize(mcArr->size());
+      hZvertex->Fill(mcEvent->GetZ());
+      const auto& ir = irs[mcEvent->GetEventID() - 1]; // event id start from 1
+      for (unsigned int mcI{0}; mcI < mcArr->size(); ++mcI) {
+        auto part = mcArr->at(mcI);
+        info[n][mcI].event = n;
+        info[n][mcI].pdg = part.GetPdgCode();
+        info[n][mcI].pvx = mcEvent->GetX();
+        info[n][mcI].pvy = mcEvent->GetY();
+        info[n][mcI].pvz = mcEvent->GetZ();
+        info[n][mcI].pt = part.GetPt();
+        info[n][mcI].phi = part.GetPhi();
+        info[n][mcI].eta = part.GetEta();
+        info[n][mcI].isPrimary = part.isPrimary();
+        if (!ir.isDummy()) {
+          info[n][mcI].bcInROF = (ir.toLong() - roFrameBiasInBC) % roFrameLengthInBC;
+          info[n][mcI].rofId = (ir.toLong() - roFrameBiasInBC) / roFrameLengthInBC;
+        }
+      }
+    }
+    std::cout << "done." << std::endl;
+
+    std::cout << "** Creating particle/clusters correspondance ... " << std::flush;
+    for (int frame = 0; frame < clusTree->GetEntriesFast(); frame++) { // Cluster frames
+      if (!clusTree->GetEvent(frame)) {
+        continue;
+      }
+
+      for (unsigned int iClus{0}; iClus < clusArr->size(); ++iClus) {
+        auto lab = (clusLabArr->getLabels(iClus))[0];
+        if (!lab.isValid() || lab.getSourceID() != 0 || !lab.isCorrect()) {
+          continue;
+        }
+
+        int trackID, evID, srcID;
+        bool fake;
+        lab.get(trackID, evID, srcID, fake);
+        if (evID < 0 || evID >= (int)info.size()) {
+          std::cout << "Cluster MC label eventID out of range" << std::endl;
+          continue;
+        }
+        if (trackID < 0 || trackID >= (int)info[evID].size()) {
+          std::cout << "Cluster MC label trackID out of range" << std::endl;
+          continue;
+        }
+
+        const CompClusterExt& c = (*clusArr)[iClus];
+        auto layer = gman->getLayer(c.getSensorID());
+        info[evID][trackID].clusters |= 1 << layer;
+      }
+    }
+    std::cout << "done." << std::endl;
+
+    std::cout << "** Analysing tracks... " << std::flush;
+    int unaccounted{0}, good{0}, fakes{0}, total{0}, length{0};
+    for (int frame = 0; frame < recTree->GetEntriesFast(); frame++) { // Cluster frames
+      if (!recTree->GetEvent(frame)) {
+        continue;
+      }
+      total += trkLabArr->size();
+      for (unsigned int iTrack{0}; iTrack < trkLabArr->size(); ++iTrack) {
+        auto lab = trkLabArr->at(iTrack);
+        if (!lab.isSet()) {
+          unaccounted++;
+          continue;
+        }
+        lab.get(trackID, evID, srcID, fake);
+        if (evID < 0 || evID >= (int)info.size()) {
+          unaccounted++;
+          continue;
+        }
+        if (trackID < 0 || trackID >= (int)info[evID].size()) {
+          unaccounted++;
+          continue;
+        }
+        info[evID][trackID].isReco += !fake;
+        info[evID][trackID].isFake += fake;
+        /// We keep the best track we would keep in the data
+        if (recArr->at(iTrack).isBetter(info[evID][trackID].track, 1.e9)) {
+          info[evID][trackID].track = recArr->at(iTrack);
+          info[evID][trackID].storedStatus = fake;
+          static float ip[2]{0., 0.};
+          info[evID][trackID].track.getImpactParams(info[evID][trackID].pvx, info[evID][trackID].pvy, info[evID][trackID].pvz, bz, ip);
+          info[evID][trackID].dcaxy = ip[0];
+          info[evID][trackID].dcaz = ip[1];
+        }
+
+        fakes += fake;
+        good += !fake;
+        if (!fake) {
+          for (unsigned int bit{0}; bit < 7; ++bit) {
+            length += bool(info[evID][trackID].clusters & (1 << bit));
+          }
+        }
+      }
+    }
+    std::cout << "done." << std::endl;
+    std::cout << "** Some statistics:" << std::endl;
+    std::cout << "\t- Total number of tracks: " << total << std::endl;
+    std::cout << "\t- Total number of tracks not corresponding to particles: " << unaccounted << " (" << unaccounted * 100. / total << "%)" << std::endl;
+    std::cout << "\t- Total number of fakes: " << fakes << " (" << fakes * 100. / total << "%)" << std::endl;
+    std::cout << "\t- Total number of good: " << good << " (" << good * 100. / total << "%)" << std::endl;
+    std::cout << "\t- Average length of good tracks: " << (double)length / (double)good << std::endl;
+
+    TFile* fOut{nullptr};
+    if (write) {
+      fOut = TFile::Open("checkDROF.root", "RECREATE");
+    }
+
+    const int nb = 100;
+    double xbins[nb + 1], ptcutl = 0.01, ptcuth = 10.;
+    double a = std::log(ptcuth / ptcutl) / nb;
+    for (int i = 0; i <= nb; i++) {
+      xbins[i] = ptcutl * std::exp(i * a);
+    }
+
+    //////////////////////
+    // Eff Tracks
+    {
+      auto num = new TH2D("num", ";#it{p}_{T} (GeV/#it{c});NCls;Efficiency (fake-track rate)", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      num->Sumw2();
+      auto fak = new TH2D("fak", ";#it{p}_{T} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      fak->Sumw2();
+      auto multiFak = new TH2D("multiFak", ";#it{p}_{T} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      multiFak->Sumw2();
+      auto clone = new TH2D("clone", ";#it{p}_{T} (GeV/#it{c});NCls;Clone", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      clone->Sumw2();
+      auto den = new TH2D("den", ";#it{p}_{T} (GeV/#it{c});NCls;Den", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      den->Sumw2();
+      auto numMC = new TH2D("numMC", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Efficiency (fake-track rate)", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      numMC->Sumw2();
+      auto fakMC = new TH2D("fakMC", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      fakMC->Sumw2();
+      auto multiFakMC = new TH2D("multiFakMC", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      multiFakMC->Sumw2();
+      auto cloneMC = new TH2D("cloneMC", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Clone", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      cloneMC->Sumw2();
+      auto denMC = new TH2D("denMC", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Den", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      denMC->Sumw2();
+
+      auto numVal = new TH2D("numVal", ";#it{p}_{T} (GeV/#it{c});NCls;Efficiency (fake-track rate)", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      numVal->Sumw2();
+      auto fakVal = new TH2D("fakVal", ";#it{p}_{T} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      fakVal->Sumw2();
+      auto multiFakVal = new TH2D("multiFakVal", ";#it{p}_{T} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      multiFakVal->Sumw2();
+      auto cloneVal = new TH2D("cloneVal", ";#it{p}_{T} (GeV/#it{c});NCls;Clone", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      cloneVal->Sumw2();
+      auto denVal = new TH2D("denVal", ";#it{p}_{T} (GeV/#it{c});NCls;Den", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      denVal->Sumw2();
+      auto numMCVal = new TH2D("numMCVal", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Efficiency (fake-track rate)", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      numMCVal->Sumw2();
+      auto fakMCVal = new TH2D("fakMCVal", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      fakMCVal->Sumw2();
+      auto multiFakMCVal = new TH2D("multiFakMCVal", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      multiFakMCVal->Sumw2();
+      auto cloneMCVal = new TH2D("cloneMCVal", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Clone", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      cloneMCVal->Sumw2();
+      auto denMCVal = new TH2D("denMCVal", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Den", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      denMCVal->Sumw2();
+
+      auto numMig = new TH2D("numMig", ";#it{p}_{T} (GeV/#it{c});NCls;Efficiency (fake-track rate)", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      numMig->Sumw2();
+      auto fakMig = new TH2D("fakMig", ";#it{p}_{T} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      fakMig->Sumw2();
+      auto multiFakMig = new TH2D("multiFakMig", ";#it{p}_{T} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      multiFakMig->Sumw2();
+      auto cloneMig = new TH2D("cloneMig", ";#it{p}_{T} (GeV/#it{c});NCls;Clone", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      cloneMig->Sumw2();
+      auto denMig = new TH2D("denMig", ";#it{p}_{T} (GeV/#it{c});NCls;Den", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      denMig->Sumw2();
+      auto numMCMig = new TH2D("numMCMig", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Efficiency (fake-track rate)", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      numMCMig->Sumw2();
+      auto fakMCMig = new TH2D("fakMCMig", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      fakMCMig->Sumw2();
+      auto multiFakMCMig = new TH2D("multiFakMCMig", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Fak", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      multiFakMCMig->Sumw2();
+      auto cloneMCMig = new TH2D("cloneMCMig", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Clone", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      cloneMCMig->Sumw2();
+      auto denMCMig = new TH2D("denMCMig", ";#it{p}_{T,MC} (GeV/#it{c});NCls;Den", nb, xbins, 4, 4 - 0.5, 8 - 0.5);
+      denMCMig->Sumw2();
+
+      TProfile* avgClsZ = new TProfile("avgClsZ", "good attachment;z_{MC};<Cls>", 25, -20, 20);
+      avgClsZ->SetLineColor(kBlack);
+      TProfile* avgClsZGood = new TProfile("avgClsZGood", "good attachment;z_{MC};<Cls>", 25, -20, 20);
+      avgClsZGood->SetLineColor(kBlue);
+      TProfile* avgClsZFake = new TProfile("avgClsZFake", "fake attachment;z_{MC};<Cls>", 25, -20, 20);
+      avgClsZFake->SetLineColor(kRed);
+
+      for (auto& evInfo : info) {
+        for (auto& part : evInfo) {
+          if (!part.isReconstructable()) {
+            continue;
+          }
+          den->Fill(part.track.getPt(), part.track.getNClusters());
+          denMC->Fill(part.pt, part.track.getNClusters());
+          if (part.isReco) {
+            num->Fill(part.track.getPt(), part.track.getNClusters());
+            numMC->Fill(part.pt, part.track.getNClusters());
+            if (part.isReco > 1) {
+              for (int _i{0}; _i < part.isReco - 1; ++_i) {
+                clone->Fill(part.track.getPt(), part.track.getNClusters());
+                cloneMC->Fill(part.pt, part.track.getNClusters());
+              }
+            }
+          }
+          if (part.isFake) {
+            fak->Fill(part.track.getPt(), part.track.getNClusters());
+            fakMC->Fill(part.pt, part.track.getNClusters());
+            if (part.isFake > 1) {
+              for (int _i{0}; _i < part.isFake - 1; ++_i) {
+                multiFak->Fill(part.track.getPt(), part.track.getNClusters());
+                multiFakMC->Fill(part.pt, part.track.getNClusters());
+              }
+            }
+          }
+
+          // sep into validation and migration region
+          if (bcValStart < part.bcInROF && part.bcInROF < bcValEnd) {
+            denVal->Fill(part.track.getPt(), part.track.getNClusters());
+            denMCVal->Fill(part.pt, part.track.getNClusters());
+            if (part.isReco) {
+              numVal->Fill(part.track.getPt(), part.track.getNClusters());
+              numMCVal->Fill(part.pt, part.track.getNClusters());
+              if (part.isReco > 1) {
+                for (int _i{0}; _i < part.isReco - 1; ++_i) {
+                  cloneVal->Fill(part.track.getPt(), part.track.getNClusters());
+                  cloneMCVal->Fill(part.pt, part.track.getNClusters());
+                }
+              }
+            }
+            if (part.isFake) {
+              fakVal->Fill(part.track.getPt(), part.track.getNClusters());
+              fakMCVal->Fill(part.pt, part.track.getNClusters());
+              if (part.isFake > 1) {
+                for (int _i{0}; _i < part.isFake - 1; ++_i) {
+                  multiFakVal->Fill(part.track.getPt(), part.track.getNClusters());
+                  multiFakMCVal->Fill(part.pt, part.track.getNClusters());
+                }
+              }
+            }
+          } else {
+            denMig->Fill(part.track.getPt(), part.track.getNClusters());
+            denMCMig->Fill(part.pt, part.track.getNClusters());
+            if (part.isReco) {
+              numMig->Fill(part.track.getPt(), part.track.getNClusters());
+              numMCMig->Fill(part.pt, part.track.getNClusters());
+              if (part.isReco > 1) {
+                for (int _i{0}; _i < part.isReco - 1; ++_i) {
+                  cloneMig->Fill(part.track.getPt(), part.track.getNClusters());
+                  cloneMCMig->Fill(part.pt, part.track.getNClusters());
+                }
+              }
+            }
+            if (part.isFake) {
+              fakMig->Fill(part.track.getPt(), part.track.getNClusters());
+              fakMCMig->Fill(part.pt, part.track.getNClusters());
+              if (part.isFake > 1) {
+                for (int _i{0}; _i < part.isFake - 1; ++_i) {
+                  multiFakMig->Fill(part.track.getPt(), part.track.getNClusters());
+                  multiFakMCMig->Fill(part.pt, part.track.getNClusters());
+                }
+              }
+            }
+          }
+
+          int nCl = part.getNClusters();
+          avgClsZ->Fill(part.pvz, nCl);
+          if (part.isReco) {
+            avgClsZGood->Fill(part.pvz, nCl);
+          }
+          if (part.isFake) {
+            avgClsZFake->Fill(part.pvz, nCl);
+          }
+        }
+      }
+
+      auto sum = (TH2D*)num->Clone("sum");
+      auto sumMC = (TH2D*)numMC->Clone("sumMC");
+      sum->Add(fak);
+      sumMC->Add(fakMC);
+      sum->SetLineColor(kBlack);
+      sumMC->SetLineColor(kBlack);
+      fak->SetLineColor(2);
+      fakMC->SetLineColor(2);
+      multiFak->SetLineColor(kRed + 1);
+      multiFakMC->SetLineColor(kRed + 1);
+
+      auto sumVal = (TH2D*)numVal->Clone("sumVal");
+      auto sumMCVal = (TH2D*)numMCVal->Clone("sumMCVal");
+      sumVal->Add(fakVal);
+      sumMCVal->Add(fakMCVal);
+      sumVal->SetLineColor(kBlack);
+      sumMCVal->SetLineColor(kBlack);
+      fakVal->SetLineColor(2);
+      fakMCVal->SetLineColor(2);
+      multiFakVal->SetLineColor(kRed + 1);
+      multiFakMCVal->SetLineColor(kRed + 1);
+
+      auto sumMig = (TH2D*)numMig->Clone("sumMig");
+      auto sumMCMig = (TH2D*)numMCMig->Clone("sumMCMig");
+      sumMig->Add(fakMig);
+      sumMCMig->Add(fakMCMig);
+      sumMig->SetLineColor(kBlack);
+      sumMCMig->SetLineColor(kBlack);
+      fakMig->SetLineColor(2);
+      fakMCMig->SetLineColor(2);
+      multiFakMig->SetLineColor(kRed + 1);
+      multiFakMCMig->SetLineColor(kRed + 1);
+
+      if (write) {
+        num->Write();
+        den->Write();
+        sum->Write();
+        fak->Write();
+        multiFak->Write();
+        numMC->Write();
+        denMC->Write();
+        sumMC->Write();
+        fakMC->Write();
+        multiFakMC->Write();
+
+        numVal->Write();
+        denVal->Write();
+        sumVal->Write();
+        fakVal->Write();
+        multiFakVal->Write();
+        numMCVal->Write();
+        denMCVal->Write();
+        sumMCVal->Write();
+        fakMCVal->Write();
+        multiFakMCVal->Write();
+
+        numMig->Write();
+        denMig->Write();
+        sumMig->Write();
+        fakMig->Write();
+        multiFakMig->Write();
+        numMCMig->Write();
+        denMCMig->Write();
+        sumMCMig->Write();
+        fakMCMig->Write();
+        multiFakMCMig->Write();
+      } else {
+        TCanvas* c1 = new TCanvas;
+        c1->SetLogx();
+        c1->SetGrid();
+        gPad->DrawFrame(ptcutl, 0.05, ptcuth, 1.03, ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)");
+
+        auto denp = den->ProjectionX();
+        auto nump = num->ProjectionX();
+        auto fakp = fak->ProjectionX();
+        auto multiFakp = multiFak->ProjectionX();
+        auto sump = sum->ProjectionX();
+        auto clonep = clone->ProjectionX();
+
+        sump->Divide(sump, denp, 1, 1, "B");
+        sump->Draw("hist;same");
+        nump->Divide(nump, denp, 1, 1, "B");
+        nump->Draw("hist;same");
+        fakp->Divide(fakp, denp, 1, 1, "B");
+        fakp->Draw("hist;same");
+        multiFakp->Divide(multiFakp, denp, 1, 1, "B");
+        multiFakp->Draw("hist;same");
+        clonep->Divide(clonep, denp, 1, 1, "B");
+        clonep->SetLineColor(3);
+        clonep->Draw("hist;same");
+
+        TCanvas* c2 = new TCanvas;
+        c2->Divide(2, 1);
+        c2->cd(1);
+        hZvertex->Draw();
+        c2->cd(2);
+        avgClsZ->Draw();
+        avgClsZGood->Draw("same");
+        avgClsZFake->Draw("same");
+      }
+    }
+
+    //////////////////////
+    // DROF Tracks
+    {
+      auto hBC = new TH1F("hBC", "Distance in BC;bcInROF;counts.", roFbins, -0.5, roFbins - 0.5);
+      auto hBCTracksDen = new TH2F("hBCTracksDen", "BC Den Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksNum = new TH2F("hBCTracksNum", "BC Num Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksFake = new TH2F("hBCTracksFake", "BC Fake Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksSum = new TH2F("hBCTracksSum", "BC Sum Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+
+      // control region
+      auto hBCTracksDenVal = new TH2F("hBCTracksDenVal", "Val BC Den Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksNumVal = new TH2F("hBCTracksNumVal", "Val BC Num Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksFakeVal = new TH2F("hBCTracksFakeVal", "Val BC Fake Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksSumVal = new TH2F("hBCTracksSumVal", "Val BC Sum Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+
+      // migration region
+      auto hBCTracksDenMig = new TH2F("hBCTracksDenMig", "MigBC Den Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksNumMig = new TH2F("hBCTracksNumMig", "MigBC Num Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksFakeMig = new TH2F("hBCTracksFakeMig", "MigBC Fake Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+      auto hBCTracksSumMig = new TH2F("hBCTracksSumMig", "MigBC Sum Tracks;bcInROF;NCls;eff.", roFbins, -0.5, roFbins - 0.5, 4, 4 - 0.5, 8 - 0.5);
+
+      for (auto& evInfo : info) {
+        for (auto& part : evInfo) {
+          if (!part.isReconstructable()) {
+            continue;
+          }
+          hBC->Fill(part.bcInROF);
+          hBCTracksDen->Fill(part.bcInROF, part.track.getNClusters());
+          if (part.isReco) {
+            hBCTracksNum->Fill(part.bcInROF, part.track.getNClusters());
+          }
+          if (part.isFake) {
+            hBCTracksFake->Fill(part.bcInROF, part.track.getNClusters());
+          }
+
+          if (bcValStart < part.bcInROF && part.bcInROF < bcValEnd) {
+            hBCTracksDenVal->Fill(part.bcInROF, part.track.getNClusters());
+            if (part.isReco) {
+              hBCTracksNumVal->Fill(part.bcInROF, part.track.getNClusters());
+            }
+            if (part.isFake) {
+              hBCTracksFakeVal->Fill(part.bcInROF, part.track.getNClusters());
+            }
+          } else {
+            hBCTracksDenMig->Fill(part.bcInROF, part.track.getNClusters());
+            if (part.isReco) {
+              hBCTracksNumMig->Fill(part.bcInROF, part.track.getNClusters());
+            }
+            if (part.isFake) {
+              hBCTracksFakeMig->Fill(part.bcInROF, part.track.getNClusters());
+            }
+          }
+        }
+      }
+
+      hBCTracksSum->Add(hBCTracksNum);
+      hBCTracksSum->Add(hBCTracksFake);
+      hBCTracksSum->SetLineColor(kBlack);
+      hBCTracksFake->SetLineColor(2);
+
+      hBCTracksSumVal->Add(hBCTracksNum);
+      hBCTracksSumVal->Add(hBCTracksFake);
+      hBCTracksSumVal->SetLineColor(kBlack);
+      hBCTracksFakeVal->SetLineColor(2);
+
+      hBCTracksSumMig->Add(hBCTracksNum);
+      hBCTracksSumMig->Add(hBCTracksFake);
+      hBCTracksSumMig->SetLineColor(kBlack);
+      hBCTracksFakeMig->SetLineColor(2);
+
+      if (write) {
+        hBCTracksDen->Write();
+        hBCTracksNum->Write();
+        hBCTracksFake->Write();
+        hBCTracksSum->Write();
+
+        hBCTracksDenVal->Write();
+        hBCTracksNumVal->Write();
+        hBCTracksFakeVal->Write();
+        hBCTracksSumVal->Write();
+
+        hBCTracksDenMig->Write();
+        hBCTracksNumMig->Write();
+        hBCTracksFakeMig->Write();
+        hBCTracksSumMig->Write();
+      } else {
+        auto hBCTracksDenp = hBCTracksDen->ProjectionX();
+        auto hBCTracksSump = hBCTracksSum->ProjectionX();
+        auto hBCTracksNump = hBCTracksNum->ProjectionX();
+        auto hBCTracksFakep = hBCTracksFake->ProjectionX();
+
+        hBCTracksSump->Divide(hBCTracksSump, hBCTracksDenp, 1., 1., "B");
+        hBCTracksNump->Divide(hBCTracksNump, hBCTracksDenp, 1., 1., "B");
+        hBCTracksFakep->Divide(hBCTracksFakep, hBCTracksDenp, 1., 1., "B");
+
+        auto c = new TCanvas;
+        c->Divide(2, 1);
+        c->cd(1);
+        hBC->Draw();
+        c->cd(2);
+        gPad->DrawFrame(-0.5, 1e-3, roFbins - 0.5, 1.1, "Tracking >4 ITS cls;bcInROF;eff.");
+        gPad->SetGrid();
+        hBCTracksSump->Draw("histe;same");
+        hBCTracksNump->Draw("histe;same");
+        hBCTracksFakep->Draw("histe;same");
+        auto leg = new TLegend;
+        leg->AddEntry(hBCTracksSump, "Sum");
+        leg->AddEntry(hBCTracksNump, "Good");
+        leg->AddEntry(hBCTracksFakep, "Fake");
+        leg->Draw();
+      }
+    }
+
+    //////////////////////
+    // DROF Vertices
+    if constexpr (false) {
+      std::vector<VertexInfo> vertexInfo;
+      std::cout << "** Creating vertices/particles correspondance ... " << std::flush;
+      for (int frame = 0; frame < recTree->GetEntriesFast(); frame++) { // Vertices frames
+        if (!recTree->GetEvent(frame)) {
+          continue;
+        }
+        int contLabIdx{0}; // contributor labels are stored as flat vector
+        for (size_t iRecord{0}; iRecord < recVerROFArr->size(); ++iRecord) {
+          auto& rec = recVerROFArr->at(iRecord);
+          auto verStartIdx = rec.getFirstEntry(), verSize = rec.getNEntries();
+          for (int iVertex{rec.getFirstEntry()}; iVertex < verStartIdx + verSize; ++iVertex) {
+            auto& info = vertexInfo.emplace_back();
+            info.vertex = recVerArr->at(iVertex);
+            info.mainLabel = recVerLabelsArr->at(contLabIdx);
+            info.purity = recVerPurityArr->at(contLabIdx);
+            info.event = info.mainLabel.getEventID();
+            ++contLabIdx;
+            if (info.mainLabel.isSet()) {
+              const auto& ir = irs[info.event];
+              // LOGP(info, "iROF={} {} to {}", iRecord, info.mainLabel.asString(), ir.asString());
+              if (!ir.isDummy()) {
+                info.bcInROF = (ir.toLong() - roFrameBiasInBC) % roFrameLengthInBC;
+                info.rofId = (ir.toLong() - roFrameBiasInBC) / roFrameLengthInBC;
+              }
+            }
+          }
+        }
+      }
+      std::cout << "done." << std::endl;
+
+      auto hMCVtxZ = new TH1F("hMCVtxZ", "MC Vertex;Z", 50, -16, 16);
+      auto hReVtxZ = new TH1F("hRecoVtxZ", "Reco Vertex;Z", 50, -16, 16);
+
+      auto hBCVtxDen = new TH1F("hBCVtxDen;bcInROF;eff.", "BC Den Vertices", roFbins, -0.5, roFbins - 0.5);
+      auto hBCVtxNum = new TH1F("hBCVtxNum;bcInROF;eff.", "BC Num Vertices", roFbins, -0.5, roFbins - 0.5);
+
+      auto hBCVtxZDen = new TH2F("hBCVtxDen;bcInROF;z;eff.", "BC Den Vertices vs. z position", roFbins, -0.5, roFbins - 0.5, 40, -20, 20);
+      auto hBCVtxZNum = new TH2F("hBCVtxNum;bcInROF;z;eff.", "BC Num Vertices vs. z position", roFbins, -0.5, roFbins - 0.5, 40, -20, 20);
+
+      auto pBCPurity = new TProfile("pBCProfile", ";bcInROF;<purity>", roFbins, -0.5, roFbins - 0.5);
+      auto pBCPurityDup = new TProfile("pBCProfileDup", ";bcInROF;<purity>", roFbins, -0.5, roFbins - 0.5);
+      pBCPurityDup->SetLineColor(kRed);
+
+      auto hVtxMCx = new TH2F("hVtxMCx", ";MC_{x};Vtx_{x}", 100, -0.3, 0.3, 100, -0.3, 0.3);
+      auto hVtxMCy = new TH2F("hVtxMCy", ";MC_{y};Vtx_{y}", 100, -0.3, 0.3, 100, -0.3, 0.3);
+      auto hVtxMCz = new TH2F("hVtxMCz", ";MC_{z};Vtx_{z}", 100, -20, 20, 100, -20, 20);
+
+      for (int n = 0; n < nev; n++) { // loop over MC events
+        mcTree->GetEvent(n);
+        hMCVtxZ->Fill(mcEvent->GetZ());
+        const auto& ir = irs[mcEvent->GetEventID() - 1]; // event id start from 1
+        if (!ir.isDummy()) {
+          int bcInROF = (ir.toLong() - roFrameBiasInBC) % roFrameLengthInBC;
+          hBCVtxDen->Fill(bcInROF);
+          hBCVtxZDen->Fill(bcInROF, mcEvent->GetZ());
+        }
+      }
+      std::unordered_map<o2::MCCompLabel, size_t> seenMCEvent;
+      for (const auto& vtx : vertexInfo) {
+        ++seenMCEvent[vtx.mainLabel];
+      }
+      // for (const auto& [k, f] : seenMCEvent) {
+      //   LOGP(info, "{}:{} -> {} ({:.1f}%)", k.getSourceID(), k.getEventID(), f, 100.f * ((float)f / (float)vertexInfo.size()));
+      // }
+      LOGP(info, "received {} unique vertices", seenMCEvent.size());
+      for (const auto& vtx : vertexInfo) {
+        if (!vtx.mainLabel.isValid() || vtx.bcInROF < 0 || vtx.event < 0) {
+          continue;
+        }
+        mcTree->GetEvent(vtx.event);
+        hVtxMCx->Fill(mcEvent->GetX(), vtx.vertex.getX());
+        hVtxMCy->Fill(mcEvent->GetY(), vtx.vertex.getY());
+        hVtxMCz->Fill(mcEvent->GetZ(), vtx.vertex.getZ());
+        if (seenMCEvent[vtx.mainLabel] > 1) {
+          pBCPurityDup->Fill(vtx.bcInROF, vtx.purity);
+        } else {
+          hReVtxZ->Fill(vtx.vertex.getZ());
+          hBCVtxNum->Fill(vtx.bcInROF);
+          hBCVtxZNum->Fill(vtx.bcInROF, vtx.vertex.getZ());
+          pBCPurity->Fill(vtx.bcInROF, vtx.purity);
+        }
+      }
+
+      auto hBCVtxNumClone = (TH1F*)hBCVtxNum->Clone();
+      hBCVtxNumClone->SetTitle("unique Vertex;bcInROF;efficiency");
+      hBCVtxNum->Divide(hBCVtxNum, hBCVtxDen, 1., 1., "b");
+
+      auto hBCVtxZNumClone = (TH2F*)hBCVtxZNum->Clone();
+      hBCVtxZNumClone->SetTitle("unique Vertex;bcInROF;vtx.z;efficiency");
+      hBCVtxZNumClone->Divide(hBCVtxZNum, hBCVtxZDen, 1., 1., "b");
+
+      hReVtxZ->Sumw2();
+      hReVtxZ->SetLineColor(kRed);
+
+      auto c = new TCanvas;
+      c->Divide(3, 2);
+
+      c->cd(1);
+      auto hRatioVtxZ = new TRatioPlot(hReVtxZ, hMCVtxZ);
+      hRatioVtxZ->Draw();
+      hRatioVtxZ->GetUpperPad()->cd();
+      TLegend* legend = new TLegend(0.3, 0.7, 0.7, 0.85);
+      legend->SetHeader(Form("MC=%.0f Reco=%.0f", hMCVtxZ->GetEntries(), hReVtxZ->GetEntries()));
+      legend->AddEntry(hReVtxZ, "Reco", "l");
+      legend->AddEntry(hMCVtxZ, "MC", "le");
+      legend->Draw();
+      gPad->Update();
+      double max1 = hReVtxZ->GetMaximum();
+      double max2 = hMCVtxZ->GetMaximum();
+      double maxY = std::max(max1, max2);
+      hReVtxZ->GetYaxis()->SetRangeUser(0, maxY * 1.1);
+
+      c->cd(2);
+      gPad->DrawFrame(-0.5, 1e-3, roFbins - 0.5, 1.1, "Vertex ;bcInROF;eff.");
+      hBCVtxNum->Draw("histe;same");
+
+      c->cd(3);
+      gPad->DrawFrame(-0.5, 1e-3, roFbins - 0.5, 1.1, "Purity;bcInROF;<purity>");
+      pBCPurity->Draw();
+      pBCPurityDup->Draw("same");
+      c->Draw();
+
+      c->cd(4);
+      hBCVtxDen->Draw();
+      c->cd(5);
+      hBCVtxNumClone->Draw();
+      c->cd(6);
+      hBCVtxZNumClone->Draw();
+      c->Draw();
+
+      c = new TCanvas;
+      c->Divide(3, 1);
+      c->cd(1);
+      hVtxMCx->Draw("colz");
+      c->cd(2);
+      hVtxMCy->Draw("colz");
+      c->cd(3);
+      hVtxMCz->Draw("colz");
+      c->Draw();
+    }
+    //////////////////////
+    // Fake clusters
+    if (write) {
+      const int nby{4}, nbz{7};
+      double ybins[nby + 1], zbins[nbz + 1];
+      for (int i{0}; i < nby + 1; ++i) {
+        ybins[i] = (4 + i) - 0.5;
+      }
+      for (int i{0}; i < nbz + 1; ++i) {
+        zbins[i] = (0 + i) - 0.5;
+      }
+      auto hFakVal = new TH3D("fakClsVal", "Fake cluster attachment;#it{p}_{T} (GeV/#it{c});NCls;Fake;(fake-cluster rate)", nb, xbins, nby, ybins, nbz, zbins);
+      auto hFakMig = new TH3D("fakClsMig", "Fake cluster attachment;#it{p}_{T} (GeV/#it{c});NCls;Fake;(fake-cluster rate)", nb, xbins, nby, ybins, nbz, zbins);
+
+      for (auto& event : info) {
+        for (auto& part : event) {
+          if (!part.isReconstructable()) {
+            continue;
+          }
+
+          const auto& trk = part.track;
+          for (int iL{0}; iL < 7; ++iL) {
+            if (!trk.hasHitOnLayer(iL) || !trk.isFakeOnLayer(iL) || (part.clusters & (0x1 << iL)) == 0) {
+              continue;
+            }
+            if (trk.hasHitInNextROF()) {
+              hFakMig->Fill(trk.getPt(), trk.getNClusters(), iL);
+            } else {
+              hFakVal->Fill(trk.getPt(), trk.getNClusters(), iL);
+            }
+          }
+        }
+      }
+
+      hFakMig->Write();
+      hFakVal->Write();
+    }
+    if (fOut) {
+      fOut->Close();
+    }
+  } else {
+    auto fWO = TFile::Open("checkDROF_wo.root");
+    auto f = TFile::Open("checkDROF_w.root");
+    plotHistos(fWO, f, "");
+    plotHistos(fWO, f, "Val");
+    plotHistos(fWO, f, "Mig");
+  }
+}
+
+void plotHistos(TFile* fWO, TFile* f, const char* append)
+{
+  TLegend* leg;
+  TH1* h;
+  const int woStyle = 1001;
+  const int wStyle = 3003;
+  const int ww{3840}, hh{2160};
+
+  const char* titlename = "";
+  if (strcmp(append, "Val") == 0) {
+    titlename = ", Validation region";
+  } else if (strcmp(append, "Mig") == 0) {
+    titlename = ", Migration region";
+  }
+
+  auto hWODen2 = fWO->Get<TH2D>(Form("den%s", append));
+  hWODen2->SetName(Form("%s_wo", hWODen2->GetName()));
+  auto hWONum2 = fWO->Get<TH2D>(Form("num%s", append));
+  hWONum2->SetName(Form("%s_wo", hWONum2->GetName()));
+  auto hWOFak2 = fWO->Get<TH2D>(Form("fak%s", append));
+  hWOFak2->SetName(Form("%s_wo", hWOFak2->GetName()));
+  auto hWOSum2 = fWO->Get<TH2D>(Form("sum%s", append));
+  hWOSum2->SetName(Form("%s_wo", hWOSum2->GetName()));
+  auto hWOMultiFak2 = fWO->Get<TH2D>(Form("multiFak%s", append));
+  hWOMultiFak2->SetName(Form("%s_wo", hWOMultiFak2->GetName()));
+
+  auto hWODenMC2 = fWO->Get<TH2D>(Form("denMC%s", append));
+  hWODenMC2->SetName(Form("%s_wo", hWODenMC2->GetName()));
+  auto hWONumMC2 = fWO->Get<TH2D>(Form("numMC%s", append));
+  hWONumMC2->SetName(Form("%s_wo", hWONumMC2->GetName()));
+  auto hWOFakMC2 = fWO->Get<TH2D>(Form("fakMC%s", append));
+  hWOFakMC2->SetName(Form("%s_wo", hWOFakMC2->GetName()));
+  auto hWOSumMC2 = fWO->Get<TH2D>(Form("sumMC%s", append));
+  hWOSumMC2->SetName(Form("%s_wo", hWOSumMC2->GetName()));
+  auto hWOMultiFakMC2 = fWO->Get<TH2D>(Form("multiFakMC%s", append));
+  hWOMultiFakMC2->SetName(Form("%s_wo", hWOMultiFakMC2->GetName()));
+
+  auto hWOBCTracksDen2 = fWO->Get<TH2F>(Form("hBCTracksDen%s", append));
+  hWOBCTracksDen2->SetName(Form("%s_wo", hWOBCTracksDen2->GetName()));
+  auto hWOBCTracksNum2 = fWO->Get<TH2F>(Form("hBCTracksNum%s", append));
+  hWOBCTracksNum2->SetName(Form("%s_wo", hWOBCTracksNum2->GetName()));
+  auto hWOBCTracksFake2 = fWO->Get<TH2F>(Form("hBCTracksFake%s", append));
+  hWOBCTracksFake2->SetName(Form("%s_wo", hWOBCTracksFake2->GetName()));
+  auto hWOBCTracksSum2 = fWO->Get<TH2F>(Form("hBCTracksSum%s", append));
+  hWOBCTracksSum2->SetName(Form("%s_wo", hWOBCTracksSum2->GetName()));
+
+  auto setColor = [](TH1* h, EColor c) {
+    h->SetLineColor(c);
+    h->SetMarkerColor(c);
+  };
+  auto hDen2 = f->Get<TH2D>(Form("den%s", append));
+  setColor(hDen2, kBlack);
+  auto hNum2 = f->Get<TH2D>(Form("num%s", append));
+  setColor(hNum2, kCyan);
+  auto hFak2 = f->Get<TH2D>(Form("fak%s", append));
+  setColor(hFak2, kOrange);
+  auto hSum2 = f->Get<TH2D>(Form("sum%s", append));
+  setColor(hSum2, kGray);
+  auto hMultiFak2 = f->Get<TH2D>(Form("multiFak%s", append));
+  setColor(hMultiFak2, kMagenta);
+
+  auto hDenMC2 = f->Get<TH2D>(Form("denMC%s", append));
+  setColor(hDenMC2, kBlack);
+  auto hNumMC2 = f->Get<TH2D>(Form("numMC%s", append));
+  setColor(hNumMC2, kCyan);
+  auto hFakMC2 = f->Get<TH2D>(Form("fakMC%s", append));
+  setColor(hFakMC2, kOrange);
+  auto hSumMC2 = f->Get<TH2D>(Form("sumMC%s", append));
+  setColor(hSumMC2, kGray);
+  auto hMultiFakMC2 = f->Get<TH2D>(Form("multiFakMC%s", append));
+  setColor(hMultiFakMC2, kMagenta);
+
+  auto hBCTracksDen2 = f->Get<TH2F>(Form("hBCTracksDen%s", append));
+  setColor(hBCTracksDen2, kBlack);
+  auto hBCTracksNum2 = f->Get<TH2F>(Form("hBCTracksNum%s", append));
+  setColor(hBCTracksNum2, kCyan);
+  auto hBCTracksFake2 = f->Get<TH2F>(Form("hBCTracksFake%s", append));
+  setColor(hBCTracksFake2, kOrange);
+  auto hBCTracksSum2 = f->Get<TH2F>(Form("hBCTracksSum%s", append));
+  setColor(hBCTracksSum2, kGray);
+
+  int k = 0;
+  TCanvas *cEff = nullptr, *cBC = nullptr, *cCont = nullptr, *cRatio = nullptr;
+  {
+    auto plotTrkEff = [&](int i, int j) {
+      auto hWONum = hWONumMC2->ProjectionX(Form("%s_%d_%d_eff_px", hWONumMC2->GetName(), i, j), i, j);
+      auto hWODen = hWODenMC2->ProjectionX(Form("%s_%d_%d_eff_px", hWODenMC2->GetName(), i, j), 0, 5);
+      auto hWOFak = hWOFakMC2->ProjectionX(Form("%s_%d_%d_eff_px", hWOFakMC2->GetName(), i, j), i, j);
+      auto hWOMultiFak = hWOMultiFakMC2->ProjectionX(Form("%s_%d_%d_eff_px", hWOMultiFakMC2->GetName(), i, j), i, j);
+      auto hWOSum = (TH1D*)hWONum->Clone(Form("%s_sum_eff__%d", hWONum->GetName(), j));
+      hWOSum->Add(hWOFak);
+
+      hWOSum->Divide(hWOSum, hWODen, 1., 1., "B");
+      hWOSum->SetFillColorAlpha(hWOSum2->GetLineColor(), 0.5);
+      hWOSum->SetFillStyle(woStyle);
+      hWOSum->Draw("histe;same");
+
+      hWONum->Divide(hWONum, hWODen, 1., 1., "B");
+      hWONum->SetFillColorAlpha(hWONum2->GetLineColor(), 0.5);
+      hWONum->SetFillStyle(woStyle);
+      hWONum->Draw("histe;same");
+
+      hWOFak->Divide(hWOFak, hWODen, 1., 1., "B");
+      hWOFak->SetFillColorAlpha(hWOFak2->GetLineColor(), 0.5);
+      hWOFak->SetFillStyle(woStyle);
+      hWOFak->Draw("histe;same");
+
+      hWOMultiFak->Divide(hWOMultiFak, hWODen, 1., 1., "B");
+      hWOMultiFak->SetLineColor(hWOMultiFak2->GetLineColor());
+      hWOMultiFak->SetFillColorAlpha(hWOMultiFak2->GetLineColor(), 0.5);
+      hWOMultiFak->SetFillStyle(woStyle);
+      // hWOMultiFak->Draw("histe;same");
+
+      auto hNum = hNum2->ProjectionX(Form("%s_%d_%d_eff_px", hNumMC2->GetName(), i, j), i, j);
+      auto hDen = hDen2->ProjectionX(Form("%s_%d_%d_eff_px", hDenMC2->GetName(), i, j), 0, 5);
+      auto hFak = hFak2->ProjectionX(Form("%s_%d_%d_eff_px", hFakMC2->GetName(), i, j), i, j);
+      auto hMultiFak = hMultiFak2->ProjectionX(Form("%s_%d_%d_px", hMultiFakMC2->GetName(), i, j), i, j);
+      auto hSum = (TH1D*)hNum->Clone(Form("%s_sum_eff_%d", hNum->GetName(), j));
+      hSum->Add(hFak);
+
+      hSum->Divide(hSum, hDen, 1., 1., "B");
+      hSum->SetFillColor(hSum2->GetLineColor());
+      hSum->SetLineColor(hSum2->GetLineColor());
+      hSum->SetFillStyle(wStyle);
+      hSum->Draw("histe;same");
+
+      hNum->Divide(hNum, hDen, 1., 1., "B");
+      hNum->SetFillColor(hNum2->GetLineColor());
+      hNum->SetLineColor(hNum2->GetLineColor());
+      hNum->SetFillStyle(wStyle);
+      hNum->Draw("histe;same");
+
+      hFak->Divide(hFak, hDen, 1., 1., "B");
+      hFak->SetFillColor(hFak2->GetLineColor());
+      hFak->SetLineColor(hFak2->GetLineColor());
+      hFak->SetFillStyle(wStyle);
+      hFak->Draw("histe;same");
+
+      hMultiFak->Divide(hMultiFak, hDen, 1., 1., "B");
+      hMultiFak->SetLineColor(hMultiFak2->GetLineColor());
+      hMultiFak->SetFillColor(hMultiFak2->GetLineColor());
+      hMultiFak->SetFillStyle(wStyle);
+      // hMultiFak->Draw("histe;same");
+
+      if (i == 1 && i == j) {
+        leg = new TLegend(0.1, 0.1, 0.9, 0.9);
+        leg->AddEntry((TObject*)0, "deltaRof=0", "");
+        leg->AddEntry(hWOSum, "sum");
+        leg->AddEntry(hWONum, "good");
+        leg->AddEntry(hWOFak, "fake");
+        // leg->AddEntry(hWOMultiFak, "multifake");
+        leg->AddEntry((TObject*)0, "deltaRof=1", "");
+        leg->AddEntry(hSum, "sum");
+        leg->AddEntry(hNum, "good");
+        leg->AddEntry(hFak, "fake");
+        // leg->AddEntry(hMultiFak, "multifake");
+      }
+    };
+
+    cEff = new TCanvas(Form("pteff%s", append), "", ww, hh);
+    cEff->Divide(3, 2);
+    k = 0;
+    for (int i{1}; i <= 4; ++i) {
+      if (i == 3) {
+        ++k;
+      }
+      cEff->cd(i + k);
+      h = gPad->DrawFrame(
+        0.02, 0, 10, 1.02,
+        Form("Tracking Efficiency #times Fraction (7 MC hits, %d-point "
+             "tracks%s);#it{p}_{T,MC} GeV/#it{c};eff. (fake-rate)",
+             3 + i, titlename));
+      h->GetXaxis()->SetTitleOffset(1.4);
+
+      plotTrkEff(i, i);
+
+      gPad->SetLogx();
+      gPad->SetGrid();
+      gPad->RedrawAxis("g");
+    }
+    cEff->cd(3);
+    h = gPad->DrawFrame(
+      0.02, 0, 10, 1.02,
+      Form("Tracking Efficiency (7 MC hits, all point "
+           "tracks%s);#it{p}_{T,MC} GeV/#it{c};eff. (fake-rate)",
+           titlename));
+    h->GetXaxis()->SetTitleOffset(1.4);
+
+    plotTrkEff(1, 4);
+
+    gPad->SetLogx();
+    gPad->SetGrid();
+    gPad->RedrawAxis("g");
+
+    cEff->cd(6);
+    leg->Draw();
+  }
+
+  {
+    auto plotRatios = [&](int i, int j, TPad* upper, TPad* lower) {
+      auto hWONum = hWONumMC2->ProjectionX(Form("%s_%d_%d_ratio_px", hWONumMC2->GetName(), i, j), i, j);
+      auto hWOFak = hWOFakMC2->ProjectionX(Form("%s_%d_%d_ratio_px", hWOFakMC2->GetName(), i, j), i, j);
+
+      hWONum->SetFillColorAlpha(hWONum2->GetLineColor(), 0.5);
+      hWONum->SetLineColor(hWONum2->GetLineColor());
+      // hWONum->SetFillStyle(woStyle);
+
+      hWOFak->SetFillColorAlpha(hWOFak2->GetLineColor(), 0.5);
+      hWOFak->SetLineColor(hWOFak2->GetLineColor());
+      // hWOFak->SetFillStyle(woStyle);
+
+      auto hNum = hNum2->ProjectionX(Form("%s_%d_%d_ratio_px", hNumMC2->GetName(), i, j), i, j);
+      auto hFak = hFak2->ProjectionX(Form("%s_%d_%d_ratio_px", hFakMC2->GetName(), i, j), i, j);
+
+      hNum->SetFillColor(hNum2->GetLineColor());
+      hNum->SetLineColor(hNum2->GetLineColor());
+      // hNum->SetFillStyle(wStyle);
+
+      hFak->SetFillColor(hFak2->GetLineColor());
+      hFak->SetLineColor(hFak2->GetLineColor());
+      // hFak->SetFillStyle(wStyle);
+      //
+      upper->cd();
+      upper->SetLogx();
+      upper->SetGrid();
+      hWONum->Draw("hist");
+      hWOFak->Draw("hist same");
+      hNum->Draw("hist same");
+      hFak->Draw("hist same");
+      double ymax = 1.1 * std::max({hNum->GetMaximum(), hFak->GetMaximum(), hWONum->GetMaximum(), hWOFak->GetMaximum()});
+      hWONum->GetYaxis()->SetRangeUser(0, ymax);
+      gPad->RedrawAxis("g");
+
+      auto rNum = (TH1*)hNum->Clone(Form("rNum_%s_%d_%d", hNum->GetName(), i, j));
+      auto rFak = (TH1*)hFak->Clone(Form("rFak_%s_%d_%d", hFak->GetName(), i, j));
+      rNum->GetYaxis()->SetTitle("(deltaRof=1) / (deltaRof=0)");
+      rNum->Divide(hWONum);
+      rFak->Divide(hWOFak);
+
+      // rNum->SetMarkerStyle(20);
+      // rFak->SetMarkerStyle(21);
+      rNum->SetLineWidth(2);
+      rFak->SetLineWidth(2);
+      rNum->SetFillStyle(0);
+      rFak->SetFillStyle(0);
+      setColor(rNum, kBlue);
+      setColor(rFak, kRed);
+      double ymin = std::min(rNum->GetMinimum(0.0), rFak->GetMinimum(0.0));
+      ymax = std::max(rNum->GetMaximum(), rFak->GetMaximum());
+      double ypad = 0.1 * (ymax - ymin);
+      ymin -= ypad;
+      ymax += ypad;
+
+      lower->cd();
+      lower->SetLogx();
+      lower->SetGrid();
+      rNum->GetYaxis()->SetRangeUser(ymin, ymax);
+      rNum->Draw("hist");
+      rFak->Draw("hist;same");
+      gPad->RedrawAxis("g");
+
+      if (i == 1 && i == j) {
+        leg = new TLegend(0.1, 0.1, 0.9, 0.9);
+        leg->AddEntry((TObject*)0, "deltaRof=0", "");
+        leg->AddEntry(hWONum, "good");
+        leg->AddEntry(hWOFak, "fake");
+        leg->AddEntry((TObject*)0, "deltaRof=1", "");
+        leg->AddEntry(hNum, "good");
+        leg->AddEntry(hFak, "fake");
+        leg->AddEntry((TObject*)0, "Ratios", "");
+        leg->AddEntry(rNum, "good", "l");
+        leg->AddEntry(rFak, "fake", "l");
+      }
+    };
+
+    cRatio = new TCanvas(Form("ptratio%s", append), "", ww, hh);
+    cRatio->Divide(3, 2);
+    k = 0;
+    for (int i{1}; i <= 4; ++i) {
+      if (i == 3) {
+        ++k;
+      }
+      cRatio->cd(i + k);
+      TPad* up = new TPad(Form("up%d", k), "", 0, 0.5, 1, 1);
+      TPad* dn = new TPad(Form("dn%d", k), "", 0, 0, 1, 0.5);
+      up->SetBottomMargin(0);
+      dn->SetTopMargin(0);
+      up->Draw();
+      dn->Draw();
+
+      plotRatios(i, i, up, dn);
+    }
+    cRatio->cd(3);
+    TPad* up = new TPad(Form("up_e_%d", k), "", 0, 0.5, 1, 1);
+    TPad* dn = new TPad(Form("dn_e_%d", k), "", 0, 0, 1, 0.5);
+    up->SetBottomMargin(0);
+    dn->SetTopMargin(0);
+    up->Draw();
+    dn->Draw();
+    plotRatios(1, 4, up, dn);
+
+    cRatio->cd(6);
+    leg->Draw();
+  }
+
+  {
+    auto plotTrkCont = [&](int i, int j) {
+      auto hWONum = hWONum2->ProjectionX(Form("%s_%d_%d_cont_px", hWONum2->GetName(), i, j), i, j);
+      auto hWODen = hWODen2->ProjectionX(Form("%s_%d_%d_cont_px", hWODen2->GetName(), i, j), 0, 5);
+      auto hWOFak = hWOFak2->ProjectionX(Form("%s_%d_%d_cont_px", hWOFak2->GetName(), i, j), i, j);
+      auto hWOMultiFak = hWOMultiFak2->ProjectionX(Form("%s_%d_%d_cont_px", hWOMultiFak2->GetName(), i, j), i, j);
+      auto hWOSum = (TH1D*)hWONum->Clone(Form("%s_sum_cont_%d", hWONum->GetName(), j));
+      hWOSum->Add(hWOFak);
+
+      hWOSum->Divide(hWOSum, hWODen, 1., 1., "B");
+      hWOSum->SetFillColorAlpha(hWOSum2->GetLineColor(), 0.5);
+      hWOSum->SetFillStyle(woStyle);
+      // hWOSum->Draw("histe;same");
+
+      hWONum->Divide(hWONum, hWODen, 1., 1., "B");
+      hWONum->SetFillColorAlpha(hWONum2->GetLineColor(), 0.5);
+      hWONum->SetFillStyle(woStyle);
+      hWONum->Draw("histe;same");
+
+      hWOFak->Divide(hWOFak, hWODen, 1., 1., "B");
+      hWOFak->SetFillColorAlpha(hWOFak2->GetLineColor(), 0.5);
+      hWOFak->SetFillStyle(woStyle);
+      hWOFak->Draw("histe;same");
+
+      hWOMultiFak->Divide(hWOMultiFak, hWODen, 1., 1., "B");
+      hWOMultiFak->SetLineColor(hWOMultiFak2->GetLineColor());
+      hWOMultiFak->SetFillColorAlpha(hWOMultiFak2->GetLineColor(), 0.5);
+      hWOMultiFak->SetFillStyle(woStyle);
+      // hWOMultiFak->Draw("histe;same");
+
+      auto hNum = hNum2->ProjectionX(Form("%s_%d_%d_cont_px", hNum2->GetName(), i, j), i, j);
+      auto hDen = hDen2->ProjectionX(Form("%s_%d_%d_cont_px", hDen2->GetName(), i, j), 0, 5);
+      auto hFak = hFak2->ProjectionX(Form("%s_%d_%d_cont_px", hFak2->GetName(), i, j), i, j);
+      auto hMultiFak = hMultiFak2->ProjectionX(Form("%s_%d_%d_px", hMultiFak2->GetName(), i, j), i, j);
+      auto hSum = (TH1D*)hNum->Clone(Form("%s_sum_cont_%d", hNum->GetName(), j));
+      hSum->Add(hFak);
+
+      hSum->Divide(hSum, hDen, 1., 1., "B");
+      hSum->SetFillColor(hSum2->GetLineColor());
+      hSum->SetFillStyle(wStyle);
+      // hSum->Draw("histe;same");
+
+      hNum->Divide(hNum, hDen, 1., 1., "B");
+      hNum->SetFillColor(hNum2->GetLineColor());
+      hNum->SetFillStyle(wStyle);
+      hNum->Draw("histe;same");
+
+      hFak->Divide(hFak, hDen, 1., 1., "B");
+      hFak->SetFillColor(hFak2->GetLineColor());
+      hFak->SetFillStyle(wStyle);
+      hFak->Draw("histe;same");
+
+      hMultiFak->Divide(hMultiFak, hDen, 1., 1., "B");
+      hMultiFak->SetLineColor(hMultiFak2->GetLineColor());
+      hMultiFak->SetFillColor(hMultiFak2->GetLineColor());
+      hMultiFak->SetFillStyle(wStyle);
+      // hMultiFak->Draw("histe;same");
+
+      if (i == 1 && i == j) {
+        leg = new TLegend(0.1, 0.1, 0.9, 0.9);
+        leg->AddEntry((TObject*)0, "deltaRof=0", "");
+        leg->AddEntry(hWONum, "good");
+        leg->AddEntry(hWOFak, "fake");
+        // leg->AddEntry(hWOMultiFak, "multifake");
+        leg->AddEntry((TObject*)0, "deltaRof=1", "");
+        leg->AddEntry(hNum, "DROF:good");
+        leg->AddEntry(hFak, "DROF:fake");
+        // leg->AddEntry(hMultiFak, "DROF:multifake");
+      }
+    };
+
+    cCont = new TCanvas(Form("ptcont%s", append), "", ww, hh);
+    cCont->Divide(3, 2);
+    k = 0;
+    for (int i{1}; i <= 4; ++i) {
+      if (i == 3) {
+        ++k;
+      }
+      cCont->cd(i + k);
+      h = gPad->DrawFrame(
+        0.02, 0, 10, 1.02,
+        Form("Tracking Contribution #times Fraction (7 MC hits, %d-point "
+             "tracks%s);#it{p}_{T,Reco} GeV/#it{c};contribtution",
+             3 + i, titlename));
+      h->GetXaxis()->SetTitleOffset(1.4);
+
+      plotTrkCont(i, i);
+
+      gPad->SetLogx();
+      gPad->SetGrid();
+      gPad->RedrawAxis("g");
+    }
+    cCont->cd(3);
+    h = gPad->DrawFrame(0.02, 0, 10, 1.02,
+                        Form("Tracking Contribution (7 MC hits, all point "
+                             "tracks%s);#it{p}_{T,Reco} GeV/#it{c};contribution",
+                             titlename));
+    h->GetXaxis()->SetTitleOffset(1.4);
+
+    plotTrkCont(1, 4);
+
+    gPad->SetLogx();
+    gPad->SetGrid();
+    gPad->RedrawAxis("g");
+
+    cCont->cd(6);
+    leg->Draw();
+  }
+
+  {
+    auto plotBCEff = [&](int i, int j) {
+      auto hWOBCTracksNum = hWOBCTracksNum2->ProjectionX(Form("%s_%d_%d_bc_px", hWOBCTracksNum2->GetName(), i, j), i, j);
+      auto hWOBCTracksDen = hWOBCTracksDen2->ProjectionX(Form("%s_%d_%d_bc_px", hWOBCTracksDen2->GetName(), i, j), 0, 5);
+      auto hWOBCTracksFake = hWOBCTracksFake2->ProjectionX(Form("%s_%d_%d_bc_px", hWOBCTracksFake2->GetName(), i, j), i, j);
+      auto hWOBCTracksSum = (TH1F*)hWOBCTracksNum->Clone(Form("%s_%d_sum", hWOBCTracksNum->GetName(), j));
+      hWOBCTracksSum->Add(hWOBCTracksFake);
+
+      hWOBCTracksSum->Divide(hWOBCTracksSum, hWOBCTracksDen, 1., 1., "B");
+      hWOBCTracksSum->SetLineColor(hWOSum2->GetLineColor());
+      hWOBCTracksSum->SetFillColorAlpha(hWOSum2->GetLineColor(), 0.5);
+      hWOBCTracksSum->SetFillStyle(woStyle);
+      hWOBCTracksSum->Draw("histe;same");
+
+      hWOBCTracksNum->Divide(hWOBCTracksNum, hWOBCTracksDen, 1., 1., "B");
+      hWOBCTracksNum->SetLineColor(hWONum2->GetLineColor());
+      hWOBCTracksNum->SetFillColorAlpha(hWONum2->GetLineColor(), 0.5);
+      hWOBCTracksNum->SetFillStyle(woStyle);
+      hWOBCTracksNum->Draw("histe;same");
+
+      hWOBCTracksFake->Divide(hWOBCTracksFake, hWOBCTracksDen, 1., 1., "B");
+      hWOBCTracksFake->SetLineColor(hWOFak2->GetLineColor());
+      hWOBCTracksFake->SetFillColorAlpha(hWOFak2->GetLineColor(), 0.5);
+      hWOBCTracksFake->SetFillStyle(woStyle);
+      hWOBCTracksFake->Draw("histe;same");
+
+      auto hBCTracksNum = hBCTracksNum2->ProjectionX(Form("%s_%d_%d_bc_px", hBCTracksNum2->GetName(), i, j), i, j);
+      auto hBCTracksDen = hBCTracksDen2->ProjectionX(Form("%s_%d_%d_bc_px", hBCTracksDen2->GetName(), i, j), 0, 5);
+      auto hBCTracksFake = hBCTracksFake2->ProjectionX(Form("%s_%d_%d_bc_px", hBCTracksFake2->GetName(), i, j), i, j);
+      auto hBCTracksSum = (TH1F*)hBCTracksNum->Clone(Form("%s_%d_sum", hBCTracksNum->GetName(), j));
+      hBCTracksSum->Add(hBCTracksFake);
+
+      hBCTracksSum->Divide(hBCTracksSum, hBCTracksDen, 1., 1., "B");
+      hBCTracksSum->SetLineColor(hSum2->GetLineColor());
+      hBCTracksSum->SetFillColor(hSum2->GetLineColor());
+      hBCTracksSum->SetFillStyle(wStyle);
+      hBCTracksSum->Draw("histe;same");
+
+      hBCTracksNum->Divide(hBCTracksNum, hBCTracksDen, 1., 1., "B");
+      hBCTracksNum->SetLineColor(hNum2->GetLineColor());
+      hBCTracksNum->SetFillColor(hNum2->GetLineColor());
+      hBCTracksNum->SetFillStyle(wStyle);
+      hBCTracksNum->Draw("histe;same");
+
+      hBCTracksFake->Divide(hBCTracksFake, hBCTracksDen, 1., 1., "B");
+      hBCTracksFake->SetLineColor(hFak2->GetLineColor());
+      hBCTracksFake->SetFillColor(hFak2->GetLineColor());
+      hBCTracksFake->SetFillStyle(wStyle);
+      hBCTracksFake->Draw("histe;same");
+
+      if (i == 1 && i == j) {
+        leg = new TLegend(0.1, 0.1, 0.9, 0.9);
+        leg->AddEntry((TObject*)0, "deltaRof=0", "");
+        leg->AddEntry(hWOBCTracksNum, "good");
+        leg->AddEntry(hWOBCTracksFake, "fake");
+        leg->AddEntry(hWOBCTracksSum, "sum");
+        leg->AddEntry((TObject*)0, "deltaRof=1", "");
+        leg->AddEntry(hBCTracksNum, "good");
+        leg->AddEntry(hBCTracksFake, "fake");
+        leg->AddEntry(hBCTracksSum, "sum");
+      }
+    };
+
+    cBC = new TCanvas(Form("bceff%s", append), "", ww, hh);
+    cBC->Divide(3, 2);
+    k = 0;
+    for (int i{1}; i <= 4; ++i) {
+      if (i == 3) {
+        ++k;
+      }
+      cBC->cd(i + k);
+      gPad->DrawFrame(-0.5, 0, 200 - 0.5, 1.02,
+                      Form("Tracking Efficiency #times Fraction (#it{p}_{T} "
+                           "integrated, %d-point "
+                           "tracks%s);BC in "
+                           "ROF;eff. (fake-rate)",
+                           3 + i, titlename));
+      plotBCEff(i, i);
+      gPad->SetGrid();
+      gPad->RedrawAxis("g");
+    }
+    cBC->cd(3);
+    gPad->DrawFrame(-0.5, 0, 200 - 0.5, 1.02,
+                    Form("Tracking Efficiency (#it{p}_{T} "
+                         "integrated, all point "
+                         "tracks%s);BC in "
+                         "ROF;eff. (fake-rate)",
+                         titlename));
+    plotBCEff(1, 4);
+    gPad->SetGrid();
+    gPad->RedrawAxis("g");
+
+    cBC->cd(6);
+    leg->Draw();
+  }
+
+  TString outname = TString::Format("trkeff%s.pdf", append);
+  cEff->cd();
+  cEff->Update();
+  cEff->Print(TString::Format("%s(", outname.Data()), "Title:Tracking Efficiency");
+  cRatio->cd();
+  cRatio->Update();
+  cRatio->Print(outname.Data(), "Title:Ratios");
+  cCont->cd();
+  cCont->Update();
+  cCont->Print(outname.Data(), "Title:Contribution");
+  cBC->cd();
+  cBC->Update();
+  cBC->Print(TString::Format("%s)", outname.Data()), "Title:BC");
+}

From 792df66197f28e4ee8e25b2a6e35dc954528c807 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 22 Jul 2025 11:07:42 +0200
Subject: [PATCH 0642/1764] ITS: fix opt. label output if firstOrbit!=0
 (#14532)

---
 .../ITS/tracking/src/VertexerTraits.cxx       | 25 ++++++++++++++-----
 .../ITSMFT/ITS/workflow/src/TrackerSpec.cxx   |  5 +++-
 2 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 409ce8895aa36..1069f1808fb2a 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -25,6 +25,7 @@
 #include "SimulationDataFormat/DigitizationContext.h"
 #include "Steer/MCKinematicsReader.h"
 #include "ITSMFTBase/DPLAlpideParam.h"
+#include "DetectorsRaw/HBFUtils.h"
 
 #ifdef VTX_DEBUG
 #include "TTree.h"
@@ -574,16 +575,25 @@ void VertexerTraits::addTruthSeedingVertices()
   int64_t roFrameBiasInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC;
   int64_t roFrameLengthInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameLengthInBC;
   o2::steer::MCKinematicsReader mcReader(dc);
-  std::map<int, bounded_vector<Vertex>> vertices;
+  struct VertInfo {
+    bounded_vector<Vertex> vertices;
+    bounded_vector<int> srcs;
+    bounded_vector<int> events;
+  };
+  std::map<int, VertInfo> vertices;
   for (int iSrc{0}; iSrc < mcReader.getNSources(); ++iSrc) {
     auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
     for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
       const auto& ir = irs[eveId2colId[iEve]];
       if (!ir.isDummy()) { // do we need this, is this for diffractive events?
         const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
-        int rofId = (ir.toLong() - roFrameBiasInBC) / roFrameLengthInBC;
+        int rofId = ((ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC) / roFrameLengthInBC;
         if (!vertices.contains(rofId)) {
-          vertices[rofId] = bounded_vector<Vertex>(mMemoryPool.get());
+          vertices[rofId] = {
+            .vertices = bounded_vector<Vertex>(mMemoryPool.get()),
+            .srcs = bounded_vector<int>(mMemoryPool.get()),
+            .events = bounded_vector<int>(mMemoryPool.get()),
+          };
         }
         Vertex vert;
         vert.setTimeStamp(rofId);
@@ -594,7 +604,9 @@ void VertexerTraits::addTruthSeedingVertices()
         vert.setChi2(1);
         constexpr float cov = 50e-9;
         vert.setCov(cov, cov, cov, cov, cov, cov);
-        vertices[rofId].push_back(vert);
+        vertices[rofId].vertices.push_back(vert);
+        vertices[rofId].srcs.push_back(iSrc);
+        vertices[rofId].events.push_back(iEve);
       }
     }
   }
@@ -603,10 +615,11 @@ void VertexerTraits::addTruthSeedingVertices()
     bounded_vector<Vertex> verts(mMemoryPool.get());
     bounded_vector<std::pair<o2::MCCompLabel, float>> polls(mMemoryPool.get());
     if (vertices.contains(iROF)) {
-      verts = vertices[iROF];
+      const auto& vertInfo = vertices[iROF];
+      verts = vertInfo.vertices;
       nVerts += verts.size();
       for (size_t i{0}; i < verts.size(); ++i) {
-        o2::MCCompLabel lbl; // unset label for now
+        o2::MCCompLabel lbl(o2::MCCompLabel::maxTrackID(), vertInfo.events[i], vertInfo.srcs[i], false);
         polls.emplace_back(lbl, 1.f);
       }
     } else {
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index c8a785b6a3627..c825ec39d3499 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -15,6 +15,7 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
 #include "ITSWorkflow/TrackerSpec.h"
+#include "ITStracking/TrackingConfigParam.h"
 
 namespace o2
 {
@@ -120,10 +121,12 @@ DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, Tracking
     inputs.emplace_back("itsmclabels", "ITS", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
     inputs.emplace_back("ITSMC2ROframes", "ITS", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "VERTICESMCTR", 0, Lifetime::Timeframe);
-    outputs.emplace_back("ITS", "VERTICESMCTRCONT", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "VERTICESMCPUR", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "TRACKSMCTR", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "ITSTrackMC2ROF", 0, Lifetime::Timeframe);
+    if (VertexerParamConfig::Instance().outputContLabels) {
+      outputs.emplace_back("ITS", "VERTICESMCTRCONT", 0, Lifetime::Timeframe);
+    }
   }
 
   return DataProcessorSpec{

From a69009b82334a2026b025313a0ce109f26874248 Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Wed, 23 Jul 2025 08:40:36 +0200
Subject: [PATCH 0643/1764] Eov for orbitreset (#14534)

* dev:orbitReset EOV

* clang

* fix
---
 Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx b/Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx
index 7dedcacbf6047..e35b6574db92f 100644
--- a/Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx
@@ -124,7 +124,14 @@ int main(int argc, char** argv)
       ret = api.storeAsTFileAny(&(vect), ccdbPath, metadata, tmin, tmax);
     } else {
       std::cout << "Storing:" << ccdbPath << " tmin:" << tmin << " tmax:" << tmax << " ts:" << tt << std::endl;
-      ret = api.storeAsTFileAny(&(vect), ccdbPath, metadata, tmin, tmax);
+      std::string filename = "orbitReset.root";
+      TClass* tcls = TClass::GetClass(typeid(vect));
+      auto ti = tcls->GetTypeInfo();
+      auto classname = "std::vector<int64_t>";
+      metadata["adjustableEOV"] = "true";
+      ret = api.storeAsTFile_impl(&(vect), *ti, ccdbPath, metadata, tmin, tmax);
+      o2::ccdb::CcdbObjectInfo oi(ccdbPath, classname, filename, metadata, tmin, tmax);
+      adjustOverriddenEOV(api, oi);
     }
   }
   //

From 6cd3538c18db2d09279f44baf5db796b4d59fcf0 Mon Sep 17 00:00:00 2001
From: Hirak Koley <hirak.kumar.koley@cern.ch>
Date: Wed, 23 Jul 2025 13:55:10 +0530
Subject: [PATCH 0644/1764] Added Lambda1520 PDG code to PhysicsConstants.h
 (#14377)

* Added Lambda1520 PDG code to PhysicsConstants.h

* Added Lambda1520 PDG - following standard procedure

* rollback the changes

* Added Lambda1520 to the header

* Update PhysicsConstants.h

* Updated block with output

* Update kLambda1520_Py

* Added kLambda1520_Py

* Updated
---
 Common/Constants/include/CommonConstants/PhysicsConstants.h | 4 +++-
 Common/Constants/include/CommonConstants/make_pdg_header.py | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/Common/Constants/include/CommonConstants/PhysicsConstants.h b/Common/Constants/include/CommonConstants/PhysicsConstants.h
index da34230662ef6..f0198f7a7f61d 100644
--- a/Common/Constants/include/CommonConstants/PhysicsConstants.h
+++ b/Common/Constants/include/CommonConstants/PhysicsConstants.h
@@ -88,7 +88,8 @@ enum Pdg {
   kHyperHydrogen4 = 1010010040,
   kHyperHelium4 = 1010020040,
   kHyperHelium5 = 1010020050,
-  kHyperHelium4Sigma = 1110020040
+  kHyperHelium4Sigma = 1110020040,
+  kLambda1520_Py = 102134
 };
 
 /// \brief Declarations of masses for additional particles
@@ -150,6 +151,7 @@ constexpr double MassHyperHydrogen4 = 3.922434;
 constexpr double MassHyperHelium4 = 3.921728;
 constexpr double MassHyperHelium5 = 4.839961;
 constexpr double MassHyperHelium4Sigma = 3.995;
+constexpr double MassLambda1520_Py = 1.5195;
 
 /// \brief Declarations of masses for particles in ROOT PDG_t
 constexpr double MassDown = 0.00467;
diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index b94cc34599d5e..ad24d66e2c3a5 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -144,7 +144,7 @@ class Pdg(Enum):
     kHyperHelium4 = 1010020040
     kHyperHelium5 = 1010020050
     kHyperHelium4Sigma = 1110020040
-
+    kLambda1520_Py = 102134  # PYTHIA code different from PDG
 
 dbPdg = ROOT.o2.O2DatabasePDG
 

From 7fce8d8ff491bfd15c7b2189b78dcbc86e614a1e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 23 Jul 2025 21:57:48 +0200
Subject: [PATCH 0645/1764] ITS: last mod. for deltaROF and perVertex (#14538)

---
 .../include/ITStracking/BoundedAllocator.h    |   8 +
 .../ITS/tracking/include/ITStracking/Cell.h   |  28 +-
 .../include/ITStracking/ClusterLines.h        |   8 +-
 .../tracking/include/ITStracking/TimeFrame.h  |   9 +-
 .../tracking/include/ITStracking/Tracklet.h   |  22 +-
 .../include/ITStracking/VertexerTraits.h      |   5 +
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |  47 +-
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |   4 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 360 ++++++++------
 .../ITS/tracking/src/TrackingInterface.cxx    |   4 +-
 .../ITS/tracking/src/VertexerTraits.cxx       | 452 ++++++++++++------
 11 files changed, 583 insertions(+), 364 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
index eced0c64c73a5..ac9f72089602d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
@@ -174,6 +174,14 @@ void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size,
   }
 }
 
+template <typename T>
+std::vector<T> toSTDVector(const bounded_vector<T>& b)
+{
+  std::vector<T> t(b.size());
+  std::copy(b.cbegin(), b.cend(), t.begin());
+  return t;
+}
+
 } // namespace o2::its
 
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index d81ba4426ca55..fcea96abbfa82 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -15,12 +15,8 @@
 
 #ifndef TRACKINGITSU_INCLUDE_CACELL_H_
 #define TRACKINGITSU_INCLUDE_CACELL_H_
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <array>
-#include <vector>
-#include <iostream>
-#endif
 
+#include "ITStracking/Constants.h"
 #include "GPUCommonDef.h"
 
 namespace o2::its
@@ -39,12 +35,12 @@ class Cell final
   GPUhd() int* getLevelPtr() { return &mLevel; }
 
  private:
-  int mFirstClusterIndex{0};
-  int mSecondClusterIndex{0};
-  int mThirdClusterIndex{0};
-  int mFirstTrackletIndex{0};
-  int mSecondTrackletIndex{0};
-  int mLevel{0};
+  int mFirstClusterIndex{constants::UnusedIndex};
+  int mSecondClusterIndex{constants::UnusedIndex};
+  int mThirdClusterIndex{constants::UnusedIndex};
+  int mFirstTrackletIndex{constants::UnusedIndex};
+  int mSecondTrackletIndex{constants::UnusedIndex};
+  int mLevel{constants::UnusedIndex};
 };
 
 class CellSeed final : public o2::track::TrackParCovF
@@ -82,14 +78,14 @@ class CellSeed final : public o2::track::TrackParCovF
   GPUhd() int getCluster(int i) const { return mClusters[i]; }
   GPUhd() void printCell() const
   {
-    printf("trkl: %d, %d\t lvl: %d\t chi2: %f\n", mTracklets[0], mTracklets[1], mLevel, mChi2);
+    printf("trkl: %d, %d\t lvl: %d\t chi2: %f\tcls: [%d | %d | %d | %d | %d | %d | %d]\n", mTracklets[0], mTracklets[1], mLevel, mChi2, mClusters[0], mClusters[1], mClusters[2], mClusters[3], mClusters[4], mClusters[5], mClusters[6]);
   }
 
  private:
-  float mChi2 = 0.f;
-  int mLevel = 0;
-  int mTracklets[2] = {-1, -1};
-  int mClusters[7] = {-1, -1, -1, -1, -1, -1, -1};
+  float mChi2 = -999.f;
+  int mLevel = constants::UnusedIndex;
+  int mTracklets[2] = {constants::UnusedIndex, constants::UnusedIndex};
+  int mClusters[7] = {constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex};
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
index 3ffeda9adcfd5..0e7ad474ae455 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
@@ -42,8 +42,8 @@ struct Line final {
   bool operator!=(const Line&) const;
   short getMinROF() const { return rof[0] < rof[1] ? rof[0] : rof[1]; }
 
-  float originPoint[3] = {0};
-  float cosinesDirector[3] = {0};
+  float originPoint[3] = {0, 0, 0};
+  float cosinesDirector[3] = {0, 0, 0};
   // float weightMatrix[6] = {1., 0., 0., 1., 0., 1.};
   // weightMatrix is a symmetric matrix internally stored as
   //    0 --> row = 0, col = 0
@@ -52,7 +52,7 @@ struct Line final {
   //    3 --> 1,1
   //    4 --> 1,2
   //    5 --> 2,2
-  short rof[2] = {-1, -1};
+  short rof[2] = {constants::UnusedIndex, constants::UnusedIndex};
 
   ClassDefNV(Line, 1);
 };
@@ -207,7 +207,7 @@ class ClusterLines final
   std::array<float, 6> mRMS2 = {0.f};         // symmetric matrix: diagonal is RMS2
   float mAvgDistance2 = 0.f;                  // substitute for chi2
   int mROFWeight = 0;                         // rof weight for voting
-  short mROF = -1;                            // rof
+  short mROF = constants::UnusedIndex;        // rof
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 9434fc2292750..3f0d291d5e51d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -77,11 +77,9 @@ struct TimeFrame {
   gsl::span<const std::array<float, 2>> getPrimaryVerticesXAlpha(int rofId) const;
   void fillPrimaryVerticesXandAlpha();
   int getPrimaryVerticesNum(int rofId = -1) const;
-  void addPrimaryVertices(const bounded_vector<Vertex>& vertices);
   void addPrimaryVerticesLabels(bounded_vector<std::pair<MCCompLabel, float>>& labels);
   void addPrimaryVerticesContributorLabels(bounded_vector<MCCompLabel>& labels);
-  void addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration);
-  void addPrimaryVertices(const gsl::span<const Vertex>& vertices, const int rofId, const int iteration);
+  void addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int iteration);
   void addPrimaryVerticesInROF(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration);
   void addPrimaryVerticesLabelsInROF(const bounded_vector<std::pair<MCCompLabel, float>>& labels, const int rofId);
   void addPrimaryVerticesContributorLabelsInROF(const bounded_vector<MCCompLabel>& labels, const int rofId);
@@ -397,7 +395,8 @@ inline gsl::span<const Vertex> TimeFrame<nLayers>::getPrimaryVertices(int romin,
   if (mPrimaryVertices.empty()) {
     return {};
   }
-  return {&mPrimaryVertices[mROFramesPV[romin]], static_cast<gsl::span<const Vertex>::size_type>(mROFramesPV[romax + 1] - mROFramesPV[romin])};
+  const int stop_idx = romax >= mNrof - 1 ? mNrof : romax + 1;
+  return {&mPrimaryVertices[mROFramesPV[romin]], static_cast<gsl::span<const Vertex>::size_type>(mROFramesPV[stop_idx] - mROFramesPV[romin])};
 }
 
 template <int nLayers>
@@ -594,7 +593,7 @@ inline gsl::span<int> TimeFrame<nLayers>::getExclusiveNTrackletsCluster(int rofI
 template <int nLayers>
 inline gsl::span<Tracklet> TimeFrame<nLayers>::getFoundTracklets(int rofId, int combId)
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= mNrof || mTracklets[combId].empty()) {
     return {};
   }
   auto startIdx{mNTrackletsPerROF[combId][rofId]};
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
index ba3474e6e86c6..5741a9fc65947 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
@@ -16,6 +16,7 @@
 #ifndef TRACKINGITS_INCLUDE_TRACKLET_H_
 #define TRACKINGITS_INCLUDE_TRACKLET_H_
 
+#include "ITStracking/Constants.h"
 #include "ITStracking/Cluster.h"
 #include "GPUCommonRtypes.h"
 #include "GPUCommonMath.h"
@@ -41,9 +42,10 @@ struct Tracklet final {
   {
     return firstClusterIndex < 0 || secondClusterIndex < 0;
   }
+  GPUhdi() auto getMinRof() const noexcept { return o2::gpu::CAMath::Min(rof[0], rof[1]); }
+  GPUhdi() auto getMaxRof() const noexcept { return o2::gpu::CAMath::Max(rof[0], rof[1]); }
   GPUhdi() auto getDeltaRof() const { return rof[1] - rof[0]; }
-  GPUhdi() void dump() const;
-  GPUhdi() void dump(const int, const int) const;
+  GPUhdi() auto getSpanRof(const Tracklet& o) const noexcept { return o2::gpu::CAMath::Max(getMaxRof(), o.getMaxRof()) - o2::gpu::CAMath::Min(getMinRof(), o.getMinRof()); }
   GPUhdi() unsigned char operator<(const Tracklet&) const;
 #if !defined(GPUCA_NO_FMT) && !defined(GPUCA_GPUCODE_DEVICE)
   std::string asString() const
@@ -53,11 +55,11 @@ struct Tracklet final {
   void print() const { LOG(info) << asString(); }
 #endif
 
-  int firstClusterIndex{-1};
-  int secondClusterIndex{-1};
+  int firstClusterIndex{constants::UnusedIndex};
+  int secondClusterIndex{constants::UnusedIndex};
   float tanLambda{-999};
   float phi{-999};
-  short rof[2] = {-1, -1};
+  short rof[2] = {constants::UnusedIndex, constants::UnusedIndex};
 
   ClassDefNV(Tracklet, 1);
 };
@@ -93,16 +95,6 @@ GPUhdi() unsigned char Tracklet::operator<(const Tracklet& t) const
   return true;
 }
 
-GPUhdi() void Tracklet::dump(const int offsetFirst, const int offsetSecond) const
-{
-  printf("fClIdx: %d sClIdx: %d  rof1: %hu rof2: %hu\n", firstClusterIndex + offsetFirst, secondClusterIndex + offsetSecond, rof[0], rof[1]);
-}
-
-GPUhdi() void Tracklet::dump() const
-{
-  printf("fClIdx: %d sClIdx: %d  rof1: %hu rof2: %hu\n", firstClusterIndex, secondClusterIndex, rof[0], rof[1]);
-}
-
 } // namespace o2::its
 
 #endif /* TRACKINGITS_INCLUDE_TRACKLET_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 54424136fcfe1..1213ad0a423b8 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -119,6 +119,11 @@ class VertexerTraits
  private:
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
+
+  // debug output
+  void debugComputeTracklets(int iteration);
+  void debugComputeTrackletMatching(int iteration);
+  void debugComputeVertices(int iteration);
 };
 
 inline void VertexerTraits::initialise(const TrackingParameters& trackingParams, const int iteration)
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 4115726756e73..2e9ce23719f90 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -59,24 +59,19 @@ TimeFrame<nLayers>::~TimeFrame()
 }
 
 template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVertices(const bounded_vector<Vertex>& vertices)
+void TimeFrame<nLayers>::addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int iteration)
 {
   for (const auto& vertex : vertices) {
-    mPrimaryVertices.emplace_back(vertex);
-    if (!isBeamPositionOverridden) {
+    mPrimaryVertices.emplace_back(vertex); // put a copy in the present
+    mTotVertPerIteration[iteration]++;
+    if (!isBeamPositionOverridden) { // beam position is updated only at first occurrence of the vertex. A bit sketchy if we have past/future vertices, it should not impact too much.
       const float w = vertex.getNContributors();
       mBeamPos[0] = (mBeamPos[0] * mBeamPosWeight + vertex.getX() * w) / (mBeamPosWeight + w);
       mBeamPos[1] = (mBeamPos[1] * mBeamPosWeight + vertex.getY() * w) / (mBeamPosWeight + w);
       mBeamPosWeight += w;
     }
   }
-  mROFramesPV.push_back(mPrimaryVertices.size());
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration)
-{
-  addPrimaryVertices(gsl::span<const Vertex>(vertices), rofId, iteration);
+  mROFramesPV.push_back(mPrimaryVertices.size()); // current rof must have number of vertices up to present
 }
 
 template <int nLayers>
@@ -119,34 +114,6 @@ void TimeFrame<nLayers>::addPrimaryVerticesContributorLabelsInROF(const bounded_
   mVerticesContributorLabels.insert(mVerticesContributorLabels.begin() + n, labels.begin(), labels.end());
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVertices(const gsl::span<const Vertex>& vertices, const int rofId, const int iteration)
-{
-  bounded_vector<Vertex> futureVertices(mMemoryPool.get());
-  for (const auto& vertex : vertices) {
-    if (vertex.getTimeStamp().getTimeStamp() < rofId) { // put a copy in the past
-      insertPastVertex(vertex, iteration);
-    } else {
-      if (vertex.getTimeStamp().getTimeStamp() > rofId) { // or put a copy in the future
-        futureVertices.emplace_back(vertex);
-      }
-    }
-    mPrimaryVertices.emplace_back(vertex); // put a copy in the present
-    mTotVertPerIteration[iteration]++;
-    if (!isBeamPositionOverridden) { // beam position is updated only at first occurrence of the vertex. A bit sketchy if we have past/future vertices, it should not impact too much.
-      const float w = vertex.getNContributors();
-      mBeamPos[0] = (mBeamPos[0] * mBeamPosWeight + vertex.getX() * w) / (mBeamPosWeight + w);
-      mBeamPos[1] = (mBeamPos[1] * mBeamPosWeight + vertex.getY() * w) / (mBeamPosWeight + w);
-      mBeamPosWeight += w;
-    }
-  }
-  mROFramesPV.push_back(mPrimaryVertices.size()); // current rof must have number of vertices up to present
-  for (auto& vertex : futureVertices) {
-    mPrimaryVertices.emplace_back(vertex);
-    mTotVertPerIteration[iteration]++;
-  }
-}
-
 template <int nLayers>
 int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
                                         gsl::span<const itsmft::CompClusterExt> clusters,
@@ -395,7 +362,7 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     if (iLayer < (int)mCells.size()) {
       deepVectorClear(mCells[iLayer]);
       deepVectorClear(mTrackletsLookupTable[iLayer]);
-      mTrackletsLookupTable[iLayer].resize(mClusters[iLayer + 1].size(), 0);
+      mTrackletsLookupTable[iLayer].resize(mClusters[iLayer + 1].size() + 1, 0);
       deepVectorClear(mCellLabels[iLayer]);
     }
 
@@ -686,8 +653,8 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mCellsLookupTable);
   deepVectorClear(mTotVertPerIteration);
   deepVectorClear(mPrimaryVertices);
-  deepVectorClear(mROFramesPV);
   deepVectorClear(mClusters);
+  deepVectorClear(mTrackletsLookupTable);
   deepVectorClear(mTrackingFrameInfo);
   deepVectorClear(mClusterExternalIndices);
   deepVectorClear(mROFramesClusters);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index aa93e32e1db9c..ba722c410f95c 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -52,7 +52,9 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
   int maxNvertices{-1};
   if (mTrkParams[0].PerPrimaryVertexProcessing) {
     for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
-      maxNvertices = std::max(maxNvertices, (int)mTimeFrame->getPrimaryVertices(iROF).size());
+      int minRof = o2::gpu::CAMath::Max(0, iROF - mTrkParams[0].DeltaROF);
+      int maxRof = o2::gpu::CAMath::Min(mTimeFrame->getNrof(), iROF + mTrkParams[0].DeltaROF);
+      maxNvertices = std::max(maxNvertices, (int)mTimeFrame->getPrimaryVertices(minRof, maxRof).size());
     }
   }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index da7f31bd678b5..136ebc647cc38 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -21,6 +21,7 @@
 
 #ifdef OPTIMISATION_OUTPUT
 #include <format>
+#include <fstream>
 #endif
 
 #include <oneapi/tbb/blocked_range.h>
@@ -42,8 +43,6 @@ using o2::base::PropagatorF;
 namespace o2::its
 {
 
-static constexpr int debugLevel{0};
-
 struct PassMode {
   using OnePass = std::integral_constant<int, 0>;
   using TwoPassCount = std::integral_constant<int, 1>;
@@ -73,130 +72,173 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
   int endROF{o2::gpu::GPUCommonMath::Min(mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * mTrkParams[iteration].nROFsPerIterations + mTrkParams[iteration].DeltaROF : mTimeFrame->getNrof(), mTimeFrame->getNrof())};
 
   mTaskArena->execute([&] {
-    for (int rof0{startROF}; rof0 < endROF; ++rof0) {
-      gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(rof0);
-      const int startVtx{iVertex >= 0 ? iVertex : 0};
-      const int endVtx{iVertex >= 0 ? o2::gpu::CAMath::Min(iVertex + 1, static_cast<int>(primaryVertices.size())) : static_cast<int>(primaryVertices.size())};
-      int minRof = o2::gpu::CAMath::Max(startROF, rof0 - mTrkParams[iteration].DeltaROF);
-      int maxRof = o2::gpu::CAMath::Min(endROF - 1, rof0 + mTrkParams[iteration].DeltaROF);
+    auto forTracklets = [&](auto Tag, int iLayer, int pivotROF, int base, int& offset) -> int {
+      int minROF = o2::gpu::CAMath::Max(startROF, pivotROF - mTrkParams[iteration].DeltaROF);
+      int maxROF = o2::gpu::CAMath::Min(endROF - 1, pivotROF + mTrkParams[iteration].DeltaROF);
+      gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(minROF, maxROF);
+      if (primaryVertices.empty()) {
+        return 0;
+      }
+      const int startVtx = iVertex >= 0 ? iVertex : 0;
+      const int endVtx = iVertex >= 0 ? o2::gpu::CAMath::Min(iVertex + 1, int(primaryVertices.size())) : int(primaryVertices.size());
+      if (endVtx <= startVtx) {
+        return 0;
+      }
 
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
-        [&](const tbb::blocked_range<int>& Layers) {
-          for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
-            gsl::span<const Cluster> layer0 = mTimeFrame->getClustersOnLayer(rof0, iLayer);
-            if (layer0.empty()) {
+      int localCount = 0;
+      auto& tracklets = mTimeFrame->getTracklets()[iLayer];
+      for (int targetROF0{minROF}; targetROF0 <= maxROF; ++targetROF0) {
+        if (!mTimeFrame->mMultiplicityCutMask[targetROF0]) {
+          continue;
+        }
+        auto layer0 = mTimeFrame->getClustersOnLayer(targetROF0, iLayer);
+        if (layer0.empty()) {
+          continue;
+        }
+        const float meanDeltaR = mTrkParams[iteration].LayerRadii[iLayer + 1] - mTrkParams[iteration].LayerRadii[iLayer];
+
+        for (int iCluster = 0; iCluster < int(layer0.size()); ++iCluster) {
+          const Cluster& currentCluster = layer0[iCluster];
+          const int currentSortedIndex = mTimeFrame->getSortedIndex(targetROF0, iLayer, iCluster);
+          if (mTimeFrame->isClusterUsed(iLayer, currentCluster.clusterId)) {
+            continue;
+          }
+          const float inverseR0 = 1.f / currentCluster.radius;
+
+          for (int iV = startVtx; iV < endVtx; ++iV) {
+            const auto& pv = primaryVertices[iV];
+            if (pv.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) {
               continue;
             }
-            float meanDeltaR{mTrkParams[iteration].LayerRadii[iLayer + 1] - mTrkParams[iteration].LayerRadii[iLayer]};
-
-            const int currentLayerClustersNum{static_cast<int>(layer0.size())};
-            for (int iCluster{0}; iCluster < currentLayerClustersNum; ++iCluster) {
-              const Cluster& currentCluster{layer0[iCluster]};
-              const int currentSortedIndex{mTimeFrame->getSortedIndex(rof0, iLayer, iCluster)};
+            const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)) + math_utils::Sq(mTrkParams[iteration].PVres) / float(pv.getNContributors()));
+            const float tanLambda = (currentCluster.zCoordinate - pv.getZ()) * inverseR0;
+            const float zAtRmin = tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
+            const float zAtRmax = tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
+            const float sqInvDeltaZ0 = 1.f / (math_utils::Sq(currentCluster.zCoordinate - pv.getZ()) + constants::Tolerance);
+            const float sigmaZ = o2::gpu::CAMath::Sqrt(
+              math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInvDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)));
+
+            auto bins = getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer));
+            if (bins.x == 0 && bins.y == 0 && bins.z == 0 && bins.w == 0) {
+              continue;
+            }
+            int phiBinsNum = bins.w - bins.y + 1;
+            if (phiBinsNum < 0) {
+              phiBinsNum += mTrkParams[iteration].PhiBins;
+            }
 
-              if (mTimeFrame->isClusterUsed(iLayer, currentCluster.clusterId)) {
+            for (int targetROF1{minROF}; targetROF1 <= maxROF; ++targetROF1) {
+              if (!mTimeFrame->mMultiplicityCutMask[targetROF1] || std::abs(targetROF0 - targetROF1) > mTrkParams[iteration].DeltaROF) {
                 continue;
               }
-              const float inverseR0{1.f / currentCluster.radius};
-
-              for (int iV{startVtx}; iV < endVtx; ++iV) {
-                const auto& primaryVertex{primaryVertices[iV]};
-                if (primaryVertex.isFlagSet(2) && iteration != 3) {
-                  continue;
-                }
-                const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTrkParams[iteration].PVres) / primaryVertex.getNContributors() + math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)));
-
-                const float tanLambda{(currentCluster.zCoordinate - primaryVertex.getZ()) * inverseR0};
-
-                const float zAtRmin{tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
-                const float zAtRmax{tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate};
-
-                const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
-                const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)))};
-
-                const int4 selectedBinsRect{getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer))};
-                if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
-                  continue;
-                }
-
-                int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
-
-                if (phiBinsNum < 0) {
-                  phiBinsNum += mTrkParams[iteration].PhiBins;
-                }
-
-                for (int rof1{minRof}; rof1 <= maxRof; ++rof1) {
-                  auto layer1 = mTimeFrame->getClustersOnLayer(rof1, iLayer + 1);
-                  if (layer1.empty()) {
+              auto layer1 = mTimeFrame->getClustersOnLayer(targetROF1, iLayer + 1);
+              if (layer1.empty()) {
+                continue;
+              }
+              for (int iPhi = 0; iPhi < phiBinsNum; ++iPhi) {
+                int iPhiBin = (bins.y + iPhi) % mTrkParams[iteration].PhiBins;
+                int firstBinIdx = mTimeFrame->mIndexTableUtils.getBinIndex(bins.x, iPhiBin);
+                int maxBinIdx = firstBinIdx + (bins.z - bins.x) + 1;
+                int firstRow = mTimeFrame->getIndexTable(targetROF1, iLayer + 1)[firstBinIdx];
+                int lastRow = mTimeFrame->getIndexTable(targetROF1, iLayer + 1)[maxBinIdx];
+                for (int iNext = firstRow; iNext < lastRow; ++iNext) {
+                  if (iNext >= int(layer1.size())) {
+                    break;
+                  }
+                  const Cluster& nextCluster = layer1[iNext];
+                  if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
                     continue;
                   }
-                  for (int iPhiCount{0}; iPhiCount < phiBinsNum; iPhiCount++) {
-                    int iPhiBin = (selectedBinsRect.y + iPhiCount) % mTrkParams[iteration].PhiBins;
-                    const int firstBinIndex{mTimeFrame->mIndexTableUtils.getBinIndex(selectedBinsRect.x, iPhiBin)};
-                    const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
-                    if constexpr (debugLevel) {
-                      if (firstBinIndex < 0 || firstBinIndex > mTimeFrame->getIndexTable(rof1, iLayer + 1).size() ||
-                          maxBinIndex < 0 || maxBinIndex > mTimeFrame->getIndexTable(rof1, iLayer + 1).size()) {
-                        std::cout << iLayer << "\t" << iCluster << "\t" << zAtRmin << "\t" << zAtRmax << "\t" << sigmaZ * mTrkParams[iteration].NSigmaCut << "\t" << mTimeFrame->getPhiCut(iLayer) << std::endl;
-                        std::cout << currentCluster.zCoordinate << "\t" << primaryVertex.getZ() << "\t" << currentCluster.radius << std::endl;
-                        std::cout << mTimeFrame->getMinR(iLayer + 1) << "\t" << currentCluster.radius << "\t" << currentCluster.zCoordinate << std::endl;
-                        std::cout << "Illegal access to IndexTable " << firstBinIndex << "\t" << maxBinIndex << "\t" << selectedBinsRect.z << "\t" << selectedBinsRect.x << std::endl;
-                        exit(1);
-                      }
-                    }
-                    const int firstRowClusterIndex = mTimeFrame->getIndexTable(rof1, iLayer + 1)[firstBinIndex];
-                    const int maxRowClusterIndex = mTimeFrame->getIndexTable(rof1, iLayer + 1)[maxBinIndex];
-                    for (int iNextCluster{firstRowClusterIndex}; iNextCluster < maxRowClusterIndex; ++iNextCluster) {
-                      if (iNextCluster >= (int)layer1.size()) {
-                        break;
-                      }
-
-                      const Cluster& nextCluster{layer1[iNextCluster]};
-                      if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
-                        continue;
-                      }
-
-                      const float deltaPhi{o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi)};
-                      const float deltaZ{o2::gpu::GPUCommonMath::Abs(tanLambda * (nextCluster.radius - currentCluster.radius) +
-                                                                     currentCluster.zCoordinate - nextCluster.zCoordinate)};
+                  float deltaPhi = o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi);
+                  float deltaZ = o2::gpu::GPUCommonMath::Abs((tanLambda * (nextCluster.radius - currentCluster.radius)) + currentCluster.zCoordinate - nextCluster.zCoordinate);
 
 #ifdef OPTIMISATION_OUTPUT
-                      MCCompLabel label;
-                      int currentId{currentCluster.clusterId};
-                      int nextId{nextCluster.clusterId};
-                      for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
-                        for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
-                          if (lab1 == lab2 && lab1.isValid()) {
-                            label = lab1;
-                            break;
-                          }
-                        }
-                        if (label.isValid()) {
-                          break;
-                        }
+                  MCCompLabel label;
+                  int currentId{currentCluster.clusterId};
+                  int nextId{nextCluster.clusterId};
+                  for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
+                    for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
+                      if (lab1 == lab2 && lab1.isValid()) {
+                        label = lab1;
+                        break;
                       }
-                      off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
+                    }
+                    if (label.isValid()) {
+                      break;
+                    }
+                  }
+                  off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
 #endif
 
-                      if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
-                          (deltaPhi < mTimeFrame->getPhiCut(iLayer) ||
-                           o2::gpu::GPUCommonMath::Abs(deltaPhi - o2::constants::math::TwoPI) < mTimeFrame->getPhiCut(iLayer))) {
-                        if (iLayer > 0) {
-                          mTimeFrame->getTrackletsLookupTable()[iLayer - 1][currentSortedIndex]++;
-                        }
-                        const float phi{o2::gpu::GPUCommonMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate,
-                                                                      currentCluster.xCoordinate - nextCluster.xCoordinate)};
-                        const float tanL{(currentCluster.zCoordinate - nextCluster.zCoordinate) /
-                                         (currentCluster.radius - nextCluster.radius)};
-                        mTimeFrame->getTracklets()[iLayer].emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(rof1, iLayer + 1, iNextCluster), tanL, phi, rof0, rof1);
-                      }
+                  if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
+                      (deltaPhi < mTimeFrame->getPhiCut(iLayer) ||
+                       o2::gpu::GPUCommonMath::Abs(deltaPhi - o2::constants::math::TwoPI) < mTimeFrame->getPhiCut(iLayer))) {
+                    float phi = o2::gpu::GPUCommonMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate);
+                    float tanL = (currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius);
+                    if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
+                      tracklets.emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF1, iLayer + 1, iNext), tanL, phi, targetROF0, targetROF1);
+                    } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
+                      ++localCount;
+                    } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
+                      const int idx = base + offset++;
+                      tracklets[idx] = Tracklet(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF1, iLayer + 1, iNext), tanL, phi, targetROF0, targetROF1);
                     }
                   }
                 }
               }
             }
           }
+        }
+      }
+      return localCount;
+    };
+
+    int dummy{0};
+    if (mTaskArena->max_concurrency() <= 1) {
+      for (int pivotROF{startROF}; pivotROF < endROF; ++pivotROF) {
+        for (int iLayer{0}; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
+          forTracklets(PassMode::OnePass{}, iLayer, pivotROF, 0, dummy);
+        }
+      }
+    } else {
+      bounded_vector<bounded_vector<int>> perROFCount(mTrkParams[iteration].TrackletsPerRoad(), bounded_vector<int>(endROF - startROF + 1, 0, mMemoryPool.get()), mMemoryPool.get());
+      tbb::parallel_for(
+        tbb::blocked_range2d<int, int>(0, mTrkParams[iteration].TrackletsPerRoad(), 1,
+                                       startROF, endROF, 1),
+        [&](auto const& Range) {
+          for (int iLayer{Range.rows().begin()}; iLayer < Range.rows().end(); ++iLayer) {
+            for (int pivotROF = Range.cols().begin(); pivotROF < Range.cols().end(); ++pivotROF) {
+              perROFCount[iLayer][pivotROF - startROF] = forTracklets(PassMode::TwoPassCount{}, iLayer, pivotROF, 0, dummy);
+            }
+          }
+        });
+
+      tbb::parallel_for(
+        tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
+        [&](auto const& Layers) {
+          for (int iLayer{Layers.begin()}; iLayer < Layers.end(); ++iLayer) {
+            std::exclusive_scan(perROFCount[iLayer].begin(), perROFCount[iLayer].end(), perROFCount[iLayer].begin(), 0);
+            mTimeFrame->getTracklets()[iLayer].resize(perROFCount[iLayer].back());
+          }
+        });
+
+      tbb::parallel_for(
+        tbb::blocked_range2d<int, int>(0, mTrkParams[iteration].TrackletsPerRoad(), 1,
+                                       startROF, endROF, 1),
+        [&](auto const& Range) {
+          for (int iLayer{Range.rows().begin()}; iLayer < Range.rows().end(); ++iLayer) {
+            if (perROFCount[iLayer].back() == 0) {
+              continue;
+            }
+            for (int pivotROF = Range.cols().begin(); pivotROF < Range.cols().end(); ++pivotROF) {
+              int baseIdx = perROFCount[iLayer][pivotROF - startROF];
+              if (baseIdx == perROFCount[iLayer][pivotROF - startROF + 1]) {
+                continue;
+              }
+              int localIdx = 0;
+              forTracklets(PassMode::TwoPassInsert{}, iLayer, pivotROF, baseIdx, localIdx);
+            }
+          }
         });
     }
 
@@ -217,42 +259,43 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
           trkl.shrink_to_fit();
           if (iLayer > 0) { /// recalculate lut
             auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer - 1]};
-            std::fill(lut.begin(), lut.end(), 0);
-            if (trkl.empty()) {
-              return;
-            }
-            for (const auto& tkl : trkl) {
-              lut[tkl.firstClusterIndex]++;
+            if (!trkl.empty()) {
+              for (const auto& tkl : trkl) {
+                lut[tkl.firstClusterIndex + 1]++;
+              }
+              std::inclusive_scan(lut.begin(), lut.end(), lut.begin());
             }
-            std::exclusive_scan(lut.begin(), lut.end(), lut.begin(), 0);
-            lut.push_back(trkl.size());
           }
         }
       });
-  });
 
-  /// Create tracklets labels
-  if (mTimeFrame->hasMCinformation()) {
-    for (int iLayer{0}; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
-      for (auto& trk : mTimeFrame->getTracklets()[iLayer]) {
-        MCCompLabel label;
-        int currentId{mTimeFrame->getClusters()[iLayer][trk.firstClusterIndex].clusterId};
-        int nextId{mTimeFrame->getClusters()[iLayer + 1][trk.secondClusterIndex].clusterId};
-        for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
-          for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
-            if (lab1 == lab2 && lab1.isValid()) {
-              label = lab1;
-              break;
+    /// Create tracklets labels
+    if (mTimeFrame->hasMCinformation()) {
+      tbb::parallel_for(
+        tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
+        [&](const tbb::blocked_range<int>& Layers) {
+          for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
+            for (auto& trk : mTimeFrame->getTracklets()[iLayer]) {
+              MCCompLabel label;
+              int currentId{mTimeFrame->getClusters()[iLayer][trk.firstClusterIndex].clusterId};
+              int nextId{mTimeFrame->getClusters()[iLayer + 1][trk.secondClusterIndex].clusterId};
+              for (const auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
+                for (const auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
+                  if (lab1 == lab2 && lab1.isValid()) {
+                    label = lab1;
+                    break;
+                  }
+                }
+                if (label.isValid()) {
+                  break;
+                }
+              }
+              mTimeFrame->getTrackletsLabel(iLayer).emplace_back(label);
             }
           }
-          if (label.isValid()) {
-            break;
-          }
-        }
-        mTimeFrame->getTrackletsLabel(iLayer).emplace_back(label);
-      }
+        });
     }
-  }
+  });
 }
 
 template <int nLayers>
@@ -277,17 +320,19 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
     auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeed>& layerCells, int iTracklet, int offset = 0) -> int {
       const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
       const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
-      const int nextLayerFirstTrackletIndex{
-        mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
-      const int nextLayerLastTrackletIndex{
-        mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
-
+      const int nextLayerFirstTrackletIndex{mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
+      const int nextLayerLastTrackletIndex{mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
       int foundCells{0};
       for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
+        const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
+        const auto& nextLbl = mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet];
+        bool print = false;
         if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
           break;
         }
-        const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
+        if (mTrkParams[iteration].DeltaROF && currentTracklet.getSpanRof(nextTracklet) > mTrkParams[iteration].DeltaROF) { // TODO this has to be improved for the staggering
+          continue;
+        }
         const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
 
 #ifdef OPTIMISATION_OUTPUT
@@ -414,19 +459,13 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
   /// Create cells labels
   if (mTimeFrame->hasMCinformation()) {
     for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-      for (auto& cell : mTimeFrame->getCells()[iLayer]) {
+      for (const auto& cell : mTimeFrame->getCells()[iLayer]) {
         MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
         MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
         mTimeFrame->getCellsLabel(iLayer).emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
       }
     }
   }
-
-  if constexpr (debugLevel) {
-    for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-      std::cout << "Cells on layer " << iLayer << " " << mTimeFrame->getCells()[iLayer].size() << std::endl;
-    }
-  }
 }
 
 template <int nLayers>
@@ -464,6 +503,16 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
             break;
           }
 
+          if (mTrkParams[iteration].DeltaROF) { // TODO this has to be improved for the staggering
+            const auto& trkl00 = mTimeFrame->getTracklets()[iLayer][currentCellSeed.getFirstTrackletIndex()];
+            const auto& trkl01 = mTimeFrame->getTracklets()[iLayer + 1][currentCellSeed.getSecondTrackletIndex()];
+            const auto& trkl10 = mTimeFrame->getTracklets()[iLayer + 1][nextCellSeed.getFirstTrackletIndex()];
+            const auto& trkl11 = mTimeFrame->getTracklets()[iLayer + 2][nextCellSeed.getSecondTrackletIndex()];
+            if ((std::max({trkl00.getMaxRof(), trkl01.getMaxRof(), trkl10.getMaxRof(), trkl11.getMaxRof()}) - std::min({trkl00.getMinRof(), trkl01.getMinRof(), trkl10.getMinRof(), trkl10.getMinRof()})) > mTrkParams[0].DeltaROF) {
+              continue;
+            }
+          }
+
           if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
               !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
             continue;
@@ -607,6 +656,21 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
           CA_DEBUGGER(failed[0]++);
           continue;
         }
+        if (mTrkParams[0].DeltaROF) { // TODO this has to be improved for the staggering
+          const auto& trklNeigh = mTimeFrame->getTracklets()[iLayer - 1][neighbourCell.getFirstTrackletIndex()];
+          short minRof{std::numeric_limits<short>::max()}, maxRof{std::numeric_limits<short>::min()};
+          for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
+            if (const auto clsId = currentCell.getCluster(iLayer); clsId != constants::UnusedIndex) {
+              const short clsROF = mTimeFrame->getClusterROF(iLayer, clsId);
+              minRof = std::min(minRof, clsROF);
+              maxRof = std::max(maxRof, clsROF);
+            }
+          }
+          if ((std::max(trklNeigh.getMaxRof(), maxRof) - std::min(trklNeigh.getMinRof(), minRof)) > mTrkParams[0].DeltaROF) {
+            continue;
+          }
+        }
+
         /// Let's start the fitting procedure
         CellSeed seed{currentCell};
         const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index a908f8b2a1f1e..00a69a37cb51a 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -165,7 +165,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   gsl::span<const std::pair<MCCompLabel, float>> vMCRecInfo;
   gsl::span<const MCCompLabel> vMCContLabels;
   for (auto iRof{0}; iRof < trackROFspan.size(); ++iRof) {
-    std::vector<Vertex> vtxVecLoc;
+    bounded_vector<Vertex> vtxVecLoc;
     auto& vtxROF = vertROFvec.emplace_back(trackROFspan[iRof]);
     vtxROF.setFirstEntry(vertices.size());
     if (mRunVertexer) {
@@ -223,7 +223,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       for (auto& v : vtxVecLoc) {
         vertices.push_back(v);
       }
-      mTimeFrame->addPrimaryVertices(vtxVecLoc, iRof, 0);
+      mTimeFrame->addPrimaryVertices(vtxVecLoc, 0);
     }
   }
   if (mRunVertexer) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 1069f1808fb2a..bcafa98972d78 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -26,18 +26,12 @@
 #include "Steer/MCKinematicsReader.h"
 #include "ITSMFTBase/DPLAlpideParam.h"
 #include "DetectorsRaw/HBFUtils.h"
-
-#ifdef VTX_DEBUG
-#include "TTree.h"
-#include "TFile.h"
-#include <fstream>
-#include <ostream>
-#endif
+#include "CommonUtils/TreeStreamRedirector.h"
 
 using namespace o2::its;
 
 template <TrackletMode Mode, bool EvalRun>
-void trackleterKernelHost(
+static void trackleterKernelHost(
   const gsl::span<const Cluster>& clustersNextLayer,    // 0 2
   const gsl::span<const Cluster>& clustersCurrentLayer, // 1 1
   const gsl::span<uint8_t>& usedClustersNextLayer,      // 0 2
@@ -97,21 +91,22 @@ void trackleterKernelHost(
   }
 }
 
-void trackletSelectionKernelHost(
+static void trackletSelectionKernelHost(
   const gsl::span<const Cluster> clusters0, // 0
   const gsl::span<const Cluster> clusters1, // 1
   gsl::span<unsigned char> usedClusters0,   // Layer 0
   gsl::span<unsigned char> usedClusters2,   // Layer 2
   const gsl::span<const Tracklet>& tracklets01,
   const gsl::span<const Tracklet>& tracklets12,
-  bounded_vector<uint8_t>& usedTracklets,
+  bounded_vector<bool>& usedTracklets,
   const gsl::span<int> foundTracklets01,
   const gsl::span<int> foundTracklets12,
   bounded_vector<Line>& lines,
   const gsl::span<const o2::MCCompLabel>& trackletLabels,
   bounded_vector<o2::MCCompLabel>& linesLabels,
-  const short pivotRofId,
-  const short targetRofId,
+  const short targetRofId0,
+  const short targetRofId2,
+  bool safeWrites = false,
   const float tanLambdaCut = 0.025f,
   const float phiCut = 0.005f,
   const int maxTracklets = static_cast<int>(1e2))
@@ -121,16 +116,27 @@ void trackletSelectionKernelHost(
     int validTracklets{0};
     for (int iTracklet12{offset12}; iTracklet12 < offset12 + foundTracklets12[iCurrentLayerClusterIndex]; ++iTracklet12) {
       for (int iTracklet01{offset01}; iTracklet01 < offset01 + foundTracklets01[iCurrentLayerClusterIndex]; ++iTracklet01) {
+        if (usedTracklets[iTracklet01]) {
+          continue;
+        }
+
         const auto& tracklet01{tracklets01[iTracklet01]};
         const auto& tracklet12{tracklets12[iTracklet12]};
-        if (tracklet01.rof[0] != targetRofId || tracklet12.rof[1] != targetRofId) {
+
+        if (tracklet01.rof[0] != targetRofId0 || tracklet12.rof[1] != targetRofId2) {
           continue;
         }
+
         const float deltaTanLambda{o2::gpu::GPUCommonMath::Abs(tracklet01.tanLambda - tracklet12.tanLambda)};
         const float deltaPhi{o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(tracklet01.phi, tracklet12.phi))};
-        if (!usedTracklets[iTracklet01] && deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets != maxTracklets) {
-          usedClusters0[tracklet01.firstClusterIndex] = true;
-          usedClusters2[tracklet12.secondClusterIndex] = true;
+        if (deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets != maxTracklets) {
+          if (safeWrites) {
+            __atomic_store_n(&usedClusters0[tracklet01.firstClusterIndex], 1, __ATOMIC_RELAXED);
+            __atomic_store_n(&usedClusters2[tracklet12.secondClusterIndex], 1, __ATOMIC_RELAXED);
+          } else {
+            usedClusters0[tracklet01.firstClusterIndex] = 1;
+            usedClusters2[tracklet12.secondClusterIndex] = 1;
+          }
           usedTracklets[iTracklet01] = true;
           lines.emplace_back(tracklet01, clusters0.data(), clusters1.data());
           if (!trackletLabels.empty()) {
@@ -273,46 +279,7 @@ void VertexerTraits::computeTracklets(const int iteration)
   }
 
 #ifdef VTX_DEBUG
-  // Dump on file
-  TFile* trackletFile = TFile::Open("artefacts_tf.root", "recreate");
-  TTree* tr_tre = new TTree("tracklets", "tf");
-  std::vector<o2::its::Tracklet> trkl_vec_0(0);
-  std::vector<o2::its::Tracklet> trkl_vec_1(0);
-  std::vector<o2::its::Cluster> clus0(0);
-  std::vector<o2::its::Cluster> clus1(0);
-  std::vector<o2::its::Cluster> clus2(0);
-  tr_tre->Branch("Tracklets0", &trkl_vec_0);
-  tr_tre->Branch("Tracklets1", &trkl_vec_1);
-  for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    trkl_vec_0.clear();
-    trkl_vec_1.clear();
-    for (auto& tr : mTimeFrame->getFoundTracklets(rofId, 0)) {
-      trkl_vec_0.push_back(tr);
-    }
-    for (auto& tr : mTimeFrame->getFoundTracklets(rofId, 1)) {
-      trkl_vec_1.push_back(tr);
-    }
-    tr_tre->Fill();
-  }
-  trackletFile->cd();
-  tr_tre->Write();
-  trackletFile->Close();
-
-  std::ofstream out01("NTC01_cpu.txt"), out12("NTC12_cpu.txt");
-  for (int iRof{0}; iRof < mTimeFrame->getNrof(); ++iRof) {
-    out01 << "ROF: " << iRof << std::endl;
-    out12 << "ROF: " << iRof << std::endl;
-    std::copy(mTimeFrame->getNTrackletsCluster(iRof, 0).begin(), mTimeFrame->getNTrackletsCluster(iRof, 0).end(), std::ostream_iterator<double>(out01, "\t"));
-    out01 << std::endl;
-    std::copy(mTimeFrame->getExclusiveNTrackletsCluster(iRof, 0).begin(), mTimeFrame->getExclusiveNTrackletsCluster(iRof, 0).end(), std::ostream_iterator<double>(out01, "\t"));
-    std::copy(mTimeFrame->getNTrackletsCluster(iRof, 1).begin(), mTimeFrame->getNTrackletsCluster(iRof, 1).end(), std::ostream_iterator<double>(out12, "\t"));
-    out12 << std::endl;
-    std::copy(mTimeFrame->getExclusiveNTrackletsCluster(iRof, 1).begin(), mTimeFrame->getExclusiveNTrackletsCluster(iRof, 1).end(), std::ostream_iterator<double>(out12, "\t"));
-    out01 << std::endl;
-    out12 << std::endl;
-  }
-  out01.close();
-  out12.close();
+  debugComputeTracklets(iteration);
 #endif
 }
 
@@ -326,62 +293,52 @@ void VertexerTraits::computeTrackletMatching(const int iteration)
           if (iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold) {
             continue;
           }
+          if (mTimeFrame->getFoundTracklets(pivotRofId, 0).empty()) {
+            continue;
+          }
           mTimeFrame->getLines(pivotRofId).reserve(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).size());
-          bounded_vector<uint8_t> usedTracklets(mTimeFrame->getFoundTracklets(pivotRofId, 0).size(), false, mMemoryPool.get());
+          bounded_vector<bool> usedTracklets(mTimeFrame->getFoundTracklets(pivotRofId, 0).size(), false, mMemoryPool.get());
           short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
           short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-          for (short targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
-            trackletSelectionKernelHost(
-              mTimeFrame->getClustersOnLayer(targetRofId, 0),
-              mTimeFrame->getClustersOnLayer(pivotRofId, 1),
-              mTimeFrame->getUsedClustersROF(targetRofId, 0),
-              mTimeFrame->getUsedClustersROF(targetRofId, 2),
-              mTimeFrame->getFoundTracklets(pivotRofId, 0),
-              mTimeFrame->getFoundTracklets(pivotRofId, 1),
-              usedTracklets,
-              mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
-              mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
-              mTimeFrame->getLines(pivotRofId),
-              mTimeFrame->getLabelsFoundTracklets(pivotRofId, 0),
-              mTimeFrame->getLinesLabel(pivotRofId),
-              pivotRofId,
-              targetRofId,
-              mVrtParams[iteration].tanLambdaCut,
-              mVrtParams[iteration].phiCut);
+
+          // needed only if multi-threaded using deltaRof and only at the overlap edges of the ranges
+          bool safeWrite = mTaskArena->max_concurrency() > 1 && mVrtParams[iteration].deltaRof != 0 && ((Rofs.begin() - startROF < 0) || (endROF - Rofs.end() > 0));
+
+          for (short targetRofId0 = startROF; targetRofId0 < endROF; ++targetRofId0) {
+            for (short targetRofId2 = startROF; targetRofId2 < endROF; ++targetRofId2) {
+              if (std::abs(targetRofId0 - targetRofId2) > mVrtParams[iteration].deltaRof) { // do not allow over 3 ROFs
+                continue;
+              }
+              trackletSelectionKernelHost(
+                mTimeFrame->getClustersOnLayer(targetRofId0, 0),
+                mTimeFrame->getClustersOnLayer(pivotRofId, 1),
+                mTimeFrame->getUsedClustersROF(targetRofId0, 0),
+                mTimeFrame->getUsedClustersROF(targetRofId2, 2),
+                mTimeFrame->getFoundTracklets(pivotRofId, 0),
+                mTimeFrame->getFoundTracklets(pivotRofId, 1),
+                usedTracklets,
+                mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
+                mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
+                mTimeFrame->getLines(pivotRofId),
+                mTimeFrame->getLabelsFoundTracklets(pivotRofId, 0),
+                mTimeFrame->getLinesLabel(pivotRofId),
+                targetRofId0,
+                targetRofId2,
+                safeWrite,
+                mVrtParams[iteration].tanLambdaCut,
+                mVrtParams[iteration].phiCut);
+            }
           }
         }
       });
   });
 
 #ifdef VTX_DEBUG
-  TFile* trackletFile = TFile::Open("artefacts_tf.root", "update");
-  TTree* ln_tre = new TTree("lines", "tf");
-  std::vector<o2::its::Line> lines_vec(0);
-  std::vector<int> nTrackl01(0);
-  std::vector<int> nTrackl12(0);
-  ln_tre->Branch("Lines", &lines_vec);
-  ln_tre->Branch("NTrackletCluster01", &nTrackl01);
-  ln_tre->Branch("NTrackletCluster12", &nTrackl12);
-  for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    lines_vec.clear();
-    nTrackl01.clear();
-    nTrackl12.clear();
-    for (auto& ln : mTimeFrame->getLines(rofId)) {
-      lines_vec.push_back(ln);
-    }
-    for (auto& n : mTimeFrame->getNTrackletsCluster(rofId, 0)) {
-      nTrackl01.push_back(n);
-    }
-    for (auto& n : mTimeFrame->getNTrackletsCluster(rofId, 1)) {
-      nTrackl12.push_back(n);
-    }
-
-    ln_tre->Fill();
-  }
-  trackletFile->cd();
-  ln_tre->Write();
-  trackletFile->Close();
+  debugComputeTrackletMatching(iteration);
 #endif
+
+  // from here on we do not use tracklets from L1-2 anymore, so let's free them
+  deepVectorClear(mTimeFrame->getTracklets()[1]);
 }
 
 void VertexerTraits::computeVertices(const int iteration)
@@ -390,9 +347,6 @@ void VertexerTraits::computeVertices(const int iteration)
   bounded_vector<Vertex> vertices(mMemoryPool.get());
   bounded_vector<std::pair<o2::MCCompLabel, float>> polls(mMemoryPool.get());
   bounded_vector<o2::MCCompLabel> contLabels(mMemoryPool.get());
-#ifdef VTX_DEBUG
-  std::vector<std::vector<ClusterLines>> dbg_clusLines(mTimeFrame->getNrof());
-#endif
   bounded_vector<int> noClustersVec(mTimeFrame->getNrof(), 0, mMemoryPool.get());
   for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
     if (iteration && (int)mTimeFrame->getPrimaryVertices(rofId).size() > mVrtParams[iteration].vertPerRofThreshold) {
@@ -473,12 +427,7 @@ void VertexerTraits::computeVertices(const int iteration)
   }
   for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
     std::sort(mTimeFrame->getTrackletClusters(rofId).begin(), mTimeFrame->getTrackletClusters(rofId).end(),
-              [](ClusterLines& cluster1, ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); }); // ensure clusters are ordered by contributors, so that we can cat after the first.
-#ifdef VTX_DEBUG
-    for (auto& cl : mTimeFrame->getTrackletClusters(rofId)) {
-      dbg_clusLines[rofId].push_back(cl);
-    }
-#endif
+              [](const ClusterLines& cluster1, const ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); }); // ensure clusters are ordered by contributors, so that we can cat after the first.
     bool atLeastOneFound{false};
     for (int iCluster{0}; iCluster < noClustersVec[rofId]; ++iCluster) {
       bool lowMultCandidate{false};
@@ -520,7 +469,7 @@ void VertexerTraits::computeVertices(const int iteration)
       }
     }
     if (!iteration) {
-      mTimeFrame->addPrimaryVertices(vertices, rofId, iteration);
+      mTimeFrame->addPrimaryVertices(vertices, iteration);
       if (mTimeFrame->hasMCinformation()) {
         mTimeFrame->addPrimaryVerticesLabels(polls);
         if (mVrtParams[iteration].outputContLabels) {
@@ -542,27 +491,9 @@ void VertexerTraits::computeVertices(const int iteration)
     vertices.clear();
     polls.clear();
   }
+
 #ifdef VTX_DEBUG
-  TFile* dbg_file = TFile::Open("artefacts_tf.root", "update");
-  TTree* ln_clus_lines_tree = new TTree("clusterlines", "tf");
-  std::vector<o2::its::ClusterLines> cl_lines_vec_pre(0);
-  std::vector<o2::its::ClusterLines> cl_lines_vec_post(0);
-  ln_clus_lines_tree->Branch("cllines_pre", &cl_lines_vec_pre);
-  ln_clus_lines_tree->Branch("cllines_post", &cl_lines_vec_post);
-  for (auto rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    cl_lines_vec_pre.clear();
-    cl_lines_vec_post.clear();
-    for (auto& clln : mTimeFrame->getTrackletClusters(rofId)) {
-      cl_lines_vec_post.push_back(clln);
-    }
-    for (auto& cl : dbg_clusLines[rofId]) {
-      cl_lines_vec_pre.push_back(cl);
-    }
-    ln_clus_lines_tree->Fill();
-  }
-  dbg_file->cd();
-  ln_clus_lines_tree->Write();
-  dbg_file->Close();
+  debugComputeVertices(iteration);
 #endif
 }
 
@@ -625,7 +556,7 @@ void VertexerTraits::addTruthSeedingVertices()
     } else {
       mTimeFrame->getNoVertexROF()++;
     }
-    mTimeFrame->addPrimaryVertices(verts, iROF, 0);
+    mTimeFrame->addPrimaryVertices(verts, 0);
     mTimeFrame->addPrimaryVerticesLabels(polls);
   }
   LOGP(info, "Found {}/{} ROFs with {} vertices -> <NV>={:.2f}", vertices.size(), mTimeFrame->getNrof(), nVerts, (float)nVerts / (float)vertices.size());
@@ -634,6 +565,7 @@ void VertexerTraits::addTruthSeedingVertices()
 void VertexerTraits::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
 {
 #if defined(VTX_DEBUG)
+  LOGP(info, "Vertexer with debug output forcing single thread");
   mTaskArena = std::make_shared<tbb::task_arena>(1);
 #else
   if (arena == nullptr) {
@@ -645,3 +577,257 @@ void VertexerTraits::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
   }
 #endif
 }
+
+void VertexerTraits::debugComputeTracklets(int iteration)
+{
+  auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "recreate");
+  LOGP(info, "writing debug output for computeTracklets");
+  for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
+    const auto& strk0 = mTimeFrame->getFoundTracklets(rofId, 0);
+    std::vector<Tracklet> trk0(strk0.begin(), strk0.end());
+    const auto& strk1 = mTimeFrame->getFoundTracklets(rofId, 1);
+    std::vector<Tracklet> trk1(strk1.begin(), strk1.end());
+    (*stream) << "tracklets"
+              << "Tracklets0=" << trk0
+              << "Tracklets1=" << trk1
+              << "iteration=" << iteration
+              << "\n";
+  }
+  stream->Close();
+  delete stream;
+}
+
+void VertexerTraits::debugComputeTrackletMatching(int iteration)
+{
+  auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "update");
+  LOGP(info, "writing debug output for computeTrackletMatching");
+  for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
+    (*stream) << "lines"
+              << "Lines=" << toSTDVector(mTimeFrame->getLines(rofId))
+              << "NTrackletCluster01=" << mTimeFrame->getNTrackletsCluster(rofId, 0)
+              << "NTrackletCluster12=" << mTimeFrame->getNTrackletsCluster(rofId, 1)
+              << "iteration=" << iteration
+              << "\n";
+  }
+
+  if (mTimeFrame->hasMCinformation()) {
+    LOGP(info, "\tdumping also MC information");
+    const auto dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
+    const auto irs = dc->getEventRecords();
+    int64_t roFrameBiasInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC;
+    int64_t roFrameLengthInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameLengthInBC;
+    o2::steer::MCKinematicsReader mcReader(dc);
+
+    std::map<int, int> eve2BcInROF, bcInRofNEve;
+    for (int iSrc{0}; iSrc < mcReader.getNSources(); ++iSrc) {
+      auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
+      for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
+        const auto& ir = irs[eveId2colId[iEve]];
+        if (!ir.isDummy()) { // do we need this, is this for diffractive events?
+          const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
+          const int bcInROF = ((ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC) % roFrameLengthInBC;
+          eve2BcInROF[iEve] = bcInROF;
+          ++bcInRofNEve[bcInROF];
+        }
+      }
+    }
+
+    std::unordered_map<int, int> bcROFNTracklets01, bcROFNTracklets12;
+    std::vector<std::vector<int>> tracklet01BC, tracklet12BC;
+    for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
+      { // 0-1
+        const auto& tracklet01 = mTimeFrame->getFoundTracklets(rofId, 0);
+        const auto& lbls01 = mTimeFrame->getLabelsFoundTracklets(rofId, 0);
+        auto& trkls01 = tracklet01BC.emplace_back();
+        for (int iTrklt{0}; iTrklt < (int)tracklet01.size(); ++iTrklt) {
+          const auto& tracklet = tracklet01[iTrklt];
+          const auto& lbl = lbls01[iTrklt];
+          if (lbl.isCorrect()) {
+            ++bcROFNTracklets01[eve2BcInROF[lbl.getEventID()]];
+            trkls01.push_back(eve2BcInROF[lbl.getEventID()]);
+          } else {
+            trkls01.push_back(-1);
+          }
+        }
+      }
+      { // 1-2 computed on the fly!
+        const auto& tracklet12 = mTimeFrame->getFoundTracklets(rofId, 1);
+        auto& trkls12 = tracklet12BC.emplace_back();
+        for (int iTrklt{0}; iTrklt < (int)tracklet12.size(); ++iTrklt) {
+          const auto& tracklet = tracklet12[iTrklt];
+          o2::MCCompLabel label;
+
+          int sortedId1{mTimeFrame->getSortedIndex(tracklet.rof[0], 1, tracklet.firstClusterIndex)};
+          int sortedId2{mTimeFrame->getSortedIndex(tracklet.rof[1], 2, tracklet.secondClusterIndex)};
+          for (const auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
+            for (const auto& lab2 : mTimeFrame->getClusterLabels(2, mTimeFrame->getClusters()[2][sortedId2].clusterId)) {
+              if (lab1 == lab2 && lab1.isValid()) {
+                label = lab1;
+                break;
+              }
+            }
+            if (label.isValid()) {
+              break;
+            }
+          }
+
+          if (label.isCorrect()) {
+            ++bcROFNTracklets12[eve2BcInROF[label.getEventID()]];
+            trkls12.push_back(eve2BcInROF[label.getEventID()]);
+          } else {
+            trkls12.push_back(-1);
+          }
+        }
+      }
+    }
+    LOGP(info, "\tdumping ntracklets/RofBC ({})", bcInRofNEve.size());
+    for (const auto& [bcInRof, neve] : bcInRofNEve) {
+      (*stream) << "ntracklets"
+                << "bcInROF=" << bcInRof
+                << "ntrkl01=" << bcROFNTracklets01[bcInRof]
+                << "ntrkl12=" << bcROFNTracklets12[bcInRof]
+                << "neve=" << neve
+                << "iteration=" << iteration
+                << "\n";
+    }
+
+    std::unordered_map<int, int> bcROFNLines;
+    for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
+      const auto& lines = mTimeFrame->getLines(rofId);
+      const auto& lbls = mTimeFrame->getLinesLabel(rofId);
+      for (int iLine{0}; iLine < (int)lines.size(); ++iLine) {
+        const auto& line = lines[iLine];
+        const auto& lbl = lbls[iLine];
+        if (lbl.isCorrect()) {
+          ++bcROFNLines[eve2BcInROF[lbl.getEventID()]];
+        }
+      }
+    }
+
+    LOGP(info, "\tdumping nlines/RofBC");
+    for (const auto& [bcInRof, neve] : bcInRofNEve) {
+      (*stream) << "nlines"
+                << "bcInROF=" << bcInRof
+                << "nline=" << bcROFNLines[bcInRof]
+                << "neve=" << neve
+                << "iteration=" << iteration
+                << "\n";
+    }
+  }
+  stream->Close();
+  delete stream;
+}
+
+void VertexerTraits::debugComputeVertices(int iteration)
+{
+  auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "update");
+  LOGP(info, "writing debug output for computeVertices");
+  for (auto rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
+    (*stream) << "clusterlines"
+              << "clines_post=" << toSTDVector(mTimeFrame->getTrackletClusters(rofId))
+              << "iteration=" << iteration
+              << "\n";
+  }
+
+  if (mTimeFrame->hasMCinformation()) {
+    LOGP(info, "\tdumping also MC information");
+    const auto dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
+    const auto irs = dc->getEventRecords();
+    int64_t roFrameBiasInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC;
+    int64_t roFrameLengthInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameLengthInBC;
+    o2::steer::MCKinematicsReader mcReader(dc);
+
+    std::map<int, int> eve2BcInROF, bcInRofNEve;
+    for (int iSrc{0}; iSrc < mcReader.getNSources(); ++iSrc) {
+      auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
+      for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
+        const auto& ir = irs[eveId2colId[iEve]];
+        if (!ir.isDummy()) { // do we need this, is this for diffractive events?
+          const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
+          const int bcInROF = ((ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC) % roFrameLengthInBC;
+          eve2BcInROF[iEve] = bcInROF;
+          ++bcInRofNEve[bcInROF];
+        }
+      }
+    }
+
+    std::unordered_map<int, int> bcROFNVtx;
+    std::unordered_map<int, float> bcROFNPur;
+    std::unordered_map<o2::MCCompLabel, size_t> uniqueVertices;
+    for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
+      const auto& pvs = mTimeFrame->getPrimaryVertices(rofId);
+      const auto& lblspv = mTimeFrame->getPrimaryVerticesMCRecInfo(rofId);
+      for (int i{0}; i < (int)pvs.size(); ++i) {
+        const auto& pv = pvs[i];
+        const auto& [lbl, pur] = lblspv[i];
+        if (lbl.isCorrect()) {
+          ++uniqueVertices[lbl];
+          ++bcROFNVtx[eve2BcInROF[lbl.getEventID()]];
+          bcROFNPur[eve2BcInROF[lbl.getEventID()]] += pur;
+        }
+      }
+    }
+
+    std::unordered_map<int, int> bcROFNUVtx, bcROFNCVtx;
+    for (const auto& [k, _] : eve2BcInROF) {
+      bcROFNUVtx[k] = bcROFNCVtx[k] = 0;
+    }
+
+    for (const auto& [lbl, c] : uniqueVertices) {
+      if (c <= 1) {
+        ++bcROFNUVtx[eve2BcInROF[lbl.getEventID()]];
+      } else {
+        ++bcROFNCVtx[eve2BcInROF[lbl.getEventID()]];
+      }
+    }
+
+    LOGP(info, "\tdumping nvtx/RofBC");
+    for (const auto& [bcInRof, neve] : bcInRofNEve) {
+      (*stream) << "nvtx"
+                << "bcInROF=" << bcInRof
+                << "nvtx=" << bcROFNVtx[bcInRof]   // all vertices
+                << "nuvtx=" << bcROFNUVtx[bcInRof] // unique vertices
+                << "ncvtx=" << bcROFNCVtx[bcInRof] // cloned vertices
+                << "npur=" << bcROFNPur[bcInRof]
+                << "neve=" << neve
+                << "iteration=" << iteration
+                << "\n";
+    }
+
+    // check dist of clones
+    std::unordered_map<o2::MCCompLabel, std::vector<Vertex>> cVtx;
+    for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
+      const auto& pvs = mTimeFrame->getPrimaryVertices(rofId);
+      const auto& lblspv = mTimeFrame->getPrimaryVerticesMCRecInfo(rofId);
+      for (int i{0}; i < (int)pvs.size(); ++i) {
+        const auto& pv = pvs[i];
+        const auto& [lbl, pur] = lblspv[i];
+        if (lbl.isCorrect() && uniqueVertices.contains(lbl) && uniqueVertices[lbl] > 1) {
+          if (!cVtx.contains(lbl)) {
+            cVtx[lbl] = std::vector<Vertex>();
+          }
+          cVtx[lbl].push_back(pv);
+        }
+      }
+    }
+
+    for (auto& [_, vertices] : cVtx) {
+      std::sort(vertices.begin(), vertices.end(), [](const Vertex& a, const Vertex& b) { return a.getNContributors() > b.getNContributors(); });
+      for (int i{0}; i < (int)vertices.size(); ++i) {
+        const auto vtx = vertices[i];
+        (*stream) << "cvtx"
+                  << "vertex=" << vtx
+                  << "i=" << i
+                  << "dx=" << vertices[0].getX() - vtx.getX()
+                  << "dy=" << vertices[0].getY() - vtx.getY()
+                  << "dz=" << vertices[0].getZ() - vtx.getZ()
+                  << "drof=" << vertices[0].getTimeStamp().getTimeStamp() - vtx.getTimeStamp().getTimeStamp()
+                  << "dnc=" << vertices[0].getNContributors() - vtx.getNContributors()
+                  << "iteration=" << iteration
+                  << "\n";
+      }
+    }
+  }
+  stream->Close();
+  delete stream;
+}

From 02b6dc2d9938ae3c857570cb7d39d554ab200536 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 23 Jul 2025 14:43:00 +0200
Subject: [PATCH 0646/1764] Fix alignment so that jemalloc / address sanitizer
 do no complain

This apparently fixes the issues with std::pmr in DataDistribution.
---
 DataFormats/Headers/include/Headers/Stack.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index 40987c483e1b8..0958b639ef451 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -38,7 +38,7 @@ struct Stack {
   struct freeobj {
     freeobj(memory_resource* mr) : resource(mr) {}
     memory_resource* resource{nullptr};
-    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, 0); }
+    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, alignof(std::max_align_t)); }
   };
 
  public:

From 76f5dc4b283c38c66535ca63ba9eb3c63d4309e2 Mon Sep 17 00:00:00 2001
From: aferrero2707 <aferrero1975@gmail.com>
Date: Tue, 8 Apr 2025 09:18:26 +0200
Subject: [PATCH 0647/1764] [MFT] read track covariances from AO2Ds

The "EXMFTTRACKCOV" table needs to be added to the aodSpawnerCallback()
in order to load the MFT tracks covariances from the AO2Ds.
---
 Framework/Core/src/AODReaderHelpers.cxx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index ba68cbf15a6e9..2587b8e4ca03a 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -188,6 +188,8 @@ AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(std::vector<InputSpec>& reque
           } else if (version == 1U) {
             outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMFTTRACK/1"_h>>(input, pc));
           }
+        } else if (description == header::DataDescription{"EXMFTTRACKCOV"}) {
+          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMFTTRACKCOV/0"_h>>(input, pc));
         } else if (description == header::DataDescription{"EXFWDTRACK"}) {
           outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXFWDTRACK/0"_h>>(input, pc));
         } else if (description == header::DataDescription{"EXFWDTRACKCOV"}) {

From b733857a1191e88a43dd9a5e0ab5515bfc347c57 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 23 Jul 2025 14:35:12 +0200
Subject: [PATCH 0648/1764] ITS: GPU: fix perVtx + upc iteration + atomic level
 update

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt  |   2 +-
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |   7 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   |   6 +
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 138 +++++++++---------
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  27 ++--
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  |  92 +++++-------
 .../ITS/tracking/GPU/hip/CMakeLists.txt       |   3 +-
 .../tracking/include/ITStracking/TimeFrame.h  |   6 +-
 .../include/ITStracking/TrackingInterface.h   |   1 -
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |   1 -
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  11 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |   3 +-
 .../ITS/tracking/src/TrackingInterface.cxx    |   6 +-
 .../ITSMFT/ITS/workflow/src/TrackerSpec.cxx   |   1 -
 14 files changed, 139 insertions(+), 165 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index f9565307d35f6..291ddffbf9475 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -9,7 +9,6 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-#add_compile_options(-O0 -g -fPIC -fno-omit-frame-pointer)
 o2_add_library(ITStracking
                TARGETVARNAME targetName
                SOURCES src/ClusterLines.cxx
@@ -37,6 +36,7 @@ o2_add_library(ITStracking
                PRIVATE_LINK_LIBRARIES
                        O2::Steer
                        TBB::tbb)
+# target_compile_options(${targetName} PRIVATE -O0 -g -fPIC -fno-omit-frame-pointer)
 
 o2_add_library(ITSTrackingInterface
                TARGETVARNAME targetName
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 8b3e9bddd18d6..0ad08fd88ccf5 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -23,11 +23,6 @@
 namespace o2::its::gpu
 {
 
-class DefaultGPUAllocator : public ExternalAllocator
-{
-  void* allocate(size_t size) override;
-};
-
 template <int nLayers = 7>
 class TimeFrameGPU : public TimeFrame<nLayers>
 {
@@ -84,7 +79,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
     return mGpuStreams[stream];
   }
   auto& getStreams() { return mGpuStreams; }
-  void wipe(const int);
+  virtual void wipe() final;
 
   /// interface
   int getNClustersInRofSpan(const int, const int, const int) const;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index 454e39e04a661..802973d5f4000 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -21,6 +21,12 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonHelpers.h"
 
+#ifndef __HIPCC__
+#define THRUST_NAMESPACE thrust::cuda
+#else
+#define THRUST_NAMESPACE thrust::hip
+#endif
+
 namespace o2::its
 {
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index d5ea573a2f0e8..f6d9157b0da68 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -21,8 +21,6 @@
 #include "ITStrackingGPU/TracerGPU.h"
 
 #include <unistd.h>
-#include <thread>
-#include <tuple>
 #include <vector>
 #include <fmt/format.h>
 
@@ -31,14 +29,7 @@
 #include "GPUCommonLogger.h"
 #include "GPUCommonHelpers.h"
 
-namespace o2
-{
-namespace its
-{
-using constants::GB;
-using constants::MB;
-
-namespace gpu
+namespace o2::its::gpu
 {
 
 #ifdef ITS_MEASURE_GPU_TIME
@@ -96,14 +87,19 @@ class GPUTimer
   std::vector<cudaEvent_t> mStarts, mStops;
   std::vector<cudaStream_t> mStreams;
 };
+
+#define GPULog(...) LOGP(info, __VA_ARGS__)
 #else // ITS_MEASURE_GPU_TIME not defined
 class GPUTimer
 {
  public:
-  GPUTimer(Stream&, const std::string&) {}
-  GPUTimer(Streams&, const std::string&) {}
-  GPUTimer(Streams&, const std::string&, int, int = 0) {}
+  template <typename... Args>
+  GPUTimer(Args&&...)
+  {
+  }
 };
+
+#define GPULog(...)
 #endif
 
 template <int nLayers>
@@ -121,7 +117,7 @@ void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& strea
   if (extAllocator) {
     *ptr = this->mAllocator->allocate(size);
   } else {
-    LOGP(debug, "Calling default CUDA allocator");
+    GPULog("Calling default CUDA allocator");
     GPUChkErrS(cudaMallocAsync(reinterpret_cast<void**>(ptr), size, stream.get()));
   }
 }
@@ -137,10 +133,10 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
 {
   GPUTimer timer(mGpuStreams[0], "loading indextable utils");
   if (!iteration) {
-    LOGP(debug, "gpu-allocation: allocating IndexTableUtils buffer, for {} MB.", sizeof(IndexTableUtils) / MB);
+    GPULog("gpu-allocation: allocating IndexTableUtils buffer, for {:.2f} MB.", sizeof(IndexTableUtils) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), mGpuStreams[0], this->getExtAllocator());
   }
-  LOGP(debug, "gpu-transfer: loading IndexTableUtils object, for {} MB.", sizeof(IndexTableUtils) / MB);
+  GPULog("gpu-transfer: loading IndexTableUtils object, for {:.2f} MB.", sizeof(IndexTableUtils) / constants::MB);
   GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
 }
 
@@ -149,11 +145,11 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer(mGpuStreams[0], "loading unsorted clusters");
-    for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading {} unsorted clusters on layer {}, for {} MB.", this->mUnsortedClusters[iLayer].size(), iLayer, this->mUnsortedClusters[iLayer].size() * sizeof(Cluster) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[0], this->getExtAllocator());
+    for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+      GPULog("gpu-transfer: loading {} unsorted clusters on layer {}, for {:.2f} MB.", this->mUnsortedClusters[iLayer].size(), iLayer, this->mUnsortedClusters[iLayer].size() * sizeof(Cluster) / constants::MB);
+      allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[iLayer], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
     }
     allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
@@ -167,7 +163,7 @@ void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
   if (!iteration) {
     GPUTimer timer(mGpuStreams[0], "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading {} clusters on layer {}, for {} MB.", this->mClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(Cluster) / MB);
+      GPULog("gpu-transfer: loading {} clusters on layer {}, for {:.2f} MB.", this->mClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(Cluster) / constants::MB);
       allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), this->mClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[0], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
       GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
@@ -184,7 +180,7 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
   if (!iteration) {
     GPUTimer timer(mGpuStreams[0], "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading clusters indextable for layer {} with {} elements, for {} MB.", iLayer, this->mIndexTables[iLayer].size(), this->mIndexTables[iLayer].size() * sizeof(int) / MB);
+      GPULog("gpu-transfer: loading clusters indextable for layer {} with {} elements, for {:.2f} MB.", iLayer, this->mIndexTables[iLayer].size(), this->mIndexTables[iLayer].size() * sizeof(int) / constants::MB);
       allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), this->mIndexTables[iLayer].size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
       GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
@@ -199,7 +195,7 @@ void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
   if (!iteration) {
     GPUTimer timer(mGpuStreams[0], "creating used clusters flags");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: creating {} used clusters flags on layer {}, for {} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / MB);
+      GPULog("gpu-transfer: creating {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / constants::MB);
       allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0], this->getExtAllocator());
       GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0].get()));
     }
@@ -213,7 +209,7 @@ void TimeFrameGPU<nLayers>::loadUsedClustersDevice()
 {
   GPUTimer timer(mGpuStreams[0], "loading used clusters flags");
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading {} used clusters flags on layer {}, for {} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(unsigned char) / MB);
+    GPULog("gpu-transfer: loading {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(unsigned char) / constants::MB);
     GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
 }
@@ -224,7 +220,7 @@ void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
   if (!iteration) {
     GPUTimer timer(mGpuStreams[0], "loading ROframe clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading {} ROframe clusters info on layer {}, for {} MB.", this->mROFramesClusters[iLayer].size(), iLayer, this->mROFramesClusters[iLayer].size() * sizeof(int) / MB);
+      GPULog("gpu-transfer: loading {} ROframe clusters info on layer {}, for {:.2f} MB.", this->mROFramesClusters[iLayer].size(), iLayer, this->mROFramesClusters[iLayer].size() * sizeof(int) / constants::MB);
       allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), this->mROFramesClusters[iLayer].size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
       GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
@@ -239,7 +235,7 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
   GPUTimer timer(mGpuStreams[0], "loading trackingframeinfo");
   if (!iteration) {
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      LOGP(debug, "gpu-transfer: loading {} tfinfo on layer {}, for {} MB.", this->mTrackingFrameInfo[iLayer].size(), iLayer, this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / MB);
+      GPULog("gpu-transfer: loading {} tfinfo on layer {}, for {:.2f} MB.", this->mTrackingFrameInfo[iLayer].size(), iLayer, this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / constants::MB);
       allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), mGpuStreams[0], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
       GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
@@ -253,10 +249,12 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
 {
-  if (!iteration) {
+  if (!iteration || iteration == 3) { // we need to re-load the swapped mult-mask in upc iteration
     GPUTimer timer(mGpuStreams[0], "loading multiplicity cut mask");
-    LOGP(debug, "gpu-transfer: loading multiplicity cut mask with {} elements, for {} MB.", this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(bool) / MB);
-    allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), mGpuStreams[0], this->getExtAllocator());
+    GPULog("gpu-transfer: iteration {} loading multiplicity cut mask with {} elements, for {:.2f} MB.", iteration, this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(bool) / constants::MB);
+    if (!iteration) { // only allocate on first call
+      allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), mGpuStreams[0], this->getExtAllocator());
+    }
     GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
 }
@@ -266,10 +264,10 @@ void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer(mGpuStreams[0], "loading seeding vertices");
-    LOGP(debug, "gpu-transfer: loading {} ROframes vertices, for {} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / MB);
+    GPULog("gpu-transfer: loading {} ROframes vertices, for {:.2f} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
-    LOGP(debug, "gpu-transfer: loading {} seeding vertices, for {} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / MB);
+    GPULog("gpu-transfer: loading {} seeding vertices, for {:.2f} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
@@ -278,13 +276,14 @@ void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
 {
-  GPUTimer timer(mGpuStreams, "creating tracklets LUTs", nLayers - 1);
+  GPUTimer timer(mGpuStreams[0], "creating tracklets LUTs");
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
+    const int ncls = this->mClusters[iLayer].size() + 1;
     if (!iteration) {
-      LOGP(debug, "gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {} MB.", this->mClusters[iLayer].size() + 1, iLayer, (this->mClusters[iLayer].size() + 1) * sizeof(int) / MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
+      GPULog("gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {:.2f} MB.", ncls, iLayer, ncls * sizeof(int) / constants::MB);
+      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), ncls * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
     }
-    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, (this->mClusters[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
+    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, ncls * sizeof(int), mGpuStreams[iLayer].get()));
   }
   if (!iteration) {
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
@@ -295,11 +294,11 @@ void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsBuffers()
 {
-  GPUTimer timer(mGpuStreams, "creating cells buffers", nLayers - 1);
-  for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
+  GPUTimer timer(mGpuStreams[0], "creating tracklet buffers");
+  for (int iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
     mNTracklets[iLayer] = 0;
-    GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + this->mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost));
-    LOGP(debug, "gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {} MB.", mNTracklets[iLayer], iLayer, mNTracklets[iLayer] * sizeof(Tracklet) / MB);
+    GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + this->mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
+    GPULog("gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {:.2f} MB.", mNTracklets[iLayer], iLayer, mNTracklets[iLayer] * sizeof(Tracklet) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), mGpuStreams[iLayer], this->getExtAllocator());
   }
   allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), mGpuStreams[0], this->getExtAllocator());
@@ -312,7 +311,7 @@ void TimeFrameGPU<nLayers>::loadTrackletsDevice()
 {
   GPUTimer timer(mGpuStreams, "loading tracklets", nLayers - 1);
   for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading {} tracklets on layer {}, for {} MB.", this->mTracklets[iLayer].size(), iLayer, this->mTracklets[iLayer].size() * sizeof(Tracklet) / MB);
+    GPULog("gpu-transfer: loading {} tracklets on layer {}, for {:.2f} MB.", this->mTracklets[iLayer].size(), iLayer, this->mTracklets[iLayer].size() * sizeof(Tracklet) / constants::MB);
     GPUChkErrS(cudaHostRegister(this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
@@ -323,12 +322,12 @@ void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
 {
   GPUTimer timer(mGpuStreams, "loading tracklets", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {} MB", this->mTrackletsLookupTable[iLayer].size(), iLayer + 1, this->mTrackletsLookupTable[iLayer].size() * sizeof(int) / MB);
+    GPULog("gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {:.2f} MB", this->mTrackletsLookupTable[iLayer].size(), iLayer + 1, this->mTrackletsLookupTable[iLayer].size() * sizeof(int) / constants::MB);
     GPUChkErrS(cudaHostRegister(this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
   GPUChkErrS(cudaHostRegister(mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
+  GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
 }
 
 template <int nLayers>
@@ -340,7 +339,7 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
   GPUChkErrS(cudaHostRegister(mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
+    GPULog("gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
     if (iLayer < nLayers - 3) {
@@ -353,7 +352,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const unsigned int nCells)
 {
   GPUTimer timer(mGpuStreams[0], "reserving neighboursLUT");
-  LOGP(debug, "gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / MB);
+  GPULog("gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {:.2f} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator()); // We need one element more to move exc -> inc
   GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0].get()));
 }
@@ -363,7 +362,7 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
 {
   GPUTimer timer(mGpuStreams, "loading cell seeds", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading {} cell seeds on layer {}, for {} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeed) / MB);
+    GPULog("gpu-transfer: loading {} cell seeds on layer {}, for {:.2f} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeed) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeed), mGpuStreams[iLayer], this->getExtAllocator());
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator()); // accessory for the neigh. finding.
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
@@ -378,7 +377,7 @@ void TimeFrameGPU<nLayers>::createCellsLUTDevice()
 {
   GPUTimer timer(mGpuStreams, "creating cells LUTs", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    LOGP(debug, "gpu-transfer: creating cell LUT for {} elements on layer {}, for {} MB.", mNTracklets[iLayer] + 1, iLayer, (mNTracklets[iLayer] + 1) * sizeof(int) / MB);
+    GPULog("gpu-transfer: creating cell LUT for {} elements on layer {}, for {:.2f} MB.", mNTracklets[iLayer] + 1, iLayer, (mNTracklets[iLayer] + 1) * sizeof(int) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
     GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer].get()));
   }
@@ -391,9 +390,9 @@ void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
 {
   GPUTimer timer(mGpuStreams[0], "creating cells buffers");
   mNCells[layer] = 0;
-  GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost));
-  LOGP(debug, "gpu-transfer: creating cell buffer for {} elements on layer {}, for {} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
+  GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
+  GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / constants::MB);
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), mGpuStreams[layer], this->getExtAllocator());
 }
 
 template <int nLayers>
@@ -401,7 +400,7 @@ void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
 {
   GPUTimer timer(mGpuStreams, "loading cells LUTs", nLayers - 3);
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
-    LOGP(debug, "gpu-transfer: loading cell LUT for {} elements on layer {}, for {} MB.", this->mCellsLookupTable[iLayer].size(), iLayer, this->mCellsLookupTable[iLayer].size() * sizeof(int) / MB);
+    GPULog("gpu-transfer: loading cell LUT for {} elements on layer {}, for {:.2f} MB.", this->mCellsLookupTable[iLayer].size(), iLayer, this->mCellsLookupTable[iLayer].size() * sizeof(int) / constants::MB);
     GPUChkErrS(cudaHostRegister(this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
@@ -411,7 +410,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadRoadsDevice()
 {
   GPUTimer timer(mGpuStreams[0], "loading roads device");
-  LOGP(debug, "gpu-transfer: loading {} roads, for {} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / MB);
+  GPULog("gpu-transfer: loading {} roads, for {:.2f} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
@@ -421,7 +420,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeed>& seeds)
 {
   GPUTimer timer(mGpuStreams[0], "loading track seeds");
-  LOGP(debug, "gpu-transfer: loading {} track seeds, for {} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / MB);
+  GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
@@ -431,10 +430,10 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, const unsigned int nNeighbours)
 {
   GPUTimer timer(mGpuStreams[0], "reserving neighbours");
-  LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
+  GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
-  LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / MB);
+  GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), mGpuStreams[0], this->getExtAllocator());
 }
 
@@ -444,10 +443,10 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, std
   GPUTimer timer(mGpuStreams[0], "reserving neighbours");
   this->mCellsNeighbours[layer].clear();
   this->mCellsNeighbours[layer].resize(neighbours.size());
-  LOGP(debug, "gpu-allocation: reserving {} neighbours (pairs), for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
+  GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
-  LOGP(debug, "gpu-allocation: reserving {} neighbours, for {} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / MB);
+  GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
 }
 
@@ -464,7 +463,7 @@ void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeed>& se
 {
   GPUTimer timer(mGpuStreams[0], "reserving tracks");
   mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
-  LOGP(debug, "gpu-allocation: reserving {} tracks, for {} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / MB);
+  GPULog("gpu-allocation: reserving {} tracks, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0].get()));
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
@@ -475,7 +474,7 @@ void TimeFrameGPU<nLayers>::downloadCellsDevice()
 {
   GPUTimer timer(mGpuStreams, "downloading cells", nLayers - 2);
   for (int iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    LOGP(debug, "gpu-transfer: downloading {} cells on layer: {}, for {} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / MB);
+    GPULog("gpu-transfer: downloading {} cells on layer: {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / constants::MB);
     this->mCells[iLayer].resize(mNCells[iLayer]);
     GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
   }
@@ -486,7 +485,7 @@ void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
 {
   GPUTimer timer(mGpuStreams, "downloading cell luts", nLayers - 3);
   for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
-    LOGP(debug, "gpu-transfer: downloading cells lut on layer {} for {} elements", iLayer, (mNTracklets[iLayer + 1] + 1));
+    GPULog("gpu-transfer: downloading cells lut on layer {} for {} elements", iLayer, (mNTracklets[iLayer + 1] + 1));
     this->mCellsLookupTable[iLayer].resize(mNTracklets[iLayer + 1] + 1);
     GPUChkErrS(cudaMemcpyAsync(this->mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
   }
@@ -496,7 +495,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>& neighbours, const int layer)
 {
   GPUTimer timer(mGpuStreams[0], fmt::format("downloading neighbours from layer {}", layer));
-  LOGP(debug, "gpu-transfer: downloading {} neighbours, for {} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / MB);
+  GPULog("gpu-transfer: downloading {} neighbours, for {:.2f} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / constants::MB);
   // TODO: something less dangerous than assuming the same memory layout of std::pair and gpuPair... or not? :)
   GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
 }
@@ -505,7 +504,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut, const int layer)
 {
   GPUTimer timer(mGpuStreams[0], fmt::format("downloading neighbours LUT from layer {}", layer));
-  LOGP(debug, "gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {} MB.", lut.size(), layer, lut.size() * sizeof(int) / MB);
+  GPULog("gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {:.2f} MB.", lut.size(), layer, lut.size() * sizeof(int) / constants::MB);
   GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
 }
 
@@ -513,7 +512,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
   GPUTimer timer(mGpuStreams[0], "downloading tracks");
-  LOGP(debug, "gpu-transfer: downloading {} tracks, for {} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / MB);
+  GPULog("gpu-transfer: downloading {} tracks, for {:.2f} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
   GPUChkErrS(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
   GPUChkErrS(cudaHostUnregister(mTrackITSExt.data()));
   GPUChkErrS(cudaHostUnregister(seeds.data()));
@@ -523,7 +522,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterRest()
 {
   GPUTimer timer(mGpuStreams[0], "unregistering rest of the host memory");
-  LOGP(debug, "unregistering rest of the host memory...");
+  GPULog("unregistering rest of the host memory...");
   GPUChkErrS(cudaHostUnregister(mCellsDevice.data()));
   GPUChkErrS(cudaHostUnregister(mTrackletsDevice.data()));
 }
@@ -531,6 +530,8 @@ void TimeFrameGPU<nLayers>::unregisterRest()
 template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
 {
+  GPUTimer timer(mGpuStreams[0], "unregistering host memory");
+  GPULog("unregistering host memory");
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
     GPUChkErrS(cudaHostUnregister(this->mUnsortedClusters[iLayer].data()));
     GPUChkErrS(cudaHostUnregister(this->mClusters[iLayer].data()));
@@ -552,7 +553,12 @@ void TimeFrameGPU<nLayers>::initialise(const int iteration,
   o2::its::TimeFrame<nLayers>::initialise(iteration, trkParam, maxLayers);
 }
 
+template <int nLayers>
+void TimeFrameGPU<nLayers>::wipe()
+{
+  unregisterHostMemory(0);
+  o2::its::TimeFrame<nLayers>::wipe();
+}
+
 template class TimeFrameGPU<7>;
-} // namespace gpu
-} // namespace its
-} // namespace o2
+} // namespace o2::its::gpu
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 1b1c4af682dc5..a8061e872c029 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -18,10 +18,10 @@
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
 #include "ITStrackingGPU/TrackingKernels.h"
 #include "ITStracking/TrackingConfigParam.h"
+#include "ITStracking/Constants.h"
 
 namespace o2::its
 {
-constexpr int UnusedIndex{-1};
 
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
@@ -48,10 +48,8 @@ void TrackerTraitsGPU<nLayers>::adoptTimeFrame(TimeFrame<nLayers>* tf)
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
 {
-  auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
+  const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  const Vertex diamondVert({this->mTrkParams[iteration].Diamond[0], this->mTrkParams[iteration].Diamond[1], this->mTrkParams[iteration].Diamond[2]}, {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f}, 1, 1.f);
-  gsl::span<const Vertex> diamondSpan(&diamondVert, 1);
   int startROF{this->mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * this->mTrkParams[iteration].nROFsPerIterations : 0};
   int endROF{o2::gpu::CAMath::Min(this->mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * this->mTrkParams[iteration].nROFsPerIterations + this->mTrkParams[iteration].DeltaROF : mTimeFrameGPU->getNrof(), mTimeFrameGPU->getNrof())};
 
@@ -128,6 +126,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
 
   for (int iLayer = 0; iLayer < this->mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
     if (!mTimeFrameGPU->getNTracklets()[iLayer + 1] || !mTimeFrameGPU->getNTracklets()[iLayer]) {
+      mTimeFrameGPU->getNCells()[iLayer] = 0;
       continue;
     }
     const int currentLayerTrackletsNum{static_cast<int>(mTimeFrameGPU->getNTracklets()[iLayer])};
@@ -173,9 +172,10 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
   mTimeFrameGPU->createNeighboursIndexTablesDevice();
   const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   for (int iLayer{0}; iLayer < this->mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
+    const int currentLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer])};
     const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};
-
-    if (!nextLayerCellsNum) {
+    if (!nextLayerCellsNum || !currentLayerCellsNum) {
+      mTimeFrameGPU->getNNeighbours()[iLayer] = 0;
       continue;
     }
 
@@ -188,7 +188,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                                      this->mTrkParams[0].MaxChi2ClusterAttachment,
                                                      this->mBz,
                                                      iLayer,
-                                                     mTimeFrameGPU->getNCells()[iLayer],
+                                                     currentLayerCellsNum,
                                                      nextLayerCellsNum,
                                                      1e2,
                                                      conf.nBlocks,
@@ -204,7 +204,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                  this->mTrkParams[0].MaxChi2ClusterAttachment,
                                  this->mBz,
                                  iLayer,
-                                 mTimeFrameGPU->getNCells()[iLayer],
+                                 currentLayerCellsNum,
                                  nextLayerCellsNum,
                                  1e2,
                                  conf.nBlocks,
@@ -251,8 +251,8 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         conf.nThreads);
     }
     // fixme: I don't want to move tracks back and forth, but I need a way to use a thrust::allocator that is aware of our managed memory.
-    if (!trackSeeds.size()) {
-      LOGP(info, "No track seeds found, skipping track finding");
+    if (trackSeeds.empty()) {
+      LOGP(debug, "No track seeds found, skipping track finding");
       continue;
     }
     mTimeFrameGPU->createTrackITSExtDevice(trackSeeds);
@@ -283,7 +283,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
       int nShared = 0;
       bool isFirstShared{false};
       for (int iLayer{0}; iLayer < this->mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == UnusedIndex) {
+        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
           continue;
         }
         nShared += int(mTimeFrameGPU->isClusterUsed(iLayer, track.getClusterIndex(iLayer)));
@@ -296,7 +296,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
 
       std::array<int, 3> rofs{INT_MAX, INT_MAX, INT_MAX};
       for (int iLayer{0}; iLayer < this->mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == UnusedIndex) {
+        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
           continue;
         }
         mTimeFrameGPU->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
@@ -320,9 +320,6 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
     }
     mTimeFrameGPU->loadUsedClustersDevice();
   }
-  if (iteration == this->mTrkParams.size() - 1) {
-    mTimeFrameGPU->unregisterHostMemory(0);
-  }
 };
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 38c59d520aa76..fb75764da2e36 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -36,15 +36,6 @@
 #include "ITStrackingGPU/TrackingKernels.h"
 #include "ITStrackingGPU/Utils.h"
 
-#ifndef __HIPCC__
-#define THRUST_NAMESPACE thrust::cuda
-#else
-#define THRUST_NAMESPACE thrust::hip
-#endif
-
-#define GPU_BLOCKS GPUCA_DETERMINISTIC_CODE(1, 99999)
-#define GPU_THREADS GPUCA_DETERMINISTIC_CODE(1, 99999)
-
 // O2 track model
 #include "ReconstructionDataFormats/Track.h"
 #include "DetectorsBase/Propagator.h"
@@ -112,7 +103,6 @@ GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerInde
 
   if (zRangeMax < -utils.getLayerZ(layerIndex) ||
       zRangeMin > utils.getLayerZ(layerIndex) || zRangeMin > zRangeMax) {
-
     return getEmptyBinsRect();
   }
 
@@ -398,22 +388,20 @@ GPUg() void computeLayerCellNeighboursKernel(
       }
       if constexpr (initRun) {
         atomicAdd(neighboursLUT + iNextCell, 1);
-        foundNeighbours++;
         neighboursIndexTable[iCurrentCellIndex]++;
       } else {
         cellNeighbours[neighboursIndexTable[iCurrentCellIndex] + foundNeighbours] = {iCurrentCellIndex, iNextCell};
         foundNeighbours++;
-        // FIXME: this is prone to race conditions: check on level is not atomic
         const int currentCellLevel{currentCellSeed.getLevel()};
         if (currentCellLevel >= nextCellSeed.getLevel()) {
-          cellSeedArray[layerIndex + 1][iNextCell].setLevel(currentCellLevel + 1);
+          atomicMax(cellSeedArray[layerIndex + 1][iNextCell].getLevelPtr(), currentCellLevel + 1);
         }
       }
     }
   }
 }
 
-template <bool initRun, int nLayers = 7>
+template <bool initRun>
 GPUg() void computeLayerCellsKernel(
   const Cluster** sortedClusters,
   const Cluster** unsortedClusters,
@@ -530,8 +518,14 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
   for (unsigned int iROF{blockIdx.x}; iROF < endROF - startROF; iROF += gridDim.x) {
     const short rof0 = iROF + startROF;
     auto primaryVertices = getPrimaryVertices(rof0, rofPV, totalROFs, multMask, vertices);
+    if (primaryVertices.empty()) {
+      continue;
+    }
     const auto startVtx{vertexId >= 0 ? vertexId : 0};
     const auto endVtx{vertexId >= 0 ? o2::gpu::CAMath::Min(vertexId + 1, static_cast<int>(primaryVertices.size())) : static_cast<int>(primaryVertices.size())};
+    if ((endVtx - startVtx) <= 0) {
+      continue;
+    }
     const short minROF = o2::gpu::CAMath::Max(startROF, static_cast<int>(rof0 - deltaROF));
     const short maxROF = o2::gpu::CAMath::Min(endROF - 1, static_cast<int>(rof0 + deltaROF));
     auto clustersCurrentLayer = getClustersOnLayer(rof0, totalROFs, layerIndex, ROFClusters, clusters);
@@ -541,7 +535,7 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
 
     for (int currentClusterIndex = threadIdx.x; currentClusterIndex < clustersCurrentLayer.size(); currentClusterIndex += blockDim.x) {
       unsigned int storedTracklets{0};
-      auto currentCluster{clustersCurrentLayer[currentClusterIndex]};
+      const auto& currentCluster{clustersCurrentLayer[currentClusterIndex]};
       const int currentSortedIndex{ROFClusters[layerIndex][rof0] + currentClusterIndex};
       if (usedClusters[layerIndex][currentCluster.clusterId]) {
         continue;
@@ -550,14 +544,15 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
       const float inverseR0{1.f / currentCluster.radius};
       for (int iV{startVtx}; iV < endVtx; ++iV) {
         auto& primaryVertex{primaryVertices[iV]};
-        if (primaryVertex.isFlagSet(2) && iteration != 3) {
+        if ((primaryVertex.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) || (iteration == 3 && !primaryVertex.isFlagSet(Vertex::Flags::UPCMode))) {
           continue;
         }
+
         const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(resolutionPV) / primaryVertex.getNContributors() + math_utils::Sq(positionResolution));
         const float tanLambda{(currentCluster.zCoordinate - primaryVertex.getZ()) * inverseR0};
         const float zAtRmin{tanLambda * (minR - currentCluster.radius) + currentCluster.zCoordinate};
         const float zAtRmax{tanLambda * (maxR - currentCluster.radius) + currentCluster.zCoordinate};
-        const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + 2.e-8f)}; /// protecting from overflows adding the detector resolution
+        const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + constants::Tolerance)}; /// protecting from overflows adding the detector resolution
         const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * MSAngle))};
         const int4 selectedBinsRect{getBinsRect(currentCluster, layerIndex + 1, *utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
         if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
@@ -579,8 +574,8 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
             int iPhiBin = (selectedBinsRect.y + iPhiCount) % phiBins;
             const int firstBinIndex{utils->getBinIndex(selectedBinsRect.x, iPhiBin)};
             const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
-            const int firstRowClusterIndex = indexTables[layerIndex + 1][(rof1 - startROF) * tableSize + firstBinIndex];
-            const int maxRowClusterIndex = indexTables[layerIndex + 1][(rof1 - startROF) * tableSize + maxBinIndex];
+            const int firstRowClusterIndex = indexTables[layerIndex + 1][(rof1)*tableSize + firstBinIndex];
+            const int maxRowClusterIndex = indexTables[layerIndex + 1][(rof1)*tableSize + maxBinIndex];
             for (int nextClusterIndex{firstRowClusterIndex}; nextClusterIndex < maxRowClusterIndex; ++nextClusterIndex) {
               if (nextClusterIndex >= clustersNextLayer.size()) {
                 break;
@@ -591,13 +586,13 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
               }
               const float deltaPhi{o2::gpu::CAMath::Abs(currentCluster.phi - nextCluster.phi)};
               const float deltaZ{o2::gpu::CAMath::Abs(tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate)};
-              const int nextSortedIndex{ROFClusters[layerIndex + 1][rof1] + nextClusterIndex};
               if (deltaZ / sigmaZ < NSigmaCut && (deltaPhi < phiCut || o2::gpu::CAMath::Abs(deltaPhi - o2::constants::math::TwoPI) < phiCut)) {
                 if constexpr (initRun) {
                   trackletsLUT[layerIndex][currentSortedIndex]++; // we need l0 as well for usual exclusive sums.
                 } else {
                   const float phi{o2::gpu::CAMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate)};
                   const float tanL{(currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius)};
+                  const int nextSortedIndex{ROFClusters[layerIndex + 1][rof1] + nextClusterIndex};
                   new (tracklets[layerIndex] + trackletsLUT[layerIndex][currentSortedIndex] + storedTracklets) Tracklet{currentSortedIndex, nextSortedIndex, tanL, phi, rof0, rof1};
                 }
                 ++storedTracklets;
@@ -841,11 +836,9 @@ GPUhi() void cubExclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stre
 {
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out,
-                                           in_out, num_items, stream));
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
   GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out,
-                                           in_out, num_items, stream));
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
   GPUChkErrS(cudaFree(d_temp_storage));
 }
 
@@ -860,11 +853,9 @@ GPUhi() void cubInclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stre
 {
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
-  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out,
-                                           in_out, num_items, stream));
+  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
   GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
-  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out,
-                                           in_out, num_items, stream));
+  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
   GPUChkErrS(cudaFree(d_temp_storage));
 }
 
@@ -907,10 +898,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  gpu::Streams& streams)
 {
   for (int iLayer = 0; iLayer < nLayers - 1; ++iLayer) {
-    gpu::computeLayerTrackletsMultiROFKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                                     o2::gpu::CAMath::Min(nThreads, GPU_THREADS),
-                                                     0,
-                                                     streams[iLayer].get()>>>(
+    gpu::computeLayerTrackletsMultiROFKernel<true><<<nBlocks, nThreads, 0, streams[iLayer].get()>>>(
       utils,
       multMask,
       iLayer,
@@ -976,10 +964,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    gpu::Streams& streams)
 {
   for (int iLayer = 0; iLayer < nLayers - 1; ++iLayer) {
-    gpu::computeLayerTrackletsMultiROFKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                                      o2::gpu::CAMath::Min(nThreads, GPU_THREADS),
-                                                      0,
-                                                      streams[iLayer].get()>>>(
+    gpu::computeLayerTrackletsMultiROFKernel<false><<<nBlocks, nThreads, 0, streams[iLayer].get()>>>(
       utils,
       multMask,
       iLayer,
@@ -1013,10 +998,10 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
     nTracklets[iLayer] = unique_end - tracklets_ptr;
     if (iLayer > 0) {
       GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[iLayer], 0, nClusters[iLayer] * sizeof(int), streams[iLayer].get()));
-      gpu::compileTrackletsLookupTableKernel<<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                               o2::gpu::CAMath::Min(nThreads, GPU_THREADS),
-                                               0,
-                                               streams[iLayer].get()>>>(spanTracklets[iLayer], trackletsLUTsHost[iLayer], nTracklets[iLayer]);
+      gpu::compileTrackletsLookupTableKernel<<<nBlocks, nThreads, 0, streams[iLayer].get()>>>(
+        spanTracklets[iLayer],
+        trackletsLUTsHost[iLayer],
+        nTracklets[iLayer]);
       gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get());
     }
   }
@@ -1040,8 +1025,7 @@ void countCellsHandler(
   const int nBlocks,
   const int nThreads)
 {
-  gpu::computeLayerCellsKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                       o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+  gpu::computeLayerCellsKernel<true><<<nBlocks, nThreads>>>(
     sortedClusters,           // const Cluster**
     unsortedClusters,         // const Cluster**
     tfInfo,                   // const TrackingFrameInfo**
@@ -1076,8 +1060,7 @@ void computeCellsHandler(
   const int nBlocks,
   const int nThreads)
 {
-  gpu::computeLayerCellsKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                        o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+  gpu::computeLayerCellsKernel<false><<<nBlocks, nThreads>>>(
     sortedClusters,           // const Cluster**
     unsortedClusters,         // const Cluster**
     tfInfo,                   // const TrackingFrameInfo**
@@ -1107,8 +1090,7 @@ unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                         const int nBlocks,
                                         const int nThreads)
 {
-  gpu::computeLayerCellNeighboursKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                                o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+  gpu::computeLayerCellNeighboursKernel<true><<<nBlocks, nThreads>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1142,8 +1124,7 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   const int nThreads)
 {
 
-  gpu::computeLayerCellNeighboursKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                                 o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+  gpu::computeLayerCellNeighboursKernel<false><<<nBlocks, nThreads>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1198,8 +1179,7 @@ void processNeighboursHandler(const int startLayer,
   thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt); // Shortcut: device_vector skips central memory management, we are relying on the contingency.
                                                                                                              // TODO: fix this.
 
-  gpu::processNeighboursKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                       o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+  gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1221,8 +1201,7 @@ void processNeighboursHandler(const int startLayer,
 
   thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
   thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
-  gpu::processNeighboursKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                        o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+  gpu::processNeighboursKernel<false><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1255,8 +1234,7 @@ void processNeighboursHandler(const int startLayer,
     foundSeedsTable.resize(lastCellSeedSize + 1);
     thrust::fill(foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
-    gpu::processNeighboursKernel<true><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                         o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+    gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(
       iLayer,
       --level,
       allCellSeeds,
@@ -1282,8 +1260,7 @@ void processNeighboursHandler(const int startLayer,
     updatedCellSeed.resize(foundSeeds);
     thrust::fill(updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed());
 
-    gpu::processNeighboursKernel<false><<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                                          o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+    gpu::processNeighboursKernel<false><<<nBlocks, nThreads>>>(
       iLayer,
       level,
       allCellSeeds,
@@ -1326,8 +1303,7 @@ void trackSeedHandler(CellSeed* trackSeeds,
                       const int nThreads)
 {
   thrust::device_vector<float> minPts(minPtsHost);
-  gpu::fitTrackSeedsKernel<<<o2::gpu::CAMath::Min(nBlocks, GPU_BLOCKS),
-                             o2::gpu::CAMath::Min(nThreads, GPU_THREADS)>>>(
+  gpu::fitTrackSeedsKernel<<<nBlocks, nThreads>>>(
     trackSeeds,                           // CellSeed*
     foundTrackingFrameInfo,               // TrackingFrameInfo**
     tracks,                               // TrackITSExt*
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
index cc43b6845a714..e8e475f2232c8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
@@ -12,6 +12,7 @@
 if(HIP_ENABLED)
   message(STATUS "Building ITS HIP tracker")
   set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} -fgpu-rdc")
+  # set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} -O0 -g -ggdb -fno-inline -fno-omit-frame-pointer -D__HIP_ENABLE_DEVICE_ASSERT__")
   o2_add_hipified_library(ITStrackingHIP
                  SOURCES ../cuda/ClusterLinesGPU.cu
                          ../cuda/TimeFrameGPU.cu
@@ -28,4 +29,4 @@ if(HIP_ENABLED)
                                        hip::host
                  PRIVATE_LINK_LIBRARIES O2::GPUTrackingHIPExternalProvider
                  TARGETVARNAME targetName)
-endif()
\ No newline at end of file
+endif()
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 3f0d291d5e51d..5e08e6c48e03a 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -308,7 +308,7 @@ struct TimeFrame {
 
   const o2::base::PropagatorImpl<float>* mPropagatorDevice = nullptr; // Needed only for GPU
 
-  void wipe();
+  virtual void wipe();
 
  private:
   void prepareClusters(const TrackingParameters& trkParam, const int maxLayers = nLayers);
@@ -531,8 +531,8 @@ inline gsl::span<int> TimeFrame<nLayers>::getIndexTable(int rofId, int layer)
   if (rofId < 0 || rofId >= mNrof) {
     return {};
   }
-  return {&mIndexTables[layer][rofId * (mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1)],
-          static_cast<gsl::span<int>::size_type>(mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1)};
+  const int tableSize = mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1;
+  return {&mIndexTables[layer][rofId * tableSize], static_cast<gsl::span<int>::size_type>(tableSize)};
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index bf9cb79169566..f123a2a9a1d80 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -61,7 +61,6 @@ class ITSTrackingInterface
   void initialise();
   void run(framework::ProcessingContext& pc);
   void printSummary() const;
-  void end();
 
   virtual void updateTimeDependentParams(framework::ProcessingContext& pc);
   virtual void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 2e9ce23719f90..a59c51949b9f9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -583,7 +583,6 @@ void TimeFrame<nLayers>::printSliceInfo(const int startROF, const int sliceSize)
 template <int nLayers>
 void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool)
 {
-  wipe();
   mMemoryPool = pool;
 
   auto initVector = [&]<typename T>(bounded_vector<T>& vec) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index ba722c410f95c..938356050262d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -65,7 +65,6 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
          (double)mTimeFrame->getArtefactsMemory() / GB, (double)mTrkParams[iteration].MaxMemory / GB);
     LOGP(error, "Exception: {}", err.what());
     if (mTrkParams[iteration].DropTFUponFailure) {
-      mTimeFrame->wipe();
       mMemoryPool->print();
       ++mNumberOfDroppedTFs;
       error("...Dropping Timeframe...");
@@ -144,17 +143,17 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
     error("Uncaught exception, all bets are off...");
   }
 
-  if (mTrkParams[0].PrintMemory) {
-    mTimeFrame->printArtefactsMemory();
-    mMemoryPool->print();
-  }
-
   if (mTimeFrame->hasMCinformation()) {
     computeTracksMClabels();
   }
   rectifyClusterIndices();
   ++mTimeFrameCounter;
   mTotalTime += total;
+
+  if (mTrkParams[0].PrintMemory) {
+    mTimeFrame->printArtefactsMemory();
+    mMemoryPool->print();
+  }
 }
 
 void Tracker::computeRoadsMClabels()
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 136ebc647cc38..b46e7a68875e6 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -107,9 +107,10 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
 
           for (int iV = startVtx; iV < endVtx; ++iV) {
             const auto& pv = primaryVertices[iV];
-            if (pv.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) {
+            if ((pv.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) || (iteration == 3 && !pv.isFlagSet(Vertex::Flags::UPCMode))) {
               continue;
             }
+
             const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)) + math_utils::Sq(mTrkParams[iteration].PVres) / float(pv.getNContributors()));
             const float tanLambda = (currentCluster.zCoordinate - pv.getZ()) * inverseR0;
             const float zAtRmin = tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 00a69a37cb51a..3b05a7655d68c 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -310,6 +310,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       LOGP(info, "ITSTracker pushed {} vertex purities", allVerticesPurities.size());
     }
   }
+  mTimeFrame->wipe();
 }
 
 void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContext& pc)
@@ -381,11 +382,6 @@ void ITSTrackingInterface::printSummary() const
   mTracker->printSummary();
 }
 
-void ITSTrackingInterface::end()
-{
-  mTimeFrame->wipe();
-}
-
 void ITSTrackingInterface::setTraitsFromProvider(VertexerTraits* vertexerTraits,
                                                  TrackerTraits7* trackerTraits,
                                                  TimeFrame7* frame)
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index c825ec39d3499..be7750964b3e7 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -75,7 +75,6 @@ void TrackerDPL::endOfStream(EndOfStreamContext& ec)
 
 void TrackerDPL::end()
 {
-  mITSTrackingInterface.end();
   mITSTrackingInterface.printSummary();
   LOGF(info, "ITS CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }

From 723aeb36ed3efac043632e8b9c8195d455402513 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 24 Jul 2025 13:34:14 +0200
Subject: [PATCH 0649/1764] ITSMFT: FST opt. rerun clusterizer

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 prodtests/full-system-test/dpl-workflow.sh | 23 ++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 55186dbff9c84..044c382e45070 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -108,9 +108,6 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 
 [[ "0$DISABLE_ROOT_OUTPUT" == "00" ]] && DISABLE_ROOT_OUTPUT=
 
-has_detectors_gpu TPC ITS && GPU_INPUT+=",its-clusters"
-has_detectors_gpu TPC ITS && GPU_OUTPUT+=",its-tracks"
-
 if [[ $CTFINPUT != 1 ]]; then
   GPU_OUTPUT+=",tpc-triggers"
 fi
@@ -421,6 +418,17 @@ if [[ -n ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS} ]] || [[ -n ${WORKFLOW_D
   has_detector TOF && has_detector_from_global_reader TOF && add_W o2-tof-reco-workflow "$DISABLE_MC --input-type digits --output-type NONE $HBFINI_OPTIONS"
 fi
 
+if [[ ${ITSMFT_RECO_RERUN_CLUSTERIZER:-0} == 1 && ${DISABLE_DIGIT_CLUSTER_INPUT:-} =~ "--digits-from-upstream" ]]; then
+  echo "Cannot set both ITSMFT_RECO_RERUN_CLUSTERIZER and DISABLE_DIGIT_CLUSTER_INPUT at the same time"
+  echo "DISABLE_DIGIT_CLUSTER_INPUT will be removed once used in O2DPG"
+  exit 1
+fi
+if [[ ${ITSMFT_RECO_RERUN_CLUSTERIZER:-0} == 1 ]]; then
+  has_detector_reco MFT && ARGS_EXTRA_PROCESS_o2_ctf_reader_workflow+=' --mft-digits '
+  ( has_detector_reco ITS || has_detector_gpu ITS ) && ARGS_EXTRA_PROCESS_o2_ctf_reader_workflow+=' --its-digits '
+  DISABLE_DIGIT_CLUSTER_INPUT="--digits-from-upstream"
+fi
+
 if [[ -n $INPUT_DETECTOR_LIST ]]; then
   if [[ $CTFINPUT == 1 ]]; then
     GPU_INPUT=compressed-clusters-ctf
@@ -490,7 +498,6 @@ if [[ -n $INPUT_DETECTOR_LIST ]]; then
   elif [[ $DIGITINPUT == 1 ]]; then
     [[ $NTIMEFRAMES != 1 ]] && { echo "Digit input works only with NTIMEFRAMES=1" 1>&2; exit 1; }
     DISABLE_DIGIT_ROOT_INPUT=
-    DISABLE_DIGIT_CLUSTER_INPUT=
     TOF_INPUT=digits
     GPU_INPUT=zsonthefly
     has_detector TPC && add_W o2-tpc-reco-workflow "--input-type digits --output-type zsraw,disable-writer $DISABLE_MC --pipeline $(get_N tpc-zsEncoder TPC RAW 1 TPCRAWDEC)"
@@ -543,11 +550,15 @@ if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
   has_detector EMC && ! has_detector_from_global_reader EMC && ! has_detector_flp_processing EMC && add_W o2-emcal-reco-workflow "--input-type raw --output-type cells ${RAW_EMC_SUBSPEC:-} $EMCRAW2C_CONFIG $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N EMCALRawToCellConverterSpec EMC REST 1 EMCREC)"
 fi
 
+has_detector_gpu ITS && GPU_INPUT+=",its-clusters"
+has_detector_gpu ITS && GPU_OUTPUT+=",its-tracks"
+
 # ---------------------------------------------------------------------------------------------------------------------
 # Common reconstruction workflows
+(has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--trackerCA $ITS_CONFIG $DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
+[[ ${DISABLE_DIGIT_CLUSTER_INPUT:-} =~ "--digits-from-upstream" ]]  && has_detector_gpu ITS && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--disable-tracking ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_MC $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
 (has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $TPC_CORR_OPT --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;$TPC_CORR_KEY"
 (has_detector_reco TOF || has_detector_ctf TOF) && ! has_detector_from_global_reader TOF && add_W o2-tof-reco-workflow "$TOF_CONFIG --input-type $TOF_INPUT --output-type $TOF_OUTPUT $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N tof-compressed-decoder TOF RAW 1),$(get_N TOFClusterer TOF REST 1)"
-(has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--trackerCA $ITS_CONFIG $DISABLE_MC $DISABLE_DIGIT_CLUSTER_INPUT $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
 has_detector_reco FT0 && ! has_detector_from_global_reader FT0 && add_W o2-ft0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N ft0-reconstructor FT0 REST 1)"
 has_detector_reco TRD && ! has_detector_from_global_reader TRD && add_W o2-trd-tracklet-transformer "--disable-irframe-reader $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_FILTER_CONFIG --pipeline $(get_N TRDTRACKLETTRANSFORMER TRD REST 1 TRDTRKTRANS)"
 has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $SEND_ITSTPC_DTGL  $TPC_CORR_OPT --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
@@ -559,7 +570,7 @@ has_detectors TPC && [[ -z "$DISABLE_ROOT_OUTPUT" && "${SKIP_TPC_CLUSTERSTRACKS_
 # Reconstruction workflows normally active only in async mode ($LIST_OF_ASYNC_RECO_STEPS), but can be forced via $WORKFLOW_EXTRA_PROCESSING_STEPS
 has_detector MID && ! has_detector_from_global_reader MID && has_processing_step MID_RECO && add_W o2-mid-reco-workflow "$DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N MIDClusterizer MID REST 1),$(get_N MIDTracker MID REST 1)"
 has_detector MCH && ! has_detector_from_global_reader MCH && has_processing_step MCH_RECO && add_W o2-mch-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N mch-track-finder MCH REST 1 MCHTRK),$(get_N mch-cluster-finder MCH REST 1 MCHCL),$(get_N mch-cluster-transformer MCH REST 1)" "$MCH_CONFIG_KEY"
-has_detector MFT && ! has_detector_from_global_reader MFT && has_processing_step MFT_RECO && add_W o2-mft-reco-workflow "$DISABLE_DIGIT_CLUSTER_INPUT $DISABLE_MC $DISABLE_ROOT_OUTPUT $MFT_CONFIG --pipeline $(get_N mft-tracker MFT REST 1 MFTTRK)" "$MFT_CONFIG_KEY;$ITSMFT_STROBES"
+has_detector MFT && ! has_detector_from_global_reader MFT && has_processing_step MFT_RECO && add_W o2-mft-reco-workflow "$DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT $MFT_CONFIG --pipeline $(get_N mft-tracker MFT REST 1 MFTTRK)" "$MFT_CONFIG_KEY;$ITSMFT_STROBES"
 has_detector FDD && ! has_detector_from_global_reader FDD && has_processing_step FDD_RECO && add_W o2-fdd-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC"
 has_detector FV0 && ! has_detector_from_global_reader FV0 && has_processing_step FV0_RECO && add_W o2-fv0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC"
 has_detector ZDC && ! has_detector_from_global_reader ZDC && has_processing_step ZDC_RECO && add_W o2-zdc-digits-reco "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC"

From 84dd75dff552f74be128232ffefda1cb574e85a3 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 26 Jul 2025 10:41:31 +0200
Subject: [PATCH 0650/1764] Fix coding rule violation

---
 Framework/Core/src/StepTHn.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/StepTHn.cxx b/Framework/Core/src/StepTHn.cxx
index 4b2e81f02e1a2..bb0109db2c97f 100644
--- a/Framework/Core/src/StepTHn.cxx
+++ b/Framework/Core/src/StepTHn.cxx
@@ -327,8 +327,9 @@ void StepTHn::createTarget(Int_t step, Bool_t sparse)
   }
 
   THnBase* target = mTarget[step];
-  if (mSumw2[step])
+  if (mSumw2[step]) {
     target->Sumw2();
+  }
 
   Int_t* binIdx = new Int_t[mNVars];
   Int_t* nBins = new Int_t[mNVars];

From 6f47846208dc46772280cc26449a20703b9f720c Mon Sep 17 00:00:00 2001
From: Francesco Mazzaschi <43742195+fmazzasc@users.noreply.github.com>
Date: Mon, 28 Jul 2025 09:56:00 +0200
Subject: [PATCH 0651/1764] Add Lambda1405 to TDatabasePdg and O2MCApplication
 (#14506)

* Add Lambda1405 to TDatabasePdg and O2MCApplication

* Please consider the following formatting changes

---------

Co-authored-by: Francesco Mazzaschi <fmazzasc@alipap1.cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../SimulationDataFormat/O2DatabasePDG.h      |  9 ++++
 Steer/src/O2MCApplication.cxx                 | 41 +++++++++++++++++++
 2 files changed, 50 insertions(+)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h b/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
index ec8e6db889167..23dc30119aa7a 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
@@ -470,6 +470,15 @@ inline void O2DatabasePDG::addALICEParticles(TDatabasePDG* db)
                     0.185, 0, "Resonance", ionCode);
   }
 
+  // Lambda(1405)0
+  ionCode = 102132;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("Lambda_1405_0", "Lambda_1405_0", 1.405, kFALSE, 0.05, 0, "Resonance", ionCode);
+  }
+  if (!db->GetParticle(-ionCode)) {
+    db->AddParticle("AntiLambda_1405_0", "AntiLambda_1405_0", 1.405, kFALSE, 0.05, 0, "Resonance", -ionCode);
+  }
+
   // Lambda(1520)0
   ionCode = 102134;
   if (!db->GetParticle(ionCode)) {
diff --git a/Steer/src/O2MCApplication.cxx b/Steer/src/O2MCApplication.cxx
index e44758241b8d2..77b49ec9e2906 100644
--- a/Steer/src/O2MCApplication.cxx
+++ b/Steer/src/O2MCApplication.cxx
@@ -383,6 +383,10 @@ void addSpecialParticles()
   // f1(1420) (PDG: width = 54 MeV) Spin/Parity might not be correct
   TVirtualMC::GetMC()->DefineParticle(20333, "f1_1420", kPTNeutron, 1.42640, 0.0, 1e-24, "Hadron", 0.05490, 3, 1, 0, 0, 0, 0, 0, 1, kTRUE);
 
+  // lambda1405 (PDG: width = 50 MeV)
+  TVirtualMC::GetMC()->DefineParticle(102132, "Lambda1405", kPTNeutron, 1.405, 0.0, 1.316e-23, "Hadron", 0.050, 0, 1, 0, 0, 0, 0, 0, 2, kTRUE);
+  TVirtualMC::GetMC()->DefineParticle(-102132, "AntiLambda1405", kPTNeutron, 1.405, 0.0, 1.316e-23, "Hadron", 0.050, 0, 1, 0, 0, 0, 0, 0, 2, kTRUE);
+
   // Glueball hunting family
   // Their life times are not known, so we set them to 1e-24
   // f0(1370) (PDG: width = 200-500 MeV) Spin/Parity might not be correct
@@ -1380,6 +1384,43 @@ void addSpecialParticles()
   TVirtualMC::GetMC()->SetDecayMode(20223, bratio2, mode); // f1(1285)
   TVirtualMC::GetMC()->SetDecayMode(20333, bratio2, mode); // f1(1420)
 
+  // Define the decay modes for the Lambda(1405)
+  for (Int_t kz = 0; kz < 6; kz++) {
+    bratio[kz] = 0.;
+    mode[kz][0] = 0;
+    mode[kz][1] = 0;
+    mode[kz][2] = 0;
+  }
+  // 33.3 % sigma-pi+, sigma+pi-, sigma0pi0
+  bratio[0] = 33.3;
+  mode[0][0] = 3112; // Sigma-
+  mode[0][1] = 211;  // negative pion
+  bratio[1] = 33.3;
+  mode[1][0] = 3222; // Sigma+
+  mode[1][1] = -211; // positive pion
+  bratio[2] = 33.3;
+  mode[2][0] = 3212;                                       // Sigma0
+  mode[2][1] = 111;                                        // neutral pion
+  TVirtualMC::GetMC()->SetDecayMode(102132, bratio, mode); // Lambda(1405)
+  // Define the decay modes for the Anti-Lambda(1405)
+  for (Int_t kz = 0; kz < 6; kz++) {
+    abratio[kz] = 0.;
+    amode[kz][0] = 0;
+    amode[kz][1] = 0;
+    amode[kz][2] = 0;
+  }
+  // 33.3 % sigma-pi-, sigma-pi+, sigma0pi0
+  abratio[0] = 33.3;
+  amode[0][0] = -3112; // AntiSigma-
+  amode[0][1] = -211;  // positive pion
+  abratio[1] = 33.3;
+  amode[1][0] = -3222; // AntiSigma+
+  amode[1][1] = 211;   // negative pion
+  abratio[2] = 33.3;
+  amode[2][0] = -3212;                                        // Sigma0
+  amode[2][1] = 111;                                          // negative pion
+  TVirtualMC::GetMC()->SetDecayMode(-102132, abratio, amode); // Anti-Lambda(1405)
+
   // Lambda1520/Lambda1520bar
 
   TVirtualMC::GetMC()->DefineParticle(102134, "Lambda1520", kPTNeutron, 1.5195, 0.0, 4.22e-23, "Hadron", 0.0156, 3, -1, 0, 0, 0, 0, 0, 1, kTRUE);

From 69f673745dc009e30b4143b774d81c45b791a2af Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Mon, 28 Jul 2025 16:01:55 +0200
Subject: [PATCH 0652/1764] NN clusterizer: Bug-fixes and adding deterministic
 mode (#14530)

* Adding first version of kernel timers

* Removing GPU_CONFIG_KEY from dpl-workflow.sh to set my own values

* Bug fixes

* undoing changes in dpl-workflow.sh

* Furhter fixes and beautifications

* Please consider the following formatting changes

* Removing unused timers

* Moving Stop() of classification timer

* Adding force method to fill input like it is done on GPU

* Removing unnecessary static asserts

* Adding deterministic mode (unfortunately that did not make it deterministic on GPU -> general problem with ONNX)

* Please consider the following formatting changes

* Adjusting for comment

* Adding deterministic mode

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Common/ML/include/ML/OrtInterface.h           |  2 +-
 Common/ML/src/OrtInterface.cxx                |  5 ++
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  3 ++
 .../Global/GPUChainTrackingClusterizer.cxx    | 53 ++++++++++++++-----
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |  1 +
 .../GPUTPCNNClusterizerHost.cxx               |  4 +-
 .../GPUTPCNNClusterizerHost.h                 |  4 +-
 .../GPUTPCNNClusterizerKernels.cxx            | 26 ++++-----
 .../GPUTPCNNClusterizerKernels.h              |  6 ---
 9 files changed, 65 insertions(+), 39 deletions(-)

diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index 0c498e33d2e2c..04a5e0ba5c9fc 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -116,7 +116,7 @@ class OrtModel
   int32_t mInputsTotal = 0, mOutputsTotal = 0;                                                        // Total number of inputs and outputs
 
   // Environment settings
-  bool mInitialized = false;
+  bool mInitialized = false, mDeterministicMode = false;
   std::string mModelPath, mEnvName = "", mDeviceType = "CPU", mThreadAffinity = ""; // device options should be cpu, rocm, migraphx, cuda
   int32_t mIntraOpNumThreads = 1, mInterOpNumThreads = 1, mDeviceId = -1, mEnableProfiling = 0, mLoggingLevel = 0, mAllocateDeviceMemory = 0, mEnableOptimizations = 0;
 
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index 1cd9913efb6aa..58d80eb9c0bf0 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -68,6 +68,7 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
     mEnableProfiling = (optionsMap.contains("enable-profiling") ? std::stoi(optionsMap["enable-profiling"]) : 0);
     mEnableOptimizations = (optionsMap.contains("enable-optimizations") ? std::stoi(optionsMap["enable-optimizations"]) : 0);
     mEnvName = (optionsMap.contains("onnx-environment-name") ? optionsMap["onnx-environment-name"] : "onnx_model_inference");
+    mDeterministicMode = (optionsMap.contains("deterministic-compute") ? std::stoi(optionsMap["deterministic-compute"]) : 0);
 
     if (mDeviceType == "CPU") {
       (mPImplOrt->sessionOptions).SetIntraOpNumThreads(mIntraOpNumThreads);
@@ -99,6 +100,10 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
       (mPImplOrt->sessionOptions).DisableProfiling();
     }
 
+    if (mDeterministicMode > 0) {
+      (mPImplOrt->sessionOptions).AddConfigEntry("session_options.use_deterministic_compute", "1");
+    }
+
     (mPImplOrt->sessionOptions).SetGraphOptimizationLevel(GraphOptimizationLevel(mEnableOptimizations));
     (mPImplOrt->sessionOptions).SetLogSeverityLevel(OrtLoggingLevel(mLoggingLevel));
 
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 51a0add7dbeea..65697b7f7c08b 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -256,6 +256,7 @@ AddOption(nnInferenceOutputDType, std::string, "FP32", "", 0, "(std::string) Spe
 AddOption(nnInferenceIntraOpNumThreads, int, 1, "", 0, "Number of threads used to evaluate one neural network (ONNX: SetIntraOpNumThreads). 0 = auto-detect, can lead to problems on SLURM systems.")
 AddOption(nnInferenceInterOpNumThreads, int, 1, "", 0, "Number of threads used to evaluate one neural network (ONNX: SetInterOpNumThreads). 0 = auto-detect, can lead to problems on SLURM systems.")
 AddOption(nnInferenceEnableOrtOptimization, unsigned int, 99, "", 0, "Enables graph optimizations in ONNX Runtime. Can be [0, 1, 2, 99] -> see https://github.com/microsoft/onnxruntime/blob/3f71d637a83dc3540753a8bb06740f67e926dc13/include/onnxruntime/core/session/onnxruntime_c_api.h#L347")
+AddOption(nnInferenceUseDeterministicCompute, int, 0, "", 0, "Enables deterministic compute in ONNX Runtime were possible. Can be [0, 1] -> see https://github.com/microsoft/onnxruntime/blob/3b97d79b3c12dbf93aa0d563f345714596dc8ab6/onnxruntime/core/framework/session_options.h#L208")
 AddOption(nnInferenceOrtProfiling, int, 0, "", 0, "Enables profiling of model execution in ONNX Runtime")
 AddOption(nnInferenceOrtProfilingPath, std::string, ".", "", 0, "If nnInferenceOrtProfiling is set, the path to store the profiling data")
 AddOption(nnInferenceVerbosity, int, 1, "", 0, "0: No messages; 1: Warnings; 2: Warnings + major debugs; >3: All debugs")
@@ -275,6 +276,8 @@ AddOption(nnClassThreshold, float, 0.5, "", 0, "The cutoff at which clusters wil
 AddOption(nnRegressionPath, std::string, "network_reg.onnx", "", 0, "The regression network path")
 AddOption(nnSigmoidTrafoClassThreshold, int, 1, "", 0, "If true (default), then the classification threshold is transformed by an inverse sigmoid function. This depends on how the network was trained (with a sigmoid as acitvation function in the last layer or not).")
 AddOption(nnEvalMode, std::string, "c1:r1", "", 0, "Concatention of modes, e.g. c1:r1 (classification class 1, regression class 1)")
+AddOption(nnClusterizerUseClassification, int, 1, "", 0, "If 1, the classification output of the network is used to select clusters, else only the regression output is used and no clusters are rejected by classification")
+AddOption(nnClusterizerForceGpuInputFill, int, 0, "", 0, "Forces to use the fillInputNNGPU function")
 // CCDB
 AddOption(nnLoadFromCCDB, int, 0, "", 0, "If 1 networks are fetched from ccdb, else locally")
 AddOption(nnLocalFolder, std::string, ".", "", 0, "Local folder in which the networks will be fetched")
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 13455efe6cb47..07b332db1fc12 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -641,13 +641,30 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   const GPUSettingsProcessingNNclusterizer& nn_settings = GetProcessingSettings().nn;
   GPUTPCNNClusterizerHost nnApplications[GetProcessingSettings().nTPCClustererLanes];
 
+  // Maximum of 4 lanes supported
+  HighResTimer* nnTimers[12];
+  if (GetProcessingSettings().nn.applyNNclusterizer && GetProcessingSettings().debugLevel >= 1) {
+    nnTimers[0] = &getTimer<GPUTPCNNClusterizer, 0>("GPUTPCNNClusterizer_ONNXClassification_0_", 0);
+    nnTimers[1] = &getTimer<GPUTPCNNClusterizer, 1>("GPUTPCNNClusterizer_ONNXRegression_1_", 1);
+    nnTimers[2] = &getTimer<GPUTPCNNClusterizer, 2>("GPUTPCNNClusterizer_ONNXRegression2_2_", 2);
+    nnTimers[3] = &getTimer<GPUTPCNNClusterizer, 3>("GPUTPCNNClusterizer_ONNXClassification_0_", 3);
+    nnTimers[4] = &getTimer<GPUTPCNNClusterizer, 4>("GPUTPCNNClusterizer_ONNXRegression_1_", 4);
+    nnTimers[5] = &getTimer<GPUTPCNNClusterizer, 5>("GPUTPCNNClusterizer_ONNXRegression2_2_", 5);
+    nnTimers[6] = &getTimer<GPUTPCNNClusterizer, 6>("GPUTPCNNClusterizer_ONNXClassification_0_", 6);
+    nnTimers[7] = &getTimer<GPUTPCNNClusterizer, 7>("GPUTPCNNClusterizer_ONNXRegression_1_", 7);
+    nnTimers[8] = &getTimer<GPUTPCNNClusterizer, 8>("GPUTPCNNClusterizer_ONNXRegression2_2_", 8);
+    nnTimers[9] = &getTimer<GPUTPCNNClusterizer, 9>("GPUTPCNNClusterizer_ONNXClassification_0_", 9);
+    nnTimers[10] = &getTimer<GPUTPCNNClusterizer, 10>("GPUTPCNNClusterizer_ONNXRegression_1_", 10);
+    nnTimers[11] = &getTimer<GPUTPCNNClusterizer, 11>("GPUTPCNNClusterizer_ONNXRegression2_2_", 11);
+  }
+
   if (GetProcessingSettings().nn.applyNNclusterizer) {
     int32_t deviceId = -1;
     int32_t numLanes = GetProcessingSettings().nTPCClustererLanes;
     int32_t maxThreads = mRec->getNKernelHostThreads(true);
     // bool recreateMemoryAllocator = false;
     mRec->runParallelOuterLoop(doGPU, numLanes, [&](uint32_t lane) {
-      nnApplications[lane].init(nn_settings);
+      nnApplications[lane].init(nn_settings, GetProcessingSettings().deterministicGPUReconstruction);
       if (nnApplications[lane].mModelsUsed[0]) {
         SetONNXGPUStream(*(nnApplications[lane].mModelClass).getSessionOptions(), lane, &deviceId);
         (nnApplications[lane].mModelClass).setDeviceId(deviceId);
@@ -993,9 +1010,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             size_t iSize = CAMath::Min((uint)clustererNNShadow.mNnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
 
             // Filling the data
-            if (mRec->IsGPU()) {
+            if (mRec->IsGPU() || GetProcessingSettings().nn.nnClusterizerForceGpuInputFill) {
               // Fills element by element of each input matrix -> better parallelizability, but worse on CPU due to unnecessary computations
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNGPU>({GetGrid(iSize * clustererNNShadow.mNnClusterizerElementSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNGPU>({GetGrid(iSize * clustererNNShadow.mNnClusterizerRowTimeSizeFull, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
             } else {
               // Fills the whole input matrix at once -> better performance on CPU, but worse parallelizability
               runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNCPU>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
@@ -1006,20 +1023,25 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             }
 
             // NN evaluations
-            if (clustererNNShadow.mNnInferenceInputDType == 0) {
-              if (clustererNNShadow.mNnInferenceOutputDType == 0) {
-                (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mModelProbabilities_16);
-              } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
-                (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mModelProbabilities_32);
-              }
-            } else if (clustererNNShadow.mNnInferenceInputDType == 1) {
-              if (clustererNNShadow.mNnInferenceOutputDType == 0) {
-                (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mModelProbabilities_16);
-              } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
-                (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mModelProbabilities_32);
+            if(clustererNNShadow.mNnClusterizerUseClassification) {
+              if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane]->Start(); }
+              if (clustererNNShadow.mNnInferenceInputDType == 0) {
+                if (clustererNNShadow.mNnInferenceOutputDType == 0) {
+                  (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mModelProbabilities_16);
+                } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
+                  (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mModelProbabilities_32);
+                }
+              } else if (clustererNNShadow.mNnInferenceInputDType == 1) {
+                if (clustererNNShadow.mNnInferenceOutputDType == 0) {
+                  (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mModelProbabilities_16);
+                } else if (clustererNNShadow.mNnInferenceOutputDType == 1) {
+                  (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mModelProbabilities_32);
+                }
               }
+              if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane]->Stop(); }
             }
             if (!clustererNNShadow.mNnClusterizerUseCfRegression) {
+              if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 1]->Start(); }
               if (clustererNNShadow.mNnInferenceInputDType == 0) {
                 if (clustererNNShadow.mNnInferenceOutputDType == 0) {
                   (nnApplication.mModelReg1).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mOutputDataReg1_16);
@@ -1033,7 +1055,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                   (nnApplication.mModelReg1).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mOutputDataReg1_32);
                 }
               }
+              if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 1]->Stop(); }
               if (nnApplication.mModelClass.getNumOutputNodes()[0][1] > 1 && nnApplication.mModelReg2.isInitialized()) {
+                if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 2]->Start(); }
                 if (clustererNNShadow.mNnInferenceInputDType == 0) {
                   if (clustererNNShadow.mNnInferenceOutputDType == 0) {
                     (nnApplication.mModelReg2).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mOutputDataReg2_16);
@@ -1047,6 +1071,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                     (nnApplication.mModelReg2).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mOutputDataReg2_32);
                   }
                 }
+                if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 2]->Stop(); }
               }
             }
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index 7c22d8123fdec..69972c8a0651c 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -43,6 +43,7 @@ class GPUTPCNNClusterizer : public GPUProcessor
   int32_t mNnClusterizerChargeArraySize = -1;
   int32_t mNnClusterizerElementSize = -1;
   int8_t mNnClusterizerAddIndexData = 1;
+  int8_t mNnClusterizerUseClassification = 1;
   float mNnClassThreshold = 0.01;
   int8_t mNnSigmoidTrafoClassThreshold = 1;
   int8_t mNnClusterizerSetDeconvolutionFlags = 1;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index fd56d49de7921..ad635c15b9256 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -28,7 +28,7 @@
 
 using namespace o2::gpu;
 
-void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& settings)
+void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& settings, bool useDeterministicMode)
 {
   std::string class_model_path = settings.nnClassificationPath, reg_model_path = settings.nnRegressionPath;
   std::vector<std::string> reg_model_paths_local;
@@ -54,6 +54,7 @@ void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& set
     {"intra-op-num-threads", std::to_string(settings.nnInferenceIntraOpNumThreads)},
     {"inter-op-num-threads", std::to_string(settings.nnInferenceInterOpNumThreads)},
     {"enable-optimizations", std::to_string(settings.nnInferenceEnableOrtOptimization)},
+    {"deterministic-compute", std::to_string(useDeterministicMode ? 1 : settings.nnInferenceUseDeterministicCompute)}, // TODO: This unfortunately doesn't guarantee determinism (25.07.2025)
     {"enable-profiling", std::to_string(settings.nnInferenceOrtProfiling)},
     {"profiling-output-path", settings.nnInferenceOrtProfilingPath},
     {"logging-level", std::to_string(settings.nnInferenceVerbosity)},
@@ -106,6 +107,7 @@ void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclust
   clustererNN.mNnClusterizerBatchedMode = settings.nnClusterizerBatchedMode;
   clustererNN.mNnClusterizerBoundaryFillValue = settings.nnClusterizerBoundaryFillValue;
   clustererNN.mNnSigmoidTrafoClassThreshold = settings.nnSigmoidTrafoClassThreshold;
+  clustererNN.mNnClusterizerUseClassification = settings.nnClusterizerUseClassification;
   clustererNN.mNnClusterizerSetDeconvolutionFlags = (bool)settings.nnClusterizerSetDeconvolutionFlags;
   if (clustererNN.mNnSigmoidTrafoClassThreshold) {
     clustererNN.mNnClassThreshold = (float)std::log(settings.nnClassThreshold / (1.f - settings.nnClassThreshold));
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
index ed3c80320b632..414c4539a33c1 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
@@ -45,9 +45,9 @@ class GPUTPCNNClusterizerHost
 {
  public:
   GPUTPCNNClusterizerHost() = default;
-  GPUTPCNNClusterizerHost(const GPUSettingsProcessingNNclusterizer& settings) { init(settings); }
+  GPUTPCNNClusterizerHost(const GPUSettingsProcessingNNclusterizer& settings, bool useDeterministicMode = false) { init(settings, useDeterministicMode); }
 
-  void init(const GPUSettingsProcessingNNclusterizer&);
+  void init(const GPUSettingsProcessingNNclusterizer&, bool = false);
   void initClusterizer(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&);
   void createBoundary(GPUTPCNNClusterizer&);
   void createIndexLookup(GPUTPCNNClusterizer&);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 4cd0c094398df..dd33a72f79389 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -117,18 +117,14 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   }
 
   if (clustererNN.mNnClusterizerAddIndexData) {
-    float sector_norm = sector / 36.f;
-    float row_norm = row / 152.f;
-    float pad_norm = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
-
     if (dtype == 0) {
-      clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)sector_norm;
-      clustererNN.mInputData_16[write_idx + 1] = (OrtDataType::Float16_t)row_norm;
-      clustererNN.mInputData_16[write_idx + 2] = (OrtDataType::Float16_t)pad_norm;
+      clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(sector) / o2::tpc::constants::MAXSECTOR);
+      clustererNN.mInputData_16[write_idx + 1] = (OrtDataType::Float16_t)(static_cast<float>(row) / o2::tpc::constants::MAXGLOBALPADROW);
+      clustererNN.mInputData_16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
     } else {
-      clustererNN.mInputData_32[write_idx] = sector_norm;
-      clustererNN.mInputData_32[write_idx + 1] = row_norm;
-      clustererNN.mInputData_32[write_idx + 2] = pad_norm;
+      clustererNN.mInputData_32[write_idx] = static_cast<float>(sector) / o2::tpc::constants::MAXSECTOR;
+      clustererNN.mInputData_32[write_idx + 1] = static_cast<float>(row) / o2::tpc::constants::MAXGLOBALPADROW;
+      clustererNN.mInputData_32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
     }
   }
 
@@ -178,8 +174,8 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
     uint32_t write_idx = base_idx * clustererNN.mNnClusterizerElementSize + clustererNN.mNnClusterizerChargeArraySize + data_idx;
 
     float index_values[3] = {
-      sector / 36.f,
-      row / 152.f,
+      static_cast<float>(sector) / o2::tpc::constants::MAXSECTOR,
+      static_cast<float>(row) / o2::tpc::constants::MAXGLOBALPADROW,
       static_cast<float>(pad) / GPUTPCGeometry::NPads(row)};
 
     if (dtype == 0) {
@@ -335,11 +331,11 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
     return;
   }
 
-  tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
+  tpc::ClusterNative* clusterOut = clusterer.mPclusterByRow;
 
   // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.mNnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
 
-  if (clustererNN.mOutputDataClass[full_glo_idx] == 1 || (clustererNN.mNnClusterizerModelReg2NumOutputNodes != -1 && clustererNN.mOutputDataClass[full_glo_idx] >= 1)) {
+  if (clustererNN.mOutputDataClass[full_glo_idx] == 1 || (clustererNN.mNnClusterizerUseClassification <= 0)) {
 
     ClusterAccumulator pc;
 
@@ -451,7 +447,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
   uint32_t model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg2NumOutputNodes;
 
-  if (clustererNN.mOutputDataClass[full_glo_idx] > 0) {
+  if ((clustererNN.mOutputDataClass[full_glo_idx] > 0) || (clustererNN.mNnClusterizerUseClassification <= 0)) {
 
     ClusterAccumulator pc;
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index 5659c61894c85..7469754594124 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -38,12 +38,6 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
 {
  public:
   // Must all have same number of threads, since they use a common SCRATCH_PAD_WORK_GROUP_SIZE below
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNCPU) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNGPU) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
-  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression) == GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer));
   static constexpr size_t SCRATCH_PAD_WORK_GROUP_SIZE = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer);
   struct GPUSharedMemory {
     // Regular cluster finder

From 99071164afd16c430b42aba76a2f5a4d8f149455 Mon Sep 17 00:00:00 2001
From: ddobrigk <david.dobrigkeit.chinellato@cern.ch>
Date: Tue, 29 Jul 2025 11:35:02 +0200
Subject: [PATCH 0653/1764] Make max Xiu for pre-propagation settable (#14544)

* Change name of prepropagation config variable

* Makes max xiu to be propagated settable from command line
---
 .../AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h | 2 +-
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx                 | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 1e3a4cf970d3b..62b99e98f990d 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -246,7 +246,7 @@ class AODProducerWorkflowDPL : public Task
   std::mt19937 mGenerator{}; ///< random generator for trackQA sampling
   o2::base::Propagator::MatCorrType mMatCorr{o2::base::Propagator::MatCorrType::USEMatCorrLUT};
   o2::dataformats::MeanVertexObject mVtx;
-  float mMinPropR{o2::constants::geom::XTPCInnerRef + 0.1f};
+  float mMaxPropXiu{5.0f}; // max X_IU for which track is to be propagated if mPropTracks is true. (other option: o2::constants::geom::XTPCInnerRef + 0.1f)
 
   std::unordered_set<GIndex> mGIDUsedBySVtx;
   std::unordered_set<GIndex> mGIDUsedByStr;
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 7d9b6c7902360..8247eb3d870c0 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -540,7 +540,7 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
           }
           const auto& trOrig = data.getTrackParam(trackIndex);
           bool isProp = false;
-          if (mPropTracks && trOrig.getX() < mMinPropR &&
+          if (mPropTracks && trOrig.getX() < mMaxPropXiu &&
               mGIDUsedBySVtx.find(trackIndex) == mGIDUsedBySVtx.end() &&
               mGIDUsedByStr.find(trackIndex) == mGIDUsedByStr.end()) { // Do not propagate track assoc. to V0s and str. tracking
             auto trackPar(trOrig);
@@ -1688,6 +1688,7 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
   mEMCselectLeading = ic.options().get<bool>("emc-select-leading");
   mThinTracks = ic.options().get<bool>("thin-tracks");
   mPropTracks = ic.options().get<bool>("propagate-tracks");
+  mMaxPropXiu = ic.options().get<float>("propagate-tracks-max-xiu");
   mPropMuons = ic.options().get<bool>("propagate-muons");
   if (auto s = ic.options().get<std::string>("with-streamers"); !s.empty()) {
     mStreamerFlags.set(s);
@@ -3299,6 +3300,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"ctpreadout-create", VariantType::Int, 0, {"Create CTP digits from detector readout and CTP inputs. !=1 -- off, 1 -- on"}},
       ConfigParamSpec{"emc-select-leading", VariantType::Bool, false, {"Flag to select if only the leading contributing particle for an EMCal cell should be stored"}},
       ConfigParamSpec{"propagate-tracks", VariantType::Bool, false, {"Propagate tracks (not used for secondary vertices) to IP"}},
+      ConfigParamSpec{"propagate-tracks-max-xiu", VariantType::Float, 5.0f, {"Propagate tracks to IP if X_IU smaller than this value (and if propagate tracks enabled)"}},
       ConfigParamSpec{"hepmc-update", VariantType::String, "always", {"When to update HepMC Aux tables: always - force update, never - never update, all - if all keys are present, any - when any key is present (not valid yet)"}},
       ConfigParamSpec{"propagate-muons", VariantType::Bool, false, {"Propagate muons to IP"}},
       ConfigParamSpec{"thin-tracks", VariantType::Bool, false, {"Produce thinned track tables"}},

From 0975a957c93bf14147c03fe622f3e548cfeb8744 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 29 Jul 2025 13:06:27 +0200
Subject: [PATCH 0654/1764] DataFormats: Add V0Type (#14547)

* DataFormats: Add V0Type

* Update DecayNBodyIndex.h
---
 .../ReconstructionDataFormats/DecayNBodyIndex.h | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/DecayNBodyIndex.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/DecayNBodyIndex.h
index 31a4b8ebc44b3..5a5a8a9e64cca 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/DecayNBodyIndex.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/DecayNBodyIndex.h
@@ -55,14 +55,19 @@ class DecayNBodyIndex
 class V0Index : public DecayNBodyIndex<2>
 {
  public:
+  enum V0Type : uint8_t {
+    kStandaloneV0 = 0,
+    kPhotonOnly,
+    kCollinear,
+  };
   using DecayNBodyIndex<2>::DecayNBodyIndex;
   V0Index(int v, GIndex p, GIndex n) : DecayNBodyIndex<2>(v, {p, n}) {}
-  bool isStandaloneV0() const { return testBit(0); }
-  bool isPhotonOnly() const { return testBit(1); }
-  bool isCollinear() const { return testBit(2); }
-  void setStandaloneV0() { setBit(0); }
-  void setPhotonOnly() { setBit(1); }
-  void setCollinear() { setBit(2); }
+  bool isStandaloneV0() const { return testBit(kStandaloneV0); }
+  bool isPhotonOnly() const { return testBit(kPhotonOnly); }
+  bool isCollinear() const { return testBit(kCollinear); }
+  void setStandaloneV0() { setBit(kStandaloneV0); }
+  void setPhotonOnly() { setBit(kPhotonOnly); }
+  void setCollinear() { setBit(kCollinear); }
   ClassDefNV(V0Index, 1);
 };
 

From 30e53d06741031c33016419c9a5dd66bfc238d6f Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 18 Jul 2025 17:30:33 +0200
Subject: [PATCH 0655/1764] Account for TPC clusters non-monotonous sorting

---
 .../GlobalTrackingStudy/TrackMCStudyTypes.h   | 18 +++++-
 .../study/src/TrackMCStudy.cxx                | 30 ++++++---
 .../study/src/TrackMCStudyTypes.cxx           | 62 +++++++++++++++++++
 .../study/src/TrackingStudy.cxx               | 18 +++---
 4 files changed, 111 insertions(+), 17 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
index 47fed477f98bd..66ae23d91eaaa 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
@@ -69,6 +69,10 @@ struct MCTrackInfo {
   void setBit(int bit) { flags |= BitMask & (0x1 << bit); }
   void resetBit(int bit) { flags &= ~(BitMask & (0x1 << bit)); }
 
+  o2::track::TrackPar getTrackParTPC(float b, float x = 90) const;
+  float getTrackParTPCPar(int i, float b, float x = 90) const;
+  float getTrackParTPCPhiSec(float b, float x = 90) const;
+
   ClassDefNV(MCTrackInfo, 7);
 };
 
@@ -80,6 +84,7 @@ struct RecTrack {
     FakeTOF = 0x1 << 3,
     FakeITSTPC = 0x1 << 4,
     FakeITSTPCTRD = 0x1 << 5,
+    HASACSides = 0x1 << 6,
     FakeGLO = 0x1 << 7
   };
   o2::track::TrackParCov track{};
@@ -87,12 +92,15 @@ struct RecTrack {
   o2::dataformats::TimeStampWithError<float, float> ts{};
   o2::MCEventLabel pvLabel{};
   short pvID = -1;
+  uint8_t nClTPCShared = 0;
   uint8_t flags = 0;
   uint8_t nClITS = 0;
   uint8_t nClTPC = 0;
   uint8_t pattITS = 0;
   int8_t lowestPadRow = -1;
   int8_t padFromEdge = -1;
+  uint8_t rowMaxTPC = 0;
+  uint8_t rowCountTPC = 0;
 
   bool isFakeGLO() const { return flags & FakeGLO; }
   bool isFakeITS() const { return flags & FakeITS; }
@@ -100,8 +108,9 @@ struct RecTrack {
   bool isFakeTRD() const { return flags & FakeTRD; }
   bool isFakeTOF() const { return flags & FakeTOF; }
   bool isFakeITSTPC() const { return flags & FakeITSTPC; }
+  bool hasACSides() const { return flags & HASACSides; }
 
-  ClassDefNV(RecTrack, 2);
+  ClassDefNV(RecTrack, 3);
 };
 
 struct TrackPairInfo {
@@ -151,6 +160,13 @@ struct TrackFamily { // set of tracks related to the same MC label
   const RecTrack& getTrackWithTPC() const { return entTPC < 0 ? dummyRecTrack : recTracks[entTPC]; }
   const RecTrack& getTrackWithITSTPC() const { return entITSTPC < 0 ? dummyRecTrack : recTracks[entITSTPC]; }
   const RecTrack& getTrackWithITSFound() const { return entITSFound < 0 ? dummyRecTrack : recTracks[entITSFound]; }
+  const RecTrack& getLongestTPCTrack() const
+  {
+    int n = getLongestTPCTrackEntry();
+    return n < 0 ? dummyRecTrack : recTracks[n];
+  }
+  int getLongestTPCTrackEntry() const;
+  int getNTPCClones() const;
   static RecTrack dummyRecTrack; //
 
   ClassDefNV(TrackFamily, 1);
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index fa8cadf3a115c..9f4b79ab47b72 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -280,20 +280,33 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
     return patt;
   };
 
-  auto getLowestPadrow = [&recoData](const o2::tpc::TrackTPC& trc, RecTrack& tref) {
+  auto fillTPCClusterInfo = [&recoData](const o2::tpc::TrackTPC& trc, RecTrack& tref) {
     if (recoData.inputsTPCclusters) {
-      uint8_t clSect = 0, clRow = 0;
+      uint8_t clSect = 0, clRow = 0, lowestR = -1;
       uint32_t clIdx = 0;
       const auto clRefs = recoData.getTPCTracksClusterRefs();
       const auto tpcClusAcc = recoData.getTPCClusters();
-      trc.getClusterReference(clRefs, trc.getNClusterReferences() - 1, clSect, clRow, clIdx);
+      const auto shMap = recoData.clusterShMapTPC;
+      for (int ic = 0; ic < trc.getNClusterReferences(); ic++) { // outside -> inside ordering, but on the sector boundaries backward jumps are possible
+        trc.getClusterReference(clRefs, ic, clSect, clRow, clIdx);
+        if (clRow < lowestR) {
+          tref.rowCountTPC++;
+          lowestR = clRow;
+        }
+        unsigned int absoluteIndex = tpcClusAcc.clusterOffset[clSect][clRow] + clIdx;
+        if (shMap[absoluteIndex] & o2::gpu::GPUTPCGMMergedTrackHit::flagShared) {
+          tref.nClTPCShared++;
+        }
+      }
+      tref.lowestPadRow = lowestR;
       const auto& clus = tpcClusAcc.clusters[clSect][clRow][clIdx];
       int padFromEdge = int(clus.getPad()), npads = o2::gpu::GPUTPCGeometry::NPads(clRow);
       if (padFromEdge > npads / 2) {
         padFromEdge = npads - 1 - padFromEdge;
       }
       tref.padFromEdge = uint8_t(padFromEdge);
-      tref.lowestPadRow = clRow;
+      trc.getClusterReference(clRefs, 0, clSect, clRow, clIdx);
+      tref.rowMaxTPC = clRow;
     }
   };
 
@@ -557,7 +570,10 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
         if (msk[DetID::TPC]) {
           const auto& trtpc = recoData.getTPCTrack(gidSet[GTrackID::TPC]);
           tref.nClTPC = trtpc.getNClusters();
-          getLowestPadrow(trtpc, tref);
+          if (trtpc.hasBothSidesClusters()) {
+            tref.flags |= RecTrack::HASACSides;
+          }
+          fillTPCClusterInfo(trtpc, tref);
           flagTPCClusters(trtpc, entry.first);
           if (trackFam.entTPC < 0) {
             trackFam.entTPC = tcnt;
@@ -748,8 +764,8 @@ void TrackMCStudy::fillMCClusterInfo(const o2::globaltracking::RecoContainer& re
   const auto& params = o2::trackstudy::TrackMCStudyConfig::Instance();
 
   ClResTPC clRes{};
-  for (uint8_t sector = 0; sector < 36; sector++) {
-    for (uint8_t row = 0; row < 152; row++) {
+  for (uint8_t row = 0; row < 152; row++) { // we need to go in increasing row, so this should be the outer loop
+    for (uint8_t sector = 0; sector < 36; sector++) {
       unsigned int offs = TPCClusterIdxStruct.clusterOffset[sector][row];
       for (unsigned int icl0 = 0; icl0 < TPCClusterIdxStruct.nClusters[sector][row]; icl0++) {
         const auto labels = TPCClMClab->getLabels(icl0 + offs);
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx
index 204e0c741a675..b6236b7bf0e73 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudyTypes.cxx
@@ -77,4 +77,66 @@ int MCTrackInfo::getHighestITSLayer() const
   return -1;
 }
 
+o2::track::TrackPar MCTrackInfo::getTrackParTPC(float b, float x) const
+{
+  o2::track::TrackPar t(track);
+  int ntri = 0;
+  while (ntri < 2) {
+    int sector0 = o2::math_utils::angle2Sector(t.getAlpha());
+    if (!t.propagateParamTo(x, b)) {
+      t.invalidate();
+      break;
+    }
+    int sector = o2::math_utils::angle2Sector(t.getPhiPos());
+    float alpha = o2::math_utils::sector2Angle(sector);
+    if (!t.rotateParam(alpha)) {
+      t.invalidate();
+      break;
+    }
+    if (sector != sector0) {
+      ntri++;
+      continue;
+    }
+    break;
+  }
+  //  printf("%s ->\n%s <-\n",track.asString().c_str(), t.asString().c_str());
+  return t;
+}
+
+float MCTrackInfo::getTrackParTPCPar(int i, float b, float x) const
+{
+  auto t = getTrackParTPC(b, x);
+  return t.isValid() ? t.getParam(i) : -999.;
+}
+
+float MCTrackInfo::getTrackParTPCPhiSec(float b, float x) const
+{
+  auto t = getTrackParTPC(b, x);
+  return t.isValid() ? std::atan2(t.getY(), t.getX()) : -999.;
+}
+
+int TrackFamily::getLongestTPCTrackEntry() const
+{
+  int n = -1, ncl = 0;
+  int ntr = recTracks.size();
+  for (int i = 0; i < ntr; i++) {
+    if (recTracks[i].nClTPC > ncl) {
+      ncl = recTracks[i].nClTPC;
+      n = i;
+    }
+  }
+  return n;
+}
+
+int TrackFamily::getNTPCClones() const
+{
+  int n = 0;
+  for (auto& t : recTracks) {
+    if (t.nClTPC > 0) {
+      n++;
+    }
+  }
+  return n;
+}
+
 } // namespace o2::trackstudy
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index 97721a30b0ab8..44dbf5f1e1458 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -274,25 +274,25 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
     const auto clRefs = recoData.getTPCTracksClusterRefs();
     const auto tpcClusAcc = recoData.getTPCClusters();
     const auto shMap = recoData.clusterShMapTPC;
+
     if (recoData.inputsTPCclusters) {
-      uint8_t clSect = 0, clRow = 0, clRowP = -1;
+      uint8_t clSect = 0, clRow = 0, lowestR = -1;
       uint32_t clIdx = 0;
-      for (int ic = 0; ic < trc.getNClusterReferences(); ic++) {
+      for (int ic = 0; ic < trc.getNClusterReferences(); ic++) { // outside -> inside ordering, but on the sector boundaries backward jumps are possible
         trc.getClusterReference(clRefs, ic, clSect, clRow, clIdx);
-        if (clRow != clRowP) {
+        if (clRow < lowestR) {
           trExt.rowCountTPC++;
-          clRowP = clRow;
+          lowestR = clRow;
         }
         unsigned int absoluteIndex = tpcClusAcc.clusterOffset[clSect][clRow] + clIdx;
         if (shMap[absoluteIndex] & o2::gpu::GPUTPCGMMergedTrackHit::flagShared) {
           trExt.nClTPCShared++;
         }
       }
-      trc.getClusterReference(clRefs, trc.getNClusterReferences() - 1, clSect, clRow, clIdx);
-      trExt.rowMinTPC = clRow;
+      trExt.rowMinTPC = lowestR;
       const auto& clus = tpcClusAcc.clusters[clSect][clRow][clIdx];
       trExt.padFromEdge = uint8_t(clus.getPad());
-      int npads = o2::gpu::GPUTPCGeometry::NPads(clRow);
+      int npads = o2::gpu::GPUTPCGeometry::NPads(lowestR);
       if (trExt.padFromEdge > npads / 2) {
         trExt.padFromEdge = npads - 1 - trExt.padFromEdge;
       }
@@ -314,9 +314,9 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
       uint8_t clSect0 = 0, clRow0 = 0, clSect1 = 0, clRow1 = 0;
       uint32_t clIdx0 = 0, clIdx1 = 0;
       int ic1Start = 0;
-      for (int ic0 = 0; ic0 < trc0.getNClusterReferences(); ic0++) { // outside -> inside
+      for (int ic0 = 0; ic0 < trc0.getNClusterReferences(); ic0++) { // outside -> inside, but on the sector boundaries backward jumps are possible
         trc0.getClusterReference(clRefs, ic0, clSect0, clRow0, clIdx0);
-        for (int ic1 = ic1Start; ic1 < trc1.getNClusterReferences(); ic1++) { // outside -> inside
+        for (int ic1 = ic1Start; ic1 < trc1.getNClusterReferences(); ic1++) { // outside -> inside, but on the sector boundaries backward jumps are possible
           trc1.getClusterReference(clRefs, ic1, clSect1, clRow1, clIdx1);
           if (clRow1 > clRow0) {
             ic1Start = ic1 + 1;

From 7fa67851725829b5e473f103bc44482b61afe7be Mon Sep 17 00:00:00 2001
From: Vikas Singhal <vikasssinghal@gmail.com>
Date: Wed, 30 Jul 2025 08:24:32 +0200
Subject: [PATCH 0656/1764] GPU: GPUd --> GPUdii Force Inline, Code did not
 break

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 87486292eb034..f224e860839df 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -1095,7 +1095,7 @@ GPUd() bool GPUTPCGMTrackParam::CheckNumericalQuality(float overrideCovYY) const
   return ok;
 }
 
-GPUd() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict() track, int32_t iTrk, GPUTPCGMMerger* GPUrestrict() merger, int32_t attempt) // TODO: Inline me, once __forceinline__ is fixed by HIP
+GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict() track, int32_t iTrk, GPUTPCGMMerger* GPUrestrict() merger, int32_t attempt) // VS: GPUd changed to GPUdii. No change in output and no performance penalty.
 {
   if (!track.OK()) {
     return;

From d55013b2ec4f6043963ed8f9e40ff7a1d6dc5a46 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 30 Jul 2025 16:29:03 +0200
Subject: [PATCH 0657/1764] Add hash method to the TrackParam

Hash is calculated by combining the precision-truncated (a la AOD)
x, alpha + 5 parameters, so the hash depends on the X where it is evaluated.
---
 .../TrackParametrization.h                      | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index f240e34861eeb..9c3079208b2f5 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -248,6 +248,8 @@ class TrackParametrization
 #ifndef GPUCA_ALIGPUCODE
   std::string asString() const;
   std::string asStringHexadecimal();
+  size_t hash() const { return hash(getX(), getAlpha(), getY(), getZ(), getSnp(), getTgl(), getQ2Pt()); }
+  static size_t hash(float x, float alp, float y, float z, float snp, float tgl, float q2pt);
 #endif
 
   GPUd() void updateParam(value_t delta, int i);
@@ -752,6 +754,21 @@ GPUdi() void TrackParametrization<value_T>::updateParams(const value_t* delta)
   }
 }
 
+#ifndef GPUCA_ALIGPUCODE
+template <typename value_T>
+size_t TrackParametrization<value_T>::hash(float x, float alp, float y, float z, float snp, float tgl, float q2pt)
+{
+  size_t h = std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(x, 0xFFFFFFF0));
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(alp, 0xFFFFFFF0)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(y, 0xFFFFFFF0)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(z, 0xFFFFFFF0)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(snp, 0xFFFFFF00)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(tgl, 0xFFFFFF00)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(q2pt, 0xFFFFFC00)) << 1;
+  return h;
+}
+#endif
+
 } // namespace track
 } // namespace o2
 

From de1a1d68f0bd4d62b7b84ddaef5b0931f5546edd Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 30 Jul 2025 16:29:32 +0200
Subject: [PATCH 0658/1764] Add track hash to TrackStudy output

---
 .../study/include/GlobalTrackingStudy/TrackInfoExt.h          | 4 ++--
 Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx  | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
index 2eed64df3bfca..e33a0def63842 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackInfoExt.h
@@ -53,7 +53,7 @@ struct TrackInfoExt {
   uint8_t padFromEdge = -1;
   uint8_t rowMaxTPC = 0;
   uint8_t rowCountTPC = 0;
-
+  size_t hashIU = 0;
   void setTPCA() { setBit(int(TPCA)); }
   void setTPCC() { setBit(int(TPCC)); }
   void setTPCAC() { setBit(int(TPCC)); }
@@ -74,7 +74,7 @@ struct TrackInfoExt {
   void resetBit(int bit) { flags &= ~(kBitMask & (0x1 << bit)); }
   bool isBitSet(int bit) const { return flags & (kBitMask & (0x1 << bit)); }
 
-  ClassDefNV(TrackInfoExt, 7);
+  ClassDefNV(TrackInfoExt, 8);
 };
 
 } // namespace dataformats
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index 44dbf5f1e1458..d9ea9fe4516e1 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -479,6 +479,7 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
           auto& trcExt = trcExtVec.emplace_back();
           recoData.getTrackTime(vid, trcExt.ttime, trcExt.ttimeE);
           trcExt.track = trc;
+          trcExt.hashIU = trc.hash();
           trcExt.dca = dca;
           trcExt.gid = vid;
           trcExt.xmin = xmin;

From fd6d4eb302df34cb4d97ac8bb2ea74874b439958 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 31 Jul 2025 10:47:37 +0200
Subject: [PATCH 0659/1764] dpl-workflow: simple serialization mitigation seems
 not to work on MI100 in async, have to use full serialization workaround

---
 prodtests/full-system-test/dpl-workflow.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 044c382e45070..e4cd6d3c74cec 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -272,7 +272,8 @@ if [[ $GPUTYPE == "HIP" ]]; then
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
   # serialization workaround for MI100 nodes: remove it again if the problem will be fixed in ROCm, then also remove the DISABLE_MI100_SERIALIZATION flag in the O2DPG parse script
-  [[ $EPNSYNCMODE == 1 || -n ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.amdMI100SerializationWorkaround=1;"
+  [[ $EPNSYNCMODE == 1 ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.amdMI100SerializationWorkaround=1;"
+  [[ -n ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else
   GPU_CONFIG_KEY+="GPU_proc.deviceNum=-2;"

From c01e12034776fe51d63106c06f9f961eb94930c1 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 31 Jul 2025 22:38:58 +0200
Subject: [PATCH 0660/1764] ITS: if TF dropped clear tracks (#14553)

---
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 938356050262d..b0add9881d01b 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -66,6 +66,7 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
     LOGP(error, "Exception: {}", err.what());
     if (mTrkParams[iteration].DropTFUponFailure) {
       mMemoryPool->print();
+      mTimeFrame->wipe();
       ++mNumberOfDroppedTFs;
       error("...Dropping Timeframe...");
     } else {

From 5cae1bcdde3318e4d5720403c87d5af00b79f7f5 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Fri, 1 Aug 2025 01:55:29 +0200
Subject: [PATCH 0661/1764] Bug-fix for memory allocation (#14554)

---
 .../Global/GPUChainTrackingClusterizer.cxx    | 34 ++++++++++---------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 07b332db1fc12..846df352d3a34 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -643,26 +643,28 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
   // Maximum of 4 lanes supported
   HighResTimer* nnTimers[12];
-  if (GetProcessingSettings().nn.applyNNclusterizer && GetProcessingSettings().debugLevel >= 1) {
-    nnTimers[0] = &getTimer<GPUTPCNNClusterizer, 0>("GPUTPCNNClusterizer_ONNXClassification_0_", 0);
-    nnTimers[1] = &getTimer<GPUTPCNNClusterizer, 1>("GPUTPCNNClusterizer_ONNXRegression_1_", 1);
-    nnTimers[2] = &getTimer<GPUTPCNNClusterizer, 2>("GPUTPCNNClusterizer_ONNXRegression2_2_", 2);
-    nnTimers[3] = &getTimer<GPUTPCNNClusterizer, 3>("GPUTPCNNClusterizer_ONNXClassification_0_", 3);
-    nnTimers[4] = &getTimer<GPUTPCNNClusterizer, 4>("GPUTPCNNClusterizer_ONNXRegression_1_", 4);
-    nnTimers[5] = &getTimer<GPUTPCNNClusterizer, 5>("GPUTPCNNClusterizer_ONNXRegression2_2_", 5);
-    nnTimers[6] = &getTimer<GPUTPCNNClusterizer, 6>("GPUTPCNNClusterizer_ONNXClassification_0_", 6);
-    nnTimers[7] = &getTimer<GPUTPCNNClusterizer, 7>("GPUTPCNNClusterizer_ONNXRegression_1_", 7);
-    nnTimers[8] = &getTimer<GPUTPCNNClusterizer, 8>("GPUTPCNNClusterizer_ONNXRegression2_2_", 8);
-    nnTimers[9] = &getTimer<GPUTPCNNClusterizer, 9>("GPUTPCNNClusterizer_ONNXClassification_0_", 9);
-    nnTimers[10] = &getTimer<GPUTPCNNClusterizer, 10>("GPUTPCNNClusterizer_ONNXRegression_1_", 10);
-    nnTimers[11] = &getTimer<GPUTPCNNClusterizer, 11>("GPUTPCNNClusterizer_ONNXRegression2_2_", 11);
-  }
 
   if (GetProcessingSettings().nn.applyNNclusterizer) {
     int32_t deviceId = -1;
     int32_t numLanes = GetProcessingSettings().nTPCClustererLanes;
     int32_t maxThreads = mRec->getNKernelHostThreads(true);
     // bool recreateMemoryAllocator = false;
+
+    if (GetProcessingSettings().debugLevel >= 1) {
+      nnTimers[0] = &getTimer<GPUTPCNNClusterizer, 0>("GPUTPCNNClusterizer_ONNXClassification_0_", 0);
+      nnTimers[1] = &getTimer<GPUTPCNNClusterizer, 1>("GPUTPCNNClusterizer_ONNXRegression_1_", 1);
+      nnTimers[2] = &getTimer<GPUTPCNNClusterizer, 2>("GPUTPCNNClusterizer_ONNXRegression2_2_", 2);
+      nnTimers[3] = &getTimer<GPUTPCNNClusterizer, 3>("GPUTPCNNClusterizer_ONNXClassification_0_", 3);
+      nnTimers[4] = &getTimer<GPUTPCNNClusterizer, 4>("GPUTPCNNClusterizer_ONNXRegression_1_", 4);
+      nnTimers[5] = &getTimer<GPUTPCNNClusterizer, 5>("GPUTPCNNClusterizer_ONNXRegression2_2_", 5);
+      nnTimers[6] = &getTimer<GPUTPCNNClusterizer, 6>("GPUTPCNNClusterizer_ONNXClassification_0_", 6);
+      nnTimers[7] = &getTimer<GPUTPCNNClusterizer, 7>("GPUTPCNNClusterizer_ONNXRegression_1_", 7);
+      nnTimers[8] = &getTimer<GPUTPCNNClusterizer, 8>("GPUTPCNNClusterizer_ONNXRegression2_2_", 8);
+      nnTimers[9] = &getTimer<GPUTPCNNClusterizer, 9>("GPUTPCNNClusterizer_ONNXClassification_0_", 9);
+      nnTimers[10] = &getTimer<GPUTPCNNClusterizer, 10>("GPUTPCNNClusterizer_ONNXRegression_1_", 10);
+      nnTimers[11] = &getTimer<GPUTPCNNClusterizer, 11>("GPUTPCNNClusterizer_ONNXRegression2_2_", 11);
+    }
+
     mRec->runParallelOuterLoop(doGPU, numLanes, [&](uint32_t lane) {
       nnApplications[lane].init(nn_settings, GetProcessingSettings().deterministicGPUReconstruction);
       if (nnApplications[lane].mModelsUsed[0]) {
@@ -708,7 +710,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         LOG(info) << "(ORT) Allocated ONNX stream for lane " << lane << " and device " << deviceId;
       }
     });
-    mRec->runParallelOuterLoop(doGPU, NSECTORS, [&](uint32_t sector) {
+    for (int32_t sector = 0; sector < NSECTORS; sector++) {
       GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[sector];
       GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[sector] : clustererNN;
       int32_t lane = sector % numLanes;
@@ -725,7 +727,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
       AllocateRegisteredMemory(clustererNN.mMemoryId);
       // nnApplications[lane].createBoundary(clustererNNShadow);
       // nnApplications[lane].createIndexLookup(clustererNNShadow);
-    });
+    }
     if (doGPU) {
       WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->tpcNNClusterer - (char*)processors(), &processorsShadow()->tpcNNClusterer, sizeof(GPUTPCNNClusterizer) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);
     }

From 1aa2c1409988e1054730c7cccdc987fbe1db7506 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <nicolo.jacazio@cern.ch>
Date: Tue, 15 Jul 2025 19:18:09 +0200
Subject: [PATCH 0662/1764] TOF Param container: move to header only

---
 DataFormats/Detectors/TOF/CMakeLists.txt      |  1 -
 .../DataFormatsTOF/ParameterContainers.h      | 43 +++++++++++--
 .../Detectors/TOF/src/ParameterContainers.cxx | 62 -------------------
 3 files changed, 38 insertions(+), 68 deletions(-)
 delete mode 100644 DataFormats/Detectors/TOF/src/ParameterContainers.cxx

diff --git a/DataFormats/Detectors/TOF/CMakeLists.txt b/DataFormats/Detectors/TOF/CMakeLists.txt
index 03dbd9275edf9..8a55e531287e1 100644
--- a/DataFormats/Detectors/TOF/CMakeLists.txt
+++ b/DataFormats/Detectors/TOF/CMakeLists.txt
@@ -16,7 +16,6 @@ o2_add_library(DataFormatsTOF
                        src/CalibLHCphaseTOF.cxx
                        src/CalibTimeSlewingParamTOF.cxx
                        src/CTF.cxx
-                       src/ParameterContainers.cxx
                        src/CalibInfoCluster.cxx
                        src/CosmicInfo.cxx
                        src/Diagnostic.cxx
diff --git a/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h b/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
index 9029c06d503c8..c9d910d8345e5 100644
--- a/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
+++ b/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
@@ -37,7 +37,7 @@ class Parameters
   Parameters(std::array<std::string, nPar> parNames, std::string name) : mName{name}, mPar{}, mParNames{parNames} {};
 
   /// Default destructor
-  ~Parameters() = default;
+  virtual ~Parameters() = default; // Ensure proper cleanup in derived classes
 
   /// Setter for the parameter at position iparam
   /// \param iparam index in the array of the parameters
@@ -183,10 +183,27 @@ class ParameterCollection : public TNamed
   /// @param value parameter to add to the stored information
   /// @param pass key to look for in the stored information e.g. pass
   /// @return true if found and configured false if not fully configured
-  bool addParameter(const std::string& pass, const std::string& parName, float value);
+  bool addParameter(const std::string& pass, const std::string& parName, float value)
+  {
+    const bool alreadyPresent = hasKey(pass);
+    if (alreadyPresent) {
+      LOG(debug) << "Changing parametrization corresponding to key " << pass << " from size " << mParameters[pass].size() << " to " << parName;
+    } else {
+      mParameters[pass] = std::unordered_map<std::string, paramvar_t>{};
+      LOG(debug) << "Adding new parametrization corresponding to key " << pass << ": " << parName;
+    }
+    mParameters[pass][parName] = value;
+    return true;
+  }
 
   /// @return the size of the container i.e. the number of stored keys (or passes)
-  int getSize(const std::string& pass) const;
+  int getSize(const std::string& pass) const
+  {
+    if (!hasKey(pass)) {
+      return -1;
+    }
+    return mParameters.at(pass).size();
+  }
 
   /// @brief Function to push the parameters from the sub container into the collection and store it under a given key
   /// @tparam ParType type of the parameter container
@@ -214,10 +231,26 @@ class ParameterCollection : public TNamed
 
   /// @brief printing function for the content of the pass
   /// @param pass pass to print
-  void print(const std::string& pass) const;
+  void print(const std::string& pass) const
+  {
+    const auto& size = getSize(pass);
+    if (size < 0) {
+      LOG(info) << "empty pass: " << pass;
+      return;
+    }
+    LOG(info) << "Pass \"" << pass << "\" with size " << size;
+    for (const auto& [par, value] : mParameters.at(pass)) {
+      LOG(info) << "par name = " << par << ", value = " << value;
+    }
+  }
 
   /// @brief printing function for the full content of the container
-  void print() const;
+  void print() const
+  {
+    for (const auto& [pass, pars] : mParameters) {
+      print(pass);
+    }
+  }
 
   /// @brief Getter of the full map of parameters stored in the container
   /// @return returns the full map of parameters
diff --git a/DataFormats/Detectors/TOF/src/ParameterContainers.cxx b/DataFormats/Detectors/TOF/src/ParameterContainers.cxx
deleted file mode 100644
index 91f723873e9cd..0000000000000
--- a/DataFormats/Detectors/TOF/src/ParameterContainers.cxx
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file   ParameterContainers.h
-/// \author Francesco Noferini
-/// \author Nicolò Jacazio nicolo.jacazio@cern.ch
-/// @since  2022-11-08
-/// \brief  Implementation of the containers for the general parameters
-
-#include "DataFormatsTOF/ParameterContainers.h"
-
-// ClassImp(o2::tof::Parameters);
-using namespace o2::tof;
-
-bool ParameterCollection::addParameter(const std::string& pass, const std::string& parName, float value)
-{
-  const bool alreadyPresent = hasKey(pass);
-  if (alreadyPresent) {
-    LOG(debug) << "Changing parametrization corresponding to key " << pass << " from size " << mParameters[pass].size() << " to " << parName;
-  } else {
-    mParameters[pass] = std::unordered_map<std::string, paramvar_t>{};
-    LOG(debug) << "Adding new parametrization corresponding to key " << pass << ": " << parName;
-  }
-  mParameters[pass][parName] = value;
-  return true;
-}
-
-int ParameterCollection::getSize(const std::string& pass) const
-{
-  if (!hasKey(pass)) {
-    return -1;
-  }
-  return mParameters.at(pass).size();
-}
-
-void ParameterCollection::print() const
-{
-  for (const auto& [pass, pars] : mParameters) {
-    print(pass);
-  }
-}
-
-void ParameterCollection::print(const std::string& pass) const
-{
-  const auto& size = getSize(pass);
-  if (size < 0) {
-    LOG(info) << "empty pass: " << pass;
-    return;
-  }
-  LOG(info) << "Pass \"" << pass << "\" with size " << size;
-  for (const auto& [par, value] : mParameters.at(pass)) {
-    LOG(info) << "par name = " << par << ", value = " << value;
-  }
-}

From f08023c41d023c219ac097d031398ff7e41fd742 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 31 Jul 2025 11:32:50 +0200
Subject: [PATCH 0663/1764] ITS: allow to Individually set kernel parameters

---
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 32 +++++++++----------
 .../include/ITStracking/TrackingConfigParam.h | 29 +++++++++++++++--
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  1 +
 .../ITS/tracking/src/TrackingConfigParam.cxx  | 28 ++++++++++++++++
 4 files changed, 71 insertions(+), 19 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index a8061e872c029..82eb48a8a7663 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -80,8 +80,8 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                        mTimeFrameGPU->getPositionResolutions(),
                                        this->mTrkParams[iteration].LayerRadii,
                                        mTimeFrameGPU->getMSangles(),
-                                       conf.nBlocks,
-                                       conf.nThreads,
+                                       conf.nBlocksLayerTracklets[iteration],
+                                       conf.nThreadsLayerTracklets[iteration],
                                        mTimeFrameGPU->getStreams());
   mTimeFrameGPU->createTrackletsBuffers();
   computeTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
@@ -113,8 +113,8 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getPositionResolutions(),
                                          this->mTrkParams[iteration].LayerRadii,
                                          mTimeFrameGPU->getMSangles(),
-                                         conf.nBlocks,
-                                         conf.nThreads,
+                                         conf.nBlocksLayerTracklets[iteration],
+                                         conf.nThreadsLayerTracklets[iteration],
                                          mTimeFrameGPU->getStreams());
 }
 
@@ -144,8 +144,8 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                       this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                       this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                       this->mTrkParams[iteration].NSigmaCut,
-                      conf.nBlocks,
-                      conf.nThreads);
+                      conf.nBlocksLayerCells[iteration],
+                      conf.nThreadsLayerCells[iteration]);
     mTimeFrameGPU->createCellsBuffers(iLayer);
     computeCellsHandler(mTimeFrameGPU->getDeviceArrayClusters(),
                         mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
@@ -161,8 +161,8 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                         this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                         this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                         this->mTrkParams[iteration].NSigmaCut,
-                        conf.nBlocks,
-                        conf.nThreads);
+                        conf.nBlocksLayerCells[iteration],
+                        conf.nThreadsLayerCells[iteration]);
   }
 }
 
@@ -191,8 +191,8 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                                      currentLayerCellsNum,
                                                      nextLayerCellsNum,
                                                      1e2,
-                                                     conf.nBlocks,
-                                                     conf.nThreads);
+                                                     conf.nBlocksFindNeighbours[iteration],
+                                                     conf.nThreadsFindNeighbours[iteration]);
 
     mTimeFrameGPU->createNeighboursDevice(iLayer, nNeigh);
 
@@ -207,8 +207,8 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                  currentLayerCellsNum,
                                  nextLayerCellsNum,
                                  1e2,
-                                 conf.nBlocks,
-                                 conf.nThreads);
+                                 conf.nBlocksFindNeighbours[iteration],
+                                 conf.nThreadsFindNeighbours[iteration]);
 
     nNeigh = filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                          mTimeFrameGPU->getDeviceNeighbours(iLayer),
@@ -247,8 +247,8 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
                                         this->mTrkParams[0].CorrType,
-                                        conf.nBlocks,
-                                        conf.nThreads);
+                                        conf.nBlocksProcessNeighbours[iteration],
+                                        conf.nThreadsProcessNeighbours[iteration]);
     }
     // fixme: I don't want to move tracks back and forth, but I need a way to use a thrust::allocator that is aware of our managed memory.
     if (trackSeeds.empty()) {
@@ -269,8 +269,8 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                      this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
                      mTimeFrameGPU->getDevicePropagator(),             // const o2::base::Propagator* propagator
                      this->mTrkParams[0].CorrType,                     // o2::base::PropagatorImpl<float>::MatCorrType
-                     conf.nBlocks,
-                     conf.nThreads);
+                     conf.nBlocksTracksSeeds[iteration],
+                     conf.nThreadsTracksSeeds[iteration]);
 
     mTimeFrameGPU->downloadTrackITSExtDevice(trackSeeds);
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index ef6f925f1c29f..5b4b1aca1dfb8 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -107,9 +107,32 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
 };
 
 struct ITSGpuTrackingParamConfig : public o2::conf::ConfigurableParamHelper<ITSGpuTrackingParamConfig> {
-  // GPU-specific parameters
-  int nBlocks = 20;
-  int nThreads = 256;
+  static constexpr int MaxIter = TrackerParamConfig::MaxIter;
+
+  /// Set nBlocks/nThreads to summarily override all kernel launch parameters in each iteration.
+  /// Parameters must start with nBlocks/nThreads.
+  static constexpr int OverrideValue{-1};
+  static constexpr char const* BlocksName = "nBlocks";
+  static constexpr char const* ThreadsName = "nThreads";
+  int nBlocks = OverrideValue;
+  int nThreads = OverrideValue;
+  void maybeOverride() const;
+
+  /// Individual kernel launch parameter for each iteration
+  int nBlocksLayerTracklets[MaxIter] = {30, 30, 30, 30};
+  int nThreadsLayerTracklets[MaxIter] = {256, 256, 256, 256};
+
+  int nBlocksLayerCells[MaxIter] = {30, 30, 30, 30};
+  int nThreadsLayerCells[MaxIter] = {256, 256, 256, 256};
+
+  int nBlocksFindNeighbours[MaxIter] = {30, 30, 30, 30};
+  int nThreadsFindNeighbours[MaxIter] = {256, 256, 256, 256};
+
+  int nBlocksProcessNeighbours[MaxIter] = {30, 30, 30, 30};
+  int nThreadsProcessNeighbours[MaxIter] = {256, 256, 256, 256};
+
+  int nBlocksTracksSeeds[MaxIter] = {30, 30, 30, 30};
+  int nThreadsTracksSeeds[MaxIter] = {256, 256, 256, 256};
 
   O2ParamDef(ITSGpuTrackingParamConfig, "ITSGpuTrackingParam");
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index b0add9881d01b..c8bf39142e019 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -39,6 +39,7 @@ Tracker::Tracker(TrackerTraits7* traits) : mTraits(traits)
   /// Initialise standard configuration with 1 iteration
   mTrkParams.resize(1);
   if (traits->isGPU()) {
+    ITSGpuTrackingParamConfig::Instance().maybeOverride();
     ITSGpuTrackingParamConfig::Instance().printKeyValues(true, true);
   }
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
index b5fbedcc89339..3101c34d4ab8f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
@@ -9,8 +9,36 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <boost/property_tree/ptree.hpp>
+
+#include "Framework/Logger.h"
 #include "ITStracking/TrackingConfigParam.h"
 
 O2ParamImpl(o2::its::VertexerParamConfig);
 O2ParamImpl(o2::its::TrackerParamConfig);
 O2ParamImpl(o2::its::ITSGpuTrackingParamConfig);
+
+namespace o2::its
+{
+
+void ITSGpuTrackingParamConfig::maybeOverride() const
+{
+  if (nBlocks == OverrideValue && nThreads == OverrideValue) {
+    return;
+  }
+  const auto name = getName();
+  auto members = getDataMembers();
+  for (auto member : *members) {
+    if (!member.name.ends_with(BlocksName) && !member.name.ends_with(ThreadsName)) {
+      if (nBlocks != OverrideValue && member.name.starts_with(BlocksName) && (member.value != nBlocks)) {
+        o2::conf::ConfigurableParam::setValue<int>(name, member.name, nBlocks);
+      }
+      if (nThreads != OverrideValue && member.name.starts_with(ThreadsName) && (member.value != nThreads)) {
+        o2::conf::ConfigurableParam::setValue<int>(name, member.name, nThreads);
+      }
+    }
+  }
+  LOGP(info, "Overwriting gpu threading parameters");
+} // namespace o2::its
+
+} // namespace o2::its

From afc3e674f955961207efd3ee919ad94983953f6a Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 4 Aug 2025 16:08:45 +0200
Subject: [PATCH 0664/1764] ITS: Tracklet add print compatible on GPU

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h     | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
index 5741a9fc65947..e6c9db55198a3 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
@@ -47,13 +47,10 @@ struct Tracklet final {
   GPUhdi() auto getDeltaRof() const { return rof[1] - rof[0]; }
   GPUhdi() auto getSpanRof(const Tracklet& o) const noexcept { return o2::gpu::CAMath::Max(getMaxRof(), o.getMaxRof()) - o2::gpu::CAMath::Min(getMinRof(), o.getMinRof()); }
   GPUhdi() unsigned char operator<(const Tracklet&) const;
-#if !defined(GPUCA_NO_FMT) && !defined(GPUCA_GPUCODE_DEVICE)
-  std::string asString() const
+  GPUhd() void print() const
   {
-    return fmt::format("fClIdx:{} fROF:{} sClIdx:{} sROF:{} (DROF:{})", firstClusterIndex, rof[0], secondClusterIndex, rof[1], getDeltaRof());
+    printf("TRKLT: fClIdx:%d fROF:%d sClIdx:%d sROF:%d (DROF:%d) tgl=%f phi=%f\n", firstClusterIndex, rof[0], secondClusterIndex, rof[1], getDeltaRof(), tanLambda, phi);
   }
-  void print() const { LOG(info) << asString(); }
-#endif
 
   int firstClusterIndex{constants::UnusedIndex};
   int secondClusterIndex{constants::UnusedIndex};

From 8feebaaa2e31b5f33618f11b17eedb327cdebab8 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 4 Aug 2025 16:09:38 +0200
Subject: [PATCH 0665/1764] ITS: format time for TF

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index be7750964b3e7..201f1d064a632 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -60,7 +60,7 @@ void TrackerDPL::run(ProcessingContext& pc)
   mITSTrackingInterface.updateTimeDependentParams(pc);
   mITSTrackingInterface.run(pc);
   mTimer.Stop();
-  LOGP(info, "CPU Reconstruction time for this TF {} s (cpu), {} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
+  LOGP(info, "CPU Reconstruction time for this TF {:.2f} s (cpu), {:.2f} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
 }
 
 void TrackerDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)

From 0a6a9624ca5066bbdfa9732e91190ee5c4151706 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 4 Aug 2025 16:10:26 +0200
Subject: [PATCH 0666/1764] ITS: make trackleting compatible with GPU (partial
 revert)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 181 ++++++++----------
 1 file changed, 84 insertions(+), 97 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index b46e7a68875e6..2515f8287d72b 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -73,6 +73,9 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
 
   mTaskArena->execute([&] {
     auto forTracklets = [&](auto Tag, int iLayer, int pivotROF, int base, int& offset) -> int {
+      if (!mTimeFrame->mMultiplicityCutMask[pivotROF]) {
+        return 0;
+      }
       int minROF = o2::gpu::CAMath::Max(startROF, pivotROF - mTrkParams[iteration].DeltaROF);
       int maxROF = o2::gpu::CAMath::Min(endROF - 1, pivotROF + mTrkParams[iteration].DeltaROF);
       gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(minROF, maxROF);
@@ -87,103 +90,98 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
 
       int localCount = 0;
       auto& tracklets = mTimeFrame->getTracklets()[iLayer];
-      for (int targetROF0{minROF}; targetROF0 <= maxROF; ++targetROF0) {
-        if (!mTimeFrame->mMultiplicityCutMask[targetROF0]) {
-          continue;
-        }
-        auto layer0 = mTimeFrame->getClustersOnLayer(targetROF0, iLayer);
-        if (layer0.empty()) {
+      auto layer0 = mTimeFrame->getClustersOnLayer(pivotROF, iLayer);
+      if (layer0.empty()) {
+        return 0;
+      }
+
+      const float meanDeltaR = mTrkParams[iteration].LayerRadii[iLayer + 1] - mTrkParams[iteration].LayerRadii[iLayer];
+
+      for (int iCluster = 0; iCluster < int(layer0.size()); ++iCluster) {
+        const Cluster& currentCluster = layer0[iCluster];
+        const int currentSortedIndex = mTimeFrame->getSortedIndex(pivotROF, iLayer, iCluster);
+        if (mTimeFrame->isClusterUsed(iLayer, currentCluster.clusterId)) {
           continue;
         }
-        const float meanDeltaR = mTrkParams[iteration].LayerRadii[iLayer + 1] - mTrkParams[iteration].LayerRadii[iLayer];
+        const float inverseR0 = 1.f / currentCluster.radius;
 
-        for (int iCluster = 0; iCluster < int(layer0.size()); ++iCluster) {
-          const Cluster& currentCluster = layer0[iCluster];
-          const int currentSortedIndex = mTimeFrame->getSortedIndex(targetROF0, iLayer, iCluster);
-          if (mTimeFrame->isClusterUsed(iLayer, currentCluster.clusterId)) {
+        for (int iV = startVtx; iV < endVtx; ++iV) {
+          const auto& pv = primaryVertices[iV];
+          if ((pv.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) || (iteration == 3 && !pv.isFlagSet(Vertex::Flags::UPCMode))) {
             continue;
           }
-          const float inverseR0 = 1.f / currentCluster.radius;
 
-          for (int iV = startVtx; iV < endVtx; ++iV) {
-            const auto& pv = primaryVertices[iV];
-            if ((pv.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) || (iteration == 3 && !pv.isFlagSet(Vertex::Flags::UPCMode))) {
-              continue;
-            }
+          const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)) + math_utils::Sq(mTrkParams[iteration].PVres) / float(pv.getNContributors()));
+          const float tanLambda = (currentCluster.zCoordinate - pv.getZ()) * inverseR0;
+          const float zAtRmin = tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
+          const float zAtRmax = tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
+          const float sqInvDeltaZ0 = 1.f / (math_utils::Sq(currentCluster.zCoordinate - pv.getZ()) + constants::Tolerance);
+          const float sigmaZ = o2::gpu::CAMath::Sqrt(
+            math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInvDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)));
 
-            const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)) + math_utils::Sq(mTrkParams[iteration].PVres) / float(pv.getNContributors()));
-            const float tanLambda = (currentCluster.zCoordinate - pv.getZ()) * inverseR0;
-            const float zAtRmin = tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
-            const float zAtRmax = tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
-            const float sqInvDeltaZ0 = 1.f / (math_utils::Sq(currentCluster.zCoordinate - pv.getZ()) + constants::Tolerance);
-            const float sigmaZ = o2::gpu::CAMath::Sqrt(
-              math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInvDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)));
+          auto bins = getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer));
+          if (bins.x == 0 && bins.y == 0 && bins.z == 0 && bins.w == 0) {
+            continue;
+          }
+          int phiBinsNum = bins.w - bins.y + 1;
+          if (phiBinsNum < 0) {
+            phiBinsNum += mTrkParams[iteration].PhiBins;
+          }
 
-            auto bins = getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer));
-            if (bins.x == 0 && bins.y == 0 && bins.z == 0 && bins.w == 0) {
+          for (int targetROF{minROF}; targetROF <= maxROF; ++targetROF) {
+            if (!mTimeFrame->mMultiplicityCutMask[targetROF]) {
               continue;
             }
-            int phiBinsNum = bins.w - bins.y + 1;
-            if (phiBinsNum < 0) {
-              phiBinsNum += mTrkParams[iteration].PhiBins;
+            auto layer1 = mTimeFrame->getClustersOnLayer(targetROF, iLayer + 1);
+            if (layer1.empty()) {
+              continue;
             }
-
-            for (int targetROF1{minROF}; targetROF1 <= maxROF; ++targetROF1) {
-              if (!mTimeFrame->mMultiplicityCutMask[targetROF1] || std::abs(targetROF0 - targetROF1) > mTrkParams[iteration].DeltaROF) {
-                continue;
-              }
-              auto layer1 = mTimeFrame->getClustersOnLayer(targetROF1, iLayer + 1);
-              if (layer1.empty()) {
-                continue;
-              }
-              for (int iPhi = 0; iPhi < phiBinsNum; ++iPhi) {
-                int iPhiBin = (bins.y + iPhi) % mTrkParams[iteration].PhiBins;
-                int firstBinIdx = mTimeFrame->mIndexTableUtils.getBinIndex(bins.x, iPhiBin);
-                int maxBinIdx = firstBinIdx + (bins.z - bins.x) + 1;
-                int firstRow = mTimeFrame->getIndexTable(targetROF1, iLayer + 1)[firstBinIdx];
-                int lastRow = mTimeFrame->getIndexTable(targetROF1, iLayer + 1)[maxBinIdx];
-                for (int iNext = firstRow; iNext < lastRow; ++iNext) {
-                  if (iNext >= int(layer1.size())) {
-                    break;
-                  }
-                  const Cluster& nextCluster = layer1[iNext];
-                  if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
-                    continue;
-                  }
-                  float deltaPhi = o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi);
-                  float deltaZ = o2::gpu::GPUCommonMath::Abs((tanLambda * (nextCluster.radius - currentCluster.radius)) + currentCluster.zCoordinate - nextCluster.zCoordinate);
+            for (int iPhi = 0; iPhi < phiBinsNum; ++iPhi) {
+              const int iPhiBin = (bins.y + iPhi) % mTrkParams[iteration].PhiBins;
+              const int firstBinIdx = mTimeFrame->mIndexTableUtils.getBinIndex(bins.x, iPhiBin);
+              const int maxBinIdx = firstBinIdx + (bins.z - bins.x) + 1;
+              const int firstRow = mTimeFrame->getIndexTable(targetROF, iLayer + 1)[firstBinIdx];
+              const int lastRow = mTimeFrame->getIndexTable(targetROF, iLayer + 1)[maxBinIdx];
+              for (int iNext = firstRow; iNext < lastRow; ++iNext) {
+                if (iNext >= int(layer1.size())) {
+                  break;
+                }
+                const Cluster& nextCluster = layer1[iNext];
+                if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
+                  continue;
+                }
+                float deltaPhi = o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi);
+                float deltaZ = o2::gpu::GPUCommonMath::Abs((tanLambda * (nextCluster.radius - currentCluster.radius)) + currentCluster.zCoordinate - nextCluster.zCoordinate);
 
 #ifdef OPTIMISATION_OUTPUT
-                  MCCompLabel label;
-                  int currentId{currentCluster.clusterId};
-                  int nextId{nextCluster.clusterId};
-                  for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
-                    for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
-                      if (lab1 == lab2 && lab1.isValid()) {
-                        label = lab1;
-                        break;
-                      }
-                    }
-                    if (label.isValid()) {
+                MCCompLabel label;
+                int currentId{currentCluster.clusterId};
+                int nextId{nextCluster.clusterId};
+                for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
+                  for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
+                    if (lab1 == lab2 && lab1.isValid()) {
+                      label = lab1;
                       break;
                     }
                   }
-                  off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
+                  if (label.isValid()) {
+                    break;
+                  }
+                }
+                off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
 #endif
 
-                  if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
-                      (deltaPhi < mTimeFrame->getPhiCut(iLayer) ||
-                       o2::gpu::GPUCommonMath::Abs(deltaPhi - o2::constants::math::TwoPI) < mTimeFrame->getPhiCut(iLayer))) {
-                    float phi = o2::gpu::GPUCommonMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate);
-                    float tanL = (currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius);
-                    if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
-                      tracklets.emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF1, iLayer + 1, iNext), tanL, phi, targetROF0, targetROF1);
-                    } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
-                      ++localCount;
-                    } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
-                      const int idx = base + offset++;
-                      tracklets[idx] = Tracklet(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF1, iLayer + 1, iNext), tanL, phi, targetROF0, targetROF1);
-                    }
+                if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
+                    ((deltaPhi < mTimeFrame->getPhiCut(iLayer) || o2::gpu::GPUCommonMath::Abs(deltaPhi - o2::constants::math::TwoPI) < mTimeFrame->getPhiCut(iLayer)))) {
+                  const float phi{o2::gpu::CAMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate)};
+                  const float tanL = (currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius);
+                  if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
+                    tracklets.emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, iLayer + 1, iNext), tanL, phi, pivotROF, targetROF);
+                  } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
+                    ++localCount;
+                  } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
+                    const int idx = base + offset++;
+                    tracklets[idx] = Tracklet(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, iLayer + 1, iNext), tanL, phi, pivotROF, targetROF);
                   }
                 }
               }
@@ -250,7 +248,10 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
           /// Sort tracklets
           auto& trkl{mTimeFrame->getTracklets()[iLayer]};
           tbb::parallel_sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
-            return a.firstClusterIndex < b.firstClusterIndex || (a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex < b.secondClusterIndex);
+            if (a.firstClusterIndex != b.firstClusterIndex) {
+              return a.firstClusterIndex < b.firstClusterIndex;
+            }
+            return a.secondClusterIndex < b.secondClusterIndex;
           });
           /// Remove duplicates
           trkl.erase(std::unique(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
@@ -297,7 +298,7 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
         });
     }
   });
-}
+} // namespace o2::its
 
 template <int nLayers>
 void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
@@ -327,7 +328,6 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
       for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
         const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
         const auto& nextLbl = mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet];
-        bool print = false;
         if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
           break;
         }
@@ -509,7 +509,8 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
             const auto& trkl01 = mTimeFrame->getTracklets()[iLayer + 1][currentCellSeed.getSecondTrackletIndex()];
             const auto& trkl10 = mTimeFrame->getTracklets()[iLayer + 1][nextCellSeed.getFirstTrackletIndex()];
             const auto& trkl11 = mTimeFrame->getTracklets()[iLayer + 2][nextCellSeed.getSecondTrackletIndex()];
-            if ((std::max({trkl00.getMaxRof(), trkl01.getMaxRof(), trkl10.getMaxRof(), trkl11.getMaxRof()}) - std::min({trkl00.getMinRof(), trkl01.getMinRof(), trkl10.getMinRof(), trkl10.getMinRof()})) > mTrkParams[0].DeltaROF) {
+            if ((std::max({trkl00.getMaxRof(), trkl01.getMaxRof(), trkl10.getMaxRof(), trkl11.getMaxRof()}) -
+                 std::min({trkl00.getMinRof(), trkl01.getMinRof(), trkl10.getMinRof(), trkl11.getMinRof()})) > mTrkParams[0].DeltaROF) {
               continue;
             }
           }
@@ -657,20 +658,6 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
           CA_DEBUGGER(failed[0]++);
           continue;
         }
-        if (mTrkParams[0].DeltaROF) { // TODO this has to be improved for the staggering
-          const auto& trklNeigh = mTimeFrame->getTracklets()[iLayer - 1][neighbourCell.getFirstTrackletIndex()];
-          short minRof{std::numeric_limits<short>::max()}, maxRof{std::numeric_limits<short>::min()};
-          for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
-            if (const auto clsId = currentCell.getCluster(iLayer); clsId != constants::UnusedIndex) {
-              const short clsROF = mTimeFrame->getClusterROF(iLayer, clsId);
-              minRof = std::min(minRof, clsROF);
-              maxRof = std::max(maxRof, clsROF);
-            }
-          }
-          if ((std::max(trklNeigh.getMaxRof(), maxRof) - std::min(trklNeigh.getMinRof(), minRof)) > mTrkParams[0].DeltaROF) {
-            continue;
-          }
-        }
 
         /// Let's start the fitting procedure
         CellSeed seed{currentCell};

From c62aef2ea85d3e24b42e1eff827d440cb2702132 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 4 Aug 2025 16:11:21 +0200
Subject: [PATCH 0667/1764] ITS: GPU: fix deltaROF tracking

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TrackingKernels.h      |   6 ++
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |   6 ++
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 102 +++++++++++++-----
 3 files changed, 88 insertions(+), 26 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index a058f7e5fab0c..b0fb443513fef 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -131,6 +131,7 @@ void countCellsHandler(const Cluster** sortedClusters,
                        CellSeed* cells,
                        int** cellsLUTsDeviceArray,
                        int* cellsLUTsHost,
+                       const int deltaROF,
                        const float bz,
                        const float maxChi2ClusterAttachment,
                        const float cellDeltaTanLambdaSigma,
@@ -148,6 +149,7 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          CellSeed* cells,
                          int** cellsLUTsDeviceArray,
                          int* cellsLUTsHost,
+                         const int deltaROF,
                          const float bz,
                          const float maxChi2ClusterAttachment,
                          const float cellDeltaTanLambdaSigma,
@@ -160,6 +162,8 @@ unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                         int** cellsLUTs,
                                         gpuPair<int, int>* cellNeighbours,
                                         int* neighboursIndexTable,
+                                        const Tracklet** tracklets,
+                                        const int deltaROF,
                                         const float maxChi2ClusterAttachment,
                                         const float bz,
                                         const int layerIndex,
@@ -174,6 +178,8 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   int** cellsLUTs,
                                   gpuPair<int, int>* cellNeighbours,
                                   int* neighboursIndexTable,
+                                  const Tracklet** tracklets,
+                                  const int deltaROF,
                                   const float maxChi2ClusterAttachment,
                                   const float bz,
                                   const int layerIndex,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 82eb48a8a7663..eaa6080761fec 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -140,6 +140,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                       nullptr,
                       mTimeFrameGPU->getDeviceArrayCellsLUT(),
                       mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
+                      this->mTrkParams[iteration].DeltaROF,
                       this->mBz,
                       this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                       this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
@@ -157,6 +158,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                         mTimeFrameGPU->getDeviceCells()[iLayer],
                         mTimeFrameGPU->getDeviceArrayCellsLUT(),
                         mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
+                        this->mTrkParams[iteration].DeltaROF,
                         this->mBz,
                         this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                         this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
@@ -185,6 +187,8 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                                      mTimeFrameGPU->getDeviceArrayCellsLUT(),
                                                      mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                                      mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
+                                                     (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
+                                                     this->mTrkParams[0].DeltaROF,
                                                      this->mTrkParams[0].MaxChi2ClusterAttachment,
                                                      this->mBz,
                                                      iLayer,
@@ -201,6 +205,8 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                  mTimeFrameGPU->getDeviceArrayCellsLUT(),
                                  mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                  mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
+                                 (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
+                                 this->mTrkParams[0].DeltaROF,
                                  this->mTrkParams[0].MaxChi2ClusterAttachment,
                                  this->mBz,
                                  iLayer,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index fb75764da2e36..02be19b1e3a08 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -201,7 +201,13 @@ GPUd() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
 }
 
 struct sort_tracklets {
-  GPUhd() bool operator()(const Tracklet& a, const Tracklet& b) { return a.firstClusterIndex < b.firstClusterIndex || (a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex < b.secondClusterIndex); }
+  GPUhd() bool operator()(const Tracklet& a, const Tracklet& b)
+  {
+    if (a.firstClusterIndex != b.firstClusterIndex) {
+      return a.firstClusterIndex < b.firstClusterIndex;
+    }
+    return a.secondClusterIndex < b.secondClusterIndex;
+  }
 };
 
 struct equal_tracklets {
@@ -263,23 +269,34 @@ struct compare_track_chi2 {
   }
 };
 
-GPUd() gpuSpan<const Vertex> getPrimaryVertices(const int rof,
-                                                const int* roframesPV,
-                                                const int nROF,
-                                                const uint8_t* mask,
-                                                const Vertex* vertices)
+GPUdii() gpuSpan<const Vertex> getPrimaryVertices(const int rof,
+                                                  const int* roframesPV,
+                                                  const int nROF,
+                                                  const uint8_t* mask,
+                                                  const Vertex* vertices)
 {
   const int start_pv_id = roframesPV[rof];
   const int stop_rof = rof >= nROF - 1 ? nROF : rof + 1;
-  size_t delta = mask[rof] ? roframesPV[stop_rof] - start_pv_id : 0; // return empty span if ROF is excluded
+  const size_t delta = mask[rof] ? roframesPV[stop_rof] - start_pv_id : 0; // return empty span if ROF is excluded
   return gpuSpan<const Vertex>(&vertices[start_pv_id], delta);
 };
 
-GPUd() gpuSpan<const Cluster> getClustersOnLayer(const int rof,
-                                                 const int totROFs,
-                                                 const int layer,
-                                                 const int** roframesClus,
-                                                 const Cluster** clusters)
+GPUdii() gpuSpan<const Vertex> getPrimaryVertices(const int romin,
+                                                  const int romax,
+                                                  const int* roframesPV,
+                                                  const int nROF,
+                                                  const Vertex* vertices)
+{
+  const int start_pv_id = roframesPV[romin];
+  const int stop_rof = romax >= nROF - 1 ? nROF : romax + 1;
+  return gpuSpan<const Vertex>(&vertices[start_pv_id], roframesPV[stop_rof] - roframesPV[romin]);
+};
+
+GPUdii() gpuSpan<const Cluster> getClustersOnLayer(const int rof,
+                                                   const int totROFs,
+                                                   const int layer,
+                                                   const int** roframesClus,
+                                                   const Cluster** clusters)
 {
   if (rof < 0 || rof >= totROFs) {
     return gpuSpan<const Cluster>();
@@ -360,6 +377,8 @@ GPUg() void computeLayerCellNeighboursKernel(
   int* neighboursIndexTable,
   int** cellsLUTs,
   gpuPair<int, int>* cellNeighbours,
+  const Tracklet** tracklets,
+  const int deltaROF,
   const float maxChi2ClusterAttachment,
   const float bz,
   const int layerIndex,
@@ -377,15 +396,29 @@ GPUg() void computeLayerCellNeighboursKernel(
       if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) { // Check if cells share the same tracklet
         break;
       }
+
+      if (deltaROF) {
+        const auto& trkl00 = tracklets[layerIndex][currentCellSeed.getFirstTrackletIndex()];
+        const auto& trkl01 = tracklets[layerIndex + 1][currentCellSeed.getSecondTrackletIndex()];
+        const auto& trkl10 = tracklets[layerIndex + 1][nextCellSeed.getFirstTrackletIndex()];
+        const auto& trkl11 = tracklets[layerIndex + 2][nextCellSeed.getSecondTrackletIndex()];
+        if ((o2::gpu::CAMath::Max(trkl00.getMaxRof(), o2::gpu::CAMath::Max(trkl01.getMaxRof(), o2::gpu::CAMath::Max(trkl10.getMaxRof(), trkl11.getMaxRof()))) -
+             o2::gpu::CAMath::Min(trkl00.getMinRof(), o2::gpu::CAMath::Min(trkl01.getMinRof(), o2::gpu::CAMath::Min(trkl10.getMinRof(), trkl11.getMinRof())))) > deltaROF) {
+          continue;
+        }
+      }
+
       if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
           !nextCellSeed.propagateTo(currentCellSeed.getX(), bz)) {
         continue;
       }
+
       float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed);
       if (chi2 > maxChi2ClusterAttachment) /// TODO: switch to the chi2 wrt cluster to avoid correlation
       {
         continue;
       }
+
       if constexpr (initRun) {
         atomicAdd(neighboursLUT + iNextCell, 1);
         neighboursIndexTable[iCurrentCellIndex]++;
@@ -412,6 +445,7 @@ GPUg() void computeLayerCellsKernel(
   const int layer,
   CellSeed* cells,
   int** cellsLUTs,
+  const int deltaROF,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
@@ -432,6 +466,9 @@ GPUg() void computeLayerCellsKernel(
         break;
       }
       const Tracklet& nextTracklet = tracklets[layer + 1][iNextTrackletIndex];
+      if (deltaROF && currentTracklet.getSpanRof(nextTracklet) > deltaROF) {
+        continue;
+      }
       const float deltaTanLambda{o2::gpu::CAMath::Abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
 
       if (deltaTanLambda / cellDeltaTanLambdaSigma < nSigmaCut) {
@@ -515,9 +552,12 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
 {
   const int phiBins{utils->getNphiBins()};
   const int zBins{utils->getNzBins()};
+  const int tableSize{phiBins * zBins + 1};
   for (unsigned int iROF{blockIdx.x}; iROF < endROF - startROF; iROF += gridDim.x) {
-    const short rof0 = iROF + startROF;
-    auto primaryVertices = getPrimaryVertices(rof0, rofPV, totalROFs, multMask, vertices);
+    const short pivotROF = iROF + startROF;
+    const short minROF = o2::gpu::CAMath::Max(startROF, static_cast<int>(pivotROF - deltaROF));
+    const short maxROF = o2::gpu::CAMath::Min(endROF - 1, static_cast<int>(pivotROF + deltaROF));
+    auto primaryVertices = getPrimaryVertices(minROF, maxROF, rofPV, totalROFs, vertices);
     if (primaryVertices.empty()) {
       continue;
     }
@@ -526,17 +566,17 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
     if ((endVtx - startVtx) <= 0) {
       continue;
     }
-    const short minROF = o2::gpu::CAMath::Max(startROF, static_cast<int>(rof0 - deltaROF));
-    const short maxROF = o2::gpu::CAMath::Min(endROF - 1, static_cast<int>(rof0 + deltaROF));
-    auto clustersCurrentLayer = getClustersOnLayer(rof0, totalROFs, layerIndex, ROFClusters, clusters);
+
+    auto clustersCurrentLayer = getClustersOnLayer(pivotROF, totalROFs, layerIndex, ROFClusters, clusters);
     if (clustersCurrentLayer.empty()) {
       continue;
     }
 
     for (int currentClusterIndex = threadIdx.x; currentClusterIndex < clustersCurrentLayer.size(); currentClusterIndex += blockDim.x) {
+
       unsigned int storedTracklets{0};
       const auto& currentCluster{clustersCurrentLayer[currentClusterIndex]};
-      const int currentSortedIndex{ROFClusters[layerIndex][rof0] + currentClusterIndex};
+      const int currentSortedIndex{ROFClusters[layerIndex][pivotROF] + currentClusterIndex};
       if (usedClusters[layerIndex][currentCluster.clusterId]) {
         continue;
       }
@@ -564,9 +604,8 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
           phiBinsNum += phiBins;
         }
 
-        const int tableSize{phiBins * zBins + 1};
-        for (short rof1{minROF}; rof1 <= maxROF; ++rof1) {
-          auto clustersNextLayer = getClustersOnLayer(rof1, totalROFs, layerIndex + 1, ROFClusters, clusters);
+        for (short targetROF{minROF}; targetROF <= maxROF; ++targetROF) {
+          auto clustersNextLayer = getClustersOnLayer(targetROF, totalROFs, layerIndex + 1, ROFClusters, clusters);
           if (clustersNextLayer.empty()) {
             continue;
           }
@@ -574,8 +613,8 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
             int iPhiBin = (selectedBinsRect.y + iPhiCount) % phiBins;
             const int firstBinIndex{utils->getBinIndex(selectedBinsRect.x, iPhiBin)};
             const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
-            const int firstRowClusterIndex = indexTables[layerIndex + 1][(rof1)*tableSize + firstBinIndex];
-            const int maxRowClusterIndex = indexTables[layerIndex + 1][(rof1)*tableSize + maxBinIndex];
+            const int firstRowClusterIndex = indexTables[layerIndex + 1][(targetROF)*tableSize + firstBinIndex];
+            const int maxRowClusterIndex = indexTables[layerIndex + 1][(targetROF)*tableSize + maxBinIndex];
             for (int nextClusterIndex{firstRowClusterIndex}; nextClusterIndex < maxRowClusterIndex; ++nextClusterIndex) {
               if (nextClusterIndex >= clustersNextLayer.size()) {
                 break;
@@ -592,8 +631,8 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
                 } else {
                   const float phi{o2::gpu::CAMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate)};
                   const float tanL{(currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius)};
-                  const int nextSortedIndex{ROFClusters[layerIndex + 1][rof1] + nextClusterIndex};
-                  new (tracklets[layerIndex] + trackletsLUT[layerIndex][currentSortedIndex] + storedTracklets) Tracklet{currentSortedIndex, nextSortedIndex, tanL, phi, rof0, rof1};
+                  const int nextSortedIndex{ROFClusters[layerIndex + 1][targetROF] + nextClusterIndex};
+                  new (tracklets[layerIndex] + trackletsLUT[layerIndex][currentSortedIndex] + storedTracklets) Tracklet{currentSortedIndex, nextSortedIndex, tanL, phi, pivotROF, targetROF};
                 }
                 ++storedTracklets;
               }
@@ -1018,6 +1057,7 @@ void countCellsHandler(
   CellSeed* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
+  const int deltaROF,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
@@ -1035,6 +1075,7 @@ void countCellsHandler(
     layer,                    // const int
     cells,                    // CellSeed*
     cellsLUTsArrayDevice,     // int**
+    deltaROF,                 // const int
     bz,                       // const float
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
@@ -1053,6 +1094,7 @@ void computeCellsHandler(
   CellSeed* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
+  const int deltaROF,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
@@ -1070,6 +1112,7 @@ void computeCellsHandler(
     layer,                    // const int
     cells,                    // CellSeed*
     cellsLUTsArrayDevice,     // int**
+    deltaROF,                 // const int
     bz,                       // const float
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
@@ -1081,6 +1124,8 @@ unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                         int** cellsLUTs,
                                         gpuPair<int, int>* cellNeighbours,
                                         int* neighboursIndexTable,
+                                        const Tracklet** tracklets,
+                                        const int deltaROF,
                                         const float maxChi2ClusterAttachment,
                                         const float bz,
                                         const int layerIndex,
@@ -1096,12 +1141,13 @@ unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
     neighboursIndexTable,
     cellsLUTs,
     cellNeighbours,
+    tracklets,
+    deltaROF,
     maxChi2ClusterAttachment,
     bz,
     layerIndex,
     nCells,
     maxCellNeighbours);
-
   gpu::cubInclusiveScanInPlace(neighboursLUT, nCellsNext);
   gpu::cubExclusiveScanInPlace(neighboursIndexTable, nCells + 1);
   unsigned int nNeighbours;
@@ -1114,6 +1160,8 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   int** cellsLUTs,
                                   gpuPair<int, int>* cellNeighbours,
                                   int* neighboursIndexTable,
+                                  const Tracklet** tracklets,
+                                  const int deltaROF,
                                   const float maxChi2ClusterAttachment,
                                   const float bz,
                                   const int layerIndex,
@@ -1130,6 +1178,8 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
     neighboursIndexTable,
     cellsLUTs,
     cellNeighbours,
+    tracklets,
+    deltaROF,
     maxChi2ClusterAttachment,
     bz,
     layerIndex,

From 0e237624c33f47edd65930a27f6f7131fb827744 Mon Sep 17 00:00:00 2001
From: jmyrcha <julian.myrcha@cern.ch>
Date: Tue, 5 Aug 2025 09:01:12 +0200
Subject: [PATCH 0668/1764] added socket communication (#14529)

* added socket communication

* fixed timeout problem

* changed Location parameter to reference

* clang

---------

Co-authored-by: Julian Myrcha <jmyrcha@cern.ch>
---
 .../DataConverter/CMakeLists.txt              |   2 +
 .../Location.h                                |  70 +++++++
 .../VisualisationEventJSONSerializer.h        |   2 +-
 .../VisualisationEventOpenGLSerializer.h      |   2 +-
 .../VisualisationEventROOTSerializer.h        |   2 +-
 .../VisualisationEventSerializer.h            |   3 +-
 .../DataConverter/src/Location.cxx            | 182 ++++++++++++++++++
 .../src/VisualisationEventJSONSerializer.cxx  |   3 +-
 .../VisualisationEventOpenGLSerializer.cxx    |  52 ++---
 .../src/VisualisationEventROOTSerializer.cxx  |   3 +-
 .../DataConverter/src/converter.cxx           | 104 +++++++---
 .../include/EveWorkflow/EveWorkflowHelper.h   |   2 +-
 .../include/EveWorkflow/FileProducer.h        |   5 +-
 .../include/EveWorkflow/O2DPLDisplay.h        |  42 +++-
 .../Workflow/src/AO2DConverter.cxx            |   4 +-
 .../Workflow/src/EveWorkflowHelper.cxx        | 148 +++++++++-----
 .../Workflow/src/FileProducer.cxx             |  14 +-
 .../Workflow/src/O2DPLDisplay.cxx             |  17 +-
 18 files changed, 536 insertions(+), 121 deletions(-)
 create mode 100644 EventVisualisation/DataConverter/include/EventVisualisationDataConverter/Location.h
 create mode 100644 EventVisualisation/DataConverter/src/Location.cxx

diff --git a/EventVisualisation/DataConverter/CMakeLists.txt b/EventVisualisation/DataConverter/CMakeLists.txt
index 778a3b6182aaf..b0198000c3dbe 100644
--- a/EventVisualisation/DataConverter/CMakeLists.txt
+++ b/EventVisualisation/DataConverter/CMakeLists.txt
@@ -18,6 +18,7 @@ o2_add_library(EventVisualisationDataConverter
                        src/VisualisationEventJSONSerializer.cxx
                        src/VisualisationEventROOTSerializer.cxx
                        src/VisualisationEventOpenGLSerializer.cxx
+                       src/Location.cxx
                PUBLIC_LINK_LIBRARIES RapidJSON::RapidJSON
                         O2::ReconstructionDataFormats
                         O2::DataFormatsParameters
@@ -33,6 +34,7 @@ o2_add_executable(eve-convert
                 src/VisualisationTrack.cxx
                 src/VisualisationCluster.cxx
                 src/VisualisationCalo.cxx
+                src/Location.cxx
         PUBLIC_LINK_LIBRARIES
                 O2::EventVisualisationView
                 RapidJSON::RapidJSON
diff --git a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/Location.h b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/Location.h
new file mode 100644
index 0000000000000..72ebc36b1dd31
--- /dev/null
+++ b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/Location.h
@@ -0,0 +1,70 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file    Location.h
+/// \author  Julian Myrcha
+///
+
+#ifndef O2EVE_LOCATION_H
+#define O2EVE_LOCATION_H
+
+#include <string>
+#include <fstream>
+#include <iosfwd>
+
+namespace o2::event_visualisation
+{
+struct LocationParams {
+  std::string fileName;
+  int port = -1;
+  int timeout = 100;
+  std::string host = "localhost";
+  bool toFile = true;
+  bool toSocket = true;
+};
+class Location
+{
+  std::ofstream* mOut;
+  int mClientSocket;
+  bool mToFile;
+  bool mToSocket;
+  std::string mFileName;
+  int mPort;
+  int mTimeout;
+  std::string mHostName;
+
+ public:
+  explicit Location(const LocationParams& params)
+  {
+    this->mFileName = params.fileName;
+    this->mToFile = !params.fileName.empty() && params.toFile;
+    this->mToSocket = params.port != -1 && params.toSocket;
+    this->mOut = nullptr;
+    this->mPort = params.port;
+    this->mHostName = params.host;
+    this->mClientSocket = -1;
+    this->mTimeout = params.timeout;
+  }
+  ~Location()
+  {
+    close();
+  }
+  void open();
+  void close();
+  void write(char* buf, std::streamsize size);
+  [[nodiscard]] std::string fileName() const { return this->mFileName; }
+  [[nodiscard]] std::string hostName() const { return this->mHostName; }
+  [[nodiscard]] int port() const { return this->mPort; }
+};
+} // namespace o2::event_visualisation
+
+#endif // O2EVE_LOCATION_H
diff --git a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventJSONSerializer.h b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventJSONSerializer.h
index c08009215d9fe..8f4b0d2bd8375 100644
--- a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventJSONSerializer.h
+++ b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventJSONSerializer.h
@@ -56,7 +56,7 @@ class VisualisationEventJSONSerializer : public VisualisationEventSerializer
 
  public:
   bool fromFile(VisualisationEvent& event, std::string fileName) override;
-  void toFile(const VisualisationEvent& event, std::string fileName) override;
+  void toFile(const VisualisationEvent& event, Location& location) override;
   ~VisualisationEventJSONSerializer() override = default;
 };
 
diff --git a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventOpenGLSerializer.h b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventOpenGLSerializer.h
index 3e6d3809cb709..8af91d6964a46 100644
--- a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventOpenGLSerializer.h
+++ b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventOpenGLSerializer.h
@@ -38,7 +38,7 @@ class VisualisationEventOpenGLSerializer : public VisualisationEventSerializer
  public:
   const std::string serializerName() const override { return std::string("VisualisationEventOpenGLSerializer"); }
   bool fromFile(VisualisationEvent& event, std::string fileName) override;
-  void toFile(const VisualisationEvent& event, std::string fileName) override;
+  void toFile(const VisualisationEvent& event, Location& location) override;
   ~VisualisationEventOpenGLSerializer() override = default;
 };
 
diff --git a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventROOTSerializer.h b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventROOTSerializer.h
index e6408fb1c6c3f..3a5cf245f4816 100644
--- a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventROOTSerializer.h
+++ b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventROOTSerializer.h
@@ -44,7 +44,7 @@ class VisualisationEventROOTSerializer : public VisualisationEventSerializer
  public:
   [[nodiscard]] const std::string serializerName() const override { return std::string("VisualisationEventROOTSerializer"); }
   bool fromFile(VisualisationEvent& event, std::string fileName) override;
-  void toFile(const VisualisationEvent& event, std::string fileName) override;
+  void toFile(const VisualisationEvent& event, Location& location) override;
   ~VisualisationEventROOTSerializer() override = default;
 };
 
diff --git a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventSerializer.h b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventSerializer.h
index 5a6d902084ebf..80cb3c0b131a0 100644
--- a/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventSerializer.h
+++ b/EventVisualisation/DataConverter/include/EventVisualisationDataConverter/VisualisationEventSerializer.h
@@ -17,6 +17,7 @@
 #define O2EVE_VISUALISATIONEVENTSERIALIZER_H
 
 #include "EventVisualisationDataConverter/VisualisationEvent.h"
+#include "EventVisualisationDataConverter/Location.h"
 #include <string>
 #include <map>
 
@@ -45,7 +46,7 @@ class VisualisationEventSerializer
   static o2::dataformats::GlobalTrackID deserialize(unsigned source, unsigned index, unsigned flags);
   static VisualisationEventSerializer* getInstance(std::string ext) { return instances[ext]; }
   virtual bool fromFile(VisualisationEvent& event, std::string fileName) = 0;
-  virtual void toFile(const VisualisationEvent& event, std::string fileName) = 0;
+  virtual void toFile(const VisualisationEvent& event, Location& location) = 0;
   virtual const std::string serializerName() const = 0;
   virtual ~VisualisationEventSerializer() = default;
 };
diff --git a/EventVisualisation/DataConverter/src/Location.cxx b/EventVisualisation/DataConverter/src/Location.cxx
new file mode 100644
index 0000000000000..416412c742252
--- /dev/null
+++ b/EventVisualisation/DataConverter/src/Location.cxx
@@ -0,0 +1,182 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file    Location.cxx
+/// \author  Julian Myrcha
+///
+
+#include "EventVisualisationDataConverter/Location.h"
+#include <fairlogger/Logger.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <ctime>
+
+using namespace std;
+
+namespace o2::event_visualisation
+{
+
+int connect_with_timeout(const int socket, const struct sockaddr* addr, socklen_t addrlen, const unsigned int timeout_ms)
+{
+  int connection = 0;
+  // Setting O_NONBLOCK
+  int socket_flags_before;
+  if ((socket_flags_before = fcntl(socket, F_GETFL, 0) < 0)) {
+    return -1;
+  }
+  if (fcntl(socket, F_SETFL, socket_flags_before | O_NONBLOCK) < 0) {
+    return -1;
+  }
+  do {
+    if (connect(socket, addr, addrlen) < 0) {
+      if ((errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
+        connection = -1; // error
+      } else {           // wait for complete
+        // deadline 'timeout' ms from now
+        timespec now; // NOLINT(*-pro-type-member-init)
+        if (clock_gettime(CLOCK_MONOTONIC, &now) < 0) {
+          connection = -1;
+          break;
+        }
+        const timespec deadline = {.tv_sec = now.tv_sec,
+                                   .tv_nsec = now.tv_nsec + timeout_ms * 1000000l};
+        do {
+          if (clock_gettime(CLOCK_MONOTONIC, &now) < 0) {
+            connection = -1;
+            break;
+          }
+          // compute remaining deadline
+          const int ms_until_deadline = static_cast<int>((deadline.tv_sec - now.tv_sec) * 1000l + (deadline.tv_nsec - now.tv_nsec) / 1000000l);
+          if (ms_until_deadline < 0) {
+            connection = 0;
+            break;
+          }
+          pollfd connectionPool[] = {{.fd = socket, .events = POLLOUT}};
+          connection = poll(connectionPool, 1, ms_until_deadline);
+
+          if (connection > 0) { // confirm the success
+            int error = 0;
+            socklen_t len = sizeof(error);
+            if (getsockopt(socket, SOL_SOCKET, SO_ERROR, &error, &len) == 0) {
+              errno = error;
+            }
+            if (error != 0) {
+              connection = -1;
+            }
+          }
+        } while (connection == -1 && errno == EINTR); // If interrupted, try again.
+        if (connection == 0) {
+          errno = ETIMEDOUT;
+          connection = -1;
+        }
+      }
+    }
+  } while (false);
+  // Restore socket state
+  if (fcntl(socket, F_SETFL, socket_flags_before) < 0) {
+    return -1;
+  }
+  return connection;
+}
+
+void Location::open()
+{
+  if (this->mToFile) {
+    this->mOut = new std::ofstream(mFileName, std::ios::out | std::ios::binary);
+  }
+  if (this->mToSocket) {
+    // resolve host name
+    sockaddr_in serverAddress; // NOLINT(*-pro-type-member-init)
+    serverAddress.sin_family = AF_INET;
+    serverAddress.sin_port = htons(this->mPort); // Port number
+
+    // ask once
+    static auto server = gethostbyname(this->mHostName.c_str());
+    if (server == nullptr) {
+      LOGF(info, "Error no such host %s", this->mHostName.c_str());
+      return;
+    };
+
+    bcopy((char*)server->h_addr,
+          (char*)&serverAddress.sin_addr.s_addr,
+          server->h_length);
+
+    // Connect to the server
+    this->mClientSocket = socket(AF_INET, SOCK_STREAM, 0);
+    if (this->mClientSocket == -1) {
+      LOGF(info, "Error creating socket");
+      return;
+    }
+
+    if (connect_with_timeout(this->mClientSocket, (sockaddr*)&serverAddress,
+                             sizeof(serverAddress), this->mTimeout) == -1) {
+      LOGF(info, "Error connecting to %s:%d", this->mHostName.c_str(), this->mPort);
+      ::close(this->mClientSocket);
+      this->mClientSocket = -1;
+      return;
+    }
+    try {
+      char buf[256] = "SEND:";
+      strncpy(buf + 6, this->mFileName.c_str(), sizeof(buf) - 7);
+      strncpy(buf + sizeof(buf) - 6, "ALICE", 6);
+      auto real = send(this->mClientSocket, buf, sizeof(buf), 0);
+      if (real != sizeof(buf)) {
+        throw real;
+      }
+    } catch (...) {
+      ::close(this->mClientSocket);
+      this->mClientSocket = -1;
+      LOGF(info, "Error sending file name to %s:%d", this->mHostName.c_str(), this->mPort);
+    }
+  }
+}
+
+void Location::close()
+{
+  if (this->mToFile && this->mOut) {
+    this->mOut->close();
+    delete this->mOut;
+    this->mOut = nullptr;
+  }
+  if (this->mToSocket && this->mClientSocket != -1) {
+    ::close(this->mClientSocket);
+    this->mClientSocket = -1;
+  }
+}
+
+void Location::write(char* buf, std::streamsize size)
+{
+  if (size == 0) {
+    return;
+  }
+  if (this->mToFile && this->mOut) {
+    this->mOut->write(buf, size);
+  }
+  if (this->mToSocket && this->mClientSocket != -1) {
+    LOGF(info, "Location::write() socket %s ++++++++++++++++++++++", fileName());
+    try {
+      auto real = send(this->mClientSocket, buf, size, 0);
+      if (real != size) {
+        throw real;
+      }
+    } catch (...) {
+      ::close(this->mClientSocket);
+      this->mClientSocket = -1;
+      LOGF(info, "Error sending data to %s:%d", this->mHostName.c_str(), this->mPort);
+    }
+  }
+}
+
+} // namespace o2::event_visualisation
\ No newline at end of file
diff --git a/EventVisualisation/DataConverter/src/VisualisationEventJSONSerializer.cxx b/EventVisualisation/DataConverter/src/VisualisationEventJSONSerializer.cxx
index 612ddaf8717f4..cce3e6b4a2c58 100644
--- a/EventVisualisation/DataConverter/src/VisualisationEventJSONSerializer.cxx
+++ b/EventVisualisation/DataConverter/src/VisualisationEventJSONSerializer.cxx
@@ -29,8 +29,9 @@ using namespace rapidjson;
 namespace o2::event_visualisation
 {
 
-void VisualisationEventJSONSerializer::toFile(const VisualisationEvent& event, std::string fileName)
+void VisualisationEventJSONSerializer::toFile(const VisualisationEvent& event, Location& location)
 {
+  std::string fileName = location.fileName();
   std::string json = toJson(event);
   std::ofstream out(fileName);
   out << json;
diff --git a/EventVisualisation/DataConverter/src/VisualisationEventOpenGLSerializer.cxx b/EventVisualisation/DataConverter/src/VisualisationEventOpenGLSerializer.cxx
index 4c907eeda0291..1d22a02df61af 100644
--- a/EventVisualisation/DataConverter/src/VisualisationEventOpenGLSerializer.cxx
+++ b/EventVisualisation/DataConverter/src/VisualisationEventOpenGLSerializer.cxx
@@ -20,6 +20,7 @@
 #include <iostream>
 #include <fstream>
 #include <filesystem>
+#include "EventVisualisationDataConverter/Location.h"
 
 namespace o2::event_visualisation
 {
@@ -82,8 +83,9 @@ const auto CALT = "CALT"; // calo PID
 
 const auto FINE = "FINE"; //
 
-void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event, std::string fileName)
+void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event, Location& location)
 {
+  std::string fileName = location.fileName();
   static const std::vector<std::string> det_coma = {
     "ITS", "TPC", "TRD", "TOF", "PHS", "CPV", "EMC", "HMP", "MFT", "MCH", "MID", "ZDC", "FT0", "FV0", "FDD", "ITS-TPC",
     "TPC-TOF", "TPC-TRD", "MFT-MCH", "ITS-TPC-TRD", "ITS-TPC-TOF", "TPC-TRD-TOF", "MFT-MCH-MID", "ITS-TPC-TRD-TOF", "ITS-AB", "CTP",
@@ -91,7 +93,9 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
   std::ostringstream buf;
   constexpr auto SIGSIZE = 512;
   unsigned char data[SIGSIZE];
-  std::ofstream out(fileName, std::ios::out | std::ios::binary);
+  // std::ofstream out(fileName, std::ios::out | std::ios::binary);
+
+  location.open();
   // head --bytes 512 fileName.eve
   buf << "eve" << std::endl;
   buf << "version=1.00" << std::endl;
@@ -104,7 +108,7 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
   memcpy((char*)&data[0], buf.str().c_str(), SIGSIZE);
   data[SIGSIZE - 2] = '\n';
   data[SIGSIZE - 1] = 0;
-  out.write((char*)&data[0], SIGSIZE); // <----0 SIGN
+  location.write((char*)&data[0], SIGSIZE); // <----0 SIGN
 
   const auto trackNo = event.getTracksSpan().size();
   int phsCount = 0;
@@ -140,7 +144,7 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
     head[Header::emcCount] = emcCount;
     head[Header::primaryVertex] = event.getPrimaryVertex();
     head[Header::tfCounter] = event.getTfCounter();
-    out.write(static_cast<char*>(chunkHEAD), chunkSize(chunkHEAD)); // <----1 HEAD
+    location.write(static_cast<char*>(chunkHEAD), chunkSize(chunkHEAD)); // <----1 HEAD
     free(chunkHEAD);
   }
 
@@ -171,15 +175,15 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
       celm[index] = track.getClusterCount();
       index++;
     }
-    out.write(static_cast<char*>(chunkTTYP), chunkSize(chunkTTYP)); // <----2 TTYP
+    location.write(static_cast<char*>(chunkTTYP), chunkSize(chunkTTYP)); // <----2 TTYP
     free(chunkTTYP);
-    out.write(static_cast<char*>(chunkTELM), chunkSize(chunkTELM)); // <----3 TELM
+    location.write(static_cast<char*>(chunkTELM), chunkSize(chunkTELM)); // <----3 TELM
     free(chunkTELM);
-    out.write(static_cast<char*>(chunkCELM), chunkSize(chunkCELM)); // <----3 CELM
+    location.write(static_cast<char*>(chunkCELM), chunkSize(chunkCELM)); // <----3 CELM
     free(chunkCELM);
-    out.write(static_cast<char*>(chunkTGID), chunkSize(chunkTGID)); // <----3 GIND
+    location.write(static_cast<char*>(chunkTGID), chunkSize(chunkTGID)); // <----3 GIND
     free(chunkTGID);
-    out.write(static_cast<char*>(chunkTPID), chunkSize(chunkTPID)); // <----3 TPID (tracks pid)
+    location.write(static_cast<char*>(chunkTPID), chunkSize(chunkTPID)); // <----3 TPID (tracks pid)
     free(chunkTPID);
   }
 
@@ -230,17 +234,17 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
         cxyz[cidx++] = track.getClustersSpan()[i].Z();
       }
     }
-    out.write(static_cast<char*>(chunkTXYZ), chunkSize(chunkTXYZ)); // <----4 TXYZ
+    location.write(static_cast<char*>(chunkTXYZ), chunkSize(chunkTXYZ)); // <----4 TXYZ
     free(chunkTXYZ);
-    out.write(static_cast<char*>(chunkCXYZ), chunkSize(chunkCXYZ)); // <----4 CXYZ
+    location.write(static_cast<char*>(chunkCXYZ), chunkSize(chunkCXYZ)); // <----4 CXYZ
     free(chunkCXYZ);
-    out.write(static_cast<char*>(chunkTIME), chunkSize(chunkTIME)); // <----4 TIME
+    location.write(static_cast<char*>(chunkTIME), chunkSize(chunkTIME)); // <----4 TIME
     free(chunkTIME);
-    out.write(static_cast<char*>(chunkSXYZ), chunkSize(chunkSXYZ)); // <----4 SXYZ
+    location.write(static_cast<char*>(chunkSXYZ), chunkSize(chunkSXYZ)); // <----4 SXYZ
     free(chunkSXYZ);
-    out.write(static_cast<char*>(chunkCRGE), chunkSize(chunkCRGE)); // <----4 CRGE
+    location.write(static_cast<char*>(chunkCRGE), chunkSize(chunkCRGE)); // <----4 CRGE
     free(chunkCRGE);
-    out.write(static_cast<char*>(chunkATPE), chunkSize(chunkATPE)); // <----4 CRGE
+    location.write(static_cast<char*>(chunkATPE), chunkSize(chunkATPE)); // <----4 CRGE
     free(chunkATPE);
   }
 
@@ -260,11 +264,11 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
       uxyz[idx++] = c.Y();
       uxyz[idx++] = c.Z();
     }
-    out.write(static_cast<char*>(chunkUGID), chunkSize(chunkUGID)); //
+    location.write(static_cast<char*>(chunkUGID), chunkSize(chunkUGID)); //
     free(chunkUGID);
-    out.write(static_cast<char*>(chunkUTIM), chunkSize(chunkUTIM)); //
+    location.write(static_cast<char*>(chunkUTIM), chunkSize(chunkUTIM)); //
     free(chunkUTIM);
-    out.write(static_cast<char*>(chunkUXYZ), chunkSize(chunkUXYZ)); //
+    location.write(static_cast<char*>(chunkUXYZ), chunkSize(chunkUXYZ)); //
     free(chunkUXYZ);
   }
 
@@ -300,22 +304,22 @@ void VisualisationEventOpenGLSerializer::toFile(const VisualisationEvent& event,
       }
     }
 
-    out.write((char*)chunkCALO, chunkSize(chunkCALO)); //
+    location.write((char*)chunkCALO, chunkSize(chunkCALO)); //
     free(chunkCALO);
-    out.write((char*)chunkCALP, chunkSize(chunkCALP)); //
+    location.write((char*)chunkCALP, chunkSize(chunkCALP)); //
     free(chunkCALP);
-    out.write((char*)chunkCALG, chunkSize(chunkCALG)); //
+    location.write((char*)chunkCALG, chunkSize(chunkCALG)); //
     free(chunkCALG);
-    out.write((char*)chunkCALT, chunkSize(chunkCALT)); //
+    location.write((char*)chunkCALT, chunkSize(chunkCALT)); //
     free(chunkCALT);
   }
 
   {
     const auto chunkFINE = createChunk(FINE, 0);
-    out.write(static_cast<char*>(chunkFINE), chunkSize(chunkFINE)); // <----5 FINE
+    location.write(static_cast<char*>(chunkFINE), chunkSize(chunkFINE)); // <----5 FINE
     free(chunkFINE);
   }
-  out.close();
+  location.close();
 }
 
 void* VisualisationEventOpenGLSerializer::createChunk(const char* lbl, unsigned size)
diff --git a/EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx b/EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx
index 730af08b5fd61..8c1a84c1bf85e 100644
--- a/EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx
+++ b/EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx
@@ -93,8 +93,9 @@ bool VisualisationEventROOTSerializer::existUInt64(TFile& f, const char* name)
   return true;
 }
 
-void VisualisationEventROOTSerializer::toFile(const VisualisationEvent& event, std::string fileName)
+void VisualisationEventROOTSerializer::toFile(const VisualisationEvent& event, Location& location)
 {
+  std::string fileName = location.fileName();
   TFile f(fileName.c_str(), "recreate");
 
   saveInt("runNumber", event.mRunNumber);
diff --git a/EventVisualisation/DataConverter/src/converter.cxx b/EventVisualisation/DataConverter/src/converter.cxx
index a0820d2e6feef..7bbada4bbb5e9 100644
--- a/EventVisualisation/DataConverter/src/converter.cxx
+++ b/EventVisualisation/DataConverter/src/converter.cxx
@@ -16,31 +16,40 @@
 #include "EventVisualisationDataConverter/VisualisationEvent.h"
 #include "EventVisualisationView/Initializer.h"
 #include "EventVisualisationView/Options.h"
+#include <EventVisualisationDataConverter/Location.h>
 #include <EventVisualisationDataConverter/VisualisationEventJSONSerializer.h>
 #include <EventVisualisationDataConverter/VisualisationEventROOTSerializer.h>
 #include <EventVisualisationDataConverter/VisualisationEventOpenGLSerializer.h>
 #include <EventVisualisationBase/DirectoryLoader.h>
-#include <TApplication.h>
 #include <TEveManager.h>
-#include <TEnv.h>
 #include <filesystem>
 #include <fairlogger/Logger.h>
 #include <csignal>
 #include <thread>
 #include <chrono>
 
+#include <boost/program_options.hpp>
+#include <boost/program_options/options_description.hpp>
+#include <boost/program_options/variables_map.hpp>
+
 using namespace std::chrono_literals;
 
 // source file name, destination (not existing) file name, if limit > 0 then limit EACH type of data
-int singleFileConversion(const std::string& src, const std::string& dst, const int limit = -1)
+int singleFileConversion(const std::string& src, o2::event_visualisation::Location& dst, const int limit = -1)
 {
-  LOGF(info, "Translate: %s -> %s", src, dst);
+  LOGF(info, "Translate: %s -> %s", src, dst.fileName());
   o2::event_visualisation::VisualisationEvent vEvent;
 
   auto srcSerializer = o2::event_visualisation::VisualisationEventSerializer::getInstance(
     std::filesystem::path(src).extension());
+  auto dstExtension = std::filesystem::path(
+                        src)
+                        .extension(); // if there is no destination, there will be no extension change
+  if (!dst.fileName().empty()) {
+    dstExtension = std::filesystem::path(dst.fileName()).extension();
+  }
   auto dstSerializer = o2::event_visualisation::VisualisationEventSerializer::getInstance(
-    std::filesystem::path(dst).extension());
+    dstExtension);
 
   std::chrono::time_point currentTime = std::chrono::high_resolution_clock::now();
   std::chrono::time_point endTime = std::chrono::high_resolution_clock::now();
@@ -61,8 +70,9 @@ int singleFileConversion(const std::string& src, const std::string& dst, const i
 
 // reads source folder files, find missing files in destination folder and convert them
 // source folder (/path-to-folder/.ext1) , destination folder (/path-to-folder/.ext2)
-int folderConversion(const std::string& srcFolder, const std::string& dstFolder)
+int folderConversion(const std::string& srcFolder, const o2::event_visualisation::Location& dstFolderLocation)
 {
+  const std::string dstFolder = dstFolderLocation.fileName();
   std::vector<std::string> supported = {".json", ".root", ".eve"};
   auto ext1 = srcFolder.substr(srcFolder.rfind('.'));
   auto ext2 = dstFolder.substr(dstFolder.rfind('.'));
@@ -109,7 +119,13 @@ int folderConversion(const std::string& srcFolder, const std::string& dstFolder)
     auto match = e.substr(0, e.size() - ext1.size()) + ext2;
     if (destinationList.end() == std::find(destinationList.begin(), destinationList.end(), match)) {
       // LOGF(info, "translate %s ->%s", src+e, dst+match);
-      singleFileConversion(src + e, dst + match);
+      o2::event_visualisation::Location location({.fileName = dst + match,
+                                                  .port = dstFolderLocation.port(),
+                                                  .host = dstFolderLocation.hostName()});
+      singleFileConversion(src + e, location);
+      ;
+      singleFileConversion(src + e, location);
+      ;
     }
   }
 
@@ -122,6 +138,10 @@ void my_handler(int s)
   exit(1);
 }
 
+namespace po = boost::program_options;
+
+using namespace std;
+
 int main(int argc, char** argv)
 {
   struct sigaction sigIntHandler {
@@ -133,25 +153,59 @@ int main(int argc, char** argv)
   sigaction(SIGINT, &sigIntHandler, nullptr);
   LOGF(info, "Welcome in O2 event conversion tool");
 
-  if (argc == 3) {
-    singleFileConversion(argv[1], argv[2]); // std::quick_exit(...
-    return 0;
-  }
-  if (argc == 4 and std::string(argv[1]) == std::string("-l")) {
-    singleFileConversion(argv[2], argv[3], 3); // std::quick_exit(...
-    return 0;
-  }
-  if (argc == 4 and std::string(argv[1]) == std::string("-f")) {
-    folderConversion(argv[2], argv[3]); // std::quick_exit(...
-    return 0;
-  }
-  if (argc == 4 and std::string(argv[1]) == std::string("-c")) {
-    while (true) {
-      std::this_thread::sleep_for(2000ms);
-      folderConversion(argv[2], argv[3]);
+  try {
+    int port;
+    string host;
+    int limit;
+    bool folderMode;
+    bool continuousMode;
+    vector<string> sources;
+    po::options_description desc("Allowed options");
+    desc.add_options()("help,h", "produce help message")("port", po::value(&port)->default_value(-1), "port number")("host", po::value(&host)->default_value("localhost"), "host name")("sources", po::value(&sources), "sources")("limit,l", po::value(&limit)->default_value(-1), "limit number of elements")("folder,f", po::bool_switch(&folderMode)->default_value(false), "convert folders")("continuous,c", po::bool_switch(&continuousMode)->default_value(false), "continuous folder mode");
+
+    po::positional_options_description p;
+    p.add("sources", 2);
+
+    po::variables_map vm;
+    po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
+    po::notify(vm);
+
+    if (vm.count("help")) {
+      cout << desc << "\n";
+      return 0;
+    }
+
+    if (vm.count("sources")) {
+      if (vm["sources"].as<vector<string>>().size() != 2) {
+        cout << "two positional parameters expected" << "\n";
+        return 0;
+      }
     }
-    return 0;
+    o2::event_visualisation::LocationParams locationParams;
+    locationParams.fileName = sources[1];
+    locationParams.port = port;
+    locationParams.host = host;
+
+    o2::event_visualisation::Location location(locationParams);
+
+    if (folderMode) {
+      folderConversion(sources[0], location);
+    } else if (continuousMode) {
+      while (true) {
+        std::this_thread::sleep_for(2000ms);
+        folderConversion(sources[0], location);
+      }
+    } else {
+      singleFileConversion(sources[0], location, limit);
+      return 0;
+    }
+  }
+
+  catch (exception& e) {
+    cerr << "error: " << e.what() << "\n";
+    return 1;
+  } catch (...) {
+    cerr << "Exception of unknown type!\n";
   }
-  LOGF(error, "two filename required, second should point to not existent file");
   return -1; // std::quick_exit(-1);
 }
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
index 1043ed5c303e0..6b3ec653c5350 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/EveWorkflowHelper.h
@@ -183,7 +183,7 @@ class EveWorkflowHelper
   bool isInsideITSROF(float t);
   bool isInsideTimeBracket(float t);
 
-  void save(const std::string& jsonPath, const std::string& ext, int numberOfFiles);
+  void save(const std::string& jsonPath, const std::string& ext, int numberOfFiles, const std::string& receiverHostname, int receiverPort, int receiverTimeout, bool useOnlyFiles, bool useOnlySockets);
 
   bool mUseTimeBracket = false;
   bool mUseEtaBracketTPC = false;
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h b/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
index d35ddcaa78711..e7203baceba2a 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/FileProducer.h
@@ -26,16 +26,15 @@ namespace event_visualisation
 class FileProducer
 {
  private:
-  size_t mFilesInFolder;
   std::string mPath;
   std::string mName;
   std::string mExt;
 
  public:
-  explicit FileProducer(const std::string& path, const std::string& ext, int filesInFolder = -1,
-                        const std::string& name = "tracks_{timestamp}_{hostname}_{pid}{ext}");
+  explicit FileProducer(const std::string& path, const std::string& ext, const std::string& name = "tracks_{timestamp}_{hostname}_{pid}{ext}");
 
   [[nodiscard]] std::string newFileName() const;
+  void reduceNumberOfFiles(size_t filesInFolder) const;
 };
 
 } // namespace event_visualisation
diff --git a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
index 1156d31d190ea..37d4155803e85 100644
--- a/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
+++ b/EventVisualisation/Workflow/include/EveWorkflow/O2DPLDisplay.h
@@ -50,7 +50,8 @@ class TPCFastTransform;
 class O2DPLDisplaySpec : public o2::framework::Task
 {
  public:
-  static constexpr auto allowedTracks = "ITS,TPC,MFT,MCH,MID,ITS-TPC,TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD,ITS-TPC-TRD-TOF,MCH-MID,MFT-MCH,MFT-MCH-MID,PHS,EMC,HMP";
+  static constexpr auto allowedTracks =
+    "ITS,TPC,MFT,MCH,MID,ITS-TPC,TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD,ITS-TPC-TRD-TOF,MCH-MID,MFT-MCH,MFT-MCH-MID,PHS,EMC,HMP";
   static constexpr auto allowedClusters = "ITS,TPC,TRD,TOF,MFT,MCH,MID,PHS,EMC,HMP";
 
   O2DPLDisplaySpec(bool disableWrite, bool useMC, o2::dataformats::GlobalTrackID::mask_t trkMask,
@@ -60,12 +61,33 @@ class O2DPLDisplaySpec : public o2::framework::Task
                    std::shared_ptr<o2::emcal::CalibLoader> emcCalibLoader,
                    const std::string& jsonPath, const std::string& ext,
                    std::chrono::milliseconds timeInterval,
-                   bool eveHostNameMatch)
-    : mDisableWrite(disableWrite), mUseMC(useMC), mTrkMask(trkMask), mClMask(clMask), mDataRequest(dataRequest), mGGCCDBRequest(gr), mEMCALCalibLoader(emcCalibLoader), mJsonPath(jsonPath), mExt(ext), mTimeInterval(timeInterval), mEveHostNameMatch(eveHostNameMatch), mRunType(o2::parameters::GRPECS::NONE)
-
+                   bool eveHostNameMatch,
+                   const std::string& receiverHostname,
+                   int receiverPort,
+                   int receiverTimeout,
+                   bool useOnlyFiles,
+                   bool useOnlySockets)
+    : mDisableWrite(disableWrite),
+      mUseMC(useMC),
+      mTrkMask(trkMask),
+      mClMask(clMask),
+      mDataRequest(dataRequest),
+      mGGCCDBRequest(gr),
+      mEMCALCalibLoader(emcCalibLoader),
+      mJsonPath(jsonPath),
+      mExt(ext),
+      mTimeInterval(timeInterval),
+      mEveHostNameMatch(eveHostNameMatch),
+      mRunType(o2::parameters::GRPECS::NONE),
+      mReceiverHostname(receiverHostname),
+      mReceiverPort(receiverPort),
+      mReceiverTimeout(receiverTimeout),
+      mUseOnlyFiles(useOnlyFiles),
+      mUseOnlySockets(useOnlySockets)
   {
     this->mTimeStamp = std::chrono::high_resolution_clock::now() - timeInterval; // first run meets condition
   }
+
   ~O2DPLDisplaySpec() override = default;
   void init(o2::framework::InitContext& ic) final;
   void run(o2::framework::ProcessingContext& pc) final;
@@ -81,7 +103,8 @@ class O2DPLDisplaySpec : public o2::framework::Task
   std::string mJsonPath;                   // folder where files are stored
   std::string mExt;                        // extension of created files (".json" or ".root")
   std::chrono::milliseconds mTimeInterval; // minimal interval between files in milliseconds
-  bool mPrimaryVertexTriggers;             // instead of drawing vertices with tracks (and maybe calorimeter triggers), draw vertices with calorimeter triggers (and maybe tracks)
+  bool mPrimaryVertexTriggers;
+  // instead of drawing vertices with tracks (and maybe calorimeter triggers), draw vertices with calorimeter triggers (and maybe tracks)
   int mEventCounter = 0;
   std::chrono::time_point<std::chrono::high_resolution_clock> mTimeStamp;
 
@@ -94,8 +117,13 @@ class O2DPLDisplaySpec : public o2::framework::Task
   std::shared_ptr<o2::emcal::CalibLoader> mEMCALCalibLoader;
   std::unique_ptr<o2::emcal::CellRecalibrator> mEMCALCalibrator;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-};
 
+  std::string mReceiverHostname;
+  int mReceiverPort;
+  int mReceiverTimeout;
+  bool mUseOnlyFiles;
+  bool mUseOnlySockets;
+};
 } // namespace o2::event_visualisation
 
-#endif
+#endif
\ No newline at end of file
diff --git a/EventVisualisation/Workflow/src/AO2DConverter.cxx b/EventVisualisation/Workflow/src/AO2DConverter.cxx
index d339b150265de..f54907c20d260 100644
--- a/EventVisualisation/Workflow/src/AO2DConverter.cxx
+++ b/EventVisualisation/Workflow/src/AO2DConverter.cxx
@@ -74,8 +74,8 @@ struct AO2DConverter {
     mHelper->mEvent.setTfCounter(mTfCounter);
     mHelper->mEvent.setFirstTForbit(mTfOrbit);
     mHelper->mEvent.setCreationTime(collision.collisionTime());
-
-    mHelper->save(jsonPath, ".root", -1);
+    const std::string hostname("localhost");
+    mHelper->save(jsonPath, ".root", -1, hostname, -1, 100, true, true);
     mHelper->clear();
   }
 };
diff --git a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
index 8c795dd01c79f..2bb3c220d67a0 100644
--- a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
+++ b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
@@ -23,6 +23,7 @@
 #include "ITStracking/IOUtils.h"
 #include "MFTTracking/IOUtils.h"
 #include "DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h"
+#include "DataFormatsMID/Track.h"
 #include "ReconstructionDataFormats/PrimaryVertex.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "DetectorsBase/Propagator.h"
@@ -120,7 +121,8 @@ double EveWorkflowHelper::bcDiffToTFTimeMUS(const o2::InteractionRecord& ir)
   auto bcd = ir.differenceInBC(startIR);
 
   if (uint64_t(bcd) > o2::constants::lhc::LHCMaxBunches * 256 && BCDiffErrCount < MAXBCDiffErrCount) {
-    LOGP(alarm, "ATTENTION: wrong bunches diff. {} for current IR {} wrt 1st TF orbit {}", bcd, ir.asString(), startIR.asString());
+    LOGP(alarm, "ATTENTION: wrong bunches diff. {} for current IR {} wrt 1st TF orbit {}", bcd, ir.asString(),
+         startIR.asString());
     BCDiffErrCount++;
   }
 
@@ -162,12 +164,14 @@ void EveWorkflowHelper::selectTracks(const CalibObjectsConst* calib,
       t0 *= this->mTPCBin2MUS;
       terr *= this->mTPCBin2MUS;
     } else if constexpr (isITSTrack<decltype(_tr)>()) {
-      t0 += 0.5f * this->mITSROFrameLengthMUS;          // ITS time is supplied in \mus as beginning of ROF
-      terr *= this->mITSROFrameLengthMUS;               // error is supplied as a half-ROF duration, convert to \mus
-    } else if constexpr (isMFTTrack<decltype(_tr)>()) { // Same for MFT
+      t0 += 0.5f * this->mITSROFrameLengthMUS; // ITS time is supplied in \mus as beginning of ROF
+      terr *= this->mITSROFrameLengthMUS;      // error is supplied as a half-ROF duration, convert to \mus
+    } else if constexpr (isMFTTrack<decltype(_tr)>()) {
+      // Same for MFT
       t0 += 0.5f * this->mMFTROFrameLengthMUS;
       terr *= this->mMFTROFrameLengthMUS;
-    } else if constexpr (!(isMCHTrack<decltype(_tr)>() || isMIDTrack<decltype(_tr)>() || isGlobalFwdTrack<decltype(_tr)>())) {
+    } else if constexpr (!(isMCHTrack<decltype(_tr)>() || isMIDTrack<decltype(_tr)>() ||
+                           isGlobalFwdTrack<decltype(_tr)>())) {
       // for all other tracks the time is in \mus with gaussian error
       terr *= mPVParams->nSigmaTimeTrack; // gaussian errors must be scaled by requested n-sigma
     }
@@ -197,7 +201,8 @@ void EveWorkflowHelper::selectTracks(const CalibObjectsConst* calib,
       }
     }
   };
-  auto creator = [&conf, maskTrk, this, &correctTrackTime, &flagTime, &fixMFTMCHMIDLabel](auto& trk, GID gid, float time, float terr) {
+  auto creator = [&conf, maskTrk, this, &correctTrackTime, &flagTime, &fixMFTMCHMIDLabel](auto& trk, GID gid,
+                                                                                          float time, float terr) {
     fixMFTMCHMIDLabel(gid);
 
     const auto src = gid.getSource();
@@ -234,7 +239,8 @@ void EveWorkflowHelper::selectTracks(const CalibObjectsConst* calib,
     bool checkTPCDCA = conf.TPCOnlyMaxDCARZ[0] > 0.f || conf.TPCOnlyMaxDCARZ[1] > 0.f;
     const auto trackIndex = mRecoCont->getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
     const auto vtxRefs = mRecoCont->getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
-    const auto totalPrimaryVertices = vtxRefs.size() - 1;               // The last entry is for unassigned tracks, ignore them
+    const auto totalPrimaryVertices =
+      vtxRefs.size() - 1; // The last entry is for unassigned tracks, ignore them
 
     for (std::size_t iv = 0; iv < totalPrimaryVertices; iv++) {
       const auto& pv = mRecoCont->getPrimaryVertex(iv);
@@ -259,15 +265,19 @@ void EveWorkflowHelper::selectTracks(const CalibObjectsConst* calib,
           if (gid.getSource() == o2::dataformats::GlobalTrackID::TPC && checkTPCDCA) {
             const auto& tpcTr = mRecoCont->getTPCTrack(gid);
             o2::track::TrackPar trc{tpcTr};
-            if (!tpcTr.hasBothSidesClusters()) { // need to correct track Z with this vertex time
-              float dz = (tpcTr.getTime0() * mTPCTimeBins2MUS - (pv.getTimeStamp().getTimeStamp() + mTPCVDrift->getTimeOffset())) * mTPCVDrift->getVDrift();
+            if (!tpcTr.hasBothSidesClusters()) {
+              // need to correct track Z with this vertex time
+              float dz = (tpcTr.getTime0() * mTPCTimeBins2MUS -
+                          (pv.getTimeStamp().getTimeStamp() + mTPCVDrift->getTimeOffset())) *
+                         mTPCVDrift->getVDrift();
               if (tpcTr.hasCSideClustersOnly()) {
                 dz = -dz;
               }
               trc.setZ(trc.getZ() + dz);
             }
             std::array<float, 2> dca;
-            if (!prop->propagateToDCA(pvXYZ, trc, prop->getNominalBz(), 10., o2::base::PropagatorF::MatCorrType::USEMatCorrNONE, &dca) ||
+            if (!prop->propagateToDCA(pvXYZ, trc, prop->getNominalBz(), 10.,
+                                      o2::base::PropagatorF::MatCorrType::USEMatCorrNONE, &dca) ||
                 (conf.TPCOnlyMaxDCARZ[1] > 0. && std::abs(dca[1]) > conf.TPCOnlyMaxDCARZ[1]) ||
                 (conf.TPCOnlyMaxDCARZ[0] > 0. && std::abs(dca[0]) > conf.TPCOnlyMaxDCARZ[0])) {
               continue;
@@ -303,7 +313,8 @@ void EveWorkflowHelper::selectTowers()
   if (conf.PVMode) {
     const auto trackIndex = mRecoCont->getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
     const auto vtxRefs = mRecoCont->getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
-    const auto totalPrimaryVertices = vtxRefs.size() - 1;               // The last entry is for unassigned tracks, ignore them
+    const auto totalPrimaryVertices =
+      vtxRefs.size() - 1; // The last entry is for unassigned tracks, ignore them
 
     for (std::size_t iv = 0; iv < totalPrimaryVertices; iv++) {
       const auto& vtref = vtxRefs[iv];
@@ -315,7 +326,8 @@ void EveWorkflowHelper::selectTowers()
         mPrimaryVertexTriggerGIDs[iv].emplace_back(GID{static_cast<unsigned int>(i), GID::HMP});
       }
 
-      const auto triggersPHOS = gsl::span(trackIndex.data() + vtref.getFirstEntryOfSource(GID::PHS), vtref.getEntriesOfSource(GID::PHS));
+      const auto triggersPHOS = gsl::span(trackIndex.data() + vtref.getFirstEntryOfSource(GID::PHS),
+                                          vtref.getEntriesOfSource(GID::PHS));
 
       for (const auto& tvid : triggersPHOS) {
         mTotalDataTypes[GID::PHS]++;
@@ -327,7 +339,8 @@ void EveWorkflowHelper::selectTowers()
         }
       }
 
-      const auto triggersEMCAL = gsl::span(trackIndex.data() + vtref.getFirstEntryOfSource(GID::EMC), vtref.getEntriesOfSource(GID::EMC));
+      const auto triggersEMCAL = gsl::span(trackIndex.data() + vtref.getFirstEntryOfSource(GID::EMC),
+                                           vtref.getEntriesOfSource(GID::EMC));
 
       for (const auto& tvid : triggersEMCAL) {
         mTotalDataTypes[GID::EMC]++;
@@ -416,11 +429,14 @@ void EveWorkflowHelper::draw(std::size_t primaryVertexIdx, bool sortTracks)
           break;
         case GID::TPC: {
           float dz = 0.f;
-          if (conf.PVMode) { // for TPC the nominal time (center of the bracket) is stored but in the PVMode we correct it by the PV time
+          if (conf.PVMode) {
+            // for TPC the nominal time (center of the bracket) is stored but in the PVMode we correct it by the PV time
             tim = pvTime;
             const auto& tpcTr = mRecoCont->getTPCTrack(gid);
-            if (!tpcTr.hasBothSidesClusters()) { // need to correct track Z with this vertex time
-              float dz = (tpcTr.getTime0() * mTPCTimeBins2MUS - (pvTime + mTPCVDrift->getTimeOffset())) * mTPCVDrift->getVDrift();
+            if (!tpcTr.hasBothSidesClusters()) {
+              // need to correct track Z with this vertex time
+              float dz = (tpcTr.getTime0() * mTPCTimeBins2MUS - (pvTime + mTPCVDrift->getTimeOffset())) *
+                         mTPCVDrift->getVDrift();
               if (tpcTr.hasCSideClustersOnly()) {
                 dz = -dz;
               }
@@ -500,14 +516,25 @@ void EveWorkflowHelper::draw(std::size_t primaryVertexIdx, bool sortTracks)
   }
 }
 
-void EveWorkflowHelper::save(const std::string& jsonPath, const std::string& ext, int numberOfFiles)
+void EveWorkflowHelper::save(const std::string& jsonPath, const std::string& ext, int numberOfFiles,
+                             const std::string& receiverHostname, int receiverPort, int receiverTimeout, bool useOnlyFiles,
+                             bool useOnlySockets)
 {
   mEvent.setEveVersion(o2_eve_version);
-  FileProducer producer(jsonPath, ext, numberOfFiles);
-  VisualisationEventSerializer::getInstance(ext)->toFile(mEvent, producer.newFileName());
+  FileProducer producer(jsonPath, ext);
+  producer.reduceNumberOfFiles(numberOfFiles);
+  Location location({.fileName = producer.newFileName(),
+                     .port = receiverPort,
+                     .timeout = receiverTimeout,
+                     .host = receiverHostname,
+                     .toFile = !useOnlySockets,
+                     .toSocket = !useOnlyFiles});
+  VisualisationEventSerializer::getInstance(ext)->toFile(mEvent, location);
 }
 
-std::vector<PNT> EveWorkflowHelper::getTrackPoints(const o2::track::TrackPar& trc, float minR, float maxR, float maxStep, float minZ, float maxZ)
+std::vector<PNT>
+  EveWorkflowHelper::getTrackPoints(const o2::track::TrackPar& trc, float minR, float maxR, float maxStep, float minZ,
+                                    float maxZ)
 {
   // adjust minR according to real track start from track starting point
   auto maxR2 = maxR * maxR;
@@ -528,7 +555,8 @@ std::vector<PNT> EveWorkflowHelper::getTrackPoints(const o2::track::TrackPar& tr
   auto tp = trc;
   float dxmin = std::abs(xMin - tp.getX()), dxmax = std::abs(xMax - tp.getX());
 
-  if (dxmin > dxmax) { // start from closest end
+  if (dxmin > dxmax) {
+    // start from closest end
     std::swap(xMin, xMax);
     dx = -dx;
   }
@@ -556,7 +584,8 @@ std::vector<PNT> EveWorkflowHelper::getTrackPoints(const o2::track::TrackPar& tr
   return pnts;
 }
 
-void EveWorkflowHelper::addTrackToEvent(const o2::track::TrackPar& tr, GID gid, float trackTime, float dz, GID::Source source, float maxStep)
+void EveWorkflowHelper::addTrackToEvent(const o2::track::TrackPar& tr, GID gid, float trackTime, float dz,
+                                        GID::Source source, float maxStep)
 {
   if (source == GID::NSources) {
     source = (o2::dataformats::GlobalTrackID::Source)gid.getSource();
@@ -599,7 +628,8 @@ void EveWorkflowHelper::prepareITSClusters(const o2::itsmft::TopologyDictionary*
   }
 }
 
-void EveWorkflowHelper::prepareMFTClusters(const o2::itsmft::TopologyDictionary* dict) // do we also have something as ITS...dict?
+void EveWorkflowHelper::prepareMFTClusters(
+  const o2::itsmft::TopologyDictionary* dict) // do we also have something as ITS...dict?
 {
   const auto& MFTClusterROFRec = this->mRecoCont->getMFTClustersROFRecords();
   const auto& clusMFT = this->mRecoCont->getMFTClusters();
@@ -669,7 +699,8 @@ void EveWorkflowHelper::drawEMC(GID gid)
   const auto& conf = EveConfParam::Instance();
 
   for (const auto& cell : cellsForTrigger) {
-    if (!(cell.getType() == o2::emcal::ChannelType_t::HIGH_GAIN || cell.getType() == o2::emcal::ChannelType_t::LOW_GAIN)) {
+    if (!(cell.getType() == o2::emcal::ChannelType_t::HIGH_GAIN ||
+          cell.getType() == o2::emcal::ChannelType_t::LOW_GAIN)) {
       // Select FEE cells (excluding LEDMON or TRU cells)
       continue;
     }
@@ -738,7 +769,7 @@ void EveWorkflowHelper::drawTPCTRD(GID gid, float trackTime, GID::Source source)
   const auto& tpcTrdTrack = mRecoCont->getTPCTRDTrack<o2::trd::TrackTRD>(gid);
   addTrackToEvent(tpcTrdTrack, gid, trackTime, 0., source);
   drawTPCClusters(tpcTrdTrack.getRefGlobalTrackId(), trackTime * mMUS2TPCTimeBins);
-  drawTRDClusters(tpcTrdTrack);                       // tracktime
+  drawTRDClusters(tpcTrdTrack); // tracktime
 }
 
 void EveWorkflowHelper::drawITSTPCTRD(GID gid, float trackTime, GID::Source source)
@@ -774,7 +805,7 @@ void EveWorkflowHelper::drawTPCTOF(GID gid, float trackTime)
   const auto& match = mRecoCont->getTPCTOFMatch(gid.getIndex());
   addTrackToEvent(trTPCTOF, gid, trackTime, 0);
   drawTPCClusters(match.getTrackRef(), trackTime * mMUS2TPCTimeBins);
-  drawTOFClusters(gid);                 // trackTime
+  drawTOFClusters(gid); // trackTime
 }
 
 void EveWorkflowHelper::drawMFTMCH(GID gid, float trackTime)
@@ -832,8 +863,9 @@ void EveWorkflowHelper::drawMCHMID(GID gid, float trackTime)
 
 void EveWorkflowHelper::drawAODBarrel(EveWorkflowHelper::AODBarrelTrack const& track, float trackTime)
 {
-  const std::array<float, 5> arraypar = {track.y(), track.z(), track.snp(),
-                                         track.tgl(), track.signed1Pt()};
+  const std::array<float, 5> arraypar = {
+    track.y(), track.z(), track.snp(),
+    track.tgl(), track.signed1Pt()};
 
   const auto tr = o2::track::TrackPar(track.x(), track.alpha(), arraypar);
 
@@ -907,7 +939,9 @@ void EveWorkflowHelper::drawForwardTrack(GID gid, mch::TrackParam track, float s
   auto vTrack = mEvent.addTrack({.time = static_cast<float>(trackTime),
                                  .charge = 0,
                                  .PID = o2::track::PID::Muon,
-                                 .startXYZ = {(float)track.getNonBendingCoor(), (float)track.getBendingCoor(), (float)track.getZ()},
+                                 .startXYZ = {
+                                   (float)track.getNonBendingCoor(), (float)track.getBendingCoor(),
+                                   (float)track.getZ()},
                                  .phi = (float)0,
                                  .theta = (float)0,
                                  .eta = (float)0,
@@ -950,7 +984,8 @@ void EveWorkflowHelper::drawTOFClusters(GID gid)
 
 void EveWorkflowHelper::drawITSClusters(GID gid) // float trackTime
 {
-  if (gid.getSource() == GID::ITS) { // this is for for full standalone tracks
+  if (gid.getSource() == GID::ITS) {
+    // this is for for full standalone tracks
     const auto& trc = mRecoCont->getITSTrack(gid);
     auto refs = mRecoCont->getITSTracksClusterRefs();
     int ncl = trc.getNumberOfClusters();
@@ -961,7 +996,8 @@ void EveWorkflowHelper::drawITSClusters(GID gid) // float trackTime
       float xyz[] = {glo.X(), glo.Y(), glo.Z()};
       drawPoint(xyz); // trackTime;
     }
-  } else if (gid.getSource() == GID::ITSAB) { // this is for ITS tracklets from ITS-TPC afterburner
+  } else if (gid.getSource() == GID::ITSAB) {
+    // this is for ITS tracklets from ITS-TPC afterburner
     const auto& trc = mRecoCont->getITSABRef(gid);
     const auto& refs = mRecoCont->getITSABClusterRefs();
     int ncl = trc.getNClusters();
@@ -990,9 +1026,12 @@ void EveWorkflowHelper::drawTPCClusters(GID gid, float trackTimeTB)
     const auto& clTPC = trc.getCluster(mTPCTracksClusIdx, iCl, *mTPCClusterIdxStruct, sector, row);
 
     std::array<float, 3> xyz;
-    this->mTPCFastTransform->TransformIdeal(sector, row, clTPC.getPad(), clTPC.getTime(), xyz[0], xyz[1], xyz[2], trackTimeTB);    // in sector coordinate
-    o2::math_utils::rotateZ(xyz, o2::math_utils::sector2Angle(sector % o2::tpc::SECTORSPERSIDE));                                  // lab coordinate (global)
-    mEvent.addCluster(xyz.data());                                                                                                 // trackTimeTB / mMUS2TPCTimeBins
+    this->mTPCFastTransform->TransformIdeal(sector, row, clTPC.getPad(), clTPC.getTime(), xyz[0], xyz[1], xyz[2],
+                                            trackTimeTB); // in sector coordinate
+    o2::math_utils::rotateZ(xyz, o2::math_utils::sector2Angle(
+                                   sector % o2::tpc::SECTORSPERSIDE)); // lab coordinate (global)
+    mEvent.addCluster(
+      xyz.data()); // trackTimeTB / mMUS2TPCTimeBins
   }
 }
 
@@ -1018,8 +1057,10 @@ void EveWorkflowHelper::drawTPC(GID gid, float trackTime, float dz)
   }
 
   addTrackToEvent(tr, gid, trackTime, dz, GID::TPC);
-  float clTime0 = EveConfParam::Instance().PVMode ? trackTime * mMUS2TPCTimeBins : -2e9; // in PVMode use supplied real time converted to TB, otherwise pass dummy time to use tpcTrack.getTime0
-  drawTPCClusters(gid, clTime0);                                                         // trackTime
+  float clTime0 = EveConfParam::Instance().PVMode
+                    ? trackTime * mMUS2TPCTimeBins
+                    : -2e9;      // in PVMode use supplied real time converted to TB, otherwise pass dummy time to use tpcTrack.getTime0
+  drawTPCClusters(gid, clTime0); // trackTime
 }
 
 void EveWorkflowHelper::drawITS(GID gid, float trackTime)
@@ -1074,7 +1115,9 @@ void EveWorkflowHelper::drawMID(GID gid, float trackTime)
   auto vTrack = mEvent.addTrack({.time = static_cast<float>(trackTime),
                                  .charge = (int)0,
                                  .PID = o2::track::PID::Muon,
-                                 .startXYZ = {(float)midTrack.getPositionX(), (float)midTrack.getPositionY(), (float)midTrack.getPositionZ()},
+                                 .startXYZ = {
+                                   (float)midTrack.getPositionX(), (float)midTrack.getPositionY(),
+                                   (float)midTrack.getPositionZ()},
                                  .phi = (float)0,
                                  .theta = (float)0,
                                  .eta = (float)0,
@@ -1149,9 +1192,12 @@ EveWorkflowHelper::EveWorkflowHelper()
   }
   o2::mch::TrackExtrap::setField();
   this->mMFTGeom = o2::mft::GeometryTGeo::Instance();
-  this->mMFTGeom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
+  this->mMFTGeom->fillMatrixCache(
+    o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
   this->mITSGeom = o2::its::GeometryTGeo::Instance();
-  this->mITSGeom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::L2G));
+  this->mITSGeom->fillMatrixCache(
+    o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot,
+                             o2::math_utils::TransformType::L2G));
   this->mEMCALGeom = o2::emcal::Geometry::GetInstance("");
   this->mPHOSGeom = o2::phos::Geometry::GetInstance("");
   this->mTPCFastTransform = (o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
@@ -1161,10 +1207,18 @@ EveWorkflowHelper::EveWorkflowHelper()
   mTPCBin2MUS = elParams.ZbinWidth;
   const auto grp = o2::base::GRPGeomHelper::instance().getGRPECS();
   const auto& alpParamsITS = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-  mITSROFrameLengthMUS = grp->isDetContinuousReadOut(o2::detectors::DetID::ITS) ? alpParamsITS.roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingMUS : alpParamsITS.roFrameLengthTrig * 1.e-3;
+  mITSROFrameLengthMUS = grp->isDetContinuousReadOut(o2::detectors::DetID::ITS)
+                           ? alpParamsITS.roFrameLengthInBC *
+                               o2::constants::lhc::LHCBunchSpacingMUS
+                           : alpParamsITS.roFrameLengthTrig *
+                               1.e-3;
 
   const auto& alpParamsMFT = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>::Instance();
-  mMFTROFrameLengthMUS = grp->isDetContinuousReadOut(o2::detectors::DetID::MFT) ? alpParamsMFT.roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingMUS : alpParamsMFT.roFrameLengthTrig * 1.e-3;
+  mMFTROFrameLengthMUS = grp->isDetContinuousReadOut(o2::detectors::DetID::MFT)
+                           ? alpParamsMFT.roFrameLengthInBC *
+                               o2::constants::lhc::LHCBunchSpacingMUS
+                           : alpParamsMFT.roFrameLengthTrig *
+                               1.e-3;
 
   mPVParams = &o2::vertexing::PVertexerParams::Instance();
 
@@ -1177,7 +1231,8 @@ void EveWorkflowHelper::setTPCVDrift(const o2::tpc::VDriftCorrFact* v)
 {
   mTPCVDrift = v;
   if (v) {
-    o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mTPCFastTransform.get(), 0, v->corrFact, v->refVDrift, v->getTimeOffset());
+    o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mTPCFastTransform.get(), 0, v->corrFact,
+                                                                     v->refVDrift, v->getTimeOffset());
   }
 }
 
@@ -1198,11 +1253,14 @@ GID::Source EveWorkflowHelper::detectorMapToGIDSource(uint8_t dm)
       return GID::TPCTOF;
     case static_cast<uint8_t>(o2::aod::track::TPC) | static_cast<uint8_t>(o2::aod::track::TRD):
       return GID::TPCTRD;
-    case static_cast<uint8_t>(o2::aod::track::ITS) | static_cast<uint8_t>(o2::aod::track::TPC) | static_cast<uint8_t>(o2::aod::track::TRD):
+    case static_cast<uint8_t>(o2::aod::track::ITS) | static_cast<uint8_t>(o2::aod::track::TPC) |
+      static_cast<uint8_t>(o2::aod::track::TRD):
       return GID::ITSTPCTRD;
-    case static_cast<uint8_t>(o2::aod::track::ITS) | static_cast<uint8_t>(o2::aod::track::TPC) | static_cast<uint8_t>(o2::aod::track::TOF):
+    case static_cast<uint8_t>(o2::aod::track::ITS) | static_cast<uint8_t>(o2::aod::track::TPC) |
+      static_cast<uint8_t>(o2::aod::track::TOF):
       return GID::ITSTPCTOF;
-    case static_cast<uint8_t>(o2::aod::track::TPC) | static_cast<uint8_t>(o2::aod::track::TRD) | static_cast<uint8_t>(o2::aod::track::TOF):
+    case static_cast<uint8_t>(o2::aod::track::TPC) | static_cast<uint8_t>(o2::aod::track::TRD) |
+      static_cast<uint8_t>(o2::aod::track::TOF):
       return GID::TPCTRDTOF;
     default:
       return GID::ITSTPCTRDTOF;
diff --git a/EventVisualisation/Workflow/src/FileProducer.cxx b/EventVisualisation/Workflow/src/FileProducer.cxx
index c50dcb8fad135..01e68240bfe6a 100644
--- a/EventVisualisation/Workflow/src/FileProducer.cxx
+++ b/EventVisualisation/Workflow/src/FileProducer.cxx
@@ -30,13 +30,18 @@ using std::chrono::duration_cast;
 using std::chrono::milliseconds;
 using std::chrono::system_clock;
 
-FileProducer::FileProducer(const std::string& path, const std::string& ext, int filesInFolder, const std::string& name)
+FileProducer::FileProducer(const std::string& path, const std::string& ext, const std::string& name)
 {
-  this->mFilesInFolder = filesInFolder;
   this->mPath = path;
   this->mName = name;
   this->mExt = ext;
-  o2::utils::createDirectoriesIfAbsent(path); // create folder if not exists (fails if no rights)
+  o2::utils::createDirectoriesIfAbsent(path); // create a folder if not exists (fails if no rights)
+}
+
+void FileProducer::reduceNumberOfFiles(size_t filesInFolder) const
+{
+  const std::vector<std::string> ext = {".json", ".root", ".eve"};
+  DirectoryLoader::reduceNumberOfFiles(this->mPath, DirectoryLoader::load(this->mPath, "_", ext), filesInFolder);
 }
 
 std::string FileProducer::newFileName() const
@@ -52,8 +57,5 @@ std::string FileProducer::newFileName() const
                                   fmt::arg("pid", pid),
                                   fmt::arg("timestamp", millisec_since_epoch),
                                   fmt::arg("ext", this->mExt));
-  const std::vector<std::string> ext = {".json", ".root", ".eve"};
-  DirectoryLoader::reduceNumberOfFiles(this->mPath, DirectoryLoader::load(this->mPath, "_", ext), this->mFilesInFolder);
-
   return this->mPath + "/" + result;
 }
diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index e02e1ee20ce58..bd8ab5a664d99 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -60,6 +60,11 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
   std::vector<o2::framework::ConfigParamSpec> options{
     {"jsons-folder", VariantType::String, "jsons", {"name of the folder to store json files"}},
+    {"receiver-hostname", VariantType::String, "arcbs04.cern.ch", {"name of the host where visualisation data is transmitted (only eve format)"}},
+    {"receiver-port", VariantType::Int, 8001, {"port number of the host where visualisation data is transmitted (only eve format)"}},
+    {"receiver-timeout", VariantType::Int, 300, {"socket connection timeout (ms)"}},
+    {"use-only-files", VariantType::Bool, false, {"do not transmit visualisation data using sockets (only eve format)"}},
+    {"use-only-sockets", VariantType::Bool, false, {"do not store visualisation data using filesystem"}},
     {"use-json-format", VariantType::Bool, false, {"instead of eve format (default) use json format"}},
     {"use-root-format", VariantType::Bool, false, {"instead of eve format (default) use root format"}},
     {"eve-hostname", VariantType::String, "", {"name of the host allowed to produce files (empty means no limit)"}},
@@ -186,7 +191,7 @@ void O2DPLDisplaySpec::run(ProcessingContext& pc)
         helper.mEvent.setRunType(this->mRunType);
         helper.mEvent.setPrimaryVertex(pv);
         helper.mEvent.setCreationTime(tinfo.creation);
-        helper.save(this->mJsonPath, this->mExt, conf.maxFiles);
+        helper.save(this->mJsonPath, this->mExt, conf.maxFiles, this->mReceiverHostname, this->mReceiverPort, this->mReceiverTimeout, this->mUseOnlyFiles, this->mUseOnlySockets);
         filesSaved++;
         currentTime = std::chrono::high_resolution_clock::now(); // time AFTER save
         this->mTimeStamp = currentTime;                          // next run AFTER period counted from last save
@@ -302,6 +307,12 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   bool useMC = !cfgc.options().get<bool>("disable-mc");
   bool disableWrite = cfgc.options().get<bool>("disable-write");
 
+  auto receiverHostname = cfgc.options().get<std::string>("receiver-hostname");
+  auto receiverPort = cfgc.options().get<int>("receiver-port");
+  auto receiverTimeout = cfgc.options().get<int>("receiver-timeout");
+  auto useOnlyFiles = cfgc.options().get<bool>("use-only-files");
+  auto useOnlySockets = cfgc.options().get<bool>("use-only-sockets");
+
   char hostname[_POSIX_HOST_NAME_MAX];
   gethostname(hostname, _POSIX_HOST_NAME_MAX);
   bool eveHostNameMatch = eveHostName.empty() || eveHostName == hostname;
@@ -398,7 +409,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     "o2-eve-export",
     dataRequest->inputs,
     {},
-    AlgorithmSpec{adaptFromTask<O2DPLDisplaySpec>(disableWrite, useMC, srcTrk, srcCl, dataRequest, ggRequest, emcalCalibLoader, jsonFolder, ext, timeInterval, eveHostNameMatch)}});
+    AlgorithmSpec{adaptFromTask<O2DPLDisplaySpec>(disableWrite, useMC, srcTrk, srcCl, dataRequest, ggRequest,
+                                                  emcalCalibLoader, jsonFolder, ext, timeInterval, eveHostNameMatch,
+                                                  receiverHostname, receiverPort, receiverTimeout, useOnlyFiles, useOnlySockets)}});
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(cfgc, specs);

From 83467b3c67f9b51545b730c3fff5904419ea2806 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 18 Jun 2025 08:47:02 +0200
Subject: [PATCH 0669/1764] DPL: move to std::pmr where possible

---
 CCDB/include/CCDB/CCDBDownloader.h            |  2 +-
 CCDB/include/CCDB/CcdbApi.h                   | 18 +++++------
 CCDB/src/CcdbApi.cxx                          | 14 ++++-----
 CCDB/test/testCcdbApi.cxx                     |  4 +--
 CCDB/test/testCcdbApiDownloader.cxx           |  6 ++--
 DataFormats/Headers/include/Headers/Stack.h   | 13 ++++----
 DataFormats/Headers/test/testDataHeader.cxx   |  5 ++--
 .../include/MemoryResources/MemoryResources.h | 25 ++++++----------
 .../test/testMemoryResources.cxx              | 10 +++----
 .../include/CTPReconstruction/CTFCoder.h      |  3 +-
 .../CTPReconstruction/RawDataDecoder.h        |  6 ++--
 .../CTP/reconstruction/src/RawDataDecoder.cxx |  8 ++---
 .../include/CTPWorkflow/RawDecoderSpec.h      |  2 +-
 .../src/emc-channel-data-producer.cxx         |  4 +--
 .../Clusters/clusters-sampler-workflow.cxx    |  6 ++--
 .../MCH/DevIO/Tracks/TrackSamplerSpec.cxx     |  4 +--
 .../src/ClusterTransformerSpec.cxx            |  2 +-
 .../MUON/MCH/Tracking/src/TrackFinderSpec.cxx |  8 ++---
 .../MCH/Workflow/src/ClusterFinderGEMSpec.cxx |  4 +--
 .../src/ClusterFinderOriginalSpec.cxx         |  8 ++---
 .../workflow/src/TOFIntegrateClusterSpec.cxx  |  6 ++--
 .../TPC/calibration/src/IDCFactorization.cxx  |  2 +-
 .../TPCWorkflow/TPCDistributeIDCSpec.h        |  2 +-
 .../include/TPCWorkflow/TPCFLPIDCSpec.h       |  6 ++--
 .../workflow/test/test_ft_EPN_Aggregator.cxx  |  2 +-
 Detectors/Vertexing/src/SVertexer.cxx         |  2 +-
 Framework/CCDBSupport/src/CCDBHelpers.cxx     |  2 +-
 .../Core/include/Framework/DataAllocator.h    |  9 +++---
 Framework/Core/include/Framework/DataChunk.h  | 30 +++++++------------
 .../Core/include/Framework/MessageContext.h   | 14 ++++-----
 Framework/Core/src/LifetimeHelpers.cxx        |  2 +-
 Framework/Core/test/test_DataAllocator.cxx    |  2 +-
 Framework/Core/test/test_DataRefUtils.cxx     |  1 +
 Framework/Core/test/test_DataRelayer.cxx      |  1 +
 Framework/Core/test/test_FairMQ.cxx           |  7 ++---
 .../Core/test/test_O2DataModelHelpers.cxx     |  1 +
 Framework/Utils/include/DPLUtils/Utils.h      |  2 +-
 37 files changed, 115 insertions(+), 128 deletions(-)

diff --git a/CCDB/include/CCDB/CCDBDownloader.h b/CCDB/include/CCDB/CCDBDownloader.h
index 6c057a537a096..3ca2e763130df 100644
--- a/CCDB/include/CCDB/CCDBDownloader.h
+++ b/CCDB/include/CCDB/CCDBDownloader.h
@@ -41,7 +41,7 @@ namespace o2::ccdb
 #if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
 struct HeaderObjectPair_t {
   std::multimap<std::string, std::string> header;
-  o2::pmr::vector<char>* object = nullptr;
+  std::pmr::vector<char>* object = nullptr;
   int counter = 0;
 };
 
diff --git a/CCDB/include/CCDB/CcdbApi.h b/CCDB/include/CCDB/CcdbApi.h
index cc8312d0bef0a..60097ff86baeb 100644
--- a/CCDB/include/CCDB/CcdbApi.h
+++ b/CCDB/include/CCDB/CcdbApi.h
@@ -355,7 +355,7 @@ class CcdbApi //: public DatabaseInterface
 
 #if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
   typedef struct RequestContext {
-    o2::pmr::vector<char>& dest;
+    std::pmr::vector<char>& dest;
     std::string path;
     std::map<std::string, std::string> const& metadata;
     long timestamp;
@@ -365,7 +365,7 @@ class CcdbApi //: public DatabaseInterface
     std::string createdNotBefore;
     bool considerSnapshot;
 
-    RequestContext(o2::pmr::vector<char>& d,
+    RequestContext(std::pmr::vector<char>& d,
                    std::map<std::string, std::string> const& m,
                    std::map<std::string, std::string>& h)
       : dest(d), metadata(m), headers(h) {}
@@ -379,7 +379,7 @@ class CcdbApi //: public DatabaseInterface
 
   void getFromSnapshot(bool createSnapshot, std::string const& path,
                        long timestamp, std::map<std::string, std::string>& headers,
-                       std::string& snapshotpath, o2::pmr::vector<char>& dest, int& fromSnapshot, std::string const& etag) const;
+                       std::string& snapshotpath, std::pmr::vector<char>& dest, int& fromSnapshot, std::string const& etag) const;
   void releaseNamedSemaphore(boost::interprocess::named_semaphore* sem, std::string const& path) const;
   boost::interprocess::named_semaphore* createNamedSemaphore(std::string const& path) const;
   static std::string determineSemaphoreName(std::string const& basedir, std::string const& objectpath);
@@ -388,22 +388,22 @@ class CcdbApi //: public DatabaseInterface
   static bool removeSemaphore(std::string const& name, bool remove = false);
   static void removeLeakingSemaphores(std::string const& basedir, bool remove = false);
 
-  void loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders = nullptr, bool fetchLocalMetaData = true) const;
-  void loadFileToMemory(o2::pmr::vector<char>& dest, std::string const& path,
+  void loadFileToMemory(std::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders = nullptr, bool fetchLocalMetaData = true) const;
+  void loadFileToMemory(std::pmr::vector<char>& dest, std::string const& path,
                         std::map<std::string, std::string> const& metadata, long timestamp,
                         std::map<std::string, std::string>* headers, std::string const& etag,
                         const std::string& createdNotAfter, const std::string& createdNotBefore, bool considerSnapshot = true) const;
 
   // Loads files from alien and cvmfs into given destination.
-  bool loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string& url) const;
+  bool loadLocalContentToMemory(std::pmr::vector<char>& dest, std::string& url) const;
 
   // add annotated flattened headers in the end of the blob
-  static void appendFlatHeader(o2::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers);
+  static void appendFlatHeader(std::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers);
 
   // the failure to load the file to memory is signaled by 0 size and non-0 capacity
-  static bool isMemoryFileInvalid(const o2::pmr::vector<char>& v) { return v.size() == 0 && v.capacity() > 0; }
+  static bool isMemoryFileInvalid(const std::pmr::vector<char>& v) { return v.size() == 0 && v.capacity() > 0; }
   template <typename T>
-  static T* extractFromMemoryBlob(o2::pmr::vector<char>& blob)
+  static T* extractFromMemoryBlob(std::pmr::vector<char>& blob)
   {
     auto obj = static_cast<T*>(interpretAsTMemFileAndExtract(blob.data(), blob.size(), typeid(T)));
     if constexpr (std::is_base_of<o2::conf::ConfigurableParam, T>::value) {
diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index f187fbf57f558..056435ca9f0fe 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -843,7 +843,7 @@ bool CcdbApi::retrieveBlob(std::string const& path, std::string const& targetdir
     return false;
   }
 
-  o2::pmr::vector<char> buff;
+  std::pmr::vector<char> buff;
   std::map<std::string, std::string> headers;
   // avoid creating snapshot via loadFileToMemory itself
   loadFileToMemory(buff, path, metadata, timestamp, &headers, "", createdNotAfter, createdNotBefore, false);
@@ -1838,7 +1838,7 @@ void CcdbApi::removeLeakingSemaphores(std::string const& snapshotdir, bool remov
 
 void CcdbApi::getFromSnapshot(bool createSnapshot, std::string const& path,
                               long timestamp, std::map<std::string, std::string>& headers,
-                              std::string& snapshotpath, o2::pmr::vector<char>& dest, int& fromSnapshot, std::string const& etag) const
+                              std::string& snapshotpath, std::pmr::vector<char>& dest, int& fromSnapshot, std::string const& etag) const
 {
   if (createSnapshot) { // create named semaphore
     std::string logfile = mSnapshotCachePath + "/log";
@@ -1892,7 +1892,7 @@ void CcdbApi::loadFileToMemory(std::vector<char>& dest, std::string const& path,
                                std::map<std::string, std::string>* headers, std::string const& etag,
                                const std::string& createdNotAfter, const std::string& createdNotBefore, bool considerSnapshot) const
 {
-  o2::pmr::vector<char> destP;
+  std::pmr::vector<char> destP;
   destP.reserve(dest.size());
   loadFileToMemory(destP, path, metadata, timestamp, headers, etag, createdNotAfter, createdNotBefore, considerSnapshot);
   dest.clear();
@@ -1902,7 +1902,7 @@ void CcdbApi::loadFileToMemory(std::vector<char>& dest, std::string const& path,
   }
 }
 
-void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, std::string const& path,
+void CcdbApi::loadFileToMemory(std::pmr::vector<char>& dest, std::string const& path,
                                std::map<std::string, std::string> const& metadata, long timestamp,
                                std::map<std::string, std::string>* headers, std::string const& etag,
                                const std::string& createdNotAfter, const std::string& createdNotBefore, bool considerSnapshot) const
@@ -1920,7 +1920,7 @@ void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, std::string const& p
   vectoredLoadFileToMemory(contexts);
 }
 
-void CcdbApi::appendFlatHeader(o2::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers)
+void CcdbApi::appendFlatHeader(std::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers)
 {
   size_t hsize = getFlatHeaderSize(headers), cnt = dest.size();
   dest.resize(cnt + hsize);
@@ -1985,7 +1985,7 @@ void CcdbApi::vectoredLoadFileToMemory(std::vector<RequestContext>& requestConte
   }
 }
 
-bool CcdbApi::loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string& url) const
+bool CcdbApi::loadLocalContentToMemory(std::pmr::vector<char>& dest, std::string& url) const
 {
   if (url.find("alien:/", 0) != std::string::npos) {
     std::map<std::string, std::string> localHeaders;
@@ -2013,7 +2013,7 @@ bool CcdbApi::loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string&
   return false;
 }
 
-void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders, bool fetchLocalMetaData) const
+void CcdbApi::loadFileToMemory(std::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders, bool fetchLocalMetaData) const
 {
   // Read file to memory as vector. For special case of the locally cached file retriev metadata stored directly in the file
   constexpr size_t MaxCopySize = 0x1L << 25;
diff --git a/CCDB/test/testCcdbApi.cxx b/CCDB/test/testCcdbApi.cxx
index 0ba037710cf62..84119b099de3b 100644
--- a/CCDB/test/testCcdbApi.cxx
+++ b/CCDB/test/testCcdbApi.cxx
@@ -560,7 +560,7 @@ BOOST_AUTO_TEST_CASE(multi_host_test)
   api.init("http://bogus-host.cern.ch,http://ccdb-test.cern.ch:8080");
   std::map<std::string, std::string> metadata;
   std::map<std::string, std::string> headers;
-  o2::pmr::vector<char> dst;
+  std::pmr::vector<char> dst;
   std::string url = "Analysis/ALICE3/Centrality";
   api.loadFileToMemory(dst, url, metadata, 1645780010602, &headers, "", "", "", true);
   BOOST_CHECK(dst.size() != 0);
@@ -572,7 +572,7 @@ BOOST_AUTO_TEST_CASE(vectored)
   api.init("http://ccdb-test.cern.ch:8080");
 
   int TEST_SAMPLE_SIZE = 5;
-  std::vector<o2::pmr::vector<char>> dests(TEST_SAMPLE_SIZE);
+  std::vector<std::pmr::vector<char>> dests(TEST_SAMPLE_SIZE);
   std::vector<std::map<std::string, std::string>> metadatas(TEST_SAMPLE_SIZE);
   std::vector<std::map<std::string, std::string>> headers(TEST_SAMPLE_SIZE);
 
diff --git a/CCDB/test/testCcdbApiDownloader.cxx b/CCDB/test/testCcdbApiDownloader.cxx
index 76686f5ee1c00..8e412dcfa7f76 100644
--- a/CCDB/test/testCcdbApiDownloader.cxx
+++ b/CCDB/test/testCcdbApiDownloader.cxx
@@ -116,12 +116,12 @@ size_t writeCallbackNoLambda(void* contents, size_t size, size_t nmemb, void* ch
   return realsize;
 }
 
-std::vector<CURL*> prepareAsyncHandles(size_t num, std::vector<o2::pmr::vector<char>*>& dests)
+std::vector<CURL*> prepareAsyncHandles(size_t num, std::vector<std::pmr::vector<char>*>& dests)
 {
   std::vector<CURL*> handles;
 
   for (int i = 0; i < num; i++) {
-    auto dest = new o2::pmr::vector<char>();
+    auto dest = new std::pmr::vector<char>();
     dests.push_back(dest);
     CURL* curl_handle = curl_easy_init();
     handles.push_back(curl_handle);
@@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE(asynch_schedule_test)
   }
 
   CCDBDownloader downloader;
-  std::vector<o2::pmr::vector<char>*> dests;
+  std::vector<std::pmr::vector<char>*> dests;
   auto handles = prepareAsyncHandles(TRANSFERS, dests);
   size_t transfersLeft = 0;
 
diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index 0958b639ef451..98fb95e602ecf 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -11,9 +11,10 @@
 #ifndef O2_HEADERS_STACK_H
 #define O2_HEADERS_STACK_H
 
-#include "MemoryResources/MemoryResources.h"
 #include "Headers/DataHeader.h"
 
+#include <memory_resource>
+
 namespace o2::header
 {
 //__________________________________________________________________________________________________
@@ -32,7 +33,7 @@ namespace o2::header
 ///   - returns a Stack ready to be shipped.
 struct Stack {
 
-  using memory_resource = o2::pmr::memory_resource;
+  using memory_resource = std::pmr::memory_resource;
 
  private:
   struct freeobj {
@@ -42,7 +43,7 @@ struct Stack {
   };
 
  public:
-  using allocator_type = fair::mq::pmr::polymorphic_allocator<std::byte>;
+  using allocator_type = std::pmr::polymorphic_allocator<std::byte>;
   using value_type = std::byte;
   using BufferType = std::unique_ptr<value_type[], freeobj>; // this gives us proper default move semantics for free
 
@@ -87,9 +88,9 @@ struct Stack {
   /// all headers must derive from BaseHeader, in addition also other stacks can be passed to ctor.
   template <typename FirstArgType, typename... Headers,
             typename std::enable_if_t<
-              !std::is_convertible<FirstArgType, fair::mq::pmr::polymorphic_allocator<std::byte>>::value, int> = 0>
+              !std::is_convertible<FirstArgType, std::pmr::polymorphic_allocator<std::byte>>::value, int> = 0>
   Stack(FirstArgType&& firstHeader, Headers&&... headers)
-    : Stack(fair::mq::pmr::new_delete_resource(), std::forward<FirstArgType>(firstHeader),
+    : Stack(std::pmr::new_delete_resource(), std::forward<FirstArgType>(firstHeader),
             std::forward<Headers>(headers)...)
   {
   }
@@ -140,7 +141,7 @@ struct Stack {
   constexpr static size_t calculateSize() { return 0; }
 
  private:
-  allocator_type allocator{fair::mq::pmr::new_delete_resource()};
+  allocator_type allocator{std::pmr::new_delete_resource()};
   size_t bufferSize{0};
   BufferType buffer{nullptr, freeobj{allocator.resource()}};
 
diff --git a/DataFormats/Headers/test/testDataHeader.cxx b/DataFormats/Headers/test/testDataHeader.cxx
index 2403c1a6230be..23a230840fafe 100644
--- a/DataFormats/Headers/test/testDataHeader.cxx
+++ b/DataFormats/Headers/test/testDataHeader.cxx
@@ -314,8 +314,7 @@ BOOST_AUTO_TEST_CASE(headerStack_test)
   BOOST_CHECK(h3->secret == 42);
 
   // test constructing from a buffer and an additional header
-  using namespace fair::mq::pmr;
-  Stack s5(new_delete_resource(), s1.data(), Stack{}, meta);
+  Stack s5(std::pmr::new_delete_resource(), s1.data(), Stack{}, meta);
   BOOST_CHECK(s5.size() == s1.size() + sizeof(meta));
   // check if we can find the header even though there was an empty stack in the middle
   h3 = get<test::MetaHeader*>(s5.data());
@@ -329,7 +328,7 @@ BOOST_AUTO_TEST_CASE(headerStack_test)
   BOOST_CHECK(h4 == h3);
 
   // let's assume we have some stack that is missing the required DataHeader at the beginning:
-  Stack s6{new_delete_resource(), DataHeader{}, s1.data()};
+  Stack s6{std::pmr::new_delete_resource(), DataHeader{}, s1.data()};
   BOOST_CHECK(s6.size() == sizeof(DataHeader) + s1.size());
 }
 
diff --git a/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h b/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
index b52f5c715575e..66b44162b47ff 100644
--- a/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
+++ b/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
@@ -28,9 +28,6 @@
 #ifndef ALICEO2_MEMORY_RESOURCES_
 #define ALICEO2_MEMORY_RESOURCES_
 
-#include <boost/container/pmr/memory_resource.hpp>
-#include <boost/container/pmr/monotonic_buffer_resource.hpp>
-#include <boost/container/pmr/polymorphic_allocator.hpp>
 #include <cstring>
 #include <string>
 #include <type_traits>
@@ -45,12 +42,8 @@
 namespace o2::pmr
 {
 
-using FairMQMemoryResource = fair::mq::MemoryResource;
-using ChannelResource = fair::mq::ChannelResource;
-using namespace fair::mq::pmr;
-
 template <typename ContainerT>
-fair::mq::MessagePtr getMessage(ContainerT&& container, FairMQMemoryResource* targetResource = nullptr)
+fair::mq::MessagePtr getMessage(ContainerT&& container, fair::mq::MemoryResource* targetResource = nullptr)
 {
   return fair::mq::getMessage(std::forward<ContainerT>(container), targetResource);
 }
@@ -60,7 +53,7 @@ fair::mq::MessagePtr getMessage(ContainerT&& container, FairMQMemoryResource* ta
 /// Ownership of hte message is taken. Meant to be used for transparent data adoption in containers.
 /// In combination with the SpectatorAllocator this is an alternative to using span, as raw memory
 /// (e.g. an existing buffer message) will be accessible with appropriate container.
-class MessageResource : public FairMQMemoryResource
+class MessageResource : public fair::mq::MemoryResource
 {
 
  public:
@@ -82,7 +75,7 @@ class MessageResource : public FairMQMemoryResource
   size_t getNumberOfMessages() const noexcept override { return mMessageData ? 1 : 0; }
 
  protected:
-  FairMQMemoryResource* mUpstream{nullptr};
+  fair::mq::MemoryResource* mUpstream{nullptr};
   size_t mMessageSize{0};
   void* mMessageData{nullptr};
   bool initialImport{true};
@@ -113,14 +106,14 @@ class MessageResource : public FairMQMemoryResource
 
 // The NoConstructAllocator behaves like the normal pmr vector but does not call constructors / destructors
 template <typename T>
-class NoConstructAllocator : public fair::mq::pmr::polymorphic_allocator<T>
+class NoConstructAllocator : public std::pmr::polymorphic_allocator<T>
 {
  public:
-  using fair::mq::pmr::polymorphic_allocator<T>::polymorphic_allocator;
+  using std::pmr::polymorphic_allocator<T>::polymorphic_allocator;
   using propagate_on_container_move_assignment = std::true_type;
 
   template <typename... Args>
-  NoConstructAllocator(Args&&... args) : fair::mq::pmr::polymorphic_allocator<T>(std::forward<Args>(args)...)
+  NoConstructAllocator(Args&&... args) : std::pmr::polymorphic_allocator<T>(std::forward<Args>(args)...)
   {
   }
 
@@ -145,13 +138,13 @@ class NoConstructAllocator : public fair::mq::pmr::polymorphic_allocator<T>
 //__________________________________________________________________________________________________
 //__________________________________________________________________________________________________
 
-using BytePmrAllocator = fair::mq::pmr::polymorphic_allocator<std::byte>;
+using BytePmrAllocator = std::pmr::polymorphic_allocator<std::byte>;
 template <class T>
-using vector = std::vector<T, fair::mq::pmr::polymorphic_allocator<T>>;
+using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>;
 
 //__________________________________________________________________________________________________
 /// Get the allocator associated to a transport factory
-inline static FairMQMemoryResource* getTransportAllocator(fair::mq::TransportFactory* factory)
+inline static fair::mq::MemoryResource* getTransportAllocator(fair::mq::TransportFactory* factory)
 {
   return *factory;
 }
diff --git a/DataFormats/MemoryResources/test/testMemoryResources.cxx b/DataFormats/MemoryResources/test/testMemoryResources.cxx
index a49cd00d75255..c72ac8f6d422b 100644
--- a/DataFormats/MemoryResources/test/testMemoryResources.cxx
+++ b/DataFormats/MemoryResources/test/testMemoryResources.cxx
@@ -19,6 +19,7 @@
 #include <fairmq/ProgOptions.h>
 #include <vector>
 #include <cstring>
+#include <memory_resource>
 
 namespace o2::pmr
 {
@@ -60,8 +61,6 @@ BOOST_AUTO_TEST_CASE(transportallocatormap_test)
   BOOST_CHECK(_tmp == allocZMQ);
 }
 
-using namespace fair::mq::pmr;
-
 BOOST_AUTO_TEST_CASE(allocator_test)
 {
   size_t session{(size_t)getpid() * 1000 + 1};
@@ -76,7 +75,7 @@ BOOST_AUTO_TEST_CASE(allocator_test)
   testData::nconstructions = 0;
 
   {
-    std::vector<testData, polymorphic_allocator<testData>> v(polymorphic_allocator<testData>{allocZMQ});
+    std::vector<testData, std::pmr::polymorphic_allocator<testData>> v(std::pmr::polymorphic_allocator<testData>{allocZMQ});
     v.reserve(3);
     BOOST_CHECK(v.capacity() == 3);
     BOOST_CHECK(allocZMQ->getNumberOfMessages() == 1);
@@ -110,7 +109,7 @@ BOOST_AUTO_TEST_CASE(getMessage_test)
 
   // test message creation on the same channel it was allocated with
   {
-    std::vector<testData, polymorphic_allocator<testData>> v(polymorphic_allocator<testData>{allocZMQ});
+    std::vector<testData, std::pmr::polymorphic_allocator<testData>> v(std::pmr::polymorphic_allocator<testData>{allocZMQ});
     v.emplace_back(1);
     v.emplace_back(2);
     v.emplace_back(3);
@@ -125,7 +124,7 @@ BOOST_AUTO_TEST_CASE(getMessage_test)
 
   // test message creation on a different channel than it was allocated with
   {
-    std::vector<testData, polymorphic_allocator<testData>> v(polymorphic_allocator<testData>{allocZMQ});
+    std::vector<testData, std::pmr::polymorphic_allocator<testData>> v(std::pmr::polymorphic_allocator<testData>{allocZMQ});
     v.emplace_back(4);
     v.emplace_back(5);
     v.emplace_back(6);
@@ -137,7 +136,6 @@ BOOST_AUTO_TEST_CASE(getMessage_test)
   BOOST_CHECK(message->GetSize() == 3 * sizeof(testData));
   messageArray = static_cast<int*>(message->GetData());
   BOOST_CHECK(messageArray[0] == 4 && messageArray[1] == 5 && messageArray[2] == 6);
-
 }
 
 }; // namespace o2::pmr
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
index 9189df5d12685..4b3d097417659 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
@@ -26,6 +26,7 @@
 #include "CTPReconstruction/CTFHelper.h"
 #include "CTPReconstruction/RawDataDecoder.h"
 #include "DataFormatsCTP/Configuration.h"
+#include <vector>
 
 class TTree;
 
@@ -225,7 +226,7 @@ o2::ctf::CTFIOSize CTFCoder::decode(const CTF::base& ec, VTRG& data, LumiInfo& l
       trgclassmask = mCTPConfig.getTriggerClassMask();
     }
     // std::cout << "trgclassmask:" << std::hex << trgclassmask << std::dec << std::endl;
-    o2::pmr::vector<CTPDigit> digits;
+    std::pmr::vector<CTPDigit> digits;
     o2::ctp::RawDataDecoder::shiftInputs(digitsMap, digits, mFirstTFOrbit, trgclassmask);
     for (auto const& dig : digits) {
       data.emplace_back(dig);
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
index 53addf32c538f..3027c8aea39fc 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
@@ -35,7 +35,7 @@ class RawDataDecoder
   ~RawDataDecoder() = default;
   static void makeGBTWordInverse(std::vector<gbtword80_t>& diglets, gbtword80_t& GBTWord, gbtword80_t& remnant, uint32_t& size_gbt, uint32_t Npld);
   int addCTPDigit(uint32_t linkCRU, uint32_t triggerOrbit, gbtword80_t& diglet, gbtword80_t& pldmask, std::map<o2::InteractionRecord, CTPDigit>& digits);
-  int decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, o2::pmr::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1);
+  int decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, std::pmr::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1);
   int decodeRawFatal(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter);
   int decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, std::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1);
   void setDecodeInps(bool decodeinps) { mDecodeInps = decodeinps; }
@@ -54,8 +54,8 @@ class RawDataDecoder
   CTPConfiguration& getCTPConfig() { return mCTPConfig; }
   int init();
   static int shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit, std::bitset<48>& inpmask, int64_t shift, int level, std::map<o2::InteractionRecord, CTPDigit>& digmap);
-  static int shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask = 0xffffffffffffffff);
-  int checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask = 0xffffffffffffffff, uint64_t trigclassmaskNoTrgDets = 0xffffffffffffffff);
+  static int shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, std::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask = 0xffffffffffffffff);
+  int checkReadoutConsistentncy(std::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask = 0xffffffffffffffff, uint64_t trigclassmaskNoTrgDets = 0xffffffffffffffff);
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassErrorsA() { return mClassErrorsA; }
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassErrorsB() { return mClassErrorsB; }
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassCountersA() { return mClassCountersA; }
diff --git a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
index a062a262acf62..025e63a786a48 100644
--- a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
+++ b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
@@ -128,7 +128,7 @@ int RawDataDecoder::addCTPDigit(uint32_t linkCRU, uint32_t orbit, gbtword80_t& d
 // Decodes one page
 // It is NOT assumed that CTP HBF has never more than one page.
 // 1 HBF/page <= 8000kB = 8*1024*8/120 = 546 GBT words = 546 IRs/page = 5.5 MHz
-int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, o2::pmr::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1)
+int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, std::pmr::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1)
 {
   int ret = 0;
   static int nwrites = 0;
@@ -495,7 +495,7 @@ int RawDataDecoder::decodeRawFatal(o2::framework::InputRecord& inputs, std::vect
 //
 int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, std::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1)
 {
-  o2::pmr::vector<CTPDigit> pmrdigits;
+  std::pmr::vector<CTPDigit> pmrdigits;
   int ret = decodeRaw(inputs, filter, pmrdigits, lumiPointsHBF1);
   for (auto const d : pmrdigits) {
     digits.push_back(d);
@@ -532,7 +532,7 @@ int RawDataDecoder::shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit
 }
 //
 
-int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask)
+int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, std::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask)
 {
   // int nClasswoInp = 0; // counting classes without input which should never happen
   int lost = 0;
@@ -598,7 +598,7 @@ int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digit
   return lost;
 }
 //
-int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask, uint64_t trgclassmaskNoTrgDet)
+int RawDataDecoder::checkReadoutConsistentncy(std::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask, uint64_t trgclassmaskNoTrgDet)
 {
   LOG(debug) << "Checking readout";
   int ret = 0;
diff --git a/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h b/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
index 3198e5c33e219..1ba01803f3b19 100644
--- a/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
+++ b/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
@@ -57,7 +57,7 @@ class RawDecoderSpec : public framework::Task
  private:
   // for digits
   bool mDoDigits = true;
-  o2::pmr::vector<CTPDigit> mOutputDigits;
+  std::pmr::vector<CTPDigit> mOutputDigits;
   int mMaxInputSize = 0;
   bool mMaxInputSizeFatal = 0;
   // for lumi
diff --git a/Detectors/EMCAL/workflow/src/emc-channel-data-producer.cxx b/Detectors/EMCAL/workflow/src/emc-channel-data-producer.cxx
index 75e2cdbd9fce3..a0141256ac29d 100644
--- a/Detectors/EMCAL/workflow/src/emc-channel-data-producer.cxx
+++ b/Detectors/EMCAL/workflow/src/emc-channel-data-producer.cxx
@@ -128,7 +128,7 @@ DataProcessorSpec generateData(const std::string nameRootFile, const std::string
 
         // loop over cells
         // ToDo: Make more realistic assumption that we dont always have the same amount of cells per event
-        o2::pmr::vector<o2::emcal::Cell> CellOutput;
+        std::pmr::vector<o2::emcal::Cell> CellOutput;
         for (int i = 0; i < nCellsPerEvent; ++i) {
           double cellID = 0;
           double cellE = 0;
@@ -157,7 +157,7 @@ DataProcessorSpec generateData(const std::string nameRootFile, const std::string
         }
         // send output
         LOG(debug) << "sending " << CellOutput.size() << "cells";
-        o2::pmr::vector<o2::emcal::TriggerRecord> TriggerOutput;
+        std::pmr::vector<o2::emcal::TriggerRecord> TriggerOutput;
         TriggerOutput.emplace_back(0, 0, 0, CellOutput.size());
 
         ctx.outputs().adoptContainer(Output{o2::header::gDataOriginEMC, "CELLS", 0}, std::move(CellOutput));
diff --git a/Detectors/MUON/MCH/DevIO/Clusters/clusters-sampler-workflow.cxx b/Detectors/MUON/MCH/DevIO/Clusters/clusters-sampler-workflow.cxx
index 9d98ada911df2..95c748f1cc6f1 100644
--- a/Detectors/MUON/MCH/DevIO/Clusters/clusters-sampler-workflow.cxx
+++ b/Detectors/MUON/MCH/DevIO/Clusters/clusters-sampler-workflow.cxx
@@ -101,7 +101,7 @@ class ClusterSamplerTask
     // create the output messages
     auto& rofs = pc.outputs().make<std::vector<ROFRecord>>(OutputRef{"rofs"});
     auto& clusters = pc.outputs().make<std::vector<Cluster>>(OutputRef{"clusters"});
-    std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>* digits(nullptr);
+    std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>* digits(nullptr);
     if (mDoDigits) {
       digits = &pc.outputs().make<std::vector<Digit>>(OutputRef{"digits"});
     }
@@ -115,8 +115,8 @@ class ClusterSamplerTask
 
  private:
   //_________________________________________________________________________________________________
-  int readOneEvent(std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters,
-                   std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>* digits)
+  int readOneEvent(std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters,
+                   std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>* digits)
   {
     /// fill the internal buffers with the clusters and digits of the current event
 
diff --git a/Detectors/MUON/MCH/DevIO/Tracks/TrackSamplerSpec.cxx b/Detectors/MUON/MCH/DevIO/Tracks/TrackSamplerSpec.cxx
index 4a53659e2732b..27291af10e3b0 100644
--- a/Detectors/MUON/MCH/DevIO/Tracks/TrackSamplerSpec.cxx
+++ b/Detectors/MUON/MCH/DevIO/Tracks/TrackSamplerSpec.cxx
@@ -102,8 +102,8 @@ class TrackSamplerTask
   }
 
   //_________________________________________________________________________________________________
-  int readOneEvent(std::vector<TrackMCH, o2::pmr::polymorphic_allocator<TrackMCH>>& tracks,
-                   std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters)
+  int readOneEvent(std::vector<TrackMCH, std::pmr::polymorphic_allocator<TrackMCH>>& tracks,
+                   std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters)
   {
     /// fill the output messages with the tracks and attached clusters of the current event
     /// modify the references to the attached clusters according to their position in the global vector
diff --git a/Detectors/MUON/MCH/Geometry/Transformer/src/ClusterTransformerSpec.cxx b/Detectors/MUON/MCH/Geometry/Transformer/src/ClusterTransformerSpec.cxx
index f70f9574b6974..1f71af86078a8 100644
--- a/Detectors/MUON/MCH/Geometry/Transformer/src/ClusterTransformerSpec.cxx
+++ b/Detectors/MUON/MCH/Geometry/Transformer/src/ClusterTransformerSpec.cxx
@@ -42,7 +42,7 @@ namespace o2::mch
 // convert all clusters from local to global reference frames
 void local2global(geo::TransformationCreator transformation,
                   gsl::span<const Cluster> localClusters,
-                  std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& globalClusters)
+                  std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& globalClusters)
 {
   int i{0};
   globalClusters.insert(globalClusters.end(), localClusters.begin(), localClusters.end());
diff --git a/Detectors/MUON/MCH/Tracking/src/TrackFinderSpec.cxx b/Detectors/MUON/MCH/Tracking/src/TrackFinderSpec.cxx
index 6239186309dc3..c21249527cb23 100644
--- a/Detectors/MUON/MCH/Tracking/src/TrackFinderSpec.cxx
+++ b/Detectors/MUON/MCH/Tracking/src/TrackFinderSpec.cxx
@@ -145,7 +145,7 @@ class TrackFinderTask
     auto& trackROFs = pc.outputs().make<std::vector<ROFRecord>>(OutputRef{"trackrofs"});
     auto& mchTracks = pc.outputs().make<std::vector<TrackMCH>>(OutputRef{"tracks"});
     auto& usedClusters = pc.outputs().make<std::vector<Cluster>>(OutputRef{"trackclusters"});
-    std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>* usedDigits(nullptr);
+    std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>* usedDigits(nullptr);
     if (mDigits) {
       usedDigits = &pc.outputs().make<std::vector<Digit>>(OutputRef{"trackdigits"});
     }
@@ -219,9 +219,9 @@ class TrackFinderTask
   //_________________________________________________________________________________________________
   void writeTracks(const std::list<Track>& tracks, const gsl::span<const Digit>& digitsIn,
                    const ROFRecord& clusterROF, uint32_t firstTForbit,
-                   std::vector<TrackMCH, o2::pmr::polymorphic_allocator<TrackMCH>>& mchTracks,
-                   std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& usedClusters,
-                   std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>* usedDigits) const
+                   std::vector<TrackMCH, std::pmr::polymorphic_allocator<TrackMCH>>& mchTracks,
+                   std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& usedClusters,
+                   std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>* usedDigits) const
   {
     /// fill the output messages with tracks and attached clusters and digits if requested
 
diff --git a/Detectors/MUON/MCH/Workflow/src/ClusterFinderGEMSpec.cxx b/Detectors/MUON/MCH/Workflow/src/ClusterFinderGEMSpec.cxx
index 5158cc436b277..2af245d453702 100644
--- a/Detectors/MUON/MCH/Workflow/src/ClusterFinderGEMSpec.cxx
+++ b/Detectors/MUON/MCH/Workflow/src/ClusterFinderGEMSpec.cxx
@@ -303,8 +303,8 @@ class ClusterFinderGEMTask
 
  private:
   //_________________________________________________________________________________________________
-  void writeClusters(std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters,
-                     std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>& usedDigits) const
+  void writeClusters(std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters,
+                     std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>& usedDigits) const
   {
     /// fill the output messages with clusters and attached digits of the current event
     /// modify the references to the attached digits according to their position in the global vector
diff --git a/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx b/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
index 8344d2837b814..b0890e3e6c7e2 100644
--- a/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
+++ b/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
@@ -144,8 +144,8 @@ class ClusterFinderOriginalTask
  private:
   //_________________________________________________________________________________________________
   void writeClusters(const gsl::span<const Digit>& preclusterDigits, size_t firstClusterIdx,
-                     std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters,
-                     std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>& usedDigits) const
+                     std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters,
+                     std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>& usedDigits) const
   {
     /// fill the output messages with the new clusters and all the digits from the corresponding precluster
     /// modify the references to the attached digits according to their position in the global vector
@@ -167,8 +167,8 @@ class ClusterFinderOriginalTask
   }
 
   //_________________________________________________________________________________________________
-  void writeClusters(std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters,
-                     std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>& usedDigits) const
+  void writeClusters(std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters,
+                     std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>& usedDigits) const
   {
     /// fill the output messages with clusters and attached digits of the current event
     /// modify the references to the attached digits according to their position in the global vector
diff --git a/Detectors/TOF/workflow/src/TOFIntegrateClusterSpec.cxx b/Detectors/TOF/workflow/src/TOFIntegrateClusterSpec.cxx
index 2b647f9236611..f3e561a0c531d 100644
--- a/Detectors/TOF/workflow/src/TOFIntegrateClusterSpec.cxx
+++ b/Detectors/TOF/workflow/src/TOFIntegrateClusterSpec.cxx
@@ -60,8 +60,8 @@ class TOFIntegrateClusters : public Task
     const float sliceWidthMSinv = 1. / float(sliceWidthMS);
 
     // storage for integrated currents
-    o2::pmr::vector<float> iTOFCNCl(nSlices);
-    o2::pmr::vector<float> iTOFCqTot(nSlices);
+    std::pmr::vector<float> iTOFCNCl(nSlices);
+    std::pmr::vector<float> iTOFCqTot(nSlices);
 
     const auto clusters = pc.inputs().get<gsl::span<o2::tof::Cluster>>("tofcluster");
     if (mTagNoise) {
@@ -106,7 +106,7 @@ class TOFIntegrateClusters : public Task
   std::vector<int> mCounterNeighbours;                    ///< buffer for noise removal (contains number of neighbouring cluster for time +-mTimeCutNoisePS)
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest; ///< info for CCDB request
 
-  void sendOutput(ProcessingContext& pc, o2::pmr::vector<float> iTOFCNCl, o2::pmr::vector<float> iTOFCqTot)
+  void sendOutput(ProcessingContext& pc, std::pmr::vector<float> iTOFCNCl, std::pmr::vector<float> iTOFCqTot)
   {
     pc.outputs().adoptContainer(Output{header::gDataOriginTOF, "ITOFCN"}, std::move(iTOFCNCl));
     pc.outputs().adoptContainer(Output{header::gDataOriginTOF, "ITOFCQ"}, std::move(iTOFCqTot));
diff --git a/Detectors/TPC/calibration/src/IDCFactorization.cxx b/Detectors/TPC/calibration/src/IDCFactorization.cxx
index e5474016e7b98..cc60be31acb54 100644
--- a/Detectors/TPC/calibration/src/IDCFactorization.cxx
+++ b/Detectors/TPC/calibration/src/IDCFactorization.cxx
@@ -1241,4 +1241,4 @@ bool o2::tpc::IDCFactorization::checkReceivedIDCs()
   return idcsGood;
 }
 
-template void o2::tpc::IDCFactorization::calcIDCOne(const o2::pmr::vector<float>&, const int, const int, const unsigned int, const CRU, std::vector<std::vector<float>>&, const IDCZero*, const CalDet<PadFlags>*, const bool);
+template void o2::tpc::IDCFactorization::calcIDCOne(const std::pmr::vector<float>&, const int, const int, const unsigned int, const CRU, std::vector<std::vector<float>>&, const IDCZero*, const CalDet<PadFlags>*, const bool);
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeIDCSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeIDCSpec.h
index 6e589cd6c4e8b..e0c1a87d939ae 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeIDCSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeIDCSpec.h
@@ -247,7 +247,7 @@ class TPCDistributeIDCSpec : public o2::framework::Task
   std::vector<InputSpec> mFilter{};                                                    ///< filter for looping over input data
   std::vector<header::DataDescription> mDataDescrOut{};
 
-  void sendOutput(o2::framework::ProcessingContext& pc, const unsigned int currentOutLane, const unsigned int cru, o2::pmr::vector<float> idcs)
+  void sendOutput(o2::framework::ProcessingContext& pc, const unsigned int currentOutLane, const unsigned int cru, std::pmr::vector<float> idcs)
   {
     pc.outputs().adoptContainer(Output{gDataOriginTPC, mDataDescrOut[currentOutLane], header::DataHeader::SubSpecificationType{cru}}, std::move(idcs));
   }
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
index ec3e158590661..6f6ff249c1935 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
@@ -93,7 +93,7 @@ class TPCFLPIDCDevice : public o2::framework::Task
       ++mCountTFsForBuffer;
       auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
       const int cru = tpcCRUHeader->subSpecification >> 7;
-      auto vecIDCs = pc.inputs().get<o2::pmr::vector<float>>(ref);
+      auto vecIDCs = pc.inputs().get<std::pmr::vector<float>>(ref);
       mIDCs[cru].insert(mIDCs[cru].end(), vecIDCs.begin(), vecIDCs.end());
 
       if (mEnableSynchProc) {
@@ -164,7 +164,7 @@ class TPCFLPIDCDevice : public o2::framework::Task
   bool mDumpIDCs{};                                                                                                                                                                                  ///< dump IDCs to tree for debugging
   int mCountTFsForBuffer{0};                                                                                                                                                                         ///< count processed TFs to track when the output will be send
   std::pair<std::vector<float>, std::vector<unsigned int>> mOneDIDCs{};                                                                                                                              ///< 1D-IDCs which will be send to the EPNs
-  std::unordered_map<unsigned int, o2::pmr::vector<float>> mIDCs{};                                                                                                                                  ///< object for averaging and grouping of the IDCs
+  std::unordered_map<unsigned int, std::pmr::vector<float>> mIDCs{};                                                                                                                                 ///< object for averaging and grouping of the IDCs
   std::unordered_map<unsigned int, std::deque<std::pair<std::vector<float>, std::vector<unsigned int>>>> mBuffer1DIDCs{};                                                                            ///< buffer for 1D-IDCs. The buffered 1D-IDCs for n TFs will be send to the EPNs for synchronous reco. Zero initialized to avoid empty first TFs!
   CalDet<PadFlags>* mPadFlagsMap{nullptr};                                                                                                                                                           ///< status flag for each pad (i.e. if the pad is dead)
   IDCZero mIDCZero{};                                                                                                                                                                                ///< I_0(r,\phi) = <I(r,\phi,t)>_t: Used for calculating IDC1 (provided from input file or CCDB)
@@ -173,7 +173,7 @@ class TPCFLPIDCDevice : public o2::framework::Task
   /// update the time dependent parameters if they have changed (i.e. update the pad status map)
   void updateTimeDependentParams(ProcessingContext& pc) { pc.inputs().get<o2::tpc::CalDet<PadFlags>*>("tpcpadmap").get(); }
 
-  void sendOutputSync(DataAllocator& output, const o2::pmr::vector<float>& idc, const uint32_t cru)
+  void sendOutputSync(DataAllocator& output, const std::pmr::vector<float>& idc, const uint32_t cru)
   {
     const header::DataHeader::SubSpecificationType subSpec{cru << 7};
     const CRU cruTmp(cru);
diff --git a/Detectors/TPC/workflow/test/test_ft_EPN_Aggregator.cxx b/Detectors/TPC/workflow/test/test_ft_EPN_Aggregator.cxx
index e8255f98eff6c..f8236756b27cb 100644
--- a/Detectors/TPC/workflow/test/test_ft_EPN_Aggregator.cxx
+++ b/Detectors/TPC/workflow/test/test_ft_EPN_Aggregator.cxx
@@ -230,7 +230,7 @@ DataProcessorSpec generateIDCsCRU(int lane, const unsigned int maxTFs, const std
           o2::tpc::CRU cruTmp(icru);
           const unsigned int nPads = o2::tpc::Mapper::PADSPERREGION[cruTmp.region()];
           const int cru = (icru + tf * Mapper::NREGIONS) % o2::tpc::CRU::MaxCRU; // shuffle CRUs
-          o2::pmr::vector<float> idcs;
+          std::pmr::vector<float> idcs;
           idcs.reserve(generateIDCs ? o2::tpc::Mapper::PADSPERREGION[cruTmp.region()] : mIDCs[cru].size());
           const int nIntervals = intervalsRand.size();
           for (int interval = 0; interval < nIntervals; ++interval) {
diff --git a/Detectors/Vertexing/src/SVertexer.cxx b/Detectors/Vertexing/src/SVertexer.cxx
index 1d48bcceb0097..edaf523cddb41 100644
--- a/Detectors/Vertexing/src/SVertexer.cxx
+++ b/Detectors/Vertexing/src/SVertexer.cxx
@@ -216,7 +216,7 @@ void SVertexer::produceOutput(o2::framework::ProcessingContext& pc)
 
     auto& strTracksOut = pc.outputs().make<std::vector<o2::dataformats::StrangeTrack>>(o2f::Output{"GLO", "STRANGETRACKS", 0});
     auto& strClustOut = pc.outputs().make<std::vector<o2::strangeness_tracking::ClusAttachments>>(o2f::Output{"GLO", "CLUSUPDATES", 0});
-    o2::pmr::vector<o2::MCCompLabel> mcLabsOut;
+    std::pmr::vector<o2::MCCompLabel> mcLabsOut;
     strTracksOut.resize(mNStrangeTracks);
     strClustOut.resize(mNStrangeTracks);
     if (mStrTracker->getMCTruthOn()) {
diff --git a/Framework/CCDBSupport/src/CCDBHelpers.cxx b/Framework/CCDBSupport/src/CCDBHelpers.cxx
index 0db4cbb5ac71d..71b6282c80086 100644
--- a/Framework/CCDBSupport/src/CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/CCDBHelpers.cxx
@@ -159,7 +159,7 @@ CCDBHelpers::ParserResult CCDBHelpers::parseRemappings(char const* str)
   }
 }
 
-auto getOrbitResetTime(o2::pmr::vector<char> const& v) -> Long64_t
+auto getOrbitResetTime(std::pmr::vector<char> const& v) -> Long64_t
 {
   Int_t previousErrorLevel = gErrorIgnoreLevel;
   gErrorIgnoreLevel = kFatal;
diff --git a/Framework/Core/include/Framework/DataAllocator.h b/Framework/Core/include/Framework/DataAllocator.h
index 287513ec85845..c5aa4bbffa480 100644
--- a/Framework/Core/include/Framework/DataAllocator.h
+++ b/Framework/Core/include/Framework/DataAllocator.h
@@ -32,6 +32,7 @@
 #include <gsl/span>
 
 #include <memory>
+#include <memory_resource>
 #include <vector>
 #include <map>
 #include <string>
@@ -449,7 +450,7 @@ class DataAllocator
   }
 
   // get the memory resource associated with an output
-  o2::pmr::FairMQMemoryResource* getMemoryResource(const Output& spec)
+  std::pmr::memory_resource* getMemoryResource(const Output& spec)
   {
     auto& timingInfo = mRegistry.get<TimingInfo>();
     auto& proxy = mRegistry.get<FairMQDeviceProxy>();
@@ -459,10 +460,10 @@ class DataAllocator
 
   // make a stl (pmr) vector
   template <typename T, typename... Args>
-  o2::pmr::vector<T> makeVector(const Output& spec, Args&&... args)
+  std::pmr::vector<T> makeVector(const Output& spec, Args&&... args)
   {
-    o2::pmr::FairMQMemoryResource* targetResource = getMemoryResource(spec);
-    return o2::pmr::vector<T>{targetResource, std::forward<Args>(args)...};
+    std::pmr::memory_resource* targetResource = getMemoryResource(spec);
+    return std::pmr::vector<T>{targetResource, std::forward<Args>(args)...};
   }
 
   struct CacheId {
diff --git a/Framework/Core/include/Framework/DataChunk.h b/Framework/Core/include/Framework/DataChunk.h
index 664092216a0ee..bbb1c44098f46 100644
--- a/Framework/Core/include/Framework/DataChunk.h
+++ b/Framework/Core/include/Framework/DataChunk.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -8,14 +8,13 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-#ifndef FRAMEWORK_DATACHUNK_H
-#define FRAMEWORK_DATACHUNK_H
+#ifndef O2_FRAMEWORK_DATACHUNK_H_
+#define O2_FRAMEWORK_DATACHUNK_H_
 
-#include "MemoryResources/MemoryResources.h"
+#include <memory_resource>
+#include <vector>
 
-namespace o2
-{
-namespace framework
+namespace o2::framework
 {
 /// @class DataChunk A resizable buffer used with DPL's DataAllocator
 /// DataChunk derives from std::vector with polymorphic allocator and forbids copying, the underlying
@@ -23,18 +22,11 @@ namespace framework
 /// message memory.
 /// Since MessageContext returns the object by reference, the forbidden copy and assignment makes sure that
 /// the code can not accidentally use a copy instead reference.
-class DataChunk : public std::vector<char, o2::pmr::polymorphic_allocator<char>>
+class DataChunk : public std::vector<char, std::pmr::polymorphic_allocator<char>>
 {
  public:
-  // FIXME: want to have a general forwarding, but then the copy constructor is not deleted any more despite
-  // it's declared deleted
-  //template <typename... Args>
-  //DataChunk(T&& arg, Args&&... args) : std::vector<char, o2::pmr::polymorphic_allocator<char>>(std::forward<Args>(args)...)
-  //{
-  //}
-
   // DataChunk is special and for the moment it's enough to declare the constructor with size and allocator
-  DataChunk(size_t size, const o2::pmr::polymorphic_allocator<char>& allocator) : std::vector<char, o2::pmr::polymorphic_allocator<char>>(size, allocator)
+  DataChunk(size_t size, const std::pmr::polymorphic_allocator<char>& allocator) : std::vector<char, std::pmr::polymorphic_allocator<char>>(size, allocator)
   {
   }
   DataChunk(const DataChunk&) = delete;
@@ -43,6 +35,6 @@ class DataChunk : public std::vector<char, o2::pmr::polymorphic_allocator<char>>
   DataChunk& operator=(DataChunk&&) = default;
 };
 
-} // namespace framework
-} // namespace o2
-#endif // FRAMEWORK_DATACHUNK_H
+} // namespace o2::framework
+
+#endif // O2_FRAMEWORK_DATACHUNK_H_
diff --git a/Framework/Core/include/Framework/MessageContext.h b/Framework/Core/include/Framework/MessageContext.h
index 407bac0ceb00a..4b0047e3e33ad 100644
--- a/Framework/Core/include/Framework/MessageContext.h
+++ b/Framework/Core/include/Framework/MessageContext.h
@@ -28,11 +28,11 @@
 #include <fairmq/Parts.h>
 
 #include <cassert>
-#include <functional>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
 #include <vector>
+#include <memory_resource>
 
 #include <fairmq/FwdDecls.h>
 
@@ -182,7 +182,7 @@ class MessageContext
 
   // A memory resource which can force a minimum alignment, so that
   // the whole polymorphic allocator business is happy...
-  class AlignedMemoryResource : public pmr::FairMQMemoryResource
+  class AlignedMemoryResource : public fair::mq::MemoryResource
   {
    public:
     AlignedMemoryResource(fair::mq::MemoryResource* other)
@@ -230,7 +230,7 @@ class MessageContext
       return mUpstream->deallocate(p, bytes, alignment < 64 ? 64 : alignment);
     }
 
-    [[nodiscard]] bool do_is_equal(const pmr::memory_resource& other) const noexcept override
+    [[nodiscard]] bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override
     {
       return this == &other;
     }
@@ -240,7 +240,7 @@ class MessageContext
   };
 
   /// ContainerRefObject handles a message object holding an instance of type T
-  /// The allocator type is required to be o2::pmr::polymorphic_allocator
+  /// The allocator type is required to be std::pmr::polymorphic_allocator
   /// can not adopt an existing message, because the polymorphic_allocator will call type constructor,
   /// so this works only with new messages
   /// FIXME: not sure if we want to have this for all container types
@@ -251,7 +251,7 @@ class MessageContext
     using value_type = typename T::value_type;
     using return_type = T;
     using buffer_type = return_type;
-    static_assert(std::is_base_of<o2::pmr::polymorphic_allocator<value_type>, typename T::allocator_type>::value, "container must have polymorphic allocator");
+    static_assert(std::is_base_of<std::pmr::polymorphic_allocator<value_type>, typename T::allocator_type>::value, "container must have polymorphic allocator");
     /// default contructor forbidden, object always has to control message instances
     ContainerRefObject() = delete;
     /// constructor taking header message by move and creating the paypload message
@@ -263,7 +263,7 @@ class MessageContext
         // the memory resource takes ownership of the message
         mResource{mFactory ? AlignedMemoryResource(mFactory->GetMemoryResource()) : AlignedMemoryResource(nullptr)},
         // create the vector with apropriate underlying memory resource for the message
-        mData{std::forward<Args>(args)..., pmr::polymorphic_allocator<value_type>(&mResource)}
+        mData{std::forward<Args>(args)..., std::pmr::polymorphic_allocator<value_type>(&mResource)}
     {
       // FIXME: drop this repeated check and make sure at initial setup of devices that everything is fine
       // introduce error policy
@@ -313,7 +313,7 @@ class MessageContext
   /// VectorObject handles a message object holding std::vector with polymorphic_allocator
   /// can not adopt an existing message, because the polymorphic_allocator will call the element constructor,
   /// so this works only with new messages
-  template <typename T, typename _BASE = ContainerRefObject<std::vector<T, o2::pmr::polymorphic_allocator<T>>>>
+  template <typename T, typename _BASE = ContainerRefObject<std::vector<T, std::pmr::polymorphic_allocator<T>>>>
   class VectorObject : public _BASE
   {
    public:
diff --git a/Framework/Core/src/LifetimeHelpers.cxx b/Framework/Core/src/LifetimeHelpers.cxx
index 21aa29c1f10e9..439e6f852123a 100644
--- a/Framework/Core/src/LifetimeHelpers.cxx
+++ b/Framework/Core/src/LifetimeHelpers.cxx
@@ -353,7 +353,7 @@ size_t readToMessage(void* p, size_t size, size_t nmemb, void* userdata)
   if (size == 0) {
     return 0;
   }
-  auto* buffer = (o2::pmr::vector<char>*)userdata;
+  auto* buffer = (std::pmr::vector<char>*)userdata;
   size_t oldSize = buffer->size();
   buffer->resize(oldSize + nmemb * size);
   memcpy(buffer->data() + oldSize, p, nmemb * size);
diff --git a/Framework/Core/test/test_DataAllocator.cxx b/Framework/Core/test/test_DataAllocator.cxx
index fefb6438b98d5..739c999e868b9 100644
--- a/Framework/Core/test/test_DataAllocator.cxx
+++ b/Framework/Core/test/test_DataAllocator.cxx
@@ -144,7 +144,7 @@ DataProcessorSpec getSourceSpec()
 
     // make a PMR std::vector, make it large to test the auto transport buffer resize funtionality as well
     Output pmrOutputSpec{"TST", "PMRTESTVECTOR", 0};
-    auto pmrvec = o2::pmr::vector<o2::test::TriviallyCopyable>(pc.outputs().getMemoryResource(pmrOutputSpec));
+    auto pmrvec = std::pmr::vector<o2::test::TriviallyCopyable>(pc.outputs().getMemoryResource(pmrOutputSpec));
     pmrvec.reserve(100);
     pmrvec.emplace_back(o2::test::TriviallyCopyable{1, 2, 3});
     pc.outputs().adoptContainer(pmrOutputSpec, std::move(pmrvec));
diff --git a/Framework/Core/test/test_DataRefUtils.cxx b/Framework/Core/test/test_DataRefUtils.cxx
index d4accde0fecf0..a0bc4dec49df6 100644
--- a/Framework/Core/test/test_DataRefUtils.cxx
+++ b/Framework/Core/test/test_DataRefUtils.cxx
@@ -15,6 +15,7 @@
 #include <TMessage.h>
 #include "Framework/RootSerializationSupport.h"
 #include "Framework/DataRefUtils.h"
+#include <fairmq/TransportFactory.h>
 #include <catch_amalgamated.hpp>
 
 #include <memory>
diff --git a/Framework/Core/test/test_DataRelayer.cxx b/Framework/Core/test/test_DataRelayer.cxx
index 7d5a3ded88e16..5f6cde4078540 100644
--- a/Framework/Core/test/test_DataRelayer.cxx
+++ b/Framework/Core/test/test_DataRelayer.cxx
@@ -26,6 +26,7 @@
 #include "Framework/WorkflowSpec.h"
 #include <Monitoring/Monitoring.h>
 #include <fairmq/TransportFactory.h>
+#include <fairmq/MemoryResources.h>
 #include <array>
 #include <vector>
 #include <uv.h>
diff --git a/Framework/Core/test/test_FairMQ.cxx b/Framework/Core/test/test_FairMQ.cxx
index f11d98505298f..e80741c143060 100644
--- a/Framework/Core/test/test_FairMQ.cxx
+++ b/Framework/Core/test/test_FairMQ.cxx
@@ -27,7 +27,7 @@ using namespace o2::pmr;
 //__________________________________________________________________________________________________
 // addDataBlock for generic (compatible) containers, that is contiguous containers using the pmr allocator
 template <typename ContainerT, typename std::enable_if<!std::is_same<ContainerT, fair::mq::MessagePtr>::value, int>::type = 0>
-bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, ContainerT&& inputData, o2::pmr::FairMQMemoryResource* targetResource = nullptr)
+bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, ContainerT&& inputData, fair::mq::MemoryResource* targetResource = nullptr)
 {
   auto headerMessage = o2::pmr::getMessage(std::move(inputStack), targetResource);
   auto dataMessage = o2::pmr::getMessage(std::forward<ContainerT>(inputData), targetResource);
@@ -42,7 +42,7 @@ bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, Contai
 // addDataBlock for data already wrapped in fair::mq::MessagePtr
 // note: since we cannot partially specialize function templates, use SFINAE here instead
 template <typename ContainerT, typename std::enable_if<std::is_same<ContainerT, fair::mq::MessagePtr>::value, int>::type = 0>
-bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, ContainerT&& dataMessage, o2::pmr::FairMQMemoryResource* targetResource = nullptr)
+bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, ContainerT&& dataMessage, fair::mq::MemoryResource* targetResource = nullptr)
 {
   // make sure the payload size in DataHeader corresponds to message size
   using o2::header::DataHeader;
@@ -174,9 +174,8 @@ TEST_CASE("addDataBlockForEach_test")
       int i;
       int j;
     };
-    using namespace fair::mq::pmr;
     fair::mq::Parts message;
-    std::vector<elem, polymorphic_allocator<elem>> vec(polymorphic_allocator<elem>{allocZMQ});
+    std::vector<elem, std::pmr::polymorphic_allocator<elem>> vec(std::pmr::polymorphic_allocator<elem>{allocZMQ});
     vec.reserve(100);
     vec.push_back({1, 2});
     vec.push_back({3, 4});
diff --git a/Framework/Core/test/test_O2DataModelHelpers.cxx b/Framework/Core/test/test_O2DataModelHelpers.cxx
index c32738699c222..98a269ed3a907 100644
--- a/Framework/Core/test/test_O2DataModelHelpers.cxx
+++ b/Framework/Core/test/test_O2DataModelHelpers.cxx
@@ -13,6 +13,7 @@
 #include "Framework/DataProcessingHeader.h"
 #include "Headers/DataHeader.h"
 #include "Headers/Stack.h"
+#include "MemoryResources/MemoryResources.h"
 #include <fairmq/TransportFactory.h>
 #include <catch_amalgamated.hpp>
 
diff --git a/Framework/Utils/include/DPLUtils/Utils.h b/Framework/Utils/include/DPLUtils/Utils.h
index 8786a579fdc53..93758fbfe53db 100644
--- a/Framework/Utils/include/DPLUtils/Utils.h
+++ b/Framework/Utils/include/DPLUtils/Utils.h
@@ -37,7 +37,7 @@ o2f::DataProcessorSpec defineBroadcaster(std::string devName, o2f::InputSpec usr
                                          size_t fixMsgSize);
 o2f::DataProcessorSpec defineBroadcaster(std::string devName, o2f::InputSpec usrInput, o2f::Outputs usrOutputs);
 
-using OutputBuffer = o2::pmr::vector<char>;
+using OutputBuffer = std::pmr::vector<char>;
 // Merger implementations
 o2f::DataProcessorSpec defineMerger(std::string devName, o2f::Inputs usrInputs, o2f::OutputSpec usrOutput,
                                     std::function<void(OutputBuffer, const o2f::DataRef)> const mergerFunc);

From 1f482616e0341f84b3cadb23deb72efb824d173a Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 24 Jul 2025 13:37:28 +0200
Subject: [PATCH 0670/1764] DPL: add component for Arrow Acero Streaming Engine

---
 dependencies/O2Dependencies.cmake | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/dependencies/O2Dependencies.cmake b/dependencies/O2Dependencies.cmake
index 0e0b1caf7d3ba..26f381a4ef79f 100644
--- a/dependencies/O2Dependencies.cmake
+++ b/dependencies/O2Dependencies.cmake
@@ -65,6 +65,33 @@ if(NOT TARGET ArrowDataset::arrow_dataset_shared)
   )
 endif()
 
+if(NOT TARGET ArrowAcero::arrow_acero_shared)
+  # ArrowAcero::arrow_acero_shared is linked for no reason to parquet
+  # so we cannot use it because we do not want to build parquet itself.
+  # For that reason at the moment we need to do the lookup by hand.
+  get_target_property(ARROW_SHARED_LOCATION Arrow::arrow_shared LOCATION)
+  get_filename_component(ARROW_SHARED_DIR ${ARROW_SHARED_LOCATION} DIRECTORY)
+
+  find_library(ARROW_ACERO_SHARED arrow_acero
+      PATHS ${ARROW_SHARED_DIR}
+      NO_DEFAULT_PATH
+  )
+
+  if(ARROW_ACERO_SHARED)
+    message(STATUS
+            "Found arrow_acero_shared library at: ${ARROW_ACERO_SHARED}")
+  else()
+    message(FATAL_ERROR
+            "arrow_acero_shared library not found in ${ARROW_SHARED_DIR}")
+  endif()
+
+  # Step 3: Create a target for ArrowAcero::arrow_acero_shared
+  add_library(ArrowAcero::arrow_acero_shared SHARED IMPORTED)
+  set_target_properties(ArrowAcero::arrow_acero_shared PROPERTIES
+      IMPORTED_LOCATION ${ARROW_ACERO_SHARED}
+  )
+endif()
+
 if (NOT TARGET Gandiva::gandiva_shared)
   add_library(Gandiva::gandiva_shared ALIAS gandiva_shared)
 endif()

From 28345fbd29d86fad3bdbb789ef474f82e3f04a2d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 7 Aug 2025 12:43:33 +0200
Subject: [PATCH 0671/1764] Get rid of C++ extension warning

---
 CCDB/include/CCDB/CcdbApi.h |  3 ---
 CCDB/src/CcdbApi.cxx        | 20 ++++++--------------
 2 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/CCDB/include/CCDB/CcdbApi.h b/CCDB/include/CCDB/CcdbApi.h
index 60097ff86baeb..9dc69cd10fc84 100644
--- a/CCDB/include/CCDB/CcdbApi.h
+++ b/CCDB/include/CCDB/CcdbApi.h
@@ -576,9 +576,6 @@ class CcdbApi //: public DatabaseInterface
   // convert type_info to TClass, throw on failure
   static TClass* tinfo2TClass(std::type_info const& tinfo);
 
-  // split string on delimiters and return tokens as vector
-  std::vector<std::string> splitString(const std::string& str, const char* delimiters);
-
   typedef size_t (*CurlWriteCallback)(void*, size_t, size_t, void*);
 
   void initCurlOptionsForRetrieve(CURL* curlHandle, void* pointer, CurlWriteCallback writeCallback, bool followRedirect = true) const;
diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index 056435ca9f0fe..541ef28d17ede 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -24,6 +24,7 @@
 #include "Framework/DataTakingContext.h"
 #include <chrono>
 #include <memory>
+#include <ranges>
 #include <sstream>
 #include <TFile.h>
 #include <TGrid.h>
@@ -1665,22 +1666,13 @@ int CcdbApi::updateMetadata(std::string const& path, std::map<std::string, std::
   return ret;
 }
 
-std::vector<std::string> CcdbApi::splitString(const std::string& str, const char* delimiters)
-{
-  std::vector<std::string> tokens;
-  char stringForStrTok[str.length() + 1];
-  strcpy(stringForStrTok, str.c_str());
-  char* token = strtok(stringForStrTok, delimiters);
-  while (token != nullptr) {
-    tokens.emplace_back(token);
-    token = strtok(nullptr, delimiters);
-  }
-  return tokens;
-}
-
 void CcdbApi::initHostsPool(std::string hosts)
 {
-  hostsPool = splitString(hosts, ",;");
+  hostsPool.clear();
+  auto splitted = hosts | std::views::transform([](char c) { return (c == ';') ? ',' : c; }) | std::views::split(',');
+  for (auto&& part : splitted) {
+    hostsPool.emplace_back(part.begin(), part.end());
+  }
 }
 
 std::string CcdbApi::getHostUrl(int hostIndex) const

From 1f0e87470ba69927be19730af82d79d7cfd1d0fb Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 7 Aug 2025 15:41:11 +0200
Subject: [PATCH 0672/1764] DPL tests: drop unneeded includes

---
 Framework/Core/test/test_HTTPParser.cxx                | 2 --
 Framework/Core/test/test_Parallel.cxx                  | 2 --
 Framework/Core/test/test_RegionInfoCallbackService.cxx | 7 -------
 Framework/Core/test/test_Services.cxx                  | 2 --
 Framework/Core/test/test_TimePipeline.cxx              | 6 ++----
 5 files changed, 2 insertions(+), 17 deletions(-)

diff --git a/Framework/Core/test/test_HTTPParser.cxx b/Framework/Core/test/test_HTTPParser.cxx
index b2889f9f305e1..1b87fcf49cfd4 100644
--- a/Framework/Core/test/test_HTTPParser.cxx
+++ b/Framework/Core/test/test_HTTPParser.cxx
@@ -9,8 +9,6 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include <boost/test/tools/old/interface.hpp>
-
 #include "../src/HTTPParser.h"
 #include <catch_amalgamated.hpp>
 
diff --git a/Framework/Core/test/test_Parallel.cxx b/Framework/Core/test/test_Parallel.cxx
index 7967f55a7b93d..35b8a52e663a1 100644
--- a/Framework/Core/test/test_Parallel.cxx
+++ b/Framework/Core/test/test_Parallel.cxx
@@ -17,8 +17,6 @@
 #include "Framework/ParallelContext.h"
 #include "Framework/runDataProcessing.h"
 
-#include <boost/algorithm/string.hpp>
-
 using namespace o2::framework;
 
 struct FakeCluster {
diff --git a/Framework/Core/test/test_RegionInfoCallbackService.cxx b/Framework/Core/test/test_RegionInfoCallbackService.cxx
index f0e7160bcfaad..178d6048545e6 100644
--- a/Framework/Core/test/test_RegionInfoCallbackService.cxx
+++ b/Framework/Core/test/test_RegionInfoCallbackService.cxx
@@ -8,19 +8,12 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-#include <boost/algorithm/string.hpp>
-
-#include "Framework/InputSpec.h"
 #include "Framework/CallbackService.h"
 #include "Framework/ControlService.h"
 #include "Framework/DataProcessorSpec.h"
-#include "Framework/ParallelContext.h"
 #include "Framework/runDataProcessing.h"
 #include "Framework/Logger.h"
 
-#include <chrono>
-#include <thread>
-
 using namespace o2::framework;
 using DataHeader = o2::header::DataHeader;
 
diff --git a/Framework/Core/test/test_Services.cxx b/Framework/Core/test/test_Services.cxx
index 056a3d0d9b6c4..abac9eca5e9b0 100644
--- a/Framework/Core/test/test_Services.cxx
+++ b/Framework/Core/test/test_Services.cxx
@@ -8,8 +8,6 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-#include <boost/test/tools/old/interface.hpp>
-
 #include "Framework/ServiceHandle.h"
 #include "Framework/ServiceRegistry.h"
 #include "Framework/CallbackService.h"
diff --git a/Framework/Core/test/test_TimePipeline.cxx b/Framework/Core/test/test_TimePipeline.cxx
index 8740f2ba365cd..5ff3eeae5e6cf 100644
--- a/Framework/Core/test/test_TimePipeline.cxx
+++ b/Framework/Core/test/test_TimePipeline.cxx
@@ -8,13 +8,11 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-#include "Framework/InputSpec.h"
+
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/ParallelContext.h"
 #include "Framework/runDataProcessing.h"
-
-#include <boost/algorithm/string.hpp>
-
+#include <thread>
 #include <chrono>
 
 using namespace o2::framework;

From 87ef0fc667ebea8b6c075d87a049cc10178a1676 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 7 Aug 2025 15:41:11 +0200
Subject: [PATCH 0673/1764] DPL: drop more boost_test usage

---
 Framework/Core/CMakeLists.txt           | 13 ++++++++-----
 Framework/Core/test/test_InfoLogger.cxx | 10 +++-------
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index d69194c83285e..f24ac6387649e 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -315,11 +315,14 @@ set_property(TARGET o2-test-framework-root PROPERTY RUNTIME_OUTPUT_DIRECTORY ${o
 add_test(NAME framework:root COMMAND o2-test-framework-root --skip-benchmarks)
 add_test(NAME framework:crash COMMAND  sh -e -c "PATH=${CMAKE_RUNTIME_OUTPUT_DIRECTORY}:$PATH ${CMAKE_CURRENT_LIST_DIR}/test/test_AllCrashTypes.sh")
 
-o2_add_test(InfoLogger NAME test_Framework_test_InfoLogger
-            SOURCES test/test_InfoLogger.cxx
-            COMPONENT_NAME Framework
-            LABELS framework
-            PUBLIC_LINK_LIBRARIES O2::Framework AliceO2::InfoLogger)
+add_executable(o2-test-framework-infologger
+               test/test_InfoLogger.cxx)
+target_link_libraries(o2-test-framework-infologger PRIVATE O2::Framework)
+target_link_libraries(o2-test-framework-infologger PRIVATE AliceO2::InfoLogger)
+target_link_libraries(o2-test-framework-infologger PRIVATE O2::Catch2)
+set_property(TARGET o2-test-framework-infologger
+             PROPERTY RUNTIME_OUTPUT_DIRECTORY ${outdir})
+add_test(NAME framework:infologger COMMAND o2-test-framework-infologger)
 
 o2_add_executable(dpl-null-sink
                   SOURCES src/o2NullSink.cxx
diff --git a/Framework/Core/test/test_InfoLogger.cxx b/Framework/Core/test/test_InfoLogger.cxx
index 4fde33c8775d7..b3a4e794bdcd4 100644
--- a/Framework/Core/test/test_InfoLogger.cxx
+++ b/Framework/Core/test/test_InfoLogger.cxx
@@ -8,16 +8,12 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-#define BOOST_TEST_MODULE Test Framework InfoLoggerTest
-#define BOOST_TEST_MAIN
-#define BOOST_TEST_DYN_LINK
-
-#include <boost/test/unit_test.hpp>
+#include <catch_amalgamated.hpp>
 
 #include <InfoLogger/InfoLogger.hxx>
 using namespace AliceO2::InfoLogger;
 
-BOOST_AUTO_TEST_CASE(InfoLoggerTest)
+TEST_CASE("InfoLoggerTest")
 {
 
   // define infologger output to stdout, as we don't want to use the default infoLoggerD pipe which might not be running here
@@ -27,5 +23,5 @@ BOOST_AUTO_TEST_CASE(InfoLoggerTest)
   InfoLogger theLog;
 
   // log a test message
-  BOOST_CHECK(theLog.log("This is a log message test to stdout") == 0);
+  CHECK(theLog.log("This is a log message test to stdout") == 0);
 }

From 00279c7108ea07b1e5b4091297b7bbaa20665a4f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 7 Aug 2025 15:41:11 +0200
Subject: [PATCH 0674/1764] DPL CCDB: move helper initialisation to a separate
 function

---
 Framework/CCDBSupport/src/CCDBHelpers.cxx | 97 ++++++++++++-----------
 1 file changed, 50 insertions(+), 47 deletions(-)

diff --git a/Framework/CCDBSupport/src/CCDBHelpers.cxx b/Framework/CCDBSupport/src/CCDBHelpers.cxx
index 71b6282c80086..2d44469c641f4 100644
--- a/Framework/CCDBSupport/src/CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/CCDBHelpers.cxx
@@ -20,10 +20,8 @@
 #include "CCDB/CcdbApi.h"
 #include "CommonConstants/LHCConstants.h"
 #include "Framework/Signpost.h"
-#include <typeinfo>
 #include <TError.h>
 #include <TMemFile.h>
-#include <functional>
 
 O2_DECLARE_DYNAMIC_LOG(ccdb);
 
@@ -159,6 +157,55 @@ CCDBHelpers::ParserResult CCDBHelpers::parseRemappings(char const* str)
   }
 }
 
+void initialiseHelper(CCDBFetcherHelper& helper, ConfigParamRegistry const& options, std::vector<o2::framework::OutputRoute> const& outputRoutes)
+{
+  std::unordered_map<std::string, bool> accountedSpecs;
+  auto defHost = options.get<std::string>("condition-backend");
+  auto checkRate = options.get<int>("condition-tf-per-query");
+  auto checkMult = options.get<int>("condition-tf-per-query-multiplier");
+  helper.timeToleranceMS = options.get<int64_t>("condition-time-tolerance");
+  helper.queryPeriodGlo = checkRate > 0 ? checkRate : std::numeric_limits<int>::max();
+  helper.queryPeriodFactor = checkMult > 0 ? checkMult : 1;
+  LOGP(info, "CCDB Backend at: {}, validity check for every {} TF{}", defHost, helper.queryPeriodGlo, helper.queryPeriodFactor == 1 ? std::string{} : fmt::format(", (query for high-rate objects downscaled by {})", helper.queryPeriodFactor));
+  LOGP(info, "Hook to enable signposts for CCDB messages at {}", (void*)&private_o2_log_ccdb->stacktrace);
+  auto remapString = options.get<std::string>("condition-remap");
+  CCDBHelpers::ParserResult result = CCDBHelpers::parseRemappings(remapString.c_str());
+  if (!result.error.empty()) {
+    throw runtime_error_f("Error while parsing remapping string %s", result.error.c_str());
+  }
+  helper.remappings = result.remappings;
+  helper.apis[""].init(defHost); // default backend
+  LOGP(info, "Initialised default CCDB host {}", defHost);
+  //
+  for (auto& entry : helper.remappings) { // init api instances for every host seen in the remapping
+    if (helper.apis.find(entry.second) == helper.apis.end()) {
+      helper.apis[entry.second].init(entry.second);
+      LOGP(info, "Initialised custom CCDB host {}", entry.second);
+    }
+    LOGP(info, "{} is remapped to {}", entry.first, entry.second);
+  }
+  helper.createdNotBefore = std::to_string(options.get<int64_t>("condition-not-before"));
+  helper.createdNotAfter = std::to_string(options.get<int64_t>("condition-not-after"));
+
+  for (auto& route : outputRoutes) {
+    if (route.matcher.lifetime != Lifetime::Condition) {
+      continue;
+    }
+    auto specStr = DataSpecUtils::describe(route.matcher);
+    if (accountedSpecs.find(specStr) != accountedSpecs.end()) {
+      continue;
+    }
+    accountedSpecs[specStr] = true;
+    helper.routes.push_back(route);
+    LOGP(info, "The following route is a condition {}", DataSpecUtils::describe(route.matcher));
+    for (auto& metadata : route.matcher.metadata) {
+      if (metadata.type == VariantType::String) {
+        LOGP(info, "- {}: {}", metadata.name, metadata.defaultValue.asString());
+      }
+    }
+  }
+}
+
 auto getOrbitResetTime(std::pmr::vector<char> const& v) -> Long64_t
 {
   Int_t previousErrorLevel = gErrorIgnoreLevel;
@@ -307,51 +354,7 @@ AlgorithmSpec CCDBHelpers::fetchFromCCDB()
 {
   return adaptStateful([](CallbackService& callbacks, ConfigParamRegistry const& options, DeviceSpec const& spec) {
       std::shared_ptr<CCDBFetcherHelper> helper = std::make_shared<CCDBFetcherHelper>();
-      std::unordered_map<std::string, bool> accountedSpecs;
-      auto defHost = options.get<std::string>("condition-backend");
-      auto checkRate = options.get<int>("condition-tf-per-query");
-      auto checkMult = options.get<int>("condition-tf-per-query-multiplier");
-      helper->timeToleranceMS = options.get<int64_t>("condition-time-tolerance");
-      helper->queryPeriodGlo = checkRate > 0 ? checkRate : std::numeric_limits<int>::max();
-      helper->queryPeriodFactor = checkMult > 0 ? checkMult : 1;
-      LOGP(info, "CCDB Backend at: {}, validity check for every {} TF{}", defHost, helper->queryPeriodGlo, helper->queryPeriodFactor == 1 ? std::string{} : fmt::format(", (query for high-rate objects downscaled by {})", helper->queryPeriodFactor));
-      LOGP(info, "Hook to enable signposts for CCDB messages at {}", (void*)&private_o2_log_ccdb->stacktrace);
-      auto remapString = options.get<std::string>("condition-remap");
-      ParserResult result = CCDBHelpers::parseRemappings(remapString.c_str());
-      if (!result.error.empty()) {
-        throw runtime_error_f("Error while parsing remapping string %s", result.error.c_str());
-      }
-      helper->remappings = result.remappings;
-      helper->apis[""].init(defHost); // default backend
-      LOGP(info, "Initialised default CCDB host {}", defHost);
-      //
-      for (auto& entry : helper->remappings) { // init api instances for every host seen in the remapping
-        if (helper->apis.find(entry.second) == helper->apis.end()) {
-          helper->apis[entry.second].init(entry.second);
-          LOGP(info, "Initialised custom CCDB host {}", entry.second);
-        }
-        LOGP(info, "{} is remapped to {}", entry.first, entry.second);
-      }
-      helper->createdNotBefore = std::to_string(options.get<int64_t>("condition-not-before"));
-      helper->createdNotAfter = std::to_string(options.get<int64_t>("condition-not-after"));
-
-      for (auto &route : spec.outputs) {
-        if (route.matcher.lifetime != Lifetime::Condition) {
-          continue;
-        }
-        auto specStr = DataSpecUtils::describe(route.matcher);
-        if (accountedSpecs.find(specStr) != accountedSpecs.end()) {
-          continue;
-        }
-        accountedSpecs[specStr] = true;
-        helper->routes.push_back(route);
-        LOGP(info, "The following route is a condition {}", DataSpecUtils::describe(route.matcher));
-        for (auto& metadata : route.matcher.metadata) {
-          if (metadata.type == VariantType::String) {
-            LOGP(info, "- {}: {}", metadata.name, metadata.defaultValue.asString());
-          }
-        }
-      }
+      initialiseHelper(*helper, options, spec.outputs);
       /// Add a callback on stop which dumps the statistics for the caching per
       /// path
       callbacks.set<CallbackService::Id::Stop>([helper]() {

From 6209646b6e6b4161efa09179ed1b52dde5b834a0 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 30 Jun 2025 09:39:40 +0200
Subject: [PATCH 0675/1764] DPL Analysis: fix hash calculation for the
 string_views

---
 Framework/Core/include/Framework/ASoA.h       | 385 +++++++++---------
 .../Core/include/Framework/StringHelpers.h    |   7 +
 Framework/Core/test/test_StringHelpers.cxx    |   5 +
 3 files changed, 204 insertions(+), 193 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index ccf2cab5e6807..9703f8eb26b9d 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -34,7 +34,6 @@
 #include <cstring>
 #include <gsl/span> // IWYU pragma: export
 #include <limits>
-#include <ranges>
 
 namespace o2::framework
 {
@@ -2307,7 +2306,7 @@ consteval static std::string_view namespace_prefix()
 {
   constexpr auto name = o2::framework::type_name<T>();
   const auto pos = name.rfind(std::string_view{":"});
-  return name.substr(0, pos - 1);
+  return name.substr(0, pos + 1);
 }
 } // namespace
 
@@ -2326,7 +2325,7 @@ consteval static std::string_view namespace_prefix()
 #define DECLARE_SOA_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_)                                                                                                                \
   struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                                                                                               \
     static constexpr const char* mLabel = _Label_;                                                                                                                                \
-    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_});                                                                        \
+    static constexpr const uint32_t hash = compile_time_hash(namespace_prefix<_Name_>(), std::string_view{#_Getter_});                                                            \
     static_assert(!((*(mLabel + 1) == 'I' && *(mLabel + 2) == 'n' && *(mLabel + 3) == 'd' && *(mLabel + 4) == 'e' && *(mLabel + 5) == 'x')), "Index is not a valid column name"); \
     using base = o2::soa::Column<_Type_, _Name_>;                                                                                                                                 \
     using type = _Type_;                                                                                                                                                          \
@@ -2362,7 +2361,7 @@ consteval static std::string_view namespace_prefix()
 #define DECLARE_SOA_BITMAP_COLUMN_FULL(_Name_, _Getter_, _Size_, _Label_)                                                                                                         \
   struct _Name_ : o2::soa::Column<MAKEINT(_Size_), _Name_> {                                                                                                                      \
     static constexpr const char* mLabel = _Label_;                                                                                                                                \
-    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_});                                                                        \
+    static constexpr const uint32_t hash = compile_time_hash(namespace_prefix<_Name_>(), std::string_view{#_Getter_});                                                            \
     static_assert(!((*(mLabel + 1) == 'I' && *(mLabel + 2) == 'n' && *(mLabel + 3) == 'd' && *(mLabel + 4) == 'e' && *(mLabel + 5) == 'x')), "Index is not a valid column name"); \
     using base = o2::soa::Column<MAKEINT(_Size_), _Name_>;                                                                                                                        \
     using type = MAKEINT(_Size_);                                                                                                                                                 \
@@ -2392,38 +2391,38 @@ consteval static std::string_view namespace_prefix()
 
 /// An 'expression' column. i.e. a column that can be calculated from other
 /// columns with gandiva based on static C++ expression.
-#define DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_, _Expression_)                \
-  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                        \
-    static constexpr const char* mLabel = _Label_;                                                         \
-    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_}); \
-    using base = o2::soa::Column<_Type_, _Name_>;                                                          \
-    using type = _Type_;                                                                                   \
-    using column_t = _Name_;                                                                               \
-    using spawnable_t = std::true_type;                                                                    \
-    _Name_(arrow::ChunkedArray const* column)                                                              \
-      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                             \
-    {                                                                                                      \
-    }                                                                                                      \
-                                                                                                           \
-    _Name_() = default;                                                                                    \
-    _Name_(_Name_ const& other) = default;                                                                 \
-    _Name_& operator=(_Name_ const& other) = default;                                                      \
-                                                                                                           \
-    decltype(auto) _Getter_() const                                                                        \
-    {                                                                                                      \
-      return *mColumnIterator;                                                                             \
-    }                                                                                                      \
-                                                                                                           \
-    decltype(auto) get() const                                                                             \
-    {                                                                                                      \
-      return _Getter_();                                                                                   \
-    }                                                                                                      \
-                                                                                                           \
-    static o2::framework::expressions::Projector Projector()                                               \
-    {                                                                                                      \
-      return _Expression_;                                                                                 \
-    }                                                                                                      \
-  };                                                                                                       \
+#define DECLARE_SOA_EXPRESSION_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_, _Expression_)                            \
+  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                                    \
+    static constexpr const char* mLabel = _Label_;                                                                     \
+    static constexpr const uint32_t hash = compile_time_hash(namespace_prefix<_Name_>(), std::string_view{#_Getter_}); \
+    using base = o2::soa::Column<_Type_, _Name_>;                                                                      \
+    using type = _Type_;                                                                                               \
+    using column_t = _Name_;                                                                                           \
+    using spawnable_t = std::true_type;                                                                                \
+    _Name_(arrow::ChunkedArray const* column)                                                                          \
+      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                                         \
+    {                                                                                                                  \
+    }                                                                                                                  \
+                                                                                                                       \
+    _Name_() = default;                                                                                                \
+    _Name_(_Name_ const& other) = default;                                                                             \
+    _Name_& operator=(_Name_ const& other) = default;                                                                  \
+                                                                                                                       \
+    decltype(auto) _Getter_() const                                                                                    \
+    {                                                                                                                  \
+      return *mColumnIterator;                                                                                         \
+    }                                                                                                                  \
+                                                                                                                       \
+    decltype(auto) get() const                                                                                         \
+    {                                                                                                                  \
+      return _Getter_();                                                                                               \
+    }                                                                                                                  \
+                                                                                                                       \
+    static o2::framework::expressions::Projector Projector()                                                           \
+    {                                                                                                                  \
+      return _Expression_;                                                                                             \
+    }                                                                                                                  \
+  };                                                                                                                   \
   [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, _Name_::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 #define DECLARE_SOA_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Expression_) \
@@ -2431,34 +2430,34 @@ consteval static std::string_view namespace_prefix()
 
 /// A configurable 'expression' column. i.e. a column that can be calculated from other
 /// columns with gandiva based on dynamically supplied C++ expression or a string definition.
-#define DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Label_)                      \
-  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                        \
-    static constexpr const char* mLabel = _Label_;                                                         \
-    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_}); \
-    static constexpr const int32_t mHash = _Label_ ""_h;                                                   \
-    using base = o2::soa::Column<_Type_, _Name_>;                                                          \
-    using type = _Type_;                                                                                   \
-    using column_t = _Name_;                                                                               \
-    using spawnable_t = std::true_type;                                                                    \
-    _Name_(arrow::ChunkedArray const* column)                                                              \
-      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                             \
-    {                                                                                                      \
-    }                                                                                                      \
-                                                                                                           \
-    _Name_() = default;                                                                                    \
-    _Name_(_Name_ const& other) = default;                                                                 \
-    _Name_& operator=(_Name_ const& other) = default;                                                      \
-                                                                                                           \
-    decltype(auto) _Getter_() const                                                                        \
-    {                                                                                                      \
-      return *mColumnIterator;                                                                             \
-    }                                                                                                      \
-                                                                                                           \
-    decltype(auto) get() const                                                                             \
-    {                                                                                                      \
-      return _Getter_();                                                                                   \
-    }                                                                                                      \
-  };                                                                                                       \
+#define DECLARE_SOA_CONFIGURABLE_EXPRESSION_COLUMN(_Name_, _Getter_, _Type_, _Label_)                                  \
+  struct _Name_ : o2::soa::Column<_Type_, _Name_> {                                                                    \
+    static constexpr const char* mLabel = _Label_;                                                                     \
+    static constexpr const uint32_t hash = compile_time_hash(namespace_prefix<_Name_>(), std::string_view{#_Getter_}); \
+    static constexpr const int32_t mHash = _Label_ ""_h;                                                               \
+    using base = o2::soa::Column<_Type_, _Name_>;                                                                      \
+    using type = _Type_;                                                                                               \
+    using column_t = _Name_;                                                                                           \
+    using spawnable_t = std::true_type;                                                                                \
+    _Name_(arrow::ChunkedArray const* column)                                                                          \
+      : o2::soa::Column<_Type_, _Name_>(o2::soa::ColumnIterator<type>(column))                                         \
+    {                                                                                                                  \
+    }                                                                                                                  \
+                                                                                                                       \
+    _Name_() = default;                                                                                                \
+    _Name_(_Name_ const& other) = default;                                                                             \
+    _Name_& operator=(_Name_ const& other) = default;                                                                  \
+                                                                                                                       \
+    decltype(auto) _Getter_() const                                                                                    \
+    {                                                                                                                  \
+      return *mColumnIterator;                                                                                         \
+    }                                                                                                                  \
+                                                                                                                       \
+    decltype(auto) get() const                                                                                         \
+    {                                                                                                                  \
+      return _Getter_();                                                                                               \
+    }                                                                                                                  \
+  };                                                                                                                   \
   [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, _Name_::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 /// An index column is a column of indices to elements / of another table named
@@ -2731,81 +2730,81 @@ consteval auto getIndexTargets()
 #define DECLARE_SOA_ARRAY_INDEX_COLUMN_CUSTOM(_Name_, _Getter_, _Label_) DECLARE_SOA_ARRAY_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, int32_t, _Name_##s, _Label_, "")
 
 /// NORMAL
-#define DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, _Label_, _Suffix_)                  \
-  struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                         \
-    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                       \
-    static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _");                         \
-    static constexpr const char* mLabel = "fIndex" _Label_ _Suffix_;                                                \
-    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_##Id>(), std::string_view{#_Getter_ "Id"}); \
-    using base = o2::soa::Column<_Type_, _Name_##Id>;                                                               \
-    using type = _Type_;                                                                                            \
-    using column_t = _Name_##Id;                                                                                    \
-    using binding_t = _Table_;                                                                                      \
-    static constexpr auto index_targets = getIndexTargets<_Table_>();                                               \
-    _Name_##Id(arrow::ChunkedArray const* column)                                                                   \
-      : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                  \
-    {                                                                                                               \
-    }                                                                                                               \
-                                                                                                                    \
-    _Name_##Id() = default;                                                                                         \
-    _Name_##Id(_Name_##Id const& other) = default;                                                                  \
-    _Name_##Id& operator=(_Name_##Id const& other) = default;                                                       \
-    type inline getId() const                                                                                       \
-    {                                                                                                               \
-      return _Getter_##Id();                                                                                        \
-    }                                                                                                               \
-                                                                                                                    \
-    type _Getter_##Id() const                                                                                       \
-    {                                                                                                               \
-      return *mColumnIterator;                                                                                      \
-    }                                                                                                               \
-                                                                                                                    \
-    bool has_##_Getter_() const                                                                                     \
-    {                                                                                                               \
-      return *mColumnIterator >= 0;                                                                                 \
-    }                                                                                                               \
-                                                                                                                    \
-    template <typename T>                                                                                           \
-    auto _Getter_##_as() const                                                                                      \
-    {                                                                                                               \
-      if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                           \
-        o2::soa::notBoundTable(#_Table_);                                                                           \
-      }                                                                                                             \
-      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                                 \
-        o2::soa::accessingInvalidIndexFor(#_Getter_);                                                               \
-      }                                                                                                             \
-      auto t = mBinding.get<T>();                                                                                   \
-      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                                      \
-        o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                                     \
-      }                                                                                                             \
-      return t->rawIteratorAt(*mColumnIterator);                                                                    \
-    }                                                                                                               \
-                                                                                                                    \
-    auto _Getter_() const                                                                                           \
-    {                                                                                                               \
-      return _Getter_##_as<binding_t>();                                                                            \
-    }                                                                                                               \
-                                                                                                                    \
-    template <typename T>                                                                                           \
-    bool setCurrent(T* current)                                                                                     \
-    {                                                                                                               \
-      if constexpr (o2::soa::is_binding_compatible_v<T, binding_t>()) {                                             \
-        assert(current != nullptr);                                                                                 \
-        this->mBinding.bind(current);                                                                               \
-        return true;                                                                                                \
-      }                                                                                                             \
-      return false;                                                                                                 \
-    }                                                                                                               \
-                                                                                                                    \
-    bool setCurrentRaw(o2::soa::Binding current)                                                                    \
-    {                                                                                                               \
-      this->mBinding = current;                                                                                     \
-      return true;                                                                                                  \
-    }                                                                                                               \
-    binding_t const* getCurrent() const { return mBinding.get<binding_t>(); }                                       \
-    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                     \
-    o2::soa::Binding mBinding;                                                                                      \
-  };                                                                                                                \
+#define DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, _Label_, _Suffix_)                              \
+  struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                                     \
+    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                                   \
+    static_assert((*_Suffix_ == '\0') || (*_Suffix_ == '_'), "Suffix has to begin with _");                                     \
+    static constexpr const char* mLabel = "fIndex" _Label_ _Suffix_;                                                            \
+    static constexpr const uint32_t hash = compile_time_hash(namespace_prefix<_Name_##Id>(), std::string_view{#_Getter_ "Id"}); \
+    using base = o2::soa::Column<_Type_, _Name_##Id>;                                                                           \
+    using type = _Type_;                                                                                                        \
+    using column_t = _Name_##Id;                                                                                                \
+    using binding_t = _Table_;                                                                                                  \
+    static constexpr auto index_targets = getIndexTargets<_Table_>();                                                           \
+    _Name_##Id(arrow::ChunkedArray const* column)                                                                               \
+      : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                              \
+    {                                                                                                                           \
+    }                                                                                                                           \
+                                                                                                                                \
+    _Name_##Id() = default;                                                                                                     \
+    _Name_##Id(_Name_##Id const& other) = default;                                                                              \
+    _Name_##Id& operator=(_Name_##Id const& other) = default;                                                                   \
+    type inline getId() const                                                                                                   \
+    {                                                                                                                           \
+      return _Getter_##Id();                                                                                                    \
+    }                                                                                                                           \
+                                                                                                                                \
+    type _Getter_##Id() const                                                                                                   \
+    {                                                                                                                           \
+      return *mColumnIterator;                                                                                                  \
+    }                                                                                                                           \
+                                                                                                                                \
+    bool has_##_Getter_() const                                                                                                 \
+    {                                                                                                                           \
+      return *mColumnIterator >= 0;                                                                                             \
+    }                                                                                                                           \
+                                                                                                                                \
+    template <typename T>                                                                                                       \
+    auto _Getter_##_as() const                                                                                                  \
+    {                                                                                                                           \
+      if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                                       \
+        o2::soa::notBoundTable(#_Table_);                                                                                       \
+      }                                                                                                                         \
+      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                                             \
+        o2::soa::accessingInvalidIndexFor(#_Getter_);                                                                           \
+      }                                                                                                                         \
+      auto t = mBinding.get<T>();                                                                                               \
+      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                                                  \
+        o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                                                 \
+      }                                                                                                                         \
+      return t->rawIteratorAt(*mColumnIterator);                                                                                \
+    }                                                                                                                           \
+                                                                                                                                \
+    auto _Getter_() const                                                                                                       \
+    {                                                                                                                           \
+      return _Getter_##_as<binding_t>();                                                                                        \
+    }                                                                                                                           \
+                                                                                                                                \
+    template <typename T>                                                                                                       \
+    bool setCurrent(T* current)                                                                                                 \
+    {                                                                                                                           \
+      if constexpr (o2::soa::is_binding_compatible_v<T, binding_t>()) {                                                         \
+        assert(current != nullptr);                                                                                             \
+        this->mBinding.bind(current);                                                                                           \
+        return true;                                                                                                            \
+      }                                                                                                                         \
+      return false;                                                                                                             \
+    }                                                                                                                           \
+                                                                                                                                \
+    bool setCurrentRaw(o2::soa::Binding current)                                                                                \
+    {                                                                                                                           \
+      this->mBinding = current;                                                                                                 \
+      return true;                                                                                                              \
+    }                                                                                                                           \
+    binding_t const* getCurrent() const { return mBinding.get<binding_t>(); }                                                   \
+    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                                 \
+    o2::soa::Binding mBinding;                                                                                                  \
+  };                                                                                                                            \
   [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" #_Table_ _Suffix_, _Name_##Id::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 #define DECLARE_SOA_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Table_, _Suffix_) DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, #_Table_, _Suffix_)
@@ -2813,60 +2812,60 @@ consteval auto getIndexTargets()
 #define DECLARE_SOA_INDEX_COLUMN_CUSTOM(_Name_, _Getter_, _Label_) DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, int32_t, _Name_##s, _Label_, "")
 
 /// SELF
-#define DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_)                    \
-  struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                         \
-    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                       \
-    static constexpr const char* mLabel = "fIndex" _Label_;                                                         \
-    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_##Id>(), std::string_view{#_Getter_ "Id"}); \
-    using base = o2::soa::Column<_Type_, _Name_##Id>;                                                               \
-    using type = _Type_;                                                                                            \
-    using column_t = _Name_##Id;                                                                                    \
-    using self_index_t = std::true_type;                                                                            \
-    using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>;            \
-    _Name_##Id(arrow::ChunkedArray const* column)                                                                   \
-      : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                  \
-    {                                                                                                               \
-    }                                                                                                               \
-                                                                                                                    \
-    _Name_##Id() = default;                                                                                         \
-    _Name_##Id(_Name_##Id const& other) = default;                                                                  \
-    _Name_##Id& operator=(_Name_##Id const& other) = default;                                                       \
-    type inline getId() const                                                                                       \
-    {                                                                                                               \
-      return _Getter_##Id();                                                                                        \
-    }                                                                                                               \
-                                                                                                                    \
-    type _Getter_##Id() const                                                                                       \
-    {                                                                                                               \
-      return *mColumnIterator;                                                                                      \
-    }                                                                                                               \
-                                                                                                                    \
-    bool has_##_Getter_() const                                                                                     \
-    {                                                                                                               \
-      return *mColumnIterator >= 0;                                                                                 \
-    }                                                                                                               \
-                                                                                                                    \
-    template <typename T>                                                                                           \
-    auto _Getter_##_as() const                                                                                      \
-    {                                                                                                               \
-      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                                 \
-        o2::soa::accessingInvalidIndexFor(#_Getter_);                                                               \
-      }                                                                                                             \
-      auto t = mBinding.get<T>();                                                                                   \
-      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                                      \
-        o2::soa::dereferenceWithWrongType(#_Getter_, "self");                                                       \
-      }                                                                                                             \
-      return t->rawIteratorAt(*mColumnIterator);                                                                    \
-    }                                                                                                               \
-                                                                                                                    \
-    bool setCurrentRaw(o2::soa::Binding current)                                                                    \
-    {                                                                                                               \
-      this->mBinding = current;                                                                                     \
-      return true;                                                                                                  \
-    }                                                                                                               \
-    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                     \
-    o2::soa::Binding mBinding;                                                                                      \
-  };                                                                                                                \
+#define DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, _IndexTarget_)                                \
+  struct _Name_##Id : o2::soa::Column<_Type_, _Name_##Id> {                                                                     \
+    static_assert(std::is_integral_v<_Type_>, "Index type must be integral");                                                   \
+    static constexpr const char* mLabel = "fIndex" _Label_;                                                                     \
+    static constexpr const uint32_t hash = compile_time_hash(namespace_prefix<_Name_##Id>(), std::string_view{#_Getter_ "Id"}); \
+    using base = o2::soa::Column<_Type_, _Name_##Id>;                                                                           \
+    using type = _Type_;                                                                                                        \
+    using column_t = _Name_##Id;                                                                                                \
+    using self_index_t = std::true_type;                                                                                        \
+    using compatible_signature = std::conditional<aod::is_aod_hash<_IndexTarget_>, _IndexTarget_, void>;                        \
+    _Name_##Id(arrow::ChunkedArray const* column)                                                                               \
+      : o2::soa::Column<_Type_, _Name_##Id>(o2::soa::ColumnIterator<type>(column))                                              \
+    {                                                                                                                           \
+    }                                                                                                                           \
+                                                                                                                                \
+    _Name_##Id() = default;                                                                                                     \
+    _Name_##Id(_Name_##Id const& other) = default;                                                                              \
+    _Name_##Id& operator=(_Name_##Id const& other) = default;                                                                   \
+    type inline getId() const                                                                                                   \
+    {                                                                                                                           \
+      return _Getter_##Id();                                                                                                    \
+    }                                                                                                                           \
+                                                                                                                                \
+    type _Getter_##Id() const                                                                                                   \
+    {                                                                                                                           \
+      return *mColumnIterator;                                                                                                  \
+    }                                                                                                                           \
+                                                                                                                                \
+    bool has_##_Getter_() const                                                                                                 \
+    {                                                                                                                           \
+      return *mColumnIterator >= 0;                                                                                             \
+    }                                                                                                                           \
+                                                                                                                                \
+    template <typename T>                                                                                                       \
+    auto _Getter_##_as() const                                                                                                  \
+    {                                                                                                                           \
+      if (O2_BUILTIN_UNLIKELY(!has_##_Getter_())) {                                                                             \
+        o2::soa::accessingInvalidIndexFor(#_Getter_);                                                                           \
+      }                                                                                                                         \
+      auto t = mBinding.get<T>();                                                                                               \
+      if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                                                  \
+        o2::soa::dereferenceWithWrongType(#_Getter_, "self");                                                                   \
+      }                                                                                                                         \
+      return t->rawIteratorAt(*mColumnIterator);                                                                                \
+    }                                                                                                                           \
+                                                                                                                                \
+    bool setCurrentRaw(o2::soa::Binding current)                                                                                \
+    {                                                                                                                           \
+      this->mBinding = current;                                                                                                 \
+      return true;                                                                                                              \
+    }                                                                                                                           \
+    o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                                 \
+    o2::soa::Binding mBinding;                                                                                                  \
+  };                                                                                                                            \
   [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" _Label_, _Name_##Id::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 #define DECLARE_SOA_SELF_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Label_) DECLARE_SOA_SELF_INDEX_COLUMN_COMPLETE(_Name_, _Getter_, _Type_, _Label_, void)
diff --git a/Framework/Core/include/Framework/StringHelpers.h b/Framework/Core/include/Framework/StringHelpers.h
index e450764576c29..8a2d892062f70 100644
--- a/Framework/Core/include/Framework/StringHelpers.h
+++ b/Framework/Core/include/Framework/StringHelpers.h
@@ -85,6 +85,13 @@ consteval uint32_t crc32(Ts... Vs)
   return crc;
 }
 
+template <typename... Ts>
+  requires(std::same_as<Ts, std::string_view> && ...)
+consteval uint32_t compile_time_hash(Ts... Vs)
+{
+  return crc32(Vs...) ^ 0xFFFFFFFF;
+}
+
 consteval uint32_t compile_time_hash(char const* str)
 {
   return crc32(str, static_cast<int>(__builtin_strlen(str)) - 1) ^ 0xFFFFFFFF;
diff --git a/Framework/Core/test/test_StringHelpers.cxx b/Framework/Core/test/test_StringHelpers.cxx
index 44f3fffd4efee..96abe20b814a9 100644
--- a/Framework/Core/test/test_StringHelpers.cxx
+++ b/Framework/Core/test/test_StringHelpers.cxx
@@ -12,6 +12,9 @@
 #include <catch_amalgamated.hpp>
 #include "Framework/StringHelpers.h"
 
+static constexpr std::string_view part1 = "o2::aod::track::";
+static constexpr std::string_view part2 = "pt";
+
 TEST_CASE("StringHelpersHash")
 {
   std::string s{"test-string"};
@@ -19,6 +22,8 @@ TEST_CASE("StringHelpersHash")
   REQUIRE(runtime_hash(s.c_str()) == compile_time_hash("test-string"));
   REQUIRE(runtime_hash(cs) == compile_time_hash("test-string"));
   REQUIRE(runtime_hash(s.c_str()) == runtime_hash(cs));
+
+  REQUIRE(compile_time_hash(part1, part2) == "o2::aod::track::pt"_h);
 }
 
 template <typename T>

From 7129f4565628b8f9c6cbcdf2df43acd9d5a48272 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 30 Jun 2025 09:40:08 +0200
Subject: [PATCH 0676/1764] DPL Analysis: add parsing of expressions from
 strings

---
 Framework/Core/include/Framework/BasicOps.h   |  58 ++
 .../include/Framework/ExpressionHelpers.h     |  19 +-
 .../Core/include/Framework/Expressions.h      | 329 +++++++----
 Framework/Core/src/Expressions.cxx            | 535 +++++++++++++++++-
 Framework/Core/test/test_Expressions.cxx      |  72 ++-
 5 files changed, 856 insertions(+), 157 deletions(-)

diff --git a/Framework/Core/include/Framework/BasicOps.h b/Framework/Core/include/Framework/BasicOps.h
index 0927b557c86bc..06880de275b9e 100644
--- a/Framework/Core/include/Framework/BasicOps.h
+++ b/Framework/Core/include/Framework/BasicOps.h
@@ -10,6 +10,9 @@
 // or submit itself to any jurisdiction.
 #ifndef O2_FRAMEWORK_BASICOPS_H_
 #define O2_FRAMEWORK_BASICOPS_H_
+#include <array>
+#include <string_view>
+#include "CommonConstants/MathConstants.h"
 
 namespace o2::framework
 {
@@ -46,6 +49,61 @@ enum BasicOp : unsigned int {
   BitwiseNot,
   Conditional // 3-ar functions
 };
+
+static constexpr std::array<std::string_view, BasicOp::Conditional + 1> mapping{
+  "&&",
+  "||",
+  "+",
+  "-",
+  "/",
+  "*",
+  "&",
+  "|",
+  "^",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "==",
+  "!=",
+  "natan2",
+  "npow",
+  "nsqrt",
+  "nexp",
+  "nlog",
+  "nlog10",
+  "nsin",
+  "ncos",
+  "ntan",
+  "nasin",
+  "nacos",
+  "natan",
+  "nabs",
+  "nround",
+  "nbitwise_not",
+  "ifnode"};
+
+static constexpr std::array<std::string_view, 9> mathConstants{
+  "Almost0",
+  "Epsilon",
+  "Almost1",
+  "VeryBig",
+  "PI",
+  "TwoPI",
+  "PIHalf",
+  "PIThird",
+  "PIQuarter"};
+
+static constexpr std::array<float, 9> mathConstantsValues{
+  o2::constants::math::Almost0,
+  o2::constants::math::Epsilon,
+  o2::constants::math::Almost1,
+  o2::constants::math::VeryBig,
+  o2::constants::math::PI,
+  o2::constants::math::TwoPI,
+  o2::constants::math::PIHalf,
+  o2::constants::math::PIThird,
+  o2::constants::math::PIQuarter};
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_BASICOPS_H_
diff --git a/Framework/Core/include/Framework/ExpressionHelpers.h b/Framework/Core/include/Framework/ExpressionHelpers.h
index f881abf7b0e6c..cd2ccd743c5d6 100644
--- a/Framework/Core/include/Framework/ExpressionHelpers.h
+++ b/Framework/Core/include/Framework/ExpressionHelpers.h
@@ -25,17 +25,26 @@ struct DatumSpec {
   size_t hash = 0;
   atype::type type = atype::NA;
 
-  explicit DatumSpec(size_t index, atype::type type_) : datum{index}, type{type_} {}
-  explicit DatumSpec(LiteralNode::var_t literal, atype::type type_) : datum{literal}, type{type_} {}
-  explicit DatumSpec(std::string binding, size_t hash_, atype::type type_) : datum{binding}, hash{hash_}, type{type_} {}
+  explicit constexpr DatumSpec(size_t index, atype::type type_) : datum{index}, type{type_} {}
+  explicit constexpr DatumSpec(LiteralNode::var_t literal, atype::type type_) : datum{literal}, type{type_} {}
+  explicit constexpr DatumSpec(std::string binding, size_t hash_, atype::type type_) : datum{binding}, hash{hash_}, type{type_} {}
   DatumSpec() = default;
   DatumSpec(DatumSpec const&) = default;
   DatumSpec(DatumSpec&&) = default;
   DatumSpec& operator=(DatumSpec const&) = default;
   DatumSpec& operator=(DatumSpec&&) = default;
-};
 
-bool operator==(DatumSpec const& lhs, DatumSpec const& rhs);
+  bool operator==(DatumSpec const& rhs) const
+  {
+    bool eqValue = this->datum == rhs.datum;
+    bool eqHash = true;
+    if (this->datum.index() == 3 && eqValue) {
+      eqHash = this->hash == rhs.hash;
+    }
+    bool eqType = this->type == rhs.type;
+    return eqValue && eqHash && eqType;
+  }
+};
 
 std::ostream& operator<<(std::ostream& os, DatumSpec const& spec);
 
diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 4163a73f83983..6568f5d58c421 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -110,13 +110,16 @@ std::string upcastTo(atype::type f);
 
 /// An expression tree node corresponding to a literal value
 struct LiteralNode {
+  LiteralNode()
+    : value{-1},
+      type{atype::INT32}
+  {
+  }
   template <typename T>
   LiteralNode(T v) : value{v}, type{selectArrowType<T>()}
   {
   }
 
-  LiteralNode(LiteralNode const& other) = default;
-
   using var_t = LiteralValue::stored_type;
   var_t value;
   atype::type type = atype::NA;
@@ -124,9 +127,16 @@ struct LiteralNode {
 
 /// An expression tree node corresponding to a column binding
 struct BindingNode {
+  constexpr BindingNode()
+    : name{nullptr},
+      hash{0},
+      type{atype::FLOAT}
+  {
+  }
   BindingNode(BindingNode const&) = default;
   BindingNode(BindingNode&&) = delete;
   constexpr BindingNode(const char* name_, uint32_t hash_, atype::type type_) : name{name_}, hash{hash_}, type{type_} {}
+  constexpr BindingNode(uint32_t hash_, atype::type type_) : name{nullptr}, hash{hash_}, type{type_} {}
   const char* name;
   uint32_t hash;
   atype::type type;
@@ -134,8 +144,8 @@ struct BindingNode {
 
 /// An expression tree node corresponding to binary or unary operation
 struct OpNode {
+  OpNode() : op{BasicOp::Abs} {}
   OpNode(BasicOp op_) : op{op_} {}
-  OpNode(OpNode const& other) = default;
   BasicOp op;
 };
 
@@ -155,8 +165,6 @@ struct PlaceholderNode : LiteralNode {
     retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{static_cast<AT>(context.options().get<T>(name))}; };
   }
 
-  PlaceholderNode(PlaceholderNode const& other) = default;
-
   void reset(InitContext& context)
   {
     value = retrieve(context, name.data());
@@ -180,8 +188,6 @@ struct ParameterNode : LiteralNode {
   {
   }
 
-  ParameterNode(ParameterNode const&) = default;
-
   template <typename T>
   void reset(T value_, int index_ = -1)
   {
@@ -221,7 +227,7 @@ struct Node {
   {
   }
 
-  Node(Node&& n) : self{std::forward<self_t>(n.self)}, left{std::forward<std::unique_ptr<Node>>(n.left)}, right{std::forward<std::unique_ptr<Node>>(n.right)}, condition{std::forward<std::unique_ptr<Node>>(n.condition)}
+  Node(Node&& n) : self{std::forward<self_t>(n.self)}, left{std::forward<std::unique_ptr<Node>>(n.left)}, right{std::forward<std::unique_ptr<Node>>(n.right)}, condition{std::forward<std::unique_ptr<Node>>(n.condition)}, binding{std::forward<std::string>(n.binding)}
   {
   }
 
@@ -229,6 +235,11 @@ struct Node {
   {
   }
 
+  Node(BindingNode const& n, std::string binding_) : self{n}, left{nullptr}, right{nullptr}, condition{nullptr}, binding{binding_}
+  {
+    get<BindingNode>(self).name = binding.c_str();
+  }
+
   Node(ParameterNode&& p) : self{std::forward<ParameterNode>(p)}, left{nullptr}, right{nullptr}, condition{nullptr}
   {
   }
@@ -239,12 +250,24 @@ struct Node {
       right{std::make_unique<Node>(std::forward<Node>(else_))},
       condition{std::make_unique<Node>(std::forward<Node>(condition_))} {}
 
+  Node(ConditionalNode op, Node&& then_, std::unique_ptr<Node>&& else_, Node&& condition_)
+    : self{op},
+      left{std::make_unique<Node>(std::forward<Node>(then_))},
+      right{std::forward<std::unique_ptr<Node>>(else_)},
+      condition{std::make_unique<Node>(std::forward<Node>(condition_))} {}
+
   Node(OpNode op, Node&& l, Node&& r)
     : self{op},
       left{std::make_unique<Node>(std::forward<Node>(l))},
       right{std::make_unique<Node>(std::forward<Node>(r))},
       condition{nullptr} {}
 
+  Node(OpNode op, std::unique_ptr<Node>&& l, Node&& r)
+    : self{op},
+      left{std::forward<std::unique_ptr<Node>>(l)},
+      right{std::make_unique<Node>(std::forward<Node>(r))},
+      condition{nullptr} {}
+
   Node(OpNode op, Node&& l)
     : self{op},
       left{std::make_unique<Node>(std::forward<Node>(l))},
@@ -264,6 +287,10 @@ struct Node {
     if (other.condition != nullptr) {
       condition = std::make_unique<Node>(*other.condition);
     }
+    binding = other.binding;
+    if (!binding.empty()) {
+      get<BindingNode>(self).name = binding.c_str();
+    }
   }
 
   /// variant with possible nodes
@@ -274,6 +301,9 @@ struct Node {
   std::unique_ptr<Node> left = nullptr;
   std::unique_ptr<Node> right = nullptr;
   std::unique_ptr<Node> condition = nullptr;
+
+  /// buffer for dynamic binding
+  std::string binding;
 };
 
 /// helper struct used to parse trees
@@ -315,54 +345,58 @@ void walk(Node* head, L&& pred)
   }
 }
 
+/// helper concepts
+template <typename T>
+concept arithmetic = std::is_arithmetic_v<T>;
+
 /// overloaded operators to build the tree from an expression
 
-#define BINARY_OP_NODES(_operator_, _operation_)                                                        \
-  inline Node operator _operator_(Node&& left, Node&& right)                                            \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), std::forward<Node>(right)};     \
-  }                                                                                                     \
-  template <typename T>                                                                                 \
-  inline Node operator _operator_(Node&& left, T right) requires(std::is_arithmetic_v<std::decay_t<T>>) \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), LiteralNode{right}};            \
-  }                                                                                                     \
-  template <typename T>                                                                                 \
-  inline Node operator _operator_(T left, Node&& right) requires(std::is_arithmetic_v<std::decay_t<T>>) \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, LiteralNode{left}, std::forward<Node>(right)};            \
-  }                                                                                                     \
-  template <typename T>                                                                                 \
-  inline Node operator _operator_(Node&& left, Configurable<T> const& right)                            \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), PlaceholderNode{right}};        \
-  }                                                                                                     \
-  template <typename T>                                                                                 \
-  inline Node operator _operator_(Configurable<T> const& left, Node&& right)                            \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, PlaceholderNode{left}, std::forward<Node>(right)};        \
-  }                                                                                                     \
-  inline Node operator _operator_(BindingNode const& left, BindingNode const& right)                    \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, left, right};                                             \
-  }                                                                                                     \
-  inline Node operator _operator_(BindingNode const& left, Node&& right)                                \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, left, std::forward<Node>(right)};                         \
-  }                                                                                                     \
-  inline Node operator _operator_(Node&& left, BindingNode const& right)                                \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), right};                         \
-  }                                                                                                     \
-  template <typename T>                                                                                 \
-  inline Node operator _operator_(Configurable<T> const& left, BindingNode const& right)                \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, PlaceholderNode{left}, right};                            \
-  }                                                                                                     \
-  template <typename T>                                                                                 \
-  inline Node operator _operator_(BindingNode const& left, Configurable<T> const& right)                \
-  {                                                                                                     \
-    return Node{OpNode{BasicOp::_operation_}, left, PlaceholderNode{right}};                            \
+#define BINARY_OP_NODES(_operator_, _operation_)                                                    \
+  inline Node operator _operator_(Node&& left, Node&& right)                                        \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), std::forward<Node>(right)}; \
+  }                                                                                                 \
+  template <arithmetic T>                                                                           \
+  inline Node operator _operator_(Node&& left, T right)                                             \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), LiteralNode{right}};        \
+  }                                                                                                 \
+  template <arithmetic T>                                                                           \
+  inline Node operator _operator_(T left, Node&& right)                                             \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, LiteralNode{left}, std::forward<Node>(right)};        \
+  }                                                                                                 \
+  template <typename T>                                                                             \
+  inline Node operator _operator_(Node&& left, Configurable<T> const& right)                        \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), PlaceholderNode{right}};    \
+  }                                                                                                 \
+  template <typename T>                                                                             \
+  inline Node operator _operator_(Configurable<T> const& left, Node&& right)                        \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, PlaceholderNode{left}, std::forward<Node>(right)};    \
+  }                                                                                                 \
+  inline Node operator _operator_(BindingNode const& left, BindingNode const& right)                \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, left, right};                                         \
+  }                                                                                                 \
+  inline Node operator _operator_(BindingNode const& left, Node&& right)                            \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, left, std::forward<Node>(right)};                     \
+  }                                                                                                 \
+  inline Node operator _operator_(Node&& left, BindingNode const& right)                            \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, std::forward<Node>(left), right};                     \
+  }                                                                                                 \
+  template <typename T>                                                                             \
+  inline Node operator _operator_(Configurable<T> const& left, BindingNode const& right)            \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, PlaceholderNode{left}, right};                        \
+  }                                                                                                 \
+  template <typename T>                                                                             \
+  inline Node operator _operator_(BindingNode const& left, Configurable<T> const& right)            \
+  {                                                                                                 \
+    return Node{OpNode{BasicOp::_operation_}, left, PlaceholderNode{right}};                        \
   }
 
 BINARY_OP_NODES(&, BitwiseAnd);
@@ -382,61 +416,61 @@ BINARY_OP_NODES(&&, LogicalAnd);
 BINARY_OP_NODES(||, LogicalOr);
 
 /// functions
-template <typename T>
-inline Node npow(Node&& left, T right) requires(std::is_arithmetic_v<T>)
+template <arithmetic T>
+inline Node npow(Node&& left, T right)
 {
   return Node{OpNode{BasicOp::Power}, std::forward<Node>(left), LiteralNode{right}};
 }
 
-#define BINARY_FUNC_NODES(_func_, _node_)                                                          \
-  template <typename L, typename R>                                                                \
-  inline Node _node_(L left, R right) requires(std::is_arithmetic_v<L> && std::is_arithmetic_v<R>) \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, LiteralNode{left}, LiteralNode{right}};                   \
-  }                                                                                                \
-                                                                                                   \
-  inline Node _node_(Node&& left, Node&& right)                                                    \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), std::forward<Node>(right)};     \
-  }                                                                                                \
-                                                                                                   \
-  inline Node _node_(Node&& left, BindingNode const& right)                                        \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), right};                         \
-  }                                                                                                \
-                                                                                                   \
-  inline Node _node_(BindingNode const& left, BindingNode const& right)                            \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, left, right};                                             \
-  }                                                                                                \
-                                                                                                   \
-  inline Node _node_(BindingNode const& left, Node&& right)                                        \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, left, std::forward<Node>(right)};                         \
-  }                                                                                                \
-                                                                                                   \
-  template <typename T>                                                                            \
-  inline Node _node_(Node&& left, Configurable<T> const& right)                                    \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), PlaceholderNode{right}};        \
-  }                                                                                                \
-                                                                                                   \
-  template <typename T>                                                                            \
-  inline Node _node_(Configurable<T> const& left, Node&& right)                                    \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, PlaceholderNode{left}, std::forward<Node>(right)};        \
-  }                                                                                                \
-                                                                                                   \
-  template <typename T>                                                                            \
-  inline Node _node_(BindingNode const& left, Configurable<T> const& right)                        \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, left, PlaceholderNode{right}};                            \
-  }                                                                                                \
-                                                                                                   \
-  template <typename T>                                                                            \
-  inline Node _node_(Configurable<T> const& left, BindingNode const& right)                        \
-  {                                                                                                \
-    return Node{OpNode{BasicOp::_func_}, PlaceholderNode{left}, right};                            \
+#define BINARY_FUNC_NODES(_func_, _node_)                                                      \
+  template <arithmetic L, arithmetic R>                                                        \
+  inline Node _node_(L left, R right)                                                          \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, LiteralNode{left}, LiteralNode{right}};               \
+  }                                                                                            \
+                                                                                               \
+  inline Node _node_(Node&& left, Node&& right)                                                \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), std::forward<Node>(right)}; \
+  }                                                                                            \
+                                                                                               \
+  inline Node _node_(Node&& left, BindingNode const& right)                                    \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), right};                     \
+  }                                                                                            \
+                                                                                               \
+  inline Node _node_(BindingNode const& left, BindingNode const& right)                        \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, left, right};                                         \
+  }                                                                                            \
+                                                                                               \
+  inline Node _node_(BindingNode const& left, Node&& right)                                    \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, left, std::forward<Node>(right)};                     \
+  }                                                                                            \
+                                                                                               \
+  template <typename T>                                                                        \
+  inline Node _node_(Node&& left, Configurable<T> const& right)                                \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, std::forward<Node>(left), PlaceholderNode{right}};    \
+  }                                                                                            \
+                                                                                               \
+  template <typename T>                                                                        \
+  inline Node _node_(Configurable<T> const& left, Node&& right)                                \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, PlaceholderNode{left}, std::forward<Node>(right)};    \
+  }                                                                                            \
+                                                                                               \
+  template <typename T>                                                                        \
+  inline Node _node_(BindingNode const& left, Configurable<T> const& right)                    \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, left, PlaceholderNode{right}};                        \
+  }                                                                                            \
+                                                                                               \
+  template <typename T>                                                                        \
+  inline Node _node_(Configurable<T> const& left, BindingNode const& right)                    \
+  {                                                                                            \
+    return Node{OpNode{BasicOp::_func_}, PlaceholderNode{left}, right};                        \
   }
 
 BINARY_FUNC_NODES(Atan2, natan2);
@@ -469,20 +503,20 @@ inline Node ifnode(Node&& condition_, Node&& then_, Node&& else_)
   return Node{ConditionalNode{}, std::forward<Node>(then_), std::forward<Node>(else_), std::forward<Node>(condition_)};
 }
 
-template <typename L>
-inline Node ifnode(Node&& condition_, Node&& then_, L else_) requires(std::is_arithmetic_v<L>)
+template <arithmetic L>
+inline Node ifnode(Node&& condition_, Node&& then_, L else_)
 {
   return Node{ConditionalNode{}, std::forward<Node>(then_), LiteralNode{else_}, std::forward<Node>(condition_)};
 }
 
-template <typename L>
-inline Node ifnode(Node&& condition_, L then_, Node&& else_) requires(std::is_arithmetic_v<L>)
+template <arithmetic L>
+inline Node ifnode(Node&& condition_, L then_, Node&& else_)
 {
   return Node{ConditionalNode{}, LiteralNode{then_}, std::forward<Node>(else_), std::forward<Node>(condition_)};
 }
 
-template <typename L1, typename L2>
-inline Node ifnode(Node&& condition_, L1 then_, L2 else_) requires(std::is_arithmetic_v<L1>&& std::is_arithmetic_v<L2>)
+template <arithmetic L1, arithmetic L2>
+inline Node ifnode(Node&& condition_, L1 then_, L2 else_)
 {
   return Node{ConditionalNode{}, LiteralNode{then_}, LiteralNode{else_}, std::forward<Node>(condition_)};
 }
@@ -644,6 +678,79 @@ std::shared_ptr<gandiva::Projector> createProjectors(framework::pack<C...>, std:
 }
 
 void updateFilterInfo(ExpressionInfo& info, std::shared_ptr<arrow::Table>& table);
+
+/*
+ * The formal grammar for framework expressions.
+ * Operations are in the order of increasing priority.
+ * Identifier includes namespaces, e.g. o2::aod::track::pt.
+ *
+ * top ::= primary
+ *
+ * primary ::= tier1 ('||' tier1)*
+ * tier1 ::= tier2 ('&&' tier2)*
+ * tier2 ::= tier3 ('|' tier3)*
+ * tier3 ::= tier4 ('^' tier4)*
+ * tier4 ::= tier5 ('&' tier5)*
+ * tier5 ::= tier6 (('=='|'!=') tier6)*
+ * tier6 ::= tier7 (('<'|'>'|'<='|'>=') tier7)*
+ * tier7 ::= tier8 (('+'|'-') tier8)*
+ * tier8 ::= base (('*'|'/') base)*
+ *
+ * base ::= identifier
+ *  | number
+ *  | function_call
+ *  | '(' primary ')'
+ *
+ * number ::= -?[0-9]+(\.[0-9]*)?([uf])?
+ * identifier ::= [a-zA-Z][a-zA-Z0-9_]* ('::' [a-zA-Z][a-zA-Z0-9_]*)*
+ * function_call ::= identifier '(' (primary (',' primary)*)? ')'
+ */
+
+/// String parsing
+enum Token : int {
+  EoL = -1,
+  Identifier = -2,
+  IntegerNumber = -3,
+  FloatNumber = -4,
+  BinaryOp = -5,
+  Unexpected = -100
+};
+
+struct Tokenizer {
+  std::string source;
+  std::string::iterator current;
+  std::string IdentifierStr;
+  std::string BinaryOpStr;
+  std::string StrValue;
+  std::string TokenStr;
+  std::variant<uint32_t, int32_t, uint64_t, int64_t> IntegerValue;
+  std::variant<float, double> FloatValue;
+  char LastChar;
+  int currentToken = Token::Unexpected;
+
+  Tokenizer(std::string const& input = "");
+  void reset(std::string const& input);
+  [[maybe_unused]] int nextToken();
+  void pop();
+  char peek();
+};
+
+struct Parser {
+  static Node parse(std::string const& input);
+  static std::unique_ptr<Node> parsePrimary(Tokenizer& tk);
+  static std::unique_ptr<Node> parseTier1(Tokenizer& tk);
+  static std::unique_ptr<Node> parseTier2(Tokenizer& tk);
+  static std::unique_ptr<Node> parseTier3(Tokenizer& tk);
+  static std::unique_ptr<Node> parseTier4(Tokenizer& tk);
+  static std::unique_ptr<Node> parseTier5(Tokenizer& tk);
+  static std::unique_ptr<Node> parseTier6(Tokenizer& tk);
+  static std::unique_ptr<Node> parseTier7(Tokenizer& tk);
+  static std::unique_ptr<Node> parseTier8(Tokenizer& tk);
+  static std::unique_ptr<Node> parseBase(Tokenizer& tk);
+
+  static OpNode opFromToken(std::string const& token);
+};
+
 } // namespace o2::framework::expressions
 
 #endif // O2_FRAMEWORK_EXPRESSIONS_H_
diff --git a/Framework/Core/src/Expressions.cxx b/Framework/Core/src/Expressions.cxx
index 94649f8639a0a..3e52d49dfa4bb 100644
--- a/Framework/Core/src/Expressions.cxx
+++ b/Framework/Core/src/Expressions.cxx
@@ -31,7 +31,7 @@ void unknownParameterUsed(const char* name)
 
 /// a map between BasicOp and gandiva node definitions
 /// note that logical 'and' and 'or' are created separately
-static const std::array<std::string, BasicOp::Conditional + 1> basicOperationsMap = {
+static constexpr std::array<const char*, BasicOp::Conditional + 1> basicOperationsMap = {
   "and",
   "or",
   "add",
@@ -175,11 +175,6 @@ std::string upcastTo(atype::type f)
   }
 }
 
-bool operator==(DatumSpec const& lhs, DatumSpec const& rhs)
-{
-  return (lhs.datum == rhs.datum) && (lhs.type == rhs.type);
-}
-
 std::ostream& operator<<(std::ostream& os, DatumSpec const& spec)
 {
   std::visit(
@@ -332,7 +327,7 @@ Operations createOperations(Filter const& expression)
   std::vector<atype::type> resultTypes;
   resultTypes.resize(OperationSpecs.size());
 
-  auto inferResultType = [&resultTypes](DatumSpec& left, DatumSpec& right) {
+  auto inferResultType = [&resultTypes](BasicOp op, DatumSpec& left, DatumSpec& right) {
     // if the left datum is monostate (error)
     if (left.datum.index() == 0) {
       throw runtime_error("Malformed operation spec: empty left datum");
@@ -365,11 +360,15 @@ Operations createOperations(Filter const& expression)
       return (t == atype::UINT8) || (t == atype::INT8) || (t == atype::UINT16) || (t == atype::INT16) || (t == atype::UINT32) || (t == atype::INT32) || (t == atype::UINT64) || (t == atype::INT64);
     };
 
+    auto isBitwiseOp = [](auto o) {
+      return ((o == BasicOp::BitwiseAnd) || (o == BasicOp::BitwiseNot) || (o == BasicOp::BitwiseOr) || (o == BasicOp::BitwiseXor));
+    };
+
     if (isIntType(t1)) {
-      if (t2 == atype::FLOAT) {
+      if (t2 == atype::FLOAT && !isBitwiseOp(op)) {
         return atype::FLOAT;
       }
-      if (t2 == atype::DOUBLE) {
+      if (t2 == atype::DOUBLE && !isBitwiseOp(op)) {
         return atype::DOUBLE;
       }
       if (isIntType(t2)) {
@@ -380,7 +379,7 @@ Operations createOperations(Filter const& expression)
       }
     }
     if (t1 == atype::FLOAT) {
-      if (isIntType(t2)) {
+      if (isIntType(t2) && !isBitwiseOp(op)) {
         return atype::FLOAT;
       }
       if (t2 == atype::DOUBLE) {
@@ -390,11 +389,19 @@ Operations createOperations(Filter const& expression)
     if (t1 == atype::DOUBLE) {
       return atype::DOUBLE;
     }
+
+    if (isIntType(t1) && isBitwiseOp(op)) {
+      return t1;
+    }
+    if (isIntType(t2) && isBitwiseOp(op)) {
+      return t2;
+    }
+
     throw runtime_error_f("Invalid combination of argument types %s and %s", stringType(t1), stringType(t2));
   };
 
   for (auto it = OperationSpecs.rbegin(); it != OperationSpecs.rend(); ++it) {
-    auto type = inferResultType(it->left, it->right);
+    auto type = inferResultType(it->op, it->left, it->right);
     if (it->type == atype::NA) {
       it->type = type;
     }
@@ -609,30 +616,34 @@ gandiva::NodePtr createExpressionTree(Operations const& opSpecs,
     throw runtime_error("Malformed DatumSpec");
   };
 
+  auto insertUpcastNode = [](gandiva::NodePtr node, atype::type t0, atype::type t) {
+    if (t != t0) {
+      auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(t0), {node}, concreteArrowType(t0));
+      node = upcast;
+    }
+    return node;
+  };
+
+  auto insertEqualizeUpcastNode = [](gandiva::NodePtr& node1, gandiva::NodePtr& node2, atype::type t1, atype::type t2) {
+    if (t2 > t1) {
+      auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(t2), {node1}, concreteArrowType(t2));
+      node1 = upcast;
+    } else if (t1 > t2) {
+      auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(t1), {node2}, concreteArrowType(t1));
+      node2 = upcast;
+    }
+  };
+
+  auto isBitwiseOp = [](auto o) {
+    return ((o == BasicOp::BitwiseAnd) || (o == BasicOp::BitwiseNot) || (o == BasicOp::BitwiseOr) || (o == BasicOp::BitwiseXor));
+  };
+
   gandiva::NodePtr tree = nullptr;
   for (auto it = opSpecs.rbegin(); it != opSpecs.rend(); ++it) {
     auto leftNode = datumNode(it->left);
     auto rightNode = datumNode(it->right);
     auto condNode = datumNode(it->condition);
 
-    auto insertUpcastNode = [](gandiva::NodePtr node, atype::type t0, atype::type t) {
-      if (t != t0) {
-        auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(t0), {node}, concreteArrowType(t0));
-        node = upcast;
-      }
-      return node;
-    };
-
-    auto insertEqualizeUpcastNode = [](gandiva::NodePtr& node1, gandiva::NodePtr& node2, atype::type t1, atype::type t2) {
-      if (t2 > t1) {
-        auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(t2), {node1}, concreteArrowType(t2));
-        node1 = upcast;
-      } else if (t1 > t2) {
-        auto upcast = gandiva::TreeExprBuilder::MakeFunction(upcastTo(t1), {node2}, concreteArrowType(t1));
-        node2 = upcast;
-      }
-    };
-
     gandiva::NodePtr temp_node;
 
     switch (it->op) {
@@ -647,7 +658,7 @@ gandiva::NodePtr createExpressionTree(Operations const& opSpecs,
         break;
       default:
         if (it->op < BasicOp::Sqrt) {
-          if (it->type != atype::BOOL) {
+          if (it->type != atype::BOOL && !isBitwiseOp(it->op)) {
             leftNode = insertUpcastNode(leftNode, it->type, it->left.type);
             rightNode = insertUpcastNode(rightNode, it->type, it->right.type);
           } else if (it->op == BasicOp::Equal || it->op == BasicOp::NotEqual) {
@@ -655,7 +666,9 @@ gandiva::NodePtr createExpressionTree(Operations const& opSpecs,
           }
           temp_node = gandiva::TreeExprBuilder::MakeFunction(basicOperationsMap[it->op], {leftNode, rightNode}, concreteArrowType(it->type));
         } else {
-          leftNode = insertUpcastNode(leftNode, it->type, it->left.type);
+          if (!isBitwiseOp(it->op)) {
+            leftNode = insertUpcastNode(leftNode, it->type, it->left.type);
+          }
           temp_node = gandiva::TreeExprBuilder::MakeFunction(basicOperationsMap[it->op], {leftNode}, concreteArrowType(it->type));
         }
         break;
@@ -722,4 +735,464 @@ void updateFilterInfo(ExpressionInfo& info, std::shared_ptr<arrow::Table>& table
   }
 }
 
+/// String parsing
+Tokenizer::Tokenizer(std::string const& input)
+  : source{input},
+    IdentifierStr{""},
+    StrValue{""},
+    IntegerValue{0},
+    FloatValue{0.f}
+{
+  LastChar = ' ';
+  if (!source.empty()) {
+    source.erase(std::remove_if(source.begin(), source.end(), ::isspace), source.end());
+  }
+  current = source.begin();
+}
+
+void Tokenizer::reset(std::string const& input)
+{
+  LastChar = ' ';
+  IdentifierStr = "";
+  StrValue = "";
+  IntegerValue = 0;
+  FloatValue = 0.f;
+  source = input;
+  if (!source.empty()) {
+    source.erase(std::remove_if(source.begin(), source.end(), ::isspace), source.end());
+  }
+  current = source.begin();
+  currentToken = Token::Unexpected;
+}
+
+int Tokenizer::nextToken()
+{
+  // skip initial space
+  if (isspace(LastChar)) {
+    pop();
+  }
+  // logical or bitwise OR
+  if (LastChar == '|') {
+    BinaryOpStr = LastChar;
+    if (peek() == '|') {
+      pop();
+      BinaryOpStr += LastChar;
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    } else {
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    }
+  }
+  // logical or bitwise AND
+  if (LastChar == '&') {
+    BinaryOpStr = LastChar;
+    if (peek() == '&') {
+      pop();
+      BinaryOpStr += LastChar;
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    } else {
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    }
+  }
+  // less than or less or equal than
+  if (LastChar == '<') {
+    BinaryOpStr = LastChar;
+    if (peek() == '=') {
+      pop();
+      BinaryOpStr += LastChar;
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    } else {
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    }
+  }
+  // greater than or greater or equal than
+  if (LastChar == '>') {
+    BinaryOpStr = LastChar;
+    if (peek() == '=') {
+      pop();
+      BinaryOpStr += LastChar;
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    } else {
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    }
+  }
+  // equal or error
+  if (LastChar == '=') {
+    BinaryOpStr = LastChar;
+    if (peek() == '=') {
+      pop();
+      BinaryOpStr += LastChar;
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    } else {
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::Unexpected;
+      return currentToken;
+    }
+  }
+  // not equal or error
+  if (LastChar == '!') {
+    BinaryOpStr = LastChar;
+    if (peek() == '=') {
+      pop();
+      BinaryOpStr += LastChar;
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    } else {
+      pop();
+      TokenStr = BinaryOpStr;
+      currentToken = Token::BinaryOp;
+      return currentToken;
+    }
+  }
+  // unambiguous single-character binary operations: addition, multiplication, subtraction, division, bitwise XOR
+  if (LastChar == '+' || LastChar == '*' || (LastChar == '-' && (currentToken != Token::BinaryOp && currentToken != '(' && currentToken != Token::Unexpected)) || LastChar == '/' || LastChar == '^') {
+    BinaryOpStr = LastChar;
+    pop();
+    TokenStr = BinaryOpStr;
+    currentToken = Token::BinaryOp;
+    return currentToken;
+  }
+  // identifier: column, function, constant
+  if (isalpha(LastChar)) {
+    // identifier
+    IdentifierStr = LastChar;
+    pop();
+    while (isalnum(LastChar) || (LastChar == '_') || (LastChar == ':')) {
+      IdentifierStr += LastChar;
+      pop();
+    }
+    TokenStr = IdentifierStr;
+    currentToken = Token::Identifier;
+    return currentToken;
+  }
+  // number: integer, unsigned integer or float
+  if (isdigit(LastChar) || LastChar == '.' || (LastChar == '-' && isdigit(peek()))) {
+    // number
+    StrValue = "";
+    bool isFloat = false;
+    bool isUnsigned = false;
+    do {
+      StrValue += LastChar;
+      pop();
+    } while (isdigit(LastChar) || LastChar == '.');
+    if (LastChar == 'f') {
+      isFloat = true;
+      pop();
+    }
+    if (LastChar == 'u') {
+      isUnsigned = true;
+      pop();
+    }
+    if (std::find(StrValue.begin(), StrValue.end(), '.') == StrValue.end() && !isFloat) {
+      if (!isUnsigned) {
+        IntegerValue = atoi(StrValue.c_str());
+      } else {
+        IntegerValue = static_cast<unsigned int>(atoi(StrValue.c_str()));
+      }
+      TokenStr = StrValue;
+      currentToken = Token::IntegerNumber;
+      return currentToken;
+    }
+    if (isFloat) {
+      FloatValue = strtof(StrValue.c_str(), nullptr);
+    } else {
+      FloatValue = strtod(StrValue.c_str(), nullptr);
+    }
+    TokenStr = StrValue;
+    currentToken = Token::FloatNumber;
+    return currentToken;
+  }
+  // end-of-line
+  if (LastChar == '\0') {
+    TokenStr = LastChar;
+    currentToken = Token::EoL;
+    return currentToken;
+  }
+  // generic character
+  currentToken = LastChar;
+  TokenStr = LastChar;
+  pop();
+  return currentToken;
+}
+
+void Tokenizer::pop()
+{
+  if (current != source.end()) {
+    LastChar = *current;
+    ++current;
+  } else {
+    LastChar = '\0';
+  }
+}
+
+char Tokenizer::peek()
+{
+  if (current != source.end()) {
+    return *current;
+  } else {
+    return '\0';
+  }
+}
+
+Node Parser::parse(std::string const& input)
+{
+  auto tk = Tokenizer(input);
+  tk.nextToken();
+  auto node = parsePrimary(tk);
+  if (tk.currentToken != Token::EoL) {
+    throw runtime_error_f("Unexpected token after expression: %s", tk.TokenStr.c_str());
+  }
+  return *node.get();
+}
+
+std::unique_ptr<Node> Parser::parsePrimary(Tokenizer& tk)
+{
+  auto root = parseTier1(tk);
+  while (tk.TokenStr == "||") {
+    auto opnode = std::make_unique<Node>(OpNode{BasicOp::LogicalOr}, std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseTier1(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseTier1(Tokenizer& tk)
+{
+  auto root = parseTier2(tk);
+  while (tk.TokenStr == "&&") {
+    auto opnode = std::make_unique<Node>(OpNode{BasicOp::LogicalAnd}, std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseTier2(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseTier2(Tokenizer& tk)
+{
+  auto root = parseTier3(tk);
+  while (tk.TokenStr == "|") {
+    auto opnode = std::make_unique<Node>(OpNode{BasicOp::BitwiseOr}, std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseTier3(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseTier3(Tokenizer& tk)
+{
+  auto root = parseTier4(tk);
+  while (tk.TokenStr == "^") {
+    auto opnode = std::make_unique<Node>(OpNode{BasicOp::BitwiseXor}, std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseTier4(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseTier4(Tokenizer& tk)
+{
+  auto root = parseTier5(tk);
+  while (tk.TokenStr == "&") {
+    auto opnode = std::make_unique<Node>(OpNode{BasicOp::BitwiseAnd}, std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseTier5(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseTier5(Tokenizer& tk)
+{
+  auto root = parseTier6(tk);
+  while (tk.TokenStr == "==" || tk.TokenStr == "!=") {
+    auto opnode = std::make_unique<Node>(opFromToken(tk.TokenStr), std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseTier6(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseTier6(Tokenizer& tk)
+{
+  auto root = parseTier7(tk);
+  while (tk.TokenStr == "<" || tk.TokenStr == "<=" || tk.TokenStr == "=>" || tk.TokenStr == ">") {
+    auto opnode = std::make_unique<Node>(opFromToken(tk.TokenStr), std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseTier7(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseTier7(Tokenizer& tk)
+{
+  auto root = parseTier8(tk);
+  while (tk.TokenStr == "+" || tk.TokenStr == "-") {
+    auto opnode = std::make_unique<Node>(opFromToken(tk.TokenStr), std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseTier8(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseTier8(Tokenizer& tk)
+{
+  auto root = parseBase(tk);
+  while (tk.TokenStr == "*" || tk.TokenStr == "/") {
+    auto opnode = std::make_unique<Node>(opFromToken(tk.TokenStr), std::move(root), LiteralNode{-1});
+    root.swap(opnode);
+    tk.nextToken();
+    root->right = parseBase(tk);
+  }
+  return root;
+}
+
+std::unique_ptr<Node> Parser::parseBase(Tokenizer& tk)
+{
+  // parentheses
+  if (tk.currentToken == '(') {
+    tk.nextToken();
+    auto node = parsePrimary(tk);
+    if (tk.currentToken != ')') {
+      throw runtime_error_f("Expected \")\" got %s", tk.TokenStr.c_str());
+    }
+    tk.nextToken();
+    return node;
+  }
+
+  // identifier or function call
+  if (tk.currentToken == Token::Identifier) {
+    std::string id = tk.IdentifierStr;
+    tk.nextToken();
+    if (tk.currentToken != '(') { // binding node or a constant
+      std::string binding = id;
+      auto posc = std::find(mathConstants.begin(), mathConstants.end(), id);
+      if (posc != mathConstants.end()) { // constant
+        return std::make_unique<Node>(LiteralNode{mathConstantsValues[std::distance(mathConstants.begin(), posc)]});
+      }
+      // binding node
+      auto pos = binding.rfind(':');
+      binding.erase(0, pos + 1);
+      binding[0] = std::toupper(binding[0]);
+      binding.insert(binding.begin(), 'f');
+      return std::make_unique<Node>(BindingNode{runtime_hash(id.c_str()), atype::FLOAT}, binding);
+    }
+
+    // function call
+    if (id == "ifnode") { // conditional, 3 args
+      auto node = std::make_unique<Node>(ConditionalNode{}, LiteralNode{-1}, LiteralNode{-1}, LiteralNode{-1});
+      int args = 0;
+      while (tk.currentToken != ')') {
+        do {
+          tk.nextToken();
+          if (args == 0) {
+            node->condition = parsePrimary(tk);
+          } else if (args == 1) {
+            node->left = parsePrimary(tk);
+          } else if (args == 2) {
+            node->right = parsePrimary(tk);
+          } else {
+            throw runtime_error_f("Extra argument in a conditional: %s", tk.TokenStr.c_str());
+          }
+          ++args;
+        } while (tk.currentToken == ',');
+      }
+      tk.nextToken();
+      return node;
+    } else { // normal function
+      auto node = std::make_unique<Node>(opFromToken(id), LiteralNode{-1}, LiteralNode{-1});
+      int args = 0;
+      while (tk.currentToken != ')') {
+        do {
+          tk.nextToken();
+          if (args == 0) {
+            node->left = parsePrimary(tk);
+          } else if (args == 1) {
+            node->right = parsePrimary(tk);
+          } else {
+            throw runtime_error_f("Extra argument in a function call: %s", tk.TokenStr.c_str());
+          }
+          ++args;
+        } while (tk.currentToken == ',');
+      }
+      if (args == 1) {
+        node->right = nullptr;
+      }
+      tk.nextToken();
+      return node;
+    }
+  }
+
+  // number
+  if (tk.currentToken == Token::FloatNumber) {
+    tk.nextToken();
+    switch (tk.FloatValue.index()) {
+      case 0:
+        return std::make_unique<Node>(LiteralNode{get<0>(tk.FloatValue)});
+      case 1:
+        return std::make_unique<Node>(LiteralNode{get<1>(tk.FloatValue)});
+    }
+  }
+  if (tk.currentToken == Token::IntegerNumber) {
+    tk.nextToken();
+    switch (tk.IntegerValue.index()) {
+      case 0:
+        return std::make_unique<Node>(LiteralNode{get<0>(tk.IntegerValue)});
+      case 1:
+        return std::make_unique<Node>(LiteralNode{get<1>(tk.IntegerValue)});
+      case 2:
+        return std::make_unique<Node>(LiteralNode{get<2>(tk.IntegerValue)});
+      case 3:
+        return std::make_unique<Node>(LiteralNode{get<3>(tk.IntegerValue)});
+    }
+  }
+
+  // error
+  throw runtime_error_f("Unexpected token %s in operand", tk.TokenStr.c_str());
+}
+
+OpNode Parser::opFromToken(std::string const& token)
+{
+  auto locate = std::find(mapping.begin(), mapping.end(), token);
+  if (locate == mapping.end()) {
+    throw runtime_error_f("No operation \"%s\" defined", token.c_str());
+  }
+  return OpNode{static_cast<BasicOp>(std::distance(mapping.begin(), locate))};
+}
+
 } // namespace o2::framework::expressions
diff --git a/Framework/Core/test/test_Expressions.cxx b/Framework/Core/test/test_Expressions.cxx
index e8cf43e03e11d..eef0375f46086 100644
--- a/Framework/Core/test/test_Expressions.cxx
+++ b/Framework/Core/test/test_Expressions.cxx
@@ -14,6 +14,7 @@
 #include "Framework/AnalysisDataModel.h"
 #include <catch_amalgamated.hpp>
 #include <arrow/util/config.h>
+#include <iostream>
 
 using namespace o2::framework;
 using namespace o2::framework::expressions;
@@ -127,7 +128,7 @@ TEST_CASE("TestTreeParsing")
   REQUIRE(ptfilter.node->left->self.index() == 1);
   REQUIRE(ptfilter.node->right->self.index() == 3);
   auto ptfilterspecs = createOperations(ptfilter);
-  REQUIRE(ptfilterspecs[0].left == (DatumSpec{std::string{"fPt"}, typeid(o2::aod::track::Pt).hash_code(), atype::FLOAT}));
+  REQUIRE(ptfilterspecs[0].left == (DatumSpec{std::string{"fPt"}, "o2::aod::track::pt"_h, atype::FLOAT}));
   REQUIRE(ptfilterspecs[0].right == (DatumSpec{LiteralNode::var_t{0.5f}, atype::FLOAT}));
   REQUIRE(ptfilterspecs[0].result == (DatumSpec{0u, atype::BOOL}));
 
@@ -143,7 +144,7 @@ TEST_CASE("TestTreeParsing")
   REQUIRE(ptfilter2.node->right->self.index() == 3);
   REQUIRE(std::get<PlaceholderNode>(ptfilter2.node->right->self).name == "prefix.pTCut");
   auto ptfilterspecs2 = createOperations(ptfilter2);
-  REQUIRE(ptfilterspecs2[0].left == (DatumSpec{std::string{"fPt"}, typeid(o2::aod::track::Pt).hash_code(), atype::FLOAT}));
+  REQUIRE(ptfilterspecs2[0].left == (DatumSpec{std::string{"fPt"}, "o2::aod::track::pt"_h, atype::FLOAT}));
   REQUIRE(ptfilterspecs2[0].right == (DatumSpec{LiteralNode::var_t{1.0f}, atype::FLOAT}));
   REQUIRE(ptfilterspecs2[0].result == (DatumSpec{0u, atype::BOOL}));
 
@@ -161,12 +162,12 @@ TEST_CASE("TestGandivaTreeCreation")
 {
   Projector pze = o2::aod::track::Pze::Projector();
   auto pzspecs = createOperations(pze);
-  REQUIRE(pzspecs[0].left == (DatumSpec{std::string{"fTgl"}, typeid(o2::aod::track::Tgl).hash_code(), atype::FLOAT}));
+  REQUIRE(pzspecs[0].left == (DatumSpec{std::string{"fTgl"}, "o2::aod::track::tgl"_h, atype::FLOAT}));
   REQUIRE(pzspecs[0].right == (DatumSpec{1u, atype::FLOAT}));
   REQUIRE(pzspecs[0].result == (DatumSpec{0u, atype::FLOAT}));
 
   REQUIRE(pzspecs[1].left == (DatumSpec{LiteralNode::var_t{1.f}, atype::FLOAT}));
-  REQUIRE(pzspecs[1].right == (DatumSpec{std::string{"fSigned1Pt"}, typeid(o2::aod::track::Signed1Pt).hash_code(), atype::FLOAT}));
+  REQUIRE(pzspecs[1].right == (DatumSpec{std::string{"fSigned1Pt"}, "o2::aod::track::signed1Pt"_h, atype::FLOAT}));
   REQUIRE(pzspecs[1].result == (DatumSpec{1u, atype::FLOAT}));
   auto infield1 = o2::aod::track::Signed1Pt::asArrowField();
   auto infield2 = o2::aod::track::Tgl::asArrowField();
@@ -200,7 +201,7 @@ TEST_CASE("TestGandivaTreeCreation")
   REQUIRE(bwf[0].right == (DatumSpec{LiteralNode::var_t{0u}, atype::UINT32}));
   REQUIRE(bwf[0].result == (DatumSpec{0u, atype::BOOL}));
 
-  REQUIRE(bwf[1].left == (DatumSpec{std::string{"fFlags"}, typeid(o2::aod::track::Flags).hash_code(), atype::UINT32}));
+  REQUIRE(bwf[1].left == (DatumSpec{std::string{"fFlags"}, "o2::aod::track::flags"_h, atype::UINT32}));
   REQUIRE(bwf[1].right == (DatumSpec{LiteralNode::var_t{static_cast<uint32_t>(o2::aod::track::TPCrefit)}, atype::UINT32}));
   REQUIRE(bwf[1].result == (DatumSpec{1u, atype::UINT32}));
 
@@ -220,7 +221,7 @@ TEST_CASE("TestGandivaTreeCreation")
   REQUIRE(rf[0].right == (DatumSpec{LiteralNode::var_t{0.1f}, atype::FLOAT}));
   REQUIRE(rf[0].result == (DatumSpec{0u, atype::BOOL}));
 
-  REQUIRE(rf[1].left == (DatumSpec{std::string{"fPt"}, typeid(o2::aod::track::Pt).hash_code(), atype::FLOAT}));
+  REQUIRE(rf[1].left == (DatumSpec{std::string{"fPt"}, "o2::aod::track::pt"_h, atype::FLOAT}));
   REQUIRE(rf[1].right == (DatumSpec{}));
   REQUIRE(rf[1].result == (DatumSpec{1u, atype::FLOAT}));
 
@@ -249,15 +250,15 @@ TEST_CASE("TestConditionalExpressions")
   REQUIRE(cfspecs[1].condition == (DatumSpec{5u, atype::BOOL}));
   REQUIRE(cfspecs[1].result == (DatumSpec{2u, atype::BOOL}));
 
-  REQUIRE(cfspecs[2].left == (DatumSpec{std::string{"fPt"}, typeid(o2::aod::track::Pt).hash_code(), atype::FLOAT}));
+  REQUIRE(cfspecs[2].left == (DatumSpec{std::string{"fPt"}, "o2::aod::track::pt"_h, atype::FLOAT}));
   REQUIRE(cfspecs[2].right == (DatumSpec{LiteralNode::var_t{1.0f}, atype::FLOAT}));
   REQUIRE(cfspecs[2].result == (DatumSpec{5u, atype::BOOL}));
 
-  REQUIRE(cfspecs[3].left == (DatumSpec{std::string{"fPhi"}, typeid(o2::aod::track::Phi).hash_code(), atype::FLOAT}));
+  REQUIRE(cfspecs[3].left == (DatumSpec{std::string{"fPhi"}, "o2::aod::track::phi"_h, atype::FLOAT}));
   REQUIRE(cfspecs[3].right == (DatumSpec{LiteralNode::var_t{(float)(M_PI / 2.)}, atype::FLOAT}));
   REQUIRE(cfspecs[3].result == (DatumSpec{4u, atype::BOOL}));
 
-  REQUIRE(cfspecs[4].left == (DatumSpec{std::string{"fPhi"}, typeid(o2::aod::track::Phi).hash_code(), atype::FLOAT}));
+  REQUIRE(cfspecs[4].left == (DatumSpec{std::string{"fPhi"}, "o2::aod::track::phi"_h, atype::FLOAT}));
   REQUIRE(cfspecs[4].right == (DatumSpec{LiteralNode::var_t{(float)(M_PI / 2.)}, atype::FLOAT}));
   REQUIRE(cfspecs[4].result == (DatumSpec{3u, atype::BOOL}));
 
@@ -265,7 +266,7 @@ TEST_CASE("TestConditionalExpressions")
   REQUIRE(cfspecs[5].right == (DatumSpec{LiteralNode::var_t{1.0f}, atype::FLOAT}));
   REQUIRE(cfspecs[5].result == (DatumSpec{1u, atype::BOOL}));
 
-  REQUIRE(cfspecs[6].left == (DatumSpec{std::string{"fEta"}, typeid(o2::aod::track::Eta).hash_code(), atype::FLOAT}));
+  REQUIRE(cfspecs[6].left == (DatumSpec{std::string{"fEta"}, "o2::aod::track::eta"_h, atype::FLOAT}));
   REQUIRE(cfspecs[6].right == (DatumSpec{}));
   REQUIRE(cfspecs[6].result == (DatumSpec{6u, atype::FLOAT}));
 
@@ -324,3 +325,54 @@ TEST_CASE("TestBinnedExpressions")
   auto tree2 = createExpressionTree(p2specs, schema2);
   REQUIRE(tree2->ToString() == "if (bool less_than((float) fPhi, (const float) 0 raw(0))) { (const float) -1 raw(bf800000) } else { if (bool less_than((float) fPhi, (const float) 1.5708 raw(3fc90fdb))) { float add(float add(float multiply(float multiply((const float) 1 raw(3f800000), (float) fX), (float) fX), float multiply(float multiply((const float) 2 raw(40000000), (float) fY), (float) fY)), float multiply(float multiply((const float) 3 raw(40400000), (float) fZ), (float) fZ)) } else { if (bool less_than((float) fPhi, (const float) 3.14159 raw(40490fdb))) { float add(float add(float multiply(float multiply((const float) 1.1 raw(3f8ccccd), (float) fX), (float) fX), float multiply(float multiply((const float) 2.1 raw(40066666), (float) fY), (float) fY)), float multiply(float multiply((const float) 3.1 raw(40466666), (float) fZ), (float) fZ)) } else { if (bool less_than((float) fPhi, (const float) 4.71239 raw(4096cbe4))) { float add(float add(float multiply(float multiply((const float) 1.2 raw(3f99999a), (float) fX), (float) fX), float multiply(float multiply((const float) 2.2 raw(400ccccd), (float) fY), (float) fY)), float multiply(float multiply((const float) 3.2 raw(404ccccd), (float) fZ), (float) fZ)) } else { if (bool less_than((float) fPhi, (const float) 6.28319 raw(40c90fdb))) { float add(float add(float multiply(float multiply((const float) 1.3 raw(3fa66666), (float) fX), (float) fX), float multiply(float multiply((const float) 2.3 raw(40133333), (float) fY), (float) fY)), float multiply(float multiply((const float) 3.3 raw(40533333), (float) fZ), (float) fZ)) } else { (const float) -1 raw(bf800000) } } } } }");
 }
+
+void printTokens(Tokenizer& t)
+{
+  int token;
+  while ((token = t.nextToken()) && (token != Token::EoL)) {
+    std::cout << t.TokenStr << " ";
+  };
+  std::cout << std::endl;
+}
+
+TEST_CASE("TestStringExpressionsParsing")
+{
+  Filter f = (o2::aod::track::flags & 1u) != 0u && (o2::aod::track::pt <= 10.f);
+  std::string input = "(o2::aod::track::flags & 1u) != 0u && (o2::aod::track::pt <= 10.f)";
+
+  auto t1 = createOperations(f);
+  Filter ff = Parser::parse(input);
+  auto t2 = createOperations(ff);
+
+  auto schema = std::make_shared<arrow::Schema>(std::vector{o2::aod::track::Flags::asArrowField(), o2::aod::track::Pt::asArrowField()});
+  auto tree1 = createExpressionTree(t1, schema);
+  auto tree2 = createExpressionTree(t2, schema);
+
+  REQUIRE(tree1->ToString() == tree2->ToString());
+
+  Projector p = -1.f * nlog(ntan(o2::constants::math::PIQuarter - 0.5f * natan(o2::aod::fwdtrack::tgl)));
+  input = "-1.f * nlog(ntan(PIQuarter - 0.5f * natan(o2::aod::fwdtrack::tgl)))";
+
+  auto tp1 = createOperations(p);
+  Projector pp = Parser::parse(input);
+  auto tp2 = createOperations(pp);
+
+  schema = std::make_shared<arrow::Schema>(std::vector{o2::aod::fwdtrack::Tgl::asArrowField()});
+  auto treep1 = createExpressionTree(tp1, schema);
+  auto treep2 = createExpressionTree(tp2, schema);
+
+  REQUIRE(treep1->ToString() == treep2->ToString());
+
+  Filter f2 = o2::aod::track::signed1Pt > 0.f && ifnode(nabs(o2::aod::track::eta) < 1.0f, nabs(o2::aod::track::x) > 2.0f, nabs(o2::aod::track::y) > 3.0f);
+  input = "o2::aod::track::signed1Pt > 0.f && ifnode(nabs(o2::aod::track::eta) < 1.0f, nabs(o2::aod::track::x) > 2.0f, nabs(o2::aod::track::y) > 3.0f)";
+
+  auto tf1 = createOperations(f2);
+  Filter ff2 = Parser::parse(input);
+  auto tf2 = createOperations(ff2);
+
+  schema = std::make_shared<arrow::Schema>(std::vector{o2::aod::track::Eta::asArrowField(), o2::aod::track::Signed1Pt::asArrowField(), o2::aod::track::X::asArrowField(), o2::aod::track::Y::asArrowField()});
+  auto treef1 = createExpressionTree(tf1, schema);
+  auto treef2 = createExpressionTree(tf2, schema);
+
+  REQUIRE(treef1->ToString() == treef2->ToString());
+}

From 81851e7f759202cb3f4d585b1b8e81d2d4c5ea86 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 30 Jun 2025 10:21:14 +0200
Subject: [PATCH 0677/1764] move unnecessary statics to .cxx

---
 Framework/Core/include/Framework/BasicOps.h | 58 --------------------
 Framework/Core/src/Expressions.cxx          | 61 ++++++++++++++++++++-
 2 files changed, 60 insertions(+), 59 deletions(-)

diff --git a/Framework/Core/include/Framework/BasicOps.h b/Framework/Core/include/Framework/BasicOps.h
index 06880de275b9e..0927b557c86bc 100644
--- a/Framework/Core/include/Framework/BasicOps.h
+++ b/Framework/Core/include/Framework/BasicOps.h
@@ -10,9 +10,6 @@
 // or submit itself to any jurisdiction.
 #ifndef O2_FRAMEWORK_BASICOPS_H_
 #define O2_FRAMEWORK_BASICOPS_H_
-#include <array>
-#include <string_view>
-#include "CommonConstants/MathConstants.h"
 
 namespace o2::framework
 {
@@ -49,61 +46,6 @@ enum BasicOp : unsigned int {
   BitwiseNot,
   Conditional // 3-ar functions
 };
-
-static constexpr std::array<std::string_view, BasicOp::Conditional + 1> mapping{
-  "&&",
-  "||",
-  "+",
-  "-",
-  "/",
-  "*",
-  "&",
-  "|",
-  "^",
-  "<",
-  "<=",
-  ">",
-  ">=",
-  "==",
-  "!=",
-  "natan2",
-  "npow",
-  "nsqrt",
-  "nexp",
-  "nlog",
-  "nlog10",
-  "nsin",
-  "ncos",
-  "ntan",
-  "nasin",
-  "nacos",
-  "natan",
-  "nabs",
-  "nround",
-  "nbitwise_not",
-  "ifnode"};
-
-static constexpr std::array<std::string_view, 9> mathConstants{
-  "Almost0",
-  "Epsilon",
-  "Almost1",
-  "VeryBig",
-  "PI",
-  "TwoPI",
-  "PIHalf",
-  "PIThird",
-  "PIQuarter"};
-
-static constexpr std::array<float, 9> mathConstantsValues{
-  o2::constants::math::Almost0,
-  o2::constants::math::Epsilon,
-  o2::constants::math::Almost1,
-  o2::constants::math::VeryBig,
-  o2::constants::math::PI,
-  o2::constants::math::TwoPI,
-  o2::constants::math::PIHalf,
-  o2::constants::math::PIThird,
-  o2::constants::math::PIQuarter};
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_BASICOPS_H_
diff --git a/Framework/Core/src/Expressions.cxx b/Framework/Core/src/Expressions.cxx
index 3e52d49dfa4bb..cc6d9f99fb25d 100644
--- a/Framework/Core/src/Expressions.cxx
+++ b/Framework/Core/src/Expressions.cxx
@@ -19,6 +19,7 @@
 #include <set>
 #include <stack>
 #include <unordered_map>
+#include "CommonConstants/MathConstants.h"
 
 using namespace o2::framework;
 
@@ -29,9 +30,67 @@ void unknownParameterUsed(const char* name)
   runtime_error_f("Unknown parameter used in expression: %s", name);
 }
 
+/// a map between BasicOp and tokens in string expressions
+constexpr std::array<std::string_view, BasicOp::Conditional + 1> mapping{
+  "&&",
+  "||",
+  "+",
+  "-",
+  "/",
+  "*",
+  "&",
+  "|",
+  "^",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "==",
+  "!=",
+  "natan2",
+  "npow",
+  "nsqrt",
+  "nexp",
+  "nlog",
+  "nlog10",
+  "nsin",
+  "ncos",
+  "ntan",
+  "nasin",
+  "nacos",
+  "natan",
+  "nabs",
+  "nround",
+  "nbitwise_not",
+  "ifnode"};
+
+/// math constants to recognize in string expressions
+constexpr std::array<std::string_view, 9> mathConstants{
+  "Almost0",
+  "Epsilon",
+  "Almost1",
+  "VeryBig",
+  "PI",
+  "TwoPI",
+  "PIHalf",
+  "PIThird",
+  "PIQuarter"};
+
+/// values of math constants to substiture
+constexpr std::array<float, 9> mathConstantsValues{
+  o2::constants::math::Almost0,
+  o2::constants::math::Epsilon,
+  o2::constants::math::Almost1,
+  o2::constants::math::VeryBig,
+  o2::constants::math::PI,
+  o2::constants::math::TwoPI,
+  o2::constants::math::PIHalf,
+  o2::constants::math::PIThird,
+  o2::constants::math::PIQuarter};
+
 /// a map between BasicOp and gandiva node definitions
 /// note that logical 'and' and 'or' are created separately
-static constexpr std::array<const char*, BasicOp::Conditional + 1> basicOperationsMap = {
+constexpr std::array<const char*, BasicOp::Conditional + 1> basicOperationsMap = {
   "and",
   "or",
   "add",

From 59033a58b4b6fb06ae2f018fa179e55aca654152 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 30 Jun 2025 13:25:01 +0200
Subject: [PATCH 0678/1764] Allow filters to be set in init(); Add ability to
 set a filter from string directly

---
 Framework/Core/include/Framework/AnalysisTask.h |  9 +++++----
 Framework/Core/include/Framework/Expressions.h  | 14 ++++++++++++++
 Framework/Core/src/Expressions.cxx              |  9 +++++++++
 3 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 892948582b3cc..b3378543e6ebb 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -574,6 +574,11 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
 
     callbacks.set<CallbackService::Id::EndOfStream>(eoscb);
 
+    /// call the task's init() function first as it may manipulate the task's elements
+    if constexpr (requires { task->init(ic); }) {
+      task->init(ic);
+    }
+
     /// update configurables in filters and partitions
     homogeneous_apply_refs(
       [&ic](auto& element) -> bool { return analysis_task_parsers::updatePlaceholders(ic, element); },
@@ -584,10 +589,6 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
     },
                            *task.get());
 
-    if constexpr (requires { task->init(ic); }) {
-      task->init(ic);
-    }
-
     /// parse process functions to enable requested grouping caches - note that at this state process configurables have their final values
     if constexpr (requires { &T::process; }) {
       AnalysisDataProcessorBuilder::cacheFromArgs(&T::process, true, bindingsKeys, bindingsKeysUnsorted);
diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 6568f5d58c421..ed8d4ef24f402 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -610,15 +610,29 @@ struct Filter {
     (void)designateSubtrees(node.get());
   }
 
+  Filter(std::string const& input_) : input{input_} {}
+
   Filter& operator=(Filter&& other) noexcept
   {
     node = std::move(other.node);
+    input = std::move(other.input);
+    return *this;
+  }
+
+  Filter& operator=(std::string const& input_)
+  {
+    input = input_;
+    if (node != nullptr) {
+      node = nullptr;
+    }
     return *this;
   }
 
   std::unique_ptr<Node> node = nullptr;
+  std::string input;
 
   size_t designateSubtrees(Node* node, size_t index = 0);
+  void parse();
 };
 
 template <typename T>
diff --git a/Framework/Core/src/Expressions.cxx b/Framework/Core/src/Expressions.cxx
index cc6d9f99fb25d..1d4dec734ff21 100644
--- a/Framework/Core/src/Expressions.cxx
+++ b/Framework/Core/src/Expressions.cxx
@@ -152,6 +152,12 @@ size_t Filter::designateSubtrees(Node* node, size_t index)
   return index;
 }
 
+void Filter::parse()
+{
+  node = std::make_unique<Node>(Parser::parse(input));
+  (void)designateSubtrees(node.get());
+}
+
 template <typename T>
 constexpr inline auto makeDatum(T const&)
 {
@@ -252,6 +258,9 @@ std::ostream& operator<<(std::ostream& os, DatumSpec const& spec)
 
 void updatePlaceholders(Filter& filter, InitContext& context)
 {
+  if (filter.node == nullptr && !filter.input.empty()) {
+    filter.parse();
+  }
   expressions::walk(filter.node.get(), [&](Node* node) {
     if (node->self.index() == 3) {
       std::get_if<3>(&node->self)->reset(context);

From db916c26a15ef5b604c3d69423d32f124806dcf1 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 8 Aug 2025 11:38:49 +0200
Subject: [PATCH 0679/1764] DPL Analysis: add support for BinaryView columns

The idea is to be able to have BinaryViews on top of the CCDB object
blobs which are already cached in shared memory, so that we can have
a table with rows of the kind:

(timestamp, blob-requested-ccdb-object-2, blob-requested-ccdb-object-2)

which then can be joined to the timestamps to provide access to the associated CCDB
Object.
---
 Framework/Core/include/Framework/ASoA.h       | 21 +++++++----
 Framework/Core/include/Framework/ArrowTypes.h |  5 +++
 .../Core/include/Framework/TableBuilder.h     | 33 ++++++++++++++++-
 Framework/Core/test/test_TableBuilder.cxx     | 35 ++++++++++++++++++-
 4 files changed, 86 insertions(+), 8 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 9703f8eb26b9d..8af9878703d18 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -23,11 +23,12 @@
 #include "Framework/ArrowTableSlicingCache.h" // IWYU pragma: export
 #include "Framework/SliceCache.h"             // IWYU pragma: export
 #include "Framework/VariantHelpers.h"         // IWYU pragma: export
-#include <arrow/table.h>                      // IWYU pragma: export
-#include <arrow/array.h>                      // IWYU pragma: export
-#include <arrow/util/config.h>                // IWYU pragma: export
-#include <gandiva/selection_vector.h>         // IWYU pragma: export
-#include <array>                              // IWYU pragma: export
+#include <arrow/array/array_binary.h>
+#include <arrow/table.h>              // IWYU pragma: export
+#include <arrow/array.h>              // IWYU pragma: export
+#include <arrow/util/config.h>        // IWYU pragma: export
+#include <gandiva/selection_vector.h> // IWYU pragma: export
+#include <array>                      // IWYU pragma: export
 #include <cassert>
 #include <fmt/format.h>
 #include <concepts>
@@ -578,7 +579,15 @@ class ColumnIterator : ChunkingPolicy
   }
 
   decltype(auto) operator*() const
-    requires((!std::same_as<bool, std::decay_t<T>>) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
+    requires((!std::same_as<bool, std::decay_t<T>>) && std::same_as<arrow_array_for_t<T>, arrow::BinaryViewArray>)
+  {
+    checkSkipChunk();
+    auto array = std::static_pointer_cast<arrow::BinaryViewArray>(mColumn->chunk(mCurrentChunk));
+    return array->GetView(*mCurrentPos - mFirstIndex);
+  }
+
+  decltype(auto) operator*() const
+    requires((!std::same_as<bool, std::decay_t<T>>) && !std::same_as<arrow_array_for_t<T>, arrow::ListArray> && !std::same_as<arrow_array_for_t<T>, arrow::BinaryViewArray>)
   {
     checkSkipChunk();
     return *(mCurrent + (*mCurrentPos >> SCALE_FACTOR));
diff --git a/Framework/Core/include/Framework/ArrowTypes.h b/Framework/Core/include/Framework/ArrowTypes.h
index 69946b6f35a50..6fd70113fede7 100644
--- a/Framework/Core/include/Framework/ArrowTypes.h
+++ b/Framework/Core/include/Framework/ArrowTypes.h
@@ -12,6 +12,7 @@
 #ifndef O2_FRAMEWORK_ARROWTYPES_H
 #define O2_FRAMEWORK_ARROWTYPES_H
 #include "arrow/type_fwd.h"
+#include <span>
 
 namespace o2::soa
 {
@@ -62,6 +63,10 @@ template <>
 struct arrow_array_for<double> {
   using type = arrow::DoubleArray;
 };
+template <>
+struct arrow_array_for<std::span<std::byte>> {
+  using type = arrow::BinaryViewArray;
+};
 template <int N>
 struct arrow_array_for<float[N]> {
   using type = arrow::FixedSizeListArray;
diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index eb56791acfd3c..74395a2680077 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -98,6 +98,7 @@ O2_ARROW_STL_CONVERSION(long unsigned, UInt64Type)
 O2_ARROW_STL_CONVERSION(float, FloatType)
 O2_ARROW_STL_CONVERSION(double, DoubleType)
 O2_ARROW_STL_CONVERSION(std::string, StringType)
+O2_ARROW_STL_CONVERSION(std::span<std::byte>, BinaryViewType)
 } // namespace detail
 
 void addLabelToSchema(std::shared_ptr<arrow::Schema>& schema, const char* label);
@@ -274,6 +275,29 @@ struct BuilderMaker<bool> {
   }
 };
 
+template <>
+struct BuilderMaker<std::span<std::byte>> {
+  using FillType = std::span<std::byte>;
+  using STLValueType = std::span<std::byte>;
+  using ArrowType = typename detail::ConversionTraits<std::span<std::byte>>::ArrowType;
+  using BuilderType = typename arrow::TypeTraits<ArrowType>::BuilderType;
+
+  static std::unique_ptr<BuilderType> make(arrow::MemoryPool* pool)
+  {
+    return std::make_unique<BuilderType>(pool);
+  }
+
+  static std::shared_ptr<arrow::DataType> make_datatype()
+  {
+    return arrow::TypeTraits<ArrowType>::type_singleton();
+  }
+
+  static arrow::Status append(BuilderType& builder, std::span<std::byte> value)
+  {
+    return builder.Append((char*)value.data(), (int64_t)value.size());
+  }
+};
+
 template <typename ITERATOR>
 struct BuilderMaker<std::pair<ITERATOR, ITERATOR>> {
   using FillType = std::pair<ITERATOR, ITERATOR>;
@@ -422,6 +446,13 @@ struct DirectInsertion {
     return builder->Append(value);
   }
 
+  template <typename BUILDER>
+    requires std::same_as<std::span<std::byte>, T>
+  arrow::Status append(BUILDER& builder, T value)
+  {
+    return builder->Append((char*)value.data(), (int64_t)value.size());
+  }
+
   template <typename BUILDER>
   arrow::Status flush(BUILDER&)
   {
@@ -569,7 +600,7 @@ template <typename... ARGS>
 using IndexedHoldersTuple = decltype(makeHolderTypes<ARGS...>());
 
 template <typename T>
-concept ShouldNotDeconstruct = std::is_bounded_array_v<T> || std::is_arithmetic_v<T> || framework::is_base_of_template_v<std::vector, T>;
+concept ShouldNotDeconstruct = std::is_bounded_array_v<T> || std::is_arithmetic_v<T> || framework::is_base_of_template_v<std::vector, T> || std::same_as<std::span<std::byte>, T>;
 
 /// Helper class which creates a lambda suitable for building
 /// an arrow table from a tuple. This can be used, for example
diff --git a/Framework/Core/test/test_TableBuilder.cxx b/Framework/Core/test/test_TableBuilder.cxx
index 00cbbbc59b725..02bc8fbe67833 100644
--- a/Framework/Core/test/test_TableBuilder.cxx
+++ b/Framework/Core/test/test_TableBuilder.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -19,6 +19,8 @@
 #include <arrow/ipc/writer.h>
 #include <arrow/ipc/reader.h>
 
+#include <string_view>
+
 using namespace o2::framework;
 
 // We use a different namespace to avoid clashes with the
@@ -27,10 +29,12 @@ namespace test2
 {
 DECLARE_SOA_COLUMN_FULL(X, x, uint64_t, "x");
 DECLARE_SOA_COLUMN_FULL(Y, y, uint64_t, "y");
+DECLARE_SOA_COLUMN_FULL(Blob, blob, std::span<std::byte>, "blob");
 DECLARE_SOA_COLUMN_FULL(Pos, pos, int[4], "pos");
 } // namespace test2
 
 using TestTable = o2::soa::InPlaceTable<0, test2::X, test2::Y>;
+using SpanTable = o2::soa::InPlaceTable<0, test2::Blob>;
 using ArrayTable = o2::soa::InPlaceTable<0, test2::Pos>;
 
 TEST_CASE("TestTableBuilder")
@@ -189,6 +193,35 @@ TEST_CASE("TestTableBuilderMore")
   REQUIRE(table->schema()->field(3)->type()->id() == arrow::boolean()->id());
 }
 
+TEST_CASE("TestSpan")
+{
+  TableBuilder builder;
+  std::vector<std::byte> buffer{10, std::byte{'c'}};
+  std::vector<std::byte> buffer1{10, std::byte{'a'}};
+
+  auto rowWriter = builder.persist<std::span<std::byte>>({"blob"});
+  rowWriter(0, std::span(buffer));
+  rowWriter(0, std::span(buffer.data() + 1, 9));
+  rowWriter(0, std::span(buffer1.data(), 3));
+  rowWriter(0, std::span(buffer1.data(), 1));
+  auto table = builder.finalize();
+
+  REQUIRE(table->num_columns() == 1);
+  REQUIRE(table->num_rows() == 4);
+  REQUIRE(table->schema()->field(0)->name() == "blob");
+  REQUIRE(table->schema()->field(0)->type()->id() == arrow::binary_view()->id());
+
+  auto readBack = SpanTable{table};
+  auto row = readBack.begin();
+  REQUIRE(row.blob() == "cccccccccc");
+  ++row;
+  REQUIRE(row.blob() == "ccccccccc");
+  ++row;
+  REQUIRE(row.blob() == "aaa");
+  ++row;
+  REQUIRE(row.blob() == "a");
+}
+
 TEST_CASE("TestSoAIntegration")
 {
   TableBuilder builder;

From f2b0957773011be7cd8d4feb68fb9cae45e0e05d Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 6 Aug 2025 14:20:09 +0200
Subject: [PATCH 0680/1764] ITS: GPU: put trackleting properly on different
 streams

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  9 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   | 25 ++++--
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 82 ++++++++++++-------
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  1 +
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 10 ++-
 5 files changed, 80 insertions(+), 47 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 0ad08fd88ccf5..4656dd1d14846 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -79,6 +79,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
     return mGpuStreams[stream];
   }
   auto& getStreams() { return mGpuStreams; }
+  void syncStreams();
   virtual void wipe() final;
 
   /// interface
@@ -108,7 +109,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   std::vector<unsigned int> getClusterSizes();
   const unsigned char** getDeviceArrayUsedClusters() const { return mUsedClustersDeviceArray; }
   const int** getDeviceROframeClusters() const { return mROFrameClustersDeviceArray; }
-  Tracklet** getDeviceArrayTracklets() { return mTrackletsDeviceArray; }
+  Tracklet** getDeviceArrayTracklets() { return mTrackletsDevice.data(); }
   int** getDeviceArrayTrackletsLUT() const { return mTrackletsLUTDeviceArray; }
   int** getDeviceArrayCellsLUT() const { return mCellsLUTDeviceArray; }
   int** getDeviceArrayNeighboursCellLUT() const { return mNeighboursCellLUTDeviceArray; }
@@ -140,7 +141,8 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   int getNumberOfNeighbours() const final;
 
  private:
-  void allocMemAsync(void**, size_t, Stream&, bool); // Abstract owned and unowned memory allocations
+  void allocMemAsync(void**, size_t, Stream&, bool); // Abstract owned and unowned memory allocations on specific stream
+  void allocMem(void**, size_t, bool);               // Abstract owned and unowned memory allocations on default stream
   bool mHostRegistered = false;
   TimeFrameGPUParameters mGpuParams;
 
@@ -167,7 +169,6 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   const unsigned char** mUsedClustersDeviceArray;
   const int** mROFrameClustersDeviceArray;
   std::array<Tracklet*, nLayers - 1> mTrackletsDevice;
-  Tracklet** mTrackletsDeviceArray;
   std::array<int*, nLayers - 1> mTrackletsLUTDevice;
   std::array<int*, nLayers - 2> mCellsLUTDevice;
   std::array<int*, nLayers - 3> mNeighboursLUTDevice;
@@ -195,8 +196,6 @@ class TimeFrameGPU : public TimeFrame<nLayers>
 
   // State
   Streams mGpuStreams;
-  size_t mAvailMemGB;
-  bool mFirstInit = true;
 
   // Temporary buffer for storing output tracks from GPU tracking
   bounded_vector<TrackITSExt> mTrackITSExt;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index 802973d5f4000..9d25bd22484fe 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -94,16 +94,21 @@ class Stream
  public:
 #if defined(__HIPCC__)
   using Handle = hipStream_t;
-  static constexpr Handle Default = 0;
+  static constexpr Handle DefaultStream = 0;
+  // static constexpr unsigned int DefaultFlag = hipStreamNonBlocking; TODO replace once ready
+  static constexpr unsigned int DefaultFlag = 0;
 #elif defined(__CUDACC__)
   using Handle = cudaStream_t;
-  static constexpr Handle Default = 0;
+  static constexpr Handle DefaultStream = 0;
+  // static constexpr unsigned int DefaultFlag = cudaStreamNonBlocking; TODO replace once ready
+  static constexpr unsigned int DefaultFlag = 0;
 #else
   using Handle = void*;
-  static constexpr Handle Default = nullptr;
+  static constexpr Handle DefaultStream = nullptr;
+  static constexpr unsigned int DefaultFlag = 0;
 #endif
 
-  Stream(unsigned int flags = 0)
+  Stream(unsigned int flags = DefaultFlag)
   {
 #if defined(__HIPCC__)
     GPUChkErrS(hipStreamCreateWithFlags(&mHandle, flags));
@@ -115,7 +120,7 @@ class Stream
   Stream(Handle h) : mHandle(h) {}
   ~Stream()
   {
-    if (mHandle != Default) {
+    if (mHandle != DefaultStream) {
 #if defined(__HIPCC__)
       GPUChkErrS(hipStreamDestroy(mHandle));
 #elif defined(__CUDACC__)
@@ -124,7 +129,7 @@ class Stream
     }
   }
 
-  operator bool() const { return mHandle != Default; }
+  operator bool() const { return mHandle != DefaultStream; }
   const Handle& get() { return mHandle; }
   void sync() const
   {
@@ -136,7 +141,7 @@ class Stream
   }
 
  private:
-  Handle mHandle{Default};
+  Handle mHandle{DefaultStream};
 };
 static_assert(sizeof(Stream) == sizeof(void*), "Stream type must match pointer type!");
 
@@ -150,6 +155,12 @@ class Streams
   void clear() { mStreams.clear(); }
   auto& operator[](size_t i) { return mStreams[i % mStreams.size()]; }
   void push_back(const Stream& stream) { mStreams.push_back(stream); }
+  void sync()
+  {
+    for (auto& s : mStreams) {
+      s.sync();
+    }
+  }
 
  private:
   std::vector<Stream> mStreams;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index f6d9157b0da68..dafd218c1e811 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -122,6 +122,17 @@ void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& strea
   }
 }
 
+template <int nLayers>
+void TimeFrameGPU<nLayers>::allocMem(void** ptr, size_t size, bool extAllocator)
+{
+  if (extAllocator) {
+    *ptr = this->mAllocator->allocate(size);
+  } else {
+    GPULog("Calling default CUDA allocator");
+    GPUChkErrS(cudaMalloc(reinterpret_cast<void**>(ptr), size));
+  }
+}
+
 template <int nLayers>
 void TimeFrameGPU<nLayers>::setDevicePropagator(const o2::base::PropagatorImpl<float>* propagator)
 {
@@ -134,10 +145,10 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
   GPUTimer timer(mGpuStreams[0], "loading indextable utils");
   if (!iteration) {
     GPULog("gpu-allocation: allocating IndexTableUtils buffer, for {:.2f} MB.", sizeof(IndexTableUtils) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), mGpuStreams[0], this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), this->getExtAllocator());
   }
   GPULog("gpu-transfer: loading IndexTableUtils object, for {:.2f} MB.", sizeof(IndexTableUtils) / constants::MB);
-  GPUChkErrS(cudaMemcpyAsync(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtils), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpy(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtils), cudaMemcpyHostToDevice));
 }
 
 template <int nLayers>
@@ -151,9 +162,10 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
       GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
       GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), mGpuStreams[0], this->getExtAllocator());
+    mGpuStreams.sync();
+    allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpy(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice));
   }
 }
 
@@ -164,13 +176,14 @@ void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
     GPUTimer timer(mGpuStreams[0], "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       GPULog("gpu-transfer: loading {} clusters on layer {}, for {:.2f} MB.", this->mClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(Cluster) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), this->mClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[0], this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), this->mClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[iLayer], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), mGpuStreams[0], this->getExtAllocator());
+    mGpuStreams.sync();
+    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpy(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice));
   }
 }
 
@@ -181,11 +194,12 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
     GPUTimer timer(mGpuStreams[0], "loading sorted clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       GPULog("gpu-transfer: loading clusters indextable for layer {} with {} elements, for {:.2f} MB.", iLayer, this->mIndexTables[iLayer].size(), this->mIndexTables[iLayer].size() * sizeof(int) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), this->mIndexTables[iLayer].size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), this->mIndexTables[iLayer].size() * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
+      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    mGpuStreams.sync();
+    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice));
   }
 }
 
@@ -196,10 +210,11 @@ void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
     GPUTimer timer(mGpuStreams[0], "creating used clusters flags");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       GPULog("gpu-transfer: creating {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0], this->getExtAllocator());
-      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[0].get()));
+      allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[iLayer], this->getExtAllocator());
+      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[iLayer].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), mGpuStreams[0], this->getExtAllocator());
+    mGpuStreams.sync();
+    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), this->getExtAllocator());
     GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   }
 }
@@ -221,11 +236,12 @@ void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
     GPUTimer timer(mGpuStreams[0], "loading ROframe clusters");
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       GPULog("gpu-transfer: loading {} ROframe clusters info on layer {}, for {:.2f} MB.", this->mROFramesClusters[iLayer].size(), iLayer, this->mROFramesClusters[iLayer].size() * sizeof(int) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), this->mROFramesClusters[iLayer].size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), this->mROFramesClusters[iLayer].size() * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
       GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
     }
-    allocMemAsync(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    mGpuStreams.sync();
+    allocMem(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpy(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice));
   }
 }
 
@@ -236,10 +252,11 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
   if (!iteration) {
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
       GPULog("gpu-transfer: loading {} tfinfo on layer {}, for {:.2f} MB.", this->mTrackingFrameInfo[iLayer].size(), iLayer, this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), mGpuStreams[0], this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), mGpuStreams[iLayer], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
     }
+    mGpuStreams.sync();
     allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), mGpuStreams[0], this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
@@ -253,9 +270,9 @@ void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
     GPUTimer timer(mGpuStreams[0], "loading multiplicity cut mask");
     GPULog("gpu-transfer: iteration {} loading multiplicity cut mask with {} elements, for {:.2f} MB.", iteration, this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(bool) / constants::MB);
     if (!iteration) { // only allocate on first call
-      allocMemAsync(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), mGpuStreams[0], this->getExtAllocator());
+      allocMem(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), this->getExtAllocator());
     }
-    GPUChkErrS(cudaMemcpyAsync(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUChkErrS(cudaMemcpy(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice));
   }
 }
 
@@ -265,11 +282,11 @@ void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
   if (!iteration) {
     GPUTimer timer(mGpuStreams[0], "loading seeding vertices");
     GPULog("gpu-transfer: loading {} ROframes vertices, for {:.2f} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    allocMem(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpy(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice));
     GPULog("gpu-transfer: loading {} seeding vertices, for {:.2f} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), mGpuStreams[0], this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    allocMem(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpy(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice));
   }
 }
 
@@ -294,16 +311,13 @@ void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsBuffers()
 {
-  GPUTimer timer(mGpuStreams[0], "creating tracklet buffers");
   for (int iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
+    GPUTimer timer(mGpuStreams[iLayer], "creating tracklet buffers");
     mNTracklets[iLayer] = 0;
     GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + this->mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
     GPULog("gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {:.2f} MB.", mNTracklets[iLayer], iLayer, mNTracklets[iLayer] * sizeof(Tracklet) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), mGpuStreams[iLayer], this->getExtAllocator());
   }
-  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mTrackletsDeviceArray, mTrackletsDevice.data(), (nLayers - 1) * sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
 }
 
 template <int nLayers>
@@ -524,7 +538,7 @@ void TimeFrameGPU<nLayers>::unregisterRest()
   GPUTimer timer(mGpuStreams[0], "unregistering rest of the host memory");
   GPULog("unregistering rest of the host memory...");
   GPUChkErrS(cudaHostUnregister(mCellsDevice.data()));
-  GPUChkErrS(cudaHostUnregister(mTrackletsDevice.data()));
+  // GPUChkErrS(cudaHostUnregister(mTrackletsDevice.data()));
 }
 
 template <int nLayers>
@@ -553,6 +567,12 @@ void TimeFrameGPU<nLayers>::initialise(const int iteration,
   o2::its::TimeFrame<nLayers>::initialise(iteration, trkParam, maxLayers);
 }
 
+template <int nLayers>
+void TimeFrameGPU<nLayers>::syncStreams()
+{
+  mGpuStreams.sync();
+}
+
 template <int nLayers>
 void TimeFrameGPU<nLayers>::wipe()
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index eaa6080761fec..9a6fe4e050519 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -116,6 +116,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          conf.nBlocksLayerTracklets[iteration],
                                          conf.nThreadsLayerTracklets[iteration],
                                          mTimeFrameGPU->getStreams());
+  mTimeFrameGPU->syncStreams(); // TODO evaluate if this can be removed
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 02be19b1e3a08..6e678118686ab 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -876,9 +876,9 @@ GPUhi() void cubExclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stre
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
   GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+  GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
   GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  GPUChkErrS(cudaFree(d_temp_storage));
+  GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
 }
 
 template <typename Vector>
@@ -893,9 +893,9 @@ GPUhi() void cubInclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stre
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
   GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  GPUChkErrS(cudaMalloc(&d_temp_storage, temp_storage_bytes));
+  GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
   GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  GPUChkErrS(cudaFree(d_temp_storage));
+  GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
 }
 
 template <typename Vector>
@@ -1030,6 +1030,8 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
       resolutions[iLayer],
       radii[iLayer + 1] - radii[iLayer],
       mulScatAng[iLayer]);
+    /// Internal thrust allocation serialize this part to a degree
+    /// TODO switch to cub equivelent and do all work on one stream
     thrust::device_ptr<Tracklet> tracklets_ptr(spanTracklets[iLayer]);
     auto nosync_policy = THRUST_NAMESPACE::par_nosync.on(streams[iLayer].get());
     thrust::sort(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::sort_tracklets());

From 2498a68ad1982a2dec814390a64d0b4b1a4a9bdf Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 6 Aug 2025 15:33:05 +0200
Subject: [PATCH 0681/1764] ITS: GPU: put cell finding on different streams

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  6 +---
 .../GPU/ITStrackingGPU/TrackingKernels.h      | 11 ++++++--
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     |  8 +++++-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 28 ++++++++++++++-----
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 12 ++++----
 5 files changed, 44 insertions(+), 21 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 4656dd1d14846..afe31b14a4a0a 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -73,12 +73,8 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
   void unregisterRest();
-  template <Task task>
-  auto& getStream(const size_t stream)
-  {
-    return mGpuStreams[stream];
-  }
   auto& getStreams() { return mGpuStreams; }
+  void syncStream(const size_t stream);
   void syncStreams();
   virtual void wipe() final;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index b0fb443513fef..567aa07f42f7c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -25,7 +25,10 @@ namespace gpu
 
 #ifdef GPUCA_GPUCODE // GPUg() global kernels must only when compiled by GPU compiler
 
-GPUdi() int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
+GPUdi() int4 getEmptyBinsRect()
+{
+  return int4{0, 0, 0, 0};
+}
 
 GPUd() bool fitTrack(TrackITSExt& track,
                      int start,
@@ -137,7 +140,8 @@ void countCellsHandler(const Cluster** sortedClusters,
                        const float cellDeltaTanLambdaSigma,
                        const float nSigmaCut,
                        const int nBlocks,
-                       const int nThreads);
+                       const int nThreads,
+                       gpu::Streams& streams);
 
 void computeCellsHandler(const Cluster** sortedClusters,
                          const Cluster** unsortedClusters,
@@ -155,7 +159,8 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          const float cellDeltaTanLambdaSigma,
                          const float nSigmaCut,
                          const int nBlocks,
-                         const int nThreads);
+                         const int nThreads,
+                         gpu::Streams& streams);
 
 unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                         int* neighboursLUTs,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index dafd218c1e811..da91373611a2d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -402,7 +402,7 @@ void TimeFrameGPU<nLayers>::createCellsLUTDevice()
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
 {
-  GPUTimer timer(mGpuStreams[0], "creating cells buffers");
+  GPUTimer timer(mGpuStreams[layer], "creating cells buffers");
   mNCells[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / constants::MB);
@@ -567,6 +567,12 @@ void TimeFrameGPU<nLayers>::initialise(const int iteration,
   o2::its::TimeFrame<nLayers>::initialise(iteration, trkParam, maxLayers);
 }
 
+template <int nLayers>
+void TimeFrameGPU<nLayers>::syncStream(const size_t stream)
+{
+  mGpuStreams[stream].sync();
+}
+
 template <int nLayers>
 void TimeFrameGPU<nLayers>::syncStreams()
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 9a6fe4e050519..2ae4f0aa91819 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -116,7 +116,6 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          conf.nBlocksLayerTracklets[iteration],
                                          conf.nThreadsLayerTracklets[iteration],
                                          mTimeFrameGPU->getStreams());
-  mTimeFrameGPU->syncStreams(); // TODO evaluate if this can be removed
 }
 
 template <int nLayers>
@@ -125,18 +124,30 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
   mTimeFrameGPU->createCellsLUTDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
+  std::vector<bool> isTrackletStreamSynched(this->mTrkParams[iteration].TrackletsPerRoad());
+  auto syncOnce = [&](const int iLayer) {
+    if (!isTrackletStreamSynched[iLayer]) {
+      mTimeFrameGPU->syncStream(iLayer);
+      isTrackletStreamSynched[iLayer] = true;
+    }
+  };
+
   for (int iLayer = 0; iLayer < this->mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-    if (!mTimeFrameGPU->getNTracklets()[iLayer + 1] || !mTimeFrameGPU->getNTracklets()[iLayer]) {
+    // need to ensure that trackleting on layers iLayer and iLayer + 1 are done (only once)
+    syncOnce(iLayer);
+    syncOnce(iLayer + 1);
+    // if there are no tracklets skip entirely
+    const int currentLayerTrackletsNum{static_cast<int>(mTimeFrameGPU->getNTracklets()[iLayer])};
+    if (!currentLayerTrackletsNum || !mTimeFrameGPU->getNTracklets()[iLayer + 1]) {
       mTimeFrameGPU->getNCells()[iLayer] = 0;
       continue;
     }
-    const int currentLayerTrackletsNum{static_cast<int>(mTimeFrameGPU->getNTracklets()[iLayer])};
     countCellsHandler(mTimeFrameGPU->getDeviceArrayClusters(),
                       mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
                       mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                       mTimeFrameGPU->getDeviceArrayTracklets(),
                       mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
-                      mTimeFrameGPU->getNTracklets()[iLayer],
+                      currentLayerTrackletsNum,
                       iLayer,
                       nullptr,
                       mTimeFrameGPU->getDeviceArrayCellsLUT(),
@@ -147,14 +158,15 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                       this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                       this->mTrkParams[iteration].NSigmaCut,
                       conf.nBlocksLayerCells[iteration],
-                      conf.nThreadsLayerCells[iteration]);
+                      conf.nThreadsLayerCells[iteration],
+                      mTimeFrameGPU->getStreams());
     mTimeFrameGPU->createCellsBuffers(iLayer);
     computeCellsHandler(mTimeFrameGPU->getDeviceArrayClusters(),
                         mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
                         mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                         mTimeFrameGPU->getDeviceArrayTracklets(),
                         mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
-                        mTimeFrameGPU->getNTracklets()[iLayer],
+                        currentLayerTrackletsNum,
                         iLayer,
                         mTimeFrameGPU->getDeviceCells()[iLayer],
                         mTimeFrameGPU->getDeviceArrayCellsLUT(),
@@ -165,8 +177,10 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                         this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                         this->mTrkParams[iteration].NSigmaCut,
                         conf.nBlocksLayerCells[iteration],
-                        conf.nThreadsLayerCells[iteration]);
+                        conf.nThreadsLayerCells[iteration],
+                        mTimeFrameGPU->getStreams());
   }
+  mTimeFrameGPU->syncStreams(); // TODO evaluate if this can be removed
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 6e678118686ab..d4dcda067b26f 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -1065,9 +1065,10 @@ void countCellsHandler(
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut,
   const int nBlocks,
-  const int nThreads)
+  const int nThreads,
+  gpu::Streams& streams)
 {
-  gpu::computeLayerCellsKernel<true><<<nBlocks, nThreads>>>(
+  gpu::computeLayerCellsKernel<true><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
     sortedClusters,           // const Cluster**
     unsortedClusters,         // const Cluster**
     tfInfo,                   // const TrackingFrameInfo**
@@ -1082,7 +1083,7 @@ void countCellsHandler(
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
     nSigmaCut);               // const float
-  gpu::cubExclusiveScanInPlace(cellsLUTsHost, nTracklets + 1);
+  gpu::cubExclusiveScanInPlace(cellsLUTsHost, nTracklets + 1, streams[layer].get());
 }
 
 void computeCellsHandler(
@@ -1102,9 +1103,10 @@ void computeCellsHandler(
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut,
   const int nBlocks,
-  const int nThreads)
+  const int nThreads,
+  gpu::Streams& streams)
 {
-  gpu::computeLayerCellsKernel<false><<<nBlocks, nThreads>>>(
+  gpu::computeLayerCellsKernel<false><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
     sortedClusters,           // const Cluster**
     unsortedClusters,         // const Cluster**
     tfInfo,                   // const TrackingFrameInfo**

From 853e48dd3895a78b2e81aef21968bf16f8fb1ac4 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 6 Aug 2025 16:28:15 +0200
Subject: [PATCH 0682/1764] ITS: GPU: put cell neighbour finding on different
 streams

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         | 12 ++--
 .../GPU/ITStrackingGPU/TrackingKernels.h      | 35 +++++-----
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 59 ++++-------------
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 66 +++++++++++--------
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 58 ++++++++--------
 5 files changed, 101 insertions(+), 129 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index afe31b14a4a0a..5c10b01412b4e 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -62,17 +62,15 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void createCellsDevice();
   void createCellsLUTDevice();
   void createNeighboursIndexTablesDevice();
-  void createNeighboursDevice(const unsigned int layer, const unsigned int nNeighbours);
-  void createNeighboursDevice(const unsigned int layer, std::vector<std::pair<int, int>>& neighbours);
+  void createNeighboursDevice(const unsigned int layer);
   void createNeighboursLUTDevice(const int, const unsigned int);
-  void createNeighboursDeviceArray();
   void createTrackITSExtDevice(bounded_vector<CellSeed>&);
   void downloadTrackITSExtDevice(bounded_vector<CellSeed>&);
   void downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>&, const int);
   void downloadNeighboursLUTDevice(bounded_vector<int>&, const int);
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
-  void unregisterRest();
+  auto& getStream(const size_t stream) { return mGpuStreams[stream]; }
   auto& getStreams() { return mGpuStreams; }
   void syncStream(const size_t stream);
   void syncStreams();
@@ -96,7 +94,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   gpuPair<int, int>* getDeviceNeighbourPairs(const int layer) { return mNeighbourPairsDevice[layer]; }
   std::array<int*, nLayers - 2>& getDeviceNeighboursAll() { return mNeighboursDevice; }
   int* getDeviceNeighbours(const int layer) { return mNeighboursDevice[layer]; }
-  int** getDeviceNeighboursArray() { return mNeighboursDeviceArray; }
+  int** getDeviceNeighboursArray() { return mNeighboursDevice.data(); }
   TrackingFrameInfo* getDeviceTrackingFrameInfo(const int);
   const TrackingFrameInfo** getDeviceArrayTrackingFrameInfo() const { return mTrackingFrameInfoDeviceArray; }
   const Cluster** getDeviceArrayClusters() const { return mClustersDeviceArray; }
@@ -109,7 +107,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   int** getDeviceArrayTrackletsLUT() const { return mTrackletsLUTDeviceArray; }
   int** getDeviceArrayCellsLUT() const { return mCellsLUTDeviceArray; }
   int** getDeviceArrayNeighboursCellLUT() const { return mNeighboursCellLUTDeviceArray; }
-  CellSeed** getDeviceArrayCells() const { return mCellsDeviceArray; }
+  CellSeed** getDeviceArrayCells() { return mCellsDevice.data(); }
   CellSeed* getDeviceTrackSeeds() { return mTrackSeedsDevice; }
   o2::track::TrackParCovF** getDeviceArrayTrackSeeds() { return mCellSeedsDeviceArray; }
   float** getDeviceArrayTrackSeedsChi2() { return mCellSeedsChi2DeviceArray; }
@@ -176,7 +174,6 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   std::array<CellSeed*, nLayers - 2> mCellsDevice;
   std::array<int*, nLayers - 2> mNeighboursIndexTablesDevice;
   CellSeed* mTrackSeedsDevice;
-  CellSeed** mCellsDeviceArray;
   std::array<o2::track::TrackParCovF*, nLayers - 2> mCellSeedsDevice;
   o2::track::TrackParCovF** mCellSeedsDeviceArray;
   std::array<float*, nLayers - 2> mCellSeedsChi2Device;
@@ -186,7 +183,6 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   TrackITSExt* mTrackITSExtDevice;
   std::array<gpuPair<int, int>*, nLayers - 2> mNeighbourPairsDevice;
   std::array<int*, nLayers - 2> mNeighboursDevice;
-  int** mNeighboursDeviceArray;
   std::array<TrackingFrameInfo*, nLayers> mTrackingFrameInfoDevice;
   const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 567aa07f42f7c..caa7675756db6 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -162,21 +162,22 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          const int nThreads,
                          gpu::Streams& streams);
 
-unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
-                                        int* neighboursLUTs,
-                                        int** cellsLUTs,
-                                        gpuPair<int, int>* cellNeighbours,
-                                        int* neighboursIndexTable,
-                                        const Tracklet** tracklets,
-                                        const int deltaROF,
-                                        const float maxChi2ClusterAttachment,
-                                        const float bz,
-                                        const int layerIndex,
-                                        const unsigned int nCells,
-                                        const unsigned int nCellsNext,
-                                        const int maxCellNeighbours,
-                                        const int nBlocks,
-                                        const int nThreads);
+void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
+                                int* neighboursLUTs,
+                                int** cellsLUTs,
+                                gpuPair<int, int>* cellNeighbours,
+                                int* neighboursIndexTable,
+                                const Tracklet** tracklets,
+                                const int deltaROF,
+                                const float maxChi2ClusterAttachment,
+                                const float bz,
+                                const int layerIndex,
+                                const unsigned int nCells,
+                                const unsigned int nCellsNext,
+                                const int maxCellNeighbours,
+                                const int nBlocks,
+                                const int nThreads,
+                                gpu::Stream& stream);
 
 void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   int* neighboursLUTs,
@@ -192,11 +193,13 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   const unsigned int nCellsNext,
                                   const int maxCellNeighbours,
                                   const int nBlocks,
-                                  const int nThreads);
+                                  const int nThreads,
+                                  gpu::Stream& stream);
 
 int filterCellNeighboursHandler(gpuPair<int, int>*,
                                 int*,
                                 unsigned int,
+                                gpu::Stream&,
                                 o2::its::ExternalAllocator* = nullptr);
 
 template <int nLayers = 7>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index da91373611a2d..72a1f98d1b78b 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -349,26 +349,20 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
 {
   GPUTimer timer(mGpuStreams[0], "creating cells neighbours");
   // Here we do also the creation of the CellsDeviceArray, as the cells buffers are populated separately in the previous steps.
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaHostRegister(mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     GPULog("gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[0].get()));
-    if (iLayer < nLayers - 3) {
-      mNNeighbours[iLayer] = 0;
-    }
+    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
+    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer].get()));
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const unsigned int nCells)
 {
-  GPUTimer timer(mGpuStreams[0], "reserving neighboursLUT");
+  GPUTimer timer(mGpuStreams[layer], "reserving neighboursLUT");
   GPULog("gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {:.2f} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[0], this->getExtAllocator()); // We need one element more to move exc -> inc
-  GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[0].get()));
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[layer], this->getExtAllocator()); // We need one element more to move exc -> inc
+  GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[layer].get()));
 }
 
 template <int nLayers>
@@ -382,8 +376,6 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
     GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
 }
 
 template <int nLayers>
@@ -441,35 +433,15 @@ void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeed>& seeds
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, const unsigned int nNeighbours)
+void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer)
 {
-  GPUTimer timer(mGpuStreams[0], "reserving neighbours");
+  GPUTimer timer(mGpuStreams[layer], "reserving neighbours");
+  GPUChkErrS(cudaMemcpyAsync(&(this->mNNeighbours[layer]), &(mNeighboursLUTDevice[layer][this->mNCells[layer + 1] - 1]), sizeof(unsigned int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, nNeighbours * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
+  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer], this->getExtAllocator());
+  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer].get()));
   GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), nNeighbours * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-}
-
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer, std::vector<std::pair<int, int>>& neighbours)
-{
-  GPUTimer timer(mGpuStreams[0], "reserving neighbours");
-  this->mCellsNeighbours[layer].clear();
-  this->mCellsNeighbours[layer].resize(neighbours.size());
-  GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, neighbours.size() * sizeof(gpuPair<int, int>), mGpuStreams[0].get()));
-  GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", neighbours.size(), neighbours.size() * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), neighbours.size() * sizeof(int), mGpuStreams[0], this->getExtAllocator());
-}
-
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createNeighboursDeviceArray()
-{
-  GPUTimer timer(mGpuStreams[0], "reserving neighbours");
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mNeighboursDeviceArray, mNeighboursDevice.data(), (nLayers - 2) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
 }
 
 template <int nLayers>
@@ -532,15 +504,6 @@ void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeed>&
   GPUChkErrS(cudaHostUnregister(seeds.data()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::unregisterRest()
-{
-  GPUTimer timer(mGpuStreams[0], "unregistering rest of the host memory");
-  GPULog("unregistering rest of the host memory...");
-  GPUChkErrS(cudaHostUnregister(mCellsDevice.data()));
-  // GPUChkErrS(cudaHostUnregister(mTrackletsDevice.data()));
-}
-
 template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 2ae4f0aa91819..0fa258f63fd23 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -180,7 +180,6 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                         conf.nThreadsLayerCells[iteration],
                         mTimeFrameGPU->getStreams());
   }
-  mTimeFrameGPU->syncStreams(); // TODO evaluate if this can be removed
 }
 
 template <int nLayers>
@@ -188,7 +187,20 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
 {
   mTimeFrameGPU->createNeighboursIndexTablesDevice();
   const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
+
+  std::vector<bool> isCellStreamSynched(this->mTrkParams[iteration].TrackletsPerRoad() - 1);
+  auto syncOnce = [&](const int iLayer) {
+    if (!isCellStreamSynched[iLayer]) {
+      mTimeFrameGPU->syncStream(iLayer);
+      isCellStreamSynched[iLayer] = true;
+    }
+  };
+
   for (int iLayer{0}; iLayer < this->mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
+    // ensure that celling is done for iLayer and iLayer+1 is done
+    syncOnce(iLayer);
+    syncOnce(iLayer + 1);
+
     const int currentLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer])};
     const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};
     if (!nextLayerCellsNum || !currentLayerCellsNum) {
@@ -197,24 +209,23 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
     }
 
     mTimeFrameGPU->createNeighboursLUTDevice(iLayer, nextLayerCellsNum);
-    unsigned int nNeigh = countCellNeighboursHandler(mTimeFrameGPU->getDeviceArrayCells(),
-                                                     mTimeFrameGPU->getDeviceNeighboursLUT(iLayer), // LUT is initialised here.
-                                                     mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                                                     mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
-                                                     mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
-                                                     (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                                                     this->mTrkParams[0].DeltaROF,
-                                                     this->mTrkParams[0].MaxChi2ClusterAttachment,
-                                                     this->mBz,
-                                                     iLayer,
-                                                     currentLayerCellsNum,
-                                                     nextLayerCellsNum,
-                                                     1e2,
-                                                     conf.nBlocksFindNeighbours[iteration],
-                                                     conf.nThreadsFindNeighbours[iteration]);
-
-    mTimeFrameGPU->createNeighboursDevice(iLayer, nNeigh);
-
+    countCellNeighboursHandler(mTimeFrameGPU->getDeviceArrayCells(),
+                               mTimeFrameGPU->getDeviceNeighboursLUT(iLayer), // LUT is initialised here.
+                               mTimeFrameGPU->getDeviceArrayCellsLUT(),
+                               mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
+                               mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
+                               (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
+                               this->mTrkParams[0].DeltaROF,
+                               this->mTrkParams[0].MaxChi2ClusterAttachment,
+                               this->mBz,
+                               iLayer,
+                               currentLayerCellsNum,
+                               nextLayerCellsNum,
+                               1e2,
+                               conf.nBlocksFindNeighbours[iteration],
+                               conf.nThreadsFindNeighbours[iteration],
+                               mTimeFrameGPU->getStream(iLayer));
+    mTimeFrameGPU->createNeighboursDevice(iLayer);
     computeCellNeighboursHandler(mTimeFrameGPU->getDeviceArrayCells(),
                                  mTimeFrameGPU->getDeviceNeighboursLUT(iLayer),
                                  mTimeFrameGPU->getDeviceArrayCellsLUT(),
@@ -229,16 +240,15 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                  nextLayerCellsNum,
                                  1e2,
                                  conf.nBlocksFindNeighbours[iteration],
-                                 conf.nThreadsFindNeighbours[iteration]);
-
-    nNeigh = filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
-                                         mTimeFrameGPU->getDeviceNeighbours(iLayer),
-                                         nNeigh,
-                                         mTimeFrameGPU->getExternalAllocator());
-    mTimeFrameGPU->getArrayNNeighbours()[iLayer] = nNeigh;
+                                 conf.nThreadsFindNeighbours[iteration],
+                                 mTimeFrameGPU->getStream(iLayer));
+    mTimeFrameGPU->getArrayNNeighbours()[iLayer] = filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
+                                                                               mTimeFrameGPU->getDeviceNeighbours(iLayer),
+                                                                               mTimeFrameGPU->getArrayNNeighbours()[iLayer],
+                                                                               mTimeFrameGPU->getStream(iLayer),
+                                                                               mTimeFrameGPU->getExternalAllocator());
   }
-  mTimeFrameGPU->createNeighboursDeviceArray();
-  mTimeFrameGPU->unregisterRest();
+  mTimeFrameGPU->syncStreams(); // TODO evaluate if this can be removed
 };
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index d4dcda067b26f..060f150bd6f42 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -1123,23 +1123,24 @@ void computeCellsHandler(
     nSigmaCut);               // const float
 }
 
-unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
-                                        int* neighboursLUT,
-                                        int** cellsLUTs,
-                                        gpuPair<int, int>* cellNeighbours,
-                                        int* neighboursIndexTable,
-                                        const Tracklet** tracklets,
-                                        const int deltaROF,
-                                        const float maxChi2ClusterAttachment,
-                                        const float bz,
-                                        const int layerIndex,
-                                        const unsigned int nCells,
-                                        const unsigned int nCellsNext,
-                                        const int maxCellNeighbours,
-                                        const int nBlocks,
-                                        const int nThreads)
+void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
+                                int* neighboursLUT,
+                                int** cellsLUTs,
+                                gpuPair<int, int>* cellNeighbours,
+                                int* neighboursIndexTable,
+                                const Tracklet** tracklets,
+                                const int deltaROF,
+                                const float maxChi2ClusterAttachment,
+                                const float bz,
+                                const int layerIndex,
+                                const unsigned int nCells,
+                                const unsigned int nCellsNext,
+                                const int maxCellNeighbours,
+                                const int nBlocks,
+                                const int nThreads,
+                                gpu::Stream& stream)
 {
-  gpu::computeLayerCellNeighboursKernel<true><<<nBlocks, nThreads>>>(
+  gpu::computeLayerCellNeighboursKernel<true><<<nBlocks, nThreads, 0, stream.get()>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1152,11 +1153,8 @@ unsigned int countCellNeighboursHandler(CellSeed** cellsLayersDevice,
     layerIndex,
     nCells,
     maxCellNeighbours);
-  gpu::cubInclusiveScanInPlace(neighboursLUT, nCellsNext);
-  gpu::cubExclusiveScanInPlace(neighboursIndexTable, nCells + 1);
-  unsigned int nNeighbours;
-  GPUChkErrS(cudaMemcpy(&nNeighbours, &neighboursLUT[nCellsNext - 1], sizeof(unsigned int), cudaMemcpyDeviceToHost));
-  return nNeighbours;
+  gpu::cubInclusiveScanInPlace(neighboursLUT, nCellsNext, stream.get());
+  gpu::cubExclusiveScanInPlace(neighboursIndexTable, nCells + 1, stream.get());
 }
 
 void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
@@ -1173,10 +1171,10 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   const unsigned int nCellsNext,
                                   const int maxCellNeighbours,
                                   const int nBlocks,
-                                  const int nThreads)
+                                  const int nThreads,
+                                  gpu::Stream& stream)
 {
-
-  gpu::computeLayerCellNeighboursKernel<false><<<nBlocks, nThreads>>>(
+  gpu::computeLayerCellNeighboursKernel<false><<<nBlocks, nThreads, 0, stream.get()>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1189,21 +1187,23 @@ void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
     layerIndex,
     nCells,
     maxCellNeighbours);
-  GPUChkErrS(cudaPeekAtLastError());
-  GPUChkErrS(cudaDeviceSynchronize());
 }
 
 int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
                                 int* cellNeighbours,
                                 unsigned int nNeigh,
+                                gpu::Stream& stream,
                                 o2::its::ExternalAllocator* allocator)
 {
+  /// Internal thrust allocation serialize this part to a degree
+  /// TODO switch to cub equivelent and do all work on one stream
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync.on(stream.get());
   thrust::device_ptr<gpuPair<int, int>> neighVectorPairs(cellNeighbourPairs);
   thrust::device_ptr<int> validNeighs(cellNeighbours);
-  auto updatedEnd = thrust::remove_if(neighVectorPairs, neighVectorPairs + nNeigh, gpu::is_invalid_pair<int, int>());
+  auto updatedEnd = thrust::remove_if(nosync_policy, neighVectorPairs, neighVectorPairs + nNeigh, gpu::is_invalid_pair<int, int>());
   size_t newSize = updatedEnd - neighVectorPairs;
-  thrust::stable_sort(neighVectorPairs, neighVectorPairs + newSize, gpu::sort_by_second<int, int>());
-  thrust::transform(neighVectorPairs, neighVectorPairs + newSize, validNeighs, gpu::pair_to_first<int, int>());
+  thrust::stable_sort(nosync_policy, neighVectorPairs, neighVectorPairs + newSize, gpu::sort_by_second<int, int>());
+  thrust::transform(nosync_policy, neighVectorPairs, neighVectorPairs + newSize, validNeighs, gpu::pair_to_first<int, int>());
 
   return newSize;
 }

From 0825b22c6eb8a853eaa4094cc179e22e663a161b Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 7 Aug 2025 08:00:13 +0200
Subject: [PATCH 0683/1764] ITS: GPU: use external allocator for temp storage

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  6 +-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  6 +-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 67 ++++++++++++-------
 3 files changed, 54 insertions(+), 25 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index caa7675756db6..a7bf4c70bc5c2 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -86,6 +86,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  bounded_vector<float>& resolutions,
                                  std::vector<float>& radii,
                                  bounded_vector<float>& mulScatAng,
+                                 o2::its::ExternalAllocator* alloc,
                                  const int nBlocks,
                                  const int nThreads,
                                  gpu::Streams& streams);
@@ -120,6 +121,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    bounded_vector<float>& resolutions,
                                    std::vector<float>& radii,
                                    bounded_vector<float>& mulScatAng,
+                                   o2::its::ExternalAllocator* alloc,
                                    const int nBlocks,
                                    const int nThreads,
                                    gpu::Streams& streams);
@@ -139,6 +141,7 @@ void countCellsHandler(const Cluster** sortedClusters,
                        const float maxChi2ClusterAttachment,
                        const float cellDeltaTanLambdaSigma,
                        const float nSigmaCut,
+                       o2::its::ExternalAllocator* alloc,
                        const int nBlocks,
                        const int nThreads,
                        gpu::Streams& streams);
@@ -175,6 +178,7 @@ void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                 const unsigned int nCells,
                                 const unsigned int nCellsNext,
                                 const int maxCellNeighbours,
+                                o2::its::ExternalAllocator* alloc,
                                 const int nBlocks,
                                 const int nThreads,
                                 gpu::Stream& stream);
@@ -213,12 +217,12 @@ void processNeighboursHandler(const int startLayer,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
                               bounded_vector<CellSeed>& seedsHost,
-                              o2::its::ExternalAllocator*,
                               const float bz,
                               const float MaxChi2ClusterAttachment,
                               const float maxChi2NDF,
                               const o2::base::Propagator* propagator,
                               const o2::base::PropagatorF::MatCorrType matCorrType,
+                              o2::its::ExternalAllocator* alloc,
                               const int nBlocks,
                               const int nThreads);
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 0fa258f63fd23..e7135e55a16c8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -80,6 +80,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                        mTimeFrameGPU->getPositionResolutions(),
                                        this->mTrkParams[iteration].LayerRadii,
                                        mTimeFrameGPU->getMSangles(),
+                                       mTimeFrameGPU->getExternalAllocator(),
                                        conf.nBlocksLayerTracklets[iteration],
                                        conf.nThreadsLayerTracklets[iteration],
                                        mTimeFrameGPU->getStreams());
@@ -113,6 +114,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getPositionResolutions(),
                                          this->mTrkParams[iteration].LayerRadii,
                                          mTimeFrameGPU->getMSangles(),
+                                         mTimeFrameGPU->getExternalAllocator(),
                                          conf.nBlocksLayerTracklets[iteration],
                                          conf.nThreadsLayerTracklets[iteration],
                                          mTimeFrameGPU->getStreams());
@@ -157,6 +159,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                       this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                       this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                       this->mTrkParams[iteration].NSigmaCut,
+                      mTimeFrameGPU->getExternalAllocator(),
                       conf.nBlocksLayerCells[iteration],
                       conf.nThreadsLayerCells[iteration],
                       mTimeFrameGPU->getStreams());
@@ -222,6 +225,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                currentLayerCellsNum,
                                nextLayerCellsNum,
                                1e2,
+                               mTimeFrameGPU->getExternalAllocator(),
                                conf.nBlocksFindNeighbours[iteration],
                                conf.nThreadsFindNeighbours[iteration],
                                mTimeFrameGPU->getStream(iLayer));
@@ -272,12 +276,12 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         mTimeFrameGPU->getDeviceNeighboursLUTs(),
                                         mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                                         trackSeeds,
-                                        mTimeFrameGPU->getExternalAllocator(),
                                         this->mBz,
                                         this->mTrkParams[0].MaxChi2ClusterAttachment,
                                         this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
                                         this->mTrkParams[0].CorrType,
+                                        mTimeFrameGPU->getExternalAllocator(),
                                         conf.nBlocksProcessNeighbours[iteration],
                                         conf.nThreadsProcessNeighbours[iteration]);
     }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 060f150bd6f42..b8eeae12691a3 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -871,37 +871,53 @@ GPUg() void printCellSeeds(CellSeed* seed, int nCells, const unsigned int tId =
 }
 
 template <typename T>
-GPUhi() void cubExclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr)
+GPUhi() void cubExclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
 {
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
   GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
+  if (alloc) {
+    d_temp_storage = alloc->allocate(temp_storage_bytes);
+  } else {
+    GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
+  }
   GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
+  if (alloc) {
+    alloc->deallocate(reinterpret_cast<char*>(d_temp_storage), temp_storage_bytes);
+  } else {
+    GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
+  }
 }
 
 template <typename Vector>
-GPUhi() void cubExclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr)
+GPUhi() void cubExclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
 {
-  cubExclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream);
+  cubExclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream, alloc);
 }
 
 template <typename T>
-GPUhi() void cubInclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr)
+GPUhi() void cubInclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
 {
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
   GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
+  if (alloc) {
+    d_temp_storage = alloc->allocate(temp_storage_bytes);
+  } else {
+    GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
+  }
   GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
+  if (alloc) {
+    alloc->deallocate(reinterpret_cast<char*>(d_temp_storage), temp_storage_bytes);
+  } else {
+    GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
+  }
 }
 
 template <typename Vector>
-GPUhi() void cubInclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr)
+GPUhi() void cubInclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
 {
-  cubInclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream);
+  cubInclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream, alloc);
 }
 } // namespace gpu
 
@@ -932,6 +948,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  bounded_vector<float>& resolutions,
                                  std::vector<float>& radii,
                                  bounded_vector<float>& mulScatAng,
+                                 o2::its::ExternalAllocator* alloc,
                                  const int nBlocks,
                                  const int nThreads,
                                  gpu::Streams& streams)
@@ -964,7 +981,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
       resolutions[iLayer],
       radii[iLayer + 1] - radii[iLayer],
       mulScatAng[iLayer]);
-    gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get());
+    gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get(), alloc);
   }
 }
 
@@ -998,6 +1015,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    bounded_vector<float>& resolutions,
                                    std::vector<float>& radii,
                                    bounded_vector<float>& mulScatAng,
+                                   o2::its::ExternalAllocator* alloc,
                                    const int nBlocks,
                                    const int nThreads,
                                    gpu::Streams& streams)
@@ -1043,7 +1061,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
         spanTracklets[iLayer],
         trackletsLUTsHost[iLayer],
         nTracklets[iLayer]);
-      gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get());
+      gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get(), alloc);
     }
   }
 }
@@ -1064,6 +1082,7 @@ void countCellsHandler(
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut,
+  o2::its::ExternalAllocator* alloc,
   const int nBlocks,
   const int nThreads,
   gpu::Streams& streams)
@@ -1083,7 +1102,7 @@ void countCellsHandler(
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
     nSigmaCut);               // const float
-  gpu::cubExclusiveScanInPlace(cellsLUTsHost, nTracklets + 1, streams[layer].get());
+  gpu::cubExclusiveScanInPlace(cellsLUTsHost, nTracklets + 1, streams[layer].get(), alloc);
 }
 
 void computeCellsHandler(
@@ -1136,6 +1155,7 @@ void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                 const unsigned int nCells,
                                 const unsigned int nCellsNext,
                                 const int maxCellNeighbours,
+                                o2::its::ExternalAllocator* alloc,
                                 const int nBlocks,
                                 const int nThreads,
                                 gpu::Stream& stream)
@@ -1153,8 +1173,8 @@ void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
     layerIndex,
     nCells,
     maxCellNeighbours);
-  gpu::cubInclusiveScanInPlace(neighboursLUT, nCellsNext, stream.get());
-  gpu::cubExclusiveScanInPlace(neighboursIndexTable, nCells + 1, stream.get());
+  gpu::cubInclusiveScanInPlace(neighboursLUT, nCellsNext, stream.get(), alloc);
+  gpu::cubExclusiveScanInPlace(neighboursIndexTable, nCells + 1, stream.get(), alloc);
 }
 
 void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
@@ -1219,19 +1239,18 @@ void processNeighboursHandler(const int startLayer,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
                               bounded_vector<CellSeed>& seedsHost,
-                              o2::its::ExternalAllocator* allocator,
                               const float bz,
                               const float maxChi2ClusterAttachment,
                               const float maxChi2NDF,
                               const o2::base::Propagator* propagator,
                               const o2::base::PropagatorF::MatCorrType matCorrType,
+                              o2::its::ExternalAllocator* alloc,
                               const int nBlocks,
                               const int nThreads)
 {
-  auto allocInt = gpu::TypedAllocator<int>(allocator);
-  auto allocCellSeed = gpu::TypedAllocator<CellSeed>(allocator);
-  thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt); // Shortcut: device_vector skips central memory management, we are relying on the contingency.
-                                                                                                             // TODO: fix this.
+  auto allocInt = gpu::TypedAllocator<int>(alloc);
+  auto allocCellSeed = gpu::TypedAllocator<CellSeed>(alloc);
+  thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
 
   gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(
     startLayer,
@@ -1251,7 +1270,7 @@ void processNeighboursHandler(const int startLayer,
     maxChi2ClusterAttachment,
     propagator,
     matCorrType);
-  gpu::cubExclusiveScanInPlace(foundSeedsTable, nCells[startLayer] + 1);
+  gpu::cubExclusiveScanInPlace(foundSeedsTable, nCells[startLayer] + 1, gpu::Stream::DefaultStream, alloc);
 
   thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
   thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
@@ -1306,7 +1325,7 @@ void processNeighboursHandler(const int startLayer,
       maxChi2ClusterAttachment,
       propagator,
       matCorrType);
-    gpu::cubExclusiveScanInPlace(foundSeedsTable, foundSeedsTable.size());
+    gpu::cubExclusiveScanInPlace(foundSeedsTable, foundSeedsTable.size(), gpu::Stream::DefaultStream, alloc);
 
     auto foundSeeds{foundSeedsTable.back()};
     updatedCellId.resize(foundSeeds);
@@ -1402,6 +1421,7 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                              bounded_vector<float>& resolutions,
                                              std::vector<float>& radii,
                                              bounded_vector<float>& mulScatAng,
+                                             o2::its::ExternalAllocator* alloc,
                                              const int nBlocks,
                                              const int nThreads,
                                              gpu::Streams& streams);
@@ -1435,6 +1455,7 @@ template void computeTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                                bounded_vector<float>& resolutions,
                                                std::vector<float>& radii,
                                                bounded_vector<float>& mulScatAng,
+                                               o2::its::ExternalAllocator* alloc,
                                                const int nBlocks,
                                                const int nThreads,
                                                gpu::Streams& streams);
@@ -1449,12 +1470,12 @@ template void processNeighboursHandler<7>(const int startLayer,
                                           gsl::span<int*> neighboursDeviceLUTs,
                                           const TrackingFrameInfo** foundTrackingFrameInfo,
                                           bounded_vector<CellSeed>& seedsHost,
-                                          o2::its::ExternalAllocator*,
                                           const float bz,
                                           const float maxChi2ClusterAttachment,
                                           const float maxChi2NDF,
                                           const o2::base::Propagator* propagator,
                                           const o2::base::PropagatorF::MatCorrType matCorrType,
+                                          o2::its::ExternalAllocator* alloc,
                                           const int nBlocks,
                                           const int nThreads);
 } // namespace o2::its

From 7b7d8ff2291cb61976d5af9721057e8a53bcaf21 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 7 Aug 2025 08:06:04 +0200
Subject: [PATCH 0684/1764] ITS: GPU: simplify stream synchronization

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 26 ++++---------------
 1 file changed, 5 insertions(+), 21 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index e7135e55a16c8..bef271a1b0129 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -126,18 +126,10 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
   mTimeFrameGPU->createCellsLUTDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  std::vector<bool> isTrackletStreamSynched(this->mTrkParams[iteration].TrackletsPerRoad());
-  auto syncOnce = [&](const int iLayer) {
-    if (!isTrackletStreamSynched[iLayer]) {
-      mTimeFrameGPU->syncStream(iLayer);
-      isTrackletStreamSynched[iLayer] = true;
-    }
-  };
-
+  mTimeFrameGPU->syncStream(0);
   for (int iLayer = 0; iLayer < this->mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-    // need to ensure that trackleting on layers iLayer and iLayer + 1 are done (only once)
-    syncOnce(iLayer);
-    syncOnce(iLayer + 1);
+    mTimeFrameGPU->syncStream(iLayer + 1);
+
     // if there are no tracklets skip entirely
     const int currentLayerTrackletsNum{static_cast<int>(mTimeFrameGPU->getNTracklets()[iLayer])};
     if (!currentLayerTrackletsNum || !mTimeFrameGPU->getNTracklets()[iLayer + 1]) {
@@ -191,18 +183,10 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
   mTimeFrameGPU->createNeighboursIndexTablesDevice();
   const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  std::vector<bool> isCellStreamSynched(this->mTrkParams[iteration].TrackletsPerRoad() - 1);
-  auto syncOnce = [&](const int iLayer) {
-    if (!isCellStreamSynched[iLayer]) {
-      mTimeFrameGPU->syncStream(iLayer);
-      isCellStreamSynched[iLayer] = true;
-    }
-  };
-
+  mTimeFrameGPU->syncStream(0);
   for (int iLayer{0}; iLayer < this->mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
     // ensure that celling is done for iLayer and iLayer+1 is done
-    syncOnce(iLayer);
-    syncOnce(iLayer + 1);
+    mTimeFrameGPU->syncStream(iLayer + 1);
 
     const int currentLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer])};
     const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};

From 80c4d143ee8d8a54aa0fdb8761a38a77814f3159 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 8 Aug 2025 12:55:50 +0200
Subject: [PATCH 0685/1764] ITS: GPU: resolve added TODOs

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   |   6 +-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 119 ++++++++++++------
 2 files changed, 84 insertions(+), 41 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index 9d25bd22484fe..cd860c47ebd9c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -95,13 +95,11 @@ class Stream
 #if defined(__HIPCC__)
   using Handle = hipStream_t;
   static constexpr Handle DefaultStream = 0;
-  // static constexpr unsigned int DefaultFlag = hipStreamNonBlocking; TODO replace once ready
-  static constexpr unsigned int DefaultFlag = 0;
+  static constexpr unsigned int DefaultFlag = hipStreamNonBlocking;
 #elif defined(__CUDACC__)
   using Handle = cudaStream_t;
   static constexpr Handle DefaultStream = 0;
-  // static constexpr unsigned int DefaultFlag = cudaStreamNonBlocking; TODO replace once ready
-  static constexpr unsigned int DefaultFlag = 0;
+  static constexpr unsigned int DefaultFlag = cudaStreamNonBlocking;
 #else
   using Handle = void*;
   static constexpr Handle DefaultStream = nullptr;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index b8eeae12691a3..401d98ad63560 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -145,9 +145,7 @@ GPUd() bool fitTrack(TrackITSExt& track,
 
     if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
       const float xx0 = (iLayer > 2) ? 1.e-2f : 5.e-3f; // Rough layer thickness
-      constexpr float radiationLength = 9.36f;          // Radiation length of Si [cm]
-      constexpr float density = 2.33f;                  // Density of Si [g/cm^3]
-      if (!track.correctForMaterial(xx0, xx0 * radiationLength * density, true)) {
+      if (!track.correctForMaterial(xx0, xx0 * constants::Radl * constants::Rho, true)) {
         return false;
       }
     }
@@ -728,13 +726,13 @@ GPUg() void processNeighboursKernel(const int layer,
       if (!seed.o2::track::TrackParCov::update(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)) {
         continue;
       }
-      seed.getClusters()[layer - 1] = neighbourCell.getFirstClusterIndex();
-      seed.setLevel(neighbourCell.getLevel());
-      seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
-      seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
       if constexpr (dryRun) {
         foundSeedsTable[iCurrentCell]++;
       } else {
+        seed.getClusters()[layer - 1] = neighbourCell.getFirstClusterIndex();
+        seed.setLevel(neighbourCell.getLevel());
+        seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
+        seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
         updatedCellsIds[foundSeedsTable[iCurrentCell] + foundSeeds] = neighbourCellId;
         updatedCellSeeds[foundSeedsTable[iCurrentCell] + foundSeeds] = seed;
       }
@@ -870,25 +868,35 @@ GPUg() void printCellSeeds(CellSeed* seed, int nCells, const unsigned int tId =
   }
 }
 
-template <typename T>
-GPUhi() void cubExclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
+GPUhi() void allocateMemory(void** p, size_t bytes, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
 {
-  void* d_temp_storage = nullptr;
-  size_t temp_storage_bytes = 0;
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
   if (alloc) {
-    d_temp_storage = alloc->allocate(temp_storage_bytes);
+    *p = alloc->allocate(bytes);
   } else {
-    GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
+    GPUChkErrS(cudaMallocAsync(p, bytes, stream));
   }
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
+}
+
+GPUhi() void deallocateMemory(void* p, size_t bytes, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
+{
   if (alloc) {
-    alloc->deallocate(reinterpret_cast<char*>(d_temp_storage), temp_storage_bytes);
+    alloc->deallocate(reinterpret_cast<char*>(p), bytes);
   } else {
-    GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
+    GPUChkErrS(cudaFreeAsync(p, stream));
   }
 }
 
+template <typename T>
+GPUhi() void cubExclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
+{
+  void* d_temp_storage = nullptr;
+  size_t temp_storage_bytes = 0;
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
+  allocateMemory(&d_temp_storage, temp_storage_bytes, stream, alloc);
+  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
+  deallocateMemory(d_temp_storage, temp_storage_bytes, stream, alloc);
+}
+
 template <typename Vector>
 GPUhi() void cubExclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
 {
@@ -901,21 +909,13 @@ GPUhi() void cubInclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stre
   void* d_temp_storage = nullptr;
   size_t temp_storage_bytes = 0;
   GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  if (alloc) {
-    d_temp_storage = alloc->allocate(temp_storage_bytes);
-  } else {
-    GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
-  }
+  allocateMemory(&d_temp_storage, temp_storage_bytes, stream, alloc);
   GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  if (alloc) {
-    alloc->deallocate(reinterpret_cast<char*>(d_temp_storage), temp_storage_bytes);
-  } else {
-    GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
-  }
+  deallocateMemory(d_temp_storage, temp_storage_bytes, stream, alloc);
 }
 
 template <typename Vector>
-GPUhi() void cubInclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
+GPUhi() void cubInclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr, o2::its::ExternalAllocator* alloc = nullptr)
 {
   cubInclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream, alloc);
 }
@@ -1048,13 +1048,30 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
       resolutions[iLayer],
       radii[iLayer + 1] - radii[iLayer],
       mulScatAng[iLayer]);
-    /// Internal thrust allocation serialize this part to a degree
-    /// TODO switch to cub equivelent and do all work on one stream
-    thrust::device_ptr<Tracklet> tracklets_ptr(spanTracklets[iLayer]);
-    auto nosync_policy = THRUST_NAMESPACE::par_nosync.on(streams[iLayer].get());
-    thrust::sort(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::sort_tracklets());
-    auto unique_end = thrust::unique(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[iLayer], gpu::equal_tracklets());
-    nTracklets[iLayer] = unique_end - tracklets_ptr;
+    if (nTracklets[iLayer]) {
+      Tracklet *tracklets_in = spanTracklets[iLayer], *tracklets_out{nullptr};
+      size_t n = nTracklets[iLayer];
+      size_t sort_temp_bytes = 0;
+      GPUChkErrS(cub::DeviceMergeSort::SortKeys(nullptr, sort_temp_bytes, tracklets_in, n, gpu::sort_tracklets{}, streams[iLayer].get()));
+      void* sort_temp_storage = nullptr;
+      gpu::allocateMemory(&sort_temp_storage, sort_temp_bytes, streams[iLayer].get(), alloc);
+      GPUChkErrS(cub::DeviceMergeSort::SortKeys(sort_temp_storage, sort_temp_bytes, tracklets_in, n, gpu::sort_tracklets{}, streams[iLayer].get()));
+      gpu::allocateMemory(reinterpret_cast<void**>(&tracklets_out), n * sizeof(Tracklet), streams[iLayer].get(), alloc);
+      size_t unique_temp_bytes = 0;
+      int* num_selected = nullptr;
+      gpu::allocateMemory(reinterpret_cast<void**>(&num_selected), sizeof(int), streams[iLayer].get(), alloc);
+      GPUChkErrS(cub::DeviceSelect::Unique(nullptr, unique_temp_bytes, tracklets_in, tracklets_out, num_selected, n, streams[iLayer].get()));
+      void* unique_temp_storage = nullptr;
+      gpu::allocateMemory(&unique_temp_storage, unique_temp_bytes, streams[iLayer].get(), alloc);
+      GPUChkErrS(cub::DeviceSelect::Unique(unique_temp_storage, unique_temp_bytes, tracklets_in, tracklets_out, num_selected, n, streams[iLayer].get()));
+      GPUChkErrS(cudaMemcpyAsync(tracklets_in, tracklets_out, n * sizeof(Tracklet), cudaMemcpyDeviceToDevice, streams[iLayer].get()));
+      GPUChkErrS(cudaMemcpyAsync(&nTracklets[iLayer], num_selected, sizeof(int), cudaMemcpyDeviceToHost, streams[iLayer].get()));
+      streams[iLayer].sync();
+      gpu::deallocateMemory(tracklets_out, n * sizeof(Tracklet), streams[iLayer].get(), alloc);
+      gpu::deallocateMemory(sort_temp_storage, sort_temp_bytes, streams[iLayer].get(), alloc);
+      gpu::deallocateMemory(unique_temp_storage, unique_temp_bytes, streams[iLayer].get(), alloc);
+      gpu::deallocateMemory(num_selected, sizeof(int), streams[iLayer].get(), alloc);
+    }
     if (iLayer > 0) {
       GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[iLayer], 0, nClusters[iLayer] * sizeof(int), streams[iLayer].get()));
       gpu::compileTrackletsLookupTableKernel<<<nBlocks, nThreads, 0, streams[iLayer].get()>>>(
@@ -1215,8 +1232,35 @@ int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
                                 gpu::Stream& stream,
                                 o2::its::ExternalAllocator* allocator)
 {
-  /// Internal thrust allocation serialize this part to a degree
-  /// TODO switch to cub equivelent and do all work on one stream
+#ifndef __HIPCC__
+  int* d_num_selected = nullptr;
+  gpu::allocateMemory(reinterpret_cast<void**>(&d_num_selected), sizeof(int), stream.get(), allocator);
+  size_t select_bytes = 0;
+  GPUChkErrS(cub::DeviceSelect::If(nullptr, select_bytes, cellNeighbourPairs, static_cast<gpuPair<int, int>*>(nullptr), d_num_selected, nNeigh, gpu::is_valid_pair<int, int>(), stream.get()));
+  void* select_temp = nullptr;
+  gpu::allocateMemory(&select_temp, select_bytes, stream.get(), allocator);
+  gpuPair<int, int>* d_temp_valid = nullptr;
+  gpu::allocateMemory(reinterpret_cast<void**>(&d_temp_valid), nNeigh * sizeof(gpuPair<int, int>), stream.get(), allocator);
+  GPUChkErrS(cub::DeviceSelect::If(select_temp, select_bytes, cellNeighbourPairs, d_temp_valid, d_num_selected, nNeigh, gpu::is_valid_pair<int, int>(), stream.get()));
+  int newSize = 0;
+  GPUChkErrS(cudaMemcpyAsync(&newSize, d_num_selected, sizeof(int), cudaMemcpyDeviceToHost, stream.get()));
+  stream.sync(); // needed to get newSize
+  size_t sort_bytes = 0;
+  GPUChkErrS(cub::DeviceMergeSort::SortPairs(nullptr, sort_bytes, d_temp_valid, d_temp_valid, newSize, gpu::sort_by_second<int, int>(), stream.get()));
+  void* sort_temp = nullptr;
+  gpu::allocateMemory(&sort_temp, sort_bytes, stream.get(), allocator);
+  GPUChkErrS(cub::DeviceMergeSort::SortPairs(sort_temp, sort_bytes, d_temp_valid, d_temp_valid, newSize, gpu::sort_by_second<int, int>(), stream.get()));
+  size_t transform_bytes = 0;
+  GPUChkErrS(cub::DeviceTransform::Transform(nullptr, transform_bytes, d_temp_valid, cellNeighbours, newSize, gpu::pair_to_first<int, int>(), stream.get()));
+  void* transform_temp = nullptr;
+  gpu::allocateMemory(&transform_temp, transform_bytes, stream.get(), allocator);
+  GPUChkErrS(cub::DeviceTransform::Transform(transform_temp, transform_bytes, d_temp_valid, cellNeighbours, newSize, gpu::pair_to_first<int, int>(), stream.get()));
+  gpu::deallocateMemory(transform_temp, transform_bytes, stream.get(), allocator);
+  gpu::deallocateMemory(d_temp_valid, newSize * sizeof(gpuPair<int, int>), stream.get(), allocator);
+  gpu::deallocateMemory(sort_temp, sort_bytes, stream.get(), allocator);
+  gpu::deallocateMemory(d_num_selected, sizeof(int), stream.get(), allocator);
+  gpu::deallocateMemory(select_temp, select_bytes, stream.get(), allocator);
+#else // FIXME using thrust here since hipcub does not yet have DeviceTransform
   auto nosync_policy = THRUST_NAMESPACE::par_nosync.on(stream.get());
   thrust::device_ptr<gpuPair<int, int>> neighVectorPairs(cellNeighbourPairs);
   thrust::device_ptr<int> validNeighs(cellNeighbours);
@@ -1224,6 +1268,7 @@ int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
   size_t newSize = updatedEnd - neighVectorPairs;
   thrust::stable_sort(nosync_policy, neighVectorPairs, neighVectorPairs + newSize, gpu::sort_by_second<int, int>());
   thrust::transform(nosync_policy, neighVectorPairs, neighVectorPairs + newSize, validNeighs, gpu::pair_to_first<int, int>());
+#endif
 
   return newSize;
 }

From a4e3e1587993a315555227587d21a4b979d77177 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 10 Aug 2025 22:08:23 +0200
Subject: [PATCH 0686/1764] Fix TimingInfo.timeslice vs DPH.startTime mismatch

---
 Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx | 33 ++++++++++---------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
index f4cd64377034e..2b8090af42648 100644
--- a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
+++ b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
@@ -87,7 +87,8 @@ class TFReaderSpec : public o2f::Task
   std::map<int, std::vector<std::pair<long, long>>> mRunTimeRanges;
   o2::utils::IRFrameSelector mIRFrameSelector; // optional IR frames selector
   int mConvRunTimeRangesToOrbits = -1;         // not defined yet
-  int mTFCounter = 0;
+  int mSentTFCounter = 0;
+  int mAccTFCounter = 0;
   int mTFBuilderCounter = 0;
   int mNWaits = 0;
   int mTFLength = 32;
@@ -159,15 +160,15 @@ void TFReaderSpec::run(o2f::ProcessingContext& ctx)
       }
       if (hd->splitPayloadIndex == 0) { // check the 1st one only
         auto& entry = this->mSeenOutputMap[{hd->dataDescription.str, hd->dataOrigin.str}];
-        if (entry.count != this->mTFCounter) {
+        if (entry.count != this->mSentTFCounter) {
           if (verbose && hdPrev) { // report previous partition size
             LOGP(info, "Block:{} {}/{} with size {}", nblocks, hdPrev->dataOrigin.as<std::string>(), hdPrev->dataDescription.as<std::string>(), dsize);
           }
           dsizeTot += dsize;
           dsize = 0;
-          entry.count = this->mTFCounter; // acknowledge identifier seen in the data
+          entry.count = this->mSentTFCounter; // acknowledge identifier seen in the data
           LOG(debug) << "Found a part " << ip << " of " << np << " | " << hd->dataOrigin.as<std::string>() << "/" << hd->dataDescription.as<std::string>()
-                     << "/" << hd->subSpecification << " part " << hd->splitPayloadIndex << " of " << hd->splitPayloadParts << " for TF " << this->mTFCounter;
+                     << "/" << hd->subSpecification << " part " << hd->splitPayloadIndex << " of " << hd->splitPayloadParts << " for TF " << this->mSentTFCounter;
           nblocks++;
         }
       }
@@ -219,11 +220,11 @@ void TFReaderSpec::run(o2f::ProcessingContext& ctx)
     const auto* hd0 = o2h::get<o2h::DataHeader*>(dataptr);
     const auto* dph = o2h::get<o2f::DataProcessingHeader*>(dataptr);
     for (auto& out : this->mSeenOutputMap) {
-      if (out.second.count == this->mTFCounter) { // was seen in the data
+      if (out.second.count == this->mSentTFCounter) { // was seen in the data
         continue;
       }
       LOG(debug) << "Adding dummy output for " << out.first.dataOrigin.as<std::string>() << "/" << out.first.dataDescription.as<std::string>()
-                 << "/" << out.second.defSubSpec << " for TF " << this->mTFCounter;
+                 << "/" << out.second.defSubSpec << " for TF " << this->mSentTFCounter;
       o2h::DataHeader outHeader(out.first.dataDescription, out.first.dataOrigin, out.second.defSubSpec, 0);
       outHeader.payloadSerializationMethod = o2h::gSerializationMethodNone;
       outHeader.firstTForbit = hd0->firstTForbit;
@@ -270,7 +271,7 @@ void TFReaderSpec::run(o2f::ProcessingContext& ctx)
 
       auto tNow = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
       auto tDiff = tNow - tLastTF;
-      if (mTFCounter && tDiff < mInput.delay_us) {
+      if (mSentTFCounter && tDiff < mInput.delay_us) {
         std::this_thread::sleep_for(std::chrono::microseconds((size_t)(mInput.delay_us - tDiff))); // respect requested delay before sending
       }
       for (auto& msgIt : *tfPtr.get()) {
@@ -285,9 +286,9 @@ void TFReaderSpec::run(o2f::ProcessingContext& ctx)
       //        however this is a small enough hack for now.
       ctx.services().get<o2f::MessageContext>().fakeDispatch();
       tNow = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
-      LOGP(info, "Sent TF {} of size {} with {} parts, {:.4f} s elapsed from previous TF., WaitSending={}", mTFCounter, dataSize, nparts, mTFCounter ? double(tNow - tLastTF) * 1e-6 : 0., mWaitSendingLast);
+      LOGP(info, "Sent TF {} of size {} with {} parts, {:.4f} s elapsed from previous TF., WaitSending={}", mSentTFCounter, dataSize, nparts, mSentTFCounter ? double(tNow - tLastTF) * 1e-6 : 0., mWaitSendingLast);
       tLastTF = tNow;
-      ++mTFCounter;
+      ++mSentTFCounter;
 
       while (mTFQueue.size() == 0 && mWaitSendingLast) {
         usleep(10000);
@@ -300,7 +301,7 @@ void TFReaderSpec::run(o2f::ProcessingContext& ctx)
     }
     //    usleep(5000); // wait 5ms for new TF to be built
   }
-  if (mTFCounter >= mInput.maxTFs || (!mTFQueue.size() && !mRunning)) { // done
+  if (mSentTFCounter >= mInput.maxTFs || (!mTFQueue.size() && !mRunning)) { // done
     stopProcessing(ctx);
   }
 }
@@ -325,7 +326,7 @@ void TFReaderSpec::stopProcessing(o2f::ProcessingContext& ctx)
     return;
   }
   stopDone = true;
-  LOGP(info, "{} TFs in {}  loops were sent, spent {:.2} s in {} data waiting states", mTFCounter, mFileFetcher->getNLoops(), 1e-6 * mTotalWaitTime, mNWaits);
+  LOGP(info, "{} TFs in {}  loops were sent, spent {:.2} s in {} data waiting states", mSentTFCounter, mFileFetcher->getNLoops(), 1e-6 * mTotalWaitTime, mNWaits);
   mRunning = false;
   if (mFileFetcher) {
     mFileFetcher->stop();
@@ -420,7 +421,7 @@ void TFReaderSpec::TFBuilder()
           std::this_thread::sleep_for(sleepTime);
           continue;
         }
-        auto tf = reader.read(mDevice, mOutputRoutes, mInput.rawChannelConfig, mSelIDEntry, mInput.sup0xccdb, mInput.verbosity);
+        auto tf = reader.read(mDevice, mOutputRoutes, mInput.rawChannelConfig, mAccTFCounter, mInput.sup0xccdb, mInput.verbosity);
         bool acceptTF = true;
         if (tf) {
           if (mRunTimeRanges.size()) {
@@ -443,21 +444,23 @@ void TFReaderSpec::TFBuilder()
           locID++;
           if (!mInput.tfIDs.empty() && acceptTF) {
             acceptTF = false;
+            while ((mInput.tfIDs[mSelIDEntry] < mTFBuilderCounter) && (mSelIDEntry + 1) < mInput.tfIDs.size()) {
+              mSelIDEntry++;
+            }
+            LOGP(info, "chec if mInput.tfIDs[{}]({}) == {}", mSelIDEntry, mInput.tfIDs[mSelIDEntry], mTFBuilderCounter);
             if (mInput.tfIDs[mSelIDEntry] == mTFBuilderCounter) {
               mWaitSendingLast = false;
               acceptTF = true;
               LOGP(info, "Retrieved TF#{} will be pushed as slice {} following user request", mTFBuilderCounter, mSelIDEntry);
-              mSelIDEntry++;
             } else {
               LOGP(info, "Retrieved TF#{} will be discared following user request", mTFBuilderCounter);
             }
-          } else {
-            mSelIDEntry++;
           }
           mTFBuilderCounter++;
         }
         if (mRunning && tf) {
           if (acceptTF) {
+            mAccTFCounter++;
             mWaitSendingLast = true;
             mTFQueue.push(std::move(tf));
           }

From 24f1796bc7d175e523c048a0c1b26b045ec48fae Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 10 Aug 2025 15:38:21 +0200
Subject: [PATCH 0687/1764] DPL: improve error message

---
 Framework/Core/src/WorkflowHelpers.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 652e863f98394..b86a4f15e7306 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -974,7 +974,8 @@ WorkflowParsingState WorkflowHelpers::verifyWorkflow(const o2::framework::Workfl
       if (DataSpecUtils::validate(input) == false) {
         ss << "In spec " << spec.name << " input specification "
            << ii << " requires binding, description and origin"
-                    " to be fully specified";
+                    " to be fully specified (found "
+           << input.binding << ":" << DataSpecUtils::describe(input) << ")";
         throw std::runtime_error(ss.str());
       }
     }

From 919285695e84e3b247087b9f45c0a7da1080527c Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Sun, 8 Sep 2024 19:30:51 +0000
Subject: [PATCH 0688/1764] use generic get() in row_helpers

---
 Framework/Core/include/Framework/ASoA.h       |  2 +-
 .../Core/include/Framework/ASoAHelpers.h      | 66 ++-----------------
 .../Core/include/Framework/BinningPolicy.h    | 28 ++++----
 3 files changed, 19 insertions(+), 77 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 8af9878703d18..11485403e967b 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2194,7 +2194,7 @@ typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = s
   if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
     rowIterator.setCursor(globalIndex);
   }
-  return rowIterator.template getDynamicColumn<C>();
+  return static_cast<C>(rowIterator).get();
 }
 
 template <typename T, soa::is_index_column C>
diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index 5bf474e61f935..2f2d1f06fce1a 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -76,77 +76,19 @@ void dataSizeVariesBetweenColumns();
 template <template <typename... Cs> typename BP, typename T, typename... Cs>
 std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPolicy, int minCatSize, int outsider)
 {
-  arrow::Table* arrowTable = table.asArrowTable().get();
-  auto rowIterator = table.begin();
-
-  uint64_t ind = 0;
-  uint64_t selInd = 0;
-  gsl::span<int64_t const> selectedRows;
   std::vector<BinningIndex> groupedIndices;
 
-  // Separate check to account for Filtered size different from arrow table
+  // TODO: Check if this check can be now skipped
   if (table.size() == 0) {
     return groupedIndices;
   }
 
-  if constexpr (soa::is_filtered_table<T>) {
-    selectedRows = table.getSelectedRows(); // vector<int64_t>
-  }
-
-  auto persistentColumns = typename BP<Cs...>::persistent_columns_t{};
-  constexpr auto persistentColumnsCount = pack_size(persistentColumns);
-  auto arrowColumns = o2::soa::row_helpers::getArrowColumns(arrowTable, persistentColumns);
-  auto chunksCount = arrowColumns[0]->num_chunks();
-  for (int i = 1; i < persistentColumnsCount; i++) {
-    if (arrowColumns[i]->num_chunks() != chunksCount) {
-      dataSizeVariesBetweenColumns();
-    }
-  }
-
-  for (uint64_t ci = 0; ci < chunksCount; ++ci) {
-    auto chunks = o2::soa::row_helpers::getChunks(arrowTable, persistentColumns, ci);
-    auto chunkLength = std::get<0>(chunks)->length();
-    for_<persistentColumnsCount - 1>([&chunks, &chunkLength](auto i) {
-      if (std::get<i.value + 1>(chunks)->length() != chunkLength) {
-        dataSizeVariesBetweenColumns();
-      }
-    });
-
-    if constexpr (soa::is_filtered_table<T>) {
-      if (selectedRows[ind] >= selInd + chunkLength) {
-        selInd += chunkLength;
-        continue; // Go to the next chunk, no value selected in this chunk
-      }
-    }
-
-    uint64_t ai = 0;
-    while (ai < chunkLength) {
-      if constexpr (soa::is_filtered_table<T>) {
-        ai += selectedRows[ind] - selInd;
-        selInd = selectedRows[ind];
-      }
-
-      auto values = binningPolicy.getBinningValues(rowIterator, arrowTable, ci, ai, ind);
+  for(auto rowIterator : table) {
+      auto values = binningPolicy.getBinningValues(rowIterator);
       auto val = binningPolicy.getBin(values);
       if (val != outsider) {
-        groupedIndices.emplace_back(val, ind);
-      }
-      ind++;
-
-      if constexpr (soa::is_filtered_table<T>) {
-        if (ind >= selectedRows.size()) {
-          break;
-        }
-      } else {
-        ai++;
+        groupedIndices.emplace_back(val, *std::get<1>(rowIterator.getIndices()));
       }
-    }
-
-    if constexpr (soa::is_filtered_table<T>) {
-      if (ind == selectedRows.size()) {
-        break;
-      }
-    }
   }
 
   // Do a stable sort so that same categories entries are
diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index 73548cbd6c6ed..9afd43a6490d7 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -241,7 +241,7 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
   }
 
   template <typename T, typename T2>
-  auto getBinningValue(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValue(T& rowIterator, uint64_t globalIndex = -1) const
   {
     if constexpr (has_type<T2>(pack<Ls...>{})) {
       if (globalIndex != -1) {
@@ -249,20 +249,20 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
       }
       return std::get<T2>(mBinningFunctions)(rowIterator);
     } else {
-      return soa::row_helpers::getSingleRowData<T, T2>(table, rowIterator, ci, ai, globalIndex);
+      return soa::row_helpers::getSingleRowData<T, T2>(rowIterator, globalIndex);
     }
   }
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(getBinningValue<T, Ts>(rowIterator, table, ci, ai, globalIndex)...);
+    return std::make_tuple(getBinningValue<T, Ts>(rowIterator, globalIndex)...);
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
+    return getBinningValues(rowIterator, globalIndex);
   }
 
   template <typename... T2s>
@@ -284,15 +284,15 @@ struct ColumnBinningPolicy : BinningPolicyBase<sizeof...(Ts)> {
   }
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(soa::row_helpers::getSingleRowData<T, Ts>(table, rowIterator, ci, ai, globalIndex)...);
+    return std::make_tuple(soa::row_helpers::getSingleRowData<T, Ts>(rowIterator, globalIndex)...);
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
+    return getBinningValues(rowIterator, globalIndex);
   }
 
   int getBin(std::tuple<typename Ts::type...> const& data) const
@@ -309,15 +309,15 @@ struct NoBinningPolicy {
   NoBinningPolicy() = default;
 
   template <typename T>
-  auto getBinningValues(T& rowIterator, arrow::Table* table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(soa::row_helpers::getSingleRowData<T, C>(table, rowIterator, ci, ai, globalIndex));
+    return std::make_tuple(soa::row_helpers::getSingleRowData<T, C>(rowIterator, globalIndex));
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t ci = -1, uint64_t ai = -1, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, uint64_t globalIndex = -1) const
   {
-    return getBinningValues(rowIterator, table.asArrowTable().get(), ci, ai, globalIndex);
+    return getBinningValues(rowIterator, globalIndex);
   }
 
   int getBin(std::tuple<typename C::type> const& data) const

From cfbfb1374c8fd46eeb9951560aaea8e17ad19e16 Mon Sep 17 00:00:00 2001
From: mytkom <marek.mytkowski.mm@gmail.com>
Date: Mon, 9 Sep 2024 21:30:22 +0000
Subject: [PATCH 0689/1764] backward compatibility for binning policy

---
 Framework/Core/include/Framework/BinningPolicy.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index 9afd43a6490d7..58fc42ae63422 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -260,7 +260,7 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
   {
     return getBinningValues(rowIterator, globalIndex);
   }
@@ -315,7 +315,7 @@ struct NoBinningPolicy {
   }
 
   template <typename T>
-  auto getBinningValues(typename T::iterator rowIterator, uint64_t globalIndex = -1) const
+  auto getBinningValues(typename T::iterator rowIterator, T& table, uint64_t globalIndex = -1) const
   {
     return getBinningValues(rowIterator, globalIndex);
   }

From 73793c8083dad748f4125bbfdcd533daa20a9543 Mon Sep 17 00:00:00 2001
From: saganatt <8majak8@gmail.com>
Date: Thu, 9 Jan 2025 18:15:47 +0100
Subject: [PATCH 0690/1764] Fix after rebase

---
 Framework/Core/include/Framework/ASoA.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 11485403e967b..8af9878703d18 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2194,7 +2194,7 @@ typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = s
   if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
     rowIterator.setCursor(globalIndex);
   }
-  return static_cast<C>(rowIterator).get();
+  return rowIterator.template getDynamicColumn<C>();
 }
 
 template <typename T, soa::is_index_column C>

From aec2bdb7bab8e5aeaea9000d689e18422a93b8ec Mon Sep 17 00:00:00 2001
From: saganatt <8majak8@gmail.com>
Date: Mon, 13 Jan 2025 09:57:05 +0100
Subject: [PATCH 0691/1764] Further simplification and compilable code

---
 Framework/Core/include/Framework/ASoA.h       | 51 +------------------
 .../Core/include/Framework/BinningPolicy.h    | 18 ++++---
 2 files changed, 14 insertions(+), 55 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 8af9878703d18..6a49ed25e40d2 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2165,61 +2165,14 @@ void emptyColumnLabel();
 
 namespace row_helpers
 {
-template <soa::is_persistent_column... Cs>
-std::array<arrow::ChunkedArray*, sizeof...(Cs)> getArrowColumns(arrow::Table* table, framework::pack<Cs...>)
-{
-  return std::array<arrow::ChunkedArray*, sizeof...(Cs)>{o2::soa::getIndexFromLabel(table, Cs::columnLabel())...};
-}
-
-template <soa::is_persistent_column... Cs>
-std::array<std::shared_ptr<arrow::Array>, sizeof...(Cs)> getChunks(arrow::Table* table, framework::pack<Cs...>, uint64_t ci)
-{
-  return std::array<std::shared_ptr<arrow::Array>, sizeof...(Cs)>{o2::soa::getIndexFromLabel(table, Cs::columnLabel())->chunk(ci)...};
-}
-
-template <typename T, soa::is_persistent_column C>
-typename C::type getSingleRowData(arrow::Table* table, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
-{
-  if (ci == std::numeric_limits<uint64_t>::max() || ai == std::numeric_limits<uint64_t>::max()) {
-    auto colIterator = static_cast<C>(rowIterator).getIterator();
-    ci = colIterator.mCurrentChunk;
-    ai = *(colIterator.mCurrentPos) - colIterator.mFirstIndex;
-  }
-  return std::static_pointer_cast<o2::soa::arrow_array_for_t<typename C::type>>(o2::soa::getIndexFromLabel(table, C::columnLabel())->chunk(ci))->raw_values()[ai];
-}
-
-template <typename T, soa::is_dynamic_column C>
-typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
-{
-  if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
-    rowIterator.setCursor(globalIndex);
-  }
-  return rowIterator.template getDynamicColumn<C>();
-}
-
-template <typename T, soa::is_index_column C>
-typename C::type getSingleRowData(arrow::Table*, T& rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
-{
-  if (globalIndex != std::numeric_limits<uint64_t>::max() && globalIndex != *std::get<0>(rowIterator.getIndices())) {
-    rowIterator.setCursor(globalIndex);
-  }
-  return rowIterator.template getId<C>();
-}
-
-template <typename T, typename... Cs>
-std::tuple<typename Cs::type...> getRowData(arrow::Table* table, T rowIterator, uint64_t ci = std::numeric_limits<uint64_t>::max(), uint64_t ai = std::numeric_limits<uint64_t>::max(), uint64_t globalIndex = std::numeric_limits<uint64_t>::max())
-{
-  return std::make_tuple(getSingleRowData<T, Cs>(table, rowIterator, ci, ai, globalIndex)...);
-}
-
-namespace
-{
 template <typename R, typename T, typename C>
 R getColumnValue(const T& rowIterator)
 {
   return static_cast<R>(static_cast<C>(rowIterator).get());
 }
 
+namespace
+{
 template <typename R, typename T>
 using ColumnGetterFunction = R (*)(const T&);
 
diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index 58fc42ae63422..3e41302c920f8 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -243,13 +243,13 @@ struct FlexibleBinningPolicy<std::tuple<Ls...>, Ts...> : BinningPolicyBase<sizeo
   template <typename T, typename T2>
   auto getBinningValue(T& rowIterator, uint64_t globalIndex = -1) const
   {
+    if (globalIndex != -1) {
+      rowIterator.setCursor(globalIndex);
+    }
     if constexpr (has_type<T2>(pack<Ls...>{})) {
-      if (globalIndex != -1) {
-        rowIterator.setCursor(globalIndex);
-      }
       return std::get<T2>(mBinningFunctions)(rowIterator);
     } else {
-      return soa::row_helpers::getSingleRowData<T, T2>(rowIterator, globalIndex);
+      return soa::row_helpers::getColumnValue<typename T2::type, T, T2>(rowIterator);
     }
   }
 
@@ -286,7 +286,10 @@ struct ColumnBinningPolicy : BinningPolicyBase<sizeof...(Ts)> {
   template <typename T>
   auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(soa::row_helpers::getSingleRowData<T, Ts>(rowIterator, globalIndex)...);
+    if (globalIndex != -1) {
+      rowIterator.setCursor(globalIndex);
+    }
+    return std::make_tuple(soa::row_helpers::getColumnValue<typename Ts::type, T, Ts>(rowIterator)...);
   }
 
   template <typename T>
@@ -311,7 +314,10 @@ struct NoBinningPolicy {
   template <typename T>
   auto getBinningValues(T& rowIterator, uint64_t globalIndex = -1) const
   {
-    return std::make_tuple(soa::row_helpers::getSingleRowData<T, C>(rowIterator, globalIndex));
+    if (globalIndex != -1) {
+      rowIterator.setCursor(globalIndex);
+    }
+    return std::make_tuple(soa::row_helpers::getColumnValue<typename C::type, T, C>(rowIterator));
   }
 
   template <typename T>

From c1e321bfbf7b10208d6f1a82759c8d31f1ffdff2 Mon Sep 17 00:00:00 2001
From: saganatt <8majak8@gmail.com>
Date: Wed, 30 Apr 2025 15:08:45 +0200
Subject: [PATCH 0692/1764] Remove probably redundant check. To be checked

---
 Framework/Core/include/Framework/ASoAHelpers.h | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index 2f2d1f06fce1a..129224017e294 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -78,11 +78,6 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
 {
   std::vector<BinningIndex> groupedIndices;
 
-  // TODO: Check if this check can be now skipped
-  if (table.size() == 0) {
-    return groupedIndices;
-  }
-
   for(auto rowIterator : table) {
       auto values = binningPolicy.getBinningValues(rowIterator);
       auto val = binningPolicy.getBin(values);

From 5df80a763db2d3c1f1f5f260f82db5ccfdd572b3 Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Fri, 11 Jul 2025 11:41:07 +0000
Subject: [PATCH 0693/1764] Please consider the following formatting changes

---
 Framework/Core/include/Framework/ASoAHelpers.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoAHelpers.h b/Framework/Core/include/Framework/ASoAHelpers.h
index 129224017e294..0449bdfdc2a0c 100644
--- a/Framework/Core/include/Framework/ASoAHelpers.h
+++ b/Framework/Core/include/Framework/ASoAHelpers.h
@@ -78,12 +78,12 @@ std::vector<BinningIndex> groupTable(const T& table, const BP<Cs...>& binningPol
 {
   std::vector<BinningIndex> groupedIndices;
 
-  for(auto rowIterator : table) {
-      auto values = binningPolicy.getBinningValues(rowIterator);
-      auto val = binningPolicy.getBin(values);
-      if (val != outsider) {
-        groupedIndices.emplace_back(val, *std::get<1>(rowIterator.getIndices()));
-      }
+  for (auto rowIterator : table) {
+    auto values = binningPolicy.getBinningValues(rowIterator);
+    auto val = binningPolicy.getBin(values);
+    if (val != outsider) {
+      groupedIndices.emplace_back(val, *std::get<1>(rowIterator.getIndices()));
+    }
   }
 
   // Do a stable sort so that same categories entries are

From 3e0d913b6c189fc66fca22cec0a493ab00758cd6 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 11 Aug 2025 01:39:09 +0200
Subject: [PATCH 0694/1764] Optionally store CTP lumi scaler (norm to 1s) in
 CTP digitizer output

---
 .../TPCResidualAggregatorSpec.h               |  1 -
 .../src/CTPDigitizerSpec.cxx                  | 19 ++++++++++++++++---
 .../DigitizerWorkflow/src/CTPDigitizerSpec.h  |  2 +-
 .../src/SimpleDigitizerWorkflow.cxx           |  8 ++++++--
 4 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h
index 4f1705533c965..b9c99f9e65676 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h
@@ -145,7 +145,6 @@ class ResidualAggregatorDevice : public o2::framework::Task
     using lumiDataType = std::decay_t<decltype(pc.inputs().get<o2::ctp::LumiInfo>(""))>;
     std::optional<lumiDataType> lumiInput;
     if (mCTPInput) {
-      recoCont.getCTPLumi();
       lumiInput = recoCont.getCTPLumi();
       lumi = &lumiInput.value();
     }
diff --git a/Steer/DigitizerWorkflow/src/CTPDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/CTPDigitizerSpec.cxx
index 17a4fab61fd2e..3902692abd7f0 100644
--- a/Steer/DigitizerWorkflow/src/CTPDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/CTPDigitizerSpec.cxx
@@ -17,12 +17,14 @@
 #include "Framework//Task.h"
 #include "DetectorsBase/BaseDPLDigitizer.h"
 #include "DataFormatsCTP/Digits.h"
+#include "DataFormatsCTP/LumiInfo.h"
 #include "Steer/HitProcessingManager.h" // for DigitizationContext
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "CTPSimulation/Digitizer.h"
 #include "DataFormatsCTP/Configuration.h"
 #include "DataFormatsFT0/Digit.h"
 #include "DataFormatsFV0/Digit.h"
+#include "CommonConstants/LHCConstants.h"
 
 #include <TStopwatch.h>
 #include <gsl/span>
@@ -37,7 +39,7 @@ class CTPDPLDigitizerTask : public o2::base::BaseDPLDigitizer
   using GRP = o2::parameters::GRPObject;
 
  public:
-  CTPDPLDigitizerTask(const std::vector<o2::detectors::DetID>& detList) : o2::base::BaseDPLDigitizer(), mDigitizer(), mDetList(detList) {}
+  CTPDPLDigitizerTask(const std::vector<o2::detectors::DetID>& detList, float ctpLumiScaler) : o2::base::BaseDPLDigitizer(), mDigitizer(), mDetList(detList), mLumiScaler(ctpLumiScaler) {}
   ~CTPDPLDigitizerTask() override = default;
   void initDigitizerTask(framework::InitContext& ic) override
   {
@@ -85,6 +87,12 @@ class CTPDPLDigitizerTask : public o2::base::BaseDPLDigitizer
     pc.outputs().snapshot(Output{"CTP", "DIGITS", 0}, digits);
     LOG(info) << "CTP PRESENT being sent.";
     pc.outputs().snapshot(Output{"CTP", "ROMode", 0}, mROMode);
+    if (mLumiScaler >= 0.) {
+      uint32_t nhbf = mLumiScaler > 0.f ? uint32_t(int(mLumiScaler) / mLumiScaler * o2::constants::lhc::LHCRevFreq) : 0;
+      o2::ctp::LumiInfo lminfo{pc.services().get<o2::framework::TimingInfo>().firstTForbit, nhbf, 0, uint64_t(mLumiScaler), 0};
+      LOG(info) << "CTP Lumi scaler " << lminfo.counts << " for integration time of " << lminfo.nHBFCounted << " being sent";
+      pc.outputs().snapshot(Output{"CTP", "LUMI", 0}, lminfo);
+    }
     timer.Stop();
     LOG(info) << "CTP Digitization took " << timer.CpuTime() << "s";
   }
@@ -102,8 +110,10 @@ class CTPDPLDigitizerTask : public o2::base::BaseDPLDigitizer
   o2::parameters::GRPObject::ROMode mROMode = o2::parameters::GRPObject::PRESENT;
   o2::ctp::Digitizer mDigitizer; ///< Digitizer
   std::vector<o2::detectors::DetID> mDetList;
+  float mLumiScaler = -1.;
 };
-o2::framework::DataProcessorSpec getCTPDigitizerSpec(int channel, std::vector<o2::detectors::DetID>& detList, bool mctruth)
+
+o2::framework::DataProcessorSpec getCTPDigitizerSpec(int channel, std::vector<o2::detectors::DetID>& detList, float ctpLumiScaler, bool mctruth)
 {
   std::vector<InputSpec> inputs;
   std::vector<OutputSpec> output;
@@ -119,12 +129,15 @@ o2::framework::DataProcessorSpec getCTPDigitizerSpec(int channel, std::vector<o2
   }
   inputs.emplace_back("ctpconfig", "CTP", "CTPCONFIG", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/Config", true));
   output.emplace_back("CTP", "DIGITS", 0, Lifetime::Timeframe);
+  if (ctpLumiScaler >= 0.f) {
+    output.emplace_back("CTP", "LUMI", 0, Lifetime::Timeframe);
+  }
   output.emplace_back("CTP", "ROMode", 0, Lifetime::Timeframe);
   return DataProcessorSpec{
     "CTPDigitizer",
     inputs,
     output,
-    AlgorithmSpec{adaptFromTask<CTPDPLDigitizerTask>(detList)},
+    AlgorithmSpec{adaptFromTask<CTPDPLDigitizerTask>(detList, ctpLumiScaler)},
     Options{{"pileup", VariantType::Int, 1, {"whether to run in continuous time mode"}},
             {"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
 }
diff --git a/Steer/DigitizerWorkflow/src/CTPDigitizerSpec.h b/Steer/DigitizerWorkflow/src/CTPDigitizerSpec.h
index b5cd46f27ad64..64a058fe539b0 100644
--- a/Steer/DigitizerWorkflow/src/CTPDigitizerSpec.h
+++ b/Steer/DigitizerWorkflow/src/CTPDigitizerSpec.h
@@ -20,7 +20,7 @@ namespace o2
 namespace ctp
 {
 
-o2::framework::DataProcessorSpec getCTPDigitizerSpec(int channel, std::vector<o2::detectors::DetID>& detList, bool mctruth = true);
+o2::framework::DataProcessorSpec getCTPDigitizerSpec(int channel, std::vector<o2::detectors::DetID>& detList, float ctpLumiScaler = -1.f, bool mctruth = true);
 
 } // namespace ctp
 } // end namespace o2
diff --git a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
index b111d8f372967..e86ee47550f13 100644
--- a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
+++ b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
@@ -220,6 +220,9 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 
   // to enable distribution of triggers
   workflowOptions.push_back(ConfigParamSpec{"with-trigger", VariantType::Bool, false, {"enable distribution of CTP trigger digits"}});
+
+  // option to propagate CTP Lumi scaler counts (if >=0) into the CTP digits
+  workflowOptions.push_back(ConfigParamSpec{"store-ctp-lumi", VariantType::Float, -1.f, {"store CTP lumi scaler in CTP digits (if >= 0)"}});
 }
 
 void customize(std::vector<o2::framework::DispatchPolicy>& policies)
@@ -798,10 +801,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // the CTP part
   if (isEnabled(o2::detectors::DetID::CTP)) {
     detList.emplace_back(o2::detectors::DetID::CTP);
+    float lumiScaler = configcontext.options().get<float>("store-ctp-lumi");
     // connect the CTP digitization
-    specs.emplace_back(o2::ctp::getCTPDigitizerSpec(fanoutsize++, detList));
+    specs.emplace_back(o2::ctp::getCTPDigitizerSpec(fanoutsize++, detList, lumiScaler));
     // connect the CTP digit writer
-    specs.emplace_back(o2::ctp::getDigitWriterSpec(false));
+    specs.emplace_back(o2::ctp::getDigitWriterSpec(lumiScaler >= 0));
   }
   // GRP updater: must come after all detectors since requires their list
   if (!configcontext.options().get<bool>("only-context")) {

From 26acde4f6c846d75f6855c03f28e3fde0947a3b3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 12 Aug 2025 18:24:02 +0200
Subject: [PATCH 0695/1764] DPL: add C++20 ranges views to filter vectors of
 InputSpecs / OutputSpecs

---
 .../Core/include/Framework/DataSpecViews.h    | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 Framework/Core/include/Framework/DataSpecViews.h

diff --git a/Framework/Core/include/Framework/DataSpecViews.h b/Framework/Core/include/Framework/DataSpecViews.h
new file mode 100644
index 0000000000000..010d771b07941
--- /dev/null
+++ b/Framework/Core/include/Framework/DataSpecViews.h
@@ -0,0 +1,25 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef O2_FRAMEWORK_DATASPECVIEWS_H_
+#define O2_FRAMEWORK_DATASPECVIEWS_H_
+
+#include "Framework/DataSpecUtils.h"
+#include <ranges>
+
+namespace o2::framework::views
+{
+static auto partial_match_filter(auto what)
+{
+  return std::views::filter([&what](auto const& t) -> bool { return DataSpecUtils::partialMatch(t, what); });
+}
+} // namespace o2::framework::views
+
+#endif // O2_FRAMEWORK_DATASPECVIEWS_H_

From a4605d05188b4a57e5ebf4445ba68cedf66c4061 Mon Sep 17 00:00:00 2001
From: aferrero2707 <aferrero1975@gmail.com>
Date: Tue, 12 Aug 2025 18:13:02 +0200
Subject: [PATCH 0696/1764] [MCH] improvements to the pedestal calibrator

The pedestal processing code is modified to run in multi-threaded
mode, to improve the processing speed on the calibrator node

The periodic logging of pedestals statistics is also improved,
to better monitor and debug the pedestals data taking.
---
 .../MCHCalibration/BadChannelCalibrator.h     |   6 +-
 .../BadChannelCalibratorParam.h               |   2 +
 .../include/MCHCalibration/PedestalData.h     |   5 +-
 .../src/BadChannelCalibrationDevice.cxx       |  29 +++--
 .../Calibration/src/BadChannelCalibrator.cxx  |  39 +++++-
 .../MUON/MCH/Calibration/src/PedestalData.cxx | 121 ++++++++++++++----
 .../MCH/Calibration/test/testPedestalData.cxx |  21 +++
 7 files changed, 179 insertions(+), 44 deletions(-)

diff --git a/Detectors/MUON/MCH/Calibration/include/MCHCalibration/BadChannelCalibrator.h b/Detectors/MUON/MCH/Calibration/include/MCHCalibration/BadChannelCalibrator.h
index 509b9b88b30e4..6873d340841a2 100644
--- a/Detectors/MUON/MCH/Calibration/include/MCHCalibration/BadChannelCalibrator.h
+++ b/Detectors/MUON/MCH/Calibration/include/MCHCalibration/BadChannelCalibrator.h
@@ -68,13 +68,17 @@ class BadChannelCalibrator final : public o2::calibration::TimeSlotCalibration<o
   const BadChannelsVector& getBadChannelsVector() const { return mBadChannelsVector; }
   const PedestalsVector& getPedestalsVector() const { return mPedestalsVector; }
 
+  void setLoggingInterval(int loggingInterval) { mLoggingInterval = loggingInterval; }
+
  private:
   TFType mTFStart;
 
   BadChannelsVector mBadChannelsVector; ///< vector containing the unique IDs of the bad/noisy channels
   PedestalsVector mPedestalsVector;     ///< vector containing the source pedestal information used for bad channel decision
 
-  ClassDefOverride(BadChannelCalibrator, 1);
+  int mLoggingInterval = 0; ///< time interval between statistics logging messages
+
+  ClassDefOverride(BadChannelCalibrator, 2);
 };
 
 } // namespace o2::mch::calibration
diff --git a/Detectors/MUON/MCH/Calibration/include/MCHCalibration/BadChannelCalibratorParam.h b/Detectors/MUON/MCH/Calibration/include/MCHCalibration/BadChannelCalibratorParam.h
index 08427ce8a081e..17647f86966db 100644
--- a/Detectors/MUON/MCH/Calibration/include/MCHCalibration/BadChannelCalibratorParam.h
+++ b/Detectors/MUON/MCH/Calibration/include/MCHCalibration/BadChannelCalibratorParam.h
@@ -30,6 +30,8 @@ struct BadChannelCalibratorParam : public o2::conf::ConfigurableParamHelper<BadC
   int minRequiredNofEntriesPerChannel = 10000; ///< mininum pedestal digits per channel needed to assess a channel quality
   float minRequiredCalibratedFraction = 0.9f;  ///< minimum fraction of channels for which we need a quality value to produce a bad channel map.
 
+  int nThreads = 1; ///< number of paralle threads for processing the pedestal data
+
   bool onlyAtEndOfStream = {true}; ///< only produce bad channel map at end of stream (EoS). In that case the minRequiredCalibratedFraction and minRequiredNofEntriesPerChannel are irrelevant.
 
   O2ParamDef(BadChannelCalibratorParam, "MCHBadChannelCalibratorParam");
diff --git a/Detectors/MUON/MCH/Calibration/include/MCHCalibration/PedestalData.h b/Detectors/MUON/MCH/Calibration/include/MCHCalibration/PedestalData.h
index 8e1d8c6c40d64..b9c3d770a9ad3 100644
--- a/Detectors/MUON/MCH/Calibration/include/MCHCalibration/PedestalData.h
+++ b/Detectors/MUON/MCH/Calibration/include/MCHCalibration/PedestalData.h
@@ -86,6 +86,8 @@ class PedestalData
 
   uint32_t size() const;
 
+  void setNThreads(int nThreads) { mNThreads = nThreads; }
+
  private:
   PedestalData::PedestalMatrix initPedestalMatrix(uint16_t solarId);
 
@@ -94,8 +96,9 @@ class PedestalData
 
   PedestalsMap mPedestals{}; ///< internal storage of all PedestalChannel values
   uint32_t mSize{0};         ///< total number of valid channels in the pedestals map
+  int mNThreads{1};          ///< number of parallel threads to process the pedestal digits
 
-  ClassDefNV(PedestalData, 1)
+  ClassDefNV(PedestalData, 2)
 };
 
 namespace impl
diff --git a/Detectors/MUON/MCH/Calibration/src/BadChannelCalibrationDevice.cxx b/Detectors/MUON/MCH/Calibration/src/BadChannelCalibrationDevice.cxx
index 32e2de5d85264..a57e569f49921 100644
--- a/Detectors/MUON/MCH/Calibration/src/BadChannelCalibrationDevice.cxx
+++ b/Detectors/MUON/MCH/Calibration/src/BadChannelCalibrationDevice.cxx
@@ -37,6 +37,7 @@ void BadChannelCalibrationDevice::init(o2::framework::InitContext& ic)
   mCalibrator = std::make_unique<o2::mch::calibration::BadChannelCalibrator>();
   mCalibrator->setSlotLength(o2::calibration::INFINITE_TF);
   mCalibrator->setUpdateAtTheEndOfRunOnly();
+  mCalibrator->setLoggingInterval(mLoggingInterval);
   mTimeStamp = std::numeric_limits<uint64_t>::max();
 }
 
@@ -52,6 +53,8 @@ void BadChannelCalibrationDevice::logStats(size_t dataSize)
   static auto loggerEnd = loggerStart;
   static size_t nDigits = 0;
   static size_t nTF = 0;
+  static size_t nTFtot = 0;
+  static size_t nTFtotWithData = 0;
 
   if (mLoggingInterval == 0) {
     return;
@@ -59,11 +62,17 @@ void BadChannelCalibrationDevice::logStats(size_t dataSize)
 
   nDigits += dataSize;
   nTF += 1;
+  nTFtot += 1;
+  if (dataSize > 1000) {
+    nTFtotWithData += 1;
+  }
 
   loggerEnd = std::chrono::high_resolution_clock::now();
   std::chrono::duration<double, std::milli> loggerElapsed = loggerEnd - loggerStart;
-  if (loggerElapsed.count() > 1000) {
-    LOG(info) << "received " << nDigits << " digits in " << nTF << " time frames";
+  if (loggerElapsed.count() > mLoggingInterval) {
+    LOG(warning) << "received " << nDigits << " digits in " << nTF << " time frames";
+    LOG(warning) << "received " << nTFtotWithData << " time frames with data out of " << nTFtot << " total time frames ("
+                 << ((nTFtot > 0) ? (nTFtotWithData * 100.0) / nTFtot : 0.0) << "%)";
     nDigits = 0;
     nTF = 0;
     loggerStart = std::chrono::high_resolution_clock::now();
@@ -86,7 +95,7 @@ void BadChannelCalibrationDevice::run(o2::framework::ProcessingContext& pc)
     std::string reason;
     if (mCalibrator->readyToSend(reason)) {
       mHasEnoughStat = true;
-      LOGP(info, "We're ready to send output to CCDB ({})", reason);
+      LOGP(warning, "We're ready to send output to CCDB ({})", reason);
       sendOutput(pc.outputs(), reason);
       mSkipData = true;
     }
@@ -139,12 +148,12 @@ void sendCalibrationOutput(o2::framework::DataAllocator& output,
   using clbUtils = o2::calibration::Utils;
   auto image = o2::ccdb::CcdbApi::createObjectImage(payload, payloadInfo);
 
-  LOG(info) << "Sending object " << payloadInfo->getPath()
-            << " of type" << payloadInfo->getObjectType()
-            << " /" << payloadInfo->getFileName()
-            << " of size " << image->size()
-            << " bytes, valid for " << payloadInfo->getStartValidityTimestamp()
-            << " : " << payloadInfo->getEndValidityTimestamp();
+  LOG(warning) << "Sending object " << payloadInfo->getPath()
+               << " of type" << payloadInfo->getObjectType()
+               << " /" << payloadInfo->getFileName()
+               << " of size " << image->size()
+               << " bytes, valid for " << payloadInfo->getStartValidityTimestamp()
+               << " : " << payloadInfo->getEndValidityTimestamp();
 
   output.snapshot(o2::framework::Output{o2::calibration::Utils::gDataOriginCDBPayload, "MCH_BADCHAN", subSpec}, *image.get());
   output.snapshot(o2::framework::Output{o2::calibration::Utils::gDataOriginCDBWrapper, "MCH_BADCHAN", subSpec}, *payloadInfo);
@@ -168,7 +177,7 @@ void BadChannelCalibrationDevice::sendOutput(o2::framework::DataAllocator& outpu
     reason_with_entries = fmt::format("{} ; no entries", reason);
   }
 
-  LOGP(info, "sendOutput: {}", reason_with_entries);
+  LOGP(warning, "sendOutput: {}", reason_with_entries);
   mCalibrator->finalize();
 
   // the bad channels table is only updated if there is enough statistics
diff --git a/Detectors/MUON/MCH/Calibration/src/BadChannelCalibrator.cxx b/Detectors/MUON/MCH/Calibration/src/BadChannelCalibrator.cxx
index 26d312e7dc36e..b5aa17ef81f8c 100644
--- a/Detectors/MUON/MCH/Calibration/src/BadChannelCalibrator.cxx
+++ b/Detectors/MUON/MCH/Calibration/src/BadChannelCalibrator.cxx
@@ -20,6 +20,7 @@
 #include <iostream>
 #include <iterator>
 #include <numeric>
+#include <limits>
 #include <sstream>
 
 namespace o2::mch::calibration
@@ -65,6 +66,8 @@ void BadChannelCalibrator::finalize()
 
 bool BadChannelCalibrator::hasEnoughData(const Slot& slot) const
 {
+  static auto loggerStart = std::chrono::high_resolution_clock::now();
+  static auto loggerEnd = loggerStart;
   const int minNofEntries = BadChannelCalibratorParam::Instance().minRequiredNofEntriesPerChannel;
   const o2::mch::calibration::PedestalData* pedData = slot.getContainer();
   auto nofChannels = pedData->size();
@@ -75,9 +78,35 @@ bool BadChannelCalibrator::hasEnoughData(const Slot& slot) const
 
   bool hasEnough = nofCalibrated > requiredChannels;
 
-  LOGP(info,
-       "nofChannelWithEnoughStat(>{})={} nofChannels={} requiredChannels={} hasEnough={}",
-       minNofEntries, nofCalibrated, nofChannels, requiredChannels, hasEnough);
+  // logging of calibration statistics
+  loggerEnd = std::chrono::high_resolution_clock::now();
+  std::chrono::duration<double, std::milli> loggerElapsed = loggerEnd - loggerStart;
+  if (mLoggingInterval > 0 && loggerElapsed.count() > mLoggingInterval) {
+    int minEntriesPerChannel{std::numeric_limits<int>::max()};
+    int maxEntriesPerChannel{0};
+    uint64_t averageEntriesPerChannel = 0;
+    std::for_each(pedData->cbegin(), pedData->cend(),
+                  [&](const PedestalChannel& c) {
+                    if (c.mEntries == 0) {
+                      return;
+                    }
+                    if (c.mEntries > maxEntriesPerChannel) {
+                      maxEntriesPerChannel = c.mEntries;
+                    }
+                    if (c.mEntries < minEntriesPerChannel) {
+                      minEntriesPerChannel = c.mEntries;
+                    }
+                    averageEntriesPerChannel += c.mEntries;
+                  });
+    if (nofChannels > 0) {
+      averageEntriesPerChannel /= nofChannels;
+    }
+    LOGP(warning, "channel stats: min={} max={} average={}", minEntriesPerChannel, maxEntriesPerChannel, averageEntriesPerChannel);
+    LOGP(warning,
+         "nofChannelWithEnoughStat(>{})={} nofChannels={} requiredChannels={} hasEnough={}",
+         minNofEntries, nofCalibrated, nofChannels, requiredChannels, hasEnough);
+    loggerStart = std::chrono::high_resolution_clock::now();
+  }
 
   return hasEnough;
 }
@@ -92,7 +121,7 @@ void BadChannelCalibrator::finalizeSlot(Slot& slot)
   mBadChannelsVector.clear();
 
   o2::mch::calibration::PedestalData* pedestalData = slot.getContainer();
-  LOG(info) << "Finalize slot " << slot.getTFStart() << " <= TF <= " << slot.getTFEnd();
+  LOG(warning) << "Finalize slot " << slot.getTFStart() << " <= TF <= " << slot.getTFEnd();
 
   // keep track of first TimeFrame
   if (slot.getTFStart() < mTFStart) {
@@ -120,9 +149,11 @@ void BadChannelCalibrator::finalizeSlot(Slot& slot)
 BadChannelCalibrator::Slot&
   BadChannelCalibrator::emplaceNewSlot(bool front, TFType tstart, TFType tend)
 {
+  const int nThreads = static_cast<int>(BadChannelCalibratorParam::Instance().nThreads);
   auto& cont = getSlots();
   auto& slot = front ? cont.emplace_front(tstart, tend) : cont.emplace_back(tstart, tend);
   slot.setContainer(std::make_unique<PedestalData>());
+  slot.getContainer()->setNThreads(nThreads);
   return slot;
 }
 
diff --git a/Detectors/MUON/MCH/Calibration/src/PedestalData.cxx b/Detectors/MUON/MCH/Calibration/src/PedestalData.cxx
index 661bab7913b8e..5947cc940e3ce 100644
--- a/Detectors/MUON/MCH/Calibration/src/PedestalData.cxx
+++ b/Detectors/MUON/MCH/Calibration/src/PedestalData.cxx
@@ -19,6 +19,9 @@
 #include <iostream>
 #include <iterator>
 #include <limits>
+#include <mutex>
+#include <thread>
+#include <queue>
 
 namespace o2::mch::calibration
 {
@@ -69,45 +72,107 @@ PedestalData::PedestalMatrix PedestalData::initPedestalMatrix(uint16_t solarId)
 void PedestalData::fill(gsl::span<const PedestalDigit> digits)
 {
   bool mDebug = false;
+  static std::mutex pedestalMutex;
+  static std::set<uint16_t> solarIds = o2::mch::raw::getSolarUIDs<o2::mch::raw::ElectronicMapperGenerated>();
 
-  for (auto& d : digits) {
-    uint16_t solarId = d.getSolarId();
-    uint8_t dsId = d.getDsId();
-    uint8_t channel = d.getChannel();
+  if (digits.empty()) {
+    return;
+  }
 
-    auto iPedestal = mPedestals.find(solarId);
+  LOGP(info, "processing {} digits with {} threads", (int)digits.size(), mNThreads);
 
-    if (iPedestal == mPedestals.end()) {
-      auto iPedestalsNew = mPedestals.emplace(std::make_pair(solarId, initPedestalMatrix(solarId)));
-      iPedestal = iPedestalsNew.first;
-    }
+  // fill the queue of SOLAR IDs to be processed
+  std::queue<uint16_t> solarQueue;
+  for (auto solarId : solarIds) {
+    solarQueue.push(solarId);
+  }
 
-    if (iPedestal == mPedestals.end()) {
-      LOGP(fatal, "failed to insert new element in padestals map");
-      break;
-    }
+  auto processSolarDigits = [&]() {
+    while (true) {
+      int targetSolarId = -1;
+      PedestalsMap::iterator iPedestal;
+      bool pedestalsAreInitialized;
+
+      // non thread-safe access to solarQueue, protected by the pedestalMutex
+      {
+        std::lock_guard<std::mutex> lock(pedestalMutex);
+
+        // stop when there are no mor SOLAR IDs to process
+        if (solarQueue.empty()) {
+          break;
+        }
+
+        // get the next SOLAR ID to be processed
+        targetSolarId = solarQueue.front();
+        solarQueue.pop();
+
+        // update the iterator to the pedestal data for the target SOLAR
+        iPedestal = mPedestals.find(targetSolarId);
+        if (iPedestal == mPedestals.end()) {
+          pedestalsAreInitialized = false;
+        } else {
+          pedestalsAreInitialized = true;
+        }
+      }
 
-    auto& ped = iPedestal->second[dsId][channel];
+      // loop over digits, selecting only those belonging to the target SOLAR
+      for (auto& d : digits) {
+        uint16_t solarId = d.getSolarId();
+        if (solarId != targetSolarId) {
+          continue;
+        }
 
-    for (uint16_t i = 0; i < d.nofSamples(); i++) {
-      auto s = d.getSample(i);
+        // non thread-safe access to Pedestals structure, protected by the pedestalMutex
+        if (!pedestalsAreInitialized) {
+          std::lock_guard<std::mutex> lock(pedestalMutex);
 
-      ped.mEntries += 1;
-      uint64_t N = ped.mEntries;
+          // create the pedestals structure corresponding to the SOLAR ID to be processed
+          iPedestal = mPedestals.emplace(std::make_pair(targetSolarId, initPedestalMatrix(targetSolarId))).first;
 
-      double p0 = ped.mPedestal;
-      double p = p0 + (s - p0) / N;
-      ped.mPedestal = p;
+          if (iPedestal == mPedestals.end()) {
+            LOGP(fatal, "failed to insert new element in padestals map");
+            break;
+          }
+          pedestalsAreInitialized = true;
+        }
 
-      double M0 = ped.mVariance;
-      double M = M0 + (s - p0) * (s - p);
-      ped.mVariance = M;
-    }
+        uint8_t dsId = d.getDsId();
+        uint8_t channel = d.getChannel();
+
+        auto& ped = iPedestal->second[dsId][channel];
+
+        for (uint16_t i = 0; i < d.nofSamples(); i++) {
+          auto s = d.getSample(i);
 
-    if (mDebug) {
-      LOGP(info, "solarId {}  dsId {}  ch {}  nsamples {}  entries{}  mean {}  variance {}",
-           (int)solarId, (int)dsId, (int)channel, d.nofSamples(), ped.mEntries, ped.mPedestal, ped.mVariance);
+          ped.mEntries += 1;
+          uint64_t N = ped.mEntries;
+
+          double p0 = ped.mPedestal;
+          double p = p0 + (s - p0) / N;
+          ped.mPedestal = p;
+
+          double M0 = ped.mVariance;
+          double M = M0 + (s - p0) * (s - p);
+          ped.mVariance = M;
+        }
+
+        if (mDebug) {
+          LOGP(info, "solarId {}  dsId {}  ch {}  nsamples {}  entries{}  mean {}  variance {}",
+               (int)solarId, (int)dsId, (int)channel, d.nofSamples(), ped.mEntries, ped.mPedestal, ped.mVariance);
+        }
+      }
     }
+  };
+
+  // process the digits in parallel threads
+  std::vector<std::thread> threads;
+  for (int ti = 0; ti < mNThreads; ti++) {
+    threads.emplace_back(processSolarDigits);
+  }
+
+  // wait for all threads to finish processing
+  for (auto& thread : threads) {
+    thread.join();
   }
 }
 
diff --git a/Detectors/MUON/MCH/Calibration/test/testPedestalData.cxx b/Detectors/MUON/MCH/Calibration/test/testPedestalData.cxx
index c61656aa7845f..0c1d6bffb984e 100644
--- a/Detectors/MUON/MCH/Calibration/test/testPedestalData.cxx
+++ b/Detectors/MUON/MCH/Calibration/test/testPedestalData.cxx
@@ -84,6 +84,17 @@ BOOST_AUTO_TEST_CASE(TestIteratorOnCompletePedestalData)
     ++n;
   }
   BOOST_TEST(n == allDigits.size());
+
+  // multi-threaded version
+  PedestalData pdmt;
+  pdmt.setNThreads(8);
+  pdmt.fill(allDigits);
+
+  int nmt{0};
+  for (const auto& ped : pdmt) {
+    ++nmt;
+  }
+  BOOST_TEST(nmt == allDigits.size());
 }
 
 BOOST_AUTO_TEST_CASE(TestIteratorEquality)
@@ -113,6 +124,16 @@ BOOST_AUTO_TEST_CASE(TestIteratorPreIncrementable)
     n++;
   }
   BOOST_TEST(n == 2768);
+
+  // multi-threaded version
+  PedestalData pdmt;
+  pdmt.setNThreads(8);
+  pdmt.fill(digits);
+  int nmt{0};
+  for (auto rec : pdmt) {
+    nmt++;
+  }
+  BOOST_TEST(nmt == 2768);
   // 2768 = 1856 pads in solar 328 + 721 pads in solar 721
   // Note that solar 328 has 29 dual sampas
   // solar 721 has 15 dual sampas

From e96552ab9df7f88abfe83767ea82ea470e67539f Mon Sep 17 00:00:00 2001
From: Martin Eide <43970264+mrtineide@users.noreply.github.com>
Date: Wed, 13 Aug 2025 09:28:49 +0200
Subject: [PATCH 0697/1764] Update README so example code has std::

When working on AliceO2Group/AliceO2#14524 the code
that needed to be changed came most likely from the
README.md and its code example. So with this change
now any future copy-paste will also have std::.
---
 CCDB/README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CCDB/README.md b/CCDB/README.md
index ce8d9e19f7b27..e098617cf44e3 100644
--- a/CCDB/README.md
+++ b/CCDB/README.md
@@ -31,7 +31,7 @@ If you access the CCDB with a web browser, add `/browse` at the end of the URL t
 ```c++
 // init
 CcdbApi api;
-map<string, string> metadata; // can be empty
+std::map<std::string, std::string> metadata; // can be empty
 api.init("http://ccdb-test.cern.ch:8080"); // or http://localhost:8080 for a local installation
 // store abitrary user object in strongly typed manner
 auto deadpixels = new o2::FOO::DeadPixelMap();
@@ -39,7 +39,7 @@ api.storeAsTFileAny(deadpixels, "FOO/DeadPixels", metadata);
 // read like this (you have to specify the type)
 auto deadpixelsback = api.retrieveFromTFileAny<o2::FOO::DeadPixelMap>("FOO/DeadPixels", metadata); 
 // read like this to get the headers as well, and thus the metadata attached to the object 
-map<string, string> headers;
+std::map<std::string, std::string> headers;
 auto deadpixelsback = api.retrieveFromTFileAny<o2::FOO::DeadPixelMap>("FOO/DeadPixels", metadata /* constraint the objects retrieved to those matching the metadata */, -1 /* timestamp */, &headers /* the headers attached to the returned object */); 
 // finally, use this method to retrieve only the headers (and thus the metadata)
 std::map<std::string, std::string> headers = f.api.retrieveHeaders("FOO/DeadPixels", f.metadata); 
@@ -50,7 +50,7 @@ std::map<std::string, std::string> headers = f.api.retrieveHeaders("FOO/DeadPixe
 ```c++
 // init
 CcdbApi api;
-map<string, string> metadata; // can be empty
+std::map<std::string, std::string> metadata; // can be empty
 api.init("http://ccdb-test.cern.ch:8080"); // or http://localhost:8080 for a local installation
 // create a local snapshot of everthing in or below the FOO folder valid for timestamp 12345
 api.snapshot("FOO", "/tmp/CCDBSnapshot/", 12345);

From a1c484d69684ac857e84f4b3394be0793a20c801 Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Wed, 13 Aug 2025 11:55:26 +0200
Subject: [PATCH 0698/1764] Ctpdev: reducing logs in run manager (#14574)

* dev: reducing logs

* @clang@
---
 .../CTP/workflowScalers/src/RunManager.cxx     | 18 +++++++++---------
 .../CTP/workflowScalers/src/ctp-proxy.cxx      | 11 ++++++++++-
 .../CTP/workflowScalers/src/ctpCCDBManager.cxx |  4 ++--
 3 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/Detectors/CTP/workflowScalers/src/RunManager.cxx b/Detectors/CTP/workflowScalers/src/RunManager.cxx
index 054505aea7ba6..778677bec2ec9 100644
--- a/Detectors/CTP/workflowScalers/src/RunManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/RunManager.cxx
@@ -216,14 +216,14 @@ int CTPRunManager::addScalers(uint32_t irun, std::time_t time, bool start)
   }
   scalrec.intRecord.bc = 0;
   mActiveRuns[irun]->scalers.addScalerRacordRaw(scalrec);
-  LOG(info) << "Adding scalers for orbit:" << scalrec.intRecord.orbit;
+  LOG(debug) << "Adding scalers for orbit:" << scalrec.intRecord.orbit;
   // scalrec.printStream(std::cout);
   // printCounters();
   return 0;
 }
 int CTPRunManager::processMessage(std::string& topic, const std::string& message)
 {
-  LOG(info) << "Processing message with topic:" << topic;
+  LOG(debug) << "Processing message with topic:" << topic;
   std::string firstcounters;
   if (topic.find("clear") != std::string::npos) {
     mRunsLoaded.clear();
@@ -283,7 +283,7 @@ int CTPRunManager::processMessage(std::string& topic, const std::string& message
     // get config
     size_t irun = message.find("run");
     if (irun == std::string::npos) {
-      LOG(warning) << "run keyword not found in SOX";
+      LOG(debug) << "run keyword not found in SOX";
       irun = message.size();
     }
     LOG(info) << "SOX received, Run keyword position:" << irun;
@@ -319,22 +319,22 @@ int CTPRunManager::processMessage(std::string& topic, const std::string& message
   }
   double timeStamp = std::stold(tokens.at(0));
   std::time_t tt = timeStamp;
-  LOG(info) << "Processing scalers, all good, time:" << tokens.at(0) << " " << std::asctime(std::localtime(&tt));
+  LOG(debug) << "Processing scalers, all good, time:" << tokens.at(0) << " " << std::asctime(std::localtime(&tt));
   for (uint32_t i = 1; i < tokens.size(); i++) {
     mCounters[i - 1] = std::stoull(tokens.at(i));
     if (i < (NRUNS + 1)) {
-      std::cout << mCounters[i - 1] << " ";
+      // std::cout << mCounters[i - 1] << " ";
     }
   }
-  std::cout << std::endl;
-  LOG(info) << "Counter size:" << tokens.size();
+  // std::cout << std::endl;
+  LOG(debug) << "Counter size:" << tokens.size();
   //
   for (uint32_t i = 0; i < NRUNS; i++) {
     if ((mCounters[i] == 0) && (mActiveRunNumbers[i] == 0)) {
       // not active
     } else if ((mCounters[i] != 0) && (mActiveRunNumbers[i] == mCounters[i])) {
       // active , do scalers
-      LOG(info) << "Run continue:" << mCounters[i];
+      LOG(debug) << "Run continue:" << mCounters[i];
       addScalers(i, tt);
       // LOG(info) << " QC period:" << mActiveRunNumbers[i] << " " << mActiveRuns[i]->qcwpcount << " " << mQCWritePeriod;
       if (mActiveRuns[i]->qcwpcount > mQCWritePeriod) {
@@ -367,7 +367,7 @@ int CTPRunManager::processMessage(std::string& topic, const std::string& message
     }
   }
   mEOX = 0;
-  printActiveRuns();
+  // printActiveRuns();
   return 0;
 }
 void CTPRunManager::printActiveRuns() const
diff --git a/Detectors/CTP/workflowScalers/src/ctp-proxy.cxx b/Detectors/CTP/workflowScalers/src/ctp-proxy.cxx
index f8f8ad3c95fbb..391d1b5ccf58b 100644
--- a/Detectors/CTP/workflowScalers/src/ctp-proxy.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctp-proxy.cxx
@@ -56,6 +56,7 @@ InjectorFunction dcs2dpl(std::string& ccdbhost, std::string& bkhost, std::string
   runMgr->setCtpCfgDir(ctpcfgdir);
   runMgr->init();
   // runMgr->setClient(client);
+  static int nprint = 0;
   return [runMgr](TimingInfo&, ServiceRegistryRef const& services, fair::mq::Parts& parts, ChannelRetriever channelRetriever, size_t newTimesliceId, bool& stop) -> bool {
     // FIXME: Why isn't this function using the timeslice index?
     // make sure just 2 messages received
@@ -66,7 +67,15 @@ InjectorFunction dcs2dpl(std::string& ccdbhost, std::string& bkhost, std::string
     std::string messageHeader{static_cast<const char*>(parts.At(0)->GetData()), parts.At(0)->GetSize()};
     size_t dataSize = parts.At(1)->GetSize();
     std::string messageData{static_cast<const char*>(parts.At(1)->GetData()), parts.At(1)->GetSize()};
-    LOG(info) << "received message " << messageHeader << " of size " << dataSize << " # parts:" << parts.Size(); // << " Payload:" << messageData;
+    nprint++;
+    int nlimit = 60;
+    int nrange = 8;
+    if (nprint > nlimit && nprint < (nlimit + nrange + 1)) {
+      LOG(info) << "received message " << messageHeader << " of size " << dataSize << " # parts:" << parts.Size(); // << " Payload:" << messageData;
+      if (nprint == (nlimit + nrange)) {
+        nprint = 0;
+      }
+    }
     runMgr->processMessage(messageHeader, messageData);
     return true;
   };
diff --git a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
index 77d3f03bbbde2..2c634ddd2565d 100644
--- a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
@@ -28,7 +28,7 @@ int ctpCCDBManager::saveRunScalersToCCDB(CTPRunScalers& scalers, long timeStart,
 {
   // data base
   if (mCCDBHost == "none") {
-    LOG(info) << "Scalers not written to CCDB none";
+    LOG(debug) << "Scalers not written to CCDB none";
     return 0;
   }
   // CTPActiveRun* run = mActiveRuns[i];
@@ -56,7 +56,7 @@ int ctpCCDBManager::saveRunScalersToQCDB(CTPRunScalers& scalers, long timeStart,
 {
   // data base
   if (mQCDBHost == "none") {
-    LOG(info) << "Scalers not written to QCDB none";
+    LOG(debug) << "Scalers not written to QCDB none";
     return 0;
   }
   // CTPActiveRun* run = mActiveRuns[i];q

From f9fa54ef165c5abf3b034035462b294ba1430e5c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 13 Aug 2025 15:37:51 +0200
Subject: [PATCH 0699/1764] DPL: add benchmark for stack creation

---
 Framework/Core/CMakeLists.txt           |  1 +
 Framework/Core/test/benchmark_Stack.cxx | 41 +++++++++++++++++++++++++
 2 files changed, 42 insertions(+)
 create mode 100644 Framework/Core/test/benchmark_Stack.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index f24ac6387649e..936d8874179a5 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -339,6 +339,7 @@ o2_add_executable(dpl-run
 foreach(b
         DataDescriptorMatcher
         DataRelayer
+        Stack
         DeviceMetricsInfo
         InputRecord
         TableBuilder
diff --git a/Framework/Core/test/benchmark_Stack.cxx b/Framework/Core/test/benchmark_Stack.cxx
new file mode 100644
index 0000000000000..ff45b8724ce73
--- /dev/null
+++ b/Framework/Core/test/benchmark_Stack.cxx
@@ -0,0 +1,41 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#include <benchmark/benchmark.h>
+
+#include "Framework/DataProcessingHeader.h"
+#include "Headers/DataHeader.h"
+#include "Headers/Stack.h"
+#include <iostream>
+
+// a simple benchmark of the contribution of the pure message creation
+// this was important when the benchmarks below included the message
+// creation inside the benchmark loop, its somewhat obsolete now but
+// we keep it for reference
+static void BM_RelayStackLifecycle(benchmark::State& state)
+{
+  using namespace o2::framework;
+  using namespace o2::header;
+  DataProcessingHeader dph{0, 1};
+
+  for (auto _ : state) {
+    DataHeader dh;
+    dh.dataDescription = "CLUSTERS";
+    dh.dataOrigin = "TPC";
+    dh.subSpecification = 0;
+
+    DataProcessingHeader dph{0, 1};
+    Stack stack{dh, dph};
+  }
+}
+
+BENCHMARK(BM_RelayStackLifecycle);
+
+BENCHMARK_MAIN();

From bbef7a7e9362c793039af6a9cf658d170bda33d6 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 13 Aug 2025 17:59:46 +0200
Subject: [PATCH 0700/1764] Data Model: provide size when deallocating a Stack

---
 DataFormats/Headers/include/Headers/Stack.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index 98fb95e602ecf..f225a0d80a60b 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -37,9 +37,10 @@ struct Stack {
 
  private:
   struct freeobj {
-    freeobj(memory_resource* mr) : resource(mr) {}
+    freeobj(memory_resource* mr, size_t s) : resource(mr), size(s) {}
     memory_resource* resource{nullptr};
-    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, alignof(std::max_align_t)); }
+    size_t           size{0};
+    void operator()(std::byte* ptr) { resource->deallocate(ptr, size, alignof(std::max_align_t)); }
   };
 
  public:
@@ -100,7 +101,7 @@ struct Stack {
   Stack(const allocator_type allocatorArg, Headers&&... headers)
     : allocator{allocatorArg},
       bufferSize{calculateSize(std::forward<Headers>(headers)...)},
-      buffer{static_cast<std::byte*>(allocator.resource()->allocate(bufferSize, alignof(std::max_align_t))), freeobj{allocator.resource()}}
+      buffer{static_cast<std::byte*>(allocator.resource()->allocate(bufferSize, alignof(std::max_align_t))), freeobj{allocator.resource(), bufferSize}}
   {
     if constexpr (sizeof...(headers) > 1) {
       injectAll(buffer.get(), std::forward<Headers>(headers)...);
@@ -143,7 +144,7 @@ struct Stack {
  private:
   allocator_type allocator{std::pmr::new_delete_resource()};
   size_t bufferSize{0};
-  BufferType buffer{nullptr, freeobj{allocator.resource()}};
+  BufferType buffer{nullptr, freeobj{allocator.resource(), 0}};
 
   //______________________________________________________________________________________________
   template <typename T>

From 999ac719cffe2591fe395af9c5d7f21f7b67c778 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 14 Aug 2025 00:58:02 +0200
Subject: [PATCH 0701/1764] Make sure extra tracks are randomized to avoid PHOS
 hole losses

The tracks with TRD/TOF are prioritized as of higher quality and we accept a limited min. amount of tracks per TF (1)
before swithing to extra tracks (whose max accepted number is also capped).
Therefore this guaranteed minimum will be typically affected by the PHOS hole, the same is true for the ITS-TPC stripped
versions of these global tracks which are added for additional processing if ITS only extrapolation is asked.

When processing extra tracks, the algorithm was considering only these stripped ITS-TPC tracks,
so the ITS extrapolation were also affected by the PHOS hole.
This PR makes sure that the extra tracks processing starts from the first seed abandoned due to meeting the condition (1),
and that the remaining tracks are processed in the random order.
---
 DataFormats/Headers/include/Headers/Stack.h   |  2 +-
 .../SpacePoints/src/TrackInterpolation.cxx    | 60 ++++++++++++-------
 2 files changed, 38 insertions(+), 24 deletions(-)

diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index f225a0d80a60b..ce1a71dafd3eb 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -39,7 +39,7 @@ struct Stack {
   struct freeobj {
     freeobj(memory_resource* mr, size_t s) : resource(mr), size(s) {}
     memory_resource* resource{nullptr};
-    size_t           size{0};
+    size_t size{0};
     void operator()(std::byte* ptr) { resource->deallocate(ptr, size, alignof(std::max_align_t)); }
   };
 
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index d13f24ad728fd..015c0ef1df416 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -272,7 +272,7 @@ void TrackInterpolation::process()
   trackIndices.insert(trackIndices.end(), mTrackIndices[mTrackTypes[GTrackID::ITSTPCTOF]].begin(), mTrackIndices[mTrackTypes[GTrackID::ITSTPCTOF]].end());
   trackIndices.insert(trackIndices.end(), mTrackIndices[mTrackTypes[GTrackID::ITSTPC]].begin(), mTrackIndices[mTrackTypes[GTrackID::ITSTPC]].end());
 
-  int nSeeds = mSeeds.size();
+  int nSeeds = mSeeds.size(), lastChecked = 0;
   int maxOutputTracks = (mMaxTracksPerTF >= 0) ? mMaxTracksPerTF + mAddTracksForMapPerTF : nSeeds;
   mTrackData.reserve(maxOutputTracks);
   mClRes.reserve(maxOutputTracks * param::NPadRows);
@@ -286,51 +286,65 @@ void TrackInterpolation::process()
     if (mParams->enableTrackDownsampling && !isTrackSelected(mSeeds[seedIndex])) {
       continue;
     }
+
+    auto addPart = [this, seedIndex](GTrackID::Source src) {
+      this->mGIDs.push_back(this->mGIDtables[seedIndex][src]);
+      this->mGIDtables.push_back(this->mRecoCont->getSingleDetectorRefs(this->mGIDs.back()));
+      this->mTrackTimes.push_back(this->mTrackTimes[seedIndex]);
+      this->mSeeds.push_back(this->mSeeds[seedIndex]);
+    };
+
+    GTrackID::mask_t partsAdded;
     if (!mSingleSourcesConfigured && !mSourcesConfiguredMap[mGIDs[seedIndex].getSource()]) {
       auto src = findValidSource(mSourcesConfiguredMap, static_cast<GTrackID::Source>(mGIDs[seedIndex].getSource()));
       if (src == GTrackID::ITSTPCTRD || src == GTrackID::ITSTPC) {
-        LOGP(debug, "process: Found valid source {}", GTrackID::getSourceName(src));
-        mGIDs.push_back(mGIDtables[seedIndex][src]);
-        mGIDtables.push_back(mRecoCont->getSingleDetectorRefs(mGIDs.back()));
-        mTrackTimes.push_back(mTrackTimes[seedIndex]);
-        mSeeds.push_back(mSeeds[seedIndex]);
+        LOGP(debug, "process {}: Found valid source {} for {} | nseeds:{} mSeeds:{} used: {}", iSeed, GTrackID::getSourceName(src), GTrackID::getSourceName(mGIDs[seedIndex].getSource()), nSeeds, mSeeds.size(), mTrackDataCompact.size());
+        addPart(src);
       }
     }
     if (mMaxTracksPerTF >= 0 && mTrackDataCompact.size() >= mMaxTracksPerTF) {
-      LOG(debug) << "We already have reached mMaxTracksPerTF, but we continue to create seeds until mAddTracksForMapPerTF is also reached";
+      if (!maxTracksReached) {
+        LOGP(info, "We already have reached mMaxTracksPerTF={}, but we continue to create seeds until mAddTracksForMapPerTF={} is also reached, iSeed: {} of {} inital seeds", mMaxTracksPerTF, mAddTracksForMapPerTF, iSeed, nSeeds);
+      }
+      maxTracksReached = true;
       continue;
     }
     if (mGIDs[seedIndex].includesDet(DetID::TRD) || mGIDs[seedIndex].includesDet(DetID::TOF)) {
       interpolateTrack(seedIndex);
+      LOGP(debug, "interpolateTrack {} {}, accepted: {}", iSeed, GTrackID::getSourceName(mGIDs[seedIndex].getSource()), mTrackDataCompact.size());
       if (mProcessSeeds) {
-        if (mGIDs[seedIndex].includesDet(DetID::TRD) && mGIDs[seedIndex].includesDet(DetID::TOF)) {
-          mGIDs.push_back(mGIDtables[seedIndex][GTrackID::ITSTPCTRD]);
-          mGIDtables.push_back(mRecoCont->getSingleDetectorRefs(mGIDs.back()));
-          mTrackTimes.push_back(mTrackTimes[seedIndex]);
-          mSeeds.push_back(mSeeds[seedIndex]);
+        if (mGIDs[seedIndex].includesDet(DetID::TRD) && mGIDs[seedIndex].includesDet(DetID::TOF) && !partsAdded[GTrackID::ITSTPCTRD]) {
+          addPart(GTrackID::ITSTPCTRD);
+        }
+        if (!partsAdded[GTrackID::ITSTPC]) {
+          addPart(GTrackID::ITSTPC);
         }
-        mGIDs.push_back(mGIDtables[seedIndex][GTrackID::ITSTPC]);
-        mGIDtables.push_back(mRecoCont->getSingleDetectorRefs(mGIDs.back()));
-        mTrackTimes.push_back(mTrackTimes[seedIndex]);
-        mSeeds.push_back(mSeeds[seedIndex]);
       }
     } else {
       extrapolateTrack(seedIndex);
+      LOGP(debug, "extrapolateTrack {} {}, accepted: {}", iSeed, GTrackID::getSourceName(mGIDs[seedIndex].getSource()), mTrackDataCompact.size());
     }
+    lastChecked = iSeed;
   }
-  if (mSeeds.size() > nSeeds) {
-    LOGP(info, "Up to {} tracks out of {} additional seeds will be processed", mAddTracksForMapPerTF, mSeeds.size() - nSeeds);
+  std::vector<int> remSeeds;
+  if (mSeeds.size() > ++lastChecked) {
+    remSeeds.resize(mSeeds.size() - lastChecked);
+    std::iota(remSeeds.begin(), remSeeds.end(), lastChecked);
+    std::shuffle(remSeeds.begin(), remSeeds.end(), g);
+    LOGP(info, "Up to {} tracks out of {} additional seeds will be processed in random order, of which {} are stripped versions, accepted seeds: {}", mAddTracksForMapPerTF, remSeeds.size(), mSeeds.size() - nSeeds, mTrackDataCompact.size());
   }
-  for (int iSeed = nSeeds; iSeed < (int)mSeeds.size(); ++iSeed) {
-    if (!mProcessSeeds && mAddTracksForMapPerTF > 0 && mTrackDataCompact.size() >= mMaxTracksPerTF + mAddTracksForMapPerTF) {
-      LOG(info) << "Maximum number of additional tracks per TF reached. Skipping the remaining " << mSeeds.size() - iSeed << " tracks.";
+  int extraChecked = 0;
+  for (int iSeed : remSeeds) {
+    if (mAddTracksForMapPerTF > 0 && mTrackDataCompact.size() >= mMaxTracksPerTF + mAddTracksForMapPerTF) {
+      LOGP(info, "Maximum number {} of additional tracks per TF reached. Skipping the remaining {} tracks", mAddTracksForMapPerTF, remSeeds.size() - extraChecked);
       break;
     }
-    // this loop will only be entered in case mProcessSeeds is set
-    LOGP(debug, "Processing additional track {}", mGIDs[iSeed].asString());
+    extraChecked++;
     if (mGIDs[iSeed].includesDet(DetID::TRD) || mGIDs[iSeed].includesDet(DetID::TOF)) {
       interpolateTrack(iSeed);
+      LOGP(debug, "extra check {} of {}, seed {} interpolateTrack {}, used: {}", extraChecked, remSeeds.size(), iSeed, GTrackID::getSourceName(mGIDs[iSeed].getSource()), mTrackDataCompact.size());
     } else {
+      LOGP(debug, "extra check {} of {}, seed {} extrapolateTrack {}, used: {}", extraChecked, remSeeds.size(), iSeed, GTrackID::getSourceName(mGIDs[iSeed].getSource()), mTrackDataCompact.size());
       extrapolateTrack(iSeed);
     }
   }

From 1463e6654c567ddf3598c2207ce09b480c6c7fe5 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 14 Aug 2025 13:45:19 +0200
Subject: [PATCH 0702/1764] ITS: add common vertex definition and neighbours
 per road

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/include/ITStracking/Configuration.h |  1 +
 .../ITS/tracking/include/ITStracking/Definitions.h   | 12 +++++++++---
 .../ITS/tracking/include/ITStracking/TimeFrame.h     |  1 -
 .../ITS/tracking/include/ITStracking/TrackerTraits.h |  5 +----
 .../ITS/tracking/include/ITStracking/Vertexer.h      |  4 +---
 Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx  |  2 +-
 .../workflow/include/ITSWorkflow/TrackReaderSpec.h   |  4 +---
 .../workflow/include/ITSWorkflow/VertexReaderSpec.h  |  4 +---
 .../ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx      |  3 +--
 Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx    |  3 +--
 10 files changed, 17 insertions(+), 22 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 19c4617426304..40fe31abbfa36 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -31,6 +31,7 @@ namespace o2::its
 
 struct TrackingParameters {
   int CellMinimumLevel() const noexcept { return MinTrackLength - constants::ClustersPerCell + 1; }
+  int NeighboursPerRoad() const noexcept { return NLayers - 3; }
   int CellsPerRoad() const noexcept { return NLayers - 2; }
   int TrackletsPerRoad() const noexcept { return NLayers - 1; }
   std::string asString() const;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
index 352e13963b6d1..72857794c711e 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
@@ -15,9 +15,7 @@
 #ifndef TRACKINGITS_DEFINITIONS_H_
 #define TRACKINGITS_DEFINITIONS_H_
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <array>
-#endif
+#include "ReconstructionDataFormats/Vertex.h"
 
 #ifdef CA_DEBUG
 #define CA_DEBUGGER(x) x
@@ -26,4 +24,12 @@
   do {                 \
   } while (0)
 #endif
+
+namespace o2::its
+{
+
+using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
+
+}
+
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 5e08e6c48e03a..d9d89e8149e62 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -62,7 +62,6 @@ namespace gpu
 template <int>
 class TimeFrameGPU;
 }
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 template <int nLayers = 7>
 struct TimeFrame {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index cba536324edeb..08961a2c8c1ee 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -16,7 +16,7 @@
 #ifndef TRACKINGITSU_INCLUDE_TRACKERTRAITS_H_
 #define TRACKINGITSU_INCLUDE_TRACKERTRAITS_H_
 
-#include <cmath>
+#include <oneapi/tbb.h>
 
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Configuration.h"
@@ -24,9 +24,6 @@
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/BoundedAllocator.h"
 
-#include <oneapi/tbb.h>
-#include <oneapi/tbb/partitioner.h>
-
 // #define OPTIMISATION_OUTPUT
 
 namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 2b9bfabd80128..47e483c2e9f06 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -26,17 +26,15 @@
 #include <oneapi/tbb/task_arena.h>
 
 #include "ITStracking/Constants.h"
+#include "ITStracking/Definitions.h"
 #include "ITStracking/Configuration.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/VertexerTraits.h"
 #include "ITStracking/BoundedAllocator.h"
-#include "ReconstructionDataFormats/Vertex.h"
 
 namespace o2::its
 {
 
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
 class Vertexer
 {
   static constexpr int NLayers{7};
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 2515f8287d72b..2ebfbfe235c5b 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -481,7 +481,7 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
   };
 
   mTaskArena->execute([&] {
-    for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
+    for (int iLayer{0}; iLayer < mTrkParams[iteration].NeighboursPerRoad(); ++iLayer) {
       deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
       deepVectorClear(mTimeFrame->getCellsNeighboursLUT()[iLayer]);
       if (mTimeFrame->getCells()[iLayer + 1].empty() ||
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackReaderSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackReaderSpec.h
index 600e42e136697..8666864ca1ae9 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackReaderSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackReaderSpec.h
@@ -20,11 +20,11 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "Headers/DataHeader.h"
+#include "ITStracking/Definitions.h"
 #include "DataFormatsITS/TrackITS.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
-#include "ReconstructionDataFormats/Vertex.h"
 
 namespace o2
 {
@@ -33,8 +33,6 @@ namespace its
 
 class TrackReader : public o2::framework::Task
 {
-  using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
  public:
   TrackReader(bool useMC = true);
   ~TrackReader() override = default;
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/VertexReaderSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/VertexReaderSpec.h
index f412640a702ef..b300967408256 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/VertexReaderSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/VertexReaderSpec.h
@@ -19,7 +19,7 @@
 
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
-#include "ReconstructionDataFormats/Vertex.h"
+#include "ITStracking/Definitions.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 
 namespace o2
@@ -30,8 +30,6 @@ namespace its
 
 class VertexReader : public o2::framework::Task
 {
-  using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
  public:
   VertexReader() = default;
   ~VertexReader() override = default;
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
index 9fbb138b376b2..c10b4aa32f054 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
@@ -19,7 +19,7 @@
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
-#include "ReconstructionDataFormats/Vertex.h"
+#include "ITStracking/Definitions.h"
 #include "ITStracking/TrackingConfigParam.h"
 
 using namespace o2::framework;
@@ -28,7 +28,6 @@ namespace o2
 {
 namespace its
 {
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 template <typename T>
 using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index 201f1d064a632..dbfd5edf839ae 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -15,6 +15,7 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
 #include "ITSWorkflow/TrackerSpec.h"
+#include "ITStracking/Definitions.h"
 #include "ITStracking/TrackingConfigParam.h"
 
 namespace o2
@@ -22,8 +23,6 @@ namespace o2
 using namespace framework;
 namespace its
 {
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
 TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        bool isMC,
                        int trgType,

From 947b41ba5a81dcbded154e677036ff9c54f77c15 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 14 Aug 2025 16:00:11 +0200
Subject: [PATCH 0703/1764] Revert "Data Model: provide size when deallocating
 a Stack"

This reverts commit bbef7a7e9362c793039af6a9cf658d170bda33d6.
---
 DataFormats/Headers/include/Headers/Stack.h | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index ce1a71dafd3eb..98fb95e602ecf 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -37,10 +37,9 @@ struct Stack {
 
  private:
   struct freeobj {
-    freeobj(memory_resource* mr, size_t s) : resource(mr), size(s) {}
+    freeobj(memory_resource* mr) : resource(mr) {}
     memory_resource* resource{nullptr};
-    size_t size{0};
-    void operator()(std::byte* ptr) { resource->deallocate(ptr, size, alignof(std::max_align_t)); }
+    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, alignof(std::max_align_t)); }
   };
 
  public:
@@ -101,7 +100,7 @@ struct Stack {
   Stack(const allocator_type allocatorArg, Headers&&... headers)
     : allocator{allocatorArg},
       bufferSize{calculateSize(std::forward<Headers>(headers)...)},
-      buffer{static_cast<std::byte*>(allocator.resource()->allocate(bufferSize, alignof(std::max_align_t))), freeobj{allocator.resource(), bufferSize}}
+      buffer{static_cast<std::byte*>(allocator.resource()->allocate(bufferSize, alignof(std::max_align_t))), freeobj{allocator.resource()}}
   {
     if constexpr (sizeof...(headers) > 1) {
       injectAll(buffer.get(), std::forward<Headers>(headers)...);
@@ -144,7 +143,7 @@ struct Stack {
  private:
   allocator_type allocator{std::pmr::new_delete_resource()};
   size_t bufferSize{0};
-  BufferType buffer{nullptr, freeobj{allocator.resource(), 0}};
+  BufferType buffer{nullptr, freeobj{allocator.resource()}};
 
   //______________________________________________________________________________________________
   template <typename T>

From fe9e22661fc8583d06d5e415d3263f099c9fdc9d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 14 Aug 2025 16:02:35 +0200
Subject: [PATCH 0704/1764] Revert "DPL: move to std::pmr where possible" This
 reverts commit 83467b3c67f9b51545b730c3fff5904419ea2806.

---
 CCDB/include/CCDB/CCDBDownloader.h            |  2 +-
 CCDB/include/CCDB/CcdbApi.h                   | 18 +++++------
 CCDB/src/CcdbApi.cxx                          | 14 ++++-----
 CCDB/test/testCcdbApi.cxx                     |  4 +--
 CCDB/test/testCcdbApiDownloader.cxx           |  6 ++--
 DataFormats/Headers/include/Headers/Stack.h   | 13 ++++----
 DataFormats/Headers/test/testDataHeader.cxx   |  5 ++--
 .../include/MemoryResources/MemoryResources.h | 25 ++++++++++------
 .../test/testMemoryResources.cxx              | 10 ++++---
 .../include/CTPReconstruction/CTFCoder.h      |  3 +-
 .../CTPReconstruction/RawDataDecoder.h        |  6 ++--
 .../CTP/reconstruction/src/RawDataDecoder.cxx |  8 ++---
 .../include/CTPWorkflow/RawDecoderSpec.h      |  2 +-
 .../src/emc-channel-data-producer.cxx         |  4 +--
 .../Clusters/clusters-sampler-workflow.cxx    |  6 ++--
 .../MCH/DevIO/Tracks/TrackSamplerSpec.cxx     |  4 +--
 .../src/ClusterTransformerSpec.cxx            |  2 +-
 .../MUON/MCH/Tracking/src/TrackFinderSpec.cxx |  8 ++---
 .../MCH/Workflow/src/ClusterFinderGEMSpec.cxx |  4 +--
 .../src/ClusterFinderOriginalSpec.cxx         |  8 ++---
 .../workflow/src/TOFIntegrateClusterSpec.cxx  |  6 ++--
 .../TPC/calibration/src/IDCFactorization.cxx  |  2 +-
 .../TPCWorkflow/TPCDistributeIDCSpec.h        |  2 +-
 .../include/TPCWorkflow/TPCFLPIDCSpec.h       |  6 ++--
 .../workflow/test/test_ft_EPN_Aggregator.cxx  |  2 +-
 Detectors/Vertexing/src/SVertexer.cxx         |  2 +-
 Framework/CCDBSupport/src/CCDBHelpers.cxx     |  2 +-
 .../Core/include/Framework/DataAllocator.h    |  9 +++---
 Framework/Core/include/Framework/DataChunk.h  | 30 ++++++++++++-------
 .../Core/include/Framework/MessageContext.h   | 14 ++++-----
 Framework/Core/src/LifetimeHelpers.cxx        |  2 +-
 Framework/Core/test/test_DataAllocator.cxx    |  2 +-
 Framework/Core/test/test_DataRefUtils.cxx     |  1 -
 Framework/Core/test/test_DataRelayer.cxx      |  1 -
 Framework/Core/test/test_FairMQ.cxx           |  7 +++--
 .../Core/test/test_O2DataModelHelpers.cxx     |  1 -
 Framework/Utils/include/DPLUtils/Utils.h      |  2 +-
 37 files changed, 128 insertions(+), 115 deletions(-)

diff --git a/CCDB/include/CCDB/CCDBDownloader.h b/CCDB/include/CCDB/CCDBDownloader.h
index 3ca2e763130df..6c057a537a096 100644
--- a/CCDB/include/CCDB/CCDBDownloader.h
+++ b/CCDB/include/CCDB/CCDBDownloader.h
@@ -41,7 +41,7 @@ namespace o2::ccdb
 #if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
 struct HeaderObjectPair_t {
   std::multimap<std::string, std::string> header;
-  std::pmr::vector<char>* object = nullptr;
+  o2::pmr::vector<char>* object = nullptr;
   int counter = 0;
 };
 
diff --git a/CCDB/include/CCDB/CcdbApi.h b/CCDB/include/CCDB/CcdbApi.h
index 9dc69cd10fc84..e41f58d5c6da9 100644
--- a/CCDB/include/CCDB/CcdbApi.h
+++ b/CCDB/include/CCDB/CcdbApi.h
@@ -355,7 +355,7 @@ class CcdbApi //: public DatabaseInterface
 
 #if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
   typedef struct RequestContext {
-    std::pmr::vector<char>& dest;
+    o2::pmr::vector<char>& dest;
     std::string path;
     std::map<std::string, std::string> const& metadata;
     long timestamp;
@@ -365,7 +365,7 @@ class CcdbApi //: public DatabaseInterface
     std::string createdNotBefore;
     bool considerSnapshot;
 
-    RequestContext(std::pmr::vector<char>& d,
+    RequestContext(o2::pmr::vector<char>& d,
                    std::map<std::string, std::string> const& m,
                    std::map<std::string, std::string>& h)
       : dest(d), metadata(m), headers(h) {}
@@ -379,7 +379,7 @@ class CcdbApi //: public DatabaseInterface
 
   void getFromSnapshot(bool createSnapshot, std::string const& path,
                        long timestamp, std::map<std::string, std::string>& headers,
-                       std::string& snapshotpath, std::pmr::vector<char>& dest, int& fromSnapshot, std::string const& etag) const;
+                       std::string& snapshotpath, o2::pmr::vector<char>& dest, int& fromSnapshot, std::string const& etag) const;
   void releaseNamedSemaphore(boost::interprocess::named_semaphore* sem, std::string const& path) const;
   boost::interprocess::named_semaphore* createNamedSemaphore(std::string const& path) const;
   static std::string determineSemaphoreName(std::string const& basedir, std::string const& objectpath);
@@ -388,22 +388,22 @@ class CcdbApi //: public DatabaseInterface
   static bool removeSemaphore(std::string const& name, bool remove = false);
   static void removeLeakingSemaphores(std::string const& basedir, bool remove = false);
 
-  void loadFileToMemory(std::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders = nullptr, bool fetchLocalMetaData = true) const;
-  void loadFileToMemory(std::pmr::vector<char>& dest, std::string const& path,
+  void loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders = nullptr, bool fetchLocalMetaData = true) const;
+  void loadFileToMemory(o2::pmr::vector<char>& dest, std::string const& path,
                         std::map<std::string, std::string> const& metadata, long timestamp,
                         std::map<std::string, std::string>* headers, std::string const& etag,
                         const std::string& createdNotAfter, const std::string& createdNotBefore, bool considerSnapshot = true) const;
 
   // Loads files from alien and cvmfs into given destination.
-  bool loadLocalContentToMemory(std::pmr::vector<char>& dest, std::string& url) const;
+  bool loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string& url) const;
 
   // add annotated flattened headers in the end of the blob
-  static void appendFlatHeader(std::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers);
+  static void appendFlatHeader(o2::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers);
 
   // the failure to load the file to memory is signaled by 0 size and non-0 capacity
-  static bool isMemoryFileInvalid(const std::pmr::vector<char>& v) { return v.size() == 0 && v.capacity() > 0; }
+  static bool isMemoryFileInvalid(const o2::pmr::vector<char>& v) { return v.size() == 0 && v.capacity() > 0; }
   template <typename T>
-  static T* extractFromMemoryBlob(std::pmr::vector<char>& blob)
+  static T* extractFromMemoryBlob(o2::pmr::vector<char>& blob)
   {
     auto obj = static_cast<T*>(interpretAsTMemFileAndExtract(blob.data(), blob.size(), typeid(T)));
     if constexpr (std::is_base_of<o2::conf::ConfigurableParam, T>::value) {
diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index 541ef28d17ede..27ad14cdf24fa 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -844,7 +844,7 @@ bool CcdbApi::retrieveBlob(std::string const& path, std::string const& targetdir
     return false;
   }
 
-  std::pmr::vector<char> buff;
+  o2::pmr::vector<char> buff;
   std::map<std::string, std::string> headers;
   // avoid creating snapshot via loadFileToMemory itself
   loadFileToMemory(buff, path, metadata, timestamp, &headers, "", createdNotAfter, createdNotBefore, false);
@@ -1830,7 +1830,7 @@ void CcdbApi::removeLeakingSemaphores(std::string const& snapshotdir, bool remov
 
 void CcdbApi::getFromSnapshot(bool createSnapshot, std::string const& path,
                               long timestamp, std::map<std::string, std::string>& headers,
-                              std::string& snapshotpath, std::pmr::vector<char>& dest, int& fromSnapshot, std::string const& etag) const
+                              std::string& snapshotpath, o2::pmr::vector<char>& dest, int& fromSnapshot, std::string const& etag) const
 {
   if (createSnapshot) { // create named semaphore
     std::string logfile = mSnapshotCachePath + "/log";
@@ -1884,7 +1884,7 @@ void CcdbApi::loadFileToMemory(std::vector<char>& dest, std::string const& path,
                                std::map<std::string, std::string>* headers, std::string const& etag,
                                const std::string& createdNotAfter, const std::string& createdNotBefore, bool considerSnapshot) const
 {
-  std::pmr::vector<char> destP;
+  o2::pmr::vector<char> destP;
   destP.reserve(dest.size());
   loadFileToMemory(destP, path, metadata, timestamp, headers, etag, createdNotAfter, createdNotBefore, considerSnapshot);
   dest.clear();
@@ -1894,7 +1894,7 @@ void CcdbApi::loadFileToMemory(std::vector<char>& dest, std::string const& path,
   }
 }
 
-void CcdbApi::loadFileToMemory(std::pmr::vector<char>& dest, std::string const& path,
+void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, std::string const& path,
                                std::map<std::string, std::string> const& metadata, long timestamp,
                                std::map<std::string, std::string>* headers, std::string const& etag,
                                const std::string& createdNotAfter, const std::string& createdNotBefore, bool considerSnapshot) const
@@ -1912,7 +1912,7 @@ void CcdbApi::loadFileToMemory(std::pmr::vector<char>& dest, std::string const&
   vectoredLoadFileToMemory(contexts);
 }
 
-void CcdbApi::appendFlatHeader(std::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers)
+void CcdbApi::appendFlatHeader(o2::pmr::vector<char>& dest, const std::map<std::string, std::string>& headers)
 {
   size_t hsize = getFlatHeaderSize(headers), cnt = dest.size();
   dest.resize(cnt + hsize);
@@ -1977,7 +1977,7 @@ void CcdbApi::vectoredLoadFileToMemory(std::vector<RequestContext>& requestConte
   }
 }
 
-bool CcdbApi::loadLocalContentToMemory(std::pmr::vector<char>& dest, std::string& url) const
+bool CcdbApi::loadLocalContentToMemory(o2::pmr::vector<char>& dest, std::string& url) const
 {
   if (url.find("alien:/", 0) != std::string::npos) {
     std::map<std::string, std::string> localHeaders;
@@ -2005,7 +2005,7 @@ bool CcdbApi::loadLocalContentToMemory(std::pmr::vector<char>& dest, std::string
   return false;
 }
 
-void CcdbApi::loadFileToMemory(std::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders, bool fetchLocalMetaData) const
+void CcdbApi::loadFileToMemory(o2::pmr::vector<char>& dest, const std::string& path, std::map<std::string, std::string>* localHeaders, bool fetchLocalMetaData) const
 {
   // Read file to memory as vector. For special case of the locally cached file retriev metadata stored directly in the file
   constexpr size_t MaxCopySize = 0x1L << 25;
diff --git a/CCDB/test/testCcdbApi.cxx b/CCDB/test/testCcdbApi.cxx
index 84119b099de3b..0ba037710cf62 100644
--- a/CCDB/test/testCcdbApi.cxx
+++ b/CCDB/test/testCcdbApi.cxx
@@ -560,7 +560,7 @@ BOOST_AUTO_TEST_CASE(multi_host_test)
   api.init("http://bogus-host.cern.ch,http://ccdb-test.cern.ch:8080");
   std::map<std::string, std::string> metadata;
   std::map<std::string, std::string> headers;
-  std::pmr::vector<char> dst;
+  o2::pmr::vector<char> dst;
   std::string url = "Analysis/ALICE3/Centrality";
   api.loadFileToMemory(dst, url, metadata, 1645780010602, &headers, "", "", "", true);
   BOOST_CHECK(dst.size() != 0);
@@ -572,7 +572,7 @@ BOOST_AUTO_TEST_CASE(vectored)
   api.init("http://ccdb-test.cern.ch:8080");
 
   int TEST_SAMPLE_SIZE = 5;
-  std::vector<std::pmr::vector<char>> dests(TEST_SAMPLE_SIZE);
+  std::vector<o2::pmr::vector<char>> dests(TEST_SAMPLE_SIZE);
   std::vector<std::map<std::string, std::string>> metadatas(TEST_SAMPLE_SIZE);
   std::vector<std::map<std::string, std::string>> headers(TEST_SAMPLE_SIZE);
 
diff --git a/CCDB/test/testCcdbApiDownloader.cxx b/CCDB/test/testCcdbApiDownloader.cxx
index 8e412dcfa7f76..76686f5ee1c00 100644
--- a/CCDB/test/testCcdbApiDownloader.cxx
+++ b/CCDB/test/testCcdbApiDownloader.cxx
@@ -116,12 +116,12 @@ size_t writeCallbackNoLambda(void* contents, size_t size, size_t nmemb, void* ch
   return realsize;
 }
 
-std::vector<CURL*> prepareAsyncHandles(size_t num, std::vector<std::pmr::vector<char>*>& dests)
+std::vector<CURL*> prepareAsyncHandles(size_t num, std::vector<o2::pmr::vector<char>*>& dests)
 {
   std::vector<CURL*> handles;
 
   for (int i = 0; i < num; i++) {
-    auto dest = new std::pmr::vector<char>();
+    auto dest = new o2::pmr::vector<char>();
     dests.push_back(dest);
     CURL* curl_handle = curl_easy_init();
     handles.push_back(curl_handle);
@@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE(asynch_schedule_test)
   }
 
   CCDBDownloader downloader;
-  std::vector<std::pmr::vector<char>*> dests;
+  std::vector<o2::pmr::vector<char>*> dests;
   auto handles = prepareAsyncHandles(TRANSFERS, dests);
   size_t transfersLeft = 0;
 
diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index 98fb95e602ecf..0958b639ef451 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -11,10 +11,9 @@
 #ifndef O2_HEADERS_STACK_H
 #define O2_HEADERS_STACK_H
 
+#include "MemoryResources/MemoryResources.h"
 #include "Headers/DataHeader.h"
 
-#include <memory_resource>
-
 namespace o2::header
 {
 //__________________________________________________________________________________________________
@@ -33,7 +32,7 @@ namespace o2::header
 ///   - returns a Stack ready to be shipped.
 struct Stack {
 
-  using memory_resource = std::pmr::memory_resource;
+  using memory_resource = o2::pmr::memory_resource;
 
  private:
   struct freeobj {
@@ -43,7 +42,7 @@ struct Stack {
   };
 
  public:
-  using allocator_type = std::pmr::polymorphic_allocator<std::byte>;
+  using allocator_type = fair::mq::pmr::polymorphic_allocator<std::byte>;
   using value_type = std::byte;
   using BufferType = std::unique_ptr<value_type[], freeobj>; // this gives us proper default move semantics for free
 
@@ -88,9 +87,9 @@ struct Stack {
   /// all headers must derive from BaseHeader, in addition also other stacks can be passed to ctor.
   template <typename FirstArgType, typename... Headers,
             typename std::enable_if_t<
-              !std::is_convertible<FirstArgType, std::pmr::polymorphic_allocator<std::byte>>::value, int> = 0>
+              !std::is_convertible<FirstArgType, fair::mq::pmr::polymorphic_allocator<std::byte>>::value, int> = 0>
   Stack(FirstArgType&& firstHeader, Headers&&... headers)
-    : Stack(std::pmr::new_delete_resource(), std::forward<FirstArgType>(firstHeader),
+    : Stack(fair::mq::pmr::new_delete_resource(), std::forward<FirstArgType>(firstHeader),
             std::forward<Headers>(headers)...)
   {
   }
@@ -141,7 +140,7 @@ struct Stack {
   constexpr static size_t calculateSize() { return 0; }
 
  private:
-  allocator_type allocator{std::pmr::new_delete_resource()};
+  allocator_type allocator{fair::mq::pmr::new_delete_resource()};
   size_t bufferSize{0};
   BufferType buffer{nullptr, freeobj{allocator.resource()}};
 
diff --git a/DataFormats/Headers/test/testDataHeader.cxx b/DataFormats/Headers/test/testDataHeader.cxx
index 23a230840fafe..2403c1a6230be 100644
--- a/DataFormats/Headers/test/testDataHeader.cxx
+++ b/DataFormats/Headers/test/testDataHeader.cxx
@@ -314,7 +314,8 @@ BOOST_AUTO_TEST_CASE(headerStack_test)
   BOOST_CHECK(h3->secret == 42);
 
   // test constructing from a buffer and an additional header
-  Stack s5(std::pmr::new_delete_resource(), s1.data(), Stack{}, meta);
+  using namespace fair::mq::pmr;
+  Stack s5(new_delete_resource(), s1.data(), Stack{}, meta);
   BOOST_CHECK(s5.size() == s1.size() + sizeof(meta));
   // check if we can find the header even though there was an empty stack in the middle
   h3 = get<test::MetaHeader*>(s5.data());
@@ -328,7 +329,7 @@ BOOST_AUTO_TEST_CASE(headerStack_test)
   BOOST_CHECK(h4 == h3);
 
   // let's assume we have some stack that is missing the required DataHeader at the beginning:
-  Stack s6{std::pmr::new_delete_resource(), DataHeader{}, s1.data()};
+  Stack s6{new_delete_resource(), DataHeader{}, s1.data()};
   BOOST_CHECK(s6.size() == sizeof(DataHeader) + s1.size());
 }
 
diff --git a/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h b/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
index 66b44162b47ff..b52f5c715575e 100644
--- a/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
+++ b/DataFormats/MemoryResources/include/MemoryResources/MemoryResources.h
@@ -28,6 +28,9 @@
 #ifndef ALICEO2_MEMORY_RESOURCES_
 #define ALICEO2_MEMORY_RESOURCES_
 
+#include <boost/container/pmr/memory_resource.hpp>
+#include <boost/container/pmr/monotonic_buffer_resource.hpp>
+#include <boost/container/pmr/polymorphic_allocator.hpp>
 #include <cstring>
 #include <string>
 #include <type_traits>
@@ -42,8 +45,12 @@
 namespace o2::pmr
 {
 
+using FairMQMemoryResource = fair::mq::MemoryResource;
+using ChannelResource = fair::mq::ChannelResource;
+using namespace fair::mq::pmr;
+
 template <typename ContainerT>
-fair::mq::MessagePtr getMessage(ContainerT&& container, fair::mq::MemoryResource* targetResource = nullptr)
+fair::mq::MessagePtr getMessage(ContainerT&& container, FairMQMemoryResource* targetResource = nullptr)
 {
   return fair::mq::getMessage(std::forward<ContainerT>(container), targetResource);
 }
@@ -53,7 +60,7 @@ fair::mq::MessagePtr getMessage(ContainerT&& container, fair::mq::MemoryResource
 /// Ownership of hte message is taken. Meant to be used for transparent data adoption in containers.
 /// In combination with the SpectatorAllocator this is an alternative to using span, as raw memory
 /// (e.g. an existing buffer message) will be accessible with appropriate container.
-class MessageResource : public fair::mq::MemoryResource
+class MessageResource : public FairMQMemoryResource
 {
 
  public:
@@ -75,7 +82,7 @@ class MessageResource : public fair::mq::MemoryResource
   size_t getNumberOfMessages() const noexcept override { return mMessageData ? 1 : 0; }
 
  protected:
-  fair::mq::MemoryResource* mUpstream{nullptr};
+  FairMQMemoryResource* mUpstream{nullptr};
   size_t mMessageSize{0};
   void* mMessageData{nullptr};
   bool initialImport{true};
@@ -106,14 +113,14 @@ class MessageResource : public fair::mq::MemoryResource
 
 // The NoConstructAllocator behaves like the normal pmr vector but does not call constructors / destructors
 template <typename T>
-class NoConstructAllocator : public std::pmr::polymorphic_allocator<T>
+class NoConstructAllocator : public fair::mq::pmr::polymorphic_allocator<T>
 {
  public:
-  using std::pmr::polymorphic_allocator<T>::polymorphic_allocator;
+  using fair::mq::pmr::polymorphic_allocator<T>::polymorphic_allocator;
   using propagate_on_container_move_assignment = std::true_type;
 
   template <typename... Args>
-  NoConstructAllocator(Args&&... args) : std::pmr::polymorphic_allocator<T>(std::forward<Args>(args)...)
+  NoConstructAllocator(Args&&... args) : fair::mq::pmr::polymorphic_allocator<T>(std::forward<Args>(args)...)
   {
   }
 
@@ -138,13 +145,13 @@ class NoConstructAllocator : public std::pmr::polymorphic_allocator<T>
 //__________________________________________________________________________________________________
 //__________________________________________________________________________________________________
 
-using BytePmrAllocator = std::pmr::polymorphic_allocator<std::byte>;
+using BytePmrAllocator = fair::mq::pmr::polymorphic_allocator<std::byte>;
 template <class T>
-using vector = std::vector<T, std::pmr::polymorphic_allocator<T>>;
+using vector = std::vector<T, fair::mq::pmr::polymorphic_allocator<T>>;
 
 //__________________________________________________________________________________________________
 /// Get the allocator associated to a transport factory
-inline static fair::mq::MemoryResource* getTransportAllocator(fair::mq::TransportFactory* factory)
+inline static FairMQMemoryResource* getTransportAllocator(fair::mq::TransportFactory* factory)
 {
   return *factory;
 }
diff --git a/DataFormats/MemoryResources/test/testMemoryResources.cxx b/DataFormats/MemoryResources/test/testMemoryResources.cxx
index c72ac8f6d422b..a49cd00d75255 100644
--- a/DataFormats/MemoryResources/test/testMemoryResources.cxx
+++ b/DataFormats/MemoryResources/test/testMemoryResources.cxx
@@ -19,7 +19,6 @@
 #include <fairmq/ProgOptions.h>
 #include <vector>
 #include <cstring>
-#include <memory_resource>
 
 namespace o2::pmr
 {
@@ -61,6 +60,8 @@ BOOST_AUTO_TEST_CASE(transportallocatormap_test)
   BOOST_CHECK(_tmp == allocZMQ);
 }
 
+using namespace fair::mq::pmr;
+
 BOOST_AUTO_TEST_CASE(allocator_test)
 {
   size_t session{(size_t)getpid() * 1000 + 1};
@@ -75,7 +76,7 @@ BOOST_AUTO_TEST_CASE(allocator_test)
   testData::nconstructions = 0;
 
   {
-    std::vector<testData, std::pmr::polymorphic_allocator<testData>> v(std::pmr::polymorphic_allocator<testData>{allocZMQ});
+    std::vector<testData, polymorphic_allocator<testData>> v(polymorphic_allocator<testData>{allocZMQ});
     v.reserve(3);
     BOOST_CHECK(v.capacity() == 3);
     BOOST_CHECK(allocZMQ->getNumberOfMessages() == 1);
@@ -109,7 +110,7 @@ BOOST_AUTO_TEST_CASE(getMessage_test)
 
   // test message creation on the same channel it was allocated with
   {
-    std::vector<testData, std::pmr::polymorphic_allocator<testData>> v(std::pmr::polymorphic_allocator<testData>{allocZMQ});
+    std::vector<testData, polymorphic_allocator<testData>> v(polymorphic_allocator<testData>{allocZMQ});
     v.emplace_back(1);
     v.emplace_back(2);
     v.emplace_back(3);
@@ -124,7 +125,7 @@ BOOST_AUTO_TEST_CASE(getMessage_test)
 
   // test message creation on a different channel than it was allocated with
   {
-    std::vector<testData, std::pmr::polymorphic_allocator<testData>> v(std::pmr::polymorphic_allocator<testData>{allocZMQ});
+    std::vector<testData, polymorphic_allocator<testData>> v(polymorphic_allocator<testData>{allocZMQ});
     v.emplace_back(4);
     v.emplace_back(5);
     v.emplace_back(6);
@@ -136,6 +137,7 @@ BOOST_AUTO_TEST_CASE(getMessage_test)
   BOOST_CHECK(message->GetSize() == 3 * sizeof(testData));
   messageArray = static_cast<int*>(message->GetData());
   BOOST_CHECK(messageArray[0] == 4 && messageArray[1] == 5 && messageArray[2] == 6);
+
 }
 
 }; // namespace o2::pmr
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
index 4b3d097417659..9189df5d12685 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
@@ -26,7 +26,6 @@
 #include "CTPReconstruction/CTFHelper.h"
 #include "CTPReconstruction/RawDataDecoder.h"
 #include "DataFormatsCTP/Configuration.h"
-#include <vector>
 
 class TTree;
 
@@ -226,7 +225,7 @@ o2::ctf::CTFIOSize CTFCoder::decode(const CTF::base& ec, VTRG& data, LumiInfo& l
       trgclassmask = mCTPConfig.getTriggerClassMask();
     }
     // std::cout << "trgclassmask:" << std::hex << trgclassmask << std::dec << std::endl;
-    std::pmr::vector<CTPDigit> digits;
+    o2::pmr::vector<CTPDigit> digits;
     o2::ctp::RawDataDecoder::shiftInputs(digitsMap, digits, mFirstTFOrbit, trgclassmask);
     for (auto const& dig : digits) {
       data.emplace_back(dig);
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
index 3027c8aea39fc..53addf32c538f 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/RawDataDecoder.h
@@ -35,7 +35,7 @@ class RawDataDecoder
   ~RawDataDecoder() = default;
   static void makeGBTWordInverse(std::vector<gbtword80_t>& diglets, gbtword80_t& GBTWord, gbtword80_t& remnant, uint32_t& size_gbt, uint32_t Npld);
   int addCTPDigit(uint32_t linkCRU, uint32_t triggerOrbit, gbtword80_t& diglet, gbtword80_t& pldmask, std::map<o2::InteractionRecord, CTPDigit>& digits);
-  int decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, std::pmr::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1);
+  int decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, o2::pmr::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1);
   int decodeRawFatal(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter);
   int decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, std::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1);
   void setDecodeInps(bool decodeinps) { mDecodeInps = decodeinps; }
@@ -54,8 +54,8 @@ class RawDataDecoder
   CTPConfiguration& getCTPConfig() { return mCTPConfig; }
   int init();
   static int shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit, std::bitset<48>& inpmask, int64_t shift, int level, std::map<o2::InteractionRecord, CTPDigit>& digmap);
-  static int shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, std::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask = 0xffffffffffffffff);
-  int checkReadoutConsistentncy(std::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask = 0xffffffffffffffff, uint64_t trigclassmaskNoTrgDets = 0xffffffffffffffff);
+  static int shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask = 0xffffffffffffffff);
+  int checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask = 0xffffffffffffffff, uint64_t trigclassmaskNoTrgDets = 0xffffffffffffffff);
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassErrorsA() { return mClassErrorsA; }
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassErrorsB() { return mClassErrorsB; }
   std::array<uint64_t, o2::ctp::CTP_NCLASSES> getClassCountersA() { return mClassCountersA; }
diff --git a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
index 025e63a786a48..a062a262acf62 100644
--- a/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
+++ b/Detectors/CTP/reconstruction/src/RawDataDecoder.cxx
@@ -128,7 +128,7 @@ int RawDataDecoder::addCTPDigit(uint32_t linkCRU, uint32_t orbit, gbtword80_t& d
 // Decodes one page
 // It is NOT assumed that CTP HBF has never more than one page.
 // 1 HBF/page <= 8000kB = 8*1024*8/120 = 546 GBT words = 546 IRs/page = 5.5 MHz
-int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, std::pmr::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1)
+int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, o2::pmr::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1)
 {
   int ret = 0;
   static int nwrites = 0;
@@ -495,7 +495,7 @@ int RawDataDecoder::decodeRawFatal(o2::framework::InputRecord& inputs, std::vect
 //
 int RawDataDecoder::decodeRaw(o2::framework::InputRecord& inputs, std::vector<o2::framework::InputSpec>& filter, std::vector<CTPDigit>& digits, std::vector<LumiInfo>& lumiPointsHBF1)
 {
-  std::pmr::vector<CTPDigit> pmrdigits;
+  o2::pmr::vector<CTPDigit> pmrdigits;
   int ret = decodeRaw(inputs, filter, pmrdigits, lumiPointsHBF1);
   for (auto const d : pmrdigits) {
     digits.push_back(d);
@@ -532,7 +532,7 @@ int RawDataDecoder::shiftNew(const o2::InteractionRecord& irin, uint32_t TFOrbit
 }
 //
 
-int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, std::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask)
+int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digitsMap, o2::pmr::vector<CTPDigit>& digits, uint32_t TFOrbit, uint64_t trgclassmask)
 {
   // int nClasswoInp = 0; // counting classes without input which should never happen
   int lost = 0;
@@ -598,7 +598,7 @@ int RawDataDecoder::shiftInputs(std::map<o2::InteractionRecord, CTPDigit>& digit
   return lost;
 }
 //
-int RawDataDecoder::checkReadoutConsistentncy(std::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask, uint64_t trgclassmaskNoTrgDet)
+int RawDataDecoder::checkReadoutConsistentncy(o2::pmr::vector<CTPDigit>& digits, uint64_t trgclassmask, uint64_t trgclassmaskNoTrgDet)
 {
   LOG(debug) << "Checking readout";
   int ret = 0;
diff --git a/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h b/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
index 1ba01803f3b19..3198e5c33e219 100644
--- a/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
+++ b/Detectors/CTP/workflow/include/CTPWorkflow/RawDecoderSpec.h
@@ -57,7 +57,7 @@ class RawDecoderSpec : public framework::Task
  private:
   // for digits
   bool mDoDigits = true;
-  std::pmr::vector<CTPDigit> mOutputDigits;
+  o2::pmr::vector<CTPDigit> mOutputDigits;
   int mMaxInputSize = 0;
   bool mMaxInputSizeFatal = 0;
   // for lumi
diff --git a/Detectors/EMCAL/workflow/src/emc-channel-data-producer.cxx b/Detectors/EMCAL/workflow/src/emc-channel-data-producer.cxx
index a0141256ac29d..75e2cdbd9fce3 100644
--- a/Detectors/EMCAL/workflow/src/emc-channel-data-producer.cxx
+++ b/Detectors/EMCAL/workflow/src/emc-channel-data-producer.cxx
@@ -128,7 +128,7 @@ DataProcessorSpec generateData(const std::string nameRootFile, const std::string
 
         // loop over cells
         // ToDo: Make more realistic assumption that we dont always have the same amount of cells per event
-        std::pmr::vector<o2::emcal::Cell> CellOutput;
+        o2::pmr::vector<o2::emcal::Cell> CellOutput;
         for (int i = 0; i < nCellsPerEvent; ++i) {
           double cellID = 0;
           double cellE = 0;
@@ -157,7 +157,7 @@ DataProcessorSpec generateData(const std::string nameRootFile, const std::string
         }
         // send output
         LOG(debug) << "sending " << CellOutput.size() << "cells";
-        std::pmr::vector<o2::emcal::TriggerRecord> TriggerOutput;
+        o2::pmr::vector<o2::emcal::TriggerRecord> TriggerOutput;
         TriggerOutput.emplace_back(0, 0, 0, CellOutput.size());
 
         ctx.outputs().adoptContainer(Output{o2::header::gDataOriginEMC, "CELLS", 0}, std::move(CellOutput));
diff --git a/Detectors/MUON/MCH/DevIO/Clusters/clusters-sampler-workflow.cxx b/Detectors/MUON/MCH/DevIO/Clusters/clusters-sampler-workflow.cxx
index 95c748f1cc6f1..9d98ada911df2 100644
--- a/Detectors/MUON/MCH/DevIO/Clusters/clusters-sampler-workflow.cxx
+++ b/Detectors/MUON/MCH/DevIO/Clusters/clusters-sampler-workflow.cxx
@@ -101,7 +101,7 @@ class ClusterSamplerTask
     // create the output messages
     auto& rofs = pc.outputs().make<std::vector<ROFRecord>>(OutputRef{"rofs"});
     auto& clusters = pc.outputs().make<std::vector<Cluster>>(OutputRef{"clusters"});
-    std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>* digits(nullptr);
+    std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>* digits(nullptr);
     if (mDoDigits) {
       digits = &pc.outputs().make<std::vector<Digit>>(OutputRef{"digits"});
     }
@@ -115,8 +115,8 @@ class ClusterSamplerTask
 
  private:
   //_________________________________________________________________________________________________
-  int readOneEvent(std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters,
-                   std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>* digits)
+  int readOneEvent(std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters,
+                   std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>* digits)
   {
     /// fill the internal buffers with the clusters and digits of the current event
 
diff --git a/Detectors/MUON/MCH/DevIO/Tracks/TrackSamplerSpec.cxx b/Detectors/MUON/MCH/DevIO/Tracks/TrackSamplerSpec.cxx
index 27291af10e3b0..4a53659e2732b 100644
--- a/Detectors/MUON/MCH/DevIO/Tracks/TrackSamplerSpec.cxx
+++ b/Detectors/MUON/MCH/DevIO/Tracks/TrackSamplerSpec.cxx
@@ -102,8 +102,8 @@ class TrackSamplerTask
   }
 
   //_________________________________________________________________________________________________
-  int readOneEvent(std::vector<TrackMCH, std::pmr::polymorphic_allocator<TrackMCH>>& tracks,
-                   std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters)
+  int readOneEvent(std::vector<TrackMCH, o2::pmr::polymorphic_allocator<TrackMCH>>& tracks,
+                   std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters)
   {
     /// fill the output messages with the tracks and attached clusters of the current event
     /// modify the references to the attached clusters according to their position in the global vector
diff --git a/Detectors/MUON/MCH/Geometry/Transformer/src/ClusterTransformerSpec.cxx b/Detectors/MUON/MCH/Geometry/Transformer/src/ClusterTransformerSpec.cxx
index 1f71af86078a8..f70f9574b6974 100644
--- a/Detectors/MUON/MCH/Geometry/Transformer/src/ClusterTransformerSpec.cxx
+++ b/Detectors/MUON/MCH/Geometry/Transformer/src/ClusterTransformerSpec.cxx
@@ -42,7 +42,7 @@ namespace o2::mch
 // convert all clusters from local to global reference frames
 void local2global(geo::TransformationCreator transformation,
                   gsl::span<const Cluster> localClusters,
-                  std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& globalClusters)
+                  std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& globalClusters)
 {
   int i{0};
   globalClusters.insert(globalClusters.end(), localClusters.begin(), localClusters.end());
diff --git a/Detectors/MUON/MCH/Tracking/src/TrackFinderSpec.cxx b/Detectors/MUON/MCH/Tracking/src/TrackFinderSpec.cxx
index c21249527cb23..6239186309dc3 100644
--- a/Detectors/MUON/MCH/Tracking/src/TrackFinderSpec.cxx
+++ b/Detectors/MUON/MCH/Tracking/src/TrackFinderSpec.cxx
@@ -145,7 +145,7 @@ class TrackFinderTask
     auto& trackROFs = pc.outputs().make<std::vector<ROFRecord>>(OutputRef{"trackrofs"});
     auto& mchTracks = pc.outputs().make<std::vector<TrackMCH>>(OutputRef{"tracks"});
     auto& usedClusters = pc.outputs().make<std::vector<Cluster>>(OutputRef{"trackclusters"});
-    std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>* usedDigits(nullptr);
+    std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>* usedDigits(nullptr);
     if (mDigits) {
       usedDigits = &pc.outputs().make<std::vector<Digit>>(OutputRef{"trackdigits"});
     }
@@ -219,9 +219,9 @@ class TrackFinderTask
   //_________________________________________________________________________________________________
   void writeTracks(const std::list<Track>& tracks, const gsl::span<const Digit>& digitsIn,
                    const ROFRecord& clusterROF, uint32_t firstTForbit,
-                   std::vector<TrackMCH, std::pmr::polymorphic_allocator<TrackMCH>>& mchTracks,
-                   std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& usedClusters,
-                   std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>* usedDigits) const
+                   std::vector<TrackMCH, o2::pmr::polymorphic_allocator<TrackMCH>>& mchTracks,
+                   std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& usedClusters,
+                   std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>* usedDigits) const
   {
     /// fill the output messages with tracks and attached clusters and digits if requested
 
diff --git a/Detectors/MUON/MCH/Workflow/src/ClusterFinderGEMSpec.cxx b/Detectors/MUON/MCH/Workflow/src/ClusterFinderGEMSpec.cxx
index 2af245d453702..5158cc436b277 100644
--- a/Detectors/MUON/MCH/Workflow/src/ClusterFinderGEMSpec.cxx
+++ b/Detectors/MUON/MCH/Workflow/src/ClusterFinderGEMSpec.cxx
@@ -303,8 +303,8 @@ class ClusterFinderGEMTask
 
  private:
   //_________________________________________________________________________________________________
-  void writeClusters(std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters,
-                     std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>& usedDigits) const
+  void writeClusters(std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters,
+                     std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>& usedDigits) const
   {
     /// fill the output messages with clusters and attached digits of the current event
     /// modify the references to the attached digits according to their position in the global vector
diff --git a/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx b/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
index b0890e3e6c7e2..8344d2837b814 100644
--- a/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
+++ b/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
@@ -144,8 +144,8 @@ class ClusterFinderOriginalTask
  private:
   //_________________________________________________________________________________________________
   void writeClusters(const gsl::span<const Digit>& preclusterDigits, size_t firstClusterIdx,
-                     std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters,
-                     std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>& usedDigits) const
+                     std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters,
+                     std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>& usedDigits) const
   {
     /// fill the output messages with the new clusters and all the digits from the corresponding precluster
     /// modify the references to the attached digits according to their position in the global vector
@@ -167,8 +167,8 @@ class ClusterFinderOriginalTask
   }
 
   //_________________________________________________________________________________________________
-  void writeClusters(std::vector<Cluster, std::pmr::polymorphic_allocator<Cluster>>& clusters,
-                     std::vector<Digit, std::pmr::polymorphic_allocator<Digit>>& usedDigits) const
+  void writeClusters(std::vector<Cluster, o2::pmr::polymorphic_allocator<Cluster>>& clusters,
+                     std::vector<Digit, o2::pmr::polymorphic_allocator<Digit>>& usedDigits) const
   {
     /// fill the output messages with clusters and attached digits of the current event
     /// modify the references to the attached digits according to their position in the global vector
diff --git a/Detectors/TOF/workflow/src/TOFIntegrateClusterSpec.cxx b/Detectors/TOF/workflow/src/TOFIntegrateClusterSpec.cxx
index f3e561a0c531d..2b647f9236611 100644
--- a/Detectors/TOF/workflow/src/TOFIntegrateClusterSpec.cxx
+++ b/Detectors/TOF/workflow/src/TOFIntegrateClusterSpec.cxx
@@ -60,8 +60,8 @@ class TOFIntegrateClusters : public Task
     const float sliceWidthMSinv = 1. / float(sliceWidthMS);
 
     // storage for integrated currents
-    std::pmr::vector<float> iTOFCNCl(nSlices);
-    std::pmr::vector<float> iTOFCqTot(nSlices);
+    o2::pmr::vector<float> iTOFCNCl(nSlices);
+    o2::pmr::vector<float> iTOFCqTot(nSlices);
 
     const auto clusters = pc.inputs().get<gsl::span<o2::tof::Cluster>>("tofcluster");
     if (mTagNoise) {
@@ -106,7 +106,7 @@ class TOFIntegrateClusters : public Task
   std::vector<int> mCounterNeighbours;                    ///< buffer for noise removal (contains number of neighbouring cluster for time +-mTimeCutNoisePS)
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest; ///< info for CCDB request
 
-  void sendOutput(ProcessingContext& pc, std::pmr::vector<float> iTOFCNCl, std::pmr::vector<float> iTOFCqTot)
+  void sendOutput(ProcessingContext& pc, o2::pmr::vector<float> iTOFCNCl, o2::pmr::vector<float> iTOFCqTot)
   {
     pc.outputs().adoptContainer(Output{header::gDataOriginTOF, "ITOFCN"}, std::move(iTOFCNCl));
     pc.outputs().adoptContainer(Output{header::gDataOriginTOF, "ITOFCQ"}, std::move(iTOFCqTot));
diff --git a/Detectors/TPC/calibration/src/IDCFactorization.cxx b/Detectors/TPC/calibration/src/IDCFactorization.cxx
index cc60be31acb54..e5474016e7b98 100644
--- a/Detectors/TPC/calibration/src/IDCFactorization.cxx
+++ b/Detectors/TPC/calibration/src/IDCFactorization.cxx
@@ -1241,4 +1241,4 @@ bool o2::tpc::IDCFactorization::checkReceivedIDCs()
   return idcsGood;
 }
 
-template void o2::tpc::IDCFactorization::calcIDCOne(const std::pmr::vector<float>&, const int, const int, const unsigned int, const CRU, std::vector<std::vector<float>>&, const IDCZero*, const CalDet<PadFlags>*, const bool);
+template void o2::tpc::IDCFactorization::calcIDCOne(const o2::pmr::vector<float>&, const int, const int, const unsigned int, const CRU, std::vector<std::vector<float>>&, const IDCZero*, const CalDet<PadFlags>*, const bool);
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeIDCSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeIDCSpec.h
index e0c1a87d939ae..6e589cd6c4e8b 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeIDCSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeIDCSpec.h
@@ -247,7 +247,7 @@ class TPCDistributeIDCSpec : public o2::framework::Task
   std::vector<InputSpec> mFilter{};                                                    ///< filter for looping over input data
   std::vector<header::DataDescription> mDataDescrOut{};
 
-  void sendOutput(o2::framework::ProcessingContext& pc, const unsigned int currentOutLane, const unsigned int cru, std::pmr::vector<float> idcs)
+  void sendOutput(o2::framework::ProcessingContext& pc, const unsigned int currentOutLane, const unsigned int cru, o2::pmr::vector<float> idcs)
   {
     pc.outputs().adoptContainer(Output{gDataOriginTPC, mDataDescrOut[currentOutLane], header::DataHeader::SubSpecificationType{cru}}, std::move(idcs));
   }
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
index 6f6ff249c1935..ec3e158590661 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
@@ -93,7 +93,7 @@ class TPCFLPIDCDevice : public o2::framework::Task
       ++mCountTFsForBuffer;
       auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
       const int cru = tpcCRUHeader->subSpecification >> 7;
-      auto vecIDCs = pc.inputs().get<std::pmr::vector<float>>(ref);
+      auto vecIDCs = pc.inputs().get<o2::pmr::vector<float>>(ref);
       mIDCs[cru].insert(mIDCs[cru].end(), vecIDCs.begin(), vecIDCs.end());
 
       if (mEnableSynchProc) {
@@ -164,7 +164,7 @@ class TPCFLPIDCDevice : public o2::framework::Task
   bool mDumpIDCs{};                                                                                                                                                                                  ///< dump IDCs to tree for debugging
   int mCountTFsForBuffer{0};                                                                                                                                                                         ///< count processed TFs to track when the output will be send
   std::pair<std::vector<float>, std::vector<unsigned int>> mOneDIDCs{};                                                                                                                              ///< 1D-IDCs which will be send to the EPNs
-  std::unordered_map<unsigned int, std::pmr::vector<float>> mIDCs{};                                                                                                                                 ///< object for averaging and grouping of the IDCs
+  std::unordered_map<unsigned int, o2::pmr::vector<float>> mIDCs{};                                                                                                                                  ///< object for averaging and grouping of the IDCs
   std::unordered_map<unsigned int, std::deque<std::pair<std::vector<float>, std::vector<unsigned int>>>> mBuffer1DIDCs{};                                                                            ///< buffer for 1D-IDCs. The buffered 1D-IDCs for n TFs will be send to the EPNs for synchronous reco. Zero initialized to avoid empty first TFs!
   CalDet<PadFlags>* mPadFlagsMap{nullptr};                                                                                                                                                           ///< status flag for each pad (i.e. if the pad is dead)
   IDCZero mIDCZero{};                                                                                                                                                                                ///< I_0(r,\phi) = <I(r,\phi,t)>_t: Used for calculating IDC1 (provided from input file or CCDB)
@@ -173,7 +173,7 @@ class TPCFLPIDCDevice : public o2::framework::Task
   /// update the time dependent parameters if they have changed (i.e. update the pad status map)
   void updateTimeDependentParams(ProcessingContext& pc) { pc.inputs().get<o2::tpc::CalDet<PadFlags>*>("tpcpadmap").get(); }
 
-  void sendOutputSync(DataAllocator& output, const std::pmr::vector<float>& idc, const uint32_t cru)
+  void sendOutputSync(DataAllocator& output, const o2::pmr::vector<float>& idc, const uint32_t cru)
   {
     const header::DataHeader::SubSpecificationType subSpec{cru << 7};
     const CRU cruTmp(cru);
diff --git a/Detectors/TPC/workflow/test/test_ft_EPN_Aggregator.cxx b/Detectors/TPC/workflow/test/test_ft_EPN_Aggregator.cxx
index f8236756b27cb..e8255f98eff6c 100644
--- a/Detectors/TPC/workflow/test/test_ft_EPN_Aggregator.cxx
+++ b/Detectors/TPC/workflow/test/test_ft_EPN_Aggregator.cxx
@@ -230,7 +230,7 @@ DataProcessorSpec generateIDCsCRU(int lane, const unsigned int maxTFs, const std
           o2::tpc::CRU cruTmp(icru);
           const unsigned int nPads = o2::tpc::Mapper::PADSPERREGION[cruTmp.region()];
           const int cru = (icru + tf * Mapper::NREGIONS) % o2::tpc::CRU::MaxCRU; // shuffle CRUs
-          std::pmr::vector<float> idcs;
+          o2::pmr::vector<float> idcs;
           idcs.reserve(generateIDCs ? o2::tpc::Mapper::PADSPERREGION[cruTmp.region()] : mIDCs[cru].size());
           const int nIntervals = intervalsRand.size();
           for (int interval = 0; interval < nIntervals; ++interval) {
diff --git a/Detectors/Vertexing/src/SVertexer.cxx b/Detectors/Vertexing/src/SVertexer.cxx
index edaf523cddb41..1d48bcceb0097 100644
--- a/Detectors/Vertexing/src/SVertexer.cxx
+++ b/Detectors/Vertexing/src/SVertexer.cxx
@@ -216,7 +216,7 @@ void SVertexer::produceOutput(o2::framework::ProcessingContext& pc)
 
     auto& strTracksOut = pc.outputs().make<std::vector<o2::dataformats::StrangeTrack>>(o2f::Output{"GLO", "STRANGETRACKS", 0});
     auto& strClustOut = pc.outputs().make<std::vector<o2::strangeness_tracking::ClusAttachments>>(o2f::Output{"GLO", "CLUSUPDATES", 0});
-    std::pmr::vector<o2::MCCompLabel> mcLabsOut;
+    o2::pmr::vector<o2::MCCompLabel> mcLabsOut;
     strTracksOut.resize(mNStrangeTracks);
     strClustOut.resize(mNStrangeTracks);
     if (mStrTracker->getMCTruthOn()) {
diff --git a/Framework/CCDBSupport/src/CCDBHelpers.cxx b/Framework/CCDBSupport/src/CCDBHelpers.cxx
index 2d44469c641f4..1428e22e86651 100644
--- a/Framework/CCDBSupport/src/CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/CCDBHelpers.cxx
@@ -206,7 +206,7 @@ void initialiseHelper(CCDBFetcherHelper& helper, ConfigParamRegistry const& opti
   }
 }
 
-auto getOrbitResetTime(std::pmr::vector<char> const& v) -> Long64_t
+auto getOrbitResetTime(o2::pmr::vector<char> const& v) -> Long64_t
 {
   Int_t previousErrorLevel = gErrorIgnoreLevel;
   gErrorIgnoreLevel = kFatal;
diff --git a/Framework/Core/include/Framework/DataAllocator.h b/Framework/Core/include/Framework/DataAllocator.h
index c5aa4bbffa480..287513ec85845 100644
--- a/Framework/Core/include/Framework/DataAllocator.h
+++ b/Framework/Core/include/Framework/DataAllocator.h
@@ -32,7 +32,6 @@
 #include <gsl/span>
 
 #include <memory>
-#include <memory_resource>
 #include <vector>
 #include <map>
 #include <string>
@@ -450,7 +449,7 @@ class DataAllocator
   }
 
   // get the memory resource associated with an output
-  std::pmr::memory_resource* getMemoryResource(const Output& spec)
+  o2::pmr::FairMQMemoryResource* getMemoryResource(const Output& spec)
   {
     auto& timingInfo = mRegistry.get<TimingInfo>();
     auto& proxy = mRegistry.get<FairMQDeviceProxy>();
@@ -460,10 +459,10 @@ class DataAllocator
 
   // make a stl (pmr) vector
   template <typename T, typename... Args>
-  std::pmr::vector<T> makeVector(const Output& spec, Args&&... args)
+  o2::pmr::vector<T> makeVector(const Output& spec, Args&&... args)
   {
-    std::pmr::memory_resource* targetResource = getMemoryResource(spec);
-    return std::pmr::vector<T>{targetResource, std::forward<Args>(args)...};
+    o2::pmr::FairMQMemoryResource* targetResource = getMemoryResource(spec);
+    return o2::pmr::vector<T>{targetResource, std::forward<Args>(args)...};
   }
 
   struct CacheId {
diff --git a/Framework/Core/include/Framework/DataChunk.h b/Framework/Core/include/Framework/DataChunk.h
index bbb1c44098f46..664092216a0ee 100644
--- a/Framework/Core/include/Framework/DataChunk.h
+++ b/Framework/Core/include/Framework/DataChunk.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -8,13 +8,14 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-#ifndef O2_FRAMEWORK_DATACHUNK_H_
-#define O2_FRAMEWORK_DATACHUNK_H_
+#ifndef FRAMEWORK_DATACHUNK_H
+#define FRAMEWORK_DATACHUNK_H
 
-#include <memory_resource>
-#include <vector>
+#include "MemoryResources/MemoryResources.h"
 
-namespace o2::framework
+namespace o2
+{
+namespace framework
 {
 /// @class DataChunk A resizable buffer used with DPL's DataAllocator
 /// DataChunk derives from std::vector with polymorphic allocator and forbids copying, the underlying
@@ -22,11 +23,18 @@ namespace o2::framework
 /// message memory.
 /// Since MessageContext returns the object by reference, the forbidden copy and assignment makes sure that
 /// the code can not accidentally use a copy instead reference.
-class DataChunk : public std::vector<char, std::pmr::polymorphic_allocator<char>>
+class DataChunk : public std::vector<char, o2::pmr::polymorphic_allocator<char>>
 {
  public:
+  // FIXME: want to have a general forwarding, but then the copy constructor is not deleted any more despite
+  // it's declared deleted
+  //template <typename... Args>
+  //DataChunk(T&& arg, Args&&... args) : std::vector<char, o2::pmr::polymorphic_allocator<char>>(std::forward<Args>(args)...)
+  //{
+  //}
+
   // DataChunk is special and for the moment it's enough to declare the constructor with size and allocator
-  DataChunk(size_t size, const std::pmr::polymorphic_allocator<char>& allocator) : std::vector<char, std::pmr::polymorphic_allocator<char>>(size, allocator)
+  DataChunk(size_t size, const o2::pmr::polymorphic_allocator<char>& allocator) : std::vector<char, o2::pmr::polymorphic_allocator<char>>(size, allocator)
   {
   }
   DataChunk(const DataChunk&) = delete;
@@ -35,6 +43,6 @@ class DataChunk : public std::vector<char, std::pmr::polymorphic_allocator<char>
   DataChunk& operator=(DataChunk&&) = default;
 };
 
-} // namespace o2::framework
-
-#endif // O2_FRAMEWORK_DATACHUNK_H_
+} // namespace framework
+} // namespace o2
+#endif // FRAMEWORK_DATACHUNK_H
diff --git a/Framework/Core/include/Framework/MessageContext.h b/Framework/Core/include/Framework/MessageContext.h
index 4b0047e3e33ad..407bac0ceb00a 100644
--- a/Framework/Core/include/Framework/MessageContext.h
+++ b/Framework/Core/include/Framework/MessageContext.h
@@ -28,11 +28,11 @@
 #include <fairmq/Parts.h>
 
 #include <cassert>
+#include <functional>
 #include <string>
 #include <type_traits>
 #include <unordered_map>
 #include <vector>
-#include <memory_resource>
 
 #include <fairmq/FwdDecls.h>
 
@@ -182,7 +182,7 @@ class MessageContext
 
   // A memory resource which can force a minimum alignment, so that
   // the whole polymorphic allocator business is happy...
-  class AlignedMemoryResource : public fair::mq::MemoryResource
+  class AlignedMemoryResource : public pmr::FairMQMemoryResource
   {
    public:
     AlignedMemoryResource(fair::mq::MemoryResource* other)
@@ -230,7 +230,7 @@ class MessageContext
       return mUpstream->deallocate(p, bytes, alignment < 64 ? 64 : alignment);
     }
 
-    [[nodiscard]] bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override
+    [[nodiscard]] bool do_is_equal(const pmr::memory_resource& other) const noexcept override
     {
       return this == &other;
     }
@@ -240,7 +240,7 @@ class MessageContext
   };
 
   /// ContainerRefObject handles a message object holding an instance of type T
-  /// The allocator type is required to be std::pmr::polymorphic_allocator
+  /// The allocator type is required to be o2::pmr::polymorphic_allocator
   /// can not adopt an existing message, because the polymorphic_allocator will call type constructor,
   /// so this works only with new messages
   /// FIXME: not sure if we want to have this for all container types
@@ -251,7 +251,7 @@ class MessageContext
     using value_type = typename T::value_type;
     using return_type = T;
     using buffer_type = return_type;
-    static_assert(std::is_base_of<std::pmr::polymorphic_allocator<value_type>, typename T::allocator_type>::value, "container must have polymorphic allocator");
+    static_assert(std::is_base_of<o2::pmr::polymorphic_allocator<value_type>, typename T::allocator_type>::value, "container must have polymorphic allocator");
     /// default contructor forbidden, object always has to control message instances
     ContainerRefObject() = delete;
     /// constructor taking header message by move and creating the paypload message
@@ -263,7 +263,7 @@ class MessageContext
         // the memory resource takes ownership of the message
         mResource{mFactory ? AlignedMemoryResource(mFactory->GetMemoryResource()) : AlignedMemoryResource(nullptr)},
         // create the vector with apropriate underlying memory resource for the message
-        mData{std::forward<Args>(args)..., std::pmr::polymorphic_allocator<value_type>(&mResource)}
+        mData{std::forward<Args>(args)..., pmr::polymorphic_allocator<value_type>(&mResource)}
     {
       // FIXME: drop this repeated check and make sure at initial setup of devices that everything is fine
       // introduce error policy
@@ -313,7 +313,7 @@ class MessageContext
   /// VectorObject handles a message object holding std::vector with polymorphic_allocator
   /// can not adopt an existing message, because the polymorphic_allocator will call the element constructor,
   /// so this works only with new messages
-  template <typename T, typename _BASE = ContainerRefObject<std::vector<T, std::pmr::polymorphic_allocator<T>>>>
+  template <typename T, typename _BASE = ContainerRefObject<std::vector<T, o2::pmr::polymorphic_allocator<T>>>>
   class VectorObject : public _BASE
   {
    public:
diff --git a/Framework/Core/src/LifetimeHelpers.cxx b/Framework/Core/src/LifetimeHelpers.cxx
index 439e6f852123a..21aa29c1f10e9 100644
--- a/Framework/Core/src/LifetimeHelpers.cxx
+++ b/Framework/Core/src/LifetimeHelpers.cxx
@@ -353,7 +353,7 @@ size_t readToMessage(void* p, size_t size, size_t nmemb, void* userdata)
   if (size == 0) {
     return 0;
   }
-  auto* buffer = (std::pmr::vector<char>*)userdata;
+  auto* buffer = (o2::pmr::vector<char>*)userdata;
   size_t oldSize = buffer->size();
   buffer->resize(oldSize + nmemb * size);
   memcpy(buffer->data() + oldSize, p, nmemb * size);
diff --git a/Framework/Core/test/test_DataAllocator.cxx b/Framework/Core/test/test_DataAllocator.cxx
index 739c999e868b9..fefb6438b98d5 100644
--- a/Framework/Core/test/test_DataAllocator.cxx
+++ b/Framework/Core/test/test_DataAllocator.cxx
@@ -144,7 +144,7 @@ DataProcessorSpec getSourceSpec()
 
     // make a PMR std::vector, make it large to test the auto transport buffer resize funtionality as well
     Output pmrOutputSpec{"TST", "PMRTESTVECTOR", 0};
-    auto pmrvec = std::pmr::vector<o2::test::TriviallyCopyable>(pc.outputs().getMemoryResource(pmrOutputSpec));
+    auto pmrvec = o2::pmr::vector<o2::test::TriviallyCopyable>(pc.outputs().getMemoryResource(pmrOutputSpec));
     pmrvec.reserve(100);
     pmrvec.emplace_back(o2::test::TriviallyCopyable{1, 2, 3});
     pc.outputs().adoptContainer(pmrOutputSpec, std::move(pmrvec));
diff --git a/Framework/Core/test/test_DataRefUtils.cxx b/Framework/Core/test/test_DataRefUtils.cxx
index a0bc4dec49df6..d4accde0fecf0 100644
--- a/Framework/Core/test/test_DataRefUtils.cxx
+++ b/Framework/Core/test/test_DataRefUtils.cxx
@@ -15,7 +15,6 @@
 #include <TMessage.h>
 #include "Framework/RootSerializationSupport.h"
 #include "Framework/DataRefUtils.h"
-#include <fairmq/TransportFactory.h>
 #include <catch_amalgamated.hpp>
 
 #include <memory>
diff --git a/Framework/Core/test/test_DataRelayer.cxx b/Framework/Core/test/test_DataRelayer.cxx
index 5f6cde4078540..7d5a3ded88e16 100644
--- a/Framework/Core/test/test_DataRelayer.cxx
+++ b/Framework/Core/test/test_DataRelayer.cxx
@@ -26,7 +26,6 @@
 #include "Framework/WorkflowSpec.h"
 #include <Monitoring/Monitoring.h>
 #include <fairmq/TransportFactory.h>
-#include <fairmq/MemoryResources.h>
 #include <array>
 #include <vector>
 #include <uv.h>
diff --git a/Framework/Core/test/test_FairMQ.cxx b/Framework/Core/test/test_FairMQ.cxx
index e80741c143060..f11d98505298f 100644
--- a/Framework/Core/test/test_FairMQ.cxx
+++ b/Framework/Core/test/test_FairMQ.cxx
@@ -27,7 +27,7 @@ using namespace o2::pmr;
 //__________________________________________________________________________________________________
 // addDataBlock for generic (compatible) containers, that is contiguous containers using the pmr allocator
 template <typename ContainerT, typename std::enable_if<!std::is_same<ContainerT, fair::mq::MessagePtr>::value, int>::type = 0>
-bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, ContainerT&& inputData, fair::mq::MemoryResource* targetResource = nullptr)
+bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, ContainerT&& inputData, o2::pmr::FairMQMemoryResource* targetResource = nullptr)
 {
   auto headerMessage = o2::pmr::getMessage(std::move(inputStack), targetResource);
   auto dataMessage = o2::pmr::getMessage(std::forward<ContainerT>(inputData), targetResource);
@@ -42,7 +42,7 @@ bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, Contai
 // addDataBlock for data already wrapped in fair::mq::MessagePtr
 // note: since we cannot partially specialize function templates, use SFINAE here instead
 template <typename ContainerT, typename std::enable_if<std::is_same<ContainerT, fair::mq::MessagePtr>::value, int>::type = 0>
-bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, ContainerT&& dataMessage, fair::mq::MemoryResource* targetResource = nullptr)
+bool addDataBlock(fair::mq::Parts& parts, o2::header::Stack&& inputStack, ContainerT&& dataMessage, o2::pmr::FairMQMemoryResource* targetResource = nullptr)
 {
   // make sure the payload size in DataHeader corresponds to message size
   using o2::header::DataHeader;
@@ -174,8 +174,9 @@ TEST_CASE("addDataBlockForEach_test")
       int i;
       int j;
     };
+    using namespace fair::mq::pmr;
     fair::mq::Parts message;
-    std::vector<elem, std::pmr::polymorphic_allocator<elem>> vec(std::pmr::polymorphic_allocator<elem>{allocZMQ});
+    std::vector<elem, polymorphic_allocator<elem>> vec(polymorphic_allocator<elem>{allocZMQ});
     vec.reserve(100);
     vec.push_back({1, 2});
     vec.push_back({3, 4});
diff --git a/Framework/Core/test/test_O2DataModelHelpers.cxx b/Framework/Core/test/test_O2DataModelHelpers.cxx
index 98a269ed3a907..c32738699c222 100644
--- a/Framework/Core/test/test_O2DataModelHelpers.cxx
+++ b/Framework/Core/test/test_O2DataModelHelpers.cxx
@@ -13,7 +13,6 @@
 #include "Framework/DataProcessingHeader.h"
 #include "Headers/DataHeader.h"
 #include "Headers/Stack.h"
-#include "MemoryResources/MemoryResources.h"
 #include <fairmq/TransportFactory.h>
 #include <catch_amalgamated.hpp>
 
diff --git a/Framework/Utils/include/DPLUtils/Utils.h b/Framework/Utils/include/DPLUtils/Utils.h
index 93758fbfe53db..8786a579fdc53 100644
--- a/Framework/Utils/include/DPLUtils/Utils.h
+++ b/Framework/Utils/include/DPLUtils/Utils.h
@@ -37,7 +37,7 @@ o2f::DataProcessorSpec defineBroadcaster(std::string devName, o2f::InputSpec usr
                                          size_t fixMsgSize);
 o2f::DataProcessorSpec defineBroadcaster(std::string devName, o2f::InputSpec usrInput, o2f::Outputs usrOutputs);
 
-using OutputBuffer = std::pmr::vector<char>;
+using OutputBuffer = o2::pmr::vector<char>;
 // Merger implementations
 o2f::DataProcessorSpec defineMerger(std::string devName, o2f::Inputs usrInputs, o2f::OutputSpec usrOutput,
                                     std::function<void(OutputBuffer, const o2f::DataRef)> const mergerFunc);

From 3cafea04f8903980abd8706d0efd36981ac1396c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 14 Aug 2025 16:03:38 +0200
Subject: [PATCH 0705/1764] Revert "Fix alignment so that jemalloc / address
 sanitizer do no complain"

This reverts commit 02b6dc2d9938ae3c857570cb7d39d554ab200536.
---
 DataFormats/Headers/include/Headers/Stack.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index 0958b639ef451..40987c483e1b8 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -38,7 +38,7 @@ struct Stack {
   struct freeobj {
     freeobj(memory_resource* mr) : resource(mr) {}
     memory_resource* resource{nullptr};
-    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, alignof(std::max_align_t)); }
+    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, 0); }
   };
 
  public:

From 65275d977a8dc28136420ce132dde21fda3e29eb Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 14 Aug 2025 23:18:55 +0200
Subject: [PATCH 0706/1764] DPL Analysis: use offset cache for sorted grouping
 (#14571)

---
 .../Framework/ArrowTableSlicingCache.h        |  6 +-
 .../Core/include/Framework/GroupSlicer.h      |  4 +-
 Framework/Core/src/ArrowTableSlicingCache.cxx | 65 ++++++++++++-------
 Framework/Core/test/test_GroupSlicer.cxx      | 20 +++---
 4 files changed, 55 insertions(+), 40 deletions(-)

diff --git a/Framework/Core/include/Framework/ArrowTableSlicingCache.h b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
index 292a67023fc5e..41d6b33e48476 100644
--- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h
+++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
@@ -21,8 +21,8 @@ namespace o2::framework
 using ListVector = std::vector<std::vector<int64_t>>;
 
 struct SliceInfoPtr {
-  gsl::span<int const> values;
-  gsl::span<int64_t const> counts;
+  gsl::span<int64_t const> offsets;
+  gsl::span<int64_t const> sizes;
 
   std::pair<int64_t, int64_t> getSliceFor(int value) const;
 };
@@ -66,6 +66,8 @@ struct ArrowTableSlicingCache {
   Cache bindingsKeys;
   std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int32Type>>> values;
   std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int64Type>>> counts;
+  std::vector<std::vector<int64_t>> offsets;
+  std::vector<std::vector<int64_t>> sizes;
 
   Cache bindingsKeysUnsorted;
   std::vector<std::vector<int>> valuesUnsorted;
diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h
index b8436314b057e..112bf7e147ff0 100644
--- a/Framework/Core/include/Framework/GroupSlicer.h
+++ b/Framework/Core/include/Framework/GroupSlicer.h
@@ -246,9 +246,7 @@ struct GroupSlicer {
         pos = position;
       }
       // optimized split
-      auto oc = sliceInfos[index].getSliceFor(pos);
-      uint64_t offset = oc.first;
-      auto count = oc.second;
+      auto [offset, count] = sliceInfos[index].getSliceFor(pos);
       auto groupedElementsTable = originalTable.rawSlice(offset, offset + count - 1);
       groupedElementsTable.bindInternalIndicesTo(&originalTable);
       return groupedElementsTable;
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index e001e293c4733..26bb9bcee80eb 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -32,28 +32,14 @@ void updatePairList(Cache& list, std::string const& binding, std::string const&
 std::pair<int64_t, int64_t> SliceInfoPtr::getSliceFor(int value) const
 {
   int64_t offset = 0;
-  if (values.empty()) {
+  if (offsets.empty()) {
     return {offset, 0};
   }
-  int64_t p = static_cast<int64_t>(values.size()) - 1;
-  while (values[p] < 0) {
-    --p;
-    if (p < 0) {
-      return {offset, 0};
-    }
-  }
-
-  if (value > values[p]) {
+  if ((size_t)value >= offsets.size()) {
     return {offset, 0};
   }
 
-  for (auto i = 0U; i < values.size(); ++i) {
-    if (values[i] == value) {
-      return {offset, counts[i]};
-    }
-    offset += counts[i];
-  }
-  return {offset, 0};
+  return {offsets[value], sizes[value]};
 }
 
 gsl::span<const int64_t> SliceInfoUnsortedPtr::getSliceFor(int value) const
@@ -84,6 +70,8 @@ ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorte
 {
   values.resize(bindingsKeys.size());
   counts.resize(bindingsKeys.size());
+  offsets.resize(bindingsKeys.size());
+  sizes.resize(bindingsKeys.size());
 
   valuesUnsorted.resize(bindingsKeysUnsorted.size());
   groups.resize(bindingsKeysUnsorted.size());
@@ -97,6 +85,10 @@ void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted)
   values.resize(bindingsKeys.size());
   counts.clear();
   counts.resize(bindingsKeys.size());
+  offsets.clear();
+  offsets.resize(bindingsKeys.size());
+  sizes.clear();
+  sizes.resize(bindingsKeys.size());
   valuesUnsorted.clear();
   valuesUnsorted.resize(bindingsKeysUnsorted.size());
   groups.clear();
@@ -105,9 +97,11 @@ void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted)
 
 arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<arrow::Table> const& table)
 {
+  values[pos].reset();
+  counts[pos].reset();
+  offsets[pos].clear();
+  sizes[pos].clear();
   if (table->num_rows() == 0) {
-    values[pos].reset();
-    counts[pos].reset();
     return arrow::Status::OK();
   }
   auto& [b, k, e] = bindingsKeys[pos];
@@ -125,6 +119,31 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
   counts[pos].reset();
   values[pos] = std::make_shared<arrow::NumericArray<arrow::Int32Type>>(pair.field(0)->data());
   counts[pos] = std::make_shared<arrow::NumericArray<arrow::Int64Type>>(pair.field(1)->data());
+
+  int maxValue = -1;
+  for (auto i = values[pos]->length() - 1; i >= 0; --i) {
+    if (values[pos]->Value(i) < 0) {
+      continue;
+    } else {
+      maxValue = values[pos]->Value(i);
+      break;
+    }
+  }
+
+  offsets[pos].resize(maxValue + 1);
+  sizes[pos].resize(maxValue + 1);
+  std::fill(offsets[pos].begin(), offsets[pos].end(), 0);
+  std::fill(sizes[pos].begin(), sizes[pos].end(), 0);
+  int64_t offset = 0;
+  for (auto i = 0U; i < values[pos]->length(); ++i) {
+    auto value = values[pos]->Value(i);
+    auto count = counts[pos]->Value(i);
+    if (value >= 0) {
+      offsets[pos][value] = offset;
+      sizes[pos][value] = count;
+    }
+    offset += count;
+  }
   return arrow::Status::OK();
 }
 
@@ -221,14 +240,14 @@ SliceInfoPtr ArrowTableSlicingCache::getCacheForPos(int pos) const
 {
   if (values[pos] == nullptr && counts[pos] == nullptr) {
     return {
-      {},
-      {} //
+      {}, //
+      {}  //
     };
   }
 
   return {
-    {reinterpret_cast<int const*>(values[pos]->values()->data()), static_cast<size_t>(values[pos]->length())},
-    {reinterpret_cast<int64_t const*>(counts[pos]->values()->data()), static_cast<size_t>(counts[pos]->length())} //
+    gsl::span{offsets[pos].data(), offsets[pos].size()}, //
+    gsl::span(sizes[pos].data(), sizes[pos].size())      //
   };
 }
 
diff --git a/Framework/Core/test/test_GroupSlicer.cxx b/Framework/Core/test/test_GroupSlicer.cxx
index 091c21eeae229..2f21d7dd17975 100644
--- a/Framework/Core/test/test_GroupSlicer.cxx
+++ b/Framework/Core/test/test_GroupSlicer.cxx
@@ -245,8 +245,8 @@ TEST_CASE("GroupSlicerMismatchedGroups")
     if (i == 3 || i == 10 || i == 12 || i == 16 || i == 19) {
       continue;
     }
-    for (auto j = 0.f; j < 5; j += 0.5f) {
-      trksWriter(0, i, 0.5f * j);
+    for (auto j = 0; j < 10; ++j) {
+      trksWriter(0, i, 0.5f * (j / 2.));
     }
   }
   auto trkTable = builderT.finalize();
@@ -260,21 +260,19 @@ TEST_CASE("GroupSlicerMismatchedGroups")
   auto s = slices.updateCacheEntry(0, trkTable);
   o2::framework::GroupSlicer g(e, tt, slices);
 
-  auto count = 0;
   for (auto& slice : g) {
     auto as = slice.associatedTables();
     auto gg = slice.groupingElement();
-    REQUIRE(gg.globalIndex() == count);
+    REQUIRE(gg.globalIndex() == (int64_t)slice.position);
     auto trks = std::get<aod::TrksX>(as);
-    if (count == 3 || count == 10 || count == 12 || count == 16 || count == 19) {
+    if (slice.position == 3 || slice.position == 10 || slice.position == 12 || slice.position == 16 || slice.position == 19) {
       REQUIRE(trks.size() == 0);
     } else {
       REQUIRE(trks.size() == 10);
     }
     for (auto& trk : trks) {
-      REQUIRE(trk.eventId() == count);
+      REQUIRE(trk.eventId() == (int64_t)slice.position);
     }
-    ++count;
   }
 }
 
@@ -299,8 +297,8 @@ TEST_CASE("GroupSlicerMismatchedUnassignedGroups")
       ++skip;
       continue;
     }
-    for (auto j = 0.f; j < 5; j += 0.5f) {
-      trksWriter(0, i, 0.5f * j);
+    for (auto j = 0; j < 10; ++j) {
+      trksWriter(0, i, 0.5f * (j / 2.));
     }
   }
   for (auto i = 0; i < 5; ++i) {
@@ -510,7 +508,7 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
 {
   TableBuilder builderE;
   auto evtsWriter = builderE.cursor<aod::Events>();
-  for (auto i = 0; i < 20; ++i) {
+  for (auto i = 0; i < 10; ++i) {
     evtsWriter(0, i, 0.5f * i, 2.f * i, 3.f * i);
   }
   auto evtTable = builderE.finalize();
@@ -523,7 +521,6 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
   std::uniform_int_distribution<> distrib(0, 99);
 
   for (auto i = 0; i < 100; ++i) {
-
     filler[0] = distrib(gen);
     filler[1] = distrib(gen);
     if (filler[0] > filler[1]) {
@@ -541,7 +538,6 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
   auto thingsTable = builderT.finalize();
 
   aod::Events e{evtTable};
-  // aod::Parts p{partsTable};
   aod::Things t{thingsTable};
   using FilteredParts = soa::Filtered<aod::Parts>;
   auto size = distrib(gen);

From dce7e0eacaa2797137b8be695ec64310f4d9569a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 14 Aug 2025 14:19:06 +0200
Subject: [PATCH 0707/1764] Skip QED events in TPC QA

---
 GPU/GPUTracking/qa/GPUQA.cxx | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 2e9c3a1870385..4fb2ee4dd58d9 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -686,6 +686,9 @@ void GPUQA::InitO2MCData(GPUTrackingInOutPointers* updateIOPtr)
 
     mMCInfosCol.resize(nSimTotalEvents);
     for (int32_t iSim = 0; iSim < mcReader.getNSources(); iSim++) {
+      if (iSim == o2::steer::QEDSOURCEID) {
+        continue;
+      }
       for (int32_t i = 0; i < mcReader.getNEvents(iSim); i++) {
         auto ir = evrec[i];
         auto ir0 = o2::raw::HBFUtils::Instance().getFirstIRofTF(ir);

From 6c35d65cebf3513ee0e0b15b3080866aca7751aa Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 15 Aug 2025 14:23:21 +0200
Subject: [PATCH 0708/1764] DPL: add more views on InputSpecs / OutputSpecs /
 DataProcessors (#14588)

Useful to reduce the amount of lines of code in various manipulation
parts.
---
 .../Core/include/Framework/DataSpecViews.h    | 44 ++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/DataSpecViews.h b/Framework/Core/include/Framework/DataSpecViews.h
index 010d771b07941..0782cefd0f632 100644
--- a/Framework/Core/include/Framework/DataSpecViews.h
+++ b/Framework/Core/include/Framework/DataSpecViews.h
@@ -18,8 +18,50 @@ namespace o2::framework::views
 {
 static auto partial_match_filter(auto what)
 {
-  return std::views::filter([&what](auto const& t) -> bool { return DataSpecUtils::partialMatch(t, what); });
+  return std::views::filter([what](auto const& t) -> bool { return DataSpecUtils::partialMatch(t, what); });
 }
+
+static auto exclude_by_name(std::string name)
+{
+  return std::views::filter([name](auto const& t) -> bool { return t.name != name; });
+}
+
+static auto filter_not_matching(auto const& provided)
+{
+  return std::views::filter([&provided](auto const& input) { return std::none_of(provided.begin(), provided.end(), [&input](auto const& output) { return DataSpecUtils::match(input, output); }); });
+}
+
 } // namespace o2::framework::views
+//
+namespace o2::framework::sinks
+{
+template <class Container>
+struct append_to {
+  Container& c;
+  // ends the pipeline, returns the container
+  template <std::ranges::input_range R>
+  friend Container& operator|(R&& r, append_to self)
+  {
+    std::ranges::copy(r, std::back_inserter(self.c));
+    return self.c;
+  }
+};
+
+template <class Container>
+struct update_input_list {
+  Container& c;
+  // ends the pipeline, returns the container
+  template <std::ranges::input_range R>
+  friend Container& operator|(R&& r, update_input_list self)
+  {
+    for (auto& item : r) {
+      auto copy = item;
+      DataSpecUtils::updateInputList(self.c, std::move(copy));
+    }
+    return self.c;
+  }
+};
+
+} // namespace o2::framework::sinks
 
 #endif // O2_FRAMEWORK_DATASPECVIEWS_H_

From c35a2cdf7c38ae865997db37c499fec310aae701 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 27 May 2025 09:38:08 +0200
Subject: [PATCH 0709/1764] Geo: optional print out alignment matrices

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../DetectorsCommonDataFormats/AlignParam.h      |  2 +-
 DataFormats/Detectors/Common/src/AlignParam.cxx  | 16 +++++++++++++---
 .../include/DetectorsBase/GeometryManagerParam.h |  2 ++
 Detectors/Base/src/GeometryManager.cxx           |  3 ++-
 4 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h
index a93a37c1e36ab..5a0d2d64b0ff5 100644
--- a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h
+++ b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/AlignParam.h
@@ -55,7 +55,7 @@ class AlignParam
   double getZ() const { return mZ; }
 
   /// apply object to geoemetry
-  bool applyToGeometry() const;
+  bool applyToGeometry(int printLevel = -1) const;
 
   /// extract global delta matrix
   TGeoHMatrix createMatrix() const;
diff --git a/DataFormats/Detectors/Common/src/AlignParam.cxx b/DataFormats/Detectors/Common/src/AlignParam.cxx
index f20cf3dac4971..1e1716ce17ff5 100644
--- a/DataFormats/Detectors/Common/src/AlignParam.cxx
+++ b/DataFormats/Detectors/Common/src/AlignParam.cxx
@@ -12,12 +12,12 @@
 /// \file AlignParam.cxx
 /// \brief Implementation of the base alignment parameters class
 
-#include <fairlogger/Logger.h>
 #include <TGeoManager.h>
 #include <TGeoMatrix.h>
 #include <TGeoOverlap.h>
 #include <TGeoPhysicalNode.h>
 
+#include "Framework/Logger.h"
 #include "DetectorsCommonDataFormats/AlignParam.h"
 
 using namespace o2::detectors;
@@ -261,7 +261,7 @@ bool AlignParam::createLocalMatrix(TGeoHMatrix& m) const
 }
 
 //_____________________________________________________________________________
-bool AlignParam::applyToGeometry() const
+bool AlignParam::applyToGeometry(int printLevel) const
 {
   /// Apply the current alignment object to the TGeo geometry
   /// This method returns FALSE if the symname of the object was not
@@ -311,10 +311,20 @@ bool AlignParam::applyToGeometry() const
     TGeoHMatrix* g = node->GetMatrix(node->GetLevel() - 1);
     align->MultiplyLeft(node->GetMatrix(node->GetLevel() - 1)->Inverse());
   }
-  LOG(debug) << "Aligning volume " << symname;
 
   node->Align(align);
 
+  if (getLevel() <= printLevel) {
+    LOGP(info, "{:*^100}", symname);
+    LOGP(info, " - Alignment parameter:");
+    print();
+    LOGP(info, " - Alignment matrix:");
+    align->Print();
+    LOGP(info, " - Node:");
+    node->Print();
+    LOGP(info, "{:~^100}", symname);
+  }
+
   return true;
 }
 
diff --git a/Detectors/Base/include/DetectorsBase/GeometryManagerParam.h b/Detectors/Base/include/DetectorsBase/GeometryManagerParam.h
index c41d41e25e233..b82d526344646 100644
--- a/Detectors/Base/include/DetectorsBase/GeometryManagerParam.h
+++ b/Detectors/Base/include/DetectorsBase/GeometryManagerParam.h
@@ -23,6 +23,8 @@ struct GeometryManagerParam : public o2::conf::ConfigurableParamHelper<GeometryM
   bool usePwGeoBVH = false;
   bool usePwCaching = false;
 
+  int printLevel = -1; // geometry level to print out (determined by the volume path)
+
   O2ParamDef(GeometryManagerParam, "GeometryManagerParam");
 };
 
diff --git a/Detectors/Base/src/GeometryManager.cxx b/Detectors/Base/src/GeometryManager.cxx
index c5e7e8e47e731..a067767752a69 100644
--- a/Detectors/Base/src/GeometryManager.cxx
+++ b/Detectors/Base/src/GeometryManager.cxx
@@ -24,6 +24,7 @@
 #include <numeric>
 
 #include "DetectorsBase/GeometryManager.h"
+#include "DetectorsBase/GeometryManagerParam.h"
 #include "DetectorsCommonDataFormats/AlignParam.h"
 #include "CommonUtils/NameConf.h"
 #include "DetectorsBase/Aligner.h"
@@ -256,7 +257,7 @@ bool GeometryManager::applyAlignment(const std::vector<o2::detectors::AlignParam
 
   bool res = true;
   for (int i = 0; i < nvols; i++) {
-    if (!algPars[ord[i]].applyToGeometry()) {
+    if (!algPars[ord[i]].applyToGeometry(GeometryManagerParam::Instance().printLevel)) {
       res = false;
       LOG(error) << "Error applying alignment object for volume" << algPars[ord[i]].getSymName();
     }

From 44cd710321a2dea07a527247f5f0e23930ae5708 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 27 May 2025 09:38:46 +0200
Subject: [PATCH 0710/1764] Align: print delta frame and level

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 DataFormats/Detectors/Common/src/AlignParam.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/DataFormats/Detectors/Common/src/AlignParam.cxx b/DataFormats/Detectors/Common/src/AlignParam.cxx
index 1e1716ce17ff5..11bfa10dab087 100644
--- a/DataFormats/Detectors/Common/src/AlignParam.cxx
+++ b/DataFormats/Detectors/Common/src/AlignParam.cxx
@@ -357,8 +357,8 @@ int AlignParam::getLevel() const
 void AlignParam::print() const
 {
   // print parameters
-  printf("%s : %6d | X: %+e Y: %+e Z: %+e | pitch: %+e roll: %+e yaw: %e\n", getSymName().c_str(), getAlignableID(), getX(),
-         getY(), getZ(), getPsi(), getTheta(), getPhi());
+  printf("%s (Lvl:%2d): %6d | %s | tra: X: %+e Y: %+e Z: %+e | pitch: %+e roll: %+e yaw: %e\n", getSymName().c_str(), getLevel(), getAlignableID(), (mIsGlobal) ? "G" : "L",
+         getX(), getY(), getZ(), getPsi(), getTheta(), getPhi());
 }
 
 //_____________________________________________________________________________

From 3912592e853546ea86e845e555c707cfe9466aae Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 15 Aug 2025 10:44:02 +0200
Subject: [PATCH 0711/1764] Align: Fix using local delta matrix

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 DataFormats/Detectors/Common/src/AlignParam.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/DataFormats/Detectors/Common/src/AlignParam.cxx b/DataFormats/Detectors/Common/src/AlignParam.cxx
index 11bfa10dab087..2061726a29c66 100644
--- a/DataFormats/Detectors/Common/src/AlignParam.cxx
+++ b/DataFormats/Detectors/Common/src/AlignParam.cxx
@@ -308,8 +308,9 @@ bool AlignParam::applyToGeometry(int printLevel) const
   TGeoHMatrix* align = new TGeoHMatrix(createMatrix());
   if (mIsGlobal) {
     align->Multiply(node->GetMatrix());
-    TGeoHMatrix* g = node->GetMatrix(node->GetLevel() - 1);
     align->MultiplyLeft(node->GetMatrix(node->GetLevel() - 1)->Inverse());
+  } else {
+    align->MultiplyLeft(node->GetOriginalMatrix());
   }
 
   node->Align(align);

From 7262c36703fb88bab6bcd1e76484aef06b2c1727 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 15 Aug 2025 11:47:22 +0200
Subject: [PATCH 0712/1764] Fix in TRD sector getter

---
 Detectors/TRD/base/include/TRDBase/GeometryBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/TRD/base/include/TRDBase/GeometryBase.h b/Detectors/TRD/base/include/TRDBase/GeometryBase.h
index c817d21cb7c48..6627e70406b2b 100644
--- a/Detectors/TRD/base/include/TRDBase/GeometryBase.h
+++ b/Detectors/TRD/base/include/TRDBase/GeometryBase.h
@@ -38,7 +38,7 @@ class GeometryBase
     }
   }
   GPUd() bool getSMstatus(int sm) const { return (mSMStatus & (0x1 << sm)) != 0; }
-  GPUd() static int getDetectorSec(int det) { return (det % (constants::NLAYER * constants::NSTACK)); }
+  GPUd() static int getDetectorSec(int det) { return (det / (constants::NLAYER * constants::NSTACK)); }
   GPUd() static int getDetectorSec(int layer, int stack) { return (layer + stack * constants::NLAYER); }
   GPUd() static int getDetector(int layer, int stack, int sector) { return (layer + stack * constants::NLAYER + sector * constants::NLAYER * constants::NSTACK); }
   GPUd() static int getLayer(int det) { return (det % constants::NLAYER); }

From 0364324707ee16ce8eae86c64149665fbcb9350e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 18 Aug 2025 08:03:56 +0200
Subject: [PATCH 0713/1764] ITS: GPU: prepare to lazy loading of data (#14585)

---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  79 ++-
 .../GPU/ITStrackingGPU/TrackerTraitsGPU.h     |   2 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  55 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   | 150 +++++-
 .../ITS/tracking/GPU/cuda/CMakeLists.txt      |  48 +-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 470 ++++++++++--------
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 151 +++---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 445 +++++------------
 8 files changed, 708 insertions(+), 692 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 5c10b01412b4e..27b987fb9a84a 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -13,13 +13,14 @@
 #ifndef TRACKINGITSGPU_INCLUDE_TIMEFRAMEGPU_H
 #define TRACKINGITSGPU_INCLUDE_TIMEFRAMEGPU_H
 
+#include <gsl/gsl>
+#include <bitset>
+
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Configuration.h"
 #include "ITStrackingGPU/Utils.h"
 
-#include <gsl/gsl>
-
 namespace o2::its::gpu
 {
 
@@ -28,7 +29,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
 {
  public:
   TimeFrameGPU();
-  ~TimeFrameGPU();
+  ~TimeFrameGPU() = default;
 
   /// Most relevant operations
   void registerHostMemory(const int);
@@ -37,18 +38,25 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void initDevice(IndexTableUtils*, const TrackingParameters& trkParam, const TimeFrameGPUParameters&, const int, const int);
   void initDeviceSAFitting();
   void loadIndexTableUtils(const int);
-  void loadTrackingFrameInfoDevice(const int);
-  void loadUnsortedClustersDevice(const int);
-  void loadClustersDevice(const int);
-  void loadClustersIndexTables(const int iteration);
-  void createUsedClustersDevice(const int);
+  void loadTrackingFrameInfoDevice(const int, const int);
+  void createTrackingFrameInfoDeviceArray(const int);
+  void loadUnsortedClustersDevice(const int, const int);
+  void createUnsortedClustersDeviceArray(const int);
+  void loadClustersDevice(const int, const int);
+  void createClustersDeviceArray(const int);
+  void loadClustersIndexTables(const int, const int);
+  void createClustersIndexTablesArray(const int iteration);
+  void createUsedClustersDevice(const int, const int);
+  void createUsedClustersDeviceArray(const int);
   void loadUsedClustersDevice();
-  void loadROframeClustersDevice(const int);
+  void loadROFrameClustersDevice(const int, const int);
+  void createROFrameClustersDeviceArray(const int);
   void loadMultiplicityCutMask(const int);
   void loadVertices(const int);
 
   ///
-  void createTrackletsLUTDevice(const int);
+  void createTrackletsLUTDevice(const int, const int);
+  void createTrackletsLUTDeviceArray(const int);
   void loadTrackletsDevice();
   void loadTrackletsLUTDevice();
   void loadCellsDevice();
@@ -57,11 +65,14 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void loadTrackSeedsChi2Device();
   void loadRoadsDevice();
   void loadTrackSeedsDevice(bounded_vector<CellSeed>&);
-  void createTrackletsBuffers();
+  void createTrackletsBuffers(const int);
+  void createTrackletsBuffersArray(const int);
   void createCellsBuffers(const int);
+  void createCellsBuffersArray(const int);
   void createCellsDevice();
-  void createCellsLUTDevice();
-  void createNeighboursIndexTablesDevice();
+  void createCellsLUTDevice(const int);
+  void createCellsLUTDeviceArray(const int);
+  void createNeighboursIndexTablesDevice(const int);
   void createNeighboursDevice(const unsigned int layer);
   void createNeighboursLUTDevice(const int, const unsigned int);
   void createTrackITSExtDevice(bounded_vector<CellSeed>&);
@@ -70,10 +81,17 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void downloadNeighboursLUTDevice(bounded_vector<int>&, const int);
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
+
+  /// synchronization
   auto& getStream(const size_t stream) { return mGpuStreams[stream]; }
   auto& getStreams() { return mGpuStreams; }
   void syncStream(const size_t stream);
-  void syncStreams();
+  void syncStreams(const bool = true);
+  void waitEvent(const int, const int);
+  void recordEvent(const int);
+  void recordEvents(const int = 0, const int = nLayers);
+
+  /// cleanup
   virtual void wipe() final;
 
   /// interface
@@ -102,19 +120,19 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   const int** getDeviceArrayClustersIndexTables() const { return mClustersIndexTablesDeviceArray; }
   std::vector<unsigned int> getClusterSizes();
   const unsigned char** getDeviceArrayUsedClusters() const { return mUsedClustersDeviceArray; }
-  const int** getDeviceROframeClusters() const { return mROFrameClustersDeviceArray; }
-  Tracklet** getDeviceArrayTracklets() { return mTrackletsDevice.data(); }
+  const int** getDeviceROFrameClusters() const { return mROFramesClustersDeviceArray; }
+  Tracklet** getDeviceArrayTracklets() { return mTrackletsDeviceArray; }
   int** getDeviceArrayTrackletsLUT() const { return mTrackletsLUTDeviceArray; }
   int** getDeviceArrayCellsLUT() const { return mCellsLUTDeviceArray; }
   int** getDeviceArrayNeighboursCellLUT() const { return mNeighboursCellLUTDeviceArray; }
-  CellSeed** getDeviceArrayCells() { return mCellsDevice.data(); }
+  CellSeed** getDeviceArrayCells() { return mCellsDeviceArray; }
   CellSeed* getDeviceTrackSeeds() { return mTrackSeedsDevice; }
   o2::track::TrackParCovF** getDeviceArrayTrackSeeds() { return mCellSeedsDeviceArray; }
   float** getDeviceArrayTrackSeedsChi2() { return mCellSeedsChi2DeviceArray; }
   int* getDeviceNeighboursIndexTables(const int layer) { return mNeighboursIndexTablesDevice[layer]; }
   uint8_t* getDeviceMultCutMask() { return mMultMaskDevice; }
 
-  void setDevicePropagator(const o2::base::PropagatorImpl<float>*) override;
+  void setDevicePropagator(const o2::base::PropagatorImpl<float>* p) final { this->mPropagatorDevice = p; }
 
   // Host-specific getters
   gsl::span<int, nLayers - 1> getNTracklets() { return mNTracklets; }
@@ -126,7 +144,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   // Host-available device getters
   gsl::span<int*> getDeviceTrackletsLUTs() { return mTrackletsLUTDevice; }
   gsl::span<int*> getDeviceCellLUTs() { return mCellsLUTDevice; }
-  gsl::span<Tracklet*> getDeviceTracklet() { return mTrackletsDevice; }
+  gsl::span<Tracklet*> getDeviceTracklets() { return mTrackletsDevice; }
   gsl::span<CellSeed*> getDeviceCells() { return mCellsDevice; }
 
   // Overridden getters
@@ -137,7 +155,6 @@ class TimeFrameGPU : public TimeFrame<nLayers>
  private:
   void allocMemAsync(void**, size_t, Stream&, bool); // Abstract owned and unowned memory allocations on specific stream
   void allocMem(void**, size_t, bool);               // Abstract owned and unowned memory allocations on default stream
-  bool mHostRegistered = false;
   TimeFrameGPUParameters mGpuParams;
 
   // Host-available device buffer sizes
@@ -161,19 +178,21 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   const Cluster** mUnsortedClustersDeviceArray;
   const int** mClustersIndexTablesDeviceArray;
   const unsigned char** mUsedClustersDeviceArray;
-  const int** mROFrameClustersDeviceArray;
+  const int** mROFramesClustersDeviceArray;
   std::array<Tracklet*, nLayers - 1> mTrackletsDevice;
   std::array<int*, nLayers - 1> mTrackletsLUTDevice;
   std::array<int*, nLayers - 2> mCellsLUTDevice;
   std::array<int*, nLayers - 3> mNeighboursLUTDevice;
 
-  int** mCellsLUTDeviceArray;
-  int** mNeighboursCellDeviceArray;
-  int** mNeighboursCellLUTDeviceArray;
-  int** mTrackletsLUTDeviceArray;
+  Tracklet** mTrackletsDeviceArray{nullptr};
+  int** mCellsLUTDeviceArray{nullptr};
+  int** mNeighboursCellDeviceArray{nullptr};
+  int** mNeighboursCellLUTDeviceArray{nullptr};
+  int** mTrackletsLUTDeviceArray{nullptr};
   std::array<CellSeed*, nLayers - 2> mCellsDevice;
-  std::array<int*, nLayers - 2> mNeighboursIndexTablesDevice;
-  CellSeed* mTrackSeedsDevice;
+  CellSeed** mCellsDeviceArray;
+  std::array<int*, nLayers - 3> mNeighboursIndexTablesDevice;
+  CellSeed* mTrackSeedsDevice{nullptr};
   std::array<o2::track::TrackParCovF*, nLayers - 2> mCellSeedsDevice;
   o2::track::TrackParCovF** mCellSeedsDeviceArray;
   std::array<float*, nLayers - 2> mCellSeedsChi2Device;
@@ -188,6 +207,12 @@ class TimeFrameGPU : public TimeFrame<nLayers>
 
   // State
   Streams mGpuStreams;
+  std::bitset<nLayers + 1> mPinnedUnsortedClusters{0};
+  std::bitset<nLayers + 1> mPinnedClusters{0};
+  std::bitset<nLayers + 1> mPinnedClustersIndexTables{0};
+  std::bitset<nLayers + 1> mPinnedUsedClusters{0};
+  std::bitset<nLayers + 1> mPinnedROFramesClusters{0};
+  std::bitset<nLayers + 1> mPinnedTrackingFrameInfo{0};
 
   // Temporary buffer for storing output tracks from GPU tracking
   bounded_vector<TrackITSExt> mTrackITSExt;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
index 1654f8cc8cf94..d5c3e8ac74925 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
@@ -24,7 +24,7 @@ class TrackerTraitsGPU final : public TrackerTraits<nLayers>
 {
  public:
   TrackerTraitsGPU() = default;
-  ~TrackerTraitsGPU() override = default;
+  ~TrackerTraitsGPU() final = default;
 
   void adoptTimeFrame(TimeFrame<nLayers>* tf) final;
   void initialiseTimeFrame(const int iteration) final;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index a7bf4c70bc5c2..23b23d2b3f3ab 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -13,6 +13,10 @@
 #ifndef ITSTRACKINGGPU_TRACKINGKERNELS_H_
 #define ITSTRACKINGGPU_TRACKINGKERNELS_H_
 
+#include <gsl/gsl>
+
+#include "ITStracking/BoundedAllocator.h"
+#include "ITStrackingGPU/Utils.h"
 #include "DetectorsBase/Propagator.h"
 #include "GPUCommonDef.h"
 
@@ -25,43 +29,43 @@ namespace gpu
 
 #ifdef GPUCA_GPUCODE // GPUg() global kernels must only when compiled by GPU compiler
 
-GPUdi() int4 getEmptyBinsRect()
+GPUdii() int4 getEmptyBinsRect()
 {
   return int4{0, 0, 0, 0};
 }
 
-GPUd() bool fitTrack(TrackITSExt& track,
-                     int start,
-                     int end,
-                     int step,
-                     float chi2clcut,
-                     float chi2ndfcut,
-                     float maxQoverPt,
-                     int nCl,
-                     float Bz,
-                     TrackingFrameInfo** tfInfos,
-                     const o2::base::Propagator* prop,
-                     o2::base::PropagatorF::MatCorrType matCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE);
+GPUdii() bool fitTrack(TrackITSExt& track,
+                       int start,
+                       int end,
+                       int step,
+                       float chi2clcut,
+                       float chi2ndfcut,
+                       float maxQoverPt,
+                       int nCl,
+                       float Bz,
+                       TrackingFrameInfo** tfInfos,
+                       const o2::base::Propagator* prop,
+                       o2::base::PropagatorF::MatCorrType matCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE);
 
 template <int nLayers = 7>
-GPUg() void fitTrackSeedsKernel(
-  CellSeed* trackSeeds,
-  const TrackingFrameInfo** foundTrackingFrameInfo,
-  o2::its::TrackITSExt* tracks,
-  const float* minPts,
-  const unsigned int nSeeds,
-  const float Bz,
-  const int startLevel,
-  float maxChi2ClusterAttachment,
-  float maxChi2NDF,
-  const o2::base::Propagator* propagator,
-  const o2::base::PropagatorF::MatCorrType matCorrType = o2::base::PropagatorF::MatCorrType::USEMatCorrLUT);
+GPUg() void fitTrackSeedsKernel(CellSeed* trackSeeds,
+                                const TrackingFrameInfo** foundTrackingFrameInfo,
+                                o2::its::TrackITSExt* tracks,
+                                const float* minPts,
+                                const unsigned int nSeeds,
+                                const float Bz,
+                                const int startLevel,
+                                float maxChi2ClusterAttachment,
+                                float maxChi2NDF,
+                                const o2::base::Propagator* propagator,
+                                const o2::base::PropagatorF::MatCorrType matCorrType = o2::base::PropagatorF::MatCorrType::USEMatCorrLUT);
 #endif
 } // namespace gpu
 
 template <int nLayers = 7>
 void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  const uint8_t* multMask,
+                                 const int layer,
                                  const int startROF,
                                  const int endROF,
                                  const int maxROF,
@@ -94,6 +98,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
 template <int nLayers = 7>
 void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    const uint8_t* multMask,
+                                   const int layer,
                                    const int startROF,
                                    const int endROF,
                                    const int maxROF,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index cd860c47ebd9c..15fe6f05f7850 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -17,9 +17,12 @@
 #define ITSTRACKINGGPU_UTILS_H_
 
 #include <vector>
+#include <string>
+#include <tuple>
 
 #include "GPUCommonDef.h"
 #include "GPUCommonHelpers.h"
+#include "GPUCommonLogger.h"
 
 #ifndef __HIPCC__
 #define THRUST_NAMESPACE thrust::cuda
@@ -27,19 +30,21 @@
 #define THRUST_NAMESPACE thrust::hip
 #endif
 
+#ifdef ITS_GPU_LOG
+#define GPULog(...) LOGP(info, __VA_ARGS__)
+#else
+#define GPULog(...)
+#endif
+
 namespace o2::its
 {
 
 template <typename T1, typename T2>
-struct gpuPair {
-  T1 first;
-  T2 second;
-};
+using gpuPair = std::pair<T1, T2>;
 
 namespace gpu
 {
 
-// Poor man implementation of a span-like struct. It is very limited.
 template <typename T>
 struct gpuSpan {
   using value_type = T;
@@ -83,11 +88,6 @@ struct gpuSpan<const T> {
   unsigned int _size;
 };
 
-enum class Task {
-  Tracker = 0,
-  Vertexer = 1
-};
-
 // Abstract stream class
 class Stream
 {
@@ -96,22 +96,27 @@ class Stream
   using Handle = hipStream_t;
   static constexpr Handle DefaultStream = 0;
   static constexpr unsigned int DefaultFlag = hipStreamNonBlocking;
+  using Event = hipEvent_t;
 #elif defined(__CUDACC__)
   using Handle = cudaStream_t;
   static constexpr Handle DefaultStream = 0;
   static constexpr unsigned int DefaultFlag = cudaStreamNonBlocking;
+  using Event = cudaEvent_t;
 #else
   using Handle = void*;
   static constexpr Handle DefaultStream = nullptr;
   static constexpr unsigned int DefaultFlag = 0;
+  using Event = void*;
 #endif
 
   Stream(unsigned int flags = DefaultFlag)
   {
 #if defined(__HIPCC__)
     GPUChkErrS(hipStreamCreateWithFlags(&mHandle, flags));
+    GPUChkErrS(hipEventCreateWithFlags(&mEvent, hipEventDisableTiming));
 #elif defined(__CUDACC__)
     GPUChkErrS(cudaStreamCreateWithFlags(&mHandle, flags));
+    GPUChkErrS(cudaEventCreateWithFlags(&mEvent, cudaEventDisableTiming));
 #endif
   }
 
@@ -121,49 +126,162 @@ class Stream
     if (mHandle != DefaultStream) {
 #if defined(__HIPCC__)
       GPUChkErrS(hipStreamDestroy(mHandle));
+      GPUChkErrS(hipEventDestroy(mEvent));
 #elif defined(__CUDACC__)
       GPUChkErrS(cudaStreamDestroy(mHandle));
+      GPUChkErrS(cudaEventDestroy(mEvent));
 #endif
     }
   }
 
   operator bool() const { return mHandle != DefaultStream; }
   const Handle& get() { return mHandle; }
+  const Handle& getStream() { return mHandle; }
+  const Event& getEvent() { return mEvent; }
   void sync() const
   {
 #if defined(__HIPCC__)
     GPUChkErrS(hipStreamSynchronize(mHandle));
 #elif defined(__CUDACC__)
     GPUChkErrS(cudaStreamSynchronize(mHandle));
+#endif
+  }
+  void record()
+  {
+#if defined(__HIPCC__)
+    GPUChkErrS(hipEventRecord(mEvent, mHandle));
+#elif defined(__CUDACC__)
+    GPUChkErrS(cudaEventRecord(mEvent, mHandle));
 #endif
   }
 
  private:
   Handle mHandle{DefaultStream};
+  Event mEvent{nullptr};
 };
-static_assert(sizeof(Stream) == sizeof(void*), "Stream type must match pointer type!");
 
 // Abstract vector for streams.
-// Handles specifically wrap around.
 class Streams
 {
  public:
   size_t size() const noexcept { return mStreams.size(); }
   void resize(size_t n) { mStreams.resize(n); }
   void clear() { mStreams.clear(); }
-  auto& operator[](size_t i) { return mStreams[i % mStreams.size()]; }
+  auto& operator[](size_t i) { return mStreams[i]; }
   void push_back(const Stream& stream) { mStreams.push_back(stream); }
-  void sync()
+  void sync(bool device = true)
   {
-    for (auto& s : mStreams) {
-      s.sync();
+    if (device) {
+#if defined(__HIPCC__)
+      GPUChkErrS(hipDeviceSynchronize());
+#elif defined(__CUDACC__)
+      GPUChkErrS(cudaDeviceSynchronize());
+#endif
+    } else {
+      for (auto& s : mStreams) {
+        s.sync();
+      }
     }
   }
+  void waitEvent(size_t iStream, size_t iEvent)
+  {
+#if defined(__HIPCC__)
+    GPUChkErrS(hipStreamWaitEvent(mStreams[iStream].get(), mStreams[iEvent].getEvent()));
+#elif defined(__CUDACC__)
+    GPUChkErrS(cudaStreamWaitEvent(mStreams[iStream].get(), mStreams[iEvent].getEvent()));
+#endif
+  }
 
  private:
   std::vector<Stream> mStreams;
 };
 
+#ifdef ITS_MEASURE_GPU_TIME
+class GPUTimer
+{
+ public:
+  GPUTimer(const std::string& name)
+    : mName(name)
+  {
+    mStreams.emplace_back(Stream::DefaultStream);
+    startTimers();
+  }
+  GPUTimer(Streams& streams, const std::string& name)
+    : mName(name)
+  {
+    for (size_t i{0}; i < streams.size(); ++i) {
+      mStreams.push_back(streams[i].get());
+    }
+    startTimers();
+  }
+  GPUTimer(Streams& streams, const std::string& name, size_t end, size_t start = 0)
+    : mName(name)
+  {
+    for (size_t sta{start}; sta < end; ++sta) {
+      mStreams.push_back(streams[sta].get());
+    }
+    startTimers();
+  }
+  GPUTimer(Stream& stream, const std::string& name, const int id = 0)
+    : mName(name)
+  {
+    mStreams.push_back(stream.get());
+    mName += ":id" + std::to_string(id);
+    startTimers();
+  }
+  ~GPUTimer()
+  {
+    for (size_t i{0}; i < mStreams.size(); ++i) {
+      float ms = 0.0f;
+#if defined(__HIPCC__)
+      GPUChkErrS(hipEventRecord(mStops[i], mStreams[i]));
+      GPUChkErrS(hipEventSynchronize(mStops[i]));
+      GPUChkErrS(hipEventElapsedTime(&ms, mStarts[i], mStops[i]));
+      GPUChkErrS(hipEventDestroy(mStarts[i]));
+      GPUChkErrS(hipEventDestroy(mStops[i]));
+#elif defined(__CUDACC__)
+      GPUChkErrS(cudaEventRecord(mStops[i], mStreams[i]));
+      GPUChkErrS(cudaEventSynchronize(mStops[i]));
+      GPUChkErrS(cudaEventElapsedTime(&ms, mStarts[i], mStops[i]));
+      GPUChkErrS(cudaEventDestroy(mStarts[i]));
+      GPUChkErrS(cudaEventDestroy(mStops[i]));
+#endif
+      LOGP(info, "Elapsed time for {}:{} {} ms", mName, i, ms);
+    }
+  }
+
+  void startTimers()
+  {
+    mStarts.resize(mStreams.size());
+    mStops.resize(mStreams.size());
+    for (size_t i{0}; i < mStreams.size(); ++i) {
+#if defined(__HIPCC__)
+      GPUChkErrS(hipEventCreate(&mStarts[i]));
+      GPUChkErrS(hipEventCreate(&mStops[i]));
+      GPUChkErrS(hipEventRecord(mStarts[i], mStreams[i]));
+#elif defined(__CUDACC__)
+      GPUChkErrS(cudaEventCreate(&mStarts[i]));
+      GPUChkErrS(cudaEventCreate(&mStops[i]));
+      GPUChkErrS(cudaEventRecord(mStarts[i], mStreams[i]));
+#endif
+    }
+  }
+
+ private:
+  std::string mName;
+  std::vector<Stream::Event> mStarts, mStops;
+  std::vector<Stream::Handle> mStreams;
+};
+#else // ITS_MEASURE_GPU_TIME not defined
+class GPUTimer
+{
+ public:
+  template <typename... Args>
+  GPUTimer(Args&&...)
+  {
+  }
+};
+#endif
 } // namespace gpu
 } // namespace o2::its
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index 9769930504f29..1f6a046a81350 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -11,29 +11,29 @@
 
 # CUDA
 if(CUDA_ENABLED)
-find_package(CUDAToolkit)
-message(STATUS "Building ITS CUDA tracker")
-# add_compile_options(-O0 -g -lineinfo -fPIC)
-# add_compile_definitions(ITS_MEASURE_GPU_TIME)
-o2_add_library(ITStrackingCUDA
-               SOURCES ClusterLinesGPU.cu
-                       TrackerTraitsGPU.cxx
-                       TimeFrameGPU.cu
-                       TracerGPU.cu
-                       TrackingKernels.cu
-                       VertexingKernels.cu
-                       VertexerTraitsGPU.cxx
-               PUBLIC_INCLUDE_DIRECTORIES ../
-               PUBLIC_LINK_LIBRARIES O2::ITStracking
-                                     O2::SimConfig
-                                     O2::SimulationDataFormat
-                                     O2::ReconstructionDataFormats
-                                     O2::GPUCommon
-               PRIVATE_LINK_LIBRARIES O2::GPUTrackingCUDAExternalProvider
-               TARGETVARNAME targetName)
-
-set_property(TARGET ${targetName} PROPERTY CUDA_SEPARABLE_COMPILATION ON)
-target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::ITStracking,COMPILE_DEFINITIONS>)
-set_target_cuda_arch(${targetName})
+    find_package(CUDAToolkit)
+    message(STATUS "Building ITS CUDA tracker")
+    # add_compile_options(-O0 -g -lineinfo -fPIC -DGPU_FORCE_DEVICE_ASSERTS=ON)
+    # add_compile_definitions(ITS_MEASURE_GPU_TIME)
+    # add_compile_definitions(ITS_GPU_LOG)
+    o2_add_library(ITStrackingCUDA
+                   SOURCES ClusterLinesGPU.cu
+                           TrackerTraitsGPU.cxx
+                           TimeFrameGPU.cu
+                           TracerGPU.cu
+                           TrackingKernels.cu
+                           VertexingKernels.cu
+                           VertexerTraitsGPU.cxx
+                   PUBLIC_INCLUDE_DIRECTORIES ../
+                   PUBLIC_LINK_LIBRARIES O2::ITStracking
+                                         O2::SimConfig
+                                         O2::SimulationDataFormat
+                                         O2::ReconstructionDataFormats
+                                         O2::GPUCommon
+                   PRIVATE_LINK_LIBRARIES O2::GPUTrackingCUDAExternalProvider
+                   TARGETVARNAME targetName)
 
+    set_property(TARGET ${targetName} PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+    target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::ITStracking,COMPILE_DEFINITIONS>)
+    set_target_cuda_arch(${targetName})
 endif()
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 72a1f98d1b78b..4f3b52d56a793 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -9,20 +9,16 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 ///
+
 #include <cuda_runtime.h>
-#include <thrust/fill.h>
-#include <thrust/execution_policy.h>
 
+#include <unistd.h>
+#include <vector>
+
+#include "ITStrackingGPU/TimeFrameGPU.h"
 #include "ITStracking/Constants.h"
 #include "ITStracking/BoundedAllocator.h"
-
 #include "ITStrackingGPU/Utils.h"
-#include "ITStrackingGPU/TimeFrameGPU.h"
-#include "ITStrackingGPU/TracerGPU.h"
-
-#include <unistd.h>
-#include <vector>
-#include <fmt/format.h>
 
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
@@ -32,85 +28,12 @@
 namespace o2::its::gpu
 {
 
-#ifdef ITS_MEASURE_GPU_TIME
-class GPUTimer
-{
- public:
-  GPUTimer(Streams& streams, const std::string& name)
-    : mName(name)
-  {
-    for (size_t i{0}; i < streams.size(); ++i) {
-      mStreams.push_back(streams[i].get());
-    }
-    startTimers();
-  }
-  GPUTimer(Streams& streams, const std::string& name, size_t end, size_t start = 0)
-    : mName(name)
-  {
-    for (size_t sta{start}; sta < end; ++sta) {
-      mStreams.push_back(streams[sta].get());
-    }
-    startTimers();
-  }
-  GPUTimer(Stream& stream, const std::string& name)
-    : mName(name)
-  {
-    mStreams.push_back(stream.get());
-    startTimers();
-  }
-  ~GPUTimer()
-  {
-    for (size_t i{0}; i < mStreams.size(); ++i) {
-      GPUChkErrS(cudaEventRecord(mStops[i], mStreams[i]));
-      GPUChkErrS(cudaEventSynchronize(mStops[i]));
-      float ms = 0.0f;
-      GPUChkErrS(cudaEventElapsedTime(&ms, mStarts[i], mStops[i]));
-      LOGP(info, "Elapsed time for {}:{} {} ms", mName, i, ms);
-      GPUChkErrS(cudaEventDestroy(mStarts[i]));
-      GPUChkErrS(cudaEventDestroy(mStops[i]));
-    }
-  }
-
-  void startTimers()
-  {
-    mStarts.resize(mStreams.size());
-    mStops.resize(mStreams.size());
-    for (size_t i{0}; i < mStreams.size(); ++i) {
-      GPUChkErrS(cudaEventCreate(&mStarts[i]));
-      GPUChkErrS(cudaEventCreate(&mStops[i]));
-      GPUChkErrS(cudaEventRecord(mStarts[i], mStreams[i]));
-    }
-  }
-
- private:
-  std::string mName;
-  std::vector<cudaEvent_t> mStarts, mStops;
-  std::vector<cudaStream_t> mStreams;
-};
-
-#define GPULog(...) LOGP(info, __VA_ARGS__)
-#else // ITS_MEASURE_GPU_TIME not defined
-class GPUTimer
-{
- public:
-  template <typename... Args>
-  GPUTimer(Args&&...)
-  {
-  }
-};
-
-#define GPULog(...)
-#endif
-
 template <int nLayers>
 TimeFrameGPU<nLayers>::TimeFrameGPU()
 {
   this->mIsGPU = true;
 }
 
-template <int nLayers>
-TimeFrameGPU<nLayers>::~TimeFrameGPU() = default;
-
 template <int nLayers>
 void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& stream, bool extAllocator)
 {
@@ -133,16 +56,10 @@ void TimeFrameGPU<nLayers>::allocMem(void** ptr, size_t size, bool extAllocator)
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::setDevicePropagator(const o2::base::PropagatorImpl<float>* propagator)
-{
-  this->mPropagatorDevice = propagator;
-}
-
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
 {
-  GPUTimer timer(mGpuStreams[0], "loading indextable utils");
+  GPUTimer timer("loading indextable utils");
   if (!iteration) {
     GPULog("gpu-allocation: allocating IndexTableUtils buffer, for {:.2f} MB.", sizeof(IndexTableUtils) / constants::MB);
     allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), this->getExtAllocator());
@@ -152,114 +69,174 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration)
+void TimeFrameGPU<nLayers>::createUnsortedClustersDeviceArray(const int iteration)
 {
   if (!iteration) {
-    GPUTimer timer(mGpuStreams[0], "loading unsorted clusters");
-    for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPULog("gpu-transfer: loading {} unsorted clusters on layer {}, for {:.2f} MB.", this->mUnsortedClusters[iLayer].size(), iLayer, this->mUnsortedClusters[iLayer].size() * sizeof(Cluster) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[iLayer]), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[iLayer], this->getExtAllocator());
-      GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[iLayer], this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
-    }
-    mGpuStreams.sync();
+    GPUTimer timer("creating unsorted clusters array");
     allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpy(mUnsortedClustersDeviceArray, mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice));
+    mPinnedUnsortedClusters.set(nLayers);
+    for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+      GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
+      mPinnedUnsortedClusters.set(iLayer);
+    }
+  }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration, const int layer)
+{
+  if (!iteration) {
+    GPUTimer timer(mGpuStreams[layer], "loading unsorted clusters", layer);
+    GPULog("gpu-transfer: loading {} unsorted clusters on layer {}, for {:.2f} MB.", this->mUnsortedClusters[layer].size(), layer, this->mUnsortedClusters[layer].size() * sizeof(Cluster) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[layer]), this->mUnsortedClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[layer], this->mUnsortedClusters[layer].data(), this->mUnsortedClusters[layer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+    GPUChkErrS(cudaMemcpyAsync(&mUnsortedClustersDeviceArray[layer], &mUnsortedClustersDevice[layer], sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration)
+void TimeFrameGPU<nLayers>::createClustersDeviceArray(const int iteration)
 {
   if (!iteration) {
-    GPUTimer timer(mGpuStreams[0], "loading sorted clusters");
+    GPUTimer timer("creating sorted clusters array");
+    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
+    GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
+    mPinnedClusters.set(nLayers);
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPULog("gpu-transfer: loading {} clusters on layer {}, for {:.2f} MB.", this->mClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(Cluster) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[iLayer]), this->mClusters[iLayer].size() * sizeof(Cluster), mGpuStreams[iLayer], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mClustersDevice[iLayer], this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
+      mPinnedClusters.set(iLayer);
     }
-    mGpuStreams.sync();
-    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
-    GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpy(mClustersDeviceArray, mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaMemcpyHostToDevice));
   }
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration)
+void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration, const int layer)
 {
   if (!iteration) {
-    GPUTimer timer(mGpuStreams[0], "loading sorted clusters");
+    GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
+    GPULog("gpu-transfer: loading {} clusters on layer {}, for {:.2f} MB.", this->mClusters[layer].size(), layer, this->mClusters[layer].size() * sizeof(Cluster) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[layer]), this->mClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mClustersDevice[layer], this->mClusters[layer].data(), this->mClusters[layer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+    GPUChkErrS(cudaMemcpyAsync(&mClustersDeviceArray[layer], &mClustersDevice[layer], sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+  }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createClustersIndexTablesArray(const int iteration)
+{
+  if (!iteration) {
+    GPUTimer timer("creating clustersindextable array");
+    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int*), this->getExtAllocator());
+    GPUChkErrS(cudaHostRegister(mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaHostRegisterPortable));
+    mPinnedClustersIndexTables.set(nLayers);
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPULog("gpu-transfer: loading clusters indextable for layer {} with {} elements, for {:.2f} MB.", iLayer, this->mIndexTables[iLayer].size(), this->mIndexTables[iLayer].size() * sizeof(int) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[iLayer]), this->mIndexTables[iLayer].size() * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[iLayer], this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
+      GPUChkErrS(cudaHostRegister(this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
+      mPinnedClustersIndexTables.set(iLayer);
     }
-    mGpuStreams.sync();
-    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int), this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDeviceArray, mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice));
   }
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration)
+void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration, const int layer)
+{
+  if (!iteration) {
+    GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
+    GPULog("gpu-transfer: loading clusters indextable for layer {} with {} elements, for {:.2f} MB.", layer, this->mIndexTables[layer].size(), this->mIndexTables[layer].size() * sizeof(int) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[layer]), this->mIndexTables[layer].size() * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[layer], this->mIndexTables[layer].data(), this->mIndexTables[layer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+    GPUChkErrS(cudaMemcpyAsync(&mClustersIndexTablesDeviceArray[layer], &mClustersIndexTablesDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+  }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createUsedClustersDeviceArray(const int iteration)
 {
   if (!iteration) {
-    GPUTimer timer(mGpuStreams[0], "creating used clusters flags");
+    GPUTimer timer("creating used clusters flags");
+    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), this->getExtAllocator());
+    GPUChkErrS(cudaHostRegister(mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaHostRegisterPortable));
+    mPinnedUsedClusters.set(nLayers);
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPULog("gpu-transfer: creating {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[iLayer]), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[iLayer], this->getExtAllocator());
-      GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[iLayer], 0, this->mUsedClusters[iLayer].size() * sizeof(unsigned char), mGpuStreams[iLayer].get()));
+      GPUChkErrS(cudaHostRegister(this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaHostRegisterPortable));
+      mPinnedUsedClusters.set(iLayer);
     }
-    mGpuStreams.sync();
-    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDeviceArray, mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration, const int layer)
+{
+  if (!iteration) {
+    GPUTimer timer(mGpuStreams[layer], "creating used clusters flags", layer);
+    GPULog("gpu-transfer: creating {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[layer].size(), layer, this->mUsedClusters[layer].size() * sizeof(unsigned char) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[layer]), this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer], this->getExtAllocator());
+    GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[layer], 0, this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer].get()));
+    GPUChkErrS(cudaMemcpyAsync(&mUsedClustersDeviceArray[layer], &mUsedClustersDevice[layer], sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadUsedClustersDevice()
 {
-  GPUTimer timer(mGpuStreams[0], "loading used clusters flags");
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-    GPULog("gpu-transfer: loading {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mClusters[iLayer].size() * sizeof(unsigned char) / constants::MB);
-    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPUTimer timer(mGpuStreams[iLayer], "loading used clusters flags", iLayer);
+    GPULog("gpu-transfer: loading {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / constants::MB);
+    GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::loadROframeClustersDevice(const int iteration)
+void TimeFrameGPU<nLayers>::createROFrameClustersDeviceArray(const int iteration)
 {
   if (!iteration) {
-    GPUTimer timer(mGpuStreams[0], "loading ROframe clusters");
+    GPUTimer timer("creating ROFrame clusters array");
+    allocMem(reinterpret_cast<void**>(&mROFramesClustersDeviceArray), nLayers * sizeof(int*), this->getExtAllocator());
+    GPUChkErrS(cudaHostRegister(mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaHostRegisterPortable));
+    mPinnedROFramesClusters.set(nLayers);
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPULog("gpu-transfer: loading {} ROframe clusters info on layer {}, for {:.2f} MB.", this->mROFramesClusters[iLayer].size(), iLayer, this->mROFramesClusters[iLayer].size() * sizeof(int) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[iLayer]), this->mROFramesClusters[iLayer].size() * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
-      GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[iLayer], this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+      GPUChkErrS(cudaHostRegister(this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
+      mPinnedROFramesClusters.set(iLayer);
     }
-    mGpuStreams.sync();
-    allocMem(reinterpret_cast<void**>(&mROFrameClustersDeviceArray), nLayers * sizeof(int*), this->getExtAllocator());
-    GPUChkErrS(cudaMemcpy(mROFrameClustersDeviceArray, mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaMemcpyHostToDevice));
   }
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration)
+void TimeFrameGPU<nLayers>::loadROFrameClustersDevice(const int iteration, const int layer)
+{
+  if (!iteration) {
+    GPUTimer timer(mGpuStreams[layer], "loading ROframe clusters", layer);
+    GPULog("gpu-transfer: loading {} ROframe clusters info on layer {}, for {:.2f} MB.", this->mROFramesClusters[layer].size(), layer, this->mROFramesClusters[layer].size() * sizeof(int) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[layer]), this->mROFramesClusters[layer].size() * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[layer], this->mROFramesClusters[layer].data(), this->mROFramesClusters[layer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+    GPUChkErrS(cudaMemcpyAsync(&mROFramesClustersDeviceArray[layer], &mROFramesClustersDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+  }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createTrackingFrameInfoDeviceArray(const int iteration)
 {
-  GPUTimer timer(mGpuStreams[0], "loading trackingframeinfo");
   if (!iteration) {
+    GPUTimer timer("creating trackingframeinfo array");
+    allocMem(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), this->getExtAllocator());
+    GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
+    mPinnedTrackingFrameInfo.set(nLayers);
     for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPULog("gpu-transfer: loading {} tfinfo on layer {}, for {:.2f} MB.", this->mTrackingFrameInfo[iLayer].size(), iLayer, this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[iLayer]), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), mGpuStreams[iLayer], this->getExtAllocator());
       GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
-      GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[iLayer], this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
+      mPinnedTrackingFrameInfo.set(iLayer);
     }
-    mGpuStreams.sync();
-    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), mGpuStreams[0], this->getExtAllocator());
-    GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
-    GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDeviceArray, mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration, const int layer)
+{
+  if (!iteration) {
+    GPUTimer timer(mGpuStreams[layer], "loading trackingframeinfo", layer);
+    GPULog("gpu-transfer: loading {} tfinfo on layer {}, for {:.2f} MB.", this->mTrackingFrameInfo[layer].size(), layer, this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[layer]), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), mGpuStreams[layer], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[layer], this->mTrackingFrameInfo[layer].data(), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+    GPUChkErrS(cudaMemcpyAsync(&mTrackingFrameInfoDeviceArray[layer], &mTrackingFrameInfoDevice[layer], sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
 }
 
@@ -267,8 +244,8 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
 {
   if (!iteration || iteration == 3) { // we need to re-load the swapped mult-mask in upc iteration
-    GPUTimer timer(mGpuStreams[0], "loading multiplicity cut mask");
-    GPULog("gpu-transfer: iteration {} loading multiplicity cut mask with {} elements, for {:.2f} MB.", iteration, this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(bool) / constants::MB);
+    GPUTimer timer("loading multiplicity cut mask");
+    GPULog("gpu-transfer: iteration {} loading multiplicity cut mask with {} elements, for {:.2f} MB.", iteration, this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(uint8_t) / constants::MB);
     if (!iteration) { // only allocate on first call
       allocMem(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), this->getExtAllocator());
     }
@@ -280,7 +257,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
 {
   if (!iteration) {
-    GPUTimer timer(mGpuStreams[0], "loading seeding vertices");
+    GPUTimer timer("loading seeding vertices");
     GPULog("gpu-transfer: loading {} ROframes vertices, for {:.2f} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / constants::MB);
     allocMem(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), this->getExtAllocator());
     GPUChkErrS(cudaMemcpy(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice));
@@ -291,35 +268,47 @@ void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration)
+void TimeFrameGPU<nLayers>::createTrackletsLUTDeviceArray(const int iteration)
 {
-  GPUTimer timer(mGpuStreams[0], "creating tracklets LUTs");
-  for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
-    const int ncls = this->mClusters[iLayer].size() + 1;
-    if (!iteration) {
-      GPULog("gpu-transfer: creating tracklets LUT for {} elements on layer {}, for {:.2f} MB.", ncls, iLayer, ncls * sizeof(int) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[iLayer]), ncls * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
-    }
-    GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[iLayer], 0, ncls * sizeof(int), mGpuStreams[iLayer].get()));
+  if (!iteration) {
+    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), this->getExtAllocator());
   }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration, const int layer)
+{
+  GPUTimer timer(mGpuStreams[layer], "creating tracklets LUTs", layer);
+  const int ncls = this->mClusters[layer].size() + 1;
   if (!iteration) {
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
-    GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), mTrackletsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+    GPULog("gpu-allocation: creating tracklets LUT for {} elements on layer {}, for {:.2f} MB.", ncls, layer, ncls * sizeof(int) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[layer]), ncls * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+    GPUChkErrS(cudaMemcpyAsync(&mTrackletsLUTDeviceArray[layer], &mTrackletsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
+  GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[layer], 0, ncls * sizeof(int), mGpuStreams[layer].get()));
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackletsBuffers()
+void TimeFrameGPU<nLayers>::createTrackletsBuffersArray(const int iteration)
 {
-  for (int iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
-    GPUTimer timer(mGpuStreams[iLayer], "creating tracklet buffers");
-    mNTracklets[iLayer] = 0;
-    GPUChkErrS(cudaMemcpyAsync(&mNTracklets[iLayer], mTrackletsLUTDevice[iLayer] + this->mClusters[iLayer].size(), sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
-    GPULog("gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {:.2f} MB.", mNTracklets[iLayer], iLayer, mNTracklets[iLayer] * sizeof(Tracklet) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iLayer]), mNTracklets[iLayer] * sizeof(Tracklet), mGpuStreams[iLayer], this->getExtAllocator());
+  if (!iteration) {
+    GPUTimer timer("creating tracklet buffers array");
+    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), this->getExtAllocator());
   }
 }
 
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createTrackletsBuffers(const int layer)
+{
+  GPUTimer timer(mGpuStreams[layer], "creating tracklet buffers", layer);
+  mNTracklets[layer] = 0;
+  GPUChkErrS(cudaMemcpyAsync(&mNTracklets[layer], mTrackletsLUTDevice[layer] + this->mClusters[layer].size(), sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
+  mGpuStreams[layer].sync(); // ensure number of tracklets is correct
+  GPULog("gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer], layer, mNTracklets[layer] * sizeof(Tracklet) / constants::MB);
+  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[layer]), mNTracklets[layer] * sizeof(Tracklet), mGpuStreams[layer], this->getExtAllocator());
+  GPUChkErrS(cudaMemcpyAsync(&mTrackletsDeviceArray[layer], &mTrackletsDevice[layer], sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+}
+
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackletsDevice()
 {
@@ -334,26 +323,22 @@ void TimeFrameGPU<nLayers>::loadTrackletsDevice()
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
 {
-  GPUTimer timer(mGpuStreams, "loading tracklets", nLayers - 2);
+  GPUTimer timer("loading tracklets");
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     GPULog("gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {:.2f} MB", this->mTrackletsLookupTable[iLayer].size(), iLayer + 1, this->mTrackletsLookupTable[iLayer].size() * sizeof(int) / constants::MB);
-    GPUChkErrS(cudaHostRegister(this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
-  GPUChkErrS(cudaHostRegister(mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  mGpuStreams.sync();
+  GPUChkErrS(cudaMemcpy(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice()
+void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice(const int layer)
 {
-  GPUTimer timer(mGpuStreams[0], "creating cells neighbours");
-  // Here we do also the creation of the CellsDeviceArray, as the cells buffers are populated separately in the previous steps.
-  for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    GPULog("gpu-transfer: loading neighbours LUT for {} elements on layer {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
-    GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (mNCells[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer].get()));
-  }
+  GPUTimer timer(mGpuStreams[layer], "creating cells neighbours", layer);
+  GPULog("gpu-transfer: reserving neighbours LUT for {} elements on layer {}, for {:.2f} MB.", mNCells[layer] + 1, layer, (mNCells[layer] + 1) * sizeof(int) / constants::MB);
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[layer]), (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+  GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[layer], 0, (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer].get()));
 }
 
 template <int nLayers>
@@ -379,16 +364,32 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createCellsLUTDevice()
+void TimeFrameGPU<nLayers>::createCellsLUTDeviceArray(const int iteration)
 {
-  GPUTimer timer(mGpuStreams, "creating cells LUTs", nLayers - 2);
-  for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    GPULog("gpu-transfer: creating cell LUT for {} elements on layer {}, for {:.2f} MB.", mNTracklets[iLayer] + 1, iLayer, (mNTracklets[iLayer] + 1) * sizeof(int) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[iLayer]), (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator());
-    GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[iLayer], 0, (mNTracklets[iLayer] + 1) * sizeof(int), mGpuStreams[iLayer].get()));
+  if (!iteration) {
+    GPUTimer timer("creating cells LUTs array");
+    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), this->getExtAllocator());
+  }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createCellsLUTDevice(const int layer)
+{
+  GPUTimer timer(mGpuStreams[layer], "creating cells LUTs", layer);
+  GPULog("gpu-transfer: creating cell LUT for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer] + 1, layer, (mNTracklets[layer] + 1) * sizeof(int) / constants::MB);
+  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[layer]), (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+  GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[layer], 0, (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer].get()));
+  GPUChkErrS(cudaMemcpyAsync(&mCellsLUTDeviceArray[layer], &mCellsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createCellsBuffersArray(const int iteration)
+{
+  if (!iteration) {
+    GPUTimer timer("creating cells buffers array");
+    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeed*), cudaMemcpyHostToDevice));
   }
-  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(mCellsLUTDeviceArray, mCellsLUTDevice.data(), mCellsLUTDevice.size() * sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
 }
 
 template <int nLayers>
@@ -397,8 +398,10 @@ void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
   GPUTimer timer(mGpuStreams[layer], "creating cells buffers");
   mNCells[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
+  mGpuStreams[layer].sync(); // ensure number of cells is correct
   GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), mGpuStreams[layer], this->getExtAllocator());
+  GPUChkErrS(cudaMemcpyAsync(&mCellsDeviceArray[layer], &mCellsDevice[layer], sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
 template <int nLayers>
@@ -415,43 +418,45 @@ void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadRoadsDevice()
 {
-  GPUTimer timer(mGpuStreams[0], "loading roads device");
+  GPUTimer timer("loading roads device");
   GPULog("gpu-transfer: loading {} roads, for {:.2f} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), mGpuStreams[0], this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpy(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice));
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeed>& seeds)
 {
-  GPUTimer timer(mGpuStreams[0], "loading track seeds");
+  GPUTimer timer("loading track seeds");
   GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), mGpuStreams[0], this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), this->getExtAllocator());
   GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpyAsync(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpy(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice));
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer)
 {
-  GPUTimer timer(mGpuStreams[layer], "reserving neighbours");
+  GPUTimer timer(mGpuStreams[layer], "reserving neighbours", layer);
+  this->mNNeighbours[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&(this->mNNeighbours[layer]), &(mNeighboursLUTDevice[layer][this->mNCells[layer + 1] - 1]), sizeof(unsigned int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
-  GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / constants::MB);
+  mGpuStreams[layer].sync(); // ensure number of neighbours is correct
+  GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer], this->getExtAllocator());
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer].get()));
-  GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", nNeighbours, nNeighbours * sizeof(gpuPair<int, int>) / constants::MB);
+  GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
-  GPUTimer timer(mGpuStreams[0], "reserving tracks");
+  GPUTimer timer("reserving tracks");
   mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
   GPULog("gpu-allocation: reserving {} tracks, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0], this->getExtAllocator());
-  GPUChkErrS(cudaMemsetAsync(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt), mGpuStreams[0].get()));
+  allocMem(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), this->getExtAllocator());
+  GPUChkErrS(cudaMemset(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt)));
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
 }
 
@@ -480,26 +485,25 @@ void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>& neighbours, const int layer)
 {
-  GPUTimer timer(mGpuStreams[0], fmt::format("downloading neighbours from layer {}", layer));
+  GPUTimer timer(mGpuStreams[layer], "downloading neighbours from layer", layer);
   GPULog("gpu-transfer: downloading {} neighbours, for {:.2f} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / constants::MB);
-  // TODO: something less dangerous than assuming the same memory layout of std::pair and gpuPair... or not? :)
-  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut, const int layer)
 {
-  GPUTimer timer(mGpuStreams[0], fmt::format("downloading neighbours LUT from layer {}", layer));
+  GPUTimer timer(mGpuStreams[layer], "downloading neighbours LUT from layer", layer);
   GPULog("gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {:.2f} MB.", lut.size(), layer, lut.size() * sizeof(int) / constants::MB);
-  GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
 {
-  GPUTimer timer(mGpuStreams[0], "downloading tracks");
+  GPUTimer timer("downloading tracks");
   GPULog("gpu-transfer: downloading {} tracks, for {:.2f} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
-  GPUChkErrS(cudaMemcpyAsync(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost, mGpuStreams[0].get()));
+  GPUChkErrS(cudaMemcpy(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost));
   GPUChkErrS(cudaHostUnregister(mTrackITSExt.data()));
   GPUChkErrS(cudaHostUnregister(seeds.data()));
 }
@@ -507,16 +511,36 @@ void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeed>&
 template <int nLayers>
 void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
 {
-  GPUTimer timer(mGpuStreams[0], "unregistering host memory");
+  GPUTimer timer("unregistering host memory");
   GPULog("unregistering host memory");
+
+  auto checkedUnregisterEntry = [](auto& bits, auto& vec, int layer) {
+    if (bits.test(layer)) {
+      GPUChkErrS(cudaHostUnregister(vec[layer].data()));
+      bits.reset(layer);
+    }
+  };
+  auto checkedUnregisterArray = [](auto& bits, auto& vec) {
+    if (bits.test(nLayers)) {
+      GPUChkErrS(cudaHostUnregister(vec.data()));
+      bits.reset(nLayers);
+    }
+  };
+
   for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-    GPUChkErrS(cudaHostUnregister(this->mUnsortedClusters[iLayer].data()));
-    GPUChkErrS(cudaHostUnregister(this->mClusters[iLayer].data()));
-    GPUChkErrS(cudaHostUnregister(this->mTrackingFrameInfo[iLayer].data()));
+    checkedUnregisterEntry(mPinnedUsedClusters, this->mUsedClusters, iLayer);
+    checkedUnregisterEntry(mPinnedUnsortedClusters, this->mUnsortedClusters, iLayer);
+    checkedUnregisterEntry(mPinnedClusters, this->mClusters, iLayer);
+    checkedUnregisterEntry(mPinnedClustersIndexTables, this->mIndexTables, iLayer);
+    checkedUnregisterEntry(mPinnedTrackingFrameInfo, this->mTrackingFrameInfo, iLayer);
+    checkedUnregisterEntry(mPinnedROFramesClusters, this->mROFramesClusters, iLayer);
   }
-  GPUChkErrS(cudaHostUnregister(mTrackingFrameInfoDevice.data()));
-  GPUChkErrS(cudaHostUnregister(mUnsortedClustersDevice.data()));
-  GPUChkErrS(cudaHostUnregister(mClustersDevice.data()));
+  checkedUnregisterArray(mPinnedUsedClusters, mUsedClustersDevice);
+  checkedUnregisterArray(mPinnedUnsortedClusters, mUnsortedClustersDevice);
+  checkedUnregisterArray(mPinnedClusters, mClustersDevice);
+  checkedUnregisterArray(mPinnedClustersIndexTables, mClustersIndexTablesDevice);
+  checkedUnregisterArray(mPinnedTrackingFrameInfo, mTrackingFrameInfoDevice);
+  checkedUnregisterArray(mPinnedROFramesClusters, mROFramesClustersDevice);
 }
 
 template <int nLayers>
@@ -537,9 +561,29 @@ void TimeFrameGPU<nLayers>::syncStream(const size_t stream)
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::syncStreams()
+void TimeFrameGPU<nLayers>::syncStreams(const bool device)
 {
-  mGpuStreams.sync();
+  mGpuStreams.sync(device);
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::waitEvent(const int stream, const int event)
+{
+  mGpuStreams.waitEvent(stream, event);
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::recordEvent(const int event)
+{
+  mGpuStreams[event].record();
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::recordEvents(const int start, const int end)
+{
+  for (int i{start}; i < end; ++i) {
+    recordEvent(i);
+  }
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index bef271a1b0129..a6dfc041e4c71 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -11,6 +11,7 @@
 ///
 
 #include <array>
+#include <vector>
 #include <unistd.h>
 
 #include "DataFormatsITS/TrackITS.h"
@@ -27,15 +28,21 @@ template <int nLayers>
 void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
 {
   mTimeFrameGPU->initialise(iteration, this->mTrkParams[iteration], nLayers);
-  mTimeFrameGPU->loadClustersDevice(iteration);
-  mTimeFrameGPU->loadUnsortedClustersDevice(iteration);
-  mTimeFrameGPU->loadClustersIndexTables(iteration);
-  mTimeFrameGPU->loadTrackingFrameInfoDevice(iteration);
-  mTimeFrameGPU->loadMultiplicityCutMask(iteration);
+
+  // on default stream
   mTimeFrameGPU->loadVertices(iteration);
-  mTimeFrameGPU->loadROframeClustersDevice(iteration);
-  mTimeFrameGPU->createUsedClustersDevice(iteration);
   mTimeFrameGPU->loadIndexTableUtils(iteration);
+  mTimeFrameGPU->loadMultiplicityCutMask(iteration);
+  mTimeFrameGPU->createUsedClustersDeviceArray(iteration);
+  mTimeFrameGPU->createClustersDeviceArray(iteration);
+  mTimeFrameGPU->createUnsortedClustersDeviceArray(iteration);
+  mTimeFrameGPU->createClustersIndexTablesArray(iteration);
+  mTimeFrameGPU->createTrackingFrameInfoDeviceArray(iteration);
+  mTimeFrameGPU->createROFrameClustersDeviceArray(iteration);
+  mTimeFrameGPU->createTrackletsLUTDeviceArray(iteration);
+  mTimeFrameGPU->createTrackletsBuffersArray(iteration);
+  mTimeFrameGPU->createCellsBuffersArray(iteration);
+  mTimeFrameGPU->createCellsLUTDeviceArray(iteration);
 }
 
 template <int nLayers>
@@ -53,40 +60,23 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
   int startROF{this->mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * this->mTrkParams[iteration].nROFsPerIterations : 0};
   int endROF{o2::gpu::CAMath::Min(this->mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * this->mTrkParams[iteration].nROFsPerIterations + this->mTrkParams[iteration].DeltaROF : mTimeFrameGPU->getNrof(), mTimeFrameGPU->getNrof())};
 
-  mTimeFrameGPU->createTrackletsLUTDevice(iteration);
-  countTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
-                                       mTimeFrameGPU->getDeviceMultCutMask(),
-                                       startROF,
-                                       endROF,
-                                       mTimeFrameGPU->getNrof(),
-                                       this->mTrkParams[iteration].DeltaROF,
-                                       iVertex,
-                                       mTimeFrameGPU->getDeviceVertices(),
-                                       mTimeFrameGPU->getDeviceROFramesPV(),
-                                       mTimeFrameGPU->getPrimaryVerticesNum(),
-                                       mTimeFrameGPU->getDeviceArrayClusters(),
-                                       mTimeFrameGPU->getClusterSizes(),
-                                       mTimeFrameGPU->getDeviceROframeClusters(),
-                                       mTimeFrameGPU->getDeviceArrayUsedClusters(),
-                                       mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
-                                       mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
-                                       mTimeFrameGPU->getDeviceTrackletsLUTs(), // Required for the exclusive sums
-                                       iteration,
-                                       this->mTrkParams[iteration].NSigmaCut,
-                                       mTimeFrameGPU->getPhiCuts(),
-                                       this->mTrkParams[iteration].PVres,
-                                       mTimeFrameGPU->getMinRs(),
-                                       mTimeFrameGPU->getMaxRs(),
-                                       mTimeFrameGPU->getPositionResolutions(),
-                                       this->mTrkParams[iteration].LayerRadii,
-                                       mTimeFrameGPU->getMSangles(),
-                                       mTimeFrameGPU->getExternalAllocator(),
-                                       conf.nBlocksLayerTracklets[iteration],
-                                       conf.nThreadsLayerTracklets[iteration],
-                                       mTimeFrameGPU->getStreams());
-  mTimeFrameGPU->createTrackletsBuffers();
-  computeTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
+  for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
+    // TODO lazy loading of essential data on separate streams
+    mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer);
+    mTimeFrameGPU->loadClustersDevice(iteration, iLayer);
+    mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer);
+    mTimeFrameGPU->loadClustersIndexTables(iteration, iLayer);
+    mTimeFrameGPU->loadROFrameClustersDevice(iteration, iLayer);
+    mTimeFrameGPU->recordEvent(iLayer);
+  }
+
+  // processing starts here
+  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
+    mTimeFrameGPU->createTrackletsLUTDevice(iteration, iLayer);
+    mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
+    countTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
                                          mTimeFrameGPU->getDeviceMultCutMask(),
+                                         iLayer,
                                          startROF,
                                          endROF,
                                          mTimeFrameGPU->getNrof(),
@@ -97,14 +87,11 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getPrimaryVerticesNum(),
                                          mTimeFrameGPU->getDeviceArrayClusters(),
                                          mTimeFrameGPU->getClusterSizes(),
-                                         mTimeFrameGPU->getDeviceROframeClusters(),
+                                         mTimeFrameGPU->getDeviceROFrameClusters(),
                                          mTimeFrameGPU->getDeviceArrayUsedClusters(),
                                          mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
-                                         mTimeFrameGPU->getDeviceArrayTracklets(),
-                                         mTimeFrameGPU->getDeviceTracklet(),
-                                         mTimeFrameGPU->getNTracklets(),
                                          mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
-                                         mTimeFrameGPU->getDeviceTrackletsLUTs(),
+                                         mTimeFrameGPU->getDeviceTrackletsLUTs(), // Required for the exclusive sums
                                          iteration,
                                          this->mTrkParams[iteration].NSigmaCut,
                                          mTimeFrameGPU->getPhiCuts(),
@@ -118,24 +105,69 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          conf.nBlocksLayerTracklets[iteration],
                                          conf.nThreadsLayerTracklets[iteration],
                                          mTimeFrameGPU->getStreams());
+    mTimeFrameGPU->createTrackletsBuffers(iLayer);
+    if (mTimeFrameGPU->getNTracklets()[iLayer] == 0) {
+      return;
+    }
+    computeTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
+                                           mTimeFrameGPU->getDeviceMultCutMask(),
+                                           iLayer,
+                                           startROF,
+                                           endROF,
+                                           mTimeFrameGPU->getNrof(),
+                                           this->mTrkParams[iteration].DeltaROF,
+                                           iVertex,
+                                           mTimeFrameGPU->getDeviceVertices(),
+                                           mTimeFrameGPU->getDeviceROFramesPV(),
+                                           mTimeFrameGPU->getPrimaryVerticesNum(),
+                                           mTimeFrameGPU->getDeviceArrayClusters(),
+                                           mTimeFrameGPU->getClusterSizes(),
+                                           mTimeFrameGPU->getDeviceROFrameClusters(),
+                                           mTimeFrameGPU->getDeviceArrayUsedClusters(),
+                                           mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
+                                           mTimeFrameGPU->getDeviceArrayTracklets(),
+                                           mTimeFrameGPU->getDeviceTracklets(),
+                                           mTimeFrameGPU->getNTracklets(),
+                                           mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
+                                           mTimeFrameGPU->getDeviceTrackletsLUTs(),
+                                           iteration,
+                                           this->mTrkParams[iteration].NSigmaCut,
+                                           mTimeFrameGPU->getPhiCuts(),
+                                           this->mTrkParams[iteration].PVres,
+                                           mTimeFrameGPU->getMinRs(),
+                                           mTimeFrameGPU->getMaxRs(),
+                                           mTimeFrameGPU->getPositionResolutions(),
+                                           this->mTrkParams[iteration].LayerRadii,
+                                           mTimeFrameGPU->getMSangles(),
+                                           mTimeFrameGPU->getExternalAllocator(),
+                                           conf.nBlocksLayerTracklets[iteration],
+                                           conf.nThreadsLayerTracklets[iteration],
+                                           mTimeFrameGPU->getStreams());
+  }
 }
 
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
 {
-  mTimeFrameGPU->createCellsLUTDevice();
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  mTimeFrameGPU->syncStream(0);
-  for (int iLayer = 0; iLayer < this->mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-    mTimeFrameGPU->syncStream(iLayer + 1);
+  for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
+    // TODO lazy loading of essential data on separate streams
+    mTimeFrameGPU->loadTrackingFrameInfoDevice(iteration, iLayer);
+    mTimeFrameGPU->recordEvent(iLayer);
+  }
 
+  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
     // if there are no tracklets skip entirely
     const int currentLayerTrackletsNum{static_cast<int>(mTimeFrameGPU->getNTracklets()[iLayer])};
     if (!currentLayerTrackletsNum || !mTimeFrameGPU->getNTracklets()[iLayer + 1]) {
       mTimeFrameGPU->getNCells()[iLayer] = 0;
-      continue;
+      return;
     }
+
+    mTimeFrameGPU->createCellsLUTDevice(iLayer);
+    mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
+    mTimeFrameGPU->waitEvent(iLayer, iLayer + 2); // wait stream until all data is available
     countCellsHandler(mTimeFrameGPU->getDeviceArrayClusters(),
                       mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
                       mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
@@ -156,6 +188,9 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                       conf.nThreadsLayerCells[iteration],
                       mTimeFrameGPU->getStreams());
     mTimeFrameGPU->createCellsBuffers(iLayer);
+    if (mTimeFrameGPU->getNCells()[iLayer] == 0) {
+      return;
+    }
     computeCellsHandler(mTimeFrameGPU->getDeviceArrayClusters(),
                         mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
                         mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
@@ -180,21 +215,16 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
 {
-  mTimeFrameGPU->createNeighboursIndexTablesDevice();
   const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  mTimeFrameGPU->syncStream(0);
-  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].CellsPerRoad() - 1; ++iLayer) {
-    // ensure that celling is done for iLayer and iLayer+1 is done
-    mTimeFrameGPU->syncStream(iLayer + 1);
-
+  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].NeighboursPerRoad(); ++iLayer) {
     const int currentLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer])};
     const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};
     if (!nextLayerCellsNum || !currentLayerCellsNum) {
       mTimeFrameGPU->getNNeighbours()[iLayer] = 0;
       continue;
     }
-
+    mTimeFrameGPU->createNeighboursIndexTablesDevice(iLayer);
     mTimeFrameGPU->createNeighboursLUTDevice(iLayer, nextLayerCellsNum);
     countCellNeighboursHandler(mTimeFrameGPU->getDeviceArrayCells(),
                                mTimeFrameGPU->getDeviceNeighboursLUT(iLayer), // LUT is initialised here.
@@ -214,6 +244,9 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                conf.nThreadsFindNeighbours[iteration],
                                mTimeFrameGPU->getStream(iLayer));
     mTimeFrameGPU->createNeighboursDevice(iLayer);
+    if (mTimeFrameGPU->getNNeighbours()[iLayer] == 0) {
+      continue;
+    }
     computeCellNeighboursHandler(mTimeFrameGPU->getDeviceArrayCells(),
                                  mTimeFrameGPU->getDeviceNeighboursLUT(iLayer),
                                  mTimeFrameGPU->getDeviceArrayCellsLUT(),
@@ -236,8 +269,8 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                                                                mTimeFrameGPU->getStream(iLayer),
                                                                                mTimeFrameGPU->getExternalAllocator());
   }
-  mTimeFrameGPU->syncStreams(); // TODO evaluate if this can be removed
-};
+  mTimeFrameGPU->syncStreams(false);
+}
 
 template <int nLayers>
 void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 401d98ad63560..9b3df193abe34 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -14,7 +14,6 @@
 #include <array>
 #include <unistd.h>
 
-#include <cub/cub.cuh>
 #include <thrust/execution_policy.h>
 #include <thrust/device_ptr.h>
 #include <thrust/device_vector.h>
@@ -23,16 +22,17 @@
 #include <thrust/functional.h>
 #include <thrust/unique.h>
 #include <thrust/remove.h>
-#include <thrust/sequence.h>
 
 #include "ITStracking/Constants.h"
+#include "ITStracking/Definitions.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/ExternalAllocator.h"
+#include "ITStracking/Tracklet.h"
+#include "ITStracking/Cluster.h"
+#include "ITStracking/Cell.h"
 #include "DataFormatsITS/TrackITS.h"
-#include "ReconstructionDataFormats/Vertex.h"
 
-#include "ITStrackingGPU/TrackerTraitsGPU.h"
 #include "ITStrackingGPU/TrackingKernels.h"
 #include "ITStrackingGPU/Utils.h"
 
@@ -43,8 +43,6 @@ using namespace o2::track;
 
 namespace o2::its
 {
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
 namespace gpu
 {
 
@@ -92,9 +90,9 @@ struct TypedAllocator {
   ExternalAllocator* mInternalAllocator;
 };
 
-GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                              const o2::its::IndexTableUtils& utils,
-                              const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
+GPUdii() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
+                                const o2::its::IndexTableUtils& utils,
+                                const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
 {
   const float zRangeMin = o2::gpu::CAMath::Min(z1, z2) - maxdeltaz;
   const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : currentCluster.phi - maxdeltaphi;
@@ -112,18 +110,18 @@ GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerInde
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
 }
 
-GPUd() bool fitTrack(TrackITSExt& track,
-                     int start,
-                     int end,
-                     int step,
-                     float chi2clcut,
-                     float chi2ndfcut,
-                     float maxQoverPt,
-                     int nCl,
-                     float bz,
-                     const TrackingFrameInfo** tfInfos,
-                     const o2::base::Propagator* prop,
-                     o2::base::PropagatorF::MatCorrType matCorrType)
+GPUdii() bool fitTrack(TrackITSExt& track,
+                       int start,
+                       int end,
+                       int step,
+                       float chi2clcut,
+                       float chi2ndfcut,
+                       float maxQoverPt,
+                       int nCl,
+                       float bz,
+                       const TrackingFrameInfo** tfInfos,
+                       const o2::base::Propagator* prop,
+                       o2::base::PropagatorF::MatCorrType matCorrType)
 {
   for (int iLayer{start}; iLayer != end; iLayer += step) {
     if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
@@ -164,10 +162,10 @@ GPUd() bool fitTrack(TrackITSExt& track,
   return o2::gpu::CAMath::Abs(track.getQ2Pt()) < maxQoverPt && track.getChi2() < chi2ndfcut * (nCl * 2 - 5);
 }
 
-GPUd() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
-                                             const Cluster& cluster2,
-                                             const TrackingFrameInfo& tf3,
-                                             const float bz)
+GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
+                                               const Cluster& cluster2,
+                                               const TrackingFrameInfo& tf3,
+                                               const float bz)
 {
   const float ca = o2::gpu::CAMath::Cos(tf3.alphaTrackingFrame), sa = o2::gpu::CAMath::Sin(tf3.alphaTrackingFrame);
   const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
@@ -368,7 +366,7 @@ GPUg() void fitTrackSeedsKernel(
   }
 }
 
-template <bool initRun, int nLayers = 7> // Version for new tracker to supersede the old one
+template <bool initRun, int nLayers = 7>
 GPUg() void computeLayerCellNeighboursKernel(
   CellSeed** cellSeedArray,
   int* neighboursLUT,
@@ -519,7 +517,7 @@ GPUg() void computeLayerCellsKernel(
   }
 }
 
-template <bool initRun = true, int nLayers = 7>
+template <bool initRun>
 GPUg() void computeLayerTrackletsMultiROFKernel(
   const IndexTableUtils* utils,
   const uint8_t* multMask,
@@ -578,6 +576,11 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
       if (usedClusters[layerIndex][currentCluster.clusterId]) {
         continue;
       }
+      if constexpr (!initRun) {
+        if (trackletsLUT[layerIndex][currentSortedIndex] == trackletsLUT[layerIndex][currentSortedIndex + 1]) {
+          continue;
+        }
+      }
 
       const float inverseR0{1.f / currentCluster.radius};
       for (int iV{startVtx}; iV < endVtx; ++iV) {
@@ -642,7 +645,6 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
   }
 }
 
-template <int nLayers = 7>
 GPUg() void compileTrackletsLookupTableKernel(const Tracklet* tracklets,
                                               int* trackletsLookUpTable,
                                               const int nTracklets)
@@ -741,133 +743,6 @@ GPUg() void processNeighboursKernel(const int layer,
   }
 }
 
-/////////////////////////////////////////
-// Debug Kernels
-/////////////////////////////////////////
-
-template <typename T>
-GPUd() void pPointer(T* ptr)
-{
-  printf("[%p]\t", ptr);
-}
-
-template <typename... Args>
-GPUg() void printPointersKernel(std::tuple<Args...> args)
-{
-  auto print_all = [&](auto... ptrs) {
-    (pPointer(ptrs), ...);
-  };
-  std::apply(print_all, args);
-}
-
-template <typename T>
-struct trackletSortEmptyFunctor {
-  GPUhd() bool operator()(const T& lhs, const T& rhs) const
-  {
-    return lhs.firstClusterIndex > rhs.firstClusterIndex;
-  }
-};
-
-template <typename T>
-struct trackletSortIndexFunctor {
-  GPUhd() bool operator()(const T& lhs, const T& rhs) const
-  {
-    return lhs.firstClusterIndex < rhs.firstClusterIndex || (lhs.firstClusterIndex == rhs.firstClusterIndex && lhs.secondClusterIndex < rhs.secondClusterIndex);
-  }
-};
-
-GPUg() void printBufferLayerOnThread(const int layer, const int* v, unsigned int size, const int len = 150, const unsigned int tId = 0)
-{
-  if (blockIdx.x * blockDim.x + threadIdx.x == tId) {
-    for (int i{0}; i < size; ++i) {
-      if (!(i % len)) {
-        printf("\n layer %d: ===> %d/%d\t", layer, i, (int)size);
-      }
-      printf("%d\t", v[i]);
-    }
-    printf("\n");
-  }
-}
-
-GPUg() void printMatrixRow(const int row, int** mat, const unsigned int rowLength, const int len = 150, const unsigned int tId = 0)
-{
-  if (blockIdx.x * blockDim.x + threadIdx.x == tId) {
-    for (int i{0}; i < rowLength; ++i) {
-      if (!(i % len)) {
-        printf("\n row %d: ===> %d/%d\t", row, i, (int)rowLength);
-      }
-      printf("%d\t", mat[row][i]);
-    }
-    printf("\n");
-  }
-}
-
-GPUg() void printBufferPointersLayerOnThread(const int layer, void** v, unsigned int size, const int len = 150, const unsigned int tId = 0)
-{
-  if (blockIdx.x * blockDim.x + threadIdx.x == tId) {
-    for (int i{0}; i < size; ++i) {
-      if (!(i % len)) {
-        printf("\n layer %d: ===> %d/%d\t", layer, i, (int)size);
-      }
-      printf("%p\t", (void*)v[i]);
-    }
-    printf("\n");
-  }
-}
-
-GPUg() void printVertices(const Vertex* v, unsigned int size, const unsigned int tId = 0)
-{
-  if (blockIdx.x * blockDim.x + threadIdx.x == tId) {
-    printf("vertices: \n");
-    for (int i{0}; i < size; ++i) {
-      printf("\tx=%f y=%f z=%f\n", v[i].getX(), v[i].getY(), v[i].getZ());
-    }
-  }
-}
-
-GPUg() void printNeighbours(const gpuPair<int, int>* neighbours,
-                            const int* nNeighboursIndexTable,
-                            const unsigned int nCells,
-                            const unsigned int tId = 0)
-{
-  for (unsigned int iNeighbour{0}; iNeighbour < nNeighboursIndexTable[nCells]; ++iNeighbour) {
-    if (threadIdx.x == tId) {
-      printf("%d -> %d\n", neighbours[iNeighbour].first, neighbours[iNeighbour].second);
-    }
-  }
-}
-
-GPUg() void printTrackletsLUTPerROF(const int layerId,
-                                    const int** ROFClusters,
-                                    int** luts,
-                                    const int tId = 0)
-{
-  if (blockIdx.x * blockDim.x + threadIdx.x == tId) {
-    for (auto rofId{0}; rofId < 2304; ++rofId) {
-      int nClus = ROFClusters[layerId][rofId + 1] - ROFClusters[layerId][rofId];
-      if (!nClus) {
-        continue;
-      }
-      printf("rof: %d (%d) ==> ", rofId, nClus);
-
-      for (int iC{0}; iC < nClus; ++iC) {
-        int nT = luts[layerId][ROFClusters[layerId][rofId] + iC];
-        printf("%d\t", nT);
-      }
-      printf("\n");
-    }
-  }
-}
-
-GPUg() void printCellSeeds(CellSeed* seed, int nCells, const unsigned int tId = 0)
-{
-  for (unsigned int iCell{0}; iCell < nCells; ++iCell) {
-    if (threadIdx.x == tId) {
-      seed[iCell].printCell();
-    }
-  }
-}
-
 GPUhi() void allocateMemory(void** p, size_t bytes, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
 {
   if (alloc) {
@@ -885,45 +760,12 @@ GPUhi() void deallocateMemory(void* p, size_t bytes, cudaStream_t stream = nullp
     GPUChkErrS(cudaFreeAsync(p, stream));
   }
 }
-
-template <typename T>
-GPUhi() void cubExclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
-{
-  void* d_temp_storage = nullptr;
-  size_t temp_storage_bytes = 0;
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  allocateMemory(&d_temp_storage, temp_storage_bytes, stream, alloc);
-  GPUChkErrS(cub::DeviceScan::ExclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  deallocateMemory(d_temp_storage, temp_storage_bytes, stream, alloc);
-}
-
-template <typename Vector>
-GPUhi() void cubExclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
-{
-  cubExclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream, alloc);
-}
-
-template <typename T>
-GPUhi() void cubInclusiveScanInPlace(T* in_out, int num_items, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
-{
-  void* d_temp_storage = nullptr;
-  size_t temp_storage_bytes = 0;
-  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  allocateMemory(&d_temp_storage, temp_storage_bytes, stream, alloc);
-  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in_out, in_out, num_items, stream));
-  deallocateMemory(d_temp_storage, temp_storage_bytes, stream, alloc);
-}
-
-template <typename Vector>
-GPUhi() void cubInclusiveScanInPlace(Vector& in_out, int num_items, cudaStream_t stream = nullptr, o2::its::ExternalAllocator* alloc = nullptr)
-{
-  cubInclusiveScanInPlace(thrust::raw_pointer_cast(in_out.data()), num_items, stream, alloc);
-}
 } // namespace gpu
 
 template <int nLayers>
 void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  const uint8_t* multMask,
+                                 const int layer,
                                  const int startROF,
                                  const int endROF,
                                  const int maxROF,
@@ -953,41 +795,41 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  const int nThreads,
                                  gpu::Streams& streams)
 {
-  for (int iLayer = 0; iLayer < nLayers - 1; ++iLayer) {
-    gpu::computeLayerTrackletsMultiROFKernel<true><<<nBlocks, nThreads, 0, streams[iLayer].get()>>>(
-      utils,
-      multMask,
-      iLayer,
-      startROF,
-      endROF,
-      maxROF,
-      deltaROF,
-      vertices,
-      rofPV,
-      nVertices,
-      vertexId,
-      clusters,
-      ROFClusters,
-      usedClusters,
-      clustersIndexTables,
-      nullptr,
-      trackletsLUTs,
-      iteration,
-      NSigmaCut,
-      phiCuts[iLayer],
-      resolutionPV,
-      minRs[iLayer + 1],
-      maxRs[iLayer + 1],
-      resolutions[iLayer],
-      radii[iLayer + 1] - radii[iLayer],
-      mulScatAng[iLayer]);
-    gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get(), alloc);
-  }
+  gpu::computeLayerTrackletsMultiROFKernel<true><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
+    utils,
+    multMask,
+    layer,
+    startROF,
+    endROF,
+    maxROF,
+    deltaROF,
+    vertices,
+    rofPV,
+    nVertices,
+    vertexId,
+    clusters,
+    ROFClusters,
+    usedClusters,
+    clustersIndexTables,
+    nullptr,
+    trackletsLUTs,
+    iteration,
+    NSigmaCut,
+    phiCuts[layer],
+    resolutionPV,
+    minRs[layer + 1],
+    maxRs[layer + 1],
+    resolutions[layer],
+    radii[layer + 1] - radii[layer],
+    mulScatAng[layer]);
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[layer].get());
+  thrust::exclusive_scan(nosync_policy, trackletsLUTsHost[layer], trackletsLUTsHost[layer] + nClusters[layer] + 1, trackletsLUTsHost[layer]);
 }
 
 template <int nLayers>
 void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    const uint8_t* multMask,
+                                   const int layer,
                                    const int startROF,
                                    const int endROF,
                                    const int maxROF,
@@ -1020,66 +862,45 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    const int nThreads,
                                    gpu::Streams& streams)
 {
-  for (int iLayer = 0; iLayer < nLayers - 1; ++iLayer) {
-    gpu::computeLayerTrackletsMultiROFKernel<false><<<nBlocks, nThreads, 0, streams[iLayer].get()>>>(
-      utils,
-      multMask,
-      iLayer,
-      startROF,
-      endROF,
-      maxROF,
-      deltaROF,
-      vertices,
-      rofPV,
-      nVertices,
-      vertexId,
-      clusters,
-      ROFClusters,
-      usedClusters,
-      clustersIndexTables,
-      tracklets,
-      trackletsLUTs,
-      iteration,
-      NSigmaCut,
-      phiCuts[iLayer],
-      resolutionPV,
-      minRs[iLayer + 1],
-      maxRs[iLayer + 1],
-      resolutions[iLayer],
-      radii[iLayer + 1] - radii[iLayer],
-      mulScatAng[iLayer]);
-    if (nTracklets[iLayer]) {
-      Tracklet *tracklets_in = spanTracklets[iLayer], *tracklets_out{nullptr};
-      size_t n = nTracklets[iLayer];
-      size_t sort_temp_bytes = 0;
-      GPUChkErrS(cub::DeviceMergeSort::SortKeys(nullptr, sort_temp_bytes, tracklets_in, n, gpu::sort_tracklets{}, streams[iLayer].get()));
-      void* sort_temp_storage = nullptr;
-      gpu::allocateMemory(&sort_temp_storage, sort_temp_bytes, streams[iLayer].get(), alloc);
-      GPUChkErrS(cub::DeviceMergeSort::SortKeys(sort_temp_storage, sort_temp_bytes, tracklets_in, n, gpu::sort_tracklets{}, streams[iLayer].get()));
-      gpu::allocateMemory(reinterpret_cast<void**>(&tracklets_out), n * sizeof(Tracklet), streams[iLayer].get(), alloc);
-      size_t unique_temp_bytes = 0;
-      int* num_selected = nullptr;
-      gpu::allocateMemory(reinterpret_cast<void**>(&num_selected), sizeof(int), streams[iLayer].get(), alloc);
-      GPUChkErrS(cub::DeviceSelect::Unique(nullptr, unique_temp_bytes, tracklets_in, tracklets_out, num_selected, n, streams[iLayer].get()));
-      void* unique_temp_storage = nullptr;
-      gpu::allocateMemory(&unique_temp_storage, unique_temp_bytes, streams[iLayer].get(), alloc);
-      GPUChkErrS(cub::DeviceSelect::Unique(unique_temp_storage, unique_temp_bytes, tracklets_in, tracklets_out, num_selected, n, streams[iLayer].get()));
-      GPUChkErrS(cudaMemcpyAsync(tracklets_in, tracklets_out, n * sizeof(Tracklet), cudaMemcpyDeviceToDevice, streams[iLayer].get()));
-      GPUChkErrS(cudaMemcpyAsync(&nTracklets[iLayer], num_selected, sizeof(int), cudaMemcpyDeviceToHost, streams[iLayer].get()));
-      streams[iLayer].sync();
-      gpu::deallocateMemory(tracklets_out, n * sizeof(Tracklet), streams[iLayer].get(), alloc);
-      gpu::deallocateMemory(sort_temp_storage, sort_temp_bytes, streams[iLayer].get(), alloc);
-      gpu::deallocateMemory(unique_temp_storage, unique_temp_bytes, streams[iLayer].get(), alloc);
-      gpu::deallocateMemory(num_selected, sizeof(int), streams[iLayer].get(), alloc);
-    }
-    if (iLayer > 0) {
-      GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[iLayer], 0, nClusters[iLayer] * sizeof(int), streams[iLayer].get()));
-      gpu::compileTrackletsLookupTableKernel<<<nBlocks, nThreads, 0, streams[iLayer].get()>>>(
-        spanTracklets[iLayer],
-        trackletsLUTsHost[iLayer],
-        nTracklets[iLayer]);
-      gpu::cubExclusiveScanInPlace(trackletsLUTsHost[iLayer], nClusters[iLayer] + 1, streams[iLayer].get(), alloc);
-    }
+  gpu::computeLayerTrackletsMultiROFKernel<false><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
+    utils,
+    multMask,
+    layer,
+    startROF,
+    endROF,
+    maxROF,
+    deltaROF,
+    vertices,
+    rofPV,
+    nVertices,
+    vertexId,
+    clusters,
+    ROFClusters,
+    usedClusters,
+    clustersIndexTables,
+    tracklets,
+    trackletsLUTs,
+    iteration,
+    NSigmaCut,
+    phiCuts[layer],
+    resolutionPV,
+    minRs[layer + 1],
+    maxRs[layer + 1],
+    resolutions[layer],
+    radii[layer + 1] - radii[layer],
+    mulScatAng[layer]);
+  thrust::device_ptr<Tracklet> tracklets_ptr(spanTracklets[layer]);
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[layer].get());
+  thrust::sort(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[layer], gpu::sort_tracklets());
+  auto unique_end = thrust::unique(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[layer], gpu::equal_tracklets());
+  nTracklets[layer] = unique_end - tracklets_ptr;
+  if (layer) {
+    GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[layer], 0, (nClusters[layer] + 1) * sizeof(int), streams[layer].get()));
+    gpu::compileTrackletsLookupTableKernel<<<nBlocks, nThreads, 0, streams[layer].get()>>>(
+      spanTracklets[layer],
+      trackletsLUTsHost[layer],
+      nTracklets[layer]);
+    thrust::exclusive_scan(nosync_policy, trackletsLUTsHost[layer], trackletsLUTsHost[layer] + nClusters[layer] + 1, trackletsLUTsHost[layer]);
   }
 }
 
@@ -1119,7 +940,8 @@ void countCellsHandler(
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
     nSigmaCut);               // const float
-  gpu::cubExclusiveScanInPlace(cellsLUTsHost, nTracklets + 1, streams[layer].get(), alloc);
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[layer].get());
+  thrust::exclusive_scan(nosync_policy, cellsLUTsHost, cellsLUTsHost + nTracklets + 1, cellsLUTsHost);
 }
 
 void computeCellsHandler(
@@ -1190,8 +1012,9 @@ void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
     layerIndex,
     nCells,
     maxCellNeighbours);
-  gpu::cubInclusiveScanInPlace(neighboursLUT, nCellsNext, stream.get(), alloc);
-  gpu::cubExclusiveScanInPlace(neighboursIndexTable, nCells + 1, stream.get(), alloc);
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(stream.get());
+  thrust::inclusive_scan(nosync_policy, neighboursLUT, neighboursLUT + nCellsNext, neighboursLUT);
+  thrust::exclusive_scan(nosync_policy, neighboursIndexTable, neighboursIndexTable + nCells + 1, neighboursIndexTable);
 }
 
 void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
@@ -1232,44 +1055,13 @@ int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
                                 gpu::Stream& stream,
                                 o2::its::ExternalAllocator* allocator)
 {
-#ifndef __HIPCC__
-  int* d_num_selected = nullptr;
-  gpu::allocateMemory(reinterpret_cast<void**>(&d_num_selected), sizeof(int), stream.get(), allocator);
-  size_t select_bytes = 0;
-  GPUChkErrS(cub::DeviceSelect::If(nullptr, select_bytes, cellNeighbourPairs, static_cast<gpuPair<int, int>*>(nullptr), d_num_selected, nNeigh, gpu::is_valid_pair<int, int>(), stream.get()));
-  void* select_temp = nullptr;
-  gpu::allocateMemory(&select_temp, select_bytes, stream.get(), allocator);
-  gpuPair<int, int>* d_temp_valid = nullptr;
-  gpu::allocateMemory(reinterpret_cast<void**>(&d_temp_valid), nNeigh * sizeof(gpuPair<int, int>), stream.get(), allocator);
-  GPUChkErrS(cub::DeviceSelect::If(select_temp, select_bytes, cellNeighbourPairs, d_temp_valid, d_num_selected, nNeigh, gpu::is_valid_pair<int, int>(), stream.get()));
-  int newSize = 0;
-  GPUChkErrS(cudaMemcpyAsync(&newSize, d_num_selected, sizeof(int), cudaMemcpyDeviceToHost, stream.get()));
-  stream.sync(); // needed to get newSize
-  size_t sort_bytes = 0;
-  GPUChkErrS(cub::DeviceMergeSort::SortPairs(nullptr, sort_bytes, d_temp_valid, d_temp_valid, newSize, gpu::sort_by_second<int, int>(), stream.get()));
-  void* sort_temp = nullptr;
-  gpu::allocateMemory(&sort_temp, sort_bytes, stream.get(), allocator);
-  GPUChkErrS(cub::DeviceMergeSort::SortPairs(sort_temp, sort_bytes, d_temp_valid, d_temp_valid, newSize, gpu::sort_by_second<int, int>(), stream.get()));
-  size_t transform_bytes = 0;
-  GPUChkErrS(cub::DeviceTransform::Transform(nullptr, transform_bytes, d_temp_valid, cellNeighbours, newSize, gpu::pair_to_first<int, int>(), stream.get()));
-  void* transform_temp = nullptr;
-  gpu::allocateMemory(&transform_temp, transform_bytes, stream.get(), allocator);
-  GPUChkErrS(cub::DeviceTransform::Transform(transform_temp, transform_bytes, d_temp_valid, cellNeighbours, newSize, gpu::pair_to_first<int, int>(), stream.get()));
-  gpu::deallocateMemory(transform_temp, transform_bytes, stream.get(), allocator);
-  gpu::deallocateMemory(d_temp_valid, newSize * sizeof(gpuPair<int, int>), stream.get(), allocator);
-  gpu::deallocateMemory(sort_temp, sort_bytes, stream.get(), allocator);
-  gpu::deallocateMemory(d_num_selected, sizeof(int), stream.get(), allocator);
-  gpu::deallocateMemory(select_temp, select_bytes, stream.get(), allocator);
-#else // FIXME using thrust here since hipcub does not yet have DeviceTransform
-  auto nosync_policy = THRUST_NAMESPACE::par_nosync.on(stream.get());
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(allocator)).on(stream.get());
   thrust::device_ptr<gpuPair<int, int>> neighVectorPairs(cellNeighbourPairs);
   thrust::device_ptr<int> validNeighs(cellNeighbours);
   auto updatedEnd = thrust::remove_if(nosync_policy, neighVectorPairs, neighVectorPairs + nNeigh, gpu::is_invalid_pair<int, int>());
   size_t newSize = updatedEnd - neighVectorPairs;
   thrust::stable_sort(nosync_policy, neighVectorPairs, neighVectorPairs + newSize, gpu::sort_by_second<int, int>());
   thrust::transform(nosync_policy, neighVectorPairs, neighVectorPairs + newSize, validNeighs, gpu::pair_to_first<int, int>());
-#endif
-
   return newSize;
 }
 
@@ -1296,6 +1088,7 @@ void processNeighboursHandler(const int startLayer,
   auto allocInt = gpu::TypedAllocator<int>(alloc);
   auto allocCellSeed = gpu::TypedAllocator<CellSeed>(alloc);
   thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(gpu::Stream::DefaultStream);
 
   gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(
     startLayer,
@@ -1315,7 +1108,7 @@ void processNeighboursHandler(const int startLayer,
     maxChi2ClusterAttachment,
     propagator,
     matCorrType);
-  gpu::cubExclusiveScanInPlace(foundSeedsTable, nCells[startLayer] + 1, gpu::Stream::DefaultStream, alloc);
+  thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
 
   thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
   thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
@@ -1337,8 +1130,7 @@ void processNeighboursHandler(const int startLayer,
     maxChi2ClusterAttachment,
     propagator,
     matCorrType);
-  GPUChkErrS(cudaPeekAtLastError());
-  GPUChkErrS(cudaDeviceSynchronize());
+  GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
 
   int level = startLevel;
   thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
@@ -1350,7 +1142,7 @@ void processNeighboursHandler(const int startLayer,
     thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellId);
     auto lastCellSeedSize{lastCellSeed.size()};
     foundSeedsTable.resize(lastCellSeedSize + 1);
-    thrust::fill(foundSeedsTable.begin(), foundSeedsTable.end(), 0);
+    thrust::fill(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
     gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(
       iLayer,
@@ -1370,13 +1162,13 @@ void processNeighboursHandler(const int startLayer,
       maxChi2ClusterAttachment,
       propagator,
       matCorrType);
-    gpu::cubExclusiveScanInPlace(foundSeedsTable, foundSeedsTable.size(), gpu::Stream::DefaultStream, alloc);
+    thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
 
     auto foundSeeds{foundSeedsTable.back()};
     updatedCellId.resize(foundSeeds);
-    thrust::fill(updatedCellId.begin(), updatedCellId.end(), 0);
+    thrust::fill(nosync_policy, updatedCellId.begin(), updatedCellId.end(), 0);
     updatedCellSeed.resize(foundSeeds);
-    thrust::fill(updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed());
+    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed());
 
     gpu::processNeighboursKernel<false><<<nBlocks, nThreads>>>(
       iLayer,
@@ -1396,11 +1188,10 @@ void processNeighboursHandler(const int startLayer,
       maxChi2ClusterAttachment,
       propagator,
       matCorrType);
-    GPUChkErrS(cudaPeekAtLastError());
-    GPUChkErrS(cudaDeviceSynchronize());
   }
+  GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
   thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> outSeeds(updatedCellSeed.size(), allocCellSeed);
-  auto end = thrust::copy_if(updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
+  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
   auto s{end - outSeeds.begin()};
   seedsHost.reserve(seedsHost.size() + s);
   thrust::copy(outSeeds.begin(), outSeeds.begin() + s, std::back_inserter(seedsHost));
@@ -1434,14 +1225,13 @@ void trackSeedHandler(CellSeed* trackSeeds,
     propagator,                           // const o2::base::Propagator*
     matCorrType);                         // o2::base::PropagatorF::MatCorrType
   thrust::device_ptr<o2::its::TrackITSExt> tr_ptr(tracks);
-
   thrust::sort(tr_ptr, tr_ptr + nSeeds, gpu::compare_track_chi2());
-  GPUChkErrS(cudaPeekAtLastError());
-  GPUChkErrS(cudaDeviceSynchronize());
+  GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
 }
 
 template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                              const uint8_t* multMask,
+                                             const int layer,
                                              const int startROF,
                                              const int endROF,
                                              const int maxROF,
@@ -1473,6 +1263,7 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
 
 template void computeTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                                const uint8_t* multMask,
+                                               const int layer,
                                                const int startROF,
                                                const int endROF,
                                                const int maxROF,

From cd8e5769a716fb9e2a684bc1d6964f1116d50c74 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 18 Aug 2025 09:31:13 +0200
Subject: [PATCH 0714/1764] DPL Analysis: add an example of the string filter
 (#14570)

---
 .../TestWorkflows/src/o2TestHistograms.cxx    | 35 ++++++++++++++++---
 1 file changed, 31 insertions(+), 4 deletions(-)

diff --git a/Framework/TestWorkflows/src/o2TestHistograms.cxx b/Framework/TestWorkflows/src/o2TestHistograms.cxx
index 2ec268130267b..326170dc56eff 100644
--- a/Framework/TestWorkflows/src/o2TestHistograms.cxx
+++ b/Framework/TestWorkflows/src/o2TestHistograms.cxx
@@ -39,8 +39,17 @@ DECLARE_SOA_TABLE(SkimmedExampleTrack, "AOD", "SKIMEXTRK", //!
 struct EtaAndClsHistogramsSimple {
   OutputObj<TH2F> etaClsH{TH2F("eta_vs_pt", "#eta vs pT", 102, -2.01, 2.01, 100, 0, 10)};
   Produces<o2::aod::SkimmedExampleTrack> skimEx;
+  Configurable<std::string> trackFilterString{"track-filter", "o2::aod::track::pt < 10.f", "Track filter string"};
+  Filter trackFilter = o2::aod::track::pt < 10.f;
 
-  void process(aod::Tracks const& tracks, aod::FT0s const&)
+  void init(InitContext&)
+  {
+    if (!trackFilterString->empty()) {
+      trackFilter = trackFilterString;
+    }
+  }
+
+  void process(soa::Filtered<aod::Tracks> const& tracks, aod::FT0s const&)
   {
     LOGP(info, "Invoking the simple one");
     for (auto& track : tracks) {
@@ -53,10 +62,19 @@ struct EtaAndClsHistogramsSimple {
 struct EtaAndClsHistogramsIUSimple {
   OutputObj<TH2F> etaClsH{TH2F("eta_vs_pt", "#eta vs pT", 102, -2.01, 2.01, 100, 0, 10)};
   Produces<o2::aod::SkimmedExampleTrack> skimEx;
+  Configurable<std::string> trackFilterString{"track-filter", "o2::aod::track::pt < 10.f", "Track filter string"};
+  Filter trackFilter = o2::aod::track::pt < 10.f;
 
-  void process(aod::TracksIU const& tracks, aod::FT0s const&)
+  void init(InitContext&)
   {
-    LOGP(info, "Invoking the simple one");
+    if (!trackFilterString->empty()) {
+      trackFilter = trackFilterString;
+    }
+  }
+
+  void process(soa::Filtered<aod::TracksIU> const& tracks, aod::FT0s const&)
+  {
+    LOGP(info, "Invoking the simple one IU");
     for (auto& track : tracks) {
       etaClsH->Fill(track.eta(), track.pt());
       skimEx(track.pt(), track.eta());
@@ -66,8 +84,17 @@ struct EtaAndClsHistogramsIUSimple {
 
 struct EtaAndClsHistogramsFull {
   OutputObj<TH3F> etaClsH{TH3F("eta_vs_cls_vs_sigmapT", "#eta vs N_{cls} vs sigma_{1/pT}", 102, -2.01, 2.01, 160, -0.5, 159.5, 100, 0, 10)};
+  Configurable<std::string> trackFilterString{"track-filter", "o2::aod::track::pt < 10.f", "Track filter string"};
+  Filter trackFilter = o2::aod::track::pt < 10.f;
+
+  void init(InitContext&)
+  {
+    if (!trackFilterString->empty()) {
+      trackFilter = trackFilterString;
+    }
+  }
 
-  void process(soa::Join<aod::FullTracks, aod::TracksCov> const& tracks)
+  void process(soa::Filtered<soa::Join<aod::FullTracks, aod::TracksCov>> const& tracks)
   {
     LOGP(info, "Invoking the run 3 one");
     for (auto& track : tracks) {

From fa7d8f9274639f70b28dafba6f989f2ea6a699d8 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 18 Aug 2025 16:21:51 +0200
Subject: [PATCH 0715/1764] Revert "Fix in TRD sector getter"

This reverts commit 7262c36703fb88bab6bcd1e76484aef06b2c1727.
The correction of https://github.com/AliceO2Group/AliceO2/pull/14589
was actually not needed, just the name of the method is misleading.
---
 Detectors/TRD/base/include/TRDBase/GeometryBase.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/TRD/base/include/TRDBase/GeometryBase.h b/Detectors/TRD/base/include/TRDBase/GeometryBase.h
index 6627e70406b2b..c817d21cb7c48 100644
--- a/Detectors/TRD/base/include/TRDBase/GeometryBase.h
+++ b/Detectors/TRD/base/include/TRDBase/GeometryBase.h
@@ -38,7 +38,7 @@ class GeometryBase
     }
   }
   GPUd() bool getSMstatus(int sm) const { return (mSMStatus & (0x1 << sm)) != 0; }
-  GPUd() static int getDetectorSec(int det) { return (det / (constants::NLAYER * constants::NSTACK)); }
+  GPUd() static int getDetectorSec(int det) { return (det % (constants::NLAYER * constants::NSTACK)); }
   GPUd() static int getDetectorSec(int layer, int stack) { return (layer + stack * constants::NLAYER); }
   GPUd() static int getDetector(int layer, int stack, int sector) { return (layer + stack * constants::NLAYER + sector * constants::NLAYER * constants::NSTACK); }
   GPUd() static int getLayer(int det) { return (det % constants::NLAYER); }

From 86424f9b3c8f1af62db76bac7a825d9805a17048 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 18 Aug 2025 21:50:02 +0200
Subject: [PATCH 0716/1764] DPL Analysis: support configurables in string
 expressions (#14598)

---
 .../Core/include/Framework/Expressions.h      | 15 ++++
 Framework/Core/src/Expressions.cxx            | 89 ++++++++++++++++++-
 Framework/Core/test/test_Expressions.cxx      | 15 ++++
 .../TestWorkflows/src/o2TestHistograms.cxx    |  6 +-
 4 files changed, 120 insertions(+), 5 deletions(-)

diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index ed8d4ef24f402..e2fdd0493d033 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -165,6 +165,14 @@ struct PlaceholderNode : LiteralNode {
     retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{static_cast<AT>(context.options().get<T>(name))}; };
   }
 
+  template <typename T>
+  PlaceholderNode(T defaultValue, std::string&& path)
+    : LiteralNode{defaultValue},
+      name{path}
+  {
+    retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{context.options().get<T>(name)}; };
+  }
+
   void reset(InitContext& context)
   {
     value = retrieve(context, name.data());
@@ -596,6 +604,13 @@ inline Node protect0(Node&& expr)
   return ifnode(nabs(Node{copy}) < o2::constants::math::Almost0, o2::constants::math::Almost0, Node{copy});
 }
 
+/// context-independent configurable
+template <typename T>
+inline Node ncfg(T defaultValue, std::string path)
+{
+  return PlaceholderNode(defaultValue, path);
+}
+
 /// A struct, containing the root of the expression tree
 struct Filter {
   Filter() = default;
diff --git a/Framework/Core/src/Expressions.cxx b/Framework/Core/src/Expressions.cxx
index 1d4dec734ff21..05a3462d6e4da 100644
--- a/Framework/Core/src/Expressions.cxx
+++ b/Framework/Core/src/Expressions.cxx
@@ -64,6 +64,17 @@ constexpr std::array<std::string_view, BasicOp::Conditional + 1> mapping{
   "nbitwise_not",
   "ifnode"};
 
+constexpr std::array<std::string_view, 8> cfgtypes{
+  "uint16_t", // 0
+  "int16_t",  // 1
+  "uint32_t", // 2
+  "int32_t",  // 3
+  "uint64_t", // 4
+  "int64_t",  // 5
+  "float",    // 6
+  "double"    // 7
+};
+
 /// math constants to recognize in string expressions
 constexpr std::array<std::string_view, 9> mathConstants{
   "Almost0",
@@ -813,7 +824,8 @@ Tokenizer::Tokenizer(std::string const& input)
 {
   LastChar = ' ';
   if (!source.empty()) {
-    source.erase(std::remove_if(source.begin(), source.end(), ::isspace), source.end());
+    source.erase(std::remove_if(source.begin(), source.end(), ::isspace), source.end()); // strip whitespaces
+    source.erase(std::remove(source.begin(), source.end(), '\"'), source.end());         // strip quotes
   }
   current = source.begin();
 }
@@ -827,7 +839,8 @@ void Tokenizer::reset(std::string const& input)
   FloatValue = 0.f;
   source = input;
   if (!source.empty()) {
-    source.erase(std::remove_if(source.begin(), source.end(), ::isspace), source.end());
+    source.erase(std::remove_if(source.begin(), source.end(), ::isspace), source.end()); // strip whitespaces
+    source.erase(std::remove(source.begin(), source.end(), '\"'), source.end());         // strip quotes
   }
   current = source.begin();
   currentToken = Token::Unexpected;
@@ -1202,6 +1215,78 @@ std::unique_ptr<Node> Parser::parseBase(Tokenizer& tk)
       }
       tk.nextToken();
       return node;
+    } else if (id == "ncfg") { // configurable placeholder, 3 args none of them can be expressions
+      int args = 0;
+      std::string type;
+      std::string value;
+      std::string path;
+      while (tk.currentToken != ')') {
+        do {
+          tk.nextToken();
+          if (args == 0) { // type
+            type = tk.TokenStr;
+            tk.nextToken();
+          } else if (args == 1) { // value
+            value = tk.TokenStr;
+            tk.nextToken();
+          } else if (args == 2) { // path
+            path = tk.TokenStr;
+            tk.nextToken();
+          } else {
+            throw runtime_error_f("Extra argument in configurable: %s", tk.TokenStr.c_str());
+          }
+          ++args;
+        } while (tk.currentToken == ',');
+      }
+      tk.nextToken();
+      auto locate = std::find(cfgtypes.begin(), cfgtypes.end(), type);
+      if (locate == cfgtypes.end()) {
+        throw runtime_error_f("Unsupported type in configurable: %s", type.c_str());
+      }
+      switch (std::distance(cfgtypes.begin(), locate)) {
+        case 0:
+          return std::make_unique<Node>(
+            PlaceholderNode(
+              static_cast<uint16_t>(std::stoi(value)),
+              std::move(path)));
+        case 1:
+          return std::make_unique<Node>(
+            PlaceholderNode(
+              static_cast<int16_t>(std::stoi(value)),
+              std::move(path)));
+        case 2:
+          return std::make_unique<Node>(
+            PlaceholderNode(
+              static_cast<uint32_t>(std::stoi(value)),
+              std::move(path)));
+        case 3:
+          return std::make_unique<Node>(
+            PlaceholderNode(
+              static_cast<int32_t>(std::stoi(value)),
+              std::move(path)));
+        case 4:
+          return std::make_unique<Node>(
+            PlaceholderNode(
+              static_cast<uint64_t>(std::stoll(value)),
+              std::move(path)));
+        case 5:
+          return std::make_unique<Node>(
+            PlaceholderNode(
+              static_cast<int64_t>(std::stol(value)),
+              std::move(path)));
+        case 6:
+          return std::make_unique<Node>(
+            PlaceholderNode(
+              std::stof(value),
+              std::move(path)));
+        case 7:
+          return std::make_unique<Node>(
+            PlaceholderNode(
+              std::stod(value),
+              std::move(path)));
+        default:
+          throw runtime_error_f("Unsupported type in configurable: %s", type.c_str());
+      }
     } else { // normal function
       auto node = std::make_unique<Node>(opFromToken(id), LiteralNode{-1}, LiteralNode{-1});
       int args = 0;
diff --git a/Framework/Core/test/test_Expressions.cxx b/Framework/Core/test/test_Expressions.cxx
index eef0375f46086..4c6fc51795ca8 100644
--- a/Framework/Core/test/test_Expressions.cxx
+++ b/Framework/Core/test/test_Expressions.cxx
@@ -375,4 +375,19 @@ TEST_CASE("TestStringExpressionsParsing")
   auto treef2 = createExpressionTree(tf2, schema);
 
   REQUIRE(treef1->ToString() == treef2->ToString());
+
+  Configurable<float> pTCut{"pTCut", 0.5f, "Lower pT limit"};
+  Filter pcfg1 = o2::aod::track::pt > pTCut;
+  Filter pcfg2 = Parser::parse("o2::aod::track::pt > ncfg(float, 0.5, \"pTCut\")");
+  auto pcfg1specs = createOperations(pcfg1);
+  auto pcfg2specs = createOperations(pcfg2);
+
+  REQUIRE(pcfg2.node->right->self.index() == 3);
+  REQUIRE(pcfg2specs[0].right == (DatumSpec{LiteralNode::var_t{0.5f}, atype::FLOAT}));
+
+  schema = std::make_shared<arrow::Schema>(std::vector{o2::aod::track::Pt::asArrowField()});
+  auto tree1c = createExpressionTree(pcfg1specs, schema);
+  auto tree2c = createExpressionTree(pcfg2specs, schema);
+
+  REQUIRE(tree1c->ToString() == tree2c->ToString());
 }
diff --git a/Framework/TestWorkflows/src/o2TestHistograms.cxx b/Framework/TestWorkflows/src/o2TestHistograms.cxx
index 326170dc56eff..38cfc00b6df7c 100644
--- a/Framework/TestWorkflows/src/o2TestHistograms.cxx
+++ b/Framework/TestWorkflows/src/o2TestHistograms.cxx
@@ -45,7 +45,7 @@ struct EtaAndClsHistogramsSimple {
   void init(InitContext&)
   {
     if (!trackFilterString->empty()) {
-      trackFilter = trackFilterString;
+      trackFilter = Parser::parse((std::string)trackFilterString);
     }
   }
 
@@ -68,7 +68,7 @@ struct EtaAndClsHistogramsIUSimple {
   void init(InitContext&)
   {
     if (!trackFilterString->empty()) {
-      trackFilter = trackFilterString;
+      trackFilter = Parser::parse((std::string)trackFilterString);
     }
   }
 
@@ -90,7 +90,7 @@ struct EtaAndClsHistogramsFull {
   void init(InitContext&)
   {
     if (!trackFilterString->empty()) {
-      trackFilter = trackFilterString;
+      trackFilter = Parser::parse((std::string)trackFilterString);
     }
   }
 

From d4e16e117bb410ea7087874ffe561dec66521d49 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 18 Aug 2025 22:03:37 +0200
Subject: [PATCH 0717/1764] ITS: GPU: overlap memcpy with compute kernels
 (#14596)

---
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 36 ++++++++++++-------
 1 file changed, 24 insertions(+), 12 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index a6dfc041e4c71..6e10956d923cc 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -60,18 +60,23 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
   int startROF{this->mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * this->mTrkParams[iteration].nROFsPerIterations : 0};
   int endROF{o2::gpu::CAMath::Min(this->mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * this->mTrkParams[iteration].nROFsPerIterations + this->mTrkParams[iteration].DeltaROF : mTimeFrameGPU->getNrof(), mTimeFrameGPU->getNrof())};
 
-  for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
-    // TODO lazy loading of essential data on separate streams
+  // start by queuing loading needed of two last layers
+  for (int iLayer{nLayers}; iLayer-- > nLayers - 2;) {
     mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer);
     mTimeFrameGPU->loadClustersDevice(iteration, iLayer);
-    mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer);
     mTimeFrameGPU->loadClustersIndexTables(iteration, iLayer);
     mTimeFrameGPU->loadROFrameClustersDevice(iteration, iLayer);
     mTimeFrameGPU->recordEvent(iLayer);
   }
 
-  // processing starts here
-  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
+  for (int iLayer{this->mTrkParams[iteration].TrackletsPerRoad()}; iLayer--;) {
+    if (iLayer) { // queue loading data of next layer in parallel, this the copies are overlapping with computation kernels
+      mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer - 1);
+      mTimeFrameGPU->loadClustersDevice(iteration, iLayer - 1);
+      mTimeFrameGPU->loadClustersIndexTables(iteration, iLayer - 1);
+      mTimeFrameGPU->loadROFrameClustersDevice(iteration, iLayer - 1);
+      mTimeFrameGPU->recordEvent(iLayer - 1);
+    }
     mTimeFrameGPU->createTrackletsLUTDevice(iteration, iLayer);
     mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
     countTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
@@ -91,7 +96,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getDeviceArrayUsedClusters(),
                                          mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
                                          mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
-                                         mTimeFrameGPU->getDeviceTrackletsLUTs(), // Required for the exclusive sums
+                                         mTimeFrameGPU->getDeviceTrackletsLUTs(),
                                          iteration,
                                          this->mTrkParams[iteration].NSigmaCut,
                                          mTimeFrameGPU->getPhiCuts(),
@@ -107,7 +112,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getStreams());
     mTimeFrameGPU->createTrackletsBuffers(iLayer);
     if (mTimeFrameGPU->getNTracklets()[iLayer] == 0) {
-      return;
+      continue;
     }
     computeTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
                                            mTimeFrameGPU->getDeviceMultCutMask(),
@@ -151,18 +156,25 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
-    // TODO lazy loading of essential data on separate streams
+  // start by queuing loading needed of three last layers
+  for (int iLayer{nLayers}; iLayer-- > nLayers - 3;) {
+    mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer);
     mTimeFrameGPU->loadTrackingFrameInfoDevice(iteration, iLayer);
     mTimeFrameGPU->recordEvent(iLayer);
   }
 
-  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
+  for (int iLayer{this->mTrkParams[iteration].CellsPerRoad()}; iLayer--;) {
+    if (iLayer) {
+      mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer - 1);
+      mTimeFrameGPU->loadTrackingFrameInfoDevice(iteration, iLayer - 1);
+      mTimeFrameGPU->recordEvent(iLayer - 1);
+    }
+
     // if there are no tracklets skip entirely
     const int currentLayerTrackletsNum{static_cast<int>(mTimeFrameGPU->getNTracklets()[iLayer])};
     if (!currentLayerTrackletsNum || !mTimeFrameGPU->getNTracklets()[iLayer + 1]) {
       mTimeFrameGPU->getNCells()[iLayer] = 0;
-      return;
+      continue;
     }
 
     mTimeFrameGPU->createCellsLUTDevice(iLayer);
@@ -189,7 +201,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                       mTimeFrameGPU->getStreams());
     mTimeFrameGPU->createCellsBuffers(iLayer);
     if (mTimeFrameGPU->getNCells()[iLayer] == 0) {
-      return;
+      continue;
     }
     computeCellsHandler(mTimeFrameGPU->getDeviceArrayClusters(),
                         mTimeFrameGPU->getDeviceArrayUnsortedClusters(),

From fb4df11e4a444cfb7884fdad5aed8ab14ea2f361 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 18 Aug 2025 22:07:35 +0200
Subject: [PATCH 0718/1764] ITS: template Tracker, Cell and Road (#14597)

---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  20 +-
 .../GPU/ITStrackingGPU/TrackerTraitsGPU.h     |   2 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  65 ++-----
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     |  34 ++--
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 142 +++++++-------
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 173 ++++++++++++++----
 .../ITS/tracking/include/ITStracking/Cell.h   |  17 +-
 .../tracking/include/ITStracking/Constants.h  |  34 +++-
 .../ITS/tracking/include/ITStracking/Road.h   |   6 +-
 .../tracking/include/ITStracking/TimeFrame.h  |   5 +-
 .../tracking/include/ITStracking/Tracker.h    |  15 +-
 .../include/ITStracking/TrackerTraits.h       |   5 +-
 .../include/ITStracking/TrackingInterface.h   |  11 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |   2 +-
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  27 ++-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  20 +-
 .../ITS/tracking/src/TrackingInterface.cxx    |   6 +-
 17 files changed, 353 insertions(+), 231 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 27b987fb9a84a..9731ad5c5db67 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -27,6 +27,8 @@ namespace o2::its::gpu
 template <int nLayers = 7>
 class TimeFrameGPU : public TimeFrame<nLayers>
 {
+  using typename TimeFrame<nLayers>::CellSeedN;
+
  public:
   TimeFrameGPU();
   ~TimeFrameGPU() = default;
@@ -64,7 +66,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void loadTrackSeedsDevice();
   void loadTrackSeedsChi2Device();
   void loadRoadsDevice();
-  void loadTrackSeedsDevice(bounded_vector<CellSeed>&);
+  void loadTrackSeedsDevice(bounded_vector<CellSeedN>&);
   void createTrackletsBuffers(const int);
   void createTrackletsBuffersArray(const int);
   void createCellsBuffers(const int);
@@ -75,8 +77,8 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void createNeighboursIndexTablesDevice(const int);
   void createNeighboursDevice(const unsigned int layer);
   void createNeighboursLUTDevice(const int, const unsigned int);
-  void createTrackITSExtDevice(bounded_vector<CellSeed>&);
-  void downloadTrackITSExtDevice(bounded_vector<CellSeed>&);
+  void createTrackITSExtDevice(bounded_vector<CellSeedN>&);
+  void downloadTrackITSExtDevice(bounded_vector<CellSeedN>&);
   void downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>&, const int);
   void downloadNeighboursLUTDevice(bounded_vector<int>&, const int);
   void downloadCellsDevice();
@@ -125,8 +127,8 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   int** getDeviceArrayTrackletsLUT() const { return mTrackletsLUTDeviceArray; }
   int** getDeviceArrayCellsLUT() const { return mCellsLUTDeviceArray; }
   int** getDeviceArrayNeighboursCellLUT() const { return mNeighboursCellLUTDeviceArray; }
-  CellSeed** getDeviceArrayCells() { return mCellsDeviceArray; }
-  CellSeed* getDeviceTrackSeeds() { return mTrackSeedsDevice; }
+  CellSeedN** getDeviceArrayCells() { return mCellsDeviceArray; }
+  CellSeedN* getDeviceTrackSeeds() { return mTrackSeedsDevice; }
   o2::track::TrackParCovF** getDeviceArrayTrackSeeds() { return mCellSeedsDeviceArray; }
   float** getDeviceArrayTrackSeedsChi2() { return mCellSeedsChi2DeviceArray; }
   int* getDeviceNeighboursIndexTables(const int layer) { return mNeighboursIndexTablesDevice[layer]; }
@@ -145,7 +147,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   gsl::span<int*> getDeviceTrackletsLUTs() { return mTrackletsLUTDevice; }
   gsl::span<int*> getDeviceCellLUTs() { return mCellsLUTDevice; }
   gsl::span<Tracklet*> getDeviceTracklets() { return mTrackletsDevice; }
-  gsl::span<CellSeed*> getDeviceCells() { return mCellsDevice; }
+  gsl::span<CellSeedN*> getDeviceCells() { return mCellsDevice; }
 
   // Overridden getters
   int getNumberOfTracklets() const final;
@@ -189,10 +191,10 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   int** mNeighboursCellDeviceArray{nullptr};
   int** mNeighboursCellLUTDeviceArray{nullptr};
   int** mTrackletsLUTDeviceArray{nullptr};
-  std::array<CellSeed*, nLayers - 2> mCellsDevice;
-  CellSeed** mCellsDeviceArray;
+  std::array<CellSeedN*, nLayers - 2> mCellsDevice;
+  CellSeedN** mCellsDeviceArray;
   std::array<int*, nLayers - 3> mNeighboursIndexTablesDevice;
-  CellSeed* mTrackSeedsDevice{nullptr};
+  CellSeedN* mTrackSeedsDevice{nullptr};
   std::array<o2::track::TrackParCovF*, nLayers - 2> mCellSeedsDevice;
   o2::track::TrackParCovF** mCellSeedsDeviceArray;
   std::array<float*, nLayers - 2> mCellSeedsChi2Device;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
index d5c3e8ac74925..f8eedb33d91eb 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
@@ -49,7 +49,7 @@ class TrackerTraitsGPU final : public TrackerTraits<nLayers>
 
  private:
   IndexTableUtils* mDeviceIndexTableUtils;
-  gpu::TimeFrameGPU<7>* mTimeFrameGPU;
+  gpu::TimeFrameGPU<nLayers>* mTimeFrameGPU;
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 23b23d2b3f3ab..53e680d474f6f 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -16,51 +16,21 @@
 #include <gsl/gsl>
 
 #include "ITStracking/BoundedAllocator.h"
+#include "ITStracking/Definitions.h"
 #include "ITStrackingGPU/Utils.h"
 #include "DetectorsBase/Propagator.h"
 #include "GPUCommonDef.h"
 
 namespace o2::its
 {
+template <int>
 class CellSeed;
+class TrackingFrameInfo;
+class Tracklet;
+class IndexTableUtils;
+class Cluster;
+class TrackITSExt;
 class ExternalAllocator;
-namespace gpu
-{
-
-#ifdef GPUCA_GPUCODE // GPUg() global kernels must only when compiled by GPU compiler
-
-GPUdii() int4 getEmptyBinsRect()
-{
-  return int4{0, 0, 0, 0};
-}
-
-GPUdii() bool fitTrack(TrackITSExt& track,
-                       int start,
-                       int end,
-                       int step,
-                       float chi2clcut,
-                       float chi2ndfcut,
-                       float maxQoverPt,
-                       int nCl,
-                       float Bz,
-                       TrackingFrameInfo** tfInfos,
-                       const o2::base::Propagator* prop,
-                       o2::base::PropagatorF::MatCorrType matCorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE);
-
-template <int nLayers = 7>
-GPUg() void fitTrackSeedsKernel(CellSeed* trackSeeds,
-                                const TrackingFrameInfo** foundTrackingFrameInfo,
-                                o2::its::TrackITSExt* tracks,
-                                const float* minPts,
-                                const unsigned int nSeeds,
-                                const float Bz,
-                                const int startLevel,
-                                float maxChi2ClusterAttachment,
-                                float maxChi2NDF,
-                                const o2::base::Propagator* propagator,
-                                const o2::base::PropagatorF::MatCorrType matCorrType = o2::base::PropagatorF::MatCorrType::USEMatCorrLUT);
-#endif
-} // namespace gpu
 
 template <int nLayers = 7>
 void countTrackletsInROFsHandler(const IndexTableUtils* utils,
@@ -131,6 +101,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
                                    const int nThreads,
                                    gpu::Streams& streams);
 
+template <int nLayers>
 void countCellsHandler(const Cluster** sortedClusters,
                        const Cluster** unsortedClusters,
                        const TrackingFrameInfo** tfInfo,
@@ -138,7 +109,7 @@ void countCellsHandler(const Cluster** sortedClusters,
                        int** trackletsLUT,
                        const int nTracklets,
                        const int layer,
-                       CellSeed* cells,
+                       CellSeed<nLayers>* cells,
                        int** cellsLUTsDeviceArray,
                        int* cellsLUTsHost,
                        const int deltaROF,
@@ -151,6 +122,7 @@ void countCellsHandler(const Cluster** sortedClusters,
                        const int nThreads,
                        gpu::Streams& streams);
 
+template <int nLayers>
 void computeCellsHandler(const Cluster** sortedClusters,
                          const Cluster** unsortedClusters,
                          const TrackingFrameInfo** tfInfo,
@@ -158,7 +130,7 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          int** trackletsLUT,
                          const int nTracklets,
                          const int layer,
-                         CellSeed* cells,
+                         CellSeed<nLayers>* cells,
                          int** cellsLUTsDeviceArray,
                          int* cellsLUTsHost,
                          const int deltaROF,
@@ -170,7 +142,8 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          const int nThreads,
                          gpu::Streams& streams);
 
-void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
+template <int nLayers>
+void countCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
                                 int* neighboursLUTs,
                                 int** cellsLUTs,
                                 gpuPair<int, int>* cellNeighbours,
@@ -188,7 +161,8 @@ void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                 const int nThreads,
                                 gpu::Stream& stream);
 
-void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
+template <int nLayers>
+void computeCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
                                   int* neighboursLUTs,
                                   int** cellsLUTs,
                                   gpuPair<int, int>* cellNeighbours,
@@ -214,14 +188,14 @@ int filterCellNeighboursHandler(gpuPair<int, int>*,
 template <int nLayers = 7>
 void processNeighboursHandler(const int startLayer,
                               const int startLevel,
-                              CellSeed** allCellSeeds,
-                              CellSeed* currentCellSeeds,
+                              CellSeed<nLayers>** allCellSeeds,
+                              CellSeed<nLayers>* currentCellSeeds,
                               std::array<int, nLayers - 2>& nCells,
                               const unsigned char** usedClusters,
                               std::array<int*, nLayers - 2>& neighbours,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                              bounded_vector<CellSeed>& seedsHost,
+                              bounded_vector<CellSeed<nLayers>>& seedsHost,
                               const float bz,
                               const float MaxChi2ClusterAttachment,
                               const float maxChi2NDF,
@@ -231,7 +205,8 @@ void processNeighboursHandler(const int startLayer,
                               const int nBlocks,
                               const int nThreads);
 
-void trackSeedHandler(CellSeed* trackSeeds,
+template <int nLayers = 7>
+void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const TrackingFrameInfo** foundTrackingFrameInfo,
                       o2::its::TrackITSExt* tracks,
                       std::vector<float>& minPtsHost,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 4f3b52d56a793..d834f28e09db0 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -355,11 +355,11 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
 {
   GPUTimer timer(mGpuStreams, "loading cell seeds", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    GPULog("gpu-transfer: loading {} cell seeds on layer {}, for {:.2f} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeed) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeed), mGpuStreams[iLayer], this->getExtAllocator());
+    GPULog("gpu-transfer: loading {} cell seeds on layer {}, for {:.2f} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeedN) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeedN), mGpuStreams[iLayer], this->getExtAllocator());
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator()); // accessory for the neigh. finding.
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
-    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeedN), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
 }
 
@@ -387,8 +387,8 @@ void TimeFrameGPU<nLayers>::createCellsBuffersArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating cells buffers array");
-    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), this->getExtAllocator());
-    GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeed*), cudaMemcpyHostToDevice));
+    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeedN*), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeedN*), cudaMemcpyHostToDevice));
   }
 }
 
@@ -399,9 +399,9 @@ void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
   mNCells[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of cells is correct
-  GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), mGpuStreams[layer], this->getExtAllocator());
-  GPUChkErrS(cudaMemcpyAsync(&mCellsDeviceArray[layer], &mCellsDevice[layer], sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+  GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeedN) / constants::MB);
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer], this->getExtAllocator());
+  GPUChkErrS(cudaMemcpyAsync(&mCellsDeviceArray[layer], &mCellsDevice[layer], sizeof(CellSeedN*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
 template <int nLayers>
@@ -426,13 +426,13 @@ void TimeFrameGPU<nLayers>::loadRoadsDevice()
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeed>& seeds)
+void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeedN>& seeds)
 {
   GPUTimer timer("loading track seeds");
-  GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeed) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeed), this->getExtAllocator());
-  GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeed), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpy(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeed), cudaMemcpyHostToDevice));
+  GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeedN) / constants::MB);
+  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeedN), this->getExtAllocator());
+  GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeedN), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemcpy(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeedN), cudaMemcpyHostToDevice));
 }
 
 template <int nLayers>
@@ -450,7 +450,7 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer)
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
+void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeedN>& seeds)
 {
   GPUTimer timer("reserving tracks");
   mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
@@ -465,9 +465,9 @@ void TimeFrameGPU<nLayers>::downloadCellsDevice()
 {
   GPUTimer timer(mGpuStreams, "downloading cells", nLayers - 2);
   for (int iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
-    GPULog("gpu-transfer: downloading {} cells on layer: {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / constants::MB);
+    GPULog("gpu-transfer: downloading {} cells on layer: {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeedN) / constants::MB);
     this->mCells[iLayer].resize(mNCells[iLayer]);
-    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
+    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeedN), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
   }
 }
 
@@ -499,7 +499,7 @@ void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeed>& seeds)
+void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeedN>& seeds)
 {
   GPUTimer timer("downloading tracks");
   GPULog("gpu-transfer: downloading {} tracks, for {:.2f} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 6e10956d923cc..15338f771ea27 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -180,47 +180,47 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
     mTimeFrameGPU->createCellsLUTDevice(iLayer);
     mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
     mTimeFrameGPU->waitEvent(iLayer, iLayer + 2); // wait stream until all data is available
-    countCellsHandler(mTimeFrameGPU->getDeviceArrayClusters(),
-                      mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
-                      mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
-                      mTimeFrameGPU->getDeviceArrayTracklets(),
-                      mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
-                      currentLayerTrackletsNum,
-                      iLayer,
-                      nullptr,
-                      mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                      mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
-                      this->mTrkParams[iteration].DeltaROF,
-                      this->mBz,
-                      this->mTrkParams[iteration].MaxChi2ClusterAttachment,
-                      this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
-                      this->mTrkParams[iteration].NSigmaCut,
-                      mTimeFrameGPU->getExternalAllocator(),
-                      conf.nBlocksLayerCells[iteration],
-                      conf.nThreadsLayerCells[iteration],
-                      mTimeFrameGPU->getStreams());
+    countCellsHandler<nLayers>(mTimeFrameGPU->getDeviceArrayClusters(),
+                               mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
+                               mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
+                               mTimeFrameGPU->getDeviceArrayTracklets(),
+                               mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
+                               currentLayerTrackletsNum,
+                               iLayer,
+                               nullptr,
+                               mTimeFrameGPU->getDeviceArrayCellsLUT(),
+                               mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
+                               this->mTrkParams[iteration].DeltaROF,
+                               this->mBz,
+                               this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                               this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
+                               this->mTrkParams[iteration].NSigmaCut,
+                               mTimeFrameGPU->getExternalAllocator(),
+                               conf.nBlocksLayerCells[iteration],
+                               conf.nThreadsLayerCells[iteration],
+                               mTimeFrameGPU->getStreams());
     mTimeFrameGPU->createCellsBuffers(iLayer);
     if (mTimeFrameGPU->getNCells()[iLayer] == 0) {
       continue;
     }
-    computeCellsHandler(mTimeFrameGPU->getDeviceArrayClusters(),
-                        mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
-                        mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
-                        mTimeFrameGPU->getDeviceArrayTracklets(),
-                        mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
-                        currentLayerTrackletsNum,
-                        iLayer,
-                        mTimeFrameGPU->getDeviceCells()[iLayer],
-                        mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                        mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
-                        this->mTrkParams[iteration].DeltaROF,
-                        this->mBz,
-                        this->mTrkParams[iteration].MaxChi2ClusterAttachment,
-                        this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
-                        this->mTrkParams[iteration].NSigmaCut,
-                        conf.nBlocksLayerCells[iteration],
-                        conf.nThreadsLayerCells[iteration],
-                        mTimeFrameGPU->getStreams());
+    computeCellsHandler<nLayers>(mTimeFrameGPU->getDeviceArrayClusters(),
+                                 mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
+                                 mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
+                                 mTimeFrameGPU->getDeviceArrayTracklets(),
+                                 mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
+                                 currentLayerTrackletsNum,
+                                 iLayer,
+                                 mTimeFrameGPU->getDeviceCells()[iLayer],
+                                 mTimeFrameGPU->getDeviceArrayCellsLUT(),
+                                 mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
+                                 this->mTrkParams[iteration].DeltaROF,
+                                 this->mBz,
+                                 this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                                 this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
+                                 this->mTrkParams[iteration].NSigmaCut,
+                                 conf.nBlocksLayerCells[iteration],
+                                 conf.nThreadsLayerCells[iteration],
+                                 mTimeFrameGPU->getStreams());
   }
 }
 
@@ -238,43 +238,43 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
     }
     mTimeFrameGPU->createNeighboursIndexTablesDevice(iLayer);
     mTimeFrameGPU->createNeighboursLUTDevice(iLayer, nextLayerCellsNum);
-    countCellNeighboursHandler(mTimeFrameGPU->getDeviceArrayCells(),
-                               mTimeFrameGPU->getDeviceNeighboursLUT(iLayer), // LUT is initialised here.
-                               mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                               mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
-                               mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
-                               (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                               this->mTrkParams[0].DeltaROF,
-                               this->mTrkParams[0].MaxChi2ClusterAttachment,
-                               this->mBz,
-                               iLayer,
-                               currentLayerCellsNum,
-                               nextLayerCellsNum,
-                               1e2,
-                               mTimeFrameGPU->getExternalAllocator(),
-                               conf.nBlocksFindNeighbours[iteration],
-                               conf.nThreadsFindNeighbours[iteration],
-                               mTimeFrameGPU->getStream(iLayer));
+    countCellNeighboursHandler<nLayers>(mTimeFrameGPU->getDeviceArrayCells(),
+                                        mTimeFrameGPU->getDeviceNeighboursLUT(iLayer), // LUT is initialised here.
+                                        mTimeFrameGPU->getDeviceArrayCellsLUT(),
+                                        mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
+                                        mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
+                                        (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
+                                        this->mTrkParams[0].DeltaROF,
+                                        this->mTrkParams[0].MaxChi2ClusterAttachment,
+                                        this->mBz,
+                                        iLayer,
+                                        currentLayerCellsNum,
+                                        nextLayerCellsNum,
+                                        1e2,
+                                        mTimeFrameGPU->getExternalAllocator(),
+                                        conf.nBlocksFindNeighbours[iteration],
+                                        conf.nThreadsFindNeighbours[iteration],
+                                        mTimeFrameGPU->getStream(iLayer));
     mTimeFrameGPU->createNeighboursDevice(iLayer);
     if (mTimeFrameGPU->getNNeighbours()[iLayer] == 0) {
       continue;
     }
-    computeCellNeighboursHandler(mTimeFrameGPU->getDeviceArrayCells(),
-                                 mTimeFrameGPU->getDeviceNeighboursLUT(iLayer),
-                                 mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                                 mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
-                                 mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
-                                 (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                                 this->mTrkParams[0].DeltaROF,
-                                 this->mTrkParams[0].MaxChi2ClusterAttachment,
-                                 this->mBz,
-                                 iLayer,
-                                 currentLayerCellsNum,
-                                 nextLayerCellsNum,
-                                 1e2,
-                                 conf.nBlocksFindNeighbours[iteration],
-                                 conf.nThreadsFindNeighbours[iteration],
-                                 mTimeFrameGPU->getStream(iLayer));
+    computeCellNeighboursHandler<nLayers>(mTimeFrameGPU->getDeviceArrayCells(),
+                                          mTimeFrameGPU->getDeviceNeighboursLUT(iLayer),
+                                          mTimeFrameGPU->getDeviceArrayCellsLUT(),
+                                          mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
+                                          mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
+                                          (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
+                                          this->mTrkParams[0].DeltaROF,
+                                          this->mTrkParams[0].MaxChi2ClusterAttachment,
+                                          this->mBz,
+                                          iLayer,
+                                          currentLayerCellsNum,
+                                          nextLayerCellsNum,
+                                          1e2,
+                                          conf.nBlocksFindNeighbours[iteration],
+                                          conf.nThreadsFindNeighbours[iteration],
+                                          mTimeFrameGPU->getStream(iLayer));
     mTimeFrameGPU->getArrayNNeighbours()[iLayer] = filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                                                                mTimeFrameGPU->getDeviceNeighbours(iLayer),
                                                                                mTimeFrameGPU->getArrayNNeighbours()[iLayer],
@@ -290,7 +290,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   for (int startLevel{this->mTrkParams[iteration].CellsPerRoad()}; startLevel >= this->mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     const int minimumLayer{startLevel - 1};
-    bounded_vector<CellSeed> trackSeeds(this->getMemoryPool().get());
+    bounded_vector<CellSeed<nLayers>> trackSeeds(this->getMemoryPool().get());
     for (int startLayer{this->mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= minimumLayer; --startLayer) {
       if ((this->mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 9b3df193abe34..694b598334be3 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -90,6 +90,11 @@ struct TypedAllocator {
   ExternalAllocator* mInternalAllocator;
 };
 
+GPUdii() int4 getEmptyBinsRect()
+{
+  return int4{0, 0, 0, 0};
+}
+
 GPUdii() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
                                 const o2::its::IndexTableUtils& utils,
                                 const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
@@ -247,12 +252,13 @@ struct is_valid_pair {
   }
 };
 
+template <int nLayers>
 struct seed_selector {
   float maxQ2Pt;
   float maxChi2;
 
   GPUhd() seed_selector(float maxQ2Pt, float maxChi2) : maxQ2Pt(maxQ2Pt), maxChi2(maxChi2) {}
-  GPUhd() bool operator()(const CellSeed& seed) const
+  GPUhd() bool operator()(const CellSeed<nLayers>& seed) const
   {
     return !(seed.getQ2Pt() > maxQ2Pt || seed.getChi2() > maxChi2);
   }
@@ -305,7 +311,7 @@ GPUdii() gpuSpan<const Cluster> getClustersOnLayer(const int rof,
 
 template <int nLayers>
 GPUg() void fitTrackSeedsKernel(
-  CellSeed* trackSeeds,
+  CellSeed<nLayers>* trackSeeds,
   const TrackingFrameInfo** foundTrackingFrameInfo,
   o2::its::TrackITSExt* tracks,
   const float* minPts,
@@ -324,7 +330,7 @@ GPUg() void fitTrackSeedsKernel(
 
     temporaryTrack.resetCovariance();
     temporaryTrack.setChi2(0);
-    int* clusters = seed.getClusters();
+    auto& clusters = seed.getClusters();
     for (int iL{0}; iL < 7; ++iL) {
       temporaryTrack.setExternalClusterIndex(iL, clusters[iL], clusters[iL] != constants::UnusedIndex);
     }
@@ -368,7 +374,7 @@ GPUg() void fitTrackSeedsKernel(
 
 template <bool initRun, int nLayers = 7>
 GPUg() void computeLayerCellNeighboursKernel(
-  CellSeed** cellSeedArray,
+  CellSeed<nLayers>** cellSeedArray,
   int* neighboursLUT,
   int* neighboursIndexTable,
   int** cellsLUTs,
@@ -388,7 +394,7 @@ GPUg() void computeLayerCellNeighboursKernel(
     const int nextLayerLastCellIndex{cellsLUTs[layerIndex + 1][nextLayerTrackletIndex + 1]};
     int foundNeighbours{0};
     for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
-      CellSeed nextCellSeed{cellSeedArray[layerIndex + 1][iNextCell]};      // Copy
+      auto nextCellSeed{cellSeedArray[layerIndex + 1][iNextCell]};          // Copy
       if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) { // Check if cells share the same tracklet
         break;
       }
@@ -430,7 +436,7 @@ GPUg() void computeLayerCellNeighboursKernel(
   }
 }
 
-template <bool initRun>
+template <bool initRun, int nLayers>
 GPUg() void computeLayerCellsKernel(
   const Cluster** sortedClusters,
   const Cluster** unsortedClusters,
@@ -439,7 +445,7 @@ GPUg() void computeLayerCellsKernel(
   int** trackletsLUT,
   const int nTrackletsCurrent,
   const int layer,
-  CellSeed* cells,
+  CellSeed<nLayers>* cells,
   int** cellsLUTs,
   const int deltaROF,
   const float bz,
@@ -506,7 +512,7 @@ GPUg() void computeLayerCellsKernel(
           continue;
         }
         if constexpr (!initRun) {
-          new (cells + cellsLUTs[layer][iCurrentTrackletIndex] + foundCells) CellSeed{layer, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2};
+          new (cells + cellsLUTs[layer][iCurrentTrackletIndex] + foundCells) CellSeed<nLayers>{layer, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2};
         }
         ++foundCells;
         if constexpr (initRun) {
@@ -654,14 +660,14 @@ GPUg() void compileTrackletsLookupTableKernel(const Tracklet* tracklets,
   }
 }
 
-template <bool dryRun, bool debug = false, int nLayers = 7>
+template <bool dryRun, int nLayers = 7>
 GPUg() void processNeighboursKernel(const int layer,
                                     const int level,
-                                    CellSeed** allCellSeeds,
-                                    CellSeed* currentCellSeeds,
+                                    CellSeed<nLayers>** allCellSeeds,
+                                    CellSeed<nLayers>* currentCellSeeds,
                                     const int* currentCellIds,
                                     const unsigned int nCurrentCells,
-                                    CellSeed* updatedCellSeeds,
+                                    CellSeed<nLayers>* updatedCellSeeds,
                                     int* updatedCellsIds,
                                     int* foundSeedsTable,               // auxiliary only in GPU code to compute the number of cells per iteration
                                     const unsigned char** usedClusters, // Used clusters
@@ -692,7 +698,7 @@ GPUg() void processNeighboursKernel(const int layer,
 
     for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
       const int neighbourCellId = neighbours[iNeighbourCell];
-      const CellSeed& neighbourCell = allCellSeeds[layer - 1][neighbourCellId];
+      const auto& neighbourCell = allCellSeeds[layer - 1][neighbourCellId];
 
       if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
         continue;
@@ -703,7 +709,7 @@ GPUg() void processNeighboursKernel(const int layer,
       if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
         continue;
       }
-      CellSeed seed{currentCell};
+      auto seed{currentCell};
       auto& trHit = foundTrackingFrameInfo[layer - 1][neighbourCell.getFirstClusterIndex()];
 
       if (!seed.rotate(trHit.alphaTrackingFrame)) {
@@ -904,6 +910,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
   }
 }
 
+template <int nLayers>
 void countCellsHandler(
   const Cluster** sortedClusters,
   const Cluster** unsortedClusters,
@@ -912,7 +919,7 @@ void countCellsHandler(
   int** trackletsLUT,
   const int nTracklets,
   const int layer,
-  CellSeed* cells,
+  CellSeed<nLayers>* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
   const int deltaROF,
@@ -944,6 +951,7 @@ void countCellsHandler(
   thrust::exclusive_scan(nosync_policy, cellsLUTsHost, cellsLUTsHost + nTracklets + 1, cellsLUTsHost);
 }
 
+template <int nLayers>
 void computeCellsHandler(
   const Cluster** sortedClusters,
   const Cluster** unsortedClusters,
@@ -952,7 +960,7 @@ void computeCellsHandler(
   int** trackletsLUT,
   const int nTracklets,
   const int layer,
-  CellSeed* cells,
+  CellSeed<nLayers>* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
   const int deltaROF,
@@ -981,7 +989,8 @@ void computeCellsHandler(
     nSigmaCut);               // const float
 }
 
-void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
+template <int nLayers>
+void countCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
                                 int* neighboursLUT,
                                 int** cellsLUTs,
                                 gpuPair<int, int>* cellNeighbours,
@@ -1017,7 +1026,8 @@ void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
   thrust::exclusive_scan(nosync_policy, neighboursIndexTable, neighboursIndexTable + nCells + 1, neighboursIndexTable);
 }
 
-void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
+template <int nLayers>
+void computeCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
                                   int* neighboursLUT,
                                   int** cellsLUTs,
                                   gpuPair<int, int>* cellNeighbours,
@@ -1068,14 +1078,14 @@ int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
 template <int nLayers>
 void processNeighboursHandler(const int startLayer,
                               const int startLevel,
-                              CellSeed** allCellSeeds,
-                              CellSeed* currentCellSeeds,
+                              CellSeed<nLayers>** allCellSeeds,
+                              CellSeed<nLayers>* currentCellSeeds,
                               std::array<int, nLayers - 2>& nCells,
                               const unsigned char** usedClusters,
                               std::array<int*, nLayers - 2>& neighbours,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                              bounded_vector<CellSeed>& seedsHost,
+                              bounded_vector<CellSeed<nLayers>>& seedsHost,
                               const float bz,
                               const float maxChi2ClusterAttachment,
                               const float maxChi2NDF,
@@ -1086,11 +1096,11 @@ void processNeighboursHandler(const int startLayer,
                               const int nThreads)
 {
   auto allocInt = gpu::TypedAllocator<int>(alloc);
-  auto allocCellSeed = gpu::TypedAllocator<CellSeed>(alloc);
+  auto allocCellSeed = gpu::TypedAllocator<CellSeed<nLayers>>(alloc);
   thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
   auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(gpu::Stream::DefaultStream);
 
-  gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(
+  gpu::processNeighboursKernel<true, nLayers><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1111,8 +1121,8 @@ void processNeighboursHandler(const int startLayer,
   thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
 
   thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
-  thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
-  gpu::processNeighboursKernel<false><<<nBlocks, nThreads>>>(
+  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
+  gpu::processNeighboursKernel<false, nLayers><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1134,17 +1144,17 @@ void processNeighboursHandler(const int startLayer,
 
   int level = startLevel;
   thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
-  thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> lastCellSeed(allocCellSeed);
+  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> lastCellSeed(allocCellSeed);
   for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
     lastCellSeed.swap(updatedCellSeed);
     lastCellId.swap(updatedCellId);
-    thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>>(allocCellSeed).swap(updatedCellSeed);
+    thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>>(allocCellSeed).swap(updatedCellSeed);
     thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellId);
     auto lastCellSeedSize{lastCellSeed.size()};
     foundSeedsTable.resize(lastCellSeedSize + 1);
     thrust::fill(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
-    gpu::processNeighboursKernel<true><<<nBlocks, nThreads>>>(
+    gpu::processNeighboursKernel<true, nLayers><<<nBlocks, nThreads>>>(
       iLayer,
       --level,
       allCellSeeds,
@@ -1168,9 +1178,9 @@ void processNeighboursHandler(const int startLayer,
     updatedCellId.resize(foundSeeds);
     thrust::fill(nosync_policy, updatedCellId.begin(), updatedCellId.end(), 0);
     updatedCellSeed.resize(foundSeeds);
-    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed());
+    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed<nLayers>());
 
-    gpu::processNeighboursKernel<false><<<nBlocks, nThreads>>>(
+    gpu::processNeighboursKernel<false, nLayers><<<nBlocks, nThreads>>>(
       iLayer,
       level,
       allCellSeeds,
@@ -1190,14 +1200,15 @@ void processNeighboursHandler(const int startLayer,
       matCorrType);
   }
   GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
-  thrust::device_vector<CellSeed, gpu::TypedAllocator<CellSeed>> outSeeds(updatedCellSeed.size(), allocCellSeed);
-  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
+  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> outSeeds(updatedCellSeed.size(), allocCellSeed);
+  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector<nLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
   auto s{end - outSeeds.begin()};
   seedsHost.reserve(seedsHost.size() + s);
   thrust::copy(outSeeds.begin(), outSeeds.begin() + s, std::back_inserter(seedsHost));
 }
 
-void trackSeedHandler(CellSeed* trackSeeds,
+template <int nLayers>
+void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const TrackingFrameInfo** foundTrackingFrameInfo,
                       o2::its::TrackITSExt* tracks,
                       std::vector<float>& minPtsHost,
@@ -1229,6 +1240,7 @@ void trackSeedHandler(CellSeed* trackSeeds,
   GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
 }
 
+/// Explicit instantiation of ITS2 handlers
 template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                              const uint8_t* multMask,
                                              const int layer,
@@ -1296,16 +1308,90 @@ template void computeTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                                const int nThreads,
                                                gpu::Streams& streams);
 
+template void countCellsHandler<7>(const Cluster** sortedClusters,
+                                   const Cluster** unsortedClusters,
+                                   const TrackingFrameInfo** tfInfo,
+                                   Tracklet** tracklets,
+                                   int** trackletsLUT,
+                                   const int nTracklets,
+                                   const int layer,
+                                   CellSeed<7>* cells,
+                                   int** cellsLUTsArrayDevice,
+                                   int* cellsLUTsHost,
+                                   const int deltaROF,
+                                   const float bz,
+                                   const float maxChi2ClusterAttachment,
+                                   const float cellDeltaTanLambdaSigma,
+                                   const float nSigmaCut,
+                                   o2::its::ExternalAllocator* alloc,
+                                   const int nBlocks,
+                                   const int nThreads,
+                                   gpu::Streams& streams);
+
+template void computeCellsHandler<7>(const Cluster** sortedClusters,
+                                     const Cluster** unsortedClusters,
+                                     const TrackingFrameInfo** tfInfo,
+                                     Tracklet** tracklets,
+                                     int** trackletsLUT,
+                                     const int nTracklets,
+                                     const int layer,
+                                     CellSeed<7>* cells,
+                                     int** cellsLUTsArrayDevice,
+                                     int* cellsLUTsHost,
+                                     const int deltaROF,
+                                     const float bz,
+                                     const float maxChi2ClusterAttachment,
+                                     const float cellDeltaTanLambdaSigma,
+                                     const float nSigmaCut,
+                                     const int nBlocks,
+                                     const int nThreads,
+                                     gpu::Streams& streams);
+
+template void countCellNeighboursHandler<7>(CellSeed<7>** cellsLayersDevice,
+                                            int* neighboursLUT,
+                                            int** cellsLUTs,
+                                            gpuPair<int, int>* cellNeighbours,
+                                            int* neighboursIndexTable,
+                                            const Tracklet** tracklets,
+                                            const int deltaROF,
+                                            const float maxChi2ClusterAttachment,
+                                            const float bz,
+                                            const int layerIndex,
+                                            const unsigned int nCells,
+                                            const unsigned int nCellsNext,
+                                            const int maxCellNeighbours,
+                                            o2::its::ExternalAllocator* alloc,
+                                            const int nBlocks,
+                                            const int nThreads,
+                                            gpu::Stream& stream);
+
+template void computeCellNeighboursHandler(CellSeed<7>** cellsLayersDevice,
+                                           int* neighboursLUT,
+                                           int** cellsLUTs,
+                                           gpuPair<int, int>* cellNeighbours,
+                                           int* neighboursIndexTable,
+                                           const Tracklet** tracklets,
+                                           const int deltaROF,
+                                           const float maxChi2ClusterAttachment,
+                                           const float bz,
+                                           const int layerIndex,
+                                           const unsigned int nCells,
+                                           const unsigned int nCellsNext,
+                                           const int maxCellNeighbours,
+                                           const int nBlocks,
+                                           const int nThreads,
+                                           gpu::Stream& stream);
+
 template void processNeighboursHandler<7>(const int startLayer,
                                           const int startLevel,
-                                          CellSeed** allCellSeeds,
-                                          CellSeed* currentCellSeeds,
+                                          CellSeed<7>** allCellSeeds,
+                                          CellSeed<7>* currentCellSeeds,
                                           std::array<int, 5>& nCells,
                                           const unsigned char** usedClusters,
                                           std::array<int*, 5>& neighbours,
                                           gsl::span<int*> neighboursDeviceLUTs,
                                           const TrackingFrameInfo** foundTrackingFrameInfo,
-                                          bounded_vector<CellSeed>& seedsHost,
+                                          bounded_vector<CellSeed<7>>& seedsHost,
                                           const float bz,
                                           const float maxChi2ClusterAttachment,
                                           const float maxChi2NDF,
@@ -1314,4 +1400,19 @@ template void processNeighboursHandler<7>(const int startLayer,
                                           o2::its::ExternalAllocator* alloc,
                                           const int nBlocks,
                                           const int nThreads);
+
+template void trackSeedHandler(CellSeed<7>* trackSeeds,
+                               const TrackingFrameInfo** foundTrackingFrameInfo,
+                               o2::its::TrackITSExt* tracks,
+                               std::vector<float>& minPtsHost,
+                               const unsigned int nSeeds,
+                               const float bz,
+                               const int startLevel,
+                               float maxChi2ClusterAttachment,
+                               float maxChi2NDF,
+                               const o2::base::Propagator* propagator,
+                               const o2::base::PropagatorF::MatCorrType matCorrType,
+                               const int nBlocks,
+                               const int nThreads);
+
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index fcea96abbfa82..902092a510eb0 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -43,12 +43,14 @@ class Cell final
   int mLevel{constants::UnusedIndex};
 };
 
+template <int nLayers>
 class CellSeed final : public o2::track::TrackParCovF
 {
  public:
   GPUhdDefault() CellSeed() = default;
   GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2) : o2::track::TrackParCovF(tpc), mChi2(chi2), mLevel(1)
   {
+    mClusters.fill(constants::UnusedIndex);
     setUserField(innerL);
     mClusters[innerL + 0] = cl0;
     mClusters[innerL + 1] = cl1;
@@ -74,18 +76,25 @@ class CellSeed final : public o2::track::TrackParCovF
   GPUhd() int getLevel() const { return mLevel; };
   GPUhd() void setLevel(int level) { mLevel = level; };
   GPUhd() int* getLevelPtr() { return &mLevel; }
-  GPUhd() int* getClusters() { return mClusters; }
+  GPUhd() auto& getClusters() { return mClusters; }
   GPUhd() int getCluster(int i) const { return mClusters[i]; }
   GPUhd() void printCell() const
   {
-    printf("trkl: %d, %d\t lvl: %d\t chi2: %f\tcls: [%d | %d | %d | %d | %d | %d | %d]\n", mTracklets[0], mTracklets[1], mLevel, mChi2, mClusters[0], mClusters[1], mClusters[2], mClusters[3], mClusters[4], mClusters[5], mClusters[6]);
+    printf("cell: %d, %d\t lvl: %d\t chi2: %f\tcls: [", mTracklets[0], mTracklets[1], mLevel, mChi2);
+    for (int i = 0; i < nLayers; ++i) {
+      printf("%d", mClusters[i]);
+      if (i < nLayers - 1) {
+        printf(" | ");
+      }
+    }
+    printf("]\n");
   }
 
  private:
   float mChi2 = -999.f;
   int mLevel = constants::UnusedIndex;
-  int mTracklets[2] = {constants::UnusedIndex, constants::UnusedIndex};
-  int mClusters[7] = {constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex, constants::UnusedIndex};
+  std::array<int, 2> mTracklets = constants::helpers::initArray<int, 2, constants::UnusedIndex>();
+  std::array<int, nLayers> mClusters = constants::helpers::initArray<int, nLayers, constants::UnusedIndex>();
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index ab9d0c2e4d1a6..22642f2e23229 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -16,21 +16,39 @@
 #ifndef TRACKINGITSU_INCLUDE_CONSTANTS_H_
 #define TRACKINGITSU_INCLUDE_CONSTANTS_H_
 
+#include <array>
+#include <utility>
+
 #include "ITStracking/Definitions.h"
+#include "GPUCommonDefAPI.h"
 
 namespace o2::its::constants
 {
-constexpr float MB = 1024.f * 1024.f;
-constexpr float GB = 1024.f * 1024.f * 1024.f;
+
+constexpr float KB = 1024.f;
+constexpr float MB = KB * KB;
+constexpr float GB = MB * KB;
 constexpr bool DoTimeBenchmarks = true;
 constexpr bool SaveTimeBenchmarks = false;
 
-constexpr float Tolerance{1e-12}; // numerical tolerance
-constexpr int ClustersPerCell{3};
-constexpr int UnusedIndex{-1};
-constexpr float Resolution{0.0005f};
-constexpr float Radl = 9.36f; // Radiation length of Si [cm]
-constexpr float Rho = 2.33f;  // Density of Si [g/cm^3]
+GPUconstexpr() float Tolerance{1e-12}; // numerical tolerance
+GPUconstexpr() int ClustersPerCell{3};
+GPUconstexpr() int UnusedIndex{-1};
+GPUconstexpr() float Resolution{0.0005f};
+GPUconstexpr() float Radl = 9.36f; // Radiation length of Si [cm]
+GPUconstexpr() float Rho = 2.33f;  // Density of Si [g/cm^3]
+
+namespace helpers
+{
+
+// initialize a std::array at compile time fully with T
+template <typename T, std::size_t N, T Value>
+constexpr std::array<T, N> initArray()
+{
+  return []<std::size_t... Is>(std::index_sequence<Is...>) { return std::array<T, N>{(static_cast<void>(Is), Value)...}; }(std::make_index_sequence<N>{});
+}
+
+} // namespace helpers
 } // namespace o2::its::constants
 
 #endif /* TRACKINGITSU_INCLUDE_CONSTANTS_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
index 75f187f31652b..009f3a1b5b146 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
@@ -16,13 +16,15 @@
 #ifndef TRACKINGCA_INCLUDE_ROAD_H
 #define TRACKINGCA_INCLUDE_ROAD_H
 
+#include <array>
+
 #include "ITStracking/Constants.h"
 #include "GPUCommonDef.h"
 
 namespace o2::its
 {
 
-template <unsigned char maxRoadSize = 5>
+template <unsigned char maxRoadSize>
 class Road final
 {
  public:
@@ -60,7 +62,7 @@ class Road final
   }
 
  private:
-  int mCellIds[maxRoadSize]{constants::UnusedIndex};
+  std::array<int, maxRoadSize> mCellIds = constants::helpers::initArray<int, maxRoadSize, constants::UnusedIndex>();
   unsigned char mRoadSize{0};
   bool mIsFakeRoad{false};
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index d9d89e8149e62..ebc885a3a35cf 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -65,9 +65,12 @@ class TimeFrameGPU;
 
 template <int nLayers = 7>
 struct TimeFrame {
+  using CellSeedN = CellSeed<nLayers>;
   friend class gpu::TimeFrameGPU<nLayers>;
+
   TimeFrame();
   virtual ~TimeFrame();
+
   const Vertex& getPrimaryVertex(const int ivtx) const { return mPrimaryVertices[ivtx]; }
   gsl::span<const Vertex> getPrimaryVertices(int rofId) const;
   gsl::span<const Vertex> getPrimaryVertices(int romin, int romax) const;
@@ -298,7 +301,7 @@ struct TimeFrame {
 
   std::array<bounded_vector<Cluster>, nLayers> mUnsortedClusters;
   std::vector<bounded_vector<Tracklet>> mTracklets;
-  std::vector<bounded_vector<CellSeed>> mCells;
+  std::vector<bounded_vector<CellSeedN>> mCells;
   bounded_vector<Road<nLayers - 2>> mRoads;
   std::vector<bounded_vector<TrackITSExt>> mTracks;
   std::vector<bounded_vector<int>> mCellsNeighbours;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 3f80d239946b1..642717bd09596 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -51,17 +51,15 @@ class GPUChainITS;
 namespace its
 {
 
+template <int nLayers>
 class Tracker
 {
-  static constexpr int NLayers{7};
-  using TrackerTraits7 = TrackerTraits<NLayers>;
-  using TimeFrame7 = TimeFrame<NLayers>;
   using LogFunc = std::function<void(const std::string& s)>;
 
  public:
-  Tracker(TrackerTraits<NLayers>* traits);
+  Tracker(TrackerTraits<nLayers>* traits);
 
-  void adoptTimeFrame(TimeFrame<NLayers>& tf);
+  void adoptTimeFrame(TimeFrame<nLayers>& tf);
 
   void clustersToTracks(
     const LogFunc& = [](const std::string& s) { std::cout << s << '\n'; },
@@ -92,8 +90,8 @@ class Tracker
   template <typename... T, typename... F>
   float evaluateTask(void (Tracker::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args);
 
-  TrackerTraits7* mTraits = nullptr; /// Observer pointer, not owned by this class
-  TimeFrame7* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
+  TrackerTraits<nLayers>* mTraits = nullptr; /// Observer pointer, not owned by this class
+  TimeFrame<nLayers>* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
 
   std::vector<TrackingParameters> mTrkParams;
   o2::gpu::GPUChainITS* mRecoChain = nullptr;
@@ -115,8 +113,9 @@ class Tracker
   static constexpr std::array<const char*, NStates> StateNames{"TimeFrame initialisation", "Tracklet finding", "Cell finding", "Neighbour finding", "Road finding"};
 };
 
+template <int nLayers>
 template <typename... T, typename... F>
-float Tracker::evaluateTask(void (Tracker::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args)
+float Tracker<nLayers>::evaluateTask(void (Tracker<nLayers>::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args)
 {
   float diff{0.f};
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 08961a2c8c1ee..8647236b4f7e7 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -22,6 +22,7 @@
 #include "ITStracking/Configuration.h"
 #include "ITStracking/MathUtils.h"
 #include "ITStracking/TimeFrame.h"
+#include "ITStracking/Cell.h"
 #include "ITStracking/BoundedAllocator.h"
 
 // #define OPTIMISATION_OUTPUT
@@ -39,6 +40,8 @@ class TrackITSExt;
 template <int nLayers = 7>
 class TrackerTraits
 {
+  using CellSeedN = CellSeed<nLayers>;
+
  public:
   virtual ~TrackerTraits() = default;
   virtual void adoptTimeFrame(TimeFrame<nLayers>* tf) { mTimeFrame = tf; }
@@ -55,7 +58,7 @@ class TrackerTraits
   virtual void findShortPrimaries();
 
   virtual bool trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration);
-  virtual void processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeed>& updatedCellSeed, bounded_vector<int>& updatedCellId);
+  virtual void processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId);
 
   void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars) { mTrkParams = trkPars; }
   TimeFrame<nLayers>* getTimeFrame() { return mTimeFrame; }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index f123a2a9a1d80..9d927e21202cc 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -35,8 +35,9 @@ namespace o2::its
 class ITSTrackingInterface
 {
   static constexpr int NLayers{7};
-  using TrackerTraits7 = TrackerTraits<NLayers>;
-  using TimeFrame7 = TimeFrame<NLayers>;
+  using TrackerN = Tracker<NLayers>;
+  using TrackerTraitsN = TrackerTraits<NLayers>;
+  using TimeFrameN = TimeFrame<NLayers>;
 
  public:
   ITSTrackingInterface(bool isMC,
@@ -66,13 +67,13 @@ class ITSTrackingInterface
   virtual void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj);
 
   // Custom
-  void setTraitsFromProvider(VertexerTraits*, TrackerTraits7*, TimeFrame7*);
+  void setTraitsFromProvider(VertexerTraits*, TrackerTraitsN*, TimeFrameN*);
   void setTrackingMode(TrackingMode::Type mode = TrackingMode::Unset) { mMode = mode; }
 
   auto getTracker() const { return mTracker.get(); }
   auto getVertexer() const { return mVertexer.get(); }
 
-  TimeFrame7* mTimeFrame = nullptr;
+  TimeFrameN* mTimeFrame = nullptr;
 
  protected:
   virtual void loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
@@ -88,7 +89,7 @@ class ITSTrackingInterface
   TrackingMode::Type mMode = TrackingMode::Unset;
   bool mOverrideBeamEstimation = false;
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
-  std::unique_ptr<Tracker> mTracker = nullptr;
+  std::unique_ptr<TrackerN> mTracker = nullptr;
   std::unique_ptr<Vertexer> mVertexer = nullptr;
   const o2::dataformats::MeanVertexObject* mMeanVertex;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index a59c51949b9f9..18da81d25fbd8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -382,7 +382,7 @@ unsigned long TimeFrame<nLayers>::getArtefactsMemory() const
     size += sizeof(Tracklet) * trkl.size();
   }
   for (const auto& cells : mCells) {
-    size += sizeof(CellSeed) * cells.size();
+    size += sizeof(CellSeedN) * cells.size();
   }
   for (const auto& cellsN : mCellsNeighbours) {
     size += sizeof(int) * cellsN.size();
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index c8bf39142e019..746a15287e994 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -34,7 +34,8 @@ namespace o2::its
 {
 using o2::its::constants::GB;
 
-Tracker::Tracker(TrackerTraits7* traits) : mTraits(traits)
+template <int nLayers>
+Tracker<nLayers>::Tracker(TrackerTraits<nLayers>* traits) : mTraits(traits)
 {
   /// Initialise standard configuration with 1 iteration
   mTrkParams.resize(1);
@@ -44,7 +45,8 @@ Tracker::Tracker(TrackerTraits7* traits) : mTraits(traits)
   }
 }
 
-void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
+template <int nLayers>
+void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& error)
 {
   LogFunc evalLog = [](const std::string&) {};
 
@@ -158,7 +160,8 @@ void Tracker::clustersToTracks(const LogFunc& logger, const LogFunc& error)
   }
 }
 
-void Tracker::computeRoadsMClabels()
+template <int nLayers>
+void Tracker<nLayers>::computeRoadsMClabels()
 {
   /// Moore's Voting Algorithm
   if (!mTimeFrame->hasMCinformation()) {
@@ -171,7 +174,7 @@ void Tracker::computeRoadsMClabels()
 
   for (int iRoad{0}; iRoad < roadsNum; ++iRoad) {
 
-    Road<5>& currentRoad{mTimeFrame->getRoads()[iRoad]};
+    auto& currentRoad{mTimeFrame->getRoads()[iRoad]};
     std::vector<std::pair<MCCompLabel, size_t>> occurrences;
     bool isFakeRoad{false};
     bool isFirstRoadCell{true};
@@ -187,7 +190,7 @@ void Tracker::computeRoadsMClabels()
         }
       }
 
-      const CellSeed& currentCell{mTimeFrame->getCells()[iCell][currentCellIndex]};
+      const auto& currentCell{mTimeFrame->getCells()[iCell][currentCellIndex]};
 
       if (isFirstRoadCell) {
 
@@ -262,7 +265,8 @@ void Tracker::computeRoadsMClabels()
   }
 }
 
-void Tracker::computeTracksMClabels()
+template <int nLayers>
+void Tracker<nLayers>::computeTracksMClabels()
 {
   for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
     for (auto& track : mTimeFrame->getTracks(iROF)) {
@@ -320,7 +324,8 @@ void Tracker::computeTracksMClabels()
   }
 }
 
-void Tracker::rectifyClusterIndices()
+template <int nLayers>
+void Tracker<nLayers>::rectifyClusterIndices()
 {
   for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
     for (auto& track : mTimeFrame->getTracks(iROF)) {
@@ -334,17 +339,21 @@ void Tracker::rectifyClusterIndices()
   }
 }
 
-void Tracker::adoptTimeFrame(TimeFrame7& tf)
+template <int nLayers>
+void Tracker<nLayers>::adoptTimeFrame(TimeFrame<nLayers>& tf)
 {
   mTimeFrame = &tf;
   mTraits->adoptTimeFrame(&tf);
 }
 
-void Tracker::printSummary() const
+template <int nLayers>
+void Tracker<nLayers>::printSummary() const
 {
   auto avgTF = mTotalTime * 1.e-3 / ((mTimeFrameCounter > 0) ? (double)mTimeFrameCounter : -1.0);
   auto avgTFwithDropped = mTotalTime * 1.e-3 / (((mTimeFrameCounter + mNumberOfDroppedTFs) > 0) ? (double)(mTimeFrameCounter + mNumberOfDroppedTFs) : -1.0);
   LOGP(info, "Tracker summary: Processed {} TFs (dropped {}) in TOT={:.2f} s, AVG/TF={:.2f} ({:.2f}) s", mTimeFrameCounter, mNumberOfDroppedTFs, mTotalTime * 1.e-3, avgTF, avgTFwithDropped);
 }
 
+template class Tracker<7>;
+
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 2ebfbfe235c5b..fc43a09694dd8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -319,7 +319,7 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
   }
 
   mTaskArena->execute([&] {
-    auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeed>& layerCells, int iTracklet, int offset = 0) -> int {
+    auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeedN>& layerCells, int iTracklet, int offset = 0) -> int {
       const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
       const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
       const int nextLayerFirstTrackletIndex{mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
@@ -392,7 +392,7 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
               ++foundCells;
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
-              layerCells[offset++] = CellSeed(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
+              layerCells[offset++] = CellSeedN(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
             } else {
               static_assert(false, "Unknown mode!");
             }
@@ -615,7 +615,7 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
 }
 
 template <int nLayers>
-void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeed>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
+void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
 {
   CA_DEBUGGER(std::cout << "Processing neighbours layer " << iLayer << " level " << iLevel << ", size of the cell seeds: " << currentCellSeed.size() << std::endl);
   auto propagator = o2::base::Propagator::Instance();
@@ -626,7 +626,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
 
   mTaskArena->execute([&] {
     auto forCellNeighbours = [&](auto Tag, int iCell, int offset = 0) -> int {
-      const CellSeed& currentCell{currentCellSeed[iCell]};
+      const auto& currentCell{currentCellSeed[iCell]};
 
       if constexpr (decltype(Tag)::value != PassMode::TwoPassInsert::value) {
         if (currentCell.getLevel() != iLevel) {
@@ -646,7 +646,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
       for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
         CA_DEBUGGER(attempts++);
         const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
-        const CellSeed& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
+        const auto& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
         if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
           CA_DEBUGGER(failedByMismatch++);
           continue;
@@ -660,7 +660,7 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
         }
 
         /// Let's start the fitting procedure
-        CellSeed seed{currentCell};
+        CellSeedN seed{currentCell};
         const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
 
         if (!seed.rotate(trHit.alphaTrackingFrame)) {
@@ -767,17 +767,17 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
 
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     CA_DEBUGGER(std::cout << "\t > Processing level " << startLevel << std::endl);
-    auto seedFilter = [&](const CellSeed& seed) {
+    auto seedFilter = [&](const auto& seed) {
       return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[0].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
     };
-    bounded_vector<CellSeed> trackSeeds(mMemoryPool.get());
+    bounded_vector<CellSeedN> trackSeeds(mMemoryPool.get());
     for (int startLayer{mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= startLevel - 1; --startLayer) {
       if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
       }
       CA_DEBUGGER(std::cout << "\t\t > Starting processing layer " << startLayer << std::endl);
       bounded_vector<int> lastCellId(mMemoryPool.get()), updatedCellId(mMemoryPool.get());
-      bounded_vector<CellSeed> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
+      bounded_vector<CellSeedN> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
 
       processNeighbours(startLayer, startLevel, mTimeFrame->getCells()[startLayer], lastCellId, updatedCellSeed, updatedCellId);
 
@@ -805,7 +805,7 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
     bounded_vector<TrackITSExt> tracks(mMemoryPool.get());
     mTaskArena->execute([&] {
       auto forSeed = [&](auto Tag, int iSeed, int offset = 0) {
-        const CellSeed& seed{trackSeeds[iSeed]};
+        const auto& seed{trackSeeds[iSeed]};
         TrackITSExt temporaryTrack{seed};
         temporaryTrack.resetCovariance();
         temporaryTrack.setChi2(0);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index 3b05a7655d68c..d2e96aad40a9e 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -383,11 +383,11 @@ void ITSTrackingInterface::printSummary() const
 }
 
 void ITSTrackingInterface::setTraitsFromProvider(VertexerTraits* vertexerTraits,
-                                                 TrackerTraits7* trackerTraits,
-                                                 TimeFrame7* frame)
+                                                 TrackerTraitsN* trackerTraits,
+                                                 TimeFrameN* frame)
 {
   mVertexer = std::make_unique<Vertexer>(vertexerTraits);
-  mTracker = std::make_unique<Tracker>(trackerTraits);
+  mTracker = std::make_unique<TrackerN>(trackerTraits);
   mTimeFrame = frame;
   mVertexer->adoptTimeFrame(*mTimeFrame);
   mTracker->adoptTimeFrame(*mTimeFrame);

From 556556aeec6e1d9ea530baa1d953b31e6eb31725 Mon Sep 17 00:00:00 2001
From: Fabio Catalano <fabio.catalano@cern.ch>
Date: Wed, 30 Jul 2025 13:28:15 +0200
Subject: [PATCH 0719/1764] ZDC: Add getter for hit secondary flag

---
 DataFormats/Detectors/ZDC/include/DataFormatsZDC/Hit.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/Hit.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/Hit.h
index 6e0b99dca6761..3ce90a95f7248 100644
--- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/Hit.h
+++ b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/Hit.h
@@ -58,6 +58,7 @@ class Hit : public o2::BasicXYZEHit<Float_t, Float_t>
   float getPMCLightYield() const { return mNphePMC; }
   float getPMQLightYield() const { return mNphePMQ; }
   int getNumContributingSteps() const { return mNoContributingSteps; }
+  bool getSecFlag() const { return mSecFlag; }
 
  private:
   Int_t mParentID;

From 6b6098b988626b58e07e5e76702b771ca1018078 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 19 Aug 2025 13:05:36 +0200
Subject: [PATCH 0720/1764] ITS: create artefacts labels only on demand 
 (#14594)

---
 .../include/ITStracking/Configuration.h       |  2 ++
 .../include/ITStracking/TrackingConfigParam.h |  2 ++
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |  2 ++
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 11 +++++---
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 25 +++++++++++--------
 5 files changed, 29 insertions(+), 13 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 40fe31abbfa36..2bfa0639ad5a2 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -80,6 +80,8 @@ struct TrackingParameters {
   float TrackFollowerNSigmaCutZ = 1.f;
   float TrackFollowerNSigmaCutPhi = 1.f;
 
+  bool createArtefactLabels{false};
+
   bool PrintMemory = false; // print allocator usage in epilog report
   size_t MaxMemory = std::numeric_limits<size_t>::max();
   bool DropTFUponFailure = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 5b4b1aca1dfb8..e8d3692909d05 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -97,6 +97,8 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   bool doUPCIteration = false;             // Perform an additional iteration for UPC events on tagged vertices. You want to combine this config with VertexerParamConfig.nIterations=2
   int nIterations = MaxIter;               // overwrite the number of iterations
 
+  bool createArtefactLabels{false}; // create on-the-fly labels for the artefacts
+
   int nThreads = 1;
   bool printMemory = false;
   size_t maxMemory = std::numeric_limits<size_t>::max();
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 144b9a1dfc7c4..6af66b18a2878 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -187,6 +187,8 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       p.MinPt[lslot] *= bFactor;
     }
 
+    p.createArtefactLabels = tc.createArtefactLabels;
+
     p.PrintMemory = tc.printMemory;
     p.MaxMemory = tc.maxMemory;
     p.DropTFUponFailure = tc.dropTFUponFailure;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 18da81d25fbd8..510c66e2420f1 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -666,7 +666,6 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mROFramesPV);
   deepVectorClear(mPrimaryVertices);
   deepVectorClear(mRoads);
-  deepVectorClear(mRoadLabels);
   deepVectorClear(mMSangles);
   deepVectorClear(mPhiCuts);
   deepVectorClear(mPositionResolution);
@@ -676,9 +675,15 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mTrackletsIndexROF);
   deepVectorClear(mPrimaryVertices);
   deepVectorClear(mTrackletClusters);
-  deepVectorClear(mVerticesContributorLabels);
   deepVectorClear(mLines);
-  deepVectorClear(mLinesLabels);
+  if (hasMCinformation()) {
+    deepVectorClear(mLinesLabels);
+    deepVectorClear(mVerticesContributorLabels);
+    deepVectorClear(mTrackletLabels);
+    deepVectorClear(mCellLabels);
+    deepVectorClear(mRoadLabels);
+    deepVectorClear(mTracksLabel);
+  }
 }
 
 template class TimeFrame<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index fc43a09694dd8..280101d4dc4c7 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -272,7 +272,7 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
       });
 
     /// Create tracklets labels
-    if (mTimeFrame->hasMCinformation()) {
+    if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
       tbb::parallel_for(
         tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
         [&](const tbb::blocked_range<int>& Layers) {
@@ -313,7 +313,7 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
     if (iLayer > 0) {
       deepVectorClear(mTimeFrame->getCellsLookupTable()[iLayer - 1]);
     }
-    if (mTimeFrame->hasMCinformation()) {
+    if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
       deepVectorClear(mTimeFrame->getCellsLabel(iLayer));
     }
   }
@@ -458,14 +458,19 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
   });
 
   /// Create cells labels
-  if (mTimeFrame->hasMCinformation()) {
-    for (int iLayer{0}; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-      for (const auto& cell : mTimeFrame->getCells()[iLayer]) {
-        MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
-        MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
-        mTimeFrame->getCellsLabel(iLayer).emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
-      }
-    }
+  if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
+    tbb::parallel_for(
+      tbb::blocked_range<int>(0, mTrkParams[iteration].CellsPerRoad()),
+      [&](const tbb::blocked_range<int>& Layers) {
+        for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
+          mTimeFrame->getCellsLabel(iLayer).reserve(mTimeFrame->getCells()[iLayer].size());
+          for (const auto& cell : mTimeFrame->getCells()[iLayer]) {
+            MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
+            MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
+            mTimeFrame->getCellsLabel(iLayer).emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
+          }
+        }
+      });
   }
 }
 

From 89bef8a2f52b117003758db9d996276a234751a8 Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Tue, 19 Aug 2025 14:37:37 +0200
Subject: [PATCH 0721/1764] DPL: don't print INVALID runNumber error when
 running with ALICE_O2_FST=1 (#14591)

---
 Framework/Core/src/ExternalFairMQDeviceProxy.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index cfc445725a92d..c07baeaaf40b8 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -13,6 +13,8 @@
 #include "Framework/AlgorithmSpec.h"
 #include "Framework/DataProcessingHeader.h"
 #include "Framework/DataSpecUtils.h"
+#include "Framework/DataTakingContext.h"
+#include "Framework/DefaultsHelpers.h"
 #include "Framework/DeviceSpec.h"
 #include "Framework/ExternalFairMQDeviceProxy.h"
 #include "Framework/InitContext.h"
@@ -534,7 +536,7 @@ InjectorFunction dplModelAdaptor(std::vector<OutputSpec> const& filterSpecs, DPL
       timingInfo.runNumber = dh->runNumber;
       timingInfo.tfCounter = dh->tfCounter;
       LOG(debug) << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();
-      if (dh->runNumber == 0 || (dh->tfCounter == 0 && dh->dataDescription.as<std::string>() != "EOS") || (fmqRunNumber > 0 && fmqRunNumber != dh->runNumber)) {
+      if (DefaultsHelpers::deploymentMode() != DeploymentMode::FST && (dh->runNumber == 0 || (dh->tfCounter == 0 && dh->dataDescription.as<std::string>() != "EOS") || (fmqRunNumber > 0 && fmqRunNumber != dh->runNumber))) {
         LOG(error) << "INVALID runNumber / tfCounter: runNumber " << dh->runNumber
                    << ", tfCounter " << dh->tfCounter << ", FMQ runNumber " << fmqRunNumber
                    << " for msgidx " << msgidx << ": " << DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}) << " part " << dh->splitPayloadIndex << " of " << dh->splitPayloadParts << "  payload " << parts.At(msgidx + 1)->GetSize();

From be990f75447aec73fa621173875dcb684625283c Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 20 Aug 2025 10:37:29 +0200
Subject: [PATCH 0722/1764] DPL Analysis: fix for retrieving placeholder nodes
 in filters parsed from strings (#14603)

---
 Framework/Core/include/Framework/Expressions.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index e2fdd0493d033..5a889e9ae26ec 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -168,16 +168,18 @@ struct PlaceholderNode : LiteralNode {
   template <typename T>
   PlaceholderNode(T defaultValue, std::string&& path)
     : LiteralNode{defaultValue},
-      name{path}
+      stored_name{path},
+      name{stored_name}
   {
     retrieve = [](InitContext& context, char const* name) { return LiteralNode::var_t{context.options().get<T>(name)}; };
   }
 
   void reset(InitContext& context)
   {
-    value = retrieve(context, name.data());
+    value = retrieve(context, stored_name.empty() ? name.data() : stored_name.data());
   }
 
+  std::string stored_name;
   std::string const& name;
   LiteralNode::var_t (*retrieve)(InitContext&, char const*);
 };

From 396c2c41136880b814ea2c2ab23c17292903af97 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 20 Aug 2025 15:01:35 +0200
Subject: [PATCH 0723/1764] Add sapling to the .gitignore (#14605)

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 6db76441528d9..d58d1e151800b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -82,6 +82,9 @@ bazel-*
 # direnv
 .envrc
 
+# git wrappers
+.sl
+
 # LSP support on macOS with vim
 .clangd
 DataFormats/Detectors/CTP/include/DataFormatsCTP/Scalers.h

From d84a22ca453dd1dab241edcb118ab3b8ba3f6b1b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 20 Aug 2025 16:04:37 +0200
Subject: [PATCH 0724/1764] DPL: make addInputs support anything which provides
 base_specs (#14575)

---
 Framework/Core/include/Framework/AnalysisManagers.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 02d252970d731..6c43bf3eebebb 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -159,7 +159,9 @@ const char* controlOption()
 }
 
 template <typename T>
-  requires(is_spawns<T> || is_builds<T> || is_defines<T>)
+concept with_base_table = requires(T const& t) { t.base_specs(); };
+
+template <with_base_table T>
 bool requestInputs(std::vector<InputSpec>& inputs, T const& entity)
 {
   auto base_specs = entity.base_specs();

From 9b8fb2326d967dbef763ba328b43580c5ce74972 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <48915672+matthias-kleiner@users.noreply.github.com>
Date: Thu, 21 Aug 2025 13:25:23 +0200
Subject: [PATCH 0725/1764] TPC: Add scaling of VDrift with T/P (#14602)

* TPC: Add scaling of VDrift with T/P

- scaling of the VDrift is automatically enabled
- the reference T/P is extracted for VDrift objects without stored T/P if firstTime and
lastTime of VDrift object is in the range +-20 minutes of available temperature and pressure
- scaling with T/P can be disabled by setting 'TPCGasParam.Temperature=0;TPCGasParam.Pressure=0'
- reference T/P is extracted automatically for online created VDrift
with ITSTgl and laser method
- add storing of temperature. pressure and used VDrift in timeseries

* VDrift: Keep refVDrift constant by changing corrFact with T/P
---
 .../TPC/include/DataFormatsTPC/LtrCalibData.h |  3 +-
 .../include/DataFormatsTPC/VDriftCorrFact.h   | 28 +++---
 .../IntegratedClusterCalibrator.h             |  5 +-
 Detectors/GlobalTracking/src/MatchTPCITS.cxx  |  2 +-
 .../include/TPCCalibration/CalibLaserTracks.h | 11 ++-
 .../PressureTemperatureHelper.h               | 20 +++++
 .../TPCCalibration/TPCVDriftTglCalibration.h  | 15 +++-
 .../include/TPCCalibration/VDriftHelper.h     | 12 ++-
 .../TPC/calibration/src/CalibLaserTracks.cxx  | 27 +++++-
 .../src/PressureTemperatureHelper.cxx         | 77 +++++++++++++++-
 .../src/TPCVDriftTglCalibration.cxx           |  3 +-
 .../TPC/calibration/src/VDriftHelper.cxx      | 87 +++++++++++++++++--
 .../TPCWorkflow/CalibLaserTracksSpec.h        |  6 +-
 .../TPC/workflow/src/TPCTimeSeriesSpec.cxx    | 15 ++--
 .../workflow/src/TPCVDriftTglCalibSpec.cxx    | 21 ++++-
 15 files changed, 287 insertions(+), 45 deletions(-)

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/LtrCalibData.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/LtrCalibData.h
index e410cd00dd3f6..e5e9b41229d50 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/LtrCalibData.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/LtrCalibData.h
@@ -42,6 +42,7 @@ struct LtrCalibData {
   std::vector<uint16_t> matchedLtrIDs; ///< matched laser track IDs
   std::vector<uint16_t> nTrackTF;      ///< number of laser tracks per TF
   std::vector<float> dEdx;             ///< dE/dx of each track
+  float tp{0.f};                       ///< temperature over pressure ratio
 
   bool isValid() const
   {
@@ -138,7 +139,7 @@ struct LtrCalibData {
     dEdx.clear();
   }
 
-  ClassDefNV(LtrCalibData, 4);
+  ClassDefNV(LtrCalibData, 5);
 };
 
 } // namespace o2::tpc
diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/VDriftCorrFact.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/VDriftCorrFact.h
index 03ad9755fedae..a20c37e9b2cee 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/VDriftCorrFact.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/VDriftCorrFact.h
@@ -26,14 +26,15 @@ namespace o2::tpc
 {
 
 struct VDriftCorrFact {
-  long firstTime{};       ///< first time stamp of processed TFs
-  long lastTime{};        ///< last time stamp of processed TFs
-  long creationTime{};    ///< time of creation
-  float corrFact{1.0};    ///< drift velocity correction factor (multiplicative)
-  float corrFactErr{0.0}; ///< stat error of correction factor
-  float refVDrift{0.};    ///< reference vdrift for which factor was extracted
+  long firstTime{};         ///< first time stamp of processed TFs
+  long lastTime{};          ///< last time stamp of processed TFs
+  long creationTime{};      ///< time of creation
+  float corrFact{1.0};      ///< drift velocity correction factor (multiplicative)
+  float corrFactErr{0.0};   ///< stat error of correction factor
+  float refVDrift{0.};      ///< reference vdrift for which factor was extracted
   float refTimeOffset{0.};  ///< additive time offset reference (\mus)
   float timeOffsetCorr{0.}; ///< additive time offset correction (\mus)
+  float refTP{0.};          ///< reference temperature / pressure for which refVDrift was extracted
 
   float getVDrift() const { return refVDrift * corrFact; }
   float getVDriftError() const { return refVDrift * corrFactErr; }
@@ -41,12 +42,19 @@ struct VDriftCorrFact {
   float getTimeOffset() const { return refTimeOffset + timeOffsetCorr; }
 
   // renormalize VDrift reference and correction either to provided new reference (if >0) or to correction 1 wrt current reference
-  void normalize(float newVRef = 0.f)
+  void normalize(float newVRef = 0.f, float tp = 0.f)
   {
+    float normVDrift = newVRef;
     if (newVRef == 0.f) {
-      newVRef = refVDrift * corrFact;
+      normVDrift = refVDrift * corrFact;
+      newVRef = normVDrift;
+      if ((tp > 0) && (refTP > 0)) {
+        // linear scaling based on relative change of T/P
+        normVDrift *= refTP / tp;
+        refTP = tp; // update reference T/P
+      }
     }
-    float fact = refVDrift / newVRef;
+    float fact = refVDrift / normVDrift;
     refVDrift = newVRef;
     corrFactErr *= fact;
     corrFact *= fact;
@@ -66,7 +74,7 @@ struct VDriftCorrFact {
     }
   }
 
-  ClassDefNV(VDriftCorrFact, 2);
+  ClassDefNV(VDriftCorrFact, 3);
 };
 
 } // namespace o2::tpc
diff --git a/Detectors/Calibration/include/DetectorsCalibration/IntegratedClusterCalibrator.h b/Detectors/Calibration/include/DetectorsCalibration/IntegratedClusterCalibrator.h
index 8a6996c35f2b3..9720142d391b1 100644
--- a/Detectors/Calibration/include/DetectorsCalibration/IntegratedClusterCalibrator.h
+++ b/Detectors/Calibration/include/DetectorsCalibration/IntegratedClusterCalibrator.h
@@ -331,6 +331,9 @@ struct TimeSeriesdEdx {
 };
 
 struct TimeSeriesITSTPC {
+  float mVDrift = 0;                          ///< drift velocity in cm/us
+  float mPressure = 0;                        ///< pressure
+  float mTemperature = 0;                     ///< temperature
   TimeSeries mTSTPC;                          ///< TPC standalone DCAs
   TimeSeries mTSITSTPC;                       ///< ITS-TPC standalone DCAs
   ITSTPC_Matching mITSTPCAll;                 ///< ITS-TPC matching efficiency for ITS standalone + afterburner
@@ -499,7 +502,7 @@ struct TimeSeriesITSTPC {
     nVertexContributors_Quantiles.resize(nTotalQ);
   }
 
-  ClassDefNV(TimeSeriesITSTPC, 5);
+  ClassDefNV(TimeSeriesITSTPC, 6);
 };
 
 } // end namespace tpc
diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index c8c9dda6a4025..e16031f641829 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -101,7 +101,7 @@ void MatchTPCITS::run(const o2::globaltracking::RecoContainer& inp,
       break;
     }
     if (mVDriftCalibOn) { // in the beginning of the output vector we send the full and reference VDrift used for this TF
-      calib.emplace_back(mTPCVDrift, mTPCDrift.refVDrift, -999.);
+      calib.emplace_back(mTPCVDrift, mTPCDrift.refVDrift, mTPCDrift.refTP);
       calib.emplace_back(mTPCDriftTimeOffset, mTPCDrift.refTimeOffset, -999.);
     }
 
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CalibLaserTracks.h b/Detectors/TPC/calibration/include/TPCCalibration/CalibLaserTracks.h
index 15c9a8648a796..cecf3ed4b8dca 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CalibLaserTracks.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CalibLaserTracks.h
@@ -25,7 +25,6 @@
 #include <gsl/span>
 #include <string_view>
 
-#include "CommonConstants/MathConstants.h"
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTPC/LaserTrack.h"
@@ -74,10 +73,12 @@ class CalibLaserTracks
   ~CalibLaserTracks() = default;
 
   /// process all tracks of one TF
-  void fill(const gsl::span<const TrackTPC> tracks);
+  /// \param tp ratio of temperature over pressure
+  void fill(const gsl::span<const TrackTPC> tracks, float tp = 0);
 
   /// process all tracks of one TF
-  void fill(std::vector<TrackTPC> const& tracks);
+  /// \param tp ratio of temperature over pressure
+  void fill(std::vector<TrackTPC> const& tracks, float tp = 0);
 
   /// process single track
   void processTrack(const TrackTPC& track);
@@ -163,6 +164,8 @@ class CalibLaserTracks
   float mDriftV{0};                                            ///< drift velocity used during reconstruction
   float mTOffsetMUS{0};                                        ///< time offset in \mus to impose
   float mZbinWidth{0};                                         ///< width of a bin in us
+  float mAvgTP{0};                                             ///< ratio of average temperature over pressure
+  float mAvgDriftV{0};                                         ///< average drift velocity used for the laser track calibration
   uint64_t mTFstart{0};                                        ///< start time of processed time frames
   uint64_t mTFend{0};                                          ///< end time of processed time frames
   LtrCalibData mCalibDataTF{};                                 ///< calibration data for single TF (debugging)
@@ -184,7 +187,7 @@ class CalibLaserTracks
   /// perform fits on the matched z-position pairs to extract the drift velocity correction factor and trigger offset
   void fillCalibData(LtrCalibData& calibData, const std::vector<TimePair>& pairsA, const std::vector<TimePair>& pairsC);
 
-  ClassDefNV(CalibLaserTracks, 1);
+  ClassDefNV(CalibLaserTracks, 2);
 };
 
 } // namespace o2::tpc
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
index 671c2efb78a8f..8317fc6bc68d8 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/PressureTemperatureHelper.h
@@ -63,15 +63,35 @@ class PressureTemperatureHelper
   /// get pressure for given time stamp in ms
   float getPressure(const ULong64_t timestamp) const { return interpolate(mPressure.second, mPressure.first, timestamp); }
 
+  /// manually set the pressure
+  void setPressure(const std::pair<std::vector<float>, std::vector<ULong64_t>>& pressure) { mPressure = pressure; }
+
+  /// manually set the temperature
+  void setTemperature(const std::pair<std::vector<float>, std::vector<ULong64_t>>& temperatureA, const std::pair<std::vector<float>, std::vector<ULong64_t>>& temperatureC)
+  {
+    mTemperatureA = temperatureA;
+    mTemperatureC = temperatureC;
+  }
+
   /// get temperature for given time stamp in ms
   dataformats::Pair<float, float> getTemperature(const ULong64_t timestamp) const { return dataformats::Pair<float, float>{interpolate(mTemperatureA.second, mTemperatureA.first, timestamp), interpolate(mTemperatureC.second, mTemperatureC.first, timestamp)}; }
 
+  /// get mean temperature over A and C side
+  float getMeanTemperature(const ULong64_t timestamp) const;
+
+  // get ratio of temperature over pressure for given time stamp
+  float getTP(int64_t ts) const;
+
   static constexpr o2::header::DataDescription getDataDescriptionPressure() { return o2::header::DataDescription{"pressure"}; }
   static constexpr o2::header::DataDescription getDataDescriptionTemperature() { return o2::header::DataDescription{"temperature"}; }
 
+  /// get minimum and maximum time stamps of the pressure and temperature data
+  std::pair<ULong64_t, ULong64_t> getMinMaxTime() const;
+
  protected:
   static void addInput(std::vector<o2::framework::InputSpec>& inputs, o2::framework::InputSpec&& isp);
   static void addOutput(std::vector<o2::framework::OutputSpec>& outputs, o2::framework::OutputSpec&& osp);
+  static constexpr float toKelvin(float celsius) { return celsius + 273.15f; } // convert Celsius to Kelvin
 
   std::pair<std::vector<float>, std::vector<ULong64_t>> mPressure;     ///< pressure values for both measurements
   std::pair<std::vector<float>, std::vector<ULong64_t>> mTemperatureA; ///< temperature values A-side
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/TPCVDriftTglCalibration.h b/Detectors/TPC/calibration/include/TPCCalibration/TPCVDriftTglCalibration.h
index c4028f727983f..2b0aef8820acc 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/TPCVDriftTglCalibration.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/TPCVDriftTglCalibration.h
@@ -32,6 +32,7 @@ struct TPCVDTglContainer {
   double driftVFullMean = 0.;
   static float tOffsetRef;
   static float driftVRef;
+  float tp = 0;
 
   TPCVDTglContainer(int ntgl, float tglMax, int ndtgl, float dtglMax)
   {
@@ -42,9 +43,12 @@ struct TPCVDTglContainer {
   {
     histo = std::make_unique<o2::dataformats::FlatHisto2D_f>(*(src.histo.get()));
     entries = src.entries;
+    tp = src.tp;
+    driftVFullMean = src.driftVFullMean;
   }
 
-  void fill(const gsl::span<const o2::dataformats::Triplet<float, float, float>> data)
+  /// \param tp ratio of temperature over pressure
+  void fill(const gsl::span<const o2::dataformats::Triplet<float, float, float>> data, float currentTemperaturePressure = 0)
   {
     if (data.size() < 3) { // first 2 entres always contains the {full and reference VDrift} and {full and reference DriftTimeOffset} used for the TF
       return;
@@ -59,12 +63,14 @@ struct TPCVDTglContainer {
     }
     //
     float vfull = data[0].first, vref = data[0].second;
+    const float temperaturePressure = (data[0].third == 0) ? currentTemperaturePressure : data[0].third;
     if (driftVRef == 0.f) {
       driftVRef = vref;
     } else if (driftVRef != vref) {
       LOGP(warn, "data with VDriftRef={} were received while initially was set to {}, keep old one", vref, driftVRef);
     }
     driftVFullMean = (driftVFullMean * nTFProc + vfull) / (nTFProc + 1);
+    tp = (tp * nTFProc + temperaturePressure) / (nTFProc + 1);
     if (tOffsetRef == 0.f) {
       tOffsetRef = data[1].first; // assign 1st full toffset as a reference
     }
@@ -73,6 +79,11 @@ struct TPCVDTglContainer {
 
   void merge(const TPCVDTglContainer* other)
   {
+    const int norm = nTFProc + other->nTFProc;
+    if (norm > 0) {
+      tp = (tp * nTFProc + other->tp * other->nTFProc) / norm;
+      driftVFullMean = (driftVFullMean * nTFProc + other->driftVFullMean * other->nTFProc) / norm;
+    }
     entries += other->entries;
     histo->add(*(other->histo));
     LOGP(debug, "Old entries:{} New entries:{} oldSum: {} newSum: {}", other->entries, entries, other->histo->getSum(), histo->getSum());
@@ -82,7 +93,7 @@ struct TPCVDTglContainer {
   {
     LOG(info) << "Nentries = " << entries;
   }
-  ClassDefNV(TPCVDTglContainer, 1);
+  ClassDefNV(TPCVDTglContainer, 2);
 };
 
 class TPCVDriftTglCalibration : public o2::calibration::TimeSlotCalibration<TPCVDTglContainer>
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/VDriftHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/VDriftHelper.h
index a8af81fc65e8b..d600df201f985 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/VDriftHelper.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/VDriftHelper.h
@@ -18,6 +18,7 @@
 
 #include "GPUCommonRtypes.h"
 #include "DataFormatsTPC/VDriftCorrFact.h"
+#include "TPCCalibration/PressureTemperatureHelper.h"
 #include <array>
 #include <vector>
 #include <string_view>
@@ -56,6 +57,7 @@ class VDriftHelper
   Source getSource() const { return mSource; }
   static std::string_view getSourceName(Source s) { return SourceNames[s]; }
   std::string_view getSourceName() const { return SourceNames[mSource]; }
+  const auto& getPTHelper() const { return mPTHelper; }
 
   bool accountCCDBInputs(const o2::framework::ConcreteDataMatcher& matcher, void* obj);
   void extractCCDBInputs(o2::framework::ProcessingContext& pc, bool laser = true, bool itstpcTgl = true);
@@ -63,16 +65,20 @@ class VDriftHelper
 
  protected:
   static void addInput(std::vector<o2::framework::InputSpec>& inputs, o2::framework::InputSpec&& isp);
+  bool extractTPForVDrift(VDriftCorrFact& vdrift, int64_t tsStepMS = 100 * 1000);
   VDriftCorrFact mVDLaser{};
   VDriftCorrFact mVDTPCITSTgl{};
   VDriftCorrFact mVD{};
-  Source mSource{Source::Param}; // update source
-  bool mUpdated = false;  // signal update, must be reset once new value is fetched
+  Source mSource{Source::Param};       // update source
+  bool mUpdated = false;               // signal update, must be reset once new value is fetched
+  bool mIsTPScalingPossible = false;   // if T/P scaling is possible always perform the updating
   bool mForceParamDrift = false;       // enforce vdrift from gasParam
   bool mForceParamOffset = false;      // enforce offset from DetectorParam
+  bool mForceTPScaling = false;        // enforce T/P scaling from gasParam (scaling disabled by negative T or P)
   uint32_t mMayRenormSrc = 0xffffffff; // if starting VDrift correction != 1, we will renorm reference in such a way that initial correction is 1.0, flag per source
+  PressureTemperatureHelper mPTHelper; // helper to extract pressure and temperature from CCDB
 
-  ClassDefNV(VDriftHelper, 1);
+  ClassDefNV(VDriftHelper, 2);
 };
 } // namespace o2::tpc
 #endif
diff --git a/Detectors/TPC/calibration/src/CalibLaserTracks.cxx b/Detectors/TPC/calibration/src/CalibLaserTracks.cxx
index 1e4218c527f02..da52525328c6c 100644
--- a/Detectors/TPC/calibration/src/CalibLaserTracks.cxx
+++ b/Detectors/TPC/calibration/src/CalibLaserTracks.cxx
@@ -24,13 +24,13 @@
 #include <string_view>
 
 using namespace o2::tpc;
-void CalibLaserTracks::fill(std::vector<TrackTPC> const& tracks)
+void CalibLaserTracks::fill(std::vector<TrackTPC> const& tracks, float tp)
 {
-  fill(gsl::span(tracks.data(), tracks.size()));
+  fill(gsl::span(tracks.data(), tracks.size()), tp);
 }
 
 //______________________________________________________________________________
-void CalibLaserTracks::fill(const gsl::span<const TrackTPC> tracks)
+void CalibLaserTracks::fill(const gsl::span<const TrackTPC> tracks, float tp)
 {
   // ===| clean up TF data |===
   mZmatchPairsTFA.clear();
@@ -63,6 +63,9 @@ void CalibLaserTracks::fill(const gsl::span<const TrackTPC> tracks)
   mCalibDataTF.firstTime = mTFstart;
   mCalibDataTF.lastTime = tfEnd;
 
+  mAvgTP = (mAvgTP * mCalibData.processedTFs + tp) / (mCalibData.processedTFs + 1);
+  mAvgDriftV = (mAvgDriftV * mCalibData.processedTFs + mDriftV) / (mCalibData.processedTFs + 1);
+
   // ===| TF counters |===
   ++mCalibData.processedTFs;
   ++mCalibDataTF.processedTFs;
@@ -147,6 +150,8 @@ void CalibLaserTracks::processTrack(const TrackTPC& track)
                   << "ltr=" << ltr              // matched ideal laser track
                   << "trOutLtr=" << parOutAtLtr // track rotated and propagated to ideal track position
                   << "TPCTracks=" << writeTrack // original TPC track
+                  << "mDriftV=" << mDriftV
+                  << "laserTrackID=" << laserTrackID
                   << "\n";
   }
 }
@@ -277,6 +282,18 @@ void CalibLaserTracks::merge(const CalibLaserTracks* other)
   mCalibData.firstTime = std::min(mCalibData.firstTime, other->mCalibData.firstTime);
   mCalibData.lastTime = std::max(mCalibData.lastTime, other->mCalibData.lastTime);
 
+  if ((mAvgTP > 0) && (other->mAvgTP > 0)) {
+    mAvgTP = (mAvgTP + other->mAvgTP) / 2.0;
+  } else if (other->mAvgTP > 0) {
+    mAvgTP = other->mAvgTP;
+  }
+
+  if ((mAvgDriftV > 0) && (other->mAvgDriftV > 0)) {
+    mAvgDriftV = (mAvgDriftV + other->mAvgDriftV) / 2.0;
+  } else if (other->mAvgDriftV > 0) {
+    mAvgDriftV = other->mAvgDriftV;
+  }
+
   sort(mZmatchPairsA);
   sort(mZmatchPairsC);
 
@@ -296,6 +313,7 @@ void CalibLaserTracks::endTF()
                     << "zPairsA=" << mZmatchPairsTFA
                     << "zPairsC=" << mZmatchPairsTFC
                     << "calibData=" << mCalibDataTF
+                    << "mDriftV=" << mDriftV
                     << "\n";
   }
 }
@@ -330,7 +348,7 @@ void CalibLaserTracks::fillCalibData(LtrCalibData& calibData, const std::vector<
   auto dvA = fit(pairsA, "A-Side");
   auto dvC = fit(pairsC, "C-Side");
   calibData.creationTime = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
-  calibData.refVDrift = mDriftV;
+  calibData.refVDrift = mAvgDriftV;
   calibData.dvOffsetA = dvA.x1;
   calibData.dvCorrectionA = dvA.x2;
   calibData.nTracksA = uint16_t(pairsA.size());
@@ -340,6 +358,7 @@ void CalibLaserTracks::fillCalibData(LtrCalibData& calibData, const std::vector<
   calibData.nTracksC = uint16_t(pairsC.size());
 
   calibData.refTimeOffset = mTOffsetMUS;
+  calibData.tp = mAvgTP;
 }
 
 //______________________________________________________________________________
diff --git a/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx b/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
index d9a55e4aed2b9..2de4ee2086426 100644
--- a/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
+++ b/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
@@ -14,7 +14,7 @@
 /// \author Matthias Kleiner <mkleiner@ikf.uni-frankfurt.de>
 
 #include "TPCCalibration/PressureTemperatureHelper.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBase/CDBTypes.h"
 #include "Framework/ProcessingContext.h"
 #include "DataFormatsTPC/DCS.h"
 #include "Framework/InputRecord.h"
@@ -52,14 +52,25 @@ bool PressureTemperatureHelper::accountCCDBInputs(const ConcreteDataMatcher& mat
     mTemperatureC.second.clear();
 
     for (const auto& dp : temp.statsA.data) {
-      mTemperatureA.first.emplace_back(dp.value.mean);
+      mTemperatureA.first.emplace_back(toKelvin(dp.value.mean));
       mTemperatureA.second.emplace_back(dp.time);
     }
 
     for (const auto& dp : temp.statsC.data) {
-      mTemperatureC.first.emplace_back(dp.value.mean);
+      mTemperatureC.first.emplace_back(toKelvin(dp.value.mean));
       mTemperatureC.second.emplace_back(dp.time);
     }
+
+    // check if temperature data is available
+    if (mTemperatureA.first.empty() && mTemperatureC.first.empty()) {
+      float temperature = toKelvin(temp.getMeanTempRaw());
+      mTemperatureA.first.emplace_back(temperature);
+      mTemperatureA.second.emplace_back(0);
+      mTemperatureC.first.emplace_back(temperature);
+      mTemperatureC.second.emplace_back(0);
+      LOGP(warning, "No temperature data available from fit. Using average temperature {} K", temperature);
+    }
+
     return true;
   }
   return false;
@@ -117,3 +128,63 @@ void PressureTemperatureHelper::sendPTForTS(o2::framework::ProcessingContext& pc
   pc.outputs().snapshot(Output{o2::header::gDataOriginTPC, o2::tpc::PressureTemperatureHelper::getDataDescriptionTemperature()}, temp);
   pc.outputs().snapshot(Output{o2::header::gDataOriginTPC, o2::tpc::PressureTemperatureHelper::getDataDescriptionPressure()}, pressure);
 }
+
+float PressureTemperatureHelper::getTP(int64_t ts) const
+{
+  const float pressure = getPressure(ts);
+  const auto temp = getMeanTemperature(ts);
+  if (pressure <= 0) {
+    LOGP(error, "Pressure {} is zero or negative, cannot compute T/P ratio for timestamp {}", pressure, ts);
+    return 0;
+  }
+  const float tp = temp / pressure;
+  return tp;
+}
+
+float PressureTemperatureHelper::getMeanTemperature(const ULong64_t timestamp) const
+{
+  const auto temp = getTemperature(timestamp);
+
+  float sumT = 0;
+  int w = 0;
+  constexpr float minTemp = toKelvin(15);
+  constexpr float maxTemp = toKelvin(25);
+  if (auto t = temp.first; t > minTemp && t < maxTemp) {
+    sumT += t;
+    ++w;
+  }
+  if (auto t = temp.second; t > minTemp && t < maxTemp) {
+    sumT += t;
+    ++w;
+  }
+
+  if (w == 0) {
+    constexpr float defaultTemp = toKelvin(19.6440f);
+    LOGP(info, "Returning default temperature of {}K", defaultTemp);
+    return defaultTemp;
+  }
+
+  const float meanT = sumT / w;
+  return meanT;
+}
+
+std::pair<ULong64_t, ULong64_t> PressureTemperatureHelper::getMinMaxTime() const
+{
+  ULong64_t minTime = std::numeric_limits<ULong64_t>::max();
+  ULong64_t maxTime = 0;
+
+  if (!mPressure.first.empty()) {
+    minTime = std::min(minTime, mPressure.second.front());
+    maxTime = std::max(maxTime, mPressure.second.back());
+  }
+  if (!mTemperatureA.first.empty()) {
+    minTime = std::min(minTime, mTemperatureA.second.front());
+    maxTime = std::max(maxTime, mTemperatureA.second.back());
+  }
+  if (!mTemperatureC.first.empty()) {
+    minTime = std::min(minTime, mTemperatureC.second.front());
+    maxTime = std::max(maxTime, mTemperatureC.second.back());
+  }
+
+  return {minTime, maxTime};
+}
diff --git a/Detectors/TPC/calibration/src/TPCVDriftTglCalibration.cxx b/Detectors/TPC/calibration/src/TPCVDriftTglCalibration.cxx
index 61f0d816e1c11..316f4b25eff67 100644
--- a/Detectors/TPC/calibration/src/TPCVDriftTglCalibration.cxx
+++ b/Detectors/TPC/calibration/src/TPCVDriftTglCalibration.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 
 #include "TPCCalibration/TPCVDriftTglCalibration.h"
-#include "TPCBase/ParameterGas.h"
 #include "Framework/Logger.h"
 #include "MathUtils/fit.h"
 #include "CommonUtils/MemFileHelper.h"
@@ -91,7 +90,7 @@ void TPCVDriftTglCalibration::finalizeSlot(Slot& slot)
                                                                corrFact,
                                                                corrFactErr,
                                                                float(cont->driftVFullMean),
-                                                               cont->tOffsetRef, 0.f});
+                                                               cont->tOffsetRef, 0.f, cont->tp});
     // at this stage the correction object is defined wrt average corrected drift used for the slot processing, we want to redefine it to run-constant reference vdrift
     vd.normalize(cont->driftVRef);
 
diff --git a/Detectors/TPC/calibration/src/VDriftHelper.cxx b/Detectors/TPC/calibration/src/VDriftHelper.cxx
index fb262acc1afa1..2badf3bb510e8 100644
--- a/Detectors/TPC/calibration/src/VDriftHelper.cxx
+++ b/Detectors/TPC/calibration/src/VDriftHelper.cxx
@@ -20,6 +20,7 @@
 #include "Framework/CCDBParamSpec.h"
 #include "Framework/InputRecord.h"
 #include "Framework/ConcreteDataMatcher.h"
+#include "Framework/TimingInfo.h"
 
 using namespace o2::tpc;
 using namespace o2::framework;
@@ -43,10 +44,19 @@ VDriftHelper::VDriftHelper()
   if (o2::conf::ConfigurableParam::getProvenance("TPCDetParam.DriftTimeOffset") == o2::conf::ConfigurableParam::EParamProvenance::kRT) { // we stick to this value
     mVD.creationTime = std::numeric_limits<long>::max();
     mForceParamOffset = true;
-    LOGP(info, "TPC dridt time offset was set from command line to {} mus ({} TB), will neglect update from CCDB",
+    LOGP(info, "TPC drift time offset was set from command line to {} mus ({} TB), will neglect update from CCDB",
          mVD.refTimeOffset, detpar.DriftTimeOffset);
   }
 
+  // check if temperature and pressure is set from the command line
+  if ((o2::conf::ConfigurableParam::getProvenance("TPCGasParam.Temperature") == o2::conf::ConfigurableParam::EParamProvenance::kRT) && (o2::conf::ConfigurableParam::getProvenance("TPCGasParam.Pressure") == o2::conf::ConfigurableParam::EParamProvenance::kRT)) { // we stick to this value
+    mForceTPScaling = true;
+    LOGP(info, "VDriftHelper: Temperature and pressure were set from command line to {} C and {} mbar, will neglect updates from CCDB", gaspar.Temperature, gaspar.Pressure);
+    if (gaspar.Temperature <= 0 || gaspar.Pressure <= 0) {
+      LOGP(info, "VDriftHelper: Disabling VDrift scaling with T / P");
+    }
+  }
+
   mUpdated = true;
   mSource = Source::Param;
 }
@@ -74,11 +84,12 @@ void VDriftHelper::accountLaserCalibration(const LtrCalibData* calib, long fallB
     mVDLaser.corrFact = 1. / corr;
     mVDLaser.creationTime = calib->creationTime;
     mVDLaser.refTimeOffset = calib->refTimeOffset;
+    mVDLaser.refTP = calib->tp;
     mUpdated = true;
     mSource = Source::Laser;
     if (mMayRenormSrc & (0x1U << Source::Laser)) { // this was 1st setting?
       if (corr != 1.f) {                           // this may happen if old-style (non-normalized) standalone or non-normalized run-time laset calibration is used
-        LOGP(warn, "VDriftHelper: renorming initinal TPC refVDrift={}/correction={} to {}/1.0, source: {}", mVDLaser.refVDrift, mVDLaser.corrFact, mVDLaser.getVDrift(), getSourceName(mSource));
+        LOGP(warn, "VDriftHelper: renorming initial TPC refVDrift={}/correction={} to {}/1.0, source: {}", mVDLaser.refVDrift, mVDLaser.corrFact, mVDLaser.getVDrift(), getSourceName(mSource));
         mVDLaser.normalize(); // renorm reference to have correction = 1.
       }
       mMayRenormSrc &= ~(0x1U << Source::Laser); // unset MayRenorm
@@ -103,11 +114,11 @@ void VDriftHelper::accountDriftCorrectionITSTPCTgl(const VDriftCorrFact* calib)
   mSource = Source::ITSTPCTgl;
   if (mMayRenormSrc & (0x1U << Source::ITSTPCTgl)) {         // this was 1st setting?
     if (!mForceParamDrift && mVDTPCITSTgl.corrFact != 1.f) { // this may happen if calibration from prevous run is used
-      LOGP(warn, "VDriftHelper: renorming initinal TPC refVDrift={}/correction={} to {}/1.0, source: {}", mVDTPCITSTgl.refVDrift, mVDTPCITSTgl.corrFact, mVDTPCITSTgl.getVDrift(), getSourceName(mSource));
+      LOGP(warn, "VDriftHelper: renorming initial TPC refVDrift={}/correction={} to {}/1.0, source: {}", mVDTPCITSTgl.refVDrift, mVDTPCITSTgl.corrFact, mVDTPCITSTgl.getVDrift(), getSourceName(mSource));
       mVDTPCITSTgl.normalize(); // renorm reference to have correction = 1.
     }
     if (!mForceParamOffset && mVDTPCITSTgl.timeOffsetCorr != 0.) {
-      LOGP(warn, "VDriftHelper: renorming initinal TPC refTimeOffset={}/correction={} to {}/0.0, source: {}", mVDTPCITSTgl.refTimeOffset, mVDTPCITSTgl.timeOffsetCorr, mVDTPCITSTgl.getTimeOffset(), getSourceName());
+      LOGP(warn, "VDriftHelper: renorming initial TPC refTimeOffset={}/correction={} to {}/0.0, source: {}", mVDTPCITSTgl.refTimeOffset, mVDTPCITSTgl.timeOffsetCorr, mVDTPCITSTgl.getTimeOffset(), getSourceName());
       mVDTPCITSTgl.normalizeOffset();
     }
     mMayRenormSrc &= ~(0x1U << Source::ITSTPCTgl); // unset MayRenorm
@@ -135,9 +146,34 @@ void VDriftHelper::extractCCDBInputs(ProcessingContext& pc, bool laser, bool its
   if (itstpcTgl) {
     pc.inputs().get<o2::tpc::VDriftCorrFact*>("vdriftTgl");
   }
-  if (mUpdated) { // there was a change
+  mPTHelper.extractCCDBInputs(pc);
+
+  if (mUpdated || mIsTPScalingPossible) { // there was a change
     // prefer among laser and tgl VDrift the one with the latest update time
     auto saveVD = mVD;
+
+    // apply TP scaling of mVD if possible
+    if (float tp = mPTHelper.getTP(pc.services().get<o2::framework::TimingInfo>().creation); tp > 0) {
+      // try to extract refTP if needed
+      auto& vd = (mVDTPCITSTgl.creationTime < mVDLaser.creationTime) ? mVDLaser : mVDTPCITSTgl;
+      if (mForceTPScaling) {
+        const auto& gaspar = o2::tpc::ParameterGas::Instance();
+        tp = (gaspar.Temperature > 0 && gaspar.Pressure > 0) ? ((gaspar.Temperature + 273.15) / gaspar.Pressure) : -1;
+        mIsTPScalingPossible = (tp > 0) && (vd.refTP > 0 || extractTPForVDrift(vd));
+      } else {
+        mIsTPScalingPossible = (vd.refTP > 0) || extractTPForVDrift(vd);
+      }
+      if (mIsTPScalingPossible) {
+        mUpdated = true;
+        vd.normalize(0, tp);
+        if (vd.creationTime == saveVD.creationTime) {
+          LOGP(info, "VDriftHelper: Scaling VDrift from {} to {} with T/P from {} to {}", saveVD.getVDrift(), vd.getVDrift(), saveVD.refTP, vd.refTP);
+        } else {
+          LOGP(info, "VDriftHelper: Init new VDrift of {} with T/P {}", vd.getVDrift(), vd.refTP);
+        }
+      }
+    }
+
     mVD = mVDTPCITSTgl.creationTime < mVDLaser.creationTime ? mVDLaser : mVDTPCITSTgl;
     auto& loserVD = mVDTPCITSTgl.creationTime < mVDLaser.creationTime ? mVDTPCITSTgl : mVDLaser;
 
@@ -178,6 +214,8 @@ void VDriftHelper::requestCCDBInputs(std::vector<InputSpec>& inputs, bool laser,
     // VDrift calibration may change during the run (in opposite to Laser calibration, at least at the moment), so ask per-TF query
     addInput(inputs, {"vdriftTgl", "TPC", "VDriftTgl", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalVDriftTgl), {}, 1)});
   }
+  // adding pressure and temperature inputs
+  PressureTemperatureHelper::requestCCDBInputs(inputs);
 }
 
 //________________________________________________________
@@ -199,5 +237,42 @@ bool VDriftHelper::accountCCDBInputs(const ConcreteDataMatcher& matcher, void* o
     accountLaserCalibration(static_cast<LtrCalibData*>(obj));
     return true;
   }
-  return false;
+  return mPTHelper.accountCCDBInputs(matcher, obj);
+}
+
+bool VDriftHelper::extractTPForVDrift(VDriftCorrFact& vdrift, int64_t tsStepMS)
+{
+  const int64_t tsStart = vdrift.firstTime;
+  const int64_t tsEnd = vdrift.lastTime;
+
+  // make sanity check of the time range
+  const auto [minValidTime, maxValidTime] = mPTHelper.getMinMaxTime();
+  const int64_t minTimeAccepted = static_cast<int64_t>(minValidTime) - 20 * o2::ccdb::CcdbObjectInfo::MINUTE;
+  const int64_t maxTimeAccepted = static_cast<int64_t>(maxValidTime) + 20 * o2::ccdb::CcdbObjectInfo::MINUTE;
+
+  // check if the stored time stamp range is valid i.e. check if the range is in the vicinity of the current time
+  if ((minTimeAccepted > tsEnd) || (tsStart > maxTimeAccepted)) {
+    // check if creation time can be used
+    LOGP(warn, "VDriftHelper: Time range of VDrift object {} - {} is not valid for time range of T/P object {} - {}! Do not extract ref. T/P for VDrift!", tsStart, tsEnd, minValidTime, maxValidTime);
+    return false;
+  }
+
+  double meanTP = 0;
+  int countTP = 0;
+
+  for (int64_t ts = tsStart; ts < tsEnd; ts += tsStepMS) {
+    meanTP += mPTHelper.getTP(ts);
+    ++countTP;
+  }
+
+  if (countTP == 0) {
+    LOGP(error, "VDriftHelper: Could not get T/P for time range {} -> {}", tsStart, tsEnd);
+    return false;
+  }
+
+  meanTP /= countTP;
+
+  LOGP(info, "VDriftHelper: Setting mean T/P for VDrift to {} for time range {} -> {}", meanTP, tsStart, tsEnd);
+  vdrift.refTP = meanTP;
+  return true;
 }
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/CalibLaserTracksSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/CalibLaserTracksSpec.h
index 207bea0e7fa42..3ae33c7c2a5db 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/CalibLaserTracksSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/CalibLaserTracksSpec.h
@@ -64,6 +64,10 @@ class CalibLaserTracksDevice : public o2::framework::Task
       return;
     }
     mTPCVDriftHelper.extractCCDBInputs(pc);
+    const auto timestamp = pc.services().get<o2::framework::TimingInfo>().creation;
+
+    // if reference temperature / pressure of VDrift object is zero then it was not corrected
+    const float tp = (mTPCVDriftHelper.getVDriftObject().refTP == 0) ? mTPCVDriftHelper.getPTHelper().getTP(timestamp) : mTPCVDriftHelper.getVDriftObject().refTP;
     if (mTPCVDriftHelper.isUpdated()) {
       mTPCVDriftHelper.acknowledgeUpdate();
       mCalib.setVDriftRef(mTPCVDriftHelper.getVDriftObject().getVDrift());
@@ -75,7 +79,7 @@ class CalibLaserTracksDevice : public o2::framework::Task
 
     auto data = pc.inputs().get<gsl::span<TrackTPC>>("input");
     mCalib.setTFtimes(startTime, endTime);
-    mCalib.fill(data);
+    mCalib.fill(data, tp);
 
     if (!mOnlyPublishOnEOS && mCalib.hasEnoughData(mMinNumberTFs) && !mPublished) {
       sendOutput(pc.outputs());
diff --git a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
index a9f1e7d71da8e..5007019d52910 100644
--- a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
@@ -19,7 +19,6 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/ControlService.h"
-#include "DataFormatsTPC/WorkflowHelper.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "TPCBase/Mapper.h"
 #include "DetectorsBase/GRPGeomHelper.h"
@@ -31,7 +30,6 @@
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "MathUtils/Tsallis.h"
 #include "ReconstructionDataFormats/TrackTPCITS.h"
-#include "CommonDataFormat/AbstractRefAccessor.h"
 #include "ReconstructionDataFormats/PrimaryVertex.h"
 #include "ReconstructionDataFormats/VtxTrackIndex.h"
 #include "ReconstructionDataFormats/VtxTrackRef.h"
@@ -46,6 +44,7 @@
 #include "ReconstructionDataFormats/MatchInfoTOF.h"
 #include "DataFormatsTOF/Cluster.h"
 #include "DataFormatsFT0/RecPoints.h"
+#include "TPCCalibration/PressureTemperatureHelper.h"
 
 using namespace o2::globaltracking;
 using GTrackID = o2::dataformats::GlobalTrackID;
@@ -127,16 +126,20 @@ class TPCTimeSeries : public Task
   {
     o2::base::GRPGeomHelper::instance().checkUpdates(pc);
     mTPCVDriftHelper.extractCCDBInputs(pc);
+    mPTHelper.extractCCDBInputs(pc);
     if (mTPCVDriftHelper.isUpdated()) {
       mTPCVDriftHelper.acknowledgeUpdate();
       mVDrift = mTPCVDriftHelper.getVDriftObject().getVDrift();
       LOGP(info, "Updated reference drift velocity to: {}", mVDrift);
     }
+    mBufferDCA.mVDrift = mVDrift;
 
     const int nBins = getNBins();
 
     mTimeMS = o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS() + processing_helpers::getFirstTForbit(pc) * o2::constants::lhc::LHCOrbitMUS / 1000;
     mRun = processing_helpers::getRunNumber(pc);
+    mBufferDCA.mTemperature = mPTHelper.getMeanTemperature(mTimeMS);
+    mBufferDCA.mPressure = mPTHelper.getPressure(mTimeMS);
 
     // init only once
     if (mAvgADCAr.size() != nBins) {
@@ -870,6 +873,7 @@ class TPCTimeSeries : public Task
   void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
   {
     mTPCVDriftHelper.accountCCDBInputs(matcher, obj);
+    mPTHelper.accountCCDBInputs(matcher, obj);
     o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
   }
 
@@ -1107,6 +1111,7 @@ class TPCTimeSeries : public Task
   long mTimeMS{};                                                          ///< time in MS of current TF
   int mRun{};                                                              ///< run number
   int mMaxOccupancyHistBins{912};                                          ///< maximum number of occupancy bins
+  PressureTemperatureHelper mPTHelper;                                     ///< helper to extract pressure and temperature from CCDB
 
   /// check if track passes coarse cuts
   bool acceptTrack(const TrackTPC& track) const { return std::abs(track.getTgl()) < mMaxTgl; }
@@ -1823,12 +1828,11 @@ o2::framework::DataProcessorSpec getTPCTimeSeriesSpec(const bool disableWriter,
   dataRequest->requestTracks(srcTracks, useMC);
   dataRequest->requestClusters(GTrackID::getSourcesMask("TPC"), useMC);
 
-  dataRequest->requestFT0RecPoints(false);
-
   bool tpcOnly = srcTracks == GTrackID::getSourcesMask("TPC");
   if (!tpcOnly) {
-    dataRequest->requestPrimaryVertices(useMC);
+    dataRequest->requestFT0RecPoints(useMC);
   }
+  dataRequest->requestPrimaryVertices(useMC);
 
   const bool enableAskMatLUT = matType == o2::base::Propagator::MatCorrType::USEMatCorrLUT;
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(!disableWriter,                 // orbitResetTime
@@ -1842,6 +1846,7 @@ o2::framework::DataProcessorSpec getTPCTimeSeriesSpec(const bool disableWriter,
                                                                 true);
 
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
+  PressureTemperatureHelper::requestCCDBInputs(dataRequest->inputs);
   std::vector<OutputSpec> outputs;
   outputs.emplace_back(o2::header::gDataOriginTPC, getDataDescriptionTimeSeries(), 0, Lifetime::Sporadic);
   if (!disableWriter) {
diff --git a/Detectors/TPC/workflow/src/TPCVDriftTglCalibSpec.cxx b/Detectors/TPC/workflow/src/TPCVDriftTglCalibSpec.cxx
index 957ed07078cfe..8456fa3fa4740 100644
--- a/Detectors/TPC/workflow/src/TPCVDriftTglCalibSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCVDriftTglCalibSpec.cxx
@@ -20,6 +20,7 @@
 #include "CCDB/CcdbApi.h"
 #include "CCDB/CcdbObjectInfo.h"
 #include "Framework/Task.h"
+#include "TPCCalibration/PressureTemperatureHelper.h"
 
 using namespace o2::framework;
 
@@ -52,12 +53,24 @@ class TPCVDriftTglCalibSpec : public Task
       return;
     }
     o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+    mPTHelper.extractCCDBInputs(pc);
     auto data = pc.inputs().get<gsl::span<o2::dataformats::Triplet<float, float, float>>>("input");
     o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
     if (data.size()) {
       LOG(detail) << "Processing TF " << mCalibrator->getCurrentTFInfo().tfCounter << " with " << data.size() - 2 << " tracks"; // 1st entry is for VDrift, 2nd for the offset
     }
-    mCalibrator->process(data);
+
+    // if no T/P scaling of the VDrift was performed get the current T/P
+    float tp = 0;
+    if (!data.empty()) {
+      // third value of first entry is the T/P ratio, if it is 0, we use the current T/P
+      if (data[0].third == 0) {
+        const auto timestamp = pc.services().get<o2::framework::TimingInfo>().creation;
+        tp = mPTHelper.getTP(timestamp);
+      }
+    }
+
+    mCalibrator->process(data, tp);
     if (pc.transitionState() == TransitionHandlingState::Requested) {
       LOG(info) << "Run stop requested, finalizing";
       mRunStopRequested = true;
@@ -80,13 +93,15 @@ class TPCVDriftTglCalibSpec : public Task
   void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
   {
     o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
+    mPTHelper.accountCCDBInputs(matcher, obj);
   }
 
  private:
   void sendOutput(DataAllocator& output);
   std::unique_ptr<o2::tpc::TPCVDriftTglCalibration> mCalibrator;
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
-  bool mRunStopRequested = false; // flag that run was stopped (ant the last output is sent)
+  PressureTemperatureHelper mPTHelper; // helper to extract pressure and temperature from CCDB
+  bool mRunStopRequested = false;      // flag that run was stopped (ant the last output is sent)
 };
 
 //_____________________________________________________________
@@ -134,6 +149,8 @@ DataProcessorSpec getTPCVDriftTglCalibSpec(int ntgl, float tglMax, int ndtgl, fl
   outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "TPCVDTGL"}, Lifetime::Sporadic);
   slot0frac = 1. - slot0frac;
 
+  PressureTemperatureHelper::requestCCDBInputs(inputs);
+
   return DataProcessorSpec{
     "tpc-vd-tgl-calib",
     inputs,

From 06c1b84595010602d08aac715e54cc7bec5f2a47 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sawenzel@gmail.com>
Date: Thu, 21 Aug 2025 23:48:29 +0200
Subject: [PATCH 0726/1764] Enable ROOT file output in TPC chunked-digit merger
 (#14608)

We can now regenerate a TPC digit file using the TPC chunked-digit merger.
This is useful when we have the TPC "drift-time" digits (as in O2DPG) and want
to obtain the full timeframe of TPC digits in ROOT file tpcdigits.root.

There is a new special mode for this and the command line to use is
```
${O2_ROOT}/bin/o2-tpc-chunkeddigit-merger --writer-mode --tpc-lanes 8
```
for the case in which we had 8 separate lanes of drift-time digits.

This commit includes:
* small modularity and library refactoring
* do not fatal in the TPCDigitRootWriter if no triggers are sent
* merging/treatment of the TPC common modes in the merger (so far not done)

Co-author: @ChSonnabend.
---
 Detectors/TPC/CMakeLists.txt                  |  1 +
 Detectors/TPC/simworkflow/CMakeLists.txt      | 28 +++++++
 .../TPCSimWorkflow}/TPCDigitRootWriterSpec.h  |  0
 .../src/ChunkedDigitPublisher.cxx             | 84 +++++++++++++++++--
 .../src/TPCDigitRootWriterSpec.cxx            | 16 ++--
 Detectors/TPC/workflow/CMakeLists.txt         | 11 ---
 Detectors/TPC/workflow/readers/CMakeLists.txt |  6 --
 Steer/DigitizerWorkflow/CMakeLists.txt        |  2 +-
 .../src/SimpleDigitizerWorkflow.cxx           |  2 +-
 9 files changed, 117 insertions(+), 33 deletions(-)
 create mode 100644 Detectors/TPC/simworkflow/CMakeLists.txt
 rename {Steer/DigitizerWorkflow/src => Detectors/TPC/simworkflow/include/TPCSimWorkflow}/TPCDigitRootWriterSpec.h (100%)
 rename Detectors/TPC/{workflow => simworkflow}/src/ChunkedDigitPublisher.cxx (75%)
 rename {Steer/DigitizerWorkflow => Detectors/TPC/simworkflow}/src/TPCDigitRootWriterSpec.cxx (95%)

diff --git a/Detectors/TPC/CMakeLists.txt b/Detectors/TPC/CMakeLists.txt
index b602e61e49fe2..e3de1ca57c1be 100644
--- a/Detectors/TPC/CMakeLists.txt
+++ b/Detectors/TPC/CMakeLists.txt
@@ -13,6 +13,7 @@ add_subdirectory(base)
 add_subdirectory(reconstruction)
 add_subdirectory(calibration)
 add_subdirectory(simulation)
+add_subdirectory(simworkflow)
 add_subdirectory(monitor)
 add_subdirectory(workflow)
 add_subdirectory(qc)
diff --git a/Detectors/TPC/simworkflow/CMakeLists.txt b/Detectors/TPC/simworkflow/CMakeLists.txt
new file mode 100644
index 0000000000000..e442d45fab63f
--- /dev/null
+++ b/Detectors/TPC/simworkflow/CMakeLists.txt
@@ -0,0 +1,28 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(TPCSimWorkflow
+               SOURCES
+                       src/ChunkedDigitPublisher.cxx
+                       src/TPCDigitRootWriterSpec.cxx
+               PUBLIC_LINK_LIBRARIES O2::TPCSimulation O2::Framework)
+
+o2_add_executable(chunkeddigit-merger
+        COMPONENT_NAME tpc
+        TARGETVARNAME mergertargetName
+        SOURCES src/ChunkedDigitPublisher.cxx
+        PUBLIC_LINK_LIBRARIES O2::TPCSimWorkflow)
+
+if(OpenMP_CXX_FOUND)
+   # Must be private, depending libraries might be compiled by compiler not understanding -fopenmp
+   target_compile_definitions(${mergertargetName} PRIVATE WITH_OPENMP)
+   target_link_libraries(${mergertargetName} PRIVATE OpenMP::OpenMP_CXX)
+endif()
diff --git a/Steer/DigitizerWorkflow/src/TPCDigitRootWriterSpec.h b/Detectors/TPC/simworkflow/include/TPCSimWorkflow/TPCDigitRootWriterSpec.h
similarity index 100%
rename from Steer/DigitizerWorkflow/src/TPCDigitRootWriterSpec.h
rename to Detectors/TPC/simworkflow/include/TPCSimWorkflow/TPCDigitRootWriterSpec.h
diff --git a/Detectors/TPC/workflow/src/ChunkedDigitPublisher.cxx b/Detectors/TPC/simworkflow/src/ChunkedDigitPublisher.cxx
similarity index 75%
rename from Detectors/TPC/workflow/src/ChunkedDigitPublisher.cxx
rename to Detectors/TPC/simworkflow/src/ChunkedDigitPublisher.cxx
index adf0cba944c03..bdc2f358a4169 100644
--- a/Detectors/TPC/workflow/src/ChunkedDigitPublisher.cxx
+++ b/Detectors/TPC/simworkflow/src/ChunkedDigitPublisher.cxx
@@ -19,6 +19,7 @@
 #include "Framework/DataAllocator.h"
 #include "Framework/ControlService.h"
 #include "DataFormatsTPC/Digit.h"
+#include "TPCSimWorkflow/TPCDigitRootWriterSpec.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "TPCSimulation/CommonMode.h"
@@ -46,6 +47,9 @@
 #include <omp.h>
 #endif
 #include <TStopwatch.h>
+#include "CommonDataFormat/RangeReference.h"
+
+using DigiGroupRef = o2::dataformats::RangeReference<int, int>;
 
 using SubSpecificationType = o2::framework::DataAllocator::SubSpecificationType;
 
@@ -71,6 +75,9 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   workflowOptions.push_back(
     ConfigParamSpec{"tpc-sectors", VariantType::String, sectorDefault.c_str(), {sectorshelp}});
 
+  // option to write merged data to file
+  workflowOptions.push_back(ConfigParamSpec{"writer-mode", o2::framework::VariantType::Bool, false, {"enable ROOT file output"}});
+
   // option to disable MC truth
   workflowOptions.push_back(ConfigParamSpec{"disable-mc", o2::framework::VariantType::Bool, false, {"disable  mc-truth"}});
   workflowOptions.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}});
@@ -104,14 +111,30 @@ void copyHelper<MCTruthContainer>(MCTruthContainer const& origin, MCTruthContain
   target.mergeAtBack(origin);
 }
 
+// a trait to map TPC data types to a DPL channel name
+template <typename T>
+struct OutputChannelName;
+template <>
+struct OutputChannelName<std::vector<o2::tpc::Digit>> {
+  static constexpr char value[] = "DIGITS";
+};
+template <>
+struct OutputChannelName<std::vector<o2::tpc::CommonMode>> {
+  static constexpr char value[] = "COMMONMODE";
+};
+template <>
+struct OutputChannelName<std::vector<DigiGroupRef>> {
+  static constexpr char value[] = "DIGTRIGGERS";
+};
+
 template <typename T>
 auto makePublishBuffer(framework::ProcessingContext& pc, int sector, uint64_t activeSectors)
 {
-  LOG(info) << "PUBLISHING SECTOR " << sector;
+  LOG(info) << "PUBLISHING SECTOR " << sector << " FOR CHANNEL " << OutputChannelName<T>::value;
 
   o2::tpc::TPCSectorHeader header{sector};
   header.activeSectors = activeSectors;
-  return &pc.outputs().make<T>(Output{"TPC", "DIGITS", static_cast<SubSpecificationType>(sector), header});
+  return &pc.outputs().make<T>(Output{"TPC", OutputChannelName<T>::value, static_cast<SubSpecificationType>(sector), header});
 }
 
 template <>
@@ -187,6 +210,30 @@ void mergeHelper(const char* brprefix, std::vector<int> const& tpcsectors, uint6
   }
 }
 
+template <>
+void mergeHelper<std::vector<DigiGroupRef>>(const char* brprefix, std::vector<int> const& tpcsectors, uint64_t activeSectors,
+                                            TFile& originfile, framework::ProcessingContext& pc)
+{
+  // specialization for TPC Trigger
+  auto keyslist = originfile.GetListOfKeys();
+  for (int i = 0; i < keyslist->GetEntries(); ++i) {
+    auto key = keyslist->At(i);
+    int sector = atoi(key->GetName());
+    if (std::find(tpcsectors.begin(), tpcsectors.end(), sector) == tpcsectors.end()) {
+      // do nothing if sector not wanted
+      continue;
+    }
+
+    using AccumType = std::decay_t<decltype(makePublishBuffer<std::vector<DigiGroupRef>>(pc, sector, activeSectors))>;
+    AccumType accum;
+#pragma omp critical
+    accum = makePublishBuffer<std::vector<DigiGroupRef>>(pc, sector, activeSectors);
+    // no actual data sent. Continuous mode.
+
+    publishBuffer(pc, sector, activeSectors, accum);
+  }
+}
+
 void publishMergedTimeframes(std::vector<int> const& lanes, std::vector<int> const& tpcsectors, bool domctruth, framework::ProcessingContext& pc)
 {
   uint64_t activeSectors = 0;
@@ -208,13 +255,21 @@ void publishMergedTimeframes(std::vector<int> const& lanes, std::vector<int> con
     auto originfile = new TFile(filename.c_str(), "OPEN");
     assert(originfile);
 
-    //data definitions
+    // data definitions
     using DigitsType = std::vector<o2::tpc::Digit>;
     using LabelType = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
     mergeHelper<DigitsType>("TPCDigit_", tpcsectors, activeSectors, *originfile, pc);
     if (domctruth) {
       mergeHelper<LabelType>("TPCDigitMCTruth_", tpcsectors, activeSectors, *originfile, pc);
     }
+
+    // we also merge common modes and publish a (fake) trigger entry
+    using CommonModeType = std::vector<o2::tpc::CommonMode>;
+    mergeHelper<CommonModeType>("TPCCommonMode_", tpcsectors, activeSectors, *originfile, pc);
+
+    using TriggerType = std::vector<DigiGroupRef>;
+    mergeHelper<TriggerType>("TPCCommonMode_", tpcsectors, activeSectors, *originfile, pc);
+
     originfile->Close();
     delete originfile;
   }
@@ -257,7 +312,7 @@ class Task
 /// MC truth information is also aggregated and written out
 DataProcessorSpec getSpec(std::vector<int> const& laneConfiguration, std::vector<int> const& tpcsectors, bool mctruth, bool publish = true)
 {
-  //data definitions
+  // data definitions
   using DigitsOutputType = std::vector<o2::tpc::Digit>;
   using CommonModeOutputType = std::vector<o2::tpc::CommonMode>;
 
@@ -266,10 +321,14 @@ DataProcessorSpec getSpec(std::vector<int> const& laneConfiguration, std::vector
     // effectively the input expects one sector per subspecification
     for (int s = 0; s < 36; ++s) {
       OutputLabel binding{std::to_string(s)};
-      outputs.emplace_back(/*binding,*/ "TPC", "DIGITS", static_cast<SubSpecificationType>(s), Lifetime::Timeframe);
+      outputs.emplace_back("TPC", "DIGITS", static_cast<SubSpecificationType>(s), Lifetime::Timeframe);
       if (mctruth) {
-        outputs.emplace_back(/*binding,*/ "TPC", "DIGITSMCTR", static_cast<SubSpecificationType>(s), Lifetime::Timeframe);
+        outputs.emplace_back("TPC", "DIGITSMCTR", static_cast<SubSpecificationType>(s), Lifetime::Timeframe);
       }
+      // common mode
+      outputs.emplace_back("TPC", "COMMONMODE", static_cast<SubSpecificationType>(s), Lifetime::Timeframe);
+      // trigger records
+      outputs.emplace_back("TPC", "DIGTRIGGERS", static_cast<SubSpecificationType>(s), Lifetime::Timeframe);
     }
   }
 
@@ -287,12 +346,25 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   auto numlanes = configcontext.options().get<int>("tpc-lanes");
   bool mctruth = !configcontext.options().get<bool>("disable-mc");
+  bool writeout = configcontext.options().get<bool>("writer-mode");
   auto tpcsectors = o2::RangeTokenizer::tokenize<int>(configcontext.options().get<std::string>("tpc-sectors"));
 
   std::vector<int> lanes(numlanes);
   std::iota(lanes.begin(), lanes.end(), 0);
   specs.emplace_back(o2::tpc::getSpec(lanes, tpcsectors, mctruth));
 
+  if (writeout) {
+    // for now writeout to a ROOT file only works if all sectors
+    // are included
+    if (tpcsectors.size() != 36) {
+      LOG(error) << "You currently need to include all TPC sectors in the ROOT writer-mode";
+    } else {
+      std::vector<int> writerlanes(tpcsectors.size());
+      std::iota(writerlanes.begin(), writerlanes.end(), 0);
+      specs.emplace_back(o2::tpc::getTPCDigitRootWriterSpec(writerlanes, mctruth));
+    }
+  }
+
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
   return specs;
diff --git a/Steer/DigitizerWorkflow/src/TPCDigitRootWriterSpec.cxx b/Detectors/TPC/simworkflow/src/TPCDigitRootWriterSpec.cxx
similarity index 95%
rename from Steer/DigitizerWorkflow/src/TPCDigitRootWriterSpec.cxx
rename to Detectors/TPC/simworkflow/src/TPCDigitRootWriterSpec.cxx
index 9bc9b9ba45e71..a907a73281884 100644
--- a/Steer/DigitizerWorkflow/src/TPCDigitRootWriterSpec.cxx
+++ b/Detectors/TPC/simworkflow/src/TPCDigitRootWriterSpec.cxx
@@ -14,7 +14,7 @@
 /// @since  2018-04-19
 /// @brief  Processor spec for a ROOT file writer for TPC digits
 
-#include "TPCDigitRootWriterSpec.h"
+#include "TPCSimWorkflow/TPCDigitRootWriterSpec.h"
 #include "DataFormatsTPC/TPCSectorHeader.h"
 #include "CommonDataFormat/RangeReference.h"
 #include "Framework/InputRecord.h"
@@ -77,7 +77,7 @@ DataProcessorSpec getTPCDigitRootWriterSpec(std::vector<int> const& laneConfigur
     }
   };
 
-  //branch definitions for RootTreeWriter spec
+  // branch definitions for RootTreeWriter spec
   using DigitsOutputType = std::vector<o2::tpc::Digit>;
   using CommonModeOutputType = std::vector<o2::tpc::CommonMode>;
 
@@ -156,8 +156,8 @@ DataProcessorSpec getTPCDigitRootWriterSpec(std::vector<int> const& laneConfigur
       LOG(info) << "DIGIT SIZE " << digiData.size();
       const auto& trigS = (*trigP2Sect.get())[sector];
       int entries = 0;
-      if (!trigS.size()) {
-        std::runtime_error("Digits for sector " + std::to_string(sector) + " are received w/o info on grouping in triggers");
+      if (trigS.size() == 0) {
+        LOG(warn) << "Digits for sector " + std::to_string(sector) + " are received w/o trigger info. Will assume continuous mode";
       } else { // check consistency of Ndigits with that of expected from the trigger
         int nExp = trigS.back().getFirstEntry() + trigS.back().getEntries() - trigS.front().getFirstEntry();
         if (nExp != digiData.size()) {
@@ -167,7 +167,7 @@ DataProcessorSpec getTPCDigitRootWriterSpec(std::vector<int> const& laneConfigur
       }
 
       {
-        if (trigS.size() == 1) { // just 1 entry (continous mode?), use digits directly
+        if (trigS.size() <= 1) { // just 1 entry (continous mode?), use digits directly
           auto ptr = &digiData;
           branch.SetAddress(&ptr);
           branch.Fill();
@@ -214,8 +214,8 @@ DataProcessorSpec getTPCDigitRootWriterSpec(std::vector<int> const& laneConfigur
       LOG(info) << "MCTRUTH ELEMENTS " << labeldata.getIndexedSize()
                 << " WITH " << labeldata.getNElements() << " LABELS";
       const auto& trigS = (*trigP2Sect.get())[sector];
-      if (!trigS.size()) {
-        throw std::runtime_error("MCTruth for sector " + std::to_string(sector) + " are received w/o info on grouping in triggers");
+      if (trigS.size() == 0) {
+        LOG(warn) << "MCTruth for sector " + std::to_string(sector) + " received w/o trigger info. Will assume continuous mode";
       } else {
         int nExp = trigS.back().getFirstEntry() + trigS.back().getEntries() - trigS.front().getFirstEntry();
         if (nExp != labeldata.getIndexedSize()) {
@@ -225,7 +225,7 @@ DataProcessorSpec getTPCDigitRootWriterSpec(std::vector<int> const& laneConfigur
         }
       }
       {
-        if (trigS.size() == 1) { // just 1 entry (continous mode?), use labels directly
+        if (trigS.size() <= 1) { // just 0 or 1 entry (continous mode?), use labels directly
           outputcontainer.adopt(labelbuffer);
           br->Fill();
           br->ResetAddress();
diff --git a/Detectors/TPC/workflow/CMakeLists.txt b/Detectors/TPC/workflow/CMakeLists.txt
index fe7c9175968b5..48ebb54ac4070 100644
--- a/Detectors/TPC/workflow/CMakeLists.txt
+++ b/Detectors/TPC/workflow/CMakeLists.txt
@@ -70,17 +70,6 @@ o2_add_library(TPCWorkflowStudies
                                      O2::GlobalTrackingWorkflow
            )
 
-o2_add_executable(chunkeddigit-merger
-        COMPONENT_NAME tpc
-        TARGETVARNAME mergertargetName
-        SOURCES src/ChunkedDigitPublisher.cxx
-        PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
-
-if(OpenMP_CXX_FOUND)
-  # Must be private, depending libraries might be compiled by compiler not understanding -fopenmp
-  target_compile_definitions(${mergertargetName} PRIVATE WITH_OPENMP)
-  target_link_libraries(${mergertargetName} PRIVATE OpenMP::OpenMP_CXX)
-endif()
 
 
 o2_add_executable(reco-workflow
diff --git a/Detectors/TPC/workflow/readers/CMakeLists.txt b/Detectors/TPC/workflow/readers/CMakeLists.txt
index 80e967c287404..28d101caf188c 100644
--- a/Detectors/TPC/workflow/readers/CMakeLists.txt
+++ b/Detectors/TPC/workflow/readers/CMakeLists.txt
@@ -21,9 +21,3 @@ o2_add_library(TPCReaderWorkflow
                                      O2::DPLUtils
                                      O2::TPCBase
            )
-
-if(OpenMP_CXX_FOUND)
-  # Must be private, depending libraries might be compiled by compiler not understanding -fopenmp
-  target_compile_definitions(${mergertargetName} PRIVATE WITH_OPENMP)
-  target_link_libraries(${mergertargetName} PRIVATE OpenMP::OpenMP_CXX)
-endif()
diff --git a/Steer/DigitizerWorkflow/CMakeLists.txt b/Steer/DigitizerWorkflow/CMakeLists.txt
index babc5fce4d864..6b31550c83636 100644
--- a/Steer/DigitizerWorkflow/CMakeLists.txt
+++ b/Steer/DigitizerWorkflow/CMakeLists.txt
@@ -24,7 +24,6 @@ o2_add_executable(digitizer-workflow
                           src/CPVDigitizerSpec.cxx
                           src/SimReaderSpec.cxx
                           src/SimpleDigitizerWorkflow.cxx
-                          src/TPCDigitRootWriterSpec.cxx
                           src/TPCDigitizerSpec.cxx
                           src/ZDCDigitizerSpec.cxx
                           src/TOFDigitizerSpec.cxx
@@ -59,6 +58,7 @@ o2_add_executable(digitizer-workflow
                                         O2::TOFReconstruction
                                         O2::TOFWorkflowIO
                                         O2::TPCSimulation
+                                        O2::TPCSimWorkflow
                                         O2::TRDSimulation
                                         O2::TRDWorkflow
                                         O2::TRDWorkflowIO
diff --git a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
index e86ee47550f13..ea5c6ba272ec6 100644
--- a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
+++ b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
@@ -30,7 +30,7 @@
 
 // for TPC
 #include "TPCDigitizerSpec.h"
-#include "TPCDigitRootWriterSpec.h"
+#include "TPCSimWorkflow/TPCDigitRootWriterSpec.h"
 #include "TPCBase/Sector.h"
 #include "TPCBase/CDBInterface.h"
 // needed in order to init the **SHARED** polyadist file (to be done before the digitizers initialize)

From df10dd3ccdfc6912472fcb15c4ccd5e8b6a96ee0 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 21 Aug 2025 23:50:10 +0200
Subject: [PATCH 0727/1764] DPL Analysis: rework cursor logic keeping the
 `gsl::span` for VLAs (#14607)

---
 Framework/Core/include/Framework/ASoA.h       | 62 +++++++++----------
 .../Core/include/Framework/AnalysisHelpers.h  | 14 +++--
 .../Framework/ArrowTableSlicingCache.h        |  4 +-
 .../Core/include/Framework/GroupSlicer.h      |  6 +-
 .../Core/include/Framework/TableBuilder.h     | 24 +++----
 Framework/Core/src/ASoA.cxx                   |  4 +-
 Framework/Core/src/ArrowTableSlicingCache.cxx |  2 +-
 7 files changed, 59 insertions(+), 57 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 6a49ed25e40d2..3aab089fde00c 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -561,21 +561,21 @@ class ColumnIterator : ChunkingPolicy
     mLast = mCurrent + array->length() + (mFirstIndex >> SCALE_FACTOR);
   }
 
-  decltype(auto) operator*() const
+  auto operator*() const
     requires std::same_as<bool, std::decay_t<T>>
   {
     checkSkipChunk();
     return (*(mCurrent - (mOffset >> SCALE_FACTOR) + ((*mCurrentPos + mOffset) >> SCALE_FACTOR)) & (1 << ((*mCurrentPos + mOffset) & 0x7))) != 0;
   }
 
-  decltype(auto) operator*() const
+  auto operator*() const
     requires((!std::same_as<bool, std::decay_t<T>>) && std::same_as<arrow_array_for_t<T>, arrow::ListArray>)
   {
     checkSkipChunk();
     auto list = std::static_pointer_cast<arrow::ListArray>(mColumn->chunk(mCurrentChunk));
     auto offset = list->value_offset(*mCurrentPos - mFirstIndex);
     auto length = list->value_length(*mCurrentPos - mFirstIndex);
-    return gsl::span{mCurrent + mFirstIndex + offset, mCurrent + mFirstIndex + (offset + length)};
+    return gsl::span<unwrap_t<T> const>{mCurrent + mFirstIndex + offset, mCurrent + mFirstIndex + (offset + length)};
   }
 
   decltype(auto) operator*() const
@@ -851,7 +851,7 @@ struct FilteredIndexPolicy : IndexPolicyBase {
   // which happens below which will properly setup the first index
   // by remapping the filtered index 0 to whatever unfiltered index
   // it belongs to.
-  FilteredIndexPolicy(gsl::span<int64_t const> selection, int64_t rows, uint64_t offset = 0)
+  FilteredIndexPolicy(std::span<int64_t const> selection, int64_t rows, uint64_t offset = 0)
     : IndexPolicyBase{-1, offset},
       mSelectedRows(selection),
       mMaxSelection(selection.size()),
@@ -860,7 +860,7 @@ struct FilteredIndexPolicy : IndexPolicyBase {
     this->setCursor(0);
   }
 
-  void resetSelection(gsl::span<int64_t const> selection)
+  void resetSelection(std::span<int64_t const> selection)
   {
     mSelectedRows = selection;
     mMaxSelection = selection.size();
@@ -944,7 +944,7 @@ struct FilteredIndexPolicy : IndexPolicyBase {
   {
     this->mRowIndex = O2_BUILTIN_LIKELY(mSelectionRow < mMaxSelection) ? mSelectedRows[mSelectionRow] : -1;
   }
-  gsl::span<int64_t const> mSelectedRows;
+  std::span<int64_t const> mSelectedRows;
   int64_t mSelectionRow = 0;
   int64_t mMaxSelection = 0;
   int64_t nRows = 0;
@@ -1428,7 +1428,7 @@ struct PreslicePolicyGeneral : public PreslicePolicyBase {
   void updateSliceInfo(SliceInfoUnsortedPtr&& si);
 
   SliceInfoUnsortedPtr sliceInfo;
-  gsl::span<const int64_t> getSliceFor(int value) const;
+  std::span<const int64_t> getSliceFor(int value) const;
 };
 
 template <typename T, typename Policy, bool OPT = false>
@@ -1453,7 +1453,7 @@ struct PresliceBase : public Policy {
     return Policy::getSliceFor(value, input, offset);
   }
 
-  gsl::span<const int64_t> getSliceFor(int value) const
+  std::span<const int64_t> getSliceFor(int value) const
   {
     if constexpr (OPT) {
       if (Policy::isMissing()) {
@@ -1549,7 +1549,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
 }
 
 template <soa::is_filtered_table T>
-auto doSliceByHelper(T const* table, gsl::span<const int64_t> const& selection)
+auto doSliceByHelper(T const* table, std::span<const int64_t> const& selection)
 {
   auto t = soa::Filtered<typename T::base_t>({table->asArrowTable()}, selection);
   table->copyIndexBindings(t);
@@ -1560,7 +1560,7 @@ auto doSliceByHelper(T const* table, gsl::span<const int64_t> const& selection)
 
 template <soa::is_table T>
   requires(!soa::is_filtered_table<T>)
-auto doSliceByHelper(T const* table, gsl::span<const int64_t> const& selection)
+auto doSliceByHelper(T const* table, std::span<const int64_t> const& selection)
 {
   auto t = soa::Filtered<T>({table->asArrowTable()}, selection);
   table->copyIndexBindings(t);
@@ -1581,7 +1581,7 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
   return doSliceByHelper(table, selection);
 }
 
-SelectionVector sliceSelection(gsl::span<int64_t const> const& mSelectedRows, int64_t nrows, uint64_t offset);
+SelectionVector sliceSelection(std::span<int64_t const> const& mSelectedRows, int64_t nrows, uint64_t offset);
 
 template <soa::is_filtered_table T>
 auto prepareFilteredSlice(T const* table, std::shared_ptr<arrow::Table> slice, uint64_t offset)
@@ -2011,7 +2011,7 @@ class Table
     return RowViewSentinel{mEnd};
   }
 
-  filtered_iterator filtered_begin(gsl::span<int64_t const> selection)
+  filtered_iterator filtered_begin(std::span<int64_t const> selection)
   {
     // Note that the FilteredIndexPolicy will never outlive the selection which
     // is held by the table, so we are safe passing the bare pointer. If it does it
@@ -3371,7 +3371,7 @@ class FilteredBase : public T
       mSelectedRowsCache{std::move(selection)},
       mCached{true}
   {
-    mSelectedRows = gsl::span{mSelectedRowsCache};
+    mSelectedRows = std::span{mSelectedRowsCache};
     if (this->tableSize() != 0) {
       mFilteredBegin = table_t::filtered_begin(mSelectedRows);
     }
@@ -3379,7 +3379,7 @@ class FilteredBase : public T
     mFilteredBegin.bindInternalIndices(this);
   }
 
-  FilteredBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, gsl::span<int64_t const> const& selection, uint64_t offset = 0)
+  FilteredBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<int64_t const> const& selection, uint64_t offset = 0)
     : T{std::move(tables), offset},
       mSelectedRows{selection}
   {
@@ -3458,12 +3458,12 @@ class FilteredBase : public T
   static inline auto getSpan(gandiva::Selection const& sel)
   {
     if (sel == nullptr) {
-      return gsl::span<int64_t const>{};
+      return std::span<int64_t const>{};
     }
     auto array = std::static_pointer_cast<arrow::Int64Array>(sel->ToArray());
     auto start = array->raw_values();
     auto stop = start + array->length();
-    return gsl::span{start, stop};
+    return std::span{start, stop};
   }
 
   /// Bind the columns which refer to other tables
@@ -3562,7 +3562,7 @@ class FilteredBase : public T
     resetRanges();
   }
 
-  void sumWithSelection(gsl::span<int64_t const> const& selection)
+  void sumWithSelection(std::span<int64_t const> const& selection)
   {
     mCached = true;
     SelectionVector rowsUnion;
@@ -3572,7 +3572,7 @@ class FilteredBase : public T
     resetRanges();
   }
 
-  void intersectWithSelection(gsl::span<int64_t const> const& selection)
+  void intersectWithSelection(std::span<int64_t const> const& selection)
   {
     mCached = true;
     SelectionVector intersection;
@@ -3591,7 +3591,7 @@ class FilteredBase : public T
   void resetRanges()
   {
     if (mCached) {
-      mSelectedRows = gsl::span{mSelectedRowsCache};
+      mSelectedRows = std::span{mSelectedRowsCache};
     }
     mFilteredEnd.reset(new RowViewSentinel{static_cast<int64_t>(mSelectedRows.size())});
     if (tableSize() == 0) {
@@ -3601,7 +3601,7 @@ class FilteredBase : public T
     }
   }
 
-  gsl::span<int64_t const> mSelectedRows;
+  std::span<int64_t const> mSelectedRows;
   SelectionVector mSelectedRowsCache;
   bool mCached = false;
   iterator mFilteredBegin;
@@ -3637,7 +3637,7 @@ class Filtered : public FilteredBase<T>
   Filtered(std::vector<std::shared_ptr<arrow::Table>>&& tables, SelectionVector&& selection, uint64_t offset = 0)
     : FilteredBase<T>(std::move(tables), std::forward<SelectionVector>(selection), offset) {}
 
-  Filtered(std::vector<std::shared_ptr<arrow::Table>>&& tables, gsl::span<int64_t const> const& selection, uint64_t offset = 0)
+  Filtered(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<int64_t const> const& selection, uint64_t offset = 0)
     : FilteredBase<T>(std::move(tables), selection, offset) {}
 
   Filtered<T> operator+(SelectionVector const& selection)
@@ -3647,7 +3647,7 @@ class Filtered : public FilteredBase<T>
     return copy;
   }
 
-  Filtered<T> operator+(gsl::span<int64_t const> const& selection)
+  Filtered<T> operator+(std::span<int64_t const> const& selection)
   {
     Filtered<T> copy(*this);
     copy.sumWithSelection(selection);
@@ -3665,7 +3665,7 @@ class Filtered : public FilteredBase<T>
     return *this;
   }
 
-  Filtered<T> operator+=(gsl::span<int64_t const> const& selection)
+  Filtered<T> operator+=(std::span<int64_t const> const& selection)
   {
     this->sumWithSelection(selection);
     return *this;
@@ -3683,7 +3683,7 @@ class Filtered : public FilteredBase<T>
     return copy;
   }
 
-  Filtered<T> operator*(gsl::span<int64_t const> const& selection)
+  Filtered<T> operator*(std::span<int64_t const> const& selection)
   {
     Filtered<T> copy(*this);
     copy.intersectWithSelection(selection);
@@ -3701,7 +3701,7 @@ class Filtered : public FilteredBase<T>
     return *this;
   }
 
-  Filtered<T> operator*=(gsl::span<int64_t const> const& selection)
+  Filtered<T> operator*=(std::span<int64_t const> const& selection)
   {
     this->intersectWithSelection(selection);
     return *this;
@@ -3809,7 +3809,7 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
     }
   }
 
-  Filtered(std::vector<Filtered<T>>&& tables, gsl::span<int64_t const> const& selection, uint64_t offset = 0)
+  Filtered(std::vector<Filtered<T>>&& tables, std::span<int64_t const> const& selection, uint64_t offset = 0)
     : FilteredBase<typename T::table_t>(std::move(extractTablesFromFiltered(tables)), selection, offset)
   {
     for (auto& table : tables) {
@@ -3824,7 +3824,7 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
     return copy;
   }
 
-  Filtered<Filtered<T>> operator+(gsl::span<int64_t const> const& selection)
+  Filtered<Filtered<T>> operator+(std::span<int64_t const> const& selection)
   {
     Filtered<Filtered<T>> copy(*this);
     copy.sumWithSelection(selection);
@@ -3842,7 +3842,7 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
     return *this;
   }
 
-  Filtered<Filtered<T>> operator+=(gsl::span<int64_t const> const& selection)
+  Filtered<Filtered<T>> operator+=(std::span<int64_t const> const& selection)
   {
     this->sumWithSelection(selection);
     return *this;
@@ -3860,7 +3860,7 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
     return copy;
   }
 
-  Filtered<Filtered<T>> operator*(gsl::span<int64_t const> const& selection)
+  Filtered<Filtered<T>> operator*(std::span<int64_t const> const& selection)
   {
     Filtered<Filtered<T>> copy(*this);
     copy.intersectionWithSelection(selection);
@@ -3878,7 +3878,7 @@ class Filtered<Filtered<T>> : public FilteredBase<typename T::table_t>
     return *this;
   }
 
-  Filtered<Filtered<T>> operator*=(gsl::span<int64_t const> const& selection)
+  Filtered<Filtered<T>> operator*=(std::span<int64_t const> const& selection)
   {
     this->intersectWithSelection(selection);
     return *this;
@@ -3987,7 +3987,7 @@ struct SmallGroupsBase : public Filtered<T> {
   SmallGroupsBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, SelectionVector&& selection, uint64_t offset = 0)
     : Filtered<T>(std::move(tables), std::forward<SelectionVector>(selection), offset) {}
 
-  SmallGroupsBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, gsl::span<int64_t const> const& selection, uint64_t offset = 0)
+  SmallGroupsBase(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<int64_t const> const& selection, uint64_t offset = 0)
     : Filtered<T>(std::move(tables), selection, offset) {}
 };
 
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 6e9b1e211bb76..0fc4821e6a420 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -119,6 +119,9 @@ class TableConsumer;
 template <typename T>
 concept is_producable = soa::has_metadata<aod::MetadataTrait<T>> || soa::has_metadata<aod::MetadataTrait<typename T::parent_t>>;
 
+template <typename T>
+concept is_enumerated_iterator = requires(T t) { t.globalIndex(); };
+
 template <is_producable T>
 struct WritingCursor {
  public:
@@ -126,9 +129,9 @@ struct WritingCursor {
   using cursor_t = decltype(std::declval<TableBuilder>().cursor<persistent_table_t>());
 
   template <typename... Ts>
-  void operator()(Ts... args)
+  void operator()(Ts&&... args)
+    requires(sizeof...(Ts) == framework::pack_size(typename persistent_table_t::persistent_columns_t{}))
   {
-    static_assert(sizeof...(Ts) == framework::pack_size(typename persistent_table_t::persistent_columns_t{}), "Argument number mismatch");
     ++mCount;
     cursor(0, extract(args)...);
   }
@@ -167,15 +170,14 @@ struct WritingCursor {
   decltype(FFL(std::declval<cursor_t>())) cursor;
 
  private:
-  template <typename A>
-    requires requires { &A::globalIndex; }
-  static decltype(auto) extract(A const& arg)
+  static decltype(auto) extract(is_enumerated_iterator auto const& arg)
   {
     return arg.globalIndex();
   }
 
   template <typename A>
-  static decltype(auto) extract(A const& arg)
+    requires(!is_enumerated_iterator<A>)
+  static decltype(auto) extract(A&& arg)
   {
     return arg;
   }
diff --git a/Framework/Core/include/Framework/ArrowTableSlicingCache.h b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
index 41d6b33e48476..40991a955e52b 100644
--- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h
+++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
@@ -28,10 +28,10 @@ struct SliceInfoPtr {
 };
 
 struct SliceInfoUnsortedPtr {
-  gsl::span<int const> values;
+  std::span<int const> values;
   ListVector const* groups;
 
-  gsl::span<int64_t const> getSliceFor(int value) const;
+  std::span<int64_t const> getSliceFor(int value) const;
 };
 
 struct Entry {
diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h
index 112bf7e147ff0..4cfbb8c440fd3 100644
--- a/Framework/Core/include/Framework/GroupSlicer.h
+++ b/Framework/Core/include/Framework/GroupSlicer.h
@@ -264,9 +264,9 @@ struct GroupSlicer {
     std::tuple<A...>* mAt;
     typename grouping_t::iterator mGroupingElement;
     uint64_t position = 0;
-    gsl::span<int64_t const> groupSelection;
-    std::array<gsl::span<int64_t const> const*, sizeof...(A)> selections;
-    std::array<gsl::span<int64_t const>::iterator, sizeof...(A)> starts;
+    std::span<int64_t const> groupSelection;
+    std::array<std::span<int64_t const> const*, sizeof...(A)> selections;
+    std::array<std::span<int64_t const>::iterator, sizeof...(A)> starts;
 
     std::array<SliceInfoPtr, sizeof...(A)> sliceInfos;
     std::array<SliceInfoUnsortedPtr, sizeof...(A)> sliceInfosUnsorted;
diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index 74395a2680077..1eb493bfd052d 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -105,7 +105,7 @@ void addLabelToSchema(std::shared_ptr<arrow::Schema>& schema, const char* label)
 
 struct BuilderUtils {
   template <typename T>
-  static arrow::Status appendToList(std::unique_ptr<arrow::FixedSizeListBuilder>& builder, T* data, int size = 1)
+  static arrow::Status appendToList(std::unique_ptr<arrow::FixedSizeListBuilder>& builder, const T* data, int size = 1)
   {
     using ArrowType = typename detail::ConversionTraits<std::decay_t<T>>::ArrowType;
     using BuilderType = typename arrow::TypeTraits<ArrowType>::BuilderType;
@@ -134,7 +134,7 @@ struct BuilderUtils {
   /// Assumes that the pointer actually points to a buffer
   /// which contains the correct number of elements.
   template <typename HolderType, typename T>
-  static arrow::Status append(HolderType& holder, T* data)
+  static arrow::Status append(HolderType& holder, const T* data)
   {
     if constexpr (std::is_same_v<decltype(holder.builder), std::unique_ptr<arrow::FixedSizeListBuilder>>) {
       return appendToList<T>(holder.builder, data);
@@ -144,21 +144,21 @@ struct BuilderUtils {
   }
   /// Appender for the array case.
   template <typename HolderType, typename T, int N>
-  static arrow::Status append(HolderType& holder, T (&data)[N])
+  static arrow::Status append(HolderType& holder, const T (&data)[N])
   {
     return holder.builder->Append(reinterpret_cast<const uint8_t*>(data));
   }
 
   /// Appender for the array case.
   template <typename HolderType, typename T, int N>
-  static arrow::Status append(HolderType& holder, std::array<T, N> const& data)
+  static arrow::Status append(HolderType& holder, std::array<const T, N> const& data)
   {
     return holder.builder->Append(reinterpret_cast<const uint8_t*>(data.data()));
   }
 
   /// Appender for the vector case.
   template <typename HolderType, typename T>
-  static arrow::Status append(HolderType& holder, std::vector<T> const& data)
+  static arrow::Status append(HolderType& holder, std::span<const T> data)
   {
     using ArrowType = typename detail::ConversionTraits<T>::ArrowType;
     using ValueBuilderType = typename arrow::TypeTraits<ArrowType>::BuilderType;
@@ -171,7 +171,7 @@ struct BuilderUtils {
   }
 
   template <typename HolderType, typename T>
-  static void unsafeAppend(HolderType& holder, std::vector<T> const& value)
+  static void unsafeAppend(HolderType& holder, std::span<const T> value)
   {
     auto status = append(holder, value);
     if (!status.ok()) {
@@ -300,7 +300,7 @@ struct BuilderMaker<std::span<std::byte>> {
 
 template <typename ITERATOR>
 struct BuilderMaker<std::pair<ITERATOR, ITERATOR>> {
-  using FillType = std::pair<ITERATOR, ITERATOR>;
+  using FillType = std::pair<ITERATOR, ITERATOR> const&;
   using STLValueType = typename ITERATOR::value_type;
   using ArrowType = arrow::ListType;
   using ValueType = typename detail::ConversionTraits<typename ITERATOR::value_type>::ArrowType;
@@ -321,7 +321,7 @@ struct BuilderMaker<std::pair<ITERATOR, ITERATOR>> {
 
 template <typename T, int N>
 struct BuilderMaker<T (&)[N]> {
-  using FillType = T*;
+  using FillType = const T*;
   using STLValueType = T;
   using BuilderType = arrow::FixedSizeListBuilder;
   using ArrowType = arrow::FixedSizeListType;
@@ -343,7 +343,7 @@ struct BuilderMaker<T (&)[N]> {
 
 template <typename T, int N>
 struct BuilderMaker<T[N]> {
-  using FillType = T*;
+  using FillType = const T*;
   using BuilderType = arrow::FixedSizeListBuilder;
   using ArrowType = arrow::FixedSizeListType;
   using ElementType = typename detail::ConversionTraits<T>::ArrowType;
@@ -364,7 +364,7 @@ struct BuilderMaker<T[N]> {
 
 template <typename T, int N>
 struct BuilderMaker<std::array<T, N>> {
-  using FillType = T*;
+  using FillType = const T*;
   using BuilderType = arrow::FixedSizeListBuilder;
   using ArrowType = arrow::FixedSizeListType;
   using ElementType = typename detail::ConversionTraits<T>::ArrowType;
@@ -385,7 +385,7 @@ struct BuilderMaker<std::array<T, N>> {
 
 template <typename T>
 struct BuilderMaker<std::vector<T>> {
-  using FillType = std::vector<T>;
+  using FillType = std::span<const T>;
   using BuilderType = arrow::ListBuilder;
   using ArrowType = arrow::ListType;
   using ElementType = typename detail::ConversionTraits<T>::ArrowType;
@@ -678,7 +678,7 @@ class TableBuilder
   {
     auto persister = persistTuple(framework::pack<ARG0, ARGS...>{}, columnNames);
     // Callback used to fill the builders
-    return [persister = persister](unsigned int slot, typename BuilderMaker<ARG0>::FillType const& arg, typename BuilderMaker<ARGS>::FillType... args) -> void {
+    return [persister = persister](unsigned int slot, typename BuilderMaker<ARG0>::FillType arg, typename BuilderMaker<ARGS>::FillType... args) -> void {
       persister(slot, std::forward_as_tuple(arg, args...));
     };
   }
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index 3a681ee931a2b..7b5cdf72191cf 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -50,7 +50,7 @@ SelectionVector selectionToVector(gandiva::Selection const& sel)
   return rows;
 }
 
-SelectionVector sliceSelection(gsl::span<int64_t const> const& mSelectedRows, int64_t nrows, uint64_t offset)
+SelectionVector sliceSelection(std::span<int64_t const> const& mSelectedRows, int64_t nrows, uint64_t offset)
 {
   auto start = offset;
   auto end = start + nrows;
@@ -217,7 +217,7 @@ std::shared_ptr<arrow::Table> PreslicePolicySorted::getSliceFor(int value, std::
   return output;
 }
 
-gsl::span<const int64_t> PreslicePolicyGeneral::getSliceFor(int value) const
+std::span<const int64_t> PreslicePolicyGeneral::getSliceFor(int value) const
 {
   return this->sliceInfo.getSliceFor(value);
 }
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 26bb9bcee80eb..0d06a926dd930 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -42,7 +42,7 @@ std::pair<int64_t, int64_t> SliceInfoPtr::getSliceFor(int value) const
   return {offsets[value], sizes[value]};
 }
 
-gsl::span<const int64_t> SliceInfoUnsortedPtr::getSliceFor(int value) const
+std::span<const int64_t> SliceInfoUnsortedPtr::getSliceFor(int value) const
 {
   if (values.empty()) {
     return {};

From 95f677e876aad0a50a609cc6fece450b66e2f9b0 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Thu, 21 Aug 2025 22:18:48 +0200
Subject: [PATCH 0728/1764] Adding sigma=0 cluster handling

---
 .../GPUTPCNNClusterizerKernels.cxx               | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index dd33a72f79389..143b73263642a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -360,20 +360,28 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
       return;
     }
 
+    bool notSinglePad = false, notSingleTime = false;
+    for (uint16_t i = 0; i < 8; i++) {
+      Delta2 d = cfconsts::InnerNeighbors[i];
+      CfChargePos tmp_pos = peak.delta(d);
+      notSinglePad |= (d.x != 0) && (static_cast<float>(chargeMap[tmp_pos].unpack()) > 0);
+      notSingleTime |= (d.y != 0) && (static_cast<float>(chargeMap[tmp_pos].unpack()) > 0);
+    }
+
     if (dtype == 0) {
       pc.setFull(central_charge * clustererNN.mOutputDataReg1_16[model_output_index + 4].ToFloat(),
                  static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_16[model_output_index].ToFloat(),
-                 clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat(),
+                 notSinglePad ? clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat() : 0,
                  (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_16[model_output_index + 1].ToFloat(),
-                 clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat(),
+                 notSingleTime ? clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat() : 0.f,
                  clustererNN.mClusterFlags[2 * glo_idx],
                  clustererNN.mClusterFlags[2 * glo_idx + 1]);
     } else if (dtype == 1) {
       pc.setFull(central_charge * clustererNN.mOutputDataReg1_32[model_output_index + 4],
                  static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_32[model_output_index],
-                 clustererNN.mOutputDataReg1_32[model_output_index + 2],
+                 notSinglePad ? clustererNN.mOutputDataReg1_32[model_output_index + 2] : 0.f,
                  (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_32[model_output_index + 1],
-                 clustererNN.mOutputDataReg1_32[model_output_index + 3],
+                 notSingleTime ? clustererNN.mOutputDataReg1_32[model_output_index + 3] : 0.f,
                  clustererNN.mClusterFlags[2 * glo_idx],
                  clustererNN.mClusterFlags[2 * glo_idx + 1]);
     }

From da20bb74719cb7e616a54f6371eb93b0c47c37f2 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Thu, 21 Aug 2025 22:20:07 +0200
Subject: [PATCH 0729/1764] fix

---
 GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 143b73263642a..62032f6e2c46d 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -373,7 +373,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
                  static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_16[model_output_index].ToFloat(),
                  notSinglePad ? clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat() : 0,
                  (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_16[model_output_index + 1].ToFloat(),
-                 notSingleTime ? clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat() : 0.f,
+                 notSingleTime ? clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat() : 0,
                  clustererNN.mClusterFlags[2 * glo_idx],
                  clustererNN.mClusterFlags[2 * glo_idx + 1]);
     } else if (dtype == 1) {

From ec334bc281dc4916d2eb6304356445c74af54fcb Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Thu, 21 Aug 2025 22:20:24 +0200
Subject: [PATCH 0730/1764] fix

---
 .../TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx           | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 62032f6e2c46d..1882acd2a45c6 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -371,9 +371,9 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
     if (dtype == 0) {
       pc.setFull(central_charge * clustererNN.mOutputDataReg1_16[model_output_index + 4].ToFloat(),
                  static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_16[model_output_index].ToFloat(),
-                 notSinglePad ? clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat() : 0,
+                 notSinglePad ? clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat() : 0.f,
                  (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_16[model_output_index + 1].ToFloat(),
-                 notSingleTime ? clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat() : 0,
+                 notSingleTime ? clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat() : 0.f,
                  clustererNN.mClusterFlags[2 * glo_idx],
                  clustererNN.mClusterFlags[2 * glo_idx + 1]);
     } else if (dtype == 1) {

From 7fccf1d2454b129e9bb66a2b5f5f510c4c6a8241 Mon Sep 17 00:00:00 2001
From: mcoquet642 <74600025+mcoquet642@users.noreply.github.com>
Date: Fri, 22 Aug 2025 16:26:21 +0200
Subject: [PATCH 0731/1764] [MFT] Fixing wrong call of functions in
 construction of NoiseMaps (#14609)

* Fixing calls of ccdb objects construction

* Clang format

* Fix typo

---------

Co-authored-by: Maurice Coquet <mcoquet@lxplus957.cern.ch>
---
 .../calibration/src/NoiseCalibratorSpec.cxx   | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
index 8359d6c89ab60..29cdb09692f4e 100644
--- a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
@@ -78,12 +78,12 @@ void NoiseCalibratorSpec::run(ProcessingContext& pc)
         LOG(info) << "Sending an object to Production-CCDBMerge";
         sendOutputCcdbMerge(pc.outputs());
       } else if (mOutputType.compare("DCS") == 0) {
-        LOG(info) << "Sending an object to DCS-CCDB";
-        sendOutputDcs(pc.outputs());
+        LOG(info) << "Sending an object to DCS-Merge";
+        sendOutputDcsMerge(pc.outputs());
       } else {
-        LOG(info) << "Sending an object to Production-CCDB and DCS-CCDB";
-        sendOutputCcdbDcs(pc.outputs());
-        LOG(info) << "Sending an object to Production-CCDBMerge";
+        LOG(info) << "Sending an object to Production-CCDB, Production-CCDB-Merge and DCS-Merge";
+        sendOutputCcdb(pc.outputs());
+        sendOutputDcsMerge(pc.outputs());
         sendOutputCcdbMerge(pc.outputs());
       }
       pc.services().get<ControlService>().readyToQuit(mStopMeOnly ? QuitRequest::Me : QuitRequest::All);
@@ -102,12 +102,12 @@ void NoiseCalibratorSpec::run(ProcessingContext& pc)
         LOG(info) << "Sending an object to Production-CCDBMerge";
         sendOutputCcdbMerge(pc.outputs());
       } else if (mOutputType.compare("DCS") == 0) {
-        LOG(info) << "Sending an object to DCS-CCDB";
-        sendOutputDcs(pc.outputs());
+        LOG(info) << "Sending an object to DCS-Merge";
+        sendOutputDcsMerge(pc.outputs());
       } else {
-        LOG(info) << "Sending an object to Production-CCDB and DCS-CCDB";
-        sendOutputCcdbDcs(pc.outputs());
-        LOG(info) << "Sending an object to Production-CCDBMerge";
+        LOG(info) << "Sending an object to Production-CCDB, Production-CCDB-Merge and DCS-Merge";
+        sendOutputCcdb(pc.outputs());
+        sendOutputDcsMerge(pc.outputs());
         sendOutputCcdbMerge(pc.outputs());
       }
       pc.services().get<ControlService>().readyToQuit(mStopMeOnly ? QuitRequest::Me : QuitRequest::All);
@@ -385,7 +385,7 @@ void NoiseCalibratorSpec::sendOutputDcs(DataAllocator& output)
 void NoiseCalibratorSpec::sendOutputDcsMerge(DataAllocator& output)
 {
 
-  LOG(info) << "DCS mode";
+  LOG(info) << "DCS-Merge mode";
 
   static bool done = false;
   if (done) {

From b319a5ff822c21f5ec64db740ffa913b080b6740 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sat, 23 Aug 2025 17:52:34 +0200
Subject: [PATCH 0732/1764] ITS: GPU: disallow nROFsPerIterations (#14614)

---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx | 4 ++--
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx               | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 15338f771ea27..6a824de851fed 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -57,8 +57,8 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
 {
   const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  int startROF{this->mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * this->mTrkParams[iteration].nROFsPerIterations : 0};
-  int endROF{o2::gpu::CAMath::Min(this->mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * this->mTrkParams[iteration].nROFsPerIterations + this->mTrkParams[iteration].DeltaROF : mTimeFrameGPU->getNrof(), mTimeFrameGPU->getNrof())};
+  int startROF{0};
+  int endROF{mTimeFrameGPU->getNrof()};
 
   // start by queuing loading needed of two last layers
   for (int iLayer{nLayers}; iLayer-- > nLayers - 2;) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 746a15287e994..e8212f4ad53a1 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -85,7 +85,7 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
       }
       double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
       int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
-      int nROFsIterations = mTrkParams[iteration].nROFsPerIterations > 0 ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
+      int nROFsIterations = (mTrkParams[iteration].nROFsPerIterations > 0 && !mTimeFrame->mIsGPU) ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
       iVertex = std::min(maxNvertices, 0);
       logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
 

From d823a46382c73a91aa0c46a16dfbcd90873b0bd4 Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Sun, 24 Aug 2025 14:53:26 +0200
Subject: [PATCH 0733/1764] Ctpdev: validity of orbitreset (#14612)

* dev: validity range adjustment

* clang

* fixes
---
 Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx |  4 +---
 Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx | 11 ++++++++---
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx b/Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx
index e35b6574db92f..aa953e89264ef 100644
--- a/Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctp-ccdb-orbit.cxx
@@ -125,11 +125,9 @@ int main(int argc, char** argv)
     } else {
       std::cout << "Storing:" << ccdbPath << " tmin:" << tmin << " tmax:" << tmax << " ts:" << tt << std::endl;
       std::string filename = "orbitReset.root";
-      TClass* tcls = TClass::GetClass(typeid(vect));
-      auto ti = tcls->GetTypeInfo();
       auto classname = "std::vector<int64_t>";
       metadata["adjustableEOV"] = "true";
-      ret = api.storeAsTFile_impl(&(vect), *ti, ccdbPath, metadata, tmin, tmax);
+      ret = api.storeAsTFileAny(&(vect), ccdbPath, metadata, tmin, tmax);
       o2::ccdb::CcdbObjectInfo oi(ccdbPath, classname, filename, metadata, tmin, tmax);
       adjustOverriddenEOV(api, oi);
     }
diff --git a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
index 2c634ddd2565d..df75b21c2effd 100644
--- a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
@@ -157,9 +157,14 @@ int ctpCCDBManager::saveOrbitReset(long timeStamp)
   o2::ccdb::CcdbApi api;
   std::map<std::string, std::string> metadata; // can be empty
   api.init(mCCDBHost.c_str());  // or http://localhost:8080 for a local installation
-
-  // store abitrary user object in strongly typed manner
-  int ret = api.storeAsTFileAny(&vect, mCCDBPathOrbitReset, metadata, tmin, tmax);
+  // int ret = api.storeAsTFileAny(&vect, mCCDBPathOrbitReset, metadata, tmin, tmax);
+  std::cout << "Storing:" << mCCDBPathOrbitReset << " tmin:" << tmin << " tmax:" << tmax << " ts:" << timeStamp << std::endl;
+  std::string filename = "orbitReset.root";
+  auto classname = "std::vector<int64_t>";
+  metadata["adjustableEOV"] = "true";
+  int ret = api.storeAsTFileAny(&(vect), mCCDBPathOrbitReset, metadata, tmin, tmax);
+  o2::ccdb::CcdbObjectInfo oi(mCCDBPathOrbitReset, classname, filename, metadata, tmin, tmax);
+  adjustOverriddenEOV(api, oi);
   if (ret == 0) {
     LOG(info) << "Orbit reset  saved in ccdb:" << mCCDBHost << " tmin:" << tmin << " tmax:" << tmax;
   } else {

From 3e1afe2b25cfcb95bb8fbec12ca5328537fd0c41 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 24 Aug 2025 16:09:36 +0200
Subject: [PATCH 0734/1764] Method to translate TOF cluster to nominal sector
 frame

---
 .../Detectors/TOF/include/DataFormatsTOF/Cluster.h  |  7 ++++++-
 Detectors/TOF/base/include/TOFBase/Geo.h            |  2 ++
 Detectors/TOF/base/src/Geo.cxx                      | 13 +++++++++++++
 3 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h b/DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h
index f36150e18fbbc..2f15923419795 100644
--- a/DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h
+++ b/DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h
@@ -49,7 +49,9 @@ class Cluster : public o2::BaseCluster<float>
          kDownRight = 4, // 2^4, 5th bit
          kDown = 5,      // 2^5, 6th bit
          kDownLeft = 6,  // 2^6, 7th bit
-         kLeft = 7 };    // 2^7, 8th bit
+         kLeft = 7,      // 2^7, 8th bit
+         //
+         FrameBit = 6 }; // this bit set means that the cluster is in the nominal (alpha=20*sector+10 deg.) sector frame rather than aligned
 
   Cluster() = default;
 
@@ -57,6 +59,9 @@ class Cluster : public o2::BaseCluster<float>
 
   ~Cluster() = default;
 
+  bool isInNominalSector() const { return isBitSet(FrameBit); }
+  void setInNominalSector() { setBit(FrameBit); }
+
   std::int8_t getSector() const { return getCount(); }
   void setSector(std::int8_t value) { setCount(value); }
 
diff --git a/Detectors/TOF/base/include/TOFBase/Geo.h b/Detectors/TOF/base/include/TOFBase/Geo.h
index 761528d472d71..24e8fbdf51174 100644
--- a/Detectors/TOF/base/include/TOFBase/Geo.h
+++ b/Detectors/TOF/base/include/TOFBase/Geo.h
@@ -66,6 +66,8 @@ class Geo
   static void antiRotateToSector(Float_t* xyz, Int_t isector);
   static void antiRotateToStrip(Float_t* xyz, Int_t iplate, Int_t istrip, Int_t isector);
 
+  static void alignedToNominalSector(Float_t* xyz, Int_t isector);
+
   static void antiRotate(Float_t* xyz, Double_t rotationAngles[6]);
   static void getDetID(Float_t* pos, Int_t* det);
   static Int_t getIndex(const Int_t* detId);               // Get channel index from det Id (for calibration mainly)
diff --git a/Detectors/TOF/base/src/Geo.cxx b/Detectors/TOF/base/src/Geo.cxx
index c76e6b4d83943..08cda68c6d12e 100644
--- a/Detectors/TOF/base/src/Geo.cxx
+++ b/Detectors/TOF/base/src/Geo.cxx
@@ -988,6 +988,7 @@ void Geo::translate(Float_t* xyz, Float_t translationVector[3])
 
   return;
 }
+
 void Geo::translate(Float_t& x, Float_t& y, Float_t& z, Float_t translationVector[3])
 {
   //
@@ -1045,6 +1046,18 @@ void Geo::rotateToSector(Float_t* xyz, Int_t isector)
   return;
 }
 
+void Geo::alignedToNominalSector(Float_t* xyz, Int_t isector)
+{
+  // rotate from the aligned sector frame coordinates to nominal ones (i.e. alpha=20*sector+10 deg.)
+  constexpr float CS[18] = {.848077e-01, 8.660254e-01, 6.427876e-01, 3.420202e-01, -4.371139e-08, -3.420201e-01, -6.427876e-01, -8.660254e-01, -9.848077e-01, -9.848077e-01, -8.660254e-01, -6.427875e-01, -3.420201e-01, 1.192488e-08, 3.420201e-01, 6.427875e-01, 8.660253e-01, 9.848078e-01};
+  constexpr float SN[18] = {1.736482e-01, 5.000000e-01, 7.660444e-01, 9.396926e-01, 1.000000e+00, 9.396926e-01, 7.660444e-01, 5.000001e-01, 1.736483e-01, -1.736482e-01, -5.000000e-01, -7.660446e-01, -9.396927e-01, -1.000000e+00, -9.396926e-01, -7.660445e-01, -5.000002e-01, -1.736480e-01};
+  Float_t xyzDummy[3] = {xyz[1], xyz[2], xyz[0]};      // go to twisted coordinates...
+  o2::tof::Geo::antiRotateToSector(xyzDummy, isector); // lab coordinates
+  xyz[0] = xyzDummy[0] * CS[isector] + xyzDummy[1] * SN[isector];
+  xyz[1] = -xyzDummy[0] * SN[isector] + xyzDummy[1] * CS[isector];
+  xyz[2] = xyzDummy[2];
+}
+
 void Geo::antiRotateToStrip(Float_t* xyz, Int_t iplate, Int_t istrip, Int_t isector)
 {
   Float_t xyzDummy[3] = {0., 0., 0.};

From 38a4549cd515dd3be10afdf874f33c2fd33c38b5 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 18 Aug 2025 00:08:21 +0200
Subject: [PATCH 0735/1764] Add residuals for external detectors unless
 --skip-ext-det-residuals is passed

The unbinned residuals got channel data member which holds ITS chipID, TRD chamber ID
or TOF pad within the sector resp. The convention for non-TPC rows:
160-165: TRD layers
170:     TOF
180-186: ITS layers
The getters isTPC(), isTRD(), isTOF() and isITS() can be used to query the residual type
and getDetID() will return 0,1,2 and 3 for ITS, TPC, TRD and TOF points resp.
Also, getX() and getAlpha() will provide the tracking frame X and alpha of the residual.
These getters, when acting on the non-TPC residuals require initialized geometry helpers.
The initialization can be done manually via static method
o2::tpc::UnbinnedResid::init(long timeStamp = -1)
which will load from the CCDB the geometry corresponding to the requested timestamp (-1 : now).
If the initialization was not done in advance then it will be done internally at the 1st
query of getX() or getAlpha(), with the timestamp = -1.
---
 .../TPCInterpolationSpec.h                    |   7 +-
 .../src/TPCInterpolationSpec.cxx              |   7 +-
 .../src/tpc-interpolation-workflow.cxx        |   4 +-
 .../calibration/SpacePoints/CMakeLists.txt    |   1 +
 .../include/SpacePoints/TrackInterpolation.h  |  69 +++-
 .../SpacePoints/src/TrackInterpolation.cxx    | 373 +++++++++++++++---
 6 files changed, 382 insertions(+), 79 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCInterpolationSpec.h b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCInterpolationSpec.h
index 86064f84d881f..83dbb1bd0f5fe 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCInterpolationSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCInterpolationSpec.h
@@ -38,7 +38,8 @@ namespace tpc
 class TPCInterpolationDPL : public Task
 {
  public:
-  TPCInterpolationDPL(std::shared_ptr<o2::globaltracking::DataRequest> dr, o2::dataformats::GlobalTrackID::mask_t src, o2::dataformats::GlobalTrackID::mask_t srcMap, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput) : mDataRequest(dr), mSources(src), mSourcesMap(srcMap), mGGCCDBRequest(gr), mUseMC(useMC), mProcessITSTPConly(processITSTPConly), mSendTrackData(sendTrackData), mDebugOutput(debugOutput) {}
+  TPCInterpolationDPL(std::shared_ptr<o2::globaltracking::DataRequest> dr, o2::dataformats::GlobalTrackID::mask_t src, o2::dataformats::GlobalTrackID::mask_t srcMap, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC,
+                      bool processITSTPConly, bool sendTrackData, bool debugOutput, bool extDetResid) : mDataRequest(dr), mSources(src), mSourcesMap(srcMap), mGGCCDBRequest(gr), mUseMC(useMC), mProcessITSTPConly(processITSTPConly), mSendTrackData(sendTrackData), mDebugOutput(debugOutput), mExtDetResid(extDetResid) {}
   ~TPCInterpolationDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -58,6 +59,7 @@ class TPCInterpolationDPL : public Task
   bool mProcessITSTPConly{false}; ///< should also tracks without outer point (ITS-TPC only) be processed?
   bool mProcessSeeds{false};      ///< process not only most complete track, but also its shorter parts
   bool mDebugOutput{false};       ///< add more information to the output (track points of ITS, TRD and TOF)
+  bool mExtDetResid{true};        ///< produce unbinned residuals for external detectors
   bool mSendTrackData{false};     ///< if true, not only the clusters but also corresponding track data will be sent
   uint32_t mSlotLength{600u};     ///< the length of one calibration slot required to calculate max number of tracks per TF
   int mMatCorr{2};                ///< the material correction to be used for track interpolation
@@ -65,7 +67,8 @@ class TPCInterpolationDPL : public Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getTPCInterpolationSpec(o2::dataformats::GlobalTrackID::mask_t srcCls, o2::dataformats::GlobalTrackID::mask_t srcVtx, o2::dataformats::GlobalTrackID::mask_t srcTrk, o2::dataformats::GlobalTrackID::mask_t srcTrkMap, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput);
+framework::DataProcessorSpec getTPCInterpolationSpec(o2::dataformats::GlobalTrackID::mask_t srcCls, o2::dataformats::GlobalTrackID::mask_t srcVtx, o2::dataformats::GlobalTrackID::mask_t srcTrk,
+                                                     o2::dataformats::GlobalTrackID::mask_t srcTrkMap, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput, bool extDetResid);
 
 } // namespace tpc
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
index 521a02cabcbee..da2fcaab913d7 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
@@ -105,8 +105,9 @@ void TPCInterpolationDPL::updateTimeDependentParams(ProcessingContext& pc)
   }
   if (mDebugOutput) {
     mInterpolation.setDumpTrackPoints();
-    mInterpolation.setITSClusterDictionary(mITSDict);
   }
+  mInterpolation.setExtDetResid(mExtDetResid);
+  mInterpolation.setITSClusterDictionary(mITSDict);
 }
 
 void TPCInterpolationDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
@@ -158,7 +159,7 @@ void TPCInterpolationDPL::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t srcCls, GTrackID::mask_t srcVtx, GTrackID::mask_t srcTrk, GTrackID::mask_t srcTrkMap, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput)
+DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t srcCls, GTrackID::mask_t srcVtx, GTrackID::mask_t srcTrk, GTrackID::mask_t srcTrkMap, bool useMC, bool processITSTPConly, bool sendTrackData, bool debugOutput, bool extDetResid)
 {
   auto dataRequest = std::make_shared<DataRequest>();
   std::vector<OutputSpec> outputs;
@@ -199,7 +200,7 @@ DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t srcCls, GTrackID::mas
     "tpc-track-interpolation",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TPCInterpolationDPL>(dataRequest, srcTrk, srcTrkMap, ggRequest, useMC, processITSTPConly, sendTrackData, debugOutput)},
+    AlgorithmSpec{adaptFromTask<TPCInterpolationDPL>(dataRequest, srcTrk, srcTrkMap, ggRequest, useMC, processITSTPConly, sendTrackData, debugOutput, extDetResid)},
     Options{
       {"matCorrType", VariantType::Int, 2, {"material correction type (definition in Propagator.h)"}},
       {"sec-per-slot", VariantType::UInt32, 600u, {"number of seconds per calibration time slot (put 0 for infinite slot length)"}},
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx
index 0905942c956a4..2f28fc5bb2d34 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx
@@ -42,6 +42,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"tracking-sources-map-extraction", VariantType::String, std::string{GID::ALL}, {"can be subset of \"tracking-sources\""}},
     {"send-track-data", VariantType::Bool, false, {"Send also the track information to the aggregator"}},
     {"debug-output", VariantType::Bool, false, {"Dump extended tracking information for debugging"}},
+    {"skip-ext-det-residuals", VariantType::Bool, false, {"Do not produce residuals for external detectors"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
@@ -104,8 +105,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   useMC = false; // force disabling MC as long as it is not implemented
   auto sendTrackData = configcontext.options().get<bool>("send-track-data");
   auto debugOutput = configcontext.options().get<bool>("debug-output");
+  auto extDetResid = !configcontext.options().get<bool>("skip-ext-det-residuals");
 
-  specs.emplace_back(o2::tpc::getTPCInterpolationSpec(srcClusters, srcVtx, srcTracks, srcTracksMap, useMC, processITSTPConly, sendTrackData, debugOutput));
+  specs.emplace_back(o2::tpc::getTPCInterpolationSpec(srcClusters, srcVtx, srcTracks, srcTracksMap, useMC, processITSTPConly, sendTrackData, debugOutput, extDetResid));
   if (!configcontext.options().get<bool>("disable-root-output")) {
     specs.emplace_back(o2::tpc::getTPCResidualWriterSpec(sendTrackData, debugOutput));
   }
diff --git a/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt b/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
index 1b5e79f601211..566558b7e982f 100644
--- a/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
+++ b/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
@@ -19,6 +19,7 @@ o2_add_library(SpacePoints
                                      O2::CommonUtils
                                      O2::TPCBase
                                      O2::TRDBase
+                                     O2::TOFBase
                                      O2::TPCReconstruction
                                      O2::TPCFastTransformation
                                      O2::ITStracking
diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
index 9cbcf3d117661..9f7c6d0fc8fbc 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
@@ -67,31 +67,49 @@ struct TPCClusterResiduals {
 /// (this is the data type which will be sent from the EPNs to the aggregator)
 struct UnbinnedResid {
   UnbinnedResid() = default;
-  UnbinnedResid(float dyIn, float dzIn, float tgSlpIn, float yIn, float zIn, unsigned char rowIn, unsigned char secIn) : dy(static_cast<short>(dyIn * 0x7fff / param::MaxResid)),
-                                                                                                                         dz(static_cast<short>(dzIn * 0x7fff / param::MaxResid)),
-                                                                                                                         tgSlp(static_cast<short>(tgSlpIn * 0x7fff / param::MaxTgSlp)),
-                                                                                                                         y(static_cast<short>(yIn * 0x7fff / param::MaxY)),
-                                                                                                                         z(static_cast<short>(zIn * 0x7fff / param::MaxZ)),
-                                                                                                                         row(rowIn),
-                                                                                                                         sec(secIn) {}
-  short dy;          ///< residual in y
-  short dz;          ///< residual in z
-  short tgSlp;       ///< tan of the phi angle between padrow and track
-  short y;           ///< y position of the track, needed for binning
-  short z;           ///< z position of the track, needed for binning
-  unsigned char row; ///< TPC pad row
-  unsigned char sec; ///< TPC sector (0..35)
-  ClassDefNV(UnbinnedResid, 1);
+  UnbinnedResid(float dyIn, float dzIn, float tgSlpIn, float yIn, float zIn, unsigned char rowIn, unsigned char secIn, short chanIn = -1) : dy(static_cast<short>(dyIn * 0x7fff / param::MaxResid)),
+                                                                                                                                            dz(static_cast<short>(dzIn * 0x7fff / param::MaxResid)),
+                                                                                                                                            tgSlp(static_cast<short>(tgSlpIn * 0x7fff / param::MaxTgSlp)),
+                                                                                                                                            y(static_cast<short>(yIn * 0x7fff / param::MaxY)),
+                                                                                                                                            z(static_cast<short>(zIn * 0x7fff / param::MaxZ)),
+                                                                                                                                            row(rowIn),
+                                                                                                                                            sec(secIn),
+                                                                                                                                            channel(chanIn) {}
+  short dy{0};          ///< residual in y
+  short dz{0};          ///< residual in z
+  short tgSlp{0};       ///< tan of the phi angle between padrow and track
+  short y{0};           ///< y position of the track, needed for binning
+  short z{0};           ///< z position of the track, needed for binning
+  unsigned char row{0}; ///< TPC pad row
+  unsigned char sec{0}; ///< TPC sector (0..35)
+  short channel{-1};    ///< extra channel info (ITS chip ID, TRD chamber, TOF main pad within the sector)
+
+  bool isTPC() const { return row < constants::MAXGLOBALPADROW; }
+  bool isTRD() const { return row >= 160 && row < 166; }
+  bool isTOF() const { return row == 170; }
+  bool isITS() const { return row >= 180; }
+  int getDetID() const { return isTPC() ? 1 : (isITS() ? 0 : (isTRD() ? 2 : (isTOF() ? 3 : -1))); }
+  int getITSLayer() const { return row - 180; }
+  int getTRDLayer() const { return row - 170; }
+  float getAlpha() const;
+  float getX() const;
+
+  static void init(long timestamp = -1);
+  static void checkInitDone();
+  static bool gInitDone;
+
+  ClassDefNV(UnbinnedResid, 2);
 };
 
 /// Structure for the information required to associate each residual with a given track type (ITS-TPC-TRD-TOF, etc)
 struct TrackDataCompact {
   TrackDataCompact() = default;
-  TrackDataCompact(uint32_t idx, uint8_t nRes, uint8_t source) : idxFirstResidual(idx), nResiduals(nRes), sourceId(source) {}
+  TrackDataCompact(uint32_t idx, uint8_t nRes, uint8_t source, uint8_t nextraRes = 0) : idxFirstResidual(idx), nResiduals(nRes), sourceId(source), nExtDetResid(nextraRes) {}
   uint32_t idxFirstResidual; ///< the index of the first residual from this track
-  uint8_t nResiduals;        ///< total number of residuals associated to this track
+  uint8_t nResiduals;        ///< total number of TPC residuals associated to this track
+  uint8_t nExtDetResid = 0;  ///< number of external detectors (wrt TPC) residuals stored, on top of clIdx.getEntries
   uint8_t sourceId;          ///< source ID obtained from the global track ID
-  ClassDefNV(TrackDataCompact, 1);
+  ClassDefNV(TrackDataCompact, 2);
 };
 
 // TODO add to UnbinnedResid::sec flag if cluster was used or not
@@ -110,7 +128,8 @@ struct TrackDataExtended {
   std::vector<o2::trd::CalibratedTracklet> clsTRD{}; ///< the TRD space points (if available)
   o2::tof::Cluster clsTOF{};                         ///< the TOF cluster (if available)
   o2::dataformats::RangeReference<> clIdx{};         ///< index of first cluster residual and total number of cluster residuals of this track
-  ClassDefNV(TrackDataExtended, 2);
+  uint8_t nExtDetResid = 0;                          ///< number of external detectors (to TPC) residuals stored, on top of clIdx.getEntries
+  ClassDefNV(TrackDataExtended, 3);
 };
 
 /// Structure filled for each track with track quality information and a vector with TPCClusterResiduals
@@ -121,12 +140,14 @@ struct TrackData {
   float chi2TPC{};                           ///< chi2 of TPC track
   float chi2ITS{};                           ///< chi2 of ITS track
   float chi2TRD{};                           ///< chi2 of TRD track
+
   unsigned short nClsTPC{};                  ///< number of attached TPC clusters
   unsigned short nClsITS{};                  ///< number of attached ITS clusters
   unsigned short nTrkltsTRD{};               ///< number of attached TRD tracklets
   unsigned short clAvailTOF{};               ///< whether or not track seed has a matched TOF cluster
-  o2::dataformats::RangeReference<> clIdx{}; ///< index of first cluster residual and total number of cluster residuals of this track
-  ClassDefNV(TrackData, 6);
+  uint8_t nExtDetResid = 0;                  ///< number of external detectors (to TPC) residuals stored, on top of clIdx.getEntries
+  o2::dataformats::RangeReference<> clIdx{}; ///< index of first cluster residual and total number of TPC cluster residuals of this track
+  ClassDefNV(TrackData, 7);
 };
 
 /// \class TrackInterpolation
@@ -265,6 +286,10 @@ class TrackInterpolation
   /// Set the centre of mass energy required for pT downsampling Tsalis function
   void setSqrtS(float s) { mSqrtS = s; }
 
+  void setExtDetResid(bool v) { mExtDetResid = v; }
+
+  int processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork, std::array<float, 2>* trkltTRDYZ = nullptr, std::array<float, 3>* trkltTRDCov = nullptr);
+
   // --------------------------------- output ---------------------------------------------
   std::vector<UnbinnedResid>& getClusterResiduals() { return mClRes; }
   std::vector<TrackDataCompact>& getTrackDataCompact() { return mTrackDataCompact; }
@@ -285,6 +310,7 @@ class TrackInterpolation
   int mMaxTracksPerTF{-1};                                      ///< max number of tracks to be processed per TF (-1 means there is no limit)
   int mAddTracksForMapPerTF{0};                                 ///< in case residuals from different track types are used for vDrift calibration and map creation this defines the statistics for the latter
   bool mDumpTrackPoints{false};                                 ///< dump also track points in ITS, TRD and TOF
+  bool mExtDetResid{true};                                      ///< produce unbinned residuals for external detectors
   bool mProcessSeeds{false};                                    ///< in case for global tracks also their shorter parts are processed separately
   bool mProcessITSTPConly{false};                               ///< flag, whether or not to extrapolate ITS-only through TPC
   o2::dataformats::GlobalTrackID::mask_t mSourcesConfigured;    ///< the track sources taken into account for extra-/interpolation
@@ -297,6 +323,7 @@ class TrackInterpolation
   std::vector<o2::globaltracking::RecoContainer::GlobalIDSet> mGIDtables{}; ///< GIDs of contributors from single detectors for each seed
   std::vector<float> mTrackTimes{};                                         ///< time estimates for all input tracks in micro seconds
   std::vector<o2::track::TrackParCov> mSeeds{};                             ///< seeding track parameters (ITS tracks)
+  std::vector<int> mParentID{};                                             ///< entry of more global parent track for skimmed seeds (-1: no parent)
   std::map<int, int> mTrackTypes;                                           ///< mapping of track source to array index in mTrackIndices
   std::array<std::vector<uint32_t>, 4> mTrackIndices;                       ///< keep GIDs of input tracks separately for each track type
   gsl::span<const TPCClRefElem> mTPCTracksClusIdx;                          ///< input TPC cluster indices from span
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index 015c0ef1df416..1daaa897e9756 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -18,7 +18,9 @@
 #include "SpacePoints/TrackInterpolation.h"
 #include "SpacePoints/TrackResiduals.h"
 #include "ITStracking/IOUtils.h"
+#include "ITSBase/GeometryTGeo.h"
 #include "TPCBase/ParameterElectronics.h"
+#include "TOFBase/Geo.h"
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTPC/Defs.h"
 #include "DataFormatsTRD/Constants.h"
@@ -30,6 +32,7 @@
 #include "TMath.h"
 #include "DataFormatsTPC/VDriftCorrFact.h"
 #include "Framework/Logger.h"
+#include "CCDB/BasicCCDBManager.h"
 #include <set>
 #include <algorithm>
 #include <random>
@@ -38,6 +41,71 @@ using namespace o2::tpc;
 using GTrackID = o2::dataformats::GlobalTrackID;
 using DetID = o2::detectors::DetID;
 
+bool UnbinnedResid::gInitDone = false;
+
+float UnbinnedResid::getAlpha() const
+{
+  if (!isITS()) {
+    return o2::math_utils::sector2Angle(sec % 18);
+  }
+  // ITS alpha repends on the chip ID
+  checkInitDone();
+  return o2::its::GeometryTGeo::Instance()->getSensorRefAlpha(channel);
+}
+
+float UnbinnedResid::getX() const
+{
+  if (isTPC()) {
+    return param::RowX[row];
+  }
+  checkInitDone();
+  if (isITS()) {
+    return o2::its::GeometryTGeo::Instance()->getSensorRefX(channel); // ITS X repends on the chip ID
+  }
+  if (isTRD()) {
+    auto geo = o2::trd::Geometry::instance();
+    ROOT::Math::Impl::Transform3D<double>::Point local{geo->cdrHght() - 0.5 - 0.279, 0., 0.}; // see TrackletTransformer::transformTracklet
+    return (geo->getMatrixT2L(channel) ^ local).X();
+  }
+  if (isTOF()) {
+    int det[5];
+    o2::tof::Geo::getVolumeIndices(channel + sec * o2::tof::Geo::NPADSXSECTOR, det);
+    float pos[3] = {0.f, 0.f, 0.f};
+    o2::tof::Geo::getPos(det, pos);
+    float posl[3] = {pos[0], pos[1], pos[2]};
+    o2::tof::Geo::rotateToSector(pos, sec);
+    return pos[2]; // coordinates in sector frame: note that the rotation above puts z in pos[1], the radial coordinate in pos[2], and the tangent coordinate in pos[0] (this is to match the TOF residual system, where we don't use the radial component), so we swap their positions.
+  }
+  LOGP(fatal, "Did not recognize detector type: row:{}, sec:{}, channel:{}", row, sec, channel);
+  return 0.;
+}
+
+void UnbinnedResid::checkInitDone()
+{
+  if (!gInitDone) {
+    LOGP(warn, "geometry initialization was not done, doing this for the current timestamp");
+    init();
+    if (!gInitDone) {
+      LOGP(fatal, "geometry initialization failed");
+    }
+  }
+}
+
+void UnbinnedResid::init(long timestamp)
+{
+  if (gInitDone) {
+    LOGP(warn, "Initialization was already done");
+    return;
+  }
+  if (!gGeoManager) {
+    o2::ccdb::BasicCCDBManager::instance().getSpecific<TGeoManager>("GLO/Config/GeometryAligned", timestamp);
+  }
+  auto geoTRD = o2::trd::Geometry::instance();
+  geoTRD->createPadPlaneArray();
+  geoTRD->createClusterMatrixArray();
+  gInitDone = true;
+}
+
 void TrackInterpolation::init(o2::dataformats::GlobalTrackID::mask_t src, o2::dataformats::GlobalTrackID::mask_t srcMap)
 {
   // perform initialization
@@ -65,6 +133,9 @@ void TrackInterpolation::init(o2::dataformats::GlobalTrackID::mask_t src, o2::da
   mTrackTypes.insert({GTrackID::ITSTPCTOF, 2});
   mTrackTypes.insert({GTrackID::ITSTPCTRDTOF, 3});
 
+  auto geom = o2::its::GeometryTGeo::Instance();
+  geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
+
   mInitDone = true;
   LOGP(info, "Done initializing TrackInterpolation. Configured track input: {}. Track input specifically for map: {}",
        GTrackID::getSourcesNames(mSourcesConfigured), mSingleSourcesConfigured ? "identical" : GTrackID::getSourcesNames(mSourcesConfiguredMap));
@@ -241,7 +312,7 @@ void TrackInterpolation::process()
   // set the input containers
   mTPCTracksClusIdx = mRecoCont->getTPCTracksClusterRefs();
   mTPCClusterIdxStruct = &mRecoCont->getTPCClusters();
-  if (mDumpTrackPoints) {
+  {
     if (!mITSDict) {
       LOG(error) << "No ITS dictionary available";
       return;
@@ -273,6 +344,9 @@ void TrackInterpolation::process()
   trackIndices.insert(trackIndices.end(), mTrackIndices[mTrackTypes[GTrackID::ITSTPC]].begin(), mTrackIndices[mTrackTypes[GTrackID::ITSTPC]].end());
 
   int nSeeds = mSeeds.size(), lastChecked = 0;
+  mParentID.clear();
+  mParentID.resize(nSeeds, -1);
+
   int maxOutputTracks = (mMaxTracksPerTF >= 0) ? mMaxTracksPerTF + mAddTracksForMapPerTF : nSeeds;
   mTrackData.reserve(maxOutputTracks);
   mClRes.reserve(maxOutputTracks * param::NPadRows);
@@ -292,6 +366,7 @@ void TrackInterpolation::process()
       this->mGIDtables.push_back(this->mRecoCont->getSingleDetectorRefs(this->mGIDs.back()));
       this->mTrackTimes.push_back(this->mTrackTimes[seedIndex]);
       this->mSeeds.push_back(this->mSeeds[seedIndex]);
+      this->mParentID.push_back(seedIndex); // store parent seed id
     };
 
     GTrackID::mask_t partsAdded;
@@ -378,6 +453,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
   trackData.gid = mGIDs[iSeed];
   trackData.par = mSeeds[iSeed];
   auto& trkWork = mSeeds[iSeed];
+  o2::track::TrackPar trkInner{trkWork};
   // reset the cache array (sufficient to set cluster available to zero)
   for (auto& elem : mCache) {
     elem.clAvailable = 0;
@@ -436,10 +512,13 @@ void TrackInterpolation::interpolateTrack(int iSeed)
       LOG(debug) << "Failed to rotate into TOF cluster sector frame";
       return;
     }
-    float clTOFX = clTOF.getX();
-    std::array<float, 2> clTOFYZ{clTOF.getY(), clTOF.getZ()};
+    float clTOFxyz[3] = {clTOF.getX(), clTOF.getY(), clTOF.getZ()};
+    if (!clTOF.isInNominalSector()) {
+      o2::tof::Geo::alignedToNominalSector(clTOFxyz, clTOFSec); // go from the aligned to nominal sector frame
+    }
+    std::array<float, 2> clTOFYZ{clTOFxyz[1], clTOFxyz[2]};
     std::array<float, 3> clTOFCov{mParams->sigYZ2TOF, 0.f, mParams->sigYZ2TOF}; // assume no correlation between y and z and equal cluster error sigma^2 = (3cm)^2 / 12
-    if (!propagator->PropagateToXBxByBz(trkWork, clTOFX, mParams->maxSnp, mParams->maxStep, mMatCorr)) {
+    if (!propagator->PropagateToXBxByBz(trkWork, clTOFxyz[0], mParams->maxSnp, mParams->maxStep, mMatCorr)) {
       LOG(debug) << "Failed final propagation to TOF radius";
       return;
     }
@@ -457,41 +536,15 @@ void TrackInterpolation::interpolateTrack(int iSeed)
       (*trackDataExtended).trkTRD = trkTRD;
     }
     for (int iLayer = o2::trd::constants::NLAYER - 1; iLayer >= 0; --iLayer) {
-      int trkltIdx = trkTRD.getTrackletIndex(iLayer);
-      if (trkltIdx < 0) {
-        // no TRD tracklet in this layer
+      std::array<float, 2> trkltTRDYZ{};
+      std::array<float, 3> trkltTRDCov{};
+      int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ, &trkltTRDCov);
+      if (res == -1) { // no TRD tracklet in this layer
         continue;
       }
-      const auto& trdSP = mRecoCont->getTRDCalibratedTracklets()[trkltIdx];
-      const auto& trdTrklt = mRecoCont->getTRDTracklets()[trkltIdx];
-      if (mDumpTrackPoints) {
-        (*trackDataExtended).trkltTRD.push_back(trdTrklt);
-        (*trackDataExtended).clsTRD.push_back(trdSP);
-      }
-      auto trkltDet = trdTrklt.getDetector();
-      auto trkltSec = trkltDet / (o2::trd::constants::NLAYER * o2::trd::constants::NSTACK);
-      if (trkltSec != o2::math_utils::angle2Sector(trkWork.getAlpha())) {
-        if (!trkWork.rotate(o2::math_utils::sector2Angle(trkltSec))) {
-          LOG(debug) << "Track could not be rotated in TRD tracklet coordinate system in layer " << iLayer;
-          return;
-        }
-      }
-      if (!propagator->PropagateToXBxByBz(trkWork, trdSP.getX(), mParams->maxSnp, mParams->maxStep, mMatCorr)) {
-        LOG(debug) << "Failed propagation to TRD layer " << iLayer;
+      if (res < -1) { // failed to reach this layer
         return;
       }
-
-      const auto* pad = mGeoTRD->getPadPlane(trkltDet);
-      float tilt = tan(TMath::DegToRad() * pad->getTiltingAngle()); // tilt is signed! and returned in degrees
-      float tiltCorrUp = tilt * (trdSP.getZ() - trkWork.getZ());
-      float zPosCorrUp = trdSP.getZ() + mRecoParam.getZCorrCoeffNRC() * trkWork.getTgl(); // maybe Z can be corrected on avarage already by the tracklet transformer?
-      float padLength = pad->getRowSize(trdTrklt.getPadRow());
-      if (!((trkWork.getSigmaZ2() < (padLength * padLength / 12.f)) && (std::fabs(trdSP.getZ() - trkWork.getZ()) < padLength))) {
-        tiltCorrUp = 0.f;
-      }
-      std::array<float, 2> trkltTRDYZ{trdSP.getY() - tiltCorrUp, zPosCorrUp};
-      std::array<float, 3> trkltTRDCov;
-      mRecoParam.recalcTrkltCov(tilt, trkWork.getSnp(), pad->getRowSize(trdTrklt.getPadRow()), trkltTRDCov);
       if (!trkWork.update(trkltTRDYZ, trkltTRDCov)) {
         LOG(debug) << "Failed to update track at TRD layer " << iLayer;
         return;
@@ -502,6 +555,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
   if (mDumpTrackPoints) {
     (*trackDataExtended).trkOuter = trkWork;
   }
+  auto trkOuter = trkWork; // outer param
 
   // go back through the TPC and store updated track positions
   bool outerParamStored = false;
@@ -594,13 +648,98 @@ void TrackInterpolation::interpolateTrack(int iSeed)
       }
     }
     trackData.clIdx.setEntries(nClValidated);
+
+    bool stopPropagation = !mExtDetResid;
+    if (!stopPropagation) {
+      // do we have TRD residuals to add?
+      trkWork = trkOuter;
+      if (gidTable[GTrackID::TRD].isIndexSet()) {
+        const auto& trkTRD = mRecoCont->getITSTPCTRDTrack<o2::trd::TrackTRD>(gidTable[GTrackID::ITSTPCTRD]);
+        for (int iLayer = 0; iLayer < o2::trd::constants::NLAYER; iLayer++) {
+          std::array<float, 2> trkltTRDYZ{};
+          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ);
+          if (res == -1) { // no traklet on this layer
+            continue;
+          }
+          if (res < -1) { // failed to reach this layer
+            stopPropagation = true;
+            break;
+          }
+
+          float tgPhi = trkWork.getSnp() / std::sqrt((1.f - trkWork.getSnp()) * (1.f + trkWork.getSnp()));
+          auto dy = trkltTRDYZ[0] - trkWork.getY();
+          auto dz = trkltTRDYZ[1] - trkWork.getZ();
+          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
+            mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 160 + iLayer, o2::math_utils::angle2Sector(trkWork.getAlpha()), (short)res);
+            trackData.nExtDetResid++;
+          }
+        }
+      }
+
+      // do we have TOF residual to add?
+      while (gidTable[GTrackID::TOF].isIndexSet() && !stopPropagation) {
+        const auto& clTOF = mRecoCont->getTOFClusters()[gidTable[GTrackID::TOF]];
+        float clTOFxyz[3] = {clTOF.getX(), clTOF.getY(), clTOF.getZ()};
+        if (!clTOF.isInNominalSector()) {
+          o2::tof::Geo::alignedToNominalSector(clTOFxyz, clTOF.getCount()); // go from the aligned to nominal sector frame
+        }
+        const float clTOFAlpha = o2::math_utils::sector2Angle(clTOF.getCount());
+        if (trkWork.getAlpha() != clTOFAlpha && !trkWork.rotate(clTOFAlpha)) {
+          LOG(debug) << "Failed to rotate into TOF cluster sector frame";
+          stopPropagation = true;
+          break;
+        }
+        if (!propagator->PropagateToXBxByBz(trkWork, clTOFxyz[0], mParams->maxSnp, mParams->maxStep, mMatCorr)) {
+          LOG(debug) << "Failed final propagation to TOF radius";
+          break;
+        }
+
+        float tgPhi = trkWork.getSnp() / std::sqrt((1.f - trkWork.getSnp()) * (1.f + trkWork.getSnp()));
+        auto dy = clTOFxyz[1] - trkWork.getY();
+        auto dz = clTOFxyz[2] - trkWork.getZ();
+        if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
+          mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 170, clTOF.getCount(), clTOF.getPadInSector());
+          trackData.nExtDetResid++;
+        }
+        break;
+      }
+
+      // add ITS residuals
+      while (!stopPropagation) {
+        auto& trkWorkITS = trkInner; // this is ITS outer param
+        auto nCl = trkITS.getNumberOfClusters();
+        auto clEntry = trkITS.getFirstClusterEntry();
+        auto geom = o2::its::GeometryTGeo::Instance();
+        for (int iCl = 0; iCl < nCl; iCl++) { // clusters are stored from outer to inner layers
+          const auto& cls = mITSClustersArray[mITSTrackClusIdx[clEntry + iCl]];
+          int chip = cls.getSensorID();
+          float chipX, chipAlpha;
+          geom->getSensorXAlphaRefPlane(cls.getSensorID(), chipX, chipAlpha);
+          if (!trkWorkITS.rotate(chipAlpha) || !propagator->PropagateToXBxByBz(trkWorkITS, chipX, mParams->maxSnp, mParams->maxStep, mMatCorr)) {
+            LOGP(debug, "Failed final propagation to ITS X={} alpha={}", chipX, chipAlpha);
+            stopPropagation = true;
+            break;
+          }
+          float tgPhi = trkWorkITS.getSnp() / std::sqrt((1.f - trkWorkITS.getSnp()) * (1.f + trkWorkITS.getSnp()));
+          auto dy = cls.getY() - trkWorkITS.getY();
+          auto dz = cls.getZ() - trkWorkITS.getZ();
+          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
+            mClRes.emplace_back(dy, dz, tgPhi, trkWorkITS.getY(), trkWorkITS.getZ(), 180 + geom->getLayer(cls.getSensorID()), -1, cls.getSensorID());
+            trackData.nExtDetResid++;
+          }
+        }
+        break;
+      }
+    }
+
+    mGIDsSuccess.push_back(mGIDs[iSeed]);
+    mTrackDataCompact.emplace_back(trackData.clIdx.getFirstEntry(), nClValidated, mGIDs[iSeed].getSource(), trackData.nExtDetResid);
     mTrackData.push_back(std::move(trackData));
     if (mDumpTrackPoints) {
       (*trackDataExtended).clIdx.setEntries(nClValidated);
+      (*trackDataExtended).nExtDetResid = trackData.nExtDetResid;
       mTrackDataExtended.push_back(std::move(*trackDataExtended));
     }
-    mGIDsSuccess.push_back(mGIDs[iSeed]);
-    mTrackDataCompact.emplace_back(mClRes.size() - nClValidated, nClValidated, mGIDs[iSeed].getSource());
   }
   if (mParams->writeUnfiltered) {
     TrackData trkDataTmp = trackData;
@@ -611,6 +750,46 @@ void TrackInterpolation::interpolateTrack(int iSeed)
   }
 }
 
+int TrackInterpolation::processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork,
+                                        std::array<float, 2>* trkltTRDYZ, std::array<float, 3>* trkltTRDCov)
+{
+  // return chamber ID (0:539) in case of successful processing, -1 if there is no TRD tracklet at given layer, -2 if processing failed
+  int trkltIdx = trkTRD.getTrackletIndex(iLayer);
+  if (trkltIdx < 0) {
+    return -1; // no TRD tracklet in this layer
+  }
+  const auto& trdSP = mRecoCont->getTRDCalibratedTracklets()[trkltIdx];
+  const auto& trdTrklt = mRecoCont->getTRDTracklets()[trkltIdx];
+  auto trkltDet = trdTrklt.getDetector();
+  auto trkltSec = trkltDet / (o2::trd::constants::NLAYER * o2::trd::constants::NSTACK);
+  if (trkltSec != o2::math_utils::angle2Sector(trkWork.getAlpha())) {
+    if (!trkWork.rotate(o2::math_utils::sector2Angle(trkltSec))) {
+      LOG(debug) << "Track could not be rotated in TRD tracklet coordinate system in layer " << iLayer;
+      return -2;
+    }
+  }
+  if (!o2::base::Propagator::Instance()->PropagateToXBxByBz(trkWork, trdSP.getX(), mParams->maxSnp, mParams->maxStep, mMatCorr)) {
+    LOG(debug) << "Failed propagation to TRD layer " << iLayer;
+    return -2;
+  }
+  if (trkltTRDYZ) {
+    const auto* pad = mGeoTRD->getPadPlane(trkltDet);
+    float tilt = tan(TMath::DegToRad() * pad->getTiltingAngle()); // tilt is signed! and returned in degrees
+    float tiltCorrUp = tilt * (trdSP.getZ() - trkWork.getZ());
+    float zPosCorrUp = trdSP.getZ() + mRecoParam.getZCorrCoeffNRC() * trkWork.getTgl(); // maybe Z can be corrected on avarage already by the tracklet transformer?
+    float padLength = pad->getRowSize(trdTrklt.getPadRow());
+    if (!((trkWork.getSigmaZ2() < (padLength * padLength / 12.f)) && (std::fabs(trdSP.getZ() - trkWork.getZ()) < padLength))) {
+      tiltCorrUp = 0.f;
+    }
+    (*trkltTRDYZ)[0] = trdSP.getY() - tiltCorrUp;
+    (*trkltTRDYZ)[1] = zPosCorrUp;
+    if (trkltTRDCov) {
+      mRecoParam.recalcTrkltCov(tilt, trkWork.getSnp(), pad->getRowSize(trdTrklt.getPadRow()), *trkltTRDCov);
+    }
+  }
+  return trkltDet;
+}
+
 void TrackInterpolation::extrapolateTrack(int iSeed)
 {
   // extrapolate ITS-only track through TPC and store residuals to TPC clusters in the output vectors
@@ -638,7 +817,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
   trackData.gid = mGIDs[iSeed];
   trackData.par = mSeeds[iSeed];
 
-  auto& trkWork = mSeeds[iSeed];
+  auto trkWork = mSeeds[iSeed];
   float clusterTimeBinOffset = mTrackTimes[iSeed] / mTPCTimeBinMUS;
   auto propagator = o2::base::Propagator::Instance();
   unsigned short rowPrev = 0; // used to calculate dRow of two consecutive cluster residuals
@@ -681,6 +860,13 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
     rowPrev = row;
     ++nMeasurements;
   }
+
+  TrackParams params; // for refitted track parameters and flagging rejected clusters
+  if (clusterResiduals.size() > constants::MAXGLOBALPADROW) {
+    LOGP(warn, "Extrapolated ITS-TPC track and found more reesiduals than possible ({})", clusterResiduals.size());
+    return;
+  }
+
   trackData.chi2TPC = trkTPC.getChi2();
   trackData.chi2ITS = trkITS.getChi2();
   trackData.nClsTPC = trkTPC.getNClusterReferences();
@@ -691,19 +877,14 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
     (*trackDataExtended).trkOuter = trkWork;
   }
 
-  TrackParams params; // for refitted track parameters and flagging rejected clusters
-  if (clusterResiduals.size() > constants::MAXGLOBALPADROW) {
-    LOGP(warn, "Extrapolated ITS-TPC track and found more reesiduals than possible ({})", clusterResiduals.size());
-    return;
-  }
   if (mParams->skipOutlierFiltering || validateTrack(trackData, params, clusterResiduals)) {
-    // track is good
-    int nClValidated = 0;
-    int iRow = 0;
-    for (unsigned int iCl = 0; iCl < clusterResiduals.size(); ++iCl) {
+    // track is good, store TPC part
+
+    int nClValidated = 0, iRow = 0;
+    unsigned int iCl = 0;
+    for (iCl = 0; iCl < clusterResiduals.size(); ++iCl) {
       iRow += clusterResiduals[iCl].dRow;
-      if (params.flagRej[iCl]) {
-        // skip masked cluster residual
+      if (iRow < param::NPadRows && params.flagRej[iCl]) { // skip masked cluster residual
         continue;
       }
       ++nClValidated;
@@ -712,19 +893,107 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
       const auto dz = clusterResiduals[iCl].dz;
       const auto y = clusterResiduals[iCl].y;
       const auto z = clusterResiduals[iCl].z;
-      const auto sec = clusterResiduals[iCl].sec;
       if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(y) < param::MaxY) && (std::abs(z) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
-        mClRes.emplace_back(dy, dz, tgPhi, y, z, iRow, sec);
+        mClRes.emplace_back(dy, dz, tgPhi, y, z, iRow, clusterResiduals[iCl].sec);
       } else {
         ++mRejectedResiduals;
       }
     }
     trackData.clIdx.setEntries(nClValidated);
+
+    bool stopPropagation = !mExtDetResid;
+    if (!stopPropagation) {
+      // do we have TRD residuals to add?
+      int iSeedFull = mParentID[iSeed] == -1 ? iSeed : mParentID[iSeed];
+      auto gidFull = mGIDs[iSeedFull];
+      const auto& gidTableFull = mGIDtables[iSeedFull];
+      if (gidTableFull[GTrackID::TRD].isIndexSet()) {
+        const auto& trkTRD = mRecoCont->getITSTPCTRDTrack<o2::trd::TrackTRD>(gidTableFull[GTrackID::ITSTPCTRD]);
+        for (int iLayer = 0; iLayer < o2::trd::constants::NLAYER; iLayer++) {
+          std::array<float, 2> trkltTRDYZ{};
+          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ);
+          if (res == -1) { // no traklet on this layer
+            continue;
+          }
+          if (res < -1) { // failed to reach this layer
+            stopPropagation = true;
+            break;
+          }
+
+          float tgPhi = trkWork.getSnp() / std::sqrt((1.f - trkWork.getSnp()) * (1.f + trkWork.getSnp()));
+          auto dy = trkltTRDYZ[0] - trkWork.getY();
+          auto dz = trkltTRDYZ[1] - trkWork.getZ();
+          const auto sec = clusterResiduals[iCl].sec;
+          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
+            mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 160 + iLayer, o2::math_utils::angle2Sector(trkWork.getAlpha()), (short)res);
+            trackData.nTrkltsTRD++;
+            trackData.nExtDetResid++;
+          }
+        }
+      }
+
+      // do we have TOF residual to add?
+      while (gidTableFull[GTrackID::TOF].isIndexSet() && !stopPropagation) {
+        const auto& clTOF = mRecoCont->getTOFClusters()[gidTableFull[GTrackID::TOF]];
+        const float clTOFAlpha = o2::math_utils::sector2Angle(clTOF.getCount());
+        float clTOFxyz[3] = {clTOF.getX(), clTOF.getY(), clTOF.getZ()};
+        if (!clTOF.isInNominalSector()) {
+          o2::tof::Geo::alignedToNominalSector(clTOFxyz, clTOF.getCount()); // go from the aligned to nominal sector frame
+        }
+        if (trkWork.getAlpha() != clTOFAlpha && !trkWork.rotate(clTOFAlpha)) {
+          LOG(debug) << "Failed to rotate into TOF cluster sector frame";
+          stopPropagation = true;
+          break;
+        }
+        if (!propagator->PropagateToXBxByBz(trkWork, clTOFxyz[0], mParams->maxSnp, mParams->maxStep, mMatCorr)) {
+          LOG(debug) << "Failed final propagation to TOF radius";
+          break;
+        }
+
+        float tgPhi = trkWork.getSnp() / std::sqrt((1.f - trkWork.getSnp()) * (1.f + trkWork.getSnp()));
+        auto dy = clTOFxyz[1] - trkWork.getY();
+        auto dz = clTOFxyz[2] - trkWork.getZ();
+        if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
+          mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 170, clTOF.getCount(), clTOF.getPadInSector());
+          trackData.clAvailTOF = 1;
+          trackData.nExtDetResid++;
+        }
+        break;
+      }
+
+      // add ITS residuals
+      while (!stopPropagation) {
+        o2::track::TrackPar trkWorkITS{trackData.par}; // this is ITS outer param
+        auto nCl = trkITS.getNumberOfClusters();
+        auto clEntry = trkITS.getFirstClusterEntry();
+        auto geom = o2::its::GeometryTGeo::Instance();
+        for (int iCl = 0; iCl < nCl; iCl++) { // clusters are stored from outer to inner layers
+          const auto& cls = mITSClustersArray[mITSTrackClusIdx[clEntry + iCl]];
+          int chip = cls.getSensorID();
+          float chipX, chipAlpha;
+          geom->getSensorXAlphaRefPlane(cls.getSensorID(), chipX, chipAlpha);
+          if (!trkWorkITS.rotate(chipAlpha) || !propagator->PropagateToXBxByBz(trkWorkITS, chipX, mParams->maxSnp, mParams->maxStep, mMatCorr)) {
+            LOGP(debug, "Failed final propagation to ITS X={} alpha={}", chipX, chipAlpha);
+            stopPropagation = true;
+            break;
+          }
+          float tgPhi = trkWorkITS.getSnp() / std::sqrt((1.f - trkWorkITS.getSnp()) * (1.f + trkWorkITS.getSnp()));
+          auto dy = cls.getY() - trkWorkITS.getY();
+          auto dz = cls.getZ() - trkWorkITS.getZ();
+          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
+            mClRes.emplace_back(dy, dz, tgPhi, trkWorkITS.getY(), trkWorkITS.getZ(), 180 + geom->getLayer(cls.getSensorID()), -1, cls.getSensorID());
+            trackData.nExtDetResid++;
+          }
+        }
+        break;
+      }
+    }
     mTrackData.push_back(std::move(trackData));
     mGIDsSuccess.push_back(mGIDs[iSeed]);
-    mTrackDataCompact.emplace_back(mClRes.size() - nClValidated, nClValidated, mGIDs[iSeed].getSource());
+    mTrackDataCompact.emplace_back(trackData.clIdx.getFirstEntry(), nClValidated, mGIDs[iSeed].getSource(), trackData.nExtDetResid);
     if (mDumpTrackPoints) {
       (*trackDataExtended).clIdx.setEntries(nClValidated);
+      (*trackDataExtended).nExtDetResid = trackData.nExtDetResid;
       mTrackDataExtended.push_back(std::move(*trackDataExtended));
     }
   }

From 8e291428afdf366d367762aba37c2007ac067204 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 20 Aug 2025 14:32:00 +0200
Subject: [PATCH 0736/1764] GPU Workflow: Don't load ITS geometry when ITS is
 not used

---
 GPU/Workflow/src/GPUWorkflowSpec.cxx | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 6aa4b753f9300..0ca3f741b7247 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -613,7 +613,7 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
   auto lockDecodeInput = std::make_unique<std::lock_guard<std::mutex>>(mPipeline->mutexDecodeInput);
 
   GRPGeomHelper::instance().checkUpdates(pc);
-  if (pc.inputs().getPos("itsTGeo") >= 0) {
+  if (mSpecConfig.runITSTracking && pc.inputs().getPos("itsTGeo") >= 0) {
     pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
   }
   if (GRPGeomHelper::instance().getGRPECS()->isDetReadOut(o2::detectors::DetID::TPC) && mConfParam->tpcTriggeredMode ^ !GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::TPC)) {
@@ -1045,7 +1045,7 @@ void GPURecoWorkflowSpec::doCalibUpdates(o2::framework::ProcessingContext& pc, c
     mGRPGeomUpdated = false;
     needCalibUpdate = true;
 
-    if (!mITSGeometryCreated) {
+    if (mSpecConfig.runITSTracking && !mITSGeometryCreated) {
       o2::its::GeometryTGeo* geom = o2::its::GeometryTGeo::Instance();
       geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G));
       mITSGeometryCreated = true;
@@ -1078,15 +1078,13 @@ void GPURecoWorkflowSpec::doCalibUpdates(o2::framework::ProcessingContext& pc, c
       }
       mMatLUTCreated = true;
     }
-    if (!mTRDGeometryCreated) {
-      if (mSpecConfig.readTRDtracklets) {
-        auto gm = o2::trd::Geometry::instance();
-        gm->createPadPlaneArray();
-        gm->createClusterMatrixArray();
-        mTRDGeometry = std::make_unique<o2::trd::GeometryFlat>(*gm);
-        newCalibObjects.trdGeometry = mConfig->configCalib.trdGeometry = mTRDGeometry.get();
-        LOG(info) << "Loaded TRD geometry";
-      }
+    if (mSpecConfig.readTRDtracklets && !mTRDGeometryCreated) {
+      auto gm = o2::trd::Geometry::instance();
+      gm->createPadPlaneArray();
+      gm->createClusterMatrixArray();
+      mTRDGeometry = std::make_unique<o2::trd::GeometryFlat>(*gm);
+      newCalibObjects.trdGeometry = mConfig->configCalib.trdGeometry = mTRDGeometry.get();
+      LOG(info) << "Loaded TRD geometry";
       mTRDGeometryCreated = true;
     }
   }

From 1eb10b8c782cc32782380b62efb7b2ad019d0760 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 20 Aug 2025 15:03:37 +0200
Subject: [PATCH 0737/1764] GPU Workflow: Do not do calib requests / updates in
 gpu-reconstruction-prepare

---
 GPU/Workflow/src/GPUWorkflowPipeline.cxx |  2 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx     | 64 +++++++++++++-----------
 2 files changed, 36 insertions(+), 30 deletions(-)

diff --git a/GPU/Workflow/src/GPUWorkflowPipeline.cxx b/GPU/Workflow/src/GPUWorkflowPipeline.cxx
index 5aca7502d8e91..a09fdac988d1a 100644
--- a/GPU/Workflow/src/GPUWorkflowPipeline.cxx
+++ b/GPU/Workflow/src/GPUWorkflowPipeline.cxx
@@ -177,7 +177,7 @@ int32_t GPURecoWorkflowSpec::handlePipeline(ProcessingContext& pc, GPUTrackingIn
     ptrs.tpcZS = &tpcZS;
   }
   if (mSpecConfig.enableDoublePipeline == 2) {
-    auto prepareBuffer = pc.outputs().make<DataAllocator::UninitializedVector<char>>(Output{gDataOriginGPU, "PIPELINEPREPARE", 0}, 0u);
+    auto prepareDummyMessage = pc.outputs().make<DataAllocator::UninitializedVector<char>>(Output{gDataOriginGPU, "PIPELINEPREPARE", 0}, 0u);
 
     size_t ptrsTotal = 0;
     const void* firstPtr = nullptr;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 0ca3f741b7247..51e3f252811c3 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -613,11 +613,13 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
   auto lockDecodeInput = std::make_unique<std::lock_guard<std::mutex>>(mPipeline->mutexDecodeInput);
 
   GRPGeomHelper::instance().checkUpdates(pc);
-  if (mSpecConfig.runITSTracking && pc.inputs().getPos("itsTGeo") >= 0) {
-    pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
-  }
-  if (GRPGeomHelper::instance().getGRPECS()->isDetReadOut(o2::detectors::DetID::TPC) && mConfParam->tpcTriggeredMode ^ !GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::TPC)) {
-    LOG(fatal) << "configKeyValue tpcTriggeredMode does not match GRP isDetContinuousReadOut(TPC) setting";
+  if (mSpecConfig.enableDoublePipeline != 2) {
+    if (mSpecConfig.runITSTracking && pc.inputs().getPos("itsTGeo") >= 0) {
+      pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
+    }
+    if (GRPGeomHelper::instance().getGRPECS()->isDetReadOut(o2::detectors::DetID::TPC) && mConfParam->tpcTriggeredMode ^ !GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::TPC)) {
+      LOG(fatal) << "configKeyValue tpcTriggeredMode does not match GRP isDetContinuousReadOut(TPC) setting";
+    }
   }
 
   GPUTrackingInOutPointers ptrs;
@@ -630,23 +632,25 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
   mTFSettings->hasNHBFPerTF = 1;
   mTFSettings->nHBFPerTF = mConfParam->overrideNHbfPerTF ? mConfParam->overrideNHbfPerTF : GRPGeomHelper::instance().getGRPECS()->getNHBFPerTF();
   mTFSettings->hasRunStartOrbit = 0;
-  if (mVerbosity) {
-    LOG(info) << "TF firstTForbit " << mTFSettings->tfStartOrbit << " nHBF " << mTFSettings->nHBFPerTF << " runStartOrbit " << mTFSettings->runStartOrbit << " simStartOrbit " << mTFSettings->simStartOrbit;
-  }
   ptrs.settingsTF = mTFSettings.get();
 
-  if (mConfParam->checkFirstTfOrbit) {
-    static uint32_t lastFirstTFOrbit = -1;
-    static uint32_t lastTFCounter = -1;
-    if (lastFirstTFOrbit != -1 && lastTFCounter != -1) {
-      int32_t diffOrbit = tinfo.firstTForbit - lastFirstTFOrbit;
-      int32_t diffCounter = tinfo.tfCounter - lastTFCounter;
-      if (diffOrbit != diffCounter * mTFSettings->nHBFPerTF) {
-        LOG(error) << "Time frame has mismatching firstTfOrbit - Last orbit/counter: " << lastFirstTFOrbit << " " << lastTFCounter << " - Current: " << tinfo.firstTForbit << " " << tinfo.tfCounter;
+  if (mSpecConfig.enableDoublePipeline != 2) {
+    if (mVerbosity) {
+      LOG(info) << "TF firstTForbit " << mTFSettings->tfStartOrbit << " nHBF " << mTFSettings->nHBFPerTF << " runStartOrbit " << mTFSettings->runStartOrbit << " simStartOrbit " << mTFSettings->simStartOrbit;
+    }
+    if (mConfParam->checkFirstTfOrbit) {
+      static uint32_t lastFirstTFOrbit = -1;
+      static uint32_t lastTFCounter = -1;
+      if (lastFirstTFOrbit != -1 && lastTFCounter != -1) {
+        int32_t diffOrbit = tinfo.firstTForbit - lastFirstTFOrbit;
+        int32_t diffCounter = tinfo.tfCounter - lastTFCounter;
+        if (diffOrbit != diffCounter * mTFSettings->nHBFPerTF) {
+          LOG(error) << "Time frame has mismatching firstTfOrbit - Last orbit/counter: " << lastFirstTFOrbit << " " << lastTFCounter << " - Current: " << tinfo.firstTForbit << " " << tinfo.tfCounter;
+        }
       }
+      lastFirstTFOrbit = tinfo.firstTForbit;
+      lastTFCounter = tinfo.tfCounter;
     }
-    lastFirstTFOrbit = tinfo.firstTForbit;
-    lastTFCounter = tinfo.tfCounter;
   }
 
   o2::globaltracking::RecoContainer inputTracksTRD;
@@ -1142,12 +1146,12 @@ Inputs GPURecoWorkflowSpec::inputs()
   } else if (mSpecConfig.enableDoublePipeline == 1) {
     inputs.emplace_back("pipelineprepare", gDataOriginGPU, "PIPELINEPREPARE", 0, Lifetime::Timeframe);
   }
-  if (mSpecConfig.outputTracks || mSpecConfig.caClusterer) {
+  if (mSpecConfig.enableDoublePipeline != 2 && (mSpecConfig.outputTracks || mSpecConfig.caClusterer)) {
     // calibration objects for TPC clusterization
     inputs.emplace_back("tpcgain", gDataOriginTPC, "PADGAINFULL", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::CalPadGainFull)));
     inputs.emplace_back("tpcaltrosync", gDataOriginTPC, "ALTROSYNCSIGNAL", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::AltroSyncSignal)));
   }
-  if (mSpecConfig.outputTracks) {
+  if (mSpecConfig.enableDoublePipeline != 2 && mSpecConfig.outputTracks) {
     // calibration objects for TPC tracking
     const auto mapSources = mSpecConfig.tpcDeadMapSources;
     if (mapSources != 0) {
@@ -1217,15 +1221,17 @@ Inputs GPURecoWorkflowSpec::inputs()
     } else if (mSpecConfig.itsTriggerType == 2) {
       inputs.emplace_back("phystrig", "TRD", "TRKTRGRD", 0, Lifetime::Timeframe);
     }
-    if (mSpecConfig.isITS3) {
-      inputs.emplace_back("cldict", "IT3", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("IT3/Calib/ClusterDictionary"));
-      inputs.emplace_back("alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
-    } else {
-      inputs.emplace_back("itscldict", "ITS", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
-      inputs.emplace_back("itsalppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
-    }
-    if (mSpecConfig.itsOverrBeamEst) {
-      inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
+    if (mSpecConfig.enableDoublePipeline != 2) {
+      if (mSpecConfig.isITS3) {
+        inputs.emplace_back("cldict", "IT3", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("IT3/Calib/ClusterDictionary"));
+        inputs.emplace_back("alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+      } else {
+        inputs.emplace_back("itscldict", "ITS", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
+        inputs.emplace_back("itsalppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+      }
+      if (mSpecConfig.itsOverrBeamEst) {
+        inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
+      }
     }
     if (mSpecConfig.processMC) {
       inputs.emplace_back("itsmclabels", "ITS", "CLUSTERSMCTR", 0, Lifetime::Timeframe);

From 4a450cf93ee5aac56a88dff846b1a3fcea921a76 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 22 Aug 2025 11:08:43 +0200
Subject: [PATCH 0738/1764] GPU HIP: Ignore comments in hipification template
 file check

---
 GPU/GPUTracking/Base/hip/CMakeLists.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 5acbaa28bf36f..17bbf46795761 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -63,8 +63,9 @@ if(NOT DEFINED GPUCA_HIP_HIPIFY_FROM_CUDA OR "${GPUCA_HIP_HIPIFY_FROM_CUDA}")
   endforeach()
 
   add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_HIPIFIED_CHK.done
-                     COMMAND diff -u ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPkernel.template.hip ${CMAKE_CURRENT_SOURCE_DIR}/GPUReconstructionHIPkernel.template.hip > ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_HIPIFIED_CHK.done
+                     COMMAND bash -c "diff -u <(sed 's,//.*$,,g' ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPkernel.template.hip) <(sed 's,//.*$,,g' ${CMAKE_CURRENT_SOURCE_DIR}/GPUReconstructionHIPkernel.template.hip) > ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_HIPIFIED_CHK.done"
                      DEPENDS ${GPUCA_HIP_SOURCE_DIR}/GPUReconstructionHIPkernel.template.hip ${CMAKE_CURRENT_SOURCE_DIR}/GPUReconstructionHIPkernel.template.hip
+                     VERBATIM
                      COMMENT "Checking HIPified file ${CMAKE_CURRENT_SOURCE_DIR}/GPUReconstructionHIPkernel.template.hip")
   add_custom_target(${MODULE}_HIPIFIED_CHK ALL DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${MODULE}_HIPIFIED_CHK.done)
 else()

From c86ea4ed59b4dc88f615f0fc932de026f58e5477 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 19 Aug 2025 14:32:19 +0200
Subject: [PATCH 0739/1764] TPC Workflow: Don't write triggerwords if they are
 not created

---
 Detectors/TPC/workflow/src/RecoWorkflow.cxx                     | 2 +-
 .../Base/hip/GPUReconstructionHIPkernel.template.hip            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index 0ccc3d73f115c..132d85bfce790 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -434,7 +434,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
                                    (caClusterer || decompressTPC || inputType == InputType::PassThrough) && !isEnabled(OutputType::SendClustersPerSector)));
   }
 
-  if ((isEnabled(OutputType::TPCTriggers) || caClusterer) && !isEnabled(OutputType::DisableWriter)) {
+  if ((isEnabled(OutputType::TPCTriggers) || (caClusterer && runGPUReco)) && !isEnabled(OutputType::DisableWriter)) {
     specs.push_back(o2::tpc::getTPCTriggerWriterSpec());
   }
 
diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
index d5ac1d14c2d9e..30a84dfa135eb 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUReconstructionHIPkernel.cu
+/// \file GPUReconstructionHIPkernel.hip
 /// \author David Rohr
 
 #define GPUCA_GPUCODE_COMPILEKERNELS

From 012946b0d2041fa4c0663c5204cedadb8b66612f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 14 Aug 2025 10:12:51 +0200
Subject: [PATCH 0740/1764] GPU CMake: Force using alidist GCC for host
 compilation of CUDA/HIP code

---
 dependencies/FindO2GPU.cmake | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 633d1220575db..032d02aabe5db 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 1
+# FindO2GPU.cmake Version 2
 
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
@@ -125,6 +125,8 @@ if(ENABLE_CUDA)
     if(GPUCA_CUDA_GCCBIN)
       message(STATUS "Using as CUDA GCC version: ${GPUCA_CUDA_GCCBIN}")
       set(CMAKE_CUDA_HOST_COMPILER "${GPUCA_CUDA_GCCBIN}")
+    elseif(DEFINED ENV{GCC_TOOLCHAIN_ROOT})
+      set(CMAKE_CUDA_HOST_COMPILER "$ENV{GCC_TOOLCHAIN_ROOT}/bin/gcc")
     endif()
     enable_language(CUDA)
     get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
@@ -278,6 +280,12 @@ if(ENABLE_HIP)
       endif()
     endif()
     if (CMAKE_HIP_COMPILER)
+      if(GPUCA_HIP_GCCBIN)
+        message(STATUS "Using as HIP GCC version: ${GPUCA_HIP_GCCBIN}")
+        set(CMAKE_HIP_HOST_COMPILER "${GPUCA_HIP_GCCBIN}")
+      elseif(DEFINED ENV{GCC_TOOLCHAIN_ROOT})
+        set(CMAKE_HIP_HOST_COMPILER "$ENV{GCC_TOOLCHAIN_ROOT}/bin/gcc")
+      endif()
       enable_language(HIP)
       message(STATUS "HIP language enabled: ${CMAKE_HIP_COMPILER}")
     endif()

From d375e634783f1211e7ca00e57535a431094bc5cb Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 25 Aug 2025 11:40:23 +0200
Subject: [PATCH 0741/1764] DPL Analysis: centralised CCDB support in analysis
 (#14567)

Thanks to the newly added binary view columns we can finally support
proper CCDB integration in analysis.

In order to do so, the user needs to create a TIMESTAMPED table, i.e. a table
which is an extension of another one where the timestamps for each rows
are provided. The extra columns of such timestamped table will be CCDB columns
where the iterator of each provides access for one specified CCDB object.

Notice the PR duplicates the CCDB code run in reconstruction and the additional
device will never be added to the topology if running online, so there are no expected
side effects.
---
 Framework/CCDBSupport/CMakeLists.txt          |  21 +-
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   | 188 ++++++++++++
 .../CCDBSupport/src/AnalysisCCDBHelpers.h     |  25 ++
 .../CCDBSupport/src/CCDBFetcherHelper.cxx     | 279 ++++++++++++++++++
 Framework/CCDBSupport/src/CCDBFetcherHelper.h | 109 +++++++
 Framework/CCDBSupport/src/Plugin.cxx          |   9 +
 .../CCDBSupport/test/test_CCDBHelpers.cxx     |  52 ++--
 Framework/Core/include/Framework/ASoA.h       |  90 ++++++
 .../Core/include/Framework/AnalysisContext.h  |  10 +-
 .../Core/include/Framework/AnalysisHelpers.h  |  38 ++-
 .../Framework/AnalysisSupportHelpers.h        |   5 +
 .../Core/include/Framework/AnalysisTask.h     |  10 +-
 Framework/Core/src/ASoA.cxx                   |  63 +++-
 Framework/Core/src/AnalysisSupportHelpers.cxx |  29 ++
 Framework/Core/src/ArrowSupport.cxx           |  29 ++
 Framework/Core/src/WorkflowHelpers.cxx        |  38 +++
 Framework/TestWorkflows/CMakeLists.txt        |   5 +
 .../TestWorkflows/src/o2TestAnalysisCCDB.cxx  |  69 +++++
 18 files changed, 1027 insertions(+), 42 deletions(-)
 create mode 100644 Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
 create mode 100644 Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
 create mode 100644 Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
 create mode 100644 Framework/CCDBSupport/src/CCDBFetcherHelper.h
 create mode 100644 Framework/TestWorkflows/src/o2TestAnalysisCCDB.cxx

diff --git a/Framework/CCDBSupport/CMakeLists.txt b/Framework/CCDBSupport/CMakeLists.txt
index e4310ac5e0ec5..ed898fb3114aa 100644
--- a/Framework/CCDBSupport/CMakeLists.txt
+++ b/Framework/CCDBSupport/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# Copyright 2019-2025 CERN and copyright holders of ALICE O2.
 # See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 # All rights not expressly granted are reserved.
 #
@@ -9,14 +9,21 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 o2_add_library(FrameworkCCDBSupport
-               SOURCES 
+               SOURCES
                 src/Plugin.cxx
+                src/CCDBFetcherHelper.cxx
                 src/CCDBHelpers.cxx
+                src/AnalysisCCDBHelpers.cxx
                PRIVATE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_LIST_DIR}/src
                PUBLIC_LINK_LIBRARIES O2::Framework O2::CCDB)
 
-o2_add_test(CCDBHelpers NAME test_Framework_test_CCDBHelpers
-            SOURCES test/test_CCDBHelpers.cxx
-            COMPONENT_NAME Framework
-            LABELS framework
-            PUBLIC_LINK_LIBRARIES O2::Framework O2::FrameworkCCDBSupport)
+add_executable(o2-test-framework-ccdbsupport
+               test/test_CCDBHelpers.cxx)
+target_link_libraries(o2-test-framework-ccdbsupport PRIVATE O2::Framework)
+target_link_libraries(o2-test-framework-ccdbsupport PRIVATE O2::FrameworkCCDBSupport)
+target_link_libraries(o2-test-framework-ccdbsupport PRIVATE O2::Catch2)
+
+get_filename_component(outdir ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/../tests ABSOLUTE)
+set_property(TARGET o2-test-framework-ccdbsupport PROPERTY RUNTIME_OUTPUT_DIRECTORY ${outdir})
+
+add_test(NAME framework:ccdbsupport COMMAND o2-test-framework-ccdbsupport --skip-benchmarks)
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
new file mode 100644
index 0000000000000..aba1f3ed4e13d
--- /dev/null
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -0,0 +1,188 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "AnalysisCCDBHelpers.h"
+#include "CCDBFetcherHelper.h"
+#include "Framework/DeviceSpec.h"
+#include "Framework/TimingInfo.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/DataTakingContext.h"
+#include "Framework/RawDeviceService.h"
+#include "Framework/Output.h"
+#include "Framework/Signpost.h"
+#include "Framework/AnalysisContext.h"
+#include "Framework/ConfigContext.h"
+#include "Framework/ConfigContext.h"
+#include <arrow/array/builder_binary.h>
+#include <arrow/type.h>
+#include <arrow/type_fwd.h>
+#include <arrow/util/key_value_metadata.h>
+#include <arrow/table.h>
+#include <arrow/array.h>
+#include <arrow/builder.h>
+#include <fmt/base.h>
+#include <ctime>
+#include <memory>
+#include <unordered_map>
+
+O2_DECLARE_DYNAMIC_LOG(ccdb);
+
+namespace o2::framework
+{
+// Fill valid routes. Notice that for analysis the timestamps are associated to
+// a ATIM table and there might be multiple CCDB objects of the same kind for
+// dataframe.
+// For this reason rather than matching the Lifetime::Condition, we match the
+// origin.
+namespace
+{
+void fillValidRoutes(CCDBFetcherHelper& helper, std::vector<o2::framework::OutputRoute> const& outputRoutes, std::unordered_map<std::string, int>& bindings)
+{
+  for (auto& route : outputRoutes) {
+    auto originMatcher = DataSpecUtils::asConcreteDataMatcher(route.matcher);
+    if (originMatcher.origin != header::DataOrigin{"ATIM"}) {
+      continue;
+    }
+    auto specStr = DataSpecUtils::describe(route.matcher);
+    if (bindings.find(specStr) != bindings.end()) {
+      continue;
+    }
+    bindings[specStr] = helper.routes.size();
+    helper.routes.push_back(route);
+    LOGP(info, "The following route needs condition objects {} ", DataSpecUtils::describe(route.matcher));
+    for (auto& metadata : route.matcher.metadata) {
+      if (metadata.type == VariantType::String) {
+        LOGP(info, "- {}: {}", metadata.name, metadata.defaultValue.asString());
+      }
+    }
+  }
+}
+} // namespace
+
+AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
+{
+  auto& ac = ctx.services().get<AnalysisContext>();
+  std::vector<std::shared_ptr<arrow::Schema>> schemas;
+  auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
+
+  for (auto& input : ac.analysisCCDBInputs) {
+    std::vector<std::shared_ptr<arrow::Field>> fields;
+    schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
+    schemaMetadata->Append("outputBinding", input.binding);
+
+    for (auto& m : input.metadata) {
+      // Save the list of input tables
+      if (m.name.starts_with("input:")) {
+        auto name = m.name.substr(6);
+        schemaMetadata->Append("sourceTable", name);
+        continue;
+      }
+      // Ignore the non ccdb: entries
+      if (!m.name.starts_with("ccdb:")) {
+        continue;
+      }
+      // Create the schema of the output
+      auto metadata = std::make_shared<arrow::KeyValueMetadata>();
+      metadata->Append("url", m.defaultValue.asString());
+      auto columnName = m.name.substr(strlen("ccdb:"));
+      fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
+    }
+    schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
+  }
+  return adaptStateful([schemas](CallbackService& callbacks, ConfigParamRegistry const& options, DeviceSpec const& spec) {
+    std::shared_ptr<CCDBFetcherHelper> helper = std::make_shared<CCDBFetcherHelper>();
+    CCDBFetcherHelper::initialiseHelper(*helper, options);
+    std::unordered_map<std::string, int> bindings;
+    fillValidRoutes(*helper, spec.outputs, bindings);
+
+    return adaptStateless([schemas, bindings, helper](InputRecord& inputs, DataTakingContext& dtc, DataAllocator& allocator, TimingInfo& timingInfo) {
+      O2_SIGNPOST_ID_GENERATE(sid, ccdb);
+      O2_SIGNPOST_START(ccdb, sid, "fetchFromAnalysisCCDB", "Fetching CCDB objects for analysis%" PRIu64, (uint64_t)timingInfo.timeslice);
+      for (auto& schema : schemas) {
+        std::vector<CCDBFetcherHelper::FetchOp> ops;
+        auto inputBinding = *schema->metadata()->Get("sourceTable");
+        auto outRouteDesc = *schema->metadata()->Get("outputRoute");
+        std::string outBinding = *schema->metadata()->Get("outputBinding");
+        O2_SIGNPOST_EVENT_EMIT_INFO(ccdb, sid, "fetchFromAnalysisCCDB",
+                                    "Fetching CCDB objects for %{public}s's columns with timestamps from %{public}s and putting them in route %{public}s",
+                                    outBinding.c_str(), inputBinding.c_str(), outRouteDesc.c_str());
+        auto ref = inputs.get<TableConsumer>(inputBinding);
+        auto table = ref->asArrowTable();
+        // FIXME: make the fTimestamp column configurable.
+        auto timestampColumn = table->GetColumnByName("fTimestamp");
+        O2_SIGNPOST_EVENT_EMIT_INFO(ccdb, sid, "fetchFromAnalysisCCDB",
+                                    "There are %zu bindings available", bindings.size());
+        for (auto& binding : bindings) {
+          O2_SIGNPOST_EVENT_EMIT_INFO(ccdb, sid, "fetchFromAnalysisCCDB",
+                                      "* %{public}s: %d",
+                                      binding.first.c_str(), binding.second);
+        }
+        int outputRouteIndex = bindings.at(outRouteDesc);
+        auto& spec = helper->routes[outputRouteIndex].matcher;
+        std::vector<std::shared_ptr<arrow::BinaryViewBuilder>> builders;
+        for (auto& _ : schema->fields()) {
+          builders.emplace_back(std::make_shared<arrow::BinaryViewBuilder>());
+        }
+
+        for (size_t ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
+          std::shared_ptr<arrow::Array> chunk = timestampColumn->chunk(ci);
+          auto const* timestamps = chunk->data()->GetValuesSafe<size_t>(1);
+
+          for (int64_t ri = 0; ri < chunk->data()->length; ri++) {
+            ops.clear();
+            int64_t timestamp = timestamps[ri];
+            for (auto& field : schema->fields()) {
+              auto url = *field->metadata()->Get("url");
+              // Time to actually populate the blob
+              ops.push_back({
+                .spec = spec,
+                .url = url,
+                .timestamp = timestamp,
+                .runNumber = 1,
+                .runDependent = 0,
+                .queryRate = 0,
+              });
+            }
+            auto responses = CCDBFetcherHelper::populateCacheWith(helper, ops, timingInfo, dtc, allocator);
+            O2_SIGNPOST_START(ccdb, sid, "handlingResponses",
+                              "Got %zu responses from server.",
+                              responses.size());
+            if (builders.size() != responses.size()) {
+              LOGP(fatal, "Not enough responses (expected {}, found {})", builders.size(), responses.size());
+            }
+            arrow::Status result;
+            for (size_t bi = 0; bi < responses.size(); bi++) {
+              auto& builder = builders[bi];
+              auto& response = responses[bi];
+              char const* address = reinterpret_cast<char const*>(response.id.value);
+              result &= builder->Append(std::string_view(address, response.size));
+            }
+            if (!result.ok()) {
+              LOGP(fatal, "Error adding results from CCDB");
+            }
+            O2_SIGNPOST_END(ccdb, sid, "handlingResponses", "Done processing responses");
+          }
+        }
+        arrow::ArrayVector arrays;
+        for (auto& builder : builders) {
+          arrays.push_back(*builder->Finish());
+        }
+        auto outTable = arrow::Table::Make(schema, arrays);
+        auto concrete = DataSpecUtils::asConcreteDataMatcher(spec);
+        allocator.adopt(Output{concrete.origin, concrete.description, concrete.subSpec}, outTable);
+      }
+
+      O2_SIGNPOST_END(ccdb, sid, "fetchFromAnalysisCCDB", "Fetching CCDB objects");
+    });
+  });
+}
+
+} // namespace o2::framework
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
new file mode 100644
index 0000000000000..f8175034da0ba
--- /dev/null
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
@@ -0,0 +1,25 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef O2_FRAMEWORK_ANALYSISCCDBHELPERS_H_
+#define O2_FRAMEWORK_ANALYSISCCDBHELPERS_H_
+
+#include "Framework/AlgorithmSpec.h"
+
+namespace o2::framework
+{
+
+struct AnalysisCCDBHelpers {
+  static AlgorithmSpec fetchFromCCDB(ConfigContext const& ctx);
+};
+
+} // namespace o2::framework
+
+#endif // O2_FRAMEWORK_ANALYSISCCDBHELPERS_H_
diff --git a/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx b/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
new file mode 100644
index 0000000000000..14c3fefb31024
--- /dev/null
+++ b/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
@@ -0,0 +1,279 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#include "CCDBFetcherHelper.h"
+#include "Framework/DataTakingContext.h"
+#include "Framework/Signpost.h"
+#include "Framework/DataSpecUtils.h"
+#include "Framework/ConfigParamRegistry.h"
+#include <TError.h>
+#include <TMemFile.h>
+
+O2_DECLARE_DYNAMIC_LOG(ccdb);
+
+namespace o2::framework
+{
+
+o2::ccdb::CcdbApi& CCDBFetcherHelper::getAPI(const std::string& path)
+{
+  // find the first = sign in the string. If present drop everything after it
+  // and between it and the previous /.
+  auto pos = path.find('=');
+  if (pos == std::string::npos) {
+    auto entry = remappings.find(path);
+    return apis[entry == remappings.end() ? "" : entry->second];
+  }
+  auto pos2 = path.rfind('/', pos);
+  if (pos2 == std::string::npos || pos2 == pos - 1 || pos2 == 0) {
+    throw runtime_error_f("Malformed path %s", path.c_str());
+  }
+  auto entry = remappings.find(path.substr(0, pos2));
+  return apis[entry == remappings.end() ? "" : entry->second];
+}
+
+namespace
+{
+bool isOnlineRun(DataTakingContext const& dtc)
+{
+  return dtc.deploymentMode == DeploymentMode::OnlineAUX || dtc.deploymentMode == DeploymentMode::OnlineDDS || dtc.deploymentMode == DeploymentMode::OnlineECS;
+}
+} // namespace
+
+void CCDBFetcherHelper::initialiseHelper(CCDBFetcherHelper& helper, ConfigParamRegistry const& options)
+{
+  auto defHost = options.get<std::string>("condition-backend");
+  auto checkRate = options.get<int>("condition-tf-per-query");
+  auto checkMult = options.get<int>("condition-tf-per-query-multiplier");
+  helper.timeToleranceMS = options.get<int64_t>("condition-time-tolerance");
+  helper.queryPeriodGlo = checkRate > 0 ? checkRate : std::numeric_limits<int>::max();
+  helper.queryPeriodFactor = checkMult > 0 ? checkMult : 1;
+  LOGP(info, "CCDB Backend at: {}, validity check for every {} TF{}", defHost, helper.queryPeriodGlo, helper.queryPeriodFactor == 1 ? std::string{} : fmt::format(", (query for high-rate objects downscaled by {})", helper.queryPeriodFactor));
+  LOGP(info, "Hook to enable signposts for CCDB messages at {}", (void*)&private_o2_log_ccdb->stacktrace);
+  auto remapString = options.get<std::string>("condition-remap");
+  ParserResult result = parseRemappings(remapString.c_str());
+  if (!result.error.empty()) {
+    throw runtime_error_f("Error while parsing remapping string %s", result.error.c_str());
+  }
+  helper.remappings = result.remappings;
+  helper.apis[""].init(defHost); // default backend
+  LOGP(info, "Initialised default CCDB host {}", defHost);
+  //
+  for (auto& entry : helper.remappings) { // init api instances for every host seen in the remapping
+    if (helper.apis.find(entry.second) == helper.apis.end()) {
+      helper.apis[entry.second].init(entry.second);
+      LOGP(info, "Initialised custom CCDB host {}", entry.second);
+    }
+    LOGP(info, "{} is remapped to {}", entry.first, entry.second);
+  }
+  helper.createdNotBefore = std::to_string(options.get<int64_t>("condition-not-before"));
+  helper.createdNotAfter = std::to_string(options.get<int64_t>("condition-not-after"));
+}
+
+CCDBFetcherHelper::ParserResult CCDBFetcherHelper::parseRemappings(char const* str)
+{
+  std::unordered_map<std::string, std::string> remappings;
+  std::string currentUrl = "";
+
+  enum ParsingStates {
+    IN_BEGIN,
+    IN_BEGIN_URL,
+    IN_BEGIN_TARGET,
+    IN_END_TARGET,
+    IN_END_URL
+  };
+  ParsingStates state = IN_BEGIN;
+
+  while (true) {
+    switch (state) {
+      case IN_BEGIN: {
+        if (*str == 0) {
+          return {remappings, ""};
+        }
+        state = IN_BEGIN_URL;
+      }
+      case IN_BEGIN_URL: {
+        if ((strncmp("http://", str, 7) != 0) && (strncmp("https://", str, 8) != 0 && (strncmp("file://", str, 7) != 0))) {
+          return {remappings, "URL should start with either http:// or https:// or file://"};
+        }
+        state = IN_END_URL;
+      } break;
+      case IN_END_URL: {
+        char const* c = strchr(str, '=');
+        if (c == nullptr) {
+          return {remappings, "Expecting at least one target path, missing `='?"};
+        }
+        if ((c - str) == 0) {
+          return {remappings, "Empty url"};
+        }
+        currentUrl = std::string_view(str, c - str);
+        state = IN_BEGIN_TARGET;
+        str = c + 1;
+      } break;
+      case IN_BEGIN_TARGET: {
+        if (*str == 0) {
+          return {remappings, "Empty target"};
+        }
+        state = IN_END_TARGET;
+      } break;
+      case IN_END_TARGET: {
+        char const* c = strpbrk(str, ",;");
+        if (c == nullptr) {
+          if (remappings.count(str)) {
+            return {remappings, fmt::format("Path {} requested more than once.", str)};
+          }
+          remappings[std::string(str)] = currentUrl;
+          return {remappings, ""};
+        }
+        if ((c - str) == 0) {
+          return {remappings, "Empty target"};
+        }
+        auto key = std::string(str, c - str);
+        if (remappings.count(str)) {
+          return {remappings, fmt::format("Path {} requested more than once.", key)};
+        }
+        remappings[key] = currentUrl;
+        if (*c == ';') {
+          state = IN_BEGIN_URL;
+        } else {
+          state = IN_BEGIN_TARGET;
+        }
+        str = c + 1;
+      } break;
+    }
+  }
+}
+
+auto CCDBFetcherHelper::populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
+                                          std::vector<CCDBFetcherHelper::FetchOp> const& ops,
+                                          TimingInfo& timingInfo,
+                                          DataTakingContext& dtc,
+                                          DataAllocator& allocator) -> std::vector<CCDBFetcherHelper::Response>
+{
+  int objCnt = -1;
+  // We use the timeslice, so that we hook into the same interval as the rest of the
+  // callback.
+  static bool isOnline = isOnlineRun(dtc);
+
+  auto sid = _o2_signpost_id_t{(int64_t)timingInfo.timeslice};
+  O2_SIGNPOST_START(ccdb, sid, "populateCacheWith", "Starting to populate cache with CCDB objects");
+  std::vector<Response> responses;
+  for (auto& op : ops) {
+    int64_t timestampToUse = op.timestamp;
+    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "Fetching object for route %{public}s", DataSpecUtils::describe(op.spec).data());
+    objCnt++;
+    auto concrete = DataSpecUtils::asConcreteDataMatcher(op.spec);
+    Output output{concrete.origin, concrete.description, concrete.subSpec};
+    auto&& v = allocator.makeVector<char>(output);
+    std::map<std::string, std::string> metadata;
+    std::map<std::string, std::string> headers;
+    std::string path = op.url;
+    std::string etag = "";
+    int chRate = helper->queryPeriodGlo;
+    bool checkValidity = false;
+    if (op.runDependent > 0) {
+      if (op.runDependent == 1) {
+        metadata["runNumber"] = std::format("{}", op.runNumber);
+      } else if (op.runDependent == 2) {
+        timestampToUse = op.runNumber;
+      } else {
+        LOGP(fatal, "Undefined ccdb-run-dependent option {} for spec {}/{}/{}", op.runDependent,
+             concrete.origin.as<std::string>(), concrete.description.as<std::string>(), int(concrete.subSpec));
+      }
+    }
+    for (auto m : op.metadata) {
+      O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "Adding metadata %{public}s: %{public}s to the request", m.key.data(), m.value.data());
+      metadata[m.key] = m.value;
+    }
+    if (op.queryRate != 0) {
+      chRate = op.queryRate * helper->queryPeriodFactor;
+    }
+
+    const auto url2uuid = helper->mapURL2UUID.find(path);
+    if (url2uuid != helper->mapURL2UUID.end()) {
+      etag = url2uuid->second.etag;
+      // We check validity every chRate timeslices or if the cache is expired
+      uint64_t validUntil = url2uuid->second.cacheValidUntil;
+      // When the cache was populated. If the cache was populated after the timestamp, we need to check validity.
+      uint64_t cachePopulatedAt = url2uuid->second.cachePopulatedAt;
+      // If timestamp is before the time the element was cached or after the claimed validity, we need to check validity, again
+      // when online.
+      bool cacheExpired = (validUntil <= timestampToUse) || (op.timestamp < cachePopulatedAt);
+      checkValidity = (std::abs(int(timingInfo.tfCounter - url2uuid->second.lastCheckedTF)) >= chRate) && (isOnline || cacheExpired);
+    } else {
+      checkValidity = true; // never skip check if the cache is empty
+    }
+
+    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tfID %d of %{public}s", checkValidity ? "true" : "false", timingInfo.tfCounter, path.data());
+
+    const auto& api = helper->getAPI(path);
+    if (checkValidity && (!api.isSnapshotMode() || etag.empty())) { // in the snapshot mode the object needs to be fetched only once
+      LOGP(detail, "Loading {} for timestamp {}", path, timestampToUse);
+      api.loadFileToMemory(v, path, metadata, timestampToUse, &headers, etag, helper->createdNotAfter, helper->createdNotBefore);
+      if ((headers.count("Error") != 0) || (etag.empty() && v.empty())) {
+        LOGP(fatal, "Unable to find CCDB object {}/{}", path, timestampToUse);
+        // FIXME: I should send a dummy message.
+        continue;
+      }
+      // printing in case we find a default entry
+      if (headers.find("default") != headers.end()) {
+        LOGP(detail, "******** Default entry used for {} ********", path);
+      }
+      helper->mapURL2UUID[path].lastCheckedTF = timingInfo.tfCounter;
+      if (etag.empty()) {
+        helper->mapURL2UUID[path].etag = headers["ETag"]; // update uuid
+        helper->mapURL2UUID[path].cachePopulatedAt = timestampToUse;
+        helper->mapURL2UUID[path].cacheMiss++;
+        helper->mapURL2UUID[path].size = v.size();
+        helper->mapURL2UUID[path].minSize = std::min(v.size(), helper->mapURL2UUID[path].minSize);
+        helper->mapURL2UUID[path].maxSize = std::max(v.size(), helper->mapURL2UUID[path].maxSize);
+        auto size = v.size();
+        api.appendFlatHeader(v, headers);
+        auto cacheId = allocator.adoptContainer(output, std::move(v), DataAllocator::CacheStrategy::Always, header::gSerializationMethodCCDB);
+        helper->mapURL2DPLCache[path] = cacheId;
+        responses.emplace_back(Response{.id = cacheId, .size = size, .request = nullptr});
+        O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "Caching %{public}s for %{public}s (DPL id %" PRIu64 ", size %zu)", path.data(), headers["ETag"].data(), cacheId.value, size);
+        continue;
+      }
+      if (v.size()) { // but should be overridden by fresh object
+        // somewhere here pruneFromCache should be called
+        helper->mapURL2UUID[path].etag = headers["ETag"]; // update uuid
+        helper->mapURL2UUID[path].cachePopulatedAt = timestampToUse;
+        helper->mapURL2UUID[path].cacheValidUntil = headers["Cache-Valid-Until"].empty() ? 0 : std::stoul(headers["Cache-Valid-Until"]);
+        helper->mapURL2UUID[path].cacheMiss++;
+        helper->mapURL2UUID[path].size = v.size();
+        helper->mapURL2UUID[path].minSize = std::min(v.size(), helper->mapURL2UUID[path].minSize);
+        helper->mapURL2UUID[path].maxSize = std::max(v.size(), helper->mapURL2UUID[path].maxSize);
+        auto size = v.size();
+        api.appendFlatHeader(v, headers);
+        auto cacheId = allocator.adoptContainer(output, std::move(v), DataAllocator::CacheStrategy::Always, header::gSerializationMethodCCDB);
+        helper->mapURL2DPLCache[path] = cacheId;
+        responses.emplace_back(Response{.id = cacheId, .size = size, .request = nullptr});
+        O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "Caching %{public}s for %{public}s (DPL id %" PRIu64 ")", path.data(), headers["ETag"].data(), cacheId.value);
+        // one could modify the    adoptContainer to take optional old cacheID to clean:
+        // mapURL2DPLCache[URL] = ctx.outputs().adoptContainer(output, std::move(outputBuffer), DataAllocator::CacheStrategy::Always, mapURL2DPLCache[URL]);
+        continue;
+      } else {
+        // Only once the etag is actually used, we get the information on how long the object is valid
+        helper->mapURL2UUID[path].cacheValidUntil = headers["Cache-Valid-Until"].empty() ? 0 : std::stoul(headers["Cache-Valid-Until"]);
+      }
+    }
+    // cached object is fine
+    auto cacheId = helper->mapURL2DPLCache[path];
+    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "Reusing %{public}s for %{public}s (DPL id %" PRIu64 ")", path.data(), headers["ETag"].data(), cacheId.value);
+    helper->mapURL2UUID[path].cacheHit++;
+    responses.emplace_back(Response{.id = cacheId, .size = helper->mapURL2UUID[path].size, .request = nullptr});
+    allocator.adoptFromCache(output, cacheId, header::gSerializationMethodCCDB);
+    // the outputBuffer was not used, can we destroy it?
+  }
+  O2_SIGNPOST_END(ccdb, sid, "populateCacheWith", "Finished populating cache with CCDB objects");
+  return responses;
+};
+
+} // namespace o2::framework
diff --git a/Framework/CCDBSupport/src/CCDBFetcherHelper.h b/Framework/CCDBSupport/src/CCDBFetcherHelper.h
new file mode 100644
index 0000000000000..e3453b48bf156
--- /dev/null
+++ b/Framework/CCDBSupport/src/CCDBFetcherHelper.h
@@ -0,0 +1,109 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef O2_FRAMEWORK_CCDBFETCHERHELPER_H_
+#define O2_FRAMEWORK_CCDBFETCHERHELPER_H_
+
+#include "Framework/OutputRoute.h"
+#include "Framework/DataAllocator.h"
+#include "CCDB/CcdbApi.h"
+#include <unordered_map>
+#include <string>
+
+namespace o2::framework
+{
+
+struct DataTakingContext;
+
+struct CCDBFetcherHelper {
+  struct CCDBCacheInfo {
+    std::string etag;
+    size_t cacheValidUntil = 0;
+    size_t cachePopulatedAt = 0;
+    size_t cacheMiss = 0;
+    size_t cacheHit = 0;
+    size_t size = 0L;
+    size_t minSize = -1ULL;
+    size_t maxSize = 0;
+    int lastCheckedTF = 0;
+  };
+
+  struct RemapMatcher {
+    std::string path;
+  };
+
+  struct RemapTarget {
+    std::string url;
+  };
+
+  struct ParserResult {
+    std::unordered_map<std::string, std::string> remappings;
+    std::string error;
+  };
+
+  struct MetadataEntry {
+    std::string key;
+    std::string value;
+  };
+
+  // A fetch operation.
+  struct FetchOp {
+    // Where to put the blob
+    OutputSpec& spec;
+    // The url to fetch
+    std::string url = "";
+    // The timestamp to use
+    int64_t timestamp = 0;
+    // The run to use
+    int runNumber = 0;
+    // Wether or not the thing is run dependent
+    int runDependent = 0;
+    // Actual metadata
+    std::vector<MetadataEntry> metadata = {};
+    // Query rate
+    int queryRate = 0;
+  };
+
+  // Where the data has been fetched
+  struct Response {
+    // CacheId / Pointer to the actual data
+    DataAllocator::CacheId id;
+    // The size of the buffer
+    size_t size = 0;
+    // Where to actually
+    FetchOp* request = nullptr;
+  };
+
+  static ParserResult parseRemappings(char const*);
+
+  std::unordered_map<std::string, CCDBCacheInfo> mapURL2UUID;
+  std::unordered_map<std::string, DataAllocator::CacheId> mapURL2DPLCache;
+  std::string createdNotBefore = "0";
+  std::string createdNotAfter = "3385078236000";
+  std::unordered_map<std::string, o2::ccdb::CcdbApi> apis;
+  std::vector<OutputRoute> routes;
+  std::unordered_map<std::string, std::string> remappings;
+  uint32_t lastCheckedTFCounterOrbReset = 0; // last checkecked TFcounter for bulk check
+  int queryPeriodGlo = 1;
+  int queryPeriodFactor = 1;
+  int64_t timeToleranceMS = 5000;
+
+  o2::ccdb::CcdbApi& getAPI(const std::string& path);
+  static void initialiseHelper(CCDBFetcherHelper& helper, ConfigParamRegistry const& options);
+  static auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
+                                std::vector<FetchOp> const& ops,
+                                TimingInfo& timingInfo,
+                                DataTakingContext& dtc,
+                                DataAllocator& allocator) -> std::vector<Response>;
+};
+
+} // namespace o2::framework
+
+#endif // O2_FRAMEWORK_CCDBFETCHERHELPER_H_
diff --git a/Framework/CCDBSupport/src/Plugin.cxx b/Framework/CCDBSupport/src/Plugin.cxx
index 18aabc07ae4a4..d9083f97a023e 100644
--- a/Framework/CCDBSupport/src/Plugin.cxx
+++ b/Framework/CCDBSupport/src/Plugin.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 #include "Framework/Plugins.h"
 #include "Framework/AlgorithmSpec.h"
+#include "AnalysisCCDBHelpers.h"
 #include "CCDBHelpers.h"
 
 struct CCDBFetcherPlugin : o2::framework::AlgorithmPlugin {
@@ -19,6 +20,14 @@ struct CCDBFetcherPlugin : o2::framework::AlgorithmPlugin {
   }
 };
 
+struct AnalysisCCDBFetcherPlugin : o2::framework::AlgorithmPlugin {
+  o2::framework::AlgorithmSpec create(o2::framework::ConfigContext const& ctx) final
+  {
+    return o2::framework::AnalysisCCDBHelpers::fetchFromCCDB(ctx);
+  }
+};
+
 DEFINE_DPL_PLUGINS_BEGIN
 DEFINE_DPL_PLUGIN_INSTANCE(CCDBFetcherPlugin, CustomAlgorithm);
+DEFINE_DPL_PLUGIN_INSTANCE(AnalysisCCDBFetcherPlugin, CustomAlgorithm);
 DEFINE_DPL_PLUGINS_END
diff --git a/Framework/CCDBSupport/test/test_CCDBHelpers.cxx b/Framework/CCDBSupport/test/test_CCDBHelpers.cxx
index df21738ddb647..53e6b66a2b30c 100644
--- a/Framework/CCDBSupport/test/test_CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/test/test_CCDBHelpers.cxx
@@ -9,43 +9,39 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#define BOOST_TEST_MODULE Test Framework CCDBHelpers
-#define BOOST_TEST_MAIN
-#define BOOST_TEST_DYN_LINK
-
-#include <boost/test/unit_test.hpp>
-#include "../src/CCDBHelpers.h"
+#include <catch_amalgamated.hpp>
+#include "../src/CCDBFetcherHelper.h"
 
 using namespace o2::framework;
 
-BOOST_AUTO_TEST_CASE(TestSorting)
+TEST_CASE("TestSorting")
 {
-  auto result = CCDBHelpers::parseRemappings("");
-  BOOST_CHECK_EQUAL(result.error, ""); // not an error
+  auto result = CCDBFetcherHelper::parseRemappings("");
+  CHECK(result.error == ""); // not an error
 
-  result = CCDBHelpers::parseRemappings("https");
-  BOOST_CHECK_EQUAL(result.error, "URL should start with either http:// or https:// or file://");
+  result = CCDBFetcherHelper::parseRemappings("https");
+  CHECK(result.error == "URL should start with either http:// or https:// or file://");
 
-  result = CCDBHelpers::parseRemappings("https://alice.cern.ch:8000");
-  BOOST_CHECK_EQUAL(result.error, "Expecting at least one target path, missing `='?");
+  result = CCDBFetcherHelper::parseRemappings("https://alice.cern.ch:8000");
+  CHECK(result.error == "Expecting at least one target path, missing `='?");
 
-  result = CCDBHelpers::parseRemappings("https://alice.cern.ch:8000=");
-  BOOST_CHECK_EQUAL(result.error, "Empty target");
+  result = CCDBFetcherHelper::parseRemappings("https://alice.cern.ch:8000=");
+  CHECK(result.error == "Empty target");
 
-  result = CCDBHelpers::parseRemappings("https://alice.cern.ch:8000=/foo/bar,");
-  BOOST_CHECK_EQUAL(result.error, "Empty target");
+  result = CCDBFetcherHelper::parseRemappings("https://alice.cern.ch:8000=/foo/bar,");
+  CHECK(result.error == "Empty target");
 
-  result = CCDBHelpers::parseRemappings("https://alice.cern.ch:8000=/foo/bar,/foo/bar;");
-  BOOST_CHECK_EQUAL(result.error, "URL should start with either http:// or https:// or file://");
+  result = CCDBFetcherHelper::parseRemappings("https://alice.cern.ch:8000=/foo/bar,/foo/bar;");
+  CHECK(result.error == "URL should start with either http:// or https:// or file://");
 
-  result = CCDBHelpers::parseRemappings("https://alice.cern.ch:8000=/foo/bar,/foo/barbar;file://user/test=/foo/barr");
-  BOOST_CHECK_EQUAL(result.error, "");
-  BOOST_CHECK_EQUAL(result.remappings.size(), 3);
-  BOOST_CHECK_EQUAL(result.remappings["/foo/bar"], "https://alice.cern.ch:8000");
-  BOOST_CHECK_EQUAL(result.remappings["/foo/barbar"], "https://alice.cern.ch:8000");
-  BOOST_CHECK_EQUAL(result.remappings["/foo/barr"], "file://user/test");
+  result = CCDBFetcherHelper::parseRemappings("https://alice.cern.ch:8000=/foo/bar,/foo/barbar;file://user/test=/foo/barr");
+  CHECK(result.error == "");
+  CHECK(result.remappings.size() == 3);
+  CHECK(result.remappings["/foo/bar"] == "https://alice.cern.ch:8000");
+  CHECK(result.remappings["/foo/barbar"] == "https://alice.cern.ch:8000");
+  CHECK(result.remappings["/foo/barr"] == "file://user/test");
 
-  result = CCDBHelpers::parseRemappings("https://alice.cern.ch:8000=/foo/bar;file://user/test=/foo/bar");
-  BOOST_CHECK_EQUAL(result.remappings.size(), 1);
-  BOOST_CHECK_EQUAL(result.error, "Path /foo/bar requested more than once.");
+  result = CCDBFetcherHelper::parseRemappings("https://alice.cern.ch:8000=/foo/bar;file://user/test=/foo/bar");
+  CHECK(result.remappings.size() == 1);
+  CHECK(result.error == "Path /foo/bar requested more than once.");
 }
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 3aab089fde00c..4db774d88a224 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -44,12 +44,15 @@ std::string cutString(std::string&& str);
 std::string strToUpper(std::string&& str);
 } // namespace o2::framework
 
+struct TClass;
+
 namespace o2::soa
 {
 void accessingInvalidIndexFor(const char* getter);
 void dereferenceWithWrongType(const char* getter, const char* target);
 void missingFilterDeclaration(int hash, int ai);
 void notBoundTable(const char* tableName);
+void* extractCCDBPayload(char* payload, size_t size, TClass const* cl, const char* what);
 } // namespace o2::soa
 
 namespace o2::soa
@@ -1274,6 +1277,11 @@ concept with_sources = requires {
   T::sources.size();
 };
 
+template <typename T>
+concept with_ccdb_urls = requires {
+  T::ccdb_urls.size();
+};
+
 template <typename T>
 concept with_base_table = not_void<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t>;
 
@@ -2248,11 +2256,14 @@ ColumnGetterFunction<R, typename T::iterator> getColumnGetterByLabel(const std::
 
 namespace o2::aod
 {
+// If you get an error about not satisfying is_origin_hash, you need to add
+// an entry here.
 O2ORIGIN("AOD");
 O2ORIGIN("AOD1");
 O2ORIGIN("AOD2");
 O2ORIGIN("DYN");
 O2ORIGIN("IDX");
+O2ORIGIN("ATIM");
 O2ORIGIN("JOIN");
 O2HASH("JOIN/0");
 O2ORIGIN("CONC");
@@ -2313,6 +2324,48 @@ consteval static std::string_view namespace_prefix()
   };                                                                                                                                                                              \
   [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, _Name_::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
+#define DECLARE_SOA_CCDB_COLUMN_FULL(_Name_, _Label_, _Getter_, _ConcreteType_, _CCDBQuery_)                    \
+  struct _Name_ : o2::soa::Column<std::span<std::byte>, _Name_> {                                               \
+    static constexpr const char* mLabel = _Label_;                                                              \
+    static constexpr const char* query = _CCDBQuery_;                                                           \
+    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_});      \
+    using base = o2::soa::Column<std::span<std::byte>, _Name_>;                                                 \
+    using type = std::span<std::byte>;                                                                          \
+    using column_t = _Name_;                                                                                    \
+    _Name_(arrow::ChunkedArray const* column)                                                                   \
+      : o2::soa::Column<std::span<std::byte>, _Name_>(o2::soa::ColumnIterator<std::span<std::byte>>(column))    \
+    {                                                                                                           \
+    }                                                                                                           \
+                                                                                                                \
+    _Name_() = default;                                                                                         \
+    _Name_(_Name_ const& other) = default;                                                                      \
+    _Name_& operator=(_Name_ const& other) = default;                                                           \
+                                                                                                                \
+    decltype(auto) _Getter_() const                                                                             \
+    {                                                                                                           \
+      static std::byte* payload = nullptr;                                                                      \
+      static _ConcreteType_* deserialised = nullptr;                                                            \
+      static TClass* c = TClass::GetClass(#_ConcreteType_);                                                     \
+      auto span = *mColumnIterator;                                                                             \
+      if (payload != (std::byte*)span.data()) {                                                                 \
+        payload = (std::byte*)span.data();                                                                      \
+        delete deserialised;                                                                                    \
+        TBufferFile f(TBufferFile::EMode::kRead, span.size(), (char*)span.data(), kFALSE);                      \
+        deserialised = (_ConcreteType_*)soa::extractCCDBPayload((char*)payload, span.size(), c, "ccdb_object"); \
+      }                                                                                                         \
+      return *deserialised;                                                                                     \
+    }                                                                                                           \
+                                                                                                                \
+    decltype(auto)                                                                                              \
+      get() const                                                                                               \
+    {                                                                                                           \
+      return _Getter_();                                                                                        \
+    }                                                                                                           \
+  };
+
+#define DECLARE_SOA_CCDB_COLUMN(_Name_, _Getter_, _ConcreteType_, _CCDBQuery_) \
+  DECLARE_SOA_CCDB_COLUMN_FULL(_Name_, "f" #_Name_, _Getter_, _ConcreteType_, _CCDBQuery_)
+
 #define DECLARE_SOA_COLUMN(_Name_, _Getter_, _Type_) \
   DECLARE_SOA_COLUMN_FULL(_Name_, _Getter_, _Type_, "f" #_Name_)
 
@@ -3188,6 +3241,43 @@ consteval auto getIndexTargets()
     using metadata = _Name_##Metadata;                                                                                                     \
   };
 
+// Declare were each row is associated to a timestamp column of an _TimestampSource_
+// table.
+//
+// The columns of this table have to be CCDB_COLUMNS so that for each timestamp, we get a row
+// which points to the specified CCDB objectes described by those columns.
+#define DECLARE_SOA_TIMESTAMPED_TABLE_FULL(_Name_, _Label_, _TimestampSource_, _TimestampColumn_, _Origin_, _Version_, _Desc_, ...) \
+  O2HASH(_Desc_ "/" #_Version_);                                                                                                    \
+  template <typename O>                                                                                                             \
+  using _Name_##TimestampFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>;              \
+  using _Name_##Timestamp = _Name_##TimestampFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                    \
+  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                              \
+  struct _Name_##TimestampMetadataFrom : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                    \
+    using base_table_t = _TimestampSource_;                                                                                         \
+    using extension_table_t = _Name_##TimestampFrom<O>;                                                                             \
+    static constexpr const auto ccdb_urls = []<typename... Cs>(framework::pack<Cs...>) {                                            \
+      return std::array<std::string_view, sizeof...(Cs)>{Cs::query...};                                                             \
+    }(framework::pack<__VA_ARGS__>{});                                                                                              \
+    static constexpr const auto ccdb_bindings = []<typename... Cs>(framework::pack<Cs...>) {                                        \
+      return std::array<std::string_view, sizeof...(Cs)>{Cs::mLabel...};                                                            \
+    }(framework::pack<__VA_ARGS__>{});                                                                                              \
+    static constexpr auto sources = _TimestampSource_::originals;                                                                   \
+    static constexpr auto timestamp_column_label = _TimestampColumn_::mLabel;                                                       \
+    /*static constexpr auto timestampColumn = _TimestampColumn_;*/                                                                  \
+  };                                                                                                                                \
+  using _Name_##TimestampMetadata = _Name_##TimestampMetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                                    \
+  template <>                                                                                                                       \
+  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                 \
+    using metadata = _Name_##TimestampMetadata;                                                                                     \
+  };                                                                                                                                \
+  template <typename O>                                                                                                             \
+  using _Name_##From = o2::soa::JoinFull<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, _TimestampSource_, _Name_##TimestampFrom<O>>;   \
+  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
+
+#define DECLARE_SOA_TIMESTAMPED_TABLE(_Name_, _TimestampSource_, _TimestampColumn_, _Version_, _Desc_, ...) \
+  O2HASH(#_Name_ "Timestamped");                                                                            \
+  DECLARE_SOA_TIMESTAMPED_TABLE_FULL(_Name_, #_Name_ "Timestamped", _TimestampSource_, _TimestampColumn_, "ATIM", _Version_, _Desc_, __VA_ARGS__)
+
 #define DECLARE_SOA_INDEX_TABLE(_Name_, _Key_, _Description_, ...) \
   DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", 0, _Description_, false, __VA_ARGS__)
 
diff --git a/Framework/Core/include/Framework/AnalysisContext.h b/Framework/Core/include/Framework/AnalysisContext.h
index 0f62f952d0aaa..7d1544ed312a4 100644
--- a/Framework/Core/include/Framework/AnalysisContext.h
+++ b/Framework/Core/include/Framework/AnalysisContext.h
@@ -29,16 +29,24 @@ struct OutputObjectInfo {
   std::vector<std::string> bindings;
 };
 
-//
+// This will keep track of the inputs which have
+// been requested and for which we will need to inject
+// some source device.
 struct AnalysisContext {
   std::vector<InputSpec> requestedAODs;
   std::vector<OutputSpec> providedAODs;
   std::vector<InputSpec> requestedDYNs;
   std::vector<OutputSpec> providedDYNs;
   std::vector<InputSpec> requestedIDXs;
+  std::vector<OutputSpec> providedTIMs;
+  std::vector<InputSpec> requestedTIMs;
   std::vector<OutputSpec> providedOutputObjHist;
   std::vector<InputSpec> spawnerInputs;
 
+  // These are the timestamped tables which are required to
+  // inject the the CCDB objecs.
+  std::vector<InputSpec> analysisCCDBInputs;
+
   // Needed to created the hist writer
   std::vector<OutputTaskInfo> outTskMap;
   std::vector<OutputObjectInfo> outObjHistMap;
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 0fc4821e6a420..842263cd75abc 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -11,6 +11,7 @@
 #ifndef o2_framework_AnalysisHelpers_H_DEFINED
 #define o2_framework_AnalysisHelpers_H_DEFINED
 
+#include "ConfigParamSpec.h"
 #include "Framework/ASoA.h"
 #include "Framework/DataAllocator.h"
 #include "Framework/IndexBuilderHelpers.h"
@@ -49,6 +50,19 @@ inline constexpr auto getSources()
   }.template operator()<T::sources.size(), T::sources>();
 }
 
+template <soa::with_ccdb_urls T>
+inline constexpr auto getCCDBUrls()
+{
+  std::vector<framework::ConfigParamSpec> result;
+  for (size_t i = 0; i < T::ccdb_urls.size(); ++i) {
+    result.push_back({std::string{"ccdb:"} + std::string{T::ccdb_bindings[i]},
+                      framework::VariantType::String,
+                      T::ccdb_urls[i],
+                      {"\"\""}});
+  }
+  return result;
+}
+
 template <soa::with_sources T>
 constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
 {
@@ -67,18 +81,40 @@ constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
 {
   return {};
 }
+
+template <soa::with_ccdb_urls T>
+constexpr auto getCCDBMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  std::vector<framework::ConfigParamSpec> results = getCCDBUrls<T>();
+  std::sort(results.begin(), results.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name < b.name; });
+  auto last = std::unique(results.begin(), results.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name == b.name; });
+  results.erase(last, results.end());
+  return results;
+}
+
+template <typename T>
+constexpr auto getCCDBMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  return {};
+}
 }  // namespace
 
 template <TableRef R>
 constexpr auto tableRef2InputSpec()
 {
+  std::vector<framework::ConfigParamSpec> metadata;
+  auto m = getInputMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  metadata.insert(metadata.end(), m.begin(), m.end());
+  auto ccdbMetadata = getCCDBMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  metadata.insert(metadata.end(), ccdbMetadata.begin(), ccdbMetadata.end());
+
   return framework::InputSpec{
     o2::aod::label<R>(),
     o2::aod::origin<R>(),
     o2::aod::description(o2::aod::signature<R>()),
     R.version,
     framework::Lifetime::Timeframe,
-    getInputMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>()};
+    metadata};
 }
 
 template <TableRef R>
diff --git a/Framework/Core/include/Framework/AnalysisSupportHelpers.h b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
index 4ae601dc9e4a2..a4e80decf2bbe 100644
--- a/Framework/Core/include/Framework/AnalysisSupportHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
@@ -39,6 +39,11 @@ struct AnalysisSupportHelpers {
                                          std::vector<InputSpec> const& requestedSpecials,
                                          std::vector<InputSpec>& requestedAODs,
                                          DataProcessorSpec& publisher);
+  static void addMissingOutputsToAnalysisCCDBFetcher(std::vector<OutputSpec> const& providedSpecials,
+                                                     std::vector<InputSpec> const& requestedSpecials,
+                                                     std::vector<InputSpec>& requestedAODs,
+                                                     std::vector<InputSpec>& requestedDYNs,
+                                                     DataProcessorSpec& publisher);
   static void addMissingOutputsToBuilder(std::vector<InputSpec> const& requestedSpecials,
                                          std::vector<InputSpec>& requestedAODs,
                                          std::vector<InputSpec>& requestedDYNs,
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index b3378543e6ebb..53f6bc0f862d6 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -65,7 +65,8 @@ concept is_enumeration = is_enumeration_v<std::decay_t<T>>;
 
 // Helper struct which builds a DataProcessorSpec from
 // the contents of an AnalysisTask...
-namespace {
+namespace
+{
 struct AnalysisDataProcessorBuilder {
   template <soa::is_iterator G, typename... Args>
   static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled)
@@ -417,7 +418,7 @@ struct AnalysisDataProcessorBuilder {
     std::invoke(processingFunction, task, g, std::get<A>(at)...);
   }
 };
-}
+} // namespace
 
 struct SetDefaultProcesses {
   std::vector<std::pair<std::string, bool>> map;
@@ -429,7 +430,8 @@ struct TaskName {
   std::string value;
 };
 
-namespace {
+namespace
+{
 template <typename T, typename... A>
 auto getTaskNameSetProcesses(std::string& outputName, TaskName first, SetDefaultProcesses second, A... args)
 {
@@ -493,7 +495,7 @@ auto getTaskNameSetProcesses(std::string& outputName, A... args)
   return task;
 }
 
-}
+} // namespace
 
 /// Adaptor to make an AlgorithmSpec from a o2::framework::Task
 ///
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index 7b5cdf72191cf..83ca358525f9f 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -14,6 +14,11 @@
 #include "Framework/RuntimeError.h"
 #include <arrow/util/key_value_metadata.h>
 #include <arrow/util/config.h>
+#include <TMemFile.h>
+#include <TClass.h>
+#include <TTree.h>
+#include <TH1.h>
+#include <TError.h>
 
 namespace o2::soa
 {
@@ -149,7 +154,7 @@ arrow::ChunkedArray* getIndexFromLabel(arrow::Table* table, std::string_view lab
     return caseInsensitiveCompare(label, f->name());
   });
   if (field == table->schema()->fields().end()) {
-    o2::framework::throw_error(o2::framework::runtime_error_f("Unable to find column with label %s", label));
+    o2::framework::throw_error(o2::framework::runtime_error_f("Unable to find column with label %s.", label));
   }
   auto index = std::distance(table->schema()->fields().begin(), field);
   return table->column(index).get();
@@ -170,6 +175,62 @@ void missingOptionalPreslice(const char* label, const char* key)
   throw o2::framework::runtime_error_f(R"(Optional Preslice with missing binding used: table "%s" (or join based on it) does not have column "%s")", label, key);
 }
 
+void* extractCCDBPayload(char* payload, size_t size, TClass const* cl, const char* what)
+{
+  Int_t previousErrorLevel = gErrorIgnoreLevel;
+  gErrorIgnoreLevel = kFatal;
+  // does it have a flattened headers map attached in the end?
+  TMemFile file("name", (char*)payload, size, "READ");
+  gErrorIgnoreLevel = previousErrorLevel;
+  if (file.IsZombie()) {
+    return nullptr;
+  }
+
+  if (!cl) {
+    return nullptr;
+  }
+  auto object = file.GetObjectChecked(what, cl);
+  if (!object) {
+    // it could be that object was stored with previous convention
+    // where the classname was taken as key
+    std::string objectName(cl->GetName());
+    objectName.erase(std::find_if(objectName.rbegin(), objectName.rend(), [](unsigned char ch) {
+                       return !std::isspace(ch);
+                     }).base(),
+                     objectName.end());
+    objectName.erase(objectName.begin(), std::find_if(objectName.begin(), objectName.end(), [](unsigned char ch) {
+                       return !std::isspace(ch);
+                     }));
+
+    object = file.GetObjectChecked(objectName.c_str(), cl);
+    LOG(warn) << "Did not find object under expected name " << what;
+    if (!object) {
+      return nullptr;
+    }
+    LOG(warn) << "Found object under deprecated name " << cl->GetName();
+  }
+  auto result = object;
+  // We need to handle some specific cases as ROOT ties them deeply
+  // to the file they are contained in
+  if (cl->InheritsFrom("TObject")) {
+    // make a clone
+    // detach from the file
+    auto tree = dynamic_cast<TTree*>((TObject*)object);
+    if (tree) {
+      tree->LoadBaskets(0x1L << 32); // make tree memory based
+      tree->SetDirectory(nullptr);
+      result = tree;
+    } else {
+      auto h = dynamic_cast<TH1*>((TObject*)object);
+      if (h) {
+        h->SetDirectory(nullptr);
+        result = h;
+      }
+    }
+  }
+  return result;
+}
+
 } // namespace o2::soa
 
 namespace o2::framework
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index eb17566fd6d31..e8c2d7acab5d2 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -207,6 +207,35 @@ void AnalysisSupportHelpers::addMissingOutputsToBuilder(std::vector<InputSpec> c
   }
 }
 
+void AnalysisSupportHelpers::addMissingOutputsToAnalysisCCDBFetcher(
+  std::vector<OutputSpec> const& providedSpecials,
+  std::vector<InputSpec> const& requestedSpecials,
+  std::vector<InputSpec>& requestedAODs,
+  std::vector<InputSpec>& requestedDYNs,
+  DataProcessorSpec& publisher)
+{
+  for (auto& input : requestedSpecials) {
+    auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
+    publisher.outputs.emplace_back(concrete.origin, concrete.description, concrete.subSpec);
+    // FIXME: good enough for now...
+    for (auto& i : input.metadata) {
+      if ((i.type == VariantType::String) && (i.name.find("input:") != std::string::npos)) {
+        auto value = i.defaultValue.get<std::string>();
+        auto spec = DataSpecUtils::fromMetadataString(i.defaultValue.get<std::string>());
+        auto j = std::find_if(publisher.inputs.begin(), publisher.inputs.end(), [&](auto x) { return x.binding == spec.binding; });
+        if (j == publisher.inputs.end()) {
+          publisher.inputs.push_back(spec);
+        }
+        if (DataSpecUtils::partialMatch(spec, AODOrigins)) {
+          DataSpecUtils::updateInputList(requestedAODs, std::move(spec));
+        } else if (DataSpecUtils::partialMatch(spec, header::DataOrigin{"DYN"})) {
+          DataSpecUtils::updateInputList(requestedDYNs, std::move(spec));
+        }
+      }
+    }
+  }
+}
+
 // =============================================================================
 DataProcessorSpec AnalysisSupportHelpers::getOutputObjHistSink(ConfigContext const& ctx)
 {
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 3a7699fb6876d..0e524da280598 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -19,6 +19,8 @@
 #include "Framework/ServiceRegistry.h"
 #include "Framework/ConfigContext.h"
 #include "Framework/CommonDataProcessors.h"
+#include "Framework/DataSpecUtils.h"
+#include "Framework/DataSpecViews.h"
 #include "Framework/DeviceSpec.h"
 #include "Framework/EndOfStreamContext.h"
 #include "Framework/Tracing.h"
@@ -27,6 +29,7 @@
 #include "Framework/DeviceInfo.h"
 #include "Framework/DevicesManager.h"
 #include "Framework/DeviceConfig.h"
+#include "Framework/PluginManager.h"
 #include "Framework/ServiceMetricsInfo.h"
 #include "WorkflowHelpers.h"
 #include "Framework/WorkflowSpecNode.h"
@@ -441,6 +444,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
     .adjustTopology = [](WorkflowSpecNode& node, ConfigContext const& ctx) {
       auto& workflow = node.specs;
       auto spawner = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-spawner"; });
+      auto analysisCCDB = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-ccdb"; });
       auto builder = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-index-builder"; });
       auto reader = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-reader"; });
       auto writer = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-writer"; });
@@ -448,6 +452,8 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
       ac.requestedAODs.clear();
       ac.requestedDYNs.clear();
       ac.providedDYNs.clear();
+      ac.providedTIMs.clear();
+      ac.requestedTIMs.clear();
 
 
       auto inputSpecLessThan = [](InputSpec const& lhs, InputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
@@ -511,6 +517,27 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, *spawner);
       }
 
+      if (analysisCCDB != workflow.end()) {
+        for (auto& d : workflow | views::exclude_by_name(analysisCCDB->name)) {
+          d.inputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::update_input_list{ac.requestedTIMs};
+          d.outputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::append_to{ac.providedTIMs};
+        }
+        std::sort(ac.requestedTIMs.begin(), ac.requestedTIMs.end(), inputSpecLessThan);
+        std::sort(ac.providedTIMs.begin(), ac.providedTIMs.end(), outputSpecLessThan);
+        // Use ranges::to<std::vector<>> in C++23...
+        ac.analysisCCDBInputs.clear();
+        ac.requestedTIMs | views::filter_not_matching(ac.providedTIMs) | sinks::append_to{ac.analysisCCDBInputs};
+
+        // recreate inputs and outputs
+        analysisCCDB->outputs.clear();
+        analysisCCDB->inputs.clear();
+        // replace AlgorithmSpec
+        // FIXME: it should be made more generic, so it does not need replacement...
+        // FIXME how can I make the lookup depend on DYN tables as well??
+        analysisCCDB->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
+        AnalysisSupportHelpers::addMissingOutputsToAnalysisCCDBFetcher({}, ac.analysisCCDBInputs, ac.requestedAODs, ac.requestedDYNs, *analysisCCDB);
+      }
+
       if (writer != workflow.end()) {
         workflow.erase(writer);
       }
@@ -538,6 +565,8 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         }
       }
 
+
+
       // replace writer as some outputs may have become dangling and some are now consumed
       auto [outputsInputs, isDangling] = WorkflowHelpers::analyzeOutputs(workflow);
 
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index b86a4f15e7306..6eda838070f6d 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -18,6 +18,7 @@
 #include "Framework/ConfigContext.h"
 #include "Framework/DeviceSpec.h"
 #include "Framework/DataSpecUtils.h"
+#include "Framework/DataSpecViews.h"
 #include "Framework/DataAllocator.h"
 #include "Framework/ControlService.h"
 #include "Framework/RawDeviceService.h"
@@ -184,6 +185,21 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
                 {"end-value-enumeration", VariantType::Int64, -1ll, {"final value for the enumeration"}},
                 {"step-value-enumeration", VariantType::Int64, 1ll, {"step between one value and the other"}}},
   };
+  DataProcessorSpec analysisCCDBBackend{
+    .name = "internal-dpl-aod-ccdb",
+    .inputs = {},
+    .outputs = {},
+    .algorithm = AlgorithmSpec::dummyAlgorithm(),
+    .options = {{"condition-backend", VariantType::String, defaultConditionBackend(), {"URL for CCDB"}},
+                {"condition-not-before", VariantType::Int64, 0ll, {"do not fetch from CCDB objects created before provide timestamp"}},
+                {"condition-not-after", VariantType::Int64, 3385078236000ll, {"do not fetch from CCDB objects created after the timestamp"}},
+                {"condition-remap", VariantType::String, "", {"remap condition path in CCDB based on the provided string."}},
+                {"condition-tf-per-query", VariantType::Int, defaultConditionQueryRate(), {"check condition validity per requested number of TFs, fetch only once if <=0"}},
+                {"condition-tf-per-query-multiplier", VariantType::Int, defaultConditionQueryRateMultiplier(), {"check conditions once per this amount of nominal checks"}},
+                {"condition-time-tolerance", VariantType::Int64, 5000ll, {"prefer creation time if its difference to orbit-derived time exceeds threshold (ms), impose if <0"}},
+                {"start-value-enumeration", VariantType::Int64, 0ll, {"initial value for the enumeration"}},
+                {"end-value-enumeration", VariantType::Int64, -1ll, {"final value for the enumeration"}},
+                {"step-value-enumeration", VariantType::Int64, 1ll, {"step between one value and the other"}}}};
   DataProcessorSpec transientStore{"internal-dpl-transient-store",
                                    {},
                                    {},
@@ -357,6 +373,9 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       if (DataSpecUtils::partialMatch(input, header::DataOrigin{"IDX"})) {
         DataSpecUtils::updateInputList(ac.requestedIDXs, InputSpec{input});
       }
+      if (DataSpecUtils::partialMatch(input, header::DataOrigin{"ATIM"})) {
+        DataSpecUtils::updateInputList(ac.requestedTIMs, InputSpec{input});
+      }
     }
 
     std::stable_sort(timer.outputs.begin(), timer.outputs.end(), [](OutputSpec const& a, OutputSpec const& b) { return *DataSpecUtils::getOptionalSubSpec(a) < *DataSpecUtils::getOptionalSubSpec(b); });
@@ -366,6 +385,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
         ac.providedAODs.emplace_back(output);
       } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"DYN"})) {
         ac.providedDYNs.emplace_back(output);
+      } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"ATIM"})) {
+        ac.providedTIMs.emplace_back(output);
       } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"ATSK"})) {
         ac.providedOutputObjHist.emplace_back(output);
         auto it = std::find_if(ac.outObjHistMap.begin(), ac.outObjHistMap.end(), [&](auto&& x) { return x.id == hash; });
@@ -384,7 +405,9 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   auto inputSpecLessThan = [](InputSpec const& lhs, InputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
   auto outputSpecLessThan = [](OutputSpec const& lhs, OutputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
   std::sort(ac.requestedDYNs.begin(), ac.requestedDYNs.end(), inputSpecLessThan);
+  std::sort(ac.requestedTIMs.begin(), ac.requestedTIMs.end(), inputSpecLessThan);
   std::sort(ac.providedDYNs.begin(), ac.providedDYNs.end(), outputSpecLessThan);
+  std::sort(ac.providedTIMs.begin(), ac.providedTIMs.end(), outputSpecLessThan);
 
   DataProcessorSpec indexBuilder{
     "internal-dpl-aod-index-builder",
@@ -394,6 +417,12 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     {}};
   AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.requestedIDXs, ac.requestedAODs, ac.requestedDYNs, indexBuilder);
 
+  ac.requestedTIMs | views::filter_not_matching(ac.providedTIMs) | sinks::append_to{ac.analysisCCDBInputs};
+  DeploymentMode deploymentMode = DefaultsHelpers::deploymentMode();
+  if (deploymentMode != DeploymentMode::OnlineDDS && deploymentMode != DeploymentMode::OnlineECS) {
+    AnalysisSupportHelpers::addMissingOutputsToAnalysisCCDBFetcher({}, ac.analysisCCDBInputs, ac.requestedAODs, ac.requestedTIMs, analysisCCDBBackend);
+  }
+
   for (auto& input : ac.requestedDYNs) {
     if (std::none_of(ac.providedDYNs.begin(), ac.providedDYNs.end(), [&input](auto const& x) { return DataSpecUtils::match(input, x); })) {
       ac.spawnerInputs.emplace_back(input);
@@ -568,6 +597,15 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     }
   }
 
+  // add the Analysys CCDB backend which reads CCDB objects using a provided
+  // table
+  if (analysisCCDBBackend.outputs.empty() == false) {
+    // add normal reader
+    auto&& algo = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
+    analysisCCDBBackend.algorithm = algo;
+    extraSpecs.push_back(analysisCCDBBackend);
+  }
+
   // add the timer
   if (timer.outputs.empty() == false) {
     extraSpecs.push_back(timer);
diff --git a/Framework/TestWorkflows/CMakeLists.txt b/Framework/TestWorkflows/CMakeLists.txt
index b147a4871bf26..f5d18183c3705 100644
--- a/Framework/TestWorkflows/CMakeLists.txt
+++ b/Framework/TestWorkflows/CMakeLists.txt
@@ -41,6 +41,11 @@ o2_add_dpl_workflow(analysis-histograms
                   SOURCES src/o2TestHistograms.cxx
                   COMPONENT_NAME TestWorkflows)
 
+o2_add_dpl_workflow(analysis-ccdb
+                    SOURCES src/o2TestAnalysisCCDB.cxx
+                    PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
+                    COMPONENT_NAME TestWorkflows)
+
 o2_add_dpl_workflow(two-timers
                   SOURCES src/o2TwoTimers.cxx
                   COMPONENT_NAME TestWorkflows)
diff --git a/Framework/TestWorkflows/src/o2TestAnalysisCCDB.cxx b/Framework/TestWorkflows/src/o2TestAnalysisCCDB.cxx
new file mode 100644
index 0000000000000..f9684762539f7
--- /dev/null
+++ b/Framework/TestWorkflows/src/o2TestAnalysisCCDB.cxx
@@ -0,0 +1,69 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \brief FullTracks is a join of Tracks, TracksCov, and TracksExtra.
+/// \author
+/// \since
+
+#include "Framework/runDataProcessing.h"
+#include "Framework/AnalysisTask.h"
+#include "Framework/AnalysisDataModel.h"
+#include "DataFormatsTOF/CalibLHCphaseTOF.h"
+#include <iostream>
+
+#include <TH2F.h>
+
+using namespace o2;
+using namespace o2::framework;
+using namespace o2::framework::expressions;
+
+namespace o2::aod
+{
+namespace tofcalib
+{
+DECLARE_SOA_CCDB_COLUMN(LHCphase, lhcPhase, o2::dataformats::CalibLHCphaseTOF, "TOF/Calib/LHCphase"); //!
+} // namespace tofcalib
+
+DECLARE_SOA_TIMESTAMPED_TABLE(TOFCalibrationObjects, aod::Timestamps, o2::aod::timestamp::Timestamp, 1, "TOFCALIB", //!
+                              tofcalib::LHCphase);
+} // namespace o2::aod
+
+struct DummyTimestampsTable {
+  Produces<aod::Timestamps> timestamps; /// Table with SOR timestamps produced by the task
+  Service<o2::framework::ControlService> control;
+
+  void process(Enumeration<0, 1>& e)
+  {
+    timestamps(1747442464000); // c2b3d801393540b7bddb949d600b199f, ecacb915-3d70-11f0-ac6f-808de0f5250c
+    timestamps(1747442764000); // 0262dbd9d50aa79c3d4dcd5ec3ca67c3, ed5471c5-3d70-11f0-b0a3-808de0f524ee
+    control->readyToQuit(QuitRequest::Me);
+    control->endOfStream();
+    std::cout << "Executed " << std::endl;
+  }
+};
+
+struct SimpleCCDBConsumer {
+  void process(o2::aod::TOFCalibrationObjects const& ccdbObjectsForAllTimestamps)
+  {
+    LOGP(info, "Looking at all the LHCphases associated to the timestamps");
+    for (auto& object : ccdbObjectsForAllTimestamps) {
+      std::cout << object.lhcPhase().getStartValidity() << " " << object.lhcPhase().getEndValidity() << std::endl;
+    }
+  }
+};
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
+{
+  return WorkflowSpec{
+    adaptAnalysisTask<DummyTimestampsTable>(cfgc),
+    adaptAnalysisTask<SimpleCCDBConsumer>(cfgc, TaskName{"simple-ccdb-cunsumer"}),
+  };
+}

From 408665def344b7e8a84c974cd3dadc7b25af1e2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <nicolo.jacazio@cern.ch>
Date: Mon, 25 Aug 2025 11:34:59 +0200
Subject: [PATCH 0742/1764] Add missing includes

---
 Framework/AODMerger/src/aodMerger.cxx   | 1 +
 Framework/AODMerger/src/aodStrainer.cxx | 1 +
 Framework/AODMerger/src/aodThinner.cxx  | 1 +
 3 files changed, 3 insertions(+)

diff --git a/Framework/AODMerger/src/aodMerger.cxx b/Framework/AODMerger/src/aodMerger.cxx
index 2be87274a928f..3ea45e84a39e0 100644
--- a/Framework/AODMerger/src/aodMerger.cxx
+++ b/Framework/AODMerger/src/aodMerger.cxx
@@ -13,6 +13,7 @@
 #include <list>
 #include <fstream>
 #include <getopt.h>
+#include <algorithm>
 
 #include "TSystem.h"
 #include "TFile.h"
diff --git a/Framework/AODMerger/src/aodStrainer.cxx b/Framework/AODMerger/src/aodStrainer.cxx
index fc54aa9c533cf..26af1205f0c35 100644
--- a/Framework/AODMerger/src/aodStrainer.cxx
+++ b/Framework/AODMerger/src/aodStrainer.cxx
@@ -15,6 +15,7 @@
 #include <getopt.h>
 #include <sstream>
 #include <random>
+#include <algorithm>
 
 #include "TSystem.h"
 #include "TFile.h"
diff --git a/Framework/AODMerger/src/aodThinner.cxx b/Framework/AODMerger/src/aodThinner.cxx
index e724595b94ba6..bf2215a67cab1 100644
--- a/Framework/AODMerger/src/aodThinner.cxx
+++ b/Framework/AODMerger/src/aodThinner.cxx
@@ -11,6 +11,7 @@
 
 #include <unordered_map>
 #include <getopt.h>
+#include <algorithm>
 
 #include "TSystem.h"
 #include "TStopwatch.h"

From 2d53aee68ce76be39d11fcbd7adb20e2ab355fba Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <nicolo.jacazio@cern.ch>
Date: Mon, 25 Aug 2025 12:36:06 +0200
Subject: [PATCH 0743/1764] another fix

---
 Framework/AODMerger/src/aodThinner.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Framework/AODMerger/src/aodThinner.cxx b/Framework/AODMerger/src/aodThinner.cxx
index bf2215a67cab1..9b03ebf2f360f 100644
--- a/Framework/AODMerger/src/aodThinner.cxx
+++ b/Framework/AODMerger/src/aodThinner.cxx
@@ -12,6 +12,7 @@
 #include <unordered_map>
 #include <getopt.h>
 #include <algorithm>
+#include <cmath>
 
 #include "TSystem.h"
 #include "TStopwatch.h"

From bd748b778467fc02f4153f362fe4e0bee1aee565 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 25 Aug 2025 11:42:22 +0200
Subject: [PATCH 0744/1764] Revert "Skip QED events in TPC QA"

This reverts commit dce7e0eacaa2797137b8be695ec64310f4d9569a.
---
 GPU/GPUTracking/qa/GPUQA.cxx | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 4fb2ee4dd58d9..2e9c3a1870385 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -686,9 +686,6 @@ void GPUQA::InitO2MCData(GPUTrackingInOutPointers* updateIOPtr)
 
     mMCInfosCol.resize(nSimTotalEvents);
     for (int32_t iSim = 0; iSim < mcReader.getNSources(); iSim++) {
-      if (iSim == o2::steer::QEDSOURCEID) {
-        continue;
-      }
       for (int32_t i = 0; i < mcReader.getNEvents(iSim); i++) {
         auto ir = evrec[i];
         auto ir0 = o2::raw::HBFUtils::Instance().getFirstIRofTF(ir);

From 88321c2a56f96dca131994908c326390c9c69386 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 25 Aug 2025 13:32:16 +0200
Subject: [PATCH 0745/1764] Minor fixes of debug printouts

---
 .../common/include/CommonDataFormat/InteractionRecord.h     | 4 ++--
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx               | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/DataFormats/common/include/CommonDataFormat/InteractionRecord.h b/DataFormats/common/include/CommonDataFormat/InteractionRecord.h
index 7aa3ccdd5d12c..e99f338a16343 100644
--- a/DataFormats/common/include/CommonDataFormat/InteractionRecord.h
+++ b/DataFormats/common/include/CommonDataFormat/InteractionRecord.h
@@ -281,7 +281,7 @@ struct InteractionRecord {
     return tmp;
   }
 
-#ifndef GPUCA_ALIGPUCODE
+#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
   void print() const;
   std::string asString() const;
   friend std::ostream& operator<<(std::ostream& stream, InteractionRecord const& ir);
@@ -359,7 +359,7 @@ struct InteractionTimeRecord : public InteractionRecord {
     return !((*this) > other);
   }
 
-#ifndef GPUCA_ALIGPUCODE
+#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
   void print() const;
   std::string asString() const;
   friend std::ostream& operator<<(std::ostream& stream, InteractionTimeRecord const& ir);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index d29fc09f32f63..faa5ccbaf6a50 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -66,7 +66,7 @@ inline void GPUReconstructionCPU::runKernelBackend(const krnlSetupTime& _xyz, co
   int32_t nThreads = getNKernelHostThreads(false);
   if (nThreads > 1) {
     if (GetProcessingSettings().debugLevel >= 5) {
-      printf("Running %d Threads\n", mThreading->activeThreads->max_concurrency());
+      GPUInfo("Running %d Threads", mThreading->activeThreads->max_concurrency());
     }
     tbb::this_task_arena::isolate([&] {
       mThreading->activeThreads->execute([&] {
@@ -227,7 +227,7 @@ int32_t GPUReconstructionCPU::RunChains()
   mNEventsProcessed++;
 
   if (GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) {
-    printf("Allocated memory when starting processing %34s", "");
+    GPUInfo("Allocated memory when starting processing %34s", "");
     PrintMemoryOverview();
   }
   mTimerTotal.Start();
@@ -254,7 +254,7 @@ int32_t GPUReconstructionCPU::RunChains()
   mTimerTotal.Stop();
   mStatCPUTime += (double)(std::clock() - cpuTimerStart) / CLOCKS_PER_SEC;
   if (GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) {
-    printf("Allocated memory when ending processing %36s", "");
+    GPUInfo("Allocated memory when ending processing %36s", "");
     PrintMemoryOverview();
   }
 

From 504267220ea25bf3050eb41dfffd2f9fb1e6b2e9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 25 Aug 2025 13:32:59 +0200
Subject: [PATCH 0746/1764] GPU QA: Proper fix for fetching timebins of MC data

---
 .../display/render/GPUDisplayDraw.cxx         |  3 ++
 GPU/GPUTracking/qa/GPUQA.cxx                  | 29 ++++++++++++++++---
 2 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index cbe385324ebbf..cccf0f098bd8d 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -539,6 +539,9 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
           if (mc.pid < 0) {
             break;
           }
+          if (mc.t0 == -100.f) {
+            break;
+          }
 
           alphaOrg = mParam->Alpha(iSector);
           float c = cosf(alphaOrg);
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 2e9c3a1870385..3f57ecd8f88be 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -673,7 +673,27 @@ void GPUQA::InitO2MCData(GPUTrackingInOutPointers* updateIOPtr)
     std::vector<int32_t> refId;
 
     auto dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
-    auto evrec = dc->getEventRecords();
+    const auto& evrec = dc->getEventRecords();
+    const auto& evparts = dc->getEventParts();
+    std::vector<std::vector<float>> evTimeBins(mcReader.getNSources());
+    for (uint32_t i = 0; i < evTimeBins.size(); i++) {
+      evTimeBins[i].resize(mcReader.getNEvents(i), -100.f);
+    }
+    for (uint32_t i = 0; i < evrec.size(); i++) {
+      const auto& ir = evrec[i];
+      for (uint32_t j = 0; j < evparts[i].size(); j++) {
+        const int iSim = evparts[i][j].sourceID;
+        const int iEv = evparts[i][j].entryID;
+        if (iSim == o2::steer::QEDSOURCEID || ir.differenceInBC(o2::raw::HBFUtils::Instance().getFirstIR()) >= 0) {
+          auto ir0 = o2::raw::HBFUtils::Instance().getFirstIRofTF(ir);
+          float timebin = (float)ir.differenceInBC(ir0) / o2::tpc::constants::LHCBCPERTIMEBIN;
+          if (evTimeBins[iSim][iEv] >= 0) {
+            throw std::runtime_error("Multiple time bins for same MC collision found");
+          }
+          evTimeBins[iSim][iEv] = timebin;
+        }
+      }
+    }
 
     uint32_t nSimSources = mcReader.getNSources();
     mMCEventOffset.resize(nSimSources);
@@ -687,9 +707,7 @@ void GPUQA::InitO2MCData(GPUTrackingInOutPointers* updateIOPtr)
     mMCInfosCol.resize(nSimTotalEvents);
     for (int32_t iSim = 0; iSim < mcReader.getNSources(); iSim++) {
       for (int32_t i = 0; i < mcReader.getNEvents(iSim); i++) {
-        auto ir = evrec[i];
-        auto ir0 = o2::raw::HBFUtils::Instance().getFirstIRofTF(ir);
-        float timebin = (float)ir.differenceInBC(ir0) / o2::tpc::constants::LHCBCPERTIMEBIN;
+        const float timebin = evTimeBins[iSim][i];
 
         const std::vector<o2::MCTrack>& tracks = mcReader.getTracks(iSim, i);
         const std::vector<o2::TrackReference>& trackRefs = mcReader.getTrackRefsByEvent(iSim, i);
@@ -1295,6 +1313,9 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         if (mc1.pid < 0) {
           continue;
         }
+        if (mc1.t0 == -100.f) {
+          continue;
+        }
         if (mConfig.filterCharge && mc1.charge * mConfig.filterCharge < 0) {
           continue;
         }

From 7278b4e3e47ad2bc5c7f527ee72e4b2e203ec3ae Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Mon, 25 Aug 2025 13:33:39 +0200
Subject: [PATCH 0747/1764] TPC: sort buffer of pressure in case it is not
 sorted

- allocate enough memory to prevent reallocation
---
 DataFormats/Detectors/TPC/src/DCS.cxx | 27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/DataFormats/Detectors/TPC/src/DCS.cxx b/DataFormats/Detectors/TPC/src/DCS.cxx
index 14c3887f8e8ae..b56d07acd7c73 100644
--- a/DataFormats/Detectors/TPC/src/DCS.cxx
+++ b/DataFormats/Detectors/TPC/src/DCS.cxx
@@ -329,12 +329,27 @@ void fillBuffer(std::pair<std::vector<float>, std::vector<TimeStampType>>& buffe
     }
   }
 
-  std::pair<std::vector<float>, std::vector<TimeStampType>> buffTmp{
-    std::vector<float>(buffer.first.begin() + idxStartBuffer, buffer.first.end()),
-    std::vector<TimeStampType>(buffer.second.begin() + idxStartBuffer, buffer.second.end())};
-
-  buffTmp.first.insert(buffTmp.first.end(), values.first.begin(), values.first.end());
-  buffTmp.second.insert(buffTmp.second.end(), values.second.begin(), values.second.end());
+  std::pair<std::vector<float>, std::vector<TimeStampType>> buffTmp;
+  auto& [buffVals, buffTimes] = buffTmp;
+
+  // Preallocate enough capacity to avoid reallocations
+  buffVals.reserve(buffer.first.size() - idxStartBuffer + values.first.size());
+  buffTimes.reserve(buffer.second.size() - idxStartBuffer + values.second.size());
+  // Insert the kept part of the old buffer
+  buffVals.insert(buffVals.end(), buffer.first.begin() + idxStartBuffer, buffer.first.end());
+  buffTimes.insert(buffTimes.end(), buffer.second.begin() + idxStartBuffer, buffer.second.end());
+  // Insert the new values
+  buffVals.insert(buffVals.end(), values.first.begin(), values.first.end());
+  buffTimes.insert(buffTimes.end(), values.second.begin(), values.second.end());
+
+  // this should not happen
+  if (!std::is_sorted(buffTimes.begin(), buffTimes.end())) {
+    LOGP(info, "Pressure buffer not sorted after filling - sorting it");
+    std::vector<size_t> idx(buffTimes.size());
+    o2::math_utils::SortData(buffTimes, idx);
+    o2::math_utils::Reorder(buffVals, idx);
+    o2::math_utils::Reorder(buffTimes, idx);
+  }
 
   buffer = std::move(buffTmp);
 }

From de1d18e3004532769346bce46c489c5028f4e4a4 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Mon, 25 Aug 2025 18:36:35 +0200
Subject: [PATCH 0748/1764] start_tmux.sh: use o2-ccdb.internal for ccdb
 requests

---
 prodtests/full-system-test/start_tmux.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/start_tmux.sh b/prodtests/full-system-test/start_tmux.sh
index 39922ea5503d2..22b603f48a0d0 100755
--- a/prodtests/full-system-test/start_tmux.sh
+++ b/prodtests/full-system-test/start_tmux.sh
@@ -38,7 +38,7 @@ if [[ "0$FST_TMUX_NO_EPN" != "01" ]]; then
   [[ -z $EPNPIPELINES ]] && export EPNPIPELINES=1
   [[ -z $O2_GPU_DOUBLE_PIPELINE ]] && export O2_GPU_DOUBLE_PIPELINE=1
   [[ -z $O2_GPU_RTC ]] && export O2_GPU_RTC=1
-  [[ -z $DPL_CONDITION_BACKEND ]] && export DPL_CONDITION_BACKEND="http://localhost:8084"
+  [[ -z $DPL_CONDITION_BACKEND ]] && export DPL_CONDITION_BACKEND="http://o2-ccdb.internal"
   export ALL_EXTRA_CONFIG="$ALL_EXTRA_CONFIG;NameConf.mCCDBServer=${DPL_CONDITION_BACKEND};"
   export GEN_TOPO_QC_OVERRIDE_CCDB_SERVER="${DPL_CONDITION_BACKEND}"
   [[ -z $NUM_DPL_WORKFLOWS ]] && NUM_DPL_WORKFLOWS=2

From e1ff91130bc03a20e7c5c69b43e748d911497d23 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 26 Aug 2025 15:47:43 +0200
Subject: [PATCH 0749/1764] Add HBFUtilsConfig to allow standalone aggregation
 of TPC residuals

---
 .../src/tpc-residual-aggregator.cxx                   | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx
index bd21b8ac22116..20e37c3bcc3b4 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-residual-aggregator.cxx
@@ -14,10 +14,17 @@
 #include "TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h"
 #include "TPCInterpolationWorkflow/TPCUnbinnedResidualReaderSpec.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "Framework/CallbacksPolicy.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
 
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
+{
+  o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
+
 // we need to add workflow options before including Framework/runDataProcessing
 void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 {
@@ -27,6 +34,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"enable-ctp", VariantType::Bool, false, {"Subscribe to lumi info from CTP"}},
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input readers"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -79,5 +87,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, maskClusters, maskNone, maskNone, false);
   }
 
+  // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
+  o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
+
   return specs;
 }

From a4dd82a477faaed73df27828e562d3db3c89934b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 23 Jul 2025 14:43:00 +0200
Subject: [PATCH 0750/1764] Fix alignment so that jemalloc / address sanitizer
 do no complain

This apparently fixes the issues with std::pmr in DataDistribution.
---
 DataFormats/Headers/include/Headers/Stack.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index 40987c483e1b8..0958b639ef451 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -38,7 +38,7 @@ struct Stack {
   struct freeobj {
     freeobj(memory_resource* mr) : resource(mr) {}
     memory_resource* resource{nullptr};
-    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, 0); }
+    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, alignof(std::max_align_t)); }
   };
 
  public:

From ff42ca25aacfede2281b8981ada42aa6dd59695e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 13 Aug 2025 17:59:46 +0200
Subject: [PATCH 0751/1764] Data Model: provide size when deallocating a Stack

---
 DataFormats/Headers/include/Headers/Stack.h | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/DataFormats/Headers/include/Headers/Stack.h b/DataFormats/Headers/include/Headers/Stack.h
index 0958b639ef451..9770df9fa54ef 100644
--- a/DataFormats/Headers/include/Headers/Stack.h
+++ b/DataFormats/Headers/include/Headers/Stack.h
@@ -36,9 +36,10 @@ struct Stack {
 
  private:
   struct freeobj {
-    freeobj(memory_resource* mr) : resource(mr) {}
+    freeobj(memory_resource* mr, size_t s) : resource(mr), size(s) {}
     memory_resource* resource{nullptr};
-    void operator()(std::byte* ptr) { resource->deallocate(ptr, 0, alignof(std::max_align_t)); }
+    size_t           size{0};
+    void operator()(std::byte* ptr) { resource->deallocate(ptr, size, alignof(std::max_align_t)); }
   };
 
  public:
@@ -99,7 +100,7 @@ struct Stack {
   Stack(const allocator_type allocatorArg, Headers&&... headers)
     : allocator{allocatorArg},
       bufferSize{calculateSize(std::forward<Headers>(headers)...)},
-      buffer{static_cast<std::byte*>(allocator.resource()->allocate(bufferSize, alignof(std::max_align_t))), freeobj{allocator.resource()}}
+      buffer{static_cast<std::byte*>(allocator.resource()->allocate(bufferSize, alignof(std::max_align_t))), freeobj{allocator.resource(), bufferSize}}
   {
     if constexpr (sizeof...(headers) > 1) {
       injectAll(buffer.get(), std::forward<Headers>(headers)...);
@@ -142,7 +143,7 @@ struct Stack {
  private:
   allocator_type allocator{fair::mq::pmr::new_delete_resource()};
   size_t bufferSize{0};
-  BufferType buffer{nullptr, freeobj{allocator.resource()}};
+  BufferType buffer{nullptr, freeobj{allocator.resource(), 0}};
 
   //______________________________________________________________________________________________
   template <typename T>

From dec2fe8515bfb431c911a4121cc1ebdcd0e77381 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 27 Aug 2025 08:33:52 +0200
Subject: [PATCH 0752/1764] A3: Add customization of detector
 MID/Magnet/Absorber radius (#14621)

---
 .../MID/base/include/MI3Base/MI3BaseParam.h   | 12 ++++
 .../ALICE3/MID/simulation/src/Detector.cxx    | 12 +++-
 .../Alice3DetectorsPassive/PassiveBaseParam.h |  6 ++
 .../Upgrades/ALICE3/Passive/src/Absorber.cxx  | 66 +++++++++++++------
 .../Upgrades/ALICE3/Passive/src/Magnet.cxx    | 40 +++++++++--
 5 files changed, 110 insertions(+), 26 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/MID/base/include/MI3Base/MI3BaseParam.h b/Detectors/Upgrades/ALICE3/MID/base/include/MI3Base/MI3BaseParam.h
index 7061a05bfeb37..913e27e85c207 100644
--- a/Detectors/Upgrades/ALICE3/MID/base/include/MI3Base/MI3BaseParam.h
+++ b/Detectors/Upgrades/ALICE3/MID/base/include/MI3Base/MI3BaseParam.h
@@ -19,7 +19,19 @@ namespace o2
 {
 namespace mi3
 {
+
+// **
+// ** Parameters for MID base configuration
+// **
+
+enum MIDLayout : int {
+  StandardRadius = 0,
+  ReducedRadius = 1
+};
+
 struct MIDBaseParam : public o2::conf::ConfigurableParamHelper<MIDBaseParam> {
+  int mLayout = MIDLayout::StandardRadius;
+
   O2ParamDef(MIDBaseParam, "MIDBase");
 };
 
diff --git a/Detectors/Upgrades/ALICE3/MID/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/MID/simulation/src/Detector.cxx
index 36f5b376563c0..0eaf401e40596 100644
--- a/Detectors/Upgrades/ALICE3/MID/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/MID/simulation/src/Detector.cxx
@@ -126,8 +126,16 @@ void Detector::createGeometry()
 
   // Build the MID
   mLayers.resize(2);
-  mLayers[0] = MIDLayer(0, GeometryTGeo::composeSymNameLayer(0), 301.f, 500.f);
-  mLayers[1] = MIDLayer(1, GeometryTGeo::composeSymNameLayer(1), 311.f, 520.f); // arbitrarily reduced to get multiple of 5.2f
+  auto& midParam = MIDBaseParam::Instance();
+  const bool standardRadius = (midParam.mLayout == o2::mi3::MIDLayout::StandardRadius);
+
+  if (standardRadius) {
+    mLayers[0] = MIDLayer(0, GeometryTGeo::composeSymNameLayer(0), 301.f, 500.f);
+    mLayers[1] = MIDLayer(1, GeometryTGeo::composeSymNameLayer(1), 311.f, 520.f); // arbitrarily reduced to get multiple of 5.2f
+  } else {
+    mLayers[0] = MIDLayer(0, GeometryTGeo::composeSymNameLayer(0), 266.f, 500.f);
+    mLayers[1] = MIDLayer(1, GeometryTGeo::composeSymNameLayer(1), 276.f, 520.f);
+  }
 
   for (auto& layer : mLayers) {
     layer.createLayer(vMID);
diff --git a/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/PassiveBaseParam.h b/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/PassiveBaseParam.h
index 3ac53c1bfb92b..671f436aabe7b 100644
--- a/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/PassiveBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/Passive/include/Alice3DetectorsPassive/PassiveBaseParam.h
@@ -29,10 +29,16 @@ enum MagnetLayout : int {
   CopperStabilizer = 1
 };
 
+enum DetLayout : int {
+  StandardRadius = 0,
+  ReducedRadius = 1
+};
+
 struct Alice3PassiveBaseParam : public o2::conf::ConfigurableParamHelper<Alice3PassiveBaseParam> {
   // Geometry Builder parameters
 
   int mLayout = MagnetLayout::AluminiumStabilizer;
+  int mDetLayout = DetLayout::StandardRadius;
 
   O2ParamDef(Alice3PassiveBaseParam, "Alice3PassiveBase");
 };
diff --git a/Detectors/Upgrades/ALICE3/Passive/src/Absorber.cxx b/Detectors/Upgrades/ALICE3/Passive/src/Absorber.cxx
index 7ce753db89536..924d977247c89 100644
--- a/Detectors/Upgrades/ALICE3/Passive/src/Absorber.cxx
+++ b/Detectors/Upgrades/ALICE3/Passive/src/Absorber.cxx
@@ -12,6 +12,7 @@
 #include <DetectorsBase/Detector.h>
 #include <DetectorsBase/MaterialManager.h>
 #include <Alice3DetectorsPassive/Absorber.h>
+#include <Alice3DetectorsPassive/PassiveBaseParam.h>
 #include <TGeoArb8.h> // for TGeoTrap
 #include <TGeoCompositeShape.h>
 #include <TGeoCone.h>
@@ -130,25 +131,52 @@ void Alice3Absorber::ConstructGeometry()
   }
 
   TGeoPcon* absorings = new TGeoPcon(0., 360., 18);
-
-  absorings->DefineSection(0, 500, 236, 274);
-  absorings->DefineSection(1, 400, 236, 274);
-  absorings->DefineSection(2, 400, 232.5, 277.5);
-  absorings->DefineSection(3, 300, 232.5, 277.5);
-  absorings->DefineSection(4, 300, 227.5, 282.5);
-  absorings->DefineSection(5, 200, 227.5, 282.5);
-  absorings->DefineSection(6, 200, 222.5, 287.5);
-  absorings->DefineSection(7, 100, 222.5, 287.5);
-  absorings->DefineSection(8, 100, 220, 290);
-  absorings->DefineSection(9, -100, 220, 290);
-  absorings->DefineSection(10, -100, 222.5, 287.5);
-  absorings->DefineSection(11, -200, 222.5, 287.5);
-  absorings->DefineSection(12, -200, 227.5, 282.5);
-  absorings->DefineSection(13, -300, 227.5, 282.5);
-  absorings->DefineSection(14, -300, 232.5, 277.5);
-  absorings->DefineSection(15, -400, 232.5, 277.5);
-  absorings->DefineSection(16, -400, 236, 274);
-  absorings->DefineSection(17, -500, 236, 274);
+  auto& passiveBaseParam = Alice3PassiveBaseParam::Instance();
+  switch (passiveBaseParam.mDetLayout) {
+    case o2::passive::DetLayout::StandardRadius:
+      absorings->DefineSection(0, 500, 236, 274);
+      absorings->DefineSection(1, 400, 236, 274);
+      absorings->DefineSection(2, 400, 232.5, 277.5);
+      absorings->DefineSection(3, 300, 232.5, 277.5);
+      absorings->DefineSection(4, 300, 227.5, 282.5);
+      absorings->DefineSection(5, 200, 227.5, 282.5);
+      absorings->DefineSection(6, 200, 222.5, 287.5);
+      absorings->DefineSection(7, 100, 222.5, 287.5);
+      absorings->DefineSection(8, 100, 220, 290);
+      absorings->DefineSection(9, -100, 220, 290);
+      absorings->DefineSection(10, -100, 222.5, 287.5);
+      absorings->DefineSection(11, -200, 222.5, 287.5);
+      absorings->DefineSection(12, -200, 227.5, 282.5);
+      absorings->DefineSection(13, -300, 227.5, 282.5);
+      absorings->DefineSection(14, -300, 232.5, 277.5);
+      absorings->DefineSection(15, -400, 232.5, 277.5);
+      absorings->DefineSection(16, -400, 236, 274);
+      absorings->DefineSection(17, -500, 236, 274);
+      break;
+    case o2::passive::DetLayout::ReducedRadius:
+      absorings->DefineSection(0, 500, 201, 239);
+      absorings->DefineSection(1, 400, 201, 239);
+      absorings->DefineSection(2, 400, 197.5, 242.5);
+      absorings->DefineSection(3, 300, 197.5, 242.5);
+      absorings->DefineSection(4, 300, 192.5, 247.5);
+      absorings->DefineSection(5, 200, 192.5, 247.5);
+      absorings->DefineSection(6, 200, 187.5, 252.5);
+      absorings->DefineSection(7, 100, 187.5, 252.5);
+      absorings->DefineSection(8, 100, 185, 255);
+      absorings->DefineSection(9, -100, 185, 255);
+      absorings->DefineSection(10, -100, 187.5, 252.5);
+      absorings->DefineSection(11, -200, 187.5, 252.5);
+      absorings->DefineSection(12, -200, 192.5, 247.5);
+      absorings->DefineSection(13, -300, 192.5, 247.5);
+      absorings->DefineSection(14, -300, 197.5, 242.5);
+      absorings->DefineSection(15, -400, 197.5, 242.5);
+      absorings->DefineSection(16, -400, 201, 239);
+      absorings->DefineSection(17, -500, 201, 239);
+      break;
+    default:
+      LOG(fatal) << "Unknown detector layout " << passiveBaseParam.mDetLayout;
+      break;
+  }
 
   // Insert
   absorings->SetName("absorings");
diff --git a/Detectors/Upgrades/ALICE3/Passive/src/Magnet.cxx b/Detectors/Upgrades/ALICE3/Passive/src/Magnet.cxx
index 5c94c3e31a244..e6c1171829bfc 100644
--- a/Detectors/Upgrades/ALICE3/Passive/src/Magnet.cxx
+++ b/Detectors/Upgrades/ALICE3/Passive/src/Magnet.cxx
@@ -106,11 +106,41 @@ void Alice3Magnet::ConstructGeometry()
 
   // Passive Base configuration parameters
   auto& passiveBaseParam = Alice3PassiveBaseParam::Instance();
-  const bool doCopperStabilizer = (passiveBaseParam.mLayout == o2::passive::MagnetLayout::CopperStabilizer);
-  if (doCopperStabilizer) {
-    mRestMaterialThickness -= 3.3; // cm Remove the Aluminium stabiliser
-    mRestMaterialThickness += 2.2; // cm Add the Copper stabiliser
-    LOG(debug) << "Alice 3 magnet: using Copper Stabilizer with thickness " << mRestMaterialThickness << " cm";
+
+  switch (passiveBaseParam.mDetLayout) {
+    case o2::passive::DetLayout::StandardRadius:
+      // Defined in the header file
+      break;
+    case o2::passive::DetLayout::ReducedRadius:
+      mInnerWrapInnerRadius = 125.f; // cm
+      mInnerWrapThickness = 1.f;     // cm
+      mCoilInnerRadius = 145.f;      // cm
+      mCoilThickness = 0.3f;         // cm
+      mRestMaterialRadius = 145.3f;  // cm
+      mRestMaterialThickness = 6.8f; // cm
+      mOuterWrapInnerRadius = 165.f; // cm
+      mOuterWrapThickness = 3.f;     // cm
+      mZLength = 800.f;              // cm
+      break;
+    default:
+      LOG(fatal) << "Unknown detector layout " << passiveBaseParam.mDetLayout;
+      break;
+  }
+
+  bool doCopperStabilizer = false;
+  switch (passiveBaseParam.mLayout) {
+    case o2::passive::MagnetLayout::AluminiumStabilizer:
+      // Handled in the header file
+      break;
+    case o2::passive::MagnetLayout::CopperStabilizer:
+      doCopperStabilizer = true;
+      mRestMaterialThickness -= 3.3; // cm Remove the Aluminium stabiliser
+      mRestMaterialThickness += 2.2; // cm Add the Copper stabiliser
+      LOG(debug) << "Alice 3 magnet: using Copper Stabilizer with thickness " << mRestMaterialThickness << " cm";
+      break;
+    default:
+      LOG(fatal) << "Unknown magnet layout " << passiveBaseParam.mLayout;
+      break;
   }
 
   TGeoManager* geoManager = gGeoManager;

From 8735573dd1cbccd27167cb8040e08718774336e9 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Wed, 27 Aug 2025 08:37:49 +0200
Subject: [PATCH 0753/1764] ALICE3-TRK: first version of working digitizer
 (#14619)

* ALICE3-TRK: correctly setting the path to retrieve matrices from the geometry

* ALICE3-TRK: setting basis for digitization code - definition of a simple segmentation, adding methods to deal with the curved VD layers, adding chip response based on ITS2 and ITS3 codes, adding useful codes for parameters, digit containers, etc.

* ALICE3-TRK: improving segmentation, dealing with different silicon depth and pixel size wrt the APTS response

* ALICE3-TRK: adjusted curvedToFlat coordinate orientation

* ALICE3-TRK: first version of complete digitizer. Now the digits are stored in the trkdigits.root file

* ALICE3-TRK: fixing DigitROF setting

* Please consider the following formatting changes

* ALICE3-TRK: fixing copyright headers

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../Upgrades/ALICE3/TRK/base/CMakeLists.txt   |   4 +-
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |   2 +-
 .../base/include/TRKBase/SegmentationChip.h   | 282 ++++++
 .../ALICE3/TRK/base/include/TRKBase/Specs.h   | 129 +++
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      | 120 +--
 .../ALICE3/TRK/base/src/SegmentationChip.cxx  |  27 +
 .../ALICE3/TRK/simulation/CMakeLists.txt      |   9 +-
 .../TRKSimulation/ChipDigitsContainer.h       |  37 +
 .../include/TRKSimulation/ChipSimResponse.h   |  37 +
 .../include/TRKSimulation/DPLDigitizerParam.h |   2 +-
 .../include/TRKSimulation/DigiParams.h        | 135 +++
 .../include/TRKSimulation/Digitizer.h         |  86 +-
 .../simulation/src/ChipDigitsContainer.cxx    |  17 +
 .../TRK/simulation/src/ChipSimResponse.cxx    |  21 +
 .../ALICE3/TRK/simulation/src/DigiParams.cxx  |  72 ++
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   | 899 ++++++++++--------
 .../src/TRKDigitizerSpec.cxx                  |   7 +-
 17 files changed, 1395 insertions(+), 491 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/base/src/SegmentationChip.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipSimResponse.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipDigitsContainer.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipSimResponse.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/base/CMakeLists.txt
index a237a2d12211d..96ebf4ead4b7b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/base/CMakeLists.txt
@@ -12,8 +12,10 @@
 o2_add_library(TRKBase
                SOURCES src/GeometryTGeo.cxx
                        src/TRKBaseParam.cxx
+                       src/SegmentationChip.cxx
                PUBLIC_LINK_LIBRARIES O2::DetectorsBase)
 
 o2_target_root_dictionary(TRKBase
                HEADERS include/TRKBase/GeometryTGeo.h
-                       include/TRKBase/TRKBaseParam.h)
\ No newline at end of file
+                       include/TRKBase/TRKBaseParam.h
+                       include/TRKBase/SegmentationChip.h)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index cfd991728d09b..a1e4b9321130f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -73,7 +73,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   void setOwner(bool v) { mOwner = v; }
 
   void Print(Option_t* opt = "") const;
-  void PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int indexRetrieved) const;
+  void PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const;
 
   int getLayer(int index) const;
   int getStave(int index) const;
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
new file mode 100644
index 0000000000000..100af5be1b4d0
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
@@ -0,0 +1,282 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SegmentationChip.h
+/// \brief Definition of the SegmentationChipclass
+
+#ifndef ALICEO2_TRK_SEGMENTATIONCHIP_H_
+#define ALICEO2_TRK_SEGMENTATIONCHIP_H_
+
+#include <type_traits>
+#include <fairlogger/Logger.h>
+
+#include "MathUtils/Cartesian.h"
+#include "TRKBase/Specs.h"
+
+namespace o2::trk
+{
+
+/// Segmentation and response for TRK chips in ALICE3 upgrade
+/// This is a work-in-progress code derived from the ITS2 and ITS3 segmentations.
+class SegmentationChip
+{
+  // This class defines the segmenation of the TRK chips in the ALICE3 upgrade.
+  // The "global coordinate system" refers to the hit position in cm in the global coordinate system centered in 0,0,0
+  // The "local coordinate system" refers to the hit position in cm in the coordinate system of the sensor, which
+  // is centered in 0,0,0 in the case of curved layers, and in the middle of the chip in the case of flat layers
+  // The "detector coordinate system" refers to the hit position in row,col inside the sensor
+  // This class provides the transformations from the local and detector coordinate systems
+  // The conversion between global and local coordinate systems is operated by the transformation matrices
+  // For the curved VD layers there exist three coordinate systems and one is transient.
+  // 1. The global (curved) coordinate system. The chip's center of coordinate system is
+  //    defined at the the mid-point of the detector.
+  // 2. The local (flat) coordinate system. This is the tube segment projected onto a flat
+  //    surface. In the projection we implicitly assume that the inner and outer
+  //    stretch does not depend on the radius.
+  // 3. The detector coordinate system. Defined by the row and column segmentation
+  //    defined at the upper edge in the flat coord.
+  // For the flat ML and OT layers, there exist two coordinate systems:
+  // 1. The global (flat) coordinate system. The chip's center of coordinate system is
+  //    defined at the the mid-point of the detector.
+  // 2. The detector coordinate system. Defined by the row and column segmentation
+  // TODO: add segmentation for VD disks
+
+ public:
+  constexpr SegmentationChip() = default;
+  ~SegmentationChip() = default;
+  constexpr SegmentationChip(const SegmentationChip&) = default;
+  constexpr SegmentationChip(SegmentationChip&&) = delete;
+  constexpr SegmentationChip& operator=(const SegmentationChip&) = default;
+  constexpr SegmentationChip& operator=(SegmentationChip&&) = delete;
+
+  static constexpr float PitchColVD{constants::VD::petal::layer::pitchZ};
+  static constexpr float PitchRowVD{constants::VD::petal::layer::pitchX};
+
+  static constexpr float PitchColMLOT{constants::moduleMLOT::chip::pitchZ};
+  static constexpr float PitchRowMLOT{constants::moduleMLOT::chip::pitchX};
+
+  static constexpr float SensorLayerThicknessVD = {constants::VD::petal::layer::totalThickness}; // physical thickness of sensitive part = 30 um
+  static constexpr float SensorLayerThicknessML = {constants::moduleMLOT::chip::totalThickness}; // physical thickness of sensitive part = 100 um
+  static constexpr float SensorLayerThicknessOT = {constants::moduleMLOT::chip::totalThickness}; // physical thickness of sensitive part = 100 um
+
+  static constexpr float SiliconThicknessVD = constants::VD::silicon::thickness;           // effective thickness of sensitive part
+  static constexpr float SiliconThicknessMLOT = constants::moduleMLOT::silicon::thickness; // effective thickness of sensitive part
+
+  static constexpr std::array<double, constants::VD::petal::nLayers> radiiVD = constants::VD::petal::layer::radii;
+
+  /// Transformation from Geant detector centered local coordinates (cm) to
+  /// Pixel cell numbers iRow and iCol.
+  /// Returns kTRUE if point x,z is inside sensitive volume, kFALSE otherwise.
+  /// A value of -1 for iRow or iCol indicates that this point is outside of the
+  /// detector segmentation as defined.
+  /// \param float x Detector local coordinate x in cm with respect to
+  /// the center of the sensitive volume.
+  /// \param float z Detector local coordinate z in cm with respect to
+  /// the center of the sensitive volulme.
+  /// \param int iRow Detector x cell coordinate. Has the range 0 <= iRow < mNumberOfRows
+  /// \param int iCol Detector z cell coordinate. Has the range 0 <= iCol < mNumberOfColumns
+  /// \param int subDetID Sub-detector ID (0 for VD, 1 for ML/OT)
+  /// \param int layer Layer number (0 to 2 for VD, 0 to 7 for ML/OT)
+  /// \param int disk Disk number (0 to 5 for VD)
+  static bool localToDetector(float xRow, float zCol, int& iRow, int& iCol, int subDetID, int layer, int disk) noexcept
+  {
+    if (!isValidGlob(xRow, zCol, subDetID, layer)) {
+      LOGP(debug, "Local coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
+      return false;
+    }
+    localToDetectorUnchecked(xRow, zCol, iRow, iCol, subDetID, layer, disk);
+
+    LOG(debug) << "Result from localToDetectorUnchecked: xRow " << xRow << " -> iRow " << iRow << ", zCol " << zCol << " -> iCol " << iCol << " on subDetID, layer, disk: " << subDetID << " " << layer << " " << disk;
+
+    if (!isValidDet(iRow, iCol, subDetID, layer)) {
+      iRow = iCol = -1;
+      LOGP(debug, "Detector coordinates not valid: iRow = {}, iCol = {}", iRow, iCol);
+      return false;
+    }
+    return true;
+  };
+  /// same but w/o check for row/column range
+  static void localToDetectorUnchecked(float xRow, float zCol, int& iRow, int& iCol, int subDetID, int layer, int disk) noexcept
+  {
+    // convert to row/col w/o over/underflow check
+    float pitchRow(0), pitchCol(0);
+    float maxWidth(0), maxLength(0);
+
+    if (subDetID == 0) {
+      pitchRow = PitchRowVD;
+      pitchCol = PitchColVD;
+      maxWidth = constants::VD::petal::layer::width[layer];
+      maxLength = constants::VD::petal::layer::length;
+      // TODO: change this to use the layer and disk
+    } else if (subDetID == 1 && layer <= 3) { // ML
+      pitchRow = PitchRowMLOT;
+      pitchCol = PitchColMLOT;
+      maxWidth = constants::ML::width;
+      maxLength = constants::ML::length;
+    } else if (subDetID == 1 && layer >= 4) { // OT
+      pitchRow = PitchRowMLOT;
+      pitchCol = PitchColMLOT;
+      maxWidth = constants::OT::width;
+      maxLength = constants::OT::length;
+    }
+    // convert to row/col
+    iRow = static_cast<int>(std::floor((maxWidth / 2 - xRow) / pitchRow));
+    iCol = static_cast<int>(std::floor((zCol + maxLength / 2) / pitchCol));
+  };
+
+  // Check local coordinates (cm) validity.
+  static constexpr bool isValidGlob(float x, float z, int subDetID, int layer) noexcept
+  {
+    float maxWidth(0), maxLength(0);
+    if (subDetID == 0) {
+      maxWidth = constants::VD::petal::layer::width[layer];
+      maxLength = constants::VD::petal::layer::length;
+      // TODO: change this to use the layer and disk
+    } else if (subDetID == 1 && layer <= 3) { // ML
+      maxWidth = constants::ML::width;
+      maxLength = constants::ML::length;
+    } else if (subDetID == 1 && layer >= 4) { // OT
+      maxWidth = constants::OT::width;
+      maxLength = constants::OT::length;
+    }
+    return (-maxWidth / 2 < x && x < maxWidth / 2 && -maxLength / 2 < z && z < maxLength / 2);
+  }
+
+  // Check detector coordinates validity.
+  static constexpr bool isValidDet(float row, float col, int subDetID, int layer) noexcept
+  {
+    // Check if the row and column are within the valid range
+    int nRows(0), nCols(0);
+    if (subDetID == 0) {
+      nRows = constants::VD::petal::layer::nRows[layer];
+      nCols = constants::VD::petal::layer::nCols;
+      // TODO: change this to use the layer and disk
+    } else if (subDetID == 1 && layer <= 3) { // ML
+      nRows = constants::ML::nRows;
+      nCols = constants::ML::nCols;
+    } else if (subDetID == 1 && layer >= 4) { // OT
+      nRows = constants::OT::nRows;
+      nCols = constants::OT::nCols;
+    }
+    return (row >= 0 && row < static_cast<float>(nRows) && col >= 0 && col < static_cast<float>(nCols));
+  }
+
+  /// Transformation from Detector cell coordinates to Geant detector centered
+  /// local coordinates (cm)
+  /// \param int iRow Detector x cell coordinate.
+  /// \param int iCol Detector z cell coordinate.
+  /// \param float x Detector local coordinate x in cm with respect to the
+  /// center of the sensitive volume.
+  /// \param float z Detector local coordinate z in cm with respect to the
+  /// center of the sensitive volume.
+  /// If iRow and or iCol is outside of the segmentation range a value of -0.5*Dx()
+  /// or -0.5*Dz() is returned.
+  /// \param int subDetID Sub-detector ID (0 for VD, 1 for ML/OT)
+  /// \param int layer Layer number (0 to 2 for VD, 0 to 7 for ML/OT)
+  /// \param int disk Disk number (0 to 5 for VD)
+  static constexpr bool detectorToLocal(int iRow, int iCol, float& xRow, float& zCol, int subDetID, int layer, int disk) noexcept
+  {
+    if (!isValidDet(iRow, iCol, subDetID, layer)) {
+      LOGP(debug, "Detector coordinates not valid: iRow = {}, iCol = {}", iRow, iCol);
+      return false;
+    }
+    detectorToLocalUnchecked(iRow, iCol, xRow, zCol, subDetID, layer, disk);
+    LOG(debug) << "Result from detectorToLocalUnchecked: iRow " << iRow << " -> xRow " << xRow << ", iCol " << iCol << " -> zCol " << zCol << " on subDetID, layer, disk: " << subDetID << " " << layer << " " << disk;
+
+    if (!isValidGlob(xRow, zCol, subDetID, layer)) {
+      LOGP(debug, "Local coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
+      return false;
+    }
+    return true;
+  };
+
+  // Same as detectorToLocal w.o. checks.
+  // We position ourself in the middle of the pixel.
+  static void detectorToLocalUnchecked(int row, int col, float& xRow, float& zCol, int subDetID, int layer, int disk) noexcept
+  {
+    /// xRow = half chip width - iRow(center) * pitch
+    /// zCol = iCol * pitch - half chip lenght
+    if (subDetID == 0) {
+      xRow = 0.5 * (constants::VD::petal::layer::width[layer] - PitchRowVD) - (row * PitchRowVD);
+      zCol = col * PitchColVD + 0.5 * (PitchColVD - constants::VD::petal::layer::length);
+    } else if (subDetID == 1 && layer <= 3) { // ML
+      xRow = 0.5 * (constants::ML::width - PitchRowMLOT) - (row * PitchRowMLOT);
+      zCol = col * PitchRowMLOT + 0.5 * (PitchRowMLOT - constants::ML::length);
+    } else if (subDetID == 1 && layer >= 4) { // OT
+      xRow = 0.5 * (constants::OT::width - PitchRowMLOT) - (row * PitchRowMLOT);
+      zCol = col * PitchColMLOT + 0.5 * (PitchColMLOT - constants::OT::length);
+    }
+  }
+
+  /// Transformation from the curved surface to a flat surface.
+  /// Additionally a shift in the flat coordinates must be applied because
+  /// the center of the TGeoShap when projected will be higher than the
+  /// physical thickness of the chip. Thus we shift the projected center
+  /// down by this difference to align the coordinate systems.
+  /// \param layer VD layer number
+  /// \param xCurved Detector local curved coordinate x in cm with respect to
+  /// the center of the sensitive volume.
+  /// \param yCurved Detector local curved coordinate y in cm with respect to
+  /// the center of the sensitive volume.
+  /// \return math_utils::Vector2D<float>: x and y represent the detector local flat coordinates x and y
+  // in cm with respect to the center of the sensitive volume.
+  static math_utils::Vector2D<float> curvedToFlat(const int layer, const float xCurved, const float yCurved) noexcept
+  {
+    // Align the flat surface with the curved survace of the original chip (and account for metal stack, TODO)
+    float dist = std::hypot(xCurved, yCurved);
+    float phi = std::atan2(yCurved, xCurved);
+
+    // the y position is in the silicon volume however we need the chip volume (silicon+metalstack)
+    // this is accounted by a y shift
+    float xFlat = constants::VD::petal::layer::radii[layer] * phi; /// this is equal to the circumference segment covered between y=0 and the phi angle
+    float yFlat = constants::VD::petal::layer::radii[layer] - dist;
+    return math_utils::Vector2D<float>(xFlat, yFlat);
+  }
+
+  /// Transformation from the flat surface to a curved surface
+  /// It works only if the detector is not rototraslated.
+  /// \param layer VD layer number
+  /// \param xFlat Detector local flat coordinate x in cm with respect to
+  /// the center of the sensitive volume.
+  /// \param yFlat Detector local flat coordinate y in cm with respect to
+  /// the center of the sensitive volume.
+  /// \return math_utils::Vector2D<float>: x and y represent the detector local curved coordinates x and y
+  // in cm with respect to the center of the sensitive volume.
+  static constexpr math_utils::Vector2D<float> flatToCurved(int layer, float xFlat, float yFlat) noexcept
+  {
+    // Revert the curvedToFlat transformation
+    float dist = constants::VD::petal::layer::radii[layer] - yFlat;
+    float phi = xFlat / constants::VD::petal::layer::radii[layer];
+    // the y position is in the chip volume however we need the silicon volume
+    // this is accounted by a -y shift
+    float xCurved = dist * std::cos(phi);
+    float yCurved = dist * std::sin(phi);
+    return math_utils::Vector2D<float>(xCurved, yCurved);
+  }
+
+  /// Print segmentation info
+  static const void Print() noexcept
+  {
+    LOG(info) << "Number of rows:\nVD L0: " << constants::VD::petal::layer::nRows[0]
+              << "\nVD L1: " << constants::VD::petal::layer::nRows[1]
+              << "\nVD L2: " << constants::VD::petal::layer::nRows[2]
+              << "\nML stave: " << constants::ML::nRows
+              << "\nOT stave: " << constants::OT::nRows;
+
+    LOG(info) << "Number of cols:\nVD: " << constants::VD::petal::layer::nCols
+              << "\nML stave: " << constants::ML::nCols
+              << "\nOT stave: " << constants::OT::nCols;
+  }
+};
+
+} // namespace o2::trk
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
new file mode 100644
index 0000000000000..373e9d972656b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -0,0 +1,129 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Specs.h
+/// \brief specs of the ALICE3 TRK
+
+#ifndef O2_ALICE_TRK_SPECS
+#define O2_ALICE_TRK_SPECS
+
+#include <array>
+#include <math.h>
+// This is a temporary version with the specs for the ALICE3 TRK
+// This files defines the design specifications of the chips for VD, ML, OT.
+// Each TGeoShape has the following properties
+// length: dimension in z-axis
+// width: dimension in xy-axes
+// color: for visulisation
+namespace o2::trk::constants
+{
+// Default unit of TGeo = cm
+constexpr double cm{1};
+constexpr double mu{1e-4};
+constexpr double mm{1e-1};
+
+namespace VD // TODO: add a primitive segmentation with more granularity wrt 1/4 layer = 1 chip
+{
+namespace silicon
+{
+constexpr double thickness{30 * mu}; // thickness of the silicon (should be 10 um epitaxial layer + 20 um substrate)?
+} // namespace silicon
+namespace metalstack
+{
+constexpr double thickness{0 * mu}; // thickness of the copper metal stack - for the moment it is not implemented
+} // namespace metalstack
+namespace petal
+{
+constexpr int nLayers{3}; // number of layers in each VD petal
+constexpr int nDisks{6};  // number of disks in each VD petal
+namespace layer
+{
+constexpr double pitchX{10 * mu};                                                                                                                        // pitch of the row
+constexpr double pitchZ{10 * mu};                                                                                                                        // pitch of the column
+constexpr double totalThickness{silicon::thickness + metalstack::thickness};                                                                             // total thickness of the chip
+constexpr std::array<double, nLayers> radii{0.5 * cm, 1.2 * cm, 2.5 * cm};                                                                               // radius of layer in cm
+constexpr std::array<double, nLayers> width{radii[0] * 2 * M_PI / 4, radii[1] * 2 * M_PI / 4, radii[2] * 2 * M_PI / 4};                                  // width of the quarter of layer in cm
+constexpr double length{50 * cm};                                                                                                                        // length of the layer
+constexpr int nCols{static_cast<int>(length / pitchZ)};                                                                                                  // number of columns in the chip
+constexpr std::array<int, nLayers> nRows{static_cast<int>(width[0] / pitchX), static_cast<int>(width[1] / pitchX), static_cast<int>(width[2] / pitchX)}; // number of rows in the chip. For the moment is different for each layer since a siner segmentation in repetitive units is stil to be implemented
+
+} // namespace layer
+namespace disk
+{ //// TODO: to be filled
+constexpr double radiusIn{0.5 * cm};
+constexpr double radiusOut{2.5 * cm};
+} // namespace disk
+} // namespace petal
+} // namespace VD
+
+namespace moduleMLOT /// same for ML and OT for the moment
+{                    /// TODO: account for different modules in case of changes
+namespace silicon
+{
+constexpr double thickness{100 * mu}; // thickness of the silicon (should be 10 um epitaxial layer + 90 um substrate)?
+} // namespace silicon
+namespace metalstack
+{
+constexpr double thickness{0 * mu}; // thickness of the copper metal stack - for the moment it is not implemented
+} // namespace metalstack
+namespace chip
+{
+constexpr double width{25 * mm};                                             // width of the chip
+constexpr double length{32 * mm};                                            // length of the chip
+constexpr double pitchX{50 * mu};                                            // pitch of the row
+constexpr double pitchZ{50 * mu};                                            // pitch of the column
+constexpr int nRows{static_cast<int>(width / pitchX)};                       // number of columns in the chip
+constexpr int nCols{static_cast<int>(length / pitchZ)};                      // number of rows in the chip
+constexpr double totalThickness{silicon::thickness + metalstack::thickness}; // total thickness of the chip
+/// Set to 0 for the moment, to be adjusted with the actual design of the chip if needed
+static constexpr float PassiveEdgeReadOut = 0.f; // width of the readout edge (Passive bottom)
+static constexpr float PassiveEdgeTop = 0.f;     // Passive area on top
+static constexpr float PassiveEdgeSide = 0.f;    // width of Passive area on left/right of the sensor
+} // namespace chip
+namespace gaps
+{
+constexpr double interChips{0.2 * mm};         // gap between the chips
+constexpr double outerEdgeLongSide{1 * mm};    // gap between the chips and the outer edges (long side)
+constexpr double outerEdgeShortSide{0.1 * mm}; // gap between the chips and the outer edges (short side)
+} // namespace gaps
+constexpr double width{chip::width * 2 + gaps::interChips + 2 * gaps::outerEdgeLongSide};        // width of the module
+constexpr double length{chip::length * 4 + 3 * gaps::interChips + 2 * gaps::outerEdgeShortSide}; // length of the module
+constexpr int nRows{static_cast<int>(width / chip::pitchX)};                                     // number of columns in the module
+constexpr int nCols{static_cast<int>(length / chip::pitchZ)};                                    // number of rows in the module
+} // namespace moduleMLOT
+
+namespace ML
+{
+constexpr double width{constants::moduleMLOT::width * 1};                            // width of the stave
+constexpr double length{constants::moduleMLOT::length * 10};                         // length of the stave
+constexpr int nRows{static_cast<int>(width / constants::moduleMLOT::chip::pitchX)};  // number of rows in the stave
+constexpr int nCols{static_cast<int>(length / constants::moduleMLOT::chip::pitchZ)}; // number of columns in the stave
+} // namespace ML
+
+namespace OT
+{                                                                         //// TODO: add shorter lenght of the stave of L4
+constexpr double width{moduleMLOT::width * 2};                            // width of the stave
+constexpr double length{moduleMLOT::length * 20};                         // length of the stave
+constexpr int nRows{static_cast<int>(width / moduleMLOT::chip::pitchX)};  // number of rows in the stave
+constexpr int nCols{static_cast<int>(length / moduleMLOT::chip::pitchZ)}; // number of columns in the stave
+} // namespace OT
+
+namespace apts /// parameters for the APTS response
+{
+constexpr double pitchX{15.0 * mu};
+constexpr double pitchZ{15.0 * mu};
+constexpr double responseYShift{15.5 * mu};
+constexpr double thickness{45 * mu};
+} // namespace apts
+
+} // namespace o2::trk::constants
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 69bae0fad9cee..20088179f4dcc 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -11,9 +11,9 @@
 
 #include <TRKBase/GeometryTGeo.h>
 #include <TGeoManager.h>
-// #include "TRKBase/SegmentationChip.h"
+#include "TRKBase/SegmentationChip.h"
 
-// using Segmentation = o2::trk::SegmentationChip;
+using Segmentation = o2::trk::SegmentationChip;
 
 namespace o2
 {
@@ -263,58 +263,35 @@ bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk
 TString GeometryTGeo::getMatrixPath(int index) const
 {
 
-  int subDetID, petalcase, disk, lay, stave, halfstave; //// TODO: add chips in a second step
-  getChipID(index, subDetID, petalcase, disk, lay, stave, halfstave);
+  int subDetID, petalcase, disk, layer, stave, halfstave; //// TODO: add chips in a second step
+  getChipID(index, subDetID, petalcase, disk, layer, stave, halfstave);
 
-  int indexRetrieved = getChipIndex(subDetID, petalcase, disk, lay, stave, halfstave);
+  // PrintChipID(index, subDetID, petalcase, disk, layer, stave, halfstave);
 
-  PrintChipID(index, subDetID, petalcase, disk, lay, stave, halfstave, indexRetrieved);
+  // TString path = "/cave_1/barrel_1/TRKV_2/TRKLayer0_1/TRKStave0_1/TRKChip0_1/TRKSensor0_1/"; /// dummy path, to be used for tests
+  TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
 
-  // TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
-  TString path = "/cave_1/barrel_1/TRKV_2/TRKLayer0_1/TRKStave0_1/TRKChip0_1/TRKSensor0_1/"; /// dummy path, to be replaced
-
-  // if (wrID >= 0) {
-  //   path += Form("%s%d_1/", getITSWrapVolPattern(), wrID);
-  // }
-
-  // if (isVD) {
-  //   path += Form("%s%d_1/", getTRKPetalPattern(), index);
-
-  // } else {
-  // path += Form("%s%d_1/", getTRKLayerPattern(), index);
-  // }
-
-  // if (!mIsLayerITS3[lay]) {
-  //   path +=
-  //     Form("%s%d_1/", getITSLayerPattern(), lay);
-  //   if (mNumberOfHalfBarrels > 0) {
-  //     path += Form("%s%d_%d/", getITSHalfBarrelPattern(), lay, hba);
-  //   }
-  //   path +=
-  //     Form("%s%d_%d/", getITSStavePattern(), lay, stav);
-
-  //   if (mNumberOfHalfStaves[lay] > 0) {
-  //     path += Form("%s%d_%d/", getITSHalfStavePattern(), lay, sstav);
-  //   }
-  //   if (mNumberOfModules[lay] > 0) {
-  //     path += Form("%s%d_%d/", getITSModulePattern(), lay, mod);
-  //   }
-  //   path += Form("%s%d_%d/%s%d_1", getITSChipPattern(), lay, chipInMod, getITSSensorPattern(), lay);
-  // } else {
-  //   // hba = carbonform
-  //   // stav = 0
-  //   // sstav = segment
-  //   // mod = rsu
-  //   // chipInMod = tile
-  //   // sensor = pixelarray
-  //   path += Form("%s_0/", getITS3LayerPattern(lay));
-  //   path += Form("%s_%d/", getITS3CarbonFormPattern(lay), hba);
-  //   path += Form("%s_0/", getITS3ChipPattern(lay));
-  //   path += Form("%s_%d/", getITS3SegmentPattern(lay), sstav);
-  //   path += Form("%s_%d/", getITS3RSUPattern(lay), mod);
-  //   path += Form("%s_%d/", getITS3TilePattern(lay), chipInMod);
-  //   path += Form("%s_0", getITS3PixelArrayPattern(lay));
-  // }
+  if (subDetID == 0) { // VD
+    if (disk >= 0) {
+      path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk);                                   // PETALCASEx_DISKy_1
+      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk, getTRKChipPattern(), disk);   // PETALCASEx_DISKy_TRKChipy_1
+      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk, getTRKSensorPattern(), disk); // PETALCASEx_DISKy_TRKSensory_1
+    } else if (layer >= 0) {
+      path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer);                                    // PETALCASEx_LAYERy_1
+      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKStavePattern(), layer);  // PETALCASEx_LAYERy_TRKStavey_1
+      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKChipPattern(), layer);   // PETALCASEx_LAYERy_TRKChipy_1
+      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKSensorPattern(), layer); // PETALCASEx_LAYERy_TRKSensory_1
+    }
+  } else if (subDetID == 1) {                                          // MLOT
+    path += Form("%s%d_1/", getTRKLayerPattern(), layer);              // TRKLayerx_1
+    path += Form("%s%d_%d/", getTRKStavePattern(), layer, stave);      // TRKStavex_y
+    if (mNumberOfHalfStaves[layer] == 2) {                             // staggered geometry
+      path += Form("%s%d_%d/", getTRKChipPattern(), layer, halfstave); // TRKChipx_0/1
+    } else if (mNumberOfHalfStaves[layer] == 1) {                      // turbo geometry
+      path += Form("%s%d_1/", getTRKChipPattern(), layer);             // TRKChipx_1
+    }
+    path += Form("%s%d_1/", getTRKSensorPattern(), layer); // TRKSensorx_1
+  }
   return path;
 }
 
@@ -325,40 +302,40 @@ TGeoHMatrix* GeometryTGeo::extractMatrixSensor(int index) const
   // Note, the if the effective sensitive layer thickness is smaller than the
   // total physical sensor tickness, this matrix is biased and connot be used
   // directly for transformation from sensor frame to global one.
-  //
   // Therefore we need to add a shift
+
   auto path = getMatrixPath(index);
 
   static TGeoHMatrix matTmp;
-  // gGeoManager->PushPath(); // Preserve the modeler state.
+  gGeoManager->PushPath(); // Preserve the modeler state.
 
-  // if (!gGeoManager->cd(path.Data())) {
-  //   gGeoManager->PopPath();
-  //   LOG(error) << "Error in cd-ing to " << path.Data();
-  //   return nullptr;
-  // } // end if !gGeoManager
+  if (!gGeoManager->cd(path.Data())) {
+    gGeoManager->PopPath();
+    LOG(error) << "Error in cd-ing to " << path.Data();
+    return nullptr;
+  } // end if !gGeoManager
 
   matTmp = *gGeoManager->GetCurrentMatrix(); // matrix may change after cd
 
   // RSS
-  // printf("%d/%d/%d %s\n", lay, stav, detInSta, path.Data());
   // matTmp.Print();
   // Restore the modeler state.
   gGeoManager->PopPath();
 
   static int chipInGlo{0};
 
+  /// TODO:
   // account for the difference between physical sensitive layer (where charge collection is simulated) and effective sensor thicknesses
-  // in the ITS3 case this accounted by specialized functions
-  // double delta = Segmentation::SensorLayerThickness;
-  // static TGeoTranslation tra(0., 0.5 * delta, 0.);
-  // #ifdef ENABLE_UPGRADES // only apply for non ITS3 OB layers
-  //   if (!mIsLayerITS3[getLayer(index)]) {
-  //     matTmp *= tra;
-  //   }
-  // #else
+  // in the VD case this will be accounted by specialized functions during the clusterization (following what it is done for ITS3)
+  // this can be done once the right sensor thickness is in place in the geometry
+  // double delta = 0.;
+  // if (getSubDetID(index) == 1){ /// ML/OT
+  //   delta = Segmentation::SensorLayerThicknessVD - Segmentation::SiliconTickness;
+  //   static TGeoTranslation tra(0., 0.5 * delta, 0.);
   //   matTmp *= tra;
-  // #endif
+  // }
+  // std::cout<<"-----"<<std::endl;
+  // matTmp.Print();
 
   return &matTmp;
 }
@@ -384,6 +361,8 @@ void GeometryTGeo::fillMatrixCache(int mask)
       cacheL2G.setMatrix(Mat3D(*hm), i);
     }
   }
+
+  // TODO: build matrices for the cases T2L, T2G and T2GRot when needed
 }
 
 //__________________________________________________________________________
@@ -672,7 +651,7 @@ int GeometryTGeo::extractNumberOfHalfStavesMLOT(int lay) const
 }
 
 //__________________________________________________________________________
-void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int indexRetrieved) const
+void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const
 {
   std::cout << "\nindex = " << index << std::endl;
   std::cout << "subDetID = " << subDetID << std::endl;
@@ -682,7 +661,6 @@ void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk,
   std::cout << "first chip index = " << getFirstChipIndex(lay, petalcase, subDetID) << std::endl;
   std::cout << "stave = " << stave << std::endl;
   std::cout << "halfstave = " << halfstave << std::endl;
-  std::cout << "check index Retrieved = " << indexRetrieved << std::endl;
 }
 
 //__________________________________________________________________________
@@ -731,4 +709,4 @@ void GeometryTGeo::Print(Option_t*) const
 }
 
 } // namespace trk
-} // namespace o2
\ No newline at end of file
+} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/SegmentationChip.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/SegmentationChip.cxx
new file mode 100644
index 0000000000000..26e76530597d7
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/SegmentationChip.cxx
@@ -0,0 +1,27 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file SegmentationChip.cxx
+/// \brief Implementation of the SegmentationChip class
+
+#include "TRKBase/SegmentationChip.h"
+#include <cstdio>
+
+using namespace o2::trk;
+
+// void SegmentationChip::print()
+// {
+//   printf("++++++++++ VD ++++++++++");
+//   printf("Pixel size: %.2f (along %d rows) %.2f (along %d columns) microns\n", PitchRowVD * 1e4, -999, PitchColVD * 1e4, NColsVD);
+//   printf("++++++++++ ML ++++++++++");
+//   printf("Pixel size: %.2f (along %d rows) %.2f (along %d columns) microns\n", PitchRowML * 1e4, -999, PitchColML * 1e4, NColsML);
+
+// }
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
index a1cb0279efef8..ab817a3fdaa0d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
@@ -11,7 +11,10 @@
 
 o2_add_library(TRKSimulation
                SOURCES src/TRKLayer.cxx
+                       src/ChipDigitsContainer.cxx
+                       src/ChipSimResponse.cxx
                        src/Detector.cxx
+                       src/DigiParams.cxx
                        src/Digitizer.cxx
                        src/TRKServices.cxx
                        src/DPLDigitizerParam.cxx
@@ -21,10 +24,14 @@ o2_add_library(TRKSimulation
                PUBLIC_LINK_LIBRARIES O2::TRKBase
                                      O2::FT3Simulation
                                      O2::ITSMFTSimulation
+                                     O2::DetectorsRaw
                                      O2::SimulationDataFormat)
 
 o2_target_root_dictionary(TRKSimulation
-                          HEADERS include/TRKSimulation/Digitizer.h
+                          HEADERS include/TRKSimulation/ChipDigitsContainer.h
+                                  include/TRKSimulation/ChipSimResponse.h
+                                  include/TRKSimulation/DigiParams.h
+                                  include/TRKSimulation/Digitizer.h
                                   include/TRKSimulation/Detector.h
                                   include/TRKSimulation/TRKLayer.h
                                   include/TRKSimulation/TRKServices.h
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
new file mode 100644
index 0000000000000..658fb823bb596
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
@@ -0,0 +1,37 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_TRK_CHIPDIGITSCONTAINER_
+#define ALICEO2_TRK_CHIPDIGITSCONTAINER_
+
+#include "ITSMFTBase/SegmentationAlpide.h"
+#include "ITSMFTSimulation/ChipDigitsContainer.h"
+#include "TRKBase/SegmentationChip.h"
+#include "TRKBase/Specs.h"
+#include "TRKSimulation/DigiParams.h"
+#include <TRandom.h>
+
+namespace o2::trk
+{
+
+class ChipDigitsContainer : public o2::itsmft::ChipDigitsContainer
+{
+ public:
+  explicit ChipDigitsContainer(UShort_t idx = 0);
+
+  using Segmentation = SegmentationChip;
+
+  ClassDefNV(ChipDigitsContainer, 1);
+};
+
+} // namespace o2::trk
+
+#endif // ALICEO2_TRK_CHIPDIGITSCONTAINER_
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipSimResponse.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipSimResponse.h
new file mode 100644
index 0000000000000..29147997f66bf
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipSimResponse.h
@@ -0,0 +1,37 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_TRKSIMULATION_CHIPSIMRESPONSE_H
+#define ALICEO2_TRKSIMULATION_CHIPSIMRESPONSE_H
+
+#include "ITSMFTSimulation/AlpideSimResponse.h"
+
+namespace o2
+{
+namespace trk
+{
+
+class ChipSimResponse : public o2::itsmft::AlpideSimResponse
+{
+ public:
+  ChipSimResponse() = default;
+  ChipSimResponse(const ChipSimResponse& other) = default;
+  ChipSimResponse(const o2::itsmft::AlpideSimResponse* base) : o2::itsmft::AlpideSimResponse(*base) {}
+
+  void initData(int tableNumber, std::string dataPath, const bool quiet = true);
+
+  ClassDef(ChipSimResponse, 1);
+};
+
+} // namespace trk
+} // namespace o2
+
+#endif // ALICEO2_TRKSIMULATION_CHIPSIMRESPONSE_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
index 59b3551ecbd32..584ffaa3aff75 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
@@ -39,7 +39,7 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
   double timeOffset = 0.;                 ///< time offset (in seconds!) to calculate ROFrame from hit time
   int chargeThreshold = 150;              ///< charge threshold in Nelectrons
   int minChargeToAccount = 15;            ///< minimum charge contribution to account
-  int nSimSteps = 7;                      ///< number of steps in response simulation
+  int nSimSteps = 18;                     ///< number of steps in response simulation
   float energyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
 
   float Vbb = 0.0;   ///< back bias absolute value for MFT (in Volt)
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
new file mode 100644
index 0000000000000..739ac5c9bd617
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
@@ -0,0 +1,135 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DigiParams.h
+/// \brief Simulation parameters for the TRK digitizer. Based on the ITS2 and ITS3 digitizer parameters
+
+#ifndef ALICEO2_TRK_DIGIPARAMS_H
+#define ALICEO2_TRK_DIGIPARAMS_H
+
+#include <Rtypes.h>
+#include <ITSMFTSimulation/AlpideSignalTrapezoid.h>
+#include "TRKBase/TRKBaseParam.h"
+#include "TRKBase/GeometryTGeo.h"
+
+////////////////////////////////////////////////////////////
+//                                                        //
+// Simulation params for the TRK digitizer                //
+//                                                        //
+// This is a provisionary implementation, until proper    //
+// microscopic simulation and its configuration will      //
+// be implemented                                         //
+//                                                        //
+////////////////////////////////////////////////////////////
+
+namespace o2
+{
+namespace trk
+{
+
+class ChipSimResponse;
+
+class DigiParams
+{
+
+  using SignalShape = o2::itsmft::AlpideSignalTrapezoid;
+
+ public:
+  DigiParams();
+  ~DigiParams() = default;
+
+  void setNoisePerPixel(float v) { mNoisePerPixel = v; }
+  float getNoisePerPixel() const { return mNoisePerPixel; }
+
+  void setContinuous(bool v) { mIsContinuous = v; }
+  bool isContinuous() const { return mIsContinuous; }
+
+  int getROFrameLengthInBC() const { return mROFrameLengthInBC; }
+  void setROFrameLengthInBC(int n) { mROFrameLengthInBC = n; }
+
+  void setROFrameLength(float ns);
+  float getROFrameLength() const { return mROFrameLength; }
+  float getROFrameLengthInv() const { return mROFrameLengthInv; }
+
+  void setStrobeDelay(float ns) { mStrobeDelay = ns; }
+  float getStrobeDelay() const { return mStrobeDelay; }
+
+  void setStrobeLength(float ns) { mStrobeLength = ns; }
+  float getStrobeLength() const { return mStrobeLength; }
+
+  void setTimeOffset(double sec) { mTimeOffset = sec; }
+  double getTimeOffset() const { return mTimeOffset; }
+
+  void setROFrameBiasInBC(int n) { mROFrameBiasInBC = n; }
+  int getROFrameBiasInBC() const { return mROFrameBiasInBC; }
+
+  void setChargeThreshold(int v, float frac2Account = 0.1);
+  void setNSimSteps(int v);
+  void setEnergyToNElectrons(float v) { mEnergyToNElectrons = v; }
+
+  void setVbb(float v) { mVbb = v; }
+  void setIBVbb(float v) { mIBVbb = v; }
+  void setOBVbb(float v) { mOBVbb = v; }
+
+  int getChargeThreshold() const { return mChargeThreshold; }
+  int getMinChargeToAccount() const { return mMinChargeToAccount; }
+  int getNSimSteps() const { return mNSimSteps; }
+  float getNSimStepsInv() const { return mNSimStepsInv; }
+  float getEnergyToNElectrons() const { return mEnergyToNElectrons; }
+
+  float getVbb() const { return mVbb; }
+  float getIBVbb() const { return mIBVbb; }
+  float getOBVbb() const { return mOBVbb; }
+
+  bool isTimeOffsetSet() const { return mTimeOffset > -infTime; }
+
+  const o2::trk::ChipSimResponse* getAlpSimResponse() const { return mAlpSimResponse; }
+  void setAlpSimResponse(const o2::trk::ChipSimResponse* par) { mAlpSimResponse = par; }
+
+  const SignalShape& getSignalShape() const { return mSignalShape; }
+  SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
+
+  virtual void print() const;
+
+ private:
+  static constexpr double infTime = 1e99;
+  bool mIsContinuous = false;        ///< flag for continuous simulation
+  float mNoisePerPixel = 1.e-8;      ///< ALPIDE Noise per chip
+  int mROFrameLengthInBC = 0;        ///< ROF length in BC for continuos mode
+  float mROFrameLength = 0;          ///< length of RO frame in ns
+  float mStrobeDelay = 0.;           ///< strobe start (in ns) wrt ROF start
+  float mStrobeLength = 0;           ///< length of the strobe in ns (sig. over threshold checked in this window only)
+  double mTimeOffset = -2 * infTime; ///< time offset (in seconds!) to calculate ROFrame from hit time
+  int mROFrameBiasInBC = 0;          ///< misalignment of the ROF start in BC
+  int mChargeThreshold = 150;        ///< charge threshold in Nelectrons
+  int mMinChargeToAccount = 15;      ///< minimum charge contribution to account
+  int mNSimSteps = 18;               ///< number of steps in response simulation
+  float mNSimStepsInv = 0;           ///< its inverse
+
+  float mEnergyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
+
+  float mVbb = 0.0;   ///< back bias absolute value for MFT (in Volt)
+  float mIBVbb = 0.0; ///< back bias absolute value for ITS Inner Barrel (in Volt)
+  float mOBVbb = 0.0; ///< back bias absolute value for ITS Outter Barrel (in Volt)
+
+  o2::itsmft::AlpideSignalTrapezoid mSignalShape; ///< signal timeshape parameterization
+
+  const o2::trk::ChipSimResponse* mAlpSimResponse = nullptr; //!< pointer on external response
+
+  // auxiliary precalculated parameters
+  float mROFrameLengthInv = 0; ///< inverse length of RO frame in ns
+
+  //   ClassDef(DigiParams, 2);
+};
+} // namespace trk
+} // namespace o2
+
+#endif
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
index 6863c5392cae3..573217fe9b076 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
@@ -21,12 +21,12 @@
 #include "Rtypes.h"  // for Digitizer::Class
 #include "TObject.h" // for TObject
 
-#include "ITSMFTSimulation/ChipDigitsContainer.h"
-// #include "ITSMFTSimulation/AlpideSimResponse.h"
-#include "ITSMFTSimulation/DigiParams.h"
+#include "TRKSimulation/ChipSimResponse.h"
+#include "TRKSimulation/ChipDigitsContainer.h"
+
+#include "TRKSimulation/DigiParams.h"
 #include "ITSMFTSimulation/Hit.h"
 #include "TRKBase/GeometryTGeo.h"
-// #include "ITS3Base/SegmentationSuperAlpide.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "CommonDataFormat/InteractionRecord.h"
@@ -37,7 +37,7 @@
 namespace o2::trk
 {
 
-class Digitizer : public TObject
+class Digitizer
 {
   using ExtraDig = std::vector<itsmft::PreDigitLabelRef>; ///< container for extra contributions to PreDigits
 
@@ -46,11 +46,13 @@ class Digitizer : public TObject
   void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
   void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
 
-  o2::itsmft::DigiParams& getParams() { return (o2::itsmft::DigiParams&)mParams; }
-  const o2::itsmft::DigiParams& getParams() const { return mParams; }
+  o2::trk::DigiParams& getParams() { return (o2::trk::DigiParams&)mParams; }
+  const o2::trk::DigiParams& getParams() const { return mParams; }
 
   void init();
 
+  o2::trk::ChipSimResponse* getChipResponse(int chipID);
+
   /// Steer conversion of hits to digits
   void process(const std::vector<itsmft::Hit>* hits, int evID, int srcID);
   void setEventTime(const o2::InteractionTimeRecord& irt);
@@ -64,10 +66,10 @@ class Digitizer : public TObject
   bool isContinuous() const { return mParams.isContinuous(); }
   void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
 
-  void setDigiParams(const o2::itsmft::DigiParams& par) { mParams = par; }
-  const o2::itsmft::DigiParams& getDigitParams() const { return mParams; }
+  void setDigiParams(const o2::trk::DigiParams& par) { mParams = par; }
+  const o2::trk::DigiParams& getDigitParams() const { return mParams; }
 
-  // provide the common itsmft::GeometryTGeo to access matrices and segmentation
+  // provide the common trk::GeometryTGeo to access matrices and segmentation
   void setGeometry(const o2::trk::GeometryTGeo* gm) { mGeometry = gm; }
 
   uint32_t getEventROFrameMin() const { return mEventROFrameMin; }
@@ -82,7 +84,7 @@ class Digitizer : public TObject
 
  private:
   void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
-  void registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+  void registerDigits(o2::trk::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
                       uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
 
   ExtraDig* getExtraDigBuffer(uint32_t roFrame)
@@ -97,9 +99,41 @@ class Digitizer : public TObject
     return mExtraBuff[ind].get();
   }
 
+  /// Get the number of columns according to the subdetector
+  /// \param subDetID 0 for VD, 1 for ML/OT
+  /// \param layer 0 to 2 for VD, 0 to 7 for ML/OT
+  /// \return Number of columns (for the moment, in the entire layer(VD) or stave (ML/OT)
+  int getNCols(int subDetID, int layer)
+  {
+    if (subDetID == 0) { // VD
+      return constants::VD::petal::layer::nCols;
+    } else if (subDetID == 1 && layer <= 3) { // ML
+      return constants::ML::nCols;
+    } else if (subDetID == 1 && layer >= 4) { // OT
+      return constants::OT::nCols;
+    }
+    return 0;
+  }
+
+  /// Get the number of rows according to the subdetector
+  /// \param subDetID 0 for VD, 1 for ML/OT
+  /// \param layer 0 to 2 for VD, 0 to 7 for ML/OT
+  /// \return Number of rows (for the moment, in the entire layer(VD) or stave (ML/OT)
+  int getNRows(int subDetID, int layer)
+  {
+    if (subDetID == 0) { // VD
+      return constants::VD::petal::layer::nRows[layer];
+    } else if (subDetID == 1 && layer <= 3) { // ML
+      return constants::ML::nRows;
+    } else if (subDetID == 1 && layer >= 4) { // OT
+      return constants::OT::nRows;
+    }
+    return 0;
+  }
+
   static constexpr float sec2ns = 1e9;
 
-  o2::itsmft::DigiParams mParams;          ///< digitization parameters
+  o2::trk::DigiParams mParams;             ///< digitization parameters
   o2::InteractionTimeRecord mEventTime;    ///< global event time and interaction record
   o2::InteractionRecord mIRFirstSampledTF; ///< IR of the 1st sampled IR, noise-only ROFs will be inserted till this IR only
   double mCollisionTimeWrtROF{};
@@ -110,19 +144,35 @@ class Digitizer : public TObject
   uint32_t mEventROFrameMin = 0xffffffff; ///< lowest RO frame for processed events (w/o automatic noise ROFs)
   uint32_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)
 
-  o2::itsmft::AlpideSimResponse* mAlpSimResp = nullptr; // simulated response
+  int mNumberOfChips = 0;
+
+  o2::trk::ChipSimResponse* mChipSimResp = nullptr;     // simulated response
+  o2::trk::ChipSimResponse* mChipSimRespVD = nullptr;   // simulated response for VD chips
+  o2::trk::ChipSimResponse* mChipSimRespMLOT = nullptr; // simulated response for ML/OT chips
+
+  // std::string mResponseFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
+  std::string mResponseFile = "$(O2_ROOT)/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/APTSResponseData.root"; /// using temporarly the APTS response
+
+  bool mSimRespOrientation{false};   // wether the orientation in the response function is flipped
+  float mSimRespVDShift{0.f};        // adjusting the Y-shift in the APTS response function to match sensor local coord.
+  float mSimRespVDScaleX{1.f};       // scale x-local coordinate to response function x-coordinate
+  float mSimRespVDScaleZ{1.f};       // scale z-local coordinate to response function z-coordinate
+  float mSimRespMLOTShift{0.f};      // adjusting the Y-shift in the APTS response function to match sensor local coord.
+  float mSimRespMLOTScaleX{1.f};     // scale x-local coordinate to response function x-coordinate
+  float mSimRespMLOTScaleZ{1.f};     // scale z-local coordinate to response function z-coordinate
+  float mSimRespVDScaleDepth{1.f};   // scale depth-local coordinate to response function depth-coordinate
+  float mSimRespMLOTScaleDepth{1.f}; // scale depth-local coordinate to response function depth-coordinate
 
   const o2::trk::GeometryTGeo* mGeometry = nullptr; ///< TRK geometry
 
-  std::vector<o2::itsmft::ChipDigitsContainer> mChips; ///< Array of chips digits containers
-  std::deque<std::unique_ptr<ExtraDig>> mExtraBuff;    ///< burrer (per roFrame) for extra digits
+  std::vector<o2::trk::ChipDigitsContainer> mChips; ///< Array of chips digits containers
+  std::deque<std::unique_ptr<ExtraDig>> mExtraBuff; ///< buffer (per roFrame) for extra digits
 
   std::vector<o2::itsmft::Digit>* mDigits = nullptr;                       //! output digits
   std::vector<o2::itsmft::ROFRecord>* mROFRecords = nullptr;               //! output ROF records
   o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mMCLabels = nullptr; //! output labels
 
   const o2::itsmft::NoiseMap* mDeadChanMap = nullptr;
-
-  ClassDef(Digitizer, 1);
+  const o2::itsmft::NoiseMap* mNoiseMap = nullptr;
 };
-} // namespace o2::trk
\ No newline at end of file
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipDigitsContainer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipDigitsContainer.cxx
new file mode 100644
index 0000000000000..9ed4a4bedf5c5
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipDigitsContainer.cxx
@@ -0,0 +1,17 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKSimulation/ChipDigitsContainer.h"
+
+using namespace o2::trk;
+
+ChipDigitsContainer::ChipDigitsContainer(UShort_t idx)
+  : o2::itsmft::ChipDigitsContainer(idx) {}
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipSimResponse.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipSimResponse.cxx
new file mode 100644
index 0000000000000..70c4f131b9724
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipSimResponse.cxx
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKSimulation/ChipSimResponse.h"
+#include <vector>
+#include <algorithm>
+
+using namespace o2::trk;
+
+void ChipSimResponse::initData(int tableNumber, std::string dataPath, const bool quiet)
+{
+  AlpideSimResponse::initData(tableNumber, dataPath, quiet);
+}
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
new file mode 100644
index 0000000000000..df6f46ac0ecb0
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
@@ -0,0 +1,72 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file DigiParams.cxx
+/// \brief Implementation of the TRK digitization steering params. Based on the ITS2 code.
+
+#include <fairlogger/Logger.h> // for LOG
+#include "TRKSimulation/DigiParams.h"
+#include <cassert>
+
+using namespace o2::trk;
+
+DigiParams::DigiParams()
+{
+  // make sure the defaults are consistent
+  setNSimSteps(mNSimSteps);
+}
+
+void DigiParams::setROFrameLength(float lNS)
+{
+  // set ROFrame length in nanosecongs
+  mROFrameLength = lNS;
+  assert(mROFrameLength > 1.);
+  mROFrameLengthInv = 1. / mROFrameLength;
+}
+
+void DigiParams::setNSimSteps(int v)
+{
+  // set number of sampling steps in silicon
+  mNSimSteps = v > 0 ? v : 1;
+  mNSimStepsInv = 1.f / mNSimSteps;
+}
+
+void DigiParams::setChargeThreshold(int v, float frac2Account)
+{
+  // set charge threshold for digits creation and its fraction to account
+  // contribution from single hit
+  mChargeThreshold = v;
+  mMinChargeToAccount = v * frac2Account;
+  if (mMinChargeToAccount < 0 || mMinChargeToAccount > mChargeThreshold) {
+    mMinChargeToAccount = mChargeThreshold;
+  }
+  LOG(info) << "Set charge threshold to " << mChargeThreshold
+            << ", single hit will be accounted from " << mMinChargeToAccount
+            << " electrons";
+}
+
+//______________________________________________
+void DigiParams::print() const
+{
+  // print settings
+  printf("TRK digitization params:\n");
+  printf("Continuous readout             : %s\n", mIsContinuous ? "ON" : "OFF");
+  printf("Readout Frame Length(ns)       : %f\n", mROFrameLength);
+  printf("Strobe delay (ns)              : %f\n", mStrobeDelay);
+  printf("Strobe length (ns)             : %f\n", mStrobeLength);
+  printf("Threshold (N electrons)        : %d\n", mChargeThreshold);
+  printf("Min N electrons to account     : %d\n", mMinChargeToAccount);
+  printf("Number of charge sharing steps : %d\n", mNSimSteps);
+  printf("ELoss to N electrons factor    : %e\n", mEnergyToNElectrons);
+  printf("Noise level per pixel          : %e\n", mNoisePerPixel);
+  printf("Charge time-response:\n");
+  mSignalShape.print();
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 21e6e629ec418..cc89f0eff1a54 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -12,456 +12,563 @@
 /// \file Digitizer.cxx
 
 #include "DataFormatsITSMFT/Digit.h"
-// #include "ITSMFTBase/SegmentationAlpide.h"
+#include "TRKBase/SegmentationChip.h"
 #include "TRKSimulation/DPLDigitizerParam.h"
+#include "TRKSimulation/TRKLayer.h"
 #include "TRKSimulation/Digitizer.h"
-// #include "MathUtils/Cartesian.h"
-// #include "SimulationDataFormat/MCTruthContainer.h"
-// #include "DetectorsRaw/HBFUtils.h"
+#include "DetectorsRaw/HBFUtils.h"
 
-// #include <TRandom.h>
+#include <TRandom.h>
 // #include <climits>
-// #include <vector>
-// #include <numeric>
+#include <vector>
+#include <iostream>
+#include <numeric>
 #include <fairlogger/Logger.h> // for LOG
 
 using o2::itsmft::Digit;
 using o2::itsmft::Hit;
-// using Segmentation = o2::itsmft::SegmentationAlpide;
+using Segmentation = o2::trk::SegmentationChip;
 
 using namespace o2::trk;
+using namespace o2::itsmft;
 // using namespace o2::base;
-
 //_______________________________________________________________________
 void Digitizer::init()
 {
-  // mNumberOfChips = mGeometry->getNumberOfChips();
-  // mChips.resize(mNumberOfChips);
-  // for (int i = mNumberOfChips; i--;) {
-  //   mChips[i].setChipIndex(i);
-  // if (mNoiseMap) {
-  //   mChips[i].setNoiseMap(mNoiseMap);
-  // }
-  // if (mDeadChanMap) {
-  //   mChips[i].disable(mDeadChanMap->isFullChipMasked(i));
-  //   mChips[i].setDeadChanMap(mDeadChanMap);
-  // }
-  // }
-  // initializing for both collection tables
-  /*for (int i = 0; i < 2; i++) {
-    mAlpSimResp[i].initData(i);
-  }*/
-
+  LOG(info) << "Initializing digitizer";
+  mNumberOfChips = mGeometry->getNumberOfChips();
+  mChips.resize(mNumberOfChips); /// temporary, to not make it crash
+  for (int i = mNumberOfChips; i--;) {
+    mChips[i].setChipIndex(i);
+    if (mNoiseMap) {
+      mChips[i].setNoiseMap(mNoiseMap);
+    }
+    if (mDeadChanMap) {
+      mChips[i].disable(mDeadChanMap->isFullChipMasked(i));
+      mChips[i].setDeadChanMap(mDeadChanMap);
+    }
+  }
   // importing the charge collection tables
   // (initialized while building O2)
-  //   auto file = TFile::Open(mResponseFile.data());
-  //   if (!file) {
-  //     LOG(fatal) << "Cannot open response file " << mResponseFile;
-  //   }
-  /*std::string response = "response";
-  for (int i=0; i<2; i++) {
-    response.append(std::to_string(i));
-    mAlpSimResp[i] = *(o2::itsmft::AlpideSimResponse*)file->Get(response.data());
-  }*/
-  //   mAlpSimResp[0] = *(o2::itsmft::AlpideSimResponse*)file->Get("response0");
-  //   mAlpSimResp[1] = *(o2::itsmft::AlpideSimResponse*)file->Get("response1");
+  auto file = TFile::Open(mResponseFile.data());
+  if (!file) {
+    LOG(fatal) << "Cannot open response file " << mResponseFile;
+  }
+
+  // setting the correct response function (for the moment, for both VD and MLOT the APTS response function is udes)
+  mChipSimResp = (o2::trk::ChipSimResponse*)file->Get("response1");
+  mChipSimRespVD = mChipSimResp;   /// for the moment considering the same response
+  mChipSimRespMLOT = mChipSimResp; /// for the moment considering the same response
+
+  /// setting scale factors to adapt to the APTS response function (adjusting pitch and Y shift)
+  // TODO: adjust Y shift when the geometry is improved
+  LOG(debug) << " Depth max: " << mChipSimRespVD->getDepthMax();
+  LOG(debug) << " Depth min: " << mChipSimRespVD->getDepthMin();
+
+  float thicknessVD = 0.0095; // cm --- hardcoded based on geometry currently present
+  float thicknessMLOT = 0.1;  // cm --- hardcoded based on geometry currently present
+
+  mSimRespVDScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowVD;
+  mSimRespVDScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColVD;
+  mSimRespVDScaleDepth = o2::trk::constants::apts::thickness / (thicknessVD); /// introducing this scaling factor because the silicon thickness for the moment is 1 mm -> rescale to 45 um which is the depth of the APTS response
+  // mSimRespVDShift = mChipSimRespVD->getDepthMax() - thicknessVD * mSimRespVDScaleDepth / 2.f; // the shift should be done considering the rescaling done to adapt to the wrong silicon thickness. TODO: remove the scaling factor for the depth when the silicon thickness match the simulated response
+  mSimRespVDShift = mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -45. Must add 10 um (= max depth) to match the APTS response.
+  mSimRespMLOTScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowMLOT;
+  mSimRespMLOTScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColMLOT;
+  mSimRespMLOTScaleDepth = o2::trk::constants::apts::thickness / (thicknessMLOT);                     /// introducing this scaling factor because the silicon thickness for the moment is 1 mm -> rescale to 45 um which is the depth of the APTS response
+  mSimRespMLOTShift = mChipSimRespMLOT->getDepthMax() - thicknessMLOT * mSimRespMLOTScaleDepth / 2.f; // the shift should be done considering the rescaling done to adapt to the wrong silicon thickness. TODO: remove the scaling factor for the depth when the silicon thickness match the simulated response
+  mSimRespOrientation = false;
 
   // importing the parameters from DPLDigitizerParam.h
   auto& dOptTRK = DPLDigitizerParam<o2::detectors::DetID::TRK>::Instance();
 
-  LOGP(info, "TRK Digitizer is initalised.");
+  LOGP(info, "TRK Digitizer is initialised.");
+  mParams.print();
+  LOGP(info, "VD shift = {}  ; ML/OT shift = {} = {} - {}", mSimRespVDShift, mSimRespMLOTShift, mChipSimRespMLOT->getDepthMax(), thicknessMLOT * mSimRespMLOTScaleDepth / 2.f);
+  LOGP(info, "VD pixel scale on x = {} ; z = {}", mSimRespVDScaleX, mSimRespVDScaleZ);
+  LOGP(info, "ML/OT pixel scale on x = {} ; z = {}", mSimRespMLOTScaleX, mSimRespMLOTScaleZ);
+  LOGP(info, "Response orientation: {}", mSimRespOrientation ? "flipped" : "normal");
+
+  mIRFirstSampledTF = o2::raw::HBFUtils::Instance().getFirstSampledTFIR();
 }
 
-// auto Digitizer::getChipResponse(int chipID)
-// {
-//   if (mNumberOfChips < 10000) { // in MFT
-//     return mAlpSimRespMFT;
-//   }
+o2::trk::ChipSimResponse* Digitizer::getChipResponse(int chipID)
+{
+  if (mGeometry->getSubDetID(chipID) == 0) { /// VD
+    return mChipSimRespVD;
+  }
 
-//   if (chipID < 432) { // in ITS Inner Barrel
-//     return mAlpSimRespIB;
-//   } else { // in ITS Outter Barrel
-//     return mAlpSimRespOB;
-//   }
-// }
+  else if (mGeometry->getSubDetID(chipID) == 1) { /// ML/OT
+    return mChipSimRespMLOT;
+  }
+  return nullptr;
+};
 
 //_______________________________________________________________________
 void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
 {
   // digitize single event, the time must have been set beforehand
 
-  // LOG(info) << "Digitizing " << mGeometry->getName() << " hits of entry " << evID << " from source "
-  //           << srcID << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
-  //           << " cont.mode: " << isContinuous()
-  //           << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
+  LOG(info) << " Digitizing " << mGeometry->getName() << " (ID: " << mGeometry->getDetID()
+            << ") hits of entry " << evID << " from source " << srcID
+            << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
+            << " cont.mode: " << isContinuous()
+            << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
+
+  std::cout << "Printing segmentation info: " << std::endl;
+  SegmentationChip::Print();
 
   // // is there something to flush ?
-  // if (mNewROFrame > mROFrameMin) {
-  //   fillOutputContainer(mNewROFrame - 1); // flush out all frame preceding the new one
-  // }
-
-  // int nHits = hits->size();
-  // std::vector<int> hitIdx(nHits);
-  // std::iota(std::begin(hitIdx), std::end(hitIdx), 0);
-  // // sort hits to improve memory access
-  // std::sort(hitIdx.begin(), hitIdx.end(),
-  //           [hits](auto lhs, auto rhs) {
-  //             return (*hits)[lhs].GetDetectorID() < (*hits)[rhs].GetDetectorID();
-  //           });
-  // for (int i : hitIdx) {
-  //   processHit((*hits)[i], mROFrameMax, evID, srcID);
-  // }
-  // // in the triggered mode store digits after every MC event
-  // // TODO: in the real triggered mode this will not be needed, this is actually for the
-  // // single event processing only
-  // if (!mParams.isContinuous()) {
-  //   fillOutputContainer(mROFrameMax);
-  // }
+  if (mNewROFrame > mROFrameMin) {
+    fillOutputContainer(mNewROFrame - 1); // flush out all frames preceding the new one
+  }
+
+  int nHits = hits->size();
+  std::vector<int> hitIdx(nHits);
+  std::iota(std::begin(hitIdx), std::end(hitIdx), 0);
+  // sort hits to improve memory access
+  std::sort(hitIdx.begin(), hitIdx.end(),
+            [hits](auto lhs, auto rhs) {
+              return (*hits)[lhs].GetDetectorID() < (*hits)[rhs].GetDetectorID();
+            });
+  LOG(info) << "Processing " << nHits << " hits";
+  for (int i : hitIdx) {
+    processHit((*hits)[i], mROFrameMax, evID, srcID);
+  }
+
+  // in the triggered mode store digits after every MC event
+  // TODO: in the real triggered mode this will not be needed, this is actually for the
+  // single event processing only
+  if (!mParams.isContinuous()) {
+    fillOutputContainer(mROFrameMax);
+  }
 }
 
 //_______________________________________________________________________
 void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
 {
-  // // assign event time in ns
-  // mEventTime = irt;
-  // if (!mParams.isContinuous()) {
-  //   mROFrameMin = 0; // in triggered mode reset the frame counters
-  //   mROFrameMax = 0;
-  // }
-  // // RO frame corresponding to provided time
-  // mCollisionTimeWrtROF = mEventTime.timeInBCNS; // in triggered mode the ROF starts at BC (is there a delay?)
-  // if (mParams.isContinuous()) {
-  //   auto nbc = mEventTime.differenceInBC(mIRFirstSampledTF);
-  //   if (mCollisionTimeWrtROF < 0 && nbc > 0) {
-  //     nbc--;
-  //   }
-
-  //   // we might get interactions to digitize from before
-  //   // the first sampled IR
-  //   if (nbc < 0) {
-  //     mNewROFrame = 0;
-  //     // this event is before the first RO
-  //     mIsBeforeFirstRO = true;
-  //   } else {
-  //     mNewROFrame = nbc / mParams.getROFrameLengthInBC();
-  //     mIsBeforeFirstRO = false;
-  //   }
-  //   LOG(info) << " NewROFrame " << mNewROFrame << " nbc " << nbc;
-
-  //   // in continuous mode depends on starts of periodic readout frame
-  //   mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC()) * o2::constants::lhc::LHCBunchSpacingNS;
-  // } else {
-  //   mNewROFrame = 0;
-  // }
-
-  // if (mNewROFrame < mROFrameMin) {
-  //   LOG(error) << "New ROFrame " << mNewROFrame << " (" << irt << ") precedes currently cashed " << mROFrameMin;
-  //   throw std::runtime_error("deduced ROFrame precedes already processed one");
-  // }
-
-  // if (mParams.isContinuous() && mROFrameMax < mNewROFrame) {
-  //   mROFrameMax = mNewROFrame - 1; // all frames up to this are finished
-  // }
+  LOG(info) << "Setting event time ";
+  // assign event time in ns
+  mEventTime = irt;
+  if (!mParams.isContinuous()) {
+    mROFrameMin = 0; // in triggered mode reset the frame counters
+    mROFrameMax = 0;
+  }
+  // RO frame corresponding to provided time
+  mCollisionTimeWrtROF = mEventTime.timeInBCNS; // in triggered mode the ROF starts at BC (is there a delay?)
+  if (mParams.isContinuous()) {
+    auto nbc = mEventTime.differenceInBC(mIRFirstSampledTF);
+
+    if (mCollisionTimeWrtROF < 0 && nbc > 0) {
+      nbc--;
+    }
+
+    mNewROFrame = nbc / mParams.getROFrameLengthInBC();
+
+    LOG(info) << " NewROFrame " << mNewROFrame << " = " << nbc << "/" << mParams.getROFrameLengthInBC() << " (nbc/mParams.getROFrameLengthInBC()";
+
+    // in continuous mode depends on starts of periodic readout frame
+    mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC()) * o2::constants::lhc::LHCBunchSpacingNS;
+  } else {
+    mNewROFrame = 0;
+  }
+
+  if (mNewROFrame < mROFrameMin) {
+    LOG(error) << "New ROFrame " << mNewROFrame << " (" << irt << ") precedes currently cashed " << mROFrameMin;
+    throw std::runtime_error("deduced ROFrame precedes already processed one");
+  }
+
+  if (mParams.isContinuous() && mROFrameMax < mNewROFrame) {
+    mROFrameMax = mNewROFrame - 1; // all frames up to this are finished
+  }
 }
 
 //_______________________________________________________________________
 void Digitizer::fillOutputContainer(uint32_t frameLast)
 {
   // // fill output with digits from min.cached up to requested frame, generating the noise beforehand
-  // if (frameLast > mROFrameMax) {
-  //   frameLast = mROFrameMax;
-  // }
+  if (frameLast > mROFrameMax) {
+    frameLast = mROFrameMax;
+  }
   // // make sure all buffers for extra digits are created up to the maxFrame
-  // getExtraDigBuffer(mROFrameMax);
-
-  // LOG(info) << "Filling " << mGeometry->getName() << " digits output for RO frames " << mROFrameMin << ":"
-  //           << frameLast;
-
-  // o2::itsmft::ROFRecord rcROF;
-
-  // // we have to write chips in RO increasing order, therefore have to loop over the frames here
-  // for (; mROFrameMin <= frameLast; mROFrameMin++) {
-  //   rcROF.setROFrame(mROFrameMin);
-  //   rcROF.setFirstEntry(mDigits->size()); // start of current ROF in digits
-
-  //   auto& extra = *(mExtraBuff.front().get());
-  //   for (auto& chip : mChips) {
-  //     if (chip.isDisabled()) {
-  //       continue;
-  //     }
-  //     chip.addNoise(mROFrameMin, mROFrameMin, &mParams);
-  //     auto& buffer = chip.getPreDigits();
-  //     if (buffer.empty()) {
-  //       continue;
-  //     }
-  //     auto itBeg = buffer.begin();
-  //     auto iter = itBeg;
-  //     ULong64_t maxKey = chip.getOrderingKey(mROFrameMin + 1, 0, 0) - 1; // fetch digits with key below that
-  //     for (; iter != buffer.end(); ++iter) {
-  //       if (iter->first > maxKey) {
-  //         break; // is the digit ROFrame from the key > the max requested frame
-  //       }
-  //       auto& preDig = iter->second; // preDigit
-  //       if (preDig.charge >= mParams.getChargeThreshold()) {
-  //         int digID = mDigits->size();
-  //         mDigits->emplace_back(chip.getChipIndex(), preDig.row, preDig.col, preDig.charge);
-  //         mMCLabels->addElement(digID, preDig.labelRef.label);
-  //         auto& nextRef = preDig.labelRef; // extra contributors are in extra array
-  //         while (nextRef.next >= 0) {
-  //           nextRef = extra[nextRef.next];
-  //           mMCLabels->addElement(digID, nextRef.label);
-  //         }
-  //       }
-  //     }
-  //     buffer.erase(itBeg, iter);
-  //   }
-  //   // finalize ROF record
-  //   rcROF.setNEntries(mDigits->size() - rcROF.getFirstEntry()); // number of digits
-  //   if (isContinuous()) {
-  //     rcROF.getBCData().setFromLong(mIRFirstSampledTF.toLong() + mROFrameMin * mParams.getROFrameLengthInBC());
-  //   } else {
-  //     rcROF.getBCData() = mEventTime; // RSTODO do we need to add trigger delay?
-  //   }
-  //   if (mROFRecords) {
-  //     mROFRecords->push_back(rcROF);
-  //   }
-  //   extra.clear(); // clear container for extra digits of the mROFrameMin ROFrame
-  //   // and move it as a new slot in the end
-  //   mExtraBuff.emplace_back(mExtraBuff.front().release());
-  //   mExtraBuff.pop_front();
-  // }
+  getExtraDigBuffer(mROFrameMax);
+  LOG(info) << "Filling " << mGeometry->getName() << " digits output for RO frames " << mROFrameMin << ":"
+            << frameLast;
+
+  o2::itsmft::ROFRecord rcROF; /// using temporarly itsmft::ROFRecord
+
+  // we have to write chips in RO increasing order, therefore have to loop over the frames here
+  for (; mROFrameMin <= frameLast; mROFrameMin++) {
+    rcROF.setROFrame(mROFrameMin);
+    rcROF.setFirstEntry(mDigits->size()); // start of current ROF in digits
+
+    auto& extra = *(mExtraBuff.front().get());
+    for (auto& chip : mChips) {
+      if (chip.isDisabled()) {
+        continue;
+      }
+      // chip.addNoise(mROFrameMin, mROFrameMin, &mParams);  /// TODO: add noise
+      auto& buffer = chip.getPreDigits();
+      if (buffer.empty()) {
+        continue;
+      }
+      auto itBeg = buffer.begin();
+      auto iter = itBeg;
+      ULong64_t maxKey = chip.getOrderingKey(mROFrameMin + 1, 0, 0) - 1; // fetch digits with key below that
+      for (; iter != buffer.end(); ++iter) {
+        if (iter->first > maxKey) {
+          break; // is the digit ROFrame from the key > the max requested frame
+        }
+        auto& preDig = iter->second; // preDigit
+        if (preDig.charge >= mParams.getChargeThreshold()) {
+          int digID = mDigits->size();
+          mDigits->emplace_back(chip.getChipIndex(), preDig.row, preDig.col, preDig.charge);
+          LOG(debug) << "Adding digit ID: " << digID << " with chipID: " << chip.getChipIndex() << ", row: " << preDig.row << ", col: " << preDig.col << ", charge: " << preDig.charge;
+          mMCLabels->addElement(digID, preDig.labelRef.label);
+          auto& nextRef = preDig.labelRef; // extra contributors are in extra array
+          while (nextRef.next >= 0) {
+            nextRef = extra[nextRef.next];
+            mMCLabels->addElement(digID, nextRef.label);
+          }
+        }
+      }
+      buffer.erase(itBeg, iter);
+    }
+    // finalize ROF record
+    rcROF.setNEntries(mDigits->size() - rcROF.getFirstEntry()); // number of digits
+    if (isContinuous()) {
+      rcROF.getBCData().setFromLong(mIRFirstSampledTF.toLong() + mROFrameMin * mParams.getROFrameLengthInBC());
+    } else {
+      rcROF.getBCData() = mEventTime; // RSTODO do we need to add trigger delay?
+    }
+    if (mROFRecords) {
+      mROFRecords->push_back(rcROF);
+    }
+    extra.clear(); // clear container for extra digits of the mROFrameMin ROFrame
+                   // and move it as a new slot in the end
+    mExtraBuff.emplace_back(mExtraBuff.front().release());
+    mExtraBuff.pop_front();
+  }
 }
 
 //_______________________________________________________________________
 void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID)
 {
-  // // convert single hit to digits
-  // int chipID = hit.GetDetectorID();
-  // auto& chip = mChips[chipID];
-  // if (chip.isDisabled()) {
-  //   LOG(debug) << "skip disabled chip " << chipID;
-  //   return;
-  // }
-  // float timeInROF = hit.GetTime() * sec2ns;
-  // if (timeInROF > 20e3) {
-  //   const int maxWarn = 10;
-  //   static int warnNo = 0;
-  //   if (warnNo < maxWarn) {
-  //     LOG(warning) << "Ignoring hit with time_in_event = " << timeInROF << " ns"
-  //                  << ((++warnNo < maxWarn) ? "" : " (suppressing further warnings)");
-  //   }
-  //   return;
-  // }
-  // if (isContinuous()) {
-  //   timeInROF += mCollisionTimeWrtROF;
-  // }
-  // if (mIsBeforeFirstRO && timeInROF < 0) {
-  //   // disregard this hit because it comes from an event before readout starts and it does not effect this RO
-  //   return;
-  // }
-
-  // // calculate RO Frame for this hit
-  // if (timeInROF < 0) {
-  //   timeInROF = 0.;
-  // }
-  // float tTot = mParams.getSignalShape().getMaxDuration();
-  // // frame of the hit signal start wrt event ROFrame
-  // int roFrameRel = int(timeInROF * mParams.getROFrameLengthInv());
-  // // frame of the hit signal end  wrt event ROFrame: in the triggered mode we read just 1 frame
-  // uint32_t roFrameRelMax = mParams.isContinuous() ? (timeInROF + tTot) * mParams.getROFrameLengthInv() : roFrameRel;
-  // int nFrames = roFrameRelMax + 1 - roFrameRel;
-  // uint32_t roFrameMax = mNewROFrame + roFrameRelMax;
-  // if (roFrameMax > maxFr) {
-  //   maxFr = roFrameMax; // if signal extends beyond current maxFrame, increase the latter
-  // }
-
-  // // here we start stepping in the depth of the sensor to generate charge diffusion
-  // float nStepsInv = mParams.getNSimStepsInv();
-  // int nSteps = mParams.getNSimSteps();
-  // const auto& matrix = mGeometry->getMatrixL2G(hit.GetDetectorID());
-  // math_utils::Vector3D<float> xyzLocS(matrix ^ (hit.GetPosStart())); // start position in sensor frame
-  // math_utils::Vector3D<float> xyzLocE(matrix ^ (hit.GetPos()));      // end position in sensor frame
-
-  // math_utils::Vector3D<float> step(xyzLocE);
-  // step -= xyzLocS;
-  // step *= nStepsInv; // position increment at each step
-  // // the electrons will injected in the middle of each step
-  // math_utils::Vector3D<float> stepH(step * 0.5);
-  // xyzLocS += stepH;
-  // xyzLocE -= stepH;
-
-  // int rowS = -1, colS = -1, rowE = -1, colE = -1, nSkip = 0;
-  // // get entrance pixel row and col
-  // while (!Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS)) { // guard-ring ?
-  //   if (++nSkip >= nSteps) {
-  //     return; // did not enter to sensitive matrix
-  //   }
-  //   xyzLocS += step;
-  // }
-  // // get exit pixel row and col
-  // while (!Segmentation::localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE)) { // guard-ring ?
-  //   if (++nSkip >= nSteps) {
-  //     return; // did not enter to sensitive matrix
-  //   }
-  //   xyzLocE -= step;
-  // }
-  // // estimate the limiting min/max row and col where the non-0 response is possible
-  // if (rowS > rowE) {
-  //   std::swap(rowS, rowE);
-  // }
-  // if (colS > colE) {
-  //   std::swap(colS, colE);
-  // }
-  // rowS -= AlpideRespSimMat::NPix / 2;
-  // rowE += AlpideRespSimMat::NPix / 2;
-  // if (rowS < 0) {
-  //   rowS = 0;
-  // }
-  // if (rowE >= Segmentation::NRows) {
-  //   rowE = Segmentation::NRows - 1;
-  // }
-  // colS -= AlpideRespSimMat::NPix / 2;
-  // colE += AlpideRespSimMat::NPix / 2;
-  // if (colS < 0) {
-  //   colS = 0;
-  // }
-  // if (colE >= Segmentation::NCols) {
-  //   colE = Segmentation::NCols - 1;
-  // }
-  // int rowSpan = rowE - rowS + 1, colSpan = colE - colS + 1; // size of plaquet where some response is expected
-
-  // float respMatrix[rowSpan][colSpan]; // response accumulated here
-  // std::fill(&respMatrix[0][0], &respMatrix[0][0] + rowSpan * colSpan, 0.f);
-
-  // float nElectrons = hit.GetEnergyLoss() * mParams.getEnergyToNElectrons(); // total number of deposited electrons
-  // nElectrons *= nStepsInv;                                                  // N electrons injected per step
-  // if (nSkip) {
-  //   nSteps -= nSkip;
-  // }
-  // //
-  // int rowPrev = -1, colPrev = -1, row, col;
-  // float cRowPix = 0.f, cColPix = 0.f; // local coordinated of the current pixel center
-
-  // const o2::itsmft::AlpideSimResponse* resp = getChipResponse(chipID);
-
-  // // take into account that the AlpideSimResponse depth defintion has different min/max boundaries
-  // // although the max should coincide with the surface of the epitaxial layer, which in the chip
-  // // local coordinates has Y = +SensorLayerThickness/2
-
-  // xyzLocS.SetY(xyzLocS.Y() + resp->getDepthMax() - Segmentation::SensorLayerThickness / 2.);
-
-  // // collect charge in every pixel which might be affected by the hit
-  // for (int iStep = nSteps; iStep--;) {
-  //   // Get the pixel ID
-  //   Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col);
-  //   if (row != rowPrev || col != colPrev) { // update pixel and coordinates of its center
-  //     if (!Segmentation::detectorToLocal(row, col, cRowPix, cColPix)) {
-  //       continue; // should not happen
-  //     }
-  //     rowPrev = row;
-  //     colPrev = col;
-  //   }
-  //   bool flipCol, flipRow;
-  //   // note that response needs coordinates along column row (locX) (locZ) then depth (locY)
-  //   auto rspmat = resp->getResponse(xyzLocS.X() - cRowPix, xyzLocS.Z() - cColPix, xyzLocS.Y(), flipRow, flipCol);
-
-  //   xyzLocS += step;
-  //   if (!rspmat) {
-  //     continue;
-  //   }
-
-  //   for (int irow = AlpideRespSimMat::NPix; irow--;) {
-  //     int rowDest = row + irow - AlpideRespSimMat::NPix / 2 - rowS; // destination row in the respMatrix
-  //     if (rowDest < 0 || rowDest >= rowSpan) {
-  //       continue;
-  //     }
-  //     for (int icol = AlpideRespSimMat::NPix; icol--;) {
-  //       int colDest = col + icol - AlpideRespSimMat::NPix / 2 - colS; // destination column in the respMatrix
-  //       if (colDest < 0 || colDest >= colSpan) {
-  //         continue;
-  //       }
-  //       respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, flipRow, flipCol);
-  //     }
-  //   }
-  // }
-
-  // // fire the pixels assuming Poisson(n_response_electrons)
-  // o2::MCCompLabel lbl(hit.GetTrackID(), evID, srcID, false);
-  // auto roFrameAbs = mNewROFrame + roFrameRel;
-  // for (int irow = rowSpan; irow--;) {
-  //   uint16_t rowIS = irow + rowS;
-  //   for (int icol = colSpan; icol--;) {
-  //     float nEleResp = respMatrix[irow][icol];
-  //     if (!nEleResp) {
-  //       continue;
-  //     }
-  //     int nEle = gRandom->Poisson(nElectrons * nEleResp); // total charge in given pixel
-  //     // ignore charge which have no chance to fire the pixel
-  //     if (nEle < mParams.getMinChargeToAccount()) {
-  //       continue;
-  //     }
-  //     uint16_t colIS = icol + colS;
-  //     if (mNoiseMap && mNoiseMap->isNoisy(chipID, rowIS, colIS)) {
-  //       continue;
-  //     }
-  //     if (mDeadChanMap && mDeadChanMap->isNoisy(chipID, rowIS, colIS)) {
-  //       continue;
-  //     }
-  //     //
-  //     registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl);
-  //   }
-  // }
+  int chipID = hit.GetDetectorID(); //// the chip ID at the moment is not referred to the chip but to a wider detector element (e.g. quarter of layer or disk in VD, stave in ML, half stave in OT)
+  int subDetID = mGeometry->getSubDetID(chipID);
+
+  int layer = mGeometry->getLayer(chipID);
+  int disk = mGeometry->getDisk(chipID);
+
+  if (disk != -1) {
+    LOG(debug) << "Skipping disk " << disk;
+    return; // skipping hits on disks for the moment
+  }
+
+  LOG(debug) << "Processing hit for chip " << chipID;
+  auto& chip = mChips[chipID];
+  if (chip.isDisabled()) {
+    LOG(debug) << "Skipping disabled chip " << chipID;
+    return;
+  }
+  float timeInROF = hit.GetTime() * sec2ns;
+  LOG(debug) << "timeInROF: " << timeInROF;
+  if (timeInROF > 20e3) {
+    const int maxWarn = 10;
+    static int warnNo = 0;
+    if (warnNo < maxWarn) {
+      LOG(warning) << "Ignoring hit with time_in_event = " << timeInROF << " ns"
+                   << ((++warnNo < maxWarn) ? "" : " (suppressing further warnings)");
+    }
+    return;
+  }
+  if (isContinuous()) {
+    timeInROF += mCollisionTimeWrtROF;
+  }
+  if (timeInROF < 0) {
+    // disregard this hit because it comes from an event byefore readout starts and it does not effect this RO
+    LOG(debug) << "Ignoring hit with timeInROF = " << timeInROF;
+    return;
+  }
+
+  // calculate RO Frame for this hit
+  if (timeInROF < 0) {
+    timeInROF = 0.;
+  }
+  float tTot = mParams.getSignalShape().getMaxDuration();
+  // frame of the hit signal start wrt event ROFrame
+  int roFrameRel = int(timeInROF * mParams.getROFrameLengthInv());
+  // frame of the hit signal end  wrt event ROFrame: in the triggered mode we read just 1 frame
+  uint32_t roFrameRelMax = mParams.isContinuous() ? (timeInROF + tTot) * mParams.getROFrameLengthInv() : roFrameRel;
+  int nFrames = roFrameRelMax + 1 - roFrameRel;
+  uint32_t roFrameMax = mNewROFrame + roFrameRelMax;
+  if (roFrameMax > maxFr) {
+    maxFr = roFrameMax; // if signal extends beyond current maxFrame, increase the latter
+  }
+
+  // here we start stepping in the depth of the sensor to generate charge diffusion
+  float nStepsInv = mParams.getNSimStepsInv();
+  int nSteps = mParams.getNSimSteps();
+
+  const auto& matrix = mGeometry->getMatrixL2G(hit.GetDetectorID());
+  // matrix.print();
+
+  /// transorm from the global detector coordinates to the local detector coordinates
+  math_utils::Vector3D<float> xyzLocS(matrix ^ (hit.GetPosStart())); // start position in sensor frame
+  math_utils::Vector3D<float> xyzLocE(matrix ^ (hit.GetPos()));      // end position in sensor frame
+
+  if (subDetID == 0) { // VD - need to take into account for the curved layers. TODO: consider the disks
+    // transform the point on the curved surface to a flat one
+    math_utils::Vector2D<float> xyFlatS = Segmentation::curvedToFlat(layer, xyzLocS.x(), xyzLocS.y());
+    math_utils::Vector2D<float> xyFlatE = Segmentation::curvedToFlat(layer, xyzLocE.x(), xyzLocE.y());
+    LOG(debug) << "Called curved to flat: " << xyzLocS.x() << " -> " << xyFlatS.x() << ", " << xyzLocS.y() << " -> " << xyFlatS.y();
+    // update the local coordinates with the flattened ones
+    xyzLocS.SetXYZ(xyFlatS.x(), xyFlatS.y(), xyzLocS.Z());
+    xyzLocE.SetXYZ(xyFlatE.x(), xyFlatE.y(), xyzLocE.Z());
+  }
+
+  // std::cout<<"Printing example of point in 0.35 0.35 0 in global frame: "<<std::endl;
+  // math_utils::Point3D<float> examplehitGlob(0.35, 0.35, 0);
+  // math_utils::Vector3D<float> exampleLoc(matrix ^ (examplehitGlob)); // start position in sensor frame
+  // std::cout<< "Example hit in local frame: " << exampleLoc << std::endl;
+  // std::cout<<"Going back to glob coordinates: " << (matrix * exampleLoc) << std::endl;
+
+  //// adapting the depth (Y) of the chip to the APTS response maximum depth
+  LOG(debug) << "local original: startPos = " << xyzLocS << ", endPos = " << xyzLocE << std::endl;
+  if (subDetID == 0) {
+    xyzLocS.SetY(xyzLocS.Y() * mSimRespVDScaleDepth);
+    xyzLocE.SetY(xyzLocE.Y() * mSimRespVDScaleDepth);
+  } else {
+    xyzLocS.SetY(xyzLocS.Y() * mSimRespMLOTScaleDepth);
+    xyzLocE.SetY(xyzLocE.Y() * mSimRespMLOTScaleDepth);
+  }
+  LOG(debug) << "rescaled Y: startPos = " << xyzLocS << ", endPos = " << xyzLocE << std::endl;
+
+  math_utils::Vector3D<float> step(xyzLocE);
+  step -= xyzLocS;
+  step *= nStepsInv; // position increment at each step
+  // the electrons will injected in the middle of each step
+  // starting from the middle of the first step
+  math_utils::Vector3D<float> stepH(step * 0.5);
+  xyzLocS += stepH;
+  xyzLocE -= stepH;
+
+  LOG(debug) << "Step into the sensitive volume: " << step << ".  Number of steps: " << nSteps;
+  int rowS = -1, colS = -1, rowE = -1, colE = -1, nSkip = 0;
+
+  /// here it is the control whether the hit is in the sensitive matrix based on the segmentation
+  // get entrance pixel row and col
+  while (!Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), rowS, colS, subDetID, layer, disk)) { // guard-ring ?
+    if (++nSkip >= nSteps) {
+      LOG(debug) << "Did not enter to sensitive matrix, " << nSkip << " >= " << nSteps;
+      return; // did not enter to sensitive matrix
+    }
+    xyzLocS += step;
+  }
+
+  // get exit pixel row and col
+  while (!Segmentation::localToDetector(xyzLocE.X(), xyzLocE.Z(), rowE, colE, subDetID, layer, disk)) { /// for the moment chipID = bigger element
+    if (++nSkip >= nSteps) {
+      LOG(debug) << "Did not enter to sensitive matrix, " << nSkip << " >= " << nSteps;
+      return; // did not enter to sensitive matrix
+    }
+    xyzLocE -= step;
+  }
+
+  int nCols = getNCols(subDetID, layer);
+  int nRows = getNRows(subDetID, layer);
+
+  // estimate the limiting min/max row and col where the non-0 response is possible
+  if (rowS > rowE) {
+    std::swap(rowS, rowE);
+  }
+  if (colS > colE) {
+    std::swap(colS, colE);
+  }
+  rowS -= AlpideRespSimMat::NPix / 2;
+  rowE += AlpideRespSimMat::NPix / 2;
+  if (rowS < 0) {
+    rowS = 0;
+  }
+  if (rowE >= nRows) {
+    rowE = nRows - 1;
+  }
+  colS -= AlpideRespSimMat::NPix / 2;
+  colE += AlpideRespSimMat::NPix / 2;
+  if (colS < 0) {
+    colS = 0;
+  }
+  if (colE >= nCols) {
+    colE = nCols - 1;
+  }
+  int rowSpan = rowE - rowS + 1, colSpan = colE - colS + 1; // size of plaquet where some response is expected
+
+  float respMatrix[rowSpan][colSpan]; // response accumulated here
+  std::fill(&respMatrix[0][0], &respMatrix[0][0] + rowSpan * colSpan, 0.f);
+
+  float nElectrons = hit.GetEnergyLoss() * mParams.getEnergyToNElectrons(); // total number of deposited electrons
+  nElectrons *= nStepsInv;                                                  // N electrons injected per step
+  if (nSkip) {
+    nSteps -= nSkip;
+  }
+
+  int rowPrev = -1, colPrev = -1, row, col;
+  float cRowPix = 0.f, cColPix = 0.f; // local coordinate of the current pixel center
+
+  const o2::trk::ChipSimResponse* resp = getChipResponse(chipID);
+  // std::cout << "Printing chip response:" << std::endl;
+  // resp->print();
+
+  // take into account that the ChipSimResponse depth defintion has different min/max boundaries
+  // although the max should coincide with the surface of the epitaxial layer, which in the chip
+  // local coordinates has Y = +SensorLayerThickness/2
+  xyzLocS.SetY(xyzLocS.Y() + ((subDetID == 0) ? mSimRespVDShift : mSimRespMLOTShift));
+
+  // collect charge in every pixel which might be affected by the hit
+  for (int iStep = nSteps; iStep--;) {
+    // Get the pixel ID
+    Segmentation::localToDetector(xyzLocS.X(), xyzLocS.Z(), row, col, subDetID, layer, disk);
+    if (row != rowPrev || col != colPrev) { // update pixel and coordinates of its center
+      if (!Segmentation::detectorToLocal(row, col, cRowPix, cColPix, subDetID, layer, disk)) {
+        continue; // should not happen
+      }
+      rowPrev = row;
+      colPrev = col;
+    }
+    bool flipCol = false, flipRow = false;
+    // note that response needs coordinates along column row (locX) (locZ) then depth (locY)
+    float rowMax{}, colMax{};
+    const AlpideRespSimMat* rspmat{nullptr};
+    if (subDetID == 0) { // VD
+      rowMax = 0.5f * Segmentation::PitchRowVD * mSimRespVDScaleX;
+      colMax = 0.5f * Segmentation::PitchColVD * mSimRespVDScaleZ;
+      rspmat = resp->getResponse(mSimRespVDScaleX * (xyzLocS.X() - cRowPix), mSimRespVDScaleZ * (xyzLocS.Z() - cColPix), xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
+    } else { // ML/OT
+      rowMax = 0.5f * Segmentation::PitchRowMLOT * mSimRespMLOTScaleX;
+      colMax = 0.5f * Segmentation::PitchColMLOT * mSimRespMLOTScaleZ;
+      rspmat = resp->getResponse(mSimRespMLOTScaleX * (xyzLocS.X() - cRowPix), mSimRespMLOTScaleZ * (xyzLocS.Z() - cColPix), xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
+    }
+
+    float tempPitchX = 0, tempPitchZ = 0;
+    if (subDetID == 0) {
+      tempPitchX = Segmentation::PitchRowVD;
+      tempPitchZ = Segmentation::PitchColVD;
+    } else {
+      tempPitchX = Segmentation::PitchRowMLOT;
+      tempPitchZ = Segmentation::PitchColMLOT;
+    }
+    LOG(debug) << "X and Z inside pixel at start = " << (xyzLocS.X() - cRowPix) << " , " << (xyzLocS.Z() - cColPix) << ", rescaled: " << mSimRespMLOTScaleX * (xyzLocS.X() - cRowPix) << " , " << mSimRespMLOTScaleZ * (xyzLocS.Z() - cColPix);
+    LOG(debug) << "Hit inside pitch? X: " << ((xyzLocS.X() - cRowPix) < tempPitchX) << "  Z: " << ((xyzLocS.Z() - cColPix) < tempPitchZ);
+
+    xyzLocS += step;
+
+    if (rspmat == nullptr) {
+      LOG(debug) << "Error in rspmat for step " << iStep << " / " << nSteps;
+      continue;
+    }
+    LOG(debug) << "rspmat valid! for step " << iStep << " / " << nSteps << ", (row,col) = (" << row << "," << col << ")";
+    // rspmat->print(); // print the response matrix for debugging
+
+    for (int irow = AlpideRespSimMat::NPix; irow--;) {
+      int rowDest = row + irow - AlpideRespSimMat::NPix / 2 - rowS; // destination row in the respMatrix
+      if (rowDest < 0 || rowDest >= rowSpan) {
+        continue;
+      }
+      for (int icol = AlpideRespSimMat::NPix; icol--;) {
+        int colDest = col + icol - AlpideRespSimMat::NPix / 2 - colS; // destination column in the respMatrix
+        if (colDest < 0 || colDest >= colSpan) {
+          continue;
+        }
+        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, mSimRespOrientation ? !flipRow : flipRow, flipCol);
+      }
+    }
+  }
+
+  // fire the pixels assuming Poisson(n_response_electrons)
+  o2::MCCompLabel lbl(hit.GetTrackID(), evID, srcID, false);
+  auto roFrameAbs = mNewROFrame + roFrameRel;
+  LOG(debug) << "Spanning through rows and columns; rowspan = " << rowSpan << " colspan = " << colSpan << " = " << colE << " - " << colS << " +1 " << std::endl;
+  for (int irow = rowSpan; irow--;) {          // irow ranging from 4 to 0
+    uint16_t rowIS = irow + rowS;              // row distant irow from the row of the hit start
+    for (int icol = colSpan; icol--;) {        // icol ranging from 4 to 0
+      float nEleResp = respMatrix[irow][icol]; // value of the probability of the response in this pixel
+      if (nEleResp <= 1.e-36) {
+        continue;
+      }
+      LOG(debug) << "nEleResp: value " << nEleResp << " for pixel " << irow << " " << icol << std::endl;
+      int nEle = gRandom->Poisson(nElectrons * nEleResp); // total charge in given pixel = number of electrons generated in the hit multiplied by the probability of being detected in their position
+      LOG(debug) << "Charge detected in the pixel: " << nEle << " for pixel " << irow << " " << icol << std::endl;
+      // ignore charge which have no chance to fire the pixel
+      if (nEle < mParams.getMinChargeToAccount()) { /// TODO: substitute with the threshold?
+        LOG(debug) << "Ignoring pixel with nEle = " << nEle << " < min charge to account "
+                   << mParams.getMinChargeToAccount() << " for pixel " << irow << " " << icol;
+        continue;
+      }
+
+      uint16_t colIS = icol + colS; // col distant icol from the col of the hit start
+      if (mNoiseMap && mNoiseMap->isNoisy(chipID, rowIS, colIS)) {
+        continue;
+      }
+      if (mDeadChanMap && mDeadChanMap->isNoisy(chipID, rowIS, colIS)) {
+        continue;
+      }
+
+      registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl);
+    }
+  }
 }
 
 //________________________________________________________________________________
-void Digitizer::registerDigits(o2::itsmft::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
+void Digitizer::registerDigits(o2::trk::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
                                uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl)
 {
   // Register digits for given pixel, accounting for the possible signal contribution to
   // multiple ROFrame. The signal starts at time tInROF wrt the start of provided roFrame
   // In every ROFrame we check the collected signal during strobe
-
-  // float tStrobe = mParams.getStrobeDelay() - tInROF; // strobe start wrt signal start
-  // for (int i = 0; i < nROF; i++) {
-  //   uint32_t roFr = roFrame + i;
-  //   int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength());
-  //   tStrobe += mParams.getROFrameLength(); // for the next ROF
-
-  //   // discard too small contributions, they have no chance to produce a digit
-  //   if (nEleROF < mParams.getMinChargeToAccount()) {
-  //     continue;
-  //   }
-  //   if (roFr > mEventROFrameMax) {
-  //     mEventROFrameMax = roFr;
-  //   }
-  //   if (roFr < mEventROFrameMin) {
-  //     mEventROFrameMin = roFr;
-  //   }
-  //   auto key = chip.getOrderingKey(roFr, row, col);
-  //   PreDigit* pd = chip.findDigit(key);
-  //   if (!pd) {
-  //     chip.addDigit(key, roFr, row, col, nEleROF, lbl);
-  //   } else { // there is already a digit at this slot, account as PreDigitExtra contribution
-  //     pd->charge += nEleROF;
-  //     if (pd->labelRef.label == lbl) { // don't store the same label twice
-  //       continue;
-  //     }
-  //     ExtraDig* extra = getExtraDigBuffer(roFr);
-  //     int& nxt = pd->labelRef.next;
-  //     bool skip = false;
-  //     while (nxt >= 0) {
-  //       if ((*extra)[nxt].label == lbl) { // don't store the same label twice
-  //         skip = true;
-  //         break;
-  //       }
-  //       nxt = (*extra)[nxt].next;
-  //     }
-  //     if (skip) {
-  //       continue;
-  //     }
-  //     // new predigit will be added in the end of the chain
-  //     nxt = extra->size();
-  //     extra->emplace_back(lbl);
-  //   }
-  // }
+  LOG(debug) << "Registering digits for chip " << chip.getChipIndex() << " at ROFrame " << roFrame
+             << " row " << row << " col " << col << " nEle " << nEle << " label " << lbl;
+  float tStrobe = mParams.getStrobeDelay() - tInROF; // strobe start wrt signal start
+  for (int i = 0; i < nROF; i++) {
+    uint32_t roFr = roFrame + i;
+    int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength());
+    tStrobe += mParams.getROFrameLength(); // for the next ROF
+
+    // discard too small contributions, they have no chance to produce a digit
+    if (nEleROF < mParams.getMinChargeToAccount()) { /// use threshold instead?
+      continue;
+    }
+    if (roFr > mEventROFrameMax) {
+      mEventROFrameMax = roFr;
+    }
+    if (roFr < mEventROFrameMin) {
+      mEventROFrameMin = roFr;
+    }
+    auto key = chip.getOrderingKey(roFr, row, col);
+    o2::itsmft::PreDigit* pd = chip.findDigit(key);
+    if (!pd) {
+      chip.addDigit(key, roFr, row, col, nEleROF, lbl);
+      LOG(debug) << "Added digit " << key << "  " << roFr << "  " << row << "  " << col << "  " << nEleROF;
+    } else { // there is already a digit at this slot, account as PreDigitExtra contribution
+      pd->charge += nEleROF;
+      if (pd->labelRef.label == lbl) { // don't store the same label twice
+        continue;
+      }
+      ExtraDig* extra = getExtraDigBuffer(roFr);
+      int& nxt = pd->labelRef.next;
+      bool skip = false;
+      while (nxt >= 0) {
+        if ((*extra)[nxt].label == lbl) { // don't store the same label twice
+          skip = true;
+          break;
+        }
+        nxt = (*extra)[nxt].next;
+      }
+      if (skip) {
+        continue;
+      }
+      // new predigit will be added in the end of the chain
+      nxt = extra->size();
+      extra->emplace_back(lbl);
+    }
+  }
 }
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
index cb375936744d5..0ed276237bd86 100644
--- a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
@@ -93,7 +93,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     timer.Start();
     LOG(info) << " CALLING TRK DIGITIZATION ";
 
-    // mDigitizer.setDigits(&mDigits);
+    mDigitizer.setDigits(&mDigits);
     mDigitizer.setROFRecords(&mROFRecords);
     mDigitizer.setMCLabels(&mLabels);
 
@@ -104,8 +104,10 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       // accumulate result of single event processing, called after processing every event supplied
       // AND after the final flushing via digitizer::fillOutputContainer
       if (mDigits.empty()) {
+        LOG(debug) << "No digits to accumulate";
         return; // no digits were flushed, nothing to accumulate
       }
+      LOG(debug) << "Accumulating " << mDigits.size() << " digits ";
       auto ndigAcc = digitsAccum.size();
       std::copy(mDigits.begin(), mDigits.end(), std::back_inserter(digitsAccum));
 
@@ -139,7 +141,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       mLabels.clear();
       mDigits.clear();
       mROFRecords.clear();
-    }; // and accumulate lambda
+    }; // end accumulate lambda
 
     auto& eventParts = context->getEventParts(withQED);
     // loop over all composite collisions given from context (aka loop over all the interaction records)
@@ -172,6 +174,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       accumulate();
     }
     mDigitizer.fillOutputContainer();
+    LOG(debug) << "mDigits size after fill: " << mDigits.size();
     accumulate();
 
     // here we have all digits and labels and we can send them to consumer (aka snapshot it onto output)

From 6d863f47f390367ea2360894d868c3b10b06a4c6 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 27 Aug 2025 09:08:38 +0200
Subject: [PATCH 0754/1764] ITS: template Vertexer&Traits, IndexTableUtils
 (#14606)

Co-authored-by: Felix Schlepper <fschlepp@aliceml.cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  9 +--
 .../GPU/ITStrackingGPU/TrackerTraitsGPU.h     |  4 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  5 +-
 .../ITS/tracking/GPU/cuda/CMakeLists.txt      |  4 +-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 10 +--
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 19 +++---
 .../ITS/tracking/GPU/hip/CMakeLists.txt       |  4 +-
 .../tracking/include/ITStracking/Cluster.h    | 21 ++----
 .../include/ITStracking/IndexTableUtils.h     | 41 +++++++-----
 .../tracking/include/ITStracking/TimeFrame.h  |  3 +-
 .../include/ITStracking/TrackerTraits.h       |  6 +-
 .../include/ITStracking/TrackingInterface.h   |  6 +-
 .../tracking/include/ITStracking/Vertexer.h   | 64 ++++++++-----------
 .../include/ITStracking/VertexerTraits.h      | 34 +++++-----
 Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx |  6 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  2 +-
 .../ITS/tracking/src/TrackingInterface.cxx    |  4 +-
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      | 20 ++++--
 .../ITS/tracking/src/VertexerTraits.cxx       | 39 +++++++----
 .../include/ITSWorkflow/CookedTrackerSpec.h   |  4 +-
 .../ITS/workflow/src/CookedTrackerSpec.cxx    |  4 +-
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  4 +-
 GPU/GPUTracking/Base/GPUReconstruction.h      |  3 +-
 .../Base/GPUReconstructionIncludesITS.h       | 14 ++--
 .../Base/cuda/GPUReconstructionCUDA.cu        |  4 +-
 .../Base/cuda/GPUReconstructionCUDA.h         |  2 +-
 GPU/GPUTracking/Global/GPUChainITS.cxx        |  2 +-
 GPU/GPUTracking/Global/GPUChainITS.h          |  4 +-
 GPU/GPUTracking/Interface/GPUO2Interface.cxx  |  2 +-
 GPU/GPUTracking/Interface/GPUO2Interface.h    |  3 +-
 GPU/Workflow/src/GPUWorkflowITS.cxx           |  2 +-
 31 files changed, 188 insertions(+), 161 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 9731ad5c5db67..a1d52bff11f9d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -28,6 +28,7 @@ template <int nLayers = 7>
 class TimeFrameGPU : public TimeFrame<nLayers>
 {
   using typename TimeFrame<nLayers>::CellSeedN;
+  using typename TimeFrame<nLayers>::IndexTableUtilsN;
 
  public:
   TimeFrameGPU();
@@ -36,8 +37,8 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   /// Most relevant operations
   void registerHostMemory(const int);
   void unregisterHostMemory(const int);
-  void initialise(const int, const TrackingParameters&, const int, IndexTableUtils* utils = nullptr, const TimeFrameGPUParameters* pars = nullptr);
-  void initDevice(IndexTableUtils*, const TrackingParameters& trkParam, const TimeFrameGPUParameters&, const int, const int);
+  void initialise(const int, const TrackingParameters&, const int, IndexTableUtilsN* utils = nullptr, const TimeFrameGPUParameters* pars = nullptr);
+  void initDevice(IndexTableUtilsN*, const TrackingParameters& trkParam, const TimeFrameGPUParameters&, const int, const int);
   void initDeviceSAFitting();
   void loadIndexTableUtils(const int);
   void loadTrackingFrameInfoDevice(const int, const int);
@@ -98,7 +99,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
 
   /// interface
   int getNClustersInRofSpan(const int, const int, const int) const;
-  IndexTableUtils* getDeviceIndexTableUtils() { return mIndexTableUtilsDevice; }
+  IndexTableUtilsN* getDeviceIndexTableUtils() { return mIndexTableUtilsDevice; }
   int* getDeviceROFramesClusters(const int layer) { return mROFramesClustersDevice[layer]; }
   auto& getTrackITSExt() { return mTrackITSExt; }
   Vertex* getDeviceVertices() { return mPrimaryVerticesDevice; }
@@ -165,7 +166,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   std::array<int, nLayers - 3> mNNeighbours;
 
   // Device pointers
-  IndexTableUtils* mIndexTableUtilsDevice;
+  IndexTableUtilsN* mIndexTableUtilsDevice;
 
   // Hybrid pref
   uint8_t* mMultMaskDevice;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
index f8eedb33d91eb..7d26e74692aa5 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
@@ -22,6 +22,8 @@ namespace o2::its
 template <int nLayers = 7>
 class TrackerTraitsGPU final : public TrackerTraits<nLayers>
 {
+  using typename TrackerTraits<nLayers>::IndexTableUtilsN;
+
  public:
   TrackerTraitsGPU() = default;
   ~TrackerTraitsGPU() final = default;
@@ -48,7 +50,7 @@ class TrackerTraitsGPU final : public TrackerTraits<nLayers>
   int getTFNumberOfCells() const override;
 
  private:
-  IndexTableUtils* mDeviceIndexTableUtils;
+  IndexTableUtilsN* mDeviceIndexTableUtils;
   gpu::TimeFrameGPU<nLayers>* mTimeFrameGPU;
 };
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 53e680d474f6f..69d6799686654 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -27,13 +27,14 @@ template <int>
 class CellSeed;
 class TrackingFrameInfo;
 class Tracklet;
+template <int>
 class IndexTableUtils;
 class Cluster;
 class TrackITSExt;
 class ExternalAllocator;
 
 template <int nLayers = 7>
-void countTrackletsInROFsHandler(const IndexTableUtils* utils,
+void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                  const uint8_t* multMask,
                                  const int layer,
                                  const int startROF,
@@ -66,7 +67,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
                                  gpu::Streams& streams);
 
 template <int nLayers = 7>
-void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
+void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                    const uint8_t* multMask,
                                    const int layer,
                                    const int startROF,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index 1f6a046a81350..3dff67dbccd80 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -22,8 +22,8 @@ if(CUDA_ENABLED)
                            TimeFrameGPU.cu
                            TracerGPU.cu
                            TrackingKernels.cu
-                           VertexingKernels.cu
-                           VertexerTraitsGPU.cxx
+                           # VertexingKernels.cu
+                           # VertexerTraitsGPU.cxx
                    PUBLIC_INCLUDE_DIRECTORIES ../
                    PUBLIC_LINK_LIBRARIES O2::ITStracking
                                          O2::SimConfig
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index d834f28e09db0..965bf27fdd12b 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -61,11 +61,11 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
 {
   GPUTimer timer("loading indextable utils");
   if (!iteration) {
-    GPULog("gpu-allocation: allocating IndexTableUtils buffer, for {:.2f} MB.", sizeof(IndexTableUtils) / constants::MB);
-    allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtils), this->getExtAllocator());
+    GPULog("gpu-allocation: allocating IndexTableUtils buffer, for {:.2f} MB.", sizeof(IndexTableUtilsN) / constants::MB);
+    allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtilsN), this->getExtAllocator());
   }
-  GPULog("gpu-transfer: loading IndexTableUtils object, for {:.2f} MB.", sizeof(IndexTableUtils) / constants::MB);
-  GPUChkErrS(cudaMemcpy(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtils), cudaMemcpyHostToDevice));
+  GPULog("gpu-transfer: loading IndexTableUtils object, for {:.2f} MB.", sizeof(IndexTableUtilsN) / constants::MB);
+  GPUChkErrS(cudaMemcpy(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtilsN), cudaMemcpyHostToDevice));
 }
 
 template <int nLayers>
@@ -547,7 +547,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::initialise(const int iteration,
                                        const TrackingParameters& trkParam,
                                        const int maxLayers,
-                                       IndexTableUtils* utils,
+                                       IndexTableUtilsN* utils,
                                        const TimeFrameGPUParameters* gpuParam)
 {
   mGpuStreams.resize(nLayers);
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 694b598334be3..94c6610ab9430 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -95,8 +95,9 @@ GPUdii() int4 getEmptyBinsRect()
   return int4{0, 0, 0, 0};
 }
 
+template <int nLayers>
 GPUdii() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                                const o2::its::IndexTableUtils& utils,
+                                const IndexTableUtils<nLayers>& utils,
                                 const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
 {
   const float zRangeMin = o2::gpu::CAMath::Min(z1, z2) - maxdeltaz;
@@ -331,7 +332,7 @@ GPUg() void fitTrackSeedsKernel(
     temporaryTrack.resetCovariance();
     temporaryTrack.setChi2(0);
     auto& clusters = seed.getClusters();
-    for (int iL{0}; iL < 7; ++iL) {
+    for (int iL{0}; iL < nLayers; ++iL) {
       temporaryTrack.setExternalClusterIndex(iL, clusters[iL], clusters[iL] != constants::UnusedIndex);
     }
     bool fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
@@ -523,9 +524,9 @@ GPUg() void computeLayerCellsKernel(
   }
 }
 
-template <bool initRun>
+template <bool initRun, int nLayers>
 GPUg() void computeLayerTrackletsMultiROFKernel(
-  const IndexTableUtils* utils,
+  const IndexTableUtils<nLayers>* utils,
   const uint8_t* multMask,
   const int layerIndex,
   const int startROF,
@@ -601,7 +602,7 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
         const float zAtRmax{tanLambda * (maxR - currentCluster.radius) + currentCluster.zCoordinate};
         const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + constants::Tolerance)}; /// protecting from overflows adding the detector resolution
         const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * MSAngle))};
-        const int4 selectedBinsRect{getBinsRect(currentCluster, layerIndex + 1, *utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
+        const int4 selectedBinsRect{getBinsRect<nLayers>(currentCluster, layerIndex + 1, *utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
         if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
           continue;
         }
@@ -769,7 +770,7 @@ GPUhi() void deallocateMemory(void* p, size_t bytes, cudaStream_t stream = nullp
 } // namespace gpu
 
 template <int nLayers>
-void countTrackletsInROFsHandler(const IndexTableUtils* utils,
+void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                  const uint8_t* multMask,
                                  const int layer,
                                  const int startROF,
@@ -833,7 +834,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils* utils,
 }
 
 template <int nLayers>
-void computeTrackletsInROFsHandler(const IndexTableUtils* utils,
+void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                    const uint8_t* multMask,
                                    const int layer,
                                    const int startROF,
@@ -1241,7 +1242,7 @@ void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
 }
 
 /// Explicit instantiation of ITS2 handlers
-template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
+template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                              const uint8_t* multMask,
                                              const int layer,
                                              const int startROF,
@@ -1273,7 +1274,7 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
                                              const int nThreads,
                                              gpu::Streams& streams);
 
-template void computeTrackletsInROFsHandler<7>(const IndexTableUtils* utils,
+template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                                const uint8_t* multMask,
                                                const int layer,
                                                const int startROF,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
index e8e475f2232c8..dd83669311a54 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
@@ -19,8 +19,8 @@ if(HIP_ENABLED)
                          ../cuda/TrackerTraitsGPU.cxx
                          ../cuda/TracerGPU.cu
                          ../cuda/TrackingKernels.cu
-                         ../cuda/VertexingKernels.cu
-                         ../cuda/VertexerTraitsGPU.cxx
+                         # ../cuda/VertexingKernels.cu
+                         # ../cuda/VertexerTraitsGPU.cxx
                  PUBLIC_INCLUDE_DIRECTORIES ../
                  PUBLIC_LINK_LIBRARIES O2::ITStracking
                                        O2::GPUTracking
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
index eaefbee5e2aaa..dd96dc80f2926 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
@@ -22,32 +22,23 @@
 namespace o2::its
 {
 
+template <int>
 class IndexTableUtils;
 
 struct Cluster final {
   GPUhdDefault() Cluster() = default;
   GPUhd() Cluster(const float x, const float y, const float z, const int idx);
-  GPUhd() Cluster(const int, const IndexTableUtils& utils, const Cluster&);
-  GPUhd() Cluster(const int, const float3&, const IndexTableUtils& utils, const Cluster&);
+  template <int nLayers>
+  GPUhd() Cluster(const int, const IndexTableUtils<nLayers>& utils, const Cluster&);
+  template <int nLayers>
+  GPUhd() Cluster(const int, const float3&, const IndexTableUtils<nLayers>& utils, const Cluster&);
   GPUhdDefault() Cluster(const Cluster&) = default;
   GPUhdDefault() Cluster(Cluster&&) noexcept = default;
   GPUhdDefault() ~Cluster() = default;
 
   GPUhdDefault() Cluster& operator=(const Cluster&) = default;
   GPUhdDefault() Cluster& operator=(Cluster&&) noexcept = default;
-
-  // TODO
-  /*GPUhdDefault() bool operator==(const Cluster&) const = default;*/
-  GPUhd() bool operator==(const Cluster& other) const
-  {
-    return xCoordinate == other.xCoordinate &&
-           yCoordinate == other.yCoordinate &&
-           zCoordinate == other.zCoordinate &&
-           phi == other.phi &&
-           radius == other.radius &&
-           clusterId == other.clusterId &&
-           indexTableBinIndex == other.indexTableBinIndex;
-  }
+  GPUhdDefault() bool operator==(const Cluster&) const = default;
 
   GPUhd() void print() const;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
index 61072cb2410b7..118557c970c35 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
@@ -16,16 +16,19 @@
 #ifndef TRACKINGITSU_INCLUDE_INDEXTABLEUTILS_H_
 #define TRACKINGITSU_INCLUDE_INDEXTABLEUTILS_H_
 
+#include <array>
+
+#include "ITStracking/Constants.h"
 #include "ITStracking/Configuration.h"
 #include "ITStracking/Definitions.h"
 #include "CommonConstants/MathConstants.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonDef.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
+
+template <int nLayers>
 class IndexTableUtils
 {
  public:
@@ -48,12 +51,13 @@ class IndexTableUtils
   int mNzBins = 0;
   int mNphiBins = 0;
   float mInversePhiBinSize = 0.f;
-  float mLayerZ[8] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
-  float mInverseZBinSize[8] = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+  std::array<float, nLayers> mLayerZ{};
+  std::array<float, nLayers> mInverseZBinSize{};
 };
 
+template <int nLayers>
 template <class T>
-inline void IndexTableUtils::setTrackingParameters(const T& params)
+inline void IndexTableUtils<nLayers>::setTrackingParameters(const T& params)
 {
   mInversePhiBinSize = params.PhiBins / o2::constants::math::TwoPI;
   mNzBins = params.ZBins;
@@ -66,28 +70,33 @@ inline void IndexTableUtils::setTrackingParameters(const T& params)
   }
 }
 
-inline float IndexTableUtils::getInverseZCoordinate(const int layerIndex) const
+template <int nLayers>
+inline float IndexTableUtils<nLayers>::getInverseZCoordinate(const int layerIndex) const
 {
   return 0.5f * mNzBins / mLayerZ[layerIndex];
 }
 
-GPUhdi() int IndexTableUtils::getZBinIndex(const int layerIndex, const float zCoordinate) const
+template <int nLayers>
+GPUhdi() int IndexTableUtils<nLayers>::getZBinIndex(const int layerIndex, const float zCoordinate) const
 {
   return (zCoordinate + mLayerZ[layerIndex]) * mInverseZBinSize[layerIndex];
 }
 
-GPUhdi() int IndexTableUtils::getPhiBinIndex(const float currentPhi) const
+template <int nLayers>
+GPUhdi() int IndexTableUtils<nLayers>::getPhiBinIndex(const float currentPhi) const
 {
   return (currentPhi * mInversePhiBinSize);
 }
 
-GPUhdi() int IndexTableUtils::getBinIndex(const int zIndex, const int phiIndex) const
+template <int nLayers>
+GPUhdi() int IndexTableUtils<nLayers>::getBinIndex(const int zIndex, const int phiIndex) const
 {
   return o2::gpu::GPUCommonMath::Min(phiIndex * mNzBins + zIndex, mNzBins * mNphiBins - 1);
 }
 
-GPUhdi() int IndexTableUtils::countRowSelectedBins(const int* indexTable, const int phiBinIndex,
-                                                   const int minZBinIndex, const int maxZBinIndex) const
+template <int nLayers>
+GPUhdi() int IndexTableUtils<nLayers>::countRowSelectedBins(const int* indexTable, const int phiBinIndex,
+                                                            const int minZBinIndex, const int maxZBinIndex) const
 {
   const int firstBinIndex{getBinIndex(minZBinIndex, phiBinIndex)};
   const int maxBinIndex{firstBinIndex + maxZBinIndex - minZBinIndex + 1};
@@ -95,14 +104,14 @@ GPUhdi() int IndexTableUtils::countRowSelectedBins(const int* indexTable, const
   return indexTable[maxBinIndex] - indexTable[firstBinIndex];
 }
 
-GPUhdi() void IndexTableUtils::print() const
+template <int nLayers>
+GPUhdi() void IndexTableUtils<nLayers>::print() const
 {
   printf("NzBins: %d, NphiBins: %d, InversePhiBinSize: %f\n", mNzBins, mNphiBins, mInversePhiBinSize);
-  for (int iLayer{0}; iLayer < 7; ++iLayer) {
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
     printf("Layer %d: Z: %f, InverseZBinSize: %f\n", iLayer, mLayerZ[iLayer], mInverseZBinSize[iLayer]);
   }
 }
-} // namespace its
-} // namespace o2
 
+} // namespace o2::its
 #endif /* TRACKINGITSU_INCLUDE_INDEXTABLEUTILS_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index ebc885a3a35cf..a148049e50129 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -65,6 +65,7 @@ class TimeFrameGPU;
 
 template <int nLayers = 7>
 struct TimeFrame {
+  using IndexTableUtilsN = IndexTableUtils<nLayers>;
   using CellSeedN = CellSeed<nLayers>;
   friend class gpu::TimeFrameGPU<nLayers>;
 
@@ -273,7 +274,7 @@ struct TimeFrame {
   void printCellLUTs();
   void printSliceInfo(const int, const int);
 
-  IndexTableUtils mIndexTableUtils;
+  IndexTableUtilsN mIndexTableUtils;
 
   bool mIsGPU = false;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 8647236b4f7e7..9d14bb91635a0 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -21,6 +21,7 @@
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Configuration.h"
 #include "ITStracking/MathUtils.h"
+#include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Cell.h"
 #include "ITStracking/BoundedAllocator.h"
@@ -40,9 +41,10 @@ class TrackITSExt;
 template <int nLayers = 7>
 class TrackerTraits
 {
+ public:
+  using IndexTableUtilsN = IndexTableUtils<nLayers>;
   using CellSeedN = CellSeed<nLayers>;
 
- public:
   virtual ~TrackerTraits() = default;
   virtual void adoptTimeFrame(TimeFrame<nLayers>* tf) { mTimeFrame = tf; }
   virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers); }
@@ -119,7 +121,7 @@ inline const int4 TrackerTraits<nLayers>::getBinsRect(const int layerIndex, floa
     return getEmptyBinsRect();
   }
 
-  const IndexTableUtils& utils{mTimeFrame->mIndexTableUtils};
+  const IndexTableUtilsN& utils{mTimeFrame->mIndexTableUtils};
   return int4{o2::gpu::GPUCommonMath::Max(0, utils.getZBinIndex(layerIndex, zRangeMin)),
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
               o2::gpu::GPUCommonMath::Min(mTrkParams[0].ZBins - 1, utils.getZBinIndex(layerIndex, zRangeMax)), // /!\ trkParams can potentially change across iterations
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index 9d927e21202cc..787f299e15888 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -35,6 +35,8 @@ namespace o2::its
 class ITSTrackingInterface
 {
   static constexpr int NLayers{7};
+  using VertexerN = Vertexer<NLayers>;
+  using VertexerTraitsN = VertexerTraits<NLayers>;
   using TrackerN = Tracker<NLayers>;
   using TrackerTraitsN = TrackerTraits<NLayers>;
   using TimeFrameN = TimeFrame<NLayers>;
@@ -67,7 +69,7 @@ class ITSTrackingInterface
   virtual void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj);
 
   // Custom
-  void setTraitsFromProvider(VertexerTraits*, TrackerTraitsN*, TimeFrameN*);
+  void setTraitsFromProvider(VertexerTraitsN*, TrackerTraitsN*, TimeFrameN*);
   void setTrackingMode(TrackingMode::Type mode = TrackingMode::Unset) { mMode = mode; }
 
   auto getTracker() const { return mTracker.get(); }
@@ -90,7 +92,7 @@ class ITSTrackingInterface
   bool mOverrideBeamEstimation = false;
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
   std::unique_ptr<TrackerN> mTracker = nullptr;
-  std::unique_ptr<Vertexer> mVertexer = nullptr;
+  std::unique_ptr<VertexerN> mVertexer = nullptr;
   const o2::dataformats::MeanVertexObject* mMeanVertex;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 47e483c2e9f06..ab92e7c1a1523 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -35,47 +35,58 @@
 namespace o2::its
 {
 
+template <int nLayers>
 class Vertexer
 {
-  static constexpr int NLayers{7};
-  using TimeFrame7 = TimeFrame<NLayers>;
+  using TimeFrameN = TimeFrame<nLayers>;
+  using VertexerTraitsN = VertexerTraits<nLayers>;
   using LogFunc = std::function<void(const std::string& s)>;
 
  public:
-  Vertexer(VertexerTraits* traits);
+  Vertexer(VertexerTraitsN* traits);
   virtual ~Vertexer() = default;
   Vertexer(const Vertexer&) = delete;
   Vertexer& operator=(const Vertexer&) = delete;
 
-  void adoptTimeFrame(TimeFrame7& tf);
+  void adoptTimeFrame(TimeFrameN& tf);
   auto& getVertParameters() const { return mTraits->getVertexingParameters(); }
   void setParameters(const std::vector<VertexingParameters>& vertParams) { mVertParams = vertParams; }
   const auto& getParameters() const noexcept { return mVertParams; }
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
 
   std::vector<Vertex> exportVertices();
-  VertexerTraits* getTraits() const { return mTraits; };
+  VertexerTraitsN* getTraits() const { return mTraits; };
 
   float clustersToVertices(LogFunc = [](const std::string& s) { std::cout << s << '\n'; });
   void filterMCTracklets();
 
   template <typename... T>
-  void findTracklets(T&&... args);
-  void findTrivialMCTracklets();
+  void findTracklets(T&&... args)
+  {
+    mTraits->computeTracklets(std::forward<T>(args)...);
+  }
   template <typename... T>
-  void validateTracklets(T&&... args);
+  void validateTracklets(T&&... args)
+  {
+    mTraits->computeTrackletMatching(std::forward<T>(args)...);
+  }
   template <typename... T>
-  void findVertices(T&&... args);
+  void findVertices(T&&... args)
+  {
+    mTraits->computeVertices(std::forward<T>(args)...);
+  }
 
   void addTruthSeeds() { mTraits->addTruthSeedingVertices(); }
 
   template <typename... T>
-  void initialiseVertexer(T&&... args);
+  void initialiseVertexer(T&&... args)
+  {
+    mTraits->initialise(std::forward<T>(args)...);
+  }
   template <typename... T>
   void initialiseTimeFrame(T&&... args);
 
   // Utils
-  void dumpTraits() { mTraits->dumpVertexerTraits(); }
   template <typename... T>
   float evaluateTask(void (Vertexer::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args);
 
@@ -89,8 +100,8 @@ class Vertexer
  private:
   std::uint32_t mTimeFrameCounter = 0;
 
-  VertexerTraits* mTraits = nullptr; /// Observer pointer, not owned by this class
-  TimeFrame7* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
+  VertexerTraitsN* mTraits = nullptr; /// Observer pointer, not owned by this class
+  TimeFrameN* mTimeFrame = nullptr;   /// Observer pointer, not owned by this class
 
   std::vector<VertexingParameters> mVertParams;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
@@ -107,32 +118,9 @@ class Vertexer
   static constexpr std::array<const char*, NStates> StateNames{"Initialisation", "Tracklet finding", "Tracklet validation", "Vertex finding", "Truth seeding"};
 };
 
+template <int nLayers>
 template <typename... T>
-void Vertexer::initialiseVertexer(T&&... args)
-{
-  mTraits->initialise(std::forward<T>(args)...);
-}
-
-template <typename... T>
-void Vertexer::findTracklets(T&&... args)
-{
-  mTraits->computeTracklets(std::forward<T>(args)...);
-}
-
-template <typename... T>
-inline void Vertexer::validateTracklets(T&&... args)
-{
-  mTraits->computeTrackletMatching(std::forward<T>(args)...);
-}
-
-template <typename... T>
-inline void Vertexer::findVertices(T&&... args)
-{
-  mTraits->computeVertices(std::forward<T>(args)...);
-}
-
-template <typename... T>
-float Vertexer::evaluateTask(void (Vertexer::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args)
+float Vertexer<nLayers>::evaluateTask(void (Vertexer<nLayers>::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args)
 {
   float diff{0.f};
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 1213ad0a423b8..7da7617957179 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -48,10 +48,11 @@ enum class TrackletMode {
   Layer1Layer2 = 2
 };
 
+template <int nLayers>
 class VertexerTraits
 {
-  static constexpr int NLayers{7};
-  using TimeFrame7 = TimeFrame<NLayers>;
+  using IndexTableUtilsN = IndexTableUtils<nLayers>;
+  using TimeFrameN = TimeFrame<nLayers>;
 
  public:
   VertexerTraits() = default;
@@ -62,8 +63,8 @@ class VertexerTraits
     return int4{0, 0, 0, 0};
   }
   GPUhd() const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi);
-  GPUhd() static const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi, const IndexTableUtils&);
-  GPUhd() static const int2 getPhiBins(float phi, float deltaPhi, const IndexTableUtils&);
+  GPUhd() static const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi, const IndexTableUtilsN&);
+  GPUhd() static const int2 getPhiBins(float phi, float deltaPhi, const IndexTableUtilsN&);
   GPUhd() const int2 getPhiBins(float phi, float deltaPhi) { return getPhiBins(phi, deltaPhi, mIndexTableUtils); }
 
   // virtual vertexer interface
@@ -71,7 +72,7 @@ class VertexerTraits
   virtual void computeTracklets(const int iteration = 0);
   virtual void computeTrackletMatching(const int iteration = 0);
   virtual void computeVertices(const int iteration = 0);
-  virtual void adoptTimeFrame(TimeFrame7* tf) noexcept { mTimeFrame = tf; }
+  virtual void adoptTimeFrame(TimeFrameN* tf) noexcept { mTimeFrame = tf; }
   virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& gpuTfPar);
 
   // truth tracking
@@ -81,7 +82,6 @@ class VertexerTraits
   auto& getVertexingParameters() { return mVrtParams; }
   auto getVertexingParameters() const { return mVrtParams; }
   void setVertexingParameters(std::vector<VertexingParameters>& vertParams) { mVrtParams = vertParams; }
-  void dumpVertexerTraits();
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena);
   int getNThreads() { return mTaskArena->max_concurrency(); }
   virtual bool isGPU() const noexcept { return false; }
@@ -112,10 +112,10 @@ class VertexerTraits
 
  protected:
   std::vector<VertexingParameters> mVrtParams;
-  IndexTableUtils mIndexTableUtils;
+  IndexTableUtilsN mIndexTableUtils;
 
   // Frame related quantities
-  TimeFrame7* mTimeFrame = nullptr; // observer ptr
+  TimeFrameN* mTimeFrame = nullptr; // observer ptr
  private:
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
@@ -126,20 +126,23 @@ class VertexerTraits
   void debugComputeVertices(int iteration);
 };
 
-inline void VertexerTraits::initialise(const TrackingParameters& trackingParams, const int iteration)
+template <int nLayers>
+inline void VertexerTraits<nLayers>::initialise(const TrackingParameters& trackingParams, const int iteration)
 {
   mTimeFrame->initialise(0, trackingParams, 3, (bool)(!iteration)); // iteration for initialisation must be 0 for correctly resetting the frame, we need to pass the non-reset flag for vertices as well, tho.
 }
 
-GPUhdi() const int2 VertexerTraits::getPhiBins(float phi, float dPhi, const IndexTableUtils& utils)
+template <int nLayers>
+GPUhdi() const int2 VertexerTraits<nLayers>::getPhiBins(float phi, float dPhi, const IndexTableUtilsN& utils)
 {
   return int2{utils.getPhiBinIndex(math_utils::getNormalizedPhi(phi - dPhi)),
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phi + dPhi))};
 }
 
-GPUhdi() const int4 VertexerTraits::getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                                                const float directionZIntersection, float maxdeltaz, float maxdeltaphi,
-                                                const IndexTableUtils& utils)
+template <int nLayers>
+GPUhdi() const int4 VertexerTraits<nLayers>::getBinsRect(const Cluster& currentCluster, const int layerIndex,
+                                                         const float directionZIntersection, float maxdeltaz, float maxdeltaphi,
+                                                         const IndexTableUtilsN& utils)
 {
   const float zRangeMin = directionZIntersection - 2 * maxdeltaz;
   const float phiRangeMin = currentCluster.phi - maxdeltaphi;
@@ -157,8 +160,9 @@ GPUhdi() const int4 VertexerTraits::getBinsRect(const Cluster& currentCluster, c
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
 }
 
-GPUhdi() const int4 VertexerTraits::getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                                                const float directionZIntersection, float maxdeltaz, float maxdeltaphi)
+template <int nLayers>
+GPUhdi() const int4 VertexerTraits<nLayers>::getBinsRect(const Cluster& currentCluster, const int layerIndex,
+                                                         const float directionZIntersection, float maxdeltaz, float maxdeltaphi)
 {
   return VertexerTraits::getBinsRect(currentCluster, layerIndex, directionZIntersection, maxdeltaz, maxdeltaphi, mIndexTableUtils);
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
index 78f6683675947..c4d288bd61777 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
@@ -37,7 +37,8 @@ Cluster::Cluster(const float x, const float y, const float z, const int index)
   // Nothing to do
 }
 
-Cluster::Cluster(const int layerIndex, const IndexTableUtils& utils, const Cluster& other)
+template <int nLayers>
+Cluster::Cluster(const int layerIndex, const IndexTableUtils<nLayers>& utils, const Cluster& other)
   : xCoordinate{other.xCoordinate},
     yCoordinate{other.yCoordinate},
     zCoordinate{other.zCoordinate},
@@ -51,7 +52,8 @@ Cluster::Cluster(const int layerIndex, const IndexTableUtils& utils, const Clust
   // Nothing to do
 }
 
-Cluster::Cluster(const int layerIndex, const float3& primaryVertex, const IndexTableUtils& utils, const Cluster& other)
+template <int nLayers>
+Cluster::Cluster(const int layerIndex, const float3& primaryVertex, const IndexTableUtils<nLayers>& utils, const Cluster& other)
   : xCoordinate{other.xCoordinate},
     yCoordinate{other.yCoordinate},
     zCoordinate{other.zCoordinate},
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 280101d4dc4c7..58cfab73a7af3 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -814,7 +814,7 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         TrackITSExt temporaryTrack{seed};
         temporaryTrack.resetCovariance();
         temporaryTrack.setChi2(0);
-        for (int iL{0}; iL < 7; ++iL) {
+        for (int iL{0}; iL < nLayers; ++iL) {
           temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
         }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index d2e96aad40a9e..d6ac3b5229509 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -382,11 +382,11 @@ void ITSTrackingInterface::printSummary() const
   mTracker->printSummary();
 }
 
-void ITSTrackingInterface::setTraitsFromProvider(VertexerTraits* vertexerTraits,
+void ITSTrackingInterface::setTraitsFromProvider(VertexerTraitsN* vertexerTraits,
                                                  TrackerTraitsN* trackerTraits,
                                                  TimeFrameN* frame)
 {
-  mVertexer = std::make_unique<Vertexer>(vertexerTraits);
+  mVertexer = std::make_unique<VertexerN>(vertexerTraits);
   mTracker = std::make_unique<TrackerN>(trackerTraits);
   mTimeFrame = frame;
   mVertexer->adoptTimeFrame(*mTimeFrame);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 94d69f7968ac8..69dddbf367653 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -26,7 +26,8 @@
 namespace o2::its
 {
 
-Vertexer::Vertexer(VertexerTraits* traits) : mTraits(traits)
+template <int nLayers>
+Vertexer<nLayers>::Vertexer(VertexerTraitsN* traits) : mTraits(traits)
 {
   if (!mTraits) {
     LOG(fatal) << "nullptr passed to ITS vertexer construction.";
@@ -34,7 +35,8 @@ Vertexer::Vertexer(VertexerTraits* traits) : mTraits(traits)
   mVertParams.resize(1);
 }
 
-float Vertexer::clustersToVertices(LogFunc logger)
+template <int nLayers>
+float Vertexer<nLayers>::clustersToVertices(LogFunc logger)
 {
   LogFunc evalLog = [](const std::string&) {};
 
@@ -87,16 +89,18 @@ float Vertexer::clustersToVertices(LogFunc logger)
   return timeInit + timeTracklet + timeSelection + timeVertexing;
 }
 
-void Vertexer::adoptTimeFrame(TimeFrame7& tf)
+template <int nLayers>
+void Vertexer<nLayers>::adoptTimeFrame(TimeFrameN& tf)
 {
   mTimeFrame = &tf;
   mTraits->adoptTimeFrame(&tf);
 }
 
-void Vertexer::printEpilog(LogFunc& logger,
-                           const unsigned int trackletN01, const unsigned int trackletN12,
-                           const unsigned selectedN, const unsigned int vertexN, const float initT,
-                           const float trackletT, const float selecT, const float vertexT)
+template <int nLayers>
+void Vertexer<nLayers>::printEpilog(LogFunc& logger,
+                                    const unsigned int trackletN01, const unsigned int trackletN12,
+                                    const unsigned selectedN, const unsigned int vertexN, const float initT,
+                                    const float trackletT, const float selecT, const float vertexT)
 {
   logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
   logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {} ms", mTraits->getName(), selectedN, selecT));
@@ -107,4 +111,6 @@ void Vertexer::printEpilog(LogFunc& logger,
   }
 }
 
+template class Vertexer<7>;
+
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index bcafa98972d78..153d7b6faa358 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -28,9 +28,10 @@
 #include "DetectorsRaw/HBFUtils.h"
 #include "CommonUtils/TreeStreamRedirector.h"
 
-using namespace o2::its;
+namespace o2::its
+{
 
-template <TrackletMode Mode, bool EvalRun>
+template <TrackletMode Mode, bool EvalRun, int nLayers>
 static void trackleterKernelHost(
   const gsl::span<const Cluster>& clustersNextLayer,    // 0 2
   const gsl::span<const Cluster>& clustersCurrentLayer, // 1 1
@@ -39,7 +40,7 @@ static void trackleterKernelHost(
   const float phiCut,
   bounded_vector<Tracklet>& tracklets,
   gsl::span<int> foundTracklets,
-  const IndexTableUtils& utils,
+  const IndexTableUtils<nLayers>& utils,
   const short pivotRof,
   const short targetRof,
   gsl::span<int> rofFoundTrackletsOffsets, // we want to change those, to keep track of the offset in deltaRof>0
@@ -51,7 +52,7 @@ static void trackleterKernelHost(
   for (int iCurrentLayerClusterIndex = 0; iCurrentLayerClusterIndex < clustersCurrentLayer.size(); ++iCurrentLayerClusterIndex) {
     int storedTracklets{0};
     const Cluster& currentCluster{clustersCurrentLayer[iCurrentLayerClusterIndex]};
-    const int4 selectedBinsRect{VertexerTraits::getBinsRect(currentCluster, (int)Mode, 0.f, 50.f, phiCut / 2, utils)};
+    const int4 selectedBinsRect{VertexerTraits<nLayers>::getBinsRect(currentCluster, (int)Mode, 0.f, 50.f, phiCut / 2, utils)};
     if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) {
       int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
       if (phiBinsNum < 0) {
@@ -151,7 +152,8 @@ static void trackletSelectionKernelHost(
   }
 }
 
-void VertexerTraits::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& tfPar)
+template <int nLayers>
+void VertexerTraits<nLayers>::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& tfPar)
 {
   mVrtParams = vrtPar;
   mIndexTableUtils.setTrackingParameters(vrtPar[0]);
@@ -162,7 +164,8 @@ void VertexerTraits::updateVertexingParameters(const std::vector<VertexingParame
 }
 
 // Main functions
-void VertexerTraits::computeTracklets(const int iteration)
+template <int nLayers>
+void VertexerTraits<nLayers>::computeTracklets(const int iteration)
 {
   mTaskArena->execute([&] {
     tbb::parallel_for(
@@ -283,7 +286,8 @@ void VertexerTraits::computeTracklets(const int iteration)
 #endif
 }
 
-void VertexerTraits::computeTrackletMatching(const int iteration)
+template <int nLayers>
+void VertexerTraits<nLayers>::computeTrackletMatching(const int iteration)
 {
   mTaskArena->execute([&] {
     tbb::parallel_for(
@@ -341,7 +345,8 @@ void VertexerTraits::computeTrackletMatching(const int iteration)
   deepVectorClear(mTimeFrame->getTracklets()[1]);
 }
 
-void VertexerTraits::computeVertices(const int iteration)
+template <int nLayers>
+void VertexerTraits<nLayers>::computeVertices(const int iteration)
 {
   auto nsigmaCut{std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f)};
   bounded_vector<Vertex> vertices(mMemoryPool.get());
@@ -497,7 +502,8 @@ void VertexerTraits::computeVertices(const int iteration)
 #endif
 }
 
-void VertexerTraits::addTruthSeedingVertices()
+template <int nLayers>
+void VertexerTraits<nLayers>::addTruthSeedingVertices()
 {
   LOGP(info, "Using truth seeds as vertices; will skip computations");
   mTimeFrame->resetRofPV();
@@ -562,7 +568,8 @@ void VertexerTraits::addTruthSeedingVertices()
   LOGP(info, "Found {}/{} ROFs with {} vertices -> <NV>={:.2f}", vertices.size(), mTimeFrame->getNrof(), nVerts, (float)nVerts / (float)vertices.size());
 }
 
-void VertexerTraits::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
+template <int nLayers>
+void VertexerTraits<nLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
 {
 #if defined(VTX_DEBUG)
   LOGP(info, "Vertexer with debug output forcing single thread");
@@ -578,7 +585,8 @@ void VertexerTraits::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
 #endif
 }
 
-void VertexerTraits::debugComputeTracklets(int iteration)
+template <int nLayers>
+void VertexerTraits<nLayers>::debugComputeTracklets(int iteration)
 {
   auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "recreate");
   LOGP(info, "writing debug output for computeTracklets");
@@ -597,7 +605,8 @@ void VertexerTraits::debugComputeTracklets(int iteration)
   delete stream;
 }
 
-void VertexerTraits::debugComputeTrackletMatching(int iteration)
+template <int nLayers>
+void VertexerTraits<nLayers>::debugComputeTrackletMatching(int iteration)
 {
   auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "update");
   LOGP(info, "writing debug output for computeTrackletMatching");
@@ -718,7 +727,8 @@ void VertexerTraits::debugComputeTrackletMatching(int iteration)
   delete stream;
 }
 
-void VertexerTraits::debugComputeVertices(int iteration)
+template <int nLayers>
+void VertexerTraits<nLayers>::debugComputeVertices(int iteration)
 {
   auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "update");
   LOGP(info, "writing debug output for computeVertices");
@@ -831,3 +841,6 @@ void VertexerTraits::debugComputeVertices(int iteration)
   stream->Close();
   delete stream;
 }
+
+template class VertexerTraits<7>;
+} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
index eb55081889c12..4ecc98eed9cfb 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
@@ -58,8 +58,8 @@ class CookedTrackerDPL : public Task
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
   std::unique_ptr<o2::parameters::GRPObject> mGRP = nullptr;
   o2::its::CookedTracker mTracker;
-  std::unique_ptr<VertexerTraits> mVertexerTraitsPtr = nullptr;
-  std::unique_ptr<Vertexer> mVertexerPtr = nullptr;
+  std::unique_ptr<VertexerTraits<7>> mVertexerTraitsPtr = nullptr;
+  std::unique_ptr<Vertexer<7>> mVertexerPtr = nullptr;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
   TStopwatch mTimer;
diff --git a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
index 98662e46269d1..b989a78e59b7c 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
@@ -53,8 +53,8 @@ using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 CookedTrackerDPL::CookedTrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, int trgType, TrackingMode::Type trMode) : mGGCCDBRequest(gr), mUseMC(useMC), mUseTriggers{trgType}, mMode(trMode)
 {
-  mVertexerTraitsPtr = std::make_unique<VertexerTraits>();
-  mVertexerPtr = std::make_unique<Vertexer>(mVertexerTraitsPtr.get());
+  mVertexerTraitsPtr = std::make_unique<VertexerTraits<7>>();
+  mVertexerPtr = std::make_unique<Vertexer<7>>(mVertexerTraitsPtr.get());
 }
 
 void CookedTrackerDPL::init(InitContext& ic)
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index c7b61a976021a..09aae2aacf16d 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -111,13 +111,13 @@ GPUReconstruction::~GPUReconstruction()
   }
 }
 
-void GPUReconstruction::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame)
+void GPUReconstruction::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits<7>>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame)
 {
   if (trackerTraits) {
     trackerTraits->reset(new o2::its::TrackerTraits<7>);
   }
   if (vertexerTraits) {
-    vertexerTraits->reset(new o2::its::VertexerTraits);
+    vertexerTraits->reset(new o2::its::VertexerTraits<7>);
   }
   if (timeFrame) {
     timeFrame->reset(new o2::its::TimeFrame<7>);
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 70c504cdee6e1..420e602e61352 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -38,6 +38,7 @@ namespace o2::its
 {
 template <int>
 class TrackerTraits;
+template <int>
 class VertexerTraits;
 template <int>
 class TimeFrame;
@@ -191,7 +192,7 @@ class GPUReconstruction
   GPUMemorySizeScalers* MemoryScalers() { return mMemoryScalers.get(); }
 
   // Helpers to fetch processors from other shared libraries
-  virtual void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame);
+  virtual void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits<7>>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame);
   bool slavesExist() { return mSlaves.size() || mMaster; }
   int slaveId() { return mSlaveId; }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
index f4ef3b464c24f..c4202e9980d24 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
@@ -21,26 +21,28 @@
 #include "ITStracking/TimeFrame.h"
 #if defined(__CUDACC__) || defined(__HIPCC__)
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
-#include "ITStrackingGPU/VertexerTraitsGPU.h"
+// #include "ITStrackingGPU/VertexerTraitsGPU.h"
 #include "ITStrackingGPU/TimeFrameGPU.h"
 #endif
 #else
 namespace o2::its
 {
+template <int32_t>
 class VertexerTraits
 {
 };
-template <int>
+template <int32_t>
 class TrackerTraits
 {
 };
-template <int>
+template <int32_t>
 class TimeFrame
 {
 };
-class VertexerTraitsGPU : public VertexerTraits
-{
-};
+// template <int32_t NLayers>
+// class VertexerTraitsGPU : public VertexerTraits<NLayers>
+// {
+// };
 template <int32_t NLayers = 7>
 class TrackerTraitsGPU : public TrackerTraits<NLayers>
 {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index dc904fa96fa2d..0ee91dd2eaf21 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -91,13 +91,13 @@ int32_t GPUReconstructionCUDA::GPUChkErrInternal(const int64_t error, const char
 
 GPUReconstruction* GPUReconstruction_Create_CUDA(const GPUSettingsDeviceBackend& cfg) { return new GPUReconstructionCUDA(cfg); }
 
-void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame)
+void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits<7>>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame)
 {
   if (trackerTraits) {
     trackerTraits->reset(new o2::its::TrackerTraitsGPU);
   }
   if (vertexerTraits) {
-    vertexerTraits->reset(new o2::its::VertexerTraits); // TODO gpu-code to be implemented
+    vertexerTraits->reset(new o2::its::VertexerTraits<7>); // TODO gpu-code to be implemented
   }
   if (timeFrame) {
     timeFrame->reset(new o2::its::gpu::TimeFrameGPU);
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
index 1cc7e0fc819ff..b3562eff4096d 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.h
@@ -76,7 +76,7 @@ class GPUReconstructionCUDA : public GPUReconstructionProcessing::KernelInterfac
   void RecordMarker(deviceEvent* ev, int32_t stream) override;
   void SetONNXGPUStream(Ort::SessionOptions& session_options, int32_t stream, int32_t* deviceId) override;
 
-  void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame) override;
+  void GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits<7>>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame) override;
 
 #ifndef __HIPCC__ // CUDA
   bool CanQueryMaxMemory() override { return true; }
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index 18fb5ff1de939..e53f5db3a2549 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -56,7 +56,7 @@ o2::its::TrackerTraits<7>* GPUChainITS::GetITSTrackerTraits()
   return mITSTrackerTraits.get();
 }
 
-o2::its::VertexerTraits* GPUChainITS::GetITSVertexerTraits()
+o2::its::VertexerTraits<7>* GPUChainITS::GetITSVertexerTraits()
 {
   if (mITSVertexerTraits == nullptr) {
     mRec->GetITSTraits(nullptr, &mITSVertexerTraits, nullptr);
diff --git a/GPU/GPUTracking/Global/GPUChainITS.h b/GPU/GPUTracking/Global/GPUChainITS.h
index 6821f63845b95..a607f66322bab 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.h
+++ b/GPU/GPUTracking/Global/GPUChainITS.h
@@ -45,13 +45,13 @@ class GPUChainITS final : public GPUChain
   void MemorySize(size_t&, size_t&) final {};
 
   o2::its::TrackerTraits<7>* GetITSTrackerTraits();
-  o2::its::VertexerTraits* GetITSVertexerTraits();
+  o2::its::VertexerTraits<7>* GetITSVertexerTraits();
   o2::its::TimeFrame<7>* GetITSTimeframe();
 
  protected:
   GPUChainITS(GPUReconstruction* rec);
   std::unique_ptr<o2::its::TrackerTraits<7>> mITSTrackerTraits;
-  std::unique_ptr<o2::its::VertexerTraits> mITSVertexerTraits;
+  std::unique_ptr<o2::its::VertexerTraits<7>> mITSVertexerTraits;
   std::unique_ptr<o2::its::TimeFrame<7>> mITSTimeFrame;
   std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkAllocator;
 };
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index f1504a430db36..65907528a3dba 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -251,7 +251,7 @@ void GPUO2Interface::setErrorCodeOutput(std::vector<std::array<uint32_t, 4>>* v)
   }
 }
 
-void GPUO2Interface::GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame)
+void GPUO2Interface::GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits<7>*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame)
 {
   trackerTraits = mChainITS->GetITSTrackerTraits();
   vertexerTraits = mChainITS->GetITSVertexerTraits();
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.h b/GPU/GPUTracking/Interface/GPUO2Interface.h
index 03b24c2b23877..9b7390f2ed663 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.h
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.h
@@ -45,6 +45,7 @@ namespace o2::its
 {
 template <int>
 class TrackerTraits;
+template <int>
 class VertexerTraits;
 template <int>
 class TimeFrame;
@@ -79,7 +80,7 @@ class GPUO2Interface
   void DumpEvent(int32_t nEvent, GPUTrackingInOutPointers* data);
   void DumpSettings();
 
-  void GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame);
+  void GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits<7>*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame);
   const o2::base::Propagator* GetDeviceO2Propagator(int32_t iThread = 0) const;
   void UseGPUPolynomialFieldInPropagator(o2::base::Propagator* prop) const;
 
diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index 31ccaad8c2783..fe55b83633972 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -37,7 +37,7 @@ int32_t GPURecoWorkflowSpec::runITSTracking(o2::framework::ProcessingContext& pc
 
 void GPURecoWorkflowSpec::initFunctionITS(o2::framework::InitContext& ic)
 {
-  o2::its::VertexerTraits* vtxTraits = nullptr;
+  o2::its::VertexerTraits<7>* vtxTraits = nullptr;
   o2::its::TrackerTraits<7>* trkTraits = nullptr;
 #ifdef ENABLE_UPGRADES
   if (mSpecConfig.isITS3) {

From ad2098cbb0863ae836ee51b197fe7081ed85aa8f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 26 Aug 2025 16:30:22 +0200
Subject: [PATCH 0755/1764] GPU: Rename misleading variable

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx        |  2 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.h          |  2 +-
 GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h   |  2 +-
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu   | 10 +++++-----
 GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx |  6 +++---
 GPU/GPUTracking/Global/GPUChain.h                    |  2 +-
 6 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index faa5ccbaf6a50..f7b08f9dd0c48 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -194,7 +194,7 @@ int32_t GPUReconstructionCPU::InitDevice()
     ClearAllocatedMemory();
   }
   if (GetProcessingSettings().inKernelParallel) {
-    mBlockCount = mMaxHostThreads;
+    mMultiprocessorCount = mMaxHostThreads;
   }
   mProcShadow.mProcessorsProc = processors();
   return 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index d93d1335d45c5..768c301f24327 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -94,7 +94,7 @@ class GPUReconstructionCPU : public GPUReconstructionProcessing::KernelInterface
   GPUProcessorProcessors mProcShadow; // Host copy of tracker objects that will be used on the GPU
   GPUConstantMem*& mProcessorsShadow = mProcShadow.mProcessorsProc;
 
-  uint32_t mBlockCount = 1;
+  uint32_t mMultiprocessorCount = 1;
   uint32_t mThreadCount = 1;
   uint32_t mWarpSize = 1;
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h b/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
index 837516a93b6ae..7bf819a74e1b6 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
@@ -36,7 +36,7 @@ inline void GPUReconstructionCPU::runKernelInterface(krnlSetup&& setup, Args con
   const uint32_t stream = setup.x.stream;
   auto prop = getKernelProperties<S, I>();
   const int32_t autoThreads = cpuFallback ? 1 : prop.nThreads;
-  const int32_t autoBlocks = cpuFallback ? 1 : (prop.forceBlocks ? prop.forceBlocks : (prop.minBlocks * mBlockCount));
+  const int32_t autoBlocks = cpuFallback ? 1 : (prop.forceBlocks ? prop.forceBlocks : (prop.minBlocks * mMultiprocessorCount));
   if (nBlocks == (uint32_t)-1) {
     nBlocks = (nThreads + autoThreads - 1) / autoThreads;
     nThreads = autoThreads;
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 0ee91dd2eaf21..71582b4fed55e 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -247,8 +247,8 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       throw std::runtime_error("Invalid warp size on GPU");
     }
     mWarpSize = deviceProp.warpSize;
-    mBlockCount = deviceProp.multiProcessorCount;
-    mMaxBackendThreads = std::max<int32_t>(mMaxBackendThreads, deviceProp.maxThreadsPerBlock * mBlockCount);
+    mMultiprocessorCount = deviceProp.multiProcessorCount;
+    mMaxBackendThreads = std::max<int32_t>(mMaxBackendThreads, deviceProp.maxThreadsPerBlock * mMultiprocessorCount);
     mDeviceName = deviceProp.name;
     mDeviceName += " (CUDA GPU)";
 
@@ -329,9 +329,9 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
     }
 
 #ifndef __HIPCC__ // CUDA
-    dummyInitKernel<<<mBlockCount, 256>>>(mDeviceMemoryBase);
+    dummyInitKernel<<<mMultiprocessorCount, 256>>>(mDeviceMemoryBase); // TODO: Can't we just use the CUDA version and hipify will take care of the rest?
 #else // HIP
-    hipLaunchKernelGGL(HIP_KERNEL_NAME(dummyInitKernel), dim3(mBlockCount), dim3(256), 0, 0, mDeviceMemoryBase);
+    hipLaunchKernelGGL(HIP_KERNEL_NAME(dummyInitKernel), dim3(mMultiprocessorCount), dim3(256), 0, 0, mDeviceMemoryBase);
 #endif
 
     if (GetProcessingSettings().rtc.enable) {
@@ -373,7 +373,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
   } else {
     GPUReconstructionCUDA* master = dynamic_cast<GPUReconstructionCUDA*>(mMaster);
     mDeviceId = master->mDeviceId;
-    mBlockCount = master->mBlockCount;
+    mMultiprocessorCount = master->mMultiprocessorCount;
     mWarpSize = master->mWarpSize;
     mMaxBackendThreads = master->mMaxBackendThreads;
     mDeviceName = master->mDeviceName;
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index 49533216869d2..271fe494860cd 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -266,9 +266,9 @@ int32_t GPUReconstructionOCL::InitDevice_Runtime()
 
     mDeviceName = device_name.c_str();
     mDeviceName += " (OpenCL)";
-    mBlockCount = device_shaders;
+    mMultiprocessorCount = device_shaders;
     mWarpSize = 32;
-    mMaxBackendThreads = std::max<int32_t>(mMaxBackendThreads, deviceMaxWorkGroup * mBlockCount);
+    mMaxBackendThreads = std::max<int32_t>(mMaxBackendThreads, deviceMaxWorkGroup * mMultiprocessorCount);
 
     mInternals->context = clCreateContext(nullptr, 1, &mInternals->device, nullptr, nullptr, &ocl_error);
     if (GPUChkErrI(ocl_error)) {
@@ -378,7 +378,7 @@ int32_t GPUReconstructionOCL::InitDevice_Runtime()
     GPUInfo("OPENCL Initialisation successfull (%d: %s %s (Frequency %d, Shaders %d), %ld / %ld bytes host / global memory, Stack frame %d, Constant memory %ld)", bestDevice, device_vendor, device_name, (int32_t)device_freq, (int32_t)device_shaders, (int64_t)mDeviceMemorySize, (int64_t)mHostMemorySize, -1, (int64_t)gGPUConstantMemBufferSize);
   } else {
     GPUReconstructionOCL* master = dynamic_cast<GPUReconstructionOCL*>(mMaster);
-    mBlockCount = master->mBlockCount;
+    mMultiprocessorCount = master->mMultiprocessorCount;
     mWarpSize = master->mWarpSize;
     mMaxBackendThreads = master->mMaxBackendThreads;
     mDeviceName = master->mDeviceName;
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index aca1bb2420fb6..e3a20ad81a2cb 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -210,7 +210,7 @@ class GPUChain
   krnlExec GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
   krnlExec GetGridAutoStep(int32_t stream, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
 
-  inline uint32_t BlockCount() const { return mRec->mBlockCount; }
+  inline uint32_t BlockCount() const { return mRec->mMultiprocessorCount; }
   inline uint32_t WarpSize() const { return mRec->mWarpSize; }
   inline uint32_t ThreadCount() const { return mRec->mThreadCount; }
 

From 3673ef74be24ce9bc6a506dadaa7bdf789141b68 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 27 Aug 2025 11:09:25 +0200
Subject: [PATCH 0756/1764] ITS: cell neighbour step use atomicMax (#14595)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx    | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 58cfab73a7af3..83210d474ed9f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -601,20 +601,14 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
       mTimeFrame->getCellsNeighbours()[iLayer].reserve(cellsNeighbours.size());
       std::ranges::transform(cellsNeighbours, std::back_inserter(mTimeFrame->getCellsNeighbours()[iLayer]), [](const auto& neigh) { return neigh.cell; });
 
-      auto it = cellsNeighbours.begin();
-      int current = it->nextCell;
-      int maxLvl = it->level;
-      ++it;
-      for (; it != cellsNeighbours.end(); ++it) {
-        if (it->nextCell == current) {
+      for (auto it = cellsNeighbours.begin(); it != cellsNeighbours.end();) {
+        int cellIdx = it->nextCell;
+        int maxLvl = it->level;
+        while (++it != cellsNeighbours.end() && it->nextCell == cellIdx) {
           maxLvl = std::max(maxLvl, it->level);
-        } else {
-          mTimeFrame->getCells()[iLayer + 1][current].setLevel(maxLvl);
-          current = it->nextCell;
-          maxLvl = it->level;
         }
+        o2::gpu::CAMath::AtomicMax(mTimeFrame->getCells()[iLayer + 1][cellIdx].getLevelPtr(), maxLvl);
       }
-      mTimeFrame->getCells()[iLayer + 1][current].setLevel(maxLvl);
     }
   });
 }

From cfa791d76569b4cd88f21323d8a6618670c0d1be Mon Sep 17 00:00:00 2001
From: Francesco Noferini <noferini@bo.infn.it>
Date: Wed, 27 Aug 2025 13:49:38 +0200
Subject: [PATCH 0757/1764] add best knowldge of collision time in tof matching
 info (#14615)

---
 .../ReconstructionDataFormats/MatchInfoTOF.h  | 13 ++++++++++-
 Detectors/GlobalTracking/src/MatchTOF.cxx     | 23 +++++++++++++++++--
 .../src/tof-matcher-workflow.cxx              |  6 ++---
 3 files changed, 36 insertions(+), 6 deletions(-)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/MatchInfoTOF.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/MatchInfoTOF.h
index 1816e8604c0be..7bcfd7af0911a 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/MatchInfoTOF.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/MatchInfoTOF.h
@@ -86,6 +86,14 @@ class MatchInfoTOF
                       hasT0_1BCbefore = 0x1 << 8,
                       hasT0_2BCbefore = 0x1 << 9 };
 
+  void setFT0Best(double val, float res = 200.)
+  {
+    mFT0Best = val;
+    mFT0BestRes = res;
+  }
+  double getFT0Best() const { return mFT0Best; }
+  float getFT0BestRes() const { return mFT0BestRes; }
+
  private:
   int mIdLocal;                      // track id in sector of the pair track-TOFcluster
   float mChi2;                       // chi2 of the pair track-TOFcluster
@@ -106,7 +114,10 @@ class MatchInfoTOF
   float mTgeant = 0.0;        ///< geant time in MC
   double mT0true = 0.0;       ///< t0true
 
-  ClassDefNV(MatchInfoTOF, 8);
+  double mFT0Best = 0.0;     //< best info for collision time
+  float mFT0BestRes = 200.0; //< resolution (in ps) of the best info for collision time
+
+  ClassDefNV(MatchInfoTOF, 9);
 };
 } // namespace dataformats
 } // namespace o2
diff --git a/Detectors/GlobalTracking/src/MatchTOF.cxx b/Detectors/GlobalTracking/src/MatchTOF.cxx
index 89d6f8347373d..6a3486dd12044 100644
--- a/Detectors/GlobalTracking/src/MatchTOF.cxx
+++ b/Detectors/GlobalTracking/src/MatchTOF.cxx
@@ -1581,6 +1581,8 @@ void MatchTOF::doMatchingForTPC(int sec)
 //______________________________________________
 int MatchTOF::findFITIndex(int bc, const gsl::span<const o2::ft0::RecPoints>& FITRecPoints, unsigned long firstOrbit)
 {
+  const auto& FT0Params = o2::ft0::InteractionTag::Instance();
+
   if ((!mHasFillScheme) && o2::tof::Utils::hasFillScheme()) {
     mHasFillScheme = true;
     for (int ibc = 0; ibc < o2::tof::Utils::getNinteractionBC(); ibc++) {
@@ -1598,6 +1600,10 @@ int MatchTOF::findFITIndex(int bc, const gsl::span<const o2::ft0::RecPoints>& FI
   const int distThr = 8;
 
   for (unsigned int i = 0; i < FITRecPoints.size(); i++) {
+    const auto& ft = FITRecPoints[i];
+    if (!FT0Params.isSelected(ft)) {
+      continue;
+    }
     const o2::InteractionRecord ir = FITRecPoints[i].getInteractionRecord();
     if (mHasFillScheme && !mFillScheme[ir.bc]) {
       continue;
@@ -1702,8 +1708,8 @@ void MatchTOF::BestMatches(std::vector<o2::dataformats::MatchInfoTOFReco>& match
     matchingPair.setT0true(TOFClusWork[matchingPair.getTOFClIndex()].getT0true());
 
     // let's check if cluster has multiple-hits (noferini)
-    if (TOFClusWork[matchingPair.getTOFClIndex()].getNumOfContributingChannels() > 1) {
-      const auto& tofcl = TOFClusWork[matchingPair.getTOFClIndex()];
+    const auto& tofcl = TOFClusWork[matchingPair.getTOFClIndex()];
+    if (tofcl.getNumOfContributingChannels() > 1) {
       // has an additional hit Up or Down (Z-dir)
       matchingPair.setHitPatternUpDown(tofcl.isAdditionalChannelSet(o2::tof::Cluster::kUp) ||
                                        tofcl.isAdditionalChannelSet(o2::tof::Cluster::kUpLeft) ||
@@ -1719,6 +1725,19 @@ void MatchTOF::BestMatches(std::vector<o2::dataformats::MatchInfoTOFReco>& match
                                           tofcl.isAdditionalChannelSet(o2::tof::Cluster::kDownRight) ||
                                           tofcl.isAdditionalChannelSet(o2::tof::Cluster::kUpRight));
     }
+
+    // estimate collision time using FT0 info if available
+    ULong64_t bclongtofCal = (matchingPair.getSignal() - 10000) * o2::tof::Geo::BC_TIME_INPS_INV;
+    double t0Best = bclongtofCal * o2::tof::Geo::BC_TIME_INPS; // here just BC
+    float t0BestRes = 200;
+    if (FITRecPoints.size() > 0) {
+      int index = findFITIndex(bclongtofCal, FITRecPoints, mFirstTForbit);
+      if (index > -1 && FITRecPoints[index].isValidTime(1) && FITRecPoints[index].isValidTime(2)) { // require A and C
+        t0Best += FITRecPoints[index].getCollisionTime(0);
+        t0BestRes = 15;
+      }
+    }
+    matchingPair.setFT0Best(t0Best, t0BestRes);
     matchedTracks[trkTypeSplitted].push_back(matchingPair); // array of MatchInfoTOF
 
     // get fit info
diff --git a/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
index 8dc56794817a5..9a95c83617210 100644
--- a/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
@@ -114,9 +114,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     }
   }
 
-  if (!writecalib) {
-    useFIT = false;
-  }
+  //  if (!writecalib) {
+  //    useFIT = false;
+  //  }
 
   LOG(debug) << "TOF MATCHER WORKFLOW configuration";
   LOG(debug) << "TOF track inputs = " << configcontext.options().get<std::string>("track-sources");

From 577a7f008d93e173f2880982905940d349a7e95f Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 27 Aug 2025 18:21:35 +0200
Subject: [PATCH 0758/1764] ITS: skip processing entirely if no clusters/rofs
 in TF (#14629)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/src/TrackingInterface.cxx    | 25 +++++++++++--------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index d6ac3b5229509..f673d8f446350 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -99,7 +99,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   irFrames.reserve(trackROFvec.size());
   int nBCPerTF = alpParams.roFrameLengthInBC;
 
-  LOGP(info, "ITSTracker pulled {} clusters, {} RO frames", compClusters.size(), trackROFvec.size());
+  LOGP(info, "ITSTracker pulled {} clusters, {} RO frames {}", compClusters.size(), trackROFvec.size(), compClusters.empty() ? " -> received no processable data will skip" : "");
   const dataformats::MCTruthContainer<MCCompLabel>* labels = nullptr;
   gsl::span<itsmft::MC2ROFRecord const> mc2rofs;
   if (mIsMC) {
@@ -157,7 +157,9 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   if (mRunVertexer) {
     vertROFvec.reserve(trackROFvec.size());
     // Run seeding vertexer
-    vertexerElapsedTime = mVertexer->clustersToVertices(logger);
+    if (!compClusters.empty()) {
+      vertexerElapsedTime = mVertexer->clustersToVertices(logger);
+    }
   } else { // cosmics
     mTimeFrame->resetRofPV();
   }
@@ -226,7 +228,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       mTimeFrame->addPrimaryVertices(vtxVecLoc, 0);
     }
   }
-  if (mRunVertexer) {
+  if (mRunVertexer && !compClusters.empty()) {
     LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms for {} ({} + {}) vertices found in {}/{} ROFs",
                              vertexerElapsedTime,
                              mTimeFrame->getPrimaryVerticesNum(),
@@ -244,14 +246,15 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   if (mCosmicsProcessing && compClusters.size() > 1500 * trackROFspan.size()) {
     LOG(error) << "Cosmics processing was requested with an average detector occupancy exceeding 1.e-7, skipping TF processing.";
   } else {
-
-    mTimeFrame->setMultiplicityCutMask(processingMask);
-    mTimeFrame->setROFMask(processUPCMask);
-    // Run CA tracker
-    if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
-      mTracker->clustersToTracks(logger, fatalLogger);
-    } else {
-      mTracker->clustersToTracks(logger, errorLogger);
+    if (!compClusters.empty()) {
+      mTimeFrame->setMultiplicityCutMask(processingMask);
+      mTimeFrame->setROFMask(processUPCMask);
+      // Run CA tracker
+      if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
+        mTracker->clustersToTracks(logger, fatalLogger);
+      } else {
+        mTracker->clustersToTracks(logger, errorLogger);
+      }
     }
     size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
     if (totTracks) {

From 8de09fccdf8da8a48e28be5482713489d083b623 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 7 Aug 2025 10:57:25 +0200
Subject: [PATCH 0759/1764] TPC: change default max-delay to 1 for
 o2-tpc-calibrator-dedx

---
 Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx b/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
index ce45356aa28c8..4c2a26da38908 100644
--- a/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
@@ -235,7 +235,7 @@ DataProcessorSpec getCalibratordEdxSpec(const o2::base::Propagator::MatCorrType
     Options{
       {"tf-per-slot", VariantType::UInt32, 6000u, {"number of TFs per calibration time slot, is overwritten by seconds-per-slot if > 0"}},
       {"seconds-per-slot", VariantType::Int, 180, {"seconds per calibration time slot, overwrites tf-per-slot if > 0"}},
-      {"max-delay", VariantType::UInt32, 10u, {"number of slots in past to consider"}},
+      {"max-delay", VariantType::UInt32, 1u, {"number of slots in past to consider"}},
       {"min-entries", VariantType::Int, 10000, {"minimum entries per stack to fit a single time slot"}},
       {"calib-interval-extension", VariantType::UInt32, 3600u, {"seconds by which to extend the calibration interval beyond the end of the time slot"}},
 

From c1576ad6ed9a7eefae5a7a4ea0020e33aa6b8789 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 28 Aug 2025 09:15:08 +0200
Subject: [PATCH 0760/1764] DPL CDDB: hide private implementation of
 CCDBFetrcherHelper

---
 Framework/CCDBSupport/src/CCDBHelpers.cxx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Framework/CCDBSupport/src/CCDBHelpers.cxx b/Framework/CCDBSupport/src/CCDBHelpers.cxx
index 1428e22e86651..acf8b782f8f06 100644
--- a/Framework/CCDBSupport/src/CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/CCDBHelpers.cxx
@@ -28,6 +28,7 @@ O2_DECLARE_DYNAMIC_LOG(ccdb);
 namespace o2::framework
 {
 
+namespace {
 struct CCDBFetcherHelper {
   struct CCDBCacheInfo {
     std::string etag;
@@ -77,6 +78,7 @@ struct CCDBFetcherHelper {
     return apis[entry == remappings.end() ? "" : entry->second];
   }
 };
+}
 
 bool isPrefix(std::string_view prefix, std::string_view full)
 {

From 4d6b61e44d2e47257a41dde559c122891d2e1e85 Mon Sep 17 00:00:00 2001
From: Maurice Coquet <mcoquet@lxplus981.cern.ch>
Date: Wed, 27 Aug 2025 14:11:50 +0200
Subject: [PATCH 0761/1764] Fix DCS object sspec for MFT noise calibration

---
 .../ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx    | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
index 29cdb09692f4e..86107106dc2ba 100644
--- a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
@@ -378,8 +378,8 @@ void NoiseCalibratorSpec::sendOutputDcs(DataAllocator& output)
             << " : " << infoDcs.getEndValidityTimestamp();
 
   using clbUtilsDcs = o2::calibration::Utils;
-  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 0}, *imageDcs.get());
-  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 0}, infoDcs);
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 1}, *imageDcs.get());
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 1}, infoDcs);
 }
 
 void NoiseCalibratorSpec::sendOutputDcsMerge(DataAllocator& output)
@@ -447,8 +447,8 @@ void NoiseCalibratorSpec::sendOutputDcsMerge(DataAllocator& output)
             << " : " << infoDcs.getEndValidityTimestamp();
 
   using clbUtilsDcs = o2::calibration::Utils;
-  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 0}, *imageDcs.get());
-  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 0}, infoDcs);
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBPayload, "MFT_NoiseMap", 1}, *imageDcs.get());
+  output.snapshot(Output{clbUtilsDcs::gDataOriginCDBWrapper, "MFT_NoiseMap", 1}, infoDcs);
 }
 
 void NoiseCalibratorSpec::endOfStream(o2::framework::EndOfStreamContext& ec)

From e962d83a5a0cad122947c9dbc8981744d21acf57 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 27 Aug 2025 13:26:49 +0200
Subject: [PATCH 0762/1764] DPL Analysis: percolate DataOrigin so that we can
 use it for multiple files reading.

---
 .../AnalysisSupport/src/DataInputDirector.cxx | 38 ++++++++++++-------
 .../AnalysisSupport/src/DataInputDirector.h   |  8 ++--
 .../Framework/AnalysisSupportHelpers.h        |  4 +-
 .../Core/src/AnalysisDataModelHelpers.cxx     | 10 +++--
 .../TestWorkflows/src/o2TestHistograms.cxx    |  5 ++-
 5 files changed, 41 insertions(+), 24 deletions(-)

diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index 590329de146f7..7cc0134a27968 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -124,15 +124,22 @@ void DataInputDescriptor::addFileNameHolder(FileNameHolder* fn)
   mfilenames.emplace_back(fn);
 }
 
-bool DataInputDescriptor::setFile(int counter)
+bool DataInputDescriptor::setFile(int counter, std::string_view origin)
 {
   // no files left
   if (counter >= getNumberInputfiles()) {
     return false;
   }
 
+  // In case the origin starts with a anything but AOD, we add the origin as the suffix
+  // of the filename. In the future we might expand this for proper rewriting of the
+  // filename based on the origin and the original file information.
+  std::string filename = mfilenames[counter]->fileName;
+  if (!origin.starts_with("AOD")) {
+    filename = std::regex_replace(filename, std::regex("[.]root$"), fmt::format("_{}.root", origin));
+  }
+
   // open file
-  auto filename = mfilenames[counter]->fileName;
   auto rootFS = std::dynamic_pointer_cast<TFileFileSystem>(mCurrentFilesystem);
   if (rootFS.get()) {
     if (rootFS->GetFile()->GetName() == filename) {
@@ -213,11 +220,11 @@ bool DataInputDescriptor::setFile(int counter)
   return true;
 }
 
-uint64_t DataInputDescriptor::getTimeFrameNumber(int counter, int numTF)
+uint64_t DataInputDescriptor::getTimeFrameNumber(int counter, int numTF, std::string_view origin)
 {
 
   // open file
-  if (!setFile(counter)) {
+  if (!setFile(counter, origin)) {
     return 0ul;
   }
 
@@ -229,10 +236,10 @@ uint64_t DataInputDescriptor::getTimeFrameNumber(int counter, int numTF)
   return (mfilenames[counter]->listOfTimeFrameNumbers)[numTF];
 }
 
-arrow::dataset::FileSource DataInputDescriptor::getFileFolder(int counter, int numTF)
+arrow::dataset::FileSource DataInputDescriptor::getFileFolder(int counter, int numTF, std::string_view origin)
 {
   // open file
-  if (!setFile(counter)) {
+  if (!setFile(counter, origin)) {
     return {};
   }
 
@@ -246,7 +253,7 @@ arrow::dataset::FileSource DataInputDescriptor::getFileFolder(int counter, int n
   return {fmt::format("DF_{}", mfilenames[counter]->listOfTimeFrameNumbers[numTF]), mCurrentFilesystem};
 }
 
-DataInputDescriptor* DataInputDescriptor::getParentFile(int counter, int numTF, std::string treename)
+DataInputDescriptor* DataInputDescriptor::getParentFile(int counter, int numTF, std::string treename, std::string_view origin)
 {
   if (!mParentFileMap) {
     // This file has no parent map
@@ -283,7 +290,7 @@ DataInputDescriptor* DataInputDescriptor::getParentFile(int counter, int numTF,
   mParentFile->mdefaultFilenamesPtr = new std::vector<FileNameHolder*>;
   mParentFile->mdefaultFilenamesPtr->emplace_back(makeFileNameHolder(parentFileName->GetString().Data()));
   mParentFile->fillInputfiles();
-  mParentFile->setFile(0);
+  mParentFile->setFile(0, origin);
   return mParentFile;
 }
 
@@ -427,7 +434,8 @@ struct CalculateDelta {
     mTarget += (uv_hrtime() - start);
   }
 
-  void deactivate() {
+  void deactivate()
+  {
     active = false;
   }
 
@@ -440,7 +448,8 @@ struct CalculateDelta {
 bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh, int counter, int numTF, std::string treename, size_t& totalSizeCompressed, size_t& totalSizeUncompressed)
 {
   CalculateDelta t(mIOTime);
-  auto folder = getFileFolder(counter, numTF);
+  std::string origin = dh.dataOrigin.as<std::string>();
+  auto folder = getFileFolder(counter, numTF, origin);
   if (!folder.filesystem()) {
     t.deactivate();
     return false;
@@ -473,7 +482,7 @@ bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh
   if (!format) {
     t.deactivate();
     LOGP(debug, "Could not find tree {}. Trying in parent file.", fullpath.path());
-    auto parentFile = getParentFile(counter, numTF, treename);
+    auto parentFile = getParentFile(counter, numTF, treename, origin);
     if (parentFile != nullptr) {
       int parentNumTF = parentFile->findDFNumber(0, folder.path());
       if (parentNumTF == -1) {
@@ -817,8 +826,9 @@ arrow::dataset::FileSource DataInputDirector::getFileFolder(header::DataHeader d
   if (!didesc) {
     didesc = mdefaultDataInputDescriptor;
   }
+  std::string origin = dh.dataOrigin.as<std::string>();
 
-  return didesc->getFileFolder(counter, numTF);
+  return didesc->getFileFolder(counter, numTF, origin);
 }
 
 int DataInputDirector::getTimeFramesInFile(header::DataHeader dh, int counter)
@@ -839,8 +849,9 @@ uint64_t DataInputDirector::getTimeFrameNumber(header::DataHeader dh, int counte
   if (!didesc) {
     didesc = mdefaultDataInputDescriptor;
   }
+  std::string origin = dh.dataOrigin.as<std::string>();
 
-  return didesc->getTimeFrameNumber(counter, numTF);
+  return didesc->getTimeFrameNumber(counter, numTF, origin);
 }
 
 bool DataInputDirector::readTree(DataAllocator& outputs, header::DataHeader dh, int counter, int numTF, size_t& totalSizeCompressed, size_t& totalSizeUncompressed)
@@ -858,6 +869,7 @@ bool DataInputDirector::readTree(DataAllocator& outputs, header::DataHeader dh,
     didesc = mdefaultDataInputDescriptor;
     treename = aod::datamodel::getTreeName(dh);
   }
+  std::string origin = dh.dataOrigin.as<std::string>();
 
   auto result = didesc->readTree(outputs, dh, counter, numTF, treename, totalSizeCompressed, totalSizeUncompressed);
   return result;
diff --git a/Framework/AnalysisSupport/src/DataInputDirector.h b/Framework/AnalysisSupport/src/DataInputDirector.h
index 94bdcf2c9368e..61b477bd8522d 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.h
+++ b/Framework/AnalysisSupport/src/DataInputDirector.h
@@ -64,7 +64,7 @@ class DataInputDescriptor
 
   void addFileNameHolder(FileNameHolder* fn);
   int fillInputfiles();
-  bool setFile(int counter);
+  bool setFile(int counter, std::string_view origin);
 
   // getters
   std::string getInputfilesFilename();
@@ -74,9 +74,9 @@ class DataInputDescriptor
   int getNumberTimeFrames() { return mtotalNumberTimeFrames; }
   int findDFNumber(int file, std::string dfName);
 
-  uint64_t getTimeFrameNumber(int counter, int numTF);
-  arrow::dataset::FileSource getFileFolder(int counter, int numTF);
-  DataInputDescriptor* getParentFile(int counter, int numTF, std::string treename);
+  uint64_t getTimeFrameNumber(int counter, int numTF, std::string_view origin);
+  arrow::dataset::FileSource getFileFolder(int counter, int numTF, std::string_view origin);
+  DataInputDescriptor* getParentFile(int counter, int numTF, std::string treename, std::string_view origin);
   int getTimeFramesInFile(int counter);
   int getReadTimeFramesInFile(int counter);
 
diff --git a/Framework/Core/include/Framework/AnalysisSupportHelpers.h b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
index a4e80decf2bbe..cc4d45a46c8bc 100644
--- a/Framework/Core/include/Framework/AnalysisSupportHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
@@ -20,8 +20,8 @@
 
 namespace o2::framework
 {
-static constexpr std::array<header::DataOrigin, 3> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}};
-static constexpr std::array<header::DataOrigin, 5> extendedAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"DYN"}, header::DataOrigin{"AMD"}};
+static constexpr std::array<header::DataOrigin, 4> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
+static constexpr std::array<header::DataOrigin, 6> extendedAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"DYN"}, header::DataOrigin{"AMD"}, header::DataOrigin{"EMB"}};
 static constexpr std::array<header::DataOrigin, 4> writableAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"DYN"}};
 
 class DataOutputDirector;
diff --git a/Framework/Core/src/AnalysisDataModelHelpers.cxx b/Framework/Core/src/AnalysisDataModelHelpers.cxx
index bfc53c8972e2c..b7b459c89d847 100644
--- a/Framework/Core/src/AnalysisDataModelHelpers.cxx
+++ b/Framework/Core/src/AnalysisDataModelHelpers.cxx
@@ -11,6 +11,7 @@
 
 #include "Framework/AnalysisDataModelHelpers.h"
 #include "Framework/AnalysisDataModel.h"
+#include "Framework/AnalysisSupportHelpers.h"
 #include "Framework/StringHelpers.h"
 #include "Framework/Logger.h"
 
@@ -27,7 +28,6 @@ namespace o2::aod::datamodel
 std::string getTreeName(header::DataHeader dh)
 {
   auto description = std::string(dh.dataDescription.str);
-  auto origin = std::string(dh.dataOrigin.str);
   auto iver = (float)dh.subSpecification;
 
   // lower case of first part of description
@@ -38,11 +38,15 @@ std::string getTreeName(header::DataHeader dh)
   }
 
   // add prefix according to origin
-  if (origin == "AOD") {
-    treeName = "O2" + treeName;
+  for (auto possibleOrigin : framework::AODOrigins) {
+    if (dh.dataOrigin == possibleOrigin) {
+      treeName = "O2" + treeName;
+      break;
+    }
   }
 
   // exceptions from this
+  auto origin = std::string(dh.dataOrigin.str);
   if (origin == "AOD" && description == "MCCOLLISLABEL") {
     treeName = "O2mccollisionlabel";
   }
diff --git a/Framework/TestWorkflows/src/o2TestHistograms.cxx b/Framework/TestWorkflows/src/o2TestHistograms.cxx
index 38cfc00b6df7c..61710e1f63d5f 100644
--- a/Framework/TestWorkflows/src/o2TestHistograms.cxx
+++ b/Framework/TestWorkflows/src/o2TestHistograms.cxx
@@ -25,6 +25,7 @@ using namespace o2::framework::expressions;
 
 namespace o2::aod
 {
+O2ORIGIN("EMB");
 namespace skimmedExampleTrack
 {
 DECLARE_SOA_COLUMN(Pt, pt, float);   //!
@@ -49,7 +50,7 @@ struct EtaAndClsHistogramsSimple {
     }
   }
 
-  void process(soa::Filtered<aod::Tracks> const& tracks, aod::FT0s const&)
+  void process(soa::Filtered<aod::Tracks> const& tracks, aod::FT0s const&, aod::StoredTracksFrom<o2::aod::Hash<"EMB"_h>> const& ortherTracks)
   {
     LOGP(info, "Invoking the simple one");
     for (auto& track : tracks) {
@@ -72,7 +73,7 @@ struct EtaAndClsHistogramsIUSimple {
     }
   }
 
-  void process(soa::Filtered<aod::TracksIU> const& tracks, aod::FT0s const&)
+  void process(soa::Filtered<aod::TracksIU> const& tracks, aod::FT0s const&, aod::TracksIUFrom<o2::aod::Hash<"EMB"_h>> const& otherTracks)
   {
     LOGP(info, "Invoking the simple one IU");
     for (auto& track : tracks) {

From bd41c6a7a2c3aa6f1074cfc19cbe2d63bf175b27 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <nicolo.jacazio@cern.ch>
Date: Mon, 25 Aug 2025 15:41:35 +0200
Subject: [PATCH 0763/1764] Add missing includes

---
 Detectors/CTF/test/test_ctf_io_cpv.cxx                      | 1 +
 Detectors/ITSMFT/ITS/postprocessing/studies/src/Helpers.cxx | 1 +
 Detectors/TPC/spacecharge/src/DataContainer3D.cxx           | 2 ++
 GPU/GPUTracking/qa/genEvents.h                              | 1 +
 4 files changed, 5 insertions(+)

diff --git a/Detectors/CTF/test/test_ctf_io_cpv.cxx b/Detectors/CTF/test/test_ctf_io_cpv.cxx
index e4b91569d1df3..34a383a6875a0 100644
--- a/Detectors/CTF/test/test_ctf_io_cpv.cxx
+++ b/Detectors/CTF/test/test_ctf_io_cpv.cxx
@@ -28,6 +28,7 @@
 #include <TRandom.h>
 #include <TStopwatch.h>
 #include <TSystem.h>
+#include <TMath.h>
 #include <cstring>
 
 using namespace o2::cpv;
diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/Helpers.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/Helpers.cxx
index 70b9bfb64dfd5..a5b3495047934 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/Helpers.cxx
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/Helpers.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include <cassert>
+#include <cmath>
 
 // o2 includes
 #include "ITSStudies/Helpers.h"
diff --git a/Detectors/TPC/spacecharge/src/DataContainer3D.cxx b/Detectors/TPC/spacecharge/src/DataContainer3D.cxx
index c9a39e940873d..cd2802b975fd2 100644
--- a/Detectors/TPC/spacecharge/src/DataContainer3D.cxx
+++ b/Detectors/TPC/spacecharge/src/DataContainer3D.cxx
@@ -17,6 +17,8 @@
 #include "Framework/Logger.h"
 #include "TFile.h"
 #include "ROOT/RDataFrame.hxx"
+#include "TStopwatch.h"
+#include "TTree.h"
 
 #include <memory>
 #include <iomanip>
diff --git a/GPU/GPUTracking/qa/genEvents.h b/GPU/GPUTracking/qa/genEvents.h
index abf1742b48e88..ee5510c729525 100644
--- a/GPU/GPUTracking/qa/genEvents.h
+++ b/GPU/GPUTracking/qa/genEvents.h
@@ -16,6 +16,7 @@
 #define GENEVENTS_H
 
 #include "GPUCommonDef.h"
+#include <cmath>
 
 namespace o2::gpu
 {

From a4c0d4fde66ef10fce9d8178135760b48d956197 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 11:02:57 +0200
Subject: [PATCH 0764/1764] Fix codechecker error

---
 Detectors/TOF/workflow/src/make-parameter-collection.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/TOF/workflow/src/make-parameter-collection.cxx b/Detectors/TOF/workflow/src/make-parameter-collection.cxx
index 3a210df3fcad8..c90f417639212 100644
--- a/Detectors/TOF/workflow/src/make-parameter-collection.cxx
+++ b/Detectors/TOF/workflow/src/make-parameter-collection.cxx
@@ -63,7 +63,7 @@ class ParamExample : public Parameters<5>
  public:
   ParamExample() : Parameters(std::array<std::string, 5>{"p0", "p1", "p2", "p3", "p4"},
                               "ParamExample") { setParameters(std::array<paramvar_t, 5>{0, 1, 2, 3, 4}); }; // Default constructor with default parameters
-  ~ParamExample() = default;
+  ~ParamExample() override = default;
 };
 
 int main(int argc, char* argv[])

From aee6ae723640cc92580133ed4cd0dc1f32217278 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <nicolo.jacazio@cern.ch>
Date: Mon, 25 Aug 2025 15:34:11 +0200
Subject: [PATCH 0765/1764] Add includes

---
 Detectors/PHOS/reconstruction/src/CaloRawFitter.cxx   | 1 +
 Detectors/PHOS/reconstruction/src/CaloRawFitterGS.cxx | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/Detectors/PHOS/reconstruction/src/CaloRawFitter.cxx b/Detectors/PHOS/reconstruction/src/CaloRawFitter.cxx
index 37ba3ecae7159..aa929f8d6c6e5 100644
--- a/Detectors/PHOS/reconstruction/src/CaloRawFitter.cxx
+++ b/Detectors/PHOS/reconstruction/src/CaloRawFitter.cxx
@@ -13,6 +13,7 @@
 /// \author Dmitri Peresunko
 
 #include <gsl/span>
+#include <cmath>
 
 #include "PHOSReconstruction/CaloRawFitter.h"
 #include "PHOSBase/PHOSSimParams.h"
diff --git a/Detectors/PHOS/reconstruction/src/CaloRawFitterGS.cxx b/Detectors/PHOS/reconstruction/src/CaloRawFitterGS.cxx
index 08c1f7fb14bc1..3ea506cf203aa 100644
--- a/Detectors/PHOS/reconstruction/src/CaloRawFitterGS.cxx
+++ b/Detectors/PHOS/reconstruction/src/CaloRawFitterGS.cxx
@@ -13,6 +13,8 @@
 /// \author Dmitri Peresunko
 
 #include <gsl/span>
+#include <cmath>
+#include <TMath.h>
 
 #include "PHOSReconstruction/CaloRawFitterGS.h"
 #include "PHOSBase/PHOSSimParams.h"

From ac05dee924defedcc070ea36fa78c79001d70680 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Fri, 29 Aug 2025 15:44:04 +0200
Subject: [PATCH 0766/1764] DPL: print error when exit transition timer expires

---
 Framework/Core/src/DataProcessingDevice.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index a902ed9326e07..859a48955a8f5 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -138,10 +138,10 @@ void on_transition_requested_expired(uv_timer_t* handle)
   O2_SIGNPOST_ID_FROM_POINTER(cid, device, handle);
   auto& spec = ref->get<DeviceSpec const>();
   if (hasOnlyGenerated(spec)) {
-    O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for source expired. Exiting.");
+    O2_SIGNPOST_EVENT_EMIT_ERROR(calibration, cid, "callback", "DPL exit transition grace period for source expired. Exiting.");
   } else {
-    O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for %{public}s expired. Exiting.",
-                                state.allowedProcessing == DeviceState::CalibrationOnly ? "calibration" : "data & calibration");
+    O2_SIGNPOST_EVENT_EMIT_ERROR(calibration, cid, "callback", "DPL exit transition grace period for %{public}s expired. Exiting.",
+                                 state.allowedProcessing == DeviceState::CalibrationOnly ? "calibration" : "data & calibration");
   }
   state.transitionHandling = TransitionHandlingState::Expired;
 }

From 3db6ccad1999805d64a90fd6a356065d6171960e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 18:30:18 +0200
Subject: [PATCH 0767/1764] GPU Workflow: Pop next tf from completion policy
 queue only when actually running and add sanity checks

---
 .../Global/GPUChainTrackingClusterizer.cxx         |  3 +++
 GPU/Workflow/src/GPUWorkflowPipeline.cxx           | 14 +++++++++-----
 2 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 846df352d3a34..c92049b040c46 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -751,6 +751,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   if (buildNativeGPU) {
     AllocateRegisteredMemory(mInputsHost->mResourceClusterNativeBuffer);
   }
+  if (mWaitForFinalInputs && GetProcessingSettings().nTPCClustererLanes > 6) {
+    GPUFatal("ERROR, mWaitForFinalInputs cannot be called with nTPCClustererLanes > 6");
+  }
   if (buildNativeHost && !(buildNativeGPU && GetProcessingSettings().delayedOutput)) {
     if (mWaitForFinalInputs) {
       GPUFatal("Cannot use waitForFinalInput callback without delayed output");
diff --git a/GPU/Workflow/src/GPUWorkflowPipeline.cxx b/GPU/Workflow/src/GPUWorkflowPipeline.cxx
index a09fdac988d1a..8867b6c336f97 100644
--- a/GPU/Workflow/src/GPUWorkflowPipeline.cxx
+++ b/GPU/Workflow/src/GPUWorkflowPipeline.cxx
@@ -66,11 +66,7 @@ void GPURecoWorkflowSpec::initPipeline(o2::framework::InitContext& ic)
     mPolicyOrder = [this](o2::framework::DataProcessingHeader::StartTime timeslice) {
       std::unique_lock lk(mPipeline->completionPolicyMutex);
       mPipeline->completionPolicyNotify.wait(lk, [pipeline = mPipeline.get()] { return pipeline->pipelineSenderTerminating || !pipeline->completionPolicyQueue.empty(); });
-      if (mPipeline->completionPolicyQueue.front() == timeslice) {
-        mPipeline->completionPolicyQueue.pop();
-        return true;
-      }
-      return false;
+      return !mPipeline->completionPolicyQueue.empty() && mPipeline->completionPolicyQueue.front() == timeslice;
     };
     mPipeline->receiveThread = std::thread([this]() { RunReceiveThread(); });
     for (uint32_t i = 0; i < mPipeline->workers.size(); i++) {
@@ -175,6 +171,14 @@ int32_t GPURecoWorkflowSpec::handlePipeline(ProcessingContext& pc, GPUTrackingIn
     tpcZSmeta = std::move(context->tpcZSmeta);
     tpcZS = context->tpcZS;
     ptrs.tpcZS = &tpcZS;
+
+    {
+      std::lock_guard lk(mPipeline->completionPolicyMutex);
+      if (mPipeline->completionPolicyQueue.empty() || mPipeline->completionPolicyQueue.front() != tinfo.timeslice) {
+        LOG(fatal) << "Time frame processed does not equal the timeframe at the top of the queue, time frames seem out of sync";
+      }
+      mPipeline->completionPolicyQueue.pop();
+    }
   }
   if (mSpecConfig.enableDoublePipeline == 2) {
     auto prepareDummyMessage = pc.outputs().make<DataAllocator::UninitializedVector<char>>(Output{gDataOriginGPU, "PIPELINEPREPARE", 0}, 0u);

From 6fd377b7e1587f2dfcf93a32d0f5dacb729e8e64 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 29 Aug 2025 14:05:56 +0200
Subject: [PATCH 0768/1764] DPL: initial metric to debug size of the histograms
 / objects being written

I am not sure this is exactly what we want, but it should be good enough for now.
---
 Framework/AnalysisSupport/src/AODWriterHelpers.cxx | 13 +++++++++++--
 Framework/Core/src/runDataProcessing.cxx           |  1 +
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index 40d2189ea96d0..475e65bf9212b 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -21,7 +21,9 @@
 #include "Framework/TableConsumer.h"
 #include "Framework/DataOutputDirector.h"
 #include "Framework/TableTreeHelpers.h"
+#include "Framework/Monitoring.h"
 
+#include <Monitoring/Monitoring.h>
 #include <TFile.h>
 #include <TFile.h>
 #include <TTree.h>
@@ -235,6 +237,7 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
 
 AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 {
+  using namespace monitoring;
   auto& ac = ctx.services().get<AnalysisContext>();
   auto tskmap = ac.outTskMap;
   auto objmap = ac.outObjHistMap;
@@ -269,7 +272,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 
     callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
     return [inputObjects, objmap, tskmap](ProcessingContext& pc) mutable -> void {
-      auto mergePart = [&inputObjects, &objmap, &tskmap](DataRef const& ref) {
+      auto mergePart = [&inputObjects, &objmap, &tskmap, &pc](DataRef const& ref) {
         if (!ref.header) {
           LOG(error) << "Header not found";
           return;
@@ -381,7 +384,13 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
             if (object->InheritsFrom(TList::Class())) {
               writeListToFile(static_cast<TList*>(object), parentDir->mkdir(object->GetName(), object->GetName(), true));
             } else {
-              parentDir->WriteObjectAny(object, object->Class(), object->GetName());
+              int objSize = parentDir->WriteObjectAny(object, object->Class(), object->GetName());
+              static int maxSizeWritten = 0;
+              if (objSize > maxSizeWritten) {
+                auto& monitoring = pc.services().get<Monitoring>();
+                maxSizeWritten = objSize;
+                monitoring.send(Metric{fmt::format("{}/{}:{}", object->ClassName(), object->GetName(), objSize), "aod-largest-object-written"}.addTag(tags::Key::Subsystem, tags::Value::DPL));
+              }
               auto* written = list->Remove(object);
               delete written;
             }
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 59bacc67fef31..5fe4792daa32a 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1233,6 +1233,7 @@ std::vector<std::regex> getDumpableMetrics()
   dumpableMetrics.emplace_back("^aod-bytes-read-uncompressed$");
   dumpableMetrics.emplace_back("^aod-bytes-read-compressed$");
   dumpableMetrics.emplace_back("^aod-file-read-info$");
+  dumpableMetrics.emplace_back("^aod-largest-object-written$");
   dumpableMetrics.emplace_back("^table-bytes-.*");
   dumpableMetrics.emplace_back("^total-timeframes.*");
   dumpableMetrics.emplace_back("^device_state.*");

From 057426487bdb48dfe045ec5ca6d6e39cd384ce24 Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Sat, 30 Aug 2025 21:52:35 +0200
Subject: [PATCH 0769/1764] DPL: change exit transition timeout default on FLPs
 to 40 s (#14638)

---
 Framework/Core/src/O2ControlHelpers.cxx                   | 2 +-
 Framework/Core/src/runDataProcessing.cxx                  | 2 +-
 Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx | 8 ++++----
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Framework/Core/src/O2ControlHelpers.cxx b/Framework/Core/src/O2ControlHelpers.cxx
index 273950e5047f0..c8027c20234b8 100644
--- a/Framework/Core/src/O2ControlHelpers.cxx
+++ b/Framework/Core/src/O2ControlHelpers.cxx
@@ -369,7 +369,7 @@ void dumpTask(std::ostream& dumpOut, const DeviceSpec& spec, const DeviceExecuti
   dumpOut << indLevel << "defaults:\n";
   dumpOut << indLevel << indScheme << "log_task_stdout: none\n";
   dumpOut << indLevel << indScheme << "log_task_stderr: none\n";
-  std::string exitTransitionTimeout = "25"; // Allow 25 seconds to finish processing and calibrations
+  std::string exitTransitionTimeout = "40"; // Allow 40 seconds to finish processing and calibrations
   std::string dataProcessingTimeout = "20"; // Allow only 20 seconds to finish processing
   if (execution.args.size() > 2) {
     for (size_t i = 0; i < execution.args.size() - 1; ++i) {
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 5fe4792daa32a..a343637080da1 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1038,7 +1038,7 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
       defaultDataProcessingTimeout = "20";
       defaultInfologgerMode = "infoLoggerD";
     } else if (deploymentMode == o2::framework::DeploymentMode::OnlineECS) {
-      defaultExitTransitionTimeout = "25";
+      defaultExitTransitionTimeout = "40";
       defaultDataProcessingTimeout = "20";
     }
     boost::program_options::options_description optsDesc;
diff --git a/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx b/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
index 32dd0b5922a4f..abf6d64a7ca1e 100644
--- a/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
+++ b/Framework/Core/test/test_FrameworkDataFlowToO2Control.cxx
@@ -138,7 +138,7 @@ const std::vector expectedTasks{
 defaults:
   log_task_stdout: none
   log_task_stderr: none
-  exit_transition_timeout: 25
+  exit_transition_timeout: 40
   data_processing_timeout: 20
   _module_cmdline: >-
     source /etc/profile.d/modules.sh && MODULEPATH={{ modulepath }} module load O2 QualityControl Control-OCCPlugin &&
@@ -236,7 +236,7 @@ const std::vector expectedTasks{
 defaults:
   log_task_stdout: none
   log_task_stderr: none
-  exit_transition_timeout: 25
+  exit_transition_timeout: 40
   data_processing_timeout: 20
   _module_cmdline: >-
     source /etc/profile.d/modules.sh && MODULEPATH={{ modulepath }} module load O2 QualityControl Control-OCCPlugin &&
@@ -336,7 +336,7 @@ const std::vector expectedTasks{
 defaults:
   log_task_stdout: none
   log_task_stderr: none
-  exit_transition_timeout: 25
+  exit_transition_timeout: 40
   data_processing_timeout: 20
   _module_cmdline: >-
     source /etc/profile.d/modules.sh && MODULEPATH={{ modulepath }} module load O2 QualityControl Control-OCCPlugin &&
@@ -436,7 +436,7 @@ const std::vector expectedTasks{
 defaults:
   log_task_stdout: none
   log_task_stderr: none
-  exit_transition_timeout: 25
+  exit_transition_timeout: 40
   data_processing_timeout: 20
   _module_cmdline: >-
     source /etc/profile.d/modules.sh && MODULEPATH={{ modulepath }} module load O2 QualityControl Control-OCCPlugin &&

From ef0de0f9e27a945b042ccd10990645a23cf24e21 Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Sat, 30 Aug 2025 21:54:55 +0200
Subject: [PATCH 0770/1764] DPL: fix for printing O2_SIGNPOST_END without start
 interval (#14637)

---
 .../Foundation/include/Framework/Signpost.h    | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/Framework/Foundation/include/Framework/Signpost.h b/Framework/Foundation/include/Framework/Signpost.h
index 0ea0a1f5ec75b..7ed544c529303 100644
--- a/Framework/Foundation/include/Framework/Signpost.h
+++ b/Framework/Foundation/include/Framework/Signpost.h
@@ -246,6 +246,7 @@ inline _o2_signpost_id_t _o2_signpost_id_make_with_pointer(_o2_log_t* log, void
 #include <execinfo.h>
 #include "Framework/RuntimeError.h"
 #include "Framework/BacktraceHelpers.h"
+void _o2_signpost_event_emit_v(_o2_log_t* log, _o2_signpost_id_t id, char const* name, char const* const format, va_list args);
 void _o2_signpost_interval_end_v(_o2_log_t* log, _o2_signpost_id_t id, char const* name, char const* const format, va_list args);
 
 // returns true if the push was successful, false if the stack was full
@@ -358,11 +359,8 @@ void* _o2_log_create(char const* name, int defaultStacktrace)
 
 // This will look at the slot in the log associated to the ID.
 // If the slot is empty, it will return the id and increment the indentation level.
-void _o2_signpost_event_emit(_o2_log_t* log, _o2_signpost_id_t id, char const* name, char const* const format, ...)
+void _o2_signpost_event_emit_v(_o2_log_t* log, _o2_signpost_id_t id, char const* name, char const* const format, va_list args)
 {
-  va_list args;
-  va_start(args, format);
-
   // Find the index of the activity
   int leading = 0;
 
@@ -386,7 +384,6 @@ void _o2_signpost_event_emit(_o2_log_t* log, _o2_signpost_id_t id, char const* n
   char prebuffer[4096];
   int s = snprintf(prebuffer, 4096, "id%.16" PRIx64 ":%-16s*>%*c", id.value, name, leading, ' ');
   vsnprintf(prebuffer + s, 4096 - s, format, args);
-  va_end(args);
   O2_LOG_MACRO("%s", prebuffer);
   if (log->stacktrace > 1) {
     void* traces[o2::framework::BacktraceHelpers::MAX_BACKTRACE_SIZE];
@@ -396,6 +393,15 @@ void _o2_signpost_event_emit(_o2_log_t* log, _o2_signpost_id_t id, char const* n
   }
 }
 
+// We separate this so that we can still emit the end signpost when the log is not enabled.
+void _o2_signpost_event_emit(_o2_log_t* log, _o2_signpost_id_t id, char const* name, char const* const format, ...)
+{
+  va_list args;
+  va_start(args, format);
+  _o2_signpost_event_emit_v(log, id, name, format, args);
+  va_end(args);
+}
+
 // This will look at the slot in the log associated to the ID.
 // If the slot is empty, it will return the id and increment the indentation level.
 void _o2_signpost_interval_begin(_o2_log_t* log, _o2_signpost_id_t id, char const* name, char const* const format, ...)
@@ -434,7 +440,7 @@ void _o2_signpost_interval_end_v(_o2_log_t* log, _o2_signpost_id_t id, char cons
   // We should not make this an error because one could have enabled the log after the interval
   // was started.
   if (i == log->ids.size()) {
-    _o2_signpost_event_emit(log, id, name, format, args);
+    _o2_signpost_event_emit_v(log, id, name, format, args);
     return;
   }
   // i is the slot index

From dbd2625ae505bd59226dc4865269384fdfbb8050 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 29 Aug 2025 18:08:48 +0200
Subject: [PATCH 0771/1764] Add to trackdata in residuals TOF time difference
 and t0 error

TrackData got extra data member deltaTOF, which provides the difference between
the measered and expected time-of-flight in ps: timeTOF - t0 - tof_integral(track_PID)
if the the tracks was matched to TOF (0 otherwhise).
The meaning of the clAvailTOF data member is changed: as before, 0 means no TOF match,
otherwhise the value of the uncertainty on the interaction t0 is stored in ps (200 means
that the nominal BC compatible with the TOF time was assumed).
---
 .../include/SpacePoints/TrackInterpolation.h        |  9 +++++++--
 .../SpacePoints/src/TrackInterpolation.cxx          | 13 +++++++++++--
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
index 9f7c6d0fc8fbc..3b9e4021f443a 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
@@ -140,14 +140,19 @@ struct TrackData {
   float chi2TPC{};                           ///< chi2 of TPC track
   float chi2ITS{};                           ///< chi2 of ITS track
   float chi2TRD{};                           ///< chi2 of TRD track
+  float deltaTOF{};                          ///< TOFsignal - T0 - texp(PID), if T0 is available
 
   unsigned short nClsTPC{};                  ///< number of attached TPC clusters
   unsigned short nClsITS{};                  ///< number of attached ITS clusters
   unsigned short nTrkltsTRD{};               ///< number of attached TRD tracklets
-  unsigned short clAvailTOF{};               ///< whether or not track seed has a matched TOF cluster
+  unsigned short clAvailTOF{};               ///< whether or not track seed has a matched TOF cluster, if so, gives the resolution of the T0 in ps
   uint8_t nExtDetResid = 0;                  ///< number of external detectors (to TPC) residuals stored, on top of clIdx.getEntries
   o2::dataformats::RangeReference<> clIdx{}; ///< index of first cluster residual and total number of TPC cluster residuals of this track
-  ClassDefNV(TrackData, 7);
+
+  float getT0Error() const { return float(clAvailTOF); }
+  bool isTOFAvail() const { return clAvailTOF != 0; }
+
+  ClassDefNV(TrackData, 8);
 };
 
 /// \class TrackInterpolation
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index 1daaa897e9756..00d689326de73 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -620,7 +620,13 @@ void TrackInterpolation::interpolateTrack(int iSeed)
   trackData.nClsTPC = trkTPC.getNClusterReferences();
   trackData.nClsITS = trkITS.getNumberOfClusters();
   trackData.nTrkltsTRD = gidTable[GTrackID::TRD].isIndexSet() ? mRecoCont->getITSTPCTRDTrack<o2::trd::TrackTRD>(gidTable[GTrackID::ITSTPCTRD]).getNtracklets() : 0;
-  trackData.clAvailTOF = gidTable[GTrackID::TOF].isIndexSet() ? 1 : 0;
+  if (gidTable[GTrackID::TOF].isIndexSet()) {
+    const auto& tofMatch = mRecoCont->getTOFMatch(mGIDs[iSeed]);
+    trackData.deltaTOF = tofMatch.getSignal() - tofMatch.getFT0Best() - tofMatch.getLTIntegralOut().getTOF(trkTPC.getPID().getID());
+    trackData.clAvailTOF = uint16_t(tofMatch.getFT0BestRes());
+  } else {
+    trackData.clAvailTOF = 0;
+  }
   trackData.dEdxTPC = trkTPC.getdEdx().dEdxTotTPC;
 
   TrackParams params; // for refitted track parameters and flagging rejected clusters
@@ -933,7 +939,11 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
       }
 
       // do we have TOF residual to add?
+      trackData.clAvailTOF = 0;
       while (gidTableFull[GTrackID::TOF].isIndexSet() && !stopPropagation) {
+        const auto& tofMatch = mRecoCont->getTOFMatch(gidFull);
+        trackData.deltaTOF = tofMatch.getSignal() - tofMatch.getFT0Best() - tofMatch.getLTIntegralOut().getTOF(trkTPC.getPID().getID());
+        trackData.clAvailTOF = uint16_t(tofMatch.getFT0BestRes());
         const auto& clTOF = mRecoCont->getTOFClusters()[gidTableFull[GTrackID::TOF]];
         const float clTOFAlpha = o2::math_utils::sector2Angle(clTOF.getCount());
         float clTOFxyz[3] = {clTOF.getX(), clTOF.getY(), clTOF.getZ()};
@@ -955,7 +965,6 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
         auto dz = clTOFxyz[2] - trkWork.getZ();
         if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
           mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 170, clTOF.getCount(), clTOF.getPadInSector());
-          trackData.clAvailTOF = 1;
           trackData.nExtDetResid++;
         }
         break;

From 17ae0d0a344a8a64cf72f38b491a8c581db0e034 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 31 Aug 2025 17:01:41 +0200
Subject: [PATCH 0772/1764] TOF matching should use the same FT0 int. tag as
 other global workflows

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index e4cd6d3c74cec..8823f009eec8f 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -564,7 +564,7 @@ has_detector_reco FT0 && ! has_detector_from_global_reader FT0 && add_W o2-ft0-r
 has_detector_reco TRD && ! has_detector_from_global_reader TRD && add_W o2-trd-tracklet-transformer "--disable-irframe-reader $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_FILTER_CONFIG --pipeline $(get_N TRDTRACKLETTRANSFORMER TRD REST 1 TRDTRKTRANS)"
 has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $SEND_ITSTPC_DTGL  $TPC_CORR_OPT --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
 has_detector_reco TRD && [[ -n "$TRD_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-global-tracking "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_CONFIG $TRD_FILTER_CONFIG $TPC_CORR_OPT --track-sources $TRD_SOURCES --pipeline $(get_N trd-globaltracking_TPC_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_CTP_ TRD REST 1 TRDTRK)" "$TRD_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
-has_detector_reco TOF && [[ -n "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TPC_CORR_OPT ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
+has_detector_reco TOF && [[ -n "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TPC_CORR_OPT ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY;$INTERACTION_TAG_CONFIG_KEY"
 has_detectors TPC && [[ -z "$DISABLE_ROOT_OUTPUT" && "${SKIP_TPC_CLUSTERSTRACKS_OUTPUT:-}" != 1 ]] && ! has_detector_from_global_reader TPC && add_W o2-tpc-reco-workflow "--input-type pass-through --output-type clusters,tpc-triggers,tracks,send-clusters-per-sector $DISABLE_MC"
 
 # ---------------------------------------------------------------------------------------------------------------------

From 6749a807bb8b4ee0d08ede58d1685e2be128b201 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Tue, 26 Aug 2025 14:33:30 +0200
Subject: [PATCH 0773/1764] dpl-workflow.sh: modifying config/key defaults
 (ITS, MFT, MCH) for synchronous processing

---
 prodtests/full-system-test/aggregator-workflow.sh | 12 +++++-------
 prodtests/full-system-test/dpl-workflow.sh        | 15 +++++++++------
 2 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/prodtests/full-system-test/aggregator-workflow.sh b/prodtests/full-system-test/aggregator-workflow.sh
index bd0c9fea2a31a..f90decefa3f2f 100755
--- a/prodtests/full-system-test/aggregator-workflow.sh
+++ b/prodtests/full-system-test/aggregator-workflow.sh
@@ -243,13 +243,11 @@ if [[ $AGGREGATOR_TASKS == BARREL_TF ]] || [[ $AGGREGATOR_TASKS == ALL ]]; then
      add_W o2-itsmft-deadmap-builder-workflow  "--runmft --ccdb-url $CCDB_POPULATOR_UPLOAD_PATH ${CALIB_MFT_DEADMAP_TIME_OPT:---skip-static-map}"
   fi
   # TOF
-  if [[ $CALIB_TOF_LHCPHASE == 1 ]] || [[ $CALIB_TOF_CHANNELOFFSETS == 1 ]]; then
-    if [[ $CALIB_TOF_LHCPHASE == 1 ]]; then
-      add_W o2-calibration-tof-calib-workflow "--do-lhc-phase --tf-per-slot $LHCPHASE_TF_PER_SLOT --use-ccdb --max-delay 0 " "" 0
-    fi
-    if [[ $CALIB_TOF_CHANNELOFFSETS == 1 ]]; then
-      add_W o2-calibration-tof-calib-workflow "--do-channel-offset --update-interval $TOF_CHANNELOFFSETS_UPDATE --delta-update-interval $TOF_CHANNELOFFSETS_DELTA_UPDATE --min-entries 100 --range 100000 --use-ccdb --condition-tf-per-query 2640 " "" 0
-    fi
+  if [[ $CALIB_TOF_LHCPHASE == 1 ]]; then
+    add_W o2-calibration-tof-calib-workflow "--do-lhc-phase --tf-per-slot $LHCPHASE_TF_PER_SLOT --use-ccdb --max-delay 0 " "" 0
+  fi
+  if [[ $CALIB_TOF_CHANNELOFFSETS == 1 ]]; then
+    add_W o2-calibration-tof-calib-workflow "--do-channel-offset --update-interval $TOF_CHANNELOFFSETS_UPDATE --delta-update-interval $TOF_CHANNELOFFSETS_DELTA_UPDATE --min-entries 100 --range 100000 --use-ccdb --condition-tf-per-query 2640 " "" 0
   fi
   if [[ $CALIB_TOF_DIAGNOSTICS == 1 ]]; then
     add_W o2-calibration-tof-diagnostic-workflow "--tf-per-slot $LHCPHASE_TF_PER_SLOT --max-delay 1" "" 0
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 8823f009eec8f..17a085bf7da96 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -81,7 +81,9 @@ TOF_CONFIG=
 TOF_INPUT=raw
 TOF_OUTPUT=clusters
 ITS_CONFIG_KEY=
+ITS_STF_DEC_CONFIG=
 MFT_CONFIG=
+MFT_STF_DEC_CONFIG=
 MFT_CONFIG_KEY=
 TRD_CONFIG=
 TRD_CONFIG_KEY=
@@ -113,14 +115,15 @@ if [[ $CTFINPUT != 1 ]]; then
 fi
 if [[ $SYNCMODE == 1 ]]; then
   has_detectors_gpu TPC ITS && ITS_CONFIG_KEY+="ITSCATrackerParam.trackingMode=0;" # sets ITS gpu reco to sync
+  ITS_STF_DEC_CONFIG+="ITSClustererParam.maxBCDiffToMaskBias=-1;"
+  MFT_STF_DEC_CONFIG+="MFTClustererParam.maxBCDiffToMaskBias=-1;"
+  [[ $BEAMTYPE == "PbPb" || $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]] && MFT_CONFIG_KEY+="MFTTracking.cutMultClusLow=0;MFTTracking.cutMultClusHigh=4000;"
   if [[ $BEAMTYPE == "PbPb" ]]; then
-    ITS_CONFIG_KEY+="fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:-100};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:-200};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:-20};"
+    ITS_CONFIG_KEY+="fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:-0};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:-400};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:-20};"
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=50000;MCHTracking.maxTrackingDuration=20;"
-    MFT_CONFIG_KEY+="MFTTracking.cutMultClusLow=0;MFTTracking.cutMultClusHigh=20000;"
   elif [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then
     ITS_CONFIG_KEY+="fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:--1};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:--1};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:--1};ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;"
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=20000;MCHTracking.maxTrackingDuration=10;"
-    MFT_CONFIG_KEY+="MFTTracking.cutMultClusLow=0;MFTTracking.cutMultClusHigh=3000;"
   fi
   [[ -n ${CUT_RANDOM_FRACTION_ITS:-} ]] && ITS_CONFIG_KEY+="fastMultConfig.cutRandomFraction=$CUT_RANDOM_FRACTION_ITS;"
   ITS_CONFIG_KEY+="ITSCATrackerParam.trackletsPerClusterLimit=${CUT_TRACKLETSPERCLUSTER_MAX_ITS:--1};ITSCATrackerParam.cellsPerClusterLimit=${CUT_CELLSPERCLUSTER_MAX_ITS:--1};"
@@ -534,12 +537,12 @@ if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
     add_W o2-tpc-raw-to-digits-workflow "--input-spec \"\" --remove-duplicates $RAWTODIGITOPTIONS --pipeline $(get_N tpc-raw-to-digits-0 TPC RAW 1 TPCRAWDEC)"
     add_W o2-tpc-reco-workflow "--input-type digitizer --output-type zsraw,disable-writer --pipeline $(get_N tpc-zsEncoder TPC RAW 1 TPCRAWDEC)" "GPU_rec_tpc.zsThreshold=0"
   fi
-  has_detector ITS && ! has_detector_from_global_reader ITS && add_W o2-itsmft-stf-decoder-workflow "--nthreads ${NITSDECTHREADS} --raw-data-dumps $ALPIDE_ERR_DUMPS --pipeline $(get_N its-stf-decoder ITS RAW 1 ITSRAWDEC)" "$ITSMFT_STROBES;VerbosityConfig.rawParserSeverity=warn;"
-  has_detector MFT && ! has_detector_from_global_reader MFT && add_W o2-itsmft-stf-decoder-workflow "--nthreads ${NMFTDECTHREADS} --raw-data-dumps $ALPIDE_ERR_DUMPS --pipeline $(get_N mft-stf-decoder MFT RAW 1 MFTRAWDEC) --runmft true" "$ITSMFT_STROBES;VerbosityConfig.rawParserSeverity=warn;"
+  has_detector ITS && ! has_detector_from_global_reader ITS && add_W o2-itsmft-stf-decoder-workflow "--nthreads ${NITSDECTHREADS} --raw-data-dumps $ALPIDE_ERR_DUMPS --pipeline $(get_N its-stf-decoder ITS RAW 1 ITSRAWDEC)" "$ITS_STF_DEC_CONFIG;$ITSMFT_STROBES;VerbosityConfig.rawParserSeverity=warn;"
+  has_detector MFT && ! has_detector_from_global_reader MFT && add_W o2-itsmft-stf-decoder-workflow "--nthreads ${NMFTDECTHREADS} --raw-data-dumps $ALPIDE_ERR_DUMPS --pipeline $(get_N mft-stf-decoder MFT RAW 1 MFTRAWDEC) --runmft true" "$MFT_STF_DEC_CONFIG;$ITSMFT_STROBES;VerbosityConfig.rawParserSeverity=warn;"
   has_detector FT0 && ! has_detector_from_global_reader FT0 && ! has_detector_flp_processing FT0 && add_W o2-ft0-flp-dpl-workflow "$DISABLE_ROOT_OUTPUT --pipeline $(get_N ft0-datareader-dpl FT0 RAW 1)"
   has_detector FV0 && ! has_detector_from_global_reader FV0 && ! has_detector_flp_processing FV0 && add_W o2-fv0-flp-dpl-workflow "$DISABLE_ROOT_OUTPUT --pipeline $(get_N fv0-datareader-dpl FV0 RAW 1)"
   has_detector MID && ! has_detector_from_global_reader MID && add_W o2-mid-raw-to-digits-workflow "$MIDDEC_CONFIG --pipeline $(get_N MIDRawDecoder MID RAW 1),$(get_N MIDDecodedDataAggregator MID RAW 1)"
-  has_detector MCH && ! has_detector_from_global_reader MCH && add_W o2-mch-raw-to-digits-workflow "--pipeline $(get_N mch-data-decoder MCH RAW 1)"
+  has_detector MCH && ! has_detector_from_global_reader MCH && add_W o2-mch-raw-to-digits-workflow "--pipeline $(get_N mch-data-decoder MCH RAW 1 MCHRAWDEC)"
   has_detector TOF && ! has_detector_from_global_reader TOF && ! has_detector_flp_processing TOF && add_W o2-tof-compressor "--tof-compressor-paranoid --pipeline $(get_N tof-compressor-0 TOF RAW 1)"
   has_detector FDD && ! has_detector_from_global_reader FDD && ! has_detector_flp_processing FDD && add_W o2-fdd-flp-dpl-workflow "$DISABLE_ROOT_OUTPUT --pipeline $(get_N fdd-datareader-dpl FDD RAW 1)"
   has_detector TRD && ! has_detector_from_global_reader TRD && add_W o2-trd-datareader "$DISABLE_ROOT_OUTPUT --sortDigits --pipeline $(get_N trd-datareader TRD RAW 1 TRDRAWDEC)" "" 0

From c09477ef95ae54a52bebffa3f224b95591b55fe7 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <92120560+cima22@users.noreply.github.com>
Date: Wed, 3 Sep 2025 11:41:03 +0200
Subject: [PATCH 0774/1764] ITS: GPU: added launch bounds for ITS kernels, not
 fully optimised for MI50 (#14644)

---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 50 ++++++++++---------
 .../include/ITStracking/TrackingConfigParam.h | 10 ++--
 2 files changed, 31 insertions(+), 29 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 94c6610ab9430..0e5fd21e5e90e 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -311,7 +311,7 @@ GPUdii() gpuSpan<const Cluster> getClustersOnLayer(const int rof,
 }
 
 template <int nLayers>
-GPUg() void fitTrackSeedsKernel(
+GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   CellSeed<nLayers>* trackSeeds,
   const TrackingFrameInfo** foundTrackingFrameInfo,
   o2::its::TrackITSExt* tracks,
@@ -374,7 +374,7 @@ GPUg() void fitTrackSeedsKernel(
 }
 
 template <bool initRun, int nLayers = 7>
-GPUg() void computeLayerCellNeighboursKernel(
+GPUg() void __launch_bounds__(256, 1) computeLayerCellNeighboursKernel(
   CellSeed<nLayers>** cellSeedArray,
   int* neighboursLUT,
   int* neighboursIndexTable,
@@ -438,7 +438,7 @@ GPUg() void computeLayerCellNeighboursKernel(
 }
 
 template <bool initRun, int nLayers>
-GPUg() void computeLayerCellsKernel(
+GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
   const Cluster** sortedClusters,
   const Cluster** unsortedClusters,
   const TrackingFrameInfo** tfInfo,
@@ -525,7 +525,7 @@ GPUg() void computeLayerCellsKernel(
 }
 
 template <bool initRun, int nLayers>
-GPUg() void computeLayerTrackletsMultiROFKernel(
+GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
   const IndexTableUtils<nLayers>* utils,
   const uint8_t* multMask,
   const int layerIndex,
@@ -652,9 +652,10 @@ GPUg() void computeLayerTrackletsMultiROFKernel(
   }
 }
 
-GPUg() void compileTrackletsLookupTableKernel(const Tracklet* tracklets,
-                                              int* trackletsLookUpTable,
-                                              const int nTracklets)
+GPUg() void __launch_bounds__(256, 1) compileTrackletsLookupTableKernel(
+  const Tracklet* tracklets,
+  int* trackletsLookUpTable,
+  const int nTracklets)
 {
   for (int currentTrackletIndex = blockIdx.x * blockDim.x + threadIdx.x; currentTrackletIndex < nTracklets; currentTrackletIndex += blockDim.x * gridDim.x) {
     atomicAdd(&trackletsLookUpTable[tracklets[currentTrackletIndex].firstClusterIndex], 1);
@@ -662,23 +663,24 @@ GPUg() void compileTrackletsLookupTableKernel(const Tracklet* tracklets,
 }
 
 template <bool dryRun, int nLayers = 7>
-GPUg() void processNeighboursKernel(const int layer,
-                                    const int level,
-                                    CellSeed<nLayers>** allCellSeeds,
-                                    CellSeed<nLayers>* currentCellSeeds,
-                                    const int* currentCellIds,
-                                    const unsigned int nCurrentCells,
-                                    CellSeed<nLayers>* updatedCellSeeds,
-                                    int* updatedCellsIds,
-                                    int* foundSeedsTable,               // auxiliary only in GPU code to compute the number of cells per iteration
-                                    const unsigned char** usedClusters, // Used clusters
-                                    int* neighbours,
-                                    int* neighboursLUT,
-                                    const TrackingFrameInfo** foundTrackingFrameInfo,
-                                    const float bz,
-                                    const float maxChi2ClusterAttachment,
-                                    const o2::base::Propagator* propagator,
-                                    const o2::base::PropagatorF::MatCorrType matCorrType)
+GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
+  const int layer,
+  const int level,
+  CellSeed<nLayers>** allCellSeeds,
+  CellSeed<nLayers>* currentCellSeeds,
+  const int* currentCellIds,
+  const unsigned int nCurrentCells,
+  CellSeed<nLayers>* updatedCellSeeds,
+  int* updatedCellsIds,
+  int* foundSeedsTable,               // auxiliary only in GPU code to compute the number of cells per iteration
+  const unsigned char** usedClusters, // Used clusters
+  int* neighbours,
+  int* neighboursLUT,
+  const TrackingFrameInfo** foundTrackingFrameInfo,
+  const float bz,
+  const float maxChi2ClusterAttachment,
+  const o2::base::Propagator* propagator,
+  const o2::base::PropagatorF::MatCorrType matCorrType)
 {
   constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // Hardcoded here for the moment.
   for (unsigned int iCurrentCell = blockIdx.x * blockDim.x + threadIdx.x; iCurrentCell < nCurrentCells; iCurrentCell += blockDim.x * gridDim.x) {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index e8d3692909d05..4c445bdbbfa16 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -121,19 +121,19 @@ struct ITSGpuTrackingParamConfig : public o2::conf::ConfigurableParamHelper<ITSG
   void maybeOverride() const;
 
   /// Individual kernel launch parameter for each iteration
-  int nBlocksLayerTracklets[MaxIter] = {30, 30, 30, 30};
+  int nBlocksLayerTracklets[MaxIter] = {60, 60, 60, 60};
   int nThreadsLayerTracklets[MaxIter] = {256, 256, 256, 256};
 
-  int nBlocksLayerCells[MaxIter] = {30, 30, 30, 30};
+  int nBlocksLayerCells[MaxIter] = {60, 60, 60, 60};
   int nThreadsLayerCells[MaxIter] = {256, 256, 256, 256};
 
-  int nBlocksFindNeighbours[MaxIter] = {30, 30, 30, 30};
+  int nBlocksFindNeighbours[MaxIter] = {60, 60, 60, 60};
   int nThreadsFindNeighbours[MaxIter] = {256, 256, 256, 256};
 
-  int nBlocksProcessNeighbours[MaxIter] = {30, 30, 30, 30};
+  int nBlocksProcessNeighbours[MaxIter] = {60, 60, 60, 60};
   int nThreadsProcessNeighbours[MaxIter] = {256, 256, 256, 256};
 
-  int nBlocksTracksSeeds[MaxIter] = {30, 30, 30, 30};
+  int nBlocksTracksSeeds[MaxIter] = {60, 60, 60, 60};
   int nThreadsTracksSeeds[MaxIter] = {256, 256, 256, 256};
 
   O2ParamDef(ITSGpuTrackingParamConfig, "ITSGpuTrackingParam");

From 5f95c73d8f5c935c4c81681998e30c4d64499074 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 1 Sep 2025 12:35:29 +0200
Subject: [PATCH 0775/1764] ITS: extend macros for pull distributions

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/macros/test/CheckTracksCA.C    | 455 ++++++++++++++----
 1 file changed, 352 insertions(+), 103 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/macros/test/CheckTracksCA.C b/Detectors/ITSMFT/ITS/macros/test/CheckTracksCA.C
index 7c128ce34d538..e185be83a389f 100644
--- a/Detectors/ITSMFT/ITS/macros/test/CheckTracksCA.C
+++ b/Detectors/ITSMFT/ITS/macros/test/CheckTracksCA.C
@@ -21,16 +21,21 @@
 #include <TFile.h>
 #include <TTree.h>
 #include <TClonesArray.h>
+#include <TF1.h>
 #include <TH2F.h>
 #include <TCanvas.h>
 #include <THStack.h>
 #include <TLegend.h>
 #include <TPad.h>
+#include <TLatex.h>
+#include <TFitResult.h>
+#include <TFitResultPtr.h>
 
 #include "ITSBase/GeometryTGeo.h"
 #include "SimulationDataFormat/MCEventHeader.h"
 #include "DetectorsBase/Propagator.h"
 #include "SimulationDataFormat/TrackReference.h"
+#include "SimulationDataFormat/O2DatabasePDG.h"
 #include "SimulationDataFormat/MCTrack.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
@@ -41,6 +46,19 @@
 
 using namespace std;
 
+// chi2 PDF with amplitude A, degrees of freedom k, scale s
+Double_t chi2_pdf(Double_t* x, Double_t* par)
+{
+  const Double_t xx = x[0];
+  const Double_t A = par[0];
+  const Double_t k = par[1];
+  const Double_t s = par[2];
+  if (xx <= 0.0 || k <= 0.0 || s <= 0.0)
+    return 0.0;
+  const Double_t coef = 1.0 / (TMath::Power(2.0 * s, k * 0.5) * TMath::Gamma(k * 0.5));
+  return A * coef * TMath::Power(xx, k * 0.5 - 1.0) * TMath::Exp(-xx / (2.0 * s));
+}
+
 struct ParticleInfo {
   int event;
   int pdg;
@@ -60,11 +78,15 @@ struct ParticleInfo {
   bool isPrimary = 0u;
   unsigned char storedStatus = 2; /// not stored = 2, fake = 1, good = 0
   o2::its::TrackITS track;
+  o2::MCTrack mcTrack;
 };
 
 #pragma link C++ class ParticleInfo + ;
 
-void CheckTracksCA(bool doFakeClStud = false,
+void CheckTracksCA(bool doEffStud = true,
+                   bool doFakeClStud = false,
+                   bool doPullStud = false,
+                   bool createOutput = false,
                    std::string tracfile = "o2trac_its.root",
                    std::string magfile = "o2sim_grp.root",
                    std::string clusfile = "o2clus_its.root",
@@ -124,7 +146,10 @@ void CheckTracksCA(bool doFakeClStud = false,
     info[n].resize(mcArr->size());
     hZvertex->Fill(mcEvent->GetZ());
     for (unsigned int mcI{0}; mcI < mcArr->size(); ++mcI) {
-      auto part = mcArr->at(mcI);
+      const auto part = mcArr->at(mcI);
+      if (!o2::O2DatabasePDG::Instance()->GetParticle(part.GetPdgCode())) {
+        continue;
+      }
       info[n][mcI].event = n;
       info[n][mcI].pdg = part.GetPdgCode();
       info[n][mcI].pvx = mcEvent->GetX();
@@ -134,6 +159,7 @@ void CheckTracksCA(bool doFakeClStud = false,
       info[n][mcI].phi = part.GetPhi();
       info[n][mcI].eta = part.GetEta();
       info[n][mcI].isPrimary = part.isPrimary();
+      info[n][mcI].mcTrack = part;
     }
   }
   std::cout << "done." << std::endl;
@@ -214,117 +240,108 @@ void CheckTracksCA(bool doFakeClStud = false,
   std::cout << "\t- Total number of fakes: " << fakes << " (" << fakes * 100. / total << "%)" << std::endl;
   std::cout << "\t- Total number of good: " << good << " (" << good * 100. / total << "%)" << std::endl;
 
-  int nb = 100;
-  double xbins[nb + 1], ptcutl = 0.01, ptcuth = 10.;
-  double a = std::log(ptcuth / ptcutl) / nb;
-  for (int i = 0; i <= nb; i++)
-    xbins[i] = ptcutl * std::exp(i * a);
-  TH1D* num = new TH1D("num", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", nb, xbins);
-  num->Sumw2();
-  TH1D* numEta = new TH1D("numEta", ";#eta;Number of tracks", 60, -3, 3);
-  numEta->Sumw2();
-  TH1D* numChi2 = new TH1D("numChi2", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", 200, 0, 100);
-
-  TH1D* fak = new TH1D("fak", ";#it{p}_{T} (GeV/#it{c});Fak", nb, xbins);
-  fak->Sumw2();
-  TH1D* multiFak = new TH1D("multiFak", ";#it{p}_{T} (GeV/#it{c});Fak", nb, xbins);
-  multiFak->Sumw2();
-  TH1D* fakChi2 = new TH1D("fakChi2", ";#it{p}_{T} (GeV/#it{c});Fak", 200, 0, 100);
-
-  TH1D* clone = new TH1D("clone", ";#it{p}_{T} (GeV/#it{c});Clone", nb, xbins);
-  clone->Sumw2();
-
-  TH1D* den = new TH1D("den", ";#it{p}_{T} (GeV/#it{c});Den", nb, xbins);
-  den->Sumw2();
-
-  for (auto& evInfo : info) {
-    for (auto& part : evInfo) {
-      if ((part.clusters & 0x7f) != 0x7f) {
-        // part.clusters != 0x3f && part.clusters != 0x3f << 1 &&
-        // part.clusters != 0x1f && part.clusters != 0x1f << 1 && part.clusters != 0x1f << 2 &&
-        // part.clusters != 0x0f && part.clusters != 0x0f << 1 && part.clusters != 0x0f << 2 && part.clusters != 0x0f << 3) {
-        continue;
-      }
-      if (!part.isPrimary) {
-        continue;
-      }
-      den->Fill(part.pt);
-      if (part.isReco) {
-        num->Fill(part.pt);
-        numEta->Fill(part.eta);
-        if (part.isReco > 1) {
-          for (int _i{0}; _i < part.isReco - 1; ++_i) {
-            clone->Fill(part.pt);
+  TFile* file{nullptr};
+  if (createOutput) {
+    file = TFile::Open("CheckTracksCA.root", "recreate");
+  }
+
+  if (doEffStud) {
+    std::cout << "Calculating efficiencies... ";
+    const int nb = 100;
+    double xbins[nb + 1], ptcutl = 0.01, ptcuth = 10.;
+    double a = std::log(ptcuth / ptcutl) / nb;
+    for (int i = 0; i <= nb; i++)
+      xbins[i] = ptcutl * std::exp(i * a);
+    TH1D* num = new TH1D("num", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", nb, xbins);
+    num->Sumw2();
+    TH1D* numEta = new TH1D("numEta", ";#eta;Number of tracks", 60, -3, 3);
+    numEta->Sumw2();
+    TH1D* numChi2 = new TH1D("numChi2", ";#it{p}_{T} (GeV/#it{c});Efficiency (fake-track rate)", 200, 0, 100);
+
+    TH1D* fak = new TH1D("fak", ";#it{p}_{T} (GeV/#it{c});Fak", nb, xbins);
+    fak->Sumw2();
+    TH1D* multiFak = new TH1D("multiFak", ";#it{p}_{T} (GeV/#it{c});Fak", nb, xbins);
+    multiFak->Sumw2();
+    TH1D* fakChi2 = new TH1D("fakChi2", ";#it{p}_{T} (GeV/#it{c});Fak", 200, 0, 100);
+
+    TH1D* clone = new TH1D("clone", ";#it{p}_{T} (GeV/#it{c});Clone", nb, xbins);
+    clone->Sumw2();
+
+    TH1D* den = new TH1D("den", ";#it{p}_{T} (GeV/#it{c});Den", nb, xbins);
+    den->Sumw2();
+
+    for (auto& evInfo : info) {
+      for (auto& part : evInfo) {
+        if ((part.clusters & 0x7f) != 0x7f) {
+          // part.clusters != 0x3f && part.clusters != 0x3f << 1 &&
+          // part.clusters != 0x1f && part.clusters != 0x1f << 1 && part.clusters != 0x1f << 2 &&
+          // part.clusters != 0x0f && part.clusters != 0x0f << 1 && part.clusters != 0x0f << 2 && part.clusters != 0x0f << 3) {
+          continue;
+        }
+        if (!part.isPrimary) {
+          continue;
+        }
+        den->Fill(part.pt);
+        if (part.isReco) {
+          num->Fill(part.pt);
+          numEta->Fill(part.eta);
+          if (part.isReco > 1) {
+            for (int _i{0}; _i < part.isReco - 1; ++_i) {
+              clone->Fill(part.pt);
+            }
           }
         }
-      }
-      if (part.isFake) {
-        fak->Fill(part.pt);
-        if (part.isFake > 1) {
-          for (int _i{0}; _i < part.isFake - 1; ++_i) {
-            multiFak->Fill(part.pt);
+        if (part.isFake) {
+          fak->Fill(part.pt);
+          if (part.isFake > 1) {
+            for (int _i{0}; _i < part.isFake - 1; ++_i) {
+              multiFak->Fill(part.pt);
+            }
           }
         }
       }
     }
-  }
 
-  TCanvas* c1 = new TCanvas;
-  c1->SetLogx();
-  c1->SetGridx();
-  c1->SetGridy();
-  TH1* sum = (TH1*)num->Clone("sum");
-  sum->Add(fak);
-  sum->Divide(sum, den, 1, 1);
-  sum->SetLineColor(kBlack);
-  sum->Draw("hist");
-  num->Divide(num, den, 1, 1, "b");
-  num->Draw("histesame");
-  fak->Divide(fak, den, 1, 1, "b");
-  fak->SetLineColor(2);
-  fak->Draw("histesame");
-  multiFak->Divide(multiFak, den, 1, 1, "b");
-  multiFak->SetLineColor(kRed + 1);
-  multiFak->Draw("histsame");
-  clone->Divide(clone, den, 1, 1, "b");
-  clone->SetLineColor(3);
-  clone->Draw("histesame");
-  TCanvas* c2 = new TCanvas;
-  c2->SetGridx();
-  c2->SetGridy();
-  hZvertex->DrawClone();
-
-  std::cout << "** Streaming output TTree to file ... " << std::flush;
-  TFile file("CheckTracksCA.root", "recreate");
-  TTree tree("ParticleInfo", "ParticleInfo");
-  ParticleInfo pInfo;
-  tree.Branch("particle", &pInfo);
-  for (auto& event : info) {
-    for (auto& part : event) {
-      int nCl{0};
-      for (unsigned int bit{0}; bit < sizeof(pInfo.clusters) * 8; ++bit) {
-        nCl += bool(part.clusters & (1 << bit));
-      }
-      if (nCl < 3) {
-        continue;
-      }
-      pInfo = part;
-      tree.Fill();
+    TCanvas* c1 = new TCanvas;
+    c1->SetLogx();
+    c1->SetGridx();
+    c1->SetGridy();
+    TH1* sum = (TH1*)num->Clone("sum");
+    sum->Add(fak);
+    sum->Divide(sum, den, 1, 1);
+    sum->SetLineColor(kBlack);
+    sum->Draw("hist");
+    num->Divide(num, den, 1, 1, "b");
+    num->Draw("histesame");
+    fak->Divide(fak, den, 1, 1, "b");
+    fak->SetLineColor(2);
+    fak->Draw("histesame");
+    multiFak->Divide(multiFak, den, 1, 1, "b");
+    multiFak->SetLineColor(kRed + 1);
+    multiFak->Draw("histsame");
+    clone->Divide(clone, den, 1, 1, "b");
+    clone->SetLineColor(3);
+    clone->Draw("histesame");
+    TCanvas* c2 = new TCanvas;
+    c2->SetGridx();
+    c2->SetGridy();
+    hZvertex->DrawClone();
+
+    if (createOutput) {
+      sum->Write("total");
+      fak->Write("singleFake");
+      num->Write("efficiency");
+      numEta->Write("etaDist");
+      multiFak->Write("multiFake");
+      clone->Write("clones");
     }
+    std::cout << " done." << std::endl;
   }
-  tree.Write();
-  sum->Write("total");
-  fak->Write("singleFake");
-  num->Write("efficiency");
-  numEta->Write("etaDist");
-  multiFak->Write("multiFake");
-  clone->Write("clones");
-  file.Close();
-  std::cout << " done." << std::endl;
 
   //////////////////////
   // Fake clusters study
   if (doFakeClStud) {
+    std::cout << "Creating fake cluster study... ";
     std::vector<TH1I*> histLength, histLength1Fake, histLengthNoCl, histLength1FakeNoCl;
     std::vector<THStack*> stackLength, stackLength1Fake;
     std::vector<TLegend*> legends, legends1Fake;
@@ -364,10 +381,10 @@ void CheckTracksCA(bool doFakeClStud = false,
       stackLength1Fake[iH - 4]->Add(histLength1FakeNoCl[iH - 4]);
     }
 
-    for (auto& event : info) {
-      for (auto& part : event) {
+    for (const auto& event : info) {
+      for (const auto& part : event) {
         int nCl{0};
-        for (unsigned int bit{0}; bit < sizeof(pInfo.clusters) * 8; ++bit) {
+        for (unsigned int bit{0}; bit < sizeof(part.clusters) * 8; ++bit) {
           nCl += bool(part.clusters & (1 << bit));
         }
         if (nCl < 3) {
@@ -409,5 +426,237 @@ void CheckTracksCA(bool doFakeClStud = false,
       gPad->BuildLegend();
     }
     canvas->SaveAs("fakeClusters.png", "recreate");
+    std::cout << " done\n";
+  }
+
+  if (doPullStud) {
+    std::cout << "Creating pull study... ";
+    const int nBins{30};
+    const float xWidth{10};
+    // Pulls
+    auto hYPull = new TH1F("hYPull", "Pull Y", nBins, -xWidth, xWidth);
+    auto hZPull = new TH1F("hZPull", "Pull Z", nBins, -xWidth, xWidth);
+    auto hSPhiPull = new TH1F("hSPhiPull", "Pull Sin(Phi)", nBins, -xWidth, xWidth);
+    auto hTglPull = new TH1F("hTglPull", "Pull Tg(Lambda)", nBins, -xWidth, xWidth);
+    auto hQoPtPull = new TH1F("hQoPtPull", "Pull Q/Pt", nBins, -xWidth, xWidth);
+    // Correlation
+    float maxY2{1e-6}, maxZ2{1e-6}, maxSnp2{2e-6}, maxTgl2{2e-6}, max1Pt2{0.01};
+    auto hCorYZ = new TH2F("hCorYZ", ";#sigma_{Z}^{2};#sigma_{Y}^{2}", nBins, 0, maxZ2, nBins, 0, maxY2);
+    auto hCorYSPhi = new TH2F("hCorYSPhi", ";#sigma_{snp}^{2};#sigma_{Y}^{2}", nBins, 0, maxSnp2, nBins, 0, maxY2);
+    auto hCorYTgl = new TH2F("hCorYTgl", ";#sigma_{tgl}^{2};#sigma_{Y}^{2}", nBins, 0, maxTgl2, nBins, 0, maxY2);
+    auto hCorYQoPt = new TH2F("hCorYQoPt", ";#sigma_{Q/Pt}^{2};#sigma_{Y}^{2}", nBins, 0, max1Pt2, nBins, 0, maxY2);
+
+    auto hCorZSPhi = new TH2F("hCorZSPhi", ";#sigma_{snp}^{2};#sigma_{Z}^{2}", nBins, 0, maxSnp2, nBins, 0, maxZ2);
+    auto hCorZTgl = new TH2F("hCorZTgl", ";#sigma_{tgl}^{2};#sigma_{Z}^{2}", nBins, 0, maxTgl2, nBins, 0, maxZ2);
+    auto hCorZQoPt = new TH2F("hCorZQoPt", ";#sigma_{Q/Pt}^{2};#sigma_{Z}^{2}", nBins, 0, max1Pt2, nBins, 0, maxZ2);
+
+    auto hCorSPhiTgl = new TH2F("hCorSPhiTgl", ";#sigma_{tgl}^{2};#sigma_{snp}^{2}", nBins, 0, maxTgl2, nBins, 0, maxSnp2);
+    auto hCorSPhiQoPt = new TH2F("hCorSPhiQoPt", ";#sigma_{Q/Pt}^{2};#sigma_{snp}^{2}", nBins, 0, max1Pt2, nBins, 0, maxSnp2);
+
+    auto hCorTglQoPt = new TH2F("hCorTglQoPt", ";#sigma_{Q/Pt}^{2};#sigma_{tgl}^{2}", nBins, 0, max1Pt2, nBins, 0, maxTgl2);
+
+    auto calcMahalanobisDist = [&](const auto& trk, const auto& mc) -> float {
+      o2::math_utils::SMatrix<float, o2::track::kNParams, o2::track::kNParams, o2::math_utils::MatRepSym<float, o2::track::kNParams>> cov;
+      cov(o2::track::kY, o2::track::kY) = trk.getSigmaY2();
+      cov(o2::track::kZ, o2::track::kY) = trk.getSigmaZY();
+      cov(o2::track::kZ, o2::track::kZ) = trk.getSigmaZ2();
+      cov(o2::track::kSnp, o2::track::kY) = trk.getSigmaSnpY();
+      cov(o2::track::kSnp, o2::track::kZ) = trk.getSigmaSnpZ();
+      cov(o2::track::kSnp, o2::track::kSnp) = trk.getSigmaSnp2();
+      cov(o2::track::kTgl, o2::track::kY) = trk.getSigmaTglY();
+      cov(o2::track::kTgl, o2::track::kZ) = trk.getSigmaTglZ();
+      cov(o2::track::kTgl, o2::track::kSnp) = trk.getSigmaTglSnp();
+      cov(o2::track::kTgl, o2::track::kTgl) = trk.getSigmaTgl2();
+      cov(o2::track::kQ2Pt, o2::track::kY) = trk.getSigma1PtY();
+      cov(o2::track::kQ2Pt, o2::track::kZ) = trk.getSigma1PtZ();
+      cov(o2::track::kQ2Pt, o2::track::kSnp) = trk.getSigma1PtSnp();
+      cov(o2::track::kQ2Pt, o2::track::kTgl) = trk.getSigma1PtTgl();
+      cov(o2::track::kQ2Pt, o2::track::kQ2Pt) = trk.getSigma1Pt2();
+      if (!cov.Invert()) {
+        return -1.f;
+      }
+      o2::math_utils::SVector<float, o2::track::kNParams> trkPar(trk.getParams(), o2::track::kNParams), mcPar(mc.getParams(), o2::track::kNParams);
+      auto res = trkPar - mcPar;
+      return std::sqrt(ROOT::Math::Similarity(cov, res));
+    };
+    auto hMahDist = new TH1F("hMahDist", ";Mahalanobis distance;n. entries", 100, 0, 10);
+    TF1* fchi = new TF1("fchi", chi2_pdf, 0, 6, 3);
+    fchi->SetParNames("A", "k", "s");
+    fchi->SetParameter(0, 1);
+    fchi->SetParameter(1, 5);
+    fchi->SetParameter(2, 1);
+
+    for (const auto& event : info) {
+      for (const auto& part : event) {
+        if (((part.clusters & 0x7f) != 0x7f) && !part.isPrimary) {
+          continue;
+        }
+
+        // prepare mc truth parameters
+        std::array<float, 3> xyz{(float)part.mcTrack.GetStartVertexCoordinatesX(), (float)part.mcTrack.GetStartVertexCoordinatesY(), (float)part.mcTrack.GetStartVertexCoordinatesZ()};
+        std::array<float, 3> pxyz{(float)part.mcTrack.GetStartVertexMomentumX(), (float)part.mcTrack.GetStartVertexMomentumY(), (float)part.mcTrack.GetStartVertexMomentumZ()};
+        o2::track::TrackPar mcTrack(xyz, pxyz, TMath::Nint(o2::O2DatabasePDG::Instance()->GetParticle(part.mcTrack.GetPdgCode())->Charge() / 3), false);
+        if (!mcTrack.rotate(part.track.getAlpha()) ||
+            !o2::base::Propagator::Instance()->propagateTo(mcTrack, part.track.getX())) {
+          continue;
+        }
+
+        const float sY = part.track.getSigmaY2();
+        const float sZ = part.track.getSigmaZ2();
+        const float sSnp = part.track.getSigmaSnp2();
+        const float sTgl = part.track.getSigmaTgl2();
+        const float s1Pt = part.track.getSigma1Pt2();
+
+        hYPull->Fill((part.track.getY() - mcTrack.getY()) / std::sqrt(part.track.getSigmaY2()));
+        hZPull->Fill((part.track.getZ() - mcTrack.getZ()) / std::sqrt(part.track.getSigmaZ2()));
+        hSPhiPull->Fill((part.track.getSnp() - mcTrack.getSnp()) / std::sqrt(part.track.getSigmaSnp2()));
+        hTglPull->Fill((part.track.getTgl() - mcTrack.getTgl()) / std::sqrt(part.track.getSigmaTgl2()));
+        hQoPtPull->Fill((part.track.getQ2Pt() - mcTrack.getQ2Pt()) / std::sqrt(part.track.getSigma1Pt2()));
+
+        hCorYZ->Fill(part.track.getSigmaZ2(), part.track.getSigmaY2());
+        hCorYSPhi->Fill(part.track.getSigmaSnp2(), part.track.getSigmaY2());
+        hCorYTgl->Fill(part.track.getSigmaTgl2(), part.track.getSigmaY2());
+        hCorYQoPt->Fill(part.track.getSigma1Pt2(), part.track.getSigmaY2());
+
+        hCorZSPhi->Fill(part.track.getSigmaSnp2(), part.track.getSigmaZ2());
+        hCorZTgl->Fill(part.track.getSigmaTgl2(), part.track.getSigmaZ2());
+        hCorZQoPt->Fill(part.track.getSigma1Pt2(), part.track.getSigmaZ2());
+
+        hCorSPhiTgl->Fill(part.track.getSigmaTgl2(), part.track.getSigmaSnp2());
+        hCorSPhiQoPt->Fill(part.track.getSigma1Pt2(), part.track.getSigmaSnp2());
+
+        hCorTglQoPt->Fill(part.track.getSigma1Pt2(), part.track.getSigmaTgl2());
+
+        hMahDist->Fill(calcMahalanobisDist(part.track, mcTrack));
+      }
+    }
+
+    // normalise, set axis, fit and draw
+    auto doPullCalc = [](TH1F* h) {
+      h->Scale(1. / h->Integral("width"));
+      h->GetYaxis()->SetRangeUser(1e-5, 1.);
+      gPad->SetLogy();
+      h->Draw("hist");
+      h->Fit("gaus", "QMR", "", -3, 3);
+      if (auto f = h->GetFunction("gaus")) {
+        f->SetLineColor(kRed);
+        f->SetLineWidth(2);
+        f->Draw("same");
+        const double mean = f->GetParameter(1);
+        const double sigma = f->GetParameter(2);
+        TLatex lat;
+        lat.SetNDC();
+        lat.SetTextFont(42);
+        lat.SetTextSize(0.04);
+        lat.DrawLatex(0.62, 0.85, Form("#mu = %.4f", mean));
+        lat.DrawLatex(0.62, 0.79, Form("#sigma = %.4f", sigma));
+      }
+    };
+    hMahDist->Scale(1. / hMahDist->Integral("width"));
+    TFitResultPtr fitres = hMahDist->Fit(fchi, "RMQS");
+
+    auto c = new TCanvas("cPull", "", 2000, 1000);
+    c->Divide(5, 5);
+    c->cd(1);
+    doPullCalc(hYPull);
+    c->cd(2);
+    hCorYZ->Draw("colz");
+    c->cd(3);
+    hCorYSPhi->Draw("colz");
+    c->cd(4);
+    hCorYTgl->Draw("colz");
+    c->cd(5);
+    hCorYQoPt->Draw("colz");
+
+    c->cd(7);
+    doPullCalc(hZPull);
+    c->cd(8);
+    hCorZSPhi->Draw("colz");
+    c->cd(9);
+    hCorZTgl->Draw("colz");
+    c->cd(10);
+    hCorZQoPt->Draw("colz");
+
+    c->cd(13);
+    doPullCalc(hSPhiPull);
+    c->cd(14);
+    hCorSPhiTgl->Draw("colz");
+    c->cd(15);
+    hCorSPhiQoPt->Draw("colz");
+
+    c->cd(19);
+    doPullCalc(hTglPull);
+    c->cd(20);
+    hCorTglQoPt->Draw("colz");
+
+    c->cd();
+    const double xlow = 0.0;
+    const double xup = 0.4;
+    const double ylow = 0.0;
+    const double yup = 0.4;
+    auto pMahBig = new TPad("pMahBig", "Mahalanobis Distance", xlow, ylow, xup, yup);
+    pMahBig->SetFillStyle(4000);
+    pMahBig->SetBorderMode(0);
+    pMahBig->SetLeftMargin(0.12);
+    pMahBig->SetRightMargin(0.02);
+    pMahBig->SetBottomMargin(0.12);
+    pMahBig->SetTopMargin(0.05);
+    pMahBig->Draw();
+    pMahBig->cd();
+    hMahDist->Draw("hist");
+    fchi->SetLineColor(kRed);
+    fchi->SetLineWidth(2);
+    fchi->Draw("same");
+    const Double_t A_fit = fchi->GetParameter(0);
+    const Double_t k_fit = fchi->GetParameter(1);
+    const Double_t s_fit = fchi->GetParameter(2);
+    const Double_t A_err = fchi->GetParError(0);
+    const Double_t k_err = fchi->GetParError(1);
+    const Double_t s_err = fchi->GetParError(2);
+    const Double_t chi2 = fchi->GetChisquare();
+    const Int_t ndf = fchi->GetNDF();
+    TLatex lat;
+    lat.SetNDC();
+    lat.SetTextFont(42);
+    lat.SetTextSize(0.038);
+    lat.SetTextAlign(11);
+    const Double_t xText = 0.55;
+    Double_t yText = 0.85;
+    const Double_t dy = 0.06;
+    lat.DrawLatex(xText, yText, Form("A = %.3g #pm %.3g", A_fit, A_err));
+    yText -= dy;
+    lat.DrawLatex(xText, yText, Form("k (ndf) = %.3f #pm %.3f", k_fit, k_err));
+    yText -= dy;
+    lat.DrawLatex(xText, yText, Form("scale s = %.3g #pm %.3g", s_fit, s_err));
+    yText -= dy;
+    lat.DrawLatex(xText, yText, Form("#chi^{2}/ndf = %.2f / %d", chi2, ndf));
+    yText -= dy;
+    if (fitres.Get()) {
+      lat.DrawLatex(xText, yText, Form("Fit status = %d", fitres->Status()));
+      yText -= dy;
+    }
+
+    c->cd(25);
+    doPullCalc(hQoPtPull);
+    c->Draw();
+    std::cout << " done\n";
+  }
+
+  if (createOutput) {
+    std::cout << "** Streaming output TTree to file ... " << std::flush;
+    TTree tree("ParticleInfo", "ParticleInfo");
+    ParticleInfo pInfo;
+    tree.Branch("particle", &pInfo);
+    for (const auto& event : info) {
+      for (const auto& part : event) {
+        if (((part.clusters & 0x7f) != 0x7f) && !part.isPrimary) {
+          continue;
+        }
+        pInfo = part;
+        tree.Fill();
+      }
+    }
+    tree.Write();
+    file->Close();
   }
 }

From f37a28b8fedf79bf7184970303acdc3b8647ff3e Mon Sep 17 00:00:00 2001
From: Vikas Singhal <vikas@vecc.gov.in>
Date: Tue, 2 Sep 2025 16:37:24 +0530
Subject: [PATCH 0776/1764] GPU: TODO: TPCRawCluster needed in Base
 GPUReconstructionConvert

---
 GPU/GPUTracking/Base/GPUReconstructionConvert.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
index 2dec88393f632..6bffdc3560d4a 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
@@ -25,7 +25,7 @@
 #include "GPUO2DataTypes.h"
 #include "GPUDataTypes.h"
 #include "GPUTPCGeometry.h"
-#include "AliHLTTPCRawCluster.h" // TODO: Is this still needed at all, or can it be removed?
+#include "AliHLTTPCRawCluster.h" // VS: It can not be removed. Used in line 93.
 #include "GPUParam.h"
 #include "GPULogging.h"
 #include <algorithm>

From 7d68370fb8d3778bf3f292b8bc6e76be44eb8d00 Mon Sep 17 00:00:00 2001
From: aferrero2707 <aferrero1975@gmail.com>
Date: Thu, 4 Sep 2025 21:26:23 +0200
Subject: [PATCH 0777/1764] Fix EnumFlags compilation for large enums The
 EnumFlags fails to compile when the underlying enum has 30 or more elements.

With exactly 32 elements the compilation error is the following:

  note: shift count 32 >= width of type 'int' (32 bits)
   static constexpr auto MaxRep{((1 << (Max_u_v - Min_u_v + 1)) - 1) << Min_u_v}; // largest representable value

With 30 or 31 elements the compilation error is:

  note: value -2147483649 is outside the range of representable values of type 'int'
   static constexpr auto MaxRep{((1 << (Max_u_v - Min_u_v + 1)) - 1) << Min_u_v}; // largest representable value

The solution consists in using "1ULL" literals in the MaxRep expression, such that the bit shifts are
performed on a variable with at least 64-bits.
---
 Common/Utils/include/CommonUtils/EnumFlags.h |  5 ++-
 Common/Utils/test/testEnumFlags.cxx          | 47 ++++++++++++++++++++
 2 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/Common/Utils/include/CommonUtils/EnumFlags.h b/Common/Utils/include/CommonUtils/EnumFlags.h
index fcd7d2d9e5e26..9a8960f612553 100644
--- a/Common/Utils/include/CommonUtils/EnumFlags.h
+++ b/Common/Utils/include/CommonUtils/EnumFlags.h
@@ -160,8 +160,9 @@ struct FlagsHelper final {
   static constexpr auto Max_v{Values.back()};                                                          // Enum last entry
   static constexpr auto Min_u_v{static_cast<size_t>(Min_v)};                                           // Enum first entry as size_t
   static constexpr auto Max_u_v{static_cast<size_t>(Max_v)};                                           // Enum last entry as size_t
-  static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); }         // Is the enum continuous
-  static constexpr auto MaxRep{((1 << (Max_u_v - Min_u_v + 1)) - 1) << Min_u_v};                       // largest representable value
+  static_assert(Max_u_v < std::numeric_limits<U>::digits, "Max Bit is beyond allow range defered from underlying type");
+  static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); }                             // Is the enum continuous
+  static constexpr auto MaxRep{((1ULL << (static_cast<unsigned long long>(Max_u_v - Min_u_v) + 1ULL)) - 1ULL) << Min_u_v}; // largest representable value
 
   template <E e>
   static constexpr std::string_view getName()
diff --git a/Common/Utils/test/testEnumFlags.cxx b/Common/Utils/test/testEnumFlags.cxx
index 5c8b71eb9040a..41b43bc4218ff 100644
--- a/Common/Utils/test/testEnumFlags.cxx
+++ b/Common/Utils/test/testEnumFlags.cxx
@@ -28,6 +28,46 @@ enum class TestEnum : uint8_t {
   Bit5VeryLongName,
 };
 
+// Very long enum
+// to test that it works beyond 32 bits
+enum class TestEnumLong : uint64_t {
+  Bit1,
+  Bit2,
+  Bit3,
+  Bit4,
+  Bit5,
+  Bit6,
+  Bit7,
+  Bit8,
+  Bit9,
+  Bit10,
+  Bit11,
+  Bit12,
+  Bit13,
+  Bit14,
+  Bit15,
+  Bit16,
+  Bit17,
+  Bit18,
+  Bit19,
+  Bit20,
+  Bit21,
+  Bit22,
+  Bit23,
+  Bit24,
+  Bit25,
+  Bit26,
+  Bit27,
+  Bit28,
+  Bit29,
+  Bit30,
+  Bit31,
+  Bit32,
+  Bit33,
+  Bit34,
+  // ...
+};
+
 BOOST_AUTO_TEST_CASE(Flags_test)
 {
   using EFlags = o2::utils::EnumFlags<TestEnum>;
@@ -257,4 +297,11 @@ BOOST_AUTO_TEST_CASE(Flags_test)
     EFlags flags3{TestEnum::Bit4};
     BOOST_CHECK(!flags1.contains(flags3)); // flags1 does not contain flags3
   }
+
+  {
+    // Test compilation using an enum with more than 32 bits
+    o2::utils::EnumFlags<TestEnumLong> test;
+    test.set("Bit32");
+    BOOST_CHECK(test.test(TestEnumLong::Bit32));
+  }
 }

From d7638dec1fcd180417017fc75c2dba406a37fb57 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 28 Aug 2025 17:34:58 +0200
Subject: [PATCH 0778/1764] Geo: Fix Run 4 barrel beam pipe section

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/Passive/src/PipeRun4.cxx | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Detectors/Passive/src/PipeRun4.cxx b/Detectors/Passive/src/PipeRun4.cxx
index 7a2ff6dcfe90b..0403624f23b4c 100644
--- a/Detectors/Passive/src/PipeRun4.cxx
+++ b/Detectors/Passive/src/PipeRun4.cxx
@@ -215,8 +215,7 @@ void PipeRun4::ConstructGeometry()
   voberylliumTube->SetLineColor(kRed);
 
   TGeoTube* berylliumTubeVacuum =
-    new TGeoTube("IP_PIPEVACUUMsh", 0., kBeryliumSectionOuterRadius - kBeryliumSectionThickness,
-                 (kBeryliumSectionZmax - kBeryliumSectionZmin) / 2);
+    new TGeoTube("IP_PIPEVACUUMsh", 0., kBeryliumSectionOuterRadius, (kBeryliumSectionZmax - kBeryliumSectionZmin) / 2);
   TGeoVolume* voberylliumTubeVacuum = new TGeoVolume("IP_PIPEMOTHER", berylliumTubeVacuum, kMedVac);
   voberylliumTubeVacuum->AddNode(voberylliumTube, 1, gGeoIdentity);
   voberylliumTubeVacuum->SetVisibility(0);

From 98f5ae05e5d6e1b0f949c0aaaefcb32c31914a15 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 5 Sep 2025 09:13:42 +0200
Subject: [PATCH 0779/1764] DPL Analysis: improve grouping performance further
 (#14600)

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Framework/Core/include/Framework/ASoA.h       | 70 +++++++++++-----
 .../Framework/ArrowTableSlicingCache.h        |  2 -
 Framework/Core/src/ArrowTableSlicingCache.cxx | 80 ++++++++-----------
 3 files changed, 85 insertions(+), 67 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 4db774d88a224..b9b97bfa5ca9c 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1068,7 +1068,9 @@ struct TableIterator : IP, C... {
     : IP{policy},
       C(columnData[framework::has_type_at_v<C>(all_columns{})])...
   {
-    bind();
+    if (this->size() != 0) {
+      bind();
+    }
   }
 
   TableIterator(arrow::ChunkedArray* columnData[sizeof...(C)], IP&& policy)
@@ -1076,7 +1078,9 @@ struct TableIterator : IP, C... {
     : IP{policy},
       C(columnData[framework::has_type_at_v<C>(all_columns{})])...
   {
-    bind();
+    if (this->size() != 0) {
+      bind();
+    }
     // In case we have an index column might need to constrain the actual
     // number of rows in the view to the range provided by the index.
     // FIXME: we should really understand what happens to an index when we
@@ -1089,14 +1093,18 @@ struct TableIterator : IP, C... {
     : IP{static_cast<IP const&>(other)},
       C(static_cast<C const&>(other))...
   {
-    bind();
+    if (this->size() != 0) {
+      bind();
+    }
   }
 
   TableIterator& operator=(TableIterator other)
   {
     IP::operator=(static_cast<IP const&>(other));
     (void(static_cast<C&>(*this) = static_cast<C>(other)), ...);
-    bind();
+    if (this->size() != 0) {
+      bind();
+    }
     return *this;
   }
 
@@ -1105,7 +1113,9 @@ struct TableIterator : IP, C... {
     : IP{static_cast<IP const&>(other)},
       C(static_cast<C const&>(other))...
   {
-    bind();
+    if (this->size() != 0) {
+      bind();
+    }
   }
 
   TableIterator& operator++()
@@ -1551,8 +1561,10 @@ auto doSliceBy(T const* table, o2::framework::PresliceBase<C, Policy, OPT> const
   uint64_t offset = 0;
   auto out = container.getSliceFor(value, table->asArrowTable(), offset);
   auto t = typename T::self_t({out}, offset);
-  table->copyIndexBindings(t);
-  t.bindInternalIndicesTo(table);
+  if (t.tableSize() != 0) {
+    table->copyIndexBindings(t);
+    t.bindInternalIndicesTo(table);
+  }
   return t;
 }
 
@@ -1560,9 +1572,11 @@ template <soa::is_filtered_table T>
 auto doSliceByHelper(T const* table, std::span<const int64_t> const& selection)
 {
   auto t = soa::Filtered<typename T::base_t>({table->asArrowTable()}, selection);
-  table->copyIndexBindings(t);
-  t.bindInternalIndicesTo(table);
-  t.intersectWithSelection(table->getSelectedRows()); // intersect filters
+  if (t.tableSize() != 0) {
+    table->copyIndexBindings(t);
+    t.bindInternalIndicesTo(table);
+    t.intersectWithSelection(table->getSelectedRows()); // intersect filters
+  }
   return t;
 }
 
@@ -1571,8 +1585,10 @@ template <soa::is_table T>
 auto doSliceByHelper(T const* table, std::span<const int64_t> const& selection)
 {
   auto t = soa::Filtered<T>({table->asArrowTable()}, selection);
-  table->copyIndexBindings(t);
-  t.bindInternalIndicesTo(table);
+  if (t.tableSize() != 0) {
+    table->copyIndexBindings(t);
+    t.bindInternalIndicesTo(table);
+  }
   return t;
 }
 
@@ -1596,12 +1612,16 @@ auto prepareFilteredSlice(T const* table, std::shared_ptr<arrow::Table> slice, u
 {
   if (offset >= static_cast<uint64_t>(table->tableSize())) {
     Filtered<typename T::base_t> fresult{{{slice}}, SelectionVector{}, 0};
-    table->copyIndexBindings(fresult);
+    if (fresult.tableSize() != 0) {
+      table->copyIndexBindings(fresult);
+    }
     return fresult;
   }
   auto slicedSelection = sliceSelection(table->getSelectedRows(), slice->num_rows(), offset);
   Filtered<typename T::base_t> fresult{{{slice}}, std::move(slicedSelection), offset};
-  table->copyIndexBindings(fresult);
+  if (fresult.tableSize() != 0) {
+    table->copyIndexBindings(fresult);
+  }
   return fresult;
 }
 
@@ -1625,7 +1645,9 @@ auto doSliceByCached(T const* table, framework::expressions::BindingNode const&
   auto localCache = cache.ptr->getCacheFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
   auto [offset, count] = localCache.getSliceFor(value);
   auto t = typename T::self_t({table->asArrowTable()->Slice(static_cast<uint64_t>(offset), count)}, static_cast<uint64_t>(offset));
-  table->copyIndexBindings(t);
+  if (t.tableSize() != 0) {
+    table->copyIndexBindings(t);
+  }
   return t;
 }
 
@@ -1644,12 +1666,16 @@ auto doSliceByCachedUnsorted(T const* table, framework::expressions::BindingNode
   auto localCache = cache.ptr->getCacheUnsortedFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
   if constexpr (soa::is_filtered_table<T>) {
     auto t = typename T::self_t({table->asArrowTable()}, localCache.getSliceFor(value));
-    t.intersectWithSelection(table->getSelectedRows());
-    table->copyIndexBindings(t);
+    if (t.tableSize() != 0) {
+      t.intersectWithSelection(table->getSelectedRows());
+      table->copyIndexBindings(t);
+    }
     return t;
   } else {
     auto t = Filtered<T>({table->asArrowTable()}, localCache.getSliceFor(value));
-    table->copyIndexBindings(t);
+    if (t.tableSize() != 0) {
+      table->copyIndexBindings(t);
+    }
     return t;
   }
 }
@@ -3299,12 +3325,16 @@ struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts.
   JoinFull(std::shared_ptr<arrow::Table>&& table, uint64_t offset = 0)
     : base{std::move(table), offset}
   {
-    bindInternalIndicesTo(this);
+    if (this->tableSize() != 0) {
+      bindInternalIndicesTo(this);
+    }
   }
   JoinFull(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
     : base{ArrowHelpers::joinTables(std::move(tables), std::span{base::originalLabels}), offset}
   {
-    bindInternalIndicesTo(this);
+    if (this->tableSize() != 0) {
+      bindInternalIndicesTo(this);
+    }
   }
   using base::bindExternalIndices;
   using base::bindInternalIndicesTo;
diff --git a/Framework/Core/include/Framework/ArrowTableSlicingCache.h b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
index 40991a955e52b..a6117ec3e01bc 100644
--- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h
+++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
@@ -64,8 +64,6 @@ struct ArrowTableSlicingCache {
   constexpr static ServiceKind service_kind = ServiceKind::Stream;
 
   Cache bindingsKeys;
-  std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int32Type>>> values;
-  std::vector<std::shared_ptr<arrow::NumericArray<arrow::Int64Type>>> counts;
   std::vector<std::vector<int64_t>> offsets;
   std::vector<std::vector<int64_t>> sizes;
 
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 0d06a926dd930..373c98516bb09 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -31,12 +31,8 @@ void updatePairList(Cache& list, std::string const& binding, std::string const&
 
 std::pair<int64_t, int64_t> SliceInfoPtr::getSliceFor(int value) const
 {
-  int64_t offset = 0;
-  if (offsets.empty()) {
-    return {offset, 0};
-  }
   if ((size_t)value >= offsets.size()) {
-    return {offset, 0};
+    return {0, 0};
   }
 
   return {offsets[value], sizes[value]};
@@ -68,8 +64,6 @@ ArrowTableSlicingCache::ArrowTableSlicingCache(Cache&& bsks, Cache&& bsksUnsorte
   : bindingsKeys{bsks},
     bindingsKeysUnsorted{bsksUnsorted}
 {
-  values.resize(bindingsKeys.size());
-  counts.resize(bindingsKeys.size());
   offsets.resize(bindingsKeys.size());
   sizes.resize(bindingsKeys.size());
 
@@ -81,10 +75,6 @@ void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted)
 {
   bindingsKeys = bsks;
   bindingsKeysUnsorted = bsksUnsorted;
-  values.clear();
-  values.resize(bindingsKeys.size());
-  counts.clear();
-  counts.resize(bindingsKeys.size());
   offsets.clear();
   offsets.resize(bindingsKeys.size());
   sizes.clear();
@@ -97,8 +87,6 @@ void ArrowTableSlicingCache::setCaches(Cache&& bsks, Cache&& bsksUnsorted)
 
 arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<arrow::Table> const& table)
 {
-  values[pos].reset();
-  counts[pos].reset();
   offsets[pos].clear();
   sizes[pos].clear();
   if (table->num_rows() == 0) {
@@ -109,41 +97,50 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
     throw runtime_error_f("Disabled cache %s/%s update requested", b.c_str(), k.c_str());
   }
   validateOrder(bindingsKeys[pos], table);
-  arrow::Datum value_counts;
-  auto options = arrow::compute::ScalarAggregateOptions::Defaults();
-  ARROW_ASSIGN_OR_RAISE(value_counts,
-                        arrow::compute::CallFunction("value_counts", {table->GetColumnByName(bindingsKeys[pos].key)},
-                                                     &options));
-  auto pair = static_cast<arrow::StructArray>(value_counts.array());
-  values[pos].reset();
-  counts[pos].reset();
-  values[pos] = std::make_shared<arrow::NumericArray<arrow::Int32Type>>(pair.field(0)->data());
-  counts[pos] = std::make_shared<arrow::NumericArray<arrow::Int64Type>>(pair.field(1)->data());
 
   int maxValue = -1;
-  for (auto i = values[pos]->length() - 1; i >= 0; --i) {
-    if (values[pos]->Value(i) < 0) {
-      continue;
-    } else {
-      maxValue = values[pos]->Value(i);
+  auto column = table->GetColumnByName(k);
+
+  // starting from the end, find the first positive value, in a sorted column it is the largest index
+  for (auto iChunk = column->num_chunks() - 1; iChunk >= 0; --iChunk) {
+    auto chunk = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(iChunk)->data());
+    for (auto iElement = chunk.length() - 1; iElement >= 0; --iElement) {
+      auto value = chunk.Value(iElement);
+      if (value < 0) {
+        continue;
+      } else {
+        maxValue = value;
+        break;
+      }
+    }
+    if (maxValue >= 0) {
       break;
     }
   }
 
   offsets[pos].resize(maxValue + 1);
   sizes[pos].resize(maxValue + 1);
-  std::fill(offsets[pos].begin(), offsets[pos].end(), 0);
-  std::fill(sizes[pos].begin(), sizes[pos].end(), 0);
-  int64_t offset = 0;
-  for (auto i = 0U; i < values[pos]->length(); ++i) {
-    auto value = values[pos]->Value(i);
-    auto count = counts[pos]->Value(i);
-    if (value >= 0) {
-      offsets[pos][value] = offset;
-      sizes[pos][value] = count;
+
+  // loop over the index and collect size/offset
+  int lastValue = std::numeric_limits<int>::max();
+  int globalRow = 0;
+  for (auto iChunk = 0; iChunk < column->num_chunks(); ++iChunk) {
+    auto chunk = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(iChunk)->data());
+    for (auto iElement = 0; iElement < chunk.length(); ++iElement) {
+      auto v = chunk.Value(iElement);
+      if (v >= 0) {
+        if (v == lastValue) {
+          ++sizes[pos][v];
+        } else {
+          lastValue = v;
+          ++sizes[pos][v];
+          offsets[pos][v] = globalRow;
+        }
+      }
+      ++globalRow;
     }
-    offset += count;
   }
+
   return arrow::Status::OK();
 }
 
@@ -238,13 +235,6 @@ SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedFor(const Entry& bi
 
 SliceInfoPtr ArrowTableSlicingCache::getCacheForPos(int pos) const
 {
-  if (values[pos] == nullptr && counts[pos] == nullptr) {
-    return {
-      {}, //
-      {}  //
-    };
-  }
-
   return {
     gsl::span{offsets[pos].data(), offsets[pos].size()}, //
     gsl::span(sizes[pos].data(), sizes[pos].size())      //

From db05c58f0f5f906dd717e3f68e23a29a706fa610 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 2 Sep 2025 13:28:35 +0200
Subject: [PATCH 0780/1764] Fix inconsistencies in the HelixHelper

---
 .../DCAFitter/include/DCAFitter/HelixHelper.h   | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/Common/DCAFitter/include/DCAFitter/HelixHelper.h b/Common/DCAFitter/include/DCAFitter/HelixHelper.h
index bd710e459ac54..d197cba256c0e 100644
--- a/Common/DCAFitter/include/DCAFitter/HelixHelper.h
+++ b/Common/DCAFitter/include/DCAFitter/HelixHelper.h
@@ -63,9 +63,10 @@ struct CrossInfo {
   {
     const auto& trcA = trax0.rC > trax1.rC ? trax0 : trax1; // designate the largest circle as A
     const auto& trcB = trax0.rC > trax1.rC ? trax1 : trax0;
+    nDCA = 0;
     float xDist = trcB.xC - trcA.xC, yDist = trcB.yC - trcA.yC;
     float dist2 = xDist * xDist + yDist * yDist, dist = o2::gpu::GPUCommonMath::Sqrt(dist2), rsum = trcA.rC + trcB.rC;
-    if (o2::gpu::GPUCommonMath::Sqrt(dist) < 1e-12) {
+    if (dist < 1e-12) {
       return nDCA; // circles are concentric?
     }
     if (dist > rsum) { // circles don't touch, chose a point in between
@@ -75,9 +76,13 @@ struct CrossInfo {
         return nDCA;
       }
       notTouchingXY(dist, xDist, yDist, trcA, trcB.rC, isCollinear);
-    } else if (dist + trcB.rC < trcA.rC) { // the small circle is nestled into large one w/o touching
-      // select the point of closest approach of 2 circles
-      notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC, isCollinear);
+    } else if (auto dfr = dist + trcB.rC - trcA.rC; dfr < 0.) { // the small circle is nestled into large one w/o touching
+      if (dfr > -maxDistXY) {
+        // select the point of closest approach of 2 circles
+        notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC, isCollinear);
+      } else {
+        return nDCA;
+      }
     } else { // 2 intersection points
       if (isCollinear) {
         /// collinear tracks, e.g. electrons from photon conversion
@@ -89,7 +94,7 @@ struct CrossInfo {
         xDCA[0] = r2_r * trcA.xC + r1_r * trcB.xC;
         yDCA[0] = r2_r * trcA.yC + r1_r * trcB.yC;
         nDCA = 1;
-      } else if (o2::gpu::GPUCommonMath::Sqrt(xDist) < o2::gpu::GPUCommonMath::Sqrt(yDist)) {
+      } else if (o2::gpu::GPUCommonMath::Abs(xDist) < o2::gpu::GPUCommonMath::Abs(yDist)) {
         // to simplify calculations, we move to new frame x->x+Xc0, y->y+Yc0, so that
         // the 1st one is centered in origin
         float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * yDist), b = -xDist / yDist, ab = a * b, bb = b * b;
@@ -167,7 +172,7 @@ struct CrossInfo {
     ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
     ///  zL(t) = zL + t Kz;  Kz = tgl / csp
     ///  Note that Kx^2 + Ky^2 + Kz^2 = (1+tgl^2) / csp^2
-
+    nDCA = 0;
     float dx = trax1.xC - trax0.xC; // for straight line TrackAuxPar stores lab coordinates at referene point!!!
     float dy = trax1.yC - trax0.yC; //
     float dz = tr1.getZ() - tr0.getZ();

From 1cfbc1d9787cc147823a439eb7e44009bc78fac1 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 4 Sep 2025 07:55:48 +0200
Subject: [PATCH 0781/1764] ITS: make CA tracker the default

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/workflow/include/ITSWorkflow/RecoWorkflow.h       | 2 +-
 Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx        | 8 ++++----
 Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx   | 7 ++++---
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
index 0ab48d713f7c7..011ee6b88ff6f 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
@@ -26,7 +26,7 @@ namespace its
 namespace reco_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC, bool useCAtracker, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
+framework::WorkflowSpec getWorkflow(bool useMC, bool useCMtracker, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
                                     bool upstreamDigits = false, bool upstreamClusters = false, bool disableRootOutput = false, bool useGeom = false, int useTrig = 0,
                                     bool useGPUWF = false, o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index 948d2c1b53009..f375eaf67c04f 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -29,7 +29,7 @@ namespace o2::its::reco_workflow
 {
 
 framework::WorkflowSpec getWorkflow(bool useMC,
-                                    bool useCAtracker,
+                                    bool useCMtracker,
                                     TrackingMode::Type trmode,
                                     const bool overrideBeamPosition,
                                     bool upstreamDigits,
@@ -51,7 +51,9 @@ framework::WorkflowSpec getWorkflow(bool useMC,
     specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
   }
   if ((trmode != TrackingMode::Off) && (TrackerParamConfig::Instance().trackingMode != TrackingMode::Off)) {
-    if (useCAtracker) {
+    if (useCMtracker) {
+      specs.emplace_back(o2::its::getCookedTrackerSpec(useMC, useGeom, useTrig, trmode));
+    } else {
       if (useGPUWF) {
         o2::gpu::GPURecoWorkflowSpec::Config cfg{
           .itsTriggerType = useTrig,
@@ -83,8 +85,6 @@ framework::WorkflowSpec getWorkflow(bool useMC,
       } else {
         specs.emplace_back(o2::its::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
       }
-    } else {
-      specs.emplace_back(o2::its::getCookedTrackerSpec(useMC, useGeom, useTrig, trmode));
     }
     if (!disableRootOutput) {
       specs.emplace_back(o2::its::getTrackWriterSpec(useMC));
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
index b7d72eb3618db..4b9053436d44c 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
@@ -41,7 +41,8 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"clusters-from-upstream", o2::framework::VariantType::Bool, false, {"clusters will be provided from upstream, skip clusterizer"}},
     {"disable-root-output", o2::framework::VariantType::Bool, false, {"do not write output root files"}},
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}},
-    {"trackerCA", o2::framework::VariantType::Bool, false, {"use trackerCA (default: trackerCM)"}},
+    {"trackerCA", o2::framework::VariantType::Bool, false, {"use trackerCA (deprecated)"}}, // keep this around to not break scripts
+    {"trackerCM", o2::framework::VariantType::Bool, false, {"use trackerCM (default: trackerCA)"}},
     {"ccdb-meanvertex-seed", o2::framework::VariantType::Bool, false, {"use MeanVertex from CCDB if available to provide beam position seed (default: false)"}},
     {"select-with-triggers", o2::framework::VariantType::String, "none", {"use triggers to prescale processed ROFs: phys, trd, none"}},
     {"tracking-mode", o2::framework::VariantType::String, "sync", {"sync,async,cosmics,unset,off"}},
@@ -64,7 +65,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // Update the (declared) parameters if changed from the command line
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   auto beamPosOVerride = configcontext.options().get<bool>("ccdb-meanvertex-seed");
-  auto useCAtracker = configcontext.options().get<bool>("trackerCA");
+  auto useCMtracker = configcontext.options().get<bool>("trackerCM");
   auto trmode = configcontext.options().get<std::string>("tracking-mode");
   auto selTrig = configcontext.options().get<std::string>("select-with-triggers");
   auto useGpuWF = configcontext.options().get<bool>("use-gpu-workflow");
@@ -89,7 +90,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     }
   }
   auto wf = o2::its::reco_workflow::getWorkflow(useMC,
-                                                useCAtracker,
+                                                useCMtracker,
                                                 o2::its::TrackingMode::fromString(trmode),
                                                 beamPosOVerride,
                                                 extDigits,

From c1cd2a6fa4efb8f01643ab69e2698fe273c79f28 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 5 Sep 2025 01:48:56 +0200
Subject: [PATCH 0782/1764] With -condition-use-slice-for-prescaling <N> use TF
 slice instead of TFcounter for CCDB cache validation is N!=0

If --condition-tf-per-query-multiplier value is negative, the prescaling is simply
applied to tfCounter%|query_rate| (or timeslice%|query_rate| if --condition-use-slice-for-prescaling is asked)

If N>0, then enforce a check if the abs difference between the last checked and current TFCounters (not slices!) exceeds N,
even if the slices difference is less than the requested check rate.
---
 .../CCDBSupport/src/CCDBFetcherHelper.cxx     | 28 +++++++++++--
 Framework/CCDBSupport/src/CCDBFetcherHelper.h |  2 +
 Framework/CCDBSupport/src/CCDBHelpers.cxx     | 41 +++++++++++++++----
 Framework/Core/src/WorkflowHelpers.cxx        |  6 ++-
 4 files changed, 62 insertions(+), 15 deletions(-)

diff --git a/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx b/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
index 14c3fefb31024..92aff08a26032 100644
--- a/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
+++ b/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
@@ -51,10 +51,20 @@ void CCDBFetcherHelper::initialiseHelper(CCDBFetcherHelper& helper, ConfigParamR
   auto defHost = options.get<std::string>("condition-backend");
   auto checkRate = options.get<int>("condition-tf-per-query");
   auto checkMult = options.get<int>("condition-tf-per-query-multiplier");
+  helper.useTFSlice = options.get<int>("condition-use-slice-for-prescaling");
   helper.timeToleranceMS = options.get<int64_t>("condition-time-tolerance");
   helper.queryPeriodGlo = checkRate > 0 ? checkRate : std::numeric_limits<int>::max();
-  helper.queryPeriodFactor = checkMult > 0 ? checkMult : 1;
-  LOGP(info, "CCDB Backend at: {}, validity check for every {} TF{}", defHost, helper.queryPeriodGlo, helper.queryPeriodFactor == 1 ? std::string{} : fmt::format(", (query for high-rate objects downscaled by {})", helper.queryPeriodFactor));
+  helper.queryPeriodFactor = checkMult == 0 ? 1 : checkMult;
+  std::string extraCond{};
+  if (helper.useTFSlice) {
+    extraCond = ". Use TFSlice";
+    if (helper.useTFSlice > 0) {
+      extraCond += fmt::format(" + max TFcounter jump <= {}", helper.useTFSlice);
+    }
+  }
+  LOGP(info, "CCDB Backend at: {}, validity check for every {} TF{}{}", defHost, helper.queryPeriodGlo,
+       helper.queryPeriodFactor == 1 ? std::string{} : (helper.queryPeriodFactor > 0 ? fmt::format(", (query for high-rate objects downscaled by {})", helper.queryPeriodFactor) : fmt::format(", (query downscaled as TFcounter%{})", -helper.queryPeriodFactor)),
+       extraCond);
   LOGP(info, "Hook to enable signposts for CCDB messages at {}", (void*)&private_o2_log_ccdb->stacktrace);
   auto remapString = options.get<std::string>("condition-remap");
   ParserResult result = parseRemappings(remapString.c_str());
@@ -205,12 +215,21 @@ auto CCDBFetcherHelper::populateCacheWith(std::shared_ptr<CCDBFetcherHelper> con
       // If timestamp is before the time the element was cached or after the claimed validity, we need to check validity, again
       // when online.
       bool cacheExpired = (validUntil <= timestampToUse) || (op.timestamp < cachePopulatedAt);
-      checkValidity = (std::abs(int(timingInfo.tfCounter - url2uuid->second.lastCheckedTF)) >= chRate) && (isOnline || cacheExpired);
+      if (isOnline || cacheExpired) {
+        if (!helper->useTFSlice) {
+          checkValidity = chRate > 0 ? (std::abs(int(timingInfo.tfCounter - url2uuid->second.lastCheckedTF)) >= chRate) : (timingInfo.tfCounter % -chRate) == 0;
+        } else {
+          checkValidity = chRate > 0 ? (std::abs(int(timingInfo.timeslice - url2uuid->second.lastCheckedSlice)) >= chRate) : (timingInfo.timeslice % -chRate) == 0;
+          if (!checkValidity && helper->useTFSlice > std::abs(chRate)) { // make sure the interval is tolerated unless the check rate itself is too large
+            checkValidity = std::abs(int(timingInfo.tfCounter) - url2uuid->second.lastCheckedTF) > helper->useTFSlice;
+          }
+        }
+      }
     } else {
       checkValidity = true; // never skip check if the cache is empty
     }
 
-    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tfID %d of %{public}s", checkValidity ? "true" : "false", timingInfo.tfCounter, path.data());
+    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tf%{public}s %d of %{public}s", checkValidity ? "true" : "false", helper->useTFSlice ? "ID" : "Slice", helper->useTFSlice ? timingInfo.timeslice : timingInfo.tfCounter, path.data());
 
     const auto& api = helper->getAPI(path);
     if (checkValidity && (!api.isSnapshotMode() || etag.empty())) { // in the snapshot mode the object needs to be fetched only once
@@ -226,6 +245,7 @@ auto CCDBFetcherHelper::populateCacheWith(std::shared_ptr<CCDBFetcherHelper> con
         LOGP(detail, "******** Default entry used for {} ********", path);
       }
       helper->mapURL2UUID[path].lastCheckedTF = timingInfo.tfCounter;
+      helper->mapURL2UUID[path].lastCheckedSlice = timingInfo.timeslice;
       if (etag.empty()) {
         helper->mapURL2UUID[path].etag = headers["ETag"]; // update uuid
         helper->mapURL2UUID[path].cachePopulatedAt = timestampToUse;
diff --git a/Framework/CCDBSupport/src/CCDBFetcherHelper.h b/Framework/CCDBSupport/src/CCDBFetcherHelper.h
index e3453b48bf156..1778712f45002 100644
--- a/Framework/CCDBSupport/src/CCDBFetcherHelper.h
+++ b/Framework/CCDBSupport/src/CCDBFetcherHelper.h
@@ -33,6 +33,7 @@ struct CCDBFetcherHelper {
     size_t minSize = -1ULL;
     size_t maxSize = 0;
     int lastCheckedTF = 0;
+    int lastCheckedSlice = 0;
   };
 
   struct RemapMatcher {
@@ -94,6 +95,7 @@ struct CCDBFetcherHelper {
   int queryPeriodGlo = 1;
   int queryPeriodFactor = 1;
   int64_t timeToleranceMS = 5000;
+  int useTFSlice = 0; // if non-zero, use TFslice instead of TFcounter for the validity check. If > requested checking rate, add additional check on |lastTFchecked - TCcounter|<=useTFSlice
 
   o2::ccdb::CcdbApi& getAPI(const std::string& path);
   static void initialiseHelper(CCDBFetcherHelper& helper, ConfigParamRegistry const& options);
diff --git a/Framework/CCDBSupport/src/CCDBHelpers.cxx b/Framework/CCDBSupport/src/CCDBHelpers.cxx
index acf8b782f8f06..d303308df0c82 100644
--- a/Framework/CCDBSupport/src/CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/CCDBHelpers.cxx
@@ -39,6 +39,7 @@ struct CCDBFetcherHelper {
     size_t minSize = -1ULL;
     size_t maxSize = 0;
     int lastCheckedTF = 0;
+    int lastCheckedSlice = 0;
   };
 
   struct RemapMatcher {
@@ -60,6 +61,7 @@ struct CCDBFetcherHelper {
   int queryPeriodGlo = 1;
   int queryPeriodFactor = 1;
   int64_t timeToleranceMS = 5000;
+  int useTFSlice = 0; // if non-zero, use TFslice instead of TFcounter for the validity check. If > requested checking rate, add additional check on |lastTFchecked - TCcounter|<=useTFSlice
 
   o2::ccdb::CcdbApi& getAPI(const std::string& path)
   {
@@ -165,10 +167,20 @@ void initialiseHelper(CCDBFetcherHelper& helper, ConfigParamRegistry const& opti
   auto defHost = options.get<std::string>("condition-backend");
   auto checkRate = options.get<int>("condition-tf-per-query");
   auto checkMult = options.get<int>("condition-tf-per-query-multiplier");
+  helper.useTFSlice = options.get<int>("condition-use-slice-for-prescaling");
   helper.timeToleranceMS = options.get<int64_t>("condition-time-tolerance");
   helper.queryPeriodGlo = checkRate > 0 ? checkRate : std::numeric_limits<int>::max();
-  helper.queryPeriodFactor = checkMult > 0 ? checkMult : 1;
-  LOGP(info, "CCDB Backend at: {}, validity check for every {} TF{}", defHost, helper.queryPeriodGlo, helper.queryPeriodFactor == 1 ? std::string{} : fmt::format(", (query for high-rate objects downscaled by {})", helper.queryPeriodFactor));
+  helper.queryPeriodFactor = checkMult == 0 ? 1 : checkMult;
+  std::string extraCond{};
+  if (helper.useTFSlice) {
+    extraCond = ". Use TFSlice";
+    if (helper.useTFSlice > 0) {
+      extraCond += fmt::format(" + max TFcounter jump <= {}", helper.useTFSlice);
+    }
+  }
+  LOGP(info, "CCDB Backend at: {}, validity check for every {} TF{}{}", defHost, helper.queryPeriodGlo,
+       helper.queryPeriodFactor == 1 ? std::string{} : (helper.queryPeriodFactor > 0 ? fmt::format(", (query for high-rate objects downscaled by {})", helper.queryPeriodFactor) : fmt::format(", (query downscaled as TFcounter%{})", -helper.queryPeriodFactor)),
+       extraCond);
   LOGP(info, "Hook to enable signposts for CCDB messages at {}", (void*)&private_o2_log_ccdb->stacktrace);
   auto remapString = options.get<std::string>("condition-remap");
   CCDBHelpers::ParserResult result = CCDBHelpers::parseRemappings(remapString.c_str());
@@ -276,7 +288,7 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
         O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "Adding metadata %{public}s: %{public}s to the request", key.data(), value.data());
         metadata[key] = value;
       } else if (meta.name == "ccdb-query-rate") {
-        chRate = meta.defaultValue.get<int>() * helper->queryPeriodFactor;
+        chRate = std::max(1, meta.defaultValue.get<int>()) * helper->queryPeriodFactor;
       }
     }
     const auto url2uuid = helper->mapURL2UUID.find(path);
@@ -289,12 +301,21 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
       // If timestamp is before the time the element was cached or after the claimed validity, we need to check validity, again
       // when online.
       bool cacheExpired = (validUntil <= timestampToUse) || (timestamp < cachePopulatedAt);
-      checkValidity = (std::abs(int(timingInfo.tfCounter - url2uuid->second.lastCheckedTF)) >= chRate) && (isOnline || cacheExpired);
+      if (isOnline || cacheExpired) {
+        if (!helper->useTFSlice) {
+          checkValidity = chRate > 0 ? (std::abs(int(timingInfo.tfCounter - url2uuid->second.lastCheckedTF)) >= chRate) : (timingInfo.tfCounter % -chRate) == 0;
+        } else {
+          checkValidity = chRate > 0 ? (std::abs(int(timingInfo.timeslice - url2uuid->second.lastCheckedSlice)) >= chRate) : (timingInfo.timeslice % -chRate) == 0;
+          if (!checkValidity && helper->useTFSlice > std::abs(chRate)) { // make sure the interval is tolerated unless the check rate itself is too large
+            checkValidity = std::abs(int(timingInfo.tfCounter) - url2uuid->second.lastCheckedTF) > helper->useTFSlice;
+          }
+        }
+      }
     } else {
       checkValidity = true; // never skip check if the cache is empty
     }
 
-    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tfID %d of %{public}s", checkValidity ? "true" : "false", timingInfo.tfCounter, path.data());
+    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tf%{public}s %d of %{public}s", checkValidity ? "true" : "false", helper->useTFSlice ? "ID" : "Slice", helper->useTFSlice ? timingInfo.timeslice : timingInfo.tfCounter, path.data());
 
     const auto& api = helper->getAPI(path);
     if (checkValidity && (!api.isSnapshotMode() || etag.empty())) { // in the snapshot mode the object needs to be fetched only once
@@ -310,6 +331,7 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
         LOGP(detail, "******** Default entry used for {} ********", path);
       }
       helper->mapURL2UUID[path].lastCheckedTF = timingInfo.tfCounter;
+      helper->mapURL2UUID[path].lastCheckedSlice = timingInfo.timeslice;
       if (etag.empty()) {
         helper->mapURL2UUID[path].etag = headers["ETag"]; // update uuid
         helper->mapURL2UUID[path].cachePopulatedAt = timestampToUse;
@@ -382,21 +404,22 @@ AlgorithmSpec CCDBHelpers::fetchFromCCDB()
           std::map<std::string, std::string> metadata;
           std::map<std::string, std::string> headers;
           std::string etag;
-          bool checkValidity = std::abs(int(timingInfo.tfCounter - helper->lastCheckedTFCounterOrbReset)) >= helper->queryPeriodGlo;
+          int32_t counter = helper->useTFSlice ? timingInfo.timeslice : timingInfo.tfCounter;
+          bool checkValidity = std::abs(int(counter - helper->lastCheckedTFCounterOrbReset)) >= helper->queryPeriodGlo;
           const auto url2uuid = helper->mapURL2UUID.find(path);
           if (url2uuid != helper->mapURL2UUID.end()) {
             etag = url2uuid->second.etag;
           } else {
             checkValidity = true; // never skip check if the cache is empty
           }
-          O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "fetchFromCCDB", "checkValidity is %{public}s for tfID %d of %{public}s",
-                                 checkValidity ? "true" : "false", timingInfo.tfCounter, path.data());
+          O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "fetchFromCCDB", "checkValidity is %{public}s for tf%{public}s %d of %{public}s",
+                                 checkValidity ? "true" : "false", helper->useTFSlice ? "ID" : "Slice", counter, path.data());
           Output output{"CTP", "OrbitReset", 0};
           Long64_t newOrbitResetTime = orbitResetTime;
           auto&& v = allocator.makeVector<char>(output);
           const auto& api = helper->getAPI(path);
           if (checkValidity && (!api.isSnapshotMode() || etag.empty())) { // in the snapshot mode the object needs to be fetched only once
-            helper->lastCheckedTFCounterOrbReset = timingInfo.tfCounter;
+            helper->lastCheckedTFCounterOrbReset = counter;
             api.loadFileToMemory(v, path, metadata, timingInfo.creation, &headers, etag, helper->createdNotAfter, helper->createdNotBefore);
             if ((headers.count("Error") != 0) || (etag.empty() && v.empty())) {
               LOGP(fatal, "Unable to find CCDB object {}/{}", path, timingInfo.creation);
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 6eda838070f6d..36583035c41ff 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -177,7 +177,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
                 {"condition-not-after", VariantType::Int64, 3385078236000ll, {"do not fetch from CCDB objects created after the timestamp"}},
                 {"condition-remap", VariantType::String, "", {"remap condition path in CCDB based on the provided string."}},
                 {"condition-tf-per-query", VariantType::Int, defaultConditionQueryRate(), {"check condition validity per requested number of TFs, fetch only once if <=0"}},
-                {"condition-tf-per-query-multiplier", VariantType::Int, defaultConditionQueryRateMultiplier(), {"check conditions once per this amount of nominal checks"}},
+                {"condition-tf-per-query-multiplier", VariantType::Int, defaultConditionQueryRateMultiplier(), {"check conditions once per this amount of nominal checks (>0) or on module of TFcounter (<0)"}},
+                {"condition-use-slice-for-prescaling", VariantType::Int, 0, {"use TFslice instead of TFcounter to control validation frequency. If > query rate, do not allow TFCounter excursion exceeding it"}},
                 {"condition-time-tolerance", VariantType::Int64, 5000ll, {"prefer creation time if its difference to orbit-derived time exceeds threshold (ms), impose if <0"}},
                 {"orbit-offset-enumeration", VariantType::Int64, 0ll, {"initial value for the orbit"}},
                 {"orbit-multiplier-enumeration", VariantType::Int64, 0ll, {"multiplier to get the orbit from the counter"}},
@@ -195,7 +196,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
                 {"condition-not-after", VariantType::Int64, 3385078236000ll, {"do not fetch from CCDB objects created after the timestamp"}},
                 {"condition-remap", VariantType::String, "", {"remap condition path in CCDB based on the provided string."}},
                 {"condition-tf-per-query", VariantType::Int, defaultConditionQueryRate(), {"check condition validity per requested number of TFs, fetch only once if <=0"}},
-                {"condition-tf-per-query-multiplier", VariantType::Int, defaultConditionQueryRateMultiplier(), {"check conditions once per this amount of nominal checks"}},
+                {"condition-tf-per-query-multiplier", VariantType::Int, defaultConditionQueryRateMultiplier(), {"check conditions once per this amount of nominal checks (>0) or on module of TFcounter (<0)"}},
+                {"condition-use-slice-for-prescaling", VariantType::Int, 0, {"use TFslice instead of TFcounter to control validation frequency. If > query rate, do not allow TFCounter excursion exceeding it"}},
                 {"condition-time-tolerance", VariantType::Int64, 5000ll, {"prefer creation time if its difference to orbit-derived time exceeds threshold (ms), impose if <0"}},
                 {"start-value-enumeration", VariantType::Int64, 0ll, {"initial value for the enumeration"}},
                 {"end-value-enumeration", VariantType::Int64, -1ll, {"final value for the enumeration"}},

From 642abba64f9b2e5c4078afb88062b5dcf94b8527 Mon Sep 17 00:00:00 2001
From: Ivana Hrivnacova <Ivana.Hrivnacova@cern.ch>
Date: Tue, 2 Sep 2025 10:11:00 +0200
Subject: [PATCH 0783/1764] Removed work-around in FindGeant4.cmake

- Not needed with Geant4 versions 11.x
---
 dependencies/FindGeant4.cmake | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dependencies/FindGeant4.cmake b/dependencies/FindGeant4.cmake
index e9ac4600670e4..0abd8ddfe1ea0 100644
--- a/dependencies/FindGeant4.cmake
+++ b/dependencies/FindGeant4.cmake
@@ -23,7 +23,6 @@ set_target_properties(geant4
                       PROPERTIES INTERFACE_INCLUDE_DIRECTORIES
                                  "${Geant4_INCLUDE_DIRS}")
 
-list(GET Geant4_INCLUDE_DIRS 0 Geant4_INCLUDE_DIR)
 set(Geant4_LIBRARY_DIRS)
 foreach(gl4lib IN LISTS Geant4_LIBRARIES)
   find_library(gl4libpath NAMES ${gl4lib} PATHS "${Geant4_INCLUDE_DIR}/../.."

From 1f95ef561e089a25bba708d402acd0869f8f9613 Mon Sep 17 00:00:00 2001
From: Sergio Garcia <47090312+singiamtel@users.noreply.github.com>
Date: Tue, 9 Sep 2025 12:30:57 +0200
Subject: [PATCH 0784/1764] Remove old Jenkinsfile (#14642)

---
 Jenkinsfile | 76 -----------------------------------------------------
 1 file changed, 76 deletions(-)
 delete mode 100644 Jenkinsfile

diff --git a/Jenkinsfile b/Jenkinsfile
deleted file mode 100644
index 1025790950608..0000000000000
--- a/Jenkinsfile
+++ /dev/null
@@ -1,76 +0,0 @@
-#!groovy
-
-node {
-  stage "Verify author"
-  def power_users = [
-    "Barthelemy",
-    "MohammadAlTurany",
-    "PatrykLesiak",
-    "bovulpes",
-    "dberzano",
-    "iouribelikov",
-    "ktf",
-    "matthiasrichter",
-    "mkrzewic",
-    "mpuccio",
-    "rbx",
-    "sawenzel",
-    "wiechula"
-  ]
-  echo "Changeset from " + env.CHANGE_AUTHOR
-  if (power_users.contains(env.CHANGE_AUTHOR)) {
-    currentBuild.displayName = "Testing ${env.BRANCH_NAME} from ${env.CHANGE_AUTHOR}"
-    echo "PR comes from power user. Testing"
-  } else {
-    currentBuild.displayName = "Feedback needed for ${env.BRANCH_NAME} from ${env.CHANGE_AUTHOR}"
-    input "Do you want to test this change?"
-  }
-  currentBuild.displayName = "Testing ${env.BRANCH_NAME} from ${env.CHANGE_AUTHOR}"
-
-  stage "Build AliceO2"
-  def test_script = '''
-      rm -fr alibuild alidist
-      git clone https://github.com/alisw/alibuild
-      git clone -b IB/v5-08/o2 https://github.com/alisw/alidist
-      x=`date +"%s"`
-      WORKAREA=/build/workarea/pr/`echo $(( $x / 3600 / 24 / 7))`
-
-      # Make sure we have only one builder per directory
-      CURRENT_SLAVE=unknown
-      while [[ "$CURRENT_SLAVE" != '' ]]; do
-        WORKAREA_INDEX=$((WORKAREA_INDEX+1))
-        CURRENT_SLAVE=$(cat $WORKAREA/$WORKAREA_INDEX/current_slave 2> /dev/null || true)
-        [[ "$CURRENT_SLAVE" == "$NODE_NAME" ]] && CURRENT_SLAVE=
-      done
-
-      mkdir -p $WORKAREA/$WORKAREA_INDEX
-      echo $NODE_NAME > $WORKAREA/$WORKAREA_INDEX/current_slave
-
-      alibuild/aliBuild --work-dir $WORKAREA/$WORKAREA_INDEX               \
-                        --reference-sources /build/mirror                  \
-                        --debug                                            \
-                        --jobs 16                                          \
-                        --remote-store rsync://repo.marathon.mesos/store/  \
-                        --defaults o2                                      \
-                        -d build O2 || BUILDERR=$?
-
-      rm -f $WORKAREA/$WORKAREA_INDEX/current_slave
-      if [ ! "X$BUILDERR" = X ]; then
-        exit $BUILDERR
-      fi
-    '''
-
-  currentBuild.displayName = "Testing ${env.BRANCH_NAME}"
-  parallel(
-    "slc7": {
-      node ("slc7_x86-64-large") {
-        dir ("O2") {
-          checkout scm
-        }
-        withEnv (["CHANGE_TARGET=${env.CHANGE_TARGET}"]) {
-          sh test_script
-        }
-      }
-    }
-  )
-}

From cc7210c48bf6e80024d12f5af1d887cc99a33ca4 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Tue, 9 Sep 2025 14:46:54 +0200
Subject: [PATCH 0785/1764] NN clusterizer: Fixing memory access faults
 (#14657)

* Adding verbosity and fixing off-by-one error

* removing unnecessary include, using GPUCommonLogger to fix CI build

* GetGrid spawns more threads than actual number -> Most probably explains out-of-bounds accesses and memory faults

* Fixing smem usage from CFClusterizer and adding rejection flag -> No out-of-bounds in QC anymore

* Adjusting kernels for GPU safe rejection

* Please consider the following formatting changes

* Casting to avoid CI build failures

* Changing formatter to not use std::

* Remove usage of std::

* Adding back the runParallelOuterLoop

* Declaring CfChargePos as struct, not class

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Common/ML/src/OrtInterface.cxx                |   2 +-
 GPU/GPUTracking/Definitions/GPUSettingsList.h |   4 +-
 .../Global/GPUChainTrackingClusterizer.cxx    |  44 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.cxx  |   2 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.h    |   2 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.inc  |   6 +-
 .../TPCClusterFinder/GPUTPCNNClusterizer.cxx  |  83 +++
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |   2 +-
 .../GPUTPCNNClusterizerKernels.cxx            | 490 ++++++++++--------
 .../GPUTPCNNClusterizerKernels.h              |  13 +-
 10 files changed, 399 insertions(+), 249 deletions(-)

diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index 58d80eb9c0bf0..d30d05d1d1a00 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -54,7 +54,7 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
 
   // Load from options map
   if (!optionsMap.contains("model-path")) {
-    LOG(fatal) << "(ORT) Model path cannot be empty!";
+    LOG(fatal) << "(ORT) Model path must be contained in options map!";
   }
 
   if (!optionsMap["model-path"].empty()) {
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 65697b7f7c08b..6419d63bb7ada 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -259,7 +259,7 @@ AddOption(nnInferenceEnableOrtOptimization, unsigned int, 99, "", 0, "Enables gr
 AddOption(nnInferenceUseDeterministicCompute, int, 0, "", 0, "Enables deterministic compute in ONNX Runtime were possible. Can be [0, 1] -> see https://github.com/microsoft/onnxruntime/blob/3b97d79b3c12dbf93aa0d563f345714596dc8ab6/onnxruntime/core/framework/session_options.h#L208")
 AddOption(nnInferenceOrtProfiling, int, 0, "", 0, "Enables profiling of model execution in ONNX Runtime")
 AddOption(nnInferenceOrtProfilingPath, std::string, ".", "", 0, "If nnInferenceOrtProfiling is set, the path to store the profiling data")
-AddOption(nnInferenceVerbosity, int, 1, "", 0, "0: No messages; 1: Warnings; 2: Warnings + major debugs; >3: All debugs")
+AddOption(nnInferenceVerbosity, int, 2, "", 0, "0: All debugs; 1: Warnings + major debugs; 2: Warnings; >=3: No messages")
 AddOption(nnClusterizerAddIndexData, int, 1, "", 0, "If normalized index data (sector, row, pad), should be appended to the input")
 AddOption(nnClusterizerSizeInputRow, int, 3, "", 0, "Size of the input to the NN (currently calcualted as (length-1)/2")
 AddOption(nnClusterizerSizeInputPad, int, 3, "", 0, "Size of the input to the NN (currently calcualted as (length-1)/2")
@@ -267,7 +267,7 @@ AddOption(nnClusterizerSizeInputTime, int, 3, "", 0, "Size of the input to the N
 AddOption(nnClusterizerUseCfRegression, int, 0, "", 0, "(bool, default = false) If true, use the regression from the native clusterizer and not the NN")
 AddOption(nnClusterizerApplyCfDeconvolution, int, 0, "", 0, "Applies the CFDeconvolution kernel before the digits to the network are filled")
 AddOption(nnClusterizerBatchedMode, unsigned int, 1, "", 0, "(int, default = 1) If >1, the NN is evaluated on batched input of size specified in this variable")
-AddOption(nnClusterizerVerbosity, int, -1, "", 0, "(int, default = -1) If >0, logging messages of the clusterizer will be displayed")
+AddOption(nnClusterizerVerbosity, int, -1, "", 0, "(int, default = -1) If >0, logging messages of the clusterizer will be displayed. Higher number = higher verbosity")
 AddOption(nnClusterizerBoundaryFillValue, int, -1, "", 0, "Fill value for the boundary of the input to the NN")
 AddOption(nnClusterizerApplyNoiseSuppression, int, 1, "", 0, "Applies the NoiseSuppression kernel before the digits to the network are filled")
 AddOption(nnClusterizerSetDeconvolutionFlags, int, 1, "", 0, "Runs the deconvolution kernel without overwriting the charge in order to make cluster-to-track attachment identical to heuristic CF")
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index c92049b040c46..fd3699ae4d125 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -43,7 +43,6 @@
 #include "DataFormatsTPC/Digit.h"
 #include "DataFormatsTPC/Constants.h"
 #include "TPCBase/RDHUtils.h"
-#include "GPULogging.h"
 
 #ifdef GPUCA_HAS_ONNX
 #include "GPUTPCNNClusterizerKernels.h"
@@ -706,7 +705,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         // nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
         (nnApplications[lane].mModelReg2).initSession();
       }
-      if (nn_settings.nnClusterizerVerbosity < 3) {
+      if (nn_settings.nnClusterizerVerbosity > 0) {
         LOG(info) << "(ORT) Allocated ONNX stream for lane " << lane << " and device " << deviceId;
       }
     });
@@ -724,12 +723,24 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         clustererNNShadow.mNnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
         nnApplications[lane].initClusterizer(nn_settings, clustererNNShadow);
       }
+      if (nn_settings.nnClusterizerVerbosity > 2) {
+        LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Processor initialized. Sector " << sector << ", lane " << lane << ", max clusters " << clustererNN.mNnClusterizerTotalClusters << " (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+      }
       AllocateRegisteredMemory(clustererNN.mMemoryId);
+      if (nn_settings.nnClusterizerVerbosity > 2) {
+        LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Memory registered for memoryId " << clustererNN.mMemoryId << " (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+      }
       // nnApplications[lane].createBoundary(clustererNNShadow);
       // nnApplications[lane].createIndexLookup(clustererNNShadow);
     }
     if (doGPU) {
+      if (nn_settings.nnClusterizerVerbosity > 2) {
+        LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Writing to constant memory...";
+      }
       WriteToConstantMemory(RecoStep::TPCClusterFinding, (char*)&processors()->tpcNNClusterer - (char*)processors(), &processorsShadow()->tpcNNClusterer, sizeof(GPUTPCNNClusterizer) * NSECTORS, mRec->NStreams() - 1, &mEvents->init);
+      if (nn_settings.nnClusterizerVerbosity > 2) {
+        LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Writing to constant memory done";
+      }
     }
   }
 #endif
@@ -1010,7 +1021,13 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           }
 
           // float time_clusterizer = 0, time_fill = 0, time_networks = 0;
+          if (nn_settings.nnClusterizerVerbosity > 2) {
+            LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Starting loop over batched data. clustererNNShadow.mNnClusterizerBatchedMode=" << clustererNNShadow.mNnClusterizerBatchedMode << ", numLoops=" << std::ceil((float)clusterer.mPmemory->counters.nClusters / clustererNNShadow.mNnClusterizerBatchedMode) << ", numClusters=" << clusterer.mPmemory->counters.nClusters << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+          }
           for (int batch = 0; batch < std::ceil((float)clusterer.mPmemory->counters.nClusters / clustererNNShadow.mNnClusterizerBatchedMode); batch++) {
+            if (nn_settings.nnClusterizerVerbosity > 3) {
+              LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Start. Loop=" << batch << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+            }
             uint batchStart = batch * clustererNNShadow.mNnClusterizerBatchedMode;
             size_t iSize = CAMath::Min((uint)clustererNNShadow.mNnClusterizerBatchedMode, (uint)(clusterer.mPmemory->counters.nClusters - batchStart));
 
@@ -1022,9 +1039,15 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
               // Fills the whole input matrix at once -> better performance on CPU, but worse parallelizability
               runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNCPU>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
             }
+            if (nn_settings.nnClusterizerVerbosity > 3) {
+              LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Done filling data. Loop=" << batch << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+            }
 
             if (clustererNNShadow.mNnClusterizerSetDeconvolutionFlags) {
               runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart); // Publishing the deconvolution flags
+              if (nn_settings.nnClusterizerVerbosity > 3) {
+                LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Done setting deconvolution flags. Loop=" << batch << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+              }
             }
 
             // NN evaluations
@@ -1044,6 +1067,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                 }
               }
               if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane]->Stop(); }
+              if (nn_settings.nnClusterizerVerbosity > 3) {
+                LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Done with NN classification inference. Loop=" << batch << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+              }
             }
             if (!clustererNNShadow.mNnClusterizerUseCfRegression) {
               if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 1]->Start(); }
@@ -1078,9 +1104,13 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                 }
                 if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 2]->Stop(); }
               }
+              if (nn_settings.nnClusterizerVerbosity > 3) {
+                LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Done with NN regression inference. Loop=" << batch << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+              }
             }
 
             // Publishing kernels for class labels and regression results
+            // In case classification should not be used, this kernel should still be executed to fill the mOutputDataClass array with default values
             if (nnApplication.mModelClass.getNumOutputNodes()[0][1] == 1) {
               runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::determineClass1Labels>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, propagateMCLabels, batchStart); // Assigning class labels
             } else {
@@ -1092,6 +1122,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                 runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::publishClass2Regression>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceOutputDType, propagateMCLabels, batchStart); // Publishing class 2 regression results
               }
             }
+            if (nn_settings.nnClusterizerVerbosity > 3) {
+              LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Done publishing. Loop=" << batch << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+            }
           }
 
           if (clustererNNShadow.mNnClusterizerUseCfRegression) {
@@ -1100,6 +1133,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             }
             DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererChargeMap, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Split Charges");
             runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::runCfClusterizer>({GetGrid(clusterer.mPmemory->counters.nClusters, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, 0); // Running the CF regression kernel - no batching needed: batchStart = 0
+            if (nn_settings.nnClusterizerVerbosity > 3) {
+              LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Done with CF regression. (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
+            }
           }
 #else
           GPUFatal("Project not compiled with neural network clusterization. Aborting.");
@@ -1203,7 +1239,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   for (int32_t i = 0; i < GetProcessingSettings().nTPCClustererLanes; i++) {
 #ifdef GPUCA_HAS_ONNX
     if (GetProcessingSettings().nn.applyNNclusterizer) {
-      LOG(info) << "(ORT) Environment releasing...";
+      if (GetProcessingSettings().nn.nnClusterizerVerbosity > 0) {
+        LOG(info) << "(ORT) Environment releasing...";
+      }
       GPUTPCNNClusterizerHost& nnApplication = nnApplications[i];
       nnApplication.mModelClass.release(true);
       nnApplication.mModelReg1.release(true);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
index c9c6b157499f2..49ee5957b8b36 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.cxx
@@ -35,5 +35,5 @@ GPUdii() void GPUTPCCFClusterizer::Thread<0>(int32_t nBlocks, int32_t nThreads,
 
   tpc::ClusterNative* clusterOut = (onlyMC) ? nullptr : clusterer.mPclusterByRow;
 
-  GPUTPCCFClusterizer::computeClustersImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, smem, chargeMap, clusterer.mPfilteredPeakPositions, clusterer.Param().rec, CPU_PTR(&labelAcc), clusterer.mPmemory->counters.nClusters, clusterer.mNMaxClusterPerRow, clusterer.mPclusterInRow, clusterOut, clusterer.mPclusterPosInRow);
+  GPUTPCCFClusterizer::computeClustersImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, smem, chargeMap, clusterer.mPfilteredPeakPositions, clusterer.Param().rec, CPU_PTR(&labelAcc), clusterer.mPmemory->counters.nClusters, clusterer.mNMaxClusterPerRow, clusterer.mPclusterInRow, clusterOut, clusterer.mPclusterPosInRow, true);
 }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
index 466d13d3254de..70e21db81756c 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
@@ -57,7 +57,7 @@ class GPUTPCCFClusterizer : public GPUKernelTemplate
   template <int32_t iKernel = defaultKernel>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int8_t);
 
-  static GPUd() void computeClustersImpl(int32_t, int32_t, int32_t, int32_t, processorType&, const CfFragment&, GPUSharedMemory&, const CfArray2D<PackedCharge>&, const CfChargePos*, const GPUSettingsRec&, MCLabelAccumulator*, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*, uint32_t*);
+  static GPUd() void computeClustersImpl(int32_t, int32_t, int32_t, int32_t, processorType&, const CfFragment&, GPUSharedMemory&, const CfArray2D<PackedCharge>&, const CfChargePos*, const GPUSettingsRec&, MCLabelAccumulator*, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*, uint32_t*, int8_t);
 
   static GPUd() void buildCluster(const GPUSettingsRec&, const CfArray2D<PackedCharge>&, CfChargePos, CfChargePos*, PackedCharge*, uint8_t*, ClusterAccumulator*, MCLabelAccumulator*);
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
index e32abbf37584f..c2c104809990e 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.inc
@@ -27,7 +27,8 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
                                                        uint32_t maxClusterPerRow,
                                                        uint32_t* clusterInRow,
                                                        tpc::ClusterNative* clusterByRow,
-                                                       uint32_t* clusterPosInRow)
+                                                       uint32_t* clusterPosInRow,
+                                                       int8_t isAccepted)
 {
   uint32_t idx = get_global_id(0);
 
@@ -62,6 +63,9 @@ GPUdii() void GPUTPCCFClusterizer::computeClustersImpl(int32_t nBlocks, int32_t
   tpc::ClusterNative myCluster;
   pc.finalize(pos, charge, fragment.start);
   bool rejectCluster = !pc.toNative(pos, charge, myCluster, clusterer.Param(), chargeMap);
+  if (!isAccepted) {
+    rejectCluster = true;
+  }
 
   if (rejectCluster) {
     if (clusterPosInRow) {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
index 3dd8b0d621a56..6fac0e417ac26 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.cxx
@@ -16,6 +16,7 @@
 #include "ML/3rdparty/GPUORTFloat16.h"
 #include "GPUTPCNNClusterizer.h"
 #include "GPUSettings.h"
+#include "GPUCommonLogger.h"
 
 using namespace o2::gpu;
 
@@ -25,6 +26,8 @@ void GPUTPCNNClusterizer::SetMaxData(const GPUTrackingInOutPointers& io) {}
 
 void* GPUTPCNNClusterizer::setIOPointers(void* mem)
 {
+  // Keep track of the start address to compute how much memory we assign
+  void* startMem = mem;
   if (mNnClusterizerBatchedMode > 0) {
     if (mNnInferenceInputDType == 0 && mNnClusterizerElementSize > 0) {
       computePointerWithAlignment(mem, mInputData_16, mNnClusterizerBatchedMode * mNnClusterizerElementSize);
@@ -62,6 +65,86 @@ void* GPUTPCNNClusterizer::setIOPointers(void* mem)
   if (mNnClusterizerTotalClusters > 0) {
     computePointerWithAlignment(mem, mOutputDataClass, mNnClusterizerTotalClusters);
   }
+
+  if (mNnClusterizerVerbosity > 2) {
+    if (mNnClusterizerVerbosity > 3) {
+      auto fmt = [](size_t bytes) -> const char* {
+        static char buf[64];
+        double mb = (double)bytes / (1024.0 * 1024.0);
+        int n = snprintf(buf, sizeof(buf), "%zu bytes (%.3f MB)", bytes, mb);
+        (void)n;
+        return buf;
+      };
+
+      // Element counts (number of array entries, not bytes)
+      size_t elemsClusterFlags = (mClusterFlags && mNnClusterizerBatchedMode > 0) ? (size_t)2 * mNnClusterizerBatchedMode : 0;
+      size_t elemsInput16 = (mInputData_16 && mNnClusterizerBatchedMode > 0 && mNnClusterizerElementSize > 0) ? (size_t)mNnClusterizerBatchedMode * mNnClusterizerElementSize : 0;
+      size_t elemsInput32 = (mInputData_32 && mNnClusterizerBatchedMode > 0 && mNnClusterizerElementSize > 0) ? (size_t)mNnClusterizerBatchedMode * mNnClusterizerElementSize : 0;
+      size_t elemsProb16 = (mModelProbabilities_16 && mNnClusterizerBatchedMode > 0 && mNnClusterizerModelClassNumOutputNodes > 0) ? (size_t)mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes : 0;
+      size_t elemsProb32 = (mModelProbabilities_32 && mNnClusterizerBatchedMode > 0 && mNnClusterizerModelClassNumOutputNodes > 0) ? (size_t)mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes : 0;
+      size_t elemsReg1_16 = (mOutputDataReg1_16 && mNnClusterizerBatchedMode > 0 && mNnClusterizerModelReg1NumOutputNodes > 0) ? (size_t)mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes : 0;
+      size_t elemsReg2_16 = (mOutputDataReg2_16 && mNnClusterizerBatchedMode > 0 && mNnClusterizerModelReg2NumOutputNodes > 0) ? (size_t)mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes : 0;
+      size_t elemsReg1_32 = (mOutputDataReg1_32 && mNnClusterizerBatchedMode > 0 && mNnClusterizerModelReg1NumOutputNodes > 0) ? (size_t)mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes : 0;
+      size_t elemsReg2_32 = (mOutputDataReg2_32 && mNnClusterizerBatchedMode > 0 && mNnClusterizerModelReg2NumOutputNodes > 0) ? (size_t)mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes : 0;
+      size_t elemsOutputDataClass = (mOutputDataClass && mNnClusterizerTotalClusters > 0) ? (size_t)mNnClusterizerTotalClusters : 0;
+
+      // Byte sizes
+      size_t szClusterFlags = elemsClusterFlags * sizeof(int8_t);
+      size_t szInput16 = elemsInput16 * sizeof(OrtDataType::Float16_t);
+      size_t szInput32 = elemsInput32 * sizeof(float);
+      size_t szProb16 = elemsProb16 * sizeof(OrtDataType::Float16_t);
+      size_t szProb32 = elemsProb32 * sizeof(float);
+      size_t szReg1_16 = elemsReg1_16 * sizeof(OrtDataType::Float16_t);
+      size_t szReg2_16 = elemsReg2_16 * sizeof(OrtDataType::Float16_t);
+      size_t szReg1_32 = elemsReg1_32 * sizeof(float);
+      size_t szReg2_32 = elemsReg2_32 * sizeof(float);
+      size_t szOutputDataClass = elemsOutputDataClass * sizeof(int32_t);
+
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") Pointers set for clusterizer with memoryID " << mMemoryId << " deviceID " << mDeviceId << " and sector " << mISector;
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mOutputDataClass pointer: " << mOutputDataClass
+                << " | elements=" << elemsOutputDataClass << " (= mNnClusterizerTotalClusters)"
+                << " | " << fmt(szOutputDataClass);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mClusterFlags pointer: " << static_cast<const void*>(mClusterFlags)
+                << " | elements=" << elemsClusterFlags << " (= 2 * mNnClusterizerBatchedMode)"
+                << " | " << fmt(szClusterFlags);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mInputData_16 pointer: " << mInputData_16
+                << " | elements=" << elemsInput16 << " (= mNnClusterizerBatchedMode * mNnClusterizerElementSize)"
+                << " | " << fmt(szInput16);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mModelProbabilities_16 pointer: " << mModelProbabilities_16
+                << " | elements=" << elemsProb16 << " (= mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes)"
+                << " | " << fmt(szProb16);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mOutputDataReg1_16 pointer: " << mOutputDataReg1_16
+                << " | elements=" << elemsReg1_16 << " (= mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes)"
+                << " | " << fmt(szReg1_16);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mOutputDataReg2_16 pointer: " << mOutputDataReg2_16
+                << " | elements=" << elemsReg2_16 << " (= mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes)"
+                << " | " << fmt(szReg2_16);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mInputData_32 pointer: " << mInputData_32
+                << " | elements=" << elemsInput32 << " (= mNnClusterizerBatchedMode * mNnClusterizerElementSize)"
+                << " | " << fmt(szInput32);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mModelProbabilities_32 pointer: " << mModelProbabilities_32
+                << " | elements=" << elemsProb32 << " (= mNnClusterizerBatchedMode * mNnClusterizerModelClassNumOutputNodes)"
+                << " | " << fmt(szProb32);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mOutputDataReg1_32 pointer: " << mOutputDataReg1_32
+                << " | elements=" << elemsReg1_32 << " (= mNnClusterizerBatchedMode * mNnClusterizerModelReg1NumOutputNodes)"
+                << " | " << fmt(szReg1_32);
+      LOG(info) << "(NNCLUS, GPUTPCNNClusterizer, this=" << this << ") mOutputDataReg2_32 pointer: " << mOutputDataReg2_32
+                << " | elements=" << elemsReg2_32 << " (= mNnClusterizerBatchedMode * mNnClusterizerModelReg2NumOutputNodes)"
+                << " | " << fmt(szReg2_32);
+    }
+    // Compute allocated bytes (difference between advanced pointer and start pointer)
+    size_t allocatedBytes = static_cast<size_t>(reinterpret_cast<uintptr_t>(mem) - reinterpret_cast<uintptr_t>(startMem));
+    double allocatedMB = static_cast<double>(allocatedBytes) / (1024.0 * 1024.0);
+    {
+      char allocMsg[256];
+      int nn = snprintf(allocMsg, sizeof(allocMsg),
+                        "(NNCLUS, GPUTPCNNClusterizer, this=%p) Total scratch allocation in setIOPointers: %zu bytes (%.3f MB)",
+                        (void*)this, (size_t)allocatedBytes, allocatedMB);
+      (void)nn;
+      LOG(info) << allocMsg;
+    }
+  }
+
   return mem;
 }
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index 69972c8a0651c..a6b0b081fc3dd 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -50,7 +50,7 @@ class GPUTPCNNClusterizer : public GPUProcessor
   int32_t mNnClusterizerUseCfRegression = 0;
   int32_t mNnClusterizerBatchedMode = 1;
   int32_t mNnClusterizerTotalClusters = 1;
-  int32_t mNnClusterizerVerbosity = 0;
+  int32_t mNnClusterizerVerbosity = 1;
   int32_t mNnClusterizerBoundaryFillValue = -1;
   int32_t mNnClusterizerModelClassNumOutputNodes = -1;
   int32_t mNnClusterizerModelReg1NumOutputNodes = -1;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 1882acd2a45c6..15ee6b6119022 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -12,7 +12,11 @@
 /// \file GPUTPCNNClusterizerKernels.cxx
 /// \author Christian Sonnabend
 
+#include "clusterFinderDefs.h"
+#include "PackedCharge.h"
 #include "GPUTPCNNClusterizerKernels.h"
+#include "GPUConstantMem.h"
+#include "GPUTPCClusterFinder.h"
 #include "GPUTPCCFClusterizer.h"
 #include "GPUTPCGeometry.h"
 
@@ -40,14 +44,11 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
   uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
-  if (clustererNN.mOutputDataClass[glo_idx] == 0) { // default clusterizer should not be called in batched mode due to mess-up with thread indices
-    return;
-  }
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CPU_ONLY(MCLabelAccumulator labelAcc(clusterer));
   tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
-  o2::gpu::GPUTPCCFClusterizer::GPUSharedMemory smem_new;
-  GPUTPCCFClusterizer::computeClustersImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, smem_new, chargeMap, clusterer.mPfilteredPeakPositions, clusterer.Param().rec, CPU_PTR(&labelAcc), clusterer.mPmemory->counters.nClusters, clusterer.mNMaxClusterPerRow, clusterer.mPclusterInRow, clusterOut, clusterer.mPclusterPosInRow);
+  int8_t isAccepted = (clustererNN.mNnClusterizerUseClassification ? (clustererNN.mOutputDataClass[CAMath::Min(glo_idx, (uint32_t)clusterer.mPmemory->counters.nClusters - 1)] > 0) : 1);
+  GPUTPCCFClusterizer::computeClustersImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, reinterpret_cast<GPUTPCCFClusterizer::GPUSharedMemory&>(smem), chargeMap, clusterer.mPfilteredPeakPositions, clusterer.Param().rec, CPU_PTR(&labelAcc), clusterer.mPmemory->counters.nClusters, clusterer.mNMaxClusterPerRow, clusterer.mPclusterInRow, clusterOut, clusterer.mPclusterPosInRow, isAccepted);
 }
 
 template <>
@@ -57,7 +58,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
   uint32_t glo_idx = get_global_id(0);
-  if (glo_idx + batchStart >= clusterer.mPmemory->counters.nClusters) {
+  if (glo_idx + batchStart >= clusterer.mPmemory->counters.nClusters || glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode) {
     return;
   }
 
@@ -95,12 +96,6 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
         } else {
           CfChargePos tmp_pos(target_row, target_pad, target_time);
           float normalized_charge = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
-
-          if (!clustererNN.mNnClusterizerSetDeconvolutionFlags && r == 0 && CAMath::Abs(p) < 3 && CAMath::Abs(t) < 3 && p != 0 && t != 0) {
-            clustererNN.mClusterFlags[2 * glo_idx] += CfUtils::isPeak(isPeakMap[tmp_pos]);
-            clustererNN.mClusterFlags[2 * glo_idx + 1] = clustererNN.mClusterFlags[2 * glo_idx];
-          }
-
           if (dtype == 0) {
             clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)normalized_charge;
           } else {
@@ -145,11 +140,13 @@ template <>
 GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNGPU>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   uint32_t glo_idx = get_global_id(0);
-
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
-  // Optimized division using bit operations
+  if (glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode * clustererNN.mNnClusterizerRowTimeSizeFull) {
+    return;
+  }
+
   uint32_t base_idx = glo_idx / clustererNN.mNnClusterizerRowTimeSizeFull;
   uint32_t transient_index = glo_idx - (base_idx * clustererNN.mNnClusterizerRowTimeSizeFull);
 
@@ -185,7 +182,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
     }
 
     // Handle deconvolution flags only once per cluster (last thread in element)
-    if (data_idx == 2 && !clustererNN.mNnClusterizerSetDeconvolutionFlags) {
+    if (!clustererNN.mNnClusterizerSetDeconvolutionFlags && data_idx == 2) {
       uint8_t cluster_flags = 0;
       for (uint16_t i = 0; i < 8; i++) {
         Delta2 d = cfconsts::InnerNeighbors[i];
@@ -249,6 +246,21 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
       } else {
         clustererNN.mInputData_32[write_idx] = output_value;
       }
+      // if (write_idx >= clustererNN.mNnClusterizerElementSize * clustererNN.mNnClusterizerBatchedMode) {
+      //   printf("Error: Write index out of bounds (central array)! %d >= %d (write_idx: %d, base_idx: %d, transient_index: %d, row_idx: %d, time_idx: %d, r_local: %d, t_local: %d)\n",
+      //          write_idx, (int)(clustererNN.mNnClusterizerElementSize * clustererNN.mNnClusterizerBatchedMode), write_idx, base_idx, transient_index, row_idx, time_idx, r_local, t_local);
+      // }
+      // if ((clusterer.mPmemory->counters.nClusters - batchStart) < clustererNN.mNnClusterizerBatchedMode) {
+      //   if (write_idx >= ((clusterer.mPmemory->counters.nClusters - batchStart) * clustererNN.mNnClusterizerElementSize)) {
+      //     printf("Error: Write index out of bounds (end of array)! %d >= %d (write_idx: %d, base_idx: %d, transient_index: %d, row_idx: %d, time_idx: %d, r_local: %d, t_local: %d)\n",
+      //           write_idx, (int)((clusterer.mPmemory->counters.nClusters - batchStart) * clustererNN.mNnClusterizerElementSize), write_idx, base_idx, transient_index, row_idx, time_idx, r_local, t_local);
+      //   }
+      //   if (write_idx > ((clusterer.mPmemory->counters.nClusters - batchStart) * clustererNN.mNnClusterizerElementSize - 5)) {
+      //     printf("Sanity check (should appear only once) %d == %d (write_idx: %d, base_idx: %d, transient_index: %d, row_idx: %d, time_idx: %d, r_local: %d, t_local: %d)\n",
+      //           write_idx, (int)((clusterer.mPmemory->counters.nClusters - batchStart) * clustererNN.mNnClusterizerElementSize - 4), write_idx, base_idx, transient_index, row_idx, time_idx, r_local, t_local);
+      //   }
+      // }
+
       write_idx += clustererNN.mNnClusterizerFullTimeSize; // Move to next pad position
     }
   }
@@ -258,41 +270,58 @@ template <>
 GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass1Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
   uint32_t glo_idx = get_global_id(0);
-  if (dtype == 0) {
-    processors.tpcNNClusterer[sector].mOutputDataClass[glo_idx + batchStart] = (int)((processors.tpcNNClusterer[sector].mModelProbabilities_16[glo_idx]).ToFloat() > processors.tpcNNClusterer[sector].mNnClassThreshold);
-  } else if (dtype == 1) {
-    processors.tpcNNClusterer[sector].mOutputDataClass[glo_idx + batchStart] = (int)(processors.tpcNNClusterer[sector].mModelProbabilities_32[glo_idx] > processors.tpcNNClusterer[sector].mNnClassThreshold);
+  auto& clusterer = processors.tpcClusterer[sector];
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  if (glo_idx + batchStart >= clusterer.mPmemory->counters.nClusters || glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode) {
+    return;
+  }
+  if (clustererNN.mNnClusterizerUseClassification) {
+    if (dtype == 0) {
+      clustererNN.mOutputDataClass[glo_idx + batchStart] = (int32_t)((clustererNN.mModelProbabilities_16[glo_idx]).ToFloat() > clustererNN.mNnClassThreshold);
+    } else if (dtype == 1) {
+      clustererNN.mOutputDataClass[glo_idx + batchStart] = (int32_t)(clustererNN.mModelProbabilities_32[glo_idx] > clustererNN.mNnClassThreshold);
+    }
+  } else {
+    clustererNN.mOutputDataClass[glo_idx + batchStart] = 1;
   }
 }
 
 template <>
 GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::determineClass2Labels>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
-  auto& clustererNN = processors.tpcNNClusterer[sector];
   uint32_t glo_idx = get_global_id(0);
-  uint32_t elem_iterator = glo_idx * clustererNN.mNnClusterizerModelClassNumOutputNodes;
-  float current_max_prob = 0.f; // If the neural network doesn't contain the softmax as a last layer, the outputs can range in [-infty, infty]
-  uint32_t class_label = 0;
-  for (uint32_t pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes; pIdx++) {
-    if (pIdx == elem_iterator) {
-      if (dtype == 0) {
-        current_max_prob = static_cast<float>(clustererNN.mModelProbabilities_16[pIdx]);
-      } else if (dtype == 1) {
-        current_max_prob = clustererNN.mModelProbabilities_32[pIdx];
-      }
-    } else {
-      if (dtype == 0) {
-        current_max_prob = CAMath::Max(current_max_prob, clustererNN.mModelProbabilities_16[pIdx].ToFloat());
-      } else if (dtype == 1) {
-        current_max_prob = CAMath::Max(current_max_prob, clustererNN.mModelProbabilities_32[pIdx]);
+  auto& clusterer = processors.tpcClusterer[sector];
+  auto& clustererNN = processors.tpcNNClusterer[sector];
+  if (glo_idx + batchStart >= clusterer.mPmemory->counters.nClusters || glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode) {
+    return;
+  }
+  if (clustererNN.mNnClusterizerUseClassification) {
+    uint32_t elem_iterator = glo_idx * clustererNN.mNnClusterizerModelClassNumOutputNodes;
+    float current_max_prob = 0.f; // If the neural network doesn't contain the softmax as a last layer, the outputs can range in [-infty, infty]
+    uint32_t class_label = 0;
+    for (uint32_t pIdx = elem_iterator; pIdx < elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes; pIdx++) {
+      if (pIdx == elem_iterator) {
+        if (dtype == 0) {
+          current_max_prob = static_cast<float>(clustererNN.mModelProbabilities_16[pIdx]);
+        } else if (dtype == 1) {
+          current_max_prob = clustererNN.mModelProbabilities_32[pIdx];
+        }
+      } else {
+        if (dtype == 0) {
+          current_max_prob = CAMath::Max(current_max_prob, clustererNN.mModelProbabilities_16[pIdx].ToFloat());
+        } else if (dtype == 1) {
+          current_max_prob = CAMath::Max(current_max_prob, clustererNN.mModelProbabilities_32[pIdx]);
+        }
       }
     }
-  }
-  // uint32_t class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
-  clustererNN.mOutputDataClass[glo_idx + batchStart] = class_label;
-  if (class_label > 1) {
-    clustererNN.mClusterFlags[2 * glo_idx] = 1;
-    clustererNN.mClusterFlags[2 * glo_idx + 1] = 1;
+    // uint32_t class_label = std::distance(elem_iterator, std::max_element(elem_iterator, elem_iterator + clustererNN.mNnClusterizerModelClassNumOutputNodes)); // Multiple outputs of the class network are the probabilities for each class. The highest one "wins"
+    clustererNN.mOutputDataClass[glo_idx + batchStart] = class_label;
+    if (class_label > 1) {
+      clustererNN.mClusterFlags[2 * glo_idx] = 1;
+      clustererNN.mClusterFlags[2 * glo_idx + 1] = 1;
+    }
+  } else {
+    clustererNN.mOutputDataClass[glo_idx + batchStart] = 1;
   }
 }
 
@@ -302,6 +331,9 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
+  if (glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode) {
+    return;
+  }
 
   uint32_t maxClusterNum = clusterer.mPmemory->counters.nClusters;
   uint32_t full_glo_idx = glo_idx + batchStart;
@@ -335,88 +367,84 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
   // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.mNnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
 
-  if (clustererNN.mOutputDataClass[full_glo_idx] == 1 || (clustererNN.mNnClusterizerUseClassification <= 0)) {
-
-    ClusterAccumulator pc;
-
-    // Publishing logic is taken from default clusterizer
-    if (withMC) {
-      ClusterAccumulator dummy_pc;
-      CPU_ONLY(labelAcc->collect(peak, central_charge));
-      GPUTPCCFClusterizer::buildCluster(
-        clusterer.Param().rec,
-        chargeMap,
-        peak,
-        smem.posBcast,
-        smem.buf,
-        smem.innerAboveThreshold,
-        &dummy_pc,
-        labelAcc);
-    }
-    if ((clusterer.mPmemory->fragment).isOverlap(peak.time())) {
-      if (clusterer.mPclusterPosInRow) {
-        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
-      }
-      return;
-    }
-
-    bool notSinglePad = false, notSingleTime = false;
-    for (uint16_t i = 0; i < 8; i++) {
-      Delta2 d = cfconsts::InnerNeighbors[i];
-      CfChargePos tmp_pos = peak.delta(d);
-      notSinglePad |= (d.x != 0) && (static_cast<float>(chargeMap[tmp_pos].unpack()) > 0);
-      notSingleTime |= (d.y != 0) && (static_cast<float>(chargeMap[tmp_pos].unpack()) > 0);
+  ClusterAccumulator pc;
+
+  // Publishing logic is taken from default clusterizer
+  if (withMC) {
+    ClusterAccumulator dummy_pc;
+    CPU_ONLY(labelAcc->collect(peak, central_charge));
+    GPUTPCCFClusterizer::buildCluster(
+      clusterer.Param().rec,
+      chargeMap,
+      peak,
+      smem.posBcast,
+      smem.buf,
+      smem.innerAboveThreshold,
+      &dummy_pc,
+      labelAcc);
+  }
+  if ((clusterer.mPmemory->fragment).isOverlap(peak.time())) {
+    if (clusterer.mPclusterPosInRow) {
+      clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
     }
+    return;
+  }
 
-    if (dtype == 0) {
-      pc.setFull(central_charge * clustererNN.mOutputDataReg1_16[model_output_index + 4].ToFloat(),
-                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_16[model_output_index].ToFloat(),
-                 notSinglePad ? clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat() : 0.f,
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_16[model_output_index + 1].ToFloat(),
-                 notSingleTime ? clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat() : 0.f,
-                 clustererNN.mClusterFlags[2 * glo_idx],
-                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
-    } else if (dtype == 1) {
-      pc.setFull(central_charge * clustererNN.mOutputDataReg1_32[model_output_index + 4],
-                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_32[model_output_index],
-                 notSinglePad ? clustererNN.mOutputDataReg1_32[model_output_index + 2] : 0.f,
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_32[model_output_index + 1],
-                 notSingleTime ? clustererNN.mOutputDataReg1_32[model_output_index + 3] : 0.f,
-                 clustererNN.mClusterFlags[2 * glo_idx],
-                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
-    }
+  // For flag influence on cluster error setting: O2/GPU/GPUTracking/Base/GPUParam.inc -> UpdateClusterError2ByState
+  bool notSinglePad = false, notSingleTime = false;
+  for (uint16_t i = 0; i < 8; i++) {
+    Delta2 d = cfconsts::InnerNeighbors[i];
+    CfChargePos tmp_pos = peak.delta(d);
+    notSinglePad |= (d.x != 0) && (static_cast<float>(chargeMap[tmp_pos].unpack()) > 0);
+    notSingleTime |= (d.y != 0) && (static_cast<float>(chargeMap[tmp_pos].unpack()) > 0);
+  }
 
-    tpc::ClusterNative myCluster;
-    bool rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
-    if (rejectCluster) {
-      if (clusterer.mPclusterPosInRow) {
-        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
-      }
-      return;
-    }
+  if (dtype == 0) {
+    pc.setFull(central_charge * clustererNN.mOutputDataReg1_16[model_output_index + 4].ToFloat(),
+               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_16[model_output_index].ToFloat(),
+               notSinglePad ? clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat() : 0.f,
+               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_16[model_output_index + 1].ToFloat(),
+               notSingleTime ? clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat() : 0.f,
+               clustererNN.mClusterFlags[2 * glo_idx],
+               clustererNN.mClusterFlags[2 * glo_idx + 1]);
+  } else if (dtype == 1) {
+    pc.setFull(central_charge * clustererNN.mOutputDataReg1_32[model_output_index + 4],
+               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_32[model_output_index],
+               notSinglePad ? clustererNN.mOutputDataReg1_32[model_output_index + 2] : 0.f,
+               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_32[model_output_index + 1],
+               notSingleTime ? clustererNN.mOutputDataReg1_32[model_output_index + 3] : 0.f,
+               clustererNN.mClusterFlags[2 * glo_idx],
+               clustererNN.mClusterFlags[2 * glo_idx + 1]);
+  }
 
-    uint32_t rowIndex = 0;
-    if (clusterOut != nullptr) {
-      rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
-        clusterer,
-        myCluster,
-        peak.row(),
-        clusterer.mNMaxClusterPerRow,
-        clusterer.mPclusterInRow,
-        clusterOut);
-      if (clusterer.mPclusterPosInRow != nullptr) {
-        clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
-      }
-    } else if (clusterer.mPclusterPosInRow) {
-      rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
-    }
-    CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow));
-  } else {
+  tpc::ClusterNative myCluster;
+  bool rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
+  if (clustererNN.mNnClusterizerUseClassification) {
+    rejectCluster |= (clustererNN.mOutputDataClass[CAMath::Min(full_glo_idx, (uint32_t)clusterer.mPmemory->counters.nClusters - 1)] <= 0);
+  }
+  if (rejectCluster) {
     if (clusterer.mPclusterPosInRow) {
       clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
     }
     return;
   }
+
+  uint32_t rowIndex = 0;
+  if (clusterOut != nullptr) {
+    rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
+      clusterer,
+      myCluster,
+      peak.row(),
+      clusterer.mNMaxClusterPerRow,
+      clusterer.mPclusterInRow,
+      clusterOut);
+    if (clusterer.mPclusterPosInRow != nullptr) {
+      clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
+    }
+  } else if (clusterer.mPclusterPosInRow) {
+    rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
+  }
+  CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow));
 }
 
 template <>
@@ -425,6 +453,9 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
+  if (glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode) {
+    return;
+  }
 
   uint32_t maxClusterNum = clusterer.mPmemory->counters.nClusters;
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
@@ -455,123 +486,121 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
   uint32_t model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg2NumOutputNodes;
 
-  if ((clustererNN.mOutputDataClass[full_glo_idx] > 0) || (clustererNN.mNnClusterizerUseClassification <= 0)) {
-
-    ClusterAccumulator pc;
-
-    if (withMC) {
-      ClusterAccumulator dummy_pc;
-      CPU_ONLY(labelAcc->collect(peak, central_charge));
-      GPUTPCCFClusterizer::buildCluster(
-        clusterer.Param().rec,
-        chargeMap,
-        peak,
-        smem.posBcast,
-        smem.buf,
-        smem.innerAboveThreshold,
-        &dummy_pc,
-        labelAcc);
-    }
-    if ((clusterer.mPmemory->fragment).isOverlap(peak.time())) {
-      if (clusterer.mPclusterPosInRow) {
-        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
-      }
-      return;
-    }
-
-    // Cluster 1
-    if (dtype == 0) {
-      pc.setFull(central_charge * clustererNN.mOutputDataReg2_16[model_output_index + 8].ToFloat(),
-                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index].ToFloat(),
-                 clustererNN.mOutputDataReg2_16[model_output_index + 4].ToFloat(),
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 2].ToFloat(),
-                 clustererNN.mOutputDataReg2_16[model_output_index + 6].ToFloat(),
-                 clustererNN.mClusterFlags[2 * glo_idx],
-                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
-    } else if (dtype == 1) {
-      pc.setFull(central_charge * clustererNN.mOutputDataReg2_32[model_output_index + 8],
-                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index],
-                 clustererNN.mOutputDataReg2_32[model_output_index + 4],
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 2],
-                 clustererNN.mOutputDataReg2_32[model_output_index + 6],
-                 clustererNN.mClusterFlags[2 * glo_idx],
-                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
+  ClusterAccumulator pc;
+
+  if (withMC) {
+    ClusterAccumulator dummy_pc;
+    CPU_ONLY(labelAcc->collect(peak, central_charge));
+    GPUTPCCFClusterizer::buildCluster(
+      clusterer.Param().rec,
+      chargeMap,
+      peak,
+      smem.posBcast,
+      smem.buf,
+      smem.innerAboveThreshold,
+      &dummy_pc,
+      labelAcc);
+  }
+  if ((clusterer.mPmemory->fragment).isOverlap(peak.time())) {
+    if (clusterer.mPclusterPosInRow) {
+      clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
     }
+    return;
+  }
 
-    tpc::ClusterNative myCluster;
-    bool rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
-    if (rejectCluster) {
-      if (clusterer.mPclusterPosInRow) {
-        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
-      }
-      return;
-    }
+  // Cluster 1
+  if (dtype == 0) {
+    pc.setFull(central_charge * clustererNN.mOutputDataReg2_16[model_output_index + 8].ToFloat(),
+               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index].ToFloat(),
+               clustererNN.mOutputDataReg2_16[model_output_index + 4].ToFloat(),
+               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 2].ToFloat(),
+               clustererNN.mOutputDataReg2_16[model_output_index + 6].ToFloat(),
+               clustererNN.mClusterFlags[2 * glo_idx],
+               clustererNN.mClusterFlags[2 * glo_idx + 1]);
+  } else if (dtype == 1) {
+    pc.setFull(central_charge * clustererNN.mOutputDataReg2_32[model_output_index + 8],
+               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index],
+               clustererNN.mOutputDataReg2_32[model_output_index + 4],
+               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 2],
+               clustererNN.mOutputDataReg2_32[model_output_index + 6],
+               clustererNN.mClusterFlags[2 * glo_idx],
+               clustererNN.mClusterFlags[2 * glo_idx + 1]);
+  }
 
-    uint32_t rowIndex = 0;
-    if (clusterOut != nullptr) {
-      rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
-        clusterer,
-        myCluster,
-        peak.row(),
-        clusterer.mNMaxClusterPerRow,
-        clusterer.mPclusterInRow,
-        clusterOut);
-      if (clusterer.mPclusterPosInRow != nullptr) {
-        clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
-      }
-    } else if (clusterer.mPclusterPosInRow) {
-      rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
+  tpc::ClusterNative myCluster;
+  bool rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
+  if (clustererNN.mNnClusterizerUseClassification) {
+    rejectCluster |= (clustererNN.mOutputDataClass[CAMath::Min(full_glo_idx, (uint32_t)clusterer.mPmemory->counters.nClusters - 1)] <= 0);
+  }
+  if (rejectCluster) {
+    if (clusterer.mPclusterPosInRow) {
+      clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
     }
-    CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow));
+    return;
+  }
 
-    // Cluster 2
-    if (dtype == 0) {
-      pc.setFull(central_charge * clustererNN.mOutputDataReg2_16[model_output_index + 9].ToFloat(),
-                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index + 1].ToFloat(),
-                 clustererNN.mOutputDataReg2_16[model_output_index + 5].ToFloat(),
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 3].ToFloat(),
-                 clustererNN.mOutputDataReg2_16[model_output_index + 7].ToFloat(),
-                 clustererNN.mClusterFlags[2 * glo_idx],
-                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
-    } else if (dtype == 1) {
-      pc.setFull(central_charge * clustererNN.mOutputDataReg2_32[model_output_index + 9],
-                 static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index + 1],
-                 clustererNN.mOutputDataReg2_32[model_output_index + 5],
-                 (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 3],
-                 clustererNN.mOutputDataReg2_32[model_output_index + 7],
-                 clustererNN.mClusterFlags[2 * glo_idx],
-                 clustererNN.mClusterFlags[2 * glo_idx + 1]);
+  uint32_t rowIndex = 0;
+  if (clusterOut != nullptr) {
+    rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
+      clusterer,
+      myCluster,
+      peak.row(),
+      clusterer.mNMaxClusterPerRow,
+      clusterer.mPclusterInRow,
+      clusterOut);
+    if (clusterer.mPclusterPosInRow != nullptr) {
+      clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
     }
+  } else if (clusterer.mPclusterPosInRow) {
+    rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
+  }
+  CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow));
 
-    rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
-    if (rejectCluster) {
-      if (clusterer.mPclusterPosInRow) {
-        clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
-      }
-      return;
-    }
+  // Cluster 2
+  if (dtype == 0) {
+    pc.setFull(central_charge * clustererNN.mOutputDataReg2_16[model_output_index + 9].ToFloat(),
+               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index + 1].ToFloat(),
+               clustererNN.mOutputDataReg2_16[model_output_index + 5].ToFloat(),
+               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 3].ToFloat(),
+               clustererNN.mOutputDataReg2_16[model_output_index + 7].ToFloat(),
+               clustererNN.mClusterFlags[2 * glo_idx],
+               clustererNN.mClusterFlags[2 * glo_idx + 1]);
+  } else if (dtype == 1) {
+    pc.setFull(central_charge * clustererNN.mOutputDataReg2_32[model_output_index + 9],
+               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index + 1],
+               clustererNN.mOutputDataReg2_32[model_output_index + 5],
+               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 3],
+               clustererNN.mOutputDataReg2_32[model_output_index + 7],
+               clustererNN.mClusterFlags[2 * glo_idx],
+               clustererNN.mClusterFlags[2 * glo_idx + 1]);
+  }
 
-    if (clusterOut != nullptr) {
-      rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
-        clusterer,
-        myCluster,
-        peak.row(),
-        clusterer.mNMaxClusterPerRow,
-        clusterer.mPclusterInRow,
-        clusterOut);
-      if (clusterer.mPclusterPosInRow != nullptr) {
-        clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
-      }
-    } else if (clusterer.mPclusterPosInRow) {
-      rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
-    }
-    // CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow)); // -> Is this needed? How to handle MC labels for split clusters?
-  } else {
+  rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
+  if (clustererNN.mNnClusterizerUseClassification) {
+    rejectCluster |= (clustererNN.mOutputDataClass[CAMath::Min(full_glo_idx, (uint32_t)clusterer.mPmemory->counters.nClusters - 1)] <= 0);
+  }
+  if (rejectCluster) {
     if (clusterer.mPclusterPosInRow) {
       clusterer.mPclusterPosInRow[full_glo_idx] = clusterer.mNMaxClusterPerRow;
     }
     return;
   }
+
+  if (clusterOut != nullptr) {
+    rowIndex = GPUTPCCFClusterizer::sortIntoBuckets(
+      clusterer,
+      myCluster,
+      peak.row(),
+      clusterer.mNMaxClusterPerRow,
+      clusterer.mPclusterInRow,
+      clusterOut);
+    if (clusterer.mPclusterPosInRow != nullptr) {
+      clusterer.mPclusterPosInRow[full_glo_idx] = rowIndex;
+    }
+  } else if (clusterer.mPclusterPosInRow) {
+    rowIndex = clusterer.mPclusterPosInRow[full_glo_idx];
+  }
+  // CPU_ONLY(labelAcc->commit(peak.row(), rowIndex, clusterer.mNMaxClusterPerRow)); // -> Is this needed? How to handle MC labels for split clusters?
 }
 
 // ---------------------------------
@@ -579,27 +608,30 @@ template <>
 GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::publishDeconvolutionFlags>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint batchStart)
 {
   // Implements identical publishing logic as the heuristic clusterizer and deconvolution kernel
-  uint32_t idx = get_global_id(0);
+  uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
+  if (glo_idx + batchStart >= clusterer.mPmemory->counters.nClusters || glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode) {
+    return;
+  }
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  CfChargePos peak = clusterer.mPfilteredPeakPositions[idx + batchStart];
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[glo_idx + batchStart];
 
-  clustererNN.mClusterFlags[2 * idx] = 0;
-  clustererNN.mClusterFlags[2 * idx + 1] = 0;
+  clustererNN.mClusterFlags[2 * glo_idx] = 0;
+  clustererNN.mClusterFlags[2 * glo_idx + 1] = 0;
   for (int i = 0; i < 8; i++) {
     Delta2 d = cfconsts::InnerNeighbors[i];
     CfChargePos tmp_pos = peak.delta(d);
     PackedCharge charge = chargeMap[tmp_pos];
-    clustererNN.mClusterFlags[2 * idx] += (d.y != 0 && charge.isSplit());
-    clustererNN.mClusterFlags[2 * idx + 1] += (d.x != 0 && charge.isSplit());
+    clustererNN.mClusterFlags[2 * glo_idx] += (d.y != 0 && charge.isSplit());
+    clustererNN.mClusterFlags[2 * glo_idx + 1] += (d.x != 0 && charge.isSplit());
   }
   for (int i = 0; i < 16; i++) {
     Delta2 d = cfconsts::OuterNeighbors[i];
     CfChargePos tmp_pos = peak.delta(d);
     PackedCharge charge = chargeMap[tmp_pos];
-    clustererNN.mClusterFlags[2 * idx] += (d.y != 0 && charge.isSplit() && !charge.has3x3Peak());
-    clustererNN.mClusterFlags[2 * idx + 1] += (d.x != 0 && charge.isSplit() && !charge.has3x3Peak());
+    clustererNN.mClusterFlags[2 * glo_idx] += (d.y != 0 && charge.isSplit() && !charge.has3x3Peak());
+    clustererNN.mClusterFlags[2 * glo_idx + 1] += (d.x != 0 && charge.isSplit() && !charge.has3x3Peak());
   }
 }
 
@@ -607,7 +639,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 GPUd() int32_t GPUTPCNNClusterizerKernels::padOffset(int32_t row_ref, int32_t row_current)
 {
   if (row_current < 0 || row_current >= o2::tpc::constants::MAXGLOBALPADROW) {
-    return 0; // Short-circuit for negative rows
+    return 0; // Short-circuit for out-of-bound rows
   } else {
     return (int)((GPUTPCGeometry::NPads(row_current) - GPUTPCGeometry::NPads(row_ref)) / 2);
   }
@@ -623,11 +655,11 @@ GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int32_t row, int32_t pad, int
   if (pad < 0 || row < 0) { // Faster short-circuit
     return true;
   } else if (row < 63) {
-    return ((pad < 0) || (pad >= static_cast<int>(GPUTPCGeometry::NPads(row))));
+    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row)));
   } else if (row < (63 + offset)) { // to account for the gap between IROC and OROC. Charge will be set to the boundary fill value in order to signal boundaries to the neural network
     return true;
   } else if (row < (o2::tpc::constants::MAXGLOBALPADROW + offset)) {
-    return ((pad < 0) || (pad >= static_cast<int>(GPUTPCGeometry::NPads(row - offset))));
+    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row - offset)));
   } else {
     return true;
   }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index 7469754594124..9c93726a097b7 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -15,12 +15,8 @@
 #ifndef O2_GPU_NN_CLUSTERIZER_H
 #define O2_GPU_NN_CLUSTERIZER_H
 
-#include "clusterFinderDefs.h"
-#include "GPUGeneralKernels.h"
-#include "GPUConstantMem.h"
-#include "GPUTPCClusterFinder.h"
 #include "CfArray2D.h"
-#include "PackedCharge.h"
+#include "GPUGeneralKernels.h"
 #include "GPUTPCNNClusterizer.h"
 
 namespace o2::tpc
@@ -33,6 +29,8 @@ namespace o2::gpu
 
 class ClusterAccumulator;
 class MCLabelAccumulator;
+struct CfChargePos;
+class PackedCharge;
 
 class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
 {
@@ -66,11 +64,6 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
   GPUd() static void Thread(int32_t, int32_t, int32_t, int32_t, GPUSharedMemory&, processorType&, uint8_t = 0, int8_t = 0, int8_t = 0, uint = 0, Args...);
 
  private:
-  static GPUd() void fillInputData(int32_t, int32_t, int32_t, int32_t, processorType&, uint8_t, int8_t, uint);
-  static GPUd() void publishClustersReg1(uint, GPUSharedMemory&, processorType&, uint8_t, int8_t, int8_t, uint);
-  static GPUd() uint32_t sortIntoBuckets(GPUTPCClusterFinder&, const tpc::ClusterNative&, uint32_t, uint32_t, uint32_t*, tpc::ClusterNative*, uint32_t);
-  static GPUd() void publishClustersReg2(uint, GPUSharedMemory&, processorType&, uint8_t, int8_t, int8_t, uint);
-
   static GPUd() int32_t padOffset(int32_t, int32_t);
   static GPUd() int32_t rowOffset(int32_t, int32_t);
   static GPUd() bool isBoundary(int32_t, int32_t, int32_t);

From d0b682530be67a588e2fdb99274a7975d2b940a8 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 8 Sep 2025 18:15:53 +0200
Subject: [PATCH 0786/1764] Check consistency of the TPC scaling request and
 map mean scaler

Unless --disable-lumi-type-consistency-check option is passed.
For the CTP Lumi the map->getLumi() must be > map->getCTP2IDCFallBackThreshold(), for the IDC scaling
the map->getIDC() must be < map->getCTP2IDCFallBackThreshold().
The default map->getCTP2IDCFallBackThreshold() is 30.
---
 .../Workflow/src/BarrelAlignmentSpec.cxx      |  1 +
 .../src/CosmicsMatchingSpec.cxx               |  1 +
 .../src/SecondaryVertexingSpec.cxx            |  1 +
 .../src/TOFMatcherSpec.cxx                    |  1 +
 .../src/TPCITSMatchingSpec.cxx                |  1 +
 .../study/src/TPCTrackStudy.cxx               |  1 +
 .../study/src/TrackMCStudy.cxx                |  1 +
 .../study/src/TrackingStudy.cxx               |  1 +
 .../TPCCalibration/CorrectionMapsLoader.h     |  2 ++
 .../calibration/src/CorrectionMapsLoader.cxx  | 21 +++++++++++++++++++
 .../TPCWorkflow/TPCCalibPadGainTracksSpec.h   |  1 +
 Detectors/TPC/workflow/src/RecoWorkflow.cxx   |  1 +
 Detectors/TPC/workflow/src/TPCRefitter.cxx    |  1 +
 .../TRDWorkflow/TRDGlobalTrackingSpec.h       |  1 +
 .../CorrectionMapsHelper.h                    |  4 ++++
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |  1 +
 GPU/Workflow/src/GPUWorkflowTPC.cxx           |  1 +
 17 files changed, 41 insertions(+)

diff --git a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
index 7681380692033..559eabc3f018b 100644
--- a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
+++ b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
@@ -92,6 +92,7 @@ class BarrelAlignmentSpec : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(tpcOpt.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(tpcOpt.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(tpcOpt.checkCTPIDCconsistency);
   }
   ~BarrelAlignmentSpec() override = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
index 8a7611e3380a4..34c41ec234dc5 100644
--- a/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
@@ -66,6 +66,7 @@ class CosmicsMatchingSpec : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~CosmicsMatchingSpec() override = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
index 80ba5f94280a0..043fe0e659ba6 100644
--- a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
@@ -62,6 +62,7 @@ class SecondaryVertexingSpec : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~SecondaryVertexingSpec() override = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
index 4710302e4e91e..3f6e79e433635 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
@@ -62,6 +62,7 @@ class TOFMatcherSpec : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~TOFMatcherSpec() override = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
index 1368bf6f34fe4..14af8c12794cc 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
@@ -75,6 +75,7 @@ class TPCITSMatchingDPL : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~TPCITSMatchingDPL() override = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
index 1cb108da5a460..09ef766aa1536 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
@@ -55,6 +55,7 @@ class TPCTrackStudySpec : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~TPCTrackStudySpec() final = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 9f4b79ab47b72..531a4ec746ccf 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -88,6 +88,7 @@ class TrackMCStudy : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~TrackMCStudy() final = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index d9ea9fe4516e1..f1a07c10d0318 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -75,6 +75,7 @@ class TrackingStudySpec : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~TrackingStudySpec() final = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
index 41e3ed6d3dcd5..a907b83fe49bf 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
@@ -42,6 +42,7 @@ struct CorrectionMapsLoaderGloOpts {
   int lumiMode = 0; ///< what corrections method to use: 0: classical scaling, 1: Using of the derivative map, 2: Using of the derivative map for MC
   bool enableMShapeCorrection = false;
   bool requestCTPLumi = true; //< request CTP Lumi regardless of what is used for corrections scaling
+  bool checkCTPIDCconsistency = true; //< check the selected CTP or IDC scaling source being consistent with mean scaler of the map
 
   bool needTPCScalersWorkflow() const
   {
@@ -63,6 +64,7 @@ class CorrectionMapsLoader : public o2::gpu::CorrectionMapsHelper
   void init(o2::framework::InitContext& ic);
   void copySettings(const CorrectionMapsLoader& src);
   void updateInverse(); /// recalculate inverse correction
+  void checkMeanScaleConsistency(float meanLumi, float threshold) const;
   float getMapMeanRate(const o2::gpu::TPCFastTransform* mp, bool lumiOverridden) const;
 
   static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, const CorrectionMapsLoaderGloOpts& gloOpts);
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index d1e1f60d4b801..0e4a5e2a73df4 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -138,6 +138,7 @@ void CorrectionMapsLoader::addGlobalOptions(std::vector<ConfigParamSpec>& option
   addOption(options, ConfigParamSpec{"corrmap-lumi-mode", o2::framework::VariantType::Int, 0, {"scaling mode: (default) 0 = static + scale * full; 1 = full + scale * derivative; 2 = full + scale * derivative (for MC)"}});
   addOption(options, ConfigParamSpec{"enable-M-shape-correction", o2::framework::VariantType::Bool, false, {"Enable M-shape distortion correction"}});
   addOption(options, ConfigParamSpec{"disable-ctp-lumi-request", o2::framework::VariantType::Bool, false, {"do not request CTP lumi (regardless what is used for corrections)"}});
+  addOption(options, ConfigParamSpec{"disable-lumi-type-consistency-check", o2::framework::VariantType::Bool, false, {"disable check of selected CTP or IDC scaling source being consistent with the map"}});
 }
 
 //________________________________________________________
@@ -148,6 +149,7 @@ CorrectionMapsLoaderGloOpts CorrectionMapsLoader::parseGlobalOptions(const o2::f
   tpcopt.lumiMode = opts.get<int>("corrmap-lumi-mode");
   tpcopt.enableMShapeCorrection = opts.get<bool>("enable-M-shape-correction");
   tpcopt.requestCTPLumi = !opts.get<bool>("disable-ctp-lumi-request");
+  tpcopt.checkCTPIDCconsistency = !opts.get<bool>("disable-lumi-type-consistency-check");
   if (!tpcopt.requestCTPLumi && tpcopt.lumiType == 1) {
     LOGP(fatal, "Scaling with CTP Lumi is requested but this input is disabled");
   }
@@ -192,6 +194,9 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     } else if (getLumiScaleType() == 2) {
       mapMeanRate = mCorrMap->getIDC();
     }
+    if (mCheckCTPIDCConsistency) {
+      checkMeanScaleConsistency(mapMeanRate, mCorrMap->getCTP2IDCFallBackThreshold());
+    }
     if (getMeanLumiOverride() == 0 && mapMeanRate > 0.) {
       setMeanLumi(mapMeanRate, false);
     }
@@ -218,6 +223,9 @@ bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher,
     } else if (getLumiScaleType() == 2) {
       mapRefMeanRate = mCorrMapRef->getIDC();
     }
+    if (mCheckCTPIDCConsistency) {
+      checkMeanScaleConsistency(mapRefMeanRate, mCorrMapRef->getCTP2IDCFallBackThreshold());
+    }
     if (getMeanLumiRefOverride() == 0) {
       setMeanLumiRef(mapRefMeanRate);
     }
@@ -328,4 +336,17 @@ void CorrectionMapsLoader::updateInverse()
   }
 }
 
+void CorrectionMapsLoader::checkMeanScaleConsistency(float meanLumi, float threshold) const
+{
+  if (getLumiScaleType() == 1) {
+    if (meanLumi < threshold) {
+      LOGP(fatal, "CTP Lumi scaling source is requested, but the map mean scale {} is below the threshold {}", meanLumi, threshold);
+    }
+  } else if (getLumiScaleType() == 2) {
+    if (meanLumi > threshold) {
+      LOGP(fatal, "IDC scaling source is requested, but the map mean scale {} is above the threshold {}", meanLumi, threshold);
+    }
+  }
+}
+
 #endif // #ifndef GPUCA_GPUCODE_DEVICE
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
index c5af27da7b8f7..2491e5f71a889 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
@@ -54,6 +54,7 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
     }
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
 
   void init(o2::framework::InitContext& ic) final
diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index 132d85bfce790..3e35f416373a1 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -456,6 +456,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
     cfg.runTPCTracking = true;
     cfg.lumiScaleType = sclOpts.lumiType;
     cfg.lumiScaleMode = sclOpts.lumiMode;
+    cfg.checkCTPIDCconsistency = sclOpts.checkCTPIDCconsistency;
     cfg.enableMShape = sclOpts.enableMShapeCorrection;
     cfg.enableCTPLumi = sclOpts.requestCTPLumi;
     cfg.decompressTPC = decompressTPC;
diff --git a/Detectors/TPC/workflow/src/TPCRefitter.cxx b/Detectors/TPC/workflow/src/TPCRefitter.cxx
index b2e41c8e808da..51ff2516524a9 100644
--- a/Detectors/TPC/workflow/src/TPCRefitter.cxx
+++ b/Detectors/TPC/workflow/src/TPCRefitter.cxx
@@ -68,6 +68,7 @@ class TPCRefitterSpec final : public Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~TPCRefitterSpec() final = default;
   void init(InitContext& ic) final;
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
index 955af1995b0de..b4bfbddf7a4e6 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
@@ -57,6 +57,7 @@ class TRDGlobalTracking : public o2::framework::Task
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
   ~TRDGlobalTracking() override = default;
   void init(o2::framework::InitContext& ic) final;
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
index 46070b36e63b2..42d55adfcc3d0 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -106,6 +106,9 @@ class CorrectionMapsHelper
     }
   }
 
+  void setCheckCTPIDCConsistency(bool v) { mCheckCTPIDCConsistency = v; }
+  bool getCheckCTPIDCConsistency() const { return mCheckCTPIDCConsistency; }
+
   GPUd() float getInstLumiCTP() const { return mInstLumiCTP; }
   GPUd() float getInstLumi() const { return mInstLumi; }
   GPUd() float getMeanLumi() const { return mMeanLumi; }
@@ -181,6 +184,7 @@ class CorrectionMapsHelper
   float mInstCTPLumiOverride = -1.f;                  // optional value to override inst lumi from CTP
   bool mEnableMShape = false;                         ///< use v shape correction
   bool mScaleInverse{false};                          // if set to false the inverse correction is already scaled and will not scaled again
+  bool mCheckCTPIDCConsistency{true};                 // check of selected CTP or IDC scaling source being consistent with the map
   o2::gpu::TPCFastTransform* mCorrMap{nullptr};       // current transform
   o2::gpu::TPCFastTransform* mCorrMapRef{nullptr};    // reference transform
   o2::gpu::TPCFastTransform* mCorrMapMShape{nullptr}; // correction map for v-shape distortions on A-side
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 405f4a371f0cc..ad424cc226499 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -105,6 +105,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   struct Config {
     int32_t itsTriggerType = 0;
     int32_t lumiScaleMode = 0;
+    bool checkCTPIDCconsistency = true;
     bool enableMShape = false;
     bool enableCTPLumi = false;
     int32_t enableDoublePipeline = 0;
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index a0ed5813d90ca..6606386819b64 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -114,6 +114,7 @@ void GPURecoWorkflowSpec::initFunctionTPCCalib(InitContext& ic)
   mCalibObjects.mFastTransformHelper->setLumiScaleType(mSpecConfig.lumiScaleType);
   mCalibObjects.mFastTransformHelper->setCorrMapMShape(mCalibObjects.mFastTransformMShape.get());
   mCalibObjects.mFastTransformHelper->setLumiScaleMode(mSpecConfig.lumiScaleMode);
+  mCalibObjects.mFastTransformHelper->setCheckCTPIDCConsistency(mSpecConfig.checkCTPIDCconsistency);
   mCalibObjects.mFastTransformHelper->enableMShapeCorrection(mSpecConfig.enableMShape);
   if (mSpecConfig.outputTracks) {
     mCalibObjects.mFastTransformHelper->init(ic);

From aca5f47d72365397eba224570fcf72a34500ce5b Mon Sep 17 00:00:00 2001
From: Sergio Garcia <47090312+singiamtel@users.noreply.github.com>
Date: Wed, 10 Sep 2025 06:52:50 +0200
Subject: [PATCH 0787/1764] Fix macro formatting (#14661)

---
 Framework/CCDBSupport/src/CCDBFetcherHelper.cxx | 2 +-
 Framework/CCDBSupport/src/CCDBHelpers.cxx       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx b/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
index 92aff08a26032..151703105a1dd 100644
--- a/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
+++ b/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
@@ -229,7 +229,7 @@ auto CCDBFetcherHelper::populateCacheWith(std::shared_ptr<CCDBFetcherHelper> con
       checkValidity = true; // never skip check if the cache is empty
     }
 
-    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tf%{public}s %d of %{public}s", checkValidity ? "true" : "false", helper->useTFSlice ? "ID" : "Slice", helper->useTFSlice ? timingInfo.timeslice : timingInfo.tfCounter, path.data());
+    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tf%{public}s %zu of %{public}s", checkValidity ? "true" : "false", helper->useTFSlice ? "ID" : "Slice", helper->useTFSlice ? timingInfo.timeslice : timingInfo.tfCounter, path.data());
 
     const auto& api = helper->getAPI(path);
     if (checkValidity && (!api.isSnapshotMode() || etag.empty())) { // in the snapshot mode the object needs to be fetched only once
diff --git a/Framework/CCDBSupport/src/CCDBHelpers.cxx b/Framework/CCDBSupport/src/CCDBHelpers.cxx
index d303308df0c82..80a79796f8c1b 100644
--- a/Framework/CCDBSupport/src/CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/CCDBHelpers.cxx
@@ -315,7 +315,7 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
       checkValidity = true; // never skip check if the cache is empty
     }
 
-    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tf%{public}s %d of %{public}s", checkValidity ? "true" : "false", helper->useTFSlice ? "ID" : "Slice", helper->useTFSlice ? timingInfo.timeslice : timingInfo.tfCounter, path.data());
+    O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "checkValidity is %{public}s for tf%{public}s %zu of %{public}s", checkValidity ? "true" : "false", helper->useTFSlice ? "ID" : "Slice", helper->useTFSlice ? timingInfo.timeslice : timingInfo.tfCounter, path.data());
 
     const auto& api = helper->getAPI(path);
     if (checkValidity && (!api.isSnapshotMode() || etag.empty())) { // in the snapshot mode the object needs to be fetched only once

From 91a7d8b0ae435def5ce681b208830ee3e38b094a Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Tue, 9 Sep 2025 16:55:04 +0200
Subject: [PATCH 0788/1764] MaterialManager: Allow density modification on the
 individual material level

We can now scale the material density beyond the module level. We simply need
to use "MODULENAME/MATERIAL" strings in the configurable param.

Matching on individual material takes precedence over matching on the module level.

An example is
```
o2-sim --configKeyValues "SimMaterialParams.localDensityFactor=TPC/Air:1.2,TPC:2.0,ITS:5."
```
which will scale TPC air with a factor 1.2, the rest of TPC with factor 2.0 and
all of ITS with factor 5.0

Fixes https://its.cern.ch/jira/browse/O2-6294
---
 .../SimConfig/include/SimConfig/SimParams.h   |  6 ++-
 .../include/DetectorsBase/MaterialManager.h   |  2 +-
 Detectors/Base/src/MaterialManager.cxx        | 41 ++++++++++++++++---
 3 files changed, 41 insertions(+), 8 deletions(-)

diff --git a/Common/SimConfig/include/SimConfig/SimParams.h b/Common/SimConfig/include/SimConfig/SimParams.h
index cf3ee2b01cf2e..b5f975d1b0c6e 100644
--- a/Common/SimConfig/include/SimConfig/SimParams.h
+++ b/Common/SimConfig/include/SimConfig/SimParams.h
@@ -44,7 +44,11 @@ struct SimCutParams : public o2::conf::ConfigurableParamHelper<SimCutParams> {
 struct SimMaterialParams : public o2::conf::ConfigurableParamHelper<SimMaterialParams> {
   // Local density value takes precedence over global density value, i.e. local values overwrite the global value.
   float globalDensityFactor = 1.f; // global factor that scales all material densities for systematic studies
-  std::string localDensityFactor; // Expected format: "SimMaterialParams.localDensityFactor=<mod1>:<value1>,<mod2>:<value2>,..."
+  // String to set densities on module or material level. Expected format:
+  // "SimMaterialParams.localDensityFactor=<mod1/matname>:<value1>,<mod2>:<value2>,..."
+  // Example: "SimMaterialParams.localDensityFactor=TPC/Air:1.2,ITS:5." will scale the density of the Air in TPC
+  //           with 1.2 and to 5.0 for all materials in ITS".
+  std::string localDensityFactor;
 
   O2ParamDef(SimMaterialParams, "SimMaterialParams");
 };
diff --git a/Detectors/Base/include/DetectorsBase/MaterialManager.h b/Detectors/Base/include/DetectorsBase/MaterialManager.h
index 4448998ee3d33..b0de75c2d6c84 100644
--- a/Detectors/Base/include/DetectorsBase/MaterialManager.h
+++ b/Detectors/Base/include/DetectorsBase/MaterialManager.h
@@ -218,7 +218,7 @@ class MaterialManager
   std::unordered_map<std::string, float> mDensityMap;
 
   void initDensityMap();
-  float getDensity(std::string const& modname);
+  float getDensity(std::string const& modname, std::string const& matname);
 
   // Hide details by providing these private methods so it cannot happen that special settings
   // are applied as default settings by accident using a boolean flag
diff --git a/Detectors/Base/src/MaterialManager.cxx b/Detectors/Base/src/MaterialManager.cxx
index 741b69d019871..b1c98ad5e3f79 100644
--- a/Detectors/Base/src/MaterialManager.cxx
+++ b/Detectors/Base/src/MaterialManager.cxx
@@ -123,22 +123,51 @@ void MaterialManager::initDensityMap()
   mDensityMapInitialized = true;
 }
 
-float MaterialManager::getDensity(std::string const& modname)
+float MaterialManager::getDensity(std::string const& modname, std::string const& matname)
 {
+  // This function returns the final density for a material of name matname inside module modname.
+  // The priority is
+  // - return density for a specific module + material if it exists in the lookup
+  // - return density for the module if it exists in the the lookup
+  // - return global density factor
+
+  auto debug = getenv("O2SIM_MATMGR_LOCALDENSITY_DEBUG");
+
   if (!mDensityMapInitialized) {
     initDensityMap();
   }
-  if (mDensityMap.find(modname) != mDensityMap.end()) {
-    return mDensityMap[modname];
+  // density on final material level
+  // (this works by a name lookup of pair "modname/matname")
+  std::string lookupstring = modname + "/" + matname;
+  auto iter = mDensityMap.find(lookupstring);
+  if (iter != mDensityMap.end()) {
+    if (debug) {
+      LOG(info) << "MatManager - " << modname << "/" << matname << " : applying density " << iter->second << " from material match";
+    }
+    return iter->second;
   }
-  return o2::conf::SimMaterialParams::Instance().globalDensityFactor;
+  // density on module level
+  iter = mDensityMap.find(modname);
+  if (iter != mDensityMap.end()) {
+    if (debug) {
+      LOG(info) << "MatManager - " << modname << "/" << matname << " : applying density " << iter->second << " from module match";
+    }
+    return iter->second;
+  }
+  // global factor
+  const auto global = o2::conf::SimMaterialParams::Instance().globalDensityFactor;
+  if (debug && global != 1.0) {
+    LOG(info) << "MatManager - " << modname << "/" << matname << " : applying global density " << iter->second;
+  }
+  return global;
 }
 
 void MaterialManager::Material(const char* modname, Int_t imat, const char* name, Float_t a, Float_t z, Float_t dens,
                                Float_t radl, Float_t absl, Float_t* buf, Int_t nwbuf)
 {
   TString uniquename = modname;
-  auto densityFactor = getDensity(modname);
+  auto densityFactor = getDensity(modname, name);
+
   uniquename.Append("_");
   uniquename.Append(name);
   if (TVirtualMC::GetMC()) {
@@ -173,7 +202,7 @@ void MaterialManager::Mixture(const char* modname, Int_t imat, const char* name,
                               Int_t nlmat, Float_t* wmat)
 {
   TString uniquename = modname;
-  auto densityFactor = getDensity(modname);
+  auto densityFactor = getDensity(modname, name);
   uniquename.Append("_");
   uniquename.Append(name);
 

From 9de536a17d9fdec8d2952b2e740cff62fb964cb6 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 9 Sep 2025 21:04:38 +0200
Subject: [PATCH 0789/1764] GPU TPC: Make buffer size estimation more robust
 and improve error message in GPUWorkflow

---
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx | 9 +++++++++
 GPU/Workflow/src/GPUWorkflowSpec.cxx            | 2 +-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index e923e126e1841..c19e96f1879a8 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -143,6 +143,15 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   mNMaxTracklets = mRec->MemoryScalers()->NTPCTracklets(mData.NumberOfHits());
   mNMaxRowHits = mRec->MemoryScalers()->NTPCTrackletHits(mData.NumberOfHits());
   mNMaxTracks = mRec->MemoryScalers()->NTPCSectorTracks(mData.NumberOfHits());
+  if (io.clustersNative) {
+    uint32_t sectorOffset = mISector >= GPUCA_NSECTORS / 2 ? GPUCA_NSECTORS / 2 : 0;
+    uint32_t nextSector = (mISector + 1) % (GPUCA_NSECTORS / 2) + sectorOffset;
+    uint32_t prevSector = (mISector + GPUCA_NSECTORS - 1) % (GPUCA_NSECTORS / 2) + sectorOffset;
+    uint32_t nExtrapolationTracks = mRec->MemoryScalers()->NTPCSectorTracks((io.clustersNative->nClustersSector[nextSector] + io.clustersNative->nClustersSector[prevSector]) / 2) / 2;
+    if (nExtrapolationTracks > mNMaxTracks) {
+      mNMaxTracks = nExtrapolationTracks;
+    }
+  }
   mNMaxTrackHits = mRec->MemoryScalers()->NTPCSectorTrackHits(mData.NumberOfHits(), mRec->GetProcessingSettings().tpcInputWithClusterRejection);
 
   if (mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking).par_SORT_STARTHITS) {
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 51e3f252811c3..2642ff3ee1ebc 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -900,7 +900,7 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
       }
       createEmptyOutput = !mConfParam->partialOutputForNonFatalErrors;
     } else {
-      throw std::runtime_error("GPU Reconstruction error: error code " + std::to_string(retVal));
+      LOG(fatal) << "GPU Reconstruction aborted with error code " << retVal << " - errors are not ignored - terminating";
     }
   }
 

From 81394149c1b0e98c484e9c743cc22b343a5b86a2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 9 Sep 2025 14:58:14 +0200
Subject: [PATCH 0790/1764] GPU TPC dEdx: Fix out of bounds access

---
 GPU/GPUTracking/dEdx/GPUdEdx.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index e556fd3845d42..9e1727d4988ad 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -118,7 +118,7 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
   const float tanTheta = CAMath::Sqrt(tgl2 * sec2);
 
   // getting the topology correction
-  const uint32_t padPos = CAMath::Float2UIntRn(pad); // position of the pad is shifted half a pad ( pad=3 -> centre position of third pad)
+  const uint32_t padPos = CAMath::Max<uint32_t>(GPUTPCGeometry::NPads(padRow) - 1, CAMath::Float2UIntRn(pad)); // position of the pad is shifted half a pad ( pad=3 -> centre position of third pad)
   const float absRelPad = CAMath::Abs(pad - padPos);
   const int32_t region = geo.GetRegion(padRow);
   z = CAMath::Abs(z);

From 938cb93e4ef7c60f06332405bc047412cfc4bf5f Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 9 Sep 2025 17:40:19 +0200
Subject: [PATCH 0791/1764] MCStudy: fix ITS/TPC extrapolation, optionally add
 TPC track.refs

---
 .../GlobalTrackingWorkflow/study/CMakeLists.txt   |  2 +-
 .../GlobalTrackingStudy/TrackMCStudyConfig.h      |  1 +
 .../GlobalTrackingStudy/TrackMCStudyTypes.h       |  3 ++-
 .../study/src/TrackMCStudy.cxx                    | 15 ++++++++++++---
 4 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
index 776d3946283c3..ab900c7efd87b 100644
--- a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
+++ b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
@@ -9,7 +9,7 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-#add_compile_options(-O0 -g -fPIC)
+add_compile_options(-O0 -g -fPIC)
 
 o2_add_library(GlobalTrackingStudy
                TARGETVARNAME targetName
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
index 74d77eb3d53de..2b92c00a989cf 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
@@ -27,6 +27,7 @@ struct TrackMCStudyConfig : o2::conf::ConfigurableParamHelper<TrackMCStudyConfig
   float decayMotherMaxT = 1.0f; // max TOF in ns for mother particles to study
   bool requireITSorTPCTrackRefs = true;
   bool requireTopBottomRefs = false;
+  bool storeTPCTrackRefs = false;
   int minTPCRefsToExtractClRes = 2;
   int nOccBinsDrift = 10; // number of bins for TPC max drift time, where we integrate the occupancies
   int nTBPerOccBin = 48;  // number of TB per occ bin
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
index 66ae23d91eaaa..4766dc6787351 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
@@ -33,6 +33,7 @@ struct MCTrackInfo {
   int getLowestITSLayer() const;
   int getHighestITSLayer() const;
   std::vector<float> occTPCV{};
+  std::vector<o2::track::TrackPar> trackRefsTPC{};
   o2::track::TrackPar track{};
   o2::MCCompLabel label{};
   float occTPC = -1.f;
@@ -73,7 +74,7 @@ struct MCTrackInfo {
   float getTrackParTPCPar(int i, float b, float x = 90) const;
   float getTrackParTPCPhiSec(float b, float x = 90) const;
 
-  ClassDefNV(MCTrackInfo, 7);
+  ClassDefNV(MCTrackInfo, 8);
 };
 
 struct RecTrack {
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 531a4ec746ccf..9dba400fe6edc 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -507,7 +507,7 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
   }
 
   LOGP(info, "collected {} MC tracks", mSelMCTracks.size());
-  if (params.minTPCRefsToExtractClRes > 0) { // prepare MC trackrefs for TPC
+  if (params.minTPCRefsToExtractClRes > 0 || params.storeTPCTrackRefs) { // prepare MC trackrefs for TPC
     processTPCTrackRefs();
   }
 
@@ -532,6 +532,15 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
       }
       return lhs.gid.getSource() > rhs.gid.getSource();
     });
+    if (params.storeTPCTrackRefs) {
+      auto rft = mSelTRefIdx.find(entry.first);
+      if (rft != mSelTRefIdx.end()) {
+        auto rfent = rft->second;
+        for (int irf = rfent.first; irf < rfent.second; irf++) {
+          trackFam.mcTrackInfo.trackRefsTPC.push_back(mSelTRefs[irf]);
+        }
+      }
+    }
     // fill track params
     int tcnt = 0;
     for (auto& tref : tracks) {
@@ -598,8 +607,8 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
       tcnt++;
     }
     if (trackFam.entITS > -1 && trackFam.entTPC > -1) { // ITS and TPC were found but matching failed
-      auto vidITS = tracks[trackFam.entITS].gid;
-      auto vidTPC = tracks[trackFam.entTPC].gid;
+      auto vidITS = recoData.getITSContributorGID(tracks[trackFam.entITS].gid);
+      auto vidTPC = recoData.getTPCContributorGID(tracks[trackFam.entTPC].gid);
       auto trcTPC = recoData.getTrackParam(vidTPC);
       auto trcITS = recoData.getTrackParamOut(vidITS);
       if (propagateToRefX(trcTPC, trcITS)) {

From e04d84f1b6dc34b8d923fd97dba595a49a4c5f16 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 11 Sep 2025 13:42:49 +0200
Subject: [PATCH 0792/1764] remove new line from Track::asString, set alpha to
 +-pi

---
 .../include/ReconstructionDataFormats/TrackParametrization.h   | 3 +++
 DataFormats/Reconstruction/src/TrackParametrization.cxx        | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index 9c3079208b2f5..87cd059e0b325 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -277,6 +277,7 @@ GPUdi() TrackParametrization<value_T>::TrackParametrization(value_t x, value_t a
   : mX{x}, mAlpha{alpha}, mAbsCharge{char(gpu::CAMath::Abs(charge))}, mPID{pid}
 {
   // explicit constructor
+  math_utils::detail::bringToPMPi<value_t>(mAlpha);
   for (int i = 0; i < kNParams; i++) {
     mP[i] = par[i];
   }
@@ -295,6 +296,7 @@ GPUdi() void TrackParametrization<value_T>::set(value_t x, value_t alpha, const
 {
   mX = x;
   mAlpha = alpha;
+  math_utils::detail::bringToPMPi<value_t>(mAlpha);
   mAbsCharge = char(gpu::CAMath::Abs(charge));
   for (int i = 0; i < kNParams; i++) {
     mP[i] = par[i];
@@ -430,6 +432,7 @@ template <typename value_T>
 GPUdi() void TrackParametrization<value_T>::setAlpha(value_t v)
 {
   mAlpha = v;
+  math_utils::detail::bringToPMPi<value_t>(mAlpha);
 }
 
 //____________________________________________________________
diff --git a/DataFormats/Reconstruction/src/TrackParametrization.cxx b/DataFormats/Reconstruction/src/TrackParametrization.cxx
index 1bdf9b55a60a0..b685a1549dd31 100644
--- a/DataFormats/Reconstruction/src/TrackParametrization.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrization.cxx
@@ -575,7 +575,7 @@ template <typename value_T>
 std::string TrackParametrization<value_T>::asString() const
 {
   // print parameters as string
-  return fmt::format("X:{:+.4e} Alp:{:+.3e} Par: {:+.4e} {:+.4e} {:+.4e} {:+.4e} {:+.4e} |Q|:{:d} {:s}\n",
+  return fmt::format("X:{:+.4e} Alp:{:+.3e} Par: {:+.4e} {:+.4e} {:+.4e} {:+.4e} {:+.4e} |Q|:{:d} {:s}",
                      getX(), getAlpha(), getY(), getZ(), getSnp(), getTgl(), getQ2Pt(), getAbsCharge(), getPID().getName());
 }
 

From cb96bdb701d40dcb6b79a4913664a60d67fce1f7 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sat, 13 Sep 2025 08:45:22 +0200
Subject: [PATCH 0793/1764] ITS: Tracker don't print expected exception
 (#14671)

---
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index e8212f4ad53a1..c6eee88a9f48b 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -66,7 +66,9 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
     LOGP(error, "Too much memory used during {} in iteration {} in ROF span {}-{} iVtx={}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
          StateNames[mCurState], iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, iVertex,
          (double)mTimeFrame->getArtefactsMemory() / GB, (double)mTrkParams[iteration].MaxMemory / GB);
-    LOGP(error, "Exception: {}", err.what());
+    if (typeid(err) != typeid(std::bad_alloc)) { // only print if the exceptions is different from what is expected
+      LOGP(error, "Exception: {}", err.what());
+    }
     if (mTrkParams[iteration].DropTFUponFailure) {
       mMemoryPool->print();
       mTimeFrame->wipe();

From fc68b8bd4338a4b4966c4ef299cc8b64eca38cad Mon Sep 17 00:00:00 2001
From: Sawan Sawan <sawan.sawan@cern.ch>
Date: Mon, 15 Sep 2025 11:46:01 +0530
Subject: [PATCH 0794/1764] Corrected spin and mass of the k0sk0s mass spectrum
 particles according to latest PDG

---
 Steer/src/O2MCApplication.cxx | 43 +++++++++++++++++------------------
 1 file changed, 21 insertions(+), 22 deletions(-)

diff --git a/Steer/src/O2MCApplication.cxx b/Steer/src/O2MCApplication.cxx
index 77b49ec9e2906..584598d350581 100644
--- a/Steer/src/O2MCApplication.cxx
+++ b/Steer/src/O2MCApplication.cxx
@@ -375,8 +375,8 @@ void addSpecialParticles()
   // f0(980) assume 70 MeV as width (PDG: 40 to 100 MeV)
   TVirtualMC::GetMC()->DefineParticle(9010221, "f0_980", kPTNeutron, 0.98, 0.0, 9.403e-24, "Hadron", 7e-2, 0, 1, 1, 0, 0, 1, 0, 0, kTRUE);
 
-  // f2(1270) (PDG: width = 185 MeV)
-  TVirtualMC::GetMC()->DefineParticle(225, "f2_1270", kPTNeutron, 1.275, 0.0, 3.558e-24, "Hadron", 0.185, 4, 1, 1, 0, 0, 1, 0, 0, kTRUE);
+  // f2(1270) (PDG: width = 186 MeV)
+  TVirtualMC::GetMC()->DefineParticle(225, "f2_1270", kPTNeutron, 1.275, 0.0, 3.538e-24, "Hadron", 0.186, 2, 1, 1, 0, 0, 1, 0, 0, kTRUE);
 
   // f1(1285) (PDG: width = 24.20 MeV) Spin/Parity might not be correct
   TVirtualMC::GetMC()->DefineParticle(20223, "f1_1285", kPTNeutron, 1.28210, 0.0, 1e-24, "Hadron", 0.02420, 3, 1, 0, 0, 0, 0, 0, 1, kTRUE);
@@ -391,14 +391,14 @@ void addSpecialParticles()
   // Their life times are not known, so we set them to 1e-24
   // f0(1370) (PDG: width = 200-500 MeV) Spin/Parity might not be correct
   TVirtualMC::GetMC()->DefineParticle(10221, "f0_1370", kPTNeutron, 1.37, 0.0, 1e-24, "Hadron", 0.2, 1, 1, 1, 0, 0, 1, 0, 0, kTRUE);
-  // a2(1320) (PDG: width = 107.8 MeV) (Spin/Parity might not be correct)
-  TVirtualMC::GetMC()->DefineParticle(115, "a2_1320", kPTNeutron, 1.3182, 0.0, 1e-24, "Hadron", 0.1078, 1, 1, 1, 1, 0, 1, 0, 0, kTRUE);
-  // f0(1500) (PDG: width = 112 MeV) Spin/Parity might not be correct
+  // a2(1320) (PDG: width = 107.8 MeV)
+  TVirtualMC::GetMC()->DefineParticle(115, "a2_1320", kPTNeutron, 1.3182, 0.0, 6.1e-24, "Hadron", 0.1078, 2, 1, 1, 1, 0, -1, 0, 0, kTRUE);
+  // f0(1500) (PDG: width = 112 MeV)
   TVirtualMC::GetMC()->DefineParticle(9030221, "f0_1500", kPTNeutron, 1.506, 0.0, 1e-24, "Hadron", 0.112, 0, 1, 1, 0, 0, 1, 0, 0, kTRUE);
-  // f0(1710) (PDG: width = 139 MeV) Spin/Parity might not be correct
-  TVirtualMC::GetMC()->DefineParticle(10331, "f0_1710", kPTNeutron, 1.71, 0.0, 1e-24, "Hadron", 0.139, 1, 1, 1, 0, 0, 1, 0, 0, kTRUE);
-  // f2(1525) (PDG: width = 73 MeV) Spin/Parity might not be correct
-  TVirtualMC::GetMC()->DefineParticle(335, "f2_1525", kPTNeutron, 1.525, 0.0, 1e-24, "Hadron", 0.073, 5, 1, 1, 0, 0, 1, 0, 0, kTRUE);
+  // f0(1710) (PDG: width = 150 MeV)
+  TVirtualMC::GetMC()->DefineParticle(10331, "f0_1710", kPTNeutron, 1.71, 0.0, 4.4e-24, "Hadron", 0.150, 0, 1, 1, 0, 0, 1, 0, 0, kTRUE);
+  // f2(1525) (PDG: width = 84 MeV)
+  TVirtualMC::GetMC()->DefineParticle(335, "f2_1525", kPTNeutron, 1.525, 0.0, 7.798e-24, "Hadron", 0.084, 2, 1, 1, 0, 0, 1, 0, 0, kTRUE);
 
   // Xi_0(1820)
   TVirtualMC::GetMC()->DefineParticle(123324, "Xi_0_1820", kPTNeutron, 1.8234, 0.0, 2.742550e-23, "Hadron", 0.024, 3, -1, 0, 1, 1, 0, 0, 1, kTRUE);
@@ -1331,22 +1331,20 @@ void addSpecialParticles()
   TVirtualMC::GetMC()->SetDecayMode(9010221, bratio, mode);
 
   // Define the 2-body phase space decay for the f2(1270)
-  //  Int_t mode[6][3];
-  //  Float_t bratio[6];
 
-  for (Int_t kz = 0; kz < 6; kz++) {
-    bratio[kz] = 0.;
-    mode[kz][0] = 0;
-    mode[kz][1] = 0;
-    mode[kz][2] = 0;
-  }
-  bratio[0] = 100.;
-  mode[0][0] = 211;  // pion
-  mode[0][1] = -211; // pion
+  // for (Int_t kz = 0; kz < 6; kz++) {
+  //   bratio[kz] = 0.;
+  //   mode[kz][0] = 0;
+  //   mode[kz][1] = 0;
+  //   mode[kz][2] = 0;
+  // }
+  // bratio[0] = 100.;
+  // mode[0][0] = 211;  // pion
+  // mode[0][1] = -211; // pion
 
-  TVirtualMC::GetMC()->SetDecayMode(225, bratio, mode);
+  // TVirtualMC::GetMC()->SetDecayMode(225, bratio, mode);
 
-  // Define the 2-body phase space decay for the resonances: f0(1500), f2(1525), f0(1710
+  // Define the 2-body phase space decay for the resonances: f0(1500), f2(1525), f0(1710), f0(1370), a2(1320), f2(1270)
   for (Int_t kz = 0; kz < 6; kz++) {
     bratio[kz] = 0.;
     mode[kz][0] = 0;
@@ -1362,6 +1360,7 @@ void addSpecialParticles()
   TVirtualMC::GetMC()->SetDecayMode(10331, bratio, mode);   // f0(1710)
   TVirtualMC::GetMC()->SetDecayMode(10221, bratio, mode);   // f0(1370)
   TVirtualMC::GetMC()->SetDecayMode(115, bratio, mode);     // a2(1320)
+  TVirtualMC::GetMC()->SetDecayMode(225, bratio, mode);     // f2(1270)
 
   // Define the 3-body phase space decay for the resonances: f1(1285), f1(1420)
   for (Int_t kz = 0; kz < 6; kz++) {

From 3135513204c0e3e371840a7c2cd6236871469a7d Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 15 Sep 2025 18:54:51 +0200
Subject: [PATCH 0795/1764] ITS: GPU: partial Vertexer implementation (#14672)

---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  49 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   | 189 +++++
 .../GPU/ITStrackingGPU/VertexerTraitsGPU.h    |  15 +-
 .../GPU/ITStrackingGPU/VertexingKernels.h     | 134 +++-
 .../ITS/tracking/GPU/cuda/CMakeLists.txt      |   4 +-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 105 ++-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |   6 +-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 110 +--
 .../tracking/GPU/cuda/VertexerTraitsGPU.cxx   | 324 ++++----
 .../ITS/tracking/GPU/cuda/VertexingKernels.cu | 718 ++++++++++--------
 .../ITS/tracking/GPU/hip/CMakeLists.txt       |   4 +-
 .../include/ITStracking/Definitions.h         |  12 +-
 .../tracking/include/ITStracking/TimeFrame.h  |  19 +-
 .../include/ITStracking/TrackingConfigParam.h |   6 +
 .../include/ITStracking/VertexerTraits.h      |   5 -
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |   2 +-
 .../ITS/tracking/src/VertexerTraits.cxx       |   4 +
 .../Base/GPUReconstructionIncludesITS.h       |  10 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        |   4 +-
 GPU/GPUTracking/Global/GPUChainITS.cxx        |   2 +-
 20 files changed, 1009 insertions(+), 713 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index a1d52bff11f9d..2bd1550e7c72b 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -25,13 +25,13 @@ namespace o2::its::gpu
 {
 
 template <int nLayers = 7>
-class TimeFrameGPU : public TimeFrame<nLayers>
+class TimeFrameGPU final : public TimeFrame<nLayers>
 {
   using typename TimeFrame<nLayers>::CellSeedN;
   using typename TimeFrame<nLayers>::IndexTableUtilsN;
 
  public:
-  TimeFrameGPU();
+  TimeFrameGPU() = default;
   ~TimeFrameGPU() = default;
 
   /// Most relevant operations
@@ -44,13 +44,13 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void loadTrackingFrameInfoDevice(const int, const int);
   void createTrackingFrameInfoDeviceArray(const int);
   void loadUnsortedClustersDevice(const int, const int);
-  void createUnsortedClustersDeviceArray(const int);
+  void createUnsortedClustersDeviceArray(const int, const int = nLayers);
   void loadClustersDevice(const int, const int);
-  void createClustersDeviceArray(const int);
+  void createClustersDeviceArray(const int, const int = nLayers);
   void loadClustersIndexTables(const int, const int);
-  void createClustersIndexTablesArray(const int iteration);
+  void createClustersIndexTablesArray(const int);
   void createUsedClustersDevice(const int, const int);
-  void createUsedClustersDeviceArray(const int);
+  void createUsedClustersDeviceArray(const int, const int = nLayers);
   void loadUsedClustersDevice();
   void loadROFrameClustersDevice(const int, const int);
   void createROFrameClustersDeviceArray(const int);
@@ -85,6 +85,12 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
 
+  /// Vertexer
+  void createVtxTrackletsLUTDevice(const int32_t);
+  void createVtxTrackletsBuffers(const int32_t);
+  void createVtxLinesLUTDevice(const int32_t);
+  void createVtxLinesBuffer(const int32_t);
+
   /// synchronization
   auto& getStream(const size_t stream) { return mGpuStreams[stream]; }
   auto& getStreams() { return mGpuStreams; }
@@ -98,6 +104,8 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   virtual void wipe() final;
 
   /// interface
+  virtual bool isGPU() const noexcept final { return true; }
+  virtual const char* getName() const noexcept { return "GPU"; }
   int getNClustersInRofSpan(const int, const int, const int) const;
   IndexTableUtilsN* getDeviceIndexTableUtils() { return mIndexTableUtilsDevice; }
   int* getDeviceROFramesClusters(const int layer) { return mROFramesClustersDevice[layer]; }
@@ -122,7 +130,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   const Cluster** getDeviceArrayUnsortedClusters() const { return mUnsortedClustersDeviceArray; }
   const int** getDeviceArrayClustersIndexTables() const { return mClustersIndexTablesDeviceArray; }
   std::vector<unsigned int> getClusterSizes();
-  const unsigned char** getDeviceArrayUsedClusters() const { return mUsedClustersDeviceArray; }
+  uint8_t** getDeviceArrayUsedClusters() const { return mUsedClustersDeviceArray; }
   const int** getDeviceROFrameClusters() const { return mROFramesClustersDeviceArray; }
   Tracklet** getDeviceArrayTracklets() { return mTrackletsDeviceArray; }
   int** getDeviceArrayTrackletsLUT() const { return mTrackletsLUTDeviceArray; }
@@ -135,6 +143,19 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   int* getDeviceNeighboursIndexTables(const int layer) { return mNeighboursIndexTablesDevice[layer]; }
   uint8_t* getDeviceMultCutMask() { return mMultMaskDevice; }
 
+  // Vertexer
+  auto& getDeviceNTrackletsPerROF() const noexcept { return mNTrackletsPerROFDevice; }
+  auto& getDeviceNTrackletsPerCluster() const noexcept { return mNTrackletsPerClusterDevice; }
+  auto& getDeviceNTrackletsPerClusterSum() const noexcept { return mNTrackletsPerClusterSumDevice; }
+  int32_t** getDeviceArrayNTrackletsPerROF() const noexcept { return mNTrackletsPerROFDeviceArray; }
+  int32_t** getDeviceArrayNTrackletsPerCluster() const noexcept { return mNTrackletsPerClusterDeviceArray; }
+  int32_t** getDeviceArrayNTrackletsPerClusterSum() const noexcept { return mNTrackletsPerClusterSumDeviceArray; }
+  uint8_t* getDeviceUsedTracklets() const noexcept { return mUsedTrackletsDevice; }
+  int32_t* getDeviceNLinesPerCluster() const noexcept { return mNLinesPerClusterDevice; }
+  int32_t* getDeviceNLinesPerClusterSum() const noexcept { return mNLinesPerClusterSumDevice; }
+  Line* getDeviceLines() const noexcept { return mLinesDevice; }
+  gsl::span<int*> getDeviceTrackletsPerROFs() { return mNTrackletsPerROFDevice; }
+
   void setDevicePropagator(const o2::base::PropagatorImpl<float>* p) final { this->mPropagatorDevice = p; }
 
   // Host-specific getters
@@ -180,7 +201,7 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   const Cluster** mClustersDeviceArray;
   const Cluster** mUnsortedClustersDeviceArray;
   const int** mClustersIndexTablesDeviceArray;
-  const unsigned char** mUsedClustersDeviceArray;
+  uint8_t** mUsedClustersDeviceArray;
   const int** mROFramesClustersDeviceArray;
   std::array<Tracklet*, nLayers - 1> mTrackletsDevice;
   std::array<int*, nLayers - 1> mTrackletsLUTDevice;
@@ -208,6 +229,18 @@ class TimeFrameGPU : public TimeFrame<nLayers>
   std::array<TrackingFrameInfo*, nLayers> mTrackingFrameInfoDevice;
   const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
+  /// Vertexer
+  std::array<int32_t*, 2> mNTrackletsPerROFDevice;
+  std::array<int32_t*, 2> mNTrackletsPerClusterDevice;
+  std::array<int32_t*, 2> mNTrackletsPerClusterSumDevice;
+  uint8_t* mUsedTrackletsDevice;
+  int32_t* mNLinesPerClusterDevice;
+  int32_t* mNLinesPerClusterSumDevice;
+  int32_t** mNTrackletsPerROFDeviceArray;
+  int32_t** mNTrackletsPerClusterDeviceArray;
+  int32_t** mNTrackletsPerClusterSumDeviceArray;
+  Line* mLinesDevice;
+
   // State
   Streams mGpuStreams;
   std::bitset<nLayers + 1> mPinnedUnsortedClusters{0};
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index 15fe6f05f7850..e5b9253ca4090 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -20,15 +20,22 @@
 #include <string>
 #include <tuple>
 
+#include "ITStracking/MathUtils.h"
+#include "ITStracking/ExternalAllocator.h"
+
 #include "GPUCommonDef.h"
 #include "GPUCommonHelpers.h"
 #include "GPUCommonLogger.h"
+#include "GPUCommonDefAPI.h"
 
+#ifdef GPUCA_GPUCODE
+#include <thrust/device_ptr.h>
 #ifndef __HIPCC__
 #define THRUST_NAMESPACE thrust::cuda
 #else
 #define THRUST_NAMESPACE thrust::hip
 #endif
+#endif
 
 #ifdef ITS_GPU_LOG
 #define GPULog(...) LOGP(info, __VA_ARGS__)
@@ -38,6 +45,10 @@
 
 namespace o2::its
 {
+// FWD declarations
+template <int>
+class IndexTableUtils;
+class Tracklet;
 
 template <typename T1, typename T2>
 using gpuPair = std::pair<T1, T2>;
@@ -282,6 +293,184 @@ class GPUTimer
   }
 };
 #endif
+
+#ifdef GPUCA_GPUCODE
+template <typename T>
+struct TypedAllocator {
+  using value_type = T;
+  using pointer = thrust::device_ptr<T>;
+  using const_pointer = thrust::device_ptr<const T>;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  TypedAllocator() noexcept : mInternalAllocator(nullptr) {}
+  explicit TypedAllocator(ExternalAllocator* a) noexcept : mInternalAllocator(a) {}
+
+  template <typename U>
+  TypedAllocator(const TypedAllocator<U>& o) noexcept : mInternalAllocator(o.mInternalAllocator)
+  {
+  }
+
+  pointer allocate(size_type n)
+  {
+    void* raw = mInternalAllocator->allocate(n * sizeof(T));
+    return thrust::device_pointer_cast(static_cast<T*>(raw));
+  }
+
+  void deallocate(pointer p, size_type n) noexcept
+  {
+    if (!p) {
+      return;
+    }
+    void* raw = thrust::raw_pointer_cast(p);
+    mInternalAllocator->deallocate(static_cast<char*>(raw), n * sizeof(T));
+  }
+
+  bool operator==(TypedAllocator const& o) const noexcept
+  {
+    return mInternalAllocator == o.mInternalAllocator;
+  }
+  bool operator!=(TypedAllocator const& o) const noexcept
+  {
+    return !(*this == o);
+  }
+
+ private:
+  ExternalAllocator* mInternalAllocator;
+};
+
+template <int nLayers>
+GPUdii() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
+                                const o2::its::IndexTableUtils<nLayers>* utils,
+                                const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
+{
+  const float zRangeMin = o2::gpu::CAMath::Min(z1, z2) - maxdeltaz;
+  const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : currentCluster.phi - maxdeltaphi;
+  const float zRangeMax = o2::gpu::CAMath::Max(z1, z2) + maxdeltaz;
+  const float phiRangeMax = (maxdeltaphi > o2::constants::math::PI) ? o2::constants::math::TwoPI : currentCluster.phi + maxdeltaphi;
+
+  if (zRangeMax < -utils->getLayerZ(layerIndex) ||
+      zRangeMin > utils->getLayerZ(layerIndex) || zRangeMin > zRangeMax) {
+    return {};
+  }
+
+  return int4{o2::gpu::CAMath::Max(0, utils->getZBinIndex(layerIndex, zRangeMin)),
+              utils->getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
+              o2::gpu::CAMath::Min(utils->getNzBins() - 1, utils->getZBinIndex(layerIndex, zRangeMax)),
+              utils->getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
+}
+
+GPUdii() gpuSpan<const Vertex> getPrimaryVertices(const int rof,
+                                                  const int* roframesPV,
+                                                  const int nROF,
+                                                  const uint8_t* mask,
+                                                  const Vertex* vertices)
+{
+  const int start_pv_id = roframesPV[rof];
+  const int stop_rof = rof >= nROF - 1 ? nROF : rof + 1;
+  size_t delta = mask[rof] ? roframesPV[stop_rof] - start_pv_id : 0; // return empty span if ROF is excluded
+  return gpuSpan<const Vertex>(&vertices[start_pv_id], delta);
+};
+
+GPUdii() gpuSpan<const Vertex> getPrimaryVertices(const int romin,
+                                                  const int romax,
+                                                  const int* roframesPV,
+                                                  const int nROF,
+                                                  const Vertex* vertices)
+{
+  const int start_pv_id = roframesPV[romin];
+  const int stop_rof = romax >= nROF - 1 ? nROF : romax + 1;
+  return gpuSpan<const Vertex>(&vertices[start_pv_id], roframesPV[stop_rof] - roframesPV[romin]);
+};
+
+GPUdii() gpuSpan<const Cluster> getClustersOnLayer(const int rof,
+                                                   const int totROFs,
+                                                   const int layer,
+                                                   const int** roframesClus,
+                                                   const Cluster** clusters)
+{
+  if (rof < 0 || rof >= totROFs) {
+    return gpuSpan<const Cluster>();
+  }
+  const int start_clus_id{roframesClus[layer][rof]};
+  const int stop_rof = rof >= totROFs - 1 ? totROFs : rof + 1;
+  const unsigned int delta = roframesClus[layer][stop_rof] - start_clus_id;
+  return gpuSpan<const Cluster>(&(clusters[layer][start_clus_id]), delta);
+}
+
+GPUdii() gpuSpan<const Tracklet> getTrackletsPerCluster(const int rof,
+                                                        const int totROFs,
+                                                        const int mode,
+                                                        const int** roframesClus,
+                                                        const Tracklet** tracklets)
+{
+  if (rof < 0 || rof >= totROFs) {
+    return gpuSpan<const Tracklet>();
+  }
+  const int start_clus_id{roframesClus[1][rof]};
+  const int stop_rof = rof >= totROFs - 1 ? totROFs : rof + 1;
+  const unsigned int delta = roframesClus[1][stop_rof] - start_clus_id;
+  return gpuSpan<const Tracklet>(&(tracklets[mode][start_clus_id]), delta);
+}
+
+GPUdii() gpuSpan<int> getNTrackletsPerCluster(const int rof,
+                                              const int totROFs,
+                                              const int mode,
+                                              const int** roframesClus,
+                                              int** ntracklets)
+{
+  if (rof < 0 || rof >= totROFs) {
+    return gpuSpan<int>();
+  }
+  const int start_clus_id{roframesClus[1][rof]};
+  const int stop_rof = rof >= totROFs - 1 ? totROFs : rof + 1;
+  const unsigned int delta = roframesClus[1][stop_rof] - start_clus_id;
+  return gpuSpan<int>(&(ntracklets[mode][start_clus_id]), delta);
+}
+
+GPUdii() gpuSpan<const int> getNTrackletsPerCluster(const int rof,
+                                                    const int totROFs,
+                                                    const int mode,
+                                                    const int** roframesClus,
+                                                    const int** ntracklets)
+{
+  if (rof < 0 || rof >= totROFs) {
+    return gpuSpan<const int>();
+  }
+  const int start_clus_id{roframesClus[1][rof]};
+  const int stop_rof = rof >= totROFs - 1 ? totROFs : rof + 1;
+  const unsigned int delta = roframesClus[1][stop_rof] - start_clus_id;
+  return gpuSpan<const int>(&(ntracklets[mode][start_clus_id]), delta);
+}
+
+GPUdii() gpuSpan<int> getNLinesPerCluster(const int rof,
+                                          const int totROFs,
+                                          const int** roframesClus,
+                                          int* nlines)
+{
+  if (rof < 0 || rof >= totROFs) {
+    return gpuSpan<int>();
+  }
+  const int start_clus_id{roframesClus[1][rof]};
+  const int stop_rof = rof >= totROFs - 1 ? totROFs : rof + 1;
+  const unsigned int delta = roframesClus[1][stop_rof] - start_clus_id;
+  return gpuSpan<int>(&(nlines[start_clus_id]), delta);
+}
+
+GPUdii() gpuSpan<const int> getNLinesPerCluster(const int rof,
+                                                const int totROFs,
+                                                const int** roframesClus,
+                                                const int* nlines)
+{
+  if (rof < 0 || rof >= totROFs) {
+    return gpuSpan<const int>();
+  }
+  const int start_clus_id{roframesClus[1][rof]};
+  const int stop_rof = rof >= totROFs - 1 ? totROFs : rof + 1;
+  const unsigned int delta = roframesClus[1][stop_rof] - start_clus_id;
+  return gpuSpan<const int>(&(nlines[start_clus_id]), delta);
+}
+#endif
 } // namespace gpu
 } // namespace o2::its
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
index 5b1d9194e1174..dddc247466c65 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
@@ -31,32 +31,25 @@
 namespace o2::its
 {
 
-class VertexerTraitsGPU final : public VertexerTraits
+template <int nLayers>
+class VertexerTraitsGPU final : public VertexerTraits<nLayers>
 {
  public:
   void initialise(const TrackingParameters&, const int iteration = 0) final;
-  void adoptTimeFrame(TimeFrame<7>*) noexcept final;
+  void adoptTimeFrame(TimeFrame<nLayers>* tf) noexcept final;
   void computeTracklets(const int iteration = 0) final;
   void computeTrackletMatching(const int iteration = 0) final;
   void computeVertices(const int iteration = 0) final;
   void updateVertexingParameters(const std::vector<VertexingParameters>&, const TimeFrameGPUParameters&) final;
-  void computeVerticesHist();
 
   bool isGPU() const noexcept final { return true; }
   const char* getName() const noexcept final { return "GPU"; }
 
  protected:
-  IndexTableUtils* mDeviceIndexTableUtils;
-  gpu::TimeFrameGPU<7>* mTimeFrameGPU;
+  gpu::TimeFrameGPU<nLayers>* mTimeFrameGPU;
   TimeFrameGPUParameters mTfGPUParams;
 };
 
-inline void VertexerTraitsGPU::adoptTimeFrame(TimeFrame<7>* tf) noexcept
-{
-  mTimeFrameGPU = static_cast<gpu::TimeFrameGPU<7>*>(tf);
-  mTimeFrame = static_cast<TimeFrame<7>*>(tf);
-}
-
 } // namespace o2::its
 
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
index 059b1cdc29082..67f12bad8486c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
@@ -12,46 +12,104 @@
 
 #ifndef ITSTRACKINGGPU_VERTEXINGKERNELS_H_
 #define ITSTRACKINGGPU_VERTEXINGKERNELS_H_
-#include "ITStracking/MathUtils.h"
-#include "ITStracking/Configuration.h"
-#include "ITStracking/ClusterLines.h"
-#include "ITStracking/Tracklet.h"
 
+#include <cstdint>
+#include <gsl/span>
+#include <array>
+#include "ITStracking/Tracklet.h"
+#include "ITStracking/Cluster.h"
+#include "ITStracking/ClusterLines.h"
 #include "ITStrackingGPU/Utils.h"
-#include "ITStrackingGPU/ClusterLinesGPU.h"
-#include "ITStrackingGPU/VertexerTraitsGPU.h"
-#include "ITStrackingGPU/TracerGPU.h"
 
-namespace o2::its::gpu
+namespace o2::its
 {
-#ifdef GPUCA_GPUCODE // GPUg() global kernels must only when compiled by GPU compiler
-template <TrackletMode Mode>
-GPUg() void trackleterKernelMultipleRof(
-  const Cluster* clustersNextLayer,    // 0 2
-  const Cluster* clustersCurrentLayer, // 1 1
-  const int* sizeNextLClusters,
-  const int* sizeCurrentLClusters,
-  const int* nextIndexTables,
-  Tracklet* Tracklets,
-  int* foundTracklets,
-  const IndexTableUtils* utils,
-  const unsigned int startRofId,
-  const unsigned int rofSize,
-  const float phiCut,
-  const size_t maxTrackletsPerCluster);
-#endif
-template <TrackletMode Mode>
-void trackletFinderHandler(const Cluster* clustersNextLayer,    // 0 2
-                           const Cluster* clustersCurrentLayer, // 1 1
-                           const int* sizeNextLClusters,
-                           const int* sizeCurrentLClusters,
-                           const int* nextIndexTables,
-                           Tracklet* Tracklets,
-                           int* foundTracklets,
-                           const IndexTableUtils* utils,
-                           const unsigned int startRofId,
-                           const unsigned int rofSize,
-                           const float phiCut,
-                           const size_t maxTrackletsPerCluster = 1e2);
-} // namespace o2::its::gpu
+
+/// Trackleting
+template <int32_t nLayers>
+void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* GPUrestrict() utils,
+                                 const uint8_t* GPUrestrict() multMask,
+                                 const int32_t nRofs,
+                                 const int32_t deltaROF,
+                                 const int32_t* GPUrestrict() rofPV,
+                                 const int32_t vertPerRofThreshold,
+                                 const Cluster** GPUrestrict() clusters,
+                                 const uint32_t nClusters,
+                                 const int32_t** GPUrestrict() ROFClusters,
+                                 const uint8_t** GPUrestrict() usedClusters,
+                                 const int32_t** GPUrestrict() clustersIndexTables,
+                                 int32_t** trackletsPerClusterLUTs,
+                                 int32_t** trackletsPerClusterSumLUTs,
+                                 int32_t** trackletsPerROF,
+                                 const std::array<int32_t*, 2>& trackletsPerClusterLUTsHost,
+                                 const std::array<int32_t*, 2>& trackletsPerClusterSumLUTsHost,
+                                 const int32_t iteration,
+                                 const float phiCut,
+                                 const int32_t maxTrackletsPerCluster,
+                                 const int32_t nBlocks,
+                                 const int32_t nThreads,
+                                 gpu::Streams& streams);
+
+template <int32_t nLayers>
+void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* GPUrestrict() utils,
+                                   const uint8_t* GPUrestrict() multMask,
+                                   const int32_t nRofs,
+                                   const int32_t deltaROF,
+                                   const int32_t* GPUrestrict() rofPV,
+                                   const int vertPerRofThreshold,
+                                   const Cluster** GPUrestrict() clusters,
+                                   const uint32_t nClusters,
+                                   const int32_t** GPUrestrict() ROFClusters,
+                                   const uint8_t** GPUrestrict() usedClusters,
+                                   const int32_t** GPUrestrict() clustersIndexTables,
+                                   Tracklet** GPUrestrict() foundTracklets,
+                                   const int32_t** GPUrestrict() trackletsPerClusterLUTs,
+                                   const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
+                                   const int32_t** GPUrestrict() trackletsPerROF,
+                                   const int32_t iteration,
+                                   const float phiCut,
+                                   const int32_t maxTrackletsPerCluster,
+                                   const int32_t nBlocks,
+                                   const int32_t nThreads,
+                                   gpu::Streams& streams);
+
+/// Selection
+void countTrackletsMatchingInROFsHandler(const int32_t nRofs,
+                                         const int32_t deltaROF,
+                                         const uint32_t nClusters,
+                                         const int32_t** GPUrestrict() ROFClusters,
+                                         const Cluster** GPUrestrict() clusters,
+                                         uint8_t** GPUrestrict() usedClusters,
+                                         const Tracklet** GPUrestrict() foundTracklets,
+                                         uint8_t* GPUrestrict() usedTracklets,
+                                         const int32_t** GPUrestrict() trackletsPerClusterLUTs,
+                                         const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
+                                         int32_t* GPUrestrict() linesPerClusterLUT,
+                                         int32_t* GPUrestrict() linesPerClusterSumLUT,
+                                         const int32_t iteration,
+                                         const float phiCut,
+                                         const float tanLambdaCut,
+                                         const int32_t nBlocks,
+                                         const int32_t nThreads,
+                                         gpu::Streams& streams);
+
+void computeTrackletsMatchingInROFsHandler(const int32_t nRofs,
+                                           const int32_t deltaROF,
+                                           const uint32_t nClusters,
+                                           const int32_t** GPUrestrict() ROFClusters,
+                                           const Cluster** GPUrestrict() clusters,
+                                           const uint8_t** GPUrestrict() usedClusters,
+                                           const Tracklet** GPUrestrict() foundTracklets,
+                                           uint8_t* GPUrestrict() usedTracklets,
+                                           const int32_t** GPUrestrict() trackletsPerClusterLUTs,
+                                           const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
+                                           const int32_t* GPUrestrict() linesPerClusterSumLUT,
+                                           Line* GPUrestrict() lines,
+                                           const int32_t iteration,
+                                           const float phiCut,
+                                           const float tanLambdaCut,
+                                           const int32_t nBlocks,
+                                           const int32_t nThreads,
+                                           gpu::Streams& streams);
+
+} // namespace o2::its
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index 3dff67dbccd80..1f6a046a81350 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -22,8 +22,8 @@ if(CUDA_ENABLED)
                            TimeFrameGPU.cu
                            TracerGPU.cu
                            TrackingKernels.cu
-                           # VertexingKernels.cu
-                           # VertexerTraitsGPU.cxx
+                           VertexingKernels.cu
+                           VertexerTraitsGPU.cxx
                    PUBLIC_INCLUDE_DIRECTORIES ../
                    PUBLIC_LINK_LIBRARIES O2::ITStracking
                                          O2::SimConfig
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 965bf27fdd12b..4da91522371f8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -28,12 +28,6 @@
 namespace o2::its::gpu
 {
 
-template <int nLayers>
-TimeFrameGPU<nLayers>::TimeFrameGPU()
-{
-  this->mIsGPU = true;
-}
-
 template <int nLayers>
 void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& stream, bool extAllocator)
 {
@@ -69,14 +63,14 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createUnsortedClustersDeviceArray(const int iteration)
+void TimeFrameGPU<nLayers>::createUnsortedClustersDeviceArray(const int iteration, const int maxLayers)
 {
   if (!iteration) {
     GPUTimer timer("creating unsorted clusters array");
     allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     mPinnedUnsortedClusters.set(nLayers);
-    for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+    for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
       GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
       mPinnedUnsortedClusters.set(iLayer);
     }
@@ -96,14 +90,14 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration, cons
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createClustersDeviceArray(const int iteration)
+void TimeFrameGPU<nLayers>::createClustersDeviceArray(const int iteration, const int maxLayers)
 {
   if (!iteration) {
     GPUTimer timer("creating sorted clusters array");
     allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     mPinnedClusters.set(nLayers);
-    for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+    for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
       GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
       mPinnedClusters.set(iLayer);
     }
@@ -150,15 +144,15 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration, const i
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createUsedClustersDeviceArray(const int iteration)
+void TimeFrameGPU<nLayers>::createUsedClustersDeviceArray(const int iteration, const int maxLayers)
 {
   if (!iteration) {
     GPUTimer timer("creating used clusters flags");
-    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(unsigned char*), this->getExtAllocator());
-    GPUChkErrS(cudaHostRegister(mUsedClustersDevice.data(), nLayers * sizeof(unsigned char*), cudaHostRegisterPortable));
+    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(uint8_t*), this->getExtAllocator());
+    GPUChkErrS(cudaHostRegister(mUsedClustersDevice.data(), nLayers * sizeof(uint8_t*), cudaHostRegisterPortable));
     mPinnedUsedClusters.set(nLayers);
-    for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPUChkErrS(cudaHostRegister(this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaHostRegisterPortable));
+    for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
+      GPUChkErrS(cudaHostRegister(this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(uint8_t), cudaHostRegisterPortable));
       mPinnedUsedClusters.set(iLayer);
     }
   }
@@ -460,6 +454,87 @@ void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeedN>& s
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
 }
 
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createVtxTrackletsLUTDevice(const int32_t iteration)
+{
+  GPUTimer timer("creating vertexer tracklet LUTs");
+  const int32_t ncls = this->mClusters[1].size();
+  for (int32_t iMode{0}; iMode < 2; ++iMode) {
+    if (!iteration) {
+      GPULog("gpu-transfer: creating vertexer tracklets per cluster for {} elements for mode {}, for {:.2f} MB.", ncls, iMode, ncls * sizeof(int32_t) / constants::MB);
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterDevice[iMode]), ncls * sizeof(int32_t), mGpuStreams[iMode], this->getExtAllocator());
+
+      GPULog("gpu-transfer: creating vertexer tracklets per cluster sum for {} elements for mode {}, for {:.2f} MB.", ncls + 1, iMode, (ncls + 1) * sizeof(int32_t) / constants::MB);
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDevice[iMode]), (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode], this->getExtAllocator());
+
+      GPULog("gpu-transfer: creating vertexer tracklets per ROF for {} elements for mode {}, for {:.2f} MB.", this->mNrof + 1, iMode, (this->mNrof + 1) * sizeof(int32_t) / constants::MB);
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerROFDevice[iMode]), (this->mNrof + 1) * sizeof(int32_t), mGpuStreams[iMode], this->getExtAllocator());
+    }
+    GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterDevice[iMode], 0, ncls * sizeof(int32_t), mGpuStreams[iMode].get()));
+    GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterSumDevice[iMode], 0, (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode].get()));
+    GPUChkErrS(cudaMemsetAsync(mNTrackletsPerROFDevice[iMode], 0, (this->mNrof + 1) * sizeof(int32_t), mGpuStreams[iMode].get()));
+  }
+  mGpuStreams[0].sync();
+  mGpuStreams[1].sync();
+  if (!iteration) {
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterDeviceArray), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpy(mNTrackletsPerClusterDeviceArray, mNTrackletsPerClusterDevice.data(), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
+
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDeviceArray), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpy(mNTrackletsPerClusterSumDeviceArray, mNTrackletsPerClusterSumDevice.data(), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
+
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerROFDeviceArray), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), this->getExtAllocator());
+    GPUChkErrS(cudaMemcpy(mNTrackletsPerROFDeviceArray, mNTrackletsPerROFDevice.data(), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
+  }
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createVtxTrackletsBuffers(const int32_t iteration)
+{
+  GPUTimer timer("creating vertexer tracklet buffers");
+  for (int32_t iMode{0}; iMode < 2; ++iMode) {
+    this->mTotalTracklets[iMode] = 0;
+    GPUChkErrS(cudaMemcpyAsync(&(this->mTotalTracklets[iMode]), mNTrackletsPerClusterSumDevice[iMode] + this->mClusters[1].size(), sizeof(int32_t), cudaMemcpyDeviceToHost, mGpuStreams[iMode].get()));
+    GPULog("gpu-transfer: creating vertexer tracklets buffer for {} elements on layer {}, for {:.2f} MB.", this->mTotalTracklets[iMode], iMode, this->mTotalTracklets[iMode] * sizeof(Tracklet) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iMode]), this->mTotalTracklets[iMode] * sizeof(Tracklet), mGpuStreams[iMode], this->getExtAllocator());
+  }
+  mGpuStreams[0].sync();
+  mGpuStreams[1].sync();
+  allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), 2 * sizeof(Tracklet*), this->getExtAllocator());
+  GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), 2 * sizeof(Tracklet*), cudaHostRegisterPortable));
+  GPUChkErrS(cudaMemcpy(mTrackletsDeviceArray, mTrackletsDevice.data(), 2 * sizeof(Tracklet*), cudaMemcpyHostToDevice));
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createVtxLinesLUTDevice(const int32_t iteration)
+{
+  GPUTimer timer("creating vertexer lines LUT and used tracklets buffer");
+  const int32_t ncls = this->mClusters[1].size();
+
+  GPULog("gpu-transfer: creating vertexer lines per cluster for {} elements , for {:.2f} MB.", ncls, ncls * sizeof(int32_t) / constants::MB);
+  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterDevice), ncls * sizeof(int32_t), this->getExtAllocator());
+
+  GPULog("gpu-transfer: creating vertexer lines per cluster sum for {} elements , for {:.2f} MB.", ncls + 1, (ncls + 1) * sizeof(int32_t) / constants::MB);
+  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterSumDevice), (ncls + 1) * sizeof(int32_t), this->getExtAllocator());
+
+  const int32_t ntrkls = this->mTotalTracklets[0];
+  GPULog("gpu-transfer: creating vertexer used tracklets for {} elements , for {:.2f} MB.", ntrkls, ntrkls * sizeof(uint8_t) / constants::MB);
+  allocMem(reinterpret_cast<void**>(&mUsedTrackletsDevice), ntrkls * sizeof(uint8_t), this->getExtAllocator());
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::createVtxLinesBuffer(const int32_t iteration)
+{
+  GPUTimer timer("creating vertexer lines buffer and resetting used tracklets");
+  int32_t nlines = 0;
+  GPUChkErrS(cudaMemcpy(&nlines, mNLinesPerClusterDevice + this->mClusters[1].size(), sizeof(int32_t), cudaMemcpyDeviceToHost));
+  this->mTotalLines = nlines;
+  GPULog("gpu-transfer: creating vertexer lines for {} elements , for {:.2f} MB.", nlines, nlines * sizeof(Line) / constants::MB);
+  allocMem(reinterpret_cast<void**>(&mLinesDevice), nlines * sizeof(Line), this->getExtAllocator());
+  // reset used tracklets
+  GPUChkErrS(cudaMemset(mUsedTrackletsDevice, 0, this->mTotalTracklets[0] * sizeof(uint8_t)));
+}
+
 template <int nLayers>
 void TimeFrameGPU<nLayers>::downloadCellsDevice()
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 6a824de851fed..047d42d815e99 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -93,7 +93,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getDeviceArrayClusters(),
                                          mTimeFrameGPU->getClusterSizes(),
                                          mTimeFrameGPU->getDeviceROFrameClusters(),
-                                         mTimeFrameGPU->getDeviceArrayUsedClusters(),
+                                         (const uint8_t**)mTimeFrameGPU->getDeviceArrayUsedClusters(),
                                          mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
                                          mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
                                          mTimeFrameGPU->getDeviceTrackletsLUTs(),
@@ -128,7 +128,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                            mTimeFrameGPU->getDeviceArrayClusters(),
                                            mTimeFrameGPU->getClusterSizes(),
                                            mTimeFrameGPU->getDeviceROFrameClusters(),
-                                           mTimeFrameGPU->getDeviceArrayUsedClusters(),
+                                           (const uint8_t**)mTimeFrameGPU->getDeviceArrayUsedClusters(),
                                            mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
                                            mTimeFrameGPU->getDeviceArrayTracklets(),
                                            mTimeFrameGPU->getDeviceTracklets(),
@@ -300,7 +300,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         mTimeFrameGPU->getDeviceArrayCells(),
                                         mTimeFrameGPU->getDeviceCells()[startLayer],
                                         mTimeFrameGPU->getArrayNCells(),
-                                        mTimeFrameGPU->getDeviceArrayUsedClusters(),
+                                        (const uint8_t**)mTimeFrameGPU->getDeviceArrayUsedClusters(),
                                         mTimeFrameGPU->getDeviceNeighboursAll(),
                                         mTimeFrameGPU->getDeviceNeighboursLUTs(),
                                         mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 0e5fd21e5e90e..2c43ccd3bb81c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -46,76 +46,6 @@ namespace o2::its
 namespace gpu
 {
 
-template <typename T>
-struct TypedAllocator {
-  using value_type = T;
-  using pointer = thrust::device_ptr<T>;
-  using const_pointer = thrust::device_ptr<const T>;
-  using size_type = std::size_t;
-  using difference_type = std::ptrdiff_t;
-
-  TypedAllocator() noexcept : mInternalAllocator(nullptr) {}
-  explicit TypedAllocator(ExternalAllocator* a) noexcept : mInternalAllocator(a) {}
-
-  template <typename U>
-  TypedAllocator(const TypedAllocator<U>& o) noexcept : mInternalAllocator(o.mInternalAllocator)
-  {
-  }
-
-  pointer allocate(size_type n)
-  {
-    void* raw = mInternalAllocator->allocate(n * sizeof(T));
-    return thrust::device_pointer_cast(static_cast<T*>(raw));
-  }
-
-  void deallocate(pointer p, size_type n) noexcept
-  {
-    if (!p) {
-      return;
-    }
-    void* raw = thrust::raw_pointer_cast(p);
-    mInternalAllocator->deallocate(static_cast<char*>(raw), n * sizeof(T));
-  }
-
-  bool operator==(TypedAllocator const& o) const noexcept
-  {
-    return mInternalAllocator == o.mInternalAllocator;
-  }
-  bool operator!=(TypedAllocator const& o) const noexcept
-  {
-    return !(*this == o);
-  }
-
- private:
-  ExternalAllocator* mInternalAllocator;
-};
-
-GPUdii() int4 getEmptyBinsRect()
-{
-  return int4{0, 0, 0, 0};
-}
-
-template <int nLayers>
-GPUdii() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                                const IndexTableUtils<nLayers>& utils,
-                                const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
-{
-  const float zRangeMin = o2::gpu::CAMath::Min(z1, z2) - maxdeltaz;
-  const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : currentCluster.phi - maxdeltaphi;
-  const float zRangeMax = o2::gpu::CAMath::Max(z1, z2) + maxdeltaz;
-  const float phiRangeMax = (maxdeltaphi > o2::constants::math::PI) ? o2::constants::math::TwoPI : currentCluster.phi + maxdeltaphi;
-
-  if (zRangeMax < -utils.getLayerZ(layerIndex) ||
-      zRangeMin > utils.getLayerZ(layerIndex) || zRangeMin > zRangeMax) {
-    return getEmptyBinsRect();
-  }
-
-  return int4{o2::gpu::CAMath::Max(0, utils.getZBinIndex(layerIndex, zRangeMin)),
-              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
-              o2::gpu::CAMath::Min(utils.getNzBins() - 1, utils.getZBinIndex(layerIndex, zRangeMax)),
-              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
-}
-
 GPUdii() bool fitTrack(TrackITSExt& track,
                        int start,
                        int end,
@@ -272,44 +202,6 @@ struct compare_track_chi2 {
   }
 };
 
-GPUdii() gpuSpan<const Vertex> getPrimaryVertices(const int rof,
-                                                  const int* roframesPV,
-                                                  const int nROF,
-                                                  const uint8_t* mask,
-                                                  const Vertex* vertices)
-{
-  const int start_pv_id = roframesPV[rof];
-  const int stop_rof = rof >= nROF - 1 ? nROF : rof + 1;
-  const size_t delta = mask[rof] ? roframesPV[stop_rof] - start_pv_id : 0; // return empty span if ROF is excluded
-  return gpuSpan<const Vertex>(&vertices[start_pv_id], delta);
-};
-
-GPUdii() gpuSpan<const Vertex> getPrimaryVertices(const int romin,
-                                                  const int romax,
-                                                  const int* roframesPV,
-                                                  const int nROF,
-                                                  const Vertex* vertices)
-{
-  const int start_pv_id = roframesPV[romin];
-  const int stop_rof = romax >= nROF - 1 ? nROF : romax + 1;
-  return gpuSpan<const Vertex>(&vertices[start_pv_id], roframesPV[stop_rof] - roframesPV[romin]);
-};
-
-GPUdii() gpuSpan<const Cluster> getClustersOnLayer(const int rof,
-                                                   const int totROFs,
-                                                   const int layer,
-                                                   const int** roframesClus,
-                                                   const Cluster** clusters)
-{
-  if (rof < 0 || rof >= totROFs) {
-    return gpuSpan<const Cluster>();
-  }
-  const int start_clus_id{roframesClus[layer][rof]};
-  const int stop_rof = rof >= totROFs - 1 ? totROFs : rof + 1;
-  const unsigned int delta = roframesClus[layer][stop_rof] - start_clus_id;
-  return gpuSpan<const Cluster>(&(clusters[layer][start_clus_id]), delta);
-}
-
 template <int nLayers>
 GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   CellSeed<nLayers>* trackSeeds,
@@ -602,7 +494,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
         const float zAtRmax{tanLambda * (maxR - currentCluster.radius) + currentCluster.zCoordinate};
         const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + constants::Tolerance)}; /// protecting from overflows adding the detector resolution
         const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * MSAngle))};
-        const int4 selectedBinsRect{getBinsRect<nLayers>(currentCluster, layerIndex + 1, *utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
+        const int4 selectedBinsRect{getBinsRect<nLayers>(currentCluster, layerIndex + 1, utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
         if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
           continue;
         }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
index 90d654a26a43d..658d3cf0dfb91 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
@@ -11,217 +11,169 @@
 //
 /// \author matteo.concas@cern.ch
 
-#include <iostream>
-#include <sstream>
-#include <fstream>
-#include <array>
-#include <cassert>
-#include <thread>
-
-#ifdef VTX_DEBUG
-#include "TTree.h"
-#include "TFile.h"
-#endif
+#include <gsl/span>
 
+#include "ITStracking/TrackingConfigParam.h"
 #include "ITStrackingGPU/VertexingKernels.h"
 #include "ITStrackingGPU/VertexerTraitsGPU.h"
 
 namespace o2::its
 {
 
-void VertexerTraitsGPU::initialise(const TrackingParameters& trackingParams, const int iteration)
+template <int nLayers>
+void VertexerTraitsGPU<nLayers>::initialise(const TrackingParameters& trackingParams, const int iteration)
+{
+  // FIXME
+  // Two things to fix here:
+  // This loads all necessary data for this step at once, can be overlayed with computation
+  // Also if running with the tracker some data is loaded twice!
+  mTimeFrameGPU->initialise(0, trackingParams, 3, &this->mIndexTableUtils, &mTfGPUParams);
+
+  // FIXME some of these only need to be created once!
+  mTimeFrameGPU->loadIndexTableUtils(iteration);
+  mTimeFrameGPU->createUsedClustersDeviceArray(iteration, 3);
+  mTimeFrameGPU->createClustersDeviceArray(iteration, 3);
+  mTimeFrameGPU->createUnsortedClustersDeviceArray(iteration, 3);
+  mTimeFrameGPU->createClustersIndexTablesArray(iteration);
+  mTimeFrameGPU->createROFrameClustersDeviceArray(iteration);
+  for (int iLayer{0}; iLayer < 3; ++iLayer) {
+    mTimeFrameGPU->loadClustersDevice(iteration, iLayer);
+    mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer);
+    mTimeFrameGPU->loadClustersIndexTables(iteration, iLayer);
+    mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer);
+    mTimeFrameGPU->loadROFrameClustersDevice(iteration, iLayer);
+  }
+}
+
+template <int nLayers>
+void VertexerTraitsGPU<nLayers>::adoptTimeFrame(TimeFrame<nLayers>* tf) noexcept
 {
-  mTimeFrameGPU->initialise(0, trackingParams, 3, &mIndexTableUtils, &mTfGPUParams);
+  mTimeFrameGPU = static_cast<gpu::TimeFrameGPU<nLayers>*>(tf);
+  this->mTimeFrame = static_cast<TimeFrame<nLayers>*>(tf);
 }
 
-void VertexerTraitsGPU::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& tfPar)
+template <int nLayers>
+void VertexerTraitsGPU<nLayers>::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& tfPar)
 {
-  mVrtParams = vrtPar;
+  this->mVrtParams = vrtPar;
   mTfGPUParams = tfPar;
-  mIndexTableUtils.setTrackingParameters(vrtPar[0]);
-  for (auto& par : mVrtParams) {
-    par.phiSpan = static_cast<int>(std::ceil(mIndexTableUtils.getNphiBins() * par.phiCut / o2::constants::math::TwoPI));
-    par.zSpan = static_cast<int>(std::ceil(par.zCut * mIndexTableUtils.getInverseZCoordinate(0)));
+  this->mIndexTableUtils.setTrackingParameters(vrtPar[0]);
+  for (auto& par : this->mVrtParams) {
+    par.phiSpan = static_cast<int>(std::ceil(this->mIndexTableUtils.getNphiBins() * par.phiCut / o2::constants::math::TwoPI));
+    par.zSpan = static_cast<int>(std::ceil(par.zCut * this->mIndexTableUtils.getInverseZCoordinate(0)));
   }
 }
 
-void VertexerTraitsGPU::computeTracklets(const int iteration)
+template <int nLayers>
+void VertexerTraitsGPU<nLayers>::computeTracklets(const int iteration)
 {
-  if (!mTimeFrameGPU->getClusters().size()) {
+  if (mTimeFrameGPU->getClusters().empty()) {
     return;
   }
-  // std::vector<std::thread> threads(mTimeFrameGPU->getNChunks());
-  // for (int chunkId{0}; chunkId < mTimeFrameGPU->getNChunks(); ++chunkId) {
-  //   int rofPerChunk{mTimeFrameGPU->mNrof / (int)mTimeFrameGPU->getNChunks()};
-  //   mTimeFrameGPU->getVerticesInChunks()[chunkId].clear();
-  //   mTimeFrameGPU->getNVerticesInChunks()[chunkId].clear();
-  //   mTimeFrameGPU->getLabelsInChunks()[chunkId].clear();
-  //   auto doVertexReconstruction = [&, chunkId, rofPerChunk]() -> void {
-  //     auto offset = chunkId * rofPerChunk;
-  //     auto maxROF = offset + rofPerChunk;
-  //     while (offset < maxROF) {
-  //       auto rofs = mTimeFrameGPU->loadChunkData<gpu::Task::Vertexer>(chunkId, offset, maxROF);
-  //       RANGE("chunk_gpu_vertexing", 1);
-  //       // gpu::GpuTimer timer{offset, mTimeFrameGPU->getStream(chunkId).get()};
-  //       // timer.Start("vtTrackletFinder");
-  //       gpu::trackleterKernelMultipleRof<TrackletMode::Layer0Layer1><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),         // const Cluster* clustersNextLayer,    // 0 2
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),         // const Cluster* clustersCurrentLayer, // 1 1
-  //         mTimeFrameGPU->getDeviceROframesClusters(0),                   // const int* sizeNextLClusters,
-  //         mTimeFrameGPU->getDeviceROframesClusters(1),                   // const int* sizeCurrentLClusters,
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceIndexTables(0),      // const int* nextIndexTables,
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),        // Tracklet* Tracklets,
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0), // int* foundTracklets,
-  //         mTimeFrameGPU->getDeviceIndexTableUtils(),                     // const IndexTableUtils* utils,
-  //         offset,                                                        // const unsigned int startRofId,
-  //         rofs,                                                          // const unsigned int rofSize,
-  //         mVrtParams.phiCut,                                             // const float phiCut,
-  //         mVrtParams.maxTrackletsPerCluster);                            // const size_t maxTrackletsPerCluster = 1e2
-
-  //       gpu::trackleterKernelMultipleRof<TrackletMode::Layer1Layer2><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(2),         // const Cluster* clustersNextLayer,    // 0 2
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),         // const Cluster* clustersCurrentLayer, // 1 1
-  //         mTimeFrameGPU->getDeviceROframesClusters(2),                   // const int* sizeNextLClusters,
-  //         mTimeFrameGPU->getDeviceROframesClusters(1),                   // const int* sizeCurrentLClusters,
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceIndexTables(2),      // const int* nextIndexTables,
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),        // Tracklet* Tracklets,
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1), // int* foundTracklets,
-  //         mTimeFrameGPU->getDeviceIndexTableUtils(),                     // const IndexTableUtils* utils,
-  //         offset,                                                        // const unsigned int startRofId,
-  //         rofs,                                                          // const unsigned int rofSize,
-  //         mVrtParams.phiCut,                                             // const float phiCut,
-  //         mVrtParams.maxTrackletsPerCluster);                            // const size_t maxTrackletsPerCluster = 1e2
-
-  //       gpu::trackletSelectionKernelMultipleRof<true><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),            // const Cluster* clusters0,               // Clusters on layer 0
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),            // const Cluster* clusters1,               // Clusters on layer 1
-  //         mTimeFrameGPU->getDeviceROframesClusters(0),                      // const int* sizeClustersL0,              // Number of clusters on layer 0 per ROF
-  //         mTimeFrameGPU->getDeviceROframesClusters(1),                      // const int* sizeClustersL1,              // Number of clusters on layer 1 per ROF
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),           // Tracklet* tracklets01,                  // Tracklets on layer 0-1
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),           // Tracklet* tracklets12,                  // Tracklets on layer 1-2
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0),    // const int* nFoundTracklets01,           // Number of tracklets found on layers 0-1
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1),    // const int* nFoundTracklet12,            // Number of tracklets found on layers 1-2
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),        // unsigned char* usedTracklets,           // Used tracklets
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceLines(),                // Line* lines,                            // Lines
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),          // int* nFoundLines,                       // Number of found lines
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), // int* nExclusiveFoundLines,              // Number of found lines exclusive scan
-  //         offset,                                                           // const unsigned int startRofId,          // Starting ROF ID
-  //         rofs,                                                             // const unsigned int rofSize,             // Number of ROFs to consider
-  //         mVrtParams.maxTrackletsPerCluster,                                // const int maxTrackletsPerCluster = 1e2, // Maximum number of tracklets per cluster
-  //         mVrtParams.tanLambdaCut,                                          // const float tanLambdaCut = 0.025f,      // Cut on tan lambda
-  //         mVrtParams.phiCut);                                               // const float phiCut = 0.002f)            // Cut on phi
-
-  //       discardResult(cub::DeviceScan::ExclusiveSum(mTimeFrameGPU->getChunk(chunkId).getDeviceCUBTmpBuffer(),
-  //                                                   mTimeFrameGPU->getChunk(chunkId).getTimeFrameGPUParameters()->tmpCUBBufferSize,
-  //                                                   mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),
-  //                                                   mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(),
-  //                                                   mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1),
-  //                                                   mTimeFrameGPU->getStream(chunkId).get()));
-
-  //       // Reset used tracklets
-  //       checkGPUError(cudaMemsetAsync(mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),
-  //                                     false,
-  //                                     sizeof(unsigned char) * mVrtParams.maxTrackletsPerCluster * mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1),
-  //                                     mTimeFrameGPU->getStream(chunkId).get()),
-  //                     __FILE__, __LINE__);
-
-  //       gpu::trackletSelectionKernelMultipleRof<false><<<rofs, 1024, 0, mTimeFrameGPU->getStream(chunkId).get()>>>(
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(0),            // const Cluster* clusters0,               // Clusters on layer 0
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceClusters(1),            // const Cluster* clusters1,               // Clusters on layer 1
-  //         mTimeFrameGPU->getDeviceROframesClusters(0),                      // const int* sizeClustersL0,              // Number of clusters on layer 0 per ROF
-  //         mTimeFrameGPU->getDeviceROframesClusters(1),                      // const int* sizeClustersL1,              // Number of clusters on layer 1 per ROF
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(0),           // Tracklet* tracklets01,                  // Tracklets on layer 0-1
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceTracklets(1),           // Tracklet* tracklets12,                  // Tracklets on layer 1-2
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(0),    // const int* nFoundTracklets01,           // Number of tracklets found on layers 0-1
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNTrackletCluster(1),    // const int* nFoundTracklet12,            // Number of tracklets found on layers 1-2
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceUsedTracklets(),        // unsigned char* usedTracklets,           // Used tracklets
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceLines(),                // Line* lines,                            // Lines
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines(),          // int* nFoundLines,                       // Number of found lines
-  //         mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), // int* nExclusiveFoundLines,              // Number of found lines exclusive scan
-  //         offset,                                                           // const unsigned int startRofId,          // Starting ROF ID
-  //         rofs,                                                             // const unsigned int rofSize,             // Number of ROFs to consider
-  //         mVrtParams.maxTrackletsPerCluster,                                // const int maxTrackletsPerCluster = 1e2, // Maximum number of tracklets per cluster
-  //         mVrtParams.tanLambdaCut,                                          // const float tanLambdaCut = 0.025f,      // Cut on tan lambda
-  //         mVrtParams.phiCut);                                               // const float phiCut = 0.002f)            // Cut on phi
-
-  //       int nClusters = mTimeFrameGPU->getTotalClustersPerROFrange(offset, rofs, 1);
-  //       int lastFoundLines;
-  //       std::vector<int> exclusiveFoundLinesHost(nClusters + 1);
-
-  //       // Obtain whole exclusive sum including nCluster+1 element  (nCluster+1)th element is the total number of found lines.
-  //       checkGPUError(cudaMemcpyAsync(exclusiveFoundLinesHost.data(), mTimeFrameGPU->getChunk(chunkId).getDeviceNExclusiveFoundLines(), (nClusters) * sizeof(int), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
-  //       checkGPUError(cudaMemcpyAsync(&lastFoundLines, mTimeFrameGPU->getChunk(chunkId).getDeviceNFoundLines() + nClusters - 1, sizeof(int), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
-  //       exclusiveFoundLinesHost[nClusters] = exclusiveFoundLinesHost[nClusters - 1] + lastFoundLines;
-
-  //       std::vector<Line> lines(exclusiveFoundLinesHost[nClusters]);
-
-  //       checkGPUError(cudaMemcpyAsync(lines.data(), mTimeFrameGPU->getChunk(chunkId).getDeviceLines(), sizeof(Line) * lines.size(), cudaMemcpyDeviceToHost, mTimeFrameGPU->getStream(chunkId).get()));
-  //       checkGPUError(cudaStreamSynchronize(mTimeFrameGPU->getStream(chunkId).get()));
-
-  //       // Compute vertices
-  //       std::vector<ClusterLines> clusterLines;
-  //       std::vector<bool> usedLines;
-  //       for (int rofId{0}; rofId < rofs; ++rofId) {
-  //         auto rof = offset + rofId;
-  //         auto clustersL1offsetRof = mTimeFrameGPU->getROframeClusters(1)[rof] - mTimeFrameGPU->getROframeClusters(1)[offset]; // starting cluster offset for this ROF
-  //         auto nClustersL1Rof = mTimeFrameGPU->getROframeClusters(1)[rof + 1] - mTimeFrameGPU->getROframeClusters(1)[rof];     // number of clusters for this ROF
-  //         auto linesOffsetRof = exclusiveFoundLinesHost[clustersL1offsetRof];                                                  // starting line offset for this ROF
-  //         auto nLinesRof = exclusiveFoundLinesHost[clustersL1offsetRof + nClustersL1Rof] - linesOffsetRof;
-  //         gsl::span<const o2::its::Line> linesInRof(lines.data() + linesOffsetRof, static_cast<gsl::span<o2::its::Line>::size_type>(nLinesRof));
-
-  //         usedLines.resize(linesInRof.size(), false);
-  //         usedLines.assign(linesInRof.size(), false);
-  //         clusterLines.clear();
-  //         clusterLines.reserve(nClustersL1Rof);
-  //         computeVerticesInRof(rof,
-  //                              linesInRof,
-  //                              usedLines,
-  //                              clusterLines,
-  //                              mTimeFrameGPU->getBeamXY(),
-  //                              mTimeFrameGPU->getVerticesInChunks()[chunkId],
-  //                              mTimeFrameGPU->getNVerticesInChunks()[chunkId],
-  //                              mTimeFrameGPU,
-  //                              mTimeFrameGPU->hasMCinformation() ? &mTimeFrameGPU->getLabelsInChunks()[chunkId] : nullptr);
-  //       }
-  //       offset += rofs;
-  //     }
-  //   };
-  //   // Do work
-  //   threads[chunkId] = std::thread(doVertexReconstruction);
-  // }
-  // for (auto& thread : threads) {
-  //   thread.join();
-  // }
-  // for (int chunkId{0}; chunkId < mTimeFrameGPU->getNChunks(); ++chunkId) {
-  //   int start{0};
-  //   for (int rofId{0}; rofId < mTimeFrameGPU->getNVerticesInChunks()[chunkId].size(); ++rofId) {
-  //     gsl::span<const Vertex> rofVerts{mTimeFrameGPU->getVerticesInChunks()[chunkId].data() + start, static_cast<gsl::span<Vertex>::size_type>(mTimeFrameGPU->getNVerticesInChunks()[chunkId][rofId])};
-  //     mTimeFrameGPU->addPrimaryVertices(rofVerts);
-  //     if (mTimeFrameGPU->hasMCinformation()) {
-  //       mTimeFrameGPU->getVerticesLabels().emplace_back();
-  //       // TODO: add MC labels
-  //     }
-  //     start += mTimeFrameGPU->getNVerticesInChunks()[chunkId][rofId];
-  //   }
-  // }
-  // mTimeFrameGPU->wipe(3);
-  // }
+  const auto& conf = ITSGpuTrackingParamConfig::Instance();
+
+  mTimeFrameGPU->createVtxTrackletsLUTDevice(iteration);
+  countTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
+                                       mTimeFrameGPU->getDeviceMultCutMask(),
+                                       mTimeFrameGPU->getNrof(),
+                                       this->mVrtParams[iteration].deltaRof,
+                                       mTimeFrameGPU->getDeviceROFramesPV(),
+                                       this->mVrtParams[iteration].vertPerRofThreshold,
+                                       mTimeFrameGPU->getDeviceArrayClusters(),
+                                       mTimeFrameGPU->getClusterSizes()[1],
+                                       mTimeFrameGPU->getDeviceROFrameClusters(),
+                                       (const uint8_t**)mTimeFrameGPU->getDeviceArrayUsedClusters(),
+                                       mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
+                                       mTimeFrameGPU->getDeviceArrayNTrackletsPerCluster(),
+                                       mTimeFrameGPU->getDeviceArrayNTrackletsPerClusterSum(),
+                                       mTimeFrameGPU->getDeviceArrayNTrackletsPerROF(),
+                                       mTimeFrameGPU->getDeviceNTrackletsPerCluster(),
+                                       mTimeFrameGPU->getDeviceNTrackletsPerClusterSum(),
+                                       iteration,
+                                       this->mVrtParams[iteration].phiCut,
+                                       this->mVrtParams[iteration].maxTrackletsPerCluster,
+                                       conf.nBlocksVtxComputeTracklets[iteration],
+                                       conf.nThreadsVtxComputeTracklets[iteration],
+                                       mTimeFrameGPU->getStreams());
+  mTimeFrameGPU->createVtxTrackletsBuffers(iteration);
+  computeTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
+                                         mTimeFrameGPU->getDeviceMultCutMask(),
+                                         mTimeFrameGPU->getNrof(),
+                                         this->mVrtParams[iteration].deltaRof,
+                                         mTimeFrameGPU->getDeviceROFramesPV(),
+                                         this->mVrtParams[iteration].vertPerRofThreshold,
+                                         mTimeFrameGPU->getDeviceArrayClusters(),
+                                         mTimeFrameGPU->getClusterSizes()[1],
+                                         mTimeFrameGPU->getDeviceROFrameClusters(),
+                                         (const uint8_t**)mTimeFrameGPU->getDeviceArrayUsedClusters(),
+                                         mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
+                                         mTimeFrameGPU->getDeviceArrayTracklets(),
+                                         (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerCluster(),
+                                         (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerClusterSum(),
+                                         (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerROF(),
+                                         iteration,
+                                         this->mVrtParams[iteration].phiCut,
+                                         this->mVrtParams[iteration].maxTrackletsPerCluster,
+                                         conf.nBlocksVtxComputeTracklets[iteration],
+                                         conf.nThreadsVtxComputeTracklets[iteration],
+                                         mTimeFrameGPU->getStreams());
 }
 
-void VertexerTraitsGPU::computeTrackletMatching(const int iteration)
+template <int nLayers>
+void VertexerTraitsGPU<nLayers>::computeTrackletMatching(const int iteration)
 {
-}
+  if (!mTimeFrameGPU->getTotalTrackletsTF(0) || !mTimeFrameGPU->getTotalTrackletsTF(1)) {
+    return;
+  }
 
-void VertexerTraitsGPU::computeVertices(const int iteration)
-{
+  const auto& conf = ITSGpuTrackingParamConfig::Instance();
+  mTimeFrameGPU->createVtxLinesLUTDevice(iteration);
+  countTrackletsMatchingInROFsHandler(mTimeFrameGPU->getNrof(),
+                                      this->mVrtParams[iteration].deltaRof,
+                                      mTimeFrameGPU->getClusterSizes()[1],
+                                      mTimeFrameGPU->getDeviceROFrameClusters(),
+                                      mTimeFrameGPU->getDeviceArrayClusters(),
+                                      mTimeFrameGPU->getDeviceArrayUsedClusters(),
+                                      (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
+                                      mTimeFrameGPU->getDeviceUsedTracklets(),
+                                      (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerCluster(),
+                                      (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerClusterSum(),
+                                      mTimeFrameGPU->getDeviceNLinesPerCluster(),
+                                      mTimeFrameGPU->getDeviceNLinesPerClusterSum(),
+                                      iteration,
+                                      this->mVrtParams[iteration].phiCut,
+                                      this->mVrtParams[iteration].tanLambdaCut,
+                                      conf.nBlocksVtxComputeMatching[iteration],
+                                      conf.nThreadsVtxComputeMatching[iteration],
+                                      mTimeFrameGPU->getStreams());
+  mTimeFrameGPU->createVtxLinesBuffer(iteration);
+  computeTrackletsMatchingInROFsHandler(mTimeFrameGPU->getNrof(),
+                                        this->mVrtParams[iteration].deltaRof,
+                                        mTimeFrameGPU->getClusterSizes()[1],
+                                        mTimeFrameGPU->getDeviceROFrameClusters(),
+                                        mTimeFrameGPU->getDeviceArrayClusters(),
+                                        nullptr,
+                                        (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
+                                        mTimeFrameGPU->getDeviceUsedTracklets(),
+                                        (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerCluster(),
+                                        (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerClusterSum(),
+                                        (const int32_t*)mTimeFrameGPU->getDeviceNLinesPerClusterSum(),
+                                        mTimeFrameGPU->getDeviceLines(),
+                                        iteration,
+                                        this->mVrtParams[iteration].phiCut,
+                                        this->mVrtParams[iteration].tanLambdaCut,
+                                        conf.nBlocksVtxComputeMatching[iteration],
+                                        conf.nThreadsVtxComputeMatching[iteration],
+                                        mTimeFrameGPU->getStreams());
 }
 
-void VertexerTraitsGPU::computeVerticesHist()
+template <int nLayers>
+void VertexerTraitsGPU<nLayers>::computeVertices(const int iteration)
 {
+  LOGP(fatal, "This step is not implemented yet!");
+  mTimeFrameGPU->loadUsedClustersDevice();
 }
 
-VertexerTraits* createVertexerTraitsGPU()
-{
-  return new VertexerTraitsGPU;
-}
+template class VertexerTraitsGPU<7>;
+
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
index 126e799efce5d..a2787bb13598d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
@@ -14,364 +14,454 @@
 #include <cub/cub.cuh>
 
 #include "ITStrackingGPU/VertexingKernels.h"
+#include "ITStracking/Tracklet.h"
+#include "ITStracking/IndexTableUtils.h"
+#include "ITStracking/ClusterLines.h"
+
+#include "GPUCommonMath.h"
 #include "GPUCommonHelpers.h"
+#include "GPUCommonDef.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
-using math_utils::getNormalizedPhi;
 
 namespace gpu
 {
-template <TrackletMode Mode>
-void trackletFinderHandler(const Cluster* clustersNextLayer,    // 0 2
-                           const Cluster* clustersCurrentLayer, // 1 1
-                           const int* sizeNextLClusters,
-                           const int* sizeCurrentLClusters,
-                           const int* nextIndexTables,
-                           Tracklet* Tracklets,
-                           int* foundTracklets,
-                           const IndexTableUtils* utils,
-                           const unsigned int startRofId,
-                           const unsigned int rofSize,
-                           const float phiCut,
-                           const unsigned int maxTrackletsPerCluster,
-                           const int nBlocks,
-                           const int nThreads)
-{
-  gpu::trackleterKernelMultipleRof<Mode><<<nBlocks, nThreads>>>(
-    clustersNextLayer,       // const Cluster* clustersNextLayer,    // 0 2
-    clustersCurrentLayer,    // const Cluster* clustersCurrentLayer, // 1 1
-    sizeNextLClusters,       // const int* sizeNextLClusters,
-    sizeCurrentLClusters,    // const int* sizeCurrentLClusters,
-    nextIndexTables,         // const int* nextIndexTables,
-    Tracklets,               // Tracklet* Tracklets,
-    foundTracklets,          // int* foundTracklets,
-    utils,                   // const IndexTableUtils* utils,
-    startRofId,              // const unsigned int startRofId,
-    rofSize,                 // const unsigned int rofSize,
-    phiCut,                  // const float phiCut,
-    maxTrackletsPerCluster); // const unsigned int maxTrackletsPerCluster = 1e2
-}
-/*
-
-GPUd() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                              const float z1, float maxdeltaz, float maxdeltaphi)
-{
-  const float zRangeMin = z1 - maxdeltaz;
-  const float phiRangeMin = currentCluster.phi - maxdeltaphi;
-  const float zRangeMax = z1 + maxdeltaz;
-  const float phiRangeMax = currentCluster.phi + maxdeltaphi;
-
-  if (zRangeMax < -LayersZCoordinate()[layerIndex + 1] ||
-      zRangeMin > LayersZCoordinate()[layerIndex + 1] || zRangeMin > zRangeMax) {
-
-    return getEmptyBinsRect();
-  }
 
-  return int4{o2::gpu::GPUCommonMath::Max(0, getZBinIndex(layerIndex + 1, zRangeMin)),
-              getPhiBinIndex(phiRangeMin),
-              o2::gpu::GPUCommonMath::Min(ZBins - 1, getZBinIndex(layerIndex + 1, zRangeMax)),
-              getPhiBinIndex(phiRangeMax)};
-}
-
-template <typename... Args>
-GPUd() void printOnThread(const unsigned int tId, const char* str, Args... args)
+template <int nLayers, TrackletMode Mode, bool dryRun>
+GPUg() void computeLayerTrackletMutliROFKernel(const Cluster** GPUrestrict() clusters,
+                                               const int32_t** GPUrestrict() rofClusters,
+                                               const uint8_t** GPUrestrict() usedClusters,
+                                               const int32_t** GPUrestrict() clusterIndexTables,
+                                               const float phiCut,
+                                               maybe_const<dryRun, Tracklet>** GPUrestrict() tracklets,
+                                               maybe_const<!dryRun, int32_t>** GPUrestrict() trackletOffsets,
+                                               const IndexTableUtils<nLayers>* GPUrestrict() utils,
+                                               const int32_t nRofs,
+                                               const int32_t deltaRof,
+                                               const int32_t* GPUrestrict() rofPV,
+                                               const int32_t iteration,
+                                               const int32_t verPerRofThreshold,
+                                               const int32_t maxTrackletsPerCluster)
 {
-  if (blockIdx.x * blockDim.x + threadIdx.x == tId) {
-    printf(str, args...);
-  }
-}
-
-template <typename... Args>
-GPUd() void printOnBlock(const unsigned int bId, const char* str, Args... args)
-{
-  if (blockIdx.x == bId && threadIdx.x == 0) {
-    printf(str, args...);
-  }
-}
-
-GPUg() void printBufferOnThread(const int* v, unsigned int size, const int len = 150, const unsigned int tId = 0)
-{
-  if (blockIdx.x * blockDim.x + threadIdx.x == tId) {
-    for (int i{0}; i < size; ++i) {
-      if (!(i % len)) {
-        printf("\n start: ===>%d/%d\t", i, (int)size);
-      }
-      printf("%d\t", v[i]);
+  constexpr int32_t iMode = (Mode == TrackletMode::Layer0Layer1) ? 0 : 1;
+  const int32_t phiBins(utils->getNphiBins());
+  const int32_t zBins(utils->getNzBins());
+  const int32_t tableSize{phiBins * zBins + 1};
+  extern __shared__ uint16_t storedTrackletsShared[]; // each deltaROF needs its own counters
+  uint16_t* storedTrackletsLocal = storedTrackletsShared + threadIdx.x * (2 * deltaRof + 1);
+  for (uint32_t pivotRofId{blockIdx.x}; pivotRofId < (uint32_t)nRofs; pivotRofId += gridDim.x) {
+    if (iteration && rofPV[pivotRofId] > verPerRofThreshold) {
+      continue;
     }
-    printf("\n");
-  }
-}
-
-GPUg() void printBufferOnThreadF(const float* v, unsigned int size, const unsigned int tId = 0)
-{
-  if (blockIdx.x * blockDim.x + threadIdx.x == tId) {
-    printf("vector :");
-    for (int i{0}; i < size; ++i) {
-      printf("%.9f\t", v[i]);
+    const uint16_t startROF = o2::gpu::CAMath::Max(0, (int)pivotRofId - deltaRof);
+    const uint16_t endROF = o2::gpu::CAMath::Min(nRofs, (int)pivotRofId + deltaRof + 1);
+    const auto clustersCurrentLayer = getClustersOnLayer((int32_t)pivotRofId, nRofs, 1, rofClusters, clusters);
+    if (clustersCurrentLayer.empty()) {
+      continue;
     }
-    printf("\n");
-  }
-}
-
-GPUg() void resetTrackletsKernel(Tracklet* tracklets, const int nTracklets)
-{
-  for (int iCurrentLayerClusterIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentLayerClusterIndex < nTracklets; iCurrentLayerClusterIndex += blockDim.x * gridDim.x) {
-    new (tracklets + iCurrentLayerClusterIndex) Tracklet{};
-  }
-}
-
-GPUg() void dumpFoundTrackletsKernel(const Tracklet* tracklets, const int* nTracklet, const unsigned int nClustersMiddleLayer, const int maxTrackletsPerCluster)
-{
-  for (int iCurrentLayerClusterIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentLayerClusterIndex < nClustersMiddleLayer; iCurrentLayerClusterIndex += blockDim.x * gridDim.x) {
-    const int stride{iCurrentLayerClusterIndex * maxTrackletsPerCluster};
-    for (int iTracklet{0}; iTracklet < nTracklet[iCurrentLayerClusterIndex]; ++iTracklet) {
-      auto& t = tracklets[stride + iTracklet];
-      t.dump();
-    }
-  }
-}
-
-GPUg() void dumpMaximaKernel(const cub::KeyValuePair<int, int>* tmpVertexBins, const int threadId)
-{
-  if (blockIdx.x * blockDim.x + threadIdx.x == threadId) {
-    printf("XmaxBin: %d at index: %d | YmaxBin: %d at index: %d | ZmaxBin: %d at index: %d\n",
-           tmpVertexBins[0].value, tmpVertexBins[0].key,
-           tmpVertexBins[1].value, tmpVertexBins[1].key,
-           tmpVertexBins[2].value, tmpVertexBins[2].key);
-  }
-}
-
-template <TrackletMode Mode>
-GPUg() void trackleterKernelSingleRof(
-  const Cluster* clustersNextLayer,    // 0 2
-  const Cluster* clustersCurrentLayer, // 1 1
-  const int sizeNextLClusters,
-  const int sizeCurrentLClusters,
-  const int* indexTableNext,
-  const float phiCut,
-  Tracklet* Tracklets,
-  int* foundTracklets,
-  const IndexTableUtils* utils,
-  const short rofId,
-  const unsigned int maxTrackletsPerCluster = 1e2)
-{
-  const int phiBins{utils->getNphiBins()};
-  const int zBins{utils->getNzBins()};
-  // loop on layer1 clusters
-  for (int iCurrentLayerClusterIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentLayerClusterIndex < sizeCurrentLClusters; iCurrentLayerClusterIndex += blockDim.x * gridDim.x) {
-    if (iCurrentLayerClusterIndex < sizeCurrentLClusters) {
-      unsigned int storedTracklets{0};
-      const unsigned int stride{iCurrentLayerClusterIndex * maxTrackletsPerCluster};
-      const Cluster& currentCluster = clustersCurrentLayer[iCurrentLayerClusterIndex];
-      const int4 selectedBinsRect{VertexerTraits::getBinsRect(currentCluster, (int)Mode, 0.f, 50.f, phiCut / 2, *utils)};
+    auto trackletsPerCluster = getNTrackletsPerCluster(pivotRofId, nRofs, iMode, rofClusters, trackletOffsets);
+    for (uint32_t iCurrentLayerClusterIndex{threadIdx.x}; iCurrentLayerClusterIndex < (uint32_t)clustersCurrentLayer.size(); iCurrentLayerClusterIndex += blockDim.x) {
+      for (int16_t i{0}; i < (int16_t)((2 * deltaRof) + 1); ++i) {
+        storedTrackletsLocal[i] = 0;
+      }
+      const Cluster& GPUrestrict() currentCluster { clustersCurrentLayer[iCurrentLayerClusterIndex] };
+      const int4 selectedBinsRect{getBinsRect(currentCluster, (int)Mode, utils, 0.f, 0.f, 50.f, phiCut / 2)};
       if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) {
         int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
         if (phiBinsNum < 0) {
           phiBinsNum += phiBins;
         }
-        // loop on phi bins next layer
-        for (unsigned int iPhiBin{(unsigned int)selectedBinsRect.y}, iPhiCount{0}; iPhiCount < (unsigned int)phiBinsNum; iPhiBin = ++iPhiBin == phiBins ? 0 : iPhiBin, iPhiCount++) {
-          const int firstBinIndex{utils->getBinIndex(selectedBinsRect.x, iPhiBin)};
-          const int firstRowClusterIndex{indexTableNext[firstBinIndex]};
-          const int maxRowClusterIndex{indexTableNext[firstBinIndex + zBins]};
-          // loop on clusters next layer
-          for (int iNextLayerClusterIndex{firstRowClusterIndex}; iNextLayerClusterIndex < maxRowClusterIndex && iNextLayerClusterIndex < sizeNextLClusters; ++iNextLayerClusterIndex) {
-            const Cluster& nextCluster = clustersNextLayer[iNextLayerClusterIndex];
-            if (o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi) < phiCut) {
-              if (storedTracklets < maxTrackletsPerCluster) {
-                if constexpr (Mode == TrackletMode::Layer0Layer1) {
-                  new (Tracklets + stride + storedTracklets) Tracklet{iNextLayerClusterIndex, iCurrentLayerClusterIndex, nextCluster, currentCluster, rofId, rofId};
-                } else {
-                  new (Tracklets + stride + storedTracklets) Tracklet{iCurrentLayerClusterIndex, iNextLayerClusterIndex, currentCluster, nextCluster, rofId, rofId};
+        for (int32_t iPhiBin{selectedBinsRect.y}, iPhiCount{0}; iPhiCount < phiBinsNum; iPhiBin = ++iPhiBin == phiBins ? 0 : iPhiBin, iPhiCount++) {
+          for (uint16_t targetRofId{startROF}; targetRofId < endROF; ++targetRofId) {
+            uint16_t& storedTracklets = storedTrackletsLocal[pivotRofId - targetRofId + deltaRof];
+            const int32_t firstBinIndex{utils->getBinIndex(selectedBinsRect.x, iPhiBin)};
+            const int32_t maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
+            const int32_t firstRowClusterIndex{clusterIndexTables[(int)Mode][(targetRofId)*tableSize + firstBinIndex]};
+            const int32_t maxRowClusterIndex{clusterIndexTables[(int)Mode][(targetRofId)*tableSize + maxBinIndex]};
+            auto clustersNextLayer = getClustersOnLayer((int32_t)targetRofId, nRofs, (int32_t)Mode, rofClusters, clusters);
+            if (clustersNextLayer.empty()) {
+              continue;
+            }
+            for (int32_t iNextLayerClusterIndex{firstRowClusterIndex}; iNextLayerClusterIndex < maxRowClusterIndex && iNextLayerClusterIndex < (int32_t)clustersNextLayer.size(); ++iNextLayerClusterIndex) {
+              if (iteration && usedClusters[(int32_t)Mode][iNextLayerClusterIndex]) {
+                continue;
+              }
+              const Cluster& GPUrestrict() nextCluster { clustersNextLayer[iNextLayerClusterIndex] };
+              if (o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(currentCluster.phi, nextCluster.phi)) < phiCut) {
+                if (storedTracklets < maxTrackletsPerCluster) {
+                  if constexpr (!dryRun) {
+                    if constexpr (Mode == TrackletMode::Layer0Layer1) {
+                      tracklets[0][trackletsPerCluster[iCurrentLayerClusterIndex] + storedTracklets] = Tracklet{iNextLayerClusterIndex, (int)iCurrentLayerClusterIndex, nextCluster, currentCluster, (short)targetRofId, (short)pivotRofId};
+                    } else {
+                      tracklets[1][trackletsPerCluster[iCurrentLayerClusterIndex] + storedTracklets] = Tracklet{(int)iCurrentLayerClusterIndex, iNextLayerClusterIndex, currentCluster, nextCluster, (short)pivotRofId, (short)targetRofId};
+                    }
+                  }
+                  ++storedTracklets;
                 }
-                ++storedTracklets;
               }
             }
           }
         }
       }
-      foundTracklets[iCurrentLayerClusterIndex] = storedTracklets;
-      if (storedTracklets >= maxTrackletsPerCluster) {
-        printf("gpu tracklet finder: some lines will be left behind for cluster %d. valid: %u max: %zu\n", iCurrentLayerClusterIndex, storedTracklets, maxTrackletsPerCluster);
+      if constexpr (dryRun) {
+        for (int32_t i{0}; i < (int32_t)((2 * deltaRof) + 1); ++i) {
+          trackletsPerCluster[iCurrentLayerClusterIndex] += storedTrackletsLocal[i];
+        }
       }
     }
   }
 }
 
-template <TrackletMode Mode>
-GPUg() void trackleterKernelMultipleRof(
-  const Cluster* clustersNextLayer,    // 0 2
-  const Cluster* clustersCurrentLayer, // 1 1
-  const int* sizeNextLClusters,
-  const int* sizeCurrentLClusters,
-  const int* nextIndexTables,
-  Tracklet* Tracklets,
-  int* foundTracklets,
-  const IndexTableUtils* utils,
-  const short startRofId,
-  const short rofSize,
-  const float phiCut,
-  const unsigned int maxTrackletsPerCluster = 1e2)
+template <bool dryRun>
+GPUg() void computeTrackletSelectionMutliROFKernel(const Cluster** GPUrestrict() clusters,
+                                                   maybe_const<!dryRun, uint8_t>** GPUrestrict() usedClusters,
+                                                   const int32_t** GPUrestrict() rofClusters,
+                                                   const float phiCut,
+                                                   const float tanLambdaCut,
+                                                   const Tracklet** GPUrestrict() tracklets,
+                                                   uint8_t* GPUrestrict() usedTracklets,
+                                                   const int32_t** GPUrestrict() trackletOffsets,
+                                                   const int32_t** GPUrestrict() trackletLUTs,
+                                                   maybe_const<!dryRun, int32_t>* lineOffsets,
+                                                   maybe_const<dryRun, Line>* GPUrestrict() lines,
+                                                   const int32_t nRofs,
+                                                   const int32_t deltaRof,
+                                                   const int32_t maxTracklets)
 {
-  const int phiBins{utils->getNphiBins()};
-  const int zBins{utils->getNzBins()};
-  for (auto iRof{blockIdx.x}; iRof < rofSize; iRof += gridDim.x) {
-    short rof = static_cast<short>(iRof) + startRofId;
-    auto* clustersNextLayerRof = clustersNextLayer + (sizeNextLClusters[rof] - sizeNextLClusters[startRofId]);
-    auto* clustersCurrentLayerRof = clustersCurrentLayer + (sizeCurrentLClusters[rof] - sizeCurrentLClusters[startRofId]);
-    auto nClustersNextLayerRof = sizeNextLClusters[rof + 1] - sizeNextLClusters[rof];
-    auto nClustersCurrentLayerRof = sizeCurrentLClusters[rof + 1] - sizeCurrentLClusters[rof];
-    auto* indexTableNextRof = nextIndexTables + iRof * (phiBins * zBins + 1);
-    auto* TrackletsRof = Tracklets + (sizeCurrentLClusters[rof] - sizeCurrentLClusters[startRofId]) * maxTrackletsPerCluster;
-    auto* foundTrackletsRof = foundTracklets + (sizeCurrentLClusters[rof] - sizeCurrentLClusters[startRofId]);
+  for (uint32_t pivotRofId{blockIdx.x}; pivotRofId < nRofs; pivotRofId += gridDim.x) {
+    const int16_t startROF = o2::gpu::CAMath::Max(0, (int32_t)pivotRofId - deltaRof);
+    const int16_t endROF = o2::gpu::CAMath::Min(nRofs, (int32_t)pivotRofId + deltaRof + 1);
 
-    // single rof loop on layer1 clusters
-    for (int iCurrentLayerClusterIndex = threadIdx.x; iCurrentLayerClusterIndex < nClustersCurrentLayerRof; iCurrentLayerClusterIndex += blockDim.x) {
-      unsigned int storedTracklets{0};
-      const unsigned int stride{iCurrentLayerClusterIndex * maxTrackletsPerCluster};
-      const Cluster& currentCluster = clustersCurrentLayerRof[iCurrentLayerClusterIndex];
-      const int4 selectedBinsRect{VertexerTraits::getBinsRect(currentCluster, (int)Mode, 0.f, 50.f, phiCut / 2, *utils)};
-      if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) {
-        int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
-        if (phiBinsNum < 0) {
-          phiBinsNum += phiBins;
-        }
-        // loop on phi bins next layer
-        for (unsigned int iPhiBin{(unsigned int)selectedBinsRect.y}, iPhiCount{0}; iPhiCount < (unsigned int)phiBinsNum; iPhiBin = ++iPhiBin == phiBins ? 0 : iPhiBin, iPhiCount++) {
-          const int firstBinIndex{utils->getBinIndex(selectedBinsRect.x, iPhiBin)};
-          const int firstRowClusterIndex{indexTableNextRof[firstBinIndex]};
-          const int maxRowClusterIndex{indexTableNextRof[firstBinIndex + zBins]};
-          // loop on clusters next layer
-          for (int iNextLayerClusterIndex{firstRowClusterIndex}; iNextLayerClusterIndex < maxRowClusterIndex && iNextLayerClusterIndex < nClustersNextLayerRof; ++iNextLayerClusterIndex) {
-            const Cluster& nextCluster = clustersNextLayerRof[iNextLayerClusterIndex];
-            if (o2::gpu::GPUCommonMath::Abs(smallestAngleDifference(currentCluster.phi, nextCluster.phi)) < phiCut) {
-              if (storedTracklets < maxTrackletsPerCluster) {
-                if constexpr (Mode == TrackletMode::Layer0Layer1) {
-                  new (TrackletsRof + stride + storedTracklets) Tracklet{iNextLayerClusterIndex, iCurrentLayerClusterIndex, nextCluster, currentCluster, rof, rof};
-                } else {
-                  new (TrackletsRof + stride + storedTracklets) Tracklet{iCurrentLayerClusterIndex, iNextLayerClusterIndex, currentCluster, nextCluster, rof, rof};
-                }
-                ++storedTracklets;
-              }
+    const uint32_t clusterOffset = rofClusters[1][pivotRofId];
+    const uint32_t nClustersCurrentLayer = rofClusters[1][pivotRofId + 1] - clusterOffset;
+    if (nClustersCurrentLayer <= 0) {
+      continue;
+    }
+
+    auto linesPerCluster = getNLinesPerCluster(pivotRofId, nRofs, rofClusters, lineOffsets);
+    auto nTrackletsPerCluster01 = getNTrackletsPerCluster(pivotRofId, nRofs, 0, rofClusters, trackletOffsets);
+    auto nTrackletsPerCluster12 = getNTrackletsPerCluster(pivotRofId, nRofs, 1, rofClusters, trackletOffsets);
+
+    for (uint32_t iCurrentLayerClusterIndex{threadIdx.x}; iCurrentLayerClusterIndex < nClustersCurrentLayer; iCurrentLayerClusterIndex += blockDim.x) {
+      int32_t validTracklets{0};
+      const int32_t nTracklets01 = nTrackletsPerCluster01[iCurrentLayerClusterIndex];
+      const int32_t nTracklets12 = nTrackletsPerCluster12[iCurrentLayerClusterIndex];
+      for (int32_t iTracklet12{0}; iTracklet12 < nTracklets12; ++iTracklet12) {
+        for (int32_t iTracklet01{0}; iTracklet01 < nTracklets01; ++iTracklet01) {
+
+          if (usedTracklets[trackletLUTs[0][clusterOffset + iCurrentLayerClusterIndex] + iTracklet01]) {
+            continue;
+          }
+
+          const auto& GPUrestrict() tracklet01 { tracklets[0][trackletLUTs[0][clusterOffset + iCurrentLayerClusterIndex] + iTracklet01] };
+          const auto& GPUrestrict() tracklet12 { tracklets[1][trackletLUTs[1][clusterOffset + iCurrentLayerClusterIndex] + iTracklet12] };
+          const int16_t rof0 = tracklet01.rof[0];
+          const int16_t rof2 = tracklet12.rof[1];
+          if (deltaRof > 0 && ((rof0 < startROF) || (rof0 >= endROF) || (rof2 < startROF) || (rof2 >= endROF) || (o2::gpu::CAMath::Abs(rof0 - rof2) > deltaRof))) {
+            continue;
+          }
+
+          const float deltaTanLambda{o2::gpu::GPUCommonMath::Abs(tracklet01.tanLambda - tracklet12.tanLambda)};
+          const float deltaPhi{o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(tracklet01.phi, tracklet12.phi))};
+          //
+          if (deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets < maxTracklets) {
+            // TODO use atomics to avoid race conditions for torn writes but is it needed here?
+            usedTracklets[trackletLUTs[0][clusterOffset + iCurrentLayerClusterIndex] + iTracklet01] = 1;
+            if constexpr (dryRun) {
+              usedClusters[0][rofClusters[0][rof0] + tracklet01.firstClusterIndex] = 1;
+              usedClusters[2][rofClusters[2][rof2] + tracklet12.secondClusterIndex] = 1;
+            } else {
+              const Cluster* clusters0 = clusters[0] + rofClusters[0][tracklet01.rof[0]];
+              const Cluster* clusters1 = clusters[1] + rofClusters[1][tracklet01.rof[1]];
+              lines[lineOffsets[iCurrentLayerClusterIndex] + validTracklets] = Line(tracklet01, clusters0, clusters1);
             }
+            ++validTracklets;
           }
         }
       }
-      foundTrackletsRof[iCurrentLayerClusterIndex] = storedTracklets;
-      // if (storedTracklets >= maxTrackletsPerCluster && storedTracklets - maxTrackletsPerCluster < 5) {
-      //   printf("gpu tracklet finder: some lines will be left behind for cluster %d in rof: %d. valid: %u max: %lu (suppressing after 5 msgs)\n", iCurrentLayerClusterIndex, rof, storedTracklets, maxTrackletsPerCluster);
-      // }
+
+      if constexpr (dryRun) {
+        linesPerCluster[iCurrentLayerClusterIndex] = validTracklets;
+      }
     }
   }
 }
 
-template <bool initRun>
-GPUg() void trackletSelectionKernelSingleRof(
-  const Cluster* clusters0,
-  const Cluster* clusters1,
-  const unsigned int nClustersMiddleLayer,
-  Tracklet* tracklets01,
-  Tracklet* tracklets12,
-  const int* nFoundTracklet01,
-  const int* nFoundTracklet12,
-  unsigned char* usedTracklets,
-  Line* lines,
-  int* nFoundLines,
-  int* nExclusiveFoundLines,
-  const int maxTrackletsPerCluster = 1e2,
-  const float tanLambdaCut = 0.025f,
-  const float phiCut = 0.002f)
+template <TrackletMode Mode>
+GPUg() void compileTrackletsPerROFKernel(const int32_t nRofs,
+                                         int** GPUrestrict() nTrackletsPerROF,
+                                         const int32_t** GPUrestrict() rofClusters,
+                                         const int32_t** GPUrestrict() nTrackletsPerCluster)
 {
-  for (int iCurrentLayerClusterIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentLayerClusterIndex < nClustersMiddleLayer; iCurrentLayerClusterIndex += blockDim.x * gridDim.x) {
-    const int stride{iCurrentLayerClusterIndex * maxTrackletsPerCluster};
-    int validTracklets{0};
-    for (int iTracklet12{0}; iTracklet12 < nFoundTracklet12[iCurrentLayerClusterIndex]; ++iTracklet12) {
-      for (int iTracklet01{0}; iTracklet01 < nFoundTracklet01[iCurrentLayerClusterIndex] && validTracklets < maxTrackletsPerCluster; ++iTracklet01) {
-        const float deltaTanLambda{o2::gpu::GPUCommonMath::Abs(tracklets01[stride + iTracklet01].tanLambda - tracklets12[stride + iTracklet12].tanLambda)};
-        const float deltaPhi{o2::gpu::GPUCommonMath::Abs(smallestAngleDifference(tracklets01[stride + iTracklet01].phi, tracklets12[stride + iTracklet12].phi))};
-        if (!usedTracklets[stride + iTracklet01] && deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets != maxTrackletsPerCluster) {
-          usedTracklets[stride + iTracklet01] = true;
-          if constexpr (!initRun) {
-            new (lines + nExclusiveFoundLines[iCurrentLayerClusterIndex] + validTracklets) Line{tracklets01[stride + iTracklet01], clusters0, clusters1};
-          }
-          ++validTracklets;
-        }
-      }
+  // TODO is this the best reduction kernel?
+  constexpr int32_t iMode = (Mode == TrackletMode::Layer0Layer1) ? 0 : 1;
+  extern __shared__ int32_t ssum[];
+  for (uint32_t rof = blockIdx.x; rof < (uint32_t)nRofs; rof += gridDim.x) {
+    const auto& GPUrestrict() currentNTracklets = getNTrackletsPerCluster(rof, nRofs, iMode, rofClusters, nTrackletsPerCluster);
+    int32_t localSum = 0;
+    for (uint32_t ci = threadIdx.x; ci < (uint32_t)currentNTracklets.size(); ci += blockDim.x) {
+      localSum += currentNTracklets[ci];
     }
-    if constexpr (initRun) {
-      nFoundLines[iCurrentLayerClusterIndex] = validTracklets;
-      if (validTracklets >= maxTrackletsPerCluster) {
-        printf("gpu tracklet selection: some lines will be left behind for cluster %d. valid: %d max: %d\n", iCurrentLayerClusterIndex, validTracklets, maxTrackletsPerCluster);
+    ssum[threadIdx.x] = localSum;
+    __syncthreads();
+    for (uint32_t stride = blockDim.x / 2; stride > 0; stride >>= 1) {
+      if (threadIdx.x < stride) {
+        ssum[threadIdx.x] += ssum[threadIdx.x + stride];
       }
+      __syncthreads();
+    }
+    if (threadIdx.x == 0) {
+      nTrackletsPerROF[iMode][rof] = ssum[0];
     }
   }
 }
 
-template <bool initRun>
-GPUg() void trackletSelectionKernelMultipleRof(
-  const Cluster* clusters0,               // Clusters on layer 0
-  const Cluster* clusters1,               // Clusters on layer 1
-  const int* sizeClustersL0,              // Number of clusters on layer 0 per ROF
-  const int* sizeClustersL1,              // Number of clusters on layer 1 per ROF
-  Tracklet* tracklets01,                  // Tracklets on layer 0-1
-  Tracklet* tracklets12,                  // Tracklets on layer 1-2
-  const int* nFoundTracklets01,           // Number of tracklets found on layers 0-1
-  const int* nFoundTracklets12,           // Number of tracklets found on layers 1-2
-  unsigned char* usedTracklets,           // Used tracklets
-  Line* lines,                            // Lines
-  int* nFoundLines,                       // Number of found lines
-  int* nExclusiveFoundLines,              // Number of found lines exclusive scan
-  const unsigned int startRofId,          // Starting ROF ID
-  const unsigned int rofSize,             // Number of ROFs to consider
-  const int maxTrackletsPerCluster = 1e2, // Maximum number of tracklets per cluster
-  const float tanLambdaCut = 0.025f,      // Cut on tan lambda
-  const float phiCut = 0.002f)            // Cut on phi
+template <typename T>
+GPUhi() void cubExclusiveScan(const T* GPUrestrict() in, T* GPUrestrict() out, int32_t num_items, cudaStream_t stream)
 {
-  for (unsigned int iRof{blockIdx.x}; iRof < rofSize; iRof += gridDim.x) {
-    auto rof = iRof + startRofId;
-    auto* clustersL0Rof = clusters0 + (sizeClustersL0[rof] - sizeClustersL0[startRofId]);
-    auto clustersL1offsetRof = sizeClustersL1[rof] - sizeClustersL1[startRofId];
-    auto* clustersL1Rof = clusters1 + clustersL1offsetRof;
-    auto nClustersL1Rof = sizeClustersL1[rof + 1] - sizeClustersL1[rof];
-    auto* tracklets01Rof = tracklets01 + clustersL1offsetRof * maxTrackletsPerCluster;
-    auto* tracklets12Rof = tracklets12 + clustersL1offsetRof * maxTrackletsPerCluster;
-    auto* foundTracklets01Rof = nFoundTracklets01 + clustersL1offsetRof;
-    auto* foundTracklets12Rof = nFoundTracklets12 + clustersL1offsetRof;
-    auto* usedTrackletsRof = usedTracklets + clustersL1offsetRof * maxTrackletsPerCluster;
-    auto* foundLinesRof = nFoundLines + clustersL1offsetRof;
-    int* nExclusiveFoundLinesRof = nullptr;
-    if constexpr (!initRun) {
-      nExclusiveFoundLinesRof = nExclusiveFoundLines + clustersL1offsetRof;
-    }
-    for (int iClusterIndexLayer1 = threadIdx.x; iClusterIndexLayer1 < nClustersL1Rof; iClusterIndexLayer1 += blockDim.x) {
-      const int stride{iClusterIndexLayer1 * maxTrackletsPerCluster};
-      int validTracklets{0};
-      for (int iTracklet12{0}; iTracklet12 < foundTracklets12Rof[iClusterIndexLayer1]; ++iTracklet12) {
-        for (int iTracklet01{0}; iTracklet01 < foundTracklets01Rof[iClusterIndexLayer1] && validTracklets < maxTrackletsPerCluster; ++iTracklet01) {
-          const float deltaTanLambda{o2::gpu::GPUCommonMath::Abs(tracklets01Rof[stride + iTracklet01].tanLambda - tracklets12Rof[stride + iTracklet12].tanLambda)};
-          const float deltaPhi{o2::gpu::GPUCommonMath::Abs(tracklets01Rof[stride + iTracklet01].phi - tracklets12Rof[stride + iTracklet12].phi)};
-          if (!usedTrackletsRof[stride + iTracklet01] && deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets != maxTrackletsPerCluster) {
-            usedTrackletsRof[stride + iTracklet01] = true;
-            if constexpr (!initRun) {
-              new (lines + nExclusiveFoundLinesRof[iClusterIndexLayer1] + validTracklets) Line{tracklets01Rof[stride + iTracklet01], clustersL0Rof, clustersL1Rof};
-            }
-            ++validTracklets;
-          }
-        }
-      }
-      if constexpr (initRun) {
-        foundLinesRof[iClusterIndexLayer1] = validTracklets;
-        // if (validTracklets >= maxTrackletsPerCluster) {
-        // printf("gpu tracklet selection: some lines will be left behind for cluster %d. valid: %d max: %d\n", iClusterIndexLayer1, validTracklets, maxTrackletsPerCluster);
-        // }
-      }
-    }
-  } // rof loop
+  void* d_temp_storage = nullptr;
+  size_t temp_storage_bytes = 0;
+  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in, out + 1, num_items, stream));
+  GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
+  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in, out + 1, num_items, stream));
+  GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
+}
+
+} // namespace gpu
+
+template <int nLayers>
+void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* GPUrestrict() utils,
+                                 const uint8_t* GPUrestrict() multMask,
+                                 const int32_t nRofs,
+                                 const int32_t deltaROF,
+                                 const int32_t* GPUrestrict() rofPV,
+                                 const int32_t vertPerRofThreshold,
+                                 const Cluster** GPUrestrict() clusters,
+                                 const uint32_t nClusters,
+                                 const int32_t** GPUrestrict() ROFClusters,
+                                 const uint8_t** GPUrestrict() usedClusters,
+                                 const int32_t** GPUrestrict() clustersIndexTables,
+                                 int32_t** GPUrestrict() trackletsPerClusterLUTs,
+                                 int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
+                                 int32_t** GPUrestrict() trackletsPerROF,
+                                 const std::array<int32_t*, 2>& trackletsPerClusterLUTsHost,
+                                 const std::array<int32_t*, 2>& trackletsPerClusterSumLUTsHost,
+                                 const int32_t iteration,
+                                 const float phiCut,
+                                 const int32_t maxTrackletsPerCluster,
+                                 const int32_t nBlocks,
+                                 const int32_t nThreads,
+                                 gpu::Streams& streams)
+{
+  const uint32_t sharedBytes = nThreads * (2 * deltaROF + 1) * sizeof(uint16_t);
+  gpu::computeLayerTrackletMutliROFKernel<nLayers, TrackletMode::Layer0Layer1, true><<<nBlocks, nThreads, sharedBytes, streams[0].get()>>>(clusters,
+                                                                                                                                           ROFClusters,
+                                                                                                                                           usedClusters,
+                                                                                                                                           clustersIndexTables,
+                                                                                                                                           phiCut,
+                                                                                                                                           nullptr,
+                                                                                                                                           trackletsPerClusterLUTs,
+                                                                                                                                           utils,
+                                                                                                                                           nRofs,
+                                                                                                                                           deltaROF,
+                                                                                                                                           rofPV,
+                                                                                                                                           iteration,
+                                                                                                                                           vertPerRofThreshold,
+                                                                                                                                           maxTrackletsPerCluster);
+  gpu::compileTrackletsPerROFKernel<TrackletMode::Layer0Layer1><<<nBlocks, nThreads, nThreads * sizeof(int32_t), streams[0].get()>>>(nRofs, trackletsPerROF, ROFClusters, (const int32_t**)trackletsPerClusterLUTs);
+  gpu::cubExclusiveScan(trackletsPerClusterLUTsHost[0], trackletsPerClusterSumLUTsHost[0], nClusters, streams[0].get());
+
+  gpu::computeLayerTrackletMutliROFKernel<nLayers, TrackletMode::Layer1Layer2, true><<<nBlocks, nThreads, sharedBytes, streams[1].get()>>>(clusters,
+                                                                                                                                           ROFClusters,
+                                                                                                                                           usedClusters,
+                                                                                                                                           clustersIndexTables,
+                                                                                                                                           phiCut,
+                                                                                                                                           nullptr,
+                                                                                                                                           trackletsPerClusterLUTs,
+                                                                                                                                           utils,
+                                                                                                                                           nRofs,
+                                                                                                                                           deltaROF,
+                                                                                                                                           rofPV,
+                                                                                                                                           iteration,
+                                                                                                                                           vertPerRofThreshold,
+                                                                                                                                           maxTrackletsPerCluster);
+  gpu::compileTrackletsPerROFKernel<TrackletMode::Layer1Layer2><<<nBlocks, nThreads, nThreads * sizeof(int), streams[1].get()>>>(nRofs, trackletsPerROF, ROFClusters, (const int**)trackletsPerClusterLUTs);
+  gpu::cubExclusiveScan(trackletsPerClusterLUTsHost[1], trackletsPerClusterSumLUTsHost[1], nClusters, streams[1].get());
+}
+
+template <int32_t nLayers>
+void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* GPUrestrict() utils,
+                                   const uint8_t* GPUrestrict() multMask,
+                                   const int32_t nRofs,
+                                   const int32_t deltaROF,
+                                   const int32_t* GPUrestrict() rofPV,
+                                   const int vertPerRofThreshold,
+                                   const Cluster** GPUrestrict() clusters,
+                                   const uint32_t nClusters,
+                                   const int32_t** GPUrestrict() ROFClusters,
+                                   const uint8_t** GPUrestrict() usedClusters,
+                                   const int32_t** GPUrestrict() clustersIndexTables,
+                                   Tracklet** GPUrestrict() foundTracklets,
+                                   const int32_t** GPUrestrict() trackletsPerClusterLUTs,
+                                   const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
+                                   const int32_t** GPUrestrict() trackletsPerROF,
+                                   const int32_t iteration,
+                                   const float phiCut,
+                                   const int32_t maxTrackletsPerCluster,
+                                   const int32_t nBlocks,
+                                   const int32_t nThreads,
+                                   gpu::Streams& streams)
+{
+  const uint32_t sharedBytes = nThreads * (2 * deltaROF + 1) * sizeof(uint16_t);
+  gpu::computeLayerTrackletMutliROFKernel<nLayers, TrackletMode::Layer0Layer1, false><<<nBlocks, nThreads, sharedBytes, streams[0].get()>>>(clusters,
+                                                                                                                                            ROFClusters,
+                                                                                                                                            usedClusters,
+                                                                                                                                            clustersIndexTables,
+                                                                                                                                            phiCut,
+                                                                                                                                            foundTracklets,
+                                                                                                                                            trackletsPerClusterSumLUTs,
+                                                                                                                                            utils,
+                                                                                                                                            nRofs,
+                                                                                                                                            deltaROF,
+                                                                                                                                            rofPV,
+                                                                                                                                            iteration,
+                                                                                                                                            vertPerRofThreshold,
+                                                                                                                                            maxTrackletsPerCluster);
+  gpu::computeLayerTrackletMutliROFKernel<nLayers, TrackletMode::Layer1Layer2, false><<<nBlocks, nThreads, sharedBytes, streams[1].get()>>>(clusters,
+                                                                                                                                            ROFClusters,
+                                                                                                                                            usedClusters,
+                                                                                                                                            clustersIndexTables,
+                                                                                                                                            phiCut,
+                                                                                                                                            foundTracklets,
+                                                                                                                                            trackletsPerClusterSumLUTs,
+                                                                                                                                            utils,
+                                                                                                                                            nRofs,
+                                                                                                                                            deltaROF,
+                                                                                                                                            rofPV,
+                                                                                                                                            iteration,
+                                                                                                                                            vertPerRofThreshold,
+                                                                                                                                            maxTrackletsPerCluster);
+}
+
+void countTrackletsMatchingInROFsHandler(const int32_t nRofs,
+                                         const int32_t deltaROF,
+                                         const uint32_t nClusters,
+                                         const int32_t** GPUrestrict() ROFClusters,
+                                         const Cluster** GPUrestrict() clusters,
+                                         uint8_t** GPUrestrict() usedClusters,
+                                         const Tracklet** GPUrestrict() foundTracklets,
+                                         uint8_t* GPUrestrict() usedTracklets,
+                                         const int32_t** GPUrestrict() trackletsPerClusterLUTs,
+                                         const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
+                                         int32_t* GPUrestrict() linesPerClusterLUT,
+                                         int32_t* GPUrestrict() linesPerClusterSumLUT,
+                                         const int32_t iteration,
+                                         const float phiCut,
+                                         const float tanLambdaCut,
+                                         const int32_t nBlocks,
+                                         const int32_t nThreads,
+                                         gpu::Streams& streams)
+{
+  streams[1].sync(); // need to make sure that all tracklets are done, since this placed in 0 tracklet01 will be done but tracklet12 needs to be guaranteed
+  gpu::computeTrackletSelectionMutliROFKernel<true><<<nBlocks, nThreads, 0, streams[0].get()>>>(nullptr,
+                                                                                                usedClusters,
+                                                                                                ROFClusters,
+                                                                                                phiCut,
+                                                                                                tanLambdaCut,
+                                                                                                foundTracklets,
+                                                                                                usedTracklets,
+                                                                                                trackletsPerClusterLUTs,
+                                                                                                trackletsPerClusterSumLUTs,
+                                                                                                linesPerClusterLUT,
+                                                                                                nullptr,
+                                                                                                nRofs,
+                                                                                                deltaROF,
+                                                                                                100);
+  gpu::cubExclusiveScan(linesPerClusterLUT, linesPerClusterSumLUT, nClusters, streams[0].get());
 }
 
+void computeTrackletsMatchingInROFsHandler(const int32_t nRofs,
+                                           const int32_t deltaROF,
+                                           const uint32_t nClusters,
+                                           const int32_t** GPUrestrict() ROFClusters,
+                                           const Cluster** GPUrestrict() clusters,
+                                           const uint8_t** GPUrestrict() usedClusters,
+                                           const Tracklet** GPUrestrict() foundTracklets,
+                                           uint8_t* GPUrestrict() usedTracklets,
+                                           const int32_t** GPUrestrict() trackletsPerClusterLUTs,
+                                           const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
+                                           const int32_t* GPUrestrict() linesPerClusterSumLUT,
+                                           Line* GPUrestrict() lines,
+                                           const int32_t iteration,
+                                           const float phiCut,
+                                           const float tanLambdaCut,
+                                           const int32_t nBlocks,
+                                           const int32_t nThreads,
+                                           gpu::Streams& streams)
+{
+  gpu::computeTrackletSelectionMutliROFKernel<false><<<nBlocks, nThreads, 0, streams[0].get()>>>(clusters,
+                                                                                                 nullptr,
+                                                                                                 ROFClusters,
+                                                                                                 phiCut,
+                                                                                                 tanLambdaCut,
+                                                                                                 foundTracklets,
+                                                                                                 usedTracklets,
+                                                                                                 trackletsPerClusterLUTs,
+                                                                                                 trackletsPerClusterSumLUTs,
+                                                                                                 linesPerClusterSumLUT,
+                                                                                                 lines,
+                                                                                                 nRofs,
+                                                                                                 deltaROF,
+                                                                                                 100);
+}
+
+/// Explicit instantiation of ITS2 handlers
+template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* GPUrestrict() utils,
+                                             const uint8_t* GPUrestrict() multMask,
+                                             const int32_t nRofs,
+                                             const int32_t deltaROF,
+                                             const int32_t* GPUrestrict() rofPV,
+                                             const int32_t vertPerRofThreshold,
+                                             const Cluster** GPUrestrict() clusters,
+                                             const uint32_t nClusters,
+                                             const int32_t** GPUrestrict() ROFClusters,
+                                             const uint8_t** GPUrestrict() usedClusters,
+                                             const int32_t** GPUrestrict() clustersIndexTables,
+                                             int32_t** trackletsPerClusterLUTs,
+                                             int32_t** trackletsPerClusterSumLUTs,
+                                             int32_t** trackletsPerROF,
+                                             const std::array<int32_t*, 2>& trackletsPerClusterLUTsHost,
+                                             const std::array<int32_t*, 2>& trackletsPerClusterSumLUTsHost,
+                                             const int32_t iteration,
+                                             const float phiCut,
+                                             const int32_t maxTrackletsPerCluster,
+                                             const int32_t nBlocks,
+                                             const int32_t nThreads,
+                                             gpu::Streams& streams);
+
+template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* GPUrestrict() utils,
+                                               const uint8_t* GPUrestrict() multMask,
+                                               const int32_t nRofs,
+                                               const int32_t deltaROF,
+                                               const int32_t* GPUrestrict() rofPV,
+                                               const int vertPerRofThreshold,
+                                               const Cluster** GPUrestrict() clusters,
+                                               const uint32_t nClusters,
+                                               const int32_t** GPUrestrict() ROFClusters,
+                                               const uint8_t** GPUrestrict() usedClusters,
+                                               const int32_t** GPUrestrict() clustersIndexTables,
+                                               Tracklet** GPUrestrict() foundTracklets,
+                                               const int32_t** GPUrestrict() trackletsPerClusterLUTs,
+                                               const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
+                                               const int32_t** GPUrestrict() trackletsPerROF,
+                                               const int32_t iteration,
+                                               const float phiCut,
+                                               const int32_t maxTrackletsPerCluster,
+                                               const int32_t nBlocks,
+                                               const int32_t nThreads,
+                                               gpu::Streams& streams);
+/*
 GPUg() void lineClustererMultipleRof(
   const int* sizeClustersL1,     // Number of clusters on layer 1 per ROF
   Line* lines,                   // Lines
@@ -567,6 +657,4 @@ GPUg() void computeVertexKernel(
   }
 }
 */
-} // namespace gpu
-} // namespace its
-} // namespace o2
+} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
index dd83669311a54..e8e475f2232c8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
@@ -19,8 +19,8 @@ if(HIP_ENABLED)
                          ../cuda/TrackerTraitsGPU.cxx
                          ../cuda/TracerGPU.cu
                          ../cuda/TrackingKernels.cu
-                         # ../cuda/VertexingKernels.cu
-                         # ../cuda/VertexerTraitsGPU.cxx
+                         ../cuda/VertexingKernels.cu
+                         ../cuda/VertexerTraitsGPU.cxx
                  PUBLIC_INCLUDE_DIRECTORIES ../
                  PUBLIC_LINK_LIBRARIES O2::ITStracking
                                        O2::GPUTracking
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
index 72857794c711e..c3be0de2dade7 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
@@ -15,6 +15,8 @@
 #ifndef TRACKINGITS_DEFINITIONS_H_
 #define TRACKINGITS_DEFINITIONS_H_
 
+#include <type_traits>
+
 #include "ReconstructionDataFormats/Vertex.h"
 
 #ifdef CA_DEBUG
@@ -28,8 +30,16 @@
 namespace o2::its
 {
 
+enum class TrackletMode {
+  Layer0Layer1 = 0,
+  Layer1Layer2 = 2
+};
+
 using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
-}
+template <bool IsConst, typename T>
+using maybe_const = typename std::conditional<IsConst, const T, T>::type;
+
+} // namespace o2::its
 
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index a148049e50129..c34701ce222e2 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -204,10 +204,8 @@ struct TimeFrame {
   void computeTracletsPerClusterScans();
   int& getNTrackletsROF(int rofId, int combId) { return mNTrackletsPerROF[combId][rofId]; }
   auto& getLines(int rofId) { return mLines[rofId]; }
-  int getNLinesTotal() const
-  {
-    return std::accumulate(mLines.begin(), mLines.end(), 0, [](int sum, const auto& l) { return sum + l.size(); });
-  }
+  int getNLinesTotal() const noexcept { return mTotalLines; }
+  void setNLinesTotal(uint32_t a) noexcept { mTotalLines = a; }
   auto& getTrackletClusters(int rofId) { return mTrackletClusters[rofId]; }
   gsl::span<const Tracklet> getFoundTracklets(int rofId, int combId) const;
   gsl::span<Tracklet> getFoundTracklets(int rofId, int combId);
@@ -237,10 +235,9 @@ struct TimeFrame {
 
   void setExternalAllocator(ExternalAllocator* allocator)
   {
-    if (mIsGPU) {
+    if (isGPU()) {
       LOGP(debug, "Setting timeFrame allocator to external");
       mAllocator = allocator;
-      mExtAllocator = true; // to be removed
     } else {
       LOGP(fatal, "External allocator is currently only supported for GPU");
     }
@@ -276,8 +273,6 @@ struct TimeFrame {
 
   IndexTableUtilsN mIndexTableUtils;
 
-  bool mIsGPU = false;
-
   std::array<bounded_vector<Cluster>, nLayers> mClusters;
   std::array<bounded_vector<TrackingFrameInfo>, nLayers> mTrackingFrameInfo;
   std::array<bounded_vector<int>, nLayers> mClusterExternalIndices;
@@ -296,9 +291,8 @@ struct TimeFrame {
   bounded_vector<Vertex> mPrimaryVertices;
 
   // State if memory will be externally managed.
-  bool mExtAllocator = false;
   ExternalAllocator* mAllocator = nullptr;
-  bool getExtAllocator() const { return mExtAllocator; }
+  bool getExtAllocator() const noexcept { return mAllocator != nullptr; }
 
   std::array<bounded_vector<Cluster>, nLayers> mUnsortedClusters;
   std::vector<bounded_vector<Tracklet>> mTracklets;
@@ -313,6 +307,10 @@ struct TimeFrame {
 
   virtual void wipe();
 
+  // interface
+  virtual bool isGPU() const noexcept { return false; }
+  virtual const char* getName() const noexcept { return "CPU"; }
+
  private:
   void prepareClusters(const TrackingParameters& trkParam, const int maxLayers = nLayers);
   float mBz = 5.;
@@ -348,6 +346,7 @@ struct TimeFrame {
   std::vector<std::pair<MCCompLabel, float>> mVerticesMCRecInfo;
   bounded_vector<MCCompLabel> mVerticesContributorLabels;
   std::array<uint32_t, 2> mTotalTracklets = {0, 0};
+  uint32_t mTotalLines = 0;
   unsigned int mNoVertexROF = 0;
   bounded_vector<int> mTotVertPerIteration;
   // \Vertexer
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 4c445bdbbfa16..d368eb1d1f56a 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -136,6 +136,12 @@ struct ITSGpuTrackingParamConfig : public o2::conf::ConfigurableParamHelper<ITSG
   int nBlocksTracksSeeds[MaxIter] = {60, 60, 60, 60};
   int nThreadsTracksSeeds[MaxIter] = {256, 256, 256, 256};
 
+  int nBlocksVtxComputeTracklets[2] = {60, 60};
+  int nThreadsVtxComputeTracklets[2] = {256, 256};
+
+  int nBlocksVtxComputeMatching[2] = {60, 60};
+  int nThreadsVtxComputeMatching[2] = {256, 256};
+
   O2ParamDef(ITSGpuTrackingParamConfig, "ITSGpuTrackingParam");
 };
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 7da7617957179..dda32ddfd5aec 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -43,11 +43,6 @@ class MCCompLabel;
 namespace its
 {
 
-enum class TrackletMode {
-  Layer0Layer1 = 0,
-  Layer1Layer2 = 2
-};
-
 template <int nLayers>
 class VertexerTraits
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index c6eee88a9f48b..59459dcab17e8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -87,7 +87,7 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
       }
       double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
       int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
-      int nROFsIterations = (mTrkParams[iteration].nROFsPerIterations > 0 && !mTimeFrame->mIsGPU) ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
+      int nROFsIterations = (mTrkParams[iteration].nROFsPerIterations > 0 && !mTimeFrame->isGPU()) ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
       iVertex = std::min(maxNvertices, 0);
       logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 153d7b6faa358..53be03af7eb14 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -17,6 +17,7 @@
 
 #include <oneapi/tbb/blocked_range.h>
 #include <oneapi/tbb/parallel_for.h>
+#include <oneapi/tbb/combinable.h>
 
 #include "ITStracking/VertexerTraits.h"
 #include "ITStracking/BoundedAllocator.h"
@@ -290,6 +291,7 @@ template <int nLayers>
 void VertexerTraits<nLayers>::computeTrackletMatching(const int iteration)
 {
   mTaskArena->execute([&] {
+    tbb::combinable<int> totalLines{0};
     tbb::parallel_for(
       tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
       [&](const tbb::blocked_range<short>& Rofs) {
@@ -333,8 +335,10 @@ void VertexerTraits<nLayers>::computeTrackletMatching(const int iteration)
                 mVrtParams[iteration].phiCut);
             }
           }
+          totalLines.local() += mTimeFrame->getLines(pivotRofId).size();
         }
       });
+    mTimeFrame->setNLinesTotal(totalLines.combine(std::plus<int>()));
   });
 
 #ifdef VTX_DEBUG
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
index c4202e9980d24..813e0aef2d1aa 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
@@ -21,7 +21,7 @@
 #include "ITStracking/TimeFrame.h"
 #if defined(__CUDACC__) || defined(__HIPCC__)
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
-// #include "ITStrackingGPU/VertexerTraitsGPU.h"
+#include "ITStrackingGPU/VertexerTraitsGPU.h"
 #include "ITStrackingGPU/TimeFrameGPU.h"
 #endif
 #else
@@ -39,10 +39,10 @@ template <int32_t>
 class TimeFrame
 {
 };
-// template <int32_t NLayers>
-// class VertexerTraitsGPU : public VertexerTraits<NLayers>
-// {
-// };
+template <int32_t NLayers>
+class VertexerTraitsGPU : public VertexerTraits<NLayers>
+{
+};
 template <int32_t NLayers = 7>
 class TrackerTraitsGPU : public TrackerTraits<NLayers>
 {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 71582b4fed55e..9e7cfa5495040 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -97,7 +97,9 @@ void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<
     trackerTraits->reset(new o2::its::TrackerTraitsGPU);
   }
   if (vertexerTraits) {
-    vertexerTraits->reset(new o2::its::VertexerTraits<7>); // TODO gpu-code to be implemented
+    vertexerTraits->reset(new o2::its::VertexerTraits<7>);
+    // TODO gpu-code to be implemented then remove line above and uncomment line below
+    // vertexerTraits->reset(new o2::its::VertexerTraitsGPU<7>);
   }
   if (timeFrame) {
     timeFrame->reset(new o2::its::gpu::TimeFrameGPU);
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index e53f5db3a2549..26dff3710cd4a 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -70,7 +70,7 @@ o2::its::TimeFrame<7>* GPUChainITS::GetITSTimeframe()
     mRec->GetITSTraits(nullptr, nullptr, &mITSTimeFrame);
   }
 #if !defined(GPUCA_STANDALONE)
-  if (mITSTimeFrame->mIsGPU) {
+  if (mITSTimeFrame->isGPU()) {
     auto doFWExtAlloc = [this](size_t size) -> void* { return rec()->AllocateDirectMemory(size, GPUMemoryResource::MEMORY_GPU); };
 
     mFrameworkAllocator.reset(new o2::its::GPUFrameworkExternalAllocator);

From 8eabc2e7d098aef70601aace2eb04e24a71cc66d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Sep 2025 22:16:05 +0200
Subject: [PATCH 0796/1764] Bump actions/stale from 9 to 10 (#14659)

Bumps [actions/stale](https://github.com/actions/stale) from 9 to 10.
- [Release notes](https://github.com/actions/stale/releases)
- [Changelog](https://github.com/actions/stale/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/stale/compare/v9...v10)

---
updated-dependencies:
- dependency-name: actions/stale
  dependency-version: '10'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/stale.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
index b1be426cdfc77..23f454aaca950 100644
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -7,7 +7,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v9
+    - uses: actions/stale@v10
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         stale-pr-message: 'This PR did not have any update in the last 30 days. Is it still needed? Unless further action in will be closed in 5 days.'

From 22e05b56e9e7de0f7ef457b8e84fa7f8fa99fd41 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Sep 2025 22:16:35 +0200
Subject: [PATCH 0797/1764] Bump actions/setup-python from 5 to 6 (#14658)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5 to 6.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5...v6)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/datamodel-doc.yml | 2 +-
 .github/workflows/reports.yml       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/datamodel-doc.yml b/.github/workflows/datamodel-doc.yml
index 51789c9697196..83cbaf44251ee 100644
--- a/.github/workflows/datamodel-doc.yml
+++ b/.github/workflows/datamodel-doc.yml
@@ -40,7 +40,7 @@ jobs:
           git checkout -B auto-datamodel-doc
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: 3.x
 
diff --git a/.github/workflows/reports.yml b/.github/workflows/reports.yml
index cadb920fa022f..75ca7f7dc65a9 100644
--- a/.github/workflows/reports.yml
+++ b/.github/workflows/reports.yml
@@ -19,7 +19,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python 3.10
-      uses: actions/setup-python@v5
+      uses: actions/setup-python@v6
       with:
         python-version: '3.10'
     - uses: actions/cache@v4

From e63e19ced04beed1461415bf1e66509a0715ee67 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Sep 2025 22:16:56 +0200
Subject: [PATCH 0798/1764] Bump actions/first-interaction from 1 to 3 (#14573)

Bumps [actions/first-interaction](https://github.com/actions/first-interaction) from 1 to 3.
- [Release notes](https://github.com/actions/first-interaction/releases)
- [Commits](https://github.com/actions/first-interaction/compare/v1...v3)

---
updated-dependencies:
- dependency-name: actions/first-interaction
  dependency-version: '3'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/first-timer.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/first-timer.yml b/.github/workflows/first-timer.yml
index 20b7ee6a070a8..54334d109bd49 100644
--- a/.github/workflows/first-timer.yml
+++ b/.github/workflows/first-timer.yml
@@ -8,7 +8,7 @@ jobs:
   nag_first_timer:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/first-interaction@v1
+    - uses: actions/first-interaction@v3
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         pr-message: 'This seems to be your first PR. You will need a positive review in order for tests to start.'

From 9dfb8b263dca0a21fba2df62ba73448f8217fa4f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Sep 2025 22:17:19 +0200
Subject: [PATCH 0799/1764] Bump actions/checkout from 4 to 5 (#14572)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4 to 5.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/code-transformations.yml | 2 +-
 .github/workflows/datamodel-doc.yml        | 6 +++---
 .github/workflows/doxygen.yml              | 2 +-
 .github/workflows/release.yml              | 2 +-
 .github/workflows/reports.yml              | 2 +-
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/code-transformations.yml b/.github/workflows/code-transformations.yml
index bfc60fdfcbe44..35493afda94f5 100644
--- a/.github/workflows/code-transformations.yml
+++ b/.github/workflows/code-transformations.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         ref: ${{ github.event.pull_request.head.sha }}
         persist-credentials: false
diff --git a/.github/workflows/datamodel-doc.yml b/.github/workflows/datamodel-doc.yml
index 83cbaf44251ee..3ba015631aec6 100644
--- a/.github/workflows/datamodel-doc.yml
+++ b/.github/workflows/datamodel-doc.yml
@@ -10,20 +10,20 @@ jobs:
     steps:
 
       - name: Checkout O2
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           path: O2
           persist-credentials: false
 
       - name: Checkout O2Physics
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           repository: AliceO2Group/O2Physics
           path: O2Physics
           persist-credentials: false
 
       - name: Checkout documentation
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           repository: AliceO2Group/analysis-framework
           path: analysis-framework
diff --git a/.github/workflows/doxygen.yml b/.github/workflows/doxygen.yml
index ae867739eba62..b1dbaf122b342 100644
--- a/.github/workflows/doxygen.yml
+++ b/.github/workflows/doxygen.yml
@@ -13,7 +13,7 @@ jobs:
       run: |
         sudo apt-get update -y
         sudo apt-get install -y doxygen doxygen-doc doxygen-latex doxygen-gui graphviz cmake
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         ref: "dev"
         persist-credentials: false
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index a401af1ba39e2..2f692527ea5ce 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -18,7 +18,7 @@ jobs:
         branch=$(echo ${{ github.event.inputs.tag }}-patches | tr . - | sed -e's/-[0-9]*-patches$/-patches/')
         EOF
       id: decide_release_branch
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
         ref: "dev"
     - name: Tag branch (or create one before tagging if does not exists)
diff --git a/.github/workflows/reports.yml b/.github/workflows/reports.yml
index 75ca7f7dc65a9..936be948b7218 100644
--- a/.github/workflows/reports.yml
+++ b/.github/workflows/reports.yml
@@ -17,7 +17,7 @@ jobs:
     if: github.repository == 'AliceO2Group/AliceO2'
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Set up Python 3.10
       uses: actions/setup-python@v6
       with:

From da04bfb20fd98d3b45469a041e0c41b59fe8a5e4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 26 Jul 2025 12:30:19 +0200
Subject: [PATCH 0800/1764] GPU QA: Add track t0 QA

---
 GPU/GPUTracking/qa/GPUQA.cxx | 72 +++++++++++++++++++++++++++++++++---
 GPU/GPUTracking/qa/GPUQA.h   |  5 +++
 2 files changed, 71 insertions(+), 6 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 3f57ecd8f88be..c3028facc67a5 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -531,10 +531,12 @@ int32_t GPUQA::InitQACreateHistograms()
       snprintf(name, 2048, i ? "nrows_with_cluster" : "nclusters");
       createHist(mNCl[i], name, name, 160, 0, 159);
     }
-    snprintf(name, 2048, "tracks");
     std::unique_ptr<double[]> binsPt{CreateLogAxis(AXIS_BINS[4], PT_MIN_CLUST, PT_MAX)};
-    createHist(mTracks, name, name, AXIS_BINS[4], binsPt.get());
-    createHist(mClXY, "clXY", "clXY", 1000, -250, 250, 1000, -250, 250);
+    createHist(mTracks, "tracks_pt", "tracks_pt", AXIS_BINS[4], binsPt.get());
+    const uint32_t maxTime = (mTracking && mTracking->GetParam().continuousMaxTimeBin > 0) ? mTracking->GetParam().continuousMaxTimeBin : TPC_MAX_TIME_BIN_TRIGGERED;
+    createHist(mT0[0], "tracks_t0", "tracks_t0", (maxTime + 1) / 10, 0, maxTime);
+    createHist(mT0[1], "tracks_t0_res", "tracks_t0_res", 1000, -100, 100);
+    createHist(mClXY, "clXY", "clXY", 1000, -250, 250, 1000, -250, 250); // TODO: Pass name only once
   }
 
   if ((mQATasks & taskClusterCounts) && mConfig.clusterRejectionHistograms) {
@@ -1732,6 +1734,11 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
       mNCl[1]->Fill(nClCorrected);
+      mT0[0]->Fill(track.GetParam().GetTZOffset());
+      if (mTrackMCLabels.size() && !mTrackMCLabels[i].isFake() && !track.MergedLooper() && !track.CCE()) {
+        const auto& info = GetMCTrack(mTrackMCLabels[i]);
+        mT0[1]->Fill(track.GetParam().GetTZOffset() - info.t0);
+      }
     }
     if (mClNative && mTracking && mTracking->GetTPCTransformHelper()) {
       for (uint32_t i = 0; i < GPUChainTracking::NSECTORS; i++) {
@@ -2130,7 +2137,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
 
     // Create Canvas for track statistic histos
     if (mQATasks & taskTrackStatistics) {
-      mCTracks = createGarbageCollected<TCanvas>("ctracks", "Track Pt", 0, 0, 700, 700. * 2. / 3.);
+      mCTracks = createGarbageCollected<TCanvas>("ctrackspt", "Track Pt", 0, 0, 700, 700. * 2. / 3.);
       mCTracks->cd();
       mPTracks = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPTracks->Draw();
@@ -2138,7 +2145,15 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       SetLegend(mLTracks);
 
       for (int32_t i = 0; i < 2; i++) {
-        snprintf(name, 2048, "cncl%d Pull", i);
+        snprintf(name, 2048, "ctrackst0%d", i);
+        mCT0[i] = createGarbageCollected<TCanvas>(name, "Track T0", 0, 0, 700, 700. * 2. / 3.);
+        mCT0[i]->cd();
+        mPT0[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
+        mPT0[i]->Draw();
+        mLT0[i] = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.45, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
+        SetLegend(mLT0[i]);
+
+        snprintf(name, 2048, "cncl%d", i);
         mCNCl[i] = createGarbageCollected<TCanvas>(name, i ? "Number of clusters (corrected for multiple per row)" : "Number of clusters per track", 0, 0, 700, 700. * 2. / 3.);
         mCNCl[i]->cd();
         mPNCl[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
@@ -2742,7 +2757,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
   if (mQATasks & taskTrackStatistics) {
     // Process track statistic histograms
     float tmpMax = 0.;
-    for (int32_t k = 0; k < ConfigNumInputs; k++) {
+    for (int32_t k = 0; k < ConfigNumInputs; k++) { // TODO: Simplify this drawing, avoid copy&paste
       TH1F* e = mTracks;
       if (GetHist(e, tin, k, nNewInput) == nullptr) {
         continue;
@@ -2786,6 +2801,51 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     }
 
     for (int32_t i = 0; i < 2; i++) {
+      tmpMax = 0.;
+      for (int32_t k = 0; k < ConfigNumInputs; k++) {
+        TH1F* e = mT0[i];
+        if (GetHist(e, tin, k, nNewInput) == nullptr) {
+          continue;
+        }
+        e->SetMaximum(-1111);
+        if (e->GetMaximum() > tmpMax) {
+          tmpMax = e->GetMaximum();
+        }
+      }
+      mPT0[i]->cd();
+      for (int32_t k = 0; k < ConfigNumInputs; k++) {
+        TH1F* e = mT0[i];
+        if (GetHist(e, tin, k, nNewInput) == nullptr) {
+          continue;
+        }
+        if (tout && !mConfig.inputHistogramsOnly && k == 0) {
+          e->Write();
+        }
+        e->SetMaximum(tmpMax * 1.02);
+        e->SetMinimum(tmpMax * -0.02);
+        e->SetStats(kFALSE);
+        e->SetLineWidth(1);
+        e->GetYaxis()->SetTitle("a.u.");
+        e->GetXaxis()->SetTitle(i ? "to vs t0_{mc}" : "t0");
+        if (qcout) {
+          qcout->Add(e);
+        }
+        e->SetMarkerColor(kBlack);
+        e->SetLineColor(colorNums[k % COLORCOUNT]);
+        e->Draw(k == 0 ? "" : "same");
+        GetName(fname, k);
+        snprintf(name, 2048, "%sTrack T0 %s", fname, i ? "" : "resolution");
+        mLT0[i]->AddEntry(e, name, "l");
+      }
+      mLT0[i]->Draw();
+      mCT0[i]->cd();
+      snprintf(name, 2048, "plots/t0%s.pdf", i ? "_res" : "");
+      mCT0[i]->Print(name);
+      if (mConfig.writeRootFiles) {
+        snprintf(name, 2048, "plots/t0%s.root", i ? "_res" : "");
+        mCT0[i]->Print(name);
+      }
+
       tmpMax = 0.;
       for (int32_t k = 0; k < ConfigNumInputs; k++) {
         TH1F* e = mNCl[i];
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index e587b15f68d80..591eb1722bf9f 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -305,6 +305,11 @@ class GPUQA
   TPad* mPNCl[2];
   TLegend* mLNCl[2];
 
+  TH1F* mT0[2];
+  TCanvas* mCT0[2];
+  TPad* mPT0[2];
+  TLegend* mLT0[2];
+
   TH2F* mClXY;
   TCanvas* mCClXY;
   TPad* mPClXY;

From 52abf75ebad4f6f2f1f52918abb09e078fd74600 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 21 Jul 2025 15:21:28 +0200
Subject: [PATCH 0801/1764] GPU Display: Block until display started and print
 meaningful info messages to the console

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  7 +++-
 .../Interface/GPUO2InterfaceDisplay.cxx       |  6 ++-
 GPU/GPUTracking/display/GPUDisplay.cxx        | 42 ++++++++++++++-----
 GPU/GPUTracking/display/GPUDisplay.h          | 27 +++++++-----
 GPU/GPUTracking/display/GPUDisplayInterface.h |  3 +-
 .../display/frontend/GPUDisplayKeys.cxx       |  2 +-
 .../display/render/GPUDisplayDraw.cxx         |  2 +-
 7 files changed, 61 insertions(+), 28 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 9d2578731a30c..79e9ce6cef766 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -824,6 +824,7 @@ int32_t GPUChainTracking::RunChainFinalize()
 
   if (GetProcessingSettings().eventDisplay) {
     if (!mDisplayRunning) {
+      GPUInfo("Starting Event Display...");
       if (mEventDisplay->StartDisplay()) {
         return (1);
       }
@@ -832,6 +833,8 @@ int32_t GPUChainTracking::RunChainFinalize()
       mEventDisplay->ShowNextEvent();
     }
 
+    mEventDisplay->WaitTillEventShown();
+
     if (GetProcessingSettings().eventDisplay->EnableSendKey()) {
       while (kbhit()) {
         getch();
@@ -863,9 +866,9 @@ int32_t GPUChainTracking::RunChainFinalize()
       return (2);
     }
     GetProcessingSettings().eventDisplay->setDisplayControl(0);
-    GPUInfo("Loading next event");
+    GPUInfo("Loading next event...");
 
-    mEventDisplay->WaitForNextEvent();
+    mEventDisplay->BlockTillNextEvent();
   }
 
   return 0;
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
index 60d5eaf9ae162..ad740200a253a 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
@@ -46,7 +46,8 @@ int32_t GPUO2InterfaceDisplay::startDisplay()
   if (retVal) {
     return retVal;
   }
-  mDisplay->WaitForNextEvent();
+  mDisplay->WaitTillEventShown();
+  mDisplay->BlockTillNextEvent();
   return 0;
 }
 
@@ -59,6 +60,7 @@ int32_t GPUO2InterfaceDisplay::show(const GPUTrackingInOutPointers* ptrs)
     ptrs = tmpPtr.get();
   }
   mDisplay->ShowNextEvent(ptrs);
+  mDisplay->WaitTillEventShown();
   do {
     usleep(10000);
   } while (mFrontend->getDisplayControl() == 0);
@@ -66,7 +68,7 @@ int32_t GPUO2InterfaceDisplay::show(const GPUTrackingInOutPointers* ptrs)
     return 1;
   }
   mFrontend->setDisplayControl(0);
-  mDisplay->WaitForNextEvent();
+  mDisplay->BlockTillNextEvent();
   return 0;
 }
 
diff --git a/GPU/GPUTracking/display/GPUDisplay.cxx b/GPU/GPUTracking/display/GPUDisplay.cxx
index 136b1947f60ee..163e4c0981bc2 100644
--- a/GPU/GPUTracking/display/GPUDisplay.cxx
+++ b/GPU/GPUTracking/display/GPUDisplay.cxx
@@ -21,6 +21,8 @@
 #include <memory>
 #include <cstring>
 #include <stdexcept>
+#include <mutex>
+#include <condition_variable>
 
 #ifndef _WIN32
 #include "../utils/linux_helpers.h"
@@ -143,7 +145,7 @@ void GPUDisplay::ResizeScene(int32_t width, int32_t height, bool init)
   mBackend->resizeScene(width, height);
 
   if (init) {
-    mResetScene = 1;
+    mResetScene = true;
     mViewMatrix = MY_HMM_IDENTITY;
     mModelMatrix = MY_HMM_IDENTITY;
   }
@@ -220,6 +222,14 @@ int32_t GPUDisplay::DrawGLScene()
     GPUError("Runtime error %s during display", e.what());
     retVal = 1;
   }
+
+  if (mLoadAndShowEvent) {
+    {
+      std::lock_guard<std::mutex> lock(mMutexLoadAndShowEvent);
+      mLoadAndShowEvent = false;
+    }
+    mCVLoadAndShowEvent.notify_one();
+  }
   mSemLockDisplay.Unlock();
 
   return retVal;
@@ -266,9 +276,9 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSla
     mCfgR.camLookOrigin = mCfgR.camYUp = false;
     mAngleRollOrigin = -1e9f;
     mCfgR.fov = 45.f;
-    mUpdateDrawCommands = 1;
+    mUpdateDrawCommands = true;
 
-    mResetScene = 0;
+    mResetScene = false;
   } else {
     float moveZ = scalefactor * ((float)mMouseWheelTmp / 150 + (float)(mFrontend->mKeys[(uint8_t)'W'] - mFrontend->mKeys[(uint8_t)'S']) * (!mFrontend->mKeys[mFrontend->KEY_SHIFT]) * 0.2f * mFPSScale);
     float moveY = scalefactor * ((float)(mFrontend->mKeys[mFrontend->KEY_PAGEDOWN] - mFrontend->mKeys[mFrontend->KEY_PAGEUP]) * 0.2f * mFPSScale);
@@ -386,7 +396,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSla
     }
     if (deltaLine) {
       SetInfo("%s line width: %f", deltaLine > 0 ? "Increasing" : "Decreasing", mCfgL.lineWidth);
-      mUpdateDrawCommands = 1;
+      mUpdateDrawCommands = true;
     }
     minSize *= 2;
     int32_t deltaPoint = mFrontend->mKeys[(uint8_t)'+'] * (!mFrontend->mKeysShift[(uint8_t)'+']) - mFrontend->mKeys[(uint8_t)'-'] * (!mFrontend->mKeysShift[(uint8_t)'-']);
@@ -396,7 +406,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSla
     }
     if (deltaPoint) {
       SetInfo("%s point size: %f", deltaPoint > 0 ? "Increasing" : "Decreasing", mCfgL.pointSize);
-      mUpdateDrawCommands = 1;
+      mUpdateDrawCommands = true;
     }
   }
 
@@ -616,7 +626,7 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     disableUnsupportedOptions();
   }
   if (mUpdateEventData || mUpdateVertexLists) {
-    mUpdateDrawCommands = 1;
+    mUpdateDrawCommands = true;
   }
 
   if (animateTime < 0 && (mUpdateEventData || mResetScene) && mIOPtrs) {
@@ -625,8 +635,8 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     mTimerFPS.ResetStart();
     mFramesDoneFPS = 0;
     mFPSScaleadjust = 0;
-    mUpdateVertexLists = 1;
-    mUpdateEventData = 0;
+    mUpdateVertexLists = true;
+    mUpdateEventData = false;
   }
 
   hmm_mat4 nextViewMatrix = MY_HMM_IDENTITY;
@@ -658,7 +668,7 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     mBackend->drawField();
   }
 
-  mUpdateDrawCommands = mUpdateRenderPipeline = 0;
+  mUpdateDrawCommands = mUpdateRenderPipeline = false;
   mBackend->finishDraw(doScreenshot, renderToMixBuffer, mixSlaveImage);
 
   if (animateTime < 0) {
@@ -708,15 +718,25 @@ void GPUDisplay::ShowNextEvent(const GPUTrackingInOutPointers* ptrs)
   if (mMaxClusterZ <= 0) {
     mResetScene = true;
   }
-  mSemLockDisplay.Unlock();
   mFrontend->mNeedUpdate = 1;
   mUpdateEventData = true;
+  mLoadAndShowEvent = true;
+  mSemLockDisplay.Unlock();
 }
 
-void GPUDisplay::WaitForNextEvent() { mSemLockDisplay.Lock(); }
+void GPUDisplay::BlockTillNextEvent() { mSemLockDisplay.Lock(); }
+
+void GPUDisplay::WaitTillEventShown()
+{
+  std::unique_lock<std::mutex> lock(mMutexLoadAndShowEvent);
+  while (mLoadAndShowEvent) {
+    mCVLoadAndShowEvent.wait(lock);
+  }
+}
 
 int32_t GPUDisplay::StartDisplay()
 {
+  mLoadAndShowEvent = true;
   if (mFrontend->StartDisplay()) {
     return (1);
   }
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index 06977c26e0b63..b59e3c52e9bd3 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -20,13 +20,15 @@
 #include "GPUDisplayInterface.h"
 #include "GPUSettings.h"
 
-#include "../utils/vecpod.h"
-#include "../utils/qsem.h"
-
 #include <array>
+#include <mutex>
+#include <condition_variable>
+
 #include "HandMadeMath.h"
 
 #include "utils/timer.h"
+#include "utils/vecpod.h"
+#include "utils/qsem.h"
 
 namespace o2::gpu
 {
@@ -44,7 +46,8 @@ class GPUDisplay : public GPUDisplayInterface
 
   int32_t StartDisplay() override;
   void ShowNextEvent(const GPUTrackingInOutPointers* ptrs = nullptr) override;
-  void WaitForNextEvent() override;
+  void BlockTillNextEvent() override;
+  void WaitTillEventShown() override;
   void SetCollisionFirstCluster(uint32_t collision, int32_t sector, int32_t cluster) override;
   void UpdateCalib(const GPUCalibObjectsConst* calib) override { mCalib = calib; }
   void UpdateParam(const GPUParam* param) override { mParam = param; }
@@ -221,7 +224,10 @@ class GPUDisplay : public GPUDisplayInterface
   GPUSettingsDisplayRenderer mCfgR;
   const GPUSettingsProcessing& mProcessingSettings;
   GPUQA* mQA;
+
   qSem mSemLockDisplay;
+  std::mutex mMutexLoadAndShowEvent;
+  std::condition_variable mCVLoadAndShowEvent;
 
   bool mDrawTextInCompatMode = false;
   int32_t mDrawTextFontSize = 0;
@@ -272,13 +278,14 @@ class GPUDisplay : public GPUDisplayInterface
   vecpod<int32_t> mTRDTrackIds;
   vecpod<bool> mITSStandaloneTracks;
   std::vector<bool> mTrackFilter;
-  bool mUpdateTrackFilter = false;
 
-  int32_t mUpdateVertexLists = 1;
-  int32_t mUpdateEventData = 0;
-  int32_t mUpdateDrawCommands = 1;
-  int32_t mUpdateRenderPipeline = 0;
-  volatile int32_t mResetScene = 0;
+  volatile bool mUpdateTrackFilter = false;
+  volatile bool mUpdateVertexLists = true;
+  volatile bool mUpdateEventData = false;
+  volatile bool mUpdateDrawCommands = true;
+  volatile bool mUpdateRenderPipeline = false;
+  volatile bool mResetScene = false;
+  volatile bool mLoadAndShowEvent = false;
 
   int32_t mAnimate = 0;
   HighResTimer mAnimationTimer;
diff --git a/GPU/GPUTracking/display/GPUDisplayInterface.h b/GPU/GPUTracking/display/GPUDisplayInterface.h
index 574a8cffc71f0..7caceb1699da6 100644
--- a/GPU/GPUTracking/display/GPUDisplayInterface.h
+++ b/GPU/GPUTracking/display/GPUDisplayInterface.h
@@ -40,7 +40,8 @@ class GPUDisplayInterface
   virtual ~GPUDisplayInterface();
   virtual int32_t StartDisplay() = 0;
   virtual void ShowNextEvent(const GPUTrackingInOutPointers* ptrs = nullptr) = 0;
-  virtual void WaitForNextEvent() = 0;
+  virtual void BlockTillNextEvent() = 0;
+  virtual void WaitTillEventShown() = 0;
   virtual void SetCollisionFirstCluster(uint32_t collision, int32_t sector, int32_t cluster) = 0;
   virtual void UpdateCalib(const GPUCalibObjectsConst* calib) = 0;
   virtual void UpdateParam(const GPUParam* param) = 0;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
index 54258857a244c..e1e6d9e54df0a 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
@@ -89,7 +89,7 @@ void GPUDisplay::HandleKey(uint8_t key)
     mFrontend->mDisplayControl = 2;
     SetInfo("Exiting", 1);
   } else if (key == 'r') {
-    mResetScene = 1;
+    mResetScene = true;
     SetInfo("View reset", 1);
   } else if (key == mFrontend->KEY_ALT && mFrontend->mKeysShift[mFrontend->KEY_ALT]) {
     mCfgR.camLookOrigin ^= 1;
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index cccf0f098bd8d..9410ee69fb5bd 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -944,7 +944,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
     break; // TODO: Only sector 0 filled for now
   }
 
-  mUpdateVertexLists = 0;
+  mUpdateVertexLists = false;
   size_t totalVertizes = 0;
   for (int32_t i = 0; i < NSECTORS; i++) {
     totalVertizes += mVertexBuffer[i].size();

From f47c6b7a684307874620a1e4d8dcee465ff1e00d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Jul 2025 10:01:55 +0200
Subject: [PATCH 0802/1764] GPU: Use [[maybe_unused]] to silence compiler
 warnings

---
 .../Global/GPUChainTrackingClusterizer.cxx        |  3 +--
 .../Global/GPUChainTrackingDebugAndProfiling.cxx  |  3 +--
 GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx  |  3 +--
 .../SectorTracker/GPUTPCTrackletConstructor.cxx   |  3 +--
 GPU/GPUTracking/display/render/GPUDisplayDraw.cxx |  4 +---
 GPU/GPUTracking/qa/GPUQA.cxx                      |  6 ++----
 GPU/GPUTracking/qa/GPUQAHelper.h                  |  4 ----
 GPU/GPUTracking/utils/qconfig.h                   | 15 +++++----------
 8 files changed, 12 insertions(+), 29 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index fd3699ae4d125..1fa2014fe47e7 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -591,7 +591,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     return ForwardTPCDigits();
   }
 #ifdef GPUCA_TPC_GEOMETRY_O2
-  int32_t tpcTimeBinCut = mUpdateNewCalibObjects && mNewCalibValues->newTPCTimeBinCut ? mNewCalibValues->tpcTimeBinCut : param().tpcCutTimeBin;
+  [[maybe_unused]] int32_t tpcTimeBinCut = mUpdateNewCalibObjects && mNewCalibValues->newTPCTimeBinCut ? mNewCalibValues->tpcTimeBinCut : param().tpcCutTimeBin;
   mRec->PushNonPersistentMemory(qStr2Tag("TPCCLUST"));
   const auto& threadContext = GetThreadContext();
   const bool doGPU = GetRecoStepsGPU() & RecoStep::TPCClusterFinding;
@@ -894,7 +894,6 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           int32_t firstHBF = (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasTfStartOrbit) ? mIOPtrs.settingsTF->tfStartOrbit : ((mIOPtrs.tpcZS->sector[iSector].count[0] && mIOPtrs.tpcZS->sector[iSector].nZSPtr[0][0]) ? o2::raw::RDHUtils::getHeartBeatOrbit(*(const o2::header::RAWDataHeader*)mIOPtrs.tpcZS->sector[iSector].zsPtr[0][0]) : 0);
           uint32_t nBlocks = doGPU ? clusterer.mPmemory->counters.nPagesSubsector : GPUTrackingInOutZS::NENDPOINTS;
 
-          (void)tpcTimeBinCut; // TODO: To be used in decoding kernels
           switch (mCFContext->zsVersion) {
             default:
               GPUFatal("Data with invalid TPC ZS mode (%d) received", mCFContext->zsVersion);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 173d2fb916239..7d790d8e3913f 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -70,7 +70,7 @@ int32_t GPUChainTracking::DoProfile()
   fwrite(&bmpFH, 1, sizeof(bmpFH), fp2);
   fwrite(&bmpIH, 1, sizeof(bmpIH), fp2);
 
-  int32_t nEmptySync = 0;
+  [[maybe_unused]] int32_t nEmptySync = 0;
   for (uint32_t i = 0; i < bmpheight * ConstructorBlockCount() * ConstructorThreadCount(); i += ConstructorBlockCount() * ConstructorThreadCount()) {
     int32_t fEmpty = 1;
     for (uint32_t j = 0; j < ConstructorBlockCount() * ConstructorThreadCount(); j++) {
@@ -103,7 +103,6 @@ int32_t GPUChainTracking::DoProfile()
     } else {
       nEmptySync = 0;
     }
-    (void)nEmptySync;
     // if (nEmptySync == GPUCA_SCHED_ROW_STEP + 2) break;
   }
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx b/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
index 5ca20a39d0462..eeabab6ed395f 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingRefit.cxx
@@ -28,8 +28,7 @@ int32_t GPUChainTracking::RunRefit()
   GPUTrackingRefitProcessor& Refit = processors()->trackingRefit;
   GPUTrackingRefitProcessor& RefitShadow = doGPU ? processorsShadow()->trackingRefit : Refit;
 
-  const auto& threadContext = GetThreadContext();
-  (void)threadContext;
+  [[maybe_unused]] const auto& threadContext = GetThreadContext();
   SetupGPUProcessor(&Refit, false);
   RefitShadow.SetPtrsFromGPUConstantMem(processorsShadow(), doGPU ? &processorsDevice()->param : nullptr);
   RefitShadow.SetPropagator(doGPU ? processorsShadow()->calibObjects.o2Propagator : GetO2Propagator());
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
index 2660f6d8cbf44..0b22bfa57c89e 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
@@ -274,7 +274,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
       }
       CADEBUG(printf("%14s: SEA PROP  ROW %3d X %8.3f -", "", iRow, tParam.X()); for (int32_t i = 0; i < 5; i++) { printf(" %8.3f", tParam.Par()[i]); } printf(" -"); for (int32_t i = 0; i < 15; i++) { printf(" %8.3f", tParam.Cov()[i]); } printf("\n"));
 
-      bool found = false;
+      [[maybe_unused]] bool found = false;
       float yUncorrected = tParam.GetY(), zUncorrected = tParam.GetZ();
       do {
         if (row.NHits() < 1) {
@@ -373,7 +373,6 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
           r.mFirstRow = iRow;
         }
       } while (false);
-      (void)found;
       if (!found && tracker.GetConstantMem()->calibObjects.dEdxCalibContainer) {
         uint32_t pad = CAMath::Float2UIntRn(GPUTPCGeometry::LinearY2Pad(tracker.ISector(), iRow, yUncorrected));
         if (pad < GPUTPCGeometry::NPads(iRow) && tracker.GetConstantMem()->calibObjects.dEdxCalibContainer->isDead(tracker.ISector(), iRow, pad)) {
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 9410ee69fb5bd..577d6cd906297 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -129,7 +129,7 @@ GPUDisplay::vboList GPUDisplay::DrawClusters(int32_t iSector, int32_t select, ui
   if (mOverlayTFClusters.size() > 0 || iCol == 0 || mNCollissions) {
     const int32_t firstCluster = (mOverlayTFClusters.size() > 1 && iCol > 0) ? mOverlayTFClusters[iCol - 1][iSector] : 0;
     const int32_t lastCluster = (mOverlayTFClusters.size() > 1 && iCol + 1 < mOverlayTFClusters.size()) ? mOverlayTFClusters[iCol][iSector] : (mParam->par.earlyTpcTransform ? mIOPtrs->nClusterData[iSector] : mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0);
-    const bool checkClusterCollision = mQA && mNCollissions && mOverlayTFClusters.size() == 0 && mIOPtrs->clustersNative && mIOPtrs->clustersNative->clustersMCTruth;
+    [[maybe_unused]] const bool checkClusterCollision = mQA && mNCollissions && mOverlayTFClusters.size() == 0 && mIOPtrs->clustersNative && mIOPtrs->clustersNative->clustersMCTruth;
     for (int32_t cidInSector = firstCluster; cidInSector < lastCluster; cidInSector++) {
       const int32_t cid = GET_CID(iSector, cidInSector);
 #ifdef GPUCA_TPC_GEOMETRY_O2
@@ -139,8 +139,6 @@ GPUDisplay::vboList GPUDisplay::DrawClusters(int32_t iSector, int32_t select, ui
           continue;
         }
       }
-#else
-      (void)checkClusterCollision;
 #endif
       if (mCfgH.hideUnmatchedClusters && mQA && mQA->SuppressHit(cid)) {
         continue;
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index c3028facc67a5..0466fed0250e1 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -99,7 +99,7 @@ using namespace o2::gpu;
   bool unattached = attach == 0;                                                                 \
   float qpt = 0;                                                                                 \
   bool lowPt = false;                                                                            \
-  bool mev200 = false;                                                                           \
+  [[maybe_unused]] bool mev200 = false;                                                          \
   bool mergedLooper = false;                                                                     \
   int32_t id = attach & gputpcgmmergertypes::attachTrackMask;                                    \
   if (!unattached) {                                                                             \
@@ -126,7 +126,6 @@ using namespace o2::gpu;
 
 #define CHECK_CLUSTER_STATE_NOCOUNT()                                             \
   CHECK_CLUSTER_STATE_INIT()                                                      \
-  (void)mev200; /* silence unused variable warning*/                              \
   if (!lowPt && !mergedLooper) {                                                  \
     GPUTPCClusterRejection::GetProtectionStatus<false>(attach, physics, protect); \
   }
@@ -1981,8 +1980,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
 
   std::vector<Color_t> colorNums(COLORCOUNT);
   if (!qcout) {
-    static int32_t initColorsInitialized = initColors();
-    (void)initColorsInitialized;
+    [[maybe_unused]] static int32_t initColorsInitialized = initColors();
   }
   for (int32_t i = 0; i < COLORCOUNT; i++) {
     colorNums[i] = qcout ? defaultColorNums[i] : mColors[i]->GetNumber();
diff --git a/GPU/GPUTracking/qa/GPUQAHelper.h b/GPU/GPUTracking/qa/GPUQAHelper.h
index a830562119467..e9d98f3e4e305 100644
--- a/GPU/GPUTracking/qa/GPUQAHelper.h
+++ b/GPU/GPUTracking/qa/GPUQAHelper.h
@@ -105,10 +105,6 @@ class GPUTPCTrkLbl
         *labelWeight = bestLabel.fWeight;
         *totalWeight = mTotalWeight;
         *maxCount = bestLabelCount;
-      } else {
-        (void)labelWeight;
-        (void)totalWeight;
-        (void)maxCount;
       }
       U retVal = bestLabel;
       if (bestLabelCount < (1.f - mTrackMCMaxFake) * mNCl) {
diff --git a/GPU/GPUTracking/utils/qconfig.h b/GPU/GPUTracking/utils/qconfig.h
index bc755e583c3b7..a809cc69be501 100644
--- a/GPU/GPUTracking/utils/qconfig.h
+++ b/GPU/GPUTracking/utils/qconfig.h
@@ -97,12 +97,9 @@ enum qConfigRetVal { qcrOK = 0,
 
 #define BeginSubConfig(name, instance, parent, preoptname, preoptnameshort, descr, ...) \
   {                                                                                     \
-    constexpr const char* preopt = preoptname;                                          \
-    (void)preopt;                                                                       \
-    constexpr const char preoptshort = preoptnameshort;                                 \
-    (void)preoptshort;                                                                  \
-    name& tmp = parent.instance;                                                        \
-    (void)tmp;                                                                          \
+    [[maybe_unused]] constexpr const char* preopt = preoptname;                         \
+    [[maybe_unused]] constexpr const char preoptshort = preoptnameshort;                \
+    [[maybe_unused]] name& tmp = parent.instance;                                       \
     bool tmpfound = true;                                                               \
     if (found) {                                                                        \
     }
@@ -174,10 +171,8 @@ enum qConfigRetVal { qcrOK = 0,
   const char* qon_mxcat(qConfig_subconfig_, name) = preoptnameshort == 0 ? (qon_mxstr(name) ": --" preoptname "\n\t\t" descr) : (qon_mxstr(name) ": -" qon_mxstr('a') " (--" preoptname ")\n\t\t" descr); \
   (void)qon_mxcat(qConfig_subconfig_, name);                                                                                                                                                              \
   if (subConfig == nullptr || strcmp(subConfig, followSub == 2 ? qon_mxstr(name) : preoptname) == 0) {                                                                                                    \
-    constexpr const char* preopt = preoptname;                                                                                                                                                            \
-    (void)preopt;                                                                                                                                                                                         \
-    constexpr const char preoptshort = preoptnameshort;                                                                                                                                                   \
-    (void)preoptshort;                                                                                                                                                                                    \
+    [[maybe_unused]] constexpr const char* preopt = preoptname;                                                                                                                                           \
+    [[maybe_unused]] constexpr const char preoptshort = preoptnameshort;                                                                                                                                  \
     char argBuffer[2] = {preoptnameshort, 0};                                                                                                                                                             \
     printf("\n  %s: (--%s%s%s)\n", descr, preoptname, preoptnameshort == 0 ? "" : " or -", argBuffer);
 #define BeginHiddenConfig(name, instance) {

From 2aa7c77507908be8c87705d346b416fdabbb701f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Jul 2025 10:02:15 +0200
Subject: [PATCH 0803/1764] GPU: Improve timing messages for GPU Display and
 GPU QA

---
 GPU/GPUTracking/display/GPUDisplay.cxx        | 15 ++++--
 GPU/GPUTracking/display/GPUDisplay.h          |  2 +-
 .../display/render/GPUDisplayDraw.cxx         | 53 ++++++++++++++++---
 .../display/render/GPUDisplayImportEvent.cxx  | 21 +++++++-
 GPU/GPUTracking/qa/GPUQA.cxx                  | 29 +++++-----
 GPU/GPUTracking/utils/timer.cxx               |  7 +++
 GPU/GPUTracking/utils/timer.h                 |  1 +
 7 files changed, 97 insertions(+), 31 deletions(-)

diff --git a/GPU/GPUTracking/display/GPUDisplay.cxx b/GPU/GPUTracking/display/GPUDisplay.cxx
index 163e4c0981bc2..e7c04a1bfb407 100644
--- a/GPU/GPUTracking/display/GPUDisplay.cxx
+++ b/GPU/GPUTracking/display/GPUDisplay.cxx
@@ -237,6 +237,7 @@ int32_t GPUDisplay::DrawGLScene()
 
 void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSlaveImage, hmm_mat4& nextViewMatrix)
 {
+  HighResTimer timer(mUpdateVertexLists && mChain->GetProcessingSettings().debugLevel >= 2);
   int32_t mMouseWheelTmp = mFrontend->mMouseWheel;
   mFrontend->mMouseWheel = 0;
   bool lookOrigin = mCfgR.camLookOrigin ^ mFrontend->mKeys[mFrontend->KEY_ALT];
@@ -420,6 +421,9 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSla
     mFrontend->mMouseDnX = mFrontend->mMouseMvX;
     mFrontend->mMouseDnY = mFrontend->mMouseMvY;
   }
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Camera:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
 }
 
 void GPUDisplay::DrawGLScene_drawCommands()
@@ -618,7 +622,6 @@ void GPUDisplay::DrawGLScene_drawCommands()
 
 void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer) // negative time = no mixing
 {
-  bool showTimer = false;
   bool doScreenshot = (mRequestScreenshot || mAnimateScreenshot) && animateTime < 0;
 
   updateOptions();
@@ -629,8 +632,9 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     mUpdateDrawCommands = true;
   }
 
+  HighResTimer timerDraw;
   if (animateTime < 0 && (mUpdateEventData || mResetScene) && mIOPtrs) {
-    showTimer = true;
+    timerDraw.ResetStart();
     DrawGLScene_updateEventData();
     mTimerFPS.ResetStart();
     mFramesDoneFPS = 0;
@@ -646,8 +650,8 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
   // Prepare Event
   if (mUpdateVertexLists && mIOPtrs) {
     size_t totalVertizes = DrawGLScene_updateVertexList();
-    if (showTimer) {
-      printf("Event visualization time: %'d us (vertices %'ld / %'ld bytes)\n", (int32_t)(mTimerDraw.GetCurrentElapsedTime() * 1000000.), (int64_t)totalVertizes, (int64_t)(totalVertizes * sizeof(mVertexBuffer[0][0])));
+    if (timerDraw.IsRunning()) {
+      printf("Event visualization time: %'d us (vertices %'ld / %'ld bytes)\n", (int32_t)(timerDraw.GetCurrentElapsedTime() * 1000000.), (int64_t)totalVertizes, (int64_t)(totalVertizes * sizeof(mVertexBuffer[0][0])));
     }
   }
 
@@ -668,7 +672,8 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     mBackend->drawField();
   }
 
-  mUpdateDrawCommands = mUpdateRenderPipeline = false;
+  mUpdateDrawCommands = false;
+  mUpdateRenderPipeline = false;
   mBackend->finishDraw(doScreenshot, renderToMixBuffer, mixSlaveImage);
 
   if (animateTime < 0) {
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index b59e3c52e9bd3..c8deeb2378970 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -310,7 +310,7 @@ class GPUDisplay : public GPUDisplayInterface
 
   float mFPSScale = 1, mFPSScaleadjust = 0;
   int32_t mFramesDone = 0, mFramesDoneFPS = 0;
-  HighResTimer mTimerFPS, mTimerDisplay, mTimerDraw;
+  HighResTimer mTimerFPS;
   vboList mGlDLLines[NSECTORS][N_LINES_TYPE];
   vecpod<std::array<vboList, N_FINAL_TYPE>> mGlDLFinal[NSECTORS];
   vboList mGlDLFinalITS;
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 577d6cd906297..06c572e516853 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -755,6 +755,7 @@ GPUDisplay::vboList GPUDisplay::DrawGridTRD(int32_t sector)
 
 size_t GPUDisplay::DrawGLScene_updateVertexList()
 {
+  HighResTimer timer(mChain->GetProcessingSettings().debugLevel >= 2);
   for (int32_t i = 0; i < NSECTORS; i++) {
     mVertexBuffer[i].clear();
     mVertexBufferStart[i].clear();
@@ -776,6 +777,10 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
       mGlDLFinal[iSector].resize(mNCollissions);
     }
   }
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Vertex Init:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
+
   int32_t numThreads = getNumThreads();
   tbb::task_arena(numThreads).execute([&] {
     if (mChain && (mChain->GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking)) {
@@ -785,6 +790,9 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
         mGlDLLines[iSector][tINITLINK] = DrawLinks(tracker, tINITLINK, true);
         tracker.SetPointersDataLinks(mChain->rec()->Res(tracker.MemoryResLinks()).Ptr()); // clang-format off
       }, tbb::simple_partitioner()); // clang-format on
+      if (timer.IsRunning()) {
+        GPUInfo("Display Time: Vertex Links:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+      }
 
       tbb::parallel_for(0, NSECTORS, [&](int32_t iSector) {
         const GPUTPCTracker& tracker = sectorTracker(iSector);
@@ -798,11 +806,17 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
           mGlDLGridTRD[iSector] = DrawGridTRD(iSector);
         } // clang-format off
       }, tbb::simple_partitioner()); // clang-format on
+      if (timer.IsRunning()) {
+        GPUInfo("Display Time: Vertex Seeds:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+      }
 
       tbb::parallel_for(0, NSECTORS, [&](int32_t iSector) {
         const GPUTPCTracker& tracker = sectorTracker(iSector);
         mGlDLLines[iSector][tEXTRAPOLATEDTRACK] = DrawTracks(tracker, 1); // clang-format off
       }, tbb::simple_partitioner()); // clang-format on
+      if (timer.IsRunning()) {
+        GPUInfo("Display Time: Vertex Sector Tracks:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+      }
     }
     tbb::parallel_for(0, numThreads, [&](int32_t iThread) {
       mThreadTracks[iThread].resize(mNCollissions);
@@ -875,6 +889,9 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
         mThreadTracks[GPUReconstruction::getHostThreadIndex()][col][sector][1].emplace_back(i);
       });
     }
+    if (timer.IsRunning()) {
+      GPUInfo("Display Time: Vertex Sort merged tracks:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+    }
 
     GPUTPCGMPropagator prop;
     prop.SetMaxSinPhi(.999);
@@ -903,6 +920,9 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
         }
       } // clang-format off
     }, tbb::simple_partitioner()); // clang-format on
+    if (timer.IsRunning()) {
+      GPUInfo("Display Time: Vertex Merged Tracks:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+    }
 
     tbb::parallel_for(0, NSECTORS, [&](int32_t iSector) {
       for (int32_t i = 0; i < N_POINTS_TYPE_TPC; i++) {
@@ -911,36 +931,49 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
         }
       } // clang-format off
     }, tbb::simple_partitioner()); // clang-format on
+    if (timer.IsRunning()) {
+      GPUInfo("Display Time: Vertex Clusters:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+    }
+
   });
   // End omp parallel
 
   mGlDLFinalITS = DrawFinalITS();
-
   for (int32_t iSector = 0; iSector < NSECTORS; iSector++) {
-    for (int32_t i = N_POINTS_TYPE_TPC; i < N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD; i++) {
+    for (int32_t i = N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD + N_POINTS_TYPE_TOF; i < N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD + N_POINTS_TYPE_TOF + N_POINTS_TYPE_ITS; i++) {
       for (int32_t iCol = 0; iCol < mNCollissions; iCol++) {
-        mGlDLPoints[iSector][i][iCol] = DrawSpacePointsTRD(iSector, i, iCol);
+        mGlDLPoints[iSector][i][iCol] = DrawSpacePointsITS(iSector, i, iCol);
       }
     }
+    break; // TODO: Only sector 0 filled for now
+  }
+
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Vertex ITS:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
   }
 
   for (int32_t iSector = 0; iSector < NSECTORS; iSector++) {
-    for (int32_t i = N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD; i < N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD + N_POINTS_TYPE_TOF; i++) {
+    for (int32_t i = N_POINTS_TYPE_TPC; i < N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD; i++) {
       for (int32_t iCol = 0; iCol < mNCollissions; iCol++) {
-        mGlDLPoints[iSector][i][iCol] = DrawSpacePointsTOF(iSector, i, iCol);
+        mGlDLPoints[iSector][i][iCol] = DrawSpacePointsTRD(iSector, i, iCol);
       }
     }
-    break; // TODO: Only sector 0 filled for now
+  }
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Vertex TRD:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
   }
 
   for (int32_t iSector = 0; iSector < NSECTORS; iSector++) {
-    for (int32_t i = N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD + N_POINTS_TYPE_TOF; i < N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD + N_POINTS_TYPE_TOF + N_POINTS_TYPE_ITS; i++) {
+    for (int32_t i = N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD; i < N_POINTS_TYPE_TPC + N_POINTS_TYPE_TRD + N_POINTS_TYPE_TOF; i++) {
       for (int32_t iCol = 0; iCol < mNCollissions; iCol++) {
-        mGlDLPoints[iSector][i][iCol] = DrawSpacePointsITS(iSector, i, iCol);
+        mGlDLPoints[iSector][i][iCol] = DrawSpacePointsTOF(iSector, i, iCol);
       }
     }
     break; // TODO: Only sector 0 filled for now
   }
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Vertex TOF:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
 
   mUpdateVertexLists = false;
   size_t totalVertizes = 0;
@@ -968,5 +1001,9 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
   for (int32_t i = 0; i < (mUseMultiVBO ? GPUCA_NSECTORS : 1); i++) {
     mVertexBuffer[i].clear();
   }
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Vertex Final:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
+
   return totalVertizes;
 }
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index ab4c0abd7b60e..df3b385c14fe5 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -23,6 +23,7 @@
 #include "GPUTPCConvertImpl.h"
 #include "GPUTRDGeometry.h"
 #include "GPUTRDTrackletWord.h"
+#include "GPUChainTracking.h"
 #include "GPUParam.inc"
 
 #include "DataFormatsTOF/Cluster.h"
@@ -40,7 +41,7 @@ using namespace o2::gpu;
 
 void GPUDisplay::DrawGLScene_updateEventData()
 {
-  mTimerDraw.ResetStart();
+  HighResTimer timer(mChain->GetProcessingSettings().debugLevel >= 2);
   if (mIOPtrs->clustersNative) {
     mCurrentClusters = mIOPtrs->clustersNative->nClustersTotal;
   } else {
@@ -110,6 +111,9 @@ void GPUDisplay::DrawGLScene_updateEventData()
       }
     }
   }
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Init:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
 
   if (mCfgH.trackFilter) {
     uint32_t nTracks = mConfig.showTPCTracksFromO2Format ? mIOPtrs->nOutputTracksTPCO2 : mIOPtrs->nMergedTracks;
@@ -128,6 +132,9 @@ void GPUDisplay::DrawGLScene_updateEventData()
     }
   }
   mUpdateTrackFilter = false;
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Track Filter:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
 
   mMaxClusterZ = tbb::parallel_reduce(tbb::blocked_range<int32_t>(0, NSECTORS, 1), float(0.f), [&](const tbb::blocked_range<int32_t>& r, float maxClusterZ) {
     for (int32_t iSector = r.begin(); iSector < r.end(); iSector++) {
@@ -174,6 +181,9 @@ void GPUDisplay::DrawGLScene_updateEventData()
     }
     return maxClusterZ; // clang-format off
   }, [](const float a, const float b) { return std::max(a, b); }, tbb::simple_partitioner()); // clang-format on
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Load TPC:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
 
   mMaxClusterZ = tbb::parallel_reduce(tbb::blocked_range<int32_t>(0, mCurrentSpacePointsTRD, 32), float(mMaxClusterZ), [&](const tbb::blocked_range<int32_t>& r, float maxClusterZ) {
     int32_t trdTriggerRecord = -1;
@@ -209,6 +219,9 @@ void GPUDisplay::DrawGLScene_updateEventData()
     }
     return maxClusterZ; // clang-format off
   }, [](const float a, const float b) { return std::max(a, b); }, tbb::static_partitioner()); // clang-format on
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Load TRD:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
 
   mMaxClusterZ = tbb::parallel_reduce(tbb::blocked_range<int32_t>(0, mCurrentClustersTOF, 32), float(mMaxClusterZ), [&](const tbb::blocked_range<int32_t>& r, float maxClusterZ) {
     for (int32_t i = r.begin(); i < r.end(); i++) {
@@ -230,6 +243,9 @@ void GPUDisplay::DrawGLScene_updateEventData()
     }
     return maxClusterZ; // clang-format off
   }, [](const float a, const float b) { return std::max(a, b); }); // clang-format on
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Load TOF:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
 
   if (mCurrentClustersITS) {
     float itsROFhalfLen = 0;
@@ -270,4 +286,7 @@ void GPUDisplay::DrawGLScene_updateEventData()
       }
     }
   }
+  if (timer.IsRunning()) {
+    GPUInfo("Display Time: Load ITS:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
+  }
 }
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 0466fed0250e1..d542e39c55b52 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -663,10 +663,9 @@ void GPUQA::InitO2MCData(GPUTrackingInOutPointers* updateIOPtr)
 {
 #ifdef GPUCA_O2_LIB
   if (!mO2MCDataLoaded) {
-    HighResTimer timer;
+    HighResTimer timer(mTracking && mTracking->GetProcessingSettings().debugLevel);
     if (mTracking && mTracking->GetProcessingSettings().debugLevel) {
       GPUInfo("Start reading O2 Track MC information");
-      timer.Start();
     }
     static constexpr float PRIM_MAX_T = 0.01f;
 
@@ -776,7 +775,7 @@ void GPUQA::InitO2MCData(GPUTrackingInOutPointers* updateIOPtr)
         }
       }
     }
-    if (mTracking && mTracking->GetProcessingSettings().debugLevel) {
+    if (timer.IsRunning()) {
       GPUInfo("Finished reading O2 Track MC information (%f seconds)", timer.GetCurrentElapsedTime());
     }
     mO2MCDataLoaded = true;
@@ -922,7 +921,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     mClusterParam.resize(GetNMCLabels());
     memset(mClusterParam.data(), 0, mClusterParam.size() * sizeof(mClusterParam[0]));
   }
-  HighResTimer timer;
+  HighResTimer timer(QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 2));
 
   mNEvents++;
   if (mConfig.writeMCLabels) {
@@ -934,9 +933,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
 
   bool mcAvail = mcPresent() || tracksExtMC;
 
-  if (mcAvail) {
-    // Assign Track MC Labels
-    timer.Start();
+  if (mcAvail) { // Assign Track MC Labels
     if (tracksExternal) {
 #ifdef GPUCA_O2_LIB
       for (uint32_t i = 0; i < tracksExternal->size(); i++) {
@@ -987,7 +984,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       });
     }
-    if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+    if (timer.IsRunning()) {
       GPUInfo("QA Time: Assign Track Labels:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
     }
 
@@ -1127,7 +1124,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
     }
-    if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+    if (timer.IsRunning()) {
       GPUInfo("QA Time: Cluster attach status:\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
     }
 
@@ -1154,7 +1151,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
     }
-    if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+    if (timer.IsRunning()) {
       GPUInfo("QA Time: Compute cluster label weights:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
     }
 
@@ -1178,7 +1175,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       } // clang-format off
     }, tbb::simple_partitioner()); // clang-format on
-    if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+    if (timer.IsRunning()) {
       GPUInfo("QA Time: Compute track mc parameters:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
     }
 
@@ -1268,7 +1265,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           }
         }
       }
-      if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+      if (timer.IsRunning()) {
         GPUInfo("QA Time: Fill efficiency histograms:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
       }
     }
@@ -1444,7 +1441,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           }
         }
       }
-      if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+      if (timer.IsRunning()) {
         GPUInfo("QA Time: Fill resolution histograms:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
       }
     }
@@ -1671,7 +1668,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
 
-      if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+      if (timer.IsRunning()) {
         GPUInfo("QA Time: Fill cluster histograms:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
       }
     }
@@ -1765,7 +1762,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       clusterAttachCounts.clear();
     }
 
-    if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+    if (timer.IsRunning()) {
       GPUInfo("QA Time: Fill track statistics:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
     }
   }
@@ -1838,7 +1835,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     mClusterCounts = counts_t();
   }
 
-  if (QA_TIMING || (mTracking && mTracking->GetProcessingSettings().debugLevel >= 3)) {
+  if (timer.IsRunning()) {
     GPUInfo("QA Time: Cluster Counts:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
   }
 
diff --git a/GPU/GPUTracking/utils/timer.cxx b/GPU/GPUTracking/utils/timer.cxx
index f3b108fc6f159..df3790ad9ccbf 100644
--- a/GPU/GPUTracking/utils/timer.cxx
+++ b/GPU/GPUTracking/utils/timer.cxx
@@ -23,6 +23,13 @@
 #include <ctime>
 #endif
 
+HighResTimer::HighResTimer(bool start)
+{
+  if (start) {
+    ResetStart();
+  }
+}
+
 inline double HighResTimer::GetTime()
 {
 #ifdef _WIN32
diff --git a/GPU/GPUTracking/utils/timer.h b/GPU/GPUTracking/utils/timer.h
index 44a01b04747cb..35b1d707b97b0 100644
--- a/GPU/GPUTracking/utils/timer.h
+++ b/GPU/GPUTracking/utils/timer.h
@@ -21,6 +21,7 @@ class HighResTimer
 {
  public:
   HighResTimer() = default;
+  HighResTimer(bool start);
   ~HighResTimer() = default;
   void Start();
   void Stop();

From 8fffdd7e98431f70f58cea4aa8f9f43910f53c0f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Jul 2025 10:50:58 +0200
Subject: [PATCH 0804/1764] GPU Display: Speed up drawing clusters with many
 collisions

---
 GPU/GPUTracking/display/GPUDisplay.h          |   3 +-
 .../display/render/GPUDisplayDraw.cxx         | 135 ++++++++++--------
 2 files changed, 78 insertions(+), 60 deletions(-)

diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index c8deeb2378970..1cdbf62da2202 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -193,7 +193,7 @@ class GPUDisplay : public GPUDisplayInterface
   void SetCollisionColor(int32_t col);
   void updateConfig();
   void drawPointLinestrip(int32_t iSector, int32_t cid, int32_t id, int32_t id_limit = TRACK_TYPE_ID_LIMIT);
-  vboList DrawClusters(int32_t iSector, int32_t select, uint32_t iCol);
+  void DrawClusters(int32_t iSector);
   vboList DrawSpacePointsTRD(int32_t iSector, int32_t select, int32_t iCol);
   vboList DrawSpacePointsTOF(int32_t iSector, int32_t select, int32_t iCol);
   vboList DrawSpacePointsITS(int32_t iSector, int32_t select, int32_t iCol);
@@ -256,6 +256,7 @@ class GPUDisplay : public GPUDisplayInterface
   vecpod<vtx> mVertexBuffer[NSECTORS];
   vecpod<int32_t> mVertexBufferStart[NSECTORS];
   vecpod<uint32_t> mVertexBufferCount[NSECTORS];
+  std::vector<std::array<uint32_t, N_POINTS_TYPE_TPC>> mClusterBufferSizeCache[NSECTORS];
 
   std::unique_ptr<float4[]> mGlobalPosPtr;
   std::unique_ptr<float4[]> mGlobalPosPtrTRD;
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 06c572e516853..9ed16f10361f5 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -122,70 +122,91 @@ GPUDisplay::vboList GPUDisplay::DrawSpacePointsITS(int32_t iSector, int32_t sele
   return (vboList(startCount, mVertexBufferStart[iSector].size() - startCount, iSector));
 }
 
-GPUDisplay::vboList GPUDisplay::DrawClusters(int32_t iSector, int32_t select, uint32_t iCol)
+void GPUDisplay::DrawClusters(int32_t iSector)
 {
-  size_t startCount = mVertexBufferStart[iSector].size();
-  size_t startCountInner = mVertexBuffer[iSector].size();
-  if (mOverlayTFClusters.size() > 0 || iCol == 0 || mNCollissions) {
-    const int32_t firstCluster = (mOverlayTFClusters.size() > 1 && iCol > 0) ? mOverlayTFClusters[iCol - 1][iSector] : 0;
-    const int32_t lastCluster = (mOverlayTFClusters.size() > 1 && iCol + 1 < mOverlayTFClusters.size()) ? mOverlayTFClusters[iCol][iSector] : (mParam->par.earlyTpcTransform ? mIOPtrs->nClusterData[iSector] : mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0);
-    [[maybe_unused]] const bool checkClusterCollision = mQA && mNCollissions && mOverlayTFClusters.size() == 0 && mIOPtrs->clustersNative && mIOPtrs->clustersNative->clustersMCTruth;
-    for (int32_t cidInSector = firstCluster; cidInSector < lastCluster; cidInSector++) {
-      const int32_t cid = GET_CID(iSector, cidInSector);
+  std::vector<std::array<vecpod<vtx>, N_POINTS_TYPE_TPC>> vertexCache(mNCollissions);
+  if (mClusterBufferSizeCache[iSector].size() < (uint32_t)mNCollissions) {
+    mClusterBufferSizeCache[iSector].resize(mNCollissions);
+  }
+  for (int32_t iCol = 0; iCol < mNCollissions; iCol++) {
+    for (int32_t i = 0; i < N_POINTS_TYPE_TPC; i++) {
+      vertexCache[iCol][i].reserve(mClusterBufferSizeCache[iSector][iCol][i]);
+    }
+  }
+
+  uint32_t col = 0;
+  const int32_t nClustersInSector = mParam->par.earlyTpcTransform ? mIOPtrs->nClusterData[iSector] : (mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0);
+  [[maybe_unused]] const bool checkClusterCollision = mQA && mNCollissions && mOverlayTFClusters.size() == 0 && mIOPtrs->clustersNative && mIOPtrs->clustersNative->clustersMCTruth;
+  for (int32_t cidInSector = 0; cidInSector < nClustersInSector; cidInSector++) {
+    const int32_t cid = GET_CID(iSector, cidInSector);
 #ifdef GPUCA_TPC_GEOMETRY_O2
-      if (checkClusterCollision) {
-        const auto& labels = mIOPtrs->clustersNative->clustersMCTruth->getLabels(cid);
-        if (labels.size() ? (iCol != mQA->GetMCLabelCol(labels[0])) : (iCol != 0)) {
-          continue;
-        }
-      }
+    if (checkClusterCollision) {
+      const auto& labels = mIOPtrs->clustersNative->clustersMCTruth->getLabels(cid);
+      col = labels.size() ? mQA->GetMCLabelCol(labels[0]) : 0;
+    } else
 #endif
-      if (mCfgH.hideUnmatchedClusters && mQA && mQA->SuppressHit(cid)) {
-        continue;
+      if (mOverlayTFClusters.size()) {
+      while (col < mOverlayTFClusters.size() && cidInSector >= mOverlayTFClusters[col][iSector]) {
+        col++;
       }
-      bool draw = mGlobalPos[cid].w == select;
-
-      if (mCfgH.markAdjacentClusters) {
-        const int32_t attach = mIOPtrs->mergedTrackHitAttachment[cid];
-        if (attach) {
-          if (mCfgH.markAdjacentClusters >= 32) {
-            if (mQA && mQA->clusterRemovable(attach, mCfgH.markAdjacentClusters == 33)) {
-              draw = select == tMARKED;
-            }
-          } else if ((mCfgH.markAdjacentClusters & 2) && (attach & gputpcgmmergertypes::attachTube)) {
-            draw = select == tMARKED;
-          } else if ((mCfgH.markAdjacentClusters & 1) && (attach & (gputpcgmmergertypes::attachGood | gputpcgmmergertypes::attachTube)) == 0) {
-            draw = select == tMARKED;
-          } else if ((mCfgH.markAdjacentClusters & 4) && (attach & gputpcgmmergertypes::attachGoodLeg) == 0) {
-            draw = select == tMARKED;
-          } else if ((mCfgH.markAdjacentClusters & 16) && (attach & gputpcgmmergertypes::attachHighIncl)) {
-            draw = select == tMARKED;
-          } else if (mCfgH.markAdjacentClusters & 8) {
-            if (fabsf(mIOPtrs->mergedTracks[attach & gputpcgmmergertypes::attachTrackMask].GetParam().GetQPt()) > 20.f) {
-              draw = select == tMARKED;
-            }
+    }
+    if (mCfgH.hideUnmatchedClusters && mQA && mQA->SuppressHit(cid)) {
+      continue;
+    }
+    int32_t select = mGlobalPos[cid].w;
+
+    if (mCfgH.markAdjacentClusters) {
+      const int32_t attach = mIOPtrs->mergedTrackHitAttachment[cid];
+      if (attach) {
+        if (mCfgH.markAdjacentClusters >= 32) {
+          if (mQA && mQA->clusterRemovable(attach, mCfgH.markAdjacentClusters == 33)) {
+            select = tMARKED;
+          }
+        } else if ((mCfgH.markAdjacentClusters & 2) && (attach & gputpcgmmergertypes::attachTube)) {
+          select = tMARKED;
+        } else if ((mCfgH.markAdjacentClusters & 1) && (attach & (gputpcgmmergertypes::attachGood | gputpcgmmergertypes::attachTube)) == 0) {
+          select = tMARKED;
+        } else if ((mCfgH.markAdjacentClusters & 4) && (attach & gputpcgmmergertypes::attachGoodLeg) == 0) {
+          select = tMARKED;
+        } else if ((mCfgH.markAdjacentClusters & 16) && (attach & gputpcgmmergertypes::attachHighIncl)) {
+          select = tMARKED;
+        } else if (mCfgH.markAdjacentClusters & 8) {
+          if (fabsf(mIOPtrs->mergedTracks[attach & gputpcgmmergertypes::attachTrackMask].GetParam().GetQPt()) > 20.f) {
+            select = tMARKED;
           }
         }
-      } else if (mCfgH.markClusters) {
-        int16_t flags;
-        if (mParam->par.earlyTpcTransform) {
-          flags = mIOPtrs->clusterData[iSector][cidInSector].flags;
-        } else {
-          flags = mIOPtrs->clustersNative->clustersLinear[cid].getFlags();
-        }
-        const bool match = flags & mCfgH.markClusters;
-        draw = (select == tMARKED) ? (match) : (draw && !match);
-      } else if (mCfgH.markFakeClusters) {
-        const bool fake = (mQA->HitAttachStatus(cid));
-        draw = (select == tMARKED) ? (fake) : (draw && !fake);
       }
-      if (draw) {
-        mVertexBuffer[iSector].emplace_back(mGlobalPos[cid].x, mGlobalPos[cid].y * mYFactor, mCfgH.projectXY ? 0 : mGlobalPos[cid].z);
+    } else if (mCfgH.markClusters) {
+      int16_t flags;
+      if (mParam->par.earlyTpcTransform) {
+        flags = mIOPtrs->clusterData[iSector][cidInSector].flags;
+      } else {
+        flags = mIOPtrs->clustersNative->clustersLinear[cid].getFlags();
+      }
+      if (flags & mCfgH.markClusters) {
+        select = tMARKED;
+      }
+    } else if (mCfgH.markFakeClusters) {
+      if (mQA->HitAttachStatus(cid)) {
+        select = tMARKED;
       }
     }
+    vertexCache[col][select].emplace_back(mGlobalPos[cid].x, mGlobalPos[cid].y * mYFactor, mCfgH.projectXY ? 0 : mGlobalPos[cid].z);
+  }
+
+  size_t startCountInner = mVertexBuffer[iSector].size();
+  mVertexBuffer[iSector].resize(mVertexBuffer[iSector].size() + nClustersInSector);
+  for (int32_t iCol = 0; iCol < mNCollissions; iCol++) {
+    for (int32_t i = 0; i < N_POINTS_TYPE_TPC; i++) {
+      uint32_t count = vertexCache[iCol][i].size();
+      mClusterBufferSizeCache[iSector][iCol][i] = std::max(mClusterBufferSizeCache[iSector][iCol][i], count);
+      memcpy((void*)&mVertexBuffer[iSector][startCountInner], (const void*)vertexCache[iCol][i].data(), count * sizeof(vertexCache[iCol][i][0]));
+      size_t startCount = mVertexBufferStart[iSector].size();
+      insertVertexList(iSector, startCountInner, startCountInner + count);
+      startCountInner += count;
+      mGlDLPoints[iSector][i][iCol] = vboList(startCount, mVertexBufferStart[iSector].size() - startCount, iSector);
+    }
   }
-  insertVertexList(iSector, startCountInner, mVertexBuffer[iSector].size());
-  return (vboList(startCount, mVertexBufferStart[iSector].size() - startCount, iSector));
 }
 
 GPUDisplay::vboList GPUDisplay::DrawLinks(const GPUTPCTracker& tracker, int32_t id, bool dodown)
@@ -925,11 +946,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
     }
 
     tbb::parallel_for(0, NSECTORS, [&](int32_t iSector) {
-      for (int32_t i = 0; i < N_POINTS_TYPE_TPC; i++) {
-        for (int32_t iCol = 0; iCol < mNCollissions; iCol++) {
-          mGlDLPoints[iSector][i][iCol] = DrawClusters(iSector, i, iCol);
-        }
-      } // clang-format off
+      DrawClusters(iSector); // clang-format off
     }, tbb::simple_partitioner()); // clang-format on
     if (timer.IsRunning()) {
       GPUInfo("Display Time: Vertex Clusters:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);

From cf749eb33aa4707479466507a961a42bf41d997a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Jul 2025 10:54:41 +0200
Subject: [PATCH 0805/1764] GPU Display: ResetScene should reset which
 collision to show

---
 GPU/GPUTracking/display/GPUDisplay.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/display/GPUDisplay.cxx b/GPU/GPUTracking/display/GPUDisplay.cxx
index e7c04a1bfb407..35ebb132398ab 100644
--- a/GPU/GPUTracking/display/GPUDisplay.cxx
+++ b/GPU/GPUTracking/display/GPUDisplay.cxx
@@ -273,6 +273,7 @@ void GPUDisplay::DrawGLScene_cameraAndAnimation(float animateTime, float& mixSla
     mCfgL.pointSize = 2.0f;
     mCfgL.lineWidth = 1.4f;
     mCfgL.drawSector = -1;
+    mCfgL.showCollision = -1;
     mCfgH.xAdd = mCfgH.zAdd = 0;
     mCfgR.camLookOrigin = mCfgR.camYUp = false;
     mAngleRollOrigin = -1e9f;

From b181f34cae0e5656a6f4abd6a32d737358a6ba5f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Jul 2025 11:11:27 +0200
Subject: [PATCH 0806/1764] GPU Display: Extrapolate tracks only on-demand when
 first requested

---
 GPU/GPUTracking/display/GPUDisplay.cxx              | 2 +-
 GPU/GPUTracking/display/GPUDisplay.h                | 1 +
 GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx | 3 +++
 GPU/GPUTracking/display/render/GPUDisplayDraw.cxx   | 4 ++++
 4 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/display/GPUDisplay.cxx b/GPU/GPUTracking/display/GPUDisplay.cxx
index 35ebb132398ab..7cad25916940a 100644
--- a/GPU/GPUTracking/display/GPUDisplay.cxx
+++ b/GPU/GPUTracking/display/GPUDisplay.cxx
@@ -633,7 +633,7 @@ void GPUDisplay::DrawGLScene_internal(float animateTime, bool renderToMixBuffer)
     mUpdateDrawCommands = true;
   }
 
-  HighResTimer timerDraw;
+  HighResTimer timerDraw(mUpdateVertexLists);
   if (animateTime < 0 && (mUpdateEventData || mResetScene) && mIOPtrs) {
     timerDraw.ResetStart();
     DrawGLScene_updateEventData();
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index 1cdbf62da2202..7279f2ee87fdb 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -287,6 +287,7 @@ class GPUDisplay : public GPUDisplayInterface
   volatile bool mUpdateRenderPipeline = false;
   volatile bool mResetScene = false;
   volatile bool mLoadAndShowEvent = false;
+  bool mTracksArePropagated = false;
 
   int32_t mAnimate = 0;
   HighResTimer mAnimationTimer;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
index e1e6d9e54df0a..6dc09545733fe 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayKeys.cxx
@@ -493,6 +493,9 @@ void GPUDisplay::HandleKey(uint8_t key)
   if (memcmp((void*)&oldCfgH, (void*)&mCfgH, sizeof(mCfgH)) != 0) {
     mUpdateEventData = true;
   }
+  if (mCfgL.propagateTracks != 0 && !mTracksArePropagated) {
+    mUpdateVertexLists = true;
+  }
   if (memcmp((void*)&oldCfgL, (void*)&mCfgL, sizeof(mCfgL)) != 0 || memcmp((void*)&oldCfgR, (void*)&mCfgR, sizeof(mCfgR)) != 0) {
     mUpdateDrawCommands = true;
   }
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 9ed16f10361f5..ebb1b41802ba0 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -494,6 +494,9 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
     if (!mIOPtrs->clustersNative) {
       continue;
     }
+    if (mCfgL.propagateTracks == 0) {
+      continue;
+    }
 
     // Propagate track paramters / plot MC tracks
     for (int32_t iMC = 0; iMC < 2; iMC++) {
@@ -992,6 +995,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
     GPUInfo("Display Time: Vertex TOF:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
   }
 
+  mTracksArePropagated = mCfgL.propagateTracks != 0;
   mUpdateVertexLists = false;
   size_t totalVertizes = 0;
   for (int32_t i = 0; i < NSECTORS; i++) {

From 26ba4abda081cbbd27176f5848518dc8feb8c604 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Jul 2025 11:34:16 +0200
Subject: [PATCH 0807/1764] TPC: Change some default settings

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 6419d63bb7ada..4bdca9b62c462 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -132,11 +132,11 @@ AddOptionRTC(cfInnerThreshold, uint8_t, 0, "", 0, "Cluster Finder extends cluste
 AddOptionRTC(cfMinSplitNum, uint8_t, 1, "", 0, "Minimum number of split charges in a cluster for the cluster to be marked as split")
 AddOptionRTC(cfNoiseSuppressionEpsilon, uint8_t, 10, "", 0, "Cluster Finder: Difference between peak and charge for the charge to count as a minima during noise suppression")
 AddOptionRTC(cfNoiseSuppressionEpsilonRelative, uint8_t, 76, "", 0, "Cluster Finder: Difference between peak and charge for the charge to count as a minima during noise suppression, relative as fraction of 255")
-AddOptionRTC(cfEdgeTwoPads, uint8_t, 1, "", 0, "Flag clusters with peak on the 2 pads closes to the sector edge as edge cluster")
+AddOptionRTC(cfEdgeTwoPads, uint8_t, 0, "", 0, "Flag clusters with peak on the 2 pads closes to the sector edge as edge cluster")
 AddOptionRTC(nWays, uint8_t, 3, "", 0, "Do N fit passes in final fit of merger")
 AddOptionRTC(nWaysOuter, int8_t, 0, "", 0, "Store outer param")
 AddOptionRTC(trackFitRejectMode, int8_t, 5, "", 0, "0: no limit on rejection or missed hits, >0: break after n rejected hits, <0: reject at max -n hits")
-AddOptionRTC(rejectIFCLowRadiusCluster, uint8_t, 0, "", 0, "Reject clusters that get the IFC mask error during refit")
+AddOptionRTC(rejectIFCLowRadiusCluster, uint8_t, 1, "", 0, "Reject clusters that get the IFC mask error during refit")
 AddOptionRTC(dEdxTruncLow, uint8_t, 2, "", 0, "Low truncation threshold, fraction of 128")
 AddOptionRTC(dEdxTruncHigh, uint8_t, 77, "", 0, "High truncation threshold, fraction of 128")
 AddOptionRTC(extrapolationTracking, int8_t, 1, "", 0, "Enable Extrapolation Tracking (prolong tracks to adjacent sectors to find short segments)")

From 0e9df6ce4f047bad409fceb232650a30b0865145 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 22 Jul 2025 11:56:53 +0200
Subject: [PATCH 0808/1764] GPU TPC: Do looper cluster attachment always in
 separate kernel

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  3 -
 .../Definitions/GPUDefParametersDefaults.h    | 10 ----
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 -
 .../Global/GPUChainTrackingMerger.cxx         |  4 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 57 +++----------------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |  6 +-
 .../Standalone/Benchmark/standalone.cxx       |  1 -
 GPU/GPUTracking/kernels.cmake                 |  1 -
 8 files changed, 12 insertions(+), 71 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 09aae2aacf16d..ff4ce2c905507 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -271,9 +271,6 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
 #endif
     mProcessingSettings->overrideClusterizerFragmentLen = TPC_MAX_FRAGMENT_LEN_GPU;
     param().rec.tpc.nWaysOuter = true;
-    if (param().rec.tpc.looperInterpolationInExtraPass == -1) {
-      param().rec.tpc.looperInterpolationInExtraPass = 0;
-    }
     if (GetProcessingSettings().createO2Output > 1) {
       mProcessingSettings->createO2Output = 1;
     }
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 48d00b274dc9c..b1f12034d9c2f 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -80,7 +80,6 @@
     #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
     #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
     #define GPUCA_PAR_SORT_BEFORE_FIT 1
-    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 1
     #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
     #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
     #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
@@ -143,7 +142,6 @@
     #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
     #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
     #define GPUCA_PAR_SORT_BEFORE_FIT 1
-    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 1
     #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
     #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
     #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
@@ -206,7 +204,6 @@
     #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
     #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
     #define GPUCA_PAR_SORT_BEFORE_FIT 1
-    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 1
     #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
     #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
     #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
@@ -261,7 +258,6 @@
     #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
     #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
     #define GPUCA_PAR_SORT_BEFORE_FIT 1
-    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 1
     #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
     #define GPUCA_PAR_COMP_GATHER_KERNEL 4
     #define GPUCA_PAR_COMP_GATHER_MODE 3
@@ -529,9 +525,6 @@
   #ifndef GPUCA_PAR_SORT_BEFORE_FIT
     #define GPUCA_PAR_SORT_BEFORE_FIT 0
   #endif
-  #ifndef GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION
-    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 0
-  #endif
   #ifndef GPUCA_PAR_COMP_GATHER_KERNEL
     #define GPUCA_PAR_COMP_GATHER_KERNEL 0
   #endif
@@ -566,9 +559,6 @@
   #ifndef GPUCA_PAR_SORT_BEFORE_FIT
     #define GPUCA_PAR_SORT_BEFORE_FIT 0
   #endif
-  #ifndef GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION
-    #define GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION 0
-  #endif
   #ifndef GPUCA_PAR_COMP_GATHER_KERNEL
     #define GPUCA_PAR_COMP_GATHER_KERNEL 0
   #endif
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 4bdca9b62c462..a22524713c5c0 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -154,7 +154,6 @@ AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation inst
 AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position")
 AddOptionRTC(mergeCE, uint8_t, 1, "", 0, "Merge tracks accross the central electrode")
 AddOptionRTC(retryRefit, int8_t, 1, "", 0, "Retry refit with seeding errors and without cluster rejection when fit fails (=2 means retry in same kernel, =1 for separate kernel")
-AddOptionRTC(looperInterpolationInExtraPass, int8_t, -1, "", 0, "Perform looper interpolation in an extra pass")
 AddOptionRTC(dropSecondaryLegsInOutput, int8_t, 1, "", 0, "Do not store secondary legs of looping track in TrackTPC")
 AddOptionRTC(enablePID, int8_t, 1, "", 0, "Enable PID response")
 AddOptionRTC(PID_useNsigma, int8_t, 1, "", 0, "Use nSigma instead of absolute distance in PID response")
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 118f0bf73a845..5d3ac212c5b54 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -224,9 +224,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   if (param().rec.tpc.retryRefit == 1) {
     runKernel<GPUTPCGMMergerTrackFit>(GetGridAuto(0), -1);
   }
-  if (param().rec.tpc.looperInterpolationInExtraPass == -1 ? mRec->getGPUParameters(doGPU).par_MERGER_SPLIT_LOOP_INTERPOLATION : param().rec.tpc.looperInterpolationInExtraPass) {
-    runKernel<GPUTPCGMMergerFollowLoopers>(GetGridAuto(0));
-  }
+  runKernel<GPUTPCGMMergerFollowLoopers>(GetGridAuto(0));
 
   DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRefit, Merger, &GPUTPCGMMerger::DumpRefit, *mDebugFile);
   runKernel<GPUTPCGMMergerFinalize, 0>(GetGridAuto(0, deviceType));
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index f224e860839df..1c74bb4a9b2c5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -189,32 +189,12 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       CADEBUG(printf("\tLeg %3d Sector %2d %4sTrack   Alpha %8.3f %s, X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", (int32_t)cluster.leg, (int32_t)cluster.sector, "", prop.GetAlpha(), (CAMath::Abs(prop.GetAlpha() - clAlpha) < 0.01 ? "   " : " R!"), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
       // clang-format on
       if (allowModification && changeDirection && !noFollowCircle && !noFollowCircle2) {
-        bool tryFollow = lastRow != 255;
-        if (tryFollow) {
-          const GPUTPCGMTrackParam backup = *this;
-          const float backupAlpha = prop.GetAlpha();
-          if (FollowCircle<0>(merger, prop, lastSector, lastRow, iTrk, clAlpha, xx, yy, cluster.sector, cluster.row, inFlyDirection)) {
-            CADEBUG(printf("Error during follow circle, resetting track!\n"));
-            *this = backup;
-            prop.SetTrack(this, backupAlpha);
+        if (lastRow != 255) {
+          if (!(merger->Param().rec.tpc.disableRefitAttachment & 4)) {
+            StoreAttachMirror(merger, lastSector, lastRow, iTrk, clAlpha, yy, xx, cluster.sector, cluster.row, inFlyDirection, prop.GetAlpha());
             noFollowCircle = true;
-            tryFollow = false;
           }
         }
-        if (tryFollow) {
-          MirrorTo(prop, yy, zz, inFlyDirection, param, cluster.row, clusterState, false, cluster.sector);
-          lastUpdateX = mX;
-          lastLeg = cluster.leg;
-          lastSector = cluster.sector;
-          lastRow = 255;
-          N++;
-          resetT0 = initResetT0();
-          // clang-format off
-          CADEBUG(printf("\n"));
-          CADEBUG(printf("\t%21sMirror  Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
-          // clang-format on
-          continue;
-        }
       } else if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
           bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2 && cluster.leg == clusters[maxN - 1].leg;
@@ -269,8 +249,8 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         CADEBUG(printf(" -- MirroredY: %f --> %f", mP[0], mirrordY));
         if (CAMath::Abs(yy - mP[0]) > CAMath::Abs(yy - mirrordY)) {
           CADEBUG(printf(" - Mirroring!!!"));
-          if (allowModification) {
-            AttachClustersMirror<0>(merger, cluster.sector, cluster.row, iTrk, yy, prop); // TODO: Never true, will always call FollowCircle above, really???
+          if (allowModification && !(merger->Param().rec.tpc.disableRefitAttachment & 8)) {
+            StoreAttachMirror(merger, cluster.sector, cluster.row, iTrk, 0, yy, 0, -1, 0, 0, prop.GetAlpha());
           }
           MirrorTo(prop, yy, zz, inFlyDirection, param, cluster.row, clusterState, true, cluster.sector);
           noFollowCircle = false;
@@ -751,24 +731,15 @@ GPUdii() void GPUTPCGMTrackParam::RefitLoop(const GPUTPCGMMerger* GPUrestrict()
   GPUTPCGMLoopData& data = Merger->LoopData()[loopIdx];
   prop.SetTrack(&data.param, data.alpha);
   if (data.toSector == -1) {
-    data.param.AttachClustersMirror<1>(Merger, data.sector, data.row, data.track, data.toY, prop, true);
+    data.param.AttachClustersMirror(Merger, data.sector, data.row, data.track, data.toY, prop);
   } else {
-    data.param.FollowCircle<1>(Merger, prop, data.sector, data.row, data.track, data.toAlpha, data.toX, data.toY, data.toSector, data.toRow, data.inFlyDirection, true);
+    data.param.FollowCircle(Merger, prop, data.sector, data.row, data.track, data.toAlpha, data.toX, data.toY, data.toSector, data.toRow, data.inFlyDirection);
   }
 }
 
-template <int32_t I>
-GPUdic(0, 1) int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& GPUrestrict() prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection, bool phase2)
+GPUdi() int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& GPUrestrict() prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection)
 {
   static constexpr float kSectAngle = 2 * M_PI / 18.f;
-  if (Merger->Param().rec.tpc.disableRefitAttachment & 4) {
-    return 1;
-  }
-  const bool inExtraPass = Merger->Param().rec.tpc.looperInterpolationInExtraPass == -1 ? GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION : Merger->Param().rec.tpc.looperInterpolationInExtraPass;
-  if (inExtraPass && phase2 == false) {
-    StoreAttachMirror(Merger, sector, iRow, iTrack, toAlpha, toY, toX, toSector, toRow, inFlyDirection, prop.GetAlpha());
-    return 1;
-  }
   const GPUParam& GPUrestrict() param = Merger->Param();
   bool right;
   float dAlpha = toAlpha - prop.GetAlpha();
@@ -862,19 +833,9 @@ GPUdic(0, 1) int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUr
   return (0);
 }
 
-template <int32_t I>
-GPUdni() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toY, GPUTPCGMPropagator& GPUrestrict() prop, bool phase2)
+GPUdi() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toY, GPUTPCGMPropagator& GPUrestrict() prop)
 {
   static constexpr float kSectAngle = 2 * M_PI / 18.f;
-
-  if (Merger->Param().rec.tpc.disableRefitAttachment & 8) {
-    return;
-  }
-  const bool inExtraPass = Merger->Param().rec.tpc.looperInterpolationInExtraPass == -1 ? GPUCA_PAR_MERGER_SPLIT_LOOP_INTERPOLATION : Merger->Param().rec.tpc.looperInterpolationInExtraPass;
-  if (inExtraPass && phase2 == false) {
-    StoreAttachMirror(Merger, sector, iRow, iTrack, 0, toY, 0, -1, 0, 0, prop.GetAlpha());
-    return;
-  }
   // Note that the coordinate system is rotated by 90 degree swapping X and Y!
   float X = mP[2] > 0 ? mP[0] : -mP[0];
   float toX = mP[2] > 0 ? toY : -toY;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index e3a5b2f7c1d01..90ff3154a3fe9 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -150,10 +150,8 @@ class GPUTPCGMTrackParam
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop); // Returns uncorrectedY for later use
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, float Y, float Z);
   // We force to compile these twice, for RefitLoop and for Fit, for better optimization
-  template <int32_t I>
-  GPUd() void AttachClustersMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toY, GPUTPCGMPropagator& prop, bool phase2 = false);
-  template <int32_t I>
-  GPUd() int32_t FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection, bool phase2 = false);
+  GPUd() void AttachClustersMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toY, GPUTPCGMPropagator& prop);
+  GPUd() int32_t FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection);
   GPUd() void StoreAttachMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toY, float toX, int32_t toSector, int32_t toRow, bool inFlyDirection, float alpha);
   GPUd() void StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, const GPUTPCGMPropagator& prop, int32_t phase);
   GPUd() static void RefitLoop(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t loopIdx);
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index fed4610b2f13a..5240b5ca47967 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -460,7 +460,6 @@ int32_t SetupReconstruction()
       procSet.tpcInputWithClusterRejection = 1;
     }
     recSet.tpc.disableRefitAttachment = 0xFF;
-    recSet.tpc.looperInterpolationInExtraPass = 0;
     recSet.maxTrackQPtB5 = CAMath::Min(recSet.maxTrackQPtB5, recSet.tpc.rejectQPtB5);
     recSet.useMatLUT = true;
     recAsync->SetSettings(&grp, &recSet, &procSet, &steps);
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 7ebe631d86e92..e1fef5795828b 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -142,7 +142,6 @@ o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP
                             TRACKLET_SELECTOR_HITS_REG_SIZE
                             ALTERNATE_BORDER_SORT
                             SORT_BEFORE_FIT
-                            MERGER_SPLIT_LOOP_INTERPOLATION
                             NO_ATOMIC_PRECHECK
                             COMP_GATHER_KERNEL
                             COMP_GATHER_MODE

From 990d2070c79f3dfd8f8f8924be38082dc2ffb084 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 23 Jul 2025 13:09:28 +0200
Subject: [PATCH 0809/1764] GPU TPC: Keep merged track legs as individual track
 segments during refit

---
 .../DataTypes/GPUMemorySizeScalers.h          |   2 +-
 .../Definitions/GPUDefConstantsAndSettings.h  |   2 +-
 .../GPUChainTrackingDebugAndProfiling.cxx     |   4 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h  |  22 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 558 ++++++++----------
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |   4 +-
 .../display/render/GPUDisplayDraw.cxx         |  14 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  |  17 +-
 GPU/GPUTracking/qa/GPUQA.h                    |   3 +-
 9 files changed, 287 insertions(+), 339 deletions(-)

diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
index 164ecb32c26c7..ff8abdc1a491e 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
@@ -47,7 +47,7 @@ struct GPUMemorySizeScalers {
   double tpcSectorTracksPerHit = 0.02;
   double tpcSectorTrackHitsPerHit = 0.8;
   double tpcSectorTrackHitsPerHitWithRejection = 1.0;
-  double tpcMergedTrackPerSectorTrack = 0.9;
+  double tpcMergedTrackPerSectorTrack = 1.0;
   double tpcMergedTrackHitPerSectorHit = 1.1;
   size_t tpcCompressedUnattachedHitsBase1024[3] = {900, 900, 500}; // No ratio, but integer fraction of 1024 for exact computation
 
diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index 46988208256fc..e5a2c8eb75bcb 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -32,7 +32,7 @@
 
 #define GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(QPTB5) (CAMath::Abs(QPTB5) > 10 ? 10 : (CAMath::Abs(QPTB5) > 5 ? 15 : 29)) // Minimum hits should depend on Pt, low Pt tracks can have few hits. 29 Hits default, 15 for < 200 mev, 10 for < 100 mev
 
-#define GPUCA_MERGER_MAX_TRACK_CLUSTERS 1000          // Maximum number of clusters a track may have after merging
+#define GPUCA_MERGER_MAX_TRACK_CLUSTERS 1024          // Maximum number of clusters a track may have after merging
 
 #define GPUCA_MAXN 40                                 // Maximum number of neighbor hits to consider in one row in neightbors finder
 #define GPUCA_MIN_TRACK_PTB5_DEFAULT 0.010f           // Default setting for minimum track Pt at some places (at B=0.5T)
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 7d790d8e3913f..fbd999f8feb56 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -216,7 +216,9 @@ void GPUChainTracking::PrintOutputStat()
   } else {
     for (uint32_t k = 0; k < mIOPtrs.nMergedTracks; k++) {
       if (mIOPtrs.mergedTracks[k].OK()) {
-        nTracks++;
+        if (!mIOPtrs.mergedTracks[k].MergedLooper()) {
+          nTracks++;
+        }
         nAttachedClusters += mIOPtrs.mergedTracks[k].NClusters();
         nAttachedClustersFitted += mIOPtrs.mergedTracks[k].NClustersFitted();
       }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 73b14ba1b2fdf..483cbc15998bc 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -45,13 +45,18 @@ class GPUTPCGMMergedTrack
   GPUd() bool Looper() const { return mFlags & 0x02; }
   GPUd() bool CSide() const { return mFlags & 0x04; }
   GPUd() bool CCE() const { return mFlags & 0x08; }
-  GPUd() bool MergedLooper() const { return mFlags & 0x10; }
+  GPUd() bool MergedLooperUnconnected() const { return mFlags & 0x10; }
+  GPUd() bool MergedLooperConnected() const { return mFlags & 0x20; }
+  GPUd() bool MergedLooper() const { return mFlags & 0x30; }
+  GPUd() int32_t PrevSegment() const { return mPrevSegment; }
+  GPUd() uint8_t Flags() const { return mFlags; }
 
   GPUd() void SetNClusters(int32_t v) { mNClusters = v; }
   GPUd() void SetNClustersFitted(int32_t v) { mNClustersFitted = v; }
   GPUd() void SetFirstClusterRef(int32_t v) { mFirstClusterRef = v; }
   GPUd() void SetParam(const GPUTPCGMTrackParam& v) { mParam = v; }
   GPUd() void SetAlpha(float v) { mAlpha = v; }
+  GPUd() void SetPrevSegment(int32_t v) { mPrevSegment = v; }
   GPUd() void SetOK(bool v)
   {
     if (v) {
@@ -84,7 +89,7 @@ class GPUTPCGMMergedTrack
       mFlags &= 0xF7;
     }
   }
-  GPUd() void SetMergedLooper(bool v)
+  GPUd() void SetMergedLooperUnconnected(bool v)
   {
     if (v) {
       mFlags |= 0x10;
@@ -92,10 +97,15 @@ class GPUTPCGMMergedTrack
       mFlags &= 0xEF;
     }
   }
+  GPUd() void SetMergedLooperConnected(bool v)
+  {
+    if (v) {
+      mFlags |= 0x20;
+    } else {
+      mFlags &= 0xDF;
+    }
+  }
   GPUd() void SetFlags(uint8_t v) { mFlags = v; }
-  GPUd() void SetLegs(uint8_t v) { mLegs = v; }
-  GPUd() uint8_t Legs() const { return mLegs; }
-  GPUd() uint8_t Flags() const { return mFlags; }
 
   GPUd() const gputpcgmmergertypes::GPUTPCOuterParam& OuterParam() const { return mOuterParam; }
   GPUd() gputpcgmmergertypes::GPUTPCOuterParam& OuterParam() { return mOuterParam; }
@@ -106,11 +116,11 @@ class GPUTPCGMMergedTrack
 
   float mAlpha;              //* alpha angle
   uint32_t mFirstClusterRef; //* index of the first track cluster in corresponding cluster arrays
+  int32_t mPrevSegment;      //* next segment in case of looping track
   // TODO: Change to 8 bit
   uint32_t mNClusters;       //* number of track clusters
   uint32_t mNClustersFitted; //* number of clusters used in fit
   uint8_t mFlags;
-  uint8_t mLegs;
 
 #if !defined(GPUCA_STANDALONE)
   ClassDefNV(GPUTPCGMMergedTrack, 0);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 338ecae4f9b95..3e2eae2e2ad6b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -59,9 +59,6 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #endif
 
-static constexpr int32_t kMaxParts = 400;
-static constexpr int32_t kMaxClusters = GPUCA_MERGER_MAX_TRACK_CLUSTERS;
-
 using namespace o2::gpu;
 using namespace o2::tpc;
 using namespace gputpcgmmergertypes;
@@ -98,9 +95,6 @@ struct GPUTPCGMMergerSortTracks_comp {
     if (a.CCE() != b.CCE()) {
       return a.CCE() > b.CCE();
     }
-    if (a.Legs() != b.Legs()) {
-      return a.Legs() > b.Legs();
-    }
     GPUCA_DETERMINISTIC_CODE( // clang-format off
       if (a.NClusters() != b.NClusters()) {
         return a.NClusters() > b.NClusters();
@@ -1348,8 +1342,7 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
         continue;
       }
       bool celooper = (trk[0]->GetParam().GetQPt() * Param().qptB5Scaler > 1 && trk[0]->GetParam().GetQPt() * trk[1]->GetParam().GetQPt() < 0);
-      bool looper = trk[0]->Looper() || trk[1]->Looper() || celooper;
-      if (!looper && trk[0]->GetParam().GetPar(3) * trk[1]->GetParam().GetPar(3) < 0) {
+      if (!celooper && trk[0]->GetParam().GetPar(3) * trk[1]->GetParam().GetPar(3) < 0) {
         continue;
       }
 
@@ -1365,7 +1358,7 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
       }
 
       bool needswap = false;
-      if (looper) {
+      if (celooper) {
         float z0max, z1max;
         if (Param().par.earlyTpcTransform) {
           z0max = CAMath::Max(CAMath::Abs(mClustersXYZ[trk[0]->FirstClusterRef()].z), CAMath::Abs(mClustersXYZ[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].z));
@@ -1386,15 +1379,13 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
         GPUCommonAlgorithm::swap(trk[0], trk[1]);
       }
 
-      bool reverse[2] = {false, false};
-      if (looper) {
-        if (Param().par.earlyTpcTransform) {
-          reverse[0] = (mClustersXYZ[trk[0]->FirstClusterRef()].z > mClustersXYZ[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].z) ^ (trk[0]->CSide() > 0);
-          reverse[1] = (mClustersXYZ[trk[1]->FirstClusterRef()].z < mClustersXYZ[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].z) ^ (trk[1]->CSide() > 0);
-        } else {
-          reverse[0] = cls[mClusters[trk[0]->FirstClusterRef()].num].getTime() < cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime();
-          reverse[1] = cls[mClusters[trk[1]->FirstClusterRef()].num].getTime() > cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime();
-        }
+      if (celooper) {
+        trk[0]->SetMergedLooperConnected(true);
+        trk[0]->SetCCE(true);
+        trk[0]->SetLooper(true);
+        trk[1]->SetCCE(true);
+        trk[1]->SetLooper(true);
+        continue;
       }
 
       if (Param().par.continuousTracking) {
@@ -1415,31 +1406,14 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
           trk[1]->Param().TZOffset() = offset;
         }
       }
-
       int32_t pos = newRef;
-      int32_t leg = -1;
-      int32_t lastLeg = -1;
 #pragma unroll
       for (int32_t k = 1; k >= 0; k--) {
-        int32_t loopstart = reverse[k] ? (trk[k]->NClusters() - 1) : 0;
-        int32_t loopend = reverse[k] ? -1 : (int32_t)trk[k]->NClusters();
-        int32_t loopinc = reverse[k] ? -1 : 1;
-        for (int32_t j = loopstart; j != loopend; j += loopinc) {
+        for (uint32_t j = 0; j != trk[k]->NClusters(); j++) {
           if (Param().par.earlyTpcTransform) {
             mClustersXYZ[pos] = mClustersXYZ[trk[k]->FirstClusterRef() + j];
           }
-          mClusters[pos] = mClusters[trk[k]->FirstClusterRef() + j];
-          if (looper) {
-            if (mClusters[trk[k]->FirstClusterRef() + j].leg != lastLeg) {
-              leg++;
-              lastLeg = mClusters[trk[k]->FirstClusterRef() + j].leg;
-            }
-            mClusters[pos].leg = leg;
-          }
-          pos++;
-        }
-        if (celooper) {
-          lastLeg = -1;
+          mClusters[pos++] = mClusters[trk[k]->FirstClusterRef() + j];
         }
       }
       trk[1]->SetFirstClusterRef(newRef);
@@ -1449,10 +1423,6 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
         trk[1]->SetNClusters(GPUCA_MERGER_MAX_TRACK_CLUSTERS);
       }
       trk[1]->SetCCE(true);
-      if (looper) {
-        trk[1]->SetLooper(true);
-        trk[1]->SetLegs(leg + 1);
-      }
       trk[0]->SetNClusters(0);
       trk[0]->SetOK(false);
     }
@@ -1465,32 +1435,6 @@ namespace o2::gpu::internal
 {
 namespace // anonymous
 {
-struct GPUTPCGMMerger_CompareClusterIdsLooper {
-  struct clcomparestruct {
-    uint8_t leg;
-  };
-
-  const uint8_t leg;
-  const bool outwards;
-  const GPUTPCGMMerger::trackCluster* const cmp1;
-  const clcomparestruct* const cmp2;
-  GPUd() GPUTPCGMMerger_CompareClusterIdsLooper(uint8_t l, bool o, const GPUTPCGMMerger::trackCluster* c1, const clcomparestruct* c2) : leg(l), outwards(o), cmp1(c1), cmp2(c2) {}
-  GPUd() bool operator()(const int16_t aa, const int16_t bb)
-  {
-    const clcomparestruct& a = cmp2[aa];
-    const clcomparestruct& b = cmp2[bb];
-    const GPUTPCGMMerger::trackCluster& a1 = cmp1[aa];
-    const GPUTPCGMMerger::trackCluster& b1 = cmp1[bb];
-    if (a.leg != b.leg) {
-      return ((leg > 0) ^ (a.leg > b.leg));
-    }
-    if (a1.row != b1.row) {
-      return ((a1.row > b1.row) ^ ((a.leg - leg) & 1) ^ outwards);
-    }
-    return GPUCA_DETERMINISTIC_CODE((a1.id != b1.id) ? (a1.id > b1.id) : (aa > bb), a1.id > b1.id);
-  }
-};
-
 struct GPUTPCGMMerger_CompareClusterIds {
   const GPUTPCGMMerger::trackCluster* const mCmp;
   GPUd() GPUTPCGMMerger_CompareClusterIds(const GPUTPCGMMerger::trackCluster* cmp) : mCmp(cmp) {}
@@ -1509,296 +1453,269 @@ struct GPUTPCGMMerger_CompareClusterIds {
 
 GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  GPUTPCGMSectorTrack* trackParts[kMaxParts];
+  static constexpr int32_t kMaxParts = 16;
+  static constexpr int32_t kMaxClusters = GPUCA_MERGER_MAX_TRACK_CLUSTERS;
 
-  for (int32_t itr = iBlock * nThreads + iThread; itr < SectorTrackInfoLocalTotal(); itr += nThreads * nBlocks) {
-    GPUTPCGMSectorTrack& track = mSectorTrackInfos[itr];
+  GPUTPCGMSectorTrack* trackParts[kMaxParts];
 
-    if (track.PrevSegmentNeighbour() >= 0) {
-      continue;
-    }
-    if (track.PrevNeighbour() >= 0) {
-      continue;
+  int32_t itr = iBlock * nThreads + iThread;
+  GPUTPCGMSectorTrack* trbase = nullptr;
+  int32_t leg = 0;
+  int32_t lastMergedSegment = -1;
+  while (true) {
+    if (trbase) {
+      int32_t jtr = trbase->NextNeighbour();
+      if (jtr >= 0) {
+        trbase = &(mSectorTrackInfos[jtr]);
+        if (trbase->PrevSegmentNeighbour() >= 0) {
+          trbase = nullptr;
+        } else {
+          trbase->SetPrevSegmentNeighbour(1000000001);
+          leg++;
+        }
+      } else {
+        trbase = nullptr;
+      }
     }
-    int32_t nParts = 0;
-    int32_t nHits = 0;
-    int32_t leg = 0;
-    GPUTPCGMSectorTrack *trbase = &track, *tr = &track;
-    tr->SetPrevSegmentNeighbour(1000000000);
-    while (true) {
-      if (nParts >= kMaxParts) {
+
+    if (trbase == nullptr) {
+      while (itr < SectorTrackInfoLocalTotal()) {
+        trbase = &mSectorTrackInfos[itr];
+        if (trbase->PrevSegmentNeighbour() >= 0 || trbase->PrevNeighbour() >= 0) {
+          itr += nThreads * nBlocks;
+          continue;
+        }
         break;
       }
-      if (nHits + tr->NClusters() > kMaxClusters) {
+      if (itr >= SectorTrackInfoLocalTotal()) {
         break;
       }
-      nHits += tr->NClusters();
+      itr += nThreads * nBlocks;
+      trbase->SetPrevSegmentNeighbour(1000000000);
+      leg = 0;
+      lastMergedSegment = -1;
+    }
 
-      tr->SetLeg(leg);
-      trackParts[nParts++] = tr;
-      for (int32_t i = 0; i < 2; i++) {
-        if (tr->ExtrapolatedTrackId(i) != -1) {
-          if (nParts >= kMaxParts) {
-            break;
-          }
-          if (nHits + mSectorTrackInfos[tr->ExtrapolatedTrackId(i)].NClusters() > kMaxClusters) {
-            break;
-          }
-          trackParts[nParts] = &mSectorTrackInfos[tr->ExtrapolatedTrackId(i)];
-          trackParts[nParts++]->SetLeg(leg);
-          nHits += mSectorTrackInfos[tr->ExtrapolatedTrackId(i)].NClusters();
+    do {
+      int32_t nParts = 0;
+      int32_t nHits = 0;
+
+      GPUTPCGMSectorTrack* tr = trbase;
+      while (true) {
+        if (nParts >= kMaxParts) {
+          break;
         }
-      }
-      int32_t jtr = tr->NextSegmentNeighbour();
-      if (jtr >= 0) {
-        tr = &(mSectorTrackInfos[jtr]);
-        tr->SetPrevSegmentNeighbour(1000000002);
-        continue;
-      }
-      jtr = trbase->NextNeighbour();
-      if (jtr >= 0) {
-        trbase = &(mSectorTrackInfos[jtr]);
-        tr = trbase;
-        if (tr->PrevSegmentNeighbour() >= 0) {
+        if (nHits + tr->NClusters() > kMaxClusters) {
           break;
         }
-        tr->SetPrevSegmentNeighbour(1000000001);
-        leg++;
-        continue;
+        nHits += tr->NClusters();
+
+        tr->SetLeg(leg);
+        trackParts[nParts++] = tr;
+        for (int32_t i = 0; i < 2; i++) {
+          if (tr->ExtrapolatedTrackId(i) != -1) {
+            if (nParts >= kMaxParts) {
+              break;
+            }
+            if (nHits + mSectorTrackInfos[tr->ExtrapolatedTrackId(i)].NClusters() > kMaxClusters) {
+              break;
+            }
+            trackParts[nParts] = &mSectorTrackInfos[tr->ExtrapolatedTrackId(i)];
+            trackParts[nParts++]->SetLeg(leg);
+            nHits += mSectorTrackInfos[tr->ExtrapolatedTrackId(i)].NClusters();
+          }
+        }
+        int32_t jtr = tr->NextSegmentNeighbour();
+        if (jtr >= 0) {
+          tr = &(mSectorTrackInfos[jtr]);
+          tr->SetPrevSegmentNeighbour(1000000002);
+          continue;
+        }
+        break;
       }
-      break;
-    }
 
-    // unpack and sort clusters
-    if (nParts > 1 && leg == 0) {
-      GPUCommonAlgorithm::sort(trackParts, trackParts + nParts, [](const GPUTPCGMSectorTrack* a, const GPUTPCGMSectorTrack* b) {
-        GPUCA_DETERMINISTIC_CODE( // clang-format off
-          if (a->X() != b->X()) {
+      // unpack and sort clusters
+      if (nParts > 1 && leg == 0) {
+        GPUCommonAlgorithm::sort(trackParts, trackParts + nParts, [](const GPUTPCGMSectorTrack* a, const GPUTPCGMSectorTrack* b) {
+          GPUCA_DETERMINISTIC_CODE( // clang-format off
+            if (a->X() != b->X()) {
+              return (a->X() > b->X());
+            }
+            if (a->Y() != b->Y()) {
+              return (a->Y() > b->Y());
+            }
+            if (a->Z() != b->Z()) {
+              return (a->Z() > b->Z());
+            }
+            return a->QPt() > b->QPt();
+          , // !GPUCA_DETERMINISTIC_CODE
             return (a->X() > b->X());
-          }
-          if (a->Y() != b->Y()) {
-            return (a->Y() > b->Y());
-          }
-          if (a->Z() != b->Z()) {
-            return (a->Z() > b->Z());
-          }
-          return a->QPt() > b->QPt();
-        , // !GPUCA_DETERMINISTIC_CODE
-          return (a->X() > b->X());
-        ) // clang-format on
-      });
-    }
-
-    if (Param().rec.tpc.dropLoopers && leg > 0) {
-      nParts = 1;
-      leg = 0;
-    }
-
-    trackCluster trackClusters[kMaxClusters];
-    nHits = 0;
-    for (int32_t ipart = 0; ipart < nParts; ipart++) {
-      const GPUTPCGMSectorTrack* t = trackParts[ipart];
-      CADEBUG(printf("Collect Track %d Part %d QPt %f DzDs %f\n", mMemory->nMergedTracks, ipart, t->QPt(), t->DzDs()));
-      int32_t nTrackHits = t->NClusters();
-      trackCluster* c2 = trackClusters + nHits + nTrackHits - 1;
-      for (int32_t i = 0; i < nTrackHits; i++, c2--) {
-        const GPUTPCTracker& trk = GetConstantMem()->tpcTrackers[t->Sector()];
-        const GPUTPCHitId& ic = trk.TrackHits()[t->OrigTrack()->FirstHitID() + i];
-        uint32_t id = trk.Data().ClusterDataIndex(trk.Data().Row(ic.RowIndex()), ic.HitIndex()) + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[t->Sector()][0];
-        *c2 = trackCluster{id, (uint8_t)ic.RowIndex(), t->Sector(), t->Leg()};
-      }
-      nHits += nTrackHits;
-    }
-    if (nHits < GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(track.QPt() * Param().qptB5Scaler)) {
-      continue;
-    }
+          ) // clang-format on
+        });
+      }
+
+      if (Param().rec.tpc.dropLoopers && leg > 0) {
+        nParts = 1;
+        leg = 0;
+      }
+
+      trackCluster trackClusters[kMaxClusters];
+      nHits = 0;
+      for (int32_t ipart = 0; ipart < nParts; ipart++) {
+        const GPUTPCGMSectorTrack* t = trackParts[ipart];
+        CADEBUG(printf("Collect Track %d Part %d QPt %f DzDs %f\n", mMemory->nMergedTracks, ipart, t->QPt(), t->DzDs()));
+        int32_t nTrackHits = t->NClusters();
+        trackCluster* c2 = trackClusters + nHits + nTrackHits - 1;
+        for (int32_t i = 0; i < nTrackHits; i++, c2--) {
+          const GPUTPCTracker& trk = GetConstantMem()->tpcTrackers[t->Sector()];
+          const GPUTPCHitId& ic = trk.TrackHits()[t->OrigTrack()->FirstHitID() + i];
+          uint32_t id = trk.Data().ClusterDataIndex(trk.Data().Row(ic.RowIndex()), ic.HitIndex()) + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[t->Sector()][0];
+          *c2 = trackCluster{id, (uint8_t)ic.RowIndex(), t->Sector(), t->Leg()};
+        }
+        nHits += nTrackHits;
+      }
+      if (nHits < GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(trbase->QPt() * Param().qptB5Scaler)) {
+        break;
+      }
 
-    int32_t ordered = leg == 0;
-    if (ordered) {
+      bool ordered = true;
       for (int32_t i = 1; i < nHits; i++) {
         if (trackClusters[i].row > trackClusters[i - 1].row || trackClusters[i].id == trackClusters[i - 1].id) {
-          ordered = 0;
+          ordered = false;
           break;
         }
       }
-    }
-    int32_t firstTrackIndex = 0;
-    int32_t lastTrackIndex = nParts - 1;
-    if (ordered == 0) {
-      int32_t nTmpHits = 0;
-      trackCluster trackClustersUnsorted[kMaxClusters];
-      int16_t clusterIndices[kMaxClusters];
-      for (int32_t i = 0; i < nHits; i++) {
-        trackClustersUnsorted[i] = trackClusters[i];
-        clusterIndices[i] = i;
-      }
+      int32_t firstTrackIndex = 0;
+      int32_t lastTrackIndex = nParts - 1;
+      if (ordered == 0) {
+        int32_t nTmpHits = 0;
+        trackCluster trackClustersUnsorted[kMaxClusters];
+        int16_t clusterIndices[kMaxClusters];
+        for (int32_t i = 0; i < nHits; i++) {
+          trackClustersUnsorted[i] = trackClusters[i];
+          clusterIndices[i] = i;
+        }
+
+        GPUCommonAlgorithm::sort(clusterIndices, clusterIndices + nHits, GPUTPCGMMerger_CompareClusterIds(trackClusters));
 
-      if (leg > 0) {
-        // Find QPt and DzDs for the segment closest to the vertex, if low/mid Pt
-        float baseZT = 1e9;
-        uint8_t baseLeg = 0;
+        nTmpHits = 0;
+        firstTrackIndex = lastTrackIndex = -1;
         for (int32_t i = 0; i < nParts; i++) {
-          if (trackParts[i]->Leg() == 0 || trackParts[i]->Leg() == leg) {
-            float zt;
-            if (Param().par.earlyTpcTransform) {
-              zt = CAMath::Min(CAMath::Abs(trackParts[i]->ClusterZT0()), CAMath::Abs(trackParts[i]->ClusterZTN()));
-            } else {
-              zt = -trackParts[i]->MinClusterZT(); // Negative time ~ smallest z, to behave the same way // TODO: Check all these min / max ZT
-            }
-            if (zt < baseZT) {
-              baseZT = zt;
-              baseLeg = trackParts[i]->Leg();
-            }
+          nTmpHits += trackParts[i]->NClusters();
+          if (nTmpHits > clusterIndices[0] && firstTrackIndex == -1) {
+            firstTrackIndex = i;
           }
-        }
-        int32_t iLongest = 1e9;
-        int32_t length = 0;
-        for (int32_t i = (baseLeg ? (nParts - 1) : 0); baseLeg ? (i >= 0) : (i < nParts); baseLeg ? i-- : i++) {
-          if (trackParts[i]->Leg() != baseLeg) {
-            break;
-          }
-          if (trackParts[i]->OrigTrack()->NHits() > length) {
-            iLongest = i;
-            length = trackParts[i]->OrigTrack()->NHits();
+          if (nTmpHits > clusterIndices[nHits - 1] && lastTrackIndex == -1) {
+            lastTrackIndex = i;
           }
         }
-        bool outwards;
-        if (Param().par.earlyTpcTransform) {
-          outwards = (trackParts[iLongest]->ClusterZT0() > trackParts[iLongest]->ClusterZTN()) ^ trackParts[iLongest]->CSide();
-        } else {
-          outwards = trackParts[iLongest]->ClusterZT0() < trackParts[iLongest]->ClusterZTN();
-        }
-        GPUTPCGMMerger_CompareClusterIdsLooper::clcomparestruct clusterSort[kMaxClusters];
-        for (int32_t iPart = 0; iPart < nParts; iPart++) {
-          const GPUTPCGMSectorTrack* t = trackParts[iPart];
-          int32_t nTrackHits = t->NClusters();
-          for (int32_t j = 0; j < nTrackHits; j++) {
-            int32_t i = nTmpHits + j;
-            clusterSort[i].leg = t->Leg();
+
+        int32_t nFilteredHits = 0;
+        int32_t indPrev = -1;
+        for (int32_t i = 0; i < nHits; i++) {
+          int32_t ind = clusterIndices[i];
+          if (indPrev >= 0 && trackClustersUnsorted[ind].id == trackClustersUnsorted[indPrev].id) {
+            continue;
           }
-          nTmpHits += nTrackHits;
+          indPrev = ind;
+          trackClusters[nFilteredHits] = trackClustersUnsorted[ind];
+          nFilteredHits++;
         }
-
-        GPUCommonAlgorithm::sort(clusterIndices, clusterIndices + nHits, GPUTPCGMMerger_CompareClusterIdsLooper(baseLeg, outwards, trackClusters, clusterSort));
-      } else {
-        GPUCommonAlgorithm::sort(clusterIndices, clusterIndices + nHits, GPUTPCGMMerger_CompareClusterIds(trackClusters));
+        nHits = nFilteredHits;
       }
-      nTmpHits = 0;
-      firstTrackIndex = lastTrackIndex = -1;
-      for (int32_t i = 0; i < nParts; i++) {
-        nTmpHits += trackParts[i]->NClusters();
-        if (nTmpHits > clusterIndices[0] && firstTrackIndex == -1) {
-          firstTrackIndex = i;
-        }
-        if (nTmpHits > clusterIndices[nHits - 1] && lastTrackIndex == -1) {
-          lastTrackIndex = i;
-        }
+
+      const uint32_t iMergedTrackFirstCluster = CAMath::AtomicAdd(&mMemory->nMergedTrackClusters, (uint32_t)nHits);
+      if (iMergedTrackFirstCluster + nHits > mNMaxMergedTrackClusters) {
+        raiseError(GPUErrors::ERROR_MERGER_HIT_OVERFLOW, iMergedTrackFirstCluster, mNMaxMergedTrackClusters);
+        CAMath::AtomicExch(&mMemory->nMergedTrackClusters, mNMaxMergedTrackClusters);
+        break;
       }
 
-      int32_t nFilteredHits = 0;
-      int32_t indPrev = -1;
+      GPUTPCGMMergedTrackHit* const cl = mClusters + iMergedTrackFirstCluster;
+
       for (int32_t i = 0; i < nHits; i++) {
-        int32_t ind = clusterIndices[i];
-        if (indPrev >= 0 && trackClustersUnsorted[ind].id == trackClustersUnsorted[indPrev].id) {
-          continue;
+        uint8_t state;
+        if (Param().par.earlyTpcTransform) {
+          const GPUTPCClusterData& c = GetConstantMem()->tpcTrackers[trackClusters[i].sector].ClusterData()[trackClusters[i].id - GetConstantMem()->tpcTrackers[trackClusters[i].sector].Data().ClusterIdOffset()];
+          GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iMergedTrackFirstCluster;
+          clXYZ[i].x = c.x;
+          clXYZ[i].y = c.y;
+          clXYZ[i].z = c.z;
+          clXYZ[i].amp = c.amp;
+          state = c.flags;
+        } else {
+          const ClusterNative& c = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[trackClusters[i].id];
+          state = c.getFlags();
         }
-        indPrev = ind;
-        trackClusters[nFilteredHits] = trackClustersUnsorted[ind];
-        nFilteredHits++;
+        cl[i].state = state & GPUTPCGMMergedTrackHit::clustererAndSharedFlags; // Only allow edge, deconvoluted, and shared flags
+        cl[i].row = trackClusters[i].row;
+        cl[i].num = trackClusters[i].id;
+        cl[i].sector = trackClusters[i].sector;
+        cl[i].leg = trackClusters[i].leg;
       }
-      nHits = nFilteredHits;
-    }
-
-    const uint32_t iMergedTrackFirstCluster = CAMath::AtomicAdd(&mMemory->nMergedTrackClusters, (uint32_t)nHits);
-    if (iMergedTrackFirstCluster + nHits > mNMaxMergedTrackClusters) {
-      raiseError(GPUErrors::ERROR_MERGER_HIT_OVERFLOW, iMergedTrackFirstCluster, mNMaxMergedTrackClusters);
-      CAMath::AtomicExch(&mMemory->nMergedTrackClusters, mNMaxMergedTrackClusters);
-      continue;
-    }
 
-    GPUTPCGMMergedTrackHit* const cl = mClusters + iMergedTrackFirstCluster;
+      uint32_t iOutputTrack = CAMath::AtomicAdd(&mMemory->nMergedTracks, 1u);
+      if (iOutputTrack >= mNMaxTracks) {
+        raiseError(GPUErrors::ERROR_MERGER_TRACK_OVERFLOW, iOutputTrack, mNMaxTracks);
+        CAMath::AtomicExch(&mMemory->nMergedTracks, mNMaxTracks);
+        break;
+      }
 
-    for (int32_t i = 0; i < nHits; i++) {
-      uint8_t state;
-      if (Param().par.earlyTpcTransform) {
-        const GPUTPCClusterData& c = GetConstantMem()->tpcTrackers[trackClusters[i].sector].ClusterData()[trackClusters[i].id - GetConstantMem()->tpcTrackers[trackClusters[i].sector].Data().ClusterIdOffset()];
-        GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iMergedTrackFirstCluster;
-        clXYZ[i].x = c.x;
-        clXYZ[i].y = c.y;
-        clXYZ[i].z = c.z;
-        clXYZ[i].amp = c.amp;
-        state = c.flags;
+      GPUTPCGMMergedTrack& mergedTrack = mMergedTracks[iOutputTrack];
+      mergedTrack.SetFlags(0);
+      mergedTrack.SetOK(true);
+      mergedTrack.SetLooper(leg > 0 || trbase->NextNeighbour() >= 0);
+      mergedTrack.SetNClusters(nHits);
+      mergedTrack.SetFirstClusterRef(iMergedTrackFirstCluster);
+      GPUTPCGMTrackParam& p1 = mergedTrack.Param();
+      const GPUTPCGMSectorTrack& p2 = *trackParts[firstTrackIndex];
+      mergedTrack.SetCSide(p2.CSide());
+      mergedTrack.SetMergedLooperConnected(leg > 0);
+      mergedTrack.SetPrevSegment(lastMergedSegment);
+      lastMergedSegment = iOutputTrack;
+
+      GPUTPCGMBorderTrack b;
+      const float toX = Param().par.earlyTpcTransform ? mClustersXYZ[iMergedTrackFirstCluster].x : GPUTPCGeometry::Row2X(cl[0].row);
+      if (p2.TransportToX(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
+        p1.X() = toX;
+        p1.Y() = b.Par()[0];
+        p1.Z() = b.Par()[1];
+        p1.SinPhi() = b.Par()[2];
       } else {
-        const ClusterNative& c = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[trackClusters[i].id];
-        state = c.getFlags();
-      }
-      cl[i].state = state & GPUTPCGMMergedTrackHit::clustererAndSharedFlags; // Only allow edge, deconvoluted, and shared flags
-      cl[i].row = trackClusters[i].row;
-      cl[i].num = trackClusters[i].id;
-      cl[i].sector = trackClusters[i].sector;
-      cl[i].leg = trackClusters[i].leg;
-    }
-
-    uint32_t iOutputTrack = CAMath::AtomicAdd(&mMemory->nMergedTracks, 1u);
-    if (iOutputTrack >= mNMaxTracks) {
-      raiseError(GPUErrors::ERROR_MERGER_TRACK_OVERFLOW, iOutputTrack, mNMaxTracks);
-      CAMath::AtomicExch(&mMemory->nMergedTracks, mNMaxTracks);
-      continue;
-    }
-
-    GPUTPCGMMergedTrack& mergedTrack = mMergedTracks[iOutputTrack];
-
-    mergedTrack.SetFlags(0);
-    mergedTrack.SetOK(1);
-    mergedTrack.SetLooper(leg > 0);
-    mergedTrack.SetLegs(leg);
-    mergedTrack.SetNClusters(nHits);
-    mergedTrack.SetFirstClusterRef(iMergedTrackFirstCluster);
-    GPUTPCGMTrackParam& p1 = mergedTrack.Param();
-    const GPUTPCGMSectorTrack& p2 = *trackParts[firstTrackIndex];
-    mergedTrack.SetCSide(p2.CSide());
-
-    GPUTPCGMBorderTrack b;
-    const float toX = Param().par.earlyTpcTransform ? mClustersXYZ[iMergedTrackFirstCluster].x : GPUTPCGeometry::Row2X(cl[0].row);
-    if (p2.TransportToX(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
-      p1.X() = toX;
-      p1.Y() = b.Par()[0];
-      p1.Z() = b.Par()[1];
-      p1.SinPhi() = b.Par()[2];
-    } else {
-      p1.X() = p2.X();
-      p1.Y() = p2.Y();
-      p1.Z() = p2.Z();
-      p1.SinPhi() = p2.SinPhi();
-    }
-    p1.TZOffset() = p2.TZOffset();
-    p1.DzDs() = p2.DzDs();
-    p1.QPt() = p2.QPt();
-    mergedTrack.SetAlpha(p2.Alpha());
-    if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (gpu_common_constants::kZeroFieldCut * gpu_common_constants::kCLight)) {
-      p1.QPt() = 100.f / Param().rec.bz0Pt10MeV;
-    }
+        p1.X() = p2.X();
+        p1.Y() = p2.Y();
+        p1.Z() = p2.Z();
+        p1.SinPhi() = p2.SinPhi();
+      }
+      p1.TZOffset() = p2.TZOffset();
+      p1.DzDs() = p2.DzDs();
+      p1.QPt() = p2.QPt();
+      mergedTrack.SetAlpha(p2.Alpha());
+      if (CAMath::Abs(Param().polynomialField.GetNominalBz()) < (gpu_common_constants::kZeroFieldCut * gpu_common_constants::kCLight)) {
+        p1.QPt() = 100.f / Param().rec.bz0Pt10MeV;
+      }
 
-    // if (nParts > 1) printf("Merged %d: QPt %f %d parts %d hits\n", mMemory->nMergedTracks, p1.QPt(), nParts, nHits);
+      // if (nParts > 1) printf("Merged %d: QPt %f %d parts %d hits\n", mMemory->nMergedTracks, p1.QPt(), nParts, nHits);
 
-    /*if (GPUQA::QAAvailable() && mRec->GetQA() && mRec->GetQA()->SuppressTrack(mMemory->nMergedTracks))
-    {
-      mergedTrack.SetOK(0);
-      mergedTrack.SetNClusters(0);
-    }
-    if (mergedTrack.NClusters() && mergedTrack.OK()) */
-    if (Param().rec.tpc.mergeCE) {
-      bool CEside;
-      if (Param().par.earlyTpcTransform) {
-        const GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iMergedTrackFirstCluster;
-        CEside = (mergedTrack.CSide() != 0) ^ (clXYZ[0].z > clXYZ[nHits - 1].z);
-      } else {
-        auto& cls = mConstantMem->ioPtrs.clustersNative->clustersLinear;
-        CEside = cls[cl[0].num].getTime() < cls[cl[nHits - 1].num].getTime();
+      /*if (GPUQA::QAAvailable() && mRec->GetQA() && mRec->GetQA()->SuppressTrack(mMemory->nMergedTracks))
+      {
+        mergedTrack.SetOK(0);
+        mergedTrack.SetNClusters(0);
       }
-      MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], Param().par.earlyTpcTransform ? &(mClustersXYZ + iMergedTrackFirstCluster)[CEside ? (nHits - 1) : 0] : nullptr, iOutputTrack);
-    }
-  } // itr
+      if (mergedTrack.NClusters() && mergedTrack.OK()) */
+      if (Param().rec.tpc.mergeCE) {
+        bool CEside;
+        if (Param().par.earlyTpcTransform) {
+          const GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iMergedTrackFirstCluster;
+          CEside = (mergedTrack.CSide() != 0) ^ (clXYZ[0].z > clXYZ[nHits - 1].z);
+        } else {
+          auto& cls = mConstantMem->ioPtrs.clustersNative->clustersLinear;
+          CEside = cls[cl[0].num].getTime() < cls[cl[nHits - 1].num].getTime();
+        }
+        MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], Param().par.earlyTpcTransform ? &(mClustersXYZ + iMergedTrackFirstCluster)[CEside ? (nHits - 1) : 0] : nullptr, iOutputTrack);
+      }
+    } while (false);
+  }
 }
 
 GPUd() void GPUTPCGMMerger::SortTracksPrepare(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
@@ -1911,6 +1828,7 @@ GPUd() void GPUTPCGMMerger::Finalize2(int32_t nBlocks, int32_t nThreads, int32_t
 
 GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
+  return;                                                       // FIXME: !!!!
   const float lowPtThresh = Param().rec.tpc.rejectQPtB5 * 1.1f; // Might need to merge tracks above the threshold with parts below the threshold
   for (uint32_t i = get_global_id(0); i < mMemory->nMergedTracks; i += get_global_size(0)) {
     const auto& trk = mMergedTracks[i];
@@ -2057,9 +1975,9 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
     }*/
 #endif
       if (EQ) {
-        mMergedTracks[params[j].id].SetMergedLooper(true);
+        mMergedTracks[params[j].id].SetMergedLooperUnconnected(true);
         if (CAMath::Abs(param2.GetQPt() * Param().qptB5Scaler) >= Param().rec.tpc.rejectQPtB5) {
-          mMergedTracks[params[i].id].SetMergedLooper(true);
+          mMergedTracks[params[i].id].SetMergedLooperUnconnected(true);
         }
       }
     }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 9c924e74ec519..90f2fce5cdd2e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -205,7 +205,7 @@ void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
     out << "  Track " << i << ": OK " << trk.OK() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTZOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << " / " << trk.NClustersFitted() << " Cov " << p.GetErr2Y() << "/" << p.GetErr2Z()
         << " dEdx " << (trk.OK() && Param().dodEdxEnabled ? mMergedTracksdEdx[i].dEdxTotTPC : -1.f) << "/" << (trk.OK() && Param().dodEdxEnabled ? mMergedTracksdEdx[i].dEdxMaxTPC : -1.f)
         << " Outer " << po.P[0] << "/" << po.P[1] << "/" << po.P[2] << "/" << po.P[3] << "/" << po.P[4]
-        << " NFitted " << trk.NClustersFitted() << " legs " << (int)trk.Legs() << " flags " << (int)trk.Flags() << "\n";
+        << " NFitted " << trk.NClustersFitted() << " flags " << (int)trk.Flags() << "\n";
   }
   out << std::setprecision(ss);
 }
@@ -217,7 +217,7 @@ void GPUTPCGMMerger::DumpLoopers(std::ostream& out) const
     if (i && i % 100 == 0) {
       out << "\n";
     }
-    out << (int)mMergedTracks[i].MergedLooper() << " ";
+    out << (int)mMergedTracks[i].MergedLooperUnconnected() << " ";
   }
   out << "\n";
 }
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index ebb1b41802ba0..43de5a1d5011a 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -464,6 +464,13 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
         } else {
           if (!drawing) {
             startCountInner = mVertexBuffer[iSector].size();
+            if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
+              if (k == 0 && track->PrevSegment() >= 0) {
+                const auto& prevtrk = mIOPtrs->mergedTracks[track->PrevSegment()];
+                int32_t prevcid = mIOPtrs->mergedTrackHits[prevtrk.FirstClusterRef() + prevtrk.NClusters() - 1].num;
+                drawPointLinestrip(iSector, prevcid, tFINALTRACK, separateExtrapolatedTracksLimit);
+              }
+            }
             if (lastCluster != -1 && (!mCfgH.splitCETracks || lastSide == (mGlobalPos[cid].z < 0))) {
               int32_t lastcid;
               if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
@@ -512,6 +519,11 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
         if (lastCluster == -1) {
           continue;
         }
+        if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
+          if (track->MergedLooperConnected()) {
+            continue;
+          }
+        }
       }
 
       size_t startCountInner = mVertexBuffer[iSector].size();
@@ -610,7 +622,7 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
           if ((inFlyDirection == 0 && x < 0) || (inFlyDirection && x * x + trkParam.Y() * trkParam.Y() > (iMC ? (450 * 450) : (300 * 300)))) {
             break;
           }
-          if (fabsf(trkParam.Z() + ZOffset) > mMaxClusterZ + (iMC ? 0 : 0)) {
+          if (fabsf(trkParam.Z() + ZOffset) > mMaxClusterZ) {
             break;
           }
           if (fabsf(trkParam.Z() - z0) > (iMC ? GPUTPCGeometry::TPCLength() : GPUTPCGeometry::TPCLength())) {
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index d542e39c55b52..dcc2a37992a05 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -100,13 +100,15 @@ using namespace o2::gpu;
   float qpt = 0;                                                                                 \
   bool lowPt = false;                                                                            \
   [[maybe_unused]] bool mev200 = false;                                                          \
-  bool mergedLooper = false;                                                                     \
+  bool mergedLooperUnconnected = false;                                                          \
+  bool mergedLooperConnected = false;                                                            \
   int32_t id = attach & gputpcgmmergertypes::attachTrackMask;                                    \
   if (!unattached) {                                                                             \
     qpt = fabsf(mTracking->mIOPtrs.mergedTracks[id].GetParam().GetQPt());                        \
     lowPt = qpt * mTracking->GetParam().qptB5Scaler > mTracking->GetParam().rec.tpc.rejectQPtB5; \
     mev200 = qpt > 5;                                                                            \
-    mergedLooper = mTracking->mIOPtrs.mergedTracks[id].MergedLooper();                           \
+    mergedLooperUnconnected = mTracking->mIOPtrs.mergedTracks[id].MergedLooperUnconnected();     \
+    mergedLooperConnected = mTracking->mIOPtrs.mergedTracks[id].MergedLooperConnected();         \
   }                                                                                              \
   bool physics = false, protect = false;                                                         \
   CHECK_CLUSTER_STATE_INIT_LEG_BY_MC();
@@ -118,15 +120,17 @@ using namespace o2::gpu;
   }                                                                                                        \
   if (lowPt) {                                                                                             \
     mClusterCounts.nLowPt++;                                                                               \
-  } else if (mergedLooper) {                                                                               \
-    mClusterCounts.nMergedLooper++;                                                                        \
+  } else if (mergedLooperUnconnected) {                                                                    \
+    mClusterCounts.nMergedLooperUnconnected++;                                                             \
+  } else if (mergedLooperConnected) {                                                                      \
+    mClusterCounts.nMergedLooperConnected++;                                                               \
   } else {                                                                                                 \
     GPUTPCClusterRejection::GetProtectionStatus<true>(attach, physics, protect, &mClusterCounts, &mev200); \
   }
 
 #define CHECK_CLUSTER_STATE_NOCOUNT()                                             \
   CHECK_CLUSTER_STATE_INIT()                                                      \
-  if (!lowPt && !mergedLooper) {                                                  \
+  if (!lowPt && !mergedLooperUnconnected && !mergedLooperConnected) {             \
     GPUTPCClusterRejection::GetProtectionStatus<false>(attach, physics, protect); \
   }
 
@@ -2967,7 +2971,8 @@ int32_t GPUQA::DoClusterCounts(uint64_t* attachClusterCounts, int32_t mode)
     PrintClusterCount(mode, num, "Removed (Strategy B)", mClusterCounts.nTotal - mClusterCounts.nProt, mClusterCounts.nTotal);
   }
 
-  PrintClusterCount(mode, num, "Merged Loopers (Afterburner)", mClusterCounts.nMergedLooper, mClusterCounts.nTotal);
+  PrintClusterCount(mode, num, "Merged Loopers (Track Merging)", mClusterCounts.nMergedLooperConnected, mClusterCounts.nTotal);
+  PrintClusterCount(mode, num, "Merged Loopers (Afterburner)", mClusterCounts.nMergedLooperUnconnected, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "High Inclination Angle", mClusterCounts.nHighIncl, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "Rejected", mClusterCounts.nRejected, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "Tube (> 200 MeV)", mClusterCounts.nTube, mClusterCounts.nTotal);
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 591eb1722bf9f..92e931892339a 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -291,7 +291,8 @@ class GPUQA
   TLegend* mLClust[N_CLS_TYPE];
 
   struct counts_t {
-    int64_t nRejected = 0, nTube = 0, nTube200 = 0, nLoopers = 0, nLowPt = 0, n200MeV = 0, nPhysics = 0, nProt = 0, nUnattached = 0, nTotal = 0, nHighIncl = 0, nAbove400 = 0, nFakeRemove400 = 0, nFullFakeRemove400 = 0, nBelow40 = 0, nFakeProtect40 = 0, nMergedLooper = 0, nCorrectlyAttachedNormalized = 0, nCorrectlyAttachedNormalizedNonFake = 0;
+    int64_t nRejected = 0, nTube = 0, nTube200 = 0, nLoopers = 0, nLowPt = 0, n200MeV = 0, nPhysics = 0, nProt = 0, nUnattached = 0, nTotal = 0, nHighIncl = 0, nAbove400 = 0, nFakeRemove400 = 0, nFullFakeRemove400 = 0, nBelow40 = 0, nFakeProtect40 = 0;
+    int64_t nMergedLooperConnected = 0, nMergedLooperUnconnected = 0, nCorrectlyAttachedNormalized = 0, nCorrectlyAttachedNormalizedNonFake = 0;
     double nUnaccessible = 0;
   } mClusterCounts;
 

From 21a985f98fc92f3dcc2d3187cfe56369782a0b31 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Jul 2025 11:47:33 +0200
Subject: [PATCH 0810/1764] GPU TPC: Order legs in descending way and store leg
 id per track not cluster

---
 .../GPUTPCCompressionKernels.cxx              |  8 +--
 .../DataTypes/GPUTPCGMMergedTrackHit.h        |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h  |  3 ++
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 26 ++++------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  1 -
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   | 10 ++--
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 52 +++++--------------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |  2 +-
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |  9 ----
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.h   |  2 +-
 .../display/render/GPUDisplayDraw.cxx         | 22 +++++---
 GPU/GPUTracking/qa/GPUQA.cxx                  |  2 +-
 12 files changed, 52 insertions(+), 87 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 73b195e8f4fe4..5503eeb30cdd6 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -32,7 +32,6 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
   GPUTPCCompression& GPUrestrict() compressor = processors.tpcCompressor;
   const GPUParam& GPUrestrict() param = processors.param;
 
-  uint8_t lastLeg = 0;
   int32_t myTrack = 0;
   for (uint32_t i = get_global_id(0); i < ioPtrs.nMergedTracks; i += get_global_size(0)) {
     GPUbarrierWarp();
@@ -75,9 +74,6 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
         if ((hit.sector < GPUCA_NSECTORS) ^ (lastSector < GPUCA_NSECTORS)) {
           break;
         }
-        if (lastLeg != hit.leg && track.Mirror()) {
-          break;
-        }
         if (track.Propagate(geo.Row2X(hit.row), param.SectorParam[hit.sector].Alpha)) {
           break;
         }
@@ -93,7 +89,6 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
 
         myTrack = CAMath::AtomicAdd(&compressor.mMemory->nStoredTracks, 1u);
         compressor.mAttachedClusterFirstIndex[myTrack] = trk.FirstClusterRef();
-        lastLeg = hit.leg;
         c.qPtA[myTrack] = qpt;
         c.rowA[myTrack] = hit.row;
         c.sliceA[myTrack] = hit.sector;
@@ -114,12 +109,11 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
           sector -= lastSector;
         }
         c.rowDiffA[cidx] = row;
-        c.sliceLegDiffA[cidx] = (hit.leg == lastLeg ? 0 : compressor.NSECTORS) + sector;
+        c.sliceLegDiffA[cidx] = sector;
         float pad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_ROW_COUNT - 1), track.LinearY2Pad(hit.sector, track.Y(), geo.PadWidth(hit.row), geo.NPads(hit.row))));
         c.padResA[cidx] = orgCl.padPacked - orgCl.packPad(pad);
         float time = CAMath::Max(0.f, geo.LinearZ2Time(hit.sector, track.Z() + zOffset));
         c.timeResA[cidx] = (orgCl.getTimePacked() - orgCl.packTime(time)) & 0xFFFFFF;
-        lastLeg = hit.leg;
       }
       uint16_t qtot = orgCl.qTot, qmax = orgCl.qMax;
       uint8_t sigmapad = orgCl.sigmaPadPacked, sigmatime = orgCl.sigmaTimePacked;
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h b/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
index a5f0c1a55e2b9..a965f306dac79 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
@@ -21,7 +21,7 @@ namespace o2::gpu
 {
 struct GPUTPCGMMergedTrackHit {
   uint32_t num;
-  uint8_t sector, row, leg, state;
+  uint8_t sector, row, state;
 
   // NOTE: the lower states must match those from ClusterNative!
   // TODO: take them directly from clusterNative header.
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 483cbc15998bc..1ea6ab10918d5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -49,6 +49,7 @@ class GPUTPCGMMergedTrack
   GPUd() bool MergedLooperConnected() const { return mFlags & 0x20; }
   GPUd() bool MergedLooper() const { return mFlags & 0x30; }
   GPUd() int32_t PrevSegment() const { return mPrevSegment; }
+  GPUd() uint8_t Leg() const { return mLeg; }
   GPUd() uint8_t Flags() const { return mFlags; }
 
   GPUd() void SetNClusters(int32_t v) { mNClusters = v; }
@@ -57,6 +58,7 @@ class GPUTPCGMMergedTrack
   GPUd() void SetParam(const GPUTPCGMTrackParam& v) { mParam = v; }
   GPUd() void SetAlpha(float v) { mAlpha = v; }
   GPUd() void SetPrevSegment(int32_t v) { mPrevSegment = v; }
+  GPUd() void SetLeg(uint8_t v) { mLeg = v; }
   GPUd() void SetOK(bool v)
   {
     if (v) {
@@ -121,6 +123,7 @@ class GPUTPCGMMergedTrack
   uint32_t mNClusters;       //* number of track clusters
   uint32_t mNClustersFitted; //* number of clusters used in fit
   uint8_t mFlags;
+  uint8_t mLeg;
 
 #if !defined(GPUCA_STANDALONE)
   ClassDefNV(GPUTPCGMMergedTrack, 0);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 3e2eae2e2ad6b..81e96af47152d 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -179,7 +179,6 @@ void GPUTPCGMMerger::CheckMergedTracks()
     if (track.PrevNeighbour() >= 0) {
       continue;
     }
-    int32_t leg = 0;
     GPUTPCGMSectorTrack *trbase = &track, *tr = &track;
     while (true) {
       int32_t iTrk = tr - mSectorTrackInfos;
@@ -200,7 +199,6 @@ void GPUTPCGMMerger::CheckMergedTracks()
         if (tr->PrevSegmentNeighbour() >= 0) {
           break;
         }
-        leg++;
         continue;
       }
       break;
@@ -1463,7 +1461,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
   int32_t leg = 0;
   int32_t lastMergedSegment = -1;
   while (true) {
-    if (trbase) {
+    if (trbase && !Param().rec.tpc.dropLoopers) {
       int32_t jtr = trbase->NextNeighbour();
       if (jtr >= 0) {
         trbase = &(mSectorTrackInfos[jtr]);
@@ -1471,7 +1469,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
           trbase = nullptr;
         } else {
           trbase->SetPrevSegmentNeighbour(1000000001);
-          leg++;
+          leg--;
         }
       } else {
         trbase = nullptr;
@@ -1492,7 +1490,12 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       }
       itr += nThreads * nBlocks;
       trbase->SetPrevSegmentNeighbour(1000000000);
+      int32_t jtr = trbase->NextNeighbour();
       leg = 0;
+      while (jtr >= 0) {
+        leg++;
+        jtr = mSectorTrackInfos[jtr].NextNeighbour();
+      }
       lastMergedSegment = -1;
     }
 
@@ -1535,7 +1538,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       }
 
       // unpack and sort clusters
-      if (nParts > 1 && leg == 0) {
+      if (nParts > 1) {
         GPUCommonAlgorithm::sort(trackParts, trackParts + nParts, [](const GPUTPCGMSectorTrack* a, const GPUTPCGMSectorTrack* b) {
           GPUCA_DETERMINISTIC_CODE( // clang-format off
             if (a->X() != b->X()) {
@@ -1554,11 +1557,6 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         });
       }
 
-      if (Param().rec.tpc.dropLoopers && leg > 0) {
-        nParts = 1;
-        leg = 0;
-      }
-
       trackCluster trackClusters[kMaxClusters];
       nHits = 0;
       for (int32_t ipart = 0; ipart < nParts; ipart++) {
@@ -1570,7 +1568,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
           const GPUTPCTracker& trk = GetConstantMem()->tpcTrackers[t->Sector()];
           const GPUTPCHitId& ic = trk.TrackHits()[t->OrigTrack()->FirstHitID() + i];
           uint32_t id = trk.Data().ClusterDataIndex(trk.Data().Row(ic.RowIndex()), ic.HitIndex()) + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[t->Sector()][0];
-          *c2 = trackCluster{id, (uint8_t)ic.RowIndex(), t->Sector(), t->Leg()};
+          *c2 = trackCluster{id, (uint8_t)ic.RowIndex(), t->Sector()};
         }
         nHits += nTrackHits;
       }
@@ -1651,7 +1649,6 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         cl[i].row = trackClusters[i].row;
         cl[i].num = trackClusters[i].id;
         cl[i].sector = trackClusters[i].sector;
-        cl[i].leg = trackClusters[i].leg;
       }
 
       uint32_t iOutputTrack = CAMath::AtomicAdd(&mMemory->nMergedTracks, 1u);
@@ -1664,7 +1661,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       GPUTPCGMMergedTrack& mergedTrack = mMergedTracks[iOutputTrack];
       mergedTrack.SetFlags(0);
       mergedTrack.SetOK(true);
-      mergedTrack.SetLooper(leg > 0 || trbase->NextNeighbour() >= 0);
+      mergedTrack.SetLooper(leg > 0 || lastMergedSegment >= 0);
       mergedTrack.SetNClusters(nHits);
       mergedTrack.SetFirstClusterRef(iMergedTrackFirstCluster);
       GPUTPCGMTrackParam& p1 = mergedTrack.Param();
@@ -1799,7 +1796,6 @@ GPUd() void GPUTPCGMMerger::Finalize1(int32_t nBlocks, int32_t nThreads, int32_t
     if (!trk.OK() || trk.NClusters() == 0) {
       continue;
     }
-    uint8_t goodLeg = mClusters[trk.FirstClusterRef() + trk.NClusters() - 1].leg;
     for (uint32_t j = 0; j < trk.NClusters(); j++) {
       int32_t id = mClusters[trk.FirstClusterRef() + j].num;
       uint32_t weight = mTrackOrderAttach[i] | attachAttached;
@@ -1809,7 +1805,7 @@ GPUd() void GPUTPCGMMerger::Finalize1(int32_t nBlocks, int32_t nThreads, int32_t
       } else if (clusterState & GPUTPCGMMergedTrackHit::flagHighIncl) {
         weight |= attachHighIncl;
       }
-      if (mClusters[trk.FirstClusterRef() + j].leg == goodLeg) {
+      if (trk.Leg() == 0) {
         weight |= attachGoodLeg;
       }
       CAMath::AtomicMax(&mClusterAttachment[id], weight);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 54a541ebe0fd6..76f3f3cdcba08 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -82,7 +82,6 @@ class GPUTPCGMMerger : public GPUProcessor
     uint32_t id;
     uint8_t row;
     uint8_t sector;
-    uint8_t leg;
   };
 
   struct tmpSort {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 74a8df388d163..b10b1d0510fd7 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -65,14 +65,15 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
     if (!tracks[i].OK()) {
       continue;
     }
+    if (merger.Param().rec.tpc.dropSecondaryLegsInOutput && tracks[i].MergedLooper()) {
+      continue;
+    }
+
     uint32_t nCl = 0;
     for (uint32_t j = 0; j < tracks[i].NClusters(); j++) {
       if ((trackClusters[tracks[i].FirstClusterRef() + j].state & flagsReject) || (merger.ClusterAttachment()[trackClusters[tracks[i].FirstClusterRef() + j].num] & flagsRequired) != flagsRequired) {
         continue;
       }
-      if (merger.Param().rec.tpc.dropSecondaryLegsInOutput && trackClusters[tracks[i].FirstClusterRef() + j].leg != trackClusters[tracks[i].FirstClusterRef() + tracks[i].NClusters() - 1].leg) {
-        continue;
-      }
       nCl++;
     }
     if (nCl == 0) {
@@ -192,9 +193,6 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
       if ((trackClusters[tracks[i].FirstClusterRef() + j].state & flagsReject) || (merger.ClusterAttachment()[trackClusters[tracks[i].FirstClusterRef() + j].num] & flagsRequired) != flagsRequired) {
         continue;
       }
-      if (merger.Param().rec.tpc.dropSecondaryLegsInOutput && trackClusters[tracks[i].FirstClusterRef() + j].leg != trackClusters[tracks[i].FirstClusterRef() + tracks[i].NClusters() - 1].leg) {
-        continue;
-      }
       int32_t clusterIdGlobal = trackClusters[tracks[i].FirstClusterRef() + j].num;
       int32_t sector = trackClusters[tracks[i].FirstClusterRef() + j].sector;
       int32_t globalRow = trackClusters[tracks[i].FirstClusterRef() + j].row;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 1c74bb4a9b2c5..c76d8f6ab4409 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -54,7 +54,7 @@
 using namespace o2::gpu;
 using namespace o2::tpc;
 
-GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_t iTrk, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, GPUTPCGMMergedTrackHitXYZ* GPUrestrict() clustersXYZ, int32_t& GPUrestrict() N, int32_t& GPUrestrict() NTolerated, float& GPUrestrict() Alpha, int32_t attempt, float maxSinPhi, gputpcgmmergertypes::GPUTPCOuterParam* GPUrestrict() outerParam)
+GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_t iTrk, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, GPUTPCGMMergedTrackHitXYZ* GPUrestrict() clustersXYZ, int32_t& GPUrestrict() N, int32_t& GPUrestrict() NTolerated, float& GPUrestrict() Alpha, int32_t attempt, float maxSinPhi, gputpcgmmergertypes::GPUTPCOuterParam* GPUrestrict() outerParam, int8_t leg)
 {
   static constexpr float kDeg2Rad = M_PI / 180.f;
   CADEBUG(static constexpr float kSectAngle = 2 * M_PI / 18.f);
@@ -83,22 +83,15 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
   float lastUpdateX = -1.f;
   uint8_t lastRow = 255;
   uint8_t lastSector = 255;
-  uint8_t storeOuter = 0;
 
   for (int32_t iWay = 0; iWay < nWays; iWay++) {
     int32_t nMissed = 0, nMissed2 = 0;
     float sumInvSqrtCharge = 0.f;
     int32_t nAvgCharge = 0;
 
-    if (iWay && storeOuter != 255 && param.rec.tpc.nWaysOuter && outerParam) {
-      storeOuter = 0;
+    if (iWay && param.rec.tpc.nWaysOuter && outerParam) {
       if (iWay == nWays - 1) {
         StoreOuter(outerParam, prop, 0);
-        if (merger->MergedTracks()[iTrk].Looper()) {
-          storeOuter = 1;
-        }
-      } else if (iWay == nWays - 2 && merger->MergedTracks()[iTrk].Looper()) {
-        storeOuter = 2;
       }
     }
 
@@ -117,8 +110,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
     N = 0;
     lastUpdateX = -1;
-    const bool inFlyDirection = iWay & 1;
-    uint8_t lastLeg = clusters[ihitStart].leg;
+    const bool inFlyDirection = (leg & 1);
     const int32_t wayDirection = (iWay & 1) ? -1 : 1;
 
     bool noFollowCircle = false, noFollowCircle2 = false;
@@ -130,15 +122,6 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         noFollowCircle2 = true;
       }
 
-      if (storeOuter == 2 && clusters[ihit].leg == clusters[maxN - 1].leg - 1) {
-        if (lastLeg == clusters[maxN - 1].leg) {
-          StoreOuter(outerParam, prop, 1);
-          storeOuter = 255;
-        } else {
-          storeOuter = 0;
-        }
-      }
-
       if ((param.rec.tpc.trackFitRejectMode > 0 && nMissed >= param.rec.tpc.trackFitRejectMode) || nMissed2 >= param.rec.tpc.trackFitMaxRowMissedHard || clusters[ihit].state & GPUTPCGMMergedTrackHit::flagReject) {
         CADEBUG(printf("\tSkipping hit, %d hits rejected, flag %X\n", nMissed, (int32_t)clusters[ihit].state));
         if (iWay + 2 >= nWays && !(clusters[ihit].state & GPUTPCGMMergedTrackHit::flagReject)) {
@@ -183,12 +166,10 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
       const auto& cluster = clusters[ihit];
 
-      bool changeDirection = (cluster.leg - lastLeg) & 1;
       // clang-format off
-      CADEBUG(if (changeDirection) printf("\t\tChange direction\n"));
-      CADEBUG(printf("\tLeg %3d Sector %2d %4sTrack   Alpha %8.3f %s, X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", (int32_t)cluster.leg, (int32_t)cluster.sector, "", prop.GetAlpha(), (CAMath::Abs(prop.GetAlpha() - clAlpha) < 0.01 ? "   " : " R!"), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
+      CADEBUG(printf("\tSector %2d %4sTrack   Alpha %8.3f %s, X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", (int32_t)cluster.sector, "", prop.GetAlpha(), (CAMath::Abs(prop.GetAlpha() - clAlpha) < 0.01 ? "   " : " R!"), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
       // clang-format on
-      if (allowModification && changeDirection && !noFollowCircle && !noFollowCircle2) {
+      if (allowModification && false /*changeDirection*/ && !noFollowCircle && !noFollowCircle2) {
         if (lastRow != 255) {
           if (!(merger->Param().rec.tpc.disableRefitAttachment & 4)) {
             StoreAttachMirror(merger, lastSector, lastRow, iTrk, clAlpha, yy, xx, cluster.sector, cluster.row, inFlyDirection, prop.GetAlpha());
@@ -197,8 +178,8 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         }
       } else if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
-          bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2 && cluster.leg == clusters[maxN - 1].leg;
-          dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, cluster.leg == clusters[maxN - 1].leg, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
+          bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2;
+          dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, leg == 0, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
           if (dodEdx) {
             dEdx.fillSubThreshold(lastRow - wayDirection);
             if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMask) != GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMaskAlt)) {
@@ -244,7 +225,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         }
       }
 
-      if (err == 0 && changeDirection) {
+      if (err == 0 && false /*changeDirection*/) {
         const float mirrordY = prop.GetMirroredYTrack();
         CADEBUG(printf(" -- MirroredY: %f --> %f", mP[0], mirrordY));
         if (CAMath::Abs(yy - mP[0]) > CAMath::Abs(yy - mirrordY)) {
@@ -256,7 +237,6 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           noFollowCircle = false;
 
           lastUpdateX = mX;
-          lastLeg = cluster.leg;
           lastRow = 255;
           N++;
           resetT0 = initResetT0();
@@ -270,7 +250,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
       float uncorrectedY = -1e6f;
       if (allowModification) {
-        uncorrectedY = AttachClusters(merger, cluster.sector, cluster.row, iTrk, cluster.leg == clusters[maxN - 1].leg, prop);
+        uncorrectedY = AttachClusters(merger, cluster.sector, cluster.row, iTrk, leg == 0, prop);
       }
 
       const int32_t err2 = mNDF > 0 && CAMath::Abs(prop.GetSinPhi0()) >= maxSinForUpdate;
@@ -334,10 +314,6 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       ConstrainSinPhi();
       if (retVal == 0) // track is updated
       {
-        if (storeOuter == 1 && cluster.leg == clusters[maxN - 1].leg) {
-          StoreOuter(outerParam, prop, 2);
-          storeOuter = 255;
-        }
         noFollowCircle2 = false;
         lastUpdateX = mX;
         covYYUpd = mC[0];
@@ -352,7 +328,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           prop.SetTrack(this, prop.GetAlpha());
         }
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
-          if (param.dodEdxEnabled && iWay == nWays - 1 && cluster.leg == clusters[maxN - 1].leg) { // TODO: Costimize flag to remove, and option to remove double-clusters
+          if (param.dodEdxEnabled && iWay == nWays - 1) { // TODO: Costimize flag to remove, and option to remove double-clusters
             bool acc = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMask) == 0, accAlt = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) == 0;
             if (acc || accAlt) {
               float qtot = 0, qmax = 0, pad = 0, relTime = 0;
@@ -486,7 +462,7 @@ GPUd() void GPUTPCGMTrackParam::MirrorTo(GPUTPCGMPropagator& GPUrestrict() prop,
 
 GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t wayDirection, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, const GPUTPCGMMerger* GPUrestrict() merger, GPUTPCGMPropagator& GPUrestrict() prop, float& GPUrestrict() xx, float& GPUrestrict() yy, float& GPUrestrict() zz, int32_t maxN, float clAlpha, uint8_t& GPUrestrict() clusterState, bool rejectChi2)
 {
-  if (ihit + wayDirection >= 0 && ihit + wayDirection < maxN && clusters[ihit].row == clusters[ihit + wayDirection].row && clusters[ihit].sector == clusters[ihit + wayDirection].sector && clusters[ihit].leg == clusters[ihit + wayDirection].leg) {
+  if (ihit + wayDirection >= 0 && ihit + wayDirection < maxN && clusters[ihit].row == clusters[ihit + wayDirection].row && clusters[ihit].sector == clusters[ihit + wayDirection].sector) {
     float maxDistY, maxDistZ;
     prop.GetErr2(maxDistY, maxDistZ, merger->Param(), zz, clusters[ihit].row, 0, clusters[ihit].sector, -1.f, 0.f, 0.f); // TODO: Use correct time, avgCharge
     maxDistY = (maxDistY + mC[0]) * 20.f;
@@ -530,7 +506,7 @@ GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t
         clusterState |= clusters[ihit].state;
         count += clamp;
       }
-      if (!(ihit + wayDirection >= 0 && ihit + wayDirection < maxN && clusters[ihit].row == clusters[ihit + wayDirection].row && clusters[ihit].sector == clusters[ihit + wayDirection].sector && clusters[ihit].leg == clusters[ihit + wayDirection].leg)) {
+      if (!(ihit + wayDirection >= 0 && ihit + wayDirection < maxN && clusters[ihit].row == clusters[ihit + wayDirection].row && clusters[ihit].sector == clusters[ihit + wayDirection].sector)) {
         break;
       }
       ihit += wayDirection;
@@ -1071,7 +1047,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
   GPUTPCGMTrackParam t = track.Param();
   float Alpha = track.Alpha();
   CADEBUG(int32_t nTrackHitsOld = nTrackHits; float ptOld = t.QPt());
-  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), merger->Param().par.earlyTpcTransform ? merger->ClustersXYZ() + track.FirstClusterRef() : nullptr, nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, &track.OuterParam());
+  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), merger->Param().par.earlyTpcTransform ? merger->ClustersXYZ() + track.FirstClusterRef() : nullptr, nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, &track.OuterParam(), track.Leg());
   CADEBUG(printf("Finished Fit Track %d\n", iTrk));
   CADEBUG(printf("OUTPUT hits %d -> %d+%d = %d, QPt %f -> %f, SP %f, ok %d chi2 %f chi2ndf %f\n", nTrackHitsOld, nTrackHits, NTolerated, nTrackHits + NTolerated, ptOld, t.QPt(), t.SinPhi(), (int32_t)ok, t.Chi2(), t.Chi2() / CAMath::Max(1, nTrackHits)));
 
@@ -1085,7 +1061,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
       NTolerated = 0; // Clusters not fit but tollerated for track length cut
       t = track.Param();
       Alpha = track.Alpha();
-      ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), merger->ClustersXYZ() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, 1, GPUCA_MAX_SIN_PHI, &track.OuterParam());
+      ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), merger->ClustersXYZ() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, 1, GPUCA_MAX_SIN_PHI, &track.OuterParam(), track.Leg());
     } else {
       uint32_t nRefit = CAMath::AtomicAdd(&merger->Memory()->nRetryRefit, 1u);
       merger->RetryRefitIds()[nRefit] = iTrk;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index 90ff3154a3fe9..3412388003ec6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -141,7 +141,7 @@ class GPUTPCGMTrackParam
   GPUd() bool CheckNumericalQuality(float overrideCovYY = -1.f) const;
   GPUd() bool CheckCov() const;
 
-  GPUd() bool Fit(GPUTPCGMMerger* merger, int32_t iTrk, GPUTPCGMMergedTrackHit* clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, int32_t& N, int32_t& NTolerated, float& Alpha, int32_t attempt = 0, float maxSinPhi = GPUCA_MAX_SIN_PHI, gputpcgmmergertypes::GPUTPCOuterParam* outerParam = nullptr);
+  GPUd() bool Fit(GPUTPCGMMerger* merger, int32_t iTrk, GPUTPCGMMergedTrackHit* clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, int32_t& N, int32_t& NTolerated, float& Alpha, int32_t attempt = 0, float maxSinPhi = GPUCA_MAX_SIN_PHI, gputpcgmmergertypes::GPUTPCOuterParam* outerParam = nullptr, int8_t leg = 0);
   GPUd() void MoveToReference(GPUTPCGMPropagator& prop, const GPUParam& param, float& alpha);
   GPUd() void MirrorTo(GPUTPCGMPropagator& prop, float toY, float toZ, bool inFlyDirection, const GPUParam& param, uint8_t row, uint8_t clusterState, bool mirrorParameters, int8_t sector);
   GPUd() int32_t MergeDoubleRowClusters(int32_t& ihit, int32_t wayDirection, GPUTPCGMMergedTrackHit* clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, const GPUTPCGMMerger* merger, GPUTPCGMPropagator& prop, float& xx, float& yy, float& zz, int32_t maxN, float clAlpha, uint8_t& clusterState, bool rejectChi2);
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index 3f342c6111f04..29ccab2a765da 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -223,15 +223,6 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
   float tOffset;
   if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
     count = trkX.NClusters();
-    if (trkX.Looper()) {
-      int32_t leg = mPtrackHits[trkX.FirstClusterRef() + trkX.NClusters() - 1].leg;
-      for (int32_t i = trkX.NClusters() - 2; i > 0; i--) {
-        if (mPtrackHits[trkX.FirstClusterRef() + i].leg != leg) {
-          begin = i + 1;
-          break;
-        }
-      }
-    }
     tOffset = trkX.GetParam().GetTZOffset();
   } else if constexpr (std::is_same_v<T, TrackTPC>) {
     count = trkX.getNClusters();
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
index 431fa357e8b89..f8fa0342ee62d 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
@@ -101,7 +101,7 @@ class GPUTRDTracker_t : public GPUProcessor
   {
     return true;
   }
-  GPUd() bool PreCheckTrackTRDCandidate(const GPUTPCGMMergedTrack& trk) const { return trk.OK() && !trk.Looper(); }
+  GPUd() bool PreCheckTrackTRDCandidate(const GPUTPCGMMergedTrack& trk) const { return trk.OK() && !trk.MergedLooper(); }
   GPUd() bool CheckTrackTRDCandidate(const TRDTRK& trk) const;
   GPUd() int32_t LoadTrack(const TRDTRK& trk, uint32_t tpcTrackId, bool checkTrack = true, HelperTrackAttributes* attribs = nullptr);
 
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 43de5a1d5011a..679d5a6cf88fd 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -434,6 +434,16 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
       // Print TPC part of track
       int32_t separateExtrapolatedTracksLimit = (mCfgH.separateExtrapolatedTracks ? tEXTRAPOLATEDTRACK : TRACK_TYPE_ID_LIMIT);
       uint32_t lastSide = -1;
+      int32_t prevcid = -1;
+      int32_t leg = 0;
+      if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
+        if (track->PrevSegment() >= 0) {
+          const auto& prevtrk = mIOPtrs->mergedTracks[track->PrevSegment()];
+          prevcid = mIOPtrs->mergedTrackHits[prevtrk.FirstClusterRef() + ((track->Leg() & 1) ? (prevtrk.NClusters() - 1) : 0)].num;
+          leg = track->Leg();
+        }
+      }
+
       for (int32_t k = 0; k < nClusters; k++) {
         if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
           if (mCfgH.hideRejectedClusters && (mIOPtrs->mergedTrackHits[track->FirstClusterRef() + k].state & GPUTPCGMMergedTrackHit::flagReject)) {
@@ -464,13 +474,6 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
         } else {
           if (!drawing) {
             startCountInner = mVertexBuffer[iSector].size();
-            if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
-              if (k == 0 && track->PrevSegment() >= 0) {
-                const auto& prevtrk = mIOPtrs->mergedTracks[track->PrevSegment()];
-                int32_t prevcid = mIOPtrs->mergedTrackHits[prevtrk.FirstClusterRef() + prevtrk.NClusters() - 1].num;
-                drawPointLinestrip(iSector, prevcid, tFINALTRACK, separateExtrapolatedTracksLimit);
-              }
-            }
             if (lastCluster != -1 && (!mCfgH.splitCETracks || lastSide == (mGlobalPos[cid].z < 0))) {
               int32_t lastcid;
               if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
@@ -479,6 +482,8 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
                 lastcid = &track->getCluster(mIOPtrs->outputClusRefsTPCO2, lastCluster, *mIOPtrs->clustersNative) - mIOPtrs->clustersNative->clustersLinear;
               }
               drawPointLinestrip(iSector, lastcid, tFINALTRACK, separateExtrapolatedTracksLimit);
+            } else if (prevcid != -1 && k == 0 && (leg & 1) == 0) {
+              drawPointLinestrip(iSector, prevcid, tFINALTRACK, separateExtrapolatedTracksLimit);
             }
             drawPointLinestrip(iSector, cid, tFINALTRACK, separateExtrapolatedTracksLimit);
           }
@@ -487,6 +492,9 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
         lastCluster = k;
         lastSide = mGlobalPos[cid].z < 0;
       }
+      if (prevcid != -1 && (leg & 1) && drawing) {
+        drawPointLinestrip(iSector, prevcid, tFINALTRACK, separateExtrapolatedTracksLimit);
+      }
 
       // Print ITS part of track
       if constexpr (std::is_same_v<T, o2::tpc::TrackTPC>) {
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index dcc2a37992a05..aa4db98d0b71a 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -1704,7 +1704,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           }
           rowClCount += !(trackClusters[track.FirstClusterRef() + jNext].state & GPUTPCGMMergedTrackHit::flagReject);
         }
-        if (trackClusters[track.FirstClusterRef() + j].leg == trackClusters[track.FirstClusterRef() + track.NClusters() - 1].leg && rowClCount) {
+        if (!track.MergedLooper() && rowClCount) {
           nClCorrected++;
         }
         if (mcAvail && rowClCount) {

From 47f2193ca90a31465291e33edfc1fad44f3c4b59 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Jul 2025 12:15:36 +0200
Subject: [PATCH 0811/1764] GPU TPC: 16 bits are enough for nclusters

---
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 1ea6ab10918d5..60be206ed7e42 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -119,9 +119,8 @@ class GPUTPCGMMergedTrack
   float mAlpha;              //* alpha angle
   uint32_t mFirstClusterRef; //* index of the first track cluster in corresponding cluster arrays
   int32_t mPrevSegment;      //* next segment in case of looping track
-  // TODO: Change to 8 bit
-  uint32_t mNClusters;       //* number of track clusters
-  uint32_t mNClustersFitted; //* number of clusters used in fit
+  uint16_t mNClusters;       //* number of track clusters
+  uint16_t mNClustersFitted; //* number of clusters used in fit
   uint8_t mFlags;
   uint8_t mLeg;
 

From 7b966cddbe779645ef37b1a8f7348fac52fe61b1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Jul 2025 13:12:21 +0200
Subject: [PATCH 0812/1764] GPU Display: Make 'none' frontend and backend work

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  1 +
 .../Standalone/Benchmark/standalone.cxx       |  4 +-
 GPU/GPUTracking/display/CMakeLists.txt        |  2 +
 .../display/backend/GPUDisplayBackend.cxx     |  4 +-
 .../display/backend/GPUDisplayBackend.h       |  3 +-
 .../display/backend/GPUDisplayBackendNone.cxx | 30 ++++++++++++
 .../display/backend/GPUDisplayBackendNone.h   | 49 +++++++++++++++++++
 .../display/frontend/GPUDisplayFrontend.cxx   | 33 +++++++++++--
 .../display/frontend/GPUDisplayFrontend.h     |  5 +-
 .../frontend/GPUDisplayFrontendGlfw.cxx       | 11 -----
 .../display/frontend/GPUDisplayFrontendGlfw.h |  1 -
 .../frontend/GPUDisplayFrontendGlut.cxx       | 10 ----
 .../display/frontend/GPUDisplayFrontendGlut.h |  1 -
 .../frontend/GPUDisplayFrontendNone.cxx       | 19 +++++++
 .../display/frontend/GPUDisplayFrontendNone.h |  7 ++-
 .../frontend/GPUDisplayFrontendWayland.cxx    | 10 ----
 .../frontend/GPUDisplayFrontendWayland.h      |  1 -
 .../frontend/GPUDisplayFrontendWindows.cxx    | 10 ----
 .../frontend/GPUDisplayFrontendWindows.h      |  1 -
 .../frontend/GPUDisplayFrontendX11.cxx        | 12 +----
 .../display/frontend/GPUDisplayFrontendX11.h  |  6 +--
 21 files changed, 150 insertions(+), 70 deletions(-)
 create mode 100644 GPU/GPUTracking/display/backend/GPUDisplayBackendNone.cxx
 create mode 100644 GPU/GPUTracking/display/backend/GPUDisplayBackendNone.h

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 79e9ce6cef766..b0ea052063f20 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -826,6 +826,7 @@ int32_t GPUChainTracking::RunChainFinalize()
     if (!mDisplayRunning) {
       GPUInfo("Starting Event Display...");
       if (mEventDisplay->StartDisplay()) {
+        GPUError("Error starting Event Display");
         return (1);
       }
       mDisplayRunning = true;
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 5240b5ca47967..1b1cb510af7be 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -703,10 +703,10 @@ int32_t RunBenchmark(GPUReconstruction* recUse, GPUChainTracking* chainTrackingU
       configStandalone.noprompt = 1;
     }
     if (tmpRetVal == 3 && configStandalone.proc.ignoreNonFatalGPUErrors) {
-      printf("Non-FATAL GPU error occured, ignoring\n");
+      printf("GPU Standalone Benchmark: Non-FATAL GPU error occured, ignoring\n");
     } else if (tmpRetVal && !configStandalone.continueOnError) {
       if (tmpRetVal != 2) {
-        printf("Error occured\n");
+        printf("GPU Standalone Benchmark: Error occured\n");
       }
       return 1;
     }
diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index 25b028d573bcf..32d25ee08b729 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -55,7 +55,9 @@ set(SRCS ../utils/qsem.cxx
          helpers/GPUDisplayMagneticField.cxx
          frontend/GPUDisplayFrontend.cxx
          frontend/GPUDisplayFrontendGlfw.cxx
+         frontend/GPUDisplayFrontendNone.cxx
          backend/GPUDisplayBackend.cxx
+         backend/GPUDisplayBackendNone.cxx
          backend/GPUDisplayBackendOpenGL.cxx)
 
 set(SRCS_NO_H helpers/GPUDisplayLoader.cxx
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
index 98d2593c27950..3694ab93398cc 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
@@ -16,7 +16,7 @@
 #include "helpers/GPUDisplayMagneticField.h"
 
 #include "GPUDisplayBackendOpenGL.h"
-
+#include "GPUDisplayBackendNone.h"
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
 #include "GPUDisplayBackendVulkan.h"
 #endif
@@ -51,6 +51,8 @@ GPUDisplayBackend* GPUDisplayBackend::getBackend(const char* type)
 #endif
   if (strcmp(type, "opengl") == 0 || strcmp(type, "auto") == 0) {
     return new GPUDisplayBackendOpenGL;
+  } else if (strcmp(type, "none") == 0) {
+    return new GPUDisplayBackendNone;
   } else {
     GPUError("Requested renderer not available");
   }
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackend.h b/GPU/GPUTracking/display/backend/GPUDisplayBackend.h
index dc56dedf587ed..546c53e1e63ff 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackend.h
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackend.h
@@ -57,7 +57,8 @@ class GPUDisplayBackend
   enum backendTypes {
     TYPE_INVALID = -1,
     TYPE_OPENGL = 0,
-    TYPE_VULKAN = 1
+    TYPE_VULKAN = 1,
+    TYPE_NONE = 2
   };
 
   struct DrawArraysIndirectCommand {
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendNone.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendNone.cxx
new file mode 100644
index 0000000000000..c0011265dbe52
--- /dev/null
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendNone.cxx
@@ -0,0 +1,30 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDisplayBackendNone.cxx
+/// \author David Rohr
+
+#include "GPUCommonDef.h"
+#include "GPUDisplayBackendNone.h"
+
+using namespace o2::gpu;
+
+GPUDisplayBackendNone::GPUDisplayBackendNone()
+{
+  mBackendType = TYPE_NONE;
+  mBackendName = "NONE";
+}
+
+int32_t GPUDisplayBackendNone::InitBackendA()
+{
+
+  return 0;
+}
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendNone.h b/GPU/GPUTracking/display/backend/GPUDisplayBackendNone.h
new file mode 100644
index 0000000000000..4af69692d79c1
--- /dev/null
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendNone.h
@@ -0,0 +1,49 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDisplayBackendNone.h
+/// \author David Rohr
+
+#ifndef GPUDISPLAYBACKENDNONE_H
+#define GPUDISPLAYBACKENDNONE_H
+
+#include "GPUDisplayBackend.h"
+
+namespace o2::gpu
+{
+class GPUDisplayBackendNone : public GPUDisplayBackend
+{
+ public:
+  GPUDisplayBackendNone();
+  ~GPUDisplayBackendNone() override = default;
+
+ protected:
+  uint32_t DepthBits() override { return 32; };
+  uint32_t drawVertices(const vboList& v, const drawType t) override { return 0; }
+  void ActivateColor(std::array<float, 4>& color) override {}
+  void setDepthBuffer() override {}
+  int32_t InitBackendA() override;
+  void ExitBackendA() override {}
+  void loadDataToGPU(size_t totalVertizes) override {}
+  void prepareDraw(const hmm_mat4& proj, const hmm_mat4& view, bool requestScreenshot, bool toMixBuffer, float includeMixImage) override {}
+  void finishDraw(bool doScreenshot, bool toMixBuffer, float includeMixImage) override {}
+  void finishFrame(bool doScreenshot, bool toMixBuffer, float includeMixImage) override {}
+  void prepareText() override {}
+  void finishText() override {}
+  void pointSizeFactor(float factor) override {}
+  void lineWidthFactor(float factor) override {}
+  void OpenGLPrint(const char* s, float x, float y, float* color, float scale) override {}
+  void addFontSymbol(int32_t symbol, int32_t sizex, int32_t sizey, int32_t offsetx, int32_t offsety, int32_t advance, void* data) override {}
+  void initializeTextDrawing() override {}
+};
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx
index 22970c3228815..df5c45c6beaa8 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.cxx
@@ -17,7 +17,11 @@
 
 #ifdef _WIN32
 #include "GPUDisplayFrontendWindows.h"
-#elif defined(GPUCA_BUILD_EVENT_DISPLAY_X11)
+#else
+#include <pthread.h>
+#endif
+
+#ifdef GPUCA_BUILD_EVENT_DISPLAY_X11
 #include "GPUDisplayFrontendX11.h"
 #endif
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_GLFW
@@ -29,6 +33,7 @@
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_WAYLAND
 #include "GPUDisplayFrontendWayland.h"
 #endif
+#include "GPUDisplayFrontendNone.h"
 
 #include "GPULogging.h"
 #include <cstring>
@@ -118,7 +123,7 @@ bool GPUDisplayFrontend::isGUIRunning()
 }
 
 GPUDisplayFrontend* GPUDisplayFrontend::getFrontend(const char* type)
-{
+{ // clang-format off
 #if !defined(GPUCA_STANDALONE) && defined(GPUCA_BUILD_EVENT_DISPLAY_GLFW)
   if (strcmp(type, "glfw") == 0 || strcmp(type, "auto") == 0) {
     return new GPUDisplayFrontendGlfw;
@@ -148,11 +153,13 @@ GPUDisplayFrontend* GPUDisplayFrontend::getFrontend(const char* type)
     return new GPUDisplayFrontendGlut;
   } else
 #endif
-  {
+  if (strcmp(type, "none") == 0) {
+    return new GPUDisplayFrontendNone;
+  } else {
     GPUError("Requested frontend not available");
   }
   return nullptr;
-}
+} // clang-format on
 
 GPUDisplayBackend* GPUDisplayFrontend::backend()
 {
@@ -163,3 +170,21 @@ int32_t& GPUDisplayFrontend::drawTextFontSize()
 {
   return mDisplay->drawTextFontSize();
 }
+
+int32_t GPUDisplayFrontend::StartDisplay()
+{
+#ifndef _WIN32
+  static pthread_t hThread;
+  if (pthread_create(&hThread, nullptr, FrontendThreadWrapper, this)) {
+    GPUError("Coult not Create frontend Thread...");
+    return (1);
+  }
+#else
+  HANDLE hThread;
+  if ((hThread = CreateThread(nullptr, nullptr, &OpenGLWrapper, this, nullptr, nullptr)) == nullptr) {
+    GPUError("Coult not Create GL Thread...");
+    return (1);
+  }
+#endif
+  return (0);
+}
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h
index 9087ec9a431f6..0abab8bb0a121 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontend.h
@@ -40,14 +40,15 @@ class GPUDisplayFrontend : public GPUDisplayFrontendInterface
     TYPE_X11 = 1,
     TYPE_GLUT = 2,
     TYPE_GLFW = 3,
-    TYPE_WAYLAND = 4
+    TYPE_WAYLAND = 4,
+    TYPE_NONE = 5
   };
 
   // Compile time minimum version defined in GPUDisplay.h, keep in sync!
   static constexpr int32_t GL_MIN_VERSION_MAJOR = 4;
   static constexpr int32_t GL_MIN_VERSION_MINOR = 5;
 
-  virtual int32_t StartDisplay() = 0;                                                                                        // Start the display. This function returns, and should spawn a thread that runs the display, and calls InitDisplay
+  int32_t StartDisplay();                                                                                                    // Start the display. This function returns, and should spawn a thread that runs the display, and calls InitDisplay
   void DisplayExit() override = 0;                                                                                           // Stop the display. Display thread should call ExitDisplay and the function returns after the thread has terminated
   virtual void SwitchFullscreen(bool set) = 0;                                                                               // Toggle full-screen mode
   virtual void ToggleMaximized(bool set) = 0;                                                                                // Maximize window
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
index 4d80917a26215..ba22f92660fd0 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
@@ -33,7 +33,6 @@ extern "C" int32_t gl3wInit();
 #include <cstdio>
 #include <cstring>
 #include <unistd.h>
-#include <pthread.h>
 
 #ifdef GPUCA_O2_LIB
 #if __has_include("../src/imgui.h")
@@ -417,16 +416,6 @@ void GPUDisplayFrontendGlfw::ToggleMaximized(bool set)
 
 void GPUDisplayFrontendGlfw::SetVSync(bool enable) { glfwSwapInterval(enable); }
 
-int32_t GPUDisplayFrontendGlfw::StartDisplay()
-{
-  static pthread_t hThread;
-  if (pthread_create(&hThread, nullptr, FrontendThreadWrapper, this)) {
-    GPUError("Coult not Create GL Thread...");
-    return (1);
-  }
-  return (0);
-}
-
 bool GPUDisplayFrontendGlfw::EnableSendKey()
 {
 #ifdef GPUCA_O2_LIB
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h
index 5276652a370a1..43dd3d65531dd 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h
@@ -28,7 +28,6 @@ class GPUDisplayFrontendGlfw : public GPUDisplayFrontend
   GPUDisplayFrontendGlfw();
   ~GPUDisplayFrontendGlfw() override = default;
 
-  int32_t StartDisplay() override;
   void DisplayExit() override;
   void SwitchFullscreen(bool set) override;
   void ToggleMaximized(bool set) override;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.cxx
index 334a60446a4f3..1b2f2a21150c3 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.cxx
@@ -309,13 +309,3 @@ void GPUDisplayFrontendGlut::SwitchFullscreen(bool set)
 
 void GPUDisplayFrontendGlut::ToggleMaximized(bool set) {}
 void GPUDisplayFrontendGlut::SetVSync(bool enable) {}
-
-int32_t GPUDisplayFrontendGlut::StartDisplay()
-{
-  static pthread_t hThread;
-  if (pthread_create(&hThread, nullptr, FrontendThreadWrapper, this)) {
-    GPUError("Coult not Create GL Thread...");
-    return (1);
-  }
-  return (0);
-}
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.h
index 96f8f4af6cba5..9351349e2287d 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlut.h
@@ -26,7 +26,6 @@ class GPUDisplayFrontendGlut : public GPUDisplayFrontend
   GPUDisplayFrontendGlut();
   ~GPUDisplayFrontendGlut() override = default;
 
-  int32_t StartDisplay() override;
   void DisplayExit() override;
   void SwitchFullscreen(bool set) override;
   void ToggleMaximized(bool set) override;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendNone.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendNone.cxx
index c48000bd80685..8a7eab7e00526 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendNone.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendNone.cxx
@@ -13,4 +13,23 @@
 /// \author David Rohr
 
 #include "GPUDisplayFrontendNone.h"
+#include "GPUDisplayGUIWrapper.h"
 using namespace o2::gpu;
+
+GPUDisplayFrontendNone::GPUDisplayFrontendNone()
+{
+  mFrontendType = TYPE_NONE;
+  mFrontendName = "NONE";
+}
+
+int32_t GPUDisplayFrontendNone::FrontendMain()
+{
+  if (InitDisplay()) {
+    return 1;
+  }
+  do {
+    DrawGLScene();
+    HandleSendKey();
+  } while (mDisplayControl != 2);
+  return 0;
+}
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendNone.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendNone.h
index defd759ac4df6..3c7b67c35a0ce 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendNone.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendNone.h
@@ -21,15 +21,18 @@ namespace o2::gpu
 {
 class GPUDisplayFrontendNone : public GPUDisplayFrontend
 {
-  GPUDisplayFrontendNone() = default;
+ public:
+  GPUDisplayFrontendNone();
   ~GPUDisplayFrontendNone() override = default;
 
-  int32_t StartDisplay() override { return 1; }
   void DisplayExit() override {}
   void SwitchFullscreen(bool set) override {}
   void ToggleMaximized(bool set) override {}
   void SetVSync(bool enable) override {}
   void OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton = true) override {}
+
+ private:
+  int32_t FrontendMain() override;
 };
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
index 7a652297d89d7..5a42954c90fa7 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.cxx
@@ -475,16 +475,6 @@ void GPUDisplayFrontendWayland::SetVSync(bool enable)
 {
 }
 
-int32_t GPUDisplayFrontendWayland::StartDisplay()
-{
-  static pthread_t hThread;
-  if (pthread_create(&hThread, nullptr, FrontendThreadWrapper, this)) {
-    GPUError("Coult not Create frontend Thread...");
-    return (1);
-  }
-  return (0);
-}
-
 void GPUDisplayFrontendWayland::getSize(int32_t& width, int32_t& height)
 {
   width = mDisplayWidth;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.h
index 6dfe0a361fbb6..55676c694cfef 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWayland.h
@@ -36,7 +36,6 @@ class GPUDisplayFrontendWayland : public GPUDisplayFrontend
   GPUDisplayFrontendWayland();
   ~GPUDisplayFrontendWayland() override = default;
 
-  int32_t StartDisplay() override;
   void DisplayExit() override;
   void SwitchFullscreen(bool set) override;
   void ToggleMaximized(bool set) override;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.cxx
index e511718e258f7..30148e0cb00ee 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.cxx
@@ -375,13 +375,3 @@ void OpenGLPrint(const char* s, float x, float y, float r, float g, float b, flo
 void SwitchFullscreen(bool set) {}
 void ToggleMaximized(bool set) {}
 void SetVSync(bool enable) {}
-
-int32_t GPUDisplayFrontendWindows::StartDisplay()
-{
-  HANDLE hThread;
-  if ((hThread = CreateThread(nullptr, nullptr, &OpenGLWrapper, this, nullptr, nullptr)) == nullptr) {
-    GPUError("Coult not Create GL Thread...");
-    return (1);
-  }
-  return (0);
-}
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.h
index a8534f3f0fc1f..cac5b62c4cc63 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendWindows.h
@@ -25,7 +25,6 @@ class GPUDisplayFrontendWindows : public GPUDisplayFrontend
   GPUDisplayFrontendWindows();
   ~GPUDisplayFrontendWindows() override = default;
 
-  int32_t StartDisplay() override;
   void DisplayExit() override;
   void SwitchFullscreen(bool set) override;
   void ToggleMaximized(bool set) override;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.cxx
index 96011aa064bac..be56fc8a1e546 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.cxx
@@ -23,6 +23,8 @@
 #include <stdexcept>
 #include <chrono>
 
+#include <unistd.h>
+
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
 #include <vulkan/vulkan.h>
 #include <vulkan/vulkan_xlib.h>
@@ -518,16 +520,6 @@ void GPUDisplayFrontendX11::SetVSync(bool enable)
   }
 }
 
-int32_t GPUDisplayFrontendX11::StartDisplay()
-{
-  static pthread_t hThread;
-  if (pthread_create(&hThread, nullptr, FrontendThreadWrapper, this)) {
-    GPUError("Coult not Create frontend Thread...");
-    return (1);
-  }
-  return (0);
-}
-
 void GPUDisplayFrontendX11::getSize(int32_t& width, int32_t& height)
 {
   Window root_return;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.h
index f14d05b3080bd..7ea38271f2ee9 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendX11.h
@@ -16,9 +16,10 @@
 #define GPUDISPLAYFRONTENDX11_H
 
 #include "GPUDisplayFrontend.h"
-#include <GL/glx.h>
 #include <pthread.h>
-#include <unistd.h>
+#include <X11/Xlib.h>
+#include <GL/gl.h>
+#include <GL/glx.h>
 #include <GL/glxext.h>
 
 namespace o2::gpu
@@ -29,7 +30,6 @@ class GPUDisplayFrontendX11 : public GPUDisplayFrontend
   GPUDisplayFrontendX11();
   ~GPUDisplayFrontendX11() override = default;
 
-  int32_t StartDisplay() override;
   void DisplayExit() override;
   void SwitchFullscreen(bool set) override;
   void ToggleMaximized(bool set) override;

From bfac9ed1ba054c5b009a0a8c4d0a74f55fcc80bd Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Jul 2025 18:44:05 +0200
Subject: [PATCH 0813/1764] GPU Display: Skip rejected first/last clusters when
 drawing connected looper segments

---
 GPU/GPUTracking/display/render/GPUDisplayDraw.cxx | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 679d5a6cf88fd..15b58504b3ef2 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -439,8 +439,14 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
       if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
         if (track->PrevSegment() >= 0) {
           const auto& prevtrk = mIOPtrs->mergedTracks[track->PrevSegment()];
-          prevcid = mIOPtrs->mergedTrackHits[prevtrk.FirstClusterRef() + ((track->Leg() & 1) ? (prevtrk.NClusters() - 1) : 0)].num;
           leg = track->Leg();
+          for (int32_t iChk = (leg & 1) ? (prevtrk.NClusters() - 1) : 0; iChk != ((leg & 1) ? -1 : (int32_t)prevtrk.NClusters()); iChk += (leg & 1) ? -1 : 1) {
+            const auto& hit = mIOPtrs->mergedTrackHits[prevtrk.FirstClusterRef() + iChk];
+            if (!mCfgH.hideRejectedClusters || !(hit.state & GPUTPCGMMergedTrackHit::flagReject)) {
+              prevcid = hit.num;
+              break;
+            }
+          }
         }
       }
 

From 32df13a54a734e4ff2fdb06a6fa10b292f03bd57 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 24 Jul 2025 22:58:52 +0200
Subject: [PATCH 0814/1764] GPU TPC: Fix sorting of clusters in segments of
 looping tracks

---
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h  |   2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 107 ++++++++++++++----
 GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h  |   3 -
 .../display/render/GPUDisplayDraw.cxx         |  18 ++-
 4 files changed, 94 insertions(+), 36 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 60be206ed7e42..358a808e120a9 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -42,7 +42,7 @@ class GPUTPCGMMergedTrack
     return mAlpha;
   }
   GPUd() bool OK() const { return mFlags & 0x01; }
-  GPUd() bool Looper() const { return mFlags & 0x02; }
+  GPUd() bool Looper() const { return mFlags & 0x02; } // TODO: Get rid of the looper flag, or rename it if still needed.
   GPUd() bool CSide() const { return mFlags & 0x04; }
   GPUd() bool CCE() const { return mFlags & 0x08; }
   GPUd() bool MergedLooperUnconnected() const { return mFlags & 0x10; }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 81e96af47152d..27aee906860d7 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1435,13 +1435,14 @@ namespace // anonymous
 {
 struct GPUTPCGMMerger_CompareClusterIds {
   const GPUTPCGMMerger::trackCluster* const mCmp;
-  GPUd() GPUTPCGMMerger_CompareClusterIds(const GPUTPCGMMerger::trackCluster* cmp) : mCmp(cmp) {}
+  const bool revert;
+  GPUd() GPUTPCGMMerger_CompareClusterIds(const GPUTPCGMMerger::trackCluster* cmp, bool r) : mCmp(cmp), revert(r) {}
   GPUd() bool operator()(const int16_t aa, const int16_t bb)
   {
     const GPUTPCGMMerger::trackCluster& a = mCmp[aa];
     const GPUTPCGMMerger::trackCluster& b = mCmp[bb];
     if (a.row != b.row) {
-      return (a.row > b.row);
+      return (a.row > b.row) ^ revert;
     }
     return GPUCA_DETERMINISTIC_CODE((a.id != b.id) ? (a.id > b.id) : (aa > bb), a.id > b.id);
   }
@@ -1460,6 +1461,8 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
   GPUTPCGMSectorTrack* trbase = nullptr;
   int32_t leg = 0;
   int32_t lastMergedSegment = -1;
+  bool revertSegments = false;
+  bool revertInSegment = false;
   while (true) {
     if (trbase && !Param().rec.tpc.dropLoopers) {
       int32_t jtr = trbase->NextNeighbour();
@@ -1469,7 +1472,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
           trbase = nullptr;
         } else {
           trbase->SetPrevSegmentNeighbour(1000000001);
-          leg--;
+          leg += revertSegments ? 1 : -1;
         }
       } else {
         trbase = nullptr;
@@ -1488,15 +1491,68 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       if (itr >= SectorTrackInfoLocalTotal()) {
         break;
       }
-      itr += nThreads * nBlocks;
+      revertSegments = false;
+      revertInSegment = false;
       trbase->SetPrevSegmentNeighbour(1000000000);
       int32_t jtr = trbase->NextNeighbour();
       leg = 0;
-      while (jtr >= 0) {
-        leg++;
-        jtr = mSectorTrackInfos[jtr].NextNeighbour();
+      if (jtr >= 0) {
+        int32_t lasttr = itr;
+        while (jtr >= 0) { // --------------- count segments ---------------
+          if (&mSectorTrackInfos[jtr] == trbase) {
+            break; // Break cyclic graph
+          }
+          lasttr = jtr;
+          leg++;
+          jtr = mSectorTrackInfos[jtr].NextNeighbour();
+        }
+
+        float mainZT = 1e9;
+        revertSegments = true;
+        for (uint32_t k = 0; k < 2; k++) { // --------------- check if first or last segment is primary ---------------
+          int32_t ichk = k ? lasttr : itr;
+          const GPUTPCGMSectorTrack* trchk = &mSectorTrackInfos[ichk];
+          while (true) {
+            float zt = Param().par.earlyTpcTransform ? CAMath::Min(CAMath::Abs(trchk->ClusterZT0()), CAMath::Abs(trchk->ClusterZTN())) : -trchk->MinClusterZT(); // Negative time ~ smallest z, behaves the same way
+            if (zt < mainZT) {
+              if (k) {
+                revertSegments = false;
+                break;
+              }
+              mainZT = zt;
+            }
+            int32_t next = trchk->NextSegmentNeighbour();
+            if (next < 0 || next == ichk) {
+              break; // Breaks also cycles
+            }
+            trchk = &mSectorTrackInfos[next];
+          }
+        }
+        if (revertSegments) {
+          leg = 0;
+        }
+
+        { // --------------- find longest sector track of main segment ---------------
+          int32_t length = 0;
+          int32_t ichk = revertSegments ? itr : lasttr;
+          const GPUTPCGMSectorTrack* trchk = &mSectorTrackInfos[ichk];
+          const GPUTPCGMSectorTrack* longest = trchk;
+          while (true) {
+            if (trchk->OrigTrack()->NHits() > length) {
+              longest = trchk;
+              length = trchk->OrigTrack()->NHits();
+            }
+            int32_t next = trchk->NextSegmentNeighbour();
+            if (next < 0 || next == ichk) {
+              break; // Breaks also cycles
+            }
+            trchk = &mSectorTrackInfos[next];
+          }
+          revertInSegment = (longest->ClusterZT0() < longest->ClusterZTN()) ^ (Param().par.earlyTpcTransform ? !longest->CSide() : false);
+        }
       }
       lastMergedSegment = -1;
+      itr += nThreads * nBlocks;
     }
 
     do {
@@ -1513,7 +1569,6 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         }
         nHits += tr->NClusters();
 
-        tr->SetLeg(leg);
         trackParts[nParts++] = tr;
         for (int32_t i = 0; i < 2; i++) {
           if (tr->ExtrapolatedTrackId(i) != -1) {
@@ -1523,8 +1578,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
             if (nHits + mSectorTrackInfos[tr->ExtrapolatedTrackId(i)].NClusters() > kMaxClusters) {
               break;
             }
-            trackParts[nParts] = &mSectorTrackInfos[tr->ExtrapolatedTrackId(i)];
-            trackParts[nParts++]->SetLeg(leg);
+            trackParts[nParts++] = &mSectorTrackInfos[tr->ExtrapolatedTrackId(i)];
             nHits += mSectorTrackInfos[tr->ExtrapolatedTrackId(i)].NClusters();
           }
         }
@@ -1538,7 +1592,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       }
 
       // unpack and sort clusters
-      if (nParts > 1) {
+      if (nParts > 1 && (!revertInSegment ^ (leg & 1))) {
         GPUCommonAlgorithm::sort(trackParts, trackParts + nParts, [](const GPUTPCGMSectorTrack* a, const GPUTPCGMSectorTrack* b) {
           GPUCA_DETERMINISTIC_CODE( // clang-format off
             if (a->X() != b->X()) {
@@ -1576,11 +1630,14 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         break;
       }
 
-      bool ordered = true;
-      for (int32_t i = 1; i < nHits; i++) {
-        if (trackClusters[i].row > trackClusters[i - 1].row || trackClusters[i].id == trackClusters[i - 1].id) {
-          ordered = false;
-          break;
+      const bool mustReverse = revertInSegment ^ (leg & 1);
+      bool ordered = !mustReverse;
+      if (ordered) {
+        for (int32_t i = 1; i < nHits; i++) {
+          if ((trackClusters[i].row > trackClusters[i - 1].row) ^ mustReverse || trackClusters[i].id == trackClusters[i - 1].id) {
+            ordered = false;
+            break;
+          }
         }
       }
       int32_t firstTrackIndex = 0;
@@ -1594,7 +1651,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
           clusterIndices[i] = i;
         }
 
-        GPUCommonAlgorithm::sort(clusterIndices, clusterIndices + nHits, GPUTPCGMMerger_CompareClusterIds(trackClusters));
+        GPUCommonAlgorithm::sort(clusterIndices, clusterIndices + nHits, GPUTPCGMMerger_CompareClusterIds(trackClusters, mustReverse));
 
         nTmpHits = 0;
         firstTrackIndex = lastTrackIndex = -1;
@@ -1659,16 +1716,24 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       }
 
       GPUTPCGMMergedTrack& mergedTrack = mMergedTracks[iOutputTrack];
+      GPUTPCGMTrackParam& p1 = mergedTrack.Param();
+      const GPUTPCGMSectorTrack& p2 = *trackParts[firstTrackIndex];
       mergedTrack.SetFlags(0);
       mergedTrack.SetOK(true);
-      mergedTrack.SetLooper(leg > 0 || lastMergedSegment >= 0);
+      mergedTrack.SetLeg(leg);
+      mergedTrack.SetLooper(leg > 0);
       mergedTrack.SetNClusters(nHits);
       mergedTrack.SetFirstClusterRef(iMergedTrackFirstCluster);
-      GPUTPCGMTrackParam& p1 = mergedTrack.Param();
-      const GPUTPCGMSectorTrack& p2 = *trackParts[firstTrackIndex];
       mergedTrack.SetCSide(p2.CSide());
       mergedTrack.SetMergedLooperConnected(leg > 0);
-      mergedTrack.SetPrevSegment(lastMergedSegment);
+      if (revertSegments) {
+        mergedTrack.SetPrevSegment(-1);
+        if (lastMergedSegment >= 0) {
+          mMergedTracks[lastMergedSegment].SetPrevSegment(iOutputTrack);
+        }
+      } else {
+        mergedTrack.SetPrevSegment(lastMergedSegment);
+      }
       lastMergedSegment = iOutputTrack;
 
       GPUTPCGMBorderTrack b;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
index 27e4a89300ca4..1de3928aac409 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
@@ -55,7 +55,6 @@ class GPUTPCGMSectorTrack
   GPUd() float DzDs() const { return mParam.mDzDs; }
   GPUd() float QPt() const { return mParam.mQPt; }
   GPUd() float TZOffset() const { return mTZOffset; }
-  GPUd() uint8_t Leg() const { return mLeg; }
 
   GPUd() int32_t LocalTrackId() const { return mLocalTrackId; }
   GPUd() void SetLocalTrackId(int32_t v) { mLocalTrackId = v; }
@@ -99,7 +98,6 @@ class GPUTPCGMSectorTrack
   GPUd() void SetNeighbor(int32_t v, int32_t i) { mNeighbour[i] = v; }
   GPUd() void SetPrevSegmentNeighbour(int32_t v) { mSegmentNeighbour[0] = v; }
   GPUd() void SetNextSegmentNeighbour(int32_t v) { mSegmentNeighbour[1] = v; }
-  GPUd() void SetLeg(uint8_t v) { mLeg = v; }
 
   GPUd() void CopyParamFrom(const GPUTPCGMSectorTrack& t)
   {
@@ -136,7 +134,6 @@ class GPUTPCGMSectorTrack
   int32_t mLocalTrackId;            // Corrected local track id in terms of GMSectorTracks array for extrapolated tracks, UNDEFINED for local tracks!
   int32_t mExtrapolatedTrackIds[2]; // IDs of associated extrapolated tracks
   uint8_t mSector;                  // sector of this track segment
-  uint8_t mLeg;                     // Leg of this track segment
 
   ClassDefNV(GPUTPCGMSectorTrack, 1);
 };
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 15b58504b3ef2..3a56f874d2d12 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -376,6 +376,7 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
 
       size_t startCountInner = mVertexBuffer[iSector].size();
       bool drawing = false;
+      uint32_t lastSide = -1;
 
       if constexpr (std::is_same_v<T, o2::tpc::TrackTPC>) {
         if (!mCfgH.drawTracksAndFilter && !(mCfgH.drawTPCTracks || (mCfgH.drawITSTracks && mIOPtrs->tpcLinkITS && mIOPtrs->tpcLinkITS[i] != -1) || (mCfgH.drawTRDTracks && mIOPtrs->tpcLinkTRD && mIOPtrs->tpcLinkTRD[i] != -1) || (mCfgH.drawTOFTracks && mIOPtrs->tpcLinkTOF && mIOPtrs->tpcLinkTOF[i] != -1))) {
@@ -397,6 +398,7 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
           drawing = true;
           mVertexBuffer[iSector].emplace_back(mGlobalPosTOF[cid].x, mGlobalPosTOF[cid].y * mYFactor, mCfgH.projectXY ? 0 : mGlobalPosTOF[cid].z);
           mGlobalPosTOF[cid].w = tTOFATTACHED;
+          lastSide = mGlobalPosTOF[cid].z < 0;
         }
       }
 
@@ -410,6 +412,7 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
           drawing = true;
           mVertexBuffer[iSector].emplace_back(mGlobalPosTRD2[cid].x, mGlobalPosTRD2[cid].y * mYFactor, mCfgH.projectXY ? 0 : mGlobalPosTRD2[cid].z);
           mVertexBuffer[iSector].emplace_back(mGlobalPosTRD[cid].x, mGlobalPosTRD[cid].y * mYFactor, mCfgH.projectXY ? 0 : mGlobalPosTRD[cid].z);
+          lastSide = mGlobalPosTRD[cid].z < 0;
           mGlobalPosTRD[cid].w = tTRDATTACHED;
         }
       };
@@ -433,17 +436,15 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
 
       // Print TPC part of track
       int32_t separateExtrapolatedTracksLimit = (mCfgH.separateExtrapolatedTracks ? tEXTRAPOLATEDTRACK : TRACK_TYPE_ID_LIMIT);
-      uint32_t lastSide = -1;
-      int32_t prevcid = -1;
-      int32_t leg = 0;
       if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
         if (track->PrevSegment() >= 0) {
           const auto& prevtrk = mIOPtrs->mergedTracks[track->PrevSegment()];
-          leg = track->Leg();
-          for (int32_t iChk = (leg & 1) ? (prevtrk.NClusters() - 1) : 0; iChk != ((leg & 1) ? -1 : (int32_t)prevtrk.NClusters()); iChk += (leg & 1) ? -1 : 1) {
+          for (int32_t iChk = prevtrk.NClusters() - 1; iChk >= 0; iChk--) {
             const auto& hit = mIOPtrs->mergedTrackHits[prevtrk.FirstClusterRef() + iChk];
             if (!mCfgH.hideRejectedClusters || !(hit.state & GPUTPCGMMergedTrackHit::flagReject)) {
-              prevcid = hit.num;
+              drawPointLinestrip(iSector, hit.num, tFINALTRACK, separateExtrapolatedTracksLimit);
+              lastSide = mGlobalPos[hit.num].z < 0;
+              drawing = true;
               break;
             }
           }
@@ -488,8 +489,6 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
                 lastcid = &track->getCluster(mIOPtrs->outputClusRefsTPCO2, lastCluster, *mIOPtrs->clustersNative) - mIOPtrs->clustersNative->clustersLinear;
               }
               drawPointLinestrip(iSector, lastcid, tFINALTRACK, separateExtrapolatedTracksLimit);
-            } else if (prevcid != -1 && k == 0 && (leg & 1) == 0) {
-              drawPointLinestrip(iSector, prevcid, tFINALTRACK, separateExtrapolatedTracksLimit);
             }
             drawPointLinestrip(iSector, cid, tFINALTRACK, separateExtrapolatedTracksLimit);
           }
@@ -498,9 +497,6 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
         lastCluster = k;
         lastSide = mGlobalPos[cid].z < 0;
       }
-      if (prevcid != -1 && (leg & 1) && drawing) {
-        drawPointLinestrip(iSector, prevcid, tFINALTRACK, separateExtrapolatedTracksLimit);
-      }
 
       // Print ITS part of track
       if constexpr (std::is_same_v<T, o2::tpc::TrackTPC>) {

From 8fbde5eb87cdaa5b67ef926a2366e6aed6c56867 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 25 Jul 2025 12:54:14 +0200
Subject: [PATCH 0815/1764] GPU TPC: Use inner SectorRefit parameters as start
 parameters for odd leg numbers

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  2 +-
 .../Merger/GPUTPCGMSectorTrack.cxx            | 59 ++++++++++++-------
 GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h  |  1 +
 3 files changed, 39 insertions(+), 23 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 27aee906860d7..9f9df0884901c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1738,7 +1738,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
 
       GPUTPCGMBorderTrack b;
       const float toX = Param().par.earlyTpcTransform ? mClustersXYZ[iMergedTrackFirstCluster].x : GPUTPCGeometry::Row2X(cl[0].row);
-      if (p2.TransportToX(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
+      if (p2.TransportToX<2>(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
         p1.X() = toX;
         p1.Y() = b.Par()[0];
         p1.Z() = b.Par()[1];
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index 11b153c7f0d8b..2b6d826baea56 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -274,13 +274,25 @@ GPUd() bool GPUTPCGMSectorTrack::FilterErrors(const GPUTPCGMMerger* merger, int3
   return ok;
 }
 
+template <>
+GPUd() bool GPUTPCGMSectorTrack::TransportToX<2>(GPUTPCGMMerger* merger, float x, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi, bool doCov) const
+{
+  if (CAMath::Abs(x - mParam2.mX) < CAMath::Abs(x - mParam.mX) && mParam2.mX > 0) {
+    return TransportToX<1>(merger, x, Bz, b, maxSinPhi, doCov);
+  } else {
+    return TransportToX<0>(merger, x, Bz, b, maxSinPhi, doCov);
+  }
+}
+
+template <int I>
 GPUd() bool GPUTPCGMSectorTrack::TransportToX(GPUTPCGMMerger* merger, float x, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi, bool doCov) const
 {
+  const auto& param = I ? mParam2 : mParam;
   Bz = -Bz;
-  float ex = mParam.mCosPhi;
-  float ey = mParam.mSinPhi;
-  float k = mParam.mQPt * Bz;
-  float dx = x - mParam.mX;
+  float ex = param.mCosPhi;
+  float ey = param.mSinPhi;
+  float k = param.mQPt * Bz;
+  float dx = x - param.mX;
   float ey1 = k * dx + ey;
 
   if (CAMath::Abs(ey1) > maxSinPhi) {
@@ -308,13 +320,13 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToX(GPUTPCGMMerger* merger, float x, f
     dS = dl + dl * a * (k2 + a * (k4)); //+ k6*a) );
   }
 
-  float dz = dS * mParam.mDzDs;
+  float dz = dS * param.mDzDs;
 
-  b.SetPar(0, mParam.mY + dy);
-  b.SetPar(1, mParam.mZ + dz);
+  b.SetPar(0, param.mY + dy);
+  b.SetPar(1, param.mZ + dz);
   b.SetPar(2, ey1);
-  b.SetPar(3, mParam.mDzDs);
-  b.SetPar(4, mParam.mQPt);
+  b.SetPar(3, param.mDzDs);
+  b.SetPar(4, param.mQPt);
   if (merger->Param().par.earlyTpcTransform) {
     b.SetZOffsetLinear(mTZOffset);
   } else {
@@ -327,33 +339,33 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToX(GPUTPCGMMerger* merger, float x, f
 
   float ex1i = 1.f / ex1;
   float hh = dxcci * ex1i * norm2;
-  float h2 = hh * mParam.mSecPhi;
+  float h2 = hh * param.mSecPhi;
   float h4 = Bz * dxcci * hh;
 
-  float c20 = mParam.mC3;
-  float c22 = mParam.mC5;
-  float c31 = mParam.mC7;
-  float c33 = mParam.mC9;
-  float c40 = mParam.mC10;
-  float c42 = mParam.mC12;
-  float c44 = mParam.mC14;
+  float c20 = param.mC3;
+  float c22 = param.mC5;
+  float c31 = param.mC7;
+  float c33 = param.mC9;
+  float c40 = param.mC10;
+  float c42 = param.mC12;
+  float c44 = param.mC14;
 
   float c20ph4c42 = c20 + h4 * c42;
   float h2c22 = h2 * c22;
   float h4c44 = h4 * c44;
   float n7 = c31 + dS * c33;
 
-  if (CAMath::Abs(mParam.mQPt) > 6.66f) // Special treatment for low Pt
+  if (CAMath::Abs(param.mQPt) > 6.66f) // Special treatment for low Pt
   {
-    b.SetCov(0, CAMath::Max(mParam.mC0, mParam.mC0 + h2 * h2c22 + h4 * h4c44 + 2.f * (h2 * c20ph4c42 + h4 * c40))); // Do not decrease Y cov for matching!
+    b.SetCov(0, CAMath::Max(param.mC0, param.mC0 + h2 * h2c22 + h4 * h4c44 + 2.f * (h2 * c20ph4c42 + h4 * c40))); // Do not decrease Y cov for matching!
     float C2tmp = dS * 2.f * c31;
     if (C2tmp < 0) {
       C2tmp = 0;
     }
-    b.SetCov(1, mParam.mC2 + C2tmp + dS * dS * c33); // Incorrect formula, correct would be "dS * (c31 + n7)", but we need to make sure cov(Z) increases regardless of the direction of the propagation
+    b.SetCov(1, param.mC2 + C2tmp + dS * dS * c33); // Incorrect formula, correct would be "dS * (c31 + n7)", but we need to make sure cov(Z) increases regardless of the direction of the propagation
   } else {
-    b.SetCov(0, mParam.mC0 + h2 * h2c22 + h4 * h4c44 + 2.f * (h2 * c20ph4c42 + h4 * c40));
-    b.SetCov(1, mParam.mC2 + dS * (c31 + n7));
+    b.SetCov(0, param.mC0 + h2 * h2c22 + h4 * h4c44 + 2.f * (h2 * c20ph4c42 + h4 * c40));
+    b.SetCov(1, param.mC2 + dS * (c31 + n7));
   }
   b.SetCov(2, c22 + dxBz * (c42 + c42 + dxBz * c44));
   b.SetCov(3, c33);
@@ -366,6 +378,9 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToX(GPUTPCGMMerger* merger, float x, f
   return 1;
 }
 
+template GPUdni() bool GPUTPCGMSectorTrack::TransportToX<0>(GPUTPCGMMerger* merger, float x, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi, bool doCov) const;
+template GPUdni() bool GPUTPCGMSectorTrack::TransportToX<1>(GPUTPCGMMerger* merger, float x, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi, bool doCov) const;
+
 GPUd() bool GPUTPCGMSectorTrack::TransportToXAlpha(GPUTPCGMMerger* merger, float newX, float sinAlpha, float cosAlpha, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi) const
 {
   //*
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
index 1de3928aac409..81facce76cf10 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
@@ -113,6 +113,7 @@ class GPUTPCGMSectorTrack
   }
 
   GPUd() bool FilterErrors(const GPUTPCGMMerger* merger, int32_t iSector, float maxSinPhi = GPUCA_MAX_SIN_PHI, float sinPhiMargin = 0.f);
+  template <int I = 0>
   GPUd() bool TransportToX(GPUTPCGMMerger* merger, float x, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi, bool doCov = true) const;
   GPUd() bool TransportToXAlpha(GPUTPCGMMerger* merger, float x, float sinAlpha, float cosAlpha, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi) const;
   GPUd() void CopyBaseTrackCov();

From bab3332dd8adc5120f1a7b65075e399888bb502b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 25 Jul 2025 19:27:21 +0200
Subject: [PATCH 0816/1764] GPU: Fix kernel file include order, must follow
 template specialization usage

---
 GPU/GPUTracking/kernels.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index e1fef5795828b..5bcda68e691b3 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -19,7 +19,7 @@ o2_gpu_kernel_file_list(TPCSECTORDATA TPCTRACKER GPUTPCTrackingData.cxx)
 o2_gpu_kernel_file_list(TPCOCCUPANCY GPUTPCClusterOccupancyMap.cxx)
 o2_gpu_kernel_file_list(TPCDEDX GPUdEdx.cxx)
 o2_gpu_kernel_file_list(MATLUT MatLayerCylSet.cxx MatLayerCyl.cxx Ray.cxx)
-o2_gpu_kernel_file_list(TPCMERGER ERRORS GPUTPCGMMerger.cxx GPUTPCGMSectorTrack.cxx GPUTPCGMTrackParam.cxx GPUTPCGMPhysicalTrackModel.cxx GPUTPCGMPropagator.cxx)
+o2_gpu_kernel_file_list(TPCMERGER ERRORS GPUTPCGMSectorTrack.cxx GPUTPCGMMerger.cxx GPUTPCGMTrackParam.cxx GPUTPCGMPhysicalTrackModel.cxx GPUTPCGMPropagator.cxx)
 o2_gpu_kernel_file_list(O2PROPAGATOR TrackParametrization.cxx TrackParametrizationWithError.cxx Propagator.cxx TrackLTIntegral.cxx)
 o2_gpu_kernel_file_list(TPCCOMPRESSION GPUTPCCompressionTrackModel.cxx)
 o2_gpu_kernel_file_list(TPCDECOMPRESSION GPUTPCCompressionTrackModel.cxx ERRORS)

From 580dbe8d996a71b9428668a63ac2ca1871f4da94 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 25 Jul 2025 23:54:03 +0200
Subject: [PATCH 0817/1764] GPU TPC: Remove early transform option, we can just
 process triggered data as continuous data

---
 GPU/GPUTracking/Base/GPUConstantMem.h         |   2 -
 GPU/GPUTracking/Base/GPUParam.cxx             |   2 -
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |   1 -
 GPU/GPUTracking/CMakeLists.txt                |   2 -
 GPU/GPUTracking/DataTypes/GPUDataTypes.h      |   2 -
 .../DataTypes/GPUTPCGMMergedTrackHit.h        |   5 -
 .../Definitions/GPUDefParametersDefaults.h    |   3 -
 GPU/GPUTracking/Definitions/GPUSettingsList.h |   2 -
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  17 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |   1 -
 .../Global/GPUChainTrackingMerger.cxx         |   5 -
 .../Global/GPUChainTrackingSectorTracker.cxx  |  23 +--
 .../Global/GPUChainTrackingTransformation.cxx |  34 +---
 .../Interface/GPUO2InterfaceDisplay.cxx       |   1 -
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 112 ++++---------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |   5 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |   1 -
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |   2 +-
 .../Merger/GPUTPCGMSectorTrack.cxx            |  18 +--
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 148 +++++-------------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |   6 +-
 .../GPUTPCSectorDebugSortKernels.cxx          |   1 -
 .../SectorTracker/GPUTPCTracker.cxx           |   1 -
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.h |   4 -
 .../SectorTracker/GPUTPCTrackingData.cxx      |  74 ++-------
 .../SectorTracker/GPUTPCTrackingData.h        |  23 ++-
 .../Standalone/Benchmark/standalone.cxx       |   2 +-
 GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx  |  54 -------
 GPU/GPUTracking/TPCConvert/GPUTPCConvert.h    |  56 -------
 .../TPCConvert/GPUTPCConvertKernel.cxx        |  48 ------
 .../TPCConvert/GPUTPCConvertKernel.h          |  31 ----
 .../display/helpers/GPUDisplayHelpers.cxx     |   3 -
 .../display/render/GPUDisplayDraw.cxx         |  38 ++---
 .../display/render/GPUDisplayImportEvent.cxx  |  32 ++--
 GPU/GPUTracking/kernels.cmake                 |   1 -
 GPU/GPUTracking/qa/GPUQA.cxx                  |  12 +-
 36 files changed, 135 insertions(+), 637 deletions(-)
 delete mode 100644 GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx
 delete mode 100644 GPU/GPUTracking/TPCConvert/GPUTPCConvert.h
 delete mode 100644 GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx
 delete mode 100644 GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.h

diff --git a/GPU/GPUTracking/Base/GPUConstantMem.h b/GPU/GPUTracking/Base/GPUConstantMem.h
index ffb17997b9190..c496151c3dfd0 100644
--- a/GPU/GPUTracking/Base/GPUConstantMem.h
+++ b/GPU/GPUTracking/Base/GPUConstantMem.h
@@ -23,7 +23,6 @@
 #include "GPUTPCGMMerger.h"
 #include "GPUTRDTracker.h"
 
-#include "GPUTPCConvert.h"
 #include "GPUTPCCompression.h"
 #include "GPUTPCDecompression.h"
 #include "GPUTPCClusterFinder.h"
@@ -42,7 +41,6 @@ namespace o2::gpu
 struct GPUConstantMem {
   GPUParam param;
   GPUTPCTracker tpcTrackers[GPUCA_NSECTORS];
-  GPUTPCConvert tpcConverter;
   GPUTPCCompression tpcCompressor;
   GPUTPCDecompression tpcDecompressor;
   GPUTPCGMMerger tpcMerger;
diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index 3062e1c4d2064..649682939ab39 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -111,7 +111,6 @@ void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
   par.continuousTracking = false;
   continuousMaxTimeBin = 0;
   tpcCutTimeBin = 0;
-  par.earlyTpcTransform = false;
 }
 
 void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p, const GPURecoStepConfiguration* w, const GPUSettingsRecDynamic* d)
@@ -122,7 +121,6 @@ void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessi
     continuousMaxTimeBin = g->grpContinuousMaxTimeBin == -1 ? GPUSettings::TPC_MAX_TF_TIME_BIN : g->grpContinuousMaxTimeBin;
     tpcCutTimeBin = g->tpcCutTimeBin;
   }
-  par.earlyTpcTransform = rec.tpc.forceEarlyTransform == -1 ? (!par.continuousTracking) : rec.tpc.forceEarlyTransform;
   qptB5Scaler = CAMath::Abs(bzkG) > 0.1f ? CAMath::Abs(bzkG) / 5.006680f : 1.f; // Repeat here, since passing in g is optional
   if (p) {
     UpdateRun3ClusterErrors(p->param.tpcErrorParamY, p->param.tpcErrorParamZ);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index f7b08f9dd0c48..641b0a2d095ca 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -17,7 +17,6 @@
 #include "GPUReconstructionThreading.h"
 #include "GPUChain.h"
 #include "GPUDefParametersRuntime.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUTPCGMMergedTrackHit.h"
 #include "GPUTRDTrackletWord.h"
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index a7159549322a0..a976e5c93b7c6 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -174,8 +174,6 @@ set(SRCS_NO_CINT ${SRCS_NO_CINT} display/GPUDisplayInterface.cxx)
 set(SRCS_NO_CINT ${SRCS_NO_CINT}
     Global/GPUChainITS.cxx
     dEdx/GPUdEdx.cxx
-    TPCConvert/GPUTPCConvert.cxx
-    TPCConvert/GPUTPCConvertKernel.cxx
     DataCompression/GPUTPCCompression.cxx
     DataCompression/GPUTPCCompressionTrackModel.cxx
     DataCompression/GPUTPCCompressionKernels.cxx
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.h b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
index 3e9623e23559b..801c60f6b02ba 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
@@ -101,7 +101,6 @@ class GPUTPCTrack;
 class GPUTPCHitId;
 class GPUTPCGMMergedTrack;
 struct GPUTPCGMMergedTrackHit;
-struct GPUTPCGMMergedTrackHitXYZ;
 class GPUTRDTrackletWord;
 class GPUTRDSpacePoint;
 struct GPUTPCMCInfo;
@@ -237,7 +236,6 @@ struct GPUTrackingInOutPointers {
   const GPUTPCGMMergedTrack* mergedTracks = nullptr;
   uint32_t nMergedTracks = 0;
   const GPUTPCGMMergedTrackHit* mergedTrackHits = nullptr;
-  const GPUTPCGMMergedTrackHitXYZ* mergedTrackHitsXYZ = nullptr;
   uint32_t nMergedTrackHits = 0;
   const uint32_t* mergedTrackHitAttachment = nullptr;
   const uint8_t* mergedTrackHitStates = nullptr;
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h b/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
index a965f306dac79..789c1f00262f8 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGMMergedTrackHit.h
@@ -38,11 +38,6 @@ struct GPUTPCGMMergedTrackHit {
                   flagHighIncl = 0x80 };
 };
 
-struct GPUTPCGMMergedTrackHitXYZ {
-  float x, y, z;
-  uint16_t amp;
-};
-
 } // namespace o2::gpu
 
 #endif
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index b1f12034d9c2f..7b76860d4ca2b 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -305,9 +305,6 @@
   #ifndef GPUCA_LB_GPUTRDTrackerKernels_o2Version
     #define GPUCA_LB_GPUTRDTrackerKernels_o2Version 512
   #endif
-  #ifndef GPUCA_LB_GPUTPCConvertKernel
-    #define GPUCA_LB_GPUTPCConvertKernel 256
-  #endif
   #ifndef GPUCA_LB_GPUTPCCompressionKernels_step0attached
     #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 256
   #endif
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index a22524713c5c0..60ee12252b0a8 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -147,7 +147,6 @@ AddOptionRTC(compressionTypeMask, uint8_t, o2::gpu::GPUSettings::CompressionFull
 AddOptionRTC(compressionSortOrder, uint8_t, o2::gpu::GPUSettings::SortTime, "", 0, "Sort order of TPC compression (0 = time, 1 = pad, 2 = Z-time-pad, 3 = Z-pad-time, 4 = no sorting (use incoming order))")
 AddOptionRTC(sigBitsCharge, uint8_t, 4, "", 0, "Number of significant bits for TPC cluster charge in compression mode 1")
 AddOptionRTC(sigBitsWidth, uint8_t, 3, "", 0, "Number of significant bits for TPC cluster width in compression mode 1")
-AddOptionRTC(forceEarlyTransform, int8_t, -1, "", 0, "Force early TPC transformation also for continuous data (-1 = auto)")
 AddOptionRTC(dropLoopers, uint8_t, 0, "", 0, "Drop looping tracks starting from second loop")
 AddOptionRTC(mergerCovSource, uint8_t, 2, "", 0, "Method to obtain covariance in track merger: 0 = simple filterErrors method, 1 = use cov from track following, 2 = refit (default)")
 AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation instead of extrapolation for chi2 based cluster rejection")
@@ -661,7 +660,6 @@ EndConfig()
 BeginHiddenConfig(GPUSettingsParam, param)
 AddVariableRTC(continuousTracking, int8_t, 0) // Continuous tracking, estimate bz and errors for abs(z) = 125cm during seeding
 AddVariableRTC(dodEdx, int8_t, 0)             // Do dEdx computation
-AddVariableRTC(earlyTpcTransform, int8_t, 0)  // do Early TPC transformation
 EndConfig()
 
 EndNamespace() // gpu
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index b0ea052063f20..f42b7cc34df73 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -21,11 +21,11 @@
 #include "GPUChainTrackingGetters.inc"
 #include "GPUReconstructionIO.h"
 #include "GPUChainTrackingDefs.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUTPCGMMergedTrackHit.h"
 #include "GPUTPCTrack.h"
 #include "GPUTPCHitId.h"
+#include "GPUTPCClusterData.h"
 #include "TPCZSLinkMapping.h"
 #include "GPUTRDTrackletWord.h"
 #include "AliHLTTPCClusterMCData.h"
@@ -93,9 +93,6 @@ void GPUChainTracking::RegisterPermanentMemoryAndProcessors()
   if (GetRecoSteps() & RecoStep::TRDTracking) {
     mRec->RegisterGPUProcessor(&processors()->trdTrackerO2, GetRecoStepsGPU() & RecoStep::TRDTracking);
   }
-  if (GetRecoSteps() & RecoStep::TPCConversion) {
-    mRec->RegisterGPUProcessor(&processors()->tpcConverter, GetRecoStepsGPU() & RecoStep::TPCConversion);
-  }
   if (GetRecoSteps() & RecoStep::TPCCompression) {
     mRec->RegisterGPUProcessor(&processors()->tpcCompressor, GetRecoStepsGPU() & RecoStep::TPCCompression);
   }
@@ -141,9 +138,6 @@ void GPUChainTracking::RegisterGPUProcessors()
   if (GetRecoStepsGPU() & RecoStep::TRDTracking) {
     mRec->RegisterGPUDeviceProcessor(&processorsShadow()->trdTrackerO2, &processors()->trdTrackerO2);
   }
-  if (GetRecoStepsGPU() & RecoStep::TPCConversion) {
-    mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcConverter, &processors()->tpcConverter);
-  }
   if (GetRecoStepsGPU() & RecoStep::TPCCompression) {
     mRec->RegisterGPUDeviceProcessor(&processorsShadow()->tpcCompressor, &processors()->tpcCompressor);
   }
@@ -182,11 +176,9 @@ bool GPUChainTracking::ValidateSteps()
     GPUError("Invalid GPU Reconstruction Step Setting: dEdx requires TPC Merger to be active");
     return false;
   }
-  if (!param().par.earlyTpcTransform) {
-    if (((GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging)) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCConversion)) {
-      GPUError("Invalid Reconstruction Step Setting: Tracking without early transform requires TPC Conversion to be active");
-      return false;
-    }
+  if (((GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging)) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCConversion)) {
+    GPUError("Invalid Reconstruction Step Setting: Tracking requires TPC Conversion to be active");
+    return false;
   }
   if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) && !(GetRecoStepsInputs() & GPUDataTypes::InOutType::TPCRaw)) {
     GPUError("Invalid input, TPC Clusterizer needs TPC raw input");
@@ -566,7 +558,6 @@ void GPUChainTracking::AllocateIOMemory()
   AllocateIOMemoryHelper(mIOPtrs.nMCInfosTPCCol, mIOPtrs.mcInfosTPCCol, mIOMem.mcInfosTPCCol);
   AllocateIOMemoryHelper(mIOPtrs.nMergedTracks, mIOPtrs.mergedTracks, mIOMem.mergedTracks);
   AllocateIOMemoryHelper(mIOPtrs.nMergedTrackHits, mIOPtrs.mergedTrackHits, mIOMem.mergedTrackHits);
-  AllocateIOMemoryHelper(mIOPtrs.nMergedTrackHits, mIOPtrs.mergedTrackHitsXYZ, mIOMem.mergedTrackHitsXYZ);
   AllocateIOMemoryHelper(mIOPtrs.nTRDTracks, mIOPtrs.trdTracks, mIOMem.trdTracks);
   AllocateIOMemoryHelper(mIOPtrs.nTRDTracklets, mIOPtrs.trdTracklets, mIOMem.trdTracklets);
   AllocateIOMemoryHelper(mIOPtrs.nTRDTracklets, mIOPtrs.trdSpacePoints, mIOMem.trdSpacePoints);
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 7d4adcd70af7f..d7e821187e1fe 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -114,7 +114,6 @@ class GPUChainTracking : public GPUChain
     std::unique_ptr<GPUTPCMCInfoCol[]> mcInfosTPCCol;
     std::unique_ptr<GPUTPCGMMergedTrack[]> mergedTracks;
     std::unique_ptr<GPUTPCGMMergedTrackHit[]> mergedTrackHits;
-    std::unique_ptr<GPUTPCGMMergedTrackHitXYZ[]> mergedTrackHitsXYZ;
     std::unique_ptr<GPUTRDTrackletWord[]> trdTracklets;
     std::unique_ptr<GPUTRDSpacePoint[]> trdSpacePoints;
     std::unique_ptr<float[]> trdTriggerTimes;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 5d3ac212c5b54..36e4e9af83fbd 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -260,9 +260,6 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
         GPUMemCpy(RecoStep::TPCMerging, Merger.MergedTracksdEdx(), MergerShadowAll.MergedTracksdEdx(), Merger.NMergedTracks() * sizeof(*Merger.MergedTracksdEdx()), outputStream, 0);
       }
       GPUMemCpy(RecoStep::TPCMerging, Merger.Clusters(), MergerShadowAll.Clusters(), Merger.NMergedTrackClusters() * sizeof(*Merger.Clusters()), outputStream, 0);
-      if (param().par.earlyTpcTransform) {
-        GPUMemCpy(RecoStep::TPCMerging, Merger.ClustersXYZ(), MergerShadowAll.ClustersXYZ(), Merger.NMergedTrackClusters() * sizeof(*Merger.ClustersXYZ()), outputStream, 0);
-      }
       GPUMemCpy(RecoStep::TPCMerging, Merger.ClusterAttachment(), MergerShadowAll.ClusterAttachment(), Merger.NMaxClusters() * sizeof(*Merger.ClusterAttachment()), outputStream, 0);
     }
     if (GetProcessingSettings().outputSharedClusterMap) {
@@ -327,7 +324,6 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   mIOPtrs.mergedTracks = Merger.MergedTracks();
   mIOPtrs.nMergedTracks = Merger.NMergedTracks();
   mIOPtrs.mergedTrackHits = Merger.Clusters();
-  mIOPtrs.mergedTrackHitsXYZ = Merger.ClustersXYZ();
   mIOPtrs.nMergedTrackHits = Merger.NMergedTrackClusters();
   mIOPtrs.mergedTrackHitAttachment = Merger.ClusterAttachment();
   mIOPtrs.mergedTrackHitStates = Merger.ClusterStateExt();
@@ -341,7 +337,6 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     processorsShadow()->ioPtrs.mergedTracks = MergerShadow.MergedTracks();
     processorsShadow()->ioPtrs.nMergedTracks = Merger.NMergedTracks();
     processorsShadow()->ioPtrs.mergedTrackHits = MergerShadow.Clusters();
-    processorsShadow()->ioPtrs.mergedTrackHitsXYZ = MergerShadow.ClustersXYZ();
     processorsShadow()->ioPtrs.nMergedTrackHits = Merger.NMergedTrackClusters();
     processorsShadow()->ioPtrs.mergedTrackHitAttachment = MergerShadow.ClusterAttachment();
     processorsShadow()->ioPtrs.mergedTrackHitStates = MergerShadow.ClusterStateExt();
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 708037239071e..d13e8d5544631 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -17,7 +17,6 @@
 #include "GPULogging.h"
 #include "GPUO2DataTypes.h"
 #include "GPUMemorySizeScalers.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTrackingInputProvider.h"
 #include "GPUTPCClusterOccupancyMap.h"
 #include "GPUDefParametersRuntime.h"
@@ -74,25 +73,13 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     GPUInfo("Running TPC Sector Tracker");
   }
   bool doGPU = GetRecoStepsGPU() & RecoStep::TPCSectorTracking;
-  if (!param().par.earlyTpcTransform) {
-    for (uint32_t i = 0; i < NSECTORS; i++) {
-      processors()->tpcTrackers[i].Data().SetClusterData(nullptr, mIOPtrs.clustersNative->nClustersSector[i], mIOPtrs.clustersNative->clusterOffset[i][0]);
-      if (doGPU) {
-        processorsShadow()->tpcTrackers[i].Data().SetClusterData(nullptr, mIOPtrs.clustersNative->nClustersSector[i], mIOPtrs.clustersNative->clusterOffset[i][0]); // TODO: not needed I think, anyway copied in SetupGPUProcessor
-      }
-    }
-    mRec->MemoryScalers()->nTPCHits = mIOPtrs.clustersNative->nClustersTotal;
-  } else {
-    int32_t offset = 0;
-    for (uint32_t i = 0; i < NSECTORS; i++) {
-      processors()->tpcTrackers[i].Data().SetClusterData(mIOPtrs.clusterData[i], mIOPtrs.nClusterData[i], offset);
-      if (doGPU && GetRecoSteps().isSet(RecoStep::TPCConversion)) {
-        processorsShadow()->tpcTrackers[i].Data().SetClusterData(processorsShadow()->tpcConverter.mClusters + processors()->tpcTrackers[i].Data().ClusterIdOffset(), processors()->tpcTrackers[i].NHitsTotal(), processors()->tpcTrackers[i].Data().ClusterIdOffset());
-      }
-      offset += mIOPtrs.nClusterData[i];
+  for (uint32_t i = 0; i < NSECTORS; i++) {
+    processors()->tpcTrackers[i].Data().SetClusterData(mIOPtrs.clustersNative->nClustersSector[i], mIOPtrs.clustersNative->clusterOffset[i][0]);
+    if (doGPU) {
+      processorsShadow()->tpcTrackers[i].Data().SetClusterData(mIOPtrs.clustersNative->nClustersSector[i], mIOPtrs.clustersNative->clusterOffset[i][0]); // TODO: not needed I think, anyway copied in SetupGPUProcessor
     }
-    mRec->MemoryScalers()->nTPCHits = offset;
   }
+  mRec->MemoryScalers()->nTPCHits = mIOPtrs.clustersNative->nClustersTotal;
   GPUInfo("Event has %u TPC Clusters, %d TRD Tracklets", (uint32_t)mRec->MemoryScalers()->nTPCHits, mIOPtrs.nTRDTracklets);
 
   for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
index c9d4d269f070c..83ddc45830621 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
@@ -16,13 +16,11 @@
 #include "GPULogging.h"
 #include "GPUO2DataTypes.h"
 #include "GPUTrackingInputProvider.h"
-#include "GPUTPCClusterData.h"
 #include "GPUReconstructionConvert.h"
 #include "GPUMemorySizeScalers.h"
-#include "GPUTPCConvert.h"
 #include "AliHLTTPCRawCluster.h"
 #include "GPUConstantMem.h"
-#include "GPUTPCConvertKernel.h"
+#include "GPUTPCClusterData.h"
 
 #include "DataFormatsTPC/ClusterNative.h"
 #include "DataFormatsTPC/ZeroSuppression.h"
@@ -41,9 +39,6 @@ int32_t GPUChainTracking::ConvertNativeToClusterData()
 {
   mRec->PushNonPersistentMemory(qStr2Tag("TPCTRANS"));
   const auto& threadContext = GetThreadContext();
-  bool doGPU = GetRecoStepsGPU() & RecoStep::TPCConversion;
-  GPUTPCConvert& convert = processors()->tpcConverter;
-  GPUTPCConvert& convertShadow = doGPU ? processorsShadow()->tpcConverter : convert;
 
   bool transferClusters = false;
   if (mRec->IsGPU() && !(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding) && NeedTPCClustersOnGPU()) {
@@ -58,31 +53,12 @@ int32_t GPUChainTracking::ConvertNativeToClusterData()
     TransferMemoryResourceLinkToGPU(RecoStep::TPCConversion, mInputsHost->mResourceClusterNativeAccess, 0);
     transferClusters = true;
   }
-  if (!param().par.earlyTpcTransform) {
-    if (GetProcessingSettings().debugLevel >= 3) {
-      GPUInfo("Early transform inactive, skipping TPC Early transformation kernel, transformed on the fly during sector data creation / refit");
-    }
-    if (transferClusters) {
-      SynchronizeStream(0); // TODO: Synchronize implicitly with next step
-    }
-    return 0;
+  if (GetProcessingSettings().debugLevel >= 3) {
+    GPUInfo("Early transform inactive, skipping TPC Early transformation kernel, transformed on the fly during sector data creation / refit");
   }
-  SetupGPUProcessor(&convert, true);
-  for (uint32_t i = 0; i < NSECTORS; i++) {
-    convert.mMemory->clusters[i] = convertShadow.mClusters + mIOPtrs.clustersNative->clusterOffset[i][0];
-  }
-
-  WriteToConstantMemory(RecoStep::TPCConversion, (char*)&processors()->tpcConverter - (char*)processors(), &convertShadow, sizeof(convertShadow), 0);
-  TransferMemoryResourcesToGPU(RecoStep::TPCConversion, &convert, 0);
-  runKernel<GPUTPCConvertKernel>(GetGridBlk(NSECTORS * GPUCA_ROW_COUNT, 0));
-  TransferMemoryResourcesToHost(RecoStep::TPCConversion, &convert, 0);
-  SynchronizeStream(0);
-
-  for (uint32_t i = 0; i < NSECTORS; i++) {
-    mIOPtrs.nClusterData[i] = (i == NSECTORS - 1 ? mIOPtrs.clustersNative->nClustersTotal : mIOPtrs.clustersNative->clusterOffset[i + 1][0]) - mIOPtrs.clustersNative->clusterOffset[i][0];
-    mIOPtrs.clusterData[i] = convert.mClusters + mIOPtrs.clustersNative->clusterOffset[i][0];
+  if (transferClusters) {
+    SynchronizeStream(0); // TODO: Synchronize implicitly with next step
   }
-  mRec->PopNonPersistentMemory(RecoStep::TPCConversion, qStr2Tag("TPCTRANS"));
   return 0;
 }
 
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
index ad740200a253a..8ef1b1980dc0c 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.cxx
@@ -30,7 +30,6 @@ GPUO2InterfaceDisplay::GPUO2InterfaceDisplay(const GPUO2InterfaceConfiguration*
   mConfig->configDisplay.showTPCTracksFromO2Format = true;
   mParam.reset(new GPUParam);
   mParam->SetDefaults(&config->configGRP, &config->configReconstruction, &config->configProcessing, nullptr);
-  mParam->par.earlyTpcTransform = 0;
   if (mConfig->configProcessing.runMC) {
     mQA.reset(new GPUQA(nullptr, &config->configQA, mParam.get()));
     mQA->InitO2MCData();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 9f9df0884901c..fb2fcdfd06776 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -30,7 +30,6 @@
 #endif
 
 #include "GPUTPCTracker.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTPCTrackParam.h"
 #include "GPUTPCGMMerger.h"
 #include "GPUO2DataTypes.h"
@@ -365,9 +364,6 @@ void* GPUTPCGMMerger::SetPointersOutput(void* mem)
     }
   }
   computePointerWithAlignment(mem, mClusters, mNMaxMergedTrackClusters);
-  if (mRec->GetParam().par.earlyTpcTransform) {
-    computePointerWithAlignment(mem, mClustersXYZ, mNMaxMergedTrackClusters);
-  }
   computePointerWithAlignment(mem, mClusterAttachment, mNMaxClusters);
   return mem;
 }
@@ -495,7 +491,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
   trk.SinPhi() = inTrack->Param().GetSinPhi();
   trk.DzDs() = inTrack->Param().GetDzDs();
   trk.QPt() = inTrack->Param().GetQPt();
-  trk.TZOffset() = Param().par.earlyTpcTransform ? inTrack->Param().GetZOffset() : GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin);
+  trk.TZOffset() = GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin);
   trk.ShiftZ(this, sector, sectorTrack.ClusterZT0(), sectorTrack.ClusterZTN(), inTrack->Param().GetX(), inTrack->Param().GetX()); // We do not store the inner / outer cluster X, so we just use the track X instead
   sectorTrack.SetX2(0.f);
   for (int32_t way = 0; way < 2; way++) {
@@ -517,13 +513,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
       row = ic.RowIndex();
       const ClusterNative& cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[GetConstantMem()->ioPtrs.clustersNative->clusterOffset[sector][0] + clusterIndex];
       flags = cl.getFlags();
-      if (Param().par.earlyTpcTransform) {
-        x = tracker.Data().ClusterData()[clusterIndex].x;
-        y = tracker.Data().ClusterData()[clusterIndex].y;
-        z = tracker.Data().ClusterData()[clusterIndex].z - trk.TZOffset();
-      } else {
-        GetConstantMem()->calibObjects.fastTransformHelper->Transform(sector, row, cl.getPad(), cl.getTime(), x, y, z, trk.TZOffset());
-      }
+      GetConstantMem()->calibObjects.fastTransformHelper->Transform(sector, row, cl.getPad(), cl.getTime(), x, y, z, trk.TZOffset());
       if (prop.PropagateToXAlpha(x, alpha, true)) {
         return way == 0;
       }
@@ -549,12 +539,8 @@ GPUd() void GPUTPCGMMerger::SetTrackClusterZT(GPUTPCGMSectorTrack& track, int32_
   const GPUTPCHitId& ic2 = trk.TrackHits()[sectorTr->FirstHitID() + sectorTr->NHits() - 1];
   int32_t clusterIndex1 = trk.Data().ClusterDataIndex(trk.Data().Row(ic1.RowIndex()), ic1.HitIndex());
   int32_t clusterIndex2 = trk.Data().ClusterDataIndex(trk.Data().Row(ic2.RowIndex()), ic2.HitIndex());
-  if (Param().par.earlyTpcTransform) {
-    track.SetClusterZT(trk.Data().ClusterData()[clusterIndex1].z, trk.Data().ClusterData()[clusterIndex2].z);
-  } else {
-    const ClusterNative* cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[iSector][0];
-    track.SetClusterZT(cl[clusterIndex1].getTime(), cl[clusterIndex2].getTime());
-  }
+  const ClusterNative* cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[iSector][0];
+  track.SetClusterZT(cl[clusterIndex1].getTime(), cl[clusterIndex2].getTime());
 }
 
 GPUd() void GPUTPCGMMerger::UnpackSaveNumber(int32_t id)
@@ -1285,16 +1271,14 @@ GPUd() void GPUTPCGMMerger::ResolveMergeSectors(GPUResolveSharedMemory& smem, in
   }
 }
 
-GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, const GPUTPCGMMergedTrackHitXYZ* clsXYZ, int32_t itr)
+GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, int32_t itr)
 {
   if (Param().rec.tpc.mergerCERowLimit > 0 && CAMath::Abs(track->QPt()) * Param().qptB5Scaler < 0.3f && (cls.row < Param().rec.tpc.mergerCERowLimit || cls.row >= GPUCA_ROW_COUNT - Param().rec.tpc.mergerCERowLimit)) {
     return;
   }
 
   float z = 0;
-  if (Param().par.earlyTpcTransform) {
-    z = clsXYZ->z;
-  } else {
+  {
     float x, y;
     auto& cln = mConstantMem->ioPtrs.clustersNative->clustersLinear[cls.num];
     GPUTPCConvertImpl::convert(*mConstantMem, cls.sector, cls.row, cln.getPad(), cln.getTime(), x, y, z);
@@ -1328,7 +1312,7 @@ GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const
 
 GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  const ClusterNative* cls = Param().par.earlyTpcTransform ? nullptr : mConstantMem->ioPtrs.clustersNative->clustersLinear;
+  const ClusterNative* cls = mConstantMem->ioPtrs.clustersNative->clustersLinear;
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nThreads * nBlocks) {
     if (mMergedTracks[i].CSide() == 0 && mTrackLinks[i] >= 0) {
       if (mTrackLinks[mTrackLinks[i]] != (int32_t)i) {
@@ -1357,14 +1341,8 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
 
       bool needswap = false;
       if (celooper) {
-        float z0max, z1max;
-        if (Param().par.earlyTpcTransform) {
-          z0max = CAMath::Max(CAMath::Abs(mClustersXYZ[trk[0]->FirstClusterRef()].z), CAMath::Abs(mClustersXYZ[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].z));
-          z1max = CAMath::Max(CAMath::Abs(mClustersXYZ[trk[1]->FirstClusterRef()].z), CAMath::Abs(mClustersXYZ[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].z));
-        } else {
-          z0max = -CAMath::Min(cls[mClusters[trk[0]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime());
-          z1max = -CAMath::Min(cls[mClusters[trk[1]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime());
-        }
+        const float z0max = -CAMath::Min(cls[mClusters[trk[0]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime());
+        const float z1max = -CAMath::Min(cls[mClusters[trk[1]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime());
         if (z1max < z0max) {
           needswap = true;
         }
@@ -1387,30 +1365,19 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
       }
 
       if (Param().par.continuousTracking) {
-        if (Param().par.earlyTpcTransform) {
-          const float z0 = trk[0]->CSide() ? CAMath::Max(mClustersXYZ[trk[0]->FirstClusterRef()].z, mClustersXYZ[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].z) : CAMath::Min(mClustersXYZ[trk[0]->FirstClusterRef()].z, mClustersXYZ[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].z);
-          const float z1 = trk[1]->CSide() ? CAMath::Max(mClustersXYZ[trk[1]->FirstClusterRef()].z, mClustersXYZ[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].z) : CAMath::Min(mClustersXYZ[trk[1]->FirstClusterRef()].z, mClustersXYZ[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].z);
-          const float offset = CAMath::Abs(z1) > CAMath::Abs(z0) ? -z0 : z1;
-          trk[1]->Param().Z() += trk[1]->Param().TZOffset() - offset;
-          trk[1]->Param().TZOffset() = offset;
-        } else {
-          GPUTPCGMMergedTrackHit* clsmax;
-          const float tmax = CAMath::MaxWithRef(cls[mClusters[trk[0]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime(),
-                                                cls[mClusters[trk[1]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime(),
-                                                &mClusters[trk[0]->FirstClusterRef()], &mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1],
-                                                &mClusters[trk[1]->FirstClusterRef()], &mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1], clsmax);
-          const float offset = CAMath::Max(tmax - mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(clsmax->sector, clsmax->row, cls[clsmax->num].getPad()), 0.f);
-          trk[1]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[1]->CSide() * NSECTORS / 2, trk[1]->Param().TZOffset() - offset);
-          trk[1]->Param().TZOffset() = offset;
-        }
+        GPUTPCGMMergedTrackHit* clsmax;
+        const float tmax = CAMath::MaxWithRef(cls[mClusters[trk[0]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime(),
+                                              cls[mClusters[trk[1]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime(),
+                                              &mClusters[trk[0]->FirstClusterRef()], &mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1],
+                                              &mClusters[trk[1]->FirstClusterRef()], &mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1], clsmax);
+        const float offset = CAMath::Max(tmax - mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(clsmax->sector, clsmax->row, cls[clsmax->num].getPad()), 0.f);
+        trk[1]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[1]->CSide() * NSECTORS / 2, trk[1]->Param().TZOffset() - offset);
+        trk[1]->Param().TZOffset() = offset;
       }
       int32_t pos = newRef;
 #pragma unroll
       for (int32_t k = 1; k >= 0; k--) {
         for (uint32_t j = 0; j != trk[k]->NClusters(); j++) {
-          if (Param().par.earlyTpcTransform) {
-            mClustersXYZ[pos] = mClustersXYZ[trk[k]->FirstClusterRef() + j];
-          }
           mClusters[pos++] = mClusters[trk[k]->FirstClusterRef() + j];
         }
       }
@@ -1513,7 +1480,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
           int32_t ichk = k ? lasttr : itr;
           const GPUTPCGMSectorTrack* trchk = &mSectorTrackInfos[ichk];
           while (true) {
-            float zt = Param().par.earlyTpcTransform ? CAMath::Min(CAMath::Abs(trchk->ClusterZT0()), CAMath::Abs(trchk->ClusterZTN())) : -trchk->MinClusterZT(); // Negative time ~ smallest z, behaves the same way
+            float zt = -trchk->MinClusterZT();
             if (zt < mainZT) {
               if (k) {
                 revertSegments = false;
@@ -1548,7 +1515,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
             }
             trchk = &mSectorTrackInfos[next];
           }
-          revertInSegment = (longest->ClusterZT0() < longest->ClusterZTN()) ^ (Param().par.earlyTpcTransform ? !longest->CSide() : false);
+          revertInSegment = longest->ClusterZT0() < longest->ClusterZTN();
         }
       }
       lastMergedSegment = -1;
@@ -1690,18 +1657,8 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
 
       for (int32_t i = 0; i < nHits; i++) {
         uint8_t state;
-        if (Param().par.earlyTpcTransform) {
-          const GPUTPCClusterData& c = GetConstantMem()->tpcTrackers[trackClusters[i].sector].ClusterData()[trackClusters[i].id - GetConstantMem()->tpcTrackers[trackClusters[i].sector].Data().ClusterIdOffset()];
-          GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iMergedTrackFirstCluster;
-          clXYZ[i].x = c.x;
-          clXYZ[i].y = c.y;
-          clXYZ[i].z = c.z;
-          clXYZ[i].amp = c.amp;
-          state = c.flags;
-        } else {
-          const ClusterNative& c = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[trackClusters[i].id];
-          state = c.getFlags();
-        }
+        const ClusterNative& c = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[trackClusters[i].id];
+        state = c.getFlags();
         cl[i].state = state & GPUTPCGMMergedTrackHit::clustererAndSharedFlags; // Only allow edge, deconvoluted, and shared flags
         cl[i].row = trackClusters[i].row;
         cl[i].num = trackClusters[i].id;
@@ -1737,7 +1694,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       lastMergedSegment = iOutputTrack;
 
       GPUTPCGMBorderTrack b;
-      const float toX = Param().par.earlyTpcTransform ? mClustersXYZ[iMergedTrackFirstCluster].x : GPUTPCGeometry::Row2X(cl[0].row);
+      const float toX = GPUTPCGeometry::Row2X(cl[0].row);
       if (p2.TransportToX<2>(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
         p1.X() = toX;
         p1.Y() = b.Par()[0];
@@ -1766,15 +1723,9 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       }
       if (mergedTrack.NClusters() && mergedTrack.OK()) */
       if (Param().rec.tpc.mergeCE) {
-        bool CEside;
-        if (Param().par.earlyTpcTransform) {
-          const GPUTPCGMMergedTrackHitXYZ* const clXYZ = mClustersXYZ + iMergedTrackFirstCluster;
-          CEside = (mergedTrack.CSide() != 0) ^ (clXYZ[0].z > clXYZ[nHits - 1].z);
-        } else {
-          auto& cls = mConstantMem->ioPtrs.clustersNative->clustersLinear;
-          CEside = cls[cl[0].num].getTime() < cls[cl[nHits - 1].num].getTime();
-        }
-        MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], Param().par.earlyTpcTransform ? &(mClustersXYZ + iMergedTrackFirstCluster)[CEside ? (nHits - 1) : 0] : nullptr, iOutputTrack);
+        auto& cls = mConstantMem->ioPtrs.clustersNative->clustersLinear;
+        bool CEside = cls[cl[0].num].getTime() < cls[cl[nHits - 1].num].getTime();
+        MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], iOutputTrack);
       }
     } while (false);
   }
@@ -1897,7 +1848,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads,
     const float qptabs = CAMath::Abs(p.GetQPt());
     if (trk.NClusters() && qptabs * Param().qptB5Scaler > 5.f && qptabs * Param().qptB5Scaler <= lowPtThresh) {
       const int32_t sector = mClusters[trk.FirstClusterRef() + trk.NClusters() - 1].sector;
-      const float refz = p.GetZ() + (Param().par.earlyTpcTransform ? p.GetTZOffset() : GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, p.GetTZOffset(), Param().continuousMaxTimeBin)) + (trk.CSide() ? -100 : 100);
+      const float refz = p.GetZ() + GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, p.GetTZOffset(), Param().continuousMaxTimeBin) + (trk.CSide() ? -100 : 100);
       float sinA, cosA;
       CAMath::SinCos(trk.GetAlpha(), sinA, cosA);
       float gx = cosA * p.GetX() - sinA * p.GetY();
@@ -1920,15 +1871,8 @@ GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads,
       /*printf("Track %u Sanity qpt %f snp %f bz %f\n", mMemory->nLooperMatchCandidates, p.GetQPt(), p.GetSinPhi(), bz);
       for (uint32_t k = 0;k < trk.NClusters();k++) {
         float xx, yy, zz;
-        if (Param().par.earlyTpcTransform) {
-          const float zOffset = (mClusters[trk.FirstClusterRef() + k].sector < 18) == (mClusters[trk.FirstClusterRef() + 0].sector < 18) ? p.GetTZOffset() : -p.GetTZOffset();
-          xx = mClustersXYZ[trk.FirstClusterRef() + k].x;
-          yy = mClustersXYZ[trk.FirstClusterRef() + k].y;
-          zz = mClustersXYZ[trk.FirstClusterRef() + k].z - zOffset;
-        } else {
-          const ClusterNative& GPUrestrict() cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[mClusters[trk.FirstClusterRef() + k].num];
-          GetConstantMem()->calibObjects.fastTransformHelper->Transform(mClusters[trk.FirstClusterRef() + k].sector, mClusters[trk.FirstClusterRef() + k].row, cl.getPad(), cl.getTime(), xx, yy, zz, p.GetTZOffset());
-        }
+        const ClusterNative& GPUrestrict() cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[mClusters[trk.FirstClusterRef() + k].num];
+        GetConstantMem()->calibObjects.fastTransformHelper->Transform(mClusters[trk.FirstClusterRef() + k].sector, mClusters[trk.FirstClusterRef() + k].row, cl.getPad(), cl.getTime(), xx, yy, zz, p.GetTZOffset());
         float sa2, ca2;
         CAMath::SinCos(Param().Alpha(mClusters[trk.FirstClusterRef() + k].sector), sa2, ca2);
         float cx = ca2 * xx - sa2 * yy;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 76f3f3cdcba08..7813ca4595271 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -116,8 +116,6 @@ class GPUTPCGMMerger : public GPUProcessor
   GPUhdi() uint32_t NMergedTrackClusters() const { return mMemory->nMergedTrackClusters; }
   GPUhdi() const GPUTPCGMMergedTrackHit* Clusters() const { return mClusters; }
   GPUhdi() GPUTPCGMMergedTrackHit* Clusters() { return (mClusters); }
-  GPUhdi() const GPUTPCGMMergedTrackHitXYZ* ClustersXYZ() const { return mClustersXYZ; }
-  GPUhdi() GPUTPCGMMergedTrackHitXYZ* ClustersXYZ() { return (mClustersXYZ); }
   GPUhdi() GPUAtomic(uint32_t) * ClusterAttachment() const { return mClusterAttachment; }
   GPUhdi() uint32_t* TrackOrderAttach() const { return mTrackOrderAttach; }
   GPUhdi() uint32_t* TrackOrderProcess() const { return mTrackOrderProcess; }
@@ -225,7 +223,7 @@ class GPUTPCGMMerger : public GPUProcessor
   template <int32_t I>
   GPUd() void MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode = 0);
 
-  GPUd() void MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, const GPUTPCGMMergedTrackHitXYZ* clsXYZ, int32_t itr);
+  GPUd() void MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, int32_t itr);
 
   void CheckMergedTracks();
 #ifndef GPUCA_GPUCODE
@@ -267,7 +265,6 @@ class GPUTPCGMMerger : public GPUProcessor
   GPUTPCGMSectorTrack* mSectorTrackInfos = nullptr; //* additional information for sector tracks
   int32_t* mSectorTrackInfoIndex = nullptr;
   GPUTPCGMMergedTrackHit* mClusters = nullptr;
-  GPUTPCGMMergedTrackHitXYZ* mClustersXYZ = nullptr;
   GPUAtomic(uint32_t) * mClusterAttachment = nullptr;
   o2::tpc::TrackTPC* mOutputTracksTPCO2 = nullptr;
   uint32_t* mOutputClusRefsTPCO2 = nullptr;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 90f2fce5cdd2e..e1cec59d96b95 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -19,7 +19,6 @@
 #include <iomanip>
 #include <numeric>
 #include "GPUTPCTracker.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTPCTrackParam.h"
 #include "GPUTPCGMMerger.h"
 #include "GPUO2DataTypes.h"
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index b10b1d0510fd7..ab3eb02db393e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -90,7 +90,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
     }
     uint32_t myId = CAMath::AtomicAdd(&merger.Memory()->nO2Tracks, 1u);
     tmpData[i] = {nCl, CAMath::AtomicAdd(&merger.Memory()->nO2ClusRefs, nCl + (nCl + 1) / 2)};
-    trackSort[myId] = {i, (merger.Param().par.earlyTpcTransform || tracks[i].CSide()) ? tracks[i].GetParam().GetTZOffset() : -tracks[i].GetParam().GetTZOffset()};
+    trackSort[myId] = {i, tracks[i].CSide() ? tracks[i].GetParam().GetTZOffset() : -tracks[i].GetParam().GetTZOffset()};
   }
 }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index 2b6d826baea56..a44837c897f46 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -37,11 +37,7 @@ GPUd() void GPUTPCGMSectorTrack::Set(const GPUTPCGMMerger* merger, const GPUTPCT
   mParam.mSecPhi = 1.f / mParam.mCosPhi;
   mAlpha = alpha;
   mSector = sector;
-  if (merger->Param().par.earlyTpcTransform) {
-    mTZOffset = t.GetZOffset();
-  } else {
-    mTZOffset = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, t.GetZOffset(), merger->Param().continuousMaxTimeBin);
-  }
+  mTZOffset = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, t.GetZOffset(), merger->Param().continuousMaxTimeBin);
   mNClusters = sectorTr->NHits();
 }
 
@@ -327,11 +323,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToX(GPUTPCGMMerger* merger, float x, f
   b.SetPar(2, ey1);
   b.SetPar(3, param.mDzDs);
   b.SetPar(4, param.mQPt);
-  if (merger->Param().par.earlyTpcTransform) {
-    b.SetZOffsetLinear(mTZOffset);
-  } else {
-    b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTZOffset, merger->Param().continuousMaxTimeBin));
-  }
+  b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTZOffset, merger->Param().continuousMaxTimeBin));
 
   if (!doCov) {
     return (1);
@@ -486,11 +478,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToXAlpha(GPUTPCGMMerger* merger, float
   b.SetPar(2, ey1);
   b.SetPar(3, dzds);
   b.SetPar(4, qpt);
-  if (merger->Param().par.earlyTpcTransform) {
-    b.SetZOffsetLinear(mTZOffset);
-  } else {
-    b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTZOffset, merger->Param().continuousMaxTimeBin));
-  }
+  b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTZOffset, merger->Param().continuousMaxTimeBin));
 
   b.SetCov(0, c00 + h2 * h2c22 + h4 * h4c44 + 2.f * (h2 * c20ph4c42 + h4 * c40));
   b.SetCov(1, c11 + dS * (c31 + n7));
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index c76d8f6ab4409..80d4809e4a466 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -29,7 +29,6 @@
 #include "GPUTPCGMPolynomialField.h"
 #include "GPUTPCGMMerger.h"
 #include "GPUTPCTracker.h"
-#include "GPUTPCClusterData.h"
 #include "GPUdEdx.h"
 #include "GPUParam.h"
 #include "GPUO2DataTypes.h"
@@ -54,7 +53,7 @@
 using namespace o2::gpu;
 using namespace o2::tpc;
 
-GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_t iTrk, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, GPUTPCGMMergedTrackHitXYZ* GPUrestrict() clustersXYZ, int32_t& GPUrestrict() N, int32_t& GPUrestrict() NTolerated, float& GPUrestrict() Alpha, int32_t attempt, float maxSinPhi, gputpcgmmergertypes::GPUTPCOuterParam* GPUrestrict() outerParam, int8_t leg)
+GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_t iTrk, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, int32_t& GPUrestrict() N, int32_t& GPUrestrict() NTolerated, float& GPUrestrict() Alpha, int32_t attempt, float maxSinPhi, gputpcgmmergertypes::GPUTPCOuterParam* GPUrestrict() outerParam, int8_t leg)
 {
   static constexpr float kDeg2Rad = M_PI / 180.f;
   CADEBUG(static constexpr float kSectAngle = 2 * M_PI / 18.f);
@@ -68,7 +67,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
   prop.SetPolynomialField(&param.polynomialField);
   prop.SetMaxSinPhi(maxSinPhi);
   if ((clusters[0].sector < 18) == (clusters[N - 1].sector < 18)) {
-    ShiftZ2(clusters, clustersXYZ, merger, N);
+    ShiftZ2(clusters, merger, N);
   }
   if (param.rec.tpc.mergerInterpolateErrors) {
     for (int32_t i = 0; i < N; i++) {
@@ -136,12 +135,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       uint8_t clusterState = clusters[ihit].state;
       const float clAlpha = param.Alpha(clusters[ihit].sector);
       float xx, yy, zz;
-      if (param.par.earlyTpcTransform) {
-        const float zOffset = (clusters[ihit].sector < 18) == (clusters[0].sector < 18) ? mTZOffset : -mTZOffset;
-        xx = clustersXYZ[ihit].x;
-        yy = clustersXYZ[ihit].y;
-        zz = clustersXYZ[ihit].z - zOffset;
-      } else {
+      {
         const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
         merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), xx, yy, zz, mTZOffset);
       }
@@ -150,7 +144,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       // CADEBUG(if ((uint32_t)merger->GetTrackingChain()->mIOPtrs.nMCLabelsTPC > clusters[ihit].num))
       // CADEBUG({printf(" MC:"); for (int32_t i = 0; i < 3; i++) {int32_t mcId = merger->GetTrackingChain()->mIOPtrs.mcLabelsTPC[clusters[ihit].num].fClusterID[i].fMCID; if (mcId >= 0) printf(" %d", mcId); } } printf("\n"));
       // clang-format on
-      if (MergeDoubleRowClusters(ihit, wayDirection, clusters, clustersXYZ, merger, prop, xx, yy, zz, maxN, clAlpha, clusterState, allowModification) == -1) {
+      if (MergeDoubleRowClusters(ihit, wayDirection, clusters, merger, prop, xx, yy, zz, maxN, clAlpha, clusterState, allowModification) == -1) {
         nMissed++;
         nMissed2++;
         continue;
@@ -334,15 +328,11 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
               float qtot = 0, qmax = 0, pad = 0, relTime = 0;
               const int32_t clusterCount = (ihit - ihitMergeFirst) * wayDirection + 1;
               for (int32_t iTmp = ihitMergeFirst; iTmp != ihit + wayDirection; iTmp += wayDirection) {
-                if (merger->GetConstantMem()->ioPtrs.clustersNative == nullptr) {
-                  qtot += clustersXYZ[ihit].amp;
-                } else {
-                  const ClusterNative& cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num];
-                  qtot += cl.qTot;
-                  qmax = CAMath::Max<float>(qmax, cl.qMax);
-                  pad += cl.getPad();
-                  relTime += cl.getTime();
-                }
+                const ClusterNative& cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num];
+                qtot += cl.qTot;
+                qmax = CAMath::Max<float>(qmax, cl.qMax);
+                pad += cl.getPad();
+                relTime += cl.getTime();
               }
               qtot /= clusterCount; // TODO: Weighted Average
               pad /= clusterCount;
@@ -372,7 +362,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       }
     }
     if (((nWays - iWay) & 1) && (iWay != nWays - 1) && (clusters[0].sector < 18) == (clusters[maxN - 1].sector < 18)) {
-      ShiftZ2(clusters, clustersXYZ, merger, maxN);
+      ShiftZ2(clusters, merger, maxN);
     }
   }
   ConstrainSinPhi();
@@ -460,7 +450,7 @@ GPUd() void GPUTPCGMTrackParam::MirrorTo(GPUTPCGMPropagator& GPUrestrict() prop,
   mChi2 = 0;
 }
 
-GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t wayDirection, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, const GPUTPCGMMerger* GPUrestrict() merger, GPUTPCGMPropagator& GPUrestrict() prop, float& GPUrestrict() xx, float& GPUrestrict() yy, float& GPUrestrict() zz, int32_t maxN, float clAlpha, uint8_t& GPUrestrict() clusterState, bool rejectChi2)
+GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t wayDirection, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, const GPUTPCGMMerger* GPUrestrict() merger, GPUTPCGMPropagator& GPUrestrict() prop, float& GPUrestrict() xx, float& GPUrestrict() yy, float& GPUrestrict() zz, int32_t maxN, float clAlpha, uint8_t& GPUrestrict() clusterState, bool rejectChi2)
 {
   if (ihit + wayDirection >= 0 && ihit + wayDirection < maxN && clusters[ihit].row == clusters[ihit + wayDirection].row && clusters[ihit].sector == clusters[ihit + wayDirection].sector) {
     float maxDistY, maxDistZ;
@@ -479,18 +469,10 @@ GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t
     xx = yy = zz = 0.f;
     clusterState = 0;
     while (true) {
-      float clx, cly, clz, clamp;
-      if (merger->Param().par.earlyTpcTransform) {
-        const float zOffset = (clusters[ihit].sector < 18) == (clusters[0].sector < 18) ? mTZOffset : -mTZOffset;
-        clx = clustersXYZ[ihit].x;
-        cly = clustersXYZ[ihit].y;
-        clz = clustersXYZ[ihit].z - zOffset;
-        clamp = clustersXYZ[ihit].amp;
-      } else {
-        const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
-        clamp = cl.qTot;
-        merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), clx, cly, clz, mTZOffset);
-      }
+      const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
+      float clamp = cl.qTot;
+      float clx, cly, clz;
+      merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), clx, cly, clz, mTZOffset);
       float dy = cly - projY;
       float dz = clz - projZ;
       if (noReject == 0 && (dy * dy > maxDistY || dz * dz > maxDistZ)) {
@@ -525,16 +507,11 @@ GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t
 GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop)
 {
   float Y, Z;
-  if (Merger->Param().par.earlyTpcTransform) {
+  float X = 0;
+  Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoX(sector, iRow, mP[0], mP[1], X);
+  if (prop.GetPropagatedYZ(X, Y, Z)) {
     Y = mP[0];
     Z = mP[1];
-  } else {
-    float X = 0;
-    Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoX(sector, iRow, mP[0], mP[1], X);
-    if (prop.GetPropagatedYZ(X, Y, Z)) {
-      Y = mP[0];
-      Z = mP[1];
-    }
   }
   return AttachClusters(Merger, sector, iRow, iTrack, goodLeg, Y, Z);
 }
@@ -544,7 +521,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   if (Merger->Param().rec.tpc.disableRefitAttachment & 1) {
     return -1e6f;
   }
-  const GPUTPCTracker& GPUrestrict() tracker = *(Merger -> GetConstantMem()->tpcTrackers + sector);
+  const GPUTPCTracker& GPUrestrict() tracker = *(Merger->GetConstantMem()->tpcTrackers + sector);
   const GPUTPCRow& GPUrestrict() row = tracker.Row(iRow);
   GPUglobalref() const cahit2* hits = tracker.HitData(row);
   GPUglobalref() const calink* firsthit = tracker.FirstHitInBin(row);
@@ -552,7 +529,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
     return -1e6f;
   }
 
-  const float zOffset = Merger->Param().par.earlyTpcTransform ? ((Merger->MergedTracks()[iTrack].CSide() ^ (sector >= 18)) ? -mTZOffset : mTZOffset) : Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTZOffset, Merger->Param().continuousMaxTimeBin);
+  const float zOffset = Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTZOffset, Merger->Param().continuousMaxTimeBin);
   const float y0 = row.Grid().YMin();
   const float stepY = row.HstepY();
   const float z0 = row.Grid().ZMin() - zOffset; // We can use our own ZOffset, since this is only used temporarily anyway
@@ -568,12 +545,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   const float sy21 = 1.f / sy2;
   const float sz21 = 1.f / sz2;
   float uncorrectedY, uncorrectedZ;
-  if (Merger->Param().par.earlyTpcTransform) {
-    uncorrectedY = Y;
-    uncorrectedZ = Z;
-  } else {
-    Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(sector, iRow, Y, Z, uncorrectedY, uncorrectedZ);
-  }
+  Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(sector, iRow, Y, Z, uncorrectedY, uncorrectedZ);
 
   if (CAMath::Abs(uncorrectedY) > row.getTPCMaxY()) {
     return uncorrectedY;
@@ -870,25 +842,18 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPUr
   }
 }
 
-GPUd() void GPUTPCGMTrackParam::ShiftZ2(const GPUTPCGMMergedTrackHit* clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, const GPUTPCGMMerger* merger, int32_t N)
+GPUd() void GPUTPCGMTrackParam::ShiftZ2(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N)
 {
   float tzInner, tzOuter;
   float xInner, xOuter;
   if (N == 0) {
     N = 1;
   }
-  if (merger->Param().par.earlyTpcTransform) {
-    tzInner = clustersXYZ[N - 1].z;
-    tzOuter = clustersXYZ[0].z;
-    xInner = clustersXYZ[N - 1].x;
-    xOuter = clustersXYZ[0].x;
-  } else {
-    const auto& GPUrestrict() cls = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
-    tzInner = cls[clusters[N - 1].num].getTime();
-    tzOuter = cls[clusters[0].num].getTime();
-    xInner = GPUTPCGeometry::Row2X(clusters[N - 1].row);
-    xOuter = GPUTPCGeometry::Row2X(clusters[0].row);
-  }
+  const auto& GPUrestrict() cls = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
+  tzInner = cls[clusters[N - 1].num].getTime();
+  tzOuter = cls[clusters[0].num].getTime();
+  xInner = GPUTPCGeometry::Row2X(clusters[N - 1].row);
+  xOuter = GPUTPCGeometry::Row2X(clusters[0].row);
   ShiftZ(merger, clusters[0].sector, tzInner, tzOuter, xInner, xOuter);
 }
 
@@ -925,53 +890,20 @@ GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merge
   }
 
   if (!beamlineReached) {
-    if (merger->Param().par.earlyTpcTransform) {
-      float basez, basex;
-      if (CAMath::Abs(tz1) < CAMath::Abs(tz2)) {
-        basez = tz1;
-        basex = x1;
-      } else {
-        basez = tz2;
-        basex = x2;
-      }
-      float refZ = ((basez > 0) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * basex;
-      deltaZ = basez - refZ - mTZOffset;
+    float baset, basex;
+    if (CAMath::Abs(tz1) > CAMath::Abs(tz2)) {
+      baset = tz1;
+      basex = x1;
     } else {
-      float baset, basex;
-      if (CAMath::Abs(tz1) > CAMath::Abs(tz2)) {
-        baset = tz1;
-        basex = x1;
-      } else {
-        baset = tz2;
-        basex = x2;
-      }
-      float refZ = ((sector < GPUCA_NSECTORS / 2) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * basex;
-      float basez;
-      merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->TransformIdealZ(sector, baset, basez, mTZOffset);
-      deltaZ = basez - refZ;
+      baset = tz2;
+      basex = x2;
     }
+    float refZ = ((sector < GPUCA_NSECTORS / 2) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * basex;
+    float basez;
+    merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->TransformIdealZ(sector, baset, basez, mTZOffset);
+    deltaZ = basez - refZ;
   }
-  if (merger->Param().par.earlyTpcTransform) {
-    mTZOffset += deltaZ;
-    mP[1] -= deltaZ;
-    deltaZ = 0;
-    float zMax = CAMath::Max(tz1, tz2);
-    float zMin = CAMath::Min(tz1, tz2);
-    // printf("Z Check: Clusters %f %f, min %f max %f vtx %f\n", tz1, tz2, zMin, zMax, mTZOffset);
-    if (zMin < 0 && zMin - mTZOffset < -GPUTPCGeometry::TPCLength()) {
-      deltaZ = zMin - mTZOffset + GPUTPCGeometry::TPCLength();
-    } else if (zMax > 0 && zMax - mTZOffset > GPUTPCGeometry::TPCLength()) {
-      deltaZ = zMax - mTZOffset - GPUTPCGeometry::TPCLength();
-    }
-    if (zMin < 0 && zMax - (mTZOffset + deltaZ) > 0) {
-      deltaZ = zMax - mTZOffset;
-    } else if (zMax > 0 && zMin - (mTZOffset + deltaZ) < 0) {
-      deltaZ = zMin - mTZOffset;
-    }
-    // if (deltaZ != 0) printf("Moving clusters to TPC Range: Shift %f in Z: %f to %f --> %f to %f in Z\n", deltaZ, tz2 - mTZOffset, tz1 - mTZOffset, tz2 - mTZOffset - deltaZ, tz1 - mTZOffset - deltaZ);
-    mTZOffset += deltaZ;
-    mP[1] -= deltaZ;
-  } else {
+  {
     float deltaT = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaZtoDeltaTimeInTimeFrame(sector, deltaZ);
     mTZOffset += deltaT;
     mP[1] -= deltaZ;
@@ -1047,7 +979,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
   GPUTPCGMTrackParam t = track.Param();
   float Alpha = track.Alpha();
   CADEBUG(int32_t nTrackHitsOld = nTrackHits; float ptOld = t.QPt());
-  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), merger->Param().par.earlyTpcTransform ? merger->ClustersXYZ() + track.FirstClusterRef() : nullptr, nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, &track.OuterParam(), track.Leg());
+  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, &track.OuterParam(), track.Leg());
   CADEBUG(printf("Finished Fit Track %d\n", iTrk));
   CADEBUG(printf("OUTPUT hits %d -> %d+%d = %d, QPt %f -> %f, SP %f, ok %d chi2 %f chi2ndf %f\n", nTrackHitsOld, nTrackHits, NTolerated, nTrackHits + NTolerated, ptOld, t.QPt(), t.SinPhi(), (int32_t)ok, t.Chi2(), t.Chi2() / CAMath::Max(1, nTrackHits)));
 
@@ -1061,7 +993,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
       NTolerated = 0; // Clusters not fit but tollerated for track length cut
       t = track.Param();
       Alpha = track.Alpha();
-      ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), merger->ClustersXYZ() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, 1, GPUCA_MAX_SIN_PHI, &track.OuterParam(), track.Leg());
+      ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, 1, GPUCA_MAX_SIN_PHI, &track.OuterParam(), track.Leg());
     } else {
       uint32_t nRefit = CAMath::AtomicAdd(&merger->Memory()->nRetryRefit, 1u);
       merger->RetryRefitIds()[nRefit] = iTrk;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index 3412388003ec6..435f88bb93a16 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -141,10 +141,10 @@ class GPUTPCGMTrackParam
   GPUd() bool CheckNumericalQuality(float overrideCovYY = -1.f) const;
   GPUd() bool CheckCov() const;
 
-  GPUd() bool Fit(GPUTPCGMMerger* merger, int32_t iTrk, GPUTPCGMMergedTrackHit* clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, int32_t& N, int32_t& NTolerated, float& Alpha, int32_t attempt = 0, float maxSinPhi = GPUCA_MAX_SIN_PHI, gputpcgmmergertypes::GPUTPCOuterParam* outerParam = nullptr, int8_t leg = 0);
+  GPUd() bool Fit(GPUTPCGMMerger* merger, int32_t iTrk, GPUTPCGMMergedTrackHit* clusters, int32_t& N, int32_t& NTolerated, float& Alpha, int32_t attempt = 0, float maxSinPhi = GPUCA_MAX_SIN_PHI, gputpcgmmergertypes::GPUTPCOuterParam* outerParam = nullptr, int8_t leg = 0);
   GPUd() void MoveToReference(GPUTPCGMPropagator& prop, const GPUParam& param, float& alpha);
   GPUd() void MirrorTo(GPUTPCGMPropagator& prop, float toY, float toZ, bool inFlyDirection, const GPUParam& param, uint8_t row, uint8_t clusterState, bool mirrorParameters, int8_t sector);
-  GPUd() int32_t MergeDoubleRowClusters(int32_t& ihit, int32_t wayDirection, GPUTPCGMMergedTrackHit* clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, const GPUTPCGMMerger* merger, GPUTPCGMPropagator& prop, float& xx, float& yy, float& zz, int32_t maxN, float clAlpha, uint8_t& clusterState, bool rejectChi2);
+  GPUd() int32_t MergeDoubleRowClusters(int32_t& ihit, int32_t wayDirection, GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, GPUTPCGMPropagator& prop, float& xx, float& yy, float& zz, int32_t maxN, float clAlpha, uint8_t& clusterState, bool rejectChi2);
 
   GPUd() bool AttachClustersPropagate(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t lastRow, int32_t toRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop, bool inFlyDirection, float maxSinPhi = GPUCA_MAX_SIN_PHI, bool checkdEdx = false);
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop); // Returns uncorrectedY for later use
@@ -184,7 +184,7 @@ class GPUTPCGMTrackParam
 
   GPUd() void Rotate(float alpha);
   GPUd() void ShiftZ(const GPUTPCGMMerger* merger, int32_t sector, float tzInner, float tzOuter, float x1, float x2);
-  GPUd() void ShiftZ2(const GPUTPCGMMergedTrackHit* clusters, GPUTPCGMMergedTrackHitXYZ* clustersXYZ, const GPUTPCGMMerger* merger, int32_t N);
+  GPUd() void ShiftZ2(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N);
 
   GPUd() static float Reciprocal(float x) { return 1.f / x; }
   GPUdi() static void Assign(float& x, bool mask, float v)
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCSectorDebugSortKernels.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCSectorDebugSortKernels.cxx
index 7981ef5af26d8..afd90184b60ca 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCSectorDebugSortKernels.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCSectorDebugSortKernels.cxx
@@ -13,7 +13,6 @@
 /// \author David Rohr
 
 #include "GPUParam.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTPCHit.h"
 #include "GPUTPCTrackingData.h"
 #include "GPUProcessor.h"
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index c19e96f1879a8..41530cb629ce8 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -17,7 +17,6 @@
 #include "GPUTPCTrack.h"
 #include "GPUCommonMath.h"
 
-#include "GPUTPCClusterData.h"
 #include "GPUO2DataTypes.h"
 #include "GPUTPCTrackParam.h"
 #include "GPUParam.inc"
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
index 3bebdc4fa2b06..60cc12573be99 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
@@ -69,10 +69,6 @@ class GPUTPCTracker : public GPUProcessor
     int32_t nLocalTrackHits = 0;        // see above
   };
 
-  GPUhdi() GPUglobalref() const GPUTPCClusterData* ClusterData() const
-  {
-    return mData.ClusterData();
-  }
   GPUhdi() const GPUTPCRow& Row(const GPUTPCHitId& HitId) const { return mData.Row(HitId.RowIndex()); }
   GPUhdni() GPUglobalref() commonMemoryStruct* CommonMemory() const
   {
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
index 6c3ffbb5120bc..7ebe13e8bfb9e 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
@@ -13,7 +13,6 @@
 /// \author Matthias Kretz, Sergey Gorbunov, David Rohr
 
 #include "GPUParam.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTPCHit.h"
 #include "GPUTPCTrackingData.h"
 #include "GPUProcessor.h"
@@ -45,9 +44,8 @@ void GPUTPCTrackingData::InitializeRows(const GPUParam& p)
   }
 }
 
-void GPUTPCTrackingData::SetClusterData(const GPUTPCClusterData* data, int32_t nClusters, int32_t clusterIdOffset)
+void GPUTPCTrackingData::SetClusterData(int32_t nClusters, int32_t clusterIdOffset)
 {
-  mClusterData = data;
   mNumberOfHits = nClusters;
   mClusterIdOffset = clusterIdOffset;
 }
@@ -164,50 +162,10 @@ GPUdii() void GPUTPCTrackingData::SetRowGridEmpty(GPUTPCRow& GPUrestrict() row)
 
 GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUconstantref() const GPUConstantMem* GPUrestrict() mem, int32_t iSector, float* tmpMinMax)
 {
-#ifdef GPUCA_GPUCODE
-  constexpr bool EarlyTransformWithoutClusterNative = false;
-#else
-  bool EarlyTransformWithoutClusterNative = mem->param.par.earlyTpcTransform && mem->ioPtrs.clustersNative == nullptr;
-#endif
-  int32_t* tmpHitIndex = nullptr;
-  const uint32_t* NumberOfClustersInRow = nullptr;
-  const uint32_t* RowOffsets = nullptr;
-
 #ifndef GPUCA_GPUCODE
   vecpod<float2> YZData(mNumberOfHits);
   vecpod<calink> binMemory(mNumberOfHits);
-  uint32_t RowOffsetsA[GPUCA_ROW_COUNT];
-  uint32_t NumberOfClustersInRowA[GPUCA_ROW_COUNT];
-
   vecpod<int32_t> tmpHitIndexA;
-  if (EarlyTransformWithoutClusterNative) { // Implies mem->param.par.earlyTpcTransform but no ClusterNative present
-    NumberOfClustersInRow = NumberOfClustersInRowA;
-    RowOffsets = RowOffsetsA;
-    tmpHitIndexA.resize(mNumberOfHits);
-    tmpHitIndex = tmpHitIndexA.data();
-
-    memset(NumberOfClustersInRowA, 0, GPUCA_ROW_COUNT * sizeof(NumberOfClustersInRowA[0]));
-    for (int32_t i = 0; i < mNumberOfHits; i++) {
-      const int32_t tmpRow = mClusterData[i].row;
-      NumberOfClustersInRowA[tmpRow]++;
-    }
-    int32_t tmpOffset = 0;
-    for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
-      RowOffsetsA[i] = tmpOffset;
-      tmpOffset += NumberOfClustersInRow[i];
-    }
-    int32_t RowsFilled[GPUCA_ROW_COUNT];
-    memset(RowsFilled, 0, GPUCA_ROW_COUNT * sizeof(int32_t));
-    for (int32_t i = 0; i < mNumberOfHits; i++) {
-      float2 tmp;
-      tmp.x = mClusterData[i].y;
-      tmp.y = mClusterData[i].z;
-      int32_t tmpRow = mClusterData[i].row;
-      int32_t newIndex = RowOffsetsA[tmpRow] + (RowsFilled[tmpRow])++;
-      YZData[newIndex] = tmp;
-      tmpHitIndex[newIndex] = i;
-    }
-  } // Other cases below in loop over rows
 #else
   float2* YZData = (float2*)mLinkUpData; // TODO: we can do this as well on the CPU, just must make sure that CPU has the scratch memory
   calink* binMemory = (calink*)mHitWeights;
@@ -221,8 +179,8 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
     float zMin = 1.e6f;
     float zMax = -1.e6f;
 
-    const uint32_t NumberOfClusters = EarlyTransformWithoutClusterNative ? NumberOfClustersInRow[rowIndex] : mem->ioPtrs.clustersNative->nClusters[iSector][rowIndex];
-    const uint32_t RowOffset = EarlyTransformWithoutClusterNative ? RowOffsets[rowIndex] : (mem->ioPtrs.clustersNative->clusterOffset[iSector][rowIndex] - mem->ioPtrs.clustersNative->clusterOffset[iSector][0]);
+    const uint32_t NumberOfClusters = mem->ioPtrs.clustersNative->nClusters[iSector][rowIndex];
+    const uint32_t RowOffset = mem->ioPtrs.clustersNative->clusterOffset[iSector][rowIndex] - mem->ioPtrs.clustersNative->clusterOffset[iSector][0];
     constexpr const uint32_t maxN = 1u << (sizeof(calink) < 3 ? (sizeof(calink) * 8) : 24);
     GPUTPCRow& row = mRows[rowIndex];
     if (iThread == 0) {
@@ -251,25 +209,11 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
       continue;
     }
 
-    if (EarlyTransformWithoutClusterNative) {
-      for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
-        UpdateMinMaxYZ(yMin, yMax, zMin, zMax, YZData[RowOffset + i].x, YZData[RowOffset + i].y);
-      }
-    } else if (mem->param.par.earlyTpcTransform) { // Early transform case with ClusterNative present
-      for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
-        float2 tmp;
-        tmp.x = mClusterData[RowOffset + i].y;
-        tmp.y = mClusterData[RowOffset + i].z;
-        UpdateMinMaxYZ(yMin, yMax, zMin, zMax, tmp.x, tmp.y);
-        YZData[RowOffset + i] = tmp;
-      }
-    } else {
-      for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
-        float x, y, z;
-        GPUTPCConvertImpl::convert(*mem, iSector, rowIndex, mem->ioPtrs.clustersNative->clusters[iSector][rowIndex][i].getPad(), mem->ioPtrs.clustersNative->clusters[iSector][rowIndex][i].getTime(), x, y, z);
-        UpdateMinMaxYZ(yMin, yMax, zMin, zMax, y, z);
-        YZData[RowOffset + i] = CAMath::MakeFloat2(y, z);
-      }
+    for (uint32_t i = iThread; i < NumberOfClusters; i += nThreads) {
+      float x, y, z;
+      GPUTPCConvertImpl::convert(*mem, iSector, rowIndex, mem->ioPtrs.clustersNative->clusters[iSector][rowIndex][i].getPad(), mem->ioPtrs.clustersNative->clusters[iSector][rowIndex][i].getTime(), x, y, z);
+      UpdateMinMaxYZ(yMin, yMax, zMin, zMax, y, z);
+      YZData[RowOffset + i] = CAMath::MakeFloat2(y, z);
     }
 
     if (iThread == 0) {
@@ -380,7 +324,7 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
       const int32_t globalHitIndex = RowOffset + hitIndex;
 
       // allows to find the global hit index / coordinates from a global bin sorted hit index
-      mClusterDataIndex[globalBinsortedIndex] = EarlyTransformWithoutClusterNative ? tmpHitIndex[globalHitIndex] : (RowOffset + hitIndex);
+      mClusterDataIndex[globalBinsortedIndex] = RowOffset + hitIndex;
 
       const float xx = ((YZData[globalHitIndex].x - y0) * stepYi) + .5;
       const float yy = ((YZData[globalHitIndex].y - z0) * stepZi) + .5;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.h
index b08fbed4b319d..3db4b6c36e722 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.h
@@ -29,13 +29,13 @@ class GPUTPCHit;
 class GPUTPCTrackingData
 {
  public:
-  GPUTPCTrackingData() : mNumberOfHits(0), mNumberOfHitsPlusAlign(0), mClusterIdOffset(0), mRows(nullptr), mLinkUpData(nullptr), mLinkDownData(nullptr), mClusterData(nullptr) {}
+  GPUTPCTrackingData() = default;
 
 #ifndef GPUCA_GPUCODE_DEVICE
   ~GPUTPCTrackingData() = default;
   void InitializeRows(const GPUParam& p);
   void SetMaxData();
-  void SetClusterData(const GPUTPCClusterData* data, int32_t nClusters, int32_t clusterIdOffset);
+  void SetClusterData(int32_t nClusters, int32_t clusterIdOffset);
   void* SetPointersScratch(void* mem, bool idsOnGPU);
   void* SetPointersLinks(void* mem);
   void* SetPointersWeights(void* mem);
@@ -112,8 +112,6 @@ class GPUTPCTrackingData
 
   GPUhdi() GPUglobalref() GPUAtomic(uint32_t) * HitWeights() { return (mHitWeights); }
 
-  GPUhdi() GPUglobalref() const GPUTPCClusterData* ClusterData() const { return mClusterData; }
-
  private:
 #ifndef GPUCA_GPUCODE
   GPUTPCTrackingData& operator=(const GPUTPCTrackingData&) = delete; // ROOT 5 tries to use this if it is not private
@@ -127,16 +125,16 @@ class GPUTPCTrackingData
   friend class GPUTPCNeighboursFinder;
   friend class GPUTPCStartHitsFinder;
 
-  int32_t mNumberOfHits; // the number of hits in this sector
-  int32_t mNumberOfHitsPlusAlign;
-  int32_t mClusterIdOffset;
+  int32_t mNumberOfHits = 0; // the number of hits in this sector
+  int32_t mNumberOfHitsPlusAlign = 0;
+  int32_t mClusterIdOffset = 0;
 
-  GPUglobalref() GPUTPCRow* mRows; // The row objects needed for most accessor functions
+  GPUglobalref() GPUTPCRow* mRows = nullptr; // The row objects needed for most accessor functions
 
-  GPUglobalref() calink* mLinkUpData;        // hit index in the row above which is linked to the given (global) hit index
-  GPUglobalref() calink* mLinkDownData;      // hit index in the row below which is linked to the given (global) hit index
-  GPUglobalref() cahit2* mHitData;           // packed y,z coordinate of the given (global) hit index
-  GPUglobalref() int32_t* mClusterDataIndex; // see ClusterDataIndex()
+  GPUglobalref() calink* mLinkUpData = nullptr;        // hit index in the row above which is linked to the given (global) hit index
+  GPUglobalref() calink* mLinkDownData = nullptr;      // hit index in the row below which is linked to the given (global) hit index
+  GPUglobalref() cahit2* mHitData = nullptr;           // packed y,z coordinate of the given (global) hit index
+  GPUglobalref() int32_t* mClusterDataIndex = nullptr; // see ClusterDataIndex()
 
   /*
    * The size of the array is row.Grid.N + row.Grid.Ny + 3. The row.Grid.Ny + 3 is an optimization
@@ -144,7 +142,6 @@ class GPUTPCTrackingData
    */
   GPUglobalref() calink* mFirstHitInBin;            // see FirstHitInBin
   GPUglobalref() GPUAtomic(uint32_t) * mHitWeights; // the weight of the longest tracklet crossed the cluster
-  GPUglobalref() const GPUTPCClusterData* mClusterData;
 };
 
 GPUdi() calink GPUTPCTrackingData::HitLinkUpData(const GPUTPCRow& row, const calink& hitIndex) const { return mLinkUpData[row.mHitNumberOffset + hitIndex]; }
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 1b1cb510af7be..38af340d67d7a 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -585,7 +585,7 @@ int32_t LoadEvent(int32_t iEvent, int32_t x)
     }
   }
 
-  if (!rec->GetParam().par.earlyTpcTransform && !chainTracking->mIOPtrs.clustersNative && !chainTracking->mIOPtrs.tpcPackedDigits && !chainTracking->mIOPtrs.tpcZS && !chainTracking->mIOPtrs.tpcCompressedClusters) {
+  if (!chainTracking->mIOPtrs.clustersNative && !chainTracking->mIOPtrs.tpcPackedDigits && !chainTracking->mIOPtrs.tpcZS && !chainTracking->mIOPtrs.tpcCompressedClusters) {
     printf("Need cluster native data for on-the-fly TPC transform\n");
     return 1;
   }
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx b/GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx
deleted file mode 100644
index 899149d320bda..0000000000000
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvert.cxx
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCConvert.cxx
-/// \author David Rohr
-
-#include "GPUTPCConvert.h"
-#include "TPCFastTransform.h"
-#include "GPUTPCClusterData.h"
-#include "GPUReconstruction.h"
-#include "GPUO2DataTypes.h"
-#include "GPUParam.h"
-
-using namespace o2::gpu;
-
-void GPUTPCConvert::InitializeProcessor() {}
-
-void* GPUTPCConvert::SetPointersOutput(void* mem)
-{
-  if (mRec->GetParam().par.earlyTpcTransform) {
-    computePointerWithAlignment(mem, mClusters, mNClustersTotal);
-  }
-  return mem;
-}
-
-void* GPUTPCConvert::SetPointersMemory(void* mem)
-{
-  computePointerWithAlignment(mem, mMemory, 1);
-  return mem;
-}
-
-void GPUTPCConvert::RegisterMemoryAllocation()
-{
-  AllocateAndInitializeLate();
-  mMemoryResMemory = mRec->RegisterMemoryAllocation(this, &GPUTPCConvert::SetPointersMemory, GPUMemoryResource::MEMORY_INPUT | GPUMemoryResource::MEMORY_PERMANENT, "TPCConvertMemory");
-  mMemoryResOutput = mRec->RegisterMemoryAllocation(this, &GPUTPCConvert::SetPointersOutput, GPUMemoryResource::MEMORY_OUTPUT, "TPCConvertOutput");
-}
-
-void GPUTPCConvert::SetMaxData(const GPUTrackingInOutPointers& io)
-{
-  if (io.clustersNative) {
-    mNClustersTotal = io.clustersNative->nClustersTotal;
-  } else {
-    mNClustersTotal = 0;
-  }
-}
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvert.h b/GPU/GPUTracking/TPCConvert/GPUTPCConvert.h
deleted file mode 100644
index 9bf40417192b6..0000000000000
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvert.h
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCConvert.h
-/// \author David Rohr
-
-#ifndef GPUTPCCONVERT_H
-#define GPUTPCCONVERT_H
-
-#include "GPUDef.h"
-#include "GPUProcessor.h"
-
-namespace o2::gpu
-{
-struct GPUTPCClusterData;
-
-class GPUTPCConvert : public GPUProcessor
-{
-  friend class GPUTPCConvertKernel;
-  friend class GPUChainTracking;
-
- public:
-#ifndef GPUCA_GPUCODE
-  void InitializeProcessor();
-  void RegisterMemoryAllocation();
-  void SetMaxData(const GPUTrackingInOutPointers& io);
-
-  void* SetPointersOutput(void* mem);
-  void* SetPointersMemory(void* mem);
-#endif
-
-  constexpr static uint32_t NSECTORS = GPUCA_NSECTORS;
-
-  struct Memory {
-    GPUTPCClusterData* clusters[NSECTORS];
-  };
-
- protected:
-  Memory* mMemory = nullptr;
-  GPUTPCClusterData* mClusters = nullptr;
-  uint32_t mNClustersTotal = 0;
-
-  int16_t mMemoryResOutput = -1;
-  int16_t mMemoryResMemory = -1;
-};
-} // namespace o2::gpu
-
-#endif
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx b/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx
deleted file mode 100644
index 806a06dfbbe02..0000000000000
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.cxx
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCConvertKernel.cxx
-/// \author David Rohr
-
-#include "GPUTPCConvertKernel.h"
-#include "GPUConstantMem.h"
-#include "TPCFastTransform.h"
-#include "GPUTPCClusterData.h"
-#include "GPUO2DataTypes.h"
-#include "GPUTPCConvertImpl.h"
-
-using namespace o2::gpu;
-
-template <>
-GPUdii() void GPUTPCConvertKernel::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() processors)
-{
-  const int32_t iSector = iBlock / GPUCA_ROW_COUNT;
-  const int32_t iRow = iBlock % GPUCA_ROW_COUNT;
-  GPUTPCConvert& GPUrestrict() convert = processors.tpcConverter;
-  const o2::tpc::ClusterNativeAccess* GPUrestrict() native = processors.ioPtrs.clustersNative;
-  GPUTPCClusterData* GPUrestrict() clusters = convert.mMemory -> clusters[iSector];
-  const int32_t idOffset = native->clusterOffset[iSector][iRow];
-  const int32_t indexOffset = native->clusterOffset[iSector][iRow] - native->clusterOffset[iSector][0];
-
-  for (uint32_t k = get_local_id(0); k < native->nClusters[iSector][iRow]; k += get_local_size(0)) {
-    const auto& GPUrestrict() clin = native -> clusters[iSector][iRow][k];
-    float x, y, z;
-    GPUTPCConvertImpl::convert(processors, iSector, iRow, clin.getPad(), clin.getTime(), x, y, z);
-    auto& GPUrestrict() clout = clusters[indexOffset + k];
-    clout.x = x;
-    clout.y = y;
-    clout.z = z;
-    clout.row = iRow;
-    clout.amp = clin.qTot;
-    clout.flags = clin.getFlags();
-    clout.id = idOffset + k;
-  }
-}
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.h b/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.h
deleted file mode 100644
index d62e10e682a4b..0000000000000
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvertKernel.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCConvertKernel.h
-/// \author David Rohr
-
-#ifndef GPUTPCCONVERTKERNEL_H
-#define GPUTPCCONVERTKERNEL_H
-
-#include "GPUGeneralKernels.h"
-
-namespace o2::gpu
-{
-class GPUTPCConvertKernel : public GPUKernelTemplate
-{
- public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCConversion; }
-  template <int32_t iKernel = defaultKernel>
-  GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors);
-};
-} // namespace o2::gpu
-
-#endif
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx
index 9d188d03c7b69..8726563c0ec39 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayHelpers.cxx
@@ -52,9 +52,6 @@ void GPUDisplay::disableUnsupportedOptions()
   if (!mChain) {
     mCfgL.excludeClusters = mCfgL.drawInitLinks = mCfgL.drawLinks = mCfgL.drawSeeds = mCfgL.drawTracklets = mCfgL.drawTracks = mCfgL.drawExtrapolatedTracks = 0;
   }
-  if (mConfig.showTPCTracksFromO2Format && mParam->par.earlyTpcTransform) {
-    throw std::runtime_error("Cannot run GPU display with early Transform when input is O2 tracks");
-  }
 }
 
 void GPUDisplay::DoScreenshot(const char* filename, std::vector<char>& pixels, float animateTime)
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 3a56f874d2d12..608eeb056b6ad 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -22,7 +22,6 @@
 #include "GPUTRDTracker.h"
 #include "GPUTRDTrackletWord.h"
 #include "GPUQA.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTPCConvertImpl.h"
 #include "GPUTPCGMPropagator.h"
 #include "GPUTPCMCInfo.h"
@@ -41,7 +40,7 @@
 
 using namespace o2::gpu;
 
-#define GET_CID(sector, i) (mParam->par.earlyTpcTransform ? mIOPtrs->clusterData[sector][i].id : (mIOPtrs->clustersNative->clusterOffset[sector][0] + i))
+#define GET_CID(sector, i) (mIOPtrs->clustersNative->clusterOffset[sector][0] + i)
 
 const GPUTRDGeometry* GPUDisplay::trdGeometry() { return (GPUTRDGeometry*)mCalib->trdGeometry; }
 const GPUTPCTracker& GPUDisplay::sectorTracker(int32_t iSector) { return mChain->GetProcessors()->tpcTrackers[iSector]; }
@@ -135,7 +134,7 @@ void GPUDisplay::DrawClusters(int32_t iSector)
   }
 
   uint32_t col = 0;
-  const int32_t nClustersInSector = mParam->par.earlyTpcTransform ? mIOPtrs->nClusterData[iSector] : (mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0);
+  const int32_t nClustersInSector = mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0;
   [[maybe_unused]] const bool checkClusterCollision = mQA && mNCollissions && mOverlayTFClusters.size() == 0 && mIOPtrs->clustersNative && mIOPtrs->clustersNative->clustersMCTruth;
   for (int32_t cidInSector = 0; cidInSector < nClustersInSector; cidInSector++) {
     const int32_t cid = GET_CID(iSector, cidInSector);
@@ -178,11 +177,7 @@ void GPUDisplay::DrawClusters(int32_t iSector)
       }
     } else if (mCfgH.markClusters) {
       int16_t flags;
-      if (mParam->par.earlyTpcTransform) {
-        flags = mIOPtrs->clusterData[iSector][cidInSector].flags;
-      } else {
-        flags = mIOPtrs->clustersNative->clustersLinear[cid].getFlags();
-      }
+      flags = mIOPtrs->clustersNative->clustersLinear[cid].getFlags();
       if (flags & mCfgH.markClusters) {
         select = tMARKED;
       }
@@ -556,24 +551,17 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
             trkParam.Set(t);
           }
 
-          if (mParam->par.earlyTpcTransform) {
-            if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
-              x = mIOPtrs->mergedTrackHitsXYZ[track->FirstClusterRef() + lastCluster].x;
-              ZOffset = track->GetParam().GetTZOffset();
-            }
+          float y, z;
+          if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
+            auto cl = mIOPtrs->mergedTrackHits[track->FirstClusterRef() + lastCluster];
+            const auto& cln = mIOPtrs->clustersNative->clustersLinear[cl.num];
+            GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, cl.sector, cl.row, cln.getPad(), cln.getTime(), x, y, z);
+            ZOffset = mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(iSector, track->GetParam().GetTZOffset(), mParam->continuousMaxTimeBin);
           } else {
-            float y, z;
-            if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
-              auto cl = mIOPtrs->mergedTrackHits[track->FirstClusterRef() + lastCluster];
-              const auto& cln = mIOPtrs->clustersNative->clustersLinear[cl.num];
-              GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, cl.sector, cl.row, cln.getPad(), cln.getTime(), x, y, z);
-              ZOffset = mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(iSector, track->GetParam().GetTZOffset(), mParam->continuousMaxTimeBin);
-            } else {
-              uint8_t sector, row;
-              auto cln = track->getCluster(mIOPtrs->outputClusRefsTPCO2, lastCluster, *mIOPtrs->clustersNative, sector, row);
-              GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, sector, row, cln.getPad(), cln.getTime(), x, y, z);
-              ZOffset = mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, track->getTime0(), mParam->continuousMaxTimeBin);
-            }
+            uint8_t sector, row;
+            auto cln = track->getCluster(mIOPtrs->outputClusRefsTPCO2, lastCluster, *mIOPtrs->clustersNative, sector, row);
+            GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, sector, row, cln.getPad(), cln.getTime(), x, y, z);
+            ZOffset = mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, track->getTime0(), mParam->continuousMaxTimeBin);
           }
         } else {
           const GPUTPCMCInfo& mc = mIOPtrs->mcInfosTPC[i];
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index df3b385c14fe5..9c516ebb960d7 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -19,7 +19,6 @@
 #include "GPUDisplay.h"
 #include "frontend/GPUDisplayInfo.inc"
 #include "GPUO2DataTypes.h"
-#include "GPUTPCClusterData.h"
 #include "GPUTPCConvertImpl.h"
 #include "GPUTRDGeometry.h"
 #include "GPUTRDTrackletWord.h"
@@ -139,35 +138,24 @@ void GPUDisplay::DrawGLScene_updateEventData()
   mMaxClusterZ = tbb::parallel_reduce(tbb::blocked_range<int32_t>(0, NSECTORS, 1), float(0.f), [&](const tbb::blocked_range<int32_t>& r, float maxClusterZ) {
     for (int32_t iSector = r.begin(); iSector < r.end(); iSector++) {
       int32_t row = 0;
-      uint32_t nCls = mParam->par.earlyTpcTransform ? mIOPtrs->nClusterData[iSector] : (mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0);
+      uint32_t nCls = mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0;
       for (uint32_t i = 0; i < nCls; i++) {
         int32_t cid;
-        if (mParam->par.earlyTpcTransform) {
-          const auto& cl = mIOPtrs->clusterData[iSector][i];
-          cid = cl.id;
-          row = cl.row;
-        } else {
-          cid = mIOPtrs->clustersNative->clusterOffset[iSector][0] + i;
-          while (row < GPUCA_ROW_COUNT - 1 && mIOPtrs->clustersNative->clusterOffset[iSector][row + 1] <= (uint32_t)cid) {
-            row++;
-          }
+        cid = mIOPtrs->clustersNative->clusterOffset[iSector][0] + i;
+        while (row < GPUCA_ROW_COUNT - 1 && mIOPtrs->clustersNative->clusterOffset[iSector][row + 1] <= (uint32_t)cid) {
+          row++;
         }
         if (cid >= mNMaxClusters) {
           throw std::runtime_error("Cluster Buffer Size exceeded");
         }
         float4* ptr = &mGlobalPos[cid];
-        if (mParam->par.earlyTpcTransform) {
-          const auto& cl = mIOPtrs->clusterData[iSector][i];
-          mParam->Sector2Global(iSector, (mCfgH.clustersOnNominalRow ? GPUTPCGeometry::Row2X(row) : cl.x) + mCfgH.xAdd, cl.y, cl.z, &ptr->x, &ptr->y, &ptr->z);
-        } else {
-          float x, y, z;
-          const auto& cln = mIOPtrs->clustersNative->clusters[iSector][0][i];
-          GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, iSector, row, cln.getPad(), cln.getTime(), x, y, z);
-          if (mCfgH.clustersOnNominalRow) {
-            x = GPUTPCGeometry::Row2X(row);
-          }
-          mParam->Sector2Global(iSector, x + mCfgH.xAdd, y, z, &ptr->x, &ptr->y, &ptr->z);
+        float x, y, z;
+        const auto& cln = mIOPtrs->clustersNative->clusters[iSector][0][i];
+        GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, iSector, row, cln.getPad(), cln.getTime(), x, y, z);
+        if (mCfgH.clustersOnNominalRow) {
+          x = GPUTPCGeometry::Row2X(row);
         }
+        mParam->Sector2Global(iSector, x + mCfgH.xAdd, y, z, &ptr->x, &ptr->y, &ptr->z);
 
         if (fabsf(ptr->z) > maxClusterZ) {
           maxClusterZ = fabsf(ptr->z);
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 5bcda68e691b3..3ab84ca3f67cd 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -90,7 +90,6 @@ o2_gpu_add_kernel("GPUTPCGMO2Output, output"                              "= TPC
 o2_gpu_add_kernel("GPUTPCGMO2Output, mc"                                  "= TPCMERGER")
 o2_gpu_add_kernel("GPUTRDTrackerKernels, gpuVersion"                      "= TRDTRACKER MATLUT TPCMERGER"                         LB GPUTRDTrackerGPU* externalInstance)
 o2_gpu_add_kernel("GPUTRDTrackerKernels, o2Version"                       "= TRDTRACKER MATLUT O2PROPAGATOR"                      LB GPUTRDTracker* externalInstance)
-o2_gpu_add_kernel("GPUTPCConvertKernel"                                   "="                                                     LB)
 o2_gpu_add_kernel("GPUTPCCompressionKernels, step0attached"               "= TPCCOMPRESSION"                                      LB)
 o2_gpu_add_kernel("GPUTPCCompressionKernels, step1unattached"             "= ERRORS"                                              LB)
 o2_gpu_add_kernel("GPUTPCCompressionGatherKernels, unbuffered"            "GPUTPCCompressionKernels"                              LB)
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index aa4db98d0b71a..31bfaa47d7420 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -45,7 +45,6 @@
 #include "GPUTPCGMPropagator.h"
 #include "AliHLTTPCClusterMCData.h"
 #include "GPUTPCMCInfo.h"
-#include "GPUTPCClusterData.h"
 #include "GPUO2DataTypes.h"
 #include "GPUParam.inc"
 #include "GPUTPCClusterRejection.h"
@@ -1048,8 +1047,6 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             bool comp;
             if (revLabel == -1) {
               comp = true;
-            } else if (mTracking->GetParam().par.earlyTpcTransform) {
-              comp = fabsf(trks[i].GetParam().GetZ() + trks[i].GetParam().GetTZOffset()) < fabsf(trks[revLabel].GetParam().GetZ() + trks[revLabel].GetParam().GetTZOffset());
             } else {
               float shift1 = mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trks[i].CSide() * GPUChainTracking::NSECTORS / 2, trks[i].GetParam().GetTZOffset());
               float shift2 = mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trks[revLabel].CSide() * GPUChainTracking::NSECTORS / 2, trks[revLabel].GetParam().GetTZOffset());
@@ -1387,13 +1384,8 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           if (!mParam->continuousMaxTimeBin) {
             return param.GetZ() - mc1.z;
           }
-#ifdef GPUCA_TPC_GEOMETRY_O2
-          if (!mParam->par.earlyTpcTransform) {
-            float shift = side == 2 ? 0 : mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSECTORS / 2, param.GetTZOffset() - mc1.t0);
-            return param.GetZ() + shift - mc1.z;
-          }
-#endif
-          return param.Z() + param.TZOffset() - mc1.z;
+          float shift = side == 2 ? 0 : mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSECTORS / 2, param.GetTZOffset() - mc1.t0);
+          return param.GetZ() + shift - mc1.z;
         };
 
         prop.SetTrack(&param, alpha);

From c8ed101857e8c1cf8806fb10eaa13d3bc312ac4b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 9 Sep 2025 11:13:41 +0200
Subject: [PATCH 0818/1764] GPU: Fix direction for material correction in
 sector track refit

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index fb2fcdfd06776..71b93221445f5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -514,7 +514,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
       const ClusterNative& cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[GetConstantMem()->ioPtrs.clustersNative->clusterOffset[sector][0] + clusterIndex];
       flags = cl.getFlags();
       GetConstantMem()->calibObjects.fastTransformHelper->Transform(sector, row, cl.getPad(), cl.getTime(), x, y, z, trk.TZOffset());
-      if (prop.PropagateToXAlpha(x, alpha, true)) {
+      if (prop.PropagateToXAlpha(x, alpha, way == 0)) {
         return way == 0;
       }
       trk.ConstrainSinPhi();

From 1f4bf031f237cc415bacca7f22c578044539a697 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 9 Sep 2025 11:17:08 +0200
Subject: [PATCH 0819/1764] GPU TPC: Add Pt cut to treat < 100 MeV always as
 secondary

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 43 ++++++++++---------
 .../SectorTracker/GPUTPCTrackParam.cxx        | 38 ++++++++--------
 2 files changed, 42 insertions(+), 39 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 80d4809e4a466..79e69603423b6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -862,30 +862,31 @@ GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merge
   if (!merger->Param().par.continuousTracking) {
     return;
   }
-  const float r1 = CAMath::Max(0.0001f, CAMath::Abs(mP[4] * merger->Param().polynomialField.GetNominalBz()));
-
-  const float dist2 = mX * mX + mP[0] * mP[0];
-  const float dist1r2 = dist2 * r1 * r1;
   float deltaZ = 0.f;
   bool beamlineReached = false;
-  if (dist1r2 < 4) {
-    const float alpha = CAMath::ACos(1 - 0.5f * dist1r2); // Angle of a circle, such that |(cosa, sina) - (1,0)| == dist
-    const float beta = CAMath::ATan2(mP[0], mX);
-    const int32_t comp = mP[2] > CAMath::Sin(beta);
-    const float sinab = CAMath::Sin((comp ? 0.5f : -0.5f) * alpha + beta); // Angle of circle through origin and track position, to be compared to Snp
-    const float res = CAMath::Abs(sinab - mP[2]);
-
-    if (res < 0.2) {
-      const float r = 1.f / r1;
-      const float dS = alpha * r;
-      float z0 = dS * mP[3];
-      if (CAMath::Abs(z0) > GPUTPCGeometry::TPCLength()) {
-        z0 = z0 > 0 ? GPUTPCGeometry::TPCLength() : -GPUTPCGeometry::TPCLength();
-      }
-      deltaZ = mP[1] - z0;
-      beamlineReached = true;
+  const float r1 = CAMath::Max(0.0001f, CAMath::Abs(mP[4] * merger->Param().polynomialField.GetNominalBz()));
+  if (r1 < 0.01501) { // 100 MeV @ 0.5T ~ 0.66m cutof
+    const float dist2 = mX * mX + mP[0] * mP[0];
+    const float dist1r2 = dist2 * r1 * r1;
+    if (dist1r2 < 4) {
+      const float alpha = CAMath::ACos(1 - 0.5f * dist1r2); // Angle of a circle, such that |(cosa, sina) - (1,0)| == dist
+      const float beta = CAMath::ATan2(mP[0], mX);
+      const int32_t comp = mP[2] > CAMath::Sin(beta);
+      const float sinab = CAMath::Sin((comp ? 0.5f : -0.5f) * alpha + beta); // Angle of circle through origin and track position, to be compared to Snp
+      const float res = CAMath::Abs(sinab - mP[2]);
+
+      if (res < 0.2) {
+        const float r = 1.f / r1;
+        const float dS = alpha * r;
+        float z0 = dS * mP[3];
+        if (CAMath::Abs(z0) > GPUTPCGeometry::TPCLength()) {
+          z0 = z0 > 0 ? GPUTPCGeometry::TPCLength() : -GPUTPCGeometry::TPCLength();
+        }
+        deltaZ = mP[1] - z0;
+        beamlineReached = true;
 
-      // printf("X %9.3f Y %9.3f QPt %9.3f R %9.3f --> Alpha %9.3f Snp %9.3f Snab %9.3f Res %9.3f dS %9.3f z0 %9.3f\n", mX, mP[0], mP[4], r, alpha / 3.1415 * 180, mP[2], sinab, res, dS, z0);
+        // printf("X %9.3f Y %9.3f QPt %9.3f R %9.3f --> Alpha %9.3f Snp %9.3f Snab %9.3f Res %9.3f dS %9.3f z0 %9.3f\n", mX, mP[0], mP[4], r, alpha / 3.1415 * 180, mP[2], sinab, res, dS, z0);
+      }
     }
   }
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.cxx
index af6f8e6cddc08..a4d9265cf800e 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.cxx
@@ -745,27 +745,29 @@ GPUd() void GPUTPCTrackParam::ConstrainZ(float& z, int32_t sector, float& z0, fl
 GPUd() void GPUTPCTrackParam::ShiftZ(float z1, float z2, float x1, float x2, float bz, float defaultZOffsetOverR)
 {
   const float r1 = CAMath::Max(0.0001f, CAMath::Abs(mParam.mP[4] * bz));
-
-  const float dist2 = mParam.mX * mParam.mX + mParam.mP[0] * mParam.mP[0];
-  const float dist1r2 = dist2 * r1 * r1;
   float deltaZ = 0.f;
   bool beamlineReached = false;
-  if (dist1r2 < 4) {
-    const float alpha = CAMath::ACos(1 - 0.5f * dist1r2); // Angle of a circle, such that |(cosa, sina) - (1,0)| == dist
-    const float beta = CAMath::ATan2(mParam.mP[0], mParam.mX);
-    const int32_t comp = mParam.mP[2] > CAMath::Sin(beta);
-    const float sinab = CAMath::Sin((comp ? 0.5f : -0.5f) * alpha + beta); // Angle of circle through origin and track position, to be compared to Snp
-    const float res = CAMath::Abs(sinab - mParam.mP[2]);
-
-    if (res < 0.2f) {
-      const float r = 1.f / r1;
-      const float dS = alpha * r;
-      float z0 = dS * mParam.mP[3];
-      if (CAMath::Abs(z0) > GPUTPCGeometry::TPCLength()) {
-        z0 = z0 > 0 ? GPUTPCGeometry::TPCLength() : -GPUTPCGeometry::TPCLength();
+
+  if (r1 < 0.01501) { // 100 MeV @ 0.5T ~ 0.66m cutof
+    const float dist2 = mParam.mX * mParam.mX + mParam.mP[0] * mParam.mP[0];
+    const float dist1r2 = dist2 * r1 * r1;
+    if (dist1r2 < 4) {
+      const float alpha = CAMath::ACos(1 - 0.5f * dist1r2); // Angle of a circle, such that |(cosa, sina) - (1,0)| == dist
+      const float beta = CAMath::ATan2(mParam.mP[0], mParam.mX);
+      const int32_t comp = mParam.mP[2] > CAMath::Sin(beta);
+      const float sinab = CAMath::Sin((comp ? 0.5f : -0.5f) * alpha + beta); // Angle of circle through origin and track position, to be compared to Snp
+      const float res = CAMath::Abs(sinab - mParam.mP[2]);
+
+      if (res < 0.2f) {
+        const float r = 1.f / r1;
+        const float dS = alpha * r;
+        float z0 = dS * mParam.mP[3];
+        if (CAMath::Abs(z0) > GPUTPCGeometry::TPCLength()) {
+          z0 = z0 > 0 ? GPUTPCGeometry::TPCLength() : -GPUTPCGeometry::TPCLength();
+        }
+        deltaZ = mParam.mP[1] - z0;
+        beamlineReached = true;
       }
-      deltaZ = mParam.mP[1] - z0;
-      beamlineReached = true;
     }
   }
 

From 75046a185598e3e6d58fc0864346d968283e9a61 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 9 Sep 2025 11:24:37 +0200
Subject: [PATCH 0820/1764] GPU TPC: Rename some kernels

---
 .../Definitions/GPUDefParametersDefaults.h    | 36 ++++++-------
 .../Global/GPUChainTrackingMerger.cxx         | 10 ++--
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  8 +--
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  6 +--
 GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx  | 12 ++---
 GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h    |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   | 51 ++++++++++---------
 .../Merger/GPUTPCGlobalDebugSortKernels.cxx   |  4 +-
 .../Merger/GPUTPCGlobalDebugSortKernels.h     |  4 +-
 GPU/GPUTracking/kernels.cmake                 | 10 ++--
 10 files changed, 72 insertions(+), 71 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 7b76860d4ca2b..29aa3808506dc 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -57,9 +57,9 @@
     #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
     #define GPUCA_LB_GPUTPCGMMergerCollect 512
     #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
@@ -119,9 +119,9 @@
     #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
     #define GPUCA_LB_GPUTPCGMMergerCollect 512
     #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
@@ -181,9 +181,9 @@
     #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
     #define GPUCA_LB_GPUTPCGMMergerCollect 256, 2
     #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
@@ -243,9 +243,9 @@
     #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
     #define GPUCA_LB_GPUTPCGMMergerCollect 128, 2
     #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
@@ -398,14 +398,14 @@
   #ifndef GPUCA_LB_GPUTPCGMMergerSortTracksPrepare
     #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
   #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step0 256
+  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
   #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step1 256
+  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
   #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2
-    #define GPUCA_LB_GPUTPCGMMergerPrepareClusters_step2 256
+  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2
+    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
   #endif
   #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step0
     #define GPUCA_LB_GPUTPCGMMergerFinalize_step0 256
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 36e4e9af83fbd..4d9fcd4b1572a 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -165,8 +165,8 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   runKernel<GPUTPCGMMergerLinkExtrapolatedTracks>(GetGridAuto(0, deviceType));
   runKernel<GPUTPCGMMergerCollect>(GetGridAuto(0, deviceType));
   if (GetProcessingSettings().deterministicGPUReconstruction) {
-    runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::extrapolatedTracks1>({{1, -WarpSize(), 0, deviceType}}, 1);
-    runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::extrapolatedTracks2>({{1, -WarpSize(), 0, deviceType}}, 1);
+    runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::mergedTracks1>({{1, -WarpSize(), 0, deviceType}}, 1);
+    runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::mergedTracks2>({{1, -WarpSize(), 0, deviceType}}, 1);
   }
   DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingCollectedTracks, doGPU, Merger, &GPUTPCGMMerger::DumpCollected, *mDebugFile);
 
@@ -196,11 +196,11 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   }
   runKernel<GPUMemClean16>({{numBlocks, -ThreadCount(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.SharedCount(), maxId * sizeof(*MergerShadowAll.SharedCount()));
   runKernel<GPUMemClean16>({{numBlocks, -ThreadCount(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.ClusterAttachment(), maxId * sizeof(*MergerShadowAll.ClusterAttachment()));
-  runKernel<GPUTPCGMMergerPrepareClusters, 0>(GetGridAuto(0, deviceType));
+  runKernel<GPUTPCGMMergerPrepareForFit, 0>(GetGridAuto(0, deviceType));
   CondWaitEvent(waitForTransfer, &mEvents->single);
   runKernel<GPUTPCGMMergerSortTracksQPt>(GetGridAuto(0, deviceType));
-  runKernel<GPUTPCGMMergerPrepareClusters, 1>(GetGridAuto(0, deviceType));
-  runKernel<GPUTPCGMMergerPrepareClusters, 2>(GetGridAuto(0, deviceType));
+  runKernel<GPUTPCGMMergerPrepareForFit, 1>(GetGridAuto(0, deviceType));
+  runKernel<GPUTPCGMMergerPrepareForFit, 2>(GetGridAuto(0, deviceType));
 
   DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingPrepareFit, doGPU, Merger, &GPUTPCGMMerger::DumpFitPrepare, *mDebugFile);
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 71b93221445f5..a36c98e25d205 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -325,7 +325,7 @@ void* GPUTPCGMMerger::SetPointersMerger(void* mem)
   computePointerWithAlignment(mem, mTrackIDs, GPUCA_NSECTORS * mNMaxSingleSectorTracks); // UnpackResetIds - RefitSectorTracks - UnpackSectorGlobal
   memMax = (void*)std::max((size_t)mem, (size_t)memMax);
   mem = memBase;
-  computePointerWithAlignment(mem, mTrackSort, mNMaxTracks); // PrepareClustersForFit0 - SortTracksQPt - PrepareClustersForFit1 - PrepareClustersForFit1 / Finalize0 - Finalize2
+  computePointerWithAlignment(mem, mTrackSort, mNMaxTracks); // PrepareForFit0 - SortTracksQPt - PrepareForFit1 - PrepareForFit1 / Finalize0 - Finalize2
   computePointerWithAlignment(mem, mSharedCount, mNMaxClusters);
   memMax = (void*)std::max((size_t)mem, (size_t)memMax);
   mem = memBase;
@@ -1738,7 +1738,7 @@ GPUd() void GPUTPCGMMerger::SortTracksPrepare(int32_t nBlocks, int32_t nThreads,
   }
 }
 
-GPUd() void GPUTPCGMMerger::PrepareClustersForFit0(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
+GPUd() void GPUTPCGMMerger::PrepareForFit0(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nBlocks * nThreads) {
     mTrackSort[i] = i;
@@ -1763,7 +1763,7 @@ GPUd() void GPUTPCGMMerger::SortTracksQPt(int32_t nBlocks, int32_t nThreads, int
 #endif
 }
 
-GPUd() void GPUTPCGMMerger::PrepareClustersForFit1(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
+GPUd() void GPUTPCGMMerger::PrepareForFit1(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nBlocks * nThreads) {
     mTrackOrderAttach[mTrackSort[i]] = i;
@@ -1777,7 +1777,7 @@ GPUd() void GPUTPCGMMerger::PrepareClustersForFit1(int32_t nBlocks, int32_t nThr
   }
 }
 
-GPUd() void GPUTPCGMMerger::PrepareClustersForFit2(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
+GPUd() void GPUTPCGMMerger::PrepareForFit2(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTrackClusters; i += nBlocks * nThreads) {
     if (mSharedCount[mClusters[i].num] > 1) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 7813ca4595271..2576ed0720c16 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -170,9 +170,9 @@ class GPUTPCGMMerger : public GPUProcessor
   GPUd() void SortTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
   GPUd() void SortTracksQPt(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
   GPUd() void SortTracksPrepare(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
-  GPUd() void PrepareClustersForFit0(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
-  GPUd() void PrepareClustersForFit1(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
-  GPUd() void PrepareClustersForFit2(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
+  GPUd() void PrepareForFit0(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
+  GPUd() void PrepareForFit1(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
+  GPUd() void PrepareForFit2(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
   GPUd() void LinkExtrapolatedTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
   GPUd() void CollectMergedTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
   GPUd() void Finalize0(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
index 1631777d80482..6bee239e42848 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
@@ -163,21 +163,21 @@ GPUdii() void GPUTPCGMMergerSortTracksPrepare::Thread<0>(int32_t nBlocks, int32_
 }
 
 template <>
-GPUdii() void GPUTPCGMMergerPrepareClusters::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
+GPUdii() void GPUTPCGMMergerPrepareForFit::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
-  merger.PrepareClustersForFit0(nBlocks, nThreads, iBlock, iThread);
+  merger.PrepareForFit0(nBlocks, nThreads, iBlock, iThread);
 }
 
 template <>
-GPUdii() void GPUTPCGMMergerPrepareClusters::Thread<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
+GPUdii() void GPUTPCGMMergerPrepareForFit::Thread<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
-  merger.PrepareClustersForFit1(nBlocks, nThreads, iBlock, iThread);
+  merger.PrepareForFit1(nBlocks, nThreads, iBlock, iThread);
 }
 
 template <>
-GPUdii() void GPUTPCGMMergerPrepareClusters::Thread<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
+GPUdii() void GPUTPCGMMergerPrepareForFit::Thread<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
-  merger.PrepareClustersForFit2(nBlocks, nThreads, iBlock, iThread);
+  merger.PrepareForFit2(nBlocks, nThreads, iBlock, iThread);
 }
 
 template <>
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h
index bda00822bac6a..dec72b1d431e6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h
@@ -138,7 +138,7 @@ class GPUTPCGMMergerCollect : public GPUTPCGMMergerGeneral
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& merger);
 };
 
-class GPUTPCGMMergerPrepareClusters : public GPUTPCGMMergerGeneral
+class GPUTPCGMMergerPrepareForFit : public GPUTPCGMMergerGeneral
 {
  public:
   template <int32_t iKernel = defaultKernel>
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index ab3eb02db393e..6ea44e334db7a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -127,22 +127,23 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
   for (int32_t iTmp = get_global_id(0); iTmp < nTracks; iTmp += get_global_size(0)) {
     TrackTPC oTrack;
     const int32_t i = trackSort[iTmp].x;
-    auto snpIn = tracks[i].GetParam().GetSinPhi();
+    const auto& track = tracks[i];
+    auto snpIn = track.GetParam().GetSinPhi();
     if (snpIn > SNPThresh) {
       snpIn = SNPThresh;
     } else if (snpIn < -SNPThresh) {
       snpIn = -SNPThresh;
     }
-    oTrack.set(tracks[i].GetParam().GetX(), tracks[i].GetAlpha(),
-               {tracks[i].GetParam().GetY(), tracks[i].GetParam().GetZ(), snpIn, tracks[i].GetParam().GetDzDs(), tracks[i].GetParam().GetQPt()},
-               {tracks[i].GetParam().GetCov(0),
-                tracks[i].GetParam().GetCov(1), tracks[i].GetParam().GetCov(2),
-                tracks[i].GetParam().GetCov(3), tracks[i].GetParam().GetCov(4), tracks[i].GetParam().GetCov(5),
-                tracks[i].GetParam().GetCov(6), tracks[i].GetParam().GetCov(7), tracks[i].GetParam().GetCov(8), tracks[i].GetParam().GetCov(9),
-                tracks[i].GetParam().GetCov(10), tracks[i].GetParam().GetCov(11), tracks[i].GetParam().GetCov(12), tracks[i].GetParam().GetCov(13), tracks[i].GetParam().GetCov(14)});
+    oTrack.set(track.GetParam().GetX(), track.GetAlpha(),
+               {track.GetParam().GetY(), track.GetParam().GetZ(), snpIn, track.GetParam().GetDzDs(), track.GetParam().GetQPt()},
+               {track.GetParam().GetCov(0),
+                track.GetParam().GetCov(1), track.GetParam().GetCov(2),
+                track.GetParam().GetCov(3), track.GetParam().GetCov(4), track.GetParam().GetCov(5),
+                track.GetParam().GetCov(6), track.GetParam().GetCov(7), track.GetParam().GetCov(8), track.GetParam().GetCov(9),
+                track.GetParam().GetCov(10), track.GetParam().GetCov(11), track.GetParam().GetCov(12), track.GetParam().GetCov(13), track.GetParam().GetCov(14)});
 
-    oTrack.setChi2(tracks[i].GetParam().GetChi2());
-    auto& outerPar = tracks[i].OuterParam();
+    oTrack.setChi2(track.GetParam().GetChi2());
+    auto& outerPar = track.OuterParam();
     if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
       if (param.dodEdxEnabled) {
         oTrack.setdEdx(tracksdEdx[i]);
@@ -189,13 +190,13 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
     float t1 = 0, t2 = 0;
     int32_t sector1 = 0, sector2 = 0;
     const o2::tpc::ClusterNativeAccess* GPUrestrict() clusters = merger.GetConstantMem()->ioPtrs.clustersNative;
-    for (uint32_t j = 0; j < tracks[i].NClusters(); j++) {
-      if ((trackClusters[tracks[i].FirstClusterRef() + j].state & flagsReject) || (merger.ClusterAttachment()[trackClusters[tracks[i].FirstClusterRef() + j].num] & flagsRequired) != flagsRequired) {
+    for (uint32_t j = 0; j < track.NClusters(); j++) {
+      if ((trackClusters[track.FirstClusterRef() + j].state & flagsReject) || (merger.ClusterAttachment()[trackClusters[track.FirstClusterRef() + j].num] & flagsRequired) != flagsRequired) {
         continue;
       }
-      int32_t clusterIdGlobal = trackClusters[tracks[i].FirstClusterRef() + j].num;
-      int32_t sector = trackClusters[tracks[i].FirstClusterRef() + j].sector;
-      int32_t globalRow = trackClusters[tracks[i].FirstClusterRef() + j].row;
+      int32_t clusterIdGlobal = trackClusters[track.FirstClusterRef() + j].num;
+      int32_t sector = trackClusters[track.FirstClusterRef() + j].sector;
+      int32_t globalRow = trackClusters[track.FirstClusterRef() + j].row;
       int32_t clusterIdInRow = clusterIdGlobal - clusters->clusterOffset[sector][globalRow];
       clIndArr[nOutCl2] = clusterIdInRow;
       sectorIndexArr[nOutCl2] = sector;
@@ -210,25 +211,25 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
       }
     }
 
-    bool cce = tracks[i].CCE() && ((sector1 < MAXSECTOR / 2) ^ (sector2 < MAXSECTOR / 2));
+    bool cce = track.CCE() && ((sector1 < MAXSECTOR / 2) ^ (sector2 < MAXSECTOR / 2));
     float time0 = 0.f, tFwd = 0.f, tBwd = 0.f;
     if (merger.Param().par.continuousTracking) {
-      time0 = tracks[i].GetParam().GetTZOffset();
+      time0 = track.GetParam().GetTZOffset();
       if (cce) {
-        bool lastSide = trackClusters[tracks[i].FirstClusterRef()].sector < MAXSECTOR / 2;
+        bool lastSide = trackClusters[track.FirstClusterRef()].sector < MAXSECTOR / 2;
         float delta = 0.f;
-        for (uint32_t iCl = 1; iCl < tracks[i].NClusters(); iCl++) {
-          auto& cacl1 = trackClusters[tracks[i].FirstClusterRef() + iCl];
+        for (uint32_t iCl = 1; iCl < track.NClusters(); iCl++) {
+          auto& cacl1 = trackClusters[track.FirstClusterRef() + iCl];
           if (lastSide ^ (cacl1.sector < MAXSECTOR / 2)) {
             auto& cl1 = clusters->clustersLinear[cacl1.num];
-            auto& cl2 = clusters->clustersLinear[trackClusters[tracks[i].FirstClusterRef() + iCl - 1].num];
+            auto& cl2 = clusters->clustersLinear[trackClusters[track.FirstClusterRef() + iCl - 1].num];
             delta = CAMath::Abs(cl1.getTime() - cl2.getTime()) * 0.5f;
-            if (delta < MinDelta) {
-              delta = MinDelta;
-            }
             break;
           }
         }
+        if (delta < MinDelta) {
+          delta = MinDelta;
+        }
         tFwd = tBwd = delta;
       } else {
         // estimate max/min time increments which still keep track in the physical limits of the TPC
@@ -261,7 +262,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
     if (cce) {
       oTrack.setHasCSideClusters();
       oTrack.setHasASideClusters();
-    } else if (tracks[i].CSide()) {
+    } else if (track.CSide()) {
       oTrack.setHasCSideClusters();
     } else {
       oTrack.setHasASideClusters();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
index 5af3ebb51b9d6..7dfa84bee4a10 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
@@ -94,7 +94,7 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
 }
 
 template <>
-GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels::extrapolatedTracks1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int8_t parameter)
+GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels::mergedTracks1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int8_t parameter)
 {
   if (iThread || iBlock) {
     return;
@@ -112,7 +112,7 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
 }
 
 template <>
-GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels::extrapolatedTracks2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int8_t parameter)
+GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels::mergedTracks2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int8_t parameter)
 {
   if (iBlock) {
     return;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.h b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.h
index 7c3d4246ad303..726e8cee1f7a7 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.h
@@ -29,8 +29,8 @@ class GPUTPCGlobalDebugSortKernels : public GPUKernelTemplate
   enum K { defaultKernel = 0,
            clearIds = 0,
            sectorTracks = 1,
-           extrapolatedTracks1 = 2,
-           extrapolatedTracks2 = 3,
+           mergedTracks1 = 2,
+           mergedTracks2 = 3,
            borderTracks = 4 };
   GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCMerging; }
   typedef GPUTPCGMMerger processorType;
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 3ab84ca3f67cd..151f0326e00ca 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -46,8 +46,8 @@ o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, startHits"               "= TPC
 o2_gpu_add_kernel("GPUTPCSectorDebugSortKernels, sectorTracks"            "= TPCTRACKER")
 o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, clearIds"                "= TPCMERGER"                                           NO int8_t parameter)
 o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, sectorTracks"            "= TPCMERGER"                                           NO int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks1"     "= TPCMERGER"                                           NO int8_t parameter)
-o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, extrapolatedTracks2"     "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, mergedTracks1"           "= TPCMERGER"                                           NO int8_t parameter)
+o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, mergedTracks2"           "= TPCMERGER"                                           NO int8_t parameter)
 o2_gpu_add_kernel("GPUTPCGlobalDebugSortKernels, borderTracks"            "= TPCMERGER"                                           NO int8_t parameter)
 o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fill"                        "= TPCOCCUPANCY"                                        LB GPUTPCClusterOccupancyMapBin* map)
 o2_gpu_add_kernel("GPUTPCCreateOccupancyMap, fold"                        "= TPCOCCUPANCY"                                        LB GPUTPCClusterOccupancyMapBin* map uint32_t* output)
@@ -75,9 +75,9 @@ o2_gpu_add_kernel("GPUTPCGMMergerCollect"                                 "GPUTP
 o2_gpu_add_kernel("GPUTPCGMMergerSortTracks"                              "GPUTPCGMMergerGPU TPCMERGER")
 o2_gpu_add_kernel("GPUTPCGMMergerSortTracksQPt"                           "GPUTPCGMMergerGPU TPCMERGER")
 o2_gpu_add_kernel("GPUTPCGMMergerSortTracksPrepare"                       "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step0"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step1"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
-o2_gpu_add_kernel("GPUTPCGMMergerPrepareClusters, step2"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareForFit, step0"                    "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareForFit, step1"                    "GPUTPCGMMergerGPU TPCMERGER"                           LB)
+o2_gpu_add_kernel("GPUTPCGMMergerPrepareForFit, step2"                    "GPUTPCGMMergerGPU TPCMERGER"                           LB)
 o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step0"                         "GPUTPCGMMergerGPU TPCMERGER"                           LB)
 o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step1"                         "GPUTPCGMMergerGPU TPCMERGER"                           LB)
 o2_gpu_add_kernel("GPUTPCGMMergerFinalize, step2"                         "GPUTPCGMMergerGPU TPCMERGER"                           LB)

From 490d8a53e684847412d20b413aa5a90669bd7d13 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 9 Sep 2025 14:28:47 +0200
Subject: [PATCH 0821/1764] GPU TPC Merger: Improve sanity check debug code

---
 GPU/GPUTracking/Definitions/GPUDef.h      |  3 ---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 24 +++++++++++++++++++++++
 2 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDef.h b/GPU/GPUTracking/Definitions/GPUDef.h
index 8ca361dd5003a..d684cd42f8262 100644
--- a/GPU/GPUTracking/Definitions/GPUDef.h
+++ b/GPU/GPUTracking/Definitions/GPUDef.h
@@ -60,9 +60,6 @@
   #ifdef CADEBUG
     #undef CADEBUG
   #endif
-  #ifdef GPUCA_CADEBUG_ENABLED
-    #undef GPUCA_CADEBUG_ENABLED
-  #endif
   #if GPUCA_CADEBUG == 1 && !defined(GPUCA_GPUCODE)
     #define CADEBUG(...) __VA_ARGS__
     #define CADEBUG2(cmd, ...) {__VA_ARGS__; cmd;}
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index a36c98e25d205..93d1f45e846b8 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -14,6 +14,7 @@
 
 #define GPUCA_CADEBUG 0
 #define GPUCA_MERGE_LOOPER_MC 0
+// #define GPUCA_CADEBUG_ENABLED
 
 #include "GPUCommonDef.h"
 
@@ -165,6 +166,7 @@ GPUTPCGMMerger::GPUTPCGMMerger()
 
 void GPUTPCGMMerger::CheckMergedTracks()
 {
+  uint32_t nErr = 0;
   std::vector<bool> trkUsed(SectorTrackInfoLocalTotal());
   for (int32_t i = 0; i < SectorTrackInfoLocalTotal(); i++) {
     trkUsed[i] = false;
@@ -172,6 +174,22 @@ void GPUTPCGMMerger::CheckMergedTracks()
 
   for (int32_t itr = 0; itr < SectorTrackInfoLocalTotal(); itr++) {
     GPUTPCGMSectorTrack& track = mSectorTrackInfos[itr];
+    if (track.PrevSegmentNeighbour() >= 0 && mSectorTrackInfos[track.PrevSegmentNeighbour()].NextSegmentNeighbour() != itr) {
+      GPUError("Invalid reciprocal segment link: %d PrevSegmentNeighbour %d NextSegmentNeighbour %d", itr, track.PrevSegmentNeighbour(), mSectorTrackInfos[track.PrevSegmentNeighbour()].NextSegmentNeighbour());
+      nErr++;
+    }
+    if (track.NextSegmentNeighbour() >= 0 && mSectorTrackInfos[track.NextSegmentNeighbour()].PrevSegmentNeighbour() != itr) {
+      GPUError("Invalid reciprocal segment link: %d NextSegmentNeighbour %d PrevSegmentNeighbour %d", itr, track.NextSegmentNeighbour(), mSectorTrackInfos[track.NextSegmentNeighbour()].PrevSegmentNeighbour());
+      nErr++;
+    }
+    if (track.PrevNeighbour() >= 0 && mSectorTrackInfos[track.PrevNeighbour()].NextNeighbour() != itr) {
+      GPUError("Invalid reciprocal  link: %d PrevNeighbour %d NextNeighbour %d", itr, track.PrevNeighbour(), mSectorTrackInfos[track.PrevNeighbour()].NextNeighbour());
+      nErr++;
+    }
+    if (track.NextNeighbour() >= 0 && mSectorTrackInfos[track.NextNeighbour()].PrevNeighbour() != itr) {
+      GPUError("Invalid reciprocal  link: %d NextNeighbour %d PrevNeighbour %d", itr, track.NextNeighbour(), mSectorTrackInfos[track.NextNeighbour()].PrevNeighbour());
+      nErr++;
+    }
     if (track.PrevSegmentNeighbour() >= 0) {
       continue;
     }
@@ -183,6 +201,7 @@ void GPUTPCGMMerger::CheckMergedTracks()
       int32_t iTrk = tr - mSectorTrackInfos;
       if (trkUsed[iTrk]) {
         GPUError("FAILURE: double use");
+        nErr++;
       }
       trkUsed[iTrk] = true;
 
@@ -206,8 +225,12 @@ void GPUTPCGMMerger::CheckMergedTracks()
   for (int32_t i = 0; i < SectorTrackInfoLocalTotal(); i++) {
     if (trkUsed[i] == false) {
       GPUError("FAILURE: trk missed");
+      nErr++;
     }
   }
+  if (nErr == 0) {
+    GPUInfo("Merged Track Graph OK");
+  }
 }
 
 template <class T>
@@ -1419,6 +1442,7 @@ struct GPUTPCGMMerger_CompareClusterIds {
 
 GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
+  // if (iThread == 0 && iBlock == 0) { CheckMergedTracks(); } return; // (if GPUCA_CADEBUG_ENABLED)
   static constexpr int32_t kMaxParts = 16;
   static constexpr int32_t kMaxClusters = GPUCA_MERGER_MAX_TRACK_CLUSTERS;
 

From 43ea20b3e93dc591582cb5b64ab3e48067bb710a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 9 Sep 2025 21:03:44 +0200
Subject: [PATCH 0822/1764] GPU TPC: Fix deterministic mode with per-segment
 tracking

---
 GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
index 7dfa84bee4a10..6f5e000ddcc7b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
@@ -141,6 +141,11 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
         merger.MergedTracks()[currIdx] = firstItem;
       }
     }
+    for (int32_t j = 0; j < n; j++) {
+      if (merger.MergedTracks()[j].PrevSegment() >= 0) {
+        merger.MergedTracks()[j].SetPrevSegment(tmp2[merger.MergedTracks()[j].PrevSegment()]);
+      }
+    }
   }
   GPUbarrier();
   for (int32_t i = 0; i < 2 * GPUCA_NSECTORS; i++) {

From cd0514393b6f45036244badf1bc2a1637e20ef62 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 25 Jul 2025 23:58:36 +0200
Subject: [PATCH 0823/1764] GPU TPC: Shift all segments of looping tracks once
 before track fit

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 29 +++++++++-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   | 14 +++++
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 55 +++++++------------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |  6 +-
 4 files changed, 64 insertions(+), 40 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 93d1f45e846b8..58dba0b22230f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -515,7 +515,8 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
   trk.DzDs() = inTrack->Param().GetDzDs();
   trk.QPt() = inTrack->Param().GetQPt();
   trk.TZOffset() = GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin);
-  trk.ShiftZ(this, sector, sectorTrack.ClusterZT0(), sectorTrack.ClusterZTN(), inTrack->Param().GetX(), inTrack->Param().GetX()); // We do not store the inner / outer cluster X, so we just use the track X instead
+  const auto tmp = sectorTrack.ClusterZTN() > sectorTrack.ClusterZT0() ? std::array<float, 2>{sectorTrack.ClusterZTN(), sectorTrack.ClusterZT0()} : std::array<float, 2>{sectorTrack.ClusterZT0(), sectorTrack.ClusterZTN()};
+  trk.ShiftZ(this, sector, tmp[0], tmp[1], inTrack->Param().GetX()); // We do not store the inner / outer cluster X, so we just use the track X instead
   sectorTrack.SetX2(0.f);
   for (int32_t way = 0; way < 2; way++) {
     if (way) {
@@ -1791,12 +1792,36 @@ GPUd() void GPUTPCGMMerger::PrepareForFit1(int32_t nBlocks, int32_t nThreads, in
 {
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTracks; i += nBlocks * nThreads) {
     mTrackOrderAttach[mTrackSort[i]] = i;
-    const GPUTPCGMMergedTrack& trk = mMergedTracks[i];
+    GPUTPCGMMergedTrack& trk = mMergedTracks[i];
     if (trk.OK()) {
       for (uint32_t j = 0; j < trk.NClusters(); j++) {
         mClusterAttachment[mClusters[trk.FirstClusterRef() + j].num] = attachAttached | attachGood;
         CAMath::AtomicAdd(&mSharedCount[mClusters[trk.FirstClusterRef() + j].num], 1u);
       }
+      if (!trk.CCE() && !trk.MergedLooper()) {
+        GPUTPCGMMergedTrack* updTrk = &trk;
+        while (updTrk->PrevSegment() >= 0) {
+          auto next = &mMergedTracks[updTrk->PrevSegment()];
+          if (next == &trk) {
+            break;
+          }
+          updTrk = next;
+        }
+        const auto &cl0 = mClusters[trk.FirstClusterRef()], &cln = mClusters[updTrk->FirstClusterRef() + updTrk->NClusters() - 1];
+        const auto& GPUrestrict() cls = GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
+        float z0 = cls[cl0.num].getTime(), zn = cls[cln.num].getTime();
+        const auto tmp = zn > z0 ? std::array<float, 3>{zn, z0, GPUTPCGeometry::Row2X(cln.row)} : std::array<float, 3>{z0, zn, GPUTPCGeometry::Row2X(cl0.row)};
+        trk.Param().ShiftZ(this, cl0.sector, tmp[0], tmp[1], tmp[2]);
+        updTrk = &trk;
+        while (updTrk->PrevSegment() >= 0) {
+          auto next = &mMergedTracks[updTrk->PrevSegment()];
+          if (next == &trk) {
+            break;
+          }
+          updTrk = next;
+          updTrk->Param().TZOffset() = trk.Param().TZOffset();
+        }
+      }
     }
   }
 }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 6ea44e334db7a..35de1611e280c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -211,6 +211,20 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
       }
     }
 
+    if (track.PrevSegment() >= 0) {
+      const GPUTPCGMMergedTrack* chkTrk = &tracks[track.PrevSegment()];
+      while (chkTrk->PrevSegment() >= 0) {
+        auto next = &tracks[chkTrk->PrevSegment()];
+        if (next == &track) {
+          break;
+        }
+        chkTrk = next;
+      }
+      const auto& firstPrevCluster = trackClusters[chkTrk->FirstClusterRef()];
+      t1 = clusters->clustersLinear[firstPrevCluster.num].getTime();
+      sector1 = firstPrevCluster.sector;
+    }
+
     bool cce = track.CCE() && ((sector1 < MAXSECTOR / 2) ^ (sector2 < MAXSECTOR / 2));
     float time0 = 0.f, tFwd = 0.f, tBwd = 0.f;
     if (merger.Param().par.continuousTracking) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 79e69603423b6..52b02c7502a6a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -53,7 +53,7 @@
 using namespace o2::gpu;
 using namespace o2::tpc;
 
-GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_t iTrk, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, int32_t& GPUrestrict() N, int32_t& GPUrestrict() NTolerated, float& GPUrestrict() Alpha, int32_t attempt, float maxSinPhi, gputpcgmmergertypes::GPUTPCOuterParam* GPUrestrict() outerParam, int8_t leg)
+GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_t iTrk, GPUTPCGMMergedTrackHit* GPUrestrict() clusters, int32_t& GPUrestrict() N, int32_t& GPUrestrict() NTolerated, float& GPUrestrict() Alpha, int32_t attempt, float maxSinPhi, GPUTPCGMMergedTrack& GPUrestrict() track)
 {
   static constexpr float kDeg2Rad = M_PI / 180.f;
   CADEBUG(static constexpr float kSectAngle = 2 * M_PI / 18.f);
@@ -66,9 +66,6 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
   prop.SetMaterialTPC();
   prop.SetPolynomialField(&param.polynomialField);
   prop.SetMaxSinPhi(maxSinPhi);
-  if ((clusters[0].sector < 18) == (clusters[N - 1].sector < 18)) {
-    ShiftZ2(clusters, merger, N);
-  }
   if (param.rec.tpc.mergerInterpolateErrors) {
     for (int32_t i = 0; i < N; i++) {
       interpolation.hit[i].errorY = -1;
@@ -88,9 +85,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     float sumInvSqrtCharge = 0.f;
     int32_t nAvgCharge = 0;
 
-    if (iWay && param.rec.tpc.nWaysOuter && outerParam) {
+    if (iWay && param.rec.tpc.nWaysOuter) {
       if (iWay == nWays - 1) {
-        StoreOuter(outerParam, prop, 0);
+        StoreOuter(&track.OuterParam(), prop, 0);
       }
     }
 
@@ -109,7 +106,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
     N = 0;
     lastUpdateX = -1;
-    const bool inFlyDirection = (leg & 1);
+    const bool inFlyDirection = (track.Leg() & 1);
     const int32_t wayDirection = (iWay & 1) ? -1 : 1;
 
     bool noFollowCircle = false, noFollowCircle2 = false;
@@ -173,7 +170,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       } else if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
           bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2;
-          dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, leg == 0, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
+          dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, track.Leg() == 0, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
           if (dodEdx) {
             dEdx.fillSubThreshold(lastRow - wayDirection);
             if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMask) != GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMaskAlt)) {
@@ -244,7 +241,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
       float uncorrectedY = -1e6f;
       if (allowModification) {
-        uncorrectedY = AttachClusters(merger, cluster.sector, cluster.row, iTrk, leg == 0, prop);
+        uncorrectedY = AttachClusters(merger, cluster.sector, cluster.row, iTrk, track.Leg() == 0, prop);
       }
 
       const int32_t err2 = mNDF > 0 && CAMath::Abs(prop.GetSinPhi0()) >= maxSinForUpdate;
@@ -361,14 +358,14 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         break; // bad chi2 for the whole track, stop the fit
       }
     }
-    if (((nWays - iWay) & 1) && (iWay != nWays - 1) && (clusters[0].sector < 18) == (clusters[maxN - 1].sector < 18)) {
-      ShiftZ2(clusters, merger, maxN);
+    if (((nWays - iWay) & 1) && (iWay != nWays - 1) && !track.CCE() && !track.Looper()) {
+      ShiftZ(clusters, merger, maxN);
     }
   }
   ConstrainSinPhi();
 
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamUpdateTrack, iTrk)) {
-    o2::utils::DebugStreamer::instance()->getStreamer("debug_accept_track", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("debug_accept_track").data() << "iTrk=" << iTrk << "outerParam=" << *outerParam << "track=" << this << "ihitStart=" << ihitStart << "\n";
+    o2::utils::DebugStreamer::instance()->getStreamer("debug_accept_track", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("debug_accept_track").data() << "iTrk=" << iTrk << "outerParam=" << track.OuterParam() << "track=" << this << "ihitStart=" << ihitStart << "\n";
   })
 
   if (!(N + NTolerated >= GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(mP[4] * param.qptB5Scaler) && 2 * NTolerated <= CAMath::Max(10, N) && CheckNumericalQuality(covYYUpd))) {
@@ -842,22 +839,18 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPUr
   }
 }
 
-GPUd() void GPUTPCGMTrackParam::ShiftZ2(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N)
+GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N)
 {
-  float tzInner, tzOuter;
-  float xInner, xOuter;
   if (N == 0) {
     N = 1;
   }
   const auto& GPUrestrict() cls = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
-  tzInner = cls[clusters[N - 1].num].getTime();
-  tzOuter = cls[clusters[0].num].getTime();
-  xInner = GPUTPCGeometry::Row2X(clusters[N - 1].row);
-  xOuter = GPUTPCGeometry::Row2X(clusters[0].row);
-  ShiftZ(merger, clusters[0].sector, tzInner, tzOuter, xInner, xOuter);
+  float z0 = cls[clusters[0].num].getTime(), zn = cls[clusters[N - 1].num].getTime();
+  const auto tmp = zn > z0 ? std::array<float, 3>{zn, z0, GPUTPCGeometry::Row2X(clusters[N - 1].row)} : std::array<float, 3>{z0, zn, GPUTPCGeometry::Row2X(clusters[0].row)};
+  ShiftZ(merger, clusters[0].sector, tmp[0], tmp[1], tmp[2]);
 }
 
-GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merger, int32_t sector, float tz1, float tz2, float x1, float x2)
+GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merger, int32_t sector, float cltmax, float cltmin, float clx)
 {
   if (!merger->Param().par.continuousTracking) {
     return;
@@ -891,25 +884,17 @@ GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merge
   }
 
   if (!beamlineReached) {
-    float baset, basex;
-    if (CAMath::Abs(tz1) > CAMath::Abs(tz2)) {
-      baset = tz1;
-      basex = x1;
-    } else {
-      baset = tz2;
-      basex = x2;
-    }
-    float refZ = ((sector < GPUCA_NSECTORS / 2) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * basex;
+    float refZ = ((sector < GPUCA_NSECTORS / 2) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * clx;
     float basez;
-    merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->TransformIdealZ(sector, baset, basez, mTZOffset);
+    merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->TransformIdealZ(sector, cltmax, basez, mTZOffset);
     deltaZ = basez - refZ;
   }
   {
     float deltaT = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaZtoDeltaTimeInTimeFrame(sector, deltaZ);
     mTZOffset += deltaT;
     mP[1] -= deltaZ;
-    const float maxT = CAMath::Min(tz1, tz2) - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getT0();
-    const float minT = CAMath::Max(tz1, tz2) - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(sector);
+    const float maxT = cltmin - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getT0();
+    const float minT = cltmax - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(sector);
     // printf("T Check: Clusters %f %f, min %f max %f vtx %f\n", tz1, tz2, minT, maxT, mTZOffset);
     deltaT = 0.f;
     if (mTZOffset < minT) {
@@ -980,7 +965,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
   GPUTPCGMTrackParam t = track.Param();
   float Alpha = track.Alpha();
   CADEBUG(int32_t nTrackHitsOld = nTrackHits; float ptOld = t.QPt());
-  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, &track.OuterParam(), track.Leg());
+  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, track);
   CADEBUG(printf("Finished Fit Track %d\n", iTrk));
   CADEBUG(printf("OUTPUT hits %d -> %d+%d = %d, QPt %f -> %f, SP %f, ok %d chi2 %f chi2ndf %f\n", nTrackHitsOld, nTrackHits, NTolerated, nTrackHits + NTolerated, ptOld, t.QPt(), t.SinPhi(), (int32_t)ok, t.Chi2(), t.Chi2() / CAMath::Max(1, nTrackHits)));
 
@@ -994,7 +979,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
       NTolerated = 0; // Clusters not fit but tollerated for track length cut
       t = track.Param();
       Alpha = track.Alpha();
-      ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, 1, GPUCA_MAX_SIN_PHI, &track.OuterParam(), track.Leg());
+      ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, 1, GPUCA_MAX_SIN_PHI, track);
     } else {
       uint32_t nRefit = CAMath::AtomicAdd(&merger->Memory()->nRetryRefit, 1u);
       merger->RetryRefitIds()[nRefit] = iTrk;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index 435f88bb93a16..0b65e5f155104 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -141,7 +141,7 @@ class GPUTPCGMTrackParam
   GPUd() bool CheckNumericalQuality(float overrideCovYY = -1.f) const;
   GPUd() bool CheckCov() const;
 
-  GPUd() bool Fit(GPUTPCGMMerger* merger, int32_t iTrk, GPUTPCGMMergedTrackHit* clusters, int32_t& N, int32_t& NTolerated, float& Alpha, int32_t attempt = 0, float maxSinPhi = GPUCA_MAX_SIN_PHI, gputpcgmmergertypes::GPUTPCOuterParam* outerParam = nullptr, int8_t leg = 0);
+  GPUd() bool Fit(GPUTPCGMMerger* merger, int32_t iTrk, GPUTPCGMMergedTrackHit* clusters, int32_t& N, int32_t& NTolerated, float& Alpha, int32_t attempt, float maxSinPhi, GPUTPCGMMergedTrack& track);
   GPUd() void MoveToReference(GPUTPCGMPropagator& prop, const GPUParam& param, float& alpha);
   GPUd() void MirrorTo(GPUTPCGMPropagator& prop, float toY, float toZ, bool inFlyDirection, const GPUParam& param, uint8_t row, uint8_t clusterState, bool mirrorParameters, int8_t sector);
   GPUd() int32_t MergeDoubleRowClusters(int32_t& ihit, int32_t wayDirection, GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, GPUTPCGMPropagator& prop, float& xx, float& yy, float& zz, int32_t maxN, float clAlpha, uint8_t& clusterState, bool rejectChi2);
@@ -183,8 +183,8 @@ class GPUTPCGMTrackParam
   }
 
   GPUd() void Rotate(float alpha);
-  GPUd() void ShiftZ(const GPUTPCGMMerger* merger, int32_t sector, float tzInner, float tzOuter, float x1, float x2);
-  GPUd() void ShiftZ2(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N);
+  GPUd() void ShiftZ(const GPUTPCGMMerger* merger, int32_t sector, float cltmax, float cltmin, float clx);
+  GPUd() void ShiftZ(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N);
 
   GPUd() static float Reciprocal(float x) { return 1.f / x; }
   GPUdi() static void Assign(float& x, bool mask, float v)

From 8f2bc11f5a86bf81f47a04e85a495490dc63f430 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 10 Sep 2025 14:01:40 +0200
Subject: [PATCH 0824/1764] GPU TPC: Restrict CE-merging to primary legs of
 segmented tracks

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 32 +++++++++++++----------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 58dba0b22230f..4b7e8481152e6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1348,23 +1348,15 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
         continue;
       }
       bool celooper = (trk[0]->GetParam().GetQPt() * Param().qptB5Scaler > 1 && trk[0]->GetParam().GetQPt() * trk[1]->GetParam().GetQPt() < 0);
+      celooper |= trk[0]->PrevSegment() != -1 && trk[1]->PrevSegment() != -1;
       if (!celooper && trk[0]->GetParam().GetPar(3) * trk[1]->GetParam().GetPar(3) < 0) {
         continue;
       }
 
-      uint32_t newRef = CAMath::AtomicAdd(&mMemory->nMergedTrackClusters, trk[0]->NClusters() + trk[1]->NClusters());
-      if (newRef + trk[0]->NClusters() + trk[1]->NClusters() >= mNMaxMergedTrackClusters) {
-        raiseError(GPUErrors::ERROR_MERGER_CE_HIT_OVERFLOW, newRef + trk[0]->NClusters() + trk[1]->NClusters(), mNMaxMergedTrackClusters);
-        for (uint32_t k = newRef; k < mNMaxMergedTrackClusters; k++) {
-          mClusters[k].num = 0;
-          mClusters[k].state = 0;
-        }
-        CAMath::AtomicExch(&mMemory->nMergedTrackClusters, mNMaxMergedTrackClusters);
-        return;
-      }
-
       bool needswap = false;
-      if (celooper) {
+      if (trk[0]->PrevSegment() == -1 && trk[1]->PrevSegment() >= 0) {
+        needswap = true;
+      } else if (celooper) {
         const float z0max = -CAMath::Min(cls[mClusters[trk[0]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime());
         const float z1max = -CAMath::Min(cls[mClusters[trk[1]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime());
         if (z1max < z0max) {
@@ -1379,15 +1371,27 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
         GPUCommonAlgorithm::swap(trk[0], trk[1]);
       }
 
-      if (celooper) {
+      if (celooper) { // TODO: Need propper handling, avoid falsely flagging the primary leg as looper
         trk[0]->SetMergedLooperConnected(true);
         trk[0]->SetCCE(true);
         trk[0]->SetLooper(true);
+        trk[1]->SetMergedLooperConnected(true);
         trk[1]->SetCCE(true);
         trk[1]->SetLooper(true);
         continue;
       }
 
+      uint32_t newRef = CAMath::AtomicAdd(&mMemory->nMergedTrackClusters, trk[0]->NClusters() + trk[1]->NClusters());
+      if (newRef + trk[0]->NClusters() + trk[1]->NClusters() >= mNMaxMergedTrackClusters) {
+        raiseError(GPUErrors::ERROR_MERGER_CE_HIT_OVERFLOW, newRef + trk[0]->NClusters() + trk[1]->NClusters(), mNMaxMergedTrackClusters);
+        for (uint32_t k = newRef; k < mNMaxMergedTrackClusters; k++) {
+          mClusters[k].num = 0;
+          mClusters[k].state = 0;
+        }
+        CAMath::AtomicExch(&mMemory->nMergedTrackClusters, mNMaxMergedTrackClusters);
+        return;
+      }
+
       if (Param().par.continuousTracking) {
         GPUTPCGMMergedTrackHit* clsmax;
         const float tmax = CAMath::MaxWithRef(cls[mClusters[trk[0]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime(),
@@ -1747,7 +1751,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         mergedTrack.SetNClusters(0);
       }
       if (mergedTrack.NClusters() && mergedTrack.OK()) */
-      if (Param().rec.tpc.mergeCE) {
+      if (leg == 0 && Param().rec.tpc.mergeCE) {
         auto& cls = mConstantMem->ioPtrs.clustersNative->clustersLinear;
         bool CEside = cls[cl[0].num].getTime() < cls[cl[nHits - 1].num].getTime();
         MergeCEFill(trackParts[CEside ? lastTrackIndex : firstTrackIndex], cl[CEside ? (nHits - 1) : 0], iOutputTrack);

From 3968977e08bcf764ca363ab7e17c4acd51d78f81 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 26 Jul 2025 13:36:08 +0200
Subject: [PATCH 0825/1764] GPU: Remove obsolete mergerCovSource and
 dropSecondaryLegsInOutput, rename TZOffset to TOffset and similar

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 -
 .../Global/GPUChainTrackingTRD.cxx            |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 68 ++++++++-----------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |  6 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   | 10 +--
 .../Merger/GPUTPCGMSectorTrack.cxx            | 10 +--
 GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h  | 20 +++---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 24 +++----
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |  8 +--
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |  2 +-
 .../tools/GPUExtractPbPbCollision.h           |  2 +-
 .../display/render/GPUDisplayDraw.cxx         |  2 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  | 14 ++--
 14 files changed, 80 insertions(+), 92 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 60ee12252b0a8..75d9230a364f0 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -148,12 +148,10 @@ AddOptionRTC(compressionSortOrder, uint8_t, o2::gpu::GPUSettings::SortTime, "",
 AddOptionRTC(sigBitsCharge, uint8_t, 4, "", 0, "Number of significant bits for TPC cluster charge in compression mode 1")
 AddOptionRTC(sigBitsWidth, uint8_t, 3, "", 0, "Number of significant bits for TPC cluster width in compression mode 1")
 AddOptionRTC(dropLoopers, uint8_t, 0, "", 0, "Drop looping tracks starting from second loop")
-AddOptionRTC(mergerCovSource, uint8_t, 2, "", 0, "Method to obtain covariance in track merger: 0 = simple filterErrors method, 1 = use cov from track following, 2 = refit (default)")
 AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation instead of extrapolation for chi2 based cluster rejection")
 AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position")
 AddOptionRTC(mergeCE, uint8_t, 1, "", 0, "Merge tracks accross the central electrode")
 AddOptionRTC(retryRefit, int8_t, 1, "", 0, "Retry refit with seeding errors and without cluster rejection when fit fails (=2 means retry in same kernel, =1 for separate kernel")
-AddOptionRTC(dropSecondaryLegsInOutput, int8_t, 1, "", 0, "Do not store secondary legs of looping track in TrackTPC")
 AddOptionRTC(enablePID, int8_t, 1, "", 0, "Enable PID response")
 AddOptionRTC(PID_useNsigma, int8_t, 1, "", 0, "Use nSigma instead of absolute distance in PID response")
 AddOptionRTC(adddEdxSubThresholdClusters, int8_t, 1, "", 0, "Add sub threshold clusters in TPC dEdx computation")
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx b/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
index f9011131803e3..9f72b7443c49f 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
@@ -69,7 +69,7 @@ int32_t GPUChainTracking::RunTRDTrackingInternal()
       GPUTRDTrackerGPU::HelperTrackAttributes trkAttribs, *trkAttribsPtr{nullptr};
       if (!isTriggeredEvent) {
         const float tpcTBinMUS = 0.199606f;
-        trkAttribs.mTime = trk.GetParam().GetTZOffset() * tpcTBinMUS;
+        trkAttribs.mTime = trk.GetParam().GetTOffset() * tpcTBinMUS;
         trkAttribs.mTimeAddMax = 50.f; // half of a TPC drift time in us
         trkAttribs.mTimeSubMax = 50.f; // half of a TPC drift time in us
         if (!trk.CCE()) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 4b7e8481152e6..b2d1f91a96d01 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -514,8 +514,8 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
   trk.SinPhi() = inTrack->Param().GetSinPhi();
   trk.DzDs() = inTrack->Param().GetDzDs();
   trk.QPt() = inTrack->Param().GetQPt();
-  trk.TZOffset() = GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin);
-  const auto tmp = sectorTrack.ClusterZTN() > sectorTrack.ClusterZT0() ? std::array<float, 2>{sectorTrack.ClusterZTN(), sectorTrack.ClusterZT0()} : std::array<float, 2>{sectorTrack.ClusterZT0(), sectorTrack.ClusterZTN()};
+  trk.TOffset() = GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin);
+  const auto tmp = sectorTrack.ClusterTN() > sectorTrack.ClusterT0() ? std::array<float, 2>{sectorTrack.ClusterTN(), sectorTrack.ClusterT0()} : std::array<float, 2>{sectorTrack.ClusterT0(), sectorTrack.ClusterTN()};
   trk.ShiftZ(this, sector, tmp[0], tmp[1], inTrack->Param().GetX()); // We do not store the inner / outer cluster X, so we just use the track X instead
   sectorTrack.SetX2(0.f);
   for (int32_t way = 0; way < 2; way++) {
@@ -537,7 +537,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
       row = ic.RowIndex();
       const ClusterNative& cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[GetConstantMem()->ioPtrs.clustersNative->clusterOffset[sector][0] + clusterIndex];
       flags = cl.getFlags();
-      GetConstantMem()->calibObjects.fastTransformHelper->Transform(sector, row, cl.getPad(), cl.getTime(), x, y, z, trk.TZOffset());
+      GetConstantMem()->calibObjects.fastTransformHelper->Transform(sector, row, cl.getPad(), cl.getTime(), x, y, z, trk.TOffset());
       if (prop.PropagateToXAlpha(x, alpha, way == 0)) {
         return way == 0;
       }
@@ -556,7 +556,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
   return 0;
 }
 
-GPUd() void GPUTPCGMMerger::SetTrackClusterZT(GPUTPCGMSectorTrack& track, int32_t iSector, const GPUTPCTrack* sectorTr)
+GPUd() void GPUTPCGMMerger::SetTrackClusterT(GPUTPCGMSectorTrack& track, int32_t iSector, const GPUTPCTrack* sectorTr)
 {
   const GPUTPCTracker& trk = GetConstantMem()->tpcTrackers[iSector];
   const GPUTPCHitId& ic1 = trk.TrackHits()[sectorTr->FirstHitID()];
@@ -564,7 +564,7 @@ GPUd() void GPUTPCGMMerger::SetTrackClusterZT(GPUTPCGMSectorTrack& track, int32_
   int32_t clusterIndex1 = trk.Data().ClusterDataIndex(trk.Data().Row(ic1.RowIndex()), ic1.HitIndex());
   int32_t clusterIndex2 = trk.Data().ClusterDataIndex(trk.Data().Row(ic2.RowIndex()), ic2.HitIndex());
   const ClusterNative* cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[iSector][0];
-  track.SetClusterZT(cl[clusterIndex1].getTime(), cl[clusterIndex2].getTime());
+  track.SetClusterT(cl[clusterIndex1].getTime(), cl[clusterIndex2].getTime());
 }
 
 GPUd() void GPUTPCGMMerger::UnpackSaveNumber(int32_t id)
@@ -587,7 +587,7 @@ GPUd() void GPUTPCGMMerger::UnpackSectorGlobal(int32_t nBlocks, int32_t nThreads
     }
     uint32_t myTrack = CAMath::AtomicAdd(&mMemory->nUnpackedTracks, 1u);
     GPUTPCGMSectorTrack& track = mSectorTrackInfos[myTrack];
-    SetTrackClusterZT(track, iSector, sectorTr);
+    SetTrackClusterT(track, iSector, sectorTr);
     track.Set(this, sectorTr, alpha, iSector);
     track.SetGlobalSectorTrackCov();
     track.SetPrevNeighbour(-1);
@@ -618,22 +618,12 @@ GPUd() void GPUTPCGMMerger::RefitSectorTracks(int32_t nBlocks, int32_t nThreads,
   for (uint32_t itr = iBlock * nThreads + iThread; itr < nLocalTracks; itr += nBlocks * nThreads) {
     sectorTr = &trk.Tracks()[itr];
     GPUTPCGMSectorTrack track;
-    SetTrackClusterZT(track, iSector, sectorTr);
-    if (Param().rec.tpc.mergerCovSource == 0) {
-      track.Set(this, sectorTr, alpha, iSector);
+    SetTrackClusterT(track, iSector, sectorTr);
+    if (RefitSectorTrack(track, sectorTr, alpha, iSector)) {
+      track.Set(this, sectorTr, alpha, iSector); // TODO: Why does the refit fail, it shouldn't, this workaround should be removed
       if (!track.FilterErrors(this, iSector, GPUCA_MAX_SIN_PHI, 0.1f)) {
         continue;
       }
-    } else if (Param().rec.tpc.mergerCovSource == 1) {
-      track.Set(this, sectorTr, alpha, iSector);
-      track.CopyBaseTrackCov();
-    } else if (Param().rec.tpc.mergerCovSource == 2) {
-      if (RefitSectorTrack(track, sectorTr, alpha, iSector)) {
-        track.Set(this, sectorTr, alpha, iSector); // TODO: Why does the refit fail, it shouldn't, this workaround should be removed
-        if (!track.FilterErrors(this, iSector, GPUCA_MAX_SIN_PHI, 0.1f)) {
-          continue;
-        }
-      }
     }
 
     CADEBUG(GPUInfo("INPUT Sector %d, Track %u, QPt %f DzDs %f", iSector, itr, track.QPt(), track.DzDs()));
@@ -709,7 +699,7 @@ GPUd() void GPUTPCGMMerger::MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nT
       }
       trackTmp = *trackMin;
       track = &trackTmp;
-      if (Param().rec.tpc.mergerCovSource == 2 && trackTmp.X2() != 0.f) {
+      if (trackTmp.X2() != 0.f) {
         trackTmp.UseParam2();
       } else {
         trackTmp.Set(this, trackMin->OrigTrack(), trackMin->Alpha(), trackMin->Sector());
@@ -1222,17 +1212,17 @@ GPUd() void GPUTPCGMMerger::ResolveMergeSectors(GPUResolveSharedMemory& smem, in
         }
 
         float z1min, z1max, z2min, z2max;
-        z1min = track1->MinClusterZT();
-        z1max = track1->MaxClusterZT();
-        z2min = track2->MinClusterZT();
-        z2max = track2->MaxClusterZT();
+        z1min = track1->MinClusterT();
+        z1max = track1->MaxClusterT();
+        z2min = track2->MinClusterT();
+        z2max = track2->MaxClusterT();
         if (track1 != track1Base) {
-          z1min = CAMath::Min(z1min, track1Base->MinClusterZT());
-          z1max = CAMath::Max(z1max, track1Base->MaxClusterZT());
+          z1min = CAMath::Min(z1min, track1Base->MinClusterT());
+          z1max = CAMath::Max(z1max, track1Base->MaxClusterT());
         }
         if (track2 != track2Base) {
-          z2min = CAMath::Min(z2min, track2Base->MinClusterZT());
-          z2max = CAMath::Max(z2max, track2Base->MaxClusterZT());
+          z2min = CAMath::Min(z2min, track2Base->MinClusterT());
+          z2max = CAMath::Max(z2max, track2Base->MaxClusterT());
         }
         bool goUp = z2max - z1min > z1max - z2min;
 
@@ -1399,8 +1389,8 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
                                               &mClusters[trk[0]->FirstClusterRef()], &mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1],
                                               &mClusters[trk[1]->FirstClusterRef()], &mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1], clsmax);
         const float offset = CAMath::Max(tmax - mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(clsmax->sector, clsmax->row, cls[clsmax->num].getPad()), 0.f);
-        trk[1]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[1]->CSide() * NSECTORS / 2, trk[1]->Param().TZOffset() - offset);
-        trk[1]->Param().TZOffset() = offset;
+        trk[1]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[1]->CSide() * NSECTORS / 2, trk[1]->Param().TOffset() - offset);
+        trk[1]->Param().TOffset() = offset;
       }
       int32_t pos = newRef;
 #pragma unroll
@@ -1503,19 +1493,19 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
           jtr = mSectorTrackInfos[jtr].NextNeighbour();
         }
 
-        float mainZT = 1e9;
+        float mainT = 1e9;
         revertSegments = true;
         for (uint32_t k = 0; k < 2; k++) { // --------------- check if first or last segment is primary ---------------
           int32_t ichk = k ? lasttr : itr;
           const GPUTPCGMSectorTrack* trchk = &mSectorTrackInfos[ichk];
           while (true) {
-            float zt = -trchk->MinClusterZT();
-            if (zt < mainZT) {
+            float t = -trchk->MinClusterT();
+            if (t < mainT) {
               if (k) {
                 revertSegments = false;
                 break;
               }
-              mainZT = zt;
+              mainT = t;
             }
             int32_t next = trchk->NextSegmentNeighbour();
             if (next < 0 || next == ichk) {
@@ -1544,7 +1534,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
             }
             trchk = &mSectorTrackInfos[next];
           }
-          revertInSegment = longest->ClusterZT0() < longest->ClusterZTN();
+          revertInSegment = longest->ClusterT0() < longest->ClusterTN();
         }
       }
       lastMergedSegment = -1;
@@ -1735,7 +1725,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         p1.Z() = p2.Z();
         p1.SinPhi() = p2.SinPhi();
       }
-      p1.TZOffset() = p2.TZOffset();
+      p1.TOffset() = p2.TOffset();
       p1.DzDs() = p2.DzDs();
       p1.QPt() = p2.QPt();
       mergedTrack.SetAlpha(p2.Alpha());
@@ -1823,7 +1813,7 @@ GPUd() void GPUTPCGMMerger::PrepareForFit1(int32_t nBlocks, int32_t nThreads, in
             break;
           }
           updTrk = next;
-          updTrk->Param().TZOffset() = trk.Param().TZOffset();
+          updTrk->Param().TOffset() = trk.Param().TOffset();
         }
       }
     }
@@ -1901,7 +1891,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads,
     const float qptabs = CAMath::Abs(p.GetQPt());
     if (trk.NClusters() && qptabs * Param().qptB5Scaler > 5.f && qptabs * Param().qptB5Scaler <= lowPtThresh) {
       const int32_t sector = mClusters[trk.FirstClusterRef() + trk.NClusters() - 1].sector;
-      const float refz = p.GetZ() + GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, p.GetTZOffset(), Param().continuousMaxTimeBin) + (trk.CSide() ? -100 : 100);
+      const float refz = p.GetZ() + GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, p.GetTOffset(), Param().continuousMaxTimeBin) + (trk.CSide() ? -100 : 100);
       float sinA, cosA;
       CAMath::SinCos(trk.GetAlpha(), sinA, cosA);
       float gx = cosA * p.GetX() - sinA * p.GetY();
@@ -1925,7 +1915,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads,
       for (uint32_t k = 0;k < trk.NClusters();k++) {
         float xx, yy, zz;
         const ClusterNative& GPUrestrict() cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[mClusters[trk.FirstClusterRef() + k].num];
-        GetConstantMem()->calibObjects.fastTransformHelper->Transform(mClusters[trk.FirstClusterRef() + k].sector, mClusters[trk.FirstClusterRef() + k].row, cl.getPad(), cl.getTime(), xx, yy, zz, p.GetTZOffset());
+        GetConstantMem()->calibObjects.fastTransformHelper->Transform(mClusters[trk.FirstClusterRef() + k].sector, mClusters[trk.FirstClusterRef() + k].row, cl.getPad(), cl.getTime(), xx, yy, zz, p.GetTOffset());
         float sa2, ca2;
         CAMath::SinCos(Param().Alpha(mClusters[trk.FirstClusterRef() + k].sector), sa2, ca2);
         float cx = ca2 * xx - sa2 * yy;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 2576ed0720c16..0159b795aa963 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -151,7 +151,7 @@ class GPUTPCGMMerger : public GPUProcessor
   GPUd() uint16_t MemoryResOutputO2Scratch() const { return mMemoryResOutputO2Scratch; }
 
   GPUd() int32_t RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack, const GPUTPCTrack* inTrack, float alpha, int32_t sector);
-  GPUd() void SetTrackClusterZT(GPUTPCGMSectorTrack& track, int32_t iSector, const GPUTPCTrack* sectorTr);
+  GPUd() void SetTrackClusterT(GPUTPCGMSectorTrack& track, int32_t iSector, const GPUTPCTrack* sectorTr);
 
   int32_t CheckSectors();
   GPUd() void RefitSectorTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index e1cec59d96b95..863998079f2cd 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -51,7 +51,7 @@ void GPUTPCGMMerger::DumpSectorTracks(std::ostream& out) const
       out << "  Track type " << iGlobal << "\n";
       for (int32_t j = mSectorTrackInfoIndex[iSector + NSECTORS * iGlobal]; j < mSectorTrackInfoIndex[iSector + NSECTORS * iGlobal + 1]; j++) {
         const auto& trk = mSectorTrackInfos[j];
-        out << "    Track " << j << ": LocalId " << (iGlobal ? (trk.LocalTrackId() >> 24) : -1) << "/" << (iGlobal ? (trk.LocalTrackId() & 0xFFFFFF) : -1) << " X " << trk.X() << " offsetz " << trk.TZOffset() << " A " << trk.Alpha() << " Y " << trk.Y() << " Z " << trk.Z() << " SinPhi " << trk.SinPhi() << " CosPhi " << trk.CosPhi() << " SecPhi " << trk.SecPhi() << " Tgl " << trk.DzDs() << " QPt " << trk.QPt() << "\n";
+        out << "    Track " << j << ": LocalId " << (iGlobal ? (trk.LocalTrackId() >> 24) : -1) << "/" << (iGlobal ? (trk.LocalTrackId() & 0xFFFFFF) : -1) << " X " << trk.X() << " offsetz " << trk.TOffset() << " A " << trk.Alpha() << " Y " << trk.Y() << " Z " << trk.Z() << " SinPhi " << trk.SinPhi() << " CosPhi " << trk.CosPhi() << " SecPhi " << trk.SecPhi() << " Tgl " << trk.DzDs() << " QPt " << trk.QPt() << "\n";
       }
     }
   }
@@ -140,7 +140,7 @@ void GPUTPCGMMerger::DumpCollected(std::ostream& out) const
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mMergedTracks[i];
     const auto& p = trk.GetParam();
-    out << "  Track " << i << ": Loop " << trk.Looper() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTZOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << "\n";
+    out << "  Track " << i << ": Loop " << trk.Looper() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << "\n";
   }
   out << std::setprecision(ss);
 }
@@ -201,7 +201,7 @@ void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
     }
     const auto& p = trk.GetParam();
     const auto& po = trk.OuterParam();
-    out << "  Track " << i << ": OK " << trk.OK() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTZOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << " / " << trk.NClustersFitted() << " Cov " << p.GetErr2Y() << "/" << p.GetErr2Z()
+    out << "  Track " << i << ": OK " << trk.OK() << " Alpha " << trk.GetAlpha() << " X " << p.GetX() << " offset " << p.GetTOffset() << " Y " << p.GetY() << " Z " << p.GetZ() << " SPhi " << p.GetSinPhi() << " Tgl " << p.GetDzDs() << " QPt " << p.GetQPt() << " NCl " << trk.NClusters() << " / " << trk.NClustersFitted() << " Cov " << p.GetErr2Y() << "/" << p.GetErr2Z()
         << " dEdx " << (trk.OK() && Param().dodEdxEnabled ? mMergedTracksdEdx[i].dEdxTotTPC : -1.f) << "/" << (trk.OK() && Param().dodEdxEnabled ? mMergedTracksdEdx[i].dEdxMaxTPC : -1.f)
         << " Outer " << po.P[0] << "/" << po.P[1] << "/" << po.P[2] << "/" << po.P[3] << "/" << po.P[4]
         << " NFitted " << trk.NClustersFitted() << " flags " << (int)trk.Flags() << "\n";
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 35de1611e280c..9c789a8d95f82 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -33,7 +33,7 @@ using namespace o2::tpc;
 using namespace o2::tpc::constants;
 
 GPUdi() static constexpr uint8_t getFlagsReject() { return GPUTPCGMMergedTrackHit::flagReject | GPUTPCGMMergedTrackHit::flagHighIncl; }
-GPUdi() static uint32_t getFlagsRequired(const GPUSettingsRec& rec) { return rec.tpc.dropSecondaryLegsInOutput ? gputpcgmmergertypes::attachGoodLeg : gputpcgmmergertypes::attachZero; }
+GPUdi() static uint32_t getFlagsRequired(const GPUSettingsRec& rec) { return gputpcgmmergertypes::attachGoodLeg; }
 
 namespace o2::gpu::internal
 {
@@ -65,7 +65,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
     if (!tracks[i].OK()) {
       continue;
     }
-    if (merger.Param().rec.tpc.dropSecondaryLegsInOutput && tracks[i].MergedLooper()) {
+    if (tracks[i].MergedLooper()) {
       continue;
     }
 
@@ -79,7 +79,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
     if (nCl == 0) {
       continue;
     }
-    if (merger.Param().rec.tpc.dropSecondaryLegsInOutput && nCl + 2 < GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tracks[i].GetParam().GetQPt() * merger.Param().qptB5Scaler)) { // Give 2 hits tolerance in the primary leg, compared to the full fit of the looper
+    if (nCl + 2 < GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tracks[i].GetParam().GetQPt() * merger.Param().qptB5Scaler)) { // Give 2 hits tolerance in the primary leg, compared to the full fit of the looper
       continue;
     }
     if (merger.Param().rec.tpc.minNClustersFinalTrack != -1 && nCl < (uint32_t)merger.Param().rec.tpc.minNClustersFinalTrack) {
@@ -90,7 +90,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
     }
     uint32_t myId = CAMath::AtomicAdd(&merger.Memory()->nO2Tracks, 1u);
     tmpData[i] = {nCl, CAMath::AtomicAdd(&merger.Memory()->nO2ClusRefs, nCl + (nCl + 1) / 2)};
-    trackSort[myId] = {i, tracks[i].CSide() ? tracks[i].GetParam().GetTZOffset() : -tracks[i].GetParam().GetTZOffset()};
+    trackSort[myId] = {i, tracks[i].CSide() ? tracks[i].GetParam().GetTOffset() : -tracks[i].GetParam().GetTOffset()};
   }
 }
 
@@ -228,7 +228,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
     bool cce = track.CCE() && ((sector1 < MAXSECTOR / 2) ^ (sector2 < MAXSECTOR / 2));
     float time0 = 0.f, tFwd = 0.f, tBwd = 0.f;
     if (merger.Param().par.continuousTracking) {
-      time0 = track.GetParam().GetTZOffset();
+      time0 = track.GetParam().GetTOffset();
       if (cce) {
         bool lastSide = trackClusters[track.FirstClusterRef()].sector < MAXSECTOR / 2;
         float delta = 0.f;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index a44837c897f46..bce70ea79f322 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -37,7 +37,7 @@ GPUd() void GPUTPCGMSectorTrack::Set(const GPUTPCGMMerger* merger, const GPUTPCT
   mParam.mSecPhi = 1.f / mParam.mCosPhi;
   mAlpha = alpha;
   mSector = sector;
-  mTZOffset = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, t.GetZOffset(), merger->Param().continuousMaxTimeBin);
+  mTOffset = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, t.GetZOffset(), merger->Param().continuousMaxTimeBin);
   mNClusters = sectorTr->NHits();
 }
 
@@ -54,7 +54,7 @@ GPUd() void GPUTPCGMSectorTrack::Set(const GPUTPCGMTrackParam& trk, const GPUTPC
   mParam.mSecPhi = 1.f / mParam.mCosPhi;
   mAlpha = alpha;
   mSector = sector;
-  mTZOffset = trk.GetTZOffset();
+  mTOffset = trk.GetTOffset();
   mNClusters = sectorTr->NHits();
   mParam.mC0 = trk.GetCov(0);
   mParam.mC2 = trk.GetCov(2);
@@ -256,7 +256,7 @@ GPUd() bool GPUTPCGMSectorTrack::FilterErrors(const GPUTPCGMMerger* merger, int3
 
   //* Check that the track parameters and covariance matrix are reasonable
 
-  bool ok = CAMath::Finite(mParam.mX) && CAMath::Finite(mParam.mY) && CAMath::Finite(mParam.mZ) && CAMath::Finite(mParam.mSinPhi) && CAMath::Finite(mParam.mDzDs) && CAMath::Finite(mParam.mQPt) && CAMath::Finite(mParam.mCosPhi) && CAMath::Finite(mParam.mSecPhi) && CAMath::Finite(mTZOffset) && CAMath::Finite(mParam.mC0) && CAMath::Finite(mParam.mC2) &&
+  bool ok = CAMath::Finite(mParam.mX) && CAMath::Finite(mParam.mY) && CAMath::Finite(mParam.mZ) && CAMath::Finite(mParam.mSinPhi) && CAMath::Finite(mParam.mDzDs) && CAMath::Finite(mParam.mQPt) && CAMath::Finite(mParam.mCosPhi) && CAMath::Finite(mParam.mSecPhi) && CAMath::Finite(mTOffset) && CAMath::Finite(mParam.mC0) && CAMath::Finite(mParam.mC2) &&
             CAMath::Finite(mParam.mC3) && CAMath::Finite(mParam.mC5) && CAMath::Finite(mParam.mC7) && CAMath::Finite(mParam.mC9) && CAMath::Finite(mParam.mC10) && CAMath::Finite(mParam.mC12) && CAMath::Finite(mParam.mC14);
 
   if (mParam.mC0 <= 0.f || mParam.mC2 <= 0.f || mParam.mC5 <= 0.f || mParam.mC9 <= 0.f || mParam.mC14 <= 0.f || mParam.mC0 > 5.f || mParam.mC2 > 5.f || mParam.mC5 > 2.f || mParam.mC9 > 2.f) {
@@ -323,7 +323,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToX(GPUTPCGMMerger* merger, float x, f
   b.SetPar(2, ey1);
   b.SetPar(3, param.mDzDs);
   b.SetPar(4, param.mQPt);
-  b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTZOffset, merger->Param().continuousMaxTimeBin));
+  b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin));
 
   if (!doCov) {
     return (1);
@@ -478,7 +478,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToXAlpha(GPUTPCGMMerger* merger, float
   b.SetPar(2, ey1);
   b.SetPar(3, dzds);
   b.SetPar(4, qpt);
-  b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTZOffset, merger->Param().continuousMaxTimeBin));
+  b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin));
 
   b.SetCov(0, c00 + h2 * h2c22 + h4 * h4c44 + 2.f * (h2 * c20ph4c42 + h4 * c40));
   b.SetCov(1, c11 + dS * (c31 + n7));
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
index 81facce76cf10..60febbb4428f6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
@@ -54,7 +54,7 @@ class GPUTPCGMSectorTrack
   GPUd() float SecPhi() const { return mParam.mSecPhi; }
   GPUd() float DzDs() const { return mParam.mDzDs; }
   GPUd() float QPt() const { return mParam.mQPt; }
-  GPUd() float TZOffset() const { return mTZOffset; }
+  GPUd() float TOffset() const { return mTOffset; }
 
   GPUd() int32_t LocalTrackId() const { return mLocalTrackId; }
   GPUd() void SetLocalTrackId(int32_t v) { mLocalTrackId = v; }
@@ -62,14 +62,14 @@ class GPUTPCGMSectorTrack
   GPUd() void SetExtrapolatedTrackId(int32_t n, int32_t v) { mExtrapolatedTrackIds[n] = v; }
   GPUd() int32_t* ExtrapolatedTrackIds() { return mExtrapolatedTrackIds; }
 
-  GPUd() float MaxClusterZT() const { return CAMath::Max(mClusterZT[0], mClusterZT[1]); }
-  GPUd() float MinClusterZT() const { return CAMath::Min(mClusterZT[0], mClusterZT[1]); }
-  GPUd() float ClusterZT0() const { return mClusterZT[0]; }
-  GPUd() float ClusterZTN() const { return mClusterZT[1]; }
-  GPUd() void SetClusterZT(float v1, float v2)
+  GPUd() float MaxClusterT() const { return CAMath::Max(mClusterT[0], mClusterT[1]); }
+  GPUd() float MinClusterT() const { return CAMath::Min(mClusterT[0], mClusterT[1]); }
+  GPUd() float ClusterT0() const { return mClusterT[0]; }
+  GPUd() float ClusterTN() const { return mClusterT[1]; }
+  GPUd() void SetClusterT(float v1, float v2)
   {
-    mClusterZT[0] = v1;
-    mClusterZT[1] = v2;
+    mClusterT[0] = v1;
+    mClusterT[1] = v2;
   }
 
   GPUd() void Set(const GPUTPCGMTrackParam& trk, const GPUTPCTrack* sectorTr, float alpha, int32_t sector);
@@ -126,9 +126,9 @@ class GPUTPCGMSectorTrack
   const GPUTPCTrack* mOrigTrack;    // pointer to original sector track
   sectorTrackParam mParam;          // Track parameters
   sectorTrackParam mParam2;         // Parameters at other side
-  float mTZOffset;                  // Z offset with early transform, T offset otherwise
+  float mTOffset;                   // Z offset with early transform, T offset otherwise
   float mAlpha;                     // alpha angle
-  float mClusterZT[2];              // Minimum maximum cluster Z / T
+  float mClusterT[2];               // Minimum maximum cluster T
   int32_t mNClusters;               // N clusters
   int32_t mNeighbour[2];            //
   int32_t mSegmentNeighbour[2];     //
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 52b02c7502a6a..30fcf7053089b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -134,7 +134,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       float xx, yy, zz;
       {
         const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
-        merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), xx, yy, zz, mTZOffset);
+        merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), xx, yy, zz, mTOffset);
       }
       // clang-format off
       CADEBUG(printf("\tHit %3d/%3d Row %3d: Cluster Alpha %8.3f %3d, X %8.3f - Y %8.3f, Z %8.3f (Missed %d)\n", ihit, maxN, (int32_t)clusters[ihit].row, clAlpha, (int32_t)clusters[ihit].sector, xx, yy, zz, nMissed));
@@ -469,7 +469,7 @@ GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t
       const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
       float clamp = cl.qTot;
       float clx, cly, clz;
-      merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), clx, cly, clz, mTZOffset);
+      merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), clx, cly, clz, mTOffset);
       float dy = cly - projY;
       float dz = clz - projZ;
       if (noReject == 0 && (dy * dy > maxDistY || dz * dz > maxDistZ)) {
@@ -526,7 +526,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
     return -1e6f;
   }
 
-  const float zOffset = Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTZOffset, Merger->Param().continuousMaxTimeBin);
+  const float zOffset = Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, Merger->Param().continuousMaxTimeBin);
   const float y0 = row.Grid().YMin();
   const float stepY = row.HstepY();
   const float z0 = row.Grid().ZMin() - zOffset; // We can use our own ZOffset, since this is only used temporarily anyway
@@ -886,27 +886,27 @@ GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merge
   if (!beamlineReached) {
     float refZ = ((sector < GPUCA_NSECTORS / 2) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * clx;
     float basez;
-    merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->TransformIdealZ(sector, cltmax, basez, mTZOffset);
+    merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->TransformIdealZ(sector, cltmax, basez, mTOffset);
     deltaZ = basez - refZ;
   }
   {
     float deltaT = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaZtoDeltaTimeInTimeFrame(sector, deltaZ);
-    mTZOffset += deltaT;
+    mTOffset += deltaT;
     mP[1] -= deltaZ;
     const float maxT = cltmin - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getT0();
     const float minT = cltmax - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(sector);
-    // printf("T Check: Clusters %f %f, min %f max %f vtx %f\n", tz1, tz2, minT, maxT, mTZOffset);
+    // printf("T Check: Clusters %f %f, min %f max %f vtx %f\n", tz1, tz2, minT, maxT, mTOffset);
     deltaT = 0.f;
-    if (mTZOffset < minT) {
-      deltaT = minT - mTZOffset;
+    if (mTOffset < minT) {
+      deltaT = minT - mTOffset;
     }
-    if (mTZOffset + deltaT > maxT) {
-      deltaT = maxT - mTZOffset;
+    if (mTOffset + deltaT > maxT) {
+      deltaT = maxT - mTOffset;
     }
     if (deltaT != 0.f) {
       deltaZ = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(sector, deltaT);
-      // printf("Moving clusters to TPC Range: QPt %f, New mTZOffset %f, t1 %f, t2 %f, Shift %f in Z: %f to %f --> %f to %f in T\n", mP[4], mTZOffset + deltaT, tz1, tz2, deltaZ, tz2 - mTZOffset, tz1 - mTZOffset, tz2 - mTZOffset - deltaT, tz1 - mTZOffset - deltaT);
-      mTZOffset += deltaT;
+      // printf("Moving clusters to TPC Range: QPt %f, New mTOffset %f, t1 %f, t2 %f, Shift %f in Z: %f to %f --> %f to %f in T\n", mP[4], mTOffset + deltaT, tz1, tz2, deltaZ, tz2 - mTOffset, tz1 - mTOffset, tz2 - mTOffset - deltaT, tz1 - mTOffset - deltaT);
+      mTOffset += deltaT;
       mP[1] -= deltaZ;
     }
   }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index 0b65e5f155104..0cf65f84d1c44 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -71,9 +71,9 @@ class GPUTPCGMTrackParam
   {
     return mP[4];
   }
-  GPUd() float& TZOffset()
+  GPUd() float& TOffset()
   {
-    return mTZOffset;
+    return mTOffset;
   }
 
   GPUhd() float GetX() const { return mX; }
@@ -82,7 +82,7 @@ class GPUTPCGMTrackParam
   GPUd() float GetSinPhi() const { return mP[2]; }
   GPUd() float GetDzDs() const { return mP[3]; }
   GPUd() float GetQPt() const { return mP[4]; }
-  GPUd() float GetTZOffset() const { return mTZOffset; }
+  GPUd() float GetTOffset() const { return mTOffset; }
 
   GPUd() float GetKappa(float Bz) const { return -mP[4] * Bz; }
 
@@ -217,7 +217,7 @@ class GPUTPCGMTrackParam
   GPUd() int32_t initResetT0();
 
   float mX;        // x position
-  float mTZOffset; // Z offset with early transform, T offset otherwise
+  float mTOffset;  // Z offset with early transform, T offset otherwise
   float mP[5];     // 'active' track parameters: Y, Z, SinPhi, DzDs, q/Pt
   float mC[15];    // the covariance matrix for Y,Z,SinPhi,..
   float mChi2;     // the chi^2 value
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index 29ccab2a765da..27426cf0ff6a7 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -223,7 +223,7 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
   float tOffset;
   if constexpr (std::is_same_v<T, GPUTPCGMMergedTrack>) {
     count = trkX.NClusters();
-    tOffset = trkX.GetParam().GetTZOffset();
+    tOffset = trkX.GetParam().GetTOffset();
   } else if constexpr (std::is_same_v<T, TrackTPC>) {
     count = trkX.getNClusters();
     tOffset = trkX.getTime0();
diff --git a/GPU/GPUTracking/Standalone/tools/GPUExtractPbPbCollision.h b/GPU/GPUTracking/Standalone/tools/GPUExtractPbPbCollision.h
index fd49c89ae9073..b83d2c40be81c 100644
--- a/GPU/GPUTracking/Standalone/tools/GPUExtractPbPbCollision.h
+++ b/GPU/GPUTracking/Standalone/tools/GPUExtractPbPbCollision.h
@@ -34,7 +34,7 @@ static void GPUExtractPbPbCollision(GPUParam& param, GPUTrackingInOutPointers& i
     if (ioPtrs.mergedTracks[i].NClusters() < 40) {
       continue;
     }
-    int32_t time = ioPtrs.mergedTracks[i].GetParam().GetTZOffset();
+    int32_t time = ioPtrs.mergedTracks[i].GetParam().GetTOffset();
     if (time < 0 || time > param.continuousMaxTimeBin) {
       continue;
     }
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 608eeb056b6ad..4953815a6fc19 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -556,7 +556,7 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
             auto cl = mIOPtrs->mergedTrackHits[track->FirstClusterRef() + lastCluster];
             const auto& cln = mIOPtrs->clustersNative->clustersLinear[cl.num];
             GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, cl.sector, cl.row, cln.getPad(), cln.getTime(), x, y, z);
-            ZOffset = mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(iSector, track->GetParam().GetTZOffset(), mParam->continuousMaxTimeBin);
+            ZOffset = mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(iSector, track->GetParam().GetTOffset(), mParam->continuousMaxTimeBin);
           } else {
             uint8_t sector, row;
             auto cln = track->getCluster(mIOPtrs->outputClusRefsTPCO2, lastCluster, *mIOPtrs->clustersNative, sector, row);
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 31bfaa47d7420..079e7e7be4dc7 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -1048,8 +1048,8 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             if (revLabel == -1) {
               comp = true;
             } else {
-              float shift1 = mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trks[i].CSide() * GPUChainTracking::NSECTORS / 2, trks[i].GetParam().GetTZOffset());
-              float shift2 = mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trks[revLabel].CSide() * GPUChainTracking::NSECTORS / 2, trks[revLabel].GetParam().GetTZOffset());
+              float shift1 = mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trks[i].CSide() * GPUChainTracking::NSECTORS / 2, trks[i].GetParam().GetTOffset());
+              float shift2 = mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trks[revLabel].CSide() * GPUChainTracking::NSECTORS / 2, trks[revLabel].GetParam().GetTOffset());
               comp = fabsf(trks[i].GetParam().GetZ() + shift1) < fabsf(trks[revLabel].GetParam().GetZ() + shift2);
             }
             if (revLabel == -1 || !trks[revLabel].OK() || (trks[i].OK() && comp)) {
@@ -1345,7 +1345,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             param.Cov()[k] = (*tracksExternal)[i].getCov()[k];
           }
           param.X() = (*tracksExternal)[i].getX();
-          param.TZOffset() = (*tracksExternal)[i].getTime0();
+          param.TOffset() = (*tracksExternal)[i].getTime0();
           alpha = (*tracksExternal)[i].getAlpha();
           side = (*tracksExternal)[i].hasBothSidesClusters() ? 2 : ((*tracksExternal)[i].hasCSideClusters() ? 1 : 0);
 #endif
@@ -1384,7 +1384,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           if (!mParam->continuousMaxTimeBin) {
             return param.GetZ() - mc1.z;
           }
-          float shift = side == 2 ? 0 : mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSECTORS / 2, param.GetTZOffset() - mc1.t0);
+          float shift = side == 2 ? 0 : mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSECTORS / 2, param.GetTOffset() - mc1.t0);
           return param.GetZ() + shift - mc1.z;
         };
 
@@ -1726,10 +1726,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
       mNCl[1]->Fill(nClCorrected);
-      mT0[0]->Fill(track.GetParam().GetTZOffset());
+      mT0[0]->Fill(track.GetParam().GetTOffset());
       if (mTrackMCLabels.size() && !mTrackMCLabels[i].isFake() && !track.MergedLooper() && !track.CCE()) {
         const auto& info = GetMCTrack(mTrackMCLabels[i]);
-        mT0[1]->Fill(track.GetParam().GetTZOffset() - info.t0);
+        mT0[1]->Fill(track.GetParam().GetTOffset() - info.t0);
       }
     }
     if (mClNative && mTracking && mTracking->GetTPCTransformHelper()) {
@@ -1849,7 +1849,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           if (attach & gputpcgmmergertypes::attachFlagMask) {
             uint32_t track = attach & gputpcgmmergertypes::attachTrackMask;
             const auto& trk = mTracking->mIOPtrs.mergedTracks[track];
-            mTracking->GetTPCTransformHelper()->Transform(i, j, cl.getPad(), cl.getTime(), x, y, z, trk.GetParam().GetTZOffset());
+            mTracking->GetTPCTransformHelper()->Transform(i, j, cl.getPad(), cl.getTime(), x, y, z, trk.GetParam().GetTOffset());
             mTracking->GetParam().Sector2Global(i, x, y, z, &x, &y, &z);
           }
           uint32_t extState = mTracking->mIOPtrs.mergedTrackHitStates ? mTracking->mIOPtrs.mergedTrackHitStates[clid] : 0;

From baf981a74b59b58539b0d0e1d5b7fc687c430f1f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 26 Jul 2025 15:30:26 +0200
Subject: [PATCH 0826/1764] GPU TPC: Fix handling of ce-crossing looping tracks

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 25 ++++++++++++++---------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index b2d1f91a96d01..acd8331e8bf8f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1361,6 +1361,21 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
         GPUCommonAlgorithm::swap(trk[0], trk[1]);
       }
 
+      if (Param().par.continuousTracking) {
+        GPUTPCGMMergedTrackHit* clsmax;
+        const float tmax = CAMath::MaxWithRef(cls[mClusters[trk[0]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime(),
+                                              cls[mClusters[trk[1]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime(),
+                                              &mClusters[trk[0]->FirstClusterRef()], &mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1],
+                                              &mClusters[trk[1]->FirstClusterRef()], &mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1], clsmax);
+        const float offset = CAMath::Max(tmax - mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(clsmax->sector, clsmax->row, cls[clsmax->num].getPad()), 0.f);
+        trk[1]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[1]->CSide() * NSECTORS / 2, trk[1]->Param().TOffset() - offset);
+        trk[1]->Param().TOffset() = offset;
+        if (celooper) {
+          trk[0]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[0]->CSide() * NSECTORS / 2, trk[0]->Param().TOffset() - offset);
+          trk[0]->Param().TOffset() = offset;
+        }
+      }
+
       if (celooper) { // TODO: Need propper handling, avoid falsely flagging the primary leg as looper
         trk[0]->SetMergedLooperConnected(true);
         trk[0]->SetCCE(true);
@@ -1382,16 +1397,6 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
         return;
       }
 
-      if (Param().par.continuousTracking) {
-        GPUTPCGMMergedTrackHit* clsmax;
-        const float tmax = CAMath::MaxWithRef(cls[mClusters[trk[0]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1].num].getTime(),
-                                              cls[mClusters[trk[1]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime(),
-                                              &mClusters[trk[0]->FirstClusterRef()], &mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1],
-                                              &mClusters[trk[1]->FirstClusterRef()], &mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1], clsmax);
-        const float offset = CAMath::Max(tmax - mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(clsmax->sector, clsmax->row, cls[clsmax->num].getPad()), 0.f);
-        trk[1]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[1]->CSide() * NSECTORS / 2, trk[1]->Param().TOffset() - offset);
-        trk[1]->Param().TOffset() = offset;
-      }
       int32_t pos = newRef;
 #pragma unroll
       for (int32_t k = 1; k >= 0; k--) {

From abee5217de95dcb04d0cd41452c222faf70b4cb7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 29 Jul 2025 15:17:56 +0200
Subject: [PATCH 0827/1764] GPU TPC: Always store outer param

---
 .../reconstruction/test/testGPUCATracking.cxx   | 17 ++++++++---------
 GPU/GPUTracking/Base/GPUReconstruction.cxx      |  1 -
 GPU/GPUTracking/Definitions/GPUSettingsList.h   |  3 +--
 GPU/GPUTracking/Global/GPUChainTracking.cxx     |  4 ++--
 GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx  |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx   | 12 ++++++------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h     |  2 +-
 .../Standalone/Benchmark/standalone.cxx         |  4 ----
 GPU/Workflow/src/GPUWorkflowSpec.cxx            |  1 -
 9 files changed, 19 insertions(+), 27 deletions(-)

diff --git a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
index bdf9b95e94450..3e196fa9bb7cc 100644
--- a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
+++ b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
@@ -50,24 +50,23 @@ BOOST_AUTO_TEST_CASE(CATracking_test1)
 {
   GPUO2Interface tracker;
 
-  float solenoidBz = -5.00668; //B-field
-  float refX = 1000.;          //transport tracks to this x after tracking, >500 for disabling
-  bool continuous = false;     //time frame data v.s. triggered events
+  float solenoidBz = -5.00668; // B-field
+  float refX = 1000.;          // transport tracks to this x after tracking, >500 for disabling
+  bool continuous = false;     // time frame data v.s. triggered events
 
   GPUO2InterfaceConfiguration config;
   config.configDeviceBackend.deviceType = GPUDataTypes::DeviceType::CPU;
   config.configDeviceBackend.forceDeviceType = true;
 
-  config.configProcessing.ompThreads = 4;         //4 threads if we run on the CPU, 1 = default, 0 = auto-detect
-  config.configProcessing.runQA = false;          //Run QA after tracking
-  config.configProcessing.eventDisplay = nullptr; //Ptr to event display backend, for running standalone OpenGL event display
+  config.configProcessing.ompThreads = 4;         // 4 threads if we run on the CPU, 1 = default, 0 = auto-detect
+  config.configProcessing.runQA = false;          // Run QA after tracking
+  config.configProcessing.eventDisplay = nullptr; // Ptr to event display backend, for running standalone OpenGL event display
 
   config.configGRP.solenoidBzNominalGPU = solenoidBz;
   config.configGRP.grpContinuousMaxTimeBin = continuous ? GPUSettings::TPC_MAX_TF_TIME_BIN : 0; // Number of timebins in timeframe if continuous, 0 otherwise
 
-  config.configReconstruction.tpc.nWays = 3;               //Should always be 3!
-  config.configReconstruction.tpc.nWaysOuter = true;       //Will create outer param for TRD
-  config.configReconstruction.tpc.searchWindowDZDR = 2.5f; //Should always be 2.5 for looper-finding and/or continuous tracking
+  config.configReconstruction.tpc.nWays = 3;               // Should always be 3!
+  config.configReconstruction.tpc.searchWindowDZDR = 2.5f; // Should always be 2.5 for looper-finding and/or continuous tracking
   config.configReconstruction.tpc.trackReferenceX = refX;
 
   config.configWorkflow.steps.set(GPUDataTypes::RecoStep::TPCConversion, GPUDataTypes::RecoStep::TPCSectorTracking,
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index ff4ce2c905507..b2af986ebfac9 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -270,7 +270,6 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     GPUError("WARNING, deterministicGPUReconstruction needs GPUCA_DETERMINISTIC_MODE for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
 #endif
     mProcessingSettings->overrideClusterizerFragmentLen = TPC_MAX_FRAGMENT_LEN_GPU;
-    param().rec.tpc.nWaysOuter = true;
     if (GetProcessingSettings().createO2Output > 1) {
       mProcessingSettings->createO2Output = 1;
     }
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 75d9230a364f0..b35bc04d7232f 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -134,7 +134,6 @@ AddOptionRTC(cfNoiseSuppressionEpsilon, uint8_t, 10, "", 0, "Cluster Finder: Dif
 AddOptionRTC(cfNoiseSuppressionEpsilonRelative, uint8_t, 76, "", 0, "Cluster Finder: Difference between peak and charge for the charge to count as a minima during noise suppression, relative as fraction of 255")
 AddOptionRTC(cfEdgeTwoPads, uint8_t, 0, "", 0, "Flag clusters with peak on the 2 pads closes to the sector edge as edge cluster")
 AddOptionRTC(nWays, uint8_t, 3, "", 0, "Do N fit passes in final fit of merger")
-AddOptionRTC(nWaysOuter, int8_t, 0, "", 0, "Store outer param")
 AddOptionRTC(trackFitRejectMode, int8_t, 5, "", 0, "0: no limit on rejection or missed hits, >0: break after n rejected hits, <0: reject at max -n hits")
 AddOptionRTC(rejectIFCLowRadiusCluster, uint8_t, 1, "", 0, "Reject clusters that get the IFC mask error during refit")
 AddOptionRTC(dEdxTruncLow, uint8_t, 2, "", 0, "Low truncation threshold, fraction of 128")
@@ -595,7 +594,7 @@ AddOption(rundEdx, int32_t, -1, "", 0, "Enable dEdx processing")
 AddOption(runCompression, int32_t, 1, "", 0, "Enable TPC Compression")
 AddOption(runTransformation, int32_t, 1, "", 0, "Enable TPC Transformation")
 AddOption(runRefit, bool, false, "", 0, "Enable final track refit")
-AddOption(setO2Settings, bool, false, "", 0, "Set O2 defaults for outerParam, output of shared cluster map, referenceX")
+AddOption(setO2Settings, bool, false, "", 0, "Set O2 defaults for output of shared cluster map, referenceX")
 AddHelp("help", 'h')
 AddHelpAll("helpall", 'H')
 AddSubConfig(GPUSettingsRec, rec)
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index f42b7cc34df73..b69d0941d9375 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -299,8 +299,8 @@ bool GPUChainTracking::ValidateSettings()
     return false;
   }
   if (GetRecoSteps() & RecoStep::TRDTracking) {
-    if (GetProcessingSettings().trdTrackModelO2 && (GetProcessingSettings().createO2Output == 0 || param().rec.tpc.nWaysOuter == 0 || (GetMatLUT() == nullptr && !GetProcessingSettings().willProvideO2PropagatorLate))) {
-      GPUError("TRD tracking can only run on O2 TPC tracks if createO2Output is enabled (%d), nWaysOuter is set (%d), and matBudLUT is available (0x%p)", (int32_t)GetProcessingSettings().createO2Output, (int32_t)param().rec.tpc.nWaysOuter, (void*)GetMatLUT());
+    if (GetProcessingSettings().trdTrackModelO2 && (GetProcessingSettings().createO2Output == 0 || (GetMatLUT() == nullptr && !GetProcessingSettings().willProvideO2PropagatorLate))) {
+      GPUError("TRD tracking can only run on O2 TPC tracks if createO2Output is enabled (%d), and matBudLUT is available (0x%p)", (int32_t)GetProcessingSettings().createO2Output, (void*)GetMatLUT());
       return false;
     }
     if ((GetRecoStepsGPU() & RecoStep::TRDTracking) && !GetProcessingSettings().trdTrackModelO2 && GetProcessingSettings().createO2Output > 1) {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx b/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
index 9f72b7443c49f..ca47d65b32cd4 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingTRD.cxx
@@ -62,7 +62,7 @@ int32_t GPUChainTracking::RunTRDTrackingInternal()
       if (!Tracker.PreCheckTrackTRDCandidate(trk)) {
         continue;
       }
-      const GPUTRDTrackGPU& trktrd = param().rec.tpc.nWaysOuter ? (GPUTRDTrackGPU)trk.OuterParam() : (GPUTRDTrackGPU)trk;
+      const GPUTRDTrackGPU& trktrd = (GPUTRDTrackGPU)trk.OuterParam();
       if (!Tracker.CheckTrackTRDCandidate(trktrd)) {
         continue;
       }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 30fcf7053089b..3cebcdbfcdb7a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -85,9 +85,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     float sumInvSqrtCharge = 0.f;
     int32_t nAvgCharge = 0;
 
-    if (iWay && param.rec.tpc.nWaysOuter) {
-      if (iWay == nWays - 1) {
-        StoreOuter(&track.OuterParam(), prop, 0);
+    if (iWay) {
+      if (iWay && ((nWays - iWay) & 1) == 1) {
+        StoreOuter(&track.OuterParam(), prop.GetAlpha());
       }
     }
 
@@ -626,9 +626,9 @@ GPUd() bool GPUTPCGMTrackParam::FollowCircleChk(float lrFactor, float toY, float
          (up ? (-mP[0] * lrFactor > toX || (right ^ (mP[2] > 0))) : (-mP[0] * lrFactor < toX || (right ^ (mP[2] < 0)))); // don't overshoot in X
 }
 
-GPUdii() void GPUTPCGMTrackParam::StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, const GPUTPCGMPropagator& prop, int32_t phase)
+GPUdii() void GPUTPCGMTrackParam::StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, float alpha)
 {
-  CADEBUG(printf("\t%21sStorO%d  Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f\n", "", phase, prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14])));
+  CADEBUG(printf("\t%21sStorO  Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14])));
   for (int32_t i = 0; i < 5; i++) {
     outerParam->P[i] = mP[i];
   }
@@ -636,7 +636,7 @@ GPUdii() void GPUTPCGMTrackParam::StoreOuter(gputpcgmmergertypes::GPUTPCOuterPar
     outerParam->C[i] = mC[i];
   }
   outerParam->X = mX;
-  outerParam->alpha = prop.GetAlpha();
+  outerParam->alpha = alpha;
 }
 
 GPUdic(0, 1) void GPUTPCGMTrackParam::StoreAttachMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toY, float toX, int32_t toSector, int32_t toRow, bool inFlyDirection, float alpha)
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index 0cf65f84d1c44..a6258e3d2595d 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -153,7 +153,7 @@ class GPUTPCGMTrackParam
   GPUd() void AttachClustersMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toY, GPUTPCGMPropagator& prop);
   GPUd() int32_t FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection);
   GPUd() void StoreAttachMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toY, float toX, int32_t toSector, int32_t toRow, bool inFlyDirection, float alpha);
-  GPUd() void StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, const GPUTPCGMPropagator& prop, int32_t phase);
+  GPUd() void StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, float alpha);
   GPUd() static void RefitLoop(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t loopIdx);
 
   GPUd() void AddCovDiagErrors(const float* GPUrestrict() errors2);
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 38af340d67d7a..7dcabde4e94b6 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -220,7 +220,6 @@ int32_t ReadConfiguration(int argc, char** argv)
     if (configStandalone.runGPU) {
       configStandalone.proc.forceHostMemoryPoolSize = 1024 * 1024 * 1024;
     }
-    configStandalone.rec.tpc.nWaysOuter = 1;
     configStandalone.rec.tpc.trackReferenceX = 83;
     configStandalone.proc.outputSharedClusterMap = 1;
     configStandalone.proc.clearO2OutputFromGPU = 1;
@@ -415,9 +414,6 @@ int32_t SetupReconstruction()
   steps.outputs.setBits(GPUDataTypes::InOutType::TPCClusters, steps.steps.isSet(GPUDataTypes::RecoStep::TPCClusterFinding));
 
   if (steps.steps.isSet(GPUDataTypes::RecoStep::TRDTracking)) {
-    if (recSet.tpc.nWays > 1) {
-      recSet.tpc.nWaysOuter = 1;
-    }
     if (procSet.createO2Output && !procSet.trdTrackModelO2) {
       procSet.createO2Output = 1; // Must not be 2, to make sure TPC GPU tracks are still available for TRD
     }
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 2642ff3ee1ebc..68f7be8fb6330 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -227,7 +227,6 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
       mConfig->configProcessing.runQA = -mQATaskMask;
     }
   }
-  mConfig->configReconstruction.tpc.nWaysOuter = true;
   mConfig->configInterface.outputToExternalBuffers = true;
   if (mConfParam->synchronousProcessing) {
     mConfig->configReconstruction.useMatLUT = false;

From 7b9388d34b26c4a09eaed19533ce34e06ee66f7b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 31 Jul 2025 16:31:05 +0200
Subject: [PATCH 0828/1764] GPU TPC: Adjust tagging of adjacent looper clusters
 to segmented looping tracks

---
 GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx  |   2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 148 +++++++-----------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |  15 +-
 3 files changed, 64 insertions(+), 101 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
index 6bee239e42848..3cb937d4f7abc 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
@@ -32,7 +32,7 @@ template <>
 GPUdii() void GPUTPCGMMergerFollowLoopers::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger)
 {
   GPUCA_TBB_KERNEL_LOOP(merger.GetRec(), uint32_t, i, merger.Memory()->nLoopData, {
-    GPUTPCGMTrackParam::RefitLoop(&merger, i);
+    GPUTPCGMTrackParam::PropagateLooper(&merger, i);
   });
 }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 3cebcdbfcdb7a..915d62c576af9 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -85,10 +85,8 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     float sumInvSqrtCharge = 0.f;
     int32_t nAvgCharge = 0;
 
-    if (iWay) {
-      if (iWay && ((nWays - iWay) & 1) == 1) {
-        StoreOuter(&track.OuterParam(), prop.GetAlpha());
-      }
+    if (iWay && ((nWays - iWay) & 1) == 1) {
+      StoreOuter(&track.OuterParam(), prop.GetAlpha());
     }
 
     int32_t resetT0 = initResetT0();
@@ -106,16 +104,14 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
     N = 0;
     lastUpdateX = -1;
-    const bool inFlyDirection = (track.Leg() & 1);
+    const bool inFlyDirection = !((iWay ^ nWays) & 1);
     const int32_t wayDirection = (iWay & 1) ? -1 : 1;
 
-    bool noFollowCircle = false, noFollowCircle2 = false;
     int32_t goodRows = 0;
     for (int32_t ihit = ihitStart; ihit >= 0 && ihit < maxN; ihit += wayDirection) {
       const bool crossCE = lastSector != 255 && ((lastSector < 18) ^ (clusters[ihit].sector < 18));
       if (crossCE) {
         lastSector = clusters[ihit].sector;
-        noFollowCircle2 = true;
       }
 
       if ((param.rec.tpc.trackFitRejectMode > 0 && nMissed >= param.rec.tpc.trackFitRejectMode) || nMissed2 >= param.rec.tpc.trackFitMaxRowMissedHard || clusters[ihit].state & GPUTPCGMMergedTrackHit::flagReject) {
@@ -160,14 +156,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       // clang-format off
       CADEBUG(printf("\tSector %2d %4sTrack   Alpha %8.3f %s, X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", (int32_t)cluster.sector, "", prop.GetAlpha(), (CAMath::Abs(prop.GetAlpha() - clAlpha) < 0.01 ? "   " : " R!"), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
       // clang-format on
-      if (allowModification && false /*changeDirection*/ && !noFollowCircle && !noFollowCircle2) {
-        if (lastRow != 255) {
-          if (!(merger->Param().rec.tpc.disableRefitAttachment & 4)) {
-            StoreAttachMirror(merger, lastSector, lastRow, iTrk, clAlpha, yy, xx, cluster.sector, cluster.row, inFlyDirection, prop.GetAlpha());
-            noFollowCircle = true;
-          }
-        }
-      } else if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
+      if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
           bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2;
           dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, track.Leg() == 0, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
@@ -180,15 +169,15 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         }
       }
 
-      int32_t err = prop.PropagateToXAlpha(xx, clAlpha, inFlyDirection);
+      int32_t retValProp = prop.PropagateToXAlpha(xx, clAlpha, inFlyDirection);
       // clang-format off
       CADEBUG(if (!CheckCov()){printf("INVALID COV AFTER PROPAGATE!!!\n");});
       // clang-format on
-      if (err == -2) // Rotation failed, try to bring to new x with old alpha first, rotate, and then propagate to x, alpha
+      if (retValProp == -2) // Rotation failed, try to bring to new x with old alpha first, rotate, and then propagate to x, alpha
       {
         CADEBUG(printf("REROTATE\n"));
         if (prop.PropagateToXAlpha(xx, prop.GetAlpha(), inFlyDirection) == 0) {
-          err = prop.PropagateToXAlpha(xx, clAlpha, inFlyDirection);
+          retValProp = prop.PropagateToXAlpha(xx, clAlpha, inFlyDirection);
         }
       }
       if (lastRow == 255 || CAMath::Abs((int32_t)lastRow - (int32_t)cluster.row) > 5 || lastSector != cluster.sector || (param.rec.tpc.trackFitRejectMode < 0 && -nMissed <= param.rec.tpc.trackFitRejectMode)) {
@@ -196,7 +185,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       } else {
         goodRows++;
       }
-      if (err == 0) {
+      if (retValProp == 0) {
         lastRow = cluster.row;
         lastSector = cluster.sector;
       }
@@ -216,51 +205,28 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         }
       }
 
-      if (err == 0 && false /*changeDirection*/) {
-        const float mirrordY = prop.GetMirroredYTrack();
-        CADEBUG(printf(" -- MirroredY: %f --> %f", mP[0], mirrordY));
-        if (CAMath::Abs(yy - mP[0]) > CAMath::Abs(yy - mirrordY)) {
-          CADEBUG(printf(" - Mirroring!!!"));
-          if (allowModification && !(merger->Param().rec.tpc.disableRefitAttachment & 8)) {
-            StoreAttachMirror(merger, cluster.sector, cluster.row, iTrk, 0, yy, 0, -1, 0, 0, prop.GetAlpha());
-          }
-          MirrorTo(prop, yy, zz, inFlyDirection, param, cluster.row, clusterState, true, cluster.sector);
-          noFollowCircle = false;
-
-          lastUpdateX = mX;
-          lastRow = 255;
-          N++;
-          resetT0 = initResetT0();
-          // clang-format off
-          CADEBUG(printf("\n"));
-          CADEBUG(printf("\t%21sMirror  Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
-          // clang-format on
-          continue;
-        }
-      }
-
       float uncorrectedY = -1e6f;
       if (allowModification) {
         uncorrectedY = AttachClusters(merger, cluster.sector, cluster.row, iTrk, track.Leg() == 0, prop);
       }
 
-      const int32_t err2 = mNDF > 0 && CAMath::Abs(prop.GetSinPhi0()) >= maxSinForUpdate;
-      if (err || err2) {
+      const bool sinPhiErr = mNDF > 0 && CAMath::Abs(prop.GetSinPhi0()) >= maxSinForUpdate;
+      if (retValProp || sinPhiErr) {
         if (mC[0] > param.rec.tpc.trackFitCovLimit || mC[2] > param.rec.tpc.trackFitCovLimit) {
           break;
         }
         MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagHighIncl);
         nMissed2++;
         NTolerated++;
-        CADEBUG(printf(" --- break (%d, %d)\n", err, err2));
+        CADEBUG(printf(" --- break (%d, %d)\n", retValProp, (int32_t)sinPhiErr));
         continue;
       }
       CADEBUG(printf("\n"));
 
-      int32_t retVal;
+      int32_t retValUpd;
       float threshold = 3.f + (lastUpdateX >= 0 ? (CAMath::Abs(mX - lastUpdateX) / 2) : 0.f);
       if (mNDF > 5 && (CAMath::Abs(yy - mP[0]) > threshold || CAMath::Abs(zz - mP[1]) > threshold)) {
-        retVal = GPUTPCGMPropagator::updateErrorClusterRejectedDistance;
+        retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedDistance;
       } else {
         int8_t rejectChi2 = attempt ? 0 : ((param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (refit ? (GPUTPCGMPropagator::rejectInterFill + ((nWays - iWay) & 1)) : 0) : (allowModification && goodRows > 5));
 #if EXTRACT_RESIDUALS == 1
@@ -284,28 +250,27 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 #endif
         GPUCA_DEBUG_STREAMER_CHECK(GPUTPCGMPropagator::DebugStreamerVals debugVals;);
         if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowModification
-          retVal = GPUTPCGMPropagator::updateErrorClusterRejectedEdge;
+          retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedEdge;
         } else {
           const float time = merger->GetConstantMem()->ioPtrs.clustersNative ? merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].getTime() : -1.f;
           const float invSqrtCharge = merger->GetConstantMem()->ioPtrs.clustersNative ? CAMath::InvSqrt(merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].qMax) : 0.f;
           const float invCharge = merger->GetConstantMem()->ioPtrs.clustersNative ? (1.f / merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].qMax) : 0.f;
           float invAvgCharge = (sumInvSqrtCharge += invSqrtCharge) / ++nAvgCharge;
           invAvgCharge *= invAvgCharge;
-          retVal = prop.Update(yy, zz, cluster.row, param, clusterState, rejectChi2, &interpolation.hit[ihit], refit, cluster.sector, time, invAvgCharge, invCharge GPUCA_DEBUG_STREAMER_CHECK(, &debugVals));
+          retValUpd = prop.Update(yy, zz, cluster.row, param, clusterState, rejectChi2, &interpolation.hit[ihit], refit, cluster.sector, time, invAvgCharge, invCharge GPUCA_DEBUG_STREAMER_CHECK(, &debugVals));
         }
         GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamUpdateTrack, iTrk)) {
-          merger->DebugStreamerUpdate(iTrk, ihit, xx, yy, zz, cluster, merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num], *this, prop, interpolation.hit[ihit], rejectChi2, refit, retVal, sumInvSqrtCharge / nAvgCharge * sumInvSqrtCharge / nAvgCharge, yy, zz, clusterState, debugVals.retVal, debugVals.err2Y, debugVals.err2Z);
+          merger->DebugStreamerUpdate(iTrk, ihit, xx, yy, zz, cluster, merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num], *this, prop, interpolation.hit[ihit], rejectChi2, refit, retValUpd, sumInvSqrtCharge / nAvgCharge * sumInvSqrtCharge / nAvgCharge, yy, zz, clusterState, debugVals.retVal, debugVals.err2Y, debugVals.err2Z);
         });
       }
       // clang-format off
       CADEBUG(if (!CheckCov()) GPUError("INVALID COV AFTER UPDATE!!!"));
-      CADEBUG(printf("\t%21sFit     Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f), DzDs %5.2f %16s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   Err %d\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[3], "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retVal));
+      CADEBUG(printf("\t%21sFit     Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f), DzDs %5.2f %16s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   Err %d\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[3], "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retValUpd));
       // clang-format on
 
       ConstrainSinPhi();
-      if (retVal == 0) // track is updated
+      if (retValUpd == 0) // track is updated
       {
-        noFollowCircle2 = false;
         lastUpdateX = mX;
         covYYUpd = mC[0];
         nMissed = nMissed2 = 0;
@@ -346,7 +311,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
             }
           }
         }
-      } else if (retVal >= GPUTPCGMPropagator::updateErrorClusterRejected) { // cluster far away form the track
+      } else if (retValUpd >= GPUTPCGMPropagator::updateErrorClusterRejected) { // cluster far away form the track
         if (allowModification) {
           MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagRejectDistance);
         } else if (iWay == nWays - 1) {
@@ -358,6 +323,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         break; // bad chi2 for the whole track, stop the fit
       }
     }
+    if (nWays - iWay <= 2 && !(merger->Param().rec.tpc.disableRefitAttachment & 4) && lastRow != 255 && lastSector != 255) {
+      StoreLoopPropagation(merger, lastSector, lastRow, iTrk, lastRow > clusters[0].row, prop.GetAlpha());
+    }
     if (((nWays - iWay) & 1) && (iWay != nWays - 1) && !track.CCE() && !track.Looper()) {
       ShiftZ(clusters, merger, maxN);
     }
@@ -639,8 +607,21 @@ GPUdii() void GPUTPCGMTrackParam::StoreOuter(gputpcgmmergertypes::GPUTPCOuterPar
   outerParam->alpha = alpha;
 }
 
-GPUdic(0, 1) void GPUTPCGMTrackParam::StoreAttachMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toY, float toX, int32_t toSector, int32_t toRow, bool inFlyDirection, float alpha)
+GPUdic(0, 1) void GPUTPCGMTrackParam::StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outerParam, float alpha)
 {
+  if (iRow == 0 || iRow == GPUCA_ROW_COUNT - 1) {
+    return;
+  }
+  if (CAMath::Abs(mP[2]) >= GPUCA_MAX_SIN_PHI_LOW) {
+    return;
+  }
+  if (CAMath::Abs(mP[2]) < 0.75) {
+    return;
+  }
+  if ((mP[2] * mP[4] < 0) ^ outerParam) {
+    return;
+  }
+
   uint32_t nLoopData = CAMath::AtomicAdd(&Merger->Memory()->nLoopData, 1u);
   if (nLoopData >= Merger->NMaxTracks()) {
     Merger->raiseError(GPUErrors::ERROR_MERGER_LOOPER_OVERFLOW, nLoopData, Merger->NMaxTracks());
@@ -649,20 +630,15 @@ GPUdic(0, 1) void GPUTPCGMTrackParam::StoreAttachMirror(const GPUTPCGMMerger* GP
   }
   GPUTPCGMLoopData data;
   data.param = *this;
-  data.alpha = alpha;
   data.track = iTrack;
-  data.toAlpha = toAlpha;
-  data.toY = toY;
-  data.toX = toX;
+  data.alpha = alpha;
   data.sector = sector;
   data.row = iRow;
-  data.toSector = toSector;
-  data.toRow = toRow;
-  data.inFlyDirection = inFlyDirection;
+  data.outerParam = outerParam;
   Merger->LoopData()[nLoopData] = data;
 }
 
-GPUdii() void GPUTPCGMTrackParam::RefitLoop(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t loopIdx)
+GPUdii() void GPUTPCGMTrackParam::PropagateLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t loopIdx)
 {
   GPUTPCGMPropagator prop;
   prop.SetMaterialTPC();
@@ -675,11 +651,8 @@ GPUdii() void GPUTPCGMTrackParam::RefitLoop(const GPUTPCGMMerger* GPUrestrict()
 
   GPUTPCGMLoopData& data = Merger->LoopData()[loopIdx];
   prop.SetTrack(&data.param, data.alpha);
-  if (data.toSector == -1) {
-    data.param.AttachClustersMirror(Merger, data.sector, data.row, data.track, data.toY, prop);
-  } else {
-    data.param.FollowCircle(Merger, prop, data.sector, data.row, data.track, data.toAlpha, data.toX, data.toY, data.toSector, data.toRow, data.inFlyDirection);
-  }
+  data.param.AttachClustersLooper(Merger, data.sector, data.row, data.track, data.outerParam, prop);
+  // data.param.FollowCircle(Merger, prop, data.sector, data.row, data.track, data.toAlpha, data.toX, data.toY, data.toSector, data.toRow, data.inFlyDirection);
 }
 
 GPUdi() int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& GPUrestrict() prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection)
@@ -778,38 +751,33 @@ GPUdi() int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUrestri
   return (0);
 }
 
-GPUdi() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toY, GPUTPCGMPropagator& GPUrestrict() prop)
+GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outer, GPUTPCGMPropagator& GPUrestrict() prop)
 {
   static constexpr float kSectAngle = 2 * M_PI / 18.f;
   // Note that the coordinate system is rotated by 90 degree swapping X and Y!
   float X = mP[2] > 0 ? mP[0] : -mP[0];
-  float toX = mP[2] > 0 ? toY : -toY;
   float Y = mP[2] > 0 ? -mX : mX;
   float Z = mP[1];
-  if (CAMath::Abs(mP[2]) >= GPUCA_MAX_SIN_PHI_LOW) {
-    return;
-  }
   float SinPhi = CAMath::Sqrt(1 - mP[2] * mP[2]) * (mP[2] > 0 ? -1 : 1);
-  if (CAMath::Abs(SinPhi) >= GPUCA_MAX_SIN_PHI_LOW) {
-    return;
-  }
   float b = prop.GetBz(prop.GetAlpha(), mX, mP[0], mP[1]);
 
-  int32_t count = CAMath::Float2IntRn(CAMath::Abs((toX - X) * 2.f));
-  if (count == 0) {
-    return;
-  }
-  float dx = (toX - X) / count;
+  float dx = outer ? 1.f : -1.f;
   const float myRowX = GPUTPCGeometry::Row2X(iRow);
-  // printf("AttachMirror\n");
-  // printf("X %f Y %f Z %f SinPhi %f toY %f -->\n", mX, mP[0], mP[1], mP[2], toY);
-  // printf("X %f Y %f Z %f SinPhi %f, count %d dx %f (to: %f)\n", X, Y, Z, SinPhi, count, dx, X + count * dx);
-  while (count--) {
+  // printf("\nAttachMirror sector %d row %d outer %d\n", (int)sector, (int)iRow, (int)outer);
+  // printf("X %f Y %f Z %f SinPhi %f -->\n", mX, mP[0], mP[1], mP[2]);
+  // printf("X %f Y %f Z %f SinPhi %f, dx %f\n", X, Y, Z, SinPhi, dx);
+  uint32_t maxTries = 100;
+  while (maxTries--) {
     float ex = CAMath::Sqrt(1 - SinPhi * SinPhi);
     float exi = 1.f / ex;
     float dxBzQ = dx * -b * mP[4];
     float newSinPhi = SinPhi + dxBzQ;
     if (CAMath::Abs(newSinPhi) > GPUCA_MAX_SIN_PHI_LOW) {
+      // printf("Abort, newSinPhi %f\n", newSinPhi);
+      return;
+    }
+    if (mP[2] > 0 ? (newSinPhi > 0.5) : (newSinPhi < -0.5)) {
+      // printf("Finished, newSinPhi %f\n", newSinPhi);
       return;
     }
     float dS = dx * exi;
@@ -821,18 +789,18 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersMirror(const GPUTPCGMMerger* GPUr
     Z += dS * mP[3];
     SinPhi = newSinPhi;
     if (CAMath::Abs(X) > CAMath::Abs(Y) * CAMath::Tan(kSectAngle / 2.f)) {
-      continue;
+      // printf("Abort, sector edge\n");
+      return;
     }
 
-    // printf("count %d: At X %f Y %f Z %f SinPhi %f\n", count, mP[2] > 0 ? -Y : Y, mP[2] > 0 ? X : -X, Z, SinPhi);
-
+    // printf("count %d: At X %f Y %f Z %f SinPhi %f\n", maxTries, mP[2] > 0 ? -Y : Y, mP[2] > 0 ? X : -X, Z, SinPhi);
     float paramX = mP[2] > 0 ? -Y : Y;
-    int32_t step = paramX >= mX ? 1 : -1;
+    int32_t step = outer ? 1 : -1;
     int32_t found = 0;
     for (int32_t j = iRow; j >= 0 && j < GPUCA_ROW_COUNT && found < 3; j += step) {
       float rowX = mX + GPUTPCGeometry::Row2X(j) - myRowX;
       if (CAMath::Abs(rowX - paramX) < 1.5f) {
-        // printf("Attempt row %d\n", j);
+        // printf("Attempt row %d at y %f\n", j, X);
         AttachClusters(Merger, sector, j, iTrack, false, mP[2] > 0 ? X : -X, Z);
       }
     }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index a6258e3d2595d..ee46b61e8d775 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -149,12 +149,12 @@ class GPUTPCGMTrackParam
   GPUd() bool AttachClustersPropagate(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t lastRow, int32_t toRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop, bool inFlyDirection, float maxSinPhi = GPUCA_MAX_SIN_PHI, bool checkdEdx = false);
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop); // Returns uncorrectedY for later use
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, float Y, float Z);
-  // We force to compile these twice, for RefitLoop and for Fit, for better optimization
-  GPUd() void AttachClustersMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toY, GPUTPCGMPropagator& prop);
+  // We force to compile these twice, for PropagateLooper and for Fit, for better optimization
+  GPUd() void AttachClustersLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outer, GPUTPCGMPropagator& prop);
   GPUd() int32_t FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection);
-  GPUd() void StoreAttachMirror(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toY, float toX, int32_t toSector, int32_t toRow, bool inFlyDirection, float alpha);
+  GPUd() void StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outerParam, float alpha);
   GPUd() void StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, float alpha);
-  GPUd() static void RefitLoop(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t loopIdx);
+  GPUd() static void PropagateLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t loopIdx);
 
   GPUd() void AddCovDiagErrors(const float* GPUrestrict() errors2);
   GPUd() void AddCovDiagErrorsWithCorrelations(const float* GPUrestrict() errors2);
@@ -227,15 +227,10 @@ class GPUTPCGMTrackParam
 struct GPUTPCGMLoopData {
   GPUTPCGMTrackParam param;
   uint32_t track;
-  float toY;
-  float toX;
   float alpha;
-  float toAlpha;
   uint8_t sector;
   uint8_t row;
-  int8_t toSector;
-  uint8_t toRow;
-  uint8_t inFlyDirection;
+  uint8_t outerParam;
 };
 
 GPUdi() int32_t GPUTPCGMTrackParam::initResetT0()

From b66531742e047b747737ad197aeda3358d562dab Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 25 Aug 2025 13:33:05 +0200
Subject: [PATCH 0829/1764] GPU QA: Proper fix for fetching timebins of MC data

---
 GPU/GPUTracking/qa/GPUQA.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 079e7e7be4dc7..6d1e724e1be3b 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -1729,7 +1729,9 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       mT0[0]->Fill(track.GetParam().GetTOffset());
       if (mTrackMCLabels.size() && !mTrackMCLabels[i].isFake() && !track.MergedLooper() && !track.CCE()) {
         const auto& info = GetMCTrack(mTrackMCLabels[i]);
-        mT0[1]->Fill(track.GetParam().GetTOffset() - info.t0);
+        if (info.t0 != -100.f) {
+          mT0[1]->Fill(track.GetParam().GetTOffset() - info.t0);
+        }
       }
     }
     if (mClNative && mTracking && mTracking->GetTPCTransformHelper()) {

From aac042bd9d7525e8290340af064da4f7c37b2dcb Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 10 Sep 2025 23:41:31 +0200
Subject: [PATCH 0830/1764] GPU TPC: Implement looper following with propagator
 for segmented tracks

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 152 +++++++-----------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |   9 +-
 2 files changed, 65 insertions(+), 96 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 915d62c576af9..71b1878804893 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -154,7 +154,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       const auto& cluster = clusters[ihit];
 
       // clang-format off
-      CADEBUG(printf("\tSector %2d %4sTrack   Alpha %8.3f %s, X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", (int32_t)cluster.sector, "", prop.GetAlpha(), (CAMath::Abs(prop.GetAlpha() - clAlpha) < 0.01 ? "   " : " R!"), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
+      CADEBUG(printf("\tSector %2d %11sTrack   Alpha %8.3f %s, X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", (int32_t)cluster.sector, "", prop.GetAlpha(), (CAMath::Abs(prop.GetAlpha() - clAlpha) < 0.01 ? "   " : " R!"), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
       // clang-format on
       if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
@@ -190,7 +190,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         lastSector = cluster.sector;
       }
       // clang-format off
-      CADEBUG(printf("\t%21sPropaga Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Res %8.3f %8.3f   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   Err %d", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[0] - yy, mP[1] - zz, sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], err));
+      CADEBUG(printf("\t%21sPropaga Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Res %8.3f %8.3f   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   Err %d", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[0] - yy, mP[1] - zz, sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retValProp));
       // clang-format on
 
       if (crossCE) {
@@ -218,7 +218,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagHighIncl);
         nMissed2++;
         NTolerated++;
-        CADEBUG(printf(" --- break (%d, %d)\n", retValProp, (int32_t)sinPhiErr));
+        CADEBUG(printf(", %d --- break\n", (int32_t)sinPhiErr));
         continue;
       }
       CADEBUG(printf("\n"));
@@ -324,7 +324,8 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       }
     }
     if (nWays - iWay <= 2 && !(merger->Param().rec.tpc.disableRefitAttachment & 4) && lastRow != 255 && lastSector != 255) {
-      StoreLoopPropagation(merger, lastSector, lastRow, iTrk, lastRow > clusters[0].row, prop.GetAlpha());
+      StoreLoopPropagation(merger, lastSector, lastRow, iTrk, lastRow > clusters[(iWay & 1) ? (maxN - 1) : 0].row, prop.GetAlpha());
+      CADEBUG(printf("\t\tSTORING %d lastRow %d row %d out %d\n", iTrk, (int)lastRow, (int)clusters[(iWay & 1) ? (maxN - 1) : 0].row, lastRow > clusters[(iWay & 1) ? (maxN - 1) : 0].row));
     }
     if (((nWays - iWay) & 1) && (iWay != nWays - 1) && !track.CCE() && !track.Looper()) {
       ShiftZ(clusters, merger, maxN);
@@ -587,16 +588,9 @@ GPUd() bool GPUTPCGMTrackParam::AttachClustersPropagate(const GPUTPCGMMerger* GP
   return dodEdx;
 }
 
-GPUd() bool GPUTPCGMTrackParam::FollowCircleChk(float lrFactor, float toY, float toX, bool up, bool right)
-{
-  return CAMath::Abs(mX * lrFactor - toY) > 1.f &&                                                                       // transport further in Y
-         CAMath::Abs(mP[2]) < 0.7f &&                                                                                    // rotate back
-         (up ? (-mP[0] * lrFactor > toX || (right ^ (mP[2] > 0))) : (-mP[0] * lrFactor < toX || (right ^ (mP[2] < 0)))); // don't overshoot in X
-}
-
 GPUdii() void GPUTPCGMTrackParam::StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, float alpha)
 {
-  CADEBUG(printf("\t%21sStorO  Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14])));
+  CADEBUG(printf("\t%21sStorO   Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f, SP %5.2f   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f\n", "", alpha, mX, mP[0], mP[1], mP[4], mP[2], sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14])));
   for (int32_t i = 0; i < 5; i++) {
     outerParam->P[i] = mP[i];
   }
@@ -607,18 +601,18 @@ GPUdii() void GPUTPCGMTrackParam::StoreOuter(gputpcgmmergertypes::GPUTPCOuterPar
   outerParam->alpha = alpha;
 }
 
-GPUdic(0, 1) void GPUTPCGMTrackParam::StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outerParam, float alpha)
+GPUdic(0, 1) void GPUTPCGMTrackParam::StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, float alpha)
 {
   if (iRow == 0 || iRow == GPUCA_ROW_COUNT - 1) {
     return;
   }
-  if (CAMath::Abs(mP[2]) >= GPUCA_MAX_SIN_PHI_LOW) {
+  if (CAMath::Abs(mP[2]) >= GPUCA_MAX_SIN_PHI) { // TODO: How can we avoid this?
     return;
   }
   if (CAMath::Abs(mP[2]) < 0.75) {
     return;
   }
-  if ((mP[2] * mP[4] < 0) ^ outerParam) {
+  if ((mP[2] * mP[4] < 0) ^ outwards) {
     return;
   }
 
@@ -634,7 +628,7 @@ GPUdic(0, 1) void GPUTPCGMTrackParam::StoreLoopPropagation(const GPUTPCGMMerger*
   data.alpha = alpha;
   data.sector = sector;
   data.row = iRow;
-  data.outerParam = outerParam;
+  data.outwards = outwards;
   Merger->LoopData()[nLoopData] = data;
 }
 
@@ -651,107 +645,83 @@ GPUdii() void GPUTPCGMTrackParam::PropagateLooper(const GPUTPCGMMerger* GPUrestr
 
   GPUTPCGMLoopData& data = Merger->LoopData()[loopIdx];
   prop.SetTrack(&data.param, data.alpha);
-  data.param.AttachClustersLooper(Merger, data.sector, data.row, data.track, data.outerParam, prop);
-  // data.param.FollowCircle(Merger, prop, data.sector, data.row, data.track, data.toAlpha, data.toX, data.toY, data.toSector, data.toRow, data.inFlyDirection);
+  if (false) {
+    data.param.AttachClustersLooper(Merger, data.sector, data.row, data.track, data.outwards, prop);
+  } else {
+    data.param.AttachClustersLooperFollow(Merger, prop, data.sector, data.row, data.track, data.outwards);
+  }
 }
 
-GPUdi() int32_t GPUTPCGMTrackParam::FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& GPUrestrict() prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection)
+GPUdi() void GPUTPCGMTrackParam::AttachClustersLooperFollow(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& GPUrestrict() prop, int32_t sector, int32_t iRow, int32_t iTrack, bool up)
 {
+  float toX = mX;
+  bool inFlyDirection = (Merger->MergedTracks()[iTrack].Leg() & 1) ^ up;
+
   static constexpr float kSectAngle = 2 * M_PI / 18.f;
   const GPUParam& GPUrestrict() param = Merger->Param();
-  bool right;
-  float dAlpha = toAlpha - prop.GetAlpha();
-  int32_t sectorSide = sector >= (GPUCA_NSECTORS / 2) ? (GPUCA_NSECTORS / 2) : 0;
-  if (CAMath::Abs(dAlpha) > 0.001f) {
-    right = CAMath::Abs(dAlpha) < CAMath::Pi() ? (dAlpha > 0) : (dAlpha < 0);
-  } else {
-    right = toY > mP[0];
-  }
-  bool up = (mP[2] < 0) ^ right;
-  int32_t targetRow = up ? (GPUCA_ROW_COUNT - 1) : 0;
-  float lrFactor = mP[2] < 0 ? -1.f : 1.f; // !(right ^ down) // TODO: shouldn't it be "right ? 1.f : -1.f", but that gives worse results...
+  bool right = (mP[2] < 0) ^ up;
+  const int32_t sectorSide = sector >= (GPUCA_NSECTORS / 2) ? (GPUCA_NSECTORS / 2) : 0;
+  float lrFactor = right ^ !up ? 1.f : -1.f;
   // clang-format off
-  CADEBUG(printf("CIRCLE Track %d: Sector %d Alpha %f X %f Y %f Z %f SinPhi %f DzDs %f - Next hit: Sector %d Alpha %f X %f Y %f - Right %d Up %d dAlpha %f lrFactor %f\n", iTrack, sector, prop.GetAlpha(), mX, mP[0], mP[1], mP[2], mP[3], toSector, toAlpha, toX, toY, (int32_t)right, (int32_t)up, dAlpha, lrFactor));
+  CADEBUG(printf("\nCIRCLE Track %d: Sector %d Alpha %f X %f Y %f Z %f SinPhi %f DzDs %f QPt %f - Right %d Up %d lrFactor %f\n", iTrack, sector, prop.GetAlpha(), mX, mP[0], mP[1], mP[2], mP[3], mP[4], (int32_t)right, (int32_t)up, lrFactor));
   // clang-format on
 
-  AttachClustersPropagate(Merger, sector, iRow, targetRow, iTrack, false, prop, inFlyDirection, 0.7f);
   if (prop.RotateToAlpha(prop.GetAlpha() + (CAMath::Pi() / 2.f) * lrFactor)) {
-    return 1;
+    return;
   }
   CADEBUG(printf("\tRotated: X %f Y %f Z %f SinPhi %f (Alpha %f / %f)\n", mP[0], mX, mP[1], mP[2], prop.GetAlpha(), prop.GetAlpha() + CAMath::Pi() / 2.f));
-  while (sector != toSector || FollowCircleChk(lrFactor, toY, toX, up, right)) {
-    while ((sector != toSector) ? (CAMath::Abs(mX) <= CAMath::Abs(mP[0]) * CAMath::Tan(kSectAngle / 2.f)) : FollowCircleChk(lrFactor, toY, toX, up, right)) {
-      int32_t err = prop.PropagateToXAlpha(mX + 1.f, prop.GetAlpha(), inFlyDirection);
+  uint32_t maxTries = 100;
+  while (true) {
+    while (CAMath::Abs(mX) <= CAMath::Abs(mP[0]) * CAMath::Tan(kSectAngle / 2.f) + 0.1f) {
+      if (maxTries-- == 0) {
+        return;
+      }
+      if (CAMath::Abs(mP[2]) > 0.7f) {
+        return;
+      }
+      if (up ? (-mP[0] * lrFactor > GPUTPCGeometry::Row2X(GPUCA_ROW_COUNT - 1)) : (-mP[0] * lrFactor < GPUTPCGeometry::Row2X(0))) {
+        return;
+      }
+      if (!((up ? (-mP[0] * lrFactor >= toX) : (-mP[0] * lrFactor <= toX)) || (right ^ (mP[2] > 0)))) {
+        return;
+      }
+      int32_t err = prop.PropagateToXAlpha(mX + (up ? 1.f : -1.f), prop.GetAlpha(), inFlyDirection);
       if (err) {
         CADEBUG(printf("\t\tpropagation error (%d)\n", err));
-        prop.RotateToAlpha(prop.GetAlpha() - (CAMath::Pi() / 2.f) * lrFactor);
-        return 1;
+        return;
       }
       CADEBUG(printf("\tPropagated to y = %f: X %f Z %f SinPhi %f\n", mX, mP[0], mP[1], mP[2]));
-      for (int32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      for (int32_t j = 0; j < GPUCA_ROW_COUNT; j++) { // TODO: Avoid iterating over all rows
         float rowX = GPUTPCGeometry::Row2X(j);
         if (CAMath::Abs(rowX - (-mP[0] * lrFactor)) < 1.5f) {
-          CADEBUG(printf("\t\tAttempt row %d (Y %f Z %f)\n", j, mX * lrFactor, mP[1]));
+          CADEBUG(printf("\t\tAttempt row %d (X %f Y %f Z %f)\n", j, rowX, mX * lrFactor, mP[1]));
           AttachClusters(Merger, sector, j, iTrack, false, mX * lrFactor, mP[1]);
         }
       }
     }
-    if (sector != toSector) {
-      if (right) {
-        if (++sector >= sectorSide + 18) {
-          sector -= 18;
-        }
-      } else {
-        if (--sector < sectorSide) {
-          sector += 18;
-        }
-      }
-      CADEBUG(printf("\tRotating to sector %d\n", sector));
-      if (prop.RotateToAlpha(param.Alpha(sector) + (CAMath::Pi() / 2.f) * lrFactor)) {
-        CADEBUG(printf("\t\trotation error\n"));
-        prop.RotateToAlpha(prop.GetAlpha() - (CAMath::Pi() / 2.f) * lrFactor);
-        return 1;
-      }
-      CADEBUG(printf("\tAfter Rotatin Alpha %f Position X %f Y %f Z %f SinPhi %f\n", prop.GetAlpha(), mP[0], mX, mP[1], mP[2]));
-    }
-  }
-  CADEBUG(printf("\tRotating back\n"));
-  for (int32_t i = 0; i < 2; i++) {
-    if (prop.RotateToAlpha(prop.GetAlpha() + (CAMath::Pi() / 2.f) * lrFactor) == 0) {
-      break;
-    }
-    if (i) {
-      CADEBUG(printf("Final rotation failed\n"));
-      return 1;
+    if (maxTries-- == 0) {
+      return;
     }
-    CADEBUG(printf("\tresetting physical model\n"));
-    prop.SetTrack(this, prop.GetAlpha());
-  }
-  prop.Rotate180();
-  CADEBUG(printf("\tMirrored position: Alpha %f X %f Y %f Z %f SinPhi %f DzDs %f\n", prop.GetAlpha(), mX, mP[0], mP[1], mP[2], mP[3]));
-  iRow = toRow;
-  float dx = toX - GPUTPCGeometry::Row2X(toRow);
-  if (up ^ (toX > mX)) {
-    if (up) {
-      while (iRow < GPUCA_ROW_COUNT - 2 && GPUTPCGeometry::Row2X(iRow + 1) + dx <= mX) {
-        iRow++;
+    if (right) {
+      if (++sector >= sectorSide + 18) {
+        sector -= 18;
       }
     } else {
-      while (iRow > 1 && GPUTPCGeometry::Row2X(iRow - 1) + dx >= mX) {
-        iRow--;
+      if (--sector < sectorSide) {
+        sector += 18;
       }
     }
-    prop.PropagateToXAlpha(GPUTPCGeometry::Row2X(iRow) + dx, prop.GetAlpha(), inFlyDirection);
-    AttachClustersPropagate(Merger, sector, iRow, toRow, iTrack, false, prop, inFlyDirection);
-  }
-  if (prop.PropagateToXAlpha(toX, prop.GetAlpha(), inFlyDirection)) {
-    mX = toX;
+    CADEBUG(printf("\tRotating to sector %d: %f --> %f\n", sector, prop.GetAlpha(), param.Alpha(sector) + (CAMath::Pi() / 2.f) * lrFactor));
+    int32_t err = prop.RotateToAlpha(param.Alpha(sector) + (CAMath::Pi() / 2.f) * lrFactor);
+    if (err) {
+      CADEBUG(printf("Rotation Error %d\n", err));
+      return;
+    }
+    CADEBUG(printf("\tAfter Rotating Alpha %f Position X %f Y %f Z %f SinPhi %f\n", prop.GetAlpha(), mP[0], mX, mP[1], mP[2]));
   }
-  CADEBUG(printf("Final position: Alpha %f X %f Y %f Z %f SinPhi %f DzDs %f\n", prop.GetAlpha(), mX, mP[0], mP[1], mP[2], mP[3]));
-  return (0);
 }
 
-GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outer, GPUTPCGMPropagator& GPUrestrict() prop)
+GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, GPUTPCGMPropagator& GPUrestrict() prop)
 {
   static constexpr float kSectAngle = 2 * M_PI / 18.f;
   // Note that the coordinate system is rotated by 90 degree swapping X and Y!
@@ -761,9 +731,9 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUr
   float SinPhi = CAMath::Sqrt(1 - mP[2] * mP[2]) * (mP[2] > 0 ? -1 : 1);
   float b = prop.GetBz(prop.GetAlpha(), mX, mP[0], mP[1]);
 
-  float dx = outer ? 1.f : -1.f;
+  float dx = outwards ? 1.f : -1.f;
   const float myRowX = GPUTPCGeometry::Row2X(iRow);
-  // printf("\nAttachMirror sector %d row %d outer %d\n", (int)sector, (int)iRow, (int)outer);
+  // printf("\nAttachMirror sector %d row %d outwards %d\n", (int)sector, (int)iRow, (int)outwards);
   // printf("X %f Y %f Z %f SinPhi %f -->\n", mX, mP[0], mP[1], mP[2]);
   // printf("X %f Y %f Z %f SinPhi %f, dx %f\n", X, Y, Z, SinPhi, dx);
   uint32_t maxTries = 100;
@@ -795,7 +765,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUr
 
     // printf("count %d: At X %f Y %f Z %f SinPhi %f\n", maxTries, mP[2] > 0 ? -Y : Y, mP[2] > 0 ? X : -X, Z, SinPhi);
     float paramX = mP[2] > 0 ? -Y : Y;
-    int32_t step = outer ? 1 : -1;
+    int32_t step = outwards ? 1 : -1;
     int32_t found = 0;
     for (int32_t j = iRow; j >= 0 && j < GPUCA_ROW_COUNT && found < 3; j += step) {
       float rowX = mX + GPUTPCGeometry::Row2X(j) - myRowX;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index ee46b61e8d775..1c084f15874fe 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -150,9 +150,9 @@ class GPUTPCGMTrackParam
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop); // Returns uncorrectedY for later use
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, float Y, float Z);
   // We force to compile these twice, for PropagateLooper and for Fit, for better optimization
-  GPUd() void AttachClustersLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outer, GPUTPCGMPropagator& prop);
-  GPUd() int32_t FollowCircle(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iRow, int32_t iTrack, float toAlpha, float toX, float toY, int32_t toSector, int32_t toRow, bool inFlyDirection);
-  GPUd() void StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outerParam, float alpha);
+  GPUd() void AttachClustersLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, GPUTPCGMPropagator& prop);
+  GPUd() void AttachClustersLooperFollow(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards);
+  GPUd() void StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, float alpha);
   GPUd() void StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, float alpha);
   GPUd() static void PropagateLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t loopIdx);
 
@@ -213,7 +213,6 @@ class GPUTPCGMTrackParam
   }
 
  private:
-  GPUd() bool FollowCircleChk(float lrFactor, float toY, float toX, bool up, bool right);
   GPUd() int32_t initResetT0();
 
   float mX;        // x position
@@ -230,7 +229,7 @@ struct GPUTPCGMLoopData {
   float alpha;
   uint8_t sector;
   uint8_t row;
-  uint8_t outerParam;
+  uint8_t outwards;
 };
 
 GPUdi() int32_t GPUTPCGMTrackParam::initResetT0()

From 8db260e40a9cd9f347292e289469cfe76bac429b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 26 Aug 2025 16:30:03 +0200
Subject: [PATCH 0831/1764] GPU: Add comments for customizable kernel
 parameters

---
 GPU/GPUTracking/kernels.cmake | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 151f0326e00ca..c8ddcd2e9d81d 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -135,17 +135,17 @@ o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishClass2Regression"   "= TPC
 o2_gpu_add_kernel("GPUTPCNNClusterizerKernels, publishDeconvolutionFlags" "= TPCNNCLUSTERFINDER"                                  LB uint8_t sector int8_t dtype int8_t withMC uint32_t batchStart)
 endif()
 
-o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP
-                            NEIGHBOURS_FINDER_UNROLL_GLOBAL
-                            NEIGHBOURS_FINDER_UNROLL_SHARED
-                            TRACKLET_SELECTOR_HITS_REG_SIZE
-                            ALTERNATE_BORDER_SORT
-                            SORT_BEFORE_FIT
-                            NO_ATOMIC_PRECHECK
-                            COMP_GATHER_KERNEL
-                            COMP_GATHER_MODE
-                            SORT_STARTHITS
-                            CF_SCAN_WORKGROUP_SIZE)
+o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP  # Number of neighhbours finder hits to cache in shared memory
+                            NEIGHBOURS_FINDER_UNROLL_GLOBAL # Unroll factor for neighbours finder iterating hits in local memory
+                            NEIGHBOURS_FINDER_UNROLL_SHARED # Fully unroll iteration over neighbours finder hits in shared memory [0/1]
+                            TRACKLET_SELECTOR_HITS_REG_SIZE # Number of hits to cache in shared memory in tracklet selector
+                            ALTERNATE_BORDER_SORT           # Use alternative border sort approach [0/1]
+                            SORT_BEFORE_FIT                 # Sort tracks after length to reduce warp serialization [0/1]
+                            NO_ATOMIC_PRECHECK              # Skip atomic precheck to reduce posterior synchronization [0/1]
+                            COMP_GATHER_KERNEL              # Default kernel to use for Compression Gather Operation [0 - 4]
+                            COMP_GATHER_MODE                # TPC Compression Gather Mode [0 - 3]
+                            SORT_STARTHITS                  # Sort start hits to improve cache locality during tracklet construction [0/1]
+                            CF_SCAN_WORKGROUP_SIZE)         # Work group size to use in clusterizer scan operation
 
-o2_gpu_kernel_add_string_parameter(DEDX_STORAGE_TYPE
-                                   MERGER_INTERPOLATION_ERROR_TYPE)
+o2_gpu_kernel_add_string_parameter(DEDX_STORAGE_TYPE                # Data type to use for intermediate storage of dEdx truncated mean inputs
+                                   MERGER_INTERPOLATION_ERROR_TYPE) # Data type for storing intermediate track residuals for interpolation

From a3ee5beac3242a26a77e9609ef406f2e52ca1302 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 26 Aug 2025 17:59:03 +0200
Subject: [PATCH 0832/1764] GPU TPC: Require minimum NDF for
 mergerInterpolateRejectAlsoOnCurrentPosition to avoid killing some tracks
 when some first clusters are bad

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index b35bc04d7232f..a3158a870e1fb 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -148,7 +148,7 @@ AddOptionRTC(sigBitsCharge, uint8_t, 4, "", 0, "Number of significant bits for T
 AddOptionRTC(sigBitsWidth, uint8_t, 3, "", 0, "Number of significant bits for TPC cluster width in compression mode 1")
 AddOptionRTC(dropLoopers, uint8_t, 0, "", 0, "Drop looping tracks starting from second loop")
 AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation instead of extrapolation for chi2 based cluster rejection")
-AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position")
+AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position starting from NDF > 5")
 AddOptionRTC(mergeCE, uint8_t, 1, "", 0, "Merge tracks accross the central electrode")
 AddOptionRTC(retryRefit, int8_t, 1, "", 0, "Retry refit with seeding errors and without cluster rejection when fit fails (=2 means retry in same kernel, =1 for separate kernel")
 AddOptionRTC(enablePID, int8_t, 1, "", 0, "Enable PID response")
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index 2d612254ba001..0ea888bca8725 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -643,7 +643,7 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow,
     return 0;
   }
 
-  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect || (param.rec.tpc.mergerInterpolateRejectAlsoOnCurrentPosition && rejectChi2 == rejectInterReject), err2Y, err2Z, &param);
+  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect || (param.rec.tpc.mergerInterpolateRejectAlsoOnCurrentPosition && rejectChi2 == rejectInterReject && mT->GetNDF() > 5 ), err2Y, err2Z, &param);
 }
 
 GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict() param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z)

From ea4b83c4329a881d6d4838f60ddda8bbb0a90975 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 26 Aug 2025 18:01:32 +0200
Subject: [PATCH 0833/1764] GPU TPC: Make mergerNonInterpolateRejectMinNDF
 configurable

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 3 ++-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index a3158a870e1fb..37998659e77ef 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -148,7 +148,8 @@ AddOptionRTC(sigBitsCharge, uint8_t, 4, "", 0, "Number of significant bits for T
 AddOptionRTC(sigBitsWidth, uint8_t, 3, "", 0, "Number of significant bits for TPC cluster width in compression mode 1")
 AddOptionRTC(dropLoopers, uint8_t, 0, "", 0, "Drop looping tracks starting from second loop")
 AddOptionRTC(mergerInterpolateErrors, uint8_t, 1, "", 0, "Use interpolation instead of extrapolation for chi2 based cluster rejection")
-AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position starting from NDF > 5")
+AddOptionRTC(mergerInterpolateRejectAlsoOnCurrentPosition, uint8_t, 1, "", 0, "When using mergerInterpolateErrors, reject based on chi2 twice computed with interpolated and current track position starting from NDF > mergerNonInterpolateRejectMinNDF")
+AddOptionRTC(mergerNonInterpolateRejectMinNDF, uint8_t, 5, "", 0, "Minimum NDF of track for non-interpolated reject (both for chi2 and absolute distance)")
 AddOptionRTC(mergeCE, uint8_t, 1, "", 0, "Merge tracks accross the central electrode")
 AddOptionRTC(retryRefit, int8_t, 1, "", 0, "Retry refit with seeding errors and without cluster rejection when fit fails (=2 means retry in same kernel, =1 for separate kernel")
 AddOptionRTC(enablePID, int8_t, 1, "", 0, "Enable PID response")
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index 0ea888bca8725..ef0dcef3b8c02 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -643,7 +643,7 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow,
     return 0;
   }
 
-  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect || (param.rec.tpc.mergerInterpolateRejectAlsoOnCurrentPosition && rejectChi2 == rejectInterReject && mT->GetNDF() > 5 ), err2Y, err2Z, &param);
+  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect || (param.rec.tpc.mergerInterpolateRejectAlsoOnCurrentPosition && rejectChi2 == rejectInterReject && mT->GetNDF() > (int32_t)param.rec.tpc.mergerNonInterpolateRejectMinNDF), err2Y, err2Z, &param);
 }
 
 GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict() param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z)
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 71b1878804893..87d789ad34879 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -225,7 +225,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
       int32_t retValUpd;
       float threshold = 3.f + (lastUpdateX >= 0 ? (CAMath::Abs(mX - lastUpdateX) / 2) : 0.f);
-      if (mNDF > 5 && (CAMath::Abs(yy - mP[0]) > threshold || CAMath::Abs(zz - mP[1]) > threshold)) {
+      if (mNDF > (int32_t)param.rec.tpc.mergerNonInterpolateRejectMinNDF && (CAMath::Abs(yy - mP[0]) > threshold || CAMath::Abs(zz - mP[1]) > threshold)) {
         retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedDistance;
       } else {
         int8_t rejectChi2 = attempt ? 0 : ((param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (refit ? (GPUTPCGMPropagator::rejectInterFill + ((nWays - iWay) & 1)) : 0) : (allowModification && goodRows > 5));

From f420ce6909fd0e60eb55c3b0372a617a30e52633 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 28 Aug 2025 18:04:44 +0200
Subject: [PATCH 0834/1764] GPU TPC: TrackletSelection: Count shared hits from
 outside, to allow more shared hits at inner rows

---
 .../SectorTracker/GPUTPCTrackletSelector.cxx         | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
index 0bf3448bed730..3049136c98f1d 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
@@ -53,10 +53,10 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
     uint32_t nHits = 0;
     const uint32_t minHits = tracker.Param().rec.tpc.minNClustersTrackSeed == -1 ? GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tracklet.Param().QPt() * tracker.Param().qptB5Scaler) : tracker.Param().rec.tpc.minNClustersTrackSeed;
     const uint32_t sharingMinNorm = minHits * tracker.Param().rec.tpc.trackletMinSharedNormFactor;
-    float maxShared = maxSharedFrac * sharingMinNorm;
+    const float maxSharedNorm = maxSharedFrac * sharingMinNorm;
 
     GPUCA_UNROLL(, U(1))
-    for (irow = firstRow; irow <= lastRow && lastRow - irow + nHits >= minHits; irow++) {
+    for (irow = lastRow; irow >= firstRow && irow - firstRow + nHits >= minHits; irow--) {
       calink ih = tracker.TrackletRowHits()[tracklet.FirstHit() + (irow - firstRow)];
       if (ih != CALINK_DEAD_CHANNEL) {
         gap++;
@@ -64,7 +64,7 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
       if (ih != CALINK_INVAL && ih != CALINK_DEAD_CHANNEL) {
         GPUglobalref() const GPUTPCRow& row = tracker.Row(irow);
         const bool own = (tracker.HitWeight(row, ih) <= w);
-        const bool sharedOK = nShared <= (nHits < sharingMinNorm ? maxShared : nHits * maxSharedFrac);
+        const bool sharedOK = nShared <= (nHits < sharingMinNorm ? maxSharedNorm : nHits * maxSharedFrac);
         if (own || sharedOK) { // SG!!!
           gap = 0;
 #pragma GCC diagnostic push
@@ -86,7 +86,7 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
         }
       }
 
-      if (gap > tracker.Param().rec.tpc.trackFollowingMaxRowGap || irow == lastRow) { // store
+      if (gap > tracker.Param().rec.tpc.trackFollowingMaxRowGap || irow == firstRow) { // store
         if (nHits >= minHits) {
           uint32_t nFirstTrackHit = CAMath::AtomicAdd(tracker.NTrackHits(), (uint32_t)nHits);
           if (nFirstTrackHit + nHits > tracker.NMaxTrackHits()) {
@@ -111,11 +111,11 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
 #pragma GCC diagnostic pop
             if constexpr (GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE > 0) {
               if (inShared) {
-                tracker.TrackHits()[nFirstTrackHit + jh] = s.mHits[jh][iThread];
+                tracker.TrackHits()[nFirstTrackHit + nHits - 1 - jh] = s.mHits[jh][iThread];
               }
             }
             if (!inShared) {
-              tracker.TrackHits()[nFirstTrackHit + jh] = trackHits[jh - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
+              tracker.TrackHits()[nFirstTrackHit + nHits - 1 - jh] = trackHits[jh - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
             }
           }
         }

From d555e388a6ba77b49cf9921227431ad06ef04f4e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 09:17:32 +0200
Subject: [PATCH 0835/1764] GPU QA: inputHistogramsOnly inplies noEvents

---
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 7dcabde4e94b6..2e89a4d72c63e 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -198,6 +198,7 @@ int32_t ReadConfiguration(int argc, char** argv)
   }
   if (configStandalone.QA.inputHistogramsOnly) {
     configStandalone.rundEdx = false;
+    configStandalone.noEvents = true;
   }
   if (configStandalone.QA.dumpToROOT) {
     configStandalone.proc.outputSharedClusterMap = true;

From d9d6e3e9b25d8e10ab3099332eb3cd771e5d7b7e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 09:20:52 +0200
Subject: [PATCH 0836/1764] GPU TPC: Better formula for cluster weights

---
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
index 60cc12573be99..2667da4a53977 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
@@ -160,13 +160,11 @@ class GPUTPCTracker : public GPUProcessor
    */
   GPUdi() static int32_t CalculateHitWeight(int32_t NHits, float chi2)
   {
-    const float chi2_suppress = 6.f;
-    float weight = (((float)NHits * (chi2_suppress - chi2 / 500.f)) * (1e9f / chi2_suppress / 160.f));
+    float weight = NHits * (NHits * 2 - 5) * 128 / chi2; // TODO: Add QPt to this formula
     if (weight < 0.f || weight > 2e9f) {
       return 0;
     }
     return ((int32_t)weight);
-    // return( (NHits << 16) + num);
   }
   GPUd() void MaximizeHitWeight(const GPUTPCRow& row, int32_t hitIndex, int32_t weight) { mData.MaximizeHitWeight(row, hitIndex, weight); }
   GPUd() void SetHitWeight(const GPUTPCRow& row, int32_t hitIndex, int32_t weight) { mData.SetHitWeight(row, hitIndex, weight); }

From cd03f1bc059c9a15ad6cb2345719f7aecc61597d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 10 Sep 2025 19:03:11 +0200
Subject: [PATCH 0837/1764] GPU: Improve debug dumps

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx     | 3 +++
 GPU/GPUTracking/Global/GPUChainTrackingDebug.h | 4 ++--
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx  | 4 ++--
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index b2af986ebfac9..17e2a2a27c747 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -269,6 +269,9 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
 #ifndef GPUCA_DETERMINISTIC_MODE
     GPUError("WARNING, deterministicGPUReconstruction needs GPUCA_DETERMINISTIC_MODE for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
 #endif
+    if (mProcessingSettings->debugLevel >= 6 && ((mProcessingSettings->debugMask + 1) & mProcessingSettings->debugMask)) {
+      GPUError("WARNING: debugMask %d - debug output might not be deterministic with intermediate steps missing", mProcessingSettings->debugMask);
+    }
     mProcessingSettings->overrideClusterizerFragmentLen = TPC_MAX_FRAGMENT_LEN_GPU;
     if (GetProcessingSettings().createO2Output > 1) {
       mProcessingSettings->createO2Output = 1;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebug.h b/GPU/GPUTracking/Global/GPUChainTrackingDebug.h
index 6c995f65f3dd3..a0be9d833d5a9 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebug.h
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebug.h
@@ -28,8 +28,8 @@ enum GPUChainTrackingDebugFlags : uint32_t {
   TPCLinks = 1 << 2,
   TPCStartHits = 1 << 3,
   TPCTracklets = 1 << 4,
-  TPCSectorTracks = 1 << 5,
-  TPCHitWeights = 1 << 6,
+  TPCHitWeights = 1 << 5,
+  TPCSectorTracks = 1 << 6,
   TPCMergingRanges = 1 << 7,
   TPCMergingSectorTracks = 1 << 8,
   TPCMergingMatching = 1 << 9,
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 863998079f2cd..0a83bf47f5725 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -51,7 +51,7 @@ void GPUTPCGMMerger::DumpSectorTracks(std::ostream& out) const
       out << "  Track type " << iGlobal << "\n";
       for (int32_t j = mSectorTrackInfoIndex[iSector + NSECTORS * iGlobal]; j < mSectorTrackInfoIndex[iSector + NSECTORS * iGlobal + 1]; j++) {
         const auto& trk = mSectorTrackInfos[j];
-        out << "    Track " << j << ": LocalId " << (iGlobal ? (trk.LocalTrackId() >> 24) : -1) << "/" << (iGlobal ? (trk.LocalTrackId() & 0xFFFFFF) : -1) << " X " << trk.X() << " offsetz " << trk.TOffset() << " A " << trk.Alpha() << " Y " << trk.Y() << " Z " << trk.Z() << " SinPhi " << trk.SinPhi() << " CosPhi " << trk.CosPhi() << " SecPhi " << trk.SecPhi() << " Tgl " << trk.DzDs() << " QPt " << trk.QPt() << "\n";
+        out << "    Track " << j << ": LocalId " << (iGlobal ? (trk.LocalTrackId() >> 24) : -1) << "/" << (iGlobal ? (trk.LocalTrackId() & 0xFFFFFF) : -1) << " NCl " << trk.NClusters() << " X " << trk.X() << " offsetz " << trk.TOffset() << " A " << trk.Alpha() << " Y " << trk.Y() << " Z " << trk.Z() << " SinPhi " << trk.SinPhi() << " CosPhi " << trk.CosPhi() << " SecPhi " << trk.SecPhi() << " Tgl " << trk.DzDs() << " QPt " << trk.QPt() << "\n";
       }
     }
   }
@@ -135,7 +135,7 @@ void GPUTPCGMMerger::DumpMergedBetweenSectors(std::ostream& out) const
 void GPUTPCGMMerger::DumpCollected(std::ostream& out) const
 {
   std::streamsize ss = out.precision();
-  out << std::setprecision(2);
+  out << std::setprecision(6);
   out << "\nTPC Merger Collected Tracks\n";
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mMergedTracks[i];

From ac9728edfda61dc9e6f8ee82f987bccf7d256c51 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 10 Sep 2025 19:03:58 +0200
Subject: [PATCH 0838/1764] GPU TPC: Deterministic (and faster since not
 relying on atomics) linking of extrapolated track segments

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx             | 11 +++++------
 .../SectorTracker/GPUTPCExtrapolationTracking.cxx     |  2 +-
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index acd8331e8bf8f..d1991c8e99646 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -581,7 +581,7 @@ GPUd() void GPUTPCGMMerger::UnpackSectorGlobal(int32_t nBlocks, int32_t nThreads
   uint32_t nTracks = *trk.NTracks();
   for (uint32_t itr = nLocalTracks + iBlock * nThreads + iThread; itr < nTracks; itr += nBlocks * nThreads) {
     sectorTr = &trk.Tracks()[itr];
-    int32_t localId = mTrackIDs[(sectorTr->LocalTrackId() >> 24) * mNMaxSingleSectorTracks + (sectorTr->LocalTrackId() & 0xFFFFFF)];
+    int32_t localId = mTrackIDs[((sectorTr->LocalTrackId() >> 24) & 0x3F) * mNMaxSingleSectorTracks + (sectorTr->LocalTrackId() & 0xFFFFFF)];
     if (localId == -1) {
       continue;
     }
@@ -594,7 +594,7 @@ GPUd() void GPUTPCGMMerger::UnpackSectorGlobal(int32_t nBlocks, int32_t nThreads
     track.SetNextNeighbour(-1);
     track.SetNextSegmentNeighbour(-1);
     track.SetPrevSegmentNeighbour(-1);
-    track.SetLocalTrackId(localId);
+    track.SetLocalTrackId(localId | (sectorTr->LocalTrackId() & 0x40000000));
   }
 }
 
@@ -643,10 +643,9 @@ GPUd() void GPUTPCGMMerger::LinkExtrapolatedTracks(int32_t nBlocks, int32_t nThr
 {
   for (int32_t itr = SectorTrackInfoGlobalFirst(0) + iBlock * nThreads + iThread; itr < SectorTrackInfoGlobalLast(NSECTORS - 1); itr += nThreads * nBlocks) {
     GPUTPCGMSectorTrack& extrapolatedTrack = mSectorTrackInfos[itr];
-    GPUTPCGMSectorTrack& localTrack = mSectorTrackInfos[extrapolatedTrack.LocalTrackId()];
-    if (localTrack.ExtrapolatedTrackId(0) != -1 || !CAMath::AtomicCAS(&localTrack.ExtrapolatedTrackIds()[0], -1, itr)) {
-      localTrack.SetExtrapolatedTrackId(1, itr);
-    }
+    GPUTPCGMSectorTrack& localTrack = mSectorTrackInfos[extrapolatedTrack.LocalTrackId() & 0xFFFFFF];
+    int up = (extrapolatedTrack.LocalTrackId() & 0x40000000) ? 1 : 0;
+    localTrack.SetExtrapolatedTrackId(up, itr);
   }
 }
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
index df998ca7cbb9a..eaaefcb278ffe 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
@@ -112,7 +112,7 @@ GPUd() int32_t GPUTPCExtrapolationTracking::PerformExtrapolationTrackingRun(GPUT
     track.SetParam(tParam.GetParam());
     track.SetNHits(nHits);
     track.SetFirstHitID(hitId);
-    track.SetLocalTrackId((sectorSource.ISector() << 24) | sectorSource.Tracks()[iTrack].LocalTrackId());
+    track.SetLocalTrackId((direction == 1 ? 0x40000000 : 0) | (sectorSource.ISector() << 24) | sectorSource.Tracks()[iTrack].LocalTrackId());
   }
 
   return (nHits >= tracker.Param().rec.tpc.extrapolationTrackingMinHits);

From 96f85dc54a8f6deb4fed9e1f02ef12da614e48c2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 13:14:33 +0200
Subject: [PATCH 0839/1764] GPU TPC: Do not interpolate with too few NDF

---
 GPU/Common/GPUCommonMath.h                    |  5 +++++
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 13 ++++++++++---
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index 372e067b14aff..0ff31899dec0c 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -74,6 +74,11 @@ class GPUCommonMath
   GPUhdni() constexpr static float Sqrt(float x);
   GPUd() static float InvSqrt(float x);
   template <class T>
+  GPUdi() constexpr static T Square(T x)
+  {
+    return x * x;
+  }
+  template <class T>
   GPUhd() constexpr static T Abs(T x);
   GPUd() constexpr static float ASin(float x);
   GPUd() constexpr static float ACos(float x);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index ef0dcef3b8c02..c81497367e8bd 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -653,11 +653,18 @@ GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict
   if (rejectChi2 == rejectInterFill) {
     inter->posY = mP[0];
     inter->posZ = mP[1];
-    inter->errorY = mC[0];
-    inter->errorZ = mC[2];
+    if (mT->NDF() <= 0) {
+      inter->errorY = inter->errorZ = 100.f;
+    } else {
+      inter->errorY = mC[0];
+      inter->errorZ = mC[2];
+    }
   } else if (rejectChi2 == rejectInterReject) {
     float chi2Y, chi2Z;
-    if (mFitInProjections || mT->NDF() <= 0) {
+    if (mT->NDF() <= 0) {
+      chi2Y = CAMath::Square((float)inter->posY - posY) / ((float)inter->errorY + err2Y);
+      chi2Z = CAMath::Square((float)inter->posZ - posZ) / ((float)inter->errorZ + err2Z);
+    } else if (mFitInProjections) {
       const float Iz0 = inter->posY - mP[0];
       const float Iz1 = inter->posZ - mP[1];
       const float Iw0 = 1.f / (mC[0] + (float)inter->errorY);

From 0b08516b10a44e24d75df452d488329f93bf0ed4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 13:14:53 +0200
Subject: [PATCH 0840/1764] GPU TPC: Don't constrain SinPhi between
 inward/outward refits

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 87d789ad34879..e0fb432c7dae6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -99,7 +99,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     prop.SetPropagateBzOnly(param.rec.fitPropagateBzOnly > iWay);
     prop.SetMatLUT((param.rec.useMatLUT && iWay == nWays - 1) ? merger->GetConstantMem()->calibObjects.matLUT : nullptr);
     prop.SetTrack(this, iWay ? prop.GetAlpha() : Alpha);
-    ConstrainSinPhi(prop.GetFitInProjections() ? 0.95f : GPUCA_MAX_SIN_PHI_LOW);
+    ConstrainSinPhi(iWay == 0 ? 0.95f : GPUCA_MAX_SIN_PHI_LOW);
     CADEBUG(printf("Fitting track %d way %d (sector %d, alpha %f)\n", iTrk, iWay, CAMath::Float2IntRn(prop.GetAlpha() / kSectAngle) + (mP[1] < 0 ? 18 : 0), prop.GetAlpha()));
 
     N = 0;

From 603277c23c6b1b75469ae32d5228977bf73f1539 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 13:16:15 +0200
Subject: [PATCH 0841/1764] GPU: Improve some debug messages

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index e0fb432c7dae6..891a4323b7ab1 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -100,7 +100,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     prop.SetMatLUT((param.rec.useMatLUT && iWay == nWays - 1) ? merger->GetConstantMem()->calibObjects.matLUT : nullptr);
     prop.SetTrack(this, iWay ? prop.GetAlpha() : Alpha);
     ConstrainSinPhi(iWay == 0 ? 0.95f : GPUCA_MAX_SIN_PHI_LOW);
-    CADEBUG(printf("Fitting track %d way %d (sector %d, alpha %f)\n", iTrk, iWay, CAMath::Float2IntRn(prop.GetAlpha() / kSectAngle) + (mP[1] < 0 ? 18 : 0), prop.GetAlpha()));
+    CADEBUG(printf("Fitting track %d way %d (sector %d, alpha %f) !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", iTrk, iWay, CAMath::Float2IntRn(prop.GetAlpha() / kSectAngle) + (mP[1] < 0 ? 18 : 0), prop.GetAlpha()));
 
     N = 0;
     lastUpdateX = -1;
@@ -190,7 +190,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         lastSector = cluster.sector;
       }
       // clang-format off
-      CADEBUG(printf("\t%21sPropaga Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Res %8.3f %8.3f   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   Err %d", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[0] - yy, mP[1] - zz, sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retValProp));
+      CADEBUG(printf("\t%21sPropaga Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Res %8.3f %8.3f   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   PErr %d", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[0] - yy, mP[1] - zz, sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retValProp));
       // clang-format on
 
       if (crossCE) {
@@ -265,10 +265,10 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       }
       // clang-format off
       CADEBUG(if (!CheckCov()) GPUError("INVALID COV AFTER UPDATE!!!"));
-      CADEBUG(printf("\t%21sFit     Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f), DzDs %5.2f %16s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   Err %d\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[3], "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retValUpd));
+      CADEBUG(printf("\t%21sFit     Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f), DzDs %5.2f %16s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   FErr %d\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[3], "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retValUpd));
       // clang-format on
 
-      ConstrainSinPhi();
+      ConstrainSinPhi();  // TODO: Limit using ConstrainSinPhi everywhere!
       if (retValUpd == 0) // track is updated
       {
         lastUpdateX = mX;

From b4767b734bb425503450d4fce2fe276a8d52558c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 13:16:48 +0200
Subject: [PATCH 0842/1764] GPU: Remove obsolete code

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 891a4323b7ab1..09b70582ed930 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -229,25 +229,6 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedDistance;
       } else {
         int8_t rejectChi2 = attempt ? 0 : ((param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (refit ? (GPUTPCGMPropagator::rejectInterFill + ((nWays - iWay) & 1)) : 0) : (allowModification && goodRows > 5));
-#if EXTRACT_RESIDUALS == 1
-        if (iWay == nWays - 1 && interpolation.hit[ihit].errorY > (GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
-          const float Iz0 = interpolation.hit[ihit].posY - mP[0];
-          const float Iz1 = interpolation.hit[ihit].posZ - mP[1];
-          float Iw0 = mC[2] + (float)interpolation.hit[ihit].errorZ;
-          float Iw2 = mC[0] + (float)interpolation.hit[ihit].errorY;
-          float Idet1 = 1.f / CAMath::Max(1e-10f, Iw0 * Iw2 - mC[1] * mC[1]);
-          const float Ik00 = (mC[0] * Iw0 + mC[1] * mC[1]) * Idet1;
-          const float Ik01 = (mC[0] * mC[1] + mC[1] * Iw2) * Idet1;
-          const float Ik10 = (mC[1] * Iw0 + mC[2] * mC[1]) * Idet1;
-          const float Ik11 = (mC[1] * mC[1] + mC[2] * Iw2) * Idet1;
-          const float ImP0 = mP[0] + Ik00 * Iz0 + Ik01 * Iz1;
-          const float ImP1 = mP[1] + Ik10 * Iz0 + Ik11 * Iz1;
-          const float ImC0 = mC[0] - Ik00 * mC[0] + Ik01 * mC[1];
-          const float ImC2 = mC[2] - Ik10 * mC[1] + Ik11 * mC[2];
-          auto& tup = GPUROOTDump<TNtuple>::get("clusterres", "row:clX:clY:clZ:angle:trkX:trkY:trkZ:trkSinPhi:trkDzDs:trkQPt:trkSigmaY2:trkSigmaZ2trkSigmaQPt2");
-          tup.Fill((float)cluster.row, xx, yy, zz, clAlpha, mX, ImP0, ImP1, mP[2], mP[3], mP[4], ImC0, ImC2, mC[14]);
-        }
-#endif
         GPUCA_DEBUG_STREAMER_CHECK(GPUTPCGMPropagator::DebugStreamerVals debugVals;);
         if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowModification
           retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedEdge;

From 87f621ce706f1eb51c99e4eb2b8c7c4dc0315519 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 13:31:32 +0200
Subject: [PATCH 0843/1764] GPU TPC: Fix setting of FitInProjection and
 PropagateBzOnly

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 09b70582ed930..43f6ca569057d 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -95,8 +95,8 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
     ResetCovariance();
     prop.SetSeedingErrors(!(refit && attempt == 0));
-    prop.SetFitInProjections(param.rec.fitInProjections == -1 ? (iWay != 0) : param.rec.fitInProjections);
-    prop.SetPropagateBzOnly(param.rec.fitPropagateBzOnly > iWay);
+    prop.SetFitInProjections(param.rec.fitInProjections == -1 ? (iWay == 0) : param.rec.fitInProjections);
+    prop.SetPropagateBzOnly(iWay < param.rec.fitPropagateBzOnly);
     prop.SetMatLUT((param.rec.useMatLUT && iWay == nWays - 1) ? merger->GetConstantMem()->calibObjects.matLUT : nullptr);
     prop.SetTrack(this, iWay ? prop.GetAlpha() : Alpha);
     ConstrainSinPhi(iWay == 0 ? 0.95f : GPUCA_MAX_SIN_PHI_LOW);

From c11114e5ea657ae461185ebf71fc2274aeb2e8f8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 13:31:56 +0200
Subject: [PATCH 0844/1764] GPU TPC: Fix applying tpc.trackFitCovLimit

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 43f6ca569057d..d687557b2a570 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -211,10 +211,10 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       }
 
       const bool sinPhiErr = mNDF > 0 && CAMath::Abs(prop.GetSinPhi0()) >= maxSinForUpdate;
+      if (mNDF >= 0 && (mC[0] > param.rec.tpc.trackFitCovLimit || mC[2] > param.rec.tpc.trackFitCovLimit)) {
+        break;
+      }
       if (retValProp || sinPhiErr) {
-        if (mC[0] > param.rec.tpc.trackFitCovLimit || mC[2] > param.rec.tpc.trackFitCovLimit) {
-          break;
-        }
         MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagHighIncl);
         nMissed2++;
         NTolerated++;

From 773fa1ebe0d18214a7a96a9c4ba29a6813f14130 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 29 Aug 2025 14:55:22 +0200
Subject: [PATCH 0845/1764] GPU TPC: Do Interpolation rejection in
 TrackParam.cxx

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 18 +++-------
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.h   | 10 ++----
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 33 ++++++++++++++-----
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |  2 +-
 5 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index d1991c8e99646..40932ec502a4b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -542,7 +542,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
         return way == 0;
       }
       trk.ConstrainSinPhi();
-      if (prop.Update(y, z, row, Param(), flags & GPUTPCGMMergedTrackHit::clustererAndSharedFlags, 0, nullptr, false, sector, -1.f, 0.f, 0.f)) { // TODO: Use correct time / avgCharge
+      if (prop.Update(y, z, row, Param(), flags & GPUTPCGMMergedTrackHit::clustererAndSharedFlags, 0, false, sector, -1.f, 0.f, 0.f)) { // TODO: Use correct time / avgCharge
         return way == 0;
       }
       trk.ConstrainSinPhi();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index c81497367e8bd..a0cfd27c90571 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -608,24 +608,16 @@ GPUd() float GPUTPCGMPropagator::PredictChi2(float posY, float posZ, float err2Y
   }
 }
 
-GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow, const GPUParam& GPUrestrict() param, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, bool refit, int8_t sector, float time, float avgInvCharge, float invCharge GPUCA_DEBUG_STREAMER_CHECK(, DebugStreamerVals* debugVals))
+GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow, const GPUParam& GPUrestrict() param, int16_t clusterState, int8_t rejectChi2, bool refit, int8_t sector, float time, float avgInvCharge, float invCharge)
 {
   float err2Y, err2Z;
   GetErr2(err2Y, err2Z, param, posZ, iRow, clusterState, sector, time, avgInvCharge, invCharge);
-  GPUCA_DEBUG_STREAMER_CHECK(if (debugVals) { debugVals->err2Y = err2Y; debugVals->err2Z = err2Z; });
 
-  if (rejectChi2 >= rejectInterFill) {
-    if (rejectChi2 == rejectInterReject && inter->errorY < (GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
-      rejectChi2 = rejectDirect;
-    } else {
-      int32_t retVal = InterpolateReject(param, posY, posZ, clusterState, rejectChi2, inter, err2Y, err2Z);
-      GPUCA_DEBUG_STREAMER_CHECK(if (debugVals) { debugVals->retVal = retVal; });
-      if (retVal) {
-        return retVal;
-      }
-    }
-  }
+  return Update(posY, posZ, iRow, param, clusterState, rejectChi2, refit, err2Y, err2Z);
+}
 
+GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow, const GPUParam& GPUrestrict() param, int16_t clusterState, int8_t rejectChi2, bool refit, float err2Y, float err2Z)
+{
   if (mT->NDF() == -5) { // first measurement: no need to filter, as the result is known in advance. just set it.
     mT->ResetCovariance();
     float* mC = mT->Cov();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
index a6e2cbc6deb3b..02ef8b293a4b7 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
@@ -72,11 +72,6 @@ class GPUTPCGMPropagator
     float radLenInv, DLMax, EP2, sigmadE2, k22, k33, k43, k44; // precalculated values for MS and EnergyLoss correction
   };
 
-  struct DebugStreamerVals {
-    int32_t retVal = -100;
-    float err2Y = -1e6f, err2Z = -1e6f;
-  };
-
   GPUd() void SetMaterial(float radLen, float rho);
   GPUd() void SetMaterialTPC() { SetMaterial(28811.7f, 1.025e-3f); }
 
@@ -109,12 +104,13 @@ class GPUTPCGMPropagator
 
   GPUd() int32_t PropagateToXAlphaBz(float posX, float posAlpha, bool inFlyDirection);
 
-  GPUd() int32_t Update(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, bool refit, int8_t sideC, float time, float avgInvCharge, float invCharge GPUCA_DEBUG_STREAMER_CHECK(, DebugStreamerVals* debugVals = nullptr));
+  GPUd() int32_t Update(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t rejectChi2, bool refit, int8_t sector, float time, float avgInvCharge, float invCharge);
+  GPUd() int32_t Update(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t rejectChi2, bool refit, float err2Y, float err2Z);
   GPUd() int32_t Update(float posY, float posZ, int16_t clusterState, bool rejectChi2, float err2Y, float err2Z, const GPUParam* param = nullptr);
   GPUd() int32_t InterpolateReject(const GPUParam& param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z);
   GPUd() float PredictChi2(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t sideC, float time, float avgCharge, float charge) const;
   GPUd() float PredictChi2(float posY, float posZ, float err2Y, float err2Z) const;
-  GPUd() int32_t RejectCluster(float chiY, float chiZ, uint8_t clusterState)
+  GPUd() static int32_t RejectCluster(float chiY, float chiZ, uint8_t clusterState)
   {
     if (chiY > 9.f || chiZ > 9.f) { // TODO: Check how a track can have chi2/ncl > 18
       return 2;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index d687557b2a570..b96e133f696b2 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -229,19 +229,34 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedDistance;
       } else {
         int8_t rejectChi2 = attempt ? 0 : ((param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (refit ? (GPUTPCGMPropagator::rejectInterFill + ((nWays - iWay) & 1)) : 0) : (allowModification && goodRows > 5));
-        GPUCA_DEBUG_STREAMER_CHECK(GPUTPCGMPropagator::DebugStreamerVals debugVals;);
-        if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowModification
+
+        float err2Y, err2Z;
+        const float time = merger->GetConstantMem()->ioPtrs.clustersNative ? merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].getTime() : -1.f;
+        const float invSqrtCharge = merger->GetConstantMem()->ioPtrs.clustersNative ? CAMath::InvSqrt(merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].qMax) : 0.f;
+        const float invCharge = merger->GetConstantMem()->ioPtrs.clustersNative ? (1.f / merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].qMax) : 0.f;
+        float invAvgCharge = (sumInvSqrtCharge += invSqrtCharge) / ++nAvgCharge;
+        invAvgCharge *= invAvgCharge;
+
+        prop.GetErr2(err2Y, err2Z, param, zz, cluster.row, clusterState, cluster.sector, time, invAvgCharge, invCharge);
+
+        int retValInt = 0;
+        if (rejectChi2 >= GPUTPCGMPropagator::rejectInterFill) {
+          if (rejectChi2 == GPUTPCGMPropagator::rejectInterReject && interpolation.hit[ihit].errorY < (GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
+            rejectChi2 = GPUTPCGMPropagator::rejectDirect;
+          } else {
+            retValInt = prop.InterpolateReject(param, yy, zz, clusterState, rejectChi2, &interpolation.hit[ihit], err2Y, err2Z);
+          }
+        }
+
+        if (retValInt) {
+          retValUpd = retValInt;
+        } else if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowModification
           retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedEdge;
         } else {
-          const float time = merger->GetConstantMem()->ioPtrs.clustersNative ? merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].getTime() : -1.f;
-          const float invSqrtCharge = merger->GetConstantMem()->ioPtrs.clustersNative ? CAMath::InvSqrt(merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].qMax) : 0.f;
-          const float invCharge = merger->GetConstantMem()->ioPtrs.clustersNative ? (1.f / merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].qMax) : 0.f;
-          float invAvgCharge = (sumInvSqrtCharge += invSqrtCharge) / ++nAvgCharge;
-          invAvgCharge *= invAvgCharge;
-          retValUpd = prop.Update(yy, zz, cluster.row, param, clusterState, rejectChi2, &interpolation.hit[ihit], refit, cluster.sector, time, invAvgCharge, invCharge GPUCA_DEBUG_STREAMER_CHECK(, &debugVals));
+          retValUpd = prop.Update(yy, zz, cluster.row, param, clusterState, rejectChi2, refit, err2Y, err2Z);
         }
         GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamUpdateTrack, iTrk)) {
-          merger->DebugStreamerUpdate(iTrk, ihit, xx, yy, zz, cluster, merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num], *this, prop, interpolation.hit[ihit], rejectChi2, refit, retValUpd, sumInvSqrtCharge / nAvgCharge * sumInvSqrtCharge / nAvgCharge, yy, zz, clusterState, debugVals.retVal, debugVals.err2Y, debugVals.err2Z);
+          merger->DebugStreamerUpdate(iTrk, ihit, xx, yy, zz, cluster, merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num], *this, prop, interpolation.hit[ihit], rejectChi2, refit, retValUpd, sumInvSqrtCharge / nAvgCharge * sumInvSqrtCharge / nAvgCharge, yy, zz, clusterState, retValInt, err2Y, err2Z);
         });
       }
       // clang-format off
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index 27426cf0ff6a7..4f9d848f2b703 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -346,7 +346,7 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
       }
       CADEBUG(printf("\t%21sPropaga Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f)   ---   Res %8.3f %8.3f   ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", "", prop.GetAlpha(), x, trk.Par()[0], trk.Par()[1], trk.Par()[4], prop.GetQPt0(), trk.Par()[2], prop.GetSinPhi0(), trk.Par()[0] - y, trk.Par()[1] - z, sqrtf(trk.Cov()[0]), sqrtf(trk.Cov()[2]), sqrtf(trk.Cov()[5]), sqrtf(trk.Cov()[14]), trk.Cov()[10]));
       lastSector = sector;
-      if (prop.Update(y, z, row, *mPparam, clusterState, 0, nullptr, true, sector, time, invAvgCharge, invCharge)) {
+      if (prop.Update(y, z, row, *mPparam, clusterState, 0, true, sector, time, invAvgCharge, invCharge)) {
         IgnoreErrors(trk.GetSinPhi());
         return -3;
       }

From 0e754194f43f9d558e1c482c4aed45ebeb0367e9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 30 Aug 2025 08:59:53 +0200
Subject: [PATCH 0846/1764] GPU: Temporarily disable with without projections
 since it gives worse results

---
 GPU/GPUTracking/Base/GPUParam.cxx             |  3 --
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 42 ++++++++++---------
 3 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index 649682939ab39..cc3c6a8bb9140 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -154,9 +154,6 @@ void GPUParam::SetDefaults(const GPUSettingsGRP* g, const GPUSettingsRec* r, con
   SetDefaults(g->solenoidBzNominalGPU, g->constBz);
   if (r) {
     rec = *r;
-    if (rec.fitPropagateBzOnly == -1) {
-      rec.fitPropagateBzOnly = rec.tpc.nWays - 1;
-    }
   }
   UpdateSettings(g, p, w);
 }
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 37998659e77ef..d98008461cfce 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -133,7 +133,7 @@ AddOptionRTC(cfMinSplitNum, uint8_t, 1, "", 0, "Minimum number of split charges
 AddOptionRTC(cfNoiseSuppressionEpsilon, uint8_t, 10, "", 0, "Cluster Finder: Difference between peak and charge for the charge to count as a minima during noise suppression")
 AddOptionRTC(cfNoiseSuppressionEpsilonRelative, uint8_t, 76, "", 0, "Cluster Finder: Difference between peak and charge for the charge to count as a minima during noise suppression, relative as fraction of 255")
 AddOptionRTC(cfEdgeTwoPads, uint8_t, 0, "", 0, "Flag clusters with peak on the 2 pads closes to the sector edge as edge cluster")
-AddOptionRTC(nWays, uint8_t, 3, "", 0, "Do N fit passes in final fit of merger")
+AddOptionRTC(nWays, uint8_t, 3, "", 0, "Do N fit passes in final fit of merger (must be odd to end with inward fit)")
 AddOptionRTC(trackFitRejectMode, int8_t, 5, "", 0, "0: no limit on rejection or missed hits, >0: break after n rejected hits, <0: reject at max -n hits")
 AddOptionRTC(rejectIFCLowRadiusCluster, uint8_t, 1, "", 0, "Reject clusters that get the IFC mask error during refit")
 AddOptionRTC(dEdxTruncLow, uint8_t, 2, "", 0, "Low truncation threshold, fraction of 128")
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index b96e133f696b2..3cfa37e34c22d 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -85,26 +85,28 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     float sumInvSqrtCharge = 0.f;
     int32_t nAvgCharge = 0;
 
-    if (iWay && ((nWays - iWay) & 1) == 1) {
+    if (iWay && (iWay & 1) == 0) {
       StoreOuter(&track.OuterParam(), prop.GetAlpha());
     }
 
     int32_t resetT0 = initResetT0();
     const bool refit = (nWays == 1 || iWay >= 1);
+    const bool finalOutInFit = iWay + 2 >= nWays;
+    const bool finalFit = iWay == nWays - 1;
     const float maxSinForUpdate = CAMath::Sin(70.f * kDeg2Rad);
 
     ResetCovariance();
     prop.SetSeedingErrors(!(refit && attempt == 0));
-    prop.SetFitInProjections(param.rec.fitInProjections == -1 ? (iWay == 0) : param.rec.fitInProjections);
-    prop.SetPropagateBzOnly(iWay < param.rec.fitPropagateBzOnly);
-    prop.SetMatLUT((param.rec.useMatLUT && iWay == nWays - 1) ? merger->GetConstantMem()->calibObjects.matLUT : nullptr);
+    prop.SetFitInProjections(true); // param.rec.fitInProjections == -1 ? (iWay == 0) : param.rec.fitInProjections); // TODO: Reenable once fixed
+    prop.SetPropagateBzOnly(param.rec.fitPropagateBzOnly == -1 ? !finalFit : param.rec.fitPropagateBzOnly);
+    prop.SetMatLUT((param.rec.useMatLUT && finalFit) ? merger->GetConstantMem()->calibObjects.matLUT : nullptr);
     prop.SetTrack(this, iWay ? prop.GetAlpha() : Alpha);
     ConstrainSinPhi(iWay == 0 ? 0.95f : GPUCA_MAX_SIN_PHI_LOW);
     CADEBUG(printf("Fitting track %d way %d (sector %d, alpha %f) !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", iTrk, iWay, CAMath::Float2IntRn(prop.GetAlpha() / kSectAngle) + (mP[1] < 0 ? 18 : 0), prop.GetAlpha()));
 
     N = 0;
     lastUpdateX = -1;
-    const bool inFlyDirection = !((iWay ^ nWays) & 1);
+    const bool inFlyDirection = iWay & 1;
     const int32_t wayDirection = (iWay & 1) ? -1 : 1;
 
     int32_t goodRows = 0;
@@ -116,13 +118,13 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
       if ((param.rec.tpc.trackFitRejectMode > 0 && nMissed >= param.rec.tpc.trackFitRejectMode) || nMissed2 >= param.rec.tpc.trackFitMaxRowMissedHard || clusters[ihit].state & GPUTPCGMMergedTrackHit::flagReject) {
         CADEBUG(printf("\tSkipping hit, %d hits rejected, flag %X\n", nMissed, (int32_t)clusters[ihit].state));
-        if (iWay + 2 >= nWays && !(clusters[ihit].state & GPUTPCGMMergedTrackHit::flagReject)) {
+        if (finalOutInFit && !(clusters[ihit].state & GPUTPCGMMergedTrackHit::flagReject)) {
           clusters[ihit].state |= GPUTPCGMMergedTrackHit::flagRejectErr;
         }
         continue;
       }
 
-      const bool allowModification = refit && (iWay == 0 || (((nWays - iWay) & 1) ? (ihit >= CAMath::Min(maxN / 2, 30)) : (ihit <= CAMath::Max(maxN / 2, maxN - 30))));
+      const bool allowChangeClusters = finalOutInFit && (nWays == 1 || ((iWay & 1) ? (ihit <= CAMath::Max(maxN / 2, maxN - 30)) : (ihit >= CAMath::Min(maxN / 2, 30))));
 
       int32_t ihitMergeFirst = ihit;
       uint8_t clusterState = clusters[ihit].state;
@@ -137,7 +139,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       // CADEBUG(if ((uint32_t)merger->GetTrackingChain()->mIOPtrs.nMCLabelsTPC > clusters[ihit].num))
       // CADEBUG({printf(" MC:"); for (int32_t i = 0; i < 3; i++) {int32_t mcId = merger->GetTrackingChain()->mIOPtrs.mcLabelsTPC[clusters[ihit].num].fClusterID[i].fMCID; if (mcId >= 0) printf(" %d", mcId); } } printf("\n"));
       // clang-format on
-      if (MergeDoubleRowClusters(ihit, wayDirection, clusters, merger, prop, xx, yy, zz, maxN, clAlpha, clusterState, allowModification) == -1) {
+      if (MergeDoubleRowClusters(ihit, wayDirection, clusters, merger, prop, xx, yy, zz, maxN, clAlpha, clusterState, allowChangeClusters) == -1) {
         nMissed++;
         nMissed2++;
         continue;
@@ -156,9 +158,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       // clang-format off
       CADEBUG(printf("\tSector %2d %11sTrack   Alpha %8.3f %s, X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f) %28s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f\n", (int32_t)cluster.sector, "", prop.GetAlpha(), (CAMath::Abs(prop.GetAlpha() - clAlpha) < 0.01 ? "   " : " R!"), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10]));
       // clang-format on
-      if (allowModification && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
+      if (allowChangeClusters && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
-          bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && iWay == nWays - 1 && CAMath::Abs(cluster.row - lastRow) == 2;
+          bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && finalFit && CAMath::Abs(cluster.row - lastRow) == 2;
           dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, track.Leg() == 0, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
           if (dodEdx) {
             dEdx.fillSubThreshold(lastRow - wayDirection);
@@ -206,7 +208,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       }
 
       float uncorrectedY = -1e6f;
-      if (allowModification) {
+      if (allowChangeClusters) {
         uncorrectedY = AttachClusters(merger, cluster.sector, cluster.row, iTrk, track.Leg() == 0, prop);
       }
 
@@ -228,7 +230,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       if (mNDF > (int32_t)param.rec.tpc.mergerNonInterpolateRejectMinNDF && (CAMath::Abs(yy - mP[0]) > threshold || CAMath::Abs(zz - mP[1]) > threshold)) {
         retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedDistance;
       } else {
-        int8_t rejectChi2 = attempt ? 0 : ((param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (refit ? (GPUTPCGMPropagator::rejectInterFill + ((nWays - iWay) & 1)) : 0) : (allowModification && goodRows > 5));
+        int8_t rejectChi2 = attempt                                                                              ? 0                                                                         // In second attempt, we do not reject
+                            : (param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (finalOutInFit ? (GPUTPCGMPropagator::rejectInterFill + !(iWay & 1)) : 0) // reject via interpolation
+                                                                                                                 : (allowChangeClusters && goodRows > 5);                                    // normal rejection during the fit
 
         float err2Y, err2Z;
         const float time = merger->GetConstantMem()->ioPtrs.clustersNative ? merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].getTime() : -1.f;
@@ -250,7 +254,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
         if (retValInt) {
           retValUpd = retValInt;
-        } else if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowModification
+        } else if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowChangeClusters
           retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedEdge;
         } else {
           retValUpd = prop.Update(yy, zz, cluster.row, param, clusterState, rejectChi2, refit, err2Y, err2Z);
@@ -280,7 +284,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           prop.SetTrack(this, prop.GetAlpha());
         }
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
-          if (param.dodEdxEnabled && iWay == nWays - 1) { // TODO: Costimize flag to remove, and option to remove double-clusters
+          if (param.dodEdxEnabled && finalFit) { // TODO: Costimize flag to remove, and option to remove double-clusters
             bool acc = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMask) == 0, accAlt = (clusterState & param.rec.tpc.dEdxClusterRejectionFlagMaskAlt) == 0;
             if (acc || accAlt) {
               float qtot = 0, qmax = 0, pad = 0, relTime = 0;
@@ -308,9 +312,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
           }
         }
       } else if (retValUpd >= GPUTPCGMPropagator::updateErrorClusterRejected) { // cluster far away form the track
-        if (allowModification) {
+        if (allowChangeClusters) {
           MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagRejectDistance);
-        } else if (iWay == nWays - 1) {
+        } else if (finalFit) {
           MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagRejectErr);
         }
         nMissed++;
@@ -319,11 +323,11 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         break; // bad chi2 for the whole track, stop the fit
       }
     }
-    if (nWays - iWay <= 2 && !(merger->Param().rec.tpc.disableRefitAttachment & 4) && lastRow != 255 && lastSector != 255) {
+    if (finalOutInFit && !(merger->Param().rec.tpc.disableRefitAttachment & 4) && lastRow != 255 && lastSector != 255) {
       StoreLoopPropagation(merger, lastSector, lastRow, iTrk, lastRow > clusters[(iWay & 1) ? (maxN - 1) : 0].row, prop.GetAlpha());
       CADEBUG(printf("\t\tSTORING %d lastRow %d row %d out %d\n", iTrk, (int)lastRow, (int)clusters[(iWay & 1) ? (maxN - 1) : 0].row, lastRow > clusters[(iWay & 1) ? (maxN - 1) : 0].row));
     }
-    if (((nWays - iWay) & 1) && (iWay != nWays - 1) && !track.CCE() && !track.Looper()) {
+    if (!(iWay & 1) && !finalFit && !track.CCE() && !track.Looper()) {
       ShiftZ(clusters, merger, maxN);
     }
   }
@@ -340,8 +344,6 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     return false;
   }
 
-  // TODO: we have looping tracks here with 0 accepted clusters in the primary leg. In that case we should refit the track using only the primary leg.
-
   if (param.par.dodEdx && param.dodEdxEnabled) {
     dEdx.computedEdx(merger->MergedTracksdEdx()[iTrk], param);
     if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMask) != GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMaskAlt)) {

From b4e3e791857d76235880f568ef0f4d3ebf7a72fa Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 30 Aug 2025 16:38:36 +0200
Subject: [PATCH 0847/1764] GPU: Improve some debug messages

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  4 +-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 11 +--
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.h   |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 72 ++++++++++---------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |  4 +-
 5 files changed, 51 insertions(+), 42 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index b69d0941d9375..430cad041ebe5 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -253,8 +253,8 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("nWay setting musst be odd number!");
     return false;
   }
-  if (param().rec.tpc.mergerInterpolateErrors && param().rec.tpc.nWays == 1) {
-    GPUError("Cannot do error interpolation with NWays = 1!");
+  if (param().rec.tpc.mergerInterpolateErrors && param().rec.tpc.nWays < 3) {
+    GPUError("Cannot do error interpolation with NWays < 3!");
     return false;
   }
   if (param().continuousMaxTimeBin > (int32_t)GPUSettings::TPC_MAX_TF_TIME_BIN) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index a0cfd27c90571..e91426b51e5c4 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -635,10 +635,10 @@ GPUd() int32_t GPUTPCGMPropagator::Update(float posY, float posZ, int32_t iRow,
     return 0;
   }
 
-  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect || (param.rec.tpc.mergerInterpolateRejectAlsoOnCurrentPosition && rejectChi2 == rejectInterReject && mT->GetNDF() > (int32_t)param.rec.tpc.mergerNonInterpolateRejectMinNDF), err2Y, err2Z, &param);
+  return Update(posY, posZ, clusterState, rejectChi2 == rejectDirect, err2Y, err2Z, &param);
 }
 
-GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict() param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z)
+GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict() param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z, float deltaZ)
 {
   float* GPUrestrict() mC = mT->Cov();
   float* GPUrestrict() mP = mT->Par();
@@ -655,10 +655,10 @@ GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict
     float chi2Y, chi2Z;
     if (mT->NDF() <= 0) {
       chi2Y = CAMath::Square((float)inter->posY - posY) / ((float)inter->errorY + err2Y);
-      chi2Z = CAMath::Square((float)inter->posZ - posZ) / ((float)inter->errorZ + err2Z);
+      chi2Z = CAMath::Square((float)inter->posZ + deltaZ - posZ) / ((float)inter->errorZ + err2Z);
     } else if (mFitInProjections) {
       const float Iz0 = inter->posY - mP[0];
-      const float Iz1 = inter->posZ - mP[1];
+      const float Iz1 = inter->posZ + deltaZ - mP[1];
       const float Iw0 = 1.f / (mC[0] + (float)inter->errorY);
       const float Iw2 = 1.f / (mC[2] + (float)inter->errorZ);
       const float Ik00 = mC[0] * Iw0;
@@ -676,7 +676,7 @@ GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict
       chi2Z = Jw2 * Jz1 * Jz1;
     } else {
       const float Iz0 = inter->posY - mP[0];
-      const float Iz1 = inter->posZ - mP[1];
+      const float Iz1 = inter->posZ + deltaZ - mP[1];
       float Iw0 = mC[2] + (float)inter->errorZ;
       float Iw2 = mC[0] + (float)inter->errorY;
       float Idet = CAMath::Max(1e-10f, Iw0 * Iw2 - mC[1] * mC[1]);
@@ -706,6 +706,7 @@ GPUd() int32_t GPUTPCGMPropagator::InterpolateReject(const GPUParam& GPUrestrict
       chi2Z = CAMath::Abs((Jw1 * Jz0 + Jw2 * Jz1) * Jz1);
     }
     if (RejectCluster(chi2Y * param.rec.tpc.clusterRejectChi2TolleranceY, chi2Z * param.rec.tpc.clusterRejectChi2TolleranceZ, clusterState)) { // TODO: Relative Pt resolution decreases slightly, why?
+      // printf("Reject Cluster chiy2 %f chiz2 %f (Pos Y: %f - %f %f ; Pos Z: %f - %f %f)\n", chi2Y, chi2Z, posY, mP[0], (float)inter->posY, posZ, mP[1], (float)inter->posZ + deltaZ);
       return updateErrorClusterRejectedInInterpolation;
     }
   }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
index 02ef8b293a4b7..47e6c870dac25 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
@@ -107,7 +107,7 @@ class GPUTPCGMPropagator
   GPUd() int32_t Update(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t rejectChi2, bool refit, int8_t sector, float time, float avgInvCharge, float invCharge);
   GPUd() int32_t Update(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t rejectChi2, bool refit, float err2Y, float err2Z);
   GPUd() int32_t Update(float posY, float posZ, int16_t clusterState, bool rejectChi2, float err2Y, float err2Z, const GPUParam* param = nullptr);
-  GPUd() int32_t InterpolateReject(const GPUParam& param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z);
+  GPUd() int32_t InterpolateReject(const GPUParam& param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z, float deltaZ);
   GPUd() float PredictChi2(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t sideC, float time, float avgCharge, float charge) const;
   GPUd() float PredictChi2(float posY, float posZ, float err2Y, float err2Z) const;
   GPUd() static int32_t RejectCluster(float chiY, float chiZ, uint8_t clusterState)
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 3cfa37e34c22d..d865a3b6899b4 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -79,6 +79,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
   float lastUpdateX = -1.f;
   uint8_t lastRow = 255;
   uint8_t lastSector = 255;
+  float deltaZ = 0.f;
 
   for (int32_t iWay = 0; iWay < nWays; iWay++) {
     int32_t nMissed = 0, nMissed2 = 0;
@@ -117,7 +118,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       }
 
       if ((param.rec.tpc.trackFitRejectMode > 0 && nMissed >= param.rec.tpc.trackFitRejectMode) || nMissed2 >= param.rec.tpc.trackFitMaxRowMissedHard || clusters[ihit].state & GPUTPCGMMergedTrackHit::flagReject) {
-        CADEBUG(printf("\tSkipping hit, %d hits rejected, flag %X\n", nMissed, (int32_t)clusters[ihit].state));
+        CADEBUG(printf("\tSkipping hit %d, %d hits rejected, flag %X\n", ihit, nMissed, (int32_t)clusters[ihit].state));
         if (finalOutInFit && !(clusters[ihit].state & GPUTPCGMMergedTrackHit::flagReject)) {
           clusters[ihit].state |= GPUTPCGMMergedTrackHit::flagRejectErr;
         }
@@ -225,14 +226,25 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       }
       CADEBUG(printf("\n"));
 
-      int32_t retValUpd;
+      int32_t retValUpd = 0, retValInt = 0;
       float threshold = 3.f + (lastUpdateX >= 0 ? (CAMath::Abs(mX - lastUpdateX) / 2) : 0.f);
       if (mNDF > (int32_t)param.rec.tpc.mergerNonInterpolateRejectMinNDF && (CAMath::Abs(yy - mP[0]) > threshold || CAMath::Abs(zz - mP[1]) > threshold)) {
         retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedDistance;
       } else {
-        int8_t rejectChi2 = attempt                                                                              ? 0                                                                         // In second attempt, we do not reject
-                            : (param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) ? (finalOutInFit ? (GPUTPCGMPropagator::rejectInterFill + !(iWay & 1)) : 0) // reject via interpolation
-                                                                                                                 : (allowChangeClusters && goodRows > 5);                                    // normal rejection during the fit
+        int8_t rejectChi2 = 0;
+        if (attempt == 0) {
+          if (param.rec.tpc.mergerInterpolateErrors && CAMath::Abs(ihit - ihitMergeFirst) <= 1) {
+            if (iWay == nWays - 3) {
+              rejectChi2 = GPUTPCGMPropagator::rejectInterFill;
+            } else if (iWay == nWays - 2) {
+              rejectChi2 = GPUTPCGMPropagator::rejectInterReject;
+            } else if (iWay == nWays - 1) {
+              rejectChi2 = (param.rec.tpc.mergerInterpolateRejectAlsoOnCurrentPosition && GetNDF() > (int32_t)param.rec.tpc.mergerNonInterpolateRejectMinNDF) ? GPUTPCGMPropagator::rejectDirect : 0;
+            }
+          } else {
+            rejectChi2 = allowChangeClusters && goodRows > 5;
+          }
+        }
 
         float err2Y, err2Z;
         const float time = merger->GetConstantMem()->ioPtrs.clustersNative ? merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].getTime() : -1.f;
@@ -243,18 +255,15 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
 
         prop.GetErr2(err2Y, err2Z, param, zz, cluster.row, clusterState, cluster.sector, time, invAvgCharge, invCharge);
 
-        int retValInt = 0;
         if (rejectChi2 >= GPUTPCGMPropagator::rejectInterFill) {
           if (rejectChi2 == GPUTPCGMPropagator::rejectInterReject && interpolation.hit[ihit].errorY < (GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE_A)0) {
             rejectChi2 = GPUTPCGMPropagator::rejectDirect;
           } else {
-            retValInt = prop.InterpolateReject(param, yy, zz, clusterState, rejectChi2, &interpolation.hit[ihit], err2Y, err2Z);
+            retValInt = prop.InterpolateReject(param, yy, zz, clusterState, rejectChi2, &interpolation.hit[ihit], err2Y, err2Z, deltaZ);
           }
         }
 
-        if (retValInt) {
-          retValUpd = retValInt;
-        } else if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowChangeClusters
+        if (param.rec.tpc.rejectEdgeClustersInTrackFit && uncorrectedY > -1e6f && param.rejectEdgeClusterByY(uncorrectedY, cluster.row, CAMath::Sqrt(mC[0]))) { // uncorrectedY > -1e6f implies allowChangeClusters
           retValUpd = GPUTPCGMPropagator::updateErrorClusterRejectedEdge;
         } else {
           retValUpd = prop.Update(yy, zz, cluster.row, param, clusterState, rejectChi2, refit, err2Y, err2Z);
@@ -265,11 +274,11 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       }
       // clang-format off
       CADEBUG(if (!CheckCov()) GPUError("INVALID COV AFTER UPDATE!!!"));
-      CADEBUG(printf("\t%21sFit     Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f), DzDs %5.2f %16s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   FErr %d\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[3], "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retValUpd));
+      CADEBUG(printf("\t%21sFit     Alpha %8.3f    , X %8.3f - Y %8.3f, Z %8.3f   -   QPt %7.2f (%7.2f), SP %5.2f (%5.2f), DzDs %5.2f %16s    ---   Cov sY %8.3f sZ %8.3f sSP %8.3f sPt %8.3f   -   YPt %8.3f   -   FErr %d %d\n", "", prop.GetAlpha(), mX, mP[0], mP[1], mP[4], prop.GetQPt0(), mP[2], prop.GetSinPhi0(), mP[3], "", sqrtf(mC[0]), sqrtf(mC[2]), sqrtf(mC[5]), sqrtf(mC[14]), mC[10], retValUpd, retValInt));
       // clang-format on
 
-      ConstrainSinPhi();  // TODO: Limit using ConstrainSinPhi everywhere!
-      if (retValUpd == 0) // track is updated
+      ConstrainSinPhi();            // TODO: Limit using ConstrainSinPhi everywhere!
+      if (!retValUpd && !retValInt) // track is updated
       {
         lastUpdateX = mX;
         covYYUpd = mC[0];
@@ -311,14 +320,16 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
             }
           }
         }
-      } else if (retValUpd >= GPUTPCGMPropagator::updateErrorClusterRejected) { // cluster far away form the track
-        if (allowChangeClusters) {
+      } else if (retValInt || retValUpd >= GPUTPCGMPropagator::updateErrorClusterRejected) { // cluster far away form the track
+        if (retValInt || allowChangeClusters) {
           MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagRejectDistance);
         } else if (finalFit) {
           MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagRejectErr);
         }
-        nMissed++;
-        nMissed2++;
+        if (!retValInt) {
+          nMissed++;
+          nMissed2++;
+        }
       } else {
         break; // bad chi2 for the whole track, stop the fit
       }
@@ -328,7 +339,9 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       CADEBUG(printf("\t\tSTORING %d lastRow %d row %d out %d\n", iTrk, (int)lastRow, (int)clusters[(iWay & 1) ? (maxN - 1) : 0].row, lastRow > clusters[(iWay & 1) ? (maxN - 1) : 0].row));
     }
     if (!(iWay & 1) && !finalFit && !track.CCE() && !track.Looper()) {
-      ShiftZ(clusters, merger, maxN);
+      deltaZ = ShiftZ(clusters, merger, maxN);
+    } else {
+      deltaZ = 0.f;
     }
   }
   ConstrainSinPhi();
@@ -775,7 +788,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUr
   }
 }
 
-GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N)
+GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N)
 {
   if (N == 0) {
     N = 1;
@@ -783,13 +796,13 @@ GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMergedTrackHit* clusters, c
   const auto& GPUrestrict() cls = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
   float z0 = cls[clusters[0].num].getTime(), zn = cls[clusters[N - 1].num].getTime();
   const auto tmp = zn > z0 ? std::array<float, 3>{zn, z0, GPUTPCGeometry::Row2X(clusters[N - 1].row)} : std::array<float, 3>{z0, zn, GPUTPCGeometry::Row2X(clusters[0].row)};
-  ShiftZ(merger, clusters[0].sector, tmp[0], tmp[1], tmp[2]);
+  return ShiftZ(merger, clusters[0].sector, tmp[0], tmp[1], tmp[2]);
 }
 
-GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merger, int32_t sector, float cltmax, float cltmin, float clx)
+GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merger, int32_t sector, float cltmax, float cltmin, float clx)
 {
   if (!merger->Param().par.continuousTracking) {
-    return;
+    return 0.f;
   }
   float deltaZ = 0.f;
   bool beamlineReached = false;
@@ -828,7 +841,6 @@ GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merge
   {
     float deltaT = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaZtoDeltaTimeInTimeFrame(sector, deltaZ);
     mTOffset += deltaT;
-    mP[1] -= deltaZ;
     const float maxT = cltmin - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getT0();
     const float minT = cltmax - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(sector);
     // printf("T Check: Clusters %f %f, min %f max %f vtx %f\n", tz1, tz2, minT, maxT, mTOffset);
@@ -840,13 +852,14 @@ GPUd() void GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merge
       deltaT = maxT - mTOffset;
     }
     if (deltaT != 0.f) {
-      deltaZ = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(sector, deltaT);
+      deltaZ += merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(sector, deltaT);
       // printf("Moving clusters to TPC Range: QPt %f, New mTOffset %f, t1 %f, t2 %f, Shift %f in Z: %f to %f --> %f to %f in T\n", mP[4], mTOffset + deltaT, tz1, tz2, deltaZ, tz2 - mTOffset, tz1 - mTOffset, tz2 - mTOffset - deltaT, tz1 - mTOffset - deltaT);
       mTOffset += deltaT;
-      mP[1] -= deltaZ;
     }
+    mP[1] -= deltaZ;
   }
   // printf("\n");
+  return -deltaZ;
 }
 
 GPUd() bool GPUTPCGMTrackParam::CheckCov() const
@@ -861,28 +874,23 @@ GPUd() bool GPUTPCGMTrackParam::CheckNumericalQuality(float overrideCovYY) const
 {
   //* Check that the track parameters and covariance matrix are reasonable
   bool ok = CAMath::Finite(mX) && CAMath::Finite(mChi2);
-  CADEBUG(printf("OK %d - %f - ", (int32_t)ok, mX); for (int32_t i = 0; i < 5; i++) { printf("%f ", mP[i]); } printf(" - "); for (int32_t i = 0; i < 15; i++) { printf("%f ", mC[i]); } printf("\n"));
+  // CADEBUG(printf("OK %d - %f - ", (int32_t)ok, mX); for (int32_t i = 0; i < 5; i++) { printf("%f ", mP[i]); } printf(" - "); for (int32_t i = 0; i < 15; i++) { printf("%f ", mC[i]); } printf("\n"));
   const float* c = mC;
   for (int32_t i = 0; i < 15; i++) {
     ok = ok && CAMath::Finite(c[i]);
   }
-  CADEBUG(printf("OK1 %d\n", (int32_t)ok));
   for (int32_t i = 0; i < 5; i++) {
     ok = ok && CAMath::Finite(mP[i]);
   }
-  CADEBUG(printf("OK2 %d\n", (int32_t)ok));
   if ((overrideCovYY > 0 ? overrideCovYY : c[0]) > 4.f * 4.f || c[2] > 4.f * 4.f || c[5] > 2.f * 2.f || c[9] > 2.f * 2.f) {
     ok = 0;
   }
-  CADEBUG(printf("OK3 %d\n", (int32_t)ok));
   if (CAMath::Abs(mP[2]) > GPUCA_MAX_SIN_PHI) {
     ok = 0;
   }
-  CADEBUG(printf("OK4 %d\n", (int32_t)ok));
   if (!CheckCov()) {
     ok = false;
   }
-  CADEBUG(printf("OK5 %d\n", (int32_t)ok));
   return ok;
 }
 
@@ -903,7 +911,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
   CADEBUG(int32_t nTrackHitsOld = nTrackHits; float ptOld = t.QPt());
   bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, track);
   CADEBUG(printf("Finished Fit Track %d\n", iTrk));
-  CADEBUG(printf("OUTPUT hits %d -> %d+%d = %d, QPt %f -> %f, SP %f, ok %d chi2 %f chi2ndf %f\n", nTrackHitsOld, nTrackHits, NTolerated, nTrackHits + NTolerated, ptOld, t.QPt(), t.SinPhi(), (int32_t)ok, t.Chi2(), t.Chi2() / CAMath::Max(1, nTrackHits)));
+  CADEBUG(printf("OUTPUT hits %d -> %d+%d = %d, QPt %f -> %f, SP %f, OK %d chi2 %f chi2ndf %f\n", nTrackHitsOld, nTrackHits, NTolerated, nTrackHits + NTolerated, ptOld, t.QPt(), t.SinPhi(), (int32_t)ok, t.Chi2(), t.Chi2() / CAMath::Max(1, nTrackHits)));
 
   if (!ok && attempt == 0 && merger->Param().rec.tpc.retryRefit) {
     for (uint32_t i = 0; i < track.NClusters(); i++) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index 1c084f15874fe..f2812be8e16a3 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -183,8 +183,8 @@ class GPUTPCGMTrackParam
   }
 
   GPUd() void Rotate(float alpha);
-  GPUd() void ShiftZ(const GPUTPCGMMerger* merger, int32_t sector, float cltmax, float cltmin, float clx);
-  GPUd() void ShiftZ(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N);
+  GPUd() float ShiftZ(const GPUTPCGMMerger* merger, int32_t sector, float cltmax, float cltmin, float clx);
+  GPUd() float ShiftZ(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N);
 
   GPUd() static float Reciprocal(float x) { return 1.f / x; }
   GPUdi() static void Assign(float& x, bool mask, float v)

From e85490179b70ac374264e1b372a858a00a5e0f5c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 4 Sep 2025 11:00:22 +0200
Subject: [PATCH 0848/1764] GPU TPC: Make Looper Merging Afterburner work with
 new Segmented Track Fit

---
 .../DataCompression/GPUTPCClusterRejection.h  |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 52 +++++++++++++------
 GPU/GPUTracking/qa/GPUQA.cxx                  |  2 +-
 3 files changed, 38 insertions(+), 18 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h b/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
index 5c25813e75d29..f39994f2d1045 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
@@ -23,7 +23,7 @@ struct GPUTPCClusterRejection {
   template <bool C, class T = void, class S = void>
   static constexpr inline bool GetProtectionStatus(int32_t attach, bool& physics, bool& protect, T* counts = nullptr, S* mev200 = nullptr)
   {
-    (void)counts; // Avoid incorrect -Wunused-but-set-parameter warning
+    (void)counts; // FIXME: Avoid incorrect -Wunused-but-set-parameter warning
     (void)mev200;
     if (attach == 0) {
       return false;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 40932ec502a4b..464f315975920 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1887,13 +1887,12 @@ GPUd() void GPUTPCGMMerger::Finalize2(int32_t nBlocks, int32_t nThreads, int32_t
 
 GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  return;                                                       // FIXME: !!!!
-  const float lowPtThresh = Param().rec.tpc.rejectQPtB5 * 1.1f; // Might need to merge tracks above the threshold with parts below the threshold
+  const float lowPtThresh = Param().rec.tpc.rejectQPtB5 * 1.1f; // Might need to merge tracks above the threshold with parts below the rejection threshold
   for (uint32_t i = get_global_id(0); i < mMemory->nMergedTracks; i += get_global_size(0)) {
     const auto& trk = mMergedTracks[i];
     const auto& p = trk.GetParam();
     const float qptabs = CAMath::Abs(p.GetQPt());
-    if (trk.NClusters() && qptabs * Param().qptB5Scaler > 5.f && qptabs * Param().qptB5Scaler <= lowPtThresh) {
+    if (trk.OK() && trk.NClusters() && trk.Leg() == 0 && qptabs * Param().qptB5Scaler > 5.f && qptabs * Param().qptB5Scaler <= lowPtThresh) {
       const int32_t sector = mClusters[trk.FirstClusterRef() + trk.NClusters() - 1].sector;
       const float refz = p.GetZ() + GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, p.GetTOffset(), Param().continuousMaxTimeBin) + (trk.CSide() ? -100 : 100);
       float sinA, cosA;
@@ -1942,12 +1941,12 @@ GPUd() void GPUTPCGMMerger::MergeLoopersSort(int32_t nBlocks, int32_t nThreads,
 
 GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  const MergeLooperParam* params = mLooperCandidates;
+  const MergeLooperParam* candidates = mLooperCandidates;
 
 #if GPUCA_MERGE_LOOPER_MC && !defined(GPUCA_GPUCODE)
   std::vector<int64_t> paramLabels(mMemory->nLooperMatchCandidates);
   for (uint32_t i = 0; i < mMemory->nLooperMatchCandidates; i++) {
-    paramLabels[i] = GetTrackLabel(mMergedTracks[params[i].id]);
+    paramLabels[i] = GetTrackLabel(mMergedTracks[candidates[i].id]);
   }
   /*std::vector<bool> dropped(mMemory->nLooperMatchCandidates);
   std::vector<bool> droppedMC(mMemory->nLooperMatchCandidates);
@@ -1961,16 +1960,37 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
   for (uint32_t i = get_global_id(0); i < mMemory->nLooperMatchCandidates; i += get_global_size(0)) {
     for (uint32_t j = i + 1; j < mMemory->nLooperMatchCandidates; j++) {
       // int32_t bs = 0;
-      if (CAMath::Abs(params[j].refz) > CAMath::Abs(params[i].refz) + 100.f) {
+      assert(CAMath::Abs(candidates[i].refz) <= CAMath::Abs(candidates[j].refz));
+      if (CAMath::Abs(candidates[j].refz) > CAMath::Abs(candidates[i].refz) + 100.f) {
         break;
       }
-      const float d2xy = CAMath::Sum2(params[i].x - params[j].x, params[i].y - params[j].y);
+      const float d2xy = CAMath::Sum2(candidates[i].x - candidates[j].x, candidates[i].y - candidates[j].y);
       if (d2xy > 15.f) {
         // bs |= 1;
         continue;
       }
-      const auto& trk1 = mMergedTracks[params[i].id];
-      const auto& trk2 = mMergedTracks[params[j].id];
+
+      const GPUTPCGMMergedTrack* trkI = &mMergedTracks[candidates[i].id];
+      float refZI = candidates[i].refz;
+      {
+        const auto* tmp = trkI;
+        while (tmp->PrevSegment() >= 0) {
+          const auto* next = &mMergedTracks[tmp->PrevSegment()];
+          if (next == trkI) {
+            break;
+          }
+          tmp = next;
+        }
+        if (tmp != trkI && tmp->CSide() == trkI->CSide() && CAMath::Abs(tmp->GetParam().GetZ()) > CAMath::Abs(trkI->GetParam().GetZ())) {
+          float tmpRefZ = refZI + tmp->GetParam().GetZ() - trkI->GetParam().GetZ();
+          if (CAMath::Abs(tmpRefZ) < CAMath::Abs(candidates[j].refz) && CAMath::Abs(tmpRefZ) > CAMath::Abs(refZI)) {
+            trkI = tmp;
+            refZI = tmpRefZ;
+          }
+        }
+      };
+      const auto& trk1 = *trkI;
+      const auto& trk2 = mMergedTracks[candidates[j].id];
       const auto& param1 = trk1.GetParam();
       const auto& param2 = trk2.GetParam();
       if (CAMath::Abs(param1.GetDzDs()) > 0.03f && CAMath::Abs(param2.GetDzDs()) > 0.03f && param1.GetDzDs() * param2.GetDzDs() * param1.GetQPt() * param2.GetQPt() < 0) {
@@ -1978,9 +1998,9 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
         continue;
       }
 
-      const float dznormalized = (CAMath::Abs(params[j].refz) - CAMath::Abs(params[i].refz)) / (CAMath::TwoPi() * 0.5f * (CAMath::Abs(param1.GetDzDs()) + CAMath::Abs(param2.GetDzDs())) * 1.f / (0.5f * (CAMath::Abs(param1.GetQPt()) + CAMath::Abs(param2.GetQPt())) * CAMath::Abs(Param().polynomialField.GetNominalBz())));
+      const float dznormalized = (CAMath::Abs(candidates[j].refz) - CAMath::Abs(refZI)) / (CAMath::TwoPi() * 0.5f * (CAMath::Abs(param1.GetDzDs()) + CAMath::Abs(param2.GetDzDs())) * 1.f / (0.5f * (CAMath::Abs(param1.GetQPt()) + CAMath::Abs(param2.GetQPt())) * CAMath::Abs(Param().polynomialField.GetNominalBz())));
       const float phasecorr = CAMath::Modf((CAMath::ASin(param1.GetSinPhi()) + trk1.GetAlpha() - CAMath::ASin(param2.GetSinPhi()) - trk2.GetAlpha()) / CAMath::TwoPi() + 5.5f, 1.f) - 0.5f;
-      const float phasecorrdirection = (params[j].refz * param1.GetQPt() * param1.GetDzDs()) > 0 ? 1 : -1;
+      const float phasecorrdirection = (candidates[j].refz * param1.GetQPt() * param1.GetDzDs()) > 0 ? 1 : -1;
       const float dzcorr = dznormalized + phasecorr * phasecorrdirection;
       const bool sameside = !(trk1.CSide() ^ trk2.CSide());
       const float dzcorrlimit[4] = {sameside ? 0.018f : 0.012f, sameside ? 0.12f : 0.025f, 0.14f, 0.15f};
@@ -2009,11 +2029,11 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
       const int64_t label2 = paramLabels[j];
       bool labelEQ = label1 != -1 && label1 == label2;
       if (1 || EQ || labelEQ) {
-        // printf("Matching track %d/%d %u-%u (%ld/%ld): dist %f side %d %d, tgl %f %f, qpt %f %f, x %f %f, y %f %f\n", (int32_t)EQ, (int32_t)labelEQ, i, j, label1, label2, d, (int32_t)mMergedTracks[params[i].id].CSide(), (int32_t)mMergedTracks[params[j].id].CSide(), params[i].tgl, params[j].tgl, params[i].qpt, params[j].qpt, params[i].x, params[j].x, params[i].y, params[j].y);
+        // printf("Matching track %d/%d %u-%u (%ld/%ld): dist %f side %d %d, tgl %f %f, qpt %f %f, x %f %f, y %f %f\n", (int32_t)EQ, (int32_t)labelEQ, i, j, label1, label2, d, (int32_t)mMergedTracks[candidates[i].id].CSide(), (int32_t)mMergedTracks[candidates[j].id].CSide(), candidates[i].tgl, candidates[j].tgl, candidates[i].qpt, candidates[j].qpt, candidates[i].x, candidates[j].x, candidates[i].y, candidates[j].y);
         static auto& tup = GPUROOTDump<TNtuple>::get("mergeloopers", "labeleq:sides:d2xy:tgl1:tgl2:qpt1:qpt2:dz:dzcorr:dtgl:dqpt:dznorm:bs");
-        tup.Fill((float)labelEQ, (trk1.CSide() ? 1 : 0) | (trk2.CSide() ? 2 : 0), d2xy, param1.GetDzDs(), param2.GetDzDs(), param1.GetQPt(), param2.GetQPt(), CAMath::Abs(params[j].refz) - CAMath::Abs(params[i].refz), dzcorr, dtgl, dqpt, dznorm, bs);
+        tup.Fill((float)labelEQ, (trk1.CSide() ? 1 : 0) | (trk2.CSide() ? 2 : 0), d2xy, param1.GetDzDs(), param2.GetDzDs(), param1.GetQPt(), param2.GetQPt(), CAMath::Abs(candidates[j].refz) - CAMath::Abs(refZI), dzcorr, dtgl, dqpt, dznorm, bs);
         static auto tup2 = GPUROOTDump<TNtuple>::getNew("mergeloopers2", "labeleq:refz1:refz2:tgl1:tgl2:qpt1:qpt2:snp1:snp2:a1:a2:dzn:phasecor:phasedir:dzcorr");
-        tup2.Fill((float)labelEQ, params[i].refz, params[j].refz, param1.GetDzDs(), param2.GetDzDs(), param1.GetQPt(), param2.GetQPt(), param1.GetSinPhi(), param2.GetSinPhi(), trk1.GetAlpha(), trk2.GetAlpha(), dznormalized, phasecorr, phasecorrdirection, dzcorr);
+        tup2.Fill((float)labelEQ, refZI, candidates[j].refz, param1.GetDzDs(), param2.GetDzDs(), param1.GetQPt(), param2.GetQPt(), param1.GetSinPhi(), param2.GetSinPhi(), trk1.GetAlpha(), trk2.GetAlpha(), dznormalized, phasecorr, phasecorrdirection, dzcorr);
       }
       /*if (EQ) {
         dropped[j] = true;
@@ -2027,9 +2047,9 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
     }*/
 #endif
       if (EQ) {
-        mMergedTracks[params[j].id].SetMergedLooperUnconnected(true);
+        mMergedTracks[candidates[j].id].SetMergedLooperUnconnected(true);
         if (CAMath::Abs(param2.GetQPt() * Param().qptB5Scaler) >= Param().rec.tpc.rejectQPtB5) {
-          mMergedTracks[params[i].id].SetMergedLooperUnconnected(true);
+          mMergedTracks[candidates[i].id].SetMergedLooperUnconnected(true);
         }
       }
     }
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 6d1e724e1be3b..4f2c13635befa 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -2967,11 +2967,11 @@ int32_t GPUQA::DoClusterCounts(uint64_t* attachClusterCounts, int32_t mode)
 
   PrintClusterCount(mode, num, "Merged Loopers (Track Merging)", mClusterCounts.nMergedLooperConnected, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "Merged Loopers (Afterburner)", mClusterCounts.nMergedLooperUnconnected, mClusterCounts.nTotal);
+  PrintClusterCount(mode, num, "Looping Legs (other)", mClusterCounts.nLoopers, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "High Inclination Angle", mClusterCounts.nHighIncl, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "Rejected", mClusterCounts.nRejected, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "Tube (> 200 MeV)", mClusterCounts.nTube, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "Tube (< 200 MeV)", mClusterCounts.nTube200, mClusterCounts.nTotal);
-  PrintClusterCount(mode, num, "Looping Legs", mClusterCounts.nLoopers, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "Low Pt < 50 MeV", mClusterCounts.nLowPt, mClusterCounts.nTotal);
   PrintClusterCount(mode, num, "Low Pt < 200 MeV", mClusterCounts.n200MeV, mClusterCounts.nTotal);
 

From 0344aa6dbc9bab70d91b19c9a37155b0f1f667b0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 4 Sep 2025 11:49:36 +0200
Subject: [PATCH 0849/1764] GPU TPC: Avoid some code duplication

---
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h | 18 ++++++++++++++++++
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx    | 18 ++----------------
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx  |  9 +--------
 3 files changed, 21 insertions(+), 24 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 358a808e120a9..46b017523a107 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -49,6 +49,24 @@ class GPUTPCGMMergedTrack
   GPUd() bool MergedLooperConnected() const { return mFlags & 0x20; }
   GPUd() bool MergedLooper() const { return mFlags & 0x30; }
   GPUd() int32_t PrevSegment() const { return mPrevSegment; }
+  template <class T>
+  GPUd() static T* GetFirstSegment_helper(T* me, T* base)
+  {
+    if (me->mPrevSegment < 0) {
+      return me;
+    }
+    T* cur = &base[me->mPrevSegment];
+    while (cur->mPrevSegment >= 0) {
+      T* next = &base[cur->mPrevSegment];
+      if (next == me) {
+        return cur;
+      }
+      cur = next;
+    }
+    return cur;
+  }
+  GPUd() GPUTPCGMMergedTrack* GetFirstSegment(GPUTPCGMMergedTrack* base) { return GetFirstSegment_helper<GPUTPCGMMergedTrack>(this, base); }
+  GPUd() const GPUTPCGMMergedTrack* GetFirstSegment(const GPUTPCGMMergedTrack* base) const { return GetFirstSegment_helper<const GPUTPCGMMergedTrack>(this, base); }
   GPUd() uint8_t Leg() const { return mLeg; }
   GPUd() uint8_t Flags() const { return mFlags; }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 464f315975920..4e0526e17dec5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1797,14 +1797,7 @@ GPUd() void GPUTPCGMMerger::PrepareForFit1(int32_t nBlocks, int32_t nThreads, in
         CAMath::AtomicAdd(&mSharedCount[mClusters[trk.FirstClusterRef() + j].num], 1u);
       }
       if (!trk.CCE() && !trk.MergedLooper()) {
-        GPUTPCGMMergedTrack* updTrk = &trk;
-        while (updTrk->PrevSegment() >= 0) {
-          auto next = &mMergedTracks[updTrk->PrevSegment()];
-          if (next == &trk) {
-            break;
-          }
-          updTrk = next;
-        }
+        GPUTPCGMMergedTrack* updTrk = trk.GetFirstSegment(mMergedTracks);
         const auto &cl0 = mClusters[trk.FirstClusterRef()], &cln = mClusters[updTrk->FirstClusterRef() + updTrk->NClusters() - 1];
         const auto& GPUrestrict() cls = GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
         float z0 = cls[cl0.num].getTime(), zn = cls[cln.num].getTime();
@@ -1973,14 +1966,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
       const GPUTPCGMMergedTrack* trkI = &mMergedTracks[candidates[i].id];
       float refZI = candidates[i].refz;
       {
-        const auto* tmp = trkI;
-        while (tmp->PrevSegment() >= 0) {
-          const auto* next = &mMergedTracks[tmp->PrevSegment()];
-          if (next == trkI) {
-            break;
-          }
-          tmp = next;
-        }
+        const auto* tmp = trkI->GetFirstSegment(mMergedTracks);
         if (tmp != trkI && tmp->CSide() == trkI->CSide() && CAMath::Abs(tmp->GetParam().GetZ()) > CAMath::Abs(trkI->GetParam().GetZ())) {
           float tmpRefZ = refZI + tmp->GetParam().GetZ() - trkI->GetParam().GetZ();
           if (CAMath::Abs(tmpRefZ) < CAMath::Abs(candidates[j].refz) && CAMath::Abs(tmpRefZ) > CAMath::Abs(refZI)) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 9c789a8d95f82..d63d764a2613c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -212,14 +212,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
     }
 
     if (track.PrevSegment() >= 0) {
-      const GPUTPCGMMergedTrack* chkTrk = &tracks[track.PrevSegment()];
-      while (chkTrk->PrevSegment() >= 0) {
-        auto next = &tracks[chkTrk->PrevSegment()];
-        if (next == &track) {
-          break;
-        }
-        chkTrk = next;
-      }
+      const GPUTPCGMMergedTrack* chkTrk = track.GetFirstSegment(tracks);
       const auto& firstPrevCluster = trackClusters[chkTrk->FirstClusterRef()];
       t1 = clusters->clustersLinear[firstPrevCluster.num].getTime();
       sector1 = firstPrevCluster.sector;

From 0aed7a652197d58e850b64bf5b532e1dc15e4441 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 10 Sep 2025 23:48:18 +0200
Subject: [PATCH 0850/1764] GPU TPC: Make workarounds for cyclic merge graphs
 optional (to be checked, but should be removed eventually)

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h  |  8 +++----
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 24 ++++++++++++-------
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  2 +-
 4 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index d98008461cfce..de8ed938b7422 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -199,6 +199,7 @@ AddOptionRTC(fitInProjections, int8_t, -1, "", 0, "Fit in projection, -1 to enab
 AddOptionRTC(fitPropagateBzOnly, int8_t, -1, "", 0, "Propagate using Bz only for n passes")
 AddOptionRTC(useMatLUT, int8_t, 0, "", 0, "Use material lookup table for TPC refit")
 AddOptionRTC(trackingRefitGPUModel, int8_t, 1, "", 0, "Use GPU track model for the Global Track Refit")
+AddOptionRTC(enableCyclicGraphWorkarounds, int8_t, 0, "", 0, "Apply workarounds to avoid cyclic merge graphs, should not be needed")
 AddCustomCPP(void SetMinTrackPtB5(float v) { maxTrackQPtB5 = v > 0.001f ? (1.f / v) : (1.f / 0.001f); })
 AddSubConfig(GPUSettingsRecTPC, tpc)
 AddSubConfig(GPUSettingsRecTRD, trd)
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
index 46b017523a107..b7d6b2aebfbb8 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergedTrack.h
@@ -50,7 +50,7 @@ class GPUTPCGMMergedTrack
   GPUd() bool MergedLooper() const { return mFlags & 0x30; }
   GPUd() int32_t PrevSegment() const { return mPrevSegment; }
   template <class T>
-  GPUd() static T* GetFirstSegment_helper(T* me, T* base)
+  GPUd() static T* GetFirstSegment_helper(T* me, T* base, bool workaround)
   {
     if (me->mPrevSegment < 0) {
       return me;
@@ -58,15 +58,15 @@ class GPUTPCGMMergedTrack
     T* cur = &base[me->mPrevSegment];
     while (cur->mPrevSegment >= 0) {
       T* next = &base[cur->mPrevSegment];
-      if (next == me) {
+      if (workaround && next == me) {
         return cur;
       }
       cur = next;
     }
     return cur;
   }
-  GPUd() GPUTPCGMMergedTrack* GetFirstSegment(GPUTPCGMMergedTrack* base) { return GetFirstSegment_helper<GPUTPCGMMergedTrack>(this, base); }
-  GPUd() const GPUTPCGMMergedTrack* GetFirstSegment(const GPUTPCGMMergedTrack* base) const { return GetFirstSegment_helper<const GPUTPCGMMergedTrack>(this, base); }
+  GPUd() GPUTPCGMMergedTrack* GetFirstSegment(GPUTPCGMMergedTrack* base, bool workaround) { return GetFirstSegment_helper<GPUTPCGMMergedTrack>(this, base, workaround); }
+  GPUd() const GPUTPCGMMergedTrack* GetFirstSegment(const GPUTPCGMMergedTrack* base, bool workaround) const { return GetFirstSegment_helper<const GPUTPCGMMergedTrack>(this, base, workaround); }
   GPUd() uint8_t Leg() const { return mLeg; }
   GPUd() uint8_t Flags() const { return mFlags; }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 4e0526e17dec5..6121ce0aa89bb 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1461,7 +1461,9 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         if (trbase->PrevSegmentNeighbour() >= 0) {
           trbase = nullptr;
         } else {
-          trbase->SetPrevSegmentNeighbour(1000000001);
+          if (Param().rec.enableCyclicGraphWorkarounds) {
+            trbase->SetPrevSegmentNeighbour(1000000001);
+          }
           leg += revertSegments ? 1 : -1;
         }
       } else {
@@ -1483,13 +1485,15 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
       }
       revertSegments = false;
       revertInSegment = false;
-      trbase->SetPrevSegmentNeighbour(1000000000);
+      if (Param().rec.enableCyclicGraphWorkarounds) {
+        trbase->SetPrevSegmentNeighbour(1000000000);
+      }
       int32_t jtr = trbase->NextNeighbour();
       leg = 0;
       if (jtr >= 0) {
         int32_t lasttr = itr;
         while (jtr >= 0) { // --------------- count segments ---------------
-          if (&mSectorTrackInfos[jtr] == trbase) {
+          if (Param().rec.enableCyclicGraphWorkarounds && &mSectorTrackInfos[jtr] == trbase) {
             break; // Break cyclic graph
           }
           lasttr = jtr;
@@ -1512,7 +1516,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
               mainT = t;
             }
             int32_t next = trchk->NextSegmentNeighbour();
-            if (next < 0 || next == ichk) {
+            if (next < 0 || (Param().rec.enableCyclicGraphWorkarounds && next == ichk)) {
               break; // Breaks also cycles
             }
             trchk = &mSectorTrackInfos[next];
@@ -1533,7 +1537,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
               length = trchk->OrigTrack()->NHits();
             }
             int32_t next = trchk->NextSegmentNeighbour();
-            if (next < 0 || next == ichk) {
+            if (next < 0 || (Param().rec.enableCyclicGraphWorkarounds && next == ichk)) {
               break; // Breaks also cycles
             }
             trchk = &mSectorTrackInfos[next];
@@ -1575,7 +1579,9 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         int32_t jtr = tr->NextSegmentNeighbour();
         if (jtr >= 0) {
           tr = &(mSectorTrackInfos[jtr]);
-          tr->SetPrevSegmentNeighbour(1000000002);
+          if (Param().rec.enableCyclicGraphWorkarounds) {
+            tr->SetPrevSegmentNeighbour(1000000002);
+          }
           continue;
         }
         break;
@@ -1797,7 +1803,7 @@ GPUd() void GPUTPCGMMerger::PrepareForFit1(int32_t nBlocks, int32_t nThreads, in
         CAMath::AtomicAdd(&mSharedCount[mClusters[trk.FirstClusterRef() + j].num], 1u);
       }
       if (!trk.CCE() && !trk.MergedLooper()) {
-        GPUTPCGMMergedTrack* updTrk = trk.GetFirstSegment(mMergedTracks);
+        GPUTPCGMMergedTrack* updTrk = trk.GetFirstSegment(mMergedTracks, Param().rec.enableCyclicGraphWorkarounds);
         const auto &cl0 = mClusters[trk.FirstClusterRef()], &cln = mClusters[updTrk->FirstClusterRef() + updTrk->NClusters() - 1];
         const auto& GPUrestrict() cls = GetConstantMem()->ioPtrs.clustersNative->clustersLinear;
         float z0 = cls[cl0.num].getTime(), zn = cls[cln.num].getTime();
@@ -1806,7 +1812,7 @@ GPUd() void GPUTPCGMMerger::PrepareForFit1(int32_t nBlocks, int32_t nThreads, in
         updTrk = &trk;
         while (updTrk->PrevSegment() >= 0) {
           auto next = &mMergedTracks[updTrk->PrevSegment()];
-          if (next == &trk) {
+          if (Param().rec.enableCyclicGraphWorkarounds && next == &trk) {
             break;
           }
           updTrk = next;
@@ -1966,7 +1972,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersMain(int32_t nBlocks, int32_t nThreads,
       const GPUTPCGMMergedTrack* trkI = &mMergedTracks[candidates[i].id];
       float refZI = candidates[i].refz;
       {
-        const auto* tmp = trkI->GetFirstSegment(mMergedTracks);
+        const auto* tmp = trkI->GetFirstSegment(mMergedTracks, Param().rec.enableCyclicGraphWorkarounds);
         if (tmp != trkI && tmp->CSide() == trkI->CSide() && CAMath::Abs(tmp->GetParam().GetZ()) > CAMath::Abs(trkI->GetParam().GetZ())) {
           float tmpRefZ = refZI + tmp->GetParam().GetZ() - trkI->GetParam().GetZ();
           if (CAMath::Abs(tmpRefZ) < CAMath::Abs(candidates[j].refz) && CAMath::Abs(tmpRefZ) > CAMath::Abs(refZI)) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index d63d764a2613c..e911275da1e55 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -212,7 +212,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
     }
 
     if (track.PrevSegment() >= 0) {
-      const GPUTPCGMMergedTrack* chkTrk = track.GetFirstSegment(tracks);
+      const GPUTPCGMMergedTrack* chkTrk = track.GetFirstSegment(tracks, merger.Param().rec.enableCyclicGraphWorkarounds);
       const auto& firstPrevCluster = trackClusters[chkTrk->FirstClusterRef()];
       t1 = clusters->clustersLinear[firstPrevCluster.num].getTime();
       sector1 = firstPrevCluster.sector;

From ac46fff423927148fd94f3841144bf94fcb15fbf Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 11 Sep 2025 08:51:04 +0200
Subject: [PATCH 0851/1764] GPU: Add some more optional sanity checks

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |   5 +-
 GPU/GPUTracking/Definitions/GPUSettingsList.h |   3 +
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |   6 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |   2 +-
 .../Global/GPUChainTrackingClusterizer.cxx    |   2 +-
 .../GPUChainTrackingDebugAndProfiling.cxx     |   2 +-
 .../Global/GPUChainTrackingMerger.cxx         |   6 +
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 162 +++++++++++-------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |   4 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |   1 -
 .../Standalone/Benchmark/standalone.cxx       |   2 +-
 11 files changed, 128 insertions(+), 67 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 17e2a2a27c747..6d64fb3daca6a 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -294,14 +294,15 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
   if (!(mRecoSteps.stepsGPUMask & GPUDataTypes::RecoStep::TPCMerging)) {
     mProcessingSettings->mergerSortTracks = false;
   }
-
   if (GetProcessingSettings().debugLevel > 3 || !IsGPU() || GetProcessingSettings().deterministicGPUReconstruction) {
     mProcessingSettings->delayedOutput = false;
   }
-
   if (!GetProcessingSettings().rtc.enable) {
     mProcessingSettings->rtc.optConstexpr = false;
   }
+  if (GetProcessingSettings().allSanityChecks) {
+    mProcessingSettings->clusterizerZSSanityCheck = mProcessingSettings->mergerSanityCheck = mProcessingSettings->outputSanityCheck = true;
+  }
 
   mMemoryScalers->scalingFactor = GetProcessingSettings().memoryScalingFactor;
   mMemoryScalers->conservative = GetProcessingSettings().conservativeMemoryEstimate;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index de8ed938b7422..8b5f70f25a4d9 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -352,6 +352,9 @@ AddOption(fastTransformObjectsMinMemorySize, uint32_t, 400u * 1024 * 1024, "", 0
 AddOption(lateO2MatLutProvisioningSize, uint32_t, 0u, "", 0, "Memory size to reserve for late provisioning of matlut table")
 AddOption(throttleAlarms, bool, false, "", 0, "Throttle rate at which alarms are sent to the InfoLogger in online runs")
 AddOption(outputSanityCheck, bool, false, "", 0, "Run some simple sanity checks finding errors in the output")
+AddOption(mergerSanityCheck, bool, false, "", 0, "Run some simple sanity checks after / during track merging")
+AddOption(clusterizerZSSanityCheck, bool, false, "", 0, "Run some simple sanity checks on ZS decoding during clusterization")
+AddOption(allSanityChecks, bool, false, "", 0, "Enable all sanity checks")
 AddOption(tpcSingleSector, int32_t, -1, "", 0, "Restrict TPC processing to a single sector")
 AddOption(tpcDownscaledEdx, uint8_t, 0, "", 0, "If != 0, downscale dEdx processing (if enabled) to x %")
 AddOption(tpcMaxAttachedClustersPerSectorRow, uint32_t, 51000, "", 0, "Maximum number of TPC attached clusters which can be decoded per SectorRow")
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 430cad041ebe5..f47c6923a6be7 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -269,6 +269,10 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("noGPUMemoryRegistration only possible with gather mode 3 (set to %d / %d)", mRec->GetProcessingSettings().tpcCompressionGatherMode, gatherMode);
     return false;
   }
+  if (mRec->IsGPU() && (GetProcessingSettings().clusterizerZSSanityCheck || GetProcessingSettings().mergerSanityCheck)) {
+    GPUError("Clusterizer and merger Sanity checks only supported when not running on GPU");
+    return false;
+  }
   if (GetProcessingSettings().doublePipeline) {
     if (!GetRecoStepsOutputs().isOnlySet(GPUDataTypes::InOutType::TPCMergedTracks, GPUDataTypes::InOutType::TPCCompressedClusters, GPUDataTypes::InOutType::TPCClusters)) {
       GPUError("Invalid outputs for double pipeline mode 0x%x", (uint32_t)GetRecoStepsOutputs());
@@ -791,7 +795,7 @@ int32_t GPUChainTracking::RunChainFinalize()
   }
 
   if (GetProcessingSettings().outputSanityCheck) {
-    SanityCheck();
+    OutputSanityCheck();
   }
 
   const bool needQA = GPUQA::QAAvailable() && (GetProcessingSettings().runQA || (GetProcessingSettings().eventDisplay && mIOPtrs.nMCInfosTPC));
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index d7e821187e1fe..5c85147494711 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -291,7 +291,7 @@ class GPUChainTracking : public GPUChain
 
  private:
   int32_t RunChainFinalize();
-  void SanityCheck();
+  void OutputSanityCheck();
   int32_t RunTPCTrackingSectors_internal();
   int32_t RunTPCClusterizer_prepare(bool restorePointers);
 #ifdef GPUCA_TPC_GEOMETRY_O2
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 1fa2014fe47e7..99f1d93796752 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -107,7 +107,7 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCountUpdat
   if (doGPU) {
     pages = o - processors()->tpcClusterer[iSector].mPzsOffsets;
   }
-  if (!doGPU && GetProcessingSettings().debugLevel >= 4 && mCFContext->zsVersion >= ZSVersion::ZSVersionDenseLinkBased) {
+  if (GetProcessingSettings().clusterizerZSSanityCheck && mCFContext->zsVersion >= ZSVersion::ZSVersionDenseLinkBased) {
     TPCClusterizerEnsureZSOffsets(iSector, fragment);
   }
   return {digits, pages};
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index fbd999f8feb56..15846246bca0a 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -251,7 +251,7 @@ void GPUChainTracking::PrintOutputStat()
   GPUInfo("Output Tracks: %d (%d / %d / %d / %d clusters (fitted / attached / adjacent / total) - %s format)%s", nTracks, nAttachedClustersFitted, nAttachedClusters, nAdjacentClusters, nCls, GetProcessingSettings().createO2Output > 1 ? "O2" : "GPU", trdText);
 }
 
-void GPUChainTracking::SanityCheck()
+void GPUChainTracking::OutputSanityCheck()
 {
   size_t nErrors = 0;
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 4d9fcd4b1572a..a9d4304d77c83 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -163,6 +163,9 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), 2 * NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
 
   runKernel<GPUTPCGMMergerLinkExtrapolatedTracks>(GetGridAuto(0, deviceType));
+  if (GetProcessingSettings().mergerSanityCheck) {
+    Merger.CheckMergeGraph();
+  }
   runKernel<GPUTPCGMMergerCollect>(GetGridAuto(0, deviceType));
   if (GetProcessingSettings().deterministicGPUReconstruction) {
     runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::mergedTracks1>({{1, -WarpSize(), 0, deviceType}}, 1);
@@ -189,6 +192,9 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     CondWaitEvent(waitForTransfer, &mEvents->single);
     runKernel<GPUTPCGMMergerSortTracks>(GetGridAuto(0, deviceType));
   }
+  if (GetProcessingSettings().mergerSanityCheck) {
+    Merger.CheckCollectedTracks();
+  }
 
   uint32_t maxId = Merger.NMaxClusters();
   if (maxId > Merger.NMaxClusters()) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 6121ce0aa89bb..9a4b129f751a4 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -164,7 +164,98 @@ GPUTPCGMMerger::GPUTPCGMMerger()
 #if !defined(GPUCA_GPUCODE) && (defined(GPUCA_MERGER_BY_MC_LABEL) || defined(GPUCA_CADEBUG_ENABLED) || GPUCA_MERGE_LOOPER_MC)
 #include "GPUQAHelper.h"
 
-void GPUTPCGMMerger::CheckMergedTracks()
+template <class T>
+inline const auto* resolveMCLabels(const o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>* a, const AliHLTTPCClusterMCLabel* b)
+{
+  return a;
+}
+template <>
+inline const auto* resolveMCLabels<AliHLTTPCClusterMCLabel>(const o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>* a, const AliHLTTPCClusterMCLabel* b)
+{
+  return b;
+}
+
+template <class T, class S>
+int64_t GPUTPCGMMerger::GetTrackLabelA(const S& trk) const
+{
+  GPUTPCGMSectorTrack* sectorTrack = nullptr;
+  int32_t nClusters = 0;
+  if constexpr (std::is_same_v<S, GPUTPCGMBorderTrack&>) {
+    sectorTrack = &mSectorTrackInfos[trk.TrackID()];
+    nClusters = sectorTrack->OrigTrack()->NHits();
+  } else {
+    nClusters = trk.NClusters();
+  }
+  auto acc = GPUTPCTrkLbl<false, GPUTPCTrkLbl_ret>(resolveMCLabels<T>(GetConstantMem()->ioPtrs.clustersNative ? GetConstantMem()->ioPtrs.clustersNative->clustersMCTruth : nullptr, GetConstantMem()->ioPtrs.mcLabelsTPC), 0.5f);
+  for (int32_t i = 0; i < nClusters; i++) {
+    int32_t id;
+    if constexpr (std::is_same_v<S, GPUTPCGMBorderTrack&>) {
+      const GPUTPCTracker& tracker = GetConstantMem()->tpcTrackers[sectorTrack->Sector()];
+      const GPUTPCHitId& ic = tracker.TrackHits()[sectorTrack->OrigTrack()->FirstHitID() + i];
+      id = tracker.Data().ClusterDataIndex(tracker.Data().Row(ic.RowIndex()), ic.HitIndex()) + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[sectorTrack->Sector()][0];
+    } else {
+      id = mClusters[trk.FirstClusterRef() + i].num;
+    }
+    acc.addLabel(id);
+  }
+  return acc.computeLabel().id;
+}
+
+template <class S>
+int64_t GPUTPCGMMerger::GetTrackLabel(const S& trk) const
+{
+#ifdef GPUCA_TPC_GEOMETRY_O2
+  if (GetConstantMem()->ioPtrs.clustersNative->clustersMCTruth) {
+    return GetTrackLabelA<o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>, S>(trk);
+  } else
+#endif
+  {
+    return GetTrackLabelA<AliHLTTPCClusterMCLabel, S>(trk);
+  }
+}
+
+#endif
+// END DEBUG CODE
+
+void GPUTPCGMMerger::CheckCollectedTracks()
+{
+  uint32_t nErr = 0;
+  for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
+    const GPUTPCGMMergedTrack& trk = mMergedTracks[i];
+    if (trk.OK()) {
+      if (trk.NClusters() == 0) {
+        GPUError("FAILURE: Track marked ok but has 0 clusters");
+        nErr++;
+      }
+      if (!trk.CCE() && !trk.MergedLooper()) {
+        const GPUTPCGMMergedTrack* updTrk = &trk;
+        while (updTrk->PrevSegment() >= 0) {
+          auto next = &mMergedTracks[updTrk->PrevSegment()];
+          if (!next->MergedLooper()) {
+            GPUError("FAILURE: prev segment not marked as merged looper\n");
+            nErr++;
+          }
+          if (next == &trk) {
+            GPUError("FAILURE: segment cycle found\n");
+            break;
+          }
+          updTrk = next;
+        }
+        if (updTrk->NClusters() == 0) {
+          printf("FAILURE: segment leg has 0 clusters");
+        }
+      }
+    }
+  }
+
+  if (nErr == 0) {
+    GPUInfo("Merged Tracks OK");
+  } else {
+    throw std::runtime_error("Error during track merging");
+  }
+}
+
+void GPUTPCGMMerger::CheckMergeGraph()
 {
   uint32_t nErr = 0;
   std::vector<bool> trkUsed(SectorTrackInfoLocalTotal());
@@ -175,19 +266,19 @@ void GPUTPCGMMerger::CheckMergedTracks()
   for (int32_t itr = 0; itr < SectorTrackInfoLocalTotal(); itr++) {
     GPUTPCGMSectorTrack& track = mSectorTrackInfos[itr];
     if (track.PrevSegmentNeighbour() >= 0 && mSectorTrackInfos[track.PrevSegmentNeighbour()].NextSegmentNeighbour() != itr) {
-      GPUError("Invalid reciprocal segment link: %d PrevSegmentNeighbour %d NextSegmentNeighbour %d", itr, track.PrevSegmentNeighbour(), mSectorTrackInfos[track.PrevSegmentNeighbour()].NextSegmentNeighbour());
+      GPUError("FAILURE: Invalid reciprocal segment link: %d PrevSegmentNeighbour %d NextSegmentNeighbour %d", itr, track.PrevSegmentNeighbour(), mSectorTrackInfos[track.PrevSegmentNeighbour()].NextSegmentNeighbour());
       nErr++;
     }
     if (track.NextSegmentNeighbour() >= 0 && mSectorTrackInfos[track.NextSegmentNeighbour()].PrevSegmentNeighbour() != itr) {
-      GPUError("Invalid reciprocal segment link: %d NextSegmentNeighbour %d PrevSegmentNeighbour %d", itr, track.NextSegmentNeighbour(), mSectorTrackInfos[track.NextSegmentNeighbour()].PrevSegmentNeighbour());
+      GPUError("FAILURE: Invalid reciprocal segment link: %d NextSegmentNeighbour %d PrevSegmentNeighbour %d", itr, track.NextSegmentNeighbour(), mSectorTrackInfos[track.NextSegmentNeighbour()].PrevSegmentNeighbour());
       nErr++;
     }
     if (track.PrevNeighbour() >= 0 && mSectorTrackInfos[track.PrevNeighbour()].NextNeighbour() != itr) {
-      GPUError("Invalid reciprocal  link: %d PrevNeighbour %d NextNeighbour %d", itr, track.PrevNeighbour(), mSectorTrackInfos[track.PrevNeighbour()].NextNeighbour());
+      GPUError("FAILURE: Invalid reciprocal  link: %d PrevNeighbour %d NextNeighbour %d", itr, track.PrevNeighbour(), mSectorTrackInfos[track.PrevNeighbour()].NextNeighbour());
       nErr++;
     }
     if (track.NextNeighbour() >= 0 && mSectorTrackInfos[track.NextNeighbour()].PrevNeighbour() != itr) {
-      GPUError("Invalid reciprocal  link: %d NextNeighbour %d PrevNeighbour %d", itr, track.NextNeighbour(), mSectorTrackInfos[track.NextNeighbour()].PrevNeighbour());
+      GPUError("FAILURE: Invalid reciprocal  link: %d NextNeighbour %d PrevNeighbour %d", itr, track.NextNeighbour(), mSectorTrackInfos[track.NextNeighbour()].PrevNeighbour());
       nErr++;
     }
     if (track.PrevSegmentNeighbour() >= 0) {
@@ -202,12 +293,17 @@ void GPUTPCGMMerger::CheckMergedTracks()
       if (trkUsed[iTrk]) {
         GPUError("FAILURE: double use");
         nErr++;
+        break;
       }
       trkUsed[iTrk] = true;
 
       int32_t jtr = tr->NextSegmentNeighbour();
       if (jtr >= 0) {
         tr = &(mSectorTrackInfos[jtr]);
+        if (tr->PrevNeighbour() >= 0) {
+          GPUError("FAILURE: Non-base segment has previous leg");
+          nErr++;
+        }
         continue;
       }
       jtr = trbase->NextNeighbour();
@@ -215,6 +311,8 @@ void GPUTPCGMMerger::CheckMergedTracks()
         trbase = &(mSectorTrackInfos[jtr]);
         tr = trbase;
         if (tr->PrevSegmentNeighbour() >= 0) {
+          GPUError("FAILURE: Neibhbour leg has previous segment neightbout");
+          nErr++;
           break;
         }
         continue;
@@ -230,62 +328,11 @@ void GPUTPCGMMerger::CheckMergedTracks()
   }
   if (nErr == 0) {
     GPUInfo("Merged Track Graph OK");
-  }
-}
-
-template <class T>
-inline const auto* resolveMCLabels(const o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>* a, const AliHLTTPCClusterMCLabel* b)
-{
-  return a;
-}
-template <>
-inline const auto* resolveMCLabels<AliHLTTPCClusterMCLabel>(const o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>* a, const AliHLTTPCClusterMCLabel* b)
-{
-  return b;
-}
-
-template <class T, class S>
-int64_t GPUTPCGMMerger::GetTrackLabelA(const S& trk) const
-{
-  GPUTPCGMSectorTrack* sectorTrack = nullptr;
-  int32_t nClusters = 0;
-  if constexpr (std::is_same_v<S, GPUTPCGMBorderTrack&>) {
-    sectorTrack = &mSectorTrackInfos[trk.TrackID()];
-    nClusters = sectorTrack->OrigTrack()->NHits();
   } else {
-    nClusters = trk.NClusters();
-  }
-  auto acc = GPUTPCTrkLbl<false, GPUTPCTrkLbl_ret>(resolveMCLabels<T>(GetConstantMem()->ioPtrs.clustersNative ? GetConstantMem()->ioPtrs.clustersNative->clustersMCTruth : nullptr, GetConstantMem()->ioPtrs.mcLabelsTPC), 0.5f);
-  for (int32_t i = 0; i < nClusters; i++) {
-    int32_t id;
-    if constexpr (std::is_same_v<S, GPUTPCGMBorderTrack&>) {
-      const GPUTPCTracker& tracker = GetConstantMem()->tpcTrackers[sectorTrack->Sector()];
-      const GPUTPCHitId& ic = tracker.TrackHits()[sectorTrack->OrigTrack()->FirstHitID() + i];
-      id = tracker.Data().ClusterDataIndex(tracker.Data().Row(ic.RowIndex()), ic.HitIndex()) + GetConstantMem()->ioPtrs.clustersNative->clusterOffset[sectorTrack->Sector()][0];
-    } else {
-      id = mClusters[trk.FirstClusterRef() + i].num;
-    }
-    acc.addLabel(id);
-  }
-  return acc.computeLabel().id;
-}
-
-template <class S>
-int64_t GPUTPCGMMerger::GetTrackLabel(const S& trk) const
-{
-#ifdef GPUCA_TPC_GEOMETRY_O2
-  if (GetConstantMem()->ioPtrs.clustersNative->clustersMCTruth) {
-    return GetTrackLabelA<o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>, S>(trk);
-  } else
-#endif
-  {
-    return GetTrackLabelA<AliHLTTPCClusterMCLabel, S>(trk);
+    throw std::runtime_error("Invalid merge graph");
   }
 }
 
-#endif
-// END DEBUG CODE
-
 void GPUTPCGMMerger::PrintMergeGraph(const GPUTPCGMSectorTrack* trk, std::ostream& out) const
 {
   const GPUTPCGMSectorTrack* orgTrack = trk;
@@ -1441,7 +1488,6 @@ struct GPUTPCGMMerger_CompareClusterIds {
 
 GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
-  // if (iThread == 0 && iBlock == 0) { CheckMergedTracks(); } return; // (if GPUCA_CADEBUG_ENABLED)
   static constexpr int32_t kMaxParts = 16;
   static constexpr int32_t kMaxClusters = GPUCA_MERGER_MAX_TRACK_CLUSTERS;
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 0159b795aa963..14974bdec2303 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -218,6 +218,9 @@ class GPUTPCGMMerger : public GPUProcessor
   GPUdi() int32_t SectorTrackInfoLocalTotal() const { return mSectorTrackInfoIndex[NSECTORS]; }
   GPUdi() int32_t SectorTrackInfoTotal() const { return mSectorTrackInfoIndex[2 * NSECTORS]; }
 
+  void CheckMergeGraph();
+  void CheckCollectedTracks();
+
  private:
   GPUd() void MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iBorder, GPUTPCGMBorderTrack** B, GPUAtomic(uint32_t) * nB, bool useOrigTrackParam = false);
   template <int32_t I>
@@ -225,7 +228,6 @@ class GPUTPCGMMerger : public GPUProcessor
 
   GPUd() void MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, int32_t itr);
 
-  void CheckMergedTracks();
 #ifndef GPUCA_GPUCODE
   void PrintMergeGraph(const GPUTPCGMSectorTrack* trk, std::ostream& out) const;
   template <class T, class S>
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index f2812be8e16a3..f38ea4d320c14 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -149,7 +149,6 @@ class GPUTPCGMTrackParam
   GPUd() bool AttachClustersPropagate(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t lastRow, int32_t toRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop, bool inFlyDirection, float maxSinPhi = GPUCA_MAX_SIN_PHI, bool checkdEdx = false);
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop); // Returns uncorrectedY for later use
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, float Y, float Z);
-  // We force to compile these twice, for PropagateLooper and for Fit, for better optimization
   GPUd() void AttachClustersLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, GPUTPCGMPropagator& prop);
   GPUd() void AttachClustersLooperFollow(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards);
   GPUd() void StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, float alpha);
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 2e89a4d72c63e..1fa41d55ebbec 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -843,7 +843,7 @@ int32_t main(int argc, char** argv)
       break;
     }
     if (configStandalone.runs2 > 1) {
-      printf("RUN2: %d\n", iRunOuter);
+      printf("\nRUN2: %d\n", iRunOuter);
     }
     int64_t nTracksTotal = 0;
     int64_t nClustersTotal = 0;

From 6a82fffbbc4452491608c4cfae64d2afffb90e1d Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Fri, 12 Sep 2025 20:57:29 +0200
Subject: [PATCH 0852/1764] Add new raw data type for common mode values

---
 DataFormats/Detectors/TPC/include/DataFormatsTPC/RawDataTypes.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/RawDataTypes.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/RawDataTypes.h
index 26d3fe9cf21cc..db96280bde534 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/RawDataTypes.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/RawDataTypes.h
@@ -28,6 +28,7 @@ enum Type : char {
   ZS = 2,      ///< final Zero Suppression (can be ILBZS, DLBZS)
   IDC = 3,     ///< Integrated Digitial Currents, with priority bit to end up in separate buffer
   SAC = 4,     ///< Sampled Analogue Currents from the current monitor
+  CMV = 5,     ///< Common mode values
 };
 
 const std::unordered_map<Type, std::string_view> TypeNameMap{
@@ -36,6 +37,7 @@ const std::unordered_map<Type, std::string_view> TypeNameMap{
   {Type::ZS, "ZS"},
   {Type::IDC, "IDC"},
   {Type::SAC, "SAC"},
+  {Type::CMV, "CMV"},
 };
 
 } // namespace o2::tpc::raw_data_types

From c2864a0d3cf6af95c41a76f772dade725b299624 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 16 Sep 2025 21:56:35 +0200
Subject: [PATCH 0853/1764] DPL: get CCDB and reader signposts to work.
 (#14678)

---
 Framework/Core/src/DataProcessingDevice.cxx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 859a48955a8f5..5564f68d8f8ce 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -96,6 +96,8 @@ O2_DECLARE_DYNAMIC_LOG(calibration);
 O2_DECLARE_DYNAMIC_LOG(async_queue);
 // Special log to track the forwarding requests
 O2_DECLARE_DYNAMIC_LOG(forwarding);
+// Special log to track CCDB related requests
+O2_DECLARE_DYNAMIC_LOG(ccdb);
 
 using namespace o2::framework;
 using ConfigurationInterface = o2::configuration::ConfigurationInterface;

From f2e0f3d96f9021663deea86e0d79fe7a429ac94c Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Tue, 16 Sep 2025 22:36:29 +0200
Subject: [PATCH 0854/1764] Add TRD tracklets slopes to unbinned residuals tree
 (#14676)

* Add TRD tracklets slopes to unbinned residuals tree

* increment TrackData class version
---
 .../include/SpacePoints/SpacePointsCalibParam.h    | 10 +++++-----
 .../include/SpacePoints/TrackInterpolation.h       |  5 +++--
 .../SpacePoints/src/TrackInterpolation.cxx         | 14 ++++++++++----
 3 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h
index 90b693820d0fa..535dd23d7a8ae 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h
@@ -53,11 +53,11 @@ static constexpr int NY2XBins = 15; ///< number of bins in y/x
 static constexpr int NZ2XBins = 5;  ///< number of bins in z/x
 
 // define ranges for compression to shorts in TPCClusterResiduals
-static constexpr float MaxResid = 20.f; ///< max residual in y and z
-static constexpr float MaxY = 50.f;     ///< max value for y position (sector coordinates)
-static constexpr float MaxZ = 300.f;    ///< max value for z position
-static constexpr float MaxTgSlp = 1.f;  ///< max value for phi (from snp, converted to tangens)
-
+static constexpr float MaxResid = 20.f;  ///< max residual in y and z
+static constexpr float MaxY = 50.f;      ///< max value for y position (sector coordinates)
+static constexpr float MaxZ = 300.f;     ///< max value for z position
+static constexpr float MaxTgSlp = 1.f;   ///< max value for phi (from snp, converted to tangens)
+static constexpr float MaxTRDSlope = 5.; ///< max value for the TRD tracklet getDy
 // miscellaneous
 static constexpr float sEps = 1e-6f; ///< small number for float comparisons
 
diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
index 3b9e4021f443a..eaaea3f26b995 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
@@ -146,13 +146,14 @@ struct TrackData {
   unsigned short nClsITS{};                  ///< number of attached ITS clusters
   unsigned short nTrkltsTRD{};               ///< number of attached TRD tracklets
   unsigned short clAvailTOF{};               ///< whether or not track seed has a matched TOF cluster, if so, gives the resolution of the T0 in ps
+  short TRDTrkltSlope[6] = {};               ///< TRD tracklet slope 0x7fff / param::MaxTRDSlope
   uint8_t nExtDetResid = 0;                  ///< number of external detectors (to TPC) residuals stored, on top of clIdx.getEntries
   o2::dataformats::RangeReference<> clIdx{}; ///< index of first cluster residual and total number of TPC cluster residuals of this track
 
   float getT0Error() const { return float(clAvailTOF); }
   bool isTOFAvail() const { return clAvailTOF != 0; }
 
-  ClassDefNV(TrackData, 8);
+  ClassDefNV(TrackData, 9);
 };
 
 /// \class TrackInterpolation
@@ -293,7 +294,7 @@ class TrackInterpolation
 
   void setExtDetResid(bool v) { mExtDetResid = v; }
 
-  int processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork, std::array<float, 2>* trkltTRDYZ = nullptr, std::array<float, 3>* trkltTRDCov = nullptr);
+  int processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork, std::array<float, 2>* trkltTRDYZ = nullptr, std::array<float, 3>* trkltTRDCov = nullptr, TrackData* trkData = nullptr);
 
   // --------------------------------- output ---------------------------------------------
   std::vector<UnbinnedResid>& getClusterResiduals() { return mClRes; }
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index 00d689326de73..d89b3c28f1a0d 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -663,7 +663,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
         const auto& trkTRD = mRecoCont->getITSTPCTRDTrack<o2::trd::TrackTRD>(gidTable[GTrackID::ITSTPCTRD]);
         for (int iLayer = 0; iLayer < o2::trd::constants::NLAYER; iLayer++) {
           std::array<float, 2> trkltTRDYZ{};
-          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ);
+          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ, nullptr, &trackData);
           if (res == -1) { // no traklet on this layer
             continue;
           }
@@ -757,7 +757,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
 }
 
 int TrackInterpolation::processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork,
-                                        std::array<float, 2>* trkltTRDYZ, std::array<float, 3>* trkltTRDCov)
+                                        std::array<float, 2>* trkltTRDYZ, std::array<float, 3>* trkltTRDCov, TrackData* trkData)
 {
   // return chamber ID (0:539) in case of successful processing, -1 if there is no TRD tracklet at given layer, -2 if processing failed
   int trkltIdx = trkTRD.getTrackletIndex(iLayer);
@@ -793,6 +793,12 @@ int TrackInterpolation::processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLa
       mRecoParam.recalcTrkltCov(tilt, trkWork.getSnp(), pad->getRowSize(trdTrklt.getPadRow()), *trkltTRDCov);
     }
   }
+  if (trkData) {
+    auto slope = trdSP.getDy();
+    if (std::abs(slope) < param::MaxTRDSlope) {
+      trkData->TRDTrkltSlope[iLayer] = slope * 0x7fff / param::MaxTRDSlope;
+    }
+  }
   return trkltDet;
 }
 
@@ -915,9 +921,10 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
       const auto& gidTableFull = mGIDtables[iSeedFull];
       if (gidTableFull[GTrackID::TRD].isIndexSet()) {
         const auto& trkTRD = mRecoCont->getITSTPCTRDTrack<o2::trd::TrackTRD>(gidTableFull[GTrackID::ITSTPCTRD]);
+        trackData.nTrkltsTRD = trkTRD.getNtracklets();
         for (int iLayer = 0; iLayer < o2::trd::constants::NLAYER; iLayer++) {
           std::array<float, 2> trkltTRDYZ{};
-          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ);
+          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ, nullptr, &trackData);
           if (res == -1) { // no traklet on this layer
             continue;
           }
@@ -932,7 +939,6 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
           const auto sec = clusterResiduals[iCl].sec;
           if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
             mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 160 + iLayer, o2::math_utils::angle2Sector(trkWork.getAlpha()), (short)res);
-            trackData.nTrkltsTRD++;
             trackData.nExtDetResid++;
           }
         }

From d0daea3091c6f4f1d8a4b6060c8eaed04e597501 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Thu, 18 Sep 2025 10:50:03 +0200
Subject: [PATCH 0855/1764] NN clusterizer: Bug fixes for MC labels (#14677)

* Bug-fix for MC labels

* Switch on timers on CPU for the first four lanes

* Improved boundary checking for input filling and cluster publishing

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../Global/GPUChainTrackingClusterizer.cxx    |  18 +-
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |   4 +
 .../GPUTPCNNClusterizerHost.cxx               |   5 +-
 .../GPUTPCNNClusterizerHost.h                 |   2 +-
 .../GPUTPCNNClusterizerKernels.cxx            | 160 +++++++++++++++---
 .../GPUTPCNNClusterizerKernels.h              |   1 +
 6 files changed, 155 insertions(+), 35 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 99f1d93796752..619940ff6d3dd 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -709,6 +709,8 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         LOG(info) << "(ORT) Allocated ONNX stream for lane " << lane << " and device " << deviceId;
       }
     });
+    const int16_t maxFragmentLen = GetProcessingSettings().overrideClusterizerFragmentLen;
+    const uint32_t maxAllowedTimebin = param().par.continuousTracking ? std::max<int32_t>(param().continuousMaxTimeBin, maxFragmentLen) : TPC_MAX_TIME_BIN_TRIGGERED;
     for (int32_t sector = 0; sector < NSECTORS; sector++) {
       GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[sector];
       GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[sector] : clustererNN;
@@ -716,12 +718,12 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
       clustererNN.mDeviceId = deviceId;
       clustererNN.mISector = sector;
       clustererNN.mNnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
-      nnApplications[lane].initClusterizer(nn_settings, clustererNN);
+      nnApplications[lane].initClusterizer(nn_settings, clustererNN, maxFragmentLen, maxAllowedTimebin);
       if (doGPU) {
         clustererNNShadow.mDeviceId = deviceId;
         clustererNNShadow.mISector = sector;
         clustererNNShadow.mNnClusterizerTotalClusters = processors()->tpcClusterer[lane].mNMaxClusters;
-        nnApplications[lane].initClusterizer(nn_settings, clustererNNShadow);
+        nnApplications[lane].initClusterizer(nn_settings, clustererNNShadow, maxFragmentLen, maxAllowedTimebin);
       }
       if (nn_settings.nnClusterizerVerbosity > 2) {
         LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Processor initialized. Sector " << sector << ", lane " << lane << ", max clusters " << clustererNN.mNnClusterizerTotalClusters << " (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
@@ -1051,7 +1053,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
             // NN evaluations
             if(clustererNNShadow.mNnClusterizerUseClassification) {
-              if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane]->Start(); }
+              if(GetProcessingSettings().debugLevel >= 1 && (doGPU || lane < 4)) { nnTimers[3*lane]->Start(); }
               if (clustererNNShadow.mNnInferenceInputDType == 0) {
                 if (clustererNNShadow.mNnInferenceOutputDType == 0) {
                   (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mModelProbabilities_16);
@@ -1065,13 +1067,13 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                   (nnApplication.mModelClass).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mModelProbabilities_32);
                 }
               }
-              if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane]->Stop(); }
+              if(GetProcessingSettings().debugLevel >= 1 && (doGPU || lane < 4)) { nnTimers[3*lane]->Stop(); } // doGPU || lane<4 -> only for GPU or first 4 CPU lanes (to limit number of concurrent timers). At least gives some statistics for CPU time...
               if (nn_settings.nnClusterizerVerbosity > 3) {
                 LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Done with NN classification inference. Loop=" << batch << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
               }
             }
             if (!clustererNNShadow.mNnClusterizerUseCfRegression) {
-              if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 1]->Start(); }
+              if(GetProcessingSettings().debugLevel >= 1 && (doGPU || lane < 4)) { nnTimers[3*lane + 1]->Start(); }
               if (clustererNNShadow.mNnInferenceInputDType == 0) {
                 if (clustererNNShadow.mNnInferenceOutputDType == 0) {
                   (nnApplication.mModelReg1).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mOutputDataReg1_16);
@@ -1085,9 +1087,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                   (nnApplication.mModelReg1).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mOutputDataReg1_32);
                 }
               }
-              if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 1]->Stop(); }
+              if(GetProcessingSettings().debugLevel >= 1 && (doGPU || lane < 4)) { nnTimers[3*lane + 1]->Stop(); }
               if (nnApplication.mModelClass.getNumOutputNodes()[0][1] > 1 && nnApplication.mModelReg2.isInitialized()) {
-                if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 2]->Start(); }
+                if(GetProcessingSettings().debugLevel >= 1 && (doGPU || lane < 4)) { nnTimers[3*lane + 2]->Start(); }
                 if (clustererNNShadow.mNnInferenceInputDType == 0) {
                   if (clustererNNShadow.mNnInferenceOutputDType == 0) {
                     (nnApplication.mModelReg2).inference(clustererNNShadow.mInputData_16, iSize, clustererNNShadow.mOutputDataReg2_16);
@@ -1101,7 +1103,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
                     (nnApplication.mModelReg2).inference(clustererNNShadow.mInputData_32, iSize, clustererNNShadow.mOutputDataReg2_32);
                   }
                 }
-                if(GetProcessingSettings().debugLevel >= 1 && doGPU) { nnTimers[3*lane + 2]->Stop(); }
+                if(GetProcessingSettings().debugLevel >= 1 && (doGPU || lane < 4)) { nnTimers[3*lane + 2]->Stop(); }
               }
               if (nn_settings.nnClusterizerVerbosity > 3) {
                 LOG(info) << "(NNCLUS, GPUChainTrackingClusterizer, this=" << this << ") Done with NN regression inference. Loop=" << batch << ". (clustererNN=" << &clustererNN << ", clustererNNShadow=" << &clustererNNShadow << ")";
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index a6b0b081fc3dd..0b9553437765c 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -60,6 +60,10 @@ class GPUTPCNNClusterizer : public GPUProcessor
   int32_t mISector = -1;
   int32_t mDeviceId = -1;
 
+  // charge array boundaries
+  int32_t maxFragmentLen = -1;
+  int32_t maxAllowedTimebin = -1; // == tpcMaxTimeBin
+
   // GPU optimizations
   uint32_t mNnClusterizerFullRowSize = 0;
   uint32_t mNnClusterizerFullPadSize = 0;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index ad635c15b9256..ae833ace2f648 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -21,6 +21,7 @@
 #include "GPUReconstruction.h"
 #include "GPUTPCGeometry.h"
 #include "DataFormatsTPC/Constants.h"
+#include "clusterFinderDefs.h"
 
 #ifdef GPUCA_HAS_ONNX
 #include <onnxruntime_cxx_api.h>
@@ -84,7 +85,7 @@ void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& set
   }
 }
 
-void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclusterizer& settings, GPUTPCNNClusterizer& clustererNN)
+void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclusterizer& settings, GPUTPCNNClusterizer& clustererNN, int32_t maxFragmentLen, int32_t maxAllowedTimebin)
 {
   clustererNN.mNnClusterizerUseCfRegression = settings.nnClusterizerUseCfRegression;
   clustererNN.mNnClusterizerSizeInputRow = settings.nnClusterizerSizeInputRow;
@@ -109,6 +110,8 @@ void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclust
   clustererNN.mNnSigmoidTrafoClassThreshold = settings.nnSigmoidTrafoClassThreshold;
   clustererNN.mNnClusterizerUseClassification = settings.nnClusterizerUseClassification;
   clustererNN.mNnClusterizerSetDeconvolutionFlags = (bool)settings.nnClusterizerSetDeconvolutionFlags;
+  clustererNN.maxFragmentLen = maxFragmentLen == -1 ? TPC_MAX_FRAGMENT_LEN_GPU : maxFragmentLen;
+  clustererNN.maxAllowedTimebin = maxAllowedTimebin == -1 ? TPC_MAX_FRAGMENT_LEN_GPU : maxAllowedTimebin;
   if (clustererNN.mNnSigmoidTrafoClassThreshold) {
     clustererNN.mNnClassThreshold = (float)std::log(settings.nnClassThreshold / (1.f - settings.nnClassThreshold));
   } else {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
index 414c4539a33c1..8f8465d5dca34 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.h
@@ -48,7 +48,7 @@ class GPUTPCNNClusterizerHost
   GPUTPCNNClusterizerHost(const GPUSettingsProcessingNNclusterizer& settings, bool useDeterministicMode = false) { init(settings, useDeterministicMode); }
 
   void init(const GPUSettingsProcessingNNclusterizer&, bool = false);
-  void initClusterizer(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&);
+  void initClusterizer(const GPUSettingsProcessingNNclusterizer&, GPUTPCNNClusterizer&, int32_t = -1, int32_t = -1);
   void createBoundary(GPUTPCNNClusterizer&);
   void createIndexLookup(GPUTPCNNClusterizer&);
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 15ee6b6119022..55fefa7dcf149 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -46,7 +46,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::run
   auto& clustererNN = processors.tpcNNClusterer[sector];
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CPU_ONLY(MCLabelAccumulator labelAcc(clusterer));
-  tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
+  tpc::ClusterNative* clusterOut = clusterer.mPclusterByRow;
   int8_t isAccepted = (clustererNN.mNnClusterizerUseClassification ? (clustererNN.mOutputDataClass[CAMath::Min(glo_idx, (uint32_t)clusterer.mPmemory->counters.nClusters - 1)] > 0) : 1);
   GPUTPCCFClusterizer::computeClustersImpl(get_num_groups(0), get_local_size(0), get_group_id(0), get_local_id(0), clusterer, clusterer.mPmemory->fragment, reinterpret_cast<GPUTPCCFClusterizer::GPUSharedMemory&>(smem), chargeMap, clusterer.mPfilteredPeakPositions, clusterer.Param().rec, CPU_PTR(&labelAcc), clusterer.mPmemory->counters.nClusters, clusterer.mNMaxClusterPerRow, clusterer.mPclusterInRow, clusterOut, clusterer.mPclusterPosInRow, isAccepted);
 }
@@ -85,7 +85,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
       for (int32_t t = -clustererNN.mNnClusterizerSizeInputTime; t <= clustererNN.mNnClusterizerSizeInputTime; ++t) {
         int32_t target_time = time + t;
 
-        if (is_boundary || target_time < 0 || target_time >= TPC_MAX_FRAGMENT_LEN_GPU) {
+        if (is_boundary || target_time < 0 || target_time >= clustererNN.maxAllowedTimebin) {
           // Fill boundary value
           float boundary_value = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
           if (dtype == 0) {
@@ -229,7 +229,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
       int32_t target_time = time + t_local;
 
       // Optimized boundary check
-      int8_t is_boundary = GPUTPCNNClusterizerKernels::isBoundary(target_row + row_offset, target_pad, clustererNN.mNnClusterizerSizeInputRow) || (target_time < 0) || (target_time >= TPC_MAX_FRAGMENT_LEN_GPU);
+      int8_t is_boundary = GPUTPCNNClusterizerKernels::isBoundary(target_row + row_offset, target_pad, clustererNN.mNnClusterizerSizeInputRow) || (target_time < 0) || (target_time >= clustererNN.maxAllowedTimebin);
 
       float output_value;
       if (is_boundary) {
@@ -340,7 +340,8 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   int32_t model_output_index = glo_idx * clustererNN.mNnClusterizerModelReg1NumOutputNodes;
 
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-  CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(full_glo_idx, maxClusterNum - 1)];
+  uint32_t peakIndex = CAMath::Min(full_glo_idx, maxClusterNum - 1);
+  CfChargePos peak = clusterer.mPfilteredPeakPositions[peakIndex];
   float central_charge = static_cast<float>(chargeMap[peak].unpack());
 
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
@@ -365,11 +366,8 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
   tpc::ClusterNative* clusterOut = clusterer.mPclusterByRow;
 
-  // LOG(info) << glo_idx << " -- " << model_output_index << " / " << clustererNN.outputDataReg1.size() << " / " << clustererNN.mNnClusterizerModelReg1NumOutputNodes << " -- " << clusterer.peakPositions.size() << " -- " << clusterer.centralCharges.size();
-
   ClusterAccumulator pc;
 
-  // Publishing logic is taken from default clusterizer
   if (withMC) {
     ClusterAccumulator dummy_pc;
     CPU_ONLY(labelAcc->collect(peak, central_charge));
@@ -390,37 +388,113 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
     return;
   }
 
-  // For flag influence on cluster error setting: O2/GPU/GPUTracking/Base/GPUParam.inc -> UpdateClusterError2ByState
   bool notSinglePad = false, notSingleTime = false;
   for (uint16_t i = 0; i < 8; i++) {
     Delta2 d = cfconsts::InnerNeighbors[i];
     CfChargePos tmp_pos = peak.delta(d);
-    notSinglePad |= (d.x != 0) && (static_cast<float>(chargeMap[tmp_pos].unpack()) > 0);
-    notSingleTime |= (d.y != 0) && (static_cast<float>(chargeMap[tmp_pos].unpack()) > 0);
+    float v = static_cast<float>(chargeMap[tmp_pos].unpack());
+    notSinglePad |= (d.x != 0) && (v > 0.f);
+    notSingleTime |= (d.y != 0) && (v > 0.f);
   }
 
+  float publishPadPosition = 0.f, publishTimePosition = 0.f;
   if (dtype == 0) {
+    publishPadPosition = static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_16[model_output_index].ToFloat();
+    publishTimePosition = static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_16[model_output_index + 1].ToFloat();
+    isBoundaryPublish(full_glo_idx, static_cast<int32_t>(peak.row()), publishPadPosition, publishTimePosition);
     pc.setFull(central_charge * clustererNN.mOutputDataReg1_16[model_output_index + 4].ToFloat(),
-               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_16[model_output_index].ToFloat(),
+               publishPadPosition,
                notSinglePad ? clustererNN.mOutputDataReg1_16[model_output_index + 2].ToFloat() : 0.f,
-               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_16[model_output_index + 1].ToFloat(),
+               (clusterer.mPmemory->fragment).start + publishTimePosition,
                notSingleTime ? clustererNN.mOutputDataReg1_16[model_output_index + 3].ToFloat() : 0.f,
                clustererNN.mClusterFlags[2 * glo_idx],
                clustererNN.mClusterFlags[2 * glo_idx + 1]);
-  } else if (dtype == 1) {
+  } else {
+    publishPadPosition = static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_32[model_output_index];
+    publishTimePosition = static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_32[model_output_index + 1];
+    isBoundaryPublish(full_glo_idx, static_cast<int32_t>(peak.row()), publishPadPosition, publishTimePosition);
     pc.setFull(central_charge * clustererNN.mOutputDataReg1_32[model_output_index + 4],
-               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg1_32[model_output_index],
+               publishPadPosition,
                notSinglePad ? clustererNN.mOutputDataReg1_32[model_output_index + 2] : 0.f,
-               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg1_32[model_output_index + 1],
+               (clusterer.mPmemory->fragment).start + publishTimePosition,
                notSingleTime ? clustererNN.mOutputDataReg1_32[model_output_index + 3] : 0.f,
                clustererNN.mClusterFlags[2 * glo_idx],
                clustererNN.mClusterFlags[2 * glo_idx + 1]);
   }
 
+  // if (boundaryFlag != 0) { // Prints the entire NN input for the given index
+  //   // Build a simple buffer manually (float with 3 decimals)
+  //   const int MAX_CHARS = 4096;
+  //   char buffer[MAX_CHARS];
+  //   int pos = 0;
+  //
+  //   auto appendChar = [&](char c) {
+  //     if (pos < MAX_CHARS - 1) buffer[pos++] = c;
+  //   };
+  //   auto appendStr = [&](const char* s) {
+  //     while (*s && pos < MAX_CHARS - 1) buffer[pos++] = *s++;
+  //   };
+  //   auto appendUInt = [&](uint32_t v) {
+  //     char tmp[16]; int tp = 0;
+  //     if (v == 0) { appendChar('0'); return; }
+  //     while (v && tp < 16) { tmp[tp++] = char('0' + (v % 10)); v /= 10; }
+  //     while (tp--) appendChar(tmp[tp]);
+  //   };
+  //   auto appendInt = [&](int v) {
+  //     if (v < 0) { appendChar('-'); v = -v; }
+  //     appendUInt((uint32_t)v);
+  //   };
+  //   auto appendFloat = [&](float f) {
+  //     if (f < 0) { appendChar('-'); f = -f; }
+  //     int ip = (int)f;
+  //     float frac = f - (float)ip;
+  //     appendInt(ip);
+  //     appendChar('.');
+  //     for (int i = 0; i < 3; i++) {
+  //       frac *= 10.f;
+  //       int d = (int)frac;
+  //       appendChar((char)('0' + (d < 0 ? 0 : (d > 9 ? 9 : d))));
+  //       frac -= d;
+  //       if (frac < 0) frac = 0;
+  //     }
+  //   };
+  //
+  //   appendStr("(NN CLUS) DEBUG: Boundary cluster detected (sector ");
+  //   appendUInt(sector);
+  //   appendStr(", row ");
+  //   appendUInt(peak.row());
+  //   appendStr(", pad ");
+  //   appendFloat(publishPadPosition);
+  //   appendStr(", time ");
+  //   appendFloat(publishTimePosition);
+  //   appendStr(") [glo_idx=");
+  //   appendUInt(glo_idx);
+  //   appendStr(" elemSize=");
+  //   appendInt(clustererNN.mNnClusterizerElementSize);
+  //   appendStr(" dtype=");
+  //   appendInt(dtype);
+  //   appendStr("] INPUT:");
+  //
+  //   int elemSize = clustererNN.mNnClusterizerElementSize;
+  //   int baseIdx = glo_idx * elemSize;
+  //
+  //   int maxPrint = elemSize;
+  //   for (int i = 0; i < maxPrint; ++i) {
+  //     appendChar(' ');
+  //     float v = (dtype == 0) ? clustererNN.mInputData_16[baseIdx + i].ToFloat()
+  //                            : clustererNN.mInputData_32[baseIdx + i];
+  //     appendFloat(v);
+  //     if (pos > (MAX_CHARS - 32)) { appendStr(" ..."); break; }
+  //   }
+  //
+  //   buffer[pos] = 0;
+  //   printf("%s\n", buffer);
+  // }
+
   tpc::ClusterNative myCluster;
   bool rejectCluster = !pc.toNative(peak, central_charge, myCluster, clusterer.Param(), chargeMap);
   if (clustererNN.mNnClusterizerUseClassification) {
-    rejectCluster |= (clustererNN.mOutputDataClass[CAMath::Min(full_glo_idx, (uint32_t)clusterer.mPmemory->counters.nClusters - 1)] <= 0);
+    rejectCluster |= (clustererNN.mOutputDataClass[peakIndex] <= 0);
   }
   if (rejectCluster) {
     if (clusterer.mPclusterPosInRow) {
@@ -464,7 +538,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
   CPU_ONLY(MCLabelAccumulator labelAccElem(clusterer));
   MCLabelAccumulator* labelAcc = CPU_PTR(&labelAccElem);
-  tpc::ClusterNative* clusterOut = (withMC) ? nullptr : clusterer.mPclusterByRow;
+  tpc::ClusterNative* clusterOut = clusterer.mPclusterByRow;
   uint32_t full_glo_idx = glo_idx + batchStart;
 
   if (full_glo_idx >= maxClusterNum) {
@@ -509,19 +583,26 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
   }
 
   // Cluster 1
+  float publishPadPosition = 0.f, publishTimePosition = 0.f;
   if (dtype == 0) {
+    publishPadPosition = static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index].ToFloat();
+    publishTimePosition = static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 1].ToFloat();
+    isBoundaryPublish(full_glo_idx, static_cast<int32_t>(peak.row()), publishPadPosition, publishTimePosition);
     pc.setFull(central_charge * clustererNN.mOutputDataReg2_16[model_output_index + 8].ToFloat(),
-               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index].ToFloat(),
+               publishPadPosition,
                clustererNN.mOutputDataReg2_16[model_output_index + 4].ToFloat(),
-               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 2].ToFloat(),
+               (clusterer.mPmemory->fragment).start + publishTimePosition,
                clustererNN.mOutputDataReg2_16[model_output_index + 6].ToFloat(),
                clustererNN.mClusterFlags[2 * glo_idx],
                clustererNN.mClusterFlags[2 * glo_idx + 1]);
   } else if (dtype == 1) {
+    publishPadPosition = static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index];
+    publishTimePosition = static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 1];
+    isBoundaryPublish(full_glo_idx, static_cast<int32_t>(peak.row()), publishPadPosition, publishTimePosition);
     pc.setFull(central_charge * clustererNN.mOutputDataReg2_32[model_output_index + 8],
-               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index],
+               publishPadPosition,
                clustererNN.mOutputDataReg2_32[model_output_index + 4],
-               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 2],
+               (clusterer.mPmemory->fragment).start + publishTimePosition,
                clustererNN.mOutputDataReg2_32[model_output_index + 6],
                clustererNN.mClusterFlags[2 * glo_idx],
                clustererNN.mClusterFlags[2 * glo_idx + 1]);
@@ -558,18 +639,24 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::pub
 
   // Cluster 2
   if (dtype == 0) {
+    publishPadPosition = static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index + 1].ToFloat();
+    publishTimePosition = static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 3].ToFloat();
+    isBoundaryPublish(full_glo_idx, static_cast<int32_t>(peak.row()), publishPadPosition, publishTimePosition);
     pc.setFull(central_charge * clustererNN.mOutputDataReg2_16[model_output_index + 9].ToFloat(),
-               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_16[model_output_index + 1].ToFloat(),
+               publishPadPosition,
                clustererNN.mOutputDataReg2_16[model_output_index + 5].ToFloat(),
-               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_16[model_output_index + 3].ToFloat(),
+               (clusterer.mPmemory->fragment).start + publishTimePosition,
                clustererNN.mOutputDataReg2_16[model_output_index + 7].ToFloat(),
                clustererNN.mClusterFlags[2 * glo_idx],
                clustererNN.mClusterFlags[2 * glo_idx + 1]);
   } else if (dtype == 1) {
+    publishPadPosition = static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index + 1];
+    publishTimePosition = static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 3];
+    isBoundaryPublish(full_glo_idx, static_cast<int32_t>(peak.row()), publishPadPosition, publishTimePosition);
     pc.setFull(central_charge * clustererNN.mOutputDataReg2_32[model_output_index + 9],
-               static_cast<float>(peak.pad()) + clustererNN.mOutputDataReg2_32[model_output_index + 1],
+               publishPadPosition,
                clustererNN.mOutputDataReg2_32[model_output_index + 5],
-               (clusterer.mPmemory->fragment).start + static_cast<float>(peak.time()) + clustererNN.mOutputDataReg2_32[model_output_index + 3],
+               (clusterer.mPmemory->fragment).start + publishTimePosition,
                clustererNN.mOutputDataReg2_32[model_output_index + 7],
                clustererNN.mClusterFlags[2 * glo_idx],
                clustererNN.mClusterFlags[2 * glo_idx + 1]);
@@ -664,3 +751,26 @@ GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int32_t row, int32_t pad, int
     return true;
   }
 }
+
+GPUd() bool GPUTPCNNClusterizerKernels::isBoundaryPublish(int32_t idx, int32_t row, float& pad, float& time)
+{
+  if (pad < 0) {
+    // printf("(NN CLUS) WARNING: Boundary detected, idx = %d, pad < 0: row %d, pad %f (%d, %d), time %f (%d, %d)\n", idx, row, pad, 0, static_cast<int>(GPUTPCGeometry::NPads(row)), time, 0, TPC_MAX_FRAGMENT_LEN_GPU);
+    pad = 0.f;
+    return true;
+  } else if (pad >= static_cast<int>(GPUTPCGeometry::NPads(row))) {
+    // printf("(NN CLUS) WARNING: Boundary detected, idx = %d, pad >= static_cast<int>(GPUTPCGeometry::NPads(row): row %d, pad %f (%d, %d), time %f (%d, %d)\n", idx, row, pad, 0, static_cast<int>(GPUTPCGeometry::NPads(row)), time, 0, TPC_MAX_FRAGMENT_LEN_GPU);
+    pad = static_cast<float>(GPUTPCGeometry::NPads(row) - 1);
+    return true;
+  } else if (time < 0) {
+    // printf("(NN CLUS) WARNING: Boundary detected, idx = %d, time < 0: row %d, pad %f (%d, %d), time %f (%d, %d)\n", idx, row, pad, 0, static_cast<int>(GPUTPCGeometry::NPads(row)), time, 0, TPC_MAX_FRAGMENT_LEN_GPU);
+    time = 0.f;
+    return true;
+  } else if (time >= TPC_MAX_FRAGMENT_LEN_GPU) {
+    // printf("(NN CLUS) WARNING: Boundary detected, idx = %d, time >= TPC_MAX_FRAGMENT_LEN_GPU: row %d, pad %f (%d, %d), time %f (%d, %d)\n", idx, row, pad, 0, static_cast<int>(GPUTPCGeometry::NPads(row)), time, 0, TPC_MAX_FRAGMENT_LEN_GPU);
+    time = static_cast<float>(TPC_MAX_FRAGMENT_LEN_GPU - 1);
+    return true;
+  } else {
+    return false;
+  }
+}
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index 9c93726a097b7..cd3d7783771fe 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -67,6 +67,7 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
   static GPUd() int32_t padOffset(int32_t, int32_t);
   static GPUd() int32_t rowOffset(int32_t, int32_t);
   static GPUd() bool isBoundary(int32_t, int32_t, int32_t);
+  static GPUd() bool isBoundaryPublish(int32_t, int32_t, float&, float&);
 };
 
 } // namespace o2::gpu

From d45eac141fb162f379e839a3d096c73b31be544c Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 18 Sep 2025 10:29:34 +0200
Subject: [PATCH 0856/1764] dpl-workflow.sh: dump raw data for GPU crashes by
 default in online

---
 prodtests/full-system-test/dpl-workflow.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 17a085bf7da96..996ab70da8f6c 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -222,6 +222,9 @@ has_detector_flp_processing CPV && CPV_INPUT=digits
 ! has_detector_flp_processing TOF && TOF_CONFIG+=" --local-cmp"
 
 if [[ $EPNSYNCMODE == 1 ]]; then
+  # dump raw data in case of GPU crash and set dump directory size limits; files are automatically cleaned by EPN after 60 days
+  GPU_CONFIG_KEY+="GPU_proc.debugOnFailure=1;GPU_proc.debugOnFailureDirectory=/data/tf/debug;GPU_proc.debugOnFailureMaxFiles=1000;GPU_proc.debugOnFailureMaxSize=500;GPU_proc.debugOnFailureSignalMask=2240;"
+
   EVE_OPT+=" --eve-dds-collection-index 0"
   MIDDEC_CONFIG+=" --feeId-config-file \"$MID_FEEID_MAP\""
   if [[ $EXTINPUT == 1 ]] && [[ $GPUTYPE != "CPU" ]] && [[ -z "$GPU_NUM_MEM_REG_CALLBACKS" ]]; then

From 17da5226dbfeff7d8c00d9cb243d8ffb9dcd03e4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 18 Sep 2025 14:43:58 +0200
Subject: [PATCH 0857/1764] GPU CMake: Bump default CUDA architecture to 75 to
 support CUDA 13

---
 dependencies/FindO2GPU.cmake | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 032d02aabe5db..51812fc84ef1a 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 2
+# FindO2GPU.cmake Version 3
 
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
@@ -109,7 +109,7 @@ if(ENABLE_CUDA)
   if(CUDA_COMPUTETARGET)
     set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET})
   else()
-    set(CMAKE_CUDA_ARCHITECTURES 61-virtual)
+    set(CMAKE_CUDA_ARCHITECTURES 75-virtual)
   endif()
   set(CMAKE_CUDA_STANDARD ${CMAKE_CXX_STANDARD})
   set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)

From 28eb74a0515157a0597f876c0e2a0bbbd60a721f Mon Sep 17 00:00:00 2001
From: Marvin Hemmer <53471402+mhemmer-cern@users.noreply.github.com>
Date: Sun, 21 Sep 2025 18:25:45 +0200
Subject: [PATCH 0858/1764] [Framework] Configurable.h: Fix
 PROCESS_SWITCH(_FULL) namespace issue (#14670)

---
 Framework/Core/include/Framework/Configurable.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/Configurable.h b/Framework/Core/include/Framework/Configurable.h
index f72d2f3a2a7d6..3ef90a0eee166 100644
--- a/Framework/Core/include/Framework/Configurable.h
+++ b/Framework/Core/include/Framework/Configurable.h
@@ -114,9 +114,9 @@ template <typename T>
 concept is_process_configurable = is_configurable<T> && requires(T& t) { t.process; };
 
 #define PROCESS_SWITCH(_Class_, _Name_, _Help_, _Default_) \
-  decltype(ProcessConfigurable{&_Class_ ::_Name_, #_Name_, _Default_, _Help_}) do##_Name_ = ProcessConfigurable{&_Class_ ::_Name_, #_Name_, _Default_, _Help_};
+  decltype(o2::framework::ProcessConfigurable{&_Class_ ::_Name_, #_Name_, _Default_, _Help_}) do##_Name_ = o2::framework::ProcessConfigurable{&_Class_ ::_Name_, #_Name_, _Default_, _Help_};
 #define PROCESS_SWITCH_FULL(_Class_, _Method_, _Name_, _Help_, _Default_) \
-  decltype(ProcessConfigurable{&_Class_ ::_Method_, #_Name_, _Default_, _Help_}) do##_Name_ = ProcessConfigurable{&_Class_ ::_Method_, #_Name_, _Default_, _Help_};
+  decltype(o2::framework::ProcessConfigurable{&_Class_ ::_Method_, #_Name_, _Default_, _Help_}) do##_Name_ = o2::framework::ProcessConfigurable{&_Class_ ::_Method_, #_Name_, _Default_, _Help_};
 
 template <typename T, ConfigParamKind K, typename IP>
 std::ostream& operator<<(std::ostream& os, Configurable<T, K, IP> const& c)

From cbeaeabc846ffff34f4f014dcf9e3a53d681160d Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Mon, 22 Sep 2025 10:54:21 +0200
Subject: [PATCH 0859/1764] DPL: add possibility to disable downscaling of
 processing reporting by env variable (#14656)

---
 Framework/Core/src/CallbacksPolicy.cxx | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/CallbacksPolicy.cxx b/Framework/Core/src/CallbacksPolicy.cxx
index aa22fa830c4c2..5e7bd7bc8306a 100644
--- a/Framework/Core/src/CallbacksPolicy.cxx
+++ b/Framework/Core/src/CallbacksPolicy.cxx
@@ -23,7 +23,7 @@
 namespace o2::framework
 {
 
-static bool checkPrescale(const TimingInfo& info, int prescale, bool startProcessing)
+static bool checkPrescale(const TimingInfo& info, int prescale, bool startProcessing, bool noDownscaling)
 {
   if (prescale <= 1) {
     static size_t counter = 0;
@@ -31,7 +31,7 @@ static bool checkPrescale(const TimingInfo& info, int prescale, bool startProces
     if (startProcessing) {
       counter++;
     }
-    if (counter <= 100000) {
+    if (counter <= 100000 || noDownscaling) {
       return true;
     }
     if (counter > 100000 * downscaleFactor) {
@@ -53,6 +53,8 @@ CallbacksPolicy epnProcessReporting()
   if (!prescale) {
     prescale = 1;
   }
+  static bool noDownscaling = getenv("DPL_REPORT_PROCESSING_NO_DOWNSCALING") != nullptr && std::abs(atoi(getenv("DPL_REPORT_PROCESSING_NO_DOWNSCALING")));
+
   return {
     .matcher = [forceReport](DeviceSpec const&, ConfigContext const& context) -> bool {
       static bool report = DefaultsHelpers::deploymentMode() == DeploymentMode::OnlineDDS || forceReport;
@@ -61,7 +63,7 @@ CallbacksPolicy epnProcessReporting()
     .policy = [prescale](CallbackService& callbacks, InitContext& context) -> void {
       callbacks.set<CallbackService::Id::PreProcessing>([prescale](ServiceRegistryRef registry, int op) {
         auto& info = registry.get<TimingInfo>();
-        if ((int)info.firstTForbit != -1 && checkPrescale(info, prescale, true)) {
+        if ((int)info.firstTForbit != -1 && checkPrescale(info, prescale, true, noDownscaling)) {
           char const* what = info.isTimer() ? "timer" : "timeslice";
           LOGP(info, "Processing {}:{}, tfCounter:{}, firstTForbit:{}, runNumber:{}, creation:{}, action:{}",
                what, info.timeslice, info.tfCounter, info.firstTForbit, info.runNumber, info.creation, op);
@@ -70,7 +72,7 @@ CallbacksPolicy epnProcessReporting()
       });
       callbacks.set<CallbackService::Id::PostProcessing>([prescale](ServiceRegistryRef registry, int op) {
         auto& info = registry.get<TimingInfo>();
-        if ((int)info.firstTForbit != -1 && checkPrescale(info, prescale, false)) {
+        if ((int)info.firstTForbit != -1 && checkPrescale(info, prescale, false, noDownscaling)) {
           char const* what = info.isTimer() ? "timer" : "timeslice";
           LOGP(info, "Done processing {}:{}, tfCounter:{}, firstTForbit:{}, runNumber:{}, creation:{}, action:{}, wall:{}",
                what, info.timeslice, info.tfCounter, info.firstTForbit, info.runNumber, info.creation, op, uv_hrtime() - info.lapse);

From e019d1aaa21bc3dfa1267d7c1597a503f439c7e6 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 22 Sep 2025 14:46:16 +0200
Subject: [PATCH 0860/1764] ITS: simplify parallel_for loops (#14648)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 301 ++++++++----------
 .../ITS/tracking/src/VertexerTraits.cxx       | 148 ++++-----
 2 files changed, 194 insertions(+), 255 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 83210d474ed9f..46a64adf5fa2f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -212,14 +212,10 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
           }
         });
 
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
-        [&](auto const& Layers) {
-          for (int iLayer{Layers.begin()}; iLayer < Layers.end(); ++iLayer) {
-            std::exclusive_scan(perROFCount[iLayer].begin(), perROFCount[iLayer].end(), perROFCount[iLayer].begin(), 0);
-            mTimeFrame->getTracklets()[iLayer].resize(perROFCount[iLayer].back());
-          }
-        });
+      tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
+        std::exclusive_scan(perROFCount[iLayer].begin(), perROFCount[iLayer].end(), perROFCount[iLayer].begin(), 0);
+        mTimeFrame->getTracklets()[iLayer].resize(perROFCount[iLayer].back());
+      });
 
       tbb::parallel_for(
         tbb::blocked_range2d<int, int>(0, mTrkParams[iteration].TrackletsPerRoad(), 1,
@@ -241,61 +237,53 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
         });
     }
 
-    tbb::parallel_for(
-      tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
-      [&](const tbb::blocked_range<int>& Layers) {
-        for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
-          /// Sort tracklets
-          auto& trkl{mTimeFrame->getTracklets()[iLayer]};
-          tbb::parallel_sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
-            if (a.firstClusterIndex != b.firstClusterIndex) {
-              return a.firstClusterIndex < b.firstClusterIndex;
-            }
-            return a.secondClusterIndex < b.secondClusterIndex;
-          });
-          /// Remove duplicates
-          trkl.erase(std::unique(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
-                       return a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex == b.secondClusterIndex;
-                     }),
-                     trkl.end());
-          trkl.shrink_to_fit();
-          if (iLayer > 0) { /// recalculate lut
-            auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer - 1]};
-            if (!trkl.empty()) {
-              for (const auto& tkl : trkl) {
-                lut[tkl.firstClusterIndex + 1]++;
-              }
-              std::inclusive_scan(lut.begin(), lut.end(), lut.begin());
-            }
-          }
+    tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
+      /// Sort tracklets
+      auto& trkl{mTimeFrame->getTracklets()[iLayer]};
+      tbb::parallel_sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
+        if (a.firstClusterIndex != b.firstClusterIndex) {
+          return a.firstClusterIndex < b.firstClusterIndex;
         }
+        return a.secondClusterIndex < b.secondClusterIndex;
       });
+      /// Remove duplicates
+      trkl.erase(std::unique(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
+                   return a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex == b.secondClusterIndex;
+                 }),
+                 trkl.end());
+      trkl.shrink_to_fit();
+      if (iLayer > 0) { /// recalculate lut
+        auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer - 1]};
+        if (!trkl.empty()) {
+          for (const auto& tkl : trkl) {
+            lut[tkl.firstClusterIndex + 1]++;
+          }
+          std::inclusive_scan(lut.begin(), lut.end(), lut.begin());
+        }
+      }
+    });
 
     /// Create tracklets labels
     if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, mTrkParams[iteration].TrackletsPerRoad()),
-        [&](const tbb::blocked_range<int>& Layers) {
-          for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
-            for (auto& trk : mTimeFrame->getTracklets()[iLayer]) {
-              MCCompLabel label;
-              int currentId{mTimeFrame->getClusters()[iLayer][trk.firstClusterIndex].clusterId};
-              int nextId{mTimeFrame->getClusters()[iLayer + 1][trk.secondClusterIndex].clusterId};
-              for (const auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
-                for (const auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
-                  if (lab1 == lab2 && lab1.isValid()) {
-                    label = lab1;
-                    break;
-                  }
-                }
-                if (label.isValid()) {
-                  break;
-                }
+      tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
+        for (auto& trk : mTimeFrame->getTracklets()[iLayer]) {
+          MCCompLabel label;
+          int currentId{mTimeFrame->getClusters()[iLayer][trk.firstClusterIndex].clusterId};
+          int nextId{mTimeFrame->getClusters()[iLayer + 1][trk.secondClusterIndex].clusterId};
+          for (const auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
+            for (const auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
+              if (lab1 == lab2 && lab1.isValid()) {
+                label = lab1;
+                break;
               }
-              mTimeFrame->getTrackletsLabel(iLayer).emplace_back(label);
+            }
+            if (label.isValid()) {
+              break;
             }
           }
-        });
+          mTimeFrame->getTrackletsLabel(iLayer).emplace_back(label);
+        }
+      });
     }
   });
 } // namespace o2::its
@@ -402,76 +390,60 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
       return foundCells;
     };
 
-    tbb::parallel_for(
-      tbb::blocked_range<int>(0, mTrkParams[iteration].CellsPerRoad()),
-      [&](const tbb::blocked_range<int>& Layers) {
-        for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
-          if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
-              mTimeFrame->getTracklets()[iLayer].empty()) {
-            continue;
-          }
-
-          auto& layerCells = mTimeFrame->getCells()[iLayer];
-          const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
-          bounded_vector<int> perTrackletCount(currentLayerTrackletsNum + 1, 0, mMemoryPool.get());
-          if (mTaskArena->max_concurrency() <= 1) {
-            for (int iTracklet{0}; iTracklet < currentLayerTrackletsNum; ++iTracklet) {
-              perTrackletCount[iTracklet] = forTrackletCells(PassMode::OnePass{}, iLayer, layerCells, iTracklet);
-            }
-            std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
-          } else {
-            tbb::parallel_for(
-              tbb::blocked_range<int>(0, currentLayerTrackletsNum),
-              [&](const tbb::blocked_range<int>& Tracklets) {
-                for (int iTracklet = Tracklets.begin(); iTracklet < Tracklets.end(); ++iTracklet) {
-                  perTrackletCount[iTracklet] = forTrackletCells(PassMode::TwoPassCount{}, iLayer, layerCells, iTracklet);
-                }
-              });
+    tbb::parallel_for(0, mTrkParams[iteration].CellsPerRoad(), [&](const int iLayer) {
+      if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
+          mTimeFrame->getTracklets()[iLayer].empty()) {
+        return;
+      }
 
-            std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
-            auto totalCells{perTrackletCount.back()};
-            if (totalCells == 0) {
-              continue;
-            }
-            layerCells.resize(totalCells);
-
-            tbb::parallel_for(
-              tbb::blocked_range<int>(0, currentLayerTrackletsNum),
-              [&](const tbb::blocked_range<int>& Tracklets) {
-                for (int iTracklet = Tracklets.begin(); iTracklet < Tracklets.end(); ++iTracklet) {
-                  int offset = perTrackletCount[iTracklet];
-                  if (offset == perTrackletCount[iTracklet + 1]) {
-                    continue;
-                  }
-                  forTrackletCells(PassMode::TwoPassInsert{}, iLayer, layerCells, iTracklet, offset);
-                }
-              });
-          }
+      auto& layerCells = mTimeFrame->getCells()[iLayer];
+      const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
+      bounded_vector<int> perTrackletCount(currentLayerTrackletsNum + 1, 0, mMemoryPool.get());
+      if (mTaskArena->max_concurrency() <= 1) {
+        for (int iTracklet{0}; iTracklet < currentLayerTrackletsNum; ++iTracklet) {
+          perTrackletCount[iTracklet] = forTrackletCells(PassMode::OnePass{}, iLayer, layerCells, iTracklet);
+        }
+        std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
+      } else {
+        tbb::parallel_for(0, currentLayerTrackletsNum, [&](const int iTracklet) {
+          perTrackletCount[iTracklet] = forTrackletCells(PassMode::TwoPassCount{}, iLayer, layerCells, iTracklet);
+        });
 
-          if (iLayer > 0) {
-            auto& lut = mTimeFrame->getCellsLookupTable()[iLayer - 1];
-            lut.resize(currentLayerTrackletsNum + 1);
-            std::copy_n(perTrackletCount.begin(), currentLayerTrackletsNum + 1, lut.begin());
-          }
+        std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
+        auto totalCells{perTrackletCount.back()};
+        if (totalCells == 0) {
+          return;
         }
-      });
-  });
+        layerCells.resize(totalCells);
 
-  /// Create cells labels
-  if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
-    tbb::parallel_for(
-      tbb::blocked_range<int>(0, mTrkParams[iteration].CellsPerRoad()),
-      [&](const tbb::blocked_range<int>& Layers) {
-        for (int iLayer = Layers.begin(); iLayer < Layers.end(); ++iLayer) {
-          mTimeFrame->getCellsLabel(iLayer).reserve(mTimeFrame->getCells()[iLayer].size());
-          for (const auto& cell : mTimeFrame->getCells()[iLayer]) {
-            MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
-            MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
-            mTimeFrame->getCellsLabel(iLayer).emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
+        tbb::parallel_for(0, currentLayerTrackletsNum, [&](const int iTracklet) {
+          int offset = perTrackletCount[iTracklet];
+          if (offset == perTrackletCount[iTracklet + 1]) {
+            return;
           }
+          forTrackletCells(PassMode::TwoPassInsert{}, iLayer, layerCells, iTracklet, offset);
+        });
+      }
+
+      if (iLayer > 0) {
+        auto& lut = mTimeFrame->getCellsLookupTable()[iLayer - 1];
+        lut.resize(currentLayerTrackletsNum + 1);
+        std::copy_n(perTrackletCount.begin(), currentLayerTrackletsNum + 1, lut.begin());
+      }
+    });
+
+    /// Create cells labels
+    if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
+      tbb::parallel_for(0, mTrkParams[iteration].CellsPerRoad(), [&](const int iLayer) {
+        mTimeFrame->getCellsLabel(iLayer).reserve(mTimeFrame->getCells()[iLayer].size());
+        for (const auto& cell : mTimeFrame->getCells()[iLayer]) {
+          MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
+          MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
+          mTimeFrame->getCellsLabel(iLayer).emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
         }
       });
-  }
+    }
+  });
 }
 
 template <int nLayers>
@@ -554,13 +526,9 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
         }
       } else {
         bounded_vector<int> perCellCount(nCells + 1, 0, mMemoryPool.get());
-        tbb::parallel_for(
-          tbb::blocked_range<int>(0, nCells),
-          [&](const tbb::blocked_range<int>& Cells) {
-            for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
-              perCellCount[iCell] = forCellNeighbour(PassMode::TwoPassCount{}, iCell);
-            }
-          });
+        tbb::parallel_for(0, nCells, [&](const int iCell) {
+          perCellCount[iCell] = forCellNeighbour(PassMode::TwoPassCount{}, iCell);
+        });
 
         std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
         int totalCellNeighbours = perCellCount.back();
@@ -570,17 +538,13 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
         }
         cellsNeighbours.resize(totalCellNeighbours);
 
-        tbb::parallel_for(
-          tbb::blocked_range<int>(0, nCells),
-          [&](const tbb::blocked_range<int>& Cells) {
-            for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
-              int offset = perCellCount[iCell];
-              if (offset == perCellCount[iCell + 1]) {
-                continue;
-              }
-              forCellNeighbour(PassMode::TwoPassInsert{}, iCell, offset);
-            }
-          });
+        tbb::parallel_for(0, nCells, [&](const int iCell) {
+          int offset = perCellCount[iCell];
+          if (offset == perCellCount[iCell + 1]) {
+            return;
+          }
+          forCellNeighbour(PassMode::TwoPassInsert{}, iCell, offset);
+        });
       }
 
       if (cellsNeighbours.empty()) {
@@ -607,7 +571,7 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
         while (++it != cellsNeighbours.end() && it->nextCell == cellIdx) {
           maxLvl = std::max(maxLvl, it->level);
         }
-        o2::gpu::CAMath::AtomicMax(mTimeFrame->getCells()[iLayer + 1][cellIdx].getLevelPtr(), maxLvl);
+        mTimeFrame->getCells()[iLayer + 1][cellIdx].setLevel(maxLvl);
       }
     }
   });
@@ -718,13 +682,9 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
       }
     } else {
       bounded_vector<int> perCellCount(nCells + 1, 0, mMemoryPool.get());
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, nCells),
-        [&](const tbb::blocked_range<int>& Cells) {
-          for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
-            perCellCount[iCell] = forCellNeighbours(PassMode::TwoPassCount{}, iCell);
-          }
-        });
+      tbb::parallel_for(0, nCells, [&](const int iCell) {
+        perCellCount[iCell] = forCellNeighbours(PassMode::TwoPassCount{}, iCell);
+      });
 
       std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
       auto totalNeighbours{perCellCount.back()};
@@ -734,17 +694,13 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
       updatedCellSeeds.resize(totalNeighbours);
       updatedCellsIds.resize(totalNeighbours);
 
-      tbb::parallel_for(
-        tbb::blocked_range<int>(0, nCells),
-        [&](const tbb::blocked_range<int>& Cells) {
-          for (int iCell = Cells.begin(); iCell < Cells.end(); ++iCell) {
-            int offset = perCellCount[iCell];
-            if (offset == perCellCount[iCell + 1]) {
-              continue;
-            }
-            forCellNeighbours(PassMode::TwoPassInsert{}, iCell, offset);
-          }
-        });
+      tbb::parallel_for(0, nCells, [&](const int iCell) {
+        int offset = perCellCount[iCell];
+        if (offset == perCellCount[iCell + 1]) {
+          return;
+        }
+        forCellNeighbours(PassMode::TwoPassInsert{}, iCell, offset);
+      });
     }
   });
 
@@ -762,19 +718,18 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
 template <int nLayers>
 void TrackerTraits<nLayers>::findRoads(const int iteration)
 {
-  CA_DEBUGGER(std::cout << "Finding roads, iteration " << iteration << std::endl);
-
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
-    CA_DEBUGGER(std::cout << "\t > Processing level " << startLevel << std::endl);
+
     auto seedFilter = [&](const auto& seed) {
       return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[0].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
     };
+
     bounded_vector<CellSeedN> trackSeeds(mMemoryPool.get());
-    for (int startLayer{mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= startLevel - 1; --startLayer) {
+    for (int startLayer{mTrkParams[iteration].NeighboursPerRoad()}; startLayer >= startLevel - 1; --startLayer) {
       if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
       }
-      CA_DEBUGGER(std::cout << "\t\t > Starting processing layer " << startLayer << std::endl);
+
       bounded_vector<int> lastCellId(mMemoryPool.get()), updatedCellId(mMemoryPool.get());
       bounded_vector<CellSeedN> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
 
@@ -844,13 +799,9 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         }
       } else {
         bounded_vector<int> perSeedCount(nSeeds + 1, 0, mMemoryPool.get());
-        tbb::parallel_for(
-          tbb::blocked_range<int>(0, nSeeds),
-          [&](const tbb::blocked_range<int>& Seeds) {
-            for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
-              perSeedCount[iSeed] = forSeed(PassMode::TwoPassCount{}, iSeed);
-            }
-          });
+        tbb::parallel_for(0, nSeeds, [&](const int iSeed) {
+          perSeedCount[iSeed] = forSeed(PassMode::TwoPassCount{}, iSeed);
+        });
 
         std::exclusive_scan(perSeedCount.begin(), perSeedCount.end(), perSeedCount.begin(), 0);
         auto totalTracks{perSeedCount.back()};
@@ -859,16 +810,12 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         }
         tracks.resize(totalTracks);
 
-        tbb::parallel_for(
-          tbb::blocked_range<int>(0, nSeeds),
-          [&](const tbb::blocked_range<int>& Seeds) {
-            for (int iSeed = Seeds.begin(); iSeed < Seeds.end(); ++iSeed) {
-              if (perSeedCount[iSeed] == perSeedCount[iSeed + 1]) {
-                continue;
-              }
-              forSeed(PassMode::TwoPassInsert{}, iSeed, perSeedCount[iSeed]);
-            }
-          });
+        tbb::parallel_for(0, nSeeds, [&](const int iSeed) {
+          if (perSeedCount[iSeed] == perSeedCount[iSeed + 1]) {
+            return;
+          }
+          forSeed(PassMode::TwoPassInsert{}, iSeed, perSeedCount[iSeed]);
+        });
       }
 
       deepVectorClear(trackSeeds);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 53be03af7eb14..b8b30e515d1ca 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -169,45 +169,41 @@ template <int nLayers>
 void VertexerTraits<nLayers>::computeTracklets(const int iteration)
 {
   mTaskArena->execute([&] {
-    tbb::parallel_for(
-      tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
-      [&](const tbb::blocked_range<short>& Rofs) {
-        for (short pivotRofId = Rofs.begin(); pivotRofId < Rofs.end(); ++pivotRofId) {
-          bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
-          short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
-          short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-          for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
-            trackleterKernelHost<TrackletMode::Layer0Layer1, true>(
-              !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(), // Clusters to be matched with the next layer in target rof
-              !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),  // Clusters to be matched with the current layer in pivot rof
-              mTimeFrame->getUsedClustersROF(targetRofId, 0),                                   // Span of the used clusters in the target rof
-              mTimeFrame->getIndexTable(targetRofId, 0).data(),                                 // Index table to access the data on the next layer in target rof
-              mVrtParams[iteration].phiCut,
-              mTimeFrame->getTracklets()[0],                   // Flat tracklet buffer
-              mTimeFrame->getNTrackletsCluster(pivotRofId, 0), // Span of the number of tracklets per each cluster in pivot rof
-              mIndexTableUtils,
-              pivotRofId,
-              targetRofId,
-              gsl::span<int>(), // Offset in the tracklet buffer
-              mVrtParams[iteration].maxTrackletsPerCluster);
-            trackleterKernelHost<TrackletMode::Layer1Layer2, true>(
-              !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
-              !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
-              mTimeFrame->getUsedClustersROF(targetRofId, 2),
-              mTimeFrame->getIndexTable(targetRofId, 2).data(),
-              mVrtParams[iteration].phiCut,
-              mTimeFrame->getTracklets()[1],
-              mTimeFrame->getNTrackletsCluster(pivotRofId, 1), // Span of the number of tracklets per each cluster in pivot rof
-              mIndexTableUtils,
-              pivotRofId,
-              targetRofId,
-              gsl::span<int>(), // Offset in the tracklet buffer
-              mVrtParams[iteration].maxTrackletsPerCluster);
-          }
-          mTimeFrame->getNTrackletsROF(pivotRofId, 0) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 0).end(), 0);
-          mTimeFrame->getNTrackletsROF(pivotRofId, 1) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 1).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 1).end(), 0);
-        }
-      });
+    tbb::parallel_for(0, mTimeFrame->getNrof(), [&](const short pivotRofId) {
+      bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
+      short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
+      short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
+      for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
+        trackleterKernelHost<TrackletMode::Layer0Layer1, true>(
+          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(), // Clusters to be matched with the next layer in target rof
+          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),  // Clusters to be matched with the current layer in pivot rof
+          mTimeFrame->getUsedClustersROF(targetRofId, 0),                                   // Span of the used clusters in the target rof
+          mTimeFrame->getIndexTable(targetRofId, 0).data(),                                 // Index table to access the data on the next layer in target rof
+          mVrtParams[iteration].phiCut,
+          mTimeFrame->getTracklets()[0],                   // Flat tracklet buffer
+          mTimeFrame->getNTrackletsCluster(pivotRofId, 0), // Span of the number of tracklets per each cluster in pivot rof
+          mIndexTableUtils,
+          pivotRofId,
+          targetRofId,
+          gsl::span<int>(), // Offset in the tracklet buffer
+          mVrtParams[iteration].maxTrackletsPerCluster);
+        trackleterKernelHost<TrackletMode::Layer1Layer2, true>(
+          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
+          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+          mTimeFrame->getUsedClustersROF(targetRofId, 2),
+          mTimeFrame->getIndexTable(targetRofId, 2).data(),
+          mVrtParams[iteration].phiCut,
+          mTimeFrame->getTracklets()[1],
+          mTimeFrame->getNTrackletsCluster(pivotRofId, 1), // Span of the number of tracklets per each cluster in pivot rof
+          mIndexTableUtils,
+          pivotRofId,
+          targetRofId,
+          gsl::span<int>(), // Offset in the tracklet buffer
+          mVrtParams[iteration].maxTrackletsPerCluster);
+      }
+      mTimeFrame->getNTrackletsROF(pivotRofId, 0) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 0).end(), 0);
+      mTimeFrame->getNTrackletsROF(pivotRofId, 1) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 1).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 1).end(), 0);
+    });
 
     mTimeFrame->computeTrackletsPerROFScans();
     if (auto tot0 = mTimeFrame->getTotalTrackletsTF(0), tot1 = mTimeFrame->getTotalTrackletsTF(1);
@@ -218,45 +214,41 @@ void VertexerTraits<nLayers>::computeTracklets(const int iteration)
       mTimeFrame->getTracklets()[1].resize(tot1);
     }
 
-    tbb::parallel_for(
-      tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
-      [&](const tbb::blocked_range<short>& Rofs) {
-        for (short pivotRofId = Rofs.begin(); pivotRofId < Rofs.end(); ++pivotRofId) {
-          bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
-          short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
-          short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-          auto mobileOffset0 = mTimeFrame->getNTrackletsROF(pivotRofId, 0);
-          auto mobileOffset1 = mTimeFrame->getNTrackletsROF(pivotRofId, 1);
-          for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
-            trackleterKernelHost<TrackletMode::Layer0Layer1, false>(
-              !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(),
-              !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
-              mTimeFrame->getUsedClustersROF(targetRofId, 0),
-              mTimeFrame->getIndexTable(targetRofId, 0).data(),
-              mVrtParams[iteration].phiCut,
-              mTimeFrame->getTracklets()[0],
-              mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
-              mIndexTableUtils,
-              pivotRofId,
-              targetRofId,
-              mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 0),
-              mVrtParams[iteration].maxTrackletsPerCluster);
-            trackleterKernelHost<TrackletMode::Layer1Layer2, false>(
-              !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
-              !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
-              mTimeFrame->getUsedClustersROF(targetRofId, 2),
-              mTimeFrame->getIndexTable(targetRofId, 2).data(),
-              mVrtParams[iteration].phiCut,
-              mTimeFrame->getTracklets()[1],
-              mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
-              mIndexTableUtils,
-              pivotRofId,
-              targetRofId,
-              mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 1),
-              mVrtParams[iteration].maxTrackletsPerCluster);
-          }
-        }
-      });
+    tbb::parallel_for(0, mTimeFrame->getNrof(), [&](const short pivotRofId) {
+      bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
+      short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
+      short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
+      auto mobileOffset0 = mTimeFrame->getNTrackletsROF(pivotRofId, 0);
+      auto mobileOffset1 = mTimeFrame->getNTrackletsROF(pivotRofId, 1);
+      for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
+        trackleterKernelHost<TrackletMode::Layer0Layer1, false>(
+          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(),
+          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+          mTimeFrame->getUsedClustersROF(targetRofId, 0),
+          mTimeFrame->getIndexTable(targetRofId, 0).data(),
+          mVrtParams[iteration].phiCut,
+          mTimeFrame->getTracklets()[0],
+          mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
+          mIndexTableUtils,
+          pivotRofId,
+          targetRofId,
+          mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 0),
+          mVrtParams[iteration].maxTrackletsPerCluster);
+        trackleterKernelHost<TrackletMode::Layer1Layer2, false>(
+          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
+          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+          mTimeFrame->getUsedClustersROF(targetRofId, 2),
+          mTimeFrame->getIndexTable(targetRofId, 2).data(),
+          mVrtParams[iteration].phiCut,
+          mTimeFrame->getTracklets()[1],
+          mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
+          mIndexTableUtils,
+          pivotRofId,
+          targetRofId,
+          mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 1),
+          mVrtParams[iteration].maxTrackletsPerCluster);
+      }
+    });
   });
 
   /// Create tracklets labels for L0-L1, information is as flat as in tracklets vector (no rofId)

From f72e1a27145c5b7fbdc0aa2c0ea341400bcb6009 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 23 Sep 2025 17:34:07 +0200
Subject: [PATCH 0861/1764] Avoid recompiling fpu.cxx a gazillion of times
 (#14686)

This will simply link the object file from fpu.cxx,
which will be compiled only once.
---
 Common/Utils/CMakeLists.txt | 3 +++
 cmake/O2AddExecutable.cmake | 3 ++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/Common/Utils/CMakeLists.txt b/Common/Utils/CMakeLists.txt
index def743d11791c..d9954e23ab435 100644
--- a/Common/Utils/CMakeLists.txt
+++ b/Common/Utils/CMakeLists.txt
@@ -91,3 +91,6 @@ o2_add_executable(treemergertool
             COMPONENT_NAME CommonUtils
           SOURCES src/TreeMergerTool.cxx
             PUBLIC_LINK_LIBRARIES O2::CommonUtils Boost::program_options ROOT::Core)
+
+add_library(fpu_support OBJECT src/fpu.cxx)
+add_library(O2::fpu_support ALIAS fpu_support)
diff --git a/cmake/O2AddExecutable.cmake b/cmake/O2AddExecutable.cmake
index d5fea084e2c23..752678c44baf0 100644
--- a/cmake/O2AddExecutable.cmake
+++ b/cmake/O2AddExecutable.cmake
@@ -92,7 +92,7 @@ function(o2_add_executable baseTargetName)
   endif()
 
   # add the executable with its sources
-  add_executable(${target} ${A_SOURCES} ${CMAKE_SOURCE_DIR}/Common/Utils/src/fpu.cxx)
+  add_executable(${target} ${A_SOURCES})
 
   # set the executable output name
   set_property(TARGET ${target} PROPERTY OUTPUT_NAME ${exeName})
@@ -118,6 +118,7 @@ function(o2_add_executable baseTargetName)
 
   # needed for fpu.c
   target_link_libraries(${target} PUBLIC ROOT::XMLIO)
+  target_link_libraries(${target} PUBLIC O2::fpu_support)
 
   if(NOT A_NO_INSTALL)
     # install the executable

From 6c5bbfb86588090e0c1bdd32e9d1a602e42692a2 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <48915672+matthias-kleiner@users.noreply.github.com>
Date: Thu, 25 Sep 2025 11:10:47 +0200
Subject: [PATCH 0862/1764] TPC: Apply T/P scaling of VDrift only if T/P change
 is large enough (#14668)

* TPC: Apply T/P scaling of VDrift only if T/P change is large enough

- suppress error for getting reference T/P in case default VDrift is used

* remove info message and print warning only once
---
 Detectors/TPC/calibration/src/VDriftHelper.cxx | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/Detectors/TPC/calibration/src/VDriftHelper.cxx b/Detectors/TPC/calibration/src/VDriftHelper.cxx
index 2badf3bb510e8..71c4e50a63fcf 100644
--- a/Detectors/TPC/calibration/src/VDriftHelper.cxx
+++ b/Detectors/TPC/calibration/src/VDriftHelper.cxx
@@ -164,6 +164,10 @@ void VDriftHelper::extractCCDBInputs(ProcessingContext& pc, bool laser, bool its
         mIsTPScalingPossible = (vd.refTP > 0) || extractTPForVDrift(vd);
       }
       if (mIsTPScalingPossible) {
+        // if no new VDrift object was loaded and if delta TP is small, do not rescale and return
+        if (!mUpdated && std::abs(tp - vd.refTP) < 1e-5) {
+          return;
+        }
         mUpdated = true;
         vd.normalize(0, tp);
         if (vd.creationTime == saveVD.creationTime) {
@@ -245,6 +249,15 @@ bool VDriftHelper::extractTPForVDrift(VDriftCorrFact& vdrift, int64_t tsStepMS)
   const int64_t tsStart = vdrift.firstTime;
   const int64_t tsEnd = vdrift.lastTime;
 
+  if (tsStart == tsEnd) {
+    static bool warned = false;
+    if (!warned) {
+      warned = true;
+      LOGP(warn, "VDriftHelper: Cannot extract T/P for VDrift with identical start/end time {}!", tsStart);
+    }
+    return false;
+  }
+
   // make sanity check of the time range
   const auto [minValidTime, maxValidTime] = mPTHelper.getMinMaxTime();
   const int64_t minTimeAccepted = static_cast<int64_t>(minValidTime) - 20 * o2::ccdb::CcdbObjectInfo::MINUTE;

From bf44a8f77e4177c8af9971be8a8e725cc41a3ead Mon Sep 17 00:00:00 2001
From: Fabrizio Chinu <91954233+fchinu@users.noreply.github.com>
Date: Thu, 25 Sep 2025 11:29:09 +0200
Subject: [PATCH 0863/1764] ITS: allow sharing of innermost cluster among
 tracks (#14684)

* feat: allow sharing of first cluster in ITS tracking

* Implement modifications from #14432

* Move to bounded_vector

---------

Co-authored-by: Maximiliano Puccio <maximiliano.puccio@cern.ch>
---
 .../include/ITStracking/Configuration.h       |  1 +
 .../include/ITStracking/TrackingConfigParam.h |  1 +
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |  1 +
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 44 +++++++++++++++++--
 4 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 2bfa0639ad5a2..d7c4e27add739 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -51,6 +51,7 @@ struct TrackingParameters {
   float Diamond[3] = {0.f, 0.f, 0.f};
 
   /// General parameters
+  bool AllowSharingFirstCluster = false;
   int ClusterSharing = 0;
   int MinTrackLength = 7;
   float NSigmaCut = 5;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index d368eb1d1f56a..6c4ecc5ab424d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -104,6 +104,7 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   size_t maxMemory = std::numeric_limits<size_t>::max();
   bool dropTFUponFailure = false;
   bool fataliseUponFailure = true; // granular management of the fatalisation in async mode
+  bool allowSharingFirstCluster = false; // allow first cluster sharing among tracks
 
   O2ParamDef(TrackerParamConfig, "ITSCATrackerParam");
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 6af66b18a2878..df736b3c7efdb 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -194,6 +194,7 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     p.DropTFUponFailure = tc.dropTFUponFailure;
     p.SaveTimeBenchmarks = tc.saveTimeBenchmarks;
     p.FataliseUponFailure = tc.fataliseUponFailure;
+    p.AllowSharingFirstCluster = tc.allowSharingFirstCluster;
 
     if (tc.useMatCorrTGeo) {
       p.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrTGeo;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 46a64adf5fa2f..3a58ad1c000b7 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -718,6 +718,10 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
 template <int nLayers>
 void TrackerTraits<nLayers>::findRoads(const int iteration)
 {
+  bounded_vector<bounded_vector<int>> firstClusters(mTrkParams[iteration].NLayers, bounded_vector<int>(mMemoryPool.get()), mMemoryPool.get());
+  bounded_vector<bounded_vector<int>> sharedFirstClusters(mTrkParams[iteration].NLayers, bounded_vector<int>(mMemoryPool.get()), mMemoryPool.get());
+  firstClusters.resize(mTrkParams[iteration].NLayers);
+  sharedFirstClusters.resize(mTrkParams[iteration].NLayers);
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
 
     auto seedFilter = [&](const auto& seed) {
@@ -827,15 +831,22 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
     for (auto& track : tracks) {
       int nShared = 0;
       bool isFirstShared{false};
+      int firstLayer{-1}, firstCluster{-1};
       for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
         if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
           continue;
         }
-        nShared += int(mTimeFrame->isClusterUsed(iLayer, track.getClusterIndex(iLayer)));
-        isFirstShared |= !iLayer && mTimeFrame->isClusterUsed(iLayer, track.getClusterIndex(iLayer));
+        bool isShared = mTimeFrame->isClusterUsed(iLayer, track.getClusterIndex(iLayer));
+        nShared += int(isShared);
+        if (firstLayer < 0) {
+          firstCluster = track.getClusterIndex(iLayer);
+          isFirstShared = isShared && mTrkParams[0].AllowSharingFirstCluster && std::find(firstClusters[iLayer].begin(), firstClusters[iLayer].end(), firstCluster) != firstClusters[iLayer].end();
+          firstLayer = iLayer;
+        }
       }
 
-      if (nShared > mTrkParams[0].ClusterSharing) {
+      /// do not account for the first cluster in the shared clusters number if it is allowed
+      if (nShared - int(isFirstShared && mTrkParams[0].AllowSharingFirstCluster) > mTrkParams[0].ClusterSharing) {
         continue;
       }
 
@@ -864,6 +875,33 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         track.setNextROFbit();
       }
       mTimeFrame->getTracks(o2::gpu::CAMath::Min(rofs[0], rofs[1])).emplace_back(track);
+
+      firstClusters[firstLayer].push_back(firstCluster);
+      if (isFirstShared) {
+        sharedFirstClusters[firstLayer].push_back(firstCluster);
+      }
+    }
+  }
+
+  /// Now we have to set the shared cluster flag
+  for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
+    std::sort(sharedFirstClusters[iLayer].begin(), sharedFirstClusters[iLayer].end());
+  }
+
+  for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
+    for (auto& track : mTimeFrame->getTracks(iROF)) {
+      int firstLayer{mTrkParams[0].NLayers}, firstCluster{constants::UnusedIndex};
+      for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
+        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
+          continue;
+        }
+        firstLayer = iLayer;
+        firstCluster = track.getClusterIndex(iLayer);
+        break;
+      }
+      if (std::binary_search(sharedFirstClusters[firstLayer].begin(), sharedFirstClusters[firstLayer].end(), firstCluster)) {
+        track.setSharedClusters();
+      }
     }
   }
 }

From 1b04a9a4b79d5c786b8d8a2d81a0f7d472e1a4fa Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 25 Sep 2025 11:32:34 +0200
Subject: [PATCH 0864/1764] ITS: GPU: improve mm and add tests for resource
 (#14681)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
Co-authored-by: Felix Schlepper <fschlepp@aliceml.cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt  |   2 +
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 142 +++++++------
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  14 +-
 .../include/ITStracking/BoundedAllocator.h    |  61 +++---
 .../tracking/include/ITStracking/Cluster.h    |   9 +-
 .../include/ITStracking/ExternalAllocator.h   |  32 +++
 .../tracking/include/ITStracking/TimeFrame.h  |  46 ++---
 .../tracking/include/ITStracking/Tracker.h    |   2 +-
 .../include/ITStracking/TrackerTraits.h       |   2 +-
 .../tracking/include/ITStracking/Vertexer.h   |   2 +-
 .../include/ITStracking/VertexerTraits.h      |   2 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 175 +++++++---------
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      |   1 -
 .../ITSMFT/ITS/tracking/test/CMakeLists.txt   |  16 ++
 .../test/testBoundedMemoryResource.cxx        | 190 ++++++++++++++++++
 .../ITS3/reconstruction/src/IOUtils.cxx       |   2 +-
 GPU/GPUTracking/Global/GPUChainITS.cxx        |  19 +-
 GPU/GPUTracking/Global/GPUChainITS.h          |   3 +-
 18 files changed, 474 insertions(+), 246 deletions(-)
 create mode 100644 Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
 create mode 100644 Detectors/ITSMFT/ITS/tracking/test/testBoundedMemoryResource.cxx

diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index 291ddffbf9475..001ee537f50d2 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -56,3 +56,5 @@ o2_target_root_dictionary(ITStracking
 if(CUDA_ENABLED OR HIP_ENABLED)
   add_subdirectory(GPU)
 endif()
+
+add_subdirectory(test)
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 4da91522371f8..27bcf04746da5 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -32,7 +32,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& stream, bool extAllocator)
 {
   if (extAllocator) {
-    *ptr = this->mAllocator->allocate(size);
+    *ptr = this->mExtDeviceAllocator->allocate(size);
   } else {
     GPULog("Calling default CUDA allocator");
     GPUChkErrS(cudaMallocAsync(reinterpret_cast<void**>(ptr), size, stream.get()));
@@ -43,7 +43,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::allocMem(void** ptr, size_t size, bool extAllocator)
 {
   if (extAllocator) {
-    *ptr = this->mAllocator->allocate(size);
+    *ptr = this->mExtDeviceAllocator->allocate(size);
   } else {
     GPULog("Calling default CUDA allocator");
     GPUChkErrS(cudaMalloc(reinterpret_cast<void**>(ptr), size));
@@ -56,7 +56,7 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
   GPUTimer timer("loading indextable utils");
   if (!iteration) {
     GPULog("gpu-allocation: allocating IndexTableUtils buffer, for {:.2f} MB.", sizeof(IndexTableUtilsN) / constants::MB);
-    allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtilsN), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtilsN), this->hasExternalDeviceAllocator());
   }
   GPULog("gpu-transfer: loading IndexTableUtils object, for {:.2f} MB.", sizeof(IndexTableUtilsN) / constants::MB);
   GPUChkErrS(cudaMemcpy(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtilsN), cudaMemcpyHostToDevice));
@@ -67,12 +67,14 @@ void TimeFrameGPU<nLayers>::createUnsortedClustersDeviceArray(const int iteratio
 {
   if (!iteration) {
     GPUTimer timer("creating unsorted clusters array");
-    allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     mPinnedUnsortedClusters.set(nLayers);
-    for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
-      GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      mPinnedUnsortedClusters.set(iLayer);
+    if (!this->hasExternalDeviceAllocator()) {
+      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
+        GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
+        mPinnedUnsortedClusters.set(iLayer);
+      }
     }
   }
 }
@@ -83,7 +85,7 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration, cons
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading unsorted clusters", layer);
     GPULog("gpu-transfer: loading {} unsorted clusters on layer {}, for {:.2f} MB.", this->mUnsortedClusters[layer].size(), layer, this->mUnsortedClusters[layer].size() * sizeof(Cluster) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[layer]), this->mUnsortedClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[layer]), this->mUnsortedClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[layer], this->mUnsortedClusters[layer].data(), this->mUnsortedClusters[layer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mUnsortedClustersDeviceArray[layer], &mUnsortedClustersDevice[layer], sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -94,12 +96,14 @@ void TimeFrameGPU<nLayers>::createClustersDeviceArray(const int iteration, const
 {
   if (!iteration) {
     GPUTimer timer("creating sorted clusters array");
-    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     mPinnedClusters.set(nLayers);
-    for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
-      GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
-      mPinnedClusters.set(iLayer);
+    if (!this->hasExternalDeviceAllocator()) {
+      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
+        GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
+        mPinnedClusters.set(iLayer);
+      }
     }
   }
 }
@@ -110,7 +114,7 @@ void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration, const int la
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
     GPULog("gpu-transfer: loading {} clusters on layer {}, for {:.2f} MB.", this->mClusters[layer].size(), layer, this->mClusters[layer].size() * sizeof(Cluster) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[layer]), this->mClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[layer]), this->mClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpyAsync(mClustersDevice[layer], this->mClusters[layer].data(), this->mClusters[layer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mClustersDeviceArray[layer], &mClustersDevice[layer], sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -121,12 +125,14 @@ void TimeFrameGPU<nLayers>::createClustersIndexTablesArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating clustersindextable array");
-    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaHostRegister(mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaHostRegisterPortable));
     mPinnedClustersIndexTables.set(nLayers);
-    for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPUChkErrS(cudaHostRegister(this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-      mPinnedClustersIndexTables.set(iLayer);
+    if (!this->hasExternalDeviceAllocator()) {
+      for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+        GPUChkErrS(cudaHostRegister(this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
+        mPinnedClustersIndexTables.set(iLayer);
+      }
     }
   }
 }
@@ -137,7 +143,7 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration, const i
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
     GPULog("gpu-transfer: loading clusters indextable for layer {} with {} elements, for {:.2f} MB.", layer, this->mIndexTables[layer].size(), this->mIndexTables[layer].size() * sizeof(int) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[layer]), this->mIndexTables[layer].size() * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[layer]), this->mIndexTables[layer].size() * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[layer], this->mIndexTables[layer].data(), this->mIndexTables[layer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mClustersIndexTablesDeviceArray[layer], &mClustersIndexTablesDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -148,12 +154,14 @@ void TimeFrameGPU<nLayers>::createUsedClustersDeviceArray(const int iteration, c
 {
   if (!iteration) {
     GPUTimer timer("creating used clusters flags");
-    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(uint8_t*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(uint8_t*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaHostRegister(mUsedClustersDevice.data(), nLayers * sizeof(uint8_t*), cudaHostRegisterPortable));
     mPinnedUsedClusters.set(nLayers);
-    for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
-      GPUChkErrS(cudaHostRegister(this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(uint8_t), cudaHostRegisterPortable));
-      mPinnedUsedClusters.set(iLayer);
+    if (!this->hasExternalDeviceAllocator()) {
+      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
+        GPUChkErrS(cudaHostRegister(this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(uint8_t), cudaHostRegisterPortable));
+        mPinnedUsedClusters.set(iLayer);
+      }
     }
   }
 }
@@ -164,7 +172,7 @@ void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration, const
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "creating used clusters flags", layer);
     GPULog("gpu-transfer: creating {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[layer].size(), layer, this->mUsedClusters[layer].size() * sizeof(unsigned char) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[layer]), this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[layer]), this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer], this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[layer], 0, this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mUsedClustersDeviceArray[layer], &mUsedClustersDevice[layer], sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -185,12 +193,14 @@ void TimeFrameGPU<nLayers>::createROFrameClustersDeviceArray(const int iteration
 {
   if (!iteration) {
     GPUTimer timer("creating ROFrame clusters array");
-    allocMem(reinterpret_cast<void**>(&mROFramesClustersDeviceArray), nLayers * sizeof(int*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mROFramesClustersDeviceArray), nLayers * sizeof(int*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaHostRegister(mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaHostRegisterPortable));
     mPinnedROFramesClusters.set(nLayers);
-    for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPUChkErrS(cudaHostRegister(this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
-      mPinnedROFramesClusters.set(iLayer);
+    if (!this->hasExternalDeviceAllocator()) {
+      for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+        GPUChkErrS(cudaHostRegister(this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
+        mPinnedROFramesClusters.set(iLayer);
+      }
     }
   }
 }
@@ -201,7 +211,7 @@ void TimeFrameGPU<nLayers>::loadROFrameClustersDevice(const int iteration, const
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading ROframe clusters", layer);
     GPULog("gpu-transfer: loading {} ROframe clusters info on layer {}, for {:.2f} MB.", this->mROFramesClusters[layer].size(), layer, this->mROFramesClusters[layer].size() * sizeof(int) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[layer]), this->mROFramesClusters[layer].size() * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[layer]), this->mROFramesClusters[layer].size() * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[layer], this->mROFramesClusters[layer].data(), this->mROFramesClusters[layer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mROFramesClustersDeviceArray[layer], &mROFramesClustersDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -212,12 +222,14 @@ void TimeFrameGPU<nLayers>::createTrackingFrameInfoDeviceArray(const int iterati
 {
   if (!iteration) {
     GPUTimer timer("creating trackingframeinfo array");
-    allocMem(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
     mPinnedTrackingFrameInfo.set(nLayers);
-    for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
-      GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
-      mPinnedTrackingFrameInfo.set(iLayer);
+    if (!this->hasExternalDeviceAllocator()) {
+      for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+        GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
+        mPinnedTrackingFrameInfo.set(iLayer);
+      }
     }
   }
 }
@@ -228,7 +240,7 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration, con
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading trackingframeinfo", layer);
     GPULog("gpu-transfer: loading {} tfinfo on layer {}, for {:.2f} MB.", this->mTrackingFrameInfo[layer].size(), layer, this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[layer]), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), mGpuStreams[layer], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[layer]), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), mGpuStreams[layer], this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[layer], this->mTrackingFrameInfo[layer].data(), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mTrackingFrameInfoDeviceArray[layer], &mTrackingFrameInfoDevice[layer], sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -241,7 +253,7 @@ void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
     GPUTimer timer("loading multiplicity cut mask");
     GPULog("gpu-transfer: iteration {} loading multiplicity cut mask with {} elements, for {:.2f} MB.", iteration, this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(uint8_t) / constants::MB);
     if (!iteration) { // only allocate on first call
-      allocMem(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), this->getExtAllocator());
+      allocMem(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), this->hasExternalDeviceAllocator());
     }
     GPUChkErrS(cudaMemcpy(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice));
   }
@@ -253,10 +265,10 @@ void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
   if (!iteration) {
     GPUTimer timer("loading seeding vertices");
     GPULog("gpu-transfer: loading {} ROframes vertices, for {:.2f} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / constants::MB);
-    allocMem(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpy(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice));
     GPULog("gpu-transfer: loading {} seeding vertices, for {:.2f} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / constants::MB);
-    allocMem(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpy(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice));
   }
 }
@@ -265,7 +277,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsLUTDeviceArray(const int iteration)
 {
   if (!iteration) {
-    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), this->hasExternalDeviceAllocator());
   }
 }
 
@@ -276,7 +288,7 @@ void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration, const
   const int ncls = this->mClusters[layer].size() + 1;
   if (!iteration) {
     GPULog("gpu-allocation: creating tracklets LUT for {} elements on layer {}, for {:.2f} MB.", ncls, layer, ncls * sizeof(int) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[layer]), ncls * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[layer]), ncls * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpyAsync(&mTrackletsLUTDeviceArray[layer], &mTrackletsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
   GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[layer], 0, ncls * sizeof(int), mGpuStreams[layer].get()));
@@ -287,7 +299,7 @@ void TimeFrameGPU<nLayers>::createTrackletsBuffersArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating tracklet buffers array");
-    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), this->hasExternalDeviceAllocator());
   }
 }
 
@@ -299,7 +311,7 @@ void TimeFrameGPU<nLayers>::createTrackletsBuffers(const int layer)
   GPUChkErrS(cudaMemcpyAsync(&mNTracklets[layer], mTrackletsLUTDevice[layer] + this->mClusters[layer].size(), sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of tracklets is correct
   GPULog("gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer], layer, mNTracklets[layer] * sizeof(Tracklet) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[layer]), mNTracklets[layer] * sizeof(Tracklet), mGpuStreams[layer], this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[layer]), mNTracklets[layer] * sizeof(Tracklet), mGpuStreams[layer], this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaMemcpyAsync(&mTrackletsDeviceArray[layer], &mTrackletsDevice[layer], sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
@@ -331,7 +343,7 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells neighbours", layer);
   GPULog("gpu-transfer: reserving neighbours LUT for {} elements on layer {}, for {:.2f} MB.", mNCells[layer] + 1, layer, (mNCells[layer] + 1) * sizeof(int) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[layer]), (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[layer]), (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[layer], 0, (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer].get()));
 }
 
@@ -340,7 +352,7 @@ void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const uns
 {
   GPUTimer timer(mGpuStreams[layer], "reserving neighboursLUT");
   GPULog("gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {:.2f} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[layer], this->getExtAllocator()); // We need one element more to move exc -> inc
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator()); // We need one element more to move exc -> inc
   GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[layer].get()));
 }
 
@@ -350,8 +362,8 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
   GPUTimer timer(mGpuStreams, "loading cell seeds", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     GPULog("gpu-transfer: loading {} cell seeds on layer {}, for {:.2f} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeedN) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeedN), mGpuStreams[iLayer], this->getExtAllocator());
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->getExtAllocator()); // accessory for the neigh. finding.
+    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeedN), mGpuStreams[iLayer], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->hasExternalDeviceAllocator()); // accessory for the neigh. finding.
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
     GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeedN), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
@@ -362,7 +374,7 @@ void TimeFrameGPU<nLayers>::createCellsLUTDeviceArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating cells LUTs array");
-    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), this->hasExternalDeviceAllocator());
   }
 }
 
@@ -371,7 +383,7 @@ void TimeFrameGPU<nLayers>::createCellsLUTDevice(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells LUTs", layer);
   GPULog("gpu-transfer: creating cell LUT for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer] + 1, layer, (mNTracklets[layer] + 1) * sizeof(int) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[layer]), (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[layer]), (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[layer], 0, (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer].get()));
   GPUChkErrS(cudaMemcpyAsync(&mCellsLUTDeviceArray[layer], &mCellsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
@@ -381,7 +393,7 @@ void TimeFrameGPU<nLayers>::createCellsBuffersArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating cells buffers array");
-    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeedN*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeedN*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeedN*), cudaMemcpyHostToDevice));
   }
 }
@@ -394,7 +406,7 @@ void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of cells is correct
   GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeedN) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer], this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer], this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaMemcpyAsync(&mCellsDeviceArray[layer], &mCellsDevice[layer], sizeof(CellSeedN*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
@@ -414,7 +426,7 @@ void TimeFrameGPU<nLayers>::loadRoadsDevice()
 {
   GPUTimer timer("loading roads device");
   GPULog("gpu-transfer: loading {} roads, for {:.2f} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaHostRegister(this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpy(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice));
 }
@@ -424,7 +436,7 @@ void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeedN>& seed
 {
   GPUTimer timer("loading track seeds");
   GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeedN) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeedN), this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeedN), this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeedN), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpy(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeedN), cudaMemcpyHostToDevice));
 }
@@ -437,10 +449,10 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer)
   GPUChkErrS(cudaMemcpyAsync(&(this->mNNeighbours[layer]), &(mNeighboursLUTDevice[layer][this->mNCells[layer + 1] - 1]), sizeof(unsigned int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of neighbours is correct
   GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer], this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer], this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer].get()));
   GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(int), mGpuStreams[layer], this->getExtAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
 }
 
 template <int nLayers>
@@ -449,7 +461,7 @@ void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeedN>& s
   GPUTimer timer("reserving tracks");
   mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
   GPULog("gpu-allocation: reserving {} tracks, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaMemset(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt)));
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
 }
@@ -462,13 +474,13 @@ void TimeFrameGPU<nLayers>::createVtxTrackletsLUTDevice(const int32_t iteration)
   for (int32_t iMode{0}; iMode < 2; ++iMode) {
     if (!iteration) {
       GPULog("gpu-transfer: creating vertexer tracklets per cluster for {} elements for mode {}, for {:.2f} MB.", ncls, iMode, ncls * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterDevice[iMode]), ncls * sizeof(int32_t), mGpuStreams[iMode], this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterDevice[iMode]), ncls * sizeof(int32_t), mGpuStreams[iMode], this->hasExternalDeviceAllocator());
 
       GPULog("gpu-transfer: creating vertexer tracklets per cluster sum for {} elements for mode {}, for {:.2f} MB.", ncls + 1, iMode, (ncls + 1) * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDevice[iMode]), (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode], this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDevice[iMode]), (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode], this->hasExternalDeviceAllocator());
 
       GPULog("gpu-transfer: creating vertexer tracklets per ROF for {} elements for mode {}, for {:.2f} MB.", this->mNrof + 1, iMode, (this->mNrof + 1) * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerROFDevice[iMode]), (this->mNrof + 1) * sizeof(int32_t), mGpuStreams[iMode], this->getExtAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerROFDevice[iMode]), (this->mNrof + 1) * sizeof(int32_t), mGpuStreams[iMode], this->hasExternalDeviceAllocator());
     }
     GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterDevice[iMode], 0, ncls * sizeof(int32_t), mGpuStreams[iMode].get()));
     GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterSumDevice[iMode], 0, (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode].get()));
@@ -477,13 +489,13 @@ void TimeFrameGPU<nLayers>::createVtxTrackletsLUTDevice(const int32_t iteration)
   mGpuStreams[0].sync();
   mGpuStreams[1].sync();
   if (!iteration) {
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterDeviceArray), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterDeviceArray), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpy(mNTrackletsPerClusterDeviceArray, mNTrackletsPerClusterDevice.data(), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
 
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDeviceArray), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDeviceArray), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpy(mNTrackletsPerClusterSumDeviceArray, mNTrackletsPerClusterSumDevice.data(), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
 
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerROFDeviceArray), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), this->getExtAllocator());
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerROFDeviceArray), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), this->hasExternalDeviceAllocator());
     GPUChkErrS(cudaMemcpy(mNTrackletsPerROFDeviceArray, mNTrackletsPerROFDevice.data(), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
   }
 }
@@ -496,11 +508,11 @@ void TimeFrameGPU<nLayers>::createVtxTrackletsBuffers(const int32_t iteration)
     this->mTotalTracklets[iMode] = 0;
     GPUChkErrS(cudaMemcpyAsync(&(this->mTotalTracklets[iMode]), mNTrackletsPerClusterSumDevice[iMode] + this->mClusters[1].size(), sizeof(int32_t), cudaMemcpyDeviceToHost, mGpuStreams[iMode].get()));
     GPULog("gpu-transfer: creating vertexer tracklets buffer for {} elements on layer {}, for {:.2f} MB.", this->mTotalTracklets[iMode], iMode, this->mTotalTracklets[iMode] * sizeof(Tracklet) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iMode]), this->mTotalTracklets[iMode] * sizeof(Tracklet), mGpuStreams[iMode], this->getExtAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iMode]), this->mTotalTracklets[iMode] * sizeof(Tracklet), mGpuStreams[iMode], this->hasExternalDeviceAllocator());
   }
   mGpuStreams[0].sync();
   mGpuStreams[1].sync();
-  allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), 2 * sizeof(Tracklet*), this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), 2 * sizeof(Tracklet*), this->hasExternalDeviceAllocator());
   GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), 2 * sizeof(Tracklet*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpy(mTrackletsDeviceArray, mTrackletsDevice.data(), 2 * sizeof(Tracklet*), cudaMemcpyHostToDevice));
 }
@@ -512,14 +524,14 @@ void TimeFrameGPU<nLayers>::createVtxLinesLUTDevice(const int32_t iteration)
   const int32_t ncls = this->mClusters[1].size();
 
   GPULog("gpu-transfer: creating vertexer lines per cluster for {} elements , for {:.2f} MB.", ncls, ncls * sizeof(int32_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterDevice), ncls * sizeof(int32_t), this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterDevice), ncls * sizeof(int32_t), this->hasExternalDeviceAllocator());
 
   GPULog("gpu-transfer: creating vertexer lines per cluster sum for {} elements , for {:.2f} MB.", ncls + 1, (ncls + 1) * sizeof(int32_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterSumDevice), (ncls + 1) * sizeof(int32_t), this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterSumDevice), (ncls + 1) * sizeof(int32_t), this->hasExternalDeviceAllocator());
 
   const int32_t ntrkls = this->mTotalTracklets[0];
   GPULog("gpu-transfer: creating vertexer used tracklets for {} elements , for {:.2f} MB.", ntrkls, ntrkls * sizeof(uint8_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mUsedTrackletsDevice), ntrkls * sizeof(uint8_t), this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mUsedTrackletsDevice), ntrkls * sizeof(uint8_t), this->hasExternalDeviceAllocator());
 }
 
 template <int nLayers>
@@ -530,7 +542,7 @@ void TimeFrameGPU<nLayers>::createVtxLinesBuffer(const int32_t iteration)
   GPUChkErrS(cudaMemcpy(&nlines, mNLinesPerClusterDevice + this->mClusters[1].size(), sizeof(int32_t), cudaMemcpyDeviceToHost));
   this->mTotalLines = nlines;
   GPULog("gpu-transfer: creating vertexer lines for {} elements , for {:.2f} MB.", nlines, nlines * sizeof(Line) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mLinesDevice), nlines * sizeof(Line), this->getExtAllocator());
+  allocMem(reinterpret_cast<void**>(&mLinesDevice), nlines * sizeof(Line), this->hasExternalDeviceAllocator());
   // reset used tracklets
   GPUChkErrS(cudaMemset(mUsedTrackletsDevice, 0, this->mTotalTracklets[0] * sizeof(uint8_t)));
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 047d42d815e99..cca4283c9b77f 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -33,12 +33,14 @@ void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
   mTimeFrameGPU->loadVertices(iteration);
   mTimeFrameGPU->loadIndexTableUtils(iteration);
   mTimeFrameGPU->loadMultiplicityCutMask(iteration);
+  // pinned on host
   mTimeFrameGPU->createUsedClustersDeviceArray(iteration);
   mTimeFrameGPU->createClustersDeviceArray(iteration);
   mTimeFrameGPU->createUnsortedClustersDeviceArray(iteration);
   mTimeFrameGPU->createClustersIndexTablesArray(iteration);
   mTimeFrameGPU->createTrackingFrameInfoDeviceArray(iteration);
   mTimeFrameGPU->createROFrameClustersDeviceArray(iteration);
+  // device array
   mTimeFrameGPU->createTrackletsLUTDeviceArray(iteration);
   mTimeFrameGPU->createTrackletsBuffersArray(iteration);
   mTimeFrameGPU->createCellsBuffersArray(iteration);
@@ -106,7 +108,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getPositionResolutions(),
                                          this->mTrkParams[iteration].LayerRadii,
                                          mTimeFrameGPU->getMSangles(),
-                                         mTimeFrameGPU->getExternalAllocator(),
+                                         mTimeFrameGPU->getExternalDeviceAllocator(),
                                          conf.nBlocksLayerTracklets[iteration],
                                          conf.nThreadsLayerTracklets[iteration],
                                          mTimeFrameGPU->getStreams());
@@ -144,7 +146,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                            mTimeFrameGPU->getPositionResolutions(),
                                            this->mTrkParams[iteration].LayerRadii,
                                            mTimeFrameGPU->getMSangles(),
-                                           mTimeFrameGPU->getExternalAllocator(),
+                                           mTimeFrameGPU->getExternalDeviceAllocator(),
                                            conf.nBlocksLayerTracklets[iteration],
                                            conf.nThreadsLayerTracklets[iteration],
                                            mTimeFrameGPU->getStreams());
@@ -195,7 +197,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                                this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                                this->mTrkParams[iteration].NSigmaCut,
-                               mTimeFrameGPU->getExternalAllocator(),
+                               mTimeFrameGPU->getExternalDeviceAllocator(),
                                conf.nBlocksLayerCells[iteration],
                                conf.nThreadsLayerCells[iteration],
                                mTimeFrameGPU->getStreams());
@@ -251,7 +253,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                         currentLayerCellsNum,
                                         nextLayerCellsNum,
                                         1e2,
-                                        mTimeFrameGPU->getExternalAllocator(),
+                                        mTimeFrameGPU->getExternalDeviceAllocator(),
                                         conf.nBlocksFindNeighbours[iteration],
                                         conf.nThreadsFindNeighbours[iteration],
                                         mTimeFrameGPU->getStream(iLayer));
@@ -279,7 +281,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                                                                mTimeFrameGPU->getDeviceNeighbours(iLayer),
                                                                                mTimeFrameGPU->getArrayNNeighbours()[iLayer],
                                                                                mTimeFrameGPU->getStream(iLayer),
-                                                                               mTimeFrameGPU->getExternalAllocator());
+                                                                               mTimeFrameGPU->getExternalDeviceAllocator());
   }
   mTimeFrameGPU->syncStreams(false);
 }
@@ -310,7 +312,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
                                         this->mTrkParams[0].CorrType,
-                                        mTimeFrameGPU->getExternalAllocator(),
+                                        mTimeFrameGPU->getExternalDeviceAllocator(),
                                         conf.nBlocksProcessNeighbours[iteration],
                                         conf.nThreadsProcessNeighbours[iteration]);
     }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
index ac9f72089602d..66634c1a07eea 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
@@ -22,6 +22,8 @@
 #include <new>
 #include <vector>
 
+#include "ITStracking/ExternalAllocator.h"
+
 #include "GPUCommonLogger.h"
 
 namespace o2::its
@@ -56,6 +58,7 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
 
   BoundedMemoryResource(size_t maxBytes = std::numeric_limits<size_t>::max(), std::pmr::memory_resource* upstream = std::pmr::get_default_resource())
     : mMaxMemory(maxBytes), mUpstream(upstream) {}
+  BoundedMemoryResource(ExternalAllocator* alloc) : mAdaptor(std::make_unique<ExternalAllocatorAdaptor>(alloc)), mUpstream(mAdaptor.get()) {}
 
   void* do_allocate(size_t bytes, size_t alignment) final
   {
@@ -69,7 +72,14 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
     } while (!mUsedMemory.compare_exchange_weak(current_used, new_used,
                                                 std::memory_order_acq_rel,
                                                 std::memory_order_relaxed));
-    return mUpstream->allocate(bytes, alignment);
+    void* p{nullptr};
+    try {
+      p = mUpstream->allocate(bytes, alignment);
+    } catch (...) {
+      mUsedMemory.fetch_sub(bytes, std::memory_order_relaxed);
+      throw;
+    }
+    return p;
   }
 
   void do_deallocate(void* p, size_t bytes, size_t alignment) final
@@ -87,11 +97,12 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   size_t getMaxMemory() const noexcept { return mMaxMemory; }
   void setMaxMemory(size_t max)
   {
-    if (mUsedMemory > max) {
+    size_t used = mUsedMemory.load(std::memory_order_acquire);
+    if (used > max) {
       ++mCountThrow;
-      throw MemoryLimitExceeded(0, mUsedMemory, max);
+      throw MemoryLimitExceeded(0, used, max);
     }
-    mMaxMemory = max;
+    mMaxMemory.store(max, std::memory_order_release);
   }
 
   void print() const
@@ -106,76 +117,74 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   }
 
  private:
-  size_t mMaxMemory{std::numeric_limits<size_t>::max()};
+  std::atomic<size_t> mMaxMemory{std::numeric_limits<size_t>::max()};
   std::atomic<size_t> mCountThrow{0};
   std::atomic<size_t> mUsedMemory{0};
-  std::pmr::memory_resource* mUpstream;
+  std::unique_ptr<ExternalAllocatorAdaptor> mAdaptor{nullptr};
+  std::pmr::memory_resource* mUpstream{nullptr};
 };
 
 template <typename T>
 using bounded_vector = std::pmr::vector<T>;
 
 template <typename T>
-void deepVectorClear(std::vector<T>& vec)
+inline void deepVectorClear(std::vector<T>& vec)
 {
   std::vector<T>().swap(vec);
 }
 
 template <typename T>
-inline void deepVectorClear(bounded_vector<T>& vec, BoundedMemoryResource* bmr = nullptr)
+inline void deepVectorClear(bounded_vector<T>& vec, std::pmr::memory_resource* mr = nullptr)
 {
+  std::pmr::memory_resource* tmr = (mr != nullptr) ? mr : vec.get_allocator().resource();
   vec.~bounded_vector<T>();
-  if (bmr == nullptr) {
-    auto alloc = vec.get_allocator().resource();
-    new (&vec) bounded_vector<T>(alloc);
-  } else {
-    new (&vec) bounded_vector<T>(bmr);
-  }
+  new (&vec) bounded_vector<T>(std::pmr::polymorphic_allocator<T>{tmr});
 }
 
 template <typename T>
-void deepVectorClear(std::vector<bounded_vector<T>>& vec, BoundedMemoryResource* bmr = nullptr)
+inline void deepVectorClear(std::vector<bounded_vector<T>>& vec, std::pmr::memory_resource* mr = nullptr)
 {
   for (auto& v : vec) {
-    deepVectorClear(v, bmr);
+    deepVectorClear(v, mr);
   }
 }
 
 template <typename T, size_t S>
-void deepVectorClear(std::array<bounded_vector<T>, S>& arr, BoundedMemoryResource* bmr = nullptr)
+inline void deepVectorClear(std::array<bounded_vector<T>, S>& arr, std::pmr::memory_resource* mr = nullptr)
 {
   for (size_t i{0}; i < S; ++i) {
-    deepVectorClear(arr[i], bmr);
+    deepVectorClear(arr[i], mr);
   }
 }
 
 template <typename T>
-void clearResizeBoundedVector(bounded_vector<T>& vec, size_t size, BoundedMemoryResource* bmr, T def = T())
+inline void clearResizeBoundedVector(bounded_vector<T>& vec, size_t sz, std::pmr::memory_resource* mr = nullptr, T def = T())
 {
+  std::pmr::memory_resource* tmr = (mr != nullptr) ? mr : vec.get_allocator().resource();
   vec.~bounded_vector<T>();
-  new (&vec) bounded_vector<T>(size, def, bmr);
+  new (&vec) bounded_vector<T>(sz, def, std::pmr::polymorphic_allocator<T>{tmr});
 }
 
 template <typename T>
-void clearResizeBoundedVector(std::vector<bounded_vector<T>>& vec, size_t size, BoundedMemoryResource* bmr)
+inline void clearResizeBoundedVector(std::vector<bounded_vector<T>>& vec, size_t size, std::pmr::memory_resource* mr)
 {
   vec.clear();
   vec.reserve(size);
-  for (size_t i{0}; i < size; ++i) {
-    vec.emplace_back(bmr);
+  for (size_t i = 0; i < size; ++i) {
+    vec.emplace_back(std::pmr::polymorphic_allocator<bounded_vector<T>>{mr});
   }
 }
 
 template <typename T, size_t S>
-void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size, BoundedMemoryResource* bmr, T def = T())
+inline void clearResizeBoundedArray(std::array<bounded_vector<T>, S>& arr, size_t size, std::pmr::memory_resource* mr = nullptr, T def = T())
 {
   for (size_t i{0}; i < S; ++i) {
-    clearResizeBoundedVector(arr[i], size, bmr, def);
+    clearResizeBoundedVector(arr[i], size, mr, def);
   }
 }
 
 template <typename T>
-std::vector<T> toSTDVector(const bounded_vector<T>& b)
+inline std::vector<T> toSTDVector(const bounded_vector<T>& b)
 {
   std::vector<T> t(b.size());
   std::copy(b.cbegin(), b.cend(), t.begin());
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
index dd96dc80f2926..b96f0558943a6 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
@@ -16,8 +16,9 @@
 #ifndef TRACKINGITSU_INCLUDE_CACLUSTER_H_
 #define TRACKINGITSU_INCLUDE_CACLUSTER_H_
 
+#include <array>
+#include "ITStracking/Constants.h"
 #include "GPUCommonRtypes.h"
-#include "GPUCommonArray.h"
 
 namespace o2::its
 {
@@ -47,8 +48,8 @@ struct Cluster final {
   float zCoordinate{-999.f};
   float phi{-999.f};
   float radius{-999.f};
-  int clusterId{-1};
-  int indexTableBinIndex{-1};
+  int clusterId{constants::UnusedIndex};
+  int indexTableBinIndex{constants::UnusedIndex};
 
   ClassDefNV(Cluster, 1);
 };
@@ -70,7 +71,7 @@ struct TrackingFrameInfo final {
   float zCoordinate{-999.f};
   float xTrackingFrame{-999.f};
   float alphaTrackingFrame{-999.f};
-  std::array<float, 2> positionTrackingFrame = {-1., -1.};
+  std::array<float, 2> positionTrackingFrame = {constants::UnusedIndex, constants::UnusedIndex};
   std::array<float, 3> covarianceTrackingFrame = {999., 999., 999.};
 
   ClassDefNV(TrackingFrameInfo, 1);
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
index 1628bbc52776b..36e78ef24020c 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
@@ -16,6 +16,8 @@
 #ifndef TRACKINGITSU_INCLUDE_EXTERNALALLOCATOR_H_
 #define TRACKINGITSU_INCLUDE_EXTERNALALLOCATOR_H_
 
+#include <memory_resource>
+
 namespace o2::its
 {
 
@@ -25,6 +27,36 @@ class ExternalAllocator
   virtual void* allocate(size_t) = 0;
   virtual void deallocate(char*, size_t) = 0;
 };
+
+class ExternalAllocatorAdaptor final : public std::pmr::memory_resource
+{
+ public:
+  explicit ExternalAllocatorAdaptor(ExternalAllocator* alloc) : mAlloc(alloc) {}
+
+ protected:
+  void* do_allocate(size_t bytes, size_t alignment) override
+  {
+    void* p = mAlloc->allocate(bytes);
+    if (!p) {
+      throw std::bad_alloc();
+    }
+    return p;
+  }
+
+  void do_deallocate(void* p, size_t bytes, size_t) override
+  {
+    mAlloc->deallocate(static_cast<char*>(p), bytes);
+  }
+
+  bool do_is_equal(const std::pmr::memory_resource& other) const noexcept override
+  {
+    return this == &other;
+  }
+
+ private:
+  ExternalAllocator* mAlloc;
+};
+
 } // namespace o2::its
 
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index c34701ce222e2..436ce25336ca7 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -69,8 +69,8 @@ struct TimeFrame {
   using CellSeedN = CellSeed<nLayers>;
   friend class gpu::TimeFrameGPU<nLayers>;
 
-  TimeFrame();
-  virtual ~TimeFrame();
+  TimeFrame() = default;
+  virtual ~TimeFrame() = default;
 
   const Vertex& getPrimaryVertex(const int ivtx) const { return mPrimaryVertices[ivtx]; }
   gsl::span<const Vertex> getPrimaryVertices(int rofId) const;
@@ -95,7 +95,7 @@ struct TimeFrame {
                       gsl::span<const unsigned char>::iterator& pattIt,
                       const itsmft::TopologyDictionary* dict,
                       const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
-  void resetROFrameData();
+  void resetROFrameData(size_t nROFs);
 
   int getTotalClusters() const;
   auto& getTotVertIteration() { return mTotVertPerIteration; }
@@ -188,7 +188,7 @@ struct TimeFrame {
   auto getNumberOfUsedExtendedClusters() const { return mNExtendedUsedClusters; }
 
   /// memory management
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool);
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool);
   auto& getMemoryPool() const noexcept { return mMemoryPool; }
   bool checkMemory(unsigned long max) { return getArtefactsMemory() < max; }
   unsigned long getArtefactsMemory() const;
@@ -233,23 +233,26 @@ struct TimeFrame {
   void setBz(float bz) { mBz = bz; }
   float getBz() const { return mBz; }
 
-  void setExternalAllocator(ExternalAllocator* allocator)
+  /// State if memory will be externally managed.
+  // device
+  ExternalAllocator* mExtDeviceAllocator{nullptr};
+  void setExternalDeviceAllocator(ExternalAllocator* allocator) { mExtDeviceAllocator = allocator; }
+  ExternalAllocator* getExternalDeviceAllocator() { return mExtDeviceAllocator; }
+  bool hasExternalDeviceAllocator() const noexcept { return mExtDeviceAllocator != nullptr; }
+  // host
+  ExternalAllocator* mExtHostAllocator{nullptr};
+  void setExternalHostAllocator(ExternalAllocator* allocator)
   {
-    if (isGPU()) {
-      LOGP(debug, "Setting timeFrame allocator to external");
-      mAllocator = allocator;
-    } else {
-      LOGP(fatal, "External allocator is currently only supported for GPU");
-    }
+    mExtHostAllocator = allocator;
+    mExtMemoryPool = std::make_shared<BoundedMemoryResource>(mExtHostAllocator);
   }
-
-  ExternalAllocator* getExternalAllocator() { return mAllocator; }
-
-  virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>*)
-  {
-    return;
-  };
+  ExternalAllocator* getExternalHostAllocator() { return mExtHostAllocator; }
+  bool hasExternalHostAllocator() const noexcept { return mExtHostAllocator != nullptr; }
+  std::shared_ptr<BoundedMemoryResource> mExtMemoryPool;
+  std::pmr::memory_resource* getMaybeExternalHostResource(bool forceHost = false) { return (hasExternalHostAllocator() && !forceHost) ? mExtMemoryPool.get() : mMemoryPool.get(); }
+  // Propagator
   const o2::base::PropagatorImpl<float>* getDevicePropagator() const { return mPropagatorDevice; }
+  virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>*) {};
 
   template <typename... T>
   void addClusterToLayer(int layer, T&&... args);
@@ -257,9 +260,6 @@ struct TimeFrame {
   void addTrackingFrameInfoToLayer(int layer, T&&... args);
   void addClusterExternalIndexToLayer(int layer, const int idx) { mClusterExternalIndices[layer].push_back(idx); }
 
-  void resetVectors();
-  void resetTracklets();
-
   /// Debug and printing
   void checkTrackletLUTs();
   void printROFoffsets();
@@ -290,10 +290,6 @@ struct TimeFrame {
   bounded_vector<int> mROFramesPV;
   bounded_vector<Vertex> mPrimaryVertices;
 
-  // State if memory will be externally managed.
-  ExternalAllocator* mAllocator = nullptr;
-  bool getExtAllocator() const noexcept { return mAllocator != nullptr; }
-
   std::array<bounded_vector<Cluster>, nLayers> mUnsortedClusters;
   std::vector<bounded_vector<Tracklet>> mTracklets;
   std::vector<bounded_vector<CellSeedN>> mCells;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 642717bd09596..4c903ed1f3ca1 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -66,7 +66,7 @@ class Tracker
     const LogFunc& = [](const std::string& s) { std::cerr << s << '\n'; });
 
   void setParameters(const std::vector<TrackingParameters>& p) { mTrkParams = p; }
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
   void setBz(float bz) { mTraits->setBz(bz); }
   bool isMatLUT() const { return mTraits->isMatLUT(); }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 9d14bb91635a0..ee64cacb8fa2a 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -70,7 +70,7 @@ class TrackerTraits
   bool isMatLUT() const;
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool isGPU() const noexcept { return false; }
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) noexcept { mMemoryPool = pool; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) noexcept { mMemoryPool = pool; }
   auto getMemoryPool() const noexcept { return mMemoryPool; }
 
   // Others
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index ab92e7c1a1523..d66bcd6ee2358 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -52,7 +52,7 @@ class Vertexer
   auto& getVertParameters() const { return mTraits->getVertexingParameters(); }
   void setParameters(const std::vector<VertexingParameters>& vertParams) { mVertParams = vertParams; }
   const auto& getParameters() const noexcept { return mVertParams; }
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
 
   std::vector<Vertex> exportVertices();
   VertexerTraitsN* getTraits() const { return mTraits; };
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index dda32ddfd5aec..b1422d66e12df 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -82,7 +82,7 @@ class VertexerTraits
   virtual bool isGPU() const noexcept { return false; }
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool usesMemoryPool() const noexcept { return true; }
-  void setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool) { mMemoryPool = pool; }
+  void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
 
   static std::pair<o2::MCCompLabel, float> computeMain(const bounded_vector<o2::MCCompLabel>& elements)
   {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 510c66e2420f1..4ea0bedaced5f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -46,18 +46,6 @@ constexpr float DefClusErrorCol = o2::itsmft::SegmentationAlpide::PitchCol * 0.5
 constexpr float DefClusError2Row = DefClusErrorRow * DefClusErrorRow;
 constexpr float DefClusError2Col = DefClusErrorCol * DefClusErrorCol;
 
-template <int nLayers>
-TimeFrame<nLayers>::TimeFrame()
-{
-  resetVectors();
-}
-
-template <int nLayers>
-TimeFrame<nLayers>::~TimeFrame()
-{
-  wipe();
-}
-
 template <int nLayers>
 void TimeFrame<nLayers>::addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int iteration)
 {
@@ -121,14 +109,25 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
                                         const itsmft::TopologyDictionary* dict,
                                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  resetROFrameData();
+  resetROFrameData(rofs.size());
 
   GeometryTGeo* geom = GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
 
-  mNrof = 0;
+  mNrof = rofs.size();
   clearResizeBoundedVector(mClusterSize, clusters.size(), mMemoryPool.get());
-  for (auto& rof : rofs) {
+  std::array<int, nLayers> clusterCountPerLayer{};
+  for (const auto& clus : clusters) {
+    ++clusterCountPerLayer[geom->getLayer(clus.getSensorID())];
+  }
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
+  }
+
+  for (size_t iRof{0}; iRof < rofs.size(); ++iRof) {
+    const auto& rof = rofs[iRof];
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {
       const auto& c = clusters[clusterId];
 
@@ -164,15 +163,13 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
       addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), geom->getSensorRefAlpha(sensorID),
                                   std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
                                   std::array<float, 3>{sigmaY2, sigmaYZ, sigmaZ2});
-
       /// Rotate to the global frame
       addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), mUnsortedClusters[layer].size());
       addClusterExternalIndexToLayer(layer, clusterId);
     }
     for (unsigned int iL{0}; iL < mUnsortedClusters.size(); ++iL) {
-      mROFramesClusters[iL].push_back(mUnsortedClusters[iL].size());
+      mROFramesClusters[iL][iRof + 1] = mUnsortedClusters[iL].size(); // effectively calculating and exclusive sum
     }
-    mNrof++;
   }
 
   for (auto i = 0; i < mNTrackletsPerCluster.size(); ++i) {
@@ -185,16 +182,16 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
   }
 
   return mNrof;
-}
+} // namespace o2::its
 
 template <int nLayers>
-void TimeFrame<nLayers>::resetROFrameData()
+void TimeFrame<nLayers>::resetROFrameData(size_t nRofs)
 {
   for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
-    deepVectorClear(mUnsortedClusters[iLayer], mMemoryPool.get());
-    deepVectorClear(mTrackingFrameInfo[iLayer], mMemoryPool.get());
+    deepVectorClear(mUnsortedClusters[iLayer], getMaybeExternalHostResource());
+    deepVectorClear(mTrackingFrameInfo[iLayer], getMaybeExternalHostResource());
+    clearResizeBoundedVector(mROFramesClusters[iLayer], nRofs + 1, getMaybeExternalHostResource());
     deepVectorClear(mClusterExternalIndices[iLayer], mMemoryPool.get());
-    clearResizeBoundedVector(mROFramesClusters[iLayer], 1, mMemoryPool.get(), 0);
 
     if (iLayer < 2) {
       deepVectorClear(mTrackletsIndexROF[iLayer], mMemoryPool.get());
@@ -298,11 +295,11 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     clearResizeBoundedVector(mBogusClusters, trkParam.NLayers, mMemoryPool.get());
     deepVectorClear(mTrackletClusters);
     for (unsigned int iLayer{0}; iLayer < std::min((int)mClusters.size(), maxLayers); ++iLayer) {
-      clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), mMemoryPool.get());
-      clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), mMemoryPool.get());
+      clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeExternalHostResource(maxLayers != nLayers));
+      clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeExternalHostResource(maxLayers != nLayers));
       mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
     }
-    clearResizeBoundedArray(mIndexTables, mNrof * (trkParam.ZBins * trkParam.PhiBins + 1), mMemoryPool.get());
+    clearResizeBoundedArray(mIndexTables, mNrof * (trkParam.ZBins * trkParam.PhiBins + 1), getMaybeExternalHostResource(maxLayers != nLayers));
     clearResizeBoundedVector(mLines, mNrof, mMemoryPool.get());
     clearResizeBoundedVector(mTrackletClusters, mNrof, mMemoryPool.get());
 
@@ -315,6 +312,8 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
         }
       }
     }
+    mMinR.fill(10000.);
+    mMaxR.fill(-1.);
   }
   mNTrackletsPerROF.resize(2);
   for (auto& v : mNTrackletsPerROF) {
@@ -453,34 +452,6 @@ void TimeFrame<nLayers>::checkTrackletLUTs()
   }
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::resetVectors()
-{
-  mMinR.fill(10000.);
-  mMaxR.fill(-1.);
-  for (int iLayers{nLayers}; iLayers--;) {
-    mClusters[iLayers].clear();
-    mUnsortedClusters[iLayers].clear();
-    mTrackingFrameInfo[iLayers].clear();
-    mClusterExternalIndices[iLayers].clear();
-    mUsedClusters[iLayers].clear();
-    mROFramesClusters[iLayers].clear();
-    mNClustersPerROF[iLayers].clear();
-  }
-  for (int i{2}; i--;) {
-    mTrackletsIndexROF[i].clear();
-  }
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::resetTracklets()
-{
-  for (auto& trkl : mTracklets) {
-    deepVectorClear(trkl);
-  }
-  deepVectorClear(mTrackletsLookupTable);
-}
-
 template <int nLayers>
 void TimeFrame<nLayers>::printTrackletLUTonLayer(int i)
 {
@@ -575,75 +546,67 @@ void TimeFrame<nLayers>::printSliceInfo(const int startROF, const int sliceSize)
     LOG(info) << "Number of seeding vertices: " << getPrimaryVertices(iROF).size();
     int iVertex{0};
     for (auto& v : getPrimaryVertices(iROF)) {
-      LOG(info) << "\t vertex " << iVertex++ << ": x=" << v.getX() << " " << " y=" << v.getY() << " z=" << v.getZ() << " has " << v.getNContributors() << " contributors.";
+      LOG(info) << "\t vertex " << iVertex++ << ": x=" << v.getX() << " "
+                << " y=" << v.getY() << " z=" << v.getZ() << " has " << v.getNContributors() << " contributors.";
     }
   }
 }
 
 template <int nLayers>
-void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource>& pool)
+void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
 {
   mMemoryPool = pool;
 
-  auto initVector = [&]<typename T>(bounded_vector<T>& vec) {
-    auto alloc = vec.get_allocator().resource();
-    if (alloc != mMemoryPool.get()) {
-      vec = bounded_vector<T>(mMemoryPool.get());
-    }
-  };
-  auto initArrays = [&]<typename T, size_t S>(std::array<bounded_vector<T>, S>& arr) {
-    for (size_t i{0}; i < S; ++i) {
-      auto alloc = arr[i].get_allocator().resource();
-      if (alloc != mMemoryPool.get()) {
-        arr[i] = bounded_vector<T>(mMemoryPool.get());
-      }
-    }
+  auto initVector = [&]<typename T>(bounded_vector<T>& vec, bool useExternal = false) {
+    std::pmr::memory_resource* mr = (useExternal) ? mExtMemoryPool.get() : mMemoryPool.get();
+    deepVectorClear(vec, mr);
   };
-  auto initVectors = [&]<typename T>(std::vector<bounded_vector<T>>& vec) {
-    for (size_t i{0}; i < vec.size(); ++i) {
-      auto alloc = vec[i].get_allocator().resource();
-      if (alloc != mMemoryPool.get()) {
-        vec[i] = bounded_vector<T>(mMemoryPool.get());
-      }
+
+  auto initContainers = [&]<typename Container>(Container& container, bool useExternal = false) {
+    for (auto& v : container) {
+      initVector(v, useExternal);
     }
   };
-
+  // these will only reside on the host for the cpu part
   initVector(mTotVertPerIteration);
-  initVector(mPrimaryVertices);
-  initVector(mROFramesPV);
-  initArrays(mClusters);
-  initArrays(mTrackingFrameInfo);
-  initArrays(mClusterExternalIndices);
-  initArrays(mROFramesClusters);
-  initArrays(mNTrackletsPerCluster);
-  initArrays(mNTrackletsPerClusterSum);
-  initArrays(mNClustersPerROF);
-  initArrays(mIndexTables);
-  initArrays(mUsedClusters);
-  initArrays(mUnsortedClusters);
+  initContainers(mClusterExternalIndices);
+  initContainers(mNTrackletsPerCluster);
+  initContainers(mNTrackletsPerClusterSum);
+  initContainers(mNClustersPerROF);
   initVector(mROFramesPV);
   initVector(mPrimaryVertices);
   initVector(mRoads);
-  initVector(mRoadLabels);
   initVector(mMSangles);
   initVector(mPhiCuts);
   initVector(mPositionResolution);
   initVector(mClusterSize);
   initVector(mPValphaX);
   initVector(mBogusClusters);
+  initContainers(mTrackletsIndexROF);
+  initContainers(mTracks);
+  initContainers(mTracklets);
+  initContainers(mCells);
+  initContainers(mCellsNeighbours);
+  initContainers(mCellsLookupTable);
+  // MC info (we don't know if we have MC)
   initVector(mVerticesContributorLabels);
-  initArrays(mTrackletsIndexROF);
-  initVectors(mTracks);
-  initVectors(mTracklets);
-  initVectors(mCells);
-  initVectors(mCellsNeighbours);
-  initVectors(mCellsLookupTable);
+  initContainers(mLinesLabels);
+  initContainers(mTrackletLabels);
+  initContainers(mCellLabels);
+  initVector(mRoadLabels);
+  initContainers(mTracksLabel);
+  // these will use possibly an externally provided allocator
+  initContainers(mClusters, hasExternalHostAllocator());
+  initContainers(mUsedClusters, hasExternalHostAllocator());
+  initContainers(mUnsortedClusters, hasExternalHostAllocator());
+  initContainers(mIndexTables, hasExternalHostAllocator());
+  initContainers(mTrackingFrameInfo, hasExternalHostAllocator());
+  initContainers(mROFramesClusters, hasExternalHostAllocator());
 }
 
 template <int nLayers>
 void TimeFrame<nLayers>::wipe()
 {
-  deepVectorClear(mUnsortedClusters);
   deepVectorClear(mTracks);
   deepVectorClear(mTracklets);
   deepVectorClear(mCells);
@@ -652,20 +615,12 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mCellsLookupTable);
   deepVectorClear(mTotVertPerIteration);
   deepVectorClear(mPrimaryVertices);
-  deepVectorClear(mClusters);
   deepVectorClear(mTrackletsLookupTable);
-  deepVectorClear(mTrackingFrameInfo);
   deepVectorClear(mClusterExternalIndices);
-  deepVectorClear(mROFramesClusters);
   deepVectorClear(mNTrackletsPerCluster);
   deepVectorClear(mNTrackletsPerClusterSum);
   deepVectorClear(mNClustersPerROF);
-  deepVectorClear(mIndexTables);
-  deepVectorClear(mUsedClusters);
-  deepVectorClear(mUnsortedClusters);
   deepVectorClear(mROFramesPV);
-  deepVectorClear(mPrimaryVertices);
-  deepVectorClear(mRoads);
   deepVectorClear(mMSangles);
   deepVectorClear(mPhiCuts);
   deepVectorClear(mPositionResolution);
@@ -673,9 +628,19 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mPValphaX);
   deepVectorClear(mBogusClusters);
   deepVectorClear(mTrackletsIndexROF);
-  deepVectorClear(mPrimaryVertices);
   deepVectorClear(mTrackletClusters);
   deepVectorClear(mLines);
+  // if we use the external host allocator then the assumption is that we
+  // don't clear the memory ourself
+  if (!hasExternalHostAllocator()) {
+    deepVectorClear(mClusters);
+    deepVectorClear(mUsedClusters);
+    deepVectorClear(mUnsortedClusters);
+    deepVectorClear(mIndexTables);
+    deepVectorClear(mTrackingFrameInfo);
+    deepVectorClear(mROFramesClusters);
+  }
+  // only needed to clear if we have MC info
   if (hasMCinformation()) {
     deepVectorClear(mLinesLabels);
     deepVectorClear(mVerticesContributorLabels);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 69dddbf367653..c4b1fb427513f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -54,7 +54,6 @@ float Vertexer<nLayers>::clustersToVertices(LogFunc logger)
       throw err;
     } else {
       LOGP(error, "Dropping this TF!");
-      mTimeFrame->resetTracklets();
     }
   };
 
diff --git a/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
new file mode 100644
index 0000000000000..818ad1d667371
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
@@ -0,0 +1,16 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_test(boundedmemoryresource
+            SOURCES testBoundedMemoryResource.cxx
+            COMPONENT_NAME its-tracking
+            LABELS "its;tracking"
+            PUBLIC_LINK_LIBRARIES O2::ITStracking)
diff --git a/Detectors/ITSMFT/ITS/tracking/test/testBoundedMemoryResource.cxx b/Detectors/ITSMFT/ITS/tracking/test/testBoundedMemoryResource.cxx
new file mode 100644
index 0000000000000..aae28f5cbc36e
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/test/testBoundedMemoryResource.cxx
@@ -0,0 +1,190 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#define BOOST_TEST_MODULE Test Flags
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_DYN_LINK
+
+#include <boost/test/unit_test.hpp>
+#include <random>
+#include "ITStracking/BoundedAllocator.h"
+
+using namespace o2::its;
+using Vec = bounded_vector<int>;
+auto getRandomInt(int min = -100, int max = 100)
+{
+  static std::mt19937 gen(std::random_device{}()); // static generator, seeded once
+  std::uniform_int_distribution<> dist(min, max);
+  return [&, dist]() mutable {
+    return dist(gen);
+  };
+}
+
+// -------- Throwing upstream resource for testing rollback --------
+class ThrowingResource final : public std::pmr::memory_resource
+{
+ protected:
+  void* do_allocate(size_t, size_t) final
+  {
+    throw std::bad_alloc(); // always fail
+  }
+  void do_deallocate(void*, size_t, size_t) noexcept final
+  {
+    // nothing
+  }
+  bool do_is_equal(const std::pmr::memory_resource& other) const noexcept final
+  {
+    return this == &other;
+  }
+};
+
+// -------- Upstream resource with empty deallocate --------
+class NoDeallocateResource final : public std::pmr::memory_resource
+{
+ public:
+  NoDeallocateResource(std::pmr::memory_resource* upstream = std::pmr::get_default_resource())
+    : mUpstream(upstream) {}
+
+ protected:
+  void* do_allocate(size_t bytes, size_t alignment) final
+  {
+    return mUpstream->allocate(bytes, alignment);
+  }
+  void do_deallocate(void*, size_t, size_t) noexcept final
+  {
+    // nothing
+  }
+  bool do_is_equal(const std::pmr::memory_resource& other) const noexcept final
+  {
+    return this == &other;
+  }
+
+ private:
+  std::pmr::memory_resource* mUpstream;
+};
+
+// -------- Tests --------
+BOOST_AUTO_TEST_CASE(allocation_and_clear_updates_used_memory)
+{
+  BoundedMemoryResource bmr(10 * 1024 * 1024); // 10 MB cap
+
+  Vec v(std::pmr::polymorphic_allocator<int>{&bmr});
+  BOOST_CHECK_EQUAL(bmr.getUsedMemory(), 0u);
+
+  const size_t count = 128;
+  v.reserve(count);
+  const size_t expected = count * sizeof(int);
+  BOOST_CHECK_GE(bmr.getUsedMemory(), expected);
+  BOOST_CHECK_LE(bmr.getUsedMemory(), expected + 64);
+
+  deepVectorClear(v, &bmr);
+  BOOST_CHECK_EQUAL(bmr.getUsedMemory(), 0u);
+}
+
+BOOST_AUTO_TEST_CASE(clearResizeBoundedVector_resizes_and_tracks_memory)
+{
+  BoundedMemoryResource bmr(1024 * 1024); // 1 MB cap
+
+  Vec v(std::pmr::polymorphic_allocator<int>{&bmr});
+  v.reserve(200);
+  const size_t used_before = bmr.getUsedMemory();
+  BOOST_CHECK_GT(used_before, 0u);
+
+  clearResizeBoundedVector(v, 50, &bmr, 7);
+  const size_t used_after = bmr.getUsedMemory();
+  BOOST_CHECK_GE(used_after, 50 * sizeof(int));
+  BOOST_CHECK_LT(used_after, used_before);
+
+  clearResizeBoundedVector(v, 300, &bmr, 3);
+  BOOST_CHECK_GE(bmr.getUsedMemory(), 300 * sizeof(int));
+}
+
+BOOST_AUTO_TEST_CASE(upstream_throw_rolls_back_reservation)
+{
+  ThrowingResource upstream;
+  BoundedMemoryResource bmr(std::numeric_limits<size_t>::max(), &upstream);
+  const size_t bytes = 1024;
+  bool threw = false;
+  void* p{nullptr};
+  try {
+    p = bmr.allocate(bytes, alignof(std::max_align_t));
+  } catch (const std::bad_alloc&) {
+    threw = true;
+  }
+  BOOST_CHECK(threw);
+  BOOST_CHECK_EQUAL(p, nullptr);
+  BOOST_CHECK_EQUAL(bmr.getUsedMemory(), 0u);
+}
+
+BOOST_AUTO_TEST_CASE(vector_of_bounded_vectors_deep_clear_releases_all)
+{
+  BoundedMemoryResource bmr(10 * 1024 * 1024); // 10 MB
+  std::vector<Vec> outer;
+  outer.reserve(5);
+  for (int i = 0; i < 5; ++i) {
+    outer.emplace_back(std::pmr::polymorphic_allocator<int>{&bmr});
+    outer.back().reserve(100);
+  }
+  BOOST_CHECK_GT(bmr.getUsedMemory(), 0u);
+  deepVectorClear(outer, &bmr); // deep clear outer
+  BOOST_CHECK_EQUAL(bmr.getUsedMemory(), 0u);
+}
+
+BOOST_AUTO_TEST_CASE(array_of_bounded_vectors_clear_resize_works)
+{
+  BoundedMemoryResource bmr(10 * 1024 * 1024);
+  std::array<Vec, 3> arr{{Vec(std::pmr::polymorphic_allocator<int>{&bmr}),
+                          Vec(std::pmr::polymorphic_allocator<int>{&bmr}),
+                          Vec(std::pmr::polymorphic_allocator<int>{&bmr})}};
+  clearResizeBoundedVector(arr[0], 10, &bmr, 1);
+  clearResizeBoundedVector(arr[1], 20, &bmr, 2);
+  clearResizeBoundedVector(arr[2], 30, &bmr, 3);
+  BOOST_CHECK_GT(bmr.getUsedMemory(), 0u);
+  deepVectorClear(arr, &bmr); // now clear all recursively
+  BOOST_CHECK_EQUAL(bmr.getUsedMemory(), 0u);
+}
+
+BOOST_AUTO_TEST_CASE(deepVectorClear_releases_and_reuses_resource)
+{
+  // Use a small bounded memory resource
+  BoundedMemoryResource bmr(1024);
+  bounded_vector<int> vec{std::pmr::polymorphic_allocator<int>{&bmr}};
+  vec.resize(100, 42);
+  BOOST_TEST(bmr.getUsedMemory() > 0);
+  deepVectorClear(vec, &bmr);
+  BOOST_TEST(vec.empty());
+  BOOST_TEST(vec.get_allocator().resource() == &bmr);
+  auto usedAfter = bmr.getUsedMemory();
+  BOOST_CHECK_EQUAL(bmr.getUsedMemory(), 0);
+  vec.push_back(7);
+  BOOST_TEST(vec.size() == 1);
+  BOOST_TEST(vec[0] == 7);
+  BOOST_TEST(vec.get_allocator().resource() == &bmr);
+}
+
+BOOST_AUTO_TEST_CASE(clear_with_memory_resource_without_deallocator)
+{
+  NoDeallocateResource dmr;
+  Vec v(std::pmr::polymorphic_allocator<int>{&dmr});
+
+  for (int shift{0}; shift < 12; ++shift) {
+    const int c{1 << shift};
+    v.resize(100);
+    std::generate(v.begin(), v.end(), getRandomInt());
+    // allocate different sizes, which is actually a no-op now
+    clearResizeBoundedVector(v, c / 2, &dmr, 999);
+    for (size_t i{0}; i < c / 2; ++i) { // now only the first c/2 elements should be set
+      BOOST_CHECK_EQUAL(v[i], 999);
+    }
+    // try to deepclear
+    deepVectorClear(v);
+  }
+}
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index acba8022e376f..2fced813efc93 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -64,7 +64,7 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
                         const its3::TopologyDictionary* dict,
                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  tf->resetROFrameData();
+  tf->resetROFrameData(rofs.size());
 
   auto geom = its::GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index 26dff3710cd4a..a85cdb48c4d1c 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -17,7 +17,6 @@
 #include "DataFormatsITS/TrackITS.h"
 #include "ITStracking/ExternalAllocator.h"
 #include "GPUReconstructionIncludesITS.h"
-#include <algorithm>
 
 using namespace o2::gpu;
 
@@ -26,15 +25,18 @@ namespace o2::its
 class GPUFrameworkExternalAllocator final : public o2::its::ExternalAllocator
 {
  public:
+  GPUFrameworkExternalAllocator(GPUMemoryResource::MemoryType type) : mType(type) {}
+
   void* allocate(size_t size) override
   {
-    return mFWReco->AllocateDirectMemory(size, GPUMemoryResource::MEMORY_GPU);
+    return mFWReco->AllocateDirectMemory(size, mType);
   }
-  void deallocate(char* ptr, size_t) override {}
+  void deallocate(char* ptr, size_t size) override {}
   void setReconstructionFramework(o2::gpu::GPUReconstruction* fwr) { mFWReco = fwr; }
 
  private:
   o2::gpu::GPUReconstruction* mFWReco;
+  GPUMemoryResource::MemoryType mType;
 };
 } // namespace o2::its
 
@@ -71,11 +73,12 @@ o2::its::TimeFrame<7>* GPUChainITS::GetITSTimeframe()
   }
 #if !defined(GPUCA_STANDALONE)
   if (mITSTimeFrame->isGPU()) {
-    auto doFWExtAlloc = [this](size_t size) -> void* { return rec()->AllocateDirectMemory(size, GPUMemoryResource::MEMORY_GPU); };
-
-    mFrameworkAllocator.reset(new o2::its::GPUFrameworkExternalAllocator);
-    mFrameworkAllocator->setReconstructionFramework(rec());
-    mITSTimeFrame->setExternalAllocator(mFrameworkAllocator.get());
+    mFrameworkDeviceAllocator.reset(new o2::its::GPUFrameworkExternalAllocator(GPUMemoryResource::MEMORY_GPU));
+    mFrameworkDeviceAllocator->setReconstructionFramework(rec());
+    mITSTimeFrame->setExternalDeviceAllocator(mFrameworkDeviceAllocator.get());
+    mFrameworkHostAllocator.reset(new o2::its::GPUFrameworkExternalAllocator(GPUMemoryResource::MEMORY_HOST));
+    mFrameworkHostAllocator->setReconstructionFramework(rec());
+    mITSTimeFrame->setExternalHostAllocator(mFrameworkHostAllocator.get());
   }
 #endif
   return mITSTimeFrame.get();
diff --git a/GPU/GPUTracking/Global/GPUChainITS.h b/GPU/GPUTracking/Global/GPUChainITS.h
index a607f66322bab..ab693bcef3f8b 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.h
+++ b/GPU/GPUTracking/Global/GPUChainITS.h
@@ -53,7 +53,8 @@ class GPUChainITS final : public GPUChain
   std::unique_ptr<o2::its::TrackerTraits<7>> mITSTrackerTraits;
   std::unique_ptr<o2::its::VertexerTraits<7>> mITSVertexerTraits;
   std::unique_ptr<o2::its::TimeFrame<7>> mITSTimeFrame;
-  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkAllocator;
+  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkDeviceAllocator;
+  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkHostAllocator;
 };
 } // namespace o2::gpu
 

From c864689194308e3dc4cadbee1803f69c65ebd50a Mon Sep 17 00:00:00 2001
From: Francesco Mazzaschi <43742195+fmazzasc@users.noreply.github.com>
Date: Thu, 25 Sep 2025 16:43:42 +0200
Subject: [PATCH 0865/1764] Add ITS fake clusters information to the mcMask
 (#14666)

* Add ITS fake clusters information to the mcMask

* remove redundant check

---------

Co-authored-by: Francesco Mazzaschi <fmazzasc@alipap1.cern.ch>
---
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx   | 17 ++++++++++++++++-
 .../Core/include/Framework/AnalysisDataModel.h  |  2 +-
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 8247eb3d870c0..90cf420bc9bf6 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -1126,7 +1126,7 @@ void AODProducerWorkflowDPL::fillMCTrackLabelsTable(MCTrackLabelCursorType& mcTr
           if (!needToStore(mGIDToTableID)) {
             continue;
           }
-          if (mcTruth.isValid()) { // if not set, -1 will be stored
+          if (mcTruth.isValid()) {                                                                               // if not set, -1 will be stored
             labelHolder.labelID = (mToStore[mcTruth.getSourceID()][mcTruth.getEventID()])[mcTruth.getTrackID()]; // defined by TPC if it contributes, otherwise: by ITS
             if (mcTruth.isFake()) {
               labelHolder.labelMask |= (0x1 << 15);
@@ -1139,6 +1139,21 @@ void AODProducerWorkflowDPL::fillMCTrackLabelsTable(MCTrackLabelCursorType& mcTr
                 }
               }
             }
+            if (trackIndex.includesDet(DetID::ITS)) {
+              auto itsGID = data.getITSContributorGID(trackIndex);
+              auto itsSource = itsGID.getSource();
+              if (itsSource == GIndex::ITS) {
+                auto& itsTrack = data.getITSTrack(itsGID);
+                for (unsigned int iL = 0; iL < 7; ++iL) {
+                  if (itsTrack.isFakeOnLayer(iL)) {
+                    labelHolder.labelMask |= (0x1 << iL);
+                  }
+                }
+              } else if (itsSource == GIndex::ITSAB) {
+                labelHolder.labelMask |= (data.getTrackMCLabel(itsGID).isFake() << 12);
+              }
+            }
+
           } else if (mcTruth.isNoise()) {
             labelHolder.labelMask |= (0x1 << 14);
           }
diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index 2a9e1b61ee6df..b174f3858e165 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -2017,7 +2017,7 @@ namespace aod
 namespace mctracklabel
 {
 DECLARE_SOA_INDEX_COLUMN(McParticle, mcParticle); //! MC particle
-DECLARE_SOA_COLUMN(McMask, mcMask, uint16_t);     //! Bit mask to indicate detector mismatches (bit ON means mismatch). Bit 0-6: mismatch at ITS layer. Bit 7-9: # of TPC mismatches in the ranges 0, 1, 2-3, 4-7, 8-15, 16-31, 32-63, >64. Bit 10: TRD, bit 11: TOF, bit 15: indicates negative label
+DECLARE_SOA_COLUMN(McMask, mcMask, uint16_t);     //! Bit mask to indicate detector mismatches (bit ON means mismatch). Bit 0-6: mismatch at ITS layer. Bit 12: ITSAB tracklet mismatch. Bit 13: ITS-TPC mismatch. Bit 14: isNoise == True (global track), Bit 15: isFake == True (global track)
 } // namespace mctracklabel
 
 DECLARE_SOA_TABLE(McTrackLabels, "AOD", "MCTRACKLABEL", //! Table joined to the track table containing the MC index

From cec632fcc29c3d7f98f4802b20928e426a16d027 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 12 Sep 2025 07:42:57 +0200
Subject: [PATCH 0866/1764] Common: allow literal suffix and add tests for
 confkey

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Common/Utils/CMakeLists.txt                   |  15 ++
 .../CommonUtils/ConfigurableParamTest.h       |  45 ++++++
 Common/Utils/src/CommonUtilsTestLinkDef.h     |  21 +++
 Common/Utils/src/ConfigurableParam.cxx        |  62 +++++++-
 Common/Utils/src/ConfigurableParamTest.cxx    |  13 ++
 Common/Utils/test/testConfigurableParam.cxx   | 145 ++++++++++++++++++
 6 files changed, 297 insertions(+), 4 deletions(-)
 create mode 100644 Common/Utils/include/CommonUtils/ConfigurableParamTest.h
 create mode 100644 Common/Utils/src/CommonUtilsTestLinkDef.h
 create mode 100644 Common/Utils/src/ConfigurableParamTest.cxx
 create mode 100644 Common/Utils/test/testConfigurableParam.cxx

diff --git a/Common/Utils/CMakeLists.txt b/Common/Utils/CMakeLists.txt
index d9954e23ab435..849a3d70f62e1 100644
--- a/Common/Utils/CMakeLists.txt
+++ b/Common/Utils/CMakeLists.txt
@@ -51,6 +51,15 @@ o2_target_root_dictionary(CommonUtils
                                   include/CommonUtils/IRFrameSelector.h
                                   include/CommonUtils/DebugStreamer.h)
 
+# Extra dictionaries only needed if tests are built
+if(BUILD_TESTING)
+    o2_add_library(CommonUtilsTest
+               SOURCES src/ConfigurableParamTest.cxx
+                       PUBLIC_LINK_LIBRARIES O2::CommonUtils)
+    o2_target_root_dictionary(CommonUtilsTest
+                              HEADERS include/CommonUtils/ConfigurableParamTest.h)
+endif()
+
 o2_add_test(TreeStream
             COMPONENT_NAME CommonUtils
             LABELS utils
@@ -87,6 +96,12 @@ o2_add_test(EnumFlags
             SOURCES test/testEnumFlags.cxx
             PUBLIC_LINK_LIBRARIES O2::CommonUtils)
 
+o2_add_test(ConfigurableParam
+            COMPONENT_NAME CommonUtils
+            LABELS utils
+            SOURCES test/testConfigurableParam.cxx
+            PUBLIC_LINK_LIBRARIES O2::CommonUtilsTest)
+
 o2_add_executable(treemergertool
             COMPONENT_NAME CommonUtils
           SOURCES src/TreeMergerTool.cxx
diff --git a/Common/Utils/include/CommonUtils/ConfigurableParamTest.h b/Common/Utils/include/CommonUtils/ConfigurableParamTest.h
new file mode 100644
index 0000000000000..547bbf9ba8c38
--- /dev/null
+++ b/Common/Utils/include/CommonUtils/ConfigurableParamTest.h
@@ -0,0 +1,45 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef COMMON_CONFIGURABLE_PARAM_TEST_H_
+#define COMMON_CONFIGURABLE_PARAM_TEST_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2::conf::test
+{
+struct TestParam : public o2::conf::ConfigurableParamHelper<TestParam> {
+  enum TestEnum : uint8_t {
+    A,
+    B,
+    C
+  };
+
+  int iValue{42};
+  float fValue{3.14};
+  double dValue{3.14};
+  bool bValue{true};
+  unsigned uValue{1};
+  long lValue{1};
+  unsigned long ulValue{1};
+  long long llValue{1};
+  unsigned long long ullValue{1};
+  std::string sValue = "default";
+  int iValueProvenanceTest{0};
+  TestEnum eValue = TestEnum::C;
+  int caValue[3] = {0, 1, 2};
+
+  O2ParamDef(TestParam, "TestParam");
+};
+} // namespace o2::conf::test
+
+#endif
diff --git a/Common/Utils/src/CommonUtilsTestLinkDef.h b/Common/Utils/src/CommonUtilsTestLinkDef.h
new file mode 100644
index 0000000000000..9ee67f62fd7d0
--- /dev/null
+++ b/Common/Utils/src/CommonUtilsTestLinkDef.h
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::conf::test::TestParam + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::conf::test::TestParam> + ;
+
+#endif
diff --git a/Common/Utils/src/ConfigurableParam.cxx b/Common/Utils/src/ConfigurableParam.cxx
index 8e242952bd61d..8497a485fca39 100644
--- a/Common/Utils/src/ConfigurableParam.cxx
+++ b/Common/Utils/src/ConfigurableParam.cxx
@@ -77,6 +77,30 @@ bool keyInTree(boost::property_tree::ptree* pt, const std::string& key)
   return reply;
 }
 
+// Convert a type info to the appropiate literal suffix
+std::string getLiteralSuffixFromType(const std::type_info& type)
+{
+  if (type == typeid(float)) {
+    return "f";
+  }
+  if (type == typeid(long double)) {
+    return "l";
+  }
+  if (type == typeid(unsigned int)) {
+    return "u";
+  }
+  if (type == typeid(unsigned long)) {
+    return "ul";
+  }
+  if (type == typeid(long long)) {
+    return "ll";
+  }
+  if (type == typeid(unsigned long long)) {
+    return "ull";
+  }
+  return "";
+}
+
 // ------------------------------------------------------------------
 
 void EnumRegistry::add(const std::string& key, const TDataMember* dm)
@@ -204,12 +228,42 @@ void ConfigurableParam::setValue(std::string const& key, std::string const& valu
     initialize();
   }
   assert(sPtree);
+  auto setValueImpl = [&](std::string const& value) {
+    sPtree->put(key, value);
+    auto changed = updateThroughStorageMapWithConversion(key, value);
+    if (changed != EParamUpdateStatus::Failed) {
+      sValueProvenanceMap->find(key)->second = kRT; // set to runtime
+    }
+  };
   try {
     if (sPtree->get_optional<std::string>(key).is_initialized()) {
-      sPtree->put(key, valuestring);
-      auto changed = updateThroughStorageMapWithConversion(key, valuestring);
-      if (changed != EParamUpdateStatus::Failed) {
-        sValueProvenanceMap->find(key)->second = kRT; // set to runtime
+      try {
+        // try first setting value without stripping a literal suffix
+        setValueImpl(valuestring);
+      } catch (...) {
+        // try second stripping the expected literal suffix value for fundamental types
+        auto iter = sKeyToStorageMap->find(key);
+        if (iter == sKeyToStorageMap->end()) {
+          std::cerr << "Error in setValue (string) key is not known\n";
+          return;
+        }
+        const auto expectedSuffix = getLiteralSuffixFromType(iter->second.first);
+        if (!expectedSuffix.empty()) {
+          auto valuestringLower = valuestring;
+          std::transform(valuestring.cbegin(), valuestring.cend(), valuestringLower.begin(), tolower);
+          if (valuestringLower.ends_with(expectedSuffix)) {
+            std::string strippedValue = valuestringLower.substr(0, valuestringLower.length() - expectedSuffix.length());
+            setValueImpl(strippedValue);
+          } else {
+            // check if it has a different suffix and throw
+            for (const auto& suffix : {"f", "l", "u", "ul", "ll", "ull"}) {
+              if (valuestringLower.ends_with(suffix) && suffix != expectedSuffix) {
+                throw std::invalid_argument("Wrong type suffix: expected " + expectedSuffix + " but got " + suffix);
+              }
+            }
+            throw; // just rethrow the original exception
+          }
+        }
       }
     }
   } catch (std::exception const& e) {
diff --git a/Common/Utils/src/ConfigurableParamTest.cxx b/Common/Utils/src/ConfigurableParamTest.cxx
new file mode 100644
index 0000000000000..5115a8dfe889d
--- /dev/null
+++ b/Common/Utils/src/ConfigurableParamTest.cxx
@@ -0,0 +1,13 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "CommonUtils/ConfigurableParamTest.h"
+O2ParamImpl(o2::conf::test::TestParam);
diff --git a/Common/Utils/test/testConfigurableParam.cxx b/Common/Utils/test/testConfigurableParam.cxx
new file mode 100644
index 0000000000000..3ef177aaca3fe
--- /dev/null
+++ b/Common/Utils/test/testConfigurableParam.cxx
@@ -0,0 +1,145 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#define BOOST_TEST_MODULE Test ConfigurableParams
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_DYN_LINK
+
+#include <boost/test/unit_test.hpp>
+#include <boost/property_tree/ptree.hpp>
+#include <filesystem>
+
+#include "CommonUtils/ConfigurableParamTest.h"
+
+using namespace o2::conf;
+using namespace o2::conf::test;
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_Basic)
+{
+  // Tests the default parameters and also getter helpers.
+  auto& param = TestParam::Instance();
+  BOOST_CHECK_EQUAL(param.iValue, 42);
+  BOOST_CHECK_EQUAL(param.dValue, 3.14);
+  BOOST_CHECK_EQUAL(param.bValue, true);
+  BOOST_CHECK_EQUAL(param.sValue, "default");
+  BOOST_CHECK_EQUAL(static_cast<int>(param.eValue), 2);
+
+  BOOST_CHECK_EQUAL(ConfigurableParam::getValueAs<int>("TestParam.iValue"), 42);
+  BOOST_CHECK_EQUAL(ConfigurableParam::getValueAs<double>("TestParam.dValue"), 3.14);
+  BOOST_CHECK_EQUAL(ConfigurableParam::getValueAs<bool>("TestParam.bValue"), true);
+  BOOST_CHECK_EQUAL(ConfigurableParam::getValueAs<std::string>("TestParam.sValue"), "default");
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_SG_Fundamental)
+{
+  // tests runtime setting and getting for fundamental types
+  ConfigurableParam::setValue("TestParam.iValue", "100");
+  ConfigurableParam::setValue("TestParam.dValue", "2.718");
+  ConfigurableParam::setValue("TestParam.bValue", "0");
+  ConfigurableParam::setValue("TestParam.sValue", "modified");
+  ConfigurableParam::setValue("TestParam.eValue", "0");
+
+  auto& param = TestParam::Instance();
+  param.printKeyValues();
+  BOOST_CHECK_EQUAL(param.iValue, 100);
+  BOOST_CHECK_EQUAL(param.dValue, 2.718);
+  BOOST_CHECK_EQUAL(param.bValue, false);
+  BOOST_CHECK_EQUAL(param.sValue, "modified");
+  BOOST_CHECK_EQUAL(static_cast<int>(param.eValue), 0);
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_SG_CArray)
+{
+  // tests setting and getting for a c-style array type
+  auto& param = TestParam::Instance();
+  BOOST_CHECK_EQUAL(ConfigurableParam::getValueAs<int>("TestParam.caValue[0]"), 0);
+  BOOST_CHECK_EQUAL(ConfigurableParam::getValueAs<int>("TestParam.caValue[1]"), 1);
+  BOOST_CHECK_EQUAL(ConfigurableParam::getValueAs<int>("TestParam.caValue[2]"), 2);
+
+  ConfigurableParam::setValue("TestParam.caValue[1]", "99");
+  BOOST_CHECK_EQUAL(ConfigurableParam::getValueAs<int>("TestParam.caValue[1]"), 99);
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_Provenance)
+{
+  // tests correct setting of provenance
+  BOOST_CHECK_EQUAL(ConfigurableParam::getProvenance("TestParam.iValueProvenanceTest"), ConfigurableParam::EParamProvenance::kCODE);
+  ConfigurableParam::setValue("TestParam.iValueProvenanceTest", "123");
+  BOOST_CHECK_EQUAL(ConfigurableParam::getProvenance("TestParam.iValueProvenanceTest"), ConfigurableParam::EParamProvenance::kRT);
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_FileIO_Ini)
+{
+  // test for ini file serialization
+  const std::string testFileName = "test_config.ini";
+  auto iValueBefore = TestParam::Instance().iValue;
+  auto sValueBefore = TestParam::Instance().sValue;
+  ConfigurableParam::writeINI(testFileName);
+  ConfigurableParam::setValue("TestParam.iValue", "999");
+  ConfigurableParam::setValue("TestParam.sValue", testFileName);
+  ConfigurableParam::updateFromFile(testFileName);
+  BOOST_CHECK_EQUAL(TestParam::Instance().iValue, iValueBefore);
+  BOOST_CHECK_EQUAL(TestParam::Instance().sValue, sValueBefore);
+  std::remove(testFileName.c_str());
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_FileIO_Json)
+{
+  // test for json file serialization
+  const std::string testFileName = "test_config.json";
+  auto iValueBefore = TestParam::Instance().iValue;
+  auto sValueBefore = TestParam::Instance().sValue;
+  ConfigurableParam::writeJSON(testFileName);
+  ConfigurableParam::setValue("TestParam.iValue", "999");
+  ConfigurableParam::setValue("TestParam.sValue", testFileName);
+  ConfigurableParam::updateFromFile(testFileName);
+  BOOST_CHECK_EQUAL(TestParam::Instance().iValue, iValueBefore);
+  BOOST_CHECK_EQUAL(TestParam::Instance().sValue, sValueBefore);
+  std::remove(testFileName.c_str());
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_FileIO_ROOT)
+{
+  // test for root file serialization
+  const std::string testFileName = "test_config.root";
+  auto iValueBefore = TestParam::Instance().iValue;
+  auto sValueBefore = TestParam::Instance().sValue;
+  TFile* testFile = TFile::Open(testFileName.c_str(), "RECREATE");
+  TestParam::Instance().serializeTo(testFile);
+  testFile->Close();
+  ConfigurableParam::setValue("TestParam.iValue", "999");
+  ConfigurableParam::setValue("TestParam.sValue", testFileName);
+  ConfigurableParam::fromCCDB(testFileName);
+  BOOST_CHECK_EQUAL(TestParam::Instance().iValue, iValueBefore);
+  BOOST_CHECK_EQUAL(TestParam::Instance().sValue, sValueBefore);
+  std::remove(testFileName.c_str());
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_Cli)
+{
+  // test setting values from as a cli arg string
+  ConfigurableParam::updateFromString("TestParam.iValue=55;TestParam.sValue=cli");
+  BOOST_CHECK_EQUAL(TestParam::Instance().iValue, 55);
+  BOOST_CHECK_EQUAL(TestParam::Instance().sValue, "cli");
+}
+
+BOOST_AUTO_TEST_CASE(ConfigurableParam_LiteralSuffix)
+{
+  // test setting values with the correct literal suffix
+  ConfigurableParam::updateFromString("TestParam.fValue=42.f");
+  BOOST_CHECK_EQUAL(TestParam::Instance().fValue, 42.f);
+
+  ConfigurableParam::setValue("TestParam.ullValue", "999ull");
+  BOOST_CHECK_EQUAL(TestParam::Instance().ullValue, 999ULL);
+  // check using wrong literal suffix fails, prints error to std
+  ConfigurableParam::setValue("TestParam.ullValue", "888u");
+  BOOST_CHECK_NE(TestParam::Instance().ullValue, 888);
+}

From 2a19535f05b7050ed86959da2852ea730965fa5e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 26 Sep 2025 09:55:51 +0200
Subject: [PATCH 0867/1764] DPL: allow closing a signpost interval with an
 error (#14692)

The error will be printed regardless of the signposts being enabled.

In case the signposts are actually enabled, the error will be the closing
message of the signpost interval.

In case the signposts are not enabled, the error will be printed as a standard error.
---
 Framework/Foundation/include/Framework/Signpost.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Framework/Foundation/include/Framework/Signpost.h b/Framework/Foundation/include/Framework/Signpost.h
index 7ed544c529303..51d1b0433b0de 100644
--- a/Framework/Foundation/include/Framework/Signpost.h
+++ b/Framework/Foundation/include/Framework/Signpost.h
@@ -611,6 +611,16 @@ void o2_debug_log_set_stacktrace(_o2_log_t* log, int stacktrace)
   } else if (O2_BUILTIN_UNLIKELY(private_o2_log_##log->stacktrace)) {                                                 \
     _o2_signpost_interval_end(private_o2_log_##log, id, name, remove_engineering_type(format).data(), ##__VA_ARGS__); \
   }
+// Print out a message at error level in any case even if the signpost is not enable.
+// If it is enabled, behaves like O2_SIGNPOST_END.
+#define O2_SIGNPOST_END_WITH_ERROR(log, id, name, format, ...)                                                        \
+  if (O2_BUILTIN_UNLIKELY(O2_SIGNPOST_ENABLED_MAC(log))) {                                                            \
+    O2_SIGNPOST_END_MAC(log, id, name, format, ##__VA_ARGS__);                                                        \
+  } else if (O2_BUILTIN_UNLIKELY(private_o2_log_##log->stacktrace)) {                                                 \
+    _o2_signpost_interval_end(private_o2_log_##log, id, name, remove_engineering_type(format).data(), ##__VA_ARGS__); \
+  } else {                                                                                                            \
+    O2_LOG_MACRO_RAW(error, remove_engineering_type(format).data(), ##__VA_ARGS__);                                   \
+  }
 #else // This is the release implementation, it does nothing.
 #define O2_DECLARE_DYNAMIC_LOG(x)
 #define O2_DECLARE_DYNAMIC_STACKTRACE_LOG(x)

From 5b1b34330e4773dcc7ec6db72323cc161ed651d2 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 26 Sep 2025 14:56:27 +0200
Subject: [PATCH 0868/1764] ITS3: use const view of ROFs, prepareROFData
 (#14694)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../tracking/include/ITStracking/TimeFrame.h  |  4 +-
 .../include/ITStracking/TrackingInterface.h   |  2 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 37 +++++++++++--------
 .../ITS/tracking/src/TrackingInterface.cxx    |  7 ++--
 .../include/ITS3Reconstruction/IOUtils.h      |  2 +-
 .../ITS3Reconstruction/TrackingInterface.h    |  2 +-
 .../ITS3/reconstruction/src/IOUtils.cxx       | 13 +++----
 .../reconstruction/src/TrackingInterface.cxx  |  2 +-
 8 files changed, 38 insertions(+), 31 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 436ce25336ca7..b324092624a6d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -90,12 +90,14 @@ struct TimeFrame {
   int loadROFrameData(const o2::itsmft::ROFRecord& rof, gsl::span<const itsmft::Cluster> clusters,
                       const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
 
-  int loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
+  int loadROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
                       gsl::span<const itsmft::CompClusterExt> clusters,
                       gsl::span<const unsigned char>::iterator& pattIt,
                       const itsmft::TopologyDictionary* dict,
                       const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
   void resetROFrameData(size_t nROFs);
+  void prepareROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
+                          gsl::span<const itsmft::CompClusterExt> clusters);
 
   int getTotalClusters() const;
   auto& getTotVertIteration() { return mTotVertPerIteration; }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index 787f299e15888..491d2df4697ac 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -78,7 +78,7 @@ class ITSTrackingInterface
   TimeFrameN* mTimeFrame = nullptr;
 
  protected:
-  virtual void loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
+  virtual void loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                        gsl::span<const itsmft::CompClusterExt> clusters,
                        gsl::span<const unsigned char>::iterator& pattIt,
                        const dataformats::MCTruthContainer<MCCompLabel>* mcLabels);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 4ea0bedaced5f..ca28ee227df56 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -103,28 +103,17 @@ void TimeFrame<nLayers>::addPrimaryVerticesContributorLabelsInROF(const bounded_
 }
 
 template <int nLayers>
-int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
+int TimeFrame<nLayers>::loadROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
                                         gsl::span<const itsmft::CompClusterExt> clusters,
                                         gsl::span<const unsigned char>::iterator& pattIt,
                                         const itsmft::TopologyDictionary* dict,
                                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  resetROFrameData(rofs.size());
-
   GeometryTGeo* geom = GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
 
-  mNrof = rofs.size();
-  clearResizeBoundedVector(mClusterSize, clusters.size(), mMemoryPool.get());
-  std::array<int, nLayers> clusterCountPerLayer{};
-  for (const auto& clus : clusters) {
-    ++clusterCountPerLayer[geom->getLayer(clus.getSensorID())];
-  }
-  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
-    mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
-    mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
-    mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
-  }
+  resetROFrameData(rofs.size());
+  prepareROFrameData(rofs, clusters);
 
   for (size_t iRof{0}; iRof < rofs.size(); ++iRof) {
     const auto& rof = rofs[iRof];
@@ -182,7 +171,7 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<o2::itsmft::ROFRecord> rofs,
   }
 
   return mNrof;
-} // namespace o2::its
+}
 
 template <int nLayers>
 void TimeFrame<nLayers>::resetROFrameData(size_t nRofs)
@@ -201,6 +190,24 @@ void TimeFrame<nLayers>::resetROFrameData(size_t nRofs)
   }
 }
 
+template <int nLayers>
+void TimeFrame<nLayers>::prepareROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
+                                            gsl::span<const itsmft::CompClusterExt> clusters)
+{
+  GeometryTGeo* geom = GeometryTGeo::Instance();
+  mNrof = rofs.size();
+  clearResizeBoundedVector(mClusterSize, clusters.size(), mMemoryPool.get());
+  std::array<int, nLayers> clusterCountPerLayer{};
+  for (const auto& clus : clusters) {
+    ++clusterCountPerLayer[geom->getLayer(clus.getSensorID())];
+  }
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
+  }
+}
+
 template <int nLayers>
 void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, const int maxLayers)
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index f673d8f446350..d5f13cd9d25ea 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -139,11 +139,10 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   mTracker->setBz(o2::base::Propagator::Instance()->getNominalBz());
 
   gsl::span<const unsigned char>::iterator pattIt = patterns.begin();
-
-  gsl::span<itsmft::ROFRecord> trackROFspan(trackROFvec);
+  gsl::span<const itsmft::ROFRecord> trackROFspan(trackROFvec);
   loadROF(trackROFspan, compClusters, pattIt, labels);
   pattIt = patterns.begin();
-  std::vector<int> savedROF;
+
   auto logger = [&](const std::string& s) { LOG(info) << s; };
   auto fatalLogger = [&](const std::string& s) { LOG(fatal) << s; };
   auto errorLogger = [&](const std::string& s) { LOG(error) << s; };
@@ -406,7 +405,7 @@ void ITSTrackingInterface::setTraitsFromProvider(VertexerTraitsN* vertexerTraits
   mVertexer->setMemoryPool(mMemoryPool);
 }
 
-void ITSTrackingInterface::loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
+void ITSTrackingInterface::loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                                    gsl::span<const itsmft::CompClusterExt> clusters,
                                    gsl::span<const unsigned char>::iterator& pattIt,
                                    const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
index 771b13539b759..fa15e73118524 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
@@ -72,7 +72,7 @@ void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
                             const its3::TopologyDictionary* dict);
 
 int loadROFrameDataITS3(its::TimeFrame<7>* tf,
-                        gsl::span<o2::itsmft::ROFRecord> rofs,
+                        gsl::span<const o2::itsmft::ROFRecord> rofs,
                         gsl::span<const itsmft::CompClusterExt> clusters,
                         gsl::span<const unsigned char>::iterator& pattIt,
                         const its3::TopologyDictionary* dict,
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h
index ab2ff0086200b..931628f2cf876 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h
@@ -28,7 +28,7 @@ class ITS3TrackingInterface final : public its::ITSTrackingInterface
   void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj) final;
 
  protected:
-  void loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
+  void loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                gsl::span<const itsmft::CompClusterExt> clusters,
                gsl::span<const unsigned char>::iterator& pattIt,
                const dataformats::MCTruthContainer<MCCompLabel>* mcLabels) final;
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index 2fced813efc93..8bfc7eedf2d6f 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -58,22 +58,22 @@ void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
 }
 
 int loadROFrameDataITS3(its::TimeFrame<7>* tf,
-                        gsl::span<o2::itsmft::ROFRecord> rofs,
+                        gsl::span<const o2::itsmft::ROFRecord> rofs,
                         gsl::span<const itsmft::CompClusterExt> clusters,
                         gsl::span<const unsigned char>::iterator& pattIt,
                         const its3::TopologyDictionary* dict,
                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  tf->resetROFrameData(rofs.size());
-
   auto geom = its::GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
 
-  tf->mNrof = 0;
+  tf->resetROFrameData(rofs.size());
+  tf->prepareROFrameData(rofs, clusters);
 
   its::bounded_vector<uint8_t> clusterSizeVec(clusters.size(), tf->getMemoryPool().get());
 
-  for (auto& rof : rofs) {
+  for (size_t iRof{0}; iRof < rofs.size(); ++iRof) {
+    const auto& rof = rofs[iRof];
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {
       auto& c = clusters[clusterId];
       auto sensorID = c.getSensorID();
@@ -108,9 +108,8 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
       tf->addClusterExternalIndexToLayer(layer, clusterId);
     }
     for (unsigned int iL{0}; iL < tf->getUnsortedClusters().size(); ++iL) {
-      tf->mROFramesClusters[iL].push_back(tf->getUnsortedClusters()[iL].size());
+      tf->mROFramesClusters[iL][iRof + 1] = tf->getUnsortedClusters()[iL].size();
     }
-    tf->mNrof++;
   }
 
   tf->setClusterSize(clusterSizeVec);
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
index 3d18ab267bd46..0f5c66a7f9663 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
@@ -74,7 +74,7 @@ void ITS3TrackingInterface::finaliseCCDB(framework::ConcreteDataMatcher& matcher
   }
 }
 
-void ITS3TrackingInterface::loadROF(gsl::span<itsmft::ROFRecord>& trackROFspan,
+void ITS3TrackingInterface::loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                                     gsl::span<const itsmft::CompClusterExt> clusters,
                                     gsl::span<const unsigned char>::iterator& pattIt,
                                     const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)

From 360d8fe90563dfd0c01246a41f8ceb0848aa3ac4 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 26 Sep 2025 16:48:16 +0200
Subject: [PATCH 0869/1764] DPL: improve message on quit (#14696)

---
 Framework/Core/src/runDataProcessing.cxx | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index a343637080da1..ae6ea03063dfc 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -2202,8 +2202,11 @@ int runStateMachine(DataProcessorSpecs const& workflow,
           driverInfo.states.push_back(DriverState::RUNNING);
         }
         break;
-      case DriverState::QUIT_REQUESTED:
-        LOG(info) << "QUIT_REQUESTED";
+      case DriverState::QUIT_REQUESTED: {
+        std::time_t result = std::time(nullptr);
+        char buffer[32];
+        std::strncpy(buffer, std::ctime(&result), 26);
+        O2_SIGNPOST_EVENT_EMIT_INFO(driver, sid, "mainloop", "Quit requested at %{public}s", buffer);
         guiQuitRequested = true;
         // We send SIGCONT to make sure stopped children are resumed
         killChildren(infos, SIGCONT);
@@ -2215,6 +2218,7 @@ int runStateMachine(DataProcessorSpecs const& workflow,
         uv_timer_start(&force_step_timer, single_step_callback, 0, 300);
         driverInfo.states.push_back(DriverState::HANDLE_CHILDREN);
         break;
+      }
       case DriverState::HANDLE_CHILDREN: {
         // Run any pending libUV event loop, block if
         // any, so that we do not consume CPU time when the driver is

From fe0e85a5bcffcc550be2aa16371d04be4e29dd77 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 26 Sep 2025 22:06:33 +0200
Subject: [PATCH 0870/1764] DPL GUI: simplify and speed up (#14700)

* Avoid cumbersome retrivial of the lifetime
* No need to create a string just to format it.
---
 Framework/GUISupport/CMakeLists.txt           |  1 +
 .../src/FrameworkGUIDataRelayerUsage.cxx      |  2 +-
 .../src/FrameworkGUIDeviceInspector.cxx       | 18 +++------
 Framework/GUISupport/src/InspectorHelpers.cxx | 40 +++++++++++++++++++
 Framework/GUISupport/src/InspectorHelpers.h   | 29 +-------------
 5 files changed, 50 insertions(+), 40 deletions(-)
 create mode 100644 Framework/GUISupport/src/InspectorHelpers.cxx

diff --git a/Framework/GUISupport/CMakeLists.txt b/Framework/GUISupport/CMakeLists.txt
index 61519c21dc20c..8e67da3e53e15 100644
--- a/Framework/GUISupport/CMakeLists.txt
+++ b/Framework/GUISupport/CMakeLists.txt
@@ -20,6 +20,7 @@ o2_add_library(FrameworkGUISupport
                        src/PaletteHelpers.cxx
                        src/SpyService.cxx
                        src/SpyServiceHelpers.cxx
+                       src/InspectorHelpers.cxx
                PRIVATE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_LIST_DIR}/src
                PUBLIC_LINK_LIBRARIES O2::Framework AliceO2::DebugGUI)
 
diff --git a/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx b/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
index c39e268fa90a7..1d3b4f24ea34c 100644
--- a/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
@@ -233,7 +233,7 @@ void displayDataRelayer(DeviceMetricsInfo const& /*metrics*/,
         continue;
       }
       if (i == (size_t)row) {
-        ImGui::Text("%d %.*s (%s)", row, int(end - input), input, InspectorHelpers::getLifeTimeStr(spec.inputs[i].matcher.lifetime).c_str());
+        ImGui::Text("%d %.*s (%s)", row, int(end - input), input, InspectorHelpers::getLifeTimeStr(spec.inputs[i].matcher.lifetime));
         break;
       }
       ++i;
diff --git a/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx b/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
index 9b2a13c07987d..b8c9cc50f0770 100644
--- a/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
@@ -79,7 +79,8 @@ void deviceStateTable(DataProcessingStates const& states)
   }
 }
 
-void deviceInfoTable(char const* label, ProcessingStateId id, DataProcessingStates const& states, std::variant<std::vector<InputRoute>, std::vector<OutputRoute>> routes, DeviceMetricsInfo const& metrics)
+template <typename Routes>
+void deviceInfoTable(char const* label, ProcessingStateId id, DataProcessingStates const& states, Routes const& routes, DeviceMetricsInfo const& metrics)
 {
   // Find the state spec associated to data_queries
   auto& view = states.statesViews[(int)id];
@@ -95,17 +96,10 @@ void deviceInfoTable(char const* label, ProcessingStateId id, DataProcessingStat
       if ((end - input) == 0) {
         continue;
       }
-      auto getLifetime = [&routes, &i]() -> Lifetime {
-        if (std::get_if<std::vector<InputRoute>>(&routes)) {
-          return std::get<std::vector<InputRoute>>(routes)[i].matcher.lifetime;
-        } else {
-          return std::get<std::vector<OutputRoute>>(routes)[i].matcher.lifetime;
-        }
-      };
-      ImGui::Text("%zu: %.*s (%s)", i, int(end - input), input, InspectorHelpers::getLifeTimeStr(getLifetime()).c_str());
+      ImGui::Text("%zu: %.*s (%s)", i, int(end - input), input, InspectorHelpers::getLifeTimeStr(routes[i].matcher.lifetime));
       if (ImGui::IsItemHovered()) {
         ImGui::BeginTooltip();
-        ImGui::Text("%zu: %.*s (%s)", i, int(end - input), input, InspectorHelpers::getLifeTimeStr(getLifetime()).c_str());
+        ImGui::Text("%zu: %.*s (%s)", i, int(end - input), input, InspectorHelpers::getLifeTimeStr(routes[i].matcher.lifetime));
         ImGui::EndTooltip();
       }
       input = end + 1;
@@ -346,8 +340,8 @@ void displayDeviceInspector(DeviceSpec const& spec,
   }
 
   deviceStateTable(states);
-  deviceInfoTable("Inputs:", ProcessingStateId::DATA_QUERIES, states, std::variant<std::vector<InputRoute>, std::vector<OutputRoute>>(spec.inputs), metrics);
-  deviceInfoTable("Outputs:", ProcessingStateId::OUTPUT_MATCHERS, states, std::variant<std::vector<InputRoute>, std::vector<OutputRoute>>(spec.outputs), metrics);
+  deviceInfoTable("Inputs:", ProcessingStateId::DATA_QUERIES, states, spec.inputs, metrics);
+  deviceInfoTable("Outputs:", ProcessingStateId::OUTPUT_MATCHERS, states, spec.outputs, metrics);
   configurationTable(info.currentConfig, info.currentProvenance);
   optionsTable("Workflow Options", metadata.workflowOptions, control);
   if (ImGui::CollapsingHeader("Labels", ImGuiTreeNodeFlags_DefaultOpen)) {
diff --git a/Framework/GUISupport/src/InspectorHelpers.cxx b/Framework/GUISupport/src/InspectorHelpers.cxx
new file mode 100644
index 0000000000000..23e74c964e531
--- /dev/null
+++ b/Framework/GUISupport/src/InspectorHelpers.cxx
@@ -0,0 +1,40 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "InspectorHelpers.h"
+
+namespace o2::framework
+{
+char const* InspectorHelpers::getLifeTimeStr(Lifetime lifetime)
+{
+  switch (lifetime) {
+    case Lifetime::Timeframe:
+      return "Timeframe";
+    case Lifetime::Condition:
+      return "Condition";
+    case Lifetime::Sporadic:
+      return "Sporadic";
+    case Lifetime::Transient:
+      return "Transient";
+    case Lifetime::Timer:
+      return "Timer";
+    case Lifetime::Enumeration:
+      return "Enumeration";
+    case Lifetime::Signal:
+      return "Signal";
+    case Lifetime::Optional:
+      return "Optional";
+    case Lifetime::OutOfBand:
+      return "OutOfBand";
+  }
+  return "none";
+};
+} // namespace o2::framework
diff --git a/Framework/GUISupport/src/InspectorHelpers.h b/Framework/GUISupport/src/InspectorHelpers.h
index 124c714f54df5..193486fc91dbc 100644
--- a/Framework/GUISupport/src/InspectorHelpers.h
+++ b/Framework/GUISupport/src/InspectorHelpers.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -11,8 +11,6 @@
 #ifndef O2_FRAMEWORK_INSPECTORHELPERS_H_
 #define O2_FRAMEWORK_INSPECTORHELPERS_H_
 
-#include <string>
-
 #include "Framework/Lifetime.h"
 
 namespace o2::framework
@@ -20,30 +18,7 @@ namespace o2::framework
 
 /// A helper class for inpsection of device information
 struct InspectorHelpers {
-  static const std::string getLifeTimeStr(Lifetime lifetime)
-  {
-    switch (lifetime) {
-      case Lifetime::Timeframe:
-        return "Timeframe";
-      case Lifetime::Condition:
-        return "Condition";
-      case Lifetime::Sporadic:
-        return "Sporadic";
-      case Lifetime::Transient:
-        return "Transient";
-      case Lifetime::Timer:
-        return "Timer";
-      case Lifetime::Enumeration:
-        return "Enumeration";
-      case Lifetime::Signal:
-        return "Signal";
-      case Lifetime::Optional:
-        return "Optional";
-      case Lifetime::OutOfBand:
-        return "OutOfBand";
-    }
-    return "none";
-  };
+  static const char* getLifeTimeStr(Lifetime lifetime);
 };
 
 } // namespace o2::framework

From 4dfc128054a89b78318b37a265b9a28b34560bde Mon Sep 17 00:00:00 2001
From: Evgeny Kryshen <evgeny.kryshen@cern.ch>
Date: Sat, 27 Sep 2025 00:24:15 +0300
Subject: [PATCH 0871/1764] First version of ECal sim, digitizer and
 clusterizer (#14697)

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Detectors/Upgrades/ALICE3/ECal/CMakeLists.txt |   4 +-
 .../ECal/DataFormatsECal/CMakeLists.txt       |  23 +
 .../include/DataFormatsECal/Cluster.h         |  85 ++++
 .../include/DataFormatsECal/Digit.h           |  55 +++
 .../include/DataFormatsECal/MCLabel.h         |  41 ++
 .../ECal/DataFormatsECal/src/Cluster.cxx      |  56 +++
 .../src/DataFormatsECalLinkDef.h              |  25 +
 .../ALICE3/ECal/DataFormatsECal/src/Digit.cxx |  24 +
 .../ECal/DataFormatsECal/src/MCLabel.cxx      |  19 +
 Detectors/Upgrades/ALICE3/ECal/README.md      |   4 +-
 .../Upgrades/ALICE3/ECal/base/CMakeLists.txt  |  10 +-
 .../base/include/ECalBase/ECalBaseParam.h     |  39 +-
 .../ECal/base/include/ECalBase/Geometry.h     |  99 ++++
 .../ECal/base/include/ECalBase/GeometryTGeo.h |  17 +-
 .../ALICE3/ECal/base/include/ECalBase/Hit.h   |  85 ++++
 .../ALICE3/ECal/base/src/ECalBaseLinkDef.h    |   3 +
 .../ALICE3/ECal/base/src/ECalBaseParam.cxx    |   9 +-
 .../ALICE3/ECal/base/src/Geometry.cxx         | 264 ++++++++++
 .../ALICE3/ECal/base/src/GeometryTGeo.cxx     |  19 +-
 .../Upgrades/ALICE3/ECal/base/src/Hit.cxx     |  34 ++
 .../ALICE3/ECal/reconstruction/CMakeLists.txt |  19 +
 .../include/ECalReconstruction/Clusterizer.h  |  75 +++
 .../ECal/reconstruction/src/Clusterizer.cxx   | 455 ++++++++++++++++++
 .../src/ECalReconstructionLinkDef.h           |  20 +
 .../ALICE3/ECal/simulation/CMakeLists.txt     |   9 +-
 .../ALICE3/ECal/simulation/data/simcuts.dat   |  14 +
 .../include/ECalSimulation/Detector.h         |  78 +--
 .../include/ECalSimulation/Digitizer.h        |  58 +++
 .../ALICE3/ECal/simulation/src/Detector.cxx   | 437 +++++++++++------
 .../ALICE3/ECal/simulation/src/Digitizer.cxx  |  89 ++++
 .../simulation/src/ECalSimulationLinkDef.h    |   1 +
 31 files changed, 1948 insertions(+), 222 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/Cluster.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/Digit.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/MCLabel.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/DataFormatsECalLinkDef.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Digit.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/MCLabel.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Geometry.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Hit.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/base/src/Geometry.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/base/src/Hit.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/reconstruction/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/reconstruction/include/ECalReconstruction/Clusterizer.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/reconstruction/src/Clusterizer.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/reconstruction/src/ECalReconstructionLinkDef.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/simulation/data/simcuts.dat
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/simulation/include/ECalSimulation/Digitizer.h
 create mode 100644 Detectors/Upgrades/ALICE3/ECal/simulation/src/Digitizer.cxx

diff --git a/Detectors/Upgrades/ALICE3/ECal/CMakeLists.txt b/Detectors/Upgrades/ALICE3/ECal/CMakeLists.txt
index 83838a01d13f1..cc0a7b0337619 100644
--- a/Detectors/Upgrades/ALICE3/ECal/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/ECal/CMakeLists.txt
@@ -10,4 +10,6 @@
 # or submit itself to any jurisdiction.
 
 add_subdirectory(base)
-add_subdirectory(simulation)
\ No newline at end of file
+add_subdirectory(simulation)
+add_subdirectory(reconstruction)
+add_subdirectory(DataFormatsECal)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/CMakeLists.txt b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/CMakeLists.txt
new file mode 100644
index 0000000000000..3448d6b31029d
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/CMakeLists.txt
@@ -0,0 +1,23 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(DataFormatsECal
+               SOURCES src/Digit.cxx
+               SOURCES src/MCLabel.cxx
+               SOURCES src/Cluster.cxx
+               PUBLIC_LINK_LIBRARIES O2::CommonDataFormat
+                                     O2::SimulationDataFormat
+                                     AliceO2::InfoLogger)
+
+o2_target_root_dictionary(DataFormatsECal
+                          HEADERS include/DataFormatsECal/Digit.h
+                          HEADERS include/DataFormatsECal/MCLabel.h
+                          HEADERS include/DataFormatsECal/Cluster.h)
diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/Cluster.h b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/Cluster.h
new file mode 100644
index 0000000000000..4a34ef1679f26
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/Cluster.h
@@ -0,0 +1,85 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Cluster.h
+/// \brief Definition of ECal cluster class
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#ifndef ALICEO2_ECAL_CLUSTER_H
+#define ALICEO2_ECAL_CLUSTER_H
+#include <map>
+#include <vector>
+#include <Rtypes.h>
+#include <TLorentzVector.h>
+
+namespace o2
+{
+namespace ecal
+{
+class Cluster
+{
+ public:
+  Cluster() = default;
+  Cluster(const Cluster& clu) = default;
+  ~Cluster() = default;
+
+  // setters
+  void addDigit(int digitIndex, int towerId, double energy);
+  void setNLM(int nMax) { mNLM = nMax; }
+  void setE(float energy) { mE = energy; }
+  void setX(float x) { mX = x; }
+  void setY(float y) { mY = y; }
+  void setZ(float z) { mZ = z; }
+  void setChi2(float chi2) { mChi2 = chi2; }
+  void setEdgeFlag(bool isEdge) { mEdge = isEdge; }
+  void addMcTrackID(int mcTrackID, float energy) { mMcTrackEnergy[mcTrackID] += energy; }
+
+  // getters
+  const std::map<int, float>& getMcTrackEnergy() { return mMcTrackEnergy; }
+  int getMultiplicity() const { return mDigitIndex.size(); }
+  int getDigitIndex(int i) const { return mDigitIndex[i]; }
+  int getDigitTowerId(int i) const { return mDigitTowerId[i]; }
+  float getDigitEnergy(int i) const { return mDigitEnergy[i]; }
+  float getNLM() const { return mNLM; }
+  float getTime() const { return mTime; }
+  float getE() const { return mE; }
+  float getX() const { return mX; }
+  float getY() const { return mY; }
+  float getZ() const { return mZ; }
+  float getR() const { return std::sqrt(mX * mX + mY * mY); }
+  float getTheta() const { return std::atan2(getR(), mZ); }
+  float getEta() const { return -std::log(std::tan(getTheta() / 2.)); }
+  float getPhi() const { return std::atan2(mY, mX); }
+  float getChi2() const { return mChi2; }
+  bool isAtTheEdge() const { return mEdge; }
+  int getMcTrackID() const;
+  TLorentzVector getMomentum() const;
+
+ private:
+  std::vector<int> mDigitIndex;        // vector of digit indices in digits vector
+  std::vector<int> mDigitTowerId;      // vector of corresponding digit tower Ids
+  std::vector<float> mDigitEnergy;     // vector of corresponding digit energies
+  std::map<int, float> mMcTrackEnergy; // MC track indices and corresponding energies
+  int mNLM = 0;                        // number of local maxima in the initial cluster
+  float mTime = 0;                     // cluster time
+  float mE = 0;                        // cluster energy
+  float mX = 0;                        // estimated x-coordinate
+  float mY = 0;                        // estimated y-ccordinate
+  float mZ = 0;                        // estimated z-ccordinate
+  float mChi2 = 0;                     // chi2 wrt EM shape
+  bool mEdge = 0;                      // set to true if one of cluster digits is at the chamber edge
+  ClassDefNV(Cluster, 1);
+};
+} // namespace ecal
+} // namespace o2
+
+#endif // ALICEO2_ECAL_CLUSTER_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/Digit.h b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/Digit.h
new file mode 100644
index 0000000000000..cc46a64e2cac0
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/Digit.h
@@ -0,0 +1,55 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Digit.h
+/// \brief Definition of ECal digit class
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#ifndef ALICEO2_ECAL_DIGIT_H
+#define ALICEO2_ECAL_DIGIT_H
+
+#include <Rtypes.h>
+#include <CommonDataFormat/TimeStamp.h>
+
+namespace o2
+{
+namespace ecal
+{
+class Digit : public o2::dataformats::TimeStamp<double>
+{
+ public:
+  Digit() = default;
+  Digit(int tower, double amplitudeGeV, double time);
+  ~Digit() = default;
+
+  // setters
+  void setTower(int tower) { mTower = tower; }
+  void setAmplitude(double amplitude) { mAmplitudeGeV = amplitude; }
+  void setEnergy(double energy) { mAmplitudeGeV = energy; }
+  void setLabel(int label) { mLabel = label; }
+
+  // getters
+  int getTower() const { return mTower; }
+  double getAmplitude() const { return mAmplitudeGeV; }
+  double getEnergy() const { return mAmplitudeGeV; }
+  int getLabel() const { return mLabel; }
+
+ private:
+  double mAmplitudeGeV = 0.; ///< Amplitude (GeV)
+  int32_t mTower = -1;       ///< Tower index (absolute cell ID)
+  int32_t mLabel = -1;       ///< Index of the corresponding entry/entries in the MC label array
+  ClassDefNV(Digit, 1);
+};
+
+} // namespace ecal
+} // namespace o2
+#endif // ALICEO2_ECAL_DIGIT_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/MCLabel.h b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/MCLabel.h
new file mode 100644
index 0000000000000..762779977ca53
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/include/DataFormatsECal/MCLabel.h
@@ -0,0 +1,41 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MCLabel.h
+/// \brief MCLabel class to store MC truth info for ECal
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#ifndef ALICEO2_ECAL_MCLABEL_H
+#define ALICEO2_ECAL_MCLABEL_H
+
+#include <SimulationDataFormat/MCCompLabel.h>
+
+namespace o2
+{
+namespace ecal
+{
+class MCLabel : public o2::MCCompLabel
+{
+ public:
+  MCLabel() = default;
+  MCLabel(int trackID, int eventID, int srcID, bool fake, float edep) : o2::MCCompLabel(trackID, eventID, srcID, fake), mEdep(edep) {}
+  float getEdep() const { return mEdep; }
+
+ private:
+  float mEdep = 0; // deposited energy
+
+  ClassDefNV(MCLabel, 1);
+};
+} // namespace ecal
+} // namespace o2
+
+#endif // ALICEO2_ECAL_MCLABEL_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx
new file mode 100644
index 0000000000000..77f7d9219ef6b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx
@@ -0,0 +1,56 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Cluster.cxx
+/// \brief Implementation of ECal cluster class
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#include <map>
+#include <vector>
+#include <DataFormatsECal/Cluster.h>
+#include <DataFormatsECal/Digit.h>
+
+using namespace o2::ecal;
+
+ClassImp(Cluster);
+
+//==============================================================================
+void Cluster::addDigit(int digitIndex, int towerId, double energy)
+{
+  mE += energy;
+  mDigitIndex.push_back(digitIndex);
+  mDigitTowerId.push_back(towerId);
+  mDigitEnergy.push_back(energy);
+}
+
+//==============================================================================
+int Cluster::getMcTrackID() const
+{
+  float maxEnergy = 0;
+  int maxID = 0;
+  for (const auto& [mcTrackID, energy] : mMcTrackEnergy) {
+    if (energy > maxEnergy) {
+      maxEnergy = energy;
+      maxID = mcTrackID;
+    }
+  }
+  return maxID;
+}
+
+//==============================================================================
+TLorentzVector Cluster::getMomentum() const
+{
+  double r = std::sqrt(mX * mX + mY * mY + mZ * mZ);
+  if (r == 0)
+    return TLorentzVector();
+  return TLorentzVector(mE * mX / r, mE * mY / r, mE * mZ / r, mE);
+}
diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/DataFormatsECalLinkDef.h b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/DataFormatsECalLinkDef.h
new file mode 100644
index 0000000000000..5b0190aa10d45
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/DataFormatsECalLinkDef.h
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::ecal::Digit + ;
+#pragma link C++ class o2::ecal::MCLabel + ;
+#pragma link C++ class o2::ecal::Cluster + ;
+#pragma link C++ class std::vector < o2::ecal::Digit> + ;
+#pragma link C++ class std::vector < o2::ecal::Cluster> + ;
+#include "SimulationDataFormat/MCTruthContainer.h"
+#pragma link C++ class o2::dataformats::MCTruthContainer < o2::ecal::MCLabel> + ;
+#endif
diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Digit.cxx b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Digit.cxx
new file mode 100644
index 0000000000000..c339c112c6858
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Digit.cxx
@@ -0,0 +1,24 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Digit.cxx
+/// \brief Implementation of ECal digit class
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#include <DataFormatsECal/Digit.h>
+
+using namespace o2::ecal;
+
+Digit::Digit(int tower, double amplitudeGeV, double time)
+  : mTower(tower), mAmplitudeGeV(amplitudeGeV), o2::dataformats::TimeStamp<double>(time)
+{
+}
diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/MCLabel.cxx b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/MCLabel.cxx
new file mode 100644
index 0000000000000..4dbd2711f1521
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/MCLabel.cxx
@@ -0,0 +1,19 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file MCLabel.cxx
+/// \brief MCLabel class to store MC truth info for ECal
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#include <DataFormatsECal/MCLabel.h>
+
+ClassImp(o2::ecal::MCLabel);
diff --git a/Detectors/Upgrades/ALICE3/ECal/README.md b/Detectors/Upgrades/ALICE3/ECal/README.md
index 288040fbd5fd9..ff58683646409 100644
--- a/Detectors/Upgrades/ALICE3/ECal/README.md
+++ b/Detectors/Upgrades/ALICE3/ECal/README.md
@@ -1,10 +1,10 @@
 <!-- doxy
-\page refDetectorsUpgradesALICE3TRK Tracker
+\page refDetectorsUpgradesALICE3ECL ECAL
 /doxy -->
 
 # ALICE 3 Electromagnetic Calorimenter
 
-This is top page for the ECL detector documentation.
+This is top page for the ECAL detector documentation.
 
 <!-- doxy
 /doxy -->
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/CMakeLists.txt b/Detectors/Upgrades/ALICE3/ECal/base/CMakeLists.txt
index 70017cc051e80..b0e1229662653 100644
--- a/Detectors/Upgrades/ALICE3/ECal/base/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/ECal/base/CMakeLists.txt
@@ -10,10 +10,14 @@
 # or submit itself to any jurisdiction.
 
 o2_add_library(ECalBase
-               SOURCES src/GeometryTGeo.cxx
+               SOURCES src/Geometry.cxx
+                       src/GeometryTGeo.cxx
                        src/ECalBaseParam.cxx
+                       src/Hit.cxx
                PUBLIC_LINK_LIBRARIES O2::DetectorsBase)
 
 o2_target_root_dictionary(ECalBase
-               HEADERS include/ECalBase/GeometryTGeo.h
-                       include/ECalBase/ECalBaseParam.h)
\ No newline at end of file
+               HEADERS include/ECalBase/Geometry.h
+                       include/ECalBase/GeometryTGeo.h
+                       include/ECalBase/ECalBaseParam.h
+                       include/ECalBase/Hit.h)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/ECalBaseParam.h b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/ECalBaseParam.h
index b8b7c75e2b7d0..aa0de4119914a 100644
--- a/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/ECalBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/ECalBaseParam.h
@@ -9,22 +9,45 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+/// \file ECalBaseParam.h
+/// \brief Geometry parameters configurable via o2-sim --configKeyValues
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
 #ifndef O2_ECAL_BASEPARAM_H
 #define O2_ECAL_BASEPARAM_H
 
-#include "CommonUtils/ConfigurableParam.h"
-#include "CommonUtils/ConfigurableParamHelper.h"
+#include <CommonUtils/ConfigurableParam.h>
+#include <CommonUtils/ConfigurableParamHelper.h>
 
 namespace o2
 {
 namespace ecal
 {
 struct ECalBaseParam : public o2::conf::ConfigurableParamHelper<ECalBaseParam> {
-  float rMin = 125.0;    // cm
-  float rMax = 155.0;    // cm
-  float zLength = 350.0; // cm
-
-  bool enableFwdEndcap = true;
+  bool enableFwdEndcap = false;
+  // general ecal barrel settings
+  double rMin = 125;    // cm
+  double rMax = 155;    // cm
+  double zLength = 350; // cm
+  int nSuperModules = 4;
+  // crystal module specification
+  int nCrystalModulesZ = 31;
+  int nCrystalModulesPhi = 96;
+  double crystalAlphaDeg = 0.4;    // degrees
+  double crystalModuleWidth = 1.9; // cm
+  double crystalModuleLength = 18; // cm
+  // sampling module specification
+  int nSamplingModulesZ = 56;
+  int nSamplingModulesPhi = 67;
+  double samplingAlphaDeg = 0.4;    // degrees
+  double samplingModuleWidth = 2.7; // cm
+  double frontPlateThickness = 1.;  // cm
+  double pbLayerThickness = 0.12;   // cm
+  double scLayerThickness = 0.15;   // cm
+  int nSamplingLayers = 80;
+  // margin in z between crystal modules and sampling modules
+  double marginCrystalToSampling = 0.1; // cm
 
   O2ParamDef(ECalBaseParam, "ECalBase");
 };
@@ -32,4 +55,4 @@ struct ECalBaseParam : public o2::conf::ConfigurableParamHelper<ECalBaseParam> {
 } // namespace ecal
 } // end namespace o2
 
-#endif
\ No newline at end of file
+#endif // O2_ECAL_BASEPARAM_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Geometry.h b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Geometry.h
new file mode 100644
index 0000000000000..ecfcb5b7cbad6
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Geometry.h
@@ -0,0 +1,99 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Geometry.h
+/// \brief Geometry helper class
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#ifndef ALICEO2_ECAL_GEOMETRY_H
+#define ALICEO2_ECAL_GEOMETRY_H
+
+#include <vector>
+#include <math.h>
+#include <Rtypes.h>
+
+namespace o2
+{
+namespace ecal
+{
+class Geometry
+{
+ public:
+  static Geometry& instance()
+  {
+    static Geometry sGeom;
+    return sGeom;
+  }
+
+  int getNcols() const;
+  int getNrows() const;
+  std::pair<int, int> getSectorChamber(int cellId) const;
+  std::pair<int, int> getSectorChamber(int iphi, int iz) const;
+
+  void fillFrontFaceCenterCoordinates();
+  int getCellID(int moduleId, int sectorId, bool isCrystal);
+  void detIdToRelIndex(int cellId, int& chamber, int& sector, int& iphi, int& iz) const;
+  void detIdToGlobalPosition(int detId, double& x, double& y, double& z);
+  std::pair<int, int> globalRowColFromIndex(int cellID) const;
+  bool isCrystal(int cellID);
+  int areNeighboursVertex(int detId1, int detId2) const;
+
+  double getTanBeta(int i) { return mTanBeta[i]; }
+  double getFrontFaceZatMinR(int i) { return mFrontFaceZatMinR[i]; }
+  double getFrontFaceCenterR(int i) { return mFrontFaceCenterR[i]; }
+  double getFrontFaceCenterZ(int i) { return mFrontFaceCenterZ[i]; }
+  double getFrontFaceCenterSamplingPhi(int i) { return mFrontFaceCenterSamplingPhi[i]; }
+  double getFrontFaceCenterCrystalPhi(int i) { return mFrontFaceCenterCrystalPhi[i]; }
+  double getFrontFaceCenterTheta(int i) { return mFrontFaceCenterTheta[i]; }
+  double getRMin() { return mRMin; }
+  double getCrystalModW() { return mCrystalModW; }
+  double getSamplingModW() { return mSamplingModW; }
+  double getCrystalAlpha() { return mCrystalAlpha; }
+  double getSamplingAlpha() { return mSamplingAlpha; }
+  double getCrystalDeltaPhi() { return 2 * std::atan(mCrystalModW / 2 / mRMin); }
+  double getSamplingDeltaPhi() { return 2 * std::atan(mSamplingModW / 2 / mRMin); }
+  double getCrystalPhiMin();
+  double getSamplingPhiMin();
+  int getNModulesZ() { return mNModulesZ; }
+  bool isAtTheEdge(int cellId);
+
+ private:
+  Geometry();
+  Geometry(const Geometry&) = delete;
+  Geometry& operator=(const Geometry&) = delete;
+  ~Geometry() = default;
+  double mRMin{0.};
+  int mNSuperModules{0};
+  int mNCrystalModulesZ{0};
+  int mNSamplingModulesZ{0};
+  int mNCrystalModulesPhi{0};
+  int mNSamplingModulesPhi{0};
+  double mCrystalModW{0.};
+  double mSamplingModW{0.};
+  double mSamplingAlpha{0.};
+  double mCrystalAlpha{0.};
+  double mMarginCrystalToSampling{0.};
+  int mNModulesZ{0};
+  std::vector<double> mFrontFaceZatMinR;
+  std::vector<double> mFrontFaceCenterR;
+  std::vector<double> mFrontFaceCenterZ;
+  std::vector<double> mFrontFaceCenterSamplingPhi;
+  std::vector<double> mFrontFaceCenterCrystalPhi;
+  std::vector<double> mFrontFaceCenterTheta;
+  std::vector<double> mTanBeta;
+
+  ClassDefNV(Geometry, 1);
+};
+} // namespace ecal
+} // namespace o2
+
+#endif // ALICEO2_ECAL_GEOMETRY_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/GeometryTGeo.h
index 1cff6dd7d3313..6975a5378a72f 100644
--- a/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/GeometryTGeo.h
@@ -9,6 +9,11 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+/// \file GeometryTGeo.h
+/// \brief Class containing ECal volume naming patterns
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
 #ifndef ALICEO2_ECAL_GEOMETRYTGEO_H
 #define ALICEO2_ECAL_GEOMETRYTGEO_H
 
@@ -27,21 +32,25 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static GeometryTGeo* Instance();
 
   static const char* getECalVolPattern() { return sVolumeName.c_str(); }
-  static const char* getECalSensorPattern() { return sSensorName.c_str(); }
+  static const char* getECalSectorPattern() { return sSectorName.c_str(); }
+  static const char* getECalModulePattern() { return sModuleName.c_str(); }
 
   static const char* composeSymNameECal()
   {
     return Form("%s_%d", o2::detectors::DetID(o2::detectors::DetID::ECL).getName(), 0);
   }
-  static const char* composeSymNameSensor(); // A single sensor for the moment
+  static const char* composeSymNameSector(int s);
+  static const char* composeSymNameModule(int s, int m);
 
  protected:
   static std::string sVolumeName;
-  static std::string sSensorName;
+  static std::string sSectorName;
+  static std::string sModuleName;
 
  private:
   static std::unique_ptr<o2::ecal::GeometryTGeo> sInstance;
 };
 } // namespace ecal
 } // namespace o2
-#endif
+
+#endif // ALICEO2_ECAL_GEOMETRYTGEO_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Hit.h b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Hit.h
new file mode 100644
index 0000000000000..006b2df5949e6
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Hit.h
@@ -0,0 +1,85 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Hit.h
+/// \brief MC hit class to store energy loss per cell and per superparent
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#ifndef ALICEO2_ECAL_HIT_H
+#define ALICEO2_ECAL_HIT_H
+
+#include <SimulationDataFormat/BaseHits.h>
+#include <CommonUtils/ShmAllocator.h>
+
+namespace o2
+{
+namespace ecal
+{
+class Hit : public o2::BasicXYZEHit<float>
+{
+ public:
+  /// \brief Default constructor
+  Hit() = default;
+
+  /// \brief Hit constructor
+  ///
+  /// Fully defining information of the ECAL point (position, momentum, energy, track, ...)
+  ///
+  /// \param trackID Index of the track, defined as parent track entering the ECAL
+  /// \param cellID ID of the detector cell
+  /// \param pos Position vector of the point
+  /// \param mom Momentum vector for the particle at the point
+  /// \param tof Time of the hit
+  /// \param eLoss Energy loss
+  Hit(int trackID, int cellID, const math_utils::Point3D<float>& pos,
+      const math_utils::Vector3D<float>& mom, float tof, float eLoss)
+    : o2::BasicXYZEHit<float>(pos.X(), pos.Y(), pos.Z(), tof, eLoss, trackID, 0),
+      mPvector(mom),
+      mCellID(cellID)
+  {
+  }
+
+  /// \brief Destructor
+  ~Hit() = default;
+
+  /// \brief Check whether the points are from the same parent and in the same detector volume
+  /// \return True if points are the same (origin and detector), false otherwise
+  bool operator==(const Hit& rhs) const;
+
+  /// \brief Sorting points according to parent particle and detector volume
+  /// \return True if this point is smaller, false otherwise
+  bool operator<(const Hit& rhs) const;
+
+  /// \brief Get cell ID
+  /// \return cell ID
+  int GetCellID() const { return mCellID; }
+
+ private:
+  math_utils::Vector3D<float> mPvector; ///< Momentum vector
+  int32_t mCellID;                      ///< Cell ID (used instead of short detID)
+  ClassDefNV(Hit, 1);
+};
+
+} // namespace ecal
+} // namespace o2
+
+#ifdef USESHM
+namespace std
+{
+template <>
+class allocator<o2::ecal::Hit> : public o2::utils::ShmAllocator<o2::ecal::Hit>
+{
+};
+} // namespace std
+#endif
+
+#endif // ALICEO2_ECAL_HIT_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/src/ECalBaseLinkDef.h b/Detectors/Upgrades/ALICE3/ECal/base/src/ECalBaseLinkDef.h
index 3bf7ccd32460c..0f0c0637ce2c1 100644
--- a/Detectors/Upgrades/ALICE3/ECal/base/src/ECalBaseLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/ECal/base/src/ECalBaseLinkDef.h
@@ -15,8 +15,11 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ class o2::ecal::Geometry + ;
 #pragma link C++ class o2::ecal::GeometryTGeo +
 #pragma link C++ class o2::ecal::ECalBaseParam + ;
+#pragma link C++ class o2::ecal::Hit + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::ecal::ECalBaseParam> + ;
+#pragma link C++ class std::vector < o2::ecal::Hit> + ;
 
 #endif
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/src/ECalBaseParam.cxx b/Detectors/Upgrades/ALICE3/ECal/base/src/ECalBaseParam.cxx
index 54eb2860526b3..6847f42e26346 100644
--- a/Detectors/Upgrades/ALICE3/ECal/base/src/ECalBaseParam.cxx
+++ b/Detectors/Upgrades/ALICE3/ECal/base/src/ECalBaseParam.cxx
@@ -9,6 +9,11 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "ECalBase/ECalBaseParam.h"
+/// \file ECalBaseParam.cxx
+/// \brief Geometry parameters configurable via o2-sim --configKeyValues
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
 
-O2ParamImpl(o2::ecal::ECalBaseParam);
\ No newline at end of file
+#include <ECalBase/ECalBaseParam.h>
+
+O2ParamImpl(o2::ecal::ECalBaseParam);
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/src/Geometry.cxx b/Detectors/Upgrades/ALICE3/ECal/base/src/Geometry.cxx
new file mode 100644
index 0000000000000..9483b83f19f49
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/base/src/Geometry.cxx
@@ -0,0 +1,264 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Geometry.cxx
+/// \brief Geometry helper class
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#include "TMath.h"
+#include <Math/Point2D.h>
+#include <Math/Vector2D.h>
+#include <ECalBase/Geometry.h>
+#include <ECalBase/ECalBaseParam.h>
+#include "CommonConstants/MathConstants.h"
+using namespace o2::ecal;
+using o2::constants::math::PIHalf;
+using o2::constants::math::TwoPI;
+
+//==============================================================================
+Geometry::Geometry()
+{
+  auto& pars = ECalBaseParam::Instance();
+  pars.updateFromFile("o2sim_configuration.ini", "ECalBase");
+  pars.printKeyValues(false, true, true, false);
+  mRMin = pars.rMin;
+  mNSuperModules = pars.nSuperModules;
+  mNCrystalModulesZ = pars.nCrystalModulesZ;
+  mNSamplingModulesZ = pars.nSamplingModulesZ;
+  mNCrystalModulesPhi = pars.nCrystalModulesPhi;
+  mNSamplingModulesPhi = pars.nSamplingModulesPhi;
+  mCrystalModW = pars.crystalModuleWidth;
+  mSamplingModW = pars.samplingModuleWidth;
+  mMarginCrystalToSampling = pars.marginCrystalToSampling;
+  mCrystalAlpha = pars.crystalAlphaDeg * TMath::DegToRad();
+  mSamplingAlpha = pars.samplingAlphaDeg * TMath::DegToRad();
+  mNModulesZ = 2 * mNSamplingModulesZ + 2 * mNCrystalModulesZ;
+  fillFrontFaceCenterCoordinates();
+}
+
+//==============================================================================
+int Geometry::getNcols() const
+{
+  return mNModulesZ;
+}
+
+//==============================================================================
+int Geometry::getNrows() const
+{
+  return mNSuperModules * (mNCrystalModulesPhi > mNSamplingModulesPhi ? mNCrystalModulesPhi : mNSamplingModulesPhi);
+}
+
+//==============================================================================
+double Geometry::getCrystalPhiMin()
+{
+  double superModuleDeltaPhi = TwoPI / mNSuperModules;
+  double crystalDeltaPhi = getCrystalDeltaPhi();
+  return (superModuleDeltaPhi - crystalDeltaPhi * mNCrystalModulesPhi) / 2.;
+}
+
+//==============================================================================
+double Geometry::getSamplingPhiMin()
+{
+  double superModuleDeltaPhi = TwoPI / mNSuperModules;
+  double samplingDeltaPhi = getSamplingDeltaPhi();
+  return (superModuleDeltaPhi - samplingDeltaPhi * mNSamplingModulesPhi) / 2.;
+}
+
+//==============================================================================
+void Geometry::fillFrontFaceCenterCoordinates()
+{
+  if (mFrontFaceCenterR.size() > 0)
+    return;
+  mFrontFaceCenterTheta.resize(mNCrystalModulesZ + mNSamplingModulesZ);
+  mFrontFaceZatMinR.resize(mNCrystalModulesZ + mNSamplingModulesZ);
+  mFrontFaceCenterR.resize(mNCrystalModulesZ + mNSamplingModulesZ);
+  mFrontFaceCenterZ.resize(mNCrystalModulesZ + mNSamplingModulesZ);
+  mTanBeta.resize(mNCrystalModulesZ + mNSamplingModulesZ);
+  mFrontFaceCenterSamplingPhi.resize(mNSuperModules * mNSamplingModulesPhi);
+  mFrontFaceCenterCrystalPhi.resize(mNSuperModules * mNCrystalModulesPhi);
+
+  double superModuleDeltaPhi = TwoPI / mNSuperModules;
+  double crystalDeltaPhi = getCrystalDeltaPhi();
+  double samplingDeltaPhi = getSamplingDeltaPhi();
+  double crystalPhiMin = getCrystalPhiMin();
+  double samplingPhiMin = getSamplingPhiMin();
+  for (int ism = 0; ism < mNSuperModules; ism++) {
+    // crystal
+    for (int i = 0; i < mNCrystalModulesPhi; i++) {
+      double phi0 = superModuleDeltaPhi * ism + crystalPhiMin + crystalDeltaPhi * i;
+      mFrontFaceCenterCrystalPhi[ism * mNCrystalModulesPhi + i] = phi0;
+    }
+    // sampling
+    for (int i = 0; i < mNSamplingModulesPhi; i++) {
+      double phi0 = superModuleDeltaPhi * ism + samplingPhiMin + samplingDeltaPhi * i;
+      mFrontFaceCenterSamplingPhi[ism * mNSamplingModulesPhi + i] = phi0;
+    }
+  }
+
+  double theta0 = PIHalf - mCrystalAlpha;
+  double zAtMinR = mCrystalModW * std::cos(mCrystalAlpha);
+
+  for (int m = 0; m < mNCrystalModulesZ; m++) {
+    mTanBeta[m] = std::sin(theta0 - mCrystalAlpha) * mCrystalModW / 2 / mRMin;
+    ROOT::Math::Polar2DVector vMid21(mCrystalModW / 2., PIHalf + theta0);
+    ROOT::Math::XYPoint pAtMinR(zAtMinR, mRMin);
+    ROOT::Math::XYPoint pc = pAtMinR + vMid21;
+    mFrontFaceZatMinR[m] = zAtMinR;
+    mFrontFaceCenterZ[m] = pc.x();
+    mFrontFaceCenterR[m] = pc.y();
+    mFrontFaceCenterTheta[m] = theta0;
+    theta0 -= 2 * mCrystalAlpha;
+    zAtMinR += mCrystalModW * std::cos(mCrystalAlpha) / std::sin(theta0 + mCrystalAlpha);
+  }
+
+  theta0 = mFrontFaceCenterTheta[mNCrystalModulesZ - 1] - mCrystalAlpha - mSamplingAlpha;
+  zAtMinR = mFrontFaceZatMinR[mNCrystalModulesZ - 1];
+  zAtMinR += mSamplingModW * std::cos(mSamplingAlpha) / std::sin(theta0 + mSamplingAlpha);
+  zAtMinR += mMarginCrystalToSampling;
+
+  for (int m = 0; m < mNSamplingModulesZ; m++) {
+    int i = m + mNCrystalModulesZ;
+    mTanBeta[i] = std::sin(theta0 - mSamplingAlpha) * mSamplingModW / 2 / mRMin;
+    ROOT::Math::Polar2DVector vMid21(mSamplingModW / 2., PIHalf + theta0);
+    ROOT::Math::XYPoint pAtMinR(zAtMinR, mRMin);
+    ROOT::Math::XYPoint pc = pAtMinR + vMid21;
+    mFrontFaceZatMinR[i] = zAtMinR;
+    mFrontFaceCenterZ[i] = pc.x();
+    mFrontFaceCenterR[i] = pc.y();
+    mFrontFaceCenterTheta[i] = theta0;
+    theta0 -= 2 * mSamplingAlpha;
+    zAtMinR += mSamplingModW * std::cos(mSamplingAlpha) / std::sin(theta0 + mSamplingAlpha);
+  }
+}
+
+int Geometry::getCellID(int moduleId, int sectorId, bool isCrystal)
+{
+  int cellID = 0;
+  if (isCrystal) {
+    if (moduleId % 2 == 0) { // crystal at positive eta
+      cellID = sectorId * mNModulesZ + moduleId / 2 + mNSamplingModulesZ + mNCrystalModulesZ;
+    } else { // crystal at negative eta
+      cellID = sectorId * mNModulesZ - moduleId / 2 + mNSamplingModulesZ + mNCrystalModulesZ - 1;
+    }
+  } else {
+    if (sectorId % 2 == 0) { // sampling at positive eta
+      cellID = sectorId / 2 * mNModulesZ + moduleId + mNSamplingModulesZ + mNCrystalModulesZ * 2;
+    } else { // sampling at negative eta
+      cellID = sectorId / 2 * mNModulesZ - moduleId + mNSamplingModulesZ;
+    }
+  }
+  return cellID;
+}
+
+//==============================================================================
+std::pair<int, int> Geometry::globalRowColFromIndex(int cellID) const
+{
+  int ip = cellID / mNModulesZ; // row
+  int iz = cellID % mNModulesZ; // col
+  return {ip, iz};
+}
+
+//==============================================================================
+bool Geometry::isCrystal(int cellID)
+{
+  auto [row, col] = globalRowColFromIndex(cellID);
+  return (col >= mNSamplingModulesZ && col < mNSamplingModulesZ + 2 * mNCrystalModulesZ);
+}
+
+//==============================================================================
+std::pair<int, int> Geometry::getSectorChamber(int cellId) const
+{
+  int iphi = cellId / mNModulesZ;
+  int iz = cellId % mNModulesZ;
+  return getSectorChamber(iphi, iz);
+}
+
+//==============================================================================
+std::pair<int, int> Geometry::getSectorChamber(int iphi, int iz) const
+{
+  int chamber = iz < mNSamplingModulesZ ? 0 : (iz < mNSamplingModulesZ + 2 * mNCrystalModulesZ ? 1 : 2);
+  int sector = iphi / (chamber == 1 ? mNCrystalModulesPhi : mNSamplingModulesPhi);
+  return {sector, chamber};
+}
+
+//==============================================================================
+void Geometry::detIdToRelIndex(int cellId, int& chamber, int& sector, int& iphi, int& iz) const
+{
+  // 3 chambers - sampling/crystal/sampling
+  iphi = cellId / mNModulesZ;
+  iz = cellId % mNModulesZ;
+  auto pair = getSectorChamber(iphi, iz);
+  sector = pair.first;
+  chamber = pair.second;
+}
+
+//==============================================================================
+void Geometry::detIdToGlobalPosition(int detId, double& x, double& y, double& z)
+{
+  int chamber, sector, iphi, iz;
+  detIdToRelIndex(detId, chamber, sector, iphi, iz);
+  if (iz < mNSamplingModulesZ + mNCrystalModulesZ) {
+    z = -mFrontFaceCenterZ[mNSamplingModulesZ + mNCrystalModulesZ - iz - 1];
+  } else {
+    z = +mFrontFaceCenterZ[iz % (mNSamplingModulesZ + mNCrystalModulesZ)];
+  }
+  double phi = chamber == 1 ? mFrontFaceCenterCrystalPhi[iphi] : mFrontFaceCenterSamplingPhi[iphi];
+  double r = mFrontFaceCenterR[iz % (mNSamplingModulesZ + mNCrystalModulesZ)];
+  x = r * std::cos(phi);
+  y = r * std::sin(phi);
+}
+
+//==============================================================================
+int Geometry::areNeighboursVertex(int detId1, int detId2) const
+{
+  int ch1, sector1, iphi1, iz1;
+  int ch2, sector2, iphi2, iz2;
+  detIdToRelIndex(detId1, ch1, sector1, iphi1, iz1);
+  detIdToRelIndex(detId2, ch2, sector2, iphi2, iz2);
+  if (sector1 != sector2 || ch1 != ch2)
+    return 0;
+  if (std::abs(iphi1 - iphi2) <= 1 && std::abs(iz1 - iz2) <= 1)
+    return 1;
+  return 0;
+}
+
+//==============================================================================
+bool Geometry::isAtTheEdge(int cellId)
+{
+  auto [row, col] = globalRowColFromIndex(cellId);
+  if (col == 0)
+    return 1;
+  if (col == mNSamplingModulesZ)
+    return 1;
+  if (col == mNSamplingModulesZ - 1)
+    return 1;
+  if (col == mNSamplingModulesZ + 2 * mNCrystalModulesZ)
+    return 1;
+  if (col == mNSamplingModulesZ + 2 * mNCrystalModulesZ - 1)
+    return 1;
+  if (col == mNModulesZ - 1)
+    return 1;
+  for (int m = 0; m <= mNSuperModules; m++) {
+    if (isCrystal(cellId)) {
+      if (row == m * mNCrystalModulesPhi)
+        return 1;
+      if (row == m * mNCrystalModulesPhi - 1)
+        return 1;
+    } else {
+      if (row == m * mNSamplingModulesPhi)
+        return 1;
+      if (row == m * mNSamplingModulesPhi - 1)
+        return 1;
+    }
+  }
+  return 0;
+}
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/ECal/base/src/GeometryTGeo.cxx
index 49f57d8a8c5cc..aca4f5548dc51 100644
--- a/Detectors/Upgrades/ALICE3/ECal/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/ECal/base/src/GeometryTGeo.cxx
@@ -9,6 +9,11 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+/// \file GeometryTGeo.cxx
+/// \brief Class containing ECal volume naming patterns
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
 #include <ECalBase/GeometryTGeo.h>
 #include <TGeoManager.h>
 
@@ -19,7 +24,8 @@ namespace ecal
 std::unique_ptr<o2::ecal::GeometryTGeo> GeometryTGeo::sInstance;
 
 std::string GeometryTGeo::sVolumeName = "ECALV";
-std::string GeometryTGeo::sSensorName = "ECALSensor";
+std::string GeometryTGeo::sSectorName = "ECALSector";
+std::string GeometryTGeo::sModuleName = "ECALModule";
 
 GeometryTGeo::GeometryTGeo(bool build, int loadTrans) : DetMatrixCache()
 {
@@ -57,10 +63,15 @@ GeometryTGeo* GeometryTGeo::Instance()
   return sInstance.get();
 }
 
-const char* GeometryTGeo::composeSymNameSensor()
+const char* GeometryTGeo::composeSymNameSector(int s)
+{
+  return Form("%s/%s_%d", composeSymNameECal(), getECalSectorPattern(), s);
+}
+
+const char* GeometryTGeo::composeSymNameModule(int s, int m)
 {
-  return Form("%s/%d", composeSymNameECal(), 0);
+  return Form("%s/%s_%d", composeSymNameSector(s), getECalModulePattern(), m);
 }
 
 } // namespace ecal
-} // namespace o2
\ No newline at end of file
+} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/src/Hit.cxx b/Detectors/Upgrades/ALICE3/ECal/base/src/Hit.cxx
new file mode 100644
index 0000000000000..ee2034314d2d8
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/base/src/Hit.cxx
@@ -0,0 +1,34 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Hit.cxx
+/// \brief MC hit class to store energy loss per cell and per superparent
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#include <ECalBase/Hit.h>
+
+ClassImp(o2::ecal::Hit);
+
+using namespace o2::ecal;
+
+bool Hit::operator<(const Hit& rhs) const
+{
+  if (GetTrackID() != rhs.GetTrackID()) {
+    return GetTrackID() < rhs.GetTrackID();
+  }
+  return GetCellID() < rhs.GetCellID();
+}
+
+bool Hit::operator==(const Hit& rhs) const
+{
+  return (GetCellID() == rhs.GetCellID()) && (GetTrackID() == rhs.GetTrackID());
+}
diff --git a/Detectors/Upgrades/ALICE3/ECal/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/ECal/reconstruction/CMakeLists.txt
new file mode 100644
index 0000000000000..f51a9c067d6b3
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/reconstruction/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(ECalReconstruction
+               SOURCES src/Clusterizer.cxx
+               PUBLIC_LINK_LIBRARIES O2::ECalBase
+                                     O2::DataFormatsECal
+                                     AliceO2::InfoLogger)
+
+o2_target_root_dictionary(ECalReconstruction
+                          HEADERS include/ECalReconstruction/Clusterizer.h)
diff --git a/Detectors/Upgrades/ALICE3/ECal/reconstruction/include/ECalReconstruction/Clusterizer.h b/Detectors/Upgrades/ALICE3/ECal/reconstruction/include/ECalReconstruction/Clusterizer.h
new file mode 100644
index 0000000000000..3bb7cab4b11e3
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/reconstruction/include/ECalReconstruction/Clusterizer.h
@@ -0,0 +1,75 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Clusterizer.h
+/// \brief Class for cluster finding and unfolding
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#ifndef ALICEO2_ECAL_CLUSTERIZER_H
+#define ALICEO2_ECAL_CLUSTERIZER_H
+
+#include <gsl/span>
+#include <vector>
+#include <DataFormatsECal/Digit.h>
+#include <DataFormatsECal/Cluster.h>
+
+using o2::ecal::Cluster;
+using o2::ecal::Digit;
+class TF1;
+
+namespace o2
+{
+namespace ecal
+{
+class Clusterizer
+{
+ public:
+  Clusterizer(bool applyCorrectionZ = 1, bool applyCorrectionE = 1);
+  ~Clusterizer() = default;
+  void initialize() {};
+  void addDigitToCluster(Cluster& cluster, int row, int col, const gsl::span<const Digit>& digits);
+  void findClusters(const gsl::span<const Digit>& digits, std::vector<Cluster>& foundClusters, std::vector<Cluster>& unfoldedClusters);
+  void makeClusters(const gsl::span<const Digit>& digits, std::vector<Cluster>& clusters);
+  void makeUnfoldings(std::vector<Cluster>& foundClusters, std::vector<Cluster>& unfoldedClusters);
+  void unfoldOneCluster(Cluster* iniClu, int nMax, int* digitId, float* maxAtEnergy, std::vector<Cluster>& unfoldedClusters);
+  void evalClusters(std::vector<Cluster>& clusters);
+  int getNumberOfLocalMax(Cluster& clu, int* maxAt, float* maxAtEnergy);
+  double showerShape(double dx, double dz, bool isCrystal);
+  void setLogWeight(double logWeight) { mLogWeight = logWeight; }
+  void setClusteringThreshold(double threshold) { mClusteringThreshold = threshold; }
+  void setCrystalDigitThreshold(double threshold) { mCrystalDigitThreshold = threshold; }
+  void setSamplingDigitThreshold(double threshold) { mSamplingDigitThreshold = threshold; }
+
+ private:
+  std::vector<std::vector<int>> mDigitIndices; // 2D map of digit indices used for recursive cluster finding
+  bool mUnfoldClusters = true;                 // to perform cluster unfolding
+  double mCrystalDigitThreshold = 0.040;       // minimal energy of crystal digit
+  double mSamplingDigitThreshold = 0.100;      // minimal energy of sampling digit
+  double mClusteringThreshold = 0.050;         // minimal energy of digit to start clustering (GeV)
+  double mClusteringTimeGate = 1e9;            // maximal time difference between digits to be accepted to clusters (in ns)
+  int mNLMMax = 30;                            // maximal number of local maxima in unfolding
+  double mLogWeight = 4.;                      // cutoff used in log. weight calculation
+  double mUnfogingEAccuracy = 1.e-4;           // accuracy of energy calculation in unfoding prosedure (GeV)
+  double mUnfogingXZAccuracy = 1.e-2;          // accuracy of position calculation in unfolding procedure (cm)
+  int mNMaxIterations = 100;                   // maximal number of iterations in unfolding procedure
+  double mLocalMaximumCut = 0.015;             // minimal height of local maximum over neighbours
+  bool mApplyCorrectionZ = 1;                  // z-correction
+  bool mApplyCorrectionE = 1;                  // energy-correction
+  TF1* fCrystalShowerShape;                    //! Crystal shower shape
+  TF1* fSamplingShowerShape;                   //! Sampling shower shape
+  TF1* fCrystalRMS;                            //! Crystal RMS
+};
+
+} // namespace ecal
+} // namespace o2
+
+#endif // ALICEO2_ECAL_CLUSTERIZER_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/Clusterizer.cxx b/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/Clusterizer.cxx
new file mode 100644
index 0000000000000..c84f62b60ec38
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/Clusterizer.cxx
@@ -0,0 +1,455 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Clusterizer.cxx
+/// \brief Class for cluster finding and unfolding
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#include <TMath.h>
+#include <TF1.h>
+#include <fairlogger/Logger.h>
+#include <ECalReconstruction/Clusterizer.h>
+#include <ECalBase/Geometry.h>
+#include <DataFormatsECal/Digit.h>
+#include <DataFormatsECal/Cluster.h>
+
+using namespace o2::ecal;
+
+//==============================================================================
+Clusterizer::Clusterizer(bool applyCorrectionZ, bool applyCorrectionE)
+{
+  auto& geo = Geometry::instance();
+  mDigitIndices.resize(geo.getNrows(), std::vector<int>(geo.getNcols(), -1));
+  mApplyCorrectionZ = applyCorrectionZ;
+  mApplyCorrectionE = applyCorrectionE;
+  fCrystalShowerShape = new TF1("fCrystal", "x<[1] ? [0]*exp([3]*x+[4]*x*x+[5]*x*x*x) : (x<[2] ? [0]*[6]*exp([7]*x+[8]*x*x) : [0]*[9]*exp([10]*x+[11]*x*x))", 0, 15);
+  double pc[12];
+  pc[0] = 1. / 13.15;
+  pc[1] = 2.2;
+  pc[2] = 5;
+  pc[3] = 4.38969;
+  pc[4] = -5.15975;
+  pc[5] = 1.18978;
+  pc[6] = 1.48726;
+  pc[7] = -1.54621;
+  pc[8] = 0.0814617;
+  pc[9] = 0.0369055;
+  pc[10] = -0.174372;
+  pc[11] = -0.0455978;
+
+  fCrystalShowerShape->SetParameters(pc);
+
+  fSamplingShowerShape = new TF1("fSampling", "x<[1] ? [0]*exp([3]*x+[4]*x*x+[5]*x*x*x) : (x<[2] ? [0]*[6]*exp([7]*x+[8]*x*x) : [0]*[9]*exp([10]*x+[11]*x*x))", 0, 15);
+  double ps[12];
+  ps[0] = 1 / 35.6;
+  ps[1] = 3.2;
+  ps[2] = 6;
+  ps[3] = 3.06543;
+  ps[4] = -2.23235;
+  ps[5] = 0.325344;
+  ps[6] = 6.0733;
+  ps[7] = -1.62713;
+  ps[8] = 0.0965569;
+  ps[9] = 0.0765706;
+  ps[10] = -0.217398;
+  ps[11] = -0.0204646;
+  fSamplingShowerShape->SetParameters(ps);
+
+  fCrystalRMS = new TF1("fCrystalRMS", "[0]*x*exp([1]*x+[2]*x*x+[3]*x*x*x)", 0, 2.2);
+  double p[4];
+  p[0] = 1.39814;
+  p[1] = -6.05426;
+  p[2] = 6.26678;
+  p[3] = -1.97092;
+  fCrystalRMS->SetParameters(p);
+}
+
+//==============================================================================
+void Clusterizer::findClusters(const gsl::span<const Digit>& digits, std::vector<Cluster>& foundClusters, std::vector<Cluster>& unfoldedClusters)
+{
+  foundClusters.clear();
+  unfoldedClusters.clear();
+
+  // Collect list of clusters
+  makeClusters(digits, foundClusters);
+
+  // Split clusters with several local maxima if necessary
+  makeUnfoldings(foundClusters, unfoldedClusters);
+
+  // Evaluate cluster position, dispersion etc.
+  evalClusters(foundClusters);
+  evalClusters(unfoldedClusters);
+}
+
+//==============================================================================
+void Clusterizer::addDigitToCluster(Cluster& cluster, int row, int col, const gsl::span<const Digit>& digits)
+{
+  auto& geo = Geometry::instance();
+  if (row < 0 || row >= geo.getNrows() || col < 0 || col >= geo.getNcols())
+    return;
+  int digitIndex = mDigitIndices[row][col];
+  LOGP(debug, "    checking row={} and col={} digitIndex={}", row, col, digitIndex);
+  if (digitIndex < 0)
+    return;
+
+  const Digit& digit = digits[digitIndex];
+  if (cluster.getMultiplicity() > 0) {
+    // check if new digit is in the same chamber and sector
+    const Digit& digit2 = digits[cluster.getDigitIndex(0)];
+    auto [sector1, ch1] = geo.getSectorChamber(digit.getTower());
+    auto [sector2, ch2] = geo.getSectorChamber(digit2.getTower());
+    LOGP(debug, "    checking if sector and chamber are the same: ({},{}) ({},{})", sector1, ch1, sector2, ch2);
+    if (sector1 != sector2 || ch1 != ch2)
+      return;
+  }
+
+  mDigitIndices[row][col] = -1;
+  cluster.addDigit(digitIndex, digit.getTower(), digit.getEnergy());
+  LOGP(debug, "    adding new digit at row={} and col={}", row, col);
+  addDigitToCluster(cluster, row - 1, col, digits);
+  addDigitToCluster(cluster, row + 1, col, digits);
+  addDigitToCluster(cluster, row, col - 1, digits);
+  addDigitToCluster(cluster, row, col + 1, digits);
+}
+
+//==============================================================================
+void Clusterizer::makeClusters(const gsl::span<const Digit>& digits, std::vector<Cluster>& clusters)
+{
+  // Combine digits into cluster
+
+  int nDigits = digits.size();
+
+  // reset mDigitIndices
+  for (auto& rows : mDigitIndices) {
+    rows.assign(rows.size(), -1);
+  }
+
+  // fill mDigitIndices
+  auto& geo = Geometry::instance();
+  for (int i = 0; i < nDigits; i++) {
+    const Digit& digit = digits[i];
+    auto [row, col] = geo.globalRowColFromIndex(digit.getTower());
+    bool isCrystal = geo.isCrystal(digit.getTower());
+    if (isCrystal) {
+      if (digit.getEnergy() < mCrystalDigitThreshold)
+        continue;
+    } else {
+      if (digit.getEnergy() < mSamplingDigitThreshold)
+        continue;
+    }
+    mDigitIndices[row][col] = i;
+  }
+
+  // add digit seeds to clusters and recursively add neighbours
+  for (int i = 0; i < nDigits; i++) {
+    const Digit& digitSeed = digits[i];
+    auto [row, col] = geo.globalRowColFromIndex(digitSeed.getTower());
+    if (mDigitIndices[row][col] < 0)
+      continue; // digit was already added in one of the clusters
+    if (digitSeed.getEnergy() < mClusteringThreshold)
+      continue;
+    LOGP(debug, "  starting new cluster at row={} and col={}", row, col);
+    auto& cluster = clusters.emplace_back();
+    addDigitToCluster(cluster, row, col, digits);
+  }
+
+  LOGP(debug, "made {} clusters from {} digits", clusters.size(), nDigits);
+}
+
+//==============================================================================
+void Clusterizer::makeUnfoldings(std::vector<Cluster>& foundClusters, std::vector<Cluster>& unfoldedClusters)
+{
+  // Split cluster if several local maxima are found
+  if (!mUnfoldClusters) {
+    return;
+  }
+
+  int* maxAt = new int[mNLMMax];
+  float* maxAtEnergy = new float[mNLMMax];
+
+  for (auto& clu : foundClusters) {
+    int nMax = getNumberOfLocalMax(clu, maxAt, maxAtEnergy);
+    if (nMax > 1) {
+      unfoldOneCluster(&clu, nMax, maxAt, maxAtEnergy, unfoldedClusters);
+    } else {
+      clu.setNLM(1);
+      unfoldedClusters.emplace_back(clu);
+    }
+  }
+  delete[] maxAt;
+  delete[] maxAtEnergy;
+}
+
+//==============================================================================
+void Clusterizer::unfoldOneCluster(Cluster* iniClu, int nMax, int* digitId, float* maxAtEnergy, std::vector<Cluster>& unfoldedClusters)
+{
+  // Based on MpdEmcClusterizerKI::UnfoldOneCluster by D. Peresunko
+  // Performs the unfolding of a cluster with nMax overlapping showers
+  // Parameters: iniClu cluster to be unfolded
+  //             nMax number of local maxima found (this is the number of new clusters)
+  //             digitId: index of digits, corresponding to local maxima
+  //             maxAtEnergy: energies of digits, corresponding to local maxima
+
+  // Take initial cluster and calculate local coordinates of digits
+  // To avoid multiple re-calculation of same parameters
+  int mult = iniClu->getMultiplicity();
+  std::vector<double> x(mult);
+  std::vector<double> y(mult);
+  std::vector<double> z(mult);
+  std::vector<double> e(mult);
+  std::vector<std::vector<double>> eInClusters(mult, std::vector<double>(nMax));
+
+  auto& geo = Geometry::instance();
+  bool isCrystal = geo.isCrystal(iniClu->getDigitTowerId(0));
+
+  for (int idig = 0; idig < mult; idig++) {
+    e[idig] = iniClu->getDigitEnergy(idig);
+    geo.detIdToGlobalPosition(iniClu->getDigitTowerId(idig), x[idig], y[idig], z[idig]);
+  }
+
+  // Coordinates of centers of clusters
+  std::vector<double> xMax(nMax);
+  std::vector<double> yMax(nMax);
+  std::vector<double> zMax(nMax);
+  std::vector<double> eMax(nMax);
+
+  for (int iclu = 0; iclu < nMax; iclu++) {
+    xMax[iclu] = x[digitId[iclu]];
+    yMax[iclu] = y[digitId[iclu]];
+    zMax[iclu] = z[digitId[iclu]];
+    eMax[iclu] = e[digitId[iclu]];
+  }
+
+  std::vector<double> prop(nMax); // proportion of clusters in the current digit
+
+  // Try to decompose cluster to contributions
+  int nIterations = 0;
+  bool insuficientAccuracy = true;
+
+  while (insuficientAccuracy && nIterations < mNMaxIterations) {
+    // Loop over all digits of parent cluster and split their energies between daughter clusters
+    // according to shower shape
+    for (int idig = 0; idig < mult; idig++) {
+      double eEstimated = 0;
+      for (int iclu = 0; iclu < nMax; iclu++) {
+        prop[iclu] = eMax[iclu] * showerShape(std::sqrt((x[idig] - xMax[iclu]) * (x[idig] - xMax[iclu]) +
+                                                        (y[idig] - yMax[iclu]) * (y[idig] - yMax[iclu])),
+                                              z[idig] - zMax[iclu], isCrystal);
+        eEstimated += prop[iclu];
+      }
+      if (eEstimated == 0.) { // numerical accuracy
+        continue;
+      }
+      // Split energy of digit according to contributions
+      for (int iclu = 0; iclu < nMax; iclu++) {
+        eInClusters[idig][iclu] = e[idig] * prop[iclu] / eEstimated;
+      }
+    }
+    // Recalculate parameters of clusters and check relative variation of energy and absolute of position
+    insuficientAccuracy = false; // will be true if at least one parameter changed too much
+    for (int iclu = 0; iclu < nMax; iclu++) {
+      double oldX = xMax[iclu];
+      double oldY = yMax[iclu];
+      double oldZ = zMax[iclu];
+      double oldE = eMax[iclu];
+      // new energy, need for weight
+      eMax[iclu] = 0;
+      for (int idig = 0; idig < mult; idig++) {
+        eMax[iclu] += eInClusters[idig][iclu];
+      }
+      xMax[iclu] = 0;
+      yMax[iclu] = 0;
+      zMax[iclu] = 0;
+      double wtot = 0.;
+      for (int idig = 0; idig < mult; idig++) {
+        double w = std::max(std::log(eInClusters[idig][iclu] / eMax[iclu]) + mLogWeight, 0.);
+        xMax[iclu] += x[idig] * w;
+        yMax[iclu] += y[idig] * w;
+        zMax[iclu] += z[idig] * w;
+        wtot += w;
+      }
+      if (wtot > 0.) {
+        xMax[iclu] /= wtot;
+        yMax[iclu] /= wtot;
+        zMax[iclu] /= wtot;
+      }
+      // Compare variation of parameters
+      insuficientAccuracy += (std::abs(eMax[iclu] - oldE) > mUnfogingEAccuracy);
+      insuficientAccuracy += (std::abs(xMax[iclu] - oldX) > mUnfogingXZAccuracy);
+      insuficientAccuracy += (std::abs(yMax[iclu] - oldY) > mUnfogingXZAccuracy);
+      insuficientAccuracy += (std::abs(zMax[iclu] - oldZ) > mUnfogingXZAccuracy);
+    }
+    nIterations++;
+  }
+
+  // Iterations finished, add new clusters
+  for (int iclu = 0; iclu < nMax; iclu++) {
+    auto& clu = unfoldedClusters.emplace_back();
+    clu.setNLM(nMax);
+    for (int idig = 0; idig < mult; idig++) {
+      int jdigit = iniClu->getDigitIndex(idig);
+      int towerId = iniClu->getDigitTowerId(idig);
+      clu.addDigit(jdigit, towerId, eInClusters[idig][iclu]);
+    }
+  }
+}
+
+//==============================================================================
+void Clusterizer::evalClusters(std::vector<Cluster>& clusters)
+{
+  auto& geo = Geometry::instance();
+  for (auto& cluster : clusters) {
+    double x = 0;
+    double y = 0;
+    double z = 0;
+    double wtot = 0;
+    double etot = cluster.getE();
+    for (size_t i = 0; i < cluster.getMultiplicity(); i++) {
+      float energy = cluster.getDigitEnergy(i);
+      int towerId = cluster.getDigitTowerId(i);
+      double xi, yi, zi;
+      geo.detIdToGlobalPosition(towerId, xi, yi, zi);
+      double w = std::max(0., mLogWeight + std::log(energy / etot));
+      x += w * xi;
+      y += w * yi;
+      z += w * zi;
+      wtot += w;
+    }
+    if (wtot != 0) {
+      x /= wtot;
+      y /= wtot;
+      z /= wtot;
+    }
+    cluster.setX(x);
+    cluster.setY(y);
+    cluster.setZ(z);
+
+    // cluster shape
+    float chi2 = 0;
+    int ndf = 0;
+    float ee = cluster.getE();
+    for (size_t i = 0; i < cluster.getMultiplicity(); i++) {
+      float energy = cluster.getDigitEnergy(i);
+      int towerId = cluster.getDigitTowerId(i);
+      double xi, yi, zi;
+      geo.detIdToGlobalPosition(towerId, xi, yi, zi);
+      double r = std::sqrt((x - xi) * (x - xi) + (y - yi) * (y - yi) + (z - zi) * (z - zi));
+      if (r > 2.2)
+        continue;
+      double frac = fCrystalShowerShape->Eval(r);
+      double rms = fCrystalRMS->Eval(r);
+      chi2 += std::pow((energy / ee - frac) / rms, 2.);
+      ndf++;
+    }
+    cluster.setChi2(chi2 / ndf);
+
+    // correct cluster energy and z position
+    float eta = std::abs(cluster.getEta());
+    float eCor = 1;
+    float zCor = 0;
+    bool isCrystal = geo.isCrystal(cluster.getDigitTowerId(0));
+    if (isCrystal) {
+      eCor = 0.00444 * std::pow(ee, -1.322) + (1.021 + 0.0018 * eta);
+      if (mApplyCorrectionE)
+        ee *= eCor;
+      if (mApplyCorrectionZ)
+        zCor = (-0.00518682 + 0.730052 * eta - 0.73817 * eta * eta);
+    } else {
+      eCor = 0.0033 * std::pow(ee, -2.09) + (1.007 + 0.0667 * eta - 0.108 * eta * eta + 0.0566 * eta * eta * eta);
+      if (mApplyCorrectionE)
+        ee *= eCor;
+      if (mApplyCorrectionZ)
+        zCor = (-2.13679 + 6.40009 * eta - 3.34233 * eta * eta) + (-0.136425 + 0.401887 * eta - 0.196851 * eta * eta) * ee + (0.00822276 - 0.0242512 * eta + 0.0118986 * eta * eta) * ee * ee;
+    }
+
+    cluster.setE(ee);
+    cluster.setZ(cluster.getZ() - zCor);
+
+    // check if cluster is at the edge of detector module
+    bool isEdge = 0;
+    for (size_t i = 0; i < cluster.getMultiplicity(); i++) {
+      int towerId = cluster.getDigitTowerId(i);
+      if (!geo.isAtTheEdge(towerId))
+        continue;
+      isEdge = 1;
+      break;
+    }
+    cluster.setEdgeFlag(isEdge);
+
+    LOGF(debug, "Cluster coordinates: (%6.2f,%6.2f,%6.2f), eCor=%6.2f zCor=%6.2f", cluster.getX(), cluster.getY(), cluster.getZ(), eCor, zCor);
+  }
+}
+
+//==============================================================================
+int Clusterizer::getNumberOfLocalMax(Cluster& clu, int* maxAt, float* maxAtEnergy)
+{
+  // Based on MpdEmcClusterizerKI::GetNumberOfLocalMax by D. Peresunko
+  // Calculates the number of local maxima in the cluster using LocalMaxCut as the minimum
+  // energy difference between maximum and surrounding digits
+  auto& geo = Geometry::instance();
+  int n = clu.getMultiplicity();
+  bool isCrystal = geo.isCrystal(clu.getDigitTowerId(0));
+  bool* isLocalMax = new bool[n];
+
+  for (int i = 0; i < n; i++) {
+    isLocalMax[i] = false;
+    float en1 = clu.getDigitEnergy(i);
+    if (en1 > mClusteringThreshold)
+      isLocalMax[i] = true;
+  }
+
+  for (int i = 0; i < n; i++) {
+    int detId1 = clu.getDigitTowerId(i);
+    float en1 = clu.getDigitEnergy(i);
+    for (int j = i + 1; j < n; j++) {
+      int detId2 = clu.getDigitTowerId(j);
+      float en2 = clu.getDigitEnergy(j);
+      if (geo.areNeighboursVertex(detId1, detId2) == 1) {
+        if (en1 > en2) {
+          isLocalMax[j] = false;
+          // but may be digit too is not local max ?
+          if (en2 > en1 - mLocalMaximumCut) {
+            isLocalMax[i] = false;
+          }
+        } else {
+          isLocalMax[i] = false;
+          // but may be digitN is not local max too?
+          if (en1 > en2 - mLocalMaximumCut) {
+            isLocalMax[j] = false;
+          }
+        }
+      } // if neighbours
+    } // digit j
+  } // digit i
+
+  int iDigitN = 0;
+  for (int i = 0; i < n; i++) {
+    if (isLocalMax[i]) {
+      maxAt[iDigitN] = i;
+      maxAtEnergy[iDigitN] = clu.getDigitEnergy(i);
+      iDigitN++;
+      if (iDigitN >= mNLMMax) { // Note that size of output arrays is limited:
+        LOGP(error, "Too many local maxima, cluster multiplicity {} region={}", n, isCrystal ? "crystal" : "sampling");
+        return 0;
+      }
+    }
+  }
+  delete[] isLocalMax;
+  return iDigitN;
+}
+
+//==============================================================================
+double Clusterizer::showerShape(double dx, double dz, bool isCrystal)
+{
+  double x = std::sqrt(dx * dx + dz * dz);
+  return isCrystal ? fCrystalShowerShape->Eval(x) : fSamplingShowerShape->Eval(x);
+}
diff --git a/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/ECalReconstructionLinkDef.h b/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/ECalReconstructionLinkDef.h
new file mode 100644
index 0000000000000..d69cd8164e717
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/ECalReconstructionLinkDef.h
@@ -0,0 +1,20 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::ecal::Clusterizer + ;
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/ECal/simulation/CMakeLists.txt
index 8c8c5a6bba15f..83de48e38db3a 100644
--- a/Detectors/Upgrades/ALICE3/ECal/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/CMakeLists.txt
@@ -11,8 +11,13 @@
 
 o2_add_library(ECalSimulation
                SOURCES src/Detector.cxx
+                       src/Digitizer.cxx
                PUBLIC_LINK_LIBRARIES O2::ECalBase
-                                     O2::ITSMFTSimulation)
+                                     O2::DataFormatsECal)
 
 o2_target_root_dictionary(ECalSimulation
-                          HEADERS include/ECalSimulation/Detector.h)
\ No newline at end of file
+                          HEADERS include/ECalSimulation/Detector.h
+                                  include/ECalSimulation/Digitizer.h
+                         )
+
+o2_data_file(COPY data DESTINATION Detectors/ECL/simulation)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/data/simcuts.dat b/Detectors/Upgrades/ALICE3/ECal/simulation/data/simcuts.dat
new file mode 100644
index 0000000000000..81aa69990f222
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/data/simcuts.dat
@@ -0,0 +1,14 @@
+* ECAL
+* ====
+*
+*     Med   GAM   ELEC   NHAD   CHAD   MUON   EBREM  MUHAB   EDEL  MUDEL MUPA  ANNI  BREM  COMP  DCAY  DRAY  HADR  LOSS  MULS  PAIR  PHOT  RAYL STRA
+* Air
+ECL    0   5.e-5  1.e-4  1.e-5  1.e-5  1.e-5  1.e-5  1.e-5  1.e-5  1.e-5  -1.   1     1     1     1     1     1     1     1     1     1     1    -1
+* Lead
+ECL    1   1.e-4  1.e-4  1.e-3  1.e-3  1.e-3  1.e-4  1.e-4  1.e-4  1.e-4  -1.   1     1     1     1     1     1     3     1     1     1     1    -1
+* Scintillator
+ECL    2   1.e-4  1.e-4  1.e-3  1.e-3  1.e-3  1.e-4  1.e-4  1.e-4  1.e-4  -1.   1     1     1     1     1     1     3     1     1     1     1    -1
+* Aluminium
+ECL    3   1.e-4  1.e-4  1.e-3  1.e-3  1.e-3  1.e-4  1.e-4  1.e-4  1.e-4  -1.   1     1     1     1     1     1     3     1     1     1     1    -1
+* PWO
+ECL    4   5.e-5  1.e-4  1.e-5  1.e-5  1.e-5  1.e-5  1.e-5  1.e-5  1.e-5  -1.   1     1     1     1     1     1     1     1     1     1     1    -1
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/include/ECalSimulation/Detector.h b/Detectors/Upgrades/ALICE3/ECal/simulation/include/ECalSimulation/Detector.h
index 14664092a8718..849dd69f85f2b 100644
--- a/Detectors/Upgrades/ALICE3/ECal/simulation/include/ECalSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/include/ECalSimulation/Detector.h
@@ -8,18 +8,18 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-//
-// Design and equations: Nicola Nicassio nicola.nicassio@cern.ch
-//
+
+/// \file Detector.h
+/// \brief ECal geometry creation and hit processing
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
 
 #ifndef ALICEO2_ECAL_DETECTOR_H
 #define ALICEO2_ECAL_DETECTOR_H
 
-#include "DetectorsBase/Detector.h"
-#include "ITSMFTSimulation/Hit.h"
-
-#include "ECalBase/GeometryTGeo.h"
-
+#include <DetectorsBase/Detector.h>
+#include <ECalBase/Hit.h>
+#include <ECalBase/GeometryTGeo.h>
 #include <TLorentzVector.h>
 #include <TString.h>
 
@@ -27,62 +27,35 @@ namespace o2
 {
 namespace ecal
 {
-
 class Detector : public o2::base::DetImpl<Detector>
 {
  public:
-  Detector(bool active);
-  Detector();
+  Detector(bool active = 1);
   ~Detector();
 
-  void ConstructGeometry() override;
-
-  o2::itsmft::Hit* addHit(int trackID, int detID, const TVector3& startPos, const TVector3& endPos,
-                          const TVector3& startMom, double startE, double endTime, double eLoss,
-                          unsigned char startStatus, unsigned char endStatus);
-
   // Mandatory overrides
-  void BeginPrimary() override { ; }
-  void FinishPrimary() override { ; }
+  void ConstructGeometry() override;
+  void BeginPrimary() override {}
+  void FinishPrimary() override {}
   void InitializeO2Detector() override;
-  void PostTrack() override { ; }
-  void PreTrack() override { ; }
+  void PostTrack() override {}
+  void PreTrack() override {}
   bool ProcessHits(FairVolume* v = nullptr) override;
-  void EndOfEvent() override;
+  void EndOfEvent() override { Reset(); }
   void Register() override;
   void Reset() override;
+  std::vector<o2::ecal::Hit>* getHits(int iColl) const { return !iColl ? mHits : nullptr; }
 
-  // Custom memer functions
-  std::vector<o2::itsmft::Hit>* getHits(int iColl) const
-  {
-    if (!iColl) {
-      return mHits;
-    }
-    return nullptr;
-  }
-
+ private:
   void createMaterials();
   void createGeometry();
-
- private:
-  // Transient data about track passing the sensor
-  struct TrackData {
-    bool mHitStarted;              // hit creation started
-    unsigned char mTrkStatusStart; // track status flag
-    TLorentzVector mPositionStart; // position at entrance
-    TLorentzVector mMomentumStart; // momentum
-    double mEnergyLoss;            // energy loss
-  } mTrackData;                    //! transient data
-
-  GeometryTGeo* mGeometryTGeo;         //!
-  std::vector<o2::itsmft::Hit>* mHits; // ITSMFT ones for the moment
-
-  void defineSensitiveVolumes();
-  float mInnerRadius;
-  float mOuterRadius;
-  float mLength;
-
-  bool mEnableEndcap{true};
+  void defineSamplingFactor();
+  std::unordered_map<int, int> mSuperParentIndices; //! Super parent indices (track index - superparent index)
+  int currentTrackId = -1;                          // current track index
+  int superparentId = -1;                           // superparent index
+  GeometryTGeo* mGeometryTGeo;                      //!
+  std::vector<o2::ecal::Hit>* mHits;                //!
+  double mSamplingFactorTransportModel = 1.;
 
  protected:
   template <typename Det>
@@ -104,4 +77,5 @@ struct UseShm<o2::ecal::Detector> {
 } // namespace base
 } // namespace o2
 #endif
-#endif
\ No newline at end of file
+
+#endif // ALICEO2_ECAL_DETECTOR_H
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/include/ECalSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/ECal/simulation/include/ECalSimulation/Digitizer.h
new file mode 100644
index 0000000000000..91213fa90b63a
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/include/ECalSimulation/Digitizer.h
@@ -0,0 +1,58 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Digitizer.h
+/// \brief Digitization of ECal MC information
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#ifndef ALICEO2_ECAL_DIGITIZER_H
+#define ALICEO2_ECAL_DIGITIZER_H
+#include <vector>
+#include <ECalBase/Hit.h>
+#include <DataFormatsECal/Digit.h>
+#include <DataFormatsECal/MCLabel.h>
+#include <SimulationDataFormat/MCTruthContainer.h>
+
+using o2::ecal::Digit;
+using o2::ecal::Hit;
+using o2::ecal::MCLabel;
+
+namespace o2
+{
+namespace ecal
+{
+class Digitizer
+{
+ public:
+  Digitizer();
+  ~Digitizer() = default;
+  Digitizer(const Digitizer&) = delete;
+  Digitizer& operator=(const Digitizer&) = delete;
+  void init() {}
+  void finish() {}
+  void processHits(const std::vector<Hit>* mHits, std::vector<Digit>& digits, o2::dataformats::MCTruthContainer<MCLabel>& labels, int collId);
+  void setThreshold(double threshold) { mThreshold = threshold; }
+  void setSmearCrystal(bool smearCrystal) { mSmearCrystal = smearCrystal; }
+  void setSamplingFraction(double fraction) { mSamplingFraction = fraction; }
+  void setCrystalPePerGeV(double pePerGeV) { mCrystalPePerGeV = pePerGeV; }
+
+ private:
+  std::vector<Digit> mArrayD;
+  bool mSmearCrystal = 0;
+  double mThreshold = 0.001;
+  double mSamplingFraction = 9.8;
+  double mCrystalPePerGeV = 4000;
+};
+} // namespace ecal
+} // namespace o2
+
+#endif // ALICEO2_ECAL_DIGITIZER_H
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/ECal/simulation/src/Detector.cxx
index aeb58649fa4c5..93089bb8ced14 100644
--- a/Detectors/Upgrades/ALICE3/ECal/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/src/Detector.cxx
@@ -9,45 +9,40 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include <FairVolume.h>
+/// \file Detector.cxx
+/// \brief ECal geometry creation and hit processing
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
 
+#include <FairVolume.h>
 #include <TVirtualMC.h>
 #include <TVirtualMCStack.h>
+#include <TGeoManager.h>
 #include <TGeoVolume.h>
 #include <TGeoTube.h>
-#include <TGeoManager.h>
-
-#include "DetectorsBase/Stack.h"
-#include "ITSMFTSimulation/Hit.h"
-#include "ECalSimulation/Detector.h"
-#include "ECalBase/ECalBaseParam.h"
-
-using o2::itsmft::Hit;
+#include <TGeoArb8.h>
+#include <TGeoTrd2.h>
+#include <Math/Point2D.h>
+#include <Math/Vector2D.h>
+#include <DetectorsBase/Stack.h>
+#include <ECalBase/Hit.h>
+#include <ECalBase/ECalBaseParam.h>
+#include <ECalBase/Geometry.h>
+#include <ECalSimulation/Detector.h>
+
+using o2::ecal::Hit;
 
 namespace o2
 {
 namespace ecal
 {
-
-Detector::Detector()
-  : o2::base::DetImpl<Detector>("ECL", true),
-    mTrackData(),
-    mHits(o2::utils::createSimVector<o2::itsmft::Hit>())
-{
-}
-
 Detector::Detector(bool active)
-  : o2::base::DetImpl<Detector>("ECL", true),
-    mTrackData(),
-    mHits(o2::utils::createSimVector<o2::itsmft::Hit>())
+  : o2::base::DetImpl<Detector>("ECL", active),
+    mHits(o2::utils::createSimVector<o2::ecal::Hit>())
 {
-  auto& ecalPars = ECalBaseParam::Instance();
-  mInnerRadius = ecalPars.rMin;
-  mOuterRadius = ecalPars.rMax;
-  mLength = ecalPars.zLength;
-  mEnableEndcap = ecalPars.enableFwdEndcap;
 }
 
+//==============================================================================
 Detector::~Detector()
 {
   if (mHits) {
@@ -55,190 +50,344 @@ Detector::~Detector()
   }
 }
 
+//==============================================================================
 void Detector::ConstructGeometry()
 {
   createMaterials();
   createGeometry();
+  defineSamplingFactor();
 }
 
+//==============================================================================
+void Detector::defineSamplingFactor()
+{
+  TString mcname = TVirtualMC::GetMC()->GetName();
+  TString mctitle = TVirtualMC::GetMC()->GetTitle();
+  LOGP(info, "Defining sampling factor for mc={}' and title='{}'", mcname.Data(), mctitle.Data());
+  if (mcname.Contains("Geant3")) {
+    mSamplingFactorTransportModel = 0.983;
+  } else if (mcname.Contains("Geant4")) {
+    mSamplingFactorTransportModel = 1.;
+  }
+}
+
+//==============================================================================
 void Detector::createMaterials()
 {
-  int ifield = 2;      // ?
-  float fieldm = 10.0; // ?
+  LOGP(info, "Creating materials for ECL");
+
+  // Air
+  float aAir[4] = {12.0107, 14.0067, 15.9994, 39.948};
+  float zAir[4] = {6., 7., 8., 18.};
+  float wAir[4] = {0.000124, 0.755267, 0.231781, 0.012827};
+  float dAir = 1.20479E-3;
+  Mixture(0, "Air", aAir, zAir, dAir, 4, wAir);
+
+  // Pb
+  Material(1, "Pb", 207.2, 82, 11.35, 0.56, 0., nullptr, 0);
+
+  // Polysterene scintillator (CH)
+  float aP[2] = {12.011, 1.00794};
+  float zP[2] = {6.0, 1.0};
+  float wP[2] = {1.0, 1.0};
+  float dP = 1.032;
+  Mixture(2, "Scintillator", aP, zP, dP, -2, wP);
+
+  // Al
+  Material(3, "Al", 26.98, 13., 2.7, 8.9, 999., nullptr, 0);
+
+  // PWO crystals
+  float aX[3] = {207.19, 183.85, 16.0};
+  float zX[3] = {82.0, 74.0, 8.0};
+  float wX[3] = {1.0, 1.0, 4.0};
+  float dX = 8.28;
+  Mixture(4, "PbWO4", aX, zX, dX, -3, wX);
+
+  int ifield = 2;     // magnetic field flag
+  float fieldm = 10.; // maximum field value (in Kilogauss)
+  float deemax = 0.1; // maximum fractional energy loss in one step (0 < deemax <=1)
+  float tmaxfd = 10.; // maximum angle due to field permitted in one step (in degrees)
   o2::base::Detector::initFieldTrackingParams(ifield, fieldm);
-
-  float tmaxfdLead = 0.1;        // .10000E+01; // Degree
-  float stemaxLead = .10000E+01; // cm
-  float deemaxLead = 0.1;        // 0.30000E-02; // Fraction of particle's energy 0<deemax<=1
-  float epsilLead = 1.0E-4;      // .10000E+01;
-  float stminLead = 0.0;         // cm "Default value used"
-
-  // First approximation is a detector full of lead
-  // Lead
-  Detector::Material(1, "LEAD", 207.19, 82., 11.35, .56, 18.5);
-  Detector::Medium(1, "LEAD", 1, 0, ifield, fieldm, tmaxfdLead, stemaxLead, deemaxLead, epsilLead, stminLead);
+  Medium(0, "Air", 0, 0, ifield, fieldm, tmaxfd, 1.0, deemax, 0.1, 10.0, nullptr, 0);
+  Medium(1, "Pb", 1, 0, ifield, fieldm, tmaxfd, 0.1, deemax, 0.1, 0.1, nullptr, 0);
+  Medium(2, "Scintillator", 2, 1, ifield, fieldm, tmaxfd, 0.001, deemax, 0.001, 0.001, nullptr, 0);
+  Medium(3, "Al", 3, 0, ifield, fieldm, tmaxfd, 0.1, deemax, 0.001, 0.001, nullptr, 0);
+  Medium(4, "Crystal", 4, 1, ifield, fieldm, tmaxfd, 0.1, deemax, 0.1, 0.1, nullptr, 0);
 }
 
+//==============================================================================
 void Detector::InitializeO2Detector()
 {
   LOG(info) << "Initialize ECal O2Detector";
   mGeometryTGeo = GeometryTGeo::Instance();
-  // defineSensitiveVolumes();
 }
 
-void Detector::defineSensitiveVolumes()
+//==============================================================================
+void Detector::Reset()
 {
-  LOGP(info, "Adding ECal Sensitive Volumes");
+  if (!o2::utils::ShmManager::Instance().isOperational()) {
+    mHits->clear();
+  }
+  mSuperParentIndices.clear();
+  currentTrackId = -1;
+  superparentId = -1;
 }
 
-void Detector::EndOfEvent() { Reset(); }
-
+//==============================================================================
 void Detector::Register()
 {
   // This will create a branch in the output tree called Hit, setting the last
   // parameter to kFALSE means that this collection will not be written to the file,
   // it will exist only during the simulation
-
+  LOGP(info, "Registering hits");
   if (FairRootManager::Instance()) {
     FairRootManager::Instance()->RegisterAny(addNameTo("Hit").data(), mHits, true);
   }
 }
 
+//==============================================================================
 void Detector::createGeometry()
 {
   LOGP(info, "Creating ECal geometry");
 
-  TGeoManager* geoManager = gGeoManager;
-  TGeoVolume* vALIC = geoManager->GetVolume("barrel");
+  TGeoVolume* vALIC = gGeoManager->GetVolume("barrel");
   if (!vALIC) {
     LOGP(fatal, "Could not find barrel volume while constructing ECal geometry");
   }
   new TGeoVolumeAssembly(GeometryTGeo::getECalVolPattern());
-  TGeoVolume* vECal = geoManager->GetVolume(GeometryTGeo::getECalVolPattern());
+  TGeoVolume* vECal = gGeoManager->GetVolume(GeometryTGeo::getECalVolPattern());
   vALIC->AddNode(vECal, 2, new TGeoTranslation(0, 30., 0));
+  vECal->SetTitle("ECalVol");
+
+  TGeoMedium* medAir = gGeoManager->GetMedium("ECL_Air");
+  TGeoMedium* medPb = gGeoManager->GetMedium("ECL_Pb");
+  TGeoMedium* medAl = gGeoManager->GetMedium("ECL_Al");
+  TGeoMedium* medSc = gGeoManager->GetMedium("ECL_Scintillator");
+  TGeoMedium* medPWO = gGeoManager->GetMedium("ECL_Crystal");
+
+  // Get relevant parameters
+  auto& pars = ECalBaseParam::Instance();
+  auto& geo = Geometry::instance();
+
+  double rMin = pars.rMin;
+  double rMax = pars.rMax;
+  double layerThickness = pars.pbLayerThickness + pars.scLayerThickness;
+  double samplingModL = pars.frontPlateThickness + layerThickness * pars.nSamplingLayers - pars.pbLayerThickness;
+  double crystalAlpha = geo.getCrystalAlpha();
+  double samplingAlpha = geo.getSamplingAlpha();
+  double tanCrystalAlpha = std::tan(crystalAlpha);
+  double tanSamplingAlpha = std::tan(samplingAlpha);
+
+  double sectorL = rMax - rMin;
+  double crystalThetaMin = geo.getFrontFaceCenterTheta(pars.nCrystalModulesZ - 1) - crystalAlpha;
+  double crystalHlMin = geo.getFrontFaceZatMinR(pars.nCrystalModulesZ - 1);
+  double crystalHlMax = crystalHlMin + sectorL / std::tan(crystalThetaMin);
+  double crystalHwMin = geo.getCrystalModW() / 2.;
+  double crystalHwMax = crystalHwMin * rMax / rMin;
+  auto crystalSectorShape = new TGeoTrap(sectorL / 2., 0, 0, crystalHlMin, crystalHwMin, crystalHwMin, 0, crystalHlMax, crystalHwMax, crystalHwMax, 0);
+  auto crystalSectorVolume = new TGeoVolume("crystalSectorVolume", crystalSectorShape, medAir);
+  AddSensitiveVolume(crystalSectorVolume);
+  crystalSectorVolume->SetLineColor(kCyan + 1);
+  crystalSectorVolume->SetTransparency(0);
+
+  double samplingThetaAtMinZ = geo.getFrontFaceCenterTheta(pars.nCrystalModulesZ) + samplingAlpha;
+  double samplingThetaAtMaxZ = geo.getFrontFaceCenterTheta(pars.nCrystalModulesZ + pars.nSamplingModulesZ - 1) - samplingAlpha;
+  double samplingMinZatMinR = geo.getFrontFaceZatMinR(pars.nCrystalModulesZ) - geo.getSamplingModW() / std::sin(samplingThetaAtMinZ);
+  double samplingMaxZatMinR = geo.getFrontFaceZatMinR(pars.nCrystalModulesZ + pars.nSamplingModulesZ - 1);
+  double samplingMinZatMaxR = samplingMinZatMinR + sectorL / std::tan(samplingThetaAtMinZ);
+  double samplingMaxZatMaxR = samplingMaxZatMinR + sectorL / std::tan(samplingThetaAtMaxZ);
+  double hlMin = (samplingMaxZatMinR - samplingMinZatMinR) / 2.;
+  double hlMax = (samplingMaxZatMaxR - samplingMinZatMaxR) / 2.;
+  double zCenterMin = (samplingMaxZatMinR + samplingMinZatMinR) / 2.;
+  double zCenterMax = (samplingMaxZatMaxR + samplingMinZatMaxR) / 2.;
+  double zCenter = (zCenterMax + zCenterMin) / 2.;
+  double thetaCenter = std::atan((zCenterMax - zCenterMin) / sectorL) * TMath::RadToDeg();
+  double samplingHwMin = geo.getSamplingModW() / 2.;
+  double samplingHwMax = samplingHwMin * rMax / rMin;
+  auto samplingSectorShape = new TGeoTrap(sectorL / 2., thetaCenter, 90, hlMin, samplingHwMin, samplingHwMin, 0, hlMax, samplingHwMax, samplingHwMax, 0);
+  auto samplingSectorVolume = new TGeoVolume("samplingSectorVolume", samplingSectorShape, medAir);
+  AddSensitiveVolume(samplingSectorVolume);
+  samplingSectorVolume->SetLineColor(kBlue + 1);
+  samplingSectorVolume->SetTransparency(0);
+
+  double sectorR = rMin + sectorL / 2.;
+  for (int ism = 0; ism < pars.nSuperModules; ism++) {
+    // crystal
+    for (int i = 0; i < pars.nCrystalModulesPhi; i++) {
+      int row = ism * pars.nCrystalModulesPhi + i;
+      double phi0 = geo.getFrontFaceCenterCrystalPhi(row);
+      double x = sectorR * std::cos(phi0);
+      double y = sectorR * std::sin(phi0);
+      auto rot = new TGeoRotation(Form("ecalcrystalsecrot%d", row), 90 + phi0 * TMath::RadToDeg(), 90, 0);
+      vECal->AddNode(crystalSectorVolume, row, new TGeoCombiTrans(x, y, 0., rot));
+    }
+    // sampling
+    for (int i = 0; i < pars.nSamplingModulesPhi; i++) {
+      int row = ism * pars.nSamplingModulesPhi + i;
+      double phi0 = geo.getFrontFaceCenterSamplingPhi(row);
+      double x = sectorR * std::cos(phi0);
+      double y = sectorR * std::sin(phi0);
+      auto rot1 = new TGeoRotation(Form("ecalsamplingsec1rot%d", row), 90 + phi0 * TMath::RadToDeg(), 90, 0.);
+      auto rot2 = new TGeoRotation(Form("ecalsamplingsec2rot%d", row), 90 + phi0 * TMath::RadToDeg(), 90, 180);
+      vECal->AddNode(samplingSectorVolume, 2 * row + 0, new TGeoCombiTrans(x, y, zCenter, rot1));
+      vECal->AddNode(samplingSectorVolume, 2 * row + 1, new TGeoCombiTrans(x, y, -zCenter, rot2));
+    }
+  }
 
-  char vstrng[100] = "ECalVol";
-  vECal->SetTitle(vstrng);
+  for (int m = 0; m < pars.nCrystalModulesZ; m++) {
+    double tanBeta = geo.getTanBeta(m);
+    double dx1 = crystalHwMin;
+    double dx2 = crystalHwMin + pars.crystalModuleLength * tanCrystalAlpha;
+    double dy1 = crystalHwMin;
+    double dy2 = crystalHwMin + pars.crystalModuleLength * tanBeta;
+    double dz = pars.crystalModuleLength / 2.;
+    auto crystalModuleShape = new TGeoTrd2(dx1, dx2, dy1, dy2, dz);
+    auto crystalModuleVolume = new TGeoVolume(Form("crystalmodule%d", m), crystalModuleShape, medPWO);
+    AddSensitiveVolume(crystalModuleVolume);
+    crystalModuleVolume->SetLineColor(kCyan + 1);
+    crystalModuleVolume->SetTransparency(0);
+    double theta = geo.getFrontFaceCenterTheta(m);
+    double r = geo.getFrontFaceCenterR(m);
+    double z = geo.getFrontFaceCenterZ(m);
+    ROOT::Math::XYPoint pFrontFace(z, r - sectorR);
+    ROOT::Math::Polar2DVector vFrontFaceToCenter(dz, theta);
+    ROOT::Math::XYPoint pc = pFrontFace + vFrontFaceToCenter;
+    auto rot1 = new TGeoRotation(Form("ecalcrystalrot%d", 2 * m), 0, 270 + theta * TMath::RadToDeg(), 90);
+    crystalSectorVolume->AddNode(crystalModuleVolume, 2 * m, new TGeoCombiTrans(0, pc.x(), pc.y(), rot1));
+    auto rot2 = new TGeoRotation(Form("ecalcrystalrot%d", 2 * m + 1), 0, 90 - theta * TMath::RadToDeg(), 90);
+    crystalSectorVolume->AddNode(crystalModuleVolume, 2 * m + 1, new TGeoCombiTrans(0, -pc.x(), pc.y(), rot2));
+  }
 
-  // Build the ECal cylinder
-  auto& matmgr = o2::base::MaterialManager::Instance();
-  TGeoMedium* medPb = matmgr.getTGeoMedium("ECL_LEAD");
-  TGeoTube* ecalShape = new TGeoTube("ECLsh", mInnerRadius, mOuterRadius, mLength);
-  TGeoVolume* ecalVol = new TGeoVolume("ECL", ecalShape, medPb);
-  ecalVol->SetLineColor(kAzure - 9);
-  ecalVol->SetTransparency(0);
-  vECal->AddNode(ecalVol, 1, nullptr);
+  for (int m = 0; m < pars.nSamplingModulesZ; m++) {
+    int k = pars.nCrystalModulesZ + m;
+    double tanBeta = geo.getTanBeta(k);
+    double dx1 = samplingHwMin;
+    double dx2 = samplingHwMin + samplingModL * tanSamplingAlpha;
+    double dy1 = samplingHwMin;
+    double dy2 = samplingHwMin + samplingModL * tanBeta;
+    double dz = samplingModL / 2.;
+    auto samplingModuleShape = new TGeoTrd2(dx1, dx2, dy1, dy2, dz);
+    auto samplingModuleVolume = new TGeoVolume(Form("samplingmodule%d", m), samplingModuleShape, medSc);
+    AddSensitiveVolume(samplingModuleVolume);
+    samplingModuleVolume->SetLineColor(kAzure - 9);
+    samplingModuleVolume->SetTransparency(0);
+    double theta = geo.getFrontFaceCenterTheta(k);
+    double r = geo.getFrontFaceCenterR(k);
+    double z = geo.getFrontFaceCenterZ(k);
+    ROOT::Math::XYPoint pFrontFace(z - zCenter, r - sectorR);
+    ROOT::Math::Polar2DVector vFrontFaceToCenter(dz, theta);
+    ROOT::Math::XYPoint pc = pFrontFace + vFrontFaceToCenter;
+    auto rot1 = new TGeoRotation(Form("ecalsamplingrot%d", m), 0, 270 + theta * TMath::RadToDeg(), 90);
+    samplingSectorVolume->AddNode(samplingModuleVolume, m, new TGeoCombiTrans(0, pc.x(), pc.y(), rot1));
+
+    // adding front aluminium plate into the volume
+    double fdx1 = dx1;
+    double fdx2 = dx1 + pars.frontPlateThickness * tanSamplingAlpha;
+    double fdy1 = dy1;
+    double fdy2 = fdy1 + pars.frontPlateThickness * tanBeta;
+    double fdz = pars.frontPlateThickness / 2.;
+    auto frontShape = new TGeoTrd2(fdx1, fdx2, fdy1, fdy2, fdz);
+    auto frontVolume = new TGeoVolume(Form("front%d", m), frontShape, medAl);
+    samplingModuleVolume->AddNode(frontVolume, 0, new TGeoTranslation(0., 0., -dz + pars.frontPlateThickness / 2.));
+    AddSensitiveVolume(frontVolume);
+    frontVolume->SetLineColor(kAzure - 7);
+    frontVolume->SetTransparency(0);
+
+    // adding lead plates
+    for (int i = 0; i < pars.nSamplingLayers - 1; i++) {
+      double lz1 = pars.frontPlateThickness + pars.scLayerThickness + layerThickness * i;
+      double lz2 = lz1 + pars.pbLayerThickness;
+      double lzc = -dz + (lz1 + lz2) / 2.;
+      double ldx1 = dx1 + lz1 * tanSamplingAlpha;
+      double ldx2 = dx1 + lz2 * tanSamplingAlpha;
+      double ldy1 = dy1 + lz1 * tanBeta;
+      double ldy2 = dy1 + lz2 * tanBeta;
+      double ldz = pars.pbLayerThickness / 2.;
+      auto leadShape = new TGeoTrd2(ldx1, ldx2, ldy1, ldy2, ldz);
+      auto leadVolume = new TGeoVolume(Form("lead%d_%d", m, i), leadShape, medPb);
+      samplingModuleVolume->AddNode(leadVolume, i, new TGeoTranslation(0., 0., lzc));
+      AddSensitiveVolume(leadVolume);
+      leadVolume->SetLineColor(kAzure - 7);
+      leadVolume->SetTransparency(0);
+    }
+  }
 
-  if (mEnableEndcap) {
+  if (pars.enableFwdEndcap) {
     // Build the ecal endcap
-    TGeoTube* ecalEndcapShape = new TGeoTube("ECLECsh", 15.f, 160.f, 0.5 * (mOuterRadius - mInnerRadius));
+    TGeoTube* ecalEndcapShape = new TGeoTube("ECLECsh", 15.f, 160.f, 0.5 * (rMax - rMin));
     TGeoVolume* ecalEndcapVol = new TGeoVolume("ECLEC", ecalEndcapShape, medPb);
     ecalEndcapVol->SetLineColor(kAzure - 9);
     ecalEndcapVol->SetTransparency(0);
     vECal->AddNode(ecalEndcapVol, 1, new TGeoTranslation(0, 0, -450.f));
   }
+  // gGeoManager->CloseGeometry();
+  // gGeoManager->CheckOverlaps(0.0001);
 }
 
-void Detector::Reset()
-{
-  if (!o2::utils::ShmManager::Instance().isOperational()) {
-    mHits->clear();
-  }
-}
-
+//==============================================================================
 bool Detector::ProcessHits(FairVolume* vol)
 {
-  // This method is called from the MC stepping
-  if (!(fMC->TrackCharge())) {
-    return false;
-  }
-
-  int lay = vol->getVolumeId();
-  int volID = vol->getMCid();
-
-  // Is it needed to keep a track reference when the outer ITS volume is encountered?
+  LOGP(debug, "Processing hits");
   auto stack = (o2::data::Stack*)fMC->GetStack();
-  if (fMC->IsTrackExiting() && (lay == 0)) {
-    o2::TrackReference tr(*fMC, GetDetId());
-    tr.setTrackID(stack->GetCurrentTrackNumber());
-    tr.setUserId(lay);
-    stack->addTrackReference(tr);
-  }
-  bool startHit = false, stopHit = false;
-  unsigned char status = 0;
-  if (fMC->IsTrackEntering()) {
-    status |= Hit::kTrackEntering;
-  }
-  if (fMC->IsTrackInside()) {
-    status |= Hit::kTrackInside;
-  }
-  if (fMC->IsTrackExiting()) {
-    status |= Hit::kTrackExiting;
-  }
-  if (fMC->IsTrackOut()) {
-    status |= Hit::kTrackOut;
-  }
-  if (fMC->IsTrackStop()) {
-    status |= Hit::kTrackStopped;
-  }
-  if (fMC->IsTrackAlive()) {
-    status |= Hit::kTrackAlive;
+  int trackId = stack->GetCurrentTrackNumber();
+  int parentId = stack->GetCurrentParentTrackNumber();
+
+  if (trackId != currentTrackId) {
+    auto superparentIndexIt = mSuperParentIndices.find(parentId);
+    if (superparentIndexIt != mSuperParentIndices.end()) {
+      superparentId = superparentIndexIt->second;
+      mSuperParentIndices[trackId] = superparentIndexIt->second;
+    } else {
+      // for new incoming tracks the superparent index is equal to the track ID (for recursion)
+      mSuperParentIndices[trackId] = trackId;
+      superparentId = trackId;
+    }
+    currentTrackId = trackId;
   }
 
-  // track is entering or created in the volume
-  if ((status & Hit::kTrackEntering) || (status & Hit::kTrackInside && !mTrackData.mHitStarted)) {
-    startHit = true;
-  } else if ((status & (Hit::kTrackExiting | Hit::kTrackOut | Hit::kTrackStopped))) {
-    stopHit = true;
+  double eloss = fMC->Edep();
+  if (eloss < DBL_EPSILON) {
+    return false;
   }
 
-  // increment energy loss at all steps except entrance
-  if (!startHit) {
-    mTrackData.mEnergyLoss += fMC->Edep();
-  }
-  if (!(startHit | stopHit)) {
-    return false; // do noting
+  TString volName = vol->GetName();
+  bool isCrystal = volName.Contains("crystalmodule");
+  bool isSampling = volName.Contains("samplingmodule");
+
+  if (!isCrystal && !isSampling) {
+    return false;
   }
 
-  if (startHit) {
-    mTrackData.mEnergyLoss = 0.;
-    fMC->TrackMomentum(mTrackData.mMomentumStart);
-    fMC->TrackPosition(mTrackData.mPositionStart);
-    mTrackData.mTrkStatusStart = status;
-    mTrackData.mHitStarted = true;
+  if (isCrystal)
+    LOGP(debug, "Processing crystal {}", volName.Data());
+  else {
+    eloss *= mSamplingFactorTransportModel;
+    LOGP(debug, "Processing scintillator {}", volName.Data());
   }
-  if (stopHit) {
-    TLorentzVector positionStop;
-    fMC->TrackPosition(positionStop);
-    // Retrieve the indices with the volume path
-    int stave(0), halfstave(0), chipinmodule(0), module;
-    fMC->CurrentVolOffID(1, chipinmodule);
-    fMC->CurrentVolOffID(2, module);
-    fMC->CurrentVolOffID(3, halfstave);
-    fMC->CurrentVolOffID(4, stave);
-
-    Hit* p = addHit(stack->GetCurrentTrackNumber(), lay, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
-                    mTrackData.mMomentumStart.Vect(), mTrackData.mMomentumStart.E(), positionStop.T(),
-                    mTrackData.mEnergyLoss, mTrackData.mTrkStatusStart, status);
-    // p->SetTotalEnergy(vmc->Etot());
-
-    // RS: not sure this is needed
-    // Increment number of Detector det points in TParticle
+  int sectorId, moduleId;
+  fMC->CurrentVolID(moduleId);
+  fMC->CurrentVolOffID(1, sectorId);
+  int cellID = Geometry::instance().getCellID(moduleId, sectorId, isCrystal);
+  LOGP(debug, "isCrystal={} sectorId={} moduleId={} cellID={} eloss={}", isCrystal, sectorId, moduleId, cellID, eloss);
+
+  int trackID = superparentId;
+  auto hit = std::find_if(mHits->begin(), mHits->end(), [cellID, trackID](const Hit& hit) { return hit.GetTrackID() == trackID && hit.GetCellID() == cellID; });
+  if (hit == mHits->end()) {
+    float posX, posY, posZ, momX, momY, momZ, energy;
+    fMC->TrackPosition(posX, posY, posZ);
+    fMC->TrackMomentum(momX, momY, momZ, energy);
+    auto pos = math_utils::Point3D<float>(posX, posY, posZ);
+    auto mom = math_utils::Vector3D<float>(momX, momY, momZ);
+    float time = fMC->TrackTime() * 1e9; // time in ns
+    mHits->emplace_back(trackID, cellID, pos, mom, time, eloss);
     stack->addHit(GetDetId());
+  } else {
+    hit->SetEnergyLoss(hit->GetEnergyLoss() + eloss);
   }
-
   return true;
 }
 
-o2::itsmft::Hit* Detector::addHit(int trackID, int detID, const TVector3& startPos, const TVector3& endPos,
-                                  const TVector3& startMom, double startE, double endTime, double eLoss, unsigned char startStatus,
-                                  unsigned char endStatus)
-{
-  mHits->emplace_back(trackID, detID, startPos, endPos, startMom, startE, endTime, eLoss, startStatus, endStatus);
-  return &(mHits->back());
-}
-
 } // namespace ecal
 } // namespace o2
 
-ClassImp(o2::ecal::Detector);
\ No newline at end of file
+ClassImp(o2::ecal::Detector);
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/ECal/simulation/src/Digitizer.cxx
new file mode 100644
index 0000000000000..f213ba563d86d
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/src/Digitizer.cxx
@@ -0,0 +1,89 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Digitizer.cxx
+/// \brief Digitization of ECal MC information
+///
+/// \author Evgeny Kryshen <evgeny.kryshen@cern.ch>
+
+#include <cstdio>
+#include <TRandom.h>
+#include <fairlogger/Logger.h>
+
+#include <ECalSimulation/Digitizer.h>
+#include <ECalBase/Hit.h>
+#include <ECalBase/Geometry.h>
+#include <DataFormatsECal/Digit.h>
+
+using namespace o2::ecal;
+
+//==============================================================================
+Digitizer::Digitizer()
+{
+  auto& geo = Geometry::instance();
+  mArrayD.resize(geo.getNrows() * geo.getNcols());
+}
+
+//==============================================================================
+void Digitizer::processHits(const std::vector<Hit>* hits, std::vector<Digit>& digits, o2::dataformats::MCTruthContainer<MCLabel>& labels, int collId)
+{
+  digits.clear();
+  labels.clear();
+
+  LOGP(debug, "nHits = {}", hits->size());
+  auto& geo = Geometry::instance();
+
+  for (int i = 0; i < mArrayD.size(); i++) {
+    mArrayD[i].setAmplitude(0);
+    mArrayD[i].setTimeStamp(1000);
+    mArrayD[i].setTower(i);
+    mArrayD[i].setLabel(-1);
+    // TODO: simulate noise
+  }
+
+  for (auto& hit : *hits) {
+    int cellID = hit.GetCellID();
+    double eloss = hit.GetEnergyLoss();
+    double t = hit.GetTime();
+    double elossSmeared = eloss;
+    bool isCrystal = geo.isCrystal(cellID);
+    if (isCrystal) { // crystal
+      double elossSmearedNpe = gRandom->Poisson(eloss * mCrystalPePerGeV) / mCrystalPePerGeV;
+      if (mSmearCrystal)
+        elossSmeared = elossSmearedNpe * gRandom->Gaus(1, 0.007); // light attenuation in crystals
+    } else {                                                      // sampling
+      elossSmeared *= mSamplingFraction;
+    }
+
+    Digit& digit = mArrayD[cellID];
+    digit.setAmplitude(digit.getAmplitude() + elossSmeared);
+    if (t < digit.getTimeStamp())
+      digit.setTimeStamp(t); // setting earliest time, TODO: add time smearing
+    LOGF(debug, "  crystal: %d cellID = %5d, eloss = %8.5f elossSmeared = %8.5f time = %8.5f", isCrystal, cellID, eloss, elossSmeared, t);
+
+    // Adding MC info
+    MCLabel label(hit.GetTrackID(), collId, 0, false, hit.GetEnergyLoss());
+    int labelIndex = digit.getLabel();
+    if (labelIndex == -1) {
+      labelIndex = labels.getIndexedSize();
+      labels.addElement(labelIndex, label);
+      digit.setLabel(labelIndex);
+    } else {
+      labels.addElementRandomAccess(labelIndex, label);
+    }
+  } // hits
+
+  for (int i = 0; i < mArrayD.size(); i++) {
+    if (mArrayD[i].getAmplitude() > mThreshold) {
+      digits.push_back(mArrayD[i]);
+    }
+  }
+}
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/src/ECalSimulationLinkDef.h b/Detectors/Upgrades/ALICE3/ECal/simulation/src/ECalSimulationLinkDef.h
index 167342773f196..5d7383f086362 100644
--- a/Detectors/Upgrades/ALICE3/ECal/simulation/src/ECalSimulationLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/src/ECalSimulationLinkDef.h
@@ -17,5 +17,6 @@
 
 #pragma link C++ class o2::ecal::Detector + ;
 #pragma link C++ class o2::base::DetImpl < o2::ecal::Detector> + ;
+#pragma link C++ class o2::ecal::Digitizer + ;
 
 #endif

From 10dd8dc225a9d2d7422389bbb79de069afa20c1a Mon Sep 17 00:00:00 2001
From: Nicolas Elliot Poffley <nicolas.poffley@gmail.com>
Date: Sat, 27 Sep 2025 07:52:31 +0200
Subject: [PATCH 0872/1764] DPL Websocket: Add protocol param to
 encode_websocket_handshake_reply which allows a response Sec-WebSocket-Accept
 in handshake. (#14687)

DPL Websocket: Add overloaded encode_websocket_handshake_reply which allows a response Sec-WebSocket-Accept in handshake.
---
 Framework/Core/src/DPLWebSocket.cxx | 2 +-
 Framework/Core/src/HTTPParser.cxx   | 5 +++--
 Framework/Core/src/HTTPParser.h     | 3 ++-
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/DPLWebSocket.cxx b/Framework/Core/src/DPLWebSocket.cxx
index a39e98c6f5310..d9b6594d5f07c 100644
--- a/Framework/Core/src/DPLWebSocket.cxx
+++ b/Framework/Core/src/DPLWebSocket.cxx
@@ -276,7 +276,7 @@ void WSDPLHandler::endHeaders()
   }
   /// Create an appropriate reply
   LOG(debug) << "Got upgrade request with nonce " << mHeaders["sec-websocket-key"].c_str();
-  std::string reply = encode_websocket_handshake_reply(mHeaders["sec-websocket-key"].c_str());
+  std::string reply = encode_websocket_handshake_reply(mHeaders["sec-websocket-key"].c_str(), "dpl");
   mHandshaken = true;
 
   uv_buf_t bfr = uv_buf_init(strdup(reply.data()), reply.size());
diff --git a/Framework/Core/src/HTTPParser.cxx b/Framework/Core/src/HTTPParser.cxx
index 04ca6e8fdce55..fa2ba91722eb0 100644
--- a/Framework/Core/src/HTTPParser.cxx
+++ b/Framework/Core/src/HTTPParser.cxx
@@ -214,15 +214,16 @@ std::string HTTPParserHelpers::calculateAccept(const char* nonce)
   return fmt::format("{}", base);
 }
 
-std::string encode_websocket_handshake_reply(char const* nonce)
+std::string encode_websocket_handshake_reply(char const* nonce, const char* protocol)
 {
   constexpr auto res =
     "HTTP/1.1 101 Switching Protocols\r\n"
     "Upgrade: websocket\r\n"
     "Connection: Upgrade\r\n"
     "Access-Control-Allow-Origin: \"*\"\r\n"
+    "{}"
     "Sec-WebSocket-Accept: {}\r\n\r\n";
-  return fmt::format(res, HTTPParserHelpers::calculateAccept(nonce));
+  return fmt::format(res, protocol && protocol[0] ? fmt::format("Sec-WebSocket-Protocol: {}\r\n", protocol) : "", HTTPParserHelpers::calculateAccept(nonce));
 }
 
 void parse_http_request(char* start, size_t size, HTTPParser* parser)
diff --git a/Framework/Core/src/HTTPParser.h b/Framework/Core/src/HTTPParser.h
index b4d92393ca5c9..a3253c7ca3d39 100644
--- a/Framework/Core/src/HTTPParser.h
+++ b/Framework/Core/src/HTTPParser.h
@@ -125,7 +125,8 @@ std::string encode_websocket_handshake_request(const char* path, const char* pro
 
 /// Encodes the server reply for a given websocket connection
 /// @a nonce the nonce of the request.
-std::string encode_websocket_handshake_reply(char const* nonce);
+/// @a protocol the websocket subprotocol to confirm (optional)
+std::string encode_websocket_handshake_reply(char const* nonce, char const* protocol = "");
 
 /// Encodes the buffer @a src which is @a size long to a number of buffers suitable to be sent via libuv.
 /// If @a binary is provided the binary bit is set.

From 8ce25b7607da339351a9724ede6d0d1fbc0ffaa7 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 25 Sep 2025 23:25:54 +0400
Subject: [PATCH 0873/1764] Methods for layer-dependend mat.LUT rescaling

See the macro O2/Detectors/Base/test/rescaleLUT.C as an example, which writes a rescaled LUT to the <original_name>_rescaled.root file.
The rescaling parameters are provided as a set of RescRange structs: radial range + scaling coefficient.
It uses a method o2::base::MatLayerCylSet::scaleLayersByR(rmin,rmax, factor, bool scaleX2X0=true, bool scaleRho=true).
All LUT layers overlapping with rmin:rmax range will be rescaled. Alternatively, one can use directly the method o2::base::MatLayerCylSet::scaleLayersByID(lrIDmin,lrIDmax, factor, bool scaleX2X0=true, bool scaleRho=true)
to scale a set of layers [lrIDmin:lrIDmax].
---
 Detectors/Base/CMakeLists.txt                 |  5 ++
 .../Base/include/DetectorsBase/MatLayerCyl.h  |  4 +-
 .../include/DetectorsBase/MatLayerCylSet.h    |  4 +
 Detectors/Base/src/MatLayerCyl.cxx            | 15 ++++
 Detectors/Base/src/MatLayerCylSet.cxx         | 27 ++++++
 Detectors/Base/test/rescaleLUT.C              | 82 +++++++++++++++++++
 6 files changed, 136 insertions(+), 1 deletion(-)
 create mode 100644 Detectors/Base/test/rescaleLUT.C

diff --git a/Detectors/Base/CMakeLists.txt b/Detectors/Base/CMakeLists.txt
index 0ba2905ab02ec..3f8b2f5343fd4 100644
--- a/Detectors/Base/CMakeLists.txt
+++ b/Detectors/Base/CMakeLists.txt
@@ -87,6 +87,7 @@ endif()
 
 install(FILES test/buildMatBudLUT.C
               test/extractLUTLayers.C
+              test/rescaleLUT.C
               DESTINATION share/macro/)
 
 o2_add_test_root_macro(test/buildMatBudLUT.C
@@ -96,3 +97,7 @@ o2_add_test_root_macro(test/buildMatBudLUT.C
 o2_add_test_root_macro(test/extractLUTLayers.C
                        PUBLIC_LINK_LIBRARIES O2::DetectorsBase
                        LABELS detectorsbase)
+
+o2_add_test_root_macro(test/rescaleLUT.C
+                       PUBLIC_LINK_LIBRARIES O2::DetectorsBase
+                       LABELS detectorsbase)
diff --git a/Detectors/Base/include/DetectorsBase/MatLayerCyl.h b/Detectors/Base/include/DetectorsBase/MatLayerCyl.h
index ca015fa457a1a..e63de51e0a6ca 100644
--- a/Detectors/Base/include/DetectorsBase/MatLayerCyl.h
+++ b/Detectors/Base/include/DetectorsBase/MatLayerCyl.h
@@ -93,10 +93,12 @@ class MatLayerCyl : public o2::gpu::FlatObject
   GPUd() const MatCell& getCell(int iphiSlice, int iz) const { return mCells[getCellID(iphiSlice, iz)]; }
 
 #ifndef GPUCA_ALIGPUCODE // this part is unvisible on GPU version
-  GPUd() MatCell& getCellPhiBin(int iphi, int iz)
+  MatCell& getCellPhiBin(int iphi, int iz)
   {
     return mCells[getCellIDPhiBin(iphi, iz)];
   }
+
+  void scale(float factor, bool _x2x0 = true, bool _rho = true);
 #endif
 
   // ---------------------- Z slice manipulation
diff --git a/Detectors/Base/include/DetectorsBase/MatLayerCylSet.h b/Detectors/Base/include/DetectorsBase/MatLayerCylSet.h
index c74ce365d378f..0a53ab00b16f2 100644
--- a/Detectors/Base/include/DetectorsBase/MatLayerCylSet.h
+++ b/Detectors/Base/include/DetectorsBase/MatLayerCylSet.h
@@ -98,6 +98,10 @@ class MatLayerCylSet : public o2::gpu::FlatObject
     // get material budget traversed on the line between point0 and point1
     return getMatBudget(point0.X(), point0.Y(), point0.Z(), point1.X(), point1.Y(), point1.Z());
   }
+
+  void scaleLayersByID(int lrFrom, int lrTo, float factor, bool _x2x0 = true, bool _rho = true);
+  void scaleLayersByR(float rFrom, float rTo, float factor, bool _x2x0 = true, bool _rho = true);
+
 #endif // !GPUCA_ALIGPUCODE
   GPUd() MatBudget getMatBudget(float x0, float y0, float z0, float x1, float y1, float z1) const;
 
diff --git a/Detectors/Base/src/MatLayerCyl.cxx b/Detectors/Base/src/MatLayerCyl.cxx
index 2346946ea6a8a..29bed111b3584 100644
--- a/Detectors/Base/src/MatLayerCyl.cxx
+++ b/Detectors/Base/src/MatLayerCyl.cxx
@@ -319,9 +319,24 @@ void MatLayerCyl::flatten(char* newPtr)
   mConstructionMask = Constructed;
 }
 
+//________________________________________________________________________________
+void MatLayerCyl::scale(float factor, bool _x2x0, bool _rho)
+{
+  LOGP(info, "Scaling layer {:.3f}<r<{:.3f} by {:.3f}", getRMin(), getRMax(), factor);
+  for (int i = 0; i < mNPhiSlices * mNZBins; i++) {
+    if (_x2x0) {
+      mCells[i].meanX2X0 *= factor;
+    }
+    if (_rho) {
+      mCells[i].meanRho *= factor;
+    }
+  }
+}
+
 #endif // ! GPUCA_ALIGPUCODE
 
 #ifndef GPUCA_GPUCODE
+
 //________________________________________________________________________________
 void MatLayerCyl::fixPointers(char* oldPtr, char* newPtr)
 {
diff --git a/Detectors/Base/src/MatLayerCylSet.cxx b/Detectors/Base/src/MatLayerCylSet.cxx
index 12156fc55b381..c287723839d22 100644
--- a/Detectors/Base/src/MatLayerCylSet.cxx
+++ b/Detectors/Base/src/MatLayerCylSet.cxx
@@ -256,6 +256,33 @@ void MatLayerCylSet::print(bool data) const
          float(getFlatBufferSize()) / 1024 / 1024);
 }
 
+//________________________________________________________________________________
+void MatLayerCylSet::scaleLayersByID(int lrFrom, int lrTo, float factor, bool _x2x0, bool _rho)
+{
+  lrFrom = std::max(0, std::min(lrFrom, get()->mNLayers - 1));
+  lrTo = std::max(0, std::min(lrTo, get()->mNLayers - 1));
+  int dir = lrFrom >= lrTo ? -1 : 1;
+  lrTo += dir;
+  for (int i = lrFrom; i != lrTo; i += dir) {
+    get()->mLayers[i].scale(factor, _x2x0, _rho);
+  }
+}
+
+//________________________________________________________________________________
+void MatLayerCylSet::scaleLayersByR(float rFrom, float rTo, float factor, bool _x2x0, bool _rho)
+{
+  if (rFrom > rTo) {
+    std::swap(rFrom, rTo);
+  }
+  Ray ray(std::max(getRMin(), rFrom), 0., 0., std::min(getRMax(), rTo), 0., 0.);
+  short lmin, lmax;
+  if (!getLayersRange(ray, lmin, lmax)) {
+    LOGP(warn, "No layers found for {} < r < {}", rFrom, rTo);
+    return;
+  }
+  scaleLayersByID(lmin, lmax, factor, _x2x0, _rho);
+}
+
 #endif //!GPUCA_ALIGPUCODE
 
 #ifndef GPUCA_GPUCODE
diff --git a/Detectors/Base/test/rescaleLUT.C b/Detectors/Base/test/rescaleLUT.C
new file mode 100644
index 0000000000000..9e25c796e43d1
--- /dev/null
+++ b/Detectors/Base/test/rescaleLUT.C
@@ -0,0 +1,82 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include "DetectorsBase/MatLayerCylSet.h"
+#include "Framework/Logger.h"
+#include "CCDB/BasicCCDBManager.h"
+#include <regex>
+#endif
+
+// Macro to extract layers covering selected radial range into the separate LUT file.
+
+void rescaleLUT(o2::base::MatLayerCylSet* src, const std::string& outName)
+{
+  struct RescRange {
+    float rMin, rMax, factor;
+  };
+  std::vector<RescRange> task = {
+    // put here radial ranges in increasing order with corresponding factors to rescale
+    {0.1f, 6.f, 1.05},  // e.g. rescale layers covering 0.1<r<6 by factor 1.05
+    {30.f, 40.f, 1.15}, // e.g. rescale layers covering 30.f<r<40.f by factor 1.15
+  };
+
+  // check if there are no overlaps in ranges, to avoid double rescaling
+  for (size_t il = 1; il < task.size(); il++) {
+    short lmax, lmin;
+    float rmin = task[il - 1].rMax, rmax = task[il].rMin;
+    if (rmin > rmax) {
+      LOGP(error, "rMax={:.2f} of range {} is larger then rMin={:.2f} of range {}, must be in increasing order", rmin, il - 1, rmax, il);
+      return;
+    }
+    o2::base::Ray ray(std::max(src->getRMin(), rmin), 0., 0., std::min(src->getRMax(), rmax), 0., 0.);
+    if (!src->getLayersRange(ray, lmin, lmax)) {
+      LOGP(error, "No layers found for {:.2f} < r < {:.2f}", rmin, rmax);
+      return;
+    }
+    if (lmin == lmax) {
+      LOGP(error, "rMax={:.2f} of range {} and rMin={:.2f} of range {}, correspond to the same slice {} with {:.2f}<r<{:.2f}",
+           rmin, il - 1, rmax, il, lmin, src->getLayer(lmin).getRMin(), src->getLayer(lmin).getRMax());
+      return;
+    }
+  }
+
+  for (size_t il = 0; il < task.size(); il++) {
+    src->scaleLayersByR(task[il].rMin, task[il].rMax, task[il].factor);
+  }
+  if (outName.size()) {
+    src->writeToFile(outName);
+  }
+}
+
+void rescaleLUT(const std::string& fname)
+{
+  auto src = o2::base::MatLayerCylSet::loadFromFile(fname);
+  if (!src) {
+    LOGP(error, "failed to open source LUT from {}", fname);
+    return;
+  }
+  auto fnameOut = std::regex_replace(fname, std::regex(R"(.root)"), "_rescaled.root");
+  rescaleLUT(src, fnameOut);
+}
+
+void rescaleLUT(long timestamp = -1)
+{
+  auto& mg = o2::ccdb::BasicCCDBManager::instance();
+  mg.setTimestamp(timestamp);
+  auto src = o2::base::MatLayerCylSet::rectifyPtrFromFile(mg.get<o2::base::MatLayerCylSet>("GLO/Param/MatLUT"));
+  if (!src) {
+    LOGP(error, "failed to open load LUT from CCDB for timestamp {}", timestamp);
+    return;
+  }
+  auto fnameOut = fmt::format("matbudLUT_ts{}_rescaled.root", timestamp);
+  rescaleLUT(src, fnameOut);
+}

From 5d6b7b53406229c5bf348d992c32696b37e1e475 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 27 Sep 2025 16:45:20 +0200
Subject: [PATCH 0874/1764] DPL: Make RawParser errorMode settable

---
 Framework/Utils/include/DPLUtils/DPLRawParser.h | 1 +
 Framework/Utils/include/DPLUtils/RawParser.h    | 5 +++++
 2 files changed, 6 insertions(+)

diff --git a/Framework/Utils/include/DPLUtils/DPLRawParser.h b/Framework/Utils/include/DPLUtils/DPLRawParser.h
index e1732ef70550a..5fa0775025deb 100644
--- a/Framework/Utils/include/DPLUtils/DPLRawParser.h
+++ b/Framework/Utils/include/DPLUtils/DPLRawParser.h
@@ -76,6 +76,7 @@ class DPLRawParser
   void setMaxFailureMessages(size_t n) { mMaxFailureMessages = n; }
   void setExtFailureCounter(size_t* cnt) { mExtFailureCounter = cnt; }
   static void setCheckIncompleteHBF(bool v) { rawparser_type::setCheckIncompleteHBF(v); }
+  static void setErrorMode(int v) { rawparser_type::setErrorMode(v); }
 
   // this is a dummy default buffer used to initialize the RawParser in the iterator
   // constructor
diff --git a/Framework/Utils/include/DPLUtils/RawParser.h b/Framework/Utils/include/DPLUtils/RawParser.h
index c1ba1ef4802b2..fa45cf79b7568 100644
--- a/Framework/Utils/include/DPLUtils/RawParser.h
+++ b/Framework/Utils/include/DPLUtils/RawParser.h
@@ -649,6 +649,11 @@ class RawParser
     raw_parser::RawParserHelper::sCheckIncompleteHBF = v;
   }
 
+  static void setErrorMode(int v)
+  {
+    raw_parser::RawParserHelper::sErrorMode = v;
+  }
+
  private:
   raw_parser::ConcreteParserVariants<MAX_SIZE, BOUNDS_CHECKS> mParser;
 };

From 1c52969c500edee17774d9af8190ba9b2d6f5147 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 28 Sep 2025 14:35:41 +0200
Subject: [PATCH 0875/1764] Custom streamer for std::vector<o2::tpc::PadFlags>

* Add support for EXTRA_PATCH in root dictionary generation
---
 DataFormats/Detectors/TPC/CMakeLists.txt      |  1 +
 .../Detectors/TPC/src/DataFormatsTPCLinkDef.h |  2 +
 .../TPC/src/VectorPadflagsCustomStreamer.cxx  | 56 +++++++++++++++++++
 cmake/AddRootDictionary.cmake                 |  9 ++-
 cmake/O2TargetRootDictionary.cmake            | 16 +++---
 cmake/rootcling_wrapper.sh.in                 | 23 ++++++++
 6 files changed, 97 insertions(+), 10 deletions(-)
 create mode 100644 DataFormats/Detectors/TPC/src/VectorPadflagsCustomStreamer.cxx

diff --git a/DataFormats/Detectors/TPC/CMakeLists.txt b/DataFormats/Detectors/TPC/CMakeLists.txt
index 2cc69e16001a6..5aed01a9772c1 100644
--- a/DataFormats/Detectors/TPC/CMakeLists.txt
+++ b/DataFormats/Detectors/TPC/CMakeLists.txt
@@ -40,6 +40,7 @@ o2_add_library(
 
 o2_target_root_dictionary(
   DataFormatsTPC
+  EXTRA_PATCH src/VectorPadflagsCustomStreamer.cxx
   HEADERS include/DataFormatsTPC/ClusterGroupAttribute.h
           include/DataFormatsTPC/ClusterNative.h
           include/DataFormatsTPC/ClusterNativeHelper.h
diff --git a/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h b/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
index fd5abca99cb0f..8659e6a2e43eb 100644
--- a/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
+++ b/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
@@ -22,6 +22,7 @@
 #pragma link C++ class o2::tpc::ClusterHardwareContainerFixedSize < 8192> + ;
 #pragma link C++ class o2::tpc::ClusterNativeContainer + ;
 #pragma link C++ class o2::tpc::Digit + ;
+// pragma link C++ enum o2::tpc::PadFlags +;                // enum itself
 #pragma link C++ class o2::tpc::ZeroSuppressedContainer8kb + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterNative> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterNativeContainer> + ;
@@ -29,6 +30,7 @@
 #pragma link C++ class std::vector < o2::tpc::ClusterHardwareContainerFixedSize < 8192>> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterHardwareContainer8kb> + ;
 #pragma link C++ class std::vector < o2::tpc::Digit> + ;
+// pragma link C++ class std::vector < o2::tpc::PadFlags> + ;
 #pragma link C++ class std::vector < o2::tpc::ZeroSuppressedContainer8kb> + ;
 #pragma link C++ class o2::tpc::TrackTPC + ;
 #pragma link C++ class o2::tpc::LaserTrack + ;
diff --git a/DataFormats/Detectors/TPC/src/VectorPadflagsCustomStreamer.cxx b/DataFormats/Detectors/TPC/src/VectorPadflagsCustomStreamer.cxx
new file mode 100644
index 0000000000000..f7cb9285b8884
--- /dev/null
+++ b/DataFormats/Detectors/TPC/src/VectorPadflagsCustomStreamer.cxx
@@ -0,0 +1,56 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+using std::vector;
+
+void VectorPadFlagsStreamer(TBuffer& R__b, void* objp)
+{
+  std::vector<o2::tpc::PadFlags>* obj = static_cast<std::vector<o2::tpc::PadFlags>*>(objp);
+  if (R__b.IsReading()) {
+    std::vector<int> R__stl;
+    R__stl.clear();
+    int R__n;
+    R__b >> R__n;
+    R__stl.reserve(R__n);
+    for (int R__i = 0; R__i < R__n; R__i++) {
+      Int_t readtemp;
+      R__b >> readtemp;
+      R__stl.push_back(readtemp);
+    }
+    auto data = reinterpret_cast<unsigned short*>(R__stl.data());
+    for (int i = 0; i < R__n; ++i) {
+      obj->push_back(static_cast<o2::tpc::PadFlags>(data[i]));
+    }
+  } else {
+    // We always save things with the old format.
+    R__b << (int)obj->size() / 2;
+    for (size_t i = 0; i < obj->size(); i++) {
+      R__b << (short)obj->at(i);
+    }
+  }
+}
+
+#define RootStreamerLocal(name, STREAMER)     \
+  namespace ROOT                              \
+  {                                           \
+                                              \
+  /** \cond HIDDEN_SYMBOLS */                 \
+  static auto _R__UNIQUE_(R__dummyStreamer) = \
+    []() { TClass::GetClass<name>()->SetStreamerFunc(STREAMER); return 0; }();                               \
+  /** \endcond */                             \
+  R__UseDummy(_R__UNIQUE_(R__dummyStreamer)); \
+  }
+
+// Let's not try to fix the old ROOT version, so that we can build
+// the new ROOT with the patched code in the CI.
+#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 33, 00)
+RootStreamerLocal(vector<o2::tpc::PadFlags>, VectorPadFlagsStreamer);
+#endif
diff --git a/cmake/AddRootDictionary.cmake b/cmake/AddRootDictionary.cmake
index 0dd68a352d1ce..17fdd2bd286c0 100644
--- a/cmake/AddRootDictionary.cmake
+++ b/cmake/AddRootDictionary.cmake
@@ -51,7 +51,7 @@ function(add_root_dictionary target)
                         1
                         A
                         ""
-                        "LINKDEF"
+                        "LINKDEF;EXTRA_PATCH"
                         "HEADERS;BASENAME")
   if(A_UNPARSED_ARGUMENTS)
     message(
@@ -112,7 +112,7 @@ function(add_root_dictionary target)
   set(pcmBase ${dictionary}_rdict.pcm)
   set(pcmFile ${lib_output_dir}/${pcmBase})
   set(rootmapFile ${lib_output_dir}/lib${basename}.rootmap)
-  
+
   set(O2_TARGETPCMMAP_TARGET "${O2_TARGETPCMMAP_TARGET};${target}" CACHE INTERNAL "target/PCM map (target)")
   set(O2_TARGETPCMMAP_PCM "${O2_TARGETPCMMAP_PCM};${pcmFile}" CACHE INTERNAL "target/PCM map (pcm)")
 
@@ -132,6 +132,7 @@ function(add_root_dictionary target)
   set(includeDirs $<TARGET_PROPERTY:${target},INCLUDE_DIRECTORIES>)
   set(includeDirs $<REMOVE_DUPLICATES:${includeDirs}>)
 
+  list(LENGTH A_EXTRA_PATCH hasExtraPatch)
   # add a custom command to generate the dictionary using rootcling
   # cmake-format: off
   add_custom_command(
@@ -146,11 +147,13 @@ function(add_root_dictionary target)
       --include_dirs -I$<JOIN:${includeDirs},$<SEMICOLON>-I>
       $<$<BOOL:${prop}>:--compile_defs>
       $<$<BOOL:${prop}>:-D$<JOIN:${prop},$<SEMICOLON>-D>>
+      $<$<BOOL:${hasExtraPatch}>:--extra-patch>
+      $<$<BOOL:${hasExtraPatch}>:${CMAKE_CURRENT_LIST_DIR}/${A_EXTRA_PATCH}>
       --pcmdeps "$<REMOVE_DUPLICATES:${list_pcm_deps_${target}}>"
       --headers "${headers}"
     COMMAND
     ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/${pcmBase} ${pcmFile}
-    DEPENDS ${headers} "$<REMOVE_DUPLICATES:${list_pcm_deps_${target}}>")
+    DEPENDS ${headers} "$<REMOVE_DUPLICATES:${list_pcm_deps_${target}}>" ${A_EXTRA_PATCH})
   # cmake-format: on
 
   # add dictionary source to the target sources
diff --git a/cmake/O2TargetRootDictionary.cmake b/cmake/O2TargetRootDictionary.cmake
index f5d630dd10569..0b91d751a4802 100644
--- a/cmake/O2TargetRootDictionary.cmake
+++ b/cmake/O2TargetRootDictionary.cmake
@@ -55,14 +55,9 @@ function(o2_target_root_dictionary baseTargetName)
                         1
                         A
                         ""
-                        "LINKDEF"
+                        "LINKDEF;EXTRA_PATCH"
                         "HEADERS")
 
-  if(A_UNPARSED_ARGUMENTS)
-    message(
-      FATAL_ERROR "Unexpected unparsed arguments: ${A_UNPARSED_ARGUMENTS}")
-  endif()
-
   if(${ARGC} LESS 1)
     message(
       FATAL_ERROR
@@ -96,6 +91,13 @@ function(o2_target_root_dictionary baseTargetName)
 
   # now that we have the O2 specific stuff computed, delegate the actual work to
   # the add_root_dictionary function
-  add_root_dictionary(${target} HEADERS ${A_HEADERS} LINKDEF ${A_LINKDEF})
+if(NOT A_EXTRA_PATCH)
+    add_root_dictionary(${target} HEADERS ${A_HEADERS} LINKDEF ${A_LINKDEF})
+else()
+    add_root_dictionary(${target}
+                        EXTRA_PATCH ${A_EXTRA_PATCH}
+                        HEADERS ${A_HEADERS}
+                        LINKDEF ${A_LINKDEF})
+endif()
 
 endfunction()
diff --git a/cmake/rootcling_wrapper.sh.in b/cmake/rootcling_wrapper.sh.in
index 76ce8c8115ca9..d5417c867bc38 100755
--- a/cmake/rootcling_wrapper.sh.in
+++ b/cmake/rootcling_wrapper.sh.in
@@ -41,6 +41,10 @@ while [[ $# -gt 0 ]]; do
     PCMDEPS="$2"
     shift 2
     ;;
+  --extra-patch)
+    EXTRA_PATCH="$2"
+    shift 2
+    ;;
   *)
     if [[ -z "$1" ]]; then
       shift
@@ -82,6 +86,18 @@ esac
 
 LOGFILE=${DICTIONARY_FILE}.log
 
+echo @CMAKE_COMMAND@ -E env "LD_LIBRARY_PATH=$libpath" @ROOT_rootcling_CMD@ \
+  -f $DICTIONARY_FILE \
+  -inlineInputHeader \
+  -noGlobalUsingStd \
+  -rmf ${ROOTMAP_FILE} \
+  -rml ${ROOTMAP_LIBRARY_NAME} \
+  ${INCLUDE_DIRS//;/ } \
+  ${COMPILE_DEFINITIONS//;/ } \
+  ${PCMDEPS:+-m }${PCMDEPS//;/ -m } \
+  ${HEADERS//;/ } \
+  > ${LOGFILE} 2>&1 || ROOTCLINGRETVAL=$?
+
 @CMAKE_COMMAND@ -E env "LD_LIBRARY_PATH=$libpath" @ROOT_rootcling_CMD@ \
   -f $DICTIONARY_FILE \
   -inlineInputHeader \
@@ -94,6 +110,13 @@ LOGFILE=${DICTIONARY_FILE}.log
   ${HEADERS//;/ } \
   > ${LOGFILE} 2>&1 || ROOTCLINGRETVAL=$?
 
+# Add the extra patch file at the end of the generated dictionary.
+# This is needed to inject custom streamers (e.g. for std::vector<PadFlags>)
+# to our dictionary.
+if [ ! X"${EXTRA_PATCH}" = X ]; then
+  cat $EXTRA_PATCH >> ${DICTIONARY_FILE}
+fi
+
 if [[ ${ROOTCLINGRETVAL:-0} != "0" ]]; then
   cat ${LOGFILE} >&2
   rm -f $DICTIONARY_FILE

From aa8b6fb8d16f0706fec9bde39197d553f75e044d Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Fri, 26 Sep 2025 15:51:05 +0200
Subject: [PATCH 0876/1764] dpl-workflow.sh: add env variable to use full MI100
 serialization in online

---
 prodtests/full-system-test/dpl-workflow.sh | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 996ab70da8f6c..9fc6ce5507168 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -278,8 +278,13 @@ if [[ $GPUTYPE == "HIP" ]]; then
     GPU_CONFIG+=" --environment \"ROCR_VISIBLE_DEVICES={timeslice${TIMESLICEOFFSET}}\""
   fi
   # serialization workaround for MI100 nodes: remove it again if the problem will be fixed in ROCm, then also remove the DISABLE_MI100_SERIALIZATION flag in the O2DPG parse script
-  [[ $EPNSYNCMODE == 1 ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.amdMI100SerializationWorkaround=1;"
-  [[ -n ${OPTIMIZED_PARALLEL_ASYNC:-} ]] && [[ ${EPN_NODE_MI100:-} == "1" ]] && [[ ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]] && GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
+  if [[ ${EPN_NODE_MI100:-} == "1" && ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]]; then
+    if [[ -n ${OPTIMIZED_PARALLEL_ASYNC:-} ]] || [[ $EPNSYNCMODE == 1 && ${FULL_MI100_SERIALIZATION:-0} == 1 ]]; then
+      GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
+    elif [[ $EPNSYNCMODE == 1 ]]; then
+      GPU_CONFIG_KEY+="GPU_proc.amdMI100SerializationWorkaround=1;"
+    fi
+  fi
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2
 else
   GPU_CONFIG_KEY+="GPU_proc.deviceNum=-2;"

From 429846dcc741d40919f10d9aca4d4ff2180e3144 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 5 Sep 2025 10:27:21 +0200
Subject: [PATCH 0877/1764] Common: Minor cleanup of flag helper class

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Common/Utils/include/CommonUtils/EnumFlags.h | 98 +++++++++++++-------
 Common/Utils/test/testEnumFlags.cxx          | 83 +++++++++--------
 2 files changed, 107 insertions(+), 74 deletions(-)

diff --git a/Common/Utils/include/CommonUtils/EnumFlags.h b/Common/Utils/include/CommonUtils/EnumFlags.h
index 9a8960f612553..4bd1a9e641056 100644
--- a/Common/Utils/include/CommonUtils/EnumFlags.h
+++ b/Common/Utils/include/CommonUtils/EnumFlags.h
@@ -57,6 +57,7 @@ concept EnumFlagHelper = requires {
 template <EnumFlagHelper E>
 struct FlagsHelper final {
   using U = std::underlying_type_t<E>;
+  using UMax = uint64_t; // max represetable type
 
   static constexpr bool isScoped() noexcept
   {
@@ -144,8 +145,8 @@ struct FlagsHelper final {
   {
     constexpr std::array<bool, sizeof...(I)> valid{isValid<static_cast<E>(MinScan + I)>()...};
     constexpr auto count{std::count_if(valid.cbegin(), valid.cend(), [](bool v) noexcept { return v; })};
-    static_assert(count > 0, "Requiring non-empty enum!");
-    static_assert(count <= MaxUnderScan, "Underlying type of enum has less digits than given expected!");
+    static_assert(count > 0, "EnumFlag requires at least one enum value. Check that your enum has consecutive values starting from 0.");
+    static_assert(count <= MaxUnderScan, "Too many enum values for underlying type. Consider using a larger underlying type or fewer enum values.");
     std::array<E, count> values{};
     for (size_t idx{}, n{}; n < count; ++idx) {
       if (valid[idx]) {
@@ -161,8 +162,16 @@ struct FlagsHelper final {
   static constexpr auto Min_u_v{static_cast<size_t>(Min_v)};                                           // Enum first entry as size_t
   static constexpr auto Max_u_v{static_cast<size_t>(Max_v)};                                           // Enum last entry as size_t
   static_assert(Max_u_v < std::numeric_limits<U>::digits, "Max Bit is beyond allow range defered from underlying type");
-  static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); }                             // Is the enum continuous
-  static constexpr auto MaxRep{((1ULL << (static_cast<unsigned long long>(Max_u_v - Min_u_v) + 1ULL)) - 1ULL) << Min_u_v}; // largest representable value
+  static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); } // Is the enum continuous
+  static constexpr UMax makeMaxRep(size_t min, size_t max)
+  {
+    const size_t width = max - min + 1;
+    if (width >= std::numeric_limits<UMax>::digits) {
+      return std::numeric_limits<UMax>::max();
+    }
+    return ((UMax(1) << width) - 1) << min;
+  }
+  static constexpr auto MaxRep{makeMaxRep(Min_u_v, Max_u_v)}; // largest representable value
 
   template <E e>
   static constexpr std::string_view getName()
@@ -173,7 +182,7 @@ struct FlagsHelper final {
     }
     if constexpr (tpeek_v<e>[tp + getSpec<SVal::Start, SType::Enum_t>().size()] == getSpec<SVal::AnonStart, SType::Enum_t>()) {
 #if defined __clang__
-      if constexpr (tpeek_v<e>[tp + getSpec<SVal::Start, SType::enum_t>().size() + 1] == getSpec<SVal::AnonStart, SType::Enum_t>()) {
+      if constexpr (tpeek_v<e>[tp + getSpec<SVal::Start, SType::Enum_t>().size() + 1] == getSpec<SVal::AnonStart, SType::Enum_t>()) {
         return {};
       }
 #endif
@@ -215,7 +224,7 @@ struct FlagsHelper final {
   template <E e>
   static constexpr auto getNameValue{getName<e>()};
 
-  template <bool with_scope, std::size_t... I>
+  template <bool with_scope, size_t... I>
   static constexpr auto getNames(std::index_sequence<I...> /*unused*/)
   {
     if constexpr (with_scope) {
@@ -248,7 +257,7 @@ struct FlagsHelper final {
 
   static constexpr std::optional<E> fromString(std::string_view str) noexcept
   {
-    for (std::size_t i{0}; i < count(); ++i) {
+    for (size_t i{0}; i < count(); ++i) {
       if (Names[i] == str || NamesScoped[i] == str) {
         return Values[i];
       }
@@ -325,7 +334,7 @@ concept EnumFlag = requires {
 /**
  * \brief Classs to aggregate and manage enum-based on-off flags.
  *
- * This class manages flags as bits in the underlying type of an enum, allowing
+ * This class manages flags as bits in the underlying type of an enum (upto 64 bits), allowing
  * manipulation via enum member names. It supports operations akin to std::bitset
  * but is fully constexpr and is ideal for aggregating multiple on-off booleans,
  * e.g., enabling/disabling algorithm features.
@@ -371,13 +380,18 @@ class EnumFlags
   constexpr EnumFlags(const EnumFlags&) = default;
   // Move constructor.
   constexpr EnumFlags(EnumFlags&&) = default;
-  // Constructor to initialize with the underlyiny type.
+  // Constructor to initialize with the underlying type.
   constexpr explicit EnumFlags(U u) : mBits(u) {}
   // Initialize with a list of flags.
   constexpr EnumFlags(std::initializer_list<E> flags) noexcept
   {
     std::for_each(flags.begin(), flags.end(), [this](const E f) noexcept { mBits |= to_bit(f); });
   }
+  // Init from a string.
+  EnumFlags(const std::string& str)
+  {
+    set(str);
+  }
   // Destructor.
   constexpr ~EnumFlags() = default;
 
@@ -415,7 +429,7 @@ class EnumFlags
     }
   }
   // Returns the raw bitset value.
-  constexpr auto value() const noexcept
+  [[nodiscard]] constexpr auto value() const noexcept
   {
     return mBits;
   }
@@ -442,6 +456,13 @@ class EnumFlags
     return (mBits & to_bit(t)) != None;
   }
 
+  // Tests if all specified flags are set.
+  template <typename... Ts>
+  [[nodiscard]] constexpr bool test(Ts... flags) const noexcept
+  {
+    return ((test(flags) && ...));
+  }
+
   // Sets a specific flag.
   template <typename T>
     requires std::is_same_v<T, E>
@@ -464,6 +485,12 @@ class EnumFlags
     return mBits != None;
   }
 
+  // Checks if all flags are set.
+  [[nodiscard]] constexpr bool all() const noexcept
+  {
+    return mBits == All;
+  }
+
   // Returns the bitset as a binary string.
   [[nodiscard]] std::string string() const
   {
@@ -505,7 +532,7 @@ class EnumFlags
   }
 
   // Checks if any flag is set (Boolean context).
-  constexpr explicit operator bool() const noexcept
+  [[nodiscard]] constexpr explicit operator bool() const noexcept
   {
     return any();
   }
@@ -513,19 +540,19 @@ class EnumFlags
   // Check if given flag is set.
   template <typename T>
     requires std::is_same_v<T, E>
-  constexpr bool operator[](const T t) noexcept
+  [[nodiscard]] constexpr bool operator[](const T t) const noexcept
   {
     return test(t);
   }
 
   // Checks if two flag sets are equal.
-  constexpr bool operator==(const EnumFlags& o) const noexcept
+  [[nodiscard]] constexpr bool operator==(const EnumFlags& o) const noexcept
   {
     return mBits == o.mBits;
   }
 
   // Checks if two flag sets are not equal.
-  constexpr bool operator!=(const EnumFlags& o) const noexcept
+  [[nodiscard]] constexpr bool operator!=(const EnumFlags& o) const noexcept
   {
     return mBits != o.mBits;
   }
@@ -584,7 +611,13 @@ class EnumFlags
   // Performs a bitwise XOR with another flag set.
   constexpr EnumFlags operator^(const EnumFlags& o) const noexcept
   {
-    return Flags(mBits ^ o.mBits);
+    return EnumFlags(mBits ^ o.mBits);
+  }
+
+  // Performs a bitwise and with another flag set.
+  constexpr EnumFlags operator&(const EnumFlags& o) const noexcept
+  {
+    return EnumFlags(mBits & o.mBits);
   }
 
   // Performs a bitwise XOR assignment.
@@ -596,14 +629,14 @@ class EnumFlags
 
   // Checks if all specified flags are set.
   template <typename... Ts>
-  constexpr bool all_of(Ts... flags) const noexcept
+  [[nodiscard]] constexpr bool all_of(Ts... flags) const noexcept
   {
-    return ((test(flags) && ...));
+    return test(flags...);
   }
 
   // Checks if none of the specified flags are set.
   template <typename... Ts>
-  constexpr bool none_of(Ts... flags) const noexcept
+  [[nodiscard]] constexpr bool none_of(Ts... flags) const noexcept
   {
     return (!(test(flags) || ...));
   }
@@ -617,7 +650,7 @@ class EnumFlags
   // Deserializes a string into the flag set.
   void deserialize(const std::string& data)
   {
-    uint64_t v = std::stoul(data);
+    typename H::UMax v = std::stoul(data);
     if (v > H::MaxRep) {
       throw std::out_of_range("Values exceeds enum range.");
     }
@@ -627,35 +660,29 @@ class EnumFlags
   // Counts the number of set bits (active flags).
   [[nodiscard]] constexpr size_t count() const noexcept
   {
-    size_t c{0};
-    for (size_t i{H::Min_u_v}; i < H::Max_u_v; ++i) {
-      if ((mBits & (U(1) << i)) != U(0)) {
-        ++c;
-      }
-    }
-    return c;
+    return std::popcount(mBits);
   }
 
   // Returns the union of two flag sets.
-  constexpr EnumFlags union_with(const EnumFlags& o) const noexcept
+  [[nodiscard]] constexpr EnumFlags union_with(const EnumFlags& o) const noexcept
   {
     return EnumFlags(mBits | o.mBits);
   }
 
   // Returns the intersection of two flag sets.
-  constexpr EnumFlags intersection_with(const EnumFlags& o) const noexcept
+  [[nodiscard]] constexpr EnumFlags intersection_with(const EnumFlags& o) const noexcept
   {
     return EnumFlags(mBits & o.mBits);
   }
 
   // Checks if all flags in another Flags object are present in the current object.
-  constexpr bool contains(const EnumFlags& other) const noexcept
+  [[nodiscard]] constexpr bool contains(const EnumFlags& other) const noexcept
   {
     return (mBits & other.mBits) == other.mBits;
   }
 
  private:
-  // Set implemnetation, bits was zeroed before.
+  // Set implementation, bits was zeroed before.
   void setImpl(const std::string& s, int base = 2)
   {
     if (std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isdigit(c); })) {
@@ -664,12 +691,12 @@ class EnumFlags
           throw std::invalid_argument("Invalid binary string.");
         }
       }
-      uint64_t v = std::stoul(s, nullptr, base);
+      typename H::UMax v = std::stoul(s, nullptr, base);
       if (v > H::MaxRep) {
         throw std::out_of_range("Values exceeds enum range.");
       }
       mBits = static_cast<U>(v);
-    } else if (std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isalnum(c) != 0 || c == '|' || c == ' ' || c == ':' || c == ','; })) {
+    } else if (std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isalnum(c) != 0 || c == '|' || c == ' ' || c == ':' || c == ',' || c == ';'; })) {
       std::string cs{s};
       std::transform(cs.begin(), cs.end(), cs.begin(), [](unsigned char c) { return std::tolower(c); });
       if (cs == H::All) {
@@ -677,7 +704,12 @@ class EnumFlags
       } else if (cs == H::None) {
         mBits = None;
       } else {
-        char token = (s.find(',') != std::string::npos) ? ',' : '|';
+        // accept as delimiter ' ', '|', ';', ','
+        char token = ' ';
+        std::string::size_type pos = s.find_first_of(",|;");
+        if (pos != std::string::npos) {
+          token = s[pos];
+        }
         for (const auto& tok : Str::tokenize(s, token)) {
           if (auto e = H::fromString(tok)) {
             mBits |= to_bit(*e);
diff --git a/Common/Utils/test/testEnumFlags.cxx b/Common/Utils/test/testEnumFlags.cxx
index 41b43bc4218ff..80f85c847653b 100644
--- a/Common/Utils/test/testEnumFlags.cxx
+++ b/Common/Utils/test/testEnumFlags.cxx
@@ -14,6 +14,9 @@
 #define BOOST_TEST_DYN_LINK
 
 #include <boost/test/unit_test.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+
 #include <stdexcept>
 #include <string>
 
@@ -21,7 +24,7 @@
 
 // Example enum to use with EnumFlags
 enum class TestEnum : uint8_t {
-  Bit1,
+  Bit1 = 0,
   Bit2,
   Bit3,
   Bit4,
@@ -29,44 +32,16 @@ enum class TestEnum : uint8_t {
 };
 
 // Very long enum
-// to test that it works beyond 32 bits
+// to test that it works beyond 32 bits upto 64 bits
+#define ENUM_BIT_NAME(n) Bit##n
+#define ENUM_BIT_NAME_EXPAND(n) ENUM_BIT_NAME(n)
+#define ENUM_BIT(z, n, _) ENUM_BIT_NAME_EXPAND(BOOST_PP_INC(n)) = (n),
 enum class TestEnumLong : uint64_t {
-  Bit1,
-  Bit2,
-  Bit3,
-  Bit4,
-  Bit5,
-  Bit6,
-  Bit7,
-  Bit8,
-  Bit9,
-  Bit10,
-  Bit11,
-  Bit12,
-  Bit13,
-  Bit14,
-  Bit15,
-  Bit16,
-  Bit17,
-  Bit18,
-  Bit19,
-  Bit20,
-  Bit21,
-  Bit22,
-  Bit23,
-  Bit24,
-  Bit25,
-  Bit26,
-  Bit27,
-  Bit28,
-  Bit29,
-  Bit30,
-  Bit31,
-  Bit32,
-  Bit33,
-  Bit34,
-  // ...
+  BOOST_PP_REPEAT(64, ENUM_BIT, _)
 };
+#undef ENUM_BIT
+#undef ENUM_BIT_NAME
+#undef ENUM_BIT_NAME_EXPAND
 
 BOOST_AUTO_TEST_CASE(Flags_test)
 {
@@ -181,7 +156,7 @@ BOOST_AUTO_TEST_CASE(Flags_test)
       BOOST_TEST(flags.test(TestEnum::Bit4));
     }
 
-    { // test with different delimiter
+    { // test with , delimiter
       std::string str = "Bit4,TestEnum::Bit2 , Bit1 ";
       flags.set(str);
       BOOST_TEST(flags.test(TestEnum::Bit1));
@@ -190,6 +165,15 @@ BOOST_AUTO_TEST_CASE(Flags_test)
       BOOST_TEST(flags.test(TestEnum::Bit4));
     }
 
+    { // test with ; delimiter
+      std::string str = "Bit4;TestEnum::Bit2 ; Bit1 ";
+      flags.set(str);
+      BOOST_TEST(flags.test(TestEnum::Bit1));
+      BOOST_TEST(flags.test(TestEnum::Bit2));
+      BOOST_TEST(!flags.test(TestEnum::Bit3));
+      BOOST_TEST(flags.test(TestEnum::Bit4));
+    }
+
     { // throw test with mixed delimiter
       std::string str = "Bit4|TestEnum::Bit2 , Bit1 ";
       BOOST_CHECK_THROW(flags.set(str), std::invalid_argument);
@@ -275,6 +259,14 @@ BOOST_AUTO_TEST_CASE(Flags_test)
     EFlags flags3{TestEnum::Bit1, TestEnum::Bit2, TestEnum::Bit3};
     EFlags flags4{TestEnum::Bit2, TestEnum::Bit3, TestEnum::Bit4};
 
+    // test xor
+    auto flagsXOR = flags3 ^ flags4;
+    BOOST_CHECK(flagsXOR.test(TestEnum::Bit1, TestEnum::Bit4));
+
+    // test and
+    auto flagsAND = flags3 & flags4;
+    BOOST_CHECK(flagsAND.test(TestEnum::Bit2, TestEnum::Bit3));
+
     // Perform an intersection operation
     EFlags intersectionFlags = flags3.intersection_with(flags4);
     BOOST_CHECK(intersectionFlags.test(TestEnum::Bit2));
@@ -284,6 +276,14 @@ BOOST_AUTO_TEST_CASE(Flags_test)
     BOOST_CHECK_EQUAL(intersectionFlags.value(), 6); // 0110 in binary
   }
 
+  {
+    // Check special flag names.
+    EFlags flag("all");
+    BOOST_CHECK(flag.all());
+    flag.set("none");
+    BOOST_CHECK(!flag.any());
+  }
+
   {
     // Create two flag sets
     EFlags flags1{TestEnum::Bit1, TestEnum::Bit2, TestEnum::Bit3};
@@ -300,8 +300,9 @@ BOOST_AUTO_TEST_CASE(Flags_test)
 
   {
     // Test compilation using an enum with more than 32 bits
-    o2::utils::EnumFlags<TestEnumLong> test;
-    test.set("Bit32");
-    BOOST_CHECK(test.test(TestEnumLong::Bit32));
+    // Also tests space delimiter and construction from string.
+    o2::utils::EnumFlags<TestEnumLong> test("Bit32 Bit34");
+    BOOST_CHECK(test.test(TestEnumLong::Bit32, TestEnumLong::Bit34));
+    BOOST_CHECK(!test.test(TestEnumLong::Bit1, TestEnumLong::Bit23));
   }
 }

From 99548c4276e77a358a6c6578a7cf1493fe250512 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 21 Sep 2025 19:03:01 +0400
Subject: [PATCH 0878/1764] Robust propagation to certain R

o2::base::Propagator got method propagateToR(track, r, bool bzOnly, maxSnp ...) which propagates the track (either TrackPar or TrackParCov)
to requested radius (not X!) if it is reachable in any tracking frame. The rotations to avoid track snp goind outside of the allowed range are done automatically.

Moved HelixHelper to ReconstructionDataFormats.
---
 Common/DCAFitter/CMakeLists.txt               |   3 +-
 .../DCAFitter/include/DCAFitter/DCAFitterN.h  |   2 +-
 .../include/DCAFitter/FwdDCAFitterN.h         |   2 +-
 Common/DCAFitter/src/DCAFitterLinkDef.h       |   3 -
 Common/Field/include/Field/MagFieldFast.h     |   4 +-
 Common/Field/src/MagFieldFast.cxx             |   2 +-
 DataFormats/Reconstruction/CMakeLists.txt     |   1 +
 .../ReconstructionDataFormats}/HelixHelper.h  |   0
 .../src/ReconstructionDataFormatsLinkDef.h    |   3 +
 .../src/TrackParametrization.cxx              |  68 ++++-----
 Detectors/Base/CMakeLists.txt                 |   1 +
 .../Base/include/DetectorsBase/Propagator.h   |  12 +-
 Detectors/Base/src/Propagator.cxx             | 139 ++++++++++++++++++
 .../DetectorsVertexing/FwdDCAFitterN.h        |   2 +-
 .../include/DetectorsVertexing/HelixHelper.h  | 115 +++++++++------
 15 files changed, 268 insertions(+), 89 deletions(-)
 rename {Common/DCAFitter/include/DCAFitter => DataFormats/Reconstruction/include/ReconstructionDataFormats}/HelixHelper.h (100%)

diff --git a/Common/DCAFitter/CMakeLists.txt b/Common/DCAFitter/CMakeLists.txt
index 5c3a93aa7fa74..c0b2d0dca1026 100644
--- a/Common/DCAFitter/CMakeLists.txt
+++ b/Common/DCAFitter/CMakeLists.txt
@@ -22,8 +22,7 @@ o2_add_library(DCAFitter
                                      O2::DetectorsBase)
 
 o2_target_root_dictionary(DCAFitter
-                          HEADERS include/DCAFitter/HelixHelper.h
-                                  include/DCAFitter/DCAFitterN.h
+                          HEADERS include/DCAFitter/DCAFitterN.h
                                   include/DCAFitter/FwdDCAFitterN.h)
 
 if (OpenMP_CXX_FOUND)
diff --git a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
index df732bd4bde63..1adf7a9ae7329 100644
--- a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
+++ b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
@@ -17,7 +17,7 @@
 #ifndef _ALICEO2_DCA_FITTERN_
 #define _ALICEO2_DCA_FITTERN_
 
-#include "DCAFitter/HelixHelper.h"
+#include "ReconstructionDataFormats/HelixHelper.h"
 #include "DetectorsBase/Propagator.h"
 #include "MathUtils/Cartesian.h"
 #include "ReconstructionDataFormats/Track.h"
diff --git a/Common/DCAFitter/include/DCAFitter/FwdDCAFitterN.h b/Common/DCAFitter/include/DCAFitter/FwdDCAFitterN.h
index cd1742e24fa72..d5bc6631575af 100644
--- a/Common/DCAFitter/include/DCAFitter/FwdDCAFitterN.h
+++ b/Common/DCAFitter/include/DCAFitter/FwdDCAFitterN.h
@@ -20,7 +20,7 @@
 #include "MathUtils/Cartesian.h"
 #include "ReconstructionDataFormats/TrackFwd.h"
 #include "ReconstructionDataFormats/Track.h"
-#include "DCAFitter/HelixHelper.h"
+#include "ReconstructionDataFormats/HelixHelper.h"
 #include <TRandom.h>
 #include "DetectorsBase/Propagator.h"
 #include "DetectorsBase/GeometryManager.h"
diff --git a/Common/DCAFitter/src/DCAFitterLinkDef.h b/Common/DCAFitter/src/DCAFitterLinkDef.h
index 3589ffe559e96..6883369c1b9b6 100644
--- a/Common/DCAFitter/src/DCAFitterLinkDef.h
+++ b/Common/DCAFitter/src/DCAFitterLinkDef.h
@@ -18,9 +18,6 @@
 #pragma link C++ class o2::vertexing::DCAFitterN < 2, o2::track::TrackParCov> + ;
 #pragma link C++ class o2::vertexing::DCAFitterN < 3, o2::track::TrackParCov> + ;
 
-#pragma link C++ class o2::track::TrackAuxPar + ;
-#pragma link C++ class o2::track::CrossInfo + ;
-
 #pragma link C++ function o2::vertexing::DCAFitter2::process(const o2::track::TrackParCov&, const o2::track::TrackParCov&);
 #pragma link C++ function o2::vertexing::DCAFitter3::process(const o2::track::TrackParCov&, const o2::track::TrackParCov&, const o2::track::TrackParCov&);
 
diff --git a/Common/Field/include/Field/MagFieldFast.h b/Common/Field/include/Field/MagFieldFast.h
index acff8f528ad06..ae6431a477923 100644
--- a/Common/Field/include/Field/MagFieldFast.h
+++ b/Common/Field/include/Field/MagFieldFast.h
@@ -57,7 +57,7 @@ class MagFieldFast
   bool Field(const math_utils::Point3D<double> xyz, double bxyz[3]) const;
   bool GetBcomp(EDim comp, const double xyz[3], double& b) const;
   bool GetBcomp(EDim comp, const float xyz[3], float& b) const;
-  bool GetBcomp(EDim comp, const math_utils::Point3D<float> xyz, double& b) const;
+  bool GetBcomp(EDim comp, const math_utils::Point3D<double> xyz, double& b) const;
   bool GetBcomp(EDim comp, const math_utils::Point3D<float> xyz, float& b) const;
 
   bool GetBx(const double xyz[3], double& bx) const { return GetBcomp(kX, xyz, bx); }
@@ -66,6 +66,8 @@ class MagFieldFast
   bool GetBy(const float xyz[3], float& by) const { return GetBcomp(kY, xyz, by); }
   bool GetBz(const double xyz[3], double& bz) const { return GetBcomp(kZ, xyz, bz); }
   bool GetBz(const float xyz[3], float& bz) const { return GetBcomp(kZ, xyz, bz); }
+  bool GetBz(const math_utils::Point3D<double> xyz, double& bz) const { return GetBcomp(kZ, xyz, bz); }
+  bool GetBz(const math_utils::Point3D<float> xyz, float& bz) const { return GetBcomp(kZ, xyz, bz); }
   void setFactorSol(float v = 1.f) { mFactorSol = v; }
   float getFactorSol() const { return mFactorSol; }
 
diff --git a/Common/Field/src/MagFieldFast.cxx b/Common/Field/src/MagFieldFast.cxx
index 5caad34d56dd4..02ef9c153d189 100644
--- a/Common/Field/src/MagFieldFast.cxx
+++ b/Common/Field/src/MagFieldFast.cxx
@@ -145,7 +145,7 @@ bool MagFieldFast::GetBcomp(EDim comp, const double xyz[3], double& b) const
 }
 
 //_______________________________________________________________________
-bool MagFieldFast::GetBcomp(EDim comp, const math_utils::Point3D<float> xyz, double& b) const
+bool MagFieldFast::GetBcomp(EDim comp, const math_utils::Point3D<double> xyz, double& b) const
 {
   // get field
   int zSeg, rSeg, quadrant;
diff --git a/DataFormats/Reconstruction/CMakeLists.txt b/DataFormats/Reconstruction/CMakeLists.txt
index 86c0831d2134e..ffd88df2412f9 100644
--- a/DataFormats/Reconstruction/CMakeLists.txt
+++ b/DataFormats/Reconstruction/CMakeLists.txt
@@ -73,6 +73,7 @@ o2_target_root_dictionary(
           include/ReconstructionDataFormats/BCRange.h
           include/ReconstructionDataFormats/TrackHMP.h
           include/ReconstructionDataFormats/MatchInfoHMP.h
+          include/ReconstructionDataFormats/HelixHelper.h
   )
 
 o2_add_test(Vertex
diff --git a/Common/DCAFitter/include/DCAFitter/HelixHelper.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/HelixHelper.h
similarity index 100%
rename from Common/DCAFitter/include/DCAFitter/HelixHelper.h
rename to DataFormats/Reconstruction/include/ReconstructionDataFormats/HelixHelper.h
diff --git a/DataFormats/Reconstruction/src/ReconstructionDataFormatsLinkDef.h b/DataFormats/Reconstruction/src/ReconstructionDataFormatsLinkDef.h
index 6cd72e8668cc1..b386830d9872d 100644
--- a/DataFormats/Reconstruction/src/ReconstructionDataFormatsLinkDef.h
+++ b/DataFormats/Reconstruction/src/ReconstructionDataFormatsLinkDef.h
@@ -117,4 +117,7 @@
 #pragma link C++ class o2::dataformats::StrangeTrack + ;
 #pragma link C++ class std::vector < o2::dataformats::StrangeTrack> + ;
 
+#pragma link C++ class o2::track::TrackAuxPar + ;
+#pragma link C++ class o2::track::CrossInfo + ;
+
 #endif
diff --git a/DataFormats/Reconstruction/src/TrackParametrization.cxx b/DataFormats/Reconstruction/src/TrackParametrization.cxx
index b685a1549dd31..0539278acb20b 100644
--- a/DataFormats/Reconstruction/src/TrackParametrization.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrization.cxx
@@ -651,7 +651,7 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
   // DirOutward (==1) - go along the track (increasing mX)
   // DirInward (==-1) - go backward (decreasing mX)
   //
-  const auto fy = mP[0], sn = mP[2];
+  const double fy = mP[0], sn = mP[2];
   const value_t kEps = 1.e-6;
   //
   if (gpu::CAMath::Abs(getSnp()) > constants::math::Almost1) {
@@ -670,18 +670,18 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
     if (r0 <= constants::math::Almost0) {
       return false; // the track is concentric to circle
     }
-    value_t tR2r0 = 1.f, g = 0.f, tmp = 0.f;
+    double tR2r0 = 1., g = 0., tmp = 0.;
     if (gpu::CAMath::Abs(circle.rC - r0) > kEps) {
       tR2r0 = circle.rC / r0;
       g = 0.5f * (r * r / (r0 * circle.rC) - tR2r0 - 1.f / tR2r0);
       tmp = 1.f + g * tR2r0;
     } else {
       tR2r0 = 1.0;
-      g = 0.5f * r * r / (r0 * circle.rC) - 1.f;
-      tmp = 0.5f * r * r / (r0 * r0);
+      g = 0.5 * r * r / (r0 * circle.rC) - 1.;
+      tmp = 0.5 * r * r / (r0 * r0);
     }
-    value_t det = (1.f - g) * (1.f + g);
-    if (det < 0.f) {
+    auto det = (1. - g) * (1. + g);
+    if (det < 0.) {
       return false; // does not reach raduis r
     }
     det = gpu::CAMath::Sqrt(det);
@@ -691,25 +691,26 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
     // where s0 and c0 make direction for the circle center (=circle.xC/r0 and circle.yC/r0)
     //
     x = circle.xC * tmp;
-    value_t y = circle.yC * tmp;
+    auto y = circle.yC * tmp;
     if (gpu::CAMath::Abs(circle.yC) > constants::math::Almost0) { // when circle.yC==0 the x,y is unique
-      value_t dfx = tR2r0 * gpu::CAMath::Abs(circle.yC) * det;
-      value_t dfy = tR2r0 * circle.xC * (circle.yC > 0.f ? det : -det);
+      auto dfx = tR2r0 * gpu::CAMath::Abs(circle.yC) * det;
+      auto dfy = tR2r0 * circle.xC * (circle.yC > 0. ? det : -det);
       if (dir == DirAuto) {                              // chose the one which corresponds to smallest step
-        value_t delta = (x - mX) * dfx - (y - fy) * dfy; // the choice of + in C will lead to smaller step if delta<0
-        x += delta < 0.f ? dfx : -dfx;
+        auto delta = (x - mX) * dfx - (y - fy) * dfy;    // the choice of + in C will lead to smaller step if delta<0
+        x += delta < 0. ? dfx : -dfx;
       } else if (dir == DirOutward) { // along track direction: x must be > mX
         x -= dfx;                     // try the smallest step (dfx is positive)
-        value_t dfeps = mX - x;       // handle special case of very small step
+        auto dfeps = mX - x;          // handle special case of very small step
         if (dfeps < -kEps) {
           return true;
         }
         if (gpu::CAMath::Abs(dfeps) < kEps && gpu::CAMath::Abs(mX * mX + fy * fy - r * r) < kEps) { // are we already in right r?
-          return mX;
+          x = mX;
+          return true;
         }
         x += dfx + dfx;
-        value_t dxm = x - mX;
-        if (dxm > 0.f) {
+        auto dxm = x - mX;
+        if (dxm > 0.) {
           return true;
         } else if (dxm < -kEps) {
           return false;
@@ -717,16 +718,17 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
         x = mX;                 // don't move
       } else {                  // backward: x must be < mX
         x += dfx;               // try the smallest step (dfx is positive)
-        value_t dfeps = x - mX; // handle special case of very small step
+        auto dfeps = x - mX;    // handle special case of very small step
         if (dfeps < -kEps) {
           return true;
         }
         if (gpu::CAMath::Abs(dfeps) < kEps && gpu::CAMath::Abs(mX * mX + fy * fy - r * r) < kEps) { // are we already in right r?
-          return mX;
+          x = mX;
+          return true;
         }
         x -= dfx + dfx;
-        value_t dxm = x - mX;
-        if (dxm < 0.f) {
+        auto dxm = x - mX;
+        if (dxm < 0.) {
           return true;
         }
         if (dxm > kEps) {
@@ -739,11 +741,11 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
         return false;
       }
     }
-    return x;
+    return true;
   }
   // this is a straight track
   if (gpu::CAMath::Abs(sn) >= constants::math::Almost1) { // || to Y axis
-    value_t det = (r - mX) * (r + mX);
+    double det = (r - mX) * (r + mX);
     if (det < 0.f) {
       return false; // does not reach raduis r
     }
@@ -753,7 +755,7 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
     }
     det = gpu::CAMath::Sqrt(det);
     if (dir == DirOutward) { // along the track direction
-      if (sn > 0.f) {
+      if (sn > 0.) {
         if (fy > det) {
           return false; // track is along Y axis and above the circle
         }
@@ -763,7 +765,7 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
         }
       }
     } else if (dir == DirInward) { // against track direction
-      if (sn > 0.f) {
+      if (sn > 0.) {
         if (fy < -det) {
           return false; // track is along Y axis
         }
@@ -772,13 +774,13 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
       }
     }
   } else if (gpu::CAMath::Abs(sn) <= constants::math::Almost0) { // || to X axis
-    value_t det = (r - fy) * (r + fy);
-    if (det < 0.f) {
+    double det = (r - fy) * (r + fy);
+    if (det < 0.) {
       return false; // does not reach raduis r
     }
     det = gpu::CAMath::Sqrt(det);
     if (dir == DirAuto) {
-      x = mX > 0.f ? det : -det; // choose the solution requiring the smalest step
+      x = mX > 0. ? det : -det; // choose the solution requiring the smalest step
       return true;
     } else if (dir == DirOutward) { // along the track direction
       if (mX > det) {
@@ -794,17 +796,17 @@ GPUd() bool TrackParametrization<value_T>::getXatLabR(value_t r, value_t& x, val
       }
     }
   } else { // general case of straight line
-    value_t cs = gpu::CAMath::Sqrt((1.f - sn) * (1.f + sn));
-    value_t xsyc = mX * sn - fy * cs;
-    value_t det = (r - xsyc) * (r + xsyc);
-    if (det < 0.f) {
+    auto cs = gpu::CAMath::Sqrt((1. - sn) * (1. + sn));
+    auto xsyc = mX * sn - fy * cs;
+    auto det = (r - xsyc) * (r + xsyc);
+    if (det < 0.) {
       return false; // does not reach raduis r
     }
     det = gpu::CAMath::Sqrt(det);
-    value_t xcys = mX * cs + fy * sn;
-    value_t t = -xcys;
+    auto xcys = mX * cs + fy * sn;
+    auto t = -xcys;
     if (dir == DirAuto) {
-      t += t > 0.f ? -det : det; // chose the solution requiring the smalest step
+      t += t > 0. ? -det : det;  // chose the solution requiring the smalest step
     } else if (dir > 0) {        // go in increasing mX direction. ( t+-det > 0)
       if (t >= -det) {
         t += det; // take minimal step giving t>0
diff --git a/Detectors/Base/CMakeLists.txt b/Detectors/Base/CMakeLists.txt
index 3f8b2f5343fd4..30ab4c4fe8a40 100644
--- a/Detectors/Base/CMakeLists.txt
+++ b/Detectors/Base/CMakeLists.txt
@@ -8,6 +8,7 @@
 # In applying this license CERN does not waive the privileges and immunities
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
+#add_compile_options(-O0 -g -fPIC)
 
 o2_add_library(DetectorsBase
                SOURCES src/Detector.cxx
diff --git a/Detectors/Base/include/DetectorsBase/Propagator.h b/Detectors/Base/include/DetectorsBase/Propagator.h
index dbdef47e4edc0..d9b1522f4295b 100644
--- a/Detectors/Base/include/DetectorsBase/Propagator.h
+++ b/Detectors/Base/include/DetectorsBase/Propagator.h
@@ -92,13 +92,17 @@ class PropagatorImpl
   GPUd() bool propagateTo(track_T& track, value_type x, bool bzOnly = false, value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP,
                           MatCorrType matCorr = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const
   {
-    return bzOnly ? propagateToX(track, x, getNominalBz(), maxSnp, maxStep, matCorr, tofInfo, signCorr) : PropagateToXBxByBz(track, x, maxSnp, maxStep, matCorr, tofInfo, signCorr);
+    return bzOnly ? propagateToX(track, x, getBz(track.getXYZGlo()), maxSnp, maxStep, matCorr, tofInfo, signCorr) : PropagateToXBxByBz(track, x, maxSnp, maxStep, matCorr, tofInfo, signCorr);
   }
 
   template <typename track_T>
   GPUd() bool propagateToAlphaX(track_T& track, value_type alpha, value_type x, bool bzOnly = false, value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, int minSteps = 1,
                                 MatCorrType matCorr = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
 
+  template <typename track_T>
+  GPUd() bool propagateToR(track_T& track, value_type r, bool bzOnly = false, value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP,
+                           MatCorrType matCorr = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
+
   GPUd() bool propagateToDCA(const o2::dataformats::VertexBase& vtx, o2::track::TrackParametrizationWithError<value_type>& track, value_type bZ,
                              value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
                              o2::dataformats::DCA* dcaInfo = nullptr, track::TrackLTIntegral* tofInfo = nullptr,
@@ -157,6 +161,10 @@ class PropagatorImpl
 
   GPUd() void getFieldXYZ(const math_utils::Point3D<double> xyz, double* bxyz) const;
 
+  GPUd() float getBz(const math_utils::Point3D<float> xyz) const;
+
+  GPUd() double getBz(const math_utils::Point3D<double> xyz) const;
+
  private:
 #ifndef GPUCA_GPUCODE
   PropagatorImpl(bool uninitialized = false);
@@ -165,6 +173,8 @@ class PropagatorImpl
   static constexpr value_type Epsilon = 0.00001; // precision of propagation to X
   template <typename T>
   GPUd() void getFieldXYZImpl(const math_utils::Point3D<T> xyz, T* bxyz) const;
+  template <typename T>
+  GPUd() T getBzImpl(const math_utils::Point3D<T> xyz) const;
 
   const o2::field::MagFieldFast* mFieldFast = nullptr; ///< External fast field map (barrel only for the moment)
   o2::field::MagneticField* mField = nullptr;          ///< External nominal field map
diff --git a/Detectors/Base/src/Propagator.cxx b/Detectors/Base/src/Propagator.cxx
index 1c44cea65c69c..b6112cd5ba32e 100644
--- a/Detectors/Base/src/Propagator.cxx
+++ b/Detectors/Base/src/Propagator.cxx
@@ -15,6 +15,7 @@
 #include "GPUCommonMath.h"
 #include "GPUTPCGMPolynomialField.h"
 #include "MathUtils/Utils.h"
+#include "ReconstructionDataFormats/HelixHelper.h"
 #include "ReconstructionDataFormats/Vertex.h"
 
 using namespace o2::base;
@@ -418,6 +419,101 @@ GPUd() bool PropagatorImpl<value_T>::propagateToX(TrackPar_t& track, value_type
   return true;
 }
 
+//_______________________________________________________________________
+template <typename value_T>
+template <typename track_T>
+GPUd() bool PropagatorImpl<value_T>::propagateToR(track_T& track, value_type r, bool bzOnly, value_type maxSnp, value_type maxStep,
+                                                  MatCorrType matCorr, track::TrackLTIntegral* tofInfo, int signCorr) const
+{
+  const value_T MaxPhiLoc = math_utils::detail::asin<value_T>(maxSnp), MaxPhiLocSafe = 0.95 * MaxPhiLoc;
+  auto bz = getNominalBz();
+  if (math_utils::detail::abs(bz) > constants::math::Almost0) {
+    o2::track::TrackAuxPar traux(track, bz);
+    o2::track::TrackAuxPar crad;
+    value_type r0 = math_utils::detail::sqrt<value_T>(track.getX() * track.getX() + track.getY() * track.getY());
+    value_type dr = (r - r0);
+    value_type rTmp = r - (math_utils::detail::abs<value_T>(dr) > 1. ? (dr > 0 ? 0.5 : -0.5) : 0.5 * dr); // 1st propagate a few mm short of the targer R
+    crad.rC = rTmp;
+    crad.c = crad.cc = 1.f;
+    crad.s = crad.ss = crad.cs = 0.f;
+    o2::track::CrossInfo cross;
+    cross.circlesCrossInfo(crad, traux, 0.);
+    if (cross.nDCA < 1) {
+      return false;
+    }
+    double phiCross[2] = {}, dphi[2] = {};
+    auto curv = track.getCurvature(bz);
+    bool clockwise = curv < 0; // q+ in B+ or q- in B- goes clockwise
+    auto phiLoc = math_utils::detail::asin<double>(track.getSnp());
+    auto phi0 = phiLoc + track.getAlpha();
+    o2::math_utils::detail::bringTo02Pi(phi0);
+    for (int i = 0; i < cross.nDCA; i++) {
+      // track pT direction angle at crossing points:
+      // == angle of the tangential to track circle at the crossing point X,Y
+      // == normal to the radial vector from the track circle center {X-cX, Y-cY}
+      // i.e. the angle of the vector {Y-cY, -(X-cx)}
+      auto normX = double(cross.yDCA[i]) - double(traux.yC), normY = -(double(cross.xDCA[i]) - double(traux.xC));
+      if (!clockwise) {
+        normX = -normX;
+        normY = -normY;
+      }
+      phiCross[i] = math_utils::detail::atan2<double>(normY, normX);
+      o2::math_utils::detail::bringTo02Pi(phiCross[i]);
+      dphi[i] = phiCross[i] - phi0;
+      if (dphi[i] > o2::constants::math::PI) {
+        dphi[i] -= o2::constants::math::TwoPI;
+      } else if (dphi[i] < -o2::constants::math::PI) {
+        dphi[i] += o2::constants::math::TwoPI;
+      }
+    }
+    int sel = cross.nDCA == 1 ? 0 : (clockwise ? (dphi[0] < dphi[1] ? 0 : 1) : (dphi[1] < dphi[0] ? 0 : 1));
+    auto deltaPhi = dphi[sel];
+
+    while (1) {
+      auto phiLocFin = phiLoc + deltaPhi;
+      // case1
+      if (math_utils::detail::abs<value_type>(phiLocFin) < MaxPhiLocSafe) { // just 1 step propagation
+        auto deltaX = (math_utils::detail::sin<double>(phiLocFin) - track.getSnp()) / track.getCurvature(bz);
+        if (!track.propagateTo(track.getX() + deltaX, bz)) {
+          return false;
+        }
+        break;
+      }
+      if (math_utils::detail::abs<value_type>(deltaPhi) < (2 * MaxPhiLocSafe)) { // still can go in 1 step with one extra rotation
+        auto rot = phiLoc + 0.5 * deltaPhi;
+        if (!track.rotate(track.getAlpha() + rot)) {
+          return false;
+        }
+        phiLoc -= rot;
+        continue; // should be ok for the case 1 now.
+      }
+
+      auto rot = phiLoc + (deltaPhi > 0 ? MaxPhiLocSafe : -MaxPhiLocSafe);
+      if (!track.rotate(track.getAlpha() + rot)) {
+        return false;
+      }
+      phiLoc -= rot; // = +- MaxPhiLocSafe
+
+      // propagate to phiLoc = +-MaxPhiLocSafe
+      auto tgtPhiLoc = deltaPhi > 0 ? MaxPhiLocSafe : -MaxPhiLocSafe;
+      auto deltaX = (math_utils::detail::sin<double>(tgtPhiLoc) - track.getSnp()) / track.getCurvature(bz);
+      if (!track.propagateTo(track.getX() + deltaX, bz)) {
+        return false;
+      }
+      deltaPhi -= tgtPhiLoc - phiLoc;
+      phiLoc = deltaPhi > 0 ? MaxPhiLocSafe : -MaxPhiLocSafe;
+      continue; // should be of for the case 1 now.
+    }
+    bz = getBz(math_utils::Point3D<value_type>{value_type(cross.xDCA[sel]), value_type(cross.yDCA[sel]), value_type(track.getZ())});
+  }
+  // do final step till target R, also covers Bz = 0;
+  value_type xfin;
+  if (!track.getXatLabR(r, xfin, bz)) {
+    return false;
+  }
+  return propagateToX(track, xfin, bzOnly, maxSnp, maxStep, matCorr, tofInfo, signCorr);
+}
+
 //_______________________________________________________________________
 template <typename value_T>
 template <typename track_T>
@@ -772,6 +868,35 @@ GPUd() void PropagatorImpl<value_T>::getFieldXYZImpl(const math_utils::Point3D<T
   }
 }
 
+template <typename value_T>
+template <typename T>
+GPUd() T PropagatorImpl<value_T>::getBzImpl(const math_utils::Point3D<T> xyz) const
+{
+  T bz = 0;
+  if (mGPUField) {
+#if defined(GPUCA_GPUCODE_DEVICE) && defined(GPUCA_HAS_GLOBAL_SYMBOL_CONSTANT_MEM)
+    const auto* f = &GPUCA_CONSMEM.param.polynomialField; // Access directly from constant memory on GPU (copied here to avoid complicated header dependencies)
+#else
+    const auto* f = mGPUField;
+#endif
+    constexpr value_type kCLight1 = 1. / o2::gpu::gpu_common_constants::kCLight;
+    bz = f->GetFieldBz(xyz.X(), xyz.Y(), xyz.Z()) * kCLight1;
+  } else {
+#ifndef GPUCA_GPUCODE
+    if (mFieldFast) {
+      mFieldFast->GetBz(xyz, bz); // Must not call the host-only function in GPU compilation
+    } else {
+#ifdef GPUCA_STANDALONE
+      LOG(fatal) << "Normal field cannot be used in standalone benchmark";
+#else
+      bz = mField->GetBz(xyz.X(), xyz.Y(), xyz.Z());
+#endif
+    }
+#endif
+  }
+  return bz;
+}
+
 template <typename value_T>
 GPUd() void PropagatorImpl<value_T>::getFieldXYZ(const math_utils::Point3D<float> xyz, float* bxyz) const
 {
@@ -784,12 +909,26 @@ GPUd() void PropagatorImpl<value_T>::getFieldXYZ(const math_utils::Point3D<doubl
   getFieldXYZImpl<double>(xyz, bxyz);
 }
 
+template <typename value_T>
+GPUd() float PropagatorImpl<value_T>::getBz(const math_utils::Point3D<float> xyz) const
+{
+  return getBzImpl<float>(xyz);
+}
+
+template <typename value_T>
+GPUd() double PropagatorImpl<value_T>::getBz(const math_utils::Point3D<double> xyz) const
+{
+  return getBzImpl<double>(xyz);
+}
+
 namespace o2::base
 {
 #if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.
 template class PropagatorImpl<float>;
 template bool GPUdni() PropagatorImpl<float>::propagateToAlphaX<PropagatorImpl<float>::TrackPar_t>(PropagatorImpl<float>::TrackPar_t&, float, float, bool, float, float, int, PropagatorImpl<float>::MatCorrType matCorr, track::TrackLTIntegral*, int) const;
 template bool GPUdni() PropagatorImpl<float>::propagateToAlphaX<PropagatorImpl<float>::TrackParCov_t>(PropagatorImpl<float>::TrackParCov_t&, float, float, bool, float, float, int, PropagatorImpl<float>::MatCorrType matCorr, track::TrackLTIntegral*, int) const;
+template bool GPUdni() PropagatorImpl<float>::propagateToR<PropagatorImpl<float>::TrackPar_t>(PropagatorImpl<float>::TrackPar_t&, float, bool, float, float, PropagatorImpl<float>::MatCorrType matCorr, track::TrackLTIntegral*, int) const;
+template bool GPUdni() PropagatorImpl<float>::propagateToR<PropagatorImpl<float>::TrackParCov_t>(PropagatorImpl<float>::TrackParCov_t&, float, bool, float, float, PropagatorImpl<float>::MatCorrType matCorr, track::TrackLTIntegral*, int) const;
 #endif
 #ifndef GPUCA_GPUCODE
 template class PropagatorImpl<double>;
diff --git a/Detectors/Vertexing/include/DetectorsVertexing/FwdDCAFitterN.h b/Detectors/Vertexing/include/DetectorsVertexing/FwdDCAFitterN.h
index cd1742e24fa72..d5bc6631575af 100644
--- a/Detectors/Vertexing/include/DetectorsVertexing/FwdDCAFitterN.h
+++ b/Detectors/Vertexing/include/DetectorsVertexing/FwdDCAFitterN.h
@@ -20,7 +20,7 @@
 #include "MathUtils/Cartesian.h"
 #include "ReconstructionDataFormats/TrackFwd.h"
 #include "ReconstructionDataFormats/Track.h"
-#include "DCAFitter/HelixHelper.h"
+#include "ReconstructionDataFormats/HelixHelper.h"
 #include <TRandom.h>
 #include "DetectorsBase/Propagator.h"
 #include "DetectorsBase/GeometryManager.h"
diff --git a/Detectors/Vertexing/include/DetectorsVertexing/HelixHelper.h b/Detectors/Vertexing/include/DetectorsVertexing/HelixHelper.h
index 72066250f1053..d197cba256c0e 100644
--- a/Detectors/Vertexing/include/DetectorsVertexing/HelixHelper.h
+++ b/Detectors/Vertexing/include/DetectorsVertexing/HelixHelper.h
@@ -30,18 +30,18 @@ namespace track
 struct TrackAuxPar : public o2::math_utils::CircleXYf_t {
   float c, s, cc, ss, cs; // cos ans sin of track alpha and their products
 
-  TrackAuxPar() = default;
+  GPUdDefault() TrackAuxPar() = default;
 
   template <typename T>
-  TrackAuxPar(const T& trc, float bz)
+  GPUd() TrackAuxPar(const T& trc, float bz)
   {
     set(trc, bz);
   }
-  float cosDif(const TrackAuxPar& t) const { return c * t.c + s * t.s; } // cos(alpha_this - alha_t)
-  float sinDif(const TrackAuxPar& t) const { return s * t.c - c * t.s; } // sin(alpha_this - alha_t)
+  GPUd() float cosDif(const TrackAuxPar& t) const { return c * t.c + s * t.s; } // cos(alpha_this - alha_t)
+  GPUd() float sinDif(const TrackAuxPar& t) const { return s * t.c - c * t.s; } // sin(alpha_this - alha_t)
 
   template <typename T>
-  void set(const T& trc, float bz)
+  GPUd() void set(const T& trc, float bz)
   {
     trc.getCircleParams(bz, *this, s, c);
     cc = c * c;
@@ -59,13 +59,14 @@ struct CrossInfo {
   float yDCA[2] = {};
   int nDCA = 0;
 
-  int circlesCrossInfo(const TrackAuxPar& trax0, const TrackAuxPar& trax1, float maxDistXY = MaxDistXYDef)
+  GPUd() int circlesCrossInfo(const TrackAuxPar& trax0, const TrackAuxPar& trax1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
   {
     const auto& trcA = trax0.rC > trax1.rC ? trax0 : trax1; // designate the largest circle as A
     const auto& trcB = trax0.rC > trax1.rC ? trax1 : trax0;
+    nDCA = 0;
     float xDist = trcB.xC - trcA.xC, yDist = trcB.yC - trcA.yC;
-    float dist2 = xDist * xDist + yDist * yDist, dist = std::sqrt(dist2), rsum = trcA.rC + trcB.rC;
-    if (std::abs(dist) < 1e-12) {
+    float dist2 = xDist * xDist + yDist * yDist, dist = o2::gpu::GPUCommonMath::Sqrt(dist2), rsum = trcA.rC + trcB.rC;
+    if (dist < 1e-12) {
       return nDCA; // circles are concentric?
     }
     if (dist > rsum) { // circles don't touch, chose a point in between
@@ -74,18 +75,32 @@ struct CrossInfo {
       if (dist - rsum > maxDistXY) { // too large distance
         return nDCA;
       }
-      notTouchingXY(dist, xDist, yDist, trcA, trcB.rC);
-    } else if (dist + trcB.rC < trcA.rC) { // the small circle is nestled into large one w/o touching
-      // select the point of closest approach of 2 circles
-      notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC);
+      notTouchingXY(dist, xDist, yDist, trcA, trcB.rC, isCollinear);
+    } else if (auto dfr = dist + trcB.rC - trcA.rC; dfr < 0.) { // the small circle is nestled into large one w/o touching
+      if (dfr > -maxDistXY) {
+        // select the point of closest approach of 2 circles
+        notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC, isCollinear);
+      } else {
+        return nDCA;
+      }
     } else { // 2 intersection points
-      // to simplify calculations, we move to new frame x->x+Xc0, y->y+Yc0, so that
-      // the 1st one is centered in origin
-      if (std::abs(xDist) < std::abs(yDist)) {
+      if (isCollinear) {
+        /// collinear tracks, e.g. electrons from photon conversion
+        /// if there are 2 crossings of the circle it is better to take
+        /// a weighted average of the crossing points as a radius
+        float r2r = trcA.rC + trcB.rC;
+        float r1_r = trcA.rC / r2r;
+        float r2_r = trcB.rC / r2r;
+        xDCA[0] = r2_r * trcA.xC + r1_r * trcB.xC;
+        yDCA[0] = r2_r * trcA.yC + r1_r * trcB.yC;
+        nDCA = 1;
+      } else if (o2::gpu::GPUCommonMath::Abs(xDist) < o2::gpu::GPUCommonMath::Abs(yDist)) {
+        // to simplify calculations, we move to new frame x->x+Xc0, y->y+Yc0, so that
+        // the 1st one is centered in origin
         float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * yDist), b = -xDist / yDist, ab = a * b, bb = b * b;
         float det = ab * ab - (1. + bb) * (a * a - trcA.rC * trcA.rC);
         if (det > 0.) {
-          det = std::sqrt(det);
+          det = o2::gpu::GPUCommonMath::Sqrt(det);
           xDCA[0] = (-ab + det) / (1. + b * b);
           yDCA[0] = a + b * xDCA[0] + trcA.yC;
           xDCA[0] += trcA.xC;
@@ -100,7 +115,7 @@ struct CrossInfo {
         float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * xDist), b = -yDist / xDist, ab = a * b, bb = b * b;
         float det = ab * ab - (1. + bb) * (a * a - trcA.rC * trcA.rC);
         if (det > 0.) {
-          det = std::sqrt(det);
+          det = o2::gpu::GPUCommonMath::Sqrt(det);
           yDCA[0] = (-ab + det) / (1. + bb);
           xDCA[0] = a + b * yDCA[0] + trcA.xC;
           yDCA[0] += trcA.yC;
@@ -116,23 +131,33 @@ struct CrossInfo {
     return nDCA;
   }
 
-  void notTouchingXY(float dist, float xDist, float yDist, const TrackAuxPar& trcA, float rBSign)
+  GPUd() void notTouchingXY(float dist, float xDist, float yDist, const TrackAuxPar& trcA, float rBSign, bool isCollinear = false)
   {
-    // fast method to calculate DCA between 2 circles, assuming that they don't touch each outer:
-    // the parametric equation of lines connecting the centers is x = xA + t/dist * xDist, y = yA + t/dist * yDist
-    // with xA,yY being the center of the circle A ( = trcA.xC, trcA.yC ), xDist = trcB.xC = trcA.xC ...
-    // There are 2 special cases:
-    // (a) small circle is inside the large one: provide rBSign as -trcB.rC
-    // (b) circle are side by side: provide rBSign as trcB.rC
+    if (isCollinear) {
+      /// for collinear tracks it is better to take
+      /// a weighted average of the crossing points as a radius
+      float r2r = trcA.rC + rBSign;
+      float r1_r = trcA.rC / r2r;
+      float r2_r = rBSign / r2r;
+      xDCA[0] = r2_r * trcA.xC + r1_r * (xDist + trcA.xC);
+      yDCA[0] = r2_r * trcA.yC + r1_r * (yDist + trcA.yC);
+    } else {
+      // fast method to calculate DCA between 2 circles, assuming that they don't touch each outer:
+      // the parametric equation of lines connecting the centers is x = xA + t/dist * xDist, y = yA + t/dist * yDist
+      // with xA,yY being the center of the circle A ( = trcA.xC, trcA.yC ), xDist = trcB.xC = trcA.xC ...
+      // There are 2 special cases:
+      // (a) small circle is inside the large one: provide rBSign as -trcB.rC
+      // (b) circle are side by side: provide rBSign as trcB.rC
+      auto t2d = (dist + trcA.rC - rBSign) / dist;
+      xDCA[0] = trcA.xC + 0.5 * (xDist * t2d);
+      yDCA[0] = trcA.yC + 0.5 * (yDist * t2d);
+    }
     nDCA = 1;
-    auto t2d = (dist + trcA.rC - rBSign) / dist;
-    xDCA[0] = trcA.xC + 0.5 * (xDist * t2d);
-    yDCA[0] = trcA.yC + 0.5 * (yDist * t2d);
   }
 
   template <typename T>
-  int linesCrossInfo(const TrackAuxPar& trax0, const T& tr0,
-                     const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
+  GPUd() int linesCrossInfo(const TrackAuxPar& trax0, const T& tr0,
+                            const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
   {
     /// closest approach of 2 straight lines
     ///  TrackParam propagation can be parameterized in lab in a form
@@ -147,19 +172,19 @@ struct CrossInfo {
     ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
     ///  zL(t) = zL + t Kz;  Kz = tgl / csp
     ///  Note that Kx^2 + Ky^2 + Kz^2 = (1+tgl^2) / csp^2
-
+    nDCA = 0;
     float dx = trax1.xC - trax0.xC; // for straight line TrackAuxPar stores lab coordinates at referene point!!!
     float dy = trax1.yC - trax0.yC; //
     float dz = tr1.getZ() - tr0.getZ();
     auto csp0i2 = 1. / tr0.getCsp2(); // 1 / csp^2
-    auto csp0i = std::sqrt(csp0i2);
+    auto csp0i = o2::gpu::GPUCommonMath::Sqrt(csp0i2);
     auto tgp0 = tr0.getSnp() * csp0i;
     float kx0 = trax0.c - trax0.s * tgp0;
     float ky0 = trax0.s + trax0.c * tgp0;
     float kz0 = tr0.getTgl() * csp0i;
     auto csp1i2 = 1. / tr1.getCsp2(); // 1 / csp^2
-    auto csp1i = std::sqrt(csp1i2);
-    auto tgp1 = tr1.getSnp() * std::sqrt(csp1i2);
+    auto csp1i = o2::gpu::GPUCommonMath::Sqrt(csp1i2);
+    auto tgp1 = tr1.getSnp() * o2::gpu::GPUCommonMath::Sqrt(csp1i2);
     float kx1 = trax1.c - trax1.s * tgp1;
     float ky1 = trax1.s + trax1.c * tgp1;
     float kz1 = tr1.getTgl() * csp1i;
@@ -174,7 +199,7 @@ struct CrossInfo {
     float a00 = (1.f + tr0.getTgl() * tr0.getTgl()) * csp0i2, a11 = (1.f + tr1.getTgl() * tr1.getTgl()) * csp1i2, a01 = -(kx0 * kx1 + ky0 * ky1 + kz0 * kz1);
     float b0 = dx * kx0 + dy * ky0 + dz * kz0, b1 = -(dx * kx1 + dy * ky1 + dz * kz1);
     float det = a00 * a11 - a01 * a01, det0 = b0 * a11 - b1 * a01, det1 = a00 * b1 - a01 * b0;
-    if (std::abs(det) > o2::constants::math::Almost0) {
+    if (o2::gpu::GPUCommonMath::Sqrt(det) > o2::constants::math::Almost0) {
       auto detI = 1. / det;
       auto t0 = det0 * detI;
       auto t1 = det1 * detI;
@@ -192,8 +217,8 @@ struct CrossInfo {
   }
 
   template <typename T>
-  int circleLineCrossInfo(const TrackAuxPar& trax0, const T& tr0,
-                          const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
+  GPUd() int circleLineCrossInfo(const TrackAuxPar& trax0, const T& tr0,
+                                 const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
   {
     /// closest approach of line and circle
     ///  TrackParam propagation can be parameterized in lab in a form
@@ -218,14 +243,14 @@ struct CrossInfo {
     float dy = traxL.yC - traxH.yC; // Y...
     // t^2(kx^2+ky^2) + 2t(dx*kx+dy*ky) + dx^2 + dy^2 - r^2 = 0
     auto cspi2 = 1. / trcL.getCsp2(); // 1 / csp^2 == kx^2 +  ky^2
-    auto cspi = std::sqrt(cspi2);
+    auto cspi = o2::gpu::GPUCommonMath::Sqrt(cspi2);
     auto tgp = trcL.getSnp() * cspi;
     float kx = traxL.c - traxL.s * tgp;
     float ky = traxL.s + traxL.c * tgp;
     double dk = dx * kx + dy * ky;
     double det = dk * dk - cspi2 * (dx * dx + dy * dy - traxH.rC * traxH.rC);
     if (det > 0) { // 2 crossings
-      det = std::sqrt(det);
+      det = o2::gpu::GPUCommonMath::Sqrt(det);
       float t0 = (-dk + det) * cspi2;
       float t1 = (-dk - det) * cspi2;
       xDCA[0] = traxL.xC + kx * t0;
@@ -236,8 +261,8 @@ struct CrossInfo {
     } else {
       // there is no crossing, find the point of the closest approach on the line which is closest to the circle center
       float t = -dk * cspi2;
-      float xL = traxL.xC + kx * t, yL = traxL.yC + ky * t;                                               // point on the line, need to average with point on the circle
-      float dxc = xL - traxH.xC, dyc = yL - traxH.yC, dist = std::sqrt(dxc * dxc + dyc * dyc);
+      float xL = traxL.xC + kx * t, yL = traxL.yC + ky * t; // point on the line, need to average with point on the circle
+      float dxc = xL - traxH.xC, dyc = yL - traxH.yC, dist = o2::gpu::GPUCommonMath::Sqrt(dxc * dxc + dyc * dyc);
       if (dist - traxH.rC > maxDistXY) { // too large distance
         return nDCA;
       }
@@ -251,12 +276,12 @@ struct CrossInfo {
   }
 
   template <typename T>
-  int set(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
+  GPUd() int set(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
   {
     // calculate up to 2 crossings between 2 circles
     nDCA = 0;
     if (trax0.rC > o2::constants::math::Almost0 && trax1.rC > o2::constants::math::Almost0) { // both are not straight lines
-      nDCA = circlesCrossInfo(trax0, trax1, maxDistXY);
+      nDCA = circlesCrossInfo(trax0, trax1, maxDistXY, isCollinear);
     } else if (trax0.rC < o2::constants::math::Almost0 && trax1.rC < o2::constants::math::Almost0) { // both are straigt lines
       nDCA = linesCrossInfo(trax0, tr0, trax1, tr1, maxDistXY);
     } else {
@@ -266,12 +291,12 @@ struct CrossInfo {
     return nDCA;
   }
 
-  CrossInfo() = default;
+  GPUdDefault() CrossInfo() = default;
 
   template <typename T>
-  CrossInfo(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
+  GPUd() CrossInfo(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
   {
-    set(trax0, tr0, trax1, tr1, maxDistXY);
+    set(trax0, tr0, trax1, tr1, maxDistXY, isCollinear);
   }
   ClassDefNV(CrossInfo, 1);
 };

From 774014b283c517ed6a273f3397cbbf4c4330c48a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 29 Sep 2025 17:51:21 +0400
Subject: [PATCH 0879/1764] Temporarily keep reduntant HelixHelper in DCAFitter
 and DetectorsVertexing for O2Physics

---
 .../DCAFitter/include/DCAFitter/HelixHelper.h | 307 ++++++++++++++++++
 1 file changed, 307 insertions(+)
 create mode 100644 Common/DCAFitter/include/DCAFitter/HelixHelper.h

diff --git a/Common/DCAFitter/include/DCAFitter/HelixHelper.h b/Common/DCAFitter/include/DCAFitter/HelixHelper.h
new file mode 100644
index 0000000000000..d197cba256c0e
--- /dev/null
+++ b/Common/DCAFitter/include/DCAFitter/HelixHelper.h
@@ -0,0 +1,307 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file HelixHelper.h
+/// \brief Helper classes for helical tracks manipulations
+/// \author ruben.shahoyan@cern.ch
+
+#ifndef _ALICEO2_HELIX_HELPER_
+#define _ALICEO2_HELIX_HELPER_
+
+#include "CommonConstants/MathConstants.h"
+#include "MathUtils/Utils.h"
+#include "MathUtils/Primitive2D.h"
+
+namespace o2
+{
+namespace track
+{
+
+///__________________________________________________________________________
+//< precalculated track radius, center, alpha sin,cos and their combinations
+struct TrackAuxPar : public o2::math_utils::CircleXYf_t {
+  float c, s, cc, ss, cs; // cos ans sin of track alpha and their products
+
+  GPUdDefault() TrackAuxPar() = default;
+
+  template <typename T>
+  GPUd() TrackAuxPar(const T& trc, float bz)
+  {
+    set(trc, bz);
+  }
+  GPUd() float cosDif(const TrackAuxPar& t) const { return c * t.c + s * t.s; } // cos(alpha_this - alha_t)
+  GPUd() float sinDif(const TrackAuxPar& t) const { return s * t.c - c * t.s; } // sin(alpha_this - alha_t)
+
+  template <typename T>
+  GPUd() void set(const T& trc, float bz)
+  {
+    trc.getCircleParams(bz, *this, s, c);
+    cc = c * c;
+    ss = s * s;
+    cs = c * s;
+  }
+  ClassDefNV(TrackAuxPar, 1);
+};
+
+//__________________________________________________________
+//< crossing coordinates of 2 circles
+struct CrossInfo {
+  static constexpr float MaxDistXYDef = 10.;
+  float xDCA[2] = {};
+  float yDCA[2] = {};
+  int nDCA = 0;
+
+  GPUd() int circlesCrossInfo(const TrackAuxPar& trax0, const TrackAuxPar& trax1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
+  {
+    const auto& trcA = trax0.rC > trax1.rC ? trax0 : trax1; // designate the largest circle as A
+    const auto& trcB = trax0.rC > trax1.rC ? trax1 : trax0;
+    nDCA = 0;
+    float xDist = trcB.xC - trcA.xC, yDist = trcB.yC - trcA.yC;
+    float dist2 = xDist * xDist + yDist * yDist, dist = o2::gpu::GPUCommonMath::Sqrt(dist2), rsum = trcA.rC + trcB.rC;
+    if (dist < 1e-12) {
+      return nDCA; // circles are concentric?
+    }
+    if (dist > rsum) { // circles don't touch, chose a point in between
+      // the parametric equation of lines connecting the centers is
+      // x = x0 + t/dist * (x1-x0), y = y0 + t/dist * (y1-y0)
+      if (dist - rsum > maxDistXY) { // too large distance
+        return nDCA;
+      }
+      notTouchingXY(dist, xDist, yDist, trcA, trcB.rC, isCollinear);
+    } else if (auto dfr = dist + trcB.rC - trcA.rC; dfr < 0.) { // the small circle is nestled into large one w/o touching
+      if (dfr > -maxDistXY) {
+        // select the point of closest approach of 2 circles
+        notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC, isCollinear);
+      } else {
+        return nDCA;
+      }
+    } else { // 2 intersection points
+      if (isCollinear) {
+        /// collinear tracks, e.g. electrons from photon conversion
+        /// if there are 2 crossings of the circle it is better to take
+        /// a weighted average of the crossing points as a radius
+        float r2r = trcA.rC + trcB.rC;
+        float r1_r = trcA.rC / r2r;
+        float r2_r = trcB.rC / r2r;
+        xDCA[0] = r2_r * trcA.xC + r1_r * trcB.xC;
+        yDCA[0] = r2_r * trcA.yC + r1_r * trcB.yC;
+        nDCA = 1;
+      } else if (o2::gpu::GPUCommonMath::Abs(xDist) < o2::gpu::GPUCommonMath::Abs(yDist)) {
+        // to simplify calculations, we move to new frame x->x+Xc0, y->y+Yc0, so that
+        // the 1st one is centered in origin
+        float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * yDist), b = -xDist / yDist, ab = a * b, bb = b * b;
+        float det = ab * ab - (1. + bb) * (a * a - trcA.rC * trcA.rC);
+        if (det > 0.) {
+          det = o2::gpu::GPUCommonMath::Sqrt(det);
+          xDCA[0] = (-ab + det) / (1. + b * b);
+          yDCA[0] = a + b * xDCA[0] + trcA.yC;
+          xDCA[0] += trcA.xC;
+          xDCA[1] = (-ab - det) / (1. + b * b);
+          yDCA[1] = a + b * xDCA[1] + trcA.yC;
+          xDCA[1] += trcA.xC;
+          nDCA = 2;
+        } else { // due to the finite precision the det<=0, i.e. the circles are barely touching, fall back to this special case
+          notTouchingXY(dist, xDist, yDist, trcA, trcB.rC);
+        }
+      } else {
+        float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * xDist), b = -yDist / xDist, ab = a * b, bb = b * b;
+        float det = ab * ab - (1. + bb) * (a * a - trcA.rC * trcA.rC);
+        if (det > 0.) {
+          det = o2::gpu::GPUCommonMath::Sqrt(det);
+          yDCA[0] = (-ab + det) / (1. + bb);
+          xDCA[0] = a + b * yDCA[0] + trcA.xC;
+          yDCA[0] += trcA.yC;
+          yDCA[1] = (-ab - det) / (1. + bb);
+          xDCA[1] = a + b * yDCA[1] + trcA.xC;
+          yDCA[1] += trcA.yC;
+          nDCA = 2;
+        } else { // due to the finite precision the det<=0, i.e. the circles are barely touching, fall back to this special case
+          notTouchingXY(dist, xDist, yDist, trcA, trcB.rC);
+        }
+      }
+    }
+    return nDCA;
+  }
+
+  GPUd() void notTouchingXY(float dist, float xDist, float yDist, const TrackAuxPar& trcA, float rBSign, bool isCollinear = false)
+  {
+    if (isCollinear) {
+      /// for collinear tracks it is better to take
+      /// a weighted average of the crossing points as a radius
+      float r2r = trcA.rC + rBSign;
+      float r1_r = trcA.rC / r2r;
+      float r2_r = rBSign / r2r;
+      xDCA[0] = r2_r * trcA.xC + r1_r * (xDist + trcA.xC);
+      yDCA[0] = r2_r * trcA.yC + r1_r * (yDist + trcA.yC);
+    } else {
+      // fast method to calculate DCA between 2 circles, assuming that they don't touch each outer:
+      // the parametric equation of lines connecting the centers is x = xA + t/dist * xDist, y = yA + t/dist * yDist
+      // with xA,yY being the center of the circle A ( = trcA.xC, trcA.yC ), xDist = trcB.xC = trcA.xC ...
+      // There are 2 special cases:
+      // (a) small circle is inside the large one: provide rBSign as -trcB.rC
+      // (b) circle are side by side: provide rBSign as trcB.rC
+      auto t2d = (dist + trcA.rC - rBSign) / dist;
+      xDCA[0] = trcA.xC + 0.5 * (xDist * t2d);
+      yDCA[0] = trcA.yC + 0.5 * (yDist * t2d);
+    }
+    nDCA = 1;
+  }
+
+  template <typename T>
+  GPUd() int linesCrossInfo(const TrackAuxPar& trax0, const T& tr0,
+                            const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
+  {
+    /// closest approach of 2 straight lines
+    ///  TrackParam propagation can be parameterized in lab in a form
+    ///  xLab(t) = (x*cosAlp - y*sinAlp) + t*(cosAlp - sinAlp* snp/csp) = xLab0 + t*(cosAlp - sinAlp* snp/csp)
+    ///  yLab(t) = (x*sinAlp + y*cosAlp) + t*(sinAlp + cosAlp* snp/csp) = yLab0 + t*(sinAlp + cosAlp* snp/csp)
+    ///  zLab(t) = z + t * tgl / csp = zLab0 + t * tgl / csp
+    ///  where t is the x-step in the track alpha-frame, xLab,yLab,zLab are reference track coordinates in lab
+    ///  frame (filled by TrackAuxPar for straight line tracks).
+    ///
+    ///  Therefore, for the parametric track equation in lab 3D we have (wrt tracking-X increment t)
+    ///  xL(t) = xL + t Kx;  Kx = (cosAlp - sinAlp* snp/csp)
+    ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
+    ///  zL(t) = zL + t Kz;  Kz = tgl / csp
+    ///  Note that Kx^2 + Ky^2 + Kz^2 = (1+tgl^2) / csp^2
+    nDCA = 0;
+    float dx = trax1.xC - trax0.xC; // for straight line TrackAuxPar stores lab coordinates at referene point!!!
+    float dy = trax1.yC - trax0.yC; //
+    float dz = tr1.getZ() - tr0.getZ();
+    auto csp0i2 = 1. / tr0.getCsp2(); // 1 / csp^2
+    auto csp0i = o2::gpu::GPUCommonMath::Sqrt(csp0i2);
+    auto tgp0 = tr0.getSnp() * csp0i;
+    float kx0 = trax0.c - trax0.s * tgp0;
+    float ky0 = trax0.s + trax0.c * tgp0;
+    float kz0 = tr0.getTgl() * csp0i;
+    auto csp1i2 = 1. / tr1.getCsp2(); // 1 / csp^2
+    auto csp1i = o2::gpu::GPUCommonMath::Sqrt(csp1i2);
+    auto tgp1 = tr1.getSnp() * o2::gpu::GPUCommonMath::Sqrt(csp1i2);
+    float kx1 = trax1.c - trax1.s * tgp1;
+    float ky1 = trax1.s + trax1.c * tgp1;
+    float kz1 = tr1.getTgl() * csp1i;
+    /// Minimize |vecL1 - vecL0|^2 wrt t0 and t1: point of closest approach
+    /// Leads to system
+    /// A Dx = B with Dx = {dx0, dx1}
+    /// with A =
+    ///  |      kx0^2+ky0^2+kz0^2     -(kx0*kx1+ky0*ky1+kz0*kz1) | =  (1+tgl0^2) / csp0^2           ....
+    ///  | -(kx0*kx1+ky0*ky1+kz0*kz1)     kx0^2+ky0^2+kz0^2      |     .....                   (1+tgl1^2) / csp1^2
+    /// and B = {(dx Kx0 + dy Ky0 + dz Kz0), -(dx Kx1 + dy Ky1 + dz Kz1) }
+    ///
+    float a00 = (1.f + tr0.getTgl() * tr0.getTgl()) * csp0i2, a11 = (1.f + tr1.getTgl() * tr1.getTgl()) * csp1i2, a01 = -(kx0 * kx1 + ky0 * ky1 + kz0 * kz1);
+    float b0 = dx * kx0 + dy * ky0 + dz * kz0, b1 = -(dx * kx1 + dy * ky1 + dz * kz1);
+    float det = a00 * a11 - a01 * a01, det0 = b0 * a11 - b1 * a01, det1 = a00 * b1 - a01 * b0;
+    if (o2::gpu::GPUCommonMath::Sqrt(det) > o2::constants::math::Almost0) {
+      auto detI = 1. / det;
+      auto t0 = det0 * detI;
+      auto t1 = det1 * detI;
+      float addx0 = kx0 * t0, addy0 = ky0 * t0, addx1 = kx1 * t1, addy1 = ky1 * t1;
+      dx += addx1 - addx0; // recalculate XY distance at DCA
+      dy += addy1 - addy0;
+      if (dx * dx + dy * dy > maxDistXY * maxDistXY) {
+        return nDCA;
+      }
+      xDCA[0] = (trax0.xC + addx0 + trax1.xC + addx1) * 0.5;
+      yDCA[0] = (trax0.yC + addy0 + trax1.yC + addy1) * 0.5;
+      nDCA = 1;
+    }
+    return nDCA;
+  }
+
+  template <typename T>
+  GPUd() int circleLineCrossInfo(const TrackAuxPar& trax0, const T& tr0,
+                                 const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
+  {
+    /// closest approach of line and circle
+    ///  TrackParam propagation can be parameterized in lab in a form
+    ///  xLab(t) = (x*cosAlp - y*sinAlp) + t*(cosAlp - sinAlp* snp/csp) = xLab0 + t*(cosAlp - sinAlp* snp/csp)
+    ///  yLab(t) = (x*sinAlp + y*cosAlp) + t*(sinAlp + cosAlp* snp/csp) = yLab0 + t*(sinAlp + cosAlp* snp/csp)
+    ///  zLab(t) = z + t * tgl / csp = zLab0 + t * tgl / csp
+    ///  where t is the x-step in the track alpha-frame, xLab,yLab,zLab are reference track coordinates in lab
+    ///  frame (filled by TrackAuxPar for straight line tracks).
+    ///
+    ///  Therefore, for the parametric track equation in lab 3D we have (wrt tracking-X increment t)
+    ///  xL(t) = xL + t Kx;  Kx = (cosAlp - sinAlp* snp/csp)
+    ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
+    ///  zL(t) = zL + t Kz;  Kz = tgl / csp
+    ///  Note that Kx^2 + Ky^2  = 1 / csp^2
+
+    const auto& traxH = trax0.rC > trax1.rC ? trax0 : trax1; // circle (for the line rC is set to 0)
+    const auto& traxL = trax0.rC > trax1.rC ? trax1 : trax0; // line
+    const auto& trcL = trax0.rC > trax1.rC ? tr1 : tr0;      // track of the line
+
+    // solve quadratic equation of line crossing the circle
+    float dx = traxL.xC - traxH.xC; // X distance between the line lab reference and circle center
+    float dy = traxL.yC - traxH.yC; // Y...
+    // t^2(kx^2+ky^2) + 2t(dx*kx+dy*ky) + dx^2 + dy^2 - r^2 = 0
+    auto cspi2 = 1. / trcL.getCsp2(); // 1 / csp^2 == kx^2 +  ky^2
+    auto cspi = o2::gpu::GPUCommonMath::Sqrt(cspi2);
+    auto tgp = trcL.getSnp() * cspi;
+    float kx = traxL.c - traxL.s * tgp;
+    float ky = traxL.s + traxL.c * tgp;
+    double dk = dx * kx + dy * ky;
+    double det = dk * dk - cspi2 * (dx * dx + dy * dy - traxH.rC * traxH.rC);
+    if (det > 0) { // 2 crossings
+      det = o2::gpu::GPUCommonMath::Sqrt(det);
+      float t0 = (-dk + det) * cspi2;
+      float t1 = (-dk - det) * cspi2;
+      xDCA[0] = traxL.xC + kx * t0;
+      yDCA[0] = traxL.yC + ky * t0;
+      xDCA[1] = traxL.xC + kx * t1;
+      yDCA[1] = traxL.yC + ky * t1;
+      nDCA = 2;
+    } else {
+      // there is no crossing, find the point of the closest approach on the line which is closest to the circle center
+      float t = -dk * cspi2;
+      float xL = traxL.xC + kx * t, yL = traxL.yC + ky * t; // point on the line, need to average with point on the circle
+      float dxc = xL - traxH.xC, dyc = yL - traxH.yC, dist = o2::gpu::GPUCommonMath::Sqrt(dxc * dxc + dyc * dyc);
+      if (dist - traxH.rC > maxDistXY) { // too large distance
+        return nDCA;
+      }
+      float drcf = traxH.rC / dist; // radius / distance to circle center
+      float xH = traxH.xC + dxc * drcf, yH = traxH.yC + dyc * drcf;
+      xDCA[0] = (xL + xH) * 0.5;
+      yDCA[0] = (yL + yH) * 0.5;
+      nDCA = 1;
+    }
+    return nDCA;
+  }
+
+  template <typename T>
+  GPUd() int set(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
+  {
+    // calculate up to 2 crossings between 2 circles
+    nDCA = 0;
+    if (trax0.rC > o2::constants::math::Almost0 && trax1.rC > o2::constants::math::Almost0) { // both are not straight lines
+      nDCA = circlesCrossInfo(trax0, trax1, maxDistXY, isCollinear);
+    } else if (trax0.rC < o2::constants::math::Almost0 && trax1.rC < o2::constants::math::Almost0) { // both are straigt lines
+      nDCA = linesCrossInfo(trax0, tr0, trax1, tr1, maxDistXY);
+    } else {
+      nDCA = circleLineCrossInfo(trax0, tr0, trax1, tr1, maxDistXY);
+    }
+    //
+    return nDCA;
+  }
+
+  GPUdDefault() CrossInfo() = default;
+
+  template <typename T>
+  GPUd() CrossInfo(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
+  {
+    set(trax0, tr0, trax1, tr1, maxDistXY, isCollinear);
+  }
+  ClassDefNV(CrossInfo, 1);
+};
+
+} // namespace track
+} // namespace o2
+
+#endif

From 0b91842e5277c0524d0d4a7f5508db5972b6a7c7 Mon Sep 17 00:00:00 2001
From: Fabrizio <fabrizio.grosa@cern.ch>
Date: Tue, 30 Sep 2025 08:31:39 +0200
Subject: [PATCH 0880/1764] Add possibility to apply signal filtering for MC
 with embedding (#14698)

* Add possibility to apply signal filtering for MC with embedding
* Add protection for signal filtering to be enabled only with emdedding
---
 .../AODProducerWorkflowSpec.h                 |  1 +
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 44 +++++++++++++++----
 2 files changed, 36 insertions(+), 9 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 62b99e98f990d..615a7f96de13e 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -256,6 +256,7 @@ class AODProducerWorkflowDPL : public Task
 
   int mNThreads = 1;
   bool mUseMC = true;
+  bool mUseSigFiltMC = false; // enable signal filtering for MC with embedding
   bool mEnableSV = true; // enable secondary vertices
   bool mEnableFITextra = false;
   bool mFieldON = false;
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 90cf420bc9bf6..b841943b05031 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -947,13 +947,17 @@ void clearMCKeepStore(std::vector<std::vector<std::unordered_map<int, int>>>& st
 }
 
 // helper function to add a particle/track to the MC keep store
-void keepMCParticle(std::vector<std::vector<std::unordered_map<int, int>>>& store, int source, int event, int track, int value = 1)
+void keepMCParticle(std::vector<std::vector<std::unordered_map<int, int>>>& store, int source, int event, int track, int value = 1, bool useSigFilt = false)
 {
   if (track < 0) {
     LOG(warn) << "trackID is smaller than 0. Neglecting";
     return;
   }
-  store[source][event][track] = value;
+  if (useSigFilt && source == 0) {
+    store[source][event][track] = -1;
+  } else {
+    store[source][event][track] = value;
+  }
 }
 
 void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader& mcReader,
@@ -982,7 +986,7 @@ void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader&
     if (!mcLabel.isValid()) {
       return;
     }
-    keepMCParticle(mToStore, mcLabel.getSourceID(), mcLabel.getEventID(), mcLabel.getTrackID());
+    keepMCParticle(mToStore, mcLabel.getSourceID(), mcLabel.getEventID(), mcLabel.getTrackID(), 1, mUseSigFiltMC);
   };
 
   // mark reconstructed MC particles to store them into the table
@@ -997,7 +1001,7 @@ void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader&
           if (!mcTruth.isValid()) {
             continue;
           }
-          keepMCParticle(mToStore, mcTruth.getSourceID(), mcTruth.getEventID(), mcTruth.getTrackID());
+          keepMCParticle(mToStore, mcTruth.getSourceID(), mcTruth.getEventID(), mcTruth.getTrackID(), 1, mUseSigFiltMC);
           // treating contributors of global tracks
           auto contributorsGID = data.getSingleDetectorRefs(trackIndex);
           if (contributorsGID[GIndex::Source::TPC].isIndexSet()) {
@@ -1012,7 +1016,7 @@ void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader&
               if (!mcLabel.isValid()) {
                 continue;
               }
-              keepMCParticle(mToStore, mcLabel.getSourceID(), mcLabel.getEventID(), mcLabel.getTrackID());
+              keepMCParticle(mToStore, mcLabel.getSourceID(), mcLabel.getEventID(), mcLabel.getTrackID(), 1, mUseSigFiltMC);
             }
           }
         }
@@ -1026,7 +1030,7 @@ void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader&
       if (!mcTruth.isValid()) {
         continue;
       }
-      keepMCParticle(mToStore, mcTruth.getSourceID(), mcTruth.getEventID(), mcTruth.getTrackID());
+      keepMCParticle(mToStore, mcTruth.getSourceID(), mcTruth.getEventID(), mcTruth.getTrackID(), 1, mUseSigFiltMC);
     }
   }
   if (mInputSources[GIndex::PHS]) {
@@ -1035,7 +1039,7 @@ void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader&
       if (!mcTruth.isValid()) {
         continue;
       }
-      keepMCParticle(mToStore, mcTruth.getSourceID(), mcTruth.getEventID(), mcTruth.getTrackID());
+      keepMCParticle(mToStore, mcTruth.getSourceID(), mcTruth.getEventID(), mcTruth.getTrackID(), 1, mUseSigFiltMC);
     }
   }
   using namespace aodmchelpers;
@@ -1743,6 +1747,8 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
     LOG(info) << "The Run number will be obtained from DPL headers";
   }
 
+  mUseSigFiltMC = ic.options().get<bool>("mc-signal-filt");
+
   // set no truncation if selected by user
   if (mTruncate != 1) {
     LOG(info) << "Truncation is not used!";
@@ -2061,6 +2067,24 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
     int totalNParts = 0;
     for (int iCol = 0; iCol < nMCCollisions; iCol++) {
       totalNParts += mcParts[iCol].size();
+
+      // if signal filtering enabled, let's check if there are more than one source; otherwise fatalise
+      if (mUseSigFiltMC) {
+        std::vector<int> sourceIDs{};
+        auto& colParts = mcParts[iCol];
+        for (auto colPart : colParts) {
+          int sourceID = colPart.sourceID;
+          if (std::find(sourceIDs.begin(), sourceIDs.end(), sourceID) == sourceIDs.end()) {
+            sourceIDs.push_back(sourceID);
+          }
+          if (sourceIDs.size() > 1) { // we found more than one, exit
+            break;
+          }
+        }
+        if (sourceIDs.size() <= 1) {
+          LOGP(fatal, "Signal filtering cannot be enabled without embedding. Please fix the configuration either enabling the embedding, or turning off the signal filtering.");
+        }
+      }
     }
     mcCollisionsCursor.reserve(totalNParts);
 
@@ -2098,7 +2122,9 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
                          0,
                          sourceID);
         }
-        mcColToEvSrc.emplace_back(std::vector<int>{iCol, sourceID, eventID}); // point background and injected signal events to one collision
+        if (sourceID != 0 || !mUseSigFiltMC) {
+          mcColToEvSrc.emplace_back(std::vector<int>{iCol, sourceID, eventID}); // point background and injected signal events to one collision
+        }
       }
     }
   }
@@ -3326,7 +3352,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"trackqc-tpc-pt", VariantType::Float, 0.2f, {"Keep TPC standalone track with this pt"}},
       ConfigParamSpec{"with-streamers", VariantType::String, "", {"Bit-mask to steer writing of intermediate streamer files"}},
       ConfigParamSpec{"seed", VariantType::Int, 0, {"Set seed for random generator used for sampling (0 (default) means using a random_device)"}},
-    }};
+      ConfigParamSpec{"mc-signal-filt", VariantType::Bool, false, {"Enable usage of signal filtering (only for MC with embedding)"}}}};
 }
 
 } // namespace o2::aodproducer

From 7948f41542b1e8e61162b8077e8842ba77176b59 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 25 Sep 2025 11:31:50 +0200
Subject: [PATCH 0881/1764] DPL Analysis: write HistogramRegistry incrementally

This should reduce big spikes at the end of the processing when a large
HistogramRegistry is serialised.
---
 .../AnalysisSupport/src/AODWriterHelpers.cxx  | 137 ++++++++++++------
 .../Core/include/Framework/AnalysisManagers.h |   6 +-
 .../include/Framework/HistogramRegistry.h     |  14 +-
 .../Core/include/Framework/OutputObjHeader.h  |   2 +
 Framework/Core/src/HistogramRegistry.cxx      |  94 +++---------
 .../TestWorkflows/src/o2TestHistograms.cxx    |  46 ++++++
 6 files changed, 167 insertions(+), 132 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index 475e65bf9212b..27dad43480913 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -22,14 +22,20 @@
 #include "Framework/DataOutputDirector.h"
 #include "Framework/TableTreeHelpers.h"
 #include "Framework/Monitoring.h"
+#include "Framework/Signpost.h"
 
 #include <Monitoring/Monitoring.h>
+#include <TDirectory.h>
 #include <TFile.h>
 #include <TFile.h>
 #include <TTree.h>
 #include <TMap.h>
 #include <TObjString.h>
 #include <arrow/table.h>
+#include <chrono>
+#include <ios>
+
+O2_DECLARE_DYNAMIC_LOG(histogram_registry);
 
 namespace o2::framework::writers
 {
@@ -46,6 +52,7 @@ struct InputObjectRoute {
 struct InputObject {
   TClass* kind = nullptr;
   void* obj = nullptr;
+  std::string container;
   std::string name;
   int count = -1;
 };
@@ -273,24 +280,30 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
     callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
     return [inputObjects, objmap, tskmap](ProcessingContext& pc) mutable -> void {
       auto mergePart = [&inputObjects, &objmap, &tskmap, &pc](DataRef const& ref) {
+        O2_SIGNPOST_ID_GENERATE(hid, histogram_registry);
+        O2_SIGNPOST_START(histogram_registry, hid, "mergePart", "Merging histogram");
         if (!ref.header) {
-          LOG(error) << "Header not found";
+          O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "mergePart", "Header not found.");
           return;
         }
         auto datah = o2::header::get<o2::header::DataHeader*>(ref.header);
         if (!datah) {
-          LOG(error) << "No data header in stack";
+          O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "mergePart", "No data header in stack");
           return;
         }
 
         if (!ref.payload) {
-          LOGP(error, "Payload not found for {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
+          O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "mergePart", "Payload not found for %{public}s/%{public}s/%d",
+                                     datah->dataOrigin.as<std::string>().c_str(), datah->dataDescription.as<std::string>().c_str(),
+                                     datah->subSpecification);
           return;
         }
 
         auto objh = o2::header::get<o2::framework::OutputObjHeader*>(ref.header);
         if (!objh) {
-          LOGP(error, "No output object header in stack of {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
+          O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "mergePart", "No output object header in stack of %{public}s/%{public}s/%d.",
+                                     datah->dataOrigin.as<std::string>().c_str(), datah->dataDescription.as<std::string>().c_str(),
+                                     datah->subSpecification);
           return;
         }
 
@@ -300,48 +313,73 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
         obj.kind = tm.ReadClass();
         tm.SetBufferOffset(0);
         tm.ResetMap();
+        O2_SIGNPOST_ID_GENERATE(did, histogram_registry);
+        O2_SIGNPOST_START(histogram_registry, did, "initialising root", "Starting deserialization of %{public}s/%{public}s/%d",
+                          datah->dataOrigin.as<std::string>().c_str(), datah->dataDescription.as<std::string>().c_str(),
+                          datah->subSpecification);
         if (obj.kind == nullptr) {
-          LOGP(error, "Cannot read class info from buffer of {}/{}/{}", datah->dataOrigin.as<std::string>(), datah->dataDescription.as<std::string>(), datah->subSpecification);
+          O2_SIGNPOST_END(histogram_registry, did, "initialising root", "Failed to deserialise");
+          O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "mergePart", "Cannot read class info from buffer of %{public}s/%{public}s/%d.",
+                                     datah->dataOrigin.as<std::string>().c_str(), datah->dataDescription.as<std::string>().c_str(),
+                                     datah->subSpecification);
           return;
         }
+        O2_SIGNPOST_END(histogram_registry, did, "initialising root", "Done init.");
 
         auto policy = objh->mPolicy;
         auto sourceType = objh->mSourceType;
         auto hash = objh->mTaskHash;
+        O2_SIGNPOST_START(histogram_registry, did, "deserialization", "Starting deserialization of %{public}s/%{public}s/%d",
+                          datah->dataOrigin.as<std::string>().c_str(), datah->dataDescription.as<std::string>().c_str(),
+                          datah->subSpecification);
 
         obj.obj = tm.ReadObjectAny(obj.kind);
         auto* named = static_cast<TNamed*>(obj.obj);
         obj.name = named->GetName();
+        O2_SIGNPOST_END(histogram_registry, did, "deserialization", "Done deserialization.");
+        // If we have a folder, we assume the first element of the path
+        // to be the name of the registry.
+        if (sourceType == HistogramRegistrySource) {
+          obj.container = objh->containerName;
+        } else {
+          obj.container = obj.name;
+        }
         auto hpos = std::find_if(tskmap.begin(), tskmap.end(), [&](auto&& x) { return x.id == hash; });
         if (hpos == tskmap.end()) {
-          LOG(error) << "No task found for hash " << hash;
+          O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "mergePart", "No task found for hash %d.", hash);
           return;
         }
         auto taskname = hpos->name;
         auto opos = std::find_if(objmap.begin(), objmap.end(), [&](auto&& x) { return x.id == hash; });
         if (opos == objmap.end()) {
-          LOG(error) << "No object list found for task " << taskname << " (hash=" << hash << ")";
+          O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "mergePart", "No object list found for task %{public}s (hash=%d).",
+                                     taskname.c_str(), hash);
           return;
         }
         auto objects = opos->bindings;
-        if (std::find(objects.begin(), objects.end(), obj.name) == objects.end()) {
-          LOG(error) << "No object " << obj.name << " in map for task " << taskname;
+        if (std::find(objects.begin(), objects.end(), obj.container) == objects.end()) {
+          O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "mergePart", "No container %{public}s in map for task %{public}s.",
+                                     obj.container.c_str(), taskname.c_str());
           return;
         }
         auto nameHash = runtime_hash(obj.name.c_str());
         InputObjectRoute key{obj.name, nameHash, taskname, hash, policy, sourceType};
         auto existing = std::find_if(inputObjects->begin(), inputObjects->end(), [&](auto&& x) { return (x.first.uniqueId == nameHash) && (x.first.taskHash == hash); });
         // If it's the first one, we just add it to the list.
+        O2_SIGNPOST_START(histogram_registry, did, "merging", "Starting merging of %{public}s/%{public}s/%d",
+                          datah->dataOrigin.as<std::string>().c_str(), datah->dataDescription.as<std::string>().c_str(),
+                          datah->subSpecification);
         if (existing == inputObjects->end()) {
           obj.count = objh->mPipelineSize;
-          inputObjects->push_back(std::make_pair(key, obj));
+          inputObjects->emplace_back(key, obj);
           existing = inputObjects->end() - 1;
         } else {
           obj.count = existing->second.count;
           // Otherwise, we merge it with the existing one.
           auto merger = existing->second.kind->GetMerge();
           if (!merger) {
-            LOG(error) << "Already one unmergeable object found for " << obj.name;
+            O2_SIGNPOST_END(histogram_registry, did, "merging", "Unabled to merge");
+            O2_SIGNPOST_END_WITH_ERROR(histogram_registry, hid, "merging", "Already one unmergeable object found for %{public}s", obj.name.c_str());
             return;
           }
           TList coll;
@@ -353,15 +391,22 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
         existing->second.count -= 1;
 
         if (existing->second.count != 0) {
+          O2_SIGNPOST_END(histogram_registry, did, "merging", "Done partial merging.");
+          O2_SIGNPOST_END(histogram_registry, hid, "mergePart", "Pipeline lanes still missing.");
           return;
         }
+        O2_SIGNPOST_END(histogram_registry, did, "merging", "Done merging.");
         // Write the object here.
         auto route = existing->first;
         auto entry = existing->second;
         auto file = ROOTfileNames.find(route.policy);
         if (file == ROOTfileNames.end()) {
+          O2_SIGNPOST_END(histogram_registry, hid, "mergePart", "Not matching any file.");
           return;
         }
+        O2_SIGNPOST_START(histogram_registry, did, "writing", "Starting writing of %{public}s/%{public}s/%d",
+                          datah->dataOrigin.as<std::string>().c_str(), datah->dataDescription.as<std::string>().c_str(),
+                          datah->subSpecification);
         auto filename = file->second;
         if (f[route.policy] == nullptr) {
           f[route.policy] = TFile::Open(filename.c_str(), "RECREATE");
@@ -375,53 +420,53 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
           currentFile = filename;
         }
 
-        // translate the list-structure created by the registry into a directory structure within the file
-        std::function<void(TList*, TDirectory*)> writeListToFile;
-        writeListToFile = [&](TList* list, TDirectory* parentDir) {
-          TIter next(list);
-          TObject* object = nullptr;
-          while ((object = next())) {
-            if (object->InheritsFrom(TList::Class())) {
-              writeListToFile(static_cast<TList*>(object), parentDir->mkdir(object->GetName(), object->GetName(), true));
+        // FIXME: handle folders
+        f[route.policy]->cd("/");
+        auto* currentDir = f[route.policy]->GetDirectory(currentDirectory.c_str());
+        // The name contains a path...
+        int objSize = 0;
+        if (sourceType == HistogramRegistrySource) {
+          TDirectory* currentFolder = currentDir;
+          O2_SIGNPOST_EVENT_EMIT(histogram_registry, hid, "mergePart", "Toplevel folder is %{public}s.",
+                                 currentDir->GetName());
+          std::string objName = entry.name;
+          auto lastSlash = entry.name.rfind('/');
+
+          if (lastSlash != std::string::npos) {
+            auto dirname = entry.name.substr(0, lastSlash);
+            objName = entry.name.substr(lastSlash + 1);
+            currentFolder = currentDir->GetDirectory(dirname.c_str());
+            if (!currentFolder) {
+              O2_SIGNPOST_EVENT_EMIT(histogram_registry, hid, "mergePart", "Creating folder %{public}s",
+                                     dirname.c_str());
+              currentFolder = currentDir->mkdir(dirname.c_str(), "", kTRUE);
             } else {
-              int objSize = parentDir->WriteObjectAny(object, object->Class(), object->GetName());
-              static int maxSizeWritten = 0;
-              if (objSize > maxSizeWritten) {
-                auto& monitoring = pc.services().get<Monitoring>();
-                maxSizeWritten = objSize;
-                monitoring.send(Metric{fmt::format("{}/{}:{}", object->ClassName(), object->GetName(), objSize), "aod-largest-object-written"}.addTag(tags::Key::Subsystem, tags::Value::DPL));
-              }
-              auto* written = list->Remove(object);
-              delete written;
+              O2_SIGNPOST_EVENT_EMIT(histogram_registry, hid, "mergePart", "Folder %{public}s already there.",
+                                     currentFolder->GetName());
             }
           }
-        };
-
-        TDirectory* currentDir = f[route.policy]->GetDirectory(currentDirectory.c_str());
-        if (route.sourceType == OutputObjSourceType::HistogramRegistrySource) {
-          auto* outputList = static_cast<TList*>(entry.obj);
-          outputList->SetOwner(false);
-
-          // if registry should live in dedicated folder a TNamed object is appended to the list
-          if (outputList->Last() && outputList->Last()->IsA() == TNamed::Class()) {
-            delete outputList->Last();
-            outputList->RemoveLast();
-            currentDir = currentDir->mkdir(outputList->GetName(), outputList->GetName(), true);
-          }
-
-          writeListToFile(outputList, currentDir);
-          outputList->SetOwner();
-          delete outputList;
+          O2_SIGNPOST_EVENT_EMIT(histogram_registry, hid, "mergePart", "Writing %{public}s of kind %{public}s in %{public}s",
+                                 entry.name.c_str(), entry.kind->GetName(), currentDir->GetName());
+          objSize = currentFolder->WriteObjectAny(entry.obj, entry.kind, objName.c_str());
+          O2_SIGNPOST_END(histogram_registry, did, "writing", "End writing %{public}s", entry.name.c_str());
+          delete (TObject*)entry.obj;
           entry.obj = nullptr;
         } else {
-          currentDir->WriteObjectAny(entry.obj, entry.kind, entry.name.c_str());
+          O2_SIGNPOST_EVENT_EMIT(histogram_registry, hid, "mergePart", "Writing %{public}s of kind %{public}s in %{public}s",
+                                 entry.name.c_str(), entry.kind->GetName(), currentDir->GetName());
+          objSize = currentDir->WriteObjectAny(entry.obj, entry.kind, entry.name.c_str());
+          O2_SIGNPOST_END(histogram_registry, did, "writing", "End writing %{public}s", entry.name.c_str());
           delete (TObject*)entry.obj;
           entry.obj = nullptr;
         }
+        O2_SIGNPOST_END(histogram_registry, hid, "mergePart", "Done merging object of %d bytes.", objSize);
       };
+      O2_SIGNPOST_ID_GENERATE(rid, histogram_registry);
+      O2_SIGNPOST_START(histogram_registry, rid, "processParts", "Start merging %zu parts received together.", pc.inputs().getNofParts(0));
       for (int pi = 0; pi < pc.inputs().getNofParts(0); ++pi) {
         mergePart(pc.inputs().get("x", pi));
       }
+      O2_SIGNPOST_END(histogram_registry, rid, "processParts", "Done histograms in multipart message.");
     };
   }};
 }
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 6c43bf3eebebb..596f3da6a557a 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -11,6 +11,7 @@
 
 #ifndef FRAMEWORK_ANALYSISMANAGERS_H
 #define FRAMEWORK_ANALYSISMANAGERS_H
+#include "DataAllocator.h"
 #include "Framework/AnalysisHelpers.h"
 #include "Framework/DataSpecUtils.h"
 #include "Framework/GroupedCombinations.h"
@@ -247,7 +248,10 @@ template <is_histogram_registry T>
 bool postRunOutput(EndOfStreamContext& context, T& hr)
 {
   auto& deviceSpec = context.services().get<o2::framework::DeviceSpec const>();
-  context.outputs().snapshot(hr.ref(deviceSpec.inputTimesliceId, deviceSpec.maxInputTimeslices), *(hr.getListOfHistograms()));
+  auto sendHistos = [deviceSpec, &context](HistogramRegistry const& self, TNamed* obj) mutable {
+    context.outputs().snapshot(self.ref(deviceSpec.inputTimesliceId, deviceSpec.maxInputTimeslices), *obj);
+  };
+  hr.apply(sendHistos);
   hr.clean();
   return true;
 }
diff --git a/Framework/Core/include/Framework/HistogramRegistry.h b/Framework/Core/include/Framework/HistogramRegistry.h
index 6db4bd0a2d0e2..49ef006f84a79 100644
--- a/Framework/Core/include/Framework/HistogramRegistry.h
+++ b/Framework/Core/include/Framework/HistogramRegistry.h
@@ -173,16 +173,15 @@ class HistogramRegistry
   template <typename T>
   std::shared_ptr<T> operator()(const HistName& histName);
 
+  // Apply @a callback on every single entry in the registry
+  void apply(std::function<void(HistogramRegistry const&, TNamed* named)> callback) const;
   // return the OutputSpec associated to the HistogramRegistry
   OutputSpec const spec();
 
-  OutputRef ref(uint16_t idx, uint16_t pipelineSize);
+  OutputRef ref(uint16_t idx, uint16_t pipelineSize) const;
 
   void setHash(uint32_t hash);
 
-  /// returns the list of histograms, properly sorted for writing.
-  TList* getListOfHistograms();
-
   /// deletes all the histograms from the registry
   void clean();
 
@@ -220,16 +219,13 @@ class HistogramRegistry
 
   // helper function to find the histogram position in the registry
   template <typename T>
-  uint32_t getHistIndex(const T& histName);
+  uint32_t getHistIndex(const T& histName) const;
 
   constexpr uint32_t imask(uint32_t i) const
   {
     return i & REGISTRY_BITMASK;
   }
 
-  // helper function to create resp. find the subList defined by path
-  TList* getSubList(TList* list, std::deque<std::string>& path);
-
   // helper function to split user defined path/to/hist/name string
   std::deque<std::string> splitPath(const std::string& pathAndNameUser);
 
@@ -431,7 +427,7 @@ std::shared_ptr<T> HistogramRegistry::operator()(const HistName& histName)
 }
 
 template <typename T>
-uint32_t HistogramRegistry::getHistIndex(const T& histName)
+uint32_t HistogramRegistry::getHistIndex(const T& histName) const
 {
   if (O2_BUILTIN_LIKELY(histName.hash == mRegistryKey[histName.idx])) {
     return histName.idx;
diff --git a/Framework/Core/include/Framework/OutputObjHeader.h b/Framework/Core/include/Framework/OutputObjHeader.h
index 6e665bb697572..f1c284d564f15 100644
--- a/Framework/Core/include/Framework/OutputObjHeader.h
+++ b/Framework/Core/include/Framework/OutputObjHeader.h
@@ -44,6 +44,8 @@ struct OutputObjHeader : public BaseHeader {
   uint32_t mTaskHash;
   uint16_t mPipelineIndex = 0;
   uint16_t mPipelineSize = 1;
+  // Name of the actual container for the object, e.g. the HistogramRegistry name
+  char containerName[64] = {0};
 
   constexpr OutputObjHeader()
     : BaseHeader(sizeof(OutputObjHeader), sHeaderType, sSerializationMethod, sVersion),
diff --git a/Framework/Core/src/HistogramRegistry.cxx b/Framework/Core/src/HistogramRegistry.cxx
index 0a0cc1fc3a690..5e39fbe7181e7 100644
--- a/Framework/Core/src/HistogramRegistry.cxx
+++ b/Framework/Core/src/HistogramRegistry.cxx
@@ -51,9 +51,12 @@ OutputSpec const HistogramRegistry::spec()
   return OutputSpec{OutputLabel{mName}, "ATSK", desc, 0, Lifetime::QA};
 }
 
-OutputRef HistogramRegistry::ref(uint16_t pipelineIndex, uint16_t pipelineSize)
+OutputRef HistogramRegistry::ref(uint16_t pipelineIndex, uint16_t pipelineSize) const
 {
-  return OutputRef{std::string{mName}, 0, o2::header::Stack{OutputObjHeader{mPolicy, OutputObjSourceType::HistogramRegistrySource, mTaskHash, pipelineIndex, pipelineSize}}};
+  OutputObjHeader header{mPolicy, OutputObjSourceType::HistogramRegistrySource, mTaskHash, pipelineIndex, pipelineSize};
+  // Copy the name of the registry to the haeder.
+  strncpy(header.containerName, mName.data(), 64);
+  return OutputRef{std::string{mName}, 0, o2::header::Stack{header}};
 }
 
 void HistogramRegistry::setHash(uint32_t hash)
@@ -282,87 +285,26 @@ void HistogramRegistry::print(bool showAxisDetails)
   LOGF(info, "");
 }
 
-// create output structure will be propagated to file-sink
-TList* HistogramRegistry::getListOfHistograms()
+void HistogramRegistry::apply(std::function<void(HistogramRegistry const&, TNamed* named)> callback) const
 {
-  TList* list = new TList();
-  list->SetName(mName.data());
-
+  // Keep the list sorted as originally done to avoid hidden dependency on the order, for now , for now.
+  auto finalList = mRegisteredNames;
+  auto caseInsensitiveCompare = [](const std::string& s1, const std::string& s2) {
+    return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
+                                        [](char c1, char c2) { return std::tolower(static_cast<unsigned char>(c1)) < std::tolower(static_cast<unsigned char>(c2)); });
+  };
   if (mSortHistos) {
-    auto caseInsensitiveCompare = [](const std::string& s1, const std::string& s2) {
-      return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
-                                          [](char c1, char c2) { return std::tolower(static_cast<unsigned char>(c1)) < std::tolower(static_cast<unsigned char>(c2)); });
-    };
-    std::sort(mRegisteredNames.begin(), mRegisteredNames.end(), caseInsensitiveCompare);
+    std::sort(finalList.begin(), finalList.end(), caseInsensitiveCompare);
   }
-
-  for (auto& curHistName : mRegisteredNames) {
+  for (auto& curHistName : finalList) {
     TNamed* rawPtr = nullptr;
     std::visit([&](const auto& sharedPtr) { rawPtr = (TNamed*)sharedPtr.get(); }, mRegistryValue[getHistIndex(HistName{curHistName.data()})]);
-    if (rawPtr) {
-      std::deque<std::string> path = splitPath(rawPtr->GetName());
-      std::string name = path.back();
-      path.pop_back();
-      TList* targetList{getSubList(list, path)};
-      if (targetList) {
-        rawPtr->SetName(name.data());
-        targetList->Add(rawPtr);
-      } else {
-        LOGF(fatal, "Specified subfolder could not be created.");
-      }
-    }
-  }
-
-  // place lists always at the top
-  std::function<void(TList*)> moveListsToTop;
-  moveListsToTop = [&](TList* list) {
-    TIter next(list);
-    TNamed* subList = nullptr;
-    std::vector<TObject*> subLists;
-    while ((subList = (TNamed*)next())) {
-      if (subList->InheritsFrom(TList::Class())) {
-        subLists.push_back(subList);
-        moveListsToTop((TList*)subList);
-      }
-    }
-    std::reverse(subLists.begin(), subLists.end());
-    for (auto curList : subLists) {
-      list->Remove(curList);
-      list->AddFirst(curList);
-    }
-  };
-  moveListsToTop(list);
-
-  // create dedicated directory containing all of the registrys histograms
-  if (mCreateRegistryDir) {
-    // propagate this to the writer by adding a 'flag' to the output list
-    list->AddLast(new TNamed("createFolder", ""));
-  }
-  return list;
-}
-
-// helper function to create resp. find the subList defined by path
-TList* HistogramRegistry::getSubList(TList* list, std::deque<std::string>& path)
-{
-  if (path.empty()) {
-    return list;
-  }
-  TList* targetList{nullptr};
-  std::string nextList = path[0];
-  path.pop_front();
-  if (auto subList = (TList*)list->FindObject(nextList.data())) {
-    if (subList->InheritsFrom(TList::Class())) {
-      targetList = getSubList((TList*)subList, path);
-    } else {
-      return nullptr;
+    if (!rawPtr) {
+      // Skipping empty histograms
+      continue;
     }
-  } else {
-    subList = new TList();
-    subList->SetName(nextList.data());
-    list->Add(subList);
-    targetList = getSubList(subList, path);
+    callback(*this, rawPtr);
   }
-  return targetList;
 }
 
 // helper function to split user defined path/to/hist/name string
diff --git a/Framework/TestWorkflows/src/o2TestHistograms.cxx b/Framework/TestWorkflows/src/o2TestHistograms.cxx
index 61710e1f63d5f..ae3610ca01e67 100644
--- a/Framework/TestWorkflows/src/o2TestHistograms.cxx
+++ b/Framework/TestWorkflows/src/o2TestHistograms.cxx
@@ -43,6 +43,16 @@ struct EtaAndClsHistogramsSimple {
   Configurable<std::string> trackFilterString{"track-filter", "o2::aod::track::pt < 10.f", "Track filter string"};
   Filter trackFilter = o2::aod::track::pt < 10.f;
 
+  HistogramRegistry registry{
+    "registry",
+    {
+      {"a/b/eta", "#Eta", {HistType::kTH1F, {{100, -2.0, 2.0}}}},                          //
+      {"a/phi", "#Phi", {HistType::kTH1D, {{102, 0, 2 * M_PI}}}},                          //
+      {"c/pt", "p_{T}", {HistType::kTH1D, {{1002, -0.01, 50.1}}}},                         //
+      {"ptToPt", "#ptToPt", {HistType::kTH2F, {{100, -0.01, 10.01}, {100, -0.01, 10.01}}}} //
+    } //
+  };
+
   void init(InitContext&)
   {
     if (!trackFilterString->empty()) {
@@ -56,6 +66,11 @@ struct EtaAndClsHistogramsSimple {
     for (auto& track : tracks) {
       etaClsH->Fill(track.eta(), track.pt());
       skimEx(track.pt(), track.eta());
+
+      registry.fill(HIST("a/b/eta"), track.eta());
+      registry.fill(HIST("a/phi"), track.phi());
+      registry.fill(HIST("c/pt"), track.pt());
+      registry.fill(HIST("ptToPt"), track.pt(), track.signed1Pt());
     }
   }
 };
@@ -66,6 +81,16 @@ struct EtaAndClsHistogramsIUSimple {
   Configurable<std::string> trackFilterString{"track-filter", "o2::aod::track::pt < 10.f", "Track filter string"};
   Filter trackFilter = o2::aod::track::pt < 10.f;
 
+  HistogramRegistry registry{
+    "registry",
+    {
+      {"a/b/eta", "#Eta", {HistType::kTH1F, {{100, -2.0, 2.0}}}},                          //
+      {"a/phi", "#Phi", {HistType::kTH1D, {{102, 0, 2 * M_PI}}}},                          //
+      {"c/pt", "p_{T}", {HistType::kTH1D, {{1002, -0.01, 50.1}}}},                         //
+      {"ptToPt", "#ptToPt", {HistType::kTH2F, {{100, -0.01, 10.01}, {100, -0.01, 10.01}}}} //
+    } //
+  };
+
   void init(InitContext&)
   {
     if (!trackFilterString->empty()) {
@@ -79,12 +104,28 @@ struct EtaAndClsHistogramsIUSimple {
     for (auto& track : tracks) {
       etaClsH->Fill(track.eta(), track.pt());
       skimEx(track.pt(), track.eta());
+
+      registry.fill(HIST("a/b/eta"), track.eta());
+      registry.fill(HIST("a/phi"), track.phi());
+      registry.fill(HIST("c/pt"), track.pt());
+      registry.fill(HIST("ptToPt"), track.pt(), track.signed1Pt());
     }
   }
 };
 
 struct EtaAndClsHistogramsFull {
   OutputObj<TH3F> etaClsH{TH3F("eta_vs_cls_vs_sigmapT", "#eta vs N_{cls} vs sigma_{1/pT}", 102, -2.01, 2.01, 160, -0.5, 159.5, 100, 0, 10)};
+
+  HistogramRegistry registry{
+    "registry",
+    {
+      {"a/b/eta", "#Eta", {HistType::kTH1F, {{100, -2.0, 2.0}}}},                          //
+      {"a/phi", "#Phi", {HistType::kTH1D, {{102, 0, 2 * M_PI}}}},                          //
+      {"c/pt", "p_{T}", {HistType::kTH1D, {{1002, -0.01, 50.1}}}},                         //
+      {"ptToPt", "#ptToPt", {HistType::kTH2F, {{100, -0.01, 10.01}, {100, -0.01, 10.01}}}} //
+    } //
+  };
+
   Configurable<std::string> trackFilterString{"track-filter", "o2::aod::track::pt < 10.f", "Track filter string"};
   Filter trackFilter = o2::aod::track::pt < 10.f;
 
@@ -100,6 +141,11 @@ struct EtaAndClsHistogramsFull {
     LOGP(info, "Invoking the run 3 one");
     for (auto& track : tracks) {
       etaClsH->Fill(track.eta(), track.tpcNClsFindable(), track.sigma1Pt());
+
+      registry.fill(HIST("a/b/eta"), track.eta());
+      registry.fill(HIST("a/phi"), track.phi());
+      registry.fill(HIST("c/pt"), track.pt());
+      registry.fill(HIST("ptToPt"), track.pt(), track.signed1Pt());
     }
   }
 };

From a36840e3305736bf4b68ed975c138180cfca9eb0 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 30 Sep 2025 13:24:31 +0200
Subject: [PATCH 0882/1764] DPL: fix typo in format

---
 Framework/Core/src/ArrowSupport.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 0e524da280598..a289980349924 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -399,7 +399,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                          }
                          if (forwarded) {
                            O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
-                                                  "Message %{public}.4s/%{public}16.s is forwarded so we are not returning its memory.",
+                                                  "Message %{public}.4s/%{public}.16s is forwarded so we are not returning its memory.",
                                                   dh->dataOrigin.str, dh->dataDescription.str);
                            continue;
                          }

From 2ccb1bb1f682a374111138b6c85752769333908d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 30 Sep 2025 09:21:21 +0200
Subject: [PATCH 0883/1764] DPL: improve debugging of ComputingQuotaEvaluator

* Use signposts rather than debug log.
---
 .../Core/src/ComputingQuotaEvaluator.cxx      | 64 ++++++++++++-------
 1 file changed, 40 insertions(+), 24 deletions(-)

diff --git a/Framework/Core/src/ComputingQuotaEvaluator.cxx b/Framework/Core/src/ComputingQuotaEvaluator.cxx
index 56b7f4a59be88..717a59f5f5372 100644
--- a/Framework/Core/src/ComputingQuotaEvaluator.cxx
+++ b/Framework/Core/src/ComputingQuotaEvaluator.cxx
@@ -13,17 +13,17 @@
 #include "Framework/DataProcessingStats.h"
 #include "Framework/ServiceRegistryRef.h"
 #include "Framework/DeviceState.h"
-#include "Framework/DriverClient.h"
-#include "Framework/Monitoring.h"
-#include "Framework/Logger.h"
+#include "Framework/Signpost.h"
 #include <Monitoring/Monitoring.h>
 
 #include <vector>
 #include <uv.h>
 #include <cassert>
+#include <fmt/core.h>
+#include <fmt/format.h>
+#include <fmt/ranges.h>
 
-#define LOGLEVEL debug
-
+O2_DECLARE_DYNAMIC_LOG(quota);
 
 namespace o2::framework
 {
@@ -64,6 +64,8 @@ struct QuotaEvaluatorStats {
 
 bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const& selector, uint64_t now)
 {
+  O2_SIGNPOST_ID_GENERATE(qid, quota);
+
   auto selectOffer = [&offers = this->mOffers, &infos = this->mInfos, task](int ref, uint64_t now) {
     auto& selected = offers[ref];
     auto& info = infos[ref];
@@ -89,28 +91,36 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
       //      LOG(LOGLEVEL) << "No particular resource was requested, so we schedule task anyways";
       return enough;
     }
+    O2_SIGNPOST_ID_GENERATE(sid, quota);
     if (enough) {
-      LOGP(LOGLEVEL, "{} offers were selected for a total of: cpu {}, memory {}, shared memory {}", result.size(), totalOffer.cpu, totalOffer.memory, totalOffer.sharedMemory);
-      //LOG(LOGLEVEL) << "  The following offers were selected for computation: {} " << fmt::join(result, ", ");
+      O2_SIGNPOST_START(quota, sid, "summary", "%zu offers were selected for a total of: cpu %d, memory %lli, shared memory %lli",
+                        result.size(), totalOffer.cpu, totalOffer.memory, totalOffer.sharedMemory);
+      for (auto& offer : result) {
+        // We pretend each offer id is a pointer, to have a unique id.
+        O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(offer*8));
+        O2_SIGNPOST_START(quota, oid, "offers", "Offer %d has been selected.", offer);
+      }
       dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCES_SATISFACTORY), DataProcessingStats::Op::Add, 1});
     } else {
+      O2_SIGNPOST_START(quota, sid, "summary", "Not enough resources to select offers.");
       dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCES_MISSING), DataProcessingStats::Op::Add, 1});
       if (result.size()) {
         dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCES_INSUFFICIENT), DataProcessingStats::Op::Add, 1});
       }
     }
     if (stats.invalidOffers.size()) {
-    //  LOGP(LOGLEVEL, "  The following offers were invalid: {}", fmt::join(stats.invalidOffers, ", "));
+      O2_SIGNPOST_EVENT_EMIT(quota, sid, "summary", "The following offers were invalid: %s", fmt::format("{}", fmt::join(stats.invalidOffers, ", ")).c_str());
     }
     if (stats.otherUser.size()) {
-     // LOGP(LOGLEVEL, "  The following offers were owned by other users: {}", fmt::join(stats.otherUser, ", "));
+      O2_SIGNPOST_EVENT_EMIT(quota, sid, "summary", "The following offers were owned by other users: %s", fmt::format("{}", fmt::join(stats.otherUser, ", ")).c_str());
     }
     if (stats.expired.size()) {
-     // LOGP(LOGLEVEL, "  The following offers are expired: {}", fmt::join(stats.expired, ", "));
+      O2_SIGNPOST_EVENT_EMIT(quota, sid, "summary", "The following offers are expired: %s", fmt::format("{}", fmt::join(stats.expired, ", ")).c_str());
     }
     if (stats.unexpiring.size() > 1) {
-     // LOGP(LOGLEVEL, "  The following offers will never expire: {}", fmt::join(stats.unexpiring, ", "));
+      O2_SIGNPOST_EVENT_EMIT(quota, sid, "summary", "The following offers will never expire: %s", fmt::format("{}", fmt::join(stats.unexpiring, ", ")).c_str());
     }
+    O2_SIGNPOST_END(quota, sid, "summary", "Done selecting offers.");
 
     return enough;
   };
@@ -139,16 +149,18 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
     if (offer.runtime < 0) {
       stats.unexpiring.push_back(i);
     } else if (offer.runtime + info.received < now) {
-      LOGP(LOGLEVEL, "Offer {} expired since {} milliseconds and holds {}MB", i, now - offer.runtime - info.received, offer.sharedMemory / 1000000);
+      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d expired since %llu milliseconds and holds %llu MB",
+                             i, now - offer.runtime - info.received, offer.sharedMemory / 1000000);
       mExpiredOffers.push_back(ComputingQuotaOfferRef{i});
       stats.expired.push_back(i);
       continue;
     } else {
-      LOGP(LOGLEVEL, "Offer {} still valid for {} milliseconds, providing {}MB", i, offer.runtime + info.received - now, offer.sharedMemory / 1000000);
+      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d still valid for %llu milliseconds, providing %llu MB",
+                             i, offer.runtime + info.received - now, offer.sharedMemory / 1000000);
       if (minValidity == 0) {
         minValidity = offer.runtime + info.received - now;
       }
-      minValidity = std::min(minValidity,(int64_t)(offer.runtime + info.received - now));
+      minValidity = std::min(minValidity, (int64_t)(offer.runtime + info.received - now));
     }
     /// We then check if the offer is suitable
     assert(offer.sharedMemory >= 0);
@@ -177,11 +189,10 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
   }
 
   if (minValidity != 0) {
-    LOGP(LOGLEVEL, "Next offer to expire in {} milliseconds", minValidity);
+    O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Next offer to expire in %llu milliseconds", minValidity);
     uv_timer_start(mTimer, [](uv_timer_t* handle) {
-      LOGP(LOGLEVEL, "Offer should be expired by now, checking again");
-    },
-                   minValidity + 100, 0);
+      O2_SIGNPOST_ID_GENERATE(tid, quota);
+      O2_SIGNPOST_EVENT_EMIT(quota, tid, "select", "Offer should be expired by now, checking again."); }, minValidity + 100, 0);
   }
   // If we get here it means we never got enough offers, so we return false.
   return summarizeWhatHappended(enough, stats.selectedOffers, accumulated, stats);
@@ -213,6 +224,8 @@ void ComputingQuotaEvaluator::dispose(int taskId)
       continue;
     }
     if (offer.sharedMemory <= 0) {
+      O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(oi*8));
+      O2_SIGNPOST_END(quota, oid, "offers", "Offer %d back to not needed.", oi);
       offer.valid = false;
       offer.score = OfferScore::Unneeded;
     }
@@ -242,34 +255,37 @@ void ComputingQuotaEvaluator::updateOffers(std::vector<ComputingQuotaOffer>& pen
 void ComputingQuotaEvaluator::handleExpired(std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats const& stats)> expirator)
 {
   static int nothingToDoCount = mExpiredOffers.size();
+  O2_SIGNPOST_ID_GENERATE(qid, quota);
   if (mExpiredOffers.size()) {
-    LOGP(LOGLEVEL, "Handling {} expired offers", mExpiredOffers.size());
+    O2_SIGNPOST_EVENT_EMIT(quota, qid, "handleExpired", "Handling %zu expired offers", mExpiredOffers.size());
     nothingToDoCount = 0;
   } else {
     if (nothingToDoCount == 0) {
       nothingToDoCount++;
-      LOGP(LOGLEVEL, "No expired offers");
+      O2_SIGNPOST_EVENT_EMIT(quota, qid, "handleExpired", "No expired offers");
     }
   }
   /// Whenever an offer is expired, we give back the resources
   /// to the driver.
   for (auto& ref : mExpiredOffers) {
     auto& offer = mOffers[ref.index];
+    O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(ref.index*8));
     if (offer.sharedMemory < 0) {
-      LOGP(LOGLEVEL, "Offer {} does not have any more memory. Marking it as invalid.", ref.index);
+      O2_SIGNPOST_END(quota, oid, "handleExpired", "Offer %d does not have any more memory. Marking it as invalid.", ref.index);
       offer.valid = false;
       offer.score = OfferScore::Unneeded;
       continue;
     }
     // FIXME: offers should go through the driver client, not the monitoring
     // api.
-    LOGP(LOGLEVEL, "Offer {} expired. Giving back {}MB and {} cores", ref.index, offer.sharedMemory / 1000000, offer.cpu);
+    O2_SIGNPOST_END(quota, oid, "handleExpired", "Offer %d expired. Giving back %llu MB and %d cores",
+                    ref.index, offer.sharedMemory / 1000000, offer.cpu);
     assert(offer.sharedMemory >= 0);
     mStats.totalExpiredBytes += offer.sharedMemory;
     mStats.totalExpiredOffers++;
     expirator(offer, mStats);
-    //driverClient.tell("expired shmem {}", offer.sharedMemory);
-    //driverClient.tell("expired cpu {}", offer.cpu);
+    // driverClient.tell("expired shmem {}", offer.sharedMemory);
+    // driverClient.tell("expired cpu {}", offer.cpu);
     offer.sharedMemory = -1;
     offer.valid = false;
     offer.score = OfferScore::Unneeded;

From 9c914094ae11181f835153bed504141524698c1d Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Tue, 30 Sep 2025 16:56:24 +0200
Subject: [PATCH 0884/1764] GPU: Prevent CUDA 13 from breaking the GPUbenchmark
 (#14706)

* GPU: Prevent CUDA 13 from breaking the GPUbenchmark

Some features are moved out from the `cudaDeviceProp` struct starting from CUDA 13.

* Please consider the following formatting changes (#14707)

* Add cooperativeMultiDevice variable in Kernels.cu

---------

Co-authored-by: ALICE Builder <alibuild@users.noreply.github.com>
---
 GPU/GPUbenchmark/cuda/Kernels.cu | 33 ++++++++++++++++++++++++++------
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/GPU/GPUbenchmark/cuda/Kernels.cu b/GPU/GPUbenchmark/cuda/Kernels.cu
index c309e7b2dbc5d..16dc138ae466f 100644
--- a/GPU/GPUbenchmark/cuda/Kernels.cu
+++ b/GPU/GPUbenchmark/cuda/Kernels.cu
@@ -301,6 +301,21 @@ void printDeviceProp(int32_t deviceId)
   cudaDeviceProp props;
   GPUCHECK(cudaGetDeviceProperties(&props, deviceId));
 
+  int32_t clockRateKHz = 0;
+  int32_t memoryClockRateKHz = 0;
+  int32_t computeMode = 0;
+  int32_t cooperativeMultiDevice = 0;
+
+#if (CUDART_VERSION >= 13000)
+  GPUCHECK(cudaDeviceGetAttribute(&clockRateKHz, cudaDevAttrClockRate, deviceId));
+  GPUCHECK(cudaDeviceGetAttribute(&memoryClockRateKHz, cudaDevAttrMemoryClockRate, deviceId));
+  GPUCHECK(cudaDeviceGetAttribute(&computeMode, cudaDevAttrComputeMode, deviceId));
+#else
+  clockRateKHz = props.clockRate;
+  memoryClockRateKHz = props.memoryClockRate;
+  computeMode = props.computeMode;
+  cooperativeMultiDevice = props.cooperativeMultiDeviceLaunch;
+#endif
   std::cout << std::setw(w1) << "Name: " << props.name << std::endl;
   std::cout << std::setw(w1) << "pciBusID: " << props.pciBusID << std::endl;
   std::cout << std::setw(w1) << "pciDeviceID: " << props.pciDeviceID << std::endl;
@@ -309,11 +324,16 @@ void printDeviceProp(int32_t deviceId)
   std::cout << std::setw(w1) << "maxThreadsPerMultiProcessor: " << props.maxThreadsPerMultiProcessor
             << std::endl;
   std::cout << std::setw(w1) << "isMultiGpuBoard: " << props.isMultiGpuBoard << std::endl;
-  std::cout << std::setw(w1) << "clockRate: " << (float)props.clockRate / 1000.0 << " Mhz" << std::endl;
-  std::cout << std::setw(w1) << "memoryClockRate: " << (float)props.memoryClockRate / 1000.0 << " Mhz"
+
+  // Use the variables we populated above for the moved properties
+  std::cout << std::setw(w1) << "clockRate: " << (float)clockRateKHz / 1000.0 << " Mhz" << std::endl;
+  std::cout << std::setw(w1) << "memoryClockRate: " << (float)memoryClockRateKHz / 1000.0 << " Mhz"
             << std::endl;
+
   std::cout << std::setw(w1) << "memoryBusWidth: " << props.memoryBusWidth << std::endl;
-  std::cout << std::setw(w1) << "clockInstructionRate: " << (float)props.clockRate / 1000.0
+
+  // clockInstructionRate is just another name for clockRate in this context
+  std::cout << std::setw(w1) << "clockInstructionRate: " << (float)clockRateKHz / 1000.0
             << " Mhz" << std::endl;
   std::cout << std::setw(w1) << "totalGlobalMem: " << std::fixed << std::setprecision(2)
             << bytesToGB(props.totalGlobalMem) << " GB" << std::endl;
@@ -332,7 +352,10 @@ void printDeviceProp(int32_t deviceId)
   std::cout << std::setw(w1) << "regsPerBlock: " << props.regsPerBlock << std::endl;
   std::cout << std::setw(w1) << "warpSize: " << props.warpSize << std::endl;
   std::cout << std::setw(w1) << "l2CacheSize: " << props.l2CacheSize << std::endl;
-  std::cout << std::setw(w1) << "computeMode: " << props.computeMode << std::endl;
+
+  // Use the variable for computeMode
+  std::cout << std::setw(w1) << "computeMode: " << computeMode << std::endl;
+
   std::cout << std::setw(w1) << "maxThreadsPerBlock: " << props.maxThreadsPerBlock << std::endl;
   std::cout << std::setw(w1) << "maxThreadsDim.x: " << props.maxThreadsDim[0] << std::endl;
   std::cout << std::setw(w1) << "maxThreadsDim.y: " << props.maxThreadsDim[1] << std::endl;
@@ -343,8 +366,6 @@ void printDeviceProp(int32_t deviceId)
   std::cout << std::setw(w1) << "major: " << props.major << std::endl;
   std::cout << std::setw(w1) << "minor: " << props.minor << std::endl;
   std::cout << std::setw(w1) << "concurrentKernels: " << props.concurrentKernels << std::endl;
-  std::cout << std::setw(w1) << "cooperativeLaunch: " << props.cooperativeLaunch << std::endl;
-  std::cout << std::setw(w1) << "cooperativeMultiDeviceLaunch: " << props.cooperativeMultiDeviceLaunch << std::endl;
 #if defined(__HIPCC__)
   std::cout << std::setw(w1) << "arch.hasGlobalInt32Atomics: " << props.arch.hasGlobalInt32Atomics << std::endl;
   std::cout << std::setw(w1) << "arch.hasGlobalFloatAtomicExch: " << props.arch.hasGlobalFloatAtomicExch

From 875747120550c244ebea3020eb7dc691f6b0c446 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Thu, 25 Sep 2025 10:04:47 +0200
Subject: [PATCH 0885/1764] Demote errors to warnings

---
 Detectors/TPC/workflow/src/IDCToVectorSpec.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx b/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
index 27dbcf5d85bbf..9d704d425f1da 100644
--- a/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
+++ b/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
@@ -405,7 +405,7 @@ class IDCToVectorDevice : public o2::framework::Task
 
       for (const auto& inf : infVec) {
         if (!inf.hasBothEPs()) {
-          LOGP(error, "IDC CRU {:3}: data missing at ({:8}, {:4}) for one or both end points {:02b} in TF {}", cru, inf.heartbeatOrbit, inf.heartbeatBC, inf.epSeen, tfCounter);
+          LOGP(warning, "IDC CRU {:3}: data missing at ({:8}, {:4}) for one or both end points {:02b} in TF {}", cru, inf.heartbeatOrbit, inf.heartbeatBC, inf.epSeen, tfCounter);
           hasErrors = true;
         }
       }
@@ -422,7 +422,7 @@ class IDCToVectorDevice : public o2::framework::Task
       }
 
       if (!std::equal(infVecComp->begin(), infVecComp->end(), infVec.begin())) {
-        LOGP(error, "IDC CRU {:3}: mismatch in orbit numbers", cru);
+        LOGP(warning, "IDC CRU {:3}: mismatch in orbit numbers", cru);
         hasErrors = true;
       }
     }

From 6dce44a0d63142bdda8cd9cb301775ac654d8c1d Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Fri, 6 Jun 2025 11:58:16 +0200
Subject: [PATCH 0886/1764] Extend time gain calibration

- allow for using TPC tracks from global track matches
- use DCA from global track in case global track match is required
- improve method for reading back a previous calibration
---
 Detectors/TPC/calibration/src/CalibdEdx.cxx   |  21 ++-
 Detectors/TPC/workflow/CMakeLists.txt         |   2 +-
 .../include/TPCWorkflow/MIPTrackFilterSpec.h  |   4 +-
 .../TPC/workflow/src/MIPTrackFilterSpec.cxx   | 137 +++++++++++++-----
 .../TPC/workflow/src/tpc-miptrack-filter.cxx  |  17 ++-
 5 files changed, 135 insertions(+), 46 deletions(-)

diff --git a/Detectors/TPC/calibration/src/CalibdEdx.cxx b/Detectors/TPC/calibration/src/CalibdEdx.cxx
index e1081335c04cb..4eb29c8833565 100644
--- a/Detectors/TPC/calibration/src/CalibdEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalibdEdx.cxx
@@ -754,17 +754,28 @@ void CalibdEdx::dumpToFile(const char* outFile)
 
 CalibdEdx CalibdEdx::readFromFile(const char* inFile)
 {
-  TFile f(inFile, "READ");
-  auto* obj = (CalibdEdx*)f.Get("calib");
+  std::unique_ptr<TFile> f(TFile::Open(inFile));
+  if (!f || f->IsZombie()) {
+    LOGP(error, "Could not open file: {}", inFile);
+    CalibdEdx calTmp;
+    return calTmp;
+  }
+
+  auto obj = f->Get<CalibdEdx>("calib");
   if (!obj) {
+    LOGP(error, "Could not read CalibdEdx object from file: {}", inFile);
     CalibdEdx calTmp;
     return calTmp;
   }
+
+  THnF* hTmp = f->Get<THnF>("histogram_data");
+
   CalibdEdx cal(*obj);
-  THnF* hTmp = (THnF*)f.Get("histogram_data");
+  delete obj;
+
   if (!hTmp) {
-    CalibdEdx calTmp;
-    return calTmp;
+    LOGP(warning, "Could not read histogram from file: {}. Returning empty histogram", inFile);
+    return cal;
   }
   cal.setFromRootHist(hTmp);
   return cal;
diff --git a/Detectors/TPC/workflow/CMakeLists.txt b/Detectors/TPC/workflow/CMakeLists.txt
index 48ebb54ac4070..6930f332bfbf1 100644
--- a/Detectors/TPC/workflow/CMakeLists.txt
+++ b/Detectors/TPC/workflow/CMakeLists.txt
@@ -200,7 +200,7 @@ o2_add_executable(idc-test-ft
 o2_add_executable(miptrack-filter
                   COMPONENT_NAME tpc
                   SOURCES src/tpc-miptrack-filter.cxx
-                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow O2::GlobalTrackingWorkflow)
 
 o2_add_executable(track-and-cluster-filter
                   COMPONENT_NAME tpc
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/MIPTrackFilterSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/MIPTrackFilterSpec.h
index 05024baad37b3..45406e6c01bbd 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/MIPTrackFilterSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/MIPTrackFilterSpec.h
@@ -17,6 +17,8 @@
 #define O2_TPC_MIPTRACKFILTERSPEC_H_
 
 #include "Framework/DataProcessorSpec.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+using GID = o2::dataformats::GlobalTrackID;
 
 using namespace o2::framework;
 
@@ -24,7 +26,7 @@ namespace o2::tpc
 {
 
 /// create a processor spec
-o2::framework::DataProcessorSpec getMIPTrackFilterSpec();
+o2::framework::DataProcessorSpec getMIPTrackFilterSpec(GID::mask_t srcTracks = GID::getSourcesMask("TPC"));
 
 } // namespace o2::tpc
 
diff --git a/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx b/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
index 33b9039298264..eff1a694a4727 100644
--- a/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
+++ b/Detectors/TPC/workflow/src/MIPTrackFilterSpec.cxx
@@ -16,7 +16,6 @@
 #include "TPCWorkflow/MIPTrackFilterSpec.h"
 
 #include <algorithm>
-#include <iterator>
 #include <vector>
 #include <memory>
 #include <random>
@@ -24,7 +23,7 @@
 // o2 includes
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTPC/TrackCuts.h"
-#include "DetectorsCalibration/Utils.h"
+#include "Framework/CCDBParamSpec.h"
 #include "Framework/Logger.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "Framework/Task.h"
@@ -33,8 +32,14 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "Headers/DataHeader.h"
+#include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "ReconstructionDataFormats/PrimaryVertex.h"
+#include "DataFormatsCalibration/MeanVertexObject.h"
+#include "ReconstructionDataFormats/VtxTrackRef.h"
 
 using namespace o2::framework;
+using DataRequest = o2::globaltracking::DataRequest;
+using GID = o2::dataformats::GlobalTrackID;
 
 namespace o2::tpc
 {
@@ -42,7 +47,8 @@ namespace o2::tpc
 class MIPTrackFilterDevice : public Task
 {
  public:
-  MIPTrackFilterDevice(std::shared_ptr<o2::base::GRPGeomRequest> gr) : mGRPGeomRequest(gr) {}
+  MIPTrackFilterDevice(std::shared_ptr<o2::base::GRPGeomRequest> gr, std::shared_ptr<DataRequest> dr, GID::mask_t trackSourcesMask)
+    : mGRPGeomRequest(gr), mDataRequest(dr), mTrackSourcesMask(trackSourcesMask) {}
 
   void init(framework::InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -53,16 +59,20 @@ class MIPTrackFilterDevice : public Task
   void sendOutput(DataAllocator& output);
 
   std::shared_ptr<o2::base::GRPGeomRequest> mGRPGeomRequest;
-  TrackCuts mCuts{};                  ///< Tracks cuts object
-  std::vector<TrackTPC> mMIPTracks;   ///< Filtered MIP tracks
-  unsigned int mProcessEveryNthTF{1}; ///< process every Nth TF only
-  int mMaxTracksPerTF{-1};            ///< max number of MIP tracks processed per TF
-  uint32_t mTFCounter{0};             ///< counter to keep track of the TFs
-  int mProcessNFirstTFs{0};           ///< number of first TFs which are not sampled
-  float mDCACut{-1};                  ///< DCA cut
-  bool mSendDummy{false};             ///< send empty data in case TF is skipped
-
-  bool acceptDCA(const TrackTPC& track);
+  std::shared_ptr<DataRequest> mDataRequest;
+  GID::mask_t mTrackSourcesMask;
+  TrackCuts mCuts{};                      ///< Tracks cuts object
+  std::vector<TrackTPC> mMIPTracks;       ///< Filtered MIP tracks
+  o2::dataformats::MeanVertexObject mVtx; ///< Mean vertex object
+  unsigned int mProcessEveryNthTF{1};     ///< process every Nth TF only
+  int mMaxTracksPerTF{-1};                ///< max number of MIP tracks processed per TF
+  uint32_t mTFCounter{0};                 ///< counter to keep track of the TFs
+  int mProcessNFirstTFs{0};               ///< number of first TFs which are not sampled
+  float mDCACut{-1};                      ///< DCA cut
+  float mDCAZCut{-1};                     ///< DCA z cut
+  bool mSendDummy{false};                 ///< send empty data in case TF is skipped
+
+  bool acceptDCA(o2::track::TrackPar propTrack, o2::math_utils::Point3D<float> refPoint, bool useDCAz = false);
 };
 
 void MIPTrackFilterDevice::init(framework::InitContext& ic)
@@ -100,6 +110,7 @@ void MIPTrackFilterDevice::init(framework::InitContext& ic)
   mCuts.setCutLooper(cutLoopers);
 
   mDCACut = ic.options().get<float>("dca-cut");
+  mDCAZCut = ic.options().get<float>("dca-z-cut");
 
   o2::base::GRPGeomHelper::instance().setRequest(mGRPGeomRequest);
 }
@@ -107,6 +118,8 @@ void MIPTrackFilterDevice::init(framework::InitContext& ic)
 void MIPTrackFilterDevice::run(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+  pc.inputs().get<o2::dataformats::MeanVertexObject*>("meanvtx");
+
   const auto currentTF = processing_helpers::getCurrentTF(pc);
   if ((mTFCounter++ % mProcessEveryNthTF) && (currentTF >= mProcessNFirstTFs)) {
     LOGP(info, "Skipping TF {}", currentTF);
@@ -117,19 +130,60 @@ void MIPTrackFilterDevice::run(ProcessingContext& pc)
     return;
   }
 
-  const auto tracks = pc.inputs().get<gsl::span<TrackTPC>>("tracks");
-  const auto nTracks = tracks.size();
+  o2::globaltracking::RecoContainer recoData;
+  recoData.collectData(pc, *mDataRequest);
+  const auto tracksTPC = recoData.getTPCTracks();
+  const auto nTracks = tracksTPC.size();
+
+  // indices to good tracks
+  std::vector<size_t> indices;
+  indices.reserve(nTracks);
+
+  const auto useGlobalTracks = mTrackSourcesMask[GID::ITSTPC];
+  o2::math_utils::Point3D<float> vertex = mVtx.getXYZ();
+
+  if (useGlobalTracks) {
+    auto trackIndex = recoData.getPrimaryVertexMatchedTracks();                      // Global ID's for associated tracks
+    auto vtxRefs = recoData.getPrimaryVertexMatchedTrackRefs();                      // references from vertex to these track IDs
+    std::vector<GID::Source> selSrc{GID::ITSTPC, GID::ITSTPCTRD, GID::ITSTPCTRDTOF}; // for Instance
+    // LOGP(info, "Number of vertex tracks: {}", vtxRefs.size());
+    const auto nv = (vtxRefs.size() > 0) ? vtxRefs.size() - 1 : 0; // note: the last entry groups the tracks which were not related to any vertex, to skip them, use vtxRefs.size()-1
+
+    for (int iv = 0; iv < nv; iv++) {
+      const auto& vtref = vtxRefs[iv];
+      // LOGP(info, "Processing vertex {} with {} tracks", iv, vtref.getEntries());
+      vertex = recoData.getPrimaryVertex(iv).getXYZ();
+      // LOGP(info, "Vertex position: x={} y={} z={}", vertex.x(), vertex.y(), vertex.z());
+
+      for (auto src : selSrc) {
+        int idMin = vtxRefs[iv].getFirstEntryOfSource(src), idMax = idMin + vtxRefs[iv].getEntriesOfSource(src);
+        // LOGP(info, "Source {}: idMin={} idMax={}", GID::getSourceName(src), idMin, idMax);
+
+        for (int i = idMin; i < idMax; i++) {
+          auto vid = trackIndex[i];
+          const auto& track = recoData.getTrackParam(vid); // this is a COPY of the track param which we will modify during DCA calculation
+          auto gidTPC = recoData.getTPCContributorGID(vid);
+          if (gidTPC.isSourceSet()) {
+            const auto idxTPC = gidTPC.getIndex();
+            if (mCuts.goodTrack(tracksTPC[idxTPC]) && acceptDCA(tracksTPC[idxTPC], vertex, true)) {
+              indices.emplace_back(idxTPC);
+            }
+          }
+        }
+      }
+    }
 
-  if ((mMaxTracksPerTF != -1) && (nTracks > mMaxTracksPerTF)) {
-    // indices to good tracks
-    std::vector<size_t> indices;
-    indices.reserve(nTracks);
+  } else {
     for (size_t i = 0; i < nTracks; ++i) {
-      if (mCuts.goodTrack(tracks[i]) && acceptDCA(tracks[i])) {
+      if (mCuts.goodTrack(tracksTPC[i]) && acceptDCA(tracksTPC[i], vertex)) {
         indices.emplace_back(i);
       }
     }
+  }
+
+  size_t nTracksSel = indices.size();
 
+  if ((mMaxTracksPerTF != -1) && (nTracksSel > mMaxTracksPerTF)) {
     // in case no good tracks have been found
     if (indices.empty()) {
       mMIPTracks.clear();
@@ -144,15 +198,14 @@ void MIPTrackFilterDevice::run(ProcessingContext& pc)
     std::shuffle(indices.begin(), indices.end(), rng);
 
     // copy good tracks
-    const int loopEnd = (mMaxTracksPerTF > indices.size()) ? indices.size() : mMaxTracksPerTF;
-    for (int i = 0; i < loopEnd; ++i) {
-      mMIPTracks.emplace_back(tracks[indices[i]]);
-    }
-  } else {
-    std::copy_if(tracks.begin(), tracks.end(), std::back_inserter(mMIPTracks), [this](const auto& track) { return mCuts.goodTrack(track) && acceptDCA(track); });
+    nTracksSel = (mMaxTracksPerTF > indices.size()) ? indices.size() : mMaxTracksPerTF;
+  }
+
+  for (int i = 0; i < nTracksSel; ++i) {
+    mMIPTracks.emplace_back(tracksTPC[indices[i]]);
   }
 
-  LOGP(info, "Filtered {} MIP tracks out of {} total tpc tracks", mMIPTracks.size(), tracks.size());
+  LOGP(info, "Filtered {} / {} MIP tracks out of {} total tpc tracks, using {}", mMIPTracks.size(), indices.size(), tracksTPC.size(), useGlobalTracks ? "global tracks" : "TPC only tracks");
   sendOutput(pc.outputs());
   mMIPTracks.clear();
 }
@@ -162,6 +215,11 @@ void MIPTrackFilterDevice::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
     return;
   }
+  if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
+    LOG(info) << "Setting new MeanVertex: " << ((const o2::dataformats::MeanVertexObject*)obj)->asString();
+    mVtx = *(const o2::dataformats::MeanVertexObject*)obj;
+    return;
+  }
 }
 
 void MIPTrackFilterDevice::sendOutput(DataAllocator& output) { output.snapshot(Output{header::gDataOriginTPC, "MIPS", 0}, mMIPTracks); }
@@ -171,7 +229,7 @@ void MIPTrackFilterDevice::endOfStream(EndOfStreamContext& eos)
   LOG(info) << "Finalizig MIP Tracks filter";
 }
 
-bool MIPTrackFilterDevice::acceptDCA(const TrackTPC& track)
+bool MIPTrackFilterDevice::acceptDCA(o2::track::TrackPar propTrack, o2::math_utils::Point3D<float> refPoint, bool useDCAz)
 {
   if (mDCACut < 0) {
     return true;
@@ -179,21 +237,21 @@ bool MIPTrackFilterDevice::acceptDCA(const TrackTPC& track)
 
   auto propagator = o2::base::Propagator::Instance();
   std::array<float, 2> dca;
-  const o2::math_utils::Point3D<float> refPoint{0, 0, 0};
-  o2::track::TrackPar propTrack(track);
   const auto ok = propagator->propagateToDCABxByBz(refPoint, propTrack, 2., o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca);
   const auto dcar = std::abs(dca[0]);
 
-  return ok && (dcar < mDCACut);
+  return ok && (dcar < mDCACut) && (!useDCAz || (std::abs(dca[1]) < mDCAZCut));
 }
 
-DataProcessorSpec getMIPTrackFilterSpec()
+DataProcessorSpec getMIPTrackFilterSpec(GID::mask_t srcTracks)
 {
   std::vector<OutputSpec> outputs;
   outputs.emplace_back(header::gDataOriginTPC, "MIPS", 0, Lifetime::Sporadic);
 
-  std::vector<InputSpec> inputs;
-  inputs.emplace_back("tracks", "TPC", "TRACKS");
+  const auto useMC = false;
+  auto dataRequest = std::make_shared<DataRequest>();
+  dataRequest->requestTracks(srcTracks, useMC);
+  dataRequest->requestPrimaryVertices(useMC);
 
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
                                                               true,                              // GRPECS=true
@@ -201,14 +259,16 @@ DataProcessorSpec getMIPTrackFilterSpec()
                                                               true,                              // GRPMagField
                                                               true,                              // askMatLUT
                                                               o2::base::GRPGeomRequest::Aligned, // geometry
-                                                              inputs,
+                                                              dataRequest->inputs,
                                                               true);
 
+  dataRequest->inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, o2::framework::ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
+
   return DataProcessorSpec{
     "tpc-miptrack-filter",
-    inputs,
+    dataRequest->inputs,
     outputs,
-    adaptFromTask<MIPTrackFilterDevice>(ggRequest),
+    adaptFromTask<MIPTrackFilterDevice>(ggRequest, dataRequest, srcTracks),
     Options{
       {"min-momentum", VariantType::Double, 0.35, {"minimum momentum cut"}},
       {"max-momentum", VariantType::Double, 0.55, {"maximum momentum cut"}},
@@ -220,7 +280,8 @@ DataProcessorSpec getMIPTrackFilterSpec()
       {"process-first-n-TFs", VariantType::Int, 1, {"Number of first TFs which are not sampled"}},
       {"send-dummy-data", VariantType::Bool, false, {"Send empty data in case TF is skipped"}},
       {"dont-cut-loopers", VariantType::Bool, false, {"Do not cut loopers by comparing zout-zin"}},
-      {"dca-cut", VariantType::Float, 3.f, {"DCA cut in cm, < 0 to disable"}},
+      {"dca-cut", VariantType::Float, 3.f, {"DCA cut in xy (cm), < 0 to disable cut in xy and z"}},
+      {"dca-z-cut", VariantType::Float, 5.f, {"DCA cut in z (cm)"}},
     }};
 }
 
diff --git a/Detectors/TPC/workflow/src/tpc-miptrack-filter.cxx b/Detectors/TPC/workflow/src/tpc-miptrack-filter.cxx
index 112e8ff2cd3a4..ae05b0c431626 100644
--- a/Detectors/TPC/workflow/src/tpc-miptrack-filter.cxx
+++ b/Detectors/TPC/workflow/src/tpc-miptrack-filter.cxx
@@ -13,6 +13,10 @@
 #include "TPCWorkflow/MIPTrackFilterSpec.h"
 #include "Framework/ConfigParamSpec.h"
 #include "DataFormatsTPC/TrackTPC.h"
+#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+
+using GID = o2::dataformats::GlobalTrackID;
 
 template <typename T>
 using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
@@ -21,6 +25,8 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
   std::vector<ConfigParamSpec> options{
     {"enable-writer", VariantType::Bool, false, {"selection string input specs"}},
+    {"use-global-tracks", VariantType::Bool, false, {"use global matched tracks instead of TPC only"}},
+    {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
   };
 
   std::swap(workflowOptions, options);
@@ -33,8 +39,17 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
 {
   using namespace o2::tpc;
 
+  const auto useGlobal = config.options().get<bool>("use-global-tracks");
   WorkflowSpec workflow;
-  workflow.emplace_back(getMIPTrackFilterSpec());
+
+  const auto useMC = false;
+  auto srcTracks = GID::getSourcesMask("TPC");
+  const auto srcCls = GID::getSourcesMask("");
+  if (useGlobal) {
+    srcTracks = GID::getSourcesMask("ITS,TPC,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
+  }
+
+  workflow.emplace_back(getMIPTrackFilterSpec(srcTracks));
 
   if (config.options().get<bool>("enable-writer")) {
     const char* processName = "tpc-mips-writer";

From 9220ba5aeff2e44693d54a4e9cefd83fcec462d2 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Tue, 16 Sep 2025 13:28:32 +0200
Subject: [PATCH 0887/1764] Negative binning omits drawing the 1D distributions

---
 Detectors/TPC/base/src/Painter.cxx | 36 +++++++++++++++++++-----------
 1 file changed, 23 insertions(+), 13 deletions(-)

diff --git a/Detectors/TPC/base/src/Painter.cxx b/Detectors/TPC/base/src/Painter.cxx
index 9f143d3fa45ce..fffe195f8bfb6 100644
--- a/Detectors/TPC/base/src/Painter.cxx
+++ b/Detectors/TPC/base/src/Painter.cxx
@@ -291,6 +291,8 @@ TCanvas* painter::draw(const CalDet<T>& calDet, int nbins1D, float xMin1D, float
 
   const Mapper& mapper = Mapper::instance();
 
+  const bool draw1D = nbins1D > 0;
+
   // ===| name and title |======================================================
   std::string title = calDet.getName();
   std::string name = calDet.getName();
@@ -305,11 +307,13 @@ TCanvas* painter::draw(const CalDet<T>& calDet, int nbins1D, float xMin1D, float
   const int bufferSize = TH1::GetDefaultBufferSize();
   TH1::SetDefaultBufferSize(Sector::MAXSECTOR * mapper.getPadsInSector());
 
-  auto hAside1D = new TH1F(fmt::format("h_Aside_1D_{}", name).data(), fmt::format("{0} (A-Side);{0}", title).data(),
-                           nbins1D, xMin1D, xMax1D); // TODO: modify ranges
+  auto hAside1D = draw1D ? new TH1F(fmt::format("h_Aside_1D_{}", name).data(), fmt::format("{0} (A-Side);{0}", title).data(),
+                                    nbins1D, xMin1D, xMax1D)
+                         : nullptr; // TODO: modify ranges
 
-  auto hCside1D = new TH1F(fmt::format("h_Cside_1D_{}", name).data(), fmt::format("{0} (C-Side);{0}", title).data(),
-                           nbins1D, xMin1D, xMax1D); // TODO: modify ranges
+  auto hCside1D = draw1D ? new TH1F(fmt::format("h_Cside_1D_{}", name).data(), fmt::format("{0} (C-Side);{0}", title).data(),
+                                    nbins1D, xMin1D, xMax1D)
+                         : nullptr; // TODO: modify ranges
 
   auto hAside2D = new TH2F(fmt::format("h_Aside_2D_{}", name).data(), fmt::format("{0} (A-Side);#it{{x}} (cm);#it{{y}} (cm);{0}", title).data(),
                            330, -270, 270, 330, -270, 270);
@@ -336,7 +340,9 @@ TCanvas* painter::draw(const CalDet<T>& calDet, int nbins1D, float xMin1D, float
         if (!hist2D->GetBinContent(bin)) {
           hist2D->SetBinContent(bin, double(val));
         }
-        hist1D->Fill(double(val));
+        if (draw1D) {
+          hist1D->Fill(double(val));
+        }
       }
     }
   }
@@ -352,13 +358,13 @@ TCanvas* painter::draw(const CalDet<T>& calDet, int nbins1D, float xMin1D, float
   gStyle->SetOptStat("mr");
   auto c = outputCanvas;
   if (!c) {
-    c = new TCanvas(fmt::format("c_{}", name).data(), title.data(), 1000, 1000);
+    c = new TCanvas(fmt::format("c_{}", name).data(), title.data(), 1000, draw1D ? 1000 : 500);
   }
   gStyle->SetStatX(1. - gPad->GetRightMargin());
   gStyle->SetStatY(1. - gPad->GetTopMargin());
 
   c->Clear();
-  c->Divide(2, 2);
+  c->Divide(2, draw1D ? 2 : 1);
 
   c->cd(1);
   hAside2D->Draw("colz");
@@ -376,18 +382,22 @@ TCanvas* painter::draw(const CalDet<T>& calDet, int nbins1D, float xMin1D, float
   adjustPalette(hCside2D, 0.92);
   drawSectorsXY(Side::C);
 
-  c->cd(3);
-  hAside1D->Draw();
+  if (draw1D) {
+    c->cd(3);
+    hAside1D->Draw();
 
-  c->cd(4);
-  hCside1D->Draw();
+    c->cd(4);
+    hCside1D->Draw();
+
+    // associate histograms to canvas
+    hAside1D->SetBit(TObject::kCanDelete);
+    hCside1D->SetBit(TObject::kCanDelete);
+  }
 
   // reset the buffer size
   TH1::SetDefaultBufferSize(bufferSize);
 
   // associate histograms to canvas
-  hAside1D->SetBit(TObject::kCanDelete);
-  hCside1D->SetBit(TObject::kCanDelete);
   hAside2D->SetBit(TObject::kCanDelete);
   hCside2D->SetBit(TObject::kCanDelete);
 

From d49dc2685b51ec83377c424ac3b0e09df0de8215 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Tue, 16 Sep 2025 13:29:34 +0200
Subject: [PATCH 0888/1764] Add possibility to add a comment for the CCDB
 upload

---
 .../TPC/dcs/macro/makeTPCCCDBEntryForDCS.C    | 22 ++++++++++++++++---
 1 file changed, 19 insertions(+), 3 deletions(-)

diff --git a/Detectors/TPC/dcs/macro/makeTPCCCDBEntryForDCS.C b/Detectors/TPC/dcs/macro/makeTPCCCDBEntryForDCS.C
index edcb69907b3e5..d488aba14e264 100644
--- a/Detectors/TPC/dcs/macro/makeTPCCCDBEntryForDCS.C
+++ b/Detectors/TPC/dcs/macro/makeTPCCCDBEntryForDCS.C
@@ -14,6 +14,7 @@
 #include <string>
 #include "TFile.h"
 #include "CCDB/CcdbApi.h"
+#include "CommonUtils/StringUtils.h"
 #include "DetectorsDCS/AliasExpander.h"
 #include "DetectorsDCS/DeliveryType.h"
 #include "DetectorsDCS/DataPointIdentifier.h"
@@ -24,9 +25,10 @@
 #include <chrono>
 
 using DPID = o2::dcs::DataPointIdentifier;
+using namespace o2::utils;
 
 /// macro to populate CCDB for TPC with the configuration for DCS
-int makeTPCCCDBEntryForDCS(const std::string url = "http://localhost:8080")
+int makeTPCCCDBEntryForDCS(const std::string url = "http://localhost:8080", std::string comment = "")
 {
 
   std::unordered_map<DPID, std::string> dpid2DataDesc;
@@ -64,9 +66,23 @@ int makeTPCCCDBEntryForDCS(const std::string url = "http://localhost:8080")
 
   o2::ccdb::CcdbApi api;
   api.init(url); // or http://localhost:8080 for a local installation
-  std::map<std::string, std::string> md;
+  std::map<std::string, std::string> meta;
+
+  auto toKeyValPairs = [&meta](std::vector<std::string> const& tokens) {
+    for (auto& token : tokens) {
+      auto keyval = Str::tokenize(token, '=', false);
+      if (keyval.size() != 2) {
+        LOG(error) << "Illegal command-line key/value string: " << token;
+        continue;
+      }
+      Str::trim(keyval[1]);
+      meta[keyval[0]] = keyval[1];
+    }
+  };
+  toKeyValPairs(Str::tokenize(comment, ';', true));
+
   long ts = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
-  api.storeAsTFileAny(&dpid2DataDesc, "TPC/Config/DCSDPconfig", md, ts, 99999999999999);
+  api.storeAsTFileAny(&dpid2DataDesc, "TPC/Config/DCSDPconfig", meta, ts, 99999999999999);
 
   return 0;
 }

From 879a5350865edbca153a483bddcf0b8e836b87cc Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Thu, 25 Sep 2025 10:05:53 +0200
Subject: [PATCH 0889/1764] Add voxel map binning

---
 Detectors/TPC/base/include/TPCBase/Painter.h | 11 ++-
 Detectors/TPC/base/src/Painter.cxx           | 84 ++++++++++++++++++--
 2 files changed, 86 insertions(+), 9 deletions(-)

diff --git a/Detectors/TPC/base/include/TPCBase/Painter.h b/Detectors/TPC/base/include/TPCBase/Painter.h
index 976fe2846ce0c..5cf8691635b1f 100644
--- a/Detectors/TPC/base/include/TPCBase/Painter.h
+++ b/Detectors/TPC/base/include/TPCBase/Painter.h
@@ -53,7 +53,8 @@ struct painter {
   enum class Type : int {
     Pad,   ///< drawing pads
     Stack, ///< drawing stacks
-    FEC    ///< drawing of FECs
+    FEC,   ///< drawing of FECs
+    SCD,   ///< drawing of FECs
   };
 
   static std::array<int, 6> colors;
@@ -87,8 +88,10 @@ struct painter {
   /// create a vector of FEC corner coordinates for one full sector
   static std::vector<PadCoordinates> getFECCoordinatesSector();
 
+  static std::vector<painter::PadCoordinates> getSCDY2XCoordinatesSector(std::string binningStr);
+
   /// \return returns coordinates for given type
-  static std::vector<o2::tpc::painter::PadCoordinates> getCoordinates(const Type type);
+  static std::vector<o2::tpc::painter::PadCoordinates> getCoordinates(const Type type, std::string binningStr = "");
 
   /// binning vector with radial pad-row positions (in cm)
   /// \param roc roc number (0-35 IROC, 36-71 OROC, >=72 full sector)
@@ -143,11 +146,11 @@ struct painter {
   /// \param yMin minimum y coordinate of the histogram
   /// \param yMax maximum y coordinate of the histogram
   /// \param type granularity of the histogram (per pad or per stack)
-  static TH2Poly* makeSectorHist(const std::string_view name = "hSector", const std::string_view title = "Sector;local #it{x} (cm);local #it{y} (cm)", const float xMin = 83.65f, const float xMax = 247.7f, const float yMin = -43.7f, const float yMax = 43.7f, const Type type = Type::Pad);
+  static TH2Poly* makeSectorHist(const std::string_view name = "hSector", const std::string_view title = "Sector;local #it{x} (cm);local #it{y} (cm)", const float xMin = 83.65f, const float xMax = 247.7f, const float yMin = -43.7f, const float yMax = 43.7f, const Type type = Type::Pad, std::string binningStr = "");
 
   /// make a side-wise histogram with correct pad corners
   /// \param type granularity of the histogram (per pad or per stack)
-  static TH2Poly* makeSideHist(Side side, const Type type = Type::Pad);
+  static TH2Poly* makeSideHist(Side side, const Type type = Type::Pad, std::string binningStr = "");
 
   /// fill existing TH2Poly histogram for CalDet object
   /// \param h2D histogram to fill
diff --git a/Detectors/TPC/base/src/Painter.cxx b/Detectors/TPC/base/src/Painter.cxx
index fffe195f8bfb6..ffbc149225212 100644
--- a/Detectors/TPC/base/src/Painter.cxx
+++ b/Detectors/TPC/base/src/Painter.cxx
@@ -31,7 +31,9 @@
 #include "TPaveText.h"
 #include "TPaletteAxis.h"
 #include "TObjArray.h"
+#include "TMath.h"
 
+#include "Algorithm/RangeTokenizer.h"
 #include "CommonUtils/StringUtils.h"
 #include "DataFormatsTPC/Defs.h"
 #include "TPCBase/ROC.h"
@@ -223,7 +225,77 @@ std::vector<painter::PadCoordinates> painter::getFECCoordinatesSector()
   return padCoords;
 }
 
-std::vector<o2::tpc::painter::PadCoordinates> painter::getCoordinates(const Type type)
+std::vector<painter::PadCoordinates> painter::getSCDY2XCoordinatesSector(std::string binningStr)
+{
+  const float deadZone = 1.5;
+  const float secPhi = 20.0 * TMath::DegToRad();
+  std::vector<painter::PadCoordinates> padCoords;
+  const Mapper& mapper = Mapper::instance();
+  const auto nPadRows = Mapper::PADROWS;
+  std::vector<float> maxY2X(nPadRows);
+  auto binCenters = o2::RangeTokenizer::tokenize<float>(binningStr);
+  size_t nY2XBins = 20;
+  std::vector<float> halfBinWidth;
+
+  auto setUniformBinning = [&binCenters, &halfBinWidth](int nY2XBins) {
+    binCenters.resize(nY2XBins);
+    halfBinWidth.resize(nY2XBins);
+    for (int i = 0; i < nY2XBins; ++i) {
+      const auto binWidth = 2.f / nY2XBins;
+      halfBinWidth[i] = binWidth / 2.f;
+      binCenters[i] = -1.f + (i + 0.5f) * binWidth;
+    }
+  };
+
+  if (binCenters.size() == 0) {
+    LOGP(info, "Empty binning provided, will use default uniform y/x binning with {} bins", nY2XBins);
+    setUniformBinning(nY2XBins);
+  } else if (binCenters.size() == 1) {
+    nY2XBins = static_cast<int>(binCenters.at(0));
+    LOGP(info, "Setting uniform binning for y/x with {} bins", nY2XBins);
+    setUniformBinning(nY2XBins);
+  } else {
+    nY2XBins = binCenters.size() - 1;
+    if (std::abs(binCenters[0] + 1.f) > 1e-6 || std::abs(binCenters[nY2XBins] - 1.f) > 1e-6) {
+      LOG(error) << "Provided binning for y/x not in range -1 to 1: " << binCenters[0] << " - " << binCenters[nY2XBins] << ". Using default uniform binning with " << nY2XBins << " bins";
+      setUniformBinning(nY2XBins);
+    } else {
+      LOGP(info, "Setting custom binning for y/x with {} bins", nY2XBins);
+      halfBinWidth.reserve(nY2XBins);
+      halfBinWidth.clear();
+      for (int i = 0; i < nY2XBins; ++i) {
+        halfBinWidth.push_back(.5f * (binCenters[i + 1] - binCenters[i]));
+        binCenters[i] = .5f * (binCenters[i] + binCenters[i + 1]);
+      }
+      binCenters.resize(nY2XBins);
+    }
+  }
+
+  for (int irow = 0; irow < nPadRows; ++irow) {
+    const auto x = mapper.getPadCentre(PadPos(irow, 0)).X();
+    maxY2X[irow] = std::tan(.5f * secPhi) - deadZone / x;
+    const auto region = Mapper::REGION[irow];
+    const auto ph = mapper.getPadRegionInfo(region).getPadHeight();
+    const auto xPadBottom = x - ph / 2;
+    const auto xPadTop = x + ph / 2;
+    for (int iy2x = 0; iy2x < nY2XBins; ++iy2x) {
+      auto& padCoord = padCoords.emplace_back();
+      float yPadRight = 0;
+      if (iy2x == 0) {
+        yPadRight = maxY2X[irow] * (binCenters[iy2x] - halfBinWidth[iy2x]);
+      } else {
+        yPadRight = maxY2X[irow] * (binCenters[iy2x - 1] + halfBinWidth[iy2x - 1]);
+      }
+      const auto yPadLeft = maxY2X[irow] * (binCenters[iy2x] + halfBinWidth[iy2x]);
+      padCoord.xVals = {xPadBottom, xPadTop, xPadTop, xPadBottom};
+      padCoord.yVals = {yPadRight * xPadBottom, yPadRight * xPadTop, yPadLeft * xPadTop, yPadLeft * xPadBottom};
+    }
+  }
+
+  return padCoords;
+}
+
+std::vector<o2::tpc::painter::PadCoordinates> painter::getCoordinates(const Type type, std::string binningStr)
 {
   if (type == Type::Pad) {
     return painter::getPadCoordinatesSector();
@@ -231,6 +303,8 @@ std::vector<o2::tpc::painter::PadCoordinates> painter::getCoordinates(const Type
     return painter::getStackCoordinatesSector();
   } else if (type == Type::FEC) {
     return painter::getFECCoordinatesSector();
+  } else if (type == Type::SCD) {
+    return painter::getSCDY2XCoordinatesSector(binningStr);
   } else {
     LOGP(warning, "Wrong Type provided!");
     return std::vector<o2::tpc::painter::PadCoordinates>();
@@ -805,11 +879,11 @@ std::vector<TCanvas*> painter::makeSummaryCanvases(const std::string_view fileNa
 }
 
 //______________________________________________________________________________
-TH2Poly* painter::makeSectorHist(const std::string_view name, const std::string_view title, const float xMin, const float xMax, const float yMin, const float yMax, const Type type)
+TH2Poly* painter::makeSectorHist(const std::string_view name, const std::string_view title, const float xMin, const float xMax, const float yMin, const float yMax, const Type type, std::string binningStr)
 {
   auto poly = new TH2Poly(name.data(), title.data(), xMin, xMax, yMin, yMax);
 
-  auto coords = painter::getCoordinates(type);
+  auto coords = painter::getCoordinates(type, binningStr);
   for (const auto& coord : coords) {
     poly->AddBin(coord.xVals.size(), coord.xVals.data(), coord.yVals.data());
   }
@@ -818,12 +892,12 @@ TH2Poly* painter::makeSectorHist(const std::string_view name, const std::string_
 }
 
 //______________________________________________________________________________
-TH2Poly* painter::makeSideHist(Side side, const Type type)
+TH2Poly* painter::makeSideHist(Side side, const Type type, std::string binningStr)
 {
   const auto s = (side == Side::A) ? "A" : "C";
   auto poly = new TH2Poly(fmt::format("hSide_{}", s).data(), fmt::format("{}-Side;#it{{x}} (cm);#it{{y}} (cm)", s).data(), -270., 270., -270., 270.);
 
-  auto coords = painter::getCoordinates(type);
+  auto coords = painter::getCoordinates(type, binningStr);
   for (int isec = 0; isec < 18; ++isec) {
     const float angDeg = 10.f + isec * 20;
     for (auto coord : coords) {

From d10c9578a793bfc1ce60348208de2917c0715e6b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 2 Oct 2025 12:07:45 +0200
Subject: [PATCH 0890/1764] Move FragmentToBatch to separate class

---
 .../src/StandaloneAODProducerSpec.cxx         |  3 +-
 Detectors/Filtering/src/FilteringSpec.cxx     |  1 -
 .../src/StandaloneAODProducerSpec.cxx         |  3 +-
 .../AnalysisSupport/src/DataInputDirector.cxx |  2 +-
 Framework/AnalysisSupport/src/Plugin.cxx      |  6 ++
 Framework/Core/CMakeLists.txt                 |  1 +
 .../Core/include/Framework/FragmentToBatch.h  | 51 +++++++++++++++++
 .../Core/include/Framework/TableTreeHelpers.h | 24 --------
 Framework/Core/src/AnalysisSupportHelpers.cxx |  1 -
 Framework/Core/src/DataAllocator.cxx          |  2 +-
 Framework/Core/src/FragmentToBatch.cxx        | 57 +++++++++++++++++++
 Framework/Core/src/TableTreeHelpers.cxx       | 27 ---------
 12 files changed, 119 insertions(+), 59 deletions(-)
 create mode 100644 Framework/Core/include/Framework/FragmentToBatch.h
 create mode 100644 Framework/Core/src/FragmentToBatch.cxx

diff --git a/Detectors/EMCAL/workflow/src/StandaloneAODProducerSpec.cxx b/Detectors/EMCAL/workflow/src/StandaloneAODProducerSpec.cxx
index 73987ce6d1c1b..227fc373bf20c 100644
--- a/Detectors/EMCAL/workflow/src/StandaloneAODProducerSpec.cxx
+++ b/Detectors/EMCAL/workflow/src/StandaloneAODProducerSpec.cxx
@@ -17,7 +17,6 @@
 #include "Framework/InputRecordWalker.h"
 #include "Framework/Logger.h"
 #include "Framework/TableBuilder.h"
-#include "Framework/TableTreeHelpers.h"
 #include "MathUtils/Utils.h"
 
 using namespace o2::framework;
@@ -105,7 +104,7 @@ void StandaloneAODProducerSpec::run(ProcessingContext& pc)
                       o2::math_utils::detail::truncateFloatFraction(cell.getTimeStamp(), mCaloTime),
                       cell.getType(),
                       1); // hard coded for emcal (-1 would be undefined, 0 phos)
-    }                     // end of cell loop
+    } // end of cell loop
 
     // filled only with BCID, rest dummy for no2
     caloCellsTRGTableCursor(0,
diff --git a/Detectors/Filtering/src/FilteringSpec.cxx b/Detectors/Filtering/src/FilteringSpec.cxx
index 847fa2cf7e1e5..bcf3c6c3539d4 100644
--- a/Detectors/Filtering/src/FilteringSpec.cxx
+++ b/Detectors/Filtering/src/FilteringSpec.cxx
@@ -38,7 +38,6 @@
 #include "Framework/InputRecordWalker.h"
 #include "Framework/Logger.h"
 #include "Framework/TableBuilder.h"
-#include "Framework/TableTreeHelpers.h"
 #include "Framework/CCDBParamSpec.h"
 #include "FDDBase/Constants.h"
 #include "FT0Base/Geometry.h"
diff --git a/Detectors/PHOS/workflow/src/StandaloneAODProducerSpec.cxx b/Detectors/PHOS/workflow/src/StandaloneAODProducerSpec.cxx
index 454be7a5fcb83..06baf889b662f 100644
--- a/Detectors/PHOS/workflow/src/StandaloneAODProducerSpec.cxx
+++ b/Detectors/PHOS/workflow/src/StandaloneAODProducerSpec.cxx
@@ -19,7 +19,6 @@
 #include "Framework/InputRecordWalker.h"
 #include "Framework/Logger.h"
 #include "Framework/TableBuilder.h"
-#include "Framework/TableTreeHelpers.h"
 #include "MathUtils/Utils.h"
 
 using namespace o2::framework;
@@ -106,7 +105,7 @@ void StandaloneAODProducerSpec::run(ProcessingContext& pc)
                       o2::math_utils::detail::truncateFloatFraction(c.getTime(), mCaloTime),
                       c.getType(), // HG/LG
                       0);          // hard coded for phos (-1 would be undefined, 0 phos)
-    }                              // end of cell loop
+    } // end of cell loop
 
     auto bcID = tr.getBCData().toLong();
     bcCursor(0,
diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index 7cc0134a27968..2bc6c5613f065 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -16,8 +16,8 @@
 #include "Framework/AnalysisDataModelHelpers.h"
 #include "Framework/Output.h"
 #include "Framework/Signpost.h"
+#include "Framework/FragmentToBatch.h"
 #include "Headers/DataHeader.h"
-#include "Framework/TableTreeHelpers.h"
 #include "Monitoring/Tags.h"
 #include "Monitoring/Metric.h"
 #include "Monitoring/Monitoring.h"
diff --git a/Framework/AnalysisSupport/src/Plugin.cxx b/Framework/AnalysisSupport/src/Plugin.cxx
index e39e76f01dbdd..5f61a236cbd58 100644
--- a/Framework/AnalysisSupport/src/Plugin.cxx
+++ b/Framework/AnalysisSupport/src/Plugin.cxx
@@ -27,6 +27,12 @@
 
 O2_DECLARE_DYNAMIC_LOG(analysis_support);
 
+struct ROOTTypeInfo {
+  EDataType type;
+  char suffix[3];
+  int size;
+};
+
 struct ROOTFileReader : o2::framework::AlgorithmPlugin {
   o2::framework::AlgorithmSpec create(o2::framework::ConfigContext const& config) override
   {
diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 936d8874179a5..43571526855cc 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -87,6 +87,7 @@ o2_add_library(Framework
                        src/FairMQDeviceProxy.cxx
                        src/FairMQResizableBuffer.cxx
                        src/FairOptionsRetriever.cxx
+                       src/FragmentToBatch.cxx
                        src/ConfigurationOptionsRetriever.cxx
                        src/FreePortFinder.cxx
                        src/GraphvizHelpers.cxx
diff --git a/Framework/Core/include/Framework/FragmentToBatch.h b/Framework/Core/include/Framework/FragmentToBatch.h
new file mode 100644
index 0000000000000..3a600d71452b9
--- /dev/null
+++ b/Framework/Core/include/Framework/FragmentToBatch.h
@@ -0,0 +1,51 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef O2_FRAMEWORK_FRAGMENT_TO_BATCH_H_
+#define O2_FRAMEWORK_FRAGMENT_TO_BATCH_H_
+
+#include <arrow/buffer.h>
+#include <arrow/io/interfaces.h>
+#include <arrow/record_batch.h>
+#include <arrow/dataset/file_base.h>
+#include <memory>
+
+// =============================================================================
+namespace o2::framework
+{
+class FragmentToBatch
+{
+ public:
+  // The function to be used to create the required stream.
+  using StreamerCreator = std::function<std::shared_ptr<arrow::io::OutputStream>(std::shared_ptr<arrow::dataset::FileFragment>, const std::shared_ptr<arrow::ResizableBuffer>& buffer)>;
+
+  FragmentToBatch(StreamerCreator, std::shared_ptr<arrow::dataset::FileFragment>, arrow::MemoryPool* pool = arrow::default_memory_pool());
+  void setLabel(const char* label);
+  void fill(std::shared_ptr<arrow::Schema> dataSetSchema, std::shared_ptr<arrow::dataset::FileFormat>);
+  std::shared_ptr<arrow::RecordBatch> finalize();
+
+  std::shared_ptr<arrow::io::OutputStream> streamer(std::shared_ptr<arrow::ResizableBuffer> buffer)
+  {
+    return mCreator(mFragment, buffer);
+  }
+
+ private:
+  std::shared_ptr<arrow::dataset::FileFragment> mFragment;
+  arrow::MemoryPool* mArrowMemoryPool = nullptr;
+  std::string mTableLabel;
+  std::shared_ptr<arrow::RecordBatch> mRecordBatch;
+  StreamerCreator mCreator;
+};
+
+// -----------------------------------------------------------------------------
+} // namespace o2::framework
+
+// =============================================================================
+#endif // O2_FRAMEWORK_FRAGMENT_TO_BATCH_H_
diff --git a/Framework/Core/include/Framework/TableTreeHelpers.h b/Framework/Core/include/Framework/TableTreeHelpers.h
index 3f76298a5bbd4..0a163d59aecb0 100644
--- a/Framework/Core/include/Framework/TableTreeHelpers.h
+++ b/Framework/Core/include/Framework/TableTreeHelpers.h
@@ -91,30 +91,6 @@ class TableToTree
   std::vector<std::unique_ptr<ColumnToBranch>> mColumnReaders;
 };
 
-class FragmentToBatch
-{
- public:
-  // The function to be used to create the required stream.
-  using StreamerCreator = std::function<std::shared_ptr<arrow::io::OutputStream>(std::shared_ptr<arrow::dataset::FileFragment>, const std::shared_ptr<arrow::ResizableBuffer>& buffer)>;
-
-  FragmentToBatch(StreamerCreator, std::shared_ptr<arrow::dataset::FileFragment>, arrow::MemoryPool* pool = arrow::default_memory_pool());
-  void setLabel(const char* label);
-  void fill(std::shared_ptr<arrow::Schema> dataSetSchema, std::shared_ptr<arrow::dataset::FileFormat>);
-  std::shared_ptr<arrow::RecordBatch> finalize();
-
-  std::shared_ptr<arrow::io::OutputStream> streamer(std::shared_ptr<arrow::ResizableBuffer> buffer)
-  {
-    return mCreator(mFragment, buffer);
-  }
-
- private:
-  std::shared_ptr<arrow::dataset::FileFragment> mFragment;
-  arrow::MemoryPool* mArrowMemoryPool = nullptr;
-  std::string mTableLabel;
-  std::shared_ptr<arrow::RecordBatch> mRecordBatch;
-  StreamerCreator mCreator;
-};
-
 // -----------------------------------------------------------------------------
 } // namespace o2::framework
 
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index e8c2d7acab5d2..7cfab22885671 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -15,7 +15,6 @@
 #include "Framework/ControlService.h"
 #include "Framework/EndOfStreamContext.h"
 #include "Framework/DeviceSpec.h"
-#include "Framework/TableTreeHelpers.h"
 #include "Framework/PluginManager.h"
 #include "Framework/ConfigContext.h"
 #include "WorkflowHelpers.h"
diff --git a/Framework/Core/src/DataAllocator.cxx b/Framework/Core/src/DataAllocator.cxx
index 4b559ef26191e..f0de6a40935b7 100644
--- a/Framework/Core/src/DataAllocator.cxx
+++ b/Framework/Core/src/DataAllocator.cxx
@@ -11,7 +11,6 @@
 #include "Framework/CompilerBuiltins.h"
 #include "Framework/Lifetime.h"
 #include "Framework/TableBuilder.h"
-#include "Framework/TableTreeHelpers.h"
 #include "Framework/DataAllocator.h"
 #include "Framework/MessageContext.h"
 #include "Framework/ArrowContext.h"
@@ -19,6 +18,7 @@
 #include "Framework/DataProcessingHeader.h"
 #include "Framework/FairMQResizableBuffer.h"
 #include "Framework/DataProcessingContext.h"
+#include "Framework/FragmentToBatch.h"
 #include "Framework/DeviceSpec.h"
 #include "Framework/StreamContext.h"
 #include "Framework/Signpost.h"
diff --git a/Framework/Core/src/FragmentToBatch.cxx b/Framework/Core/src/FragmentToBatch.cxx
new file mode 100644
index 0000000000000..88b4f42a8f220
--- /dev/null
+++ b/Framework/Core/src/FragmentToBatch.cxx
@@ -0,0 +1,57 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#include "Framework/FragmentToBatch.h"
+#include "Framework/Logger.h"
+#include "Framework/Endian.h"
+#include "Framework/Signpost.h"
+
+#include <arrow/dataset/file_base.h>
+#include <arrow/record_batch.h>
+#include <arrow/type.h>
+#include <arrow/util/key_value_metadata.h>
+#include <TBufferFile.h>
+
+#include <memory>
+#include <utility>
+
+O2_DECLARE_DYNAMIC_LOG(tabletree_helpers);
+
+namespace o2::framework
+{
+
+FragmentToBatch::FragmentToBatch(StreamerCreator creator, std::shared_ptr<arrow::dataset::FileFragment> fragment, arrow::MemoryPool* pool)
+  : mFragment{std::move(fragment)},
+    mArrowMemoryPool{pool},
+    mCreator{std::move(creator)}
+{
+}
+
+void FragmentToBatch::setLabel(const char* label)
+{
+  mTableLabel = label;
+}
+
+void FragmentToBatch::fill(std::shared_ptr<arrow::Schema> schema, std::shared_ptr<arrow::dataset::FileFormat> format)
+{
+  auto options = std::make_shared<arrow::dataset::ScanOptions>();
+  options->dataset_schema = schema;
+  auto scanner = format->ScanBatchesAsync(options, mFragment);
+  auto batch = (*scanner)();
+  mRecordBatch = *batch.result();
+  // Notice that up to here the buffer was not yet filled.
+}
+
+std::shared_ptr<arrow::RecordBatch> FragmentToBatch::finalize()
+{
+  return mRecordBatch;
+}
+
+} // namespace o2::framework
diff --git a/Framework/Core/src/TableTreeHelpers.cxx b/Framework/Core/src/TableTreeHelpers.cxx
index 92231cb9ce069..800a31e8ecac3 100644
--- a/Framework/Core/src/TableTreeHelpers.cxx
+++ b/Framework/Core/src/TableTreeHelpers.cxx
@@ -296,31 +296,4 @@ struct BranchInfo {
 };
 } // namespace
 
-FragmentToBatch::FragmentToBatch(StreamerCreator creator, std::shared_ptr<arrow::dataset::FileFragment> fragment, arrow::MemoryPool* pool)
-  : mFragment{std::move(fragment)},
-    mArrowMemoryPool{pool},
-    mCreator{std::move(creator)}
-{
-}
-
-void FragmentToBatch::setLabel(const char* label)
-{
-  mTableLabel = label;
-}
-
-void FragmentToBatch::fill(std::shared_ptr<arrow::Schema> schema, std::shared_ptr<arrow::dataset::FileFormat> format)
-{
-  auto options = std::make_shared<arrow::dataset::ScanOptions>();
-  options->dataset_schema = schema;
-  auto scanner = format->ScanBatchesAsync(options, mFragment);
-  auto batch = (*scanner)();
-  mRecordBatch = *batch.result();
-  // Notice that up to here the buffer was not yet filled.
-}
-
-std::shared_ptr<arrow::RecordBatch> FragmentToBatch::finalize()
-{
-  return mRecordBatch;
-}
-
 } // namespace o2::framework

From 4e40ed168549ae444ac13c9076757e132163ffc1 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 2 Oct 2025 12:15:10 +0200
Subject: [PATCH 0891/1764] GPU TPC dEdx: fixing bug in padPos calculation

---
 GPU/GPUTracking/dEdx/GPUdEdx.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index 9e1727d4988ad..b711f1a685a4c 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -118,7 +118,7 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
   const float tanTheta = CAMath::Sqrt(tgl2 * sec2);
 
   // getting the topology correction
-  const uint32_t padPos = CAMath::Max<uint32_t>(GPUTPCGeometry::NPads(padRow) - 1, CAMath::Float2UIntRn(pad)); // position of the pad is shifted half a pad ( pad=3 -> centre position of third pad)
+  const uint32_t padPos = CAMath::Min<uint32_t>(GPUTPCGeometry::NPads(padRow) - 1, CAMath::Float2UIntRn(pad)); // position of the pad is shifted half a pad ( pad=3 -> centre position of third pad)
   const float absRelPad = CAMath::Abs(pad - padPos);
   const int32_t region = geo.GetRegion(padRow);
   z = CAMath::Abs(z);

From a430fb1398b36cd9c9d2dff639aab02a4a1db6fe Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 2 Oct 2025 23:26:18 +0200
Subject: [PATCH 0892/1764] ITS: fix truth seeding for only signal (#14715)

---
 .../ITS/tracking/src/VertexerTraits.cxx       | 52 +++++++++----------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index b8b30e515d1ca..a546056075700 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -514,34 +514,34 @@ void VertexerTraits<nLayers>::addTruthSeedingVertices()
     bounded_vector<int> events;
   };
   std::map<int, VertInfo> vertices;
-  for (int iSrc{0}; iSrc < mcReader.getNSources(); ++iSrc) {
-    auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
-    for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
-      const auto& ir = irs[eveId2colId[iEve]];
-      if (!ir.isDummy()) { // do we need this, is this for diffractive events?
-        const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
-        int rofId = ((ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC) / roFrameLengthInBC;
-        if (!vertices.contains(rofId)) {
-          vertices[rofId] = {
-            .vertices = bounded_vector<Vertex>(mMemoryPool.get()),
-            .srcs = bounded_vector<int>(mMemoryPool.get()),
-            .events = bounded_vector<int>(mMemoryPool.get()),
-          };
-        }
-        Vertex vert;
-        vert.setTimeStamp(rofId);
-        vert.setNContributors(std::ranges::count_if(mcReader.getTracks(iSrc, iEve), [](const auto& trk) {
-          return trk.isPrimary() && trk.GetPt() > 0.2 && std::abs(trk.GetEta()) < 1.3;
-        }));
-        vert.setXYZ((float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ());
-        vert.setChi2(1);
-        constexpr float cov = 50e-9;
-        vert.setCov(cov, cov, cov, cov, cov, cov);
-        vertices[rofId].vertices.push_back(vert);
-        vertices[rofId].srcs.push_back(iSrc);
-        vertices[rofId].events.push_back(iEve);
+  const int iSrc = 0; // take only events from collision generator
+  auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
+  for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
+    const auto& ir = irs[eveId2colId[iEve]];
+    if (!ir.isDummy()) { // do we need this, is this for diffractive events?
+      const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
+      int rofId = ((ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC) / roFrameLengthInBC;
+      if (!vertices.contains(rofId)) {
+        vertices[rofId] = {
+          .vertices = bounded_vector<Vertex>(mMemoryPool.get()),
+          .srcs = bounded_vector<int>(mMemoryPool.get()),
+          .events = bounded_vector<int>(mMemoryPool.get()),
+        };
       }
+      Vertex vert;
+      vert.setTimeStamp(rofId);
+      vert.setNContributors(std::ranges::count_if(mcReader.getTracks(iSrc, iEve), [](const auto& trk) {
+        return trk.isPrimary() && trk.GetPt() > 0.2 && std::abs(trk.GetEta()) < 1.3;
+      }));
+      vert.setXYZ((float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ());
+      vert.setChi2(1);
+      constexpr float cov = 50e-9;
+      vert.setCov(cov, cov, cov, cov, cov, cov);
+      vertices[rofId].vertices.push_back(vert);
+      vertices[rofId].srcs.push_back(iSrc);
+      vertices[rofId].events.push_back(iEve);
     }
+    mcReader.releaseTracksForSourceAndEvent(iSrc, iEve);
   }
   size_t nVerts{0};
   for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {

From b1904ffa8d92e5bf9f579ce5cc6fa047659c3e8c Mon Sep 17 00:00:00 2001
From: Evgeny Kryshen <evgeny.kryshen@cern.ch>
Date: Fri, 3 Oct 2025 14:39:09 +0300
Subject: [PATCH 0893/1764] Fixes for modules at negative eta (#14716)

* Fixes for modules at negative eta

* Add braces in if statements

* retrigger checks
---
 .../ECal/base/include/ECalBase/Geometry.h     |   1 +
 .../ALICE3/ECal/base/src/Geometry.cxx         |  46 +++++---
 .../include/ECalReconstruction/Clusterizer.h  |  42 ++++---
 .../ECal/reconstruction/src/Clusterizer.cxx   | 103 ++++++++++++------
 .../ALICE3/ECal/simulation/src/Detector.cxx   |   4 +-
 .../ALICE3/ECal/simulation/src/Digitizer.cxx  |   8 +-
 6 files changed, 134 insertions(+), 70 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Geometry.h b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Geometry.h
index ecfcb5b7cbad6..a780e36f45938 100644
--- a/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Geometry.h
+++ b/Detectors/Upgrades/ALICE3/ECal/base/include/ECalBase/Geometry.h
@@ -61,6 +61,7 @@ class Geometry
   double getSamplingAlpha() { return mSamplingAlpha; }
   double getCrystalDeltaPhi() { return 2 * std::atan(mCrystalModW / 2 / mRMin); }
   double getSamplingDeltaPhi() { return 2 * std::atan(mSamplingModW / 2 / mRMin); }
+  double getFrontFaceMaxEta(int i);
   double getCrystalPhiMin();
   double getSamplingPhiMin();
   int getNModulesZ() { return mNModulesZ; }
diff --git a/Detectors/Upgrades/ALICE3/ECal/base/src/Geometry.cxx b/Detectors/Upgrades/ALICE3/ECal/base/src/Geometry.cxx
index 9483b83f19f49..2d6bdf160f393 100644
--- a/Detectors/Upgrades/ALICE3/ECal/base/src/Geometry.cxx
+++ b/Detectors/Upgrades/ALICE3/ECal/base/src/Geometry.cxx
@@ -73,11 +73,18 @@ double Geometry::getSamplingPhiMin()
   return (superModuleDeltaPhi - samplingDeltaPhi * mNSamplingModulesPhi) / 2.;
 }
 
+double Geometry::getFrontFaceMaxEta(int i)
+{
+  double theta = std::atan(mRMin / getFrontFaceZatMinR(i));
+  return -std::log(std::tan(theta / 2.));
+}
+
 //==============================================================================
 void Geometry::fillFrontFaceCenterCoordinates()
 {
-  if (mFrontFaceCenterR.size() > 0)
+  if (mFrontFaceCenterR.size() > 0) {
     return;
+  }
   mFrontFaceCenterTheta.resize(mNCrystalModulesZ + mNSamplingModulesZ);
   mFrontFaceZatMinR.resize(mNCrystalModulesZ + mNSamplingModulesZ);
   mFrontFaceCenterR.resize(mNCrystalModulesZ + mNSamplingModulesZ);
@@ -153,7 +160,7 @@ int Geometry::getCellID(int moduleId, int sectorId, bool isCrystal)
     if (sectorId % 2 == 0) { // sampling at positive eta
       cellID = sectorId / 2 * mNModulesZ + moduleId + mNSamplingModulesZ + mNCrystalModulesZ * 2;
     } else { // sampling at negative eta
-      cellID = sectorId / 2 * mNModulesZ - moduleId + mNSamplingModulesZ;
+      cellID = sectorId / 2 * mNModulesZ - moduleId + mNSamplingModulesZ - 1;
     }
   }
   return cellID;
@@ -206,13 +213,15 @@ void Geometry::detIdToGlobalPosition(int detId, double& x, double& y, double& z)
 {
   int chamber, sector, iphi, iz;
   detIdToRelIndex(detId, chamber, sector, iphi, iz);
+  double r = 0;
   if (iz < mNSamplingModulesZ + mNCrystalModulesZ) {
     z = -mFrontFaceCenterZ[mNSamplingModulesZ + mNCrystalModulesZ - iz - 1];
+    r = mFrontFaceCenterR[mNSamplingModulesZ + mNCrystalModulesZ - iz - 1];
   } else {
-    z = +mFrontFaceCenterZ[iz % (mNSamplingModulesZ + mNCrystalModulesZ)];
+    z = mFrontFaceCenterZ[iz % (mNSamplingModulesZ + mNCrystalModulesZ)];
+    r = mFrontFaceCenterR[iz % (mNSamplingModulesZ + mNCrystalModulesZ)];
   }
   double phi = chamber == 1 ? mFrontFaceCenterCrystalPhi[iphi] : mFrontFaceCenterSamplingPhi[iphi];
-  double r = mFrontFaceCenterR[iz % (mNSamplingModulesZ + mNCrystalModulesZ)];
   x = r * std::cos(phi);
   y = r * std::sin(phi);
 }
@@ -224,10 +233,12 @@ int Geometry::areNeighboursVertex(int detId1, int detId2) const
   int ch2, sector2, iphi2, iz2;
   detIdToRelIndex(detId1, ch1, sector1, iphi1, iz1);
   detIdToRelIndex(detId2, ch2, sector2, iphi2, iz2);
-  if (sector1 != sector2 || ch1 != ch2)
+  if (sector1 != sector2 || ch1 != ch2) {
     return 0;
-  if (std::abs(iphi1 - iphi2) <= 1 && std::abs(iz1 - iz2) <= 1)
+  }
+  if (std::abs(iphi1 - iphi2) <= 1 && std::abs(iz1 - iz2) <= 1) {
     return 1;
+  }
   return 0;
 }
 
@@ -235,29 +246,32 @@ int Geometry::areNeighboursVertex(int detId1, int detId2) const
 bool Geometry::isAtTheEdge(int cellId)
 {
   auto [row, col] = globalRowColFromIndex(cellId);
-  if (col == 0)
+  if (col == 0) {
     return 1;
-  if (col == mNSamplingModulesZ)
+  } else if (col == mNSamplingModulesZ) {
     return 1;
-  if (col == mNSamplingModulesZ - 1)
+  } else if (col == mNSamplingModulesZ - 1) {
     return 1;
-  if (col == mNSamplingModulesZ + 2 * mNCrystalModulesZ)
+  } else if (col == mNSamplingModulesZ + 2 * mNCrystalModulesZ) {
     return 1;
-  if (col == mNSamplingModulesZ + 2 * mNCrystalModulesZ - 1)
+  } else if (col == mNSamplingModulesZ + 2 * mNCrystalModulesZ - 1) {
     return 1;
-  if (col == mNModulesZ - 1)
+  } else if (col == mNModulesZ - 1) {
     return 1;
+  }
   for (int m = 0; m <= mNSuperModules; m++) {
     if (isCrystal(cellId)) {
-      if (row == m * mNCrystalModulesPhi)
+      if (row == m * mNCrystalModulesPhi) {
         return 1;
-      if (row == m * mNCrystalModulesPhi - 1)
+      } else if (row == m * mNCrystalModulesPhi - 1) {
         return 1;
+      }
     } else {
-      if (row == m * mNSamplingModulesPhi)
+      if (row == m * mNSamplingModulesPhi) {
         return 1;
-      if (row == m * mNSamplingModulesPhi - 1)
+      } else if (row == m * mNSamplingModulesPhi - 1) {
         return 1;
+      }
     }
   }
   return 0;
diff --git a/Detectors/Upgrades/ALICE3/ECal/reconstruction/include/ECalReconstruction/Clusterizer.h b/Detectors/Upgrades/ALICE3/ECal/reconstruction/include/ECalReconstruction/Clusterizer.h
index 3bb7cab4b11e3..5e4d36f831360 100644
--- a/Detectors/Upgrades/ALICE3/ECal/reconstruction/include/ECalReconstruction/Clusterizer.h
+++ b/Detectors/Upgrades/ALICE3/ECal/reconstruction/include/ECalReconstruction/Clusterizer.h
@@ -48,25 +48,33 @@ class Clusterizer
   void setClusteringThreshold(double threshold) { mClusteringThreshold = threshold; }
   void setCrystalDigitThreshold(double threshold) { mCrystalDigitThreshold = threshold; }
   void setSamplingDigitThreshold(double threshold) { mSamplingDigitThreshold = threshold; }
+  void setCrystalEnergyCorrectionPars(std::vector<double> pars) { mCrystalEnergyCorrectionPars = pars; }
+  void setSamplingEnergyCorrectionPars(std::vector<double> pars) { mSamplingEnergyCorrectionPars = pars; }
+  void setCrystalZCorrectionPars(std::vector<double> pars) { mCrystalZCorrectionPars = pars; }
+  void setSamplingZCorrectionPars(std::vector<double> pars) { mSamplingZCorrectionPars = pars; }
 
  private:
-  std::vector<std::vector<int>> mDigitIndices; // 2D map of digit indices used for recursive cluster finding
-  bool mUnfoldClusters = true;                 // to perform cluster unfolding
-  double mCrystalDigitThreshold = 0.040;       // minimal energy of crystal digit
-  double mSamplingDigitThreshold = 0.100;      // minimal energy of sampling digit
-  double mClusteringThreshold = 0.050;         // minimal energy of digit to start clustering (GeV)
-  double mClusteringTimeGate = 1e9;            // maximal time difference between digits to be accepted to clusters (in ns)
-  int mNLMMax = 30;                            // maximal number of local maxima in unfolding
-  double mLogWeight = 4.;                      // cutoff used in log. weight calculation
-  double mUnfogingEAccuracy = 1.e-4;           // accuracy of energy calculation in unfoding prosedure (GeV)
-  double mUnfogingXZAccuracy = 1.e-2;          // accuracy of position calculation in unfolding procedure (cm)
-  int mNMaxIterations = 100;                   // maximal number of iterations in unfolding procedure
-  double mLocalMaximumCut = 0.015;             // minimal height of local maximum over neighbours
-  bool mApplyCorrectionZ = 1;                  // z-correction
-  bool mApplyCorrectionE = 1;                  // energy-correction
-  TF1* fCrystalShowerShape;                    //! Crystal shower shape
-  TF1* fSamplingShowerShape;                   //! Sampling shower shape
-  TF1* fCrystalRMS;                            //! Crystal RMS
+  std::vector<std::vector<int>> mDigitIndices;       // 2D map of digit indices used for recursive cluster finding
+  bool mUnfoldClusters = true;                       // to perform cluster unfolding
+  double mCrystalDigitThreshold = 0.040;             // minimal energy of crystal digit
+  double mSamplingDigitThreshold = 0.100;            // minimal energy of sampling digit
+  double mClusteringThreshold = 0.050;               // minimal energy of digit to start clustering (GeV)
+  double mClusteringTimeGate = 1e9;                  // maximal time difference between digits to be accepted to clusters (in ns)
+  int mNLMMax = 30;                                  // maximal number of local maxima in unfolding
+  double mLogWeight = 4.;                            // cutoff used in log. weight calculation
+  double mUnfogingEAccuracy = 1.e-4;                 // accuracy of energy calculation in unfoding prosedure (GeV)
+  double mUnfogingXZAccuracy = 1.e-2;                // accuracy of position calculation in unfolding procedure (cm)
+  int mNMaxIterations = 100;                         // maximal number of iterations in unfolding procedure
+  double mLocalMaximumCut = 0.015;                   // minimal height of local maximum over neighbours
+  bool mApplyCorrectionZ = 1;                        // apply z-correction
+  bool mApplyCorrectionE = 1;                        // apply energy-correction
+  TF1* fCrystalShowerShape;                          //! Crystal shower shape
+  TF1* fSamplingShowerShape;                         //! Sampling shower shape
+  TF1* fCrystalRMS;                                  //! Crystal RMS
+  std::vector<double> mCrystalEnergyCorrectionPars;  // crystal energy-correction parameters
+  std::vector<double> mSamplingEnergyCorrectionPars; // sampling energy-correction parameters
+  std::vector<double> mCrystalZCorrectionPars;       // crystal z-correction parameters
+  std::vector<double> mSamplingZCorrectionPars;      // sampling z-correction parameters
 };
 
 } // namespace ecal
diff --git a/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/Clusterizer.cxx b/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/Clusterizer.cxx
index c84f62b60ec38..28efa78059dc1 100644
--- a/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/Clusterizer.cxx
+++ b/Detectors/Upgrades/ALICE3/ECal/reconstruction/src/Clusterizer.cxx
@@ -31,6 +31,45 @@ Clusterizer::Clusterizer(bool applyCorrectionZ, bool applyCorrectionE)
   mDigitIndices.resize(geo.getNrows(), std::vector<int>(geo.getNcols(), -1));
   mApplyCorrectionZ = applyCorrectionZ;
   mApplyCorrectionE = applyCorrectionE;
+
+  mCrystalEnergyCorrectionPars.reserve(6);
+  mCrystalEnergyCorrectionPars[0] = 0.00444;
+  mCrystalEnergyCorrectionPars[1] = -1.322;
+  mCrystalEnergyCorrectionPars[2] = 1.021;
+  mCrystalEnergyCorrectionPars[3] = 0.0018;
+  mCrystalEnergyCorrectionPars[4] = 0.;
+  mCrystalEnergyCorrectionPars[5] = 0.;
+
+  mSamplingEnergyCorrectionPars.reserve(6);
+  mSamplingEnergyCorrectionPars[0] = 0.0033;
+  mSamplingEnergyCorrectionPars[1] = -2.09;
+  mSamplingEnergyCorrectionPars[2] = 1.007;
+  mSamplingEnergyCorrectionPars[3] = 0.0667;
+  mSamplingEnergyCorrectionPars[4] = -0.108;
+  mSamplingEnergyCorrectionPars[5] = 0.0566;
+
+  mCrystalZCorrectionPars.reserve(9);
+  mCrystalZCorrectionPars[0] = -0.005187;
+  mCrystalZCorrectionPars[1] = 0.7301;
+  mCrystalZCorrectionPars[2] = -0.7382;
+  mCrystalZCorrectionPars[3] = 0.;
+  mCrystalZCorrectionPars[4] = 0.;
+  mCrystalZCorrectionPars[5] = 0.;
+  mCrystalZCorrectionPars[6] = 0.;
+  mCrystalZCorrectionPars[7] = 0.;
+  mCrystalZCorrectionPars[8] = 0.;
+
+  mSamplingZCorrectionPars.reserve(9);
+  mSamplingZCorrectionPars[0] = -2.137;
+  mSamplingZCorrectionPars[1] = 6.400;
+  mSamplingZCorrectionPars[2] = -3.342;
+  mSamplingZCorrectionPars[3] = -0.1364;
+  mSamplingZCorrectionPars[4] = 0.4019;
+  mSamplingZCorrectionPars[5] = -0.1969;
+  mSamplingZCorrectionPars[6] = 0.008223;
+  mSamplingZCorrectionPars[7] = -0.02425;
+  mSamplingZCorrectionPars[8] = 0.01190;
+
   fCrystalShowerShape = new TF1("fCrystal", "x<[1] ? [0]*exp([3]*x+[4]*x*x+[5]*x*x*x) : (x<[2] ? [0]*[6]*exp([7]*x+[8]*x*x) : [0]*[9]*exp([10]*x+[11]*x*x))", 0, 15);
   double pc[12];
   pc[0] = 1. / 13.15;
@@ -94,13 +133,14 @@ void Clusterizer::findClusters(const gsl::span<const Digit>& digits, std::vector
 void Clusterizer::addDigitToCluster(Cluster& cluster, int row, int col, const gsl::span<const Digit>& digits)
 {
   auto& geo = Geometry::instance();
-  if (row < 0 || row >= geo.getNrows() || col < 0 || col >= geo.getNcols())
+  if (row < 0 || row >= geo.getNrows() || col < 0 || col >= geo.getNcols()) {
     return;
+  }
   int digitIndex = mDigitIndices[row][col];
   LOGP(debug, "    checking row={} and col={} digitIndex={}", row, col, digitIndex);
-  if (digitIndex < 0)
+  if (digitIndex < 0) {
     return;
-
+  }
   const Digit& digit = digits[digitIndex];
   if (cluster.getMultiplicity() > 0) {
     // check if new digit is in the same chamber and sector
@@ -108,8 +148,9 @@ void Clusterizer::addDigitToCluster(Cluster& cluster, int row, int col, const gs
     auto [sector1, ch1] = geo.getSectorChamber(digit.getTower());
     auto [sector2, ch2] = geo.getSectorChamber(digit2.getTower());
     LOGP(debug, "    checking if sector and chamber are the same: ({},{}) ({},{})", sector1, ch1, sector2, ch2);
-    if (sector1 != sector2 || ch1 != ch2)
+    if (sector1 != sector2 || ch1 != ch2) {
       return;
+    }
   }
 
   mDigitIndices[row][col] = -1;
@@ -140,11 +181,13 @@ void Clusterizer::makeClusters(const gsl::span<const Digit>& digits, std::vector
     auto [row, col] = geo.globalRowColFromIndex(digit.getTower());
     bool isCrystal = geo.isCrystal(digit.getTower());
     if (isCrystal) {
-      if (digit.getEnergy() < mCrystalDigitThreshold)
+      if (digit.getEnergy() < mCrystalDigitThreshold) {
         continue;
+      }
     } else {
-      if (digit.getEnergy() < mSamplingDigitThreshold)
+      if (digit.getEnergy() < mSamplingDigitThreshold) {
         continue;
+      }
     }
     mDigitIndices[row][col] = i;
   }
@@ -153,10 +196,12 @@ void Clusterizer::makeClusters(const gsl::span<const Digit>& digits, std::vector
   for (int i = 0; i < nDigits; i++) {
     const Digit& digitSeed = digits[i];
     auto [row, col] = geo.globalRowColFromIndex(digitSeed.getTower());
-    if (mDigitIndices[row][col] < 0)
+    if (mDigitIndices[row][col] < 0) {
       continue; // digit was already added in one of the clusters
-    if (digitSeed.getEnergy() < mClusteringThreshold)
+    }
+    if (digitSeed.getEnergy() < mClusteringThreshold) {
       continue;
+    }
     LOGP(debug, "  starting new cluster at row={} and col={}", row, col);
     auto& cluster = clusters.emplace_back();
     addDigitToCluster(cluster, row, col, digits);
@@ -343,8 +388,9 @@ void Clusterizer::evalClusters(std::vector<Cluster>& clusters)
       double xi, yi, zi;
       geo.detIdToGlobalPosition(towerId, xi, yi, zi);
       double r = std::sqrt((x - xi) * (x - xi) + (y - yi) * (y - yi) + (z - zi) * (z - zi));
-      if (r > 2.2)
+      if (r > 2.2) {
         continue;
+      }
       double frac = fCrystalShowerShape->Eval(r);
       double rms = fCrystalRMS->Eval(r);
       chi2 += std::pow((energy / ee - frac) / rms, 2.);
@@ -354,38 +400,30 @@ void Clusterizer::evalClusters(std::vector<Cluster>& clusters)
 
     // correct cluster energy and z position
     float eta = std::abs(cluster.getEta());
-    float eCor = 1;
-    float zCor = 0;
     bool isCrystal = geo.isCrystal(cluster.getDigitTowerId(0));
-    if (isCrystal) {
-      eCor = 0.00444 * std::pow(ee, -1.322) + (1.021 + 0.0018 * eta);
-      if (mApplyCorrectionE)
-        ee *= eCor;
-      if (mApplyCorrectionZ)
-        zCor = (-0.00518682 + 0.730052 * eta - 0.73817 * eta * eta);
-    } else {
-      eCor = 0.0033 * std::pow(ee, -2.09) + (1.007 + 0.0667 * eta - 0.108 * eta * eta + 0.0566 * eta * eta * eta);
-      if (mApplyCorrectionE)
-        ee *= eCor;
-      if (mApplyCorrectionZ)
-        zCor = (-2.13679 + 6.40009 * eta - 3.34233 * eta * eta) + (-0.136425 + 0.401887 * eta - 0.196851 * eta * eta) * ee + (0.00822276 - 0.0242512 * eta + 0.0118986 * eta * eta) * ee * ee;
+    if (mApplyCorrectionE) {
+      std::vector<double>& pe = isCrystal ? mCrystalEnergyCorrectionPars : mSamplingEnergyCorrectionPars;
+      ee *= pe[0] * std::pow(ee, pe[1]) + pe[2] + pe[3] * eta + pe[4] * eta * eta + pe[5] * eta * eta * eta;
+      cluster.setE(ee);
+    }
+    if (mApplyCorrectionZ) {
+      std::vector<double>& pz = isCrystal ? mCrystalZCorrectionPars : mSamplingZCorrectionPars;
+      float zCor = (pz[0] + pz[1] * eta + pz[2] * eta * eta) + (pz[3] + pz[4] * eta + pz[5] * eta * eta) * ee + (pz[6] + pz[7] * eta + pz[8] * eta * eta) * ee * ee;
+      cluster.setZ(z > 0 ? z - zCor : z + zCor);
     }
-
-    cluster.setE(ee);
-    cluster.setZ(cluster.getZ() - zCor);
 
     // check if cluster is at the edge of detector module
     bool isEdge = 0;
     for (size_t i = 0; i < cluster.getMultiplicity(); i++) {
       int towerId = cluster.getDigitTowerId(i);
-      if (!geo.isAtTheEdge(towerId))
-        continue;
-      isEdge = 1;
-      break;
+      if (geo.isAtTheEdge(towerId)) {
+        isEdge = 1;
+        break;
+      }
     }
     cluster.setEdgeFlag(isEdge);
 
-    LOGF(debug, "Cluster coordinates: (%6.2f,%6.2f,%6.2f), eCor=%6.2f zCor=%6.2f", cluster.getX(), cluster.getY(), cluster.getZ(), eCor, zCor);
+    LOGF(debug, "Cluster coordinates: (%6.2f,%6.2f,%6.2f)", cluster.getX(), cluster.getY(), cluster.getZ());
   }
 }
 
@@ -403,8 +441,9 @@ int Clusterizer::getNumberOfLocalMax(Cluster& clu, int* maxAt, float* maxAtEnerg
   for (int i = 0; i < n; i++) {
     isLocalMax[i] = false;
     float en1 = clu.getDigitEnergy(i);
-    if (en1 > mClusteringThreshold)
+    if (en1 > mClusteringThreshold) {
       isLocalMax[i] = true;
+    }
   }
 
   for (int i = 0; i < n; i++) {
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/ECal/simulation/src/Detector.cxx
index 93089bb8ced14..f0de8aa4022a6 100644
--- a/Detectors/Upgrades/ALICE3/ECal/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/src/Detector.cxx
@@ -358,9 +358,9 @@ bool Detector::ProcessHits(FairVolume* vol)
     return false;
   }
 
-  if (isCrystal)
+  if (isCrystal) {
     LOGP(debug, "Processing crystal {}", volName.Data());
-  else {
+  } else {
     eloss *= mSamplingFactorTransportModel;
     LOGP(debug, "Processing scintillator {}", volName.Data());
   }
diff --git a/Detectors/Upgrades/ALICE3/ECal/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/ECal/simulation/src/Digitizer.cxx
index f213ba563d86d..42c1908a29d18 100644
--- a/Detectors/Upgrades/ALICE3/ECal/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/ECal/simulation/src/Digitizer.cxx
@@ -57,16 +57,18 @@ void Digitizer::processHits(const std::vector<Hit>* hits, std::vector<Digit>& di
     bool isCrystal = geo.isCrystal(cellID);
     if (isCrystal) { // crystal
       double elossSmearedNpe = gRandom->Poisson(eloss * mCrystalPePerGeV) / mCrystalPePerGeV;
-      if (mSmearCrystal)
+      if (mSmearCrystal) {
         elossSmeared = elossSmearedNpe * gRandom->Gaus(1, 0.007); // light attenuation in crystals
-    } else {                                                      // sampling
+      }
+    } else { // sampling
       elossSmeared *= mSamplingFraction;
     }
 
     Digit& digit = mArrayD[cellID];
     digit.setAmplitude(digit.getAmplitude() + elossSmeared);
-    if (t < digit.getTimeStamp())
+    if (t < digit.getTimeStamp()) {
       digit.setTimeStamp(t); // setting earliest time, TODO: add time smearing
+    }
     LOGF(debug, "  crystal: %d cellID = %5d, eloss = %8.5f elossSmeared = %8.5f time = %8.5f", isCrystal, cellID, eloss, elossSmeared, t);
 
     // Adding MC info

From 7994d1e7cdaf79fa6f8978589f84b7bec4fc2341 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 3 Oct 2025 14:11:44 +0200
Subject: [PATCH 0894/1764] DPL improve signposts when flushing metrics
 (#14711)

---
 Framework/Core/src/CommonServices.cxx | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 22324cd84b390..5a2876e074d29 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -826,30 +826,34 @@ auto flushMetrics(ServiceRegistryRef registry, DataProcessingStats& stats) -> vo
   auto& relayer = registry.get<DataRelayer>();
 
   // Send all the relevant metrics for the relayer to update the GUI
-  stats.flushChangedMetrics([&monitoring](DataProcessingStats::MetricSpec const& spec, int64_t timestamp, int64_t value) mutable -> void {
+  stats.flushChangedMetrics([&monitoring, sid](DataProcessingStats::MetricSpec const& spec, int64_t timestamp, int64_t value) mutable -> void {
     // convert timestamp to a time_point
     auto tp = std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>(std::chrono::milliseconds(timestamp));
     auto metric = o2::monitoring::Metric{spec.name, Metric::DefaultVerbosity, tp};
     if (spec.kind == DataProcessingStats::Kind::UInt64) {
       if (value < 0) {
-        LOG(debug) << "Value for " << spec.name << " is negative, setting to 0";
+        O2_SIGNPOST_EVENT_EMIT(monitoring_service, sid, "flushChangedMetrics", "Value for %{public}s is negative, setting to 0",
+                               spec.name.c_str());
         value = 0;
       }
       metric.addValue((uint64_t)value, "value");
     } else {
       if (value > (int64_t)std::numeric_limits<int>::max()) {
-        LOG(warning) << "Value for " << spec.name << " is too large, setting to INT_MAX";
+        O2_SIGNPOST_EVENT_EMIT(monitoring_service, sid, "flushChangedMetrics", "Value for %{public}s is too large, setting to INT_MAX",
+                               spec.name.c_str());
         value = (int64_t)std::numeric_limits<int>::max();
       }
       if (value < (int64_t)std::numeric_limits<int>::min()) {
+        O2_SIGNPOST_EVENT_EMIT(monitoring_service, sid, "flushChangedMetrics", "Value for %{public}s is too small, setting to INT_MIN",
+                               spec.name.c_str());
         value = (int64_t)std::numeric_limits<int>::min();
-        LOG(warning) << "Value for " << spec.name << " is too small, setting to INT_MIN";
       }
       metric.addValue((int)value, "value");
     }
     if (spec.scope == DataProcessingStats::Scope::DPL) {
       metric.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL);
     }
+    O2_SIGNPOST_EVENT_EMIT(monitoring_service, sid, "flushChangedMetrics", "Flushing metric %{public}s", spec.name.c_str());
     monitoring.send(std::move(metric));
   });
   relayer.sendContextState();

From 51669022939dd2472206f26bba03b3379ffce05b Mon Sep 17 00:00:00 2001
From: amorsch <andreas.morsch@cern.ch>
Date: Thu, 2 Oct 2025 11:31:09 +0200
Subject: [PATCH 0895/1764] extension of barrel volume to avoid extrusion of
 FOCAL

---
 Detectors/Passive/src/Cave.cxx | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/Detectors/Passive/src/Cave.cxx b/Detectors/Passive/src/Cave.cxx
index e2ea513095c72..208084a335ab5 100644
--- a/Detectors/Passive/src/Cave.cxx
+++ b/Detectors/Passive/src/Cave.cxx
@@ -85,23 +85,27 @@ void Cave::ConstructGeometry()
   shCaveTR1->DefineSection(0, -706. - 8.6, 0., 790.5);
   shCaveTR1->DefineSection(1, 707. + 7.6, 0., 790.5);
   TGeoTube* shCaveTR2 = new TGeoTube("shCaveTR2", 0., 150., 110.);
+  TGeoTube* shCaveTR3 = new TGeoTube("shCaveTR3", 0., 80., 75.);
 
   TGeoTranslation* transCaveTR2 = new TGeoTranslation("transTR2", 0, 30., -505. - 110.);
+  TGeoTranslation* transCaveTR3 = new TGeoTranslation("transTR3", 0, 30., 714.6 + 75.);
   transCaveTR2->RegisterYourself();
-  TGeoCompositeShape* shCaveTR = new TGeoCompositeShape("shCaveTR", "shCaveTR1-shCaveTR2:transTR2");
+  transCaveTR3->RegisterYourself();
+
+  TGeoCompositeShape* shCaveTR = new TGeoCompositeShape("shCaveTR", "shCaveTR1-shCaveTR2:transTR2+shCaveTR3:transTR3");
   TGeoVolume* voBarrel = new TGeoVolume("barrel", shCaveTR, kMedAir);
   cavevol->AddNode(voBarrel, 1, new TGeoTranslation(0., -30., 0.));
   if (mHasRB24) { // should be not true only for alice 3
     // mother volume for RB24 side (FDD, Compensator)
-    const Float_t kRB24CL = 2. * 597.9;
+    const Float_t kRB24CL = 2. * 597.9 - 150.;
     auto shCaveRB24 = new TGeoPcon(0., 360., 6);
-    Float_t z0 = kRB24CL / 2 + 714.6;
+    Float_t z0 = kRB24CL / 2 + 714.6 + 150.;
     shCaveRB24->DefineSection(0, -kRB24CL / 2., 0., 105.);
     shCaveRB24->DefineSection(1, -z0 + 1705., 0., 105.);
     shCaveRB24->DefineSection(2, -z0 + 1705., 0., 14.5);
-    shCaveRB24->DefineSection(3, -z0 + 1880., 0., 14.5);
-    shCaveRB24->DefineSection(4, -z0 + 1880., 0., 40.0);
-    shCaveRB24->DefineSection(5, kRB24CL / 2, 0., 40.0);
+    shCaveRB24->DefineSection(3, -z0 + 1878, 0., 14.5);
+    shCaveRB24->DefineSection(4, -z0 + 1878., 0., 40.0);
+    shCaveRB24->DefineSection(5, kRB24CL / 2., 0., 40.0);
 
     TGeoVolume* caveRB24 = new TGeoVolume("caveRB24", shCaveRB24, kMedAir);
     caveRB24->SetVisibility(0);

From 166180af16ecac7fa234714cdd7ae0394ea5a192 Mon Sep 17 00:00:00 2001
From: amorsch <andreas.morsch@cern.ch>
Date: Thu, 2 Oct 2025 11:34:00 +0200
Subject: [PATCH 0896/1764] beampipes adapted to new barrel and corrections:
 overlaps, gaps, Alu instead of vaccum was used in front of FOCAL

---
 .../include/DetectorsPassive/PipeRun4.h       |   2 +-
 Detectors/Passive/src/Pipe.cxx                |   6 +-
 Detectors/Passive/src/PipeRun4.cxx            | 117 ++++++++----------
 3 files changed, 56 insertions(+), 69 deletions(-)

diff --git a/Detectors/Passive/include/DetectorsPassive/PipeRun4.h b/Detectors/Passive/include/DetectorsPassive/PipeRun4.h
index 1943bb25a802f..5eadb7af1003c 100644
--- a/Detectors/Passive/include/DetectorsPassive/PipeRun4.h
+++ b/Detectors/Passive/include/DetectorsPassive/PipeRun4.h
@@ -46,7 +46,7 @@ class PipeRun4 : public PassiveBase
   TGeoPcon* makeMotherFromTemplate(const TGeoPcon* shape, int imin = -1, int imax = -1, float r0 = 0.,
                                    int nz = -1);
   TGeoPcon* makeInsulationFromTemplate(TGeoPcon* shape);
-  TGeoVolume* makeBellow(const char* ext, int nc, float rMin, float rMax, float dU, float rPlie,
+  TGeoVolume* makeBellow(const char* ext, int nc, float rMin, float rMax, float rPlie,
                          float dPlie);
   TGeoVolume* makeBellowCside(const char* ext, int nc, float rMin, float rMax, float rPlie, float dPlie);
 
diff --git a/Detectors/Passive/src/Pipe.cxx b/Detectors/Passive/src/Pipe.cxx
index 56f6429bc73c8..56ccfc45f0b89 100644
--- a/Detectors/Passive/src/Pipe.cxx
+++ b/Detectors/Passive/src/Pipe.cxx
@@ -786,13 +786,13 @@ void Pipe::ConstructGeometry()
 
   // Copper Tube RB24/1
   const Float_t kRB24CuTubeL = 381.5;
-  const Float_t kRB24cCuTubeL = 155.775;
+  const Float_t kRB24cCuTubeL = 155.775 - 150.;
   const Float_t kRB24bCuTubeL = kRB24CuTubeL - kRB24cCuTubeL;
   const Float_t kRB24CuTubeRi = 8.0 / 2.;
   const Float_t kRB24CuTubeRo = 8.4 / 2.;
   const Float_t kRB24CuTubeFRo = 7.6;
   const Float_t kRB24CuTubeFL = 1.86;
-  const Float_t kRB24CL = 2. * 597.9;
+  const Float_t kRB24CL = 2. * 597.9 - 150.;
   //
   // introduce cut at end of barrel 714.6m
   //
@@ -812,7 +812,7 @@ void Pipe::ConstructGeometry()
   voRB24cCuTubeM->AddNode(voRB24cCuTube, 1, gGeoIdentity);
 
   // Air outside tube with higher transport cuts
-  TGeoVolume* voRB24CuTubeA = new TGeoVolume("voRB24CuTubeA", new TGeoTube(80., 81., kRB24bCuTubeL / 2.), kMedAirHigh);
+  TGeoVolume* voRB24CuTubeA = new TGeoVolume("voRB24CuTubeA", new TGeoTube(79., 80., kRB24bCuTubeL / 2.), kMedAirHigh);
   voRB24CuTubeA->SetVisibility(0);
 
   // Simplified DN 100 Flange
diff --git a/Detectors/Passive/src/PipeRun4.cxx b/Detectors/Passive/src/PipeRun4.cxx
index 0403624f23b4c..5aa0b63a6ac78 100644
--- a/Detectors/Passive/src/PipeRun4.cxx
+++ b/Detectors/Passive/src/PipeRun4.cxx
@@ -642,7 +642,7 @@ void PipeRun4::ConstructGeometry()
   // Drawings from C. Gargiulo :
   // \\cern.ch\dfs\Workspaces\c\cgargiul\EXPERIMENT\ALICE\ALICE_MECHANICS\ALICE_DATA_PACKAGE\IN\DETECTORS\ITS_UPGRADE\1-DESIGN\0-IF_Control_Drawing\20140207_ICD_ITS_MFT_BP
   /////////////////////////////////////////////////////////////////////
-
+  TGeoVolumeAssembly* beamPipeAsideSection = new TGeoVolumeAssembly("BeamPipeAsideSection");
   float kConicalBerilliumMinThickness = 0.08;
   float kConicalBerilliumMaxThickness = 0.1;
   float kFlangeZ = 483.75;
@@ -656,33 +656,34 @@ void PipeRun4::ConstructGeometry()
   float kConicalBePipeEndOuterRadius = 3.0;
 
   TGeoPcon* tube0 = new TGeoPcon(0., 360., 5);
-  tube0->DefineSection(0, kFlangeZ - kFlangeWidth / 2, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness, kConicalBePipeEndOuterRadius);
-  tube0->DefineSection(1, kConicalBerylliumEnd, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness, kConicalBePipeEndOuterRadius);
+  tube0->DefineSection(0, kFlangeZ - kFlangeWidth / 2, kConicalBePipeEndOuterRadius - kConicalBerilliumMinThickness, kConicalBePipeEndOuterRadius);
+  tube0->DefineSection(1, kConicalBerylliumEnd, kConicalBePipeEndOuterRadius - kConicalBerilliumMinThickness, kConicalBePipeEndOuterRadius);
   tube0->DefineSection(2, kSupport1 + kSupportWidth, kPipeRadiusAtSupport1 - kConicalBerilliumMinThickness, kPipeRadiusAtSupport1);
   tube0->DefineSection(3, kSupport1, kPipeRadiusAtSupport1 - kConicalBerilliumMinThickness, kPipeRadiusAtSupport1);
   tube0->DefineSection(4, kBeryliumSectionZmax, kBeryliumSectionOuterRadius - kConicalBerilliumMinThickness, kBeryliumSectionOuterRadius); // need a transition to kConicalBerilliumMaxThickness
 
-  TGeoPcon* tube0vide = new TGeoPcon(0., 360., 5);
-  tube0vide->DefineSection(0, kFlangeZ - kFlangeWidth / 2, 0., kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness - 0.01);
-  tube0vide->DefineSection(1, kConicalBerylliumEnd, 0., kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness - 0.01);
-  tube0vide->DefineSection(2, kSupport1 + kSupportWidth, 0, kPipeRadiusAtSupport1 - kConicalBerilliumMinThickness - 0.01);
-  tube0vide->DefineSection(3, kSupport1, 0, kPipeRadiusAtSupport1 - kConicalBerilliumMinThickness - 0.01);
-  tube0vide->DefineSection(4, kBeryliumSectionZmax, 0., kBeryliumSectionOuterRadius - kConicalBerilliumMinThickness - 0.01);
+  TGeoPcon* tube0Mo = new TGeoPcon(0., 360., 5);
+  tube0Mo->DefineSection(0, kFlangeZ - kFlangeWidth / 2, 0., kConicalBePipeEndOuterRadius);
+  tube0Mo->DefineSection(1, kConicalBerylliumEnd, 0., kConicalBePipeEndOuterRadius);
+  tube0Mo->DefineSection(2, kSupport1 + kSupportWidth, 0, kPipeRadiusAtSupport1);
+  tube0Mo->DefineSection(3, kSupport1, 0, kPipeRadiusAtSupport1);
+  tube0Mo->DefineSection(4, kBeryliumSectionZmax, 0., kBeryliumSectionOuterRadius);
 
   TGeoVolume* votube0 = new TGeoVolume("votube0", tube0, kMedBe);
   votube0->SetLineColor(kRed);
-  TGeoVolume* votube0vide = new TGeoVolume("votube0vide", tube0vide, kMedVac);
-  votube0vide->SetLineColor(kGreen);
+  TGeoVolume* votube0Mo = new TGeoVolume("votube0Mo", tube0Mo, kMedVac);
+  votube0Mo->AddNode(votube0, 1, gGeoIdentity);
+  votube0Mo->SetLineColor(kGreen);
 
-  barrel->AddNode(votube0, 1, new TGeoTranslation(0., 30., 0.));
-  barrel->AddNode(votube0vide, 1, new TGeoTranslation(0., 30., 0.));
+  beamPipeAsideSection->AddNode(votube0Mo, 1, gGeoIdentity);
 
-  TGeoVolume* beampipeSupportA1 = makeSupportBar("A1", kPipeRadiusAtSupport1 + 0.01, kPipeRadiusAtSupport1 + 0.38, 20.67, 14.25);
-  barrel->AddNode(beampipeSupportA1, 1, new TGeoTranslation(0., 30, kSupport1 + kSupportWidth / 2.));
+  //  already defined in IT3
+  //  TGeoVolume* beampipeSupportA1 = makeSupportBar("A1", kPipeRadiusAtSupport1 + 0.01, kPipeRadiusAtSupport1 + 0.38, 20.67, 14.25);
+  //  beamPipeAsideSection->AddNode(beampipeSupportA1, 1, new TGeoTranslation(0., 0., kSupport1 + kSupportWidth / 2.));
 
   // Length is approximate
   TGeoVolume* beampipeSupportA2 = makeSupportBar("A2", kConicalBePipeEndOuterRadius, kConicalBePipeEndOuterRadius + 0.38, 44, 37.5);
-  barrel->AddNode(beampipeSupportA2, 1, new TGeoTranslation(0., 30, kConicalBerylliumEnd + kSupportWidth / 2.));
+  beamPipeAsideSection->AddNode(beampipeSupportA2, 1, new TGeoTranslation(0., 0., kConicalBerylliumEnd + kSupportWidth / 2.));
 
   TGeoPcon* Bolt1 = new TGeoPcon(0., 360, 8);
   Bolt1->DefineSection(0, 0, 0, 0.5);
@@ -734,7 +735,7 @@ void PipeRun4::ConstructGeometry()
   Bolts->AddNode(volBolt1, 7, t7);
   Bolts->AddNode(volBolt1, 8, t8);
 
-  barrel->AddNode(Bolts, 1, new TGeoTranslation(0., 30., 0.));
+  beamPipeAsideSection->AddNode(Bolts, 1, gGeoIdentity);
 
   TGeoTranslation* Tflange = new TGeoTranslation(0, 0, kFlangeZ);
   Tflange->SetName("Tflange");
@@ -753,53 +754,40 @@ void PipeRun4::ConstructGeometry()
   TGeoVolume* volflange = new TGeoVolume("voFlangeHoles", FlangeWithHoles, kMedAlBe);
   volflange->SetLineWidth(2);
   volflange->SetLineColor(kGray);
-
-  barrel->AddNode(volflange, 1, new TGeoTranslation(0., 30., 0.));
-
-  TGeoPcon* pipeSamell = new TGeoPcon(0., 360., 2);
-  pipeSamell->DefineSection(0, kFlangeZ + kFlangeWidth / 2, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness, kConicalBePipeEndOuterRadius);
-  pipeSamell->DefineSection(1, kFlangeZ + 5.13 + 0.435 + 0.4 + 0.08, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness, kConicalBePipeEndOuterRadius);
-  pipeSamell->SetName("pipeSamell");
-
-  TGeoVolume* VolpipeSmall = new TGeoVolume("voPipeSmallVac", pipeSamell, kMedAlu2219);
-  VolpipeSmall->SetLineWidth(2);
-  barrel->AddNode(VolpipeSmall, 1, new TGeoTranslation(0., 30., 0.));
-
-  TGeoPcon* pipeSmallVac = new TGeoPcon(0., 360., 2);
-  pipeSmallVac->DefineSection(0, kFlangeZ + kFlangeWidth / 2, 0, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness - 0.01);
-  pipeSmallVac->DefineSection(1, kFlangeZ + 5.13 + 0.435 + 0.4 + 0.08, 0, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness - 0.01);
-  TGeoVolume* vopipeSmallVac = new TGeoVolume("voPipeSmallVac", pipeSmallVac, kMedVac);
-  vopipeSmallVac->SetLineColor(kGreen);
-
-  barrel->AddNode(vopipeSmallVac, 1, new TGeoTranslation(0., 30., 0.));
+  beamPipeAsideSection->AddNode(volflange, 1, gGeoIdentity);
 
   //  -- Bellows on A side
-  // float plieradius = (3.72 + (2. *  7 - 2.) * 0.03) / (4. * 7);  // radius of bellows "plis"
   float plieradiusA = 0.2; // radius of bellow plies
-
   // ------------------ First Bellow  --------------------
   // Inner: 3.0 cm, outer 3.97 cm length 8.47 cm with 10 wiggles
-  // check meaning of dU ; it is probably the total length, see also below
-  TGeoVolume* vobellows1A = makeBellow("bellows1A", 10, 3.0, 3.97, 8.47, plieradiusA, 0.03);
-  // Z position is rough for now.
-  barrel->AddNode(vobellows1A, 1, new TGeoTranslation(0., 30., kFlangeZ + 10));
+  TGeoVolume* vobellows1A = makeBellow("bellows1A", 10, 3.0, 3.97, plieradiusA, 0.03);
+  Float_t dU = (static_cast<TGeoTube*>(vobellows1A->GetShape()))->GetDZ();
+  beamPipeAsideSection->AddNode(vobellows1A, 1, new TGeoTranslation(0., 0., kFlangeZ + 2. * dU));
   // Comments: removing 1/2 plie (see makeBellow):  0.31= 2*0.17-0.03    and   0.08: free space
+  Float_t pipeSmallDz = (dU - kFlangeWidth / 2.) / 2.;
+  TGeoTube* pipeSmall = new TGeoTube("pipeSmall", kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness, kConicalBePipeEndOuterRadius, pipeSmallDz);
+  TGeoVolume* vopipeSmall = new TGeoVolume("voPipeSmall", pipeSmall, kMedAlu2219);
+  vopipeSmall->SetLineWidth(2);
 
-  // ------------------ Outer pipe after flange  --------------------
-  TGeoPcon* pipeOut = new TGeoPcon(0., 360., 2);
-  pipeOut->DefineSection(0, kFlangeZ + 13.6 - 0.08, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness, kConicalBePipeEndOuterRadius);
-  pipeOut->DefineSection(1, 714.6, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness, kConicalBePipeEndOuterRadius);
+  TGeoTube* pipeSmallMo = new TGeoTube(0., kConicalBePipeEndOuterRadius, pipeSmallDz);
+  TGeoVolume* vopipeSmallMo = new TGeoVolume("voPipeSmallMo", pipeSmallMo, kMedVac);
+  vopipeSmallMo->SetLineColor(kGreen);
+  vopipeSmallMo->AddNode(vopipeSmall, 1, gGeoIdentity);
 
-  TGeoVolume* OuterPIPE = new TGeoVolume("pipeOut", pipeOut, kMedAlu2219);
-  barrel->AddNode(OuterPIPE, 1, new TGeoTranslation(0., 30., 0.));
+  beamPipeAsideSection->AddNode(vopipeSmallMo, 1, new TGeoTranslation(0., 0., kFlangeZ + kFlangeWidth / 2. + pipeSmallDz));
 
-  // The end of the barrel volume is at 714.6 cm, after that we start with RB24 volume
-  TGeoPcon* pipeOutVac = new TGeoPcon(0., 360., 2);
-  pipeOutVac->DefineSection(0, kFlangeZ + 13.6 - 0.08, 0, kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness);
-  pipeOutVac->DefineSection(1, 714.6, 0., kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness);
+  // ------------------ Outer pipe after flange  --------------------
+  // The end of the barrel volume is at 864.6 cm, after that we start with RB24 volume
+  Float_t pipeEndZ = 864.6;
+  Float_t pipeOutDz = (pipeEndZ - (kFlangeZ + 3. * dU)) / 2.;
+  TGeoTube* pipeOut = new TGeoTube(kConicalBePipeEndOuterRadius - kConicalBerilliumMaxThickness, kConicalBePipeEndOuterRadius, pipeOutDz);
+  TGeoVolume* OuterPIPE = new TGeoVolume("pipeOut", pipeOut, kMedAlu2219);
 
-  TGeoVolume* OuterPIPEVac = new TGeoVolume("pipeOutVac", pipeOutVac, kMedAlu2219);
-  barrel->AddNode(OuterPIPEVac, 1, new TGeoTranslation(0., 30., 0.));
+  TGeoTube* pipeOutMo = new TGeoTube(0., kConicalBePipeEndOuterRadius, pipeOutDz);
+  TGeoVolume* OuterPIPEMo = new TGeoVolume("pipeOutMo", pipeOutMo, kMedVac);
+  OuterPIPEMo->AddNode(OuterPIPE, 1, gGeoIdentity);
+  beamPipeAsideSection->AddNode(OuterPIPEMo, 1, new TGeoTranslation(0., 0., pipeEndZ - pipeOutDz));
+  barrel->AddNode(beamPipeAsideSection, 1, new TGeoTranslation(0., 30., 0.));
 
   //-------------------------------------------------
 
@@ -822,19 +810,19 @@ void PipeRun4::ConstructGeometry()
 
   // Copper Tube RB24/1
   const float kRB24CuTubeL = 381.5;
-  const float kRB24cCuTubeL = 155.775 + (28.375 - 18.135);
+  const float kRB24cCuTubeL = 155.775 - 150.;
   const float kRB24bCuTubeL = kRB24CuTubeL - kRB24cCuTubeL;
   const float kRB24CuTubeRi = 5.8 / 2.;
   const float kRB24CuTubeRo = 6.0 / 2.;
   const float kRB24CuTubeFRo = 7.6;
   const float kRB24CuTubeFL = 1.86;
-  const float kRB24CL = 2. * 597.9;
+  const float kRB24CL = 2. * 597.9 - 150.;
 
   //
   // introduce cut at end of barrel 714.6m
   //
   // outside barrel
-  TGeoVolume* voRB24cCuTubeM = new TGeoVolume("voRB24cCuTubeM", new TGeoTube(0., kRB24CuTubeRi, kRB24cCuTubeL / 2.), kMedVacNFHC);
+  TGeoVolume* voRB24cCuTubeM = new TGeoVolume("voRB24cCuTubeM", new TGeoTube(0., kRB24CuTubeRo, kRB24cCuTubeL / 2.), kMedVacNFHC);
   TGeoVolume* voRB24cCuTube = new TGeoVolume("voRB24cCuTube", new TGeoTube(kRB24CuTubeRi, kRB24CuTubeRo, kRB24cCuTubeL / 2.), kMedAlu2219);
   voRB24cCuTubeM->AddNode(voRB24cCuTube, 1, gGeoIdentity);
 
@@ -876,7 +864,7 @@ void PipeRun4::ConstructGeometry()
   const float kRB24B1PlieThickness = 0.015; // Plie thickness
 
   const float kRB24B1PlieRadius =
-    (kRB24B1BellowUndL + (2. * kRB24B1NumberOfPlies - 2.) * kRB24B1PlieThickness) / (4. * kRB24B1NumberOfPlies);
+    (kRB24B1BellowUndL + 2. * kRB24B1NumberOfPlies * kRB24B1PlieThickness) / (4. * kRB24B1NumberOfPlies + 2.);
 
   const float kRB24B1ProtTubeThickness = 0.02; // Thickness of the protection tube
   const float kRB24B1ProtTubeLength = 4.2;     // Length of the protection tube
@@ -892,7 +880,7 @@ void PipeRun4::ConstructGeometry()
   //
   // Bellow Section
   TGeoVolume* voRB24B1Bellow = makeBellow("RB24B1", kRB24B1NumberOfPlies, kRB24B1BellowRi, kRB24B1BellowRo,
-                                          kRB24B1BellowUndL, kRB24B1PlieRadius, kRB24B1PlieThickness);
+                                          kRB24B1PlieRadius, kRB24B1PlieThickness);
   voRB24B1Bellow->SetVisibility(0);
   float newRB24B1BellowUndL = 2 * (static_cast<TGeoTube*>(voRB24B1Bellow->GetShape()))->GetDz();
 
@@ -2840,13 +2828,11 @@ TGeoPcon* PipeRun4::makeInsulationFromTemplate(TGeoPcon* shape)
   return insu;
 }
 
-TGeoVolume* PipeRun4::makeBellow(const char* ext, int nc, float rMin, float rMax, float dU, float rPlie,
-                                 float dPlie)
+TGeoVolume* PipeRun4::makeBellow(const char* ext, int nc, float rMin, float rMax, float rPlie, float dPlie)
 {
   // nc     Number of convolution
   // rMin   Inner radius of the bellow
   // rMax   Outer radius of the bellow
-  // dU     Undulation length
   // rPlie  Plie radius
   // dPlie  Plie thickness
   auto& matmgr = o2::base::MaterialManager::Instance();
@@ -2896,10 +2882,10 @@ TGeoVolume* PipeRun4::makeBellow(const char* ext, int nc, float rMin, float rMax
   asWiggle->AddNode(voWiggleL, 1, new TGeoTranslation(0., 0., z0));
   asWiggle->GetShape()->ComputeBBox(); // enforce recomputing of BBox
   //
-  float zBellowTot = nc * (static_cast<TGeoBBox*>(asWiggle->GetShape()))->GetDZ();
-  TGeoVolume* voBellow = new TGeoVolume(fmt::format("{:s}BellowUS", ext).c_str(), new TGeoTube(rMin, rMax, zBellowTot), kMedVac);
+  float zBellowTot = nc * (2. * (static_cast<TGeoBBox*>(asWiggle->GetShape()))->GetDZ() - dPlie) + 2. * rPlie;
+  TGeoVolume* voBellow = new TGeoVolume(fmt::format("{:s}BellowUS", ext).c_str(), new TGeoTube(rMin, rMax, zBellowTot / 2.), kMedVac);
   // Positioning of the volumes
-  z0 = -dU / 2. + rPlie;
+  z0 = -zBellowTot / 2. + rPlie;
   voBellow->AddNode(voWiggleL, 2, new TGeoTranslation(0., 0., z0));
   z0 += rPlie;
   float zsh = 4. * rPlie - 2. * dPlie;
@@ -2907,6 +2893,7 @@ TGeoVolume* PipeRun4::makeBellow(const char* ext, int nc, float rMin, float rMax
     float zpos = z0 + iw * zsh;
     voBellow->AddNode(asWiggle, iw + 1, new TGeoTranslation(0., 0., zpos - dPlie));
   }
+
   return voBellow;
 }
 

From 5a1a8cdd62d4f299bd66a975fe54d2af0579f44c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 24 Sep 2025 21:34:38 +0200
Subject: [PATCH 0897/1764] TPC: Add option to write reduced clusterNative,
 removing rejected clusters

---
 .../DataCompression/GPUTPCCompression.h       |  1 +
 .../GPUTPCCompressionKernels.cxx              | 53 +++++++++--------
 GPU/GPUTracking/DataTypes/GPUDataTypes.h      |  1 +
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  8 +++
 GPU/GPUTracking/Global/GPUChainTracking.h     |  3 +-
 .../Global/GPUChainTrackingClusterizer.cxx    |  8 +--
 .../Global/GPUChainTrackingCompression.cxx    | 58 +++++++++++++++++++
 .../Global/GPUChainTrackingMerger.cxx         |  4 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |  3 +
 10 files changed, 107 insertions(+), 33 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
index 52585b4c08b24..1dafffaeea043 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
@@ -89,6 +89,7 @@ class GPUTPCCompression : public GPUProcessor
   void SetPointersCompressedClusters(void*& mem, T& c, uint32_t nClA, uint32_t nTr, uint32_t nClU, bool reducedClA);
   template <class T>
   GPUd() static void truncateSignificantBits(T& val, uint32_t nBits, uint32_t max);
+  GPUd() bool rejectCluster(int32_t idx, GPUParam& param, const GPUTrackingInOutPointers& ioPtrs);
 
   int16_t mMemoryResOutputHost = -1;
   int16_t mMemoryResOutputGPU = -1;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 5503eeb30cdd6..d5567bb5148d9 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -183,6 +183,31 @@ GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<4>::opera
   return mClsPtr[a].qTot < mClsPtr[b].qTot;
 }
 
+GPUd() bool GPUTPCCompression::rejectCluster(int32_t idx, GPUParam& GPUrestrict() param, const GPUTrackingInOutPointers& GPUrestrict() ioPtrs)
+{
+  if (mClusterStatus[idx]) {
+    return true;
+  }
+  int32_t attach = ioPtrs.mergedTrackHitAttachment[idx];
+  bool unattached = attach == 0;
+
+  if (unattached) {
+    if (param.rec.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyB) {
+      return true;
+    }
+  } else if (param.rec.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyA) {
+    if (GPUTPCClusterRejection::GetIsRejected(attach)) {
+      return true;
+    }
+    int32_t id = attach & gputpcgmmergertypes::attachTrackMask;
+    auto& trk = ioPtrs.mergedTracks[id];
+    if (CAMath::Abs(trk.GetParam().GetQPt() * param.qptB5Scaler) > param.rec.tpc.rejectQPtB5 || trk.MergedLooper()) {
+      return true;
+    }
+  }
+  return false;
+}
+
 template <>
 GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1unattached>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() processors)
 {
@@ -208,33 +233,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
     const uint32_t nn = CAMath::nextMultipleOf<GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached)>(clusters->nClusters[iSector][iRow]);
     for (uint32_t i = iThread; i < nn + nThreads; i += nThreads) {
       const int32_t idx = idOffset + i;
-      int32_t storeCluster = 0;
-      do {
-        if (i >= clusters->nClusters[iSector][iRow]) {
-          break;
-        }
-        if (compressor.mClusterStatus[idx]) {
-          break;
-        }
-        int32_t attach = ioPtrs.mergedTrackHitAttachment[idx];
-        bool unattached = attach == 0;
-
-        if (unattached) {
-          if (processors.param.rec.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyB) {
-            break;
-          }
-        } else if (processors.param.rec.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyA) {
-          if (GPUTPCClusterRejection::GetIsRejected(attach)) {
-            break;
-          }
-          int32_t id = attach & gputpcgmmergertypes::attachTrackMask;
-          auto& trk = ioPtrs.mergedTracks[id];
-          if (CAMath::Abs(trk.GetParam().GetQPt() * processors.param.qptB5Scaler) > processors.param.rec.tpc.rejectQPtB5 || trk.MergedLooper()) {
-            break;
-          }
-        }
-        storeCluster = 1;
-      } while (false);
+      int32_t storeCluster = i < clusters->nClusters[iSector][iRow] && !compressor.rejectCluster(idx, param, ioPtrs);
 
       GPUbarrier();
       int32_t myIndex = work_group_scan_inclusive_add(storeCluster);
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.h b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
index 801c60f6b02ba..967d6a73914dd 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
@@ -245,6 +245,7 @@ struct GPUTrackingInOutPointers {
   uint32_t nOutputClusRefsTPCO2 = 0;
   const o2::MCCompLabel* outputTracksTPCO2MC = nullptr;
   const o2::tpc::CompressedClustersFlat* tpcCompressedClusters = nullptr;
+  const o2::tpc::ClusterNativeAccess* clustersNativeReduced = nullptr;
 
   // TPC links
   int32_t* tpcLinkITS = nullptr;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 8b5f70f25a4d9..30477d67fdc4f 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -361,6 +361,7 @@ AddOption(tpcMaxAttachedClustersPerSectorRow, uint32_t, 51000, "", 0, "Maximum n
 AddOption(tpcUseOldCPUDecoding, bool, false, "", 0, "Enable old CPU-based TPC decoding")
 AddOption(tpcApplyCFCutsAtDecoding, bool, false, "", 0, "Apply cluster cuts from clusterization during decoding of compressed clusters")
 AddOption(tpcApplyClusterFilterOnCPU, uint8_t, 0, "", 0, "Apply custom cluster filter of GPUTPCClusterFilter class, 0: off, 1: debug, 2: PbPb23")
+AddOption(tpcWriteClustersAfterRejection, bool, false, "", 0, "Apply TPC rejection strategy before writing clusters")
 AddOption(oclPlatformNum, int32_t, -1, "", 0, "Platform to use, in case the backend provides multiple platforms (OpenCL only, -1 = auto-select, -2 query all platforms (also incompatible))")
 AddOption(oclCompileFromSources, bool, false, "", 0, "Compile OpenCL binary from included source code instead of using included spirv code")
 AddOption(oclOverrideSourceBuildFlags, std::string, "", "", 0, "Override OCL build flags for compilation from source, put a space for empty options")
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index f47c6923a6be7..91870f981d542 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -273,6 +273,10 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("Clusterizer and merger Sanity checks only supported when not running on GPU");
     return false;
   }
+  if (GetProcessingSettings().tpcWriteClustersAfterRejection && (mRec->IsGPU() || param().rec.tpc.compressionTypeMask || !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCCompression))) {
+    GPUError("tpcWriteClustersAfterRejection requires compressionTypeMask = 0, no GPU usage, and compression enabled");
+    return false;
+  }
   if (GetProcessingSettings().doublePipeline) {
     if (!GetRecoStepsOutputs().isOnlySet(GPUDataTypes::InOutType::TPCMergedTracks, GPUDataTypes::InOutType::TPCCompressedClusters, GPUDataTypes::InOutType::TPCClusters)) {
       GPUError("Invalid outputs for double pipeline mode 0x%x", (uint32_t)GetRecoStepsOutputs());
@@ -543,6 +547,10 @@ void GPUChainTracking::ClearIOPointers()
   std::memset((void*)&mIOPtrs, 0, sizeof(mIOPtrs));
   mIOMem.~InOutMemory();
   new (&mIOMem) InOutMemory;
+  mClusterNativeAccessReduced.reset(nullptr);
+  if (mClusterNativeAccess.get()) {
+    memset((void*)mClusterNativeAccess.get(), 0, sizeof(*mClusterNativeAccess));
+  }
 }
 
 void GPUChainTracking::AllocateIOMemory()
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 5c85147494711..8de49cc954e35 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -265,7 +265,7 @@ class GPUChainTracking : public GPUChain
   std::unique_ptr<o2::trd::GeometryFlat> mTRDGeometryU;              // TRD Geometry
 
   // Ptrs to internal buffers
-  std::unique_ptr<o2::tpc::ClusterNativeAccess> mClusterNativeAccess;
+  std::unique_ptr<o2::tpc::ClusterNativeAccess> mClusterNativeAccess, mClusterNativeAccessReduced;
   std::array<GPUOutputControl*, GPUTrackingOutputs::count()> mSubOutputControls = {nullptr};
   std::unique_ptr<GPUTriggerOutputs> mTriggerBuffer;
 
@@ -305,6 +305,7 @@ class GPUChainTracking : public GPUChain
   void RunTPCTrackingMerger_Resolve(int8_t useOrigTrackParam, int8_t mergeAll, GPUReconstruction::krnlDeviceType deviceType);
   void RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* clusters, std::function<o2::tpc::ClusterNative*(size_t)> allocator, bool applyClusterCuts);
   bool NeedTPCClustersOnGPU();
+  void WriteReducedClusters();
   template <int32_t I>
   int32_t RunTRDTrackingInternal();
   uint32_t StreamForSector(uint32_t sector) const;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 619940ff6d3dd..b0d466f13e5ef 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -772,7 +772,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
       GPUFatal("Cannot use waitForFinalInput callback without delayed output");
     }
     if (!GetProcessingSettings().tpcApplyClusterFilterOnCPU) {
-      AllocateRegisteredMemory(mInputsHost->mResourceClusterNativeOutput, mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)]);
+      AllocateRegisteredMemory(mInputsHost->mResourceClusterNativeOutput, GetProcessingSettings().tpcWriteClustersAfterRejection ? nullptr : mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)]);
       tmpNativeClusters = mInputsHost->mPclusterNativeOutput;
     } else {
       tmpNativeClusterBuffer = std::make_unique<ClusterNative[]>(mInputsHost->mNClusterNative);
@@ -1269,7 +1269,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     // TODO: write to buffer directly
     o2::dataformats::MCTruthContainer<o2::MCCompLabel> mcLabels;
     std::pair<ConstMCLabelContainer*, ConstMCLabelContainerView*> buffer;
-    if (mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)] && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)]->useExternal()) {
+    if (!GetProcessingSettings().tpcWriteClustersAfterRejection && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)] && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)]->useExternal()) {
       if (!mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)]->allocator) {
         throw std::runtime_error("Cluster MC Label buffer missing");
       }
@@ -1293,7 +1293,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
   if (buildNativeHost && buildNativeGPU && GetProcessingSettings().delayedOutput) {
     mInputsHost->mNClusterNative = mInputsShadow->mNClusterNative = nClsTotal;
-    AllocateRegisteredMemory(mInputsHost->mResourceClusterNativeOutput, mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)]);
+    AllocateRegisteredMemory(mInputsHost->mResourceClusterNativeOutput, GetProcessingSettings().tpcWriteClustersAfterRejection ? nullptr : mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)]);
     tmpNativeClusters = mInputsHost->mPclusterNativeOutput;
     for (uint32_t i = outputQueueStart; i < mOutputQueue.size(); i++) {
       mOutputQueue[i].dst = (char*)tmpNativeClusters + (size_t)mOutputQueue[i].dst;
@@ -1308,7 +1308,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     if (GetProcessingSettings().tpcApplyClusterFilterOnCPU) {
       auto allocator = [this, &tmpNativeClusters](size_t size) {
         this->mInputsHost->mNClusterNative = size;
-        this->AllocateRegisteredMemory(this->mInputsHost->mResourceClusterNativeOutput, this->mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)]);
+        this->AllocateRegisteredMemory(this->mInputsHost->mResourceClusterNativeOutput, this->GetProcessingSettings().tpcWriteClustersAfterRejection ? nullptr : this->mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)]);
         return (tmpNativeClusters = this->mInputsHost->mPclusterNativeOutput);
       };
       RunTPCClusterFilter(tmpNativeAccess, allocator, false);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 3bcd2390eae52..e06699c0918b8 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -23,6 +23,8 @@
 #include "GPUConstantMem.h" // TODO: Try to get rid of as many GPUConstantMem includes as possible!
 #include "GPUTPCCompressionKernels.h"
 #include "GPUTPCDecompressionKernels.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/MCCompLabel.h"
 #include "utils/strtag.h"
 
 #include <numeric>
@@ -52,6 +54,9 @@ int32_t GPUChainTracking::RunTPCCompression()
   TransferMemoryResourcesToGPU(myStep, &Compressor, 0);
   runKernel<GPUMemClean16>(GetGridAutoStep(0, RecoStep::TPCCompression), CompressorShadow.mClusterStatus, Compressor.mMaxClusters * sizeof(CompressorShadow.mClusterStatus[0]));
   runKernel<GPUTPCCompressionKernels, GPUTPCCompressionKernels::step0attached>(GetGridAuto(0));
+  if (GetProcessingSettings().tpcWriteClustersAfterRejection) {
+    WriteReducedClusters();
+  }
   runKernel<GPUTPCCompressionKernels, GPUTPCCompressionKernels::step1unattached>(GetGridAuto(0));
   TransferMemoryResourcesToHost(myStep, &Compressor, 0);
 #ifdef GPUCA_TPC_GEOMETRY_O2
@@ -434,3 +439,56 @@ int32_t GPUChainTracking::RunTPCDecompression()
   DoDebugDump(GPUChainTrackingDebugFlags::TPCDecompressedClusters, &GPUChainTracking::DumpClusters, *mDebugFile, mIOPtrs.clustersNative);
   return 0;
 }
+
+void GPUChainTracking::WriteReducedClusters()
+{
+  GPUTPCCompression& Compressor = processors()->tpcCompressor;
+  mClusterNativeAccessReduced = std::make_unique<ClusterNativeAccess>();
+  uint32_t nOutput = 0;
+  for (uint32_t iSec = 0; iSec < GPUCA_NSECTORS; iSec++) {
+    for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+      mClusterNativeAccessReduced->nClusters[iSec][iRow] = 0;
+      for (uint32_t i = 0; i < mIOPtrs.clustersNative->nClusters[iSec][iRow]; i++) {
+        mClusterNativeAccessReduced->nClusters[iSec][iRow] += !Compressor.rejectCluster(mIOPtrs.clustersNative->clusterOffset[iSec][iRow] + i, param(), mIOPtrs);
+      }
+      nOutput += mClusterNativeAccessReduced->nClusters[iSec][iRow];
+    }
+  }
+
+  GPUOutputControl* clOutput = mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)];
+  if (!clOutput || !clOutput->allocator) {
+    throw std::runtime_error("No output allocator for clusterNative available");
+  }
+  auto* clBuffer = (ClusterNative*)clOutput->allocator(nOutput * sizeof(ClusterNative));
+  mClusterNativeAccessReduced->clustersLinear = clBuffer;
+  mClusterNativeAccessReduced->setOffsetPtrs();
+
+  std::pair<o2::dataformats::ConstMCLabelContainer*, o2::dataformats::ConstMCLabelContainerView*> labelBuffer;
+  if (mIOPtrs.clustersNative->clustersMCTruth) {
+    GPUOutputControl* labelOutput = mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)];
+    if (!labelOutput || !labelOutput->allocator) {
+      throw std::runtime_error("No output allocator for clusterNative labels available");
+    }
+    ClusterNativeAccess::ConstMCLabelContainerViewWithBuffer* labelContainer = reinterpret_cast<ClusterNativeAccess::ConstMCLabelContainerViewWithBuffer*>(labelOutput->allocator(0));
+    labelBuffer = {&labelContainer->first, &labelContainer->second};
+  }
+
+  nOutput = 0;
+  o2::dataformats::MCLabelContainer tmpContainer;
+  for (uint32_t i = 0; i < mIOPtrs.clustersNative->nClustersTotal; i++) {
+    if (!Compressor.rejectCluster(i, param(), mIOPtrs)) {
+      if (mIOPtrs.clustersNative->clustersMCTruth) {
+        for (const auto& element : mIOPtrs.clustersNative->clustersMCTruth->getLabels(i)) {
+          tmpContainer.addElement(nOutput, element);
+        }
+      }
+      clBuffer[nOutput++] = mIOPtrs.clustersNative->clustersLinear[i];
+    }
+  }
+  mIOPtrs.clustersNativeReduced = mClusterNativeAccessReduced.get();
+  if (mIOPtrs.clustersNative->clustersMCTruth) {
+    tmpContainer.flatten_to(*labelBuffer.first);
+    *labelBuffer.second = *labelBuffer.first;
+    mClusterNativeAccessReduced->clustersMCTruth = labelBuffer.second;
+  }
+}
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index a9d4304d77c83..5ab4b963d7330 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -293,7 +293,9 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     mRec->PushNonPersistentMemory(qStr2Tag("TPCMERG2"));
     AllocateRegisteredMemory(Merger.MemoryResOutputO2Scratch());
     WriteToConstantMemory(RecoStep::TPCMerging, (char*)&processors()->tpcMerger - (char*)processors(), &MergerShadow, sizeof(MergerShadow), 0);
-    runKernel<GPUTPCGMO2Output, GPUTPCGMO2Output::prepare>(GetGridAuto(0, deviceType));
+    if (!GetProcessingSettings().tpcWriteClustersAfterRejection) {
+      runKernel<GPUTPCGMO2Output, GPUTPCGMO2Output::prepare>(GetGridAuto(0, deviceType));
+    }
     TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResMemory(), 0, &mEvents->single);
     runKernel<GPUTPCGMO2Output, GPUTPCGMO2Output::sort>(GetGridAuto(0, deviceType));
     mRec->ReturnVolatileDeviceMemory();
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 68f7be8fb6330..353af32558c7d 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -889,6 +889,9 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
 
   // ------------------------------ Varios postprocessing steps ------------------------------
 
+  if (mConfig->configProcessing.tpcWriteClustersAfterRejection) {
+    ptrs.clustersNative = ptrs.clustersNativeReduced;
+  }
   bool createEmptyOutput = false;
   if (retVal != 0) {
     if (retVal == 3 && mConfig->configProcessing.ignoreNonFatalGPUErrors) {

From ede59e786197e4c9a37d0e1adbfbb7beb6c4c59c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 4 Oct 2025 22:27:44 +0200
Subject: [PATCH 0898/1764] TPC Workflow: Clean up CompCluster options

---
 .../include/TPCWorkflow/RecoWorkflow.h        | 21 +++++------
 Detectors/TPC/workflow/src/RecoWorkflow.cxx   | 35 +++++++++++--------
 .../TPC/workflow/src/tpc-reco-workflow.cxx    |  4 +--
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |  2 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |  8 ++---
 GPU/Workflow/src/gpu-reco-workflow.cxx        | 17 ++++-----
 prodtests/full-system-test/dpl-workflow.sh    |  6 ++--
 7 files changed, 51 insertions(+), 42 deletions(-)

diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h b/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
index f86afc310b04c..a5368f451a820 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
@@ -35,15 +35,15 @@ struct CorrectionMapsLoaderGloOpts;
 namespace reco_workflow
 {
 /// define input and output types of the workflow
-enum struct InputType { PassThrough,      // No processing, just pass through available inputs to the writers, defined by the OutputType
-                        Digitizer,        // directly read digits from channel {TPC:DIGITS}
-                        Digits,           // read digits from file
-                        ClustersHardware, // read hardware clusters in raw page format from file
-                        Clusters,         // read native clusters from file
-                        CompClusters,     // read compressed cluster container
-                        CompClustersCTF,  // compressed clusters from CTF, as flat format
-                        CompClustersFlat, // compressed clusters in flat format, used as input for the entropy encoder
-                        EncodedClusters,  // read encoded clusters
+enum struct InputType { PassThrough,               // No processing, just pass through available inputs to the writers, defined by the OutputType
+                        Digitizer,                 // directly read digits from channel {TPC:DIGITS}
+                        Digits,                    // read digits from file
+                        ClustersHardware,          // read hardware clusters in raw page format from file
+                        Clusters,                  // read native clusters from file
+                        CompClustersRoot,          // read compressed cluster in ROOT format
+                        CompClustersFlat,          // compressed clusters from flat format (e.g. from CTF)
+                        CompClustersFlatForEncode, // compressed clusters in flat format, used as input for the entropy encoder, no gpu-reco
+                        EncodedClusters,           // read encoded clusters
                         ZSRaw,
 };
 
@@ -59,7 +59,8 @@ enum struct OutputType { Digits,
                          ClustersHardware,
                          Clusters,
                          Tracks,
-                         CompClusters,
+                         CompClustersRoot,
+                         CompClustersFlat,
                          EncodedClusters,
                          DisableWriter,
                          SendClustersPerSector,
diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index 3e35f416373a1..e4969700bdf5d 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -80,16 +80,17 @@ const std::unordered_map<std::string, InputType> InputMap{
   {"clustershardware", InputType::ClustersHardware},
   {"clusters", InputType::Clusters},
   {"zsraw", InputType::ZSRaw},
-  {"compressed-clusters", InputType::CompClusters},
-  {"compressed-clusters-ctf", InputType::CompClustersCTF},
-  {"compressed-clusters-flat", InputType::CompClustersFlat}};
+  {"compressed-clusters-root", InputType::CompClustersRoot},
+  {"compressed-clusters-flat", InputType::CompClustersFlat},
+  {"compressed-clusters-flat-for-encode", InputType::CompClustersFlatForEncode}};
 
 const std::unordered_map<std::string, OutputType> OutputMap{
   {"digits", OutputType::Digits},
   {"clustershardware", OutputType::ClustersHardware},
   {"clusters", OutputType::Clusters},
   {"tracks", OutputType::Tracks},
-  {"compressed-clusters", OutputType::CompClusters},
+  {"compressed-clusters-root", OutputType::CompClustersRoot},
+  {"compressed-clusters-flat", OutputType::CompClustersFlat},
   {"encoded-clusters", OutputType::EncodedClusters},
   {"disable-writer", OutputType::DisableWriter},
   {"send-clusters-per-sector", OutputType::SendClustersPerSector},
@@ -122,14 +123,19 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
     throw std::invalid_argument("filtered-input option must be provided only with pass-through input and clusters,tracks,send-clusters-per-sector output");
   }
 
-  bool decompressTPC = inputType == InputType::CompClustersCTF || inputType == InputType::CompClusters;
+  bool decompressTPC = inputType == InputType::CompClustersFlat || inputType == InputType::CompClustersRoot;
   // Disable not applicable settings depending on TPC input, no need to disable manually
   if (decompressTPC && (isEnabled(OutputType::Clusters) || isEnabled(OutputType::Tracks))) {
     caClusterer = false;
     zsOnTheFly = false;
     propagateMC = false;
   }
-  if (inputType == InputType::ZSRaw || inputType == InputType::CompClustersFlat) {
+  if (inputType == InputType::CompClustersFlatForEncode || inputType == InputType::CompClustersRoot || inputType == InputType::CompClustersFlat) {
+    caClusterer = false;
+    zsOnTheFly = false;
+    propagateMC = false;
+  }
+  if (inputType == InputType::ZSRaw) {
     caClusterer = true;
     zsOnTheFly = false;
     propagateMC = false;
@@ -225,7 +231,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
       if (sclOpts.requestCTPLumi) { // need CTP digits (lumi) reader
         specs.emplace_back(o2::ctp::getDigitsReaderSpec(false));
       }
-    } else if (inputType == InputType::CompClusters) {
+    } else if (inputType == InputType::CompClustersRoot) {
       // TODO: need to check if we want to store the MC labels alongside with compressed clusters
       // for the moment reading of labels is disabled (last parameter is false)
       // TODO: make a different publisher spec for only one output spec, for now using the
@@ -248,8 +254,9 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   // output matrix
   // Note: the ClusterHardware format is probably a deprecated legacy format and also the
   // ClusterDecoderRawSpec
-  bool produceCompClusters = isEnabled(OutputType::CompClusters);
-  bool runGPUReco = (produceTracks || produceCompClusters || (isEnabled(OutputType::Clusters) && caClusterer) || inputType == InputType::CompClustersCTF) && inputType != InputType::CompClustersFlat;
+  bool produceCompClustersRoot = isEnabled(OutputType::CompClustersRoot);
+  bool produceCompClustersFlat = isEnabled(OutputType::CompClustersFlat);
+  bool runGPUReco = (produceTracks || produceCompClustersRoot || produceCompClustersFlat || (isEnabled(OutputType::Clusters) && caClusterer) || inputType == InputType::CompClustersFlat) && inputType != InputType::CompClustersFlatForEncode;
   bool runHWDecoder = !caClusterer && (runGPUReco || isEnabled(OutputType::Clusters));
   bool runClusterer = !caClusterer && (runHWDecoder || isEnabled(OutputType::ClustersHardware));
   bool zsDecoder = inputType == InputType::ZSRaw;
@@ -460,13 +467,13 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
     cfg.enableMShape = sclOpts.enableMShapeCorrection;
     cfg.enableCTPLumi = sclOpts.requestCTPLumi;
     cfg.decompressTPC = decompressTPC;
-    cfg.decompressTPCFromROOT = decompressTPC && inputType == InputType::CompClusters;
+    cfg.decompressTPCFromROOT = decompressTPC && inputType == InputType::CompClustersRoot;
     cfg.caClusterer = caClusterer;
     cfg.zsDecoder = zsDecoder;
     cfg.zsOnTheFly = zsOnTheFly;
     cfg.outputTracks = produceTracks;
-    cfg.outputCompClusters = produceCompClusters;
-    cfg.outputCompClustersFlat = runClusterEncoder;
+    cfg.outputCompClustersRoot = produceCompClustersRoot;
+    cfg.outputCompClustersFlat = produceCompClustersFlat || runClusterEncoder;
     cfg.outputCAClusters = isEnabled(OutputType::Clusters) && (caClusterer || decompressTPC);
     cfg.outputQA = isEnabled(OutputType::QA);
     cfg.outputSharedClusterMap = (isEnabled(OutputType::Clusters) || inputType == InputType::Clusters) && isEnabled(OutputType::Tracks) && !isEnabled(OutputType::NoSharedClusterMap);
@@ -500,7 +507,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   //
   // selected by output type 'encoded-clusters'
   if (runClusterEncoder) {
-    specs.emplace_back(o2::tpc::getEntropyEncoderSpec(!runGPUReco && inputType != InputType::CompClustersFlat, selIR));
+    specs.emplace_back(o2::tpc::getEntropyEncoderSpec(!runGPUReco && inputType != InputType::CompClustersFlatForEncode, selIR));
   }
 
   //////////////////////////////////////////////////////////////////////////////////////////////
@@ -547,7 +554,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   // a writer process for compressed clusters container
   //
   // selected by output type 'compressed-clusters'
-  if (produceCompClusters && !isEnabled(OutputType::DisableWriter)) {
+  if (produceCompClustersRoot && !isEnabled(OutputType::DisableWriter)) {
     // defining the track writer process using the generic RootTreeWriter and generator tool
     //
     // defaults
diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index 9d7ab63b0c2a0..efb78c248e98c 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -57,8 +57,8 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   using namespace o2::framework;
 
   std::vector<ConfigParamSpec> options{
-    {"input-type", VariantType::String, "digits", {"digitizer, digits, zsraw, clustershw, clusters, compressed-clusters, compressed-clusters-ctf, pass-through"}},
-    {"output-type", VariantType::String, "tracks", {"digits, zsraw, clustershw, clusters, tracks, compressed-clusters, encoded-clusters, disable-writer, send-clusters-per-sector, qa, no-shared-cluster-map, tpc-triggers"}},
+    {"input-type", VariantType::String, "digits", {"digitizer, digits, zsraw, clustershw, clusters, compressed-clusters-root, compressed-clusters-ctf, compressed-clusters-flat-for-encode, pass-through"}},
+    {"output-type", VariantType::String, "tracks", {"digits, zsraw, clustershw, clusters, tracks, compressed-clusters-root, compressed-clusters-flat, encoded-clusters, disable-writer, send-clusters-per-sector, qa, no-shared-cluster-map, tpc-triggers"}},
     {"disable-root-input", o2::framework::VariantType::Bool, false, {"disable root-files input reader"}},
     {"no-ca-clusterer", VariantType::Bool, false, {"Use HardwareClusterer instead of clusterer of GPUCATracking"}},
     {"disable-mc", VariantType::Bool, false, {"disable sending of MC information"}},
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index ad424cc226499..8be69c2a0fd7c 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -117,7 +117,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     bool zsDecoder = false;
     bool zsOnTheFly = false;
     bool outputTracks = false;
-    bool outputCompClusters = false;
+    bool outputCompClustersRoot = false;
     bool outputCompClustersFlat = false;
     bool outputCAClusters = false;
     bool outputQA = false;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 353af32558c7d..be5b182dad99f 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -236,14 +236,14 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
   }
 
   // Configure the "GPU workflow" i.e. which steps we run on the GPU (or CPU)
-  if (mSpecConfig.outputTracks || mSpecConfig.outputCompClusters || mSpecConfig.outputCompClustersFlat) {
+  if (mSpecConfig.outputTracks || mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat) {
     mConfig->configWorkflow.steps.set(GPUDataTypes::RecoStep::TPCConversion,
                                       GPUDataTypes::RecoStep::TPCSectorTracking,
                                       GPUDataTypes::RecoStep::TPCMerging);
     mConfig->configWorkflow.outputs.set(GPUDataTypes::InOutType::TPCMergedTracks);
     mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, mConfParam->rundEdx == -1 ? !mConfParam->synchronousProcessing : mConfParam->rundEdx);
   }
-  if (mSpecConfig.outputCompClusters || mSpecConfig.outputCompClustersFlat) {
+  if (mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat) {
     mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, true);
     mConfig->configWorkflow.outputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, true);
   }
@@ -966,7 +966,7 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
     LOG(info) << "found " << ptrs.nOutputTracksTPCO2 << " track(s)";
   }
 
-  if (mSpecConfig.outputCompClusters) {
+  if (mSpecConfig.outputCompClustersRoot) {
     o2::tpc::CompressedClustersROOT compressedClusters = *ptrs.tpcCompressedClusters;
     pc.outputs().snapshot(Output{gDataOriginTPC, "COMPCLUSTERS", 0}, ROOTSerialized<o2::tpc::CompressedClustersROOT const>(compressedClusters));
   }
@@ -1259,7 +1259,7 @@ Outputs GPURecoWorkflowSpec::outputs()
   if (mSpecConfig.processMC && mSpecConfig.outputTracks) {
     outputSpecs.emplace_back(gDataOriginTPC, "TRACKSMCLBL", 0, Lifetime::Timeframe);
   }
-  if (mSpecConfig.outputCompClusters) {
+  if (mSpecConfig.outputCompClustersRoot) {
     outputSpecs.emplace_back(gDataOriginTPC, "COMPCLUSTERS", 0, Lifetime::Timeframe);
   }
   if (mSpecConfig.outputCompClustersFlat) {
diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index 561d537b5c251..5ae31554c173d 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -51,8 +51,8 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
 
   std::vector<ConfigParamSpec> options{
-    {"input-type", VariantType::String, "digits", {"digitizer, digits, zsraw, zsonthefly, clustersnative, compressed-clusters-root, compressed-clusters-ctf, trd-tracklets, its-clusters"}},
-    {"output-type", VariantType::String, "tracks", {"clustersnative, tracks, compressed-clusters-ctf, qa, no-shared-cluster-map, send-clusters-per-sector, trd-tracks, error-qa, tpc-triggers, its-tracks"}},
+    {"input-type", VariantType::String, "digits", {"digits, zsraw, zsonthefly, clusters, compressed-clusters-root, compressed-clusters-flat, trd-tracklets, its-clusters, its-mean-vertex"}},
+    {"output-type", VariantType::String, "tracks", {"cluster, tracks, compressed-clusters-root, compressed-clusters-flat, qa, error-qa, no-shared-cluster-map, send-clusters-per-sector, trd-tracks, tpc-triggers, its-tracks"}},
     {"corrmap-lumi-mode", VariantType::Int, 0, {"scaling mode: (default) 0 = static + scale * full; 1 = full + scale * derivative"}},
     {"disable-root-input", VariantType::Bool, true, {"disable root-files input reader"}},
     {"disable-mc", VariantType::Bool, false, {"disable sending of MC information"}},
@@ -98,7 +98,7 @@ enum struct ioType { Digits,
                      ZSRaw,
                      ZSRawOTF,
                      CompClustROOT,
-                     CompClustCTF,
+                     CompClustFlat,
                      Tracks,
                      QA,
                      ErrorQA,
@@ -117,7 +117,7 @@ static const std::unordered_map<std::string, ioType> InputMap{
   {"zsraw", ioType::ZSRaw},
   {"zsonthefly", ioType::ZSRawOTF},
   {"compressed-clusters-root", ioType::CompClustROOT},
-  {"compressed-clusters-ctf", ioType::CompClustCTF},
+  {"compressed-clusters-flat", ioType::CompClustFlat},
   {"trd-tracklets", ioType::TRDTracklets},
   {"its-clusters", ioType::ITSClusters},
   {"its-mean-vertex", ioType::MeanVertex},
@@ -126,7 +126,8 @@ static const std::unordered_map<std::string, ioType> InputMap{
 static const std::unordered_map<std::string, ioType> OutputMap{
   {"clusters", ioType::Clusters},
   {"tracks", ioType::Tracks},
-  {"compressed-clusters-ctf", ioType::CompClustCTF},
+  {"compressed-clusters-flat", ioType::CompClustFlat},
+  {"compressed-clusters-root", ioType::CompClustROOT},
   {"qa", ioType::QA},
   {"error-qa", ioType::ErrorQA},
   {"no-shared-cluster-map", ioType::NoSharedMap},
@@ -167,13 +168,13 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   cfg.enableMShape = sclOpt.enableMShapeCorrection;
   cfg.enableCTPLumi = sclOpt.requestCTPLumi;
   cfg.decompressTPCFromROOT = isEnabled(inputTypes, ioType::CompClustROOT);
-  cfg.decompressTPC = isEnabled(inputTypes, ioType::CompClustCTF) || cfg.decompressTPCFromROOT;
+  cfg.decompressTPC = isEnabled(inputTypes, ioType::CompClustFlat) || cfg.decompressTPCFromROOT;
   cfg.zsDecoder = isEnabled(inputTypes, ioType::ZSRaw);
   cfg.zsOnTheFly = isEnabled(inputTypes, ioType::ZSRawOTF);
   cfg.caClusterer = cfg.zsDecoder || cfg.zsOnTheFly || isEnabled(inputTypes, ioType::Digits);
   cfg.outputTracks = isEnabled(outputTypes, ioType::Tracks);
-  cfg.outputCompClusters = isEnabled(outputTypes, ioType::CompClustROOT);
-  cfg.outputCompClustersFlat = isEnabled(outputTypes, ioType::CompClustCTF);
+  cfg.outputCompClustersRoot = isEnabled(outputTypes, ioType::CompClustROOT);
+  cfg.outputCompClustersFlat = isEnabled(outputTypes, ioType::CompClustFlat);
   cfg.outputCAClusters = isEnabled(outputTypes, ioType::Clusters);
   cfg.outputQA = isEnabled(outputTypes, ioType::QA);
   cfg.outputErrorQA = isEnabled(outputTypes, ioType::ErrorQA);
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 9fc6ce5507168..2f0e761366e18 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -205,7 +205,7 @@ workflow_has_parameter CALIB && [[ $CALIB_TPC_VDRIFTTGL == 1 ]] && SEND_ITSTPC_D
 
 PVERTEXING_CONFIG_KEY+="${ITSMFT_STROBES};"
 
-has_processing_step ENTROPY_ENCODER && has_detector_ctf TPC && GPU_OUTPUT+=",compressed-clusters-ctf"
+has_processing_step ENTROPY_ENCODER && has_detector_ctf TPC && GPU_OUTPUT+=",compressed-clusters-flat"
 
 if [[ $SYNCMODE == 1 ]] && workflow_has_parameter QC && has_detector_qc TPC; then
   GPU_OUTPUT+=",qa,error-qa"
@@ -443,7 +443,7 @@ fi
 
 if [[ -n $INPUT_DETECTOR_LIST ]]; then
   if [[ $CTFINPUT == 1 ]]; then
-    GPU_INPUT=compressed-clusters-ctf
+    GPU_INPUT=compressed-clusters-flat
     TOF_INPUT=digits
     CTFName=`ls -t $RAWINPUTDIR/o2_ctf_*.root 2> /dev/null | head -n1`
     [[ -z $CTFName && $WORKFLOWMODE == "print" ]] && CTFName='$CTFName'
@@ -652,7 +652,7 @@ if has_processing_step ENTROPY_ENCODER && [[ -n "$WORKFLOW_DETECTORS_CTF" ]] &&
   has_detector_ctf TOF && add_W o2-tof-entropy-encoder-workflow "$RANS_OPT --mem-factor ${TOF_ENC_MEMFACT:-1.5} --pipeline $(get_N tof-entropy-encoder TOF CTF 1)"
   has_detector_ctf ITS && add_W o2-itsmft-entropy-encoder-workflow "$RANS_OPT --mem-factor ${ITS_ENC_MEMFACT:-1.5} --pipeline $(get_N its-entropy-encoder ITS CTF 1)"
   has_detector_ctf TRD && add_W o2-trd-entropy-encoder-workflow "$RANS_OPT --mem-factor ${TRD_ENC_MEMFACT:-1.5} --pipeline $(get_N trd-entropy-encoder TRD CTF 1 TRDENT)"
-  has_detector_ctf TPC && add_W o2-tpc-reco-workflow " $RANS_OPT --mem-factor ${TPC_ENC_MEMFACT:-1.} --input-type compressed-clusters-flat --output-type encoded-clusters,disable-writer --pipeline $(get_N tpc-entropy-encoder TPC CTF 1 TPCENT)"
+  has_detector_ctf TPC && add_W o2-tpc-reco-workflow " $RANS_OPT --mem-factor ${TPC_ENC_MEMFACT:-1.} --input-type compressed-clusters-flat-for-encode --output-type encoded-clusters,disable-writer --pipeline $(get_N tpc-entropy-encoder TPC CTF 1 TPCENT)"
   has_detector_ctf CTP && add_W o2-ctp-entropy-encoder-workflow "$RANS_OPT --mem-factor ${CTP_ENC_MEMFACT:-1.5} --pipeline $(get_N its-entropy-encoder CTP CTF 1)"
 
   if [[ $CREATECTFDICT == 1 && $WORKFLOWMODE == "run" ]] ; then

From 5a6a33da9c5d063289bb76b5a2691f7906c721d6 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 4 Oct 2025 22:37:36 +0200
Subject: [PATCH 0899/1764] TPC Workflow: Remove dispatch trigger for invalid
 input type (probably obsolete)

---
 Detectors/TPC/workflow/src/tpc-reco-workflow.cxx | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index efb78c248e98c..b440f6e8d359f 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -155,8 +155,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "DIGITS"};
   } else if (inputType == "clustershw") {
     gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "CLUSTERHW"};
-  } else if (inputType == "clustersnative") {
-    gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "CLUSTERNATIVE"};
   } else if (inputType == "zsraw") {
     gDispatchTrigger = o2::framework::ConcreteDataTypeMatcher{"TPC", "RAWDATA"};
   }

From 6c0251c35e5cbf6028d2bd6f7e30f9a4fd348e38 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 4 Oct 2025 22:57:58 +0200
Subject: [PATCH 0900/1764] GPU Workfow: Add option to use filtered output
 specs

---
 Detectors/TPC/workflow/src/RecoWorkflow.cxx   |  4 +--
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |  1 +
 GPU/Workflow/src/GPUWorkflowSpec.cxx          | 36 +++++++++----------
 GPU/Workflow/src/gpu-reco-workflow.cxx        |  2 ++
 4 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index e4969700bdf5d..3fdff02dd69cc 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -119,8 +119,8 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
     return std::find(outputTypes.begin(), outputTypes.end(), type) != outputTypes.end();
   };
 
-  if (filteredInp && !(inputType == InputType::PassThrough && isEnabled(OutputType::Tracks) && isEnabled(OutputType::Clusters) && isEnabled(OutputType::SendClustersPerSector))) {
-    throw std::invalid_argument("filtered-input option must be provided only with pass-through input and clusters,tracks,send-clusters-per-sector output");
+  if (filteredInp && !(inputType == InputType::PassThrough)) {
+    throw std::invalid_argument("filtered-input option must be provided only with pass-through input");
   }
 
   bool decompressTPC = inputType == InputType::CompClustersFlat || inputType == InputType::CompClustersRoot;
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 8be69c2a0fd7c..4f62f07593bff 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -134,6 +134,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     bool itsOverrBeamEst = false;
     bool tpcTriggerHandling = false;
     bool isITS3 = false;
+    bool useFilteredOutputSpecs = false;
   };
 
   GPURecoWorkflowSpec(CompletionPolicyData* policyData, Config const& specconfig, std::vector<int32_t> const& tpcsectors, uint64_t tpcSectorMask, std::shared_ptr<o2::base::GRPGeomRequest>& ggr, std::function<bool(o2::framework::DataProcessingHeader::StartTime)>** gPolicyOrder = nullptr);
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index be5b182dad99f..6c76f13c9bbd0 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -112,8 +112,8 @@ namespace o2::gpu
 
 GPURecoWorkflowSpec::GPURecoWorkflowSpec(GPURecoWorkflowSpec::CompletionPolicyData* policyData, Config const& specconfig, std::vector<int32_t> const& tpcsectors, uint64_t tpcSectorMask, std::shared_ptr<o2::base::GRPGeomRequest>& ggr, std::function<bool(o2::framework::DataProcessingHeader::StartTime)>** gPolicyOrder) : o2::framework::Task(), mPolicyData(policyData), mTPCSectorMask(tpcSectorMask), mTPCSectors(tpcsectors), mSpecConfig(specconfig), mGGR(ggr)
 {
-  if (mSpecConfig.outputCAClusters && !mSpecConfig.caClusterer && !mSpecConfig.decompressTPC) {
-    throw std::runtime_error("inconsistent configuration: cluster output is only possible if CA clusterer is activated");
+  if (mSpecConfig.outputCAClusters && !mSpecConfig.caClusterer && !mSpecConfig.decompressTPC && !mSpecConfig.useFilteredOutputSpecs) {
+    throw std::runtime_error("inconsistent configuration: cluster output is only possible if CA clusterer or CompCluster decompression is activated");
   }
 
   mConfig.reset(new GPUO2InterfaceConfiguration);
@@ -800,15 +800,15 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
   };
 
   setOutputAllocator("COMPCLUSTERSFLAT", mSpecConfig.outputCompClustersFlat, outputRegions.compressedClusters, std::make_tuple(gDataOriginTPC, (DataDescription) "COMPCLUSTERSFLAT", 0));
-  setOutputAllocator("CLUSTERNATIVE", mClusterOutputIds.size() > 0, outputRegions.clustersNative, std::make_tuple(gDataOriginTPC, mSpecConfig.sendClustersPerSector ? (DataDescription) "CLUSTERNATIVETMP" : (DataDescription) "CLUSTERNATIVE", NSectors, clusterOutputSectorHeader), sizeof(o2::tpc::ClusterCountIndex));
+  setOutputAllocator("CLUSTERNATIVE", mClusterOutputIds.size() > 0, outputRegions.clustersNative, std::make_tuple(gDataOriginTPC, mSpecConfig.sendClustersPerSector ? (DataDescription) "CLUSTERNATIVETMP" : (mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "CLUSTERNATIVEF" : (DataDescription) "CLUSTERNATIVE"), NSectors, clusterOutputSectorHeader), sizeof(o2::tpc::ClusterCountIndex));
   setOutputAllocator("CLSHAREDMAP", mSpecConfig.outputSharedClusterMap, outputRegions.sharedClusterMap, std::make_tuple(gDataOriginTPC, (DataDescription) "CLSHAREDMAP", 0));
   setOutputAllocator("TPCOCCUPANCYMAP", mSpecConfig.outputSharedClusterMap, outputRegions.tpcOccupancyMap, std::make_tuple(gDataOriginTPC, (DataDescription) "TPCOCCUPANCYMAP", 0));
-  setOutputAllocator("TRACKS", mSpecConfig.outputTracks, outputRegions.tpcTracksO2, std::make_tuple(gDataOriginTPC, (DataDescription) "TRACKS", 0));
-  setOutputAllocator("CLUSREFS", mSpecConfig.outputTracks, outputRegions.tpcTracksO2ClusRefs, std::make_tuple(gDataOriginTPC, (DataDescription) "CLUSREFS", 0));
-  setOutputAllocator("TRACKSMCLBL", mSpecConfig.outputTracks && mSpecConfig.processMC, outputRegions.tpcTracksO2Labels, std::make_tuple(gDataOriginTPC, (DataDescription) "TRACKSMCLBL", 0));
+  setOutputAllocator("TRACKS", mSpecConfig.outputTracks, outputRegions.tpcTracksO2, std::make_tuple(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "TRACKSF" : (DataDescription) "TRACKS", 0));
+  setOutputAllocator("CLUSREFS", mSpecConfig.outputTracks, outputRegions.tpcTracksO2ClusRefs, std::make_tuple(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "CLUSREFSF" : (DataDescription) "CLUSREFS", 0));
+  setOutputAllocator("TRACKSMCLBL", mSpecConfig.outputTracks && mSpecConfig.processMC, outputRegions.tpcTracksO2Labels, std::make_tuple(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "TRACKSMCLBLF" : (DataDescription) "TRACKSMCLBL", 0));
   setOutputAllocator("TRIGGERWORDS", mSpecConfig.caClusterer && mConfig->configProcessing.param.tpcTriggerHandling, outputRegions.tpcTriggerWords, std::make_tuple(gDataOriginTPC, (DataDescription) "TRIGGERWORDS", 0));
   o2::tpc::ClusterNativeHelper::ConstMCLabelContainerViewWithBuffer clustersMCBuffer;
-  if (mSpecConfig.processMC && mSpecConfig.caClusterer) {
+  if (mSpecConfig.processMC && (mSpecConfig.caClusterer || mSpecConfig.useFilteredOutputSpecs)) {
     outputRegions.clusterLabels.allocator = [&clustersMCBuffer](size_t size) -> void* { return &clustersMCBuffer; };
   }
 
@@ -979,7 +979,7 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
         if (mTPCSectorMask & (1ul << i)) {
           DataHeader::SubSpecificationType subspec = i;
           clusterOutputSectorHeader.sectorBits = (1ul << i);
-          char* buffer = pc.outputs().make<char>({gDataOriginTPC, "CLUSTERNATIVE", subspec, {clusterOutputSectorHeader}}, accessIndex.nClustersSector[i] * sizeof(*accessIndex.clustersLinear) + sizeof(o2::tpc::ClusterCountIndex)).data();
+          char* buffer = pc.outputs().make<char>({gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "CLUSTERNATIVEF" : (DataDescription) "CLUSTERNATIVE", subspec, {clusterOutputSectorHeader}}, accessIndex.nClustersSector[i] * sizeof(*accessIndex.clustersLinear) + sizeof(o2::tpc::ClusterCountIndex)).data();
           o2::tpc::ClusterCountIndex* outIndex = reinterpret_cast<o2::tpc::ClusterCountIndex*>(buffer);
           memset(outIndex, 0, sizeof(*outIndex));
           for (int32_t j = 0; j < o2::tpc::constants::MAXGLOBALPADROW; j++) {
@@ -996,7 +996,7 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
             }
             ConstMCLabelContainer contflat;
             cont.flatten_to(contflat);
-            pc.outputs().snapshot({gDataOriginTPC, "CLNATIVEMCLBL", subspec, {clusterOutputSectorHeader}}, contflat);
+            pc.outputs().snapshot({gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? DataDescription("CLNATIVEMCLBLF") : DataDescription("CLNATIVEMCLBL"), subspec, {clusterOutputSectorHeader}}, contflat);
           }
         }
       }
@@ -1006,8 +1006,8 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
       o2::tpc::ClusterCountIndex* outIndex = reinterpret_cast<o2::tpc::ClusterCountIndex*>(outputBuffers[outputRegions.getIndex(outputRegions.clustersNative)].second);
       static_assert(sizeof(o2::tpc::ClusterCountIndex) == sizeof(accessIndex.nClusters));
       memcpy(outIndex, &accessIndex.nClusters[0][0], sizeof(o2::tpc::ClusterCountIndex));
-      if (mSpecConfig.processMC && mSpecConfig.caClusterer && accessIndex.clustersMCTruth) {
-        pc.outputs().snapshot({gDataOriginTPC, "CLNATIVEMCLBL", subspec, {clusterOutputSectorHeader}}, clustersMCBuffer.first);
+      if (mSpecConfig.processMC && (mSpecConfig.caClusterer || mSpecConfig.useFilteredOutputSpecs) && accessIndex.clustersMCTruth) {
+        pc.outputs().snapshot({gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? DataDescription("CLNATIVEMCLBLF") : DataDescription("CLNATIVEMCLBL"), subspec, {clusterOutputSectorHeader}}, clustersMCBuffer.first);
       }
     }
   }
@@ -1253,11 +1253,11 @@ Outputs GPURecoWorkflowSpec::outputs()
     return outputSpecs;
   }
   if (mSpecConfig.outputTracks) {
-    outputSpecs.emplace_back(gDataOriginTPC, "TRACKS", 0, Lifetime::Timeframe);
-    outputSpecs.emplace_back(gDataOriginTPC, "CLUSREFS", 0, Lifetime::Timeframe);
+    outputSpecs.emplace_back(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "TRACKSF" : (DataDescription) "TRACKS", 0, Lifetime::Timeframe);
+    outputSpecs.emplace_back(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "CLUSREFSF" : (DataDescription) "CLUSREFS", 0, Lifetime::Timeframe);
   }
   if (mSpecConfig.processMC && mSpecConfig.outputTracks) {
-    outputSpecs.emplace_back(gDataOriginTPC, "TRACKSMCLBL", 0, Lifetime::Timeframe);
+    outputSpecs.emplace_back(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "TRACKSMCLBLF" : (DataDescription) "TRACKSMCLBL", 0, Lifetime::Timeframe);
   }
   if (mSpecConfig.outputCompClustersRoot) {
     outputSpecs.emplace_back(gDataOriginTPC, "COMPCLUSTERS", 0, Lifetime::Timeframe);
@@ -1272,18 +1272,18 @@ Outputs GPURecoWorkflowSpec::outputs()
     if (mSpecConfig.sendClustersPerSector) {
       outputSpecs.emplace_back(gDataOriginTPC, "CLUSTERNATIVETMP", NSectors, Lifetime::Timeframe); // Dummy buffer the TPC tracker writes the inital linear clusters to
       for (const auto sector : mTPCSectors) {
-        outputSpecs.emplace_back(gDataOriginTPC, "CLUSTERNATIVE", sector, Lifetime::Timeframe);
+        outputSpecs.emplace_back(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "CLUSTERNATIVEF" : (DataDescription) "CLUSTERNATIVE", sector, Lifetime::Timeframe);
       }
     } else {
-      outputSpecs.emplace_back(gDataOriginTPC, "CLUSTERNATIVE", NSectors, Lifetime::Timeframe);
+      outputSpecs.emplace_back(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? (DataDescription) "CLUSTERNATIVEF" : (DataDescription) "CLUSTERNATIVE", NSectors, Lifetime::Timeframe);
     }
     if (mSpecConfig.processMC) {
       if (mSpecConfig.sendClustersPerSector) {
         for (const auto sector : mTPCSectors) {
-          outputSpecs.emplace_back(gDataOriginTPC, "CLNATIVEMCLBL", sector, Lifetime::Timeframe);
+          outputSpecs.emplace_back(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? DataDescription("CLNATIVEMCLBLF") : DataDescription("CLNATIVEMCLBL"), sector, Lifetime::Timeframe);
         }
       } else {
-        outputSpecs.emplace_back(gDataOriginTPC, "CLNATIVEMCLBL", NSectors, Lifetime::Timeframe);
+        outputSpecs.emplace_back(gDataOriginTPC, mSpecConfig.useFilteredOutputSpecs ? DataDescription("CLNATIVEMCLBLF") : DataDescription("CLNATIVEMCLBL"), NSectors, Lifetime::Timeframe);
       }
     }
   }
diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index 5ae31554c173d..e620d013cc925 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -62,6 +62,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"enableDoublePipeline", VariantType::Bool, false, {"enable GPU double pipeline mode"}},
     {"tpc-deadMap-sources", VariantType::Int, -1, {"Sources to consider for TPC dead channel map creation; -1=all, 0=deactivated"}},
     {"tpc-mc-time-gain", VariantType::Bool, false, {"use time gain calibration for MC (true) or for data (false)"}},
+    {"filtered-output-specs", VariantType::Bool, false, {"use filtered output specs for output DataDescriptions"}},
   };
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
@@ -190,6 +191,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   cfg.tpcUseMCTimeGain = cfgc.options().get<bool>("tpc-mc-time-gain");
   cfg.runITSTracking = isEnabled(outputTypes, ioType::ITSTracks);
   cfg.itsOverrBeamEst = isEnabled(inputTypes, ioType::MeanVertex);
+  cfg.useFilteredOutputSpecs = cfgc.options().get<bool>("filtered-output-specs");
 
   Inputs ggInputs;
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true, o2::base::GRPGeomRequest::Aligned, ggInputs, true);

From b797b8ef97bc8244c1e869d3f537e52aa0938550 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 1 Oct 2025 14:20:45 +0200
Subject: [PATCH 0901/1764] Suppress reduntant versions of HelixHelper

---
 .../DCAFitter/include/DCAFitter/HelixHelper.h | 307 ------------------
 .../include/DetectorsVertexing/HelixHelper.h  | 307 ------------------
 2 files changed, 614 deletions(-)
 delete mode 100644 Common/DCAFitter/include/DCAFitter/HelixHelper.h
 delete mode 100644 Detectors/Vertexing/include/DetectorsVertexing/HelixHelper.h

diff --git a/Common/DCAFitter/include/DCAFitter/HelixHelper.h b/Common/DCAFitter/include/DCAFitter/HelixHelper.h
deleted file mode 100644
index d197cba256c0e..0000000000000
--- a/Common/DCAFitter/include/DCAFitter/HelixHelper.h
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file HelixHelper.h
-/// \brief Helper classes for helical tracks manipulations
-/// \author ruben.shahoyan@cern.ch
-
-#ifndef _ALICEO2_HELIX_HELPER_
-#define _ALICEO2_HELIX_HELPER_
-
-#include "CommonConstants/MathConstants.h"
-#include "MathUtils/Utils.h"
-#include "MathUtils/Primitive2D.h"
-
-namespace o2
-{
-namespace track
-{
-
-///__________________________________________________________________________
-//< precalculated track radius, center, alpha sin,cos and their combinations
-struct TrackAuxPar : public o2::math_utils::CircleXYf_t {
-  float c, s, cc, ss, cs; // cos ans sin of track alpha and their products
-
-  GPUdDefault() TrackAuxPar() = default;
-
-  template <typename T>
-  GPUd() TrackAuxPar(const T& trc, float bz)
-  {
-    set(trc, bz);
-  }
-  GPUd() float cosDif(const TrackAuxPar& t) const { return c * t.c + s * t.s; } // cos(alpha_this - alha_t)
-  GPUd() float sinDif(const TrackAuxPar& t) const { return s * t.c - c * t.s; } // sin(alpha_this - alha_t)
-
-  template <typename T>
-  GPUd() void set(const T& trc, float bz)
-  {
-    trc.getCircleParams(bz, *this, s, c);
-    cc = c * c;
-    ss = s * s;
-    cs = c * s;
-  }
-  ClassDefNV(TrackAuxPar, 1);
-};
-
-//__________________________________________________________
-//< crossing coordinates of 2 circles
-struct CrossInfo {
-  static constexpr float MaxDistXYDef = 10.;
-  float xDCA[2] = {};
-  float yDCA[2] = {};
-  int nDCA = 0;
-
-  GPUd() int circlesCrossInfo(const TrackAuxPar& trax0, const TrackAuxPar& trax1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
-  {
-    const auto& trcA = trax0.rC > trax1.rC ? trax0 : trax1; // designate the largest circle as A
-    const auto& trcB = trax0.rC > trax1.rC ? trax1 : trax0;
-    nDCA = 0;
-    float xDist = trcB.xC - trcA.xC, yDist = trcB.yC - trcA.yC;
-    float dist2 = xDist * xDist + yDist * yDist, dist = o2::gpu::GPUCommonMath::Sqrt(dist2), rsum = trcA.rC + trcB.rC;
-    if (dist < 1e-12) {
-      return nDCA; // circles are concentric?
-    }
-    if (dist > rsum) { // circles don't touch, chose a point in between
-      // the parametric equation of lines connecting the centers is
-      // x = x0 + t/dist * (x1-x0), y = y0 + t/dist * (y1-y0)
-      if (dist - rsum > maxDistXY) { // too large distance
-        return nDCA;
-      }
-      notTouchingXY(dist, xDist, yDist, trcA, trcB.rC, isCollinear);
-    } else if (auto dfr = dist + trcB.rC - trcA.rC; dfr < 0.) { // the small circle is nestled into large one w/o touching
-      if (dfr > -maxDistXY) {
-        // select the point of closest approach of 2 circles
-        notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC, isCollinear);
-      } else {
-        return nDCA;
-      }
-    } else { // 2 intersection points
-      if (isCollinear) {
-        /// collinear tracks, e.g. electrons from photon conversion
-        /// if there are 2 crossings of the circle it is better to take
-        /// a weighted average of the crossing points as a radius
-        float r2r = trcA.rC + trcB.rC;
-        float r1_r = trcA.rC / r2r;
-        float r2_r = trcB.rC / r2r;
-        xDCA[0] = r2_r * trcA.xC + r1_r * trcB.xC;
-        yDCA[0] = r2_r * trcA.yC + r1_r * trcB.yC;
-        nDCA = 1;
-      } else if (o2::gpu::GPUCommonMath::Abs(xDist) < o2::gpu::GPUCommonMath::Abs(yDist)) {
-        // to simplify calculations, we move to new frame x->x+Xc0, y->y+Yc0, so that
-        // the 1st one is centered in origin
-        float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * yDist), b = -xDist / yDist, ab = a * b, bb = b * b;
-        float det = ab * ab - (1. + bb) * (a * a - trcA.rC * trcA.rC);
-        if (det > 0.) {
-          det = o2::gpu::GPUCommonMath::Sqrt(det);
-          xDCA[0] = (-ab + det) / (1. + b * b);
-          yDCA[0] = a + b * xDCA[0] + trcA.yC;
-          xDCA[0] += trcA.xC;
-          xDCA[1] = (-ab - det) / (1. + b * b);
-          yDCA[1] = a + b * xDCA[1] + trcA.yC;
-          xDCA[1] += trcA.xC;
-          nDCA = 2;
-        } else { // due to the finite precision the det<=0, i.e. the circles are barely touching, fall back to this special case
-          notTouchingXY(dist, xDist, yDist, trcA, trcB.rC);
-        }
-      } else {
-        float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * xDist), b = -yDist / xDist, ab = a * b, bb = b * b;
-        float det = ab * ab - (1. + bb) * (a * a - trcA.rC * trcA.rC);
-        if (det > 0.) {
-          det = o2::gpu::GPUCommonMath::Sqrt(det);
-          yDCA[0] = (-ab + det) / (1. + bb);
-          xDCA[0] = a + b * yDCA[0] + trcA.xC;
-          yDCA[0] += trcA.yC;
-          yDCA[1] = (-ab - det) / (1. + bb);
-          xDCA[1] = a + b * yDCA[1] + trcA.xC;
-          yDCA[1] += trcA.yC;
-          nDCA = 2;
-        } else { // due to the finite precision the det<=0, i.e. the circles are barely touching, fall back to this special case
-          notTouchingXY(dist, xDist, yDist, trcA, trcB.rC);
-        }
-      }
-    }
-    return nDCA;
-  }
-
-  GPUd() void notTouchingXY(float dist, float xDist, float yDist, const TrackAuxPar& trcA, float rBSign, bool isCollinear = false)
-  {
-    if (isCollinear) {
-      /// for collinear tracks it is better to take
-      /// a weighted average of the crossing points as a radius
-      float r2r = trcA.rC + rBSign;
-      float r1_r = trcA.rC / r2r;
-      float r2_r = rBSign / r2r;
-      xDCA[0] = r2_r * trcA.xC + r1_r * (xDist + trcA.xC);
-      yDCA[0] = r2_r * trcA.yC + r1_r * (yDist + trcA.yC);
-    } else {
-      // fast method to calculate DCA between 2 circles, assuming that they don't touch each outer:
-      // the parametric equation of lines connecting the centers is x = xA + t/dist * xDist, y = yA + t/dist * yDist
-      // with xA,yY being the center of the circle A ( = trcA.xC, trcA.yC ), xDist = trcB.xC = trcA.xC ...
-      // There are 2 special cases:
-      // (a) small circle is inside the large one: provide rBSign as -trcB.rC
-      // (b) circle are side by side: provide rBSign as trcB.rC
-      auto t2d = (dist + trcA.rC - rBSign) / dist;
-      xDCA[0] = trcA.xC + 0.5 * (xDist * t2d);
-      yDCA[0] = trcA.yC + 0.5 * (yDist * t2d);
-    }
-    nDCA = 1;
-  }
-
-  template <typename T>
-  GPUd() int linesCrossInfo(const TrackAuxPar& trax0, const T& tr0,
-                            const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
-  {
-    /// closest approach of 2 straight lines
-    ///  TrackParam propagation can be parameterized in lab in a form
-    ///  xLab(t) = (x*cosAlp - y*sinAlp) + t*(cosAlp - sinAlp* snp/csp) = xLab0 + t*(cosAlp - sinAlp* snp/csp)
-    ///  yLab(t) = (x*sinAlp + y*cosAlp) + t*(sinAlp + cosAlp* snp/csp) = yLab0 + t*(sinAlp + cosAlp* snp/csp)
-    ///  zLab(t) = z + t * tgl / csp = zLab0 + t * tgl / csp
-    ///  where t is the x-step in the track alpha-frame, xLab,yLab,zLab are reference track coordinates in lab
-    ///  frame (filled by TrackAuxPar for straight line tracks).
-    ///
-    ///  Therefore, for the parametric track equation in lab 3D we have (wrt tracking-X increment t)
-    ///  xL(t) = xL + t Kx;  Kx = (cosAlp - sinAlp* snp/csp)
-    ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
-    ///  zL(t) = zL + t Kz;  Kz = tgl / csp
-    ///  Note that Kx^2 + Ky^2 + Kz^2 = (1+tgl^2) / csp^2
-    nDCA = 0;
-    float dx = trax1.xC - trax0.xC; // for straight line TrackAuxPar stores lab coordinates at referene point!!!
-    float dy = trax1.yC - trax0.yC; //
-    float dz = tr1.getZ() - tr0.getZ();
-    auto csp0i2 = 1. / tr0.getCsp2(); // 1 / csp^2
-    auto csp0i = o2::gpu::GPUCommonMath::Sqrt(csp0i2);
-    auto tgp0 = tr0.getSnp() * csp0i;
-    float kx0 = trax0.c - trax0.s * tgp0;
-    float ky0 = trax0.s + trax0.c * tgp0;
-    float kz0 = tr0.getTgl() * csp0i;
-    auto csp1i2 = 1. / tr1.getCsp2(); // 1 / csp^2
-    auto csp1i = o2::gpu::GPUCommonMath::Sqrt(csp1i2);
-    auto tgp1 = tr1.getSnp() * o2::gpu::GPUCommonMath::Sqrt(csp1i2);
-    float kx1 = trax1.c - trax1.s * tgp1;
-    float ky1 = trax1.s + trax1.c * tgp1;
-    float kz1 = tr1.getTgl() * csp1i;
-    /// Minimize |vecL1 - vecL0|^2 wrt t0 and t1: point of closest approach
-    /// Leads to system
-    /// A Dx = B with Dx = {dx0, dx1}
-    /// with A =
-    ///  |      kx0^2+ky0^2+kz0^2     -(kx0*kx1+ky0*ky1+kz0*kz1) | =  (1+tgl0^2) / csp0^2           ....
-    ///  | -(kx0*kx1+ky0*ky1+kz0*kz1)     kx0^2+ky0^2+kz0^2      |     .....                   (1+tgl1^2) / csp1^2
-    /// and B = {(dx Kx0 + dy Ky0 + dz Kz0), -(dx Kx1 + dy Ky1 + dz Kz1) }
-    ///
-    float a00 = (1.f + tr0.getTgl() * tr0.getTgl()) * csp0i2, a11 = (1.f + tr1.getTgl() * tr1.getTgl()) * csp1i2, a01 = -(kx0 * kx1 + ky0 * ky1 + kz0 * kz1);
-    float b0 = dx * kx0 + dy * ky0 + dz * kz0, b1 = -(dx * kx1 + dy * ky1 + dz * kz1);
-    float det = a00 * a11 - a01 * a01, det0 = b0 * a11 - b1 * a01, det1 = a00 * b1 - a01 * b0;
-    if (o2::gpu::GPUCommonMath::Sqrt(det) > o2::constants::math::Almost0) {
-      auto detI = 1. / det;
-      auto t0 = det0 * detI;
-      auto t1 = det1 * detI;
-      float addx0 = kx0 * t0, addy0 = ky0 * t0, addx1 = kx1 * t1, addy1 = ky1 * t1;
-      dx += addx1 - addx0; // recalculate XY distance at DCA
-      dy += addy1 - addy0;
-      if (dx * dx + dy * dy > maxDistXY * maxDistXY) {
-        return nDCA;
-      }
-      xDCA[0] = (trax0.xC + addx0 + trax1.xC + addx1) * 0.5;
-      yDCA[0] = (trax0.yC + addy0 + trax1.yC + addy1) * 0.5;
-      nDCA = 1;
-    }
-    return nDCA;
-  }
-
-  template <typename T>
-  GPUd() int circleLineCrossInfo(const TrackAuxPar& trax0, const T& tr0,
-                                 const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
-  {
-    /// closest approach of line and circle
-    ///  TrackParam propagation can be parameterized in lab in a form
-    ///  xLab(t) = (x*cosAlp - y*sinAlp) + t*(cosAlp - sinAlp* snp/csp) = xLab0 + t*(cosAlp - sinAlp* snp/csp)
-    ///  yLab(t) = (x*sinAlp + y*cosAlp) + t*(sinAlp + cosAlp* snp/csp) = yLab0 + t*(sinAlp + cosAlp* snp/csp)
-    ///  zLab(t) = z + t * tgl / csp = zLab0 + t * tgl / csp
-    ///  where t is the x-step in the track alpha-frame, xLab,yLab,zLab are reference track coordinates in lab
-    ///  frame (filled by TrackAuxPar for straight line tracks).
-    ///
-    ///  Therefore, for the parametric track equation in lab 3D we have (wrt tracking-X increment t)
-    ///  xL(t) = xL + t Kx;  Kx = (cosAlp - sinAlp* snp/csp)
-    ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
-    ///  zL(t) = zL + t Kz;  Kz = tgl / csp
-    ///  Note that Kx^2 + Ky^2  = 1 / csp^2
-
-    const auto& traxH = trax0.rC > trax1.rC ? trax0 : trax1; // circle (for the line rC is set to 0)
-    const auto& traxL = trax0.rC > trax1.rC ? trax1 : trax0; // line
-    const auto& trcL = trax0.rC > trax1.rC ? tr1 : tr0;      // track of the line
-
-    // solve quadratic equation of line crossing the circle
-    float dx = traxL.xC - traxH.xC; // X distance between the line lab reference and circle center
-    float dy = traxL.yC - traxH.yC; // Y...
-    // t^2(kx^2+ky^2) + 2t(dx*kx+dy*ky) + dx^2 + dy^2 - r^2 = 0
-    auto cspi2 = 1. / trcL.getCsp2(); // 1 / csp^2 == kx^2 +  ky^2
-    auto cspi = o2::gpu::GPUCommonMath::Sqrt(cspi2);
-    auto tgp = trcL.getSnp() * cspi;
-    float kx = traxL.c - traxL.s * tgp;
-    float ky = traxL.s + traxL.c * tgp;
-    double dk = dx * kx + dy * ky;
-    double det = dk * dk - cspi2 * (dx * dx + dy * dy - traxH.rC * traxH.rC);
-    if (det > 0) { // 2 crossings
-      det = o2::gpu::GPUCommonMath::Sqrt(det);
-      float t0 = (-dk + det) * cspi2;
-      float t1 = (-dk - det) * cspi2;
-      xDCA[0] = traxL.xC + kx * t0;
-      yDCA[0] = traxL.yC + ky * t0;
-      xDCA[1] = traxL.xC + kx * t1;
-      yDCA[1] = traxL.yC + ky * t1;
-      nDCA = 2;
-    } else {
-      // there is no crossing, find the point of the closest approach on the line which is closest to the circle center
-      float t = -dk * cspi2;
-      float xL = traxL.xC + kx * t, yL = traxL.yC + ky * t; // point on the line, need to average with point on the circle
-      float dxc = xL - traxH.xC, dyc = yL - traxH.yC, dist = o2::gpu::GPUCommonMath::Sqrt(dxc * dxc + dyc * dyc);
-      if (dist - traxH.rC > maxDistXY) { // too large distance
-        return nDCA;
-      }
-      float drcf = traxH.rC / dist; // radius / distance to circle center
-      float xH = traxH.xC + dxc * drcf, yH = traxH.yC + dyc * drcf;
-      xDCA[0] = (xL + xH) * 0.5;
-      yDCA[0] = (yL + yH) * 0.5;
-      nDCA = 1;
-    }
-    return nDCA;
-  }
-
-  template <typename T>
-  GPUd() int set(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
-  {
-    // calculate up to 2 crossings between 2 circles
-    nDCA = 0;
-    if (trax0.rC > o2::constants::math::Almost0 && trax1.rC > o2::constants::math::Almost0) { // both are not straight lines
-      nDCA = circlesCrossInfo(trax0, trax1, maxDistXY, isCollinear);
-    } else if (trax0.rC < o2::constants::math::Almost0 && trax1.rC < o2::constants::math::Almost0) { // both are straigt lines
-      nDCA = linesCrossInfo(trax0, tr0, trax1, tr1, maxDistXY);
-    } else {
-      nDCA = circleLineCrossInfo(trax0, tr0, trax1, tr1, maxDistXY);
-    }
-    //
-    return nDCA;
-  }
-
-  GPUdDefault() CrossInfo() = default;
-
-  template <typename T>
-  GPUd() CrossInfo(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
-  {
-    set(trax0, tr0, trax1, tr1, maxDistXY, isCollinear);
-  }
-  ClassDefNV(CrossInfo, 1);
-};
-
-} // namespace track
-} // namespace o2
-
-#endif
diff --git a/Detectors/Vertexing/include/DetectorsVertexing/HelixHelper.h b/Detectors/Vertexing/include/DetectorsVertexing/HelixHelper.h
deleted file mode 100644
index d197cba256c0e..0000000000000
--- a/Detectors/Vertexing/include/DetectorsVertexing/HelixHelper.h
+++ /dev/null
@@ -1,307 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file HelixHelper.h
-/// \brief Helper classes for helical tracks manipulations
-/// \author ruben.shahoyan@cern.ch
-
-#ifndef _ALICEO2_HELIX_HELPER_
-#define _ALICEO2_HELIX_HELPER_
-
-#include "CommonConstants/MathConstants.h"
-#include "MathUtils/Utils.h"
-#include "MathUtils/Primitive2D.h"
-
-namespace o2
-{
-namespace track
-{
-
-///__________________________________________________________________________
-//< precalculated track radius, center, alpha sin,cos and their combinations
-struct TrackAuxPar : public o2::math_utils::CircleXYf_t {
-  float c, s, cc, ss, cs; // cos ans sin of track alpha and their products
-
-  GPUdDefault() TrackAuxPar() = default;
-
-  template <typename T>
-  GPUd() TrackAuxPar(const T& trc, float bz)
-  {
-    set(trc, bz);
-  }
-  GPUd() float cosDif(const TrackAuxPar& t) const { return c * t.c + s * t.s; } // cos(alpha_this - alha_t)
-  GPUd() float sinDif(const TrackAuxPar& t) const { return s * t.c - c * t.s; } // sin(alpha_this - alha_t)
-
-  template <typename T>
-  GPUd() void set(const T& trc, float bz)
-  {
-    trc.getCircleParams(bz, *this, s, c);
-    cc = c * c;
-    ss = s * s;
-    cs = c * s;
-  }
-  ClassDefNV(TrackAuxPar, 1);
-};
-
-//__________________________________________________________
-//< crossing coordinates of 2 circles
-struct CrossInfo {
-  static constexpr float MaxDistXYDef = 10.;
-  float xDCA[2] = {};
-  float yDCA[2] = {};
-  int nDCA = 0;
-
-  GPUd() int circlesCrossInfo(const TrackAuxPar& trax0, const TrackAuxPar& trax1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
-  {
-    const auto& trcA = trax0.rC > trax1.rC ? trax0 : trax1; // designate the largest circle as A
-    const auto& trcB = trax0.rC > trax1.rC ? trax1 : trax0;
-    nDCA = 0;
-    float xDist = trcB.xC - trcA.xC, yDist = trcB.yC - trcA.yC;
-    float dist2 = xDist * xDist + yDist * yDist, dist = o2::gpu::GPUCommonMath::Sqrt(dist2), rsum = trcA.rC + trcB.rC;
-    if (dist < 1e-12) {
-      return nDCA; // circles are concentric?
-    }
-    if (dist > rsum) { // circles don't touch, chose a point in between
-      // the parametric equation of lines connecting the centers is
-      // x = x0 + t/dist * (x1-x0), y = y0 + t/dist * (y1-y0)
-      if (dist - rsum > maxDistXY) { // too large distance
-        return nDCA;
-      }
-      notTouchingXY(dist, xDist, yDist, trcA, trcB.rC, isCollinear);
-    } else if (auto dfr = dist + trcB.rC - trcA.rC; dfr < 0.) { // the small circle is nestled into large one w/o touching
-      if (dfr > -maxDistXY) {
-        // select the point of closest approach of 2 circles
-        notTouchingXY(dist, xDist, yDist, trcA, -trcB.rC, isCollinear);
-      } else {
-        return nDCA;
-      }
-    } else { // 2 intersection points
-      if (isCollinear) {
-        /// collinear tracks, e.g. electrons from photon conversion
-        /// if there are 2 crossings of the circle it is better to take
-        /// a weighted average of the crossing points as a radius
-        float r2r = trcA.rC + trcB.rC;
-        float r1_r = trcA.rC / r2r;
-        float r2_r = trcB.rC / r2r;
-        xDCA[0] = r2_r * trcA.xC + r1_r * trcB.xC;
-        yDCA[0] = r2_r * trcA.yC + r1_r * trcB.yC;
-        nDCA = 1;
-      } else if (o2::gpu::GPUCommonMath::Abs(xDist) < o2::gpu::GPUCommonMath::Abs(yDist)) {
-        // to simplify calculations, we move to new frame x->x+Xc0, y->y+Yc0, so that
-        // the 1st one is centered in origin
-        float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * yDist), b = -xDist / yDist, ab = a * b, bb = b * b;
-        float det = ab * ab - (1. + bb) * (a * a - trcA.rC * trcA.rC);
-        if (det > 0.) {
-          det = o2::gpu::GPUCommonMath::Sqrt(det);
-          xDCA[0] = (-ab + det) / (1. + b * b);
-          yDCA[0] = a + b * xDCA[0] + trcA.yC;
-          xDCA[0] += trcA.xC;
-          xDCA[1] = (-ab - det) / (1. + b * b);
-          yDCA[1] = a + b * xDCA[1] + trcA.yC;
-          xDCA[1] += trcA.xC;
-          nDCA = 2;
-        } else { // due to the finite precision the det<=0, i.e. the circles are barely touching, fall back to this special case
-          notTouchingXY(dist, xDist, yDist, trcA, trcB.rC);
-        }
-      } else {
-        float a = (trcA.rC * trcA.rC - trcB.rC * trcB.rC + dist2) / (2. * xDist), b = -yDist / xDist, ab = a * b, bb = b * b;
-        float det = ab * ab - (1. + bb) * (a * a - trcA.rC * trcA.rC);
-        if (det > 0.) {
-          det = o2::gpu::GPUCommonMath::Sqrt(det);
-          yDCA[0] = (-ab + det) / (1. + bb);
-          xDCA[0] = a + b * yDCA[0] + trcA.xC;
-          yDCA[0] += trcA.yC;
-          yDCA[1] = (-ab - det) / (1. + bb);
-          xDCA[1] = a + b * yDCA[1] + trcA.xC;
-          yDCA[1] += trcA.yC;
-          nDCA = 2;
-        } else { // due to the finite precision the det<=0, i.e. the circles are barely touching, fall back to this special case
-          notTouchingXY(dist, xDist, yDist, trcA, trcB.rC);
-        }
-      }
-    }
-    return nDCA;
-  }
-
-  GPUd() void notTouchingXY(float dist, float xDist, float yDist, const TrackAuxPar& trcA, float rBSign, bool isCollinear = false)
-  {
-    if (isCollinear) {
-      /// for collinear tracks it is better to take
-      /// a weighted average of the crossing points as a radius
-      float r2r = trcA.rC + rBSign;
-      float r1_r = trcA.rC / r2r;
-      float r2_r = rBSign / r2r;
-      xDCA[0] = r2_r * trcA.xC + r1_r * (xDist + trcA.xC);
-      yDCA[0] = r2_r * trcA.yC + r1_r * (yDist + trcA.yC);
-    } else {
-      // fast method to calculate DCA between 2 circles, assuming that they don't touch each outer:
-      // the parametric equation of lines connecting the centers is x = xA + t/dist * xDist, y = yA + t/dist * yDist
-      // with xA,yY being the center of the circle A ( = trcA.xC, trcA.yC ), xDist = trcB.xC = trcA.xC ...
-      // There are 2 special cases:
-      // (a) small circle is inside the large one: provide rBSign as -trcB.rC
-      // (b) circle are side by side: provide rBSign as trcB.rC
-      auto t2d = (dist + trcA.rC - rBSign) / dist;
-      xDCA[0] = trcA.xC + 0.5 * (xDist * t2d);
-      yDCA[0] = trcA.yC + 0.5 * (yDist * t2d);
-    }
-    nDCA = 1;
-  }
-
-  template <typename T>
-  GPUd() int linesCrossInfo(const TrackAuxPar& trax0, const T& tr0,
-                            const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
-  {
-    /// closest approach of 2 straight lines
-    ///  TrackParam propagation can be parameterized in lab in a form
-    ///  xLab(t) = (x*cosAlp - y*sinAlp) + t*(cosAlp - sinAlp* snp/csp) = xLab0 + t*(cosAlp - sinAlp* snp/csp)
-    ///  yLab(t) = (x*sinAlp + y*cosAlp) + t*(sinAlp + cosAlp* snp/csp) = yLab0 + t*(sinAlp + cosAlp* snp/csp)
-    ///  zLab(t) = z + t * tgl / csp = zLab0 + t * tgl / csp
-    ///  where t is the x-step in the track alpha-frame, xLab,yLab,zLab are reference track coordinates in lab
-    ///  frame (filled by TrackAuxPar for straight line tracks).
-    ///
-    ///  Therefore, for the parametric track equation in lab 3D we have (wrt tracking-X increment t)
-    ///  xL(t) = xL + t Kx;  Kx = (cosAlp - sinAlp* snp/csp)
-    ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
-    ///  zL(t) = zL + t Kz;  Kz = tgl / csp
-    ///  Note that Kx^2 + Ky^2 + Kz^2 = (1+tgl^2) / csp^2
-    nDCA = 0;
-    float dx = trax1.xC - trax0.xC; // for straight line TrackAuxPar stores lab coordinates at referene point!!!
-    float dy = trax1.yC - trax0.yC; //
-    float dz = tr1.getZ() - tr0.getZ();
-    auto csp0i2 = 1. / tr0.getCsp2(); // 1 / csp^2
-    auto csp0i = o2::gpu::GPUCommonMath::Sqrt(csp0i2);
-    auto tgp0 = tr0.getSnp() * csp0i;
-    float kx0 = trax0.c - trax0.s * tgp0;
-    float ky0 = trax0.s + trax0.c * tgp0;
-    float kz0 = tr0.getTgl() * csp0i;
-    auto csp1i2 = 1. / tr1.getCsp2(); // 1 / csp^2
-    auto csp1i = o2::gpu::GPUCommonMath::Sqrt(csp1i2);
-    auto tgp1 = tr1.getSnp() * o2::gpu::GPUCommonMath::Sqrt(csp1i2);
-    float kx1 = trax1.c - trax1.s * tgp1;
-    float ky1 = trax1.s + trax1.c * tgp1;
-    float kz1 = tr1.getTgl() * csp1i;
-    /// Minimize |vecL1 - vecL0|^2 wrt t0 and t1: point of closest approach
-    /// Leads to system
-    /// A Dx = B with Dx = {dx0, dx1}
-    /// with A =
-    ///  |      kx0^2+ky0^2+kz0^2     -(kx0*kx1+ky0*ky1+kz0*kz1) | =  (1+tgl0^2) / csp0^2           ....
-    ///  | -(kx0*kx1+ky0*ky1+kz0*kz1)     kx0^2+ky0^2+kz0^2      |     .....                   (1+tgl1^2) / csp1^2
-    /// and B = {(dx Kx0 + dy Ky0 + dz Kz0), -(dx Kx1 + dy Ky1 + dz Kz1) }
-    ///
-    float a00 = (1.f + tr0.getTgl() * tr0.getTgl()) * csp0i2, a11 = (1.f + tr1.getTgl() * tr1.getTgl()) * csp1i2, a01 = -(kx0 * kx1 + ky0 * ky1 + kz0 * kz1);
-    float b0 = dx * kx0 + dy * ky0 + dz * kz0, b1 = -(dx * kx1 + dy * ky1 + dz * kz1);
-    float det = a00 * a11 - a01 * a01, det0 = b0 * a11 - b1 * a01, det1 = a00 * b1 - a01 * b0;
-    if (o2::gpu::GPUCommonMath::Sqrt(det) > o2::constants::math::Almost0) {
-      auto detI = 1. / det;
-      auto t0 = det0 * detI;
-      auto t1 = det1 * detI;
-      float addx0 = kx0 * t0, addy0 = ky0 * t0, addx1 = kx1 * t1, addy1 = ky1 * t1;
-      dx += addx1 - addx0; // recalculate XY distance at DCA
-      dy += addy1 - addy0;
-      if (dx * dx + dy * dy > maxDistXY * maxDistXY) {
-        return nDCA;
-      }
-      xDCA[0] = (trax0.xC + addx0 + trax1.xC + addx1) * 0.5;
-      yDCA[0] = (trax0.yC + addy0 + trax1.yC + addy1) * 0.5;
-      nDCA = 1;
-    }
-    return nDCA;
-  }
-
-  template <typename T>
-  GPUd() int circleLineCrossInfo(const TrackAuxPar& trax0, const T& tr0,
-                                 const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef)
-  {
-    /// closest approach of line and circle
-    ///  TrackParam propagation can be parameterized in lab in a form
-    ///  xLab(t) = (x*cosAlp - y*sinAlp) + t*(cosAlp - sinAlp* snp/csp) = xLab0 + t*(cosAlp - sinAlp* snp/csp)
-    ///  yLab(t) = (x*sinAlp + y*cosAlp) + t*(sinAlp + cosAlp* snp/csp) = yLab0 + t*(sinAlp + cosAlp* snp/csp)
-    ///  zLab(t) = z + t * tgl / csp = zLab0 + t * tgl / csp
-    ///  where t is the x-step in the track alpha-frame, xLab,yLab,zLab are reference track coordinates in lab
-    ///  frame (filled by TrackAuxPar for straight line tracks).
-    ///
-    ///  Therefore, for the parametric track equation in lab 3D we have (wrt tracking-X increment t)
-    ///  xL(t) = xL + t Kx;  Kx = (cosAlp - sinAlp* snp/csp)
-    ///  yL(t) = yL + t Ky;  Ky = (sinAlp + cosAlp* snp/csp)
-    ///  zL(t) = zL + t Kz;  Kz = tgl / csp
-    ///  Note that Kx^2 + Ky^2  = 1 / csp^2
-
-    const auto& traxH = trax0.rC > trax1.rC ? trax0 : trax1; // circle (for the line rC is set to 0)
-    const auto& traxL = trax0.rC > trax1.rC ? trax1 : trax0; // line
-    const auto& trcL = trax0.rC > trax1.rC ? tr1 : tr0;      // track of the line
-
-    // solve quadratic equation of line crossing the circle
-    float dx = traxL.xC - traxH.xC; // X distance between the line lab reference and circle center
-    float dy = traxL.yC - traxH.yC; // Y...
-    // t^2(kx^2+ky^2) + 2t(dx*kx+dy*ky) + dx^2 + dy^2 - r^2 = 0
-    auto cspi2 = 1. / trcL.getCsp2(); // 1 / csp^2 == kx^2 +  ky^2
-    auto cspi = o2::gpu::GPUCommonMath::Sqrt(cspi2);
-    auto tgp = trcL.getSnp() * cspi;
-    float kx = traxL.c - traxL.s * tgp;
-    float ky = traxL.s + traxL.c * tgp;
-    double dk = dx * kx + dy * ky;
-    double det = dk * dk - cspi2 * (dx * dx + dy * dy - traxH.rC * traxH.rC);
-    if (det > 0) { // 2 crossings
-      det = o2::gpu::GPUCommonMath::Sqrt(det);
-      float t0 = (-dk + det) * cspi2;
-      float t1 = (-dk - det) * cspi2;
-      xDCA[0] = traxL.xC + kx * t0;
-      yDCA[0] = traxL.yC + ky * t0;
-      xDCA[1] = traxL.xC + kx * t1;
-      yDCA[1] = traxL.yC + ky * t1;
-      nDCA = 2;
-    } else {
-      // there is no crossing, find the point of the closest approach on the line which is closest to the circle center
-      float t = -dk * cspi2;
-      float xL = traxL.xC + kx * t, yL = traxL.yC + ky * t; // point on the line, need to average with point on the circle
-      float dxc = xL - traxH.xC, dyc = yL - traxH.yC, dist = o2::gpu::GPUCommonMath::Sqrt(dxc * dxc + dyc * dyc);
-      if (dist - traxH.rC > maxDistXY) { // too large distance
-        return nDCA;
-      }
-      float drcf = traxH.rC / dist; // radius / distance to circle center
-      float xH = traxH.xC + dxc * drcf, yH = traxH.yC + dyc * drcf;
-      xDCA[0] = (xL + xH) * 0.5;
-      yDCA[0] = (yL + yH) * 0.5;
-      nDCA = 1;
-    }
-    return nDCA;
-  }
-
-  template <typename T>
-  GPUd() int set(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
-  {
-    // calculate up to 2 crossings between 2 circles
-    nDCA = 0;
-    if (trax0.rC > o2::constants::math::Almost0 && trax1.rC > o2::constants::math::Almost0) { // both are not straight lines
-      nDCA = circlesCrossInfo(trax0, trax1, maxDistXY, isCollinear);
-    } else if (trax0.rC < o2::constants::math::Almost0 && trax1.rC < o2::constants::math::Almost0) { // both are straigt lines
-      nDCA = linesCrossInfo(trax0, tr0, trax1, tr1, maxDistXY);
-    } else {
-      nDCA = circleLineCrossInfo(trax0, tr0, trax1, tr1, maxDistXY);
-    }
-    //
-    return nDCA;
-  }
-
-  GPUdDefault() CrossInfo() = default;
-
-  template <typename T>
-  GPUd() CrossInfo(const TrackAuxPar& trax0, const T& tr0, const TrackAuxPar& trax1, const T& tr1, float maxDistXY = MaxDistXYDef, bool isCollinear = false)
-  {
-    set(trax0, tr0, trax1, tr1, maxDistXY, isCollinear);
-  }
-  ClassDefNV(CrossInfo, 1);
-};
-
-} // namespace track
-} // namespace o2
-
-#endif

From b54307ae96409b69dc51cd329628cdcd03691291 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 6 Oct 2025 00:53:12 +0200
Subject: [PATCH 0902/1764] DPL: refactor resource offers to allow
 multi-resource ones (#14717)

Preliminary work to properly avoid race conditions between memory
and timeslice rate limiting and in general to support multi source rate limiting.
---
 Framework/Core/src/ArrowSupport.cxx | 82 ++++++++++++++++++-----------
 1 file changed, 52 insertions(+), 30 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index a289980349924..94764571840f4 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -288,63 +288,85 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        if (maxTimeframes && (totalTimeframesRead - totalTimeframesConsumed) > maxTimeframes) {
                          return;
                        }
+                       struct ResourceState {
+                          int64_t available;
+                          int64_t offered = 0;
+                          int64_t lastDeviceOffered = 0;
+                       };
+                       struct ResourceStats {
+                          int64_t enoughCount;
+                          int64_t lowCount;
+                       };
+                       struct ResourceSpec{
+                          int64_t maxAvailable;
+                          int64_t maxQuantum;
+                          int64_t minQuantum;
+                       };
+                       static const ResourceSpec resourceSpec{
+                         .maxAvailable = (int64_t)calculateAvailableSharedMemory(registry),
+                         .maxQuantum = 100,
+                         .minQuantum = 50,
+                       };
+                       static ResourceState resourceState{
+                         .available = resourceSpec.maxAvailable,
+                       };
+                       static ResourceStats resourceStats{
+                         .enoughCount = resourceState.available - resourceSpec.minQuantum > 0 ? 1 : 0,
+                         .lowCount = resourceState.available - resourceSpec.minQuantum > 0 ? 0 : 1
+                       };
 
-                       static int64_t MAX_SHARED_MEMORY = calculateAvailableSharedMemory(registry);
-                       constexpr int64_t MAX_QUANTUM_SHARED_MEMORY = 100;
-                       constexpr int64_t MIN_QUANTUM_SHARED_MEMORY = 50;
-
-                       static int64_t availableSharedMemory = MAX_SHARED_MEMORY;
-                       static int64_t offeredSharedMemory = 0;
-                       static int64_t lastDeviceOffered = 0;
                        /// We loop over the devices, starting from where we stopped last time
                        /// offering MIN_QUANTUM_SHARED_MEMORY of shared memory to each reader.
                        int64_t lastCandidate = -1;
-                       static int enoughSharedMemoryCount = availableSharedMemory - MIN_QUANTUM_SHARED_MEMORY > 0 ? 1 : 0;
-                       static int lowSharedMemoryCount = availableSharedMemory - MIN_QUANTUM_SHARED_MEMORY > 0 ? 0 : 1;
-                       int64_t possibleOffer = MIN_QUANTUM_SHARED_MEMORY;
+                       int64_t possibleOffer = resourceSpec.minQuantum;
+
                        for (size_t di = 0; di < specs.size(); di++) {
-                         if (availableSharedMemory < possibleOffer) {
-                           if (lowSharedMemoryCount == 0) {
+                         if (resourceState.available < possibleOffer) {
+                           if (resourceStats.lowCount == 0) {
                              O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "not enough",
                                                     "We do not have enough shared memory (%{bytes}llu MB) to offer %{bytes}llu MB. Total offerings %{bytes}llu",
-                                                    availableSharedMemory, possibleOffer, offeredSharedMemory);
+                                                     resourceState.available, possibleOffer, resourceState.offered);
                            }
-                           lowSharedMemoryCount++;
-                           enoughSharedMemoryCount = 0;
+                           resourceStats.lowCount++;
+                           resourceStats.enoughCount = 0;
                            break;
                          } else {
-                           if (enoughSharedMemoryCount == 0) {
+                           if (resourceStats.enoughCount == 0) {
                              O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "enough",
-                                                    "We are back in a state where we enough shared memory: %{bytes}llu MB", availableSharedMemory);
+                                                    "We are back in a state where we enough shared memory: %{bytes}llu MB", resourceState.available);
                            }
-                           enoughSharedMemoryCount++;
-                           lowSharedMemoryCount = 0;
+                           resourceStats.lowCount = 0;
+                           resourceStats.enoughCount++;
                          }
-                         size_t candidate = (lastDeviceOffered + di) % specs.size();
+                         size_t candidate = (resourceState.lastDeviceOffered + di) % specs.size();
 
                          auto& info = infos[candidate];
                          // Do not bother for inactive devices
                          // FIXME: there is probably a race condition if the device died and we did not
                          //        took notice yet...
                          if (info.active == false || info.readyToQuit) {
+                           O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                                                  "Device %s is inactive not offering memory to it.", specs[candidate].name.c_str());
                            continue;
                          }
                          if (specs[candidate].name != "internal-dpl-aod-reader") {
+                           O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                                                  "Device %s is not a reader. Not offering memory to it.", specs[candidate].name.c_str());
                            continue;
                          }
-                         possibleOffer = std::min(MAX_QUANTUM_SHARED_MEMORY, availableSharedMemory);
+                         possibleOffer = std::min(resourceSpec.maxQuantum, resourceState.available);
                          O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
                                                 "Offering %{bytes}llu MB out of %{bytes}llu to %{public}s",
-                                                possibleOffer, availableSharedMemory, specs[candidate].id.c_str());
+                                                possibleOffer, resourceState.available, specs[candidate].id.c_str());
                          manager.queueMessage(specs[candidate].id.c_str(), fmt::format("/shm-offer {}", possibleOffer).data());
-                         availableSharedMemory -= possibleOffer;
-                         offeredSharedMemory += possibleOffer;
+                         resourceState.available -= possibleOffer;
+                         resourceState.offered += possibleOffer;
                          lastCandidate = candidate;
                        }
                        // We had at least a valid candidate, so
                        // next time we offer to the next device.
                        if (lastCandidate >= 0) {
-                         lastDeviceOffered = lastCandidate + 1;
+                         resourceState.lastDeviceOffered = lastCandidate + 1;
                        }
 
                        // unusedOfferedSharedMemory is the amount of memory which was offered and which we know it was
@@ -357,21 +379,21 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                                                 "Offer consumed so far %{bytes}llu", shmOfferBytesConsumed);
                          lastShmOfferConsumed = shmOfferBytesConsumed;
                        }
-                       int unusedOfferedMemory = (offeredSharedMemory - (totalBytesExpired + shmOfferBytesConsumed) / 1000000);
+                       int unusedOfferedMemory = (resourceState.offered - (totalBytesExpired + shmOfferBytesConsumed) / 1000000);
                        if (lastUnusedOfferedMemory != unusedOfferedMemory) {
                          O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
                                                 "unusedOfferedMemory:%{bytes}d = offered:%{bytes}llu - (expired:%{bytes}llu + consumed:%{bytes}llu) / 1000000",
-                                                 unusedOfferedMemory, offeredSharedMemory, totalBytesExpired / 1000000, shmOfferBytesConsumed / 1000000);
+                                                 unusedOfferedMemory, resourceState.offered, totalBytesExpired / 1000000, shmOfferBytesConsumed / 1000000);
                          lastUnusedOfferedMemory = unusedOfferedMemory;
                        }
                        // availableSharedMemory is the amount of memory which we know is available to be offered.
                        // We subtract the amount which we know was already offered but it's unused and we then balance how
                        // much was created with how much was destroyed.
-                       availableSharedMemory = MAX_SHARED_MEMORY + ((totalBytesDestroyed - totalBytesCreated) / 1000000) - unusedOfferedMemory;
-                       availableSharedMemoryMetric(driverMetrics, availableSharedMemory, timestamp);
+                       resourceState.available = resourceSpec.maxAvailable + ((totalBytesDestroyed - totalBytesCreated) / 1000000) - unusedOfferedMemory;
+                       availableSharedMemoryMetric(driverMetrics, resourceState.available, timestamp);
                        unusedOfferedSharedMemoryMetric(driverMetrics, unusedOfferedMemory, timestamp);
 
-                       offeredSharedMemoryMetric(driverMetrics, offeredSharedMemory, timestamp); },
+                       offeredSharedMemoryMetric(driverMetrics, resourceState.offered, timestamp); },
     .postDispatching = [](ProcessingContext& ctx, void* service) {
                        using DataHeader = o2::header::DataHeader;
                        auto* arrow = reinterpret_cast<ArrowContext*>(service);

From 21092835fedc030ae2ac653d5ccac231db2c0144 Mon Sep 17 00:00:00 2001
From: Fabrizio Grosa <fabrizio.grosa@cern.ch>
Date: Sun, 5 Oct 2025 11:08:55 +0200
Subject: [PATCH 0903/1764] Fix protection of MC signal filtering to work with
 any embedPatt

---
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 28 +++++++++++--------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index b841943b05031..b8d295a4393e4 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -2063,16 +2063,11 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
     const auto& mcRecords = mcReader->getDigitizationContext()->getEventRecords();
     const auto& mcParts = mcReader->getDigitizationContext()->getEventParts();
 
-    // count all parts
-    int totalNParts = 0;
-    for (int iCol = 0; iCol < nMCCollisions; iCol++) {
-      totalNParts += mcParts[iCol].size();
-
-      // if signal filtering enabled, let's check if there are more than one source; otherwise fatalise
-      if (mUseSigFiltMC) {
-        std::vector<int> sourceIDs{};
-        auto& colParts = mcParts[iCol];
-        for (auto colPart : colParts) {
+    // if signal filtering enabled, let's check if there are more than one source; otherwise fatalise
+    if (mUseSigFiltMC) {
+      std::vector<int> sourceIDs{};
+      for (int iCol = 0; iCol < nMCCollisions; iCol++) {
+        for (auto const& colPart : mcParts[iCol]) {
           int sourceID = colPart.sourceID;
           if (std::find(sourceIDs.begin(), sourceIDs.end(), sourceID) == sourceIDs.end()) {
             sourceIDs.push_back(sourceID);
@@ -2081,10 +2076,19 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
             break;
           }
         }
-        if (sourceIDs.size() <= 1) {
-          LOGP(fatal, "Signal filtering cannot be enabled without embedding. Please fix the configuration either enabling the embedding, or turning off the signal filtering.");
+        if (sourceIDs.size() > 1) { // we found more than one, exit
+          break;
         }
       }
+      if (sourceIDs.size() <= 1) {
+        LOGP(fatal, "Signal filtering cannot be enabled without embedding. Please fix the configuration either enabling the embedding, or turning off the signal filtering.");
+      }
+    }
+
+    // count all parts
+    int totalNParts = 0;
+    for (int iCol = 0; iCol < nMCCollisions; iCol++) {
+      totalNParts += mcParts[iCol].size();
     }
     mcCollisionsCursor.reserve(totalNParts);
 

From 18d99309a294bbd68f39e4f636707c14733e75ba Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Sun, 5 Oct 2025 23:39:18 +0200
Subject: [PATCH 0904/1764] Silence by default IncompleteHBF check

---
 Detectors/TPC/workflow/src/IDCToVectorSpec.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx b/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
index 9d704d425f1da..da8de5f262cdf 100644
--- a/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
+++ b/Detectors/TPC/workflow/src/IDCToVectorSpec.cxx
@@ -72,6 +72,7 @@ class IDCToVectorDevice : public o2::framework::Task
     mWriteDebugOnError = ic.options().get<bool>("write-debug-on-error");
     mWriteRawDataOnError = ic.options().get<bool>("write-raw-data-on-error");
     mRawDataType = ic.options().get<int>("raw-data-type");
+    o2::framework::RawParser<>::setCheckIncompleteHBF(ic.options().get<bool>("check-incomplete-hbf"));
 
     mDebugStreamFileName = ic.options().get<std::string>("debug-file-name").data();
     mRawOutputFileName = ic.options().get<std::string>("raw-file-name").data();
@@ -606,9 +607,10 @@ o2::framework::DataProcessorSpec getIDCToVectorSpec(const std::string inputSpec,
       {"write-raw-data-on-error", VariantType::Bool, false, {"dump raw data in case errors occurred"}},
       {"raw-file-name", VariantType::String, "/tmp/idc_debug.{run}.{raw_type}", {"name of the raw output file"}},
       {"raw-data-type", VariantType::Int, 0, {"Which raw data to dump: 0-full TPC with DH, 1-full TPC with DH skip empty, 2-full TPC no DH, 3-full TPC no DH skip empty, 4-IDC raw only"}},
+      {"check-incomplete-hbf", VariantType::Bool, false, {"false: don't chck; true: check and report"}},
       {"pedestal-url", VariantType::String, "ccdb-default", {"ccdb-default: load from NameConf::getCCDBServer() OR ccdb url (must contain 'ccdb' OR pedestal file name"}},
       {"swap-links", VariantType::Bool, false, {"swap links to circumvent bug in FW"}},
     } // end Options
-  };  // end DataProcessorSpec
+  }; // end DataProcessorSpec
 }
 } // namespace o2::tpc

From b03fd5c90799229cbcd96c8bcaebad91eb9fbc08 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 6 Oct 2025 14:11:58 +0200
Subject: [PATCH 0905/1764] Glo: only initialzed AB geom helper up to lowest
 layer

We can skip initializing the layers below the lowest allowed AB layer.
This allows to run the AB for ITS3 otherwise the initialization of the
RecoGeomHelper is not well defined and crashed for layers < 3 since the
chip mapping is not well defined.
Currently we anyways allow AB tracks only to go down to layer 3 by
default and this might not change for Run 4 anytime soon. If it does the
RecoGeomHelper class has to be adapted then.

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/GlobalTracking/src/MatchTPCITS.cxx                  | 4 ++--
 .../reconstruction/include/ITSReconstruction/RecoGeomHelper.h | 2 +-
 Detectors/ITSMFT/ITS/reconstruction/src/RecoGeomHelper.cxx    | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index e16031f641829..7e3f8d9f78fc9 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -245,8 +245,8 @@ void MatchTPCITS::init()
   }
 #endif
 
-  if (mParams->runAfterBurner) { // only used in AfterBurner
-    mRGHelper.init();            // prepare helper for TPC track / ITS clusters matching
+  if (mParams->runAfterBurner) {            // only used in AfterBurner
+    mRGHelper.init(mParams->lowestLayerAB); // prepare helper for TPC track / ITS clusters matching
   }
 
   clear();
diff --git a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/RecoGeomHelper.h b/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/RecoGeomHelper.h
index f9d3f1ae46752..a7d814f02d011 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/RecoGeomHelper.h
+++ b/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/RecoGeomHelper.h
@@ -103,7 +103,7 @@ struct RecoGeomHelper {
   static constexpr float ladderWidth() { return o2::itsmft::SegmentationAlpide::SensorSizeRows; }
   static constexpr float ladderWidthInv() { return 1. / ladderWidth(); }
 
-  void init();
+  void init(int minLayer = 0, int maxLayer = getNLayers());
   void print() const;
 
   ClassDefNV(RecoGeomHelper, 0);
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/RecoGeomHelper.cxx b/Detectors/ITSMFT/ITS/reconstruction/src/RecoGeomHelper.cxx
index 8f2efef0b34cd..712ec6a022d16 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/src/RecoGeomHelper.cxx
+++ b/Detectors/ITSMFT/ITS/reconstruction/src/RecoGeomHelper.cxx
@@ -229,9 +229,9 @@ void RecoGeomHelper::RecoLayer::print() const
 }
 
 //_____________________________________________________________________
-void RecoGeomHelper::init()
+void RecoGeomHelper::init(int minLayer, int maxLayer)
 {
-  for (int il = int(layers.size()); il--;) {
+  for (int il = maxLayer; --il >= minLayer;) {
     auto& lr = layers[il];
     lr.id = il;
     lr.init();

From e440f48ee0bb73cdef5615af4b3df3123a725c99 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 6 Oct 2025 18:13:22 +0200
Subject: [PATCH 0906/1764] TPC Workflow: Fix option name in help text and
 comment

---
 Detectors/TPC/workflow/src/RecoWorkflow.cxx      | 2 +-
 Detectors/TPC/workflow/src/tpc-reco-workflow.cxx | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index 3fdff02dd69cc..98a9841fac8b2 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -553,7 +553,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   //
   // a writer process for compressed clusters container
   //
-  // selected by output type 'compressed-clusters'
+  // selected by output type 'compressed-clusters-root'
   if (produceCompClustersRoot && !isEnabled(OutputType::DisableWriter)) {
     // defining the track writer process using the generic RootTreeWriter and generator tool
     //
diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index b440f6e8d359f..3c8804de8b536 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -57,7 +57,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   using namespace o2::framework;
 
   std::vector<ConfigParamSpec> options{
-    {"input-type", VariantType::String, "digits", {"digitizer, digits, zsraw, clustershw, clusters, compressed-clusters-root, compressed-clusters-ctf, compressed-clusters-flat-for-encode, pass-through"}},
+    {"input-type", VariantType::String, "digits", {"digitizer, digits, zsraw, clustershw, clusters, compressed-clusters-root, compressed-clusters-flat, compressed-clusters-flat-for-encode, pass-through"}},
     {"output-type", VariantType::String, "tracks", {"digits, zsraw, clustershw, clusters, tracks, compressed-clusters-root, compressed-clusters-flat, encoded-clusters, disable-writer, send-clusters-per-sector, qa, no-shared-cluster-map, tpc-triggers"}},
     {"disable-root-input", o2::framework::VariantType::Bool, false, {"disable root-files input reader"}},
     {"no-ca-clusterer", VariantType::Bool, false, {"Use HardwareClusterer instead of clusterer of GPUCATracking"}},

From d56b3e960180c908487faf9215b6e9ed6fa77c77 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 7 Oct 2025 23:21:17 +0200
Subject: [PATCH 0907/1764] Account for rejected clusters in unbinned residuals
 counters

---
 .../TPC/calibration/SpacePoints/src/TrackInterpolation.cxx  | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index d89b3c28f1a0d..f9861bb26ff93 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -640,7 +640,6 @@ void TrackInterpolation::interpolateTrack(int iSeed)
         // skip masked cluster residual
         continue;
       }
-      ++nClValidated;
       const float tgPhi = clusterResiduals[iCl].snp / std::sqrt((1.f - clusterResiduals[iCl].snp) * (1.f + clusterResiduals[iCl].snp));
       const auto dy = clusterResiduals[iCl].dy;
       const auto dz = clusterResiduals[iCl].dz;
@@ -649,6 +648,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
       const auto sec = clusterResiduals[iCl].sec;
       if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(y) < param::MaxY) && (std::abs(z) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
         mClRes.emplace_back(dy, dz, tgPhi, y, z, iRow, sec);
+        ++nClValidated;
       } else {
         ++mRejectedResiduals;
       }
@@ -875,7 +875,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
 
   TrackParams params; // for refitted track parameters and flagging rejected clusters
   if (clusterResiduals.size() > constants::MAXGLOBALPADROW) {
-    LOGP(warn, "Extrapolated ITS-TPC track and found more reesiduals than possible ({})", clusterResiduals.size());
+    LOGP(warn, "Extrapolated ITS-TPC track and found more residuals than possible ({})", clusterResiduals.size());
     return;
   }
 
@@ -899,7 +899,6 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
       if (iRow < param::NPadRows && params.flagRej[iCl]) { // skip masked cluster residual
         continue;
       }
-      ++nClValidated;
       const float tgPhi = clusterResiduals[iCl].snp / std::sqrt((1.f - clusterResiduals[iCl].snp) * (1.f + clusterResiduals[iCl].snp));
       const auto dy = clusterResiduals[iCl].dy;
       const auto dz = clusterResiduals[iCl].dz;
@@ -907,6 +906,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
       const auto z = clusterResiduals[iCl].z;
       if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(y) < param::MaxY) && (std::abs(z) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
         mClRes.emplace_back(dy, dz, tgPhi, y, z, iRow, clusterResiduals[iCl].sec);
+        ++nClValidated;
       } else {
         ++mRejectedResiduals;
       }

From 596f0db278ffb0586c1c408fa6097ebb5f660133 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 9 Oct 2025 20:09:48 +0200
Subject: [PATCH 0908/1764] DPL: print an error when the configuration is not
 parsed correctly (#14727)

This should probably be a fatal error not sure why the rethrown
exception is ignored (and where).
---
 Framework/Core/src/PropertyTreeHelpers.cxx | 43 ++++++++++++++++++----
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/Framework/Core/src/PropertyTreeHelpers.cxx b/Framework/Core/src/PropertyTreeHelpers.cxx
index 3f2356eb37824..18055edb635b4 100644
--- a/Framework/Core/src/PropertyTreeHelpers.cxx
+++ b/Framework/Core/src/PropertyTreeHelpers.cxx
@@ -14,12 +14,15 @@
 #include "Framework/VariantPropertyTreeHelpers.h"
 #include "Framework/RuntimeError.h"
 #include "Framework/VariantJSONHelpers.h"
+#include "Framework/Signpost.h"
 
 #include <boost/program_options/variables_map.hpp>
 
 #include <vector>
 #include <string>
 
+O2_DECLARE_DYNAMIC_LOG(configuration);
+
 namespace o2::framework
 {
 namespace
@@ -37,6 +40,8 @@ void PropertyTreeHelpers::populateDefaults(std::vector<ConfigParamSpec> const& s
                                            boost::property_tree::ptree& pt,
                                            boost::property_tree::ptree& provenance)
 {
+  O2_SIGNPOST_ID_GENERATE(cid, configuration);
+  O2_SIGNPOST_START(configuration, cid, "populateDefaults", "Filling with defaults");
   for (auto const& spec : schema) {
     std::string key = spec.name.substr(0, spec.name.find(','));
     try {
@@ -77,9 +82,12 @@ void PropertyTreeHelpers::populateDefaults(std::vector<ConfigParamSpec> const& s
         case VariantType::String:
           pt.put(key, spec.defaultValue.get<std::string>());
           break;
-        case VariantType::Bool:
-          pt.put(key, spec.defaultValue.get<bool>());
+        case VariantType::Bool: {
+          bool value = spec.defaultValue.get<bool>();
+          O2_SIGNPOST_EVENT_EMIT(configuration, cid, "populateDefaults", "Setting %{public}s: %{public}s", key.c_str(), value ? "true" : "false");
+          pt.put(key, value);
           break;
+        }
         case VariantType::Dict:
           pt.put_child(key, boost::property_tree::ptree{});
           break;
@@ -126,13 +134,17 @@ void PropertyTreeHelpers::populateDefaults(std::vector<ConfigParamSpec> const& s
       }
       provenance.put(key, "default");
     } catch (std::runtime_error& re) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populateDefaults", "Aborting because of runtime_error %{public}s", re.what());
       throw;
     } catch (std::exception& e) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populateDefaults", "Missing option %{public}s (%{public}s)", key.c_str(), e.what());
       throw std::invalid_argument(std::string("missing option: ") + key + " (" + e.what() + ")");
     } catch (...) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populateDefaults", "Aborting because of missing option %{public}s", key.c_str());
       throw std::invalid_argument(std::string("missing option: ") + key);
     }
   }
+  O2_SIGNPOST_END(configuration, cid, "populateDefaults", "Done");
 }
 
 void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
@@ -140,6 +152,8 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
                                    boost::program_options::variables_map const& vmap,
                                    boost::property_tree::ptree& provenance)
 {
+  O2_SIGNPOST_ID_GENERATE(cid, configuration);
+  O2_SIGNPOST_START(configuration, cid, "populate", "Filling parameters from variables_map");
   for (auto const& spec : schema) {
     // strip short version to get the correct key
     std::string key = spec.name.substr(0, spec.name.find(','));
@@ -183,9 +197,11 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
             pt.put(key, *v);
           }
           break;
-        case VariantType::Bool:
-          pt.put(key, vmap[key].as<bool>());
-          break;
+        case VariantType::Bool: {
+          auto v = vmap[key].as<bool>();
+          O2_SIGNPOST_EVENT_EMIT(configuration, cid, "populate", "Setting %{public}s: %{public}s", key.c_str(), v ? "true" : "false");
+          pt.put(key, v);
+        } break;
         case VariantType::ArrayInt: {
           auto v = fromString<VariantType::ArrayInt>(vmap[key].as<std::string>());
           pt.put_child(key, vectorToBranch<int>(v.get<int*>(), v.size()));
@@ -243,13 +259,17 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
       }
       provenance.put(key, "fairmq");
     } catch (std::runtime_error& re) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Aborting because of runtime_error %{public}s", re.what());
       throw;
     } catch (std::exception& e) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Missing option %{public}s (%{public}s)", key.c_str(), e.what());
       throw std::invalid_argument(std::string("missing option: ") + key + " (" + e.what() + ")");
     } catch (...) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Aborting because of missing option %{public}s", key.c_str());
       throw std::invalid_argument(std::string("missing option: ") + key);
     }
   }
+  O2_SIGNPOST_END(configuration, cid, "populate", "Done");
 }
 
 template <typename T>
@@ -273,6 +293,8 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
                                    boost::property_tree::ptree& provenance,
                                    std::string const& provenanceLabel)
 {
+  O2_SIGNPOST_ID_GENERATE(cid, configuration);
+  O2_SIGNPOST_START(configuration, cid, "populate", "Filling parameters from ptree");
   for (auto const& spec : schema) {
     // strip short version to get the correct key
     std::string key = spec.name.substr(0, spec.name.find(','));
@@ -318,9 +340,11 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
         case VariantType::String:
           pt.put(key, (*it).get_value<std::string>());
           break;
-        case VariantType::Bool:
+        case VariantType::Bool: {
+          auto v = (*it).get_value<bool>();
+          O2_SIGNPOST_EVENT_EMIT(configuration, cid, "populate", "Setting %{public}s: %{public}s", key.c_str(), v ? "true" : "false");
           pt.put(key, (*it).get_value<bool>());
-          break;
+        } break;
         case VariantType::Dict:
         case VariantType::ArrayInt:
         case VariantType::ArrayFloat:
@@ -371,13 +395,18 @@ void PropertyTreeHelpers::populate(std::vector<ConfigParamSpec> const& schema,
       }
       provenance.put(key, provenanceLabel);
     } catch (std::runtime_error& re) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Aborting during processing of %{public}s because of runtime_error %{public}s",
+                                 key.c_str(), re.what());
       throw;
     } catch (std::exception& e) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Missing option %{public}s (%{public}s)", key.c_str(), e.what());
       throw std::invalid_argument(std::string("missing option: ") + key + " (" + e.what() + ")");
     } catch (...) {
+      O2_SIGNPOST_END_WITH_ERROR(configuration, cid, "populate", "Aborting because of missing option %{public}s", key.c_str());
       throw std::invalid_argument(std::string("missing option: ") + key);
     }
   }
+  O2_SIGNPOST_END(configuration, cid, "populate", "Done");
 }
 
 namespace

From c5544b0615567a43362c43a413457f8028f040d5 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 10 Oct 2025 09:28:30 +0200
Subject: [PATCH 0909/1764] DPL: support submitting directly to slurm (#14728)

Without this, different jobs on the same machine will cross-talk
due to possible lack of isolation in linux abstract sockets.
---
 Framework/Core/src/ChannelSpecHelpers.cxx | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Framework/Core/src/ChannelSpecHelpers.cxx b/Framework/Core/src/ChannelSpecHelpers.cxx
index c66a1964c12a0..0578c51403b26 100644
--- a/Framework/Core/src/ChannelSpecHelpers.cxx
+++ b/Framework/Core/src/ChannelSpecHelpers.cxx
@@ -339,6 +339,10 @@ std::string ChannelSpecHelpers::defaultIPCFolder()
   if (channelPrefix) {
     return fmt::format("@dpl_{}_", channelPrefix);
   }
+  channelPrefix = getenv("SLURM_JOB_ID");
+  if (channelPrefix) {
+    return fmt::format("@dpl_{}_", channelPrefix);
+  }
   return "@";
 #else
   /// Find out a place where we can write the sockets

From a662980a876e54dc685cc937d528566ab933bcb8 Mon Sep 17 00:00:00 2001
From: Marvin Hemmer <marvin.hemmer@cern.ch>
Date: Tue, 9 Sep 2025 14:27:01 +0200
Subject: [PATCH 0910/1764] [Common] Add eta, omega and eta' to
 PhysicsConstants.h

- Add eta, omega and etaPrime meson to the PhysicsConstants.h with PDG value and mass by updating make_pdg_header.py and running the script and copying the output to the header file.
---
 Common/Constants/include/CommonConstants/PhysicsConstants.h | 6 ++++++
 Common/Constants/include/CommonConstants/make_pdg_header.py | 3 +++
 2 files changed, 9 insertions(+)

diff --git a/Common/Constants/include/CommonConstants/PhysicsConstants.h b/Common/Constants/include/CommonConstants/PhysicsConstants.h
index f0198f7a7f61d..46aeff98d6033 100644
--- a/Common/Constants/include/CommonConstants/PhysicsConstants.h
+++ b/Common/Constants/include/CommonConstants/PhysicsConstants.h
@@ -31,6 +31,9 @@ namespace o2::constants::physics
 /// \note Follow kCamelCase naming convention
 /// \link https://root.cern/doc/master/TPDGCode_8h.html
 enum Pdg {
+  kEta = 221,
+  kOmega = 223,
+  kEtaPrime = 331,
   kB0 = 511,
   kB0Bar = -511,
   kBPlus = 521,
@@ -93,6 +96,9 @@ enum Pdg {
 };
 
 /// \brief Declarations of masses for additional particles
+constexpr double MassEta = 0.547862;
+constexpr double MassOmega = 0.78266;
+constexpr double MassEtaPrime = 0.95778;
 constexpr double MassB0 = 5.27966;
 constexpr double MassB0Bar = 5.27966;
 constexpr double MassBPlus = 5.27934;
diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index ad24d66e2c3a5..a94450e659acd 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -86,6 +86,9 @@ class PdgROOT(Enum):
 
 # Enum of additional particles
 class Pdg(Enum):
+    kEta = 221
+    kOmega = 223
+    kEtaPrime = 331
     kB0 = 511
     kB0Bar = -511
     kBPlus = 521

From a37fc1c2fb269459b115033f9b0997838ae93421 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 6 Oct 2025 13:29:01 +0200
Subject: [PATCH 0911/1764] DPL: cleanup gsl usage in DataRelayer

---
 Framework/Core/src/DataRelayer.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 092e8340a934a..06e920112649e 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -52,7 +52,7 @@
 #endif
 #include <fmt/format.h>
 #include <fmt/ostream.h>
-#include <gsl/span>
+#include <span>
 #include <string>
 
 using namespace o2::framework::data_matcher;
@@ -191,7 +191,7 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
         continue;
       }
 
-      auto getPartialRecord = [&cache = mCache, numInputTypes = mDistinctRoutesIndex.size()](int li) -> gsl::span<MessageSet const> {
+      auto getPartialRecord = [&cache = mCache, numInputTypes = mDistinctRoutesIndex.size()](int li) -> std::span<MessageSet const> {
         auto offset = li * numInputTypes;
         assert(cache.size() >= offset + numInputTypes);
         auto const start = cache.data() + offset;
@@ -710,7 +710,7 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
   //
   // We use this to bail out early from the check as soon as we find something
   // which we know is not complete.
-  auto getPartialRecord = [&cache, &numInputTypes](int li) -> gsl::span<MessageSet const> {
+  auto getPartialRecord = [&cache, &numInputTypes](int li) -> std::span<MessageSet const> {
     auto offset = li * numInputTypes;
     assert(cache.size() >= offset + numInputTypes);
     auto const start = cache.data() + offset;

From 6d7651421dfebd88f5ca5b043316b9077eb20355 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 6 Oct 2025 13:16:55 +0200
Subject: [PATCH 0912/1764] DPL: refactor resource offering to be a function

---
 Framework/Core/src/ArrowSupport.cxx | 249 ++++++++++++++++------------
 1 file changed, 144 insertions(+), 105 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 94764571840f4..397a6f5113d13 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -13,17 +13,13 @@
 #include "Framework/AODReaderHelpers.h"
 #include "Framework/ArrowContext.h"
 #include "Framework/ArrowTableSlicingCache.h"
-#include "Framework/SliceCache.h"
 #include "Framework/DataProcessor.h"
 #include "Framework/DataProcessingStats.h"
 #include "Framework/ServiceRegistry.h"
 #include "Framework/ConfigContext.h"
-#include "Framework/CommonDataProcessors.h"
 #include "Framework/DataSpecUtils.h"
 #include "Framework/DataSpecViews.h"
 #include "Framework/DeviceSpec.h"
-#include "Framework/EndOfStreamContext.h"
-#include "Framework/Tracing.h"
 #include "Framework/DeviceMetricsInfo.h"
 #include "Framework/DeviceMetricsHelper.h"
 #include "Framework/DeviceInfo.h"
@@ -41,7 +37,6 @@
 #include "CommonMessageBackendsHelpers.h"
 #include <Monitoring/Monitoring.h>
 #include "Headers/DataHeader.h"
-#include "Headers/DataHeaderHelpers.h"
 
 #include <RtypesCore.h>
 #include <fairmq/ProgOptions.h>
@@ -108,6 +103,135 @@ uint64_t calculateAvailableSharedMemory(ServiceRegistryRef registry)
   return registry.get<RateLimitConfig>().maxMemory;
 }
 
+struct ResourceState {
+  int64_t available;
+  int64_t offered = 0;
+  int64_t lastDeviceOffered = 0;
+};
+struct ResourceStats {
+  int64_t enoughCount; /// How many times the resources were enough
+  int64_t lowCount;    /// How many times the resources were not enough
+};
+struct ResourceSpec {
+  char const* name;
+  char const* unit;
+  char const* api;                /// The callback to give resources to a device
+  int64_t maxAvailable;           /// Maximum available quantity for a resource
+  int64_t maxQuantum;             /// Largest offer which can be given
+  int64_t minQuantum;             /// Smallest offer which can be given
+  int64_t metricOfferScaleFactor; /// The scale factor between the metric accounting and offers accounting
+};
+
+auto offerResources(ResourceState& resourceState,
+                    ResourceSpec const& resourceSpec,
+                    ResourceStats& resourceStats,
+                    std::vector<DeviceSpec> const& specs,
+                    std::vector<DeviceInfo> const& infos,
+                    DevicesManager& manager,
+                    int64_t offerConsumedCurrentValue,
+                    int64_t offerExpiredCurrentValue,
+                    int64_t acquiredResourceCurrentValue,
+                    int64_t disposedResourceCurrentValue,
+                    size_t timestamp,
+                    DeviceMetricsInfo& driverMetrics,
+                    std::function<void(DeviceMetricsInfo&, int value, size_t timestamp)>& availableResourceMetric,
+                    std::function<void(DeviceMetricsInfo&, int value, size_t timestamp)>& unusedOfferedResourceMetric,
+                    std::function<void(DeviceMetricsInfo&, int value, size_t timestamp)>& offeredResourceMetric,
+                    void* signpostId) -> void
+{
+  O2_SIGNPOST_ID_FROM_POINTER(sid, rate_limiting, signpostId);
+  /// We loop over the devices, starting from where we stopped last time
+  /// offering the minimum offer to each one
+  int64_t lastCandidate = -1;
+  int64_t possibleOffer = resourceSpec.minQuantum;
+
+  for (size_t di = 0; di < specs.size(); di++) {
+    if (resourceState.available < possibleOffer) {
+      if (resourceStats.lowCount == 0) {
+        O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "not enough",
+                               "We do not have enough %{public}s (%llu %{public}s) to offer %llu %{public}s. Total offerings %{bytes}llu %{string}s.",
+                               resourceSpec.name, resourceState.available, resourceSpec.unit,
+                               possibleOffer, resourceSpec.unit,
+                               resourceState.offered, resourceSpec.unit);
+      }
+      resourceStats.lowCount++;
+      resourceStats.enoughCount = 0;
+      break;
+    } else {
+      if (resourceStats.enoughCount == 0) {
+        O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "enough",
+                               "We are back in a state where we enough %{public}s: %llu %{public}s",
+                               resourceSpec.name,
+                               resourceState.available,
+                               resourceSpec.unit);
+      }
+      resourceStats.lowCount = 0;
+      resourceStats.enoughCount++;
+    }
+    size_t candidate = (resourceState.lastDeviceOffered + di) % specs.size();
+
+    auto& info = infos[candidate];
+    // Do not bother for inactive devices
+    // FIXME: there is probably a race condition if the device died and we did not
+    //        took notice yet...
+    if (info.active == false || info.readyToQuit) {
+      O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                             "Device %s is inactive not offering %{public}s to it.",
+                             specs[candidate].name.c_str(), resourceSpec.name);
+      continue;
+    }
+    if (specs[candidate].name != "internal-dpl-aod-reader") {
+      O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                             "Device %s is not a reader. Not offering %{public}s to it.",
+                             specs[candidate].name.c_str(),
+                             resourceSpec.name);
+      continue;
+    }
+    possibleOffer = std::min(resourceSpec.maxQuantum, resourceState.available);
+    O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                           "Offering %llu %{public}s out of %llu to %{public}s",
+                           possibleOffer, resourceSpec.unit, resourceState.available, specs[candidate].id.c_str());
+    manager.queueMessage(specs[candidate].id.c_str(), fmt::format(fmt::runtime(resourceSpec.api), possibleOffer).data());
+    resourceState.available -= possibleOffer;
+    resourceState.offered += possibleOffer;
+    lastCandidate = candidate;
+  }
+  // We had at least a valid candidate, so
+  // next time we offer to the next device.
+  if (lastCandidate >= 0) {
+    resourceState.lastDeviceOffered = lastCandidate + 1;
+  }
+
+  // unusedOfferedSharedMemory is the amount of memory which was offered and which we know it was
+  // not used so far. So we need to account for the amount which got actually read (readerBytesCreated)
+  // and the amount which we know was given back.
+  static int64_t lastShmOfferConsumed = 0;
+  static int64_t lastUnusedOfferedMemory = 0;
+  if (offerConsumedCurrentValue != lastShmOfferConsumed) {
+    O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                           "Offer consumed so far %llu", offerConsumedCurrentValue);
+    lastShmOfferConsumed = offerConsumedCurrentValue;
+  }
+  int unusedOfferedMemory = (resourceState.offered - (offerExpiredCurrentValue + offerConsumedCurrentValue) / resourceSpec.metricOfferScaleFactor);
+  if (lastUnusedOfferedMemory != unusedOfferedMemory) {
+    O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
+                           "unusedOfferedMemory:%{bytes}d = offered:%{bytes}llu - (expired:%{bytes}llu + consumed:%{bytes}llu) / %lli",
+                           unusedOfferedMemory, resourceState.offered,
+                           offerExpiredCurrentValue / resourceSpec.metricOfferScaleFactor,
+                           offerConsumedCurrentValue / resourceSpec.metricOfferScaleFactor,
+                           resourceSpec.metricOfferScaleFactor);
+    lastUnusedOfferedMemory = unusedOfferedMemory;
+  }
+  // availableSharedMemory is the amount of memory which we know is available to be offered.
+  // We subtract the amount which we know was already offered but it's unused and we then balance how
+  // much was created with how much was destroyed.
+  resourceState.available = resourceSpec.maxAvailable + ((disposedResourceCurrentValue - acquiredResourceCurrentValue) / resourceSpec.metricOfferScaleFactor) - unusedOfferedMemory;
+  availableResourceMetric(driverMetrics, resourceState.available, timestamp);
+  unusedOfferedResourceMetric(driverMetrics, unusedOfferedMemory, timestamp);
+
+  offeredResourceMetric(driverMetrics, resourceState.offered, timestamp);
+};
+
 o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
 {
   using o2::monitoring::Metric;
@@ -138,7 +262,6 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        auto &allDeviceMetrics = sm.deviceMetricsInfos;
                        auto &specs = sm.deviceSpecs;
                        auto &infos = sm.deviceInfos;
-                       O2_SIGNPOST_ID_FROM_POINTER(sid, rate_limiting, &sm);
 
                        static auto stateMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "rate-limit-state");
                        static auto totalBytesCreatedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-arrow-bytes-created");
@@ -288,112 +411,28 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        if (maxTimeframes && (totalTimeframesRead - totalTimeframesConsumed) > maxTimeframes) {
                          return;
                        }
-                       struct ResourceState {
-                          int64_t available;
-                          int64_t offered = 0;
-                          int64_t lastDeviceOffered = 0;
-                       };
-                       struct ResourceStats {
-                          int64_t enoughCount;
-                          int64_t lowCount;
-                       };
-                       struct ResourceSpec{
-                          int64_t maxAvailable;
-                          int64_t maxQuantum;
-                          int64_t minQuantum;
-                       };
-                       static const ResourceSpec resourceSpec{
+                       static const ResourceSpec shmResourceSpec{
+                         .name = "shared memory",
+                         .unit = "MB",
+                         .api = "/shm-offer {}",
                          .maxAvailable = (int64_t)calculateAvailableSharedMemory(registry),
                          .maxQuantum = 100,
                          .minQuantum = 50,
+                         .metricOfferScaleFactor = 1000000,
                        };
-                       static ResourceState resourceState{
-                         .available = resourceSpec.maxAvailable,
+                       static ResourceState shmResourceState{
+                         .available = shmResourceSpec.maxAvailable,
                        };
-                       static ResourceStats resourceStats{
-                         .enoughCount = resourceState.available - resourceSpec.minQuantum > 0 ? 1 : 0,
-                         .lowCount = resourceState.available - resourceSpec.minQuantum > 0 ? 0 : 1
+                       static ResourceStats shmResourceStats{
+                         .enoughCount = shmResourceState.available - shmResourceSpec.minQuantum > 0 ? 1 : 0,
+                         .lowCount = shmResourceState.available - shmResourceSpec.minQuantum > 0 ? 0 : 1
                        };
 
-                       /// We loop over the devices, starting from where we stopped last time
-                       /// offering MIN_QUANTUM_SHARED_MEMORY of shared memory to each reader.
-                       int64_t lastCandidate = -1;
-                       int64_t possibleOffer = resourceSpec.minQuantum;
-
-                       for (size_t di = 0; di < specs.size(); di++) {
-                         if (resourceState.available < possibleOffer) {
-                           if (resourceStats.lowCount == 0) {
-                             O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "not enough",
-                                                    "We do not have enough shared memory (%{bytes}llu MB) to offer %{bytes}llu MB. Total offerings %{bytes}llu",
-                                                     resourceState.available, possibleOffer, resourceState.offered);
-                           }
-                           resourceStats.lowCount++;
-                           resourceStats.enoughCount = 0;
-                           break;
-                         } else {
-                           if (resourceStats.enoughCount == 0) {
-                             O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "enough",
-                                                    "We are back in a state where we enough shared memory: %{bytes}llu MB", resourceState.available);
-                           }
-                           resourceStats.lowCount = 0;
-                           resourceStats.enoughCount++;
-                         }
-                         size_t candidate = (resourceState.lastDeviceOffered + di) % specs.size();
-
-                         auto& info = infos[candidate];
-                         // Do not bother for inactive devices
-                         // FIXME: there is probably a race condition if the device died and we did not
-                         //        took notice yet...
-                         if (info.active == false || info.readyToQuit) {
-                           O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
-                                                  "Device %s is inactive not offering memory to it.", specs[candidate].name.c_str());
-                           continue;
-                         }
-                         if (specs[candidate].name != "internal-dpl-aod-reader") {
-                           O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
-                                                  "Device %s is not a reader. Not offering memory to it.", specs[candidate].name.c_str());
-                           continue;
-                         }
-                         possibleOffer = std::min(resourceSpec.maxQuantum, resourceState.available);
-                         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
-                                                "Offering %{bytes}llu MB out of %{bytes}llu to %{public}s",
-                                                possibleOffer, resourceState.available, specs[candidate].id.c_str());
-                         manager.queueMessage(specs[candidate].id.c_str(), fmt::format("/shm-offer {}", possibleOffer).data());
-                         resourceState.available -= possibleOffer;
-                         resourceState.offered += possibleOffer;
-                         lastCandidate = candidate;
-                       }
-                       // We had at least a valid candidate, so
-                       // next time we offer to the next device.
-                       if (lastCandidate >= 0) {
-                         resourceState.lastDeviceOffered = lastCandidate + 1;
-                       }
-
-                       // unusedOfferedSharedMemory is the amount of memory which was offered and which we know it was
-                       // not used so far. So we need to account for the amount which got actually read (readerBytesCreated)
-                       // and the amount which we know was given back.
-                       static int64_t lastShmOfferConsumed = 0;
-                       static int64_t lastUnusedOfferedMemory = 0;
-                       if (shmOfferBytesConsumed != lastShmOfferConsumed) {
-                         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
-                                                "Offer consumed so far %{bytes}llu", shmOfferBytesConsumed);
-                         lastShmOfferConsumed = shmOfferBytesConsumed;
-                       }
-                       int unusedOfferedMemory = (resourceState.offered - (totalBytesExpired + shmOfferBytesConsumed) / 1000000);
-                       if (lastUnusedOfferedMemory != unusedOfferedMemory) {
-                         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
-                                                "unusedOfferedMemory:%{bytes}d = offered:%{bytes}llu - (expired:%{bytes}llu + consumed:%{bytes}llu) / 1000000",
-                                                 unusedOfferedMemory, resourceState.offered, totalBytesExpired / 1000000, shmOfferBytesConsumed / 1000000);
-                         lastUnusedOfferedMemory = unusedOfferedMemory;
-                       }
-                       // availableSharedMemory is the amount of memory which we know is available to be offered.
-                       // We subtract the amount which we know was already offered but it's unused and we then balance how
-                       // much was created with how much was destroyed.
-                       resourceState.available = resourceSpec.maxAvailable + ((totalBytesDestroyed - totalBytesCreated) / 1000000) - unusedOfferedMemory;
-                       availableSharedMemoryMetric(driverMetrics, resourceState.available, timestamp);
-                       unusedOfferedSharedMemoryMetric(driverMetrics, unusedOfferedMemory, timestamp);
-
-                       offeredSharedMemoryMetric(driverMetrics, resourceState.offered, timestamp); },
+                       offerResources(shmResourceState, shmResourceSpec, shmResourceStats,
+                                      specs, infos, manager, shmOfferBytesConsumed, totalBytesExpired,
+                                      totalBytesCreated, totalBytesDestroyed, timestamp, driverMetrics,
+                                      availableSharedMemoryMetric, unusedOfferedSharedMemoryMetric, offeredSharedMemoryMetric,
+                                      (void*)&sm); },
     .postDispatching = [](ProcessingContext& ctx, void* service) {
                        using DataHeader = o2::header::DataHeader;
                        auto* arrow = reinterpret_cast<ArrowContext*>(service);

From ac31e611820c290673a096f4f84a4bebbc6c8916 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 22 Sep 2025 13:35:46 +0200
Subject: [PATCH 0913/1764] ITS3: add some services material and update MatLUT
 macro

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS3/base/include/ITS3Base/SpecsV2.h      |  21 ++-
 .../ITS3/macros/test/buildMatBudLUT.C         | 124 +++++++++---------
 .../DescriptorInnerBarrelITS3.h               |   7 +-
 .../src/DescriptorInnerBarrelITS3.cxx         |   3 -
 .../ITS3/simulation/src/ITS3Layer.cxx         |   2 +-
 .../ITS3/simulation/src/ITS3Services.cxx      |  21 ++-
 6 files changed, 99 insertions(+), 79 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
index cb6af1dcfc5b7..6626650359dd3 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
@@ -28,9 +28,9 @@
 // color: for visulisation
 namespace o2::its3::constants
 {
-constexpr double cm{1e+2}; // This is the default unit of TGeo so we use this as scale
-constexpr double mu{1e-6 * cm};
-constexpr double mm{1e-3 * cm};
+constexpr double cm{1.0}; // This is the default unit of TGeo so we use this as scale
+constexpr double mu{1e-4 * cm};
+constexpr double mm{1e-1 * cm};
 namespace pixelarray
 {
 constexpr double width{9.197 * mm};
@@ -108,7 +108,8 @@ constexpr double HringLength{6.0 * mm};                                    // fr
 constexpr double edgeBetwChipAndFoam{1.0 * mm};                            // from blueprint but not used cause forms are already overlapping
 constexpr double gapBetwHringsLongerons{0.05 * mm};                        // from blueprint
 constexpr std::array<int, 3> nHoles{11, 11, 11};                           // how many holes for each layer?
-constexpr std::array<double, 3> radiusHoles{1.0 * mm, 1.0 * mm, 2.0 * mm}; // what is the radius of the holes for each layer?
+constexpr std::array<double, 3> radiusHoles{1.0 * mm, 1.0 * mm, 2.0 * mm}; // TODO what is the radius of the holes for each layer?
+constexpr double thicknessOuterFoam{7 * mm};                               // TODO: lack of carbon foam radius for layer 2, use 0.7 cm as a temporary value
 constexpr EColor color{kGray};
 } // namespace carbonfoam
 namespace metalstack
@@ -212,6 +213,18 @@ inline bool isDetITS3(T detID)
 }
 
 } // namespace detID
+
+// services
+namespace services
+{
+// FIXME these value are hallucinated since this not yet defined
+constexpr double thickness{2.2 * mm};                                         // thickness of structure
+constexpr double radiusInner{radiiOuter[2] + carbonfoam::thicknessOuterFoam}; // inner radius of services
+constexpr double radiusOuter{radiusInner + thickness};                        // outer radius of services
+constexpr double length{20 * cm};                                             // length
+constexpr EColor color{kBlue};
+} // namespace services
+
 } // namespace o2::its3::constants
 
 #endif
diff --git a/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C b/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
index bfa2f3bede70d..6341338835b51 100644
--- a/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
+++ b/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
@@ -18,6 +18,7 @@
 #include "DetectorsBase/GeometryManager.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
 #include "ITS3Simulation/DescriptorInnerBarrelITS3.h"
+#include "ITS3Base/SpecsV2.h"
 #include "CommonUtils/NameConf.h"
 #include <TFile.h>
 #include <TSystem.h>
@@ -30,7 +31,7 @@ o2::base::MatLayerCylSet mbLUT;
 
 bool testMBLUT(const std::string& lutFile = "matbud.root");
 
-bool buildMatBudLUT(int nTst = 30, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomName = "");
+bool buildMatBudLUT(int nTst = 60, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomName = "");
 
 struct LrData {
   float rMin = 0.f;
@@ -50,7 +51,7 @@ bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::
   auto geomName = o2::base::NameConf::getGeomFileName(geomNameInput);
   if (gSystem->AccessPathName(geomName.c_str())) { // if needed, create geometry
     std::cout << geomName << " does not exist. Will create it\n";
-    gSystem->Exec("$O2_ROOT/bin/o2-sim -n 0");
+    gSystem->Exec("$O2_ROOT/bin/o2-sim -n 0 --detectorList ALICE2.1");
   }
   o2::base::GeometryManager::loadGeometry(geomNameInput);
   configLayers();
@@ -62,7 +63,7 @@ bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::
   }
   for (int i = 0; i < maxLr; i++) {
     auto& l = lrData[i];
-    printf("L:%3d %6.2f<R<%6.2f ZH=%5.1f | dz = %6.2f drph = %6.2f\n", i, l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
+    printf("L:%3d %6.4f<R<%6.4f ZH=%5.4f | dz = %6.4f drph = %6.4f\n", i, l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
     mbLUT.addLayer(l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
   }
 
@@ -185,87 +186,78 @@ void configLayers()
   const float kToler = 1e-3; //
   float drStep = 0.f, zSpanH = 0.f, zBin = 0.f, rphiBin = 0.f, phiBin = 0.f;
 
-  o2::itsmft::ChipMappingITS mp;
-  int nStave = 0;
-  //                           rMin    rMax   zHalf
-  lrData.emplace_back(0.0f, 1.65f, 30.f);
+  // Vacuum inside beam pipe
+  lrData.emplace_back(0.0f, 1.6f, 30.f);
 
   // beam pipe
-  lrData.emplace_back(lrData.back().rMax, 1.8f, 30.f);
+  lrData.emplace_back(lrData.back().rMax, 1.65f, 30.f);
 
   //===================================================================================
   // ITS3 Inner Barrel
-  drStep = 0.2;
+  drStep = 0.1;
   zSpanH = 20.;
-  rphiBin = 0.2; // 0.1
-  zBin = 0.5;
-  float drStepChip = 0.054;       // gap and chip width
-  float drStepChip4Layer = 0.074; // gap and chip width
+  rphiBin = 0.1;
+  zBin = 0.1;
 
-  // Layer 1
-  lrData.emplace_back(LrData(1.8f, 1.8f + drStepChip, zSpanH, zBin, rphiBin));
-  // Air
-  do {
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 2.4f - drStep + kToler);
-  lrData.emplace_back(LrData(lrData.back().rMax, 2.4f, zSpanH, zBin, rphiBin));
+  //  air and sensitive layers
+  for (int iLayer{0}; iLayer < (int)o2::its3::constants::nLayers; ++iLayer) {
+    lrData.emplace_back(lrData.back().rMax, o2::its3::constants::radiiInner[iLayer], zSpanH, zBin, rphiBin);
+    lrData.emplace_back(lrData.back().rMax, o2::its3::constants::radiiOuter[iLayer], zSpanH, zBin, rphiBin);
+  }
 
-  // Layer 2
-  lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStepChip, zSpanH, zBin, rphiBin));
-  // Air
-  do {
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 3.0f - drStep + kToler);
-  lrData.emplace_back(LrData(lrData.back().rMax, 3.0f, zSpanH, zBin, rphiBin));
+  rphiBin = 0.1;
+  zBin = 0.5;
 
-  // Layer 3
-  lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStepChip, zSpanH, zBin, rphiBin));
+  // services
+  lrData.emplace_back(lrData.back().rMax, o2::its3::constants::services::radiusOuter, zSpanH, zBin, rphiBin);
 
   //===================================================================================
   // air space between Inner and Middle Barrels
+  int nStave = 0;
   zSpanH = 40.;
   zBin = 5.;
   rphiBin = 2.;
-  lrData.emplace_back(LrData(lrData.back().rMax, 19.0, zSpanH, zBin, rphiBin));
+  lrData.emplace_back(lrData.back().rMax, 19.0, zSpanH, zBin, rphiBin);
 
   //===================================================================================
   // ITS Middle Barrel
+  o2::itsmft::ChipMappingITS mp;
   nStave = mp.getNStavesOnLr(3); // Lr 3
   zSpanH = 55.;
   zBin = 0.5;
-  drStep = 0.2;
+  drStep = 0.3;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 20.5 + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 21.4 - kToler);
 
   drStep = 0.5;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 24. + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 23.4 - kToler);
 
   nStave = mp.getNStavesOnLr(3); // Lr 4
   drStep = 0.2;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 25.6 + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 26.2 - kToler);
   drStep = 0.5;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 29. + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 29. - kToler);
 
   //===================================================================================
 
   // air space between Middle and Outer Barrels
   zSpanH = 80.f;
-  lrData.emplace_back(LrData(lrData.back().rMax, 33.5, zSpanH));
+  lrData.emplace_back(lrData.back().rMax, 33.5, zSpanH);
 
   //===================================================================================
   // ITS Outer barrel
@@ -276,54 +268,58 @@ void configLayers()
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 36. + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 36. - kToler);
 
   drStep = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 38.5 + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 38.5 - kToler);
 
   nStave = mp.getNStavesOnLr(6); // Lr 6
   drStep = 0.25;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 41. + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 41. - kToler);
 
   drStep = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 44. + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 44. - kToler);
 
   //===================================================================================
 
   zSpanH = 100.f;
   zBin = 5.;
-  lrData.emplace_back(LrData(lrData.back().rMax, 47., zSpanH, zBin));
+  lrData.emplace_back(lrData.back().rMax, 44.8, zSpanH, zBin);
+  lrData.emplace_back(lrData.back().rMax, 46.2, zSpanH, zBin);
+  lrData.emplace_back(lrData.back().rMax, 47.0, zSpanH, zBin);
 
   drStep = 2.;
   zBin = 5.;
   rphiBin = 2.;
   do {
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 53. + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 55. - kToler);
 
   zSpanH = 120.f;
-  lrData.emplace_back(LrData(lrData.back().rMax, 56.5, zSpanH));
+  lrData.emplace_back(lrData.back().rMax, 56.5, zSpanH);
+  lrData.emplace_back(lrData.back().rMax, 60.5, zSpanH);
+  lrData.emplace_back(lrData.back().rMax, 61.5, zSpanH);
 
   zSpanH = 150.f;
-  drStep = 4.;
+  drStep = 3.5;
   zBin = 15.;
   rphiBin = 10;
   do {
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
-  } while (lrData.back().rMax < 68.5 + kToler);
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
+  } while (lrData.back().rMax < 68.5 - kToler);
 
   zSpanH = 250.f;
   zBin = 25.;
@@ -331,7 +327,7 @@ void configLayers()
   {
     auto rmean = (lrData.back().rMax + 76) / 2.;
     rphiBin = rmean * TMath::Pi() * 2 / (NSect * 2);
-    lrData.emplace_back(LrData(lrData.back().rMax, 76, zSpanH, zBin, rphiBin));
+    lrData.emplace_back(lrData.back().rMax, 76, zSpanH, zBin, rphiBin);
   }
   // TPC inner vessel
   // up to r = 78.5
@@ -340,7 +336,7 @@ void configLayers()
   {
     auto rmean = (lrData.back().rMax + 78.5) / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (NSect * 12);
-    lrData.emplace_back(LrData(lrData.back().rMax, 78.5, zSpanH, zBin, rphiBin));
+    lrData.emplace_back(lrData.back().rMax, 78.8, zSpanH, zBin, rphiBin);
   }
   //
   zSpanH = 250.f;
@@ -348,12 +344,12 @@ void configLayers()
   {
     auto rmean = (lrData.back().rMax + 78.5) / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (NSect * 12);
-    lrData.emplace_back(LrData(lrData.back().rMax, 84.5, zSpanH, zBin, rphiBin));
+    lrData.emplace_back(lrData.back().rMax, 84.5, zSpanH, zBin, rphiBin);
   }
 
   // TPC drum
   zSpanH = 250.f;
-  lrData.emplace_back(LrData(lrData.back().rMax, 250.0, zSpanH));
+  lrData.emplace_back(lrData.back().rMax, 250.0, zSpanH);
 
   //===============================
 
@@ -361,12 +357,12 @@ void configLayers()
   zSpanH = 247.f; // ignore large lumps of material at |z|>247
   rphiBin = 2.;
   zBin = 3.;
-  lrData.emplace_back(LrData(lrData.back().rMax, 258., zSpanH, zBin, rphiBin));
+  lrData.emplace_back(lrData.back().rMax, 258., zSpanH, zBin, rphiBin);
 
   zSpanH = 247.f; // ignore large lumps of material at |z|>247
   rphiBin = 2.;
   zBin = 999.; // no segmentation in Z
-  lrData.emplace_back(LrData(lrData.back().rMax, 280., zSpanH, zBin, rphiBin));
+  lrData.emplace_back(lrData.back().rMax, 280., zSpanH, zBin, rphiBin);
 
   // TRD
 
@@ -376,7 +372,7 @@ void configLayers()
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (NSect * 12);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 370);
 
   // TOF
@@ -387,7 +383,7 @@ void configLayers()
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (NSect * 12);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 400);
 
   // rest
@@ -398,7 +394,7 @@ void configLayers()
     zSpanH = lrData.back().rMax;
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (NSect * 12);
-    lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
+    lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 500);
 }
 
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
index d1b54f81face4..7a7d2215eb67c 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
@@ -45,9 +45,10 @@ class DescriptorInnerBarrelITS3 : public o2::its::DescriptorInnerBarrel
   int mNumLayers{constants::nLayers};
 
   // wrapper volume properties
-  static constexpr double mWrapperMinRadiusITS3{1.8};
-  static constexpr double mWrapperMaxRadiusITS3{4.};
-  static constexpr double mWrapperZSpanITS3{constants::segment::length + 5.};
+  static constexpr double mTolerance{1e-3};
+  static constexpr double mWrapperMinRadiusITS3{constants::radiiInner[0] - mTolerance};
+  static constexpr double mWrapperMaxRadiusITS3{constants::services::radiusOuter + mTolerance};
+  static constexpr double mWrapperZSpanITS3{constants::services::length + mTolerance};
 
  private:
   std::array<std::unique_ptr<ITS3Layer>, constants::nLayers> mIBLayers;
diff --git a/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx b/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
index 540e1d41f1c62..04f244284d5b6 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 
 #include "ITS3Simulation/DescriptorInnerBarrelITS3.h"
-#include "fairlogger/Logger.h"
 
 using namespace o2::its3;
 
@@ -18,14 +17,12 @@ ClassImp(DescriptorInnerBarrelITS3);
 
 void DescriptorInnerBarrelITS3::createLayer(int iLayer, TGeoVolume* dest)
 {
-  LOGP(debug, "ITS3-IB: Creating Layer {}", iLayer);
   mIBLayers[iLayer] = std::make_unique<ITS3Layer>(iLayer);
   mIBLayers[iLayer]->createLayer(dest);
 }
 
 void DescriptorInnerBarrelITS3::createServices(TGeoVolume* dest)
 {
-  LOGP(debug, "ITS3-IB: Creating Services");
   mServices = std::make_unique<ITS3Services>();
   mServices->createCYSSAssembly(dest);
 }
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx b/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
index 8dc94e339c793..3bf29b17fa1f1 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
@@ -293,7 +293,7 @@ void ITS3Layer::createCarbonForm()
   if (mNLayer < 2) {
     dRadius = constants::radii[mNLayer + 1] - constants::radii[mNLayer] - constants::totalThickness;
   } else {
-    dRadius = 0.7; // TODO: lack of carbon foam radius for layer 2, use 0.7mm as a temporary value
+    dRadius = constants::carbonfoam::thicknessOuterFoam; // TODO: lack of carbon foam radius for layer 2, use 0.7 cm as a temporary value
   }
   double phiSta = edgeBetwChipAndFoam / (0.5 * constants::radii[mNLayer + 1] + constants::radii[mNLayer]) * o2m::Rad2Deg;
   double phiEnd = (constants::nSegments[mNLayer] * constants::segment::width) / constants::radii[mNLayer] * o2m::Rad2Deg - phiSta;
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx b/Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx
index cc2255a2b2085..e5ad6a4a1e034 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx
@@ -13,17 +13,30 @@
 /// \brief Definition of the ITS3Services class
 /// \author Fabrizio Grosa <fgrosa@cern.ch>
 
-#include "ITS3Simulation/ITS3Services.h"
+#include <TGeoManager.h>
+#include <TGeoVolume.h>
+#include <TGeoTube.h>
 
-#include <fairlogger/Logger.h> // for LOG
+#include "ITS3Simulation/ITS3Services.h"
+#include "ITS3Base/SpecsV2.h"
 
 namespace o2::its3
 {
 
 void ITS3Services::createCYSSAssembly(TGeoVolume* motherVolume)
 {
-  // Return the whole assembly
-  LOGP(info, "Creating CYSS Assembly and attaching to {}", motherVolume->GetName());
+  auto cyssVol = new TGeoVolumeAssembly("IBCYSSAssembly");
+  cyssVol->SetVisibility(kTRUE);
+  motherVolume->AddNode(cyssVol, 1., nullptr);
+
+  // Cylinder
+  auto cyssInnerCylSh = new TGeoTubeSeg(constants::services::radiusInner, constants::services::radiusOuter, constants::services::length, 180, 360);
+  auto medPrepreg = gGeoManager->GetMedium("IT3_AS4C200$");
+  auto cyssInnerCylShVol = new TGeoVolume("IBCYSSCylinder", cyssInnerCylSh, medPrepreg);
+  cyssVol->AddNode(cyssInnerCylShVol, 1, new TGeoTranslation(0, 0, 0));
+  cyssVol->AddNode(cyssInnerCylShVol, 2, new TGeoCombiTrans(0, 0, 0, new TGeoRotation("", 180, 0, 0)));
+
+  // TODO Cone
 }
 
 } // namespace o2::its3

From 4cf3f84f7b083ca545a51bfbe146d4eac4139ea7 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 23 Sep 2025 16:18:26 +0200
Subject: [PATCH 0914/1764] ITS3: ensure matrices are cached

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index 8bfc7eedf2d6f..8af893267b510 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -33,6 +33,8 @@ void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
                             const its3::TopologyDictionary* dict)
 {
   auto geom = o2::its::GeometryTGeo::Instance();
+  geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
+
   bool applyMisalignment = false;
   const auto& conf = o2::its::TrackerParamConfig::Instance();
   for (int il = 0; il < geom->getNumberOfLayers(); ++il) {

From 03eba8ea89090ba9f89249ccbad154c20288aaac Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 25 Sep 2025 15:58:33 +0200
Subject: [PATCH 0915/1764] ITS3: remove unnecessary recalculation of
 trackingframe

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/base/include/ITSBase/GeometryTGeo.h     |  3 ---
 Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx  | 13 -------------
 .../ITS3/macros/align/CheckResidualsITS3.C      | 11 +++--------
 .../ITS3/reconstruction/src/IOUtils.cxx         | 17 +++++------------
 4 files changed, 8 insertions(+), 36 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h b/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
index fcdc978fa64f0..934c927ac3059 100644
--- a/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
+++ b/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
@@ -333,9 +333,6 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   /// Sym name of the chip in the given layer/halfbarrel/stave/substave/module
   static const char* composeSymNameChip(int lr, int hba, int sta, int ssta, int mod, int chip, bool isITS3 = false);
 
-  // create matrix for transformation from tracking frame to local one for ITS3
-  const Mat3D getT2LMatrixITS3(int isn, float alpha);
-
   TString getMatrixPath(int index) const;
 
   /// Get the transformation matrix of the SENSOR (not necessary the same as the chip)
diff --git a/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx b/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
index 89b4d63729543..60570b2f204c5 100644
--- a/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
+++ b/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
@@ -899,19 +899,6 @@ TGeoHMatrix& GeometryTGeo::createT2LMatrix(int isn)
   return t2l;
 }
 
-//__________________________________________________________________________
-const o2::math_utils::Transform3D GeometryTGeo::getT2LMatrixITS3(int isn, float alpha)
-{
-  // create for sensor isn the TGeo matrix for Tracking to Local frame transformations with correction for effective thickness
-  static TGeoHMatrix t2l;
-  t2l.Clear();
-  t2l.RotateZ(alpha * RadToDeg()); // rotate in direction of normal to the tangent to the cylinder
-  const TGeoHMatrix& matL2G = getMatrixL2G(isn);
-  const auto& matL2Gi = matL2G.Inverse();
-  t2l.MultiplyLeft(&matL2Gi);
-  return Mat3D(t2l);
-}
-
 //__________________________________________________________________________
 int GeometryTGeo::extractVolumeCopy(const char* name, const char* prefix) const
 {
diff --git a/Detectors/Upgrades/ITS3/macros/align/CheckResidualsITS3.C b/Detectors/Upgrades/ITS3/macros/align/CheckResidualsITS3.C
index 9d352393d6fd9..88b342683ca44 100644
--- a/Detectors/Upgrades/ITS3/macros/align/CheckResidualsITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/align/CheckResidualsITS3.C
@@ -66,16 +66,11 @@ std::optional<Cluster> propagateTo(Track& trk, const o2::itsmft::CompClusterExt&
   ++cTotal;
   auto chipID = clus.getSensorID();
   float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
+  auto isITS3 = o2::its3::constants::detID::isDetITS3(chipID);
   const float alpha = o2::its::GeometryTGeo::Instance()->getSensorRefAlpha(clus.getSensorID());   // alpha for the tracking frame
   const auto locC = o2::its3::ioutils::extractClusterData(clus, pattIt, mDict, sigmaY2, sigmaZ2); // get cluster in sensor local frame with errors
-  Point3D trkC;
-  auto isITS3 = o2::its3::constants::detID::isDetITS3(chipID);
-  if (isITS3) {
-    trkC = o2::its::GeometryTGeo::Instance()->getT2LMatrixITS3(chipID, alpha) ^ (locC); // cluster position in the tracking frame
-  } else {
-    trkC = o2::its::GeometryTGeo::Instance()->getMatrixT2L(chipID) ^ (locC); // cluster position in the tracking frame
-  }
-  const auto gloC = o2::its::GeometryTGeo::Instance()->getMatrixL2G(chipID)(locC); // global cluster position
+  Point3D trkC = o2::its::GeometryTGeo::Instance()->getMatrixT2L(chipID) ^ (locC);                // cluster position in the tracking frame
+  const auto gloC = o2::its::GeometryTGeo::Instance()->getMatrixL2G(chipID)(locC);                // global cluster position
   const auto bz = o2::base::Propagator::Instance()->getNominalBz();
 
   // rotate the parameters to the tracking frame then propagate to the clusters'x
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index 8af893267b510..d7ba4d48dbce4 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -48,8 +48,7 @@ void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
     float sigmaY2, sigmaZ2, sigmaYZ = 0;
     auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2);
     const auto detID = c.getSensorID();
-    auto& cl3d = output.emplace_back(detID,
-                                     (its3::constants::detID::isDetITS3(detID) ? geom->getT2LMatrixITS3(detID, geom->getSensorRefAlpha(detID)) : geom->getMatrixT2L(detID)) ^ locXYZ); // local --> tracking
+    auto& cl3d = output.emplace_back(detID, geom->getMatrixT2L(detID) ^ locXYZ); // local --> tracking
     if (applyMisalignment) {
       auto lrID = geom->getLayer(detID);
       sigmaY2 += conf.sysErrY2[lrID];
@@ -79,7 +78,6 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {
       auto& c = clusters[clusterId];
       auto sensorID = c.getSensorID();
-      auto isITS3 = its3::constants::detID::isDetITS3(sensorID);
       auto layer = geom->getLayer(sensorID);
 
       float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
@@ -90,16 +88,11 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
       // Transformation to the local --> global
       auto gloXYZ = geom->getMatrixL2G(sensorID) * locXYZ;
 
-      // for cylindrical layers we have a different alpha for each cluster, for regular silicon detectors instead a single alpha for the whole sensor
+      // Inverse transformation to the local --> tracking
+      o2::math_utils::Point3D<float> trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;
+
+      // Tracking alpha angle
       float alpha = geom->getSensorRefAlpha(sensorID);
-      o2::math_utils::Point3D<float> trkXYZ;
-      if (isITS3) {
-        // Inverse transformation to the local --> tracking
-        trkXYZ = geom->getT2LMatrixITS3(sensorID, alpha) ^ locXYZ;
-      } else {
-        // Inverse transformation to the local --> tracking
-        trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;
-      }
 
       tf->addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), alpha,
                                       std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},

From 84d83834067869b5408b1b7bd16cb53aa3af6d42 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 2 Oct 2025 09:21:38 +0200
Subject: [PATCH 0916/1764] ITS3: fix longeron length to not clip into Hring

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h | 4 ++--
 Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
index 6626650359dd3..b56bb3fa2bd98 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
@@ -102,9 +102,9 @@ constexpr double lengthSensitive{nRSUs * rsu::length};
 namespace carbonfoam
 {
 // TODO: Waiting for the further information from WP5(Corrado)
-constexpr double longeronsWidth{2.0 * mm};                                 // what is the height of the longerons?
-constexpr double longeronsLength{263 * mm};                                // from blueprint
 constexpr double HringLength{6.0 * mm};                                    // from blueprint
+constexpr double longeronsWidth{2.0 * mm};                                 // what is the height of the longerons?
+constexpr double longeronsLength{segment::length - 2 * HringLength};       // 263mm from blueprint; overrriden to be consitent
 constexpr double edgeBetwChipAndFoam{1.0 * mm};                            // from blueprint but not used cause forms are already overlapping
 constexpr double gapBetwHringsLongerons{0.05 * mm};                        // from blueprint
 constexpr std::array<int, 3> nHoles{11, 11, 11};                           // how many holes for each layer?
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx b/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
index 3bf29b17fa1f1..e0be011096450 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
@@ -312,8 +312,8 @@ void ITS3Layer::createCarbonForm()
   auto zMoveHringA = new TGeoTranslation(0, 0, -constants::segment::lec::length + HringLength / 2. + constants::segment::length - HringLength);
 
   // Longerons are made by same material
-  [[maybe_unused]] auto longeronR = new TGeoTubeSeg(Form("longeronR%d", mNLayer), mRmax, mRmax + dRadius, longeronsLength / 2, phiSta, phiSta + phiLongeronsCover);
-  [[maybe_unused]] auto longeronL = new TGeoTubeSeg(Form("longeronL%d", mNLayer), mRmax, mRmax + dRadius, longeronsLength / 2, phiEnd - phiLongeronsCover, phiEnd);
+  [[maybe_unused]] auto longeronR = new TGeoTubeSeg(Form("longeronR%d", mNLayer), mRmax, mRmax + dRadius, longeronsLength / 2., phiSta, phiSta + phiLongeronsCover);
+  [[maybe_unused]] auto longeronL = new TGeoTubeSeg(Form("longeronL%d", mNLayer), mRmax, mRmax + dRadius, longeronsLength / 2., phiEnd - phiLongeronsCover, phiEnd);
   TString nameLongerons = Form("longeronR%d + longeronL%d", mNLayer, mNLayer);
   auto longerons = new TGeoCompositeShape(nameLongerons);
   auto longeronsVol = new TGeoVolume(Form("longerons%d", mNLayer), longerons, mCarbon);

From 24d15d0410dc9da19bbf04394a56bba13a8eb8fe Mon Sep 17 00:00:00 2001
From: ddobrigk <david.dobrigkeit.chinellato@cern.ch>
Date: Fri, 10 Oct 2025 23:13:12 +0200
Subject: [PATCH 0917/1764] Set default DCA in case of propagate call fail
 (#14729)

* Set default DCA in case of propagate call fail

* Please consider the following formatting changes

* Add missing setter lines for propagateToDCAs

* Please consider the following formatting changes

---------

Co-authored-by: David Dobrigkeit Chinellato <david.dobrigkeit.chinellato.cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../TrackParametrization.h                    |  3 ++
 .../src/TrackParametrization.cxx              |  8 +++++
 .../src/TrackParametrizationWithError.cxx     |  8 +++++
 Detectors/Base/src/Propagator.cxx             | 32 +++++++++++++++++++
 4 files changed, 51 insertions(+)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index 87cd059e0b325..8cb22efd39e38 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -119,6 +119,9 @@ constexpr float MaxPT = 100000.;                  // do not allow pTs exceeding
 constexpr float MinPTInv = 1. / MaxPT;            // do not allow q/pTs less this value (to avoid NANs)
 constexpr float ELoss2EKinThreshInv = 1. / 0.025; // do not allow E.Loss correction step with dE/Ekin above the inverse of this value
 constexpr int MaxELossIter = 50;                  // max number of iteration for the ELoss to account for BB dependence on beta*gamma
+constexpr float DefaultDCA = 999.f;               // default DCA value
+constexpr float DefaultDCACov = 999.f;            // default DCA cov value
+
 // uncomment this to enable correction for BB dependence on beta*gamma via BB derivative
 // #define _BB_NONCONST_CORR_
 
diff --git a/DataFormats/Reconstruction/src/TrackParametrization.cxx b/DataFormats/Reconstruction/src/TrackParametrization.cxx
index 0539278acb20b..7086e4d93cec8 100644
--- a/DataFormats/Reconstruction/src/TrackParametrization.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrization.cxx
@@ -378,6 +378,10 @@ GPUd() bool TrackParametrization<value_T>::propagateParamToDCA(const math_utils:
   // Estimate the impact parameter neglecting the track curvature
   value_t d = gpu::CAMath::Abs(x * snp - y * csp);
   if (d > maxD) {
+    if (dca) { // provide default DCA for failed propag
+      (*dca)[0] = o2::track::DefaultDCA;
+      (*dca)[1] = o2::track::DefaultDCA;
+    }
     return false;
   }
   value_t crv = getCurvature(b);
@@ -399,6 +403,10 @@ GPUd() bool TrackParametrization<value_T>::propagateParamToDCA(const math_utils:
 #else
     LOG(debug) << "failed to propagate to alpha=" << alp << " X=" << xv << " for vertex " << vtx.X() << ' ' << vtx.Y() << ' ' << vtx.Z();
 #endif
+    if (dca) { // provide default DCA for failed propag
+      (*dca)[0] = o2::track::DefaultDCA;
+      (*dca)[1] = o2::track::DefaultDCA;
+    }
     return false;
   }
   *this = tmpT;
diff --git a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
index aee24238f1247..01849bd0c9e8f 100644
--- a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
@@ -227,6 +227,10 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateToDCA(const o2::dat
   // Estimate the impact parameter neglecting the track curvature
   value_t d = gpu::CAMath::Abs(x * snp - y * csp);
   if (d > maxD) {
+    if (dca) { // provide default DCA for failed propag
+      dca->set(o2::track::DefaultDCA, o2::track::DefaultDCA,
+               o2::track::DefaultDCACov, o2::track::DefaultDCACov, o2::track::DefaultDCACov);
+    }
     return false;
   }
   value_t crv = this->getCurvature(b);
@@ -245,6 +249,10 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateToDCA(const o2::dat
 #if !defined(GPUCA_ALIGPUCODE)
     LOG(debug) << "failed to propagate to alpha=" << alp << " X=" << xv << vtx << " | Track is: " << tmpT.asString();
 #endif
+    if (dca) { // provide default DCA for failed propag
+      dca->set(o2::track::DefaultDCA, o2::track::DefaultDCA,
+               o2::track::DefaultDCACov, o2::track::DefaultDCACov, o2::track::DefaultDCACov);
+    }
     return false;
   }
   *this = tmpT;
diff --git a/Detectors/Base/src/Propagator.cxx b/Detectors/Base/src/Propagator.cxx
index b6112cd5ba32e..0763eb48ff474 100644
--- a/Detectors/Base/src/Propagator.cxx
+++ b/Detectors/Base/src/Propagator.cxx
@@ -564,6 +564,10 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCA(const o2::dataformats::Verte
   // Estimate the impact parameter neglecting the track curvature
   value_type d = math_utils::detail::abs<value_type>(x * snp - y * csp);
   if (d > maxD) {
+    if (dca) { // provide default DCA for failed propag
+      dca->set(o2::track::DefaultDCA, o2::track::DefaultDCA,
+               o2::track::DefaultDCACov, o2::track::DefaultDCACov, o2::track::DefaultDCACov);
+    }
     return false;
   }
   value_type crv = track.getCurvature(bZ);
@@ -584,6 +588,10 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCA(const o2::dataformats::Verte
 #elif !defined(GPUCA_NO_FMT)
     LOG(debug) << "failed to propagate to alpha=" << alp << " X=" << xv << vtx;
 #endif
+    if (dca) { // provide default DCA for failed propag
+      dca->set(o2::track::DefaultDCA, o2::track::DefaultDCA,
+               o2::track::DefaultDCACov, o2::track::DefaultDCACov, o2::track::DefaultDCACov);
+    }
     return false;
   }
   track = tmpT;
@@ -613,6 +621,10 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCABxByBz(const o2::dataformats:
   // Estimate the impact parameter neglecting the track curvature
   value_type d = math_utils::detail::abs<value_type>(x * snp - y * csp);
   if (d > maxD) {
+    if (dca) { // provide default DCA for failed propag
+      dca->set(o2::track::DefaultDCA, o2::track::DefaultDCA,
+               o2::track::DefaultDCACov, o2::track::DefaultDCACov, o2::track::DefaultDCACov);
+    }
     return false;
   }
   value_type crv = track.getCurvature(mNominalBz);
@@ -633,6 +645,10 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCABxByBz(const o2::dataformats:
 #elif !defined(GPUCA_NO_FMT)
     LOG(debug) << "failed to propagate to alpha=" << alp << " X=" << xv << vtx;
 #endif
+    if (dca) { // provide default DCA for failed propag
+      dca->set(o2::track::DefaultDCA, o2::track::DefaultDCA,
+               o2::track::DefaultDCACov, o2::track::DefaultDCACov, o2::track::DefaultDCACov);
+    }
     return false;
   }
   track = tmpT;
@@ -662,6 +678,10 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCA(const math_utils::Point3D<va
   // Estimate the impact parameter neglecting the track curvature
   value_type d = math_utils::detail::abs<value_type>(x * snp - y * csp);
   if (d > maxD) {
+    if (dca) { // provide default DCA for failed propag
+      (*dca)[0] = o2::track::DefaultDCA;
+      (*dca)[1] = o2::track::DefaultDCA;
+    }
     return false;
   }
   value_type crv = track.getCurvature(bZ);
@@ -683,6 +703,10 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCA(const math_utils::Point3D<va
 #else
     LOG(debug) << "failed to propagate to alpha=" << alp << " X=" << xv << " for vertex " << vtx.X() << ' ' << vtx.Y() << ' ' << vtx.Z();
 #endif
+    if (dca) { // provide default DCA for failed propag
+      (*dca)[0] = o2::track::DefaultDCA;
+      (*dca)[1] = o2::track::DefaultDCA;
+    }
     return false;
   }
   track = tmpT;
@@ -710,6 +734,10 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCABxByBz(const math_utils::Poin
   // Estimate the impact parameter neglecting the track curvature
   value_type d = math_utils::detail::abs<value_type>(x * snp - y * csp);
   if (d > maxD) {
+    if (dca) { // provide default DCA for failed propag
+      (*dca)[0] = o2::track::DefaultDCA;
+      (*dca)[1] = o2::track::DefaultDCA;
+    }
     return false;
   }
   value_type crv = track.getCurvature(mNominalBz);
@@ -731,6 +759,10 @@ GPUd() bool PropagatorImpl<value_T>::propagateToDCABxByBz(const math_utils::Poin
 #else
     LOG(debug) << "failed to propagate to alpha=" << alp << " X=" << xv << " for vertex " << vtx.X() << ' ' << vtx.Y() << ' ' << vtx.Z();
 #endif
+    if (dca) { // provide default DCA for failed propag
+      (*dca)[0] = o2::track::DefaultDCA;
+      (*dca)[1] = o2::track::DefaultDCA;
+    }
     return false;
   }
   track = tmpT;

From a657810d920d9d040044d2d4367b2378b60c820e Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Mon, 13 Oct 2025 21:14:51 +0200
Subject: [PATCH 0918/1764] ALICE3-TRK: several fixes in the digitization code
 (#14733)

* ALICE3-TRK: deal with ML/OT L4 mixed lenght and shape

* ALICE3-TRK: adjust ML/OT staves length according to the current geometry

* ALICE3-TRK: increase number of steps into silicon to 25. Setting temporarly the threshold to 1 electron

* ALICE3-TRK: fix digits distribution along columns by removing the rescaling of the silicon depth

* ALICE3-TRK: considering the OT half-stave as the smallest elemenent for the digitization in the OT
---
 .../base/include/TRKBase/SegmentationChip.h   | 70 ++++++++++++-------
 .../ALICE3/TRK/base/include/TRKBase/Specs.h   | 19 +++--
 .../include/TRKSimulation/DPLDigitizerParam.h |  6 +-
 .../include/TRKSimulation/DigiParams.h        |  6 +-
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   | 43 ++++--------
 5 files changed, 80 insertions(+), 64 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
index 100af5be1b4d0..e2a60e8a3b576 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
@@ -35,18 +35,18 @@ class SegmentationChip
   // The "detector coordinate system" refers to the hit position in row,col inside the sensor
   // This class provides the transformations from the local and detector coordinate systems
   // The conversion between global and local coordinate systems is operated by the transformation matrices
-  // For the curved VD layers there exist three coordinate systems and one is transient.
+  // For the curved VD layers there exist four coordinate systems.
   // 1. The global (curved) coordinate system. The chip's center of coordinate system is
   //    defined at the the mid-point of the detector.
-  // 2. The local (flat) coordinate system. This is the tube segment projected onto a flat
-  //    surface. In the projection we implicitly assume that the inner and outer
-  //    stretch does not depend on the radius.
-  // 3. The detector coordinate system. Defined by the row and column segmentation
-  //    defined at the upper edge in the flat coord.
+  // 2. The local (curved) coordinate system, centered in 0,0,0.
+  // 3. The local (flat) coordinate system. This is the tube segment projected onto a flat
+  //    surface, centered in the middle of the chip, with the y axis pointing towards the interaction point.
+  //    In the projection we implicitly assume that the inner and outer stretch does not depend on the radius.
+  // 4. The detector coordinate system. Defined by the row and column segmentation.
   // For the flat ML and OT layers, there exist two coordinate systems:
   // 1. The global (flat) coordinate system. The chip's center of coordinate system is
   //    defined at the the mid-point of the detector.
-  // 2. The detector coordinate system. Defined by the row and column segmentation
+  // 2. The detector coordinate system. Defined by the row and column segmentation.
   // TODO: add segmentation for VD disks
 
  public:
@@ -121,15 +121,20 @@ class SegmentationChip
       pitchCol = PitchColMLOT;
       maxWidth = constants::ML::width;
       maxLength = constants::ML::length;
-    } else if (subDetID == 1 && layer >= 4) { // OT
+    } else if (subDetID == 1 && layer == 4) { // ML/OT (mixed layer, length = ML but staggered as OT)
       pitchRow = PitchRowMLOT;
       pitchCol = PitchColMLOT;
-      maxWidth = constants::OT::width;
-      maxLength = constants::OT::length;
+      maxWidth = constants::OT::halfstave::width;
+      maxLength = constants::ML::length;
+    } else if (subDetID == 1 && layer > 4) { // OT
+      pitchRow = PitchRowMLOT;
+      pitchCol = PitchColMLOT;
+      maxWidth = constants::OT::halfstave::width;
+      maxLength = constants::OT::halfstave::length;
     }
     // convert to row/col
-    iRow = static_cast<int>(std::floor((maxWidth / 2 - xRow) / pitchRow));
-    iCol = static_cast<int>(std::floor((zCol + maxLength / 2) / pitchCol));
+    iRow = static_cast<int>(((maxWidth / 2 - xRow) / pitchRow));
+    iCol = static_cast<int>(((zCol + maxLength / 2) / pitchCol));
   };
 
   // Check local coordinates (cm) validity.
@@ -143,9 +148,12 @@ class SegmentationChip
     } else if (subDetID == 1 && layer <= 3) { // ML
       maxWidth = constants::ML::width;
       maxLength = constants::ML::length;
-    } else if (subDetID == 1 && layer >= 4) { // OT
-      maxWidth = constants::OT::width;
-      maxLength = constants::OT::length;
+    } else if (subDetID == 1 && layer == 4) { // ML/OT (mixed layer, length = ML but staggered as OT)
+      maxWidth = constants::OT::halfstave::width;
+      maxLength = constants::ML::length;
+    } else if (subDetID == 1 && layer > 4) { // OT
+      maxWidth = constants::OT::halfstave::width;
+      maxLength = constants::OT::halfstave::length;
     }
     return (-maxWidth / 2 < x && x < maxWidth / 2 && -maxLength / 2 < z && z < maxLength / 2);
   }
@@ -162,9 +170,12 @@ class SegmentationChip
     } else if (subDetID == 1 && layer <= 3) { // ML
       nRows = constants::ML::nRows;
       nCols = constants::ML::nCols;
-    } else if (subDetID == 1 && layer >= 4) { // OT
-      nRows = constants::OT::nRows;
-      nCols = constants::OT::nCols;
+    } else if (subDetID == 1 && layer == 4) { // ML/OT (mixed layer, length = ML but staggered as OT)
+      nRows = constants::OT::halfstave::nRows;
+      nCols = constants::ML::nCols;
+    } else if (subDetID == 1 && layer > 4) { // OT
+      nRows = constants::OT::halfstave::nRows;
+      nCols = constants::OT::halfstave::nCols;
     }
     return (row >= 0 && row < static_cast<float>(nRows) && col >= 0 && col < static_cast<float>(nCols));
   }
@@ -210,9 +221,12 @@ class SegmentationChip
     } else if (subDetID == 1 && layer <= 3) { // ML
       xRow = 0.5 * (constants::ML::width - PitchRowMLOT) - (row * PitchRowMLOT);
       zCol = col * PitchRowMLOT + 0.5 * (PitchRowMLOT - constants::ML::length);
-    } else if (subDetID == 1 && layer >= 4) { // OT
-      xRow = 0.5 * (constants::OT::width - PitchRowMLOT) - (row * PitchRowMLOT);
-      zCol = col * PitchColMLOT + 0.5 * (PitchColMLOT - constants::OT::length);
+    } else if (subDetID == 1 && layer == 4) { // ML/OT (mixed layer, length = ML but staggered as OT)
+      xRow = 0.5 * (constants::OT::halfstave::width - PitchRowMLOT) - (row * PitchRowMLOT);
+      zCol = col * PitchRowMLOT + 0.5 * (PitchRowMLOT - constants::ML::length);
+    } else if (subDetID == 1 && layer > 4) { // OT
+      xRow = 0.5 * (constants::OT::halfstave::width - PitchRowMLOT) - (row * PitchRowMLOT);
+      zCol = col * PitchColMLOT + 0.5 * (PitchColMLOT - constants::OT::halfstave::length);
     }
   }
 
@@ -263,17 +277,25 @@ class SegmentationChip
   }
 
   /// Print segmentation info
-  static const void Print() noexcept
+  static void Print() noexcept
   {
     LOG(info) << "Number of rows:\nVD L0: " << constants::VD::petal::layer::nRows[0]
               << "\nVD L1: " << constants::VD::petal::layer::nRows[1]
               << "\nVD L2: " << constants::VD::petal::layer::nRows[2]
               << "\nML stave: " << constants::ML::nRows
-              << "\nOT stave: " << constants::OT::nRows;
+              << "\nOT half stave: " << constants::OT::halfstave::nRows;
 
     LOG(info) << "Number of cols:\nVD: " << constants::VD::petal::layer::nCols
               << "\nML stave: " << constants::ML::nCols
-              << "\nOT stave: " << constants::OT::nCols;
+              << "\nOT half stave: " << constants::OT::halfstave::nCols;
+
+    LOG(info) << "Pitch rows [cm]:\nVD: " << PitchRowVD
+              << "\nML stave: " << PitchRowMLOT
+              << "\nOT stave: " << PitchRowMLOT;
+
+    LOG(info) << "Pitch cols [cm]:\nVD: " << PitchColVD
+              << "\nML stave: " << PitchColMLOT
+              << "\nOT stave: " << PitchColMLOT;
   }
 };
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index 373e9d972656b..bd95e5207b7ee 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -102,16 +102,25 @@ constexpr int nCols{static_cast<int>(length / chip::pitchZ)};
 
 namespace ML
 {
-constexpr double width{constants::moduleMLOT::width * 1};                            // width of the stave
-constexpr double length{constants::moduleMLOT::length * 10};                         // length of the stave
+constexpr double width{constants::moduleMLOT::width * 1}; // width of the stave
+// constexpr double length{constants::moduleMLOT::length * 10};                         // length of the stave
+constexpr double length{124 * cm};                                                   // length of the stave, hardcoded to fit the implemented geometry
 constexpr int nRows{static_cast<int>(width / constants::moduleMLOT::chip::pitchX)};  // number of rows in the stave
 constexpr int nCols{static_cast<int>(length / constants::moduleMLOT::chip::pitchZ)}; // number of columns in the stave
 } // namespace ML
 
 namespace OT
-{                                                                         //// TODO: add shorter lenght of the stave of L4
-constexpr double width{moduleMLOT::width * 2};                            // width of the stave
-constexpr double length{moduleMLOT::length * 20};                         // length of the stave
+{
+namespace halfstave
+{
+constexpr double width{moduleMLOT::width * 1}; // width of the half stave
+// constexpr double length{moduleMLOT::length * 20};                         // length of the halfstave
+constexpr double length{258 * cm};                                        // length of the halfstave, hardcoded to fit the implemented geometry
+constexpr int nRows{static_cast<int>(width / moduleMLOT::chip::pitchX)};  // number of rows in the halfstave
+constexpr int nCols{static_cast<int>(length / moduleMLOT::chip::pitchZ)}; // number of columns in the halfstave
+} // namespace halfstave
+constexpr double width{halfstave::width * 2};                             // width of the stave
+constexpr double length{halfstave::length};                               // length of the stave
 constexpr int nRows{static_cast<int>(width / moduleMLOT::chip::pitchX)};  // number of rows in the stave
 constexpr int nCols{static_cast<int>(length / moduleMLOT::chip::pitchZ)}; // number of columns in the stave
 } // namespace OT
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
index 584ffaa3aff75..179b666a159d6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
@@ -37,9 +37,9 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
   float strobeQRiseTime0 = 450.;            ///< q @ which strobe rise time is 0
 
   double timeOffset = 0.;                 ///< time offset (in seconds!) to calculate ROFrame from hit time
-  int chargeThreshold = 150;              ///< charge threshold in Nelectrons
-  int minChargeToAccount = 15;            ///< minimum charge contribution to account
-  int nSimSteps = 18;                     ///< number of steps in response simulation
+  int chargeThreshold = 1;                ///< charge threshold in Nelectrons
+  int minChargeToAccount = 1;             ///< minimum charge contribution to account
+  int nSimSteps = 25;                     ///< number of steps in response simulation
   float energyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
 
   float Vbb = 0.0;   ///< back bias absolute value for MFT (in Volt)
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
index 739ac5c9bd617..3a03ab058ec2f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
@@ -109,9 +109,9 @@ class DigiParams
   float mStrobeLength = 0;           ///< length of the strobe in ns (sig. over threshold checked in this window only)
   double mTimeOffset = -2 * infTime; ///< time offset (in seconds!) to calculate ROFrame from hit time
   int mROFrameBiasInBC = 0;          ///< misalignment of the ROF start in BC
-  int mChargeThreshold = 150;        ///< charge threshold in Nelectrons
-  int mMinChargeToAccount = 15;      ///< minimum charge contribution to account
-  int mNSimSteps = 18;               ///< number of steps in response simulation
+  int mChargeThreshold = 1;          ///< charge threshold in Nelectrons
+  int mMinChargeToAccount = 1;       ///< minimum charge contribution to account
+  int mNSimSteps = 25;               ///< number of steps in response simulation
   float mNSimStepsInv = 0;           ///< its inverse
 
   float mEnergyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index cc89f0eff1a54..0c691b03c867e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -62,21 +62,21 @@ void Digitizer::init()
 
   /// setting scale factors to adapt to the APTS response function (adjusting pitch and Y shift)
   // TODO: adjust Y shift when the geometry is improved
-  LOG(debug) << " Depth max: " << mChipSimRespVD->getDepthMax();
-  LOG(debug) << " Depth min: " << mChipSimRespVD->getDepthMin();
+  LOG(info) << " Depth max VD: " << mChipSimRespVD->getDepthMax();
+  LOG(info) << " Depth min VD: " << mChipSimRespVD->getDepthMin();
+
+  LOG(info) << " Depth max MLOT: " << mChipSimRespMLOT->getDepthMax();
+  LOG(info) << " Depth min MLOT: " << mChipSimRespMLOT->getDepthMin();
 
   float thicknessVD = 0.0095; // cm --- hardcoded based on geometry currently present
   float thicknessMLOT = 0.1;  // cm --- hardcoded based on geometry currently present
 
   mSimRespVDScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowVD;
   mSimRespVDScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColVD;
-  mSimRespVDScaleDepth = o2::trk::constants::apts::thickness / (thicknessVD); /// introducing this scaling factor because the silicon thickness for the moment is 1 mm -> rescale to 45 um which is the depth of the APTS response
-  // mSimRespVDShift = mChipSimRespVD->getDepthMax() - thicknessVD * mSimRespVDScaleDepth / 2.f; // the shift should be done considering the rescaling done to adapt to the wrong silicon thickness. TODO: remove the scaling factor for the depth when the silicon thickness match the simulated response
-  mSimRespVDShift = mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -45. Must add 10 um (= max depth) to match the APTS response.
+  mSimRespVDShift = -mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -45. Must add 10 um (= max depth) to match the APTS response.
   mSimRespMLOTScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowMLOT;
   mSimRespMLOTScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColMLOT;
-  mSimRespMLOTScaleDepth = o2::trk::constants::apts::thickness / (thicknessMLOT);                     /// introducing this scaling factor because the silicon thickness for the moment is 1 mm -> rescale to 45 um which is the depth of the APTS response
-  mSimRespMLOTShift = mChipSimRespMLOT->getDepthMax() - thicknessMLOT * mSimRespMLOTScaleDepth / 2.f; // the shift should be done considering the rescaling done to adapt to the wrong silicon thickness. TODO: remove the scaling factor for the depth when the silicon thickness match the simulated response
+  mSimRespMLOTShift = mChipSimRespMLOT->getDepthMax() - thicknessMLOT / 2.f; // the shift should be done considering the rescaling done to adapt to the wrong silicon thickness. TODO: remove the scaling factor for the depth when the silicon thickness match the simulated response
   mSimRespOrientation = false;
 
   // importing the parameters from DPLDigitizerParam.h
@@ -84,7 +84,7 @@ void Digitizer::init()
 
   LOGP(info, "TRK Digitizer is initialised.");
   mParams.print();
-  LOGP(info, "VD shift = {}  ; ML/OT shift = {} = {} - {}", mSimRespVDShift, mSimRespMLOTShift, mChipSimRespMLOT->getDepthMax(), thicknessMLOT * mSimRespMLOTScaleDepth / 2.f);
+  LOGP(info, "VD shift = {}  ; ML/OT shift = {} = {} - {}", mSimRespVDShift, mSimRespMLOTShift, mChipSimRespMLOT->getDepthMax(), thicknessMLOT / 2.f);
   LOGP(info, "VD pixel scale on x = {} ; z = {}", mSimRespVDScaleX, mSimRespVDScaleZ);
   LOGP(info, "ML/OT pixel scale on x = {} ; z = {}", mSimRespMLOTScaleX, mSimRespMLOTScaleZ);
   LOGP(info, "Response orientation: {}", mSimRespOrientation ? "flipped" : "normal");
@@ -115,8 +115,8 @@ void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
             << " cont.mode: " << isContinuous()
             << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
 
-  std::cout << "Printing segmentation info: " << std::endl;
-  SegmentationChip::Print();
+  // std::cout << "Printing segmentation info: " << std::endl;
+  // SegmentationChip::Print();
 
   // // is there something to flush ?
   if (mNewROFrame > mROFrameMin) {
@@ -335,13 +335,9 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
 
   //// adapting the depth (Y) of the chip to the APTS response maximum depth
   LOG(debug) << "local original: startPos = " << xyzLocS << ", endPos = " << xyzLocE << std::endl;
-  if (subDetID == 0) {
-    xyzLocS.SetY(xyzLocS.Y() * mSimRespVDScaleDepth);
-    xyzLocE.SetY(xyzLocE.Y() * mSimRespVDScaleDepth);
-  } else {
-    xyzLocS.SetY(xyzLocS.Y() * mSimRespMLOTScaleDepth);
-    xyzLocE.SetY(xyzLocE.Y() * mSimRespMLOTScaleDepth);
-  }
+  xyzLocS.SetY(xyzLocS.Y());
+  xyzLocE.SetY(xyzLocE.Y());
+
   LOG(debug) << "rescaled Y: startPos = " << xyzLocS << ", endPos = " << xyzLocE << std::endl;
 
   math_utils::Vector3D<float> step(xyzLocE);
@@ -449,17 +445,6 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
       rspmat = resp->getResponse(mSimRespMLOTScaleX * (xyzLocS.X() - cRowPix), mSimRespMLOTScaleZ * (xyzLocS.Z() - cColPix), xyzLocS.Y(), flipRow, flipCol, rowMax, colMax);
     }
 
-    float tempPitchX = 0, tempPitchZ = 0;
-    if (subDetID == 0) {
-      tempPitchX = Segmentation::PitchRowVD;
-      tempPitchZ = Segmentation::PitchColVD;
-    } else {
-      tempPitchX = Segmentation::PitchRowMLOT;
-      tempPitchZ = Segmentation::PitchColMLOT;
-    }
-    LOG(debug) << "X and Z inside pixel at start = " << (xyzLocS.X() - cRowPix) << " , " << (xyzLocS.Z() - cColPix) << ", rescaled: " << mSimRespMLOTScaleX * (xyzLocS.X() - cRowPix) << " , " << mSimRespMLOTScaleZ * (xyzLocS.Z() - cColPix);
-    LOG(debug) << "Hit inside pitch? X: " << ((xyzLocS.X() - cRowPix) < tempPitchX) << "  Z: " << ((xyzLocS.Z() - cColPix) < tempPitchZ);
-
     xyzLocS += step;
 
     if (rspmat == nullptr) {
@@ -479,7 +464,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
         if (colDest < 0 || colDest >= colSpan) {
           continue;
         }
-        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, mSimRespOrientation ? !flipRow : flipRow, flipCol);
+        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, mSimRespOrientation ? !flipRow : flipRow, !flipCol);
       }
     }
   }

From fe67204fae9d83e246dec5d6e2bb3c49f9bf9f1a Mon Sep 17 00:00:00 2001
From: vikasssinghal <54980686+vikasssinghal@users.noreply.github.com>
Date: Wed, 15 Oct 2025 15:02:24 +0530
Subject: [PATCH 0919/1764] GPU: Wshadow compiler directive not needed in HIP
 Includes System (#14738)

* TODO: Wshadow compiler directive not needed

* Removed all three lines push, pragma diagnostic, pop
---
 GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
index 0228f993aaee3..389c79c0e4eb9 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPIncludesSystem.h
@@ -22,11 +22,8 @@
 #include <hip/hip_runtime.h>
 #include <hip/hip_ext.h>
 #include <hipcub/hipcub.hpp>
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow" // FIXME: Is this still needed?
 #include <thrust/sort.h>
 #include <thrust/execution_policy.h>
 #include <thrust/device_ptr.h>
-#pragma GCC diagnostic pop
 
 #endif // O2_GPU_RECONSTRUCTIONHIPINCLUDESSYSTEM_H

From a35cf1e514a3fc982a34493d190faae301d0bf79 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 15 Oct 2025 12:48:42 +0200
Subject: [PATCH 0920/1764] Fix precalculated sector cos/sin values in TOF Geo

---
 Detectors/TOF/base/src/Geo.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/TOF/base/src/Geo.cxx b/Detectors/TOF/base/src/Geo.cxx
index 08cda68c6d12e..7df4c3a3537e1 100644
--- a/Detectors/TOF/base/src/Geo.cxx
+++ b/Detectors/TOF/base/src/Geo.cxx
@@ -1049,8 +1049,8 @@ void Geo::rotateToSector(Float_t* xyz, Int_t isector)
 void Geo::alignedToNominalSector(Float_t* xyz, Int_t isector)
 {
   // rotate from the aligned sector frame coordinates to nominal ones (i.e. alpha=20*sector+10 deg.)
-  constexpr float CS[18] = {.848077e-01, 8.660254e-01, 6.427876e-01, 3.420202e-01, -4.371139e-08, -3.420201e-01, -6.427876e-01, -8.660254e-01, -9.848077e-01, -9.848077e-01, -8.660254e-01, -6.427875e-01, -3.420201e-01, 1.192488e-08, 3.420201e-01, 6.427875e-01, 8.660253e-01, 9.848078e-01};
-  constexpr float SN[18] = {1.736482e-01, 5.000000e-01, 7.660444e-01, 9.396926e-01, 1.000000e+00, 9.396926e-01, 7.660444e-01, 5.000001e-01, 1.736483e-01, -1.736482e-01, -5.000000e-01, -7.660446e-01, -9.396927e-01, -1.000000e+00, -9.396926e-01, -7.660445e-01, -5.000002e-01, -1.736480e-01};
+  constexpr float CS[18] = {+9.848078e-01, +8.660254e-01, +6.427876e-01, +3.420201e-01, +6.123234e-17, -3.420201e-01, -6.427876e-01, -8.660254e-01, -9.848078e-01, -9.848078e-01, -8.660254e-01, -6.427876e-01, -3.420201e-01, -1.836970e-16, +3.420201e-01, +6.427876e-01, +8.660254e-01, +9.848078e-01};
+  constexpr float SN[18] = {+1.736482e-01, +5.000000e-01, +7.660444e-01, +9.396926e-01, +1.000000e+00, +9.396926e-01, +7.660444e-01, +5.000000e-01, +1.736482e-01, -1.736482e-01, -5.000000e-01, -7.660444e-01, -9.396926e-01, -1.000000e+00, -9.396926e-01, -7.660444e-01, -5.000000e-01, -1.736482e-01};
   Float_t xyzDummy[3] = {xyz[1], xyz[2], xyz[0]};      // go to twisted coordinates...
   o2::tof::Geo::antiRotateToSector(xyzDummy, isector); // lab coordinates
   xyz[0] = xyzDummy[0] * CS[isector] + xyzDummy[1] * SN[isector];

From 14c234e5826184994a192b2261959373d7474faa Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 15 Oct 2025 13:35:18 +0200
Subject: [PATCH 0921/1764] fix methods is/setInNominalSector of TOF cluster

---
 .../Detectors/TOF/include/DataFormatsTOF/Cluster.h   | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h b/DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h
index 2f15923419795..37d3ca23ddb35 100644
--- a/DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h
+++ b/DataFormats/Detectors/TOF/include/DataFormatsTOF/Cluster.h
@@ -49,9 +49,8 @@ class Cluster : public o2::BaseCluster<float>
          kDownRight = 4, // 2^4, 5th bit
          kDown = 5,      // 2^5, 6th bit
          kDownLeft = 6,  // 2^6, 7th bit
-         kLeft = 7,      // 2^7, 8th bit
-         //
-         FrameBit = 6 }; // this bit set means that the cluster is in the nominal (alpha=20*sector+10 deg.) sector frame rather than aligned
+         kLeft = 7       // 2^7, 8th bit
+  };
 
   Cluster() = default;
 
@@ -59,8 +58,8 @@ class Cluster : public o2::BaseCluster<float>
 
   ~Cluster() = default;
 
-  bool isInNominalSector() const { return isBitSet(FrameBit); }
-  void setInNominalSector() { setBit(FrameBit); }
+  bool isInNominalSector() const { return mInNominalSector; }
+  void setInNominalSector(bool v = true) { mInNominalSector = v; }
 
   std::int8_t getSector() const { return getCount(); }
   void setSector(std::int8_t value) { setCount(value); }
@@ -163,9 +162,10 @@ class Cluster : public o2::BaseCluster<float>
   double mDigitInfoT[6] = {0., 0., 0., 0., 0., 0.};
   float mDigitInfoTOT[6] = {0., 0., 0., 0., 0., 0.};
   float mTgeant = 0.0;
+  bool mInNominalSector = false;
   double mT0true = 0.0;
 
-  ClassDefNV(Cluster, 5);
+  ClassDefNV(Cluster, 6);
 };
 
 #ifndef GPUCA_GPUCODE

From fa19322c5688ba69a399dc985ecbe270064b2a5a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Oct 2025 11:31:35 +0200
Subject: [PATCH 0922/1764] GPU Benchmark: Remove unused variable to fix
 compiler warning

---
 GPU/GPUbenchmark/cuda/Kernels.cu | 2 --
 1 file changed, 2 deletions(-)

diff --git a/GPU/GPUbenchmark/cuda/Kernels.cu b/GPU/GPUbenchmark/cuda/Kernels.cu
index 16dc138ae466f..b8dedfd8145b1 100644
--- a/GPU/GPUbenchmark/cuda/Kernels.cu
+++ b/GPU/GPUbenchmark/cuda/Kernels.cu
@@ -304,7 +304,6 @@ void printDeviceProp(int32_t deviceId)
   int32_t clockRateKHz = 0;
   int32_t memoryClockRateKHz = 0;
   int32_t computeMode = 0;
-  int32_t cooperativeMultiDevice = 0;
 
 #if (CUDART_VERSION >= 13000)
   GPUCHECK(cudaDeviceGetAttribute(&clockRateKHz, cudaDevAttrClockRate, deviceId));
@@ -314,7 +313,6 @@ void printDeviceProp(int32_t deviceId)
   clockRateKHz = props.clockRate;
   memoryClockRateKHz = props.memoryClockRate;
   computeMode = props.computeMode;
-  cooperativeMultiDevice = props.cooperativeMultiDeviceLaunch;
 #endif
   std::cout << std::setw(w1) << "Name: " << props.name << std::endl;
   std::cout << std::setw(w1) << "pciBusID: " << props.pciBusID << std::endl;

From 54f5e871e25bf1fe0f092666145d895929a16671 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 15 Oct 2025 14:04:21 +0200
Subject: [PATCH 0923/1764] DPL Analysis: fix multiple HistogramRegistry
 instances per task

In particular when one of them needs to have its own folder.
---
 Framework/AnalysisSupport/src/AODWriterHelpers.cxx | 12 ++++++++++++
 Framework/Core/include/Framework/OutputObjHeader.h |  5 ++++-
 Framework/Core/src/HistogramRegistry.cxx           |  3 ++-
 Framework/TestWorkflows/src/o2TestHistograms.cxx   | 12 ++++++++++++
 4 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index 27dad43480913..bcf27d0be5ba3 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -339,7 +339,9 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
         O2_SIGNPOST_END(histogram_registry, did, "deserialization", "Done deserialization.");
         // If we have a folder, we assume the first element of the path
         // to be the name of the registry.
+        bool folderForContainer = false;
         if (sourceType == HistogramRegistrySource) {
+          folderForContainer = objh->createContainer != 0;
           obj.container = objh->containerName;
         } else {
           obj.container = obj.name;
@@ -423,6 +425,16 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
         // FIXME: handle folders
         f[route.policy]->cd("/");
         auto* currentDir = f[route.policy]->GetDirectory(currentDirectory.c_str());
+
+        // In case we need a folder for the registry, let's create it.
+        if (folderForContainer) {
+          auto* histogramRegistryFolder = currentDir->GetDirectory(obj.container.data());
+          if (!histogramRegistryFolder) {
+            histogramRegistryFolder = currentDir->mkdir(obj.container.c_str(), "", kTRUE);
+          }
+          currentDir = histogramRegistryFolder;
+        }
+
         // The name contains a path...
         int objSize = 0;
         if (sourceType == HistogramRegistrySource) {
diff --git a/Framework/Core/include/Framework/OutputObjHeader.h b/Framework/Core/include/Framework/OutputObjHeader.h
index f1c284d564f15..801642ec6af4f 100644
--- a/Framework/Core/include/Framework/OutputObjHeader.h
+++ b/Framework/Core/include/Framework/OutputObjHeader.h
@@ -37,6 +37,7 @@ enum OutputObjSourceType : unsigned int {
 /// @brief O2 header for OutputObj metadata
 struct OutputObjHeader : public BaseHeader {
   constexpr static const uint32_t sVersion = 1;
+  constexpr static const uint32_t MAX_REGISTRY_NAME_SIZE = 128;
   constexpr static const o2::header::HeaderType sHeaderType = "OutObjMD";
   constexpr static const o2::header::SerializationMethod sSerializationMethod = o2::header::gSerializationMethodNone;
   OutputObjHandlingPolicy mPolicy;
@@ -45,7 +46,9 @@ struct OutputObjHeader : public BaseHeader {
   uint16_t mPipelineIndex = 0;
   uint16_t mPipelineSize = 1;
   // Name of the actual container for the object, e.g. the HistogramRegistry name
-  char containerName[64] = {0};
+  char containerName[MAX_REGISTRY_NAME_SIZE] = {0};
+  // Wether or not the container should have a name
+  char createContainer = false;
 
   constexpr OutputObjHeader()
     : BaseHeader(sizeof(OutputObjHeader), sHeaderType, sSerializationMethod, sVersion),
diff --git a/Framework/Core/src/HistogramRegistry.cxx b/Framework/Core/src/HistogramRegistry.cxx
index 5e39fbe7181e7..9caa7cbd1f48e 100644
--- a/Framework/Core/src/HistogramRegistry.cxx
+++ b/Framework/Core/src/HistogramRegistry.cxx
@@ -55,7 +55,8 @@ OutputRef HistogramRegistry::ref(uint16_t pipelineIndex, uint16_t pipelineSize)
 {
   OutputObjHeader header{mPolicy, OutputObjSourceType::HistogramRegistrySource, mTaskHash, pipelineIndex, pipelineSize};
   // Copy the name of the registry to the haeder.
-  strncpy(header.containerName, mName.data(), 64);
+  strncpy(header.containerName, mName.data(), OutputObjHeader::MAX_REGISTRY_NAME_SIZE);
+  header.createContainer = mCreateRegistryDir ? 1 : 0;
   return OutputRef{std::string{mName}, 0, o2::header::Stack{header}};
 }
 
diff --git a/Framework/TestWorkflows/src/o2TestHistograms.cxx b/Framework/TestWorkflows/src/o2TestHistograms.cxx
index ae3610ca01e67..640a165fb91ff 100644
--- a/Framework/TestWorkflows/src/o2TestHistograms.cxx
+++ b/Framework/TestWorkflows/src/o2TestHistograms.cxx
@@ -53,6 +53,18 @@ struct EtaAndClsHistogramsSimple {
     } //
   };
 
+  HistogramRegistry registry2{
+    "registry2",
+    {
+      {"a/foo/b/eta", "#Eta", {HistType::kTH1F, {{100, -2.0, 2.0}}}},                           //
+      {"fii/c/hpt", "p_{T}", {HistType::kTH1D, {{1002, -0.01, 50.1}}}},                         //
+      {"a/foobar/phi", "#Phi", {HistType::kTH1D, {{102, 0, 2 * M_PI}}}},                        //
+      {"fifi/ptToPt", "#ptToPt", {HistType::kTH2F, {{100, -0.01, 10.01}, {100, -0.01, 10.01}}}} //
+    },
+    OutputObjHandlingPolicy::AnalysisObject,
+    false,
+    true};
+
   void init(InitContext&)
   {
     if (!trackFilterString->empty()) {

From 18a57ba63886e8bd427b30e71ad70bf91c0c023d Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 15 Oct 2025 21:07:16 +0200
Subject: [PATCH 0924/1764] DPL: add command line option to print error instead
 of warning when exit transition timer expires

---
 Framework/Core/src/DataProcessingDevice.cxx | 8 ++++----
 Framework/Core/src/DeviceSpecHelpers.cxx    | 2 ++
 Framework/Core/src/runDataProcessing.cxx    | 1 +
 3 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 5564f68d8f8ce..a41aa3a886d55 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -139,11 +139,11 @@ void on_transition_requested_expired(uv_timer_t* handle)
   // Check if this is a source device
   O2_SIGNPOST_ID_FROM_POINTER(cid, device, handle);
   auto& spec = ref->get<DeviceSpec const>();
-  if (hasOnlyGenerated(spec)) {
-    O2_SIGNPOST_EVENT_EMIT_ERROR(calibration, cid, "callback", "DPL exit transition grace period for source expired. Exiting.");
+  std::string messageOnExpire = hasOnlyGenerated(spec) ? "DPL exit transition grace period for source expired. Exiting." : fmt::format("DPL exit transition grace period for {} expired. Exiting.", state.allowedProcessing == DeviceState::CalibrationOnly ? "calibration" : "data & calibration").c_str();
+  if (!ref->get<RawDeviceService>().device()->GetConfig()->GetValue<bool>("error-on-exit-transition-timeout")) {
+    O2_SIGNPOST_EVENT_EMIT_WARN(calibration, cid, "callback", "%{public}s", messageOnExpire.c_str());
   } else {
-    O2_SIGNPOST_EVENT_EMIT_ERROR(calibration, cid, "callback", "DPL exit transition grace period for %{public}s expired. Exiting.",
-                                 state.allowedProcessing == DeviceState::CalibrationOnly ? "calibration" : "data & calibration");
+    O2_SIGNPOST_EVENT_EMIT_ERROR(calibration, cid, "callback", "%{public}s", messageOnExpire.c_str());
   }
   state.transitionHandling = TransitionHandlingState::Expired;
 }
diff --git a/Framework/Core/src/DeviceSpecHelpers.cxx b/Framework/Core/src/DeviceSpecHelpers.cxx
index ec0a40e44ac31..88e5269482ebd 100644
--- a/Framework/Core/src/DeviceSpecHelpers.cxx
+++ b/Framework/Core/src/DeviceSpecHelpers.cxx
@@ -1541,6 +1541,7 @@ void DeviceSpecHelpers::prepareArguments(bool defaultQuiet, bool defaultStopped,
         realOdesc.add_options()("child-driver", bpo::value<std::string>());
         realOdesc.add_options()("rate", bpo::value<std::string>());
         realOdesc.add_options()("exit-transition-timeout", bpo::value<std::string>());
+        realOdesc.add_options()("error-on-exit-transition-timeout", bpo::value<bool>()->zero_tokens());
         realOdesc.add_options()("data-processing-timeout", bpo::value<std::string>());
         realOdesc.add_options()("expected-region-callbacks", bpo::value<std::string>());
         realOdesc.add_options()("timeframes-rate-limit", bpo::value<std::string>());
@@ -1728,6 +1729,7 @@ boost::program_options::options_description DeviceSpecHelpers::getForwardedDevic
     ("control-port", bpo::value<std::string>(), "Utility port to be used by O2 Control")                                                                             //
     ("rate", bpo::value<std::string>(), "rate for a data source device (Hz)")                                                                                        //
     ("exit-transition-timeout", bpo::value<std::string>(), "timeout before switching to READY state")                                                                //
+    ("error-on-exit-transition-timeout", bpo::value<bool>()->zero_tokens(), "print error instead of warning when exit transition timer expires")                     //
     ("data-processing-timeout", bpo::value<std::string>(), "timeout after which only calibration can happen")                                                        //
     ("expected-region-callbacks", bpo::value<std::string>(), "region callbacks to expect before starting")                                                           //
     ("timeframes-rate-limit", bpo::value<std::string>()->default_value("0"), "how many timeframes can be in fly")                                                    //
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index ae6ea03063dfc..1611eb8605134 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1052,6 +1052,7 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
       ("signposts", bpo::value<std::string>()->default_value(defaultSignposts ? defaultSignposts : ""), "comma separated list of signposts to enable")                                             //
       ("expected-region-callbacks", bpo::value<std::string>()->default_value("0"), "how many region callbacks we are expecting")                                                                   //
       ("exit-transition-timeout", bpo::value<std::string>()->default_value(defaultExitTransitionTimeout), "how many second to wait before switching from RUN to READY")                            //
+      ("error-on-exit-transition-timeout", bpo::value<bool>()->zero_tokens()->default_value(false), "print error instead of warning when exit transition timer expires")                           //
       ("data-processing-timeout", bpo::value<std::string>()->default_value(defaultDataProcessingTimeout), "how many second to wait before stopping data processing and allowing data calibration") //
       ("timeframes-rate-limit", bpo::value<std::string>()->default_value("0"), "how many timeframe can be in fly at the same moment (0 disables)")                                                 //
       ("configuration,cfg", bpo::value<std::string>()->default_value("command-line"), "configuration backend")                                                                                     //

From a345c2dd06bd59b4923049758e30ae065a0b9727 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Oct 2025 15:03:24 +0200
Subject: [PATCH 0925/1764] GPU Standalone: Make setO2Settings compatible with
 debug mode

---
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 1fa41d55ebbec..f9c53e3ffd59c 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -214,11 +214,11 @@ int32_t ReadConfiguration(int argc, char** argv)
     }
   }
   if (configStandalone.setO2Settings) {
-    if (!(configStandalone.inputcontrolmem && configStandalone.outputcontrolmem)) {
-      printf("setO2Settings requires the usage of --inputMemory and --outputMemory as in O2\n");
-      return 1;
-    }
-    if (configStandalone.runGPU) {
+    if (configStandalone.runGPU && configStandalone.proc.debugLevel <= 1) {
+      if (!(configStandalone.inputcontrolmem && configStandalone.outputcontrolmem)) {
+        printf("setO2Settings requires the usage of --inputMemory and --outputMemory as in O2\n");
+        return 1;
+      }
       configStandalone.proc.forceHostMemoryPoolSize = 1024 * 1024 * 1024;
     }
     configStandalone.rec.tpc.trackReferenceX = 83;

From 6bf5c2e63ed32463bc26837f54d04cde3b2c5663 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Oct 2025 17:23:02 +0200
Subject: [PATCH 0926/1764] GPU RTC: Add overrideWarpSize option

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu | 4 ++--
 GPU/GPUTracking/Definitions/GPUSettingsList.h      | 1 +
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 9e7cfa5495040..62b490a59d0dc 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -113,7 +113,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
   constexpr int32_t reqVerMin = 0;
 #endif
   if (GetProcessingSettings().rtc.enable && GetProcessingSettings().rtctech.runTest == 2) {
-    mWarpSize = GPUCA_WARP_SIZE;
+    mWarpSize = GetProcessingSettings().rtc.overrideWarpSize != -1 ? GetProcessingSettings().rtc.overrideWarpSize : GPUCA_WARP_SIZE;
     genAndLoadRTC();
     exit(0);
   }
@@ -245,7 +245,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUInfo("\ttextureAlignment = %ld", (uint64_t)deviceProp.textureAlignment);
       GPUInfo(" ");
     }
-    if (deviceProp.warpSize != GPUCA_WARP_SIZE && !GetProcessingSettings().rtc.enable) {
+    if (GetProcessingSettings().rtc.enable ? (GetProcessingSettings().rtc.overrideWarpSize != -1 && deviceProp.warpSize != GetProcessingSettings().rtc.overrideWarpSize) : (deviceProp.warpSize != GPUCA_WARP_SIZE)) {
       throw std::runtime_error("Invalid warp size on GPU");
     }
     mWarpSize = deviceProp.warpSize;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 30477d67fdc4f..bde082b8a10c4 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -216,6 +216,7 @@ AddOption(optSpecialCode, int8_t, -1, "", 0, "Insert GPUCA_RTC_SPECIAL_CODE spec
 AddOption(deterministic, bool, false, "", 0, "Compile RTC in deterministic mode, with NO_FAST_MATH flags and GPUCA_DETERMINISTIC_MODE define")
 AddOption(compilePerKernel, bool, true, "", 0, "Run one RTC compilation per kernel")
 AddOption(enable, bool, false, "", 0, "Use RTC to optimize GPU code")
+AddOption(overrideWarpSize, int32_t, -1, "", 0, "Override the warp size to be used for RTC")
 AddHelp("help", 'h')
 EndConfig()
 

From a114b4bdd3e603c2472531766eca11c9801599f9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Oct 2025 19:14:42 +0200
Subject: [PATCH 0927/1764] GPU Workflow: Add dumpFirst and dumpLast options

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  3 ++
 GPU/GPUTracking/Interface/GPUO2Interface.cxx  | 23 +++++++-------
 GPU/GPUTracking/Interface/GPUO2Interface.h    |  4 +--
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |  1 +
 GPU/Workflow/src/GPUWorkflowInternal.h        |  1 +
 GPU/Workflow/src/GPUWorkflowPipeline.cxx      |  4 +--
 GPU/Workflow/src/GPUWorkflowSpec.cxx          | 31 ++++++++++++++++---
 prodtests/full-system-test/dpl-workflow.sh    |  3 ++
 8 files changed, 50 insertions(+), 20 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index bde082b8a10c4..fc08b063ff16a 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -625,6 +625,9 @@ AddOption(deviceType, std::string, "CPU", "", 0, "Device type, CPU | CUDA | HIP
 AddOption(forceDeviceType, bool, true, "", 0, "force device type, otherwise allows fall-back to CPU")
 AddOption(synchronousProcessing, bool, false, "", 0, "Apply performance shortcuts for synchronous processing, disable unneeded steps")
 AddOption(dump, int32_t, 0, "", 0, "Dump events for standalone benchmark: 1 = dump events, 2 = dump events and skip processing in workflow")
+AddOption(dumpFirst, int32_t, 0, "", 0, "First event to dump (referring to tfCounter)")
+AddOption(dumpLast, int32_t, -1, "", 0, "Last event to dump (-1 = all)")
+AddOption(dumpFolder, std::string, "", "", 0, "Folder to which to write dump files, [P] is replaced by process id")
 AddOption(display, bool, false, "", 0, "Enable standalone gpu tracking visualizaion")
 AddOption(rundEdx, int32_t, -1, "", 0, "Enable/disable dEdx processing (-1 for autoselect)")
 AddOption(dEdxSplineTopologyCorrFile, std::string, "", "", 0, "File name of the dE/dx spline track topology correction file")
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index 65907528a3dba..d04db5e9bf271 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -137,29 +137,30 @@ void GPUO2Interface::Deinitialize()
   mNContexts = 0;
 }
 
-void GPUO2Interface::DumpEvent(int32_t nEvent, GPUTrackingInOutPointers* data)
+void GPUO2Interface::DumpEvent(int32_t nEvent, GPUTrackingInOutPointers* data, uint32_t iThread, const char* dir)
 {
-  mCtx[0].mChain->ClearIOPointers();
-  mCtx[0].mChain->mIOPtrs = *data;
+  const auto oldPtrs = mCtx[iThread].mChain->mIOPtrs;
+  mCtx[iThread].mChain->mIOPtrs = *data;
   char fname[1024];
-  snprintf(fname, 1024, "event.%d.dump", nEvent);
-  mCtx[0].mChain->DumpData(fname);
+  snprintf(fname, 1024, "%sevent.%d.dump", dir, nEvent);
+  mCtx[iThread].mChain->DumpData(fname);
   if (nEvent == 0) {
 #ifdef GPUCA_BUILD_QA
     if (mConfig->configProcessing.runMC) {
-      mCtx[0].mChain->ForceInitQA();
+      mCtx[iThread].mChain->ForceInitQA();
       snprintf(fname, 1024, "mc.%d.dump", nEvent);
-      mCtx[0].mChain->GetQA()->UpdateChain(mCtx[0].mChain);
-      mCtx[0].mChain->GetQA()->DumpO2MCData(fname);
+      mCtx[iThread].mChain->GetQA()->UpdateChain(mCtx[iThread].mChain);
+      mCtx[iThread].mChain->GetQA()->DumpO2MCData(fname);
     }
 #endif
   }
+  mCtx[iThread].mChain->mIOPtrs = oldPtrs;
 }
 
-void GPUO2Interface::DumpSettings()
+void GPUO2Interface::DumpSettings(uint32_t iThread, const char* dir)
 {
-  mCtx[0].mChain->DoQueuedUpdates(-1);
-  mCtx[0].mRec->DumpSettings();
+  mCtx[iThread].mChain->DoQueuedUpdates(-1);
+  mCtx[iThread].mRec->DumpSettings(dir);
 }
 
 int32_t GPUO2Interface::RunTracking(GPUTrackingInOutPointers* data, GPUInterfaceOutputs* outputs, uint32_t iThread, GPUInterfaceInputUpdate* inputUpdateCallback)
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.h b/GPU/GPUTracking/Interface/GPUO2Interface.h
index 9b7390f2ed663..0e2020b306984 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.h
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.h
@@ -77,8 +77,8 @@ class GPUO2Interface
 
   int32_t RunTracking(GPUTrackingInOutPointers* data, GPUInterfaceOutputs* outputs = nullptr, uint32_t iThread = 0, GPUInterfaceInputUpdate* inputUpdateCallback = nullptr);
   void Clear(bool clearOutputs, uint32_t iThread = 0);
-  void DumpEvent(int32_t nEvent, GPUTrackingInOutPointers* data);
-  void DumpSettings();
+  void DumpEvent(int32_t nEvent, GPUTrackingInOutPointers* data, uint32_t iThread, const char* dir = "");
+  void DumpSettings(uint32_t iThread, const char* dir = "");
 
   void GetITSTraits(o2::its::TrackerTraits<7>*& trackerTraits, o2::its::VertexerTraits<7>*& vertexerTraits, o2::its::TimeFrame<7>*& timeFrame);
   const o2::base::Propagator* GetDeviceO2Propagator(int32_t iThread = 0) const;
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 4f62f07593bff..160efd4048af0 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -225,6 +225,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   int64_t mCreationForCalib = -1; ///< creation time for calib manipulation
   int32_t mVerbosity = 0;
   uint32_t mNTFs = 0;
+  uint32_t mNTFDumps = 0;
   uint32_t mNDebugDumps = 0;
   uint32_t mNextThreadIndex = 0;
   bool mUpdateGainMapCCDB = true;
diff --git a/GPU/Workflow/src/GPUWorkflowInternal.h b/GPU/Workflow/src/GPUWorkflowInternal.h
index 7ac9c60048e20..73d3676f3d84a 100644
--- a/GPU/Workflow/src/GPUWorkflowInternal.h
+++ b/GPU/Workflow/src/GPUWorkflowInternal.h
@@ -47,6 +47,7 @@ struct GPURecoWorkflow_QueueObject {
   bool jobSubmitted = false;
   bool jobFinished = false;
   int32_t jobReturnValue = 0;
+  volatile int32_t jobThreadIndex = -1;
   std::mutex jobFinishedMutex;
   std::condition_variable jobFinishedNotify;
   bool jobInputFinal = false;
diff --git a/GPU/Workflow/src/GPUWorkflowPipeline.cxx b/GPU/Workflow/src/GPUWorkflowPipeline.cxx
index 8867b6c336f97..ba395cd98d64d 100644
--- a/GPU/Workflow/src/GPUWorkflowPipeline.cxx
+++ b/GPU/Workflow/src/GPUWorkflowPipeline.cxx
@@ -90,6 +90,7 @@ void GPURecoWorkflowSpec::RunWorkerThread(int32_t id)
       context = workerContext.inputQueue.front();
       workerContext.inputQueue.pop();
     }
+    context->jobThreadIndex = id;
     context->jobReturnValue = runMain(nullptr, context->jobPtrs, context->jobOutputRegions, id, context->jobInputUpdateCallback.get());
     {
       std::lock_guard lk(context->jobFinishedMutex);
@@ -179,8 +180,7 @@ int32_t GPURecoWorkflowSpec::handlePipeline(ProcessingContext& pc, GPUTrackingIn
       }
       mPipeline->completionPolicyQueue.pop();
     }
-  }
-  if (mSpecConfig.enableDoublePipeline == 2) {
+  } else if (mSpecConfig.enableDoublePipeline == 2) {
     auto prepareDummyMessage = pc.outputs().make<DataAllocator::UninitializedVector<char>>(Output{gDataOriginGPU, "PIPELINEPREPARE", 0}, 0u);
 
     size_t ptrsTotal = 0;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 6c76f13c9bbd0..d3d3eb14869e0 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -825,11 +825,31 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
 
   lockDecodeInput.reset();
 
+  uint32_t threadIndex;
   if (mConfParam->dump) {
-    if (mNTFs == 1) {
-      mGPUReco->DumpSettings();
+    if (mSpecConfig.enableDoublePipeline && pipelineContext->jobSubmitted) {
+      while (pipelineContext->jobThreadIndex == -1) {
+      }
+      threadIndex = pipelineContext->jobThreadIndex;
+    } else {
+      threadIndex = 0; // TODO: Not sure if this is safe, but it is not yet known which threadIndex will pick up the enqueued job
+    }
+
+    std::string dir = "";
+    if (mConfParam->dumpFolder != "") {
+      dir = std::regex_replace(mConfParam->dumpFolder, std::regex("\\[P\\]"), std::to_string(getpid()));
+      if (mNTFs == 1) {
+        mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+      }
+      dir += "/";
+    }
+    if (mNTFs == 1) { // Must dump with first TF, since will enforce enqueued calib updates
+      mGPUReco->DumpSettings(threadIndex, dir.c_str());
+    }
+    if (tinfo.tfCounter >= mConfParam->dumpFirst && (mConfParam->dumpLast == -1 || tinfo.tfCounter <= mConfParam->dumpLast)) {
+      mGPUReco->DumpEvent(mNTFDumps, &ptrs, threadIndex, dir.c_str());
+      mNTFDumps++;
     }
-    mGPUReco->DumpEvent(mNTFs - 1, &ptrs);
   }
   std::unique_ptr<GPUTrackingInOutPointers> ptrsDump;
   if (mConfParam->dumpBadTFMode == 2) {
@@ -847,9 +867,10 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
     std::unique_lock lk(pipelineContext->jobFinishedMutex);
     pipelineContext->jobFinishedNotify.wait(lk, [context = pipelineContext.get()]() { return context->jobFinished; });
     retVal = pipelineContext->jobReturnValue;
+    threadIndex = pipelineContext->jobThreadIndex;
   } else {
     // uint32_t threadIndex = pc.services().get<ThreadPool>().threadIndex;
-    uint32_t threadIndex = mNextThreadIndex;
+    threadIndex = mNextThreadIndex;
     if (mConfig->configProcessing.doublePipeline) {
       mNextThreadIndex = (mNextThreadIndex + 1) % 2;
     }
@@ -879,7 +900,7 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
       }
       fclose(fp);
     } else if (mConfParam->dumpBadTFMode == 2) {
-      mGPUReco->DumpEvent(mNDebugDumps - 1, ptrsDump.get());
+      mGPUReco->DumpEvent(mNDebugDumps - 1, ptrsDump.get(), threadIndex);
     }
   }
 
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 2f0e761366e18..5d47ae84b130b 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -235,6 +235,9 @@ if [[ $EPNSYNCMODE == 1 ]]; then
     fi
   fi
 fi
+if [[ $GPUTYPE != "CPU" && $NGPUS > 1 ]]; then
+  GPU_CONFIG_KEY+="GPU_global.dumpFolder=gpu_dump_[P];"
+fi
 if [[ $SYNCRAWMODE == 1 ]]; then
   GPU_CONFIG_KEY+="GPU_proc.tpcIncreasedMinClustersPerRow=500000;GPU_proc.ignoreNonFatalGPUErrors=1;GPU_proc.throttleAlarms=1;"
   if [[ $RUNTYPE == "PHYSICS" || $RUNTYPE == "COSMICS" || $RUNTYPE == "TECHNICAL" ]]; then

From 21d965eaeb61d2aa08962b4f7638336afdaf63cb Mon Sep 17 00:00:00 2001
From: Fabrizio <fabrizio.grosa@cern.ch>
Date: Thu, 16 Oct 2025 13:50:36 +0200
Subject: [PATCH 0928/1764] Fix unwanted behaviour in signal filtering with
 embedding pattern different from (#14735)

---
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index b8d295a4393e4..4ef53a406497b 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -2126,9 +2126,7 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
                          0,
                          sourceID);
         }
-        if (sourceID != 0 || !mUseSigFiltMC) {
-          mcColToEvSrc.emplace_back(std::vector<int>{iCol, sourceID, eventID}); // point background and injected signal events to one collision
-        }
+        mcColToEvSrc.emplace_back(std::vector<int>{iCol, sourceID, eventID}); // point background and injected signal events to one collision
       }
     }
   }

From 171586d6e67f4e35174a736dfec9950a798ffda0 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 16 Oct 2025 10:43:06 +0200
Subject: [PATCH 0929/1764] aggregator.sh: print error when exit transition
 timer expires on aggregator nodes

---
 prodtests/full-system-test/aggregator-workflow.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/prodtests/full-system-test/aggregator-workflow.sh b/prodtests/full-system-test/aggregator-workflow.sh
index f90decefa3f2f..a0d091a98d193 100755
--- a/prodtests/full-system-test/aggregator-workflow.sh
+++ b/prodtests/full-system-test/aggregator-workflow.sh
@@ -14,6 +14,9 @@ source $O2DPG_ROOT/DATA/common/setenv.sh || { echo "setenv.sh failed" 1>&2 && ex
 source $O2DPG_ROOT/DATA/common/getCommonArgs.sh || { echo "getCommonArgs.sh failed" 1>&2 && exit 1; }
 source $O2DPG_ROOT/DATA/common/setenv_calib.sh || { echo "setenv_calib.sh failed" 1>&2 && exit 1; }
 
+# print an error (instead of warning) when exit transition timer expires, only for tasks on aggregator nodes
+ARGS_ALL+=" --error-on-exit-transition-timeout"
+
 # if the populator for DCS CCDB is needed, set it to non-0
 : ${NEED_DCS_CCDB_POPULATOR:=0}
 

From 3fbf25307eb5eb493b2d1e714906af06e1bdbf68 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Fri, 17 Oct 2025 09:05:30 +0200
Subject: [PATCH 0930/1764] TOF: param utilities are separated in a dedicated
 library for O2Physics usage (#14730)

* Revert "TOF Param container: move to header only"

This reverts commit 1aa2c1409988e1054730c7cccdc987fbe1db7506.

* Add DataFormatsParamTOF library to CMakeLists
---
 DataFormats/Detectors/TOF/CMakeLists.txt      | 10 ++-
 .../DataFormatsTOF/ParameterContainers.h      | 51 +++------------
 .../TOF/src/DataFormatsParamTOFLinkDef.h      | 17 +++++
 .../Detectors/TOF/src/DataFormatsTOFLinkDef.h |  2 -
 .../Detectors/TOF/src/ParameterContainers.cxx | 62 +++++++++++++++++++
 .../src/make-parameter-collection.cxx         |  2 +-
 6 files changed, 98 insertions(+), 46 deletions(-)
 create mode 100644 DataFormats/Detectors/TOF/src/DataFormatsParamTOFLinkDef.h
 create mode 100644 DataFormats/Detectors/TOF/src/ParameterContainers.cxx

diff --git a/DataFormats/Detectors/TOF/CMakeLists.txt b/DataFormats/Detectors/TOF/CMakeLists.txt
index 8a55e531287e1..4d41167f7bf1d 100644
--- a/DataFormats/Detectors/TOF/CMakeLists.txt
+++ b/DataFormats/Detectors/TOF/CMakeLists.txt
@@ -9,6 +9,14 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
+o2_add_library(DataFormatsParamTOF
+               SOURCES src/ParameterContainers.cxx
+               PUBLIC_LINK_LIBRARIES O2::FrameworkLogger)
+
+
+o2_target_root_dictionary(DataFormatsParamTOF
+                          HEADERS include/DataFormatsTOF/ParameterContainers.h)
+
 o2_add_library(DataFormatsTOF
                SOURCES src/Cluster.cxx
                        src/CalibInfoTOFshort.cxx
@@ -22,6 +30,7 @@ o2_add_library(DataFormatsTOF
                        src/TOFFEElightInfo.cxx
                PUBLIC_LINK_LIBRARIES O2::ReconstructionDataFormats
                                      O2::GPUCommon
+                                     O2::DataFormatsParamTOF
                                      Boost::serialization)
 
 o2_target_root_dictionary(DataFormatsTOF
@@ -33,7 +42,6 @@ o2_target_root_dictionary(DataFormatsTOF
                                   include/DataFormatsTOF/RawDataFormat.h
                                   include/DataFormatsTOF/CompressedDataFormat.h
                                   include/DataFormatsTOF/CTF.h
-                                  include/DataFormatsTOF/ParameterContainers.h
                                   include/DataFormatsTOF/CalibInfoCluster.h
                                   include/DataFormatsTOF/CosmicInfo.h
                                   include/DataFormatsTOF/TOFFEElightInfo.h
diff --git a/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h b/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
index c9d910d8345e5..e64bf8aa3e276 100644
--- a/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
+++ b/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
@@ -18,10 +18,10 @@
 #ifndef O2_TOF_PARAMCONTAINER_H
 #define O2_TOF_PARAMCONTAINER_H
 
-#include "TNamed.h"
-#include "TFile.h"
-#include "Framework/Logger.h"
-#include "map"
+#include <TNamed.h>
+#include <TFile.h>
+#include <Framework/Logger.h>
+#include <map>
 
 namespace o2
 {
@@ -37,7 +37,7 @@ class Parameters
   Parameters(std::array<std::string, nPar> parNames, std::string name) : mName{name}, mPar{}, mParNames{parNames} {};
 
   /// Default destructor
-  virtual ~Parameters() = default; // Ensure proper cleanup in derived classes
+  ~Parameters() = default;
 
   /// Setter for the parameter at position iparam
   /// \param iparam index in the array of the parameters
@@ -183,27 +183,10 @@ class ParameterCollection : public TNamed
   /// @param value parameter to add to the stored information
   /// @param pass key to look for in the stored information e.g. pass
   /// @return true if found and configured false if not fully configured
-  bool addParameter(const std::string& pass, const std::string& parName, float value)
-  {
-    const bool alreadyPresent = hasKey(pass);
-    if (alreadyPresent) {
-      LOG(debug) << "Changing parametrization corresponding to key " << pass << " from size " << mParameters[pass].size() << " to " << parName;
-    } else {
-      mParameters[pass] = std::unordered_map<std::string, paramvar_t>{};
-      LOG(debug) << "Adding new parametrization corresponding to key " << pass << ": " << parName;
-    }
-    mParameters[pass][parName] = value;
-    return true;
-  }
+  bool addParameter(const std::string& pass, const std::string& parName, float value);
 
   /// @return the size of the container i.e. the number of stored keys (or passes)
-  int getSize(const std::string& pass) const
-  {
-    if (!hasKey(pass)) {
-      return -1;
-    }
-    return mParameters.at(pass).size();
-  }
+  int getSize(const std::string& pass) const;
 
   /// @brief Function to push the parameters from the sub container into the collection and store it under a given key
   /// @tparam ParType type of the parameter container
@@ -231,26 +214,10 @@ class ParameterCollection : public TNamed
 
   /// @brief printing function for the content of the pass
   /// @param pass pass to print
-  void print(const std::string& pass) const
-  {
-    const auto& size = getSize(pass);
-    if (size < 0) {
-      LOG(info) << "empty pass: " << pass;
-      return;
-    }
-    LOG(info) << "Pass \"" << pass << "\" with size " << size;
-    for (const auto& [par, value] : mParameters.at(pass)) {
-      LOG(info) << "par name = " << par << ", value = " << value;
-    }
-  }
+  void print(const std::string& pass) const;
 
   /// @brief printing function for the full content of the container
-  void print() const
-  {
-    for (const auto& [pass, pars] : mParameters) {
-      print(pass);
-    }
-  }
+  void print() const;
 
   /// @brief Getter of the full map of parameters stored in the container
   /// @return returns the full map of parameters
diff --git a/DataFormats/Detectors/TOF/src/DataFormatsParamTOFLinkDef.h b/DataFormats/Detectors/TOF/src/DataFormatsParamTOFLinkDef.h
new file mode 100644
index 0000000000000..2d6ee84bedb92
--- /dev/null
+++ b/DataFormats/Detectors/TOF/src/DataFormatsParamTOFLinkDef.h
@@ -0,0 +1,17 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link C++ class o2::tof::Parameters < 5> + ;
+#pragma link C++ class o2::tof::ParameterCollection + ;
+
+#endif
diff --git a/DataFormats/Detectors/TOF/src/DataFormatsTOFLinkDef.h b/DataFormats/Detectors/TOF/src/DataFormatsTOFLinkDef.h
index 55d1fd3973e70..03004e4c22afa 100644
--- a/DataFormats/Detectors/TOF/src/DataFormatsTOFLinkDef.h
+++ b/DataFormats/Detectors/TOF/src/DataFormatsTOFLinkDef.h
@@ -33,8 +33,6 @@
 
 #pragma link C++ class std::vector < o2::dataformats::CalibInfoTOFshort> + ;
 #pragma link C++ class std::vector < o2::dataformats::CalibInfoTOF> + ;
-#pragma link C++ class o2::tof::Parameters < 5> + ;
-#pragma link C++ class o2::tof::ParameterCollection + ;
 
 #pragma link C++ class o2::tof::CTFHeader + ;
 #pragma link C++ class o2::tof::CompressedInfos + ;
diff --git a/DataFormats/Detectors/TOF/src/ParameterContainers.cxx b/DataFormats/Detectors/TOF/src/ParameterContainers.cxx
new file mode 100644
index 0000000000000..91f723873e9cd
--- /dev/null
+++ b/DataFormats/Detectors/TOF/src/ParameterContainers.cxx
@@ -0,0 +1,62 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   ParameterContainers.h
+/// \author Francesco Noferini
+/// \author Nicolò Jacazio nicolo.jacazio@cern.ch
+/// @since  2022-11-08
+/// \brief  Implementation of the containers for the general parameters
+
+#include "DataFormatsTOF/ParameterContainers.h"
+
+// ClassImp(o2::tof::Parameters);
+using namespace o2::tof;
+
+bool ParameterCollection::addParameter(const std::string& pass, const std::string& parName, float value)
+{
+  const bool alreadyPresent = hasKey(pass);
+  if (alreadyPresent) {
+    LOG(debug) << "Changing parametrization corresponding to key " << pass << " from size " << mParameters[pass].size() << " to " << parName;
+  } else {
+    mParameters[pass] = std::unordered_map<std::string, paramvar_t>{};
+    LOG(debug) << "Adding new parametrization corresponding to key " << pass << ": " << parName;
+  }
+  mParameters[pass][parName] = value;
+  return true;
+}
+
+int ParameterCollection::getSize(const std::string& pass) const
+{
+  if (!hasKey(pass)) {
+    return -1;
+  }
+  return mParameters.at(pass).size();
+}
+
+void ParameterCollection::print() const
+{
+  for (const auto& [pass, pars] : mParameters) {
+    print(pass);
+  }
+}
+
+void ParameterCollection::print(const std::string& pass) const
+{
+  const auto& size = getSize(pass);
+  if (size < 0) {
+    LOG(info) << "empty pass: " << pass;
+    return;
+  }
+  LOG(info) << "Pass \"" << pass << "\" with size " << size;
+  for (const auto& [par, value] : mParameters.at(pass)) {
+    LOG(info) << "par name = " << par << ", value = " << value;
+  }
+}
diff --git a/Detectors/TOF/workflow/src/make-parameter-collection.cxx b/Detectors/TOF/workflow/src/make-parameter-collection.cxx
index c90f417639212..3a210df3fcad8 100644
--- a/Detectors/TOF/workflow/src/make-parameter-collection.cxx
+++ b/Detectors/TOF/workflow/src/make-parameter-collection.cxx
@@ -63,7 +63,7 @@ class ParamExample : public Parameters<5>
  public:
   ParamExample() : Parameters(std::array<std::string, 5>{"p0", "p1", "p2", "p3", "p4"},
                               "ParamExample") { setParameters(std::array<paramvar_t, 5>{0, 1, 2, 3, 4}); }; // Default constructor with default parameters
-  ~ParamExample() override = default;
+  ~ParamExample() = default;
 };
 
 int main(int argc, char* argv[])

From 95b425adfdc1add2620bc0a451b38c7a54f11df5 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <92120560+cima22@users.noreply.github.com>
Date: Sat, 18 Oct 2025 09:19:33 +0200
Subject: [PATCH 0931/1764] GPU TPC: added dynamic buffer allocation during
 track-model decoding (#14747)

* GPU TPC: added dynamic buffer allocation during track-model decoding

* GPU TPC: improvement for dynamic buffer size for track-model decoding

* GPU TPC: increased margins for track-model decoding buffers
---
 GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
index fd0c929dd2ba7..7e7ee86623099 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
@@ -18,6 +18,7 @@
 #include "GPUO2DataTypes.h"
 #include "GPUMemorySizeScalers.h"
 #include "GPULogging.h"
+#include <algorithm>
 
 using namespace o2::gpu;
 
@@ -116,5 +117,10 @@ void GPUTPCDecompression::RegisterMemoryAllocation()
 
 void GPUTPCDecompression::SetMaxData(const GPUTrackingInOutPointers& io)
 {
-  mMaxNativeClustersPerBuffer = mRec->GetProcessingSettings().tpcMaxAttachedClustersPerSectorRow;
+  uint32_t maxAttachedClsMargin1 = *std::max_element(mInputGPU.nSliceRowClusters, mInputGPU.nSliceRowClusters + mInputGPU.nSliceRows);
+  float clsRatio1 = (mInputGPU.nUnattachedClusters > 0 ? float(mInputGPU.nAttachedClusters) / float(mInputGPU.nUnattachedClusters) : 1.0f) * 1.5f;
+  maxAttachedClsMargin1 *= clsRatio1;
+  uint32_t maxAttachedClsMargin2 = mInputGPU.nAttachedClusters / mInputGPU.nSliceRows * 3.5;                                             // mean #attached cls per SectorRow multiplied by 3.5 (tuned)
+  mMaxNativeClustersPerBuffer = std::max({maxAttachedClsMargin1, maxAttachedClsMargin2, 1000u});                                         // take biggest margin, 1000 clusters minimum
+  mMaxNativeClustersPerBuffer = std::min(mMaxNativeClustersPerBuffer, mRec->GetProcessingSettings().tpcMaxAttachedClustersPerSectorRow); // upperbound given by configurable param
 }

From ece1db4cad94d80832974b16d172cbfd18241399 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 16 Oct 2025 14:01:40 +0200
Subject: [PATCH 0932/1764] GPU: Make memoryStat work from GPUWorkflow

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  2 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx | 28 +++++++++++--------
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  4 +++
 .../GPUChainTrackingDebugAndProfiling.cxx     | 26 +++++++++++------
 .../Standalone/Benchmark/standalone.cxx       |  8 ------
 6 files changed, 39 insertions(+), 31 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 6d64fb3daca6a..e24b76678e710 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -999,7 +999,7 @@ void GPUReconstruction::PrintMemoryStatistics()
   }
   printf("%59s CPU / %9s GPU\n", "", "");
   for (auto it = sizes.begin(); it != sizes.end(); it++) {
-    printf("Allocation %30s %s: Size %'14zu / %'14zu\n", it->first.c_str(), it->second[2] ? "P" : " ", it->second[0], it->second[1]);
+    printf("Allocation %50s %s: Size %'14zu / %'14zu\n", it->first.c_str(), it->second[2] ? "P" : " ", it->second[0], it->second[1]);
   }
   PrintMemoryOverview();
   for (uint32_t i = 0; i < mChains.size(); i++) {
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 641b0a2d095ca..bdf1ade37868c 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -231,26 +231,24 @@ int32_t GPUReconstructionCPU::RunChains()
   }
   mTimerTotal.Start();
   const std::clock_t cpuTimerStart = std::clock();
+  int32_t retVal = 0;
   if (GetProcessingSettings().doublePipeline) {
-    int32_t retVal = EnqueuePipeline();
-    if (retVal) {
-      return retVal;
-    }
+    retVal = EnqueuePipeline();
   } else {
     if (mSlaves.size() || mMaster) {
       WriteConstantParams(); // Reinitialize // TODO: Get this in sync with GPUChainTracking::DoQueuedUpdates, and consider the doublePipeline
     }
     for (uint32_t i = 0; i < mChains.size(); i++) {
-      int32_t retVal = mChains[i]->RunChain();
-      if (retVal) {
-        return retVal;
-      }
-    }
-    if (GetProcessingSettings().tpcFreeAllocatedMemoryAfterProcessing) {
-      ClearAllocatedMemory();
+      retVal = mChains[i]->RunChain();
     }
   }
+  if (retVal != 0 && retVal != 2) {
+    return retVal;
+  }
   mTimerTotal.Stop();
+  if (GetProcessingSettings().tpcFreeAllocatedMemoryAfterProcessing) {
+    ClearAllocatedMemory();
+  }
   mStatCPUTime += (double)(std::clock() - cpuTimerStart) / CLOCKS_PER_SEC;
   if (GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) {
     GPUInfo("Allocated memory when ending processing %36s", "");
@@ -339,7 +337,13 @@ int32_t GPUReconstructionCPU::RunChains()
     mTimerTotal.Reset();
   }
 
-  return 0;
+  if (GetProcessingSettings().memoryStat) {
+    PrintMemoryStatistics();
+  } else if (GetProcessingSettings().debugLevel >= 2) {
+    PrintMemoryOverview();
+  }
+
+  return retVal;
 }
 
 void GPUReconstructionCPU::ResetDeviceProcessorTypes()
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index fc08b063ff16a..8cf6b29a43d96 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -377,6 +377,7 @@ AddOption(debugOnFailureMaxFiles, uint32_t, 0, "", 0, "Max number of files to ha
 AddOption(debugOnFailureMaxSize, uint32_t, 0, "", 0, "Max size of existing dumps in the target folder in GB")
 AddOption(debugOnFailureDirectory, std::string, ".", "", 0, "Target folder for debug / dump")
 AddOption(amdMI100SerializationWorkaround, bool, false, "", 0, "Enable workaround that mitigates MI100 serialization bug")
+AddOption(memoryStat, bool, false, "", 0, "Print memory statistics")
 AddVariable(eventDisplay, o2::gpu::GPUDisplayFrontendInterface*, nullptr)
 AddSubConfig(GPUSettingsProcessingRTC, rtc)
 AddSubConfig(GPUSettingsProcessingRTCtechnical, rtctech)
@@ -587,7 +588,6 @@ AddOption(zsVersion, int32_t, 2, "", 0, "ZS Version: 1 = 10-bit ADC row based, 2
 AddOption(dumpEvents, bool, false, "", 0, "Dump events (after transformation such as encodeZS")
 AddOption(stripDumpedEvents, bool, false, "", 0, "Remove redundant inputs (e.g. digits and ZS) before dumping")
 AddOption(printSettings, int32_t, 0, "", 0, "Print all settings", def(1))
-AddOption(memoryStat, bool, false, "", 0, "Print memory statistics")
 AddOption(testSyncAsync, bool, false, "syncAsync", 0, "Test first synchronous and then asynchronous processing")
 AddOption(testSync, bool, false, "sync", 0, "Test settings for synchronous phase")
 AddOption(timeFrameTime, bool, false, "tfTime", 0, "Print some debug information about time frame processing time")
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 91870f981d542..14d0e04eb4dd3 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -278,6 +278,10 @@ bool GPUChainTracking::ValidateSettings()
     return false;
   }
   if (GetProcessingSettings().doublePipeline) {
+    if (GetProcessingSettings().tpcFreeAllocatedMemoryAfterProcessing) {
+      GPUError("Cannot use double pipeline with tpcFreeAllocatedMemoryAfterProcessing");
+      return false;
+    }
     if (!GetRecoStepsOutputs().isOnlySet(GPUDataTypes::InOutType::TPCMergedTracks, GPUDataTypes::InOutType::TPCCompressedClusters, GPUDataTypes::InOutType::TPCClusters)) {
       GPUError("Invalid outputs for double pipeline mode 0x%x", (uint32_t)GetRecoStepsOutputs());
       return false;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 15846246bca0a..fab7179876c04 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -142,8 +142,10 @@ void GPUChainTracking::PrintMemoryStatistics()
   std::map<std::string, GPUChainTrackingMemUsage> usageMap;
   for (int32_t i = 0; i < NSECTORS; i++) {
 #ifdef GPUCA_TPC_GEOMETRY_O2
-    addToMap("TPC Clusterer Sector Peaks", usageMap, processors()->tpcClusterer[i].mPmemory->counters.nPeaks, processors()->tpcClusterer[i].mNMaxPeaks);
-    addToMap("TPC Clusterer Sector Clusters", usageMap, processors()->tpcClusterer[i].mPmemory->counters.nClusters, processors()->tpcClusterer[i].mNMaxClusters);
+    if (processors()->tpcClusterer[i].mPmemory) {
+      addToMap("TPC Clusterer Sector Peaks", usageMap, processors()->tpcClusterer[i].mPmemory->counters.nPeaks, processors()->tpcClusterer[i].mNMaxPeaks);
+      addToMap("TPC Clusterer Sector Clusters", usageMap, processors()->tpcClusterer[i].mPmemory->counters.nClusters, processors()->tpcClusterer[i].mNMaxClusters);
+    }
 #endif
     addToMap("TPC Sector Start Hits", usageMap, *processors()->tpcTrackers[i].NStartHits(), processors()->tpcTrackers[i].NMaxStartHits());
     addToMap("TPC Sector Tracklets", usageMap, *processors()->tpcTrackers[i].NTracklets(), processors()->tpcTrackers[i].NMaxTracklets());
@@ -152,8 +154,10 @@ void GPUChainTracking::PrintMemoryStatistics()
     addToMap("TPC Sector TrackHits", usageMap, *processors()->tpcTrackers[i].NTrackHits(), processors()->tpcTrackers[i].NMaxTrackHits());
   }
   addToMap("TPC Clusterer Clusters", usageMap, mRec->MemoryScalers()->nTPCHits, mRec->MemoryScalers()->NTPCClusters(mRec->MemoryScalers()->nTPCdigits));
-  addToMap("TPC Tracks", usageMap, processors()->tpcMerger.NMergedTracks(), processors()->tpcMerger.NMaxTracks());
-  addToMap("TPC TrackHits", usageMap, processors()->tpcMerger.NMergedTrackClusters(), processors()->tpcMerger.NMaxMergedTrackClusters());
+  if (processors()->tpcMerger.Memory()) {
+    addToMap("TPC Tracks", usageMap, processors()->tpcMerger.NMergedTracks(), processors()->tpcMerger.NMaxTracks());
+    addToMap("TPC TrackHits", usageMap, processors()->tpcMerger.NMergedTrackClusters(), processors()->tpcMerger.NMaxMergedTrackClusters());
+  }
 
   if (mRec->GetProcessingSettings().createO2Output) {
     addToMap("TPC O2 Tracks", usageMap, processors()->tpcMerger.NOutputTracksTPCO2(), processors()->tpcMerger.NOutputTracksTPCO2());
@@ -161,9 +165,11 @@ void GPUChainTracking::PrintMemoryStatistics()
   }
 
 #ifdef GPUCA_TPC_GEOMETRY_O2
-  addToMap("TPC ComprCache HitsAttached", usageMap, processors()->tpcCompressor.mOutput->nAttachedClusters, processors()->tpcCompressor.mMaxTrackClusters);
-  addToMap("TPC ComprCache HitsUnattached", usageMap, processors()->tpcCompressor.mOutput->nUnattachedClusters, processors()->tpcCompressor.mMaxClustersInCache);
-  addToMap("TPC ComprCache Tracks", usageMap, processors()->tpcCompressor.mOutput->nTracks, processors()->tpcCompressor.mMaxTracks);
+  if (processors()->tpcCompressor.mOutput) {
+    addToMap("TPC ComprCache HitsAttached", usageMap, processors()->tpcCompressor.mOutput->nAttachedClusters, processors()->tpcCompressor.mMaxTrackClusters);
+    addToMap("TPC ComprCache HitsUnattached", usageMap, processors()->tpcCompressor.mOutput->nUnattachedClusters, processors()->tpcCompressor.mMaxClustersInCache);
+    addToMap("TPC ComprCache Tracks", usageMap, processors()->tpcCompressor.mOutput->nTracks, processors()->tpcCompressor.mMaxTracks);
+  }
 #endif
 
   for (auto& elem : usageMap) {
@@ -180,8 +186,10 @@ void GPUChainTracking::PrintMemoryRelations()
     GPUInfo("MEMREL SectorTracks NCl %d NTrk %d", processors()->tpcTrackers[i].NHitsTotal(), *processors()->tpcTrackers[i].NTracks());
     GPUInfo("MEMREL SectorTrackHits NCl %d NTrkH %d", processors()->tpcTrackers[i].NHitsTotal(), *processors()->tpcTrackers[i].NTrackHits());
   }
-  GPUInfo("MEMREL Tracks NCl %d NTrk %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NMergedTracks());
-  GPUInfo("MEMREL TrackHitss NCl %d NTrkH %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NMergedTrackClusters());
+  if (processors()->tpcMerger.Memory()) {
+    GPUInfo("MEMREL Tracks NCl %d NTrk %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NMergedTracks());
+    GPUInfo("MEMREL TrackHitss NCl %d NTrkH %d", processors()->tpcMerger.NMaxClusters(), processors()->tpcMerger.NMergedTrackClusters());
+  }
 }
 
 void GPUChainTracking::PrepareKernelDebugOutput()
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index f9c53e3ffd59c..4fe1691afef50 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -649,11 +649,6 @@ int32_t RunBenchmark(GPUReconstruction* recUse, GPUChainTracking* chainTrackingU
 
     if (tmpRetVal == 0 || tmpRetVal == 2) {
       OutputStat(chainTrackingUse, iRun == 0 ? nTracksTotal : nullptr, iRun == 0 ? nClustersTotal : nullptr);
-      if (configStandalone.memoryStat) {
-        recUse->PrintMemoryStatistics();
-      } else if (configStandalone.proc.debugLevel >= 2) {
-        recUse->PrintMemoryOverview();
-      }
     }
 
     if (tmpRetVal == 0 && configStandalone.testSyncAsync) {
@@ -685,9 +680,6 @@ int32_t RunBenchmark(GPUReconstruction* recUse, GPUChainTracking* chainTrackingU
       tmpRetVal = recAsync->RunChains();
       if (tmpRetVal == 0 || tmpRetVal == 2) {
         OutputStat(chainTrackingAsync, nullptr, nullptr);
-        if (configStandalone.memoryStat) {
-          recAsync->PrintMemoryStatistics();
-        }
       }
       recAsync->ClearAllocatedMemory();
     }

From f1e9522b71170153b7862b9bf3a8de25f9812686 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 16 Oct 2025 15:06:20 +0200
Subject: [PATCH 0933/1764] GPU TPC Decompression: all temporary memory should
 go to the stack and be freed

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx           |  6 +++++-
 .../DataCompression/GPUTPCDecompression.cxx          | 12 ++++++------
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index e24b76678e710..a05736d519bd0 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -639,7 +639,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
       res->mPtr = GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(res->mPtrDevice);
       res->SetPointers(res->mPtr);
       if (GetProcessingSettings().allocDebugLevel >= 2) {
-        std::cout << (res->mReuse >= 0 ? "Reused " : "Allocated ") << res->mName << ": " << res->mSize << "\n";
+        std::cout << (res->mReuse >= 0 ? "Reused " : "Allocated ") << res->mName << ": " << res->mSize << " (individual" << ((res->mType & GPUMemoryResource::MEMORY_STACK) ? " stack" : "") << ")\n";
       }
       if (res->mType & GPUMemoryResource::MEMORY_STACK) {
         mNonPersistentIndividualAllocations.emplace_back(res);
@@ -896,8 +896,12 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
   }
   mHostMemoryPoolEnd = std::get<0>(mNonPersistentMemoryStack.back());
   mDeviceMemoryPoolEnd = std::get<1>(mNonPersistentMemoryStack.back());
+  std::cout << "FOOOO POP " << std::get<2>(mNonPersistentMemoryStack.back()) << " - " << mNonPersistentIndividualAllocations.size();
   for (uint32_t i = std::get<2>(mNonPersistentMemoryStack.back()); i < mNonPersistentIndividualAllocations.size(); i++) {
     GPUMemoryResource* res = mNonPersistentIndividualAllocations[i];
+    if (GetProcessingSettings().allocDebugLevel >= 2 && (res->mPtr || res->mPtrDevice)) {
+      std::cout << "Freeing NonPersistent " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
+    }
     if (res->mReuse < 0) {
       operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
     }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
index 7e7ee86623099..7f5e485c54409 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
@@ -107,12 +107,12 @@ void GPUTPCDecompression::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();
   mMemoryResInputGPU = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersInputGPU, GPUMemoryResource::MEMORY_INPUT_FLAG | GPUMemoryResource::MEMORY_GPU | GPUMemoryResource::MEMORY_EXTERNAL | GPUMemoryResource::MEMORY_SCRATCH, "TPCDecompressionInput");
-  mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersTmpNativeBuffersGPU, GPUMemoryResource::MEMORY_SCRATCH, "TPCDecompressionTmpBuffersGPU");
-  mResourceTmpIndexes = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersTmpNativeBuffersOutput, GPUMemoryResource::MEMORY_OUTPUT | GPUMemoryResource::MEMORY_SCRATCH, "TPCDecompressionTmpBuffersOutput");
-  mResourceTmpClustersOffsets = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersTmpNativeBuffersInput, GPUMemoryResource::MEMORY_INPUT | GPUMemoryResource::MEMORY_SCRATCH, "TPCDecompressionTmpBuffersInput");
-  mResourceTmpBufferBeforeFiltering = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersTmpClusterNativeAccessForFiltering, GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_SCRATCH, "TPCDecompressionTmpBufferForFiltering");
-  mResourceClusterNativeAccess = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersInputClusterNativeAccess, GPUMemoryResource::MEMORY_INPUT | GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_SCRATCH, "TPCDecompressionTmpClusterAccessForFiltering");
-  mResourceNClusterPerSectorRow = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersNClusterPerSectorRow, GPUMemoryResource::MEMORY_OUTPUT | GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_SCRATCH, "TPCDecompressionTmpClusterCountForFiltering");
+  mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersTmpNativeBuffersGPU, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK, "TPCDecompressionTmpBuffersGPU");
+  mResourceTmpIndexes = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersTmpNativeBuffersOutput, GPUMemoryResource::MEMORY_OUTPUT | GPUMemoryResource::MEMORY_STACK, "TPCDecompressionTmpBuffersOutput");
+  mResourceTmpClustersOffsets = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersTmpNativeBuffersInput, GPUMemoryResource::MEMORY_INPUT | GPUMemoryResource::MEMORY_STACK, "TPCDecompressionTmpBuffersInput");
+  mResourceTmpBufferBeforeFiltering = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersTmpClusterNativeAccessForFiltering, GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK, "TPCDecompressionTmpBufferForFiltering");
+  mResourceClusterNativeAccess = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersInputClusterNativeAccess, GPUMemoryResource::MEMORY_INPUT | GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_STACK, "TPCDecompressionTmpClusterAccessForFiltering");
+  mResourceNClusterPerSectorRow = mRec->RegisterMemoryAllocation(this, &GPUTPCDecompression::SetPointersNClusterPerSectorRow, GPUMemoryResource::MEMORY_OUTPUT | GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_STACK, "TPCDecompressionTmpClusterCountForFiltering");
 }
 
 void GPUTPCDecompression::SetMaxData(const GPUTrackingInOutPointers& io)

From 81d282c9e8da7bb53788fd84e6c16877639c6ffa Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 17 Oct 2025 11:25:19 +0200
Subject: [PATCH 0934/1764] GPU TPC: Tracklet memory during seeding when
 running on the host should be on the stack

---
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index 41530cb629ce8..7897de4f2002e 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -102,9 +102,9 @@ void GPUTPCTracker::RegisterMemoryAllocation()
   uint32_t type = GPUMemoryResource::MEMORY_SCRATCH;
   if (mRec->GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) { // For individual scheme, we allocate tracklets separately, and change the type for the following allocations to custom
     type |= GPUMemoryResource::MEMORY_CUSTOM;
-    mMemoryResTracklets = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersTracklets, type, "TPCTrackerTracklets");
+    mMemoryResTracklets = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersTracklets, type | GPUMemoryResource::MEMORY_STACK, "TPCTrackerTracklets");
   }
-  mMemoryResOutput = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersOutput, type, "TPCTrackerTracks");
+  mMemoryResOutput = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersOutput, type, "TPCTrackerTracks"); // TODO: Ideally this should eventually go on the stack, so that we can free it after the first phase of track merging
 }
 
 GPUhd() void* GPUTPCTracker::SetPointersTracklets(void* mem)

From 070eaae779f585edb7799aaac7aa7987209735c9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 17 Oct 2025 11:25:52 +0200
Subject: [PATCH 0935/1764] GPU: Add option to free individual stacked
 allocations per processor on the host

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx | 23 ++++++++++++++--------
 GPU/GPUTracking/Base/GPUReconstruction.h   |  2 +-
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index a05736d519bd0..f00c856ad1ff2 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -877,8 +877,11 @@ void GPUReconstruction::PushNonPersistentMemory(uint64_t tag)
   mNonPersistentMemoryStack.emplace_back(mHostMemoryPoolEnd, mDeviceMemoryPoolEnd, mNonPersistentIndividualAllocations.size(), mNonPersistentIndividualDirectAllocations.size(), tag);
 }
 
-void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
+void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag, const GPUProcessor* proc)
 {
+  if (proc && GetProcessingSettings().memoryAllocationStrategy != GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
+    GPUFatal("Processor-depending memory-free works only with allocation strategy ALLOCATION_INDIVIDUAL");
+  }
   if (GetProcessingSettings().keepDisplayMemory || GetProcessingSettings().disableMemoryReuse) {
     return;
   }
@@ -888,17 +891,17 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
   if (tag != 0 && std::get<4>(mNonPersistentMemoryStack.back()) != tag) {
     GPUFatal("Tag mismatch when popping non persistent memory from stack : pop %s vs on stack %s", qTag2Str(tag).c_str(), qTag2Str(std::get<4>(mNonPersistentMemoryStack.back())).c_str());
   }
-  if ((GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) && (IsGPU() || GetProcessingSettings().forceHostMemoryPoolSize)) {
+  if (!proc && (GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) && (IsGPU() || GetProcessingSettings().forceHostMemoryPoolSize)) {
     printf("Allocated memory after %30s (%8s) (Stack %zu): ", GPUDataTypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<4>(mNonPersistentMemoryStack.back())).c_str(), mNonPersistentMemoryStack.size());
     PrintMemoryOverview();
     printf("%76s", "");
     PrintMemoryMax();
   }
-  mHostMemoryPoolEnd = std::get<0>(mNonPersistentMemoryStack.back());
-  mDeviceMemoryPoolEnd = std::get<1>(mNonPersistentMemoryStack.back());
-  std::cout << "FOOOO POP " << std::get<2>(mNonPersistentMemoryStack.back()) << " - " << mNonPersistentIndividualAllocations.size();
   for (uint32_t i = std::get<2>(mNonPersistentMemoryStack.back()); i < mNonPersistentIndividualAllocations.size(); i++) {
     GPUMemoryResource* res = mNonPersistentIndividualAllocations[i];
+    if (proc && res->mProcessor != proc) {
+      continue;
+    }
     if (GetProcessingSettings().allocDebugLevel >= 2 && (res->mPtr || res->mPtrDevice)) {
       std::cout << "Freeing NonPersistent " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
     }
@@ -908,9 +911,13 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag)
     res->mPtr = nullptr;
     res->mPtrDevice = nullptr;
   }
-  mNonPersistentIndividualAllocations.resize(std::get<2>(mNonPersistentMemoryStack.back()));
-  mNonPersistentIndividualDirectAllocations.resize(std::get<3>(mNonPersistentMemoryStack.back()));
-  mNonPersistentMemoryStack.pop_back();
+  if (!proc) {
+    mHostMemoryPoolEnd = std::get<0>(mNonPersistentMemoryStack.back());
+    mDeviceMemoryPoolEnd = std::get<1>(mNonPersistentMemoryStack.back());
+    mNonPersistentIndividualAllocations.resize(std::get<2>(mNonPersistentMemoryStack.back()));
+    mNonPersistentIndividualDirectAllocations.resize(std::get<3>(mNonPersistentMemoryStack.back()));
+    mNonPersistentMemoryStack.pop_back();
+  }
 }
 
 void GPUReconstruction::BlockStackedMemory(GPUReconstruction* rec)
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 420e602e61352..b98f5660a933e 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -179,7 +179,7 @@ class GPUReconstruction
   void ReturnVolatileMemory();
   ThrustVolatileAllocator getThrustVolatileDeviceAllocator();
   void PushNonPersistentMemory(uint64_t tag);
-  void PopNonPersistentMemory(RecoStep step, uint64_t tag);
+  void PopNonPersistentMemory(RecoStep step, uint64_t tag, const GPUProcessor* proc = nullptr);
   void BlockStackedMemory(GPUReconstruction* rec);
   void UnblockStackedMemory();
   void ResetRegisteredMemoryPointers(GPUProcessor* proc);

From ce00c8b7b924fb79c764bd2a8a960118df3515a2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 17 Oct 2025 16:26:51 +0200
Subject: [PATCH 0936/1764] GPU: Make memory allocation and freeing of
 individual stacked memory thread-safe

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx |  7 ++++
 GPU/GPUTracking/Base/GPUReconstruction.h   |  2 +
 GPU/GPUTracking/utils/stdspinlock.h        | 44 ++++++++++++++++++++++
 3 files changed, 53 insertions(+)
 create mode 100644 GPU/GPUTracking/utils/stdspinlock.h

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index f00c856ad1ff2..5129ccc4becf1 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -40,6 +40,7 @@
 
 #include "GPULogging.h"
 #include "utils/strtag.h"
+#include "utils/stdspinlock.h"
 
 #ifdef GPUCA_O2_LIB
 #include "GPUO2InterfaceConfiguration.h"
@@ -589,6 +590,7 @@ size_t GPUReconstruction::AllocateRegisteredMemoryHelper(GPUMemoryResource* res,
     throw std::bad_alloc();
   }
   size_t retVal;
+  stdspinlock spinlock(mMemoryMutex);
   if ((res->mType & GPUMemoryResource::MEMORY_STACK) && memorypoolend) {
     retVal = ptrDiff((res->*setPtr)((char*)1), (char*)(1));
     memorypoolend = (void*)((char*)memorypoolend - GPUProcessor::getAlignmentMod<GPUCA_MEMALIGN>(memorypoolend));
@@ -642,6 +644,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         std::cout << (res->mReuse >= 0 ? "Reused " : "Allocated ") << res->mName << ": " << res->mSize << " (individual" << ((res->mType & GPUMemoryResource::MEMORY_STACK) ? " stack" : "") << ")\n";
       }
       if (res->mType & GPUMemoryResource::MEMORY_STACK) {
+        stdspinlock spinlock(mMemoryMutex);
         mNonPersistentIndividualAllocations.emplace_back(res);
       }
       if ((size_t)res->mPtr % GPUCA_BUFFER_ALIGNMENT) {
@@ -722,6 +725,7 @@ size_t GPUReconstruction::AllocateRegisteredMemory(int16_t ires, GPUOutputContro
 
 void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
 {
+  stdspinlock spinlock(mMemoryMutex);
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
     char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
     if ((type & GPUMemoryResource::MEMORY_STACK)) {
@@ -763,6 +767,7 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
 
 void* GPUReconstruction::AllocateVolatileDeviceMemory(size_t size)
 {
+  stdspinlock spinlock(mMemoryMutex);
   if (mVolatileMemoryStart == nullptr) {
     mVolatileMemoryStart = mDeviceMemoryPool;
   }
@@ -788,6 +793,7 @@ void* GPUReconstruction::AllocateVolatileMemory(size_t size, bool device)
     return AllocateVolatileDeviceMemory(size);
   }
   char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
+  stdspinlock spinlock(mMemoryMutex);
   mVolatileChunks.emplace_back(retVal, alignedDeleter());
   return retVal;
 }
@@ -912,6 +918,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag, cons
     res->mPtrDevice = nullptr;
   }
   if (!proc) {
+    stdspinlock spinlock(mMemoryMutex);
     mHostMemoryPoolEnd = std::get<0>(mNonPersistentMemoryStack.back());
     mDeviceMemoryPoolEnd = std::get<1>(mNonPersistentMemoryStack.back());
     mNonPersistentIndividualAllocations.resize(std::get<2>(mNonPersistentMemoryStack.back()));
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index b98f5660a933e..b7eda77aeb9fe 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -25,6 +25,7 @@
 #include <functional>
 #include <unordered_map>
 #include <unordered_set>
+#include <atomic>
 
 #include "GPUDataTypes.h"
 #include "GPUMemoryResource.h"
@@ -390,6 +391,7 @@ class GPUReconstruction
   std::vector<std::unique_ptr<char[], alignedDeleter>> mNonPersistentIndividualDirectAllocations;
   std::vector<std::unique_ptr<char[], alignedDeleter>> mDirectMemoryChunks;
   std::vector<std::unique_ptr<char[], alignedDeleter>> mVolatileChunks;
+  std::atomic_flag mMemoryMutex = ATOMIC_FLAG_INIT;
 
   std::unique_ptr<GPUReconstructionPipelineContext> mPipelineContext;
 
diff --git a/GPU/GPUTracking/utils/stdspinlock.h b/GPU/GPUTracking/utils/stdspinlock.h
new file mode 100644
index 0000000000000..14bf95c45968e
--- /dev/null
+++ b/GPU/GPUTracking/utils/stdspinlock.h
@@ -0,0 +1,44 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file stdspinlock.h
+/// \author David Rohr
+
+#ifndef Q_STDSPINLOCK_H
+#define Q_STDSPINLOCK_H
+
+#include <atomic>
+
+class stdspinlock
+{
+ public:
+  stdspinlock(std::atomic_flag& flag) : mFlag(&flag)
+  {
+    while (flag.test_and_set(std::memory_order_acquire)) {
+    }
+  }
+  void release()
+  {
+    if (mFlag) {
+      mFlag->clear(std::memory_order_release);
+      mFlag = nullptr;
+    }
+  }
+  ~stdspinlock()
+  {
+    release();
+  }
+
+ private:
+  std::atomic_flag* mFlag;
+};
+
+#endif // Q_STDSPINLOCK_H

From d2bee7d7650be78ca39ee230e00f6c50191c97c0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 17 Oct 2025 11:26:17 +0200
Subject: [PATCH 0937/1764] GPU TPC: Free sector tracking memory earlier

---
 GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx | 3 +++
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx          | 7 ++++++-
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.h            | 1 +
 3 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index d13e8d5544631..7ab2cfeccee80 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -224,6 +224,9 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       GPUInfo("Sector %u, Number of tracks: %d", iSector, *trk.NTracks());
     }
     DoDebugAndDump(RecoStep::TPCSectorTracking, GPUChainTrackingDebugFlags::TPCSectorTracks, trk, &GPUTPCTracker::DumpTrackHits, *mDebugFile);
+    if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && !trk.MemoryReuseAllowed()) {
+      mRec->PopNonPersistentMemory(RecoStep::TPCSectorTracking, qStr2Tag("TPCSLTRK"), &trk);
+    }
   });
   mRec->SetNActiveThreadsOuterLoop(1);
   if (error) {
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index 7897de4f2002e..c5e6a21460a36 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -84,10 +84,15 @@ void* GPUTPCTracker::SetPointersCommon(void* mem)
   return mem;
 }
 
+bool GPUTPCTracker::MemoryReuseAllowed()
+{
+  return !mRec->GetProcessingSettings().keepDisplayMemory && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
+}
+
 void GPUTPCTracker::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();
-  bool reuseCondition = !mRec->GetProcessingSettings().keepDisplayMemory && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
+  bool reuseCondition = MemoryReuseAllowed();
   GPUMemoryReuse reLinks{reuseCondition, GPUMemoryReuse::REUSE_1TO1, GPUMemoryReuse::TrackerDataLinks, (uint16_t)(mISector % mRec->GetProcessingSettings().nStreams)};
   mMemoryResLinks = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersDataLinks, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK, "TPCSectorLinks", reLinks);
   mMemoryResSectorScratch = mRec->RegisterMemoryAllocation(this, &GPUTPCTracker::SetPointersDataScratch, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_STACK | GPUMemoryResource::MEMORY_CUSTOM, "TPCSectorScratch");
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
index 2667da4a53977..aee429c959e98 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
@@ -103,6 +103,7 @@ class GPUTPCTracker : public GPUProcessor
   void* SetPointersTracklets(void* mem);
   void* SetPointersOutput(void* mem);
   void RegisterMemoryAllocation();
+  bool MemoryReuseAllowed();
 
   int16_t MemoryResLinks() const { return mMemoryResLinks; }
   int16_t MemoryResScratchHost() const { return mMemoryResScratchHost; }

From eaeee050675e030398303045b8477c82ded304eb Mon Sep 17 00:00:00 2001
From: amorsch <andreas.morsch@cern.ch>
Date: Thu, 16 Oct 2025 20:44:09 +0200
Subject: [PATCH 0938/1764] corrected positions of volumes in RB24 after recent
 Cave updates

---
 Detectors/FIT/FDD/base/src/Geometry.cxx   | 2 +-
 Detectors/Passive/src/Compensator.cxx     | 2 +-
 Detectors/ZDC/simulation/src/Detector.cxx | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/FIT/FDD/base/src/Geometry.cxx b/Detectors/FIT/FDD/base/src/Geometry.cxx
index 441a30fdda44f..149c086f4fc81 100644
--- a/Detectors/FIT/FDD/base/src/Geometry.cxx
+++ b/Detectors/FIT/FDD/base/src/Geometry.cxx
@@ -152,7 +152,7 @@ void Geometry::buildGeometry()
   if (!vCaveRB24) {
     LOG(fatal) << "Could not find the top volume for A-side";
   }
-  const Float_t kPosFDA = 1696.67 - 1313.347; // z-center of assembly (cm)
+  const Float_t kPosFDA = 1696.67 - 1313.347 - 75.; // z-center of assembly (cm)
   vCaveRB24->AddNode(vFDAarray, 1, new TGeoTranslation(0., 0., kPosFDA - kFDACelldz / 2. - 0.1));
   vCaveRB24->AddNode(vFDAarray, 2, new TGeoTranslation(0., 0., kPosFDA + kFDACelldz / 2. + 0.1));
 
diff --git a/Detectors/Passive/src/Compensator.cxx b/Detectors/Passive/src/Compensator.cxx
index 68e344495aaab..25b3e2a475340 100644
--- a/Detectors/Passive/src/Compensator.cxx
+++ b/Detectors/Passive/src/Compensator.cxx
@@ -110,7 +110,7 @@ void Compensator::ConstructGeometry()
 void Compensator::createCompensator()
 {
   auto top = gGeoManager->GetVolume("caveRB24");
-  top->AddNode(createMagnetYoke(), 1, new TGeoTranslation(0., 0., 1075. - 1313.347));
+  top->AddNode(createMagnetYoke(), 1, new TGeoTranslation(0., 0., 1000. - 1313.347));
 }
 
 TGeoVolume* Compensator::createMagnetYoke()
diff --git a/Detectors/ZDC/simulation/src/Detector.cxx b/Detectors/ZDC/simulation/src/Detector.cxx
index c6f91d9c2164f..b8b81379a4dff 100644
--- a/Detectors/ZDC/simulation/src/Detector.cxx
+++ b/Detectors/ZDC/simulation/src/Detector.cxx
@@ -2355,7 +2355,7 @@ void Detector::createDetectors()
 
   // --- Positioning the ZEM into the ZDC - rotation for 90 degrees
   // NB -> ZEM is positioned in cave volume
-  const float z0 = 1313.3475; // center of caveRB24 mother volume
+  const float z0 = 1313.3475 + 75.; // center of caveRB24 mother volume
   TVirtualMC::GetMC()->Gspos("ZEM ", 1, "caveRB24", -Geometry::ZEMPOSITION[0], Geometry::ZEMPOSITION[1], Geometry::ZEMPOSITION[2] + Geometry::ZEMDIMENSION[0] - z0, irotzem1, "ONLY");
 
   // Second EM ZDC (same side w.r.t. IP, just on the other side w.r.t. beam pipe)

From 516303f14755dad43373dee1227a8169685fe2ab Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Sun, 12 Oct 2025 17:38:00 +0200
Subject: [PATCH 0939/1764] Example to run HERWIG7 with o2-sim

---
 run/SimExamples/HepMC_HERWIG7/LHC.in      |  49 +++++++++
 run/SimExamples/HepMC_HERWIG7/README.md   |  25 +++++
 run/SimExamples/HepMC_HERWIG7/runo2sim.sh | 124 ++++++++++++++++++++++
 3 files changed, 198 insertions(+)
 create mode 100644 run/SimExamples/HepMC_HERWIG7/LHC.in
 create mode 100755 run/SimExamples/HepMC_HERWIG7/README.md
 create mode 100755 run/SimExamples/HepMC_HERWIG7/runo2sim.sh

diff --git a/run/SimExamples/HepMC_HERWIG7/LHC.in b/run/SimExamples/HepMC_HERWIG7/LHC.in
new file mode 100644
index 0000000000000..ef3641bf7b174
--- /dev/null
+++ b/run/SimExamples/HepMC_HERWIG7/LHC.in
@@ -0,0 +1,49 @@
+# -*- ThePEG-repository -*-
+################################################################################
+# This file contains our best tune to UE data from ATLAS at 7 TeV. More recent
+# tunes and tunes for other centre-of-mass energies as well as more usage
+# instructions can be obtained from this Herwig wiki page:
+# http://projects.hepforge.org/herwig/trac/wiki/MB_UE_tunes
+# The model for soft interactions and diffractions is explained in
+# [S. Gieseke, P. Kirchgaesser, F. Loshaj, arXiv:1612.04701]
+################################################################################
+
+read snippets/PPCollider.in
+
+##################################################
+# Technical parameters for this run
+##################################################
+cd /Herwig/Generators
+##################################################
+# LHC physics parameters (override defaults here)
+##################################################
+set EventGenerator:EventHandler:LuminosityFunction:Energy 13600.0
+
+# Minimum Bias
+read snippets/MB.in
+
+# Recommended set of parameters for MB/UE runs
+
+set /Herwig/Hadronization/ColourReconnector:ReconnectionProbability 0.5
+set /Herwig/UnderlyingEvent/MPIHandler:pTmin0 3.502683
+set /Herwig/UnderlyingEvent/MPIHandler:InvRadius 1.402055
+set /Herwig/UnderlyingEvent/MPIHandler:Power 0.416852
+set /Herwig/Partons/RemnantDecayer:ladderPower -0.08
+set /Herwig/Partons/RemnantDecayer:ladderNorm 0.95
+
+##################################################
+# Analyses
+##################################################
+## Hepmc file creation
+create ThePEG::HepMCFile /Herwig/Analysis/HepMC HepMCAnalysis.so
+set /Herwig/Analysis/HepMC:PrintEvent 10
+set /Herwig/Analysis/HepMC:Format GenEvent
+set /Herwig/Analysis/HepMC:Units GeV_mm
+set /Herwig/Analysis/HepMC:Filename herwig.hepmc
+insert /Herwig/Generators/EventGenerator:AnalysisHandlers 0 /Herwig/Analysis/HepMC
+
+
+##################################################
+# Save run for later usage with 'Herwig run'
+##################################################
+saverun LHC EventGenerator
\ No newline at end of file
diff --git a/run/SimExamples/HepMC_HERWIG7/README.md b/run/SimExamples/HepMC_HERWIG7/README.md
new file mode 100755
index 0000000000000..6366c1f076672
--- /dev/null
+++ b/run/SimExamples/HepMC_HERWIG7/README.md
@@ -0,0 +1,25 @@
+<!-- doxy
+\page refrunSimExamplesHepMC_HERWIG7 Example HepMC_HERWIG7
+/doxy -->
+
+The usage of HERWIG7 with the O2 machinery is presented in this short manual.
+The example generates HEPMC3 data using the Herwig executable and then
+reads the data via the hepmc generator defined in o2-sim.
+
+# Files description
+
+Two files are provided in the folder:
+- **runo2sim.sh** &rarr; allows the generation of events using o2-sim
+- **LHC.in** &rarr; example input file for the configuration of the HERWIG generator
+
+## runo2sim.sh
+
+The script works after loading any O2sim version containing HERWIG7 as a package (dependence of AliGenO2).
+
+If no parameters are provided, the script will run with default values (energy and nEvents provided in the LHC.in file), but few flags are available to change the settings on-the-fly:
+- **-m , --more** &rarr; feeds the simulation with advanced parameters provided to the configuration key flags
+- **-n , --nevents** &rarr; changes the number of events in the .in file or gets the one in the file if no events are provided
+- **-i , --input** &rarr; .in filename for HERWIG7 configuration
+- **-j , --jobs** &rarr; sets the number of workers (2 jobs by default)
+- **-e , --ecm** &rarr; sets the center-of-mass energy in the input file
+- **-h , --help** &rarr; prints usage instructions
\ No newline at end of file
diff --git a/run/SimExamples/HepMC_HERWIG7/runo2sim.sh b/run/SimExamples/HepMC_HERWIG7/runo2sim.sh
new file mode 100755
index 0000000000000..536a47de01d5c
--- /dev/null
+++ b/run/SimExamples/HepMC_HERWIG7/runo2sim.sh
@@ -0,0 +1,124 @@
+#!/usr/bin/env bash
+#
+# This is a simple simulation example on how to generate HEPMC3 data from
+# HERWIG7 and run an ALICE simulation using the o2-sim executable
+# In the script we assume that the .run file has the same name of the input file, so change it accordingly.
+# This script works only with AliGenO2 version containing the HERWIG7 generator
+
+# HERWIG7 and O2 must be loaded
+set -x
+if [ ! "${HERWIG_ROOT}" ]; then
+    echo "This needs HERWIG7 loaded; alienv enter ..."
+    exit 1
+fi
+
+[ ! "${O2_ROOT}" ] && echo "Error: This needs O2 loaded" && exit 2
+
+NEV=-1
+more=""
+input="LHC"
+eCM=-1
+JOBS=2
+
+usage()
+{
+    cat <<EOF
+Usage: $0 [OPTIONS]
+
+Options:
+
+  -m,--more    CONFIG      More configurations ($more)
+  -n,--nevents EVENTS      Number of events ($nev)
+  -i,--input   INPUT       Options file fed to HERWIG7 ($input)
+  -j,--jobs    JOBS        Number of jobs ($JOBS)
+  -e,--ecm     ENERGY      Center-of-Mass energy
+  -h,--help                Print these instructions
+  --                       Rest of command line sent to o2-sim
+
+COMMAND must be quoted if it contains spaces or other special
+characters
+
+Below follows the help output of o2-sim
+
+EOF
+}
+
+if [ "$#" -lt 2 ]; then
+    echo "Running with default values"
+fi
+
+while test $# -gt 0 ; do
+    case $1 in
+        -m|--more)    more="$2" ; shift ;;
+        -n|--nevents) NEV=$2 ; shift ;;
+        -i|--input)   input=$2 ; shift ;;
+        -j|--jobs)    JOBS=$2 ; shift ;;
+        -e|--ecm)     eCM=$2 ; shift ;;
+        -h|--help) usage; o2-sim --help full ; exit 0 ;;
+        --)           shift ; break ;;
+        *) echo "Unknown option '$1', did you forget '--'?" >/dev/stderr
+           exit 3
+           ;;
+    esac
+    shift
+done
+
+echo "Input file: $input"
+
+if [ ! -f $input.in ]; then
+    echo "Error: Input file $input.in not found"
+    exit 4
+else
+    if grep -Fq "saverun" $input.in; then
+        sed -i "/saverun/c\saverun $input EventGenerator" $input.in
+    else
+        echo "saverun $input EventGenerator" >> $input.in
+    fi
+fi
+
+# Set number of events to write in HepMC in input file
+if [ ! $NEV -eq -1 ]; then
+    echo "Setting number of events to $NEV"
+    if grep -Fq "PrintEvent" $input.in; then
+        sed -i "/PrintEvent/c\set /Herwig/Analysis/HepMC:PrintEvent $NEV" $input.in
+    else
+        echo "set /Herwig/Analysis/HepMC:PrintEvent $NEV" >> $input.in
+    fi
+else
+    echo "Number of events not set, checking input file..."
+    if grep -Fq "PrintEvent" $input.in; then
+        NEV=$(grep -F "PrintEvent" $input.in | awk '{print $3}')
+        echo "Number of events set to $NEV"
+    else
+        echo "Error: Number of events not set in HERWIG7"
+        exit 5
+    fi
+fi
+
+# Set ECM
+
+if [ ! $eCM -eq -1 ]; then
+    echo "Setting eCM to $eCM"
+    if grep -Fq "Energy" $input.in; then
+        sed -i "/Energy/c\set EventGenerator:EventHandler:LuminosityFunction:Energy $eCM" $input.in
+    else
+        echo "set EventGenerator:EventHandler:LuminosityFunction:Energy $eCM" >> $input.in
+    fi
+else
+    echo "Energy not set, checking input file..."
+    if grep -Fq "Energy" $input.in; then
+        eCM=$(grep -F "Energy" $input.in | awk '{print $3}')
+        echo "Energy set to $eCM"
+    else
+        echo "Error: eCM not set in HERWIG7"
+        exit 6
+    fi
+fi
+
+# Generating events using HERWIG7
+Herwig read --repo=${HERWIG_ROOT}/share/Herwig/HerwigDefaults.rpo $input.in
+Herwig run -N $NEV $input.run
+
+# Starting simulation with o2-sim
+o2-sim -j $JOBS -n ${NEV} -g hepmc  \
+       --configKeyValues "GeneratorFileOrCmd.fileNames=herwig.hepmc;${more}"

From 009371b997c872e4a9add2f9bdf238096992a30a Mon Sep 17 00:00:00 2001
From: swenzel <sandro.wenzel@cern.ch>
Date: Fri, 9 May 2025 12:14:57 +0200
Subject: [PATCH 0940/1764] ability to take inject external vertices in
 collision context

an important step for the mc-on-data embedding
---
 .../DigitizationContext.h                     |  6 ++
 .../simulation/src/DigitizationContext.cxx    | 11 +++
 Steer/src/CollisionContextTool.cxx            | 89 ++++++++++++++++++-
 3 files changed, 105 insertions(+), 1 deletion(-)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/DigitizationContext.h b/DataFormats/simulation/include/SimulationDataFormat/DigitizationContext.h
index b718b2d5eb804..0dc3806e52cf2 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/DigitizationContext.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/DigitizationContext.h
@@ -141,6 +141,12 @@ class DigitizationContext
   // have to have same vertex, as well as event ids associated to same collision.
   void sampleInteractionVertices(o2::dataformats::MeanVertexObject const& v);
 
+  // Function allowing to inject interaction vertixes from the outside.
+  // Useful when this is given from data for instance. The vertex vector needs to be of same
+  // size as the interaction record.
+  // Returns 0 if success. 1 if there is a problem.
+  int setInteractionVertices(std::vector<math_utils::Point3D<float>> const& vertices);
+
   // helper functions to save and load a context
   void saveToFile(std::string_view filename) const;
 
diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index dc3c560a1485b..9e8a125c06fa4 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -635,6 +635,17 @@ struct pair_hash {
 };
 } // namespace
 
+int DigitizationContext::setInteractionVertices(std::vector<math_utils::Point3D<float>> const& external_vertices)
+{
+  if (external_vertices.size() != mEventRecords.size()) {
+    LOG(error) << "Size mismatch with event record";
+    return 1;
+  }
+  mInteractionVertices.clear();
+  std::copy(external_vertices.begin(), external_vertices.end(), std::back_inserter(mInteractionVertices));
+  return 0;
+}
+
 void DigitizationContext::sampleInteractionVertices(o2::dataformats::MeanVertexObject const& meanv)
 {
   // mapping of source x event --> index into mInteractionVertices
diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index 9fc3e548ff213..1733caaa92eed 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -28,6 +28,7 @@
 #include <CCDB/BasicCCDBManager.h>
 #include "DataFormatsParameters/GRPLHCIFData.h"
 #include "SimConfig/SimConfig.h"
+#include <filesystem>
 
 //
 // Created by Sandro Wenzel on 13.07.21.
@@ -59,6 +60,10 @@ struct Options {
                                            // format is path prefix
   std::string vertexModeString{"kNoVertex"}; // Vertex Mode; vertices will be assigned to collisions of mode != kNoVertex
   o2::conf::VertexMode vertexMode = o2::conf::VertexMode::kNoVertex;
+  std::string external_path = ""; // optional external path where we can directly take the collision contexts
+                                  // This is useful when someone else is creating the contexts (MC-data embedding) and we
+                                  // merely want to pass these through. If this is given, we simply take the timeframe ID, number of orbits
+                                  // and copy the right amount of timeframes into the destination folder (implies individualTFextraction)
 };
 
 enum class InteractionLockMode {
@@ -210,7 +215,9 @@ bool parseOptions(int argc, char* argv[], Options& optvalues)
     "with-vertices", bpo::value<std::string>(&optvalues.vertexModeString)->default_value("kNoVertex"), "Assign vertices to collisions. Argument is the vertex mode. Defaults to no vertexing applied")(
     "timestamp", bpo::value<long>(&optvalues.timestamp)->default_value(-1L), "Timestamp for CCDB queries / anchoring")(
     "extract-per-timeframe", bpo::value<std::string>(&optvalues.individualTFextraction)->default_value(""),
-    "Extract individual timeframe contexts. Format required: time_frame_prefix[:comma_separated_list_of_signals_to_offset]");
+    "Extract individual timeframe contexts. Format required: time_frame_prefix[:comma_separated_list_of_signals_to_offset]")(
+    "import-external", bpo::value<std::string>(&optvalues.external_path)->default_value(""),
+    "Take collision contexts (per timeframe) from external files for instance for data-anchoring use-case. Needs timeframeID and number of orbits to be given as well.");
 
   options.add_options()("help,h", "Produce help message.");
 
@@ -249,6 +256,47 @@ bool parseOptions(int argc, char* argv[], Options& optvalues)
   return true;
 }
 
+bool copy_collision_context(const std::string& external_path, int this_tf_id, int target_tf_id)
+{
+  namespace fs = std::filesystem;
+  try {
+    // Construct source file path
+    fs::path filename = fs::path(external_path) / ("collission_context_" + std::to_string(this_tf_id) + ".root");
+
+    LOG(info) << "Checking existence of file: " << filename;
+
+    if (fs::exists(filename)) {
+      // Build destination path
+      std::string path_prefix = "tf"; // Can be made configurable
+      std::stringstream destination_path_stream;
+      destination_path_stream << path_prefix << (target_tf_id) << "/collisioncontext.root";
+      fs::path destination_path = destination_path_stream.str();
+
+      // Ensure parent directory exists
+      fs::path destination_dir = destination_path.parent_path();
+      if (!fs::exists(destination_dir)) {
+        fs::create_directories(destination_dir);
+        LOG(info) << "Created directory: " << destination_dir;
+      }
+
+      // Copy file
+      fs::copy_file(filename, destination_path, fs::copy_options::overwrite_existing);
+      LOG(info) << "Copied file to: " << destination_path;
+      return true;
+    } else {
+      LOG(warning) << "Source file does not exist: " << filename;
+      return false;
+    }
+  } catch (const fs::filesystem_error& e) {
+    LOG(error) << "Filesystem error: " << e.what();
+    return false;
+  } catch (const std::exception& e) {
+    LOG(error) << "Unexpected error: " << e.what();
+    return false;
+  }
+  return true;
+}
+
 int main(int argc, char* argv[])
 {
   Options options;
@@ -259,6 +307,45 @@ int main(int argc, char* argv[])
   // init params
   o2::conf::ConfigurableParam::updateFromString(options.configKeyValues);
 
+  // See if this is external mode, which simplifies things
+  if (options.external_path.size() > 0) {
+    // in this mode, we don't actually have to do much work.
+    // all we do is to
+    // - determine how many timeframes are asked
+    // - check if the right files are present in the external path (someone else needs to create/put them there)
+    // - check if the given contexts are consistent with options given (orbitsPerTF, ...)
+    // - copy the files into the MC destination folder (this implies timeframeextraction mode)
+    // - return
+
+    if (options.orbits < 0) {
+      LOG(error) << "External mode; orbits need to be given";
+      return 1;
+    }
+
+    if (options.orbitsPerTF == 0) {
+      LOG(error) << "External mode; need to have orbitsPerTF";
+      return 1;
+    }
+
+    if (options.individualTFextraction.size() == 0) {
+      LOG(error) << "External mode: This requires --extract-per-timeframe";
+      return 1;
+    }
+
+    // calculate number of timeframes
+    auto num_timeframes = options.orbits / options.orbitsPerTF;
+    LOG(info) << "External mode for " << num_timeframes << " consecutive timeframes; starting from " << options.tfid;
+
+    // loop over all timeframe ids - check if file is present - (check consistency) - copy to final destination
+    for (int i = 0; i < num_timeframes; ++i) {
+      auto this_tf_id = options.tfid + i;
+      if (!copy_collision_context(options.external_path, this_tf_id, i + 1)) {
+        return 1;
+      }
+    }
+    return 0;
+  }
+
   // init random generator
   gRandom->SetSeed(options.seed);
 

From 527dbd46a176affbcc7d624fd81e915bc5a10b41 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 10 Oct 2025 16:31:33 +0200
Subject: [PATCH 0941/1764] ITS3: remove unused files

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITS3Reconstruction/FastMultEst.h  |  66 ------
 .../ITS3Reconstruction/FastMultEstConfig.h    |  57 -----
 .../ITS3/reconstruction/src/FastMultEst.cxx   | 207 ------------------
 .../reconstruction/src/FastMultEstConfig.cxx  |  22 --
 .../ITS3/workflow/src/TrackerSpec.cxx         |   7 -
 5 files changed, 359 deletions(-)
 delete mode 100644 Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/FastMultEst.h
 delete mode 100644 Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/FastMultEstConfig.h
 delete mode 100644 Detectors/Upgrades/ITS3/reconstruction/src/FastMultEst.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/reconstruction/src/FastMultEstConfig.cxx

diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/FastMultEst.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/FastMultEst.h
deleted file mode 100644
index e9da619c0efbf..0000000000000
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/FastMultEst.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef ALICEO2_ITS3_FASTMULTEST_
-#define ALICEO2_ITS3_FASTMULTEST_
-
-#include "ITSMFTReconstruction/ChipMappingITS.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "DataFormatsITS3/CompCluster.h"
-#include <DataFormatsITSMFT/PhysTrigger.h>
-#include "ITS3Reconstruction/FastMultEstConfig.h"
-#include <gsl/span>
-#include <array>
-
-namespace o2
-{
-namespace its3
-{
-
-struct FastMultEst {
-
-  static constexpr int NLayers = o2::itsmft::ChipMappingITS::NLayers;
-
-  float mult = 0.;             /// estimated signal clusters multipliciy at reference (1st?) layer
-  float noisePerChip = 0.;     /// estimated or imposed noise per chip
-  float cov[3] = {0.};         /// covariance matrix of estimation
-  float chi2 = 0.;             /// chi2
-  int nLayersUsed = 0;         /// number of layers actually used
-  uint32_t lastRandomSeed = 0; /// state of the gRandom before
-
-  std::array<int, NLayers> nClPerLayer{0}; // measured N Cl per layer selectROFs
-  FastMultEst();
-
-  static uint32_t getCurrentRandomSeed();
-  int selectROFs(const gsl::span<const o2::itsmft::ROFRecord> rofs, const gsl::span<const o2::itsmft::CompClusterExt> clus,
-                 const gsl::span<const o2::itsmft::PhysTrigger> trig, std::vector<bool>& sel);
-
-  void fillNClPerLayer(const gsl::span<const o2::itsmft::CompClusterExt>& clusters);
-  float process(const std::array<int, NLayers> ncl)
-  {
-    return FastMultEstConfig::Instance().imposeNoisePerChip > 0 ? processNoiseImposed(ncl) : processNoiseFree(ncl);
-  }
-  float processNoiseFree(const std::array<int, NLayers> ncl);
-  float processNoiseImposed(const std::array<int, NLayers> ncl);
-  float process(const gsl::span<const o2::itsmft::CompClusterExt>& clusters)
-  {
-    fillNClPerLayer(clusters);
-    return process(nClPerLayer);
-  }
-  static bool sSeedSet;
-
-  ClassDefNV(FastMultEst, 1);
-};
-
-} // namespace its3
-} // namespace o2
-
-#endif
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/FastMultEstConfig.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/FastMultEstConfig.h
deleted file mode 100644
index 1857176b19f1f..0000000000000
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/FastMultEstConfig.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file  FastMultEstConfig.h
-/// \brief Configuration parameters for ITS fast multiplicity estimator
-/// \author ruben.shahoyan@cern.ch
-
-#ifndef ALICEO2_ITS_FASTMULTESTCONF_H_
-#define ALICEO2_ITS_FASTMULTESTCONF_H_
-
-#include "CommonUtils/ConfigurableParam.h"
-#include "CommonUtils/ConfigurableParamHelper.h"
-#include "ITSMFTReconstruction/ChipMappingITS.h"
-
-namespace o2
-{
-namespace its
-{
-struct FastMultEstConfig : public o2::conf::ConfigurableParamHelper<FastMultEstConfig> {
-  static constexpr int NLayers = 7; // FIXME
-
-  /// acceptance correction per layer (relative to 1st one)
-  float accCorr[NLayers] = {1.f, 0.895, 0.825, 0.803, 0.720, 0.962, 0.911};
-  int firstLayer = 3;                            /// 1st layer to account
-  int lastLayer = 6;                             /// last layer to account
-  float imposeNoisePerChip = 1.e-7 * 1024 * 512; // assumed noise, free parameter if<0
-
-  // cuts to reject to low or too high mult events
-  float cutMultClusLow = 0;      /// reject ROF with estimated cluster mult. below this value (no cut if <0)
-  float cutMultClusHigh = -1;    /// reject ROF with estimated cluster mult. above this value (no cut if <0)
-  float cutMultVtxLow = -1;      /// reject seed vertex if its multiplicity below this value (no cut if <0)
-  float cutMultVtxHigh = -1;     /// reject seed vertex if its multiplicity above this value (no cut if <0)
-  float cutRandomFraction = -1.; /// apply random cut rejecting requested fraction
-  int randomSeed = 0;            /// 0 - do not seet seed, >0 : set as is, <0 : use current time
-  bool preferTriggered = true;   /// prefer ROFs with highest number of physics triggers
-
-  bool isMultCutRequested() const { return cutMultClusLow >= 0.f && cutMultClusHigh > 0.f; };
-  bool isVtxMultCutRequested() const { return cutMultVtxLow >= 0.f && cutMultVtxHigh > 0.f; };
-  bool isPassingRandomRejection() const;
-  bool isPassingMultCut(float mult) const { return mult >= cutMultClusLow && (mult <= cutMultClusHigh || cutMultClusHigh <= 0.f); }
-  bool isPassingVtxMultCut(int mult) const { return mult >= cutMultVtxLow && (mult <= cutMultVtxHigh || cutMultVtxHigh <= 0.f); }
-
-  O2ParamDef(FastMultEstConfig, "fastMultConfig");
-};
-
-} // namespace its
-} // namespace o2
-
-#endif
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/FastMultEst.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/FastMultEst.cxx
deleted file mode 100644
index fa2ce319328b5..0000000000000
--- a/Detectors/Upgrades/ITS3/reconstruction/src/FastMultEst.cxx
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "ITS3Reconstruction/FastMultEst.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
-#include "Framework/Logger.h"
-#include <ctime>
-#include <cstring>
-#include <TRandom.h>
-
-using namespace o2::its;
-
-bool FastMultEst::sSeedSet = false;
-
-///______________________________________________________
-FastMultEst::FastMultEst()
-{
-  if (!sSeedSet && FastMultEstConfig::Instance().cutRandomFraction > 0.f) {
-    sSeedSet = true;
-    if (FastMultEstConfig::Instance().randomSeed > 0) {
-      gRandom->SetSeed(FastMultEstConfig::Instance().randomSeed);
-    } else if (FastMultEstConfig::Instance().randomSeed < 0) {
-      gRandom->SetSeed(std::time(nullptr) % 0xffff);
-    }
-  }
-}
-
-///______________________________________________________
-/// find multiplicity for given set of clusters
-void FastMultEst::fillNClPerLayer(const gsl::span<const o2::itsmft::CompClusterExt>& clusters)
-{
-  int lr = FastMultEst::NLayers - 1, nchAcc = o2::itsmft::ChipMappingITS::getNChips() - o2::itsmft::ChipMappingITS::getNChipsPerLr(lr);
-  std::memset(&nClPerLayer[0], 0, sizeof(int) * FastMultEst::NLayers);
-  for (int i = clusters.size(); i--;) { // profit from clusters being ordered in chip increasing order
-    while (clusters[i].getSensorID() < nchAcc) {
-      assert(lr >= 0);
-      nchAcc -= o2::itsmft::ChipMappingITS::getNChipsPerLr(--lr);
-    }
-    nClPerLayer[lr]++;
-  }
-}
-
-///______________________________________________________
-/// find multiplicity for given number of clusters per layer
-float FastMultEst::processNoiseFree(const std::array<int, NLayers> ncl)
-{
-  // we assume that on the used layers the observed number of clusters is defined by the
-  // the noise ~ nu * Nchips and contribution from the signal tracks Ntr*mAccCorr
-  const auto& conf = FastMultEstConfig::Instance();
-
-  float mat[3] = {0}, b[2] = {0};
-  nLayersUsed = 0;
-  for (int il = conf.firstLayer; il <= conf.lastLayer; il++) {
-    if (ncl[il] > 0) {
-      int nch = o2::itsmft::ChipMappingITS::getNChipsPerLr(il);
-      float err2i = 1. / ncl[il];
-      float m2n = nch * err2i;
-      mat[0] += err2i * conf.accCorr[il] * conf.accCorr[il];
-      mat[2] += nch * m2n;
-      mat[1] += conf.accCorr[il] * m2n; // non-diagonal element
-      b[0] += conf.accCorr[il];
-      b[1] += nch;
-      nLayersUsed++;
-    }
-  }
-  mult = noisePerChip = chi2 = -1;
-  float det = mat[0] * mat[2] - mat[1] * mat[1];
-  if (nLayersUsed < 2 || std::abs(det) < 1e-15) {
-    return -1;
-  }
-  float detI = 1. / det;
-  mult = detI * (b[0] * mat[2] - b[1] * mat[1]);
-  noisePerChip = detI * (b[1] * mat[0] - b[0] * mat[1]);
-  cov[0] = mat[2] * detI;
-  cov[2] = mat[0] * detI;
-  cov[1] = -mat[1] * detI;
-  chi2 = 0.;
-  for (int il = conf.firstLayer; il <= conf.lastLayer; il++) {
-    if (ncl[il] > 0) {
-      int nch = o2::itsmft::ChipMappingITS::getNChipsPerLr(il);
-      float diff = mult * conf.accCorr[il] + nch * noisePerChip - ncl[il];
-      chi2 += diff * diff / ncl[il];
-    }
-  }
-  chi2 = nLayersUsed > 2 ? chi2 / (nLayersUsed - 2) : 0.;
-  return mult > 0 ? mult : 0;
-}
-
-///______________________________________________________
-/// find multiplicity for given number of clusters per layer with mean noise imposed
-float FastMultEst::processNoiseImposed(const std::array<int, NLayers> ncl)
-{
-  // we assume that on the used layers the observed number of clusters is defined by the
-  // the noise ~ nu * Nchips and contribution from the signal tracks Ntr*conf.accCorr
-  //
-  // minimize the form sum_lr (noise_i - mu nchips_i)^2 / (mu nchips_i) + lambda_i * (noise_i + mult*acc_i - ncl_i)
-  // whith noise_i being estimate of the noise clusters in nchips_i of layer i, mu is the mean noise per chip,
-  // mult is the number of signal clusters on the ref. (1st) layer and the acc_i is the acceptance of layer i wrt 1st.
-  // The lambda_i is hust a Lagrange multiplier.
-
-  const auto& conf = FastMultEstConfig::Instance();
-  float w2sum = 0., wnsum = 0., wsum = 0.;
-  nLayersUsed = 0;
-  for (int il = conf.firstLayer; il <= conf.lastLayer; il++) {
-    if (ncl[il] > 0) {
-      float nchInv = 1. / o2::itsmft::ChipMappingITS::getNChipsPerLr(il);
-      w2sum += conf.accCorr[il] * conf.accCorr[il] * nchInv;
-      wnsum += ncl[il] * nchInv * conf.accCorr[il];
-      wsum += conf.accCorr[il];
-      nLayersUsed++;
-    }
-  }
-  mult = 0;
-  chi2 = -1;
-  noisePerChip = conf.imposeNoisePerChip;
-  if (nLayersUsed < 1) {
-    return -1;
-  }
-  auto w2sumI = 1. / w2sum;
-  mult = (wnsum - noisePerChip * wsum) * w2sumI;
-  cov[0] = wnsum * w2sumI;
-  cov[2] = 0.;
-  cov[1] = 0.;
-
-  chi2 = 0.;
-  for (int il = conf.firstLayer; il <= conf.lastLayer; il++) {
-    if (ncl[il] > 0) {
-      float noise = ncl[il] - mult * conf.accCorr[il], estNoise = o2::itsmft::ChipMappingITS::getNChipsPerLr(il) * noisePerChip;
-      float diff = noise - estNoise;
-      chi2 += diff * diff / estNoise;
-    }
-  }
-  chi2 = nLayersUsed > 2 ? chi2 / (nLayersUsed - 2) : 0.;
-  return mult > 0 ? mult : 0;
-}
-
-int FastMultEst::selectROFs(const gsl::span<const o2::itsmft::ROFRecord> rofs, const gsl::span<const o2::itsmft::CompClusterExt> clus,
-                            const gsl::span<const o2::itsmft::PhysTrigger> trig, std::vector<bool>& sel)
-{
-  int nrof = rofs.size(), nsel = 0;
-  const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
-  sel.clear();
-  sel.resize(nrof, true); // by default select all
-  lastRandomSeed = gRandom->GetSeed();
-  if (multEstConf.isMultCutRequested()) {
-    for (uint32_t irof = 0; irof < nrof; irof++) {
-      nsel += sel[irof] = multEstConf.isPassingMultCut(process(rofs[irof].getROFData(clus)));
-    }
-  } else {
-    nsel = nrof;
-  }
-  using IdNT = std::pair<int, int>;
-  if (multEstConf.cutRandomFraction > 0.) {
-    int ntrig = trig.size(), currTrig = 0;
-    if (multEstConf.preferTriggered) {
-      const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-      std::vector<IdNT> nTrigROF;
-      nTrigROF.reserve(nrof);
-      for (uint32_t irof = 0; irof < nrof; irof++) {
-        if (sel[irof]) {
-          if (nsel && gRandom->Rndm() < multEstConf.cutRandomFraction) {
-            nsel--;
-          }
-          auto irROF = rofs[irof].getBCData();
-          while (currTrig < ntrig && trig[currTrig].ir < irROF) { // triggers are sorted, jump to 1st one not less than current ROF
-            currTrig++;
-          }
-          auto& trof = nTrigROF.emplace_back(irof, 0);
-          irROF += alpParams.roFrameLengthInBC;
-          while (currTrig < ntrig && trig[currTrig].ir < irROF) {
-            trof.second++;
-            currTrig++;
-          }
-        }
-      }
-      if (nsel > 0) {
-        sort(nTrigROF.begin(), nTrigROF.end(), [](const IdNT& a, const IdNT& b) { return a.second > b.second; }); // order in number of triggers
-        auto last = nTrigROF.begin() + nsel;
-        sort(nTrigROF.begin(), last, [](const IdNT& a, const IdNT& b) { return a.first < b.first; }); // order in ROF ID first nsel ROFs
-      }
-      for (int i = nsel; i < int(nTrigROF.size()); i++) { // reject ROFs in the tail
-        sel[nTrigROF[i].first] = false;
-      }
-    } else { // dummy random rejection
-      for (int irof = 0; irof < nrof; irof++) {
-        if (sel[irof]) {
-          float sr = gRandom->Rndm();
-          if (gRandom->Rndm() < multEstConf.cutRandomFraction) {
-            sel[irof] = false;
-            nsel--;
-          }
-        }
-      }
-    }
-  }
-  LOGP(debug, "NSel = {} of {} rofs Seeds: before {} after {}", nsel, nrof, lastRandomSeed, gRandom->GetSeed());
-
-  return nsel;
-}
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/FastMultEstConfig.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/FastMultEstConfig.cxx
deleted file mode 100644
index 4f3a8a44b0391..0000000000000
--- a/Detectors/Upgrades/ITS3/reconstruction/src/FastMultEstConfig.cxx
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "ITS3Reconstruction/FastMultEstConfig.h"
-#include "TRandom.h"
-
-O2ParamImpl(o2::its::FastMultEstConfig);
-
-using namespace o2::its;
-
-bool FastMultEstConfig::isPassingRandomRejection() const
-{
-  return (cutRandomFraction <= 0. || gRandom->Rndm() > cutRandomFraction) ? true : false;
-}
diff --git a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
index 7945f8e0af1df..216056153d095 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
@@ -29,18 +29,11 @@
 #include "CommonDataFormat/IRFrame.h"
 #include "DataFormatsTRD/TriggerRecord.h"
 #include "ITS3Reconstruction/IOUtils.h"
-#include "ITSReconstruction/FastMultEstConfig.h"
 #include "ITS3Base/SpecsV2.h"
 
 namespace o2
 {
 using namespace framework;
-using its::FastMultEstConfig;
-using its::TimeFrame;
-using its::Tracker;
-using its::TrackingParameters;
-using its::TrackITSExt;
-using its::Vertexer;
 
 namespace its3
 {

From cba3d9131e16f7e5ce56b0c4c5bcde3b3b8c4d55 Mon Sep 17 00:00:00 2001
From: Podist Kurashvili <pkurash@cern.ch>
Date: Mon, 20 Oct 2025 19:52:19 +0200
Subject: [PATCH 0942/1764] FD detector (#13476)

* basic geometry and data format for new detector

* fixed geometry and json

* fixed hits

* updated geometry and detector source code

* updated geometry and detector source code

* minor fixes

* sensitive volumes

* geometry update

* geometry update

* enable hits

* enable hits

* enable hits

* fix channel ids

* More flexible confgurable parameters

* More flexible confgurable parameters

* update parameters and geometry

* fixed ring sizes

* merge conflict

* GPU

* fix conflicts

* resolve conflicts

* head

* GPU

* added Constants.h to store constants

* Adding Constants.h and correcting formatting issues

* Adding Constants.h and correcting formatting issues

* Adding Constants.h and correcting formatting issues

* Adding Constants.h and correcting formatting issues

* Adding Constants.h and correcting formatting issues

* Adding Constants.h and correcting formatting issues

* created new namespace

* created new namespace

* created new namespace

* change name of the detector

* change name of the detector

* check errors

* check errors

* Flexible ring radii, a new Boolean switch for module A, module coverage in eta independent of their position

* correct default number of ring of A side

* Modified default parameters

* Hits from charged tracks only

* Fixed hit merging

* return to the previous choice

* updated eta min/max definitions

* updated eta definitions

* remove spurious files

* Update CMake

* removed GPU file

* Add FD detector

* including aluminium containers

* including aluminium containers

* including aluminium containers

* including aluminium containers

* including aluminium containers

* Please consider the following formatting changes

* Updated Readme

* introduced FD hit data format

* introduced FD hit data format

* corrected copyright notice

* corrected copyright notice

* corrected copyright notice

* Finding detId from fMC

* colors

* change detector name

* change detector name

* change detector name

* change detector name

* Fix formatting in CMakeLists.txt for FD3Simulation

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Common/SimConfig/src/SimConfig.cxx            |   9 +-
 .../DetectorsCommonDataFormats/DetID.h        |  10 +-
 .../DetectorsCommonDataFormats/SimTraits.h    |   3 +-
 .../Detectors/Upgrades/ALICE3/CMakeLists.txt  |  12 +
 .../Upgrades/ALICE3/FD3/CMakeLists.txt        |  23 +
 .../ALICE3/FD3/include/DataFormatsFD3/Hit.h   | 125 ++++++
 .../ALICE3/FD3/src/DataFormatsFD3LinkDef.h    |  21 +
 .../Detectors/Upgrades/ALICE3/FD3/src/Hit.cxx |  35 ++
 DataFormats/Detectors/Upgrades/CMakeLists.txt |   3 +-
 .../Headers/include/Headers/DataHeader.h      |   1 +
 Detectors/Upgrades/ALICE3/CMakeLists.txt      |   3 +-
 Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt  |  13 +
 Detectors/Upgrades/ALICE3/FD3/README.md       |  10 +
 .../Upgrades/ALICE3/FD3/base/CMakeLists.txt   |  20 +
 .../FD3/base/include/FD3Base/Constants.h      |  38 ++
 .../FD3/base/include/FD3Base/FD3BaseParam.h   |  41 ++
 .../FD3/base/include/FD3Base/GeometryTGeo.h   |  54 +++
 .../ALICE3/FD3/base/src/FD3BaseLinkDef.h      |  23 +
 .../ALICE3/FD3/base/src/FD3BaseParam.cxx      |  14 +
 .../ALICE3/FD3/base/src/GeometryTGeo.cxx      |  66 +++
 .../ALICE3/FD3/simulation/CMakeLists.txt      |  19 +
 .../include/FD3Simulation/Detector.h          | 150 +++++++
 .../ALICE3/FD3/simulation/src/Detector.cxx    | 413 ++++++++++++++++++
 .../FD3/simulation/src/FD3SimulationLinkDef.h |  21 +
 macro/build_geometry.C                        |   6 +
 run/CMakeLists.txt                            |   3 +-
 run/O2HitMerger.h                             |   5 +
 run/o2simdefaultdetectorlist.json             |   1 +
 28 files changed, 1131 insertions(+), 11 deletions(-)
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/CMakeLists.txt
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/FD3/include/DataFormatsFD3/Hit.h
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/FD3/src/DataFormatsFD3LinkDef.h
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/FD3/src/Hit.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/README.md
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/base/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/Constants.h
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/FD3BaseParam.h
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/GeometryTGeo.h
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/base/src/FD3BaseLinkDef.h
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/base/src/FD3BaseParam.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/base/src/GeometryTGeo.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/simulation/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/simulation/include/FD3Simulation/Detector.h
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/simulation/src/Detector.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/FD3/simulation/src/FD3SimulationLinkDef.h

diff --git a/Common/SimConfig/src/SimConfig.cxx b/Common/SimConfig/src/SimConfig.cxx
index 9407a3c556179..2c28497fa4237 100644
--- a/Common/SimConfig/src/SimConfig.cxx
+++ b/Common/SimConfig/src/SimConfig.cxx
@@ -98,7 +98,8 @@ void SimConfig::determineActiveModules(std::vector<std::string> const& inputargs
             activeModules[i] != "TF3" &&
             activeModules[i] != "RCH" &&
             activeModules[i] != "MI3" &&
-            activeModules[i] != "ECL") {
+            activeModules[i] != "ECL" &&
+            activeModules[i] != "FD3") {
           LOGP(fatal, "List of active modules contains {}, which is not a module from the upgrades.", activeModules[i]);
         }
       }
@@ -112,7 +113,8 @@ void SimConfig::determineActiveModules(std::vector<std::string> const& inputargs
             activeModules[i] == "TF3" ||
             activeModules[i] == "RCH" ||
             activeModules[i] == "MI3" ||
-            activeModules[i] == "ECL") {
+            activeModules[i] == "ECL" ||
+            activeModules[i] == "FD3") {
           LOGP(fatal, "List of active modules contains {}, which is not a run 3 module", activeModules[i]);
         }
       }
@@ -130,6 +132,7 @@ void SimConfig::determineActiveModules(std::vector<std::string> const& inputargs
             d == DetID::TF3 ||
             d == DetID::RCH ||
             d == DetID::ECL ||
+            d == DetID::FD3 ||
             d == DetID::MI3) {
           activeModules.emplace_back(DetID::getName(d));
         }
@@ -149,7 +152,7 @@ void SimConfig::determineActiveModules(std::vector<std::string> const& inputargs
       activeModules.emplace_back("SHIL");
       for (int d = DetID::First; d <= DetID::Last; ++d) {
 #ifdef ENABLE_UPGRADES
-        if (d != DetID::IT3 && d != DetID::TRK && d != DetID::FT3 && d != DetID::FCT && d != DetID::TF3 && d != DetID::RCH && d != DetID::ECL && d != DetID::MI3) {
+        if (d != DetID::IT3 && d != DetID::TRK && d != DetID::FT3 && d != DetID::FCT && d != DetID::TF3 && d != DetID::RCH && d != DetID::ECL && d != DetID::FD3 && d != DetID::MI3) {
           activeModules.emplace_back(DetID::getName(d));
         }
       }
diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/DetID.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/DetID.h
index a2767c7620cdd..2d2383783cfc3 100644
--- a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/DetID.h
+++ b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/DetID.h
@@ -87,7 +87,8 @@ class DetID
   static constexpr ID RCH = 23;
   static constexpr ID MI3 = 24;
   static constexpr ID ECL = 25;
-  static constexpr ID Last = ECL;
+  static constexpr ID FD3 = 26;
+  static constexpr ID Last = FD3;
 #else
   static constexpr ID Last = FOC; ///< if extra detectors added, update this !!!
 #endif
@@ -181,7 +182,7 @@ class DetID
   // detector names, will be defined in DataSources
   static constexpr const char* sDetNames[nDetectors + 1] = ///< defined detector names
 #ifdef ENABLE_UPGRADES
-    {"ITS", "TPC", "TRD", "TOF", "PHS", "CPV", "EMC", "HMP", "MFT", "MCH", "MID", "ZDC", "FT0", "FV0", "FDD", "TST", "CTP", "FOC", "IT3", "TRK", "FT3", "FCT", "TF3", "RCH", "MI3", "ECL", nullptr};
+    {"ITS", "TPC", "TRD", "TOF", "PHS", "CPV", "EMC", "HMP", "MFT", "MCH", "MID", "ZDC", "FT0", "FV0", "FDD", "TST", "CTP", "FOC", "IT3", "TRK", "FT3", "FCT", "TF3", "RCH", "MI3", "ECL", "FD3", nullptr};
 #else
     {"ITS", "TPC", "TRD", "TOF", "PHS", "CPV", "EMC", "HMP", "MFT", "MCH", "MID", "ZDC", "FT0", "FV0", "FDD", "TST", "CTP", "FOC", nullptr};
 #endif
@@ -195,7 +196,7 @@ class DetID
 #ifdef ENABLE_UPGRADES
      ,
      o2h::gDataOriginIT3, o2h::gDataOriginTRK, o2h::gDataOriginFT3, o2h::gDataOriginFCT, o2h::gDataOriginTF3,
-     o2h::gDataOriginRCH, o2h::gDataOriginMI3, o2h::gDataOriginECL
+     o2h::gDataOriginRCH, o2h::gDataOriginMI3, o2h::gDataOriginECL, o2h::gDataOriginFD3
 #endif
   };
 #endif // GPUCA_GPUCODE_DEVICE
@@ -211,10 +212,11 @@ GPUconstexpr() DetID::mask_t sMasks[DetID::nDetectors] = ///< detectot masks
    DetID::mask_t(math_utils::bit2Mask(DetID::CPV)), DetID::mask_t(math_utils::bit2Mask(DetID::EMC)), DetID::mask_t(math_utils::bit2Mask(DetID::HMP)), DetID::mask_t(math_utils::bit2Mask(DetID::MFT)), DetID::mask_t(math_utils::bit2Mask(DetID::MCH)),
    DetID::mask_t(math_utils::bit2Mask(DetID::MID)), DetID::mask_t(math_utils::bit2Mask(DetID::ZDC)), DetID::mask_t(math_utils::bit2Mask(DetID::FT0)), DetID::mask_t(math_utils::bit2Mask(DetID::FV0)), DetID::mask_t(math_utils::bit2Mask(DetID::FDD)),
    DetID::mask_t(math_utils::bit2Mask(DetID::TST)), DetID::mask_t(math_utils::bit2Mask(DetID::CTP)), DetID::mask_t(math_utils::bit2Mask(DetID::FOC))
+
 #ifdef ENABLE_UPGRADES
                                                                                                        ,
    DetID::mask_t(math_utils::bit2Mask(DetID::IT3)), DetID::mask_t(math_utils::bit2Mask(DetID::TRK)), DetID::mask_t(math_utils::bit2Mask(DetID::FT3)), DetID::mask_t(math_utils::bit2Mask(DetID::FCT)), DetID::mask_t(math_utils::bit2Mask(DetID::TF3)),
-   DetID::mask_t(math_utils::bit2Mask(DetID::RCH)), DetID::mask_t(math_utils::bit2Mask(DetID::MI3)), DetID::mask_t(math_utils::bit2Mask(DetID::ECL))
+   DetID::mask_t(math_utils::bit2Mask(DetID::RCH)), DetID::mask_t(math_utils::bit2Mask(DetID::MI3)), DetID::mask_t(math_utils::bit2Mask(DetID::ECL)), DetID::mask_t(math_utils::bit2Mask(DetID::FD3))
 #endif
 };
 } // namespace detid_internal
diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/SimTraits.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/SimTraits.h
index 8f9cbcfbdba43..37c4b790d181b 100644
--- a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/SimTraits.h
+++ b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/SimTraits.h
@@ -99,7 +99,8 @@ class SimTraits
       /*TF3*/ VS{ "TF3Hit" },
       /*RCH*/ VS{ "RCHHit" },
       /*MI3*/ VS{ "MI3Hit" },
-      /*ECL*/ VS{ "ECLHit" }
+      /*ECL*/ VS{ "ECLHit" },
+      /*FD */ VS{ "FDHit" }
 #endif
     };
   // clang-format on
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/CMakeLists.txt b/DataFormats/Detectors/Upgrades/ALICE3/CMakeLists.txt
new file mode 100644
index 0000000000000..b3944c2e502d8
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/CMakeLists.txt
@@ -0,0 +1,12 @@
+# Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+add_subdirectory(FD3)
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt b/DataFormats/Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt
new file mode 100644
index 0000000000000..e2219bb893612
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt
@@ -0,0 +1,23 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(DataFormatsFD3
+  SOURCES src/Hit.cxx
+  PUBLIC_LINK_LIBRARIES O2::FD3Base
+                        O2::SimulationDataFormat
+                        O2::CommonDataFormat
+                        Microsoft.GSL::GSL
+                        O2::DetectorsCommonDataFormats
+)
+
+o2_target_root_dictionary(DataFormatsFD3
+  HEADERS include/DataFormatsFD3/Hit.h
+)
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/FD3/include/DataFormatsFD3/Hit.h b/DataFormats/Detectors/Upgrades/ALICE3/FD3/include/DataFormatsFD3/Hit.h
new file mode 100644
index 0000000000000..4fde2f6cde6b4
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/FD3/include/DataFormatsFD3/Hit.h
@@ -0,0 +1,125 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Hit.h
+/// \brief Definition of the FD3 Hit class (based on ITSMFT and FV0)
+
+#ifndef ALICEO2_FVD_HIT_H_
+#define ALICEO2_FVD_HIT_H_
+
+#include <iosfwd>
+#include "SimulationDataFormat/BaseHits.h" // for BasicXYZEHit
+#include "Rtypes.h"                        // for Bool_t, Double_t, int, Double32_t, etc
+#include "TVector3.h"                      // for TVector3
+#include "CommonUtils/ShmAllocator.h"
+
+namespace o2
+{
+namespace fd3
+{
+
+class Hit : public o2::BasicXYZEHit<float, float>
+{
+ public:
+  /// Default constructor
+  Hit() = default;
+
+  /// Class Constructor
+  /// \param trackID Index of MCTrack
+  /// \param cellID Cell ID
+  /// \param startPos Coordinates at entrance to active volume [cm]
+  /// \param endPos Coordinates to active volume [cm]
+  /// \param startMom Momentum of track at entrance [GeV]
+  /// \param startE Energy of track at entrance [GeV]
+  /// \param endTime Final time [ns]
+  /// \param eLoss Energy deposit [GeV]
+  /// \param particlePdg PDG code of the partcile associated with the track
+  inline Hit(int trackID,
+             int cellID,
+             const math_utils::Point3D<float>& startPos,
+             const math_utils::Point3D<float>& endPos,
+             const math_utils::Vector3D<float>& startMom,
+             double startE,
+             double endTime,
+             double eLoss,
+             int particlePdg);
+
+  // Entrance position getters
+  math_utils::Point3D<float> const& GetPosStart() const { return mPositionStart; }
+  float GetStartX() const { return mPositionStart.X(); }
+  float GetStartY() const { return mPositionStart.Y(); }
+  float GetStartZ() const { return mPositionStart.Z(); }
+  template <typename F>
+  void GetStartPosition(F& x, F& y, F& z) const
+  {
+    x = GetStartX();
+    y = GetStartY();
+    z = GetStartZ();
+  }
+
+  // Momentum getters
+  math_utils::Vector3D<float> const& GetMomentum() const { return mMomentumStart; }
+  math_utils::Vector3D<float>& GetMomentum() { return mMomentumStart; }
+  float GetPx() const { return mMomentumStart.X(); }
+  float GetPy() const { return mMomentumStart.Y(); }
+  float GetPz() const { return mMomentumStart.Z(); }
+  float GetE() const { return mEnergyStart; }
+  float GetTotalEnergyAtEntrance() const { return GetE(); }
+  int GetParticlePdg() const { return mParticlePdg; }
+
+  void Print(const Option_t* opt) const;
+
+ private:
+  math_utils::Vector3D<float> mMomentumStart; ///< momentum at entrance
+  math_utils::Point3D<float> mPositionStart;  ///< position at entrance (base mPos give position on exit)
+  float mEnergyStart;                         ///< total energy at entrance
+  int mParticlePdg;                           ///< PDG code of the particle associated with this track
+
+  ClassDefNV(Hit, 1);
+};
+
+Hit::Hit(int trackID,
+         int detID,
+         const math_utils::Point3D<float>& startPos,
+         const math_utils::Point3D<float>& endPos,
+         const math_utils::Vector3D<float>& startMom,
+         double startE,
+         double endTime,
+         double eLoss,
+         int particlePdg)
+  : BasicXYZEHit(endPos.X(),
+                 endPos.Y(),
+                 endPos.Z(),
+                 endTime,
+                 eLoss,
+                 trackID,
+                 detID),
+    mMomentumStart(startMom.X(), startMom.Y(), startMom.Z()),
+    mPositionStart(startPos.X(), startPos.Y(), startPos.Z()),
+    mEnergyStart(startE),
+    mParticlePdg(particlePdg)
+{
+}
+
+} // namespace fd3
+} // namespace o2
+
+#ifdef USESHM
+namespace std
+{
+template <>
+class allocator<o2::fd3::Hit> : public o2::utils::ShmAllocator<o2::fd3::Hit>
+{
+};
+
+} // namespace std
+#endif /* USESHM */
+#endif /* ALICEO2_FD3_HIT_H_ */
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/FD3/src/DataFormatsFD3LinkDef.h b/DataFormats/Detectors/Upgrades/ALICE3/FD3/src/DataFormatsFD3LinkDef.h
new file mode 100644
index 0000000000000..1014b3d8c704e
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/FD3/src/DataFormatsFD3LinkDef.h
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::fd3::Hit + ;
+#pragma link C++ class vector < o2::fd3::Hit> + ;
+
+#endif
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/FD3/src/Hit.cxx b/DataFormats/Detectors/Upgrades/ALICE3/FD3/src/Hit.cxx
new file mode 100644
index 0000000000000..403a3402bd30c
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/FD3/src/Hit.cxx
@@ -0,0 +1,35 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Hit.cxx
+/// \brief Implementation of the Hit class
+
+#include "DataFormatsFD3/Hit.h"
+#include <iostream>
+
+ClassImp(o2::fd3::Hit);
+
+namespace o2
+{
+namespace fd3
+{
+
+void Hit::Print(const Option_t* opt) const
+{
+  printf(
+    "Det: %5d Track: %6d E.loss: %.3e P: %+.3e %+.3e %+.3e\n"
+    "PosIn: %+.3e %+.3e %+.3e PosOut: %+.3e %+.3e %+.3e\n",
+    GetDetectorID(), GetTrackID(), GetEnergyLoss(), GetPx(), GetPy(), GetPz(),
+    GetStartX(), GetStartY(), GetStartZ(), GetX(), GetY(), GetZ());
+}
+
+} // namespace fd3
+} // namespace o2
diff --git a/DataFormats/Detectors/Upgrades/CMakeLists.txt b/DataFormats/Detectors/Upgrades/CMakeLists.txt
index a2d470b8ff6d5..0dfe07dc2827d 100644
--- a/DataFormats/Detectors/Upgrades/CMakeLists.txt
+++ b/DataFormats/Detectors/Upgrades/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# Copyright 2019-2025 CERN and copyright holders of ALICE O2.
 # See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 # All rights not expressly granted are reserved.
 #
@@ -10,3 +10,4 @@
 # or submit itself to any jurisdiction.
 
 message(STATUS "Building dataformats for upgrades")
+add_subdirectory(ALICE3)
diff --git a/DataFormats/Headers/include/Headers/DataHeader.h b/DataFormats/Headers/include/Headers/DataHeader.h
index 2dbfbd67d8d6c..b44f41c5d3cb3 100644
--- a/DataFormats/Headers/include/Headers/DataHeader.h
+++ b/DataFormats/Headers/include/Headers/DataHeader.h
@@ -588,6 +588,7 @@ constexpr o2::header::DataOrigin gDataOriginTF3{"TF3"};
 constexpr o2::header::DataOrigin gDataOriginRCH{"RCH"};
 constexpr o2::header::DataOrigin gDataOriginMI3{"MI3"};
 constexpr o2::header::DataOrigin gDataOriginECL{"ECL"}; // upgrades
+constexpr o2::header::DataOrigin gDataOriginFD3{"FD3"}; // upgrades
 
 constexpr o2::header::DataOrigin gDataOriginGPU{"GPU"};
 
diff --git a/Detectors/Upgrades/ALICE3/CMakeLists.txt b/Detectors/Upgrades/ALICE3/CMakeLists.txt
index 0c2bbe5e02a47..0335e85007c01 100644
--- a/Detectors/Upgrades/ALICE3/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/CMakeLists.txt
@@ -12,10 +12,11 @@
 add_subdirectory(Passive)
 add_subdirectory(TRK)
 add_subdirectory(ECal)
+add_subdirectory(FD3)
 add_subdirectory(FT3)
 add_subdirectory(FCT)
 add_subdirectory(AOD)
 add_subdirectory(IOTOF)
 add_subdirectory(RICH)
 add_subdirectory(MID)
-add_subdirectory(macros)
\ No newline at end of file
+add_subdirectory(macros)
diff --git a/Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt b/Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt
new file mode 100644
index 0000000000000..d9ea4b632952c
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+add_subdirectory(base)
+add_subdirectory(simulation)
diff --git a/Detectors/Upgrades/ALICE3/FD3/README.md b/Detectors/Upgrades/ALICE3/FD3/README.md
new file mode 100644
index 0000000000000..54c1fd37b2590
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/README.md
@@ -0,0 +1,10 @@
+<!-- doxy
+\page refDetectorsUpgradesALICE3TRK Tracker
+/doxy -->
+
+# ALICE 3 FORWARD DETECTOR
+
+This is top page for the FD3 detector documentation.
+
+<!-- doxy
+/doxy -->
diff --git a/Detectors/Upgrades/ALICE3/FD3/base/CMakeLists.txt b/Detectors/Upgrades/ALICE3/FD3/base/CMakeLists.txt
new file mode 100644
index 0000000000000..c76665da1344f
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/base/CMakeLists.txt
@@ -0,0 +1,20 @@
+# Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(FD3Base
+        SOURCES src/GeometryTGeo.cxx
+                src/FD3BaseParam.cxx
+                PUBLIC_LINK_LIBRARIES  O2::DetectorsBase)
+
+o2_target_root_dictionary(FD3Base
+        HEADERS include/FD3Base/GeometryTGeo.h
+                include/FD3Base/Constants.h
+                include/FD3Base/FD3BaseParam.h)
diff --git a/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/Constants.h b/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/Constants.h
new file mode 100644
index 0000000000000..428a7a1f6d179
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/Constants.h
@@ -0,0 +1,38 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   Constants.h
+/// \brief  General constants in FV0
+///
+/// \author Maciej Slupecki, University of Jyvaskyla, Finland
+
+#ifndef ALICEO2_FD3_CONSTANTS_
+#define ALICEO2_FD3_CONSTANTS_
+
+namespace o2
+{
+namespace fd3
+{
+struct Constants {
+  static constexpr unsigned int nsect = 8;
+  static constexpr unsigned int nringsA = 5;
+  static constexpr unsigned int nringsC = 6;
+
+  static constexpr float etaMax = 7.0f;
+  static constexpr float etaMin = 4.0f;
+
+  static constexpr unsigned int nringsA_withMG = 3;
+  static constexpr float etaMinA_withMG = 5.0f;
+};
+
+} // namespace fd3
+} // namespace o2
+#endif
diff --git a/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/FD3BaseParam.h b/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/FD3BaseParam.h
new file mode 100644
index 0000000000000..9836cebbfa760
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/FD3BaseParam.h
@@ -0,0 +1,41 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_FD3_FD3BASEPARAM_
+#define ALICEO2_FD3_FD3BASEPARAM_
+
+#include "FD3Base/GeometryTGeo.h"
+#include "FD3Base/Constants.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2
+{
+namespace fd3
+{
+struct FD3BaseParam : public o2::conf::ConfigurableParamHelper<FD3BaseParam> {
+
+  float zmodA = 1700.0f;
+  float zmodC = -1850.0f;
+  float dzscint = 4.0f;
+
+  bool withMG = false; // modified geometry with 3 rings on A side
+
+  bool plateBehindA = false;
+  bool fullContainer = false;
+  float dzplate = 1.0f; // Aluminium plate width
+
+  O2ParamDef(FD3BaseParam, "FD3Base");
+};
+
+} // namespace fd3
+} // namespace o2
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/GeometryTGeo.h
new file mode 100644
index 0000000000000..0e38bd4ccd21f
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/base/include/FD3Base/GeometryTGeo.h
@@ -0,0 +1,54 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef ALICEO2_FD3_GEOMETRYTGEO_H_
+#define ALICEO2_FD3_GEOMETRYTGEO_H_
+
+#include <DetectorsCommonDataFormats/DetMatrixCache.h>
+
+#include "DetectorsBase/GeometryManager.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include <Rtypes.h>
+#include <TGeoPhysicalNode.h>
+#include <vector>
+#include <array>
+#include <TGeoMatrix.h>
+#include <TGeoVolume.h>
+#include <TVirtualMC.h>
+
+namespace o2
+{
+namespace fd3
+{
+
+/// FD3 Geometry type
+class GeometryTGeo : public o2::detectors::DetMatrixCache
+{
+ public:
+  GeometryTGeo(bool build = false, int loadTrans = 0);
+
+  void Build(int loadTrans);
+  void fillMatrixCache(int mask);
+  virtual ~GeometryTGeo();
+
+  static GeometryTGeo* Instance();
+
+  void getGlobalPosition(float& x, float& y, float& z);
+
+  static constexpr o2::detectors::DetID::ID getDetID() { return o2::detectors::DetID::FD3; }
+
+ private:
+  static std::unique_ptr<o2::fd3::GeometryTGeo> sInstance;
+
+  ClassDefNV(GeometryTGeo, 1);
+};
+} // namespace fd3
+} // namespace o2
+#endif
diff --git a/Detectors/Upgrades/ALICE3/FD3/base/src/FD3BaseLinkDef.h b/Detectors/Upgrades/ALICE3/FD3/base/src/FD3BaseLinkDef.h
new file mode 100644
index 0000000000000..8475ef2c77313
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/base/src/FD3BaseLinkDef.h
@@ -0,0 +1,23 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::fd3::Constants + ;
+#pragma link C++ class o2::fd3::GeometryTGeo + ;
+#pragma link C++ class o2::fd3::FD3BaseParam + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::fd3::FD3BaseParam> + ;
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/FD3/base/src/FD3BaseParam.cxx b/Detectors/Upgrades/ALICE3/FD3/base/src/FD3BaseParam.cxx
new file mode 100644
index 0000000000000..74b45962b3f39
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/base/src/FD3BaseParam.cxx
@@ -0,0 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "FD3Base/FD3BaseParam.h"
+
+O2ParamImpl(o2::fd3::FD3BaseParam);
diff --git a/Detectors/Upgrades/ALICE3/FD3/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/FD3/base/src/GeometryTGeo.cxx
new file mode 100644
index 0000000000000..16788cb8944e3
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/base/src/GeometryTGeo.cxx
@@ -0,0 +1,66 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "FD3Base/GeometryTGeo.h"
+#include "FD3Base/FD3BaseParam.h"
+
+#include <cmath>
+
+#include <fairlogger/Logger.h>
+
+using namespace o2::fd3;
+namespace o2
+{
+namespace fd3
+{
+
+std::unique_ptr<o2::fd3::GeometryTGeo> GeometryTGeo::sInstance;
+
+GeometryTGeo::GeometryTGeo(bool build, int loadTrans) : DetMatrixCache()
+{
+  if (sInstance) {
+    LOGP(fatal, "Invalid use of public constructor: o2::fd3::GeometryTGeo instance exists");
+  }
+  if (build) {
+    Build(loadTrans);
+  }
+}
+
+GeometryTGeo::~GeometryTGeo() = default;
+
+GeometryTGeo* GeometryTGeo::Instance()
+{
+  if (!sInstance) {
+    sInstance = std::unique_ptr<GeometryTGeo>(new GeometryTGeo(true, 0));
+  }
+  return sInstance.get();
+}
+
+void GeometryTGeo::Build(int loadTrans)
+{
+  if (isBuilt()) {
+    LOGP(warning, "Already built");
+    return; // already initialized
+  }
+
+  if (!gGeoManager) {
+    LOGP(fatal, "Geometry is not loaded");
+  }
+
+  fillMatrixCache(loadTrans);
+}
+
+void GeometryTGeo::fillMatrixCache(int mask)
+{
+}
+
+} // namespace fd3
+} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/FD3/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/FD3/simulation/CMakeLists.txt
new file mode 100644
index 0000000000000..38886ec5fbe07
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/simulation/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(FD3Simulation
+               SOURCES src/Detector.cxx
+               PUBLIC_LINK_LIBRARIES O2::FD3Base
+	                             O2::DataFormatsFD3
+                                     ROOT::Physics)
+
+o2_target_root_dictionary(FD3Simulation
+                          HEADERS include/FD3Simulation/Detector.h)
diff --git a/Detectors/Upgrades/ALICE3/FD3/simulation/include/FD3Simulation/Detector.h b/Detectors/Upgrades/ALICE3/FD3/simulation/include/FD3Simulation/Detector.h
new file mode 100644
index 0000000000000..2d17acbd4a0e8
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/simulation/include/FD3Simulation/Detector.h
@@ -0,0 +1,150 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Detector.h
+/// \brief Definition of the Detector class
+
+#ifndef ALICEO2_FD3_DETECTOR_H_
+#define ALICEO2_FD3_DETECTOR_H_
+
+#include "SimulationDataFormat/BaseHits.h"
+#include "DetectorsBase/Detector.h"
+#include "FD3Base/GeometryTGeo.h"
+#include "FD3Base/FD3BaseParam.h"
+#include "DataFormatsFD3/Hit.h"
+#include "Rtypes.h"
+#include "TGeoManager.h"
+#include "TLorentzVector.h"
+#include "TVector3.h"
+#include <cmath>
+
+class FairVolume;
+class TGeoVolume;
+
+namespace o2
+{
+namespace fd3
+{
+class GeometryTGeo;
+}
+} // namespace o2
+
+namespace o2
+{
+namespace fd3
+{
+
+class Detector : public o2::base::DetImpl<Detector>
+{
+ public:
+  Detector(bool Active);
+
+  Detector() = default;
+
+  ~Detector() override;
+
+  void ConstructGeometry() override;
+
+  /// This method is an example of how to add your own point of type Hit to the clones array
+  o2::fd3::Hit* addHit(int trackId, unsigned int detId,
+                       const math_utils::Point3D<float>& startPos,
+                       const math_utils::Point3D<float>& endPos,
+                       const math_utils::Vector3D<float>& startMom, double startE,
+                       double endTime, double eLoss, int particlePdg);
+  //   unsigned int startStatus,
+  //   unsigned int endStatus);
+
+  std::vector<o2::fd3::Hit>* getHits(Int_t iColl)
+  {
+    if (iColl == 0) {
+      return mHits;
+    }
+    return nullptr;
+  }
+
+  // Mandatory overrides
+  void BeginPrimary() override { ; }
+  void FinishPrimary() override { ; }
+  void InitializeO2Detector() override;
+  void PostTrack() override { ; }
+  void PreTrack() override { ; }
+  bool ProcessHits(FairVolume* v = nullptr) override;
+  void EndOfEvent() override;
+  void Register() override;
+  void Reset() override;
+
+  void createMaterials();
+  void buildModules();
+
+  enum EMedia {
+    Scintillator,
+    Aluminium
+  };
+
+ private:
+  Detector(const Detector&);
+  Detector& operator=(const Detector&);
+
+  std::vector<o2::fd3::Hit>* mHits = nullptr;
+  GeometryTGeo* mGeometryTGeo = nullptr;
+
+  TGeoVolumeAssembly* buildModuleA();
+  TGeoVolumeAssembly* buildModuleC();
+
+  float ringSize(float zmod, float eta);
+
+  unsigned int mNumberOfRingsA, mNumberOfRingsC, mNumberOfSectors;
+  float mDzScint, mDzPlate;
+
+  std::vector<float> mRingSizesA = {}, mRingSizesC = {};
+
+  float mEtaMaxA, mEtaMaxC, mEtaMinA, mEtaMinC;
+  float mZA, mZC;
+
+  bool mPlateBehindA, mFullContainer;
+
+  void defineSensitiveVolumes();
+  void definePassiveVolumes();
+
+  /// Transient data about track passing the sensor, needed by ProcessHits()
+  struct TrackData {               // this is transient
+    bool mHitStarted;              //! hit creation started
+    unsigned char mTrkStatusStart; //! track status flag
+    TLorentzVector mPositionStart; //! position at entrance
+    TLorentzVector mMomentumStart; //! momentum
+    double mEnergyLoss;            //! energy loss
+  } mTrackData;                    //!
+
+  template <typename Det>
+  friend class o2::base::DetImpl;
+  ClassDefOverride(Detector, 1);
+};
+
+// Input and output function for standard C++ input/output.
+std::ostream& operator<<(std::ostream& os, Detector& source);
+std::istream& operator>>(std::istream& os, Detector& source);
+
+} // namespace fd3
+} // namespace o2
+
+#ifdef USESHM
+namespace o2
+{
+namespace base
+{
+template <>
+struct UseShm<o2::fd3::Detector> {
+  static constexpr bool value = true;
+};
+} // namespace base
+} // namespace o2
+#endif
+#endif
diff --git a/Detectors/Upgrades/ALICE3/FD3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FD3/simulation/src/Detector.cxx
new file mode 100644
index 0000000000000..bd79b1deaad80
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/simulation/src/Detector.cxx
@@ -0,0 +1,413 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Detector.cxx
+/// \brief Implementation of the Detector class
+
+#include "DataFormatsFD3/Hit.h"
+#include "FD3Simulation/Detector.h"
+#include "FD3Base/GeometryTGeo.h"
+#include "FD3Base/FD3BaseParam.h"
+#include "FD3Base/Constants.h"
+
+#include "DetectorsBase/Stack.h"
+#include "SimulationDataFormat/TrackReference.h"
+#include "Field/MagneticField.h"
+
+// FairRoot includes
+#include "FairDetector.h"
+#include <fairlogger/Logger.h>
+#include "FairRootManager.h"
+#include "FairRun.h"
+#include "FairRuntimeDb.h"
+#include "FairVolume.h"
+#include "FairRootManager.h"
+
+#include "TVirtualMC.h"
+#include "TLorentzVector.h"
+#include "TVector3.h"
+#include <TGeoTube.h>
+#include <TGeoVolume.h>
+#include <TGeoCompositeShape.h>
+#include <TGeoMedium.h>
+#include <TGeoCone.h>
+#include <TGeoManager.h>
+#include "TRandom.h"
+#include <cmath>
+
+class FairModule;
+
+class TGeoMedium;
+
+using namespace o2::fd3;
+using o2::fd3::Hit;
+
+Detector::Detector(bool active)
+  : o2::base::DetImpl<Detector>("FD3", true),
+    mHits(o2::utils::createSimVector<o2::fd3::Hit>()),
+    mGeometryTGeo(nullptr),
+    mTrackData()
+{
+  mNumberOfRingsC = Constants::nringsC;
+  mNumberOfSectors = Constants::nsect;
+
+  mEtaMinA = Constants::etaMin;
+  mEtaMaxA = Constants::etaMax;
+  mEtaMinC = -Constants::etaMax;
+  mEtaMaxC = -Constants::etaMin;
+
+  auto& baseParam = FD3BaseParam::Instance();
+
+  if (baseParam.withMG) {
+    mNumberOfRingsA = Constants::nringsA_withMG;
+    mEtaMinA = Constants::etaMinA_withMG;
+  } else {
+    mNumberOfRingsA = Constants::nringsA;
+    mEtaMinA = Constants::etaMin;
+  }
+
+  mDzScint = baseParam.dzscint / 2;
+  mDzPlate = baseParam.dzplate;
+
+  mPlateBehindA = baseParam.plateBehindA;
+  mFullContainer = baseParam.fullContainer;
+
+  mZA = baseParam.zmodA;
+  mZC = baseParam.zmodC;
+
+  for (int i = 0; i <= mNumberOfRingsA + 1; i++) {
+    float eta = mEtaMaxA - i * (mEtaMaxA - mEtaMinA) / mNumberOfRingsA;
+    float r = ringSize(mZA, eta);
+    mRingSizesA.emplace_back(r);
+  }
+
+  for (int i = 0; i <= mNumberOfRingsC + 1; i++) {
+    float eta = mEtaMinC + i * (mEtaMaxC - mEtaMinC) / mNumberOfRingsC;
+    float r = ringSize(mZC, eta);
+    mRingSizesC.emplace_back(r);
+  }
+}
+
+Detector::Detector(const Detector& rhs)
+  : o2::base::DetImpl<Detector>(rhs),
+    mTrackData(),
+    mHits(o2::utils::createSimVector<o2::fd3::Hit>())
+{
+}
+
+Detector& Detector::operator=(const Detector& rhs)
+{
+
+  if (this == &rhs) {
+    return *this;
+  }
+  // base class assignment
+  base::Detector::operator=(rhs);
+  mTrackData = rhs.mTrackData;
+
+  mHits = nullptr;
+  return *this;
+}
+
+Detector::~Detector()
+{
+
+  if (mHits) {
+    o2::utils::freeSimVector(mHits);
+  }
+}
+
+void Detector::InitializeO2Detector()
+{
+  LOG(info) << "Initialize Forward Detector";
+  mGeometryTGeo = GeometryTGeo::Instance();
+  defineSensitiveVolumes();
+}
+
+bool Detector::ProcessHits(FairVolume* vol)
+{
+  // This method is called from the MC stepping
+  if (!(fMC->TrackCharge())) {
+    return kFALSE;
+  }
+
+  int detId;
+  int volID = fMC->CurrentVolID(detId);
+
+  auto stack = (o2::data::Stack*)fMC->GetStack();
+
+  // Check track status to define when hit is started and when it is stopped
+  int particlePdg = fMC->TrackPid();
+  bool startHit = false, stopHit = false;
+  if ((fMC->IsTrackEntering()) || (fMC->IsTrackInside() && !mTrackData.mHitStarted)) {
+    startHit = true;
+  } else if ((fMC->IsTrackExiting() || fMC->IsTrackOut() || fMC->IsTrackStop())) {
+    stopHit = true;
+  }
+
+  // increment energy loss at all steps except entrance
+  if (!startHit) {
+    mTrackData.mEnergyLoss += fMC->Edep();
+  }
+  if (!(startHit | stopHit)) {
+    return kFALSE; // do noting
+  }
+
+  if (startHit) {
+    mTrackData.mHitStarted = true;
+    mTrackData.mEnergyLoss = 0.;
+    fMC->TrackMomentum(mTrackData.mMomentumStart);
+    fMC->TrackPosition(mTrackData.mPositionStart);
+    mTrackData.mTrkStatusStart = true;
+  }
+
+  if (stopHit) {
+    TLorentzVector positionStop;
+    fMC->TrackPosition(positionStop);
+    int trackId = stack->GetCurrentTrackNumber();
+
+    math_utils::Point3D<float> posStart(mTrackData.mPositionStart.X(), mTrackData.mPositionStart.Y(), mTrackData.mPositionStart.Z());
+    math_utils::Point3D<float> posStop(positionStop.X(), positionStop.Y(), positionStop.Z());
+    math_utils::Vector3D<float> momStart(mTrackData.mMomentumStart.Px(), mTrackData.mMomentumStart.Py(), mTrackData.mMomentumStart.Pz());
+
+    Hit* p = addHit(trackId, detId, posStart, posStop,
+                    momStart, mTrackData.mMomentumStart.E(),
+                    positionStop.T(), mTrackData.mEnergyLoss, particlePdg);
+    stack->addHit(GetDetId());
+  } else {
+    return false; // do nothing more
+  }
+  return true;
+}
+
+o2::fd3::Hit* Detector::addHit(int trackId, unsigned int detId,
+                               const math_utils::Point3D<float>& startPos,
+                               const math_utils::Point3D<float>& endPos,
+                               const math_utils::Vector3D<float>& startMom,
+                               double startE,
+                               double endTime,
+                               double eLoss,
+                               int particlePdg)
+{
+  mHits->emplace_back(trackId, detId, startPos,
+                      endPos, startMom, startE, endTime, eLoss, particlePdg);
+  return &(mHits->back());
+}
+
+void Detector::ConstructGeometry()
+{
+  createMaterials();
+  buildModules();
+}
+
+void Detector::EndOfEvent()
+{
+  Reset();
+}
+
+void Detector::Register()
+{
+  // This will create a branch in the output tree called Hit, setting the last
+  // parameter to kFALSE means that this collection will not be written to the file,
+  // it will exist only during the simulation
+
+  if (FairRootManager::Instance()) {
+    FairRootManager::Instance()->RegisterAny(addNameTo("Hit").data(), mHits, kTRUE);
+  }
+}
+
+void Detector::Reset()
+{
+  if (!o2::utils::ShmManager::Instance().isOperational()) {
+    mHits->clear();
+  }
+}
+
+void Detector::createMaterials()
+{
+  float density, as[11], zs[11], ws[11];
+  double radLength, absLength, a_ad, z_ad;
+  int id;
+
+  // EJ-204 scintillator, based on polyvinyltoluene
+  const int nScint = 2;
+  float aScint[nScint] = {1.00784, 12.0107};
+  float zScint[nScint] = {1, 6};
+  float wScint[nScint] = {0.07085, 0.92915}; // based on EJ-204 datasheet: n_atoms/cm3
+  const float dScint = 1.023;
+
+  // Aluminium
+  Float_t aAlu = 26.981;
+  Float_t zAlu = 13;
+  Float_t dAlu = 2.7;
+
+  int matId = 0;                  // tmp material id number
+  const int unsens = 0, sens = 1; // sensitive or unsensitive medium
+                                  //
+  int fieldType = 3;              // Field type
+  float maxField = 5.0;           // Field max.
+
+  float tmaxfd3 = -10.0; // max deflection angle due to magnetic field in one step
+  float stemax = 0.1;    // max step allowed [cm]
+  float deemax = 1.0;    // maximum fractional energy loss in one step 0<deemax<=1
+  float epsil = 0.03;    // tracking precision [cm]
+  float stmin = -0.001;  // minimum step due to continuous processes [cm] (negative value: choose it automatically)
+
+  LOG(info) << "FD3: CreateMaterials(): fieldType " << fieldType << ", maxField " << maxField;
+
+  o2::base::Detector::Mixture(++matId, "Scintillator", aScint, zScint, dScint, nScint, wScint);
+  o2::base::Detector::Medium(Scintillator, "Scintillator", matId, unsens, fieldType, maxField,
+                             tmaxfd3, stemax, deemax, epsil, stmin);
+
+  o2::base::Detector::Material(++matId, "Aluminium", aAlu, zAlu, dAlu, 8.9, 999);
+  o2::base::Detector::Medium(Aluminium, "Aluminium", matId, unsens, fieldType, maxField,
+                             tmaxfd3, stemax, deemax, epsil, stmin);
+}
+
+void Detector::buildModules()
+{
+  LOGP(info, "Creating FD3 geometry");
+
+  TGeoVolume* vCave = gGeoManager->GetVolume("cave");
+
+  if (!vCave) {
+    LOG(fatal) << "Could not find the top volume!";
+  }
+
+  TGeoVolumeAssembly* vFD3A = buildModuleA();
+  TGeoVolumeAssembly* vFD3C = buildModuleC();
+
+  vCave->AddNode(vFD3A, 1, new TGeoTranslation(0., 0., mZA));
+  vCave->AddNode(vFD3C, 2, new TGeoTranslation(0., 0., mZC));
+}
+
+TGeoVolumeAssembly* Detector::buildModuleA()
+{
+  TGeoVolumeAssembly* mod = new TGeoVolumeAssembly("FD3A");
+
+  const TGeoMedium* medium = gGeoManager->GetMedium("FD3_Scintillator");
+
+  float dphiDeg = 360. / mNumberOfSectors;
+
+  for (int ir = 0; ir < mNumberOfRingsA; ir++) {
+    std::string rName = "fd3_ring" + std::to_string(ir + 1);
+    TGeoVolumeAssembly* ring = new TGeoVolumeAssembly(rName.c_str());
+    float rmin = mRingSizesA[ir];
+    float rmax = mRingSizesA[ir + 1];
+    LOG(info) << "ring" << ir << ": from " << rmin << " to " << rmax;
+    for (int ic = 0; ic < mNumberOfSectors; ic++) {
+      int cellId = ic + mNumberOfSectors * ir;
+      std::string nodeName = "fd3_node" + std::to_string(cellId);
+      float phimin = dphiDeg * ic;
+      float phimax = dphiDeg * (ic + 1);
+      auto tbs = new TGeoTubeSeg("tbs", rmin, rmax, mDzScint, phimin, phimax);
+      auto nod = new TGeoVolume(nodeName.c_str(), tbs, medium);
+      if ((ir + ic) % 2 == 0) {
+        nod->SetLineColor(kRed);
+      } else {
+        nod->SetLineColor(kRed - 7);
+      }
+      ring->AddNode(nod, cellId);
+    }
+    mod->AddNode(ring, ir + 1);
+  }
+
+  // Aluminium plates on one or both sides of the A side module
+  if (mPlateBehindA || mFullContainer) {
+    LOG(info) << "adding container on A side";
+    auto pmed = (TGeoMedium*)gGeoManager->GetMedium("FD3_Aluminium");
+    auto pvol = new TGeoTube("pvol_fd3a", mRingSizesA[0], mRingSizesA[mNumberOfRingsA], mDzPlate);
+    auto pnod1 = new TGeoVolume("pnod1_FD3A", pvol, pmed);
+    double dpz = 2. + mDzPlate / 2;
+    mod->AddNode(pnod1, 1, new TGeoTranslation(0, 0, dpz));
+
+    if (mFullContainer) {
+      auto pnod2 = new TGeoVolume("pnod2_FD3A", pvol, pmed);
+      mod->AddNode(pnod2, 1, new TGeoTranslation(0, 0, -dpz));
+    }
+  }
+  return mod;
+}
+
+TGeoVolumeAssembly* Detector::buildModuleC()
+{
+  TGeoVolumeAssembly* mod = new TGeoVolumeAssembly("FD3C");
+
+  const TGeoMedium* medium = gGeoManager->GetMedium("FD3_Scintillator");
+
+  float dphiDeg = 360. / mNumberOfSectors;
+
+  for (int ir = 0; ir < mNumberOfRingsC; ir++) {
+    std::string rName = "fd3_ring" + std::to_string(ir + 1 + mNumberOfRingsA);
+    TGeoVolumeAssembly* ring = new TGeoVolumeAssembly(rName.c_str());
+    float rmin = mRingSizesC[ir];
+    float rmax = mRingSizesC[ir + 1];
+    LOG(info) << "ring" << ir + mNumberOfRingsA << ": from " << rmin << " to " << rmax;
+    for (int ic = 0; ic < mNumberOfSectors; ic++) {
+      int cellId = ic + mNumberOfSectors * (ir + mNumberOfRingsA);
+      std::string nodeName = "fd3_node" + std::to_string(cellId);
+      float phimin = dphiDeg * ic;
+      float phimax = dphiDeg * (ic + 1);
+      auto tbs = new TGeoTubeSeg("tbs", rmin, rmax, mDzScint, phimin, phimax);
+      auto nod = new TGeoVolume(nodeName.c_str(), tbs, medium);
+      if ((ir + ic) % 2 == 0) {
+        nod->SetLineColor(kBlue);
+      } else {
+        nod->SetLineColor(kBlue - 7);
+      }
+      ring->AddNode(nod, cellId);
+    }
+    mod->AddNode(ring, ir + 1);
+  }
+
+  // Aluminium plates on both sides of the C side module
+  if (mFullContainer) {
+    LOG(info) << "adding container on C side";
+    auto pmed = (TGeoMedium*)gGeoManager->GetMedium("FD3_Aluminium");
+    auto pvol = new TGeoTube("pvol_fd3c", mRingSizesC[0], mRingSizesC[mNumberOfRingsC], mDzPlate);
+    auto pnod1 = new TGeoVolume("pnod1_FD3C", pvol, pmed);
+    auto pnod2 = new TGeoVolume("pnod2_FD3C", pvol, pmed);
+    double dpz = mDzScint / 2 + mDzPlate / 2;
+
+    mod->AddNode(pnod1, 1, new TGeoTranslation(0, 0, dpz));
+    mod->AddNode(pnod2, 2, new TGeoTranslation(0, 0, -dpz));
+  }
+
+  return mod;
+}
+
+void Detector::defineSensitiveVolumes()
+{
+  LOG(info) << "Adding FD3 Sentitive Volumes";
+
+  TGeoVolume* v;
+  TString volumeName;
+
+  int nCellsA = mNumberOfRingsA * mNumberOfSectors;
+  int nCellsC = mNumberOfRingsC * mNumberOfSectors;
+
+  LOG(info) << "number of A rings = " << mNumberOfRingsA << " number of cells = " << nCellsA;
+  LOG(info) << "number of C rings = " << mNumberOfRingsC << " number of cells = " << nCellsC;
+
+  for (int iv = 0; iv < nCellsA + nCellsC; iv++) {
+    volumeName = "fd3_node" + std::to_string(iv);
+    v = gGeoManager->GetVolume(volumeName);
+    LOG(info) << "Adding sensitive volume => " << v->GetName();
+    AddSensitiveVolume(v);
+  }
+}
+
+float Detector::ringSize(float z, float eta)
+{
+  return z * TMath::Tan(2 * TMath::ATan(TMath::Exp(-eta)));
+}
+
+ClassImp(o2::fd3::Detector);
diff --git a/Detectors/Upgrades/ALICE3/FD3/simulation/src/FD3SimulationLinkDef.h b/Detectors/Upgrades/ALICE3/FD3/simulation/src/FD3SimulationLinkDef.h
new file mode 100644
index 0000000000000..83df03490ebd7
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FD3/simulation/src/FD3SimulationLinkDef.h
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::fd3::Detector + ;
+#pragma link C++ class o2::base::DetImpl < o2::fd3::Detector> + ;
+
+#endif
diff --git a/macro/build_geometry.C b/macro/build_geometry.C
index fde043256046a..6b13f2eac2766 100644
--- a/macro/build_geometry.C
+++ b/macro/build_geometry.C
@@ -56,6 +56,7 @@
 #include <IOTOFSimulation/Detector.h>
 #include <RICHSimulation/Detector.h>
 #include <ECalSimulation/Detector.h>
+#include <FD3Simulation/Detector.h>
 #include <MI3Simulation/Detector.h>
 #include <Alice3DetectorsPassive/Pipe.h>
 #include <Alice3DetectorsPassive/Absorber.h>
@@ -264,6 +265,11 @@ void build_geometry(FairRunSim* run = nullptr)
     addReadoutDetector(new o2::ecal::Detector(isReadout("ECL")));
   }
 
+  if (isActivated("FD3")) {
+    // ALICE3 FD3
+    addReadoutDetector(new o2::fd3::Detector(isReadout("FD3")));
+  }
+
   if (isActivated("MI3")) {
     // ALICE 3 MID
     addReadoutDetector(new o2::mi3::Detector(isReadout("MI3")));
diff --git a/run/CMakeLists.txt b/run/CMakeLists.txt
index fd43207f92d1e..474aa7e41eb7c 100644
--- a/run/CMakeLists.txt
+++ b/run/CMakeLists.txt
@@ -46,6 +46,7 @@ target_link_libraries(allsim
                                 $<$<BOOL:${ENABLE_UPGRADES}>:O2::IOTOFSimulation>
                                 $<$<BOOL:${ENABLE_UPGRADES}>:O2::RICHSimulation>
                                 $<$<BOOL:${ENABLE_UPGRADES}>:O2::ECalSimulation>
+								$<$<BOOL:${ENABLE_UPGRADES}>:O2::FD3Simulation>
                                 $<$<BOOL:${ENABLE_UPGRADES}>:O2::MI3Simulation>
                                 O2::Generators)
 
@@ -340,4 +341,4 @@ install(FILES o2-sim-client.py PERMISSIONS GROUP_READ GROUP_EXECUTE OWNER_EXECUT
 install(DIRECTORY SimExamples/
         DESTINATION examples
         PATTERN *
-        PERMISSIONS GROUP_READ GROUP_EXECUTE OWNER_EXECUTE OWNER_WRITE OWNER_READ WORLD_EXECUTE WORLD_READ)
\ No newline at end of file
+        PERMISSIONS GROUP_READ GROUP_EXECUTE OWNER_EXECUTE OWNER_WRITE OWNER_READ WORLD_EXECUTE WORLD_READ)
diff --git a/run/O2HitMerger.h b/run/O2HitMerger.h
index 520873e7aaafe..d32f6370ca2db 100644
--- a/run/O2HitMerger.h
+++ b/run/O2HitMerger.h
@@ -78,6 +78,7 @@
 #include <RICHSimulation/Detector.h>
 #include <ECalSimulation/Detector.h>
 #include <MI3Simulation/Detector.h>
+#include <FD3Simulation/Detector.h>
 #endif
 
 #include <tbb/concurrent_unordered_map.h>
@@ -1009,6 +1010,10 @@ void O2HitMerger::initDetInstances()
       mDetectorInstances[i] = std::move(std::make_unique<o2::ecal::Detector>(true));
       counter++;
     }
+    if (i == DetID::FD3) {
+      mDetectorInstances[i] = std::move(std::make_unique<o2::fd3::Detector>(true));
+      counter++;
+    }
 #endif
   }
   if (counter != DetID::nDetectors) {
diff --git a/run/o2simdefaultdetectorlist.json b/run/o2simdefaultdetectorlist.json
index 697fafcba5872..2a7e977be741d 100644
--- a/run/o2simdefaultdetectorlist.json
+++ b/run/o2simdefaultdetectorlist.json
@@ -58,6 +58,7 @@
     "RCH",
     "MI3",
     "ECL",
+    "FD3",
     "HALL",
     "MAG",
     "A3IP",

From 10dd81bb69076661742cc85d8238de0fe96a3824 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Sun, 5 Oct 2025 07:26:05 +0200
Subject: [PATCH 0943/1764] Generators: Embedd into correct event when using
 collision-context

This fixes a problem with embedding and when option `--embedIntoFile`
is used. Here, we had an index problem in the primary generator class, which
was not taking into account the actual event index according the collision context.
This could lead to wrong vertices or using wrong MCHeader information for the embedding decision.
---
 .../include/Generators/PrimaryGenerator.h     |  3 +++
 Generators/src/PrimaryGenerator.cxx           | 25 +++++++++---------
 run/O2PrimaryServerDevice.h                   | 26 +++++++++++++++++++
 3 files changed, 42 insertions(+), 12 deletions(-)

diff --git a/Generators/include/Generators/PrimaryGenerator.h b/Generators/include/Generators/PrimaryGenerator.h
index 097bfabf4ef57..cd4d842761418 100644
--- a/Generators/include/Generators/PrimaryGenerator.h
+++ b/Generators/include/Generators/PrimaryGenerator.h
@@ -80,6 +80,9 @@ class PrimaryGenerator : public FairPrimaryGenerator
   /** Public embedding methods **/
   Bool_t embedInto(TString fname);
 
+  /// sets the embedding index
+  void setEmbedIndex(int idx) { mEmbedIndex = idx; }
+
   void setExternalVertexForNextEvent(double x, double y, double z);
 
   // sets the vertex mode; if mode is kCCDB, a valid MeanVertexObject pointer must be given at the same time
diff --git a/Generators/src/PrimaryGenerator.cxx b/Generators/src/PrimaryGenerator.cxx
index ee7c6a16330f9..e7b70108a5d4b 100644
--- a/Generators/src/PrimaryGenerator.cxx
+++ b/Generators/src/PrimaryGenerator.cxx
@@ -81,7 +81,7 @@ Bool_t PrimaryGenerator::GenerateEvent(FairGenericStack* pStack)
   /** generate event **/
 
   /** normal generation if no embedding **/
-  if (!mEmbedTree) {
+  if (!mEmbedTree || mEmbedIndex < 0) {
     fixInteractionVertex(); // <-- always fixes vertex outside of FairROOT
     auto ret = FairPrimaryGenerator::GenerateEvent(pStack);
     if (ret) {
@@ -91,17 +91,18 @@ Bool_t PrimaryGenerator::GenerateEvent(FairGenericStack* pStack)
   }
 
   /** this is for embedding **/
-
-  /** setup interaction vertex **/
-  mEmbedTree->GetEntry(mEmbedIndex);
-  setInteractionVertex(mEmbedEvent);
-
-  /** notify event generators **/
-  auto genList = GetListOfGenerators();
-  for (int igen = 0; igen < genList->GetEntries(); ++igen) {
-    auto o2gen = dynamic_cast<Generator*>(genList->At(igen));
-    if (o2gen) {
-      o2gen->notifyEmbedding(mEmbedEvent);
+  if (mEmbedIndex >= 0) {
+    /** setup interaction vertex **/
+    mEmbedTree->GetEntry(mEmbedIndex);
+    setInteractionVertex(mEmbedEvent);
+
+    /** notify event generators **/
+    auto genList = GetListOfGenerators();
+    for (int igen = 0; igen < genList->GetEntries(); ++igen) {
+      auto o2gen = dynamic_cast<Generator*>(genList->At(igen));
+      if (o2gen) {
+        o2gen->notifyEmbedding(mEmbedEvent);
+      }
     }
   }
 
diff --git a/run/O2PrimaryServerDevice.h b/run/O2PrimaryServerDevice.h
index ece3747b2c94a..4eecf79cffdb6 100644
--- a/run/O2PrimaryServerDevice.h
+++ b/run/O2PrimaryServerDevice.h
@@ -46,6 +46,7 @@
 #include <chrono>
 #include <CCDB/BasicCCDBManager.h>
 #include <TRandom3.h>
+#include <regex>
 
 namespace o2
 {
@@ -135,6 +136,17 @@ class O2PrimaryServerDevice final : public fair::mq::Device
 
       auto embedinto_filename = conf.getEmbedIntoFileName();
       if (!embedinto_filename.empty()) {
+        // determine the sim prefix from the embedding filename
+        // the filename should be an MCHeader file ... so it should match SOME_PATH/prefix_MCHeader.root
+        std::regex re(R"((.*/)?([^/]+)_MCHeader\.root$)");
+        std::smatch match;
+
+        if (std::regex_search(embedinto_filename, match, re)) {
+          std::cout << "Extracted embedding prefix : " << match[2] << '\n';
+          mEmbeddIntoPrefix = match[2];
+        } else {
+          LOG(fatal) << "Embedding asked but no suitable embedding prefix extractable from " << embedinto_filename;
+        }
         mPrimGen->embedInto(embedinto_filename);
       }
 
@@ -197,6 +209,19 @@ class O2PrimaryServerDevice final : public fair::mq::Device
             auto& vertex = vertices.at(collisionindex);
             LOG(info) << "Setting vertex " << vertex << " for event " << mEventCounter << " for prefix " << mSimConfig.getOutPrefix() << " from CollContext";
             mPrimGen->setExternalVertexForNextEvent(vertex.X(), vertex.Y(), vertex.Z());
+
+            // set correct embedding index for PrimaryGenerator ... based on collision context for embedding
+            auto& collisionParts = mCollissionContext->getEventParts()[collisionindex];
+            int background_index = -1; // -1 means no embedding taking place for this signal
+
+            // find the part that corresponds to the event embeded into
+            for (auto& part : collisionParts) {
+              if (mCollissionContext->getSimPrefixes()[part.sourceID] == mEmbeddIntoPrefix) {
+                background_index = part.entryID;
+                LOG(info) << "Setting embedding index to " << background_index;
+              }
+            }
+            mPrimGen->setEmbedIndex(background_index);
           }
         }
         mPrimGen->GenerateEvent(mStack);
@@ -696,6 +721,7 @@ class O2PrimaryServerDevice final : public fair::mq::Device
   // some information specific to use case when we have a collision context
   o2::steer::DigitizationContext* mCollissionContext = nullptr; //!
   std::unordered_map<int, int> mEventID_to_CollID;              //!
+  std::string mEmbeddIntoPrefix;                                //! sim prefix of background events
 
   TRandom3 mSeedGenerator; //! specific random generator for seed generation for work chunks
 };

From 92548325d37460f34df364291b4d1f15ebc9215d Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Fri, 17 Oct 2025 15:31:27 +0200
Subject: [PATCH 0944/1764] GPU: Replace assertions with error counters in ZS
 decoding.

---
 GPU/GPUTracking/Global/GPUErrorCodes.h        |   6 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     | 156 ++++++++++++------
 .../TPCClusterFinder/GPUTPCCFDecodeZS.h       |   9 +-
 GPU/GPUTracking/kernels.cmake                 |   2 +-
 4 files changed, 116 insertions(+), 57 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUErrorCodes.h b/GPU/GPUTracking/Global/GPUErrorCodes.h
index 8fec23be00a09..a4921f478b107 100644
--- a/GPU/GPUTracking/Global/GPUErrorCodes.h
+++ b/GPU/GPUTracking/Global/GPUErrorCodes.h
@@ -47,6 +47,10 @@ GPUCA_ERROR_CODE(26, ERROR_TPCZS_INVALID_ROW, SectorRow)
 GPUCA_ERROR_CODE(27, ERROR_TPCZS_INVALID_NADC, SectorCRU, SamplesInPage, SamplesWritten)  // Invalid number of ADC samples in header, existing samples were decoded
 GPUCA_ERROR_CODE(28, ERROR_TPCZS_INCOMPLETE_HBF, SectorCRU, PacketCount, NextPacketCount) // Part of HBF is missing, decoding incomplete
 GPUCA_ERROR_CODE(29, ERROR_TPCZS_INVALID_OFFSET, SectorEndpoint, Value, Expected)         // Raw page is skipped since it contains invalid payload offset
-GPUCA_ERROR_CODE(29, MAX_GPUCA_ERROR_NUMBER)
+GPUCA_ERROR_CODE(30, ERROR_TPCZS_INVALID_MAGIC_WORD, Value)                               // ZS header contains wrong magic word
+GPUCA_ERROR_CODE(31, ERROR_TPCZS_PAGE_OVERFLOW, Position, PageEnd)                        // Ran out of page to decode
+GPUCA_ERROR_CODE(32, ERROR_TPCZS_VERSION_MISMATCH, Value, Expected)                       // ZS decoder received page with wrong version
+GPUCA_ERROR_CODE(33, ERROR_TPCZS_UNKNOWN, ErrorCode)                                      // Unkown or invalid error code raised in decoder
+GPUCA_ERROR_CODE(33, MAX_GPUCA_ERROR_NUMBER)
 
 // #define GPUCA_CHECK_TPCZS_CORRUPTION
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index f7bb64106fe4f..a548217e26b64 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -604,61 +604,107 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
   const auto* decHeader = Peek<TPCZSHDRV2>(page, raw::RDHUtils::getMemorySize(*rawDataHeader) - sizeof(TPCZSHDRV2));
   ConsumeHeader<header::RAWDataHeader>(page);
 
-  assert(decHeader->version >= ZSVersionDenseLinkBased);
-  assert(decHeader->magicWord == tpc::zerosupp_link_based::CommonHeader::MagicWordLinkZSMetaHeader);
-
   uint16_t nSamplesWritten = 0;
   const uint16_t nSamplesInPage = decHeader->nADCsamples;
 
   const auto* payloadEnd = Peek(pageStart, raw::RDHUtils::getMemorySize(*rawDataHeader) - sizeof(TPCZSHDRV2) - ((decHeader->flags & TPCZSHDRV2::ZSFlags::TriggerWordPresent) ? TPCZSHDRV2::TRIGGER_WORD_SIZE : 0));
   const auto* nextPage = Peek(pageStart, TPCZSHDR::TPC_ZS_PAGE_SIZE);
 
+  const bool extendsToNextPage = decHeader->flags & TPCZSHDRV2::ZSFlags::payloadExtendsToNextPage;
+
   ConsumeBytes(page, decHeader->firstZSDataOffset - sizeof(o2::header::RAWDataHeader));
 
-  for (uint16_t i = 0; i < decHeader->nTimebinHeaders; i++) {
+  int err = GPUErrors::ERROR_NONE;
 
-    [[maybe_unused]] ptrdiff_t sizeLeftInPage = payloadEnd - page;
-    assert(sizeLeftInPage > 0);
+  if (decHeader->version < ZSVersionDenseLinkBased) {
+    err = GPUErrors::ERROR_TPCZS_VERSION_MISMATCH;
+  }
 
-    uint16_t nSamplesWrittenTB = 0;
+  if (decHeader->magicWord != zerosupp_link_based::CommonHeader::MagicWordLinkZSMetaHeader) {
+    err = GPUErrors::ERROR_TPCZS_INVALID_MAGIC_WORD;
+  }
+
+  for (uint16_t i = 0; i < decHeader->nTimebinHeaders && !err; i++) {
+
+    ptrdiff_t sizeLeftInPage = payloadEnd - page;
+    if (sizeLeftInPage <= 0) {
+      err = GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;
+      break;
+    }
+
+    int16_t nSamplesWrittenTB = 0;
+    uint16_t nSamplesLeftInPage = nSamplesInPage - nSamplesWritten;
+
+    if (i == decHeader->nTimebinHeaders - 1 && extendsToNextPage) {
+      if (raw::RDHUtils::getMemorySize(*rawDataHeader) != TPCZSHDR::TPC_ZS_PAGE_SIZE) {
+        err = GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;
+        break;
+      }
 
-    if (i == decHeader->nTimebinHeaders - 1 && decHeader->flags & o2::tpc::TPCZSHDRV2::ZSFlags::payloadExtendsToNextPage) {
-      assert(o2::raw::RDHUtils::getMemorySize(*rawDataHeader) == TPCZSHDR::TPC_ZS_PAGE_SIZE);
       if ((uint16_t)(raw::RDHUtils::getPageCounter(rawDataHeader) + 1) == raw::RDHUtils::getPageCounter(nextPage)) {
-        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, payloadEnd, nextPage);
+        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
       } else {
-        nSamplesWrittenTB = FillWithInvalid(clusterer, iThread, nThreads, pageDigitOffset, nSamplesInPage - nSamplesWritten);
-#ifdef GPUCA_CHECK_TPCZS_CORRUPTION
-        if (iThread == 0) {
-          clusterer.raiseError(GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF, clusterer.mISector * 1000 + decHeader->cruID, raw::RDHUtils::getPageCounter(rawDataHeader), raw::RDHUtils::getPageCounter(nextPage));
-        }
-#endif
+        err = GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF;
+        break;
       }
     } else {
-      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, payloadEnd, nextPage);
+      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
+    }
+
+    // Abort decoding the page if an error was detected.
+    if (nSamplesWrittenTB < 0) {
+      err = -nSamplesWrittenTB;
+      break;
     }
 
-    assert(nSamplesWritten <= nSamplesInPage);
     nSamplesWritten += nSamplesWrittenTB;
     pageDigitOffset += nSamplesWrittenTB;
   } // for (uint16_t i = 0; i < decHeader->nTimebinHeaders; i++)
 
-#ifdef GPUCA_CHECK_TPCZS_CORRUPTION
-  if (iThread == 0 && nSamplesWritten != nSamplesInPage) {
-    clusterer.raiseError(GPUErrors::ERROR_TPCZS_INVALID_NADC, clusterer.mISector * 1000 + decHeader->cruID, nSamplesInPage, nSamplesWritten);
-    /*#ifndef GPUCA_GPUCODE
-            FILE* foo = fopen("dump.bin", "w+b");
-            fwrite(pageSrc, 1, o2::raw::RDHUtils::getMemorySize(*rdHdr), foo);
-            fclose(foo);
-    #endif*/
+  if (nSamplesWritten != nSamplesInPage) {
+    if (nSamplesWritten < nSamplesInPage) {
+      pageDigitOffset += FillWithInvalid(clusterer, iThread, nThreads, pageDigitOffset, nSamplesInPage - nSamplesWritten);
+    }
+    err = !err ? GPUErrors::ERROR_TPCZS_INVALID_NADC : err; // Ensure we don't overwrite any previous error
   }
+
+  if (iThread == 0 && err) {
+    [[maybe_unused]] bool dumpPage = false;
+
+    if (err == GPUErrors::ERROR_TPCZS_VERSION_MISMATCH) {
+      clusterer.raiseError(err, decHeader->version, ZSVersionDenseLinkBased);
+    } else if (err == GPUErrors::ERROR_TPCZS_INVALID_MAGIC_WORD) {
+      clusterer.raiseError(err, decHeader->magicWord);
+    } else if (err == GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF) {
+      clusterer.raiseError(err, clusterer.mISector * 1000 + decHeader->cruID, raw::RDHUtils::getPageCounter(rawDataHeader), raw::RDHUtils::getPageCounter(nextPage));
+    } else if (err == GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW) {
+      clusterer.raiseError(err, extendsToNextPage);
+      dumpPage = true;
+    } else if (err == GPUErrors::ERROR_TPCZS_INVALID_NADC) {
+      clusterer.raiseError(err, nSamplesInPage, nSamplesWritten, extendsToNextPage);
+      dumpPage = true;
+    } else {
+      clusterer.raiseError(GPUErrors::ERROR_TPCZS_UNKNOWN, err);
+    }
+
+#ifdef GPUCA_CHECK_TPCZS_CORRUPTION
+#ifndef GPUCA_GPUCODE
+    if (dumpPage) {
+      // allocate more space on the stack for fname, so it can be overwritten by hand in a debugger.
+      const char fname[64] = "dump00.bin";
+      FILE* foo = fopen(fname, "w+b");
+      fwrite(pageStart, 1, TPCZSHDR::TPC_ZS_PAGE_SIZE, foo);
+      fclose(foo);
+    }
+#endif
 #endif
+  }
 
   return pageDigitOffset;
 }
 
 template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
+GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
   processorType& clusterer,
   [[maybe_unused]] GPUSharedMemory& smem,
   int32_t iThread,
@@ -667,23 +713,24 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
-  [[maybe_unused]] const uint8_t* payloadEnd,
-  [[maybe_unused]] const uint8_t* nextPage)
+  uint16_t nSamplesLeftInPage,
+  const uint8_t* payloadEnd,
+  const uint8_t* nextPage)
 {
 
   if constexpr (DecodeInParallel) {
-    return DecodeTBMultiThread<PayloadExtendsToNextPage>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, cru, payloadEnd, nextPage);
+    return DecodeTBMultiThread<PayloadExtendsToNextPage>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, cru, nSamplesLeftInPage, payloadEnd, nextPage);
   } else {
-    uint16_t nSamplesWritten = 0;
+    int16_t nSamplesWritten = 0;
     if (iThread == 0) {
-      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(clusterer, page, pageDigitOffset, rawDataHeader, firstHBF, cru, payloadEnd, nextPage);
+      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(clusterer, page, pageDigitOffset, rawDataHeader, firstHBF, cru, nSamplesLeftInPage, payloadEnd, nextPage);
     }
     return warp_broadcast(nSamplesWritten, 0);
   }
 }
 
 template <bool PayloadExtendsToNextPage>
-GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
+GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   processorType& clusterer,
   GPUSharedMemory& smem,
   const int32_t iThread,
@@ -692,8 +739,9 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
-  [[maybe_unused]] const uint8_t* payloadEnd,
-  [[maybe_unused]] const uint8_t* nextPage)
+  uint16_t nSamplesLeftInPage,
+  const uint8_t* payloadEnd,
+  const uint8_t* nextPage)
 {
 #define MAYBE_PAGE_OVERFLOW(pagePtr)                               \
   if constexpr (PayloadExtendsToNextPage) {                        \
@@ -703,7 +751,9 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
       ConsumeBytes(pagePtr, sizeof(header::RAWDataHeader) + diff); \
     }                                                              \
   } else {                                                         \
-    assert(pagePtr <= payloadEnd);                                 \
+    if (pagePtr > payloadEnd) {                                    \
+      return -GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;                \
+    }                                                              \
   }
 
 #define PEEK_OVERFLOW(pagePtr, offset)                                                      \
@@ -728,7 +778,7 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   uint16_t linkBC = (tbbHdr & 0xFFF0) >> 4;
   int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
 
-  uint16_t nSamplesInTB = 0;
+  int16_t nSamplesInTB = 0;
 
   // Read timebin link headers
   for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++) {
@@ -747,7 +797,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
     }
 
     int32_t nBytesBitmask = CAMath::Popcount(bitmaskL2);
-    assert(nBytesBitmask <= 10);
 
     for (int32_t chan = iThread; chan < CAMath::nextMultipleOf<NTHREADS>(80); chan += NTHREADS) {
       int32_t chanL2Idx = chan / 8;
@@ -756,7 +805,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
       int32_t chanByteOffset = nBytesBitmask - 1 - CAMath::Popcount(bitmaskL2 >> (chanL2Idx + 1));
 
       uint8_t myChannelHasData = (chan < 80 && l2 ? TEST_BIT(PEEK_OVERFLOW(page, chanByteOffset), chan % 8) : 0);
-      assert(myChannelHasData == 0 || myChannelHasData == 1);
 
       int32_t nSamplesStep;
       int32_t threadSampleOffset = CfUtils::warpPredicateScan(myChannelHasData, &nSamplesStep);
@@ -779,13 +827,17 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   GPUbarrierWarp(); // Ensure all writes to shared memory are finished, before reading it
 
-  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
-  MAYBE_PAGE_OVERFLOW(page); // TODO: We don't need this check?
+  if (nSamplesInTB > nSamplesLeftInPage) {
+    return -GPUErrors::ERROR_TPCZS_INVALID_NADC;
+  }
 
   if (not fragment.contains(timeBin)) {
     return FillWithInvalid(clusterer, iThread, NTHREADS, pageDigitOffset, nSamplesInTB);
   }
 
+  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
+  MAYBE_PAGE_OVERFLOW(page);
+
   // Unpack ADC
   int32_t iLink = 0;
   for (uint16_t sample = iThread; sample < nSamplesInTB; sample += NTHREADS) {
@@ -821,9 +873,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   GPUbarrierWarp(); // Ensure all reads to shared memory are finished, before decoding next header into shmem
 
-  assert(PayloadExtendsToNextPage || adcData <= page);
-  assert(PayloadExtendsToNextPage || page <= payloadEnd);
-
   return nSamplesInTB;
 
 #undef TEST_BIT
@@ -832,13 +881,14 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 }
 
 template <bool PayloadExtendsToNextPage>
-GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
+GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
   processorType& clusterer,
   const uint8_t*& page,
   uint32_t pageDigitOffset,
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
+  uint16_t nSamplesLeftInPage,
   [[maybe_unused]] const uint8_t* payloadEnd,
   [[maybe_unused]] const uint8_t* nextPage)
 {
@@ -850,7 +900,9 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
       ConsumeBytes(pagePtr, sizeof(header::RAWDataHeader) + diff); \
     }                                                              \
   } else {                                                         \
-    assert(pagePtr <= payloadEnd);                                 \
+    if (pagePtr > payloadEnd) {                                    \
+      return -GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;                \
+    }                                                              \
   }
 
   using zerosupp_link_based::ChannelPerTBHeader;
@@ -898,14 +950,18 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
 
   } // for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++)
 
-  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
-  MAYBE_PAGE_OVERFLOW(page);
+  if (nSamplesInTB > nSamplesLeftInPage) {
+    return -GPUErrors::ERROR_TPCZS_INVALID_NADC;
+  }
 
   if (not fragment.contains(timeBin)) {
     FillWithInvalid(clusterer, 0, 1, pageDigitOffset, nSamplesInTB);
     return nSamplesInTB;
   }
 
+  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
+  MAYBE_PAGE_OVERFLOW(page);
+
   // Unpack ADC
   uint32_t byte = 0, bits = 0;
   uint16_t rawFECChannel = 0;
@@ -937,10 +993,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
     } // while (bits >= DECODE_BITS)
   } // while (nSamplesWritten < nAdc)
 
-  assert(PayloadExtendsToNextPage || adcData <= page);
-  assert(PayloadExtendsToNextPage || page <= payloadEnd);
-  assert(nSamplesWritten == nSamplesInTB);
-
   return nSamplesWritten;
 
 #undef MAYBE_PAGE_OVERFLOW
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
index e476674e030f9..4697462a8c504 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
@@ -167,14 +167,17 @@ class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
 
   GPUd() static bool ChannelIsActive(const uint8_t* chan, uint16_t chanIndex);
 
+  // Decode a single timebin within an 8kb page.
+  // Returns the number of samples decoded from the page
+  // or negative value to indicate an error (no samples are written in this case)
   template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-  GPUd() static uint16_t DecodeTB(processorType& clusterer, GPUSharedMemory& smem, int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTB(processorType& clusterer, GPUSharedMemory& smem, int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 
   template <bool PayloadExtendsToNextPage>
-  GPUd() static uint16_t DecodeTBSingleThread(processorType& clusterer, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTBSingleThread(processorType& clusterer, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 
   template <bool PayloadExtendsToNextPage>
-  GPUd() static uint16_t DecodeTBMultiThread(processorType& clusterer, GPUSharedMemory& smem, const int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTBMultiThread(processorType& clusterer, GPUSharedMemory& smem, const int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index c8ddcd2e9d81d..84726ea9fb8d0 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -120,7 +120,7 @@ o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                    "= TPC
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"               "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage CfChargePos* in CfChargePos* out)
 o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                      "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF)
 o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                                  "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS ERRORS"                               LB int32_t firstHBF)
 o2_gpu_add_kernel("GPUTPCCFGather"                                        "="                                                     LB o2::tpc::ClusterNative* dest)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                    "= GLOBALREFIT "                                        LB)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"            "= GLOBALREFIT "                                        LB)

From cafd48e9f370ce1ddaa08474e78c56198fe4f8ed Mon Sep 17 00:00:00 2001
From: David Rohr <github@jwdt.org>
Date: Tue, 21 Oct 2025 09:45:13 +0200
Subject: [PATCH 0945/1764] Revert "GPU: Replace assertions with error counters
 in ZS decoding."

This reverts commit 92548325d37460f34df364291b4d1f15ebc9215d.
---
 GPU/GPUTracking/Global/GPUErrorCodes.h        |   6 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     | 156 ++++++------------
 .../TPCClusterFinder/GPUTPCCFDecodeZS.h       |   9 +-
 GPU/GPUTracking/kernels.cmake                 |   2 +-
 4 files changed, 57 insertions(+), 116 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUErrorCodes.h b/GPU/GPUTracking/Global/GPUErrorCodes.h
index a4921f478b107..8fec23be00a09 100644
--- a/GPU/GPUTracking/Global/GPUErrorCodes.h
+++ b/GPU/GPUTracking/Global/GPUErrorCodes.h
@@ -47,10 +47,6 @@ GPUCA_ERROR_CODE(26, ERROR_TPCZS_INVALID_ROW, SectorRow)
 GPUCA_ERROR_CODE(27, ERROR_TPCZS_INVALID_NADC, SectorCRU, SamplesInPage, SamplesWritten)  // Invalid number of ADC samples in header, existing samples were decoded
 GPUCA_ERROR_CODE(28, ERROR_TPCZS_INCOMPLETE_HBF, SectorCRU, PacketCount, NextPacketCount) // Part of HBF is missing, decoding incomplete
 GPUCA_ERROR_CODE(29, ERROR_TPCZS_INVALID_OFFSET, SectorEndpoint, Value, Expected)         // Raw page is skipped since it contains invalid payload offset
-GPUCA_ERROR_CODE(30, ERROR_TPCZS_INVALID_MAGIC_WORD, Value)                               // ZS header contains wrong magic word
-GPUCA_ERROR_CODE(31, ERROR_TPCZS_PAGE_OVERFLOW, Position, PageEnd)                        // Ran out of page to decode
-GPUCA_ERROR_CODE(32, ERROR_TPCZS_VERSION_MISMATCH, Value, Expected)                       // ZS decoder received page with wrong version
-GPUCA_ERROR_CODE(33, ERROR_TPCZS_UNKNOWN, ErrorCode)                                      // Unkown or invalid error code raised in decoder
-GPUCA_ERROR_CODE(33, MAX_GPUCA_ERROR_NUMBER)
+GPUCA_ERROR_CODE(29, MAX_GPUCA_ERROR_NUMBER)
 
 // #define GPUCA_CHECK_TPCZS_CORRUPTION
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index a548217e26b64..f7bb64106fe4f 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -604,107 +604,61 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
   const auto* decHeader = Peek<TPCZSHDRV2>(page, raw::RDHUtils::getMemorySize(*rawDataHeader) - sizeof(TPCZSHDRV2));
   ConsumeHeader<header::RAWDataHeader>(page);
 
+  assert(decHeader->version >= ZSVersionDenseLinkBased);
+  assert(decHeader->magicWord == tpc::zerosupp_link_based::CommonHeader::MagicWordLinkZSMetaHeader);
+
   uint16_t nSamplesWritten = 0;
   const uint16_t nSamplesInPage = decHeader->nADCsamples;
 
   const auto* payloadEnd = Peek(pageStart, raw::RDHUtils::getMemorySize(*rawDataHeader) - sizeof(TPCZSHDRV2) - ((decHeader->flags & TPCZSHDRV2::ZSFlags::TriggerWordPresent) ? TPCZSHDRV2::TRIGGER_WORD_SIZE : 0));
   const auto* nextPage = Peek(pageStart, TPCZSHDR::TPC_ZS_PAGE_SIZE);
 
-  const bool extendsToNextPage = decHeader->flags & TPCZSHDRV2::ZSFlags::payloadExtendsToNextPage;
-
   ConsumeBytes(page, decHeader->firstZSDataOffset - sizeof(o2::header::RAWDataHeader));
 
-  int err = GPUErrors::ERROR_NONE;
+  for (uint16_t i = 0; i < decHeader->nTimebinHeaders; i++) {
 
-  if (decHeader->version < ZSVersionDenseLinkBased) {
-    err = GPUErrors::ERROR_TPCZS_VERSION_MISMATCH;
-  }
+    [[maybe_unused]] ptrdiff_t sizeLeftInPage = payloadEnd - page;
+    assert(sizeLeftInPage > 0);
 
-  if (decHeader->magicWord != zerosupp_link_based::CommonHeader::MagicWordLinkZSMetaHeader) {
-    err = GPUErrors::ERROR_TPCZS_INVALID_MAGIC_WORD;
-  }
-
-  for (uint16_t i = 0; i < decHeader->nTimebinHeaders && !err; i++) {
-
-    ptrdiff_t sizeLeftInPage = payloadEnd - page;
-    if (sizeLeftInPage <= 0) {
-      err = GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;
-      break;
-    }
-
-    int16_t nSamplesWrittenTB = 0;
-    uint16_t nSamplesLeftInPage = nSamplesInPage - nSamplesWritten;
-
-    if (i == decHeader->nTimebinHeaders - 1 && extendsToNextPage) {
-      if (raw::RDHUtils::getMemorySize(*rawDataHeader) != TPCZSHDR::TPC_ZS_PAGE_SIZE) {
-        err = GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;
-        break;
-      }
+    uint16_t nSamplesWrittenTB = 0;
 
+    if (i == decHeader->nTimebinHeaders - 1 && decHeader->flags & o2::tpc::TPCZSHDRV2::ZSFlags::payloadExtendsToNextPage) {
+      assert(o2::raw::RDHUtils::getMemorySize(*rawDataHeader) == TPCZSHDR::TPC_ZS_PAGE_SIZE);
       if ((uint16_t)(raw::RDHUtils::getPageCounter(rawDataHeader) + 1) == raw::RDHUtils::getPageCounter(nextPage)) {
-        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
+        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, payloadEnd, nextPage);
       } else {
-        err = GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF;
-        break;
+        nSamplesWrittenTB = FillWithInvalid(clusterer, iThread, nThreads, pageDigitOffset, nSamplesInPage - nSamplesWritten);
+#ifdef GPUCA_CHECK_TPCZS_CORRUPTION
+        if (iThread == 0) {
+          clusterer.raiseError(GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF, clusterer.mISector * 1000 + decHeader->cruID, raw::RDHUtils::getPageCounter(rawDataHeader), raw::RDHUtils::getPageCounter(nextPage));
+        }
+#endif
       }
     } else {
-      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
-    }
-
-    // Abort decoding the page if an error was detected.
-    if (nSamplesWrittenTB < 0) {
-      err = -nSamplesWrittenTB;
-      break;
+      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, payloadEnd, nextPage);
     }
 
+    assert(nSamplesWritten <= nSamplesInPage);
     nSamplesWritten += nSamplesWrittenTB;
     pageDigitOffset += nSamplesWrittenTB;
   } // for (uint16_t i = 0; i < decHeader->nTimebinHeaders; i++)
 
-  if (nSamplesWritten != nSamplesInPage) {
-    if (nSamplesWritten < nSamplesInPage) {
-      pageDigitOffset += FillWithInvalid(clusterer, iThread, nThreads, pageDigitOffset, nSamplesInPage - nSamplesWritten);
-    }
-    err = !err ? GPUErrors::ERROR_TPCZS_INVALID_NADC : err; // Ensure we don't overwrite any previous error
-  }
-
-  if (iThread == 0 && err) {
-    [[maybe_unused]] bool dumpPage = false;
-
-    if (err == GPUErrors::ERROR_TPCZS_VERSION_MISMATCH) {
-      clusterer.raiseError(err, decHeader->version, ZSVersionDenseLinkBased);
-    } else if (err == GPUErrors::ERROR_TPCZS_INVALID_MAGIC_WORD) {
-      clusterer.raiseError(err, decHeader->magicWord);
-    } else if (err == GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF) {
-      clusterer.raiseError(err, clusterer.mISector * 1000 + decHeader->cruID, raw::RDHUtils::getPageCounter(rawDataHeader), raw::RDHUtils::getPageCounter(nextPage));
-    } else if (err == GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW) {
-      clusterer.raiseError(err, extendsToNextPage);
-      dumpPage = true;
-    } else if (err == GPUErrors::ERROR_TPCZS_INVALID_NADC) {
-      clusterer.raiseError(err, nSamplesInPage, nSamplesWritten, extendsToNextPage);
-      dumpPage = true;
-    } else {
-      clusterer.raiseError(GPUErrors::ERROR_TPCZS_UNKNOWN, err);
-    }
-
 #ifdef GPUCA_CHECK_TPCZS_CORRUPTION
-#ifndef GPUCA_GPUCODE
-    if (dumpPage) {
-      // allocate more space on the stack for fname, so it can be overwritten by hand in a debugger.
-      const char fname[64] = "dump00.bin";
-      FILE* foo = fopen(fname, "w+b");
-      fwrite(pageStart, 1, TPCZSHDR::TPC_ZS_PAGE_SIZE, foo);
-      fclose(foo);
-    }
-#endif
-#endif
+  if (iThread == 0 && nSamplesWritten != nSamplesInPage) {
+    clusterer.raiseError(GPUErrors::ERROR_TPCZS_INVALID_NADC, clusterer.mISector * 1000 + decHeader->cruID, nSamplesInPage, nSamplesWritten);
+    /*#ifndef GPUCA_GPUCODE
+            FILE* foo = fopen("dump.bin", "w+b");
+            fwrite(pageSrc, 1, o2::raw::RDHUtils::getMemorySize(*rdHdr), foo);
+            fclose(foo);
+    #endif*/
   }
+#endif
 
   return pageDigitOffset;
 }
 
 template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
+GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
   processorType& clusterer,
   [[maybe_unused]] GPUSharedMemory& smem,
   int32_t iThread,
@@ -713,24 +667,23 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
-  uint16_t nSamplesLeftInPage,
-  const uint8_t* payloadEnd,
-  const uint8_t* nextPage)
+  [[maybe_unused]] const uint8_t* payloadEnd,
+  [[maybe_unused]] const uint8_t* nextPage)
 {
 
   if constexpr (DecodeInParallel) {
-    return DecodeTBMultiThread<PayloadExtendsToNextPage>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, cru, nSamplesLeftInPage, payloadEnd, nextPage);
+    return DecodeTBMultiThread<PayloadExtendsToNextPage>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, cru, payloadEnd, nextPage);
   } else {
-    int16_t nSamplesWritten = 0;
+    uint16_t nSamplesWritten = 0;
     if (iThread == 0) {
-      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(clusterer, page, pageDigitOffset, rawDataHeader, firstHBF, cru, nSamplesLeftInPage, payloadEnd, nextPage);
+      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(clusterer, page, pageDigitOffset, rawDataHeader, firstHBF, cru, payloadEnd, nextPage);
     }
     return warp_broadcast(nSamplesWritten, 0);
   }
 }
 
 template <bool PayloadExtendsToNextPage>
-GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
+GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   processorType& clusterer,
   GPUSharedMemory& smem,
   const int32_t iThread,
@@ -739,9 +692,8 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
-  uint16_t nSamplesLeftInPage,
-  const uint8_t* payloadEnd,
-  const uint8_t* nextPage)
+  [[maybe_unused]] const uint8_t* payloadEnd,
+  [[maybe_unused]] const uint8_t* nextPage)
 {
 #define MAYBE_PAGE_OVERFLOW(pagePtr)                               \
   if constexpr (PayloadExtendsToNextPage) {                        \
@@ -751,9 +703,7 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
       ConsumeBytes(pagePtr, sizeof(header::RAWDataHeader) + diff); \
     }                                                              \
   } else {                                                         \
-    if (pagePtr > payloadEnd) {                                    \
-      return -GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;                \
-    }                                                              \
+    assert(pagePtr <= payloadEnd);                                 \
   }
 
 #define PEEK_OVERFLOW(pagePtr, offset)                                                      \
@@ -778,7 +728,7 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   uint16_t linkBC = (tbbHdr & 0xFFF0) >> 4;
   int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
 
-  int16_t nSamplesInTB = 0;
+  uint16_t nSamplesInTB = 0;
 
   // Read timebin link headers
   for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++) {
@@ -797,6 +747,7 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
     }
 
     int32_t nBytesBitmask = CAMath::Popcount(bitmaskL2);
+    assert(nBytesBitmask <= 10);
 
     for (int32_t chan = iThread; chan < CAMath::nextMultipleOf<NTHREADS>(80); chan += NTHREADS) {
       int32_t chanL2Idx = chan / 8;
@@ -805,6 +756,7 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
       int32_t chanByteOffset = nBytesBitmask - 1 - CAMath::Popcount(bitmaskL2 >> (chanL2Idx + 1));
 
       uint8_t myChannelHasData = (chan < 80 && l2 ? TEST_BIT(PEEK_OVERFLOW(page, chanByteOffset), chan % 8) : 0);
+      assert(myChannelHasData == 0 || myChannelHasData == 1);
 
       int32_t nSamplesStep;
       int32_t threadSampleOffset = CfUtils::warpPredicateScan(myChannelHasData, &nSamplesStep);
@@ -827,17 +779,13 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   GPUbarrierWarp(); // Ensure all writes to shared memory are finished, before reading it
 
-  if (nSamplesInTB > nSamplesLeftInPage) {
-    return -GPUErrors::ERROR_TPCZS_INVALID_NADC;
-  }
+  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
+  MAYBE_PAGE_OVERFLOW(page); // TODO: We don't need this check?
 
   if (not fragment.contains(timeBin)) {
     return FillWithInvalid(clusterer, iThread, NTHREADS, pageDigitOffset, nSamplesInTB);
   }
 
-  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
-  MAYBE_PAGE_OVERFLOW(page);
-
   // Unpack ADC
   int32_t iLink = 0;
   for (uint16_t sample = iThread; sample < nSamplesInTB; sample += NTHREADS) {
@@ -873,6 +821,9 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   GPUbarrierWarp(); // Ensure all reads to shared memory are finished, before decoding next header into shmem
 
+  assert(PayloadExtendsToNextPage || adcData <= page);
+  assert(PayloadExtendsToNextPage || page <= payloadEnd);
+
   return nSamplesInTB;
 
 #undef TEST_BIT
@@ -881,14 +832,13 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 }
 
 template <bool PayloadExtendsToNextPage>
-GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
+GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
   processorType& clusterer,
   const uint8_t*& page,
   uint32_t pageDigitOffset,
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
-  uint16_t nSamplesLeftInPage,
   [[maybe_unused]] const uint8_t* payloadEnd,
   [[maybe_unused]] const uint8_t* nextPage)
 {
@@ -900,9 +850,7 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
       ConsumeBytes(pagePtr, sizeof(header::RAWDataHeader) + diff); \
     }                                                              \
   } else {                                                         \
-    if (pagePtr > payloadEnd) {                                    \
-      return -GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;                \
-    }                                                              \
+    assert(pagePtr <= payloadEnd);                                 \
   }
 
   using zerosupp_link_based::ChannelPerTBHeader;
@@ -950,18 +898,14 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
 
   } // for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++)
 
-  if (nSamplesInTB > nSamplesLeftInPage) {
-    return -GPUErrors::ERROR_TPCZS_INVALID_NADC;
-  }
+  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
+  MAYBE_PAGE_OVERFLOW(page);
 
   if (not fragment.contains(timeBin)) {
     FillWithInvalid(clusterer, 0, 1, pageDigitOffset, nSamplesInTB);
     return nSamplesInTB;
   }
 
-  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
-  MAYBE_PAGE_OVERFLOW(page);
-
   // Unpack ADC
   uint32_t byte = 0, bits = 0;
   uint16_t rawFECChannel = 0;
@@ -993,6 +937,10 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
     } // while (bits >= DECODE_BITS)
   } // while (nSamplesWritten < nAdc)
 
+  assert(PayloadExtendsToNextPage || adcData <= page);
+  assert(PayloadExtendsToNextPage || page <= payloadEnd);
+  assert(nSamplesWritten == nSamplesInTB);
+
   return nSamplesWritten;
 
 #undef MAYBE_PAGE_OVERFLOW
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
index 4697462a8c504..e476674e030f9 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
@@ -167,17 +167,14 @@ class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
 
   GPUd() static bool ChannelIsActive(const uint8_t* chan, uint16_t chanIndex);
 
-  // Decode a single timebin within an 8kb page.
-  // Returns the number of samples decoded from the page
-  // or negative value to indicate an error (no samples are written in this case)
   template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTB(processorType& clusterer, GPUSharedMemory& smem, int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static uint16_t DecodeTB(processorType& clusterer, GPUSharedMemory& smem, int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
 
   template <bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTBSingleThread(processorType& clusterer, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static uint16_t DecodeTBSingleThread(processorType& clusterer, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
 
   template <bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTBMultiThread(processorType& clusterer, GPUSharedMemory& smem, const int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static uint16_t DecodeTBMultiThread(processorType& clusterer, GPUSharedMemory& smem, const int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 84726ea9fb8d0..c8ddcd2e9d81d 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -120,7 +120,7 @@ o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                    "= TPC
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"               "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage CfChargePos* in CfChargePos* out)
 o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                      "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF)
 o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                                  "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS ERRORS"                               LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
 o2_gpu_add_kernel("GPUTPCCFGather"                                        "="                                                     LB o2::tpc::ClusterNative* dest)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                    "= GLOBALREFIT "                                        LB)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"            "= GLOBALREFIT "                                        LB)

From 721c0d9cb54987471ed9e219880af689af97c5be Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 20 Oct 2025 11:52:50 +0200
Subject: [PATCH 0946/1764] GPU Standalone: Add setMaxTimeBin debug option

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h       | 1 +
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 8 +++++++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 8cf6b29a43d96..957631e571b76 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -573,6 +573,7 @@ AddOption(noEvents, bool, false, "", 0, "Run without data (e.g. for field visual
 AddOption(eventDisplay, int32_t, 0, "display", 'd', "Show standalone event display", def(1))
 AddOption(eventGenerator, bool, false, "", 0, "Run event generator")
 AddOption(cont, bool, false, "", 0, "Process continuous timeframe data, even if input is triggered")
+AddOption(setMaxTimeBin, int32_t, -2, "", 0, "maximum time bin of continuous data, 0 for triggered events, -1 for automatic continuous mode, -2 for automatic continuous / triggered")
 AddOption(outputcontrolmem, uint64_t, 0, "outputMemory", 0, "Use predefined output buffer of this size", min(0ul), message("Using %s bytes as output memory"))
 AddOption(inputcontrolmem, uint64_t, 0, "inputMemory", 0, "Use predefined input buffer of this size", min(0ul), message("Using %s bytes as input memory"))
 AddOption(cpuAffinity, int32_t, -1, "", 0, "Pin CPU affinity to this CPU core", min(-1))
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 4fe1691afef50..11d32394ccfb9 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -331,9 +331,15 @@ int32_t SetupReconstruction()
       grp.grpContinuousMaxTimeBin = configStandalone.TF.timeFrameLen * ((double)GPUReconstructionTimeframe::TPCZ / (double)GPUReconstructionTimeframe::DRIFT_TIME) / chainTracking->GetTPCTransformHelper()->getCorrMap()->getVDrift();
     }
   }
-  if (configStandalone.cont && grp.grpContinuousMaxTimeBin == 0) {
+  if (configStandalone.setMaxTimeBin != -2) {
+    grp.grpContinuousMaxTimeBin = configStandalone.setMaxTimeBin;
+  } else if (configStandalone.cont && grp.grpContinuousMaxTimeBin == 0) {
     grp.grpContinuousMaxTimeBin = -1;
   }
+  if (grp.grpContinuousMaxTimeBin < -1 && !configStandalone.noEvents) {
+    printf("Invalid maxTimeBin %d\n", grp.grpContinuousMaxTimeBin);
+    return 1;
+  }
   if (rec->GetDeviceType() == GPUReconstruction::DeviceType::CPU) {
     printf("Standalone Test Framework for CA Tracker - Using CPU\n");
   } else {

From 37085da9d0534b52ce31d5661166618e81025add Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 20 Oct 2025 11:54:12 +0200
Subject: [PATCH 0947/1764] GPU TPC: Fix track Z offset in triggered mode

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx            |  4 ++--
 GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx       |  4 ++--
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx        |  2 +-
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.h        | 12 ++++++------
 .../SectorTracker/GPUTPCTrackletConstructor.cxx      | 10 +++++++---
 5 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 9a4b129f751a4..16d96dad17d16 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -561,7 +561,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
   trk.SinPhi() = inTrack->Param().GetSinPhi();
   trk.DzDs() = inTrack->Param().GetDzDs();
   trk.QPt() = inTrack->Param().GetQPt();
-  trk.TOffset() = GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin);
+  trk.TOffset() = Param().par.continuousTracking ? GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin) : 0;
   const auto tmp = sectorTrack.ClusterTN() > sectorTrack.ClusterT0() ? std::array<float, 2>{sectorTrack.ClusterTN(), sectorTrack.ClusterT0()} : std::array<float, 2>{sectorTrack.ClusterT0(), sectorTrack.ClusterTN()};
   trk.ShiftZ(this, sector, tmp[0], tmp[1], inTrack->Param().GetX()); // We do not store the inner / outer cluster X, so we just use the track X instead
   sectorTrack.SetX2(0.f);
@@ -1939,7 +1939,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads,
     const float qptabs = CAMath::Abs(p.GetQPt());
     if (trk.OK() && trk.NClusters() && trk.Leg() == 0 && qptabs * Param().qptB5Scaler > 5.f && qptabs * Param().qptB5Scaler <= lowPtThresh) {
       const int32_t sector = mClusters[trk.FirstClusterRef() + trk.NClusters() - 1].sector;
-      const float refz = p.GetZ() + GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, p.GetTOffset(), Param().continuousMaxTimeBin) + (trk.CSide() ? -100 : 100);
+      const float refz = p.GetZ() + (Param().par.continuousTracking ? GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, p.GetTOffset(), Param().continuousMaxTimeBin) : 0) + (trk.CSide() ? -100 : 100);
       float sinA, cosA;
       CAMath::SinCos(trk.GetAlpha(), sinA, cosA);
       float gx = cosA * p.GetX() - sinA * p.GetY();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index bce70ea79f322..1c3d842b0419a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -323,7 +323,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToX(GPUTPCGMMerger* merger, float x, f
   b.SetPar(2, ey1);
   b.SetPar(3, param.mDzDs);
   b.SetPar(4, param.mQPt);
-  b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin));
+  b.SetZOffsetLinear(merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin) : 0);
 
   if (!doCov) {
     return (1);
@@ -478,7 +478,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToXAlpha(GPUTPCGMMerger* merger, float
   b.SetPar(2, ey1);
   b.SetPar(3, dzds);
   b.SetPar(4, qpt);
-  b.SetZOffsetLinear(merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin));
+  b.SetZOffsetLinear(merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin) : 0);
 
   b.SetCov(0, c00 + h2 * h2c22 + h4 * h4c44 + 2.f * (h2 * c20ph4c42 + h4 * c40));
   b.SetCov(1, c11 + dS * (c31 + n7));
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index d865a3b6899b4..970b42f6ee78a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -506,7 +506,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
     return -1e6f;
   }
 
-  const float zOffset = Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, Merger->Param().continuousMaxTimeBin);
+  const float zOffset = Merger->Param().par.continuousTracking ? Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, Merger->Param().continuousMaxTimeBin) : 0;
   const float y0 = row.Grid().YMin();
   const float stepY = row.HstepY();
   const float z0 = row.Grid().ZMin() - zOffset; // We can use our own ZOffset, since this is only used temporarily anyway
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
index aee429c959e98..5efd3ca845410 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
@@ -77,19 +77,19 @@ class GPUTPCTracker : public GPUProcessor
 
   GPUdi() static void GetErrors2Seeding(const GPUParam& param, char sector, int32_t iRow, const GPUTPCTrackParam& t, float time, float& ErrY2, float& ErrZ2)
   {
-    // param.GetClusterErrors2(sector, iRow, param.GetContinuousTracking() != 0. ? 125.f : t.Z(), t.SinPhi(), t.DzDs(), time, 0.f, 0.f, ErrY2, ErrZ2);
-    param.GetClusterErrorsSeeding2(sector, iRow, param.par.continuousTracking != 0.f ? 125.f : t.Z(), t.SinPhi(), t.DzDs(), time, ErrY2, ErrZ2);
+    // param.GetClusterErrors2(sector, iRow, param.continuousTracking ? 125.f : t.Z(), t.SinPhi(), t.DzDs(), time, 0.f, 0.f, ErrY2, ErrZ2);
+    param.GetClusterErrorsSeeding2(sector, iRow, param.par.continuousTracking ? 125.f : t.Z(), t.SinPhi(), t.DzDs(), time, ErrY2, ErrZ2);
   }
 
   GPUdi() void GetErrors2Seeding(int32_t iRow, const GPUTPCTrackParam& t, float time, float& ErrY2, float& ErrZ2) const
   {
-    // Param().GetClusterErrors2(mISector, iRow, Param().GetContinuousTracking() != 0. ? 125.f : t.Z(), t.SinPhi(), t.DzDs(), time, 0.f, 0.f, ErrY2, ErrZ2);
-    Param().GetClusterErrorsSeeding2(mISector, iRow, Param().par.continuousTracking != 0.f ? 125.f : t.Z(), t.SinPhi(), t.DzDs(), time, ErrY2, ErrZ2);
+    // Param().GetClusterErrors2(mISector, iRow, Param().continuousTracking ? 125.f : t.Z(), t.SinPhi(), t.DzDs(), time, 0.f, 0.f, ErrY2, ErrZ2);
+    Param().GetClusterErrorsSeeding2(mISector, iRow, Param().par.continuousTracking ? 125.f : t.Z(), t.SinPhi(), t.DzDs(), time, ErrY2, ErrZ2);
   }
   GPUdi() void GetErrors2Seeding(int32_t iRow, float z, float sinPhi, float DzDs, float time, float& ErrY2, float& ErrZ2) const
   {
-    // Param().GetClusterErrors2(mISector, iRow, Param().GetContinuousTracking() != 0. ? 125.f : z, sinPhi, DzDs, time, 0.f, 0.f, ErrY2, ErrZ2);
-    Param().GetClusterErrorsSeeding2(mISector, iRow, Param().par.continuousTracking != 0.f ? 125.f : z, sinPhi, DzDs, time, ErrY2, ErrZ2);
+    // Param().GetClusterErrors2(mISector, iRow, Param().continuousTracking ? 125.f : z, sinPhi, DzDs, time, 0.f, 0.f, ErrY2, ErrZ2);
+    Param().GetClusterErrorsSeeding2(mISector, iRow, Param().par.continuousTracking ? 125.f : z, sinPhi, DzDs, time, ErrY2, ErrZ2);
   }
 
   void SetupCommonMemory();
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
index 0b22bfa57c89e..567e4e93cc524 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
@@ -131,8 +131,10 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
       float x = row.X();
       float y = y0 + hh.x * stepY;
       float z = z0 + hh.y * stepZ;
-      if (iRow != r.mStartRow || !tracker.Param().par.continuousTracking) {
-        tParam.ConstrainZ(z, tracker.ISector(), z0, r.mLastZ);
+      if (iRow != r.mStartRow) {
+        if (tracker.Param().par.continuousTracking) {
+          tParam.ConstrainZ(z, tracker.ISector(), z0, r.mLastZ);
+        }
         tracker.GetConstantMem()->calibObjects.fastTransformHelper->TransformXYZ(tracker.ISector(), iRow, x, y, z);
       }
       if (iRow == r.mStartRow) {
@@ -262,7 +264,9 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
           rowHit = CALINK_INVAL;
           break;
         }
-        tParam.ConstrainZ(tmpZ, tracker.ISector(), z0, r.mLastZ);
+        if (tracker.Param().par.continuousTracking) {
+          tParam.ConstrainZ(tmpZ, tracker.ISector(), z0, r.mLastZ);
+        }
         tracker.GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoX(tracker.ISector(), iRow, tmpY, tmpZ, x);
       }
 

From 731ba643e2397cf2f1d89555f6d74b0d43df5836 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 21 Oct 2025 15:27:05 +0200
Subject: [PATCH 0948/1764] GPU: Fix TPC Z Offset computation in triggered mode
 in one more place

---
 GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index 1c3d842b0419a..6042dec7d4931 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -37,7 +37,7 @@ GPUd() void GPUTPCGMSectorTrack::Set(const GPUTPCGMMerger* merger, const GPUTPCT
   mParam.mSecPhi = 1.f / mParam.mCosPhi;
   mAlpha = alpha;
   mSector = sector;
-  mTOffset = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, t.GetZOffset(), merger->Param().continuousMaxTimeBin);
+  mTOffset = merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, t.GetZOffset(), merger->Param().continuousMaxTimeBin) : 0;
   mNClusters = sectorTr->NHits();
 }
 

From 7277814d0a9822e342462787a4d5a088144391a3 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Fri, 17 Oct 2025 15:31:27 +0200
Subject: [PATCH 0949/1764] GPU: Replace assertions with error counters in ZS
 decoding.

---
 GPU/GPUTracking/Global/GPUErrorCodes.h        |   6 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     | 155 ++++++++++++------
 .../TPCClusterFinder/GPUTPCCFDecodeZS.h       |   9 +-
 GPU/GPUTracking/kernels.cmake                 |   2 +-
 4 files changed, 116 insertions(+), 56 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUErrorCodes.h b/GPU/GPUTracking/Global/GPUErrorCodes.h
index 8fec23be00a09..a4921f478b107 100644
--- a/GPU/GPUTracking/Global/GPUErrorCodes.h
+++ b/GPU/GPUTracking/Global/GPUErrorCodes.h
@@ -47,6 +47,10 @@ GPUCA_ERROR_CODE(26, ERROR_TPCZS_INVALID_ROW, SectorRow)
 GPUCA_ERROR_CODE(27, ERROR_TPCZS_INVALID_NADC, SectorCRU, SamplesInPage, SamplesWritten)  // Invalid number of ADC samples in header, existing samples were decoded
 GPUCA_ERROR_CODE(28, ERROR_TPCZS_INCOMPLETE_HBF, SectorCRU, PacketCount, NextPacketCount) // Part of HBF is missing, decoding incomplete
 GPUCA_ERROR_CODE(29, ERROR_TPCZS_INVALID_OFFSET, SectorEndpoint, Value, Expected)         // Raw page is skipped since it contains invalid payload offset
-GPUCA_ERROR_CODE(29, MAX_GPUCA_ERROR_NUMBER)
+GPUCA_ERROR_CODE(30, ERROR_TPCZS_INVALID_MAGIC_WORD, Value)                               // ZS header contains wrong magic word
+GPUCA_ERROR_CODE(31, ERROR_TPCZS_PAGE_OVERFLOW, Position, PageEnd)                        // Ran out of page to decode
+GPUCA_ERROR_CODE(32, ERROR_TPCZS_VERSION_MISMATCH, Value, Expected)                       // ZS decoder received page with wrong version
+GPUCA_ERROR_CODE(33, ERROR_TPCZS_UNKNOWN, ErrorCode)                                      // Unkown or invalid error code raised in decoder
+GPUCA_ERROR_CODE(33, MAX_GPUCA_ERROR_NUMBER)
 
 // #define GPUCA_CHECK_TPCZS_CORRUPTION
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index f7bb64106fe4f..54af72f08a432 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -604,61 +604,107 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
   const auto* decHeader = Peek<TPCZSHDRV2>(page, raw::RDHUtils::getMemorySize(*rawDataHeader) - sizeof(TPCZSHDRV2));
   ConsumeHeader<header::RAWDataHeader>(page);
 
-  assert(decHeader->version >= ZSVersionDenseLinkBased);
-  assert(decHeader->magicWord == tpc::zerosupp_link_based::CommonHeader::MagicWordLinkZSMetaHeader);
-
   uint16_t nSamplesWritten = 0;
   const uint16_t nSamplesInPage = decHeader->nADCsamples;
 
   const auto* payloadEnd = Peek(pageStart, raw::RDHUtils::getMemorySize(*rawDataHeader) - sizeof(TPCZSHDRV2) - ((decHeader->flags & TPCZSHDRV2::ZSFlags::TriggerWordPresent) ? TPCZSHDRV2::TRIGGER_WORD_SIZE : 0));
   const auto* nextPage = Peek(pageStart, TPCZSHDR::TPC_ZS_PAGE_SIZE);
 
+  const bool extendsToNextPage = decHeader->flags & TPCZSHDRV2::ZSFlags::payloadExtendsToNextPage;
+
   ConsumeBytes(page, decHeader->firstZSDataOffset - sizeof(o2::header::RAWDataHeader));
 
-  for (uint16_t i = 0; i < decHeader->nTimebinHeaders; i++) {
+  int err = GPUErrors::ERROR_NONE;
+
+  if (decHeader->version < ZSVersionDenseLinkBased) {
+    err = GPUErrors::ERROR_TPCZS_VERSION_MISMATCH;
+  }
 
-    [[maybe_unused]] ptrdiff_t sizeLeftInPage = payloadEnd - page;
-    assert(sizeLeftInPage > 0);
+  if (decHeader->magicWord != zerosupp_link_based::CommonHeader::MagicWordLinkZSMetaHeader) {
+    err = GPUErrors::ERROR_TPCZS_INVALID_MAGIC_WORD;
+  }
 
-    uint16_t nSamplesWrittenTB = 0;
+  for (uint16_t i = 0; i < decHeader->nTimebinHeaders && !err; i++) {
+
+    ptrdiff_t sizeLeftInPage = payloadEnd - page;
+    if (sizeLeftInPage <= 0) {
+      err = GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;
+      break;
+    }
+
+    int16_t nSamplesWrittenTB = 0;
+    uint16_t nSamplesLeftInPage = nSamplesInPage - nSamplesWritten;
+
+    if (i == decHeader->nTimebinHeaders - 1 && extendsToNextPage) {
+      if (raw::RDHUtils::getMemorySize(*rawDataHeader) != TPCZSHDR::TPC_ZS_PAGE_SIZE) {
+        err = GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;
+        break;
+      }
 
-    if (i == decHeader->nTimebinHeaders - 1 && decHeader->flags & o2::tpc::TPCZSHDRV2::ZSFlags::payloadExtendsToNextPage) {
-      assert(o2::raw::RDHUtils::getMemorySize(*rawDataHeader) == TPCZSHDR::TPC_ZS_PAGE_SIZE);
       if ((uint16_t)(raw::RDHUtils::getPageCounter(rawDataHeader) + 1) == raw::RDHUtils::getPageCounter(nextPage)) {
-        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, payloadEnd, nextPage);
+        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
       } else {
-        nSamplesWrittenTB = FillWithInvalid(clusterer, iThread, nThreads, pageDigitOffset, nSamplesInPage - nSamplesWritten);
-#ifdef GPUCA_CHECK_TPCZS_CORRUPTION
-        if (iThread == 0) {
-          clusterer.raiseError(GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF, clusterer.mISector * 1000 + decHeader->cruID, raw::RDHUtils::getPageCounter(rawDataHeader), raw::RDHUtils::getPageCounter(nextPage));
-        }
-#endif
+        err = GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF;
+        break;
       }
     } else {
-      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, payloadEnd, nextPage);
+      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
+    }
+
+    // Abort decoding the page if an error was detected.
+    if (nSamplesWrittenTB < 0) {
+      err = -nSamplesWrittenTB;
+      break;
     }
 
-    assert(nSamplesWritten <= nSamplesInPage);
     nSamplesWritten += nSamplesWrittenTB;
     pageDigitOffset += nSamplesWrittenTB;
   } // for (uint16_t i = 0; i < decHeader->nTimebinHeaders; i++)
 
-#ifdef GPUCA_CHECK_TPCZS_CORRUPTION
-  if (iThread == 0 && nSamplesWritten != nSamplesInPage) {
-    clusterer.raiseError(GPUErrors::ERROR_TPCZS_INVALID_NADC, clusterer.mISector * 1000 + decHeader->cruID, nSamplesInPage, nSamplesWritten);
-    /*#ifndef GPUCA_GPUCODE
-            FILE* foo = fopen("dump.bin", "w+b");
-            fwrite(pageSrc, 1, o2::raw::RDHUtils::getMemorySize(*rdHdr), foo);
-            fclose(foo);
-    #endif*/
+  if (nSamplesWritten != nSamplesInPage) {
+    if (nSamplesWritten < nSamplesInPage) {
+      pageDigitOffset += FillWithInvalid(clusterer, iThread, nThreads, pageDigitOffset, nSamplesInPage - nSamplesWritten);
+    }
+    err = !err ? GPUErrors::ERROR_TPCZS_INVALID_NADC : err; // Ensure we don't overwrite any previous error
   }
+
+  if (iThread == 0 && err) {
+    [[maybe_unused]] bool dumpPage = false;
+
+    if (err == GPUErrors::ERROR_TPCZS_VERSION_MISMATCH) {
+      clusterer.raiseError(err, decHeader->version, ZSVersionDenseLinkBased);
+    } else if (err == GPUErrors::ERROR_TPCZS_INVALID_MAGIC_WORD) {
+      clusterer.raiseError(err, decHeader->magicWord);
+    } else if (err == GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF) {
+      clusterer.raiseError(err, clusterer.mISector * 1000 + decHeader->cruID, raw::RDHUtils::getPageCounter(rawDataHeader), raw::RDHUtils::getPageCounter(nextPage));
+    } else if (err == GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW) {
+      clusterer.raiseError(err, extendsToNextPage);
+      dumpPage = true;
+    } else if (err == GPUErrors::ERROR_TPCZS_INVALID_NADC) {
+      clusterer.raiseError(err, nSamplesInPage, nSamplesWritten, extendsToNextPage);
+      dumpPage = true;
+    } else {
+      clusterer.raiseError(GPUErrors::ERROR_TPCZS_UNKNOWN, err);
+    }
+
+#ifdef GPUCA_CHECK_TPCZS_CORRUPTION
+#ifndef GPUCA_GPUCODE
+    if (dumpPage) {
+      // allocate more space on the stack for fname, so it can be overwritten by hand in a debugger.
+      const char fname[64] = "dump00.bin";
+      FILE* foo = fopen(fname, "w+b");
+      fwrite(pageStart, 1, TPCZSHDR::TPC_ZS_PAGE_SIZE, foo);
+      fclose(foo);
+    }
 #endif
+#endif
+  }
 
   return pageDigitOffset;
 }
 
 template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
+GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
   processorType& clusterer,
   [[maybe_unused]] GPUSharedMemory& smem,
   int32_t iThread,
@@ -667,23 +713,24 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
-  [[maybe_unused]] const uint8_t* payloadEnd,
-  [[maybe_unused]] const uint8_t* nextPage)
+  uint16_t nSamplesLeftInPage,
+  const uint8_t* payloadEnd,
+  const uint8_t* nextPage)
 {
 
   if constexpr (DecodeInParallel) {
-    return DecodeTBMultiThread<PayloadExtendsToNextPage>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, cru, payloadEnd, nextPage);
+    return DecodeTBMultiThread<PayloadExtendsToNextPage>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, cru, nSamplesLeftInPage, payloadEnd, nextPage);
   } else {
-    uint16_t nSamplesWritten = 0;
+    int16_t nSamplesWritten = 0;
     if (iThread == 0) {
-      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(clusterer, page, pageDigitOffset, rawDataHeader, firstHBF, cru, payloadEnd, nextPage);
+      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(clusterer, page, pageDigitOffset, rawDataHeader, firstHBF, cru, nSamplesLeftInPage, payloadEnd, nextPage);
     }
     return warp_broadcast(nSamplesWritten, 0);
   }
 }
 
 template <bool PayloadExtendsToNextPage>
-GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
+GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   processorType& clusterer,
   GPUSharedMemory& smem,
   const int32_t iThread,
@@ -692,8 +739,9 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
-  [[maybe_unused]] const uint8_t* payloadEnd,
-  [[maybe_unused]] const uint8_t* nextPage)
+  uint16_t nSamplesLeftInPage,
+  const uint8_t* payloadEnd,
+  const uint8_t* nextPage)
 {
 #define MAYBE_PAGE_OVERFLOW(pagePtr)                               \
   if constexpr (PayloadExtendsToNextPage) {                        \
@@ -703,7 +751,9 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
       ConsumeBytes(pagePtr, sizeof(header::RAWDataHeader) + diff); \
     }                                                              \
   } else {                                                         \
-    assert(pagePtr <= payloadEnd);                                 \
+    if (pagePtr > payloadEnd) {                                    \
+      return -GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;                \
+    }                                                              \
   }
 
 #define PEEK_OVERFLOW(pagePtr, offset)                                                      \
@@ -728,7 +778,7 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   uint16_t linkBC = (tbbHdr & 0xFFF0) >> 4;
   int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
 
-  uint16_t nSamplesInTB = 0;
+  int16_t nSamplesInTB = 0;
 
   // Read timebin link headers
   for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++) {
@@ -747,7 +797,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
     }
 
     int32_t nBytesBitmask = CAMath::Popcount(bitmaskL2);
-    assert(nBytesBitmask <= 10);
 
     for (int32_t chan = iThread; chan < CAMath::nextMultipleOf<NTHREADS>(80); chan += NTHREADS) {
       int32_t chanL2Idx = chan / 8;
@@ -756,7 +805,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
       int32_t chanByteOffset = nBytesBitmask - 1 - CAMath::Popcount(bitmaskL2 >> (chanL2Idx + 1));
 
       uint8_t myChannelHasData = (chan < 80 && l2 ? TEST_BIT(PEEK_OVERFLOW(page, chanByteOffset), chan % 8) : 0);
-      assert(myChannelHasData == 0 || myChannelHasData == 1);
 
       int32_t nSamplesStep;
       int32_t threadSampleOffset = CfUtils::warpPredicateScan(myChannelHasData, &nSamplesStep);
@@ -779,8 +827,14 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   GPUbarrierWarp(); // Ensure all writes to shared memory are finished, before reading it
 
+  if (nSamplesInTB > nSamplesLeftInPage) {
+    return -GPUErrors::ERROR_TPCZS_INVALID_NADC;
+  }
+
+  // This needs to happen BEFORE checking if the timebin is in fragment
+  // to ensure ADC bytes are always consumed, even if data isn't decoded
   const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
-  MAYBE_PAGE_OVERFLOW(page); // TODO: We don't need this check?
+  MAYBE_PAGE_OVERFLOW(page);
 
   if (not fragment.contains(timeBin)) {
     return FillWithInvalid(clusterer, iThread, NTHREADS, pageDigitOffset, nSamplesInTB);
@@ -821,9 +875,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   GPUbarrierWarp(); // Ensure all reads to shared memory are finished, before decoding next header into shmem
 
-  assert(PayloadExtendsToNextPage || adcData <= page);
-  assert(PayloadExtendsToNextPage || page <= payloadEnd);
-
   return nSamplesInTB;
 
 #undef TEST_BIT
@@ -832,13 +883,14 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 }
 
 template <bool PayloadExtendsToNextPage>
-GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
+GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
   processorType& clusterer,
   const uint8_t*& page,
   uint32_t pageDigitOffset,
   const header::RAWDataHeader* rawDataHeader,
   int32_t firstHBF,
   int32_t cru,
+  uint16_t nSamplesLeftInPage,
   [[maybe_unused]] const uint8_t* payloadEnd,
   [[maybe_unused]] const uint8_t* nextPage)
 {
@@ -850,7 +902,9 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
       ConsumeBytes(pagePtr, sizeof(header::RAWDataHeader) + diff); \
     }                                                              \
   } else {                                                         \
-    assert(pagePtr <= payloadEnd);                                 \
+    if (pagePtr > payloadEnd) {                                    \
+      return -GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;                \
+    }                                                              \
   }
 
   using zerosupp_link_based::ChannelPerTBHeader;
@@ -898,12 +952,15 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
 
   } // for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++)
 
+  if (nSamplesInTB > nSamplesLeftInPage) {
+    return -GPUErrors::ERROR_TPCZS_INVALID_NADC;
+  }
+
   const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
   MAYBE_PAGE_OVERFLOW(page);
 
   if (not fragment.contains(timeBin)) {
-    FillWithInvalid(clusterer, 0, 1, pageDigitOffset, nSamplesInTB);
-    return nSamplesInTB;
+    return FillWithInvalid(clusterer, 0, 1, pageDigitOffset, nSamplesInTB);
   }
 
   // Unpack ADC
@@ -937,10 +994,6 @@ GPUd() uint16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
     } // while (bits >= DECODE_BITS)
   } // while (nSamplesWritten < nAdc)
 
-  assert(PayloadExtendsToNextPage || adcData <= page);
-  assert(PayloadExtendsToNextPage || page <= payloadEnd);
-  assert(nSamplesWritten == nSamplesInTB);
-
   return nSamplesWritten;
 
 #undef MAYBE_PAGE_OVERFLOW
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
index e476674e030f9..4697462a8c504 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
@@ -167,14 +167,17 @@ class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
 
   GPUd() static bool ChannelIsActive(const uint8_t* chan, uint16_t chanIndex);
 
+  // Decode a single timebin within an 8kb page.
+  // Returns the number of samples decoded from the page
+  // or negative value to indicate an error (no samples are written in this case)
   template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-  GPUd() static uint16_t DecodeTB(processorType& clusterer, GPUSharedMemory& smem, int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTB(processorType& clusterer, GPUSharedMemory& smem, int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 
   template <bool PayloadExtendsToNextPage>
-  GPUd() static uint16_t DecodeTBSingleThread(processorType& clusterer, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTBSingleThread(processorType& clusterer, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 
   template <bool PayloadExtendsToNextPage>
-  GPUd() static uint16_t DecodeTBMultiThread(processorType& clusterer, GPUSharedMemory& smem, const int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTBMultiThread(processorType& clusterer, GPUSharedMemory& smem, const int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index c8ddcd2e9d81d..84726ea9fb8d0 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -120,7 +120,7 @@ o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                    "= TPC
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"               "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage CfChargePos* in CfChargePos* out)
 o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                      "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF)
 o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                                  "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS ERRORS"                               LB int32_t firstHBF)
 o2_gpu_add_kernel("GPUTPCCFGather"                                        "="                                                     LB o2::tpc::ClusterNative* dest)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                    "= GLOBALREFIT "                                        LB)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"            "= GLOBALREFIT "                                        LB)

From fc241f407e5bf6997e7e747495800127d81a84e1 Mon Sep 17 00:00:00 2001
From: Hadi Hassan <hadi.hassan@cern.ch>
Date: Wed, 22 Oct 2025 18:05:19 +0900
Subject: [PATCH 0950/1764] Adding cuts for air (#14755)

---
 Detectors/FOCAL/simulation/data/simcuts.dat | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Detectors/FOCAL/simulation/data/simcuts.dat b/Detectors/FOCAL/simulation/data/simcuts.dat
index 744f67c3c81f4..870e38182f01c 100644
--- a/Detectors/FOCAL/simulation/data/simcuts.dat
+++ b/Detectors/FOCAL/simulation/data/simcuts.dat
@@ -14,3 +14,5 @@ FOC    3   1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  -1.  -
 FOC    6   5.e-5  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  -1.  -1    -1    -1    -1     1    -1     3    -1    -1    -1    -1    -1
 * Aluminium
 FOC    11  5.e-5  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  -1.  -1    -1    -1    -1     1    -1     3    -1    -1    -1    -1    -1
+* Air
+FOC    13  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  1.e-4  -1.  -1    -1    -1    -1     1    -1     3    -1    -1    -1    -1    -1

From 39824aefb8a05d0f3adff4c0ebcadc2d027ec274 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Wed, 22 Oct 2025 21:07:22 +0200
Subject: [PATCH 0951/1764] ALICE3-TRK: adding macro to check digitization
 output (#14736)

* ALICE3-TRK: adding macro to check digitization output

* Fixing build issues
---
 Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt  |   1 +
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |   4 +
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      |   2 +
 .../ALICE3/TRK/base/src/TRKBaseLinkDef.h      |   4 +-
 .../Upgrades/ALICE3/TRK/macros/CMakeLists.txt |  12 +
 .../ALICE3/TRK/macros/test/CMakeLists.txt     |  21 +
 .../ALICE3/TRK/macros/test/CheckDigits.C      | 387 ++++++++++++++++++
 .../ALICE3/TRK/macros/test/run_test.sh        |  10 +
 8 files changed, 440 insertions(+), 1 deletion(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/macros/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/macros/test/run_test.sh

diff --git a/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
index 645e3149e4ab7..e623239122658 100644
--- a/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
@@ -10,5 +10,6 @@
 # or submit itself to any jurisdiction.
 
 add_subdirectory(base)
+add_subdirectory(macros)
 add_subdirectory(simulation)
 add_subdirectory(workflow)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index a1e4b9321130f..b838940860e47 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -14,6 +14,7 @@
 
 #include <memory>
 #include <DetectorsCommonDataFormats/DetMatrixCache.h>
+#include "DetectorsCommonDataFormats/DetID.h"
 
 namespace o2
 {
@@ -127,10 +128,13 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   TString getMatrixPath(int index) const;
 
+#ifdef ENABLE_UPGRADES
   static const char* composeSymNameTRK(int d)
   {
     return Form("%s_%d", o2::detectors::DetID(o2::detectors::DetID::TRK).getName(), d);
   }
+#endif
+
   static const char* composeSymNameLayer(int d, int layer);
   static const char* composeSymNameStave(int d, int layer);
   static const char* composeSymNameChip(int d, int lr);
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 20088179f4dcc..e8907efb190da 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -367,10 +367,12 @@ void GeometryTGeo::fillMatrixCache(int mask)
 
 //__________________________________________________________________________
 
+#ifdef ENABLE_UPGRADES
 const char* GeometryTGeo::composeSymNameLayer(int d, int lr)
 {
   return Form("%s/%s%d", composeSymNameTRK(d), getTRKLayerPattern(), lr);
 }
+#endif
 
 const char* GeometryTGeo::composeSymNameStave(int d, int lr)
 {
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/TRKBaseLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/base/src/TRKBaseLinkDef.h
index f29dcd302537d..eee9a23eaf5e7 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/TRKBaseLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/TRKBaseLinkDef.h
@@ -15,8 +15,10 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::TRKBaseParam> + ;
+
 #pragma link C++ class o2::trk::GeometryTGeo +
 #pragma link C++ class o2::trk::TRKBaseParam + ;
-#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::TRKBaseParam> + ;
+#pragma link C++ class o2::trk::SegmentationChip + ;
 
 #endif
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/macros/CMakeLists.txt
new file mode 100644
index 0000000000000..9a2194afd3999
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/CMakeLists.txt
@@ -0,0 +1,12 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+add_subdirectory(test)
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
new file mode 100644
index 0000000000000..379207eb07481
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_test_root_macro(CheckDigits.C
+                       PUBLIC_LINK_LIBRARIES O2::ITSMFTBase
+                                             O2::ITSMFTSimulation
+                                             O2::TRKBase
+                                             O2::TRKSimulation
+                                             O2::MathUtils
+                                             O2::SimulationDataFormat
+                                             O2::DetectorsBase
+                                             O2::Steer
+                       LABELS trk COMPILE_ONLY)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
new file mode 100644
index 0000000000000..5d60592a96f41
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
@@ -0,0 +1,387 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CheckDigits.C
+/// \brief Simple macro to check TRK digits
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <TCanvas.h>
+#include <TFile.h>
+#include <TH2F.h>
+#include <TNtuple.h>
+#include <TString.h>
+#include <TTree.h>
+
+#include "TRKBase/SegmentationChip.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "ITSMFTSimulation/Hit.h"
+#include "MathUtils/Utils.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/IOMCTruthContainerView.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "DetectorsBase/GeometryManager.h"
+
+#include "DataFormatsITSMFT/ROFRecord.h"
+
+#endif
+
+#define ENABLE_UPGRADES
+
+void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile = "o2sim_HitsTRK.root", std::string inputGeom = "", std::string paramfile = "o2sim_par.root")
+{
+
+  using namespace o2::base;
+  using namespace o2::trk;
+
+  using o2::itsmft::Digit;
+  using o2::itsmft::Hit;
+
+  using o2::trk::SegmentationChip;
+
+  TFile* f = TFile::Open("CheckDigits.root", "recreate");
+
+  TNtuple* nt = new TNtuple("ntd", "digit ntuple", "id:x:y:z:rowD:colD:rowH:colH:xlH:zlH:xlcH:zlcH:dx:dz");
+  TNtuple* nt2 = new TNtuple("ntd2", "digit ntuple", "id:z:dxH:dzH"); /// maximum number of elements in a tuple = 15: doing a new tuple to store more variables
+
+  // Geometry
+  o2::base::GeometryManager::loadGeometry(inputGeom);
+  auto* gman = o2::trk::GeometryTGeo::Instance();
+  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+
+  SegmentationChip seg;
+  // seg.Print();
+
+  // Hits
+  TFile* hitFile = TFile::Open(hitfile.data());
+  TTree* hitTree = (TTree*)hitFile->Get("o2sim");
+  int nevH = hitTree->GetEntries(); // hits are stored as one event per entry
+  std::vector<std::vector<o2::itsmft::Hit>*> hitArray(nevH, nullptr);
+
+  std::vector<std::unordered_map<uint64_t, int>> mc2hitVec(nevH);
+
+  // Digits
+  TFile* digFile = TFile::Open(digifile.data());
+  TTree* digTree = (TTree*)digFile->Get("o2sim");
+
+  std::vector<o2::itsmft::Digit>* digArr = nullptr;
+  digTree->SetBranchAddress("TRKDigit", &digArr);
+
+  o2::dataformats::IOMCTruthContainerView* plabels = nullptr;
+  digTree->SetBranchAddress("TRKDigitMCTruth", &plabels);
+
+  // Get Read Out Frame arrays
+  std::vector<o2::itsmft::ROFRecord>* ROFRecordArrray = nullptr;
+  digTree->SetBranchAddress("TRKDigitROF", &ROFRecordArrray);
+  std::vector<o2::itsmft::ROFRecord>& ROFRecordArrrayRef = *ROFRecordArrray;
+
+  std::vector<o2::itsmft::MC2ROFRecord>* MC2ROFRecordArrray = nullptr;
+  digTree->SetBranchAddress("TRKDigitMC2ROF", &MC2ROFRecordArrray);
+  std::vector<o2::itsmft::MC2ROFRecord>& MC2ROFRecordArrrayRef = *MC2ROFRecordArrray;
+
+  digTree->GetEntry(0);
+
+  int nROFRec = (int)ROFRecordArrrayRef.size();
+  std::vector<int> mcEvMin(nROFRec, hitTree->GetEntries());
+  std::vector<int> mcEvMax(nROFRec, -1);
+  o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel> labels;
+  plabels->copyandflatten(labels);
+  delete plabels;
+
+  // >> build min and max MC events used by each ROF
+  for (int imc = MC2ROFRecordArrrayRef.size(); imc--;) {
+    const auto& mc2rof = MC2ROFRecordArrrayRef[imc];
+    // printf("MCRecord: ");
+    // mc2rof.print();
+
+    if (mc2rof.rofRecordID < 0) {
+      continue; // this MC event did not contribute to any ROF
+    }
+
+    for (int irfd = mc2rof.maxROF - mc2rof.minROF + 1; irfd--;) {
+
+      int irof = mc2rof.rofRecordID + irfd;
+
+      if (irof >= nROFRec) {
+        LOG(error) << "ROF=" << irof << " from MC2ROF record is >= N ROFs=" << nROFRec;
+      }
+      if (mcEvMin[irof] > imc) {
+        mcEvMin[irof] = imc;
+      }
+      if (mcEvMax[irof] < imc) {
+        mcEvMax[irof] = imc;
+      }
+    }
+  } // << build min and max MC events used by each ROF
+
+  unsigned int rofIndex = 0;
+  unsigned int rofNEntries = 0;
+
+  // LOOP on : ROFRecord array
+  for (unsigned int iROF = 0; iROF < ROFRecordArrrayRef.size(); iROF++) {
+
+    rofIndex = ROFRecordArrrayRef[iROF].getFirstEntry();
+    rofNEntries = ROFRecordArrrayRef[iROF].getNEntries();
+
+    // >> read and map MC events contributing to this ROF
+    for (int im = mcEvMin[iROF]; im <= mcEvMax[iROF]; im++) {
+
+      if (!hitArray[im]) {
+
+        hitTree->SetBranchAddress("TRKHit", &hitArray[im]);
+        hitTree->GetEntry(im);
+
+        auto& mc2hit = mc2hitVec[im];
+
+        for (int ih = hitArray[im]->size(); ih--;) {
+
+          const auto& hit = (*hitArray[im])[ih];
+          uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
+          mc2hit.emplace(key, ih);
+        }
+      }
+    }
+
+    // LOOP on : digits array
+    for (unsigned int iDigit = rofIndex; iDigit < rofIndex + rofNEntries; iDigit++) {
+      // if (iDigit % 10000 != 0) /// looking only at a small sample
+      //   continue;
+
+      if (iDigit % 1000 == 0)
+        std::cout << "Reading digit " << iDigit << " / " << digArr->size() << std::endl;
+
+      Int_t ix = (*digArr)[iDigit].getRow(), iz = (*digArr)[iDigit].getColumn();
+      Int_t iDetID = (*digArr)[iDigit].getChipIndex();
+      Int_t layer = gman->getLayer(iDetID);
+      Int_t disk = gman->getDisk(iDetID);
+      Int_t subDetID = gman->getSubDetID(iDetID);
+      Int_t petalCase = gman->getPetalCase(iDetID);
+      Int_t stave = gman->getStave(iDetID);
+      Int_t halfstave = gman->getHalfStave(iDetID);
+
+      Float_t x = 0.f, y = 0.f, z = 0.f;
+      Float_t x_flat = 0.f, z_flat = 0.f;
+
+      if (disk != -1) {
+        continue; // skip disks for the moment
+      }
+
+      if (subDetID != 0) {
+        seg.detectorToLocal(ix, iz, x, z, subDetID, layer, disk);
+      } else if (subDetID == 0) {
+        seg.detectorToLocal(ix, iz, x_flat, z_flat, subDetID, layer, disk);
+        o2::math_utils::Vector2D<float> xyCurved = seg.flatToCurved(layer, x_flat, 0.);
+        x = xyCurved.X();
+        y = xyCurved.Y();
+        z = z_flat;
+      }
+
+      o2::math_utils::Point3D<float> locD(x, y, z);     // local Digit curved
+      o2::math_utils::Point3D<float> locDF(-1, -1, -1); // local Digit flat
+
+      Int_t chipID = (*digArr)[iDigit].getChipIndex();
+      auto lab = (labels.getLabels(iDigit))[0];
+
+      int trID = lab.getTrackID();
+
+      if (!lab.isValid()) { // not a noise
+        continue;
+      }
+
+      const auto gloD = gman->getMatrixL2G(chipID)(locD); // convert to global
+
+      std::unordered_map<uint64_t, int>* mc2hit = &mc2hitVec[lab.getEventID()];
+
+      // get MC info
+      uint64_t key = (uint64_t(trID) << 32) + chipID;
+      auto hitEntry = mc2hit->find(key);
+
+      if (hitEntry == mc2hit->end()) {
+
+        LOG(error) << "Failed to find MC hit entry for Tr" << trID << " chipID" << chipID;
+        continue;
+      }
+
+      ////// HITS
+      Hit& hit = (*hitArray[lab.getEventID()])[hitEntry->second];
+
+      auto xyzLocE = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
+      auto xyzLocS = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
+
+      o2::math_utils::Vector3D<float> locH; /// Hit, average between start and end pos
+      locH.SetCoordinates(0.5f * (xyzLocE.X() + xyzLocS.X()), 0.5f * (xyzLocE.Y() + xyzLocS.Y()), 0.5f * (xyzLocE.Z() + xyzLocS.Z()));
+      o2::math_utils::Vector3D<float> locHS; /// Hit, start pos
+      locHS.SetCoordinates(xyzLocS.X(), xyzLocS.Y(), xyzLocS.Z());
+      o2::math_utils::Vector3D<float> locHE; /// Hit, end pos
+      locHE.SetCoordinates(xyzLocE.X(), xyzLocE.Y(), xyzLocE.Z());
+      o2::math_utils::Vector3D<float> locHF;
+
+      int row = 0, col = 0;
+      float xlc = 0., zlc = 0.;
+
+      if (subDetID == 0) {
+        Float_t x_flat = 0.f, y_flat = 0.f;
+        o2::math_utils::Vector2D<float> xyFlatH = seg.curvedToFlat(layer, locH.X(), locH.Y());
+        o2::math_utils::Vector2D<float> xyFlatD = seg.curvedToFlat(layer, locD.X(), locD.Y());
+        locDF.SetCoordinates(xyFlatD.X(), xyFlatD.Y(), locD.Z());
+        locHF.SetCoordinates(xyFlatH.X(), xyFlatH.Y(), locH.Z());
+        seg.localToDetector(locHF.X(), locHF.Z(), row, col, subDetID, layer, disk);
+      }
+
+      else {
+        seg.localToDetector(locH.X(), locH.Z(), row, col, subDetID, layer, disk);
+      }
+
+      seg.detectorToLocal(row, col, xlc, zlc, subDetID, layer, disk);
+
+      if (subDetID == 0) {
+        nt->Fill(chipID,                                        /// detector ID
+                 gloD.X(), gloD.Y(), gloD.Z(),                  /// global position retrieved from the digit: digit (row, col) ->local position -> global potision
+                 ix, iz,                                        /// row and column of the digit
+                 row, col,                                      /// row and col retrieved from the hit: hit global position -> hit local position -> detector position (row, col)
+                 locH.X(), locH.Z(),                            /// x and z of the hit in the local reference frame: hit global position -> hit local position
+                 xlc, zlc,                                      /// x and z of the hit in the local frame: hit global position -> hit local position -> detector position (row, col) -> local position
+                 locHF.X() - locDF.X(), locHF.Z() - locDF.Z()); /// difference in x and z between the hit and the digit in the local frame
+
+        nt2->Fill(chipID, gloD.Z(), locHS.X() - locHE.X(), locHS.Z() - locHE.Z()); /// differences between local hit start and hit end positions
+      } else {
+
+        nt->Fill(chipID,                                                           /// detector ID
+                 gloD.X(), gloD.Y(), gloD.Z(),                                     /// global position retrieved from the digit: digit (row, col) ->local position -> global potision
+                 ix, iz,                                                           /// row and column of the digit
+                 row, col,                                                         /// row and col retrieved from the hit: hit global position -> hit local position -> detector position (row, col)
+                 locH.X(), locH.Z(),                                               /// x and z of the hit in the local reference frame: hit global position -> hit local position
+                 xlc, zlc,                                                         /// x and z of the hit in the local frame: hit global position -> hit local position -> detector position (row, col) -> local position
+                 locH.X() - locD.X(), locH.Z() - locD.Z());                        /// difference in x and z between the hit and the digit in the local frame
+                                                                                   //  locHS.X() - locHE.X(), locHS.Z() - locHE.Z()); /// difference in x and z between the hit and the digit in the local frame
+        nt2->Fill(chipID, gloD.Z(), locHS.X() - locHE.X(), locHS.Z() - locHE.Z()); /// differences between local hit start and hit end positions
+      }
+
+    } // end loop on digits array
+
+  } // end loop on ROFRecords array
+
+  // digit maps in the xy and yz planes
+  auto canvXY = new TCanvas("canvXY", "", 1600, 2400);
+  canvXY->Divide(2, 3);
+  canvXY->cd(1);
+  nt->Draw("y:x >>h_y_vs_x_VD(1000, -3, 3, 1000, -3, 3)", "id < 36 ", "colz");
+  canvXY->cd(2);
+  nt->Draw("y:z>>h_y_vs_z_VD(1000, -26, 26, 1000, -3, 3)", "id < 36 ", "colz");
+  canvXY->cd(3);
+  nt->Draw("y:x>>h_y_vs_x_ML(1000, -25, 25, 1000, -25, 25)", "id >= 36 && id < 106 ", "colz");
+  canvXY->cd(4);
+  nt->Draw("y:z>>h_y_vs_z_ML(1000, -70, 70, 1000, -25, 25)", "id >= 36 && id < 106 ", "colz");
+  canvXY->cd(5);
+  nt->Draw("y:x>>h_y_vs_x_OT(1000, -85, 85, 1000, -85, 85)", "id >= 106 ", "colz");
+  canvXY->cd(6);
+  nt->Draw("y:z>>h_y_vs_z_OT(1000, -85, 85, 1000, -130, 130)", "id >= 106 ", "colz");
+  canvXY->SaveAs("trkdigits_y_vs_x_vs_z.pdf");
+
+  // z distributions
+  auto canvZ = new TCanvas("canvZ", "", 800, 2400);
+  canvZ->Divide(1, 3);
+  canvZ->cd(1);
+  nt->Draw("z>>h_z_VD(500, -26, 26)", "id < 36 ");
+  canvZ->cd(2);
+  nt->Draw("z>>h_z_ML(500, -70, 70)", "id >= 36 && id < 106 ");
+  canvZ->cd(3);
+  nt->Draw("z>>h_z_OT(500, -85, 85)", "id >= 106 ");
+  canvZ->SaveAs("trkdigits_z.pdf");
+
+  // dz distributions (difference between local position of digits and hits in x and z)
+  auto canvdZ = new TCanvas("canvdZ", "", 800, 2400);
+  canvdZ->Divide(1, 3);
+  canvdZ->cd(1);
+  nt->Draw("dz>>h_dz_VD(500, -0.05, 0.05)", "id < 36 ");
+  canvdZ->cd(2);
+  nt->Draw("dz>>h_dz_ML(500, -0.05, 0.05)", "id >= 36 && id < 106 ");
+  canvdZ->cd(3);
+  nt->Draw("dz>>h_dz_OT(500, -0.05, 0.05)", "id >= 106 ");
+  canvdZ->SaveAs("trkdigits_dz.pdf");
+
+  // distributions of differences between local positions of digits and hits in x and z
+  auto canvdXdZ = new TCanvas("canvdXdZ", "", 1600, 2400);
+  canvdXdZ->Divide(2, 3);
+  canvdXdZ->cd(1);
+  nt->Draw("dx:dz>>h_dx_vs_dz_VD(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 36", "colz");
+  auto h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_VD");
+  LOG(info) << "dx, dz";
+  Info("VD", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("VD", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZ->cd(2);
+  nt->Draw("dx:dz>>h_dx_vs_dz_VD_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 36 && abs(z)<2", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_VD_z");
+  Info("VD |z|<2", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("VD |z|<2", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZ->cd(3);
+  nt->Draw("dx:dz>>h_dx_vs_dz_ML(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 36 && id < 106", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_ML");
+  Info("ML", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("ML", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZ->cd(4);
+  nt->Draw("dx:dz>>h_dx_vs_dz_ML_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 36 && id < 106 && abs(z)<2", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_ML_z");
+  Info("ML |z|<2", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("ML |z|<2", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZ->SaveAs("trkdigits_dx_vs_dz.pdf");
+  canvdXdZ->cd(5);
+  nt->Draw("dx:dz>>h_dx_vs_dz_OT(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 106", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_OT");
+  Info("OT", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("OT", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZ->cd(6);
+  nt->Draw("dx:dz>>h_dx_vs_dz_OT_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 106 && abs(z)<2", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_OT_z");
+  Info("OT |z|<2", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("OT |z|<2", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZ->SaveAs("trkdigits_dx_vs_dz.pdf");
+
+  // distribution of differences between hit start and hit end in local coordinates
+  auto canvdXdZHit = new TCanvas("canvdXdZHit", "", 1600, 2400);
+  canvdXdZHit->Divide(2, 3);
+  canvdXdZHit->cd(1);
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_VD(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 36", "colz");
+  LOG(info) << "dxH, dzH";
+  h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_VD");
+  Info("VD", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("VD", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZHit->cd(2);
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_VD_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 36 && abs(z)<2", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_VD_z");
+  Info("VD |z|<2", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("VD |z|<2", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZHit->cd(3);
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_ML(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 36 && id < 106", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_ML");
+  Info("ML", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("ML", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZHit->cd(4);
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_ML_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 36 && id < 106 && abs(z)<2", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_ML_z");
+  Info("ML |z|<2", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("ML |z|<2", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZHit->SaveAs("trkdigits_dxH_vs_dzH.pdf");
+  canvdXdZHit->cd(5);
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_OT(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 106", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_OT");
+  Info("OT", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("OT", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZHit->cd(6);
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_OT_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 106 && abs(z)<2", "colz");
+  h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_OT_z");
+  Info("OT |z|<2", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("OT |z|<2", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
+  canvdXdZHit->SaveAs("trkdigits_dxH_vs_dzH.pdf");
+
+  f->Write();
+  f->Close();
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/run_test.sh b/Detectors/Upgrades/ALICE3/TRK/macros/test/run_test.sh
new file mode 100644
index 0000000000000..797d1d12af4ab
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/run_test.sh
@@ -0,0 +1,10 @@
+#Number of events to simulate
+nEvents=10
+
+# Simulating
+o2-sim-serial-run5 -n $nEvents -g pythia8hi -m TRK --configKeyValues "TRKBase.layoutML=kTurboStaves;TRKBase.layoutOL=kStaggered;">& sim_TRK.log
+
+# Digitizing
+o2-sim-digitizer-workflow -b >& digiTRK.log
+
+root.exe -b -q CheckDigits.C+ >& CheckDigits.log

From 869860c68a60ffeca465eb523fbd4a0d4124bc6d Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 22 Oct 2025 15:49:01 +0200
Subject: [PATCH 0952/1764] Redefing BasicXYZVHit::mDetectorID from short to
 ushort

---
 .../simulation/include/SimulationDataFormat/BaseHits.h    | 8 ++++----
 Detectors/ITSMFT/common/simulation/src/Digitizer.cxx      | 2 +-
 Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx      | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/BaseHits.h b/DataFormats/simulation/include/SimulationDataFormat/BaseHits.h
index b9ed356ec8b5a..b527de341dae6 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/BaseHits.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/BaseHits.h
@@ -55,7 +55,7 @@ class BasicXYZVHit : public BaseHit
   BasicXYZVHit() = default; // for ROOT IO
 
   // constructor
-  BasicXYZVHit(T x, T y, T z, E time, V val, int trackid, short did)
+  BasicXYZVHit(T x, T y, T z, E time, V val, int trackid, unsigned short did)
     : mPos(x, y, z), mTime(time), mHitValue(val), BaseHit(trackid), mDetectorID(did)
   {
   }
@@ -70,12 +70,12 @@ class BasicXYZVHit : public BaseHit
   // getting the time
   E GetTime() const { return mTime; }
   // get detector + track information
-  short GetDetectorID() const { return mDetectorID; }
+  unsigned short GetDetectorID() const { return mDetectorID; }
 
   // modifiers
   void SetTime(E time) { mTime = time; }
   void SetHitValue(V val) { mHitValue = val; }
-  void SetDetectorID(short detID) { mDetectorID = detID; }
+  void SetDetectorID(unsigned short detID) { mDetectorID = detID; }
   void SetX(T x) { mPos.SetX(x); }
   void SetY(T y) { mPos.SetY(y); }
   void SetZ(T z) { mPos.SetZ(z); }
@@ -87,7 +87,7 @@ class BasicXYZVHit : public BaseHit
   }
   void SetPos(math_utils::Point3D<T> const& p) { mPos = p; }
 
-  ClassDefNV(BasicXYZVHit, 1);
+  ClassDefNV(BasicXYZVHit, 2);
 };
 
 // Class for a hit containing energy loss as hit value
diff --git a/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx b/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
index 382fa769a94c7..e5dd35e6a084d 100644
--- a/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
+++ b/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
@@ -272,7 +272,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
 void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID)
 {
   // convert single hit to digits
-  int chipID = hit.GetDetectorID();
+  auto chipID = hit.GetDetectorID();
   auto& chip = mChips[chipID];
   if (chip.isDisabled()) {
     LOG(debug) << "skip disabled chip " << chipID;
diff --git a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
index b91e17890a6d8..7dd7110801f4a 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
@@ -234,7 +234,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
 void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID)
 {
   // convert single hit to digits
-  int chipID = hit.GetDetectorID();
+  auto chipID = hit.GetDetectorID();
   auto& chip = mChips[chipID];
   if (chip.isDisabled()) {
     return;

From 6fb9235e350b4ef1f2e5e05d58fc72391dd4f181 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Wed, 22 Oct 2025 13:35:30 +0200
Subject: [PATCH 0953/1764] Fix typo in log message

---
 Framework/Core/src/runDataProcessing.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 1611eb8605134..900769adb780d 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1022,7 +1022,7 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
   fair::Logger::SetConsoleColor(false);
   fair::Logger::OnFatal([]() { throw runtime_error("Fatal error"); });
   DeviceSpec const& spec = runningWorkflow.devices[ref.index];
-  LOG(info) << "Spawing new device " << spec.id << " in process with pid " << getpid();
+  LOG(info) << "Spawning new device " << spec.id << " in process with pid " << getpid();
 
   fair::mq::DeviceRunner runner{argc, argv};
 

From 50d7d125a1f71833b6ab919851286b26e221a13a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Barth=C3=A9l=C3=A9my=20von=20Haller?=
 <barthelemy.von.haller@cern.ch>
Date: Thu, 23 Oct 2025 12:44:25 +0200
Subject: [PATCH 0954/1764] [O2-5887] Detect if an empty URL is passed to the
 CCDB api. (#14349)

* [O2-5887] Detect if an empty URL is passed to the CCDB api.

* Update testCcdbApi.cxx
---
 CCDB/src/CcdbApi.cxx      | 4 ++++
 CCDB/test/testCcdbApi.cxx | 9 ++++++++-
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index 27ad14cdf24fa..8dfa7dd25e215 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -165,6 +165,10 @@ void CcdbApi::curlInit()
 
 void CcdbApi::init(std::string const& host)
 {
+  if (host.empty()) {
+    throw std::invalid_argument("Empty url passed CcdbApi, cannot initialize. Aborting.");
+  }
+
   // if host is prefixed with "file://" this is a local snapshot
   // in this case we init the API in snapshot (readonly) mode
   constexpr const char* SNAPSHOTPREFIX = "file://";
diff --git a/CCDB/test/testCcdbApi.cxx b/CCDB/test/testCcdbApi.cxx
index 0ba037710cf62..1b6a5d6f0967a 100644
--- a/CCDB/test/testCcdbApi.cxx
+++ b/CCDB/test/testCcdbApi.cxx
@@ -589,4 +589,11 @@ BOOST_AUTO_TEST_CASE(vectored)
   for (auto context : contexts) {
     BOOST_CHECK(context.dest.size() != 0);
   }
-}
\ No newline at end of file
+}
+
+BOOST_AUTO_TEST_CASE(empty_url)
+{
+  CcdbApi api;
+  string url = "";
+  BOOST_CHECK_EXCEPTION(api.init(url), invalid_argument, [](std::invalid_argument const&) -> bool { return true; });
+}

From 9910bc19acfcfeb2e0d5a9cf0df535c28179540a Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 23 Oct 2025 14:20:52 +0200
Subject: [PATCH 0955/1764] ITS3: fix recently added service material (#14751)

* ITS3: fix IB wrapping volume length

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS3: fix service material

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h  | 2 +-
 .../include/ITS3Simulation/DescriptorInnerBarrelITS3.h   | 2 +-
 Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx  | 9 ++++++---
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
index b56bb3fa2bd98..a7422c55e72b8 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
@@ -221,7 +221,7 @@ namespace services
 constexpr double thickness{2.2 * mm};                                         // thickness of structure
 constexpr double radiusInner{radiiOuter[2] + carbonfoam::thicknessOuterFoam}; // inner radius of services
 constexpr double radiusOuter{radiusInner + thickness};                        // outer radius of services
-constexpr double length{20 * cm};                                             // length
+constexpr double length{segment::length + (1 * cm)};                          // length
 constexpr EColor color{kBlue};
 } // namespace services
 
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
index 7a7d2215eb67c..80565df55d154 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
@@ -48,7 +48,7 @@ class DescriptorInnerBarrelITS3 : public o2::its::DescriptorInnerBarrel
   static constexpr double mTolerance{1e-3};
   static constexpr double mWrapperMinRadiusITS3{constants::radiiInner[0] - mTolerance};
   static constexpr double mWrapperMaxRadiusITS3{constants::services::radiusOuter + mTolerance};
-  static constexpr double mWrapperZSpanITS3{constants::services::length + mTolerance};
+  static constexpr double mWrapperZSpanITS3{constants::services::length * 2 + mTolerance}; // z length is divided in half
 
  private:
   std::array<std::unique_ptr<ITS3Layer>, constants::nLayers> mIBLayers;
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx b/Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx
index e5ad6a4a1e034..6244ea43a5ca8 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3Services.cxx
@@ -30,13 +30,16 @@ void ITS3Services::createCYSSAssembly(TGeoVolume* motherVolume)
   motherVolume->AddNode(cyssVol, 1., nullptr);
 
   // Cylinder
-  auto cyssInnerCylSh = new TGeoTubeSeg(constants::services::radiusInner, constants::services::radiusOuter, constants::services::length, 180, 360);
-  auto medPrepreg = gGeoManager->GetMedium("IT3_AS4C200$");
-  auto cyssInnerCylShVol = new TGeoVolume("IBCYSSCylinder", cyssInnerCylSh, medPrepreg);
+  auto cyssInnerCylSh = new TGeoTubeSeg(constants::services::radiusInner, constants::services::radiusOuter, constants::services::length / 2, 180, 360);
+  auto medRohacell = gGeoManager->GetMedium("IT3_RIST110$");
+  auto cyssInnerCylShVol = new TGeoVolume("IBCYSSCylinder", cyssInnerCylSh, medRohacell);
+  cyssInnerCylShVol->SetLineColor(constants::services::color);
   cyssVol->AddNode(cyssInnerCylShVol, 1, new TGeoTranslation(0, 0, 0));
   cyssVol->AddNode(cyssInnerCylShVol, 2, new TGeoCombiTrans(0, 0, 0, new TGeoRotation("", 180, 0, 0)));
 
   // TODO Cone
+  // For now the wrapping volume just extends beyond the cylinder if something is added beyond that this volume has to
+  // be exteneded.
 }
 
 } // namespace o2::its3

From 7a7cedcdb88740aa38d3a34475742e128d8afbf5 Mon Sep 17 00:00:00 2001
From: Michael Lettrich <michael.lettrich@cern.ch>
Date: Thu, 23 Oct 2025 11:47:14 +0200
Subject: [PATCH 0956/1764] [Fix] Correct Reporting of CTF Compressed Payload
 in Metadata

---
 .../EncodedBlocks.h                           | 24 ++++++++++---------
 .../DetectorsCommonDataFormats/Metadata.h     | 17 +++++++++++--
 2 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h
index 6fb8825f7c395..a83c8f13deca4 100644
--- a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h
+++ b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h
@@ -929,9 +929,11 @@ CTFIOSize EncodedBlocks<H, N, W>::decode(D_IT dest,                        // it
   const auto& md = mMetadata[slot];
   LOGP(debug, "Slot{} | NStored={} Ndict={} nData={}, MD: messageLength:{} opt:{} min:{} max:{} offs:{} width:{} ", slot, block.getNStored(), block.getNDict(), block.getNData(), md.messageLength, (int)md.opt, md.min, md.max, md.literalsPackingOffset, md.literalsPackingWidth);
 
+  constexpr size_t word_size = sizeof(W);
+
   if (ansVersion == ANSVersionCompat) {
     if (!block.getNStored()) {
-      return {0, md.getUncompressedSize(), md.getCompressedSize()};
+      return {0, md.getUncompressedSize(), md.getCompressedSize() * word_size};
     }
     if (md.opt == Metadata::OptStore::EENCODE) {
       return decodeCompatImpl(dest, slot, decoderExt);
@@ -943,7 +945,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decode(D_IT dest,                        // it
       return decodeUnpackImpl(dest, slot);
     }
     if (!block.getNStored()) {
-      return {0, md.getUncompressedSize(), md.getCompressedSize()};
+      return {0, md.getUncompressedSize(), md.getCompressedSize() * word_size};
     }
     if (md.opt == Metadata::OptStore::EENCODE) {
       return decodeRansV1Impl(dest, slot, decoderExt);
@@ -991,7 +993,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decodeCompatImpl(dst_IT dstBegin, int slot, co
   } else {
     getDecoder().process(block.getData() + block.getNData(), dstBegin, md.messageLength, NDecoderStreams);
   }
-  return {0, md.getUncompressedSize(), md.getCompressedSize()};
+  return {0, md.getUncompressedSize(), md.getCompressedSize() * sizeof(W)};
 };
 
 template <typename H, int N, typename W>
@@ -1045,7 +1047,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decodeRansV1Impl(dst_IT dstBegin, int slot, co
   } else {
     getDecoder().process(block.getData() + block.getNData(), dstBegin, md.messageLength, md.nStreams);
   }
-  return {0, md.getUncompressedSize(), md.getCompressedSize()};
+  return {0, md.getUncompressedSize(), md.getCompressedSize() * sizeof(W)};
 };
 
 template <typename H, int N, typename W>
@@ -1079,7 +1081,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decodeUnpackImpl(dst_IT dest, int slot) const
   } else {
     rans::unpack(srcIt, messageLength, dest, packingWidth, offset);
   }
-  return {0, md.getUncompressedSize(), md.getCompressedSize()};
+  return {0, md.getUncompressedSize(), md.getCompressedSize() * sizeof(W)};
 };
 
 template <typename H, int N, typename W>
@@ -1098,7 +1100,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decodeCopyImpl(dst_IT dest, int slot) const
   destPtr_t srcEnd = srcBegin + md.messageLength * sizeof(dest_t);
   std::copy(srcBegin, srcEnd, dest);
 
-  return {0, md.getUncompressedSize(), md.getCompressedSize()};
+  return {0, md.getUncompressedSize(), md.getCompressedSize() * sizeof(W)};
 };
 
 ///_____________________________________________________________________________
@@ -1268,7 +1270,7 @@ o2::ctf::CTFIOSize EncodedBlocks<H, N, W>::entropyCodeRANSCompat(const input_IT
                                                                                      dataSize,
                                                                                      nLiteralWords);
 
-  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize()};
+  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize() * sizeof(W)};
 }
 
 template <typename H, int N, typename W>
@@ -1349,7 +1351,7 @@ CTFIOSize EncodedBlocks<H, N, W>::encodeRANSV1External(const input_IT srcBegin,
                                                                                  dataSize,
                                                                                  literalsSize);
 
-  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize()};
+  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize() * sizeof(W)};
 };
 
 template <typename H, int N, typename W>
@@ -1458,7 +1460,7 @@ CTFIOSize EncodedBlocks<H, N, W>::encodeRANSV1Inplace(const input_IT srcBegin, c
                                                                                  dataSize,
                                                                                  literalsSize);
 
-  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize()};
+  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize() * sizeof(W)};
 }; // namespace ctf
 
 template <typename H, int N, typename W>
@@ -1491,7 +1493,7 @@ o2::ctf::CTFIOSize EncodedBlocks<H, N, W>::pack(const input_IT srcBegin, const i
   }
 
   LOGP(debug, "StoreData {} bytes, offs: {}:{}", packedSize * sizeof(storageBuffer_t), thisBlock->getOffsData(), thisBlock->getOffsData() + packedSize * sizeof(storageBuffer_t));
-  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize()};
+  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize() * sizeof(W)};
 };
 
 template <typename H, int N, typename W>
@@ -1513,7 +1515,7 @@ o2::ctf::CTFIOSize EncodedBlocks<H, N, W>::store(const input_IT srcBegin, const
 
   *thisMetadata = detail::makeMetadataStore<input_t, storageBuffer_t>(messageLength, opt, nBufferElems);
 
-  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize()};
+  return {0, thisMetadata->getUncompressedSize(), thisMetadata->getCompressedSize() * sizeof(W)};
 };
 
 /// create a special EncodedBlocks containing only dictionaries made from provided vector of frequency tables
diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/Metadata.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/Metadata.h
index abf7561eb25a9..975522767dce1 100644
--- a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/Metadata.h
+++ b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/Metadata.h
@@ -37,7 +37,7 @@ struct Metadata {
   size_t nLiterals = 0;              // Number of samples that were stored as literals.
   uint8_t messageWordSize = 0;       // size in Bytes of a symbol in the encoded message.
   uint8_t coderType = 0;             // what type of CTF Coder is used? (32 vs 64 bit coders).
-  uint8_t streamSize = 0;            // how many Bytes is the rANS encoder emmiting during a stream-out step.
+  uint8_t streamSize = 0;            // number of Bytes emmitted during rANS stream out (ransCompat) or lower renorming bound (ransV1).
   uint8_t probabilityBits = 0;       // The encoder renormed the distribution of source symbols to sum up to 2^probabilityBits.
   OptStore opt = OptStore::EENCODE;  // The type of storage operation that was conducted.
   int32_t min = 0;                   // min symbol of the source dataset.
@@ -48,8 +48,21 @@ struct Metadata {
   int nDataWords = 0;                // Amount of words used to store the actual data.
   int nLiteralWords = 0;             // Amount of words used to store literal (incompressible) samples.
 
+  /**
+   * @brief Uncompressed size of stored data in bytes
+   *
+   * @return size_t Uncompressed size in bytes
+   */
   size_t getUncompressedSize() const { return messageLength * messageWordSize; }
-  size_t getCompressedSize() const { return (nDictWords + nDataWords + nLiteralWords) * streamSize; }
+
+  /**
+   * @brief Size of the stored, compressed data in multiples of the underlying buffer word size
+   *
+   * @return size_t The size in multiples of the underlying buffer word size
+   * @warning This size is in number of words of the underlying storage buffer.
+   * Multiply with the size of the storage buffer type to get the correct size in bytes.
+   */
+  size_t getCompressedSize() const { return nDictWords + nDataWords + nLiteralWords; }
   void clear()
   {
     nStreams = 0;

From 3b68b1c3a32426d2eae0215de94069b9923703d0 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 23 Oct 2025 15:50:53 +0200
Subject: [PATCH 0957/1764] Add forgotten short->unsigned short redefinition

---
 DataFormats/simulation/include/SimulationDataFormat/BaseHits.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/BaseHits.h b/DataFormats/simulation/include/SimulationDataFormat/BaseHits.h
index b527de341dae6..d1e1ee357c1cf 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/BaseHits.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/BaseHits.h
@@ -49,7 +49,7 @@ class BasicXYZVHit : public BaseHit
   math_utils::Point3D<T> mPos; // cartesian position of Hit
   E mTime;                     // time of flight
   V mHitValue;                 // hit value
-  short mDetectorID;           // the detector/sensor id
+  unsigned short mDetectorID;  // the detector/sensor id
 
  public:
   BasicXYZVHit() = default; // for ROOT IO

From 490589cff84c20da5064a9170c1cb6edd66f1601 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <gab.cima22@gmail.com>
Date: Wed, 27 Aug 2025 08:47:09 +0200
Subject: [PATCH 0958/1764] GPU Framework: fixed mismatch between CUDA and HIP
 launch bounds definitions

---
 .../Base/GPUReconstructionKernelMacros.h      | 15 ++++++++++++
 .../Base/cuda/GPUReconstructionCUDAGenRTC.cxx |  2 +-
 .../Base/cuda/GPUReconstructionCUDAKernels.cu |  2 +-
 .../cuda/GPUReconstructionCUDARTCCalls.cu     |  2 +-
 .../GPUReconstructionCUDAkernel.template.cu   |  2 +-
 .../GPUReconstructionHIPkernel.template.hip   |  2 +-
 GPU/GPUTracking/Definitions/GPUDefMacros.h    |  2 ++
 .../Definitions/GPUDefParametersDefaults.h    |  5 ++++
 .../GPUDefParametersLoad.template.inc         | 24 +++++++++----------
 GPU/GPUTracking/kernels.cmake                 |  3 ++-
 10 files changed, 41 insertions(+), 18 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
index a03d9de13ef8f..cc1c62bed507d 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionKernelMacros.h
@@ -32,6 +32,21 @@
 #define GPUCA_M_KRNL_NAME(...) GPUCA_M_KRNL_NAME_A(GPUCA_M_STRIP(__VA_ARGS__))
 
 #if defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_HOSTONLY)
+
+#if defined(__HIPCC__) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)
+  static_assert(GPUCA_PAR_AMD_EUS_PER_CU > 0);
+  #define GPUCA_MIN_WARPS_PER_EU(maxThreadsPerBlock, minBlocksPerCU) GPUCA_CEIL_INT_DIV((minBlocksPerCU) * (maxThreadsPerBlock), (GPUCA_WARP_SIZE * GPUCA_PAR_AMD_EUS_PER_CU))
+
+  #define GPUCA_LB_ARGS_1(maxThreadsPerBlock) maxThreadsPerBlock
+  #define GPUCA_LB_ARGS_2(maxThreadsPerBlock, minBlocksPerCU) maxThreadsPerBlock, GPUCA_MIN_WARPS_PER_EU(maxThreadsPerBlock, minBlocksPerCU)
+
+  #define GPUCA_LAUNCH_BOUNDS_SELECT(n, ...) GPUCA_M_CAT(GPUCA_LB_ARGS_, n)(__VA_ARGS__)
+  #define GPUCA_LAUNCH_BOUNDS_DISP(...) GPUCA_LAUNCH_BOUNDS_SELECT(GPUCA_M_COUNT(__VA_ARGS__), __VA_ARGS__)
+  #define GPUCA_KRNL_REG_DEFAULT(args) __launch_bounds__(GPUCA_LAUNCH_BOUNDS_DISP(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args))))
+#elif !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)
+  #define GPUCA_KRNL_REG_DEFAULT(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
+#endif
+
 #ifndef GPUCA_KRNL_REG
 #define GPUCA_KRNL_REG(...)
 #endif
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index 8c3fb92c11c9e..dba7e680d0b2c 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -74,7 +74,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     }
     fclose(fp);
   }
-  const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true) +
+  const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true, mParDevice->par_AMD_EUS_PER_CU ? (mParDevice->par_AMD_EUS_PER_CU * mWarpSize) : 0) +
                                    "#define GPUCA_WARP_SIZE " + std::to_string(mWarpSize) + "\n";
   if (GetProcessingSettings().rtctech.printLaunchBounds || GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("RTC Launch Bounds:\n%s", launchBounds.c_str());
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index e6ed94bba2cec..e8779415f0ea4 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -74,7 +74,7 @@ inline void GPUReconstructionCUDA::runKernelBackend(const krnlSetupTime& _xyz, c
 }
 
 #undef GPUCA_KRNL_REG
-#define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
+#define GPUCA_KRNL_REG(...) GPUCA_KRNL_REG_DEFAULT(__VA_ARGS__)
 
 // clang-format off
 #if defined(GPUCA_KERNEL_COMPILE_MODE) && GPUCA_KERNEL_COMPILE_MODE != 1 // ---------- COMPILE_MODE = perkernel ----------
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu
index 3e4d3113fb995..571428dc39e21 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDARTCCalls.cu
@@ -15,7 +15,7 @@
 #define GPUCA_GPUCODE_HOSTONLY
 #define GPUCA_GPUCODE_NO_LAUNCH_BOUNDS
 
-#define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
+#define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_STRIP(args))
 
 #include "GPUReconstructionCUDAIncludesSystem.h"
 #include "GPUReconstructionCUDADef.h"
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
index 847011a70f7f9..82759aab48d70 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAkernel.template.cu
@@ -14,7 +14,7 @@
 
 #define GPUCA_GPUCODE_COMPILEKERNELS
 #include "GPUReconstructionCUDAIncludesSystem.h"
-#define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
+#define GPUCA_KRNL_REG(...) GPUCA_KRNL_REG_DEFAULT(__VA_ARGS__)
 #define GPUCA_KRNL(...) GPUCA_KRNLGPU(__VA_ARGS__);
 #include "GPUReconstructionCUDADef.h"
 #include "GPUReconstructionKernelMacros.h"
diff --git a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
index 30a84dfa135eb..7cb895cadd770 100644
--- a/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
+++ b/GPU/GPUTracking/Base/hip/GPUReconstructionHIPkernel.template.hip
@@ -14,7 +14,7 @@
 
 #define GPUCA_GPUCODE_COMPILEKERNELS
 #include "GPUReconstructionHIPIncludesSystem.h"
-#define GPUCA_KRNL_REG(args) __launch_bounds__(GPUCA_M_MAX2_3(GPUCA_M_STRIP(args)))
+#define GPUCA_KRNL_REG(...) GPUCA_KRNL_REG_DEFAULT(__VA_ARGS__)
 #define GPUCA_KRNL(...) GPUCA_KRNLGPU(__VA_ARGS__);
 #include "GPUReconstructionHIPDef.h"
 #include "GPUReconstructionKernelMacros.h"
diff --git a/GPU/GPUTracking/Definitions/GPUDefMacros.h b/GPU/GPUTracking/Definitions/GPUDefMacros.h
index caf2d1670f84e..ea62d7f34edb0 100644
--- a/GPU/GPUTracking/Definitions/GPUDefMacros.h
+++ b/GPU/GPUTracking/Definitions/GPUDefMacros.h
@@ -50,5 +50,7 @@
 #define GPUCA_UNROLL(...)
 #endif
 
+#define GPUCA_CEIL_INT_DIV(a, b) (((a) + (b) - 1) / (b))
+
 #endif
 // clang-format on
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 29aa3808506dc..7c547b570ea16 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -25,6 +25,7 @@
   // GPU-architecture-dependent default settings
   #if defined(GPUCA_GPUTYPE_MI2xx)
     #define GPUCA_WARP_SIZE 64
+    #define GPUCA_PAR_AMD_EUS_PER_CU 4
     #define GPUCA_THREAD_COUNT_DEFAULT 256
     #define GPUCA_LB_GPUTPCCreateTrackingData 256
     #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
@@ -87,6 +88,7 @@
     #define GPUCA_PAR_COMP_GATHER_MODE 3
   #elif defined(GPUCA_GPUTYPE_VEGA)
     #define GPUCA_WARP_SIZE 64
+    #define GPUCA_PAR_AMD_EUS_PER_CU 4
     #define GPUCA_THREAD_COUNT_DEFAULT 256
     #define GPUCA_LB_GPUTPCCreateTrackingData 128
     #define GPUCA_LB_GPUTPCStartHitsSorter 1024, 2
@@ -272,6 +274,9 @@
   #ifndef GPUCA_WARP_SIZE
     #define GPUCA_WARP_SIZE 32
   #endif
+  #ifndef GPUCA_PAR_AMD_EUS_PER_CU
+    #define GPUCA_PAR_AMD_EUS_PER_CU 0
+  #endif
   #ifndef GPUCA_THREAD_COUNT_DEFAULT
     #define GPUCA_THREAD_COUNT_DEFAULT 256
   #endif
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
index ac71adc6232a6..8b7a79a9e48bf 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersLoad.template.inc
@@ -39,23 +39,23 @@ static GPUDefParameters GPUDefParametersLoad()
   };
 }
 
-#define GPUCA_EXPORT_KERNEL_LB(name)                                            \
-  if (par.par_LB_maxThreads[i] > 0) {                                           \
-    o << "#define GPUCA_LB_" GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i]; \
-    if (par.par_LB_minBlocks[i] > 0) {                                          \
-      o << ", " << par.par_LB_minBlocks[i];                                     \
-    }                                                                           \
-    if (!forRTC && par.par_LB_forceBlocks[i] > 0) {                             \
-      o << ", " << par.par_LB_forceBlocks[i];                                   \
-    }                                                                           \
-    o << "\n";                                                                  \
-  }                                                                             \
+#define GPUCA_EXPORT_KERNEL_LB(name)                                                                                                                     \
+  if (par.par_LB_maxThreads[i] > 0) {                                                                                                                    \
+    o << "#define GPUCA_LB_" GPUCA_M_STR(name) " " << par.par_LB_maxThreads[i];                                                                          \
+    if (par.par_LB_minBlocks[i] > 0) {                                                                                                                   \
+      o << ", " << GPUCA_CEIL_INT_DIV(par.par_LB_maxThreads[i] * par.par_LB_minBlocks[i], (minBlockFactor ? minBlockFactor : par.par_LB_maxThreads[i])); \
+    }                                                                                                                                                    \
+    if (!forRTC && par.par_LB_forceBlocks[i] > 0) {                                                                                                      \
+      o << ", " << par.par_LB_forceBlocks[i];                                                                                                            \
+    }                                                                                                                                                    \
+    o << "\n";                                                                                                                                           \
+  }                                                                                                                                                      \
   i++;
 
 #define GPUCA_EXPORT_KERNEL_PARAM(name) \
   o << "#define GPUCA_PAR_" GPUCA_M_STR(name) " " << GPUCA_M_CAT(par.par_, name) << "\n";
 
-static std::string GPUDefParametersExport(const GPUDefParameters& par, bool forRTC)
+static std::string GPUDefParametersExport(const GPUDefParameters& par, bool forRTC, int32_t minBlockFactor = 0)
 {
   std::stringstream o; // clang-format off
   int32_t i = 0;
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 84726ea9fb8d0..e7271a9affbba 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -145,7 +145,8 @@ o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP  # Number of neighhbo
                             COMP_GATHER_KERNEL              # Default kernel to use for Compression Gather Operation [0 - 4]
                             COMP_GATHER_MODE                # TPC Compression Gather Mode [0 - 3]
                             SORT_STARTHITS                  # Sort start hits to improve cache locality during tracklet construction [0/1]
-                            CF_SCAN_WORKGROUP_SIZE)         # Work group size to use in clusterizer scan operation
+                            CF_SCAN_WORKGROUP_SIZE          # Work group size to use in clusterizer scan operation
+			    AMD_EUS_PER_CU)	  	    # Number of SIMD units per Compute Unit (only for AMD GPUs)
 
 o2_gpu_kernel_add_string_parameter(DEDX_STORAGE_TYPE                # Data type to use for intermediate storage of dEdx truncated mean inputs
                                    MERGER_INTERPOLATION_ERROR_TYPE) # Data type for storing intermediate track residuals for interpolation

From 099c11160d9f7a8a5fdb4c9986e9d96fc66f5605 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <gab.cima22@gmail.com>
Date: Thu, 23 Oct 2025 12:48:51 +0200
Subject: [PATCH 0959/1764] GPU TPC: update optimal AMD default parameters for
 PbPb data

---
 .../Definitions/GPUDefParametersDefaults.h    | 88 ++++++++++---------
 1 file changed, 46 insertions(+), 42 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 7c547b570ea16..46316b8a62fe1 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -27,21 +27,21 @@
     #define GPUCA_WARP_SIZE 64
     #define GPUCA_PAR_AMD_EUS_PER_CU 4
     #define GPUCA_THREAD_COUNT_DEFAULT 256
-    #define GPUCA_LB_GPUTPCCreateTrackingData 256
-    #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
-    #define GPUCA_LB_GPUTPCStartHitsFinder 1024
-    #define GPUCA_LB_GPUTPCTrackletConstructor 512, 2
-    #define GPUCA_LB_GPUTPCTrackletSelector 192, 3
-    #define GPUCA_LB_GPUTPCNeighboursFinder 1024, 1
-    #define GPUCA_LB_GPUTPCNeighboursCleaner 896
-    #define GPUCA_LB_GPUTPCExtrapolationTracking 256
+    #define GPUCA_LB_GPUTPCCreateTrackingData 256, 7
+    #define GPUCA_LB_GPUTPCStartHitsSorter 1024, 5
+    #define GPUCA_LB_GPUTPCStartHitsFinder 1024, 2
+    #define GPUCA_LB_GPUTPCTrackletConstructor 768, 8
+    #define GPUCA_LB_GPUTPCTrackletSelector 384, 5
+    #define GPUCA_LB_GPUTPCNeighboursFinder 192, 8
+    #define GPUCA_LB_GPUTPCNeighboursCleaner 128, 5
+    #define GPUCA_LB_GPUTPCExtrapolationTracking 256, 7
     #define GPUCA_LB_GPUTPCCFDecodeZS 64, 4
     #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFGather 1024, 1
-    #define GPUCA_LB_GPUTPCGMMergerTrackFit 128, 1
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 64, 12
-    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256
+    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE, 4
+    #define GPUCA_LB_GPUTPCCFGather 1024, 5
+    #define GPUCA_LB_GPUTPCGMMergerTrackFit 192, 2
+    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 5
+    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 64, 4
     #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
     #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
     #define GPUCA_LB_GPUTPCGMMergerResolve_step0 512
@@ -56,7 +56,7 @@
     #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 512
     #define GPUCA_LB_GPUTPCGMMergerMergeCE 512
     #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-    #define GPUCA_LB_GPUTPCGMMergerCollect 512
+    #define GPUCA_LB_GPUTPCGMMergerCollect 768, 1
     #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
     #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
     #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
@@ -64,21 +64,23 @@
     #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 64, 2
+    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 128, 1
     #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
     #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
     #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64, 10
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
-    #define GPUCA_LB_GPUTPCCFPeakFinder 512
+    #define GPUCA_LB_GPUTPCCFPeakFinder 512, 9
     #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
-    #define GPUCA_LB_GPUTPCCFDeconvolution 512
-    #define GPUCA_LB_GPUTPCCFClusterizer 448
+    #define GPUCA_LB_GPUTPCCFDeconvolution 512, 5
+    #define GPUCA_LB_GPUTPCCFClusterizer 448, 3
     #define GPUCA_LB_COMPRESSION_GATHER 1024
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
-    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 10
+    #define PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL 4
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED 0
+    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 9
     #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
     #define GPUCA_PAR_SORT_BEFORE_FIT 1
     #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
@@ -90,21 +92,21 @@
     #define GPUCA_WARP_SIZE 64
     #define GPUCA_PAR_AMD_EUS_PER_CU 4
     #define GPUCA_THREAD_COUNT_DEFAULT 256
-    #define GPUCA_LB_GPUTPCCreateTrackingData 128
-    #define GPUCA_LB_GPUTPCStartHitsSorter 1024, 2
-    #define GPUCA_LB_GPUTPCStartHitsFinder 1024
-    #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2
-    #define GPUCA_LB_GPUTPCTrackletSelector 256, 8
-    #define GPUCA_LB_GPUTPCNeighboursFinder 1024, 1
-    #define GPUCA_LB_GPUTPCNeighboursCleaner 896
-    #define GPUCA_LB_GPUTPCExtrapolationTracking 256
-    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 4
+    #define GPUCA_LB_GPUTPCCreateTrackingData 192, 2
+    #define GPUCA_LB_GPUTPCStartHitsSorter 512, 7
+    #define GPUCA_LB_GPUTPCStartHitsFinder 1024, 7
+    #define GPUCA_LB_GPUTPCTrackletConstructor 512, 10
+    #define GPUCA_LB_GPUTPCTrackletSelector 192, 10
+    #define GPUCA_LB_GPUTPCNeighboursFinder 960, 8
+    #define GPUCA_LB_GPUTPCNeighboursCleaner 384, 9
+    #define GPUCA_LB_GPUTPCExtrapolationTracking 256, 2
+    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 1
     #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
+    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE, 14
     #define GPUCA_LB_GPUTPCCFGather 1024, 1
-    #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 1
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 4, 200
-    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256
+    #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 7
+    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 5
+    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256, 2
     #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
     #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
     #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
@@ -119,7 +121,7 @@
     #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 256
     #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
     #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-    #define GPUCA_LB_GPUTPCGMMergerCollect 512
+    #define GPUCA_LB_GPUTPCGMMergerCollect 1024, 1
     #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
     #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
     #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
@@ -127,21 +129,23 @@
     #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
     #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 192, 2
+    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 64, 2
     #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
     #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
     #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64, 2
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
-    #define GPUCA_LB_GPUTPCCFPeakFinder 512
+    #define GPUCA_LB_GPUTPCCFPeakFinder 512, 4
     #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
-    #define GPUCA_LB_GPUTPCCFDeconvolution 512
-    #define GPUCA_LB_GPUTPCCFClusterizer 512
+    #define GPUCA_LB_GPUTPCCFDeconvolution 512, 5
+    #define GPUCA_LB_GPUTPCCFClusterizer 512, 2
     #define GPUCA_LB_COMPRESSION_GATHER 1024
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 5
-    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL 2
+    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED 0
+    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 27
     #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
     #define GPUCA_PAR_SORT_BEFORE_FIT 1
     #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1

From 8740682b5befd1e1a3c7917e9247ffa4b438ddc1 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 23 Oct 2025 18:59:27 +0200
Subject: [PATCH 0960/1764] Process TRD,TOF fake flags in MC study workflow

---
 .../study/src/TrackMCStudy.cxx                | 41 ++++++++++++++++++-
 1 file changed, 39 insertions(+), 2 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 9dba400fe6edc..5881f79b17fc1 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -570,11 +570,30 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
               tref.flags |= RecTrack::FakeITS;
             }
           }
-          if (msk[DetID::TPC] && trackFam.entITSTPC < 0) { // has both ITS and TPC contribution
-            trackFam.entITSTPC = tcnt;
+          if (msk[DetID::TPC]) {
+            if (trackFam.entITSTPC < 0) { // has both ITS and TPC contribution
+              trackFam.entITSTPC = tcnt;
+            }
             if (recoData.getTrackMCLabel(gidSet[GTrackID::ITSTPC]).isFake()) {
               tref.flags |= RecTrack::FakeITSTPC;
             }
+
+            if (msk[DetID::TRD]) {
+              if (recoData.getTrackMCLabel(gidSet[GTrackID::ITSTPCTRD]).isFake()) {
+                tref.flags |= RecTrack::FakeTRD;
+              }
+              if (msk[DetID::TOF]) {
+                if (recoData.getTrackMCLabel(gidSet[GTrackID::ITSTPCTRDTOF]).isFake()) {
+                  tref.flags |= RecTrack::FakeTOF;
+                }
+              }
+            } else {
+              if (msk[DetID::TOF]) {
+                if (recoData.getTrackMCLabel(gidSet[GTrackID::ITSTPCTOF]).isFake()) {
+                  tref.flags |= RecTrack::FakeTOF;
+                }
+              }
+            }
           }
         }
         if (msk[DetID::TPC]) {
@@ -592,6 +611,24 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
           if (recoData.getTrackMCLabel(gidSet[GTrackID::TPC]).isFake()) {
             tref.flags |= RecTrack::FakeTPC;
           }
+          if (!msk[DetID::ITS]) {
+            if (msk[DetID::TRD]) {
+              if (recoData.getTrackMCLabel(gidSet[GTrackID::TPCTRD]).isFake()) {
+                tref.flags |= RecTrack::FakeTRD;
+              }
+              if (msk[DetID::TOF]) {
+                if (recoData.getTrackMCLabel(gidSet[GTrackID::TPCTRDTOF]).isFake()) {
+                  tref.flags |= RecTrack::FakeTOF;
+                }
+              }
+            } else {
+              if (msk[DetID::TOF]) {
+                if (recoData.getTrackMCLabel(gidSet[GTrackID::TPCTOF]).isFake()) {
+                  tref.flags |= RecTrack::FakeTOF;
+                }
+              }
+            }
+          }
         }
         float ts = 0, terr = 0;
         if (tref.gid.getSource() != GTrackID::ITS) {

From e0c17bc34af71b128af2dc84c84e9918a1af0dc4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 23 Oct 2025 14:57:14 +0200
Subject: [PATCH 0961/1764] GPU: Fix architecture name, we do not use MI2xx

---
 GPU/GPUTracking/CMakeLists.txt                         | 2 +-
 GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h | 2 +-
 dependencies/FindO2GPU.cmake                           | 6 +++---
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index a976e5c93b7c6..29c95eba4280a 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -405,7 +405,7 @@ target_sources(${targetName}
                BASE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
 
 make_directory(${CMAKE_CURRENT_BINARY_DIR}/genGPUArch)
-set(GPU_CONST_PARAM_ARCHITECTUES AMPERE TURING VEGA MI2xx)
+set(GPU_CONST_PARAM_ARCHITECTUES AMPERE TURING VEGA MI100)
 set(GPU_CONST_PARAM_FILES "")
 foreach(GPU_ARCH ${GPU_CONST_PARAM_ARCHITECTUES})
   set(PARAMFILE ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/gpu_const_param_${GPU_ARCH}.par)
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 46316b8a62fe1..2c750b2aabc3d 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -23,7 +23,7 @@
 // GPU Run Configuration
 #if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.
   // GPU-architecture-dependent default settings
-  #if defined(GPUCA_GPUTYPE_MI2xx)
+  #if defined(GPUCA_GPUTYPE_MI100)
     #define GPUCA_WARP_SIZE 64
     #define GPUCA_PAR_AMD_EUS_PER_CU 4
     #define GPUCA_THREAD_COUNT_DEFAULT 256
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 51812fc84ef1a..9f335eaa6600a 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 3
+# FindO2GPU.cmake Version 4
 
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
@@ -58,10 +58,10 @@ function(set_target_hip_arch target)
     target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_VEGA)
   elseif(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET MATCHES "gfx908")
     message(STATUS "Using optimized HIP settings for MI100 GPU")
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_MI2xx)
+    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_MI100)
   elseif(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET MATCHES "gfx90a")
     message(STATUS "Using optimized HIP settings for MI210 GPU")
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_MI2xx)
+    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_MI100)
   else()
     target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_VEGA)
   endif()

From f5d4b1a19a12d2d633a73fbbad671e44f66d750a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 28 Sep 2025 06:22:31 +0200
Subject: [PATCH 0962/1764] GPU: Improve track sorting before merging, group
 discarded tracks

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 16d96dad17d16..212850f107098 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -92,6 +92,9 @@ struct GPUTPCGMMergerSortTracks_comp {
   {
     const GPUTPCGMMergedTrack& GPUrestrict() a = mCmp[aa];
     const GPUTPCGMMergedTrack& GPUrestrict() b = mCmp[bb];
+    if (a.OK() != b.OK()) {
+      return a.OK();
+    }
     if (a.CCE() != b.CCE()) {
       return a.CCE() > b.CCE();
     }

From 62b99998b08923b7a89e81e5a226f10d8fb7df98 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 23 Sep 2025 15:12:13 +0200
Subject: [PATCH 0963/1764] GPU TPC: Fix rejection of inside IFC clusters

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 970b42f6ee78a..b45f08ed00f50 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -151,6 +151,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         const float rmax = (83.5f + param.rec.tpc.sysClusErrorMinDist);
         if (r2 < rmax * rmax) {
           MarkClusters(clusters, ihitMergeFirst, ihit, wayDirection, GPUTPCGMMergedTrackHit::flagRejectErr);
+          continue;
         }
       }
 

From 2a8b5d63670696189d422663c59a0c3d8cfdc538 Mon Sep 17 00:00:00 2001
From: Pavel Larionov <pavel.larionov@cern.ch>
Date: Fri, 24 Oct 2025 14:55:51 +0200
Subject: [PATCH 0964/1764] Refactor: IRIS tracker geometry (ALICE 3) (#14693)

* wip(iris): import stash-pre-rebase changes

(cherry picked from commit d291e57a2f121c4f19f1fb7ccd8031328abc9ce8)

* Cleanup

* Cleanup

* Add sensor region and type in the registry

* VD sensor names, num of vols using registry

* Changes related to digitizer

* clang-format

* Add copyright header
---
 .../Upgrades/ALICE3/Passive/src/Pipe.cxx      |   3 +-
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |   2 +
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      | 354 +++++++--
 .../ALICE3/TRK/simulation/CMakeLists.txt      |  11 +-
 .../include/TRKSimulation/Detector.h          |  14 +-
 .../include/TRKSimulation/TRKPetalCase.h      |  93 ---
 .../include/TRKSimulation/TRKPetalDisk.h      |  64 --
 .../include/TRKSimulation/TRKPetalLayer.h     |  61 --
 .../include/TRKSimulation/VDGeometryBuilder.h |  35 +
 .../include/TRKSimulation/VDLayer.h           | 110 +++
 .../include/TRKSimulation/VDSensorRegistry.h  |  42 +
 .../ALICE3/TRK/simulation/src/Detector.cxx    | 103 ++-
 .../TRK/simulation/src/TRKPetalCase.cxx       | 202 -----
 .../TRK/simulation/src/TRKPetalDisk.cxx       |  94 ---
 .../TRK/simulation/src/TRKPetalLayer.cxx      |  79 --
 .../ALICE3/TRK/simulation/src/TRKServices.cxx |   4 +-
 .../TRK/simulation/src/TRKSimulationLinkDef.h |   4 +-
 .../TRK/simulation/src/VDGeometryBuilder.cxx  | 743 ++++++++++++++++++
 .../ALICE3/TRK/simulation/src/VDLayer.cxx     | 314 ++++++++
 19 files changed, 1589 insertions(+), 743 deletions(-)
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalCase.h
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalDisk.h
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalLayer.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDLayer.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDSensorRegistry.h
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalCase.cxx
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalDisk.cxx
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalLayer.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx

diff --git a/Detectors/Upgrades/ALICE3/Passive/src/Pipe.cxx b/Detectors/Upgrades/ALICE3/Passive/src/Pipe.cxx
index 7dfd26a79b38d..fe0a1c50330fe 100644
--- a/Detectors/Upgrades/ALICE3/Passive/src/Pipe.cxx
+++ b/Detectors/Upgrades/ALICE3/Passive/src/Pipe.cxx
@@ -122,7 +122,8 @@ void Alice3Pipe::ConstructGeometry()
   // Add everything to the barrel
   barrel->AddNode(pipeVolume, 1, new TGeoTranslation(0, 30.f, 0));
 
-  pipeVolume->SetLineColor(kGreen + 3);
+  pipeVolume->SetLineColor(37);
+  pipeVolume->SetTransparency(0);
 }
 
 void Alice3Pipe::createMaterials()
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index b838940860e47..0e9ff8727a977 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -43,6 +43,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   };
   static const char* getTRKVolPattern() { return sVolumeName.c_str(); }
   static const char* getTRKLayerPattern() { return sLayerName.c_str(); }
+  static const char* getTRKPetalAssemblyPattern() { return sPetalAssemblyName.c_str(); }
   static const char* getTRKPetalPattern() { return sPetalName.c_str(); }
   static const char* getTRKPetalDiskPattern() { return sPetalDiskName.c_str(); }
   static const char* getTRKPetalLayerPattern() { return sPetalLayerName.c_str(); }
@@ -145,6 +146,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   static std::string sVolumeName;
   static std::string sLayerName;
+  static std::string sPetalAssemblyName;
   static std::string sPetalName;
   static std::string sPetalDiskName;
   static std::string sPetalLayerName;
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index e8907efb190da..9325f5079375d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -24,12 +24,14 @@ std::unique_ptr<o2::trk::GeometryTGeo> GeometryTGeo::sInstance;
 // Names
 std::string GeometryTGeo::sVolumeName = "TRKV";
 std::string GeometryTGeo::sLayerName = "TRKLayer";
+std::string GeometryTGeo::sPetalAssemblyName = "PETAL";
 std::string GeometryTGeo::sPetalName = "PETALCASE";
 std::string GeometryTGeo::sPetalDiskName = "DISK";
 std::string GeometryTGeo::sPetalLayerName = "LAYER";
 std::string GeometryTGeo::sStaveName = "TRKStave";
 std::string GeometryTGeo::sChipName = "TRKChip";
 std::string GeometryTGeo::sSensorName = "TRKSensor";
+
 std::string GeometryTGeo::sWrapperVolumeName = "TRKUWrapVol"; ///< Wrapper volume name, not implemented at the moment
 
 o2::trk::GeometryTGeo::~GeometryTGeo()
@@ -68,9 +70,9 @@ void GeometryTGeo::Build(int loadTrans)
   }
 
   mNumberOfLayersMLOT = extractNumberOfLayersMLOT();
+  mNumberOfPetalsVD = extractNumberOfPetalsVD();
   mNumberOfActivePartsVD = extractNumberOfActivePartsVD();
   mNumberOfLayersVD = extractNumberOfLayersVD();
-  mNumberOfPetalsVD = extractNumberOfPetalsVD();
   mNumberOfDisksVD = extractNumberOfDisksVD();
 
   mNumberOfStaves.resize(mNumberOfLayersMLOT);
@@ -451,118 +453,261 @@ int GeometryTGeo::extractNumberOfLayersMLOT()
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::extractNumberOfActivePartsVD() const
+int GeometryTGeo::extractNumberOfPetalsVD() const
 {
-  // The number of active parts returned here is 36 = 4 petals * (3 layers + 6 disks)
-  int numberOfParts = 0;
+  int numberOfPetals = 0;
+  TGeoVolume* trkV = gGeoManager->GetVolume(getTRKVolPattern());
+  if (!trkV) {
+    LOGP(fatal, "{} volume {} is not in the geometry", getName(), getTRKVolPattern());
+    return 0;
+  }
 
-  TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
-  if (vdV == nullptr) {
-    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  // Loop on all TRKV nodes, count PETAL assemblies and their contents
+  TObjArray* nodes = trkV->GetNodes();
+  if (!nodes) {
+    LOGP(warning, "{} volume has no child nodes", getTRKVolPattern());
+    return 0;
   }
 
-  // Loop on all TRKV nodes, count Layer volumes by checking names
-  TObjArray* nodes = vdV->GetNodes();
-  int nNodes = nodes->GetEntriesFast();
-  for (int j = 0; j < nNodes; j++) {
-    int lrID = -1;
-    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+  LOGP(info, "Searching for petal assemblies in {} (pattern: {})",
+       getTRKVolPattern(), getTRKPetalAssemblyPattern());
+
+  for (int j = 0; j < nodes->GetEntriesFast(); j++) {
+    auto* nd = dynamic_cast<TGeoNode*>(nodes->At(j));
     const char* name = nd->GetName();
 
-    if (strstr(name, getTRKPetalPattern()) != nullptr && (strstr(name, getTRKPetalLayerPattern()) != nullptr || strstr(name, getTRKPetalDiskPattern()) != nullptr)) {
-      numberOfParts++;
-      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
-        LOG(fatal) << "Failed to extract layer ID from the " << name;
+    if (strstr(name, getTRKPetalAssemblyPattern()) != nullptr) {
+      numberOfPetals++;
+      LOGP(info, "Found petal assembly: {}", name);
+
+      // Get petal volume and its nodes for debugging
+      TGeoVolume* petalVol = nd->GetVolume();
+      if (petalVol) {
+        TObjArray* petalNodes = petalVol->GetNodes();
+        if (petalNodes) {
+          LOGP(debug, "Petal {} contains {} child nodes", name, petalNodes->GetEntriesFast());
+          // Print all nodes in this petal
+          for (int k = 0; k < petalNodes->GetEntriesFast(); k++) {
+            auto* petalNode = dynamic_cast<TGeoNode*>(petalNodes->At(k));
+            LOGP(debug, "  Node {}: {}", k, petalNode->GetName());
+          }
+        } else {
+          LOGP(warning, "Petal {} has no child nodes", name);
+        }
+      } else {
+        LOGP(warning, "Petal {} has no volume", name);
       }
     }
   }
-  return numberOfParts;
+
+  if (numberOfPetals == 0) {
+    LOGP(warning, "No petal assemblies found in geometry");
+  } else {
+    LOGP(info, "Found {} petal assemblies", numberOfPetals);
+  }
+
+  return numberOfPetals;
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::extractNumberOfDisksVD() const
+int GeometryTGeo::extractNumberOfActivePartsVD() const
 {
-  // The number of disks returned here is 6
-  int numberOfDisks = 0;
-
+  // The number of active parts returned here is 36 = 4 petals * (3 layers + 6 disks)
+  int numberOfParts = 0;
   TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
-  if (vdV == nullptr) {
-    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  if (!vdV) {
+    LOGP(fatal, "{} volume {} is not in the geometry", getName(), getTRKVolPattern());
+    return 0;
   }
 
-  // Loop on all TRKV nodes, count Layer volumes by checking names
+  // Find first petal to count its active parts
   TObjArray* nodes = vdV->GetNodes();
-  int nNodes = nodes->GetEntriesFast();
-  for (int j = 0; j < nNodes; j++) {
-    int lrID = -1;
-    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+  if (!nodes) {
+    LOGP(warning, "{} volume has no child nodes", getTRKVolPattern());
+    return 0;
+  }
+
+  bool petalFound = false;
+
+  for (int j = 0; j < nodes->GetEntriesFast(); j++) {
+    auto* nd = dynamic_cast<TGeoNode*>(nodes->At(j));
     const char* name = nd->GetName();
+    if (strstr(name, getTRKPetalAssemblyPattern()) == nullptr) {
+      continue;
+    }
 
-    if (strstr(name, Form("%s%s", getTRKPetalPattern(), "0")) != nullptr && (strstr(name, getTRKPetalDiskPattern()) != nullptr)) {
-      numberOfDisks++;
-      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
-        LOG(fatal) << "Failed to extract layer ID from the " << name;
+    petalFound = true;
+    LOGP(info, "Counting active parts in petal: {}", name);
+
+    // Found a petal, count its layers and disks
+    TGeoVolume* petalVol = nd->GetVolume();
+    if (!petalVol) {
+      LOGP(warning, "Petal {} has no volume", name);
+      break;
+    }
+
+    TObjArray* petalNodes = petalVol->GetNodes();
+    if (!petalNodes) {
+      LOGP(warning, "Petal {} has no child nodes", name);
+      break;
+    }
+
+    for (int k = 0; k < petalNodes->GetEntriesFast(); k++) {
+      auto* petalNode = dynamic_cast<TGeoNode*>(petalNodes->At(k));
+      const char* nodeName = petalNode->GetName();
+
+      if (strstr(nodeName, getTRKPetalLayerPattern()) != nullptr ||
+          strstr(nodeName, getTRKPetalDiskPattern()) != nullptr) {
+        numberOfParts++;
+        LOGP(debug, "Found active part in {}: {}", name, nodeName);
       }
     }
+    // We only need to check one petal as they're identical
+    break;
   }
-  return numberOfDisks;
+
+  if (!petalFound) {
+    LOGP(warning, "No petal assembly found matching pattern '{}'", getTRKPetalAssemblyPattern());
+    return 0;
+  }
+
+  if (numberOfParts == 0) {
+    LOGP(warning, "No active parts (layers/disks) found in petal");
+    return 0;
+  }
+
+  // Multiply by number of petals since all petals are identical
+  int totalParts = numberOfParts * mNumberOfPetalsVD;
+  LOGP(info, "Total number of active parts: {} ({}*{})",
+       totalParts, numberOfParts, mNumberOfPetalsVD);
+  return totalParts;
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::extractNumberOfPetalsVD() const
+int GeometryTGeo::extractNumberOfDisksVD() const
 {
-  // The number of petals returned here is 4 = number of petals
-  int numberOfChips = 0;
-
+  // Count disks in the first petal (all petals are identical)
+  int numberOfDisks = 0;
   TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
-  if (vdV == nullptr) {
-    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  if (!vdV) {
+    LOGP(fatal, "{} volume {} is not in the geometry", getName(), getTRKVolPattern());
+    return 0;
   }
 
-  // Loop on all TRKV nodes, count Layer volumes by checking names
+  // Find first petal
   TObjArray* nodes = vdV->GetNodes();
-  int nNodes = nodes->GetEntriesFast();
-  for (int j = 0; j < nNodes; j++) {
-    int lrID = -1;
-    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
-    const char* name = nd->GetName();
+  if (!nodes) {
+    LOGP(warning, "{} volume has no child nodes", getTRKVolPattern());
+    return 0;
+  }
 
-    if (strstr(name, getTRKPetalPattern()) != nullptr && (strstr(name, Form("%s%s", getTRKPetalLayerPattern(), "0")) != nullptr)) {
-      numberOfChips++;
-      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
-        LOG(fatal) << "Failed to extract layer ID from the " << name;
+  bool petalFound = false;
+
+  for (int j = 0; j < nodes->GetEntriesFast(); j++) {
+    auto* nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+    if (strstr(nd->GetName(), getTRKPetalAssemblyPattern()) == nullptr) {
+      continue;
+    }
+
+    petalFound = true;
+    LOGP(info, "Counting disks in petal: {}", nd->GetName());
+
+    // Count disks in this petal
+    TGeoVolume* petalVol = nd->GetVolume();
+    if (!petalVol) {
+      LOGP(warning, "Petal {} has no volume", nd->GetName());
+      break;
+    }
+
+    TObjArray* petalNodes = petalVol->GetNodes();
+    if (!petalNodes) {
+      LOGP(warning, "Petal {} has no child nodes", nd->GetName());
+      break;
+    }
+
+    for (int k = 0; k < petalNodes->GetEntriesFast(); k++) {
+      auto* petalNode = dynamic_cast<TGeoNode*>(petalNodes->At(k));
+      if (strstr(petalNode->GetName(), getTRKPetalDiskPattern()) != nullptr) {
+        numberOfDisks++;
+        LOGP(info, "Found disk in {} : {}", nd->GetName(), petalNode->GetName());
       }
     }
+    // One petal is enough
+    break;
   }
-  return numberOfChips;
+
+  if (!petalFound) {
+    LOGP(warning, "No petal assembly found matching pattern '{}'", getTRKPetalAssemblyPattern());
+  }
+
+  if (numberOfDisks == 0) {
+    LOGP(warning, "No disks found in VD geometry");
+  }
+
+  return numberOfDisks;
 }
 
 //__________________________________________________________________________
 int GeometryTGeo::extractNumberOfLayersVD() const
 {
-  // The number of layers returned here is 3
+  // Count layers in the first petal (all petals are identical)
   int numberOfLayers = 0;
-
   TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
-  if (vdV == nullptr) {
-    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  if (!vdV) {
+    LOGP(fatal, "{} volume {} is not in the geometry", getName(), getTRKVolPattern());
+    return 0;
   }
 
-  // Loop on all TRKV nodes, count Layer volumes by checking names
+  // Find first petal
   TObjArray* nodes = vdV->GetNodes();
-  int nNodes = nodes->GetEntriesFast();
-  for (int j = 0; j < nNodes; j++) {
-    int lrID = -1;
-    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
-    const char* name = nd->GetName();
+  if (!nodes) {
+    LOGP(warning, "{} volume has no child nodes", getTRKVolPattern());
+    return 0;
+  }
 
-    if (strstr(name, Form("%s%s", getTRKPetalPattern(), "0")) != nullptr && strstr(name, getTRKPetalLayerPattern()) != nullptr) {
-      numberOfLayers++;
-      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
-        LOG(fatal) << "Failed to extract layer ID from the " << name;
+  bool petalFound = false;
+
+  for (int j = 0; j < nodes->GetEntriesFast(); j++) {
+    auto* nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+    if (strstr(nd->GetName(), getTRKPetalAssemblyPattern()) == nullptr) {
+      continue;
+    }
+
+    petalFound = true;
+    LOGP(info, "Counting layers in petal: {}", nd->GetName());
+
+    // Count layers in this petal
+    TGeoVolume* petalVol = nd->GetVolume();
+    if (!petalVol) {
+      LOGP(warning, "Petal {} has no volume", nd->GetName());
+      break;
+    }
+
+    TObjArray* petalNodes = petalVol->GetNodes();
+    if (!petalNodes) {
+      LOGP(warning, "Petal {} has no child nodes", nd->GetName());
+      break;
+    }
+
+    for (int k = 0; k < petalNodes->GetEntriesFast(); k++) {
+      auto* petalNode = dynamic_cast<TGeoNode*>(petalNodes->At(k));
+      if (strstr(petalNode->GetName(), getTRKPetalLayerPattern()) != nullptr) {
+        numberOfLayers++;
+        LOGP(info, "Found layer in {} : {}", nd->GetName(), petalNode->GetName());
       }
     }
+    // One petal is enough
+    break;
+  }
+
+  if (!petalFound) {
+    LOGP(warning, "No petal assembly found matching pattern '{}'", getTRKPetalAssemblyPattern());
+  }
+
+  if (numberOfLayers == 0) {
+    LOGP(warning, "No layers found in VD geometry");
   }
+
   return numberOfLayers;
 }
 
@@ -571,27 +716,82 @@ int GeometryTGeo::extractNumberOfChipsPerPetalVD() const
 {
   // The number of chips per petal returned here is 9 for each layer = number of layers + number of quarters of disks per petal
   int numberOfChips = 0;
-
   TGeoVolume* vdV = gGeoManager->GetVolume(getTRKVolPattern());
-  if (vdV == nullptr) {
-    LOG(fatal) << getName() << " volume " << getTRKVolPattern() << " is not in the geometry";
+  if (!vdV) {
+    LOGP(fatal, "{} volume {} is not in the geometry", getName(), getTRKVolPattern());
+    return 0;
   }
 
-  // Loop on all TRKV nodes, count Layer volumes by checking names
+  // Find first petal assembly
   TObjArray* nodes = vdV->GetNodes();
-  int nNodes = nodes->GetEntriesFast();
-  for (int j = 0; j < nNodes; j++) {
-    int lrID = -1;
-    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j));
+  if (!nodes) {
+    LOGP(warning, "{} volume has no child nodes", getTRKVolPattern());
+    return 0;
+  }
+
+  bool petalFound = false;
+
+  for (int j = 0; j < nodes->GetEntriesFast(); j++) {
+    auto* nd = dynamic_cast<TGeoNode*>(nodes->At(j));
     const char* name = nd->GetName();
+    if (strstr(name, getTRKPetalAssemblyPattern()) == nullptr) {
+      continue;
+    }
 
-    if (strstr(name, Form("%s%s", getTRKPetalPattern(), "0")) != nullptr && (strstr(name, getTRKPetalLayerPattern()) != nullptr || strstr(name, getTRKPetalDiskPattern()) != nullptr)) {
-      numberOfChips++;
-      if ((lrID = extractVolumeCopy(name, GeometryTGeo::getTRKPetalPattern())) < 0) {
-        LOG(fatal) << "Failed to extract layer ID from the " << name;
+    petalFound = true;
+    LOGP(info, "Counting chips in petal: {}", name);
+
+    // Found a petal, count sensors in its layers and disks
+    TGeoVolume* petalVol = nd->GetVolume();
+    if (!petalVol) {
+      LOGP(warning, "Petal {} has no volume", name);
+      break;
+    }
+
+    TObjArray* petalNodes = petalVol->GetNodes();
+    if (!petalNodes) {
+      LOGP(warning, "Petal {} has no child nodes", name);
+      break;
+    }
+
+    for (int k = 0; k < petalNodes->GetEntriesFast(); k++) {
+      auto* petalNode = dynamic_cast<TGeoNode*>(petalNodes->At(k));
+      const char* nodeName = petalNode->GetName();
+      TGeoVolume* vol = petalNode->GetVolume();
+
+      if (!vol) {
+        LOGP(debug, "Node {} has no volume", nodeName);
+        continue;
+      }
+
+      // Look for sensors in this volume
+      TObjArray* subNodes = vol->GetNodes();
+      if (!subNodes) {
+        LOGP(debug, "Node {} has no sub-nodes", nodeName);
+        continue;
+      }
+
+      for (int i = 0; i < subNodes->GetEntriesFast(); i++) {
+        auto* subNode = dynamic_cast<TGeoNode*>(subNodes->At(i));
+        if (strstr(subNode->GetName(), getTRKSensorPattern()) != nullptr) {
+          numberOfChips++;
+          LOGP(debug, "Found sensor in {}: {}", nodeName, subNode->GetName());
+        }
       }
     }
+    // We only need one petal
+    break;
   }
+
+  if (!petalFound) {
+    LOGP(warning, "No petal assembly found matching pattern '{}'", getTRKPetalAssemblyPattern());
+  }
+
+  if (numberOfChips == 0) {
+    LOGP(warning, "No chips/sensors found in VD petal");
+  }
+
+  LOGP(info, "Number of chips per petal: {}", numberOfChips);
   return numberOfChips;
 }
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
index ab817a3fdaa0d..0c3c35d49f722 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
@@ -18,9 +18,8 @@ o2_add_library(TRKSimulation
                        src/Digitizer.cxx
                        src/TRKServices.cxx
                        src/DPLDigitizerParam.cxx
-                       src/TRKPetalCase.cxx
-                       src/TRKPetalLayer.cxx
-                       src/TRKPetalDisk.cxx
+                       src/VDLayer.cxx
+                       src/VDGeometryBuilder.cxx
                PUBLIC_LINK_LIBRARIES O2::TRKBase
                                      O2::FT3Simulation
                                      O2::ITSMFTSimulation
@@ -35,7 +34,7 @@ o2_target_root_dictionary(TRKSimulation
                                   include/TRKSimulation/Detector.h
                                   include/TRKSimulation/TRKLayer.h
                                   include/TRKSimulation/TRKServices.h
-                                  include/TRKSimulation/TRKPetalCase.h
-                                  include/TRKSimulation/TRKPetalLayer.h
-                                  include/TRKSimulation/TRKPetalDisk.h
+                                  include/TRKSimulation/VDLayer.h
+                                  include/TRKSimulation/VDGeometryBuilder.h
+                                  include/TRKSimulation/VDSensorRegistry.h
                                   include/TRKSimulation/DPLDigitizerParam.h)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
index 8ed5737abcb35..92cebd681176d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
@@ -17,7 +17,6 @@
 
 #include "TRKSimulation/TRKLayer.h"
 #include "TRKSimulation/TRKServices.h"
-#include "TRKSimulation/TRKPetalCase.h"
 #include "TRKBase/GeometryTGeo.h"
 
 #include <TLorentzVector.h>
@@ -31,9 +30,6 @@ namespace trk
 class Detector : public o2::base::DetImpl<Detector>
 {
  public:
-  static constexpr Int_t mNumberOfVolumes = 44;   /// hardcoded for the current geometry = 8 MLOT layers + 36 volumes in the VD. TODO: automatize or change according to the current geometry
-  static constexpr Int_t mNumberOfVolumesVD = 36; /// hardcoded for the current geometry = 36 volumes in the VD. TODO: automatize or change according to the current geometry
-
   Detector(bool active);
   Detector();
   ~Detector();
@@ -71,7 +67,7 @@ class Detector : public o2::base::DetImpl<Detector>
   }
 
   void configDefault();
-  void buildTRKNewVacuumVessel();
+  void buildTRKMiddleOuterLayers();
   void configFromFile(std::string fileName = "alice3_TRK_layout.txt");
   void configToFile(std::string fileName = "alice3_TRK_layout.txt");
 
@@ -80,6 +76,9 @@ class Detector : public o2::base::DetImpl<Detector>
   void createGeometry();
 
  private:
+  int mNumberOfVolumes;
+  int mNumberOfVolumesVD;
+
   // Transient data about track passing the sensor
   struct TrackData {
     bool mHitStarted;                  // hit creation started
@@ -91,8 +90,7 @@ class Detector : public o2::base::DetImpl<Detector>
   GeometryTGeo* mGeometryTGeo;         //!
   std::vector<o2::itsmft::Hit>* mHits; // ITSMFT ones for the moment
   std::vector<TRKLayer> mLayers;
-  TRKServices mServices;                 // Houses the services of the TRK, but not the Iris tracker
-  std::vector<TRKPetalCase> mPetalCases; // Houses the Iris tracker and its services. Created fully in the beam pipe
+  TRKServices mServices; // Houses the services of the TRK, but not the Iris tracker
 
   std::vector<std::string> mFirstOrLastLayers; // Names of the first or last layers
   bool InsideFirstOrLastLayer(std::string layerName);
@@ -106,8 +104,6 @@ class Detector : public o2::base::DetImpl<Detector>
  public:
   static constexpr Int_t sNumberVDPetalCases = 4;          //! Number of VD petals
   int getNumberOfLayers() const { return mLayers.size(); } //! Number of TRK layers
-  int getNumberOfLayersVD() const { return mPetalCases[0].mPetalLayers.size(); }
-  int getNumberOfDisksVD() const { return mPetalCases[0].mPetalDisks.size(); }
 
   void Print(FairVolume* vol, int volume, int subDetID, int layer, int stave, int halfstave, int chipID) const;
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalCase.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalCase.h
deleted file mode 100644
index cd45cc98fd177..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalCase.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef ALICEO2_TRK_PETALCASE_H
-#define ALICEO2_TRK_PETALCASE_H
-
-#include <Rtypes.h>
-
-#include "TRKSimulation/TRKPetalLayer.h"
-#include "TRKSimulation/TRKPetalDisk.h"
-#include "TGeoCompositeShape.h"
-
-namespace o2
-{
-namespace trk
-{
-class TRKPetalCase
-{
- public:
-  TRKPetalCase() = default;
-  TRKPetalCase(Int_t number, TGeoVolume* motherVolume, Bool_t irisOpen);
-  ~TRKPetalCase() = default;
-
-  // Sensitive volume list
-  std::vector<TRKPetalLayer> mPetalLayers;
-  std::vector<TRKPetalDisk> mPetalDisks;
-
-  auto getPetalCaseName() { return mPetalCaseName; }
-  TString getFullName();
-
- private:
-  void constructCase(TGeoVolume* motherVolume);
-  void constructColdPlate(TGeoVolume* motherVolume);
-  void constructDetectionPetals(TGeoVolume* motherVolume);
-  void addDetectionPetelsToFullComposite();
-
-  void addToPetalCaseComposite(TString shape) { mFullCompositeFormula += ("+" + shape); }
-
-  Int_t mPetalCaseNumber; // Used to determine rotation and position. 0-3
-  Bool_t mOpenState;      // At injection energy, the iris tracker is in the open position. During stable beams, it is closed
-
-  TString mPetalCaseName;
-  TString mFullCompositeFormula; // Used to excavate the petal and all its components from the vacuum
-
-  // Center position of the petal case. 0,0,0 at stable beams (a.k.a. closed state)
-  Double_t mXPos, mYPos, mZPos;
-
-  Double_t mWallThickness;   // cm // Assume all the walls have the same thickness for now
-  Double_t mRIn;             // cm
-  Double_t mROut;            // cm
-  Double_t mRInOpenState;    // cm
-  Double_t mPetalCaseLength; // cm
-
-  Double_t mAngularCoverageAzimuthalWall; // Rad // Angular coverage of azimuthal part of wall (equivalent to that of the sensitive volumes)
-  Double_t mAngularCoverageRadialWall;    // Rad // Angular coverage of radial part of wall
-  Double_t mToDeg;
-
-  // Petal case parts -> In one composite shape
-  TGeoTubeSeg* mInnerAzimuthalWall;
-  TGeoTubeSeg* mOuterAzimuthalWall;
-  TGeoTubeSeg* mRadialWall;
-  TGeoTubeSeg* mForwardWall;
-
-  TGeoRotation* mAzimuthalWallRot;
-  TGeoRotation* mRadialWall1Rot;
-  TGeoRotation* mRadialWall2Rot;
-
-  TGeoCombiTrans* mAzimuthalWallCombiTrans;
-  TGeoCombiTrans* mRadialWall1CombiTrans;
-  TGeoCombiTrans* mRadialWall2CombiTrans;
-  TGeoCombiTrans* mForwardWall1CombiTrans;
-  TGeoCombiTrans* mForwardWall2CombiTrans;
-
-  TGeoVolume* mPetalCaseVolume;
-
-  // Cold plate
-  TGeoTubeSeg* mColdPlate;
-  TGeoVolume* mColdPlateVolume;
-
-  ClassDef(TRKPetalCase, 1);
-};
-
-} // namespace trk
-} // namespace o2
-#endif // ALICEO2_TRK_PETALCASE_H
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalDisk.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalDisk.h
deleted file mode 100644
index 465f52eb8d41b..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalDisk.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file TRKPetalDisk.h
-/// \brief Definition of the TRKPetalDisk class
-
-#ifndef ALICEO2_TRK_PETAL_DISK_H_
-#define ALICEO2_TRK_PETAL_DISK_H_
-
-#include "TGeoManager.h"       // for gGeoManager
-#include "Rtypes.h"            // for Double_t, Int_t, Bool_t, etc
-#include <fairlogger/Logger.h> // for LOG
-
-namespace o2
-{
-namespace trk
-{
-
-/// This class defines the Geometry for the TRK Disk TGeo.
-class TRKPetalDisk
-{
- public:
-  TRKPetalDisk() = default;
-  TRKPetalDisk(Int_t diskNumber, std::string diskName, Float_t z, Float_t rIn, Float_t rOut, Float_t angularCoverage, Float_t Diskx2X0);
-  ~TRKPetalDisk() = default;
-
-  auto getInnerRadius() const { return mInnerRadius; }
-  auto getOuterRadius() const { return mOuterRadius; }
-  auto getThickness() const { return mChipThickness; }
-  auto getAngularCoverage() const { return mAngularCoverage; }
-  auto getZ() const { return mZ; }
-  auto getx2X0() const { return mx2X0; }
-  auto getName() const { return mDiskName; }
-  auto getSensorName() const { return mSensorName; }
-
-  /// Creates the actual Disk and places inside its mother volume
-  /// \param motherVolume the TGeoVolume owing the volume structure
-  void createDisk(TGeoVolume* motherVolume, TGeoCombiTrans* combiTrans);
-
- private:
-  Int_t mDiskNumber = -1; ///< Current disk number
-  std::string mDiskName;  ///< Current disk name
-  std::string mSensorName;
-  Double_t mInnerRadius; ///< Inner radius of this disk
-  Double_t mOuterRadius; ///< Outer radius of this disk
-  Double_t mAngularCoverage;
-  Double_t mZ;             ///< Z position of the disk
-  Double_t mChipThickness; ///< Chip thickness
-  Double_t mx2X0;          ///< Disk material budget x/X0
-
-  ClassDef(TRKPetalDisk, 1);
-};
-} // namespace trk
-} // namespace o2
-
-#endif // ALICEO2_TRK_PETAL_DISK_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalLayer.h
deleted file mode 100644
index 4e7a7735d51f0..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKPetalLayer.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef ALICEO2_TRK_PETAL_LAYER_H
-#define ALICEO2_TRK_PETAL_LAYER_H
-
-#include "TGeoManager.h"
-#include <Rtypes.h>
-#include "TGeoTube.h"
-
-#include "TRKBase/TRKBaseParam.h"
-
-namespace o2
-{
-namespace trk
-{
-class TRKPetalLayer
-{
- public:
-  TRKPetalLayer() = default;
-  TRKPetalLayer(Int_t layerNumber, std::string layerName, Float_t rIn, Float_t angularCoverage, Float_t zLength, Float_t layerX2X0);
-  ~TRKPetalLayer() = default;
-
-  auto getInnerRadius() const { return mInnerRadius; }
-  auto getAngularCoverage() const { return mAngularCoverage; }
-  auto getZLength() { return mZ; }
-  auto getx2X0() const { return mX2X0; }
-  auto getChipThickness() const { return mChipThickness; }
-  auto getNumber() const { return mLayerNumber; }
-  auto getName() const { return mLayerName; }
-  auto getSensorName() const { return mSensorName; }
-
-  void createLayer(TGeoVolume* motherVolume, TGeoCombiTrans* combiTrans);
-
- private:
-  Int_t mLayerNumber;
-  std::string mLayerName;
-  std::string mSensorName;
-  Float_t mInnerRadius;
-  Float_t mZ;
-  Float_t mX2X0;
-  Float_t mChipThickness;
-  Float_t mModuleWidth;     // u.m. = cm
-  Float_t mAngularCoverage; // rad
-
-  TGeoTubeSeg* mLayer;
-
-  ClassDef(TRKPetalLayer, 1);
-};
-
-} // namespace trk
-} // namespace o2
-#endif // ALICEO2_TRK_PETAL_LAYER_H
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
new file mode 100644
index 0000000000000..0a2cb68f2233a
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
@@ -0,0 +1,35 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRK_VDGEOMETRYBUILDER_H
+#define O2_TRK_VDGEOMETRYBUILDER_H
+
+class TGeoVolume;
+
+#include <string>
+#include <vector>
+
+namespace o2::trk
+{
+
+// Build full VD for each design.
+// Each function builds one local petal assembly (walls + layers + disks)
+// and then places/rotates the petal once into the mother volume.
+
+void createIRIS4Geometry(TGeoVolume* motherVolume);  // 4 petals, cylindrical L0
+void createIRIS4aGeometry(TGeoVolume* motherVolume); // 3 petals, cylindrical L0
+void createIRIS5Geometry(TGeoVolume* motherVolume);  // 4 petals, rectangular L0
+
+void createSinglePetalDebug(TGeoVolume* motherVolume, int petalID = 0, int nPetals = 4, bool rectangularL0 = false);
+
+} // namespace o2::trk
+
+#endif // O2_TRK_VDGEOMETRYBUILDER_H
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDLayer.h
new file mode 100644
index 0000000000000..9e9ca2971bc3b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDLayer.h
@@ -0,0 +1,110 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_VD_LAYER_H
+#define ALICEO2_VD_LAYER_H
+
+#include <string>
+#include <Rtypes.h>
+
+class TGeoVolume;
+class TGeoMatrix;
+
+namespace o2
+{
+namespace trk
+{
+
+// Base class for a VD layer
+class VDLayer
+{
+ public:
+  VDLayer() = default;
+  VDLayer(int layerNumber, const std::string& layerName, double layerX2X0);
+  virtual ~VDLayer() = default;
+
+  // Create the layer (AIR container + sensors) and insert it into mother
+  virtual void createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans = nullptr) const = 0;
+
+  double getChipThickness() const { return mChipThickness; }
+
+ protected:
+  int mLayerNumber{0};
+  std::string mLayerName;
+  double mX2X0{0.f};          // Radiation length in units of X0
+  double mChipThickness{0.f}; // thickness derived from X/X0
+  double mModuleWidth{4.54f}; // cm
+
+  // ClassDef(VDLayer, 1)
+};
+
+// Cylindrical segment layer
+class VDCylindricalLayer : public VDLayer
+{
+ public:
+  VDCylindricalLayer(int layerNumber, const std::string& layerName, double layerX2X0,
+                     double radius, double phiSpanDeg, double lengthZ, double lengthSensZ);
+
+  TGeoVolume* createSensor() const; // builds the sensor volume
+  void createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans = nullptr) const override;
+
+ private:
+  double mRadius{0.f};
+  double mPhiSpanDeg{0.f};  // degrees
+  double mLengthZ{0.f};     // layer container length in Z
+  double mLengthSensZ{0.f}; // sensor length in Z
+
+  // ClassDef(VDCylindricalLayer, 1)
+};
+
+// Rectangular segment layer
+class VDRectangularLayer : public VDLayer
+{
+ public:
+  VDRectangularLayer(int layerNumber, const std::string& layerName, double layerX2X0,
+                     double width, double lengthZ, double lengthSensZ);
+
+  TGeoVolume* createSensor() const;
+  void createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans = nullptr) const override;
+
+ private:
+  double mWidth{0.f};
+  double mLengthZ{0.f};
+  double mLengthSensZ{0.f};
+
+  // ClassDef(VDRectangularLayer, 1)
+};
+
+// Disk segment layer
+class VDDiskLayer : public VDLayer
+{
+ public:
+  VDDiskLayer(int layerNumber, const std::string& layerName, double layerX2X0,
+              double rMin, double rMax, double phiSpanDeg, double zPos);
+
+  TGeoVolume* createSensor() const;
+  void createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans = nullptr) const override;
+
+  double getZPosition() const { return mZPos; }
+
+ private:
+  double mRMin{0.f};
+  double mRMax{0.f};
+  double mPhiSpanDeg{0.f}; // degrees
+  double mZPos{0.f};       // placement along Z
+
+  // ClassDef(VDDiskLayer, 1)
+};
+
+} // namespace trk
+} // namespace o2
+
+#endif // ALICEO2_VD_LAYER_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDSensorRegistry.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDSensorRegistry.h
new file mode 100644
index 0000000000000..c4fa222e1f4ef
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDSensorRegistry.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRK_VDSENSORREGISTRY_H
+#define O2_TRK_VDSENSORREGISTRY_H
+
+#include <string>
+#include <vector>
+
+namespace o2::trk
+{
+
+struct VDSensorDesc {
+  enum class Region { Barrel,
+                      Disk };
+  enum class Type { Curved,
+                    Plane,
+  };
+  std::string name; // sensor volume name
+  int petal = -1;
+  Region region = Region::Barrel;
+  Type type = Type::Curved;
+  int idx = -1; // layer or disk index
+};
+
+// Accessor (defined in VDGeometryBuilder.cxx)
+std::vector<VDSensorDesc>& vdSensorRegistry();
+
+// Utilities (defined in VDGeometryBuilder.cxx)
+void clearVDSensorRegistry();
+void registerSensor(const std::string& volName, int petal, VDSensorDesc::Region region, VDSensorDesc::Type type, int idx);
+
+} // namespace o2::trk
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index f5027310fa66d..a4d99ccf9f79f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -19,6 +19,8 @@
 #include "ITSMFTSimulation/Hit.h"
 #include "TRKSimulation/Detector.h"
 #include "TRKBase/TRKBaseParam.h"
+#include "TRKSimulation/VDGeometryBuilder.h"
+#include "TRKSimulation/VDSensorRegistry.h"
 
 using o2::itsmft::Hit;
 
@@ -26,6 +28,7 @@ namespace o2
 {
 namespace trk
 {
+
 float getDetLengthFromEta(const float eta, const float radius)
 {
   return 2. * (10. + radius * std::cos(2 * std::atan(std::exp(-eta))));
@@ -48,33 +51,11 @@ Detector::Detector(bool active)
   if (trkPars.configFile != "") {
     configFromFile(trkPars.configFile);
   } else {
-    buildTRKNewVacuumVessel();
+    buildTRKMiddleOuterLayers();
     configToFile();
     configServices();
   }
 
-  mSensorName.resize(mNumberOfVolumes); // hardcoded. TODO: change size when a different naming scheme for VD is in place. Ideally could be 4 petals + 8 layers = 12
-  int VDvolume = 0;
-  for (int i = 0; i < 4; i++) { /// VD
-    for (int j = 0; j < 3; j++) {
-      mSensorName[VDvolume].Form("%s%d_%s%d_%s%d", GeometryTGeo::getTRKPetalPattern(), i, GeometryTGeo::getTRKPetalLayerPattern(), j, GeometryTGeo::getTRKSensorPattern(), j);
-      VDvolume++;
-    }
-    for (int j = 0; j < 6; j++) {
-      mSensorName[VDvolume].Form("%s%d_%s%d_%s%d", GeometryTGeo::getTRKPetalPattern(), i, GeometryTGeo::getTRKPetalDiskPattern(), j, GeometryTGeo::getTRKSensorPattern(), j);
-      VDvolume++;
-    }
-  }
-
-  for (int i = 0; i < 8; i++) { /// MLOT
-    mSensorName[VDvolume].Form("%s%d", GeometryTGeo::getTRKSensorPattern(), i);
-    VDvolume++;
-  }
-
-  for (auto vd : mSensorName) {
-    std::cout << "Volume name: " << vd << std::endl;
-  }
-
   LOGP(info, "Summary of TRK configuration:");
   for (auto& layer : mLayers) {
     LOGP(info, "Layer: {} name: {} r: {} cm | z: {} cm | thickness: {} cm", layer.getNumber(), layer.getName(), layer.getInnerRadius(), layer.getZ(), layer.getChipThickness());
@@ -115,7 +96,7 @@ void Detector::configDefault()
   mLayers.emplace_back(7, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(7)}, 80.f, 258.f, 100.e-3);
 }
 
-void Detector::buildTRKNewVacuumVessel()
+void Detector::buildTRKMiddleOuterLayers()
 {
   // Build the TRK detector according to changes proposed during
   // https://indico.cern.ch/event/1407704/
@@ -125,9 +106,6 @@ void Detector::buildTRKNewVacuumVessel()
   mLayers.clear();
 
   LOGP(warning, "Loading \"After Upgrade Days March 2024\" configuration for ALICE3 TRK");
-  // mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 0.5f, 50.f, 100.e-4);
-  // mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 1.2f, 50.f, 100.e-4);
-  // mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 2.5f, 50.f, 100.e-4);
   mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 7.f, 124.f, 100.e-3);
   LOGP(info, "TRKLayer created. Name: {}", std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)});
   mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 9.f, 124.f, 100.e-3);
@@ -260,13 +238,38 @@ void Detector::createGeometry()
 
   // Add service for inner tracker
   mServices.createServices(vTRK);
-  mPetalCases.clear();
-  // Add petal cases (the sensitive layers inside the petal cases get constructed here too)
-  auto& trkPars = TRKBaseParam::Instance();
-  for (Int_t petalCaseNumber = 0; petalCaseNumber < sNumberVDPetalCases; ++petalCaseNumber) {
-    mPetalCases.emplace_back(petalCaseNumber, vTRK, trkPars.irisOpen);
-    mServices.excavateFromVacuum(mPetalCases[petalCaseNumber].getFullName());
+
+  // Build the VD using the petal builder
+  // Choose the VD design (here: IRIS4 by default).
+  // You can wire this to a parameter in TRKBaseParam if desired.
+  // Alternatives: createIRIS5Geometry(vTRK); createIRIS4aGeometry(vTRK);
+
+  o2::trk::clearVDSensorRegistry();
+  o2::trk::createIRIS4Geometry(vTRK);
+
+  // Fill sensor names from registry right after geometry creation
+  const auto& regs = o2::trk::vdSensorRegistry();
+  mNumberOfVolumesVD = static_cast<int>(regs.size());
+  mNumberOfVolumes = mNumberOfVolumesVD + mLayers.size();
+  mSensorName.resize(mNumberOfVolumes);
+
+  // Fill VD sensor names from registry
+  int VDvolume = 0;
+  for (const auto& sensor : regs) {
+    mSensorName[VDvolume] = sensor.name;
+    VDvolume++;
+  }
+
+  // Add MLOT sensor names
+  for (int i = 0; i < mLayers.size(); i++) {
+    mSensorName[VDvolume++].Form("%s%d", GeometryTGeo::getTRKSensorPattern(), i);
   }
+
+  for (auto vd : mSensorName) {
+    std::cout << "Volume name: " << vd << std::endl;
+  }
+
+  mServices.excavateFromVacuum("IRIS_CUTOUTsh");
   mServices.registerVacuum(vTRK);
 }
 
@@ -279,7 +282,7 @@ void Detector::InitializeO2Detector()
   mSensorID.resize(mNumberOfVolumes); // hardcoded. TODO: change size when a different namingh scheme for VD is in place. Ideally could be 4 petals + 8 layers = 12
   for (int i = 0; i < mNumberOfVolumes; i++) {
     mSensorID[i] = gMC ? TVirtualMC::GetMC()->VolId(mSensorName[i]) : 0; // Volume ID from the Geant geometry
-    LOGP(info, "{}: mSensorID={}", i, mSensorID[i]);
+    LOGP(info, "{}: mSensorID={}, mSensorName={}", i, mSensorID[i], mSensorName[i].Data());
   }
 }
 
@@ -291,26 +294,18 @@ void Detector::defineSensitiveVolumes()
   TString volumeName;
   LOGP(info, "Adding TRK Sensitive Volumes");
 
-  // Add petal case sensitive volumes
-  for (int petalCase = 0; petalCase < sNumberVDPetalCases; ++petalCase) {
-    // Petal layers
-    for (int petalLayer = 0; petalLayer < mPetalCases[petalCase].mPetalLayers.size(); ++petalLayer) {
-      volumeName = mPetalCases[petalCase].mPetalLayers[petalLayer].getSensorName();
-      if (petalLayer == 0) {
-        mFirstOrLastLayers.push_back(volumeName.Data());
-      }
-      LOGP(info, "Trying {}", volumeName.Data());
-      v = geoManager->GetVolume(volumeName.Data());
-      LOGP(info, "Adding TRK Sensitive Volume {}", v->GetName());
-      AddSensitiveVolume(v);
+  // Register VD sensors created by VDGeometryBuilder
+  for (const auto& s : o2::trk::vdSensorRegistry()) {
+    TGeoVolume* v = gGeoManager->GetVolume(s.name.c_str());
+    if (!v) {
+      LOGP(warning, "VD sensor volume '{}' not found", s.name);
+      continue;
     }
-    // Petal disks
-    for (int petalDisk = 0; petalDisk < mPetalCases[petalCase].mPetalDisks.size(); ++petalDisk) {
-      volumeName = mPetalCases[petalCase].mPetalDisks[petalDisk].getSensorName();
-      LOGP(info, "Trying {}", volumeName.Data());
-      v = geoManager->GetVolume(volumeName.Data());
-      LOGP(info, "Adding TRK Sensitive Volume {}", v->GetName());
-      AddSensitiveVolume(v);
+    LOGP(info, "Adding VD Sensitive Volume {}", v->GetName());
+    AddSensitiveVolume(v);
+    // Optionally track first/last layers for TR references:
+    if (s.region == o2::trk::VDSensorDesc::Region::Barrel && (s.idx == 0 /*innermost*/)) {
+      mFirstOrLastLayers.push_back(s.name);
     }
   }
 
@@ -455,6 +450,8 @@ bool Detector::ProcessHits(FairVolume* vol)
 
     Print(vol, volume, subDetID, layer, stave, halfstave, chipID);
 
+    mGeometryTGeo->Print();
+
     Hit* p = addHit(stack->GetCurrentTrackNumber(), chipID, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
                     mTrackData.mMomentumStart.Vect(), mTrackData.mMomentumStart.E(), positionStop.T(),
                     mTrackData.mEnergyLoss, mTrackData.mTrkStatusStart, status);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalCase.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalCase.cxx
deleted file mode 100644
index c729d7d1ec4dd..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalCase.cxx
+++ /dev/null
@@ -1,202 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "TRKSimulation/TRKPetalCase.h"
-#include "TRKBase/GeometryTGeo.h"
-#include <DetectorsBase/MaterialManager.h>
-
-#include "Framework/Logger.h"
-
-#include "TGeoTube.h"
-#include "TGeoMatrix.h"
-#include "TGeoCompositeShape.h"
-#include "TGeoVolume.h"
-#include "TString.h"
-#include "TMath.h"
-
-namespace o2
-{
-namespace trk
-{
-TRKPetalCase::TRKPetalCase(Int_t number, TGeoVolume* motherVolume, Bool_t irisOpen) : mPetalCaseNumber(number), mOpenState(irisOpen)
-{
-
-  mWallThickness = .15e-1; // cm // Assume all the walls have the same thickness for now.
-  mRIn = 0.48;             // cm
-  mROut = 3;               // cm
-  mRInOpenState = 1.5;     // cm
-  mPetalCaseLength = 70.;  // cm
-
-  // Calculate angular coverages of azimuthal part of wall (equivalent to that of the sensitive volumes)
-  mAngularCoverageAzimuthalWall = (0.25 * (2 * mRIn * TMath::Pi()) - 2 * mWallThickness) / mRIn;
-  mAngularCoverageRadialWall = mWallThickness / mRIn;
-  mToDeg = 180 / TMath::Pi();
-
-  // Calculate the center of the petal (x_c, y_c, z_c) based on whether it is open or not
-  mZPos = 0;
-  if (mOpenState) {
-    Double_t rHalfPetal = 0.5 * (mRIn + mROut);
-    Double_t rOpenStateCenter = TMath::Sqrt(rHalfPetal * rHalfPetal + mRInOpenState * mRInOpenState);
-    mXPos = rOpenStateCenter * TMath::Cos(0.25 * TMath::Pi() + (mPetalCaseNumber - 1) * 0.5 * TMath::Pi());
-    mYPos = rOpenStateCenter * TMath::Sin(0.25 * TMath::Pi() + (mPetalCaseNumber - 1) * 0.5 * TMath::Pi());
-  } else {
-    mXPos = 0.;
-    mYPos = 0.;
-  }
-
-  // Make the petal case
-  constructCase(motherVolume);
-  // Make coldplate
-  constructColdPlate(motherVolume);
-  // Add the detection petals (quarter disks and barrel layers)
-  constructDetectionPetals(motherVolume);
-}
-
-TString TRKPetalCase::getFullName()
-{
-  TString fullCompositeName = Form("PETALCASE%d_FULLCOMPOSITE", mPetalCaseNumber);
-  TGeoCompositeShape* fullCompositeShape = new TGeoCompositeShape(fullCompositeName, mFullCompositeFormula);
-  return fullCompositeName;
-}
-
-void TRKPetalCase::constructCase(TGeoVolume* motherVolume)
-{
-
-  // Petal case parts in TGeoTubeSeg
-  mInnerAzimuthalWall = new TGeoTubeSeg(Form("PETAL%d_INNER_AZIMUTHAL_WALL", mPetalCaseNumber), mRIn, mRIn + mWallThickness, mPetalCaseLength / 2., -0.5 * mAngularCoverageAzimuthalWall * mToDeg, 0.5 * mAngularCoverageAzimuthalWall * mToDeg);
-  mOuterAzimuthalWall = new TGeoTubeSeg(Form("PETAL%d_OUTER_AZIMUTHAL_WALL", mPetalCaseNumber), mROut, mROut + mWallThickness, mPetalCaseLength / 2., -0.5 * mAngularCoverageAzimuthalWall * mToDeg, 0.5 * mAngularCoverageAzimuthalWall * mToDeg);
-  mRadialWall = new TGeoTubeSeg(Form("PETAL%d_RADIAL_WALL", mPetalCaseNumber), mRIn, mROut + mWallThickness, mPetalCaseLength / 2., -0.5 * mAngularCoverageRadialWall * mToDeg, 0.5 * mAngularCoverageRadialWall * mToDeg);
-  mForwardWall = new TGeoTubeSeg(Form("PETAL%d_FORWARD_WALL", mPetalCaseNumber), mRIn, mROut + mWallThickness, mWallThickness / 2., -0.5 * (mAngularCoverageAzimuthalWall + 2 * mAngularCoverageRadialWall) * mToDeg, 0.5 * (mAngularCoverageAzimuthalWall + 2 * mAngularCoverageRadialWall) * mToDeg);
-
-  // Rotate to correct section : 0-3
-  mAzimuthalWallRot = new TGeoRotation((TString)Form("PETAL%d_AZIMUTHAL_WALL_ROT", mPetalCaseNumber), (mPetalCaseNumber * 0.5 * TMath::Pi() + 0.5 * mAngularCoverageAzimuthalWall + mAngularCoverageRadialWall) * mToDeg, 0., 0.);
-  mAzimuthalWallRot->RegisterYourself();
-  mRadialWall1Rot = new TGeoRotation((TString)Form("PETAL%d_RADIAL_WALL1_ROT", mPetalCaseNumber), (mPetalCaseNumber * 0.5 * TMath::Pi() + 0.5 * mAngularCoverageRadialWall) * mToDeg, 0., 0.);
-  mRadialWall1Rot->RegisterYourself();
-  mRadialWall2Rot = new TGeoRotation((TString)Form("PETAL%d_RADIAL_WALL2_ROT", mPetalCaseNumber), (mPetalCaseNumber * 0.5 * TMath::Pi() + mAngularCoverageAzimuthalWall + 1.5 * mAngularCoverageRadialWall) * mToDeg, 0., 0.);
-  mRadialWall2Rot->RegisterYourself();
-
-  // Place to correct position (open or closed)
-  mAzimuthalWallCombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_AZIMUTHAL_WALL_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, mZPos, mAzimuthalWallRot);
-  mAzimuthalWallCombiTrans->RegisterYourself();
-  mRadialWall1CombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_RADIAL_WALL1_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, mZPos, mRadialWall1Rot);
-  mRadialWall1CombiTrans->RegisterYourself();
-  mRadialWall2CombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_RADIAL_WALL2_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, mZPos, mRadialWall2Rot);
-  mRadialWall2CombiTrans->RegisterYourself();
-  mForwardWall1CombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_FORWARD_WALL1_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, (mPetalCaseLength + mWallThickness) / 2., mAzimuthalWallRot);
-  mForwardWall1CombiTrans->RegisterYourself();
-  mForwardWall2CombiTrans = new TGeoCombiTrans((TString)Form("PETAL%d_FORWARD_WALL2_COMBITRANS", mPetalCaseNumber), mXPos, mYPos, -(mPetalCaseLength + mWallThickness) / 2., mAzimuthalWallRot);
-  mForwardWall2CombiTrans->RegisterYourself();
-
-  TString petalCaseCompositeFormula = (TString)Form("PETAL%d_INNER_AZIMUTHAL_WALL:PETAL%d_AZIMUTHAL_WALL_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_OUTER_AZIMUTHAL_WALL:PETAL%d_AZIMUTHAL_WALL_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_RADIAL_WALL:PETAL%d_RADIAL_WALL1_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_RADIAL_WALL:PETAL%d_RADIAL_WALL2_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_FORWARD_WALL:PETAL%d_FORWARD_WALL1_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber) + (TString)Form("+PETAL%d_FORWARD_WALL:PETAL%d_FORWARD_WALL2_COMBITRANS", mPetalCaseNumber, mPetalCaseNumber);
-
-  TGeoCompositeShape* petalCaseComposite = new TGeoCompositeShape((TString)Form("PETALCASE%dsh", mPetalCaseNumber), petalCaseCompositeFormula);
-  mFullCompositeFormula = petalCaseComposite->GetName();
-  auto& matmgr = o2::base::MaterialManager::Instance();
-  const TGeoMedium* kMedBe = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_BERYLLIUM");
-
-  mPetalCaseName = Form("PETALCASE%d", mPetalCaseNumber);
-  mPetalCaseVolume = new TGeoVolume(mPetalCaseName, petalCaseComposite, kMedBe);
-  mPetalCaseVolume->SetVisibility(1);
-  mPetalCaseVolume->SetLineColor(kGray);
-
-  LOGP(info, "Creating IRIS Tracker vacuum petal case {}", mPetalCaseNumber);
-  LOGP(info, "Inserting {} in {} ", mPetalCaseVolume->GetName(), motherVolume->GetName());
-  motherVolume->AddNode(mPetalCaseVolume, 1, nullptr);
-}
-
-void TRKPetalCase::constructColdPlate(TGeoVolume* motherVolume)
-{
-  Double_t coldPlateRadius = 2.6;     // cm
-  Double_t coldPlateThickness = 0.15; // cm
-  Double_t coldPlateLength = 50.;     // cm
-
-  mColdPlate = new TGeoTubeSeg((TString)Form("PETAL%d_COLDPLATE", mPetalCaseNumber), coldPlateRadius, coldPlateRadius + coldPlateThickness, coldPlateLength / 2., -0.5 * mAngularCoverageAzimuthalWall * mToDeg, 0.5 * mAngularCoverageAzimuthalWall * mToDeg);
-  auto& matmgr = o2::base::MaterialManager::Instance();
-  const TGeoMedium* medCeramic = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_CERAMIC");
-  mColdPlateVolume = new TGeoVolume(Form("COLDPLATE%d", mPetalCaseNumber), mColdPlate, medCeramic);
-
-  TString coldPlateCompositeFormula = mColdPlate->GetName();
-  coldPlateCompositeFormula += ":";
-  coldPlateCompositeFormula += mAzimuthalWallCombiTrans->GetName();
-  addToPetalCaseComposite(coldPlateCompositeFormula);
-
-  mColdPlateVolume->SetVisibility(1);
-  mColdPlateVolume->SetLineColor(kGray);
-
-  LOGP(info, "Creating cold plate service");
-  LOGP(info, "Inserting {} in {} ", mColdPlateVolume->GetName(), motherVolume->GetName());
-  motherVolume->AddNode(mColdPlateVolume, 1, mAzimuthalWallCombiTrans);
-}
-
-void TRKPetalCase::constructDetectionPetals(TGeoVolume* motherVolume)
-{
-  // Add petal layers
-  // layerNumber, layerName, rIn, angularCoverage, zLength, layerx2X0
-  mPetalLayers.emplace_back(0, Form("%s_LAYER%d", mPetalCaseName.Data(), 0), 0.5f, mAngularCoverageAzimuthalWall, 50.f, 1.e-3);
-  mPetalLayers.emplace_back(1, Form("%s_LAYER%d", mPetalCaseName.Data(), 1), 1.2f, mAngularCoverageAzimuthalWall, 50.f, 1.e-3);
-  mPetalLayers.emplace_back(2, Form("%s_LAYER%d", mPetalCaseName.Data(), 2), 2.5f, mAngularCoverageAzimuthalWall, 50.f, 1.e-3);
-  for (Int_t i = 0; i < mPetalLayers.size(); ++i) {
-    mPetalLayers[i].createLayer(motherVolume, mAzimuthalWallCombiTrans);
-  }
-
-  // Add petal disks
-  // diskNumber, diskName, zPos, rIn, rOut, angularCoverage, diskx2X0
-  mPetalDisks.emplace_back(0, Form("%s_DISK%d", mPetalCaseName.Data(), 0), 26., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
-  mPetalDisks.emplace_back(1, Form("%s_DISK%d", mPetalCaseName.Data(), 1), 30., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
-  mPetalDisks.emplace_back(2, Form("%s_DISK%d", mPetalCaseName.Data(), 2), 34., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
-  mPetalDisks.emplace_back(3, Form("%s_DISK%d", mPetalCaseName.Data(), 3), -26., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
-  mPetalDisks.emplace_back(4, Form("%s_DISK%d", mPetalCaseName.Data(), 4), -30., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
-  mPetalDisks.emplace_back(5, Form("%s_DISK%d", mPetalCaseName.Data(), 5), -34., .5, 2.5, mAngularCoverageAzimuthalWall, 1.e-3);
-  for (Int_t i = 0; i < mPetalDisks.size(); ++i) {
-    mPetalDisks[i].createDisk(motherVolume, mAzimuthalWallCombiTrans);
-  }
-
-  addDetectionPetelsToFullComposite();
-}
-
-void TRKPetalCase::addDetectionPetelsToFullComposite()
-{
-  for (Int_t i = 0; i < mPetalLayers.size(); ++i) {
-    Double_t zLength = mPetalLayers[i].getZLength();
-    Double_t rIn = mPetalLayers[i].getInnerRadius();
-    Double_t thickness = mPetalLayers[i].getChipThickness();
-    Double_t angularCoverage = mPetalLayers[i].getAngularCoverage();
-    TGeoTubeSeg* layerForExcavation = new TGeoTubeSeg(Form("PETALCASE%d_EXCAVATIONLAYER%d", mPetalCaseNumber, i), rIn, rIn + thickness, zLength / 2., -0.5 * angularCoverage * mToDeg, 0.5 * angularCoverage * mToDeg);
-
-    TString layerForExcavationCompositeFormula = layerForExcavation->GetName();
-    layerForExcavationCompositeFormula += ":";
-    layerForExcavationCompositeFormula += mAzimuthalWallCombiTrans->GetName();
-    addToPetalCaseComposite(layerForExcavationCompositeFormula);
-  }
-
-  for (Int_t i = 0; i < mPetalDisks.size(); ++i) {
-    Double_t zPos = mPetalDisks[i].getZ();
-    Double_t rIn = mPetalDisks[i].getInnerRadius();
-    Double_t rOut = mPetalDisks[i].getOuterRadius();
-    Double_t thickness = mPetalDisks[i].getThickness();
-    Double_t angularCoverage = mPetalDisks[i].getAngularCoverage();
-    TGeoTubeSeg* diskForExcavation = new TGeoTubeSeg(Form("PETALCASE%d_EXCAVATIONDISK%d", mPetalCaseNumber, i), rIn, rOut, thickness / 2., -0.5 * angularCoverage * mToDeg, 0.5 * angularCoverage * mToDeg);
-    TGeoCombiTrans* diskForExcavationCombiTrans = new TGeoCombiTrans(*(mAzimuthalWallCombiTrans->MakeClone())); // Copy from petal case
-    diskForExcavationCombiTrans->SetName((TString)Form("PETALCASE%d_EXCAVATIONDISK%d_COMBITRANS", mPetalCaseNumber, i));
-    diskForExcavationCombiTrans->SetDz(zPos); // Overwrite z location
-    diskForExcavationCombiTrans->RegisterYourself();
-
-    TString diskForExcavationCompositeFormula = diskForExcavation->GetName();
-    diskForExcavationCompositeFormula += ":";
-    diskForExcavationCompositeFormula += diskForExcavationCombiTrans->GetName();
-    addToPetalCaseComposite(diskForExcavationCompositeFormula);
-  }
-}
-
-// ClassImp(TRKPetalCase);
-} // namespace trk
-} // namespace o2
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalDisk.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalDisk.cxx
deleted file mode 100644
index e24b24b48c882..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalDisk.cxx
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file TRKPetalDisk.cxx
-/// \brief Implementation of the TRKPetalDisk class
-
-#include "TRKSimulation/TRKPetalDisk.h"
-#include "TRKBase/GeometryTGeo.h"
-
-#include <fairlogger/Logger.h> // for LOG
-
-#include "TGeoManager.h"        // for TGeoManager, gGeoManager
-#include "TGeoMatrix.h"         // for TGeoCombiTrans, TGeoRotation, etc
-#include "TGeoTube.h"           // for TGeoTube, TGeoTubeSeg
-#include "TGeoVolume.h"         // for TGeoVolume, TGeoVolumeAssembly
-#include "TGeoCompositeShape.h" // for TGeoCompositeShape
-#include "TMathBase.h"          // for Abs
-#include "TMath.h"              // for Sin, RadToDeg, DegToRad, Cos, Tan, etc
-#include "TGeoTube.h"
-
-#include <cstdio> // for snprintf
-
-namespace o2
-{
-namespace trk
-{
-
-TRKPetalDisk::TRKPetalDisk(Int_t diskNumber, std::string diskName, Float_t z, Float_t rIn, Float_t rOut, Float_t angularCoverage, Float_t Diskx2X0)
-{
-  // Creates a simple parametrized petal disk
-  mDiskNumber = diskNumber;
-  mDiskName = diskName;
-  mZ = z;
-  mAngularCoverage = angularCoverage;
-  mx2X0 = Diskx2X0;
-  mInnerRadius = rIn;
-  mOuterRadius = rOut;
-  Float_t Si_X0 = 9.5;
-  mChipThickness = Diskx2X0 * Si_X0;
-
-  LOG(info) << "Creating TRK Disk " << mDiskNumber;
-  LOG(info) << "   Using silicon X0 = " << Si_X0 << " to emulate disk radiation length.";
-  LOG(info) << "   Disk z = " << mZ << " ; R_in = " << mInnerRadius << " ; R_out = " << mOuterRadius << " ; x2X0 = " << mx2X0 << " ; ChipThickness = " << mChipThickness;
-}
-
-void TRKPetalDisk::createDisk(TGeoVolume* motherVolume, TGeoCombiTrans* combiTrans)
-{
-  // Create tube, set sensitive volume, add to mother volume
-  Double_t toDeg = 180 / TMath::Pi();
-  std::string chipName = mDiskName + "_" + o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mDiskNumber),
-              sensName = mDiskName + "_" + Form("%s%d", GeometryTGeo::getTRKSensorPattern(), mDiskNumber);
-
-  mSensorName = sensName;
-
-  TGeoTubeSeg* sensor = new TGeoTubeSeg(mInnerRadius, mOuterRadius, mChipThickness / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
-  TGeoTubeSeg* chip = new TGeoTubeSeg(mInnerRadius, mOuterRadius, mChipThickness / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
-  TGeoTubeSeg* disk = new TGeoTubeSeg(mInnerRadius, mOuterRadius, mChipThickness / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
-
-  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
-  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
-
-  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
-  sensVol->SetLineColor(kYellow);
-  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
-  chipVol->SetLineColor(kYellow);
-  TGeoVolume* diskVol = new TGeoVolume(mDiskName.c_str(), disk, medAir);
-  diskVol->SetLineColor(kYellow);
-
-  LOG(info) << "Inserting " << sensVol->GetName() << " inside " << chipVol->GetName();
-  chipVol->AddNode(sensVol, 1, nullptr);
-
-  LOG(info) << "Inserting " << chipVol->GetName() << " inside " << diskVol->GetName();
-  diskVol->AddNode(chipVol, 1, nullptr);
-
-  // Finally put everything in the mother volume
-  TGeoCombiTrans* fwdPetalCombiTrans = new TGeoCombiTrans(*(combiTrans->MakeClone())); // Copy from petal case
-  fwdPetalCombiTrans->SetDz(mZ);                                                       // Overwrite z location
-  fwdPetalCombiTrans->RegisterYourself();
-
-  LOG(info) << "Inserting " << diskVol->GetName() << " inside " << motherVolume->GetName();
-  motherVolume->AddNode(diskVol, 1, fwdPetalCombiTrans);
-}
-// ClassImp(TRKPetalLayer);
-
-} // namespace trk
-} // namespace o2
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalLayer.cxx
deleted file mode 100644
index c8ff0d957bb19..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKPetalLayer.cxx
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "TRKSimulation/TRKPetalLayer.h"
-#include "TRKBase/GeometryTGeo.h"
-
-#include "Framework/Logger.h"
-
-#include "TGeoTube.h"
-#include "TGeoBBox.h"
-#include "TGeoVolume.h"
-#include "TGeoTube.h"
-#include "TGeoMatrix.h"
-
-#include "TMath.h"
-
-namespace o2
-{
-namespace trk
-{
-TRKPetalLayer::TRKPetalLayer(Int_t layerNumber, std::string layerName, Float_t rIn, Float_t angularCoverage, Float_t zLength, Float_t layerX2X0)
-  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rIn), mAngularCoverage(angularCoverage), mZ(zLength), mX2X0(layerX2X0), mModuleWidth(4.54)
-{
-  Float_t Si_X0 = 9.5f;
-  mChipThickness = mX2X0 * Si_X0;
-  LOGP(info, "Creating layer: id: {} rInner: {} thickness: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mChipThickness, mZ, mX2X0);
-}
-
-void TRKPetalLayer::createLayer(TGeoVolume* motherVolume, TGeoCombiTrans* combiTrans)
-{
-  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
-  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
-
-  std::string staveName = mLayerName + "_" + o2::trk::GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber),
-              chipName = mLayerName + "_" + o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber),
-              sensName = mLayerName + "_" + Form("%s%d", GeometryTGeo::getTRKSensorPattern(), mLayerNumber);
-
-  mSensorName = sensName;
-
-  Double_t toDeg = 180 / TMath::Pi();
-  mLayer = new TGeoTubeSeg(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
-  TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), mLayer, medAir);
-  layerVol->SetLineColor(kYellow);
-
-  TGeoTubeSeg* stave = new TGeoTubeSeg(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
-  TGeoTubeSeg* chip = new TGeoTubeSeg(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
-  TGeoTubeSeg* sensor = new TGeoTubeSeg(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2., -0.5 * mAngularCoverage * toDeg, 0.5 * mAngularCoverage * toDeg);
-
-  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
-  sensVol->SetLineColor(kYellow);
-  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
-  chipVol->SetLineColor(kYellow);
-  TGeoVolume* staveVol = new TGeoVolume(staveName.c_str(), stave, medSi);
-  staveVol->SetLineColor(kYellow);
-
-  LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-  chipVol->AddNode(sensVol, 1, nullptr);
-
-  LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
-  staveVol->AddNode(chipVol, 1, nullptr);
-
-  LOGP(info, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
-  layerVol->AddNode(staveVol, 1, nullptr);
-
-  LOGP(info, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
-  motherVolume->AddNode(layerVol, 1, combiTrans);
-}
-// ClassImp(TRKPetalLayer);
-
-} // namespace trk
-} // namespace o2
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 1fb966425f974..51eea905c436a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -173,7 +173,9 @@ void TRKServices::registerVacuum(TGeoVolume* motherVolume)
   TGeoVolume* vacuumVolume = new TGeoVolume("A3IP_VACUUM", vacuumComposite, kMedVac);
 
   // Add the vacuum to the barrel
-  vacuumVolume->SetLineColor(kGreen - 3);
+  vacuumVolume->SetLineColor(kAzure + 7);
+  vacuumVolume->SetTransparency(80);
+
   motherVolume->AddNode(vacuumVolume, 1, new TGeoTranslation(0, 0, 0));
 }
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
index d80027593cef0..1a2e93636491c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
@@ -15,10 +15,8 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class o2::trk::TRKPetalCase + ;
 #pragma link C++ class o2::trk::TRKLayer + ;
-#pragma link C++ class o2::trk::TRKPetalLayer + ;
-#pragma link C++ class o2::trk::TRKPetalDisk + ;
+#pragma link C++ class o2::trk::VDLayer + ;
 #pragma link C++ class o2::trk::TRKServices + ;
 #pragma link C++ class o2::trk::Detector + ;
 #pragma link C++ class o2::base::DetImpl < o2::trk::Detector> + ;
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
new file mode 100644
index 0000000000000..54567a50fa4cf
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
@@ -0,0 +1,743 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKSimulation/VDGeometryBuilder.h"
+
+#include <TGeoVolume.h>
+#include <TGeoMatrix.h>
+#include <TGeoTube.h>
+#include <TGeoBBox.h>
+#include <TMath.h>
+#include <TGeoCompositeShape.h>
+#include <TString.h>
+#include <DetectorsBase/MaterialManager.h>
+
+#include "TGeoManager.h"
+
+#include "Framework/Logger.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKSimulation/VDLayer.h"
+#include "TRKSimulation/VDSensorRegistry.h"
+
+namespace o2::trk
+{
+
+static std::vector<VDSensorDesc> gVDSensors; // stays in this TU only
+std::vector<VDSensorDesc>& vdSensorRegistry() { return gVDSensors; }
+
+void clearVDSensorRegistry() { gVDSensors.clear(); }
+
+void registerSensor(const std::string& volName, int petal, VDSensorDesc::Region region, VDSensorDesc::Type type, int idx)
+{
+  gVDSensors.push_back({volName, petal, region, type, idx});
+}
+
+static inline std::string makeSensorName(const std::string& layerName, int layerNumber)
+{
+  return Form("%s_%s%d", layerName.c_str(), o2::trk::GeometryTGeo::getTRKSensorPattern(), layerNumber);
+}
+
+namespace
+{
+
+// Config: which volumes count as SOLIDS to subtract from the vacuum volume
+inline bool isSolidToCut(const TGeoVolume* v)
+{
+  const char* nm = v->GetName();
+  const char* med = v->GetMedium() ? v->GetMedium()->GetName() : "";
+  // silicon sensors (barrel + disks)
+  if (med && strcmp(med, "TRK_SILICON$") == 0)
+    return true;
+  // walls, sidewalls, cold-plate, service rings (names from your builders)
+  if (TString(nm).BeginsWith("VD_InnerWallArc"))
+    return true;
+  if (TString(nm).BeginsWith("VD_OuterWallArc"))
+    return true;
+  if (TString(nm).BeginsWith("VD_SideWall"))
+    return true;
+  if (TString(nm).Contains("_Coldplate"))
+    return true;
+  if (TString(nm).BeginsWith("IRIS_Service_Neg"))
+    return true;
+  if (TString(nm).BeginsWith("IRIS_Service_Pos_InVac"))
+    return true;
+  return false;
+}
+
+// Ensure every leaf shape has a stable, informative name
+inline const char* ensureShapeName(TGeoVolume* v)
+{
+  auto* sh = v->GetShape();
+  TString nm = sh->GetName();
+  if (nm.IsNull() || nm.BeginsWith("TGeo")) {
+    TString wanted = TString(v->GetName()) + "_sh";
+    // avoid collisions
+    int k = 0;
+    TString cand = wanted;
+    auto* shapes = gGeoManager ? gGeoManager->GetListOfShapes() : nullptr;
+    while (shapes && shapes->FindObject(cand))
+      cand = Form("%s_%d", wanted.Data(), ++k);
+    sh->SetName(cand);
+    if (shapes && !shapes->FindObject(cand))
+      shapes->Add(sh);
+  }
+  return sh->GetName();
+}
+
+// Recorder state for the petal-local composite
+static TString gPetalSolidsFormula;
+static int gLocalTrIdx = 0;
+
+// add "ShapeName:IRIS_LOC_TR_k" to the petal-local formula (no outer rotation)
+inline void appendLocalTerm(const char* shapeName, const TGeoHMatrix& H)
+{
+  auto* ct = new TGeoCombiTrans(H);
+  ct->SetName(Form("IRIS_LOC_TR_%d", gLocalTrIdx++));
+  ct->RegisterYourself();
+  if (!gPetalSolidsFormula.IsNull())
+    gPetalSolidsFormula += "+";
+  gPetalSolidsFormula += TString::Format("%s:%s", shapeName, ct->GetName());
+}
+
+// DFS: compose LOCAL transforms only (identity prefix), to capture the petal contents
+void traversePetalLocal(TGeoVolume* vol, const TGeoHMatrix& prefix)
+{
+  auto* nodes = vol->GetNodes();
+  if (!nodes)
+    return;
+  for (int i = 0; i < nodes->GetEntriesFast(); ++i) {
+    auto* node = (TGeoNode*)nodes->At(i);
+    auto* childV = node->GetVolume();
+    TGeoHMatrix H(prefix);
+    if (auto* m = node->GetMatrix())
+      H.Multiply(m);
+
+    if (isSolidToCut(childV)) {
+      const char* shapeName = ensureShapeName(childV);
+      appendLocalTerm(shapeName, H);
+    }
+    traversePetalLocal(childV, H);
+  }
+}
+
+// Build (once) a petal-local composite containing ONLY solids (walls, silicon, coldplate, services, disks)
+inline void buildPetalSolidsComposite(TGeoVolume* petalAsm)
+{
+  // If it already exists, skip
+  if (gGeoManager && gGeoManager->GetListOfShapes() && gGeoManager->GetListOfShapes()->FindObject("IRIS_PETAL_SOLIDSsh"))
+    return;
+
+  gPetalSolidsFormula.Clear();
+  gLocalTrIdx = 0;
+
+  TGeoHMatrix I; // identity
+  traversePetalLocal(petalAsm, I);
+
+  if (gPetalSolidsFormula.IsNull()) {
+    LOGP(error, "IRIS_PETAL_SOLIDSsh formula is empty; did not find solids in petal.");
+    return;
+  }
+
+  LOGP(info, "IRIS_PETAL_SOLIDSsh formula: {}", gPetalSolidsFormula.Data());
+  new TGeoCompositeShape("IRIS_PETAL_SOLIDSsh", gPetalSolidsFormula.Data());
+}
+
+// Build the global cutout by rotating the petal-local composite n times with (p+0.5) phase
+inline void buildIrisCutoutFromPetalSolid(int nPetals)
+{
+  // Create n rotation transforms
+  TString cutFormula;
+  for (int p = 0; p < nPetals; ++p) {
+    const double phi = (360.0 / nPetals) * (p + 0.5);
+    auto* R = new TGeoRotation();
+    R->RotateZ(phi);
+    auto* RT = new TGeoCombiTrans(0, 0, 0, R);
+    RT->SetName(Form("IRIS_PETAL_ROT_%d", p));
+    RT->RegisterYourself();
+    if (p)
+      cutFormula += "+";
+    cutFormula += Form("IRIS_PETAL_SOLIDSsh:%s", RT->GetName());
+  }
+  LOGP(info, "IRIS_CUTOUTsh formula: {}", cutFormula.Data());
+  new TGeoCompositeShape("IRIS_CUTOUTsh", cutFormula.Data());
+
+  // --- Sanity check: required matrices & shapes exist
+  auto* mats = gGeoManager ? gGeoManager->GetListOfMatrices() : nullptr;
+  auto* shps = gGeoManager ? gGeoManager->GetListOfShapes() : nullptr;
+
+  if (!mats || !shps) {
+    LOGP(error, "IRIS cutout sanity: gGeoManager not initialized properly (mats/shapes missing).");
+  } else {
+    bool ok = true;
+
+    // Check the petal rotations were registered and referenced
+    for (int p = 0; p < nPetals; ++p) {
+      const TString name = Form("IRIS_PETAL_ROT_%d", p);
+      if (!mats->FindObject(name)) {
+        LOGP(error, "IRIS cutout sanity: missing matrix {}", name.Data());
+        ok = false;
+      }
+    }
+
+    // Check that the local petal composite exists
+    if (!shps->FindObject("IRIS_PETAL_SOLIDSsh")) {
+      LOGP(error, "IRIS cutout sanity: shape 'IRIS_PETAL_SOLIDSsh' not found.");
+      ok = false;
+    }
+
+    // Check that the global cutout shape was created
+    if (!shps->FindObject("IRIS_CUTOUTsh")) {
+      LOGP(error, "IRIS cutout sanity: shape 'IRIS_CUTOUTsh' not found.");
+      ok = false;
+    }
+
+    if (ok) {
+      LOGP(info, "IRIS cutout sanity: OK ({} petals).", nPetals);
+    }
+  }
+}
+
+} // namespace
+
+// =================== Specs & constants (ROOT units: cm) ===================
+static constexpr double kX2X0 = 0.001f;   // 0.1% X0 per layer
+static constexpr double kLenZ_cm = 50.0f; // L0/L1/L2 Z length
+
+// Radii (cm)
+static constexpr double rL0_cm = 0.5f; // 5 mm
+static constexpr double rL1_cm = 1.2f; // 12 mm
+static constexpr double rL2_cm = 2.5f; // 25 mm
+
+// IRIS5 rectangular L0 width (cm)
+static constexpr double kL0RectHeight_cm = 0.5f; // 5.0 mm
+static constexpr double kL0RectWidth_cm = 0.83f; // 8.3 mm
+
+// Disks radii (cm)
+static constexpr double diskRin_cm = 0.5f;  // 5 mm
+static constexpr double diskRout_cm = 2.5f; // 25 mm
+static const double diskZ_cm[6] = {-34.0f, -30.0f, -26.0f, 26.0f, 30.0f, 34.0f};
+
+// Petal walls specifications (cm)
+static constexpr double kPetalZ_cm = 70.0f;          // full wall height
+static constexpr double kWallThick_cm = 0.015f;      // 0.15 mm
+static constexpr double kInnerWallRadius_cm = 0.48f; // 4.8 mm (ALWAYS cylindrical)
+static constexpr double kOuterWallRadius_cm = 3.0f;  // 30 mm (can be changed)
+static constexpr double kEps_cm = 1.e-4f;
+
+// Coldplate specs (cm)
+static constexpr double kColdplateRadius_cm = 2.6f;     // 26 mm (outer radius)
+static constexpr double kColdplateThickness_cm = 0.15f; // 1.5 mm
+static constexpr double kColdplateZ_cm = 50.0f;         // full length
+
+// ========== φ-span helpers (gap/arc → degrees) ==========
+namespace
+{
+
+// Convert a linear gap at radius R into an angular gap (deg)
+inline double degFromArc(double arc, double radius)
+{
+  // arc and radius in the SAME units (cm or mm); result in degrees
+  return (radius > 0.f) ? (arc / radius) * TMath::RadToDeg() : 0.f;
+}
+
+/**
+ * Compute silicon segment φ-span (degrees) inside one petal,
+ * when you know the number of petals and the linear gap at a given radius.
+ *
+ * All of: gap and radius must be in the SAME units (cm or mm).
+ * If you use cm everywhere (ROOT default), pass gap_cm and radius_cm.
+ */
+inline double phiSpanFromGap(int nPetals, double gap, double radius)
+{
+  if (nPetals <= 0 || radius <= 0.f)
+    return 0.f;
+  const double petalPhiDeg = 360.f / nPetals;
+  const double phi = petalPhiDeg - degFromArc(gap, radius);
+  return phi > 0.f ? phi : 0.f;
+}
+
+/**
+ * Compute silicon segment φ-span (degrees) from a known arc length at a given radius.
+ * arcLen and radius must be in the SAME units (cm or mm).
+ */
+inline double phiSpanFromArc(double arcLen, double radius)
+{
+  return (arcLen > 0.f && radius > 0.f) ? degFromArc(arcLen, radius) : 0.f;
+}
+
+inline TGeoCombiTrans rotZ(double phiDeg)
+{
+  auto* r = new TGeoRotation();
+  r->RotateZ(static_cast<Double_t>(phiDeg));
+  return TGeoCombiTrans(0., 0., 0., r);
+}
+} // namespace
+
+// ============ Petal sub-builders (LOCAL coords only, no rotation) =========
+
+// Walls: inner cylindrical arc at r=4.8 mm (always), outer arc wall, and two side plates.
+static void addPetalWalls(TGeoVolume* petalAsm, int nPetals, double outerRadius_cm = kOuterWallRadius_cm)
+{
+  if (!petalAsm) {
+    LOGP(error, "addPetalWalls: petalAsm is null");
+    return;
+  }
+
+  auto& matmgr = o2::base::MaterialManager::Instance();
+  const TGeoMedium* med = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_ALUMINIUM5083");
+
+  if (!med) {
+    LOGP(warning, "Petal walls: ALICE3_TRKSERVICES_ALUMINIUM5083$ not found, walls not created.");
+    return;
+  }
+
+  const double halfPhi = 0.5f * (360.f / static_cast<double>(nPetals));
+  const double halfZ = 0.5f * kPetalZ_cm;
+
+  // ---- Inner cylindrical wall (always at r=4.8 mm) ----
+  {
+    auto* s = new TGeoTubeSeg(static_cast<Double_t>(kInnerWallRadius_cm),
+                              static_cast<Double_t>(kInnerWallRadius_cm + kWallThick_cm),
+                              static_cast<Double_t>(halfZ),
+                              static_cast<Double_t>(-halfPhi),
+                              static_cast<Double_t>(+halfPhi));
+    auto* v = new TGeoVolume("VD_InnerWallArc", s, med);
+    v->SetLineColor(kGray + 2);
+    v->SetTransparency(70);
+    petalAsm->AddNode(v, 1);
+  }
+
+  // ---- Outer arc wall ----
+  {
+    auto* s = new TGeoTubeSeg(static_cast<Double_t>(outerRadius_cm),
+                              static_cast<Double_t>(outerRadius_cm + kWallThick_cm),
+                              static_cast<Double_t>(halfZ),
+                              static_cast<Double_t>(-halfPhi),
+                              static_cast<Double_t>(+halfPhi));
+    auto* v = new TGeoVolume("VD_OuterWallArc", s, med);
+    v->SetLineColor(kGray + 2);
+    v->SetTransparency(70);
+    petalAsm->AddNode(v, 1);
+  }
+
+  // ---- Side walls (boxes) at ±halfPhi ----
+  const double radialLen = (outerRadius_cm - (kInnerWallRadius_cm + kWallThick_cm));
+  auto* sideS = new TGeoBBox(static_cast<Double_t>(0.5f * radialLen),
+                             static_cast<Double_t>(0.5f * kWallThick_cm),
+                             static_cast<Double_t>(halfZ));
+  auto* sideV = new TGeoVolume("VD_SideWall", sideS, med);
+  sideV->SetLineColor(kGray + 2);
+  sideV->SetTransparency(70);
+
+  for (int sgn : {-1, +1}) {
+    const double phi = sgn * halfPhi;
+    const double rMid = kInnerWallRadius_cm + kWallThick_cm + 0.5f * radialLen;
+    const double rad = static_cast<double>(TMath::DegToRad());
+    const double x = rMid * std::cos(phi * rad);
+    const double y = rMid * std::sin(phi * rad);
+    auto* rot = new TGeoRotation();
+    rot->RotateZ(static_cast<Double_t>(phi));
+    auto* tr = new TGeoCombiTrans(static_cast<Double_t>(x),
+                                  static_cast<Double_t>(y),
+                                  0.0, rot);
+    petalAsm->AddNode(sideV, (sgn < 0 ? 1 : 2), tr);
+  }
+}
+
+// Build inner layers (L0..L2). L0 may be rectangular (IRIS5) or cylindrical.
+// φ-spans derive from spec gaps/arc; all local placement (no rotation).
+static void addBarrelLayers(TGeoVolume* petalAsm, int nPetals, int petalID, bool rectangularL0)
+{
+  if (!petalAsm) {
+    LOGP(error, "addBarrelLayers: petalAsm is null");
+    return;
+  }
+
+  // Per spec (mm → cm)
+  constexpr double gapL0_cm = 0.163f;  // 1.63 mm
+  constexpr double gapL1L2_cm = 0.12f; // 1.2 mm
+  constexpr double arcL0_cm = 0.6247f; // 6.247 mm
+
+  // φ spans
+  const double phiL0_deg = phiSpanFromGap(nPetals, gapL0_cm, rL0_cm);   // L0 gap-defined
+  const double phiL1_deg = phiSpanFromGap(nPetals, gapL1L2_cm, rL1_cm); // L1 gap-defined
+  const double phiL2_deg = phiSpanFromGap(nPetals, gapL1L2_cm, rL2_cm); // L2 gap-defined
+
+  const std::string nameL0 =
+    std::string(o2::trk::GeometryTGeo::getTRKPetalPattern()) + std::to_string(petalID) + "_" +
+    std::string(o2::trk::GeometryTGeo::getTRKPetalLayerPattern()) + "0";
+
+  if (rectangularL0) {
+    VDRectangularLayer L0(0,
+                          nameL0,
+                          kX2X0, kL0RectWidth_cm, kLenZ_cm, kLenZ_cm);
+
+    // Correct translation: move to radius + half width along x
+    double x = kL0RectHeight_cm + L0.getChipThickness() / 2.;
+    LOGP(info, "Placing rectangular L0 at r={:.3f} cm (half-width={:.3f} cm)", x, 0.5f * kL0RectWidth_cm);
+    double y = 0.0;
+    double z = 0.0;
+
+    // Correct rotation: rotate 90 degrees around z so long side is horizontal
+    auto* rot = new TGeoRotation();
+    rot->RotateZ(90.0);
+
+    auto* tr = new TGeoCombiTrans(x, y, z, rot);
+    L0.createLayer(petalAsm, tr);
+    registerSensor(makeSensorName(nameL0, 0), petalID, VDSensorDesc::Region::Barrel, VDSensorDesc::Type::Plane, /*idx*/ 0);
+  } else {
+    VDCylindricalLayer L0(0,
+                          nameL0,
+                          kX2X0, rL0_cm, phiL0_deg, kLenZ_cm, kLenZ_cm);
+    L0.createLayer(petalAsm, nullptr);
+    registerSensor(makeSensorName(nameL0, 0), petalID, VDSensorDesc::Region::Barrel, VDSensorDesc::Type::Curved, /*idx*/ 0);
+  }
+
+  const std::string nameL1 =
+    std::string(o2::trk::GeometryTGeo::getTRKPetalPattern()) + std::to_string(petalID) + "_" +
+    std::string(o2::trk::GeometryTGeo::getTRKPetalLayerPattern()) + "1";
+
+  VDCylindricalLayer L1(1,
+                        nameL1,
+                        kX2X0, rL1_cm, phiL1_deg, kLenZ_cm, kLenZ_cm);
+  L1.createLayer(petalAsm, nullptr);
+  registerSensor(makeSensorName(nameL1, 1), petalID, VDSensorDesc::Region::Barrel, VDSensorDesc::Type::Curved, /*idx*/ 1);
+
+  const std::string nameL2 =
+    std::string(o2::trk::GeometryTGeo::getTRKPetalPattern()) + std::to_string(petalID) + "_" +
+    std::string(o2::trk::GeometryTGeo::getTRKPetalLayerPattern()) + "2";
+
+  VDCylindricalLayer L2(2,
+                        nameL2,
+                        kX2X0, rL2_cm, phiL2_deg, kLenZ_cm, kLenZ_cm);
+  L2.createLayer(petalAsm, nullptr);
+  registerSensor(makeSensorName(nameL2, 2), petalID, VDSensorDesc::Region::Barrel, VDSensorDesc::Type::Curved, /*idx*/ 2);
+}
+
+// Build cold plate (cylindrical) in local coordinates, and add it to the petal assembly.
+static void addColdPlate(TGeoVolume* petalAsm, int nPetals, int petalId)
+{
+  if (!petalAsm) {
+    LOGP(error, "addColdPlate: petalAsm is null");
+    return;
+  }
+
+  // Resolve medium: prefer provided medium, otherwise try to fetch from geo manager
+  const TGeoMedium* med = gGeoManager->GetMedium("ALICE3_TRKSERVICES_CERAMIC");
+  if (!med) {
+    LOGP(error, "addColdPlate: can't find the medium.");
+  }
+
+  // Angular span for one petal (deg)
+  constexpr double gapL1L2_cm = 0.12f; // 1.2 mm
+
+  // φ spans
+  const double phiSpanColdplate_deg = phiSpanFromGap(nPetals, gapL1L2_cm, rL2_cm); // L2 gap-defined
+  const double halfPhiDeg = 0.5f * phiSpanColdplate_deg;
+  const double startPhi = -halfPhiDeg;
+  const double endPhi = +halfPhiDeg;
+
+  // Build tube segment: inner radius, outer radius = inner + thickness, half-length Z
+  auto* shape = new TGeoTubeSeg(static_cast<Double_t>(kColdplateRadius_cm),
+                                static_cast<Double_t>(kColdplateRadius_cm + kColdplateThickness_cm),
+                                static_cast<Double_t>(0.5 * kColdplateZ_cm),
+                                static_cast<Double_t>(startPhi),
+                                static_cast<Double_t>(endPhi));
+
+  TString volName = TString::Format("Petal%d_Coldplate", petalId);
+  auto* coldVol = new TGeoVolume(volName, shape, med);
+  coldVol->SetLineColor(kAzure - 3);
+  coldVol->SetTransparency(10);
+
+  // Place in local petal coordinates (no extra transform); keep object alive by allocating shape/volume on heap.
+  petalAsm->AddNode(coldVol, 1);
+
+  LOGP(info, "Adding cold plate {} r={:.3f} cm t={:.3f} cm Lz={:.3f} cm φ=[{:.3f}, {:.3f}]",
+       volName.Data(), kColdplateRadius_cm, kColdplateThickness_cm, kColdplateZ_cm, startPhi, endPhi);
+}
+
+// Add IRIS service module(s) as aluminum annular cylinders placed outside the petals.
+// The two modules are placed at z = ±(36 + halfLength).
+static void addIRISServiceModules(TGeoVolume* petalAsm, int nPetals)
+{
+  if (!petalAsm) {
+    LOGP(error, "addIRISServiceModules: petalAsm is null");
+    return;
+  }
+
+  auto* matAl = new TGeoMaterial("ALUMINUM", 26.9815, 13, 2.70);
+  const TGeoMedium* med = new TGeoMedium("ALUMINUM", 4, matAl);
+
+  if (!med) {
+    LOGP(error, "addIRISServiceModules: ALUMINUM medium not found.");
+    return;
+  }
+
+  constexpr double radius = 3.2;      // cm (inner radius)
+  constexpr double thickness = 0.133; // cm (radial thickness)
+  constexpr double halfLength = 19.5; // cm (half-length along Z)
+  const double rIn = radius;
+  const double rOut = radius + thickness;
+
+  // Petal angular span. If you have an exact half-φ from your walls, use it here.
+  const double halfPhi_deg = 0.5 * (360.0 / double(nPetals));
+
+  // Create shape once and reuse
+  auto* segSh = new TGeoTubeSeg(
+    "IRIS_SERVICE_SEGsh",
+    rIn, rOut,
+    halfLength,
+    -halfPhi_deg, halfPhi_deg);
+
+  // Positive Z module
+  TString namePos = "IRIS_Service_Pos";
+  auto* volPos = new TGeoVolume(namePos, segSh, med);
+  volPos->SetLineColor(kRed + 2);
+  volPos->SetTransparency(50);
+
+  // Negative Z module: reuse same shape object, give different name
+  TString nameNeg = "IRIS_Service_Neg";
+  auto* volNeg = new TGeoVolume(nameNeg, segSh, med);
+  volNeg->SetLineColor(kRed + 2);
+  volNeg->SetTransparency(50);
+
+  // Translations (heap-allocated so ROOT keeps them)
+  const double zpos = 36.0 + halfLength;
+  auto* transPos = new TGeoTranslation(0.0, 0.0, static_cast<Double_t>(zpos));
+  auto* transNeg = new TGeoTranslation(0.0, 0.0, static_cast<Double_t>(-zpos));
+
+  // Add to mother volume
+  petalAsm->AddNode(volPos, 1, transPos);
+  petalAsm->AddNode(volNeg, 2, transNeg);
+
+  LOGP(info, "Added IRIS service modules at z = ±{} cm, r=[{}, {}] cm", zpos, rIn, rOut);
+}
+
+//     Only the A-side "inside vacuum" piece participates in the cutout.
+static void addIRISServiceModulesSegmented(TGeoVolume* petalAsm, int nPetals)
+{
+  if (!petalAsm) {
+    LOGP(error, "addIRISServiceModulesSegmented: petalAsm is null");
+    return;
+  }
+
+  // --- Service geometry (same as your previous values)
+  constexpr double rIn = 3.2;         // cm
+  constexpr double thickness = 0.133; // cm
+  constexpr double rOut = rIn + thickness;
+  constexpr double halfLen = 19.5;      // cm
+  constexpr double z0 = 36.0 + halfLen; // 55.5 cm center of +Z service
+  const double zMinA = z0 - halfLen;    // 36.0 cm
+  const double zMaxA = z0 + halfLen;    // 75.0 cm
+
+  // --- Vacuum vessel window around z∈[-L/2, +L/2] with wall thickness on +Z side
+  //     Keep these in sync with TRKServices::createVacuumCompositeShape()
+  constexpr double vacuumVesselLength = 76.0;             // cm
+  constexpr double vacuumVesselThickness = 0.08;          // cm (0.8 mm)
+  const double halfVess = 0.5 * vacuumVesselLength;       // 38.0 cm
+  const double gapStart = halfVess;                       // 38.00
+  const double gapEnd = halfVess + vacuumVesselThickness; // 38.08
+
+  // --- Petal φ-span (segment)
+  const double halfPhi = 0.5 * (360.0 / double(nPetals));
+
+  auto* matAl = new TGeoMaterial("ALUMINUM", 26.9815, 13, 2.70);
+  const TGeoMedium* med = new TGeoMedium("ALUMINUM", 4, matAl);
+
+  if (!med) {
+    LOGP(error, "addIRISServiceModules: ALUMINUM medium not found.");
+    return;
+  }
+
+  // =========================
+  // C-side (negative Z) whole
+  // =========================
+  {
+    auto* sh = new TGeoTubeSeg(rIn, rOut, halfLen, -halfPhi, +halfPhi);
+    auto* vN = new TGeoVolume("IRIS_Service_Neg", sh, med);
+    vN->SetLineColor(kRed + 2);
+    vN->SetTransparency(55);
+    petalAsm->AddNode(vN, 1, new TGeoTranslation(0., 0., -(z0)));
+  }
+
+  // =====================================
+  // A-side (positive Z): split with a gap
+  // =====================================
+  // Piece 1 (INSIDE vacuum): z ∈ [zMinA, min(zMaxA, gapStart)]  → goes into cutout
+  const double L_inVac = std::max(0.0, std::min(zMaxA, gapStart) - zMinA); // expected ~2.0 cm
+  if (L_inVac > 0) {
+    const double dz = 0.5 * L_inVac;
+    const double zc = zMinA + dz; // center of lower slice, ≈ 37.0 cm
+    auto* sh = new TGeoTubeSeg(rIn, rOut, dz, -halfPhi, halfPhi);
+    sh->SetName("IRIS_SERVICE_POS_INVACsh");
+    auto* vP = new TGeoVolume("IRIS_Service_Pos_InVac", sh, med);
+    vP->SetLineColor(kRed + 2);
+    vP->SetTransparency(55);
+    petalAsm->AddNode(vP, 1, new TGeoTranslation(0., 0., zc));
+    LOGP(info, "IRIS A-side (InVac): z=[{:.3f},{:.3f}] cm, len={:.3f} cm",
+         zc - dz, zc + dz, 2 * dz);
+  } else {
+    LOGP(warning, "IRIS A-side (InVac): no overlap with vacuum (L_inVac<=0)");
+  }
+
+  // Gap (no material): (gapStart, gapEnd) = (38.00, 38.08)
+
+  // Piece 2 (OUT of vacuum): z ∈ [max(zMinA, gapEnd), zMaxA]  → NOT in cutout
+  const double L_outVac = std::max(0.0, zMaxA - std::max(zMinA, gapEnd)); // expected ~36.92 cm
+  if (L_outVac > 0) {
+    const double dz = 0.5 * L_outVac;
+    const double zc = std::max(zMinA, gapEnd) + dz; // center of upper slice
+    auto* sh = new TGeoTubeSeg(rIn, rOut, dz, -halfPhi, +halfPhi);
+    sh->SetName("IRIS_SERVICE_POS_OUTVACsh");
+    auto* vP = new TGeoVolume("IRIS_Service_Pos_OutVac", sh, med);
+    vP->SetLineColor(kRed + 1);
+    vP->SetTransparency(70);
+    petalAsm->AddNode(vP, 2, new TGeoTranslation(0., 0., +zc));
+    LOGP(info, "IRIS A-side (OutVac): z=[{:.3f},{:.3f}] cm, len={:.3f} cm",
+         zc - dz, zc + dz, 2 * dz);
+  } else {
+    LOGP(warning, "IRIS A-side (OutVac): no upper piece (L_outVac<=0)");
+  }
+}
+
+// Build disks in local coords: each disk gets only a local Z translation.
+// φ span from gap at rOut.
+static void addDisks(TGeoVolume* petalAsm, int nPetals, int petalID)
+{
+
+  if (!petalAsm) {
+    LOGP(error, "addDisks: petalAsm is null");
+    return;
+  }
+
+  const double phiDisk_deg = phiSpanFromGap(nPetals, 2 * kWallThick_cm, diskRin_cm);
+
+  for (int i = 0; i < 6; ++i) {
+    const std::string nameD =
+      std::string(o2::trk::GeometryTGeo::getTRKPetalPattern()) + std::to_string(petalID) + "_" +
+      std::string(o2::trk::GeometryTGeo::getTRKPetalDiskPattern()) + std::to_string(i);
+
+    VDDiskLayer disk(i,
+                     nameD,
+                     kX2X0, diskRin_cm, diskRout_cm, phiDisk_deg, diskZ_cm[i]);
+
+    // Local Z placement only
+    auto* tr = new TGeoTranslation(0.0, 0.0, static_cast<Double_t>(disk.getZPosition()));
+    disk.createLayer(petalAsm, tr);
+    registerSensor(makeSensorName(nameD, i), petalID, VDSensorDesc::Region::Disk, VDSensorDesc::Type::Plane, /*idx*/ i);
+  }
+}
+
+// Build one complete petal assembly (walls + L0..L2 + disks) in LOCAL coords.
+static TGeoVolume* buildPetalAssembly(int nPetals, int petalID, bool rectangularL0)
+{
+  auto* petalAsm = new TGeoVolumeAssembly(Form("PETAL_%d", petalID));
+  addPetalWalls(petalAsm, nPetals, kOuterWallRadius_cm);
+
+  // Pass petalID to layers/disks for naming
+  addBarrelLayers(petalAsm, nPetals, petalID, rectangularL0);
+  addColdPlate(petalAsm, nPetals, petalID);
+  addDisks(petalAsm, nPetals, petalID);
+  addIRISServiceModulesSegmented(petalAsm, nPetals);
+
+  return petalAsm;
+}
+
+// =================== Public entry points ===================
+
+void createIRIS4Geometry(TGeoVolume* motherVolume)
+{
+  if (!motherVolume) {
+    LOGP(error, "createIRIS4Geometry: motherVolume is null");
+    return;
+  }
+
+  clearVDSensorRegistry();
+
+  constexpr int nPetals = 4;
+  for (int p = 0; p < nPetals; ++p) {
+    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ false);
+    // Build the petal-local solids composite once from the FIRST petal
+    if (p == 0) {
+      buildPetalSolidsComposite(petal); // <-- captures only SOLIDS in local coords
+    }
+    const double phiDeg = (360.0 / double(nPetals)) * (double(p) + 0.5);
+    auto* R = new TGeoRotation();
+    R->RotateZ(phiDeg);
+    auto* T = new TGeoCombiTrans(0, 0, 0, R);
+    motherVolume->AddNode(petal, p + 1, T);
+  }
+  buildIrisCutoutFromPetalSolid(nPetals);
+}
+
+void createIRIS5Geometry(TGeoVolume* motherVolume)
+{
+  if (!motherVolume) {
+    LOGP(error, "createIRIS5Geometry: motherVolume is null");
+    return;
+  }
+
+  clearVDSensorRegistry();
+
+  constexpr int nPetals = 4;
+  for (int p = 0; p < nPetals; ++p) {
+    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ true);
+    // Build the petal-local solids composite once from the FIRST petal
+    if (p == 0) {
+      buildPetalSolidsComposite(petal); // <-- captures only SOLIDS in local coords
+    }
+    const double phiDeg = (360.0 / double(nPetals)) * (double(p) + 0.5);
+    auto* R = new TGeoRotation();
+    R->RotateZ(phiDeg);
+    auto* T = new TGeoCombiTrans(0, 0, 0, R);
+    motherVolume->AddNode(petal, p + 1, T);
+  }
+  buildIrisCutoutFromPetalSolid(nPetals);
+}
+
+void createIRIS4aGeometry(TGeoVolume* motherVolume)
+{
+  if (!motherVolume) {
+    LOGP(error, "createIRIS4aGeometry: motherVolume is null");
+    return;
+  }
+
+  clearVDSensorRegistry();
+
+  constexpr int nPetals = 3;
+  for (int p = 0; p < nPetals; ++p) {
+    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ false);
+    // Build the petal-local solids composite once from the FIRST petal
+    if (p == 0) {
+      buildPetalSolidsComposite(petal); // <-- captures only SOLIDS in local coords
+    }
+    const double phiDeg = (360.0 / double(nPetals)) * (double(p) + 0.5);
+    auto* R = new TGeoRotation();
+    R->RotateZ(phiDeg);
+    auto* T = new TGeoCombiTrans(0, 0, 0, R);
+    motherVolume->AddNode(petal, p + 1, T);
+  }
+  buildIrisCutoutFromPetalSolid(nPetals);
+}
+
+void createSinglePetalDebug(TGeoVolume* motherVolume, int petalID, int nPetals, bool rectangularL0)
+{
+  auto* petal = buildPetalAssembly(nPetals, petalID, rectangularL0);
+
+  // Optionally rotate the petal for display
+  const double phiDeg = (360.f / static_cast<double>(nPetals)) * (static_cast<double>(petalID) + 0.5f);
+  auto* R = new TGeoCombiTrans(0, 0, 0, new TGeoRotation("", phiDeg, 0, 0));
+  motherVolume->AddNode(petal, 1, R);
+
+  LOGP(info, "Debug: Added Petal{} to {}", petalID, motherVolume->GetName());
+}
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
new file mode 100644
index 0000000000000..b762ba5c9b36a
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
@@ -0,0 +1,314 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKSimulation/VDLayer.h"
+#include "TRKBase/GeometryTGeo.h"
+
+#include "Framework/Logger.h"
+
+#include "TGeoTube.h"
+#include "TGeoBBox.h"
+#include "TGeoVolume.h"
+#include "TGeoMatrix.h"
+#include "TGeoManager.h"
+
+#include "TMath.h"
+
+namespace o2
+{
+namespace trk
+{
+// Base layer constructor
+VDLayer::VDLayer(int layerNumber, const std::string& layerName, double layerX2X0)
+  : mLayerNumber(layerNumber), mLayerName(layerName), mX2X0(layerX2X0), mModuleWidth(4.54)
+{
+  constexpr double kSiX0_cm = 9.5; // Radiation length of Silicon in cm
+  mChipThickness = mX2X0 * kSiX0_cm;
+}
+
+// VDCylindricalLayer constructor
+VDCylindricalLayer::VDCylindricalLayer(int layerNumber, const std::string& layerName, double layerX2X0, double radius,
+                                       double phiSpanDeg, double lengthZ, double lengthSensZ)
+  : VDLayer(layerNumber, layerName, layerX2X0), mRadius(radius), mPhiSpanDeg(phiSpanDeg), mLengthZ(lengthZ), mLengthSensZ(lengthSensZ)
+{
+  LOGP(info, "Creating VD cylindrical layer: id: {} name: {} x2X0: {} radius: {} phiSpanDeg: {} lengthZ: {} lengthSensZ: {} chipThickness = {} cm",
+       mLayerNumber, layerName, mX2X0, radius, phiSpanDeg, lengthZ, lengthSensZ, mChipThickness);
+}
+
+// VDRectangularLayer constructor
+VDRectangularLayer::VDRectangularLayer(int layerNumber, const std::string& layerName, double layerX2X0,
+                                       double width, double lengthZ, double lengthSensZ)
+  : VDLayer(layerNumber, layerName, layerX2X0), mWidth(width), mLengthZ(lengthZ), mLengthSensZ(lengthSensZ)
+{
+
+  if (mLengthSensZ <= 0 || mLengthSensZ > mLengthZ) {
+    LOGP(fatal, "Invalid sensor length: sensZ={} layerZ={}", mLengthSensZ, mLengthZ);
+  }
+  LOGP(info, "Creating VD rectangular layer: id: {} name: {} x2X0: {} width: {} lengthZ: {} lengthSensZ: {} chipThickness = {} cm",
+       mLayerNumber, layerName, mX2X0, width, lengthZ, lengthSensZ, mChipThickness);
+}
+
+// VDDiskLayer constructor
+VDDiskLayer::VDDiskLayer(int layerNumber, const std::string& layerName, double layerX2X0, double rMin, double rMax,
+                         double phiSpanDeg, double zPos)
+  : VDLayer(layerNumber, layerName, layerX2X0), mRMin(rMin), mRMax(rMax), mPhiSpanDeg(phiSpanDeg), mZPos(zPos)
+{
+
+  LOGP(info, "Creating VD disk layer: id: {} name: {} x2X0: {} rMin: {} rMax: {} phiSpanDeg: {} zPos: {} chipThickness = {} cm",
+       mLayerNumber, layerName, mX2X0, rMin, rMax, phiSpanDeg, zPos, mChipThickness);
+}
+
+/*
+** Create sensor
+*/
+
+TGeoVolume* VDCylindricalLayer::createSensor() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  auto* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+  std::string sensName = Form("%s_%s%d", this->mLayerName.c_str(), GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
+  const double rIn = mRadius;
+  const double rOut = mRadius + mChipThickness;
+  const double halfZ = 0.5 * mLengthSensZ;
+  const double halfPhi = 0.5 * mPhiSpanDeg; // degrees
+  auto* shape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  auto* vol = new TGeoVolume(sensName.c_str(), shape, medSi);
+  vol->SetLineColor(kYellow);
+  vol->SetTransparency(30);
+  return vol;
+}
+
+TGeoVolume* VDRectangularLayer::createSensor() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  auto* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+  std::string sensName = Form("%s_%s%d", this->mLayerName.c_str(), GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
+  const double hx = 0.5 * mWidth;
+  const double hy = 0.5 * mChipThickness; // thickness in Y
+  const double hz = 0.5 * mLengthSensZ;   // <-- use sensor Z length, not full layer
+
+  auto* shape = new TGeoBBox(hx, hy, hz);
+  auto* vol = new TGeoVolume(sensName.c_str(), shape, medSi);
+  vol->SetLineColor(kYellow);
+  vol->SetTransparency(30);
+
+  return vol;
+}
+
+TGeoVolume* VDDiskLayer::createSensor() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+  if (mRMin < 0 || mRMax <= mRMin || mChipThickness <= 0 || mPhiSpanDeg <= 0 || mPhiSpanDeg > 360.0) {
+    LOGP(error, "Invalid disk sensor dims: rMin={}, rMax={}, t={}, phiSpanDeg={}",
+         mRMin, mRMax, mChipThickness, mPhiSpanDeg);
+    return nullptr;
+  }
+  std::string sensName = Form("%s_%s%d", this->mLayerName.c_str(), GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
+  const double halfThickness = 0.5 * mChipThickness; // disk thickness is along Z
+  const double halfPhi = 0.5 * mPhiSpanDeg;          // degrees
+
+  // Same geometry as the layer (identical radii + phi span + thickness)
+  auto* shape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+
+  auto* sensVol = new TGeoVolume(sensName.c_str(), shape, medSi);
+  sensVol->SetLineColor(kYellow);
+  sensVol->SetTransparency(30);
+
+  return sensVol;
+}
+
+/*
+** Create layer
+*/
+
+// Cylindrical layer
+void VDCylindricalLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans) const
+{
+  if (!motherVolume || !gGeoManager) {
+    LOGP(error, "Null motherVolume or gGeoManager");
+    return;
+  }
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  if (!medAir) {
+    LOGP(error, "Missing TRK_AIR$");
+    return;
+  }
+
+  // Sanity
+  if (mRadius <= 0 || mChipThickness <= 0 || mLengthZ <= 0 ||
+      mPhiSpanDeg <= 0 || mPhiSpanDeg > 360.0 ||
+      mLengthSensZ <= 0 || mLengthSensZ > mLengthZ) {
+    LOGP(error, "Invalid cylindrical dimensions: r={}, t={}, Z={}, phi={}, sensZ={}",
+         mRadius, mChipThickness, mLengthZ, mPhiSpanDeg, mLengthSensZ);
+    return;
+  }
+
+  // AIR container (layer)
+  const double rIn = mRadius;
+  const double rOut = mRadius + mChipThickness;
+  const double halfZ = 0.5 * mLengthZ;
+  const double halfPhi = 0.5 * mPhiSpanDeg; // degrees
+
+  auto* layerShape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  auto* layerVol = new TGeoVolume(mLayerName.c_str(), layerShape, medAir);
+  layerVol->SetLineColor(kYellow);
+  layerVol->SetTransparency(30);
+
+  // Sensor volume (must use mLengthSensZ internally)
+  TGeoVolume* sensorVol = VDCylindricalLayer::createSensor();
+  if (!sensorVol) {
+    LOGP(error, "VDCylindricalLayer::createSensor() returned null");
+    return;
+  }
+  LOGP(info, "Inserting {} in {} ", sensorVol->GetName(), layerVol->GetName());
+  layerVol->AddNode(sensorVol, 1, nullptr);
+
+  // Tiling: edge-to-edge if sensor shorter than layer; else single centered
+  // const auto zCenters = (mLengthSensZ < mLengthZ)
+  // ? centersNoGapZ(mLengthZ, mLengthSensZ)
+  // : std::vector<double>{0.0};
+  //
+  // int copyNo = 1;
+  // for (double zc : zCenters) {
+  // TGeoTranslation tz(0.0, 0.0, zc);
+  // layerVol->AddNode(sensorVol, copyNo++, (zc == 0.0 && zCenters.size() == 1) ? nullptr : &tz);
+  // }
+
+  motherVolume->AddNode(layerVol, 1, combiTrans);
+}
+
+// Rectangular layer
+void VDRectangularLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans) const
+{
+  if (!motherVolume || !gGeoManager) {
+    LOGP(error, "Null motherVolume or gGeoManager");
+    return;
+  }
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  if (!medAir) {
+    LOGP(error, "Missing TRK_AIR$");
+    return;
+  }
+
+  if (mWidth <= 0 || mChipThickness <= 0 || mLengthZ <= 0 ||
+      mLengthSensZ <= 0 || mLengthSensZ > mLengthZ) {
+    LOGP(error, "Invalid rectangular dims: W={}, t={}, Z={}, sensZ={}",
+         mWidth, mChipThickness, mLengthZ, mLengthSensZ);
+    return;
+  }
+
+  // AIR container (layer)
+  const double hx = 0.5 * mWidth;
+  const double hy = 0.5 * mChipThickness;
+  const double hz = 0.5 * mLengthZ;
+
+  auto* layerShape = new TGeoBBox(hx, hy, hz);
+  auto* layerVol = new TGeoVolume(mLayerName.c_str(), layerShape, medAir);
+  layerVol->SetLineColor(kYellow);
+  layerVol->SetTransparency(30);
+
+  // Sensor volume (uses mLengthSensZ internally)
+  TGeoVolume* sensorVol = VDRectangularLayer::createSensor();
+  if (!sensorVol) {
+    LOGP(error, "VDRectangularLayer::createSensor() returned null");
+    return;
+  }
+
+  LOGP(info, "Inserting {} in {} ", sensorVol->GetName(), layerVol->GetName());
+  layerVol->AddNode(sensorVol, 1, nullptr);
+
+  // Tiling along Z, edge - to - edge if needed
+  // const auto zCenters = (mLengthSensZ < mLengthZ)
+  // ? centersNoGapZ(mLengthZ, mLengthSensZ)
+  // : std::vector<double>{0.0};
+  //
+  // int copyNo = 1;
+  // for (double zc : zCenters) {
+  // TGeoTranslation tz(0.0, 0.0, zc);
+  // layerVol->AddNode(sensorVol, copyNo++, (zc == 0.0 && zCenters.size() == 1) ? nullptr : &tz);
+  // }
+
+  motherVolume->AddNode(layerVol, 1, combiTrans);
+}
+
+// Disk layer
+void VDDiskLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans) const
+{
+  if (!motherVolume || !gGeoManager) {
+    LOGP(error, "Null motherVolume or gGeoManager");
+    return;
+  }
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  if (!medAir) {
+    LOGP(error, "Missing TRK_AIR$");
+    return;
+  }
+
+  if (mRMin < 0 || mRMax <= mRMin || mChipThickness <= 0 ||
+      mPhiSpanDeg <= 0 || mPhiSpanDeg > 360.0) {
+    LOGP(error, "Invalid disk dims: rMin={}, rMax={}, t={}, phi={}",
+         mRMin, mRMax, mChipThickness, mPhiSpanDeg);
+    return;
+  }
+
+  // For disks the thickness is along Z and equals mChipThickness
+  const double halfThickness = 0.5 * mChipThickness;
+  const double halfPhi = 0.5 * mPhiSpanDeg;
+
+  // AIR container (layer)
+  auto* layerShape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  auto* layerVol = new TGeoVolume(mLayerName.c_str(), layerShape, medAir);
+  layerVol->SetLineColor(kYellow);
+  layerVol->SetTransparency(30);
+
+  // Sensor (same size & shape as the layer for disks)
+  TGeoVolume* sensorVol = VDDiskLayer::createSensor();
+  if (!sensorVol) {
+    LOGP(error, "VDDiskLayer::createSensor() returned null");
+    return;
+  }
+
+  // Insert single sensor (no Z-segmentation for disks)
+  layerVol->AddNode(sensorVol, 1, nullptr);
+
+  TGeoTranslation tz(0.0, 0.0, mZPos);
+  motherVolume->AddNode(layerVol, 1, combiTrans ? combiTrans : &tz);
+}
+
+// ClassImp(VDLayer);
+// ClassImp(VDCylindricalLayer);
+// ClassImp(VDRectangularLayer);
+// ClassImp(VDDiskLayer);
+
+} // namespace trk
+} // namespace o2
\ No newline at end of file

From e7da91e8bb1cc59981a6daed22b21cf2fd953668 Mon Sep 17 00:00:00 2001
From: iravasen <ivan.ravasenga@cern.ch>
Date: Fri, 24 Oct 2025 21:00:06 +0200
Subject: [PATCH 0965/1764] ITS Calib: fix parallel processing for highly
 disordered data  (#14756)

---
 .../ITSWorkflow/ThresholdCalibratorSpec.h     |  11 +-
 .../workflow/src/ThresholdCalibratorSpec.cxx  | 220 +++++++++++-------
 2 files changed, 149 insertions(+), 82 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ThresholdCalibratorSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ThresholdCalibratorSpec.h
index 2a139f7997dfb..a768b848c7095 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ThresholdCalibratorSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ThresholdCalibratorSpec.h
@@ -175,6 +175,7 @@ class ITSThresholdCalibrator : public Task
   unsigned char vCharge[N_COL];
   unsigned char vHits[N_COL];
   short int mColStep = 8; // save s-curves to tree every mColStep pixels on 1 row
+  short int mRowStep = 1;
 
   // Initialize pointers for doing error function fits
   TH1F* mFitHist = nullptr;
@@ -232,7 +233,8 @@ class ITSThresholdCalibrator : public Task
   short int mRunTypeUp = -1;
   short int mRunTypeRU[N_RU] = {0};
   short int mRunTypeRUCopy[N_RU] = {0};
-  short int mCdwCntRU[N_RU][N_ROW] = {{0}};
+  bool mFlagsRU[N_RU] = {0};
+  std::map<short int, std::map<short int, std::array<std::array<int, 500>, 500>>> mCdwCntRU; // RU --> row --> 2D hit map
   short int mLoopVal[N_RU][N_ROW] = {{0}};
   bool mActiveLinks[N_RU][3] = {{false}};
   std::set<short int> mRuSet;
@@ -241,6 +243,7 @@ class ITSThresholdCalibrator : public Task
   short int mMin = -1, mMax = -1, mMin2 = 0, mMax2 = 0;
   short int mStep = 1, mStep2 = 1;
   short int mStrobeWindow = 5; // 5 means 5*25ns = 125 ns
+  short int mRowScan = 512;    // number of scanned rows, used only to normalize % of success
 
   // Get threshold method (fit == 1, derivative == 0, or hitcounting == 2)
   char mFitType = -1;
@@ -293,6 +296,7 @@ class ITSThresholdCalibrator : public Task
   short int manualStep = 1, manualStep2 = 1;
   std::string manualScanType;
   short int manualStrobeWindow = 5;
+  short int manualRowScan = 512; // used only to normalize % of success in thr/ithr/vcasn scans
 
   // for CRU_ITS data processing
   bool isCRUITS = false;
@@ -306,7 +310,7 @@ class ITSThresholdCalibrator : public Task
   int maxDumpS = -1;                   // maximum number of s-curves to be dumped, default -1 = dump all
   std::string chipDumpS = "";          // list of comma-separated O2 chipIDs to be dumped, default is empty = dump all
   int dumpCounterS[24120] = {0};       // count dumps for every chip
-  int countCdw[24120] = {0};           // count how many CDWs have been processed with the maximum charge injected: usefull for s-curve dump when hits do not arrive in order
+  bool isChipDB[24120] = {0};          // check whether a chip has been already added to DB entry
   TFile* fileDumpS;                    // file where to store the s-curves on disk
   std::vector<short int> chipDumpList; // vector of chips to dump
 
@@ -324,6 +328,9 @@ class ITSThresholdCalibrator : public Task
 
   // Percentage cut for VCASN/ITHR scans
   short int mPercentageCut = 25; // default, at least 1 good row equivalent
+
+  // For data replay only
+  short int isLocal = false;
 };
 
 // Create a processor spec
diff --git a/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
index e1d7dc725e9e3..0a08841059d63 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
@@ -74,6 +74,8 @@ void ITSThresholdCalibrator::init(InitContext& ic)
     LOG(warning) << "mColStep = " << mColStep << ": saving s-curves of only 1 pixel (pix 0) per row";
   }
 
+  isLocal = ic.options().get<bool>("local");
+
   std::string fittype = ic.options().get<std::string>("fittype");
   if (fittype == "derivative") {
     this->mFitType = DERIVATIVE;
@@ -149,6 +151,12 @@ void ITSThresholdCalibrator::init(InitContext& ic)
   // Parameters to operate in manual mode (when run type is not recognized automatically)
   isManualMode = ic.options().get<bool>("manual-mode");
   if (isManualMode) {
+    try {
+      manualRowScan = ic.options().get<short int>("manual-rowscan");
+    } catch (std::exception const& e) {
+      throw std::runtime_error("Number of scanned rows not found, mandatory in manual mode");
+    }
+
     try {
       manualMin = ic.options().get<short int>("manual-min");
     } catch (std::exception const& e) {
@@ -746,39 +754,40 @@ void ITSThresholdCalibrator::extractThresholdRow(const short int& chipID, const
 
   } else { // threshold, vcasn, ithr, vresetd_2d
 
-    short int iRU = getRUID(chipID);
+    for (int scan_i = 0; scan_i < ((mScanType == 'r') ? N_RANGE : N_RANGE2); scan_i++) {
 #ifdef WITH_OPENMP
-    omp_set_num_threads(mNThreads);
+      omp_set_num_threads(mNThreads);
 #pragma omp parallel for schedule(dynamic)
 #endif
-    // Loop over all columns (pixels) in the row
-    for (short int col_i = 0; col_i < this->N_COL; col_i++) {
-      // Do the threshold fit
-      float thresh = 0., noise = 0.;
-      bool success = false;
-      int spoints = 0;
-      int scan_i = mScanType == 'r' ? (mLoopVal[iRU][row] - mMin) / mStep : 0;
-      if (isDumpS) { // already protected for multi-thread in the init
-        mFitHist->SetName(Form("scurve_chip%d_row%d_col%d_scani%d", chipID, row, col_i, scan_i));
-      }
+      // Loop over all columns (pixels) in the row
+      for (short int col_i = 0; col_i < this->N_COL; col_i++) {
+        // Do the threshold fit
+        float thresh = 0., noise = 0.;
+        bool success = false;
+        int spoints = 0;
 
-      success = this->findThreshold(chipID, mPixelHits[chipID][row][col_i],
-                                    this->mX, mScanType == 'r' ? N_RANGE2 : N_RANGE, thresh, noise, spoints, scan_i);
+        if (isDumpS) { // already protected for multi-thread in the init
+          mFitHist->SetName(Form("scurve_chip%d_row%d_col%d_scani%d", chipID, row, col_i, scan_i));
+        }
 
-      vChipid[col_i] = chipID;
-      vRow[col_i] = row;
-      vThreshold[col_i] = (mScanType == 'T' || mScanType == 'r') ? (short int)(thresh * 10.) : (short int)(thresh);
-      vNoise[col_i] = (float)(noise * 10.); // always factor 10 also for ITHR/VCASN to not have all zeros
-      vSuccess[col_i] = success;
-      vPoints[col_i] = spoints > 0 ? (unsigned char)(spoints) : 0;
+        success = this->findThreshold(chipID, mPixelHits[chipID][row][col_i],
+                                      this->mX, mScanType == 'r' ? N_RANGE2 : N_RANGE, thresh, noise, spoints, scan_i);
 
+        vChipid[col_i] = chipID;
+        vRow[col_i] = row;
+        vThreshold[col_i] = (mScanType == 'T' || mScanType == 'r') ? (short int)(thresh * 10.) : (short int)(thresh);
+        vNoise[col_i] = (float)(noise * 10.); // always factor 10 also for ITHR/VCASN to not have all zeros
+        vSuccess[col_i] = success;
+        vPoints[col_i] = spoints > 0 ? (unsigned char)(spoints) : 0;
+
+        if (mScanType == 'r') {
+          vMixData[col_i] = (scan_i * mStep) + mMin;
+        }
+      }
       if (mScanType == 'r') {
-        vMixData[col_i] = mLoopVal[iRU][row];
+        this->saveThreshold(); // save before moving to the next vresetd
       }
     }
-    if (mScanType == 'r') {
-      this->saveThreshold(); // save before moving to the next vresetd
-    }
 
     // Fill the ScTree tree
     if (mScanType == 'T' || mScanType == 'V' || mScanType == 'I') { // TODO: store also for other scans?
@@ -794,6 +803,9 @@ void ITSThresholdCalibrator::extractThresholdRow(const short int& chipID, const
 
   // Saves threshold information to internal memory
   if (mScanType != 'P' && mScanType != 'p' && mScanType != 't' && mScanType != 'R' && mScanType != 'r') {
+    if (mVerboseOutput) {
+      LOG(info) << "Saving data of ChipID: " << chipID << " Row: " << row;
+    }
     this->saveThreshold();
   }
 }
@@ -934,6 +946,7 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
     this->mMax = 50;
     this->N_RANGE = 51;
     this->mCheckExactRow = true;
+    mRowScan = 512;
 
   } else if (runtype == THR_SCAN_SHORT || runtype == THR_SCAN_SHORT_100HZ ||
              runtype == THR_SCAN_SHORT_200HZ || runtype == THR_SCAN_SHORT_33 || runtype == THR_SCAN_SHORT_2_10HZ || runtype == THR_SCAN_SHORT_150INJ) {
@@ -951,6 +964,12 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
         nInjScaled = nInj / 3;
       }
     }
+    mRowScan = 11;
+    if (runtype == THR_SCAN_SHORT_33) {
+      mRowScan = 33;
+    } else if (runtype == THR_SCAN_SHORT_2_10HZ) {
+      mRowScan = 2;
+    }
   } else if (runtype == VCASN150 || runtype == VCASN100 || runtype == VCASN100_100HZ || runtype == VCASN130 || runtype == VCASNBB) {
     // VCASN tuning for different target thresholds
     // Store average VCASN for each chip into CCDB
@@ -962,6 +981,7 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
     this->mMax = inMaxVcasn; // 80 is the default
     this->N_RANGE = mMax - mMin + 1;
     this->mCheckExactRow = true;
+    mRowScan = 4;
 
   } else if (runtype == ITHR150 || runtype == ITHR100 || runtype == ITHR100_100HZ || runtype == ITHR130) {
     // ITHR tuning  -- average ITHR per chip
@@ -973,6 +993,7 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
     this->mMax = inMaxIthr; // 100 is the default
     this->N_RANGE = mMax - mMin + 1;
     this->mCheckExactRow = true;
+    mRowScan = 4;
 
   } else if (runtype == DIGITAL_SCAN || runtype == DIGITAL_SCAN_100HZ || runtype == DIGITAL_SCAN_NOMASK) {
     // Digital scan -- only storing one value per chip, no fit needed
@@ -983,6 +1004,7 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
     this->mMax = 0;
     this->N_RANGE = mMax - mMin + 1;
     this->mCheckExactRow = false;
+    mRowStep = 1;
 
   } else if (runtype == ANALOGUE_SCAN) {
     // Analogue scan -- only storing one value per chip, no fit needed
@@ -1078,6 +1100,7 @@ void ITSThresholdCalibrator::setRunType(const short int& runtype)
       if (scaleNinj) {
         nInjScaled = nInj / 3;
       }
+      mRowScan = manualRowScan;
     } else {
       throw runtype;
     }
@@ -1284,7 +1307,7 @@ void ITSThresholdCalibrator::extractAndUpdate(const short int& chipID, const sho
   return;
 }
 
-//////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////
 // Main running function
 // Get info from previous stf decoder workflow, then loop over readout frames
 //     (ROFs) to count hits and extract thresholds
@@ -1367,15 +1390,13 @@ void ITSThresholdCalibrator::run(ProcessingContext& pc)
         row = !mCdwVersion ? (short int)(calib.calibUserField & 0xffff) : (short int)(calib.calibUserField & 0x1ff);
         // cw counter
         cwcnt = (short int)(calib.calibCounter);
-        // count the last N injections
-        short int checkVal = (mScanType == 'I') ? mMin : mMax;
-        if ((mScanType != 'r' && mScanType != 'p' && mScanType != 't' && loopval == checkVal) ||
-            (mScanType == 'r' && realcharge == mMax2) ||
-            (mScanType == 'p' && realcharge == mMin2) ||
-            (mScanType == 't' && loopval == checkVal && realcharge == mMax2)) {
-          mCdwCntRU[iRU][row]++;
-          mLoopVal[iRU][row] = loopval; // keep loop val (relevant for VRESET2D and TOT_1ROW scan only)
-        }
+
+        // count injections
+        short int loopPoint = (loopval - this->mMin) / mStep;
+        short int chgPoint = (realcharge - this->mMin2) / mStep2;
+        auto& arr = mCdwCntRU[iRU][row];
+        arr[chgPoint][loopPoint]++;
+
         if (this->mVerboseOutput) {
           LOG(info) << "RU: " << iRU << " CDWcounter: " << cwcnt << " row: " << row << " Loopval: " << loopval << " realcharge: " << realcharge << " confDBv: " << mCdwVersion;
           LOG(info) << "NDIGITS: " << digits.size();
@@ -1470,15 +1491,13 @@ void ITSThresholdCalibrator::run(ProcessingContext& pc)
     if (ruIndex < 0) {
       continue;
     }
-    short int nL = 0;
-    for (int iL = 0; iL < 3; iL++) {
-      if (mActiveLinks[ruIndex][iL]) {
-        nL++; // count active links
-      }
+    short int nL = getNumberOfActiveLinks(mActiveLinks[ruIndex]);
+    if (isLocal) {
+      nL = ruIndex > 47 ? 2 : 3;
     }
     std::vector<short int> chipEnabled = getChipListFromRu(ruIndex, mActiveLinks[ruIndex]); // chip boundaries
     // Fill the chipDone info string
-    if (mRunTypeRUCopy[ruIndex] == nInjScaled * nL) {
+    if (mRunTypeRUCopy[ruIndex] == nInjScaled * nL && nL > 0) {
       for (short int iChip = 0; iChip < chipEnabled.size(); iChip++) {
         if ((chipEnabled[iChip] % mChipModBase) != mChipModSel) {
           continue;
@@ -1488,14 +1507,37 @@ void ITSThresholdCalibrator::run(ProcessingContext& pc)
       mRunTypeRUCopy[ruIndex] = 0; // reset here is safer (the other counter is reset in finalize)
     }
     // Check if scan of a row is finished: only for specific scans!
-    bool passCondition = (mCdwCntRU[ruIndex][row] >= nInjScaled * nL);
-    if (mScanType == 'p' || mScanType == 't') {
-      passCondition = passCondition && (mLoopVal[ruIndex][row] == mMax);
-      if (mVerboseOutput) {
-        LOG(info) << "PassCondition: " << passCondition << " - (mCdwCntRU,mLoopVal) of RU" << ruIndex << " row " << row << " = (" << mCdwCntRU[ruIndex][row] << ", " << mLoopVal[ruIndex][row] << ")";
+    bool passCondition = nL > 0 ? true : false;
+    for (int j1 = 0; j1 < N_RANGE2; j1++) {
+      for (int j2 = 0; j2 < N_RANGE; j2++) {
+        if (mScanType == 'D' || mScanType == 'A') { // D and A are processed in finalize and include >1 rows: row data can be mixed in time!
+          for (int ir = 0; ir < mRowScan; ir += mRowStep) {
+            if (!mCdwCntRU[ruIndex].count(ir)) {
+              passCondition = false;
+              break;
+            } else if (mCdwCntRU[ruIndex][ir][j1][j2] < nInjScaled * nL) {
+              passCondition = false;
+              break;
+            }
+          }
+        } else if (mScanType == 't') { // ToT scan is done in specific ranges depending on charge (see ITSComm)
+          if ((j1 == 0 && j2 < ((600 - mMin) / mStep)) || (j2 >= ((600 - mMin) / mStep) && j2 <= ((800 - mMin) / mStep)) || (j1 == 1 && j2 > ((800 - mMin) / mStep))) {
+            if (mCdwCntRU[ruIndex][row][j1][j2] < nInjScaled * nL) {
+              passCondition = false;
+              break;
+            }
+          }
+        } else if (mCdwCntRU[ruIndex][row][j1][j2] < nInjScaled * nL) {
+          passCondition = false;
+          break;
+        }
+      }
+      if (!passCondition) {
+        break;
       }
-    } else if (mVerboseOutput) {
-      LOG(info) << "PassCondition: " << passCondition << " - mCdwCntRU of RU" << ruIndex << " row " << row << " = " << mCdwCntRU[ruIndex][row];
+    }
+    if (mVerboseOutput) {
+      LOG(info) << "PassCondition: " << passCondition << " - mCdwCntRU of RU" << ruIndex << " row " << row << " = " << mCdwCntRU[ruIndex][row][0][0] << "(Links: " << mActiveLinks[ruIndex][0] << ", " << mActiveLinks[ruIndex][1] << "," << mActiveLinks[ruIndex][2] << ")";
     }
 
     if (mScanType != 'D' && mScanType != 'A' && mScanType != 'P' && mScanType != 'R' && passCondition) {
@@ -1509,32 +1551,48 @@ void ITSThresholdCalibrator::run(ProcessingContext& pc)
           if (mPixelHits.count(chipID)) {
             if (mPixelHits[chipID].count(row)) { // make sure the row exists
               extractAndUpdate(chipID, row);
-              if (mScanType != 'p' && (mScanType != 'r' || mLoopVal[ruIndex][row] == mMax)) { // do not erase for scantype = p because in finalize() we have calculate2Dparams
+              if (mScanType != 'p') { // do not erase for scantype = p because in finalize() we have calculate2Dparams
                 mPixelHits[chipID].erase(row);
               }
             }
           }
         }
       }
-      mCdwCntRU[ruIndex][row] = 0; // reset
+      mCdwCntRU[ruIndex].erase(row); // row is gone
+    }
+
+    if (mRunTypeRU[ruIndex] >= nInjScaled * nL && passCondition) {
+      mFlagsRU[ruIndex] = true;
+      finalize();
+      // Reset Active Links, mRunTypeRU, mFlagsRU (needed only for local data replay!)
+      if (mVerboseOutput) {
+        LOG(info) << "Resetting links of RU " << ruIndex;
+      }
+      if (!isLocal) {
+        mActiveLinks[ruIndex][0] = 0;
+        mActiveLinks[ruIndex][1] = 0;
+        mActiveLinks[ruIndex][2] = 0;
+        mRunTypeRU[ruIndex] = 0;
+        mFlagsRU[ruIndex] = false;
+        mCdwCntRU.erase(ruIndex); // for D,A,P,R (not entering the if above)
+      }
+
+      LOG(info) << "Shipping all outputs to aggregator (before endOfStream arrival!)";
+      pc.outputs().snapshot(Output{"ITS", "TSTR", (unsigned int)mChipModSel}, this->mTuning);
+      pc.outputs().snapshot(Output{"ITS", "PIXTYP", (unsigned int)mChipModSel}, this->mPixStat);
+      pc.outputs().snapshot(Output{"ITS", "RUNT", (unsigned int)mChipModSel}, this->mRunType);
+      pc.outputs().snapshot(Output{"ITS", "SCANT", (unsigned int)mChipModSel}, this->mScanType);
+      pc.outputs().snapshot(Output{"ITS", "FITT", (unsigned int)mChipModSel}, this->mFitType);
+      pc.outputs().snapshot(Output{"ITS", "CONFDBV", (unsigned int)mChipModSel}, this->mConfDBv);
+      pc.outputs().snapshot(Output{"ITS", "QCSTR", (unsigned int)mChipModSel}, this->mChipDoneQc);
+      // reset the DCSconfigObject_t before next ship out
+      mTuning.clear();
+      mPixStat.clear();
+      mChipDoneQc.clear();
     }
   } // for (ROFs)
 
-  if (!(this->mRunTypeUp)) {
-    finalize();
-    LOG(info) << "Shipping all outputs to aggregator (before endOfStream arrival!)";
-    pc.outputs().snapshot(Output{"ITS", "TSTR", (unsigned int)mChipModSel}, this->mTuning);
-    pc.outputs().snapshot(Output{"ITS", "PIXTYP", (unsigned int)mChipModSel}, this->mPixStat);
-    pc.outputs().snapshot(Output{"ITS", "RUNT", (unsigned int)mChipModSel}, this->mRunType);
-    pc.outputs().snapshot(Output{"ITS", "SCANT", (unsigned int)mChipModSel}, this->mScanType);
-    pc.outputs().snapshot(Output{"ITS", "FITT", (unsigned int)mChipModSel}, this->mFitType);
-    pc.outputs().snapshot(Output{"ITS", "CONFDBV", (unsigned int)mChipModSel}, this->mConfDBv);
-    pc.outputs().snapshot(Output{"ITS", "QCSTR", (unsigned int)mChipModSel}, this->mChipDoneQc);
-    // reset the DCSconfigObject_t before next ship out
-    mTuning.clear();
-    mPixStat.clear();
-    mChipDoneQc.clear();
-  } else if (pc.transitionState() == TransitionHandlingState::Requested) {
+  if (pc.transitionState() == TransitionHandlingState::Requested) {
     LOG(info) << "Run stop requested during the scan, sending output to aggregator and then stopping to process new data";
     mRunStopRequested = true;
     finalize();                                                                             // calculating average thresholds based on what's collected up to this moment
@@ -1769,18 +1827,19 @@ void ITSThresholdCalibrator::finalize()
     if (mScanType == 'I') {
       // Only ITHR scan: assign default ITHR = 50 if chip has no avg ITHR
       for (auto& iRU : mRuSet) {
-        if (mRunTypeRU[iRU] >= nInjScaled * getNumberOfActiveLinks(mActiveLinks[iRU]) || mRunStopRequested) {
+        if (mFlagsRU[iRU] || mRunStopRequested) {
           std::vector<short int> chipList = getChipListFromRu(iRU, mActiveLinks[iRU]);
           for (size_t i = 0; i < chipList.size(); i++) {
             if ((chipList[i] % mChipModBase) != mChipModSel) {
               continue;
             }
-            if (!mThresholds.count(chipList[i])) {
+            if (!mThresholds.count(chipList[i]) && !isChipDB[chipList[i]]) {
               if (mVerboseOutput) {
                 LOG(info) << "Setting ITHR = 50 for chip " << chipList[i];
               }
               std::vector<float> data = {50, 0, 0, 0, 0};
               addDatabaseEntry(chipList[i], name, data, false);
+              isChipDB[chipList[i]] = true;
             }
           }
         }
@@ -1790,7 +1849,7 @@ void ITSThresholdCalibrator::finalize()
     auto it = this->mThresholds.cbegin();
     while (it != this->mThresholds.cend()) {
       short int iRU = getRUID(it->first);
-      if (!isCRUITS && (mRunTypeRU[iRU] < nInjScaled * getNumberOfActiveLinks(mActiveLinks[iRU]) && !mRunStopRequested)) {
+      if (!isCRUITS && (!mFlagsRU[iRU]) && !mRunStopRequested) {
         ++it;
         continue;
       }
@@ -1805,7 +1864,7 @@ void ITSThresholdCalibrator::finalize()
       if (mVerboseOutput) {
         LOG(info) << "Average or mpv " << name << " of chip " << it->first << " = " << outVal << " e-";
       }
-      float status = ((float)it->second[4] / (float)(it->second[4] + it->second[5])) * 100.; // percentage of successful threshold extractions
+      float status = ((float)it->second[4] / (float)(mRowScan * N_COL)) * 100.; // percentage of successful threshold extractions
       if (status < mPercentageCut && (mScanType == 'I' || mScanType == 'V')) {
         if (mScanType == 'I') { // default ITHR if percentage of success < mPercentageCut
           outVal = 50.;
@@ -1822,6 +1881,7 @@ void ITSThresholdCalibrator::finalize()
       }
       std::vector<float> data = {outVal, rmsT, avgN, rmsN, status};
       this->addDatabaseEntry(it->first, name, data, false);
+      isChipDB[it->first] = true;
       it = this->mThresholds.erase(it);
     }
   } else if (this->mScanType == 'D' || this->mScanType == 'A') {
@@ -1831,7 +1891,7 @@ void ITSThresholdCalibrator::finalize()
     auto itchip = this->mPixelHits.cbegin();
     while (itchip != this->mPixelHits.cend()) { // loop over chips collected
       short int iRU = getRUID(itchip->first);
-      if (!isCRUITS && (mRunTypeRU[iRU] < nInjScaled * getNumberOfActiveLinks(mActiveLinks[iRU]) && !mRunStopRequested)) {
+      if (!isCRUITS && !mFlagsRU[iRU] && !mRunStopRequested) {
         ++itchip;
         continue;
       }
@@ -1845,7 +1905,7 @@ void ITSThresholdCalibrator::finalize()
       if (this->mVerboseOutput) {
         LOG(info) << "Chip " << itchip->first << " hits extracted";
       }
-      ++itchip;
+      itchip = mPixelHits.erase(itchip);
     }
 
     auto it = this->mNoisyPixID.cbegin();
@@ -1886,7 +1946,7 @@ void ITSThresholdCalibrator::finalize()
     auto itchip = this->mPixelHits.cbegin();
     while (itchip != mPixelHits.cend()) {
       int iRU = getRUID(itchip->first);
-      if (!mRunStopRequested && mRunTypeRU[iRU] < nInjScaled * getNumberOfActiveLinks(mActiveLinks[iRU])) {
+      if (!mRunStopRequested && !mFlagsRU[iRU]) {
         ++itchip;
         continue;
       }
@@ -1909,15 +1969,11 @@ void ITSThresholdCalibrator::finalize()
       if (this->mVerboseOutput) {
         LOG(info) << "Chip " << itchip->first << " hits extracted";
       }
-      ++itchip;
+      itchip = mPixelHits.erase(itchip);
     }
     // reset RU counters so that the chips which are done will not appear again in the DCSConfigObject
   }
 
-  for (auto& ru : thisRUs) {
-    mRunTypeRU[ru] = 0; // reset
-  }
-
   return;
 }
 
@@ -1928,9 +1984,9 @@ void ITSThresholdCalibrator::endOfStream(EndOfStreamContext& ec)
 {
   if (!isEnded && !mRunStopRequested) {
     LOGF(info, "endOfStream report:", mSelfName);
-    if (isCRUITS) {
-      finalize();
-    }
+    LOG(info) << "Calling finalize(), doing nothing if scan has properly ended, otherwise save partial data in ROOT trees as backup";
+    finalize();
+
     this->finalizeOutput();
     isEnded = true;
   }
@@ -1943,6 +1999,8 @@ void ITSThresholdCalibrator::stop()
 {
   if (!isEnded) {
     LOGF(info, "stop() report:", mSelfName);
+    LOG(info) << "Calling finalize(), doing nothing if scan has properly ended, otherwise save partial data in ROOT trees as backup";
+    finalize();
     this->finalizeOutput();
     isEnded = true;
   }
@@ -1996,6 +2054,7 @@ DataProcessorSpec getITSThresholdCalibratorSpec(const ITSCalibInpConf& inpConf)
             {"manual-step2", VariantType::Int, 1, {"Step2 value: defines the steps between manual-min2 and manual-max2. Default is 1. Use only in manual mode"}},
             {"manual-scantype", VariantType::String, "T", {"scan type, can be D, T, I, V, P, p: use only in manual mode"}},
             {"manual-strobewindow", VariantType::Int, 5, {"strobe duration in clock cycles, default is 5 = 125 ns: use only in manual mode"}},
+            {"manual-rowscan", VariantType::Int, 512, {"Number of ALPIDE rows scanned in the run: use only in manual mode"}},
             {"save-tree", VariantType::Bool, false, {"Flag to save ROOT tree on disk: use only in manual mode"}},
             {"scale-ninj", VariantType::Bool, false, {"Flag to activate the scale of the number of injects to be used to count hits from specific MEBs: use only in manual mode and in combination with --meb-select"}},
             {"enable-mpv", VariantType::Bool, false, {"Flag to enable calculation of most-probable value in vcasn/ithr scans"}},
@@ -2009,7 +2068,8 @@ DataProcessorSpec getITSThresholdCalibratorSpec(const ITSCalibInpConf& inpConf)
             {"charge-b", VariantType::Int, 0, {"To use with --calculate-slope, it defines the charge (in DAC) for the 2nd point used for the slope calculation"}},
             {"meb-select", VariantType::Int, -1, {"Select from which multi-event buffer consider the hits: 0,1 or 2"}},
             {"s-curve-col-step", VariantType::Int, 8, {"save s-curves points to tree every s-curve-col-step  pixels on 1 row"}},
-            {"percentage-cut", VariantType::Int, 25, {"discard chip in ITHR/VCASN scan if the percentage of success is less than this cut"}}}};
+            {"percentage-cut", VariantType::Int, 25, {"discard chip in ITHR/VCASN scan if the percentage of success is less than this cut"}},
+            {"local", VariantType::Bool, false, {"Enable in case of data replay of scans processed row by row or in 1 go in finalize() but with partial data in the raw TF (e.g. data dump stopped before the real end of run)"}}}};
 }
 } // namespace its
 } // namespace o2

From 5090073d31fad4f36c700825098a6cca11317d2a Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <gab.cima22@gmail.com>
Date: Fri, 24 Oct 2025 18:28:33 +0200
Subject: [PATCH 0966/1764] GPU TPC: revert FollowLoopers parameters to fix
 probable miscompilation bug

---
 GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 2c750b2aabc3d..ba8f2b05e1bd5 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -105,7 +105,7 @@
     #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE, 14
     #define GPUCA_LB_GPUTPCCFGather 1024, 1
     #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 7
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 5
+    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 4
     #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256, 2
     #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
     #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256

From 68f955b0114800a06fd2a86a4d96f5726fea32f5 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Fri, 24 Oct 2025 14:41:57 +0200
Subject: [PATCH 0967/1764] GPU: Add a fallback implementation for Vc.

---
 .../Global/GPUChainTrackingClusterizer.cxx    |  16 +-
 .../GPUTPCCFCheckPadBaseline.cxx              |  30 +--
 GPU/GPUTracking/utils/VcShim.h                | 192 ++++++++++++++++++
 3 files changed, 199 insertions(+), 39 deletions(-)
 create mode 100644 GPU/GPUTracking/utils/VcShim.h

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index b0d466f13e5ef..fdd70e150adcb 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -53,13 +53,10 @@
 #include "CommonDataFormat/InteractionRecord.h"
 #endif
 
+#include "utils/VcShim.h"
 #include "utils/strtag.h"
 #include <fstream>
 
-#ifndef GPUCA_NO_VC
-#include <Vc/Vc>
-#endif
-
 using namespace o2::gpu;
 using namespace o2::tpc;
 using namespace o2::tpc::constants;
@@ -173,7 +170,7 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCount(uint
   int32_t firstHBF = (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasTfStartOrbit) ? mIOPtrs.settingsTF->tfStartOrbit : ((mIOPtrs.tpcZS->sector[iSector].count[0] && mIOPtrs.tpcZS->sector[iSector].nZSPtr[0][0]) ? o2::raw::RDHUtils::getHeartBeatOrbit(*(const o2::header::RAWDataHeader*)mIOPtrs.tpcZS->sector[iSector].zsPtr[0][0]) : 0);
 
   for (uint16_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
-#ifndef GPUCA_NO_VC
+
     if (GetProcessingSettings().prefetchTPCpageScan >= 3 && j < GPUTrackingInOutZS::NENDPOINTS - 1) {
       for (uint32_t k = 0; k < mIOPtrs.tpcZS->sector[iSector].count[j + 1]; k++) {
         for (uint32_t l = 0; l < mIOPtrs.tpcZS->sector[iSector].nZSPtr[j + 1][k]; l++) {
@@ -182,7 +179,6 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCount(uint
         }
       }
     }
-#endif
 
     std::vector<std::pair<CfFragment, TPCCFDecodeScanTmp>> fragments;
     fragments.reserve(mCFContext->nFragments);
@@ -201,12 +197,12 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCount(uint
       }
       nPages += mIOPtrs.tpcZS->sector[iSector].nZSPtr[j][k];
       for (uint32_t l = 0; l < mIOPtrs.tpcZS->sector[iSector].nZSPtr[j][k]; l++) {
-#ifndef GPUCA_NO_VC
+
         if (GetProcessingSettings().prefetchTPCpageScan >= 2 && l + 1 < mIOPtrs.tpcZS->sector[iSector].nZSPtr[j][k]) {
           Vc::Common::prefetchForOneRead(((const uint8_t*)mIOPtrs.tpcZS->sector[iSector].zsPtr[j][k]) + (l + 1) * TPCZSHDR::TPC_ZS_PAGE_SIZE);
           Vc::Common::prefetchForOneRead(((const uint8_t*)mIOPtrs.tpcZS->sector[iSector].zsPtr[j][k]) + (l + 1) * TPCZSHDR::TPC_ZS_PAGE_SIZE + sizeof(o2::header::RAWDataHeader));
         }
-#endif
+
         const uint8_t* const page = ((const uint8_t*)mIOPtrs.tpcZS->sector[iSector].zsPtr[j][k]) + l * TPCZSHDR::TPC_ZS_PAGE_SIZE;
         const o2::header::RAWDataHeader* rdh = (const o2::header::RAWDataHeader*)page;
         if (o2::raw::RDHUtils::getMemorySize(*rdh) == sizeof(o2::header::RAWDataHeader)) {
@@ -510,7 +506,7 @@ int32_t GPUChainTracking::RunTPCClusterizer_prepare(bool restorePointers)
           return 1;
         }
       }
-#ifndef GPUCA_NO_VC
+
       if (GetProcessingSettings().prefetchTPCpageScan >= 1 && iSector < NSECTORS - 1) {
         for (uint32_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
           for (uint32_t k = 0; k < mIOPtrs.tpcZS->sector[iSector].count[j]; k++) {
@@ -521,7 +517,7 @@ int32_t GPUChainTracking::RunTPCClusterizer_prepare(bool restorePointers)
           }
         }
       }
-#endif
+
       const auto& x = TPCClusterizerDecodeZSCount(iSector, fragmentMax);
       nDigitsFragmentMax[iSector] = x.first;
       processors()->tpcClusterer[iSector].mPmemory->counters.nDigits = x.first;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
index ec084c308312e..3248e517ff465 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
@@ -19,11 +19,7 @@
 #include "clusterFinderDefs.h"
 
 #ifndef GPUCA_GPUCODE
-#ifndef GPUCA_NO_VC
-#include <Vc/Vc>
-#else
-#include <array>
-#endif
+#include "utils/VcShim.h"
 #endif
 
 using namespace o2::gpu;
@@ -80,7 +76,6 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
 
   constexpr size_t ElemsInTileRow = (size_t)TilingLayout<GridSize<2>>::WidthInTiles * TimebinsPerCacheline * PadsPerCacheline;
 
-#ifndef GPUCA_NO_VC
   using UShort8 = Vc::fixed_size_simd<uint16_t, PadsPerCacheline>;
   using Charge8 = Vc::fixed_size_simd<float, PadsPerCacheline>;
 
@@ -88,12 +83,6 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
   UShort8 consecCharges{Vc::Zero};
   UShort8 maxConsecCharges{Vc::Zero};
   Charge8 maxCharge{Vc::Zero};
-#else
-  std::array<uint16_t, PadsPerCacheline> totalCharges{0};
-  std::array<uint16_t, PadsPerCacheline> consecCharges{0};
-  std::array<uint16_t, PadsPerCacheline> maxConsecCharges{0};
-  std::array<Charge, PadsPerCacheline> maxCharge{0};
-#endif
 
   tpccf::TPCFragmentTime t = fragment.firstNonOverlapTimeBin();
 
@@ -102,7 +91,6 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
 
   for (; t < fragment.lastNonOverlapTimeBin(); t += TimebinsPerCacheline) {
     for (tpccf::TPCFragmentTime localtime = 0; localtime < TimebinsPerCacheline; localtime++) {
-#ifndef GPUCA_NO_VC
       const UShort8 packedCharges{packedChargeStart + PadsPerCacheline * localtime, Vc::Aligned};
       const UShort8::mask_type isCharge = packedCharges != 0;
 
@@ -123,22 +111,6 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
       } else {
         consecCharges = 0;
       }
-#else // Vc not available
-      for (tpccf::Pad localpad = 0; localpad < PadsPerCacheline; localpad++) {
-        const uint16_t packedCharge = packedChargeStart[PadsPerCacheline * localtime + localpad];
-        const bool isCharge = packedCharge != 0;
-        if (isCharge) {
-          totalCharges[localpad]++;
-          consecCharges[localpad]++;
-          maxConsecCharges[localpad] = CAMath::Max(maxConsecCharges[localpad], consecCharges[localpad]);
-
-          const Charge unpackedCharge = Charge(packedCharge) / Charge(1 << PackedCharge::DecimalBits);
-          maxCharge[localpad] = CAMath::Max<Charge>(maxCharge[localpad], unpackedCharge);
-        } else {
-          consecCharges[localpad] = 0;
-        }
-      }
-#endif
     }
 
     packedChargeStart += ElemsInTileRow;
diff --git a/GPU/GPUTracking/utils/VcShim.h b/GPU/GPUTracking/utils/VcShim.h
new file mode 100644
index 0000000000000..21a9a6a5c95c2
--- /dev/null
+++ b/GPU/GPUTracking/utils/VcShim.h
@@ -0,0 +1,192 @@
+// Copyright 2020-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file VcShim.h
+/// \brief Provides a basic fallback implementation for Vc
+///
+/// \author Felix Weiglhofer
+
+#ifndef GPU_UTILS_VCSHIM_H
+#define GPU_UTILS_VCSHIM_H
+
+#ifndef GPUCA_NO_VC
+
+#include <Vc/Vc>
+
+#else
+
+#include <algorithm>
+#include <array>
+#include <bitset>
+#include <cstddef>
+
+namespace Vc
+{
+
+constexpr struct VectorSpecialInitializerZero {
+} Zero;
+constexpr struct AlignedTag {
+} Aligned;
+
+template <typename T>
+typename T::vector_type& internal_data(T& v)
+{
+  return v.mData;
+}
+
+template <typename T>
+const typename T::vector_type& internal_data(const T& v)
+{
+  return v.mData;
+}
+
+namespace Common
+{
+
+template <typename V, typename M>
+class WriteMaskVector
+{
+ private:
+  const M& mMask;
+  V& mVec;
+
+ public:
+  using value_type = typename V::value_type;
+
+  WriteMaskVector(V& v, const M& m) : mMask(m), mVec(v) {}
+
+  WriteMaskVector& operator++(int)
+  {
+    for (size_t i = 0; i < mVec.size(); i++)
+      mVec[i] += value_type(mMask[i]);
+    return *this;
+  }
+
+  WriteMaskVector& operator=(const value_type& v)
+  {
+    for (size_t i = 0; i < mVec.size(); i++) {
+      if (mMask[i])
+        mVec[i] = v;
+    }
+    return *this;
+  }
+};
+
+inline void prefetchMid(const void*) {}
+inline void prefetchFar(const void*) {}
+inline void prefetchForOneRead(const void*) {}
+
+} // namespace Common
+
+template <typename T, size_t N>
+class fixed_size_simd_mask
+{
+ private:
+  std::bitset<N> mData;
+
+ public:
+  bool isNotEmpty() const { return mData.any(); }
+
+  std::bitset<N>::reference operator[](size_t i) { return mData[i]; }
+  bool operator[](size_t i) const { return mData[i]; }
+
+  fixed_size_simd_mask operator!() const
+  {
+    auto o = *this;
+    o.mData.flip();
+    return o;
+  }
+};
+
+template <typename T, size_t N>
+class fixed_size_simd
+{
+ private:
+  std::array<T, N> mData;
+
+ public:
+  using vector_type = std::array<T, N>;
+  using value_type = T;
+  using mask_type = fixed_size_simd_mask<T, N>;
+
+  static constexpr size_t size() { return N; }
+
+  fixed_size_simd() = default;
+  explicit fixed_size_simd(VectorSpecialInitializerZero) { mData = {}; }
+
+  template <typename U>
+  fixed_size_simd(const fixed_size_simd<U, N>& w)
+  {
+    std::copy_n(internal_data(w).begin(), N, mData.begin());
+  }
+
+  fixed_size_simd(const T* d, AlignedTag) { std::copy_n(d, N, mData.begin()); }
+
+  T& operator[](size_t i) { return mData[i]; }
+  const T& operator[](size_t i) const { return mData[i]; }
+
+  Common::WriteMaskVector<fixed_size_simd, mask_type> operator()(const mask_type& m) { return {*this, m}; }
+
+  fixed_size_simd& operator=(const T& v)
+  {
+    for (auto& x : mData)
+      x = v;
+    return *this;
+  }
+
+  fixed_size_simd& operator+=(const T& v)
+  {
+    for (auto& x : mData)
+      x += v;
+    return *this;
+  }
+
+  fixed_size_simd& operator/=(const T& v)
+  {
+    for (auto& x : mData)
+      x /= v;
+    return *this;
+  }
+
+  fixed_size_simd operator/(const T& v) const
+  {
+    auto x = *this;
+    return x /= v;
+  }
+
+  mask_type operator==(const T& v) const
+  {
+    mask_type m;
+    for (size_t i = 0; i < N; i++)
+      m[i] = mData[i] == v;
+    return m;
+  }
+
+  mask_type operator!=(const T& v) const { return !(*this == v); }
+
+  friend vector_type& internal_data<>(fixed_size_simd& x);
+  friend const vector_type& internal_data<>(const fixed_size_simd& x);
+};
+
+template <typename V>
+V max(const V& a, const V& b)
+{
+  V o;
+  for (size_t i = 0; i < a.size(); i++)
+    o[i] = std::max(a[i], b[i]);
+  return o;
+}
+
+} // namespace Vc
+
+#endif // ifndef GPUCA_NO_VC
+
+#endif

From fd3532d6c409328a46f798fdd5e4cb5b0e0d3fca Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 27 Oct 2025 16:16:21 +0100
Subject: [PATCH 0968/1764] Improve segmentation of material LUT generation

See https://its.cern.ch/jira/browse/O2-6417 for difference.
---
 Detectors/Base/test/buildMatBudLUT.C | 48 ++++++++++++++++------------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/Detectors/Base/test/buildMatBudLUT.C b/Detectors/Base/test/buildMatBudLUT.C
index 800597d6166fd..243a0c60ded6f 100644
--- a/Detectors/Base/test/buildMatBudLUT.C
+++ b/Detectors/Base/test/buildMatBudLUT.C
@@ -17,19 +17,21 @@
 #include "DetectorsBase/MatLayerCyl.h"
 #include "DetectorsBase/GeometryManager.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
+#include "ITS3Simulation/DescriptorInnerBarrelITS3.h"
+#include "ITS3Base/SpecsV2.h"
 #include "CommonUtils/NameConf.h"
 #include <TFile.h>
 #include <TSystem.h>
 #include <TStopwatch.h>
 #endif
 
-#ifndef GPUCA_ALIGPUCODE // this part is unvisible on GPU version
+#ifndef GPUCA_ALIGPUCODE // this part is invisible on GPU version
 
 o2::base::MatLayerCylSet mbLUT;
 
 bool testMBLUT(const std::string& lutFile = "matbud.root");
 
-bool buildMatBudLUT(int nTst = 30, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomNamePrefix = "o2sim", const std::string& opts = "");
+bool buildMatBudLUT(int nTst = 60, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomName = "o2sim_geometry-aligned.root");
 
 struct LrData {
   float rMin = 0.f;
@@ -44,17 +46,14 @@ struct LrData {
 std::vector<LrData> lrData;
 void configLayers();
 
-bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::string& geomNamePrefix, const std::string& opts)
+bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::string& geomNameInput)
 {
-  auto geomName = o2::base::NameConf::getGeomFileName(geomNamePrefix);
+  auto geomName = o2::base::NameConf::getGeomFileName(geomNameInput);
   if (gSystem->AccessPathName(geomName.c_str())) { // if needed, create geometry
-    std::cout << geomName << " does not exist. Will create it on the fly\n";
-    std::stringstream str;
-    // constructing an **unaligned** geom (Geant3 used since faster initialization) --> can be avoided by passing an existing geometry
-    str << "${O2_ROOT}/bin/o2-sim-serial -n 0 -e TGeant3 --configKeyValues \"" << opts << "\" --field 0  -o " << geomNamePrefix;
-    gSystem->Exec(str.str().c_str());
+    std::cout << geomName << " does not exist. Will create it\n";
+    gSystem->Exec("$O2_ROOT/bin/o2-sim -n 0 --detectorList ALICE2.1");
   }
-  o2::base::GeometryManager::loadGeometry(geomNamePrefix);
+  o2::base::GeometryManager::loadGeometry(geomNameInput);
   configLayers();
 
   if (maxLr < 1) {
@@ -64,7 +63,7 @@ bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::
   }
   for (int i = 0; i < maxLr; i++) {
     auto& l = lrData[i];
-    printf("L:%3d %6.2f<R<%6.2f ZH=%5.1f | dz = %6.2f drph = %6.2f\n", i, l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
+    printf("L:%3d %6.4f<R<%6.4f ZH=%5.4f | dz = %6.4f drph = %6.4f\n", i, l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
     mbLUT.addLayer(l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
   }
 
@@ -249,7 +248,9 @@ void configLayers()
 
   // air space between Middle and Outer Barrels
   zSpanH = 80.f;
-  lrData.emplace_back(LrData(lrData.back().rMax, 33.5, zSpanH));
+  zBin = 10.;
+  rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
+  lrData.emplace_back(LrData(lrData.back().rMax, 33.5, zSpanH, zBin, rphiBin));
 
   //===================================================================================
   // ITS Outer barrel
@@ -259,14 +260,14 @@ void configLayers()
   zBin = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
+    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 15);
     lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
   } while (lrData.back().rMax < 36. - kToler);
 
   drStep = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
+    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 15);
     lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
   } while (lrData.back().rMax < 38.5 - kToler);
 
@@ -274,14 +275,14 @@ void configLayers()
   drStep = 0.25;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
+    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 15);
     lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
   } while (lrData.back().rMax < 41. - kToler);
 
   drStep = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
+    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 15);
     lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
   } while (lrData.back().rMax < 44. - kToler);
 
@@ -301,15 +302,20 @@ void configLayers()
   } while (lrData.back().rMax < 55. - kToler);
 
   zSpanH = 120.f;
-  lrData.emplace_back(LrData(lrData.back().rMax, 56.5, zSpanH));
-  lrData.emplace_back(LrData(lrData.back().rMax, 60.5, zSpanH));
-  lrData.emplace_back(LrData(lrData.back().rMax, 61.5, zSpanH));
+  zBin = 10.;
+  rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
+  lrData.emplace_back(LrData(lrData.back().rMax, 56.5, zSpanH, zBin, rphiBin));
+  rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
+  lrData.emplace_back(LrData(lrData.back().rMax, 60.5, zSpanH, zBin, rphiBin));
+  rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
+  lrData.emplace_back(LrData(lrData.back().rMax, 61.5, zSpanH, zBin, rphiBin));
 
   zSpanH = 150.f;
   drStep = 3.5;
   zBin = 15.;
-  rphiBin = 10;
   do {
+    auto rmean = lrData.back().rMax + drStep / 2;
+    rphiBin = rmean * TMath::Pi() * 2 / (NSect * 2);
     lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
   } while (lrData.back().rMax < 68.5 - kToler);
 
@@ -335,7 +341,7 @@ void configLayers()
   zBin = 2;
   {
     auto rmean = (lrData.back().rMax + 78.5) / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (NSect * 12);
+    rphiBin = rmean * TMath::Pi() * 2 / (NSect * 24);
     lrData.emplace_back(LrData(lrData.back().rMax, 84.5, zSpanH, zBin, rphiBin));
   }
 

From 6863937632962abce438bedacfeba8c0fee41e96 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Mon, 27 Oct 2025 20:51:43 +0100
Subject: [PATCH 0969/1764] NN clusterizer: Improving speed of NN input-filling
 kernel (#14749)

* Improve GPU filling kernel speed

* Adjusting parameter bounds and additional GPU kernel optimizations

* Adding back if statement for early exit

* const'ing + fixing CPU kernel

* Remiving print statements

* Fixing CI build issue
---
 .../Definitions/GPUDefParametersDefaults.h    |   2 +-
 .../Global/GPUChainTrackingClusterizer.cxx    |   2 +-
 .../TPCClusterFinder/GPUTPCNNClusterizer.h    |   1 +
 .../GPUTPCNNClusterizerHost.cxx               |   1 +
 .../GPUTPCNNClusterizerKernels.cxx            | 209 ++++++++----------
 .../GPUTPCNNClusterizerKernels.h              |   4 +-
 6 files changed, 95 insertions(+), 124 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index ba8f2b05e1bd5..01ae33dc3b4d8 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -491,7 +491,7 @@
 
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNCPU GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNGPU GPUCA_LB_GPUTPCNNClusterizerKernels
+  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNGPU 1024
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
   #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index fdd70e150adcb..7a870ccb35178 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -1031,7 +1031,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             // Filling the data
             if (mRec->IsGPU() || GetProcessingSettings().nn.nnClusterizerForceGpuInputFill) {
               // Fills element by element of each input matrix -> better parallelizability, but worse on CPU due to unnecessary computations
-              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNGPU>({GetGrid(iSize * clustererNNShadow.mNnClusterizerRowTimeSizeFull, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
+              runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNGPU>({GetGrid(iSize * clustererNNShadow.mNnClusterizerRowTimeSizeThreads , lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
             } else {
               // Fills the whole input matrix at once -> better performance on CPU, but worse parallelizability
               runKernel<GPUTPCNNClusterizerKernels, GPUTPCNNClusterizerKernels::fillInputNNCPU>({GetGrid(iSize, lane), krnlRunRangeNone}, iSector, clustererNNShadow.mNnInferenceInputDType, propagateMCLabels, batchStart);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
index 0b9553437765c..b7bc1575d349a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizer.h
@@ -71,6 +71,7 @@ class GPUTPCNNClusterizer : public GPUProcessor
   uint32_t mNnClusterizerPadTimeSize = 0;
   uint32_t mNnClusterizerRowTimeSize = 0;
   uint32_t mNnClusterizerRowTimeSizeFull = 0;
+  uint32_t mNnClusterizerRowTimeSizeThreads = 0;
 
   // Boundary lookup table
   // int32_t mBoundaryMapSizeRow = 0;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index ae833ace2f648..582a0c6d7435a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -98,6 +98,7 @@ void GPUTPCNNClusterizerHost::initClusterizer(const GPUSettingsProcessingNNclust
   clustererNN.mNnClusterizerPadTimeSize = clustererNN.mNnClusterizerFullPadSize * clustererNN.mNnClusterizerFullTimeSize;
   clustererNN.mNnClusterizerRowTimeSize = clustererNN.mNnClusterizerFullRowSize * clustererNN.mNnClusterizerFullTimeSize;
   clustererNN.mNnClusterizerRowTimeSizeFull = clustererNN.mNnClusterizerRowTimeSize + (settings.nnClusterizerAddIndexData ? 3 : 0);
+  clustererNN.mNnClusterizerRowTimeSizeThreads = clustererNN.mNnClusterizerRowTimeSize + (settings.nnClusterizerAddIndexData ? 1 : 0);
   clustererNN.mNnClusterizerElementSize = clustererNN.mNnClusterizerChargeArraySize + (settings.nnClusterizerAddIndexData ? 3 : 0);
   // clustererNN.mBoundaryMapSizeRow = 3 * clustererNN.mNnClusterizerSizeInputRow + o2::tpc::constants::MAXGLOBALPADROW;
   // clustererNN.mBoundaryPadding = 11; // padding on each side to account for pad_offset. N=11 since then mIsBoundary = 24320 ~< (1.5 x 2^14 = 24576) && N must be bigger than (NPads[row(end_iroc + 1)] - NPads[row(end_iroc)])/2 (=6) for pad_offset to work
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
index 55fefa7dcf149..ee0fa217b8095 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.cxx
@@ -57,7 +57,7 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
-  uint32_t glo_idx = get_global_id(0);
+  const uint32_t glo_idx = get_global_id(0);
   if (glo_idx + batchStart >= clusterer.mPmemory->counters.nClusters || glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode) {
     return;
   }
@@ -67,39 +67,42 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
   CfArray2D<uint8_t> isPeakMap(clusterer.mPpeakMap);
   CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(glo_idx + batchStart, (uint32_t)(clusterer.mPmemory->counters.nClusters - 1))];
-  int32_t row = static_cast<int>(peak.row());
-  int32_t pad = static_cast<int>(peak.pad());
-  int32_t time = static_cast<int>(peak.time());
-  float central_charge = static_cast<float>(chargeMap[peak].unpack());
-  int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
-
-  for (int32_t r = -clustererNN.mNnClusterizerSizeInputRow; r <= clustererNN.mNnClusterizerSizeInputRow; ++r) {
-    int32_t target_row = row + r;
-    bool is_row_boundary = (target_row < 0) || (target_row >= o2::tpc::constants::MAXGLOBALPADROW);
-    int32_t pad_offset = is_row_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, target_row);
-
-    for (int32_t p = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; ++p) {
-      int32_t target_pad = pad + p;
-      bool is_boundary = is_row_boundary || GPUTPCNNClusterizerKernels::isBoundary(target_row + row_offset, target_pad, clustererNN.mNnClusterizerSizeInputRow);
-
-      for (int32_t t = -clustererNN.mNnClusterizerSizeInputTime; t <= clustererNN.mNnClusterizerSizeInputTime; ++t) {
-        int32_t target_time = time + t;
-
+  const int32_t row = static_cast<int>(peak.row());
+  const int32_t pad = static_cast<int>(peak.pad());
+  const int32_t time = static_cast<int>(peak.time());
+  const float central_charge = static_cast<float>(chargeMap[peak].unpack());
+  const float inverse_charge = 1.f / central_charge;
+
+  const int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
+  const int32_t iroc_row = 63 + clustererNN.mNnClusterizerSizeInputRow;
+  const int32_t maxrow = o2::tpc::constants::MAXGLOBALPADROW + clustererNN.mNnClusterizerSizeInputRow;
+  const int32_t npads_row = GPUTPCGeometry::NPads(row);
+  float output_value = clustererNN.mNnClusterizerBoundaryFillValue;
+
+  for (int32_t target_row = -clustererNN.mNnClusterizerSizeInputRow + row; target_row <= clustererNN.mNnClusterizerSizeInputRow + row; ++target_row) {
+    uint8_t is_boundary = (target_row < 0) || (target_row >= o2::tpc::constants::MAXGLOBALPADROW);
+    const int32_t p_local = pad + (is_boundary ? 0 : GPUTPCNNClusterizerKernels::padOffset(row, target_row));
+    const int32_t npads_reference = is_boundary ? 0 : GPUTPCGeometry::NPads(target_row - row_offset);
+
+    for (int32_t target_pad = -clustererNN.mNnClusterizerSizeInputPad + p_local; target_pad <= clustererNN.mNnClusterizerSizeInputPad + p_local; ++target_pad) {
+      is_boundary = is_boundary || GPUTPCNNClusterizerKernels::isBoundary(target_row + row_offset, target_pad, maxrow, iroc_row, npads_row, npads_reference);
+
+      for (int32_t target_time = -clustererNN.mNnClusterizerSizeInputTime + time; target_time <= clustererNN.mNnClusterizerSizeInputTime + time; ++target_time) {
         if (is_boundary || target_time < 0 || target_time >= clustererNN.maxAllowedTimebin) {
           // Fill boundary value
-          float boundary_value = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
+          output_value = clustererNN.mNnClusterizerBoundaryFillValue;
           if (dtype == 0) {
-            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)boundary_value;
+            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)output_value;
           } else {
-            clustererNN.mInputData_32[write_idx] = boundary_value;
+            clustererNN.mInputData_32[write_idx] = output_value;
           }
         } else {
           CfChargePos tmp_pos(target_row, target_pad, target_time);
-          float normalized_charge = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge;
+          output_value = chargeMap[tmp_pos].unpack() * inverse_charge;
           if (dtype == 0) {
-            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)normalized_charge;
+            clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)output_value;
           } else {
-            clustererNN.mInputData_32[write_idx] = normalized_charge;
+            clustererNN.mInputData_32[write_idx] = output_value;
           }
         }
         // if((CAMath::Abs(static_cast<float>(clustererNN.mInputData_16_Test[write_idx]) - static_cast<float>(clustererNN.mInputData_16[write_idx])) > 1e-4) && ((glo_idx + batchStart) < clusterer.mPmemory->counters.nClusters)) {
@@ -115,11 +118,11 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
     if (dtype == 0) {
       clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(sector) / o2::tpc::constants::MAXSECTOR);
       clustererNN.mInputData_16[write_idx + 1] = (OrtDataType::Float16_t)(static_cast<float>(row) / o2::tpc::constants::MAXGLOBALPADROW);
-      clustererNN.mInputData_16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / GPUTPCGeometry::NPads(row));
+      clustererNN.mInputData_16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / npads_row);
     } else {
       clustererNN.mInputData_32[write_idx] = static_cast<float>(sector) / o2::tpc::constants::MAXSECTOR;
       clustererNN.mInputData_32[write_idx + 1] = static_cast<float>(row) / o2::tpc::constants::MAXGLOBALPADROW;
-      clustererNN.mInputData_32[write_idx + 2] = static_cast<float>(pad) / GPUTPCGeometry::NPads(row);
+      clustererNN.mInputData_32[write_idx + 2] = static_cast<float>(pad) / npads_row;
     }
   }
 
@@ -139,16 +142,16 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
 template <>
 GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fillInputNNGPU>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& processors, uint8_t sector, int8_t dtype, int8_t withMC, uint32_t batchStart)
 {
-  uint32_t glo_idx = get_global_id(0);
+  const uint32_t glo_idx = get_global_id(0);
   auto& clusterer = processors.tpcClusterer[sector];
   auto& clustererNN = processors.tpcNNClusterer[sector];
 
-  if (glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode * clustererNN.mNnClusterizerRowTimeSizeFull) {
+  if (glo_idx >= (uint32_t)clustererNN.mNnClusterizerBatchedMode * clustererNN.mNnClusterizerRowTimeSizeThreads) {
     return;
   }
 
-  uint32_t base_idx = glo_idx / clustererNN.mNnClusterizerRowTimeSizeFull;
-  uint32_t transient_index = glo_idx - (base_idx * clustererNN.mNnClusterizerRowTimeSizeFull);
+  const uint32_t base_idx = glo_idx / clustererNN.mNnClusterizerRowTimeSizeThreads;
+  const uint32_t transient_index = glo_idx - (base_idx * clustererNN.mNnClusterizerRowTimeSizeThreads);
 
   // Early exit for out-of-bounds threads
   if (base_idx + batchStart >= clusterer.mPmemory->counters.nClusters) {
@@ -160,108 +163,74 @@ GPUdii() void GPUTPCNNClusterizerKernels::Thread<GPUTPCNNClusterizerKernels::fil
   // Use dedicated neural network shared memory arrays for warp-level caching
   // First thread in each warp loads shared data
   CfChargePos peak = clusterer.mPfilteredPeakPositions[CAMath::Min(base_idx + batchStart, (uint32_t)(clusterer.mPmemory->counters.nClusters - 1))];
-  float central_charge = static_cast<float>(chargeMap[peak].unpack());
-  int32_t row = static_cast<int>(peak.row());
-  int32_t pad = static_cast<int>(peak.pad());
-  int32_t time = static_cast<int>(peak.time());
+  const float central_charge = chargeMap[peak].unpack();
+  const int32_t row = static_cast<int>(peak.row());
+  const int32_t pad = static_cast<int>(peak.pad());
+  const int32_t time = static_cast<int>(peak.time());
 
   // Handle index data with fewer branches
   if (clustererNN.mNnClusterizerAddIndexData && transient_index >= clustererNN.mNnClusterizerRowTimeSize) {
-    int32_t data_idx = transient_index - clustererNN.mNnClusterizerRowTimeSize;
-    uint32_t write_idx = base_idx * clustererNN.mNnClusterizerElementSize + clustererNN.mNnClusterizerChargeArraySize + data_idx;
-
-    float index_values[3] = {
-      static_cast<float>(sector) / o2::tpc::constants::MAXSECTOR,
-      static_cast<float>(row) / o2::tpc::constants::MAXGLOBALPADROW,
-      static_cast<float>(pad) / GPUTPCGeometry::NPads(row)};
-
+    uint32_t write_idx = base_idx * clustererNN.mNnClusterizerElementSize + clustererNN.mNnClusterizerChargeArraySize;
+    const int32_t npads = GPUTPCGeometry::NPads(row);
     if (dtype == 0) {
-      clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)index_values[data_idx];
+      clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)(static_cast<float>(sector) / o2::tpc::constants::MAXSECTOR);
+      clustererNN.mInputData_16[write_idx + 1] = (OrtDataType::Float16_t)(static_cast<float>(row) / o2::tpc::constants::MAXGLOBALPADROW);
+      clustererNN.mInputData_16[write_idx + 2] = (OrtDataType::Float16_t)(static_cast<float>(pad) / npads);
     } else {
-      clustererNN.mInputData_32[write_idx] = index_values[data_idx];
-    }
-
-    // Handle deconvolution flags only once per cluster (last thread in element)
-    if (!clustererNN.mNnClusterizerSetDeconvolutionFlags && data_idx == 2) {
-      uint8_t cluster_flags = 0;
-      for (uint16_t i = 0; i < 8; i++) {
-        Delta2 d = cfconsts::InnerNeighbors[i];
-        CfChargePos tmp_pos = peak.delta(d);
-        cluster_flags += CfUtils::isPeak(isPeakMap[tmp_pos]);
-      }
-      clustererNN.mClusterFlags[2 * base_idx] = cluster_flags;
-      clustererNN.mClusterFlags[2 * base_idx + 1] = cluster_flags;
+      clustererNN.mInputData_32[write_idx] = static_cast<float>(sector) / o2::tpc::constants::MAXSECTOR;
+      clustererNN.mInputData_32[write_idx + 1] = static_cast<float>(row) / o2::tpc::constants::MAXGLOBALPADROW;
+      clustererNN.mInputData_32[write_idx + 2] = static_cast<float>(pad) / npads;
     }
-    return;
   }
 
   // Main data processing - optimize index calculations
   if (transient_index < clustererNN.mNnClusterizerRowTimeSize) {
     // Optimize 3D index calculation
-    int32_t row_idx = transient_index / clustererNN.mNnClusterizerFullTimeSize;
-    int32_t r_local = row_idx - clustererNN.mNnClusterizerSizeInputRow;
-    int32_t time_idx = transient_index - row_idx * clustererNN.mNnClusterizerFullTimeSize;
-    int32_t t_local = time_idx - clustererNN.mNnClusterizerSizeInputTime;
+    const int32_t row_idx = transient_index / clustererNN.mNnClusterizerFullTimeSize;
+    const int32_t time_idx = transient_index - row_idx * clustererNN.mNnClusterizerFullTimeSize;
     int32_t write_idx = base_idx * clustererNN.mNnClusterizerElementSize + row_idx * clustererNN.mNnClusterizerPadTimeSize + time_idx;
 
     // Early boundary check for row
-    int32_t target_row = row + r_local;
-    int8_t is_row_boundary = (target_row < 0) || (target_row > (o2::tpc::constants::MAXGLOBALPADROW - 1));
-
-    // Calculate offsets
-    int32_t row_offset = GPUTPCNNClusterizerKernels::rowOffset(row, clustererNN.mNnClusterizerSizeInputRow);
-    int32_t pad_offset = GPUTPCNNClusterizerKernels::padOffset(row, target_row);
-    for (int32_t p_local = -clustererNN.mNnClusterizerSizeInputPad + pad_offset; p_local <= clustererNN.mNnClusterizerSizeInputPad + pad_offset; p_local++) {
-      if (is_row_boundary) {
-        // Use boundary fill value
-        float boundary_val = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
+    const int32_t target_row = row + row_idx - clustererNN.mNnClusterizerSizeInputRow;
+    float output_value = clustererNN.mNnClusterizerBoundaryFillValue;
+
+    if ((row < 63 && target_row > 62) || (target_row < 0) || (row > 62 && target_row < 63) || (target_row >= o2::tpc::constants::MAXGLOBALPADROW)) {
+      for (uint32_t target_pad = 0; target_pad < clustererNN.mNnClusterizerFullPadSize; ++target_pad) {
         if (dtype == 0) {
-          clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)boundary_val;
+          clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)output_value;
         } else {
-          clustererNN.mInputData_32[write_idx] = boundary_val;
+          clustererNN.mInputData_32[write_idx] = output_value;
         }
-        write_idx += clustererNN.mNnClusterizerFullTimeSize; // Move to next pad position
-        continue;
-      }
-
-      // Calculate target pad and time
-      int32_t target_pad = pad + p_local;
-      int32_t target_time = time + t_local;
-
-      // Optimized boundary check
-      int8_t is_boundary = GPUTPCNNClusterizerKernels::isBoundary(target_row + row_offset, target_pad, clustererNN.mNnClusterizerSizeInputRow) || (target_time < 0) || (target_time >= clustererNN.maxAllowedTimebin);
-
-      float output_value;
-      if (is_boundary) {
-        output_value = static_cast<float>(clustererNN.mNnClusterizerBoundaryFillValue);
-      } else {
-        // Coalesced memory access - create position and read charge
-        CfChargePos tmp_pos(target_row, target_pad, target_time);
-        output_value = static_cast<float>(chargeMap[tmp_pos].unpack()) / central_charge; // Normalize by central charge
+        write_idx += clustererNN.mNnClusterizerFullTimeSize;
       }
-
-      // Write output with reduced branching
-      if (dtype == 0) {
-        clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)output_value;
-      } else {
-        clustererNN.mInputData_32[write_idx] = output_value;
+      return;
+    } else {
+      // Calculate offsets
+      const int32_t target_time = time + time_idx - clustererNN.mNnClusterizerSizeInputTime;
+      const uint8_t is_time_boundary = (target_time < 0) || (target_time >= clustererNN.maxAllowedTimebin);
+      const float inverse_central_charge = 1.f / central_charge; // multiply by inverse is cheaper than divide
+      const int32_t p_local = pad + GPUTPCNNClusterizerKernels::padOffset(row, target_row);
+      const int32_t npads = GPUTPCGeometry::NPads(target_row);
+
+      const int32_t start_pad = -clustererNN.mNnClusterizerSizeInputPad + p_local;
+      const int32_t end_pad = clustererNN.mNnClusterizerSizeInputPad + p_local;
+
+      for (int32_t target_pad = start_pad; target_pad <= end_pad; ++target_pad) {
+        if (target_pad >= npads || target_pad < 0 || is_time_boundary) {
+          output_value = clustererNN.mNnClusterizerBoundaryFillValue;
+        } else {
+          CfChargePos pos(target_row, target_pad, target_time);
+          // one load + one multiply
+          output_value = chargeMap[pos].unpack() * inverse_central_charge;
+        }
+        if (dtype == 0) {
+          clustererNN.mInputData_16[write_idx] = (OrtDataType::Float16_t)output_value;
+        } else {
+          clustererNN.mInputData_32[write_idx] = output_value;
+        }
+        write_idx += clustererNN.mNnClusterizerFullTimeSize;
       }
-      // if (write_idx >= clustererNN.mNnClusterizerElementSize * clustererNN.mNnClusterizerBatchedMode) {
-      //   printf("Error: Write index out of bounds (central array)! %d >= %d (write_idx: %d, base_idx: %d, transient_index: %d, row_idx: %d, time_idx: %d, r_local: %d, t_local: %d)\n",
-      //          write_idx, (int)(clustererNN.mNnClusterizerElementSize * clustererNN.mNnClusterizerBatchedMode), write_idx, base_idx, transient_index, row_idx, time_idx, r_local, t_local);
-      // }
-      // if ((clusterer.mPmemory->counters.nClusters - batchStart) < clustererNN.mNnClusterizerBatchedMode) {
-      //   if (write_idx >= ((clusterer.mPmemory->counters.nClusters - batchStart) * clustererNN.mNnClusterizerElementSize)) {
-      //     printf("Error: Write index out of bounds (end of array)! %d >= %d (write_idx: %d, base_idx: %d, transient_index: %d, row_idx: %d, time_idx: %d, r_local: %d, t_local: %d)\n",
-      //           write_idx, (int)((clusterer.mPmemory->counters.nClusters - batchStart) * clustererNN.mNnClusterizerElementSize), write_idx, base_idx, transient_index, row_idx, time_idx, r_local, t_local);
-      //   }
-      //   if (write_idx > ((clusterer.mPmemory->counters.nClusters - batchStart) * clustererNN.mNnClusterizerElementSize - 5)) {
-      //     printf("Sanity check (should appear only once) %d == %d (write_idx: %d, base_idx: %d, transient_index: %d, row_idx: %d, time_idx: %d, r_local: %d, t_local: %d)\n",
-      //           write_idx, (int)((clusterer.mPmemory->counters.nClusters - batchStart) * clustererNN.mNnClusterizerElementSize - 4), write_idx, base_idx, transient_index, row_idx, time_idx, r_local, t_local);
-      //   }
-      // }
-
-      write_idx += clustererNN.mNnClusterizerFullTimeSize; // Move to next pad position
+      return;
     }
   }
 }
@@ -737,16 +706,16 @@ GPUd() int32_t GPUTPCNNClusterizerKernels::rowOffset(int32_t row, int32_t offset
   return (row > 62 ? offset : 0);
 }
 
-GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int32_t row, int32_t pad, int32_t offset)
+GPUd() bool GPUTPCNNClusterizerKernels::isBoundary(int32_t row, int32_t pad, int32_t maxrow, int32_t iroc_row, int32_t npads_row, int32_t npads_reference)
 {
-  if (pad < 0 || row < 0) { // Faster short-circuit
+  if (pad < 0) { // Faster short-circuit
     return true;
   } else if (row < 63) {
-    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row)));
-  } else if (row < (63 + offset)) { // to account for the gap between IROC and OROC. Charge will be set to the boundary fill value in order to signal boundaries to the neural network
+    return (pad >= npads_row);
+  } else if (row < iroc_row) { // to account for the gap between IROC and OROC. Charge will be set to the boundary fill value in order to signal boundaries to the neural network
     return true;
-  } else if (row < (o2::tpc::constants::MAXGLOBALPADROW + offset)) {
-    return (pad >= static_cast<int>(GPUTPCGeometry::NPads(row - offset)));
+  } else if (row < maxrow) {
+    return (pad >= npads_reference);
   } else {
     return true;
   }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index cd3d7783771fe..9353722568b1f 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -57,7 +57,7 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
     determineClass2Labels = 4,
     publishClass1Regression = 5,
     publishClass2Regression = 6,
-    publishDeconvolutionFlags = 7,
+    publishDeconvolutionFlags = 7
   };
 
   template <int32_t iKernel = defaultKernel, typename... Args>
@@ -66,7 +66,7 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
  private:
   static GPUd() int32_t padOffset(int32_t, int32_t);
   static GPUd() int32_t rowOffset(int32_t, int32_t);
-  static GPUd() bool isBoundary(int32_t, int32_t, int32_t);
+  static GPUd() bool isBoundary(int32_t, int32_t, int32_t, int32_t, int32_t, int32_t);
   static GPUd() bool isBoundaryPublish(int32_t, int32_t, float&, float&);
 };
 

From be614d2c0496ff609a61dc1dab8118c0582f3b3f Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 27 Oct 2025 21:17:15 +0100
Subject: [PATCH 0970/1764] Recover buildMatBudLUT mods for upgrades

---
 Detectors/Base/test/buildMatBudLUT.C | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/Detectors/Base/test/buildMatBudLUT.C b/Detectors/Base/test/buildMatBudLUT.C
index 243a0c60ded6f..85f8343a2d35d 100644
--- a/Detectors/Base/test/buildMatBudLUT.C
+++ b/Detectors/Base/test/buildMatBudLUT.C
@@ -17,8 +17,6 @@
 #include "DetectorsBase/MatLayerCyl.h"
 #include "DetectorsBase/GeometryManager.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
-#include "ITS3Simulation/DescriptorInnerBarrelITS3.h"
-#include "ITS3Base/SpecsV2.h"
 #include "CommonUtils/NameConf.h"
 #include <TFile.h>
 #include <TSystem.h>
@@ -31,7 +29,7 @@ o2::base::MatLayerCylSet mbLUT;
 
 bool testMBLUT(const std::string& lutFile = "matbud.root");
 
-bool buildMatBudLUT(int nTst = 60, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomName = "o2sim_geometry-aligned.root");
+bool buildMatBudLUT(int nTst = 30, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomNamePrefix = "o2sim", const std::string& opts = "");
 
 struct LrData {
   float rMin = 0.f;
@@ -46,14 +44,17 @@ struct LrData {
 std::vector<LrData> lrData;
 void configLayers();
 
-bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::string& geomNameInput)
+bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::string& geomNamePrefix, const std::string& opts)
 {
-  auto geomName = o2::base::NameConf::getGeomFileName(geomNameInput);
+  auto geomName = o2::base::NameConf::getGeomFileName(geomNamePrefix);
   if (gSystem->AccessPathName(geomName.c_str())) { // if needed, create geometry
-    std::cout << geomName << " does not exist. Will create it\n";
-    gSystem->Exec("$O2_ROOT/bin/o2-sim -n 0 --detectorList ALICE2.1");
+    std::cout << geomName << " does not exist. Will create it on the fly\n";
+    std::stringstream str;
+    // constructing an **unaligned** geom (Geant3 used since faster initialization) --> can be avoided by passing an existing geometry
+    str << "${O2_ROOT}/bin/o2-sim-serial -n 0 -e TGeant3 --configKeyValues \"" << opts << "\" --field 0  -o " << geomNamePrefix;
+    gSystem->Exec(str.str().c_str());
   }
-  o2::base::GeometryManager::loadGeometry(geomNameInput);
+  o2::base::GeometryManager::loadGeometry(geomNamePrefix);
   configLayers();
 
   if (maxLr < 1) {
@@ -63,7 +64,7 @@ bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::
   }
   for (int i = 0; i < maxLr; i++) {
     auto& l = lrData[i];
-    printf("L:%3d %6.4f<R<%6.4f ZH=%5.4f | dz = %6.4f drph = %6.4f\n", i, l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
+    printf("L:%3d %6.2f<R<%6.2f ZH=%5.1f | dz = %6.2f drph = %6.2f\n", i, l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
     mbLUT.addLayer(l.rMin, l.rMax, l.zHalf, l.dZMin, l.dRPhiMin);
   }
 

From 7331b9701ebdd19f14860ff3b57cd60dba815119 Mon Sep 17 00:00:00 2001
From: Fabrizio <fabrizio.grosa@cern.ch>
Date: Tue, 28 Oct 2025 13:19:26 +0100
Subject: [PATCH 0971/1764] Fix application of signal filtering when enabled
 (#14763)

---
 .../AOD/include/AODProducerWorkflow/AODMcProducerHelpers.h  | 3 ++-
 Detectors/AOD/src/AODMcProducerHelpers.cxx                  | 6 +++++-
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx               | 3 ++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODMcProducerHelpers.h b/Detectors/AOD/include/AODProducerWorkflow/AODMcProducerHelpers.h
index 42431d19cb210..5e9cd445b576b 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODMcProducerHelpers.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODMcProducerHelpers.h
@@ -315,7 +315,8 @@ uint32_t updateParticles(const ParticleCursor& cursor,
                          bool background = false,
                          uint32_t weightMask = 0xFFFFFFF0,
                          uint32_t momentumMask = 0xFFFFFFF0,
-                         uint32_t positionMask = 0xFFFFFFF0);
+                         uint32_t positionMask = 0xFFFFFFF0,
+                         bool signalFilter = false);
 } // namespace o2::aodmchelpers
 
 #endif /* O2_AODMCPRODUCER_HELPERS */
diff --git a/Detectors/AOD/src/AODMcProducerHelpers.cxx b/Detectors/AOD/src/AODMcProducerHelpers.cxx
index 1a01f103dcfdb..a7093e0048c25 100644
--- a/Detectors/AOD/src/AODMcProducerHelpers.cxx
+++ b/Detectors/AOD/src/AODMcProducerHelpers.cxx
@@ -305,7 +305,8 @@ uint32_t updateParticles(const ParticleCursor& cursor,
                          bool background,
                          uint32_t weightMask,
                          uint32_t momentumMask,
-                         uint32_t positionMask)
+                         uint32_t positionMask,
+                         bool signalFilter)
 {
   using o2::mcutils::MCTrackNavigator;
   using namespace o2::aod::mcparticle::enums;
@@ -354,6 +355,9 @@ uint32_t updateParticles(const ParticleCursor& cursor,
         continue;
       }
     }
+    if (background && signalFilter) {
+      continue;
+    }
 
     // Store this particle.  We mark that putting a 1 in the
     // `toStore` mapping. This will later on be updated with the
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 4ef53a406497b..b18514949114d 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -1063,7 +1063,8 @@ void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader&
                              source == 0, // background
                              mMcParticleW,
                              mMcParticleMom,
-                             mMcParticlePos);
+                             mMcParticlePos,
+                             mUseSigFiltMC);
 
     mcReader.releaseTracksForSourceAndEvent(source, event);
   }

From b79e289dbdb26c3ff37f72b9e7a0e3a37f9f70f7 Mon Sep 17 00:00:00 2001
From: aferrero2707 <aferrero1975@gmail.com>
Date: Tue, 28 Oct 2025 09:50:12 +0100
Subject: [PATCH 0972/1764] [MCH] add cut random fraction setting for the cases
 with and without ITS

Two new environment variables are introduced to provide the fraction of
rejected MCH events separately for the cases where the selection based
on ITS IRframes is either enabled (CUT_RANDOM_FRACTION_MCH_WITH_ITS) or
disabled (CUT_RANDOM_FRACTION_MCH_NO_ITS).

The selection based on ITS is enabled by default in SYNC processing for
physics runs where ITS is included in the data taking. It can be however
explicitely disabled by adding MCH_DISABLE_ITS_IRFRAMES_SELECTION=1 to
the custom environment variables. In this case, CUT_RANDOM_FRACTION_MCH_NO_ITS
is used.

The CUT_RANDOM_FRACTION_MCH variable, as well as the two new ones, can still
be overridden by setting them explicitly in the shell environment.
Moreover, the ITS selection is applied whenever MCH_DISABLE_ITS_IRFRAMES_SELECTION
is undefined, therefore the changes are fully backward compatible.
---
 prodtests/full-system-test/dpl-workflow.sh | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 5d47ae84b130b..04c034d3ad221 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -379,7 +379,12 @@ if has_processing_step MUON_SYNC_RECO; then
   elif [[ $RUNTYPE == "PHYSICS" && $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]] || [[ $RUNTYPE == "COSMICS" ]]; then
     MCH_CONFIG_KEY+="MCHTracking.chamberResolutionX=0.4;MCHTracking.chamberResolutionY=0.4;MCHTracking.sigmaCutForTracking=7.;MCHTracking.sigmaCutForImprovement=6.;"
   fi
-  has_detector_reco ITS && [[ $RUNTYPE != "COSMICS" ]] && MCH_CONFIG_KEY+="MCHTimeClusterizer.irFramesOnly=true;"
+  if has_detector_reco ITS && [[ $RUNTYPE != "COSMICS" && x"${MCH_DISABLE_ITS_IRFRAMES_SELECTION:-}" != "x1" ]]; then
+    MCH_CONFIG_KEY+="MCHTimeClusterizer.irFramesOnly=true;"
+    [[ -z ${CUT_RANDOM_FRACTION_MCH:-} && -n ${CUT_RANDOM_FRACTION_MCH_WITH_ITS:-} ]] && CUT_RANDOM_FRACTION_MCH=${CUT_RANDOM_FRACTION_MCH_WITH_ITS:-}
+  else
+    [[ -z ${CUT_RANDOM_FRACTION_MCH:-} && -n ${CUT_RANDOM_FRACTION_MCH_NO_ITS:-} ]] && CUT_RANDOM_FRACTION_MCH=${CUT_RANDOM_FRACTION_MCH_NO_ITS:-}
+  fi
   [[ -n ${CUT_RANDOM_FRACTION_MCH:-} ]] && MCH_CONFIG_KEY+="MCHTimeClusterizer.rofRejectionFraction=$CUT_RANDOM_FRACTION_MCH;"
   MCH_CONFIG_KEY+="MCHStatusMap.useHV=false;MCHDigitFilter.statusMask=3;"
   [[ $RUNTYPE == "COSMICS" ]] && [[ -z ${CONFIG_EXTRA_PROCESS_o2_mft_reco_workflow:-} ]] && CONFIG_EXTRA_PROCESS_o2_mft_reco_workflow="MFTTracking.FullClusterScan=true"

From a5b6de9f896066bbe6834d767e3435f481b83734 Mon Sep 17 00:00:00 2001
From: Maurice Coquet <mcoquet@alicecerno2.cern.ch>
Date: Tue, 28 Oct 2025 10:09:25 +0100
Subject: [PATCH 0973/1764] [MFT] option to disable ITS irFrames

---
 prodtests/full-system-test/dpl-workflow.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 04c034d3ad221..5676cd323686e 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -127,8 +127,8 @@ if [[ $SYNCMODE == 1 ]]; then
   fi
   [[ -n ${CUT_RANDOM_FRACTION_ITS:-} ]] && ITS_CONFIG_KEY+="fastMultConfig.cutRandomFraction=$CUT_RANDOM_FRACTION_ITS;"
   ITS_CONFIG_KEY+="ITSCATrackerParam.trackletsPerClusterLimit=${CUT_TRACKLETSPERCLUSTER_MAX_ITS:--1};ITSCATrackerParam.cellsPerClusterLimit=${CUT_CELLSPERCLUSTER_MAX_ITS:--1};"
-  if has_detector_reco ITS; then
-    [[ $RUNTYPE != "COSMICS" ]] && MFT_CONFIG_KEY+="MFTTracking.irFramesOnly=1;"
+  if has_detector_reco ITS [[ $RUNTYPE != "COSMICS" && x"${MFT_DISABLE_ITS_IRFRAMES_SELECTION:-}" != "x1" ]]; then
+    MFT_CONFIG_KEY+="MFTTracking.irFramesOnly=1;"
   fi
 
   PVERTEXING_CONFIG_KEY+="pvertexer.meanVertexExtraErrConstraint=0.3;" # for calibration relax the constraint

From 8e0e840956c07a5449ef863a2cec54dc2db6d2d4 Mon Sep 17 00:00:00 2001
From: Maurice Coquet <mcoquet@alicecerno2.cern.ch>
Date: Tue, 28 Oct 2025 10:15:00 +0100
Subject: [PATCH 0974/1764] Fix typo

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 5676cd323686e..d2ba3c7ecf9fe 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -127,7 +127,7 @@ if [[ $SYNCMODE == 1 ]]; then
   fi
   [[ -n ${CUT_RANDOM_FRACTION_ITS:-} ]] && ITS_CONFIG_KEY+="fastMultConfig.cutRandomFraction=$CUT_RANDOM_FRACTION_ITS;"
   ITS_CONFIG_KEY+="ITSCATrackerParam.trackletsPerClusterLimit=${CUT_TRACKLETSPERCLUSTER_MAX_ITS:--1};ITSCATrackerParam.cellsPerClusterLimit=${CUT_CELLSPERCLUSTER_MAX_ITS:--1};"
-  if has_detector_reco ITS [[ $RUNTYPE != "COSMICS" && x"${MFT_DISABLE_ITS_IRFRAMES_SELECTION:-}" != "x1" ]]; then
+  if has_detector_reco ITS && [[ $RUNTYPE != "COSMICS" && x"${MFT_DISABLE_ITS_IRFRAMES_SELECTION:-}" != "x1" ]]; then
     MFT_CONFIG_KEY+="MFTTracking.irFramesOnly=1;"
   fi
 

From 80f2beab70ee61416cc7d4b745f6914e77b53209 Mon Sep 17 00:00:00 2001
From: Martin <43970264+mrtineide@users.noreply.github.com>
Date: Wed, 29 Oct 2025 11:47:12 +0100
Subject: [PATCH 0975/1764] Extending the CCDB API to optionally get the
 headers from first HTTP request (#14709)

* Extend CCDB functions with optional headers

* Remove the header filtering & add more tests

* Fix code snippets and enhance metadata retrieval documentation

Updated code snippets in README for header retrieval and added optional parameter documentation details.
Also fixed some CI formatting errors.

* Change unit test with to have correct includes
---
 CCDB/CMakeLists.txt                  |   6 +
 CCDB/README.md                       |  30 +-
 CCDB/include/CCDB/BasicCCDBManager.h |  31 +-
 CCDB/include/CCDB/CcdbApi.h          |   2 +-
 CCDB/src/CcdbApi.cxx                 |   5 +-
 CCDB/test/testCcdbApiHeaders.cxx     | 413 +++++++++++++++++++++++++++
 6 files changed, 466 insertions(+), 21 deletions(-)
 create mode 100644 CCDB/test/testCcdbApiHeaders.cxx

diff --git a/CCDB/CMakeLists.txt b/CCDB/CMakeLists.txt
index 9436fa37de8e6..691c3311e117c 100644
--- a/CCDB/CMakeLists.txt
+++ b/CCDB/CMakeLists.txt
@@ -92,6 +92,12 @@ o2_add_test(CcdbDownloader
             PUBLIC_LINK_LIBRARIES O2::CCDB
             LABELS ccdb)
 
+o2_add_test(CcdbApi-Headers
+            SOURCES test/testCcdbApiHeaders.cxx
+            COMPONENT_NAME ccdb
+            PUBLIC_LINK_LIBRARIES O2::CCDB
+            LABELS ccdb)
+
 # extra CcdbApi test which dispatches to CCDBDownloader (tmp until full move done)
 #o2_add_test_command(NAME CcdbApi-MultiHandle
 #                    WORKING_DIRECTORY ${SIMTESTDIR}
diff --git a/CCDB/README.md b/CCDB/README.md
index e098617cf44e3..1ae5f29dcf0e2 100644
--- a/CCDB/README.md
+++ b/CCDB/README.md
@@ -13,7 +13,7 @@ in circumstances of reduced or no network connectivity.
 
 There are currently 2 different kinds of store/retrieve functions, which we expect to unify in the immediate future:
 2. `storeAsTFile/retrieveFromTFile` API serializing a `TObject` in a ROOT `TFile`.
-3. A strongly-typed `storeAsTFileAny<T>/retrieveFromTFileAny<T>` API allowing to handle any type T 
+3. A strongly-typed `storeAsTFileAny<T>/retrieveFromTFileAny<T>` API allowing to handle any type T
    having a ROOT dictionary. We encourage to use this API by default.
 
 ## Central and local instances of the CCDB
@@ -37,12 +37,12 @@ api.init("http://ccdb-test.cern.ch:8080"); // or http://localhost:8080 for a loc
 auto deadpixels = new o2::FOO::DeadPixelMap();
 api.storeAsTFileAny(deadpixels, "FOO/DeadPixels", metadata);
 // read like this (you have to specify the type)
-auto deadpixelsback = api.retrieveFromTFileAny<o2::FOO::DeadPixelMap>("FOO/DeadPixels", metadata); 
-// read like this to get the headers as well, and thus the metadata attached to the object 
+auto deadpixelsback = api.retrieveFromTFileAny<o2::FOO::DeadPixelMap>("FOO/DeadPixels", metadata);
+// read like this to get the headers as well, and thus the metadata attached to the object
 std::map<std::string, std::string> headers;
-auto deadpixelsback = api.retrieveFromTFileAny<o2::FOO::DeadPixelMap>("FOO/DeadPixels", metadata /* constraint the objects retrieved to those matching the metadata */, -1 /* timestamp */, &headers /* the headers attached to the returned object */); 
+auto deadpixelsback = api.retrieveFromTFileAny<o2::FOO::DeadPixelMap>("FOO/DeadPixels", metadata /* constraint the objects retrieved to those matching the metadata */, -1 /* timestamp */, &headers /* the headers attached to the returned object */);
 // finally, use this method to retrieve only the headers (and thus the metadata)
-std::map<std::string, std::string> headers = f.api.retrieveHeaders("FOO/DeadPixels", f.metadata); 
+std::map<std::string, std::string> headers = api.retrieveHeaders("FOO/DeadPixels", metadata);
 ```
 
 * creating a local snapshot and fetching objects therefrom
@@ -85,7 +85,7 @@ user code. This class
 The class was written for the use-case of transport MC simulation. Typical usage should be like
 
 ```c++
-// setup manager once (at start of processing) 
+// setup manager once (at start of processing)
 auto& mgr = o2::ccdb::BasicCCDBManager::instance();
 mgr.setURL("http://ourccdbserverver.cern.ch");
 mgr.setTimestamp(timestamp_which_we_want_to_anchor_to);
@@ -111,6 +111,12 @@ This feature is useful to avoid using newer objects if the CCDB is updated in pa
 
 In cached mode, the manager can check that local objects are still valid by requiring `mgr.setLocalObjectValidityChecking(true)`, in this case a CCDB query is performed only if the cached object is no longer valid.
 
+If you want the headers/metadata for the object retrieved from the CCDB there is an optional paramater to `BasicCCDBManager::getForTimeStamp`. These headers are also cached (when caching is enabled) and is updated when a CCDB query is sent.
+```c++
+std::map<std::string,std::string> headers;
+mgr.getForTimeStamp(path, timstamp, metadata, &headers);
+```
+
 ## Future ideas / todo:
 
 - [ ] offer improved error handling / exceptions
@@ -129,26 +135,26 @@ A few prototypic command line tools are offered. These can be used in scriptable
 and facilitate the following tasks:
 
   1. Upload and annotate a generic C++ object serialized in a ROOT file
-  
+
      ```bash
      o2-ccdb-upload -f myRootFile.root --key histogram1 --path /Detector1/QA/ --meta "Description=Foo;Author=Person1;Uploader=Person2"
      ```
      This will upload the object serialized in `myRootFile.root` under the key `histogram1`. Object will be put to the CCDB path `/Detector1/QA`.
      For full list of options see `o2-ccdb-upload --help`.
-  
+
   2. Download a CCDB object to a local ROOT file (including its meta information)
-  
+
      ```bash
      o2-ccdb-downloadccdbfile --path /Detector1/QA/ --dest /tmp/CCDB --timestamp xxx
      ```
      This will download the CCDB object under path given by `--path` to a directory given by `--dest` on the disc.
      (The final filename will be `/tmp/CCDB/Detector1/QA/snapshot.root` for the moment).
      All meta-information as well as the information associated to this query will be appended to the file.
-     
+
      For full list of options see `o2-ccdb-downloadccdbfile --help`.
-  
+
   3. Inspect the content of a ROOT file and print summary about type of contained (CCDB) objects and its meta information
-  
+
      ```bash
      o2-ccdb-inspectccdbfile filename
      ```
diff --git a/CCDB/include/CCDB/BasicCCDBManager.h b/CCDB/include/CCDB/BasicCCDBManager.h
index 9668097c39473..71287c2f07d76 100644
--- a/CCDB/include/CCDB/BasicCCDBManager.h
+++ b/CCDB/include/CCDB/BasicCCDBManager.h
@@ -23,6 +23,7 @@
 #include <string>
 #include <chrono>
 #include <map>
+#include <string_view>
 #include <unordered_map>
 #include <memory>
 #include <cstdlib>
@@ -57,6 +58,7 @@ class CCDBManagerInstance
     int queries = 0;
     int fetches = 0;
     int failures = 0;
+    std::map<std::string, std::string> cacheOfHeaders;
     bool isValid(long ts) { return ts < endvalidity && ts >= startvalidity; }
     bool isCacheValid(long ts)
     {
@@ -70,6 +72,7 @@ class CCDBManagerInstance
       uuid = "";
       startvalidity = 0;
       endvalidity = -1;
+      cacheOfHeaders.clear();
     }
   };
 
@@ -98,9 +101,9 @@ class CCDBManagerInstance
   /// query timestamp
   long getTimestamp() const { return mTimestamp; }
 
-  /// retrieve an object of type T from CCDB as stored under path and timestamp
+  /// retrieve an object of type T from CCDB as stored under path and timestamp. Optional to get the headers.
   template <typename T>
-  T* getForTimeStamp(std::string const& path, long timestamp);
+  T* getForTimeStamp(std::string const& path, long timestamp, std::map<std::string, std::string>* headers = nullptr);
 
   /// retrieve an object of type T from CCDB as stored under path and using the timestamp in the middle of the run
   template <typename T>
@@ -112,10 +115,7 @@ class CCDBManagerInstance
   {
     // TODO: add some error info/handling when failing
     mMetaData = metaData;
-    auto obj = getForTimeStamp<T>(path, timestamp);
-    if (headers) {
-      *headers = mHeaders;
-    }
+    auto obj = getForTimeStamp<T>(path, timestamp, headers);
     return obj;
   }
 
@@ -235,7 +235,7 @@ class CCDBManagerInstance
 };
 
 template <typename T>
-T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp)
+T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp, std::map<std::string, std::string>* headers)
 {
   mHeaders.clear(); // we clear at the beginning; to allow to retrieve the header information in a subsequent call
   T* ptr = nullptr;
@@ -258,15 +258,32 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp)
         mFetchedSize += s;
       }
     }
+
+    if (headers) {
+      *headers = mHeaders;
+    }
   } else {
     auto& cached = mCache[path];
     cached.queries++;
     if ((!isOnline() && cached.isCacheValid(timestamp)) || (mCheckObjValidityEnabled && cached.isValid(timestamp))) {
+      // Give back the cached/saved headers
+      if (headers) {
+        *headers = cached.cacheOfHeaders;
+      }
       return reinterpret_cast<T*>(cached.noCleanupPtr ? cached.noCleanupPtr : cached.objPtr.get());
     }
     ptr = mCCDBAccessor.retrieveFromTFileAny<T>(path, mMetaData, timestamp, &mHeaders, cached.uuid,
                                                 mCreatedNotAfter ? std::to_string(mCreatedNotAfter) : "",
                                                 mCreatedNotBefore ? std::to_string(mCreatedNotBefore) : "");
+    // update the cached headers
+    for (auto const& h : mHeaders) {
+      cached.cacheOfHeaders[h.first] = h.second;
+    }
+    // return the cached headers
+    if (headers) {
+      *headers = cached.cacheOfHeaders;
+    }
+
     if (ptr) { // new object was shipped, old one (if any) is not valid anymore
       cached.fetches++;
       mFetches++;
diff --git a/CCDB/include/CCDB/CcdbApi.h b/CCDB/include/CCDB/CcdbApi.h
index e41f58d5c6da9..4dab11d5972d8 100644
--- a/CCDB/include/CCDB/CcdbApi.h
+++ b/CCDB/include/CCDB/CcdbApi.h
@@ -281,7 +281,7 @@ class CcdbApi //: public DatabaseInterface
    *  @return: True in case operation successful or false if there was a failure/problem.
    */
   bool retrieveBlob(std::string const& path, std::string const& targetdir, std::map<std::string, std::string> const& metadata, long timestamp,
-                    bool preservePathStructure = true, std::string const& localFileName = "snapshot.root", std::string const& createdNotAfter = "", std::string const& createdNotBefore = "") const;
+                    bool preservePathStructure = true, std::string const& localFileName = "snapshot.root", std::string const& createdNotAfter = "", std::string const& createdNotBefore = "", std::map<std::string, std::string>* headers = nullptr) const;
 
   /**
    * Retrieve the headers of a CCDB entry, if it exists.
diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index 8dfa7dd25e215..8b3c9e0c619c3 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -835,7 +835,7 @@ TObject* CcdbApi::retrieveFromTFile(std::string const& path, std::map<std::strin
 }
 
 bool CcdbApi::retrieveBlob(std::string const& path, std::string const& targetdir, std::map<std::string, std::string> const& metadata,
-                           long timestamp, bool preservePath, std::string const& localFileName, std::string const& createdNotAfter, std::string const& createdNotBefore) const
+                           long timestamp, bool preservePath, std::string const& localFileName, std::string const& createdNotAfter, std::string const& createdNotBefore, std::map<std::string, std::string>* outHeaders) const
 {
 
   // we setup the target path for this blob
@@ -883,6 +883,9 @@ bool CcdbApi::retrieveBlob(std::string const& path, std::string const& targetdir
   CCDBQuery querysummary(path, metadata, timestamp);
 
   updateMetaInformationInLocalFile(targetpath.c_str(), &headers, &querysummary);
+  if (outHeaders) {
+    *outHeaders = std::move(headers);
+  }
   return true;
 }
 
diff --git a/CCDB/test/testCcdbApiHeaders.cxx b/CCDB/test/testCcdbApiHeaders.cxx
new file mode 100644
index 0000000000000..bcfa2a5b44bc2
--- /dev/null
+++ b/CCDB/test/testCcdbApiHeaders.cxx
@@ -0,0 +1,413 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file   testCcdbApiHeaders.cxx
+/// \brief  Test BasicCCDBManager header/metadata information functionality with caching
+/// \author martin.oines.eide@cern.ch
+
+#define BOOST_TEST_MODULE CCDB
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_DYN_LINK
+
+#include <set>
+#include "CCDB/BasicCCDBManager.h"
+#include "CCDB/CCDBTimeStampUtils.h"
+#include "CCDB/CcdbApi.h"
+#include <boost/test/unit_test.hpp>
+
+static std::string basePath;
+// std::string ccdbUrl = "http://localhost:8080";
+std::string ccdbUrl = "http://ccdb-test.cern.ch:8080";
+bool hostReachable = false;
+
+/**
+ * Global fixture, ie general setup and teardown
+ * Copied from testBasicCCDBManager.cxx
+ */
+struct Fixture {
+  Fixture()
+  {
+    auto& ccdbManager = o2::ccdb::BasicCCDBManager::instance();
+    if (std::getenv("ALICEO2_CCDB_HOST")) {
+      ccdbUrl = std::string(std::getenv("ALICEO2_CCDB_HOST"));
+    }
+    ccdbManager.setURL(ccdbUrl);
+    hostReachable = ccdbManager.getCCDBAccessor().isHostReachable();
+    char hostname[_POSIX_HOST_NAME_MAX];
+    gethostname(hostname, _POSIX_HOST_NAME_MAX);
+    basePath = std::string("Users/m/meide/Tests/") + hostname + "/pid-" + getpid() + "/BasicCCDBManager/";
+
+    LOG(info) << "Path we will use in this test suite : " + basePath << std::endl;
+    LOG(info) << "ccdb url: " << ccdbUrl << std::endl;
+    LOG(info) << "Is host reachable ? --> " << hostReachable << std::endl;
+  }
+  ~Fixture()
+  {
+    if (hostReachable) {
+      o2::ccdb::BasicCCDBManager::instance().getCCDBAccessor().truncate(basePath + "*"); // This deletes the data after test is run, disable if you want to inspect the data
+      LOG(info) << "Test data truncated/deleted (" << basePath << ")" << std::endl;
+    }
+  }
+};
+BOOST_GLOBAL_FIXTURE(Fixture);
+/**
+ * Just an accessor to the hostReachable variable to be used to determine whether tests can be ran or not.
+ * Copied from testCcdbApi.cxx
+ */
+struct if_reachable {
+  boost::test_tools::assertion_result operator()(boost::unit_test::test_unit_id)
+  {
+    return hostReachable;
+  }
+};
+
+// Only compare known and stable keys (avoid volatile ones like Date)
+static const std::set<std::string> sStableKeys = {
+  "ETag",
+  "Valid-From",
+  "Valid-Until",
+  "Created",
+  "Last-Modified",
+  "Content-Disposition",
+  "Content-Location",
+  "path",
+  "partName",
+  "Content-MD5",
+  "Hello" // TODO find other headers to compare to
+};
+
+// Test that we get back the same header header keys as we put in (for stable keys)
+
+BOOST_AUTO_TEST_CASE(testCachedHeaders, *boost::unit_test::precondition(if_reachable()))
+{
+  /// ━━━━━━━ ARRANGE ━━━━━━━━━
+  // First store objects to test with
+  auto& ccdbManager = o2::ccdb::BasicCCDBManager::instance();
+  std::string pathA = basePath + "CachingA";
+  std::string pathB = basePath + "CachingB";
+  std::string pathC = basePath + "CachingC";
+  std::string ccdbObjO = "testObjectO";
+  std::string ccdbObjN = "testObjectN";
+  std::string ccdbObjX = "testObjectX";
+  std::map<std::string, std::string> md = {
+    {"Hello", "World"},
+    {"Key1", "Value1"},
+    {"Key2", "Value2"},
+  };
+  long start = 1000, stop = 3000;
+  ccdbManager.getCCDBAccessor().storeAsTFileAny<std::string>(&ccdbObjO, pathA, md, start, stop);
+  ccdbManager.getCCDBAccessor().storeAsTFileAny<std::string>(&ccdbObjN, pathB, md, start, stop);
+  ccdbManager.getCCDBAccessor().storeAsTFileAny<std::string>(&ccdbObjX, pathC, md, start, stop);
+  // initilize the BasicCCDBManager
+  ccdbManager.clearCache();
+  ccdbManager.setCaching(true); // This is what we want to test.
+
+  /// ━━━━━━━━━━━ ACT ━━━━━━━━━━━━
+  // Plan: get one object, then another, then the first again and check the headers are the same
+  std::map<std::string, std::string> headers1, headers2, headers3;
+
+  auto* obj1 = ccdbManager.getForTimeStamp<std::string>(pathA, (start + stop) / 2, &headers1);
+  auto* obj2 = ccdbManager.getForTimeStamp<std::string>(pathB, (start + stop) / 2, &headers2);
+  auto* obj3 = ccdbManager.getForTimeStamp<std::string>(pathA, (start + stop) / 2, &headers3); // Should lead to a cache hit!
+
+  /// ━━━━━━━━━━━ ASSERT ━━━━━━━━━━━━
+  /// Check that we got something
+  BOOST_REQUIRE(obj1 != nullptr);
+  BOOST_REQUIRE(obj2 != nullptr);
+  BOOST_REQUIRE(obj3 != nullptr);
+
+  LOG(debug) << "obj1: " << *obj1;
+  LOG(debug) << "obj2: " << *obj2;
+  LOG(debug) << "obj3: " << *obj3;
+
+  // Sanity check
+  /// Check that the objects are correct
+  BOOST_TEST(*obj1 == ccdbObjO);
+  BOOST_TEST(*obj3 == ccdbObjO);
+  BOOST_TEST(obj3 == obj1); // should be the same object in memory since it is cached
+
+  BOOST_TEST(obj2 != obj1);
+
+  (*obj1) = "ModifiedObject";
+  BOOST_TEST(*obj1 == "ModifiedObject");
+  BOOST_TEST(*obj3 == "ModifiedObject"); // obj3 and obj1 are the same object in memory
+
+  // Check that the headers are the same for the two retrievals of the same object
+  BOOST_REQUIRE(headers1.size() != 0);
+  BOOST_REQUIRE(headers3.size() != 0);
+
+  LOG(debug) << "Headers1 size: " << headers1.size();
+  for (const auto& h : headers1) {
+    LOG(debug) << "  " << h.first << " -> " << h.second;
+  }
+  LOG(debug) << "Headers3 size: " << headers3.size();
+  for (const auto& h : headers3) {
+    LOG(debug) << "  " << h.first << " -> " << h.second;
+  }
+
+  for (const auto& stableKey : sStableKeys) {
+    LOG(info) << "Checking key: " << stableKey;
+
+    BOOST_REQUIRE(headers1.count(stableKey) > 0);
+    BOOST_REQUIRE(headers3.count(stableKey) > 0);
+    BOOST_TEST(headers1.at(stableKey) == headers3.at(stableKey));
+  }
+  BOOST_TEST(headers1 != headers2, "The headers for different objects should be different");
+
+  // Test that we can  change the map and the two headers are not affected
+  headers1["NewKey"] = "NewValue";
+  headers3["NewKey"] = "DifferentValue";
+  BOOST_TEST(headers1["NewKey"] != headers3["NewKey"]); // This tests that we have a deep copy of the headers
+}
+
+BOOST_AUTO_TEST_CASE(testNonCachedHeaders, *boost::unit_test::precondition(if_reachable()))
+{
+  /// ━━━━━━━ ARRANGE ━━━━━━━━━
+  // First store objects to test with
+  auto& ccdbManager = o2::ccdb::BasicCCDBManager::instance();
+  std::string pathA = basePath + "NonCachingA";
+  std::string pathB = basePath + "NonCachingB";
+  std::string ccdbObjO = "testObjectO";
+  std::string ccdbObjN = "testObjectN";
+  std::map<std::string, std::string> md = {
+    {"Hello", "World"},
+    {"Key1", "Value1"},
+    {"Key2", "Value2"},
+  };
+  long start = 1000, stop = 2000;
+  ccdbManager.getCCDBAccessor().storeAsTFileAny(&ccdbObjO, pathA, md, start, stop);
+  ccdbManager.getCCDBAccessor().storeAsTFileAny(&ccdbObjN, pathB, md, start, stop);
+  // initilize the BasicCCDBManager
+  ccdbManager.clearCache();
+  ccdbManager.setCaching(false); // This is what we want to test, no caching
+
+  /// ━━━━━━━━━━━ ACT ━━━━━━━━━━━━
+  // Plan: get one object, then another, then the first again. Then check that the contents is the same but not the object in memory
+  std::map<std::string, std::string> headers1, headers2, headers3;
+
+  auto* obj1 = ccdbManager.getForTimeStamp<std::string>(pathA, (start + stop) / 2, &headers1);
+  auto* obj2 = ccdbManager.getForTimeStamp<std::string>(pathB, (start + stop) / 2, &headers2);
+  auto* obj3 = ccdbManager.getForTimeStamp<std::string>(pathA, (start + stop) / 2, &headers3); // Should not be cached since explicitly disabled
+
+  ccdbManager.setCaching(true); // Restore default state
+  /// ━━━━━━━━━━━ ASSERT ━━━━━━━━━━━
+  /// Check that we got something
+  BOOST_REQUIRE(obj1 != nullptr);
+  BOOST_REQUIRE(obj2 != nullptr);
+  BOOST_REQUIRE(obj3 != nullptr);
+
+  LOG(debug) << "obj1: " << *obj1;
+  LOG(debug) << "obj2: " << *obj2;
+  LOG(debug) << "obj3: " << *obj3;
+
+  // Sanity check
+  /// Check that the objects are correct
+  BOOST_TEST(*obj1 == ccdbObjO);
+  BOOST_TEST(*obj3 == ccdbObjO);
+  BOOST_TEST(obj2 != obj1);
+  BOOST_TEST(obj3 != obj1); // should NOT be the same object in memory
+  (*obj1) = "ModifiedObject";
+  BOOST_TEST(*obj1 == "ModifiedObject");
+  BOOST_TEST(*obj3 != "ModifiedObject"); // obj3 and obj1 are NOT the same object in memory
+
+  BOOST_TEST(headers1.size() == headers3.size());
+
+  // Remove the date header since it may be different even for the same object since we might have asked in different seconds
+  headers1.erase("Date");
+  headers3.erase("Date");
+  BOOST_TEST(headers1 == headers3, "The headers for the same object should be the same even if not cached");
+
+  BOOST_TEST(headers1 != headers2, "The headers for different objects should be different");
+  BOOST_TEST(headers1.size() != 0);
+  BOOST_TEST(headers3.size() != 0);
+  BOOST_TEST(headers2.size() != 0);
+  BOOST_TEST(headers1 != headers2, "The headers for different objects should be different");
+
+  // cleanup
+  delete obj1;
+  delete obj2;
+  delete obj3;
+}
+
+BOOST_AUTO_TEST_CASE(CacheFirstRetrievalAndHeadersPersistence, *boost::unit_test::precondition(if_reachable()))
+{
+  /// ━━━━━━━ ARRANGE ━━━━━━━━━
+  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
+  // Prepare two validity slots for same path to test ETag change later
+  std::string path = basePath + "ObjA";
+  std::string objV1 = "ObjectVersion1";
+  std::string objV2 = "ObjectVersion2";
+  std::map<std::string, std::string> meta1{
+    {"UserKey1", "UValue1"},
+    {"UserKey2", "UValue2"}};
+  long v1start = 10'000;
+  long v1stop = 20'000;
+  long v2start = v1stop; // contiguous slot
+  long v2stop = v2start + (v1stop - v1start);
+  long mid1 = (v1start + v1stop) / 2;
+  // Store 2 versions
+  mgr.getCCDBAccessor().storeAsTFileAny(&objV1, path, meta1, v1start, v1stop);
+  mgr.getCCDBAccessor().storeAsTFileAny(&objV2, path, meta1, v2start, v2stop);
+
+  mgr.clearCache();
+  mgr.setCaching(true);
+  mgr.setFatalWhenNull(true);
+  mgr.setTimestamp(mid1);
+
+  /// ━━━━━━━ACT━━━━━━━━━
+  std::map<std::string, std::string> headers1, headers2, headers4, headers5;
+
+  // 1) First retrieval WITH headers inside 1st slot
+  auto* p1 = mgr.getForTimeStamp<std::string>(path, mid1, &headers1);
+  size_t fetchedSizeAfterFirst = mgr.getFetchedSize();
+  // 2) Second retrieval (cache hit)
+  auto* p2 = mgr.getForTimeStamp<std::string>(path, mid1, &headers2);
+  size_t fetchedSizeAfterSecond = mgr.getFetchedSize();
+  // 3) Third retrieval (cache hit) WITHOUT passing headers
+  auto* p3 = mgr.getForTimeStamp<std::string>(path, mid1);
+  // 4) Fourth retrieval with headers again -> should still produce same headers
+  auto* p4 = mgr.getForTimeStamp<std::string>(path, mid1, &headers4);
+  // 5) Fifth retrieval with headers again to check persistence
+  auto* p5 = mgr.getForTimeStamp<std::string>(path, mid1, &headers5);
+
+  mgr.setFatalWhenNull(false); // restore default
+
+  /// ━━━━━━━ASSERT━━━━━━━━━
+
+  BOOST_TEST(p1 != nullptr);
+  BOOST_TEST(*p1 == objV1);
+
+  BOOST_TEST(headers1.count("UserKey1") == 1);
+  BOOST_TEST(headers1.count("UserKey2") == 1);
+  BOOST_TEST(headers1["UserKey1"] == "UValue1");
+  BOOST_TEST(headers1["UserKey2"] == "UValue2");
+  BOOST_TEST(headers1.count("Valid-From") == 1);
+  BOOST_TEST(headers1.count("Valid-Until") == 1);
+  BOOST_TEST(headers1.count("ETag") == 1);
+
+  /*  Need to manually amend the headers1 to have cache valid until for comparison sake,
+   *  the header is not set in the first request.
+   *  It is only set if the internal cache of CCDB has seen this object before, apperently.
+   *  This will never happen in this test since it was just created and not asked for before.
+   */
+  headers1["Cache-Valid-Until"] = std::to_string(v1stop);
+
+  /* In rare cases the header date might be different, if the second has ticked over between the requests
+   */
+  headers1.erase("Date");
+  headers2.erase("Date");
+  headers4.erase("Date");
+  headers5.erase("Date");
+
+  BOOST_TEST(p2 == p1);                                        // same pointer for cached scenario
+  BOOST_TEST(headers2 == headers1);                            // identical header map
+  BOOST_TEST(fetchedSizeAfterSecond == fetchedSizeAfterFirst); // no new fetch
+
+  BOOST_TEST(p3 == p1);
+
+  BOOST_TEST(p4 == p1);
+  BOOST_TEST(headers4 == headers1);
+
+  // Mutate the returned header map locally and ensure it does not corrupt internal cache
+  headers4["UserKey1"] = "Tampered";
+  BOOST_TEST(p5 == p1);
+  BOOST_TEST(headers5["UserKey1"] == "UValue1"); // internal unchanged
+}
+
+BOOST_AUTO_TEST_CASE(FailedFetchDoesNotGiveMetadata, *boost::unit_test::precondition(if_reachable()))
+{
+
+  /// ━━━━━━━ ARRANGE ━━━━━━━━━
+  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
+  std::string path = basePath + "FailThenRecover";
+  std::string content = "ContentX";
+  std::map<std::string, std::string> meta{{"Alpha", "Beta"}};
+  long s = 300'000, e = 310'000;
+  mgr.getCCDBAccessor().storeAsTFileAny(&content, path, meta, s, e);
+  mgr.clearCache();
+  mgr.setCaching(true);
+  mgr.setFatalWhenNull(false);
+
+  /// ━━━━━━━ ACT ━━━━━━━━━
+  // Intentionally pick a timestamp outside validity to fail first
+  long badTS = s - 1000;
+  long goodTS = (s + e) / 2;
+  std::map<std::string, std::string> hFail, hGood;
+  auto* badObj = mgr.getForTimeStamp<std::string>(path, badTS, &hFail);
+  auto* goodObj = mgr.getForTimeStamp<std::string>(path, goodTS, &hGood);
+
+  /// ━━━━━━━ ASSERT ━━━━━━━━━
+  BOOST_TEST(!hFail.empty());           // Should have some headers
+  BOOST_TEST(hFail["Alpha"] != "Beta"); // But not the metadata
+  BOOST_TEST(hGood.count("Alpha") == 1);
+  BOOST_TEST(hGood["Alpha"] == "Beta");
+
+  mgr.setFatalWhenNull(true);
+}
+
+BOOST_AUTO_TEST_CASE(FirstCallWithoutHeadersThenWithHeaders, *boost::unit_test::precondition(if_reachable()))
+{
+
+  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
+  std::string path = basePath + "LateHeaders";
+  std::string body = "Late";
+  std::map<std::string, std::string> meta{{"LateKey", "LateVal"}};
+  long s = 400'000, e = 410'000;
+  mgr.getCCDBAccessor().storeAsTFileAny(&body, path, meta, s, e);
+
+  mgr.clearCache();
+  mgr.setCaching(true);
+  long ts = (s + e) / 2;
+
+  // 1) First call with nullptr headers
+  auto* first = mgr.getForTimeStamp<std::string>(path, ts);
+  BOOST_TEST(first != nullptr);
+  BOOST_TEST(*first == body);
+
+  // 2) Second call asking for headers - should return the full set
+  std::map<std::string, std::string> h2;
+  auto* second = mgr.getForTimeStamp<std::string>(path, ts, &h2);
+  BOOST_TEST(second == first);
+  BOOST_TEST(h2.count("LateKey") == 1);
+  BOOST_TEST(h2["LateKey"] == "LateVal");
+  BOOST_TEST(h2.count("Valid-From") == 1);
+  BOOST_TEST(h2.count("Valid-Until") == 1);
+}
+
+BOOST_AUTO_TEST_CASE(HeadersAreStableAcrossMultipleHits, *boost::unit_test::precondition(if_reachable()))
+{
+
+  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
+  std::string path = basePath + "StableHeaders";
+  std::string body = "Stable";
+  std::map<std::string, std::string> meta{{"HK", "HV"}};
+  long s = 500'000, e = 510'000;
+  mgr.getCCDBAccessor().storeAsTFileAny(&body, path, meta, s, e);
+
+  mgr.clearCache();
+  mgr.setCaching(true);
+  long ts = (s + e) / 2;
+
+  std::map<std::string, std::string> h1;
+  auto* o1 = mgr.getForTimeStamp<std::string>(path, ts, &h1);
+  BOOST_TEST(o1 != nullptr);
+  BOOST_TEST(h1.count("HK") == 1);
+
+  std::string etag = h1["ETag"];
+  for (int i = 0; i < 15; ++i) {
+    std::map<std::string, std::string> hi;
+    auto* oi = mgr.getForTimeStamp<std::string>(path, ts, &hi);
+    BOOST_TEST(oi == o1);
+    BOOST_TEST(hi.count("HK") == 1);
+    BOOST_TEST(hi["ETag"] == etag);
+  }
+}

From e2abca4627ab4ccce539fc5f50db4c58e73d5e61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Wed, 29 Oct 2025 18:22:10 +0100
Subject: [PATCH 0976/1764] Improve the PDG header script  (#14769)

* Add main

* Produce the whole file

* Write to the file

* Cosmetics

* Update docstring

* Write a newline at the EOF

* Cosmetics

* Check loaded environment

* Improve exception handling
---
 .../CommonConstants/make_pdg_header.py        | 156 ++++++++++++------
 1 file changed, 110 insertions(+), 46 deletions(-)

diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index a94450e659acd..f83c44bb401db 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -12,7 +12,7 @@
 # or submit itself to any jurisdiction.
 
 """!
-@brief  Generates the body of a C++ header with PDG codes and particle masses.
+@brief  Generates and updates the body of a C++ header with PDG codes and particle masses.
 @author Vít Kučera <vit.kucera@cern.ch>, Inha University
 @date   2023-09-21
 """
@@ -21,9 +21,12 @@
 from ctypes import c_bool
 from enum import Enum
 
-import ROOT  # pylint: disable=import-error
+try:
+    import ROOT  # pylint: disable=import-error
+    from ROOT import o2
+except (ModuleNotFoundError, ImportError) as exc:
+    raise OSError("O2 environment is not loaded.") from exc
 
-name_script = os.path.basename(__file__)
 
 # Enum of PDG_t particles
 class PdgROOT(Enum):
@@ -149,7 +152,8 @@ class Pdg(Enum):
     kHyperHelium4Sigma = 1110020040
     kLambda1520_Py = 102134  # PYTHIA code different from PDG
 
-dbPdg = ROOT.o2.O2DatabasePDG
+
+dbPdg = o2.O2DatabasePDG
 
 
 def mass(code):
@@ -159,49 +163,109 @@ def mass(code):
     return dbPdg.Mass(code, success)
 
 
-def declare_mass(pdg, type="double") -> str:
+def declare_mass(pdg, mass_type="double") -> str:
     """Returns a C++ declaration of a particle mass constant."""
-    return f"constexpr {type} Mass{pdg.name[1:]} = {mass(pdg.value)};\n"
+    return f"constexpr {mass_type} Mass{pdg.name[1:]} = {mass(pdg.value)};"
 
 
-# Comment at the beginning of the output
-str_block_begin = f"""// BEGINNING OF THE GENERATED BLOCK.
-// DO NOT EDIT THIS BLOCK DIRECTLY!
-// It has been generated by the {name_script} script.
-// For modifications, edit the script and generate this block again.
-"""
-# Comment at the end of the output
-str_block_end = """// END OF THE GENERATED BLOCK
-"""
-# Start of enum declarations of additional particles
-str_enum_head = """/// \\brief Declarations of named PDG codes of particles missing in ROOT PDG_t
-/// \\note Follow kCamelCase naming convention
-/// \\link https://root.cern/doc/master/TPDGCode_8h.html
-enum Pdg {
-"""
-# End of enum declarations of additional particles
-str_enum_foot = "};\n"
-# Documentation string for mass declarations of additional particles
-str_mass_o2_head = """/// \\brief Declarations of masses for additional particles
-"""
-# Documentation string for mass declarations of PDG_t particles
-str_mass_root_head = """/// \\brief Declarations of masses for particles in ROOT PDG_t
-"""
+def main():
+    """Main function"""
+
+    path_header = "PhysicsConstants.h"
+    name_script = os.path.basename(__file__)
+
+    # Comment at the beginning of the output
+    block_begin = "// BEGINNING OF THE GENERATED BLOCK."
+    # Comment at the end of the output
+    block_end = "// END OF THE GENERATED BLOCK"
+    # Preamble with instructions
+    block_preamble = (
+        "// DO NOT EDIT THIS BLOCK DIRECTLY!"
+        f"\n// It has been generated by the {name_script} script."
+        "\n// For modifications, edit the script and generate this block again."
+    )
+    # Start of enum declarations of additional particles
+    enum_o2_head = (
+        "/// \\brief Declarations of named PDG codes of particles missing in ROOT PDG_t"
+        "\n/// \\note Follow kCamelCase naming convention"
+        "\n/// \\link https://root.cern/doc/master/TPDGCode_8h.html"
+        "\nenum Pdg {"
+    )
+    # End of enum declarations of additional particles
+    enum_o2_foot = "};"
+    # Documentation string for mass declarations of additional particles
+    mass_o2_head = "/// \\brief Declarations of masses for additional particles"
+    # Documentation string for mass declarations of PDG_t particles
+    mass_root_head = "/// \\brief Declarations of masses for particles in ROOT PDG_t"
+
+    # Get header content before and after the generated block.
+    print(f'File "{path_header}" will be updated.')
+    try:
+        with open(path_header, encoding="utf-8") as file:
+            content_old = file.readlines()
+    except OSError as exc:
+        raise OSError(f'Failed to open file "{path_header}".') from exc
+    lines_header_before: list[str] = []
+    lines_header_after: list[str] = []
+    got_block_begin = False
+    got_block_end = False
+    for line in content_old:
+        line = line.strip()
+        if line == block_begin:
+            got_block_begin = True
+        if not got_block_begin:
+            lines_header_before.append(line)
+        if got_block_end:
+            lines_header_after.append(line)
+        if line == block_end:
+            got_block_end = True
+    if not got_block_begin:
+        raise ValueError("Did not find the beginning of the block.")
+    if not got_block_end:
+        raise ValueError("Did not find the end of the block.")
+
+    # Additional particles
+    lines_enum_o2: list[str] = [enum_o2_head]
+    lines_mass_o2: list[str] = [mass_o2_head]
+    for pdg_o2 in Pdg:
+        lines_enum_o2.append(f"  {pdg_o2.name} = {pdg_o2.value},")
+        lines_mass_o2.append(declare_mass(pdg_o2))
+    lines_enum_o2[-1] = lines_enum_o2[-1][:-1]  # Remove the last comma.
+    lines_enum_o2.append(enum_o2_foot)
+
+    # PDG_t particles
+    lines_mass_root: list[str] = [mass_root_head]
+    for pdg_root in PdgROOT:
+        lines_mass_root.append(declare_mass(pdg_root))
+
+    # Header body
+    content_new = "\n".join(
+        (
+            *lines_header_before,
+            block_begin,
+            block_preamble,
+            "",
+            *lines_enum_o2,
+            "",
+            *lines_mass_o2,
+            "",
+            *lines_mass_root,
+            "",
+            block_end,
+            *lines_header_after,
+            "",
+        )
+    )
+    # print(content_new)
+
+    # Overwrite the input file.
+    try:
+        with open(path_header, "w", encoding="utf-8") as file:
+            file.write(content_new)
+            print(f'File "{path_header}" has been overwritten.')
+    except OSError as exc:
+        raise OSError(f'Failed to write to file "{path_header}".') from exc
+
 
-# Additional particles
-str_enum = str_enum_head
-str_mass_o2 = str_mass_o2_head
-for c in Pdg:
-    str_enum += f"  {c.name} = {c.value},\n"
-    str_mass_o2 += declare_mass(c)
-str_enum = str_enum[:-2] + "\n"  # Remove the last comma.
-str_enum += str_enum_foot
-
-# PDG_t particles
-str_mass_root = str_mass_root_head
-for d in PdgROOT:
-    str_mass_root += declare_mass(d)
-
-# Header body
-str_header = "\n".join((str_block_begin, str_enum, str_mass_o2, str_mass_root, str_block_end))
-print(str_header)
+if __name__ == "__main__":
+    main()

From 762d51eb867e8f97155a307336e7c009dc2b6096 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Wed, 29 Oct 2025 18:34:19 +0100
Subject: [PATCH 0977/1764] ALICE3-TRK: getMatrixPath() adapted to new
 hierarchical organization of the VD estabilished with PR#14693 (#14777)

---
 .../Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx    | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 9325f5079375d..b516918f6fdaa 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -275,13 +275,15 @@ TString GeometryTGeo::getMatrixPath(int index) const
 
   if (subDetID == 0) { // VD
     if (disk >= 0) {
-      path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk);                                   // PETALCASEx_DISKy_1
-      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk, getTRKChipPattern(), disk);   // PETALCASEx_DISKy_TRKChipy_1
+      path += Form("%s_%d_%d/", getTRKPetalAssemblyPattern(), petalcase, petalcase + 1);             // PETAL_n
+      path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk); // PETALCASEx_DISKy_1
+      // path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk, getTRKChipPattern(), disk);   // PETALCASEx_DISKy_TRKChipy_1
       path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk, getTRKSensorPattern(), disk); // PETALCASEx_DISKy_TRKSensory_1
     } else if (layer >= 0) {
-      path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer);                                    // PETALCASEx_LAYERy_1
-      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKStavePattern(), layer);  // PETALCASEx_LAYERy_TRKStavey_1
-      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKChipPattern(), layer);   // PETALCASEx_LAYERy_TRKChipy_1
+      path += Form("%s_%d_%d/", getTRKPetalAssemblyPattern(), petalcase, petalcase + 1);               // PETAL_n
+      path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer); // PETALCASEx_LAYERy_1
+      // path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKStavePattern(), layer);  // PETALCASEx_LAYERy_TRKStavey_1
+      // path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKChipPattern(), layer);   // PETALCASEx_LAYERy_TRKChipy_1
       path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKSensorPattern(), layer); // PETALCASEx_LAYERy_TRKSensory_1
     }
   } else if (subDetID == 1) {                                          // MLOT

From 180fd48c86a141c05c9b815e1b905cc4e4e5ea63 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Wed, 29 Oct 2025 22:07:41 +0100
Subject: [PATCH 0978/1764] Make GeneratorHybrid a singleton (#14737)

* Make Generators list static

* Made GeneratorHybrid a singleton
---
 Generators/include/Generators/GeneratorHybrid.h | 10 ++++++++--
 Generators/src/GeneratorFactory.cxx             |  4 ++--
 Generators/src/GeneratorHybrid.cxx              |  6 ++++++
 3 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/Generators/include/Generators/GeneratorHybrid.h b/Generators/include/Generators/GeneratorHybrid.h
index b92437b02d874..97422df1c8e2d 100644
--- a/Generators/include/Generators/GeneratorHybrid.h
+++ b/Generators/include/Generators/GeneratorHybrid.h
@@ -54,8 +54,11 @@ class GeneratorHybrid : public Generator
 {
 
  public:
-  GeneratorHybrid(const std::string& inputgens);
-  ~GeneratorHybrid();
+  GeneratorHybrid& operator=(const GeneratorHybrid&) = delete;
+  GeneratorHybrid(const GeneratorHybrid&) = delete;
+
+  // Singleton access method
+  static GeneratorHybrid& Instance(const std::string& inputgens = "");
 
   Bool_t Init() override;
   Bool_t generateEvent() override;
@@ -66,8 +69,11 @@ class GeneratorHybrid : public Generator
   Bool_t confSetter(const auto& gen);
   template <typename T>
   std::string jsonValueToString(const T& value);
+  std::vector<std::shared_ptr<o2::eventgen::Generator>> const& getGenerators() { return gens; }
 
  private:
+  GeneratorHybrid(const std::string& inputgens);
+  ~GeneratorHybrid();
   o2::eventgen::Generator* currentgen = nullptr;
   std::vector<std::shared_ptr<o2::eventgen::Generator>> gens;
   const std::vector<std::string> generatorNames = {"extkinO2", "evtpool", "boxgen", "external", "hepmc", "pythia8", "pythia8pp", "pythia8hi", "pythia8hf", "pythia8powheg"};
diff --git a/Generators/src/GeneratorFactory.cxx b/Generators/src/GeneratorFactory.cxx
index 8a6001b2cd5e6..4102bd8ffd9b2 100644
--- a/Generators/src/GeneratorFactory.cxx
+++ b/Generators/src/GeneratorFactory.cxx
@@ -284,8 +284,8 @@ void GeneratorFactory::setPrimaryGenerator(o2::conf::SimConfig const& conf, Fair
       LOG(fatal) << "Configuration file for hybrid generator does not exist";
       return;
     }
-    auto hybrid = new o2::eventgen::GeneratorHybrid(config);
-    primGen->AddGenerator(hybrid);
+    auto& hybrid = o2::eventgen::GeneratorHybrid::Instance(config);
+    primGen->AddGenerator(&hybrid);
 #endif
   } else {
     LOG(fatal) << "Invalid generator";
diff --git a/Generators/src/GeneratorHybrid.cxx b/Generators/src/GeneratorHybrid.cxx
index 83a694703c259..370671a977a5c 100644
--- a/Generators/src/GeneratorHybrid.cxx
+++ b/Generators/src/GeneratorHybrid.cxx
@@ -23,6 +23,12 @@ namespace o2
 namespace eventgen
 {
 
+GeneratorHybrid& GeneratorHybrid::Instance(const std::string& inputgens)
+{
+  static GeneratorHybrid instance(inputgens);
+  return instance;
+}
+
 GeneratorHybrid::GeneratorHybrid(const std::string& inputgens)
 {
   // This generator has trivial unit conversions

From df3b3bd9adb314a4248571dc2831a316a0e82b56 Mon Sep 17 00:00:00 2001
From: Matteo Concas <matteo.concas@cern.ch>
Date: Thu, 30 Oct 2025 13:26:10 +0100
Subject: [PATCH 0979/1764] ALICE3-TRK: Fix
 `readability-braces-around-statements` errors (#14778)

* Refactor conditionals for clarity in VDGeometryBuilder

* Fix while loop syntax for shape name generation
---
 .../TRK/simulation/src/VDGeometryBuilder.cxx  | 45 ++++++++++++-------
 1 file changed, 30 insertions(+), 15 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
index 54567a50fa4cf..5df875713262c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
@@ -54,21 +54,28 @@ inline bool isSolidToCut(const TGeoVolume* v)
   const char* nm = v->GetName();
   const char* med = v->GetMedium() ? v->GetMedium()->GetName() : "";
   // silicon sensors (barrel + disks)
-  if (med && strcmp(med, "TRK_SILICON$") == 0)
+  if (med && strcmp(med, "TRK_SILICON$") == 0) {
     return true;
+  }
   // walls, sidewalls, cold-plate, service rings (names from your builders)
-  if (TString(nm).BeginsWith("VD_InnerWallArc"))
+  if (TString(nm).BeginsWith("VD_InnerWallArc")) {
     return true;
-  if (TString(nm).BeginsWith("VD_OuterWallArc"))
+  }
+  if (TString(nm).BeginsWith("VD_OuterWallArc")) {
     return true;
-  if (TString(nm).BeginsWith("VD_SideWall"))
+  }
+  if (TString(nm).BeginsWith("VD_SideWall")) {
     return true;
-  if (TString(nm).Contains("_Coldplate"))
+  }
+  if (TString(nm).Contains("_Coldplate")) {
     return true;
-  if (TString(nm).BeginsWith("IRIS_Service_Neg"))
+  }
+  if (TString(nm).BeginsWith("IRIS_Service_Neg")) {
     return true;
-  if (TString(nm).BeginsWith("IRIS_Service_Pos_InVac"))
+  }
+  if (TString(nm).BeginsWith("IRIS_Service_Pos_InVac")) {
     return true;
+  }
   return false;
 }
 
@@ -83,11 +90,13 @@ inline const char* ensureShapeName(TGeoVolume* v)
     int k = 0;
     TString cand = wanted;
     auto* shapes = gGeoManager ? gGeoManager->GetListOfShapes() : nullptr;
-    while (shapes && shapes->FindObject(cand))
+    while (shapes && shapes->FindObject(cand)) {
       cand = Form("%s_%d", wanted.Data(), ++k);
+    }
     sh->SetName(cand);
-    if (shapes && !shapes->FindObject(cand))
+    if (shapes && !shapes->FindObject(cand)) {
       shapes->Add(sh);
+    }
   }
   return sh->GetName();
 }
@@ -102,8 +111,9 @@ inline void appendLocalTerm(const char* shapeName, const TGeoHMatrix& H)
   auto* ct = new TGeoCombiTrans(H);
   ct->SetName(Form("IRIS_LOC_TR_%d", gLocalTrIdx++));
   ct->RegisterYourself();
-  if (!gPetalSolidsFormula.IsNull())
+  if (!gPetalSolidsFormula.IsNull()) {
     gPetalSolidsFormula += "+";
+  }
   gPetalSolidsFormula += TString::Format("%s:%s", shapeName, ct->GetName());
 }
 
@@ -111,14 +121,16 @@ inline void appendLocalTerm(const char* shapeName, const TGeoHMatrix& H)
 void traversePetalLocal(TGeoVolume* vol, const TGeoHMatrix& prefix)
 {
   auto* nodes = vol->GetNodes();
-  if (!nodes)
+  if (!nodes) {
     return;
+  }
   for (int i = 0; i < nodes->GetEntriesFast(); ++i) {
     auto* node = (TGeoNode*)nodes->At(i);
     auto* childV = node->GetVolume();
     TGeoHMatrix H(prefix);
-    if (auto* m = node->GetMatrix())
+    if (auto* m = node->GetMatrix()) {
       H.Multiply(m);
+    }
 
     if (isSolidToCut(childV)) {
       const char* shapeName = ensureShapeName(childV);
@@ -132,8 +144,9 @@ void traversePetalLocal(TGeoVolume* vol, const TGeoHMatrix& prefix)
 inline void buildPetalSolidsComposite(TGeoVolume* petalAsm)
 {
   // If it already exists, skip
-  if (gGeoManager && gGeoManager->GetListOfShapes() && gGeoManager->GetListOfShapes()->FindObject("IRIS_PETAL_SOLIDSsh"))
+  if (gGeoManager && gGeoManager->GetListOfShapes() && gGeoManager->GetListOfShapes()->FindObject("IRIS_PETAL_SOLIDSsh")) {
     return;
+  }
 
   gPetalSolidsFormula.Clear();
   gLocalTrIdx = 0;
@@ -162,8 +175,9 @@ inline void buildIrisCutoutFromPetalSolid(int nPetals)
     auto* RT = new TGeoCombiTrans(0, 0, 0, R);
     RT->SetName(Form("IRIS_PETAL_ROT_%d", p));
     RT->RegisterYourself();
-    if (p)
+    if (p) {
       cutFormula += "+";
+    }
     cutFormula += Form("IRIS_PETAL_SOLIDSsh:%s", RT->GetName());
   }
   LOGP(info, "IRIS_CUTOUTsh formula: {}", cutFormula.Data());
@@ -257,8 +271,9 @@ inline double degFromArc(double arc, double radius)
  */
 inline double phiSpanFromGap(int nPetals, double gap, double radius)
 {
-  if (nPetals <= 0 || radius <= 0.f)
+  if (nPetals <= 0 || radius <= 0.f) {
     return 0.f;
+  }
   const double petalPhiDeg = 360.f / nPetals;
   const double phi = petalPhiDeg - degFromArc(gap, radius);
   return phi > 0.f ? phi : 0.f;

From dc4af26e31fd53a54ca7731a474019859bf6c249 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 30 Oct 2025 15:06:20 +0100
Subject: [PATCH 0980/1764] ITS3: update matLUT macro (#14779)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS3/macros/test/buildMatBudLUT.C         | 42 +++++++++++--------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C b/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
index 6341338835b51..fa4f7e3910b99 100644
--- a/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
+++ b/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
@@ -31,8 +31,6 @@ o2::base::MatLayerCylSet mbLUT;
 
 bool testMBLUT(const std::string& lutFile = "matbud.root");
 
-bool buildMatBudLUT(int nTst = 60, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomName = "");
-
 struct LrData {
   float rMin = 0.f;
   float rMax = 0.f;
@@ -46,14 +44,17 @@ struct LrData {
 std::vector<LrData> lrData;
 void configLayers();
 
-bool buildMatBudLUT(int nTst, int maxLr, const std::string& outFile, const std::string& geomNameInput)
+bool buildMatBudLUT(int nTst = 30, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomNamePrefix = "o2sim", const std::string& opts = "")
 {
-  auto geomName = o2::base::NameConf::getGeomFileName(geomNameInput);
+  auto geomName = o2::base::NameConf::getGeomFileName(geomNamePrefix);
   if (gSystem->AccessPathName(geomName.c_str())) { // if needed, create geometry
-    std::cout << geomName << " does not exist. Will create it\n";
-    gSystem->Exec("$O2_ROOT/bin/o2-sim -n 0 --detectorList ALICE2.1");
+    std::cout << geomName << " does not exist. Will create it on the fly\n";
+    std::stringstream str;
+    // constructing an **unaligned** geom (Geant3 used since faster initialization) --> can be avoided by passing an existing geometry
+    str << "${O2_ROOT}/bin/o2-sim-serial -n 0 -e TGeant3 --detectorList ALICE2.1 --configKeyValues \"" << opts << "\" --field 0  -o " << geomNamePrefix;
+    gSystem->Exec(str.str().c_str());
   }
-  o2::base::GeometryManager::loadGeometry(geomNameInput);
+  o2::base::GeometryManager::loadGeometry(geomNamePrefix);
   configLayers();
 
   if (maxLr < 1) {
@@ -257,7 +258,9 @@ void configLayers()
 
   // air space between Middle and Outer Barrels
   zSpanH = 80.f;
-  lrData.emplace_back(lrData.back().rMax, 33.5, zSpanH);
+  zBin = 10.;
+  rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
+  lrData.emplace_back(lrData.back().rMax, 33.5, zSpanH, zBin, rphiBin);
 
   //===================================================================================
   // ITS Outer barrel
@@ -267,14 +270,14 @@ void configLayers()
   zBin = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
+    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 15);
     lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 36. - kToler);
 
   drStep = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
+    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 15);
     lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 38.5 - kToler);
 
@@ -282,14 +285,14 @@ void configLayers()
   drStep = 0.25;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
+    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 15);
     lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 41. - kToler);
 
   drStep = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 10);
+    rphiBin = rmean * TMath::Pi() * 2 / (nStave * 15);
     lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 44. - kToler);
 
@@ -309,15 +312,20 @@ void configLayers()
   } while (lrData.back().rMax < 55. - kToler);
 
   zSpanH = 120.f;
-  lrData.emplace_back(lrData.back().rMax, 56.5, zSpanH);
-  lrData.emplace_back(lrData.back().rMax, 60.5, zSpanH);
-  lrData.emplace_back(lrData.back().rMax, 61.5, zSpanH);
+  zBin = 10.;
+  rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
+  lrData.emplace_back(lrData.back().rMax, 56.5, zSpanH, zBin, rphiBin);
+  rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
+  lrData.emplace_back(lrData.back().rMax, 60.5, zSpanH, zBin, rphiBin);
+  rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
+  lrData.emplace_back(lrData.back().rMax, 61.5, zSpanH, zBin, rphiBin);
 
   zSpanH = 150.f;
   drStep = 3.5;
   zBin = 15.;
-  rphiBin = 10;
   do {
+    auto rmean = lrData.back().rMax + drStep / 2;
+    rphiBin = rmean * TMath::Pi() * 2 / (NSect * 2);
     lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 68.5 - kToler);
 
@@ -343,7 +351,7 @@ void configLayers()
   zBin = 2;
   {
     auto rmean = (lrData.back().rMax + 78.5) / 2;
-    rphiBin = rmean * TMath::Pi() * 2 / (NSect * 12);
+    rphiBin = rmean * TMath::Pi() * 2 / (NSect * 24);
     lrData.emplace_back(lrData.back().rMax, 84.5, zSpanH, zBin, rphiBin);
   }
 

From 6043f3f6a4ba3900bcb86c2d588410be66ac7eda Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 30 Oct 2025 10:08:42 +0100
Subject: [PATCH 0981/1764] DPL: improve crash test

The executable might be in some subfolder, like stage/bin/.
---
 Framework/Core/test/test_AllCrashTypes.sh | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Framework/Core/test/test_AllCrashTypes.sh b/Framework/Core/test/test_AllCrashTypes.sh
index 54898fd9c4c5d..d333cf4252816 100755
--- a/Framework/Core/test/test_AllCrashTypes.sh
+++ b/Framework/Core/test/test_AllCrashTypes.sh
@@ -1,23 +1,23 @@
 #!/bin/sh -e
 echo $PATH
 printf "ok\nTesting runtime-init..."
-o2-framework-crashing-workflow --crash-type=runtime-init --completion-policy=quit -b --run | grep -q "Exception caught while in Init: This is a std::runtime_error. Exiting with 1." || { printf "runtime error not found" ; exit 1; }
+o2-framework-crashing-workflow --crash-type=runtime-init --completion-policy=quit -b --run | tee error.log | grep -q "Exception caught while in Init: This is a std::runtime_error. Exiting with 1." || { printf "runtime error not found" ; cat error.log ; exit 1; }
 printf "ok\nTesting framework-init..."
-o2-framework-crashing-workflow --crash-type=framework-init --completion-policy=quit -b --run | grep -q "Exception caught while in Init: This is a o2::framework::runtime_error. Exiting with 1." || { printf "framework error not found" ;  exit 1; }
+o2-framework-crashing-workflow --crash-type=framework-init --completion-policy=quit -b --run | tee error.log | grep -q "Exception caught while in Init: This is a o2::framework::runtime_error. Exiting with 1." || { printf "framework error not found" ;  cat error.log ; exit 1; }
 printf "ok\nTesting framework-run..."
-o2-framework-crashing-workflow --crash-type=framework-run --completion-policy=quit -b --run | grep -q "Unhandled o2::framework::runtime_error reached the top of main of o2-framework-crashing-workflow, device shutting down. Reason: This is a o2::framework::runtime_error" || { printf "framework error not found" ; exit 1; }
+o2-framework-crashing-workflow --crash-type=framework-run --completion-policy=quit -b --run | tee error.log | grep -q "Unhandled o2::framework::runtime_error reached the top of main of [^ ]*o2-framework-crashing-workflow, device shutting down. Reason: This is a o2::framework::runtime_error" || { printf "framework error not found" ; cat error.log ; exit 1; }
 printf "ok\nTesting runtime-run..."
-o2-framework-crashing-workflow --crash-type=runtime-run --completion-policy=quit --run | grep -q "Unhandled o2::framework::runtime_error reached the top of main of o2-framework-crashing-workflow, device shutting down. Reason: This is a std::runtime_error" || { echo "runtime error not found" ; exit 1; }
+o2-framework-crashing-workflow --crash-type=runtime-run --completion-policy=quit --run | tee error.log | grep -q "Unhandled o2::framework::runtime_error reached the top of main of [^ ]*o2-framework-crashing-workflow, device shutting down. Reason: This is a std::runtime_error" || { echo "runtime error not found" ; cat error.log ; exit 1; }
 printf "ok\n"
 
 export O2_NO_CATCHALL_EXCEPTIONS=1
 echo O2_NO_CATCHALL_EXCEPTIONS enabled
 printf "ok\nTesting runtime-init..."
-o2-framework-crashing-workflow --crash-type=runtime-init --completion-policy=quit -b --run | grep -v -q "Exception caught: This is a std::runtime_error" || { printf "runtime error not found" ; exit 1; }
+o2-framework-crashing-workflow --crash-type=runtime-init --completion-policy=quit -b --run | tee error.log | grep -v -q "Exception caught: This is a std::runtime_error" || { printf "runtime error not found" ; cat error.log ; exit 1; }
 printf "ok\nTesting framework-init..."
-o2-framework-crashing-workflow --crash-type=framework-init --completion-policy=quit -b --run | grep -v -q "Exception caught: This is a o2::framework::runtime_error" || { printf "framework error not found" ;  exit 1; }
+o2-framework-crashing-workflow --crash-type=framework-init --completion-policy=quit -b --run | tee error.log | grep -v -q "Exception caught: This is a o2::framework::runtime_error" || { printf "framework error not found" ;  cat error.log ; exit 1; }
 printf "ok\nTesting framework-run..."
-o2-framework-crashing-workflow --crash-type=framework-run --completion-policy=quit -b --run | grep -v -q "Unhandled o2::framework::runtime_error reached the top of main of o2-framework-crashing-workflow, device shutting down. Reason: This is a o2::framework::runtime_error" || { printf "framework error not found" ; exit 1; }
+o2-framework-crashing-workflow --crash-type=framework-run --completion-policy=quit -b --run | tee error.log | grep -v -q "Unhandled o2::framework::runtime_error reached the top of main of [^ ]*o2-framework-crashing-workflow, device shutting down. Reason: This is a o2::framework::runtime_error" || { printf "framework error not found" ; cat error.log ; exit 1; }
 printf "ok\nTesting runtime-run..."
-o2-framework-crashing-workflow --crash-type=runtime-run --completion-policy=quit --run | grep -v -q "Unhandled o2::framework::runtime_error reached the top of main of o2-framework-crashing-workflow, device shutting down. Reason: This is a std::runtime_error" || { echo "runtime error not found" ; exit 1; }
+o2-framework-crashing-workflow --crash-type=runtime-run --completion-policy=quit --run | tee error.log | grep -v -q "Unhandled o2::framework::runtime_error reached the top of main of [^ ]*o2-framework-crashing-workflow, device shutting down. Reason: This is a std::runtime_error" || { echo "runtime error not found"; cat error.log ; exit 1; }
 printf "ok"

From c2d9bd9fee8c447e4a689f974256132472b8334d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 30 Oct 2025 10:02:56 +0100
Subject: [PATCH 0982/1764] DPL: Move the processing policies to the
 DeviceContext

* Drop unneeded helper.
* Move the policies to the DeviceContext
---
 .../Core/include/Framework/CommonServices.h   |  1 -
 .../include/Framework/DataProcessingDevice.h  |  3 +--
 .../Core/include/Framework/DeviceContext.h    |  2 ++
 Framework/Core/src/CommonServices.cxx         | 11 ----------
 Framework/Core/src/DataProcessingDevice.cxx   | 21 ++++++++++---------
 Framework/Core/src/runDataProcessing.cxx      |  4 ++--
 6 files changed, 16 insertions(+), 26 deletions(-)

diff --git a/Framework/Core/include/Framework/CommonServices.h b/Framework/Core/include/Framework/CommonServices.h
index 69f3152c0ba76..f5080fcac28db 100644
--- a/Framework/Core/include/Framework/CommonServices.h
+++ b/Framework/Core/include/Framework/CommonServices.h
@@ -56,7 +56,6 @@ struct CommonServices {
     return [](InitContext&, void* service) -> void* { return service; };
   }
 
-  static ServiceSpec deviceContextSpec();
   static ServiceSpec dataProcessorContextSpec();
   static ServiceSpec driverClientSpec();
   static ServiceSpec monitoringSpec();
diff --git a/Framework/Core/include/Framework/DataProcessingDevice.h b/Framework/Core/include/Framework/DataProcessingDevice.h
index 67edaa99e532b..b2281274acc87 100644
--- a/Framework/Core/include/Framework/DataProcessingDevice.h
+++ b/Framework/Core/include/Framework/DataProcessingDevice.h
@@ -77,7 +77,7 @@ struct DeviceConfigurationHelpers {
 class DataProcessingDevice : public fair::mq::Device
 {
  public:
-  DataProcessingDevice(RunningDeviceRef ref, ServiceRegistry&, ProcessingPolicies& policies);
+  DataProcessingDevice(RunningDeviceRef ref, ServiceRegistry&);
   void Init() final;
   void InitTask() final;
   void PreRun() final;
@@ -112,7 +112,6 @@ class DataProcessingDevice : public fair::mq::Device
   uint64_t mBeginIterationTimestamp = 0;                 /// The timestamp of when the current ConditionalRun was started
   std::vector<fair::mq::RegionInfo> mPendingRegionInfos; /// A list of the region infos not yet notified.
   std::mutex mRegionInfoMutex;
-  ProcessingPolicies mProcessingPolicies; /// User policies related to data processing
   std::vector<uv_work_t> mHandles;        /// Handles to use to schedule work.
   std::vector<TaskStreamInfo> mStreams;   /// Information about the task running in the associated mHandle.
   /// Handle to wake up the main loop from other threads
diff --git a/Framework/Core/include/Framework/DeviceContext.h b/Framework/Core/include/Framework/DeviceContext.h
index 4593e5e819ccf..a392004c2ffbf 100644
--- a/Framework/Core/include/Framework/DeviceContext.h
+++ b/Framework/Core/include/Framework/DeviceContext.h
@@ -21,6 +21,7 @@ typedef struct uv_signal_s uv_signal_t;
 namespace o2::framework
 {
 struct ComputingQuotaStats;
+struct ProcessingPolicies;
 
 /// Stucture which holds the whole runtime context
 /// of a running device which is not stored as
@@ -33,6 +34,7 @@ struct DeviceContext {
   int expectedRegionCallbacks = 0;
   int exitTransitionTimeout = 0;
   int dataProcessingTimeout = 0;
+  ProcessingPolicies& processingPolicies;
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 5a2876e074d29..091cd9d4ed0a5 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -1237,17 +1237,6 @@ o2::framework::ServiceSpec CommonServices::dataProcessorContextSpec()
     .kind = ServiceKind::Serial};
 }
 
-o2::framework::ServiceSpec CommonServices::deviceContextSpec()
-{
-  return ServiceSpec{
-    .name = "device-context",
-    .init = [](ServiceRegistryRef, DeviceState&, fair::mq::ProgOptions&) -> ServiceHandle {
-      return ServiceHandle{TypeIdHelpers::uniqueId<DeviceContext>(), new DeviceContext()};
-    },
-    .configure = noConfiguration(),
-    .kind = ServiceKind::Serial};
-}
-
 o2::framework::ServiceSpec CommonServices::dataAllocatorSpec()
 {
   return ServiceSpec{
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index a41aa3a886d55..21d0c5a1dcfba 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -17,6 +17,7 @@
 #include "Framework/DataProcessor.h"
 #include "Framework/DataSpecUtils.h"
 #include "Framework/DeviceState.h"
+#include "Framework/DeviceStateEnums.h"
 #include "Framework/DispatchPolicy.h"
 #include "Framework/DispatchControl.h"
 #include "Framework/DanglingContext.h"
@@ -196,11 +197,10 @@ struct locked_execution {
   ~locked_execution() { ref.unlock(); }
 };
 
-DataProcessingDevice::DataProcessingDevice(RunningDeviceRef running, ServiceRegistry& registry, ProcessingPolicies& policies)
+DataProcessingDevice::DataProcessingDevice(RunningDeviceRef running, ServiceRegistry& registry)
   : mRunningDevice{running},
     mConfigRegistry{nullptr},
-    mServiceRegistry{registry},
-    mProcessingPolicies{policies}
+    mServiceRegistry{registry}
 {
   GetConfig()->Subscribe<std::string>("dpl", [&registry = mServiceRegistry](const std::string& key, std::string value) {
     if (key == "cleanup") {
@@ -247,6 +247,7 @@ DataProcessingDevice::DataProcessingDevice(RunningDeviceRef running, ServiceRegi
   mHandles.resize(1);
 
   ServiceRegistryRef ref{mServiceRegistry};
+
   mAwakeHandle = (uv_async_t*)malloc(sizeof(uv_async_t));
   auto& state = ref.get<DeviceState>();
   assert(state.loop);
@@ -1189,18 +1190,18 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
       errorCallback(errorContext);
     };
   } else {
-    context.errorHandling = [&errorPolicy = mProcessingPolicies.error,
-                             &serviceRegistry = mServiceRegistry](RuntimeErrorRef e, InputRecord& record) {
+    context.errorHandling = [&serviceRegistry = mServiceRegistry](RuntimeErrorRef e, InputRecord& record) {
       auto& err = error_from_ref(e);
       /// FIXME: we should pass the salt in, so that the message
       ///        can access information which were stored in the stream.
       ServiceRegistryRef ref{serviceRegistry, ServiceRegistry::globalDeviceSalt()};
       auto& context = ref.get<DataProcessorContext>();
+      auto& deviceContext = ref.get<DeviceContext>();
       O2_SIGNPOST_ID_FROM_POINTER(cid, device, &context);
       BacktraceHelpers::demangled_backtrace_symbols(err.backtrace, err.maxBacktrace, STDERR_FILENO);
       auto& stats = ref.get<DataProcessingStats>();
       stats.updateStats({(int)ProcessingStatsId::EXCEPTION_COUNT, DataProcessingStats::Op::Add, 1});
-      switch (errorPolicy) {
+      switch (deviceContext.processingPolicies.error) {
         case TerminationPolicy::QUIT:
           O2_SIGNPOST_EVENT_EMIT_ERROR(device, cid, "Run", "Exception while running: %{public}s. Rethrowing.", err.what);
           throw e;
@@ -1211,10 +1212,10 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
     };
   }
 
-  auto decideEarlyForward = [&context, &spec, this]() -> bool {
+  auto decideEarlyForward = [&context, &deviceContext, &spec, this]() -> bool {
     /// We must make sure there is no optional
     /// if we want to optimize the forwarding
-    bool canForwardEarly = (spec.forwards.empty() == false) && mProcessingPolicies.earlyForward != EarlyForwardPolicy::NEVER;
+    bool canForwardEarly = (spec.forwards.empty() == false) && deviceContext.processingPolicies.earlyForward != EarlyForwardPolicy::NEVER;
     bool onlyConditions = true;
     bool overriddenEarlyForward = false;
     for (auto& forwarded : spec.forwards) {
@@ -1229,7 +1230,7 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
         break;
       }
 #endif
-      if (DataSpecUtils::partialMatch(forwarded.matcher, o2::header::DataDescription{"RAWDATA"}) && mProcessingPolicies.earlyForward == EarlyForwardPolicy::NORAW) {
+      if (DataSpecUtils::partialMatch(forwarded.matcher, o2::header::DataDescription{"RAWDATA"}) && deviceContext.processingPolicies.earlyForward == EarlyForwardPolicy::NORAW) {
         context.canForwardEarly = false;
         overriddenEarlyForward = true;
         LOG(detail) << "Cannot forward early because of RAWDATA input: " << DataSpecUtils::describe(forwarded.matcher);
@@ -1560,7 +1561,7 @@ void DataProcessingDevice::Run()
     }
   }
 
-  O2_SIGNPOST_END(device, lid, "run_loop", "Run loop completed. Transition handling state %d.", state.transitionHandling);
+  O2_SIGNPOST_END(device, lid, "run_loop", "Run loop completed. Transition handling state %d.", (int)state.transitionHandling);
   auto& spec = ref.get<DeviceSpec const>();
   /// Cleanup messages which are still pending on exit.
   for (size_t ci = 0; ci < spec.inputChannels.size(); ++ci) {
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 900769adb780d..0ea9f18eb65b3 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1092,13 +1092,13 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
     quotaEvaluator = std::make_unique<ComputingQuotaEvaluator>(serviceRef);
     serviceRef.registerService(ServiceRegistryHelpers::handleForService<ComputingQuotaEvaluator>(quotaEvaluator.get()));
 
-    deviceContext = std::make_unique<DeviceContext>();
+    deviceContext = std::make_unique<DeviceContext>(DeviceContext{.processingPolicies = processingPolicies});
     serviceRef.registerService(ServiceRegistryHelpers::handleForService<DeviceSpec const>(&spec));
     serviceRef.registerService(ServiceRegistryHelpers::handleForService<RunningWorkflowInfo const>(&runningWorkflow));
     serviceRef.registerService(ServiceRegistryHelpers::handleForService<DeviceContext>(deviceContext.get()));
     serviceRef.registerService(ServiceRegistryHelpers::handleForService<DriverConfig const>(&driverConfig));
 
-    auto device = std::make_unique<DataProcessingDevice>(ref, serviceRegistry, processingPolicies);
+    auto device = std::make_unique<DataProcessingDevice>(ref, serviceRegistry);
 
     serviceRef.get<RawDeviceService>().setDevice(device.get());
     r.fDevice = std::move(device);

From 9054e0ed21ab9ee1cc70f3290353e573f4bef6aa Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 30 Oct 2025 10:13:23 +0100
Subject: [PATCH 0983/1764] DPL: refactor TransitionState calculation

Move it to a function and make it easily invokable with just a service registry ref.

This should not change the current behavior.

The goal is to be able to trigger the timers also within the input proxy busy loop so
that the timers start at the appropriate moment.
---
 Framework/Core/src/DataProcessingDevice.cxx | 98 +++++++++++----------
 1 file changed, 53 insertions(+), 45 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 21d0c5a1dcfba..aa194b525ca5d 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1331,6 +1331,58 @@ void DataProcessingDevice::Reset()
   ref.get<CallbackService>().call<CallbackService::Id::Reset>();
 }
 
+TransitionHandlingState updateStateTransition(ServiceRegistryRef& ref, ProcessingPolicies const& policies)
+{
+  auto& state = ref.get<DeviceState>();
+  auto& deviceProxy = ref.get<FairMQDeviceProxy>();
+  if (state.transitionHandling != TransitionHandlingState::NoTransition || deviceProxy.newStateRequested() == false) {
+    return state.transitionHandling;
+  }
+  O2_SIGNPOST_ID_FROM_POINTER(lid, device, state.loop);
+  auto& deviceContext = ref.get<DeviceContext>();
+  // Check if we only have timers
+  auto& spec = ref.get<DeviceSpec const>();
+  if (hasOnlyTimers(spec)) {
+    switchState(ref, StreamingState::EndOfStreaming);
+  }
+
+  // We do not do anything in particular if the data processing timeout would go past the exitTransitionTimeout
+  if (deviceContext.dataProcessingTimeout > 0 && deviceContext.dataProcessingTimeout < deviceContext.exitTransitionTimeout) {
+    uv_update_time(state.loop);
+    O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for dataProcessingTimeout.", deviceContext.dataProcessingTimeout);
+    uv_timer_start(deviceContext.dataProcessingGracePeriodTimer, on_data_processing_expired, deviceContext.dataProcessingTimeout * 1000, 0);
+  }
+  if (deviceContext.exitTransitionTimeout != 0 && state.streaming != StreamingState::Idle) {
+    ref.get<CallbackService>().call<CallbackService::Id::ExitRequested>(ServiceRegistryRef{ref});
+    uv_update_time(state.loop);
+    O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for exitTransitionTimeout.",
+                           deviceContext.exitTransitionTimeout);
+    uv_timer_start(deviceContext.gracePeriodTimer, on_transition_requested_expired, deviceContext.exitTransitionTimeout * 1000, 0);
+    bool onlyGenerated = hasOnlyGenerated(spec);
+    int timeout = onlyGenerated ? deviceContext.dataProcessingTimeout : deviceContext.exitTransitionTimeout;
+    if (policies.termination == TerminationPolicy::QUIT && DefaultsHelpers::onlineDeploymentMode() == false) {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. Waiting for %d seconds before quitting.", timeout);
+    } else {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop",
+                                  "New state requested. Waiting for %d seconds before %{public}s",
+                                  timeout,
+                                  onlyGenerated ? "dropping remaining input and switching to READY state." : "switching to READY state.");
+    }
+    return TransitionHandlingState::Requested;
+  } else {
+    if (deviceContext.exitTransitionTimeout == 0 && policies.termination == TerminationPolicy::QUIT) {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. No timeout set, quitting immediately as per --completion-policy");
+    } else if (deviceContext.exitTransitionTimeout == 0 && policies.termination != TerminationPolicy::QUIT) {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. No timeout set, switching to READY state immediately");
+    } else if (policies.termination == TerminationPolicy::QUIT) {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state pending and we are already idle, quitting immediately as per --completion-policy");
+    } else {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state pending and we are already idle, switching to READY immediately.");
+    }
+    return TransitionHandlingState::Expired;
+  }
+}
+
 void DataProcessingDevice::Run()
 {
   ServiceRegistryRef ref{mServiceRegistry};
@@ -1383,51 +1435,7 @@ void DataProcessingDevice::Run()
         shouldNotWait = true;
         state.loopReason |= DeviceState::LoopReason::NEW_STATE_PENDING;
       }
-      if (state.transitionHandling == TransitionHandlingState::NoTransition && NewStatePending()) {
-        state.transitionHandling = TransitionHandlingState::Requested;
-        auto& deviceContext = ref.get<DeviceContext>();
-        // Check if we only have timers
-        auto& spec = ref.get<DeviceSpec const>();
-        if (hasOnlyTimers(spec)) {
-          switchState(ref, StreamingState::EndOfStreaming);
-        }
-
-        // We do not do anything in particular if the data processing timeout would go past the exitTransitionTimeout
-        if (deviceContext.dataProcessingTimeout > 0 && deviceContext.dataProcessingTimeout < deviceContext.exitTransitionTimeout) {
-          uv_update_time(state.loop);
-          O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for dataProcessingTimeout.", deviceContext.dataProcessingTimeout);
-          uv_timer_start(deviceContext.dataProcessingGracePeriodTimer, on_data_processing_expired, deviceContext.dataProcessingTimeout * 1000, 0);
-        }
-        if (deviceContext.exitTransitionTimeout != 0 && state.streaming != StreamingState::Idle) {
-          state.transitionHandling = TransitionHandlingState::Requested;
-          ref.get<CallbackService>().call<CallbackService::Id::ExitRequested>(ServiceRegistryRef{ref});
-          uv_update_time(state.loop);
-          O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for exitTransitionTimeout.",
-                                 deviceContext.exitTransitionTimeout);
-          uv_timer_start(deviceContext.gracePeriodTimer, on_transition_requested_expired, deviceContext.exitTransitionTimeout * 1000, 0);
-          bool onlyGenerated = hasOnlyGenerated(spec);
-          int timeout = onlyGenerated ? deviceContext.dataProcessingTimeout : deviceContext.exitTransitionTimeout;
-          if (mProcessingPolicies.termination == TerminationPolicy::QUIT && DefaultsHelpers::onlineDeploymentMode() == false) {
-            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. Waiting for %d seconds before quitting.", timeout);
-          } else {
-            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop",
-                                        "New state requested. Waiting for %d seconds before %{public}s",
-                                        timeout,
-                                        onlyGenerated ? "dropping remaining input and switching to READY state." : "switching to READY state.");
-          }
-        } else {
-          state.transitionHandling = TransitionHandlingState::Expired;
-          if (deviceContext.exitTransitionTimeout == 0 && mProcessingPolicies.termination == TerminationPolicy::QUIT) {
-            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. No timeout set, quitting immediately as per --completion-policy");
-          } else if (deviceContext.exitTransitionTimeout == 0 && mProcessingPolicies.termination != TerminationPolicy::QUIT) {
-            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. No timeout set, switching to READY state immediately");
-          } else if (mProcessingPolicies.termination == TerminationPolicy::QUIT) {
-            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state pending and we are already idle, quitting immediately as per --completion-policy");
-          } else {
-            O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state pending and we are already idle, switching to READY immediately.");
-          }
-        }
-      }
+      state.transitionHandling = updateStateTransition(ref, ref.get<DeviceContext>().processingPolicies);
       // If we are Idle, we can then consider the transition to be expired.
       if (state.transitionHandling == TransitionHandlingState::Requested && state.streaming == StreamingState::Idle) {
         O2_SIGNPOST_EVENT_EMIT(device, lid, "run_loop", "State transition requested and we are now in Idle. We can consider it to be completed.");

From 564803bfcb238a5d6486c380278e6253347b8cc9 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 30 Oct 2025 21:15:40 +0100
Subject: [PATCH 0984/1764] ITS: fix truth seeding for events which are not in
 acceptance (#14782)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index a546056075700..0c4ecb0b12df1 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -530,11 +530,12 @@ void VertexerTraits<nLayers>::addTruthSeedingVertices()
       }
       Vertex vert;
       vert.setTimeStamp(rofId);
-      vert.setNContributors(std::ranges::count_if(mcReader.getTracks(iSrc, iEve), [](const auto& trk) {
-        return trk.isPrimary() && trk.GetPt() > 0.2 && std::abs(trk.GetEta()) < 1.3;
-      }));
+      // set minimum to 1 sometimes for diffractive events there is nothing acceptance
+      vert.setNContributors(std::max(1L, std::ranges::count_if(mcReader.getTracks(iSrc, iEve), [](const auto& trk) {
+                                       return trk.isPrimary() && trk.GetPt() > 0.05 && std::abs(trk.GetEta()) < 1.1;
+                                     })));
       vert.setXYZ((float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ());
-      vert.setChi2(1);
+      vert.setChi2(1); // not used as constraint
       constexpr float cov = 50e-9;
       vert.setCov(cov, cov, cov, cov, cov, cov);
       vertices[rofId].vertices.push_back(vert);

From c6f8660c5bb98f3f4d79a137a7f40a8144ecdfbb Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Thu, 30 Oct 2025 21:37:28 +0100
Subject: [PATCH 0985/1764] Update ALICE3 tracker segmentation + chip indexing
 scheme (#14776)

---
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |  69 ++--
 .../ALICE3/TRK/base/include/TRKBase/Specs.h   |   8 +-
 .../TRK/base/include/TRKBase/TRKBaseParam.h   |   7 +
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      | 307 +++++++++++++---
 .../ALICE3/TRK/simulation/CMakeLists.txt      |   6 +-
 .../include/TRKSimulation/Detector.h          |  32 +-
 .../simulation/include/TRKSimulation/Hit.h    | 149 ++++++++
 .../include/TRKSimulation/TRKLayer.h          |  29 +-
 .../ALICE3/TRK/simulation/src/Detector.cxx    | 120 ++++---
 .../ALICE3/TRK/simulation/src/Hit.cxx         |  34 ++
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx    | 330 ++++++++++++++----
 .../TRK/simulation/src/TRKSimulationLinkDef.h |   3 +
 12 files changed, 872 insertions(+), 222 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/simulation/src/Hit.cxx

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index 0e9ff8727a977..f900065ad738a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -48,8 +48,13 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static const char* getTRKPetalDiskPattern() { return sPetalDiskName.c_str(); }
   static const char* getTRKPetalLayerPattern() { return sPetalLayerName.c_str(); }
   static const char* getTRKStavePattern() { return sStaveName.c_str(); }
+  static const char* getTRKHalfStavePattern() { return sHalfStaveName.c_str(); }
+  static const char* getTRKModulePattern() { return sModuleName.c_str(); }
   static const char* getTRKChipPattern() { return sChipName.c_str(); }
   static const char* getTRKSensorPattern() { return sSensorName.c_str(); }
+  static const char* getTRKDeadzonePattern() { return sDeadzoneName.c_str(); }
+  static const char* getTRKMetalStackPattern() { return sMetalStackName.c_str(); }
+
   static const char* getTRKWrapVolPattern() { return sWrapperVolumeName.c_str(); }
 
   int getNumberOfChips() const { return mSize; }
@@ -63,6 +68,8 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   int extractNumberOfChipsPerPetalVD() const;
   int extractNumberOfStavesMLOT(int lay) const;
   int extractNumberOfHalfStavesMLOT(int lay) const;
+  int extractNumberOfModulesMLOT(int lay) const;
+  int extractNumberOfChipsMLOT(int lay) const;
 
   /// Extract number following the prefix in the name string
   int extractVolumeCopy(const char* name, const char* prefix) const;
@@ -75,33 +82,39 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   void setOwner(bool v) { mOwner = v; }
 
   void Print(Option_t* opt = "") const;
-  void PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const;
+  void PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int mod, int chip) const;
 
-  int getLayer(int index) const;
-  int getStave(int index) const;
-  int getHalfStave(int index) const;
   int getSubDetID(int index) const;
   int getPetalCase(int index) const;
   int getDisk(int index) const;
+  int getLayer(int index) const;
+  int getStave(int index) const;
+  int getHalfStave(int index) const;
+  int getModule(int index) const;
+  int getChip(int index) const;
 
-  /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave /// TODO: retrieve also from chip when chips will be available
+  /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave, half stave, module, chip
   /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
   /// \param int petalcase The petal case number for VD, from 0 to 3
   /// \param int disk The disk number for VD, from 0 to 5
   /// \param int lay The layer number. Starting from 0 both for VD and MLOT
   /// \param int stave The stave number for MLOT. Starting from 0
   /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
-  int getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const;
+  /// \param int module The module number for MLOT, from 0 to 10 (or 20)
+  /// \param int chip The chip number for MLOT, from 0 to 8
+  unsigned short getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int mod, int chip) const;
 
-  /// This routine computes the chip index number from the subDetID, volume, layer, stave /// TODO: retrieve also from chip when chips will be available
+  /// This routine computes the chip index number from the subDetID, volume, layer, stave, half stave, module, chip
   /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
   /// \param int volume is needed only with the current configuration for VD where each single element is a volume. // TODO: when the geometry naming scheme will be changed, change this method
   /// \param int lay The layer number for the MLOT. In the current configuration for VD this is not needed. // TODO: when the geometry naming scheme will be changed, change this method
   /// \param int stave The stave number in each layer for MLOT. Starting from 0.
   /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
-  int getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave) const;
+  /// \param int module The module number for MLOT, from 0 to 10 (or 20)
+  /// \param int chip The chip number for MLOT, from 0 to 8
+  unsigned short getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave, int mod, int chip) const;
 
-  /// This routine computes subDetID, petal, disk, layer, stave given the chip index number /// TODO: copute also from chip when chips will be available
+  /// This routine computes subDetID, petal, disk, layer, stave, half stave, module, chip, given the chip index number
   /// \param int index The chip index number, starting from 0
   /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
   /// \param int petalcase The petal case number for VD, from 0 to 3
@@ -109,10 +122,12 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   /// \param int lay The layer number. Starting from 0 both for VD and MLOT
   /// \param int stave The stave number for MLOT. Starting from 0
   /// \param int halfstave The half stave number for MLOT. Can be 0 or 1
-  bool getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave) const;
+  /// \param int module The module number for MLOT, from 0 to 10 (or 20)
+  /// \param int chip The chip number for MLOT, from 0 to 8
+  bool getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave, int& mod, int& chip) const;
 
-  int getLastChipIndex(int lay) const { return mLastChipIndex[lay]; }
-  int getFirstChipIndex(int lay, int petalcase, int subDetID) const
+  unsigned short getLastChipIndex(int lay) const { return mLastChipIndex[lay]; }
+  unsigned short getFirstChipIndex(int lay, int petalcase, int subDetID) const
   {
     /// Get the first chip index of the active petal (VD) or layer (MLOT)
     if (subDetID == 0) { // VD
@@ -138,7 +153,8 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   static const char* composeSymNameLayer(int d, int layer);
   static const char* composeSymNameStave(int d, int layer);
-  static const char* composeSymNameChip(int d, int lr);
+  static const char* composeSymNameModule(int d, int layer);
+  static const char* composeSymNameChip(int d, int layer);
   static const char* composeSymNameSensor(int d, int layer);
 
  protected:
@@ -151,25 +167,36 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static std::string sPetalDiskName;
   static std::string sPetalLayerName;
   static std::string sStaveName;
+  static std::string sHalfStaveName;
+  static std::string sModuleName;
   static std::string sChipName;
   static std::string sSensorName;
-  static std::string sWrapperVolumeName; ///< Wrapper volume name
+  static std::string sDeadzoneName;
+  static std::string sMetalStackName;
+
+  static std::string sWrapperVolumeName; ///< Wrapper volume name, not implemented at the moment
 
   Int_t mNumberOfLayersMLOT;                   ///< number of layers
   Int_t mNumberOfActivePartsVD;                ///< number of layers
   Int_t mNumberOfLayersVD;                     ///< number of layers
   Int_t mNumberOfPetalsVD;                     ///< number of Petals = chip in each VD layer
   Int_t mNumberOfDisksVD;                      ///< number of Disks = 6
-  std::vector<int> mLastChipIndex;             ///< max ID of the detctor in the petal(VD) or layer(MLOT)
-  std::vector<int> mLastChipIndexVD;           ///< max ID of the detctor in the layer for the VD
-  std::vector<int> mLastChipIndexMLOT;         ///< max ID of the detctor in the layer for the MLOT
+  std::vector<int> mNumberOfStaves;            ///< Number Of Staves per layer in ML/OT
+  std::vector<int> mNumberOfHalfStaves;        ///< Number Of Half staves in each stave of the layer in ML/OT
+  std::vector<int> mNumberOfModules;           ///< Number Of Modules per stave (half stave) in ML/OT
+  std::vector<int> mNumberOfChips;             ///< number of chips per module in ML/OT
   std::vector<int> mNumberOfChipsPerLayerVD;   ///< number of chips per layer VD ( =  number of petals)
-  std::vector<int> mNumberOfChipsPerLayerMLOT; ///< number of chips per layer MLOT ( = 1 for the moment)
+  std::vector<int> mNumberOfChipsPerLayerMLOT; ///< number of chips per layer MLOT
   std::vector<int> mNumbersOfChipPerDiskVD;    ///< numbersOfChipPerDiskVD
   std::vector<int> mNumberOfChipsPerPetalVD;   ///< numbersOfChipPerPetalVD
-  std::vector<int> mNumberOfStaves;            ///< Number Of Staves per layer in ML/OT
-  std::vector<int> mNumberOfHalfStaves;        ///< Number Of Staves in each stave of the layer in ML/OT
-  std::array<char, MAXLAYERS> mLayerToWrapper; ///< Layer to wrapper correspondence
+  // std::vector<int> mNumberOfChipsPerStave;     ///< number of chips per stave in ML/OT
+  // std::vector<int> mNumberOfChipsPerHalfStave; ///< number of chips per half stave in ML/OT
+  // std::vector<int> mNumberOfChipsPerModule; ///< number of chips per module in ML/OT
+  std::vector<unsigned short> mLastChipIndex;     ///< max ID of the detctor in the petal(VD) or layer(MLOT)
+  std::vector<unsigned short> mLastChipIndexVD;   ///< max ID of the detctor in the layer for the VD
+  std::vector<unsigned short> mLastChipIndexMLOT; ///< max ID of the detctor in the layer for the MLOT
+
+  std::array<char, MAXLAYERS> mLayerToWrapper; ///< Layer to wrapper correspondence, not implemented yet
 
   bool mOwner = true; //! is it owned by the singleton?
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index bd95e5207b7ee..559d8f6154c59 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -22,7 +22,7 @@
 // Each TGeoShape has the following properties
 // length: dimension in z-axis
 // width: dimension in xy-axes
-// color: for visulisation
+// color: for visualisation
 namespace o2::trk::constants
 {
 // Default unit of TGeo = cm
@@ -84,13 +84,11 @@ constexpr int nRows{static_cast<int>(width / pitchX)};                       //
 constexpr int nCols{static_cast<int>(length / pitchZ)};                      // number of rows in the chip
 constexpr double totalThickness{silicon::thickness + metalstack::thickness}; // total thickness of the chip
 /// Set to 0 for the moment, to be adjusted with the actual design of the chip if needed
-static constexpr float PassiveEdgeReadOut = 0.f; // width of the readout edge (Passive bottom)
-static constexpr float PassiveEdgeTop = 0.f;     // Passive area on top
-static constexpr float PassiveEdgeSide = 0.f;    // width of Passive area on left/right of the sensor
+static constexpr float passiveEdgeReadOut{1.5 * mm}; // width of the readout edge
 } // namespace chip
 namespace gaps
 {
-constexpr double interChips{0.2 * mm};         // gap between the chips
+constexpr double interChips{50 * mu};          // gap between the chips
 constexpr double outerEdgeLongSide{1 * mm};    // gap between the chips and the outer edges (long side)
 constexpr double outerEdgeShortSide{0.1 * mm}; // gap between the chips and the outer edges (short side)
 } // namespace gaps
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index 63c95b1e6b2f6..3f3f656c4b417 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -20,6 +20,11 @@ namespace o2
 namespace trk
 {
 
+enum eOverallGeom {
+  kDefaultRadii = 0, // After Upgrade Days March 2024
+  kModRadii,
+};
+
 enum eLayout {
   kCylinder = 0,
   kTurboStaves,
@@ -31,6 +36,8 @@ struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   float serviceTubeX0 = 0.02f; // X0 Al2O3
   Bool_t irisOpen = false;
 
+  eOverallGeom overallGeom = kDefaultRadii; // Overall geometry option, to be used in Detector::buildTRKMiddleOuterLayers
+
   eLayout layoutML = kCylinder; // Type of segmentation for the middle layers
   eLayout layoutOL = kCylinder; // Type of segmentation for the outer layers
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index b516918f6fdaa..3eadeed4b56f3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -13,6 +13,8 @@
 #include <TGeoManager.h>
 #include "TRKBase/SegmentationChip.h"
 
+#include <limits>
+
 using Segmentation = o2::trk::SegmentationChip;
 
 namespace o2
@@ -29,8 +31,12 @@ std::string GeometryTGeo::sPetalName = "PETALCASE";
 std::string GeometryTGeo::sPetalDiskName = "DISK";
 std::string GeometryTGeo::sPetalLayerName = "LAYER";
 std::string GeometryTGeo::sStaveName = "TRKStave";
+std::string GeometryTGeo::sHalfStaveName = "TRKHalfStave";
+std::string GeometryTGeo::sModuleName = "TRKModule";
 std::string GeometryTGeo::sChipName = "TRKChip";
 std::string GeometryTGeo::sSensorName = "TRKSensor";
+std::string GeometryTGeo::sDeadzoneName = "TRKDeadzone";
+std::string GeometryTGeo::sMetalStackName = "TRKMetalStack";
 
 std::string GeometryTGeo::sWrapperVolumeName = "TRKUWrapVol"; ///< Wrapper volume name, not implemented at the moment
 
@@ -77,18 +83,24 @@ void GeometryTGeo::Build(int loadTrans)
 
   mNumberOfStaves.resize(mNumberOfLayersMLOT);
   mNumberOfHalfStaves.resize(mNumberOfLayersMLOT);
-  mLastChipIndex.resize(mNumberOfPetalsVD + mNumberOfLayersMLOT);
-  mLastChipIndexVD.resize(mNumberOfPetalsVD);
-  mLastChipIndexMLOT.resize(mNumberOfLayersMLOT); /// ML and OT are part of TRK as the same detector, without disks
+  mNumberOfModules.resize(mNumberOfLayersMLOT);
+  mNumberOfChips.resize(mNumberOfLayersMLOT);
+
   mNumberOfChipsPerLayerVD.resize(mNumberOfLayersVD);
   mNumberOfChipsPerLayerMLOT.resize(mNumberOfLayersMLOT);
   mNumbersOfChipPerDiskVD.resize(mNumberOfDisksVD);
   mNumberOfChipsPerPetalVD.resize(mNumberOfPetalsVD);
 
+  mLastChipIndex.resize(mNumberOfPetalsVD + mNumberOfLayersMLOT);
+  mLastChipIndexVD.resize(mNumberOfPetalsVD);
+  mLastChipIndexMLOT.resize(mNumberOfLayersMLOT); /// ML and OT are part of TRK as the same detector, without disks
+
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
     std::cout << "Layer MLOT: " << i << std::endl;
     mNumberOfStaves[i] = extractNumberOfStavesMLOT(i);
     mNumberOfHalfStaves[i] = extractNumberOfHalfStavesMLOT(i);
+    mNumberOfModules[i] = extractNumberOfModulesMLOT(i);
+    mNumberOfChips[i] = extractNumberOfChipsMLOT(i);
   }
 
   int numberOfChipsTotal = 0;
@@ -103,13 +115,13 @@ void GeometryTGeo::Build(int loadTrans)
 
   /// filling the information for the MLOT
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
-    mNumberOfChipsPerLayerMLOT[i] = extractNumberOfStavesMLOT(i) * extractNumberOfHalfStavesMLOT(i); // for the moment, considering 1 half stave = 1 chip. TODO: add the final segmentation in chips
+    mNumberOfChipsPerLayerMLOT[i] = mNumberOfStaves[i] * mNumberOfHalfStaves[i] * mNumberOfModules[i] * mNumberOfChips[i];
     numberOfChipsTotal += mNumberOfChipsPerLayerMLOT[i];
     mLastChipIndex[i + mNumberOfPetalsVD] = numberOfChipsTotal - 1;
     mLastChipIndexMLOT[i] = numberOfChipsTotal - 1;
   }
 
-  setSize(numberOfChipsTotal); /// temporary, number of chips = number of staves and active parts
+  setSize(numberOfChipsTotal);
   fillMatrixCache(loadTrans);
 }
 
@@ -132,9 +144,7 @@ int GeometryTGeo::getPetalCase(int index) const
   int subDetID = getSubDetID(index);
   if (subDetID == 1) {
     return -1;
-  }
-
-  else if (index <= mLastChipIndexVD[mNumberOfPetalsVD - 1]) {
+  } else if (index <= mLastChipIndexVD[mNumberOfPetalsVD - 1]) {
     while (index > mLastChipIndexVD[petalcase]) {
       petalcase++;
     }
@@ -142,6 +152,22 @@ int GeometryTGeo::getPetalCase(int index) const
   return petalcase;
 }
 
+//__________________________________________________________________________
+int GeometryTGeo::getDisk(int index) const
+{
+  int subDetID = getSubDetID(index);
+  int petalcase = getPetalCase(index);
+
+  if (subDetID == 0) { /// VD
+    if (index % mNumberOfChipsPerPetalVD[petalcase] < mNumberOfLayersVD) {
+      return -1; /// layers
+    }
+    return (index % mNumberOfChipsPerPetalVD[petalcase]) - mNumberOfLayersVD;
+  }
+
+  return -1; /// not found or ML/OT
+}
+
 //__________________________________________________________________________
 int GeometryTGeo::getLayer(int index) const
 {
@@ -158,7 +184,7 @@ int GeometryTGeo::getLayer(int index) const
     while (index > mLastChipIndex[lay]) {
       lay++;
     }
-    return lay - mNumberOfPetalsVD; /// numeration of MLOT layesrs  starting from 0
+    return lay - mNumberOfPetalsVD; /// numeration of MLOT layers starting from 0
   }
   return -1; /// -1 if not found
 }
@@ -174,9 +200,23 @@ int GeometryTGeo::getStave(int index) const
   } else if (subDetID == 1) { /// MLOT
     int lay = getLayer(index);
     index -= getFirstChipIndex(lay, petalcase, subDetID); // get the index of the sensing element in the layer
-    return index / mNumberOfHalfStaves[lay];
+
+    const int Nhs = mNumberOfHalfStaves[lay];
+    const int Nmod = mNumberOfModules[lay];
+    const int Nchip = mNumberOfChips[lay];
+
+    if (Nhs == 2) {
+      int chipsPerModule = Nchip;
+      int chipsPerHalfStave = Nmod * chipsPerModule;
+      int chipsPerStave = Nhs * chipsPerHalfStave;
+      return index / chipsPerStave;
+    } else if (Nhs == 1) {
+      int chipsPerModule = Nchip;
+      int chipsPerStave = Nmod * chipsPerModule;
+      return index / chipsPerStave;
+    }
   }
-  return -1; /// not found
+  return -1;
 }
 
 //__________________________________________________________________________
@@ -185,36 +225,89 @@ int GeometryTGeo::getHalfStave(int index) const
   int subDetID = getSubDetID(index);
   int lay = getLayer(index);
   int petalcase = getPetalCase(index);
-  int stave = getStave(index);
 
   if (subDetID == 0) { /// VD
     return -1;
   } else if (subDetID == 1) { /// MLOT
     int lay = getLayer(index);
     index -= getFirstChipIndex(lay, petalcase, subDetID); // get the index of the sensing element in the layer
-    return index % 2;                                     /// 0 = half stave left, 1 = half stave right, as geometry is filled /// TODO: generalize once chips will be in place. Can it be working also with chips?
+
+    const int Nhs = mNumberOfHalfStaves[lay];
+    const int Nmod = mNumberOfModules[lay];
+    const int Nchip = mNumberOfChips[lay];
+
+    int chipsPerModule = Nchip;
+    int chipsPerHalfStave = Nmod * chipsPerModule;
+    int chipsPerStave = Nhs * chipsPerHalfStave;
+
+    int rem = index % chipsPerStave;
+    return rem / chipsPerHalfStave; // 0 = left, 1 = right
   }
-  return -1; /// not found
+  return -1;
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::getDisk(int index) const
+int GeometryTGeo::getModule(int index) const
 {
   int subDetID = getSubDetID(index);
+  int lay = getLayer(index);
   int petalcase = getPetalCase(index);
 
   if (subDetID == 0) { /// VD
-    if (index % mNumberOfChipsPerPetalVD[petalcase] < mNumberOfLayersVD) {
-      return -1; /// layers
+    return -1;
+  } else if (subDetID == 1) { /// MLOT
+    int lay = getLayer(index);
+    index -= getFirstChipIndex(lay, petalcase, subDetID); // get the index of the sensing element in the layer
+
+    const int Nhs = mNumberOfHalfStaves[lay];
+    const int Nmod = mNumberOfModules[lay];
+    const int Nchip = mNumberOfChips[lay];
+
+    if (Nhs == 2) {
+      int chipsPerModule = Nchip;
+      int chipsPerHalfStave = Nmod * chipsPerModule;
+      int rem = index % (Nhs * chipsPerHalfStave);
+      rem = rem % chipsPerHalfStave;
+      return rem / chipsPerModule;
+    } else if (Nhs == 1) {
+      int chipsPerModule = Nchip;
+      int rem = index % (Nmod * chipsPerModule);
+      return rem / chipsPerModule;
     }
-    return (index % mNumberOfChipsPerPetalVD[petalcase]) - mNumberOfLayersVD;
   }
+  return -1;
+}
 
-  return -1; /// not found or ML/OT
+//__________________________________________________________________________
+int GeometryTGeo::getChip(int index) const
+{
+  int subDetID = getSubDetID(index);
+  int lay = getLayer(index);
+  int petalcase = getPetalCase(index);
+
+  if (subDetID == 0) { /// VD
+    return -1;
+  } else if (subDetID == 1) { /// MLOT
+    int lay = getLayer(index);
+    index -= getFirstChipIndex(lay, petalcase, subDetID); // get the index of the sensing element in the layer
+
+    const int Nhs = mNumberOfHalfStaves[lay];
+    const int Nmod = mNumberOfModules[lay];
+    const int Nchip = mNumberOfChips[lay];
+
+    if (Nhs == 2) {
+      int chipsPerModule = Nchip;
+      return index % chipsPerModule;
+    } else if (Nhs == 1) {
+      int chipsPerModule = Nchip;
+      return index % chipsPerModule;
+    }
+  }
+  return -1;
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const
+unsigned short GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int mod, int chip) const
 {
   if (subDetID == 0) { // VD
     if (lay == -1) {   // disk
@@ -222,41 +315,70 @@ int GeometryTGeo::getChipIndex(int subDetID, int petalcase, int disk, int lay, i
     } else { // layer
       return getFirstChipIndex(lay, petalcase, subDetID) + lay;
     }
-  } else if (subDetID == 1) {            // MLOT
-    if (mNumberOfHalfStaves[lay] == 2) { // staggered geometry
-      return getFirstChipIndex(lay, petalcase, subDetID) + stave * mNumberOfHalfStaves[lay] + halfstave;
-    } else if (mNumberOfHalfStaves[lay] == 1) { // turbo geometry
-      return getFirstChipIndex(lay, petalcase, subDetID) + stave;
+  } else if (subDetID == 1) {                 // MLOT
+    const int Nhs = mNumberOfHalfStaves[lay]; // 1 or 2
+    const int Nmod = mNumberOfModules[lay];   // module per half-stave (per stave if Nhs==1)
+    const int Nchip = mNumberOfChips[lay];    // chips per module
+
+    if (Nhs == 2) { // staggered geometry: layer -> stave -> halfstave -> mod -> chip
+      int chipsPerModule = Nchip;
+      int chipsPerHalfStave = Nmod * chipsPerModule;
+      int chipsPerStave = Nhs * chipsPerHalfStave;
+      return getFirstChipIndex(lay, petalcase, subDetID) + stave * chipsPerStave + halfstave * chipsPerHalfStave + mod * chipsPerModule + chip;
+    } else if (Nhs == 1) { // turbo geometry: layer -> stave -> mod -> chip (no halfstave)
+      int chipsPerModule = Nchip;
+      int chipsPerStave = Nmod * chipsPerModule;
+      return getFirstChipIndex(lay, petalcase, subDetID) + stave * chipsPerStave + mod * chipsPerModule + chip;
     }
   }
-  return -1; // not found
+
+  LOGP(warning, "Chip index not found for subDetID %d, petalcase %d, disk %d, layer %d, stave %d, halfstave %d, module %d, chip %d, returning numeric limit", subDetID, petalcase, disk, lay, stave, halfstave, mod, chip);
+  return std::numeric_limits<unsigned short>::max(); // not found
 }
 
 //__________________________________________________________________________
-int GeometryTGeo::getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave) const
+unsigned short GeometryTGeo::getChipIndex(int subDetID, int volume, int lay, int stave, int halfstave, int mod, int chip) const
 {
   if (subDetID == 0) { // VD
     return volume;     /// In the current configuration for VD, each volume is the sensor element = chip. // TODO: when the geometry naming scheme will be changed, change this method
 
-  } else if (subDetID == 1) {            // MLOT
-    if (mNumberOfHalfStaves[lay] == 2) { // staggered geometry
-      return getFirstChipIndex(lay, -1, subDetID) + stave * mNumberOfHalfStaves[lay] + halfstave;
-    } else if (mNumberOfHalfStaves[lay] == 1) { // turbo geometry
-      return getFirstChipIndex(lay, -1, subDetID) + stave;
+  } else if (subDetID == 1) {                 // MLOT
+    const int Nhs = mNumberOfHalfStaves[lay]; // 1 or 2
+    const int Nmod = mNumberOfModules[lay];   // module per half-stave (per stave if Nhs==1)
+    const int Nchip = mNumberOfChips[lay];    // chips per module
+
+    if (Nhs == 2) { // staggered geometry: layer -> stave -> halfstave -> mod -> chip
+      int chipsPerModule = Nchip;
+      int chipsPerHalfStave = Nmod * chipsPerModule;
+      int chipsPerStave = Nhs * chipsPerHalfStave;
+      return getFirstChipIndex(lay, -1, subDetID) + stave * chipsPerStave + halfstave * chipsPerHalfStave + mod * chipsPerModule + chip;
+    } else if (Nhs == 1) { // turbo geometry: layer -> stave -> mod -> chip (no halfstave)
+      int chipsPerModule = Nchip;
+      int chipsPerStave = Nmod * chipsPerModule;
+      return getFirstChipIndex(lay, -1, subDetID) + stave * chipsPerStave + mod * chipsPerModule + chip;
     }
   }
-  return -1; // not found
+
+  LOGP(warning, "Chip index not found for subDetID %d, volume %d, layer %d, stave %d, halfstave %d, module %d, chip %d, returning numeric limit", subDetID, volume, lay, stave, halfstave, mod, chip);
+  return std::numeric_limits<unsigned short>::max(); // not found
 }
 
 //__________________________________________________________________________
-bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave) const
+bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk, int& lay, int& stave, int& halfstave, int& mod, int& chip) const
 {
   subDetID = getSubDetID(index);
   petalcase = getPetalCase(index);
   disk = getDisk(index);
   lay = getLayer(index);
   stave = getStave(index);
+  if (mNumberOfHalfStaves[lay] == 2) {
+    halfstave = getHalfStave(index);
+  } else {
+    halfstave = 0; // if not staggered geometry, return 0
+  }
   halfstave = getHalfStave(index);
+  mod = getModule(index);
+  chip = getChip(index);
 
   return kTRUE;
 }
@@ -265,10 +387,10 @@ bool GeometryTGeo::getChipID(int index, int& subDetID, int& petalcase, int& disk
 TString GeometryTGeo::getMatrixPath(int index) const
 {
 
-  int subDetID, petalcase, disk, layer, stave, halfstave; //// TODO: add chips in a second step
-  getChipID(index, subDetID, petalcase, disk, layer, stave, halfstave);
+  int subDetID, petalcase, disk, layer, stave, halfstave, mod, chip;
+  getChipID(index, subDetID, petalcase, disk, layer, stave, halfstave, mod, chip);
 
-  // PrintChipID(index, subDetID, petalcase, disk, layer, stave, halfstave);
+  // PrintChipID(index, subDetID, petalcase, disk, layer, stave, halfstave, mod, chip);
 
   // TString path = "/cave_1/barrel_1/TRKV_2/TRKLayer0_1/TRKStave0_1/TRKChip0_1/TRKSensor0_1/"; /// dummy path, to be used for tests
   TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
@@ -286,15 +408,15 @@ TString GeometryTGeo::getMatrixPath(int index) const
       // path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKChipPattern(), layer);   // PETALCASEx_LAYERy_TRKChipy_1
       path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKSensorPattern(), layer); // PETALCASEx_LAYERy_TRKSensory_1
     }
-  } else if (subDetID == 1) {                                          // MLOT
-    path += Form("%s%d_1/", getTRKLayerPattern(), layer);              // TRKLayerx_1
-    path += Form("%s%d_%d/", getTRKStavePattern(), layer, stave);      // TRKStavex_y
-    if (mNumberOfHalfStaves[layer] == 2) {                             // staggered geometry
-      path += Form("%s%d_%d/", getTRKChipPattern(), layer, halfstave); // TRKChipx_0/1
-    } else if (mNumberOfHalfStaves[layer] == 1) {                      // turbo geometry
-      path += Form("%s%d_1/", getTRKChipPattern(), layer);             // TRKChipx_1
+  } else if (subDetID == 1) {                                               // MLOT
+    path += Form("%s%d_1/", getTRKLayerPattern(), layer);                   // TRKLayerx_1
+    path += Form("%s%d_%d/", getTRKStavePattern(), layer, stave);           // TRKStavex_y
+    if (mNumberOfHalfStaves[layer] == 2) {                                  // staggered geometry
+      path += Form("%s%d_%d/", getTRKHalfStavePattern(), layer, halfstave); // TRKHalfStavex_y
     }
-    path += Form("%s%d_1/", getTRKSensorPattern(), layer); // TRKSensorx_1
+    path += Form("%s%d_%d/", getTRKModulePattern(), layer, mod); // TRKModulx_y
+    path += Form("%s%d_%d/", getTRKChipPattern(), layer, chip);  // TRKChipx_y
+    path += Form("%s%d_1/", getTRKSensorPattern(), layer);       // TRKSensorx_1
   }
   return path;
 }
@@ -372,25 +494,30 @@ void GeometryTGeo::fillMatrixCache(int mask)
 //__________________________________________________________________________
 
 #ifdef ENABLE_UPGRADES
-const char* GeometryTGeo::composeSymNameLayer(int d, int lr)
+const char* GeometryTGeo::composeSymNameLayer(int d, int layer)
 {
-  return Form("%s/%s%d", composeSymNameTRK(d), getTRKLayerPattern(), lr);
+  return Form("%s/%s%d", composeSymNameTRK(d), getTRKLayerPattern(), layer);
 }
 #endif
 
-const char* GeometryTGeo::composeSymNameStave(int d, int lr)
+const char* GeometryTGeo::composeSymNameStave(int d, int layer)
 {
-  return Form("%s/%s%d", composeSymNameLayer(d, lr), getTRKStavePattern(), lr);
+  return Form("%s/%s%d", composeSymNameLayer(d, layer), getTRKStavePattern(), layer);
 }
 
-const char* GeometryTGeo::composeSymNameChip(int d, int lr)
+const char* GeometryTGeo::composeSymNameModule(int d, int layer)
 {
-  return Form("%s/%s%d", composeSymNameStave(d, lr), getTRKChipPattern(), lr);
+  return Form("%s/%s%d", composeSymNameStave(d, layer), getTRKModulePattern(), layer);
 }
 
-const char* GeometryTGeo::composeSymNameSensor(int d, int lr)
+const char* GeometryTGeo::composeSymNameChip(int d, int layer)
 {
-  return Form("%s/%s%d", composeSymNameChip(d, lr), getTRKSensorPattern(), lr);
+  return Form("%s/%s%d", composeSymNameStave(d, layer), getTRKChipPattern(), layer);
+}
+
+const char* GeometryTGeo::composeSymNameSensor(int d, int layer)
+{
+  return Form("%s/%s%d", composeSymNameChip(d, layer), getTRKSensorPattern(), layer);
 }
 
 //__________________________________________________________________________
@@ -847,15 +974,71 @@ int GeometryTGeo::extractNumberOfHalfStavesMLOT(int lay) const
   for (int j = 0; j < nNodes; j++) {
     auto nd = dynamic_cast<TGeoNode*>(nodes->At(j)); /// layer node
     const char* name = nd->GetName();
-    if (strstr(name, getTRKChipPattern()) != nullptr) {
+    if (strstr(name, getTRKHalfStavePattern()) != nullptr) {
       numberOfHalfStaves++;
     }
   }
+
+  if (numberOfHalfStaves == 0) {
+    numberOfHalfStaves = 1; /// in case of turbo geometry, there is no half stave volume, but only stave volume
+  }
   return numberOfHalfStaves;
 }
 
 //__________________________________________________________________________
-void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave) const
+int GeometryTGeo::extractNumberOfModulesMLOT(int lay) const
+{
+  int numberOfModules = 0;
+
+  std::string staveName = Form("%s%d", (mNumberOfHalfStaves[lay] == 2 ? getTRKHalfStavePattern() : getTRKStavePattern()), lay);
+  TGeoVolume* staveV = gGeoManager->GetVolume(staveName.c_str());
+
+  if (staveV == nullptr) {
+    LOG(fatal) << getName() << " volume " << (mNumberOfHalfStaves[lay] == 2 ? getTRKHalfStavePattern() : getTRKStavePattern()) << " is not in the geometry";
+  }
+
+  // Loop on all staveV nodes, count Module volumes by checking names
+  TObjArray* nodes = staveV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j = 0; j < nNodes; j++) {
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j)); /// stave node
+    const char* name = nd->GetName();
+    if (strstr(name, getTRKModulePattern()) != nullptr) {
+      numberOfModules++;
+    }
+  }
+  return numberOfModules;
+}
+
+//__________________________________________________________________________
+int GeometryTGeo::extractNumberOfChipsMLOT(int lay) const
+{
+  int numberOfChips = 0;
+
+  std::string moduleName = Form("%s%d", getTRKModulePattern(), lay);
+  TGeoVolume* moduleV = gGeoManager->GetVolume(moduleName.c_str());
+
+  if (moduleV == nullptr) {
+    LOG(fatal) << getName() << " volume " << getTRKModulePattern() << " is not in the geometry";
+  }
+
+  // Loop on all moduleV nodes, count Chip volumes by checking names
+  TObjArray* nodes = moduleV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j = 0; j < nNodes; j++) {
+    auto nd = dynamic_cast<TGeoNode*>(nodes->At(j)); /// module node
+    const char* name = nd->GetName();
+    if (strstr(name, getTRKChipPattern()) != nullptr) {
+      numberOfChips++;
+    }
+  }
+  return numberOfChips;
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk, int lay, int stave, int halfstave, int mod, int chip) const
 {
   std::cout << "\nindex = " << index << std::endl;
   std::cout << "subDetID = " << subDetID << std::endl;
@@ -865,6 +1048,8 @@ void GeometryTGeo::PrintChipID(int index, int subDetID, int petalcase, int disk,
   std::cout << "first chip index = " << getFirstChipIndex(lay, petalcase, subDetID) << std::endl;
   std::cout << "stave = " << stave << std::endl;
   std::cout << "halfstave = " << halfstave << std::endl;
+  std::cout << "module = " << mod << std::endl;
+  std::cout << "chip = " << chip << std::endl;
 }
 
 //__________________________________________________________________________
@@ -892,6 +1077,18 @@ void GeometryTGeo::Print(Option_t*) const
     mlot = (i < 4) ? "ML" : "OT";
     LOGF(info, "Layer: %d, %s, %d staves, %d half staves per stave", i, mlot.c_str(), mNumberOfStaves[i], mNumberOfHalfStaves[i]);
   }
+  LOGF(info, "Number of modules per layer MLOT: ");
+  for (int i = 0; i < mNumberOfLayersMLOT; i++) {
+    LOGF(info, "%d", mNumberOfModules[i]);
+  }
+  LOGF(info, "Number of chips per module MLOT: ");
+  for (int i = 0; i < mNumberOfLayersMLOT; i++) {
+    LOGF(info, "%d", mNumberOfChips[i]);
+  }
+  LOGF(info, "Number of chips per layer MLOT: ");
+  for (int i = 0; i < mNumberOfLayersMLOT; i++) {
+    LOGF(info, "%d", mNumberOfChipsPerLayerMLOT[i]);
+  }
   LOGF(info, "Total number of chips: %d", getNumberOfChips());
 
   std::cout << "mLastChipIndex = [";
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
index 0c3c35d49f722..10f117750d793 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
@@ -10,7 +10,8 @@
 # or submit itself to any jurisdiction.
 
 o2_add_library(TRKSimulation
-               SOURCES src/TRKLayer.cxx
+               SOURCES src/Hit.cxx
+                       src/TRKLayer.cxx
                        src/ChipDigitsContainer.cxx
                        src/ChipSimResponse.cxx
                        src/Detector.cxx
@@ -27,7 +28,8 @@ o2_add_library(TRKSimulation
                                      O2::SimulationDataFormat)
 
 o2_target_root_dictionary(TRKSimulation
-                          HEADERS include/TRKSimulation/ChipDigitsContainer.h
+                          HEADERS include/TRKSimulation/Hit.h
+                                  include/TRKSimulation/ChipDigitsContainer.h
                                   include/TRKSimulation/ChipSimResponse.h
                                   include/TRKSimulation/DigiParams.h
                                   include/TRKSimulation/Digitizer.h
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
index 92cebd681176d..32bdc89109269 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
@@ -13,7 +13,7 @@
 #define ALICEO2_TRK_DETECTOR_H
 
 #include "DetectorsBase/Detector.h"
-#include "ITSMFTSimulation/Hit.h"
+#include "TRKSimulation/Hit.h"
 
 #include "TRKSimulation/TRKLayer.h"
 #include "TRKSimulation/TRKServices.h"
@@ -42,9 +42,9 @@ class Detector : public o2::base::DetImpl<Detector>
 
   void ConstructGeometry() override;
 
-  o2::itsmft::Hit* addHit(int trackID, int detID, const TVector3& startPos, const TVector3& endPos,
-                          const TVector3& startMom, double startE, double endTime, double eLoss,
-                          unsigned char startStatus, unsigned char endStatus);
+  o2::trk::Hit* addHit(int trackID, unsigned short detID, const TVector3& startPos, const TVector3& endPos,
+                       const TVector3& startMom, double startE, double endTime, double eLoss,
+                       unsigned char startStatus, unsigned char endStatus);
 
   // Mandatory overrides
   void BeginPrimary() override { ; }
@@ -57,8 +57,8 @@ class Detector : public o2::base::DetImpl<Detector>
   void Register() override;
   void Reset() override;
 
-  // Custom memer functions
-  std::vector<o2::itsmft::Hit>* getHits(int iColl) const
+  // Custom member functions
+  std::vector<o2::trk::Hit>* getHits(int iColl) const
   {
     if (!iColl) {
       return mHits;
@@ -81,14 +81,14 @@ class Detector : public o2::base::DetImpl<Detector>
 
   // Transient data about track passing the sensor
   struct TrackData {
-    bool mHitStarted;                  // hit creation started
-    unsigned char mTrkStatusStart;     // track status flag
-    TLorentzVector mPositionStart;     // position at entrance
-    TLorentzVector mMomentumStart;     // momentum
-    double mEnergyLoss;                // energy loss
-  } mTrackData;                        //! transient data
-  GeometryTGeo* mGeometryTGeo;         //!
-  std::vector<o2::itsmft::Hit>* mHits; // ITSMFT ones for the moment
+    bool mHitStarted;               // hit creation started
+    unsigned char mTrkStatusStart;  // track status flag
+    TLorentzVector mPositionStart;  // position at entrance
+    TLorentzVector mMomentumStart;  // momentum
+    double mEnergyLoss;             // energy loss
+  } mTrackData;                     //! transient data
+  GeometryTGeo* mGeometryTGeo;      //!
+  std::vector<o2::trk::Hit>* mHits; // ITSMFT ones for the moment
   std::vector<TRKLayer> mLayers;
   TRKServices mServices; // Houses the services of the TRK, but not the Iris tracker
 
@@ -105,11 +105,11 @@ class Detector : public o2::base::DetImpl<Detector>
   static constexpr Int_t sNumberVDPetalCases = 4;          //! Number of VD petals
   int getNumberOfLayers() const { return mLayers.size(); } //! Number of TRK layers
 
-  void Print(FairVolume* vol, int volume, int subDetID, int layer, int stave, int halfstave, int chipID) const;
+  void Print(FairVolume* vol, int volume, int subDetID, int layer, int stave, int halfstave, int mod, int chip, int chipID) const;
 
   template <typename Det>
   friend class o2::base::DetImpl;
-  ClassDefOverride(Detector, 1);
+  ClassDefOverride(Detector, 2);
 };
 } // namespace trk
 } // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
new file mode 100644
index 0000000000000..a178c30069f14
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
@@ -0,0 +1,149 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Hit.h
+/// \brief Definition of the TRK Hit class
+
+#ifndef ALICEO2_TRK_POINT_H_
+#define ALICEO2_TRK_POINT_H_
+
+#include "SimulationDataFormat/BaseHits.h" // for BasicXYZEHit
+#include "Rtypes.h"                        // for Bool_t, Double_t, Int_t, Double32_t, etc
+#include "TVector3.h"                      // for TVector3
+#include <iosfwd>
+#include "CommonUtils/ShmAllocator.h"
+
+namespace o2
+{
+namespace trk
+{
+
+class Hit : public o2::BasicXYZEHit<Float_t, Float_t>
+{
+
+ public:
+  enum HitStatus_t {
+    kTrackEntering = 0x1,
+    kTrackInside = 0x1 << 1,
+    kTrackExiting = 0x1 << 2,
+    kTrackOut = 0x1 << 3,
+    kTrackStopped = 0x1 << 4,
+    kTrackAlive = 0x1 << 5
+  };
+
+  /// Default constructor
+  Hit() = default;
+
+  /// Class Constructor
+  /// \param trackID Index of MCTrack
+  /// \param detID Detector ID
+  /// \param startPos Coordinates at entrance to active volume [cm]
+  /// \param pos Coordinates to active volume [cm]
+  /// \param mom Momentum of track at entrance [GeV]
+  /// \param endTime Time at entrance [ns]
+  /// \param time Time since event start [ns]
+  /// \param eLoss Energy deposit [GeV]
+  /// \param startStatus: status at entrance
+  /// \param endStatus: status at exit
+  inline Hit(int trackID, unsigned short detID, const TVector3& startPos, const TVector3& pos, const TVector3& mom, double startE,
+             double endTime, double eLoss, unsigned char statusStart, unsigned char status);
+
+  // Entrance position getters
+  math_utils::Point3D<Float_t> GetPosStart() const { return mPosStart; }
+  Float_t GetStartX() const { return mPosStart.X(); }
+  Float_t GetStartY() const { return mPosStart.Y(); }
+  Float_t GetStartZ() const { return mPosStart.Z(); }
+  template <typename F>
+  void GetStartPosition(F& x, F& y, F& z) const
+  {
+    x = GetStartX();
+    y = GetStartY();
+    z = GetStartZ();
+  }
+  // momentum getters
+  math_utils::Vector3D<Float_t> GetMomentum() const { return mMomentum; }
+  math_utils::Vector3D<Float_t>& GetMomentum() { return mMomentum; }
+  Float_t GetPx() const { return mMomentum.X(); }
+  Float_t GetPy() const { return mMomentum.Y(); }
+  Float_t GetPz() const { return mMomentum.Z(); }
+  Float_t GetE() const { return mE; }
+  Float_t GetTotalEnergy() const { return GetE(); }
+
+  UChar_t GetStatusEnd() const { return mTrackStatusEnd; }
+  UChar_t GetStatusStart() const { return mTrackStatusStart; }
+
+  Bool_t IsEntering() const { return mTrackStatusEnd & kTrackEntering; }
+  Bool_t IsInside() const { return mTrackStatusEnd & kTrackInside; }
+  Bool_t IsExiting() const { return mTrackStatusEnd & kTrackExiting; }
+  Bool_t IsOut() const { return mTrackStatusEnd & kTrackOut; }
+  Bool_t IsStopped() const { return mTrackStatusEnd & kTrackStopped; }
+  Bool_t IsAlive() const { return mTrackStatusEnd & kTrackAlive; }
+
+  Bool_t IsEnteringStart() const { return mTrackStatusStart & kTrackEntering; }
+  Bool_t IsInsideStart() const { return mTrackStatusStart & kTrackInside; }
+  Bool_t IsExitingStart() const { return mTrackStatusStart & kTrackExiting; }
+  Bool_t IsOutStart() const { return mTrackStatusStart & kTrackOut; }
+  Bool_t IsStoppedStart() const { return mTrackStatusStart & kTrackStopped; }
+  Bool_t IsAliveStart() const { return mTrackStatusStart & kTrackAlive; }
+
+  // Entrance position setter
+  void SetPosStart(const math_utils::Point3D<Float_t>& p) { mPosStart = p; }
+
+  /// Output to screen
+  void Print(const Option_t* opt) const;
+  friend std::ostream& operator<<(std::ostream& of, const Hit& point)
+  {
+    of << "-I- Hit: O2its point for track " << point.GetTrackID() << " in detector " << point.GetDetectorID() << std::endl;
+    /*
+      of << "    Position (" << point.fX << ", " << point.fY << ", " << point.fZ << ") cm" << std::endl;
+      of << "    Momentum (" << point.fPx << ", " << point.fPy << ", " << point.fPz << ") GeV" << std::endl;
+      of << "    Time " << point.fTime << " ns,  Length " << point.fLength << " cm,  Energy loss "
+      << point.fELoss * 1.0e06 << " keV" << std::endl;
+      */
+    return of;
+  }
+
+ private:
+  math_utils::Vector3D<Float_t> mMomentum; ///< momentum at entrance
+  math_utils::Point3D<Float_t> mPosStart;  ///< position at entrance (base mPos give position on exit)
+  Float_t mE;                              ///< total energy at entrance
+  UChar_t mTrackStatusEnd;                 ///< MC status flag at exit
+  UChar_t mTrackStatusStart;               ///< MC status at starting point
+
+  ClassDefNV(Hit, 1);
+};
+
+Hit::Hit(int trackID, unsigned short detID, const TVector3& startPos, const TVector3& endPos, const TVector3& startMom,
+         double startE, double endTime, double eLoss, unsigned char startStatus, unsigned char endStatus)
+  : BasicXYZEHit(endPos.X(), endPos.Y(), endPos.Z(), endTime, eLoss, trackID, detID),
+    mMomentum(startMom.Px(), startMom.Py(), startMom.Pz()),
+    mPosStart(startPos.X(), startPos.Y(), startPos.Z()),
+    mE(startE),
+    mTrackStatusEnd(endStatus),
+    mTrackStatusStart(startStatus)
+{
+}
+
+} // namespace trk
+} // namespace o2
+
+#ifdef USESHM
+namespace std
+{
+template <>
+class allocator<o2::trk::Hit> : public o2::utils::ShmAllocator<o2::trk::Hit>
+{
+};
+} // namespace std
+
+#endif
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
index ba894f6d7a92b..0a7a45e87bfd8 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
@@ -16,6 +16,7 @@
 #include <Rtypes.h>
 
 #include "TRKBase/TRKBaseParam.h"
+#include "TRKBase/Specs.h"
 
 namespace o2
 {
@@ -25,23 +26,27 @@ class TRKLayer
 {
  public:
   TRKLayer() = default;
-  TRKLayer(int layerNumber, std::string layerName, float rInn, float rOut, float zLength, float layerX2X0);
-  TRKLayer(int layerNumber, std::string layerName, float rInn, float zLength, float thick);
+  TRKLayer(int layerNumber, std::string layerName, float rInn, float rOut, int numberOfModules, float layerX2X0);
+  TRKLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thick);
   ~TRKLayer() = default;
 
   void setLayout(eLayout layout) { mLayout = layout; };
 
   auto getInnerRadius() const { return mInnerRadius; }
   auto getOuterRadius() const { return mOuterRadius; }
-  auto getZ() const { return mZ; }
+  auto getZ() const { return constants::moduleMLOT::length * mNumberOfModules; }
   auto getx2X0() const { return mX2X0; }
   auto getChipThickness() const { return mChipThickness; }
   auto getNumber() const { return mLayerNumber; }
   auto getName() const { return mLayerName; }
 
-  TGeoVolume* createSensor(std::string type, double width = -1);
-  TGeoVolume* createChip(std::string type, double width = -1);
-  TGeoVolume* createStave(std::string type, double width = -1);
+  TGeoVolume* createSensor(std::string type);
+  TGeoVolume* createDeadzone(std::string type);
+  TGeoVolume* createMetalStack(std::string type);
+  TGeoVolume* createChip(std::string type);
+  TGeoVolume* createModule(std::string type);
+  TGeoVolume* createStave(std::string type);
+  TGeoVolume* createHalfStave(std::string type);
   void createLayer(TGeoVolume* motherVolume);
 
  private:
@@ -49,16 +54,20 @@ class TRKLayer
   static constexpr float mLogicalVolumeThickness = 1;
 
   int mLayerNumber;
+  eLayout mLayout;
   std::string mLayerName;
   float mInnerRadius;
   float mOuterRadius;
-  float mZ;
+  int mNumberOfModules;
   float mX2X0;
+  float mChipWidth;
+  float mChipLength;
   float mChipThickness;
-  float mModuleWidth; // u.m. = cm
-  eLayout mLayout;
+  float mDeadzoneWidth;
+  float mSensorThickness;
+  int mHalfNumberOfChips;
 
-  ClassDef(TRKLayer, 1);
+  ClassDef(TRKLayer, 2);
 };
 
 } // namespace trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index a4d99ccf9f79f..4d7e560d50dc2 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -16,13 +16,16 @@
 #include <TGeoVolume.h>
 
 #include "DetectorsBase/Stack.h"
-#include "ITSMFTSimulation/Hit.h"
+#include "TRKSimulation/Hit.h"
 #include "TRKSimulation/Detector.h"
 #include "TRKBase/TRKBaseParam.h"
 #include "TRKSimulation/VDGeometryBuilder.h"
 #include "TRKSimulation/VDSensorRegistry.h"
 
-using o2::itsmft::Hit;
+#include <string>
+#include <type_traits>
+
+using o2::trk::Hit;
 
 namespace o2
 {
@@ -37,14 +40,14 @@ float getDetLengthFromEta(const float eta, const float radius)
 Detector::Detector()
   : o2::base::DetImpl<Detector>("TRK", true),
     mTrackData(),
-    mHits(o2::utils::createSimVector<o2::itsmft::Hit>())
+    mHits(o2::utils::createSimVector<o2::trk::Hit>())
 {
 }
 
 Detector::Detector(bool active)
   : o2::base::DetImpl<Detector>("TRK", true),
     mTrackData(),
-    mHits(o2::utils::createSimVector<o2::itsmft::Hit>())
+    mHits(o2::utils::createSimVector<o2::trk::Hit>())
 {
   auto& trkPars = TRKBaseParam::Instance();
 
@@ -83,40 +86,58 @@ void Detector::configDefault()
   mLayers.clear();
 
   LOGP(warning, "Loading Scoping Document configuration for ALICE3 TRK");
-  // mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 0.5f, 50.f, 100.e-4);
-  // mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 1.2f, 50.f, 100.e-4);
-  // mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 2.5f, 50.f, 100.e-4);
-  mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 3.78f, 124.f, 100.e-3);
-  mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 7.f, 124.f, 100.e-3);
-  mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 12.f, 124.f, 100.e-3);
-  mLayers.emplace_back(3, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(3)}, 20.f, 124.f, 100.e-3);
-  mLayers.emplace_back(4, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(4)}, 30.f, 124.f, 100.e-3);
-  mLayers.emplace_back(5, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(5)}, 45.f, 258.f, 100.e-3);
-  mLayers.emplace_back(6, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(6)}, 60.f, 258.f, 100.e-3);
-  mLayers.emplace_back(7, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(7)}, 80.f, 258.f, 100.e-3);
+  mLayers.emplace_back(0, GeometryTGeo::getTRKLayerPattern() + std::to_string(0), 3.78f, 10, 100.e-3);
+  mLayers.emplace_back(1, GeometryTGeo::getTRKLayerPattern() + std::to_string(1), 7.f, 10, 100.e-3);
+  mLayers.emplace_back(2, GeometryTGeo::getTRKLayerPattern() + std::to_string(2), 12.f, 10, 100.e-3);
+  mLayers.emplace_back(3, GeometryTGeo::getTRKLayerPattern() + std::to_string(3), 20.f, 10, 100.e-3);
+  mLayers.emplace_back(4, GeometryTGeo::getTRKLayerPattern() + std::to_string(4), 30.f, 10, 100.e-3);
+  mLayers.emplace_back(5, GeometryTGeo::getTRKLayerPattern() + std::to_string(5), 45.f, 20, 100.e-3);
+  mLayers.emplace_back(6, GeometryTGeo::getTRKLayerPattern() + std::to_string(6), 60.f, 20, 100.e-3);
+  mLayers.emplace_back(7, GeometryTGeo::getTRKLayerPattern() + std::to_string(7), 80.f, 20, 100.e-3);
 }
 
 void Detector::buildTRKMiddleOuterLayers()
 {
-  // Build the TRK detector according to changes proposed during
-  // https://indico.cern.ch/event/1407704/
-  // to adhere to the changes that were presented at the ALICE 3 Upgrade days in March 2024
-  // L3 -> 7 cm, L4 -> 9 cm
+  auto& trkPars = TRKBaseParam::Instance();
 
   mLayers.clear();
 
-  LOGP(warning, "Loading \"After Upgrade Days March 2024\" configuration for ALICE3 TRK");
-  mLayers.emplace_back(0, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)}, 7.f, 124.f, 100.e-3);
-  LOGP(info, "TRKLayer created. Name: {}", std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(0)});
-  mLayers.emplace_back(1, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(1)}, 9.f, 124.f, 100.e-3);
-  mLayers.emplace_back(2, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(2)}, 12.f, 124.f, 100.e-3);
-  mLayers.emplace_back(3, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(3)}, 20.f, 124.f, 100.e-3);
-  mLayers.emplace_back(4, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(4)}, 30.f, 124.f, 100.e-3);
-  mLayers.emplace_back(5, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(5)}, 45.f, 258.f, 100.e-3);
-  mLayers.emplace_back(6, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(6)}, 60.f, 258.f, 100.e-3);
-  mLayers.emplace_back(7, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(7)}, 80.f, 258.f, 100.e-3);
-
-  auto& trkPars = TRKBaseParam::Instance();
+  switch (trkPars.overallGeom) {
+    case kDefaultRadii:
+      // Build the TRK detector according to changes proposed during
+      // https://indico.cern.ch/event/1407704/
+      // to adhere to the changes that were presented at the ALICE 3 Upgrade days in March 2024
+      // L3 -> 7 cm, L4 -> 9 cm, L5 -> 12 cm, L6 -> 20 cm
+
+      LOGP(warning, "Loading \"After Upgrade Days March 2024\" configuration for ALICE3 TRK");
+      LOGP(warning, "Building TRK with new vacuum vessel and L3 at 7 cm, L4 at 9 cm, L5 at 12 cm, L6 at 20 cm");
+      mLayers.emplace_back(0, GeometryTGeo::getTRKLayerPattern() + std::to_string(0), 7.f, 10, 100.e-3);
+      LOGP(info, "TRKLayer created. Name: {}", GeometryTGeo::getTRKLayerPattern() + std::to_string(0));
+      mLayers.emplace_back(1, GeometryTGeo::getTRKLayerPattern() + std::to_string(1), 9.f, 10, 100.e-3);
+      mLayers.emplace_back(2, GeometryTGeo::getTRKLayerPattern() + std::to_string(2), 12.f, 10, 100.e-3);
+      mLayers.emplace_back(3, GeometryTGeo::getTRKLayerPattern() + std::to_string(3), 20.f, 10, 100.e-3);
+      mLayers.emplace_back(4, GeometryTGeo::getTRKLayerPattern() + std::to_string(4), 30.f, 10, 100.e-3);
+      mLayers.emplace_back(5, GeometryTGeo::getTRKLayerPattern() + std::to_string(5), 45.f, 20, 100.e-3);
+      mLayers.emplace_back(6, GeometryTGeo::getTRKLayerPattern() + std::to_string(6), 60.f, 20, 100.e-3);
+      mLayers.emplace_back(7, GeometryTGeo::getTRKLayerPattern() + std::to_string(7), 80.f, 20, 100.e-3);
+      break;
+    case kModRadii:
+      LOGP(warning, "Loading \"Alternative\" configuration for ALICE3 TRK");
+      LOGP(warning, "Building TRK with new vacuum vessel and L3 at 7 cm, L4 at 11 cm, L5 at 15 cm, L6 at 19 cm");
+      mLayers.emplace_back(0, GeometryTGeo::getTRKLayerPattern() + std::to_string(0), 7.f, 10, 100.e-3);
+      LOGP(info, "TRKLayer created. Name: {}", GeometryTGeo::getTRKLayerPattern() + std::to_string(0));
+      mLayers.emplace_back(1, GeometryTGeo::getTRKLayerPattern() + std::to_string(1), 11.f, 10, 100.e-3);
+      mLayers.emplace_back(2, GeometryTGeo::getTRKLayerPattern() + std::to_string(2), 15.f, 10, 100.e-3);
+      mLayers.emplace_back(3, GeometryTGeo::getTRKLayerPattern() + std::to_string(3), 19.f, 10, 100.e-3);
+      mLayers.emplace_back(4, GeometryTGeo::getTRKLayerPattern() + std::to_string(4), 30.f, 10, 100.e-3);
+      mLayers.emplace_back(5, GeometryTGeo::getTRKLayerPattern() + std::to_string(5), 45.f, 20, 100.e-3);
+      mLayers.emplace_back(6, GeometryTGeo::getTRKLayerPattern() + std::to_string(6), 60.f, 20, 100.e-3);
+      mLayers.emplace_back(7, GeometryTGeo::getTRKLayerPattern() + std::to_string(7), 80.f, 20, 100.e-3);
+      break;
+    default:
+      LOGP(fatal, "Unknown option {} for buildTRKMiddleOuterLayers", static_cast<int>(trkPars.overallGeom));
+      break;
+  }
 
   // Middle layers
   mLayers[0].setLayout(trkPars.layoutML);
@@ -157,7 +178,7 @@ void Detector::configFromFile(std::string fileName)
     while (getline(ss, substr, '\t')) {
       tmpBuff.push_back(std::stof(substr));
     }
-    mLayers.emplace_back(layerCount, std::string{GeometryTGeo::getTRKLayerPattern() + std::to_string(layerCount)}, tmpBuff[0], tmpBuff[1], tmpBuff[2]);
+    mLayers.emplace_back(layerCount, GeometryTGeo::getTRKLayerPattern() + std::to_string(layerCount), tmpBuff[0], tmpBuff[1], tmpBuff[2]);
     ++layerCount;
   }
 }
@@ -364,7 +385,6 @@ bool Detector::ProcessHits(FairVolume* vol)
   int subDetID = -1;
   int layer = -1;
   int volume = 0;
-  int stave = -1;
   int volID = vol->getMCid();
 
   bool notSens = false;
@@ -440,15 +460,23 @@ bool Detector::ProcessHits(FairVolume* vol)
     TLorentzVector positionStop;
     fMC->TrackPosition(positionStop);
     // Retrieve the indices with the volume path
-    int stave(0), halfstave(0);
+    int stave(0), halfstave(0), mod(0), chip(0);
     if (subDetID == 1) {
-      fMC->CurrentVolOffID(1, halfstave);
-      fMC->CurrentVolOffID(2, stave);
+      fMC->CurrentVolOffID(1, chip);
+      fMC->CurrentVolOffID(2, mod);
+      if (mGeometryTGeo->getNumberOfHalfStaves(layer) == 2) {
+        fMC->CurrentVolOffID(3, halfstave);
+        fMC->CurrentVolOffID(4, stave);
+      } else if (mGeometryTGeo->getNumberOfHalfStaves(layer) == 1) {
+        fMC->CurrentVolOffID(3, stave);
+      } else {
+        LOGP(fatal, "Wrong number of halfstaves for layer {}", layer);
+      }
     } /// if VD, for the moment the volume is the "chipID" so no need to retrieve other elments
 
-    int chipID = mGeometryTGeo->getChipIndex(subDetID, volume, layer, stave, halfstave);
+    unsigned short chipID = mGeometryTGeo->getChipIndex(subDetID, volume, layer, stave, halfstave, mod, chip);
 
-    Print(vol, volume, subDetID, layer, stave, halfstave, chipID);
+    Print(vol, volume, subDetID, layer, stave, halfstave, mod, chip, chipID);
 
     mGeometryTGeo->Print();
 
@@ -465,25 +493,27 @@ bool Detector::ProcessHits(FairVolume* vol)
   return true;
 }
 
-o2::itsmft::Hit* Detector::addHit(int trackID, int detID, const TVector3& startPos, const TVector3& endPos,
-                                  const TVector3& startMom, double startE, double endTime, double eLoss, unsigned char startStatus,
-                                  unsigned char endStatus)
+o2::trk::Hit* Detector::addHit(int trackID, unsigned short detID, const TVector3& startPos, const TVector3& endPos,
+                               const TVector3& startMom, double startE, double endTime, double eLoss, unsigned char startStatus,
+                               unsigned char endStatus)
 {
   mHits->emplace_back(trackID, detID, startPos, endPos, startMom, startE, endTime, eLoss, startStatus, endStatus);
   return &(mHits->back());
 }
 
-void Detector::Print(FairVolume* vol, int volume, int subDetID, int layer, int stave, int halfstave, int chipID) const
+void Detector::Print(FairVolume* vol, int volume, int subDetID, int layer, int stave, int halfstave, int mod, int chip, int chipID) const
 {
   int currentVol(0);
   LOG(info) << "Current volume name: " << fMC->CurrentVolName() << " and ID " << fMC->CurrentVolID(currentVol);
   LOG(info) << "volume: " << volume << "/" << mNumberOfVolumes - 1;
+  LOG(info) << "off volume name 1 " << fMC->CurrentVolOffName(1) << "  chip: " << chip;
+  LOG(info) << "off volume name 2  " << fMC->CurrentVolOffName(2) << "  module: " << mod;
   if (subDetID == 1 && mGeometryTGeo->getNumberOfHalfStaves(layer) == 2) { // staggered geometry
-    LOG(info) << "off volume name 1 " << fMC->CurrentVolOffName(1) << "  halfstave: " << halfstave;
-    LOG(info) << "off volume name 2  " << fMC->CurrentVolOffName(2) << "  stave: " << stave;
+    LOG(info) << "off volume name 3  " << fMC->CurrentVolOffName(3) << "  halfstave: " << halfstave;
+    LOG(info) << "off volume name 4  " << fMC->CurrentVolOffName(4) << "  stave: " << stave;
     LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  staveinLayer: " << stave << "  Chip ID: " << chipID;
   } else if (subDetID == 1 && mGeometryTGeo->getNumberOfHalfStaves(layer) == 1) { // turbo geometry
-    LOG(info) << "off volume name 2  " << fMC->CurrentVolOffName(2) << "  stave: " << stave;
+    LOG(info) << "off volume name 3  " << fMC->CurrentVolOffName(3) << "  stave: " << stave;
     LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  staveinLayer: " << stave << "  Chip ID: " << chipID;
   } else {
     LOG(info) << "SubDetector ID: " << subDetID << "  Chip ID: " << chipID;
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Hit.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Hit.cxx
new file mode 100644
index 0000000000000..fe496bc59692f
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Hit.cxx
@@ -0,0 +1,34 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Hit.cxx
+/// \brief Implementation of the Hit class
+
+#include "TRKSimulation/Hit.h"
+
+#include <iostream>
+#include <iostream>
+
+ClassImp(o2::trk::Hit);
+
+using std::cout;
+using std::endl;
+using namespace o2::trk;
+using namespace o2; //::base;
+
+void Hit::Print(const Option_t* opt) const
+{
+  printf(
+    "Det: %5d Track: %6d E.loss: %.3e P: %+.3e %+.3e %+.3e\n"
+    "PosIn: %+.3e %+.3e %+.3e PosOut: %+.3e %+.3e %+.3e\n",
+    GetDetectorID(), GetTrackID(), GetEnergyLoss(), GetPx(), GetPy(), GetPz(),
+    GetStartX(), GetStartY(), GetStartZ(), GetX(), GetY(), GetZ());
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index a95418afbba25..223c8b5c477a1 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -11,6 +11,7 @@
 
 #include "TRKSimulation/TRKLayer.h"
 #include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/Specs.h"
 
 #include "Framework/Logger.h"
 
@@ -24,37 +25,34 @@ namespace o2
 {
 namespace trk
 {
-TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float rOut, float zLength, float layerX2X0)
-  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mOuterRadius(rOut), mZ(zLength), mX2X0(layerX2X0), mModuleWidth(4.54), mLayout(kCylinder)
+TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float rOut, int numberOfModules, float layerX2X0)
+  : mLayerNumber(layerNumber), mLayout(kCylinder), mLayerName(layerName), mInnerRadius(rInn), mOuterRadius(rOut), mNumberOfModules(numberOfModules), mX2X0(layerX2X0), mChipWidth(constants::moduleMLOT::chip::width), mChipLength(constants::moduleMLOT::chip::length), mDeadzoneWidth(constants::moduleMLOT::chip::passiveEdgeReadOut), mSensorThickness(constants::moduleMLOT::silicon::thickness), mHalfNumberOfChips(4)
 {
   float Si_X0 = 9.5f;
   mChipThickness = mX2X0 * Si_X0;
-  LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, mZ, mX2X0);
+  LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, getZ(), mX2X0);
 }
 
-TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float zLength, float thick)
-  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mZ(zLength), mChipThickness(thick), mModuleWidth(4.54), mLayout(kCylinder)
+TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thick)
+  : mLayerNumber(layerNumber), mLayout(kCylinder), mLayerName(layerName), mInnerRadius(rInn), mNumberOfModules(numberOfModules), mChipThickness(thick), mChipWidth(constants::moduleMLOT::chip::width), mChipLength(constants::moduleMLOT::chip::length), mDeadzoneWidth(constants::moduleMLOT::chip::passiveEdgeReadOut), mSensorThickness(constants::moduleMLOT::silicon::thickness), mHalfNumberOfChips(4)
 {
   float Si_X0 = 9.5f;
   mOuterRadius = rInn + thick;
   mX2X0 = mChipThickness / Si_X0;
-  LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, mZ, mX2X0);
+  LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, getZ(), mX2X0);
 }
 
-TGeoVolume* TRKLayer::createSensor(std::string type, double width)
+TGeoVolume* TRKLayer::createSensor(std::string type)
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
-  std::string sensName = Form("%s%d", GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
+  std::string sensName = GeometryTGeo::getTRKSensorPattern() + std::to_string(mLayerNumber);
 
   TGeoShape* sensor;
 
   if (type == "cylinder") {
-    sensor = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
+    sensor = new TGeoTube(mInnerRadius, mInnerRadius + mSensorThickness, mChipLength / 2); // TO BE CHECKED !!!
   } else if (type == "flat") {
-    if (width < 0) {
-      LOGP(fatal, "Attempting to create sensor with invalid width");
-    }
-    sensor = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
+    sensor = new TGeoBBox((mChipWidth - mDeadzoneWidth) / 2, mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
   } else {
     LOGP(fatal, "Sensor of type '{}' is not implemented", type);
   }
@@ -65,75 +63,262 @@ TGeoVolume* TRKLayer::createSensor(std::string type, double width)
   return sensVol;
 };
 
-TGeoVolume* TRKLayer::createChip(std::string type, double width)
+TGeoVolume* TRKLayer::createDeadzone(std::string type)
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
-  std::string chipName = o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber);
+  std::string deadName = GeometryTGeo::getTRKDeadzonePattern() + std::to_string(mLayerNumber);
+
+  TGeoShape* deadzone;
+
+  if (type == "cylinder") {
+    deadzone = new TGeoTube(mInnerRadius, mInnerRadius + mSensorThickness, mChipLength / 2); // TO BE CHECKED !!!
+  } else if (type == "flat") {
+    deadzone = new TGeoBBox(mDeadzoneWidth / 2, mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
+  } else {
+    LOGP(fatal, "Deadzone of type '{}' is not implemented", type);
+  }
+
+  TGeoVolume* deadVol = new TGeoVolume(deadName.c_str(), deadzone, medSi);
+  deadVol->SetLineColor(kGray);
+
+  return deadVol;
+};
+
+TGeoVolume* TRKLayer::createMetalStack(std::string type)
+{
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  std::string metalName = GeometryTGeo::getTRKMetalStackPattern() + std::to_string(mLayerNumber);
+
+  TGeoShape* metalStack;
+
+  if (type == "cylinder") {
+    metalStack = new TGeoTube(mInnerRadius + mSensorThickness, mInnerRadius + mChipThickness, mChipLength / 2); // TO BE CHECKED !!!
+  } else if (type == "flat") {
+    metalStack = new TGeoBBox(mChipWidth / 2, mChipThickness - mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
+  } else {
+    LOGP(fatal, "Metal stack of type '{}' is not implemented", type);
+  }
+
+  TGeoVolume* metalVol = new TGeoVolume(metalName.c_str(), metalStack, medSi);
+  metalVol->SetLineColor(kGray);
+
+  return metalVol;
+};
+
+TGeoVolume* TRKLayer::createChip(std::string type)
+{
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  std::string chipName = GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber);
 
   TGeoShape* chip;
+  TGeoVolume* chipVol;
+
   TGeoVolume* sensVol;
+  TGeoVolume* deadVol;
+  TGeoVolume* metalVol;
 
   if (type == "cylinder") {
-    chip = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
+    chip = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
+    chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+
     sensVol = createSensor("cylinder");
+    metalVol = createMetalStack("cylinder");
+
+    TGeoCombiTrans* transSens = new TGeoCombiTrans();
+    transSens->SetTranslation(0, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
+    LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(sensVol, 1, transSens);
+
+    TGeoCombiTrans* transMetal = new TGeoCombiTrans();
+    transMetal->SetTranslation(0, mSensorThickness / 2, 0); // TO BE CHECKED !!!
+    LOGP(info, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(metalVol, 1, transMetal);
+
+    // deadVol = createDeadzone("cylinder");
   } else if (type == "flat") {
-    if (width < 0) {
-      LOGP(fatal, "Attempting to create chip with invalid width");
-    }
-    chip = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
-    sensVol = createSensor("flat", width);
+    chip = new TGeoBBox(mChipWidth / 2, mChipThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
+    chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+
+    sensVol = createSensor("flat");
+    deadVol = createDeadzone("flat");
+    metalVol = createMetalStack("flat");
+
+    TGeoCombiTrans* transSens = new TGeoCombiTrans();
+    transSens->SetTranslation(-mDeadzoneWidth / 2, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
+    LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(sensVol, 1, transSens);
+
+    TGeoCombiTrans* transDead = new TGeoCombiTrans();
+    transDead->SetTranslation((mChipWidth - mDeadzoneWidth) / 2, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
+    LOGP(info, "Inserting {} in {} ", deadVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(deadVol, 1, transDead);
+
+    TGeoCombiTrans* transMetal = new TGeoCombiTrans();
+    transMetal->SetTranslation(0, mSensorThickness / 2, 0); // TO BE CHECKED !!!
+    LOGP(info, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(metalVol, 1, transMetal);
   } else {
     LOGP(fatal, "Sensor of type '{}' is not implemented", type);
   }
 
-  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
-  LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-  chipVol->AddNode(sensVol, 1, nullptr);
   chipVol->SetLineColor(kYellow);
 
   return chipVol;
 }
 
-TGeoVolume* TRKLayer::createStave(std::string type, double width)
+TGeoVolume* TRKLayer::createModule(std::string type)
 {
   TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
-  std::string staveName = o2::trk::GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber);
+  std::string moduleName = GeometryTGeo::getTRKModulePattern() + std::to_string(mLayerNumber);
+
+  TGeoShape* module;
+  TGeoVolume* moduleVol;
+
+  if (type == "cylinder") {
+    module = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
+    moduleVol = new TGeoVolume(moduleName.c_str(), module, medAir);
+
+    TGeoVolume* chipVol = createChip("cylinder");
+    LOGP(info, "Inserting {} in {} ", chipVol->GetName(), moduleVol->GetName());
+    moduleVol->AddNode(chipVol, 1, nullptr);
+  } else if (type == "flat") {
+    double moduleWidth = constants::moduleMLOT::width;
+    double moduleLength = constants::moduleMLOT::length;
+
+    module = new TGeoBBox(moduleWidth / 2, mChipThickness / 2, moduleLength / 2); // TO BE CHECKED !!!
+    moduleVol = new TGeoVolume(moduleName.c_str(), module, medAir);
+
+    for (int iChip = 0; iChip < mHalfNumberOfChips; iChip++) {
+      TGeoVolume* chipVolLeft = createChip("flat");
+      TGeoVolume* chipVolRight = createChip("flat");
+
+      // Put the chips in the correct position
+      double xLeft = -moduleWidth / 2 + constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::width / 2;
+      double zLeft = -moduleLength / 2 + constants::moduleMLOT::gaps::outerEdgeShortSide + iChip * (constants::moduleMLOT::chip::length + constants::moduleMLOT::gaps::interChips) + constants::moduleMLOT::chip::length / 2;
+
+      TGeoCombiTrans* transLeft = new TGeoCombiTrans();
+      transLeft->SetTranslation(xLeft, 0, zLeft); // TO BE CHECKED !!!
+      LOGP(info, "Inserting {} in {} ", chipVolLeft->GetName(), moduleVol->GetName());
+      moduleVol->AddNode(chipVolLeft, iChip * 2, transLeft);
+
+      double xRight = +moduleWidth / 2 - constants::moduleMLOT::gaps::outerEdgeLongSide - constants::moduleMLOT::chip::width / 2;
+      double zRight = -moduleLength / 2 + constants::moduleMLOT::gaps::outerEdgeShortSide + iChip * (constants::moduleMLOT::chip::length + constants::moduleMLOT::gaps::interChips) + constants::moduleMLOT::chip::length / 2;
+
+      TGeoCombiTrans* transRight = new TGeoCombiTrans();
+      transRight->SetTranslation(xRight, 0, zRight); // TO BE CHECKED !!!
+      TGeoRotation* rot = new TGeoRotation();
+      rot->RotateY(180);
+      transRight->SetRotation(rot);
+      LOGP(info, "Inserting {} in {} ", chipVolRight->GetName(), moduleVol->GetName());
+      moduleVol->AddNode(chipVolRight, iChip * 2 + 1, transRight);
+    }
+  } else {
+    LOGP(fatal, "Chip of type '{}' is not implemented", type);
+  }
+
+  moduleVol->SetLineColor(kYellow);
+
+  return moduleVol;
+}
+
+TGeoVolume* TRKLayer::createHalfStave(std::string type)
+{
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  std::string halfStaveName = GeometryTGeo::getTRKHalfStavePattern() + std::to_string(mLayerNumber);
+
+  TGeoShape* halfStave;
+  TGeoVolume* halfStaveVol;
+
+  if (type == "cylinder") {
+    halfStave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
+    halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medAir);
+
+    TGeoVolume* moduleVol = createModule("cylinder");
+    LOGP(info, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
+    halfStaveVol->AddNode(moduleVol, 1, nullptr);
+  } else if (type == "flat") {
+    double moduleLength = constants::moduleMLOT::length;
+    double halfStaveWidth = constants::OT::halfstave::width;
+    double halfStaveLength = constants::moduleMLOT::length * mNumberOfModules;
+
+    halfStave = new TGeoBBox(halfStaveWidth / 2, mChipThickness / 2, halfStaveLength / 2);
+    halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medAir);
+
+    for (int iModule = 0; iModule < mNumberOfModules; iModule++) {
+      TGeoVolume* moduleVol = createModule("flat");
+
+      // Put the modules in the correct position
+      double zPos = -0.5 * mNumberOfModules * moduleLength + (iModule + 0.5) * moduleLength;
+
+      TGeoCombiTrans* trans = new TGeoCombiTrans();
+      trans->SetTranslation(0, 0, zPos); // TO BE CHECKED !!!
+
+      LOGP(info, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
+      halfStaveVol->AddNode(moduleVol, iModule, trans);
+    }
+  }
+  return halfStaveVol;
+}
+
+TGeoVolume* TRKLayer::createStave(std::string type)
+{
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  std::string staveName = GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber);
 
   TGeoShape* stave;
   TGeoVolume* staveVol;
-  TGeoVolume* chipVol;
 
   if (type == "cylinder") {
-    stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mZ / 2);
-    chipVol = createChip("cylinder");
+    stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
-    LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
-    staveVol->AddNode(chipVol, 1, nullptr);
+
+    TGeoVolume* moduleVol = createModule("cylinder");
+    LOGP(info, "Inserting {} in {} ", moduleVol->GetName(), staveVol->GetName());
+    staveVol->AddNode(moduleVol, 1, nullptr);
   } else if (type == "flat") {
-    if (width < 0) {
-      LOGP(fatal, "Attempting to create stave with invalid width");
-    }
-    stave = new TGeoBBox(width / 2, mChipThickness / 2, mZ / 2);
-    chipVol = createChip("flat", width);
+    double moduleLength = constants::moduleMLOT::length;
+    double staveWidth = constants::ML::width;
+    double staveLength = constants::moduleMLOT::length * mNumberOfModules;
+
+    stave = new TGeoBBox(staveWidth / 2, mChipThickness / 2, staveLength / 2);
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
-    LOGP(info, "Inserting {} in {} ", chipVol->GetName(), staveVol->GetName());
-    staveVol->AddNode(chipVol, 1, nullptr);
+
+    for (int iModule = 0; iModule < mNumberOfModules; iModule++) {
+      TGeoVolume* moduleVol = createModule("flat");
+
+      // Put the modules in the correct position
+      double zPos = -0.5 * mNumberOfModules * moduleLength + (iModule + 0.5) * moduleLength;
+
+      TGeoCombiTrans* trans = new TGeoCombiTrans();
+      trans->SetTranslation(0, 0, zPos); // TO BE CHECKED !!!
+
+      LOGP(info, "Inserting {} in {} ", moduleVol->GetName(), staveVol->GetName());
+      staveVol->AddNode(moduleVol, iModule, trans);
+    }
   } else if (type == "staggered") {
-    double width = mModuleWidth * 2; // Each stave has two modules (based on the LOI design)
-    stave = new TGeoBBox(width / 2, mLogicalVolumeThickness / 2, mZ / 2);
-    TGeoVolume* chipVolLeft = createChip("flat", mModuleWidth);
-    TGeoVolume* chipVolRight = createChip("flat", mModuleWidth);
+    /*double moduleWidth = constants::moduleMLOT::width;
+    double moduleLength = constants::moduleMLOT::length;*/
+
+    double halfstaveWidth = constants::ML::width;
+    double staveWidth = constants::OT::width; // Each stave has two modules (based on the LOI design)
+    double staveLength = constants::moduleMLOT::length * mNumberOfModules;
+
+    stave = new TGeoBBox(staveWidth / 2, mLogicalVolumeThickness / 2, staveLength / 2);
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
 
+    // Put the half staves in the correct position
+    TGeoVolume* halfStaveVolLeft = createHalfStave("flat");
+    TGeoVolume* halfStaveVolRight = createHalfStave("flat");
+
     TGeoCombiTrans* transLeft = new TGeoCombiTrans();
-    transLeft->SetTranslation(-mModuleWidth / 2 + 0.05, 0, 0); // 1mm overlap between the modules
-    LOGP(info, "Inserting {} in {} ", chipVolLeft->GetName(), staveVol->GetName());
-    staveVol->AddNode(chipVolLeft, 0, transLeft);
+    transLeft->SetTranslation(-halfstaveWidth / 2 + 0.05, 0, 0); // TO BE CHECKED !!! 1mm overlap between the modules
+    LOGP(info, "Inserting {} in {} ", halfStaveVolLeft->GetName(), staveVol->GetName());
+    staveVol->AddNode(halfStaveVolLeft, 0, transLeft);
 
     TGeoCombiTrans* transRight = new TGeoCombiTrans();
-    transRight->SetTranslation(mModuleWidth / 2 - 0.05, 0.2, 0);
-    LOGP(info, "Inserting {} in {} ", chipVolRight->GetName(), staveVol->GetName());
-    staveVol->AddNode(chipVolRight, 1, transRight);
+    transRight->SetTranslation(halfstaveWidth / 2 - 0.05, 0.2, 0); // TO BE CHECKED !!! 1mm overlap between the modules
+    LOGP(info, "Inserting {} in {} ", halfStaveVolRight->GetName(), staveVol->GetName());
+    staveVol->AddNode(halfStaveVolRight, 1, transRight);
   } else {
     LOGP(fatal, "Chip of type '{}' is not implemented", type);
   }
@@ -145,47 +330,49 @@ TGeoVolume* TRKLayer::createStave(std::string type, double width)
 
 void TRKLayer::createLayer(TGeoVolume* motherVolume)
 {
-  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
 
-  std::string staveName = o2::trk::GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber),
-              chipName = o2::trk::GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber),
-              sensName = Form("%s%d", GeometryTGeo::getTRKSensorPattern(), mLayerNumber);
-
   double layerThickness = mChipThickness;
   if (mLayout != eLayout::kCylinder) {
     layerThickness = mLogicalVolumeThickness;
   }
-  TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, mZ / 2);
 
-  TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-  layerVol->SetLineColor(kYellow);
+  TGeoTube* layer;
+  TGeoVolume* layerVol;
 
   if (mLayout == eLayout::kCylinder) {
-    auto staveVol = createStave("cylinder");
+    layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, mChipLength / 2);
+    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+
+    TGeoVolume* staveVol = createStave("cylinder");
     LOGP(info, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
     layerVol->AddNode(staveVol, 1, nullptr);
   } else if (mLayout == eLayout::kTurboStaves) {
-    // Compute the number of staves
-    double width = mModuleWidth; // Each stave has two modules (based on the LOI design)
+    double layerLength = constants::moduleMLOT::length * mNumberOfModules;
+    double staveWidth = constants::ML::width; // Each stave has two modules (based on the LOI design)
+
     if (mInnerRadius > 25) {
-      width *= 2; // Outer layers have two modules per stave
+      staveWidth = constants::OT::width; // Outer layers have two modules per stave
     }
 
-    int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / width);
+    layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, layerLength / 2);
+    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+
+    // Compute the number of staves
+    int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / staveWidth);
     nStaves += nStaves % 2; // Require an even number of staves
 
     // Compute the size of the overlap region
     double theta = 2 * TMath::Pi() / nStaves;
-    double theta1 = std::atan(width / 2 / mInnerRadius);
+    double theta1 = std::atan(staveWidth / 2 / mInnerRadius);
     double st = std::sin(theta);
     double ct = std::cos(theta);
-    double theta2 = std::atan((mInnerRadius * st - width / 2 * ct) / (mInnerRadius * ct + width / 2 * st));
+    double theta2 = std::atan((mInnerRadius * st - staveWidth / 2 * ct) / (mInnerRadius * ct + staveWidth / 2 * st));
     double overlap = (theta1 - theta2) * mInnerRadius;
     LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
 
     for (int iStave = 0; iStave < nStaves; iStave++) {
-      TGeoVolume* staveVol = createStave("flat", width);
+      TGeoVolume* staveVol = createStave("flat");
 
       // Put the staves in the correct position and orientation
       TGeoCombiTrans* trans = new TGeoCombiTrans();
@@ -198,17 +385,22 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       layerVol->AddNode(staveVol, iStave, trans);
     }
   } else if (mLayout == kStaggered) {
+    double layerLength = constants::moduleMLOT::length * mNumberOfModules;
+
+    layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, layerLength / 2);
+    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+
     // Compute the number of staves
-    double width = mModuleWidth * 2; // Each stave has two modules (based on the LOI design)
-    int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / width);
+    double staveWidth = constants::OT::width; // Each stave has two modules (based on the LOI design)
+    int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / staveWidth);
     nStaves += nStaves % 2; // Require an even number of staves
 
     // Compute the size of the overlap region
     double theta = 2 * TMath::Pi() / nStaves;
-    double theta1 = std::atan(width / 2 / mInnerRadius);
+    double theta1 = std::atan(staveWidth / 2 / mInnerRadius);
     double st = std::sin(theta);
     double ct = std::cos(theta);
-    double theta2 = std::atan((mInnerRadius * st - width / 2 * ct) / (mInnerRadius * ct + width / 2 * st));
+    double theta2 = std::atan((mInnerRadius * st - staveWidth / 2 * ct) / (mInnerRadius * ct + staveWidth / 2 * st));
     double overlap = (theta1 - theta2) * mInnerRadius;
     LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
 
@@ -228,6 +420,8 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
   } else {
     LOGP(fatal, "Layout not implemented");
   }
+  layerVol->SetLineColor(kYellow);
+
   LOGP(info, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
   motherVolume->AddNode(layerVol, 1, nullptr);
 }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
index 1a2e93636491c..9af868a2de44c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
@@ -15,6 +15,9 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ class o2::trk::Hit + ;
+#pragma link C++ class std::vector < o2::trk::Hit> + ;
+
 #pragma link C++ class o2::trk::TRKLayer + ;
 #pragma link C++ class o2::trk::VDLayer + ;
 #pragma link C++ class o2::trk::TRKServices + ;

From 76a4eed34d7c65b15f3de01fd00407db95893e73 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 30 Oct 2025 18:08:31 +0100
Subject: [PATCH 0986/1764] Avoid deprecated spacing in user defined literals

Warns when compiling with Clang on linux.
---
 Utilities/rANS/include/rANS/internal/common/utils.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Utilities/rANS/include/rANS/internal/common/utils.h b/Utilities/rANS/include/rANS/internal/common/utils.h
index 34f2a5c6d6b30..8b8cfd9c15154 100644
--- a/Utilities/rANS/include/rANS/internal/common/utils.h
+++ b/Utilities/rANS/include/rANS/internal/common/utils.h
@@ -152,11 +152,11 @@ inline uint32_t safeadd(uint32_t a, uint32_t b)
 
 } // namespace internal
 
-inline constexpr std::uint8_t operator"" _u8(unsigned long long int value) { return static_cast<uint8_t>(value); };
-inline constexpr std::int8_t operator"" _i8(unsigned long long int value) { return static_cast<int8_t>(value); };
+inline constexpr std::uint8_t operator""_u8(unsigned long long int value) { return static_cast<uint8_t>(value); };
+inline constexpr std::int8_t operator""_i8(unsigned long long int value) { return static_cast<int8_t>(value); };
 
-inline constexpr std::uint16_t operator"" _u16(unsigned long long int value) { return static_cast<uint16_t>(value); };
-inline constexpr std::int16_t operator"" _i16(unsigned long long int value) { return static_cast<int16_t>(value); };
+inline constexpr std::uint16_t operator""_u16(unsigned long long int value) { return static_cast<uint16_t>(value); };
+inline constexpr std::int16_t operator""_i16(unsigned long long int value) { return static_cast<int16_t>(value); };
 
 namespace utils
 {

From 48769713e2de1bcd08a124fb043e1264c63442ca Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 31 Oct 2025 13:33:12 +0100
Subject: [PATCH 0987/1764] GPU dEdx: Fix possible buffer overflow when adding
 subThreshold clusters

---
 GPU/GPUTracking/dEdx/GPUdEdx.cxx |  2 ++
 GPU/GPUTracking/dEdx/GPUdEdx.h   | 13 ++++++-------
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.cxx b/GPU/GPUTracking/dEdx/GPUdEdx.cxx
index 340463b9ec7f7..7df2cd90dab1f 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.cxx
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.cxx
@@ -19,6 +19,8 @@
 
 using namespace o2::gpu;
 
+static_assert(GPUdEdx::MAX_NCL <= 255); // Must fit in mNClsROC (uint8_t)!
+
 #ifndef GPUCA_GPUCODE_DEVICE
 GPUd() void GPUdEdx::clear()
 {
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index b711f1a685a4c..758c2a7eabfca 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -36,6 +36,8 @@ class GPUdEdx
   GPUd() void fillSubThreshold(int32_t padRow);
   GPUd() void computedEdx(GPUdEdxInfo& output, const GPUParam& param);
 
+  static constexpr size_t MAX_NCL = GPUCA_ROW_COUNT;
+
  private:
   GPUd() float GetSortTruncMean(GPUCA_PAR_DEDX_STORAGE_TYPE_A* array, int32_t count, int32_t trunclow, int32_t trunchigh);
   GPUd() void checkSubThresh(int32_t roc);
@@ -60,8 +62,6 @@ class GPUdEdx
   };
 #endif
 
-  static constexpr int32_t MAX_NCL = GPUCA_ROW_COUNT; // Must fit in mNClsROC (uint8_t)!
-
   GPUCA_PAR_DEDX_STORAGE_TYPE_A mChargeTot[MAX_NCL]; // No need for default, just some memory
   GPUCA_PAR_DEDX_STORAGE_TYPE_A mChargeMax[MAX_NCL]; // No need for default, just some memory
   float mSubThreshMinTot = 0.f;
@@ -76,7 +76,7 @@ class GPUdEdx
 GPUdi() void GPUdEdx::checkSubThresh(int32_t roc)
 {
   if (roc != mLastROC) {
-    if (mNSubThresh && mCount + mNSubThresh <= MAX_NCL) {
+    if (mNSubThresh && mCount + mNSubThresh < MAX_NCL) {
       for (int32_t i = 0; i < mNSubThresh; i++) {
         mChargeTot[mCount] = (GPUCA_PAR_DEDX_STORAGE_TYPE_A)(mSubThreshMinTot * scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::round);
         mChargeMax[mCount++] = (GPUCA_PAR_DEDX_STORAGE_TYPE_A)(mSubThreshMinMax * scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::factor + scalingFactor<GPUCA_PAR_DEDX_STORAGE_TYPE_A>::round);
@@ -94,16 +94,15 @@ GPUdi() void GPUdEdx::checkSubThresh(int32_t roc)
 
 GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint8_t sector, float trackSnp, float trackTgl, const GPUCalibObjectsConst& calib, float z, float pad, float relTime)
 {
-  if (mCount >= MAX_NCL) {
-    return;
-  }
-
   // container containing all the dE/dx corrections
   auto calibContainer = calib.dEdxCalibContainer;
   constexpr GPUTPCGeometry geo;
 
   const int32_t roc = geo.GetROC(padRow);
   checkSubThresh(roc);
+  if (mCount >= MAX_NCL) {
+    return;
+  }
   float snp2 = trackSnp * trackSnp;
   if (snp2 > GPUCA_MAX_SIN_PHI_LOW) {
     snp2 = GPUCA_MAX_SIN_PHI_LOW;

From e512e0750c7ee4ed4e3be4a411b2fe653dfd3db8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 31 Oct 2025 19:06:04 +0100
Subject: [PATCH 0988/1764] GPU Standalone: Support running QA on async reco

---
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 11d32394ccfb9..6b0637c76d857 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -304,6 +304,10 @@ int32_t SetupReconstruction()
 
   chainTracking->mConfigQA = &configStandalone.QA;
   chainTracking->mConfigDisplay = &configStandalone.display;
+  if (configStandalone.testSyncAsync) {
+    chainTrackingAsync->mConfigQA = &configStandalone.QA;
+    chainTrackingAsync->mConfigDisplay = &configStandalone.display;
+  }
 
   GPUSettingsGRP grp = rec->GetGRPSettings();
   GPUSettingsRec recSet;
@@ -426,6 +430,7 @@ int32_t SetupReconstruction()
     }
   }
 
+  bool runAsyncQA = procSet.runQA;
   if (configStandalone.testSyncAsync || configStandalone.testSync) {
     // Set settings for synchronous
     if (configStandalone.rundEdx == -1) {
@@ -434,6 +439,7 @@ int32_t SetupReconstruction()
     recSet.useMatLUT = false;
     if (configStandalone.testSyncAsync) {
       procSet.eventDisplay = nullptr;
+      procSet.runQA = false;
     }
   }
   if (configStandalone.proc.rtc.optSpecialCode == -1) {
@@ -455,7 +461,7 @@ int32_t SetupReconstruction()
     steps.inputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, true);
     steps.outputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, false);
     procSet.runMC = false;
-    procSet.runQA = false;
+    procSet.runQA = runAsyncQA;
     procSet.eventDisplay = eventDisplay.get();
     procSet.runCompressionStatistics = 0;
     procSet.rtc.optSpecialCode = 0;
@@ -749,7 +755,6 @@ int32_t main(int argc, char** argv)
       recAsync->SetDebugLevelTmp(configStandalone.proc.debugLevel);
     }
     chainTrackingAsync = recAsync->AddChain<GPUChainTracking>();
-    chainTrackingAsync->SetQAFromForeignChain(chainTracking);
   }
   if (configStandalone.proc.doublePipeline) {
     if (configStandalone.proc.debugLevel >= 3) {
@@ -959,6 +964,9 @@ int32_t main(int argc, char** argv)
   }
 
   rec->Finalize();
+  if (configStandalone.testSyncAsync) {
+    recAsync->Finalize();
+  }
   if (configStandalone.outputcontrolmem && rec->IsGPU()) {
     if (rec->unregisterMemoryForGPU(outputmemory.get()) || (configStandalone.proc.doublePipeline && recPipeline->unregisterMemoryForGPU(outputmemoryPipeline.get()))) {
       printf("Error unregistering memory\n");

From 8a913c1719b5a9b34271e99932f62b53dff6e289 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 30 Oct 2025 08:56:39 +0100
Subject: [PATCH 0989/1764] GPU QA: Fix nClCorrected histogram, don't show
 removed tracks with 0 clusters

---
 GPU/GPUTracking/qa/GPUQA.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 4f2c13635befa..1b71ae939cbd5 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -1725,7 +1725,9 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           }
         }
       }
-      mNCl[1]->Fill(nClCorrected);
+      if (nClCorrected) {
+        mNCl[1]->Fill(nClCorrected);
+      }
       mT0[0]->Fill(track.GetParam().GetTOffset());
       if (mTrackMCLabels.size() && !mTrackMCLabels[i].isFake() && !track.MergedLooper() && !track.CCE()) {
         const auto& info = GetMCTrack(mTrackMCLabels[i]);

From adcc9eee0e122bfa2221c703adf1d9cdd8787aea Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 29 Oct 2025 15:24:34 +0100
Subject: [PATCH 0990/1764] GPU QA: Add option compareTrackStatus

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  3 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  | 51 +++++++++++++++++++
 2 files changed, 53 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 957631e571b76..be9127a0c5070 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -509,9 +509,10 @@ AddOption(filterPID, int32_t, -1, "", 0, "Filter for Particle Type (0 Electron,
 AddOption(nativeFitResolutions, bool, false, "", 0, "Create resolution histograms in the native fit units (sin(phi), tan(lambda), Q/Pt)")
 AddOption(enableLocalOutput, bool, true, "", 0, "Enable normal output to local PDF files / console")
 AddOption(dumpToROOT, int32_t, 0, "", 0, "Dump all clusters and tracks to a ROOT file, 1 = combined TNTUple dump, 2 = also individual cluster / track branch dump")
-AddOption(writeMCLabels, bool, false, "", 0, "Store mc labels to file for later matching")
 AddOption(writeRootFiles, bool, false, "", 0, "Create ROOT canvas files")
+AddOption(writeMCLabels, bool, false, "", 0, "Store mc labels to file for later matching")
 AddOptionVec(matchMCLabels, std::string, "", 0, "Read labels from files and match them, only process tracks where labels differ")
+AddOption(compareTrackStatus, uint32_t, 0, "", 0, "0 = disabled, 1 = write status file, 2 = read status file and compare with current tracks")
 AddOption(matchDisplayMinPt, float, 0, "", 0, "Minimum Pt of a matched track to be displayed")
 AddOption(noMC, bool, false, "", 0, "Force running QA without MC labels even if present")
 AddOption(shipToQC, bool, false, "", 0, "Do not write output files but ship histograms for QC")
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 1b71ae939cbd5..cbeeb1076647f 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -73,6 +73,7 @@
 #include <algorithm>
 #include <cstdio>
 #include <cinttypes>
+#include <fstream>
 
 #include "utils/timer.h"
 
@@ -1899,6 +1900,56 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       }
     }
   }
+
+  if (mConfig.compareTrackStatus) {
+#ifdef GPUCA_DETERMINISTIC_MODE
+    if (!mTracking || !mTracking->GetProcessingSettings().deterministicGPUReconstruction)
+#endif
+    {
+      throw std::runtime_error("Need deterministic processing to compare track status");
+    }
+    std::vector<uint8_t> status(mTracking->mIOPtrs.nMergedTracks);
+    for (uint32_t i = 0; i < mTracking->mIOPtrs.nMergedTracks; i++) {
+      const auto& trk = mTracking->mIOPtrs.mergedTracks[i];
+      status[i] = trk.OK() && trk.NClusters() && trk.GetParam().GetNDF() > 0 && (mConfig.noMC || (mTrackMCLabels[i].isValid() && !mTrackMCLabels[i].isFake()));
+    }
+    if (mConfig.compareTrackStatus == 1) {
+      std::ofstream("track.status", std::ios::binary).write((char*)status.data(), status.size() * sizeof(status[0]));
+    } else if (mConfig.compareTrackStatus == 2) {
+      std::ifstream f("track.status", std::ios::binary | std::ios::ate);
+      std::vector<uint8_t> comp(f.tellg());
+      f.seekg(0);
+      f.read((char*)comp.data(), comp.size());
+
+      if (comp.size() != status.size()) {
+        throw std::runtime_error("Number of tracks candidates in track fit in track.status and in current reconstruction differ");
+      }
+      std::vector<uint32_t> missing, missingComp;
+      for (uint32_t i = 0; i < status.size(); i++) {
+        if (status[i] && !comp[i]) {
+          missingComp.emplace_back(i);
+        }
+        if (comp[i] && !status[i]) {
+          missing.emplace_back(i);
+        }
+      }
+      auto printer = [](std::vector<uint32_t> m, const char* name) {
+        if (m.size()) {
+          printf("Missing in %s reconstruction: (%zu)\n", name, m.size());
+          for (uint32_t i = 0; i < m.size(); i++) {
+            if (i) {
+              printf(", ");
+            }
+            printf("%d", m[i]);
+          }
+          printf("\n");
+        }
+      };
+      printer(missing, "current");
+      printer(missingComp, "comparison");
+    }
+  }
+
   mTrackingScratchBuffer.clear();
   mTrackingScratchBuffer.shrink_to_fit();
 }

From b4180ad39a912d125ccab41fc24e4130c498c1ea Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 2 Nov 2025 09:49:46 +0100
Subject: [PATCH 0991/1764] GPU: Add debug option to print track debug output
 for track selected by env variable

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index b45f08ed00f50..2b7f23aba0557 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -902,7 +902,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
   }
 
   // clang-format off
-  CADEBUG(if (DEBUG_SINGLE_TRACK >= 0 && iTrk != DEBUG_SINGLE_TRACK) { track.SetNClusters(0); track.SetOK(0); return; } );
+  CADEBUG(if (DEBUG_SINGLE_TRACK != -1 && iTrk != ((DEBUG_SINGLE_TRACK == -2 && getenv("DEBUG_TRACK")) ? atoi(getenv("DEBUG_TRACK")) :  DEBUG_SINGLE_TRACK)) { track.SetNClusters(0); track.SetOK(0); return; } );
   // clang-format on
 
   int32_t nTrackHits = track.NClusters();

From db55f0819ad84a35d9e59bb688e2ab5196e54fb1 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Wed, 8 Oct 2025 00:37:36 +0200
Subject: [PATCH 0992/1764] Fix one-off index problem when copying collision
 contexts

Fixing https://its.cern.ch/jira/browse/O2-6437
---
 DataFormats/simulation/src/DigitizationContext.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index 9e8a125c06fa4..a157fbc377fde 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -708,7 +708,7 @@ DigitizationContext DigitizationContext::extractSingleTimeframe(int timeframeid,
     auto tf_ranges = timeframeindices.at(timeframeid);
 
     auto startindex = std::get<0>(tf_ranges);
-    auto endindex = std::get<1>(tf_ranges);
+    auto endindex = std::get<1>(tf_ranges) + 1; // +1 due to endindex being "including"
     auto earlyindex = std::get<2>(tf_ranges);
 
     if (earlyindex >= 0) {

From bf3fd5b0bcd6c168bd3557b261a3879ca1829e36 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 1 Nov 2025 21:50:44 +0100
Subject: [PATCH 0993/1764] GPU TPC: Add attachProtect flag, and mark all
 clusters also in the history of protected tracks such

---
 .../DataCompression/GPUTPCClusterRejection.h  | 19 +++++++++++++------
 .../GPUTPCCompressionKernels.cxx              |  7 ++++++-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 13 +++++++++++--
 GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h  |  3 ++-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |  6 ++++++
 5 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h b/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
index f39994f2d1045..ae3ffb29926a7 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
@@ -25,18 +25,19 @@ struct GPUTPCClusterRejection {
   {
     (void)counts; // FIXME: Avoid incorrect -Wunused-but-set-parameter warning
     (void)mev200;
+    bool retVal = false;
     if (attach == 0) {
-      return false;
+      retVal = false;
     } else if ((attach & gputpcgmmergertypes::attachGoodLeg) == 0) {
       if constexpr (C) {
         counts->nLoopers++;
       }
-      return true;
+      retVal = true;
     } else if (attach & gputpcgmmergertypes::attachHighIncl) {
       if constexpr (C) {
         counts->nHighIncl++;
       }
-      return true;
+      retVal = true;
     } else if (attach & gputpcgmmergertypes::attachTube) {
       protect = true;
       if constexpr (C) {
@@ -46,17 +47,23 @@ struct GPUTPCClusterRejection {
           counts->nTube++;
         }
       }
-      return false;
+      retVal = false;
     } else if ((attach & gputpcgmmergertypes::attachGood) == 0) {
       protect = true;
       if constexpr (C) {
         counts->nRejected++;
       }
-      return false;
+      retVal = false;
     } else {
       physics = true;
-      return false;
+      retVal = false;
     }
+
+    if (attach & gputpcgmmergertypes::attachProtect) {
+      protect = true;
+      retVal = false;
+    }
+    return retVal;
   }
 
   static constexpr inline bool GetIsRejected(int32_t attach)
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index d5567bb5148d9..911af719dd3d4 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -56,10 +56,12 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
       if ((attach & gputpcgmmergertypes::attachTrackMask) != i) {
         continue; // Main attachment to different track
       }
-      bool rejectCluster = processors.param.rec.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyA && (rejectTrk || GPUTPCClusterRejection::GetIsRejected(attach));
+      bool rejectCluster = processors.param.rec.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyA && !(attach & gputpcgmmergertypes::attachProtect) && (rejectTrk || GPUTPCClusterRejection::GetIsRejected(attach));
       if (rejectCluster) {
         compressor.mClusterStatus[hitId] = 1; // Cluster rejected, do not store
         continue;
+      } else if (processors.param.rec.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyA && rejectTrk) {
+        continue;
       }
 
       if (!(param.rec.tpc.compressionTypeMask & GPUSettings::CompressionTrackModel)) {
@@ -199,6 +201,9 @@ GPUd() bool GPUTPCCompression::rejectCluster(int32_t idx, GPUParam& GPUrestrict(
     if (GPUTPCClusterRejection::GetIsRejected(attach)) {
       return true;
     }
+    if (attach & gputpcgmmergertypes::attachProtect) {
+      return false;
+    }
     int32_t id = attach & gputpcgmmergertypes::attachTrackMask;
     auto& trk = ioPtrs.mergedTracks[id];
     if (CAMath::Abs(trk.GetParam().GetQPt() * param.qptB5Scaler) > param.rec.tpc.rejectQPtB5 || trk.MergedLooper()) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 212850f107098..8793f3bb399c8 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1848,7 +1848,11 @@ GPUd() void GPUTPCGMMerger::PrepareForFit1(int32_t nBlocks, int32_t nThreads, in
     GPUTPCGMMergedTrack& trk = mMergedTracks[i];
     if (trk.OK()) {
       for (uint32_t j = 0; j < trk.NClusters(); j++) {
-        mClusterAttachment[mClusters[trk.FirstClusterRef() + j].num] = attachAttached | attachGood;
+        uint32_t weight = attachAttached | attachGood;
+        if (CAMath::Abs(trk.GetParam().GetQPt() * Param().qptB5Scaler) <= Param().rec.tpc.rejectQPtB5 && !trk.MergedLooper() && trk.Leg() == 0) {
+          weight |= attachProtect;
+        }
+        mClusterAttachment[mClusters[trk.FirstClusterRef() + j].num] = weight;
         CAMath::AtomicAdd(&mSharedCount[mClusters[trk.FirstClusterRef() + j].num], 1u);
       }
       if (!trk.CCE() && !trk.MergedLooper()) {
@@ -1896,7 +1900,9 @@ GPUd() void GPUTPCGMMerger::Finalize0(int32_t nBlocks, int32_t nThreads, int32_t
     mTrackSort[mTrackOrderAttach[i]] = i;
   }
   for (uint32_t i = iBlock * nThreads + iThread; i < mMemory->nMergedTrackClusters; i += nThreads * nBlocks) {
-    mClusterAttachment[mClusters[i].num] = 0; // Reset adjacent attachment for attached clusters, set correctly below
+    if (!(mClusterAttachment[mClusters[i].num] & attachProtect)) {
+      mClusterAttachment[mClusters[i].num] = 0; // Reset adjacent attachment for attached clusters, set correctly below
+    }
   }
 }
 
@@ -1919,6 +1925,9 @@ GPUd() void GPUTPCGMMerger::Finalize1(int32_t nBlocks, int32_t nThreads, int32_t
       if (trk.Leg() == 0) {
         weight |= attachGoodLeg;
       }
+      if (CAMath::Abs(trk.GetParam().GetQPt() * Param().qptB5Scaler) <= Param().rec.tpc.rejectQPtB5 && !trk.MergedLooper() && trk.Leg() == 0) {
+        weight |= attachProtect;
+      }
       CAMath::AtomicMax(&mClusterAttachment[id], weight);
     }
   }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h b/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
index ba251ce34a3eb..731439aab0be2 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
@@ -21,7 +21,8 @@
 namespace o2::gpu::gputpcgmmergertypes
 {
 
-enum attachTypes { attachAttached = 0x40000000,
+enum attachTypes { attachProtect = 0x80000000,
+                   attachAttached = 0x40000000,
                    attachGood = 0x20000000,
                    attachGoodLeg = 0x10000000,
                    attachTube = 0x08000000,
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 2b7f23aba0557..0e9cbdacee24e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -514,6 +514,8 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   const float stepZ = row.HstepZ();
   int32_t bin, ny, nz;
 
+  bool protect = CAMath::Abs(GetQPt() * Merger->Param().qptB5Scaler) <= Merger->Param().rec.tpc.rejectQPtB5 && goodLeg;
+
   float err2Y, err2Z;
   Merger->Param().GetClusterErrors2(sector, iRow, Z, mP[2], mP[3], -1.f, 0.f, 0.f, err2Y, err2Z);                                       // TODO: Use correct time/avgCharge
   const float sy2 = CAMath::Min(Merger->Param().rec.tpc.tubeMaxSize2, Merger->Param().rec.tpc.tubeChi2 * (err2Y + CAMath::Abs(mC[0]))); // Cov can be bogus when following circle
@@ -538,6 +540,10 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   if (goodLeg) {
     myWeight |= gputpcgmmergertypes::attachGoodLeg;
   }
+  if (protect) {
+    myWeight |= gputpcgmmergertypes::attachProtect;
+  }
+
   for (int32_t k = 0; k <= nz; k++) {
     const int32_t mybin = bin + k * nBinsY;
     const uint32_t hitFst = firsthit[mybin];

From 80ad74a3fbb506e9f348ea6a7542bbd30e27492f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 1 Nov 2025 21:58:04 +0100
Subject: [PATCH 0994/1764] GPU TPC: Add tubeProtectSigma2 tubeProtectMaxSize2
 tubeRemoveSigma2 tubeRemoveMaxSize2 options

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 7 +++++--
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 7 +++++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index be9127a0c5070..091eeccfd0246 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -68,8 +68,11 @@ AddOptionRTC(minNClustersFinalTrack, int32_t, -1, "", 0, "required min number of
 AddOptionRTC(searchWindowDZDR, float, 2.5f, "", 0, "Use DZDR window for seeding instead of neighboursSearchArea")
 AddOptionRTC(trackReferenceX, float, 1000.f, "", 0, "Transport all tracks to this X after tracking (disabled if > 500, auto = 1000)")
 AddOptionRTC(zsThreshold, float, 2.0f, "", 0, "Zero-Suppression threshold")
-AddOptionRTC(tubeChi2, float, 5.f * 5.f, "", 0, "Max chi2 to mark cluster adjacent to track")
-AddOptionRTC(tubeMaxSize2, float, 2.5f * 2.5f, "", 0, "Square of max tube size (normally derrived from tpcTubeChi2)")
+AddOptionRTC(tubeProtectSigma2, float, 5.f * 5.f, "", 0, "Max sigma2 to mark adjacent cluster for protection")
+AddOptionRTC(tubeProtectMaxSize2, float, 3.5f * 3.5f, "", 0, "Square of max tube size (if smaller than tubeProtectChi2)")
+AddOptionRTC(tubeProtectMinSize2, float, 1.0f * 1.0f, "", 0, "Square of min tube size (if larger than tubeProtectChi2)")
+AddOptionRTC(tubeRemoveSigma2, float, 1.f * 1.f, "", 0, "Max sigma2 to mark adjacent cluster for removal")
+AddOptionRTC(tubeRemoveMaxSize2, float, 1.5f * 1.5f, "", 0, "Square of max tube size (if smaller than tubeRejectChi2)")
 AddOptionRTC(clustersShiftTimebins, float, 0, "", 0, "Shift of TPC clusters (applied during CTF cluster decoding)")
 AddOptionRTC(clustersShiftTimebinsClusterizer, float, 0, "", 0, "Shift of TPC clusters (applied during CTF clusterization)")
 AddOptionRTC(clustersEdgeFixDistance, float, 0.f, "", 0, "If >0, revert cluster.flag edge bit distance to edge exceeds this parameter (fixed during CTF decoding)")
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 0e9cbdacee24e..0adfae0aa1fbd 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -518,8 +518,11 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
 
   float err2Y, err2Z;
   Merger->Param().GetClusterErrors2(sector, iRow, Z, mP[2], mP[3], -1.f, 0.f, 0.f, err2Y, err2Z);                                       // TODO: Use correct time/avgCharge
-  const float sy2 = CAMath::Min(Merger->Param().rec.tpc.tubeMaxSize2, Merger->Param().rec.tpc.tubeChi2 * (err2Y + CAMath::Abs(mC[0]))); // Cov can be bogus when following circle
-  const float sz2 = CAMath::Min(Merger->Param().rec.tpc.tubeMaxSize2, Merger->Param().rec.tpc.tubeChi2 * (err2Z + CAMath::Abs(mC[2]))); // In that case we should provide the track error externally
+  const float tubeMaxSize2 = protect ? Merger->Param().rec.tpc.tubeProtectMaxSize2 : Merger->Param().rec.tpc.tubeRemoveMaxSize2;
+  const float tubeMinSize2 = protect ? Merger->Param().rec.tpc.tubeProtectMinSize2 : 0.f;
+  const float tubeSigma2 = protect ? Merger->Param().rec.tpc.tubeProtectSigma2 : Merger->Param().rec.tpc.tubeRemoveSigma2;
+  const float sy2 = CAMath::Max(tubeMinSize2, CAMath::Min(tubeMaxSize2, tubeSigma2 * (err2Y + CAMath::Abs(mC[0])))); // Cov can be bogus when following circle
+  const float sz2 = CAMath::Max(tubeMinSize2, CAMath::Min(tubeMaxSize2, tubeSigma2 * (err2Z + CAMath::Abs(mC[2])))); // In that case we should provide the track error externally
   const float tubeY = CAMath::Sqrt(sy2);
   const float tubeZ = CAMath::Sqrt(sz2);
   const float sy21 = 1.f / sy2;

From 0efc03f8d2241f47ef71adcb7bcf231e5699b804 Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Mon, 3 Nov 2025 10:31:32 +0100
Subject: [PATCH 0995/1764] Fix chip composition and orientation (#14786)

---
 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index 223c8b5c477a1..021955c2e47ac 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -94,7 +94,7 @@ TGeoVolume* TRKLayer::createMetalStack(std::string type)
   if (type == "cylinder") {
     metalStack = new TGeoTube(mInnerRadius + mSensorThickness, mInnerRadius + mChipThickness, mChipLength / 2); // TO BE CHECKED !!!
   } else if (type == "flat") {
-    metalStack = new TGeoBBox(mChipWidth / 2, mChipThickness - mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
+    metalStack = new TGeoBBox(mChipWidth / 2, (mChipThickness - mSensorThickness) / 2, mChipLength / 2); // TO BE CHECKED !!!
   } else {
     LOGP(fatal, "Metal stack of type '{}' is not implemented", type);
   }
@@ -198,6 +198,9 @@ TGeoVolume* TRKLayer::createModule(std::string type)
 
       TGeoCombiTrans* transLeft = new TGeoCombiTrans();
       transLeft->SetTranslation(xLeft, 0, zLeft); // TO BE CHECKED !!!
+      TGeoRotation* rot = new TGeoRotation();
+      rot->RotateY(180);
+      transLeft->SetRotation(rot);
       LOGP(info, "Inserting {} in {} ", chipVolLeft->GetName(), moduleVol->GetName());
       moduleVol->AddNode(chipVolLeft, iChip * 2, transLeft);
 
@@ -206,9 +209,6 @@ TGeoVolume* TRKLayer::createModule(std::string type)
 
       TGeoCombiTrans* transRight = new TGeoCombiTrans();
       transRight->SetTranslation(xRight, 0, zRight); // TO BE CHECKED !!!
-      TGeoRotation* rot = new TGeoRotation();
-      rot->RotateY(180);
-      transRight->SetRotation(rot);
       LOGP(info, "Inserting {} in {} ", chipVolRight->GetName(), moduleVol->GetName());
       moduleVol->AddNode(chipVolRight, iChip * 2 + 1, transRight);
     }

From 80787ec23bfbf46a9d28d0f5cf7ec68dde47b81a Mon Sep 17 00:00:00 2001
From: AizatDaribayeva <aizat.daribayeva@cern.ch>
Date: Mon, 3 Nov 2025 10:31:45 +0100
Subject: [PATCH 0996/1764] additional features added to TRK geometry (#14772)

* additional features added to TRK geometry

* Fix whitespace and formatting in geometry implementation

* minor corrections
---
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |  23 +++-
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      | 126 ++++++++++++++++++
 2 files changed, 148 insertions(+), 1 deletion(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index f900065ad738a..ee6f5f33fc9fe 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -93,6 +93,23 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   int getModule(int index) const;
   int getChip(int index) const;
 
+  void defineMLOTSensors();
+  int getBarrelLayer(int) const;
+
+  // sensor ref X and alpha for ML & OT
+  void extractSensorXAlphaMLOT(int, float&, float&);
+
+  // cache for tracking frames (ML & OT)
+  bool isTrackingFrameCachedMLOT() const { return !mCacheRefXMLOT.empty(); }
+  void fillTrackingFramesCacheMLOT();
+
+  float getSensorRefAlphaMLOT(int index) const { return mCacheRefAlphaMLOT[index]; }
+  float getSensorXMLOT(int index) const { return mCacheRefXMLOT[index]; }
+
+  // create matrix for tracking to local frame for MLOT
+  TGeoHMatrix& createT2LMatrixMLOT(int);
+
+  /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave /// TODO: retrieve also from chip when chips will be available
   /// This routine computes the chip index number from the subDetID, petal, disk, layer, stave, half stave, module, chip
   /// \param int subDetID The subdetector ID, 0 for VD, 1 for MLOT
   /// \param int petalcase The petal case number for VD, from 0 to 3
@@ -200,10 +217,14 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   bool mOwner = true; //! is it owned by the singleton?
 
+  std::vector<int> sensorsMLOT;
+  std::vector<float> mCacheRefXMLOT;     /// cache for X of ML and OT
+  std::vector<float> mCacheRefAlphaMLOT; /// cache for sensor ref alpha ML and OT
+
  private:
   static std::unique_ptr<o2::trk::GeometryTGeo> sInstance;
 };
 
 } // namespace trk
 } // namespace o2
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 3eadeed4b56f3..72caf1f4d5e20 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -12,6 +12,7 @@
 #include <TRKBase/GeometryTGeo.h>
 #include <TGeoManager.h>
 #include "TRKBase/SegmentationChip.h"
+#include <TMath.h>
 
 #include <limits>
 
@@ -123,6 +124,8 @@ void GeometryTGeo::Build(int loadTrans)
 
   setSize(numberOfChipsTotal);
   fillMatrixCache(loadTrans);
+  defineMLOTSensors();
+  fillTrackingFramesCacheMLOT();
 }
 
 //__________________________________________________________________________
@@ -466,6 +469,32 @@ TGeoHMatrix* GeometryTGeo::extractMatrixSensor(int index) const
   return &matTmp;
 }
 
+//__________________________________________________________________________
+void GeometryTGeo::defineMLOTSensors()
+{
+  for (int i = 0; i < mSize; i++) {
+    if (getSubDetID(i) == 0) {
+      continue;
+    }
+    sensorsMLOT.push_back(i);
+  }
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::fillTrackingFramesCacheMLOT()
+{
+  // fill for every sensor of ML & OT its tracking frame parameters
+  if (!isTrackingFrameCachedMLOT() && !sensorsMLOT.empty()) {
+    size_t newSize = sensorsMLOT.size();
+    mCacheRefXMLOT.resize(newSize);
+    mCacheRefAlphaMLOT.resize(newSize);
+    for (int i = 0; i < newSize; i++) {
+      int sensorId = sensorsMLOT[i];
+      extractSensorXAlphaMLOT(sensorId, mCacheRefXMLOT[i], mCacheRefAlphaMLOT[i]);
+    }
+  }
+}
+
 //__________________________________________________________________________
 void GeometryTGeo::fillMatrixCache(int mask)
 {
@@ -488,6 +517,21 @@ void GeometryTGeo::fillMatrixCache(int mask)
     }
   }
 
+  // build T2L matrices for ML & OT !! VD is yet to be implemented once its geometry will be more refined
+  if ((mask & o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L)) && !getCacheT2L().isFilled()) {
+    LOGP(info, "Loading {} T2L matrices from TGeo for ML & OT", getName());
+    if (sensorsMLOT.size()) {
+      int m_Size = sensorsMLOT.size();
+      auto& cacheT2L = getCacheT2L();
+      cacheT2L.setSize(m_Size);
+      for (int i = 0; i < m_Size; i++) {
+        int sensorID = sensorsMLOT[i];
+        TGeoHMatrix& hm = createT2LMatrixMLOT(sensorID);
+        cacheT2L.setMatrix(Mat3D(hm), i); // here, sensorIDs from 0 to 374, sensorIDs shifted to 36 !
+      }
+    }
+  }
+
   // TODO: build matrices for the cases T2L, T2G and T2GRot when needed
 }
 
@@ -1109,5 +1153,87 @@ void GeometryTGeo::Print(Option_t*) const
   std::cout << "]" << std::endl;
 }
 
+//__________________________________________________________________________
+int GeometryTGeo::getBarrelLayer(int chipID) const
+{
+  // for barrel layers only,
+  // so it would be consistent with number of layers i.e. from 0 to 10,
+  // starting from VD0 to OT10;
+  // skip the disks;
+
+  int subDetID = getSubDetID(chipID);
+  int subLayerID = getLayer(chipID);
+
+  if (subDetID < 0 || subDetID > 1) {
+    LOG(error) << "getBarrelLayer(): Invalid subDetID for barrel: " << subDetID
+               << ". Expected values are 0 or 1.";
+    return -1;
+  }
+
+  if (subLayerID < 0 || subLayerID > 7) {
+    LOG(error) << "getBarrelLayer(): Invalid subLayerID for barrel: " << subDetID
+               << ". Expected values are between 0 and 7.";
+    return -1;
+  }
+
+  const int baseOffsets[] = {0, 3};
+
+  return baseOffsets[subDetID] + subLayerID;
+}
+
+//__________________________________________________________________________
+void GeometryTGeo::extractSensorXAlphaMLOT(int chipID, float& x, float& alp)
+{
+  // works for ML and OT only, a.k.a flat sensors !!!
+  double locA[3] = {-100., 0., 0.}, locB[3] = {100., 0., 0.}, gloA[3], gloB[3];
+  double xp{0}, yp{0};
+
+  if (getSubDetID(chipID) == 0) {
+
+    LOG(error) << "extractSensorXAlphaMLOT(): VD layers are not supported yet! chipID = " << chipID;
+    return;
+
+  } else { // flat sensors, ML and OT
+    const TGeoHMatrix* matL2G = extractMatrixSensor(chipID);
+    matL2G->LocalToMaster(locA, gloA);
+    matL2G->LocalToMaster(locB, gloB);
+    double dx = gloB[0] - gloA[0], dy = gloB[1] - gloA[1];
+    double t = (gloB[0] * dx + gloB[1] * dy) / (dx * dx + dy * dy);
+    xp = gloB[0] - dx * t;
+    yp = gloB[1] - dy * t;
+  }
+
+  alp = std::atan2(yp, xp);
+  x = std::hypot(xp, yp);
+  o2::math_utils::bringTo02Pi(alp);
+
+  /// TODO:
+  // once the VD segmentation is done, VD should be added
+}
+
+//__________________________________________________________________________
+TGeoHMatrix& GeometryTGeo::createT2LMatrixMLOT(int chipID)
+{
+  // works only for ML & OT
+  // for VD is yet to be implemented once we have more refined geometry
+  if (getSubDetID(chipID) == 0) {
+
+    LOG(error) << "createT2LMatrixMLOT(): VD layers are not supported yet! chipID = " << chipID
+               << "returning dummy values! ";
+    static TGeoHMatrix dummy;
+    return dummy;
+
+  } else {
+    static TGeoHMatrix t2l;
+    t2l.Clear();
+    float alpha = getSensorRefAlphaMLOT(chipID);
+    t2l.RotateZ(alpha * TMath::RadToDeg());
+    const TGeoHMatrix* matL2G = extractMatrixSensor(chipID);
+    const TGeoHMatrix& matL2Gi = matL2G->Inverse();
+    t2l.MultiplyLeft(&matL2Gi);
+    return t2l;
+  }
+}
+
 } // namespace trk
 } // namespace o2

From ed79b66f9f46705a08058b2f1948fd4870b1912a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 3 Nov 2025 17:20:25 +0100
Subject: [PATCH 0997/1764] GPU TPC: Fix possible division by 0

---
 GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
index 7f5e485c54409..b2949b5a98fd2 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
@@ -120,7 +120,7 @@ void GPUTPCDecompression::SetMaxData(const GPUTrackingInOutPointers& io)
   uint32_t maxAttachedClsMargin1 = *std::max_element(mInputGPU.nSliceRowClusters, mInputGPU.nSliceRowClusters + mInputGPU.nSliceRows);
   float clsRatio1 = (mInputGPU.nUnattachedClusters > 0 ? float(mInputGPU.nAttachedClusters) / float(mInputGPU.nUnattachedClusters) : 1.0f) * 1.5f;
   maxAttachedClsMargin1 *= clsRatio1;
-  uint32_t maxAttachedClsMargin2 = mInputGPU.nAttachedClusters / mInputGPU.nSliceRows * 3.5;                                             // mean #attached cls per SectorRow multiplied by 3.5 (tuned)
+  uint32_t maxAttachedClsMargin2 = mInputGPU.nSliceRows > 0 ? (mInputGPU.nAttachedClusters / mInputGPU.nSliceRows * 3.5) : 0;            // mean #attached cls per SectorRow multiplied by 3.5 (tuned)
   mMaxNativeClustersPerBuffer = std::max({maxAttachedClsMargin1, maxAttachedClsMargin2, 1000u});                                         // take biggest margin, 1000 clusters minimum
   mMaxNativeClustersPerBuffer = std::min(mMaxNativeClustersPerBuffer, mRec->GetProcessingSettings().tpcMaxAttachedClustersPerSectorRow); // upperbound given by configurable param
 }

From 898c79334d93d381e141ba35d50418a7d584e1ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Tue, 4 Nov 2025 15:55:52 +0100
Subject: [PATCH 0998/1764] Fix namespace closing for o2 in BunchFilling.h
 (#14791)

---
 DataFormats/common/include/CommonDataFormat/BunchFilling.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/common/include/CommonDataFormat/BunchFilling.h b/DataFormats/common/include/CommonDataFormat/BunchFilling.h
index 182a665532668..f11ce2498d04b 100644
--- a/DataFormats/common/include/CommonDataFormat/BunchFilling.h
+++ b/DataFormats/common/include/CommonDataFormat/BunchFilling.h
@@ -107,7 +107,6 @@ class BunchFilling
 
   ClassDefNV(BunchFilling, 2);
 };
-} // namespace o2
 
 namespace framework
 {
@@ -118,5 +117,6 @@ struct is_messageable<o2::BunchFilling> : std::true_type {
 };
 
 } // namespace framework
+} // namespace o2
 
 #endif

From cad3e3fa3311b3580a3c68a3bf36b04ddcdf84ea Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 4 Nov 2025 14:10:05 +0100
Subject: [PATCH 0999/1764] DPL: get rid of call_if_defined

---
 .../Foundation/include/Framework/CheckTypes.h | 31 +++++--------------
 1 file changed, 7 insertions(+), 24 deletions(-)

diff --git a/Framework/Foundation/include/Framework/CheckTypes.h b/Framework/Foundation/include/Framework/CheckTypes.h
index f0c74c54f9790..95e99a67ac0cf 100644
--- a/Framework/Foundation/include/Framework/CheckTypes.h
+++ b/Framework/Foundation/include/Framework/CheckTypes.h
@@ -18,13 +18,15 @@
 namespace o2::framework
 {
 
-/// Helper to understand if a given type is complete (declared fully) or not (forward declared).
-/// See also: https://devblogs.microsoft.com/oldnewthing/20190710-00/?p=102678
-template <typename, typename = void>
-constexpr bool is_type_complete_v = false;
+template <typename T>
+concept TypeComplete = requires(T) {
+  {
+    sizeof(T)
+  };
+};
 
 template <typename T>
-constexpr bool is_type_complete_v<T, std::void_t<decltype(sizeof(T))>> = true;
+constexpr bool is_type_complete_v = TypeComplete<T>;
 
 /// Helper which will invoke @a onDefined if the type T is actually available
 /// or @a onUndefined if the type T is a forward declaration.
@@ -39,31 +41,12 @@ void call_if_defined_full(TDefined&& onDefined, TUndefined&& onUndefined)
   }
 }
 
-/// Helper which will invoke @a onDefined if the type T is actually available
-/// or @a onUndefined if the type T is a forward declaration.
-/// Can be used to check for existence or not of a given type.
-template <typename T, typename TDefined, typename TUndefined>
-T call_if_defined_full_forward(TDefined&& onDefined, TUndefined&& onUndefined)
-{
-  if constexpr (is_type_complete_v<T>) {
-    return std::move(onDefined(static_cast<T*>(nullptr)));
-  } else {
-    return onUndefined();
-  }
-}
-
 template <typename T, typename TDefined>
 void call_if_defined(TDefined&& onDefined)
 {
   call_if_defined_full<T>(onDefined, []() -> void {});
 }
 
-template <typename T, typename TDefined>
-T call_if_defined_forward(TDefined&& onDefined)
-{
-  return std::move(call_if_defined_full_forward<T>(onDefined, []() -> T&& { O2_BUILTIN_UNREACHABLE(); }));
-}
-
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_CHECKTYPES_H_

From faf754d986607d51a4356341835a6eaa3840426c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 4 Nov 2025 12:29:38 +0100
Subject: [PATCH 1000/1764] DPL: add signposts to debug task scheduling

---
 Framework/Core/src/DataProcessingDevice.cxx | 29 +++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index aa194b525ca5d..86e2aab53791d 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 #include "Framework/AsyncQueue.h"
 #include "Framework/DataProcessingDevice.h"
+#include <atomic>
 #include "Framework/ControlService.h"
 #include "Framework/ComputingQuotaEvaluator.h"
 #include "Framework/DataProcessingHeader.h"
@@ -99,6 +100,8 @@ O2_DECLARE_DYNAMIC_LOG(async_queue);
 O2_DECLARE_DYNAMIC_LOG(forwarding);
 // Special log to track CCDB related requests
 O2_DECLARE_DYNAMIC_LOG(ccdb);
+// Special log to track task scheduling
+O2_DECLARE_DYNAMIC_LOG(scheduling);
 
 using namespace o2::framework;
 using ConfigurationInterface = o2::configuration::ConfigurationInterface;
@@ -1551,10 +1554,22 @@ void DataProcessingDevice::Run()
       auto& spec = ref.get<DeviceSpec const>();
       bool enough = ref.get<ComputingQuotaEvaluator>().selectOffer(streamRef.index, spec.resourcePolicy.request, uv_now(state.loop));
 
+      struct SchedulingStats {
+        std::atomic<size_t> lastScheduled = 0;
+        std::atomic<size_t> numberOfUnscheduledSinceLastScheduled = 0;
+        std::atomic<size_t> numberOfUnscheduled = 0;
+        std::atomic<size_t> numberOfScheduled = 0;
+      };
+      static SchedulingStats schedulingStats;
+      O2_SIGNPOST_ID_GENERATE(sid, scheduling);
       if (enough) {
         stream.id = streamRef;
         stream.running = true;
         stream.registry = &mServiceRegistry;
+        schedulingStats.lastScheduled = uv_now(state.loop);
+        schedulingStats.numberOfScheduled++;
+        schedulingStats.numberOfUnscheduledSinceLastScheduled = 0;
+        O2_SIGNPOST_EVENT_EMIT(scheduling, sid, "Run", "Enough resources to schedule computation on stream %d", streamRef.index);
         if (dplEnableMultithreding) [[unlikely]] {
           stream.task = &handle;
           uv_queue_work(state.loop, stream.task, run_callback, run_completion);
@@ -1563,6 +1578,20 @@ void DataProcessingDevice::Run()
           run_completion(&handle, 0);
         }
       } else {
+        if (schedulingStats.numberOfUnscheduledSinceLastScheduled > 100 ||
+            (uv_now(state.loop) - schedulingStats.lastScheduled) > 30000) {
+          O2_SIGNPOST_EVENT_EMIT_WARN(scheduling, sid, "Run",
+                                      "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu.",
+                                      schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
+                                      schedulingStats.lastScheduled.load());
+        } else {
+          O2_SIGNPOST_EVENT_EMIT(scheduling, sid, "Run",
+                                 "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu.",
+                                 schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
+                                 schedulingStats.lastScheduled.load());
+        }
+        schedulingStats.numberOfUnscheduled++;
+        schedulingStats.numberOfUnscheduledSinceLastScheduled++;
         auto ref = ServiceRegistryRef{mServiceRegistry};
         ref.get<ComputingQuotaEvaluator>().handleExpired(reportExpiredOffer);
       }

From 72c942b4ca8f09533bb3aac121136cac54d3a32d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 4 Nov 2025 12:29:38 +0100
Subject: [PATCH 1001/1764] DPL analysis: support timeslice rate limiting in
 DPL resource manager

Use DPL resource manager rather than the ad-hoc solution for reconstruction.
---
 .../src/AODJAlienReaderHelpers.cxx            |   1 +
 .../include/Framework/CommonDataProcessors.h  |   3 +
 .../include/Framework/ComputingQuotaOffer.h   |   4 +
 .../include/Framework/DataProcessingStats.h   |   2 +
 .../include/Framework/ResourcePolicyHelpers.h |   1 +
 Framework/Core/src/ArrowSupport.cxx           | 108 ++++++++++++------
 Framework/Core/src/CommonDataProcessors.cxx   |  39 +++++++
 Framework/Core/src/CommonServices.cxx         |  16 +++
 .../Core/src/ComputingQuotaEvaluator.cxx      |  53 ++++++---
 Framework/Core/src/DataProcessingDevice.cxx   |   5 +
 Framework/Core/src/ResourcePolicy.cxx         |   3 +-
 Framework/Core/src/ResourcePolicyHelpers.cxx  |  34 +++++-
 Framework/Core/src/WSDriverClient.cxx         |  33 +++++-
 Framework/Core/src/WorkflowHelpers.cxx        |  16 ++-
 .../src/FrameworkGUIDeviceInspector.cxx       |   4 +
 15 files changed, 255 insertions(+), 67 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
index 85ed9cd573d8a..1d4ae5a4d3c49 100644
--- a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
@@ -145,6 +145,7 @@ AlgorithmSpec AODJAlienReaderHelpers::rootFileReaderCallback(ConfigContext const
     stats.updateStats({static_cast<short>(ProcessingStatsId::ARROW_BYTES_DESTROYED), DataProcessingStats::Op::Set, 0});
     stats.updateStats({static_cast<short>(ProcessingStatsId::ARROW_MESSAGES_DESTROYED), DataProcessingStats::Op::Set, 0});
     stats.updateStats({static_cast<short>(ProcessingStatsId::ARROW_BYTES_EXPIRED), DataProcessingStats::Op::Set, 0});
+    stats.updateStats({static_cast<short>(ProcessingStatsId::CONSUMED_TIMEFRAMES), DataProcessingStats::Op::Set, 0});
 
     if (!options.isSet("aod-file-private")) {
       LOGP(fatal, "No input file defined!");
diff --git a/Framework/Core/include/Framework/CommonDataProcessors.h b/Framework/Core/include/Framework/CommonDataProcessors.h
index 824386c4d5921..d3ef596a0c0e0 100644
--- a/Framework/Core/include/Framework/CommonDataProcessors.h
+++ b/Framework/Core/include/Framework/CommonDataProcessors.h
@@ -37,6 +37,9 @@ struct CommonDataProcessors {
   /// and simply discards them. @a rateLimitingChannelConfig is the configuration
   /// for the rate limiting channel, if any required.
   static DataProcessorSpec getDummySink(std::vector<InputSpec> const& danglingInputs, std::string rateLimitingChannelConfig);
+  /// @return a dummy DataProcessorSpec which requires all the passed @a InputSpec
+  /// and simply discards them. Rate limiting goes through the DPL driver
+  static DataProcessorSpec getScheduledDummySink(std::vector<InputSpec> const& danglingInputs);
   static AlgorithmSpec wrapWithRateLimiting(AlgorithmSpec spec);
 };
 
diff --git a/Framework/Core/include/Framework/ComputingQuotaOffer.h b/Framework/Core/include/Framework/ComputingQuotaOffer.h
index f457f46eef774..b7707613bc19d 100644
--- a/Framework/Core/include/Framework/ComputingQuotaOffer.h
+++ b/Framework/Core/include/Framework/ComputingQuotaOffer.h
@@ -44,6 +44,8 @@ struct ComputingQuotaOffer {
   int64_t memory = 0;
   /// How much shared memory it can allocate
   int64_t sharedMemory = 0;
+  /// How many timeslices it can process without giving back control
+  int64_t timeslices = 0;
   /// How much runtime it can use before giving back the resource
   /// in milliseconds.
   int64_t runtime = 0;
@@ -68,8 +70,10 @@ struct ComputingQuotaInfo {
 /// Statistics on the offers consumed, expired
 struct ComputingQuotaStats {
   int64_t totalConsumedBytes = 0;
+  int64_t totalConsumedTimeslices = 0;
   int64_t totalConsumedOffers = 0;
   int64_t totalExpiredBytes = 0;
+  int64_t totalExpiredTimeslices = 0;
   int64_t totalExpiredOffers = 0;
 };
 
diff --git a/Framework/Core/include/Framework/DataProcessingStats.h b/Framework/Core/include/Framework/DataProcessingStats.h
index d42f9a9d26610..e115e5d12b58f 100644
--- a/Framework/Core/include/Framework/DataProcessingStats.h
+++ b/Framework/Core/include/Framework/DataProcessingStats.h
@@ -60,8 +60,10 @@ enum struct ProcessingStatsId : short {
   ARROW_MESSAGES_CREATED,
   ARROW_MESSAGES_DESTROYED,
   ARROW_BYTES_EXPIRED,
+  TIMESLICE_NUMBER_EXPIRED,
   RESOURCE_OFFER_EXPIRED,
   SHM_OFFER_BYTES_CONSUMED,
+  TIMESLICE_OFFER_NUMBER_CONSUMED,
   RESOURCES_MISSING,
   RESOURCES_INSUFFICIENT,
   RESOURCES_SATISFACTORY,
diff --git a/Framework/Core/include/Framework/ResourcePolicyHelpers.h b/Framework/Core/include/Framework/ResourcePolicyHelpers.h
index abee264d75104..17599f9afb1a7 100644
--- a/Framework/Core/include/Framework/ResourcePolicyHelpers.h
+++ b/Framework/Core/include/Framework/ResourcePolicyHelpers.h
@@ -22,6 +22,7 @@ namespace o2::framework
 struct ResourcePolicyHelpers {
   static ResourcePolicy trivialTask(char const* taskMatcher);
   static ResourcePolicy cpuBoundTask(char const* taskMatcher, int maxCPUs = 1);
+  static ResourcePolicy rateLimitedSharedMemoryBoundTask(char const* taskMatcher, int maxMemory, int maxTimeslices);
   static ResourcePolicy sharedMemoryBoundTask(char const* taskMatcher, int maxMemory);
 };
 
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 397a6f5113d13..932c1fdacacfb 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -65,7 +65,7 @@ enum struct RateLimitingState {
 
 struct RateLimitConfig {
   int64_t maxMemory = 2000;
-  int64_t maxTimeframes = 0;
+  int64_t maxTimeframes = 1;
 };
 
 struct MetricIndices {
@@ -77,6 +77,7 @@ struct MetricIndices {
   size_t shmOfferBytesConsumed = -1;
   size_t timeframesRead = -1;
   size_t timeframesConsumed = -1;
+  size_t timeframesExpired = -1;
 };
 
 std::vector<MetricIndices> createDefaultIndices(std::vector<DeviceMetricsInfo>& allDevicesMetrics)
@@ -84,25 +85,20 @@ std::vector<MetricIndices> createDefaultIndices(std::vector<DeviceMetricsInfo>&
   std::vector<MetricIndices> results;
 
   for (auto& info : allDevicesMetrics) {
-    MetricIndices indices;
-    indices.arrowBytesCreated = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-bytes-created");
-    indices.arrowBytesDestroyed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-bytes-destroyed");
-    indices.arrowMessagesCreated = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-messages-created");
-    indices.arrowMessagesDestroyed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-messages-destroyed");
-    indices.arrowBytesExpired = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-bytes-expired");
-    indices.shmOfferBytesConsumed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "shm-offer-bytes-consumed");
-    indices.timeframesRead = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "df-sent");
-    indices.timeframesConsumed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "consumed-timeframes");
-    results.push_back(indices);
+    results.emplace_back(MetricIndices{
+      .arrowBytesCreated = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-bytes-created"),
+      .arrowBytesDestroyed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-bytes-destroyed"),
+      .arrowMessagesCreated = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-messages-created"),
+      .arrowMessagesDestroyed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-messages-destroyed"),
+      .arrowBytesExpired = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "arrow-bytes-expired"),
+      .shmOfferBytesConsumed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "shm-offer-bytes-consumed"),
+      .timeframesRead = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "df-sent"),
+      .timeframesConsumed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "consumed-timeframes"),
+      .timeframesExpired = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "expired-timeframes")});
   }
   return results;
 }
 
-uint64_t calculateAvailableSharedMemory(ServiceRegistryRef registry)
-{
-  return registry.get<RateLimitConfig>().maxMemory;
-}
-
 struct ResourceState {
   int64_t available;
   int64_t offered = 0;
@@ -205,29 +201,30 @@ auto offerResources(ResourceState& resourceState,
   // unusedOfferedSharedMemory is the amount of memory which was offered and which we know it was
   // not used so far. So we need to account for the amount which got actually read (readerBytesCreated)
   // and the amount which we know was given back.
-  static int64_t lastShmOfferConsumed = 0;
-  static int64_t lastUnusedOfferedMemory = 0;
-  if (offerConsumedCurrentValue != lastShmOfferConsumed) {
+  static int64_t lastResourceOfferConsumed = 0;
+  static int64_t lastUnusedOfferedResource = 0;
+  if (offerConsumedCurrentValue != lastResourceOfferConsumed) {
     O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
                            "Offer consumed so far %llu", offerConsumedCurrentValue);
-    lastShmOfferConsumed = offerConsumedCurrentValue;
+    lastResourceOfferConsumed = offerConsumedCurrentValue;
   }
-  int unusedOfferedMemory = (resourceState.offered - (offerExpiredCurrentValue + offerConsumedCurrentValue) / resourceSpec.metricOfferScaleFactor);
-  if (lastUnusedOfferedMemory != unusedOfferedMemory) {
+  int unusedOfferedResource = (resourceState.offered - (offerExpiredCurrentValue + offerConsumedCurrentValue) / resourceSpec.metricOfferScaleFactor);
+  if (lastUnusedOfferedResource != unusedOfferedResource) {
     O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
-                           "unusedOfferedMemory:%{bytes}d = offered:%{bytes}llu - (expired:%{bytes}llu + consumed:%{bytes}llu) / %lli",
-                           unusedOfferedMemory, resourceState.offered,
+                           "unusedOfferedResource(%{public}s):%{bytes}d = offered:%{bytes}llu - (expired:%{bytes}llu + consumed:%{bytes}llu) / %lli",
+                           resourceSpec.name,
+                           unusedOfferedResource, resourceState.offered,
                            offerExpiredCurrentValue / resourceSpec.metricOfferScaleFactor,
                            offerConsumedCurrentValue / resourceSpec.metricOfferScaleFactor,
                            resourceSpec.metricOfferScaleFactor);
-    lastUnusedOfferedMemory = unusedOfferedMemory;
+    lastUnusedOfferedResource = unusedOfferedResource;
   }
   // availableSharedMemory is the amount of memory which we know is available to be offered.
   // We subtract the amount which we know was already offered but it's unused and we then balance how
   // much was created with how much was destroyed.
-  resourceState.available = resourceSpec.maxAvailable + ((disposedResourceCurrentValue - acquiredResourceCurrentValue) / resourceSpec.metricOfferScaleFactor) - unusedOfferedMemory;
+  resourceState.available = resourceSpec.maxAvailable + ((disposedResourceCurrentValue - acquiredResourceCurrentValue) / resourceSpec.metricOfferScaleFactor) - unusedOfferedResource;
   availableResourceMetric(driverMetrics, resourceState.available, timestamp);
-  unusedOfferedResourceMetric(driverMetrics, unusedOfferedMemory, timestamp);
+  unusedOfferedResourceMetric(driverMetrics, unusedOfferedResource, timestamp);
 
   offeredResourceMetric(driverMetrics, resourceState.offered, timestamp);
 };
@@ -258,6 +255,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        int64_t totalMessagesDestroyed = 0;
                        int64_t totalTimeframesRead = 0;
                        int64_t totalTimeframesConsumed = 0;
+                       int64_t totalTimeframesExpired = 0;
                        auto &driverMetrics = sm.driverMetricsInfo;
                        auto &allDeviceMetrics = sm.deviceMetricsInfos;
                        auto &specs = sm.deviceSpecs;
@@ -266,9 +264,14 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        static auto stateMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "rate-limit-state");
                        static auto totalBytesCreatedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-arrow-bytes-created");
                        static auto shmOfferConsumedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-shm-offer-bytes-consumed");
+                       // These are really to monitor the rate limiting
                        static auto unusedOfferedSharedMemoryMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-unused-offered-shared-memory");
+                       static auto unusedOfferedTimeslicesMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-unused-offered-timeslices");
                        static auto availableSharedMemoryMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-available-shared-memory");
+                       static auto availableTimeslicesMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-available-timeslices");
                        static auto offeredSharedMemoryMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-offered-shared-memory");
+                       static auto offeredTimeslicesMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-offered-timeslices");
+
                        static auto totalBytesDestroyedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-arrow-bytes-destroyed");
                        static auto totalBytesExpiredMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-arrow-bytes-expired");
                        static auto totalMessagesCreatedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-arrow-messages-created");
@@ -390,6 +393,18 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                            auto const& timestamps = DeviceMetricsHelper::getTimestampsStore<uint64_t>(deviceMetrics)[info.storeIdx];
                            lastTimestamp = std::max(lastTimestamp, timestamps[(info.pos - 1) % data.size()]);
                          }
+                         {
+                           size_t index = indices.timeframesExpired;
+                           assert(index < deviceMetrics.metrics.size());
+                           changed |= deviceMetrics.changed[index];
+                           MetricInfo info = deviceMetrics.metrics[index];
+                           assert(info.storeIdx < deviceMetrics.uint64Metrics.size());
+                           auto& data = deviceMetrics.uint64Metrics[info.storeIdx];
+                           auto value = (int64_t)data[(info.pos - 1) % data.size()];
+                           totalTimeframesExpired += value;
+                           auto const& timestamps = DeviceMetricsHelper::getTimestampsStore<uint64_t>(deviceMetrics)[info.storeIdx];
+                           lastTimestamp = std::max(lastTimestamp, timestamps[(info.pos - 1) % data.size()]);
+                         }
                        }
                        static uint64_t unchangedCount = 0;
                        if (changed) {
@@ -407,26 +422,45 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                          unchangedCount++;
                        }
                        changedCountMetric(driverMetrics, unchangedCount, timestamp);
-                       auto maxTimeframes = registry.get<RateLimitConfig>().maxTimeframes;
-                       if (maxTimeframes && (totalTimeframesRead - totalTimeframesConsumed) > maxTimeframes) {
-                         return;
-                       }
+
                        static const ResourceSpec shmResourceSpec{
                          .name = "shared memory",
                          .unit = "MB",
                          .api = "/shm-offer {}",
-                         .maxAvailable = (int64_t)calculateAvailableSharedMemory(registry),
+                         .maxAvailable = (int64_t)registry.get<RateLimitConfig>().maxMemory,
                          .maxQuantum = 100,
                          .minQuantum = 50,
                          .metricOfferScaleFactor = 1000000,
                        };
+                       static const ResourceSpec timesliceResourceSpec{
+                         .name = "timeslice",
+                         .unit = "timeslices",
+                         .api = "/timeslice-offer {}",
+                         .maxAvailable = (int64_t)registry.get<RateLimitConfig>().maxTimeframes,
+                         .maxQuantum = 1,
+                         .minQuantum = 1,
+                         .metricOfferScaleFactor = 1,
+                       };
                        static ResourceState shmResourceState{
                          .available = shmResourceSpec.maxAvailable,
                        };
+                       static ResourceState timesliceResourceState{
+                         .available = timesliceResourceSpec.maxAvailable,
+                       };
                        static ResourceStats shmResourceStats{
                          .enoughCount = shmResourceState.available - shmResourceSpec.minQuantum > 0 ? 1 : 0,
                          .lowCount = shmResourceState.available - shmResourceSpec.minQuantum > 0 ? 0 : 1
                        };
+                       static ResourceStats timesliceResourceStats{
+                         .enoughCount = shmResourceState.available - shmResourceSpec.minQuantum > 0 ? 1 : 0,
+                         .lowCount = shmResourceState.available - shmResourceSpec.minQuantum > 0 ? 0 : 1
+                       };
+
+                       offerResources(timesliceResourceState, timesliceResourceSpec, timesliceResourceStats,
+                                      specs, infos, manager, totalTimeframesConsumed, totalTimeframesExpired,
+                                      totalTimeframesRead, totalTimeframesConsumed, timestamp, driverMetrics,
+                                      availableTimeslicesMetric, unusedOfferedTimeslicesMetric, offeredTimeslicesMetric,
+                                      (void*)&sm);
 
                        offerResources(shmResourceState, shmResourceSpec, shmResourceStats,
                                       specs, infos, manager, shmOfferBytesConsumed, totalBytesExpired,
@@ -487,18 +521,18 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        } else {
                          config->maxMemory = readers * 500;
                        }
-                       if (dc.options.count("timeframes-rate-limit") && dc.options["timeframes-rate-limit"].as<std::string>() == "readers") {
-                         config->maxTimeframes = readers;
-                       } else {
+                       if (dc.options.count("timeframes-rate-limit") && dc.options["timeframes-rate-limit"].defaulted() == false) {
                          config->maxTimeframes = std::stoll(dc.options["timeframes-rate-limit"].as<std::string>());
+                       } else {
+                         config->maxTimeframes = readers;
                        }
                        static bool once = false;
                        // Until we guarantee this is called only once...
                        if (!once) {
                          O2_SIGNPOST_ID_GENERATE(sid, rate_limiting);
                          O2_SIGNPOST_EVENT_EMIT_INFO(rate_limiting, sid, "setup",
-                                                     "Rate limiting set up at %{bytes}llu MB distributed over %d readers",
-                                                     config->maxMemory, readers);
+                                                     "Rate limiting set up at %{bytes}llu MB and %llu timeframes distributed over %d readers",
+                                                     config->maxMemory, config->maxTimeframes, readers);
                          registry.registerService(ServiceRegistryHelpers::handleForService<RateLimitConfig>(config));
                          once = true;
                        } },
diff --git a/Framework/Core/src/CommonDataProcessors.cxx b/Framework/Core/src/CommonDataProcessors.cxx
index c2431b3ab068d..4d82cb7124e64 100644
--- a/Framework/Core/src/CommonDataProcessors.cxx
+++ b/Framework/Core/src/CommonDataProcessors.cxx
@@ -44,6 +44,7 @@ using namespace o2::framework::data_matcher;
 
 // Special log to track callbacks we know about
 O2_DECLARE_DYNAMIC_LOG(callbacks);
+O2_DECLARE_DYNAMIC_LOG(rate_limiting);
 
 namespace o2::framework
 {
@@ -211,6 +212,8 @@ DataProcessorSpec CommonDataProcessors::getDummySink(std::vector<InputSpec> cons
         auto oldestPossingTimeslice = timesliceIndex.getOldestPossibleOutput().timeslice.value;
         auto& stats = services.get<DataProcessingStats>();
         stats.updateStats({(int)ProcessingStatsId::CONSUMED_TIMEFRAMES, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.processCommandQueue();
       };
       callbacks.set<CallbackService::Id::DomainInfoUpdated>(domainInfoUpdated);
 
@@ -224,6 +227,42 @@ DataProcessorSpec CommonDataProcessors::getDummySink(std::vector<InputSpec> cons
     .labels = {{"resilient"}}};
 }
 
+// For the cases were the driver is guaranteed to be there (e.g. in analysis) we can use a
+// more sophisticated controller which can get offers for timeslices so that we can rate limit
+// across multiple input devices and rate limit shared memory usage without race conditions
+DataProcessorSpec CommonDataProcessors::getScheduledDummySink(std::vector<InputSpec> const& danglingOutputInputs)
+{
+  return DataProcessorSpec{
+    .name = "internal-dpl-injected-dummy-sink",
+    .inputs = danglingOutputInputs,
+    .algorithm = AlgorithmSpec{adaptStateful([](CallbackService& callbacks, DeviceState& deviceState, InitContext& ic) {
+      // We update the number of consumed timeframes based on the oldestPossingTimeslice
+      // this information will be aggregated in the driver which will then decide wether or not a new offer for
+      // a timeslice should be done and to which device
+      auto domainInfoUpdated = [](ServiceRegistryRef services, size_t timeslice, ChannelIndex channelIndex) {
+        LOGP(info, "Domain info updated with timeslice {}", timeslice);
+        auto& timesliceIndex = services.get<TimesliceIndex>();
+        auto oldestPossingTimeslice = timesliceIndex.getOldestPossibleOutput().timeslice.value;
+        auto& stats = services.get<DataProcessingStats>();
+        O2_SIGNPOST_ID_GENERATE(sid, rate_limiting);
+        O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "run", "Consumed timeframes (domain info updated) to be set to %zu.", oldestPossingTimeslice);
+        stats.updateStats({(int)ProcessingStatsId::CONSUMED_TIMEFRAMES, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.processCommandQueue();
+      };
+      callbacks.set<CallbackService::Id::DomainInfoUpdated>(domainInfoUpdated);
+
+      return adaptStateless([](DataProcessingStats& stats, TimesliceIndex& timesliceIndex) {
+        O2_SIGNPOST_ID_GENERATE(sid, rate_limiting);
+        auto oldestPossingTimeslice = timesliceIndex.getOldestPossibleOutput().timeslice.value;
+        O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "run", "Consumed timeframes (processing) to be set to %zu.", oldestPossingTimeslice);
+        stats.updateStats({(int)ProcessingStatsId::CONSUMED_TIMEFRAMES, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+      });
+    })},
+    .labels = {{"resilient"}}};
+}
+
 AlgorithmSpec CommonDataProcessors::wrapWithRateLimiting(AlgorithmSpec spec)
 {
   return PluginManager::wrapAlgorithm(spec, [](AlgorithmSpec::ProcessCallback& original, ProcessingContext& pcx) -> void {
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 091cd9d4ed0a5..aedd96dab41ca 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -1080,6 +1080,22 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
                    .minPublishInterval = 0,
                    .maxRefreshLatency = 10000,
                    .sendInitialValue = true},
+        MetricSpec{.name = "timeslices-expired",
+                   .enabled = arrowAndResourceLimitingMetrics,
+                   .metricId = static_cast<short>(ProcessingStatsId::TIMESLICE_NUMBER_EXPIRED),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 0,
+                   .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
+        MetricSpec{.name = "timeslices-consumed",
+                   .enabled = arrowAndResourceLimitingMetrics,
+                   .metricId = static_cast<short>(ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 0,
+                   .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
         MetricSpec{.name = "resources-missing",
                    .enabled = enableDebugMetrics,
                    .metricId = static_cast<short>(ProcessingStatsId::RESOURCES_MISSING),
diff --git a/Framework/Core/src/ComputingQuotaEvaluator.cxx b/Framework/Core/src/ComputingQuotaEvaluator.cxx
index 717a59f5f5372..aa566ccb4d549 100644
--- a/Framework/Core/src/ComputingQuotaEvaluator.cxx
+++ b/Framework/Core/src/ComputingQuotaEvaluator.cxx
@@ -36,14 +36,14 @@ ComputingQuotaEvaluator::ComputingQuotaEvaluator(ServiceRegistryRef ref)
   // so this will only work with some device which does not require
   // any CPU. Notice this will have troubles if a given DPL process
   // runs for more than a year.
-  mOffers[0] = {
-    0,
-    0,
-    0,
-    -1,
-    -1,
-    OfferScore::Unneeded,
-    true};
+  mOffers[0] = ComputingQuotaOffer{
+    .cpu = 0,
+    .memory = 0,
+    .sharedMemory = 0,
+    .timeslices = 0,
+    .runtime = -1,
+    .score = OfferScore::Unneeded,
+    .valid = true};
   mInfos[0] = {
     uv_now(state.loop),
     0,
@@ -97,7 +97,7 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
                         result.size(), totalOffer.cpu, totalOffer.memory, totalOffer.sharedMemory);
       for (auto& offer : result) {
         // We pretend each offer id is a pointer, to have a unique id.
-        O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(offer*8));
+        O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(offer * 8));
         O2_SIGNPOST_START(quota, oid, "offers", "Offer %d has been selected.", offer);
       }
       dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCES_SATISFACTORY), DataProcessingStats::Op::Add, 1});
@@ -132,6 +132,7 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
     auto& offer = mOffers[i];
     auto& info = mInfos[i];
     if (enough) {
+      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "We have enough offers. We can continue for computation.");
       break;
     }
     // Ignore:
@@ -139,24 +140,26 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
     // - Offers which belong to another task
     // - Expired offers
     if (offer.valid == false) {
+      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d is not valid. Skipping", i);
       stats.invalidOffers.push_back(i);
       continue;
     }
     if (offer.user != -1 && offer.user != task) {
+      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d already offered to some other user", i);
       stats.otherUser.push_back(i);
       continue;
     }
     if (offer.runtime < 0) {
       stats.unexpiring.push_back(i);
     } else if (offer.runtime + info.received < now) {
-      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d expired since %llu milliseconds and holds %llu MB",
-                             i, now - offer.runtime - info.received, offer.sharedMemory / 1000000);
+      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d expired since %llu milliseconds and holds %llu MB and %llu timeslices",
+                             i, now - offer.runtime - info.received, offer.sharedMemory / 1000000, offer.timeslices);
       mExpiredOffers.push_back(ComputingQuotaOfferRef{i});
       stats.expired.push_back(i);
       continue;
     } else {
-      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d still valid for %llu milliseconds, providing %llu MB",
-                             i, offer.runtime + info.received - now, offer.sharedMemory / 1000000);
+      O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d still valid for %llu milliseconds, providing %llu MB and %llu timeslices",
+                             i, offer.runtime + info.received - now, offer.sharedMemory / 1000000, offer.timeslices);
       if (minValidity == 0) {
         minValidity = offer.runtime + info.received - now;
       }
@@ -168,22 +171,29 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
     tmp.cpu += offer.cpu;
     tmp.memory += offer.memory;
     tmp.sharedMemory += offer.sharedMemory;
-    offer.score = selector(offer, tmp);
+    tmp.timeslices += offer.timeslices;
+    offer.score = selector(offer, accumulated);
     switch (offer.score) {
       case OfferScore::Unneeded:
+        O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d considered not needed. Skipping", i);
         continue;
       case OfferScore::Unsuitable:
+        O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d considered Unsuitable. Skipping", i);
         continue;
       case OfferScore::More:
         selectOffer(i, now);
         accumulated = tmp;
         stats.selectedOffers.push_back(i);
+        O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Offer %d selected but not enough. %llu MB, %d cores and %llu timeslices are not enough.",
+                               i, tmp.sharedMemory / 1000000, tmp.cpu, tmp.timeslices);
         continue;
       case OfferScore::Enough:
         selectOffer(i, now);
         accumulated = tmp;
         stats.selectedOffers.push_back(i);
         enough = true;
+        O2_SIGNPOST_EVENT_EMIT(quota, qid, "select", "Selected %zu offers providing %llu MB, %d cores and %llu timeslices are deemed enough.",
+                               stats.selectedOffers.size(), tmp.sharedMemory / 1000000, tmp.cpu, tmp.timeslices);
         break;
     };
   }
@@ -224,7 +234,7 @@ void ComputingQuotaEvaluator::dispose(int taskId)
       continue;
     }
     if (offer.sharedMemory <= 0) {
-      O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(oi*8));
+      O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(oi * 8));
       O2_SIGNPOST_END(quota, oid, "offers", "Offer %d back to not needed.", oi);
       offer.valid = false;
       offer.score = OfferScore::Unneeded;
@@ -235,21 +245,28 @@ void ComputingQuotaEvaluator::dispose(int taskId)
 /// Move offers from the pending list to the actual available offers
 void ComputingQuotaEvaluator::updateOffers(std::vector<ComputingQuotaOffer>& pending, uint64_t now)
 {
+  O2_SIGNPOST_ID_GENERATE(oid, quota);
+  O2_SIGNPOST_START(quota, oid, "updateOffers", "Starting to processe received offers");
   for (size_t oi = 0; oi < mOffers.size(); oi++) {
     auto& storeOffer = mOffers[oi];
     auto& info = mInfos[oi];
     if (pending.empty()) {
+      O2_SIGNPOST_END(quota, oid, "updateOffers", "No more pending offers to process");
       return;
     }
     if (storeOffer.valid == true) {
+      O2_SIGNPOST_EVENT_EMIT(quota, oid, "updateOffers", "Skipping update of offer %zu because it's still valid", oi);
       continue;
     }
     info.received = now;
     auto& offer = pending.back();
+    O2_SIGNPOST_EVENT_EMIT(quota, oid, "updateOffers", "Updating of offer %zu at %llu. Cpu: %d, Shared Memory %lli, Timeslices: %lli",
+                           oi, now, offer.cpu, offer.sharedMemory, offer.timeslices);
     storeOffer = offer;
     storeOffer.valid = true;
     pending.pop_back();
   }
+  O2_SIGNPOST_END_WITH_ERROR(quota, oid, "updateOffers", "Some of the pending offers were not treated");
 }
 
 void ComputingQuotaEvaluator::handleExpired(std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats const& stats)> expirator)
@@ -269,7 +286,7 @@ void ComputingQuotaEvaluator::handleExpired(std::function<void(ComputingQuotaOff
   /// to the driver.
   for (auto& ref : mExpiredOffers) {
     auto& offer = mOffers[ref.index];
-    O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(ref.index*8));
+    O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(ref.index * 8));
     if (offer.sharedMemory < 0) {
       O2_SIGNPOST_END(quota, oid, "handleExpired", "Offer %d does not have any more memory. Marking it as invalid.", ref.index);
       offer.valid = false;
@@ -278,8 +295,8 @@ void ComputingQuotaEvaluator::handleExpired(std::function<void(ComputingQuotaOff
     }
     // FIXME: offers should go through the driver client, not the monitoring
     // api.
-    O2_SIGNPOST_END(quota, oid, "handleExpired", "Offer %d expired. Giving back %llu MB and %d cores",
-                    ref.index, offer.sharedMemory / 1000000, offer.cpu);
+    O2_SIGNPOST_END(quota, oid, "handleExpired", "Offer %d expired. Giving back %llu MB, %d cores and %llu timeslices",
+                    ref.index, offer.sharedMemory / 1000000, offer.cpu, offer.timeslices);
     assert(offer.sharedMemory >= 0);
     mStats.totalExpiredBytes += offer.sharedMemory;
     mStats.totalExpiredOffers++;
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 86e2aab53791d..5868557f2c80f 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -304,16 +304,20 @@ void run_completion(uv_work_t* handle, int status)
   static std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats&)> reportConsumedOffer = [ref](ComputingQuotaOffer const& accumulatedConsumed, ComputingQuotaStats& stats) {
     auto& dpStats = ref.get<DataProcessingStats>();
     stats.totalConsumedBytes += accumulatedConsumed.sharedMemory;
+    stats.totalConsumedTimeslices += accumulatedConsumed.timeslices;
 
     dpStats.updateStats({static_cast<short>(ProcessingStatsId::SHM_OFFER_BYTES_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedBytes});
+    dpStats.updateStats({static_cast<short>(ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedBytes});
     dpStats.processCommandQueue();
     assert(stats.totalConsumedBytes == dpStats.metrics[(short)ProcessingStatsId::SHM_OFFER_BYTES_CONSUMED]);
+    assert(stats.totalConsumedTimeslices == dpStats.metrics[(short)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED]);
   };
 
   static std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats const&)> reportExpiredOffer = [ref](ComputingQuotaOffer const& offer, ComputingQuotaStats const& stats) {
     auto& dpStats = ref.get<DataProcessingStats>();
     dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCE_OFFER_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredOffers});
     dpStats.updateStats({static_cast<short>(ProcessingStatsId::ARROW_BYTES_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredBytes});
+    dpStats.updateStats({static_cast<short>(ProcessingStatsId::TIMESLICE_NUMBER_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredTimeslices});
     dpStats.processCommandQueue();
   };
 
@@ -1544,6 +1548,7 @@ void DataProcessingDevice::Run()
         auto& dpStats = ref.get<DataProcessingStats>();
         dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCE_OFFER_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredOffers});
         dpStats.updateStats({static_cast<short>(ProcessingStatsId::ARROW_BYTES_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredBytes});
+        dpStats.updateStats({static_cast<short>(ProcessingStatsId::TIMESLICE_NUMBER_EXPIRED), DataProcessingStats::Op::Set, stats.totalExpiredTimeslices});
         dpStats.processCommandQueue();
       };
       auto ref = ServiceRegistryRef{mServiceRegistry};
diff --git a/Framework/Core/src/ResourcePolicy.cxx b/Framework/Core/src/ResourcePolicy.cxx
index 9076a87d547fa..18ff15e372657 100644
--- a/Framework/Core/src/ResourcePolicy.cxx
+++ b/Framework/Core/src/ResourcePolicy.cxx
@@ -18,8 +18,9 @@ namespace o2::framework
 
 std::vector<ResourcePolicy> ResourcePolicy::createDefaultPolicies()
 {
+  // FIXME: we should have better logic to decide if we can process something.
   return {
-    ResourcePolicyHelpers::sharedMemoryBoundTask("internal-dpl-aod-reader.*", 100000000),
+    ResourcePolicyHelpers::rateLimitedSharedMemoryBoundTask("internal-dpl-aod-reader.*", 100000000, 1),
     ResourcePolicyHelpers::trivialTask(".*")};
 }
 
diff --git a/Framework/Core/src/ResourcePolicyHelpers.cxx b/Framework/Core/src/ResourcePolicyHelpers.cxx
index aad783cdc1f60..2c5c4f54dd9b5 100644
--- a/Framework/Core/src/ResourcePolicyHelpers.cxx
+++ b/Framework/Core/src/ResourcePolicyHelpers.cxx
@@ -11,9 +11,7 @@
 
 #include "Framework/ResourcePolicyHelpers.h"
 #include "Framework/DeviceSpec.h"
-#include "ResourcesMonitoringHelper.h"
 
-#include <string>
 #include <regex>
 
 namespace o2::framework
@@ -41,6 +39,36 @@ ResourcePolicy ResourcePolicyHelpers::cpuBoundTask(char const* s, int requestedC
     [requestedCPUs](ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated) -> OfferScore { return accumulated.cpu >= requestedCPUs ? OfferScore::Enough : OfferScore::More; }};
 }
 
+ResourcePolicy ResourcePolicyHelpers::rateLimitedSharedMemoryBoundTask(char const* s, int requestedSharedMemory, int requestedTimeslices)
+{
+  return ResourcePolicy{
+    "ratelimited-shm-bound",
+    [matcher = std::regex(s)](DeviceSpec const& spec) -> bool {
+      return std::regex_match(spec.name, matcher);
+    },
+    [requestedSharedMemory, requestedTimeslices](ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated) -> OfferScore { 
+      // If we have enough memory and not enough timeslices,
+      // ignore further shared memory.
+      if (accumulated.sharedMemory >= requestedSharedMemory && offer.timeslices == 0) {
+        return OfferScore::Unneeded;
+      }
+      // If we have enough timeslices and not enough shared memory
+      // ignore further timeslices.
+      if (accumulated.timeslices >= requestedTimeslices && offer.sharedMemory == 0) {
+        return OfferScore::Unneeded;
+      }
+      // If it does not offer neither shared memory nor timeslices, mark it as unneeded.
+      if (offer.sharedMemory == 0 && offer.timeslices == 0) {
+        return OfferScore::Unneeded;
+      }
+      // We have enough to process.
+      if ((accumulated.sharedMemory + offer.sharedMemory) >= requestedSharedMemory && (accumulated.timeslices + offer.timeslices) >= requestedTimeslices) {
+        return OfferScore::Enough;
+      }
+      // We need more resources
+      return OfferScore::More; }};
+}
+
 ResourcePolicy ResourcePolicyHelpers::sharedMemoryBoundTask(char const* s, int requestedSharedMemory)
 {
   return ResourcePolicy{
@@ -52,7 +80,7 @@ ResourcePolicy ResourcePolicyHelpers::sharedMemoryBoundTask(char const* s, int r
       if (offer.sharedMemory == 0) {
         return OfferScore::Unneeded;
       }
-      return accumulated.sharedMemory >= requestedSharedMemory ? OfferScore::Enough : OfferScore::More; }};
+      return (accumulated.sharedMemory + offer.sharedMemory)>= requestedSharedMemory ? OfferScore::Enough : OfferScore::More; }};
 }
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/WSDriverClient.cxx b/Framework/Core/src/WSDriverClient.cxx
index 179b13bf91d76..43a407536cb59 100644
--- a/Framework/Core/src/WSDriverClient.cxx
+++ b/Framework/Core/src/WSDriverClient.cxx
@@ -26,6 +26,7 @@ O2_DECLARE_DYNAMIC_LOG(completion);
 O2_DECLARE_DYNAMIC_LOG(monitoring_service);
 O2_DECLARE_DYNAMIC_LOG(data_processor_context);
 O2_DECLARE_DYNAMIC_LOG(stream_context);
+O2_DECLARE_DYNAMIC_LOG(ws_client);
 
 namespace o2::framework
 {
@@ -49,8 +50,8 @@ struct ClientWebSocketHandler : public WebSocketHandler {
     mClient.dispatch(std::string_view(frame, s));
   }
 
-  void endFragmentation() override{};
-  void control(char const* frame, size_t s) override{};
+  void endFragmentation() override {};
+  void control(char const* frame, size_t s) override {};
 
   /// Invoked at the beginning of some incoming data. We simply
   /// reset actions which need to happen on a per chunk basis.
@@ -119,6 +120,34 @@ void on_connect(uv_connect_t* connection, int status)
 
     state.pendingOffers.push_back(offer);
   });
+  client->observe("/timeslice-offer", [ref = context->ref](std::string_view cmd) {
+    O2_SIGNPOST_ID_GENERATE(wid, ws_client);
+    O2_SIGNPOST_START(ws_client, wid, "timeslice-offer", "Received timeslice offer.");
+    auto& state = ref.get<DeviceState>();
+    static constexpr int prefixSize = std::string_view{"/timeslice-offer "}.size();
+    if (prefixSize > cmd.size()) {
+      O2_SIGNPOST_END_WITH_ERROR(ws_client, wid, "timeslice-offer", "Malformed timeslice offer");
+      return;
+    }
+    cmd.remove_prefix(prefixSize);
+    int64_t offerSize;
+    auto offerSizeError = std::from_chars(cmd.data(), cmd.data() + cmd.size(), offerSize);
+    if (offerSizeError.ec != std::errc()) {
+      O2_SIGNPOST_END_WITH_ERROR(ws_client, wid, "timeslice-offer", "Unexpected timeslice offer size");
+      return;
+    }
+    ComputingQuotaOffer offer{
+      .cpu = 0,
+      .memory = 0,
+      .sharedMemory = 0,
+      .timeslices = offerSize,
+      .runtime = 10000,
+      .user = -1,
+      .valid = true};
+    state.pendingOffers.push_back(offer);
+    O2_SIGNPOST_END(ws_client, wid, "timeslice-offer", "Received %lli timeslices offer. Total pending offers %zu.",
+                    offerSize, state.pendingOffers.size());
+  });
 
   client->observe("/quit", [ref = context->ref](std::string_view) {
     auto& state = ref.get<DeviceState>();
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 36583035c41ff..d27753848d544 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -465,11 +465,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     if (mctracks2aod == workflow.end()) {
       // add normal reader
       auto&& algo = PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx);
-      if (internalRateLimiting) {
-        aodReader.algorithm = CommonDataProcessors::wrapWithRateLimiting(algo);
-      } else {
-        aodReader.algorithm = algo;
-      }
+      aodReader.algorithm = algo;
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
       aodReader.outputs.emplace_back(OutputSpec{"TFF", "TFFilename"});
     } else {
@@ -699,7 +695,15 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       ignoredInput.lifetime = Lifetime::Sporadic;
     }
 
-    extraSpecs.push_back(CommonDataProcessors::getDummySink(ignored, rateLimitingChannelConfigOutput));
+    // Use the new dummy sink when the AOD reader is there
+    O2_SIGNPOST_ID_GENERATE(sid, workflow_helpers);
+    if (aodReader.outputs.empty() == false) {
+      O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting scheduled dummy sink");
+      extraSpecs.push_back(CommonDataProcessors::getScheduledDummySink(ignored));
+    } else {
+      O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting rate limited dummy sink");
+      extraSpecs.push_back(CommonDataProcessors::getDummySink(ignored, rateLimitingChannelConfigOutput));
+    }
   }
 
   workflow.insert(workflow.end(), extraSpecs.begin(), extraSpecs.end());
diff --git a/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx b/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
index b8c9cc50f0770..aa546b8a9ab49 100644
--- a/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
@@ -329,6 +329,10 @@ void displayDeviceInspector(DeviceSpec const& spec,
       control.controller->write("/shm-offer 1000", strlen("/shm-offer 1000"));
     }
 
+    if (ImGui::Button("Offer timeslices")) {
+      control.controller->write("/timeslice-offer 1", strlen("/timeslice-offer 1"));
+    }
+
     if (control.requestedState > info.providedState) {
       ImGui::Text(ICON_FA_CLOCK_O);
     } else {

From c1a675807ae953ab9e79fd9f3b3938a4c3ff3ab3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 5 Nov 2025 14:51:26 +0100
Subject: [PATCH 1002/1764] DPL: move TableToTree to AnalysisSupport, on its
 way to be deprecated

---
 Detectors/AOD/CMakeLists.txt                               | 2 ++
 Framework/AnalysisSupport/CMakeLists.txt                   | 7 +++++++
 .../include/Framework/TableTreeHelpers.h                   | 2 +-
 .../{Core => AnalysisSupport}/src/TableTreeHelpers.cxx     | 0
 .../test/benchmark_TableToTree.cxx                         | 0
 Framework/Core/CMakeLists.txt                              | 2 --
 6 files changed, 10 insertions(+), 3 deletions(-)
 rename Framework/{Core => AnalysisSupport}/include/Framework/TableTreeHelpers.h (98%)
 rename Framework/{Core => AnalysisSupport}/src/TableTreeHelpers.cxx (100%)
 rename Framework/{Core => AnalysisSupport}/test/benchmark_TableToTree.cxx (100%)

diff --git a/Detectors/AOD/CMakeLists.txt b/Detectors/AOD/CMakeLists.txt
index 7ab36d260e480..827b23b3e4cdd 100644
--- a/Detectors/AOD/CMakeLists.txt
+++ b/Detectors/AOD/CMakeLists.txt
@@ -19,6 +19,7 @@ target_link_libraries(
           O2::FDDWorkflow
           O2::FV0Workflow
           O2::Framework
+          O2::FrameworkAnalysisSupport
           O2::GlobalTracking
           O2::GlobalTrackingWorkflow
           O2::ITSMFTWorkflow
@@ -75,6 +76,7 @@ o2_add_executable(
         O2::DataFormatsFT0
         O2::Steer
         O2::ZDCBase
+        O2::FrameworkAnalysisSupport
         nlohmann_json::nlohmann_json
         )
 
diff --git a/Framework/AnalysisSupport/CMakeLists.txt b/Framework/AnalysisSupport/CMakeLists.txt
index dedbf8cb590b2..92fd55b86a33d 100644
--- a/Framework/AnalysisSupport/CMakeLists.txt
+++ b/Framework/AnalysisSupport/CMakeLists.txt
@@ -19,6 +19,7 @@ endif()
 o2_add_library(FrameworkAnalysisSupport
                SOURCES src/Plugin.cxx
                        src/DataInputDirector.cxx
+                       src/TableTreeHelpers.cxx
                        src/AODJAlienReaderHelpers.cxx
                        src/AODWriterHelpers.cxx
                PRIVATE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_LIST_DIR}/src
@@ -39,3 +40,9 @@ o2_add_test(DataInputDirector NAME test_Framework_test_DataInputDirector
                COMPONENT_NAME Framework
                LABELS framework
                PUBLIC_LINK_LIBRARIES O2::FrameworkAnalysisSupport)
+
+o2_add_test(TableToTree NAME benchmark_TableToTree
+               SOURCES test/benchmark_TableToTree.cxx
+               COMPONENT_NAME Framework
+               LABELS framework
+               PUBLIC_LINK_LIBRARIES O2::FrameworkAnalysisSupport benchmark::benchmark)
diff --git a/Framework/Core/include/Framework/TableTreeHelpers.h b/Framework/AnalysisSupport/include/Framework/TableTreeHelpers.h
similarity index 98%
rename from Framework/Core/include/Framework/TableTreeHelpers.h
rename to Framework/AnalysisSupport/include/Framework/TableTreeHelpers.h
index 0a163d59aecb0..c5e9d5fa14261 100644
--- a/Framework/Core/include/Framework/TableTreeHelpers.h
+++ b/Framework/AnalysisSupport/include/Framework/TableTreeHelpers.h
@@ -18,7 +18,7 @@
 #include "TTreeReader.h"
 #include "TTreeReaderValue.h"
 #include "TTreeReaderArray.h"
-#include "TableBuilder.h"
+#include "Framework/TableBuilder.h"
 #include <arrow/dataset/file_base.h>
 #include <memory>
 
diff --git a/Framework/Core/src/TableTreeHelpers.cxx b/Framework/AnalysisSupport/src/TableTreeHelpers.cxx
similarity index 100%
rename from Framework/Core/src/TableTreeHelpers.cxx
rename to Framework/AnalysisSupport/src/TableTreeHelpers.cxx
diff --git a/Framework/Core/test/benchmark_TableToTree.cxx b/Framework/AnalysisSupport/test/benchmark_TableToTree.cxx
similarity index 100%
rename from Framework/Core/test/benchmark_TableToTree.cxx
rename to Framework/AnalysisSupport/test/benchmark_TableToTree.cxx
diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 43571526855cc..48183bc1e9526 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -132,7 +132,6 @@ o2_add_library(Framework
                        src/TMessageSerializer.cxx
                        src/TableBuilder.cxx
                        src/TableConsumer.cxx
-                       src/TableTreeHelpers.cxx
                        src/TopologyPolicy.cxx
                        src/TopologyPolicyHelpers.cxx
                        src/TextDriverClient.cxx
@@ -349,7 +348,6 @@ foreach(b
         ASoAHelpers
         EventMixing
         HistogramRegistry
-        TableToTree
         ExternalFairMQDeviceProxies
         )
   o2_add_executable(benchmark-${b}

From 57a66d189dc99bd194153814780f7e4d747a9a3a Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Tue, 4 Nov 2025 11:44:28 +0100
Subject: [PATCH 1003/1764] Revert "Fix one-off index problem when copying
 collision contexts"

This reverts commit db55f0819ad84a35d9e59bb688e2ab5196e54fb1.

Apparently it causes another problem for the last timeframe in
an anchoredMC simulation. Reverting for now and taking another look.
---
 DataFormats/simulation/src/DigitizationContext.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index a157fbc377fde..9e8a125c06fa4 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -708,7 +708,7 @@ DigitizationContext DigitizationContext::extractSingleTimeframe(int timeframeid,
     auto tf_ranges = timeframeindices.at(timeframeid);
 
     auto startindex = std::get<0>(tf_ranges);
-    auto endindex = std::get<1>(tf_ranges) + 1; // +1 due to endindex being "including"
+    auto endindex = std::get<1>(tf_ranges);
     auto earlyindex = std::get<2>(tf_ranges);
 
     if (earlyindex >= 0) {

From 17b6c77bd9fb3dbff74c1cdb61ccd34352048c66 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Tue, 4 Nov 2025 18:09:59 +0100
Subject: [PATCH 1004/1764] Fix of O2-6437

Second attempt and addition to db55f0819ad8
---
 DataFormats/simulation/src/DigitizationContext.cxx |  9 ++-------
 Steer/src/CollisionContextTool.cxx                 | 11 +++++++++++
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index 9e8a125c06fa4..b05889300340c 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -577,7 +577,7 @@ void DigitizationContext::applyMaxCollisionFilter(std::vector<std::tuple<int, in
     if (indices_old_to_new.find(lastindex) != indices_old_to_new.end()) {
       std::get<1>(tf_indices) = indices_old_to_new[lastindex]; // end;
     } else {
-      std::get<1>(tf_indices) = newrecords.size(); // end;
+      std::get<1>(tf_indices) = newrecords.size() - 1; // end; -1 since index inclusif
     }
     if (indices_old_to_new.find(previndex) != indices_old_to_new.end()) {
       std::get<2>(tf_indices) = indices_old_to_new[previndex]; // previous or "early" index
@@ -591,11 +591,6 @@ void DigitizationContext::applyMaxCollisionFilter(std::vector<std::tuple<int, in
 std::vector<std::tuple<int, int, int>> DigitizationContext::calcTimeframeIndices(long startOrbit, long orbitsPerTF, double orbitsEarly) const
 {
   auto timeframeindices = getTimeFrameBoundaries(mEventRecords, startOrbit, orbitsPerTF, orbitsEarly);
-  LOG(info) << "Fixed " << timeframeindices.size() << " timeframes ";
-  for (auto p : timeframeindices) {
-    LOG(info) << std::get<0>(p) << " " << std::get<1>(p) << " " << std::get<2>(p);
-  }
-
   return timeframeindices;
 }
 
@@ -708,7 +703,7 @@ DigitizationContext DigitizationContext::extractSingleTimeframe(int timeframeid,
     auto tf_ranges = timeframeindices.at(timeframeid);
 
     auto startindex = std::get<0>(tf_ranges);
-    auto endindex = std::get<1>(tf_ranges);
+    auto endindex = std::get<1>(tf_ranges) + 1;
     auto earlyindex = std::get<2>(tf_ranges);
 
     if (earlyindex >= 0) {
diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index 1733caaa92eed..710476bed32f9 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -565,9 +565,20 @@ int main(int argc, char* argv[])
   LOG(info) << "-------- DENSE CONTEXT ------->>";
 
   auto timeframeindices = digicontext.calcTimeframeIndices(orbitstart, options.orbitsPerTF, options.orbitsEarly);
+  LOG(info) << "Fixed " << timeframeindices.size() << " timeframes ";
+  for (auto p : timeframeindices) {
+    LOG(info) << std::get<0>(p) << " " << std::get<1>(p) << " " << std::get<2>(p);
+  }
+
   // apply max collision per timeframe filters + reindexing of event id (linearisation and compactification)
   digicontext.applyMaxCollisionFilter(timeframeindices, orbitstart, options.orbitsPerTF, options.maxCollsPerTF, options.orbitsEarly);
 
+  LOG(info) << "Timeframe indices after collision filter";
+  LOG(info) << "Fixed " << timeframeindices.size() << " timeframes ";
+  for (auto p : timeframeindices) {
+    LOG(info) << std::get<0>(p) << " " << std::get<1>(p) << " " << std::get<2>(p);
+  }
+
   // <---- at this moment we have a dense collision context (not representing the final output we want)
   LOG(info) << "<<------ FILTERED CONTEXT ---------";
   if (options.printContext) {

From a52acfc903aa8d55bd90820d07c8cdbd0b646a73 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 6 Nov 2025 08:54:33 +0100
Subject: [PATCH 1005/1764] DPL: move updateStateTransition() and smaller
 helper functions to DataProcessingHelpers

---
 .../include/Framework/DataProcessingHelpers.h |  10 ++
 Framework/Core/src/DataProcessingDevice.cxx   | 123 +----------------
 Framework/Core/src/DataProcessingHelpers.cxx  | 128 ++++++++++++++++++
 3 files changed, 145 insertions(+), 116 deletions(-)

diff --git a/Framework/Core/include/Framework/DataProcessingHelpers.h b/Framework/Core/include/Framework/DataProcessingHelpers.h
index 7a05ddf25c46c..d8d8b7caf9d0a 100644
--- a/Framework/Core/include/Framework/DataProcessingHelpers.h
+++ b/Framework/Core/include/Framework/DataProcessingHelpers.h
@@ -21,6 +21,10 @@ struct ForwardChannelState;
 struct OutputChannelInfo;
 struct OutputChannelSpec;
 struct OutputChannelState;
+struct ProcessingPolicies;
+struct DeviceSpec;
+enum struct StreamingState;
+enum struct TransitionHandlingState;
 
 /// Generic helpers for DataProcessing releated functions.
 struct DataProcessingHelpers {
@@ -35,6 +39,12 @@ struct DataProcessingHelpers {
   static bool sendOldestPossibleTimeframe(ServiceRegistryRef const& ref, OutputChannelInfo const& info, OutputChannelState& state, size_t timeslice);
   /// Broadcast the oldest possible timeslice to all channels in output
   static void broadcastOldestPossibleTimeslice(ServiceRegistryRef const& ref, size_t timeslice);
+  /// change the device StreamingState to newState
+  static void switchState(ServiceRegistryRef const& ref, StreamingState newState);
+  /// check if spec is a source devide
+  static bool hasOnlyGenerated(DeviceSpec const& spec);
+  /// starts the EoS timers and returns the new TransitionHandlingState in case as new state is requested
+  static TransitionHandlingState updateStateTransition(ServiceRegistryRef const& ref, ProcessingPolicies const& policies);
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 5868557f2c80f..ff90b93b4d114 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -125,63 +125,6 @@ void on_idle_timer(uv_timer_t* handle)
   state->loopReason |= DeviceState::TIMER_EXPIRED;
 }
 
-bool hasOnlyTimers(DeviceSpec const& spec)
-{
-  return std::all_of(spec.inputs.cbegin(), spec.inputs.cend(), [](InputRoute const& route) -> bool { return route.matcher.lifetime == Lifetime::Timer; });
-}
-
-bool hasOnlyGenerated(DeviceSpec const& spec)
-{
-  return (spec.inputChannels.size() == 1) && (spec.inputs[0].matcher.lifetime == Lifetime::Timer || spec.inputs[0].matcher.lifetime == Lifetime::Enumeration);
-}
-
-void on_transition_requested_expired(uv_timer_t* handle)
-{
-  auto* ref = (ServiceRegistryRef*)handle->data;
-  auto& state = ref->get<DeviceState>();
-  state.loopReason |= DeviceState::TIMER_EXPIRED;
-  // Check if this is a source device
-  O2_SIGNPOST_ID_FROM_POINTER(cid, device, handle);
-  auto& spec = ref->get<DeviceSpec const>();
-  std::string messageOnExpire = hasOnlyGenerated(spec) ? "DPL exit transition grace period for source expired. Exiting." : fmt::format("DPL exit transition grace period for {} expired. Exiting.", state.allowedProcessing == DeviceState::CalibrationOnly ? "calibration" : "data & calibration").c_str();
-  if (!ref->get<RawDeviceService>().device()->GetConfig()->GetValue<bool>("error-on-exit-transition-timeout")) {
-    O2_SIGNPOST_EVENT_EMIT_WARN(calibration, cid, "callback", "%{public}s", messageOnExpire.c_str());
-  } else {
-    O2_SIGNPOST_EVENT_EMIT_ERROR(calibration, cid, "callback", "%{public}s", messageOnExpire.c_str());
-  }
-  state.transitionHandling = TransitionHandlingState::Expired;
-}
-
-auto switchState(ServiceRegistryRef& ref, StreamingState newState) -> void
-{
-  auto& state = ref.get<DeviceState>();
-  auto& context = ref.get<DataProcessorContext>();
-  O2_SIGNPOST_ID_FROM_POINTER(dpid, device, &context);
-  O2_SIGNPOST_END(device, dpid, "state", "End of processing state %d", (int)state.streaming);
-  O2_SIGNPOST_START(device, dpid, "state", "Starting processing state %d", (int)newState);
-  state.streaming = newState;
-  ref.get<ControlService>().notifyStreamingState(state.streaming);
-};
-
-void on_data_processing_expired(uv_timer_t* handle)
-{
-  auto* ref = (ServiceRegistryRef*)handle->data;
-  auto& state = ref->get<DeviceState>();
-  auto& spec = ref->get<DeviceSpec const>();
-  state.loopReason |= DeviceState::TIMER_EXPIRED;
-
-  // Check if this is a source device
-  O2_SIGNPOST_ID_FROM_POINTER(cid, device, handle);
-
-  if (hasOnlyGenerated(spec)) {
-    O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for data processing expired. Switching to EndOfStreaming.");
-    switchState(*ref, StreamingState::EndOfStreaming);
-  } else {
-    O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for data processing expired. Only calibrations from this point onwards.");
-    state.allowedProcessing = DeviceState::CalibrationOnly;
-  }
-}
-
 void on_communication_requested(uv_async_t* s)
 {
   auto* state = (DeviceState*)s->data;
@@ -1267,7 +1210,7 @@ void DataProcessingDevice::PreRun()
   O2_SIGNPOST_ID_FROM_POINTER(cid, device, state.loop);
   O2_SIGNPOST_START(device, cid, "PreRun", "Entering PreRun callback.");
   state.quitRequested = false;
-  switchState(ref, StreamingState::Streaming);
+  DataProcessingHelpers::switchState(ref, StreamingState::Streaming);
   state.allowedProcessing = DeviceState::Any;
   for (auto& info : state.inputChannelInfos) {
     if (info.state != InputChannelState::Pull) {
@@ -1338,58 +1281,6 @@ void DataProcessingDevice::Reset()
   ref.get<CallbackService>().call<CallbackService::Id::Reset>();
 }
 
-TransitionHandlingState updateStateTransition(ServiceRegistryRef& ref, ProcessingPolicies const& policies)
-{
-  auto& state = ref.get<DeviceState>();
-  auto& deviceProxy = ref.get<FairMQDeviceProxy>();
-  if (state.transitionHandling != TransitionHandlingState::NoTransition || deviceProxy.newStateRequested() == false) {
-    return state.transitionHandling;
-  }
-  O2_SIGNPOST_ID_FROM_POINTER(lid, device, state.loop);
-  auto& deviceContext = ref.get<DeviceContext>();
-  // Check if we only have timers
-  auto& spec = ref.get<DeviceSpec const>();
-  if (hasOnlyTimers(spec)) {
-    switchState(ref, StreamingState::EndOfStreaming);
-  }
-
-  // We do not do anything in particular if the data processing timeout would go past the exitTransitionTimeout
-  if (deviceContext.dataProcessingTimeout > 0 && deviceContext.dataProcessingTimeout < deviceContext.exitTransitionTimeout) {
-    uv_update_time(state.loop);
-    O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for dataProcessingTimeout.", deviceContext.dataProcessingTimeout);
-    uv_timer_start(deviceContext.dataProcessingGracePeriodTimer, on_data_processing_expired, deviceContext.dataProcessingTimeout * 1000, 0);
-  }
-  if (deviceContext.exitTransitionTimeout != 0 && state.streaming != StreamingState::Idle) {
-    ref.get<CallbackService>().call<CallbackService::Id::ExitRequested>(ServiceRegistryRef{ref});
-    uv_update_time(state.loop);
-    O2_SIGNPOST_EVENT_EMIT(calibration, lid, "timer_setup", "Starting %d s timer for exitTransitionTimeout.",
-                           deviceContext.exitTransitionTimeout);
-    uv_timer_start(deviceContext.gracePeriodTimer, on_transition_requested_expired, deviceContext.exitTransitionTimeout * 1000, 0);
-    bool onlyGenerated = hasOnlyGenerated(spec);
-    int timeout = onlyGenerated ? deviceContext.dataProcessingTimeout : deviceContext.exitTransitionTimeout;
-    if (policies.termination == TerminationPolicy::QUIT && DefaultsHelpers::onlineDeploymentMode() == false) {
-      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. Waiting for %d seconds before quitting.", timeout);
-    } else {
-      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop",
-                                  "New state requested. Waiting for %d seconds before %{public}s",
-                                  timeout,
-                                  onlyGenerated ? "dropping remaining input and switching to READY state." : "switching to READY state.");
-    }
-    return TransitionHandlingState::Requested;
-  } else {
-    if (deviceContext.exitTransitionTimeout == 0 && policies.termination == TerminationPolicy::QUIT) {
-      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. No timeout set, quitting immediately as per --completion-policy");
-    } else if (deviceContext.exitTransitionTimeout == 0 && policies.termination != TerminationPolicy::QUIT) {
-      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. No timeout set, switching to READY state immediately");
-    } else if (policies.termination == TerminationPolicy::QUIT) {
-      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state pending and we are already idle, quitting immediately as per --completion-policy");
-    } else {
-      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state pending and we are already idle, switching to READY immediately.");
-    }
-    return TransitionHandlingState::Expired;
-  }
-}
-
 void DataProcessingDevice::Run()
 {
   ServiceRegistryRef ref{mServiceRegistry};
@@ -1442,7 +1333,7 @@ void DataProcessingDevice::Run()
         shouldNotWait = true;
         state.loopReason |= DeviceState::LoopReason::NEW_STATE_PENDING;
       }
-      state.transitionHandling = updateStateTransition(ref, ref.get<DeviceContext>().processingPolicies);
+      state.transitionHandling = DataProcessingHelpers::updateStateTransition(ref, ref.get<DeviceContext>().processingPolicies);
       // If we are Idle, we can then consider the transition to be expired.
       if (state.transitionHandling == TransitionHandlingState::Requested && state.streaming == StreamingState::Idle) {
         O2_SIGNPOST_EVENT_EMIT(device, lid, "run_loop", "State transition requested and we are now in Idle. We can consider it to be completed.");
@@ -1828,7 +1719,7 @@ void DataProcessingDevice::doRun(ServiceRegistryRef ref)
   // dependent on the callback, not something which is controlled by the
   // framework itself.
   if (context.allDone == true && state.streaming == StreamingState::Streaming) {
-    switchState(ref, StreamingState::EndOfStreaming);
+    DataProcessingHelpers::switchState(ref, StreamingState::EndOfStreaming);
     state.lastActiveDataProcessor = &context;
   }
 
@@ -1841,7 +1732,7 @@ void DataProcessingDevice::doRun(ServiceRegistryRef ref)
     /// timers as they do not need to be further processed.
     auto& relayer = ref.get<DataRelayer>();
 
-    bool shouldProcess = hasOnlyGenerated(spec) == false;
+    bool shouldProcess = DataProcessingHelpers::hasOnlyGenerated(spec) == false;
 
     while (DataProcessingDevice::tryDispatchComputation(ref, context.completed) && shouldProcess) {
       relayer.processDanglingInputs(context.expirationHandlers, *context.registry, false);
@@ -1874,7 +1765,7 @@ void DataProcessingDevice::doRun(ServiceRegistryRef ref)
     }
     // This is needed because the transport is deleted before the device.
     relayer.clear();
-    switchState(ref, StreamingState::Idle);
+    DataProcessingHelpers::switchState(ref, StreamingState::Idle);
     // In case  we should process, note the data processor responsible for it
     if (shouldProcess) {
       state.lastActiveDataProcessor = &context;
@@ -2567,7 +2458,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
           O2_SIGNPOST_EVENT_EMIT(device, pcid, "device", "Skipping processing because we are discarding.");
         } else {
           O2_SIGNPOST_EVENT_EMIT(device, pcid, "device", "No processing callback provided. Switching to %{public}s.", "Idle");
-          switchState(ref, StreamingState::Idle);
+          DataProcessingHelpers::switchState(ref, StreamingState::Idle);
         }
         if (shouldProcess(action)) {
           auto& timingInfo = ref.get<TimingInfo>();
@@ -2655,7 +2546,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     for (auto& channel : spec.outputChannels) {
       DataProcessingHelpers::sendEndOfStream(ref, channel);
     }
-    switchState(ref, StreamingState::Idle);
+    DataProcessingHelpers::switchState(ref, StreamingState::Idle);
   }
 
   return true;
diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index 58fda5a13bae9..e144f426372b1 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -20,10 +20,28 @@
 #include "Framework/Logger.h"
 #include "Framework/SendingPolicy.h"
 #include "Framework/RawDeviceService.h"
+#include "Framework/DeviceState.h"
+#include "Framework/DeviceContext.h"
+#include "Framework/ProcessingPolicies.h"
+#include "Framework/Signpost.h"
+#include "Framework/CallbackService.h"
+#include "Framework/DefaultsHelpers.h"
+#include "Framework/ServiceRegistryRef.h"
+#include "Framework/DeviceSpec.h"
+#include "Framework/ControlService.h"
+#include "Framework/DataProcessingContext.h"
+#include "Framework/DeviceStateEnums.h"
 
 #include <fairmq/Device.h>
 #include <fairmq/Channel.h>
 
+#include <uv.h>
+
+// A log to use for general device logging
+O2_DECLARE_DYNAMIC_LOG(device);
+// Stream which keeps track of the calibration lifetime logic
+O2_DECLARE_DYNAMIC_LOG(calibration);
+
 namespace o2::framework
 {
 void DataProcessingHelpers::sendEndOfStream(ServiceRegistryRef const& ref, OutputChannelSpec const& channel)
@@ -89,4 +107,114 @@ void DataProcessingHelpers::broadcastOldestPossibleTimeslice(ServiceRegistryRef
   }
 }
 
+void DataProcessingHelpers::switchState(ServiceRegistryRef const& ref, StreamingState newState)
+{
+  auto& state = ref.get<DeviceState>();
+  auto& context = ref.get<DataProcessorContext>();
+  O2_SIGNPOST_ID_FROM_POINTER(dpid, device, &context);
+  O2_SIGNPOST_END(device, dpid, "state", "End of processing state %d", (int)state.streaming);
+  O2_SIGNPOST_START(device, dpid, "state", "Starting processing state %d", (int)newState);
+  state.streaming = newState;
+  ref.get<ControlService>().notifyStreamingState(state.streaming);
+};
+
+bool hasOnlyTimers(DeviceSpec const& spec)
+{
+  return std::all_of(spec.inputs.cbegin(), spec.inputs.cend(), [](InputRoute const& route) -> bool { return route.matcher.lifetime == Lifetime::Timer; });
+}
+
+bool DataProcessingHelpers::hasOnlyGenerated(DeviceSpec const& spec)
+{
+  return (spec.inputChannels.size() == 1) && (spec.inputs[0].matcher.lifetime == Lifetime::Timer || spec.inputs[0].matcher.lifetime == Lifetime::Enumeration);
+}
+
+void on_data_processing_expired(uv_timer_t* handle)
+{
+  auto* ref = (ServiceRegistryRef*)handle->data;
+  auto& state = ref->get<DeviceState>();
+  auto& spec = ref->get<DeviceSpec const>();
+  state.loopReason |= DeviceState::TIMER_EXPIRED;
+
+  // Check if this is a source device
+  O2_SIGNPOST_ID_FROM_POINTER(cid, calibration, handle);
+
+  if (DataProcessingHelpers::hasOnlyGenerated(spec)) {
+    O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for data processing expired. Switching to EndOfStreaming.");
+    DataProcessingHelpers::switchState(*ref, StreamingState::EndOfStreaming);
+  } else {
+    O2_SIGNPOST_EVENT_EMIT_INFO(calibration, cid, "callback", "Grace period for data processing expired. Only calibrations from this point onwards.");
+    state.allowedProcessing = DeviceState::CalibrationOnly;
+  }
+}
+
+void on_transition_requested_expired(uv_timer_t* handle)
+{
+  auto* ref = (ServiceRegistryRef*)handle->data;
+  auto& state = ref->get<DeviceState>();
+  state.loopReason |= DeviceState::TIMER_EXPIRED;
+  // Check if this is a source device
+  O2_SIGNPOST_ID_FROM_POINTER(cid, calibration, handle);
+  auto& spec = ref->get<DeviceSpec const>();
+  std::string messageOnExpire = DataProcessingHelpers::hasOnlyGenerated(spec) ? "DPL exit transition grace period for source expired. Exiting." : fmt::format("DPL exit transition grace period for {} expired. Exiting.", state.allowedProcessing == DeviceState::CalibrationOnly ? "calibration" : "data & calibration").c_str();
+  if (!ref->get<RawDeviceService>().device()->GetConfig()->GetValue<bool>("error-on-exit-transition-timeout")) {
+    O2_SIGNPOST_EVENT_EMIT_WARN(calibration, cid, "callback", "%{public}s", messageOnExpire.c_str());
+  } else {
+    O2_SIGNPOST_EVENT_EMIT_ERROR(calibration, cid, "callback", "%{public}s", messageOnExpire.c_str());
+  }
+  state.transitionHandling = TransitionHandlingState::Expired;
+}
+
+TransitionHandlingState DataProcessingHelpers::updateStateTransition(ServiceRegistryRef const& ref, ProcessingPolicies const& policies)
+{
+  auto& state = ref.get<DeviceState>();
+  auto& deviceProxy = ref.get<FairMQDeviceProxy>();
+  if (state.transitionHandling != TransitionHandlingState::NoTransition || deviceProxy.newStateRequested() == false) {
+    return state.transitionHandling;
+  }
+  O2_SIGNPOST_ID_FROM_POINTER(lid, device, state.loop);
+  O2_SIGNPOST_ID_FROM_POINTER(cid, calibration, state.loop);
+  auto& deviceContext = ref.get<DeviceContext>();
+  // Check if we only have timers
+  auto& spec = ref.get<DeviceSpec const>();
+  if (hasOnlyTimers(spec)) {
+    DataProcessingHelpers::switchState(ref, StreamingState::EndOfStreaming);
+  }
+
+  // We do not do anything in particular if the data processing timeout would go past the exitTransitionTimeout
+  if (deviceContext.dataProcessingTimeout > 0 && deviceContext.dataProcessingTimeout < deviceContext.exitTransitionTimeout) {
+    uv_update_time(state.loop);
+    O2_SIGNPOST_EVENT_EMIT(calibration, cid, "timer_setup", "Starting %d s timer for dataProcessingTimeout.", deviceContext.dataProcessingTimeout);
+    uv_timer_start(deviceContext.dataProcessingGracePeriodTimer, on_data_processing_expired, deviceContext.dataProcessingTimeout * 1000, 0);
+  }
+  if (deviceContext.exitTransitionTimeout != 0 && state.streaming != StreamingState::Idle) {
+    ref.get<CallbackService>().call<CallbackService::Id::ExitRequested>(ServiceRegistryRef{ref});
+    uv_update_time(state.loop);
+    O2_SIGNPOST_EVENT_EMIT(calibration, cid, "timer_setup", "Starting %d s timer for exitTransitionTimeout.",
+                           deviceContext.exitTransitionTimeout);
+    uv_timer_start(deviceContext.gracePeriodTimer, on_transition_requested_expired, deviceContext.exitTransitionTimeout * 1000, 0);
+    bool onlyGenerated = DataProcessingHelpers::hasOnlyGenerated(spec);
+    int timeout = onlyGenerated ? deviceContext.dataProcessingTimeout : deviceContext.exitTransitionTimeout;
+    if (policies.termination == TerminationPolicy::QUIT && DefaultsHelpers::onlineDeploymentMode() == false) {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. Waiting for %d seconds before quitting.", timeout);
+    } else {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop",
+                                  "New state requested. Waiting for %d seconds before %{public}s",
+                                  timeout,
+                                  onlyGenerated ? "dropping remaining input and switching to READY state." : "switching to READY state.");
+    }
+    return TransitionHandlingState::Requested;
+  } else {
+    if (deviceContext.exitTransitionTimeout == 0 && policies.termination == TerminationPolicy::QUIT) {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. No timeout set, quitting immediately as per --completion-policy");
+    } else if (deviceContext.exitTransitionTimeout == 0 && policies.termination != TerminationPolicy::QUIT) {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state requested. No timeout set, switching to READY state immediately");
+    } else if (policies.termination == TerminationPolicy::QUIT) {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state pending and we are already idle, quitting immediately as per --completion-policy");
+    } else {
+      O2_SIGNPOST_EVENT_EMIT_INFO(device, lid, "run_loop", "New state pending and we are already idle, switching to READY immediately.");
+    }
+    return TransitionHandlingState::Expired;
+  }
+}
+
 } // namespace o2::framework

From d71cef8c7e3834c816913b99df64ca46200bb243 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 6 Nov 2025 08:56:26 +0100
Subject: [PATCH 1006/1764] DPL: check for state transition updates also in
 input-proxy busy loop

---
 Framework/Core/src/ExternalFairMQDeviceProxy.cxx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index c07baeaaf40b8..99176de0d9db6 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -32,6 +32,7 @@
 #include "Framework/DeviceState.h"
 #include "Framework/Monitoring.h"
 #include "Framework/SendingPolicy.h"
+#include "Framework/DataProcessingHelpers.h"
 #include "Headers/DataHeader.h"
 #include "Headers/Stack.h"
 #include "DecongestionService.h"
@@ -864,6 +865,10 @@ DataProcessorSpec specifyExternalFairMQDeviceProxy(char const* name,
 
       bool didSendParts = false;
       for (size_t ci = 0; ci < channels.size(); ++ci) {
+        // check for state transition request every 10th input channel to avoid large delays of EoS timers
+        if (ci > 0 && ci % 10 == 0) {
+          ctx.services().get<DeviceState>().transitionHandling = DataProcessingHelpers::updateStateTransition(ctx.services(), ctx.services().get<DeviceContext>().processingPolicies);
+        }
         std::string const& channel = channels[ci];
         int waitTime = channels.size() == 1 ? -1 : 1;
         int maxRead = 1000;

From 0bec003feee53f08447e50546a7ed4f39d8b337b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 5 Nov 2025 15:52:00 +0100
Subject: [PATCH 1007/1764] GPU QA: Fix colors when writing histograms to ROOT
 files

---
 GPU/GPUTracking/qa/GPUQA.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index cbeeb1076647f..b9d83a734df7d 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -2027,11 +2027,11 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
   }
 
   std::vector<Color_t> colorNums(COLORCOUNT);
-  if (!qcout) {
+  if (!(qcout || mConfig.writeRootFiles)) {
     [[maybe_unused]] static int32_t initColorsInitialized = initColors();
   }
   for (int32_t i = 0; i < COLORCOUNT; i++) {
-    colorNums[i] = qcout ? defaultColorNums[i] : mColors[i]->GetNumber();
+    colorNums[i] = (qcout || mConfig.writeRootFiles) ? defaultColorNums[i] : mColors[i]->GetNumber();
   }
 
   bool mcAvail = mcPresent();
@@ -2288,7 +2288,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
               continue;
             }
             e->SetMarkerColor(kBlack);
-            e->SetLineColor(colorNums[(l == 2 ? (ConfigNumInputs * 2 + k) : (k * 2 + l)) % COLORCOUNT]);
+            e->SetLineColor(colorNums[(k * 3 + l) % COLORCOUNT]);
             e->GetHistogram()->GetYaxis()->SetRangeUser(-0.02, 1.02);
             e->Draw(k || l ? "same P" : "AP");
             if (j == 0) {

From 512d5bc9cfa548aa3a78f232ea4aaa84a2581314 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 2 Nov 2025 15:39:23 +0100
Subject: [PATCH 1008/1764] GPU: Remove dead code

---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 0adfae0aa1fbd..7baa3b7e11b4f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -14,11 +14,6 @@
 
 #define GPUCA_CADEBUG 0
 #define DEBUG_SINGLE_TRACK -1
-#define EXTRACT_RESIDUALS 0
-
-#if EXTRACT_RESIDUALS == 1
-#include "GPUROOTDump.h"
-#endif
 
 #include "GPUTPCDef.h"
 #include "GPUTPCGMTrackParam.h"

From bc877601fa240866da9daa2643e01de674e0bb2f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 7 Nov 2025 16:18:32 +0100
Subject: [PATCH 1009/1764] DPL: refactor dumping of performanceMetrics.json

* Add test.
* Allow specifying the file on the command line
* Make the function take a std::stream rather than opening the file
  itself.
---
 Framework/Core/CMakeLists.txt                 |   1 +
 Framework/Core/include/Framework/DriverInfo.h |   2 +
 .../Core/src/ResourcesMonitoringHelper.cxx    |  20 +-
 .../Core/src/ResourcesMonitoringHelper.h      |   8 +-
 Framework/Core/src/runDataProcessing.cxx      |   9 +-
 .../test/test_ResourcesMonitoringHelpers.cxx  | 270 ++++++++++++++++++
 6 files changed, 290 insertions(+), 20 deletions(-)
 create mode 100644 Framework/Core/test/test_ResourcesMonitoringHelpers.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 48183bc1e9526..11eb4bdc08a66 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -240,6 +240,7 @@ add_executable(o2-test-framework-core
               test/test_OverrideLabels.cxx
               test/test_O2DataModelHelpers.cxx
               test/test_RootConfigParamHelpers.cxx
+              test/test_ResourcesMonitoringHelpers.cxx
               test/test_Services.cxx
               test/test_StringHelpers.cxx
               test/test_StaticFor.cxx
diff --git a/Framework/Core/include/Framework/DriverInfo.h b/Framework/Core/include/Framework/DriverInfo.h
index 41b868150e047..146602575b708 100644
--- a/Framework/Core/include/Framework/DriverInfo.h
+++ b/Framework/Core/include/Framework/DriverInfo.h
@@ -149,6 +149,8 @@ struct DriverInfo {
   std::string uniqueWorkflowId = "";
   /// Metrics gathering interval
   unsigned short resourcesMonitoringInterval = 0;
+  /// Where to dump the metrics
+  std::string resourcesMonitoringFilename = "performanceMetrics.json";
   /// Metrics gathering dump to disk interval
   unsigned short resourcesMonitoringDumpInterval = 0;
   /// Port used by the websocket control. 0 means not initialised.
diff --git a/Framework/Core/src/ResourcesMonitoringHelper.cxx b/Framework/Core/src/ResourcesMonitoringHelper.cxx
index 1f69da80888c9..1d53d0f1f2a3c 100644
--- a/Framework/Core/src/ResourcesMonitoringHelper.cxx
+++ b/Framework/Core/src/ResourcesMonitoringHelper.cxx
@@ -55,7 +55,8 @@ boost::property_tree::ptree fillNodeWithValue(const DeviceMetricsInfo& deviceMet
 bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetricsInfo>& metrics,
                                                   const DeviceMetricsInfo& driverMetrics,
                                                   const std::vector<DeviceSpec>& specs,
-                                                  std::vector<std::regex> const& performanceMetricsRegex) noexcept
+                                                  std::vector<std::regex> const& performanceMetricsRegex,
+                                                  std::ostream& out) noexcept
 {
 
   assert(metrics.size() == specs.size());
@@ -76,7 +77,7 @@ bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetric
       auto same = [metricLabel](std::regex const& matcher) -> bool {
         return std::regex_match(metricLabel.begin(), metricLabel.end(), matcher);
       };
-      //check if we are interested
+      // check if we are interested
       if (std::find_if(std::begin(performanceMetricsRegex), std::end(performanceMetricsRegex), same) == performanceMetricsRegex.end()) {
         continue;
       }
@@ -85,7 +86,7 @@ bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetric
       if (deviceMetrics.metrics[mi].filledMetrics == 0) {
         continue;
       }
-      //if so
+      // if so
 
       boost::property_tree::ptree metricNode;
 
@@ -122,7 +123,7 @@ bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetric
       return std::regex_match(metricLabel.begin(), metricLabel.end(), matcher);
     };
 
-    //check if we are interested
+    // check if we are interested
     if (std::find_if(std::begin(performanceMetricsRegex), std::end(performanceMetricsRegex), same) == performanceMetricsRegex.end()) {
       continue;
     }
@@ -133,7 +134,7 @@ bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetric
       continue;
     }
 
-    //if so
+    // if so
     boost::property_tree::ptree metricNode;
 
     switch (driverMetrics.metrics[mi].type) {
@@ -161,14 +162,7 @@ bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetric
 
   root.add_child("driver", driverRoot);
 
-  std::ofstream file("performanceMetrics.json", std::ios::out);
-  if (file.is_open()) {
-    boost::property_tree::json_parser::write_json(file, root);
-  } else {
-    return false;
-  }
-
-  file.close();
+  boost::property_tree::json_parser::write_json(out, root);
 
   return true;
 }
diff --git a/Framework/Core/src/ResourcesMonitoringHelper.h b/Framework/Core/src/ResourcesMonitoringHelper.h
index fc725e201ea98..549f681231e35 100644
--- a/Framework/Core/src/ResourcesMonitoringHelper.h
+++ b/Framework/Core/src/ResourcesMonitoringHelper.h
@@ -13,27 +13,25 @@
 #define O2_FRAMEWORK_RESOURCESMONITORINGHELPER_H_
 
 #include "Framework/DeviceMetricsInfo.h"
-#include "Monitoring/ProcessMonitor.h"
 #include "Framework/DeviceSpec.h"
 
 #include <vector>
-#include <type_traits>
 #include <regex>
+#include <iosfwd>
 
 namespace o2::framework
 {
-
 struct ResourcesMonitoringHelper {
   /// Dump the metrics in @a metrics which match the names specified in @a metricsToDump
   /// @a specs are the DeviceSpecs associated to the metrics.
   static bool dumpMetricsToJSON(std::vector<DeviceMetricsInfo> const& metrics,
                                 DeviceMetricsInfo const& driverMetrics,
                                 std::vector<DeviceSpec> const& specs,
-                                std::vector<std::regex> const& metricsToDump) noexcept;
+                                std::vector<std::regex> const& metricsToDump,
+                                std::ostream& out) noexcept;
   static bool isResourcesMonitoringEnabled(unsigned short interval) noexcept { return interval > 0; }
 };
 
-
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_RESOURCESMONITORINGHELPER_H_
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 0ea9f18eb65b3..f5992f6dbf359 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1247,8 +1247,10 @@ void dumpMetricsCallback(uv_timer_t* handle)
   auto* context = (DriverServerContext*)handle->data;
 
   static auto performanceMetrics = getDumpableMetrics();
+  std::ofstream file(context->driver->resourcesMonitoringFilename, std::ios::out);
   ResourcesMonitoringHelper::dumpMetricsToJSON(*(context->metrics),
-                                               context->driver->metrics, *(context->specs), performanceMetrics);
+                                               context->driver->metrics, *(context->specs), performanceMetrics,
+                                               file);
 }
 
 void dumpRunSummary(DriverServerContext& context, DriverInfo const& driverInfo, DeviceInfos const& infos, DeviceSpecs const& specs)
@@ -2035,6 +2037,7 @@ int runStateMachine(DataProcessorSpecs const& workflow,
             "--fairmq-ipc-prefix",
             "--readers",
             "--resources-monitoring",
+            "--resources-monitoring-file",
             "--resources-monitoring-dump-interval",
             "--time-limit",
           };
@@ -2268,7 +2271,7 @@ int runStateMachine(DataProcessorSpecs const& workflow,
           if (driverInfo.resourcesMonitoringDumpInterval) {
             uv_timer_stop(&metricDumpTimer);
           }
-          LOG(info) << "Dumping performance metrics to performanceMetrics.json file";
+          LOGP(info, "Dumping performance metrics to {}.json file", driverInfo.resourcesMonitoringFilename);
           dumpMetricsCallback(&metricDumpTimer);
         }
         dumpRunSummary(serverContext, driverInfo, infos, runningWorkflow.devices);
@@ -2916,6 +2919,7 @@ int doMain(int argc, char** argv, o2::framework::WorkflowSpec const& workflow,
     ("no-IPC", bpo::value<bool>()->zero_tokens()->default_value(false), "disable IPC topology optimization")                                                           //                                                                                                                                        //
     ("o2-control,o2", bpo::value<std::string>()->default_value(""), "dump O2 Control workflow configuration under the specified name")                                 //
     ("resources-monitoring", bpo::value<unsigned short>()->default_value(0), "enable cpu/memory monitoring for provided interval in seconds")                          //
+    ("resources-monitoring-file", bpo::value<std::string>()->default_value("performanceMetrics.json"), "file where to dump the metrics")                               //
     ("resources-monitoring-dump-interval", bpo::value<unsigned short>()->default_value(0), "dump monitoring information to disk every provided seconds");              //
   // some of the options must be forwarded by default to the device
   executorOptions.add(DeviceSpecHelpers::getForwardedDeviceOptions());
@@ -3186,6 +3190,7 @@ int doMain(int argc, char** argv, o2::framework::WorkflowSpec const& workflow,
   driverInfo.deployHostname = varmap["hostname"].as<std::string>();
   driverInfo.resources = varmap["resources"].as<std::string>();
   driverInfo.resourcesMonitoringInterval = varmap["resources-monitoring"].as<unsigned short>();
+  driverInfo.resourcesMonitoringFilename = varmap["resources-monitoring-file"].as<std::string>();
   driverInfo.resourcesMonitoringDumpInterval = varmap["resources-monitoring-dump-interval"].as<unsigned short>();
 
   // FIXME: should use the whole dataProcessorInfos, actually...
diff --git a/Framework/Core/test/test_ResourcesMonitoringHelpers.cxx b/Framework/Core/test/test_ResourcesMonitoringHelpers.cxx
new file mode 100644
index 0000000000000..9e355d535f301
--- /dev/null
+++ b/Framework/Core/test/test_ResourcesMonitoringHelpers.cxx
@@ -0,0 +1,270 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "../src/ResourcesMonitoringHelper.h"
+#include "Framework/DeviceMetricsInfo.h"
+#include "Framework/DeviceMetricsHelper.h"
+
+#include <catch_amalgamated.hpp>
+#include <regex>
+#include <sstream>
+#include <iostream>
+
+TEST_CASE("StreamMetrics")
+{
+  using namespace o2::framework;
+  std::vector<DeviceSpec> specs{
+    DeviceSpec{
+      .name = "someDevice",
+      .id = "someDevice",
+      .inputChannels = {},
+      .outputChannels = {},
+      .arguments = {},
+      .options = {},
+      .services = {},
+      .algorithm = AlgorithmSpec{},
+      .inputs = {},
+      .outputs = {},
+      .forwards = {},
+      .rank = 0,
+      .nSlots = 0,
+      .inputTimesliceId = 0,
+      .maxInputTimeslices = 0,
+      .completionPolicy = CompletionPolicy{},
+      .dispatchPolicy = DispatchPolicy{},
+      .callbacksPolicy = CallbacksPolicy{},
+      .sendingPolicy = SendingPolicy{},
+      .resourcePolicy = ResourcePolicy{},
+      .resource = {},
+      .resourceMonitoringInterval = 10,
+      .labels = {},
+      .metadata = {}},
+    DeviceSpec{
+      .name = "anotherDevice",
+      .id = "anotherDevice",
+      .inputChannels = {},
+      .outputChannels = {},
+      .arguments = {},
+      .options = {},
+      .services = {},
+      .algorithm = AlgorithmSpec{},
+      .inputs = {},
+      .outputs = {},
+      .forwards = {},
+      .rank = 0,
+      .nSlots = 0,
+      .inputTimesliceId = 0,
+      .maxInputTimeslices = 0,
+      .completionPolicy = CompletionPolicy{},
+      .dispatchPolicy = DispatchPolicy{},
+      .callbacksPolicy = CallbacksPolicy{},
+      .sendingPolicy = SendingPolicy{},
+      .resourcePolicy = ResourcePolicy{},
+      .resource = {},
+      .resourceMonitoringInterval = 10,
+      .labels = {},
+      .metadata = {}},
+
+  };
+
+  // This is the device metrics
+  std::vector<DeviceMetricsInfo> metrics;
+  metrics.resize(2);
+  {
+    DeviceMetricsInfo& info = metrics[0];
+    auto bkey = DeviceMetricsHelper::createNumericMetric<int>(info, "bkey");
+    REQUIRE(info.metricLabels.size() == 1);
+    REQUIRE(info.metricPrefixes.size() == 1);
+    auto akey = DeviceMetricsHelper::createNumericMetric<float>(info, "akey");
+    REQUIRE(info.metricLabels.size() == 2);
+    REQUIRE(info.metricPrefixes.size() == 2);
+    auto ckey = DeviceMetricsHelper::createNumericMetric<uint64_t>(info, "ckey");
+    REQUIRE(info.metricLabels.size() == 3);
+    REQUIRE(info.metricPrefixes.size() == 3);
+    REQUIRE(DeviceMetricsHelper::metricIdxByName("akey", info) == 1);
+    REQUIRE(DeviceMetricsHelper::metricIdxByName("bkey", info) == 0);
+    REQUIRE(DeviceMetricsHelper::metricIdxByName("ckey", info) == 2);
+    REQUIRE(info.changed.size() == 3);
+    REQUIRE(info.changed.at(0) == false);
+    size_t t = 1000;
+    ckey(info, 0, t++);
+    ckey(info, 1, t++);
+    ckey(info, 2, t++);
+    ckey(info, 3, t++);
+    ckey(info, 4, t++);
+    ckey(info, 5, t++);
+  }
+  // Metrics for the second device
+  {
+    DeviceMetricsInfo& info = metrics[1];
+    auto bkey = DeviceMetricsHelper::createNumericMetric<int>(info, "bkey");
+    REQUIRE(info.metricLabels.size() == 1);
+    REQUIRE(info.metricPrefixes.size() == 1);
+    auto akey = DeviceMetricsHelper::createNumericMetric<float>(info, "akey");
+    REQUIRE(info.metricLabels.size() == 2);
+    REQUIRE(info.metricPrefixes.size() == 2);
+    auto ckey = DeviceMetricsHelper::createNumericMetric<uint64_t>(info, "ckey");
+    REQUIRE(info.metricLabels.size() == 3);
+    REQUIRE(info.metricPrefixes.size() == 3);
+    REQUIRE(DeviceMetricsHelper::metricIdxByName("akey", info) == 1);
+    REQUIRE(DeviceMetricsHelper::metricIdxByName("bkey", info) == 0);
+    REQUIRE(DeviceMetricsHelper::metricIdxByName("ckey", info) == 2);
+    REQUIRE(info.changed.size() == 3);
+    REQUIRE(info.changed.at(0) == false);
+    size_t t = 1000;
+    bkey(info, 0, t++);
+    bkey(info, 1, t++);
+    bkey(info, 2, t++);
+    bkey(info, 3, t++);
+    bkey(info, 4, t++);
+    bkey(info, 5, t++);
+  }
+
+  // This is the driver metrics
+  DeviceMetricsInfo driverMetrics;
+  auto dbkey = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "bkey");
+  REQUIRE(driverMetrics.metricLabels.size() == 1);
+  REQUIRE(driverMetrics.metricPrefixes.size() == 1);
+  auto dakey = DeviceMetricsHelper::createNumericMetric<float>(driverMetrics, "akey");
+  REQUIRE(driverMetrics.metricLabels.size() == 2);
+  REQUIRE(driverMetrics.metricPrefixes.size() == 2);
+  auto dckey = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "ckey");
+  REQUIRE(driverMetrics.metricLabels.size() == 3);
+  REQUIRE(driverMetrics.metricPrefixes.size() == 3);
+  REQUIRE(DeviceMetricsHelper::metricIdxByName("akey", driverMetrics) == 1);
+  REQUIRE(DeviceMetricsHelper::metricIdxByName("bkey", driverMetrics) == 0);
+  REQUIRE(DeviceMetricsHelper::metricIdxByName("ckey", driverMetrics) == 2);
+  REQUIRE(driverMetrics.changed.size() == 3);
+  REQUIRE(driverMetrics.changed.at(0) == false);
+  size_t t = 2000;
+  dbkey(driverMetrics, 0, t++);
+  dbkey(driverMetrics, 1, t++);
+  dbkey(driverMetrics, 2, t++);
+  dbkey(driverMetrics, 3, t++);
+  dbkey(driverMetrics, 4, t++);
+  dbkey(driverMetrics, 5, t++);
+
+  dbkey(driverMetrics, 0, t++);
+  dbkey(driverMetrics, 1, t++);
+
+  dckey(driverMetrics, 0, t++);
+
+  std::stringstream streamer;
+  std::vector<std::regex> performanceMetrics{
+    std::regex("bkey"),
+    std::regex("ckey"),
+  };
+
+  ResourcesMonitoringHelper::dumpMetricsToJSON(metrics,
+                                               driverMetrics, specs, performanceMetrics,
+                                               streamer);
+  REQUIRE(streamer.str() == R"JSON({
+    "someDevice": {
+        "ckey": [
+            {
+                "timestamp": "1000",
+                "value": "0"
+            },
+            {
+                "timestamp": "1001",
+                "value": "1"
+            },
+            {
+                "timestamp": "1002",
+                "value": "2"
+            },
+            {
+                "timestamp": "1003",
+                "value": "3"
+            },
+            {
+                "timestamp": "1004",
+                "value": "4"
+            },
+            {
+                "timestamp": "1005",
+                "value": "5"
+            }
+        ]
+    },
+    "anotherDevice": {
+        "bkey": [
+            {
+                "timestamp": "1000",
+                "value": "0"
+            },
+            {
+                "timestamp": "1001",
+                "value": "1"
+            },
+            {
+                "timestamp": "1002",
+                "value": "2"
+            },
+            {
+                "timestamp": "1003",
+                "value": "3"
+            },
+            {
+                "timestamp": "1004",
+                "value": "4"
+            },
+            {
+                "timestamp": "1005",
+                "value": "5"
+            }
+        ]
+    },
+    "driver": {
+        "bkey": [
+            {
+                "timestamp": "2000",
+                "value": "0"
+            },
+            {
+                "timestamp": "2001",
+                "value": "1"
+            },
+            {
+                "timestamp": "2002",
+                "value": "2"
+            },
+            {
+                "timestamp": "2003",
+                "value": "3"
+            },
+            {
+                "timestamp": "2004",
+                "value": "4"
+            },
+            {
+                "timestamp": "2005",
+                "value": "5"
+            },
+            {
+                "timestamp": "2006",
+                "value": "0"
+            },
+            {
+                "timestamp": "2007",
+                "value": "1"
+            }
+        ],
+        "ckey": [
+            {
+                "timestamp": "2008",
+                "value": "0"
+            }
+        ]
+    }
+}
+)JSON");
+}

From ee4bb3b64d09e6b4bacdbf1c0b672669fda63eab Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 7 Nov 2025 13:41:38 +0100
Subject: [PATCH 1010/1764] GPU QA: Make some of the plots nices

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 GPU/GPUTracking/qa/GPUQA.cxx                  | 69 ++++++++++---------
 GPU/GPUTracking/qa/GPUQA.h                    |  7 +-
 3 files changed, 41 insertions(+), 36 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 091eeccfd0246..f8845f82ee1e2 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -525,6 +525,7 @@ AddOption(histMaxNClusters, uint32_t, 500000000, "", 0, "Maximum number of clust
 AddOption(minNClFindable, uint32_t, 70, "", 0, "Minimum number of (weighted) MC clusters for a track to count as findable")
 AddOption(minNClEff, uint32_t, 10, "", 0, "Minimum number of (weighted) MC clusters for a track to contribute to all-tracks efficiency histogramm")
 AddOption(minNClRes, uint32_t, 40, "", 0, "Minimum number of (weighted) MC clusters for a track to contribute to resolution histogram")
+AddOption(perfFigure, int32_t, 0, "", 0, "Show as performance figure, positive value for MC, negative value for data")
 AddShortcut("compare", 0, "--QAinput", "Compare QA histograms", "--qa", "--QAinputHistogramsOnly")
 AddHelp("help", 'h')
 EndConfig()
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index b9d83a734df7d..681426cdc9575 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -144,17 +144,11 @@ static const GPUSettingsQA& GPUQA_GetConfig(GPUChainTracking* chain)
   }
 }
 
-// static const constexpr bool PLOT_ROOT = 0;
-// static const constexpr bool FIX_SCALES = 0;
-static const constexpr bool PERF_FIGURE = 0;
-// static const constexpr float FIXED_SCALES_MIN[5] = {-0.05, -0.05, -0.2, -0.2, -0.5};
-// static const constexpr float FIXED_SCALES_MAX[5] = {0.4, 0.7, 5, 3, 6.5};
 static const constexpr float LOG_PT_MIN = -1.;
 
 static constexpr float Y_MAX = 40;
 static constexpr float Z_MAX = 100;
 static constexpr float PT_MIN = GPUCA_MIN_TRACK_PTB5_DEFAULT;
-// static constexpr float PT_MIN2 = 0.1;
 static constexpr float PT_MIN_PRIM = 0.1;
 static constexpr float PT_MIN_CLUST = GPUCA_MIN_TRACK_PTB5_DEFAULT;
 static constexpr float PT_MAX = 20;
@@ -375,10 +369,10 @@ void GPUQA::SetAxisSize(T* e)
   e->GetXaxis()->SetLabelSize(0.045);
 }
 
-void GPUQA::SetLegend(TLegend* l)
+void GPUQA::SetLegend(TLegend* l, bool bigText)
 {
   l->SetTextFont(72);
-  l->SetTextSize(0.016);
+  l->SetTextSize(bigText ? 0.03 : 0.016);
   l->SetFillColor(0);
 }
 
@@ -419,15 +413,20 @@ void GPUQA::DrawHisto(TH1* histo, char* filename, char* options)
 
 void GPUQA::doPerfFigure(float x, float y, float size)
 {
-  if (!PERF_FIGURE) {
+  const char* str_perf_figure_1 = "ALICE Performance";
+  const char* str_perf_figure_2_mc = "MC, Pb#minusPb, #sqrt{s_{NN}} = 5.36 TeV";
+  const char* str_perf_figure_2_data = "Pb#minusPb, #sqrt{s_{NN}} = 5.36 TeV";
+
+  if (mConfig.perfFigure == 0) {
     return;
   }
-  TLatex* t = createGarbageCollected<TLatex>();
+  TLatex* t = createGarbageCollected<TLatex>(); // TODO: We could perhaps put everything in a legend, to get a white background if there is a grid
   t->SetNDC(kTRUE);
   t->SetTextColor(1);
   t->SetTextSize(size);
   t->DrawLatex(x, y, str_perf_figure_1);
-  t->DrawLatex(x, y - 0.01 - size, str_perf_figure_2);
+  t->SetTextSize(size * 0.8);
+  t->DrawLatex(x, y - 0.01 - size, mConfig.perfFigure > 0 ? str_perf_figure_2_mc : str_perf_figure_2_data);
 }
 
 void GPUQA::SetMCTrackRange(int32_t min, int32_t max)
@@ -1954,20 +1953,22 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
   mTrackingScratchBuffer.shrink_to_fit();
 }
 
-void GPUQA::GetName(char* fname, int32_t k)
+void GPUQA::GetName(char* fname, int32_t k, bool noDash)
 {
   const int32_t nNewInput = mConfig.inputHistogramsOnly ? 0 : 1;
   if (k || mConfig.inputHistogramsOnly || mConfig.name.size()) {
     if (!(mConfig.inputHistogramsOnly || k)) {
-      snprintf(fname, 1024, "%s - ", mConfig.name.c_str());
+      snprintf(fname, 1024, "%s%s", mConfig.name.c_str(), noDash ? "" : " - ");
     } else if (mConfig.compareInputNames.size() > (unsigned)(k - nNewInput)) {
-      snprintf(fname, 1024, "%s - ", mConfig.compareInputNames[k - nNewInput].c_str());
+      snprintf(fname, 1024, "%s%s", mConfig.compareInputNames[k - nNewInput].c_str(), noDash ? "" : " - ");
     } else {
       strcpy(fname, mConfig.compareInputs[k - nNewInput].c_str());
       if (strlen(fname) > 5 && strcmp(fname + strlen(fname) - 5, ".root") == 0) {
         fname[strlen(fname) - 5] = 0;
       }
-      strcat(fname, " - ");
+      if (!noDash) {
+        strcat(fname, " - ");
+      }
     }
   } else {
     fname[0] = 0;
@@ -2187,8 +2188,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mCTracks->cd();
       mPTracks = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPTracks->Draw();
-      mLTracks = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.45, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
-      SetLegend(mLTracks);
+      mLTracks = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.5, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
+      SetLegend(mLTracks, true);
 
       for (int32_t i = 0; i < 2; i++) {
         snprintf(name, 2048, "ctrackst0%d", i);
@@ -2204,8 +2205,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         mCNCl[i]->cd();
         mPNCl[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
         mPNCl[i]->Draw();
-        mLNCl[i] = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.45, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
-        SetLegend(mLNCl[i]);
+        mLNCl[i] = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.45, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949); // TODO: Fix sizing of legend, and also fix font size
+        SetLegend(mLNCl[i], true);
       }
 
       mCClXY = createGarbageCollected<TCanvas>("clxy", "Number of clusters per X / Y", 0, 0, 700, 700. * 2. / 3.);
@@ -2288,7 +2289,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
               continue;
             }
             e->SetMarkerColor(kBlack);
-            e->SetLineColor(colorNums[(k * 3 + l) % COLORCOUNT]);
+            e->SetLineColor(colorNums[(k < 3 ? (l * 3 + k) : (k * 3 + l)) % COLORCOUNT]);
             e->GetHistogram()->GetYaxis()->SetRangeUser(-0.02, 1.02);
             e->Draw(k || l ? "same P" : "AP");
             if (j == 0) {
@@ -2776,7 +2777,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       if (!mConfig.enableLocalOutput) {
         continue;
       }
-      doPerfFigure(i != 2 ? 0.37 : 0.6, 0.295, 0.030);
+      doPerfFigure(i == 0 ? 0.37 : (i == 1 ? 0.34 : 0.6), 0.295, 0.030);
       mCClust[i]->cd();
       mCClust[i]->Print(i == 2 ? "plots/clusters_integral.pdf" : i == 1 ? "plots/clusters_relative.pdf" : "plots/clusters.pdf");
       if (mConfig.writeRootFiles) {
@@ -2827,19 +2828,21 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       e->SetMinimum(tmpMax * -0.02);
       e->SetStats(kFALSE);
       e->SetLineWidth(1);
-      e->GetYaxis()->SetTitle("a.u.");
-      e->GetXaxis()->SetTitle("#it{p}_{Tmc} (GeV/#it{c})");
+      e->SetTitle("Number of Tracks vs #it{p}_{T}");
+      e->GetYaxis()->SetTitle("Number of Tracks");
+      e->GetXaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
       if (qcout) {
         qcout->Add(e);
       }
       e->SetMarkerColor(kBlack);
       e->SetLineColor(colorNums[k % COLORCOUNT]);
       e->Draw(k == 0 ? "" : "same");
-      GetName(fname, k);
-      snprintf(name, 2048, "%sTrack Pt", fname);
+      GetName(fname, k, mConfig.inputHistogramsOnly);
+      snprintf(name, 2048, mConfig.inputHistogramsOnly ? "%s" : "%sTrack #it{p}_{T}", fname);
       mLTracks->AddEntry(e, name, "l");
     }
     mLTracks->Draw();
+    doPerfFigure(0.63, 0.7, 0.030);
     mCTracks->cd();
     mCTracks->Print("plots/tracks.pdf");
     if (mConfig.writeRootFiles) {
@@ -2871,19 +2874,21 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         e->SetMinimum(tmpMax * -0.02);
         e->SetStats(kFALSE);
         e->SetLineWidth(1);
+        e->SetTitle(i ? "Track t_{0} resolution" : "Track t_{0} distribution");
         e->GetYaxis()->SetTitle("a.u.");
-        e->GetXaxis()->SetTitle(i ? "to vs t0_{mc}" : "t0");
+        e->GetXaxis()->SetTitle(i ? "t_{0} - t_{0, mc}" : "t_{0}");
         if (qcout) {
           qcout->Add(e);
         }
         e->SetMarkerColor(kBlack);
         e->SetLineColor(colorNums[k % COLORCOUNT]);
         e->Draw(k == 0 ? "" : "same");
-        GetName(fname, k);
-        snprintf(name, 2048, "%sTrack T0 %s", fname, i ? "" : "resolution");
+        GetName(fname, k, mConfig.inputHistogramsOnly);
+        snprintf(name, 2048, mConfig.inputHistogramsOnly ? "%s (%s)" : "%sTrack t_{0} %s", fname, i ? "" : "resolution");
         mLT0[i]->AddEntry(e, name, "l");
       }
       mLT0[i]->Draw();
+      doPerfFigure(0.63, 0.7, 0.030);
       mCT0[i]->cd();
       snprintf(name, 2048, "plots/t0%s.pdf", i ? "_res" : "");
       mCT0[i]->Print(name);
@@ -2916,19 +2921,21 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         e->SetMinimum(tmpMax * -0.02);
         e->SetStats(kFALSE);
         e->SetLineWidth(1);
+        e->SetTitle(i ? "Number of Rows with attached Cluster" : "Number of Clusters");
         e->GetYaxis()->SetTitle("a.u.");
-        e->GetXaxis()->SetTitle("NClusters");
+        e->GetXaxis()->SetTitle(i ? "N_{Rows with Clusters}" : "N_{Clusters}");
         if (qcout) {
           qcout->Add(e);
         }
         e->SetMarkerColor(kBlack);
         e->SetLineColor(colorNums[k % COLORCOUNT]);
         e->Draw(k == 0 ? "" : "same");
-        GetName(fname, k);
-        snprintf(name, 2048, "%sNClusters%d", fname, i);
+        GetName(fname, k, mConfig.inputHistogramsOnly);
+        snprintf(name, 2048, mConfig.inputHistogramsOnly ? "%s" : (i ? "%sN_{Clusters}" : "%sN_{Rows with Clusters}"), fname);
         mLNCl[i]->AddEntry(e, name, "l");
       }
       mLNCl[i]->Draw();
+      doPerfFigure(0.6, 0.7, 0.030);
       mCNCl[i]->cd();
       snprintf(name, 2048, "plots/nClusters%s.pdf", i ? "_corrected" : "");
       mCNCl[i]->Print(name);
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 92e931892339a..fcfe1aea8b04f 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -172,12 +172,12 @@ class GPUQA
   void CopyO2MCtoIOPtr(GPUTrackingInOutPointers* ptr);
   template <class T>
   void SetAxisSize(T* e);
-  void SetLegend(TLegend* l);
+  void SetLegend(TLegend* l, bool bigText = false);
   double* CreateLogAxis(int32_t nbins, float xmin, float xmax);
   void ChangePadTitleSize(TPad* p, float size);
   void DrawHisto(TH1* histo, char* filename, char* options);
   void doPerfFigure(float x, float y, float size);
-  void GetName(char* fname, int32_t k);
+  void GetName(char* fname, int32_t k, bool noDash = false);
   template <class T>
   T* GetHist(T*& ee, std::vector<std::unique_ptr<TFile>>& tin, int32_t k, int32_t nNewInput);
 
@@ -234,9 +234,6 @@ class GPUQA
   const GPUSettingsQA& mConfig;
   const GPUParam* mParam;
 
-  const char* str_perf_figure_1 = "ALICE Performance 2018/03/20";
-  // const char* str_perf_figure_2 = "2015, MC pp, #sqrt{s} = 5.02 TeV";
-  const char* str_perf_figure_2 = "2015, MC Pb-Pb, #sqrt{s_{NN}} = 5.02 TeV";
   //-------------------------
 
   std::vector<mcLabelI_t> mTrackMCLabels;

From 584c573adc980954a941abaa9e50eb629fb428bf Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 8 Nov 2025 09:54:51 +0100
Subject: [PATCH 1011/1764] GPU QA: Fix accounting of protected and unattached
 clusters with attachProtect flag

---
 .../DataCompression/GPUTPCClusterRejection.h  |  18 +-
 .../DataCompression/GPUTPCCompression.cxx     |   2 +-
 .../DataCompression/GPUTPCCompression.h       |   2 +-
 .../GPUTPCCompressionKernels.cxx              |   6 +-
 .../Global/GPUChainTrackingClusterizer.cxx    |   2 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  | 157 +++++++++---------
 GPU/GPUTracking/qa/GPUQA.h                    |   4 +
 7 files changed, 99 insertions(+), 92 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h b/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
index ae3ffb29926a7..8ec8c85c4c73f 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCClusterRejection.h
@@ -16,12 +16,19 @@
 #define GPUTPCCLUSTERREJECTION_H
 
 #include "GPUTPCGMMergerTypes.h"
+#include "GPUCommonMath.h"
 
 namespace o2::gpu
 {
 struct GPUTPCClusterRejection {
+  template <class T, class S>
+  GPUdi() static bool IsTrackRejected(const T& trk, const S& param)
+  {
+    return CAMath::Abs(trk.GetParam().GetQPt() * param.qptB5Scaler) > param.rec.tpc.rejectQPtB5 || trk.MergedLooper();
+  }
+
   template <bool C, class T = void, class S = void>
-  static constexpr inline bool GetProtectionStatus(int32_t attach, bool& physics, bool& protect, T* counts = nullptr, S* mev200 = nullptr)
+  GPUdi() static constexpr bool GetRejectionStatus(int32_t attach, bool& physics, T* counts = nullptr, S* mev200 = nullptr)
   {
     (void)counts; // FIXME: Avoid incorrect -Wunused-but-set-parameter warning
     (void)mev200;
@@ -39,7 +46,6 @@ struct GPUTPCClusterRejection {
       }
       retVal = true;
     } else if (attach & gputpcgmmergertypes::attachTube) {
-      protect = true;
       if constexpr (C) {
         if (*mev200) {
           counts->nTube200++;
@@ -49,7 +55,6 @@ struct GPUTPCClusterRejection {
       }
       retVal = false;
     } else if ((attach & gputpcgmmergertypes::attachGood) == 0) {
-      protect = true;
       if constexpr (C) {
         counts->nRejected++;
       }
@@ -60,16 +65,15 @@ struct GPUTPCClusterRejection {
     }
 
     if (attach & gputpcgmmergertypes::attachProtect) {
-      protect = true;
       retVal = false;
     }
     return retVal;
   }
 
-  static constexpr inline bool GetIsRejected(int32_t attach)
+  GPUdi() static constexpr bool GetIsRejected(int32_t attach)
   {
-    bool physics = false, protect = false;
-    return GetProtectionStatus<false>(attach, physics, protect);
+    bool physics = false;
+    return GetRejectionStatus<false>(attach, physics);
   }
 };
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index 61f8a614fbe6f..85cd9598e0bf1 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -111,7 +111,7 @@ void GPUTPCCompression::RegisterMemoryAllocation()
   if (gatherMode == 3) {
     mMemoryResOutputGPU = mRec->RegisterMemoryAllocation(this, &GPUTPCCompression::SetPointersOutputGPU, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_GPU | GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_STACK, "TPCCompressionOutputGPU");
   }
-  uint32_t stackScratch = (gatherMode != 3) ? GPUMemoryResource::MEMORY_STACK : 0;
+  uint32_t stackScratch = (gatherMode != 3) ? GPUMemoryResource::MEMORY_STACK : 0; // TODO: Can we use stacked memory also with gather mode 3?
   if (gatherMode < 2) {
     mRec->RegisterMemoryAllocation(this, &GPUTPCCompression::SetPointersOutput, GPUMemoryResource::MEMORY_OUTPUT | stackScratch, "TPCCompressionOutput");
   }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
index 1dafffaeea043..95173dad7257f 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
@@ -60,6 +60,7 @@ class GPUTPCCompression : public GPUProcessor
 #ifndef GPUCA_GPUCODE
   void DumpCompressedClusters(std::ostream& out);
 #endif
+  GPUd() bool rejectCluster(int32_t idx, const GPUParam& param, const GPUTrackingInOutPointers& ioPtrs) const;
 
  protected:
   struct memory {
@@ -89,7 +90,6 @@ class GPUTPCCompression : public GPUProcessor
   void SetPointersCompressedClusters(void*& mem, T& c, uint32_t nClA, uint32_t nTr, uint32_t nClU, bool reducedClA);
   template <class T>
   GPUd() static void truncateSignificantBits(T& val, uint32_t nBits, uint32_t max);
-  GPUd() bool rejectCluster(int32_t idx, GPUParam& param, const GPUTrackingInOutPointers& ioPtrs);
 
   int16_t mMemoryResOutputHost = -1;
   int16_t mMemoryResOutputGPU = -1;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 911af719dd3d4..1cd44e221f203 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -39,7 +39,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
     if (!trk.OK()) {
       continue;
     }
-    bool rejectTrk = CAMath::Abs(trk.GetParam().GetQPt() * processors.param.qptB5Scaler) > processors.param.rec.tpc.rejectQPtB5 || trk.MergedLooper();
+    bool rejectTrk = GPUTPCClusterRejection::IsTrackRejected(trk, param);
     uint32_t nClustersStored = 0;
     CompressedClustersPtrs& GPUrestrict() c = compressor.mPtrs;
     uint8_t lastRow = 0, lastSector = 0;
@@ -185,7 +185,7 @@ GPUd() bool GPUTPCCompressionKernels::GPUTPCCompressionKernels_Compare<4>::opera
   return mClsPtr[a].qTot < mClsPtr[b].qTot;
 }
 
-GPUd() bool GPUTPCCompression::rejectCluster(int32_t idx, GPUParam& GPUrestrict() param, const GPUTrackingInOutPointers& GPUrestrict() ioPtrs)
+GPUd() bool GPUTPCCompression::rejectCluster(int32_t idx, const GPUParam& GPUrestrict() param, const GPUTrackingInOutPointers& GPUrestrict() ioPtrs) const
 {
   if (mClusterStatus[idx]) {
     return true;
@@ -206,7 +206,7 @@ GPUd() bool GPUTPCCompression::rejectCluster(int32_t idx, GPUParam& GPUrestrict(
     }
     int32_t id = attach & gputpcgmmergertypes::attachTrackMask;
     auto& trk = ioPtrs.mergedTracks[id];
-    if (CAMath::Abs(trk.GetParam().GetQPt() * param.qptB5Scaler) > param.rec.tpc.rejectQPtB5 || trk.MergedLooper()) {
+    if (GPUTPCClusterRejection::IsTrackRejected(trk, param)) {
       return true;
     }
   }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 7a870ccb35178..bfb0457744ce5 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -587,7 +587,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     return ForwardTPCDigits();
   }
 #ifdef GPUCA_TPC_GEOMETRY_O2
-  [[maybe_unused]] int32_t tpcTimeBinCut = mUpdateNewCalibObjects && mNewCalibValues->newTPCTimeBinCut ? mNewCalibValues->tpcTimeBinCut : param().tpcCutTimeBin;
+  [[maybe_unused]] int32_t tpcTimeBinCut = (mUpdateNewCalibObjects && mNewCalibValues->newTPCTimeBinCut) ? mNewCalibValues->tpcTimeBinCut : param().tpcCutTimeBin; // TODO: Implement time bin cut fultering
   mRec->PushNonPersistentMemory(qStr2Tag("TPCCLUST"));
   const auto& threadContext = GetThreadContext();
   const bool doGPU = GetRecoStepsGPU() & RecoStep::TPCClusterFinding;
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 681426cdc9575..d5ed7e45835eb 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -55,6 +55,7 @@
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "GPUSettings.h"
+#include "GPUDefMacros.h"
 #ifdef GPUCA_O2_LIB
 #include "DetectorsRaw/HBFUtils.h"
 #include "DataFormatsTPC/TrackTPC.h"
@@ -81,58 +82,55 @@
 
 using namespace o2::gpu;
 
-#ifdef GPUCA_MERGER_BY_MC_LABEL
-#define CHECK_CLUSTER_STATE_INIT_LEG_BY_MC()                                        \
-  if (!unattached && mTrackMCLabels[id].isValid()) {                                \
-    int32_t mcLabel = mTrackMCLabels[id].getTrackID();                              \
-    int32_t mcEvent = mTrackMCLabels[id].getEventID();                              \
-    int32_t mcSource = mTrackMCLabels[id].getSourceID();                            \
-    if (mTrackMCLabelsReverse[mMCEventOffset[mcSource] + mcEvent][mcLabel] != id) { \
-      attach &= (~gputpcgmmergertypes::attachGoodLeg);                              \
-    }                                                                               \
-  }
-#else
-#define CHECK_CLUSTER_STATE_INIT_LEG_BY_MC()
-#endif
+namespace o2::gpu
+{
+struct checkClusterStateResult {
+  bool unattached = false;
+  float qpt = 0.f;
+  bool lowPt = false;
+  bool mev200 = false;
+  bool mergedLooperUnconnected = false;
+  bool mergedLooperConnected = false;
+  int32_t id = 0;
+  bool physics = false, protect = false;
+};
+} // namespace o2::gpu
 
-#define CHECK_CLUSTER_STATE_INIT()                                                               \
-  bool unattached = attach == 0;                                                                 \
-  float qpt = 0;                                                                                 \
-  bool lowPt = false;                                                                            \
-  [[maybe_unused]] bool mev200 = false;                                                          \
-  bool mergedLooperUnconnected = false;                                                          \
-  bool mergedLooperConnected = false;                                                            \
-  int32_t id = attach & gputpcgmmergertypes::attachTrackMask;                                    \
-  if (!unattached) {                                                                             \
-    qpt = fabsf(mTracking->mIOPtrs.mergedTracks[id].GetParam().GetQPt());                        \
-    lowPt = qpt * mTracking->GetParam().qptB5Scaler > mTracking->GetParam().rec.tpc.rejectQPtB5; \
-    mev200 = qpt > 5;                                                                            \
-    mergedLooperUnconnected = mTracking->mIOPtrs.mergedTracks[id].MergedLooperUnconnected();     \
-    mergedLooperConnected = mTracking->mIOPtrs.mergedTracks[id].MergedLooperConnected();         \
-  }                                                                                              \
-  bool physics = false, protect = false;                                                         \
-  CHECK_CLUSTER_STATE_INIT_LEG_BY_MC();
-
-#define CHECK_CLUSTER_STATE()                                                                              \
-  CHECK_CLUSTER_STATE_INIT()                                                                               \
-  if (mev200) {                                                                                            \
-    mClusterCounts.n200MeV++;                                                                              \
-  }                                                                                                        \
-  if (lowPt) {                                                                                             \
-    mClusterCounts.nLowPt++;                                                                               \
-  } else if (mergedLooperUnconnected) {                                                                    \
-    mClusterCounts.nMergedLooperUnconnected++;                                                             \
-  } else if (mergedLooperConnected) {                                                                      \
-    mClusterCounts.nMergedLooperConnected++;                                                               \
-  } else {                                                                                                 \
-    GPUTPCClusterRejection::GetProtectionStatus<true>(attach, physics, protect, &mClusterCounts, &mev200); \
-  }
-
-#define CHECK_CLUSTER_STATE_NOCOUNT()                                             \
-  CHECK_CLUSTER_STATE_INIT()                                                      \
-  if (!lowPt && !mergedLooperUnconnected && !mergedLooperConnected) {             \
-    GPUTPCClusterRejection::GetProtectionStatus<false>(attach, physics, protect); \
+template <bool COUNT, class T>
+inline checkClusterStateResult GPUQA::checkClusterState(uint32_t attach, T* counts) const
+{
+  checkClusterStateResult r;
+  r.unattached = attach == 0;
+  r.id = attach & gputpcgmmergertypes::attachTrackMask;
+  if (!r.unattached && !(attach & gputpcgmmergertypes::attachProtect)) {
+    r.qpt = fabsf(mTracking->mIOPtrs.mergedTracks[r.id].GetParam().GetQPt());
+    r.lowPt = r.qpt * mTracking->GetParam().qptB5Scaler > mTracking->GetParam().rec.tpc.rejectQPtB5;
+    r.mev200 = r.qpt > 5;
+    r.mergedLooperUnconnected = mTracking->mIOPtrs.mergedTracks[r.id].MergedLooperUnconnected();
+    r.mergedLooperConnected = mTracking->mIOPtrs.mergedTracks[r.id].MergedLooperConnected();
+  }
+  if (r.mev200) {
+    if constexpr (COUNT) {
+      counts->n200MeV++;
+    }
   }
+  if (r.lowPt) {
+    if constexpr (COUNT) {
+      counts->nLowPt++;
+    }
+  } else if (r.mergedLooperUnconnected) {
+    if constexpr (COUNT) {
+      counts->nMergedLooperUnconnected++;
+    }
+  } else if (r.mergedLooperConnected) {
+    if constexpr (COUNT) {
+      counts->nMergedLooperConnected++;
+    }
+  } else if (attach) {
+    r.protect = !GPUTPCClusterRejection::GetRejectionStatus<COUNT>(attach, r.physics, counts, &r.mev200) && ((attach & gputpcgmmergertypes::attachProtect) || !GPUTPCClusterRejection::IsTrackRejected(mTracking->mIOPtrs.mergedTracks[r.id], mTracking->GetParam()));
+  }
+  return r;
+}
 
 static const GPUSettingsQA& GPUQA_GetConfig(GPUChainTracking* chain)
 {
@@ -350,11 +348,11 @@ GPUQA::~GPUQA()
 
 bool GPUQA::clusterRemovable(int32_t attach, bool prot) const
 {
-  CHECK_CLUSTER_STATE_NOCOUNT();
+  const auto& r = checkClusterState<false>(attach);
   if (prot) {
-    return protect || physics;
+    return r.protect || r.physics;
   }
-  return (!unattached && !physics && !protect);
+  return (!r.unattached && !r.physics && !r.protect);
 }
 
 template <class T>
@@ -1462,7 +1460,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
               }
             }
             int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[hitId];
-            CHECK_CLUSTER_STATE_NOCOUNT();
+            const auto& r = checkClusterState<false>(attach);
             if (totalWeight > 0) {
               float weight = 1.f / (totalWeight * (mClusterParam[hitId].attached + mClusterParam[hitId].fakeAttached));
               for (int32_t j = 0; j < GetMCLabelNID(hitId); j++) {
@@ -1478,10 +1476,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
                     mClusters[CL_tracks]->Fill(pt, GetMCLabelWeight(hitId, j) * weight);
                   }
                   mClusters[CL_all]->Fill(pt, GetMCLabelWeight(hitId, j) * weight);
-                  if (protect || physics) {
+                  if (r.protect || r.physics) {
                     mClusters[CL_prot]->Fill(pt, GetMCLabelWeight(hitId, j) * weight);
                   }
-                  if (physics) {
+                  if (r.physics) {
                     mClusters[CL_physics]->Fill(pt, GetMCLabelWeight(hitId, j) * weight);
                   }
                 }
@@ -1492,10 +1490,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
               mClusters[CL_att_adj]->Fill(0.f, weight);
               mClusters[CL_all]->Fill(0.f, weight);
               mClusterCounts.nUnaccessible += weight;
-              if (protect || physics) {
+              if (r.protect || r.physics) {
                 mClusters[CL_prot]->Fill(0.f, weight);
               }
-              if (physics) {
+              if (r.physics) {
                 mClusters[CL_physics]->Fill(0.f, weight);
               }
             }
@@ -1532,11 +1530,11 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           mClusters[CL_att_adj]->Fill(pt, weight);
           mClusters[CL_all]->Fill(pt, weight);
           int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[hitId];
-          CHECK_CLUSTER_STATE_NOCOUNT();
-          if (protect || physics) {
+          const auto& r = checkClusterState<false>(attach);
+          if (r.protect || r.physics) {
             mClusters[CL_prot]->Fill(pt, weight);
           }
-          if (physics) {
+          if (r.physics) {
             mClusters[CL_physics]->Fill(pt, weight);
           }
         }
@@ -1549,7 +1547,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           continue;
         }
         int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
-        CHECK_CLUSTER_STATE_NOCOUNT();
+        const auto& r = checkClusterState<false>(attach);
         if (mClusterParam[i].adjacent) {
           int32_t label = mTracking->mIOPtrs.mergedTrackHitAttachment[i] & gputpcgmmergertypes::attachTrackMask;
           if (!mTrackMCLabels[label].isValid()) {
@@ -1575,10 +1573,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
                   mClusters[CL_att_adj]->Fill(pt, GetMCLabelWeight(i, j) * weight);
                   mClusters[CL_fakeAdj]->Fill(pt, GetMCLabelWeight(i, j) * weight);
                   mClusters[CL_all]->Fill(pt, GetMCLabelWeight(i, j) * weight);
-                  if (protect || physics) {
+                  if (r.protect || r.physics) {
                     mClusters[CL_prot]->Fill(pt, GetMCLabelWeight(i, j) * weight);
                   }
-                  if (physics) {
+                  if (r.physics) {
                     mClusters[CL_physics]->Fill(pt, GetMCLabelWeight(i, j) * weight);
                   }
                 }
@@ -1588,10 +1586,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
               mClusters[CL_fakeAdj]->Fill(0.f, 1.f);
               mClusters[CL_all]->Fill(0.f, 1.f);
               mClusterCounts.nUnaccessible++;
-              if (protect || physics) {
+              if (r.protect || r.physics) {
                 mClusters[CL_prot]->Fill(0.f, 1.f);
               }
-              if (physics) {
+              if (r.physics) {
                 mClusters[CL_physics]->Fill(0.f, 1.f);
               }
             }
@@ -1603,10 +1601,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             mClusters[CL_att_adj]->Fill(pt, 1.f);
             mClusters[CL_tracks]->Fill(pt, 1.f);
             mClusters[CL_all]->Fill(pt, 1.f);
-            if (protect || physics) {
+            if (r.protect || r.physics) {
               mClusters[CL_prot]->Fill(pt, 1.f);
             }
-            if (physics) {
+            if (r.physics) {
               mClusters[CL_physics]->Fill(pt, 1.f);
             }
           }
@@ -1637,10 +1635,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
                   mClusters[CL_tracks]->Fill(pt, weight);
                 }
                 mClusters[CL_all]->Fill(pt, weight);
-                if (protect || physics) {
+                if (r.protect || r.physics) {
                   mClusters[CL_prot]->Fill(pt, weight);
                 }
-                if (physics) {
+                if (r.physics) {
                   mClusters[CL_physics]->Fill(pt, weight);
                 }
               }
@@ -1654,10 +1652,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             }
             mClusters[CL_all]->Fill(0.f, 1.f);
             mClusterCounts.nUnaccessible++;
-            if (protect || physics) {
+            if (r.protect || r.physics) {
               mClusters[CL_prot]->Fill(0.f, 1.f);
             }
-            if (physics) {
+            if (r.physics) {
               mClusters[CL_physics]->Fill(0.f, 1.f);
             }
           }
@@ -1772,7 +1770,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
   if (mQATasks & taskClusterCounts) {
     for (uint32_t i = 0; i < nCl; i++) {
       int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
-      CHECK_CLUSTER_STATE();
+      const auto& r = checkClusterState<true>(attach, &mClusterCounts);
 
       if (mcAvail) {
         float totalWeight = 0, weight400 = 0, weight40 = 0;
@@ -1789,7 +1787,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           }
         }
         if (totalWeight > 0 && 10.f * weight400 >= totalWeight) {
-          if (!unattached && !protect && !physics) {
+          if (!r.unattached && !r.protect && !r.physics) {
             mClusterCounts.nFakeRemove400++;
             int32_t totalFake = weight400 < 0.9f * totalWeight;
             if (totalFake) {
@@ -1812,18 +1810,19 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
         if (totalWeight > 0 && weight40 >= 0.9 * totalWeight) {
           mClusterCounts.nBelow40++;
-          if (protect || physics) {
+          if (r.protect || r.physics) {
             mClusterCounts.nFakeProtect40++;
           }
         }
       }
-      if (physics) {
+
+      if (r.physics) {
         mClusterCounts.nPhysics++;
       }
-      if (physics || protect) {
+      if (r.protect) {
         mClusterCounts.nProt++;
       }
-      if (unattached) {
+      if (r.unattached) {
         mClusterCounts.nUnattached++;
       }
     }
@@ -3010,7 +3009,7 @@ int32_t GPUQA::DoClusterCounts(uint64_t* attachClusterCounts, int32_t mode)
 {
   int32_t num = 0;
   if (mcPresent() && (mQATasks & taskClusterAttach) && attachClusterCounts) {
-    for (int32_t i = 0; i < N_CLS_HIST; i++) {
+    for (int32_t i = 0; i < N_CLS_HIST; i++) { // TODO: Check that these counts are still printed correctly!
       PrintClusterCount(mode, num, CLUSTER_NAMES[i], attachClusterCounts[i], mClusterCounts.nTotal);
     }
     PrintClusterCount(mode, num, "Unattached", attachClusterCounts[N_CLS_HIST - 1] - attachClusterCounts[CL_att_adj], mClusterCounts.nTotal);
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index fcfe1aea8b04f..9ab9b0deaaf61 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -86,6 +86,7 @@ namespace o2::gpu
 class GPUChainTracking;
 struct GPUParam;
 struct GPUTPCMCInfo;
+struct checkClusterStateResult;
 namespace internal
 {
 struct GPUQAGarbageCollection;
@@ -230,6 +231,9 @@ class GPUQA
   const auto& GetClusterLabels();
   bool mcPresent();
 
+  template <bool COUNT = false, class T = void>
+  checkClusterStateResult checkClusterState(uint32_t attach, T* counts = nullptr) const;
+
   GPUChainTracking* mTracking;
   const GPUSettingsQA& mConfig;
   const GPUParam* mParam;

From 78fae93b30d4629de5e3ef02622d95fe9dcd5958 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 8 Nov 2025 09:55:07 +0100
Subject: [PATCH 1012/1764] GPU Standalone: Improve QA features in syncAsync
 mode

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h  |  1 +
 .../Standalone/Benchmark/standalone.cxx        | 18 +++++++++++++-----
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index f8845f82ee1e2..2f1eb72cb3d00 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -596,6 +596,7 @@ AddOption(stripDumpedEvents, bool, false, "", 0, "Remove redundant inputs (e.g.
 AddOption(printSettings, int32_t, 0, "", 0, "Print all settings", def(1))
 AddOption(testSyncAsync, bool, false, "syncAsync", 0, "Test first synchronous and then asynchronous processing")
 AddOption(testSync, bool, false, "sync", 0, "Test settings for synchronous phase")
+AddOption(testSyncAsyncQcInSync, bool, false, "syncAsyncSyncQC", 0, "Run QC in sync phase of testSyncAsync")
 AddOption(timeFrameTime, bool, false, "tfTime", 0, "Print some debug information about time frame processing time")
 AddOption(controlProfiler, bool, false, "", 0, "Issues GPU profiler stop and start commands to profile only the relevant processing part")
 AddOption(preloadEvents, bool, false, "", 0, "Preload events into host memory before start processing")
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 6b0637c76d857..b0ea1f5b7dbcb 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -72,6 +72,7 @@ extern GPUSettingsStandalone configStandalone;
 }
 
 GPUReconstruction *rec, *recAsync, *recPipeline;
+uint32_t syncAsyncDecodedClusters = 0;
 GPUChainTracking *chainTracking, *chainTrackingAsync, *chainTrackingPipeline;
 GPUChainITS *chainITS, *chainITSAsync, *chainITSPipeline;
 std::string eventsDir;
@@ -430,7 +431,7 @@ int32_t SetupReconstruction()
     }
   }
 
-  bool runAsyncQA = procSet.runQA;
+  bool runAsyncQA = procSet.runQA && !configStandalone.testSyncAsyncQcInSync;
   if (configStandalone.testSyncAsync || configStandalone.testSync) {
     // Set settings for synchronous
     if (configStandalone.rundEdx == -1) {
@@ -439,7 +440,9 @@ int32_t SetupReconstruction()
     recSet.useMatLUT = false;
     if (configStandalone.testSyncAsync) {
       procSet.eventDisplay = nullptr;
-      procSet.runQA = false;
+      if (!configStandalone.testSyncAsyncQcInSync) {
+        procSet.runQA = false;
+      }
     }
   }
   if (configStandalone.proc.rtc.optSpecialCode == -1) {
@@ -664,12 +667,12 @@ int32_t RunBenchmark(GPUReconstruction* recUse, GPUChainTracking* chainTrackingU
     }
 
     if (tmpRetVal == 0 && configStandalone.testSyncAsync) {
-      if (configStandalone.testSyncAsync) {
-        printf("Running asynchronous phase\n");
-      }
 
       vecpod<char> compressedTmpMem(chainTracking->mIOPtrs.tpcCompressedClusters->totalDataSize);
       memcpy(compressedTmpMem.data(), (const void*)chainTracking->mIOPtrs.tpcCompressedClusters, chainTracking->mIOPtrs.tpcCompressedClusters->totalDataSize);
+      o2::tpc::CompressedClusters tmp(*chainTracking->mIOPtrs.tpcCompressedClusters);
+      syncAsyncDecodedClusters = tmp.nAttachedClusters + tmp.nUnattachedClusters;
+      printf("Running asynchronous phase from %'u compressed clusters\n", syncAsyncDecodedClusters);
 
       chainTrackingAsync->mIOPtrs = ioPtrs;
       chainTrackingAsync->mIOPtrs.tpcCompressedClusters = (o2::tpc::CompressedClustersFlat*)compressedTmpMem.data();
@@ -937,6 +940,11 @@ int32_t main(int argc, char** argv)
           printf("%s (Measured %s time - Extrapolated from %d clusters to %d)\n", stat, configStandalone.proc.debugLevel ? "kernel" : "wall", (int32_t)nClusters, (int32_t)nClsPerTF);
         }
       }
+      if (configStandalone.testSyncAsync && chainTracking->mIOPtrs.clustersNative && chainTrackingAsync->mIOPtrs.clustersNative) {
+        uint32_t rejected = chainTracking->mIOPtrs.clustersNative->nClustersTotal - syncAsyncDecodedClusters;
+        float rejectionPercentage = (rejected) * 100.f / chainTracking->mIOPtrs.clustersNative->nClustersTotal;
+        printf("Cluster Rejection: Sync: %'u, Compressed %'u, Async %'u, Rejected %'u (%7.2f%%)\n", chainTracking->mIOPtrs.clustersNative->nClustersTotal, syncAsyncDecodedClusters, chainTrackingAsync->mIOPtrs.clustersNative->nClustersTotal, rejected, rejectionPercentage);
+      }
 
       if (configStandalone.preloadEvents && configStandalone.proc.doublePipeline) {
         break;

From 5b829b288bc2a8d8ade3ccdbcb4de537943d5d5c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 8 Nov 2025 15:20:31 +0100
Subject: [PATCH 1013/1764] GPU QA: Avoid double-use of mEff[3] histogram

---
 GPU/GPUTracking/qa/GPUQA.cxx | 11 +++++++----
 GPU/GPUTracking/qa/GPUQA.h   |  2 +-
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index d5ed7e45835eb..0b668b617734d 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -157,7 +157,7 @@ static constexpr bool CLUST_HIST_INT_SUM = false;
 
 static constexpr const int32_t COLORCOUNT = 12;
 
-static const constexpr char* EFF_TYPES[5] = {"Rec", "Clone", "Fake", "All", "RecAndClone"};
+static const constexpr char* EFF_TYPES[6] = {"Rec", "Clone", "Fake", "All", "RecAndClone", "MC"};
 static const constexpr char* FINDABLE_NAMES[2] = {"All", "Findable"};
 static const constexpr char* PRIM_NAMES[2] = {"Prim", "Sec"};
 static const constexpr char* PARAMETER_NAMES[5] = {"Y", "Z", "#Phi", "#lambda", "Relative #it{p}_{T}"};
@@ -438,7 +438,7 @@ int32_t GPUQA::InitQACreateHistograms()
   char name[2048], fname[1024];
   if (mQATasks & taskTrackingEff) {
     // Create Efficiency Histograms
-    for (int32_t i = 0; i < 5; i++) {
+    for (int32_t i = 0; i < 6; i++) {
       for (int32_t j = 0; j < 2; j++) {
         for (int32_t k = 0; k < 2; k++) {
           for (int32_t l = 0; l < 5; l++) {
@@ -1234,7 +1234,10 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             effdump.Fill(alpha, localX, localY, info.z, mcphi, mceta, mcpt, mRecTracks[iCol][i], mFakeTracks[iCol][i], findable, info.prim, mc2.nWeightCls);
           }
 
-          for (int32_t j = 0; j < 4; j++) {
+          for (int32_t j = 0; j < 6; j++) {
+            if (j == 3 || j == 4) {
+              continue;
+            }
             for (int32_t k = 0; k < 2; k++) {
               if (k == 0 && findable == 0) {
                 continue;
@@ -2242,7 +2245,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
                 // Divide eff, compute all for fake/clone
                 auto oldLevel = gErrorIgnoreLevel;
                 gErrorIgnoreLevel = kError;
-                mEffResult[0][j / 2][j % 2][i]->Divide(mEff[l][j / 2][j % 2][i], mEff[3][j / 2][j % 2][i], "cl=0.683 b(1,1) mode");
+                mEffResult[0][j / 2][j % 2][i]->Divide(mEff[l][j / 2][j % 2][i], mEff[5][j / 2][j % 2][i], "cl=0.683 b(1,1) mode");
                 gErrorIgnoreLevel = oldLevel;
                 mEff[3][j / 2][j % 2][i]->Reset(); // Sum up rec + clone + fake for fake rate
                 mEff[3][j / 2][j % 2][i]->Add(mEff[0][j / 2][j % 2][i]);
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 9ab9b0deaaf61..f862b49a5ca4a 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -260,7 +260,7 @@ class GPUQA
   std::vector<additionalClusterParameters> mClusterParam;
   int32_t mNTotalFakes = 0;
 
-  TH1F* mEff[5][2][2][5]; // eff,clone,fake,all,all-fake - findable - secondaries - y,z,phi,eta,pt - work,result
+  TH1F* mEff[6][2][2][5]; // eff,clone,fake,all,all-fake - findable - secondaries - y,z,phi,eta,pt - work,result
   TGraphAsymmErrors* mEffResult[4][2][2][5];
   TCanvas* mCEff[6];
   TPad* mPEff[6][4];

From c546419647217ff5bbedd2430e1aba3e7ec7ff03 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 8 Nov 2025 16:02:40 +0100
Subject: [PATCH 1014/1764] GPU QA: Add cluster rejection histograms

---
 GPU/GPUTracking/qa/GPUQA.cxx | 184 +++++++++++++++++++++++++----------
 GPU/GPUTracking/qa/GPUQA.h   |   7 ++
 2 files changed, 142 insertions(+), 49 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 0b668b617734d..8d608e9a90173 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -537,6 +537,12 @@ int32_t GPUQA::InitQACreateHistograms()
     createHist(mT0[0], "tracks_t0", "tracks_t0", (maxTime + 1) / 10, 0, maxTime);
     createHist(mT0[1], "tracks_t0_res", "tracks_t0_res", 1000, -100, 100);
     createHist(mClXY, "clXY", "clXY", 1000, -250, 250, 1000, -250, 250); // TODO: Pass name only once
+    const int padCount = GPUTPCGeometry::NPads(GPUCA_ROW_COUNT - 1);
+    for (int32_t i = 0; i < 3; i++) {
+      snprintf(name, 2048, "clrej_%d", i);
+      createHist(mClRej[i], name, name, 2 * padCount, -padCount / 2 + 0.5f, padCount / 2 - 0.5f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
+    }
+    createHist(mClRejP, "clrejp", "clrejp", GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
   }
 
   if ((mQATasks & taskClusterCounts) && mConfig.clusterRejectionHistograms) {
@@ -1771,63 +1777,75 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
   uint32_t nCl = clNative ? clNative->nClustersTotal : mTracking->GetProcessors()->tpcMerger.NMaxClusters();
   mClusterCounts.nTotal += nCl;
   if (mQATasks & taskClusterCounts) {
-    for (uint32_t i = 0; i < nCl; i++) {
-      int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
-      const auto& r = checkClusterState<true>(attach, &mClusterCounts);
+    for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
+      for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+        for (uint32_t iCl = 0; iCl < mTracking->mIOPtrs.clustersNative->nClusters[iSector][iRow]; iCl++) {
+          uint32_t i = mTracking->mIOPtrs.clustersNative->clusterOffset[iSector][iRow] + iCl;
+          int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
+          const auto& r = checkClusterState<true>(attach, &mClusterCounts);
 
-      if (mcAvail) {
-        float totalWeight = 0, weight400 = 0, weight40 = 0;
-        for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
-          const auto& label = GetMCLabel(i, j);
-          if (GetMCLabelID(label) >= 0) {
-            totalWeight += GetMCLabelWeight(label);
-            if (GetMCTrackObj(mMCParam, label).pt >= 0.4) {
-              weight400 += GetMCLabelWeight(label);
-            }
-            if (GetMCTrackObj(mMCParam, label).pt <= 0.04) {
-              weight40 += GetMCLabelWeight(label);
+          if (mcAvail) {
+            float totalWeight = 0, weight400 = 0, weight40 = 0;
+            for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
+              const auto& label = GetMCLabel(i, j);
+              if (GetMCLabelID(label) >= 0) {
+                totalWeight += GetMCLabelWeight(label);
+                if (GetMCTrackObj(mMCParam, label).pt >= 0.4) {
+                  weight400 += GetMCLabelWeight(label);
+                }
+                if (GetMCTrackObj(mMCParam, label).pt <= 0.04) {
+                  weight40 += GetMCLabelWeight(label);
+                }
+              }
             }
-          }
-        }
-        if (totalWeight > 0 && 10.f * weight400 >= totalWeight) {
-          if (!r.unattached && !r.protect && !r.physics) {
-            mClusterCounts.nFakeRemove400++;
-            int32_t totalFake = weight400 < 0.9f * totalWeight;
-            if (totalFake) {
-              mClusterCounts.nFullFakeRemove400++;
+            if (totalWeight > 0 && 10.f * weight400 >= totalWeight) {
+              if (!r.unattached && !r.protect && !r.physics) {
+                mClusterCounts.nFakeRemove400++;
+                int32_t totalFake = weight400 < 0.9f * totalWeight;
+                if (totalFake) {
+                  mClusterCounts.nFullFakeRemove400++;
+                }
+                /*printf("Fake removal (%d): Hit %7d, attached %d lowPt %d looper %d tube200 %d highIncl %d tube %d bad %d recPt %7.2f recLabel %6d", totalFake, i, (int32_t) (mClusterParam[i].attached || mClusterParam[i].fakeAttached),
+                    (int32_t) lowPt, (int32_t) ((attach & gputpcgmmergertypes::attachGoodLeg) == 0), (int32_t) ((attach & gputpcgmmergertypes::attachTube) && mev200),
+                    (int32_t) ((attach & gputpcgmmergertypes::attachHighIncl) != 0), (int32_t) ((attach & gputpcgmmergertypes::attachTube) != 0), (int32_t) ((attach & gputpcgmmergertypes::attachGood) == 0),
+                    fabsf(qpt) > 0 ? 1.f / qpt : 0.f, id);
+                for (int32_t j = 0;j < GetMCLabelNID(i);j++)
+                {
+                    //if (GetMCLabelID(i, j) < 0) break;
+                    printf(" - label%d %6d weight %5d", j, GetMCLabelID(i, j), (int32_t) GetMCLabelWeight(i, j));
+                    if (GetMCLabelID(i, j) >= 0) printf(" - pt %7.2f", mMCParam[GetMCLabelID(i, j)].pt);
+                    else printf("             ");
+                }
+                printf("\n");*/
+              }
+              mClusterCounts.nAbove400++;
             }
-            /*printf("Fake removal (%d): Hit %7d, attached %d lowPt %d looper %d tube200 %d highIncl %d tube %d bad %d recPt %7.2f recLabel %6d", totalFake, i, (int32_t) (mClusterParam[i].attached || mClusterParam[i].fakeAttached),
-                (int32_t) lowPt, (int32_t) ((attach & gputpcgmmergertypes::attachGoodLeg) == 0), (int32_t) ((attach & gputpcgmmergertypes::attachTube) && mev200),
-                (int32_t) ((attach & gputpcgmmergertypes::attachHighIncl) != 0), (int32_t) ((attach & gputpcgmmergertypes::attachTube) != 0), (int32_t) ((attach & gputpcgmmergertypes::attachGood) == 0),
-                fabsf(qpt) > 0 ? 1.f / qpt : 0.f, id);
-            for (int32_t j = 0;j < GetMCLabelNID(i);j++)
-            {
-                //if (GetMCLabelID(i, j) < 0) break;
-                printf(" - label%d %6d weight %5d", j, GetMCLabelID(i, j), (int32_t) GetMCLabelWeight(i, j));
-                if (GetMCLabelID(i, j) >= 0) printf(" - pt %7.2f", mMCParam[GetMCLabelID(i, j)].pt);
-                else printf("             ");
+            if (totalWeight > 0 && weight40 >= 0.9 * totalWeight) {
+              mClusterCounts.nBelow40++;
+              if (r.protect || r.physics) {
+                mClusterCounts.nFakeProtect40++;
+              }
             }
-            printf("\n");*/
           }
-          mClusterCounts.nAbove400++;
-        }
-        if (totalWeight > 0 && weight40 >= 0.9 * totalWeight) {
-          mClusterCounts.nBelow40++;
-          if (r.protect || r.physics) {
-            mClusterCounts.nFakeProtect40++;
+
+          if (r.physics) {
+            mClusterCounts.nPhysics++;
+          }
+          if (r.protect) {
+            mClusterCounts.nProt++;
+          }
+          if (r.unattached) {
+            mClusterCounts.nUnattached++;
+          }
+          if (mTracking && mTracking->mIOPtrs.clustersNative) {
+            const auto& cl = mTracking->mIOPtrs.clustersNative->clustersLinear[i];
+            mClRej[0]->Fill(cl.getPad() - GPUTPCGeometry::NPads(iRow) / 2 + 0.5, iRow, 1.f);
+            if (!r.unattached && !r.protect) {
+              mClRej[1]->Fill(cl.getPad() - GPUTPCGeometry::NPads(iRow) / 2 + 0.5, iRow, 1.f);
+            }
           }
         }
       }
-
-      if (r.physics) {
-        mClusterCounts.nPhysics++;
-      }
-      if (r.protect) {
-        mClusterCounts.nProt++;
-      }
-      if (r.unattached) {
-        mClusterCounts.nUnattached++;
-      }
     }
   }
 
@@ -2215,6 +2233,18 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mCClXY->cd();
       mPClXY = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPClXY->Draw();
+
+      for (int32_t i = 0; i < 3; i++) {
+        snprintf(name, 2048, "cnclrej%d", i);
+        mCClRej[i] = createGarbageCollected<TCanvas>(name, i == 0 ? "Number of clusters" : (i == 1 ? "Rejected Clusters" : "Fraction of Rejected Clusters"), 0, 0, 700, 700. * 2. / 3.);
+        mCClRej[i]->cd();
+        mPClRej[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
+        mPClRej[i]->Draw();
+      }
+      mCClRejP = createGarbageCollected<TCanvas>("cnclrejp", "Fraction of Rejected Clusters", 0, 0, 700, 700. * 2. / 3.);
+      mCClRejP->cd();
+      mPClRejP = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
+      mPClRejP->Draw();
     }
   }
 
@@ -2955,6 +2985,62 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     if (mConfig.writeRootFiles) {
       mCClXY->Print("plots/clustersXY.root");
     }
+
+    if (mQATasks & taskClusterCounts) {
+      mClRej[2]->Divide(mClRej[1], mClRej[0]);
+
+      for (int32_t i = 0; i < 3; i++) {
+        if (tout && !mConfig.inputHistogramsOnly) {
+          mClRej[i]->Write();
+        }
+        mPClRej[i]->cd();
+        mClRej[i]->SetOption("colz");
+        mClRej[i]->Draw();
+        mCClRej[i]->cd();
+        snprintf(name, 2048, "plots/clustersRej%d.pdf", i);
+        mCClRej[i]->Print(name);
+        if (mConfig.writeRootFiles) {
+          snprintf(name, 2048, "plots/clustersRej%d.root", i);
+          mCClRej[i]->Print(name);
+        }
+      }
+
+      mPClRejP->cd();
+      for (int32_t k = 0; k < ConfigNumInputs; k++) {
+        auto* tmp = mClRej[0];
+        if (GetHist(tmp, tin, k, nNewInput) == nullptr) {
+          continue;
+        }
+        snprintf(name, 2048, "clrejptmp1%d", k); // TODO: Clean up names, and how names are written to char arrays
+        TH1D* proj1 = tmp->ProjectionY(name);
+        proj1->SetDirectory(nullptr);
+        tmp = mClRej[1];
+        if (GetHist(tmp, tin, k, nNewInput) == nullptr) {
+          continue;
+        }
+        snprintf(name, 2048, "clrejptmp2%d", k); // TODO: Clean up names, and how names are written to char arrays
+        TH1D* proj2 = tmp->ProjectionY(name);
+        proj2->SetDirectory(nullptr);
+
+        auto* e = mClRejP;
+        if (GetHist(e, tin, k, nNewInput) == nullptr) {
+          continue;
+        }
+        e->Divide(proj2, proj1);
+        if (tout && !mConfig.inputHistogramsOnly && k == 0) {
+          e->Write();
+        }
+        delete proj1;
+        delete proj2;
+        e->SetMinimum(-0.02);
+        e->SetMaximum(0.22);
+        e->Draw(k == 0 ? "" : "same");
+      }
+      mPClRejP->Print("plots/clustersRejP.pdf"); // TODO: Add option to write pngs
+      if (mConfig.writeRootFiles) {
+        mPClRejP->Print("plots/clustersRejP.root");
+      }
+    }
   }
 
   if (tout && !mConfig.inputHistogramsOnly && mConfig.writeMCLabels) {
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index f862b49a5ca4a..dfa644a67e9e0 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -316,6 +316,13 @@ class GPUQA
   TCanvas* mCClXY;
   TPad* mPClXY;
 
+  TH2F* mClRej[3];
+  TH1D* mClRejP;
+  TCanvas* mCClRej[3];
+  TCanvas* mCClRejP;
+  TPad* mPClRej[3];
+  TPad* mPClRejP;
+
   std::vector<TH2F*> mHistClusterCount;
 
   std::vector<TH1F>* mHist1D = nullptr;

From e049e58ffb595b8a5eb83a819f4cb2183033c93b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 10 Nov 2025 17:30:28 +0100
Subject: [PATCH 1015/1764] DPL: fix wrong log level

---
 Framework/Core/src/CommonDataProcessors.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/CommonDataProcessors.cxx b/Framework/Core/src/CommonDataProcessors.cxx
index 4d82cb7124e64..4b5f317f58063 100644
--- a/Framework/Core/src/CommonDataProcessors.cxx
+++ b/Framework/Core/src/CommonDataProcessors.cxx
@@ -240,7 +240,7 @@ DataProcessorSpec CommonDataProcessors::getScheduledDummySink(std::vector<InputS
       // this information will be aggregated in the driver which will then decide wether or not a new offer for
       // a timeslice should be done and to which device
       auto domainInfoUpdated = [](ServiceRegistryRef services, size_t timeslice, ChannelIndex channelIndex) {
-        LOGP(info, "Domain info updated with timeslice {}", timeslice);
+        LOGP(debug, "Domain info updated with timeslice {}", timeslice);
         auto& timesliceIndex = services.get<TimesliceIndex>();
         auto oldestPossingTimeslice = timesliceIndex.getOldestPossibleOutput().timeslice.value;
         auto& stats = services.get<DataProcessingStats>();

From c324ffb9e65775c8369837dbc8ee9ddcef8a9701 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 10 Nov 2025 17:18:41 +0100
Subject: [PATCH 1016/1764] DPL: reduce chances to drop offers

Workaround. Proper fix coming.
---
 Framework/Core/include/Framework/ComputingQuotaEvaluator.h | 2 +-
 Framework/Core/include/Framework/ComputingQuotaOffer.h     | 2 +-
 Framework/Core/src/DataProcessor.cxx                       | 2 +-
 Framework/Core/test/test_ComputingQuotaEvaluator.cxx       | 4 ++--
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Framework/Core/include/Framework/ComputingQuotaEvaluator.h b/Framework/Core/include/Framework/ComputingQuotaEvaluator.h
index aee2e50c90e7f..17ce9c2ba3e65 100644
--- a/Framework/Core/include/Framework/ComputingQuotaEvaluator.h
+++ b/Framework/Core/include/Framework/ComputingQuotaEvaluator.h
@@ -32,7 +32,7 @@ class ComputingQuotaEvaluator
 {
  public:
   // Maximum number of offers this evaluator can hold
-  static constexpr int MAX_INFLIGHT_OFFERS = 16;
+  static constexpr int MAX_INFLIGHT_OFFERS = 32;
   ComputingQuotaEvaluator(ServiceRegistryRef ref);
   /// @a task the task which needs some quota
   /// @a request the resource request the @a task needs
diff --git a/Framework/Core/include/Framework/ComputingQuotaOffer.h b/Framework/Core/include/Framework/ComputingQuotaOffer.h
index b7707613bc19d..8d4420e7af2f5 100644
--- a/Framework/Core/include/Framework/ComputingQuotaOffer.h
+++ b/Framework/Core/include/Framework/ComputingQuotaOffer.h
@@ -84,7 +84,7 @@ using ComputingQuotaRequest = std::function<OfferScore(ComputingQuotaOffer const
 
 /// A consumer is a function which updates a given function removing the
 /// amount of resources which are considered as consumed.
-using ComputingQuotaConsumer = std::function<void(int id, std::array<ComputingQuotaOffer, 16>&, ComputingQuotaStats&, std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats& stats)>)>;
+using ComputingQuotaConsumer = std::function<void(int id, std::array<ComputingQuotaOffer, 32>&, ComputingQuotaStats&, std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats& stats)>)>;
 
 } // namespace o2::framework
 
diff --git a/Framework/Core/src/DataProcessor.cxx b/Framework/Core/src/DataProcessor.cxx
index e9938a304b8a6..aef2455c8eb9d 100644
--- a/Framework/Core/src/DataProcessor.cxx
+++ b/Framework/Core/src/DataProcessor.cxx
@@ -123,7 +123,7 @@ void DataProcessor::doSend(DataSender& sender, ArrowContext& context, ServiceReg
   }
   static int64_t previousBytesSent = 0;
   auto disposeResources = [bs = context.bytesSent() - previousBytesSent](int taskId,
-                                                                         std::array<ComputingQuotaOffer, 16>& offers,
+                                                                         std::array<ComputingQuotaOffer, 32>& offers,
                                                                          ComputingQuotaStats& stats,
                                                                          std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats&)> accountDisposed) {
     ComputingQuotaOffer disposed;
diff --git a/Framework/Core/test/test_ComputingQuotaEvaluator.cxx b/Framework/Core/test/test_ComputingQuotaEvaluator.cxx
index 0df58ae7fed08..afd252ec169d4 100644
--- a/Framework/Core/test/test_ComputingQuotaEvaluator.cxx
+++ b/Framework/Core/test/test_ComputingQuotaEvaluator.cxx
@@ -28,7 +28,7 @@ TEST_CASE("TestComputingQuotaEvaluator")
   };
 
   ComputingQuotaConsumer dispose2MB = [bs = 2000000](int taskId,
-                                                     std::array<ComputingQuotaOffer, 16>& offers,
+                                                     std::array<ComputingQuotaOffer, 32>& offers,
                                                      ComputingQuotaStats& stats,
                                                      std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats&)> accountDisposed) {
     ComputingQuotaOffer disposed;
@@ -51,7 +51,7 @@ TEST_CASE("TestComputingQuotaEvaluator")
   };
 
   ComputingQuotaConsumer dispose10MB = [bs = 10000000](int taskId,
-                                                       std::array<ComputingQuotaOffer, 16>& offers,
+                                                       std::array<ComputingQuotaOffer, 32>& offers,
                                                        ComputingQuotaStats& stats,
                                                        std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats&)> accountDisposed) {
     ComputingQuotaOffer disposed;

From 554b906c3ec6def8b08d4235c61e09cb3f7e5f70 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 8 Nov 2025 23:03:04 +0100
Subject: [PATCH 1017/1764] GPU QA: Add firstPadRow QA

---
 GPU/GPUTracking/qa/GPUQA.cxx | 94 +++++++++++++++++++++++++++++-------
 GPU/GPUTracking/qa/GPUQA.h   |  4 ++
 2 files changed, 80 insertions(+), 18 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 8d608e9a90173..5fd1c259393bb 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -523,6 +523,9 @@ int32_t GPUQA::InitQACreateHistograms()
       std::unique_ptr<double[]> binsPt{CreateLogAxis(AXIS_BINS[4], PT_MIN_CLUST, PT_MAX)};
       createHist(mClusters[i], name, name, AXIS_BINS[4], binsPt.get());
     }
+
+    createHist(mPadRow[0], "padrow0", "padrow0", GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
+    createHist(mPadRow[1], "padrow0", "padrow0", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
   }
 
   if (mQATasks & taskTrackStatistics) {
@@ -537,6 +540,7 @@ int32_t GPUQA::InitQACreateHistograms()
     createHist(mT0[0], "tracks_t0", "tracks_t0", (maxTime + 1) / 10, 0, maxTime);
     createHist(mT0[1], "tracks_t0_res", "tracks_t0_res", 1000, -100, 100);
     createHist(mClXY, "clXY", "clXY", 1000, -250, 250, 1000, -250, 250); // TODO: Pass name only once
+
     const int padCount = GPUTPCGeometry::NPads(GPUCA_ROW_COUNT - 1);
     for (int32_t i = 0; i < 3; i++) {
       snprintf(name, 2048, "clrej_%d", i);
@@ -1063,29 +1067,56 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
     }
-    if ((mQATasks & taskClusterAttach) && mTracking->mIOPtrs.mergedTrackHitAttachment) {
+    if ((mQATasks & taskClusterAttach)) {
+      std::vector<uint8_t> lowestPadRow(mTracking->mIOPtrs.nMergedTracks);
       // fill cluster adjacent status
-      for (uint32_t i = 0; i < GetNMCLabels(); i++) {
-        if (mClusterParam[i].attached == 0 && mClusterParam[i].fakeAttached == 0) {
-          int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
-          if (attach & gputpcgmmergertypes::attachFlagMask) {
-            int32_t track = attach & gputpcgmmergertypes::attachTrackMask;
-            mcLabelI_t trackL = mTrackMCLabels[track];
-            bool fake = true;
-            for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
-              // GPUInfo("Attach %x Track %d / %d:%d", attach, track, j, GetMCLabelID(i, j));
-              if (trackL == GetMCLabel(i, j)) {
-                fake = false;
-                break;
+      if (mTracking->mIOPtrs.mergedTrackHitAttachment) {
+        for (uint32_t i = 0; i < GetNMCLabels(); i++) {
+          if (mClusterParam[i].attached == 0 && mClusterParam[i].fakeAttached == 0) {
+            int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
+            if (attach & gputpcgmmergertypes::attachFlagMask) {
+              int32_t track = attach & gputpcgmmergertypes::attachTrackMask;
+              mcLabelI_t trackL = mTrackMCLabels[track];
+              bool fake = true;
+              for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
+                // GPUInfo("Attach %x Track %d / %d:%d", attach, track, j, GetMCLabelID(i, j));
+                if (trackL == GetMCLabel(i, j)) {
+                  fake = false;
+                  break;
+                }
+              }
+              if (fake) {
+                mClusterParam[i].fakeAdjacent++;
+              } else {
+                mClusterParam[i].adjacent++;
               }
             }
-            if (fake) {
-              mClusterParam[i].fakeAdjacent++;
-            } else {
-              mClusterParam[i].adjacent++;
+          }
+        }
+      }
+      if (mTracking->mIOPtrs.nMergedTracks && mTracking->mIOPtrs.clustersNative) {
+        std::fill(lowestPadRow.begin(), lowestPadRow.end(), 255);
+        for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
+          for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+            for (uint32_t iCl = 0; iCl < mTracking->mIOPtrs.clustersNative->nClusters[iSector][iRow]; iCl++) {
+              int32_t i = mTracking->mIOPtrs.clustersNative->clusterOffset[iSector][iRow] + iCl;
+              for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
+                uint32_t trackId = GetMCTrackObj(mTrackMCLabelsReverse, GetMCLabel(i, j));
+                if (trackId < lowestPadRow.size() && lowestPadRow[trackId] > iRow) {
+                  lowestPadRow[trackId] = iRow;
+                }
+              }
             }
           }
         }
+        for (uint32_t i = 0; i < mTracking->mIOPtrs.nMergedTracks; i++) {
+          const auto& trk = mTracking->mIOPtrs.mergedTracks[i];
+          if (trk.OK() && lowestPadRow[i] != 255 && trk.NClustersFitted() > 70 && CAMath::Abs(trk.GetParam().GetQPt()) < 0.5) {
+            int32_t lowestRow = CAMath::Min(mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef()].row, mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef() + trk.NClusters() - 1].row);
+            mPadRow[0]->Fill((float)lowestPadRow[i], (float)lowestRow, 1.f);
+            mPadRow[1]->Fill(CAMath::ATan2(trk.GetParam().GetY(), trk.GetParam().GetX()), lowestRow, 1.f);
+          }
+        }
       }
     }
 
@@ -1677,7 +1708,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     }
   } else if (!mConfig.inputHistogramsOnly && !mConfig.noMC && (mQATasks & (taskTrackingEff | taskTrackingRes | taskTrackingResPull | taskClusterAttach))) {
     GPUWarning("No MC information available, only running partial TPC QA!");
-  }
+  } // mcAvail
 
   if (mQATasks & taskTrackStatistics) {
     // Fill track statistic histograms
@@ -2245,6 +2276,14 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mCClRejP->cd();
       mPClRejP = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPClRejP->Draw();
+
+      for (int32_t i = 0; i < 2; i++) {
+        snprintf(name, 2048, "cpadrow%d", i);
+        mCPadRow[i] = createGarbageCollected<TCanvas>(name, "First Track Pad Row", 0, 0, 700, 700. * 2. / 3.);
+        mCPadRow[i]->cd();
+        mPPadRow[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
+        mPPadRow[i]->Draw();
+      }
     }
   }
 
@@ -2816,6 +2855,25 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         mCClust[i]->Print(i == 2 ? "plots/clusters_integral.root" : i == 1 ? "plots/clusters_relative.root" : "plots/clusters.root");
       }
     }
+
+    for (int32_t i = 0; i < 2; i++) {
+      auto* e = mPadRow[i];
+      if (tout && !mConfig.inputHistogramsOnly) {
+        e->Write();
+      }
+      mPPadRow[i]->cd();
+      e->SetOption("colz");
+      e->GetXaxis()->SetTitle("First MC Pad Row");
+      e->GetYaxis()->SetTitle("First Pad Row");
+      e->Draw();
+      mCPadRow[i]->cd();
+      snprintf(name, 2048, "plots/padrow%d.pdf", i);
+      mCPadRow[i]->Print(name);
+      if (mConfig.writeRootFiles) {
+        snprintf(name, 2048, "plots/padrow%d.root", i);
+        mCPadRow[i]->Print(name);
+      }
+    }
   }
 
   // Process cluster count statistics
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index dfa644a67e9e0..f6225c2d38276 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -323,6 +323,10 @@ class GPUQA
   TPad* mPClRej[3];
   TPad* mPClRejP;
 
+  TH2F* mPadRow[2];
+  TCanvas* mCPadRow[2];
+  TPad* mPPadRow[2];
+
   std::vector<TH2F*> mHistClusterCount;
 
   std::vector<TH1F>* mHist1D = nullptr;

From e4df51f518d6567d55460d79825917b1073d7872 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 11 Nov 2025 18:09:08 +0100
Subject: [PATCH 1018/1764] DPL: properly handle excess of offers

---
 .../Core/src/ComputingQuotaEvaluator.cxx      | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/ComputingQuotaEvaluator.cxx b/Framework/Core/src/ComputingQuotaEvaluator.cxx
index aa566ccb4d549..85a5e6be467a7 100644
--- a/Framework/Core/src/ComputingQuotaEvaluator.cxx
+++ b/Framework/Core/src/ComputingQuotaEvaluator.cxx
@@ -247,6 +247,7 @@ void ComputingQuotaEvaluator::updateOffers(std::vector<ComputingQuotaOffer>& pen
 {
   O2_SIGNPOST_ID_GENERATE(oid, quota);
   O2_SIGNPOST_START(quota, oid, "updateOffers", "Starting to processe received offers");
+  int lastValid = -1;
   for (size_t oi = 0; oi < mOffers.size(); oi++) {
     auto& storeOffer = mOffers[oi];
     auto& info = mInfos[oi];
@@ -256,6 +257,9 @@ void ComputingQuotaEvaluator::updateOffers(std::vector<ComputingQuotaOffer>& pen
     }
     if (storeOffer.valid == true) {
       O2_SIGNPOST_EVENT_EMIT(quota, oid, "updateOffers", "Skipping update of offer %zu because it's still valid", oi);
+      // In general we want to fill an invalid offer. If we do not find any
+      // we add to the last valid offer we found.
+      lastValid = oi;
       continue;
     }
     info.received = now;
@@ -266,7 +270,20 @@ void ComputingQuotaEvaluator::updateOffers(std::vector<ComputingQuotaOffer>& pen
     storeOffer.valid = true;
     pending.pop_back();
   }
-  O2_SIGNPOST_END_WITH_ERROR(quota, oid, "updateOffers", "Some of the pending offers were not treated");
+  if (lastValid == -1) {
+    O2_SIGNPOST_END_WITH_ERROR(quota, oid, "updateOffers", "ComputingQuotaOffer losts. This should never happen.");
+    return;
+  }
+  auto& lastValidOffer = mOffers[lastValid];
+  for (auto& stillPending : pending) {
+    lastValidOffer.cpu += stillPending.cpu;
+    lastValidOffer.memory += stillPending.memory;
+    lastValidOffer.sharedMemory += stillPending.sharedMemory;
+    lastValidOffer.timeslices += stillPending.timeslices;
+    lastValidOffer.runtime = std::max(lastValidOffer.runtime, stillPending.runtime);
+  }
+  pending.clear();
+  O2_SIGNPOST_END(quota, oid, "updateOffers", "Remaining offers cohalesced to %d", lastValid);
 }
 
 void ComputingQuotaEvaluator::handleExpired(std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats const& stats)> expirator)

From de6ae4b08ebd8515aa2724a02b4202e0f1288060 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 12 Nov 2025 10:14:54 +0100
Subject: [PATCH 1019/1764] DPL: signposts for rate limiting callbacks.

---
 Framework/Core/src/CommonDataProcessors.cxx | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/CommonDataProcessors.cxx b/Framework/Core/src/CommonDataProcessors.cxx
index 4b5f317f58063..5d99fd3db7578 100644
--- a/Framework/Core/src/CommonDataProcessors.cxx
+++ b/Framework/Core/src/CommonDataProcessors.cxx
@@ -268,12 +268,16 @@ AlgorithmSpec CommonDataProcessors::wrapWithRateLimiting(AlgorithmSpec spec)
   return PluginManager::wrapAlgorithm(spec, [](AlgorithmSpec::ProcessCallback& original, ProcessingContext& pcx) -> void {
     auto& raw = pcx.services().get<RawDeviceService>();
     static RateLimiter limiter;
+    O2_SIGNPOST_ID_FROM_POINTER(sid, rate_limiting, &pcx);
     auto limit = std::stoi(raw.device()->fConfig->GetValue<std::string>("timeframes-rate-limit"));
-    LOG(detail) << "Rate limiting to " << limit << " timeframes in flight";
+    O2_SIGNPOST_EVENT_EMIT_DETAIL(rate_limiting, sid, "rate limiting callback",
+                                  "Rate limiting to %d timeframes in flight", limit);
     limiter.check(pcx, limit, 2000);
-    LOG(detail) << "Rate limiting passed. Invoking old callback";
+    O2_SIGNPOST_EVENT_EMIT_DETAIL(rate_limiting, sid, "rate limiting callback",
+                                  "Rate limiting passed. Invoking old callback.");
     original(pcx);
-    LOG(detail) << "Rate limited callback done";
+    O2_SIGNPOST_EVENT_EMIT_DETAIL(rate_limiting, sid, "rate limiting callback",
+                                  "Rate limited callback done.");
   });
 }
 

From d6b601b2d41ea0f86a2b7b7bb5cc0eaaba3455cf Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 12 Nov 2025 10:14:54 +0100
Subject: [PATCH 1020/1764] DPL Analysis: improve default value for timeframes
 rate limiting

---
 Framework/Core/src/ArrowSupport.cxx | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 932c1fdacacfb..da00c8db42280 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -33,6 +33,7 @@
 #include "Framework/ServiceRegistryRef.h"
 #include "Framework/ServiceRegistryHelpers.h"
 #include "Framework/Signpost.h"
+#include "Framework/DefaultsHelpers.h"
 
 #include "CommonMessageBackendsHelpers.h"
 #include <Monitoring/Monitoring.h>
@@ -65,7 +66,7 @@ enum struct RateLimitingState {
 
 struct RateLimitConfig {
   int64_t maxMemory = 2000;
-  int64_t maxTimeframes = 1;
+  int64_t maxTimeframes = 1000;
 };
 
 struct MetricIndices {
@@ -524,7 +525,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        if (dc.options.count("timeframes-rate-limit") && dc.options["timeframes-rate-limit"].defaulted() == false) {
                          config->maxTimeframes = std::stoll(dc.options["timeframes-rate-limit"].as<std::string>());
                        } else {
-                         config->maxTimeframes = readers;
+                         config->maxTimeframes = readers * DefaultsHelpers::pipelineLength();
                        }
                        static bool once = false;
                        // Until we guarantee this is called only once...

From 35a94dbc6b0e2d5cb31aeca56a323e132e6926fc Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 12 Nov 2025 14:03:54 +0100
Subject: [PATCH 1021/1764] DPL: fix accounting of consumed timeslices

---
 Framework/Core/src/DataProcessingDevice.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index ff90b93b4d114..42206e160d726 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -250,7 +250,7 @@ void run_completion(uv_work_t* handle, int status)
     stats.totalConsumedTimeslices += accumulatedConsumed.timeslices;
 
     dpStats.updateStats({static_cast<short>(ProcessingStatsId::SHM_OFFER_BYTES_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedBytes});
-    dpStats.updateStats({static_cast<short>(ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedBytes});
+    dpStats.updateStats({static_cast<short>(ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedTimeslices});
     dpStats.processCommandQueue();
     assert(stats.totalConsumedBytes == dpStats.metrics[(short)ProcessingStatsId::SHM_OFFER_BYTES_CONSUMED]);
     assert(stats.totalConsumedTimeslices == dpStats.metrics[(short)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED]);

From 02b8c0dae59a6887a586962063ddcba11ea7100c Mon Sep 17 00:00:00 2001
From: mario6829 <mario6829@gmail.com>
Date: Wed, 12 Nov 2025 14:46:21 +0100
Subject: [PATCH 1022/1764] Improved description of IB FPC capacitors (#14805)

* Improved description of IB FPC capacitors

* Fix clang format
---
 .../include/ITSSimulation/V3Layer.h           | 80 +++++++++--------
 .../ITSMFT/ITS/simulation/src/Detector.cxx    |  3 +-
 .../ITSMFT/ITS/simulation/src/V3Layer.cxx     | 90 +++++++++++++------
 3 files changed, 108 insertions(+), 65 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Layer.h b/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Layer.h
index 15683feac4613..bc4fd6b0dadd4 100644
--- a/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Layer.h
+++ b/Detectors/ITSMFT/ITS/simulation/include/ITSSimulation/V3Layer.h
@@ -353,43 +353,49 @@ class V3Layer : public V11Geometry
   static const Int_t sIBNChipRows;   ///< IB chip rows in module
   static const Double_t sIBChipZGap; ///< Gap between IB chips on Z
 
-  static const Double_t sIBModuleZLength;      ///< IB Module Length along Z
-  static const Double_t sIBFPCWiderXPlus;      ///< FPC protrusion at X>0
-  static const Double_t sIBFPCWiderXNeg;       ///< FPC protrusion at X<0
-  static const Double_t sIBFlexCableAlThick;   ///< Thickness of FPC Aluminum
-  static const Double_t sIBFPCAlGNDWidth;      ///< Width of total FPC Al Gnd
-  static const Double_t sIBFPCAlAnodeWidth1;   ///< Width of FPC Al Anode
-  static const Double_t sIBFPCAlAnodeWidth2;   ///< Width of FPC Al Anode
-  static const Double_t sIBFlexCableKapThick;  ///< Thickness of FPC Kapton
-  static const Double_t sIBFlexCablePolyThick; ///< Thickness of FPC Coverlay
-  static const Double_t sIBFlexCapacitorXWid;  ///< IB capaictor X width
-  static const Double_t sIBFlexCapacitorYHi;   ///< IB capaictor Y height
-  static const Double_t sIBFlexCapacitorZLen;  ///< IB capaictor Z length
-  static const Double_t sIBColdPlateWidth;     ///< IB cold plate X width
-  static const Double_t sIBColdPlateZLen;      ///< IB cold plate Z length
-  static const Double_t sIBGlueThick;          ///< IB glue thickness
-  static const Double_t sIBCarbonFleeceThick;  ///< IB carbon fleece thickness
-  static const Double_t sIBCarbonPaperThick;   ///< IB Carbon Paper Thickness
-  static const Double_t sIBCarbonPaperWidth;   ///< IB Carbon Paper X Width
-  static const Double_t sIBCarbonPaperZLen;    ///< IB Carbon Paper Z Length
-  static const Double_t sIBK13D2UThick;        ///< IB k13d2u prepreg thickness
-  static const Double_t sIBCoolPipeInnerD;     ///< IB cooling inner diameter
-  static const Double_t sIBCoolPipeThick;      ///< IB cooling pipe thickness
-  static const Double_t sIBCoolPipeXDist;      ///< IB cooling pipe separation
-  static const Double_t sIBCoolPipeZLen;       ///< IB cooling pipe length
-  static const Double_t sIBTopVertexWidth1;    ///< IB TopVertex width
-  static const Double_t sIBTopVertexWidth2;    ///< IB TopVertex width
-  static const Double_t sIBTopVertexHeight;    ///< IB TopVertex height
-  static const Double_t sIBTopVertexAngle;     ///< IB TopVertex aperture angle
-  static const Double_t sIBSideVertexWidth;    ///< IB SideVertex width
-  static const Double_t sIBSideVertexHeight;   ///< IB SideVertex height
-  static const Double_t sIBTopFilamentSide;    ///< IB TopFilament side
-  static const Double_t sIBTopFilamentAlpha;   ///< IB TopFilament angle
-  static const Double_t sIBTopFilamentInterZ;  ///< IB TopFilament Z interdist
-  static const Double_t sIBEndSupportThick;    ///< IB end support thickness
-  static const Double_t sIBEndSupportZLen;     ///< IB end support length
-  static const Double_t sIBEndSupportXUp;      ///< IB end support X up wide
-  static const Double_t sIBEndSupportOpenPhi;  ///< IB end support opening phi
+  static const Double_t sIBModuleZLength;       ///< IB Module Length along Z
+  static const Double_t sIBFPCWiderXPlus;       ///< FPC protrusion at X>0
+  static const Double_t sIBFPCWiderXNeg;        ///< FPC protrusion at X<0
+  static const Double_t sIBFlexCableAlThick;    ///< Thickness of FPC Aluminum
+  static const Double_t sIBFPCAlGNDWidth;       ///< Width of total FPC Al Gnd
+  static const Double_t sIBFPCAlAnodeWidth1;    ///< Width of FPC Al Anode
+  static const Double_t sIBFPCAlAnodeWidth2;    ///< Width of FPC Al Anode
+  static const Double_t sIBFlexCableKapThick;   ///< Thickness of FPC Kapton
+  static const Double_t sIBFlexCablePolyThick;  ///< Thickness of FPC Coverlay
+  static const Double_t sIBFlexCapacitor1XWid;  ///< IB small capacitor X width
+  static const Double_t sIBFlexCapacitor1YHi;   ///< IB small capacitor Y height
+  static const Double_t sIBFlexCapacitor1ZLen;  ///< IB small capacitor Z length
+  static const Double_t sIBFlexCapacitor22XWid; ///< IB large capacitor X width
+  static const Double_t sIBFlexCapacitor22YHi;  ///< IB large capacitor Y height
+  static const Double_t sIBFlexCapacitor22ZLen; ///< IB large capacitor Z length
+  static const Double_t sIBFlexResistorXWid;    ///< IB FPC resistor X width
+  static const Double_t sIBFlexResistorYHi;     ///< IB FPC resistor Y height
+  static const Double_t sIBFlexResistorZLen;    ///< IB FPC resistor Z length
+  static const Double_t sIBColdPlateWidth;      ///< IB cold plate X width
+  static const Double_t sIBColdPlateZLen;       ///< IB cold plate Z length
+  static const Double_t sIBGlueThick;           ///< IB glue thickness
+  static const Double_t sIBCarbonFleeceThick;   ///< IB carbon fleece thickness
+  static const Double_t sIBCarbonPaperThick;    ///< IB Carbon Paper Thickness
+  static const Double_t sIBCarbonPaperWidth;    ///< IB Carbon Paper X Width
+  static const Double_t sIBCarbonPaperZLen;     ///< IB Carbon Paper Z Length
+  static const Double_t sIBK13D2UThick;         ///< IB k13d2u prepreg thickness
+  static const Double_t sIBCoolPipeInnerD;      ///< IB cooling inner diameter
+  static const Double_t sIBCoolPipeThick;       ///< IB cooling pipe thickness
+  static const Double_t sIBCoolPipeXDist;       ///< IB cooling pipe separation
+  static const Double_t sIBCoolPipeZLen;        ///< IB cooling pipe length
+  static const Double_t sIBTopVertexWidth1;     ///< IB TopVertex width
+  static const Double_t sIBTopVertexWidth2;     ///< IB TopVertex width
+  static const Double_t sIBTopVertexHeight;     ///< IB TopVertex height
+  static const Double_t sIBTopVertexAngle;      ///< IB TopVertex aperture angle
+  static const Double_t sIBSideVertexWidth;     ///< IB SideVertex width
+  static const Double_t sIBSideVertexHeight;    ///< IB SideVertex height
+  static const Double_t sIBTopFilamentSide;     ///< IB TopFilament side
+  static const Double_t sIBTopFilamentAlpha;    ///< IB TopFilament angle
+  static const Double_t sIBTopFilamentInterZ;   ///< IB TopFilament Z interdist
+  static const Double_t sIBEndSupportThick;     ///< IB end support thickness
+  static const Double_t sIBEndSupportZLen;      ///< IB end support length
+  static const Double_t sIBEndSupportXUp;       ///< IB end support X up wide
+  static const Double_t sIBEndSupportOpenPhi;   ///< IB end support opening phi
 
   static const Double_t sIBConnectorXWidth;    ///< IB Connectors Width
   static const Double_t sIBConnectorYTot;      ///< IB Connectors total height
diff --git a/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx b/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
index 2304a9102092a..8cfe13097d581 100644
--- a/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
+++ b/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
@@ -477,10 +477,11 @@ void Detector::createMaterials()
   Float_t dInox304 = 7.85;
 
   // Ceramic (for IB capacitors) (BaTiO3)
+  // Density includes soldering
   Float_t aCeramic[3] = {137.327, 47.867, 15.999};
   Float_t zCeramic[3] = {56, 22, 8}; // Ba, Ti, O
   Float_t wCeramic[3] = {1, 1, 3};   // Molecular composition
-  Float_t dCeramic = 6.02;
+  Float_t dCeramic = 8.28;
 
   // Rohacell (C9 H13 N1 O2)
   Float_t aRohac[4] = {12.01, 1.01, 14.010, 16.};
diff --git a/Detectors/ITSMFT/ITS/simulation/src/V3Layer.cxx b/Detectors/ITSMFT/ITS/simulation/src/V3Layer.cxx
index 33a1bedec74eb..e930aa23de030 100644
--- a/Detectors/ITSMFT/ITS/simulation/src/V3Layer.cxx
+++ b/Detectors/ITSMFT/ITS/simulation/src/V3Layer.cxx
@@ -61,9 +61,15 @@ const Double_t V3Layer::sIBFPCAlAnodeWidth1 = 13.0 * sMm;
 const Double_t V3Layer::sIBFPCAlAnodeWidth2 = 14.7 * sMm;
 const Double_t V3Layer::sIBFlexCableKapThick = 75.0 * sMicron;
 const Double_t V3Layer::sIBFlexCablePolyThick = 20.0 * sMicron;
-const Double_t V3Layer::sIBFlexCapacitorXWid = 0.2 * sMm;
-const Double_t V3Layer::sIBFlexCapacitorYHi = 0.2 * sMm;
-const Double_t V3Layer::sIBFlexCapacitorZLen = 0.4 * sMm;
+const Double_t V3Layer::sIBFlexCapacitor1XWid = 0.5 * sMm;
+const Double_t V3Layer::sIBFlexCapacitor1YHi = 0.5 * sMm;
+const Double_t V3Layer::sIBFlexCapacitor1ZLen = 1.0 * sMm;
+const Double_t V3Layer::sIBFlexCapacitor22XWid = 0.7 * sMm;
+const Double_t V3Layer::sIBFlexCapacitor22YHi = 0.6 * sMm;
+const Double_t V3Layer::sIBFlexCapacitor22ZLen = 1.1 * sMm;
+const Double_t V3Layer::sIBFlexResistorXWid = 0.2 * sMm;
+const Double_t V3Layer::sIBFlexResistorYHi = 0.2 * sMm;
+const Double_t V3Layer::sIBFlexResistorZLen = 0.4 * sMm;
 const Double_t V3Layer::sIBColdPlateWidth = 15.4 * sMm;
 const Double_t V3Layer::sIBColdPlateZLen = 290.0 * sMm;
 const Double_t V3Layer::sIBGlueThick = 50.0 * sMicron;
@@ -599,8 +605,11 @@ TGeoVolume* V3Layer::createModuleInnerB(const Double_t xchip, const Double_t zch
   //         the module as a TGeoVolume
   //
   // Updated:      03 Apr 2021
+  // Updated:      03 Nov 2025  Change volume from BBox to Xtru to avoid fake overlaps
 
   Double_t xtot, ytot, ztot;
+  Double_t ymid, shrinkFactor = 0.73;
+  Double_t xv[5], yv[5];
   Double_t xpos, ypos, zpos;
   const Int_t nameLen = 30;
   char volumeName[nameLen];
@@ -619,9 +628,25 @@ TGeoVolume* V3Layer::createModuleInnerB(const Double_t xchip, const Double_t zch
   Double_t ygnd = (static_cast<TGeoBBox*>(aluGndCableVol->GetShape()))->GetDY();
   Double_t yano = (static_cast<TGeoBBox*>(aluAnodeCableVol->GetShape()))->GetDY();
 
-  ytot = sIBGlueThick / 2 + ygnd + sIBFlexCableKapThick / 2 + yano + sIBFlexCapacitorYHi / 2;
+  ytot = sIBGlueThick / 2 + ygnd + sIBFlexCableKapThick / 2 + yano + sIBFlexCapacitor22YHi / 2;
+  ymid = sIBGlueThick / 2 + ygnd + sIBFlexCableKapThick / 2 + yano;
 
-  TGeoBBox* module = new TGeoBBox(xtot, ytot, ztot);
+  xv[0] = xtot;
+  yv[0] = -ytot;
+  xv[1] = xv[0];
+  yv[1] = yv[0] + 6 * ymid;
+  xv[2] = xtot * shrinkFactor;
+  yv[2] = ytot;
+  xv[3] = -xtot;
+  yv[3] = yv[2];
+  xv[4] = xv[3];
+  yv[4] = yv[0];
+
+  TGeoXtru* module = new TGeoXtru(2);
+  module->DefinePolygon(6, xv, yv);
+  module->DefinePolygon(5, xv, yv);
+  module->DefineSection(0, -ztot);
+  module->DefineSection(1, ztot);
 
   // Now the volumes
   TGeoMedium* medAir = mgr->GetMedium(Form("%s_AIR$", GetDetName()));
@@ -674,6 +699,7 @@ void V3Layer::createIBCapacitors(TGeoVolume* modvol, Double_t zchip, Double_t yz
   //
   // Created:      13 Feb 2018  Mario Sitta
   // Updated:      03 Apr 2019  Mario Sitta  Fix positions (180' rotation)
+  // Updated:      31 Oct 2025  Mario Sitta  Fix dimensions and weight
   //
 
   // Position of the various capacitors (A.Junique private communication
@@ -705,63 +731,72 @@ void V3Layer::createIBCapacitors(TGeoVolume* modvol, Double_t zchip, Double_t yz
   Double_t xpos, ypos, zpos;
   Int_t nCapacitors;
 
-  TGeoVolume *capacitor, *resistor;
+  TGeoVolume *capacitorSmall, *capacitorLarge, *resistor;
 
-  // Check whether we already have the volume, otherwise create it
-  // (so as to avoid creating multiple copies of the very same volume
+  // Check whether we already have the volumes, otherwise create them
+  // (so as to avoid creating multiple copies of the very same volumes
   // for each layer)
-  capacitor = mgr->GetVolume("IBFPCCapacitor");
+  // The "small" capacitor is the 1 uF substrate capacitor
+  // The "large" capacitor is the 22 uF analog/digital PS capacitor
+  capacitorSmall = mgr->GetVolume("IBFPCCapacitorSmall");
 
-  if (!capacitor) {
-    TGeoBBox* capsh = new TGeoBBox(sIBFlexCapacitorXWid / 2, sIBFlexCapacitorYHi / 2, sIBFlexCapacitorZLen / 2);
+  if (!capacitorSmall) {
+    TGeoBBox* capSmsh = new TGeoBBox(sIBFlexCapacitor1XWid / 2, sIBFlexCapacitor1YHi / 2, sIBFlexCapacitor1ZLen / 2);
+    TGeoBBox* capLgsh = new TGeoBBox(sIBFlexCapacitor22XWid / 2, sIBFlexCapacitor22YHi / 2, sIBFlexCapacitor22ZLen / 2);
 
     TGeoMedium* medCeramic = mgr->GetMedium(Form("%s_CERAMIC$", GetDetName()));
 
-    capacitor = new TGeoVolume("IBFPCCapacitor", capsh, medCeramic);
-    capacitor->SetLineColor(kBlack);
-    capacitor->SetFillColor(kBlack);
+    capacitorSmall = new TGeoVolume("IBFPCCapacitorSmall", capSmsh, medCeramic);
+    capacitorSmall->SetLineColor(kBlack);
+    capacitorSmall->SetFillColor(kBlack);
+
+    capacitorLarge = new TGeoVolume("IBFPCCapacitorLarge", capLgsh, medCeramic);
+    capacitorLarge->SetLineColor(kBlack);
+    capacitorLarge->SetFillColor(kBlack);
 
-    TGeoBBox* ressh = new TGeoBBox(sIBFlexCapacitorXWid / 2,  // Resistors have
-                                   sIBFlexCapacitorYHi / 2,   // the same dim's
-                                   sIBFlexCapacitorZLen / 2); // as capacitors
+    TGeoBBox* ressh = new TGeoBBox(sIBFlexResistorXWid / 2,
+                                   sIBFlexResistorYHi / 2,
+                                   sIBFlexResistorZLen / 2);
 
     resistor = new TGeoVolume("IBFPCResistor", ressh, medCeramic);
     resistor->SetLineColor(kBlack);
     resistor->SetFillColor(kBlack);
   } else { // Volumes already defined, get them
+    capacitorLarge = mgr->GetVolume("IBFPCCapacitorLarge");
     resistor = mgr->GetVolume("IBFPCResistor");
   }
 
   // Place all the capacitors (they are really a lot...)
-  ypos = yzero + sIBFlexCapacitorYHi / 2;
+  ypos = yzero + sIBFlexCapacitor22YHi / 2;
 
   xpos = xGroup1A;
   for (Int_t j = 0; j < sIBChipsPerRow; j++) {
     zpos = -mIBModuleZLength / 2 + j * (2 * zchip + sIBChipZGap) + zchip + zGroup1A[0];
-    modvol->AddNode(capacitor, 2 * j + 1, new TGeoTranslation(-xpos, ypos, -zpos));
+    modvol->AddNode(capacitorLarge, 2 * j + 1, new TGeoTranslation(-xpos, ypos, -zpos));
     zpos = -mIBModuleZLength / 2 + j * (2 * zchip + sIBChipZGap) + zchip + zGroup1A[1];
-    modvol->AddNode(capacitor, 2 * j + 2, new TGeoTranslation(-xpos, ypos, -zpos));
+    modvol->AddNode(capacitorLarge, 2 * j + 2, new TGeoTranslation(-xpos, ypos, -zpos));
   }
 
   nCapacitors = 2 * sIBChipsPerRow;
   xpos = xGroup1B;
   for (Int_t j = 0; j < sIBChipsPerRow; j++) {
     zpos = -mIBModuleZLength / 2 + j * (2 * zchip + sIBChipZGap) + zchip + zGroup1B;
-    modvol->AddNode(capacitor, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
+    modvol->AddNode(capacitorLarge, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
   }
 
   nCapacitors += sIBChipsPerRow;
+  ypos = yzero + sIBFlexCapacitor1YHi / 2;
   xpos = xGroup2;
   // We have only 8 in these group, missing the central one
   for (Int_t j = 0; j < sIBChipsPerRow - 1; j++) {
     zpos = -mIBModuleZLength / 2 + j * (2 * zchip + sIBChipZGap) + zchip + zGroup2;
-    modvol->AddNode(capacitor, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
+    modvol->AddNode(capacitorSmall, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
   }
 
   nCapacitors += (sIBChipsPerRow - 1);
   xpos = xGroup3;
   zpos = zGroup3;
-  modvol->AddNode(capacitor, 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
+  modvol->AddNode(capacitorSmall, 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
 
   nCapacitors++;
   for (Int_t j = 0; j < sIBChipsPerRow; j++) {
@@ -771,10 +806,11 @@ void V3Layer::createIBCapacitors(TGeoVolume* modvol, Double_t zchip, Double_t yz
       xpos = xGroup4[0];
     }
     zpos = -mIBModuleZLength / 2 + j * (2 * zchip + sIBChipZGap) + zchip + zGroup4[j];
-    modvol->AddNode(capacitor, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
+    modvol->AddNode(capacitorSmall, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
   }
 
   nCapacitors += sIBChipsPerRow;
+  ypos = yzero + sIBFlexCapacitor22YHi / 2;
   for (Int_t j = 0; j < nGroup5A; j++) {
     if (j == 0) {
       xpos = xGroup5A[0];
@@ -782,14 +818,14 @@ void V3Layer::createIBCapacitors(TGeoVolume* modvol, Double_t zchip, Double_t yz
       xpos = xGroup5A[1];
     }
     zpos = zGroup5A[j];
-    modvol->AddNode(capacitor, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
+    modvol->AddNode(capacitorLarge, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
   }
 
   nCapacitors += nGroup5A;
   xpos = xGroup5B;
   for (Int_t j = 0; j < nGroup5B; j++) {
     zpos = zGroup5B[j];
-    modvol->AddNode(capacitor, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
+    modvol->AddNode(capacitorLarge, j + 1 + nCapacitors, new TGeoTranslation(-xpos, ypos, -zpos));
   }
 
   // Place the resistors
@@ -1061,7 +1097,7 @@ TGeoVolume* V3Layer::createStaveModelInnerB4(const TGeoManager* mgr)
   yv[1] = layerHeight + sIBSideVertexHeight + topfil->GetDZ();
   ;
   xv[2] = sIBEndSupportXUp / 2;
-  yv[2] = sIBStaveHeight + sIBTopFilamentSide / sinD(-theta); // theta is neg
+  yv[2] = sIBStaveHeight + sIBTopFilamentSide / sinD(-theta) - 0.01; // theta is neg
   for (Int_t i = 0; i < 3; i++) {
     xv[3 + i] = -xv[2 - i];
     yv[3 + i] = yv[2 - i];

From 72e6d0178cdf3b6e553d7df4cdce064b8929f3e7 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Thu, 13 Nov 2025 00:10:24 +0100
Subject: [PATCH 1023/1764] Find Thrust + fix compilation on CUDA13 (#14801)

* Find Thrust in CUDA13

* Fix compatibility with CUDA13

* Update FindO2GPU.cmake version to 5
---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu | 13 ++++++++-----
 dependencies/FindO2GPU.cmake                       | 10 +++++++---
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 62b490a59d0dc..8e896ca513f53 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -120,6 +120,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
 
   if (mMaster == nullptr) {
     cudaDeviceProp deviceProp;
+    int deviceMemoryClockRate{0}, deviceClockRate{0};
     int32_t count, bestDevice = -1;
     double bestDeviceSpeed = -1, deviceSpeed;
     if (GPUChkErrI(cudaGetDeviceCount(&count))) {
@@ -153,7 +154,9 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       if (GetProcessingSettings().debugLevel >= 4) {
         GPUInfo("Obtained current memory usage for device %d", i);
       }
-      if (GPUChkErrI(cudaGetDeviceProperties(&deviceProp, i))) {
+      if (GPUChkErrI(cudaGetDeviceProperties(&deviceProp, i)) ||
+          GPUChkErrI(cudaDeviceGetAttribute(&deviceMemoryClockRate, cudaDevAttrMemoryClockRate, i)) ||
+          GPUChkErrI(cudaDeviceGetAttribute(&deviceClockRate, cudaDevAttrClockRate, i))) {
         continue;
       }
       if (GetProcessingSettings().debugLevel >= 4) {
@@ -172,7 +175,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
         deviceFailure = "Insufficient GPU memory";
       }
 
-      deviceSpeed = (double)deviceProp.multiProcessorCount * (double)deviceProp.clockRate * (double)deviceProp.warpSize * (double)free * (double)deviceProp.major * (double)deviceProp.major;
+      deviceSpeed = (double)deviceProp.multiProcessorCount * (double)deviceClockRate * (double)deviceProp.warpSize * (double)free * (double)deviceProp.major * (double)deviceProp.major;
       if (GetProcessingSettings().debugLevel >= 2) {
         GPUImportant("Device %s%2d: %s (Rev: %d.%d - Mem Avail %lu / %lu)%s %s", deviceOK ? " " : "[", i, deviceProp.name, deviceProp.major, deviceProp.minor, free, (size_t)deviceProp.totalGlobalMem, deviceOK ? " " : " ]", deviceOK ? "" : deviceFailure);
       }
@@ -239,8 +242,8 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
       GPUInfo("\ttotalConstMem = %ld", (uint64_t)deviceProp.totalConstMem);
       GPUInfo("\tmajor = %d", deviceProp.major);
       GPUInfo("\tminor = %d", deviceProp.minor);
-      GPUInfo("\tclockRate = %d", deviceProp.clockRate);
-      GPUInfo("\tmemoryClockRate = %d", deviceProp.memoryClockRate);
+      GPUInfo("\tclockRate = %d", deviceClockRate);
+      GPUInfo("\tdeviceMemoryClockRateRate = %d", deviceMemoryClockRate);
       GPUInfo("\tmultiProcessorCount = %d", deviceProp.multiProcessorCount);
       GPUInfo("\ttextureAlignment = %ld", (uint64_t)deviceProp.textureAlignment);
       GPUInfo(" ");
@@ -371,7 +374,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
 #endif
     mDeviceConstantMem = (GPUConstantMem*)devPtrConstantMem;
 
-    GPUInfo("CUDA Initialisation successfull (Device %d: %s (Frequency %d, Cores %d), %ld / %ld bytes host / global memory, Stack frame %d, Constant memory %ld)", mDeviceId, deviceProp.name, deviceProp.clockRate, deviceProp.multiProcessorCount, (int64_t)mHostMemorySize, (int64_t)mDeviceMemorySize, (int32_t)GPUCA_GPU_STACK_SIZE, (int64_t)gGPUConstantMemBufferSize);
+    GPUInfo("CUDA Initialisation successfull (Device %d: %s (Frequency %d, Cores %d), %ld / %ld bytes host / global memory, Stack frame %d, Constant memory %ld)", mDeviceId, deviceProp.name, deviceClockRate, deviceProp.multiProcessorCount, (int64_t)mHostMemorySize, (int64_t)mDeviceMemorySize, (int32_t)GPUCA_GPU_STACK_SIZE, (int64_t)gGPUConstantMemBufferSize);
   } else {
     GPUReconstructionCUDA* master = dynamic_cast<GPUReconstructionCUDA*>(mMaster);
     mDeviceId = master->mDeviceId;
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 9f335eaa6600a..4813ac18eae72 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 4
+# FindO2GPU.cmake Version 5
 
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
@@ -139,10 +139,14 @@ if(ENABLE_CUDA)
       message(${FAILURE_SEVERITY} "CUDA was found but cannot be enabled")
       set(CMAKE_CUDA_COMPILER OFF)
     endif()
-    find_path(THRUST_INCLUDE_DIR thrust/version.h PATHS ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES} NO_DEFAULT_PATH)
+    find_path(THRUST_INCLUDE_DIR thrust/version.h PATHS ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}
+	    PATH_SUFFIXES "" cccl
+	    NO_DEFAULT_PATH)
     if(THRUST_INCLUDE_DIR STREQUAL "THRUST_INCLUDE_DIR-NOTFOUND")
-      message(${FAILURE_SEVERITY} "CUDA found but thrust not available")
+      message(${FAILURE_SEVERITY} "CUDA found but thrust not available, looked under: ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}")
       set(CMAKE_CUDA_COMPILER OFF)
+    else()
+      message(STATUS "Thrust found in the path: ${THRUST_INCLUDE_DIR}")
     endif()
     if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "12.8")
       message(${FAILURE_SEVERITY} "CUDA Version too old: ${CMAKE_CUDA_COMPILER_VERSION}, 12.8 required")

From aa1fa2706fbb4d9ca969eb570edfe62b14c2e50e Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 13 Nov 2025 12:23:45 +0100
Subject: [PATCH 1024/1764] DPL Analysis: generalize aod-spawner (#14808)

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Framework/Core/CMakeLists.txt                 |   1 +
 .../Core/include/Framework/AODReaderHelpers.h |   5 +-
 Framework/Core/include/Framework/ASoA.h       |  10 +-
 .../Core/include/Framework/AnalysisHelpers.h  |  34 +
 .../Core/include/Framework/Expressions.h      |  16 +-
 .../Core/include/Framework/TableBuilder.h     |   5 +-
 Framework/Core/src/AODReaderHelpers.cxx       | 197 +++--
 Framework/Core/src/ASoA.cxx                   |  30 +
 Framework/Core/src/AnalysisHelpers.cxx        |  15 +
 Framework/Core/src/ArrowSupport.cxx           |   2 +-
 Framework/Core/src/ExpressionJSONHelpers.cxx  | 826 ++++++++++++++++++
 Framework/Core/src/ExpressionJSONHelpers.h    |  29 +
 Framework/Core/src/TableBuilder.cxx           |  42 +
 Framework/Core/src/WorkflowHelpers.cxx        |   3 +-
 Framework/Core/test/test_Expressions.cxx      |  64 ++
 15 files changed, 1203 insertions(+), 76 deletions(-)
 create mode 100644 Framework/Core/src/ExpressionJSONHelpers.cxx
 create mode 100644 Framework/Core/src/ExpressionJSONHelpers.h

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 11eb4bdc08a66..1aed1f776b775 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -142,6 +142,7 @@ o2_add_library(Framework
                        src/Array2D.cxx
                        src/Variant.cxx
                        src/VariantJSONHelpers.cxx
+                       src/ExpressionJSONHelpers.cxx
                        src/VariantPropertyTreeHelpers.cxx
                        src/WorkflowCustomizationHelpers.cxx
                        src/WorkflowHelpers.cxx
diff --git a/Framework/Core/include/Framework/AODReaderHelpers.h b/Framework/Core/include/Framework/AODReaderHelpers.h
index 957a5b1cd25ba..800d26c2aeae0 100644
--- a/Framework/Core/include/Framework/AODReaderHelpers.h
+++ b/Framework/Core/include/Framework/AODReaderHelpers.h
@@ -12,10 +12,7 @@
 #ifndef O2_FRAMEWORK_AODREADERHELPERS_H_
 #define O2_FRAMEWORK_AODREADERHELPERS_H_
 
-#include "Framework/TableBuilder.h"
 #include "Framework/AlgorithmSpec.h"
-#include "Framework/Logger.h"
-#include "Framework/RootMessageContext.h"
 #include <uv.h>
 
 namespace o2::framework::readers
@@ -24,7 +21,7 @@ namespace o2::framework::readers
 
 struct AODReaderHelpers {
   static AlgorithmSpec rootFileReaderCallback();
-  static AlgorithmSpec aodSpawnerCallback(std::vector<InputSpec>& requested);
+  static AlgorithmSpec aodSpawnerCallback(ConfigContext const& ctx);
   static AlgorithmSpec indexBuilderCallback(std::vector<InputSpec>& requested);
 };
 
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index b9b97bfa5ca9c..10c1fc4ac3ceb 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1270,6 +1270,7 @@ struct TableIterator : IP, C... {
 
 struct ArrowHelpers {
   static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const char* const> labels);
+  static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const std::string> labels);
   static std::shared_ptr<arrow::Table> concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
 };
 
@@ -1293,7 +1294,14 @@ concept with_ccdb_urls = requires {
 };
 
 template <typename T>
-concept with_base_table = not_void<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t>;
+concept with_base_table = requires {
+  typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t;
+};
+
+template <typename T>
+concept with_expression_pack = requires {
+  typename T::expression_pack_t{};
+};
 
 template <size_t N1, std::array<TableRef, N1> os1, size_t N2, std::array<TableRef, N2> os2>
 consteval bool is_compatible()
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 842263cd75abc..fa82151c6e756 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -26,6 +26,12 @@
 #include "Framework/Traits.h"
 
 #include <string>
+namespace o2::framework
+{
+std::string serializeProjectors(std::vector<framework::expressions::Projector>& projectors);
+std::string serializeSchema(std::shared_ptr<arrow::Schema>& schema);
+}  // namespace o2::framework
+
 namespace o2::soa
 {
 template <TableRef R>
@@ -97,6 +103,32 @@ constexpr auto getCCDBMetadata() -> std::vector<framework::ConfigParamSpec>
 {
   return {};
 }
+
+template <soa::with_expression_pack T>
+constexpr auto getExpressionMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  using expression_pack_t = T::expression_pack_t;
+
+  auto projectors = []<typename... C>(framework::pack<C...>) -> std::vector<framework::expressions::Projector> {
+    std::vector<framework::expressions::Projector> result;
+    (result.emplace_back(std::move(C::Projector())), ...);
+    return result;
+  }(expression_pack_t{});
+
+  auto schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
+
+  auto json = framework::serializeProjectors(projectors);
+  return {framework::ConfigParamSpec{"projectors", framework::VariantType::String, json, {"\"\""}},
+          framework::ConfigParamSpec{"schema", framework::VariantType::String, framework::serializeSchema(schema), {"\"\""}}};
+}
+
+template <typename T>
+  requires(!soa::with_expression_pack<T>)
+constexpr auto getExpressionMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  return {};
+}
+
 }  // namespace
 
 template <TableRef R>
@@ -107,6 +139,8 @@ constexpr auto tableRef2InputSpec()
   metadata.insert(metadata.end(), m.begin(), m.end());
   auto ccdbMetadata = getCCDBMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
   metadata.insert(metadata.end(), ccdbMetadata.begin(), ccdbMetadata.end());
+  auto p = getExpressionMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  metadata.insert(metadata.end(), p.begin(), p.end());
 
   return framework::InputSpec{
     o2::aod::label<R>(),
diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 5a889e9ae26ec..e08bf8db52bb4 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -110,6 +110,8 @@ std::string upcastTo(atype::type f);
 
 /// An expression tree node corresponding to a literal value
 struct LiteralNode {
+  using var_t = LiteralValue::stored_type;
+
   LiteralNode()
     : value{-1},
       type{atype::INT32}
@@ -120,7 +122,12 @@ struct LiteralNode {
   {
   }
 
-  using var_t = LiteralValue::stored_type;
+  LiteralNode(var_t v, atype::type t)
+    : value{v},
+      type{t}
+  {
+  }
+
   var_t value;
   atype::type type = atype::NA;
 };
@@ -617,6 +624,12 @@ inline Node ncfg(T defaultValue, std::string path)
 struct Filter {
   Filter() = default;
 
+  Filter(std::unique_ptr<Node>&& ptr)
+  {
+    node = std::move(ptr);
+    (void)designateSubtrees(node.get());
+  }
+
   Filter(Node&& node_) : node{std::make_unique<Node>(std::forward<Node>(node_))}
   {
     (void)designateSubtrees(node.get());
@@ -624,7 +637,6 @@ struct Filter {
 
   Filter(Filter&& other) : node{std::forward<std::unique_ptr<Node>>(other.node)}
   {
-    (void)designateSubtrees(node.get());
   }
 
   Filter(std::string const& input_) : input{input_} {}
diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index 1eb493bfd052d..7707afe45b380 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -18,7 +18,6 @@
 #include "arrow/type_traits.h"
 
 // Apparently needs to be on top of the arrow includes.
-#include <sstream>
 
 #include <arrow/chunked_array.h>
 #include <arrow/status.h>
@@ -796,6 +795,10 @@ auto makeEmptyTable(const char* name, framework::pack<Cs...> p)
 std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
                                             expressions::Projector* projectors, const char* name, std::shared_ptr<gandiva::Projector>& projector);
 
+std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema,
+                                            const char* name, size_t nColumns,
+                                            const std::shared_ptr<gandiva::Projector>& projector);
+
 /// Expression-based column generator to materialize columns
 template <aod::is_aod_hash D>
   requires(soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index 2587b8e4ca03a..febc19e02834e 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -12,13 +12,16 @@
 #include "Framework/AODReaderHelpers.h"
 #include "Framework/AnalysisHelpers.h"
 #include "Framework/AnalysisDataModelHelpers.h"
-#include "Framework/DataProcessingHelpers.h"
 #include "Framework/ExpressionHelpers.h"
+#include "Framework/DataProcessingHelpers.h"
 #include "Framework/AlgorithmSpec.h"
 #include "Framework/ControlService.h"
 #include "Framework/CallbackService.h"
 #include "Framework/EndOfStreamContext.h"
 #include "Framework/DataSpecUtils.h"
+#include "ExpressionJSONHelpers.h"
+#include "Framework/ConfigContext.h"
+#include "Framework/AnalysisContext.h"
 
 #include <Monitoring/Monitoring.h>
 
@@ -44,28 +47,6 @@ auto setEOSCallback(InitContext& ic)
     });
 }
 
-template <typename... Ts>
-static inline auto doExtractOriginal(framework::pack<Ts...>, ProcessingContext& pc)
-{
-  if constexpr (sizeof...(Ts) == 1) {
-    return pc.inputs().get<TableConsumer>(aod::MetadataTrait<framework::pack_element_t<0, framework::pack<Ts...>>>::metadata::tableLabel())->asArrowTable();
-  } else {
-    return std::vector{pc.inputs().get<TableConsumer>(aod::MetadataTrait<Ts>::metadata::tableLabel())->asArrowTable()...};
-  }
-}
-
-template <typename... Os>
-static inline auto extractOriginalsTuple(framework::pack<Os...>, ProcessingContext& pc)
-{
-  return std::make_tuple(extractTypedOriginal<Os>(pc)...);
-}
-
-template <typename... Os>
-static inline auto extractOriginalsVector(framework::pack<Os...>, ProcessingContext& pc)
-{
-  return std::vector{extractOriginal<Os>(pc)...};
-}
-
 template <size_t N, std::array<soa::TableRef, N> refs>
 static inline auto extractOriginals(ProcessingContext& pc)
 {
@@ -156,53 +137,137 @@ auto make_spawn(InputSpec const& input, ProcessingContext& pc)
   (typename metadata_t::expression_pack_t{});
   return o2::framework::spawner<D>(extractOriginals<sources.size(), sources>(pc), input.binding.c_str(), projectors.data(), projector, schema);
 }
+
+struct Maker {
+  std::string binding;
+  std::vector<std::string> labels;
+  std::vector<std::shared_ptr<gandiva::Expression>> expressions;
+  std::shared_ptr<gandiva::Projector> projector = nullptr;
+  std::shared_ptr<arrow::Schema> schema;
+
+  header::DataOrigin origin;
+  header::DataDescription description;
+  header::DataHeader::SubSpecificationType version;
+
+  std::shared_ptr<arrow::Table> make(ProcessingContext& pc)
+  {
+    std::vector<std::shared_ptr<arrow::Table>> originals;
+    for (auto const& label : labels) {
+      originals.push_back(pc.inputs().get<TableConsumer>(label)->asArrowTable());
+    }
+    auto fullTable = soa::ArrowHelpers::joinTables(std::move(originals), std::span{labels.begin(), labels.size()});
+    if (projector == nullptr) {
+      auto s = gandiva::Projector::Make(
+        fullTable->schema(),
+        expressions,
+        &projector);
+      if (!s.ok()) {
+        throw o2::framework::runtime_error_f("Failed to create projector: %s", s.ToString().c_str());
+      }
+    }
+
+    return spawnerHelper(fullTable, schema, binding.c_str(), schema->num_fields(), projector);
+  }
+};
+
+struct Spawnable {
+  std::string binding;
+  std::vector<std::string> labels;
+  std::vector<expressions::Projector> projectors;
+  std::vector<std::shared_ptr<gandiva::Expression>> expressions;
+  std::shared_ptr<arrow::Schema> outputSchema;
+  std::shared_ptr<arrow::Schema> inputSchema;
+
+  header::DataOrigin origin;
+  header::DataDescription description;
+  header::DataHeader::SubSpecificationType version;
+
+  Spawnable(InputSpec const& spec)
+    : binding{spec.binding}
+  {
+    auto&& [origin_, description_, version_] = DataSpecUtils::asConcreteDataMatcher(spec);
+    origin = origin_;
+    description = description_;
+    version = version_;
+    auto loc = std::find_if(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& cps) { return cps.name.compare("projectors") == 0; });
+    std::stringstream iws(loc->defaultValue.get<std::string>());
+    projectors = ExpressionJSONHelpers::read(iws);
+
+    loc = std::find_if(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& cps) { return cps.name.compare("schema") == 0; });
+    iws.clear();
+    iws.str(loc->defaultValue.get<std::string>());
+    outputSchema = ArrowJSONHelpers::read(iws);
+
+    for (auto& i : spec.metadata) {
+      if (i.name.starts_with("input:")) {
+        labels.emplace_back(i.name.substr(6));
+      }
+    }
+
+    std::vector<std::shared_ptr<arrow::Field>> fields;
+    for (auto& p : projectors) {
+      expressions::walk(p.node.get(),
+                        [&fields](expressions::Node* n) mutable {
+                          if (n->self.index() == 1) {
+                            auto& b = std::get<expressions::BindingNode>(n->self);
+                            if (std::find_if(fields.begin(), fields.end(), [&b](std::shared_ptr<arrow::Field> const& field) { return field->name() == b.name; }) == fields.end()) {
+                              fields.emplace_back(std::make_shared<arrow::Field>(b.name, expressions::concreteArrowType(b.type)));
+                            }
+                          }
+                        });
+    }
+    inputSchema = std::make_shared<arrow::Schema>(fields);
+
+    int i = 0;
+    for (auto& p : projectors) {
+      expressions.push_back(
+        expressions::makeExpression(
+          expressions::createExpressionTree(
+            expressions::createOperations(p),
+            inputSchema),
+          outputSchema->field(i)));
+      ++i;
+    }
+  }
+
+  std::shared_ptr<gandiva::Projector> makeProjector()
+  {
+    return expressions::createProjectorHelper(projectors.size(), projectors.data(), inputSchema, outputSchema->fields());
+  }
+
+  Maker createMaker()
+  {
+    return {
+      binding,
+      labels,
+      expressions,
+      nullptr,
+      outputSchema,
+      origin,
+      description,
+      version};
+  }
+};
+
 } // namespace
 
-AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(std::vector<InputSpec>& requested)
+AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(/*std::vector<InputSpec>& requested*/ ConfigContext const& ctx)
 {
-  return AlgorithmSpec::InitCallback{[requested](InitContext& /*ic*/) {
-    return [requested](ProcessingContext& pc) {
+  auto& ac = ctx.services().get<AnalysisContext>();
+  return AlgorithmSpec::InitCallback{[requested = ac.spawnerInputs](InitContext& /*ic*/) {
+    std::vector<Spawnable> spawnables;
+    for (auto& i : requested) {
+      spawnables.emplace_back(i);
+    }
+    std::vector<Maker> makers;
+    for (auto& s : spawnables) {
+      makers.push_back(s.createMaker());
+    }
+
+    return [makers](ProcessingContext& pc) mutable {
       auto outputs = pc.outputs();
-      // spawn tables
-      for (auto& input : requested) {
-        auto&& [origin, description, version] = DataSpecUtils::asConcreteDataMatcher(input);
-        if (description == header::DataDescription{"EXTRACK"}) {
-          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACK/0"_h>>(input, pc));
-        } else if (description == header::DataDescription{"EXTRACK_IU"}) {
-          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACK_IU/0"_h>>(input, pc));
-        } else if (description == header::DataDescription{"EXTRACKCOV"}) {
-          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKCOV/0"_h>>(input, pc));
-        } else if (description == header::DataDescription{"EXTRACKCOV_IU"}) {
-          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKCOV_IU/0"_h>>(input, pc));
-        } else if (description == header::DataDescription{"EXTRACKEXTRA"}) {
-          if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKEXTRA/0"_h>>(input, pc));
-          } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKEXTRA/1"_h>>(input, pc));
-          } else if (version == 2U) {
-            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXTRACKEXTRA/2"_h>>(input, pc));
-          }
-        } else if (description == header::DataDescription{"EXMFTTRACK"}) {
-          if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMFTTRACK/0"_h>>(input, pc));
-          } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMFTTRACK/1"_h>>(input, pc));
-          }
-        } else if (description == header::DataDescription{"EXMFTTRACKCOV"}) {
-          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMFTTRACKCOV/0"_h>>(input, pc));
-        } else if (description == header::DataDescription{"EXFWDTRACK"}) {
-          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXFWDTRACK/0"_h>>(input, pc));
-        } else if (description == header::DataDescription{"EXFWDTRACKCOV"}) {
-          outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXFWDTRACKCOV/0"_h>>(input, pc));
-        } else if (description == header::DataDescription{"EXMCPARTICLE"}) {
-          if (version == 0U) {
-            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMCPARTICLE/0"_h>>(input, pc));
-          } else if (version == 1U) {
-            outputs.adopt(Output{origin, description, version}, make_spawn<o2::aod::Hash<"EXMCPARTICLE/1"_h>>(input, pc));
-          }
-        } else {
-          throw runtime_error("Not an extended table");
-        }
+      for (auto& maker : makers) {
+        outputs.adopt(Output{maker.origin, maker.description, maker.version}, maker.make(pc));
       }
     };
   }};
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index 83ca358525f9f..6a846c3d45b6c 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -99,6 +99,36 @@ std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_p
   return arrow::Table::Make(schema, columns);
 }
 
+std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const std::string> labels)
+{
+  if (tables.size() == 1) {
+    return tables[0];
+  }
+  for (auto i = 0U; i < tables.size() - 1; ++i) {
+    if (tables[i]->num_rows() != tables[i + 1]->num_rows()) {
+      throw o2::framework::runtime_error_f("Tables %s and %s have different sizes (%d vs %d) and cannot be joined!",
+                                           labels[i].c_str(), labels[i + 1].c_str(), tables[i]->num_rows(), tables[i + 1]->num_rows());
+    }
+  }
+  std::vector<std::shared_ptr<arrow::Field>> fields;
+  std::vector<std::shared_ptr<arrow::ChunkedArray>> columns;
+
+  for (auto& t : tables) {
+    auto tf = t->fields();
+    std::copy(tf.begin(), tf.end(), std::back_inserter(fields));
+  }
+
+  auto schema = std::make_shared<arrow::Schema>(fields);
+
+  if (tables[0]->num_rows() != 0) {
+    for (auto& t : tables) {
+      auto tc = t->columns();
+      std::copy(tc.begin(), tc.end(), std::back_inserter(columns));
+    }
+  }
+  return arrow::Table::Make(schema, columns);
+}
+
 std::shared_ptr<arrow::Table> ArrowHelpers::concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables)
 {
   if (tables.size() == 1) {
diff --git a/Framework/Core/src/AnalysisHelpers.cxx b/Framework/Core/src/AnalysisHelpers.cxx
index c0f804b47f5af..4f78cc42f3f98 100644
--- a/Framework/Core/src/AnalysisHelpers.cxx
+++ b/Framework/Core/src/AnalysisHelpers.cxx
@@ -9,6 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 #include "Framework/ExpressionHelpers.h"
+#include "ExpressionJSONHelpers.h"
 
 namespace o2::framework
 {
@@ -26,4 +27,18 @@ void initializePartitionCaches(std::set<uint32_t> const& hashes, std::shared_ptr
     gfilter = framework::expressions::createFilter(schema, framework::expressions::makeCondition(tree));
   }
 }
+
+std::string serializeProjectors(std::vector<framework::expressions::Projector>& projectors)
+{
+  std::stringstream osm;
+  ExpressionJSONHelpers::write(osm, projectors);
+  return osm.str();
+}
+
+std::string serializeSchema(std::shared_ptr<arrow::Schema>& schema)
+{
+  std::stringstream osm;
+  ArrowJSONHelpers::write(osm, schema);
+  return osm.str();
+}
 } // namespace o2::framework
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index da00c8db42280..cc164a77870e0 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -609,7 +609,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         spawner->inputs.clear();
         // replace AlgorithmSpec
         // FIXME: it should be made more generic, so it does not need replacement...
-        spawner->algorithm = readers::AODReaderHelpers::aodSpawnerCallback(ac.spawnerInputs);
+        spawner->algorithm = readers::AODReaderHelpers::aodSpawnerCallback(ctx);
         AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, *spawner);
       }
 
diff --git a/Framework/Core/src/ExpressionJSONHelpers.cxx b/Framework/Core/src/ExpressionJSONHelpers.cxx
new file mode 100644
index 0000000000000..8d4907a721f7e
--- /dev/null
+++ b/Framework/Core/src/ExpressionJSONHelpers.cxx
@@ -0,0 +1,826 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#include "ExpressionJSONHelpers.h"
+
+#include <rapidjson/reader.h>
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/istreamwrapper.h>
+#include <rapidjson/ostreamwrapper.h>
+#include <rapidjson/error/en.h>
+
+#include <stack>
+#include <iostream>
+#include "Framework/VariantHelpers.h"
+
+namespace o2::framework
+{
+namespace
+{
+using nodes = expressions::Node::self_t;
+enum struct Nodes : int {
+  NLITERAL = 0,
+  NBINDING = 1,
+  NOP = 2,
+  NNPH = 3,
+  NCOND = 4,
+  NPAR = 5
+};
+
+enum struct ToWrite {
+  FULL,
+  LEFT,
+  RIGHT,
+  COND,
+  POP
+};
+
+struct Entry {
+  expressions::Node* ptr = nullptr;
+  ToWrite toWrite = ToWrite::FULL;
+};
+
+std::array<std::string_view, 11> validKeys{
+  "projectors",
+  "kind",
+  "binding",
+  "index",
+  "arrow_type",
+  "value",
+  "hash",
+  "operation",
+  "left",
+  "right",
+  "condition"};
+
+struct ExpressionReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, ExpressionReader> {
+  using Ch = rapidjson::UTF8<>::Ch;
+  using SizeType = rapidjson::SizeType;
+
+  enum struct State {
+    IN_START,            // global start
+    IN_LIST,             // opening brace of the list
+    IN_ROOT,             // after encountering the opening of the expression object
+    IN_LEFT,             // in "left" key - subexpression
+    IN_RIGHT,            // in "right" key - subexpression
+    IN_COND,             // in "condition" key - subexpression
+    IN_NODE_LITERAL,     // in literal node
+    IN_NODE_BINDING,     // in binding node
+    IN_NODE_OP,          // in operation node
+    IN_NODE_CONDITIONAL, // in conditional node
+    IN_ERROR             // generic error state
+  };
+
+  std::stack<State> states;
+  std::stack<Entry> path;
+  std::ostringstream debug;
+
+  std::vector<expressions::Projector> result;
+
+  std::unique_ptr<expressions::Node> rootNode = nullptr;
+  std::unique_ptr<expressions::Node> node = nullptr;
+  expressions::LiteralValue::stored_type value;
+  atype::type type;
+  Nodes kind;
+  std::string binding;
+  BasicOp operation;
+  uint32_t hash;
+  size_t index;
+
+  std::string previousKey;
+  std::string currentKey;
+
+  ExpressionReader()
+  {
+    debug << ">>> Start" << std::endl;
+    states.push(State::IN_START);
+  }
+
+  bool StartArray()
+  {
+    debug << "StartArray()" << std::endl;
+    if (states.top() == State::IN_START) {
+      states.push(State::IN_LIST);
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool EndArray(SizeType)
+  {
+    debug << "EndArray()" << std::endl;
+    if (states.top() == State::IN_LIST) {
+      states.pop();
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool Key(const Ch* str, SizeType, bool)
+  {
+    debug << "Key(" << str << ")" << std::endl;
+    previousKey = currentKey;
+    currentKey = str;
+    if (std::find(validKeys.begin(), validKeys.end(), currentKey) == validKeys.end()) {
+      states.push(State::IN_ERROR);
+      return false;
+    }
+
+    if (states.top() == State::IN_START) {
+      if (currentKey.compare("projectors") == 0) {
+        return true;
+      }
+    }
+
+    if (states.top() == State::IN_ROOT) {
+      if (currentKey.compare("kind") == 0) {
+        return true;
+      } else {
+        states.push(State::IN_ERROR); // should start from root node
+        return false;
+      }
+    }
+
+    if (states.top() == State::IN_LEFT || states.top() == State::IN_RIGHT || states.top() == State::IN_COND) {
+      if (currentKey.compare("kind") == 0) {
+        return true;
+      }
+    }
+
+    if (states.top() == State::IN_NODE_LITERAL || states.top() == State::IN_NODE_OP || states.top() == State::IN_NODE_BINDING || states.top() == State::IN_NODE_CONDITIONAL) {
+      if (currentKey.compare("index") == 0) {
+        return true;
+      }
+      if (currentKey.compare("left") == 0) {
+        // this is the point where the node header is parsed and we can create it
+        // create a new node instance here and set a pointer to it in a parent (current stack top), based on its state
+        // push the new node into the stack with LEFT state
+        switch (states.top()) {
+          case State::IN_NODE_LITERAL:
+            node = std::make_unique<expressions::Node>(expressions::LiteralNode{value, type});
+            break;
+          case State::IN_NODE_BINDING:
+            node = std::make_unique<expressions::Node>(expressions::BindingNode{hash, type}, binding);
+            break;
+          case State::IN_NODE_OP:
+            node = std::make_unique<expressions::Node>(expressions::OpNode{operation}, expressions::LiteralNode{-1});
+            break;
+          case State::IN_NODE_CONDITIONAL:
+            node = std::make_unique<expressions::Node>(expressions::ConditionalNode{}, expressions::LiteralNode{-1}, expressions::LiteralNode{-1}, expressions::LiteralNode{true});
+            break;
+          default:
+            states.push(State::IN_ERROR);
+            return false;
+        }
+
+        if (path.empty()) {
+          rootNode = std::move(node);
+          path.emplace(rootNode.get(), ToWrite::LEFT);
+        } else {
+          auto* n = path.top().ptr;
+          switch (path.top().toWrite) {
+            case ToWrite::LEFT:
+              n->left = std::move(node);
+              path.top().toWrite = ToWrite::RIGHT;
+              path.emplace(n->left.get(), ToWrite::LEFT);
+              break;
+            case ToWrite::RIGHT:
+              n->right = std::move(node);
+              path.top().toWrite = ToWrite::COND;
+              path.emplace(n->right.get(), ToWrite::LEFT);
+              break;
+            case ToWrite::COND:
+              n->condition = std::move(node);
+              path.pop();
+              path.emplace(n->condition.get(), ToWrite::LEFT);
+              break;
+            default:
+              states.push(State::IN_ERROR);
+              return false;
+          }
+        }
+
+        states.push(State::IN_LEFT);
+        return true;
+      }
+      if (currentKey.compare("right") == 0) {
+        if (states.top() == State::IN_LEFT) {
+          states.pop();
+        }
+        // move the stack state of the node to RIGHT state
+        path.top().toWrite = ToWrite::RIGHT;
+        states.push(State::IN_RIGHT);
+        return true;
+      }
+      if (currentKey.compare("condition") == 0) {
+        if (states.top() == State::IN_RIGHT) {
+          states.pop();
+        }
+        // move the stack state of the node to COND state
+        path.top().toWrite = ToWrite::COND;
+        states.push(State::IN_COND);
+        return true;
+      }
+    }
+
+    if (states.top() == State::IN_NODE_LITERAL) {
+      if (currentKey.compare("arrow_type") == 0 || currentKey.compare("value") == 0) {
+        return true;
+      }
+    }
+
+    if (states.top() == State::IN_NODE_BINDING) {
+      if (currentKey.compare("binding") == 0 || currentKey.compare("hash") == 0 || currentKey.compare("arrow_type") == 0) {
+        return true;
+      }
+    }
+
+    if (states.top() == State::IN_NODE_OP) {
+      if (currentKey.compare("operation") == 0) {
+        return true;
+      }
+    }
+
+    debug << ">>> Unrecognized" << std::endl;
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool StartObject()
+  {
+    // opening brace encountered
+    debug << "StartObject()" << std::endl;
+    // the first opening brace in the input
+    if (states.top() == State::IN_START) {
+      return true;
+    }
+    // the opening of an expression
+    if (states.top() == State::IN_LIST) {
+      states.push(State::IN_ROOT);
+      return true;
+    }
+    // if we are looking at subexpression
+    if (states.top() == State::IN_LEFT || states.top() == State::IN_RIGHT || states.top() == State::IN_COND) { // ready to start a new node
+      return true;
+    }
+    // no other object starts are expected
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool EndObject(SizeType)
+  {
+    // closing brace encountered
+    debug << "EndObject()" << std::endl;
+    // we are closing up an expression
+    if (states.top() == State::IN_NODE_LITERAL || states.top() == State::IN_NODE_OP || states.top() == State::IN_NODE_BINDING || states.top() == State::IN_NODE_CONDITIONAL) { // finalize node
+      // finalize the current node and pop it from the stack (the pointers should be already set
+      states.pop();
+      // subexpression
+      if (states.top() == State::IN_LEFT || states.top() == State::IN_RIGHT || states.top() == State::IN_COND) {
+        states.pop();
+        return true;
+      }
+
+      // expression
+      if (states.top() == State::IN_ROOT) {
+        result.emplace_back(std::move(rootNode));
+        states.pop();
+        return true;
+      }
+    }
+
+    // we are closing the list
+    if (states.top() == State::IN_START) {
+      return true;
+    }
+    // no other object ends are expectedd
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool Null()
+  {
+    // null value
+    debug << "Null()" << std::endl;
+    // the subexpression can be empty
+    if (states.top() == State::IN_LEFT || states.top() == State::IN_RIGHT || states.top() == State::IN_COND) {
+      // empty node, nothing to do
+      // move the path state to the next
+      if (path.top().toWrite == ToWrite::LEFT) {
+        path.top().toWrite = ToWrite::RIGHT;
+      } else if (path.top().toWrite == ToWrite::RIGHT) {
+        path.top().toWrite = ToWrite::COND;
+      } else if (path.top().toWrite == ToWrite::COND) {
+        path.pop();
+      }
+
+      states.pop();
+      return true;
+    }
+    states.push(State::IN_ERROR); // no other contexts allow null
+    return false;
+  }
+
+  bool Bool(bool b)
+  {
+    debug << "Bool(" << b << ")" << std::endl;
+    // can be a value in a literal node
+    if (states.top() == State::IN_NODE_LITERAL && currentKey.compare("value") == 0) {
+      value = b;
+      return true;
+    }
+    states.push(State::IN_ERROR); // no other contexts allow booleans
+    return false;
+  }
+
+  bool Int(int i)
+  {
+    debug << "Int(" << i << ")" << std::endl;
+    // can be a value in a literal node
+    if (states.top() == State::IN_NODE_LITERAL && currentKey.compare("value") == 0) { // literal
+      switch (type) {
+        case atype::INT8:
+          value = (int8_t)i;
+          break;
+        case atype::INT16:
+          value = (int16_t)i;
+          break;
+        case atype::INT32:
+          value = i;
+          break;
+        case atype::UINT8:
+          value = (uint8_t)i;
+          break;
+        case atype::UINT16:
+          value = (uint16_t)i;
+          break;
+        case atype::UINT32:
+          value = (uint32_t)i;
+          break;
+        default:
+          states.push(State::IN_ERROR);
+          return false;
+      }
+      return true;
+    }
+    // can be a node kind designator
+    if (states.top() == State::IN_ROOT || states.top() == State::IN_LEFT || states.top() == State::IN_RIGHT || states.top() == State::IN_COND) {
+      if (currentKey.compare("kind") == 0) {
+        kind = (Nodes)i;
+        switch (kind) {
+          case Nodes::NLITERAL:
+          case Nodes::NNPH:
+          case Nodes::NPAR: {
+            states.push(State::IN_NODE_LITERAL);
+            debug << ">>> Literal node" << std::endl;
+            return true;
+          }
+          case Nodes::NBINDING: {
+            states.push(State::IN_NODE_BINDING);
+            debug << ">>> Binding node" << std::endl;
+            return true;
+          }
+          case Nodes::NOP: {
+            states.push(State::IN_NODE_OP);
+            debug << ">>> Operation node" << std::endl;
+            return true;
+          }
+          case Nodes::NCOND: {
+            states.push(State::IN_NODE_CONDITIONAL);
+            debug << ">>> Conditional node" << std::endl;
+            return true;
+          }
+        }
+      }
+    }
+    // can be node index
+    if (states.top() == State::IN_NODE_BINDING || states.top() == State::IN_NODE_CONDITIONAL || states.top() == State::IN_NODE_LITERAL || states.top() == State::IN_NODE_OP) {
+      if (currentKey.compare("index") == 0) {
+        index = (size_t)i;
+        return true;
+      }
+    }
+    // can be a node type designator
+    if (states.top() == State::IN_NODE_LITERAL || states.top() == State::IN_NODE_BINDING) {
+      if (currentKey.compare("arrow_type") == 0) {
+        type = (atype::type)i;
+        return true;
+      }
+    }
+    // can be a node operation designato
+    if (states.top() == State::IN_NODE_OP && currentKey.compare("operation") == 0) {
+      operation = (BasicOp)i;
+      return true;
+    }
+    states.push(State::IN_ERROR); // no other contexts allow ints
+    return false;
+  }
+
+  bool Uint(unsigned i)
+  {
+    debug << "Uint(" << i << ")" << std::endl;
+    // can be node hash
+    if (states.top() == State::IN_NODE_BINDING && currentKey.compare("hash") == 0) {
+      hash = i;
+      return true;
+    }
+    // any positive value will be first read as unsigned, however the actual type is determined by node's arrow_type
+    debug << ">> falling back to Int" << std::endl;
+    return Int(i);
+  }
+
+  bool Int64(int64_t i)
+  {
+    debug << "Int64(" << i << ")" << std::endl;
+    // can only be a literal node value
+    if (states.top() == State::IN_NODE_LITERAL && currentKey.compare("value") == 0) {
+      switch (type) {
+        case atype::UINT64:
+          value = (uint64_t)i;
+          break;
+        case atype::INT64:
+          value = (int64_t)i;
+          break;
+        default:
+          states.push(State::IN_ERROR);
+          return false;
+      }
+      return true;
+    }
+    states.push(State::IN_ERROR); // no other contexts allow int64s
+    return false;
+  }
+
+  bool Uint64(uint64_t i)
+  {
+    debug << "Uint64(" << i << ")" << std::endl;
+    // any positive value will be first read as unsigned, however the actual type is determined by node's arrow_type
+    debug << ">> falling back to Int64" << std::endl;
+    return Int64(i);
+  }
+
+  bool Double(double d)
+  {
+    debug << "Double(" << d << ")" << std::endl;
+    // can only be a literal node value
+    if (states.top() == State::IN_NODE_LITERAL) {
+      switch (type) {
+        case atype::FLOAT:
+          value = (float)d;
+          break;
+        case atype::DOUBLE:
+          value = d;
+          break;
+        default:
+          states.push(State::IN_ERROR);
+          return false;
+      }
+      return true;
+    }
+    states.push(State::IN_ERROR); // no other contexts allow doubles
+    return false;
+  }
+
+  bool String(const Ch* str, SizeType, bool)
+  {
+    debug << "String(" << str << ")" << std::endl;
+    // can only be a binding node
+    if (states.top() == State::IN_NODE_BINDING && currentKey.compare("binding") == 0) {
+      binding = str;
+      return true;
+    }
+    states.push(State::IN_ERROR); // no strings are expected
+    return false;
+  }
+};
+} // namespace
+
+std::vector<expressions::Projector> o2::framework::ExpressionJSONHelpers::read(std::istream& s)
+{
+  rapidjson::Reader reader;
+  rapidjson::IStreamWrapper isw(s);
+  ExpressionReader ereader;
+  bool ok = reader.Parse(isw, ereader);
+
+  if (!ok) {
+    throw framework::runtime_error_f("Cannot parse serialized Expression, error: %s at offset: %d", rapidjson::GetParseError_En(reader.GetParseErrorCode()), reader.GetErrorOffset());
+  }
+  return std::move(ereader.result);
+}
+
+namespace
+{
+void writeNodeHeader(rapidjson::Writer<rapidjson::OStreamWrapper>& w, expressions::Node const* node)
+{
+  w.Key("kind");
+  w.Int((int)node->self.index());
+  w.Key("index");
+  w.Uint64(node->index);
+  std::visit(overloaded{
+               [&w](expressions::LiteralNode const& node) {
+                 w.Key("arrow_type");
+                 w.Int(node.type);
+                 w.Key("value");
+                 std::visit(overloaded{
+                              [&w](bool v) { w.Bool(v); },
+                              [&w](float v) { w.Double(v); },
+                              [&w](double v) { w.Double(v); },
+                              [&w](uint8_t v) { w.Uint(v); },
+                              [&w](uint16_t v) { w.Uint(v); },
+                              [&w](uint32_t v) { w.Uint(v); },
+                              [&w](uint64_t v) { w.Uint64(v); },
+                              [&w](int8_t v) { w.Int(v); },
+                              [&w](int16_t v) { w.Int(v); },
+                              [&w](int v) { w.Int(v); },
+                              [&w](int64_t v) { w.Int64(v); }},
+                            node.value);
+               },
+               [&w](expressions::BindingNode const& node) {
+                 w.Key("binding");
+                 w.String(node.name);
+                 w.Key("hash");
+                 w.Uint(node.hash);
+                 w.Key("arrow_type");
+                 w.Int(node.type);
+               },
+               [&w](expressions::OpNode const& node) {
+                 w.Key("operation");
+                 w.Int(node.op);
+               },
+               [](expressions::ConditionalNode const&) {
+               }},
+             node->self);
+}
+
+void writeExpression(rapidjson::Writer<rapidjson::OStreamWrapper>& w, expressions::Node* n)
+{
+  std::stack<Entry> path;
+  path.emplace(n, ToWrite::FULL);
+  while (!path.empty()) {
+    auto& top = path.top();
+
+    if (top.toWrite == ToWrite::FULL) {
+      w.StartObject();
+      writeNodeHeader(w, top.ptr);
+      top.toWrite = ToWrite::LEFT;
+      continue;
+    }
+
+    if (top.toWrite == ToWrite::LEFT) {
+      w.Key("left");
+      top.toWrite = ToWrite::RIGHT;
+      auto* left = top.ptr->left.get();
+      if (left != nullptr) {
+        path.emplace(left, ToWrite::FULL);
+      } else {
+        w.Null();
+      }
+      continue;
+    }
+
+    if (top.toWrite == ToWrite::RIGHT) {
+      w.Key("right");
+      top.toWrite = ToWrite::COND;
+      auto* right = top.ptr->right.get();
+      if (right != nullptr) {
+        path.emplace(right, ToWrite::FULL);
+      } else {
+        w.Null();
+      }
+      continue;
+    }
+
+    if (top.toWrite == ToWrite::COND) {
+      w.Key("condition");
+      top.toWrite = ToWrite::POP;
+      auto* cond = top.ptr->condition.get();
+      if (cond != nullptr) {
+        path.emplace(cond, ToWrite::FULL);
+      } else {
+        w.Null();
+      }
+      continue;
+    }
+
+    if (top.toWrite == ToWrite::POP) {
+      w.EndObject();
+      path.pop();
+      continue;
+    }
+  }
+}
+} // namespace
+
+void o2::framework::ExpressionJSONHelpers::write(std::ostream& o, std::vector<o2::framework::expressions::Projector>& projectors)
+{
+  rapidjson::OStreamWrapper osw(o);
+  rapidjson::Writer<rapidjson::OStreamWrapper> w(osw);
+  w.StartObject();
+  w.Key("projectors");
+  w.StartArray();
+  for (auto& p : projectors) {
+    writeExpression(w, p.node.get());
+  }
+  w.EndArray();
+  w.EndObject();
+}
+
+namespace
+{
+struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, SchemaReader> {
+  using Ch = rapidjson::UTF8<>::Ch;
+  using SizeType = rapidjson::SizeType;
+
+  enum struct State {
+    IN_START,
+    IN_LIST,
+    IN_FIELD,
+    IN_ERROR
+  };
+
+  std::stack<State> states;
+  std::ostringstream debug;
+
+  std::shared_ptr<arrow::Schema> schema = nullptr;
+  std::vector<std::shared_ptr<arrow::Field>> fields;
+
+  std::string currentKey;
+
+  std::string name;
+  atype::type type;
+
+  SchemaReader()
+  {
+    debug << ">>> Start" << std::endl;
+    states.push(State::IN_START);
+  }
+
+  bool StartArray()
+  {
+    debug << "Starting array" << std::endl;
+    if (states.top() == State::IN_START && currentKey.compare("fields") == 0) {
+      states.push(State::IN_LIST);
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool EndArray(SizeType)
+  {
+    debug << "Ending array" << std::endl;
+    if (states.top() == State::IN_LIST) {
+      // finalize schema
+      schema = std::make_shared<arrow::Schema>(fields);
+      states.pop();
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool Key(const Ch* str, SizeType, bool)
+  {
+    debug << "Key(" << str << ")" << std::endl;
+    currentKey = str;
+    if (states.top() == State::IN_START) {
+      if (currentKey.compare("fields") == 0) {
+        return true;
+      }
+    }
+
+    if (states.top() == State::IN_FIELD) {
+      if (currentKey.compare("name") == 0) {
+        return true;
+      }
+      if (currentKey.compare("type") == 0) {
+        return true;
+      }
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool StartObject()
+  {
+    debug << "StartObject()" << std::endl;
+    if (states.top() == State::IN_START) {
+      return true;
+    }
+
+    if (states.top() == State::IN_LIST) {
+      states.push(State::IN_FIELD);
+      return true;
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool EndObject(SizeType)
+  {
+    debug << "EndObject()" << std::endl;
+    if (states.top() == State::IN_FIELD) {
+      states.pop();
+      // add a field
+      fields.emplace_back(std::make_shared<arrow::Field>(name, expressions::concreteArrowType(type)));
+      return true;
+    }
+
+    if (states.top() == State::IN_START) {
+      return true;
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool Uint(unsigned i)
+  {
+    debug << "Uint(" << i << ")" << std::endl;
+    if (states.top() == State::IN_FIELD) {
+      if (currentKey.compare("type") == 0) {
+        type = (atype::type)i;
+        return true;
+      }
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool String(const Ch* str, SizeType, bool)
+  {
+    debug << "String(" << str << ")" << std::endl;
+    if (states.top() == State::IN_FIELD) {
+      if (currentKey.compare("name") == 0) {
+        name = str;
+        return true;
+      }
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool Int(int i)
+  {
+    debug << "Int(" << i << ")" << std::endl;
+    return Uint(i);
+  }
+};
+} // namespace
+
+std::shared_ptr<arrow::Schema> o2::framework::ArrowJSONHelpers::read(std::istream& s)
+{
+  rapidjson::Reader reader;
+  rapidjson::IStreamWrapper isw(s);
+  SchemaReader sreader;
+
+  bool ok = reader.Parse(isw, sreader);
+
+  if (!ok) {
+    throw framework::runtime_error_f("Cannot parse serialized Expression, error: %s at offset: %d", rapidjson::GetParseError_En(reader.GetParseErrorCode()), reader.GetErrorOffset());
+  }
+  return sreader.schema;
+}
+
+namespace
+{
+void writeSchema(rapidjson::Writer<rapidjson::OStreamWrapper>& w, arrow::Schema* schema)
+{
+  for (auto& f : schema->fields()) {
+    w.StartObject();
+    w.Key("name");
+    w.String(f->name().c_str());
+    w.Key("type");
+    w.Int(f->type()->id());
+    w.EndObject();
+  }
+}
+} // namespace
+
+void o2::framework::ArrowJSONHelpers::write(std::ostream& o, std::shared_ptr<arrow::Schema>& schema)
+{
+  rapidjson::OStreamWrapper osw(o);
+  rapidjson::Writer<rapidjson::OStreamWrapper> w(osw);
+  w.StartObject();
+  w.Key("fields");
+  w.StartArray();
+  writeSchema(w, schema.get());
+  w.EndArray();
+  w.EndObject();
+}
+
+} // namespace o2::framework
diff --git a/Framework/Core/src/ExpressionJSONHelpers.h b/Framework/Core/src/ExpressionJSONHelpers.h
new file mode 100644
index 0000000000000..ed4c51c58d5c2
--- /dev/null
+++ b/Framework/Core/src/ExpressionJSONHelpers.h
@@ -0,0 +1,29 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef FRAMEWORK_EXPRESSIONJSONHELPERS_H
+#define FRAMEWORK_EXPRESSIONJSONHELPERS_H
+
+#include "Framework/Expressions.h"
+
+namespace o2::framework
+{
+struct ExpressionJSONHelpers {
+  static std::vector<expressions::Projector> read(std::istream& s);
+  static void write(std::ostream& o, std::vector<expressions::Projector>& projectors);
+};
+
+struct ArrowJSONHelpers {
+  static std::shared_ptr<arrow::Schema> read(std::istream& s);
+  static void write(std::ostream& o, std::shared_ptr<arrow::Schema>& schema);
+};
+} // namespace o2::framework
+
+#endif // FRAMEWORK_EXPRESSIONJSONHELPERS_H
diff --git a/Framework/Core/src/TableBuilder.cxx b/Framework/Core/src/TableBuilder.cxx
index 2169722efa9da..7e256fb9f1712 100644
--- a/Framework/Core/src/TableBuilder.cxx
+++ b/Framework/Core/src/TableBuilder.cxx
@@ -130,6 +130,48 @@ std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const&
   return arrow::Table::Make(newSchema, arrays);
 }
 
+std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema,
+                                            const char* name, size_t nColumns,
+                                            std::shared_ptr<gandiva::Projector> const& projector)
+{
+  arrow::TableBatchReader reader(*fullTable);
+  std::shared_ptr<arrow::RecordBatch> batch;
+  arrow::ArrayVector v;
+  std::vector<arrow::ArrayVector> chunks;
+  chunks.resize(nColumns);
+  std::vector<std::shared_ptr<arrow::ChunkedArray>> arrays;
+
+  while (true) {
+    auto s = reader.ReadNext(&batch);
+    if (!s.ok()) {
+      throw runtime_error_f("Cannot read batches from source table to spawn %s: %s", name, s.ToString().c_str());
+    }
+    if (batch == nullptr) {
+      break;
+    }
+    try {
+      s = projector->Evaluate(*batch, arrow::default_memory_pool(), &v);
+      if (!s.ok()) {
+        throw runtime_error_f("Cannot apply projector to source table of %s: %s", name, s.ToString().c_str());
+      }
+    } catch (std::exception& e) {
+      throw runtime_error_f("Cannot apply projector to source table of %s: exception caught: %s", name, e.what());
+    }
+
+    for (auto i = 0U; i < nColumns; ++i) {
+      chunks[i].emplace_back(v.at(i));
+    }
+  }
+
+  arrays.reserve(nColumns);
+  for (auto i = 0U; i < nColumns; ++i) {
+    arrays.push_back(std::make_shared<arrow::ChunkedArray>(chunks[i]));
+  }
+
+  addLabelToSchema(newSchema, name);
+  return arrow::Table::Make(newSchema, arrays);
+}
+
 } // namespace o2::framework
 
 template class arrow::NumericBuilder<arrow::UInt8Type>;
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index d27753848d544..0b82e8265b604 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -38,6 +38,7 @@
 #include <utility>
 #include <vector>
 #include <climits>
+#include <numeric>
 
 O2_DECLARE_DYNAMIC_LOG(workflow_helpers);
 
@@ -435,7 +436,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     "internal-dpl-aod-spawner",
     {},
     {},
-    readers::AODReaderHelpers::aodSpawnerCallback(ac.spawnerInputs),
+    readers::AODReaderHelpers::aodSpawnerCallback(ctx),
     {}};
   AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, aodSpawner);
 
diff --git a/Framework/Core/test/test_Expressions.cxx b/Framework/Core/test/test_Expressions.cxx
index 4c6fc51795ca8..41be7d53d2276 100644
--- a/Framework/Core/test/test_Expressions.cxx
+++ b/Framework/Core/test/test_Expressions.cxx
@@ -12,6 +12,7 @@
 #include "Framework/Configurable.h"
 #include "Framework/ExpressionHelpers.h"
 #include "Framework/AnalysisDataModel.h"
+#include "../src/ExpressionJSONHelpers.h"
 #include <catch_amalgamated.hpp>
 #include <arrow/util/config.h>
 #include <iostream>
@@ -391,3 +392,66 @@ TEST_CASE("TestStringExpressionsParsing")
 
   REQUIRE(tree1c->ToString() == tree2c->ToString());
 }
+
+TEST_CASE("TestExpressionSerialization")
+{
+  Filter f = o2::aod::track::signed1Pt > 0.f && ifnode(nabs(o2::aod::track::eta) < 1.0f, nabs(o2::aod::track::x) > 2.0f, nabs(o2::aod::track::y) > 3.0f);
+  Projector p = -1.f * nlog(ntan(o2::constants::math::PIQuarter - 0.5f * natan(o2::aod::fwdtrack::tgl)));
+  Projector p1 = ifnode(o2::aod::track::itsClusterSizes > (uint32_t)0, static_cast<uint8_t>(o2::aod::track::ITS), (uint8_t)0x0) |
+                 ifnode(o2::aod::track::tpcNClsFindable > (uint8_t)0, static_cast<uint8_t>(o2::aod::track::TPC), (uint8_t)0x0) |
+                 ifnode(o2::aod::track::trdPattern > (uint8_t)0, static_cast<uint8_t>(o2::aod::track::TRD), (uint8_t)0x0) |
+                 ifnode((o2::aod::track::tofChi2 >= 0.f) && (o2::aod::track::tofExpMom > 0.f), static_cast<uint8_t>(o2::aod::track::TOF), (uint8_t)0x0);
+
+  std::vector<Projector> projectors;
+  projectors.emplace_back(std::move(f));
+  projectors.emplace_back(std::move(p));
+  projectors.emplace_back(std::move(p1));
+
+  std::stringstream osm;
+  ExpressionJSONHelpers::write(osm, projectors);
+
+  std::stringstream ism;
+  ism.str(osm.str());
+  auto ps = ExpressionJSONHelpers::read(ism);
+
+  auto s1 = createOperations(projectors[0]);
+  auto s2 = createOperations(ps[0]);
+  auto schemaf = std::make_shared<arrow::Schema>(std::vector{o2::aod::track::Eta::asArrowField(), o2::aod::track::Signed1Pt::asArrowField(), o2::aod::track::X::asArrowField(), o2::aod::track::Y::asArrowField()});
+  auto t1 = createExpressionTree(s1, schemaf);
+  auto t2 = createExpressionTree(s2, schemaf);
+  REQUIRE(t1->ToString() == t2->ToString());
+
+  auto s12 = createOperations(projectors[1]);
+  auto s22 = createOperations(ps[1]);
+  auto schemap = std::make_shared<arrow::Schema>(std::vector{o2::aod::fwdtrack::Tgl::asArrowField()});
+  auto t12 = createExpressionTree(s12, schemap);
+  auto t22 = createExpressionTree(s22, schemap);
+  REQUIRE(t12->ToString() == t22->ToString());
+
+  auto s13 = createOperations(projectors[2]);
+  auto s23 = createOperations(ps[2]);
+  auto schemap1 = std::make_shared<arrow::Schema>(std::vector{o2::aod::track::ITSClusterSizes::asArrowField(), o2::aod::track::TPCNClsFindable::asArrowField(),
+                                                              o2::aod::track::TRDPattern::asArrowField(), o2::aod::track::TOFChi2::asArrowField(),
+                                                              o2::aod::track::TOFExpMom::asArrowField()});
+  auto t13 = createExpressionTree(s13, schemap1);
+  auto t23 = createExpressionTree(s23, schemap1);
+  REQUIRE(t13->ToString() == t23->ToString());
+
+  osm.clear();
+  osm.str("");
+  ArrowJSONHelpers::write(osm, schemaf);
+
+  ism.clear();
+  ism.str(osm.str());
+  auto newSchemaf = ArrowJSONHelpers::read(ism);
+  REQUIRE(schemaf->ToString() == newSchemaf->ToString());
+
+  osm.clear();
+  osm.str("");
+  ArrowJSONHelpers::write(osm, schemap);
+
+  ism.clear();
+  ism.str(osm.str());
+  auto newSchemap = ArrowJSONHelpers::read(ism);
+  REQUIRE(schemap->ToString() == newSchemap->ToString());
+}

From 710bcf0c42a26a83bf2e43c6add6d03e3f688684 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 12 Nov 2025 15:45:25 +0100
Subject: [PATCH 1025/1764] Use TRACK_SOURCES_GLO for svertexing in online mode

---
 prodtests/full-system-test/dpl-workflow.sh | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index d2ba3c7ecf9fe..ce5607d361cbe 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -628,6 +628,12 @@ has_detector_reco ITS && has_detector_gpu ITS TPC && [[ -z "$DISABLE_ROOT_OUTPUT
 ( [[ $BEAMTYPE == "cosmic" ]] || ! has_detector_reco ITS) && PVERTEX_CONFIG+=" --skip"
 has_detector_matching PRIMVTX && [[ -n "$VERTEXING_SOURCES" ]] && [[ $GLOBAL_READER_NEEDS_PV != 1 ]] && add_W o2-primary-vertexing-workflow "$DISABLE_MC $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $PVERTEX_CONFIG --pipeline $(get_N primary-vertexing MATCH REST 1 PRIMVTX),$(get_N pvertex-track-matching MATCH REST 1 PRIMVTXMATCH)" "${PVERTEXING_CONFIG_KEY};${INTERACTION_TAG_CONFIG_KEY};"
 
+if [[ -z ${SVERTEXING_SOURCES:-} ]]; then
+  [[ $SYNCMODE == 1 ]] && [[ -n $TRACK_SOURCES_GLO ]] && SVERTEXING_SOURCES="$TRACK_SOURCES_GLO" || SVERTEXING_SOURCES="$VERTEXING_SOURCES"
+elif [[ "${SVERTEXING_SOURCES^^}" == "NONE" ]]; then
+  SVERTEXING_SOURCES=
+fi
+
 if [[ $BEAMTYPE != "cosmic" ]] && has_detectors_reco ITS && has_detector_matching SECVTX && [[ -n "$SVERTEXING_SOURCES" ]]; then
   : ${REDUCESV_OPT:=}
   : ${REDUCESV_CONF:=}

From 3e4c7b1ba3df3c3906b73d752bb23fce06464dc6 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sat, 15 Nov 2025 01:23:43 +0100
Subject: [PATCH 1026/1764] EncodedBlocks should report real output size, not
 the allocated buffer

---
 .../include/DetectorsCommonDataFormats/EncodedBlocks.h       | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h
index a83c8f13deca4..ba6b853f7fb23 100644
--- a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h
+++ b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h
@@ -468,6 +468,9 @@ class EncodedBlocks
   /// total allocated size in bytes
   size_t size() const { return mRegistry.size; }
 
+  /// used part of total allocated size in bytes (output size)
+  size_t outputsize() const { return mRegistry.offsFreeStart; }
+
   /// size remaining for additional data
   size_t getFreeSize() const { return mRegistry.getFreeSize(); }
 
@@ -899,7 +902,7 @@ void EncodedBlocks<H, N, W>::print(const std::string& prefix, int verbosity) con
       ndata += mBlocks[i].getNData();
       nlit += mBlocks[i].getNLiterals();
     }
-    LOG(info) << prefix << N << " blocks, input size: " << inpSize << ", output size: " << size()
+    LOG(info) << prefix << N << " blocks, input size: " << inpSize << ", output size: " << outputsize()
               << " NDictWords: " << ndict << " NDataWords: " << ndata << " NLiteralWords: " << nlit;
   }
 }

From 7d8420aec6d3a41f08182d653477c5a57c8e788d Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sat, 15 Nov 2025 01:27:48 +0100
Subject: [PATCH 1027/1764] Allow to SVertexer to use global tracks only (e.g.
 for online mode)

---
 .../GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx   | 2 +-
 Detectors/Vertexing/src/SVertexer.cxx                       | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
index 043fe0e659ba6..ea566f15a0b59 100644
--- a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
@@ -255,7 +255,7 @@ DataProcessorSpec getSecondaryVertexingSpec(GTrackID::mask_t src, bool enableCas
     src |= (srcClus = GTrackID::getSourceMask(GTrackID::ITS));
   }
   if (GTrackID::includesDet(o2::detectors::DetID::TPC, src) && !src[GTrackID::TPC]) {
-    throw std::runtime_error("Tracks involving TPC were requested w/o requesting TPC-only tracks");
+    LOGP(warn, "Tracks involving TPC were requested w/o requesting TPC-only tracks, simplified selection will be applied");
   }
   if (src[GTrackID::TPC]) {
     srcClus |= GTrackID::getSourceMask(GTrackID::TPC);
diff --git a/Detectors/Vertexing/src/SVertexer.cxx b/Detectors/Vertexing/src/SVertexer.cxx
index 1d48bcceb0097..d9206fe54e068 100644
--- a/Detectors/Vertexing/src/SVertexer.cxx
+++ b/Detectors/Vertexing/src/SVertexer.cxx
@@ -269,6 +269,9 @@ void SVertexer::updateTimeDependentParams()
   if (!updatedOnce) {
     updatedOnce = true;
     mSVParams = &SVertexerParams::Instance();
+    if (mSVParams->mExcludeTPCtracks && !mRecoCont->isTrackSourceLoaded(GIndex::TPC)) {
+      LOGP(fatal, "TPC tracks requested but not provided");
+    }
     // precalculated selection cuts
     mMinR2ToMeanVertex = mSVParams->minRToMeanVertex * mSVParams->minRToMeanVertex;
     mMaxR2ToMeanVertexCascV0 = mSVParams->maxRToMeanVertexCascV0 * mSVParams->maxRToMeanVertexCascV0;
@@ -543,8 +546,7 @@ void SVertexer::buildT2V(const o2::globaltracking::RecoContainer& recoData) // a
         }
         continue;
       }
-
-      if (!hasTPC && nITSclu < mSVParams->mITSSAminNclu && (!shortOBITSOnlyTrack || mSVParams->mRejectITSonlyOBtrack)) {
+      if ((isTPCloaded && !hasTPC) && (isITSloaded && (nITSclu < mSVParams->mITSSAminNclu && (!shortOBITSOnlyTrack || mSVParams->mRejectITSonlyOBtrack)))) {
         continue; // reject short ITS-only
       }
 

From 73a1f60e27c48e90d4a3eccb8d197e454b4176f9 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 14 Nov 2025 14:58:58 +0100
Subject: [PATCH 1028/1764] DPL: fix timeslice rate limiting issues

---
 .../src/AODJAlienReaderHelpers.cxx            |  6 ++-
 .../include/Framework/CommonDataProcessors.h  |  1 +
 .../include/Framework/DataProcessingStats.h   |  8 ++-
 Framework/Core/src/ArrowSupport.cxx           | 51 +++++++++++++++++--
 Framework/Core/src/CommonDataProcessors.cxx   | 40 +++++++++++++--
 Framework/Core/src/CommonServices.cxx         | 20 +++++++-
 .../Core/src/ComputingQuotaEvaluator.cxx      | 15 +++---
 Framework/Core/src/DataProcessingDevice.cxx   |  4 +-
 Framework/Core/src/DataProcessingStats.cxx    | 10 ++++
 Framework/Core/src/WorkflowHelpers.cxx        |  5 +-
 10 files changed, 140 insertions(+), 20 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
index 1d4ae5a4d3c49..b532c51b8d307 100644
--- a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
@@ -199,7 +199,7 @@ AlgorithmSpec AODJAlienReaderHelpers::rootFileReaderCallback(ConfigContext const
                            numTF,
                            watchdog,
                            maxRate,
-                           didir, reportTFN, reportTFFileName](Monitoring& monitoring, DataAllocator& outputs, ControlService& control, DeviceSpec const& device) {
+                           didir, reportTFN, reportTFFileName](Monitoring& monitoring, DataAllocator& outputs, ControlService& control, DeviceSpec const& device, DataProcessingStats& dpstats) {
       // Each parallel reader device.inputTimesliceId reads the files fileCounter*device.maxInputTimeslices+device.inputTimesliceId
       // the TF to read is numTF
       assert(device.inputTimesliceId < device.maxInputTimeslices);
@@ -302,6 +302,10 @@ AlgorithmSpec AODJAlienReaderHelpers::rootFileReaderCallback(ConfigContext const
         }
       }
       totalDFSent++;
+
+      // Use the new API for sending TIMESLICE_NUMBER_STARTED
+      dpstats.updateStats({(int)ProcessingStatsId::TIMESLICE_NUMBER_STARTED, DataProcessingStats::Op::Add, 1});
+      dpstats.processCommandQueue();
       monitoring.send(Metric{(uint64_t)totalDFSent, "df-sent"}.addTag(Key::Subsystem, monitoring::tags::Value::DPL));
       monitoring.send(Metric{(uint64_t)totalSizeUncompressed / 1000, "aod-bytes-read-uncompressed"}.addTag(Key::Subsystem, monitoring::tags::Value::DPL));
       monitoring.send(Metric{(uint64_t)totalSizeCompressed / 1000, "aod-bytes-read-compressed"}.addTag(Key::Subsystem, monitoring::tags::Value::DPL));
diff --git a/Framework/Core/include/Framework/CommonDataProcessors.h b/Framework/Core/include/Framework/CommonDataProcessors.h
index d3ef596a0c0e0..48e240c59e5d2 100644
--- a/Framework/Core/include/Framework/CommonDataProcessors.h
+++ b/Framework/Core/include/Framework/CommonDataProcessors.h
@@ -41,6 +41,7 @@ struct CommonDataProcessors {
   /// and simply discards them. Rate limiting goes through the DPL driver
   static DataProcessorSpec getScheduledDummySink(std::vector<InputSpec> const& danglingInputs);
   static AlgorithmSpec wrapWithRateLimiting(AlgorithmSpec spec);
+  static AlgorithmSpec wrapWithTimesliceConsumption(AlgorithmSpec spec);
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/include/Framework/DataProcessingStats.h b/Framework/Core/include/Framework/DataProcessingStats.h
index e115e5d12b58f..e32523c9abb08 100644
--- a/Framework/Core/include/Framework/DataProcessingStats.h
+++ b/Framework/Core/include/Framework/DataProcessingStats.h
@@ -57,13 +57,15 @@ enum struct ProcessingStatsId : short {
   CPU_USAGE_FRACTION,
   ARROW_BYTES_CREATED,
   ARROW_BYTES_DESTROYED,
+  ARROW_BYTES_EXPIRED,
   ARROW_MESSAGES_CREATED,
   ARROW_MESSAGES_DESTROYED,
-  ARROW_BYTES_EXPIRED,
+  TIMESLICE_OFFER_NUMBER_CONSUMED,
+  TIMESLICE_NUMBER_STARTED,
   TIMESLICE_NUMBER_EXPIRED,
+  TIMESLICE_NUMBER_DONE,
   RESOURCE_OFFER_EXPIRED,
   SHM_OFFER_BYTES_CONSUMED,
-  TIMESLICE_OFFER_NUMBER_CONSUMED,
   RESOURCES_MISSING,
   RESOURCES_INSUFFICIENT,
   RESOURCES_SATISFACTORY,
@@ -172,9 +174,11 @@ struct DataProcessingStats {
   };
 
   void registerMetric(MetricSpec const& spec);
+
   // Update some stats as specified by the @cmd cmd
   void updateStats(CommandSpec cmd);
 
+  char const* findMetricNameById(ProcessingStatsId id) const;
   /// This will process the queue of commands required to update the stats.
   /// It is meant to be called periodically by a single thread.
   void processCommandQueue();
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index cc164a77870e0..1480a64b6fcc2 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -79,6 +79,10 @@ struct MetricIndices {
   size_t timeframesRead = -1;
   size_t timeframesConsumed = -1;
   size_t timeframesExpired = -1;
+  // Timeslices counting
+  size_t timeslicesStarted = -1;
+  size_t timeslicesExpired = -1;
+  size_t timeslicesDone = -1;
 };
 
 std::vector<MetricIndices> createDefaultIndices(std::vector<DeviceMetricsInfo>& allDevicesMetrics)
@@ -95,7 +99,11 @@ std::vector<MetricIndices> createDefaultIndices(std::vector<DeviceMetricsInfo>&
       .shmOfferBytesConsumed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "shm-offer-bytes-consumed"),
       .timeframesRead = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "df-sent"),
       .timeframesConsumed = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "consumed-timeframes"),
-      .timeframesExpired = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "expired-timeframes")});
+      .timeframesExpired = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "expired-timeframes"),
+      .timeslicesStarted = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "timeslices-started"),
+      .timeslicesExpired = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "timeslices-expired"),
+      .timeslicesDone = DeviceMetricsHelper::bookNumericMetric<uint64_t>(info, "timeslices-done"),
+    });
   }
   return results;
 }
@@ -230,6 +238,19 @@ auto offerResources(ResourceState& resourceState,
   offeredResourceMetric(driverMetrics, resourceState.offered, timestamp);
 };
 
+auto processTimeslices = [](size_t index, DeviceMetricsInfo& deviceMetrics, bool& changed,
+                            int64_t& totalMetricValue, size_t& lastTimestamp) {
+  assert(index < deviceMetrics.metrics.size());
+  changed |= deviceMetrics.changed[index];
+  MetricInfo info = deviceMetrics.metrics[index];
+  assert(info.storeIdx < deviceMetrics.uint64Metrics.size());
+  auto& data = deviceMetrics.uint64Metrics[info.storeIdx];
+  auto value = (int64_t)data[(info.pos - 1) % data.size()];
+  totalMetricValue += value;
+  auto const& timestamps = DeviceMetricsHelper::getTimestampsStore<uint64_t>(deviceMetrics)[info.storeIdx];
+  lastTimestamp = std::max(lastTimestamp, timestamps[(info.pos - 1) % data.size()]);
+};
+
 o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
 {
   using o2::monitoring::Metric;
@@ -257,11 +278,22 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        int64_t totalTimeframesRead = 0;
                        int64_t totalTimeframesConsumed = 0;
                        int64_t totalTimeframesExpired = 0;
+                       int64_t totalTimeslicesStarted = 0;
+                       int64_t totalTimeslicesDone = 0;
+                       int64_t totalTimeslicesExpired = 0;
                        auto &driverMetrics = sm.driverMetricsInfo;
                        auto &allDeviceMetrics = sm.deviceMetricsInfos;
                        auto &specs = sm.deviceSpecs;
                        auto &infos = sm.deviceInfos;
 
+                       // Aggregated driver metrics for timeslice rate limiting
+                       auto createUint64DriverMetric = [&driverMetrics](char const*name) -> auto {
+                          return DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, name);
+                       };
+                       auto createIntDriverMetric = [&driverMetrics](char const*name) -> auto {
+                          return DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, name);
+                       };
+
                        static auto stateMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "rate-limit-state");
                        static auto totalBytesCreatedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-arrow-bytes-created");
                        static auto shmOfferConsumedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-shm-offer-bytes-consumed");
@@ -280,6 +312,12 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        static auto totalTimeframesReadMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-timeframes-read");
                        static auto totalTimeframesConsumedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-timeframes-consumed");
                        static auto totalTimeframesInFlyMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-timeframes-in-fly");
+
+                       static auto totalTimeslicesStartedMetric = createUint64DriverMetric("total-timeslices-started");
+                       static auto totalTimeslicesExpiredMetric = createUint64DriverMetric("total-timeslices-expired");
+                       static auto totalTimeslicesDoneMetric = createUint64DriverMetric("total-timeslices-done");
+                       static auto totalTimeslicesInFlyMetric = createIntDriverMetric("total-timeslices-in-fly");
+
                        static auto totalBytesDeltaMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "arrow-bytes-delta");
                        static auto changedCountMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "changed-metrics-count");
                        static auto totalSignalsMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "aod-reader-signals");
@@ -406,6 +444,9 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                            auto const& timestamps = DeviceMetricsHelper::getTimestampsStore<uint64_t>(deviceMetrics)[info.storeIdx];
                            lastTimestamp = std::max(lastTimestamp, timestamps[(info.pos - 1) % data.size()]);
                          }
+                         processTimeslices(indices.timeslicesStarted, deviceMetrics, changed, totalTimeslicesStarted, lastTimestamp);
+                         processTimeslices(indices.timeslicesExpired, deviceMetrics, changed, totalTimeslicesExpired, lastTimestamp);
+                         processTimeslices(indices.timeslicesDone, deviceMetrics, changed, totalTimeslicesDone, lastTimestamp);
                        }
                        static uint64_t unchangedCount = 0;
                        if (changed) {
@@ -418,6 +459,10 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                          totalTimeframesReadMetric(driverMetrics, totalTimeframesRead, timestamp);
                          totalTimeframesConsumedMetric(driverMetrics, totalTimeframesConsumed, timestamp);
                          totalTimeframesInFlyMetric(driverMetrics, (int)(totalTimeframesRead - totalTimeframesConsumed), timestamp);
+                         totalTimeslicesStartedMetric(driverMetrics, totalTimeslicesStarted, timestamp);
+                         totalTimeslicesExpiredMetric(driverMetrics, totalTimeslicesExpired, timestamp);
+                         totalTimeslicesDoneMetric(driverMetrics, totalTimeslicesDone, timestamp);
+                         totalTimeslicesInFlyMetric(driverMetrics, (int)(totalTimeslicesStarted - totalTimeslicesDone), timestamp);
                          totalBytesDeltaMetric(driverMetrics, totalBytesCreated - totalBytesExpired - totalBytesDestroyed, timestamp);
                        } else {
                          unchangedCount++;
@@ -458,8 +503,8 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        };
 
                        offerResources(timesliceResourceState, timesliceResourceSpec, timesliceResourceStats,
-                                      specs, infos, manager, totalTimeframesConsumed, totalTimeframesExpired,
-                                      totalTimeframesRead, totalTimeframesConsumed, timestamp, driverMetrics,
+                                      specs, infos, manager, totalTimeframesConsumed, totalTimeslicesExpired,
+                                      totalTimeslicesStarted, totalTimeslicesDone, timestamp, driverMetrics,
                                       availableTimeslicesMetric, unusedOfferedTimeslicesMetric, offeredTimeslicesMetric,
                                       (void*)&sm);
 
diff --git a/Framework/Core/src/CommonDataProcessors.cxx b/Framework/Core/src/CommonDataProcessors.cxx
index 5d99fd3db7578..67c6314de1c34 100644
--- a/Framework/Core/src/CommonDataProcessors.cxx
+++ b/Framework/Core/src/CommonDataProcessors.cxx
@@ -45,6 +45,7 @@ using namespace o2::framework::data_matcher;
 // Special log to track callbacks we know about
 O2_DECLARE_DYNAMIC_LOG(callbacks);
 O2_DECLARE_DYNAMIC_LOG(rate_limiting);
+O2_DECLARE_DYNAMIC_LOG(quota);
 
 namespace o2::framework
 {
@@ -212,7 +213,7 @@ DataProcessorSpec CommonDataProcessors::getDummySink(std::vector<InputSpec> cons
         auto oldestPossingTimeslice = timesliceIndex.getOldestPossibleOutput().timeslice.value;
         auto& stats = services.get<DataProcessingStats>();
         stats.updateStats({(int)ProcessingStatsId::CONSUMED_TIMEFRAMES, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
-        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_NUMBER_DONE, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
         stats.processCommandQueue();
       };
       callbacks.set<CallbackService::Id::DomainInfoUpdated>(domainInfoUpdated);
@@ -247,7 +248,7 @@ DataProcessorSpec CommonDataProcessors::getScheduledDummySink(std::vector<InputS
         O2_SIGNPOST_ID_GENERATE(sid, rate_limiting);
         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "run", "Consumed timeframes (domain info updated) to be set to %zu.", oldestPossingTimeslice);
         stats.updateStats({(int)ProcessingStatsId::CONSUMED_TIMEFRAMES, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
-        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_NUMBER_DONE, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
         stats.processCommandQueue();
       };
       callbacks.set<CallbackService::Id::DomainInfoUpdated>(domainInfoUpdated);
@@ -257,7 +258,8 @@ DataProcessorSpec CommonDataProcessors::getScheduledDummySink(std::vector<InputS
         auto oldestPossingTimeslice = timesliceIndex.getOldestPossibleOutput().timeslice.value;
         O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "run", "Consumed timeframes (processing) to be set to %zu.", oldestPossingTimeslice);
         stats.updateStats({(int)ProcessingStatsId::CONSUMED_TIMEFRAMES, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
-        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.updateStats({(int)ProcessingStatsId::TIMESLICE_NUMBER_DONE, DataProcessingStats::Op::Set, (int64_t)oldestPossingTimeslice});
+        stats.processCommandQueue();
       });
     })},
     .labels = {{"resilient"}}};
@@ -281,4 +283,36 @@ AlgorithmSpec CommonDataProcessors::wrapWithRateLimiting(AlgorithmSpec spec)
   });
 }
 
+// The wrapped algorithm consumes 1 timeslice every time is invoked
+AlgorithmSpec CommonDataProcessors::wrapWithTimesliceConsumption(AlgorithmSpec spec)
+{
+  return PluginManager::wrapAlgorithm(spec, [](AlgorithmSpec::ProcessCallback& original, ProcessingContext& pcx) -> void {
+    original(pcx);
+
+    auto disposeResources = [](int taskId,
+                               std::array<ComputingQuotaOffer, 32>& offers,
+                               ComputingQuotaStats& stats,
+                               std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats&)> accountDisposed) {
+      ComputingQuotaOffer disposed;
+      disposed.sharedMemory = 0;
+      // When invoked, we have processed one timeslice by construction.
+      int64_t timeslicesProcessed = 1;
+      for (auto& offer : offers) {
+        if (offer.user != taskId) {
+          continue;
+        }
+        int64_t toRemove = std::min((int64_t)timeslicesProcessed, offer.timeslices);
+        offer.timeslices -= toRemove;
+        timeslicesProcessed -= toRemove;
+        disposed.timeslices += toRemove;
+        if (timeslicesProcessed <= 0) {
+          break;
+        }
+      }
+      return accountDisposed(disposed, stats);
+    };
+    pcx.services().get<DeviceState>().offerConsumers.emplace_back(disposeResources);
+  });
+}
+
 } // namespace o2::framework
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index aedd96dab41ca..3aa46269bdd7e 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -1080,6 +1080,14 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
                    .minPublishInterval = 0,
                    .maxRefreshLatency = 10000,
                    .sendInitialValue = true},
+        MetricSpec{.name = "timeslice-offer-number-consumed",
+                   .enabled = arrowAndResourceLimitingMetrics,
+                   .metricId = static_cast<short>(ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 0,
+                   .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
         MetricSpec{.name = "timeslices-expired",
                    .enabled = arrowAndResourceLimitingMetrics,
                    .metricId = static_cast<short>(ProcessingStatsId::TIMESLICE_NUMBER_EXPIRED),
@@ -1088,9 +1096,17 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
                    .minPublishInterval = 0,
                    .maxRefreshLatency = 10000,
                    .sendInitialValue = true},
-        MetricSpec{.name = "timeslices-consumed",
+        MetricSpec{.name = "timeslices-started",
                    .enabled = arrowAndResourceLimitingMetrics,
-                   .metricId = static_cast<short>(ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED),
+                   .metricId = static_cast<short>(ProcessingStatsId::TIMESLICE_NUMBER_STARTED),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 0,
+                   .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
+        MetricSpec{.name = "timeslices-done",
+                   .enabled = arrowAndResourceLimitingMetrics,
+                   .metricId = static_cast<short>(ProcessingStatsId::TIMESLICE_NUMBER_DONE),
                    .kind = Kind::UInt64,
                    .scope = Scope::DPL,
                    .minPublishInterval = 0,
diff --git a/Framework/Core/src/ComputingQuotaEvaluator.cxx b/Framework/Core/src/ComputingQuotaEvaluator.cxx
index 85a5e6be467a7..3f5bff2b53fab 100644
--- a/Framework/Core/src/ComputingQuotaEvaluator.cxx
+++ b/Framework/Core/src/ComputingQuotaEvaluator.cxx
@@ -246,7 +246,7 @@ void ComputingQuotaEvaluator::dispose(int taskId)
 void ComputingQuotaEvaluator::updateOffers(std::vector<ComputingQuotaOffer>& pending, uint64_t now)
 {
   O2_SIGNPOST_ID_GENERATE(oid, quota);
-  O2_SIGNPOST_START(quota, oid, "updateOffers", "Starting to processe received offers");
+  O2_SIGNPOST_START(quota, oid, "updateOffers", "Starting to process %zu received offers", pending.size());
   int lastValid = -1;
   for (size_t oi = 0; oi < mOffers.size(); oi++) {
     auto& storeOffer = mOffers[oi];
@@ -283,7 +283,9 @@ void ComputingQuotaEvaluator::updateOffers(std::vector<ComputingQuotaOffer>& pen
     lastValidOffer.runtime = std::max(lastValidOffer.runtime, stillPending.runtime);
   }
   pending.clear();
-  O2_SIGNPOST_END(quota, oid, "updateOffers", "Remaining offers cohalesced to %d", lastValid);
+  auto& updatedOffer = mOffers[lastValid];
+  O2_SIGNPOST_END(quota, oid, "updateOffers", "Remaining offers cohalesced to %d. New values: Cpu%d, Shared Memory %lli, Timeslices %lli",
+                  lastValid, updatedOffer.cpu, updatedOffer.sharedMemory, updatedOffer.timeslices);
 }
 
 void ComputingQuotaEvaluator::handleExpired(std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats const& stats)> expirator)
@@ -304,8 +306,8 @@ void ComputingQuotaEvaluator::handleExpired(std::function<void(ComputingQuotaOff
   for (auto& ref : mExpiredOffers) {
     auto& offer = mOffers[ref.index];
     O2_SIGNPOST_ID_FROM_POINTER(oid, quota, (void*)(int64_t)(ref.index * 8));
-    if (offer.sharedMemory < 0) {
-      O2_SIGNPOST_END(quota, oid, "handleExpired", "Offer %d does not have any more memory. Marking it as invalid.", ref.index);
+    if (offer.sharedMemory < 0 && offer.timeslices < 0) {
+      O2_SIGNPOST_END(quota, oid, "handleExpired", "Offer %d does not have any more resources. Marking it as invalid.", ref.index);
       offer.valid = false;
       offer.score = OfferScore::Unneeded;
       continue;
@@ -314,13 +316,14 @@ void ComputingQuotaEvaluator::handleExpired(std::function<void(ComputingQuotaOff
     // api.
     O2_SIGNPOST_END(quota, oid, "handleExpired", "Offer %d expired. Giving back %llu MB, %d cores and %llu timeslices",
                     ref.index, offer.sharedMemory / 1000000, offer.cpu, offer.timeslices);
-    assert(offer.sharedMemory >= 0);
-    mStats.totalExpiredBytes += offer.sharedMemory;
+    mStats.totalExpiredBytes += std::max<int64_t>(offer.sharedMemory, 0);
+    mStats.totalExpiredTimeslices += std::max<int64_t>(offer.timeslices, 0);
     mStats.totalExpiredOffers++;
     expirator(offer, mStats);
     // driverClient.tell("expired shmem {}", offer.sharedMemory);
     // driverClient.tell("expired cpu {}", offer.cpu);
     offer.sharedMemory = -1;
+    offer.timeslices = -1;
     offer.valid = false;
     offer.score = OfferScore::Unneeded;
   }
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 42206e160d726..3b430378dc0b0 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -247,7 +247,9 @@ void run_completion(uv_work_t* handle, int status)
   static std::function<void(ComputingQuotaOffer const&, ComputingQuotaStats&)> reportConsumedOffer = [ref](ComputingQuotaOffer const& accumulatedConsumed, ComputingQuotaStats& stats) {
     auto& dpStats = ref.get<DataProcessingStats>();
     stats.totalConsumedBytes += accumulatedConsumed.sharedMemory;
-    stats.totalConsumedTimeslices += accumulatedConsumed.timeslices;
+    // For now we give back the offer if we did not use it completely.
+    // In principle we should try to run until the offer is fully consumed.
+    stats.totalConsumedTimeslices += std::min<int64_t>(accumulatedConsumed.timeslices, 1);
 
     dpStats.updateStats({static_cast<short>(ProcessingStatsId::SHM_OFFER_BYTES_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedBytes});
     dpStats.updateStats({static_cast<short>(ProcessingStatsId::TIMESLICE_OFFER_NUMBER_CONSUMED), DataProcessingStats::Op::Set, stats.totalConsumedTimeslices});
diff --git a/Framework/Core/src/DataProcessingStats.cxx b/Framework/Core/src/DataProcessingStats.cxx
index 3b02a0aacdd70..8349af62acdc2 100644
--- a/Framework/Core/src/DataProcessingStats.cxx
+++ b/Framework/Core/src/DataProcessingStats.cxx
@@ -29,6 +29,16 @@ DataProcessingStats::DataProcessingStats(std::function<void(int64_t& base, int64
   getRealtimeBase(realTimeBase, initialTimeOffset);
 }
 
+char const* DataProcessingStats::findMetricNameById(ProcessingStatsId id) const
+{
+  for (auto& spec : metricSpecs) {
+    if (spec.metricId == (int)id) {
+      return spec.name.c_str();
+    }
+  }
+  return nullptr;
+}
+
 void DataProcessingStats::updateStats(CommandSpec cmd)
 {
   if (metricSpecs[cmd.id].name.empty()) {
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 0b82e8265b604..b3af5636127f9 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -466,12 +466,12 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     if (mctracks2aod == workflow.end()) {
       // add normal reader
       auto&& algo = PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx);
-      aodReader.algorithm = algo;
+      aodReader.algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(algo);
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
       aodReader.outputs.emplace_back(OutputSpec{"TFF", "TFFilename"});
     } else {
       // AODs are being injected on-the-fly, add dummy reader
-      aodReader.algorithm = AlgorithmSpec{
+      auto algo = AlgorithmSpec{
         adaptStateful(
           [outputs = aodReader.outputs](DeviceSpec const&) {
             LOGP(warn, "Workflow with injected AODs has unsatisfied inputs:");
@@ -482,6 +482,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
             // to ensure the output type for adaptStateful
             return adaptStateless([](DataAllocator&) {});
           })};
+      aodReader.algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(algo);
     }
     auto concrete = DataSpecUtils::asConcreteDataMatcher(aodReader.inputs[0]);
     timer.outputs.emplace_back(concrete.origin, concrete.description, concrete.subSpec, Lifetime::Enumeration);

From 7c1375a78fcaf26bcc1dc5168a91cf275560e9df Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sat, 15 Nov 2025 16:13:23 +0100
Subject: [PATCH 1029/1764] Optional ITStracks details output from TrackMCStudy

---
 .../study/CMakeLists.txt                      |  2 +-
 .../GlobalTrackingStudy/TrackMCStudyConfig.h  |  1 +
 .../GlobalTrackingStudy/TrackMCStudyTypes.h   | 11 +++
 .../study/src/GlobalTrackingStudyLinkDef.h    |  3 +
 .../study/src/TrackMCStudy.cxx                | 96 ++++++++++++++++++-
 5 files changed, 111 insertions(+), 2 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
index ab900c7efd87b..776d3946283c3 100644
--- a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
+++ b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
@@ -9,7 +9,7 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-add_compile_options(-O0 -g -fPIC)
+#add_compile_options(-O0 -g -fPIC)
 
 o2_add_library(GlobalTrackingStudy
                TARGETVARNAME targetName
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
index 2b92c00a989cf..e67abe6de3315 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
@@ -28,6 +28,7 @@ struct TrackMCStudyConfig : o2::conf::ConfigurableParamHelper<TrackMCStudyConfig
   bool requireITSorTPCTrackRefs = true;
   bool requireTopBottomRefs = false;
   bool storeTPCTrackRefs = false;
+  bool storeITSInfo = true;
   int minTPCRefsToExtractClRes = 2;
   int nOccBinsDrift = 10; // number of bins for TPC max drift time, where we integrate the occupancies
   int nTBPerOccBin = 48;  // number of TB per occ bin
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
index 4766dc6787351..f5846bcce5a49 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyTypes.h
@@ -19,6 +19,7 @@
 #include "CommonConstants/LHCConstants.h"
 #include "CommonDataFormat/TimeStamp.h"
 #include "ReconstructionDataFormats/PrimaryVertex.h"
+#include "SimulationDataFormat/TrackReference.h"
 #include <array>
 #include <vector>
 
@@ -289,6 +290,16 @@ struct ClResTPC {
   ClassDefNV(ClResTPC, 2);
 };
 
+struct ITSHitInfo {
+  o2::BaseCluster<float> clus{};
+  o2::TrackReference tref{};
+  float trefXT = 0; // track ref tracking frame coordinates
+  float trefYT = 0;
+  float chipX = 0;
+  float chipAlpha = 0;
+  ClassDefNV(ITSHitInfo, 1);
+};
+
 struct RecPV {
   o2::dataformats::PrimaryVertex pv{};
   o2::MCEventLabel mcEvLbl{};
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h b/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
index f0d3e7d4d0b4e..6075429b0b16e 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
+++ b/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
@@ -40,4 +40,7 @@
 #pragma link C++ class std::vector < o2::trackstudy::TrackPairInfo> + ;
 #pragma ling C++ class o2::tpc::TPCClusSelector + ;
 
+#pragma link C++ class o2::trackstudy::ITSHitInfo + ;
+#pragma link C++ class std::vector < o2::trackstudy::ITSHitInfo> + ;
+
 #endif
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 5881f79b17fc1..93b15a6e6650d 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -19,11 +19,14 @@
 #include "TPCCalibration/VDriftHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
+#include "ITStracking/IOUtils.h"
 #include "DetectorsBase/Propagator.h"
 #include "DetectorsBase/GeometryManager.h"
+#include "ITSBase/GeometryTGeo.h"
 #include "SimulationDataFormat/MCEventLabel.h"
 #include "SimulationDataFormat/MCUtils.h"
 #include "SimulationDataFormat/O2DatabasePDG.h"
+#include "SimulationDataFormat/TrackReference.h"
 #include "CommonDataFormat/BunchFilling.h"
 #include "CommonUtils/NameConf.h"
 #include "DataFormatsFT0/RecPoints.h"
@@ -99,6 +102,7 @@ class TrackMCStudy : public Task
 
  private:
   void processTPCTrackRefs();
+  void processITSTracks(const o2::globaltracking::RecoContainer& recoData);
   void loadTPCOccMap(const o2::globaltracking::RecoContainer& recoData);
   void fillMCClusterInfo(const o2::globaltracking::RecoContainer& recoData);
   void prepareITSData(const o2::globaltracking::RecoContainer& recoData);
@@ -122,6 +126,9 @@ class TrackMCStudy : public Task
   std::vector<long> mIntBC;      ///< interaction global BC wrt TF start
   std::vector<float> mTPCOcc;    ///< TPC occupancy for this interaction time
   std::vector<int> mITSOcc;      //< N ITS clusters in the ROF containing collision
+  std::vector<o2::BaseCluster<float>> mITSClustersArray;    ///< ITS clusters created in run() method from compact clusters
+  const o2::itsmft::TopologyDictionary* mITSDict = nullptr; ///< cluster patterns dictionary
+
   bool mCheckSV = false;         //< check SV binding (apart from prongs availability)
   bool mRecProcStage = false;    //< flag that the MC particle was added only at the stage of reco tracks processing
   int mNTPCOccBinLength = 0;     ///< TPC occ. histo bin length in TBs
@@ -221,7 +228,7 @@ void TrackMCStudy::updateTimeDependentParams(ProcessingContext& pc)
 
     auto& elParam = o2::tpc::ParameterElectronics::Instance();
     mTPCTBinMUS = elParam.ZbinWidth;
-
+    o2::its::GeometryTGeo::Instance()->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2GRot) | o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L));
     if (mCheckSV) {
       const auto& svparam = o2::vertexing::SVertexerParams::Instance();
       mFitterV0.setBz(o2::base::Propagator::Instance()->getNominalBz());
@@ -751,6 +758,10 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
     });
     (*mDBGOut) << "mcVtxTree" << "mcVtx=" << mcVtx << "\n";
   }
+
+  if (params.storeITSInfo) {
+    processITSTracks(recoData);
+  }
 }
 
 void TrackMCStudy::processTPCTrackRefs()
@@ -1023,6 +1034,11 @@ void TrackMCStudy::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
     mITSROFrameLengthMUS = par.roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingNS * 1e-3;
     return;
   }
+  if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
+    LOG(info) << "cluster dictionary updated";
+    mITSDict = (const o2::itsmft::TopologyDictionary*)obj;
+    return;
+  }
 }
 
 //_____________________________________________________
@@ -1276,6 +1292,84 @@ void TrackMCStudy::loadTPCOccMap(const o2::globaltracking::RecoContainer& recoDa
   }
 }
 
+void TrackMCStudy::processITSTracks(const o2::globaltracking::RecoContainer& recoData)
+{
+  if (!mITSDict) {
+    LOGP(warn, "ITS data is not loaded");
+    return;
+  }
+  const auto itsTracks = recoData.getITSTracks();
+  const auto itsLbls = recoData.getITSTracksMCLabels();
+  const auto itsClRefs = recoData.getITSTracksClusterRefs();
+  const auto clusITS = recoData.getITSClusters();
+  const auto patterns = recoData.getITSClustersPatterns();
+  auto pattIt = patterns.begin();
+  mITSClustersArray.clear();
+  mITSClustersArray.reserve(clusITS.size());
+
+  o2::its::ioutils::convertCompactClusters(clusITS, pattIt, mITSClustersArray, mITSDict);
+  auto geom = o2::its::GeometryTGeo::Instance();
+  int ntr = itsLbls.size();
+  LOGP(info, "We have {} ITS clusters and the number of patterns is {}, ITSdict:{} NMCLabels: {}", clusITS.size(), patterns.size(), mITSDict != nullptr, itsLbls.size());
+
+  std::vector<int> evord(ntr);
+  std::iota(evord.begin(), evord.end(), 0);
+  std::sort(evord.begin(), evord.end(), [&](int i, int j) { return itsLbls[i] < itsLbls[j]; });
+  std::vector<ITSHitInfo> outHitInfo;
+  std::array<int, 7> cl2arr{};
+
+  for (int itr0 = 0; itr0 < ntr; itr0++) {
+    auto itr = evord[itr0];
+    const auto& itsTr = itsTracks[itr];
+    const auto& itsLb = itsLbls[itr];
+    //    LOGP(info,"proc {} {} {}",itr0, itr, itsLb.asString());
+    int nCl = itsTr.getNClusters();
+    if (itsLb.isFake() || nCl != 7) {
+      continue;
+    }
+    auto entrySel = mSelMCTracks.find(itsLb);
+    if (entrySel == mSelMCTracks.end()) {
+      continue;
+    }
+    outHitInfo.clear();
+    cl2arr.fill(-1);
+    auto clEntry = itsTr.getFirstClusterEntry();
+    for (int iCl = nCl; iCl--;) { // clusters are stored from outer to inner layers
+      const auto& cls = mITSClustersArray[itsClRefs[clEntry + iCl]];
+      int hpos = outHitInfo.size();
+      auto& hinf = outHitInfo.emplace_back();
+      hinf.clus = cls;
+      hinf.clus.setCount(geom->getLayer(cls.getSensorID()));
+      geom->getSensorXAlphaRefPlane(cls.getSensorID(), hinf.chipX, hinf.chipAlpha);
+      cl2arr[hinf.clus.getCount()] = hpos; // to facilitate finding the cluster of the layer
+    }
+    auto trspan = mcReader.getTrackRefs(itsLb.getSourceID(), itsLb.getEventID(), itsLb.getTrackID());
+    int ilrc = -1, nrefAcc = 0;
+    for (const auto& trf : trspan) {
+      if (trf.getDetectorId() != 0) { // process ITS only
+        continue;
+      }
+      int lrt = trf.getUserId(); // layer of the reference, but there might be multiple hits on the same layer
+      int clEnt = cl2arr[lrt];
+      if (clEnt < 0) {
+        continue;
+      }
+      auto& hinf = outHitInfo[clEnt];
+      float traX, traY;
+      o2::math_utils::rotateZInv(trf.X(), trf.Y(), traX, traY, std::sin(hinf.chipAlpha), std::cos(hinf.chipAlpha)); // tracking coordinates of the reference
+      if (hinf.trefXT < 1 || std::abs(traX - hinf.chipX) < std::abs(hinf.trefXT - hinf.chipX)) {
+        if (hinf.trefXT < 1) {
+          nrefAcc++;
+        }
+        hinf.tref = trf;
+        hinf.trefXT = traX;
+        hinf.trefYT = traY;
+      }
+    }
+    (*mDBGOut) << "itsTree" << "hits=" << outHitInfo << "trIn=" << ((o2::track::TrackParCov&)itsTr) << "trOut=" << itsTr.getParamOut() << "mcTr=" << entrySel->second.mcTrackInfo.track << "nTrefs=" << nrefAcc << "\n";
+  }
+}
+
 DataProcessorSpec getTrackMCStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool checkSV)
 {
   std::vector<OutputSpec> outputs;

From dae698e672defc6c78379110c181cc2cd0e26d60 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Mon, 17 Nov 2025 09:30:43 +0100
Subject: [PATCH 1030/1764] ALICE3-TRK: fix nSimSteps to cover long hits at
 large Z + prints cleanup (#14819)

* ALICE3-TRK: cleanup of printed messages

* ALICE3-TRK: set nSimSteps = 475 to cover long hits at large Z
---
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      |  2 +-
 .../include/TRKSimulation/DPLDigitizerParam.h |  2 +-
 .../include/TRKSimulation/DigiParams.h        | 24 ++++++-------
 .../ALICE3/TRK/simulation/src/Detector.cxx    |  4 +--
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx    | 36 +++++++++----------
 .../ALICE3/TRK/simulation/src/VDLayer.cxx     |  4 +--
 6 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 72caf1f4d5e20..bfa23fe57c01a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -1121,7 +1121,7 @@ void GeometryTGeo::Print(Option_t*) const
     mlot = (i < 4) ? "ML" : "OT";
     LOGF(info, "Layer: %d, %s, %d staves, %d half staves per stave", i, mlot.c_str(), mNumberOfStaves[i], mNumberOfHalfStaves[i]);
   }
-  LOGF(info, "Number of modules per layer MLOT: ");
+  LOGF(info, "Number of modules per stave (half stave) in each ML(OT) layer: ");
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
     LOGF(info, "%d", mNumberOfModules[i]);
   }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
index 179b666a159d6..bbafcf3f8f979 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
@@ -39,7 +39,7 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
   double timeOffset = 0.;                 ///< time offset (in seconds!) to calculate ROFrame from hit time
   int chargeThreshold = 1;                ///< charge threshold in Nelectrons
   int minChargeToAccount = 1;             ///< minimum charge contribution to account
-  int nSimSteps = 25;                     ///< number of steps in response simulation
+  int nSimSteps = 475;                    ///< number of steps in response simulation
   float energyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
 
   float Vbb = 0.0;   ///< back bias absolute value for MFT (in Volt)
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
index 3a03ab058ec2f..970b20c48816e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
@@ -101,18 +101,18 @@ class DigiParams
 
  private:
   static constexpr double infTime = 1e99;
-  bool mIsContinuous = false;        ///< flag for continuous simulation
-  float mNoisePerPixel = 1.e-8;      ///< ALPIDE Noise per chip
-  int mROFrameLengthInBC = 0;        ///< ROF length in BC for continuos mode
-  float mROFrameLength = 0;          ///< length of RO frame in ns
-  float mStrobeDelay = 0.;           ///< strobe start (in ns) wrt ROF start
-  float mStrobeLength = 0;           ///< length of the strobe in ns (sig. over threshold checked in this window only)
-  double mTimeOffset = -2 * infTime; ///< time offset (in seconds!) to calculate ROFrame from hit time
-  int mROFrameBiasInBC = 0;          ///< misalignment of the ROF start in BC
-  int mChargeThreshold = 1;          ///< charge threshold in Nelectrons
-  int mMinChargeToAccount = 1;       ///< minimum charge contribution to account
-  int mNSimSteps = 25;               ///< number of steps in response simulation
-  float mNSimStepsInv = 0;           ///< its inverse
+  bool mIsContinuous = false;            ///< flag for continuous simulation
+  float mNoisePerPixel = 1.e-8;          ///< ALPIDE Noise per chip
+  int mROFrameLengthInBC = 0;            ///< ROF length in BC for continuos mode
+  float mROFrameLength = 0;              ///< length of RO frame in ns
+  float mStrobeDelay = 0.;               ///< strobe start (in ns) wrt ROF start
+  float mStrobeLength = 0;               ///< length of the strobe in ns (sig. over threshold checked in this window only)
+  double mTimeOffset = -2 * infTime;     ///< time offset (in seconds!) to calculate ROFrame from hit time
+  int mROFrameBiasInBC = 0;              ///< misalignment of the ROF start in BC
+  int mChargeThreshold = 1;              ///< charge threshold in Nelectrons
+  int mMinChargeToAccount = 1;           ///< minimum charge contribution to account
+  int mNSimSteps = 475;                  ///< number of steps in response simulation
+  float mNSimStepsInv = 1. / mNSimSteps; ///< its inverse
 
   float mEnergyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 4d7e560d50dc2..0924be5fb6764 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -476,9 +476,9 @@ bool Detector::ProcessHits(FairVolume* vol)
 
     unsigned short chipID = mGeometryTGeo->getChipIndex(subDetID, volume, layer, stave, halfstave, mod, chip);
 
-    Print(vol, volume, subDetID, layer, stave, halfstave, mod, chip, chipID);
+    // Print(vol, volume, subDetID, layer, stave, halfstave, mod, chip, chipID);
 
-    mGeometryTGeo->Print();
+    // mGeometryTGeo->Print();
 
     Hit* p = addHit(stack->GetCurrentTrackNumber(), chipID, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
                     mTrackData.mMomentumStart.Vect(), mTrackData.mMomentumStart.E(), positionStop.T(),
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index 021955c2e47ac..a24a8eea0be27 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -126,12 +126,12 @@ TGeoVolume* TRKLayer::createChip(std::string type)
 
     TGeoCombiTrans* transSens = new TGeoCombiTrans();
     transSens->SetTranslation(0, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
-    LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
     chipVol->AddNode(sensVol, 1, transSens);
 
     TGeoCombiTrans* transMetal = new TGeoCombiTrans();
     transMetal->SetTranslation(0, mSensorThickness / 2, 0); // TO BE CHECKED !!!
-    LOGP(info, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
     chipVol->AddNode(metalVol, 1, transMetal);
 
     // deadVol = createDeadzone("cylinder");
@@ -145,17 +145,17 @@ TGeoVolume* TRKLayer::createChip(std::string type)
 
     TGeoCombiTrans* transSens = new TGeoCombiTrans();
     transSens->SetTranslation(-mDeadzoneWidth / 2, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
-    LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
     chipVol->AddNode(sensVol, 1, transSens);
 
     TGeoCombiTrans* transDead = new TGeoCombiTrans();
     transDead->SetTranslation((mChipWidth - mDeadzoneWidth) / 2, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
-    LOGP(info, "Inserting {} in {} ", deadVol->GetName(), chipVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", deadVol->GetName(), chipVol->GetName());
     chipVol->AddNode(deadVol, 1, transDead);
 
     TGeoCombiTrans* transMetal = new TGeoCombiTrans();
     transMetal->SetTranslation(0, mSensorThickness / 2, 0); // TO BE CHECKED !!!
-    LOGP(info, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
     chipVol->AddNode(metalVol, 1, transMetal);
   } else {
     LOGP(fatal, "Sensor of type '{}' is not implemented", type);
@@ -179,7 +179,7 @@ TGeoVolume* TRKLayer::createModule(std::string type)
     moduleVol = new TGeoVolume(moduleName.c_str(), module, medAir);
 
     TGeoVolume* chipVol = createChip("cylinder");
-    LOGP(info, "Inserting {} in {} ", chipVol->GetName(), moduleVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", chipVol->GetName(), moduleVol->GetName());
     moduleVol->AddNode(chipVol, 1, nullptr);
   } else if (type == "flat") {
     double moduleWidth = constants::moduleMLOT::width;
@@ -201,7 +201,7 @@ TGeoVolume* TRKLayer::createModule(std::string type)
       TGeoRotation* rot = new TGeoRotation();
       rot->RotateY(180);
       transLeft->SetRotation(rot);
-      LOGP(info, "Inserting {} in {} ", chipVolLeft->GetName(), moduleVol->GetName());
+      LOGP(debug, "Inserting {} in {} ", chipVolLeft->GetName(), moduleVol->GetName());
       moduleVol->AddNode(chipVolLeft, iChip * 2, transLeft);
 
       double xRight = +moduleWidth / 2 - constants::moduleMLOT::gaps::outerEdgeLongSide - constants::moduleMLOT::chip::width / 2;
@@ -209,7 +209,7 @@ TGeoVolume* TRKLayer::createModule(std::string type)
 
       TGeoCombiTrans* transRight = new TGeoCombiTrans();
       transRight->SetTranslation(xRight, 0, zRight); // TO BE CHECKED !!!
-      LOGP(info, "Inserting {} in {} ", chipVolRight->GetName(), moduleVol->GetName());
+      LOGP(debug, "Inserting {} in {} ", chipVolRight->GetName(), moduleVol->GetName());
       moduleVol->AddNode(chipVolRight, iChip * 2 + 1, transRight);
     }
   } else {
@@ -234,7 +234,7 @@ TGeoVolume* TRKLayer::createHalfStave(std::string type)
     halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medAir);
 
     TGeoVolume* moduleVol = createModule("cylinder");
-    LOGP(info, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
     halfStaveVol->AddNode(moduleVol, 1, nullptr);
   } else if (type == "flat") {
     double moduleLength = constants::moduleMLOT::length;
@@ -253,7 +253,7 @@ TGeoVolume* TRKLayer::createHalfStave(std::string type)
       TGeoCombiTrans* trans = new TGeoCombiTrans();
       trans->SetTranslation(0, 0, zPos); // TO BE CHECKED !!!
 
-      LOGP(info, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
+      LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
       halfStaveVol->AddNode(moduleVol, iModule, trans);
     }
   }
@@ -273,7 +273,7 @@ TGeoVolume* TRKLayer::createStave(std::string type)
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
 
     TGeoVolume* moduleVol = createModule("cylinder");
-    LOGP(info, "Inserting {} in {} ", moduleVol->GetName(), staveVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), staveVol->GetName());
     staveVol->AddNode(moduleVol, 1, nullptr);
   } else if (type == "flat") {
     double moduleLength = constants::moduleMLOT::length;
@@ -292,7 +292,7 @@ TGeoVolume* TRKLayer::createStave(std::string type)
       TGeoCombiTrans* trans = new TGeoCombiTrans();
       trans->SetTranslation(0, 0, zPos); // TO BE CHECKED !!!
 
-      LOGP(info, "Inserting {} in {} ", moduleVol->GetName(), staveVol->GetName());
+      LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), staveVol->GetName());
       staveVol->AddNode(moduleVol, iModule, trans);
     }
   } else if (type == "staggered") {
@@ -312,12 +312,12 @@ TGeoVolume* TRKLayer::createStave(std::string type)
 
     TGeoCombiTrans* transLeft = new TGeoCombiTrans();
     transLeft->SetTranslation(-halfstaveWidth / 2 + 0.05, 0, 0); // TO BE CHECKED !!! 1mm overlap between the modules
-    LOGP(info, "Inserting {} in {} ", halfStaveVolLeft->GetName(), staveVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", halfStaveVolLeft->GetName(), staveVol->GetName());
     staveVol->AddNode(halfStaveVolLeft, 0, transLeft);
 
     TGeoCombiTrans* transRight = new TGeoCombiTrans();
     transRight->SetTranslation(halfstaveWidth / 2 - 0.05, 0.2, 0); // TO BE CHECKED !!! 1mm overlap between the modules
-    LOGP(info, "Inserting {} in {} ", halfStaveVolRight->GetName(), staveVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", halfStaveVolRight->GetName(), staveVol->GetName());
     staveVol->AddNode(halfStaveVolRight, 1, transRight);
   } else {
     LOGP(fatal, "Chip of type '{}' is not implemented", type);
@@ -345,7 +345,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
     layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
 
     TGeoVolume* staveVol = createStave("cylinder");
-    LOGP(info, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
+    LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
     layerVol->AddNode(staveVol, 1, nullptr);
   } else if (mLayout == eLayout::kTurboStaves) {
     double layerLength = constants::moduleMLOT::length * mNumberOfModules;
@@ -381,7 +381,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       trans->SetRotation(rot);
       trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
 
-      LOGP(info, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
+      LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
       layerVol->AddNode(staveVol, iStave, trans);
     }
   } else if (mLayout == kStaggered) {
@@ -414,7 +414,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       trans->SetRotation(rot);
       trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
 
-      LOGP(info, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
+      LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
       layerVol->AddNode(staveVol, iStave, trans);
     }
   } else {
@@ -422,7 +422,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
   }
   layerVol->SetLineColor(kYellow);
 
-  LOGP(info, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
+  LOGP(debug, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
   motherVolume->AddNode(layerVol, 1, nullptr);
 }
 // ClassImp(TRKLayer);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
index b762ba5c9b36a..20f36f1f6f4e7 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
@@ -190,7 +190,7 @@ void VDCylindricalLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combi
     LOGP(error, "VDCylindricalLayer::createSensor() returned null");
     return;
   }
-  LOGP(info, "Inserting {} in {} ", sensorVol->GetName(), layerVol->GetName());
+  LOGP(debug, "Inserting {} in {} ", sensorVol->GetName(), layerVol->GetName());
   layerVol->AddNode(sensorVol, 1, nullptr);
 
   // Tiling: edge-to-edge if sensor shorter than layer; else single centered
@@ -244,7 +244,7 @@ void VDRectangularLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combi
     return;
   }
 
-  LOGP(info, "Inserting {} in {} ", sensorVol->GetName(), layerVol->GetName());
+  LOGP(debug, "Inserting {} in {} ", sensorVol->GetName(), layerVol->GetName());
   layerVol->AddNode(sensorVol, 1, nullptr);
 
   // Tiling along Z, edge - to - edge if needed

From 91acb9ddb4e8a18e2d86d06955dd865555554c5c Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Mon, 17 Nov 2025 11:05:41 +0100
Subject: [PATCH 1031/1764] dev: improvements of pb lumi macro (#14822)

* dev: improvements of pb lumi macro

* forgot clang

* more options

* clang

* clang

* multigraph (thanks to Andreas Molander)

---------

Co-authored-by: Roman Lietava <romanlietava@romans-macbook-pro.home>
---
 Detectors/CTP/macro/PlotPbLumi.C | 134 ++++++++++++++++++++++++-------
 1 file changed, 106 insertions(+), 28 deletions(-)

diff --git a/Detectors/CTP/macro/PlotPbLumi.C b/Detectors/CTP/macro/PlotPbLumi.C
index 04666d5bd1cf6..4bda8d25e006e 100644
--- a/Detectors/CTP/macro/PlotPbLumi.C
+++ b/Detectors/CTP/macro/PlotPbLumi.C
@@ -9,10 +9,10 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file TestCTPScalers.C
+/// \file PlotPbLumi.C
 /// \brief create CTP scalers, test it and add to database
 /// \author Roman Lietava
-// root -b -q "GetScalers.C(\"519499\", 1656286373953)"
+// root "PLotPbLumi.C(519499)"
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
 #include <fairlogger/Logger.h>
@@ -30,12 +30,21 @@
 #include <iostream>
 #endif
 using namespace o2::ctp;
-void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-test.cern.ch:8080")
+//
+// sum = 0: TCE and TSC separatelly otherwise TCE and (TCE+TSC)
+// qc = 0: takes scalers from CCDB (available only for finished runs) otherwise from QCCDB (available for active runs)
+// t0-tlast: window in seconds counted from beginning of run
+//
+void PlotPbLumi(int runNumber = 567905, bool sum = 0, bool qc = 0, Double_t t0 = 0., Double_t tlast = 0.)
 { //
-  // what = 1: znc rate
-  // what = 2: (TCE+TSC)/ZNC
-  // what = 3: TCE/ZNC
-  std::string mCCDBPathCTPScalers = "CTP/Calib/Scalers";
+  // PLots in one canvas
+  // znc rate/28
+  // R = (TCE+TSC)*TVX*B*/ZNC*28
+  // R = TCE*TVX*B/ZNC*28
+  // R = VCH*TVX*B/ZNC*28
+  std::string ccdbHost = "http://alice-ccdb.cern.ch";
+  std::string mCCDBPathCTPScalers = "/CTP/Calib/Scalers";
+  std::string mCCDBPathCTPScalersQC = "qc/CTP/Scalers";
   std::string mCCDBPathCTPConfig = "CTP/Config/Config";
   auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance();
   // Timestamp
@@ -43,20 +52,26 @@ void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-te
   uint64_t timeStamp = (soreor.second - soreor.first) / 2 + soreor.first;
   std::cout << "Timestamp:" << timeStamp << std::endl;
   // Filling
-  std::string sfill = std::to_string(fillN);
-  std::map<string, string> metadata;
-  metadata["fillNumber"] = sfill;
-  auto lhcifdata = ccdbMgr.getSpecific<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", timeStamp, metadata);
+  auto lhcifdata = ccdbMgr.getForRun<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", runNumber);
+  // auto lhcifdata = ccdbMgr.getSpecific<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", timeStamp, metadata);
+  if (!lhcifdata) {
+    throw std::runtime_error("No GRPLHCIFData for run " + std::to_string(runNumber));
+  }
   auto bfilling = lhcifdata->getBunchFilling();
   std::vector<int> bcs = bfilling.getFilledBCs();
   int nbc = bcs.size();
   std::cout << "Number of interacting bc:" << nbc << std::endl;
   // Scalers
   std::string srun = std::to_string(runNumber);
-  metadata.clear(); // can be empty
+  std::map<string, string> metadata;
   metadata["runNumber"] = srun;
-  ccdbMgr.setURL("http://ccdb-test.cern.ch:8080");
-  auto scl = ccdbMgr.getSpecific<CTPRunScalers>(mCCDBPathCTPScalers, timeStamp, metadata);
+  CTPRunScalers* scl = nullptr;
+  if (qc) {
+    ccdbMgr.setURL("http://ali-qcdb-gpn.cern.ch:8083");
+    scl = ccdbMgr.getSpecific<CTPRunScalers>(mCCDBPathCTPScalersQC, timeStamp, metadata);
+  } else {
+    scl = ccdbMgr.getSpecific<CTPRunScalers>(mCCDBPathCTPScalers, timeStamp, metadata);
+  }
   if (scl == nullptr) {
     LOG(info) << "CTPRunScalers not in database, timestamp:" << timeStamp;
     return;
@@ -65,6 +80,7 @@ void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-te
   std::vector<CTPScalerRecordO2> recs = scl->getScalerRecordO2();
   //
   // CTPConfiguration ctpcfg;
+  ccdbMgr.setURL("http://alice-ccdb.cern.ch");
   auto ctpcfg = ccdbMgr.getSpecific<CTPConfiguration>(mCCDBPathCTPConfig, timeStamp, metadata);
   if (ctpcfg == nullptr) {
     LOG(info) << "CTPRunConfig not in database, timestamp:" << timeStamp;
@@ -85,6 +101,7 @@ void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-te
   int tsc = 255;
   int tce = 255;
   int vch = 255;
+  int zncclsi = 255;
   for (auto const& cls : ctpcls) {
     if (cls.name.find("CMTVXTSC-B-NOPF") != std::string::npos && tsc == 255) {
       int itsc = cls.getIndex();
@@ -104,6 +121,12 @@ void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-te
       // vch = scl->getScalerIndexForClass(ivch);
       std::cout << cls.name << ":" << vch << ":" << ivch << std::endl;
     }
+    if (cls.name.find("C1ZNC-B-NOPF-CRU") != std::string::npos) {
+      int iznc = cls.getIndex();
+      zncclsi = clsIndexToScaler[iznc];
+      // vch = scl->getScalerIndexForClass(ivch);
+      std::cout << cls.name << ":" << zncclsi << ":" << iznc << std::endl;
+    }
   }
   if (tsc == 255 || tce == 255 || vch == 255) {
     std::cout << " One of dcalers not available, check config to find alternative)" << std::endl;
@@ -120,11 +143,39 @@ void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-te
   double_t orbit0 = recs[0].intRecord.orbit;
   int n = recs.size() - 1;
   std::cout << " Run duration:" << Trun << " Scalers size:" << n + 1 << std::endl;
-  Double_t x[n], znc[n], zncpp[n];
-  Double_t tcetsctoznc[n], tcetoznc[n], vchtoznc[n];
-  for (int i = 0; i < n; i++) {
-    x[i] = (double_t)(recs[i + 1].intRecord.orbit + recs[i].intRecord.orbit) / 2. - orbit0;
-    x[i] *= 88e-6;
+  //
+  int i0 = 0;
+  int ilast = 0;
+  if (t0 != 0. || tlast != 0.) {
+    for (int i = 0; i < n; i++) {
+      double_t ttime = recs[i].epochTime - time0;
+      if (!i0 && t0 < ttime) {
+        i0 = i;
+      }
+      if (!ilast && tlast < ttime) {
+        ilast = i;
+      }
+    }
+  } else {
+    ilast = n;
+  }
+  n = ilast - i0;
+  std::cout << "i0:" << i0 << " ilast:" << ilast << std::endl;
+  // Double_t x[n], znc[n], zncpp[n];
+  std::vector<Double_t> xvec(n), zncvec(n), zncppvec(n), zncclassvec(n);
+  Double_t* x = xvec.data();
+  Double_t* znc = zncvec.data();
+  Double_t* zncpp = zncppvec.data();
+  Double_t* zncclass = zncclassvec.data();
+  // Double_t tcetsctoznc[n], tcetoznc[n], vchtoznc[n];
+  std::vector<Double_t> tcetsctozncvec(n), tcetozncvec(n), vchtozncvec(n);
+  Double_t* tcetsctoznc = tcetsctozncvec.data();
+  Double_t* tcetoznc = tcetozncvec.data();
+  Double_t* vchtoznc = vchtozncvec.data();
+  for (int i = i0; i < ilast; i++) {
+    int iv = i - i0;
+    x[iv] = (double_t)(recs[i + 1].intRecord.orbit + recs[i].intRecord.orbit) / 2. - orbit0;
+    x[iv] *= 88e-6;
     // x[i] = (double_t)(recs[i+1].epochTime + recs[i].epochTime)/2.;
     double_t tt = (double_t)(recs[i + 1].intRecord.orbit - recs[i].intRecord.orbit);
     tt = tt * 88e-6;
@@ -133,33 +184,53 @@ void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-te
     double_t znci = (double_t)(recs[i + 1].scalersInps[25] - recs[i].scalersInps[25]);
     double_t mu = -TMath::Log(1. - znci / tt / nbc / frev);
     double_t zncipp = mu * nbc * frev;
-    zncpp[i] = zncipp / 28.;
-    znc[i] = znci / 28. / tt;
+    zncpp[iv] = zncipp / 28.;
+    znc[iv] = znci / 28. / tt;
+    // znc class
+    znci = recs[i + 1].scalers[zncclsi].l1Before - recs[i].scalers[zncclsi].l1Before;
+    zncclass[iv] = znci / 28. / tt;
+    // std::cout << znc[i]/zncclass[i] << std::endl;
     //
-    auto had = recs[i + 1].scalers[tce].lmBefore - recs[i].scalers[tce].lmBefore;
+    double_t had = 0;
+    if (sum) {
+      had += recs[i + 1].scalers[tce].lmBefore - recs[i].scalers[tce].lmBefore;
+    }
+    double_t mutce = -TMath::Log(1. - had / tt / nbc / frev);
     // std::cout << recs[i+1].scalers[tce].lmBefore << std::endl;
     had += recs[i + 1].scalers[tsc].lmBefore - recs[i].scalers[tsc].lmBefore;
     // rat = (double_t)(had)/double_t(recs[i+1].scalersInps[25] - recs[i].scalersInps[25])*28;
-    tcetsctoznc[i] = (double_t)(had) / zncpp[i] / tt;
+    tcetsctoznc[iv] = (double_t)(had) / zncpp[iv] / tt;
     had = recs[i + 1].scalers[tce].lmBefore - recs[i].scalers[tce].lmBefore;
     // rat = (double_t)(had)/double_t(recs[i+1].scalersInps[25] - recs[i].scalersInps[25])*28;
-    tcetoznc[i] = (double_t)(had) / zncpp[i] / tt;
+    tcetoznc[iv] = (double_t)(had) / zncpp[iv] / tt;
     had = recs[i + 1].scalers[vch].lmBefore - recs[i].scalers[vch].lmBefore;
+    double_t muvch = -TMath::Log(1. - had / tt / nbc / frev);
+
     // rat = (double_t)(had)/double_t(recs[i+1].scalersInps[25] - recs[i].scalersInps[25])*28;
-    vchtoznc[i] = (double_t)(had) / zncpp[i] / tt;
+    vchtoznc[iv] = (double_t)(had) / zncpp[iv] / tt;
+    // std::cout << "muzdc:" << mu << " mu tce:" << mutce << " muvch:" << muvch << std::endl;
   }
   //
   gStyle->SetMarkerSize(0.5);
   TGraph* gr1 = new TGraph(n, x, znc);
+  TGraph* gr11 = new TGraph(n, x, zncpp);    // PileuP corrected
+  TGraph* gr12 = new TGraph(n, x, zncclass); // NOT PileuP corrected
   TGraph* gr2 = new TGraph(n, x, tcetsctoznc);
   TGraph* gr3 = new TGraph(n, x, tcetoznc);
   TGraph* gr4 = new TGraph(n, x, vchtoznc);
   gr1->SetMarkerStyle(20);
+  gr11->SetMarkerStyle(20);
+  gr12->SetMarkerStyle(20);
+  gr11->SetMarkerColor(kRed);
+  gr12->SetMarkerColor(kBlue);
   gr2->SetMarkerStyle(21);
   gr3->SetMarkerStyle(23);
   gr4->SetMarkerStyle(23);
-  gr1->SetTitle("R=ZNC/28 rate [Hz]; time[sec]; R");
-  gr2->SetTitle("R=(TSC+TCE)*TVTX*B*28/ZNC; time[sec]; R");
+  if (sum) {
+    gr2->SetTitle("R=(TSC+TCE)*TVTX*B*28/ZNC; time[sec]; R");
+  } else {
+    gr2->SetTitle("R=(TSC)*TVTX*B*28/ZNC; time[sec]; R");
+  }
   // gr2->GetHistogram()->SetMaximum(1.1);
   // gr2->GetHistogram()->SetMinimum(0.9);
   gr3->SetTitle("R=(TCE)*TVTX*B*28/ZNC; time[sec]; R");
@@ -168,10 +239,17 @@ void PlotPbLumi(int runNumber, int fillN, std::string ccdbHost = "http://ccdb-te
   gr4->SetTitle("R=(VCH)*TVTX*B*28/ZNC; time[sec]; R");
   // gr4->GetHistogram()->SetMaximum(0.6);
   // gr4->GetHistogram()->SetMinimum(0.4);
+  TMultiGraph* mg1 = new TMultiGraph();
+  mg1->SetTitle("R=ZNC/28 rate [Hz] (red=PilUp Corrected); time[sec]; R");
+  mg1->Add(gr1);
+  mg1->Add(gr11);
+  mg1->Add(gr12);
   TCanvas* c1 = new TCanvas("c1", srun.c_str(), 200, 10, 800, 500);
+  std::string title = "RUN " + std::to_string(runNumber);
+  c1->SetTitle(title.c_str());
   c1->Divide(2, 2);
   c1->cd(1);
-  gr1->Draw("AP");
+  mg1->Draw("AP");
   c1->cd(2);
   gr2->Draw("AP");
   c1->cd(3);

From 6fcb124fc43ad30f60a16489cd7bb3a329c00503 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Tue, 11 Nov 2025 14:32:35 +0100
Subject: [PATCH 1032/1764] Event Display: catch several filesystem exceptions

---
 .../Base/src/DirectoryLoader.cxx              | 47 +++++++++++++------
 .../src/VisualisationEventROOTSerializer.cxx  |  4 ++
 2 files changed, 37 insertions(+), 14 deletions(-)

diff --git a/EventVisualisation/Base/src/DirectoryLoader.cxx b/EventVisualisation/Base/src/DirectoryLoader.cxx
index 1b0135428806f..f2f5a421c0ef9 100644
--- a/EventVisualisation/Base/src/DirectoryLoader.cxx
+++ b/EventVisualisation/Base/src/DirectoryLoader.cxx
@@ -29,10 +29,15 @@ using namespace o2::event_visualisation;
 deque<string> DirectoryLoader::load(const std::string& path, const std::string& marker, const std::vector<std::string>& ext)
 {
   deque<string> result;
-  for (const auto& entry : std::filesystem::directory_iterator(path)) {
-    if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
-      result.push_back(entry.path().filename());
+  try {
+    for (const auto& entry : std::filesystem::directory_iterator(path)) {
+      if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
+        result.push_back(entry.path().filename());
+      }
     }
+  } catch (std::filesystem::filesystem_error const& ex) {
+    LOGF(error, "filesystem problem during DirectoryLoader::load: %s", ex.what());
+    return result;
   }
   // comparison with safety if marker not in the filename (-1+1 gives 0)
   std::sort(result.begin(), result.end(),
@@ -56,7 +61,8 @@ bool DirectoryLoader::canCreateNextFile(const std::vector<std::string>& paths, c
         }
       }
     } catch (std::filesystem::filesystem_error const& ex) {
-      LOGF(info, "filesystem problem: %s", ex.what());
+      LOGF(error, "filesystem problem during DirectoryLoader::canCreateNextFile: %s", ex.what());
+      return false;
     }
   }
 
@@ -87,12 +93,17 @@ bool DirectoryLoader::canCreateNextFile(const std::vector<std::string>& paths, c
 deque<string> DirectoryLoader::load(const std::vector<std::string>& paths, const std::string& marker, const std::vector<std::string>& ext)
 {
   deque<string> result;
-  for (const auto& path : paths) {
-    for (const auto& entry : std::filesystem::directory_iterator(path)) {
-      if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
-        result.push_back(entry.path().filename());
+  try {
+    for (const auto& path : paths) {
+      for (const auto& entry : std::filesystem::directory_iterator(path)) {
+        if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
+          result.push_back(entry.path().filename());
+        }
       }
     }
+  } catch (std::filesystem::filesystem_error const& ex) {
+    LOGF(error, "filesystem problem during DirectoryLoader::load: %s", ex.what());
+    return result;
   }
   // comparison with safety if marker not in the filename (-1+1 gives 0)
   std::sort(result.begin(), result.end(),
@@ -135,10 +146,14 @@ std::time_t to_time_t(TP tp)
 int DirectoryLoader::getNumberOfFiles(const std::string& path, std::vector<std::string>& ext)
 {
   int res = 0;
-  for (const auto& entry : std::filesystem::directory_iterator(path)) {
-    if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
-      res++;
+  try {
+    for (const auto& entry : std::filesystem::directory_iterator(path)) {
+      if (std::find(ext.begin(), ext.end(), entry.path().extension()) != ext.end()) {
+        res++;
+      }
     }
+  } catch (std::filesystem::filesystem_error const& ex) {
+    LOGF(error, "filesystem problem during DirectoryLoader::getNumberOfFiles: %s", ex.what());
   }
   return res;
 }
@@ -160,8 +175,12 @@ std::string DirectoryLoader::getLatestFile(const std::string& path, std::vector<
 
 void DirectoryLoader::removeOldestFiles(const std::string& path, std::vector<std::string>& ext, const int remaining)
 {
-  while (getNumberOfFiles(path, ext) > remaining) {
-    LOGF(info, "removing oldest file in folder: %s : %s", path, getLatestFile(path, ext));
-    filesystem::remove(path + "/" + getLatestFile(path, ext));
+  try {
+    while (getNumberOfFiles(path, ext) > remaining) {
+      LOGF(info, "removing oldest file in folder: %s : %s", path, getLatestFile(path, ext));
+      filesystem::remove(path + "/" + getLatestFile(path, ext));
+    }
+  } catch (std::filesystem::filesystem_error const& ex) {
+    LOGF(error, "filesystem problem during DirectoryLoader::removeOldestFiles: %s", ex.what());
   }
 }
diff --git a/EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx b/EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx
index 8c1a84c1bf85e..8480e15ee9772 100644
--- a/EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx
+++ b/EventVisualisation/DataConverter/src/VisualisationEventROOTSerializer.cxx
@@ -97,6 +97,10 @@ void VisualisationEventROOTSerializer::toFile(const VisualisationEvent& event, L
 {
   std::string fileName = location.fileName();
   TFile f(fileName.c_str(), "recreate");
+  if (f.IsZombie()) {
+    LOGF(error, "Could not create output file %s", fileName.c_str());
+    return;
+  }
 
   saveInt("runNumber", event.mRunNumber);
   saveInt("runType", event.mRunType);

From 23292794884381567948a5c39b4fb4d90fea9ecb Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 16 Nov 2025 23:53:42 +0100
Subject: [PATCH 1033/1764] GPU: Forward-declare GPUProcessor in
 GPUMemoryResource

---
 GPU/GPUTracking/Base/GPUMemoryResource.cxx | 11 +++++++++++
 GPU/GPUTracking/Base/GPUMemoryResource.h   | 16 ++++++++--------
 GPU/GPUTracking/Base/GPUReconstruction.cxx |  2 +-
 GPU/GPUTracking/Base/GPUReconstruction.h   |  9 ++++-----
 4 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUMemoryResource.cxx b/GPU/GPUTracking/Base/GPUMemoryResource.cxx
index b22267859345a..aaf31837d04e3 100644
--- a/GPU/GPUTracking/Base/GPUMemoryResource.cxx
+++ b/GPU/GPUTracking/Base/GPUMemoryResource.cxx
@@ -13,4 +13,15 @@
 /// \author David Rohr
 
 #include "GPUMemoryResource.h"
+#include "GPUProcessor.h"
 using namespace o2::gpu;
+
+void* GPUMemoryResource::SetPointers(void* ptr) const
+{
+  return (mProcessor->*mSetPointers)(ptr);
+}
+
+void* GPUMemoryResource::SetDevicePointers(void* ptr) const
+{
+  return (mProcessor->mLinkedProcessor->*mSetPointers)(ptr);
+}
diff --git a/GPU/GPUTracking/Base/GPUMemoryResource.h b/GPU/GPUTracking/Base/GPUMemoryResource.h
index 947bcac504733..79960af9bc188 100644
--- a/GPU/GPUTracking/Base/GPUMemoryResource.h
+++ b/GPU/GPUTracking/Base/GPUMemoryResource.h
@@ -16,11 +16,14 @@
 #define GPUMEMORYRESOURCE_H
 
 #include "GPUCommonDef.h"
-#include "GPUProcessor.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <cstddef>
+#endif
 
 namespace o2::gpu
 {
 
+class GPUProcessor;
 struct GPUMemoryReuse {
   enum Type : int32_t {
     NONE = 0,
@@ -80,13 +83,10 @@ class GPUMemoryResource
   }
   GPUMemoryResource(const GPUMemoryResource&) = default;
 
-  void* SetPointers(void* ptr)
-  {
-    return (mProcessor->*mSetPointers)(ptr);
-  }
-  void* SetDevicePointers(void* ptr) { return (mProcessor->mLinkedProcessor->*mSetPointers)(ptr); }
-  void* Ptr() { return mPtr; }
-  void* PtrDevice() { return mPtrDevice; }
+  void* SetPointers(void* ptr) const;
+  void* SetDevicePointers(void* ptr) const;
+  void* Ptr() const { return mPtr; }
+  void* PtrDevice() const { return mPtrDevice; }
   size_t Size() const { return mSize; }
   const char* Name() const { return mName; }
   MemoryType Type() const { return mType; }
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 5129ccc4becf1..01af74d903f72 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -567,7 +567,7 @@ size_t GPUReconstruction::AllocateRegisteredPermanentMemory()
   return total;
 }
 
-size_t GPUReconstruction::AllocateRegisteredMemoryHelper(GPUMemoryResource* res, void*& ptr, void*& memorypool, void* memorybase, size_t memorysize, void* (GPUMemoryResource::*setPtr)(void*), void*& memorypoolend, const char* device)
+size_t GPUReconstruction::AllocateRegisteredMemoryHelper(GPUMemoryResource* res, void*& ptr, void*& memorypool, void* memorybase, size_t memorysize, void* (GPUMemoryResource::*setPtr)(void*) const, void*& memorypoolend, const char* device)
 {
   if (res->mReuse >= 0) {
     ptr = (&ptr == &res->mPtrDevice) ? mMemoryResources[res->mReuse].mPtrDevice : mMemoryResources[res->mReuse].mPtr;
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index b7eda77aeb9fe..fa636fa416538 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -30,10 +30,9 @@
 #include "GPUDataTypes.h"
 #include "GPUMemoryResource.h"
 #include "GPUOutputControl.h"
-
-/*#include "GPUParam.h"
-#include "GPUSettings.h"
-#include "GPULogging.h"*/
+#include "GPUParam.h"
+#include "GPUConstantMem.h"
+#include "GPUDef.h"
 
 namespace o2::its
 {
@@ -280,7 +279,7 @@ class GPUReconstruction
   static std::string getBackendVersions();
 
   // Private helper functions for memory management
-  size_t AllocateRegisteredMemoryHelper(GPUMemoryResource* res, void*& ptr, void*& memorypool, void* memorybase, size_t memorysize, void* (GPUMemoryResource::*SetPointers)(void*), void*& memorypoolend, const char* device);
+  size_t AllocateRegisteredMemoryHelper(GPUMemoryResource* res, void*& ptr, void*& memorypool, void* memorybase, size_t memorysize, void* (GPUMemoryResource::*SetPointers)(void*) const, void*& memorypoolend, const char* device);
   size_t AllocateRegisteredPermanentMemory();
 
   // Private helper functions for reading / writing / allocating IO buffer from/to file

From a63bcbae94c417141ce31a51d28c40d202db8b27 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Nov 2025 01:28:03 +0100
Subject: [PATCH 1034/1764] GPU: Remove some preprocessor defines, move to
 GPUParam

---
 .../Definitions/GPUDefConstantsAndSettings.h     |  2 --
 GPU/GPUTracking/Definitions/GPUSettingsList.h    |  4 ++--
 GPU/GPUTracking/qa/GPUQA.cxx                     | 16 ++++++++--------
 3 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index e5a2c8eb75bcb..b8b017f04c612 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -35,8 +35,6 @@
 #define GPUCA_MERGER_MAX_TRACK_CLUSTERS 1024          // Maximum number of clusters a track may have after merging
 
 #define GPUCA_MAXN 40                                 // Maximum number of neighbor hits to consider in one row in neightbors finder
-#define GPUCA_MIN_TRACK_PTB5_DEFAULT 0.010f           // Default setting for minimum track Pt at some places (at B=0.5T)
-#define GPUCA_MIN_TRACK_PTB5_REJECT_DEFAULT 0.050f    // Default setting for Pt (at B=0.5T) where tracks are rejected
 
 #define GPUCA_MAX_SIN_PHI_LOW 0.99f                   // Limits for maximum sin phi during fit
 #define GPUCA_MAX_SIN_PHI 0.999f                      // Must be preprocessor define because c++ pre 11 cannot use static constexpr for initializes
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 2f1eb72cb3d00..20bb746117d15 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -39,7 +39,7 @@ BeginNamespace(gpu)
 
 // Reconstruction parameters for TPC, no bool in here !!!
 BeginSubConfig(GPUSettingsRecTPC, tpc, configStandalone.rec, "RECTPC", 0, "Reconstruction settings", rec_tpc)
-AddOptionRTC(rejectQPtB5, float, 1.f / GPUCA_MIN_TRACK_PTB5_REJECT_DEFAULT, "", 0, "QPt threshold to reject clusters of TPC tracks (Inverse Pt, scaled to B=0.5T!!!)")
+AddOptionRTC(rejectQPtB5, float, 1.f / 0.050f, "", 0, "QPt threshold to reject clusters of TPC tracks (Inverse Pt, scaled to B=0.5T!!!)")
 AddOptionRTC(hitPickUpFactor, float, 1.f, "", 0, "multiplier for the combined cluster+track error during track following")
 AddOptionRTC(hitSearchArea2, float, 2.f, "", 0, "square of maximum search road of hits during seeding")
 AddOptionRTC(neighboursSearchArea, float, 3.f, "", 0, "area in cm for the search of neighbours, for z only used if searchWindowDZDR = 0")
@@ -195,7 +195,7 @@ EndConfig()
 
 // Global reconstruction parameters, no bool in here !!!
 BeginSubConfig(GPUSettingsRec, rec, configStandalone, "REC", 0, "Reconstruction settings", rec)
-AddOptionRTC(maxTrackQPtB5, float, 1.f / GPUCA_MIN_TRACK_PTB5_DEFAULT, "", 0, "required max Q/Pt (==min Pt) of tracks")
+AddOptionRTC(maxTrackQPtB5, float, 1.f / 0.010f, "", 0, "required max Q/Pt (==min Pt) of tracks")
 AddOptionRTC(fwdTPCDigitsAsClusters, uint8_t, 0, "", 0, "Forward TPC digits as clusters (if they pass the ZS threshold)")
 AddOptionRTC(bz0Pt10MeV, uint8_t, 60, "", 0, "Nominal Pt to set when bz = 0 (in 10 MeV)")
 AddOptionRTC(fitInProjections, int8_t, -1, "", 0, "Fit in projection, -1 to enable full fit for all but passes but the first one")
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 5fd1c259393bb..ce4a4a81db02c 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -146,9 +146,9 @@ static const constexpr float LOG_PT_MIN = -1.;
 
 static constexpr float Y_MAX = 40;
 static constexpr float Z_MAX = 100;
-static constexpr float PT_MIN = GPUCA_MIN_TRACK_PTB5_DEFAULT;
+static constexpr float PT_MIN = 0.01; // TODO: Take from Param
 static constexpr float PT_MIN_PRIM = 0.1;
-static constexpr float PT_MIN_CLUST = GPUCA_MIN_TRACK_PTB5_DEFAULT;
+static constexpr float PT_MIN_CLUST = 0.01;
 static constexpr float PT_MAX = 20;
 static constexpr float ETA_MAX = 1.5;
 static constexpr float ETA_MAX2 = 0.9;
@@ -1495,7 +1495,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             int32_t hitId = mTracking->mIOPtrs.mergedTrackHits[track.FirstClusterRef() + k].num;
             float totalWeight = 0.;
             for (int32_t j = 0; j < GetMCLabelNID(hitId); j++) {
-              if (GetMCLabelID(hitId, j) >= 0 && GetMCTrackObj(mMCParam, GetMCLabel(hitId, j)).pt > GPUCA_MIN_TRACK_PTB5_DEFAULT) {
+              if (GetMCLabelID(hitId, j) >= 0 && GetMCTrackObj(mMCParam, GetMCLabel(hitId, j)).pt > 1.f / mTracking->GetParam().rec.maxTrackQPtB5) {
                 totalWeight += GetMCLabelWeight(hitId, j);
               }
             }
@@ -1505,7 +1505,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
               float weight = 1.f / (totalWeight * (mClusterParam[hitId].attached + mClusterParam[hitId].fakeAttached));
               for (int32_t j = 0; j < GetMCLabelNID(hitId); j++) {
                 mcLabelI_t label = GetMCLabel(hitId, j);
-                if (!label.isFake() && GetMCTrackObj(mMCParam, label).pt > GPUCA_MIN_TRACK_PTB5_DEFAULT) {
+                if (!label.isFake() && GetMCTrackObj(mMCParam, label).pt > 1.f / mTracking->GetParam().rec.maxTrackQPtB5) {
                   float pt = GetMCTrackObj(mMCParam, label).pt;
                   if (pt < PT_MIN_CLUST) {
                     pt = PT_MIN_CLUST;
@@ -1594,7 +1594,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             float totalWeight = 0.;
             for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
               mcLabelI_t labelT = GetMCLabel(i, j);
-              if (!labelT.isFake() && GetMCTrackObj(mMCParam, labelT).pt > GPUCA_MIN_TRACK_PTB5_DEFAULT) {
+              if (!labelT.isFake() && GetMCTrackObj(mMCParam, labelT).pt > 1.f / mTracking->GetParam().rec.maxTrackQPtB5) {
                 totalWeight += GetMCLabelWeight(i, j);
               }
             }
@@ -1602,7 +1602,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             if (totalWeight > 0) {
               for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
                 mcLabelI_t labelT = GetMCLabel(i, j);
-                if (!labelT.isFake() && GetMCTrackObj(mMCParam, labelT).pt > GPUCA_MIN_TRACK_PTB5_DEFAULT) {
+                if (!labelT.isFake() && GetMCTrackObj(mMCParam, labelT).pt > 1.f / mTracking->GetParam().rec.maxTrackQPtB5) {
                   float pt = GetMCTrackObj(mMCParam, labelT).pt;
                   if (pt < PT_MIN_CLUST) {
                     pt = PT_MIN_CLUST;
@@ -1652,14 +1652,14 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           float totalWeight = 0.;
           for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
             mcLabelI_t labelT = GetMCLabel(i, j);
-            if (!labelT.isFake() && GetMCTrackObj(mMCParam, labelT).pt > GPUCA_MIN_TRACK_PTB5_DEFAULT) {
+            if (!labelT.isFake() && GetMCTrackObj(mMCParam, labelT).pt > 1.f / mTracking->GetParam().rec.maxTrackQPtB5) {
               totalWeight += GetMCLabelWeight(i, j);
             }
           }
           if (totalWeight > 0) {
             for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
               mcLabelI_t label = GetMCLabel(i, j);
-              if (!label.isFake() && GetMCTrackObj(mMCParam, label).pt > GPUCA_MIN_TRACK_PTB5_DEFAULT) {
+              if (!label.isFake() && GetMCTrackObj(mMCParam, label).pt > 1.f / mTracking->GetParam().rec.maxTrackQPtB5) {
                 float pt = GetMCTrackObj(mMCParam, label).pt;
                 if (pt < PT_MIN_CLUST) {
                   pt = PT_MIN_CLUST;

From f64b5dcfa28c86b8f2086299815eb31b6c838bb9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Nov 2025 00:02:23 +0100
Subject: [PATCH 1035/1764] GPU: Add GPUO2ExternalUser.h, to be included by
 external libraries using GPUTracking classes, instead of including the full
 GPUO2Interface.h

---
 .../Workflow/src/BarrelAlignmentSpec.cxx      |  2 +-
 Detectors/Align/include/Align/Controller.h    |  2 +-
 Detectors/Align/src/AlignableDetectorTPC.cxx  |  2 +-
 Detectors/Align/src/Controller.cxx            |  2 +-
 Detectors/GlobalTracking/src/MatchTPCITS.cxx  |  2 +-
 .../study/src/TrackingStudy.cxx               |  2 +-
 .../include/ITStracking/TrackingInterface.h   |  2 +-
 .../calibration/src/CalibPadGainTracks.cxx    |  2 +-
 .../src/TPCTrackingDigitsPreCheck.cxx         |  2 +-
 .../TRDWorkflow/TRDGlobalTrackingSpec.h       |  2 +-
 .../Definitions/GPUDefConstantsAndSettings.h  |  2 +-
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 GPU/GPUTracking/Interface/CMakeLists.txt      |  2 +-
 GPU/GPUTracking/Interface/GPUO2ExternalUser.h | 26 +++++++++++++++++++
 GPU/GPUTracking/Interface/GPUO2Interface.h    | 12 +++------
 .../GPUO2InterfaceConfigurableParam.h         |  8 ++----
 .../Interface/GPUO2InterfaceConfiguration.h   | 18 +++++--------
 .../Interface/GPUO2InterfaceDisplay.h         |  9 +------
 GPU/GPUTracking/Interface/GPUO2InterfaceQA.h  |  9 +------
 .../Interface/GPUO2InterfaceRefit.h           |  9 +------
 GPU/GPUTracking/display/GPUDisplay.h          |  1 +
 GPU/Workflow/src/GPUWorkflowITS.cxx           |  1 +
 22 files changed, 55 insertions(+), 64 deletions(-)
 create mode 100644 GPU/GPUTracking/Interface/GPUO2ExternalUser.h

diff --git a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
index 559eabc3f018b..d4ab53c8181ce 100644
--- a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
+++ b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
@@ -37,7 +37,7 @@
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "TPCCalibration/VDriftHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
-#include "GPUO2Interface.h"
+#include "GPUO2ExternalUser.h"
 #include "GPUO2InterfaceUtils.h"
 #include "GPUParam.h"
 #include "Headers/DataHeader.h"
diff --git a/Detectors/Align/include/Align/Controller.h b/Detectors/Align/include/Align/Controller.h
index 96ee2e4fcf418..90abf2025d1c3 100644
--- a/Detectors/Align/include/Align/Controller.h
+++ b/Detectors/Align/include/Align/Controller.h
@@ -54,7 +54,7 @@
 #include <TTree.h>
 #include <TFile.h>
 #include "Align/Mille.h"
-// #include "GPUO2Interface.h"
+// #include "GPUO2ExternalUser.h"
 // #include "DataFormatsTPC/WorkflowHelper.h"
 
 namespace o2
diff --git a/Detectors/Align/src/AlignableDetectorTPC.cxx b/Detectors/Align/src/AlignableDetectorTPC.cxx
index b3d2102559974..980ded2d8ff2f 100644
--- a/Detectors/Align/src/AlignableDetectorTPC.cxx
+++ b/Detectors/Align/src/AlignableDetectorTPC.cxx
@@ -24,7 +24,7 @@
 #include "DataFormatsTPC/WorkflowHelper.h"
 #include <TMath.h>
 #include <TGeoManager.h>
-#include "GPUO2Interface.h"
+#include "GPUO2ExternalUser.h"
 #include "DataFormatsTPC/WorkflowHelper.h"
 #include "GPUParam.inc"
 
diff --git a/Detectors/Align/src/Controller.cxx b/Detectors/Align/src/Controller.cxx
index a45314b2285c0..5cfbbf9f3a4ae 100644
--- a/Detectors/Align/src/Controller.cxx
+++ b/Detectors/Align/src/Controller.cxx
@@ -44,7 +44,7 @@
 #include <TH1F.h>
 #include <TList.h>
 #include <cstdio>
-#include "GPUO2Interface.h"
+#include "GPUO2ExternalUser.h"
 #include "DataFormatsTPC/WorkflowHelper.h"
 #include <TGeoGlobalMagField.h>
 #include "CommonUtils/NameConf.h"
diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index 7e3f8d9f78fc9..9c1a32a262e51 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "GPUO2Interface.h" // Needed for propper settings in GPUParam.h
+#include "GPUO2ExternalUser.h" // Needed for propper settings in GPUParam.h
 #include "GPUParam.h"
 #include "GPUParam.inc"
 #ifdef WITH_OPENMP
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index f1a07c10d0318..531ee03290201 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -44,7 +44,7 @@
 #include "TPCCalibration/VDriftHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "GPUO2InterfaceRefit.h"
-#include "GPUO2Interface.h" // Needed for propper settings in GPUParam.h
+#include "GPUO2ExternalUser.h" // Needed for propper settings in GPUParam.h
 #include "GPUParam.h"
 #include "GPUParam.inc"
 #include "GPUTPCGeometry.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index 491d2df4697ac..d31b1f11a4983 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -25,7 +25,7 @@
 #include "DataFormatsCalibration/MeanVertexObject.h"
 
 #include "GPUDataTypes.h"
-#include "GPUO2Interface.h"
+#include "GPUO2ExternalUser.h"
 #include "GPUChainITS.h"
 
 #include <oneapi/tbb/task_arena.h>
diff --git a/Detectors/TPC/calibration/src/CalibPadGainTracks.cxx b/Detectors/TPC/calibration/src/CalibPadGainTracks.cxx
index 93cdb7c47ee37..094de6b830272 100644
--- a/Detectors/TPC/calibration/src/CalibPadGainTracks.cxx
+++ b/Detectors/TPC/calibration/src/CalibPadGainTracks.cxx
@@ -22,7 +22,7 @@
 #include "CorrectionMapsHelper.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "GPUO2InterfaceRefit.h"
-#include "GPUO2Interface.h"
+#include "GPUO2ExternalUser.h"
 #include "DataFormatsTPC/ClusterNative.h"
 #include "DataFormatsTPC/VDriftCorrFact.h"
 #include "DetectorsBase/Propagator.h"
diff --git a/Detectors/TPC/reconstruction/src/TPCTrackingDigitsPreCheck.cxx b/Detectors/TPC/reconstruction/src/TPCTrackingDigitsPreCheck.cxx
index 738e6cff20df4..c6f7000089d72 100644
--- a/Detectors/TPC/reconstruction/src/TPCTrackingDigitsPreCheck.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCTrackingDigitsPreCheck.cxx
@@ -19,7 +19,7 @@
 #include "DataFormatsTPC/Digit.h"
 #include "DataFormatsTPC/ClusterNative.h"
 
-#include "GPUO2Interface.h"
+#include "GPUO2ExternalUser.h"
 #include "GPUO2InterfaceConfiguration.h"
 #include "TPCBase/Sector.h"
 #include "Framework/Logger.h"
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
index b4bfbddf7a4e6..9f3b9b27d37b5 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
@@ -18,7 +18,7 @@
 #include "Framework/Task.h"
 #include "TStopwatch.h"
 #include "TRDBase/GeometryFlat.h"
-#include "GPUO2Interface.h"
+#include "GPUO2ExternalUser.h"
 #include "GPUTRDTracker.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index b8b017f04c612..0644e533e9d64 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -23,7 +23,7 @@
 #include "GPUCommonDef.h"
 
 #if !defined(GPUCA_STANDALONE) && !defined(GPUCA_O2_LIB) && !defined(GPUCA_O2_INTERFACE)
-  #error You are using the CA GPU tracking without defining the build type (O2/Standalone). If you are running an O2 ROOT macro, please include GPUO2Interface.h first!
+  #error You are using the CA GPU tracking without defining the build type (O2/Standalone). If you are running an O2 ROOT macro, please include GPUO2ExternalUser.h first!
 #endif
 
 #if (defined(GPUCA_O2_LIB) && defined(GPUCA_STANDALONE))
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 20bb746117d15..5c4c95b451bed 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -19,7 +19,7 @@
 // Create plain-C struct for GPU code.
 // Create static constexpr with default values for GPU run time compilation
 
-#include "GPUDefConstantsAndSettings.h"
+#include "GPUCommonDef.h"
 #ifndef GPUSETTINGS_H
 #error Please include GPUSettings.h!
 #endif
diff --git a/GPU/GPUTracking/Interface/CMakeLists.txt b/GPU/GPUTracking/Interface/CMakeLists.txt
index e532b24f97908..169b043b992bc 100644
--- a/GPU/GPUTracking/Interface/CMakeLists.txt
+++ b/GPU/GPUTracking/Interface/CMakeLists.txt
@@ -23,7 +23,7 @@ if(OPENGL_FOUND
 endif()
 
 string(REPLACE ".cxx" ".h" HDRS_TMP "${SRCS}")
-set(HDRS ${HDRS_TMP})
+set(HDRS ${HDRS_TMP} GPUO2ExternalUser.h)
 
 o2_add_library(${MODULE}
                SOURCES ${SRCS}
diff --git a/GPU/GPUTracking/Interface/GPUO2ExternalUser.h b/GPU/GPUTracking/Interface/GPUO2ExternalUser.h
new file mode 100644
index 0000000000000..1e5261e0065a6
--- /dev/null
+++ b/GPU/GPUTracking/Interface/GPUO2ExternalUser.h
@@ -0,0 +1,26 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUO2ExternalUser.h
+/// \author David Rohr
+
+#ifndef GPUO2EXTERNALUSER_H
+#define GPUO2EXTERNALUSER_H
+
+// Some defines denoting that we are compiling for O2
+#ifndef GPUCA_TPC_GEOMETRY_O2
+#define GPUCA_TPC_GEOMETRY_O2
+#endif
+#ifndef GPUCA_O2_INTERFACE
+#define GPUCA_O2_INTERFACE
+#endif
+
+#endif
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.h b/GPU/GPUTracking/Interface/GPUO2Interface.h
index 0e2020b306984..00c72cc5e3359 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.h
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.h
@@ -15,19 +15,13 @@
 #ifndef GPUO2INTERFACE_H
 #define GPUO2INTERFACE_H
 
-// Some defines denoting that we are compiling for O2
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
-#ifndef GPUCA_O2_INTERFACE
-#define GPUCA_O2_INTERFACE
-#endif
+#include "GPUO2ExternalUser.h"
+#include "GPUCommonDef.h"
+#include "GPUDataTypes.h"
 
 #include <memory>
 #include <array>
 #include <vector>
-#include "GPUCommonDef.h"
-#include "GPUDataTypes.h"
 
 namespace o2::base
 {
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h b/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h
index ebb426b7a8cfe..676d2c22f57c7 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h
@@ -22,12 +22,8 @@
 #ifndef GPUO2INTERFACECONFIGURABLEPARAM_H
 #define GPUO2INTERFACECONFIGURABLEPARAM_H
 
-// Some defines denoting that we are compiling for O2
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
-#ifndef GPUCA_O2_INTERFACE
-#define GPUCA_O2_INTERFACE
+#if !defined(GPUCA_STANDALONE) && !defined(GPUCA_O2_LIB)
+#include "GPUO2ExternalUser.h"
 #endif
 
 #include "CommonUtils/ConfigurableParam.h"
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.h b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.h
index af597fc4bf6b9..f378fc2c4fb7b 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.h
@@ -15,23 +15,17 @@
 #ifndef GPUO2INTERFACECONFIGURATION_H
 #define GPUO2INTERFACECONFIGURATION_H
 
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
-#ifndef GPUCA_O2_INTERFACE
-#define GPUCA_O2_INTERFACE
-#endif
-
-#include <memory>
-#include <array>
-#include <vector>
-#include <functional>
-#include <gsl/gsl>
+#include "GPUO2ExternalUser.h"
 #include "GPUSettings.h"
 #include "GPUDataTypes.h"
 #include "GPUHostDataTypes.h"
 #include "GPUOutputControl.h"
 #include "DataFormatsTPC/Constants.h"
+#include <memory>
+#include <array>
+#include <vector>
+#include <functional>
+#include <gsl/gsl> // TODO: Get rid of gsl
 
 class TH1F;
 class TH1D;
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.h b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.h
index e6d9cb76aed79..a7e9d309b6d3d 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.h
@@ -15,14 +15,7 @@
 #ifndef GPUO2INTERFACEDisplay_H
 #define GPUO2INTERFACEDisplay_H
 
-// Some defines denoting that we are compiling for O2
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
-#ifndef GPUCA_O2_INTERFACE
-#define GPUCA_O2_INTERFACE
-#endif
-
+#include "GPUO2ExternalUser.h"
 #include <memory>
 #include <vector>
 #include "GPUDataTypes.h"
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceQA.h b/GPU/GPUTracking/Interface/GPUO2InterfaceQA.h
index 18af81b6cedc7..3fc4cda0a1dcc 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceQA.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceQA.h
@@ -15,14 +15,7 @@
 #ifndef GPUO2INTERFACEQA_H
 #define GPUO2INTERFACEQA_H
 
-// Some defines denoting that we are compiling for O2
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
-#ifndef GPUCA_O2_INTERFACE
-#define GPUCA_O2_INTERFACE
-#endif
-
+#include "GPUO2ExternalUser.h"
 #include <memory>
 #include <vector>
 
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
index 9f743c89d5743..d4aa6900e308a 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
@@ -15,14 +15,7 @@
 #ifndef GPUO2INTERFACEREFIT_H
 #define GPUO2INTERFACEREFIT_H
 
-// Some defines denoting that we are compiling for O2
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
-#ifndef GPUCA_O2_INTERFACE
-#define GPUCA_O2_INTERFACE
-#endif
-
+#include "GPUO2ExternalUser.h"
 #include <memory>
 #include <vector>
 #include <gsl/span>
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index 7279f2ee87fdb..837995ef38bb4 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -19,6 +19,7 @@
 #include "backend/GPUDisplayBackend.h"
 #include "GPUDisplayInterface.h"
 #include "GPUSettings.h"
+#include "GPUDefConstantsAndSettings.h"
 
 #include <array>
 #include <mutex>
diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index fe55b83633972..b1c8d619ec736 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -13,6 +13,7 @@
 /// @author David Rohr, Matteo Concas
 
 #include "GPUWorkflow/GPUWorkflowSpec.h"
+#include "GPUO2Interface.h"
 #include "Framework/WorkflowSpec.h" // o2::framework::mergeInputs
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"

From 932036f3a5adbc5cbd4de340fb2804562fda9c34 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Wed, 12 Nov 2025 11:44:21 +0100
Subject: [PATCH 1036/1764] Forward interaction rate to collision context

---
 DataFormats/simulation/src/DigitizationContext.cxx | 1 +
 Steer/src/CollisionContextTool.cxx                 | 8 ++++++++
 2 files changed, 9 insertions(+)

diff --git a/DataFormats/simulation/src/DigitizationContext.cxx b/DataFormats/simulation/src/DigitizationContext.cxx
index b05889300340c..79e36aa9fa48b 100644
--- a/DataFormats/simulation/src/DigitizationContext.cxx
+++ b/DataFormats/simulation/src/DigitizationContext.cxx
@@ -699,6 +699,7 @@ DigitizationContext DigitizationContext::extractSingleTimeframe(int timeframeid,
   r.mSimPrefixes = mSimPrefixes;
   r.mMuBC = mMuBC;
   r.mBCFilling = mBCFilling;
+  r.mDigitizerInteractionRate = mDigitizerInteractionRate;
   try {
     auto tf_ranges = timeframeindices.at(timeframeid);
 
diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index 710476bed32f9..6a2fca20afe76 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -552,8 +552,16 @@ int main(int argc, char* argv[])
   }
   digicontext.setBunchFilling(bunchFillings[0]);
   std::vector<std::string> prefixes;
+  // Signal interaction rate
+  float sgnIRate = -1.;
   for (auto& p : ispecs) {
     prefixes.push_back(p.name);
+    if (p.name == "sgn") {
+      // Setting interaction rate in the digitizer context as provided by the O2DPG workflow
+      LOG(debug) << "Setting signal interaction rate to " << p.interactionRate << " Hz in the digitization context.";
+      sgnIRate = p.interactionRate;
+      digicontext.setDigitizerInteractionRate(p.interactionRate);
+    }
   }
   digicontext.setSimPrefixes(prefixes);
 

From ea2972eba73be699254287fc819e0e300770cc06 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Nov 2025 13:08:10 +0100
Subject: [PATCH 1037/1764] GPU CMake: Add option to override deterministic
 mode

---
 dependencies/FindO2GPU.cmake | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 4813ac18eae72..5815657ff6386 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 5
+# FindO2GPU.cmake Version 6
 
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
@@ -71,6 +71,9 @@ endfunction()
 STRING(REGEX REPLACE "\-std=[^ ]*" "" O2_GPU_CMAKE_CXX_FLAGS_NOSTD "${CMAKE_CXX_FLAGS}")
 
 # ================================== Fast Math / Deterministic Mode ==================================
+if(DEFINED ENV{O2_OVERRIDE_GPUCA_DETERMINISTIC_MODE})
+  set(GPUCA_DETERMINISTIC_MODE $ENV{O2_OVERRIDE_GPUCA_DETERMINISTIC_MODE})
+endif()
 # set(GPUCA_DETERMINISTIC_MODE WHOLEO2)          # Override
 set(GPUCA_DETERMINISTIC_MODE_MAP_OFF 0)
 set(GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH 1) # No -ffast-math and similar compile flags for GPU folder

From fb593d660e068b7cffb3bfa610f592dbe1c0b8ff Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Nov 2025 13:13:16 +0100
Subject: [PATCH 1038/1764] GPU: If deterministic compile time option set,
 default for deterministic runtime setting should be 1

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 4 ++++
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 01af74d903f72..d93ad2e178b89 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -264,7 +264,11 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     mProcessingSettings->recoTaskTiming = true;
   }
   if (GetProcessingSettings().deterministicGPUReconstruction == -1) {
+#ifdef GPUCA_DETERMINISTIC_MODE
+    mProcessingSettings->deterministicGPUReconstruction = 1;
+#else
     mProcessingSettings->deterministicGPUReconstruction = GetProcessingSettings().debugLevel >= 6;
+#endif
   }
   if (GetProcessingSettings().deterministicGPUReconstruction) {
 #ifndef GPUCA_DETERMINISTIC_MODE
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 5c4c95b451bed..b21b492fad0df 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -306,7 +306,7 @@ AddOption(debugMask, uint32_t, (1 << 18) - 1, "debugMask", 0, "Mask for debug ou
 AddOption(debugLogSuffix, std::string, "", "debugSuffix", 0, "Suffix for debug log files with --debug 6")
 AddOption(serializeGPU, int8_t, 0, "", 0, "Synchronize after each kernel call (bit 1) and DMA transfer (bit 2) and identify failures")
 AddOption(recoTaskTiming, bool, 0, "", 0, "Perform summary timing after whole reconstruction tasks")
-AddOption(deterministicGPUReconstruction, int32_t, -1, "", 0, "Make CPU and GPU debug output comparable (sort / skip concurrent parts), -1 = automatic if debugLevel >= 6", def(1))
+AddOption(deterministicGPUReconstruction, int32_t, -1, "", 0, "Make CPU and GPU debug output comparable (sort / skip concurrent parts), -1 = automatic if debugLevel >= 6 or deterministic compile flag set", def(1))
 AddOption(showOutputStat, bool, false, "", 0, "Print some track output statistics")
 AddOption(runCompressionStatistics, bool, false, "compressionStat", 0, "Run statistics and verification for cluster compression")
 AddOption(resetTimers, int8_t, 1, "", 0, "Reset timers every event")

From bef1aefa049b4e703c0c82a320f6fae8615e284e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 18 Nov 2025 00:55:16 +0100
Subject: [PATCH 1039/1764] GPU: Rename GPU ConfigurableParam header, and move
 it to DataTypes together with ExternalUser header

---
 Detectors/TPC/workflow/src/CalibdEdxSpec.cxx          |  2 +-
 Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx     |  2 +-
 GPU/GPUTracking/CMakeLists.txt                        |  3 ++-
 .../GPUO2ConfigurableParam.cxx}                       |  6 +++---
 .../GPUO2ConfigurableParam.h}                         | 11 ++++-------
 .../{Interface => DataTypes}/GPUO2ExternalUser.h      |  0
 GPU/GPUTracking/Interface/CMakeLists.txt              |  2 +-
 doc/data/2021-01-o2_prs.json                          |  2 +-
 8 files changed, 13 insertions(+), 15 deletions(-)
 rename GPU/GPUTracking/{Interface/GPUO2InterfaceConfigurableParam.cxx => DataTypes/GPUO2ConfigurableParam.cxx} (97%)
 rename GPU/GPUTracking/{Interface/GPUO2InterfaceConfigurableParam.h => DataTypes/GPUO2ConfigurableParam.h} (90%)
 rename GPU/GPUTracking/{Interface => DataTypes}/GPUO2ExternalUser.h (100%)

diff --git a/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx b/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
index 5cf412f227d78..e3943f92235ab 100644
--- a/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
@@ -26,7 +26,7 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
-#include "GPUO2InterfaceConfigurableParam.h"
+#include "GPUO2ConfigurableParam.h"
 #include "TPCCalibration/CalibdEdx.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "TPCBase/CDBTypes.h"
diff --git a/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx b/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
index 4c2a26da38908..82e6d5075d7f0 100644
--- a/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
@@ -29,7 +29,7 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
-#include "GPUO2InterfaceConfigurableParam.h"
+#include "GPUO2ConfigurableParam.h"
 #include "TPCCalibration/CalibratordEdx.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "DetectorsBase/GRPGeomHelper.h"
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 29c95eba4280a..2a0b9b9edfa09 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -130,6 +130,7 @@ set(HDRS_INSTALL
     DataTypes/GPUTRDInterfaceO2Track.h
     DataTypes/GPUTriggerOutputs.h
     DataTypes/GPUKernelClassesFwd.h
+    DataTypes/GPUO2ExternalUser.h
     Debug/GPUROOTDump.h
     Definitions/GPUDefConstantsAndSettings.h
     Definitions/GPUDefParametersWrapper.h
@@ -228,7 +229,7 @@ set(HDRS_INSTALL ${HDRS_INSTALL}
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   set(SRCS_DATATYPES
       ${SRCS_DATATYPES}
-      Interface/GPUO2InterfaceConfigurableParam.cxx)
+      DataTypes/GPUO2ConfigurableParam.cxx)
 endif()
 
 set(TEMPLATE_HEADER_LIST Base/GPUReconstructionKernelList.template.h
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.cxx b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
similarity index 97%
rename from GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.cxx
rename to GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
index 86ae8e3457019..f5b3ea8b285f5 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
@@ -9,11 +9,11 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUO2InterfaceConfigurableParam.cxx
+/// \file GPUO2ConfigurableParam.cxx
 /// \author David Rohr
 
-#include "GPUO2InterfaceConfigurableParam.h"
-#include "GPUO2InterfaceConfiguration.h"
+#include "GPUO2ConfigurableParam.h"
+#include "Interface/GPUO2InterfaceConfiguration.h"
 #include "GPUDataTypes.h"
 #include "GPUConfigDump.h"
 
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.h
similarity index 90%
rename from GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h
rename to GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.h
index 676d2c22f57c7..8bc0d98910f54 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.h
+++ b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.h
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUO2InterfaceConfigurableParam.h
+/// \file GPUO2ConfigurableParam.h
 /// \author David Rohr
 
 // This file auto-generates a ConfigurableParam object from the GPU parameter macros.
@@ -19,13 +19,10 @@
 // --configKeyValues "GPU_proc.[x]=[y]" : for processing options steering GPU reconstruction like GPU device ID, debug output level, number of CPU threads.
 // Check GPUSettingsList.h for all options
 
-#ifndef GPUO2INTERFACECONFIGURABLEPARAM_H
-#define GPUO2INTERFACECONFIGURABLEPARAM_H
+#ifndef GPUO2CONFIGURABLEPARAM_H
+#define GPUO2CONFIGURABLEPARAM_H
 
-#if !defined(GPUCA_STANDALONE) && !defined(GPUCA_O2_LIB)
 #include "GPUO2ExternalUser.h"
-#endif
-
 #include "CommonUtils/ConfigurableParam.h"
 #include "CommonUtils/ConfigurableParamHelper.h"
 #include "GPUSettings.h"
@@ -46,7 +43,7 @@
 #define AddSubConfig(name, instance)
 #define BeginSubConfig(name, instance, parent, preoptname, preoptnameshort, descr, o2prefix)                                           \
   struct GPUCA_M_CAT(GPUConfigurableParam, name) : public o2::conf::ConfigurableParamHelper<GPUCA_M_CAT(GPUConfigurableParam, name)> { \
-   O2ParamDef(GPUCA_M_CAT(GPUConfigurableParam, name), GPUCA_M_STR(GPUCA_M_CAT(GPU_, o2prefix))) public:
+    O2ParamDef(GPUCA_M_CAT(GPUConfigurableParam, name), GPUCA_M_STR(GPUCA_M_CAT(GPU_, o2prefix))) public:
 #define BeginHiddenConfig(name, instance) struct GPUCA_M_CAT(GPUConfigurableParam, name) {
 #define EndConfig() \
   }                 \
diff --git a/GPU/GPUTracking/Interface/GPUO2ExternalUser.h b/GPU/GPUTracking/DataTypes/GPUO2ExternalUser.h
similarity index 100%
rename from GPU/GPUTracking/Interface/GPUO2ExternalUser.h
rename to GPU/GPUTracking/DataTypes/GPUO2ExternalUser.h
diff --git a/GPU/GPUTracking/Interface/CMakeLists.txt b/GPU/GPUTracking/Interface/CMakeLists.txt
index 169b043b992bc..e532b24f97908 100644
--- a/GPU/GPUTracking/Interface/CMakeLists.txt
+++ b/GPU/GPUTracking/Interface/CMakeLists.txt
@@ -23,7 +23,7 @@ if(OPENGL_FOUND
 endif()
 
 string(REPLACE ".cxx" ".h" HDRS_TMP "${SRCS}")
-set(HDRS ${HDRS_TMP} GPUO2ExternalUser.h)
+set(HDRS ${HDRS_TMP})
 
 o2_add_library(${MODULE}
                SOURCES ${SRCS}
diff --git a/doc/data/2021-01-o2_prs.json b/doc/data/2021-01-o2_prs.json
index e287eaeeda857..06cd97dd6d7b7 100644
--- a/doc/data/2021-01-o2_prs.json
+++ b/doc/data/2021-01-o2_prs.json
@@ -1730,7 +1730,7 @@
                 },
                 {
                   "node": {
-                    "path": "GPU/GPUTracking/Interface/GPUO2InterfaceConfigurableParam.cxx"
+                    "path": "GPU/GPUTracking/Interface/GPUO2ConfigurableParam.cxx"
                   }
                 },
                 {

From 7f6ab4a1ac887800c765b90f049e8acad854c52b Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 18 Nov 2025 14:17:57 +0100
Subject: [PATCH 1040/1764] DPL Analysis: protect aod-spawner from empty input

---
 Framework/Core/src/AODReaderHelpers.cxx | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index febc19e02834e..0c556920d3fcb 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -156,6 +156,9 @@ struct Maker {
       originals.push_back(pc.inputs().get<TableConsumer>(label)->asArrowTable());
     }
     auto fullTable = soa::ArrowHelpers::joinTables(std::move(originals), std::span{labels.begin(), labels.size()});
+    if (fullTable->num_rows() == 0) {
+      return arrow::Table::MakeEmpty(schema).ValueOrDie();
+    }
     if (projector == nullptr) {
       auto s = gandiva::Projector::Make(
         fullTable->schema(),

From a46779a64e0c90444f6088ce84c5117e8a1084bf Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 12 Nov 2025 15:45:11 +0100
Subject: [PATCH 1041/1764] GPU TPC: Dynamically increase the protection /
 decrease the removal tube at inner pad rows, edge pads, high local occupancy

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  2 +-
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 14 +++++---
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 34 +++++++++++--------
 .../TPCConvert/GPUTPCConvertImpl.h            |  2 +-
 GPU/TPCFastTransformation/TPCFastTransform.h  |  8 +++++
 5 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index d93ad2e178b89..be2aff617ff34 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -752,7 +752,7 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
   void*& poolend = (type & GPUMemoryResource::MEMORY_GPU) ? mDeviceMemoryPoolEnd : mHostMemoryPoolEnd;
   char* retVal;
   if ((type & GPUMemoryResource::MEMORY_STACK)) {
-    poolend = (char*)poolend - size;
+    poolend = (char*)poolend - size; // TODO: Implement overflow check
     poolend = (char*)poolend - GPUProcessor::getAlignmentMod<GPUCA_MEMALIGN>(poolend);
     retVal = (char*)poolend;
   } else {
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index b21b492fad0df..052da8ae54c60 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -68,11 +68,12 @@ AddOptionRTC(minNClustersFinalTrack, int32_t, -1, "", 0, "required min number of
 AddOptionRTC(searchWindowDZDR, float, 2.5f, "", 0, "Use DZDR window for seeding instead of neighboursSearchArea")
 AddOptionRTC(trackReferenceX, float, 1000.f, "", 0, "Transport all tracks to this X after tracking (disabled if > 500, auto = 1000)")
 AddOptionRTC(zsThreshold, float, 2.0f, "", 0, "Zero-Suppression threshold")
-AddOptionRTC(tubeProtectSigma2, float, 5.f * 5.f, "", 0, "Max sigma2 to mark adjacent cluster for protection")
-AddOptionRTC(tubeProtectMaxSize2, float, 3.5f * 3.5f, "", 0, "Square of max tube size (if smaller than tubeProtectChi2)")
-AddOptionRTC(tubeProtectMinSize2, float, 1.0f * 1.0f, "", 0, "Square of min tube size (if larger than tubeProtectChi2)")
-AddOptionRTC(tubeRemoveSigma2, float, 1.f * 1.f, "", 0, "Max sigma2 to mark adjacent cluster for removal")
-AddOptionRTC(tubeRemoveMaxSize2, float, 1.5f * 1.5f, "", 0, "Square of max tube size (if smaller than tubeRejectChi2)")
+AddOptionRTC(tubeProtectSigma2, float, 4.f * 4.f, "", 0, "Max sigma2 to mark adjacent cluster for protection")
+AddOptionRTC(tubeProtectMaxSize2, float, 2.f * 2.f, "", 0, "Square of max tube size (if smaller than tubeProtectChi2)")
+AddOptionRTC(tubeProtectMinSize2, float, 0.5f * 0.5f, "", 0, "Square of min tube size (if larger than tubeProtectChi2)")
+AddOptionRTC(tubeRemoveSigma2, float, 1.25f * 1.25f, "", 0, "Max sigma2 to mark adjacent cluster for removal")
+AddOptionRTC(tubeRemoveMaxSize2, float, 2.5f * 2.5f, "", 0, "Square of max tube size (if smaller than tubeRejectChi2)")
+AddOptionRTC(tubeExtraProtectMinOccupancy, uint32_t, 1500, "", 0, "Increase Protection, decrease removal by factor 2, when above this lokal occupancy / rowx")
 AddOptionRTC(clustersShiftTimebins, float, 0, "", 0, "Shift of TPC clusters (applied during CTF cluster decoding)")
 AddOptionRTC(clustersShiftTimebinsClusterizer, float, 0, "", 0, "Shift of TPC clusters (applied during CTF clusterization)")
 AddOptionRTC(clustersEdgeFixDistance, float, 0.f, "", 0, "If >0, revert cluster.flag edge bit distance to edge exceeds this parameter (fixed during CTF decoding)")
@@ -162,6 +163,9 @@ AddOptionRTC(dEdxClusterRejectionFlagMask, int8_t, o2::gpu::GPUTPCGMMergedTrackH
 AddOptionRTC(dEdxClusterRejectionFlagMaskAlt, int8_t, o2::gpu::GPUTPCGMMergedTrackHit::flagEdge, "", 0, "OR mask of TPC flags that will reject the cluster in alternative dEdx")
 AddOptionRTC(rejectEdgeClustersInSeeding, int8_t, 0, "", 0, "Reject edge clusters based on uncorrected track Y during seeding")
 AddOptionRTC(rejectEdgeClustersInTrackFit, int8_t, 0, "", 0, "Reject edge clusters based on uncorrected track Y during track fit")
+AddOptionRTC(tubeExtraProtectMinRow, uint8_t, 20, "", 0, "Increase Protection, decrease removal by factor 2, when below this row")
+AddOptionRTC(tubeExtraProtectEdgePads, uint8_t, 2, "", 0, "Increase Protection, decrease removal by factor 2, when on this number of pads from the edge")
+
 AddOptionArray(PID_remap, int8_t, 9, (0, 1, 2, 3, 4, 5, 6, 7, 8), "", 0, "Remap Ipid to PID_reamp[Ipid] (no remap if<0)") // BUG: CUDA cannot yet hand AddOptionArrayRTC
 AddHelp("help", 'h')
 EndConfig()
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 7baa3b7e11b4f..70fb9cd1a769e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -248,7 +248,6 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
         const float invCharge = merger->GetConstantMem()->ioPtrs.clustersNative ? (1.f / merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[cluster.num].qMax) : 0.f;
         float invAvgCharge = (sumInvSqrtCharge += invSqrtCharge) / ++nAvgCharge;
         invAvgCharge *= invAvgCharge;
-
         prop.GetErr2(err2Y, err2Z, param, zz, cluster.row, clusterState, cluster.sector, time, invAvgCharge, invCharge);
 
         if (rejectChi2 >= GPUTPCGMPropagator::rejectInterFill) {
@@ -491,7 +490,8 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
 
 GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, float Y, float Z)
 {
-  if (Merger->Param().rec.tpc.disableRefitAttachment & 1) {
+  const auto& param = Merger->Param();
+  if (param.rec.tpc.disableRefitAttachment & 1) {
     return -1e6f;
   }
   const GPUTPCTracker& GPUrestrict() tracker = *(Merger->GetConstantMem()->tpcTrackers + sector);
@@ -502,34 +502,40 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
     return -1e6f;
   }
 
-  const float zOffset = Merger->Param().par.continuousTracking ? Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, Merger->Param().continuousMaxTimeBin) : 0;
+  const float zOffset = param.par.continuousTracking ? Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, param.continuousMaxTimeBin) : 0; // TODO: do some validatiomns for the transform conv functions...
   const float y0 = row.Grid().YMin();
   const float stepY = row.HstepY();
   const float z0 = row.Grid().ZMin() - zOffset; // We can use our own ZOffset, since this is only used temporarily anyway
   const float stepZ = row.HstepZ();
   int32_t bin, ny, nz;
 
-  bool protect = CAMath::Abs(GetQPt() * Merger->Param().qptB5Scaler) <= Merger->Param().rec.tpc.rejectQPtB5 && goodLeg;
+  float uncorrectedY, uncorrectedZ;
+  Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(sector, iRow, Y, Z, uncorrectedY, uncorrectedZ);
+  if (CAMath::Abs(uncorrectedY) > row.getTPCMaxY()) {
+    return uncorrectedY;
+  }
 
+  bool protect = CAMath::Abs(GetQPt() * param.qptB5Scaler) <= param.rec.tpc.rejectQPtB5 && goodLeg;
   float err2Y, err2Z;
-  Merger->Param().GetClusterErrors2(sector, iRow, Z, mP[2], mP[3], -1.f, 0.f, 0.f, err2Y, err2Z);                                       // TODO: Use correct time/avgCharge
-  const float tubeMaxSize2 = protect ? Merger->Param().rec.tpc.tubeProtectMaxSize2 : Merger->Param().rec.tpc.tubeRemoveMaxSize2;
-  const float tubeMinSize2 = protect ? Merger->Param().rec.tpc.tubeProtectMinSize2 : 0.f;
-  const float tubeSigma2 = protect ? Merger->Param().rec.tpc.tubeProtectSigma2 : Merger->Param().rec.tpc.tubeRemoveSigma2;
+  param.GetClusterErrors2(sector, iRow, Z, mP[2], mP[3], -1.f, 0.f, 0.f, err2Y, err2Z); // TODO: Use correct time/avgCharge
+  const float tubeMaxSize2 = protect ? param.rec.tpc.tubeProtectMaxSize2 : param.rec.tpc.tubeRemoveMaxSize2;
+  const float tubeMinSize2 = protect ? param.rec.tpc.tubeProtectMinSize2 : 0.f;
+  float tubeSigma2 = protect ? param.rec.tpc.tubeProtectSigma2 : param.rec.tpc.tubeRemoveSigma2;
+  uint32_t pad = CAMath::Float2UIntRn(GPUTPCGeometry::LinearY2Pad(sector, iRow, uncorrectedY));
+  float time = Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->InverseTransformInTimeFrame(sector, uncorrectedZ + (param.par.continuousTracking ? Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, param.continuousMaxTimeBin) : 0), param.continuousMaxTimeBin); // TODO: Simplify this call in TPCFastTransform
+  if (iRow < param.rec.tpc.tubeExtraProtectMinRow ||
+      pad < param.rec.tpc.tubeExtraProtectEdgePads || pad >= (uint32_t)(GPUTPCGeometry::NPads(iRow) - param.rec.tpc.tubeExtraProtectEdgePads) ||
+      param.GetUnscaledMult(time) / GPUTPCGeometry::Row2X(iRow) > param.rec.tpc.tubeExtraProtectMinOccupancy) {
+    tubeSigma2 *= protect ? 2 : 0.5;
+  }
   const float sy2 = CAMath::Max(tubeMinSize2, CAMath::Min(tubeMaxSize2, tubeSigma2 * (err2Y + CAMath::Abs(mC[0])))); // Cov can be bogus when following circle
   const float sz2 = CAMath::Max(tubeMinSize2, CAMath::Min(tubeMaxSize2, tubeSigma2 * (err2Z + CAMath::Abs(mC[2])))); // In that case we should provide the track error externally
   const float tubeY = CAMath::Sqrt(sy2);
   const float tubeZ = CAMath::Sqrt(sz2);
   const float sy21 = 1.f / sy2;
   const float sz21 = 1.f / sz2;
-  float uncorrectedY, uncorrectedZ;
-  Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(sector, iRow, Y, Z, uncorrectedY, uncorrectedZ);
 
-  if (CAMath::Abs(uncorrectedY) > row.getTPCMaxY()) {
-    return uncorrectedY;
-  }
   row.Grid().GetBinArea(uncorrectedY, uncorrectedZ + zOffset, tubeY, tubeZ, bin, ny, nz);
-
   const int32_t nBinsY = row.Grid().Ny();
   const int32_t idOffset = tracker.Data().ClusterIdOffset();
   const int32_t* ids = &(tracker.Data().ClusterDataIndex()[row.HitNumberOffset()]);
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h b/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
index dd9a74f9b9131..b185a01a3f392 100644
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
+++ b/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
@@ -28,7 +28,7 @@ class GPUTPCConvertImpl
  public:
   GPUd() static void convert(const GPUConstantMem& GPUrestrict() cm, int32_t sector, int32_t row, float pad, float time, float& GPUrestrict() x, float& GPUrestrict() y, float& GPUrestrict() z)
   {
-    if (cm.param.par.continuousTracking) {
+    if (cm.param.par.continuousTracking) { // TODO: This might be wrong, don't we just need to do TransformInTimeframe always
       cm.calibObjects.fastTransformHelper->getCorrMap()->TransformInTimeFrame(sector, row, pad, time, x, y, z, cm.param.continuousMaxTimeBin);
     } else {
       cm.calibObjects.fastTransformHelper->Transform(sector, row, pad, time, x, y, z);
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 14cd892b2554a..d9e35ba8bf405 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -194,6 +194,7 @@ class TPCFastTransform : public FlatObject
 
   /// Inverse transformation
   GPUd() void InverseTransformInTimeFrame(int32_t slice, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const;
+  GPUd() float InverseTransformInTimeFrame(int32_t slice, float z, float maxTimeBin) const;
 
   /// Inverse transformation: Transformed Y and Z -> transformed X
   GPUd() void InverseTransformYZtoX(int32_t slice, int32_t row, float y, float z, float& x, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
@@ -667,6 +668,13 @@ GPUdi() void TPCFastTransform::InverseTransformInTimeFrame(int32_t slice, int32_
   convUVtoPadTimeInTimeFrame(slice, row, u, v, pad, time, maxTimeBin);
 }
 
+GPUdi() float TPCFastTransform::InverseTransformInTimeFrame(int32_t slice, float z, float maxTimeBin) const
+{
+  float pad, time;
+  InverseTransformInTimeFrame(slice, 0, 0, 0, z, pad, time, maxTimeBin);
+  return time;
+}
+
 GPUdi() void TPCFastTransform::TransformIdealZ(int32_t slice, float time, float& z, float vertexTime) const
 {
   /// _______________ The main method: cluster transformation _______________________

From cd3de5c0fcb0f1038224af5eaf19da29ddd2d3d0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 14 Nov 2025 15:27:10 +0100
Subject: [PATCH 1042/1764] GPU TPC: occuapncy Map needs bounds check

---
 GPU/GPUTracking/Base/GPUParam.cxx             |  1 +
 GPU/GPUTracking/Base/GPUParam.h               |  1 +
 GPU/GPUTracking/Base/GPUParam.inc             |  2 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx | 19 ++++++++++++++-----
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |  2 +-
 .../Global/GPUChainTrackingSectorTracker.cxx  |  6 +++---
 .../Global/GPUTrackingInputProvider.cxx       |  3 ++-
 .../Global/GPUTrackingInputProvider.h         |  1 +
 .../Interface/GPUO2InterfaceUtils.cxx         |  2 ++
 .../Standalone/Benchmark/standalone.cxx       |  2 +-
 10 files changed, 27 insertions(+), 12 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index cc3c6a8bb9140..7095766e8512e 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -35,6 +35,7 @@ void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
   memset((void*)this, 0, sizeof(*this));
   new (&rec) GPUSettingsRec;
   occupancyMap = nullptr;
+  occupancyMapSize = 0;
   occupancyTotal = 0;
 
 #ifdef GPUCA_TPC_GEOMETRY_O2
diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 2564fc9bf0462..847f3e05ea32e 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -63,6 +63,7 @@ struct GPUParam_t {
   GPUTPCGMPolynomialField polynomialField; // Polynomial approx. of magnetic field for TPC GM
   const uint32_t* occupancyMap;            // Ptr to TPC occupancy map
   uint32_t occupancyTotal;                 // Total occupancy in the TPC (nCl / nHbf)
+  uint32_t occupancyMapSize;               // Size of occupancy map
 
   GPUParamSector SectorParam[GPUCA_NSECTORS];
 
diff --git a/GPU/GPUTracking/Base/GPUParam.inc b/GPU/GPUTracking/Base/GPUParam.inc
index a118a8f639fe9..dbccca4d7c46b 100644
--- a/GPU/GPUTracking/Base/GPUParam.inc
+++ b/GPU/GPUTracking/Base/GPUParam.inc
@@ -213,7 +213,7 @@ GPUdi() float GPUParam::GetUnscaledMult(float time) const
   if (!occupancyMap) {
     return 0.f;
   }
-  const uint32_t bin = CAMath::Max(0.f, time / rec.tpc.occupancyMapTimeBins);
+  const uint32_t bin = CAMath::Min<uint32_t>(occupancyMapSize - 1, CAMath::Max(0.f, time / rec.tpc.occupancyMapTimeBins));
   return occupancyMap[bin];
 }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index bdf1ade37868c..6ba77e25221ae 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -31,6 +31,7 @@
 #include "GPULogging.h"
 #include "GPUMemorySizeScalers.h"
 #include "GPUReconstructionProcessingKernels.inc"
+#include "GPUTPCClusterOccupancyMap.h"
 
 #include <atomic>
 #include <ctime>
@@ -355,17 +356,25 @@ void GPUReconstructionCPU::ResetDeviceProcessorTypes()
   }
 }
 
-void GPUReconstructionCPU::UpdateParamOccupancyMap(const uint32_t* mapHost, const uint32_t* mapGPU, uint32_t occupancyTotal, int32_t stream)
+void GPUReconstructionCPU::UpdateParamOccupancyMap(const uint32_t* mapHost, const uint32_t* mapGPU, uint32_t occupancyTotal, uint32_t mapSize, int32_t stream)
 {
+  if (mapHost && mapSize != GPUTPCClusterOccupancyMapBin::getNBins(param())) {
+    throw std::runtime_error("Updating occupancy map with object of invalid size");
+  }
   param().occupancyMap = mapHost;
+  param().occupancyMapSize = mapSize;
   param().occupancyTotal = occupancyTotal;
   if (IsGPU()) {
-    if (!((size_t)&param().occupancyTotal - (size_t)&param().occupancyMap == sizeof(param().occupancyMap) && sizeof(param().occupancyMap) == sizeof(size_t) && sizeof(param().occupancyTotal) < sizeof(size_t))) {
+    if (!((size_t)&param().occupancyMapSize - (size_t)&param().occupancyMap == sizeof(param().occupancyMap) + sizeof(param().occupancyTotal) && sizeof(param().occupancyMap) == sizeof(void*) && sizeof(param().occupancyTotal) == sizeof(uint32_t))) { // TODO: Make static assert, and check alignment
       throw std::runtime_error("occupancy data not consecutive in GPUParam");
     }
+    struct tmpOccuapncyParam {
+      const void* ptr;
+      uint32_t total;
+      uint32_t size;
+    };
+    tmpOccuapncyParam tmp = {mapGPU, occupancyTotal, mapSize};
     const auto holdContext = GetThreadContext();
-    size_t tmp[2] = {(size_t)mapGPU, 0};
-    memcpy(&tmp[1], &occupancyTotal, sizeof(occupancyTotal));
-    WriteToConstantMemory((char*)&processors()->param.occupancyMap - (char*)processors(), &tmp, sizeof(param().occupancyMap) + sizeof(param().occupancyTotal), stream);
+    WriteToConstantMemory((char*)&processors()->param.occupancyMap - (char*)processors(), &tmp, sizeof(tmp), stream);
   }
 }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index 768c301f24327..e72a1c6686124 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -48,7 +48,7 @@ class GPUReconstructionCPU : public GPUReconstructionProcessing::KernelInterface
 
   int32_t RunChains() override;
 
-  void UpdateParamOccupancyMap(const uint32_t* mapHost, const uint32_t* mapGPU, uint32_t occupancyTotal, int32_t stream = -1);
+  void UpdateParamOccupancyMap(const uint32_t* mapHost, const uint32_t* mapGPU, uint32_t occupancyTotal, uint32_t mapSize, int32_t stream = -1);
 
  protected:
   struct GPUProcessorProcessors : public GPUProcessor {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 7ab2cfeccee80..31ceb24ecb836 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -126,11 +126,11 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     auto* ptrTmp = (GPUTPCClusterOccupancyMapBin*)mRec->AllocateVolatileMemory(GPUTPCClusterOccupancyMapBin::getTotalSize(param()), doGPU);
     runKernel<GPUMemClean16>(GetGridAutoStep(streamInitAndOccMap, RecoStep::TPCSectorTracking), ptrTmp, GPUTPCClusterOccupancyMapBin::getTotalSize(param()));
     runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fill>(GetGridBlk(GPUCA_NSECTORS * GPUCA_ROW_COUNT, streamInitAndOccMap), ptrTmp);
-    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fold>(GetGridBlk(GPUTPCClusterOccupancyMapBin::getNBins(param()), streamInitAndOccMap), ptrTmp, ptr + 2);
+    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fold>(GetGridBlk(mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap), ptrTmp, ptr + 2);
     mRec->ReturnVolatileMemory();
     mInputsHost->mTPCClusterOccupancyMap[1] = param().rec.tpc.occupancyMapTimeBins * 0x10000 + param().rec.tpc.occupancyMapTimeBinsAverage;
     if (doGPU) {
-      GPUMemCpy(RecoStep::TPCSectorTracking, mInputsHost->mTPCClusterOccupancyMap + 2, mInputsShadow->mTPCClusterOccupancyMap + 2, sizeof(*ptr) * GPUTPCClusterOccupancyMapBin::getNBins(mRec->GetParam()), streamInitAndOccMap, false, &mEvents->init);
+      GPUMemCpy(RecoStep::TPCSectorTracking, mInputsHost->mTPCClusterOccupancyMap + 2, mInputsShadow->mTPCClusterOccupancyMap + 2, sizeof(*ptr) * mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap, false, &mEvents->init);
     } else {
       TransferMemoryResourceLinkToGPU(RecoStep::TPCSectorTracking, mInputsHost->mResourceOccupancyMap, streamInitAndOccMap, &mEvents->init);
     }
@@ -138,7 +138,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   if (param().rec.tpc.occupancyMapTimeBins || param().rec.tpc.sysClusErrorC12Norm) {
     uint32_t& occupancyTotal = *mInputsHost->mTPCClusterOccupancyMap;
     occupancyTotal = CAMath::Float2UIntRn(mRec->MemoryScalers()->nTPCHits / (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasNHBFPerTF ? mIOPtrs.settingsTF->nHBFPerTF : 128));
-    mRec->UpdateParamOccupancyMap(param().rec.tpc.occupancyMapTimeBins ? mInputsHost->mTPCClusterOccupancyMap + 2 : nullptr, doGPU && param().rec.tpc.occupancyMapTimeBins ? mInputsShadow->mTPCClusterOccupancyMap + 2 : nullptr, occupancyTotal, streamInitAndOccMap);
+    mRec->UpdateParamOccupancyMap(param().rec.tpc.occupancyMapTimeBins ? mInputsHost->mTPCClusterOccupancyMap + 2 : nullptr, doGPU && param().rec.tpc.occupancyMapTimeBins ? mInputsShadow->mTPCClusterOccupancyMap + 2 : nullptr, occupancyTotal, mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap);
   }
 
   int32_t streamMap[NSECTORS];
diff --git a/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx b/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
index 7ef9baa903fbe..9bb8b230e9e0b 100644
--- a/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
+++ b/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
@@ -82,7 +82,8 @@ void* GPUTrackingInputProvider::SetPointersInputTRD(void* mem)
 void* GPUTrackingInputProvider::SetPointersTPCOccupancyMap(void* mem)
 {
   if (mHoldTPCOccupancyMap) {
-    computePointerWithAlignment(mem, mTPCClusterOccupancyMap, (mRec->GetParam().rec.tpc.occupancyMapTimeBins ? GPUTPCClusterOccupancyMapBin::getNBins(mRec->GetParam()) + 1 : 0) + 1); // +1 for total occupancy estimator, +1 for sanity check information
+    mTPCClusterOccupancyMapSize = mRec->GetParam().rec.tpc.occupancyMapTimeBins ? GPUTPCClusterOccupancyMapBin::getNBins(mRec->GetParam()) : 0;
+    computePointerWithAlignment(mem, mTPCClusterOccupancyMap, (mRec->GetParam().rec.tpc.occupancyMapTimeBins ? mTPCClusterOccupancyMapSize + 1 : 0) + 1); // +1 for total occupancy estimator, +1 for sanity check information
   }
   return mem;
 }
diff --git a/GPU/GPUTracking/Global/GPUTrackingInputProvider.h b/GPU/GPUTracking/Global/GPUTrackingInputProvider.h
index 910e87fd02126..7aee803a03ace 100644
--- a/GPU/GPUTracking/Global/GPUTrackingInputProvider.h
+++ b/GPU/GPUTracking/Global/GPUTrackingInputProvider.h
@@ -81,6 +81,7 @@ class GPUTrackingInputProvider : public GPUProcessor
   o2::tpc::ClusterNative* mPclusterNativeOutput = nullptr;
 
   uint32_t* mTPCClusterOccupancyMap = nullptr;
+  uint32_t mTPCClusterOccupancyMapSize = 0;
 
   uint32_t* mErrorCodes = nullptr;
 };
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
index 9454c9a2389ae..43b8dc21eaf15 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
@@ -26,6 +26,7 @@
 #include "TPCBase/CRU.h"
 #include "TPCBase/RDHUtils.h"
 #include "DataFormatsTPC/ZeroSuppression.h"
+#include "GPUTPCClusterOccupancyMap.h"
 #include <gsl/span>
 
 using namespace o2::gpu;
@@ -132,6 +133,7 @@ void GPUO2InterfaceUtils::paramUseExternalOccupancyMap(GPUParam* param, uint32_t
     param->occupancyTotal = *occupancymap;
     if (param->rec.tpc.occupancyMapTimeBins) {
       param->occupancyMap = occupancymap + 2;
+      param->occupancyMapSize = GPUTPCClusterOccupancyMapBin::getNBins(*param);
     }
   }
 }
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index b0ea1f5b7dbcb..ca26f26d32612 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -453,7 +453,7 @@ int32_t SetupReconstruction()
   if (configStandalone.proc.doublePipeline) {
     recPipeline->SetSettings(&grp, &recSet, &procSet, &steps);
   }
-  if (configStandalone.testSyncAsync) {
+  if (configStandalone.testSyncAsync) { // TODO: Add --async mode / flag
     // Set settings for asynchronous
     steps.steps.setBits(GPUDataTypes::RecoStep::TPCDecompression, true);
     steps.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, true);

From ea4bdbd6622ba774d0d919199ba6d09be1c0369b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 17 Nov 2025 14:55:34 +0100
Subject: [PATCH 1043/1764] GPU TPC: Fix synchronization between update of
 occupancy map and running sector tracker on GPU

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx         |  4 ++--
 GPU/GPUTracking/Base/GPUReconstructionCPU.h           |  2 +-
 .../Global/GPUChainTrackingSectorTracker.cxx          | 11 ++++++-----
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 6ba77e25221ae..3da96654b895d 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -356,7 +356,7 @@ void GPUReconstructionCPU::ResetDeviceProcessorTypes()
   }
 }
 
-void GPUReconstructionCPU::UpdateParamOccupancyMap(const uint32_t* mapHost, const uint32_t* mapGPU, uint32_t occupancyTotal, uint32_t mapSize, int32_t stream)
+void GPUReconstructionCPU::UpdateParamOccupancyMap(const uint32_t* mapHost, const uint32_t* mapGPU, uint32_t occupancyTotal, uint32_t mapSize, int32_t stream, deviceEvent* ev)
 {
   if (mapHost && mapSize != GPUTPCClusterOccupancyMapBin::getNBins(param())) {
     throw std::runtime_error("Updating occupancy map with object of invalid size");
@@ -375,6 +375,6 @@ void GPUReconstructionCPU::UpdateParamOccupancyMap(const uint32_t* mapHost, cons
     };
     tmpOccuapncyParam tmp = {mapGPU, occupancyTotal, mapSize};
     const auto holdContext = GetThreadContext();
-    WriteToConstantMemory((char*)&processors()->param.occupancyMap - (char*)processors(), &tmp, sizeof(tmp), stream);
+    WriteToConstantMemory((char*)&processors()->param.occupancyMap - (char*)processors(), &tmp, sizeof(tmp), stream, ev);
   }
 }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index e72a1c6686124..a78a482db4e7a 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -48,7 +48,7 @@ class GPUReconstructionCPU : public GPUReconstructionProcessing::KernelInterface
 
   int32_t RunChains() override;
 
-  void UpdateParamOccupancyMap(const uint32_t* mapHost, const uint32_t* mapGPU, uint32_t occupancyTotal, uint32_t mapSize, int32_t stream = -1);
+  void UpdateParamOccupancyMap(const uint32_t* mapHost, const uint32_t* mapGPU, uint32_t occupancyTotal, uint32_t mapSize, int32_t stream = -1, deviceEvent* ev = nullptr);
 
  protected:
   struct GPUProcessorProcessors : public GPUProcessor {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 31ceb24ecb836..122eb709b4356 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -100,6 +100,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
   bool streamInit[GPUCA_MAX_STREAMS] = {false};
   int32_t streamInitAndOccMap = mRec->NStreams() - 1;
 
+  bool initializeOccMap = param().rec.tpc.occupancyMapTimeBins || param().rec.tpc.sysClusErrorC12Norm;
   if (doGPU) {
     // Copy Tracker Object to GPU Memory
     if (GetProcessingSettings().debugLevel >= 3) {
@@ -109,7 +110,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       return 2;
     }
 
-    WriteToConstantMemory(RecoStep::TPCSectorTracking, (char*)processors()->tpcTrackers - (char*)processors(), processorsShadow()->tpcTrackers, sizeof(GPUTPCTracker) * NSECTORS, streamInitAndOccMap, &mEvents->init);
+    WriteToConstantMemory(RecoStep::TPCSectorTracking, (char*)processors()->tpcTrackers - (char*)processors(), processorsShadow()->tpcTrackers, sizeof(GPUTPCTracker) * NSECTORS, streamInitAndOccMap, !initializeOccMap ? &mEvents->init : nullptr);
 
     std::fill(streamInit, streamInit + mRec->NStreams(), false);
     streamInit[streamInitAndOccMap] = true;
@@ -130,15 +131,15 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     mRec->ReturnVolatileMemory();
     mInputsHost->mTPCClusterOccupancyMap[1] = param().rec.tpc.occupancyMapTimeBins * 0x10000 + param().rec.tpc.occupancyMapTimeBinsAverage;
     if (doGPU) {
-      GPUMemCpy(RecoStep::TPCSectorTracking, mInputsHost->mTPCClusterOccupancyMap + 2, mInputsShadow->mTPCClusterOccupancyMap + 2, sizeof(*ptr) * mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap, false, &mEvents->init);
+      GPUMemCpy(RecoStep::TPCSectorTracking, mInputsHost->mTPCClusterOccupancyMap + 2, mInputsShadow->mTPCClusterOccupancyMap + 2, sizeof(*ptr) * mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap, false);
     } else {
-      TransferMemoryResourceLinkToGPU(RecoStep::TPCSectorTracking, mInputsHost->mResourceOccupancyMap, streamInitAndOccMap, &mEvents->init);
+      TransferMemoryResourceLinkToGPU(RecoStep::TPCSectorTracking, mInputsHost->mResourceOccupancyMap, streamInitAndOccMap);
     }
   }
-  if (param().rec.tpc.occupancyMapTimeBins || param().rec.tpc.sysClusErrorC12Norm) {
+  if (initializeOccMap) {
     uint32_t& occupancyTotal = *mInputsHost->mTPCClusterOccupancyMap;
     occupancyTotal = CAMath::Float2UIntRn(mRec->MemoryScalers()->nTPCHits / (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasNHBFPerTF ? mIOPtrs.settingsTF->nHBFPerTF : 128));
-    mRec->UpdateParamOccupancyMap(param().rec.tpc.occupancyMapTimeBins ? mInputsHost->mTPCClusterOccupancyMap + 2 : nullptr, doGPU && param().rec.tpc.occupancyMapTimeBins ? mInputsShadow->mTPCClusterOccupancyMap + 2 : nullptr, occupancyTotal, mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap);
+    mRec->UpdateParamOccupancyMap(param().rec.tpc.occupancyMapTimeBins ? mInputsHost->mTPCClusterOccupancyMap + 2 : nullptr, doGPU && param().rec.tpc.occupancyMapTimeBins ? mInputsShadow->mTPCClusterOccupancyMap + 2 : nullptr, occupancyTotal, mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap, &mEvents->init);
   }
 
   int32_t streamMap[NSECTORS];

From 1d4bf4839c0f7b650b2a81ed8ab62add37530666 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Wed, 19 Nov 2025 13:21:26 +0100
Subject: [PATCH 1044/1764] ALICE3-TRK: adapting to recent changes in the ML/OT
 geometry and to the new type definition o2::trk::Hit (#14831)

* ALICE3-TRK: adapting to new segmentation in chips in ML/OT and using o2::trk::Hit instead of o2::itsmft::Hit

* ALICE3-TRK: using o2::trk::Hit instead of o2::itsmft::Hit

* ALICE3-TRK: correct shift of VD chips to match the APTS response coordinate system + fix comment
---
 .../base/include/TRKBase/SegmentationChip.h   | 81 ++++++-------------
 .../ALICE3/TRK/base/include/TRKBase/Specs.h   | 17 ++--
 .../include/TRKSimulation/Digitizer.h         | 22 +++--
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   | 33 ++++----
 .../src/TRKDigitizerSpec.cxx                  |  4 +-
 5 files changed, 57 insertions(+), 100 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
index e2a60e8a3b576..8110191931e44 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
@@ -88,7 +88,7 @@ class SegmentationChip
   /// \param int disk Disk number (0 to 5 for VD)
   static bool localToDetector(float xRow, float zCol, int& iRow, int& iCol, int subDetID, int layer, int disk) noexcept
   {
-    if (!isValidGlob(xRow, zCol, subDetID, layer)) {
+    if (!isValidLoc(xRow, zCol, subDetID, layer)) {
       LOGP(debug, "Local coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
       return false;
     }
@@ -116,50 +116,34 @@ class SegmentationChip
       maxWidth = constants::VD::petal::layer::width[layer];
       maxLength = constants::VD::petal::layer::length;
       // TODO: change this to use the layer and disk
-    } else if (subDetID == 1 && layer <= 3) { // ML
+    } else if (subDetID == 1) {
       pitchRow = PitchRowMLOT;
       pitchCol = PitchColMLOT;
-      maxWidth = constants::ML::width;
-      maxLength = constants::ML::length;
-    } else if (subDetID == 1 && layer == 4) { // ML/OT (mixed layer, length = ML but staggered as OT)
-      pitchRow = PitchRowMLOT;
-      pitchCol = PitchColMLOT;
-      maxWidth = constants::OT::halfstave::width;
-      maxLength = constants::ML::length;
-    } else if (subDetID == 1 && layer > 4) { // OT
-      pitchRow = PitchRowMLOT;
-      pitchCol = PitchColMLOT;
-      maxWidth = constants::OT::halfstave::width;
-      maxLength = constants::OT::halfstave::length;
+      maxWidth = constants::moduleMLOT::chip::width - constants::moduleMLOT::chip::passiveEdgeReadOut;
+      maxLength = constants::moduleMLOT::chip::length;
     }
     // convert to row/col
-    iRow = static_cast<int>(((maxWidth / 2 - xRow) / pitchRow));
-    iCol = static_cast<int>(((zCol + maxLength / 2) / pitchCol));
+    iRow = static_cast<int>(std::floor((maxWidth / 2 - xRow) / pitchRow));
+    iCol = static_cast<int>(std::floor((zCol + maxLength / 2) / pitchCol));
   };
 
   // Check local coordinates (cm) validity.
-  static constexpr bool isValidGlob(float x, float z, int subDetID, int layer) noexcept
+  static constexpr bool isValidLoc(float x, float z, int subDetID, int layer) noexcept
   {
     float maxWidth(0), maxLength(0);
     if (subDetID == 0) {
       maxWidth = constants::VD::petal::layer::width[layer];
       maxLength = constants::VD::petal::layer::length;
       // TODO: change this to use the layer and disk
-    } else if (subDetID == 1 && layer <= 3) { // ML
-      maxWidth = constants::ML::width;
-      maxLength = constants::ML::length;
-    } else if (subDetID == 1 && layer == 4) { // ML/OT (mixed layer, length = ML but staggered as OT)
-      maxWidth = constants::OT::halfstave::width;
-      maxLength = constants::ML::length;
-    } else if (subDetID == 1 && layer > 4) { // OT
-      maxWidth = constants::OT::halfstave::width;
-      maxLength = constants::OT::halfstave::length;
+    } else if (subDetID == 1) { // ML/OT
+      maxWidth = constants::moduleMLOT::chip::width - constants::moduleMLOT::chip::passiveEdgeReadOut;
+      maxLength = constants::moduleMLOT::chip::length;
     }
     return (-maxWidth / 2 < x && x < maxWidth / 2 && -maxLength / 2 < z && z < maxLength / 2);
   }
 
   // Check detector coordinates validity.
-  static constexpr bool isValidDet(float row, float col, int subDetID, int layer) noexcept
+  static constexpr bool isValidDet(int row, int col, int subDetID, int layer) noexcept
   {
     // Check if the row and column are within the valid range
     int nRows(0), nCols(0);
@@ -167,17 +151,11 @@ class SegmentationChip
       nRows = constants::VD::petal::layer::nRows[layer];
       nCols = constants::VD::petal::layer::nCols;
       // TODO: change this to use the layer and disk
-    } else if (subDetID == 1 && layer <= 3) { // ML
-      nRows = constants::ML::nRows;
-      nCols = constants::ML::nCols;
-    } else if (subDetID == 1 && layer == 4) { // ML/OT (mixed layer, length = ML but staggered as OT)
-      nRows = constants::OT::halfstave::nRows;
-      nCols = constants::ML::nCols;
-    } else if (subDetID == 1 && layer > 4) { // OT
-      nRows = constants::OT::halfstave::nRows;
-      nCols = constants::OT::halfstave::nCols;
+    } else if (subDetID == 1) {
+      nRows = constants::moduleMLOT::chip::nRows;
+      nCols = constants::moduleMLOT::chip::nCols;
     }
-    return (row >= 0 && row < static_cast<float>(nRows) && col >= 0 && col < static_cast<float>(nCols));
+    return (row >= 0 && row < nRows && col >= 0 && col < nCols);
   }
 
   /// Transformation from Detector cell coordinates to Geant detector centered
@@ -202,7 +180,7 @@ class SegmentationChip
     detectorToLocalUnchecked(iRow, iCol, xRow, zCol, subDetID, layer, disk);
     LOG(debug) << "Result from detectorToLocalUnchecked: iRow " << iRow << " -> xRow " << xRow << ", iCol " << iCol << " -> zCol " << zCol << " on subDetID, layer, disk: " << subDetID << " " << layer << " " << disk;
 
-    if (!isValidGlob(xRow, zCol, subDetID, layer)) {
+    if (!isValidLoc(xRow, zCol, subDetID, layer)) {
       LOGP(debug, "Local coordinates not valid: row = {} cm, col = {} cm", xRow, zCol);
       return false;
     }
@@ -218,15 +196,9 @@ class SegmentationChip
     if (subDetID == 0) {
       xRow = 0.5 * (constants::VD::petal::layer::width[layer] - PitchRowVD) - (row * PitchRowVD);
       zCol = col * PitchColVD + 0.5 * (PitchColVD - constants::VD::petal::layer::length);
-    } else if (subDetID == 1 && layer <= 3) { // ML
-      xRow = 0.5 * (constants::ML::width - PitchRowMLOT) - (row * PitchRowMLOT);
-      zCol = col * PitchRowMLOT + 0.5 * (PitchRowMLOT - constants::ML::length);
-    } else if (subDetID == 1 && layer == 4) { // ML/OT (mixed layer, length = ML but staggered as OT)
-      xRow = 0.5 * (constants::OT::halfstave::width - PitchRowMLOT) - (row * PitchRowMLOT);
-      zCol = col * PitchRowMLOT + 0.5 * (PitchRowMLOT - constants::ML::length);
-    } else if (subDetID == 1 && layer > 4) { // OT
-      xRow = 0.5 * (constants::OT::halfstave::width - PitchRowMLOT) - (row * PitchRowMLOT);
-      zCol = col * PitchColMLOT + 0.5 * (PitchColMLOT - constants::OT::halfstave::length);
+    } else if (subDetID == 1) { // ML/OT
+      xRow = 0.5 * (constants::moduleMLOT::chip::width - constants::moduleMLOT::chip::passiveEdgeReadOut - PitchRowMLOT) - (row * PitchRowMLOT);
+      zCol = col * PitchRowMLOT + 0.5 * (PitchRowMLOT - constants::moduleMLOT::chip::length);
     }
   }
 
@@ -282,20 +254,13 @@ class SegmentationChip
     LOG(info) << "Number of rows:\nVD L0: " << constants::VD::petal::layer::nRows[0]
               << "\nVD L1: " << constants::VD::petal::layer::nRows[1]
               << "\nVD L2: " << constants::VD::petal::layer::nRows[2]
-              << "\nML stave: " << constants::ML::nRows
-              << "\nOT half stave: " << constants::OT::halfstave::nRows;
+              << "\nML/OT chip: " << constants::moduleMLOT::chip::nRows;
 
     LOG(info) << "Number of cols:\nVD: " << constants::VD::petal::layer::nCols
-              << "\nML stave: " << constants::ML::nCols
-              << "\nOT half stave: " << constants::OT::halfstave::nCols;
-
-    LOG(info) << "Pitch rows [cm]:\nVD: " << PitchRowVD
-              << "\nML stave: " << PitchRowMLOT
-              << "\nOT stave: " << PitchRowMLOT;
+              << "\nML/OT chip: " << constants::moduleMLOT::chip::nCols;
 
-    LOG(info) << "Pitch cols [cm]:\nVD: " << PitchColVD
-              << "\nML stave: " << PitchColMLOT
-              << "\nOT stave: " << PitchColMLOT;
+    LOG(info) << "Pitch rows x cols [um]:\nVD: " << PitchRowVD * 1e4 << "x" << PitchColVD * 1e4
+              << "\nML/OT chip: " << PitchRowMLOT * 1e4 << "x" << PitchColMLOT * 1e4;
   }
 };
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index 559d8f6154c59..172d993be7283 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -76,15 +76,14 @@ constexpr double thickness{0 * mu}; // thickness of the copper metal stack - for
 } // namespace metalstack
 namespace chip
 {
-constexpr double width{25 * mm};                                             // width of the chip
-constexpr double length{32 * mm};                                            // length of the chip
-constexpr double pitchX{50 * mu};                                            // pitch of the row
-constexpr double pitchZ{50 * mu};                                            // pitch of the column
-constexpr int nRows{static_cast<int>(width / pitchX)};                       // number of columns in the chip
-constexpr int nCols{static_cast<int>(length / pitchZ)};                      // number of rows in the chip
-constexpr double totalThickness{silicon::thickness + metalstack::thickness}; // total thickness of the chip
-/// Set to 0 for the moment, to be adjusted with the actual design of the chip if needed
-static constexpr float passiveEdgeReadOut{1.5 * mm}; // width of the readout edge
+constexpr double width{25 * mm};                                              // width of the chip
+constexpr double length{32 * mm};                                             // length of the chip
+constexpr double pitchX{50 * mu};                                             // pitch of the row
+constexpr double pitchZ{50 * mu};                                             // pitch of the column
+constexpr double totalThickness{silicon::thickness + metalstack::thickness};  // total thickness of the chip
+static constexpr double passiveEdgeReadOut{1.5 * mm};                         // width of the readout edge -> dead zone
+constexpr int nRows{static_cast<int>((width - passiveEdgeReadOut) / pitchX)}; // number of rows in the chip
+constexpr int nCols{static_cast<int>(length / pitchZ)};                       // number of columns in the chip
 } // namespace chip
 namespace gaps
 {
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
index 573217fe9b076..8e7173af8b820 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
@@ -25,7 +25,7 @@
 #include "TRKSimulation/ChipDigitsContainer.h"
 
 #include "TRKSimulation/DigiParams.h"
-#include "ITSMFTSimulation/Hit.h"
+#include "TRKSimulation/Hit.h"
 #include "TRKBase/GeometryTGeo.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
@@ -54,7 +54,7 @@ class Digitizer
   o2::trk::ChipSimResponse* getChipResponse(int chipID);
 
   /// Steer conversion of hits to digits
-  void process(const std::vector<itsmft::Hit>* hits, int evID, int srcID);
+  void process(const std::vector<o2::trk::Hit>* hits, int evID, int srcID);
   void setEventTime(const o2::InteractionTimeRecord& irt);
   double getEndTimeOfROFMax() const
   {
@@ -83,7 +83,7 @@ class Digitizer
   void setDeadChannelsMap(const o2::itsmft::NoiseMap* mp) { mDeadChanMap = mp; }
 
  private:
-  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
+  void processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, int srcID);
   void registerDigits(o2::trk::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
                       uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
 
@@ -102,15 +102,13 @@ class Digitizer
   /// Get the number of columns according to the subdetector
   /// \param subDetID 0 for VD, 1 for ML/OT
   /// \param layer 0 to 2 for VD, 0 to 7 for ML/OT
-  /// \return Number of columns (for the moment, in the entire layer(VD) or stave (ML/OT)
+  /// \return Number of columns (In the entire layer(VD) or chip (ML/OT)
   int getNCols(int subDetID, int layer)
   {
     if (subDetID == 0) { // VD
       return constants::VD::petal::layer::nCols;
-    } else if (subDetID == 1 && layer <= 3) { // ML
-      return constants::ML::nCols;
-    } else if (subDetID == 1 && layer >= 4) { // OT
-      return constants::OT::nCols;
+    } else if (subDetID == 1) { // ML/OT: the smallest element is a chip of 470 rows and 640 cols
+      return constants::moduleMLOT::chip::nCols;
     }
     return 0;
   }
@@ -118,15 +116,13 @@ class Digitizer
   /// Get the number of rows according to the subdetector
   /// \param subDetID 0 for VD, 1 for ML/OT
   /// \param layer 0 to 2 for VD, 0 to 7 for ML/OT
-  /// \return Number of rows (for the moment, in the entire layer(VD) or stave (ML/OT)
+  /// \return Number of rows (In the entire layer(VD) or chip (ML/OT)
   int getNRows(int subDetID, int layer)
   {
     if (subDetID == 0) { // VD
       return constants::VD::petal::layer::nRows[layer];
-    } else if (subDetID == 1 && layer <= 3) { // ML
-      return constants::ML::nRows;
-    } else if (subDetID == 1 && layer >= 4) { // OT
-      return constants::OT::nRows;
+    } else if (subDetID == 1) { // ML/OT
+      return constants::moduleMLOT::chip::nRows;
     }
     return 0;
   }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 0c691b03c867e..20509782f21ee 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -26,7 +26,7 @@
 #include <fairlogger/Logger.h> // for LOG
 
 using o2::itsmft::Digit;
-using o2::itsmft::Hit;
+using o2::trk::Hit;
 using Segmentation = o2::trk::SegmentationChip;
 
 using namespace o2::trk;
@@ -68,12 +68,12 @@ void Digitizer::init()
   LOG(info) << " Depth max MLOT: " << mChipSimRespMLOT->getDepthMax();
   LOG(info) << " Depth min MLOT: " << mChipSimRespMLOT->getDepthMin();
 
-  float thicknessVD = 0.0095; // cm --- hardcoded based on geometry currently present
-  float thicknessMLOT = 0.1;  // cm --- hardcoded based on geometry currently present
+  float thicknessVD = 0.0095;                                            // cm --- hardcoded based on geometry currently present
+  float thicknessMLOT = o2::trk::SegmentationChip::SiliconThicknessMLOT; // 0.01 cm = 100 um --- based on geometry currently present
 
   mSimRespVDScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowVD;
   mSimRespVDScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColVD;
-  mSimRespVDShift = -mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -45. Must add 10 um (= max depth) to match the APTS response.
+  mSimRespVDShift = mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -45. Must add 10 um (= max depth) to match the APTS response.
   mSimRespMLOTScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowMLOT;
   mSimRespMLOTScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColMLOT;
   mSimRespMLOTShift = mChipSimRespMLOT->getDepthMax() - thicknessMLOT / 2.f; // the shift should be done considering the rescaling done to adapt to the wrong silicon thickness. TODO: remove the scaling factor for the depth when the silicon thickness match the simulated response
@@ -115,8 +115,8 @@ void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
             << " cont.mode: " << isContinuous()
             << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
 
-  // std::cout << "Printing segmentation info: " << std::endl;
-  // SegmentationChip::Print();
+  std::cout << "Printing segmentation info: " << std::endl;
+  SegmentationChip::Print();
 
   // // is there something to flush ?
   if (mNewROFrame > mROFrameMin) {
@@ -252,7 +252,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
 }
 
 //_______________________________________________________________________
-void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID)
+void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, int srcID)
 {
   int chipID = hit.GetDetectorID(); //// the chip ID at the moment is not referred to the chip but to a wider detector element (e.g. quarter of layer or disk in VD, stave in ML, half stave in OT)
   int subDetID = mGeometry->getSubDetID(chipID);
@@ -333,13 +333,6 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   // std::cout<< "Example hit in local frame: " << exampleLoc << std::endl;
   // std::cout<<"Going back to glob coordinates: " << (matrix * exampleLoc) << std::endl;
 
-  //// adapting the depth (Y) of the chip to the APTS response maximum depth
-  LOG(debug) << "local original: startPos = " << xyzLocS << ", endPos = " << xyzLocE << std::endl;
-  xyzLocS.SetY(xyzLocS.Y());
-  xyzLocE.SetY(xyzLocE.Y());
-
-  LOG(debug) << "rescaled Y: startPos = " << xyzLocS << ", endPos = " << xyzLocE << std::endl;
-
   math_utils::Vector3D<float> step(xyzLocE);
   step -= xyzLocS;
   step *= nStepsInv; // position increment at each step
@@ -418,7 +411,10 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   // take into account that the ChipSimResponse depth defintion has different min/max boundaries
   // although the max should coincide with the surface of the epitaxial layer, which in the chip
   // local coordinates has Y = +SensorLayerThickness/2
+  // LOG(info)<<"SubdetID = " << subDetID<< " shift: "<<mSimRespVDShift<<" or "<<mSimRespMLOTShift;
+  // LOG(info)<< " Before shift: S = " << xyzLocS.Y()*1e4 << "  E = " << xyzLocE.Y()*1e4;
   xyzLocS.SetY(xyzLocS.Y() + ((subDetID == 0) ? mSimRespVDShift : mSimRespMLOTShift));
+  // LOG(info)<< " After shift: S = " << xyzLocS.Y()*1e4 << "  E = " << xyzLocE.Y()*1e4;
 
   // collect charge in every pixel which might be affected by the hit
   for (int iStep = nSteps; iStep--;) {
@@ -451,7 +447,8 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
       LOG(debug) << "Error in rspmat for step " << iStep << " / " << nSteps;
       continue;
     }
-    LOG(debug) << "rspmat valid! for step " << iStep << " / " << nSteps << ", (row,col) = (" << row << "," << col << ")";
+    // LOG(info) << "rspmat valid! for step " << iStep << " / " << nSteps << ", (row,col) = (" << row << "," << col << ")";
+    // LOG(info) << "rspmat valid! for step " << iStep << " / " << nSteps << " Y= " << xyzLocS.Y()*1e4 << " , (row,col) = (" << row << "," << col << ")";
     // rspmat->print(); // print the response matrix for debugging
 
     for (int irow = AlpideRespSimMat::NPix; irow--;) {
@@ -472,7 +469,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   // fire the pixels assuming Poisson(n_response_electrons)
   o2::MCCompLabel lbl(hit.GetTrackID(), evID, srcID, false);
   auto roFrameAbs = mNewROFrame + roFrameRel;
-  LOG(debug) << "Spanning through rows and columns; rowspan = " << rowSpan << " colspan = " << colSpan << " = " << colE << " - " << colS << " +1 " << std::endl;
+  LOG(debug) << "\nSpanning through rows and columns; rowspan = " << rowSpan << " colspan = " << colSpan << " = " << colE << " - " << colS << " +1 ";
   for (int irow = rowSpan; irow--;) {          // irow ranging from 4 to 0
     uint16_t rowIS = irow + rowS;              // row distant irow from the row of the hit start
     for (int icol = colSpan; icol--;) {        // icol ranging from 4 to 0
@@ -480,9 +477,9 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
       if (nEleResp <= 1.e-36) {
         continue;
       }
-      LOG(debug) << "nEleResp: value " << nEleResp << " for pixel " << irow << " " << icol << std::endl;
+      LOG(debug) << "nEleResp: value " << nEleResp << " for pixel " << irow << " " << icol;
       int nEle = gRandom->Poisson(nElectrons * nEleResp); // total charge in given pixel = number of electrons generated in the hit multiplied by the probability of being detected in their position
-      LOG(debug) << "Charge detected in the pixel: " << nEle << " for pixel " << irow << " " << icol << std::endl;
+      LOG(debug) << "Charge detected in the pixel: " << nEle << " for pixel " << irow << " " << icol;
       // ignore charge which have no chance to fire the pixel
       if (nEle < mParams.getMinChargeToAccount()) { /// TODO: substitute with the threshold?
         LOG(debug) << "Ignoring pixel with nEle = " << nEle << " < min charge to account "
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
index 0ed276237bd86..37355cb5752c4 100644
--- a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
@@ -276,8 +276,8 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
   std::vector<o2::itsmft::Digit> mDigits{};
   std::vector<o2::itsmft::ROFRecord> mROFRecords{};
   std::vector<o2::itsmft::ROFRecord> mROFRecordsAccum{};
-  std::vector<o2::itsmft::Hit> mHits{};
-  std::vector<o2::itsmft::Hit>* mHitsP{&mHits};
+  std::vector<o2::trk::Hit> mHits{};
+  std::vector<o2::trk::Hit>* mHitsP{&mHits};
   o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabels{};
   o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabelsAccum{};
   std::vector<o2::itsmft::MC2ROFRecord> mMC2ROFRecordsAccum{};

From 2439bbec037ff4b4c40361cbeaec97fafbaae132 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Tue, 18 Nov 2025 15:27:41 +0100
Subject: [PATCH 1045/1764] Custom member streamer for
 CalArray<o2::tpc::PadFlags>::mData

This commit expands on https://github.com/AliceO2Group/AliceO2/pull/14427
and fixes the issue brought up in https://its.cern.ch/jira/browse/O2-4671.

After debugging/testing it turns out that the approach taken via a customer streamer
for std::vector<o2::tpc::PadFlags> does not take effect in the ROOT/IO because
apparently ROOT still prefers to use the CollectionProxy for std::vector and does not
employ the custom streamer.

Instead, after discussion with @pcanal, this commit proposes to implement a
custom stream just for the mData data member of CalArray<o2::tpc::PadFlags>.
This is the only place where we use o2::tpc::PadFlags in IO and it fixes the problem
when reading CCDB objects containing such data.

I have verified that the following code
```
o2-ccdb-downloadccdbfile -p TPC/Calib/IDC_PadStatusMap_A -t 1731274461770 -d ./ -o tpc_idc.root --no-preserve-path
root tpc_idc.root
gFile->Get<o2::tpc::CalDet<o2::tpc::PadFlags>>("ccdb_object")
```
correctly executes the custom streamer function.

Note that there is also no need to make the code ROOT version dependent. We need to fix the reading in any
case and the writing will just stay the same.

Concerning situations, where future classes will write data containing std::vector<o2::tpc::PadFlags>
we should be protected by the fact that this bug has been fixed >= ROOT 6.36 in any case.

This commit relates also to

https://github.com/root-project/root/pull/17009

The commit also re-enables dictionary creation of related classes
and adds a dictionary for CalArray<o2::tpc::PadFlags> previously missing.
---
 DataFormats/Detectors/TPC/CMakeLists.txt      |  1 -
 .../Detectors/TPC/src/DataFormatsTPCLinkDef.h |  4 +-
 .../TPC/src/VectorPadflagsCustomStreamer.cxx  | 56 -------------
 Detectors/TPC/base/CMakeLists.txt             |  1 +
 Detectors/TPC/base/src/TPCBaseLinkDef.h       |  1 +
 .../base/src/TPCFlagsMemberCustomStreamer.cxx | 79 +++++++++++++++++++
 6 files changed, 83 insertions(+), 59 deletions(-)
 delete mode 100644 DataFormats/Detectors/TPC/src/VectorPadflagsCustomStreamer.cxx
 create mode 100644 Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx

diff --git a/DataFormats/Detectors/TPC/CMakeLists.txt b/DataFormats/Detectors/TPC/CMakeLists.txt
index 5aed01a9772c1..2cc69e16001a6 100644
--- a/DataFormats/Detectors/TPC/CMakeLists.txt
+++ b/DataFormats/Detectors/TPC/CMakeLists.txt
@@ -40,7 +40,6 @@ o2_add_library(
 
 o2_target_root_dictionary(
   DataFormatsTPC
-  EXTRA_PATCH src/VectorPadflagsCustomStreamer.cxx
   HEADERS include/DataFormatsTPC/ClusterGroupAttribute.h
           include/DataFormatsTPC/ClusterNative.h
           include/DataFormatsTPC/ClusterNativeHelper.h
diff --git a/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h b/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
index 8659e6a2e43eb..f463e9011c935 100644
--- a/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
+++ b/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
@@ -22,7 +22,7 @@
 #pragma link C++ class o2::tpc::ClusterHardwareContainerFixedSize < 8192> + ;
 #pragma link C++ class o2::tpc::ClusterNativeContainer + ;
 #pragma link C++ class o2::tpc::Digit + ;
-// pragma link C++ enum o2::tpc::PadFlags +;                // enum itself
+#pragma link C++ enum o2::tpc::PadFlags + ; // enum itself
 #pragma link C++ class o2::tpc::ZeroSuppressedContainer8kb + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterNative> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterNativeContainer> + ;
@@ -30,7 +30,7 @@
 #pragma link C++ class std::vector < o2::tpc::ClusterHardwareContainerFixedSize < 8192>> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterHardwareContainer8kb> + ;
 #pragma link C++ class std::vector < o2::tpc::Digit> + ;
-// pragma link C++ class std::vector < o2::tpc::PadFlags> + ;
+#pragma link C++ class std::vector < o2::tpc::PadFlags> + ;
 #pragma link C++ class std::vector < o2::tpc::ZeroSuppressedContainer8kb> + ;
 #pragma link C++ class o2::tpc::TrackTPC + ;
 #pragma link C++ class o2::tpc::LaserTrack + ;
diff --git a/DataFormats/Detectors/TPC/src/VectorPadflagsCustomStreamer.cxx b/DataFormats/Detectors/TPC/src/VectorPadflagsCustomStreamer.cxx
deleted file mode 100644
index f7cb9285b8884..0000000000000
--- a/DataFormats/Detectors/TPC/src/VectorPadflagsCustomStreamer.cxx
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-using std::vector;
-
-void VectorPadFlagsStreamer(TBuffer& R__b, void* objp)
-{
-  std::vector<o2::tpc::PadFlags>* obj = static_cast<std::vector<o2::tpc::PadFlags>*>(objp);
-  if (R__b.IsReading()) {
-    std::vector<int> R__stl;
-    R__stl.clear();
-    int R__n;
-    R__b >> R__n;
-    R__stl.reserve(R__n);
-    for (int R__i = 0; R__i < R__n; R__i++) {
-      Int_t readtemp;
-      R__b >> readtemp;
-      R__stl.push_back(readtemp);
-    }
-    auto data = reinterpret_cast<unsigned short*>(R__stl.data());
-    for (int i = 0; i < R__n; ++i) {
-      obj->push_back(static_cast<o2::tpc::PadFlags>(data[i]));
-    }
-  } else {
-    // We always save things with the old format.
-    R__b << (int)obj->size() / 2;
-    for (size_t i = 0; i < obj->size(); i++) {
-      R__b << (short)obj->at(i);
-    }
-  }
-}
-
-#define RootStreamerLocal(name, STREAMER)     \
-  namespace ROOT                              \
-  {                                           \
-                                              \
-  /** \cond HIDDEN_SYMBOLS */                 \
-  static auto _R__UNIQUE_(R__dummyStreamer) = \
-    []() { TClass::GetClass<name>()->SetStreamerFunc(STREAMER); return 0; }();                               \
-  /** \endcond */                             \
-  R__UseDummy(_R__UNIQUE_(R__dummyStreamer)); \
-  }
-
-// Let's not try to fix the old ROOT version, so that we can build
-// the new ROOT with the patched code in the CI.
-#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 33, 00)
-RootStreamerLocal(vector<o2::tpc::PadFlags>, VectorPadFlagsStreamer);
-#endif
diff --git a/Detectors/TPC/base/CMakeLists.txt b/Detectors/TPC/base/CMakeLists.txt
index d4c1bc4602d54..8c796d7e4ff13 100644
--- a/Detectors/TPC/base/CMakeLists.txt
+++ b/Detectors/TPC/base/CMakeLists.txt
@@ -43,6 +43,7 @@ o2_add_library(TPCBase
                                      O2::DetectorsRaw O2::CCDB FairRoot::Base)
 
 o2_target_root_dictionary(TPCBase
+                          EXTRA_PATCH src/TPCFlagsMemberCustomStreamer.cxx
                           HEADERS include/TPCBase/CalArray.h
                                   include/TPCBase/CalDet.h
                                   include/TPCBase/CDBInterface.h
diff --git a/Detectors/TPC/base/src/TPCBaseLinkDef.h b/Detectors/TPC/base/src/TPCBaseLinkDef.h
index 60924db3953e2..4fdde1ca55518 100644
--- a/Detectors/TPC/base/src/TPCBaseLinkDef.h
+++ b/Detectors/TPC/base/src/TPCBaseLinkDef.h
@@ -21,6 +21,7 @@
 #pragma link C++ class o2::tpc::CalArray < unsigned> + ;
 #pragma link C++ class o2::tpc::CalArray < short> + ;
 #pragma link C++ class o2::tpc::CalArray < bool> + ;
+#pragma link C++ class o2::tpc::CalArray < o2::tpc::PadFlags> + ;
 #pragma link C++ class o2::tpc::CalDet < float> + ;
 #pragma link C++ class o2::tpc::CalDet < double> + ;
 #pragma link C++ class o2::tpc::CalDet < int> + ;
diff --git a/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx b/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
new file mode 100644
index 0000000000000..1dfb775a14aaa
--- /dev/null
+++ b/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
@@ -0,0 +1,79 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TPCBase/CalArray.h"
+#include <TMemberStreamer.h>
+#include <TBuffer.h>
+#include <DataFormatsTPC/Defs.h>
+#include <iostream>
+
+// to enable assert statements
+#ifdef NDEBUG
+#undef NDEBUG
+#include <cassert>
+#endif
+
+// The following code provides a specific ROOT I/O streaming method
+// for the mData member of CalArray<o2::tpc::PadFlags>
+// This member was written incorrectly to the TFile in ROOT versions < 6.36, causing
+// segfaults when reading on ARM64 (occassionally).
+// We continue to write it in the incorrect format and fix the reading back.
+
+// See also:
+// - https://github.com/root-project/root/pull/17009
+// - https://its.cern.ch/jira/browse/O2-4671
+
+void MemberVectorPadFlagsStreamer(TBuffer& R__b, void* objp, int n)
+{
+  if (n != 1) {
+    std::cerr << "Error in MemberVectorPadFlagsStreamer : Unexpected n " << n << std::endl;
+    return;
+  }
+  std::vector<o2::tpc::PadFlags>* obj = static_cast<std::vector<o2::tpc::PadFlags>*>(objp);
+  if (R__b.IsReading()) {
+    std::vector<int> R__stl;
+    R__stl.clear();
+    int R__n;
+    R__b >> R__n;
+    R__stl.reserve(R__n);
+    for (int R__i = 0; R__i < R__n; R__i++) {
+      Int_t readtemp;
+      R__b >> readtemp;
+      R__stl.push_back(readtemp);
+    }
+    auto data = reinterpret_cast<unsigned short*>(R__stl.data());
+    for (int i = 0; i < R__n; ++i) {
+      obj->push_back(static_cast<o2::tpc::PadFlags>(data[i]));
+    }
+  } else {
+    // We always save things with the old format.
+    R__b << (int)obj->size() / 2;
+    for (size_t i = 0; i < obj->size(); i++) {
+      R__b << (short)obj->at(i);
+    }
+  }
+}
+
+// register the streamer via static global initialization (on library load)
+namespace ROOT
+{
+static __attribute__((used)) int _R__dummyStreamer_3 =
+  ([]() {
+    auto cl = TClass::GetClass<o2::tpc::CalArray<o2::tpc::PadFlags>>();
+    if (cl) {
+      cl->AdoptMemberStreamer("mData", new TMemberStreamer(MemberVectorPadFlagsStreamer));
+    } else {
+      // we should never come here ... and if we do we should assert/fail
+      assert(false);
+    }
+    return 0;
+  })();
+} // namespace ROOT

From ddcccec78ed82f32fb9052eff93fa3774aa31a48 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 12 Nov 2025 18:59:49 +0100
Subject: [PATCH 1046/1764] ITS: GPU: free artefacts from memory after
 iteration

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |   6 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   |   2 +-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 129 ++++++++++--------
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  17 ++-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  |  17 ---
 .../include/ITStracking/ExternalAllocator.h   |  28 +++-
 .../tracking/include/ITStracking/TimeFrame.h  |  26 ++--
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |  34 +++--
 GPU/GPUTracking/Global/GPUChainITS.cxx        |  24 ++--
 GPU/GPUTracking/Global/GPUChainITS.h          |   3 +-
 10 files changed, 158 insertions(+), 128 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 2bd1550e7c72b..8095d690bbcc8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -35,6 +35,8 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   ~TimeFrameGPU() = default;
 
   /// Most relevant operations
+  void pushMemoryStack(const int);
+  void popMemoryStack(const int);
   void registerHostMemory(const int);
   void unregisterHostMemory(const int);
   void initialise(const int, const TrackingParameters&, const int, IndexTableUtilsN* utils = nullptr, const TimeFrameGPUParameters* pars = nullptr);
@@ -177,8 +179,8 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   int getNumberOfNeighbours() const final;
 
  private:
-  void allocMemAsync(void**, size_t, Stream&, bool); // Abstract owned and unowned memory allocations on specific stream
-  void allocMem(void**, size_t, bool);               // Abstract owned and unowned memory allocations on default stream
+  void allocMemAsync(void**, size_t, Stream&, bool, int32_t = o2::gpu::GPUMemoryResource::MEMORY_GPU); // Abstract owned and unowned memory allocations on specific stream
+  void allocMem(void**, size_t, bool, int32_t = o2::gpu::GPUMemoryResource::MEMORY_GPU);               // Abstract owned and unowned memory allocations on default stream
   TimeFrameGPUParameters mGpuParams;
 
   // Host-available device buffer sizes
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index e5b9253ca4090..ee0a203f32fda 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -313,7 +313,7 @@ struct TypedAllocator {
 
   pointer allocate(size_type n)
   {
-    void* raw = mInternalAllocator->allocate(n * sizeof(T));
+    void* raw = mInternalAllocator->allocateStack(n * sizeof(T));
     return thrust::device_pointer_cast(static_cast<T*>(raw));
   }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 27bcf04746da5..6532165d9628a 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -11,6 +11,7 @@
 ///
 
 #include <cuda_runtime.h>
+#include <fmt/format.h>
 
 #include <unistd.h>
 #include <vector>
@@ -24,15 +25,16 @@
 #include "GPUCommonMath.h"
 #include "GPUCommonLogger.h"
 #include "GPUCommonHelpers.h"
+#include "utils/strtag.h"
 
 namespace o2::its::gpu
 {
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& stream, bool extAllocator)
+void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& stream, bool extAllocator, int32_t type)
 {
   if (extAllocator) {
-    *ptr = this->mExtDeviceAllocator->allocate(size);
+    *ptr = (this->mExternalAllocator)->allocate(size, type);
   } else {
     GPULog("Calling default CUDA allocator");
     GPUChkErrS(cudaMallocAsync(reinterpret_cast<void**>(ptr), size, stream.get()));
@@ -40,10 +42,10 @@ void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& strea
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::allocMem(void** ptr, size_t size, bool extAllocator)
+void TimeFrameGPU<nLayers>::allocMem(void** ptr, size_t size, bool extAllocator, int32_t type)
 {
   if (extAllocator) {
-    *ptr = this->mExtDeviceAllocator->allocate(size);
+    *ptr = (this->mExternalAllocator)->allocate(size, type);
   } else {
     GPULog("Calling default CUDA allocator");
     GPUChkErrS(cudaMalloc(reinterpret_cast<void**>(ptr), size));
@@ -56,7 +58,7 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
   GPUTimer timer("loading indextable utils");
   if (!iteration) {
     GPULog("gpu-allocation: allocating IndexTableUtils buffer, for {:.2f} MB.", sizeof(IndexTableUtilsN) / constants::MB);
-    allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtilsN), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtilsN), this->hasFrameworkAllocator());
   }
   GPULog("gpu-transfer: loading IndexTableUtils object, for {:.2f} MB.", sizeof(IndexTableUtilsN) / constants::MB);
   GPUChkErrS(cudaMemcpy(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtilsN), cudaMemcpyHostToDevice));
@@ -67,10 +69,10 @@ void TimeFrameGPU<nLayers>::createUnsortedClustersDeviceArray(const int iteratio
 {
   if (!iteration) {
     GPUTimer timer("creating unsorted clusters array");
-    allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     mPinnedUnsortedClusters.set(nLayers);
-    if (!this->hasExternalDeviceAllocator()) {
+    if (!this->hasFrameworkAllocator()) {
       for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
         mPinnedUnsortedClusters.set(iLayer);
@@ -85,7 +87,7 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration, cons
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading unsorted clusters", layer);
     GPULog("gpu-transfer: loading {} unsorted clusters on layer {}, for {:.2f} MB.", this->mUnsortedClusters[layer].size(), layer, this->mUnsortedClusters[layer].size() * sizeof(Cluster) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[layer]), this->mUnsortedClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[layer]), this->mUnsortedClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpyAsync(mUnsortedClustersDevice[layer], this->mUnsortedClusters[layer].data(), this->mUnsortedClusters[layer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mUnsortedClustersDeviceArray[layer], &mUnsortedClustersDevice[layer], sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -96,10 +98,10 @@ void TimeFrameGPU<nLayers>::createClustersDeviceArray(const int iteration, const
 {
   if (!iteration) {
     GPUTimer timer("creating sorted clusters array");
-    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
     mPinnedClusters.set(nLayers);
-    if (!this->hasExternalDeviceAllocator()) {
+    if (!this->hasFrameworkAllocator()) {
       for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
         mPinnedClusters.set(iLayer);
@@ -114,7 +116,7 @@ void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration, const int la
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
     GPULog("gpu-transfer: loading {} clusters on layer {}, for {:.2f} MB.", this->mClusters[layer].size(), layer, this->mClusters[layer].size() * sizeof(Cluster) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[layer]), this->mClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[layer]), this->mClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpyAsync(mClustersDevice[layer], this->mClusters[layer].data(), this->mClusters[layer].size() * sizeof(Cluster), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mClustersDeviceArray[layer], &mClustersDevice[layer], sizeof(Cluster*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -125,10 +127,10 @@ void TimeFrameGPU<nLayers>::createClustersIndexTablesArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating clustersindextable array");
-    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaHostRegisterPortable));
     mPinnedClustersIndexTables.set(nLayers);
-    if (!this->hasExternalDeviceAllocator()) {
+    if (!this->hasFrameworkAllocator()) {
       for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
         mPinnedClustersIndexTables.set(iLayer);
@@ -143,7 +145,7 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration, const i
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
     GPULog("gpu-transfer: loading clusters indextable for layer {} with {} elements, for {:.2f} MB.", layer, this->mIndexTables[layer].size(), this->mIndexTables[layer].size() * sizeof(int) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[layer]), this->mIndexTables[layer].size() * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[layer]), this->mIndexTables[layer].size() * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpyAsync(mClustersIndexTablesDevice[layer], this->mIndexTables[layer].data(), this->mIndexTables[layer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mClustersIndexTablesDeviceArray[layer], &mClustersIndexTablesDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -154,10 +156,10 @@ void TimeFrameGPU<nLayers>::createUsedClustersDeviceArray(const int iteration, c
 {
   if (!iteration) {
     GPUTimer timer("creating used clusters flags");
-    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(uint8_t*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(uint8_t*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mUsedClustersDevice.data(), nLayers * sizeof(uint8_t*), cudaHostRegisterPortable));
     mPinnedUsedClusters.set(nLayers);
-    if (!this->hasExternalDeviceAllocator()) {
+    if (!this->hasFrameworkAllocator()) {
       for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(uint8_t), cudaHostRegisterPortable));
         mPinnedUsedClusters.set(iLayer);
@@ -172,7 +174,7 @@ void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration, const
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "creating used clusters flags", layer);
     GPULog("gpu-transfer: creating {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[layer].size(), layer, this->mUsedClusters[layer].size() * sizeof(unsigned char) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[layer]), this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[layer]), this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemsetAsync(mUsedClustersDevice[layer], 0, this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mUsedClustersDeviceArray[layer], &mUsedClustersDevice[layer], sizeof(unsigned char*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -193,10 +195,10 @@ void TimeFrameGPU<nLayers>::createROFrameClustersDeviceArray(const int iteration
 {
   if (!iteration) {
     GPUTimer timer("creating ROFrame clusters array");
-    allocMem(reinterpret_cast<void**>(&mROFramesClustersDeviceArray), nLayers * sizeof(int*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mROFramesClustersDeviceArray), nLayers * sizeof(int*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaHostRegisterPortable));
     mPinnedROFramesClusters.set(nLayers);
-    if (!this->hasExternalDeviceAllocator()) {
+    if (!this->hasFrameworkAllocator()) {
       for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
         mPinnedROFramesClusters.set(iLayer);
@@ -211,7 +213,7 @@ void TimeFrameGPU<nLayers>::loadROFrameClustersDevice(const int iteration, const
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading ROframe clusters", layer);
     GPULog("gpu-transfer: loading {} ROframe clusters info on layer {}, for {:.2f} MB.", this->mROFramesClusters[layer].size(), layer, this->mROFramesClusters[layer].size() * sizeof(int) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[layer]), this->mROFramesClusters[layer].size() * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[layer]), this->mROFramesClusters[layer].size() * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpyAsync(mROFramesClustersDevice[layer], this->mROFramesClusters[layer].data(), this->mROFramesClusters[layer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mROFramesClustersDeviceArray[layer], &mROFramesClustersDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -222,10 +224,10 @@ void TimeFrameGPU<nLayers>::createTrackingFrameInfoDeviceArray(const int iterati
 {
   if (!iteration) {
     GPUTimer timer("creating trackingframeinfo array");
-    allocMem(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
     mPinnedTrackingFrameInfo.set(nLayers);
-    if (!this->hasExternalDeviceAllocator()) {
+    if (!this->hasFrameworkAllocator()) {
       for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
         mPinnedTrackingFrameInfo.set(iLayer);
@@ -240,7 +242,7 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration, con
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading trackingframeinfo", layer);
     GPULog("gpu-transfer: loading {} tfinfo on layer {}, for {:.2f} MB.", this->mTrackingFrameInfo[layer].size(), layer, this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[layer]), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[layer]), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpyAsync(mTrackingFrameInfoDevice[layer], this->mTrackingFrameInfo[layer].data(), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
     GPUChkErrS(cudaMemcpyAsync(&mTrackingFrameInfoDeviceArray[layer], &mTrackingFrameInfoDevice[layer], sizeof(TrackingFrameInfo*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
@@ -253,7 +255,7 @@ void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
     GPUTimer timer("loading multiplicity cut mask");
     GPULog("gpu-transfer: iteration {} loading multiplicity cut mask with {} elements, for {:.2f} MB.", iteration, this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(uint8_t) / constants::MB);
     if (!iteration) { // only allocate on first call
-      allocMem(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), this->hasExternalDeviceAllocator());
+      allocMem(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), this->hasFrameworkAllocator());
     }
     GPUChkErrS(cudaMemcpy(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice));
   }
@@ -265,10 +267,10 @@ void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
   if (!iteration) {
     GPUTimer timer("loading seeding vertices");
     GPULog("gpu-transfer: loading {} ROframes vertices, for {:.2f} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / constants::MB);
-    allocMem(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice));
     GPULog("gpu-transfer: loading {} seeding vertices, for {:.2f} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / constants::MB);
-    allocMem(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice));
   }
 }
@@ -277,7 +279,7 @@ template <int nLayers>
 void TimeFrameGPU<nLayers>::createTrackletsLUTDeviceArray(const int iteration)
 {
   if (!iteration) {
-    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), this->hasFrameworkAllocator());
   }
 }
 
@@ -288,7 +290,7 @@ void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration, const
   const int ncls = this->mClusters[layer].size() + 1;
   if (!iteration) {
     GPULog("gpu-allocation: creating tracklets LUT for {} elements on layer {}, for {:.2f} MB.", ncls, layer, ncls * sizeof(int) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[layer]), ncls * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[layer]), ncls * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpyAsync(&mTrackletsLUTDeviceArray[layer], &mTrackletsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
   }
   GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[layer], 0, ncls * sizeof(int), mGpuStreams[layer].get()));
@@ -299,7 +301,7 @@ void TimeFrameGPU<nLayers>::createTrackletsBuffersArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating tracklet buffers array");
-    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), this->hasFrameworkAllocator());
   }
 }
 
@@ -311,7 +313,7 @@ void TimeFrameGPU<nLayers>::createTrackletsBuffers(const int layer)
   GPUChkErrS(cudaMemcpyAsync(&mNTracklets[layer], mTrackletsLUTDevice[layer] + this->mClusters[layer].size(), sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of tracklets is correct
   GPULog("gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer], layer, mNTracklets[layer] * sizeof(Tracklet) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[layer]), mNTracklets[layer] * sizeof(Tracklet), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[layer]), mNTracklets[layer] * sizeof(Tracklet), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
   GPUChkErrS(cudaMemcpyAsync(&mTrackletsDeviceArray[layer], &mTrackletsDevice[layer], sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
@@ -343,7 +345,7 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells neighbours", layer);
   GPULog("gpu-transfer: reserving neighbours LUT for {} elements on layer {}, for {:.2f} MB.", mNCells[layer] + 1, layer, (mNCells[layer] + 1) * sizeof(int) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[layer]), (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[layer]), (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
   GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[layer], 0, (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer].get()));
 }
 
@@ -352,7 +354,7 @@ void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const uns
 {
   GPUTimer timer(mGpuStreams[layer], "reserving neighboursLUT");
   GPULog("gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {:.2f} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator()); // We need one element more to move exc -> inc
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK)); // We need one element more to move exc -> inc
   GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[layer].get()));
 }
 
@@ -362,8 +364,8 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
   GPUTimer timer(mGpuStreams, "loading cell seeds", nLayers - 2);
   for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
     GPULog("gpu-transfer: loading {} cell seeds on layer {}, for {:.2f} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeedN) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeedN), mGpuStreams[iLayer], this->hasExternalDeviceAllocator());
-    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->hasExternalDeviceAllocator()); // accessory for the neigh. finding.
+    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeedN), mGpuStreams[iLayer], this->hasFrameworkAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->hasFrameworkAllocator()); // accessory for the neigh. finding.
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
     GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeedN), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
@@ -374,7 +376,7 @@ void TimeFrameGPU<nLayers>::createCellsLUTDeviceArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating cells LUTs array");
-    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), this->hasFrameworkAllocator());
   }
 }
 
@@ -383,7 +385,7 @@ void TimeFrameGPU<nLayers>::createCellsLUTDevice(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells LUTs", layer);
   GPULog("gpu-transfer: creating cell LUT for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer] + 1, layer, (mNTracklets[layer] + 1) * sizeof(int) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[layer]), (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[layer]), (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
   GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[layer], 0, (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer].get()));
   GPUChkErrS(cudaMemcpyAsync(&mCellsLUTDeviceArray[layer], &mCellsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
@@ -393,7 +395,7 @@ void TimeFrameGPU<nLayers>::createCellsBuffersArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating cells buffers array");
-    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeedN*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeedN*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeedN*), cudaMemcpyHostToDevice));
   }
 }
@@ -406,7 +408,7 @@ void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of cells is correct
   GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeedN) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
   GPUChkErrS(cudaMemcpyAsync(&mCellsDeviceArray[layer], &mCellsDevice[layer], sizeof(CellSeedN*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
@@ -426,7 +428,7 @@ void TimeFrameGPU<nLayers>::loadRoadsDevice()
 {
   GPUTimer timer("loading roads device");
   GPULog("gpu-transfer: loading {} roads, for {:.2f} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), this->hasExternalDeviceAllocator());
+  allocMem(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), this->hasFrameworkAllocator());
   GPUChkErrS(cudaHostRegister(this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpy(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice));
 }
@@ -436,7 +438,7 @@ void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeedN>& seed
 {
   GPUTimer timer("loading track seeds");
   GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeedN) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeedN), this->hasExternalDeviceAllocator());
+  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeedN), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
   GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeedN), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpy(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeedN), cudaMemcpyHostToDevice));
 }
@@ -449,10 +451,10 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer)
   GPUChkErrS(cudaMemcpyAsync(&(this->mNNeighbours[layer]), &(mNeighboursLUTDevice[layer][this->mNCells[layer + 1] - 1]), sizeof(unsigned int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of neighbours is correct
   GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
   GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer].get()));
   GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(int), mGpuStreams[layer], this->hasExternalDeviceAllocator());
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
 }
 
 template <int nLayers>
@@ -461,7 +463,7 @@ void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeedN>& s
   GPUTimer timer("reserving tracks");
   mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
   GPULog("gpu-allocation: reserving {} tracks, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), this->hasExternalDeviceAllocator());
+  allocMem(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
   GPUChkErrS(cudaMemset(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt)));
   GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
 }
@@ -474,13 +476,13 @@ void TimeFrameGPU<nLayers>::createVtxTrackletsLUTDevice(const int32_t iteration)
   for (int32_t iMode{0}; iMode < 2; ++iMode) {
     if (!iteration) {
       GPULog("gpu-transfer: creating vertexer tracklets per cluster for {} elements for mode {}, for {:.2f} MB.", ncls, iMode, ncls * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterDevice[iMode]), ncls * sizeof(int32_t), mGpuStreams[iMode], this->hasExternalDeviceAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterDevice[iMode]), ncls * sizeof(int32_t), mGpuStreams[iMode], this->hasFrameworkAllocator());
 
       GPULog("gpu-transfer: creating vertexer tracklets per cluster sum for {} elements for mode {}, for {:.2f} MB.", ncls + 1, iMode, (ncls + 1) * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDevice[iMode]), (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode], this->hasExternalDeviceAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDevice[iMode]), (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode], this->hasFrameworkAllocator());
 
       GPULog("gpu-transfer: creating vertexer tracklets per ROF for {} elements for mode {}, for {:.2f} MB.", this->mNrof + 1, iMode, (this->mNrof + 1) * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerROFDevice[iMode]), (this->mNrof + 1) * sizeof(int32_t), mGpuStreams[iMode], this->hasExternalDeviceAllocator());
+      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerROFDevice[iMode]), (this->mNrof + 1) * sizeof(int32_t), mGpuStreams[iMode], this->hasFrameworkAllocator());
     }
     GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterDevice[iMode], 0, ncls * sizeof(int32_t), mGpuStreams[iMode].get()));
     GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterSumDevice[iMode], 0, (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode].get()));
@@ -489,13 +491,13 @@ void TimeFrameGPU<nLayers>::createVtxTrackletsLUTDevice(const int32_t iteration)
   mGpuStreams[0].sync();
   mGpuStreams[1].sync();
   if (!iteration) {
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterDeviceArray), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterDeviceArray), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mNTrackletsPerClusterDeviceArray, mNTrackletsPerClusterDevice.data(), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
 
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDeviceArray), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDeviceArray), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mNTrackletsPerClusterSumDeviceArray, mNTrackletsPerClusterSumDevice.data(), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
 
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerROFDeviceArray), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), this->hasExternalDeviceAllocator());
+    allocMem(reinterpret_cast<void**>(&mNTrackletsPerROFDeviceArray), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mNTrackletsPerROFDeviceArray, mNTrackletsPerROFDevice.data(), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
   }
 }
@@ -508,11 +510,11 @@ void TimeFrameGPU<nLayers>::createVtxTrackletsBuffers(const int32_t iteration)
     this->mTotalTracklets[iMode] = 0;
     GPUChkErrS(cudaMemcpyAsync(&(this->mTotalTracklets[iMode]), mNTrackletsPerClusterSumDevice[iMode] + this->mClusters[1].size(), sizeof(int32_t), cudaMemcpyDeviceToHost, mGpuStreams[iMode].get()));
     GPULog("gpu-transfer: creating vertexer tracklets buffer for {} elements on layer {}, for {:.2f} MB.", this->mTotalTracklets[iMode], iMode, this->mTotalTracklets[iMode] * sizeof(Tracklet) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iMode]), this->mTotalTracklets[iMode] * sizeof(Tracklet), mGpuStreams[iMode], this->hasExternalDeviceAllocator());
+    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iMode]), this->mTotalTracklets[iMode] * sizeof(Tracklet), mGpuStreams[iMode], this->hasFrameworkAllocator());
   }
   mGpuStreams[0].sync();
   mGpuStreams[1].sync();
-  allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), 2 * sizeof(Tracklet*), this->hasExternalDeviceAllocator());
+  allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), 2 * sizeof(Tracklet*), this->hasFrameworkAllocator());
   GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), 2 * sizeof(Tracklet*), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpy(mTrackletsDeviceArray, mTrackletsDevice.data(), 2 * sizeof(Tracklet*), cudaMemcpyHostToDevice));
 }
@@ -524,14 +526,14 @@ void TimeFrameGPU<nLayers>::createVtxLinesLUTDevice(const int32_t iteration)
   const int32_t ncls = this->mClusters[1].size();
 
   GPULog("gpu-transfer: creating vertexer lines per cluster for {} elements , for {:.2f} MB.", ncls, ncls * sizeof(int32_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterDevice), ncls * sizeof(int32_t), this->hasExternalDeviceAllocator());
+  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterDevice), ncls * sizeof(int32_t), this->hasFrameworkAllocator());
 
   GPULog("gpu-transfer: creating vertexer lines per cluster sum for {} elements , for {:.2f} MB.", ncls + 1, (ncls + 1) * sizeof(int32_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterSumDevice), (ncls + 1) * sizeof(int32_t), this->hasExternalDeviceAllocator());
+  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterSumDevice), (ncls + 1) * sizeof(int32_t), this->hasFrameworkAllocator());
 
   const int32_t ntrkls = this->mTotalTracklets[0];
   GPULog("gpu-transfer: creating vertexer used tracklets for {} elements , for {:.2f} MB.", ntrkls, ntrkls * sizeof(uint8_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mUsedTrackletsDevice), ntrkls * sizeof(uint8_t), this->hasExternalDeviceAllocator());
+  allocMem(reinterpret_cast<void**>(&mUsedTrackletsDevice), ntrkls * sizeof(uint8_t), this->hasFrameworkAllocator());
 }
 
 template <int nLayers>
@@ -542,7 +544,7 @@ void TimeFrameGPU<nLayers>::createVtxLinesBuffer(const int32_t iteration)
   GPUChkErrS(cudaMemcpy(&nlines, mNLinesPerClusterDevice + this->mClusters[1].size(), sizeof(int32_t), cudaMemcpyDeviceToHost));
   this->mTotalLines = nlines;
   GPULog("gpu-transfer: creating vertexer lines for {} elements , for {:.2f} MB.", nlines, nlines * sizeof(Line) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mLinesDevice), nlines * sizeof(Line), this->hasExternalDeviceAllocator());
+  allocMem(reinterpret_cast<void**>(&mLinesDevice), nlines * sizeof(Line), this->hasFrameworkAllocator());
   // reset used tracklets
   GPUChkErrS(cudaMemset(mUsedTrackletsDevice, 0, this->mTotalTracklets[0] * sizeof(uint8_t)));
 }
@@ -630,6 +632,23 @@ void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
   checkedUnregisterArray(mPinnedROFramesClusters, mROFramesClustersDevice);
 }
 
+template <int nLayers>
+void TimeFrameGPU<nLayers>::pushMemoryStack(const int iteration)
+{
+  // mark the beginning of memory marked with MEMORY_STACK that can be discarded
+  // after doing one iteration
+  const auto name = fmt::format("ITSITER{}", iteration);
+  (this->mExternalAllocator)->pushTagOnStack(qStr2Tag(name.c_str()));
+}
+
+template <int nLayers>
+void TimeFrameGPU<nLayers>::popMemoryStack(const int iteration)
+{
+  // pop all memory on the stack from this iteration
+  const auto name = fmt::format("ITSITER{}", iteration);
+  (this->mExternalAllocator)->popTagOffStack(qStr2Tag(name.c_str()));
+}
+
 template <int nLayers>
 void TimeFrameGPU<nLayers>::initialise(const int iteration,
                                        const TrackingParameters& trkParam,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index cca4283c9b77f..05810f0074811 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -28,7 +28,6 @@ template <int nLayers>
 void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
 {
   mTimeFrameGPU->initialise(iteration, this->mTrkParams[iteration], nLayers);
-
   // on default stream
   mTimeFrameGPU->loadVertices(iteration);
   mTimeFrameGPU->loadIndexTableUtils(iteration);
@@ -45,6 +44,8 @@ void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
   mTimeFrameGPU->createTrackletsBuffersArray(iteration);
   mTimeFrameGPU->createCellsBuffersArray(iteration);
   mTimeFrameGPU->createCellsLUTDeviceArray(iteration);
+  // push every create artefact on the stack
+  mTimeFrameGPU->pushMemoryStack(iteration);
 }
 
 template <int nLayers>
@@ -108,7 +109,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getPositionResolutions(),
                                          this->mTrkParams[iteration].LayerRadii,
                                          mTimeFrameGPU->getMSangles(),
-                                         mTimeFrameGPU->getExternalDeviceAllocator(),
+                                         mTimeFrameGPU->getFrameworkAllocator(),
                                          conf.nBlocksLayerTracklets[iteration],
                                          conf.nThreadsLayerTracklets[iteration],
                                          mTimeFrameGPU->getStreams());
@@ -146,7 +147,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
                                            mTimeFrameGPU->getPositionResolutions(),
                                            this->mTrkParams[iteration].LayerRadii,
                                            mTimeFrameGPU->getMSangles(),
-                                           mTimeFrameGPU->getExternalDeviceAllocator(),
+                                           mTimeFrameGPU->getFrameworkAllocator(),
                                            conf.nBlocksLayerTracklets[iteration],
                                            conf.nThreadsLayerTracklets[iteration],
                                            mTimeFrameGPU->getStreams());
@@ -197,7 +198,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                                this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                                this->mTrkParams[iteration].NSigmaCut,
-                               mTimeFrameGPU->getExternalDeviceAllocator(),
+                               mTimeFrameGPU->getFrameworkAllocator(),
                                conf.nBlocksLayerCells[iteration],
                                conf.nThreadsLayerCells[iteration],
                                mTimeFrameGPU->getStreams());
@@ -253,7 +254,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                         currentLayerCellsNum,
                                         nextLayerCellsNum,
                                         1e2,
-                                        mTimeFrameGPU->getExternalDeviceAllocator(),
+                                        mTimeFrameGPU->getFrameworkAllocator(),
                                         conf.nBlocksFindNeighbours[iteration],
                                         conf.nThreadsFindNeighbours[iteration],
                                         mTimeFrameGPU->getStream(iLayer));
@@ -281,7 +282,7 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
                                                                                mTimeFrameGPU->getDeviceNeighbours(iLayer),
                                                                                mTimeFrameGPU->getArrayNNeighbours()[iLayer],
                                                                                mTimeFrameGPU->getStream(iLayer),
-                                                                               mTimeFrameGPU->getExternalDeviceAllocator());
+                                                                               mTimeFrameGPU->getFrameworkAllocator());
   }
   mTimeFrameGPU->syncStreams(false);
 }
@@ -312,7 +313,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
                                         this->mTrkParams[0].CorrType,
-                                        mTimeFrameGPU->getExternalDeviceAllocator(),
+                                        mTimeFrameGPU->getFrameworkAllocator(),
                                         conf.nBlocksProcessNeighbours[iteration],
                                         conf.nThreadsProcessNeighbours[iteration]);
     }
@@ -386,6 +387,8 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
     }
     mTimeFrameGPU->loadUsedClustersDevice();
   }
+  // wipe the artefact memory
+  mTimeFrameGPU->popMemoryStack(iteration);
 };
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 2c43ccd3bb81c..71f1281401e9d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -644,23 +644,6 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
   }
 }
 
-GPUhi() void allocateMemory(void** p, size_t bytes, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
-{
-  if (alloc) {
-    *p = alloc->allocate(bytes);
-  } else {
-    GPUChkErrS(cudaMallocAsync(p, bytes, stream));
-  }
-}
-
-GPUhi() void deallocateMemory(void* p, size_t bytes, cudaStream_t stream = nullptr, ExternalAllocator* alloc = nullptr)
-{
-  if (alloc) {
-    alloc->deallocate(reinterpret_cast<char*>(p), bytes);
-  } else {
-    GPUChkErrS(cudaFreeAsync(p, stream));
-  }
-}
 } // namespace gpu
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
index 36e78ef24020c..7d1e98736db2c 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ExternalAllocator.h
@@ -17,15 +17,39 @@
 #define TRACKINGITSU_INCLUDE_EXTERNALALLOCATOR_H_
 
 #include <memory_resource>
+#include "GPUO2ExternalUser.h"
+#include "Base/GPUMemoryResource.h"
 
 namespace o2::its
 {
 
 class ExternalAllocator
 {
+  using Type = std::underlying_type_t<o2::gpu::GPUMemoryResource::MemoryType>;
+
  public:
-  virtual void* allocate(size_t) = 0;
   virtual void deallocate(char*, size_t) = 0;
+  virtual void* allocate(size_t) = 0;
+  void* allocate(size_t s, Type type)
+  {
+    auto old = mType;
+    mType = type;
+    void* p = allocate(s);
+    mType = old;
+    return p;
+  }
+  void* allocateStack(size_t s)
+  {
+    return allocate(s, (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  }
+  virtual void pushTagOnStack(uint64_t) = 0;
+  virtual void popTagOffStack(uint64_t) = 0;
+
+  void setType(Type t) noexcept { mType = t; }
+  Type getType() const noexcept { return mType; }
+
+ protected:
+  Type mType;
 };
 
 class ExternalAllocatorAdaptor final : public std::pmr::memory_resource
@@ -36,7 +60,7 @@ class ExternalAllocatorAdaptor final : public std::pmr::memory_resource
  protected:
   void* do_allocate(size_t bytes, size_t alignment) override
   {
-    void* p = mAlloc->allocate(bytes);
+    void* p = mAlloc->allocate(bytes, o2::gpu::GPUMemoryResource::MemoryType::MEMORY_HOST);
     if (!p) {
       throw std::bad_alloc();
     }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index b324092624a6d..4dbb9f09f6192 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -33,7 +33,6 @@
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/ExternalAllocator.h"
 #include "ITStracking/BoundedAllocator.h"
-
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 
@@ -235,23 +234,14 @@ struct TimeFrame {
   void setBz(float bz) { mBz = bz; }
   float getBz() const { return mBz; }
 
-  /// State if memory will be externally managed.
-  // device
-  ExternalAllocator* mExtDeviceAllocator{nullptr};
-  void setExternalDeviceAllocator(ExternalAllocator* allocator) { mExtDeviceAllocator = allocator; }
-  ExternalAllocator* getExternalDeviceAllocator() { return mExtDeviceAllocator; }
-  bool hasExternalDeviceAllocator() const noexcept { return mExtDeviceAllocator != nullptr; }
-  // host
-  ExternalAllocator* mExtHostAllocator{nullptr};
-  void setExternalHostAllocator(ExternalAllocator* allocator)
-  {
-    mExtHostAllocator = allocator;
-    mExtMemoryPool = std::make_shared<BoundedMemoryResource>(mExtHostAllocator);
-  }
-  ExternalAllocator* getExternalHostAllocator() { return mExtHostAllocator; }
-  bool hasExternalHostAllocator() const noexcept { return mExtHostAllocator != nullptr; }
-  std::shared_ptr<BoundedMemoryResource> mExtMemoryPool;
-  std::pmr::memory_resource* getMaybeExternalHostResource(bool forceHost = false) { return (hasExternalHostAllocator() && !forceHost) ? mExtMemoryPool.get() : mMemoryPool.get(); }
+  /// State if memory will be externally managed by the GPU framework
+  ExternalAllocator* mExternalAllocator{nullptr};
+  std::shared_ptr<BoundedMemoryResource> mExtMemoryPool; // host memory pool managed by the framework
+  auto getFrameworkAllocator() { return mExternalAllocator; };
+  void setFrameworkAllocator(ExternalAllocator* ext);
+  bool hasFrameworkAllocator() const noexcept { return mExternalAllocator != nullptr; }
+  std::pmr::memory_resource* getMaybeFrameworkHostResource(bool forceHost = false) { return (hasFrameworkAllocator() && !forceHost) ? mExtMemoryPool.get() : mMemoryPool.get(); }
+
   // Propagator
   const o2::base::PropagatorImpl<float>* getDevicePropagator() const { return mPropagatorDevice; }
   virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>*) {};
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index ca28ee227df56..0d8b461181741 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -177,9 +177,9 @@ template <int nLayers>
 void TimeFrame<nLayers>::resetROFrameData(size_t nRofs)
 {
   for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
-    deepVectorClear(mUnsortedClusters[iLayer], getMaybeExternalHostResource());
-    deepVectorClear(mTrackingFrameInfo[iLayer], getMaybeExternalHostResource());
-    clearResizeBoundedVector(mROFramesClusters[iLayer], nRofs + 1, getMaybeExternalHostResource());
+    deepVectorClear(mUnsortedClusters[iLayer], getMaybeFrameworkHostResource());
+    deepVectorClear(mTrackingFrameInfo[iLayer], getMaybeFrameworkHostResource());
+    clearResizeBoundedVector(mROFramesClusters[iLayer], nRofs + 1, getMaybeFrameworkHostResource());
     deepVectorClear(mClusterExternalIndices[iLayer], mMemoryPool.get());
 
     if (iLayer < 2) {
@@ -302,11 +302,11 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     clearResizeBoundedVector(mBogusClusters, trkParam.NLayers, mMemoryPool.get());
     deepVectorClear(mTrackletClusters);
     for (unsigned int iLayer{0}; iLayer < std::min((int)mClusters.size(), maxLayers); ++iLayer) {
-      clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeExternalHostResource(maxLayers != nLayers));
-      clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeExternalHostResource(maxLayers != nLayers));
+      clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeFrameworkHostResource(maxLayers != nLayers));
+      clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeFrameworkHostResource(maxLayers != nLayers));
       mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
     }
-    clearResizeBoundedArray(mIndexTables, mNrof * (trkParam.ZBins * trkParam.PhiBins + 1), getMaybeExternalHostResource(maxLayers != nLayers));
+    clearResizeBoundedArray(mIndexTables, mNrof * (trkParam.ZBins * trkParam.PhiBins + 1), getMaybeFrameworkHostResource(maxLayers != nLayers));
     clearResizeBoundedVector(mLines, mNrof, mMemoryPool.get());
     clearResizeBoundedVector(mTrackletClusters, mNrof, mMemoryPool.get());
 
@@ -574,6 +574,7 @@ void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> po
       initVector(v, useExternal);
     }
   };
+
   // these will only reside on the host for the cpu part
   initVector(mTotVertPerIteration);
   initContainers(mClusterExternalIndices);
@@ -603,12 +604,19 @@ void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> po
   initVector(mRoadLabels);
   initContainers(mTracksLabel);
   // these will use possibly an externally provided allocator
-  initContainers(mClusters, hasExternalHostAllocator());
-  initContainers(mUsedClusters, hasExternalHostAllocator());
-  initContainers(mUnsortedClusters, hasExternalHostAllocator());
-  initContainers(mIndexTables, hasExternalHostAllocator());
-  initContainers(mTrackingFrameInfo, hasExternalHostAllocator());
-  initContainers(mROFramesClusters, hasExternalHostAllocator());
+  initContainers(mClusters, hasFrameworkAllocator());
+  initContainers(mUsedClusters, hasFrameworkAllocator());
+  initContainers(mUnsortedClusters, hasFrameworkAllocator());
+  initContainers(mIndexTables, hasFrameworkAllocator());
+  initContainers(mTrackingFrameInfo, hasFrameworkAllocator());
+  initContainers(mROFramesClusters, hasFrameworkAllocator());
+}
+
+template <int nLayers>
+void TimeFrame<nLayers>::setFrameworkAllocator(ExternalAllocator* ext)
+{
+  mExternalAllocator = ext;
+  mExtMemoryPool = std::make_shared<BoundedMemoryResource>(mExternalAllocator);
 }
 
 template <int nLayers>
@@ -639,7 +647,7 @@ void TimeFrame<nLayers>::wipe()
   deepVectorClear(mLines);
   // if we use the external host allocator then the assumption is that we
   // don't clear the memory ourself
-  if (!hasExternalHostAllocator()) {
+  if (!hasFrameworkAllocator()) {
     deepVectorClear(mClusters);
     deepVectorClear(mUsedClusters);
     deepVectorClear(mUnsortedClusters);
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index a85cdb48c4d1c..9be553de27f95 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -25,18 +25,23 @@ namespace o2::its
 class GPUFrameworkExternalAllocator final : public o2::its::ExternalAllocator
 {
  public:
-  GPUFrameworkExternalAllocator(GPUMemoryResource::MemoryType type) : mType(type) {}
-
-  void* allocate(size_t size) override
+  void* allocate(size_t size) final
   {
     return mFWReco->AllocateDirectMemory(size, mType);
   }
-  void deallocate(char* ptr, size_t size) override {}
+  void deallocate(char* ptr, size_t size) final {} // this is a simple no-op
+  void pushTagOnStack(uint64_t tag)
+  {
+    mFWReco->PushNonPersistentMemory(tag);
+  }
+  void popTagOffStack(uint64_t tag)
+  {
+    mFWReco->PopNonPersistentMemory(GPUDataTypes::RecoStep::ITSTracking, tag);
+  }
   void setReconstructionFramework(o2::gpu::GPUReconstruction* fwr) { mFWReco = fwr; }
 
  private:
   o2::gpu::GPUReconstruction* mFWReco;
-  GPUMemoryResource::MemoryType mType;
 };
 } // namespace o2::its
 
@@ -73,12 +78,9 @@ o2::its::TimeFrame<7>* GPUChainITS::GetITSTimeframe()
   }
 #if !defined(GPUCA_STANDALONE)
   if (mITSTimeFrame->isGPU()) {
-    mFrameworkDeviceAllocator.reset(new o2::its::GPUFrameworkExternalAllocator(GPUMemoryResource::MEMORY_GPU));
-    mFrameworkDeviceAllocator->setReconstructionFramework(rec());
-    mITSTimeFrame->setExternalDeviceAllocator(mFrameworkDeviceAllocator.get());
-    mFrameworkHostAllocator.reset(new o2::its::GPUFrameworkExternalAllocator(GPUMemoryResource::MEMORY_HOST));
-    mFrameworkHostAllocator->setReconstructionFramework(rec());
-    mITSTimeFrame->setExternalHostAllocator(mFrameworkHostAllocator.get());
+    mFrameworkAllocator.reset(new o2::its::GPUFrameworkExternalAllocator());
+    mFrameworkAllocator->setReconstructionFramework(rec());
+    mITSTimeFrame->setFrameworkAllocator(mFrameworkAllocator.get());
   }
 #endif
   return mITSTimeFrame.get();
diff --git a/GPU/GPUTracking/Global/GPUChainITS.h b/GPU/GPUTracking/Global/GPUChainITS.h
index ab693bcef3f8b..a607f66322bab 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.h
+++ b/GPU/GPUTracking/Global/GPUChainITS.h
@@ -53,8 +53,7 @@ class GPUChainITS final : public GPUChain
   std::unique_ptr<o2::its::TrackerTraits<7>> mITSTrackerTraits;
   std::unique_ptr<o2::its::VertexerTraits<7>> mITSVertexerTraits;
   std::unique_ptr<o2::its::TimeFrame<7>> mITSTimeFrame;
-  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkDeviceAllocator;
-  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkHostAllocator;
+  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkAllocator;
 };
 } // namespace o2::gpu
 

From a8e788c4356730df1fcf8ff1c82ecd3f43fd0331 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 19 Nov 2025 18:32:52 +0100
Subject: [PATCH 1047/1764] DPL Analysis: add label to the spawned table
 metadata

---
 Framework/Core/src/AODReaderHelpers.cxx | 1 +
 Framework/Core/src/TableBuilder.cxx     | 7 +++----
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
index 0c556920d3fcb..09ec16a93b087 100644
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ b/Framework/Core/src/AODReaderHelpers.cxx
@@ -240,6 +240,7 @@ struct Spawnable {
 
   Maker createMaker()
   {
+    o2::framework::addLabelToSchema(outputSchema, binding.c_str());
     return {
       binding,
       labels,
diff --git a/Framework/Core/src/TableBuilder.cxx b/Framework/Core/src/TableBuilder.cxx
index 7e256fb9f1712..c80fef9f0533c 100644
--- a/Framework/Core/src/TableBuilder.cxx
+++ b/Framework/Core/src/TableBuilder.cxx
@@ -144,7 +144,7 @@ std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const&
   while (true) {
     auto s = reader.ReadNext(&batch);
     if (!s.ok()) {
-      throw runtime_error_f("Cannot read batches from source table to spawn %s: %s", name, s.ToString().c_str());
+      throw runtime_error_f("Cannot read batches from the source table to spawn %s: %s", name, s.ToString().c_str());
     }
     if (batch == nullptr) {
       break;
@@ -152,10 +152,10 @@ std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const&
     try {
       s = projector->Evaluate(*batch, arrow::default_memory_pool(), &v);
       if (!s.ok()) {
-        throw runtime_error_f("Cannot apply projector to source table of %s: %s", name, s.ToString().c_str());
+        throw runtime_error_f("Cannot apply projector to the source table of %s: %s", name, s.ToString().c_str());
       }
     } catch (std::exception& e) {
-      throw runtime_error_f("Cannot apply projector to source table of %s: exception caught: %s", name, e.what());
+      throw runtime_error_f("Cannot apply projector to the source table of %s: exception caught: %s", name, e.what());
     }
 
     for (auto i = 0U; i < nColumns; ++i) {
@@ -168,7 +168,6 @@ std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const&
     arrays.push_back(std::make_shared<arrow::ChunkedArray>(chunks[i]));
   }
 
-  addLabelToSchema(newSchema, name);
   return arrow::Table::Make(newSchema, arrays);
 }
 

From ca3e2cc2253fc360882b2210ed0025784026218f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 17 Nov 2025 16:04:26 +0100
Subject: [PATCH 1048/1764] DPL: use rapidjson to dump metrics

---
 .../include/Framework/DeviceMetricsInfo.h     |  10 +-
 .../Core/src/ResourcesMonitoringHelper.cxx    | 107 +++++++++---------
 .../test/test_ResourcesMonitoringHelpers.cxx  |   6 +-
 3 files changed, 63 insertions(+), 60 deletions(-)

diff --git a/Framework/Core/include/Framework/DeviceMetricsInfo.h b/Framework/Core/include/Framework/DeviceMetricsInfo.h
index ad143b7ef9373..05249898c65a2 100644
--- a/Framework/Core/include/Framework/DeviceMetricsInfo.h
+++ b/Framework/Core/include/Framework/DeviceMetricsInfo.h
@@ -154,11 +154,11 @@ struct DeviceMetricsInfo {
   std::vector<MetricsStorage<StringMetric>> stringMetrics; // We do not keep so many strings as metrics as history is less relevant.
   std::vector<MetricsStorage<float>> floatMetrics;
   std::vector<MetricsStorage<int8_t>> enumMetrics;
-  std::vector<std::array<size_t, metricStorageSize<int>()>> intTimestamps;
-  std::vector<std::array<size_t, metricStorageSize<uint64_t>()>> uint64Timestamps;
-  std::vector<std::array<size_t, metricStorageSize<float>()>> floatTimestamps;
-  std::vector<std::array<size_t, metricStorageSize<StringMetric>()>> stringTimestamps;
-  std::vector<std::array<size_t, metricStorageSize<int8_t>()>> enumTimestamps;
+  std::vector<TimestampsStorage<int>> intTimestamps;
+  std::vector<TimestampsStorage<uint64_t>> uint64Timestamps;
+  std::vector<TimestampsStorage<float>> floatTimestamps;
+  std::vector<TimestampsStorage<StringMetric>> stringTimestamps;
+  std::vector<TimestampsStorage<int8_t>> enumTimestamps;
   std::vector<float> max;
   std::vector<float> min;
   std::vector<float> average;
diff --git a/Framework/Core/src/ResourcesMonitoringHelper.cxx b/Framework/Core/src/ResourcesMonitoringHelper.cxx
index 1d53d0f1f2a3c..d457edb4844e5 100644
--- a/Framework/Core/src/ResourcesMonitoringHelper.cxx
+++ b/Framework/Core/src/ResourcesMonitoringHelper.cxx
@@ -8,12 +8,13 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-
 #include "ResourcesMonitoringHelper.h"
 #include "Framework/DeviceMetricsInfo.h"
-#define BOOST_BIND_GLOBAL_PLACEHOLDERS
-#include <boost/property_tree/json_parser.hpp>
-#include <fstream>
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/ostreamwrapper.h>
+
+#include <ostream>
+#include <string>
 #include <string_view>
 #include <algorithm>
 #include <cassert>
@@ -22,34 +23,28 @@
 using namespace o2::framework;
 
 template <typename T>
-inline static T retriveValue(T val)
+void fillNodeWithValue(rapidjson::Writer<rapidjson::OStreamWrapper>& w,
+                       size_t filledMetrics,
+                       MetricsStorage<T> const& metricsStorage,
+                       TimestampsStorage<T> const& timestampsStorage)
 {
-  return val;
-}
-
-inline static std::string retriveValue(const std::reference_wrapper<const StringMetric> val)
-{
-  return std::string(val.get().data);
-}
-
-template <typename T, typename TIMESTAMPS>
-boost::property_tree::ptree fillNodeWithValue(const DeviceMetricsInfo& deviceMetrics,
-                                              const T& metricsStorage, const TIMESTAMPS& timestampsStorage, size_t labelIndex, size_t storeIndex)
-{
-  unsigned int loopRange = std::min(deviceMetrics.metrics[labelIndex].filledMetrics, metricsStorage[storeIndex].size());
-  boost::property_tree::ptree metricNode;
+  unsigned int loopRange = std::min(filledMetrics, metricsStorage.size());
 
+  w.StartArray();
   for (unsigned int idx = 0; idx < loopRange; ++idx) {
-    boost::property_tree::ptree values;
-    values.add("timestamp", timestampsStorage[storeIndex][idx]);
+    w.StartObject();
+    w.Key("timestamp");
+    std::string s = std::to_string(timestampsStorage[idx]);
+    w.String(s.c_str(), s.size());
+    w.Key("value");
     if constexpr (std::is_arithmetic_v<T>) {
-      values.add("value", std::to_string(retriveValue(std::cref(metricsStorage[storeIndex][idx]))));
+      w.String(std::to_string(metricsStorage[idx]).c_str());
     } else {
-      values.add("value", retriveValue(std::cref(metricsStorage[storeIndex][idx])));
+      w.String(metricsStorage[idx].data);
     }
-    metricNode.push_back(std::make_pair("", values));
+    w.EndObject();
   }
-  return metricNode;
+  w.EndArray();
 }
 
 bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetricsInfo>& metrics,
@@ -58,19 +53,23 @@ bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetric
                                                   std::vector<std::regex> const& performanceMetricsRegex,
                                                   std::ostream& out) noexcept
 {
-
   assert(metrics.size() == specs.size());
 
   if (metrics.empty()) {
     return false;
   }
 
-  boost::property_tree::ptree root;
-  for (unsigned int idx = 0; idx < metrics.size(); ++idx) {
+  rapidjson::OStreamWrapper osw(out);
+  rapidjson::PrettyWriter<rapidjson::OStreamWrapper> w(osw);
+
+  // Top level obejct for all the metrics
+  w.StartObject();
 
+  for (unsigned int idx = 0; idx < metrics.size(); ++idx) {
+    w.Key(specs[idx].id.c_str());
     const auto& deviceMetrics = metrics[idx];
-    boost::property_tree::ptree deviceRoot;
 
+    w.StartObject();
     for (size_t mi = 0; mi < deviceMetrics.metricLabels.size(); mi++) {
       std::string_view metricLabel{deviceMetrics.metricLabels[mi].label, deviceMetrics.metricLabels[mi].size};
 
@@ -83,40 +82,42 @@ bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetric
       }
       auto storeIdx = deviceMetrics.metrics[mi].storeIdx;
 
+      size_t filledMetrics = deviceMetrics.metrics[mi].filledMetrics;
       if (deviceMetrics.metrics[mi].filledMetrics == 0) {
         continue;
       }
-      // if so
-
-      boost::property_tree::ptree metricNode;
-
+      w.Key(metricLabel.data(), metricLabel.size());
       switch (deviceMetrics.metrics[mi].type) {
         case MetricType::Int:
-          metricNode = fillNodeWithValue(deviceMetrics, deviceMetrics.intMetrics, deviceMetrics.intTimestamps, mi, storeIdx);
+          fillNodeWithValue(w, filledMetrics, deviceMetrics.intMetrics[storeIdx],
+                            deviceMetrics.intTimestamps[storeIdx]);
           break;
 
         case MetricType::Float:
-          metricNode = fillNodeWithValue(deviceMetrics, deviceMetrics.floatMetrics, deviceMetrics.floatTimestamps, mi, storeIdx);
+          fillNodeWithValue(w, filledMetrics, deviceMetrics.floatMetrics[storeIdx],
+                            deviceMetrics.floatTimestamps[storeIdx]);
           break;
 
         case MetricType::String:
-          metricNode = fillNodeWithValue(deviceMetrics, deviceMetrics.stringMetrics, deviceMetrics.stringTimestamps, mi, storeIdx);
+          fillNodeWithValue(w, filledMetrics, deviceMetrics.stringMetrics[storeIdx],
+                            deviceMetrics.stringTimestamps[storeIdx]);
           break;
 
         case MetricType::Uint64:
-          metricNode = fillNodeWithValue(deviceMetrics, deviceMetrics.uint64Metrics, deviceMetrics.uint64Timestamps, mi, storeIdx);
+          fillNodeWithValue(w, filledMetrics, deviceMetrics.uint64Metrics[storeIdx],
+                            deviceMetrics.uint64Timestamps[storeIdx]);
           break;
 
         default:
           continue;
       }
-      deviceRoot.add_child(std::string(metricLabel), metricNode);
     }
 
-    root.add_child(specs[idx].id, deviceRoot);
+    w.EndObject();
   }
 
-  boost::property_tree::ptree driverRoot;
+  w.Key("driver");
+  w.StartObject();
   for (size_t mi = 0; mi < driverMetrics.metricLabels.size(); mi++) {
     std::string_view const metricLabel{driverMetrics.metricLabels[mi].label, driverMetrics.metricLabels[mi].size};
     auto same = [metricLabel](std::regex const& matcher) -> bool {
@@ -130,39 +131,39 @@ bool ResourcesMonitoringHelper::dumpMetricsToJSON(const std::vector<DeviceMetric
 
     auto storeIdx = driverMetrics.metrics[mi].storeIdx;
     // and if data is there
-    if (driverMetrics.metrics[mi].filledMetrics == 0) {
+    size_t filledMetrics = driverMetrics.metrics[mi].filledMetrics;
+    if (filledMetrics == 0) {
       continue;
     }
 
-    // if so
-    boost::property_tree::ptree metricNode;
-
+    w.Key(metricLabel.data(), metricLabel.size());
     switch (driverMetrics.metrics[mi].type) {
       case MetricType::Int:
-        metricNode = fillNodeWithValue(driverMetrics, driverMetrics.intMetrics, driverMetrics.intTimestamps, mi, storeIdx);
+        fillNodeWithValue(w, filledMetrics, driverMetrics.intMetrics[storeIdx],
+                          driverMetrics.intTimestamps[storeIdx]);
         break;
 
       case MetricType::Float:
-        metricNode = fillNodeWithValue(driverMetrics, driverMetrics.floatMetrics, driverMetrics.floatTimestamps, mi, storeIdx);
+        fillNodeWithValue(w, filledMetrics, driverMetrics.floatMetrics[storeIdx],
+                          driverMetrics.floatTimestamps[storeIdx]);
         break;
 
       case MetricType::String:
-        metricNode = fillNodeWithValue(driverMetrics, driverMetrics.stringMetrics, driverMetrics.stringTimestamps, mi, storeIdx);
+        fillNodeWithValue(w, filledMetrics, driverMetrics.stringMetrics[storeIdx],
+                          driverMetrics.stringTimestamps[storeIdx]);
         break;
 
       case MetricType::Uint64:
-        metricNode = fillNodeWithValue(driverMetrics, driverMetrics.uint64Metrics, driverMetrics.uint64Timestamps, mi, storeIdx);
+        fillNodeWithValue(w, filledMetrics, driverMetrics.uint64Metrics[storeIdx],
+                          driverMetrics.uint64Timestamps[storeIdx]);
         break;
 
       default:
         continue;
     }
-    driverRoot.add_child(std::string{metricLabel}, metricNode);
   }
-
-  root.add_child("driver", driverRoot);
-
-  boost::property_tree::json_parser::write_json(out, root);
+  w.EndObject();
+  w.EndObject();
 
   return true;
 }
diff --git a/Framework/Core/test/test_ResourcesMonitoringHelpers.cxx b/Framework/Core/test/test_ResourcesMonitoringHelpers.cxx
index 9e355d535f301..e31ccea0f5a35 100644
--- a/Framework/Core/test/test_ResourcesMonitoringHelpers.cxx
+++ b/Framework/Core/test/test_ResourcesMonitoringHelpers.cxx
@@ -166,7 +166,8 @@ TEST_CASE("StreamMetrics")
   ResourcesMonitoringHelper::dumpMetricsToJSON(metrics,
                                                driverMetrics, specs, performanceMetrics,
                                                streamer);
-  REQUIRE(streamer.str() == R"JSON({
+  std::string streamed = streamer.str();
+  std::string expected = R"JSON({
     "someDevice": {
         "ckey": [
             {
@@ -266,5 +267,6 @@ TEST_CASE("StreamMetrics")
         ]
     }
 }
-)JSON");
+)JSON";
+  REQUIRE(std::regex_replace(streamed, std::regex(R"(\s+)"), "") == std::regex_replace(expected, std::regex(R"(\s+)"), ""));
 }

From 6e72bab67e6977ed228e0ba0e402254caa56f069 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 20 Nov 2025 21:11:36 +0100
Subject: [PATCH 1049/1764] DPL: fix thread safety of slot allocation in
 runtime_error_f (#14835)

---
 Framework/Foundation/src/RuntimeError.cxx | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/Framework/Foundation/src/RuntimeError.cxx b/Framework/Foundation/src/RuntimeError.cxx
index 6f31fb40b86f5..7d31389a9641c 100644
--- a/Framework/Foundation/src/RuntimeError.cxx
+++ b/Framework/Foundation/src/RuntimeError.cxx
@@ -60,8 +60,11 @@ RuntimeError& error_from_ref(RuntimeErrorRef ref)
 RuntimeErrorRef runtime_error_f(const char* format, ...)
 {
   int i = 0;
-  bool expected = false;
-  while (gErrorBooking[i].compare_exchange_strong(expected, true) == false) {
+  while (true) {
+    bool expected = false;
+    if (gErrorBooking[i].compare_exchange_strong(expected, true) == true) {
+      break;
+    }
     ++i;
     if (i >= RuntimeError::MAX_RUNTIME_ERRORS) {
       throw std::runtime_error("Too many o2::framework::runtime_error thrown without proper cleanup.");
@@ -78,11 +81,18 @@ RuntimeErrorRef runtime_error_f(const char* format, ...)
 RuntimeErrorRef runtime_error(const char* s)
 {
   int i = 0;
-  bool expected = false;
-  while (gErrorBooking[i].compare_exchange_strong(expected, true) == false) {
+  while (true) {
+    bool expected = false;
+    if (gErrorBooking[i].compare_exchange_strong(expected, true) == true) {
+      break;
+    }
     ++i;
+    if (i >= RuntimeError::MAX_RUNTIME_ERRORS) {
+      throw std::runtime_error("Too many o2::framework::runtime_error thrown without proper cleanup.");
+    }
   }
-  strncpy(gError[i].what, s, RuntimeError::MAX_RUNTIME_ERROR_SIZE);
+  strncpy(gError[i].what, s, RuntimeError::MAX_RUNTIME_ERROR_SIZE - 1);
+  gError[i].what[RuntimeError::MAX_RUNTIME_ERROR_SIZE - 1] = 0;
   gError[i].maxBacktrace = canDumpBacktrace() ? backtrace(gError[i].backtrace, BacktraceHelpers::MAX_BACKTRACE_SIZE) : 0;
   return RuntimeErrorRef{i};
 }

From 98cd61ee9a6277afa4fde283d479359aee7b69ad Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Thu, 20 Nov 2025 22:42:30 +0100
Subject: [PATCH 1050/1764] Generalize IR setting (#14833)

---
 Steer/src/CollisionContextTool.cxx | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index 6a2fca20afe76..5287e1ef32799 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -556,8 +556,10 @@ int main(int argc, char* argv[])
   float sgnIRate = -1.;
   for (auto& p : ispecs) {
     prefixes.push_back(p.name);
-    if (p.name == "sgn") {
-      // Setting interaction rate in the digitizer context as provided by the O2DPG workflow
+    // Set the interaction rate from the first pattern with a valid value.
+    // This handles both simple signal-only productions (where "sgn" has the rate)
+    // and embedding productions (where "bkg" has the rate and "sgn" syncs to it)
+    if (sgnIRate < 0 && p.interactionRate > 0) {
       LOG(debug) << "Setting signal interaction rate to " << p.interactionRate << " Hz in the digitization context.";
       sgnIRate = p.interactionRate;
       digicontext.setDigitizerInteractionRate(p.interactionRate);

From 84ee7bd7159f7275436eea4eba8c2b51a19dfa23 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 21 Nov 2025 10:15:24 +0100
Subject: [PATCH 1051/1764] ITS3: add study workflow and fix QA macros (#14780)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/Upgrades/ITS3/CMakeLists.txt        |   1 +
 .../Upgrades/ITS3/macros/test/CMakeLists.txt  |   1 -
 .../ITS3/macros/test/CheckClustersITS3.C      |   6 +-
 .../Upgrades/ITS3/macros/test/CheckDCA.C      | 965 ------------------
 .../ITS3/macros/test/CheckDigitsITS3.C        | 313 +++---
 Detectors/Upgrades/ITS3/study/CMakeLists.txt  |  37 +
 .../ITS3TrackingStudyParam.h                  |  49 +
 .../ITS3TrackingStudy/ParticleInfoExt.h       |  42 +
 .../include/ITS3TrackingStudy/TrackingStudy.h |  25 +
 .../Upgrades/ITS3/study/macros/CMakeLists.txt |  18 +
 .../Upgrades/ITS3/study/macros/PlotDCA.C      | 190 ++++
 .../Upgrades/ITS3/study/macros/PlotPulls.C    | 176 ++++
 .../ITS3/study/src/ITS3TrackingStudyLinkDef.h |  23 +
 .../ITS3/study/src/ITS3TrackingStudyParam.cxx |  13 +
 .../ITS3/study/src/ParticleInfoExt.cxx        |  13 +
 .../Upgrades/ITS3/study/src/TrackingStudy.cxx | 841 +++++++++++++++
 .../src/its3-tracking-study-workflow.cxx      |  73 ++
 17 files changed, 1677 insertions(+), 1109 deletions(-)
 delete mode 100644 Detectors/Upgrades/ITS3/macros/test/CheckDCA.C
 create mode 100644 Detectors/Upgrades/ITS3/study/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ITS3TrackingStudyParam.h
 create mode 100644 Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ParticleInfoExt.h
 create mode 100644 Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/TrackingStudy.h
 create mode 100644 Detectors/Upgrades/ITS3/study/macros/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ITS3/study/macros/PlotDCA.C
 create mode 100644 Detectors/Upgrades/ITS3/study/macros/PlotPulls.C
 create mode 100644 Detectors/Upgrades/ITS3/study/src/ITS3TrackingStudyLinkDef.h
 create mode 100644 Detectors/Upgrades/ITS3/study/src/ITS3TrackingStudyParam.cxx
 create mode 100644 Detectors/Upgrades/ITS3/study/src/ParticleInfoExt.cxx
 create mode 100644 Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
 create mode 100644 Detectors/Upgrades/ITS3/study/src/its3-tracking-study-workflow.cxx

diff --git a/Detectors/Upgrades/ITS3/CMakeLists.txt b/Detectors/Upgrades/ITS3/CMakeLists.txt
index 73ad4b9d53e37..5e40e59ad0068 100644
--- a/Detectors/Upgrades/ITS3/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/CMakeLists.txt
@@ -19,3 +19,4 @@ add_subdirectory(base)
 add_subdirectory(workflow)
 add_subdirectory(reconstruction)
 add_subdirectory(macros)
+add_subdirectory(study)
diff --git a/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt b/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
index cb6812445283c..6b274e764f276 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/macros/test/CMakeLists.txt
@@ -12,7 +12,6 @@
 its3_add_macro(CheckDigitsITS3.C)
 its3_add_macro(CheckClustersITS3.C)
 its3_add_macro(CheckTracksITS3.C)
-its3_add_macro(CheckDCA.C)
 its3_add_macro(CreateDictionariesITS3.C)
 its3_add_macro(buildMatBudLUT.C)
 its3_add_macro(CheckHits.C)
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C b/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
index f245a047377ae..5e56321c7676d 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckClustersITS3.C
@@ -283,7 +283,7 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
   nt.Draw("cgy:cgx>>h_cgy_vs_cgx_OB(1000, -50, 50, 1000, -50, 50)", "id >= 3456", "colz");
   canvCgXCgY->cd(4);
   nt.Draw("cgy:cgz>>h_cgy_vs_cgz_OB(1000, -100, 100, 1000, -50, 50)", "id >= 3456", "colz");
-  canvCgXCgY->SaveAs("it3clusters_y_vs_x_vs_z.pdf");
+  canvCgXCgY->SaveAs("it3clusters_y_vs_x_vs_z.png");
 
   auto canvdXdZ = new TCanvas("canvdXdZ", "", 1600, 800);
   canvdXdZ->Divide(2, 2);
@@ -295,7 +295,7 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
   nt.Draw("dx:dz>>h_dx_vs_dz_IB_z(1000, -0.01, 0.01, 1000, -0.01, 0.01)", "id < 3456 && abs(cgz) < 2", "colz");
   canvdXdZ->cd(4)->SetLogz();
   nt.Draw("dx:dz>>h_dx_vs_dz_OB_z(1000, -0.01, 0.01, 1000, -0.01, 0.01)", "id >= 3456 && abs(cgz) < 2", "colz");
-  canvdXdZ->SaveAs("it3clusters_dx_vs_dz.pdf");
+  canvdXdZ->SaveAs("it3clusters_dx_vs_dz.png");
 
   auto canvCHXZ = new TCanvas("canvCHXZ", "", 1600, 1600);
   canvCHXZ->Divide(2, 2);
@@ -307,7 +307,7 @@ void CheckClustersITS3(const std::string& clusfile = "o2clus_its.root",
   nt.Draw("(cgz-hgz)*10000:eta>>h_chz_IB(101,-1.4,1.4,101,-50,50)", "id<3456", "prof");
   canvCHXZ->cd(4);
   nt.Draw("(cgz-hgz)*10000:eta>>h_chz_OB(101,-1.4,1.4,101,-50,50)", "id>=3456", "prof");
-  canvCgXCgY->SaveAs("it3clusters_xz_eta.pdf");
+  canvCgXCgY->SaveAs("it3clusters_xz_eta.png");
 
   auto c1 = new TCanvas("p1", "pullX");
   c1->cd();
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckDCA.C b/Detectors/Upgrades/ITS3/macros/test/CheckDCA.C
deleted file mode 100644
index b2872431384f1..0000000000000
--- a/Detectors/Upgrades/ITS3/macros/test/CheckDCA.C
+++ /dev/null
@@ -1,965 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file CheckDCA.C
-/// \brief Simple macro to check ITS3 impact parameter resolution
-
-#if !defined(__CLING__) || defined(__ROOTCLING__)
-#include <TROOT.h>
-#include <TStyle.h>
-#include <TCanvas.h>
-#include <TFile.h>
-#include <TF1.h>
-#include <TH2F.h>
-#include <TLegend.h>
-#include <TPad.h>
-#include <TTree.h>
-#include <TList.h>
-#include <TSystem.h>
-
-#include "DataFormatsITS/TrackITS.h"
-#include "DataFormatsTPC/TrackTPC.h"
-#include "DetectorsBase/Propagator.h"
-#include "Field/MagneticField.h"
-#include "ITSBase/GeometryTGeo.h"
-#include "DetectorsBase/Propagator.h"
-#include "ReconstructionDataFormats/TrackTPCITS.h"
-#include "ReconstructionDataFormats/Vertex.h"
-#include "ReconstructionDataFormats/DCA.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCEventHeader.h"
-#include "SimulationDataFormat/MCTrack.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-#include "SimulationDataFormat/MCUtils.h"
-#include "SimulationDataFormat/TrackReference.h"
-#include "Steer/MCKinematicsReader.h"
-
-#include <array>
-#include <map>
-#include <iostream>
-#include <vector>
-#include <filesystem>
-#include <optional>
-#include <regex>
-#endif
-
-namespace fs = std::filesystem;
-
-constexpr auto mMatCorr{o2::base::Propagator::MatCorrType::USEMatCorrNONE};
-constexpr float mMaxStep{2};
-
-constexpr float rapMax{0.9};
-
-std::vector<fs::path> find_dirs(fs::path const& dir, std::function<bool(fs::path const&)> filter, std::optional<std::function<bool(fs::path const&, fs::path const&)>> sort = std::nullopt)
-{
-  std::vector<fs::path> result;
-  if (fs::exists(dir)) { // Find Dirs matching filter
-    for (auto const& entry : fs::recursive_directory_iterator(dir, fs::directory_options::follow_directory_symlink)) {
-      if (fs::is_directory(entry) && filter(entry)) {
-        result.emplace_back(entry);
-      }
-    }
-  }
-  if (sort) { // Optionally sort paths
-    std::sort(result.begin(), result.end(), *sort);
-  }
-  return result;
-}
-
-void CheckDCA(const std::string& collisioncontextFileName = "collisioncontext.root",
-              const std::string& tpcTracksFileName = "tpctracks.root",
-              const std::string& itsTracksFileName = "o2trac_its.root",
-              const std::string& itstpcTracksFileName = "o2match_itstpc.root",
-              const std::string& magFileName = "o2sim_grp.root")
-{
-  gROOT->SetBatch();
-  gStyle->SetOptStat(0);
-  gStyle->SetPalette(kRainBow);
-  gStyle->SetPadLeftMargin(0.16);
-  gStyle->SetPadTickX(1);
-  gStyle->SetPadTickY(1);
-  gErrorIgnoreLevel = 2001; // suppress warnings
-  ProcInfo_t procInfo;
-
-  const int nPtBins = 35;
-  const int nPtBinsEff = 39;
-  double ptLimits[nPtBins] = {0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2., 2.2, 2.5, 3., 4., 5., 6., 8., 10., 15., 20.};
-  double ptLimitsEff[nPtBinsEff] = {0.05, 0.06, 0.07, 0.08, 0.09, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2., 2.2, 2.5, 3., 4., 5., 6., 8., 10., 15., 20.};
-
-  const std::regex tf_pattern(R"(tf\d+)");
-  auto tf_matcher = [&tf_pattern](fs::path const& p) -> bool {
-    return std::regex_search(p.string(), tf_pattern);
-  };
-  auto tf_sorter = [&tf_pattern](fs::path const& a, fs::path const& b) -> bool {
-    const auto &as = a.string(), &bs = b.string();
-    std::smatch am, bm;
-    if (std::regex_search(as, am, tf_pattern) && std::regex_search(bs, bm, tf_pattern)) {
-      return std::stoi(am.str().substr(2)) < std::stoi(bm.str().substr(2));
-    } else {
-      LOGP(fatal, "TF Regex matching failed");
-      return false;
-    }
-  };
-
-  const int nSpecies = 4;
-  std::array<int, nSpecies> pdgCodes{11, 211, 321, 2212};
-  auto fGaus = new TF1("fGaus", "gaus", -200., 200.);
-  std::map<int, std::string> partNames = {
-    {11, "Electrons"},
-    {211, "Pions"},
-    {321, "Kaons"},
-    {2212, "Protons"}};
-  std::map<int, int> colors{{11, kOrange + 7}, {211, kRed + 1}, {321, kAzure + 4}, {2212, kGreen + 2}};
-  /// ITS
-  std::map<int, TH1F*> hDcaxyResAllLayersITS = {
-    {11, new TH1F("hDcaxyResElectronsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcaxyResPionsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcaxyResKaonsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcaxyResProtonsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcazResAllLayersITS = {
-    {11, new TH1F("hDcazResElectronsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcazResPionsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcazResKaonsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcazResProtonsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hPtResAllLayersITS = {
-    {11, new TH1F("hPtResElectronsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hPtResPionsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hPtResKaonsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hPtResProtonsAllLayersITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcaxyResNoFirstLayerITS = {
-    {11, new TH1F("hDcaxyResElectronsNoFirstLayerITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcaxyResPionsNoFirstLayerITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcaxyResKaonsNoFirstLayerITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcaxyResProtonsNoFirstLayerITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcazResNoFirstLayerITS = {
-    {11, new TH1F("hDcazResElectronsNoFirstLayerITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcazResPionsNoFirstLayerITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcazResKaonsNoFirstLayerITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcazResProtonsNoFirstLayerITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcaxyReskAnyITS = {
-    {11, new TH1F("hDcaxyResElectronskAnyITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcaxyResPionskAnyITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcaxyResKaonskAnyITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcaxyResProtonskAnyITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcazReskAnyITS = {
-    {11, new TH1F("hDcazResElectronskAnyITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcazResPionskAnyITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcazResKaonskAnyITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcazResProtonskAnyITS", "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)}};
-
-  std::map<int, TH2F*> hDcaxyVsPtAllLayersITS = {
-    {11, new TH2F("hDcaxyVsPtElectronsAllLayersITS", "ITS Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcaxyVsPtPionsAllLayersITS", "ITS Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcaxyVsPtKaonsAllLayersITS", "ITS Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcaxyVsPtProtonsAllLayersITS", "ITS Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcazVsPtAllLayersITS = {
-    {11, new TH2F("hDcazVsPtElectronsAllLayersITS", "ITS Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcazVsPtPionsAllLayersITS", "ITS Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcazVsPtKaonsAllLayersITS", "ITS Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcazVsPtProtonsAllLayersITS", "ITS Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcaxyVsPhiAllLayersITS = {
-    {11, new TH2F("hDcaxyVsPhiElectronsAllLayersITS", "ITS Electrons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{xy}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {211, new TH2F("hDcaxyVsPhiPionsAllLayersITS", "ITS Pions (>2 Gev);#varphi (rad);#sigma(DCA_{#it{xy}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {321, new TH2F("hDcaxyVsPhiKaonsAllLayersITS", "ITS Kaons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{xy}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {2212, new TH2F("hDcaxyVsPhiProtonsAllLayersITS", "ITS Protons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{xy}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcazVsPhiAllLayersITS = {
-    {11, new TH2F("hDcazVsPhiElectronsAllLayersITS", "ITS Electrons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{z}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {211, new TH2F("hDcazVsPhiPionsAllLayersITS", "ITS Pions (>2 Gev);#varphi (rad);#sigma(DCA_{#it{z}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {321, new TH2F("hDcazVsPhiKaonsAllLayersITS", "ITS Kaons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{z}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {2212, new TH2F("hDcazVsPhiProtonsAllLayersITS", "ITS Protons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{z}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcaxyVsPtNoFirstLayerITS = {
-    {11, new TH2F("hDcaxyVsPtElectronsNoFirstLayerITS", "ITS Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcaxyVsPtPionsNoFirstLayerITS", "ITS Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcaxyVsPtKaonsNoFirstLayerITS", "ITS Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcaxyVsPtProtonsNoFirstLayerITS", "ITS Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcazVsPtNoFirstLayerITS = {
-    {11, new TH2F("hDcazVsPtElectronsNoFirstLayerITS", "ITS Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcazVsPtPionsNoFirstLayerITS", "ITS Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcazVsPtKaonsNoFirstLayerITS", "ITS Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcazVsPtProtonsNoFirstLayerITS", "ITS Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcazVsPtkAnyITS = {
-    {11, new TH2F("hDcazVsPtElectronskAnyITS ", "ITS Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcazVsPtPionskAnyITS", "ITS Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcazVsPtKaonskAnyITS", "ITS Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcazVsPtProtonskAnyITS", "ITS Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcaxyVsPtkAnyITS = {
-    {11, new TH2F("hDcaxyVsPtElectronskAnyITS", "ITS Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcaxyVsPtPionskAnyITS", "ITS Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcaxyVsPtKaonskAnyITS", "ITS Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcaxyVsPtProtonskAnyITS", "ITS Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDeltaPtVsPtAllLayersITS = {
-    {11, new TH2F("hDeltaPtVsPtElectronsAllLayersITS", "ITS Electrons;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits, 200, -0.2, 0.2)},
-    {211, new TH2F("hDeltaPtVsPtPionsAllLayersITS", "ITS Pions;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits, 200, -0.2, 0.2)},
-    {321, new TH2F("hDeltaPtVsPtKaonsAllLayersITS", "ITS Kaons;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits, 200, -0.2, 0.2)},
-    {2212, new TH2F("hDeltaPtVsPtProtonsAllLayersITS", "ITS Protons;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits, 200, -0.2, 0.2)}};
-  // ITS-TPC
-  std::map<int, TH1F*> hDcaxyResAllLayersITSTPC = {
-    {11, new TH1F("hDcaxyResElectronsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcaxyResPionsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcaxyResKaonsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcaxyResProtonsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcazResAllLayersITSTPC = {
-    {11, new TH1F("hDcazResElectronsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcazResPionsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcazResKaonsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcazResProtonsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hPtResAllLayersITSTPC = {
-    {11, new TH1F("hPtResElectronsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hPtResPionsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hPtResKaonsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hPtResProtonsAllLayersITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcaxyResNoFirstLayerITSTPC = {
-    {11, new TH1F("hDcaxyResElectronsNoFirstLayerITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcaxyResPionsNoFirstLayerITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcaxyResKaonsNoFirstLayerITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcaxyResProtonsNoFirstLayerITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcazResNoFirstLayerITSTPC = {
-    {11, new TH1F("hDcazResElectronsNoFirstLayerITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcazResPionsNoFirstLayerITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcazResKaonsNoFirstLayerITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcazResProtonsNoFirstLayerITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcaxyReskAnyITSTPC = {
-    {11, new TH1F("hDcaxyResElectronskAnyITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcaxyResPionskAnyITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcaxyResKaonskAnyITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcaxyResProtonskAnyITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits)}};
-  std::map<int, TH1F*> hDcazReskAnyITSTPC = {
-    {11, new TH1F("hDcazResElectronskAnyITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {211, new TH1F("hDcazResPionskAnyITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {321, new TH1F("hDcazResKaonskAnyITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)},
-    {2212, new TH1F("hDcazResProtonskAnyITSTPC", "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits)}};
-
-  std::map<int, TH2F*> hDcaxyVsPtAllLayersITSTPC = {
-    {11, new TH2F("hDcaxyVsPtElectronsAllLayersITSTPC", "ITS-TPC Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcaxyVsPtPionsAllLayersITSTPC", "ITS-TPC Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcaxyVsPtKaonsAllLayersITSTPC", "ITS-TPC Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcaxyVsPtProtonsAllLayersITSTPC", "ITS-TPC Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcazVsPtAllLayersITSTPC = {
-    {11, new TH2F("hDcazVsPtElectronsAllLayersITSTPC", "ITS-TPC Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcazVsPtPionsAllLayersITSTPC", "ITS-TPC Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcazVsPtKaonsAllLayersITSTPC", "ITS-TPC Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcazVsPtProtonsAllLayersITSTPC", "ITS-TPC Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcaxyVsPhiAllLayersITSTPC = {
-    {11, new TH2F("hDcaxyVsPhiElectronsAllLayersITSTPC", "ITS-TPC Electrons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{xy}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {211, new TH2F("hDcaxyVsPhiPionsAllLayersITSTPC", "ITS-TPC Pions (>2 Gev);#varphi (rad);#sigma(DCA_{#it{xy}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {321, new TH2F("hDcaxyVsPhiKaonsAllLayersITSTPC", "ITS-TPC Kaons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{xy}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {2212, new TH2F("hDcaxyVsPhiProtonsAllLayersITSTPC", "ITS-TPC Protons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{xy}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcazVsPhiAllLayersITSTPC = {
-    {11, new TH2F("hDcazVsPhiElectronsAllLayersITSTPC", "ITS-TPC Electrons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{z}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {211, new TH2F("hDcazVsPhiPionsAllLayersITSTPC", "ITS-TPC Pions (>2 Gev);#varphi (rad);#sigma(DCA_{#it{z}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {321, new TH2F("hDcazVsPhiKaonsAllLayersITSTPC", "ITS-TPC Kaons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{z}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)},
-    {2212, new TH2F("hDcazVsPhiProtonsAllLayersITSTPC", "ITS-TPC Protons (>2 Gev);#varphi (rad);#sigma(DCA_{#it{z}}) (#mum)", 100, 0.f, 2 * TMath::Pi(), 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcaxyVsPtNoFirstLayerITSTPC = {
-    {11, new TH2F("hDcaxyVsPtElectronsNoFirstLayerITSTPC", "ITS-TPC Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcaxyVsPtPionsNoFirstLayerITSTPC", "ITS-TPC Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcaxyVsPtKaonsNoFirstLayerITSTPC", "ITS-TPC Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcaxyVsPtProtonsNoFirstLayerITSTPC", "ITS-TPC Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcazVsPtNoFirstLayerITSTPC = {
-    {11, new TH2F("hDcazVsPtElectronsNoFirstLayerITSTPC", "ITS-TPC Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcazVsPtPionsNoFirstLayerITSTPC", "ITS-TPC Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcazVsPtKaonsNoFirstLayerITSTPC", "ITS-TPC Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcazVsPtProtonsNoFirstLayerITSTPC", "ITS-TPC Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcazVsPtkAnyITSTPC = {
-    {11, new TH2F("hDcazVsPtElectronskAnyITSTPC", "ITS-TPC Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcazVsPtPionskAnyITSTPC", "ITS-TPC Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcazVsPtKaonskAnyITSTPC", "ITS-TPC Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcazVsPtProtonskAnyITSTPC", "ITS-TPC Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDcaxyVsPtkAnyITSTPC = {
-    {11, new TH2F("hDcaxyVsPtElectronskAnyITSTPC", "ITS-TPC Electrons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {211, new TH2F("hDcaxyVsPtPionskAnyITSTPC", "ITS-TPC Pions;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {321, new TH2F("hDcaxyVsPtKaonskAnyITSTPC", "ITS-TPC Kaons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)},
-    {2212, new TH2F("hDcaxyVsPtProtonskAnyITSTPC", "ITS-TPC Protons;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)", nPtBins - 1, ptLimits, 1000, -500, 500)}};
-  std::map<int, TH2F*> hDeltaPtVsPtAllLayersITSTPC = {
-    {11, new TH2F("hDeltaPtVsPtElectronsAllLayersITSTPC", "ITS-TPC Electrons;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits, 200, -0.2, 0.2)},
-    {211, new TH2F("hDeltaPtVsPtPionsAllLayersITSTPC", "ITS-TPC Pions;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits, 200, -0.2, 0.2)},
-    {321, new TH2F("hDeltaPtVsPtKaonsAllLayersITSTPC", "ITS-TPC Kaons;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits, 200, -0.2, 0.2)},
-    {2212, new TH2F("hDeltaPtVsPtProtonsAllLayersITSTPC", "ITS-TPC Protons;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})", nPtBins - 1, ptLimits, 200, -0.2, 0.2)}};
-
-  o2::dataformats::VertexBase collision;
-  o2::dataformats::DCA impactParameter;
-
-  const auto origWD{fs::current_path()};
-  const auto tfDirs = find_dirs(fs::current_path(), tf_matcher, tf_sorter);
-  for (const auto& tfDir : tfDirs) {
-    LOGP(info, "Analysing {:?}", tfDir.c_str());
-    fs::current_path(tfDir);
-
-    // MC Information
-    o2::steer::MCKinematicsReader mcReader;
-    if (!mcReader.initFromDigitContext(collisioncontextFileName)) {
-      LOGP(error, "Cannot init MC reader in {:?}", tfDir.c_str());
-      continue;
-    }
-
-    // Magnetic field and Propagator
-    float bz{-999};
-    static bool initOnce{false};
-    if (!initOnce) {
-      initOnce = true;
-      o2::base::Propagator::initFieldFromGRP(magFileName);
-      bz = o2::base::Propagator::Instance()->getNominalBz();
-    }
-
-    LOGP(info, "Loading ITS Tracks");
-    auto fITSTracks = TFile::Open(itsTracksFileName.c_str(), "READ");
-    auto tITSTracks = fITSTracks->Get<TTree>("o2sim");
-    std::vector<o2::its::TrackITS>* itsTracks{nullptr};
-    tITSTracks->SetBranchAddress("ITSTrack", &itsTracks);
-    std::vector<o2::MCCompLabel>* itsTrkLab{nullptr};
-    tITSTracks->SetBranchAddress("ITSTrackMCTruth", &itsTrkLab);
-
-    for (Long64_t iEntry{0}; tITSTracks->LoadTree(iEntry) >= 0; ++iEntry) {
-      tITSTracks->GetEntry(iEntry);
-      for (size_t iTrk{0}; iTrk < itsTracks->size(); ++iTrk) {
-        auto trk = itsTracks->at(iTrk);
-        const auto& lbl = itsTrkLab->at(iTrk);
-        if (!lbl.isValid()) {
-          continue;
-        }
-
-        const auto& mcEvent = mcReader.getMCEventHeader(lbl.getSourceID(), lbl.getEventID());
-        const auto& mcTrack = mcReader.getTrack(lbl);
-        if (!mcTrack->isPrimary() || !(std::abs(mcTrack->GetEta()) < rapMax)) {
-          continue;
-        }
-        auto pdg = std::abs(mcTrack->GetPdgCode());
-        if (pdg != 11 && pdg != 211 && pdg != 321 && pdg != 2212) {
-          continue;
-        }
-
-        collision.setXYZ(mcEvent.GetX(), mcEvent.GetY(), mcEvent.GetZ());
-        if (!o2::base::Propagator::Instance()->propagateToDCA(collision, trk, bz, mMaxStep, mMatCorr, &impactParameter)) {
-          continue;
-        }
-
-        auto ptReco = trk.getPt();
-        auto ptGen = mcTrack->GetPt();
-        auto deltaPt = (1. / ptReco - 1. / ptGen) / (1. / ptGen);
-        auto dcaXY = impactParameter.getY() * 10000;
-        auto dcaZ = impactParameter.getZ() * 10000;
-        auto phiReco = trk.getPhi();
-
-        if (trk.getNumberOfClusters() == 7) {
-          hDcaxyVsPtAllLayersITS[pdg]->Fill(ptGen, dcaXY);
-          hDcazVsPtAllLayersITS[pdg]->Fill(ptGen, dcaZ);
-          hDeltaPtVsPtAllLayersITS[pdg]->Fill(ptGen, deltaPt);
-          if (ptGen > 2.) {
-            hDcaxyVsPhiAllLayersITS[pdg]->Fill(phiReco, dcaXY);
-            hDcazVsPhiAllLayersITS[pdg]->Fill(phiReco, dcaZ);
-          }
-        } else if (!trk.hasHitOnLayer(0)) {
-          hDcaxyVsPtNoFirstLayerITS[pdg]->Fill(ptGen, dcaXY);
-          hDcazVsPtNoFirstLayerITS[pdg]->Fill(ptGen, dcaZ);
-        } else {
-          hDcaxyVsPtkAnyITS[pdg]->Fill(ptGen, dcaXY);
-          hDcazVsPtkAnyITS[pdg]->Fill(ptGen, dcaZ);
-        }
-      }
-    }
-
-    LOGP(info, "Loading ITS-TPC Tracks");
-    auto fITSTPCTracks = TFile::Open(itstpcTracksFileName.c_str(), "READ");
-    auto tITSTPCTracks = fITSTPCTracks->Get<TTree>("matchTPCITS");
-    std::vector<o2::dataformats::TrackTPCITS>* itstpcTracks{nullptr};
-    tITSTPCTracks->SetBranchAddress("TPCITS", &itstpcTracks);
-    std::vector<o2::MCCompLabel>* itstpcTrkLab{nullptr};
-    tITSTPCTracks->SetBranchAddress("MatchMCTruth", &itstpcTrkLab);
-    // TPC Tracks
-    auto fTPCTracks = TFile::Open(tpcTracksFileName.c_str(), "READ");
-    auto tTPCTracks = fTPCTracks->Get<TTree>("tpcrec");
-    std::vector<o2::tpc::TrackTPC>* tpcTracks{nullptr};
-    tTPCTracks->SetBranchAddress("TPCTracks", &tpcTracks);
-    std::vector<o2::MCCompLabel>* tpcTrkLab{nullptr};
-    tTPCTracks->SetBranchAddress("TPCTracksMCTruth", &tpcTrkLab);
-    for (Long64_t iEntry{0}; tITSTPCTracks->LoadTree(iEntry) >= 0; ++iEntry) {
-      tITSTPCTracks->GetEntry(iEntry);
-      tITSTracks->GetEntry(iEntry);
-      tTPCTracks->GetEntry(iEntry);
-      for (size_t iTrk{0}; iTrk < itstpcTracks->size(); ++iTrk) {
-        auto trk = itstpcTracks->at(iTrk);
-        const auto& lbl = itstpcTrkLab->at(iTrk);
-
-        const auto& trkITS = itsTracks->at(trk.getRefITS().getIndex());
-        const auto& trkITSLbl = itsTrkLab->at(trk.getRefITS().getIndex());
-        const auto& trkTPC = tpcTracks->at(trk.getRefTPC().getIndex());
-        const auto& trkTPCLbl = tpcTrkLab->at(trk.getRefTPC().getIndex());
-        if (!lbl.isValid() || trkITSLbl != trkTPCLbl) {
-          continue;
-        }
-
-        const auto& mcEvent = mcReader.getMCEventHeader(lbl.getSourceID(), lbl.getEventID());
-        const auto& mcTrack = mcReader.getTrack(lbl);
-        if (!mcTrack->isPrimary() || !(std::abs(mcTrack->GetEta()) < rapMax)) {
-          continue;
-        }
-
-        auto pdg = std::abs(mcTrack->GetPdgCode());
-        if (pdg != 11 && pdg != 211 && pdg != 321 && pdg != 2212) {
-          continue;
-        }
-
-        collision.setXYZ(mcEvent.GetX(), mcEvent.GetY(), mcEvent.GetZ());
-        if (!o2::base::Propagator::Instance()->propagateToDCA(collision, trk, bz, mMaxStep, mMatCorr, &impactParameter)) {
-          continue;
-        }
-
-        auto ptReco = trk.getPt();
-        auto ptGen = mcTrack->GetPt();
-        auto deltaPt = (1. / ptReco - 1. / ptGen) / (1. / ptGen);
-        auto dcaXY = impactParameter.getY() * 10000;
-        auto dcaZ = impactParameter.getZ() * 10000;
-        auto phiReco = trk.getPhi();
-
-        if (trkITS.getNumberOfClusters() == 7) {
-          hDcaxyVsPtAllLayersITSTPC[pdg]->Fill(ptGen, dcaXY);
-          hDcazVsPtAllLayersITSTPC[pdg]->Fill(ptGen, dcaZ);
-          hDeltaPtVsPtAllLayersITSTPC[pdg]->Fill(ptGen, deltaPt);
-          if (ptGen > 2.) {
-            hDcaxyVsPhiAllLayersITSTPC[pdg]->Fill(phiReco, dcaXY);
-            hDcazVsPhiAllLayersITSTPC[pdg]->Fill(phiReco, dcaZ);
-          }
-        } else if (!trkITS.hasHitOnLayer(0) && !trkITS.hasHitOnLayer(1) && !trkITS.hasHitOnLayer(2)) {
-          hDcaxyVsPtNoFirstLayerITSTPC[pdg]->Fill(ptGen, dcaXY);
-          hDcazVsPtNoFirstLayerITSTPC[pdg]->Fill(ptGen, dcaZ);
-        } else {
-          hDcaxyVsPtkAnyITSTPC[pdg]->Fill(ptGen, dcaXY);
-          hDcazVsPtkAnyITSTPC[pdg]->Fill(ptGen, dcaZ);
-        }
-      }
-    }
-
-    delete itsTracks;
-    delete itsTrkLab;
-    delete tpcTracks;
-    delete tpcTrkLab;
-    delete itstpcTracks;
-    delete itstpcTrkLab;
-    delete tITSTracks;
-    delete tTPCTracks;
-    delete tITSTPCTracks;
-    delete fITSTracks;
-    delete fTPCTracks;
-    delete fITSTPCTracks;
-
-    gSystem->GetProcInfo(&procInfo);
-    LOGF(info, "MemVirtual (%ld), MemResident (%ld)", procInfo.fMemVirtual, procInfo.fMemResident);
-    LOGP(info, "Done with {:?}", tfDir.c_str());
-    if (procInfo.fMemResident > 200'000'000) {
-      LOGP(error, "Exceeding 200GBs stopping!");
-      break;
-    }
-  }
-  LOGP(info, "Restoring original CWD to {:?}", origWD.c_str());
-  fs::current_path(origWD); // restore original wd
-
-  LOGP(info, "Projecting Plots");
-  TH1* hProj;
-  const char* fitOpt{"QWMER"};
-  /* const char* fitOpt{"Q"}; */
-  std::map<int, TList*> lProjITS = {
-    {11, new TList()},
-    {211, new TList()},
-    {321, new TList()},
-    {2212, new TList()},
-  };
-  std::map<int, TList*> lProjITSTPC = {
-    {11, new TList()},
-    {211, new TList()},
-    {321, new TList()},
-    {2212, new TList()},
-  };
-  for (const auto& pdgCode : pdgCodes) {
-    for (auto iPt{0}; iPt < nPtBins; ++iPt) {
-      // ITS
-      auto ptMin = hDcaxyVsPtAllLayersITS[pdgCode]->GetXaxis()->GetBinLowEdge(iPt + 1);
-      float minFit = (ptMin < 1.) ? -200. : -50.;
-      float maxFit = (ptMin < 1.) ? 200. : 50.;
-
-      hProj = hDeltaPtVsPtAllLayersITS[pdgCode]->ProjectionY(Form("hProjDeltaPtAll%d__%dITS", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt);
-      lProjITS[pdgCode]->Add(hProj);
-      hPtResAllLayersITS[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hPtResAllLayersITS[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcaxyVsPtAllLayersITS[pdgCode]->ProjectionY(Form("hProjDcaxyAll%d__%dITS", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITS[pdgCode]->Add(hProj);
-      hDcaxyResAllLayersITS[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcaxyResAllLayersITS[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcazVsPtAllLayersITS[pdgCode]->ProjectionY(Form("hProjDcazAll%d__%dITS", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITS[pdgCode]->Add(hProj);
-      hDcazResAllLayersITS[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcazResAllLayersITS[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcaxyVsPtNoFirstLayerITS[pdgCode]->ProjectionY(Form("hProjDcaxyNoFirst%d__%dITS", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITS[pdgCode]->Add(hProj);
-      hDcaxyResNoFirstLayerITS[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcaxyResNoFirstLayerITS[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcazVsPtNoFirstLayerITS[pdgCode]->ProjectionY(Form("hProjDcazNoFirst%d__%dITS", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITS[pdgCode]->Add(hProj);
-      hDcazResNoFirstLayerITS[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcazResNoFirstLayerITS[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcaxyVsPtkAnyITS[pdgCode]->ProjectionY(Form("hProjDcaxyAny%d__%dITS", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITS[pdgCode]->Add(hProj);
-      hDcaxyReskAnyITS[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcaxyReskAnyITS[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcazVsPtkAnyITS[pdgCode]->ProjectionY(Form("hProjDcazAny%d__%dITS", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITS[pdgCode]->Add(hProj);
-      hDcazReskAnyITS[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcazReskAnyITS[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      // ITS-TPC
-      hProj = hDeltaPtVsPtAllLayersITSTPC[pdgCode]->ProjectionY(Form("hProjDeltaPtAll%d__%dITSTPC", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt);
-      lProjITSTPC[pdgCode]->Add(hProj);
-      hPtResAllLayersITSTPC[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hPtResAllLayersITSTPC[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      ptMin = hDcaxyVsPtAllLayersITSTPC[pdgCode]->GetXaxis()->GetBinLowEdge(iPt + 1);
-      minFit = (ptMin < 1.) ? -200. : -50.;
-      maxFit = (ptMin < 1.) ? 200. : 50.;
-
-      hProj = hDcaxyVsPtAllLayersITSTPC[pdgCode]->ProjectionY(Form("hProjDcaxyAll%d__%dITSTPC", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITSTPC[pdgCode]->Add(hProj);
-      hDcaxyResAllLayersITSTPC[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcaxyResAllLayersITSTPC[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcazVsPtAllLayersITSTPC[pdgCode]->ProjectionY(Form("hProjDcazAll%d__%dITSTPC", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITSTPC[pdgCode]->Add(hProj);
-      hDcazResAllLayersITSTPC[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcazResAllLayersITSTPC[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcaxyVsPtNoFirstLayerITSTPC[pdgCode]->ProjectionY(Form("hProjDcaxyNoFirst%d__%dITSTPC", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITSTPC[pdgCode]->Add(hProj);
-      hDcaxyResNoFirstLayerITSTPC[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcaxyResNoFirstLayerITSTPC[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcazVsPtNoFirstLayerITSTPC[pdgCode]->ProjectionY(Form("hProjDcazNoFirst%d__%dITSTPC", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITSTPC[pdgCode]->Add(hProj);
-      hDcazResNoFirstLayerITSTPC[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcazResNoFirstLayerITSTPC[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcaxyVsPtkAnyITSTPC[pdgCode]->ProjectionY(Form("hProjDcaxAnty%d__%dITSTPC", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITSTPC[pdgCode]->Add(hProj);
-      hDcaxyReskAnyITSTPC[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcaxyReskAnyITSTPC[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-
-      hProj = hDcazVsPtkAnyITSTPC[pdgCode]->ProjectionY(Form("hProjDcazAny%d__%dITSTPC", pdgCode, iPt), iPt + 1, iPt + 1);
-      hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
-      lProjITSTPC[pdgCode]->Add(hProj);
-      hDcazReskAnyITSTPC[pdgCode]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
-      hDcazReskAnyITSTPC[pdgCode]->SetBinError(iPt + 1, fGaus->GetParError(2));
-    }
-  }
-
-  // Style
-  LOGP(info, "Styling Plots");
-  for (const auto& pdgCode : pdgCodes) {
-    // ITS
-    hPtResAllLayersITS[pdgCode]->SetLineWidth(2);
-    hPtResAllLayersITS[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hPtResAllLayersITS[pdgCode]->SetLineColor(colors[pdgCode]);
-    hPtResAllLayersITS[pdgCode]->SetMarkerStyle(kFullCircle);
-
-    hDcaxyResAllLayersITS[pdgCode]->SetLineWidth(2);
-    hDcaxyResAllLayersITS[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcaxyResAllLayersITS[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcaxyResAllLayersITS[pdgCode]->SetMarkerStyle(kFullCircle);
-
-    hDcazResAllLayersITS[pdgCode]->SetLineWidth(2);
-    hDcazResAllLayersITS[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcazResAllLayersITS[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcazResAllLayersITS[pdgCode]->SetMarkerStyle(kFullCircle);
-
-    hDcaxyResNoFirstLayerITS[pdgCode]->SetLineWidth(2);
-    hDcaxyResNoFirstLayerITS[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcaxyResNoFirstLayerITS[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcaxyResNoFirstLayerITS[pdgCode]->SetMarkerStyle(kFullCircle);
-
-    hDcazResNoFirstLayerITS[pdgCode]->SetLineWidth(2);
-    hDcazResNoFirstLayerITS[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcazResNoFirstLayerITS[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcazResNoFirstLayerITS[pdgCode]->SetMarkerStyle(kFullCircle);
-
-    hDcaxyReskAnyITS[pdgCode]->SetLineWidth(2);
-    hDcaxyReskAnyITS[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcaxyReskAnyITS[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcaxyReskAnyITS[pdgCode]->SetMarkerStyle(kFullCircle);
-
-    hDcazReskAnyITS[pdgCode]->SetLineWidth(2);
-    hDcazReskAnyITS[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcazReskAnyITS[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcazReskAnyITS[pdgCode]->SetMarkerStyle(kFullCircle);
-
-    // ITS-TPC
-    hPtResAllLayersITSTPC[pdgCode]->SetLineWidth(2);
-    hPtResAllLayersITSTPC[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hPtResAllLayersITSTPC[pdgCode]->SetLineColor(colors[pdgCode]);
-    hPtResAllLayersITSTPC[pdgCode]->SetMarkerStyle(kOpenCircle);
-
-    hDcaxyResAllLayersITSTPC[pdgCode]->SetLineWidth(2);
-    hDcaxyResAllLayersITSTPC[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcaxyResAllLayersITSTPC[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcaxyResAllLayersITSTPC[pdgCode]->SetMarkerStyle(kOpenCircle);
-
-    hDcazResAllLayersITSTPC[pdgCode]->SetLineWidth(2);
-    hDcazResAllLayersITSTPC[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcazResAllLayersITSTPC[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcazResAllLayersITSTPC[pdgCode]->SetMarkerStyle(kOpenCircle);
-
-    hDcaxyResNoFirstLayerITSTPC[pdgCode]->SetLineWidth(2);
-    hDcaxyResNoFirstLayerITSTPC[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcaxyResNoFirstLayerITSTPC[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcaxyResNoFirstLayerITSTPC[pdgCode]->SetMarkerStyle(kOpenCircle);
-
-    hDcazResNoFirstLayerITSTPC[pdgCode]->SetLineWidth(2);
-    hDcazResNoFirstLayerITSTPC[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcazResNoFirstLayerITSTPC[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcazResNoFirstLayerITSTPC[pdgCode]->SetMarkerStyle(kOpenCircle);
-
-    hDcaxyReskAnyITSTPC[pdgCode]->SetLineWidth(2);
-    hDcaxyReskAnyITSTPC[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcaxyReskAnyITSTPC[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcaxyReskAnyITSTPC[pdgCode]->SetMarkerStyle(kOpenCircle);
-
-    hDcazReskAnyITSTPC[pdgCode]->SetLineWidth(2);
-    hDcazReskAnyITSTPC[pdgCode]->SetMarkerColor(colors[pdgCode]);
-    hDcazReskAnyITSTPC[pdgCode]->SetLineColor(colors[pdgCode]);
-    hDcazReskAnyITSTPC[pdgCode]->SetMarkerStyle(kOpenCircle);
-  }
-
-  /// Output
-  LOGP(info, "Writing final output");
-  // ITS
-  auto canvPtDeltaITS = new TCanvas("canvPtDeltaITS", "", 1500, 500);
-  canvPtDeltaITS->Divide(nSpecies, 1);
-  canvPtDeltaITS->cd(1)->SetLogz();
-  hDeltaPtVsPtAllLayersITS[11]->Draw("colz");
-  canvPtDeltaITS->cd(2)->SetLogz();
-  hDeltaPtVsPtAllLayersITS[211]->Draw("colz");
-  canvPtDeltaITS->cd(3)->SetLogz();
-  hDeltaPtVsPtAllLayersITS[321]->Draw("colz");
-  canvPtDeltaITS->cd(4)->SetLogz();
-  hDeltaPtVsPtAllLayersITS[2212]->Draw("colz");
-
-  auto canvDcaVsPtITS = new TCanvas("canvDcaVsPtITS", "", 1500, 1000);
-  canvDcaVsPtITS->Divide(nSpecies, 2);
-  canvDcaVsPtITS->cd(1)->SetLogz();
-  hDcaxyVsPtAllLayersITS[11]->Draw("colz");
-  canvDcaVsPtITS->cd(2)->SetLogz();
-  hDcaxyVsPtAllLayersITS[211]->Draw("colz");
-  canvDcaVsPtITS->cd(3)->SetLogz();
-  hDcaxyVsPtAllLayersITS[321]->Draw("colz");
-  canvDcaVsPtITS->cd(4)->SetLogz();
-  hDcaxyVsPtAllLayersITS[2212]->Draw("colz");
-  canvDcaVsPtITS->cd(5)->SetLogz();
-  hDcazVsPtAllLayersITS[11]->Draw("colz");
-  canvDcaVsPtITS->cd(6)->SetLogz();
-  hDcazVsPtAllLayersITS[211]->Draw("colz");
-  canvDcaVsPtITS->cd(7)->SetLogz();
-  hDcazVsPtAllLayersITS[321]->Draw("colz");
-  canvDcaVsPtITS->cd(8)->SetLogz();
-  hDcazVsPtAllLayersITS[2212]->Draw("colz");
-
-  auto canvPtResITS = new TCanvas("canvPtResITS", "", 500, 500);
-  canvPtResITS->DrawFrame(ptLimits[0], 0., ptLimits[nPtBins - 1], 0.2, "ITS;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})");
-  for (const auto& pdgCode : pdgCodes) {
-    hPtResAllLayersITS[pdgCode]->Draw("same");
-  }
-
-  auto canvDcaxyResITS = new TCanvas("canvDcaxyResITS", "", 500, 500);
-  canvDcaxyResITS->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)");
-  canvDcaxyResITS->SetLogx();
-  canvDcaxyResITS->SetLogy();
-  canvDcaxyResITS->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcaxyResAllLayersITS[pdgCode]->Draw("same");
-  }
-
-  auto canvDcazResITS = new TCanvas("canvDcazResITS", "", 500, 500);
-  canvDcazResITS->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)");
-  canvDcazResITS->SetLogx();
-  canvDcazResITS->SetLogy();
-  canvDcazResITS->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcazResAllLayersITS[pdgCode]->Draw("same");
-  }
-
-  auto canvDcaxyResNoFirstLayerITS = new TCanvas("canvDcaxyResNoFirstLayerITS", "", 500, 500);
-  canvDcaxyResNoFirstLayerITS->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)");
-  canvDcaxyResNoFirstLayerITS->SetLogx();
-  canvDcaxyResNoFirstLayerITS->SetLogy();
-  canvDcaxyResNoFirstLayerITS->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcaxyResNoFirstLayerITS[pdgCode]->Draw("same");
-  }
-
-  auto canvDcazResNoFirstLayerITS = new TCanvas("canvDcazResNoFirstLayerITS", "", 500, 500);
-  canvDcazResNoFirstLayerITS->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)");
-  canvDcazResNoFirstLayerITS->SetLogx();
-  canvDcazResNoFirstLayerITS->SetLogy();
-  canvDcazResNoFirstLayerITS->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcazResNoFirstLayerITS[pdgCode]->Draw("same");
-  }
-
-  auto canvDcaxyReskAnyITS = new TCanvas("canvDcaxyReskAnyITS", "", 500, 500);
-  canvDcaxyReskAnyITS->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)");
-  canvDcaxyReskAnyITS->SetLogx();
-  canvDcaxyReskAnyITS->SetLogy();
-  canvDcaxyReskAnyITS->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcaxyReskAnyITS[pdgCode]->Draw("same");
-  }
-
-  auto canvDcazReskAnyITS = new TCanvas("canvDcazReskAnyITS", "", 500, 500);
-  canvDcazReskAnyITS->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)");
-  canvDcazReskAnyITS->SetLogx();
-  canvDcazReskAnyITS->SetLogy();
-  canvDcazReskAnyITS->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcazReskAnyITS[pdgCode]->Draw("same");
-  }
-
-  // ITS-TPC
-  auto canvPtDeltaITSTPC = new TCanvas("canvPtDeltaITSTPC", "", 1500, 500);
-  canvPtDeltaITSTPC->Divide(nSpecies, 1);
-  canvPtDeltaITSTPC->cd(1)->SetLogz();
-  hDeltaPtVsPtAllLayersITSTPC[11]->Draw("colz");
-  canvPtDeltaITSTPC->cd(2)->SetLogz();
-  hDeltaPtVsPtAllLayersITSTPC[211]->Draw("colz");
-  canvPtDeltaITSTPC->cd(3)->SetLogz();
-  hDeltaPtVsPtAllLayersITSTPC[321]->Draw("colz");
-  canvPtDeltaITSTPC->cd(4)->SetLogz();
-  hDeltaPtVsPtAllLayersITSTPC[2212]->Draw("colz");
-
-  auto canvDcaVsPtITSTPC = new TCanvas("canvDcaVsPtITSTPC", "", 1500, 1000);
-  canvDcaVsPtITSTPC->Divide(nSpecies, 2);
-  canvDcaVsPtITSTPC->cd(1)->SetLogz();
-  hDcaxyVsPtAllLayersITSTPC[11]->Draw("colz");
-  canvDcaVsPtITSTPC->cd(2)->SetLogz();
-  hDcaxyVsPtAllLayersITSTPC[211]->Draw("colz");
-  canvDcaVsPtITSTPC->cd(3)->SetLogz();
-  hDcaxyVsPtAllLayersITSTPC[321]->Draw("colz");
-  canvDcaVsPtITSTPC->cd(4)->SetLogz();
-  hDcaxyVsPtAllLayersITSTPC[2212]->Draw("colz");
-  canvDcaVsPtITSTPC->cd(5)->SetLogz();
-  hDcazVsPtAllLayersITSTPC[11]->Draw("colz");
-  canvDcaVsPtITSTPC->cd(6)->SetLogz();
-  hDcazVsPtAllLayersITSTPC[211]->Draw("colz");
-  canvDcaVsPtITSTPC->cd(7)->SetLogz();
-  hDcazVsPtAllLayersITSTPC[321]->Draw("colz");
-  canvDcaVsPtITSTPC->cd(8)->SetLogz();
-  hDcazVsPtAllLayersITSTPC[2212]->Draw("colz");
-
-  auto canvPtResITSTPC = new TCanvas("canvPtResITSTPC", "", 500, 500);
-  canvPtResITSTPC->DrawFrame(ptLimits[0], 0., ptLimits[nPtBins - 1], 0.2, "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})");
-  for (const auto& pdgCode : pdgCodes) {
-    hPtResAllLayersITSTPC[pdgCode]->Draw("same");
-  }
-
-  auto canvDcaxyResITSTPC = new TCanvas("canvDcaxyResITSTPC", "", 500, 500);
-  canvDcaxyResITSTPC->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)");
-  canvDcaxyResITSTPC->SetLogx();
-  canvDcaxyResITSTPC->SetLogy();
-  canvDcaxyResITSTPC->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcaxyResAllLayersITSTPC[pdgCode]->Draw("same");
-  }
-
-  auto canvDcazResITSTPC = new TCanvas("canvDcazResITSTPC", "", 500, 500);
-  canvDcazResITSTPC->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)");
-  canvDcazResITSTPC->SetLogx();
-  canvDcazResITSTPC->SetLogy();
-  canvDcazResITSTPC->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcazResAllLayersITSTPC[pdgCode]->Draw("same");
-  }
-
-  auto canvDcaxyResNoFirstLayerITSTPC = new TCanvas("canvDcaxyResNoFirstLayerITSTPC", "", 500, 500);
-  canvDcaxyResNoFirstLayerITSTPC->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)");
-  canvDcaxyResNoFirstLayerITSTPC->SetLogx();
-  canvDcaxyResNoFirstLayerITSTPC->SetLogy();
-  canvDcaxyResNoFirstLayerITSTPC->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcaxyResNoFirstLayerITSTPC[pdgCode]->Draw("same");
-  }
-
-  auto canvDcazResNoFirstLayerITSTPC = new TCanvas("canvDcazResNoFirstLayerITSTPC", "", 500, 500);
-  canvDcazResNoFirstLayerITSTPC->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)");
-  canvDcazResNoFirstLayerITSTPC->SetLogx();
-  canvDcazResNoFirstLayerITSTPC->SetLogy();
-  canvDcazResNoFirstLayerITSTPC->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcazResNoFirstLayerITSTPC[pdgCode]->Draw("same");
-  }
-
-  auto canvDcaxyReskAnyITSTPC = new TCanvas("canvDcaxyReskAnyITSTPC", "", 500, 500);
-  canvDcaxyReskAnyITSTPC->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)");
-  canvDcaxyReskAnyITSTPC->SetLogx();
-  canvDcaxyReskAnyITSTPC->SetLogy();
-  canvDcaxyReskAnyITSTPC->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcaxyReskAnyITSTPC[pdgCode]->Draw("same");
-  }
-
-  auto canvDcazReskAnyITSTPC = new TCanvas("canvDcazReskAnyITSTPC", "", 500, 500);
-  canvDcazReskAnyITSTPC->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS-TPC;#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)");
-  canvDcazReskAnyITSTPC->SetLogx();
-  canvDcazReskAnyITSTPC->SetLogy();
-  canvDcazReskAnyITSTPC->SetGrid();
-  for (const auto& pdgCode : pdgCodes) {
-    hDcazReskAnyITSTPC[pdgCode]->Draw("same");
-  }
-
-  // Compare ITS-TPC resolution;
-  auto canvDcaxyResComp = new TCanvas("canvDcaxyResAllLayersComp", "", 500, 500);
-  canvDcaxyResComp->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS vs. ITS-TPC (all layers);#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum)");
-  canvDcaxyResComp->SetLogx();
-  canvDcaxyResComp->SetLogy();
-  canvDcaxyResComp->SetGrid();
-  hDcaxyResAllLayersITS[211]->Draw("same");
-  hDcaxyResAllLayersITSTPC[211]->Draw("same");
-  gPad->BuildLegend(0.8, 0.8, 0.94, 0.94);
-
-  auto canvDcazResComp = new TCanvas("canvDcazResAllLayersComp", "", 500, 500);
-  canvDcazResComp->DrawFrame(ptLimits[0], 1., ptLimits[nPtBins - 1], 1.e3, "ITS vs. ITS-TPC (all layers);#it{p}_{T} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum)");
-  canvDcazResComp->SetLogx();
-  canvDcazResComp->SetLogy();
-  canvDcazResComp->SetGrid();
-  hDcazResAllLayersITS[211]->Draw("same");
-  hDcazResAllLayersITSTPC[211]->Draw("same");
-  gPad->BuildLegend(0.8, 0.8, 0.94, 0.94);
-
-  auto canvPtResComp = new TCanvas("canvPtResAllLayersComp", "", 500, 500);
-  canvPtResComp->DrawFrame(ptLimits[0], 0., ptLimits[nPtBins - 1], 0.2, "ITS vs. ITS-TPC (all layers);#it{p}_{T} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T})");
-  canvPtResComp->SetLogx();
-  canvPtResComp->SetGrid();
-  hPtResAllLayersITS[211]->Draw("same");
-  hPtResAllLayersITSTPC[211]->Draw("same");
-  gPad->BuildLegend(0.8, 0.8, 0.94, 0.94);
-
-  auto canvDcaPtComp = new TCanvas("canvDcaPtAllLayersComp", "", 500, 500);
-  canvDcaPtComp->Divide(2, 2);
-  canvDcaPtComp->cd(1);
-  hDcaxyVsPtAllLayersITS[211]->Draw();
-  canvDcaPtComp->cd(2);
-  hDcazVsPtAllLayersITS[211]->Draw();
-  canvDcaPtComp->cd(3);
-  hDcaxyVsPtAllLayersITSTPC[211]->Draw();
-  canvDcaPtComp->cd(4);
-  hDcazVsPtAllLayersITSTPC[211]->Draw();
-
-  auto canvDcaPhiComp = new TCanvas("canvDcaPhiAllLayersComp", "", 500, 500);
-  canvDcaPhiComp->Divide(2, 2);
-  canvDcaPhiComp->cd(1);
-  hDcaxyVsPhiAllLayersITS[211]->Draw();
-  canvDcaPhiComp->cd(2);
-  hDcazVsPhiAllLayersITS[211]->Draw();
-  canvDcaPhiComp->cd(3);
-  hDcaxyVsPhiAllLayersITSTPC[211]->Draw();
-  canvDcaPhiComp->cd(4);
-  hDcazVsPhiAllLayersITSTPC[211]->Draw();
-
-  // Write
-  TFile outFile("checkDCA.root", "RECREATE");
-  outFile.mkdir("ITS");
-  outFile.cd("ITS");
-  gDirectory->WriteTObject(canvPtResITS);
-  gDirectory->WriteTObject(canvDcaxyResITS);
-  gDirectory->WriteTObject(canvDcazResITS);
-  gDirectory->WriteTObject(canvDcazResNoFirstLayerITS);
-  gDirectory->WriteTObject(canvDcaxyResNoFirstLayerITS);
-  gDirectory->WriteTObject(canvDcaxyReskAnyITS);
-  gDirectory->WriteTObject(canvDcazReskAnyITS);
-  gDirectory->WriteTObject(canvPtDeltaITS);
-  gDirectory->WriteTObject(canvDcaVsPtITS);
-
-  outFile.mkdir("ITS-TPC");
-  outFile.cd("ITS-TPC");
-  gDirectory->WriteTObject(canvPtResITSTPC);
-  gDirectory->WriteTObject(canvDcaxyResITSTPC);
-  gDirectory->WriteTObject(canvDcazResITSTPC);
-  gDirectory->WriteTObject(canvDcazResNoFirstLayerITSTPC);
-  gDirectory->WriteTObject(canvDcaxyResNoFirstLayerITSTPC);
-  gDirectory->WriteTObject(canvDcaxyReskAnyITSTPC);
-  gDirectory->WriteTObject(canvDcazReskAnyITSTPC);
-  gDirectory->WriteTObject(canvPtDeltaITSTPC);
-  gDirectory->WriteTObject(canvDcaVsPtITSTPC);
-
-  outFile.mkdir("Compare");
-  outFile.cd("Compare");
-  gDirectory->WriteTObject(canvDcaxyResComp);
-  gDirectory->WriteTObject(canvDcazResComp);
-  gDirectory->WriteTObject(canvPtResComp);
-  gDirectory->WriteTObject(canvDcaPtComp);
-  gDirectory->WriteTObject(canvDcaPhiComp);
-
-  for (const auto& pdgCode : pdgCodes) {
-    const char* dirName = partNames[pdgCode].c_str();
-    auto dir = outFile.mkdir(dirName);
-    outFile.cd(dirName);
-
-    gDirectory->mkdir("ITS");
-    gDirectory->cd("ITS");
-    gDirectory->WriteTObject(hDeltaPtVsPtAllLayersITS[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyVsPtAllLayersITS[pdgCode]);
-    gDirectory->WriteTObject(hDcazVsPtAllLayersITS[pdgCode]);
-    gDirectory->WriteTObject(hDcazResAllLayersITS[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyResAllLayersITS[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyVsPtNoFirstLayerITS[pdgCode]);
-    gDirectory->WriteTObject(hDcazVsPtNoFirstLayerITS[pdgCode]);
-    gDirectory->WriteTObject(hDcazResNoFirstLayerITS[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyResNoFirstLayerITS[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyVsPhiAllLayersITS[pdgCode]);
-    gDirectory->WriteTObject(hDcazVsPhiAllLayersITS[pdgCode]);
-    gDirectory->mkdir("projections");
-    gDirectory->cd("projections");
-    for (TObject* obj : *lProjITS[pdgCode]) {
-      obj->Write();
-    }
-
-    dir->cd();
-    gDirectory->mkdir("ITS-TPC");
-    gDirectory->cd("ITS-TPC");
-    gDirectory->WriteTObject(hDeltaPtVsPtAllLayersITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyVsPtAllLayersITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcazVsPtAllLayersITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcazResAllLayersITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyResAllLayersITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyVsPtNoFirstLayerITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcazVsPtNoFirstLayerITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcazResNoFirstLayerITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyResNoFirstLayerITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcaxyVsPhiAllLayersITSTPC[pdgCode]);
-    gDirectory->WriteTObject(hDcazVsPhiAllLayersITSTPC[pdgCode]);
-    gDirectory->mkdir("projections");
-    gDirectory->cd("projections");
-    for (TObject* obj : *lProjITSTPC[pdgCode]) {
-      obj->Write();
-    }
-  }
-}
diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C b/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
index 240b1bd344af5..82578cc406f0c 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckDigitsITS3.C
@@ -40,7 +40,7 @@
 #include "fairlogger/Logger.h"
 #endif
 
-void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfile = "o2sim_HitsIT3.root", std::string inputGeom = "", bool batch = false)
+void CheckDigitsITS3(bool readFromFile = false, std::string digifile = "it3digits.root", std::string hitfile = "o2sim_HitsIT3.root", std::string inputGeom = "", bool batch = false)
 {
   gROOT->SetBatch(batch);
   gStyle->SetPalette(kRainBow);
@@ -53,176 +53,211 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
   using o2::itsmft::SegmentationAlpide;
   std::array<its3::SegmentationMosaix, 3> mMosaixSegmentations{0, 1, 2};
 
-  TFile* f = TFile::Open("CheckDigits.root", "recreate");
-  TNtuple* nt = new TNtuple("ntd", "digit ntuple", "id:x:y:z:rowD:colD:rowH:colH:xlH:zlH:xlcH:zlcH:dx:dz");
+  TFile* f{nullptr};
+  TNtuple* nt{nullptr};
+  if (!readFromFile) {
+    f = TFile::Open("CheckDigits.root", "recreate");
+    nt = new TNtuple("ntd", "digit ntuple", "id:x:y:z:rowD:colD:rowH:colH:xlH:zlH:xlcH:zlcH:dx:dz:etaH");
 
-  // Geometry
-  o2::base::GeometryManager::loadGeometry(inputGeom);
-  auto* gman = o2::its::GeometryTGeo::Instance();
-  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+    // Geometry
+    o2::base::GeometryManager::loadGeometry(inputGeom);
+    auto* gman = o2::its::GeometryTGeo::Instance();
+    gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
 
-  // Hits
-  TFile* hitFile = TFile::Open(hitfile.data());
-  TTree* hitTree = (TTree*)hitFile->Get("o2sim");
-  int nevH = hitTree->GetEntries(); // hits are stored as one event per entry
-  std::vector<std::vector<o2::itsmft::Hit>*> hitArray(nevH, nullptr);
-  std::vector<std::unordered_map<uint64_t, int>> mc2hitVec(nevH);
+    // Hits
+    TFile* hitFile = TFile::Open(hitfile.data());
+    TTree* hitTree = (TTree*)hitFile->Get("o2sim");
+    int nevH = hitTree->GetEntries(); // hits are stored as one event per entry
+    std::vector<std::vector<o2::itsmft::Hit>*> hitArray(nevH, nullptr);
+    std::vector<std::unordered_map<uint64_t, int>> mc2hitVec(nevH);
 
-  // Digits
-  TFile* digFile = TFile::Open(digifile.data());
-  TTree* digTree = (TTree*)digFile->Get("o2sim");
+    // Digits
+    TFile* digFile = TFile::Open(digifile.data());
+    TTree* digTree = (TTree*)digFile->Get("o2sim");
 
-  std::vector<o2::itsmft::Digit>* digArr = nullptr;
-  digTree->SetBranchAddress("IT3Digit", &digArr);
+    std::vector<o2::itsmft::Digit>* digArr = nullptr;
+    digTree->SetBranchAddress("IT3Digit", &digArr);
 
-  o2::dataformats::IOMCTruthContainerView* plabels = nullptr;
-  digTree->SetBranchAddress("IT3DigitMCTruth", &plabels);
+    o2::dataformats::IOMCTruthContainerView* plabels = nullptr;
+    digTree->SetBranchAddress("IT3DigitMCTruth", &plabels);
 
-  int nevD = digTree->GetEntries(); // digits in cont. readout may be grouped as few events per entry
+    int nevD = digTree->GetEntries(); // digits in cont. readout may be grouped as few events per entry
 
-  int nDigitReadIB{0}, nDigitReadOB{0};
-  int nDigitFilledIB{0}, nDigitFilledOB{0};
+    int nDigitReadIB{0}, nDigitReadOB{0};
+    int nDigitFilledIB{0}, nDigitFilledOB{0};
 
-  // Get Read Out Frame arrays
-  std::vector<o2::itsmft::ROFRecord>* ROFRecordArrray = nullptr;
-  digTree->SetBranchAddress("IT3DigitROF", &ROFRecordArrray);
-  std::vector<o2::itsmft::ROFRecord>& ROFRecordArrrayRef = *ROFRecordArrray;
+    // Get Read Out Frame arrays
+    std::vector<o2::itsmft::ROFRecord>* ROFRecordArrray = nullptr;
+    digTree->SetBranchAddress("IT3DigitROF", &ROFRecordArrray);
+    std::vector<o2::itsmft::ROFRecord>& ROFRecordArrrayRef = *ROFRecordArrray;
 
-  std::vector<o2::itsmft::MC2ROFRecord>* MC2ROFRecordArrray = nullptr;
-  digTree->SetBranchAddress("IT3DigitMC2ROF", &MC2ROFRecordArrray);
-  std::vector<o2::itsmft::MC2ROFRecord>& MC2ROFRecordArrrayRef = *MC2ROFRecordArrray;
+    std::vector<o2::itsmft::MC2ROFRecord>* MC2ROFRecordArrray = nullptr;
+    digTree->SetBranchAddress("IT3DigitMC2ROF", &MC2ROFRecordArrray);
+    std::vector<o2::itsmft::MC2ROFRecord>& MC2ROFRecordArrrayRef = *MC2ROFRecordArrray;
 
-  digTree->GetEntry(0);
+    digTree->GetEntry(0);
 
-  int nROFRec = (int)ROFRecordArrrayRef.size();
-  std::vector<int> mcEvMin(nROFRec, hitTree->GetEntries());
-  std::vector<int> mcEvMax(nROFRec, -1);
-  o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel> labels;
-  plabels->copyandflatten(labels);
-  delete plabels;
+    int nROFRec = (int)ROFRecordArrrayRef.size();
+    std::vector<int> mcEvMin(nROFRec, hitTree->GetEntries());
+    std::vector<int> mcEvMax(nROFRec, -1);
+    o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel> labels;
+    plabels->copyandflatten(labels);
+    delete plabels;
 
-  LOGP(debug, "Build min and max MC events used by each ROF");
-  for (int imc = MC2ROFRecordArrrayRef.size(); imc--;) {
-    const auto& mc2rof = MC2ROFRecordArrrayRef[imc];
-    /* LOGP(debug, "MCRecord: {}", mc2rof.asString()); */
+    LOGP(debug, "Build min and max MC events used by each ROF");
+    for (int imc = MC2ROFRecordArrrayRef.size(); imc--;) {
+      const auto& mc2rof = MC2ROFRecordArrrayRef[imc];
+      /* LOGP(debug, "MCRecord: {}", mc2rof.asString()); */
 
-    if (mc2rof.rofRecordID < 0) {
-      continue; // this MC event did not contribute to any ROF
-    }
+      if (mc2rof.rofRecordID < 0) {
+        continue; // this MC event did not contribute to any ROF
+      }
 
-    for (int irfd = mc2rof.maxROF - mc2rof.minROF + 1; irfd--;) {
+      for (int irfd = mc2rof.maxROF - mc2rof.minROF + 1; irfd--;) {
 
-      int irof = mc2rof.rofRecordID + irfd;
+        int irof = mc2rof.rofRecordID + irfd;
 
-      if (irof >= nROFRec) {
-        LOGP(error, "ROF={} from MC2ROF record is >= N ROFs={}", irof, nROFRec);
-      }
-      if (mcEvMin[irof] > imc) {
-        mcEvMin[irof] = imc;
-      }
-      if (mcEvMax[irof] < imc) {
-        mcEvMax[irof] = imc;
+        if (irof >= nROFRec) {
+          LOGP(error, "ROF={} from MC2ROF record is >= N ROFs={}", irof, nROFRec);
+        }
+        if (mcEvMin[irof] > imc) {
+          mcEvMin[irof] = imc;
+        }
+        if (mcEvMax[irof] < imc) {
+          mcEvMax[irof] = imc;
+        }
       }
     }
-  }
 
-  LOGP(debug, "LOOP on: ROFRecord array");
-  unsigned int rofIndex = 0;
-  unsigned int rofNEntries = 0;
-  for (unsigned int iROF = 0; iROF < ROFRecordArrrayRef.size(); iROF++) {
+    LOGP(debug, "LOOP on: ROFRecord array");
+    unsigned int rofIndex = 0;
+    unsigned int rofNEntries = 0;
+    for (unsigned int iROF = 0; iROF < ROFRecordArrrayRef.size(); iROF++) {
 
-    rofIndex = ROFRecordArrrayRef[iROF].getFirstEntry();
-    rofNEntries = ROFRecordArrrayRef[iROF].getNEntries();
+      rofIndex = ROFRecordArrrayRef[iROF].getFirstEntry();
+      rofNEntries = ROFRecordArrrayRef[iROF].getNEntries();
 
-    // >> read and map MC events contributing to this ROF
-    for (int im = mcEvMin[iROF]; im <= mcEvMax[iROF]; im++) {
+      // >> read and map MC events contributing to this ROF
+      for (int im = mcEvMin[iROF]; im <= mcEvMax[iROF]; im++) {
 
-      if (hitArray[im] == nullptr) {
+        if (hitArray[im] == nullptr) {
 
-        hitTree->SetBranchAddress("IT3Hit", &hitArray[im]);
-        hitTree->GetEntry(im);
+          hitTree->SetBranchAddress("IT3Hit", &hitArray[im]);
+          hitTree->GetEntry(im);
 
-        auto& mc2hit = mc2hitVec[im];
+          auto& mc2hit = mc2hitVec[im];
 
-        for (size_t ih = hitArray[im]->size(); ih--;) {
-          const auto& hit = (*hitArray[im])[ih];
-          uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
-          mc2hit.emplace(key, ih);
+          for (size_t ih = hitArray[im]->size(); ih--;) {
+            const auto& hit = (*hitArray[im])[ih];
+            uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
+            mc2hit.emplace(key, ih);
+          }
         }
       }
-    }
-
-    LOGP(debug, "  `-> LOOP on: Digits array(size={}) starting at ROFIndex={} to {}", digArr->size(), rofIndex, rofIndex + rofNEntries);
-    for (unsigned int iDigit = rofIndex; iDigit < rofIndex + rofNEntries; iDigit++) {
-      int ix = (*digArr)[iDigit].getRow(), iz = (*digArr)[iDigit].getColumn();
-      auto chipID = (*digArr)[iDigit].getChipIndex();
-      auto layer = its3::constants::detID::getDetID2Layer(chipID);
-      bool isIB{its3::constants::detID::isDetITS3(chipID)};
-      float x{0.f}, y{0.f}, z{0.f};
-      (isIB) ? ++nDigitReadIB : ++nDigitReadOB;
-
-      if (isIB) {
-        // ITS3 IB
-        float xFlat{0.f}, yFlat{0.f};
-        mMosaixSegmentations[layer].detectorToLocal(ix, iz, xFlat, z);
-        mMosaixSegmentations[layer].flatToCurved(xFlat, 0., x, y);
-      } else {
-        // ITS2 OB
-        SegmentationAlpide::detectorToLocal(ix, iz, x, z);
-      }
 
-      o2::math_utils::Point3D<double> locD(x, y, z);
-      auto lab = (labels.getLabels(iDigit))[0];
-      int trID = lab.getTrackID();
-      if (!lab.isValid()) { // not noise
-        continue;
-      }
-
-      // get MC info
-      uint64_t key = (uint64_t(trID) << 32) + chipID;
-      const auto* mc2hit = &mc2hitVec[lab.getEventID()];
-      const auto& hitEntry = mc2hit->find(key);
-      if (hitEntry == mc2hit->end()) {
-        LOGP(debug, "Failed to find MC hit entry for Tr {} chipID {}", trID, chipID);
-        continue;
-      }
+      LOGP(debug, "  `-> LOOP on: Digits array(size={}) starting at ROFIndex={} to {}", digArr->size(), rofIndex, rofIndex + rofNEntries);
+      for (unsigned int iDigit = rofIndex; iDigit < rofIndex + rofNEntries; iDigit++) {
+        int ix = (*digArr)[iDigit].getRow(), iz = (*digArr)[iDigit].getColumn();
+        auto chipID = (*digArr)[iDigit].getChipIndex();
+        auto layer = its3::constants::detID::getDetID2Layer(chipID);
+        bool isIB{its3::constants::detID::isDetITS3(chipID)};
+        float x{0.f}, y{0.f}, z{0.f};
+        (isIB) ? ++nDigitReadIB : ++nDigitReadOB;
+
+        if (isIB) {
+          // ITS3 IB
+          float xFlat{0.f}, yFlat{0.f};
+          mMosaixSegmentations[layer].detectorToLocal(ix, iz, xFlat, z);
+          mMosaixSegmentations[layer].flatToCurved(xFlat, 0., x, y);
+        } else {
+          // ITS2 OB
+          SegmentationAlpide::detectorToLocal(ix, iz, x, z);
+        }
 
-      auto gloD = gman->getMatrixL2G(chipID)(locD); // convert to global
-
-      ////// HITS
-      Hit& hit = (*hitArray[lab.getEventID()])[hitEntry->second];
-
-      auto xyzLocE = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
-      auto xyzLocS = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
-      o2::math_utils::Vector3D<float> xyzLocM;
-      xyzLocM.SetCoordinates(0.5f * (xyzLocE.X() + xyzLocS.X()), 0.5f * (xyzLocE.Y() + xyzLocS.Y()), 0.5f * (xyzLocE.Z() + xyzLocS.Z()));
-      float xlc = 0., zlc = 0.;
-      int row = 0, col = 0;
-
-      if (isIB) {
-        float xFlat{0.}, yFlat{0.};
-        mMosaixSegmentations[layer].curvedToFlat(xyzLocM.X(), xyzLocM.Y(), xFlat, yFlat);
-        xyzLocM.SetCoordinates(xFlat, yFlat, xyzLocM.Z());
-        mMosaixSegmentations[layer].curvedToFlat(locD.X(), locD.Y(), xFlat, yFlat);
-        locD.SetCoordinates(xFlat, yFlat, locD.Z());
-        if (auto v1 = !mMosaixSegmentations[layer].localToDetector(xyzLocM.X(), xyzLocM.Z(), row, col),
-            v2 = !mMosaixSegmentations[layer].detectorToLocal(row, col, xlc, zlc);
-            v1 || v2) {
+        o2::math_utils::Point3D<double> locD(x, y, z);
+        auto lab = (labels.getLabels(iDigit))[0];
+        int trID = lab.getTrackID();
+        if (!lab.isValid()) { // not noise
           continue;
         }
-      } else {
-        if (auto v1 = !SegmentationAlpide::localToDetector(xyzLocM.X(), xyzLocM.Z(), row, col),
-            v2 = !SegmentationAlpide::detectorToLocal(row, col, xlc, zlc);
-            v1 || v2) {
+
+        // get MC info
+        uint64_t key = (uint64_t(trID) << 32) + chipID;
+        const auto* mc2hit = &mc2hitVec[lab.getEventID()];
+        const auto& hitEntry = mc2hit->find(key);
+        if (hitEntry == mc2hit->end()) {
+          LOGP(debug, "Failed to find MC hit entry for Tr {} chipID {}", trID, chipID);
           continue;
         }
-      }
 
-      nt->Fill(chipID, gloD.X(), gloD.Y(), gloD.Z(), ix, iz, row, col, xyzLocM.X(), xyzLocM.Z(), xlc, zlc, xyzLocM.X() - locD.X(), xyzLocM.Z() - locD.Z());
+        auto gloD = gman->getMatrixL2G(chipID)(locD); // convert to global
+
+        ////// HITS
+        Hit& hit = (*hitArray[lab.getEventID()])[hitEntry->second];
+        // mean local position of the hit
+        auto locH = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
+        auto locHsta = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
+        o2::math_utils::Point3D<float> locHmid;
+        float x0, y0, z0, dltx, dlty, dltz, r;
+        if (isIB) {
+          float xFlat{0.}, yFlat{0.};
+          mMosaixSegmentations[layer].curvedToFlat(locH.X(), locH.Y(), xFlat, yFlat);
+          locH.SetCoordinates(xFlat, yFlat, locH.Z());
+          mMosaixSegmentations[layer].curvedToFlat(locHsta.X(), locHsta.Y(), xFlat, yFlat);
+          locHsta.SetCoordinates(xFlat, yFlat, locHsta.Z());
+          x0 = locHsta.X();
+          dltx = locH.X() - x0;
+          y0 = locHsta.Y();
+          dlty = locH.Y() - y0;
+          z0 = locHsta.Z();
+          dltz = locH.Z() - z0;
+          r = (o2::its3::constants::pixelarray::pixels::apts::responseYShift - y0) / dlty;
+        } else {
+          x0 = locHsta.X();
+          dltx = locH.X() - x0;
+          y0 = locHsta.Y();
+          dlty = locH.Y() - y0;
+          z0 = locHsta.Z();
+          dltz = locH.Z() - z0;
+          r = (0.5 * (o2::itsmft::SegmentationAlpide::SensorLayerThickness - o2::itsmft::SegmentationAlpide::SensorLayerThicknessEff) - y0) / dlty;
+        }
+        locHmid.SetXYZ(x0 + r * dltx, y0 + r * dlty, z0 + r * dltz);
+        auto gloHmid = gman->getMatrixL2G(chipID) * locHmid;
+        float theta = std::acos(gloHmid.Z() / gloHmid.Rho());
+        float eta = -std::log(std::tan(theta / 2.f));
+
+        float xlc = 0., zlc = 0.;
+        int row = 0, col = 0;
+
+        if (isIB) {
+          float xFlat{0.}, yFlat{0.};
+          mMosaixSegmentations[layer].curvedToFlat(locD.X(), locD.Y(), xFlat, yFlat);
+          locD.SetCoordinates(xFlat, yFlat, locD.Z());
+          if (auto v1 = !mMosaixSegmentations[layer].localToDetector(locHmid.X(), locHmid.Z(), row, col),
+              v2 = !mMosaixSegmentations[layer].detectorToLocal(row, col, xlc, zlc);
+              v1 || v2) {
+            continue;
+          }
+        } else {
+          if (auto v1 = !SegmentationAlpide::localToDetector(locHmid.X(), locHmid.Z(), row, col),
+              v2 = !SegmentationAlpide::detectorToLocal(row, col, xlc, zlc);
+              v1 || v2) {
+            continue;
+          }
+        }
+
+        nt->Fill(chipID, gloD.X(), gloD.Y(), gloD.Z(), ix, iz, row, col, locHmid.X(), locHmid.Z(), xlc, zlc, locHmid.X() - locD.X(), locHmid.Z() - locD.Z(), eta);
 
-      (isIB) ? ++nDigitFilledIB : ++nDigitFilledOB;
-    } // end loop on digits array
-  } // end loop on ROFRecords array
+        (isIB) ? ++nDigitFilledIB : ++nDigitFilledOB;
+      } // end loop on digits array
+    } // end loop on ROFRecords array
+
+    Info("EXIT", "read %d filled %d in IB\n", nDigitReadIB, nDigitFilledIB);
+    Info("EXIT", "read %d filled %d in OB\n", nDigitReadOB, nDigitFilledOB);
+  } else {
+    f = TFile::Open("CheckDigits.root", "Open");
+    nt = f->Get<TNtuple>("ntd");
+  }
 
   auto canvXY = new TCanvas("canvXY", "", 1600, 1600);
   canvXY->Divide(2, 2);
@@ -234,7 +269,7 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
   nt->Draw("y:x>>h_y_vs_x_OB(1000, -50, 50, 1000, -50, 50)", "id >= 3456", "colz");
   canvXY->cd(4);
   nt->Draw("y:z>>h_y_vs_z_OB(1000, -100, 100, 1000, -50, 50)", "id >= 3456", "colz");
-  canvXY->SaveAs("it3digits_y_vs_x_vs_z.pdf");
+  canvXY->SaveAs("it3digits_y_vs_x_vs_z.png");
 
   auto canvdXdZ = new TCanvas("canvdXdZ", "", 1600, 800);
   canvdXdZ->Divide(2, 2);
@@ -258,10 +293,8 @@ void CheckDigitsITS3(std::string digifile = "it3digits.root", std::string hitfil
   h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_OB_z");
   Info("OB |z|<2", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("OB |z|<2", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
-  canvdXdZ->SaveAs("it3digits_dx_vs_dz.pdf");
+  canvdXdZ->SaveAs("it3digits_dx_vs_dz.png");
 
   f->Write();
   f->Close();
-  Info("EXIT", "read %d filled %d in IB\n", nDigitReadIB, nDigitFilledIB);
-  Info("EXIT", "read %d filled %d in OB\n", nDigitReadOB, nDigitFilledOB);
 }
diff --git a/Detectors/Upgrades/ITS3/study/CMakeLists.txt b/Detectors/Upgrades/ITS3/study/CMakeLists.txt
new file mode 100644
index 0000000000000..4bb1cbca7dcb0
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/CMakeLists.txt
@@ -0,0 +1,37 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# add_compile_options(-O0 -g -fPIC -fno-omit-frame-pointer)
+
+o2_add_library(ITS3TrackingStudy
+               TARGETVARNAME targetName
+               SOURCES src/ITS3TrackingStudyParam.cxx
+                       src/TrackingStudy.cxx
+                       src/ParticleInfoExt.cxx
+               PUBLIC_LINK_LIBRARIES O2::ITS3Workflow
+                                     O2::GlobalTracking
+                                     O2::GlobalTrackingWorkflowReaders
+                                     O2::GlobalTrackingWorkflowHelpers
+                                     O2::DataFormatsGlobalTracking
+                                     O2::DetectorsVertexing
+                                     O2::SimulationDataFormat)
+
+o2_target_root_dictionary(ITS3TrackingStudy
+                          HEADERS include/ITS3TrackingStudy/ITS3TrackingStudyParam.h
+                                  include/ITS3TrackingStudy/ParticleInfoExt.h
+                          LINKDEF src/ITS3TrackingStudyLinkDef.h)
+
+o2_add_executable(study-workflow
+                  COMPONENT_NAME its3-tracking
+                  SOURCES src/its3-tracking-study-workflow.cxx
+                  PUBLIC_LINK_LIBRARIES O2::ITS3TrackingStudy)
+
+add_subdirectory(macros)
diff --git a/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ITS3TrackingStudyParam.h b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ITS3TrackingStudyParam.h
new file mode 100644
index 0000000000000..2e718622daa90
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ITS3TrackingStudyParam.h
@@ -0,0 +1,49 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRACKING_STUDY_CONFIG_H
+#define O2_TRACKING_STUDY_CONFIG_H
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+#include "DetectorsBase/Propagator.h"
+
+namespace o2::its3::study
+{
+
+struct ITS3TrackingStudyParam : o2::conf::ConfigurableParamHelper<ITS3TrackingStudyParam> {
+  /// general track selection
+  float maxChi2{36};
+  float maxEta{1.0};
+  float minPt{0.1};
+  float maxPt{1e2};
+  /// PV selection
+  int minPVCont{5};
+  /// ITS track selection
+  int minITSCls{7};
+  bool refitITS{true}; // refit ITS track including the PV
+  /// TPC track selection
+  int minTPCCls{110};
+
+  // propagator
+  o2::base::PropagatorImpl<float>::MatCorrType CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT;
+
+  /// studies
+  bool doDCA = true;
+  bool doDCARefit = true;
+  bool doPull = true;
+  bool doMC = false;
+  O2ParamDef(ITS3TrackingStudyParam, "ITS3TrackingStudyParam");
+};
+
+} // namespace o2::its3::study
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ParticleInfoExt.h b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ParticleInfoExt.h
new file mode 100644
index 0000000000000..c66068418377d
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ParticleInfoExt.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_PARTICLEINFO_EXT_H
+#define ALICEO2_PARTICLEINFO_EXT_H
+
+#include "ReconstructionDataFormats/Track.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "SimulationDataFormat/MCTrack.h"
+
+namespace o2::its3::study
+{
+
+struct ParticleInfoExt {
+  // cluster info
+  uint8_t clusters{0};
+  uint8_t fakeClusters{0};
+  // reco info
+  uint8_t isReco{0};
+  uint8_t isFake{0};
+  // matching info
+  uint8_t recoTracks;
+  uint8_t fakeTracks;
+  // reco track
+  track::TrackParCov recoTrack;
+  // mc info
+  MCTrack mcTrack;
+
+  ClassDefNV(ParticleInfoExt, 1);
+};
+
+} // namespace o2::its3::study
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/TrackingStudy.h b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/TrackingStudy.h
new file mode 100644
index 0000000000000..065629058fd32
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/TrackingStudy.h
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_TRACKING_STUDY_H
+#define O2_ITS3_TRACKING_STUDY_H
+
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2::its3::study
+{
+
+o2::framework::DataProcessorSpec getTrackingStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC);
+
+} // namespace o2::its3::study
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/study/macros/CMakeLists.txt b/Detectors/Upgrades/ITS3/study/macros/CMakeLists.txt
new file mode 100644
index 0000000000000..aaf763888c5e0
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/macros/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_test_root_macro(PlotDCA.C
+                       PUBLIC_LINK_LIBRARIES O2::ITS3TrackingStudy
+                       LABELS its COMPILE_ONLY)
+
+o2_add_test_root_macro(PlotPulls.C
+                       PUBLIC_LINK_LIBRARIES O2::ITS3TrackingStudy
+                       LABELS its COMPILE_ONLY)
diff --git a/Detectors/Upgrades/ITS3/study/macros/PlotDCA.C b/Detectors/Upgrades/ITS3/study/macros/PlotDCA.C
new file mode 100644
index 0000000000000..ac92fa491c1ac
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/macros/PlotDCA.C
@@ -0,0 +1,190 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file PlotDCA.C
+/// \brief Simple macro to plot ITS3 impact parameter resolution
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <memory>
+
+#include <TROOT.h>
+#include <TFile.h>
+#include <TF1.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TTree.h>
+
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "ReconstructionDataFormats/Track.h"
+#include "ReconstructionDataFormats/DCA.h"
+#include "SimulationDataFormat/MCTrack.h"
+#endif
+
+using GTrackID = o2::dataformats::GlobalTrackID;
+
+static std::string SanitizeSourceName(std::string_view raw)
+{
+  std::string s(raw);
+  s.erase(std::remove(s.begin(), s.end(), '-'), s.end());
+  return s;
+}
+
+void PlotDCA(const char* fName = "its3TrackStudy.root")
+{
+  TH1::SetDefaultSumw2();
+  std::unique_ptr<TFile> inFile(TFile::Open(fName));
+  auto tree = inFile->Get<TTree>("dca");
+
+  int src; // track type
+  tree->SetBranchAddress("src", &src);
+  o2::dataformats::DCA* dca{nullptr};
+  tree->SetBranchAddress("dca2MC", &dca);
+  o2::track::TrackParCov* trk{nullptr};
+  tree->SetBranchAddress("trk", &trk);
+  o2::MCTrack* mcTrk{nullptr};
+  tree->SetBranchAddress("mcTrk", &mcTrk);
+
+  const int nPtBins = 35;
+  const double ptLimits[nPtBins] = {0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2., 2.2, 2.5, 3., 4., 5., 6., 8., 10., 15., 20.};
+  const int yDCABins{1000};
+  const float yDCARange{500};
+  const int nSpecies = 5;
+  std::array<int, nSpecies> pdgCodes{-1, 11, 211, 321, 2212};
+  auto fGaus = new TF1("fGaus", "gaus", -200., 200.);
+  std::map<int, std::string> partNames = {
+    {-1, "All"},
+    {11, "Electrons"},
+    {211, "Pions"},
+    {321, "Kaons"},
+    {2212, "Protons"}};
+
+  std::map<int, std::map<int, TH2F*>> hMapDCAxyVsPtAllLayers;    // species -> [src, {dca}]
+  std::map<int, std::map<int, TH1F*>> hMapResDCAxyVsPtAllLayers; // species -> [src, {dca}]
+  std::map<int, std::map<int, TH2F*>> hMapDCAzVsPtAllLayers;     // species -> [src, {dca}]
+  std::map<int, std::map<int, TH1F*>> hMapResDCAzVsPtAllLayers;  // species -> [src, {dca}]
+  std::map<int, std::map<int, TH2F*>> hMapDeltaPtVsPtAllLayers;  // species -> [src, {dca}]
+  std::map<int, std::map<int, TH1F*>> hMapResPtVsPtAllLayers;    // species -> [src, {dca}]
+  for (const auto& [sPDG, sName] : partNames) {
+    std::map<int, TH2F*> histsDCAxy, histsDCAz, histsDeltaPt;
+    std::map<int, TH1F*> histsResDCAxy, histsResDCAz, histsResDeltaPt;
+
+    for (int cis = 0; cis < GTrackID::NSources; ++cis) {
+      const auto cdm = GTrackID::getSourceDetectorsMask(cis);
+      if (!cdm[GTrackID::ITS]) {
+        continue; // keep same logic as original
+      }
+
+      const std::string srcRaw = GTrackID::getSourceName(cis);
+      const std::string src = SanitizeSourceName(srcRaw);
+
+      histsDCAxy[cis] = new TH2F(Form("hDCAxyVsPtAllLayers_%s_%s", sName.c_str(), src.c_str()), Form("%s;#it{p}_{T,MC} (GeV/#it{c});DCA_{#it{xy}} (#mum);entries", srcRaw.c_str()), nPtBins - 1, ptLimits, yDCABins, -yDCARange, yDCARange);
+
+      histsResDCAxy[cis] = new TH1F(Form("hResDCAxyVsPtAllLayers_%s_%s", sName.c_str(), src.c_str()), Form("%s;#it{p}_{T,MC} (GeV/#it{c});#sigma(DCA_{#it{xy}}) (#mum);entries", srcRaw.c_str()), nPtBins - 1, ptLimits);
+
+      histsDCAz[cis] = new TH2F(Form("hDCAzVsPtAllLayers_%s_%s", sName.c_str(), src.c_str()), Form("%s;#it{p}_{T,MC} (GeV/#it{c});DCA_{#it{z}} (#mum);entries", srcRaw.c_str()), nPtBins - 1, ptLimits, yDCABins, -yDCARange, yDCARange);
+
+      histsResDCAz[cis] = new TH1F(Form("hResDCAzVsPtAllLayers_%s_%s", sName.c_str(), src.c_str()), Form("%s;#it{p}_{T,MC} (GeV/#it{c});#sigma(DCA_{#it{z}}) (#mum);entries", srcRaw.c_str()), nPtBins - 1, ptLimits);
+
+      histsDeltaPt[cis] = new TH2F(Form("hDeltaPtVsPtAllLayers_%s_%s", sName.c_str(), src.c_str()), Form("%s;#it{p}_{T,MC} (GeV/#it{c});#Delta_{#it{p}_{T}}/#it{p}_{T};entries", srcRaw.c_str()), nPtBins - 1, ptLimits, 200, -0.2, 0.2);
+
+      histsResDeltaPt[cis] = new TH1F(Form("hResDeltaPtVsPtAllLayers_%s_%s", sName.c_str(), src.c_str()), Form("%s;#it{p}_{T,MC} (GeV/#it{c});#sigma(#Delta#it{p}_{T}/#it{p}_{T});entries", srcRaw.c_str()), nPtBins - 1, ptLimits);
+    }
+
+    hMapDCAxyVsPtAllLayers[sPDG] = std::move(histsDCAxy);
+    hMapResDCAxyVsPtAllLayers[sPDG] = std::move(histsResDCAxy);
+    hMapDCAzVsPtAllLayers[sPDG] = std::move(histsDCAz);
+    hMapResDCAzVsPtAllLayers[sPDG] = std::move(histsResDCAz);
+    hMapDeltaPtVsPtAllLayers[sPDG] = std::move(histsDeltaPt);
+    hMapResPtVsPtAllLayers[sPDG] = std::move(histsResDeltaPt);
+  }
+
+  for (int iEntry = 0; tree->LoadTree(iEntry) >= 0; ++iEntry) {
+    tree->GetEntry(iEntry);
+    if (!mcTrk->isPrimary()) {
+      continue;
+    }
+    auto pdg = std::abs(mcTrk->GetPdgCode());
+    if (pdg != 11 && pdg != 211 && pdg != 321 && pdg != 2212) {
+      continue;
+    }
+    auto ptReco = trk->getPt();
+    auto ptGen = mcTrk->GetPt();
+    auto deltaPt = (1. / ptReco - 1. / ptGen) / (1. / ptGen);
+    auto dcaXY = dca->getY() * 10000.;
+    auto dcaZ = dca->getZ() * 10000.;
+    auto phiReco = trk->getPhi();
+
+    for (int spe : {-1, pdg}) {
+      hMapDeltaPtVsPtAllLayers[spe][src]->Fill(ptGen, deltaPt);
+      hMapDCAxyVsPtAllLayers[spe][src]->Fill(ptGen, dcaXY);
+      hMapDCAzVsPtAllLayers[spe][src]->Fill(ptGen, dcaZ);
+    }
+  }
+
+  const char* fitOpt{"QWMER"};
+  for (const auto& [sPDG, sName] : partNames) {
+    for (int cis = 0; cis < GTrackID::NSources; cis++) {
+      const auto cdm = GTrackID::getSourceDetectorsMask(cis);
+      if (!cdm[GTrackID::ITS]) {
+        continue;
+      }
+      for (auto iPt{0}; iPt < nPtBins; ++iPt) {
+        auto ptMin = hMapDCAxyVsPtAllLayers[sPDG][cis]->GetXaxis()->GetBinLowEdge(iPt + 1);
+        float minFit = (ptMin < 1.) ? -200. : -50.;
+        float maxFit = (ptMin < 1.) ? 200. : 50.;
+        auto doProjection = [&](auto& hIn, auto& hOut, bool useRange = true) {
+          auto hProj = hIn[sPDG][cis]->ProjectionY(Form("%s_%d", hOut[sPDG][cis]->GetName(), iPt), iPt + 1, iPt + 1);
+          if (hProj->GetEntries() < 100) {
+            return;
+          }
+          if (useRange) {
+            hProj->Fit("fGaus", fitOpt, "", minFit, maxFit);
+          } else {
+            hProj->Fit("fGaus", fitOpt);
+          }
+          hOut[sPDG][cis]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
+          hOut[sPDG][cis]->SetBinError(iPt + 1, fGaus->GetParError(2));
+        };
+
+        doProjection(hMapDeltaPtVsPtAllLayers, hMapResPtVsPtAllLayers, false);
+        doProjection(hMapDCAxyVsPtAllLayers, hMapResDCAxyVsPtAllLayers);
+        doProjection(hMapDCAzVsPtAllLayers, hMapResDCAzVsPtAllLayers);
+      }
+    }
+  }
+
+  TFile outFile("plotDCA.root", "RECREATE");
+  for (const auto& [sPDG, sName] : partNames) {
+    outFile.mkdir(sName.c_str());
+    outFile.cd(sName.c_str());
+    for (int cis = 0; cis < GTrackID::NSources; cis++) {
+      const auto cdm = GTrackID::getSourceDetectorsMask(cis);
+      if (!cdm[GTrackID::ITS]) {
+        continue;
+      }
+      const std::string srcRaw = GTrackID::getSourceName(cis);
+      const std::string src = SanitizeSourceName(srcRaw);
+      gDirectory->mkdir(src.c_str());
+      gDirectory->cd(src.c_str());
+
+      hMapDCAxyVsPtAllLayers[sPDG][cis]->Write();
+      hMapResDCAxyVsPtAllLayers[sPDG][cis]->Write();
+      hMapDCAzVsPtAllLayers[sPDG][cis]->Write();
+      hMapResDCAzVsPtAllLayers[sPDG][cis]->Write();
+      hMapDeltaPtVsPtAllLayers[sPDG][cis]->Write();
+      hMapResPtVsPtAllLayers[sPDG][cis]->Write();
+
+      outFile.cd(sName.c_str());
+    }
+
+    outFile.cd();
+  }
+}
diff --git a/Detectors/Upgrades/ITS3/study/macros/PlotPulls.C b/Detectors/Upgrades/ITS3/study/macros/PlotPulls.C
new file mode 100644
index 0000000000000..371a94cda0e70
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/macros/PlotPulls.C
@@ -0,0 +1,176 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file PlotDCA.C
+/// \brief Simple macro to plot ITS3 impact parameter resolution
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <memory>
+
+#include <TROOT.h>
+#include <TCanvas.h>
+#include <TFile.h>
+#include <TF1.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TTree.h>
+#include <TFitResult.h>
+#include <TFitResultPtr.h>
+
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "ReconstructionDataFormats/Track.h"
+#include "ReconstructionDataFormats/DCA.h"
+#include "SimulationDataFormat/MCTrack.h"
+#endif
+
+// chi2 PDF with amplitude A, degrees of freedom k, scale s
+Double_t chi2_pdf(Double_t* x, Double_t* par)
+{
+  const Double_t xx = x[0];
+  const Double_t A = par[0];
+  const Double_t k = par[1];
+  const Double_t s = par[2];
+  if (xx <= 0.0 || k <= 0.0 || s <= 0.0) {
+    return 0.0;
+  }
+  const Double_t coef = 1.0 / (TMath::Power(2.0 * s, k * 0.5) * TMath::Gamma(k * 0.5));
+  return A * coef * TMath::Power(xx, (k * 0.5) - 1.0) * TMath::Exp(-xx / (2.0 * s));
+}
+
+void PlotPulls(const char* fName = "its3TrackStudy.root")
+{
+  TH1::SetDefaultSumw2();
+  std::unique_ptr<TFile> inFile(TFile::Open(fName));
+  auto tree = inFile->Get<TTree>("pull");
+
+  uint8_t src; // track type
+  tree->SetBranchAddress("src", &src);
+  o2::track::TrackParCov* trk{nullptr};
+  tree->SetBranchAddress("trk", &trk);
+  o2::track::TrackPar* mcTrk{nullptr};
+  tree->SetBranchAddress("mcTrk", &mcTrk);
+  o2::MCTrack* part{nullptr};
+  tree->SetBranchAddress("mcPart", &part);
+  const int nPtBins = 35;
+  const double ptLimits[nPtBins] = {0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2., 2.2, 2.5, 3., 4., 5., 6., 8., 10., 15., 20.};
+  const int yBins{100}, yRange{5};
+  const char* pNames[5] = {"Y", "Z", "Snp", "Tgl", "Q2Pt"};
+  auto fGaus = new TF1("fGaus", "[0]*exp(-0.5*((x-[1])/[2])**2)", -3., 3.);
+
+  std::array<TH2F*, o2::track::kNParams> pulls{
+    new TH2F("hPullY", "", nPtBins - 1, ptLimits, yBins, -yRange, yRange),
+    new TH2F("hPullZ", "", nPtBins - 1, ptLimits, yBins, -yRange, yRange),
+    new TH2F("hPullSnp", "", nPtBins - 1, ptLimits, yBins, -yRange, yRange),
+    new TH2F("hPullTgl", "", nPtBins - 1, ptLimits, yBins, -yRange, yRange),
+    new TH2F("hPullQ2Pt", "", nPtBins - 1, ptLimits, yBins, -yRange, yRange)};
+
+  std::array<TH1F*, o2::track::kNParams> means{
+    new TH1F("hPullYMean", "", nPtBins - 1, ptLimits),
+    new TH1F("hPullZMean", "", nPtBins - 1, ptLimits),
+    new TH1F("hPullSnpMean", "", nPtBins - 1, ptLimits),
+    new TH1F("hPullTglMean", "", nPtBins - 1, ptLimits),
+    new TH1F("hPullQ2PtMean", "", nPtBins - 1, ptLimits)};
+
+  std::array<TH1F*, o2::track::kNParams> sigmas{
+    new TH1F("hPullYSigma", "", nPtBins - 1, ptLimits),
+    new TH1F("hPullZSigma", "", nPtBins - 1, ptLimits),
+    new TH1F("hPullSnpSigma", "", nPtBins - 1, ptLimits),
+    new TH1F("hPullTglSigma", "", nPtBins - 1, ptLimits),
+    new TH1F("hPullQ2PtSigma", "", nPtBins - 1, ptLimits)};
+
+  auto calcMahalanobisDist2 = [&](const auto* trk, const auto* mc) -> float {
+    o2::math_utils::SMatrix<float, o2::track::kNParams, o2::track::kNParams, o2::math_utils::MatRepSym<float, o2::track::kNParams>> cov;
+    cov(o2::track::kY, o2::track::kY) = trk->getSigmaY2();
+    cov(o2::track::kZ, o2::track::kY) = trk->getSigmaZY();
+    cov(o2::track::kZ, o2::track::kZ) = trk->getSigmaZ2();
+    cov(o2::track::kSnp, o2::track::kY) = trk->getSigmaSnpY();
+    cov(o2::track::kSnp, o2::track::kZ) = trk->getSigmaSnpZ();
+    cov(o2::track::kSnp, o2::track::kSnp) = trk->getSigmaSnp2();
+    cov(o2::track::kTgl, o2::track::kY) = trk->getSigmaTglY();
+    cov(o2::track::kTgl, o2::track::kZ) = trk->getSigmaTglZ();
+    cov(o2::track::kTgl, o2::track::kSnp) = trk->getSigmaTglSnp();
+    cov(o2::track::kTgl, o2::track::kTgl) = trk->getSigmaTgl2();
+    cov(o2::track::kQ2Pt, o2::track::kY) = trk->getSigma1PtY();
+    cov(o2::track::kQ2Pt, o2::track::kZ) = trk->getSigma1PtZ();
+    cov(o2::track::kQ2Pt, o2::track::kSnp) = trk->getSigma1PtSnp();
+    cov(o2::track::kQ2Pt, o2::track::kTgl) = trk->getSigma1PtTgl();
+    cov(o2::track::kQ2Pt, o2::track::kQ2Pt) = trk->getSigma1Pt2();
+    if (!cov.Invert()) {
+      return -1.f;
+    }
+    o2::math_utils::SVector<float, o2::track::kNParams> trkPar(trk->getParams(), o2::track::kNParams), mcPar(mc->getParams(), o2::track::kNParams);
+    auto res = trkPar - mcPar;
+    return ROOT::Math::Similarity(cov, res);
+  };
+
+  auto hMahDist2 = new TH1F("hMahDist2", ";Mahalanobis distance 2;n. entries", 100, 0, 10);
+
+  auto getIndex = [](int i) -> int { return i * (i + 3) / 2; };
+
+  for (int iEntry = 0; tree->LoadTree(iEntry) >= 0; ++iEntry) {
+    tree->GetEntry(iEntry);
+    if (src != o2::dataformats::GlobalTrackID::ITS || std::abs(part->GetPdgCode()) != 211) {
+      continue;
+    }
+    for (int i{0}; i < o2::track::kNParams; ++i) {
+      pulls[i]->Fill(part->GetPt(), (trk->getParam(i) - mcTrk->getParam(i)) / std::sqrt(trk->getCov()[getIndex(i)]));
+    }
+    if (part->GetPt() >= 1.0 && part->GetPt() < 2) {
+      if (auto dist = calcMahalanobisDist2(trk, mcTrk); dist >= 0.) {
+        hMahDist2->Fill(dist);
+      }
+    }
+  }
+
+  std::vector<TH1D*> projs;
+  const char* fitOpt{"QWMERSB"};
+  for (int i{0}; i < o2::track::kNParams; ++i) {
+    for (auto iPt{0}; iPt < nPtBins; ++iPt) {
+      auto hProj = pulls[i]->ProjectionY(Form("%s_%d", pulls[i]->GetName(), iPt), iPt + 1, iPt + 1);
+      hProj->SetName(Form("p%s_pt%d", pNames[i], iPt));
+      hProj->SetTitle(Form("Pull %s #it{p}_{T}#in[%.2f, %.2f)", pNames[i], ptLimits[iPt], ptLimits[iPt + 1]));
+      projs.push_back(hProj);
+      if (hProj->GetEntries() < 100) {
+        return;
+      }
+      fGaus->SetParameter(1, 0);
+      fGaus->SetParameter(2, 1);
+      auto fRes = hProj->Fit(fGaus, fitOpt);
+      if (fRes->IsValid() && fGaus->GetParameter(2) > 0) {
+        means[i]->SetBinContent(iPt + 1, fGaus->GetParameter(1));
+        means[i]->SetBinError(iPt + 1, fGaus->GetParError(1));
+        sigmas[i]->SetBinContent(iPt + 1, fGaus->GetParameter(2));
+        sigmas[i]->SetBinError(iPt + 1, fGaus->GetParError(2));
+      }
+    }
+  }
+
+  hMahDist2->Scale(1. / hMahDist2->Integral("width"));
+  TF1* fchi2Fit = new TF1("fchi2_fit", chi2_pdf, 0.1, 6, 3);
+  fchi2Fit->SetParNames("A", "k", "s");
+  fchi2Fit->SetParameter(0, 1);
+  fchi2Fit->SetParameter(1, 5);
+  fchi2Fit->SetParameter(2, 1);
+  auto fitres = hMahDist2->Fit(fchi2Fit, "RMQS");
+  fitres->Print();
+
+  TFile outFile("plotPulls.root", "RECREATE");
+  for (int i{0}; i < o2::track::kNParams; ++i) {
+    pulls[i]->Write();
+    means[i]->Write();
+    sigmas[i]->Write();
+  }
+  for (const auto& p : projs) {
+    p->Write();
+  }
+  hMahDist2->Write();
+  fchi2Fit->Write();
+}
diff --git a/Detectors/Upgrades/ITS3/study/src/ITS3TrackingStudyLinkDef.h b/Detectors/Upgrades/ITS3/study/src/ITS3TrackingStudyLinkDef.h
new file mode 100644
index 0000000000000..182ffd858629c
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/src/ITS3TrackingStudyLinkDef.h
@@ -0,0 +1,23 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::its3::study::ITS3TrackingStudyParam + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its3::study::ITS3TrackingStudyParam> + ;
+
+#pragma link C++ class o2::its3::study::ParticleInfoExt + ;
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/study/src/ITS3TrackingStudyParam.cxx b/Detectors/Upgrades/ITS3/study/src/ITS3TrackingStudyParam.cxx
new file mode 100644
index 0000000000000..00bb800e65f8c
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/src/ITS3TrackingStudyParam.cxx
@@ -0,0 +1,13 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3TrackingStudy/ITS3TrackingStudyParam.h"
+O2ParamImpl(o2::its3::study::ITS3TrackingStudyParam);
diff --git a/Detectors/Upgrades/ITS3/study/src/ParticleInfoExt.cxx b/Detectors/Upgrades/ITS3/study/src/ParticleInfoExt.cxx
new file mode 100644
index 0000000000000..aa5edbf408270
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/src/ParticleInfoExt.cxx
@@ -0,0 +1,13 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3TrackingStudy/ParticleInfoExt.h"
+ClassImp(o2::its3::study::ParticleInfoExt);
diff --git a/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx b/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
new file mode 100644
index 0000000000000..cb1d7f381983d
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
@@ -0,0 +1,841 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <vector>
+#include <cmath>
+
+#include <TStopwatch.h>
+#include <TF1.h>
+
+#include "CommonUtils/TreeStreamRedirector.h"
+#include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "ITSMFTSimulation/Hit.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "DetectorsBase/Propagator.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "DetectorsCommonDataFormats/SimTraits.h"
+#include "DetectorsVertexing/PVertexer.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/DeviceSpec.h"
+#include "Framework/Task.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "ITS3Base/SpecsV2.h"
+#include "ITS3Reconstruction/TopologyDictionary.h"
+#include "ITS3Reconstruction/IOUtils.h"
+#include "ITS3TrackingStudy/ITS3TrackingStudyParam.h"
+#include "ITS3TrackingStudy/ParticleInfoExt.h"
+#include "ReconstructionDataFormats/DCA.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "ReconstructionDataFormats/PrimaryVertex.h"
+#include "ReconstructionDataFormats/PrimaryVertexExt.h"
+#include "ReconstructionDataFormats/VtxTrackRef.h"
+#include "SimulationDataFormat/MCEventLabel.h"
+#include "SimulationDataFormat/MCUtils.h"
+#include "Steer/MCKinematicsReader.h"
+
+namespace o2::its3::study
+{
+
+using namespace o2::framework;
+using DetID = o2::detectors::DetID;
+using DataRequest = o2::globaltracking::DataRequest;
+using PVertex = o2::dataformats::PrimaryVertex;
+using GTrackID = o2::dataformats::GlobalTrackID;
+using VtxTrackID = o2::dataformats::VtxTrackIndex;
+using T2VMap = std::unordered_map<GTrackID, size_t>;
+
+class TrackingStudySpec : public Task
+{
+ public:
+  TrackingStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC) {}
+  ~TrackingStudySpec() final = default;
+  void init(InitContext& ic) final;
+  void run(ProcessingContext& pc) final;
+  void endOfStream(EndOfStreamContext& ec) final;
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
+
+ private:
+  void process(o2::globaltracking::RecoContainer& recoData);
+  void updateTimeDependentParams(ProcessingContext& pc);
+  std::vector<o2::BaseCluster<float>> prepareITSClusters(const o2::globaltracking::RecoContainer& data) const;
+  bool selectTrack(GTrackID trkID, o2::globaltracking::RecoContainer& recoData, bool checkMCTruth = true) const;
+  T2VMap buildT2V(o2::globaltracking::RecoContainer& recoData, bool includeCont = false, bool requireMCMatch = true) const;
+  bool refitITSPVTrack(o2::globaltracking::RecoContainer& recoData, o2::track::TrackParCov& trFit, GTrackID gidx);
+  void doDCAStudy(o2::globaltracking::RecoContainer& recoData);
+  void doDCARefitStudy(o2::globaltracking::RecoContainer& recoData);
+  void doPullStudy(o2::globaltracking::RecoContainer& recoData);
+  void doMCStudy(o2::globaltracking::RecoContainer& recoData);
+
+  struct TrackCounter {
+    TrackCounter() = default;
+
+    void operator+=(int src)
+    {
+      if (src >= 0 && src < static_cast<int>(mSuccess.size())) {
+        ++mSuccess[src];
+      }
+    }
+
+    void operator-=(int src)
+    {
+      if (src >= 0 && src < static_cast<int>(mirrors.size())) {
+        ++mirrors[src];
+      }
+    }
+
+    void operator&=(int src)
+    {
+      if (src >= 0 && src < static_cast<int>(mRejected.size())) {
+        ++mRejected[src];
+      }
+    }
+
+    void print() const
+    {
+      LOGP(info, "\t\t\tSuccess / Error / Rejected");
+      for (int cis = 0; cis < GTrackID::NSources; ++cis) {
+        const auto cdm = GTrackID::getSourceDetectorsMask(cis);
+        if (cdm[DetID::ITS]) {
+          LOGP(info, "\t{:{}}\t{} / {} / {}", GTrackID::getSourceName(cis), 15, mSuccess[cis], mirrors[cis], mRejected[cis]);
+        }
+      }
+    }
+
+    void reset()
+    {
+      mSuccess.fill(0);
+      mirrors.fill(0);
+      mRejected.fill(0);
+    }
+
+    std::array<size_t, GTrackID::NSources> mSuccess{};
+    std::array<size_t, GTrackID::NSources> mirrors{};
+    std::array<size_t, GTrackID::NSources> mRejected{};
+  };
+  TrackCounter mTrackCounter;
+
+  std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
+  std::shared_ptr<DataRequest> mDataRequest;
+  std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
+  bool mUseMC{false};
+  GTrackID::mask_t mTracksSrc;
+  o2::vertexing::PVertexer mVertexer;
+  o2::steer::MCKinematicsReader mcReader;                 // reader of MC information
+  const o2::its3::TopologyDictionary* mITSDict = nullptr; // cluster patterns dictionary
+};
+
+void TrackingStudySpec::init(InitContext& ic)
+{
+  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
+  int lane = ic.services().get<const o2::framework::DeviceSpec>().inputTimesliceId;
+  int maxLanes = ic.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices;
+  std::string dbgnm = maxLanes == 1 ? "its3TrackStudy.root" : fmt::format("its3TrackStudy_{}.root", lane);
+  mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(dbgnm.c_str(), "recreate");
+
+  if (mUseMC && !mcReader.initFromDigitContext(o2::base::NameConf::getCollisionContextFileName())) {
+    LOGP(fatal, "initialization of MCKinematicsReader failed");
+  }
+}
+
+void TrackingStudySpec::run(ProcessingContext& pc)
+{
+  o2::globaltracking::RecoContainer recoData;
+  recoData.collectData(pc, *mDataRequest);
+  updateTimeDependentParams(pc);
+  process(recoData);
+}
+
+void TrackingStudySpec::updateTimeDependentParams(ProcessingContext& pc)
+{
+  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+  if (static bool initOnceDone{false}; !initOnceDone) { // this params need to be queried only once
+    initOnceDone = true;
+    auto grp = o2::base::GRPGeomHelper::instance().getGRPECS();
+    mVertexer.init();
+    o2::its::GeometryTGeo::Instance()->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2G));
+  }
+}
+
+void TrackingStudySpec::endOfStream(EndOfStreamContext& ec)
+{
+  mDBGOut.reset();
+}
+
+void TrackingStudySpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+{
+  if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
+    return;
+  }
+  if (matcher == ConcreteDataMatcher("IT3", "CLUSDICT", 0)) {
+    LOG(info) << "cluster dictionary updated";
+    mITSDict = (const o2::its3::TopologyDictionary*)obj;
+    return;
+  }
+}
+
+void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
+{
+  const auto& conf = ITS3TrackingStudyParam::Instance();
+  if (conf.doDCA) {
+    doDCAStudy(recoData);
+  }
+  if (conf.doDCARefit) {
+    doDCARefitStudy(recoData);
+  }
+  if (mUseMC && conf.doPull) {
+    doPullStudy(recoData);
+  }
+  if (mUseMC && conf.doMC) {
+    doMCStudy(recoData);
+  }
+}
+
+std::vector<o2::BaseCluster<float>> TrackingStudySpec::prepareITSClusters(const o2::globaltracking::RecoContainer& data) const
+{
+  std::vector<o2::BaseCluster<float>> itscl;
+  const auto& clusITS = data.getITSClusters();
+  if (clusITS.size()) {
+    const auto& patterns = data.getITSClustersPatterns();
+    itscl.reserve(clusITS.size());
+    auto pattIt = patterns.begin();
+    o2::its3::ioutils::convertCompactClusters(clusITS, pattIt, itscl, mITSDict);
+  }
+  return std::move(itscl);
+}
+
+bool TrackingStudySpec::selectTrack(GTrackID trkID, o2::globaltracking::RecoContainer& recoData, bool checkMCTruth) const
+{
+  const auto& conf = ITS3TrackingStudyParam::Instance();
+  if (!trkID.includesDet(GTrackID::ITS)) {
+    return false;
+  }
+  if (!recoData.isTrackSourceLoaded(trkID.getSource())) {
+    return false;
+  }
+  auto contributorsGID = recoData.getSingleDetectorRefs(trkID);
+  if (!contributorsGID[GTrackID::ITS].isIndexSet()) { // we need of course ITS
+    return false;
+  }
+  // ITS specific
+  const auto& itsTrk = recoData.getITSTrack(contributorsGID[GTrackID::ITS]);
+  if (itsTrk.getChi2() > conf.maxChi2 || itsTrk.getNClusters() < conf.minITSCls) {
+    return false;
+  }
+  // TPC specific
+  if (contributorsGID[GTrackID::TPC].isIndexSet()) {
+    const auto& tpcTrk = recoData.getTPCTrack(contributorsGID[GTrackID::TPC]);
+    if (tpcTrk.getNClusters() < conf.minTPCCls) {
+      return false;
+    }
+  }
+  // general
+  const auto& gTrk = recoData.getTrackParam(trkID);
+  if (gTrk.getPt() < conf.minPt || gTrk.getPt() > conf.maxPt) {
+    return false;
+  }
+  if (std::abs(gTrk.getEta()) > conf.maxEta) {
+    return false;
+  }
+  if (mUseMC && checkMCTruth) {
+    const auto& itsLbl = recoData.getTrackMCLabel(contributorsGID[GTrackID::ITS]);
+    if (!itsLbl.isValid()) {
+      return false;
+    }
+    if (contributorsGID[GTrackID::TPC].isIndexSet()) {
+      const auto& tpcLbl = recoData.getTrackMCLabel(contributorsGID[GTrackID::TPC]);
+      if (itsLbl != tpcLbl) {
+        return false;
+      }
+    }
+    if (contributorsGID[GTrackID::TRD].isIndexSet()) {
+      // TODO
+    }
+    if (contributorsGID[GTrackID::TOF].isIndexSet()) {
+      const auto& tofLbls = recoData.getTOFClustersMCLabels()->getLabels(contributorsGID[GTrackID::TOF]);
+      for (const auto& lbl : tofLbls) {
+        if (lbl.isValid()) {
+          return true;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+T2VMap TrackingStudySpec::buildT2V(o2::globaltracking::RecoContainer& recoData, bool includeCont, bool requireMCMatch) const
+{
+  // build track->vertex assoc., maybe including contributor tracks
+  const auto& conf = ITS3TrackingStudyParam::Instance();
+  auto pvvec = recoData.getPrimaryVertices();
+  auto trackIndex = recoData.getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
+  auto vtxRefs = recoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
+  auto nv = vtxRefs.size() - 1;                               // last entry is for unassigned tracks, ignore them
+  T2VMap t2v;
+  for (size_t iv = 0; iv < nv; ++iv) {
+    const auto& pv = pvvec[iv];
+    if (pv.getNContributors() - 1 < conf.minPVCont) {
+      continue;
+    }
+    if (requireMCMatch) {
+      auto pvl = recoData.getPrimaryVertexMCLabel(iv);
+    }
+    const auto& vtxRef = vtxRefs[iv];
+    int it = vtxRef.getFirstEntry(), itLim = it + vtxRef.getEntries();
+    for (; it < itLim; it++) {
+      const auto& tvid = trackIndex[it];
+      if (tvid.isAmbiguous()) {
+        continue;
+      }
+      if (!recoData.isTrackSourceLoaded(tvid.getSource())) {
+        continue;
+      }
+      if (mUseMC && requireMCMatch) {
+        const auto& pvlbl = recoData.getPrimaryVertexMCLabel(iv);
+        if (pvlbl.getEventID() != recoData.getTrackMCLabel(tvid).getEventID()) {
+          continue;
+        }
+      }
+      t2v[tvid] = iv;
+      if (includeCont) {
+        auto contributorsGID = recoData.getSingleDetectorRefs(tvid);
+        for (int cis = 0; cis < GTrackID::NSources; cis++) {
+          const auto cdm = GTrackID::getSourceDetectorsMask(cis);
+          if (!recoData.isTrackSourceLoaded(cis) || !cdm[DetID::ITS] || !contributorsGID[cis].isIndexSet()) {
+            continue;
+          }
+          if (mUseMC && requireMCMatch) {
+            const auto& pvlbl = recoData.getPrimaryVertexMCLabel(iv);
+            if (pvlbl.getEventID() != recoData.getTrackMCLabel(contributorsGID[cis]).getEventID()) {
+              continue;
+            }
+          }
+          t2v[contributorsGID[cis]] = iv;
+        }
+      }
+    }
+  }
+  return std::move(t2v);
+}
+
+bool TrackingStudySpec::refitITSPVTrack(o2::globaltracking::RecoContainer& recoData, o2::track::TrackParCov& trFit, GTrackID gidx)
+{
+  if (gidx.getSource() != GTrackID::ITS) {
+    return false;
+  }
+  static auto pvvec = recoData.getPrimaryVertices();
+  static auto t2v = buildT2V(recoData, true, true);
+  static const auto itsClusters = prepareITSClusters(recoData);
+  static std::vector<unsigned int> itsTracksROF;
+  if (static bool done{false}; !done) {
+    done = true;
+    const auto& itsTracksROFRec = recoData.getITSTracksROFRecords();
+    itsTracksROF.resize(recoData.getITSTracks().size());
+    for (unsigned irf = 0, cnt = 0; irf < itsTracksROFRec.size(); irf++) {
+      int ntr = itsTracksROFRec[irf].getNEntries();
+      for (int itr = 0; itr < ntr; itr++) {
+        itsTracksROF[cnt++] = irf;
+      }
+    }
+  }
+  auto prop = o2::base::Propagator::Instance();
+  const auto& conf = ITS3TrackingStudyParam::Instance();
+  std::array<o2::BaseCluster<float>, 8> clArr{};
+  std::array<float, 8> clAlpha{};
+  const auto trkIn = recoData.getTrackParam(gidx);
+  const auto trkOut = recoData.getTrackParamOut(gidx);
+  const auto& itsTrOrig = recoData.getITSTrack(gidx);
+  int ncl = itsTrOrig.getNumberOfClusters(), rof = itsTracksROF[gidx.getIndex()];
+  const auto& itsTrackClusRefs = recoData.getITSTracksClusterRefs();
+  int clEntry = itsTrOrig.getFirstClusterEntry();
+  const auto propagator = o2::base::Propagator::Instance();
+  // convert PV to a fake cluster in the track DCA frame
+  const auto& pv = pvvec[t2v[gidx]];
+  auto trkPV = trkIn;
+  if (!prop->propagateToDCA(pv, trkPV, prop->getNominalBz(), 2.0, conf.CorrType)) {
+    mTrackCounter -= gidx.getSource();
+    return false;
+  }
+  // create base cluster from the PV, with the alpha corresponding to the track at DCA
+  float cosAlp = NAN, sinAlp = NAN;
+  o2::math_utils::sincos(trkPV.getAlpha(), sinAlp, cosAlp);
+  // vertex position rotated to track frame
+  clArr[0].setXYZ(pv.getX() * cosAlp + pv.getY() * sinAlp, -pv.getX() * sinAlp + pv.getY() * cosAlp, pv.getZ());
+  clArr[0].setSigmaY2(0.5 * (pv.getSigmaX2() + pv.getSigmaY2()));
+  clArr[0].setSigmaZ2(pv.getSigmaZ2());
+  clAlpha[0] = trkPV.getAlpha();
+  for (int icl = 0; icl < ncl; ++icl) { // ITS clusters are referred in layer decreasing order
+    clArr[ncl - icl] = itsClusters[itsTrackClusRefs[clEntry + icl]];
+    clAlpha[ncl - icl] = o2::its::GeometryTGeo::Instance()->getSensorRefAlpha(clArr[ncl - icl].getSensorID());
+  }
+  // start refit
+  trFit = trkOut;
+  trFit.resetCovariance(1'000);
+  float chi2{0};
+  for (int icl = ncl; icl >= 0; --icl) { // go backwards
+    if (!trFit.rotate(clAlpha[icl]) || !prop->propagateToX(trFit, clArr[icl].getX(), prop->getNominalBz(), 0.85, 2.0, conf.CorrType)) {
+      mTrackCounter -= gidx.getSource();
+      return false;
+    }
+    chi2 += trFit.getPredictedChi2(clArr[icl]);
+    if (!trFit.update(clArr[icl])) {
+      mTrackCounter -= gidx.getSource();
+      return false;
+    }
+  }
+  // chi2 < conf.maxChi2; should I cut here?
+  return true;
+};
+
+void TrackingStudySpec::doDCAStudy(o2::globaltracking::RecoContainer& recoData)
+{
+  /// analyse DCA of impact parameter for different track types
+  LOGP(info, "Doing DCA study");
+  mTrackCounter.reset();
+  const auto& conf = ITS3TrackingStudyParam::Instance();
+  auto prop = o2::base::Propagator::Instance();
+  TStopwatch sw;
+  sw.Start();
+  int nDCAFits{0}, nDCAFitsFail{0};
+  auto pvvec = recoData.getPrimaryVertices();
+  auto trackIndex = recoData.getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
+  auto vtxRefs = recoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
+  auto nv = vtxRefs.size() - 1;                               // last entry is for unassigned tracks, ignore them
+  auto& stream = (*mDBGOut) << "dca";
+  for (int iv = 0; iv < nv; iv++) {
+    const auto& pv = pvvec[iv];
+    const auto& vtref = vtxRefs[iv];
+    for (int is = 0; is < GTrackID::NSources; is++) {
+      const auto dm = GTrackID::getSourceDetectorsMask(is);
+      if (!recoData.isTrackSourceLoaded(is) || !dm[DetID::ITS]) {
+        mTrackCounter &= is;
+        continue;
+      }
+      int idMin = vtref.getFirstEntryOfSource(is), idMax = idMin + vtref.getEntriesOfSource(is);
+      for (int i = idMin; i < idMax; i++) {
+        const auto vid = trackIndex[i];
+        if (!vid.isPVContributor()) {
+          mTrackCounter &= vid.getSource();
+          continue;
+        }
+
+        // we fit each different sub-track type, that include ITS, e.g.
+        // ITS,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF
+        auto contributorsGID = recoData.getSingleDetectorRefs(vid);
+        for (int cis = 0; cis < GTrackID::NSources && cis <= is; cis++) {
+          const auto cdm = GTrackID::getSourceDetectorsMask(cis);
+          if (!recoData.isTrackSourceLoaded(cis) || !cdm[DetID::ITS] || !contributorsGID[cis].isIndexSet()) {
+            mTrackCounter &= cis;
+            continue;
+          }
+          if (!selectTrack(contributorsGID[cis], recoData)) {
+            mTrackCounter &= vid.getSource();
+            continue;
+          }
+
+          o2::dataformats::DCA dcaInfo;
+          const auto& trk = recoData.getTrackParam(contributorsGID[cis]);
+          auto trkRefit = trk;
+          // for ITS standalone tracks instead of having the trk at the pv we refit with the pv
+          if (conf.refitITS && cis == GTrackID::ITS && !refitITSPVTrack(recoData, trkRefit, contributorsGID[cis])) {
+            mTrackCounter -= cis;
+            continue;
+          } else {
+            trkRefit.invalidate();
+          };
+
+          auto trkDCA = trk;
+          if (!prop->propagateToDCABxByBz(pv, trkDCA, 2.f, conf.CorrType, &dcaInfo)) {
+            mTrackCounter -= cis;
+            ++nDCAFitsFail;
+            continue;
+          }
+
+          stream << "src=" << cis
+                 << "pv=" << pv
+                 << "trk=" << trk
+                 << "trkRefit=" << trkRefit
+                 << "trkAtPV=" << trkDCA
+                 << "dca=" << dcaInfo;
+
+          if (mUseMC) {
+            const auto& lbl = recoData.getTrackMCLabel(contributorsGID[cis]);
+            lbl.print();
+            o2::dataformats::DCA dcaInfoMC;
+            const auto& eve = mcReader.getMCEventHeader(lbl.getSourceID(), lbl.getEventID());
+            o2::dataformats::VertexBase mcEve;
+            mcEve.setPos({(float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ()});
+            auto trkC = trk;
+            if (!prop->propagateToDCABxByBz(mcEve, trkC, 2.f, conf.CorrType, &dcaInfoMC)) {
+              mTrackCounter -= cis;
+              ++nDCAFitsFail;
+              continue;
+            }
+            const auto& mcTrk = mcReader.getTrack(lbl);
+            if (mcTrk == nullptr) {
+              LOGP(fatal, "mcTrk is null did selection fail?");
+            }
+            stream << "mcTrk=" << *mcTrk
+                   << "dca2MC=" << dcaInfoMC
+                   << "lbl=" << lbl;
+          }
+          stream << "\n";
+
+          ++nDCAFits;
+          mTrackCounter += cis;
+        }
+      }
+    }
+  }
+  sw.Stop();
+  LOGP(info, "doDCAStudy: accepted {} fits, failed {} (in {:.2f} seconds)", nDCAFits, nDCAFitsFail, sw.RealTime());
+  mTrackCounter.print();
+}
+
+void TrackingStudySpec::doDCARefitStudy(o2::globaltracking::RecoContainer& recoData)
+{
+  /// analyse DCA of impact parameter for different track types while refitting the PV without the cand track
+  LOGP(info, "Doing DCARefit study");
+  mTrackCounter.reset();
+  const auto& conf = ITS3TrackingStudyParam::Instance();
+  auto prop = o2::base::Propagator::Instance();
+  TStopwatch sw;
+  sw.Start();
+
+  // build track->vertex assoc.
+  auto pvvec = recoData.getPrimaryVertices();
+  auto vtxRefs = recoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
+  auto nv = vtxRefs.size() - 1;                               // last entry is for unassigned tracks, ignore them
+  auto t2v = buildT2V(recoData);
+  std::vector<std::vector<GTrackID>> v2t;
+  v2t.resize(nv);
+  auto creator = [&](const auto& trk, GTrackID trkID, float _t0, float terr) -> bool {
+    if constexpr (!isBarrelTrack<decltype(trk)>()) {
+      mTrackCounter &= trkID.getSource();
+      return false;
+    }
+    if (!trkID.includesDet(GTrackID::ITS)) {
+      mTrackCounter &= trkID.getSource();
+      return false;
+    }
+    // general
+    if constexpr (isBarrelTrack<decltype(trk)>()) {
+      if (trk.getPt() < conf.minPt || trk.getPt() > conf.maxPt) {
+        mTrackCounter &= trkID.getSource();
+        return false;
+      }
+      if (std::abs(trk.getEta()) > conf.maxEta) {
+        mTrackCounter &= trkID.getSource();
+        return false;
+      }
+      if (!t2v.contains(trkID)) {
+        mTrackCounter &= trkID.getSource();
+        return false;
+      }
+      if (!selectTrack(trkID, recoData, mUseMC)) {
+        mTrackCounter &= trkID.getSource();
+        return false;
+      }
+    }
+    v2t[t2v[trkID]].push_back(trkID);
+    return true;
+  };
+  recoData.createTracksVariadic(creator);
+
+  int nDCAFits{0}, nDCAFitsFail{0};
+  auto& stream = (*mDBGOut) << "dcaRefit";
+  for (size_t iv = 0; iv < nv; ++iv) {
+    const auto& pv = pvvec[iv];
+    const auto& trkIDs = v2t[iv];
+    if (trkIDs.size() - 1 < conf.minPVCont) {
+      continue;
+    }
+    std::vector<o2::track::TrackParCov> trks;
+    trks.reserve(trkIDs.size());
+    for (const auto& trkID : trkIDs) {
+      trks.push_back(recoData.getTrackParam(trkID));
+    }
+
+    if (!mVertexer.prepareVertexRefit(trks, pv)) {
+      continue;
+    }
+    std::vector<bool> trkMask(trkIDs.size(), true);
+    for (size_t it{0}; it < trkMask.size(); ++it) {
+      trkMask[it] = false; // mask current track from pv refit
+      if (it != 0) {
+        trkMask[it - 1] = true; // unmask previoustrack from pv refit
+      }
+      auto pvRefit = mVertexer.refitVertex(trkMask, pv);
+      if (pvRefit.getChi2() < 0) {
+        trkMask[it] = true;
+        continue;
+      }
+
+      // check DCA both for refitted and original PV
+      o2::dataformats::DCA dcaInfo;
+      auto trkC = trks[it];
+      if (!prop->propagateToDCABxByBz(pv, trkC, 2.f, conf.CorrType, &dcaInfo)) {
+        mTrackCounter -= trkIDs[it].getSource();
+        ++nDCAFitsFail;
+        continue;
+      }
+      o2::dataformats::DCA dcaInfoRefit;
+      auto trkCRefit = trks[it];
+      if (!prop->propagateToDCABxByBz(pv, trkCRefit, 2.f, conf.CorrType, &dcaInfoRefit)) {
+        mTrackCounter -= trkIDs[it].getSource();
+        ++nDCAFitsFail;
+        continue;
+      }
+
+      stream << "src=" << trkIDs[it].getSource()
+             << "pv=" << pv
+             << "trkAtPV=" << trkC
+             << "dca=" << dcaInfo
+             << "pvRefit=" << pvRefit
+             << "trkAtPVRefit=" << trkC
+             << "dcaRefit=" << dcaInfoRefit;
+      if (mUseMC) {
+        const auto& mcTrk = mcReader.getTrack(recoData.getTrackMCLabel(trkIDs[it]));
+        if (mcTrk == nullptr) {
+          LOGP(fatal, "mcTrk is null did selection fail?");
+        }
+        stream << "mcTrk=" << *mcTrk;
+      }
+      stream << "\n";
+      ++nDCAFits;
+      mTrackCounter += trkIDs[it].getSource();
+    }
+  }
+  sw.Stop();
+  LOGP(info, "doDCARefitStudy: accepted {} fits, failed {} (in {:.2f} seconds)", nDCAFits, nDCAFitsFail, sw.RealTime());
+  mTrackCounter.print();
+}
+
+void TrackingStudySpec::doPullStudy(o2::globaltracking::RecoContainer& recoData)
+{
+  // check track pulls compared to mc generation
+  LOGP(info, "Doing Pull study");
+  mTrackCounter.reset();
+  TStopwatch sw;
+  sw.Start();
+  int nPulls{0}, nPullsFail{0};
+  auto prop = o2::base::Propagator::Instance();
+  const auto& conf = ITS3TrackingStudyParam::Instance();
+
+  auto checkInTrack = [&](GTrackID trkID) {
+    if (!selectTrack(trkID, recoData)) {
+      mTrackCounter &= trkID.getSource();
+      return;
+    }
+    const auto mcTrk = mcReader.getTrack(recoData.getTrackMCLabel(trkID));
+    if (!mcTrk) {
+      return;
+    }
+    auto trk = recoData.getTrackParam(trkID);
+
+    // for ITS standalone tracks we add the PV as an additional measurement point
+    if (conf.refitITS && trkID.getSource() == GTrackID::ITS && !refitITSPVTrack(recoData, trk, trkID)) {
+      mTrackCounter -= trkID.getSource();
+      ++nPullsFail;
+      return;
+    }
+
+    std::array<float, 3> xyz{(float)mcTrk->GetStartVertexCoordinatesX(), (float)mcTrk->GetStartVertexCoordinatesY(), (float)mcTrk->GetStartVertexCoordinatesZ()},
+      pxyz{(float)mcTrk->GetStartVertexMomentumX(), (float)mcTrk->GetStartVertexMomentumY(), (float)mcTrk->GetStartVertexMomentumZ()};
+    TParticlePDG* pPDG = TDatabasePDG::Instance()->GetParticle(mcTrk->GetPdgCode());
+    if (!pPDG) {
+      mTrackCounter -= trkID.getSource();
+      ++nPullsFail;
+      return;
+    }
+    o2::track::TrackPar mcTrkO2(xyz, pxyz, TMath::Nint(pPDG->Charge() / 3), false);
+    // propagate it to the alpha/X of the reconstructed track
+    if (!mcTrkO2.rotate(trk.getAlpha()) || !prop->PropagateToXBxByBz(mcTrkO2, trk.getX())) {
+      mTrackCounter -= trkID.getSource();
+      ++nPullsFail;
+      return;
+    }
+    const auto contTrk = recoData.getSingleDetectorRefs(trkID);
+    const auto& itsTrk = recoData.getITSTrack(contTrk[GTrackID::ITS]);
+
+    (*mDBGOut)
+      << "pull"
+      << "src=" << trkID.getSource()
+      << "itsTrk=" << itsTrk
+      << "mcTrk=" << mcTrkO2
+      << "mcPart=" << mcTrk
+      << "trk=" << trk
+      << "\n";
+    ++nPulls;
+    mTrackCounter += trkID.getSource();
+  };
+
+  for (size_t iTrk{0}; iTrk < recoData.getITSTracks().size(); ++iTrk) {
+    checkInTrack(GTrackID(iTrk, GTrackID::ITS));
+  }
+  for (size_t iTrk{0}; iTrk < recoData.getTPCITSTracks().size(); ++iTrk) {
+    checkInTrack(GTrackID(iTrk, GTrackID::ITSTPC));
+  }
+  for (size_t iTrk{0}; iTrk < recoData.getITSTPCTRDTracksMCLabels().size(); ++iTrk) {
+    checkInTrack(GTrackID(iTrk, GTrackID::ITSTPCTRD));
+  }
+  for (size_t iTrk{0}; iTrk < recoData.getITSTPCTOFMatches().size(); ++iTrk) {
+    checkInTrack(GTrackID(iTrk, GTrackID::ITSTPCTOF));
+  }
+  for (size_t iTrk{0}; iTrk < recoData.getITSTPCTRDTOFMatches().size(); ++iTrk) {
+    checkInTrack(GTrackID(iTrk, GTrackID::ITSTPCTRDTOF));
+  }
+  sw.Stop();
+  LOGP(info, "doPullStudy: accepted {} pulls; rejected {} (in {:.2f} seconds)", nPulls, nPullsFail, sw.RealTime());
+  mTrackCounter.print();
+}
+
+void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
+{
+  LOGP(info, "Doing MC study");
+  mTrackCounter.reset();
+  TStopwatch sw;
+  sw.Start();
+  int nTracks{0};
+
+  const int iSrc{0};
+  const int nev = mcReader.getNEvents(iSrc);
+  std::unordered_map<o2::MCCompLabel, ParticleInfoExt> info;
+
+  LOGP(info, "** Filling particle table ... ");
+  for (int iEve{0}; iEve < nev; ++iEve) {
+    const auto& mcTrks = mcReader.getTracks(iSrc, iEve);
+    for (int iTrk{0}; iTrk < mcTrks.size(); ++iTrk) {
+      const auto& mcTrk = mcTrks[iTrk];
+      const auto pdg = mcTrk.GetPdgCode();
+      if (o2::O2DatabasePDG::Instance()->GetParticle(pdg) == nullptr) {
+        continue;
+      }
+      const auto apdg = std::abs(pdg);
+      if (apdg != 11 && apdg != 211 && apdg != 321 && apdg != 2212) {
+        continue;
+      }
+      o2::MCCompLabel lbl(iTrk, iEve, iSrc);
+      auto& part = info[lbl];
+      part.mcTrack = mcTrk;
+    }
+  }
+  LOGP(info, "** Creating particle/clusters correspondence ... ");
+  const auto& clusters = recoData.getITSClusters();
+  const auto& clustersMCLCont = recoData.getITSClustersMCLabels();
+  for (auto iCluster{0}; iCluster < clusters.size(); ++iCluster) {
+    auto labs = clustersMCLCont->getLabels(iCluster);
+    for (auto& lab : labs) {
+      if (!lab.isValid() || lab.getSourceID() != 0 || !lab.isCorrect()) {
+        continue;
+      }
+      int trackID = 0, evID = 0, srcID = 0;
+      bool fake = false;
+      lab.get(trackID, evID, srcID, fake);
+      auto& cluster = clusters[iCluster];
+      auto layer = o2::its::GeometryTGeo::Instance()->getLayer(cluster.getSensorID());
+      auto& part = info[{trackID, evID, srcID}];
+      part.clusters |= (1 << layer);
+      if (fake) {
+        part.fakeClusters |= (1 << layer);
+      }
+    }
+  }
+  LOGP(info, "** Analysing tracks ... ");
+  auto accountLbl = [&](const globaltracking::RecoContainer::GlobalIDSet& contributorsGID, DetID::ID det) {
+    if (contributorsGID[det].isIndexSet()) {
+      const auto& lbl = recoData.getTrackMCLabel(contributorsGID[det]);
+      if (lbl.isValid()) {
+        o2::MCCompLabel iLbl(lbl.getTrackID(), lbl.getEventID(), lbl.getSourceID());
+        if (info.contains(iLbl)) {
+          auto& part = info[iLbl];
+          SETBIT(part.recoTracks, det);
+          if (lbl.isFake()) {
+            SETBIT(part.fakeTracks, det);
+          }
+        }
+      }
+    }
+  };
+  auto creator = [&](const auto& trk, GTrackID trkID, float _t0, float terr) -> bool {
+    if constexpr (!isBarrelTrack<decltype(trk)>()) {
+      return false;
+    }
+    if (!trkID.includesDet(GTrackID::ITS)) {
+      return false;
+    }
+    // general
+    auto contributorsGID = recoData.getSingleDetectorRefs(trkID);
+    if (!contributorsGID[GTrackID::ITS].isIndexSet()) { // we need of course ITS
+      return false;
+    }
+    const auto& gLbl = recoData.getTrackMCLabel(trkID);
+    if (!gLbl.isValid()) {
+      return false;
+    }
+    o2::MCCompLabel iLbl(gLbl.getTrackID(), gLbl.getEventID(), gLbl.getSourceID());
+    if (!info.contains(iLbl)) {
+      return false;
+    }
+    auto& part = info[iLbl];
+    part.recoTrack = recoData.getTrackParam(trkID);
+
+    accountLbl(contributorsGID, DetID::ITS);
+    accountLbl(contributorsGID, DetID::TPC);
+    accountLbl(contributorsGID, DetID::TRD);
+    accountLbl(contributorsGID, DetID::TOF);
+
+    ++nTracks;
+    return true;
+  };
+  recoData.createTracksVariadic(creator);
+
+  LOGP(info, "Streaming output to tree");
+  for (const auto& [_, part] : info) {
+    (*mDBGOut) << "mc"
+               << "part=" << part
+               << "\n";
+  }
+
+  sw.Stop();
+  LOGP(info, "doMCStudy: accounted {} MCParticles and {} tracks (in {:.2f} seconds)", info.size(), nTracks, sw.RealTime());
+}
+
+DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC)
+{
+  std::vector<OutputSpec> outputs;
+  auto dataRequest = std::make_shared<DataRequest>();
+
+  dataRequest->requestTracks(srcTracks, useMC);
+  dataRequest->requestIT3Clusters(useMC);
+  dataRequest->requestClusters(srcClusters, useMC);
+  dataRequest->requestPrimaryVertices(useMC);
+  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
+                                                              true,                              // GRPECS=true
+                                                              true,                              // GRPLHCIF
+                                                              true,                              // GRPMagField
+                                                              true,                              // askMatLUT
+                                                              o2::base::GRPGeomRequest::Aligned, // geometry
+                                                              dataRequest->inputs,
+                                                              true);
+
+  return DataProcessorSpec{
+    .name = "its3-track-study",
+    .inputs = dataRequest->inputs,
+    .outputs = outputs,
+    .algorithm = AlgorithmSpec{adaptFromTask<TrackingStudySpec>(dataRequest, ggRequest, srcTracks, useMC)},
+    .options = {}};
+}
+
+} // namespace o2::its3::study
diff --git a/Detectors/Upgrades/ITS3/study/src/its3-tracking-study-workflow.cxx b/Detectors/Upgrades/ITS3/study/src/its3-tracking-study-workflow.cxx
new file mode 100644
index 0000000000000..e0a0aea1c368a
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/src/its3-tracking-study-workflow.cxx
@@ -0,0 +1,73 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3TrackingStudy/TrackingStudy.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/CompletionPolicy.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/CompletionPolicyHelpers.h"
+#include "Framework/CallbacksPolicy.h"
+#include "DetectorsBase/DPLWorkflowUtils.h"
+#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+
+using namespace o2::framework;
+using GID = o2::dataformats::GlobalTrackID;
+using DetID = o2::detectors::DetID;
+
+// ------------------------------------------------------------------
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
+{
+  o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  // option allowing to set parameters
+  std::vector<o2::framework::ConfigParamSpec> options{
+    {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation"}},
+    {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of track sources to use"}},
+    {"cluster-sources", VariantType::String, "ITS,TRD,TOF", {"comma-separated list of cluster sources to use"}},
+    {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::raw::HBFUtilsInitializer::addConfigOption(options);
+  std::swap(workflowOptions, options);
+}
+
+// ------------------------------------------------------------------
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
+{
+  WorkflowSpec specs;
+
+  GID::mask_t allowedSourcesTrc = GID::getSourcesMask("ITS,TPC,TRD,TOF,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
+  GID::mask_t allowedSourcesClus = GID::getSourcesMask("ITS,TPC,TRD,TOF");
+
+  o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
+  auto useMC = !configcontext.options().get<bool>("disable-mc");
+
+  GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
+  GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(configcontext.options().get<std::string>("cluster-sources"));
+
+  o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC);
+  o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC);
+
+  specs.emplace_back(o2::its3::study::getTrackingStudySpec(srcTrc, srcCls, useMC));
+
+  o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
+
+  return std::move(specs);
+}

From 55b66aec6cfbfe900e74d63ba4b80a7dcee85cc9 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 21 Nov 2025 13:37:18 +0100
Subject: [PATCH 1052/1764] Set proper EOR to anchored MC GRPECS

---
 DataFormats/Parameters/src/GRPTool.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DataFormats/Parameters/src/GRPTool.cxx b/DataFormats/Parameters/src/GRPTool.cxx
index 903d659940558..e7561e6fc1ef6 100644
--- a/DataFormats/Parameters/src/GRPTool.cxx
+++ b/DataFormats/Parameters/src/GRPTool.cxx
@@ -312,7 +312,7 @@ bool create_GRPs(Options const& opts)
     auto soreor = ccdbmgr.getRunDuration(opts.run);
     runStart = soreor.first;
     grp.setTimeStart(runStart);
-    grp.setTimeEnd(runStart + 3600000);
+    grp.setTimeEnd(soreor.second);
     grp.setNHBFPerTF(opts.orbitsPerTF);
     std::vector<std::string> modules{};
     if (!o2::conf::SimConfig::determineActiveModulesList(opts.detectorList, opts.readout, std::vector<std::string>(), modules)) {

From 5a67c14095d08f65cec1988faf7a83fe9a08b8ee Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 22 Nov 2025 09:00:04 +0100
Subject: [PATCH 1053/1764] DPL: add test for MessageSet (#14838)

Propaedeutic to the API changes needed to anticipate forwarding.
---
 Framework/Core/CMakeLists.txt           |  1 +
 Framework/Core/test/test_MessageSet.cxx | 95 +++++++++++++++++++++++++
 2 files changed, 96 insertions(+)
 create mode 100644 Framework/Core/test/test_MessageSet.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 1aed1f776b775..cefb903c29895 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -237,6 +237,7 @@ add_executable(o2-test-framework-core
               test/test_InputSpec.cxx
               test/test_LogParsingHelpers.cxx
               test/test_Mermaid.cxx
+              test/test_MessageSet.cxx
               test/test_OptionsHelpers.cxx
               test/test_OverrideLabels.cxx
               test/test_O2DataModelHelpers.cxx
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
new file mode 100644
index 0000000000000..373cd7c8e5115
--- /dev/null
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -0,0 +1,95 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <fairmq/Message.h>
+#include "Framework/MessageSet.h"
+#include <catch_amalgamated.hpp>
+
+using namespace o2::framework;
+
+TEST_CASE("MessageSet") {
+  o2::framework::MessageSet msgSet;
+  std::vector<fair::mq::MessagePtr> ptrs;
+  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  std::unique_ptr<fair::mq::Message> msg2(nullptr);
+  ptrs.emplace_back(std::move(msg));
+  ptrs.emplace_back(std::move(msg2));
+  msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
+
+  REQUIRE(msgSet.messages.size() == 2);
+  REQUIRE(msgSet.messageMap.size() == 1);
+  REQUIRE(msgSet.pairMap.size() == 1);
+  REQUIRE(msgSet.messageMap[0].position == 0);
+  REQUIRE(msgSet.messageMap[0].size == 1);
+
+  REQUIRE(msgSet.pairMap[0].partIndex == 0);
+  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
+}
+
+TEST_CASE("MessageSetWithFunction") {
+  std::vector<fair::mq::MessagePtr> ptrs;
+  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  std::unique_ptr<fair::mq::Message> msg2(nullptr);
+  ptrs.emplace_back(std::move(msg));
+  ptrs.emplace_back(std::move(msg2));
+  o2::framework::MessageSet msgSet([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
+
+  REQUIRE(msgSet.messages.size() == 2);
+  REQUIRE(msgSet.messageMap.size() == 1);
+  REQUIRE(msgSet.pairMap.size() == 1);
+  REQUIRE(msgSet.messageMap[0].position == 0);
+  REQUIRE(msgSet.messageMap[0].size == 1);
+
+  REQUIRE(msgSet.pairMap[0].partIndex == 0);
+  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
+}
+
+TEST_CASE("MessageSetWithMultipart") {
+  std::vector<fair::mq::MessagePtr> ptrs;
+  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  std::unique_ptr<fair::mq::Message> msg2(nullptr);
+  std::unique_ptr<fair::mq::Message> msg3(nullptr);
+  ptrs.emplace_back(std::move(msg));
+  ptrs.emplace_back(std::move(msg2));
+  ptrs.emplace_back(std::move(msg3));
+  o2::framework::MessageSet msgSet([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 3);
+
+  REQUIRE(msgSet.messages.size() == 3);
+  REQUIRE(msgSet.messageMap.size() == 1);
+  REQUIRE(msgSet.pairMap.size() == 2);
+  REQUIRE(msgSet.messageMap[0].position == 0);
+  REQUIRE(msgSet.messageMap[0].size == 2);
+
+  REQUIRE(msgSet.pairMap[0].partIndex == 0);
+  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
+  REQUIRE(msgSet.pairMap[1].partIndex == 0);
+  REQUIRE(msgSet.pairMap[1].payloadIndex == 1);
+}
+
+TEST_CASE("MessageSetAddPartRef") {
+  std::vector<fair::mq::MessagePtr> ptrs;
+  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  std::unique_ptr<fair::mq::Message> msg2(nullptr);
+  ptrs.emplace_back(std::move(msg));
+  ptrs.emplace_back(std::move(msg2));
+  PartRef ref {std::move(msg), std::move(msg2)};
+  o2::framework::MessageSet msgSet;
+  msgSet.add(std::move(ref));
+
+  REQUIRE(msgSet.messages.size() == 2);
+  REQUIRE(msgSet.messageMap.size() == 1);
+  REQUIRE(msgSet.pairMap.size() == 1);
+  REQUIRE(msgSet.messageMap[0].position == 0);
+  REQUIRE(msgSet.messageMap[0].size == 1);
+
+  REQUIRE(msgSet.pairMap[0].partIndex == 0);
+  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
+}

From 388c823e90f57de653dfe1f462f99c6adf8350a8 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 22 Nov 2025 09:00:44 +0100
Subject: [PATCH 1054/1764] DPL Analysis: increase default shared memory offer
 per reader (#14840)

---
 Framework/Core/src/ArrowSupport.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 1480a64b6fcc2..4150fda9f63f1 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -565,7 +565,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        if (dc.options.count("aod-memory-rate-limit") && dc.options["aod-memory-rate-limit"].defaulted() == false) {
                          config->maxMemory = std::stoll(dc.options["aod-memory-rate-limit"].as<std::string>()) / 1000000;
                        } else {
-                         config->maxMemory = readers * 500;
+                         config->maxMemory = readers * 2000;
                        }
                        if (dc.options.count("timeframes-rate-limit") && dc.options["timeframes-rate-limit"].defaulted() == false) {
                          config->maxTimeframes = std::stoll(dc.options["timeframes-rate-limit"].as<std::string>());

From 8599750dfc3343080b316c23f72d979bce898a15 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Fri, 21 Nov 2025 23:30:55 +0100
Subject: [PATCH 1055/1764] o2-sim: Better error handling in req-rep
 communication in status channel

---
 run/O2PrimaryServerDevice.h | 30 ++++++++++++++++++++++--------
 run/O2SimDevice.h           |  4 ++--
 2 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/run/O2PrimaryServerDevice.h b/run/O2PrimaryServerDevice.h
index 4eecf79cffdb6..0c09c2105f403 100644
--- a/run/O2PrimaryServerDevice.h
+++ b/run/O2PrimaryServerDevice.h
@@ -251,30 +251,42 @@ class O2PrimaryServerDevice final : public fair::mq::Device
   void launchInfoThread()
   {
     static std::vector<std::thread> threads;
+
+    auto sendErrorReply = [](fair::mq::Channel& channel) {
+      LOG(error) << "UNKNOWN REQUEST";
+      std::unique_ptr<fair::mq::Message> reply(channel.NewSimpleMessage((int)(404)));
+      channel.Send(reply);
+    };
+
     LOG(info) << "LAUNCHING STATUS THREAD";
-    auto lambda = [this]() {
+    auto lambda = [this, sendErrorReply]() {
       while (mState != O2PrimaryServerState::Stopped) {
         auto& channel = GetChannels().at("o2sim-primserv-info").at(0);
         if (!channel.IsValid()) {
           LOG(error) << "channel primserv-info not valid";
         }
-        std::unique_ptr<fair::mq::Message> request(channel.NewSimpleMessage(-1));
+        std::unique_ptr<fair::mq::Message> request(channel.NewSimpleMessage((int)(-1)));
         int timeout = 100; // 100ms --> so as not to block and allow for proper termination of this thread
         if (channel.Receive(request, timeout) > 0) {
-          LOG(info) << "INFO REQUEST RECEIVED";
-          if (*(int*)(request->GetData()) == (int)O2PrimaryServerInfoRequest::Status) {
+          int request_payload; // we expect an (int) ~ to type O2PrimaryServerInfoRequest
+          if (request->GetSize() != sizeof(request_payload)) {
+            LOG(error) << "Obtained request with unexpected payload size";
+            sendErrorReply(channel); // ALWAYS reply
+          }
+
+          memcpy(&request_payload, request->GetData(), sizeof(request_payload));
+
+          if (request_payload == (int)O2PrimaryServerInfoRequest::Status) {
             LOG(info) << "Received status request";
             // request needs to be a simple enum of type O2PrimaryServerInfoRequest
             std::unique_ptr<fair::mq::Message> reply(channel.NewSimpleMessage((int)mState.load()));
             if (channel.Send(reply) > 0) {
               LOG(info) << "Send status successful";
             }
-          } else if (*(int*)request->GetData() == (int)O2PrimaryServerInfoRequest::Config) {
+          } else if (request_payload == (int)O2PrimaryServerInfoRequest::Config) {
             HandleConfigRequest(channel);
           } else {
-            LOG(fatal) << "UNKNOWN REQUEST";
-            std::unique_ptr<fair::mq::Message> reply(channel.NewSimpleMessage(404));
-            channel.Send(reply);
+            sendErrorReply(channel);
           }
         }
       }
@@ -450,6 +462,8 @@ class O2PrimaryServerDevice final : public fair::mq::Device
     if (channel.Send(message) > 0) {
       LOG(info) << "config reply send ";
       return true;
+    } else {
+      LOG(error) << "Failure sending config reply ";
     }
     return true;
   }
diff --git a/run/O2SimDevice.h b/run/O2SimDevice.h
index 07f7e9f82e249..35a0c31986702 100644
--- a/run/O2SimDevice.h
+++ b/run/O2SimDevice.h
@@ -98,7 +98,7 @@ class O2SimDevice final : public fair::mq::Device
     // auto text = new std::string("configrequest");
     // std::unique_ptr<fair::mq::Message> request(channel.NewMessage(const_cast<char*>(text->c_str()),
     //                                                           text->length(), CustomCleanup, text));
-    std::unique_ptr<fair::mq::Message> request(channel.NewSimpleMessage(O2PrimaryServerInfoRequest::Config));
+    std::unique_ptr<fair::mq::Message> request(channel.NewSimpleMessage((int)O2PrimaryServerInfoRequest::Config));
     std::unique_ptr<fair::mq::Message> reply(channel.NewMessage());
 
     int timeoutinMS = 60000; // wait for 60s max --> should be fast reply
@@ -164,7 +164,7 @@ class O2SimDevice final : public fair::mq::Device
     while (reprobe) {
       reprobe = false;
       int i = -1;
-      fair::mq::MessagePtr request(statuschannel.NewSimpleMessage(O2PrimaryServerInfoRequest::Status));
+      fair::mq::MessagePtr request(statuschannel.NewSimpleMessage((int)O2PrimaryServerInfoRequest::Status));
       fair::mq::MessagePtr reply(statuschannel.NewSimpleMessage(i));
       auto sendcode = statuschannel.Send(request, timeoutinMS);
       if (sendcode > 0) {

From 5e0206e0fb9e9aedf30c751b3e5bbb521afda5f1 Mon Sep 17 00:00:00 2001
From: Diego Stocco <dstocco@users.noreply.github.com>
Date: Sat, 22 Nov 2025 19:04:58 +0100
Subject: [PATCH 1056/1764] Set proper EOR to anchored MC GRPECS (#14843)

---
 macro/o2sim.C | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/macro/o2sim.C b/macro/o2sim.C
index 7d5faa544249c..fd44de6e93b54 100644
--- a/macro/o2sim.C
+++ b/macro/o2sim.C
@@ -69,6 +69,7 @@ FairRunSim* o2sim_init(bool asservice, bool evalmat = false)
   auto& ccdbmgr = o2::ccdb::BasicCCDBManager::instance();
   // fix the timestamp early
   uint64_t timestamp = confref.getTimestamp();
+  uint64_t runEnd = timestamp + 3600000;
   // see if we have a run number but not a timestamp
   auto run_number = confref.getRunNumber();
   if (run_number != -1) {
@@ -77,6 +78,7 @@ FairRunSim* o2sim_init(bool asservice, bool evalmat = false)
       auto [sor, eor] = ccdbmgr.getRunDuration(run_number);
       LOG(info) << "Have run number. Fixing timestamp to " << sor;
       timestamp = sor;
+      runEnd = eor;
     }
   }
 
@@ -189,7 +191,7 @@ FairRunSim* o2sim_init(bool asservice, bool evalmat = false)
     }
     uint64_t runStart = timestamp;
     grp.setTimeStart(runStart);
-    grp.setTimeEnd(runStart + 3600000);
+    grp.setTimeEnd(runEnd);
     grp.setDetsReadOut(readoutDetMask);
     // CTP is not a physical detector, just flag in the GRP if requested
     if (isReadout("CTP")) {
@@ -216,7 +218,7 @@ FairRunSim* o2sim_init(bool asservice, bool evalmat = false)
     o2::parameters::GRPECSObject grp;
     grp.setRun(run->GetRunId());
     grp.setTimeStart(runStart);
-    grp.setTimeEnd(runStart + 3600000);
+    grp.setTimeEnd(runEnd);
     grp.setNHBFPerTF(128); // might be overridden later
     grp.setDetsReadOut(readoutDetMask);
     if (isReadout("CTP")) {

From 0b946d92d14b6269dac48a560b5d269945dd8939 Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Sun, 23 Nov 2025 02:18:34 +0100
Subject: [PATCH 1057/1764] Add DPG code to special ITS output (#14844)

---
 Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 93b15a6e6650d..cf04c7c653e40 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -1366,7 +1366,7 @@ void TrackMCStudy::processITSTracks(const o2::globaltracking::RecoContainer& rec
         hinf.trefYT = traY;
       }
     }
-    (*mDBGOut) << "itsTree" << "hits=" << outHitInfo << "trIn=" << ((o2::track::TrackParCov&)itsTr) << "trOut=" << itsTr.getParamOut() << "mcTr=" << entrySel->second.mcTrackInfo.track << "nTrefs=" << nrefAcc << "\n";
+    (*mDBGOut) << "itsTree" << "hits=" << outHitInfo << "trIn=" << ((o2::track::TrackParCov&)itsTr) << "trOut=" << itsTr.getParamOut() << "mcTr=" << entrySel->second.mcTrackInfo.track << "mcPDG=" << entrySel->second.mcTrackInfo.pdg << "nTrefs=" << nrefAcc << "\n";
   }
 }
 

From 650f5f5e9a5bd94ea64f8daa36de407020c894fc Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Sun, 23 Nov 2025 17:10:33 +0100
Subject: [PATCH 1058/1764] Stability improvement for o2-sim startup

Fixing a zeromq communication problem when the O2PrimaryServerDevice
is too fast and quitting before O2HitMerge is even initialized. This can
happen rarely, for instance when startup needs long due to CVMFS latency.

This situation is now avoided by waiting for the permission to shutdown.
The permission is given by O2HitMerger once the system is up and running (first
actual hits have been received).

Some minor cleanup (comment removal) in addition.
---
 run/O2HitMerger.h           | 37 +++++++++++++++++++++++++++++++++----
 run/O2PrimaryServerDevice.h | 19 ++++++++++++++-----
 run/O2SimDevice.h           |  3 ---
 run/PrimaryServerState.h    |  7 ++++---
 4 files changed, 51 insertions(+), 15 deletions(-)

diff --git a/run/O2HitMerger.h b/run/O2HitMerger.h
index d32f6370ca2db..30ddd57ba91da 100644
--- a/run/O2HitMerger.h
+++ b/run/O2HitMerger.h
@@ -88,6 +88,29 @@ namespace o2
 namespace devices
 {
 
+// Function communicating to primary particle server that it is now safe to shutdown.
+// From the perspective of o2-sim, this is the case when all configs have been propagated and the system
+// is running ok: For instance after the HitMerger is initialized and got it's first data from Geant workers.
+bool primaryServer_sendShutdownPermission(fair::mq::Channel& channel)
+{
+  std::unique_ptr<fair::mq::Message> request(channel.NewSimpleMessage((int)o2::O2PrimaryServerInfoRequest::AllowShutdown));
+  std::unique_ptr<fair::mq::Message> reply(channel.NewMessage());
+
+  int timeoutinMS = 100;
+  if (channel.Send(request, timeoutinMS) > 0) {
+    LOG(info) << "Sending Shutdown permission to particle server";
+    if (channel.Receive(reply, timeoutinMS) > 0) {
+      // the answer is a simple ack with a status code
+      LOG(info) << "Shutdown permission was acknowledged";
+    } else {
+      LOG(error) << "No answer received within " << timeoutinMS << "ms\n";
+      return false;
+    }
+    return true;
+  }
+  return false;
+}
+
 class O2HitMerger : public fair::mq::Device
 {
 
@@ -129,6 +152,9 @@ class O2HitMerger : public fair::mq::Device
     if (o2::devices::O2SimDevice::querySimConfig(GetChannels().at("o2sim-primserv-info").at(0))) {
       outfilename = o2::base::NameConf::getMCKinematicsFileName(o2::conf::SimConfig::Instance().getOutPrefix().c_str());
       mNExpectedEvents = o2::conf::SimConfig::Instance().getNEvents();
+    } else {
+      // we didn't manage to get a configuration --> better to fail
+      LOG(fatal) << "No configuration received. Aborting";
     }
     mAsService = o2::conf::SimConfig::Instance().asService();
     mForwardKine = o2::conf::SimConfig::Instance().forwardKine();
@@ -354,6 +380,13 @@ class O2HitMerger : public fair::mq::Device
       // for the next batch
       return waitForControlInput();
     }
+
+    static bool initAcknowledged = false;
+    if (!initAcknowledged) {
+      primaryServer_sendShutdownPermission(GetChannels().at("o2sim-primserv-info").at(0));
+      initAcknowledged = true;
+    }
+
     return more;
   }
 
@@ -413,10 +446,6 @@ class O2HitMerger : public fair::mq::Device
         };
       }
     }
-    if (!expectmore) {
-      // somehow FairMQ has difficulties shutting down; helping manually
-      // raise(SIGINT);
-    }
     return expectmore;
   }
 
diff --git a/run/O2PrimaryServerDevice.h b/run/O2PrimaryServerDevice.h
index 0c09c2105f403..b8703ffcddb28 100644
--- a/run/O2PrimaryServerDevice.h
+++ b/run/O2PrimaryServerDevice.h
@@ -247,11 +247,10 @@ class O2PrimaryServerDevice final : public fair::mq::Device
     }
   }
 
-  // launches a thread that listens for status requests from outside asynchronously
+  // launches a thread that listens for status/config/shutdown requests from outside asynchronously
   void launchInfoThread()
   {
     static std::vector<std::thread> threads;
-
     auto sendErrorReply = [](fair::mq::Channel& channel) {
       LOG(error) << "UNKNOWN REQUEST";
       std::unique_ptr<fair::mq::Message> reply(channel.NewSimpleMessage((int)(404)));
@@ -260,7 +259,9 @@ class O2PrimaryServerDevice final : public fair::mq::Device
 
     LOG(info) << "LAUNCHING STATUS THREAD";
     auto lambda = [this, sendErrorReply]() {
-      while (mState != O2PrimaryServerState::Stopped) {
+      bool canShutdown{false};
+      // Exit only when both: serving stopped and allowed from outside.
+      while (!(mState == O2PrimaryServerState::Stopped && canShutdown)) {
         auto& channel = GetChannels().at("o2sim-primserv-info").at(0);
         if (!channel.IsValid()) {
           LOG(error) << "channel primserv-info not valid";
@@ -285,6 +286,11 @@ class O2PrimaryServerDevice final : public fair::mq::Device
             }
           } else if (request_payload == (int)O2PrimaryServerInfoRequest::Config) {
             HandleConfigRequest(channel);
+          } else if (request_payload == (int)O2PrimaryServerInfoRequest::AllowShutdown) {
+            LOG(info) << "Got info that we may shutdown";
+            std::unique_ptr<fair::mq::Message> ack(channel.NewSimpleMessage(200));
+            channel.Send(ack);
+            canShutdown = true;
           } else {
             sendErrorReply(channel);
           }
@@ -518,10 +524,13 @@ class O2PrimaryServerDevice final : public fair::mq::Device
 
   void PostRun() override
   {
+    // We shouldn't shut down immediately when all events have been served
+    // Instead we also need to wait until the info thread running some communication server
+    // with other processes is finished.
     while (!mInfoThreadStopped) {
       LOG(info) << "Waiting info thread";
       using namespace std::chrono_literals;
-      std::this_thread::sleep_for(100ms);
+      std::this_thread::sleep_for(1000ms);
     }
   }
 
@@ -534,7 +543,7 @@ class O2PrimaryServerDevice final : public fair::mq::Device
     if (mEventCounter >= mMaxEvents && mNeedNewEvent) {
       workavailable = false;
     }
-    if (!(mState == O2PrimaryServerState::ReadyToServe || mState == O2PrimaryServerState::WaitingEvent)) {
+    if (!(mState.load() == O2PrimaryServerState::ReadyToServe || mState.load() == O2PrimaryServerState::WaitingEvent)) {
       // send a zero answer
       workavailable = false;
     }
diff --git a/run/O2SimDevice.h b/run/O2SimDevice.h
index 35a0c31986702..9256734cce487 100644
--- a/run/O2SimDevice.h
+++ b/run/O2SimDevice.h
@@ -95,9 +95,6 @@ class O2SimDevice final : public fair::mq::Device
   // returns true if successful / false if not
   static bool querySimConfig(fair::mq::Channel& channel)
   {
-    // auto text = new std::string("configrequest");
-    // std::unique_ptr<fair::mq::Message> request(channel.NewMessage(const_cast<char*>(text->c_str()),
-    //                                                           text->length(), CustomCleanup, text));
     std::unique_ptr<fair::mq::Message> request(channel.NewSimpleMessage((int)O2PrimaryServerInfoRequest::Config));
     std::unique_ptr<fair::mq::Message> reply(channel.NewMessage());
 
diff --git a/run/PrimaryServerState.h b/run/PrimaryServerState.h
index 5a15cca12b9b1..4bae1d566dc60 100644
--- a/run/PrimaryServerState.h
+++ b/run/PrimaryServerState.h
@@ -25,10 +25,11 @@ enum class O2PrimaryServerState {
 };
 static const char* PrimStateToString[5] = {"INIT", "SERVING", "WAITEVENT", "IDLE", "STOPPED"};
 
-/// enum class for type of info request
+/// enum class for request to o2sim-primserv-info channel of the O2PrimaryServerDevice
 enum class O2PrimaryServerInfoRequest {
-  Status = 1,
-  Config = 2
+  Status = 1,       // asks to retrieve current status of O2PrimaryServerDevice --> will send O2PrimaryServerState
+  Config = 2,       // asks for o2-sim config reply
+  AllowShutdown = 3 // can be used to let particle server know that shutdown is now safe (once all components initialized)
 };
 
 /// Struct to be used as payload when making a request

From 159cf6a39256c65d30144af4c414f4adbcf7a9c2 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Sun, 23 Nov 2025 17:45:37 +0100
Subject: [PATCH 1059/1764] o2-sim: Avoid duplicate printout of detector list

---
 Common/SimConfig/src/SimConfig.cxx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Common/SimConfig/src/SimConfig.cxx b/Common/SimConfig/src/SimConfig.cxx
index 2c28497fa4237..15879687872d5 100644
--- a/Common/SimConfig/src/SimConfig.cxx
+++ b/Common/SimConfig/src/SimConfig.cxx
@@ -200,7 +200,11 @@ bool SimConfig::determineActiveModulesList(const std::string& version, std::vect
       return false;
     }
     modules = map[version];
-    LOGP(info, "Running with official detector version '{}'", version);
+    static std::string last_version{}; // prevent multiple printouts of same message
+    if (last_version != version) {
+      LOGP(info, "Running with official detector version '{}'", version);
+      last_version = version;
+    }
   }
   // check if specified modules are in list
   if (inputargs.size() != 1 || inputargs[0] != "all") {

From 72b9f51aa41d1f70bbf8f7b162881472aa8c9042 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 24 Nov 2025 09:27:47 +0100
Subject: [PATCH 1060/1764] DPL: improve test (#14847)

---
 Framework/Core/test/test_MessageSet.cxx | 40 +++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index 373cd7c8e5115..d56e32fea1adb 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -93,3 +93,43 @@ TEST_CASE("MessageSetAddPartRef") {
   REQUIRE(msgSet.pairMap[0].partIndex == 0);
   REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
 }
+
+TEST_CASE("MessageSetAddMultiple")
+{
+  std::vector<fair::mq::MessagePtr> ptrs;
+  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  std::unique_ptr<fair::mq::Message> msg2(nullptr);
+  ptrs.emplace_back(std::move(msg));
+  ptrs.emplace_back(std::move(msg2));
+  PartRef ref{std::move(msg), std::move(msg2)};
+  o2::framework::MessageSet msgSet;
+  msgSet.add(std::move(ref));
+  PartRef ref2{std::move(msg), std::move(msg2)};
+  msgSet.add(std::move(ref2));
+  std::vector<fair::mq::MessagePtr> msgs;
+  msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
+  msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
+  msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
+  msgSet.add([&msgs](size_t i) {
+    return std::move(msgs[i]);
+  }, 3);
+
+  REQUIRE(msgSet.messages.size() == 7);
+  REQUIRE(msgSet.messageMap.size() == 3);
+  REQUIRE(msgSet.pairMap.size() == 4);
+  REQUIRE(msgSet.messageMap[0].position == 0);
+  REQUIRE(msgSet.messageMap[0].size == 1);
+  REQUIRE(msgSet.messageMap[1].position == 2);
+  REQUIRE(msgSet.messageMap[1].size == 1);
+  REQUIRE(msgSet.messageMap[2].position == 4);
+  REQUIRE(msgSet.messageMap[2].size == 2);
+
+  REQUIRE(msgSet.pairMap[0].partIndex == 0);
+  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
+  REQUIRE(msgSet.pairMap[1].partIndex == 1);
+  REQUIRE(msgSet.pairMap[1].payloadIndex == 0);
+  REQUIRE(msgSet.pairMap[2].partIndex == 2);
+  REQUIRE(msgSet.pairMap[2].payloadIndex == 0);
+  REQUIRE(msgSet.pairMap[3].partIndex == 2);
+  REQUIRE(msgSet.pairMap[3].payloadIndex == 1);
+}

From 0fb4692e490f01d0d2e9939ac996f2acea41cdba Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 24 Nov 2025 20:34:25 +0100
Subject: [PATCH 1061/1764] Exercise CalArray<PadFlags> loading in a TPC unit
 test

This makes it easy to valgrind the process.
It seems that despite the custom streamer, there are still sporadic segfaults
when exercising DeadChannelMapCreator::loadIDCPadFlags (at least on ARM64).
---
 Detectors/TPC/base/test/testTPCCalDet.cxx | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Detectors/TPC/base/test/testTPCCalDet.cxx b/Detectors/TPC/base/test/testTPCCalDet.cxx
index b93e952084396..fda38c2d03e91 100644
--- a/Detectors/TPC/base/test/testTPCCalDet.cxx
+++ b/Detectors/TPC/base/test/testTPCCalDet.cxx
@@ -24,6 +24,7 @@
 #include "TPCBase/CalDet.h"
 #include "TFile.h"
 #include "Framework/TypeTraits.h"
+#include "TPCBase/DeadChannelMapCreator.h"
 
 namespace o2::tpc
 {
@@ -344,4 +345,12 @@ BOOST_AUTO_TEST_CASE(CalDetTypeTest)
   BOOST_CHECK(testDict == true);
 }
 
+BOOST_AUTO_TEST_CASE(CalDetStreamerTest)
+{
+  // simple code executing the TPC IDCPadFlags loading in a standalone env --> easy to valgrind
+  o2::tpc::DeadChannelMapCreator creator{};
+  creator.init("https://alice-ccdb.cern.ch");
+  creator.loadIDCPadFlags(1731274461770);
+}
+
 } // namespace o2::tpc

From 133c2ecf89afa068837bdefd61fd7be88029cf61 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Tue, 25 Nov 2025 14:47:50 +0100
Subject: [PATCH 1062/1764] CalDet<TPCPadFlags>: Protect against invalid reads

A continuation of the CalDet<TPCFlags> saga, possibly related
to https://its.cern.ch/jira/browse/O2-4671

Tests on ARM, even after deployment of the custom streamer
in https://github.com/AliceO2Group/AliceO2/pull/14830, still showed
segfaults in TPC digitization.

With the relevant code isolated into a unit test in
https://github.com/AliceO2Group/AliceO2/pull/14850, it was possible to
do a valgrind study. This showed Invalid reads to the mData of CalArray.

Thereafter, putting assert statements showed that we often access
CalArray<PadFlags> data slightly out of bounds - irrespective of custom
streamer or not. This then either indicates a problem in the code logic
or a problem with the calibration CCDB objects. This should clearly be
fixed.

In the meantime, this commit adds a protection against invalid accesses
and returns a trivial answer as well as an error message. This is in any
case better than undefined behaviour.

In addition, this commit introduces possibility to switch off the custom
streamer for further studies.
---
 Detectors/TPC/base/include/TPCBase/CalArray.h | 11 +++++++-
 Detectors/TPC/base/include/TPCBase/CalDet.h   | 27 ++++++++++++++++++-
 .../base/src/TPCFlagsMemberCustomStreamer.cxx |  4 ++-
 3 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/Detectors/TPC/base/include/TPCBase/CalArray.h b/Detectors/TPC/base/include/TPCBase/CalArray.h
index 2679eae4e706e..c0d5a14bd86de 100644
--- a/Detectors/TPC/base/include/TPCBase/CalArray.h
+++ b/Detectors/TPC/base/include/TPCBase/CalArray.h
@@ -26,6 +26,11 @@
 #include <boost/format.hpp>
 #endif
 
+#ifdef NDEBUG
+#undef NDEBUG
+#include <cassert>
+#endif
+
 namespace o2
 {
 namespace tpc
@@ -93,7 +98,11 @@ class CalArray
   int getPadSubsetNumber() const { return mPadSubsetNumber; }
 
   void setValue(const size_t channel, const T& value) { mData[channel] = value; }
-  const T getValue(const size_t channel) const { return mData[channel]; }
+  const T getValue(const size_t channel) const
+  {
+    assert(channel < mData.size());
+    return mData[channel];
+  }
 
   void setValue(const size_t row, const size_t pad, const T& value);
   const T getValue(const size_t row, const size_t pad) const;
diff --git a/Detectors/TPC/base/include/TPCBase/CalDet.h b/Detectors/TPC/base/include/TPCBase/CalDet.h
index cab1bd5757f27..76bbeaf8bebd1 100644
--- a/Detectors/TPC/base/include/TPCBase/CalDet.h
+++ b/Detectors/TPC/base/include/TPCBase/CalDet.h
@@ -30,6 +30,12 @@
 #include "Rtypes.h"
 #endif
 
+#ifndef NDEBUG
+#undef NDEBUG
+// always enable assert
+#include <cassert>
+#endif
+
 namespace o2
 {
 namespace tpc
@@ -211,7 +217,26 @@ inline const T CalDet<T>::getValue(const ROC roc, const size_t row, const size_t
     }
     case PadSubset::Region: {
       const auto globalRow = roc.isOROC() ? mappedRow + mapper.getNumberOfRowsROC(ROC(0)) : mappedRow;
-      return mData[Mapper::REGION[globalRow] + roc.getSector() * Mapper::NREGIONS].getValue(Mapper::OFFSETCRUGLOBAL[globalRow] + mappedPad);
+      const auto dataRow = Mapper::REGION[globalRow] + roc.getSector() * Mapper::NREGIONS;
+      const auto index = Mapper::OFFSETCRUGLOBAL[globalRow] + mappedPad;
+      assert(dataRow < mData.size());
+      if (index >= mData[dataRow].getData().size()) {
+        // S. Wenzel: We shouldn't come here but we do. For instance for CalDet calibrations loaded from
+        // creator.loadIDCPadFlags(1731274461770);
+
+        // In this case there is an index overflow, leading to invalid reads and potentially a segfault.
+        // To increase stability, for now returning a trivial answer. This can be removed once either the algorithm
+        // or the calibration data has been fixed.
+#ifndef GPUCA_ALIGPUCODE // hide from GPU standalone compilation
+        static bool printMsg = true;
+        if (printMsg) {
+          LOG(error) << "Out of bound access in TPC CalDet ROC " << roc << " row " << row << " pad " << pad << " (no more messages printed)";
+        }
+        printMsg = false;
+#endif
+        return T{};
+      }
+      return mData[dataRow].getValue(index);
       break;
     }
   }
diff --git a/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx b/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
index 1dfb775a14aaa..7e3499dec14d9 100644
--- a/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
+++ b/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
@@ -69,7 +69,9 @@ static __attribute__((used)) int _R__dummyStreamer_3 =
   ([]() {
     auto cl = TClass::GetClass<o2::tpc::CalArray<o2::tpc::PadFlags>>();
     if (cl) {
-      cl->AdoptMemberStreamer("mData", new TMemberStreamer(MemberVectorPadFlagsStreamer));
+      if (!getenv("TPC_PADFLAGS_STREAMER_OFF")) {
+        cl->AdoptMemberStreamer("mData", new TMemberStreamer(MemberVectorPadFlagsStreamer));
+      }
     } else {
       // we should never come here ... and if we do we should assert/fail
       assert(false);

From a8e80c1ad179e12a0c7a0528ecd746ab863b4192 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 25 Nov 2025 07:28:58 +0100
Subject: [PATCH 1063/1764] GPU Vulkan Display: Device layers are deprecated

---
 GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx | 2 --
 1 file changed, 2 deletions(-)

diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
index 0c2af55121b7d..a1bee6ce47ebd 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
@@ -481,8 +481,6 @@ void GPUDisplayBackendVulkan::createDevice()
   deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
   deviceCreateInfo.enabledExtensionCount = static_cast<uint32_t>(reqDeviceExtensions.size());
   deviceCreateInfo.ppEnabledExtensionNames = reqDeviceExtensions.data();
-  deviceCreateInfo.enabledLayerCount = instanceCreateInfo.enabledLayerCount;
-  deviceCreateInfo.ppEnabledLayerNames = instanceCreateInfo.ppEnabledLayerNames;
   mDevice = mPhysicalDevice.createDevice(deviceCreateInfo, nullptr);
   VULKAN_HPP_DEFAULT_DISPATCHER.init(mDevice);
   mGraphicsQueue = mDevice.getQueue(mGraphicsFamily, 0);

From f9d9c0f57458dcccc79e3847b38dbec4dda33422 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 26 Nov 2025 14:54:30 +0100
Subject: [PATCH 1064/1764] DPL Analysis: rework of aod-spawner and
 aod-index-builder (#14854)

---
 Framework/AnalysisSupport/CMakeLists.txt      |   6 +
 .../AnalysisSupport/src/AODReaderHelpers.cxx  | 206 +++++++++
 .../src}/AODReaderHelpers.h                   |   3 +-
 .../AnalysisSupport/src/OnDemandPlugin.cxx    |  32 ++
 Framework/Core/CMakeLists.txt                 |   4 +-
 Framework/Core/include/Framework/ASoA.h       |  89 ++--
 .../Core/include/Framework/AnalysisHelpers.h  | 413 +++++++++++-------
 .../Core/include/Framework/AnalysisManagers.h |  33 +-
 Framework/Core/include/Framework/ArrowTypes.h |  50 +++
 .../Core/include/Framework/Expressions.h      |   2 +
 .../include/Framework/IndexBuilderHelpers.h   | 158 +++----
 .../Core/include/Framework/TableBuilder.h     |  89 +---
 Framework/Core/src/AODReaderHelpers.cxx       | 280 ------------
 Framework/Core/src/AnalysisHelpers.cxx        | 177 +++++++-
 Framework/Core/src/AnalysisSupportHelpers.cxx |   1 -
 Framework/Core/src/ArrowSupport.cxx           |   5 +-
 Framework/Core/src/ExpressionJSONHelpers.cxx  |  57 ++-
 Framework/Core/src/Expressions.cxx            |  16 +
 Framework/Core/src/IndexBuilderHelpers.cxx    | 363 ++++++++++-----
 Framework/Core/src/IndexJSONHelpers.cxx       | 230 ++++++++++
 Framework/Core/src/IndexJSONHelpers.h         |  25 ++
 Framework/Core/src/TableBuilder.cxx           |  89 +---
 Framework/Core/src/WorkflowHelpers.cxx        |   5 +-
 Framework/Core/test/test_Expressions.cxx      |  29 ++
 Framework/Core/test/test_IndexBuilder.cxx     |  56 ++-
 25 files changed, 1507 insertions(+), 911 deletions(-)
 create mode 100644 Framework/AnalysisSupport/src/AODReaderHelpers.cxx
 rename Framework/{Core/include/Framework => AnalysisSupport/src}/AODReaderHelpers.h (92%)
 create mode 100644 Framework/AnalysisSupport/src/OnDemandPlugin.cxx
 delete mode 100644 Framework/Core/src/AODReaderHelpers.cxx
 create mode 100644 Framework/Core/src/IndexJSONHelpers.cxx
 create mode 100644 Framework/Core/src/IndexJSONHelpers.h

diff --git a/Framework/AnalysisSupport/CMakeLists.txt b/Framework/AnalysisSupport/CMakeLists.txt
index 92fd55b86a33d..6024134a5495d 100644
--- a/Framework/AnalysisSupport/CMakeLists.txt
+++ b/Framework/AnalysisSupport/CMakeLists.txt
@@ -16,6 +16,12 @@ if(TARGET JAliEn::JAliEn)
   set(EXTRA_TARGETS XRootD::Client JAliEn::JAliEn)
 endif()
 
+o2_add_library(FrameworkOnDemandTablesSupport
+               SOURCES src/OnDemandPlugin.cxx
+                       src/AODReaderHelpers.cxx
+               PRIVATE_INCLUDE_DIRECTORIES ${CMAKE_CURRENT_LIST_DIR}/src
+               PUBLIC_LINK_LIBRARIES O2::Framework ${EXTRA_TARGETS})
+
 o2_add_library(FrameworkAnalysisSupport
                SOURCES src/Plugin.cxx
                        src/DataInputDirector.cxx
diff --git a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
new file mode 100644
index 0000000000000..40aa5a9537c7f
--- /dev/null
+++ b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
@@ -0,0 +1,206 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "AODReaderHelpers.h"
+#include "../src/ExpressionJSONHelpers.h"
+#include "../src/IndexJSONHelpers.h"
+
+#include "Framework/AnalysisDataModel.h"
+#include "Framework/AnalysisHelpers.h"
+#include "Framework/DataProcessingHelpers.h"
+#include "Framework/AlgorithmSpec.h"
+#include "Framework/DataSpecUtils.h"
+#include "Framework/ConfigContext.h"
+#include "Framework/AnalysisContext.h"
+
+namespace o2::framework::readers
+{
+namespace
+{
+struct Buildable {
+  bool exclusive = false;
+  std::string binding;
+  std::vector<std::string> labels;
+  header::DataOrigin origin;
+  header::DataDescription description;
+  header::DataHeader::SubSpecificationType version;
+  std::vector<o2::soa::IndexRecord> records;
+  std::shared_ptr<arrow::Schema> outputSchema;
+
+  Buildable(InputSpec const& spec)
+    : binding{spec.binding}
+  {
+    auto&& [origin_, description_, version_] = DataSpecUtils::asConcreteDataMatcher(spec);
+    origin = origin_;
+    description = description_;
+    version = version_;
+
+    auto loc = std::find_if(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& cps) { return cps.name.compare("index-records") == 0; });
+    std::stringstream iws(loc->defaultValue.get<std::string>());
+    records = IndexJSONHelpers::read(iws);
+
+    loc = std::find_if(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& cps) { return cps.name.compare("index-exclusive") == 0; });
+    exclusive = loc->defaultValue.get<bool>();
+
+    for (auto const& r : records) {
+      labels.emplace_back(r.label);
+    }
+    outputSchema = std::make_shared<arrow::Schema>([](std::vector<o2::soa::IndexRecord> const& recs) {
+                     std::vector<std::shared_ptr<arrow::Field>> fields;
+                     for (auto& r : recs) {
+                       fields.push_back(r.field());
+                     }
+                     return fields;
+                   }(records))
+                     ->WithMetadata(std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{std::string{binding}}));
+  }
+
+  framework::Builder createBuilder() const
+  {
+    return {
+      exclusive,
+      labels,
+      records,
+      outputSchema,
+      origin,
+      description,
+      version,
+      nullptr};
+  }
+};
+
+} // namespace
+
+AlgorithmSpec AODReaderHelpers::indexBuilderCallback(ConfigContext const& ctx)
+{
+  auto& ac = ctx.services().get<AnalysisContext>();
+  return AlgorithmSpec::InitCallback{[requested = ac.requestedIDXs](InitContext& /*ic*/) {
+    std::vector<Buildable> buildables;
+    for (auto& i : requested) {
+      buildables.emplace_back(i);
+    }
+    std::vector<Builder> builders;
+    for (auto& b : buildables) {
+      builders.push_back(b.createBuilder());
+    }
+    return [builders](ProcessingContext& pc) mutable {
+      auto outputs = pc.outputs();
+      for (auto& builder : builders) {
+        outputs.adopt(Output{builder.origin, builder.description, builder.version}, builder.materialize(pc));
+      }
+    };
+  }};
+}
+
+namespace
+{
+struct Spawnable {
+  std::string binding;
+  std::vector<std::string> labels;
+  std::vector<expressions::Projector> projectors;
+  std::vector<std::shared_ptr<gandiva::Expression>> expressions;
+  std::shared_ptr<arrow::Schema> outputSchema;
+  std::shared_ptr<arrow::Schema> inputSchema;
+
+  header::DataOrigin origin;
+  header::DataDescription description;
+  header::DataHeader::SubSpecificationType version;
+
+  Spawnable(InputSpec const& spec)
+    : binding{spec.binding}
+  {
+    auto&& [origin_, description_, version_] = DataSpecUtils::asConcreteDataMatcher(spec);
+    origin = origin_;
+    description = description_;
+    version = version_;
+    auto loc = std::find_if(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& cps) { return cps.name.compare("projectors") == 0; });
+    std::stringstream iws(loc->defaultValue.get<std::string>());
+    projectors = ExpressionJSONHelpers::read(iws);
+
+    loc = std::find_if(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& cps) { return cps.name.compare("schema") == 0; });
+    iws.clear();
+    iws.str(loc->defaultValue.get<std::string>());
+    outputSchema = ArrowJSONHelpers::read(iws);
+    o2::framework::addLabelToSchema(outputSchema, binding.c_str());
+
+    std::vector<std::shared_ptr<arrow::Schema>> schemas;
+    for (auto& i : spec.metadata) {
+      if (i.name.starts_with("input-schema:")) {
+        labels.emplace_back(i.name.substr(13));
+        iws.clear();
+        auto json = i.defaultValue.get<std::string>();
+        iws.str(json);
+        schemas.emplace_back(ArrowJSONHelpers::read(iws));
+      }
+    }
+
+    std::vector<std::shared_ptr<arrow::Field>> fields;
+    for (auto& s : schemas) {
+      std::copy(s->fields().begin(), s->fields().end(), std::back_inserter(fields));
+    }
+
+    inputSchema = std::make_shared<arrow::Schema>(fields);
+    expressions = expressions::materializeProjectors(projectors, inputSchema, outputSchema->fields());
+  }
+
+  std::shared_ptr<gandiva::Projector> makeProjector() const
+  {
+    std::shared_ptr<gandiva::Projector> p = nullptr;
+    auto s = gandiva::Projector::Make(
+      inputSchema,
+      expressions,
+      &p);
+    if (!s.ok()) {
+      throw o2::framework::runtime_error_f("Failed to create projector: %s", s.ToString().c_str());
+    }
+    return p;
+  }
+
+  framework::Spawner createMaker() const
+  {
+    return {
+      binding,
+      labels,
+      expressions,
+      makeProjector(),
+      outputSchema,
+      inputSchema,
+      origin,
+      description,
+      version};
+  }
+};
+
+} // namespace
+
+AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(ConfigContext const& ctx)
+{
+  auto& ac = ctx.services().get<AnalysisContext>();
+  return AlgorithmSpec::InitCallback{[requested = ac.spawnerInputs](InitContext& /*ic*/) {
+    std::vector<Spawnable> spawnables;
+    for (auto& i : requested) {
+      spawnables.emplace_back(i);
+    }
+    std::vector<Spawner> spawners;
+    for (auto& s : spawnables) {
+      spawners.push_back(s.createMaker());
+    }
+
+    return [spawners](ProcessingContext& pc) mutable {
+      auto outputs = pc.outputs();
+      for (auto& spawner : spawners) {
+        outputs.adopt(Output{spawner.origin, spawner.description, spawner.version}, spawner.materialize(pc));
+      }
+    };
+  }};
+}
+
+} // namespace o2::framework::readers
diff --git a/Framework/Core/include/Framework/AODReaderHelpers.h b/Framework/AnalysisSupport/src/AODReaderHelpers.h
similarity index 92%
rename from Framework/Core/include/Framework/AODReaderHelpers.h
rename to Framework/AnalysisSupport/src/AODReaderHelpers.h
index 800d26c2aeae0..197907ca3ccb1 100644
--- a/Framework/Core/include/Framework/AODReaderHelpers.h
+++ b/Framework/AnalysisSupport/src/AODReaderHelpers.h
@@ -18,11 +18,10 @@
 namespace o2::framework::readers
 {
 
-
 struct AODReaderHelpers {
   static AlgorithmSpec rootFileReaderCallback();
   static AlgorithmSpec aodSpawnerCallback(ConfigContext const& ctx);
-  static AlgorithmSpec indexBuilderCallback(std::vector<InputSpec>& requested);
+  static AlgorithmSpec indexBuilderCallback(ConfigContext const& ctx);
 };
 
 } // namespace o2::framework::readers
diff --git a/Framework/AnalysisSupport/src/OnDemandPlugin.cxx b/Framework/AnalysisSupport/src/OnDemandPlugin.cxx
new file mode 100644
index 0000000000000..9438f9bf69c96
--- /dev/null
+++ b/Framework/AnalysisSupport/src/OnDemandPlugin.cxx
@@ -0,0 +1,32 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#include "Framework/Plugins.h"
+#include "Framework/AlgorithmSpec.h"
+#include "AODReaderHelpers.h"
+
+struct ExtendedTableSpawner : o2::framework::AlgorithmPlugin {
+  o2::framework::AlgorithmSpec create(o2::framework::ConfigContext const& config) override
+  {
+    return o2::framework::readers::AODReaderHelpers::aodSpawnerCallback(config);
+  }
+};
+
+struct IndexTableBuilder : o2::framework::AlgorithmPlugin {
+  o2::framework::AlgorithmSpec create(o2::framework::ConfigContext const& config) override
+  {
+    return o2::framework::readers::AODReaderHelpers::indexBuilderCallback(config);
+  }
+};
+
+DEFINE_DPL_PLUGINS_BEGIN
+DEFINE_DPL_PLUGIN_INSTANCE(ExtendedTableSpawner, CustomAlgorithm);
+DEFINE_DPL_PLUGIN_INSTANCE(IndexTableBuilder, CustomAlgorithm);
+DEFINE_DPL_PLUGINS_END
diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index cefb903c29895..ce8fbb0dc55f7 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -10,8 +10,7 @@
 # or submit itself to any jurisdiction.
 
 o2_add_library(Framework
-               SOURCES src/AODReaderHelpers.cxx
-                       src/AnalysisHelpers.cxx
+               SOURCES src/AnalysisHelpers.cxx
                        src/AlgorithmSpec.cxx
                        src/ArrowSupport.cxx
                        src/ArrowTableSlicingCache.cxx
@@ -143,6 +142,7 @@ o2_add_library(Framework
                        src/Variant.cxx
                        src/VariantJSONHelpers.cxx
                        src/ExpressionJSONHelpers.cxx
+		       src/IndexJSONHelpers.cxx
                        src/VariantPropertyTreeHelpers.cxx
                        src/WorkflowCustomizationHelpers.cxx
                        src/WorkflowHelpers.cxx
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 10c1fc4ac3ceb..a30363605af36 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -34,7 +34,6 @@
 #include <concepts>
 #include <cstring>
 #include <gsl/span> // IWYU pragma: export
-#include <limits>
 
 namespace o2::framework
 {
@@ -53,6 +52,12 @@ void dereferenceWithWrongType(const char* getter, const char* target);
 void missingFilterDeclaration(int hash, int ai);
 void notBoundTable(const char* tableName);
 void* extractCCDBPayload(char* payload, size_t size, TClass const* cl, const char* what);
+
+template <typename... C>
+auto createFieldsFromColumns(framework::pack<C...>)
+{
+  return std::vector<std::shared_ptr<arrow::Field>>{C::asArrowField()...};
+}
 } // namespace o2::soa
 
 namespace o2::soa
@@ -212,6 +217,20 @@ using is_self_index_t = typename std::conditional_t<is_self_index_column<C>, std
 
 namespace o2::aod
 {
+namespace
+{
+template <typename Key, size_t N, std::array<bool, N> map>
+static consteval int getIndexPosToKey_impl()
+{
+  constexpr const auto pos = std::find(map.begin(), map.end(), true);
+  if constexpr (pos != map.end()) {
+    return std::distance(map.begin(), pos);
+  } else {
+    return -1;
+  }
+}
+} // namespace
+
 /// Base type for table metadata
 template <typename D, typename... Cs>
 struct TableMetadata {
@@ -238,15 +257,9 @@ struct TableMetadata {
     return getIndexPosToKey_impl<Key, framework::pack_size(persistent_columns_t{}), getMap<Key>(persistent_columns_t{})>();
   }
 
-  template <typename Key, size_t N, std::array<bool, N> map>
-  static consteval int getIndexPosToKey_impl()
+  static std::shared_ptr<arrow::Schema> getSchema()
   {
-    constexpr const auto pos = std::find(map.begin(), map.end(), true);
-    if constexpr (pos != map.end()) {
-      return std::distance(map.begin(), pos);
-    } else {
-      return -1;
-    }
+    return std::make_shared<arrow::Schema>([]<typename... C>(framework::pack<C...>&& p) { return o2::soa::createFieldsFromColumns(p); }(persistent_columns_t{}));
   }
 };
 
@@ -406,12 +419,6 @@ struct Binding {
   }
 };
 
-template <typename... C>
-auto createFieldsFromColumns(framework::pack<C...>)
-{
-  return std::vector<std::shared_ptr<arrow::Field>>{C::asArrowField()...};
-}
-
 using SelectionVector = std::vector<int64_t>;
 
 template <typename T>
@@ -686,7 +693,7 @@ struct Column {
 
   static auto asArrowField()
   {
-    return std::make_shared<arrow::Field>(inherited_t::mLabel, framework::expressions::concreteArrowType(framework::expressions::selectArrowType<type>()));
+    return std::make_shared<arrow::Field>(inherited_t::mLabel, soa::asArrowDataType<type>());
   }
 
   /// FIXME: rather than keeping this public we should have a protected
@@ -1303,6 +1310,11 @@ concept with_expression_pack = requires {
   typename T::expression_pack_t{};
 };
 
+template <typename T>
+concept with_index_pack = requires {
+  typename T::index_pack_t{};
+};
+
 template <size_t N1, std::array<TableRef, N1> os1, size_t N2, std::array<TableRef, N2> os2>
 consteval bool is_compatible()
 {
@@ -3251,28 +3263,29 @@ consteval auto getIndexTargets()
   O2HASH(#_Name_ "CfgExtension");                                                    \
   DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_FULL(_Name_, #_Name_ "CfgExtension", _Table_, "AOD", "EX" _Description_, 0, __VA_ARGS__)
 
-#define DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, _Origin_, _Version_, _Desc_, _Exclusive_, ...)                                         \
-  O2HASH(#_Name_);                                                                                                                         \
-  O2HASH(_Desc_ "/" #_Version_);                                                                                                           \
-  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                                     \
-  struct _Name_##MetadataFrom : o2::aod::TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, soa::Index<>, __VA_ARGS__> {             \
-    static constexpr bool exclusive = _Exclusive_;                                                                                         \
-    using Key = _Key_;                                                                                                                     \
-    using index_pack_t = framework::pack<__VA_ARGS__>;                                                                                     \
-    static constexpr const auto sources = []<typename... Cs>(framework::pack<Cs...>) {                                                     \
-      constexpr auto a = o2::soa::mergeOriginals<typename Cs::binding_t...>();                                                             \
-      return o2::aod::filterForKey<a.size(), a, Key>();                                                                                    \
-    }(framework::pack<__VA_ARGS__>{});                                                                                                     \
-  };                                                                                                                                       \
-  using _Name_##Metadata = _Name_##MetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                             \
-                                                                                                                                           \
-  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                                     \
-  using _Name_##From = o2::soa::IndexTable<o2::aod::Hash<#_Name_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O, _Key_, __VA_ARGS__>; \
-  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;                                                                               \
-                                                                                                                                           \
-  template <>                                                                                                                              \
-  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                        \
-    using metadata = _Name_##Metadata;                                                                                                     \
+#define DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, _Origin_, _Version_, _Desc_, _Exclusive_, ...)                                                              \
+  O2HASH(#_Name_);                                                                                                                                              \
+  O2HASH(_Desc_ "/" #_Version_);                                                                                                                                \
+  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                                                          \
+  struct _Name_##MetadataFrom : o2::aod::TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, soa::Index<>, __VA_ARGS__> {                                  \
+    static constexpr bool exclusive = _Exclusive_;                                                                                                              \
+    using Key = _Key_;                                                                                                                                          \
+    using index_pack_t = framework::pack<__VA_ARGS__>;                                                                                                          \
+    static constexpr const auto sources = []<typename... Cs>(framework::pack<Cs...>) {                                                                          \
+      constexpr auto a = o2::soa::mergeOriginals<typename Cs::binding_t...>();                                                                                  \
+      return o2::aod::filterForKey<a.size(), a, Key>();                                                                                                         \
+    }(framework::pack<__VA_ARGS__>{});                                                                                                                          \
+    static_assert(sources.size() - Key::originals.size() + 1 == framework::pack_size(index_pack_t{}), "One of the referred tables does not have index to Key"); \
+  };                                                                                                                                                            \
+  using _Name_##Metadata = _Name_##MetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                                                  \
+                                                                                                                                                                \
+  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                                                          \
+  using _Name_##From = o2::soa::IndexTable<o2::aod::Hash<#_Name_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O, _Key_, __VA_ARGS__>;                      \
+  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;                                                                                                    \
+                                                                                                                                                                \
+  template <>                                                                                                                                                   \
+  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                                             \
+    using metadata = _Name_##Metadata;                                                                                                                          \
   };
 
 // Declare were each row is associated to a timestamp column of an _TimestampSource_
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index fa82151c6e756..3666fe1299489 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -26,10 +26,147 @@
 #include "Framework/Traits.h"
 
 #include <string>
+namespace o2::soa
+{
+struct IndexRecord {
+  std::string label;
+  std::string columnLabel;
+  IndexKind kind;
+  int pos;
+  std::shared_ptr<arrow::DataType> type = [](IndexKind kind) -> std::shared_ptr<arrow::DataType> {
+    switch (kind) {
+      case IndexKind::IdxSingle:
+      case IndexKind::IdxSelf:
+        return arrow::int32();
+      case IndexKind::IdxSlice:
+        return arrow::fixed_size_list(arrow::int32(), 2);
+      case IndexKind::IdxArray:
+        return arrow::list(arrow::int32());
+      default:
+        return {nullptr};
+    }
+  }(kind);
+
+  auto operator==(IndexRecord const& other) const
+  {
+    return (this->label == other.label) && (this->columnLabel == other.columnLabel) && (this->kind == other.kind) && (this->pos == other.pos);
+  }
+
+  std::shared_ptr<arrow::Field> field() const
+  {
+    return std::make_shared<arrow::Field>(columnLabel, type);
+  }
+};
+
+struct IndexBuilder {
+  static std::vector<framework::IndexColumnBuilder> makeBuilders(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::vector<soa::IndexRecord> const& records);
+  static void resetBuilders(std::vector<framework::IndexColumnBuilder>& builders, std::vector<std::shared_ptr<arrow::Table>>&& tables);
+
+  static std::shared_ptr<arrow::Table> materialize(std::vector<framework::IndexColumnBuilder>& builders, std::vector<std::shared_ptr<arrow::Table>>&& tables, std::vector<soa::IndexRecord> const& records, std::shared_ptr<arrow::Schema> const& schema, bool exclusive);
+};
+} // namespace o2::soa
+
 namespace o2::framework
 {
+std::shared_ptr<arrow::Table> makeEmptyTableImpl(const char* name, std::shared_ptr<arrow::Schema>& schema);
+
+template <soa::is_table T>
+auto makeEmptyTable(const char* name)
+{
+  auto schema = std::make_shared<arrow::Schema>(soa::createFieldsFromColumns(typename T::table_t::persistent_columns_t{}));
+  return makeEmptyTableImpl(name, schema);
+}
+
+template <soa::TableRef R>
+auto makeEmptyTable()
+{
+  auto schema = std::make_shared<arrow::Schema>(soa::createFieldsFromColumns(typename aod::MetadataTrait<aod::Hash<R.desc_hash>>::metadata::persistent_columns_t{}));
+  return makeEmptyTableImpl(o2::aod::label<R>(), schema);
+}
+
+template <typename... Cs>
+auto makeEmptyTable(const char* name, framework::pack<Cs...> p)
+{
+  auto schema = std::make_shared<arrow::Schema>(soa::createFieldsFromColumns(p));
+  return makeEmptyTableImpl(name, schema);
+}
+
+template <aod::is_aod_hash D>
+auto makeEmptyTable(const char* name)
+{
+  auto schema = std::make_shared<arrow::Schema>(soa::createFieldsFromColumns(typename aod::MetadataTrait<D>::metadata::persistent_columns_t{}));
+  return makeEmptyTableImpl(name, schema);
+}
+
+std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
+                                            expressions::Projector* projectors, const char* name, std::shared_ptr<gandiva::Projector>& projector);
+
+std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema,
+                                            const char* name, size_t nColumns,
+                                            const std::shared_ptr<gandiva::Projector>& projector);
+
+/// Expression-based column generator to materialize columns
+template <aod::is_aod_hash D>
+  requires(soa::has_extension<typename o2::aod::MetadataTrait<D>::metadata>)
+auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
+{
+  if (fullTable->num_rows() == 0) {
+    return makeEmptyTable<D>(name);
+  }
+  constexpr auto Ncol = []<typename M>() {
+    if constexpr (soa::has_configurable_extension<M>) {
+      return framework::pack_size(typename M::placeholders_pack_t{});
+    } else {
+      return framework::pack_size(typename M::expression_pack_t{});
+    }
+  }.template operator()<typename o2::aod::MetadataTrait<D>::metadata>();
+  return spawnerHelper(fullTable, schema, Ncol, projectors, name, projector);
+}
+
+template <typename... C>
+auto spawner(framework::pack<C...>, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
+{
+  std::array<const char*, 1> labels{"original"};
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span<const char* const>{labels});
+  if (fullTable->num_rows() == 0) {
+    return makeEmptyTable(name, framework::pack<C...>{});
+  }
+  return spawnerHelper(fullTable, schema, sizeof...(C), projectors, name, projector);
+}
+
 std::string serializeProjectors(std::vector<framework::expressions::Projector>& projectors);
-std::string serializeSchema(std::shared_ptr<arrow::Schema>& schema);
+std::string serializeSchema(std::shared_ptr<arrow::Schema> schema);
+std::string serializeIndexRecords(std::vector<o2::soa::IndexRecord>& irs);
+std::vector<std::shared_ptr<arrow::Table>> extractSources(ProcessingContext& pc, std::vector<std::string> const& labels);
+
+struct Spawner {
+  std::string binding;
+  std::vector<std::string> labels;
+  std::vector<std::shared_ptr<gandiva::Expression>> expressions;
+  std::shared_ptr<gandiva::Projector> projector = nullptr;
+  std::shared_ptr<arrow::Schema> schema = nullptr;
+  std::shared_ptr<arrow::Schema> inputSchema = nullptr;
+
+  header::DataOrigin origin;
+  header::DataDescription description;
+  header::DataHeader::SubSpecificationType version;
+
+  std::shared_ptr<arrow::Table> materialize(ProcessingContext& pc) const;
+};
+
+struct Builder {
+  bool exclusive;
+  std::vector<std::string> labels;
+  std::vector<o2::soa::IndexRecord> records;
+  std::shared_ptr<arrow::Schema> outputSchema;
+  header::DataOrigin origin;
+  header::DataDescription description;
+  header::DataHeader::SubSpecificationType version;
+
+  std::shared_ptr<std::vector<framework::IndexColumnBuilder>> builders = nullptr;
+
+  std::shared_ptr<arrow::Table> materialize(ProcessingContext& pc);
+};
 }  // namespace o2::framework
 
 namespace o2::soa
@@ -44,6 +181,16 @@ constexpr auto tableRef2ConfigParamSpec()
     {"\"\""}};
 }
 
+template <TableRef R>
+constexpr auto tableRef2Schema()
+{
+  return o2::framework::ConfigParamSpec{
+    std::string{"input-schema:"} + o2::aod::label<R>(),
+    framework::VariantType::String,
+    framework::serializeSchema(o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata::getSchema()),
+    {"\"\""}};
+}
+
 namespace
 {
 template <soa::with_sources T>
@@ -56,6 +203,16 @@ inline constexpr auto getSources()
   }.template operator()<T::sources.size(), T::sources>();
 }
 
+template <soa::with_sources T>
+inline constexpr auto getSourceSchemas()
+{
+  return []<size_t N, std::array<soa::TableRef, N> refs>() {
+    return []<size_t... Is>(std::index_sequence<Is...>) {
+      return std::vector{soa::tableRef2Schema<refs[Is]>()...};
+    }(std::make_index_sequence<N>());
+  }.template operator()<T::sources.size(), T::sources>();
+}
+
 template <soa::with_ccdb_urls T>
 inline constexpr auto getCCDBUrls()
 {
@@ -69,15 +226,66 @@ inline constexpr auto getCCDBUrls()
   return result;
 }
 
+template <typename T>
+  requires(std::same_as<T, int>)
+consteval IndexKind getIndexKind()
+{
+  return IndexKind::IdxSingle;
+}
+
+template <typename T>
+  requires(std::is_bounded_array_v<T>)
+consteval IndexKind getIndexKind()
+{
+  return IndexKind::IdxSlice;
+}
+
+template <typename T>
+  requires(framework::is_specialization_v<T, std::vector>)
+consteval IndexKind getIndexKind()
+{
+  return IndexKind::IdxArray;
+}
+
+template <soa::with_index_pack T>
+inline constexpr auto getIndexMapping()
+{
+  std::vector<IndexRecord> idx;
+  using indices = T::index_pack_t;
+  using Key = T::Key;
+  [&idx]<size_t... Is>(std::index_sequence<Is...>) mutable {
+    constexpr auto refs = T::sources;
+    ([&idx]<TableRef ref, typename C>() mutable {
+      constexpr auto pos = o2::aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::template getIndexPosToKey<Key>();
+      if constexpr (pos == -1) {
+        idx.emplace_back(o2::aod::label<ref>(), C::columnLabel(), IndexKind::IdxSelf, pos);
+      } else {
+        idx.emplace_back(o2::aod::label<ref>(), C::columnLabel(), getIndexKind<typename C::type>(), pos);
+      }
+    }.template operator()<refs[Is], typename framework::pack_element_t<Is, indices>>(),
+     ...);
+  }(std::make_index_sequence<framework::pack_size(indices{})>());
+  ;
+  return idx;
+}
+
 template <soa::with_sources T>
 constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
 {
   std::vector<framework::ConfigParamSpec> inputMetadata;
+
   auto inputSources = getSources<T>();
   std::sort(inputSources.begin(), inputSources.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name < b.name; });
   auto last = std::unique(inputSources.begin(), inputSources.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name == b.name; });
   inputSources.erase(last, inputSources.end());
   inputMetadata.insert(inputMetadata.end(), inputSources.begin(), inputSources.end());
+
+  auto inputSchemas = getSourceSchemas<T>();
+  std::sort(inputSchemas.begin(), inputSchemas.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name < b.name; });
+  last = std::unique(inputSchemas.begin(), inputSchemas.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name == b.name; });
+  inputSchemas.erase(last, inputSchemas.end());
+  inputMetadata.insert(inputMetadata.end(), inputSchemas.begin(), inputSchemas.end());
+
   return inputMetadata;
 }
 
@@ -115,11 +323,8 @@ constexpr auto getExpressionMetadata() -> std::vector<framework::ConfigParamSpec
     return result;
   }(expression_pack_t{});
 
-  auto schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
-
   auto json = framework::serializeProjectors(projectors);
-  return {framework::ConfigParamSpec{"projectors", framework::VariantType::String, json, {"\"\""}},
-          framework::ConfigParamSpec{"schema", framework::VariantType::String, framework::serializeSchema(schema), {"\"\""}}};
+  return {framework::ConfigParamSpec{"projectors", framework::VariantType::String, json, {"\"\""}}};
 }
 
 template <typename T>
@@ -129,6 +334,21 @@ constexpr auto getExpressionMetadata() -> std::vector<framework::ConfigParamSpec
   return {};
 }
 
+template <soa::with_index_pack T>
+constexpr auto getIndexMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  auto map = getIndexMapping<T>();
+  return {framework::ConfigParamSpec{"index-records", framework::VariantType::String, framework::serializeIndexRecords(map), {"\"\""}},
+          {framework::ConfigParamSpec{"index-exclusive", framework::VariantType::Bool, T::exclusive, {"\"\""}}}};
+}
+
+template <typename T>
+  requires(!soa::with_index_pack<T>)
+constexpr auto getIndexMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  return {};
+}
+
 }  // namespace
 
 template <TableRef R>
@@ -141,6 +361,11 @@ constexpr auto tableRef2InputSpec()
   metadata.insert(metadata.end(), ccdbMetadata.begin(), ccdbMetadata.end());
   auto p = getExpressionMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
   metadata.insert(metadata.end(), p.begin(), p.end());
+  auto idx = getIndexMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  metadata.insert(metadata.end(), idx.begin(), idx.end());
+  if constexpr (!soa::with_ccdb_urls<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>) {
+    metadata.emplace_back(framework::ConfigParamSpec{"schema", framework::VariantType::String, framework::serializeSchema(o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata::getSchema()), {"\"\""}});
+  }
 
   return framework::InputSpec{
     o2::aod::label<R>(),
@@ -319,29 +544,29 @@ struct TableTransform {
   constexpr static auto sources = M::sources;
 
   template <soa::TableRef R>
-  static constexpr auto base_spec()
+  static auto base_spec()
   {
     return soa::tableRef2InputSpec<R>();
   }
 
   static auto base_specs()
   {
-    return []<size_t... Is>(std::index_sequence<Is...>) -> std::vector<InputSpec> {
-      return {base_spec<sources[Is]>()...};
+    return []<size_t... Is>(std::index_sequence<Is...>) {
+      return std::array{base_spec<sources[Is]>()...};
     }(std::make_index_sequence<sources.size()>{});
   }
 
-  constexpr auto spec() const
+  static constexpr auto spec()
   {
     return soa::tableRef2OutputSpec<Ref>();
   }
 
-  constexpr auto output() const
+  static constexpr auto output()
   {
     return soa::tableRef2Output<Ref>();
   }
 
-  constexpr auto ref() const
+  static constexpr auto ref()
   {
     return soa::tableRef2OutputRef<Ref>();
   }
@@ -367,15 +592,9 @@ struct Spawns : decltype(transformBase<T>()) {
   using spawnable_t = T;
   using metadata = decltype(transformBase<T>())::metadata;
   using extension_t = typename metadata::extension_table_t;
-  using base_table_t = typename metadata::base_table_t;
   using expression_pack_t = typename metadata::expression_pack_t;
   static constexpr size_t N = framework::pack_size(expression_pack_t{});
 
-  constexpr auto pack()
-  {
-    return expression_pack_t{};
-  }
-
   typename T::table_t* operator->()
   {
     return table.get();
@@ -389,6 +608,7 @@ struct Spawns : decltype(transformBase<T>()) {
   {
     return extension->asArrowTable();
   }
+
   std::shared_ptr<typename T::table_t> table = nullptr;
   std::shared_ptr<extension_t> extension = nullptr;
   std::array<o2::framework::expressions::Projector, N> projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
@@ -397,13 +617,17 @@ struct Spawns : decltype(transformBase<T>()) {
   }
   (expression_pack_t{});
   std::shared_ptr<gandiva::Projector> projector = nullptr;
-  std::shared_ptr<arrow::Schema> schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
+  std::shared_ptr<arrow::Schema> schema = []() {
+    auto s = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(expression_pack_t{}));
+    s->WithMetadata(std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{std::string{o2::aod::label<T::ref>()}}));
+    return s;
+  }();
 };
 
 template <typename T>
 concept is_spawns = requires(T t) {
   typename T::metadata;
-  requires std::same_as<decltype(t.pack()), typename T::expression_pack_t>;
+  typename T::expression_pack_t;
   requires std::same_as<decltype(t.projector), std::shared_ptr<gandiva::Projector>>;
 };
 
@@ -418,15 +642,9 @@ struct Defines : decltype(transformBase<T>()) {
   using spawnable_t = T;
   using metadata = decltype(transformBase<T>())::metadata;
   using extension_t = typename metadata::extension_table_t;
-  using base_table_t = typename metadata::base_table_t;
   using placeholders_pack_t = typename metadata::placeholders_pack_t;
   static constexpr size_t N = framework::pack_size(placeholders_pack_t{});
 
-  constexpr auto pack()
-  {
-    return placeholders_pack_t{};
-  }
-
   typename T::table_t* operator->()
   {
     return table.get();
@@ -445,7 +663,11 @@ struct Defines : decltype(transformBase<T>()) {
 
   std::array<o2::framework::expressions::Projector, N> projectors;
   std::shared_ptr<gandiva::Projector> projector = nullptr;
-  std::shared_ptr<arrow::Schema> schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(placeholders_pack_t{}));
+  std::shared_ptr<arrow::Schema> schema = []() {
+    auto s = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(placeholders_pack_t{}));
+    s->WithMetadata(std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{std::string{o2::aod::label<T::ref>()}}));
+    return s;
+  }();
   std::shared_ptr<arrow::Schema> inputSchema = nullptr;
 
   bool needRecompilation = false;
@@ -462,7 +684,7 @@ using DefinesDelayed = Defines<T, true>;
 template <typename T>
 concept is_defines = requires(T t) {
   typename T::metadata;
-  requires std::same_as<decltype(t.pack()), typename T::placeholders_pack_t>;
+  typename T::placeholders_pack_t;
   requires std::same_as<decltype(t.projector), std::shared_ptr<gandiva::Projector>>;
   requires std::same_as<decltype(t.needRecompilation), bool>;
   &T::recompile;
@@ -477,129 +699,6 @@ struct Exclusive {
 struct Sparse {
 };
 
-namespace
-{
-template <typename T, typename Key>
-inline std::shared_ptr<arrow::ChunkedArray> getIndexToKey(arrow::Table* table)
-{
-  using IC = framework::pack_element_t<framework::has_type_at_conditional_v<soa::is_binding_compatible, Key>(typename T::external_index_columns_t{}), typename T::external_index_columns_t>;
-  return table->column(framework::has_type_at_v<IC>(typename T::persistent_columns_t{}));
-}
-
-template <soa::is_column C>
-struct ColumnTrait {
-  using column_t = C;
-
-  static consteval auto listSize()
-  {
-    if constexpr (std::same_as<typename C::type, std::vector<int>>) {
-      return -1;
-    } else if constexpr (std::same_as<int[2], typename C::type>) {
-      return 2;
-    } else {
-      return 1;
-    }
-  }
-
-  template <typename T, typename Key>
-  static std::shared_ptr<SelfIndexColumnBuilder> makeColumnBuilder(arrow::Table* table, arrow::MemoryPool* pool)
-  {
-    if constexpr (!std::same_as<T, Key>) {
-      return std::make_shared<IndexColumnBuilder>(getIndexToKey<T, Key>(table), C::columnLabel(), listSize(), pool);
-    } else {
-      return std::make_shared<SelfIndexColumnBuilder>(C::columnLabel(), pool);
-    }
-  }
-};
-
-template <typename Key, typename C>
-struct Reduction {
-  using type = typename std::conditional<soa::is_binding_compatible_v<Key, typename C::binding_t>(), SelfIndexColumnBuilder, IndexColumnBuilder>::type;
-};
-
-template <typename Key, typename C>
-using reduced_t = Reduction<Key, C>::type;
-}  // namespace
-
-template <typename Kind>
-struct IndexBuilder {
-  template <typename Key, size_t N, std::array<soa::TableRef, N> refs, typename C1, typename... Cs>
-  static auto indexBuilder(const char* label, std::vector<std::shared_ptr<arrow::Table>>&& tables, framework::pack<C1, Cs...>)
-  {
-    auto pool = arrow::default_memory_pool();
-    SelfIndexColumnBuilder self{C1::columnLabel(), pool};
-    std::unique_ptr<ChunkedArrayIterator> keyIndex = nullptr;
-    if constexpr (!Key::template hasOriginal<refs[0]>()) {
-      keyIndex = std::make_unique<ChunkedArrayIterator>(tables[0]->column(o2::aod::MetadataTrait<o2::aod::Hash<refs[0].desc_hash>>::metadata::template getIndexPosToKey<Key>()));
-    }
-
-    auto sq = std::make_index_sequence<sizeof...(Cs)>();
-
-    auto columnBuilders = [&tables, &pool ]<size_t... Is>(std::index_sequence<Is...>) -> std::array<std::shared_ptr<framework::SelfIndexColumnBuilder>, sizeof...(Cs)>
-    {
-      return {[](arrow::Table* table, arrow::MemoryPool* pool) {
-        using T = framework::pack_element_t<Is, framework::pack<Cs...>>;
-        if constexpr (!Key::template hasOriginal<refs[Is + 1]>()) {
-          constexpr auto pos = o2::aod::MetadataTrait<o2::aod::Hash<refs[Is + 1].desc_hash>>::metadata::template getIndexPosToKey<Key>();
-          return std::make_shared<IndexColumnBuilder>(table->column(pos), T::columnLabel(), ColumnTrait<T>::listSize(), pool);
-        } else {
-          return std::make_shared<SelfIndexColumnBuilder>(T::columnLabel(), pool);
-        }
-      }(tables[Is + 1].get(), pool)...};
-    }
-    (sq);
-
-    std::array<bool, sizeof...(Cs)> finds;
-
-    for (int64_t counter = 0; counter < tables[0]->num_rows(); ++counter) {
-      int64_t idx = -1;
-      if constexpr (Key::template hasOriginal<refs[0]>()) {
-        idx = counter;
-      } else {
-        idx = keyIndex->valueAt(counter);
-      }
-      finds = [&idx, &columnBuilders]<size_t... Is>(std::index_sequence<Is...>) {
-        return std::array{
-          [&idx, &columnBuilders]() {
-            using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
-            return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->template find<T>(idx);
-          }()...};
-      }(sq);
-      if constexpr (std::same_as<Kind, Sparse>) {
-        [&idx, &columnBuilders]<size_t... Is>(std::index_sequence<Is...>) {
-          ([&idx, &columnBuilders]() {
-            using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
-            return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->template fill<T>(idx); }(), ...);
-        }(sq);
-        self.fill<C1>(counter);
-      } else if constexpr (std::same_as<Kind, Exclusive>) {
-        if (std::none_of(finds.begin(), finds.end(), [](bool const x) { return x == false; })) {
-          [&idx, &columnBuilders]<size_t... Is>(std::index_sequence<Is...>) {
-            ([&idx, &columnBuilders]() {
-              using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
-              return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->template fill<T>(idx);
-            }(),
-             ...);
-          }(sq);
-          self.fill<C1>(counter);
-        }
-      }
-    }
-
-    return [&label, &columnBuilders, &self]<size_t... Is>(std::index_sequence<Is...>) {
-      return makeArrowTable(label,
-                            {self.template result<C1>(), [&columnBuilders]() {
-                               using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
-                               return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->template result<T>();
-                             }()...},
-                            {self.field(), [&columnBuilders]() {
-                               using T = typename framework::pack_element_t<Is, framework::pack<Cs...>>;
-                               return std::static_pointer_cast<reduced_t<Key, T>>(columnBuilders[Is])->field();
-                             }()...});
-    }(sq);
-  }
-};
-
 /// This helper struct allows you to declare index tables to be created in a task
 
 template <soa::is_index_table T>
@@ -613,12 +712,17 @@ template <soa::is_index_table T>
 struct Builds : decltype(transformBase<T>()) {
   using buildable_t = T;
   using metadata = decltype(transformBase<T>())::metadata;
-  using IP = std::conditional_t<metadata::exclusive, IndexBuilder<Exclusive>, IndexBuilder<Sparse>>;
   using Key = metadata::Key;
   using H = typename T::first_t;
   using Ts = typename T::rest_t;
   using index_pack_t = metadata::index_pack_t;
 
+  std::shared_ptr<arrow::Schema> outputSchema = []() { return std::make_shared<arrow::Schema>(soa::createFieldsFromColumns(index_pack_t{}))->WithMetadata(std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{std::string{o2::aod::label<T::ref>()}})); }();
+
+  std::vector<soa::IndexRecord> map = soa::getIndexMapping<metadata>();
+
+  std::vector<framework::IndexColumnBuilder> builders;
+
   T* operator->()
   {
     return table.get();
@@ -639,10 +743,9 @@ struct Builds : decltype(transformBase<T>()) {
     return index_pack_t{};
   }
 
-  template <typename Key, typename... Cs>
-  auto build(framework::pack<Cs...>, std::vector<std::shared_ptr<arrow::Table>>&& tables)
+  auto build(std::vector<std::shared_ptr<arrow::Table>>&& tables)
   {
-    this->table = std::make_shared<T>(IP::template indexBuilder<Key, metadata::sources.size(), metadata::sources>(o2::aod::label<T::ref>(), std::forward<std::vector<std::shared_ptr<arrow::Table>>>(tables), framework::pack<Cs...>{}));
+    this->table = std::make_shared<T>(soa::IndexBuilder::materialize(builders, std::forward<std::vector<std::shared_ptr<arrow::Table>>>(tables), map, outputSchema, metadata::exclusive));
     return (this->table != nullptr);
   }
 };
@@ -651,7 +754,7 @@ template <typename T>
 concept is_builds = requires(T t) {
   typename T::metadata;
   typename T::Key;
-  requires std::same_as<decltype(t.pack()), typename T::index_pack_t>;
+  requires std::same_as<decltype(t.map), std::vector<soa::IndexRecord>>;
 };
 
 /// This helper class allows you to declare things which will be created by a
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 596f3da6a557a..fbb499940b9b9 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -34,18 +34,6 @@ namespace o2::framework
 
 namespace
 {
-template <typename O>
-static inline auto extractOriginal(ProcessingContext& pc)
-{
-  return pc.inputs().get<TableConsumer>(aod::MetadataTrait<O>::metadata::tableLabel())->asArrowTable();
-}
-
-template <typename... Os>
-static inline std::vector<std::shared_ptr<arrow::Table>> extractOriginals(framework::pack<Os...>, ProcessingContext& pc)
-{
-  return {extractOriginal<Os>(pc)...};
-}
-
 template <size_t N, std::array<soa::TableRef, N> refs>
 static inline auto extractOriginals(ProcessingContext& pc)
 {
@@ -160,12 +148,12 @@ const char* controlOption()
 }
 
 template <typename T>
-concept with_base_table = requires(T const& t) { t.base_specs(); };
+concept with_base_table = requires { T::base_specs(); };
 
 template <with_base_table T>
 bool requestInputs(std::vector<InputSpec>& inputs, T const& entity)
 {
-  auto base_specs = entity.base_specs();
+  auto base_specs = T::base_specs();
   for (auto base_spec : base_specs) {
     base_spec.metadata.push_back(ConfigParamSpec{std::string{controlOption<T>()}, VariantType::Bool, true, {"\"\""}});
     DataSpecUtils::updateInputList(inputs, std::forward<InputSpec>(base_spec));
@@ -289,9 +277,8 @@ bool prepareOutput(ProcessingContext& context, T& spawns)
 {
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
   auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
-  if (originalTable->schema()->fields().empty() == true) {
-    using base_table_t = typename T::base_table_t::table_t;
-    originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
+  if (originalTable->num_rows() == 0) {
+    originalTable = makeEmptyTable<metadata::base_table_t::ref>();
   }
   using D = o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>;
 
@@ -308,7 +295,7 @@ template <is_builds T>
 bool prepareOutput(ProcessingContext& context, T& builds)
 {
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::buildable_t::ref.desc_hash>>::metadata;
-  return builds.template build<typename T::buildable_t::indexing_t>(builds.pack(), extractOriginals<metadata::sources.size(), metadata::sources>(context));
+  return builds.build(extractOriginals<metadata::sources.size(), metadata::sources>(context));
 }
 
 template <is_defines T>
@@ -317,9 +304,8 @@ bool prepareOutput(ProcessingContext& context, T& defines)
 {
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
   auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
-  if (originalTable->schema()->fields().empty() == true) {
-    using base_table_t = typename T::base_table_t::table_t;
-    originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
+  if (originalTable->num_rows() == 0) {
+    originalTable = makeEmptyTable<metadata::base_table_t::ref>();
   }
   if (defines.inputSchema == nullptr) {
     defines.inputSchema = originalTable->schema();
@@ -350,9 +336,8 @@ bool prepareDelayedOutput(ProcessingContext& context, T& defines)
   }
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
   auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
-  if (originalTable->schema()->fields().empty() == true) {
-    using base_table_t = typename T::base_table_t::table_t;
-    originalTable = makeEmptyTable<base_table_t>(o2::aod::label<metadata::extension_table_t::ref>());
+  if (originalTable->num_rows() == 0) {
+    originalTable = makeEmptyTable<metadata::base_table_t::ref>();
   }
   if (defines.inputSchema == nullptr) {
     defines.inputSchema = originalTable->schema();
diff --git a/Framework/Core/include/Framework/ArrowTypes.h b/Framework/Core/include/Framework/ArrowTypes.h
index 6fd70113fede7..2673472a81152 100644
--- a/Framework/Core/include/Framework/ArrowTypes.h
+++ b/Framework/Core/include/Framework/ArrowTypes.h
@@ -11,6 +11,7 @@
 
 #ifndef O2_FRAMEWORK_ARROWTYPES_H
 #define O2_FRAMEWORK_ARROWTYPES_H
+#include "Framework/Traits.h"
 #include "arrow/type_fwd.h"
 #include <span>
 
@@ -117,5 +118,54 @@ template <typename T>
 using arrow_array_for_t = typename arrow_array_for<T>::type;
 template <typename T>
 using value_for_t = typename arrow_array_for<T>::value_type;
+
+template <class Array>
+using array_element_t = std::decay_t<decltype(std::declval<Array>()[0])>;
+
+template <typename T>
+std::shared_ptr<arrow::DataType> asArrowDataType(int list_size = 1)
+{
+  auto typeGenerator = [](std::shared_ptr<arrow::DataType> const& type, int list_size) -> std::shared_ptr<arrow::DataType> {
+    switch (list_size) {
+      case -1:
+        return arrow::list(type);
+      case 1:
+        return std::move(type);
+      default:
+        return arrow::fixed_size_list(type, list_size);
+    }
+  };
+
+  if constexpr (std::is_arithmetic_v<T>) {
+    if constexpr (std::same_as<T, bool>) {
+      return typeGenerator(arrow::boolean(), list_size);
+    } else if constexpr (std::same_as<T, uint8_t>) {
+      return typeGenerator(arrow::uint8(), list_size);
+    } else if constexpr (std::same_as<T, uint16_t>) {
+      return typeGenerator(arrow::uint16(), list_size);
+    } else if constexpr (std::same_as<T, uint32_t>) {
+      return typeGenerator(arrow::uint32(), list_size);
+    } else if constexpr (std::same_as<T, uint64_t>) {
+      return typeGenerator(arrow::uint64(), list_size);
+    } else if constexpr (std::same_as<T, int8_t>) {
+      return typeGenerator(arrow::int8(), list_size);
+    } else if constexpr (std::same_as<T, int16_t>) {
+      return typeGenerator(arrow::int16(), list_size);
+    } else if constexpr (std::same_as<T, int32_t>) {
+      return typeGenerator(arrow::int32(), list_size);
+    } else if constexpr (std::same_as<T, int64_t>) {
+      return typeGenerator(arrow::int64(), list_size);
+    } else if constexpr (std::same_as<T, float>) {
+      return typeGenerator(arrow::float32(), list_size);
+    } else if constexpr (std::same_as<T, double>) {
+      return typeGenerator(arrow::float64(), list_size);
+    }
+  } else if constexpr (std::is_bounded_array_v<T>) {
+    return asArrowDataType<array_element_t<T>>(std::extent_v<T>);
+  } else if constexpr (o2::framework::is_specialization_v<T, std::vector>) {
+    return asArrowDataType<typename T::value_type>(-1);
+  }
+  return nullptr;
+}
 } // namespace o2::soa
 #endif // O2_FRAMEWORK_ARROWTYPES_H
diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index e08bf8db52bb4..0be19954f1faa 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -712,6 +712,8 @@ std::shared_ptr<gandiva::Projector> createProjectorHelper(size_t nColumns, expre
                                                           std::shared_ptr<arrow::Schema> schema,
                                                           std::vector<std::shared_ptr<arrow::Field>> const& fields);
 
+std::vector<std::shared_ptr<gandiva::Expression>> materializeProjectors(std::vector<expressions::Projector> const& projectors, std::shared_ptr<arrow::Schema> const& inputSchema, std::vector<std::shared_ptr<arrow::Field>> outputFields);
+
 template <typename... C>
 std::shared_ptr<gandiva::Projector> createProjectors(framework::pack<C...>, std::vector<std::shared_ptr<arrow::Field>> const& fields, gandiva::SchemaPtr schema)
 {
diff --git a/Framework/Core/include/Framework/IndexBuilderHelpers.h b/Framework/Core/include/Framework/IndexBuilderHelpers.h
index d02d5cfc59b3f..30754e62a8dc3 100644
--- a/Framework/Core/include/Framework/IndexBuilderHelpers.h
+++ b/Framework/Core/include/Framework/IndexBuilderHelpers.h
@@ -11,23 +11,32 @@
 
 #ifndef O2_FRAMEWORK_INDEXBUILDERHELPERS_H_
 #define O2_FRAMEWORK_INDEXBUILDERHELPERS_H_
-#include "arrow/array.h"
 #include <arrow/chunked_array.h>
 #include <arrow/builder.h>
 #include <arrow/memory_pool.h>
-#include <string>
 #include <memory>
-#include <type_traits>
+
+namespace o2::soa
+{
+enum struct IndexKind : int {
+  IdxInvalid = -1,
+  IdxSelf = 0,
+  IdxSingle = 1,
+  IdxSlice = 2,
+  IdxArray = 3
+};
+} // namespace o2::soa
 
 namespace o2::framework
 {
 void cannotBuildAnArray();
+void cannotCreateIndexBuilder();
 
 struct ChunkedArrayIterator {
   ChunkedArrayIterator(std::shared_ptr<arrow::ChunkedArray> source);
-  virtual ~ChunkedArrayIterator() = default;
+  void reset(std::shared_ptr<arrow::ChunkedArray>& source);
 
-  std::shared_ptr<arrow::ChunkedArray> mSource;
+  std::shared_ptr<arrow::ChunkedArray> mSource = nullptr;
   size_t mPosition = 0;
   int mChunk = 0;
   size_t mOffset = 0;
@@ -35,6 +44,7 @@ struct ChunkedArrayIterator {
   int const* mCurrent = nullptr;
   int const* mLast = nullptr;
   size_t mFirstIndex = 0;
+  size_t mSourceSize = 0;
 
   std::shared_ptr<arrow::Int32Array> getCurrentArray();
   void nextChunk();
@@ -42,114 +52,72 @@ struct ChunkedArrayIterator {
   int valueAt(size_t pos);
 };
 
-struct SelfIndexColumnBuilder {
-  SelfIndexColumnBuilder(const char* name, arrow::MemoryPool* pool);
-  virtual ~SelfIndexColumnBuilder() = default;
-
-  template <typename C>
-  inline std::shared_ptr<arrow::ChunkedArray> result() const
-  {
-    std::shared_ptr<arrow::Array> array;
-    auto status = static_cast<arrow::Int32Builder*>(mBuilder.get())->Finish(&array);
-    if (!status.ok()) {
-      cannotBuildAnArray();
-    }
+struct SelfBuilder {
+  std::unique_ptr<arrow::ArrayBuilder> mBuilder = nullptr;
+  std::unique_ptr<framework::ChunkedArrayIterator> keyIndex = nullptr;
+  SelfBuilder(arrow::MemoryPool* pool);
+  void reset(std::shared_ptr<arrow::ChunkedArray>);
 
-    return std::make_shared<arrow::ChunkedArray>(array);
-  }
-  std::shared_ptr<arrow::Field> field() const;
-  template <typename C>
-  inline bool find(int)
+  inline bool find(int) const
   {
     return true;
   }
-
-  template <typename C>
-  inline void fill(int idx)
-  {
-    (void)static_cast<arrow::Int32Builder*>(mBuilder.get())->Append(idx);
-  }
-
-  std::string mColumnName;
-  std::shared_ptr<arrow::DataType> mArrowType;
-  std::unique_ptr<arrow::ArrayBuilder> mBuilder = nullptr;
+  void fill(int idx);
+  std::shared_ptr<arrow::ChunkedArray> result() const;
 };
 
-class IndexColumnBuilder : public SelfIndexColumnBuilder, public ChunkedArrayIterator
-{
- public:
-  IndexColumnBuilder(std::shared_ptr<arrow::ChunkedArray> source, const char* name, int listSize, arrow::MemoryPool* pool);
-  ~IndexColumnBuilder() override = default;
+struct SingleBuilder : public ChunkedArrayIterator {
+  std::unique_ptr<arrow::ArrayBuilder> mBuilder = nullptr;
+  SingleBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::MemoryPool* pool);
+  void reset(std::shared_ptr<arrow::ChunkedArray> source);
 
-  template <typename C>
-  inline std::shared_ptr<arrow::ChunkedArray> result() const
-  {
-    if constexpr (std::same_as<typename C::type, std::vector<int>>) {
-      return resultMulti();
-    } else if constexpr (std::same_as<typename C::type, int[2]>) {
-      return resultSlice();
-    } else {
-      return resultSingle();
-    }
-  }
+  bool find(int idx);
+  void fill(int idx);
+  std::shared_ptr<arrow::ChunkedArray> result() const;
+};
 
-  template <typename C>
-  inline bool find(int idx)
-  {
-    if constexpr (std::same_as<typename C::type, std::vector<int>>) {
-      return findMulti(idx);
-    } else if constexpr (std::same_as<typename C::type, int[2]>) {
-      return findSlice(idx);
-    } else {
-      return findSingle(idx);
-    }
-  }
+struct SliceBuilder : public ChunkedArrayIterator {
+  arrow::ArrayBuilder* mValueBuilder = nullptr;
+  std::unique_ptr<arrow::ArrayBuilder> mListBuilder = nullptr;
+  std::shared_ptr<arrow::NumericArray<arrow::Int32Type>> mValues = nullptr;
+  std::shared_ptr<arrow::NumericArray<arrow::Int64Type>> mCounts = nullptr;
+  int mValuePos = 0;
+  SliceBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::MemoryPool* pool);
+  void reset(std::shared_ptr<arrow::ChunkedArray> source);
 
-  template <typename C>
-  inline void fill(int idx)
-  {
-    ++mResultSize;
-    if constexpr (std::same_as<typename C::type, std::vector<int>>) {
-      fillMulti(idx);
-    } else if constexpr (std::same_as<typename C::type, int[2]>) {
-      fillSlice(idx);
-    } else {
-      fillSingle(idx);
-    }
-  }
+  bool find(int idx);
+  void fill(int idx);
+  std::shared_ptr<arrow::ChunkedArray> result() const;
 
- private:
   arrow::Status preSlice();
-  arrow::Status preFind();
-
-  bool findSingle(int idx);
-  bool findSlice(int idx);
-  bool findMulti(int idx);
-
-  void fillSingle(int idx);
-  void fillSlice(int idx);
-  void fillMulti(int idx);
-
-  std::shared_ptr<arrow::ChunkedArray> resultSingle() const;
-  std::shared_ptr<arrow::ChunkedArray> resultSlice() const;
-  std::shared_ptr<arrow::ChunkedArray> resultMulti() const;
+};
 
-  int mListSize = 1;
+struct ArrayBuilder : public ChunkedArrayIterator {
   arrow::ArrayBuilder* mValueBuilder = nullptr;
+  std::vector<int> mValues;
+  std::vector<std::vector<int>> mIndices;
   std::unique_ptr<arrow::ArrayBuilder> mListBuilder = nullptr;
+  ArrayBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::MemoryPool* pool);
+  void reset(std::shared_ptr<arrow::ChunkedArray> source);
 
-  size_t mSourceSize = 0;
-  size_t mResultSize = 0;
+  bool find(int idx);
+  void fill(int idx);
+  std::shared_ptr<arrow::ChunkedArray> result() const;
 
-  std::shared_ptr<arrow::NumericArray<arrow::Int32Type>> mValuesArrow = nullptr;
-  std::shared_ptr<arrow::NumericArray<arrow::Int64Type>> mCounts = nullptr;
-  std::vector<int> mValues;
-  std::vector<std::vector<int>> mIndices;
-  int mFillOffset = 0;
-  int mValuePos = 0;
+  arrow::Status preFind();
 };
 
-std::shared_ptr<arrow::Table> makeArrowTable(const char* label, std::vector<std::shared_ptr<arrow::ChunkedArray>>&& columns, std::vector<std::shared_ptr<arrow::Field>>&& fields);
+struct IndexColumnBuilder {
+  std::variant<std::monostate, SelfBuilder, SingleBuilder, SliceBuilder, ArrayBuilder> builder;
+  size_t mResultSize = 0;
+  int mColumnPos = -1;
+  IndexColumnBuilder(soa::IndexKind kind, int pos, arrow::MemoryPool* pool, std::shared_ptr<arrow::ChunkedArray> source = nullptr);
+  void reset(std::shared_ptr<arrow::ChunkedArray> source = nullptr);
+
+  bool find(int idx);
+  void fill(int idx);
+  std::shared_ptr<arrow::ChunkedArray> result() const;
+};
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_INDEXBUILDERHELPERS_H_
diff --git a/Framework/Core/include/Framework/TableBuilder.h b/Framework/Core/include/Framework/TableBuilder.h
index 7707afe45b380..845820dfe4bff 100644
--- a/Framework/Core/include/Framework/TableBuilder.h
+++ b/Framework/Core/include/Framework/TableBuilder.h
@@ -15,7 +15,6 @@
 #include "Framework/ASoA.h"
 #include "Framework/StructToTuple.h"
 #include "Framework/RuntimeError.h"
-#include "arrow/type_traits.h"
 
 // Apparently needs to be on top of the arrow includes.
 
@@ -26,6 +25,7 @@
 #include <arrow/type_traits.h>
 #include <arrow/table.h>
 #include <arrow/builder.h>
+#include <arrow/util/key_value_metadata.h>
 
 #include <vector>
 #include <string>
@@ -764,92 +764,5 @@ class TableBuilder
   std::shared_ptr<arrow::Schema> mSchema;
   std::vector<std::shared_ptr<arrow::Array>> mArrays;
 };
-
-template <typename T>
-auto makeEmptyTable(const char* name)
-{
-  TableBuilder b;
-  [[maybe_unused]] auto writer = b.cursor<T>();
-  b.setLabel(name);
-  return b.finalize();
-}
-
-template <soa::TableRef R>
-auto makeEmptyTable()
-{
-  TableBuilder b;
-  [[maybe_unused]] auto writer = b.cursor(typename aod::MetadataTrait<aod::Hash<R.desc_hash>>::metadata::persistent_columns_t{});
-  b.setLabel(aod::label<R>());
-  return b.finalize();
-}
-
-template <typename... Cs>
-auto makeEmptyTable(const char* name, framework::pack<Cs...> p)
-{
-  TableBuilder b;
-  [[maybe_unused]] auto writer = b.cursor(p);
-  b.setLabel(name);
-  return b.finalize();
-}
-
-std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
-                                            expressions::Projector* projectors, const char* name, std::shared_ptr<gandiva::Projector>& projector);
-
-std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema,
-                                            const char* name, size_t nColumns,
-                                            const std::shared_ptr<gandiva::Projector>& projector);
-
-/// Expression-based column generator to materialize columns
-template <aod::is_aod_hash D>
-  requires(soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
-auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
-{
-  using placeholders_pack_t = typename o2::aod::MetadataTrait<D>::metadata::placeholders_pack_t;
-  if (fullTable->num_rows() == 0) {
-    return makeEmptyTable(name, placeholders_pack_t{});
-  }
-  return spawnerHelper(fullTable, schema, framework::pack_size(placeholders_pack_t{}), projectors, name, projector);
-}
-
-template <aod::is_aod_hash D>
-  requires(soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
-auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, o2::framework::expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
-{
-  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{o2::aod::MetadataTrait<D>::metadata::base_table_t::originalLabels});
-  return spawner<D>(fullTable, name, projectors, projector, schema);
-}
-
-template <aod::is_aod_hash D>
-  requires(soa::has_extension<typename o2::aod::MetadataTrait<D>::metadata> && !soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
-auto spawner(std::shared_ptr<arrow::Table> const& fullTable, const char* name, expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
-{
-  using expression_pack_t = typename o2::aod::MetadataTrait<D>::metadata::expression_pack_t;
-  if (fullTable->num_rows() == 0) {
-    return makeEmptyTable(name, expression_pack_t{});
-  }
-  return spawnerHelper(fullTable, schema, framework::pack_size(expression_pack_t{}), projectors, name, projector);
-}
-
-template <aod::is_aod_hash D>
-  requires(soa::has_extension<typename o2::aod::MetadataTrait<D>::metadata> && !soa::has_configurable_extension<typename o2::aod::MetadataTrait<D>::metadata>)
-auto spawner(std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
-{
-  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{o2::aod::MetadataTrait<D>::metadata::base_table_t::originalLabels});
-  return spawner<D>(fullTable, name, projectors, projector, schema);
-}
-
-template <typename... C>
-auto spawner(framework::pack<C...>, std::vector<std::shared_ptr<arrow::Table>>&& tables, const char* name, expressions::Projector* projectors, std::shared_ptr<gandiva::Projector>& projector, std::shared_ptr<arrow::Schema> const& schema)
-{
-  std::array<const char*, 1> labels{"original"};
-  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span<const char* const>{labels});
-  if (fullTable->num_rows() == 0) {
-    return makeEmptyTable(name, framework::pack<C...>{});
-  }
-  return spawnerHelper(fullTable, schema, sizeof...(C), projectors, name, projector);
-}
-
-template <typename... T>
-using iterator_tuple_t = std::tuple<typename T::iterator...>;
 } // namespace o2::framework
 #endif // FRAMEWORK_TABLEBUILDER_H
diff --git a/Framework/Core/src/AODReaderHelpers.cxx b/Framework/Core/src/AODReaderHelpers.cxx
deleted file mode 100644
index 09ec16a93b087..0000000000000
--- a/Framework/Core/src/AODReaderHelpers.cxx
+++ /dev/null
@@ -1,280 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "Framework/AODReaderHelpers.h"
-#include "Framework/AnalysisHelpers.h"
-#include "Framework/AnalysisDataModelHelpers.h"
-#include "Framework/ExpressionHelpers.h"
-#include "Framework/DataProcessingHelpers.h"
-#include "Framework/AlgorithmSpec.h"
-#include "Framework/ControlService.h"
-#include "Framework/CallbackService.h"
-#include "Framework/EndOfStreamContext.h"
-#include "Framework/DataSpecUtils.h"
-#include "ExpressionJSONHelpers.h"
-#include "Framework/ConfigContext.h"
-#include "Framework/AnalysisContext.h"
-
-#include <Monitoring/Monitoring.h>
-
-#include <TGrid.h>
-#include <TFile.h>
-#include <TTreeCache.h>
-
-#include <arrow/ipc/reader.h>
-#include <arrow/ipc/writer.h>
-#include <arrow/io/interfaces.h>
-#include <arrow/table.h>
-#include <arrow/util/key_value_metadata.h>
-
-namespace o2::framework::readers
-{
-auto setEOSCallback(InitContext& ic)
-{
-  ic.services().get<CallbackService>().set<CallbackService::Id::EndOfStream>(
-    [](EndOfStreamContext& eosc) {
-      auto& control = eosc.services().get<ControlService>();
-      control.endOfStream();
-      control.readyToQuit(QuitRequest::Me);
-    });
-}
-
-template <size_t N, std::array<soa::TableRef, N> refs>
-static inline auto extractOriginals(ProcessingContext& pc)
-{
-  return [&]<size_t... Is>(std::index_sequence<Is...>) -> std::vector<std::shared_ptr<arrow::Table>> {
-    return {pc.inputs().get<TableConsumer>(o2::aod::label<refs[Is]>())->asArrowTable()...};
-  }(std::make_index_sequence<refs.size()>());
-}
-namespace
-{
-template <typename D>
-  requires(D::exclusive)
-auto make_build(D metadata, InputSpec const& input, ProcessingContext& pc)
-{
-  using metadata_t = decltype(metadata);
-  using Key = typename metadata_t::Key;
-  using index_pack_t = typename metadata_t::index_pack_t;
-  constexpr auto sources = metadata_t::sources;
-  return o2::framework::IndexBuilder<o2::framework::Exclusive>::indexBuilder<Key, sources.size(), sources>(input.binding.c_str(),
-                                                                                                           extractOriginals<sources.size(), sources>(pc),
-                                                                                                           index_pack_t{});
-}
-
-template <typename D>
-  requires(!D::exclusive)
-auto make_build(D metadata, InputSpec const& input, ProcessingContext& pc)
-{
-  using metadata_t = decltype(metadata);
-  using Key = typename metadata_t::Key;
-  using index_pack_t = typename metadata_t::index_pack_t;
-  constexpr auto sources = metadata_t::sources;
-  return o2::framework::IndexBuilder<o2::framework::Sparse>::indexBuilder<Key, sources.size(), sources>(input.binding.c_str(),
-                                                                                                        extractOriginals<sources.size(), sources>(pc),
-                                                                                                        index_pack_t{});
-}
-} // namespace
-
-AlgorithmSpec AODReaderHelpers::indexBuilderCallback(std::vector<InputSpec>& requested)
-{
-  return AlgorithmSpec::InitCallback{[requested](InitContext& /*ic*/) {
-    return [requested](ProcessingContext& pc) {
-      auto outputs = pc.outputs();
-      // spawn tables
-      for (auto& input : requested) {
-        auto&& [origin, description, version] = DataSpecUtils::asConcreteDataMatcher(input);
-        if (description == header::DataDescription{"MA_RN2_EX"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run2MatchedExclusiveMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_RN2_SP"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run2MatchedSparseMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_RN3_EX"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run3MatchedExclusiveMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_RN3_SP"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run3MatchedSparseMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_BCCOL_EX"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::MatchedBCCollisionsExclusiveMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_BCCOL_SP"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::MatchedBCCollisionsSparseMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_BCCOLS_EX"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::MatchedBCCollisionsExclusiveMultiMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_BCCOLS_SP"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::MatchedBCCollisionsSparseMultiMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_RN3_BC_SP"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run3MatchedToBCSparseMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_RN3_BC_EX"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run3MatchedToBCExclusiveMetadata{}, input, pc));
-        } else if (description == header::DataDescription{"MA_RN2_BC_SP"}) {
-          outputs.adopt(Output{origin, description, version}, make_build(o2::aod::Run2MatchedToBCSparseMetadata{}, input, pc));
-        } else {
-          throw std::runtime_error("Not an index table");
-        }
-      }
-    };
-  }};
-}
-
-namespace
-{
-template <o2::aod::is_aod_hash D>
-auto make_spawn(InputSpec const& input, ProcessingContext& pc)
-{
-  using metadata_t = o2::aod::MetadataTrait<D>::metadata;
-  constexpr auto sources = metadata_t::sources;
-  static std::shared_ptr<gandiva::Projector> projector = nullptr;
-  static std::shared_ptr<arrow::Schema> schema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(typename metadata_t::expression_pack_t{}));
-  static auto projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
-  {
-    return {{std::move(C::Projector())...}};
-  }
-  (typename metadata_t::expression_pack_t{});
-  return o2::framework::spawner<D>(extractOriginals<sources.size(), sources>(pc), input.binding.c_str(), projectors.data(), projector, schema);
-}
-
-struct Maker {
-  std::string binding;
-  std::vector<std::string> labels;
-  std::vector<std::shared_ptr<gandiva::Expression>> expressions;
-  std::shared_ptr<gandiva::Projector> projector = nullptr;
-  std::shared_ptr<arrow::Schema> schema;
-
-  header::DataOrigin origin;
-  header::DataDescription description;
-  header::DataHeader::SubSpecificationType version;
-
-  std::shared_ptr<arrow::Table> make(ProcessingContext& pc)
-  {
-    std::vector<std::shared_ptr<arrow::Table>> originals;
-    for (auto const& label : labels) {
-      originals.push_back(pc.inputs().get<TableConsumer>(label)->asArrowTable());
-    }
-    auto fullTable = soa::ArrowHelpers::joinTables(std::move(originals), std::span{labels.begin(), labels.size()});
-    if (fullTable->num_rows() == 0) {
-      return arrow::Table::MakeEmpty(schema).ValueOrDie();
-    }
-    if (projector == nullptr) {
-      auto s = gandiva::Projector::Make(
-        fullTable->schema(),
-        expressions,
-        &projector);
-      if (!s.ok()) {
-        throw o2::framework::runtime_error_f("Failed to create projector: %s", s.ToString().c_str());
-      }
-    }
-
-    return spawnerHelper(fullTable, schema, binding.c_str(), schema->num_fields(), projector);
-  }
-};
-
-struct Spawnable {
-  std::string binding;
-  std::vector<std::string> labels;
-  std::vector<expressions::Projector> projectors;
-  std::vector<std::shared_ptr<gandiva::Expression>> expressions;
-  std::shared_ptr<arrow::Schema> outputSchema;
-  std::shared_ptr<arrow::Schema> inputSchema;
-
-  header::DataOrigin origin;
-  header::DataDescription description;
-  header::DataHeader::SubSpecificationType version;
-
-  Spawnable(InputSpec const& spec)
-    : binding{spec.binding}
-  {
-    auto&& [origin_, description_, version_] = DataSpecUtils::asConcreteDataMatcher(spec);
-    origin = origin_;
-    description = description_;
-    version = version_;
-    auto loc = std::find_if(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& cps) { return cps.name.compare("projectors") == 0; });
-    std::stringstream iws(loc->defaultValue.get<std::string>());
-    projectors = ExpressionJSONHelpers::read(iws);
-
-    loc = std::find_if(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& cps) { return cps.name.compare("schema") == 0; });
-    iws.clear();
-    iws.str(loc->defaultValue.get<std::string>());
-    outputSchema = ArrowJSONHelpers::read(iws);
-
-    for (auto& i : spec.metadata) {
-      if (i.name.starts_with("input:")) {
-        labels.emplace_back(i.name.substr(6));
-      }
-    }
-
-    std::vector<std::shared_ptr<arrow::Field>> fields;
-    for (auto& p : projectors) {
-      expressions::walk(p.node.get(),
-                        [&fields](expressions::Node* n) mutable {
-                          if (n->self.index() == 1) {
-                            auto& b = std::get<expressions::BindingNode>(n->self);
-                            if (std::find_if(fields.begin(), fields.end(), [&b](std::shared_ptr<arrow::Field> const& field) { return field->name() == b.name; }) == fields.end()) {
-                              fields.emplace_back(std::make_shared<arrow::Field>(b.name, expressions::concreteArrowType(b.type)));
-                            }
-                          }
-                        });
-    }
-    inputSchema = std::make_shared<arrow::Schema>(fields);
-
-    int i = 0;
-    for (auto& p : projectors) {
-      expressions.push_back(
-        expressions::makeExpression(
-          expressions::createExpressionTree(
-            expressions::createOperations(p),
-            inputSchema),
-          outputSchema->field(i)));
-      ++i;
-    }
-  }
-
-  std::shared_ptr<gandiva::Projector> makeProjector()
-  {
-    return expressions::createProjectorHelper(projectors.size(), projectors.data(), inputSchema, outputSchema->fields());
-  }
-
-  Maker createMaker()
-  {
-    o2::framework::addLabelToSchema(outputSchema, binding.c_str());
-    return {
-      binding,
-      labels,
-      expressions,
-      nullptr,
-      outputSchema,
-      origin,
-      description,
-      version};
-  }
-};
-
-} // namespace
-
-AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(/*std::vector<InputSpec>& requested*/ ConfigContext const& ctx)
-{
-  auto& ac = ctx.services().get<AnalysisContext>();
-  return AlgorithmSpec::InitCallback{[requested = ac.spawnerInputs](InitContext& /*ic*/) {
-    std::vector<Spawnable> spawnables;
-    for (auto& i : requested) {
-      spawnables.emplace_back(i);
-    }
-    std::vector<Maker> makers;
-    for (auto& s : spawnables) {
-      makers.push_back(s.createMaker());
-    }
-
-    return [makers](ProcessingContext& pc) mutable {
-      auto outputs = pc.outputs();
-      for (auto& maker : makers) {
-        outputs.adopt(Output{maker.origin, maker.description, maker.version}, maker.make(pc));
-      }
-    };
-  }};
-}
-
-} // namespace o2::framework::readers
diff --git a/Framework/Core/src/AnalysisHelpers.cxx b/Framework/Core/src/AnalysisHelpers.cxx
index 4f78cc42f3f98..b8e0348d5df9c 100644
--- a/Framework/Core/src/AnalysisHelpers.cxx
+++ b/Framework/Core/src/AnalysisHelpers.cxx
@@ -8,11 +8,147 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
+#include "Framework/AnalysisHelpers.h"
 #include "Framework/ExpressionHelpers.h"
 #include "ExpressionJSONHelpers.h"
+#include "IndexJSONHelpers.h"
+
+namespace o2::soa
+{
+std::vector<framework::IndexColumnBuilder> IndexBuilder::makeBuilders(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::vector<soa::IndexRecord> const& records)
+{
+  std::vector<framework::IndexColumnBuilder> builders;
+  builders.reserve(records.size());
+  auto pool = arrow::default_memory_pool();
+  builders.emplace_back(IndexKind::IdxSelf, records[0].pos, pool);
+  if (records[0].pos >= 0) {
+    std::get<framework::SelfBuilder>(builders[0].builder).keyIndex = std::make_unique<framework::ChunkedArrayIterator>(tables[0]->column(records[0].pos));
+  }
+
+  for (auto i = 1U; i < records.size(); ++i) {
+    builders.emplace_back(records[i].kind, records[i].pos, pool, records[i].pos >= 0 ? tables[i]->column(records[i].pos) : nullptr);
+  }
+
+  return builders;
+}
+
+void IndexBuilder::resetBuilders(std::vector<framework::IndexColumnBuilder>& builders, std::vector<std::shared_ptr<arrow::Table>>&& tables)
+{
+  for (auto i = 0U; i < builders.size(); ++i) {
+    builders[i].reset(builders[i].mColumnPos >= 0 ? tables[i]->column(builders[i].mColumnPos) : nullptr);
+  }
+
+  if (builders[0].mColumnPos >= 0) {
+    std::get<framework::SelfBuilder>(builders[0].builder).keyIndex = std::make_unique<framework::ChunkedArrayIterator>(tables[0]->column(builders[0].mColumnPos));
+  }
+}
+
+std::shared_ptr<arrow::Table> IndexBuilder::materialize(std::vector<framework::IndexColumnBuilder>& builders, std::vector<std::shared_ptr<arrow::Table>>&& tables, std::vector<soa::IndexRecord> const& records, std::shared_ptr<arrow::Schema> const& schema, bool exclusive)
+{
+  auto size = tables[0]->num_rows();
+  if (builders.empty()) {
+    builders = makeBuilders(std::move(tables), records);
+  } else {
+    resetBuilders(builders, std::move(tables));
+  }
+
+  std::vector<bool> finds;
+  finds.resize(builders.size());
+  for (int64_t counter = 0; counter < size; ++counter) {
+    int64_t idx = -1;
+    if (std::get<framework::SelfBuilder>(builders[0].builder).keyIndex == nullptr) {
+      idx = counter;
+    } else {
+      idx = std::get<framework::SelfBuilder>(builders[0].builder).keyIndex->valueAt(counter);
+    }
+    for (auto i = 0U; i < builders.size(); ++i) {
+      finds[i] = builders[i].find(idx);
+    }
+    if (exclusive) {
+      if (std::none_of(finds.begin(), finds.end(), [](bool const x) { return x == false; })) {
+        builders[0].fill(counter);
+        for (auto i = 1U; i < builders.size(); ++i) {
+          builders[i].fill(idx);
+        }
+      }
+    } else {
+      builders[0].fill(counter);
+      for (auto i = 1U; i < builders.size(); ++i) {
+        builders[i].fill(idx);
+      }
+    }
+  }
+
+  std::vector<std::shared_ptr<arrow::ChunkedArray>> arrays;
+  arrays.reserve(builders.size());
+  for (auto& builder : builders) {
+    arrays.push_back(builder.result());
+  }
+
+  return arrow::Table::Make(schema, arrays);
+}
+} // namespace o2::soa
 
 namespace o2::framework
 {
+std::shared_ptr<arrow::Table> makeEmptyTableImpl(const char* name, std::shared_ptr<arrow::Schema>& schema)
+{
+  schema = schema->WithMetadata(std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{std::string{name}}));
+  return arrow::Table::MakeEmpty(schema).ValueOrDie();
+}
+
+std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
+                                            expressions::Projector* projectors, const char* name,
+                                            std::shared_ptr<gandiva::Projector>& projector)
+{
+  if (projector == nullptr) {
+    projector = framework::expressions::createProjectorHelper(nColumns, projectors, fullTable->schema(), newSchema->fields());
+  }
+
+  return spawnerHelper(fullTable, newSchema, name, nColumns, projector);
+}
+
+std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema,
+                                            const char* name, size_t nColumns,
+                                            std::shared_ptr<gandiva::Projector> const& projector)
+{
+  arrow::TableBatchReader reader(*fullTable);
+  std::shared_ptr<arrow::RecordBatch> batch;
+  arrow::ArrayVector v;
+  std::vector<arrow::ArrayVector> chunks;
+  chunks.resize(nColumns);
+  std::vector<std::shared_ptr<arrow::ChunkedArray>> arrays;
+
+  while (true) {
+    auto s = reader.ReadNext(&batch);
+    if (!s.ok()) {
+      throw runtime_error_f("Cannot read batches from the source table to spawn %s: %s", name, s.ToString().c_str());
+    }
+    if (batch == nullptr) {
+      break;
+    }
+    try {
+      s = projector->Evaluate(*batch, arrow::default_memory_pool(), &v);
+      if (!s.ok()) {
+        throw runtime_error_f("Cannot apply projector to the source table of %s: %s", name, s.ToString().c_str());
+      }
+    } catch (std::exception& e) {
+      throw runtime_error_f("Cannot apply projector to the source table of %s: exception caught: %s", name, e.what());
+    }
+
+    for (auto i = 0U; i < nColumns; ++i) {
+      chunks[i].emplace_back(v.at(i));
+    }
+  }
+
+  arrays.reserve(nColumns);
+  for (auto i = 0U; i < nColumns; ++i) {
+    arrays.push_back(std::make_shared<arrow::ChunkedArray>(chunks[i]));
+  }
+
+  return arrow::Table::Make(newSchema, arrays);
+}
+
 void initializePartitionCaches(std::set<uint32_t> const& hashes, std::shared_ptr<arrow::Schema> const& schema, expressions::Filter const& filter, gandiva::NodePtr& tree, gandiva::FilterPtr& gfilter)
 {
   if (tree == nullptr) {
@@ -35,10 +171,49 @@ std::string serializeProjectors(std::vector<framework::expressions::Projector>&
   return osm.str();
 }
 
-std::string serializeSchema(std::shared_ptr<arrow::Schema>& schema)
+std::string serializeSchema(std::shared_ptr<arrow::Schema> schema)
 {
   std::stringstream osm;
   ArrowJSONHelpers::write(osm, schema);
   return osm.str();
 }
+
+std::string serializeIndexRecords(std::vector<o2::soa::IndexRecord>& irs)
+{
+  std::stringstream osm;
+  IndexJSONHelpers::write(osm, irs);
+  return osm.str();
+}
+
+std::vector<std::shared_ptr<arrow::Table>> extractSources(ProcessingContext& pc, std::vector<std::string> const& labels)
+{
+  std::vector<std::shared_ptr<arrow::Table>> tables;
+  for (auto const& label : labels) {
+    tables.emplace_back(pc.inputs().get<TableConsumer>(label.c_str())->asArrowTable());
+  }
+  return tables;
+}
+
+std::shared_ptr<arrow::Table> Spawner::materialize(ProcessingContext& pc) const
+{
+  auto tables = extractSources(pc, labels);
+  auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{labels.begin(), labels.size()});
+  if (fullTable->num_rows() == 0) {
+    return arrow::Table::MakeEmpty(schema).ValueOrDie();
+  }
+
+  return spawnerHelper(fullTable, schema, binding.c_str(), schema->num_fields(), projector);
+}
+
+std::shared_ptr<arrow::Table> Builder::materialize(ProcessingContext& pc)
+{
+  if (builders == nullptr) {
+    builders = std::make_shared<std::vector<framework::IndexColumnBuilder>>();
+    builders->reserve(records.size());
+  }
+  std::shared_ptr<arrow::Table> result;
+  auto tables = extractSources(pc, labels);
+  result = o2::soa::IndexBuilder::materialize(*builders.get(), std::move(tables), records, outputSchema, exclusive);
+  return result;
+}
 } // namespace o2::framework
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index 7cfab22885671..b5c898faa515a 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -219,7 +219,6 @@ void AnalysisSupportHelpers::addMissingOutputsToAnalysisCCDBFetcher(
     // FIXME: good enough for now...
     for (auto& i : input.metadata) {
       if ((i.type == VariantType::String) && (i.name.find("input:") != std::string::npos)) {
-        auto value = i.defaultValue.get<std::string>();
         auto spec = DataSpecUtils::fromMetadataString(i.defaultValue.get<std::string>());
         auto j = std::find_if(publisher.inputs.begin(), publisher.inputs.end(), [&](auto x) { return x.binding == spec.binding; });
         if (j == publisher.inputs.end()) {
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 4150fda9f63f1..cf2d364027932 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 #include "ArrowSupport.h"
 
-#include "Framework/AODReaderHelpers.h"
 #include "Framework/ArrowContext.h"
 #include "Framework/ArrowTableSlicingCache.h"
 #include "Framework/DataProcessor.h"
@@ -619,7 +618,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         builder->outputs.clear();
         // replace AlgorithmSpec
         //  FIXME: it should be made more generic, so it does not need replacement...
-        builder->algorithm = readers::AODReaderHelpers::indexBuilderCallback(ac.requestedIDXs);
+        builder->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx); // readers::AODReaderHelpers::indexBuilderCallback(ctx);
         AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.requestedIDXs, ac.requestedAODs, ac.requestedDYNs, *builder);
       }
 
@@ -654,7 +653,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         spawner->inputs.clear();
         // replace AlgorithmSpec
         // FIXME: it should be made more generic, so it does not need replacement...
-        spawner->algorithm = readers::AODReaderHelpers::aodSpawnerCallback(ctx);
+        spawner->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx);
         AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, *spawner);
       }
 
diff --git a/Framework/Core/src/ExpressionJSONHelpers.cxx b/Framework/Core/src/ExpressionJSONHelpers.cxx
index 8d4907a721f7e..a6e19875381cd 100644
--- a/Framework/Core/src/ExpressionJSONHelpers.cxx
+++ b/Framework/Core/src/ExpressionJSONHelpers.cxx
@@ -637,6 +637,18 @@ void o2::framework::ExpressionJSONHelpers::write(std::ostream& o, std::vector<o2
 
 namespace
 {
+std::shared_ptr<arrow::DataType> arrowDataTypeFromId(atype::type type, int list_size = 1, atype::type element = atype::NA)
+{
+  switch (list_size) {
+    case -1:
+      return arrow::list(expressions::concreteArrowType(element));
+    case 1:
+      return expressions::concreteArrowType(type);
+    default:
+      return arrow::fixed_size_list(expressions::concreteArrowType(element), list_size);
+  }
+}
+
 struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, SchemaReader> {
   using Ch = rapidjson::UTF8<>::Ch;
   using SizeType = rapidjson::SizeType;
@@ -658,6 +670,8 @@ struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Sch
 
   std::string name;
   atype::type type;
+  atype::type element;
+  int list_size = 1;
 
   SchemaReader()
   {
@@ -667,7 +681,7 @@ struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Sch
 
   bool StartArray()
   {
-    debug << "Starting array" << std::endl;
+    debug << "StartArray()" << std::endl;
     if (states.top() == State::IN_START && currentKey.compare("fields") == 0) {
       states.push(State::IN_LIST);
       return true;
@@ -678,7 +692,7 @@ struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Sch
 
   bool EndArray(SizeType)
   {
-    debug << "Ending array" << std::endl;
+    debug << "EndArray()" << std::endl;
     if (states.top() == State::IN_LIST) {
       // finalize schema
       schema = std::make_shared<arrow::Schema>(fields);
@@ -706,6 +720,12 @@ struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Sch
       if (currentKey.compare("type") == 0) {
         return true;
       }
+      if (currentKey.compare("size") == 0) {
+        return true;
+      }
+      if (currentKey.compare("element") == 0) {
+        return true;
+      }
     }
 
     states.push(State::IN_ERROR);
@@ -721,6 +741,9 @@ struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Sch
 
     if (states.top() == State::IN_LIST) {
       states.push(State::IN_FIELD);
+      list_size = 1;
+      element = atype::NA;
+      type = atype::NA;
       return true;
     }
 
@@ -734,7 +757,7 @@ struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Sch
     if (states.top() == State::IN_FIELD) {
       states.pop();
       // add a field
-      fields.emplace_back(std::make_shared<arrow::Field>(name, expressions::concreteArrowType(type)));
+      fields.emplace_back(std::make_shared<arrow::Field>(name, arrowDataTypeFromId(type, list_size, element)));
       return true;
     }
 
@@ -754,6 +777,14 @@ struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Sch
         type = (atype::type)i;
         return true;
       }
+      if (currentKey.compare("element") == 0) {
+        element = (atype::type)i;
+        return true;
+      }
+      if (currentKey.compare("size") == 0) {
+        list_size = i;
+        return true;
+      }
     }
 
     states.push(State::IN_ERROR);
@@ -777,6 +808,10 @@ struct SchemaReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, Sch
   bool Int(int i)
   {
     debug << "Int(" << i << ")" << std::endl;
+    if (states.top() == State::IN_FIELD && currentKey.compare("size") == 0) {
+      list_size = i;
+      return true;
+    }
     return Uint(i);
   }
 };
@@ -791,7 +826,7 @@ std::shared_ptr<arrow::Schema> o2::framework::ArrowJSONHelpers::read(std::istrea
   bool ok = reader.Parse(isw, sreader);
 
   if (!ok) {
-    throw framework::runtime_error_f("Cannot parse serialized Expression, error: %s at offset: %d", rapidjson::GetParseError_En(reader.GetParseErrorCode()), reader.GetErrorOffset());
+    throw framework::runtime_error_f("Cannot parse serialized Schema, error: %s at offset: %d", rapidjson::GetParseError_En(reader.GetParseErrorCode()), reader.GetErrorOffset());
   }
   return sreader.schema;
 }
@@ -804,6 +839,20 @@ void writeSchema(rapidjson::Writer<rapidjson::OStreamWrapper>& w, arrow::Schema*
     w.StartObject();
     w.Key("name");
     w.String(f->name().c_str());
+    auto fixedList = dynamic_cast<arrow::FixedSizeListType*>(f->type().get());
+    if (fixedList != nullptr) {
+      w.Key("size");
+      w.Int(fixedList->list_size());
+      w.Key("element");
+      w.Int(fixedList->field(0)->type()->id());
+    }
+    auto varList = dynamic_cast<arrow::ListType*>(f->type().get());
+    if (varList != nullptr) {
+      w.Key("size");
+      w.Int(-1);
+      w.Key("element");
+      w.Int(varList->field(0)->type()->id());
+    }
     w.Key("type");
     w.Int(f->type()->id());
     w.EndObject();
diff --git a/Framework/Core/src/Expressions.cxx b/Framework/Core/src/Expressions.cxx
index 05a3462d6e4da..43143f781ddf4 100644
--- a/Framework/Core/src/Expressions.cxx
+++ b/Framework/Core/src/Expressions.cxx
@@ -1348,4 +1348,20 @@ OpNode Parser::opFromToken(std::string const& token)
   return OpNode{static_cast<BasicOp>(std::distance(mapping.begin(), locate))};
 }
 
+std::vector<std::shared_ptr<gandiva::Expression>> materializeProjectors(std::vector<expressions::Projector> const& projectors, std::shared_ptr<arrow::Schema> const& inputSchema, std::vector<std::shared_ptr<arrow::Field>> outputFields)
+{
+  std::vector<std::shared_ptr<gandiva::Expression>> expressions;
+  int i = 0;
+  for (auto& p : projectors) {
+    expressions.push_back(
+      expressions::makeExpression(
+        expressions::createExpressionTree(
+          expressions::createOperations(p),
+          inputSchema),
+        outputFields[i]));
+    ++i;
+  }
+  return expressions;
+}
+
 } // namespace o2::framework::expressions
diff --git a/Framework/Core/src/IndexBuilderHelpers.cxx b/Framework/Core/src/IndexBuilderHelpers.cxx
index 52d6080690fe1..d7231f72cbee8 100644
--- a/Framework/Core/src/IndexBuilderHelpers.cxx
+++ b/Framework/Core/src/IndexBuilderHelpers.cxx
@@ -12,6 +12,7 @@
 #include "Framework/RuntimeError.h"
 #include "Framework/IndexBuilderHelpers.h"
 #include "Framework/CompilerBuiltins.h"
+#include "Framework/VariantHelpers.h"
 #include <arrow/compute/api_aggregate.h>
 #include <arrow/compute/kernel.h>
 #include <arrow/status.h>
@@ -22,130 +23,87 @@ namespace o2::framework
 {
 void cannotBuildAnArray()
 {
-  throw runtime_error("Cannot build an array");
+  throw framework::runtime_error("Cannot finish an array");
+}
+
+void cannotCreateIndexBuilder()
+{
+  throw framework::runtime_error("Cannot create index column builder: invalid kind of index column");
 }
 
 ChunkedArrayIterator::ChunkedArrayIterator(std::shared_ptr<arrow::ChunkedArray> source)
-  : mSource{source}
+  : mSource{source},
+    mSourceSize{(size_t)source->length()}
 {
   mCurrentArray = getCurrentArray();
   mCurrent = reinterpret_cast<int const*>(mCurrentArray->values()->data()) + mOffset;
   mLast = mCurrent + mCurrentArray->length();
 }
 
-SelfIndexColumnBuilder::SelfIndexColumnBuilder(const char* name, arrow::MemoryPool* pool)
-  : mColumnName{name},
-    mArrowType{arrow::int32()}
+void ChunkedArrayIterator::reset(std::shared_ptr<arrow::ChunkedArray>& source)
 {
-  auto status = arrow::MakeBuilder(pool, arrow::int32(), &mBuilder);
-  if (!status.ok()) {
-    throw runtime_error("Cannot create array builder!");
-  }
-}
+  mPosition = 0;
+  mChunk = 0;
+  mOffset = 0;
+  mCurrentArray = nullptr;
+  mCurrent = nullptr;
+  mLast = nullptr;
+  mFirstIndex = 0;
+  mSourceSize = 0;
 
-std::shared_ptr<arrow::Field> SelfIndexColumnBuilder::field() const
-{
-  return std::make_shared<arrow::Field>(mColumnName, mArrowType);
+  mSource = source;
+  mSourceSize = (size_t)source->length();
+  mCurrentArray = getCurrentArray();
+  mCurrent = reinterpret_cast<int const*>(mCurrentArray->values()->data()) + mOffset;
+  mLast = mCurrent + mCurrentArray->length();
 }
 
-IndexColumnBuilder::IndexColumnBuilder(std::shared_ptr<arrow::ChunkedArray> source, const char* name, int listSize, arrow::MemoryPool* pool)
-  : SelfIndexColumnBuilder{name, pool},
-    ChunkedArrayIterator{source},
-    mListSize{listSize},
-    mSourceSize{(size_t)source->length()}
+SelfBuilder::SelfBuilder(arrow::MemoryPool* pool)
 {
-  switch (mListSize) {
-    case 1: {
-      mValueBuilder = mBuilder.get();
-      mArrowType = arrow::int32();
-    }; break;
-    case 2: {
-      if (preSlice().ok()) {
-        mListBuilder = std::make_unique<arrow::FixedSizeListBuilder>(pool, std::move(mBuilder), mListSize);
-        mValueBuilder = static_cast<arrow::FixedSizeListBuilder*>(mListBuilder.get())->value_builder();
-        mArrowType = arrow::fixed_size_list(arrow::int32(), 2);
-      } else {
-        throw runtime_error("Cannot pre-slice an array");
-      }
-    }; break;
-    case -1: {
-      if (preFind().ok()) {
-        mListBuilder = std::make_unique<arrow::ListBuilder>(pool, std::move(mBuilder));
-        mValueBuilder = static_cast<arrow::ListBuilder*>(mListBuilder.get())->value_builder();
-        mArrowType = arrow::list(arrow::int32());
-      } else {
-        throw runtime_error("Cannot pre-find array groups");
-      }
-    }; break;
-    default:
-      throw runtime_error_f("Invalid list size for index column: %d", mListSize);
+  auto status = arrow::MakeBuilder(pool, arrow::int32(), &mBuilder);
+  if (!status.ok()) {
+    throw framework::runtime_error("Cannot create array builder for the self-index!");
   }
 }
-
-arrow::Status IndexColumnBuilder::preSlice()
+// static_cast<ChunkedArrayIterator*>(this)->reset(pool);
+void SelfBuilder::reset(std::shared_ptr<arrow::ChunkedArray>)
 {
-  arrow::Datum value_counts;
-  auto options = arrow::compute::ScalarAggregateOptions::Defaults();
-  ARROW_ASSIGN_OR_RAISE(value_counts, arrow::compute::CallFunction("value_counts", {mSource}, &options));
-  auto pair = static_cast<arrow::StructArray>(value_counts.array());
-  mValuesArrow = std::make_shared<arrow::NumericArray<arrow::Int32Type>>(pair.field(0)->data());
-  mCounts = std::make_shared<arrow::NumericArray<arrow::Int64Type>>(pair.field(1)->data());
-  return arrow::Status::OK();
+  mBuilder->Reset();
+  keyIndex = nullptr;
 }
 
-arrow::Status IndexColumnBuilder::preFind()
+void SelfBuilder::fill(int idx)
 {
-  arrow::Datum max;
-  auto options = arrow::compute::ScalarAggregateOptions::Defaults();
-  ARROW_ASSIGN_OR_RAISE(max, arrow::compute::CallFunction("max", {mSource}, &options));
-  auto maxValue = std::dynamic_pointer_cast<arrow::Int32Scalar>(max.scalar())->value;
-  mIndices.resize(maxValue + 1);
-
-  auto row = 0;
-  for (auto i = 0; i < mSource->length(); ++i) {
-    auto v = valueAt(i);
-    if (v >= 0) {
-      mValues.emplace_back(v);
-      mIndices[v].push_back(row);
-    }
-    ++row;
-  }
-  std::sort(mValues.begin(), mValues.end());
-
-  return arrow::Status::OK();
+  (void)static_cast<arrow::Int32Builder*>(mBuilder.get())->Append(idx);
 }
 
-std::shared_ptr<arrow::ChunkedArray> IndexColumnBuilder::resultSingle() const
+std::shared_ptr<arrow::ChunkedArray> SelfBuilder::result() const
 {
   std::shared_ptr<arrow::Array> array;
-  auto status = static_cast<arrow::Int32Builder*>(mValueBuilder)->Finish(&array);
+  auto status = static_cast<arrow::Int32Builder*>(mBuilder.get())->Finish(&array);
   if (!status.ok()) {
-    throw runtime_error("Cannot build an array");
+    cannotBuildAnArray();
   }
+
   return std::make_shared<arrow::ChunkedArray>(array);
 }
 
-std::shared_ptr<arrow::ChunkedArray> IndexColumnBuilder::resultSlice() const
+SingleBuilder::SingleBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::MemoryPool* pool)
+  : ChunkedArrayIterator{source}
 {
-  std::shared_ptr<arrow::Array> array;
-  auto status = static_cast<arrow::FixedSizeListBuilder*>(mListBuilder.get())->Finish(&array);
+  auto status = arrow::MakeBuilder(pool, arrow::int32(), &mBuilder);
   if (!status.ok()) {
-    throw runtime_error("Cannot build an array");
+    throw framework::runtime_error("Cannot create array builder for the single-valued index!");
   }
-  return std::make_shared<arrow::ChunkedArray>(array);
 }
 
-std::shared_ptr<arrow::ChunkedArray> IndexColumnBuilder::resultMulti() const
+void SingleBuilder::reset(std::shared_ptr<arrow::ChunkedArray> source)
 {
-  std::shared_ptr<arrow::Array> array;
-  auto status = static_cast<arrow::ListBuilder*>(mListBuilder.get())->Finish(&array);
-  if (!status.ok()) {
-    throw runtime_error("Cannot build an array");
-  }
-  return std::make_shared<arrow::ChunkedArray>(array);
+  static_cast<ChunkedArrayIterator*>(this)->reset(source);
+  mBuilder->Reset();
 }
 
-bool IndexColumnBuilder::findSingle(int idx)
+bool SingleBuilder::find(int idx)
 {
   auto count = mSourceSize - mPosition;
   while (count > 0) {
@@ -166,13 +124,60 @@ bool IndexColumnBuilder::findSingle(int idx)
   return (mPosition < mSourceSize && valueAt(mPosition) == idx);
 }
 
-bool IndexColumnBuilder::findSlice(int idx)
+void SingleBuilder::fill(int idx)
 {
-  auto count = mValuesArrow->length() - mValuePos;
+  if (mPosition < mSourceSize && valueAt(mPosition) == idx) {
+    (void)static_cast<arrow::Int32Builder*>(mBuilder.get())->Append((int)mPosition);
+  } else {
+    (void)static_cast<arrow::Int32Builder*>(mBuilder.get())->Append(-1);
+  }
+}
+
+std::shared_ptr<arrow::ChunkedArray> SingleBuilder::result() const
+{
+  std::shared_ptr<arrow::Array> array;
+  auto status = static_cast<arrow::Int32Builder*>(mBuilder.get())->Finish(&array);
+  if (!status.ok()) {
+    cannotBuildAnArray();
+  }
+  return std::make_shared<arrow::ChunkedArray>(array);
+}
+
+SliceBuilder::SliceBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::MemoryPool* pool)
+  : ChunkedArrayIterator{source}
+{
+  if (!preSlice().ok()) {
+    throw framework::runtime_error("Cannot pre-slice the source for slice-index building");
+  }
+
+  std::unique_ptr<arrow::ArrayBuilder> builder;
+  auto status = arrow::MakeBuilder(pool, arrow::int32(), &builder);
+  if (!status.ok()) {
+    throw framework::runtime_error("Cannot create array for the slice-index builder!");
+  }
+  mListBuilder = std::make_unique<arrow::FixedSizeListBuilder>(pool, std::move(builder), 2);
+  mValueBuilder = static_cast<arrow::FixedSizeListBuilder*>(mListBuilder.get())->value_builder();
+}
+
+void SliceBuilder::reset(std::shared_ptr<arrow::ChunkedArray> source)
+{
+  static_cast<ChunkedArrayIterator*>(this)->reset(source);
+  if (!preSlice().ok()) {
+    throw framework::runtime_error("Cannot pre-slice the source for slice-index building");
+  }
+  mListBuilder->Reset();
+  mValues = nullptr;
+  mCounts = nullptr;
+  mValuePos = 0;
+}
+
+bool SliceBuilder::find(int idx)
+{
+  auto count = mValues->length() - mValuePos;
   while (count > 0) {
     auto step = count / 2;
     mValuePos += step;
-    if (mValuesArrow->Value(mValuePos) <= idx) {
+    if (mValues->Value(mValuePos) <= idx) {
       count -= step + 1;
     } else {
       mValuePos -= step;
@@ -180,32 +185,17 @@ bool IndexColumnBuilder::findSlice(int idx)
     }
   }
 
-  if (mValuePos < mValuesArrow->length() && mValuesArrow->Value(mValuePos) <= idx) {
+  if (mValuePos < mValues->length() && mValues->Value(mValuePos) <= idx) {
     ++mPosition;
   }
 
-  return (mValuePos < mValuesArrow->length() && mValuesArrow->Value(mValuePos) == idx);
-}
-
-bool IndexColumnBuilder::findMulti(int idx)
-{
-  return (std::find(mValues.begin(), mValues.end(), idx) != mValues.end());
-}
-
-void IndexColumnBuilder::fillSingle(int idx)
-{
-  // entry point
-  if (mPosition < mSourceSize && valueAt(mPosition) == idx) {
-    (void)static_cast<arrow::Int32Builder*>(mValueBuilder)->Append((int)mPosition);
-  } else {
-    (void)static_cast<arrow::Int32Builder*>(mValueBuilder)->Append(-1);
-  }
+  return (mValuePos < mValues->length() && mValues->Value(mValuePos) == idx);
 }
 
-void IndexColumnBuilder::fillSlice(int idx)
+void SliceBuilder::fill(int idx)
 {
   int data[2] = {-1, -1};
-  if (mValuePos < mValuesArrow->length() && mValuesArrow->Value(mValuePos) == idx) {
+  if (mValuePos < mValues->length() && mValues->Value(mValuePos) == idx) {
     for (auto i = 0; i < mValuePos; ++i) {
       data[0] += mCounts->Value(i);
     }
@@ -216,7 +206,60 @@ void IndexColumnBuilder::fillSlice(int idx)
   (void)static_cast<arrow::Int32Builder*>(mValueBuilder)->AppendValues(data, 2);
 }
 
-void IndexColumnBuilder::fillMulti(int idx)
+std::shared_ptr<arrow::ChunkedArray> SliceBuilder::result() const
+{
+  std::shared_ptr<arrow::Array> array;
+  auto status = static_cast<arrow::FixedSizeListBuilder*>(mListBuilder.get())->Finish(&array);
+  if (!status.ok()) {
+    cannotBuildAnArray();
+  }
+  return std::make_shared<arrow::ChunkedArray>(array);
+}
+
+arrow::Status SliceBuilder::SliceBuilder::preSlice()
+{
+  arrow::Datum value_counts;
+  auto options = arrow::compute::ScalarAggregateOptions::Defaults();
+  ARROW_ASSIGN_OR_RAISE(value_counts, arrow::compute::CallFunction("value_counts", {mSource}, &options));
+  auto pair = static_cast<arrow::StructArray>(value_counts.array());
+  mValues = std::make_shared<arrow::NumericArray<arrow::Int32Type>>(pair.field(0)->data());
+  mCounts = std::make_shared<arrow::NumericArray<arrow::Int64Type>>(pair.field(1)->data());
+  return arrow::Status::OK();
+}
+
+ArrayBuilder::ArrayBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::MemoryPool* pool)
+  : ChunkedArrayIterator{source}
+{
+  if (!preFind().ok()) {
+    throw framework::runtime_error("Cannot pre-find in a source for array-index building");
+  }
+
+  std::unique_ptr<arrow::ArrayBuilder> builder;
+  auto status = arrow::MakeBuilder(pool, arrow::int32(), &builder);
+  if (!status.ok()) {
+    throw framework::runtime_error("Cannot create array for the array-index builder!");
+  }
+  mListBuilder = std::make_unique<arrow::ListBuilder>(pool, std::move(builder));
+  mValueBuilder = static_cast<arrow::ListBuilder*>(mListBuilder.get())->value_builder();
+}
+
+void ArrayBuilder::reset(std::shared_ptr<arrow::ChunkedArray> source)
+{
+  static_cast<ChunkedArrayIterator*>(this)->reset(source);
+  if (!preFind().ok()) {
+    throw framework::runtime_error("Cannot pre-find in a source for array-index building");
+  }
+  mValues.clear();
+  mIndices.clear();
+  mListBuilder->Reset();
+}
+
+bool ArrayBuilder::find(int idx)
+{
+  return (std::find(mValues.begin(), mValues.end(), idx) != mValues.end());
+}
+
+void ArrayBuilder::fill(int idx)
 {
   (void)static_cast<arrow::ListBuilder*>(mListBuilder.get())->Append();
   if (std::find(mValues.begin(), mValues.end(), idx) != mValues.end()) {
@@ -226,6 +269,96 @@ void IndexColumnBuilder::fillMulti(int idx)
   }
 }
 
+std::shared_ptr<arrow::ChunkedArray> ArrayBuilder::result() const
+{
+  std::shared_ptr<arrow::Array> array;
+  auto status = static_cast<arrow::ListBuilder*>(mListBuilder.get())->Finish(&array);
+  if (!status.ok()) {
+    cannotBuildAnArray();
+  }
+  return std::make_shared<arrow::ChunkedArray>(array);
+}
+
+arrow::Status ArrayBuilder::preFind()
+{
+  arrow::Datum max;
+  auto options = arrow::compute::ScalarAggregateOptions::Defaults();
+  ARROW_ASSIGN_OR_RAISE(max, arrow::compute::CallFunction("max", {mSource}, &options));
+  auto maxValue = std::dynamic_pointer_cast<arrow::Int32Scalar>(max.scalar())->value;
+  mIndices.resize(maxValue + 1);
+
+  auto row = 0;
+  for (auto i = 0; i < mSource->length(); ++i) {
+    auto v = valueAt(i);
+    if (v >= 0) {
+      mValues.emplace_back(v);
+      mIndices[v].push_back(row);
+    }
+    ++row;
+  }
+  std::sort(mValues.begin(), mValues.end());
+
+  return arrow::Status::OK();
+}
+
+IndexColumnBuilder::IndexColumnBuilder(soa::IndexKind kind, int pos, arrow::MemoryPool* pool, std::shared_ptr<arrow::ChunkedArray> source)
+  : mColumnPos{pos}
+{
+  switch (kind) {
+    case soa::IndexKind::IdxSelf:
+      builder = SelfBuilder{pool};
+      break;
+    case soa::IndexKind::IdxSingle:
+      builder = SingleBuilder{source, pool};
+      break;
+    case soa::IndexKind::IdxSlice:
+      builder = SliceBuilder{source, pool};
+      break;
+    case soa::IndexKind::IdxArray:
+      builder = ArrayBuilder{source, pool};
+      break;
+    default:
+      cannotCreateIndexBuilder();
+  }
+}
+
+void IndexColumnBuilder::reset(std::shared_ptr<arrow::ChunkedArray> source)
+{
+  std::visit(
+    overloaded{
+      [](std::monostate) {},
+      [&source](auto& b) { b.reset(source); }},
+    builder);
+}
+
+bool IndexColumnBuilder::find(int idx)
+{
+  return std::visit(
+    overloaded{
+      [](std::monostate) { return false; },
+      [&idx](auto& b) { return b.find(idx); },
+    },
+    builder);
+}
+
+void IndexColumnBuilder::fill(int idx)
+{
+  std::visit(
+    overloaded{
+      [](std::monostate) {},
+      [&idx](auto& b) { b.fill(idx); }},
+    builder);
+}
+
+std::shared_ptr<arrow::ChunkedArray> IndexColumnBuilder::result() const
+{
+  return std::visit(
+    overloaded{
+      [](std::monostate) -> std::shared_ptr<arrow::ChunkedArray> { return nullptr; },
+      [](auto& b) { return b.result(); }},
+    builder);
+}
+
 std::shared_ptr<arrow::Int32Array> ChunkedArrayIterator::getCurrentArray()
 {
   auto chunk = mSource->chunk(mChunk);
@@ -265,14 +398,4 @@ int ChunkedArrayIterator::valueAt(size_t pos)
   }
   return *(mCurrent + pos);
 }
-
-std::shared_ptr<arrow::Table> makeArrowTable(const char* label, std::vector<std::shared_ptr<arrow::ChunkedArray>>&& columns, std::vector<std::shared_ptr<arrow::Field>>&& fields)
-{
-  auto schema = std::make_shared<arrow::Schema>(fields);
-  schema->WithMetadata(
-    std::make_shared<arrow::KeyValueMetadata>(
-      std::vector{std::string{"label"}},
-      std::vector{std::string{label}}));
-  return arrow::Table::Make(schema, columns);
-}
 } // namespace o2::framework
diff --git a/Framework/Core/src/IndexJSONHelpers.cxx b/Framework/Core/src/IndexJSONHelpers.cxx
new file mode 100644
index 0000000000000..19ae94a4bcd4c
--- /dev/null
+++ b/Framework/Core/src/IndexJSONHelpers.cxx
@@ -0,0 +1,230 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#include "IndexJSONHelpers.h"
+
+#include <rapidjson/reader.h>
+#include <rapidjson/prettywriter.h>
+#include <rapidjson/istreamwrapper.h>
+#include <rapidjson/ostreamwrapper.h>
+#include <rapidjson/error/en.h>
+
+#include <stack>
+#include <iostream>
+
+namespace o2::framework
+{
+namespace
+{
+struct IndexRecordsReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>, IndexRecordsReader> {
+  using Ch = rapidjson::UTF8<>::Ch;
+  using SizeType = rapidjson::SizeType;
+
+  enum struct State {
+    IN_START,
+    IN_LIST,
+    IN_RECORD,
+    IN_ERROR
+  };
+
+  std::stack<State> states;
+  std::ostringstream debug;
+
+  std::vector<o2::soa::IndexRecord> records;
+  std::string currentKey;
+  std::string label;
+  std::string columnLabel;
+  o2::soa::IndexKind kind;
+  int pos;
+
+  IndexRecordsReader()
+  {
+    debug << ">>> Start" << std::endl;
+    states.push(State::IN_START);
+  }
+
+  bool StartArray()
+  {
+    debug << "StartArray()" << std::endl;
+    if (states.top() == State::IN_START && currentKey.compare("records") == 0) {
+      states.push(State::IN_LIST);
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool EndArray(SizeType)
+  {
+    debug << "EndArray()" << std::endl;
+    if (states.top() == State::IN_LIST) {
+      // records done
+      states.pop();
+      return true;
+    }
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool Key(const Ch* str, SizeType, bool)
+  {
+    debug << "Key(" << str << ")" << std::endl;
+    currentKey = str;
+    if (states.top() == State::IN_START) {
+      if (currentKey.compare("records") == 0) {
+        return true;
+      }
+    }
+
+    if (states.top() == State::IN_RECORD) {
+      if (currentKey.compare("label") == 0) {
+        return true;
+      }
+      if (currentKey.compare("column") == 0) {
+        return true;
+      }
+      if (currentKey.compare("kind") == 0) {
+        return true;
+      }
+      if (currentKey.compare("pos") == 0) {
+        return true;
+      }
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool StartObject()
+  {
+    debug << "StartObject()" << std::endl;
+    if (states.top() == State::IN_START) {
+      return true;
+    }
+
+    if (states.top() == State::IN_LIST) {
+      states.push(State::IN_RECORD);
+      label = "";
+      kind = soa::IndexKind::IdxInvalid;
+      pos = -2;
+      return true;
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool EndObject(SizeType)
+  {
+    debug << "EndObject()" << std::endl;
+    if (states.top() == State::IN_RECORD) {
+      states.pop();
+      // add a record
+      records.emplace_back(label, columnLabel, kind, pos);
+      return true;
+    }
+
+    if (states.top() == State::IN_START) {
+      return true;
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool Uint(unsigned i)
+  {
+    debug << "Uint(" << i << ") passed to Int()" << std::endl;
+    return Int(i);
+  }
+
+  bool Int(int i)
+  {
+    debug << "Int(" << i << ")" << std::endl;
+    if (states.top() == State::IN_RECORD) {
+      if (currentKey.compare("kind") == 0) {
+        kind = (soa::IndexKind)i;
+        return true;
+      }
+      if (currentKey.compare("pos") == 0) {
+        pos = i;
+        return true;
+      }
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+
+  bool String(const Ch* str, SizeType, bool)
+  {
+    debug << "String(" << str << ")" << std::endl;
+    if (states.top() == State::IN_RECORD) {
+      if (currentKey.compare("label") == 0) {
+        label = str;
+        return true;
+      }
+      if (currentKey.compare("column") == 0) {
+        columnLabel = str;
+        return true;
+      }
+    }
+
+    states.push(State::IN_ERROR);
+    return false;
+  }
+};
+} // namespace
+
+std::vector<o2::soa::IndexRecord> IndexJSONHelpers::read(std::istream& s)
+{
+  rapidjson::Reader reader;
+  rapidjson::IStreamWrapper isw(s);
+  IndexRecordsReader irreader;
+
+  bool ok = reader.Parse(isw, irreader);
+
+  if (!ok) {
+    throw framework::runtime_error_f("Cannot parse serialized index records vector, error: %s at offset: %d", rapidjson::GetParseError_En(reader.GetParseErrorCode()), reader.GetErrorOffset());
+  }
+  return irreader.records;
+}
+
+namespace
+{
+void writeRecords(rapidjson::Writer<rapidjson::OStreamWrapper>& w, std::vector<o2::soa::IndexRecord>& records)
+{
+  for (auto& r : records) {
+    w.StartObject();
+    w.Key("label");
+    w.String(r.label.c_str());
+    w.Key("column");
+    w.String(r.columnLabel.c_str());
+    w.Key("kind");
+    w.Int((int)r.kind);
+    w.Key("pos");
+    w.Int(r.pos);
+    w.EndObject();
+  }
+}
+} // namespace
+
+void IndexJSONHelpers::write(std::ostream& o, std::vector<o2::soa::IndexRecord>& irs)
+{
+  rapidjson::OStreamWrapper osw(o);
+  rapidjson::Writer<rapidjson::OStreamWrapper> w(osw);
+  w.StartObject();
+  w.Key("records");
+  w.StartArray();
+  writeRecords(w, irs);
+  w.EndArray();
+  w.EndObject();
+}
+} // namespace o2::framework
diff --git a/Framework/Core/src/IndexJSONHelpers.h b/Framework/Core/src/IndexJSONHelpers.h
new file mode 100644
index 0000000000000..dee534ae390f5
--- /dev/null
+++ b/Framework/Core/src/IndexJSONHelpers.h
@@ -0,0 +1,25 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef INDEXJSONHELPERS_H
+#define INDEXJSONHELPERS_H
+
+#include <Framework/AnalysisHelpers.h>
+
+namespace o2::framework
+{
+struct IndexJSONHelpers {
+  static std::vector<o2::soa::IndexRecord> read(std::istream& s);
+  static void write(std::ostream& o, std::vector<o2::soa::IndexRecord>& irs);
+};
+
+} // namespace o2::framework
+
+#endif // INDEXJSONHELPERS_H
diff --git a/Framework/Core/src/TableBuilder.cxx b/Framework/Core/src/TableBuilder.cxx
index c80fef9f0533c..955fe686e12a8 100644
--- a/Framework/Core/src/TableBuilder.cxx
+++ b/Framework/Core/src/TableBuilder.cxx
@@ -81,94 +81,7 @@ void TableBuilder::validate() const
 
 void TableBuilder::setLabel(const char* label)
 {
-  mSchema = mSchema->WithMetadata(std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{std::string{label}}));
-}
-
-std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema, size_t nColumns,
-                                            expressions::Projector* projectors, const char* name,
-                                            std::shared_ptr<gandiva::Projector>& projector)
-{
-  if (projector == nullptr) {
-    projector = framework::expressions::createProjectorHelper(nColumns, projectors, fullTable->schema(), newSchema->fields());
-  }
-
-  arrow::TableBatchReader reader(*fullTable);
-  std::shared_ptr<arrow::RecordBatch> batch;
-  arrow::ArrayVector v;
-  std::vector<arrow::ArrayVector> chunks;
-  chunks.resize(nColumns);
-  std::vector<std::shared_ptr<arrow::ChunkedArray>> arrays;
-
-  while (true) {
-    auto s = reader.ReadNext(&batch);
-    if (!s.ok()) {
-      throw runtime_error_f("Cannot read batches from source table to spawn %s: %s", name, s.ToString().c_str());
-    }
-    if (batch == nullptr) {
-      break;
-    }
-    try {
-      s = projector->Evaluate(*batch, arrow::default_memory_pool(), &v);
-      if (!s.ok()) {
-        throw runtime_error_f("Cannot apply projector to source table of %s: %s", name, s.ToString().c_str());
-      }
-    } catch (std::exception& e) {
-      throw runtime_error_f("Cannot apply projector to source table of %s: exception caught: %s", name, e.what());
-    }
-
-    for (auto i = 0U; i < nColumns; ++i) {
-      chunks[i].emplace_back(v.at(i));
-    }
-  }
-
-  arrays.reserve(nColumns);
-  for (auto i = 0U; i < nColumns; ++i) {
-    arrays.push_back(std::make_shared<arrow::ChunkedArray>(chunks[i]));
-  }
-
-  addLabelToSchema(newSchema, name);
-  return arrow::Table::Make(newSchema, arrays);
-}
-
-std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const& fullTable, std::shared_ptr<arrow::Schema> newSchema,
-                                            const char* name, size_t nColumns,
-                                            std::shared_ptr<gandiva::Projector> const& projector)
-{
-  arrow::TableBatchReader reader(*fullTable);
-  std::shared_ptr<arrow::RecordBatch> batch;
-  arrow::ArrayVector v;
-  std::vector<arrow::ArrayVector> chunks;
-  chunks.resize(nColumns);
-  std::vector<std::shared_ptr<arrow::ChunkedArray>> arrays;
-
-  while (true) {
-    auto s = reader.ReadNext(&batch);
-    if (!s.ok()) {
-      throw runtime_error_f("Cannot read batches from the source table to spawn %s: %s", name, s.ToString().c_str());
-    }
-    if (batch == nullptr) {
-      break;
-    }
-    try {
-      s = projector->Evaluate(*batch, arrow::default_memory_pool(), &v);
-      if (!s.ok()) {
-        throw runtime_error_f("Cannot apply projector to the source table of %s: %s", name, s.ToString().c_str());
-      }
-    } catch (std::exception& e) {
-      throw runtime_error_f("Cannot apply projector to the source table of %s: exception caught: %s", name, e.what());
-    }
-
-    for (auto i = 0U; i < nColumns; ++i) {
-      chunks[i].emplace_back(v.at(i));
-    }
-  }
-
-  arrays.reserve(nColumns);
-  for (auto i = 0U; i < nColumns; ++i) {
-    arrays.push_back(std::make_shared<arrow::ChunkedArray>(chunks[i]));
-  }
-
-  return arrow::Table::Make(newSchema, arrays);
+  addLabelToSchema(mSchema, label);
 }
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index b3af5636127f9..61443f5f71616 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -11,7 +11,6 @@
 #include "WorkflowHelpers.h"
 #include "Framework/AnalysisSupportHelpers.h"
 #include "Framework/AlgorithmSpec.h"
-#include "Framework/AODReaderHelpers.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/ConfigParamsHelper.h"
 #include "Framework/CommonDataProcessors.h"
@@ -416,7 +415,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     "internal-dpl-aod-index-builder",
     {},
     {},
-    readers::AODReaderHelpers::indexBuilderCallback(ac.requestedIDXs),
+    PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx), // readers::AODReaderHelpers::indexBuilderCallback(ctx),
     {}};
   AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.requestedIDXs, ac.requestedAODs, ac.requestedDYNs, indexBuilder);
 
@@ -436,7 +435,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     "internal-dpl-aod-spawner",
     {},
     {},
-    readers::AODReaderHelpers::aodSpawnerCallback(ctx),
+    PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx), // readers::AODReaderHelpers::aodSpawnerCallback(ctx),
     {}};
   AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, aodSpawner);
 
diff --git a/Framework/Core/test/test_Expressions.cxx b/Framework/Core/test/test_Expressions.cxx
index 41be7d53d2276..b4a65fb0c7b48 100644
--- a/Framework/Core/test/test_Expressions.cxx
+++ b/Framework/Core/test/test_Expressions.cxx
@@ -454,4 +454,33 @@ TEST_CASE("TestExpressionSerialization")
   ism.str(osm.str());
   auto newSchemap = ArrowJSONHelpers::read(ism);
   REQUIRE(schemap->ToString() == newSchemap->ToString());
+
+  osm.clear();
+  osm.str("");
+  ArrowJSONHelpers::write(osm, schemap1);
+
+  ism.clear();
+  ism.str(osm.str());
+  auto newSchemap1 = ArrowJSONHelpers::read(ism);
+  REQUIRE(schemap1->ToString() == newSchemap1->ToString());
+
+  osm.clear();
+  osm.str("");
+  auto realisticSchema = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(o2::aod::MetadataTrait<o2::aod::Hash<"HMPID/1"_h>>::metadata::persistent_columns_t{}));
+  ArrowJSONHelpers::write(osm, realisticSchema);
+
+  ism.clear();
+  ism.str(osm.str());
+  auto restoredSchema = ArrowJSONHelpers::read(ism);
+  REQUIRE(realisticSchema->ToString() == restoredSchema->ToString());
+
+  osm.clear();
+  osm.str("");
+  auto realisticSchema1 = std::make_shared<arrow::Schema>(o2::soa::createFieldsFromColumns(o2::aod::MetadataTrait<o2::aod::Hash<"ZDC/1"_h>>::metadata::persistent_columns_t{}));
+  ArrowJSONHelpers::write(osm, realisticSchema1);
+
+  ism.clear();
+  ism.str(osm.str());
+  auto restoredSchema1 = ArrowJSONHelpers::read(ism);
+  REQUIRE(realisticSchema1->ToString() == restoredSchema1->ToString());
 }
diff --git a/Framework/Core/test/test_IndexBuilder.cxx b/Framework/Core/test/test_IndexBuilder.cxx
index ea9f715f20c8a..e357b1164af80 100644
--- a/Framework/Core/test/test_IndexBuilder.cxx
+++ b/Framework/Core/test/test_IndexBuilder.cxx
@@ -10,7 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "Framework/AnalysisDataModel.h"
-#include "Framework/AnalysisTask.h"
+#include "../src/IndexJSONHelpers.h"
 #include <catch_amalgamated.hpp>
 
 using namespace o2::framework;
@@ -102,8 +102,11 @@ TEST_CASE("TestIndexBuilder")
   auto t4 = b4.finalize();
   Categorys st4{t4};
 
-  using m1 = MetadataTrait<o2::aod::Hash<"Index1/0"_h>>::metadata;
-  auto t5 = IndexBuilder<Exclusive>::indexBuilder<Points, m1::sources.size(), m1::sources>("test1a", {t1, t2, t3, t4}, typename IDXs::persistent_columns_t{});
+  auto map = getIndexMapping<o2::aod::MetadataTrait<o2::aod::Hash<"Index1/0"_h>>::metadata>();
+  auto schema1 = o2::aod::MetadataTrait<o2::aod::Hash<"Index1/0"_h>>::metadata::getSchema();
+  std::vector<o2::framework::IndexColumnBuilder> builders1;
+  auto t5 = IndexBuilder::materialize(builders1, {t1, t2, t3, t4}, map, schema1, true);
+  // auto t5 = IndexBuilder::materialize({t1, t2, t3, t4}, map, schema1, true);
   REQUIRE(t5->num_rows() == 4);
   IDXs idxt{t5};
   idxt.bindExternalIndices(&st1, &st2, &st3, &st4);
@@ -113,8 +116,10 @@ TEST_CASE("TestIndexBuilder")
     REQUIRE(row.category().pointId() == row.pointId());
   }
 
-  using m2 = MetadataTrait<o2::aod::Hash<"Index2/0"_h>>::metadata;
-  auto t6 = IndexBuilder<Sparse>::indexBuilder<Points, m2::sources.size(), m2::sources>("test3", {t2, t1, t3, t4}, typename IDX2s::persistent_columns_t{});
+  map = getIndexMapping<o2::aod::MetadataTrait<o2::aod::Hash<"Index2/0"_h>>::metadata>();
+  auto schema2 = o2::aod::MetadataTrait<o2::aod::Hash<"Index2/0"_h>>::metadata::getSchema();
+  std::vector<o2::framework::IndexColumnBuilder> builders2;
+  auto t6 = IndexBuilder::materialize(builders2, {t2, t1, t3, t4}, map, schema2, false);
   REQUIRE(t6->num_rows() == st2.size());
   IDX2s idxs{t6};
   std::array<int, 7> fs{0, 1, 2, -1, -1, 4, -1};
@@ -212,8 +217,10 @@ TEST_CASE("AdvancedIndexTables")
                                                    {14, 34},
                                                    {8, 31, 42, 46, 58}}};
 
-  using m3 = MetadataTrait<o2::aod::Hash<"Index3/0"_h>>::metadata;
-  auto t3 = IndexBuilder<Sparse>::indexBuilder<Points, m3::sources.size(), m3::sources>("test4", {t1, t2, tc}, typename IDX3s::persistent_columns_t{});
+  auto map = getIndexMapping<o2::aod::MetadataTrait<o2::aod::Hash<"Index3/0"_h>>::metadata>();
+  auto schema3 = o2::aod::MetadataTrait<o2::aod::Hash<"Index3/0"_h>>::metadata::getSchema();
+  std::vector<o2::framework::IndexColumnBuilder> builders3;
+  auto t3 = IndexBuilder::materialize(builders3, {t1, t2, tc}, map, schema3, false);
   REQUIRE(t3->num_rows() == st1.size());
   IDX3s idxs{t3};
   idxs.bindExternalIndices(&st1, &st2, &st3);
@@ -235,3 +242,38 @@ TEST_CASE("AdvancedIndexTables")
     ++count;
   }
 }
+
+TEST_CASE("IndexRecordsSerialization")
+{
+  auto map = getIndexMapping<o2::aod::MetadataTrait<o2::aod::Hash<"Index1/0"_h>>::metadata>();
+
+  std::stringstream osm;
+  IndexJSONHelpers::write(osm, map);
+
+  std::stringstream ism;
+  ism.str(osm.str());
+  auto rmap = IndexJSONHelpers::read(ism);
+  REQUIRE(map == rmap);
+
+  map = getIndexMapping<o2::aod::MetadataTrait<o2::aod::Hash<"Index2/0"_h>>::metadata>();
+
+  osm.clear();
+  osm.str("");
+  IndexJSONHelpers::write(osm, map);
+
+  ism.clear();
+  ism.str(osm.str());
+  rmap = IndexJSONHelpers::read(ism);
+  REQUIRE(map == rmap);
+
+  map = getIndexMapping<o2::aod::MetadataTrait<o2::aod::Hash<"Index3/0"_h>>::metadata>();
+
+  osm.clear();
+  osm.str("");
+  IndexJSONHelpers::write(osm, map);
+
+  ism.clear();
+  ism.str(osm.str());
+  rmap = IndexJSONHelpers::read(ism);
+  REQUIRE(map == rmap);
+}

From 821e1a923e33d4c825dd5b01f1a2404f8d798b18 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 26 Nov 2025 14:45:19 +0100
Subject: [PATCH 1065/1764] GPU: Fix time measurements of reco steps,
 synchronization was missing

---
 GPU/GPUTracking/Global/GPUChain.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index e3a20ad81a2cb..9ce3da1092e83 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -297,6 +297,7 @@ inline int32_t GPUChain::runRecoStep(RecoStep step, S T::*func, Args... args)
     }
     int32_t retVal = (reinterpret_cast<T*>(this)->*func)(args...);
     if (timer) {
+      SynchronizeGPU();
       timer->timerTotal.Stop();
       timer->timerCPU += (double)(std::clock() - c) / CLOCKS_PER_SEC;
     }

From f355002fa08e6a194814686138c6cc157fded843 Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Wed, 26 Nov 2025 18:30:49 +0100
Subject: [PATCH 1066/1764] FST checks to avoid node crashes for SLURM, MI100
 and FMQ segments

---
 prodtests/full-system-test/start_tmux.sh | 34 ++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/prodtests/full-system-test/start_tmux.sh b/prodtests/full-system-test/start_tmux.sh
index 22b603f48a0d0..22b658856803a 100755
--- a/prodtests/full-system-test/start_tmux.sh
+++ b/prodtests/full-system-test/start_tmux.sh
@@ -1,5 +1,39 @@
 #!/bin/bash
 
+### --- Early safety checks ----------------------------------------------------
+
+# Skip checks if FST_RUN_WITHOUT_CHECKS=1
+if [[ "${FST_RUN_WITHOUT_CHECKS:-0}" != "1" ]]; then
+
+  # 1. Abort if running inside a Slurm shell
+  if [[ -n "${SLURM_JOB_ID:-}" ]]; then
+    echo "ERROR: This script must not be run inside a Slurm job (SLURM_JOB_ID=${SLURM_JOB_ID})." >&2
+    echo "Please run it from a normal ssh shell." >&2
+    exit 1
+  fi
+
+  # 2. Abort if FMQ shared-memory files exist in /dev/shm
+  if compgen -G "/dev/shm/fmq*" > /dev/null; then
+    echo "ERROR: Found existing /dev/shm/fmq* files." >&2
+    echo "Please clean them manually before running the FST." >&2
+    exit 1
+  fi
+
+  # 3. MI100 check: detect MI100 GPU but EPN_NODE_MI100 not set or set to 0
+  if lspci | grep -qi "MI100"; then
+    if [[ -z "${EPN_NODE_MI100:-}" || "${EPN_NODE_MI100}" == "0" ]]; then
+      echo "ERROR: MI100 GPU detected on this node, but EPN_NODE_MI100 is not set to 1." >&2
+      echo "Please export EPN_NODE_MI100=1 before running this script." >&2
+      echo "See installation instructions here:" >&2
+      echo "  https://alice-pdp-operations.docs.cern.ch/o2install/#install-and-validate-the-new-o2pdpsuite-on-one-production-epn-using-the-fst"
+      exit 1
+    fi
+  fi
+
+fi
+
+### ---------------------------------------------------------------------------
+
 if [ "0$1" != "0dd" ] && [ "0$1" != "0rr" ] && [ "0$1" != "0tf" ]; then
   echo Please indicate whether to start with raw-reader [rr] or with DataDistribution [dd] or TfReader [tf] 1>&2
   exit 1

From 7b0862460d7cf26a67d492c2c081172fbc9ddcd1 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 26 Nov 2025 20:32:43 +0100
Subject: [PATCH 1067/1764] DPL: add protection against fork bomb (#14858)

---
 Framework/Core/src/runDataProcessing.cxx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index f5992f6dbf359..c36b1deadeefb 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -748,7 +748,11 @@ void spawnDevice(uv_loop_t* loop,
     for (auto& env : execution.environ) {
       putenv(strdup(DeviceSpecHelpers::reworkTimeslicePlaceholder(env, spec).data()));
     }
-    execvp(execution.args[0], execution.args.data());
+    int err = execvp(execution.args[0], execution.args.data());
+    if (err) {
+      perror("Unable to start child process");
+      exit(1);
+    }
   } else {
     O2_SIGNPOST_ID_GENERATE(sid, driver);
     O2_SIGNPOST_EVENT_EMIT(driver, sid, "spawnDevice", "New child at %{pid}d", id);

From 297aa69d7e5ec458fee6d3de4dc5c4ee1e953c85 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Wed, 26 Nov 2025 14:06:40 +0100
Subject: [PATCH 1068/1764] Fix of custom streamer code

Fixing the custom streamer code for `CalArray<o2::tpc::PadFlags>`
and resolving https://its.cern.ch/jira/browse/O2-6509
---
 Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx b/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
index 7e3499dec14d9..dca7ba35004c9 100644
--- a/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
+++ b/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
@@ -39,6 +39,7 @@ void MemberVectorPadFlagsStreamer(TBuffer& R__b, void* objp, int n)
   }
   std::vector<o2::tpc::PadFlags>* obj = static_cast<std::vector<o2::tpc::PadFlags>*>(objp);
   if (R__b.IsReading()) {
+    obj->clear();
     std::vector<int> R__stl;
     R__stl.clear();
     int R__n;
@@ -50,7 +51,8 @@ void MemberVectorPadFlagsStreamer(TBuffer& R__b, void* objp, int n)
       R__stl.push_back(readtemp);
     }
     auto data = reinterpret_cast<unsigned short*>(R__stl.data());
-    for (int i = 0; i < R__n; ++i) {
+    constexpr size_t bloatfactor = sizeof(int) / sizeof(o2::tpc::PadFlags);
+    for (int i = 0; i < bloatfactor * R__n; ++i) {
       obj->push_back(static_cast<o2::tpc::PadFlags>(data[i]));
     }
   } else {
@@ -63,6 +65,8 @@ void MemberVectorPadFlagsStreamer(TBuffer& R__b, void* objp, int n)
 }
 
 // register the streamer via static global initialization (on library load)
+// the streamer is only correct in combination with new ROOT
+#if ROOT_VERSION_CODE >= ROOT_VERSION(6, 33, 00)
 namespace ROOT
 {
 static __attribute__((used)) int _R__dummyStreamer_3 =
@@ -79,3 +83,4 @@ static __attribute__((used)) int _R__dummyStreamer_3 =
     return 0;
   })();
 } // namespace ROOT
+#endif
\ No newline at end of file

From 5b0d25dc159911a810c88d895f0c443ff24e3ff1 Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Thu, 27 Nov 2025 01:58:02 +0100
Subject: [PATCH 1069/1764] Possibility to combine 2 material LUTs (#14861)

---
 .../include/DetectorsBase/MatLayerCylSet.h    |  2 +-
 Detectors/Base/src/MatLayerCylSet.cxx         | 30 +++++++++++++++----
 2 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/Detectors/Base/include/DetectorsBase/MatLayerCylSet.h b/Detectors/Base/include/DetectorsBase/MatLayerCylSet.h
index 0a53ab00b16f2..cba6e5cebcfc8 100644
--- a/Detectors/Base/include/DetectorsBase/MatLayerCylSet.h
+++ b/Detectors/Base/include/DetectorsBase/MatLayerCylSet.h
@@ -87,7 +87,7 @@ class MatLayerCylSet : public o2::gpu::FlatObject
   void flatten();
 
   MatLayerCyl& getLayer(int i) { return get()->mLayers[i]; }
-  MatLayerCylSet* extractCopy(float rmin, float rmax, float tol = 1e-3) const;
+  MatLayerCylSet* extractCopy(float rmin, float rmax, float tol = 1e-3, const MatLayerCylSet* toAdd = nullptr) const;
   void finalizeStructures();
 
 #endif // !GPUCA_ALIGPUCODE
diff --git a/Detectors/Base/src/MatLayerCylSet.cxx b/Detectors/Base/src/MatLayerCylSet.cxx
index c287723839d22..1d904ed01e699 100644
--- a/Detectors/Base/src/MatLayerCylSet.cxx
+++ b/Detectors/Base/src/MatLayerCylSet.cxx
@@ -608,8 +608,12 @@ void MatLayerCylSet::fixPointers(char* oldPtr, char* newPtr, bool newPtrValid)
 
 #ifndef GPUCA_ALIGPUCODE // this part is unvisible on GPU version
 
-MatLayerCylSet* MatLayerCylSet::extractCopy(float rmin, float rmax, float tolerance) const
+MatLayerCylSet* MatLayerCylSet::extractCopy(float rmin, float rmax, float tolerance, const MatLayerCylSet* addTo) const
 {
+  // extract layers in the covering rmin-rmax range. If addTo is provided, simply substitute its layers by those from this
+  if (addTo && addTo->getNLayers() != getNLayers()) {
+    LOGP(fatal, "addTo has {} layers, this has {}", addTo->getNLayers(), getNLayers());
+  }
   Ray ray(std::max(getRMin(), rmin), 0., 0., std::min(getRMax(), rmax), 0., 0.);
   short lmin, lmax;
   if (!getLayersRange(ray, lmin, lmax)) {
@@ -618,23 +622,37 @@ MatLayerCylSet* MatLayerCylSet::extractCopy(float rmin, float rmax, float tolera
   }
   LOGP(info, "Will extract layers {}:{} (out of {} layers) for {} < r < {}", lmin, lmax, getNLayers(), rmin, rmax);
   MatLayerCylSet* copy = new MatLayerCylSet();
-  int lrCount = 0;
-  for (int il = lmin; il <= lmax; il++) {
-    const auto& lr = getLayer(il);
+  int lrCount = 0, lrCounOld = 0, lrCountTot = 0;
+  auto addLr = [copy, &lrCountTot](const MatLayerCyl& lr) {
     float drphi = lr.getDPhi() * (lr.getRMin() + lr.getRMax()) / 2. * 0.999;
     copy->addLayer(lr.getRMin(), lr.getRMax(), lr.getZMax(), lr.getDZ(), drphi);
-    auto& lrNew = copy->getLayer(lrCount);
+    auto& lrNew = copy->getLayer(lrCountTot++);
     for (int iz = 0; iz < lrNew.getNZBins(); iz++) {
       for (int ip = 0; ip < lrNew.getNPhiBins(); ip++) {
         lrNew.getCellPhiBin(ip, iz).set(lr.getCellPhiBin(ip, iz));
       }
     }
+  };
+  if (addTo) {
+    for (int il = 0; il < lmin; il++) {
+      addLr(addTo->getLayer(il));
+      lrCounOld++;
+    }
+  }
+  for (int il = lmin; il <= lmax; il++) {
+    addLr(getLayer(il));
     lrCount++;
   }
-
+  if (addTo) {
+    for (int il = lmax + 1; il < getNLayers(); il++) {
+      addLr(addTo->getLayer(il));
+      lrCounOld++;
+    }
+  }
   copy->finalizeStructures();
   copy->optimizePhiSlices(tolerance);
   copy->flatten();
+  LOGP(info, "Added layers {}:{} for {}<r<{} {}", lmin, lmax, rmin, rmax, fmt::format(", {} layers were transferred from additional set", lrCounOld));
   return copy;
 }
 

From 426b4e1e3a67d888bf3a49e58854cc0a617b97a6 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 27 Nov 2025 09:52:04 +0100
Subject: [PATCH 1070/1764] ITS: GPU: reverse destruction order to fix crash

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 GPU/GPUTracking/Global/GPUChainITS.cxx | 10 +++-------
 GPU/GPUTracking/Global/GPUChainITS.h   |  6 +++---
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index 9be553de27f95..c72023bdf42ce 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -30,11 +30,11 @@ class GPUFrameworkExternalAllocator final : public o2::its::ExternalAllocator
     return mFWReco->AllocateDirectMemory(size, mType);
   }
   void deallocate(char* ptr, size_t size) final {} // this is a simple no-op
-  void pushTagOnStack(uint64_t tag)
+  void pushTagOnStack(uint64_t tag) final
   {
     mFWReco->PushNonPersistentMemory(tag);
   }
-  void popTagOffStack(uint64_t tag)
+  void popTagOffStack(uint64_t tag) final
   {
     mFWReco->PopNonPersistentMemory(GPUDataTypes::RecoStep::ITSTracking, tag);
   }
@@ -45,11 +45,7 @@ class GPUFrameworkExternalAllocator final : public o2::its::ExternalAllocator
 };
 } // namespace o2::its
 
-GPUChainITS::~GPUChainITS()
-{
-  mITSTrackerTraits.reset();
-  mITSVertexerTraits.reset();
-}
+GPUChainITS::~GPUChainITS() = default;
 
 GPUChainITS::GPUChainITS(GPUReconstruction* rec) : GPUChain(rec) {}
 
diff --git a/GPU/GPUTracking/Global/GPUChainITS.h b/GPU/GPUTracking/Global/GPUChainITS.h
index a607f66322bab..4aa97f3f47784 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.h
+++ b/GPU/GPUTracking/Global/GPUChainITS.h
@@ -34,7 +34,7 @@ class GPUChainITS final : public GPUChain
   friend class GPUReconstruction;
 
  public:
-  ~GPUChainITS() override;
+  ~GPUChainITS() final;
   int32_t Init() override;
   int32_t PrepareEvent() override;
   int32_t Finalize() override;
@@ -50,10 +50,10 @@ class GPUChainITS final : public GPUChain
 
  protected:
   GPUChainITS(GPUReconstruction* rec);
+  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkAllocator;
+  std::unique_ptr<o2::its::TimeFrame<7>> mITSTimeFrame;
   std::unique_ptr<o2::its::TrackerTraits<7>> mITSTrackerTraits;
   std::unique_ptr<o2::its::VertexerTraits<7>> mITSVertexerTraits;
-  std::unique_ptr<o2::its::TimeFrame<7>> mITSTimeFrame;
-  std::unique_ptr<o2::its::GPUFrameworkExternalAllocator> mFrameworkAllocator;
 };
 } // namespace o2::gpu
 

From f9f379846815b1076692725796322e9eed4910c1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 27 Nov 2025 18:40:40 +0100
Subject: [PATCH 1071/1764] GPU: Hide FairLogger more effectively when
 compiling kernels

---
 GPU/Common/GPUCommonLogger.h                              | 2 +-
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/GPU/Common/GPUCommonLogger.h b/GPU/Common/GPUCommonLogger.h
index 0b6b5ae401244..a70710e9ae744 100644
--- a/GPU/Common/GPUCommonLogger.h
+++ b/GPU/Common/GPUCommonLogger.h
@@ -45,7 +45,7 @@ struct DummyLogger {
 #define LOGP(...)
 // #define LOGP(...) static_assert(false, "LOGP(...) unsupported in GPU code");
 
-#elif defined(GPUCA_STANDALONE)
+#elif defined(GPUCA_STANDALONE) || defined(GPUCA_GPUCODE_COMPILEKERNELS) || defined(GPUCA_COMPILEKERNELS)
 #include <iostream>
 #include <cstdio>
 #define LOG(type) std::cout
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
index e8779415f0ea4..d668bc7da1513 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAKernels.cu
@@ -12,6 +12,7 @@
 /// \file GPUReconstructionCUDAKernels.cu
 /// \author David Rohr
 
+#define GPUCA_COMPILEKERNELS
 #include "GPUReconstructionCUDAIncludesSystem.h"
 #include "GPUReconstructionCUDADef.h"
 

From 1d620f24fbe547e3f76ab3540ebc6ab0c43d711c Mon Sep 17 00:00:00 2001
From: Christian Sonnabend <sonnabendch@gmail.com>
Date: Fri, 28 Nov 2025 10:53:22 +0100
Subject: [PATCH 1072/1764] [NN Clusterizer] CCDB fetching within reco workflow
 (#14841)

* Improve GPU filling kernel speed

* Adjusting parameter bounds and additional GPU kernel optimizations

* Adding back if statement for early exit

* const'ing + fixing CPU kernel

* Remiving print statements

* Fixing CI build issue

* Working version of NN CCDB fetching and loading to file

* Cleanup

* Please consider the following formatting changes

* Using char* buffer for model loading

* Please consider the following formatting changes

* Bug-fix

* Working version of CCDB fetching and loading into ROOT class of std::vector<char>

* Please consider the following formatting changes

* Disable dumpToFile by default

* Moving macro, adding o2-test

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Common/ML/include/ML/OrtInterface.h           |   1 +
 Common/ML/src/OrtInterface.cxx                |  18 ++
 .../TPC/base/test/testTPCCDBInterface.cxx     |   1 -
 Detectors/TPC/calibration/CMakeLists.txt      |   2 -
 .../TPCCalibration/NeuralNetworkClusterizer.h |  38 ---
 .../src/NeuralNetworkClusterizer.cxx          |  48 ----
 GPU/GPUTracking/CMakeLists.txt                |   1 +
 GPU/GPUTracking/DataTypes/GPUDataTypes.h      |   4 +
 .../DataTypes/ORTRootSerializer.cxx           |  25 ++
 GPU/GPUTracking/DataTypes/ORTRootSerializer.h |  43 ++++
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  12 +-
 .../GPUTrackingLinkDef_O2_DataTypes.h         |   1 +
 .../Global/GPUChainTrackingClusterizer.cxx    |  21 +-
 .../GPUTPCNNClusterizerHost.cxx               |   2 +-
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |   7 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          | 129 ++++++----
 GPU/Workflow/src/GPUWorkflowTPC.cxx           |  28 +++
 macro/CMakeLists.txt                          |   4 +
 macro/convert_onnx_to_root_serialized.C       | 220 ++++++++++++++++++
 19 files changed, 459 insertions(+), 146 deletions(-)
 delete mode 100644 Detectors/TPC/calibration/include/TPCCalibration/NeuralNetworkClusterizer.h
 delete mode 100644 Detectors/TPC/calibration/src/NeuralNetworkClusterizer.cxx
 create mode 100644 GPU/GPUTracking/DataTypes/ORTRootSerializer.cxx
 create mode 100644 GPU/GPUTracking/DataTypes/ORTRootSerializer.h
 create mode 100644 macro/convert_onnx_to_root_serialized.C

diff --git a/Common/ML/include/ML/OrtInterface.h b/Common/ML/include/ML/OrtInterface.h
index 04a5e0ba5c9fc..987ce8fb4d6dd 100644
--- a/Common/ML/include/ML/OrtInterface.h
+++ b/Common/ML/include/ML/OrtInterface.h
@@ -51,6 +51,7 @@ class OrtModel
   void initOptions(std::unordered_map<std::string, std::string> optionsMap);
   void initEnvironment();
   void initSession();
+  void initSessionFromBuffer(const char* buffer, size_t bufferSize);
   void memoryOnDevice(int32_t = 0);
   bool isInitialized() { return mInitialized; }
   void resetSession();
diff --git a/Common/ML/src/OrtInterface.cxx b/Common/ML/src/OrtInterface.cxx
index d30d05d1d1a00..8f88ab18dacbd 100644
--- a/Common/ML/src/OrtInterface.cxx
+++ b/Common/ML/src/OrtInterface.cxx
@@ -138,6 +138,24 @@ void OrtModel::initEnvironment()
   (mPImplOrt->env)->DisableTelemetryEvents(); // Disable telemetry events
 }
 
+void OrtModel::initSessionFromBuffer(const char* buffer, size_t bufferSize)
+{
+  mPImplOrt->sessionOptions.AddConfigEntry("session.load_model_format", "ONNX");
+  mPImplOrt->sessionOptions.AddConfigEntry("session.use_ort_model_bytes_directly", "1");
+
+  mPImplOrt->session = std::make_unique<Ort::Session>(*mPImplOrt->env,
+                                                      buffer,
+                                                      bufferSize,
+                                                      mPImplOrt->sessionOptions);
+  mPImplOrt->ioBinding = std::make_unique<Ort::IoBinding>(*mPImplOrt->session);
+
+  setIO();
+
+  if (mLoggingLevel < 2) {
+    LOG(info) << "(ORT) Model loaded successfully from buffer! (inputs: " << printShape(mInputShapes, mInputNames) << ", outputs: " << printShape(mOutputShapes, mInputNames) << ")";
+  }
+}
+
 void OrtModel::initSession()
 {
   if (mAllocateDeviceMemory) {
diff --git a/Detectors/TPC/base/test/testTPCCDBInterface.cxx b/Detectors/TPC/base/test/testTPCCDBInterface.cxx
index 3074c5e90a00c..5a5384a4134ed 100644
--- a/Detectors/TPC/base/test/testTPCCDBInterface.cxx
+++ b/Detectors/TPC/base/test/testTPCCDBInterface.cxx
@@ -22,7 +22,6 @@
 
 // o2 includes
 #include "TPCBase/CDBInterface.h"
-#include "TPCBase/CDBInterface.h"
 #include "TPCBase/CalArray.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/Mapper.h"
diff --git a/Detectors/TPC/calibration/CMakeLists.txt b/Detectors/TPC/calibration/CMakeLists.txt
index 8bcb3254edb32..e5cc25230d2fc 100644
--- a/Detectors/TPC/calibration/CMakeLists.txt
+++ b/Detectors/TPC/calibration/CMakeLists.txt
@@ -25,7 +25,6 @@ o2_add_library(TPCCalibration
                        src/CalibPadGainTracksBase.cxx
                        src/CalibLaserTracks.cxx
                        src/LaserTracksCalibrator.cxx
-                       src/NeuralNetworkClusterizer.cxx
                        src/SACDecoder.cxx
                        src/IDCAverageGroup.cxx
                        src/IDCAverageGroupBase.cxx
@@ -84,7 +83,6 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/FastHisto.h
                                   include/TPCCalibration/CalibLaserTracks.h
                                   include/TPCCalibration/LaserTracksCalibrator.h
-                                  include/TPCCalibration/NeuralNetworkClusterizer.h
                                   include/TPCCalibration/SACDecoder.h
                                   include/TPCCalibration/IDCAverageGroup.h
                                   include/TPCCalibration/IDCAverageGroupBase.h
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/NeuralNetworkClusterizer.h b/Detectors/TPC/calibration/include/TPCCalibration/NeuralNetworkClusterizer.h
deleted file mode 100644
index 196bba644714c..0000000000000
--- a/Detectors/TPC/calibration/include/TPCCalibration/NeuralNetworkClusterizer.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file   NeuralNetworkClusterizer.h
-/// \brief  Fetching neural networks for clusterization from CCDB
-/// \author Christian Sonnabend
-
-#ifndef AliceO2_TPC_NeuralNetworkClusterizer_h
-#define AliceO2_TPC_NeuralNetworkClusterizer_h
-
-#include "CCDB/CcdbApi.h"
-
-namespace o2::tpc
-{
-
-class NeuralNetworkClusterizer
-{
- public:
-  NeuralNetworkClusterizer() = default;
-  void initCcdbApi(std::string url);
-  void loadIndividualFromCCDB(std::map<std::string, std::string> settings);
-
- private:
-  o2::ccdb::CcdbApi ccdbApi;
-  std::map<std::string, std::string> metadata;
-  std::map<std::string, std::string> headers;
-};
-
-} // namespace o2::tpc
-#endif
diff --git a/Detectors/TPC/calibration/src/NeuralNetworkClusterizer.cxx b/Detectors/TPC/calibration/src/NeuralNetworkClusterizer.cxx
deleted file mode 100644
index bfbb7afc946f8..0000000000000
--- a/Detectors/TPC/calibration/src/NeuralNetworkClusterizer.cxx
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file   NeuralNetworkClusterizer.cxx
-/// \brief  Fetching neural networks for clusterization from CCDB
-/// \author Christian Sonnabend
-
-#include <CommonUtils/StringUtils.h>
-#include "TPCCalibration/NeuralNetworkClusterizer.h"
-
-using namespace o2::tpc;
-
-void NeuralNetworkClusterizer::initCcdbApi(std::string url)
-{
-  ccdbApi.init(url);
-}
-
-void NeuralNetworkClusterizer::loadIndividualFromCCDB(std::map<std::string, std::string> settings)
-{
-  metadata["inputDType"] = settings["inputDType"];
-  metadata["outputDType"] = settings["outputDType"];
-  metadata["nnCCDBEvalType"] = settings["nnCCDBEvalType"];         // classification_1C, classification_2C, regression_1C, regression_2C
-  metadata["nnCCDBWithMomentum"] = settings["nnCCDBWithMomentum"]; // 0, 1 -> Only for regression model
-  metadata["nnCCDBLayerType"] = settings["nnCCDBLayerType"];       // FC, CNN
-  if (settings["nnCCDBInteractionRate"] != "" && std::stoi(settings["nnCCDBInteractionRate"]) > 0) {
-    metadata["nnCCDBInteractionRate"] = settings["nnCCDBInteractionRate"];
-  }
-  if (settings["nnCCDBBeamType"] != "") {
-    metadata["nnCCDBBeamType"] = settings["nnCCDBBeamType"];
-  }
-
-  bool retrieveSuccess = ccdbApi.retrieveBlob(settings["nnCCDBPath"], settings["outputFolder"], metadata, 1, false, settings["outputFile"]);
-  // headers = ccdbApi.retrieveHeaders(settings["nnPathCCDB"], metadata, 1); // potentially needed to init some local variables
-
-  if (retrieveSuccess) {
-    LOG(info) << "Network " << settings["nnCCDBPath"] << " retrieved from CCDB, stored at " << settings["outputFile"];
-  } else {
-    LOG(error) << "Failed to retrieve network from CCDB";
-  }
-}
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 2a0b9b9edfa09..6dd718f07a9f1 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -209,6 +209,7 @@ set(SRCS_DATATYPES
     DataTypes/TPCPadBitMap.cxx
     DataTypes/TPCZSLinkMapping.cxx
     DataTypes/CalibdEdxContainer.cxx
+    DataTypes/ORTRootSerializer.cxx
     DataTypes/CalibdEdxTrackTopologyPol.cxx
     DataTypes/CalibdEdxTrackTopologySpline.cxx
     DataTypes/GPUTRDTrackO2.cxx)
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.h b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
index 967d6a73914dd..8bf8084e048fd 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypes.h
@@ -85,6 +85,7 @@ class Cluster;
 namespace tpc
 {
 class CalibdEdxContainer;
+class ORTRootSerializer;
 } // namespace tpc
 } // namespace o2
 
@@ -182,6 +183,9 @@ struct GPUCalibObjectsTemplate { // use only pointers on PODs or flat objects he
   typename S<o2::tpc::CalibdEdxContainer>::type* dEdxCalibContainer = nullptr;
   typename S<o2::base::PropagatorImpl<float>>::type* o2Propagator = nullptr;
   typename S<o2::itsmft::TopologyDictionary>::type* itsPatternDict = nullptr;
+
+  // NN clusterizer objects
+  typename S<o2::tpc::ORTRootSerializer>::type* nnClusterizerNetworks[3] = {nullptr, nullptr, nullptr};
 };
 typedef GPUCalibObjectsTemplate<DefaultPtr> GPUCalibObjects; // NOTE: These 2 must have identical layout since they are memcopied
 typedef GPUCalibObjectsTemplate<ConstPtr> GPUCalibObjectsConst;
diff --git a/GPU/GPUTracking/DataTypes/ORTRootSerializer.cxx b/GPU/GPUTracking/DataTypes/ORTRootSerializer.cxx
new file mode 100644
index 0000000000000..82a8be1fdfec8
--- /dev/null
+++ b/GPU/GPUTracking/DataTypes/ORTRootSerializer.cxx
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   ORTRootSerializer.cxx
+/// \author Christian Sonnabend <christian.sonnabend@cern.ch>
+
+#include "ORTRootSerializer.h"
+#include <cstring>
+
+using namespace o2::tpc;
+
+/// Initialize the serialization from a char* buffer containing the model
+void ORTRootSerializer::setOnnxModel(const char* onnxModel, uint32_t size)
+{
+  mModelBuffer.resize(size);
+  std::memcpy(mModelBuffer.data(), onnxModel, size);
+}
diff --git a/GPU/GPUTracking/DataTypes/ORTRootSerializer.h b/GPU/GPUTracking/DataTypes/ORTRootSerializer.h
new file mode 100644
index 0000000000000..24009d4435a96
--- /dev/null
+++ b/GPU/GPUTracking/DataTypes/ORTRootSerializer.h
@@ -0,0 +1,43 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   ORTRootSerializer.h
+/// \brief  Class to serialize ONNX objects for ROOT snapshots of CCDB objects at runtime
+/// \author Christian Sonnabend <christian.sonnabend@cern.ch>
+
+#ifndef ALICEO2_TPC_ORTROOTSERIALIZER_H_
+#define ALICEO2_TPC_ORTROOTSERIALIZER_H_
+
+#include "GPUCommonRtypes.h"
+#include <vector>
+#include <string>
+
+namespace o2::tpc
+{
+
+class ORTRootSerializer
+{
+ public:
+  ORTRootSerializer() = default;
+  ~ORTRootSerializer() = default;
+
+  void setOnnxModel(const char* onnxModel, uint32_t size);
+  const char* getONNXModel() const { return mModelBuffer.data(); }
+  uint32_t getONNXModelSize() const { return static_cast<uint32_t>(mModelBuffer.size()); }
+
+ private:
+  std::vector<char> mModelBuffer; ///< buffer for serialization
+  ClassDefNV(ORTRootSerializer, 1);
+};
+
+} // namespace o2::tpc
+
+#endif // ALICEO2_TPC_ORTROOTSERIALIZER_H_
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 052da8ae54c60..dc1742453ef39 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -277,22 +277,22 @@ AddOption(nnClusterizerBoundaryFillValue, int, -1, "", 0, "Fill value for the bo
 AddOption(nnClusterizerApplyNoiseSuppression, int, 1, "", 0, "Applies the NoiseSuppression kernel before the digits to the network are filled")
 AddOption(nnClusterizerSetDeconvolutionFlags, int, 1, "", 0, "Runs the deconvolution kernel without overwriting the charge in order to make cluster-to-track attachment identical to heuristic CF")
 AddOption(nnClassificationPath, std::string, "network_class.onnx", "", 0, "The classification network path")
-AddOption(nnClassThreshold, float, 0.5, "", 0, "The cutoff at which clusters will be accepted / rejected.")
 AddOption(nnRegressionPath, std::string, "network_reg.onnx", "", 0, "The regression network path")
+AddOption(nnClassThreshold, float, 0.5, "", 0, "The cutoff at which clusters will be accepted / rejected.")
 AddOption(nnSigmoidTrafoClassThreshold, int, 1, "", 0, "If true (default), then the classification threshold is transformed by an inverse sigmoid function. This depends on how the network was trained (with a sigmoid as acitvation function in the last layer or not).")
 AddOption(nnEvalMode, std::string, "c1:r1", "", 0, "Concatention of modes, e.g. c1:r1 (classification class 1, regression class 1)")
 AddOption(nnClusterizerUseClassification, int, 1, "", 0, "If 1, the classification output of the network is used to select clusters, else only the regression output is used and no clusters are rejected by classification")
 AddOption(nnClusterizerForceGpuInputFill, int, 0, "", 0, "Forces to use the fillInputNNGPU function")
 // CCDB
 AddOption(nnLoadFromCCDB, int, 0, "", 0, "If 1 networks are fetched from ccdb, else locally")
+AddOption(nnCCDBDumpToFile, int, 0, "", 0, "If 1, additionally dump fetched CCDB networks to nnLocalFolder")
 AddOption(nnLocalFolder, std::string, ".", "", 0, "Local folder in which the networks will be fetched")
-AddOption(nnCCDBURL, std::string, "http://ccdb-test.cern.ch:8080", "", 0, "The CCDB URL from where the network files are fetched")
 AddOption(nnCCDBPath, std::string, "Users/c/csonnabe/TPC/Clusterization", "", 0, "Folder path containing the networks")
-AddOption(nnCCDBWithMomentum, int, 1, "", 0, "Distinguishes between the network with and without momentum output for the regression")
+AddOption(nnCCDBWithMomentum, std::string, "", "", 0, "Distinguishes between the network with and without momentum output for the regression")
 AddOption(nnCCDBClassificationLayerType, std::string, "FC", "", 0, "Distinguishes between network with different layer types. Options: FC, CNN")
-AddOption(nnCCDBRegressionLayerType, std::string, "CNN", "", 0, "Distinguishes between network with different layer types. Options: FC, CNN")
-AddOption(nnCCDBBeamType, std::string, "PbPb", "", 0, "Distinguishes between networks trained for different beam types. Options: PbPb, pp")
-AddOption(nnCCDBInteractionRate, int, 50, "", 0, "Distinguishes between networks for different interaction rates [kHz].")
+AddOption(nnCCDBRegressionLayerType, std::string, "FC", "", 0, "Distinguishes between network with different layer types. Options: FC, CNN")
+AddOption(nnCCDBBeamType, std::string, "pp", "", 0, "Distinguishes between networks trained for different beam types. Options: pp, pPb, PbPb")
+AddOption(nnCCDBInteractionRate, std::string, "500", "", 0, "Distinguishes between networks for different interaction rates [kHz].")
 AddHelp("help", 'h')
 EndConfig()
 
diff --git a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
index 46fd50464c69b..7bd2c689c5354 100644
--- a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
+++ b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
@@ -43,5 +43,6 @@
 #pragma link C++ class o2::tpc::CalibdEdxTrackTopologyPol + ;
 #pragma link C++ class o2::tpc::CalibdEdxTrackTopologySpline + ;
 #pragma link C++ struct o2::tpc::CalibdEdxTrackTopologyPolContainer + ;
+#pragma link C++ struct o2::tpc::ORTRootSerializer + ;
 
 #endif
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index bfb0457744ce5..5426f0eafdad6 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -47,6 +47,7 @@
 #ifdef GPUCA_HAS_ONNX
 #include "GPUTPCNNClusterizerKernels.h"
 #include "GPUTPCNNClusterizerHost.h"
+#include "ORTRootSerializer.h"
 #endif
 
 #ifdef GPUCA_O2_LIB
@@ -639,7 +640,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   // Maximum of 4 lanes supported
   HighResTimer* nnTimers[12];
 
-  if (GetProcessingSettings().nn.applyNNclusterizer) {
+  if (nn_settings.applyNNclusterizer) {
     int32_t deviceId = -1;
     int32_t numLanes = GetProcessingSettings().nTPCClustererLanes;
     int32_t maxThreads = mRec->getNKernelHostThreads(true);
@@ -677,7 +678,11 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         //   nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
         // }
         // recreateMemoryAllocator = true;
-        (nnApplications[lane].mModelClass).initSession();
+        if (!nn_settings.nnLoadFromCCDB) {
+          (nnApplications[lane].mModelClass).initSession(); // loads from file
+        } else {
+          (nnApplications[lane].mModelClass).initSessionFromBuffer((processors()->calibObjects.nnClusterizerNetworks[0])->getONNXModel(), (processors()->calibObjects.nnClusterizerNetworks[0])->getONNXModelSize()); // loads from CCDB
+        }
       }
       if (nnApplications[lane].mModelsUsed[1]) {
         SetONNXGPUStream(*(nnApplications[lane].mModelReg1).getSessionOptions(), lane, &deviceId);
@@ -688,7 +693,11 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         // (nnApplications[lane].mModelReg1).setEnv((nnApplications[lane].mModelClass).getEnv());
         (nnApplications[lane].mModelReg1).initEnvironment();
         // nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelReg1).getEnv(), (nnApplications[lane].mModelReg1).getMemoryInfo(), mRec, recreateMemoryAllocator);
-        (nnApplications[lane].mModelReg1).initSession();
+        if (!nn_settings.nnLoadFromCCDB) {
+          (nnApplications[lane].mModelReg1).initSession(); // loads from file
+        } else {
+          (nnApplications[lane].mModelReg1).initSessionFromBuffer((processors()->calibObjects.nnClusterizerNetworks[1])->getONNXModel(), (processors()->calibObjects.nnClusterizerNetworks[1])->getONNXModelSize()); // loads from CCDB
+        }
       }
       if (nnApplications[lane].mModelsUsed[2]) {
         SetONNXGPUStream(*(nnApplications[lane].mModelReg2).getSessionOptions(), lane, &deviceId);
@@ -699,7 +708,11 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         // (nnApplications[lane].mModelReg2).setEnv((nnApplications[lane].mModelClass).getEnv());
         (nnApplications[lane].mModelReg2).initEnvironment();
         // nnApplications[lane].directOrtAllocator((nnApplications[lane].mModelClass).getEnv(), (nnApplications[lane].mModelClass).getMemoryInfo(), mRec, recreateMemoryAllocator);
-        (nnApplications[lane].mModelReg2).initSession();
+        if (!nn_settings.nnLoadFromCCDB) {
+          (nnApplications[lane].mModelReg2).initSession(); // loads from file
+        } else {
+          (nnApplications[lane].mModelReg2).initSessionFromBuffer((processors()->calibObjects.nnClusterizerNetworks[2])->getONNXModel(), (processors()->calibObjects.nnClusterizerNetworks[2])->getONNXModelSize()); // loads from CCDB
+        }
       }
       if (nn_settings.nnClusterizerVerbosity > 0) {
         LOG(info) << "(ORT) Allocated ONNX stream for lane " << lane << " and device " << deviceId;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
index 582a0c6d7435a..77d5ee13f85fb 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerHost.cxx
@@ -36,7 +36,7 @@ void GPUTPCNNClusterizerHost::init(const GPUSettingsProcessingNNclusterizer& set
   std::vector<std::string> evalMode = o2::utils::Str::tokenize(settings.nnEvalMode, ':');
 
   if (settings.nnLoadFromCCDB) {
-    reg_model_path = settings.nnLocalFolder + "/net_regression_c1.onnx"; // Needs to be set identical to NeuralNetworkClusterizer.cxx, otherwise the networks might be loaded from the wrong place
+    reg_model_path = settings.nnLocalFolder + "/net_regression_c1.onnx"; // Needs to be set identical to GPUWorkflowSpec.cxx, otherwise the networks might be loaded from the wrong place
     if (evalMode[0] == "c1") {
       class_model_path = settings.nnLocalFolder + "/net_classification_c1.onnx";
     } else if (evalMode[0] == "c2") {
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 160efd4048af0..d610269abca81 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -135,6 +135,11 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     bool tpcTriggerHandling = false;
     bool isITS3 = false;
     bool useFilteredOutputSpecs = false;
+
+    // NN clusterizer
+    bool nnLoadFromCCDB = false;
+    bool nnDumpToFile = false;
+    std::vector<std::string> nnEvalMode;
   };
 
   GPURecoWorkflowSpec(CompletionPolicyData* policyData, Config const& specconfig, std::vector<int32_t> const& tpcsectors, uint64_t tpcSectorMask, std::shared_ptr<o2::base::GRPGeomRequest>& ggr, std::function<bool(o2::framework::DataProcessingHeader::StartTime)>** gPolicyOrder = nullptr);
@@ -230,7 +235,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   uint32_t mNextThreadIndex = 0;
   bool mUpdateGainMapCCDB = true;
   std::unique_ptr<o2::gpu::GPUSettingsTF> mTFSettings;
-  std::unique_ptr<o2::gpu::GPUSettingsProcessingNNclusterizer> mNNClusterizerSettings;
+  std::map<std::string, std::string> nnCCDBSettings;
 
   Config mSpecConfig;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGR;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index d3d3eb14869e0..d7ea772c31653 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -54,6 +54,7 @@
 #include "GPUO2Interface.h"
 #include "GPUO2InterfaceUtils.h"
 #include "CalibdEdxContainer.h"
+#include "ORTRootSerializer.h"
 #include "GPUNewCalibValues.h"
 #include "TPCPadGainCalib.h"
 #include "TPCZSLinkMapping.h"
@@ -78,7 +79,6 @@
 #include "DetectorsRaw/RDHUtils.h"
 #include "ITStracking/TrackingInterface.h"
 #include "GPUWorkflowInternal.h"
-#include "TPCCalibration/NeuralNetworkClusterizer.h"
 // #include "Framework/ThreadPool.h"
 
 #include <TStopwatch.h>
@@ -133,50 +133,6 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
 {
   GRPGeomHelper::instance().setRequest(mGGR);
   GPUO2InterfaceConfiguration& config = *mConfig.get();
-  GPUSettingsProcessingNNclusterizer& mNNClusterizerSettings = mConfig->configProcessing.nn;
-
-  if (mNNClusterizerSettings.nnLoadFromCCDB) {
-    LOG(info) << "Loading neural networks from CCDB";
-    o2::tpc::NeuralNetworkClusterizer nnClusterizerFetcher;
-    nnClusterizerFetcher.initCcdbApi(mNNClusterizerSettings.nnCCDBURL);
-    std::map<std::string, std::string> ccdbSettings = {
-      {"nnCCDBURL", mNNClusterizerSettings.nnCCDBURL},
-      {"nnCCDBPath", mNNClusterizerSettings.nnCCDBPath},
-      {"inputDType", mNNClusterizerSettings.nnInferenceInputDType},
-      {"outputDType", mNNClusterizerSettings.nnInferenceOutputDType},
-      {"outputFolder", mNNClusterizerSettings.nnLocalFolder},
-      {"nnCCDBPath", mNNClusterizerSettings.nnCCDBPath},
-      {"nnCCDBWithMomentum", std::to_string(mNNClusterizerSettings.nnCCDBWithMomentum)},
-      {"nnCCDBBeamType", mNNClusterizerSettings.nnCCDBBeamType},
-      {"nnCCDBInteractionRate", std::to_string(mNNClusterizerSettings.nnCCDBInteractionRate)}};
-
-    std::string nnFetchFolder = mNNClusterizerSettings.nnLocalFolder;
-    std::vector<std::string> evalMode = o2::utils::Str::tokenize(mNNClusterizerSettings.nnEvalMode, ':');
-
-    if (evalMode[0] == "c1") {
-      ccdbSettings["nnCCDBLayerType"] = mNNClusterizerSettings.nnCCDBClassificationLayerType;
-      ccdbSettings["nnCCDBEvalType"] = "classification_c1";
-      ccdbSettings["outputFile"] = "net_classification_c1.onnx";
-      nnClusterizerFetcher.loadIndividualFromCCDB(ccdbSettings);
-    } else if (evalMode[0] == "c2") {
-      ccdbSettings["nnCCDBLayerType"] = mNNClusterizerSettings.nnCCDBClassificationLayerType;
-      ccdbSettings["nnCCDBEvalType"] = "classification_c2";
-      ccdbSettings["outputFile"] = "net_classification_c2.onnx";
-      nnClusterizerFetcher.loadIndividualFromCCDB(ccdbSettings);
-    }
-
-    ccdbSettings["nnCCDBLayerType"] = mNNClusterizerSettings.nnCCDBRegressionLayerType;
-    ccdbSettings["nnCCDBEvalType"] = "regression_c1";
-    ccdbSettings["outputFile"] = "net_regression_c1.onnx";
-    nnClusterizerFetcher.loadIndividualFromCCDB(ccdbSettings);
-    if (evalMode[1] == "r2") {
-      ccdbSettings["nnCCDBLayerType"] = mNNClusterizerSettings.nnCCDBRegressionLayerType;
-      ccdbSettings["nnCCDBEvalType"] = "regression_c2";
-      ccdbSettings["outputFile"] = "net_regression_c2.onnx";
-      nnClusterizerFetcher.loadIndividualFromCCDB(ccdbSettings);
-    }
-    LOG(info) << "Neural network loading done!";
-  }
 
   // Create configuration object and fill settings
   mConfig->configGRP.solenoidBzNominalGPU = 0;
@@ -185,6 +141,7 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
   mTFSettings->simStartOrbit = hbfu.getFirstIRofTF(o2::InteractionRecord(0, hbfu.orbitFirstSampled)).orbit;
 
   *mConfParam = mConfig->ReadConfigurableParam();
+
   if (mConfParam->display) {
     mDisplayFrontend.reset(GPUDisplayFrontendInterface::getFrontend(mConfig->configDisplay.displayFrontend.c_str()));
     mConfig->configProcessing.eventDisplay = mDisplayFrontend.get();
@@ -1124,6 +1081,27 @@ void GPURecoWorkflowSpec::doCalibUpdates(o2::framework::ProcessingContext& pc, c
     newCalibValues.tpcTimeBinCut = mConfig->configGRP.tpcCutTimeBin = mTPCCutAtTimeBin;
     needCalibUpdate = true;
   }
+  if (mSpecConfig.nnLoadFromCCDB) {
+    auto dumpToFile = [](const char* buffer, std::size_t validSize, const std::string& path) {
+      std::ofstream out(path, std::ios::binary | std::ios::trunc);
+      if (!out.is_open()) {
+        throw std::runtime_error("Failed to open output file: " + path);
+      }
+
+      out.write(buffer, static_cast<std::streamsize>(validSize));
+      if (!out) {
+        throw std::runtime_error("Failed while writing data to: " + path);
+      }
+    };
+    for (int i = 0; i < 3; i++) {
+      newCalibObjects.nnClusterizerNetworks[i] = mConfig->configCalib.nnClusterizerNetworks[i];
+      if (mSpecConfig.nnDumpToFile && newCalibObjects.nnClusterizerNetworks[i]) {
+        std::string path = "tpc_nn_clusterizer_" + std::to_string(i) + ".onnx";
+        dumpToFile(newCalibObjects.nnClusterizerNetworks[i]->getONNXModel(), newCalibObjects.nnClusterizerNetworks[i]->getONNXModelSize(), path);
+        LOG(info) << "Dumped TPC clusterizer NN " << i << " to file " << path;
+      }
+    }
+  }
   if (needCalibUpdate) {
     LOG(info) << "Updating GPUReconstruction calibration objects";
     mGPUReco->UpdateCalibration(newCalibObjects, newCalibValues);
@@ -1262,6 +1240,67 @@ Inputs GPURecoWorkflowSpec::inputs()
     }
   }
 
+  // NN clusterizer
+  *mConfParam = mConfig->ReadConfigurableParam();
+  if (mConfig->configProcessing.nn.nnLoadFromCCDB) {
+
+    LOG(info) << "(NN CLUS) Enabling fetching of TPC NN clusterizer from CCDB";
+    mSpecConfig.nnLoadFromCCDB = true;
+    mSpecConfig.nnDumpToFile = mConfig->configProcessing.nn.nnCCDBDumpToFile;
+    GPUSettingsProcessingNNclusterizer& nnClusterizerSettings = mConfig->configProcessing.nn;
+
+    std::map<std::string, std::string> metadata;
+    metadata["inputDType"] = nnClusterizerSettings.nnInferenceInputDType;              // FP16 or FP32
+    metadata["outputDType"] = nnClusterizerSettings.nnInferenceOutputDType;            // FP16 or FP32
+    metadata["nnCCDBWithMomentum"] = nnClusterizerSettings.nnCCDBWithMomentum;         // 0, 1 -> Only for regression model
+    metadata["nnCCDBLayerType"] = nnClusterizerSettings.nnCCDBClassificationLayerType; // FC, CNN
+    metadata["nnCCDBInteractionRate"] = nnClusterizerSettings.nnCCDBInteractionRate;   // in kHz
+    metadata["nnCCDBBeamType"] = nnClusterizerSettings.nnCCDBBeamType;                 // pp, pPb, PbPb
+
+    auto convert_map_to_metadata = [](const std::map<std::string, std::string>& inputMap, std::vector<o2::framework::CCDBMetadata>& outputMetadata) {
+      for (const auto& [key, value] : inputMap) {
+        if (value != "") {
+          outputMetadata.push_back({key, value});
+        }
+      }
+    };
+
+    mSpecConfig.nnEvalMode = o2::utils::Str::tokenize(nnClusterizerSettings.nnEvalMode, ':');
+    std::vector<o2::framework::CCDBMetadata> ccdb_metadata;
+
+    if (mConfParam->printSettings) {
+      auto printSettings = [](const std::map<std::string, std::string>& settings) {
+        LOG(info) << "(NN CLUS) NN Clusterizer CCDB settings:";
+        for (const auto& [key, value] : settings) {
+          LOG(info) << "  " << key << " : " << value;
+        }
+      };
+      printSettings(metadata);
+    }
+
+    if (mSpecConfig.nnEvalMode[0] == "c1") {
+      metadata["nnCCDBEvalType"] = "classification_c1";
+      convert_map_to_metadata(metadata, ccdb_metadata);
+      inputs.emplace_back("nn_classification_c1", gDataOriginTPC, "NNCLUSTERIZER_C1", 0, Lifetime::Condition, ccdbParamSpec(nnClusterizerSettings.nnCCDBPath + "/" + metadata["nnCCDBEvalType"], ccdb_metadata, 0));
+    } else if (mSpecConfig.nnEvalMode[0] == "c2") {
+      metadata["nnCCDBLayerType"] = nnClusterizerSettings.nnCCDBRegressionLayerType;
+      metadata["nnCCDBEvalType"] = "classification_c2";
+      convert_map_to_metadata(metadata, ccdb_metadata);
+      inputs.emplace_back("nn_classification_c2", gDataOriginTPC, "NNCLUSTERIZER_C2", 0, Lifetime::Condition, ccdbParamSpec(nnClusterizerSettings.nnCCDBPath + "/" + metadata["nnCCDBEvalType"], ccdb_metadata, 0));
+    }
+
+    metadata["nnCCDBEvalType"] = "regression_c1";
+    metadata["nnCCDBLayerType"] = nnClusterizerSettings.nnCCDBRegressionLayerType;
+    convert_map_to_metadata(metadata, ccdb_metadata);
+    inputs.emplace_back("nn_regression_c1", gDataOriginTPC, "NNCLUSTERIZER_R1", 0, Lifetime::Condition, ccdbParamSpec(nnClusterizerSettings.nnCCDBPath + "/" + metadata["nnCCDBEvalType"], ccdb_metadata, 0));
+
+    if (mSpecConfig.nnEvalMode[1] == "r2") {
+      metadata["nnCCDBEvalType"] = "regression_c2";
+      convert_map_to_metadata(metadata, ccdb_metadata);
+      inputs.emplace_back("nn_regression_c2", gDataOriginTPC, "NNCLUSTERIZER_R2", 0, Lifetime::Condition, ccdbParamSpec(nnClusterizerSettings.nnCCDBPath + "/" + metadata["nnCCDBEvalType"], ccdb_metadata, 0));
+    }
+  }
+
   return inputs;
 };
 
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index 6606386819b64..13a3c4b6162b8 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -49,6 +49,7 @@
 #include "GPUO2Interface.h"
 #include "GPUO2InterfaceUtils.h"
 #include "CalibdEdxContainer.h"
+#include "ORTRootSerializer.h"
 #include "GPUNewCalibValues.h"
 #include "TPCPadGainCalib.h"
 #include "TPCZSLinkMapping.h"
@@ -293,6 +294,18 @@ void GPURecoWorkflowSpec::finaliseCCDBTPC(ConcreteDataMatcher& matcher, void* ob
          mTPCDeadChannelMapCreator->getDeadChannelMapFEE().getSum<int32_t>(), mTPCDeadChannelMapCreator->getDeadChannelMap().getSum<int32_t>());
   } else if (mTPCVDriftHelper->accountCCDBInputs(matcher, obj)) {
   } else if (mCalibObjects.mFastTransformHelper->accountCCDBInputs(matcher, obj)) {
+  } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "NNCLUSTERIZER_C1", 0)) {
+    mConfig->configCalib.nnClusterizerNetworks[0] = static_cast<o2::tpc::ORTRootSerializer*>(obj);
+    LOG(info) << "(NN CLUS) " << (mConfig->configCalib.nnClusterizerNetworks[0])->getONNXModelSize() << " bytes loaded for NN clusterizer: classification_c1";
+  } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "NNCLUSTERIZER_C2", 0)) {
+    mConfig->configCalib.nnClusterizerNetworks[0] = static_cast<o2::tpc::ORTRootSerializer*>(obj);
+    LOG(info) << "(NN CLUS) " << (mConfig->configCalib.nnClusterizerNetworks[0])->getONNXModelSize() << " bytes loaded for NN clusterizer: classification_c2";
+  } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "NNCLUSTERIZER_R1", 0)) {
+    mConfig->configCalib.nnClusterizerNetworks[1] = static_cast<o2::tpc::ORTRootSerializer*>(obj);
+    LOG(info) << "(NN CLUS) " << (mConfig->configCalib.nnClusterizerNetworks[1])->getONNXModelSize() << " bytes loaded for NN clusterizer: regression_c1";
+  } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "NNCLUSTERIZER_R2", 0)) {
+    mConfig->configCalib.nnClusterizerNetworks[2] = static_cast<o2::tpc::ORTRootSerializer*>(obj);
+    LOG(info) << "(NN CLUS) " << (mConfig->configCalib.nnClusterizerNetworks[2])->getONNXModelSize() << " bytes loaded for NN clusterizer: regression_c2";
   }
 }
 
@@ -405,6 +418,21 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
       newCalibObjects.tpcPadGain = mCalibObjects.mTPCPadGainCalib.get();
       mustUpdate = true;
     }
+
+    // NN clusterizer networks
+    if (mSpecConfig.nnLoadFromCCDB) {
+
+      if (mSpecConfig.nnEvalMode[0] == "c1") {
+        pc.inputs().get<o2::tpc::ORTRootSerializer*>("nn_classification_c1");
+      } else if (mSpecConfig.nnEvalMode[0] == "c2") {
+        pc.inputs().get<o2::tpc::ORTRootSerializer*>("nn_classification_c2");
+      }
+
+      pc.inputs().get<o2::tpc::ORTRootSerializer*>("nn_regression_c1");
+      if (mSpecConfig.nnEvalMode[1] == "r2") {
+        pc.inputs().get<o2::tpc::ORTRootSerializer*>("nn_regression_c2");
+      }
+    }
   }
   return mustUpdate;
 }
diff --git a/macro/CMakeLists.txt b/macro/CMakeLists.txt
index 843ad4a3be0ab..b5c51e50d3ffb 100644
--- a/macro/CMakeLists.txt
+++ b/macro/CMakeLists.txt
@@ -58,6 +58,7 @@ install(FILES CheckDigits_mft.C
               CreateGRPLHCIFObject.C
               getTimeStamp.C
               CreateSampleIRFrames.C
+              convert_onnx_to_root_serialized.C
         DESTINATION share/macro/)
 
 # FIXME: a lot of macros that are here should really be elsewhere. Those which
@@ -149,6 +150,9 @@ o2_add_test_root_macro(checkTOFMatching.C
                                              O2::SimulationDataFormat
                                              O2::DataFormatsTOF)
 
+o2_add_test_root_macro(convert_onnx_to_root_serialized.C
+                       PUBLIC_LINK_LIBRARIES O2::GlobalTracking)
+
 # FIXME: move to subsystem dir
 o2_add_test_root_macro(compareTopologyDistributions.C
                        PUBLIC_LINK_LIBRARIES O2::DataFormatsITSMFT
diff --git a/macro/convert_onnx_to_root_serialized.C b/macro/convert_onnx_to_root_serialized.C
new file mode 100644
index 0000000000000..b1b8b981393a1
--- /dev/null
+++ b/macro/convert_onnx_to_root_serialized.C
@@ -0,0 +1,220 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file   convert_onnx_to_root_serialized.C
+/// \brief  Utility functions to be executed as a ROOT macro for uploading ONNX models to CCDB as ROOT serialized objects and vice versa
+/// \author Christian Sonnabend <christian.sonnabend@cern.ch>
+
+// Example execution: root -l -b -q '/scratch/csonnabe/MyO2/O2/GPU/GPUTracking/utils/convert_onnx_to_root_serialized.C("/scratch/csonnabe/PhD/jobs/clusterization/NN/output/21082025_smallWindow_clean/SC/training_data_21082025_reco_noise_supressed_p3t6_CoGselected/SC/PbPb_24arp2/0_5/class1/regression/399_noMom/network/net_fp16.onnx", "", 1, 1, "nnCCDBLayerType=FC/nnCCDBWithMomentum=0/inputDType=FP16/nnCCDBInteractionRate=500/outputDType=FP16/nnCCDBEvalType=regression_c1/nnCCDBBeamType=pp/partName=blob/quality=3", 1, 4108971600000, "Users/c/csonnabe/TPC/Clusterization", "model.root")'
+
+#include "ORTRootSerializer.h"
+#include "CCDB/CcdbApi.h"
+#include "CCDB/CcdbObjectInfo.h"
+#include "TFile.h"
+#include <fstream>
+#include <stdexcept>
+
+o2::tpc::ORTRootSerializer serializer;
+
+/// Dumps the char* to a .onnx file -> Directly readable by ONNX runtime or Netron
+void dumpOnnxToFile(const char* modelBuffer, uint32_t size, const std::string outputPath)
+{
+  std::ofstream outFile(outputPath, std::ios::binary | std::ios::trunc);
+  if (!outFile.is_open()) {
+    throw std::runtime_error("Failed to open output ONNX file: " + outputPath);
+  }
+  outFile.write(modelBuffer, static_cast<std::streamsize>(size));
+  if (!outFile) {
+    throw std::runtime_error("Failed while writing data to: " + outputPath);
+  }
+  outFile.close();
+}
+
+/// Initialize the serialization from an ONNX file
+void readOnnxModelFromFile(const std::string modelPath)
+{
+  std::ifstream inFile(modelPath, std::ios::binary | std::ios::ate);
+  if (!inFile.is_open()) {
+    throw std::runtime_error("Could not open input ONNX file " + modelPath);
+  }
+  std::streamsize size = inFile.tellg();
+  std::vector<char> mModelBuffer(size);
+  inFile.seekg(0, std::ios::beg);
+  if (!inFile.read(mModelBuffer.data(), size)) {
+    throw std::runtime_error("Could not read input ONNX file " + modelPath);
+  }
+  inFile.close();
+  serializer.setOnnxModel(mModelBuffer.data(), static_cast<uint32_t>(size));
+}
+
+/// Initialize the serialization from a ROOT file
+void readRootModelFromFile(const std::string rootFilePath, std::string key)
+{
+  TFile inRootFile(rootFilePath.c_str());
+  if (inRootFile.IsZombie()) {
+    throw std::runtime_error("Could not open input ROOT file " + rootFilePath);
+  }
+  auto* serPtr = inRootFile.Get<o2::tpc::ORTRootSerializer>(key.c_str());
+  if (!serPtr) {
+    throw std::runtime_error("Could not find " + key + " in ROOT file " + rootFilePath);
+  }
+  serializer = *serPtr;
+  inRootFile.Close();
+}
+
+/// Serialize the ONNX model to a ROOT object and store to file
+void onnxToRoot(std::string infile, std::string outfile, std::string key)
+{
+  readOnnxModelFromFile(infile);
+  TFile outRootFile(outfile.c_str(), "RECREATE");
+  if (outRootFile.IsZombie()) {
+    throw std::runtime_error("Could not create output ROOT file " + outfile);
+  }
+  outRootFile.WriteObject(&serializer, key.c_str());
+  outRootFile.Close();
+}
+
+/// Deserialize the ONNX model from a ROOT object and store to a .onnx file
+void rootToOnnx(std::string infile, std::string outfile, std::string key)
+{
+  TFile inRootFile(infile.c_str());
+  if (inRootFile.IsZombie()) {
+    throw std::runtime_error("Could not open input ROOT file " + infile);
+  }
+  auto* serPtr = inRootFile.Get<o2::tpc::ORTRootSerializer>(key.c_str());
+  if (!serPtr) {
+    throw std::runtime_error("Could not find " + key + " in ROOT file " + infile);
+  }
+  serializer = *serPtr;
+
+  std::ofstream outFile(outfile, std::ios::binary | std::ios::trunc);
+  if (!outFile.is_open()) {
+    throw std::runtime_error("Failed to open output ONNX file: " + outfile);
+  }
+  outFile.write(serializer.getONNXModel(), static_cast<std::streamsize>(serializer.getONNXModelSize()));
+  if (!outFile) {
+    throw std::runtime_error("Failed while writing data to: " + outfile);
+  }
+  outFile.close();
+
+  inRootFile.Close();
+}
+
+/// Upload the ONNX model to CCDB from an ONNX file
+/// !!! Adjust the metadata, path and validity !!!
+void uploadToCCDBFromONNX(std::string onnxFile,
+                          const std::map<std::string, std::string>& metadata,
+                          // { // some example metadata entries
+                          //   "nnCCDBLayerType": "FC",
+                          //   "nnCCDBWithMomentum": "0",
+                          //   "inputDType": "FP16",
+                          //   "nnCCDBInteractionRate": "500",
+                          //   "outputDType": "FP16",
+                          //   "nnCCDBEvalType": "regression_c1",
+                          //   "nnCCDBBeamType": "pp",
+                          //   "partName": "blob",
+                          //   "quality": "3"
+                          // }
+                          long tsMin /* = 1 */,
+                          long tsMax /* = 4108971600000 */,
+                          std::string ccdbPath /* = "Users/c/csonnabe/TPC/Clusterization" */,
+                          std::string objname /* = "net_regression_r1.root" */,
+                          std::string ccdbUrl /* = "http://alice-ccdb.cern.ch" */)
+{
+  readOnnxModelFromFile(onnxFile);
+
+  o2::ccdb::CcdbApi api;
+  api.init(ccdbUrl);
+
+  // build full CCDB path including filename
+  const std::string fullPath = ccdbPath; //.back() == '/' ? (ccdbPath + objname) : (ccdbPath + "/" + objname);
+
+  api.storeAsTFileAny(&serializer, fullPath, metadata, tsMin, tsMax);
+}
+
+/// Upload the ONNX model to CCDB from a ROOT file
+/// !!! Adjust the metadata, path and validity !!!
+void uploadToCCDBFromROOT(std::string rootFile,
+                          const std::map<std::string, std::string>& metadata,
+                          long tsMin /* = 1 */,
+                          long tsMax /* = 4108971600000 */,
+                          std::string ccdbPath /* = "Users/c/csonnabe/TPC/Clusterization" */,
+                          std::string objname /* = "net_regression_r1.root" */,
+                          std::string ccdbUrl /* = "http://alice-ccdb.cern.ch" */)
+{
+  // read ROOT file, extract ORTRootSerializer object and upload via storeAsTFileAny
+  TFile inRootFile(rootFile.c_str());
+  if (inRootFile.IsZombie()) {
+    throw std::runtime_error("Could not open input ROOT file " + rootFile);
+  }
+
+  // if objname is empty, fall back to default CCDB object key
+  const std::string key = objname.empty() ? o2::ccdb::CcdbApi::CCDBOBJECT_ENTRY : objname;
+
+  auto* serPtr = inRootFile.Get<o2::tpc::ORTRootSerializer>(key.c_str());
+  if (!serPtr) {
+    inRootFile.Close();
+    throw std::runtime_error("Could not find " + key + " in ROOT file " + rootFile);
+  }
+  serializer = *serPtr;
+
+  o2::ccdb::CcdbApi api;
+  api.init(ccdbUrl);
+
+  // build full CCDB path including filename
+  const std::string fullPath = ccdbPath; //.back() == '/' ? (ccdbPath + objname) : (ccdbPath + "/" + objname);
+
+  api.storeAsTFileAny(&serializer, fullPath, metadata, tsMin, tsMax);
+
+  inRootFile.Close();
+}
+
+void convert_onnx_to_root_serialized(const std::string& onnxFile,
+                                     const std::string& rootFile,
+                                     int mode = 0,
+                                     int ccdbUpload = 0,
+                                     const std::string& metadataStr = "nnCCDBLayerType=FC/nnCCDBWithMomentum=0/inputDType=FP16/nnCCDBInteractionRate=500/outputDType=FP16/nnCCDBEvalType=regression_c1/nnCCDBBeamType=pp/partName=blob/quality=3",
+                                     long tsMin = 1,
+                                     long tsMax = 4108971600000,
+                                     std::string ccdbPath = "Users/c/csonnabe/TPC/Clusterization",
+                                     std::string objname = "net_regression_r1.root",
+                                     std::string ccdbUrl = "http://alice-ccdb.cern.ch")
+{
+  // parse metadataStr of the form key=value/key2=value2/...
+  std::map<std::string, std::string> metadata;
+  std::size_t start = 0;
+  while (start < metadataStr.size()) {
+    auto sep = metadataStr.find('/', start);
+    auto token = metadataStr.substr(start, sep == std::string::npos ? std::string::npos : sep - start);
+    if (!token.empty()) {
+      auto eq = token.find('=');
+      if (eq != std::string::npos && eq > 0 && eq + 1 < token.size()) {
+        metadata.emplace(token.substr(0, eq), token.substr(eq + 1));
+      }
+    }
+    if (sep == std::string::npos) {
+      break;
+    }
+    start = sep + 1;
+  }
+
+  if (ccdbUpload == 0) {
+    if (mode == 0)
+      onnxToRoot(onnxFile, rootFile, o2::ccdb::CcdbApi::CCDBOBJECT_ENTRY);
+    else if (mode == 1)
+      rootToOnnx(rootFile, onnxFile, o2::ccdb::CcdbApi::CCDBOBJECT_ENTRY);
+  } else if (ccdbUpload == 1) {
+    if (mode == 0)
+      uploadToCCDBFromROOT(rootFile, metadata, tsMin, tsMax, ccdbPath, objname, ccdbUrl);
+    else if (mode == 1)
+      uploadToCCDBFromONNX(onnxFile, metadata, tsMin, tsMax, ccdbPath, objname, ccdbUrl);
+  }
+}

From abe259d43847d4d949db0314cece39c2be6e7932 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 27 Nov 2025 16:46:24 +0100
Subject: [PATCH 1073/1764] DPL: cleanup Variant copying for ArrayString

Previous implementation was actually working by accident.
---
 Framework/Core/include/Framework/Variant.h    | 25 +++++-
 .../Framework/VariantPropertyTreeHelpers.h    | 14 ++--
 Framework/Core/src/Variant.cxx                | 83 +++++++++----------
 .../Core/src/VariantPropertyTreeHelpers.cxx   | 12 +--
 4 files changed, 75 insertions(+), 59 deletions(-)

diff --git a/Framework/Core/include/Framework/Variant.h b/Framework/Core/include/Framework/Variant.h
index e69ca05b91d98..7121c5fad0669 100644
--- a/Framework/Core/include/Framework/Variant.h
+++ b/Framework/Core/include/Framework/Variant.h
@@ -274,13 +274,24 @@ struct variant_helper<std::vector<std::string>> {
   // Allocates a new store and copies into it.
   static void set(void* store, std::vector<std::string> value)
   {
-    new (reinterpret_cast<std::vector<std::string>*>(store)) std::vector<std::string>{};
-    *(reinterpret_cast<std::vector<std::string>*>(store)) = value;
+    auto ptr = reinterpret_cast<std::vector<std::string>*>(store);
+    new (ptr) std::vector<std::string>{value};
   }
 
   static std::vector<std::string> const& get(const void* store) { return *(reinterpret_cast<std::vector<std::string> const*>(store)); }
 };
 
+template <>
+struct variant_helper<std::string*> {
+  static void set(void* store, std::string* values, size_t size)
+  {
+    auto ptr = reinterpret_cast<std::vector<std::string>*>(store);
+    new (ptr) std::vector<std::string>{values, values + size};
+  }
+
+  static std::string const* get(const void* store) { return (*(reinterpret_cast<std::vector<std::string> const*>(store))).data(); }
+};
+
 template <>
 struct variant_helper<const char*> {
   static const char* get(const void* store) { return *reinterpret_cast<const char* const*>(store); }
@@ -360,6 +371,16 @@ class Variant
     return variant_helper<T>::get(&mStore);
   }
 
+  template <typename T>
+  [[nodiscard]] std::string const* get() const
+    requires(std::same_as<std::string*, T>)
+  {
+    if (mType != VariantType::ArrayString) {
+      throw runtime_error_f("Variant::get: Mismatch between types %d %d.", mType, VariantType::ArrayString);
+    }
+    return variant_helper<T>::get(&mStore);
+  }
+
   template <typename T>
   void set(T value)
   {
diff --git a/Framework/Core/include/Framework/VariantPropertyTreeHelpers.h b/Framework/Core/include/Framework/VariantPropertyTreeHelpers.h
index a51e3e03ffc5e..05ab71d39b0e4 100644
--- a/Framework/Core/include/Framework/VariantPropertyTreeHelpers.h
+++ b/Framework/Core/include/Framework/VariantPropertyTreeHelpers.h
@@ -36,7 +36,7 @@ boost::property_tree::ptree basicVectorToBranch(std::vector<T>&& values)
 }
 
 template <typename T>
-boost::property_tree::ptree vectorToBranch(T* values, size_t size)
+boost::property_tree::ptree vectorToBranch(T const* values, size_t size)
 {
   boost::property_tree::ptree branch;
   branch.put_child("values", basicVectorToBranch(values, size));
@@ -150,17 +150,17 @@ extern template boost::property_tree::ptree o2::framework::basicVectorToBranch(f
 extern template boost::property_tree::ptree o2::framework::basicVectorToBranch(int*, size_t);
 extern template boost::property_tree::ptree o2::framework::basicVectorToBranch(double*, size_t);
 extern template boost::property_tree::ptree o2::framework::basicVectorToBranch(bool*, size_t);
-extern template boost::property_tree::ptree o2::framework::basicVectorToBranch(std::basic_string<char>*, size_t);
+extern template boost::property_tree::ptree o2::framework::basicVectorToBranch(std::basic_string<char> const*, size_t);
 
 extern template boost::property_tree::ptree o2::framework::vectorToBranch(std::vector<float>&& values);
 extern template boost::property_tree::ptree o2::framework::vectorToBranch(std::vector<int>&& values);
 extern template boost::property_tree::ptree o2::framework::vectorToBranch(std::vector<double>&& values);
 extern template boost::property_tree::ptree o2::framework::vectorToBranch(std::vector<std::string>&& values);
-extern template boost::property_tree::ptree o2::framework::vectorToBranch(float*, size_t);
-extern template boost::property_tree::ptree o2::framework::vectorToBranch(int*, size_t);
-extern template boost::property_tree::ptree o2::framework::vectorToBranch(double*, size_t);
-extern template boost::property_tree::ptree o2::framework::vectorToBranch(bool*, size_t);
-extern template boost::property_tree::ptree o2::framework::vectorToBranch(std::basic_string<char>*, size_t);
+extern template boost::property_tree::ptree o2::framework::vectorToBranch(float const*, size_t);
+extern template boost::property_tree::ptree o2::framework::vectorToBranch(int const*, size_t);
+extern template boost::property_tree::ptree o2::framework::vectorToBranch(double const*, size_t);
+extern template boost::property_tree::ptree o2::framework::vectorToBranch(bool const*, size_t);
+extern template boost::property_tree::ptree o2::framework::vectorToBranch(std::basic_string<char> const*, size_t);
 
 extern template boost::property_tree::ptree o2::framework::labeledArrayToBranch(o2::framework::LabeledArray<float>&& array);
 extern template boost::property_tree::ptree o2::framework::labeledArrayToBranch(o2::framework::LabeledArray<int>&& array);
diff --git a/Framework/Core/src/Variant.cxx b/Framework/Core/src/Variant.cxx
index 21eb6103aa56a..e54a973bd4413 100644
--- a/Framework/Core/src/Variant.cxx
+++ b/Framework/Core/src/Variant.cxx
@@ -89,29 +89,29 @@ Variant::Variant(const Variant& other) : mType(other.mType)
   // In case this is an array we need to duplicate it to avoid
   // double deletion.
   switch (mType) {
-    case variant_trait_v<const char*>:
+    case VariantType::String:
       mSize = other.mSize;
       variant_helper<const char*>::set(&mStore, other.get<const char*>());
       return;
-    case variant_trait_v<int*>:
+    case VariantType::ArrayInt:
       mSize = other.mSize;
       variant_helper<int*>::set(&mStore, other.get<int*>(), mSize);
       return;
-    case variant_trait_v<float*>:
+    case VariantType::ArrayFloat:
       mSize = other.mSize;
       variant_helper<float*>::set(&mStore, other.get<float*>(), mSize);
       return;
-    case variant_trait_v<double*>:
+    case VariantType::ArrayDouble:
       mSize = other.mSize;
       variant_helper<double*>::set(&mStore, other.get<double*>(), mSize);
       return;
-    case variant_trait_v<bool*>:
+    case VariantType::ArrayBool:
       mSize = other.mSize;
       variant_helper<bool*>::set(&mStore, other.get<bool*>(), mSize);
       return;
-    case variant_trait_v<std::string*>:
+    case VariantType::ArrayString:
       mSize = other.mSize;
-      variant_helper<std::string*>::set(&mStore, other.get<std::string*>(), mSize);
+      variant_helper<std::vector<std::string>>::set(&mStore, other.get<std::vector<std::string>>());
       return;
     default:
       mStore = other.mStore;
@@ -124,23 +124,14 @@ Variant::Variant(Variant&& other) noexcept : mType(other.mType)
   mStore = other.mStore;
   mSize = other.mSize;
   switch (mType) {
-    case variant_trait_v<const char*>:
-      *reinterpret_cast<char**>(&(other.mStore)) = nullptr;
-      return;
-    case variant_trait_v<int*>:
-      *reinterpret_cast<int**>(&(other.mStore)) = nullptr;
-      return;
-    case variant_trait_v<float*>:
-      *reinterpret_cast<float**>(&(other.mStore)) = nullptr;
-      return;
-    case variant_trait_v<double*>:
-      *reinterpret_cast<double**>(&(other.mStore)) = nullptr;
-      return;
-    case variant_trait_v<bool*>:
-      *reinterpret_cast<bool**>(&(other.mStore)) = nullptr;
+    case VariantType::String:
+    case VariantType::ArrayInt:
+    case VariantType::ArrayFloat:
+    case VariantType::ArrayDouble:
+    case VariantType::ArrayBool:
+    case VariantType::ArrayString:
+      *reinterpret_cast<void**>(&(other.mStore)) = nullptr;
       return;
-    case variant_trait_v<std::string*>:
-      *reinterpret_cast<std::string**>(&(other.mStore)) = nullptr;
     default:
       return;
   }
@@ -151,16 +142,20 @@ Variant::~Variant()
   // In case we allocated an array, we
   // should delete it.
   switch (mType) {
-    case variant_trait_v<const char*>:
-    case variant_trait_v<int*>:
-    case variant_trait_v<float*>:
-    case variant_trait_v<double*>:
-    case variant_trait_v<bool*>:
-    case variant_trait_v<std::string*>:
+    case VariantType::String:
+    case VariantType::ArrayInt:
+    case VariantType::ArrayFloat:
+    case VariantType::ArrayDouble:
+    case VariantType::ArrayBool: {
       if (reinterpret_cast<void**>(&mStore) != nullptr) {
         free(*reinterpret_cast<void**>(&mStore));
       }
       return;
+    }
+    case VariantType::ArrayString: {
+      // Allocated with placement new. Nothing to delete.
+      return;
+    }
     default:
       return;
   }
@@ -171,23 +166,23 @@ Variant& Variant::operator=(const Variant& other)
   mSize = other.mSize;
   mType = other.mType;
   switch (mType) {
-    case variant_trait_v<const char*>:
+    case VariantType::String:
       variant_helper<const char*>::set(&mStore, other.get<const char*>());
       return *this;
-    case variant_trait_v<int*>:
+    case VariantType::ArrayInt:
       variant_helper<int*>::set(&mStore, other.get<int*>(), mSize);
       return *this;
-    case variant_trait_v<float*>:
+    case VariantType::ArrayFloat:
       variant_helper<float*>::set(&mStore, other.get<float*>(), mSize);
       return *this;
-    case variant_trait_v<double*>:
+    case VariantType::ArrayDouble:
       variant_helper<double*>::set(&mStore, other.get<double*>(), mSize);
       return *this;
-    case variant_trait_v<bool*>:
+    case VariantType::ArrayBool:
       variant_helper<bool*>::set(&mStore, other.get<bool*>(), mSize);
       return *this;
-    case variant_trait_v<std::string*>:
-      variant_helper<std::string*>::set(&mStore, other.get<std::string*>(), mSize);
+    case VariantType::ArrayString:
+      variant_helper<std::vector<std::string>>::set(&mStore, other.get<std::vector<std::string>>());
       return *this;
     default:
       mStore = other.mStore;
@@ -200,29 +195,29 @@ Variant& Variant::operator=(Variant&& other) noexcept
   mSize = other.mSize;
   mType = other.mType;
   switch (mType) {
-    case variant_trait_v<const char*>:
+    case VariantType::String:
       variant_helper<const char*>::set(&mStore, other.get<const char*>());
       *reinterpret_cast<char**>(&(other.mStore)) = nullptr;
       return *this;
-    case variant_trait_v<int*>:
+    case VariantType::ArrayInt:
       variant_helper<int*>::set(&mStore, other.get<int*>(), mSize);
       *reinterpret_cast<int**>(&(other.mStore)) = nullptr;
       return *this;
-    case variant_trait_v<float*>:
+    case VariantType::ArrayFloat:
       variant_helper<float*>::set(&mStore, other.get<float*>(), mSize);
       *reinterpret_cast<float**>(&(other.mStore)) = nullptr;
       return *this;
-    case variant_trait_v<double*>:
+    case VariantType::ArrayDouble:
       variant_helper<double*>::set(&mStore, other.get<double*>(), mSize);
       *reinterpret_cast<double**>(&(other.mStore)) = nullptr;
       return *this;
-    case variant_trait_v<bool*>:
+    case VariantType::ArrayBool:
       variant_helper<bool*>::set(&mStore, other.get<bool*>(), mSize);
       *reinterpret_cast<bool**>(&(other.mStore)) = nullptr;
       return *this;
-    case variant_trait_v<std::string*>:
-      variant_helper<std::string*>::set(&mStore, other.get<std::string*>(), mSize);
-      *reinterpret_cast<std::string**>(&(other.mStore)) = nullptr;
+    case VariantType::ArrayString:
+      variant_helper<std::vector<std::string>>::set(&mStore, other.get<std::vector<std::string>>());
+      *reinterpret_cast<std::vector<std::string>**>(&(other.mStore)) = nullptr;
       return *this;
     default:
       mStore = other.mStore;
diff --git a/Framework/Core/src/VariantPropertyTreeHelpers.cxx b/Framework/Core/src/VariantPropertyTreeHelpers.cxx
index 2b1746aae2c66..cb0aefaab39ec 100644
--- a/Framework/Core/src/VariantPropertyTreeHelpers.cxx
+++ b/Framework/Core/src/VariantPropertyTreeHelpers.cxx
@@ -19,17 +19,17 @@ template boost::property_tree::ptree o2::framework::basicVectorToBranch(float*,
 template boost::property_tree::ptree o2::framework::basicVectorToBranch(int*, size_t);
 template boost::property_tree::ptree o2::framework::basicVectorToBranch(double*, size_t);
 template boost::property_tree::ptree o2::framework::basicVectorToBranch(bool*, size_t);
-template boost::property_tree::ptree o2::framework::basicVectorToBranch(std::basic_string<char>*, size_t);
+template boost::property_tree::ptree o2::framework::basicVectorToBranch(std::basic_string<char> const*, size_t);
 
 template boost::property_tree::ptree o2::framework::vectorToBranch(std::vector<float>&& values);
 template boost::property_tree::ptree o2::framework::vectorToBranch(std::vector<int>&& values);
 template boost::property_tree::ptree o2::framework::vectorToBranch(std::vector<double>&& values);
 template boost::property_tree::ptree o2::framework::vectorToBranch(std::vector<std::string>&& values);
-template boost::property_tree::ptree o2::framework::vectorToBranch(float*, size_t);
-template boost::property_tree::ptree o2::framework::vectorToBranch(int*, size_t);
-template boost::property_tree::ptree o2::framework::vectorToBranch(double*, size_t);
-template boost::property_tree::ptree o2::framework::vectorToBranch(bool*, size_t);
-template boost::property_tree::ptree o2::framework::vectorToBranch(std::basic_string<char>*, size_t);
+template boost::property_tree::ptree o2::framework::vectorToBranch(float const*, size_t);
+template boost::property_tree::ptree o2::framework::vectorToBranch(int const*, size_t);
+template boost::property_tree::ptree o2::framework::vectorToBranch(double const*, size_t);
+template boost::property_tree::ptree o2::framework::vectorToBranch(bool const*, size_t);
+template boost::property_tree::ptree o2::framework::vectorToBranch(std::basic_string<char> const*, size_t);
 
 template boost::property_tree::ptree o2::framework::labeledArrayToBranch(o2::framework::LabeledArray<float>&& array);
 template boost::property_tree::ptree o2::framework::labeledArrayToBranch(o2::framework::LabeledArray<int>&& array);

From 93e99c90329fa96b810919304d1dc41bc98b0d3c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Nov 2025 14:16:50 +0100
Subject: [PATCH 1074/1764] GPU: Fix handling of non critical errors in
 double-pipeline mode

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 21 ++++++++-----------
 .../Global/GPUChainTrackingCompression.cxx    |  5 +++--
 2 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index be2aff617ff34..cae7c5025609b 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -63,7 +63,7 @@ struct GPUReconstructionPipelineQueue {
 } // namespace
 
 struct GPUReconstructionPipelineContext {
-  std::queue<GPUReconstructionPipelineQueue*> queue;
+  std::queue<GPUReconstructionPipelineQueue*> pipelineQueue;
   std::mutex mutex;
   std::condition_variable cond;
   bool terminate = false;
@@ -1089,13 +1089,13 @@ void GPUReconstruction::RunPipelineWorker()
   while (!terminate) {
     {
       std::unique_lock<std::mutex> lk(mPipelineContext->mutex);
-      mPipelineContext->cond.wait(lk, [this] { return this->mPipelineContext->queue.size() > 0; });
+      mPipelineContext->cond.wait(lk, [this] { return this->mPipelineContext->pipelineQueue.size() > 0; });
     }
     GPUReconstructionPipelineQueue* q;
     {
       std::lock_guard<std::mutex> lk(mPipelineContext->mutex);
-      q = mPipelineContext->queue.front();
-      mPipelineContext->queue.pop();
+      q = mPipelineContext->pipelineQueue.front();
+      mPipelineContext->pipelineQueue.pop();
     }
     if (q->op == 1) {
       terminate = 1;
@@ -1132,26 +1132,23 @@ int32_t GPUReconstruction::EnqueuePipeline(bool terminate)
     if (rec->mPipelineContext->terminate) {
       throw std::runtime_error("Must not enqueue work after termination request");
     }
-    rec->mPipelineContext->queue.push(q);
+    rec->mPipelineContext->pipelineQueue.push(q);
     rec->mPipelineContext->terminate = terminate;
     rec->mPipelineContext->cond.notify_one();
   }
   q->c.wait(lkdone, [&q]() { return q->done; });
-  if (q->retVal) {
+  if (terminate || (q->retVal && (q->retVal != 3 || !GetProcessingSettings().ignoreNonFatalGPUErrors))) {
     return q->retVal;
   }
-  if (terminate) {
-    return 0;
-  } else {
-    return mChains[0]->FinalizePipelinedProcessing();
-  }
+  int32_t retVal2 = mChains[0]->FinalizePipelinedProcessing();
+  return retVal2 ? retVal2 : q->retVal;
 }
 
 GPUChain* GPUReconstruction::GetNextChainInQueue()
 {
   GPUReconstruction* rec = mMaster ? mMaster : this;
   std::lock_guard<std::mutex> lk(rec->mPipelineContext->mutex);
-  return rec->mPipelineContext->queue.size() && rec->mPipelineContext->queue.front()->op == 0 ? rec->mPipelineContext->queue.front()->chain : nullptr;
+  return rec->mPipelineContext->pipelineQueue.size() && rec->mPipelineContext->pipelineQueue.front()->op == 0 ? rec->mPipelineContext->pipelineQueue.front()->chain : nullptr;
 }
 
 void GPUReconstruction::PrepareEvent() // TODO: Clean this up, this should not be called from chainTracking but before
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index e06699c0918b8..ca1352b3bda1b 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -62,8 +62,9 @@ int32_t GPUChainTracking::RunTPCCompression()
 #ifdef GPUCA_TPC_GEOMETRY_O2
   if (mPipelineFinalizationCtx && GetProcessingSettings().doublePipelineClusterizer) {
     SynchronizeEventAndRelease(mEvents->single);
-    ((GPUChainTracking*)GetNextChainInQueue())->RunTPCClusterizer_prepare(false);
-    ((GPUChainTracking*)GetNextChainInQueue())->mCFContext->ptrClusterNativeSave = processorsShadow()->ioPtrs.clustersNative;
+    auto* foreignChain = (GPUChainTracking*)GetNextChainInQueue();
+    foreignChain->RunTPCClusterizer_prepare(false);
+    foreignChain->mCFContext->ptrClusterNativeSave = processorsShadow()->ioPtrs.clustersNative;
   }
 #endif
   SynchronizeStream(0);

From 1058417c46a2e306ed3c16ecf9994d60494d1513 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Nov 2025 09:31:05 +0100
Subject: [PATCH 1075/1764] jobutils: Remove exception list from previous
 commands

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu | 2 +-
 Utilities/Tools/jobutils.sh                           | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
index 66c02d6ed251c..32286905f2a71 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDArtc.cu
@@ -20,7 +20,7 @@
 #define GPUCA_DETERMINISTIC_CODE(...) GPUCA_DETERMINISTIC_CODE(__VA_ARGS__)
 #define GPUCA_RTC_CONSTEXPR GPUCA_RTC_CONSTEXPR
 
-// GPUReconstructionCUDAIncludesSystem.h prependended by CMakewithout preprocessor running
+// GPUReconstructionCUDAIncludesSystem.h prependended by CMake without preprocessor running
 #include "GPUReconstructionCUDADef.h"
 #include "GPUReconstructionIncludesDeviceAll.h"
 
diff --git a/Utilities/Tools/jobutils.sh b/Utilities/Tools/jobutils.sh
index 54f1394197815..7853f281f004b 100644
--- a/Utilities/Tools/jobutils.sh
+++ b/Utilities/Tools/jobutils.sh
@@ -107,6 +107,7 @@ taskwrapper() {
 
   STARTTIME=$SECONDS
 
+  rm -f encountered_exceptions_list_${logfile}
   # launch the actual command in the background
   echo "Launching task: ${command} &> $logfile &"
   # the command might be a complex block: For the timing measurement below
@@ -191,10 +192,10 @@ taskwrapper() {
 
     exclude_pattern="-e \"To change the tolerance or the exception severity\""
 
-    grepcommand="grep -a -H ${pattern} $logfile ${JOBUTILS_JOB_SUPERVISEDFILES} | grep -a -v ${exclude_pattern} >> encountered_exceptions_list 2>/dev/null"
+    grepcommand="grep -a -H ${pattern} $logfile ${JOBUTILS_JOB_SUPERVISEDFILES} | grep -a -v ${exclude_pattern} >> encountered_exceptions_list_${logfile} 2>/dev/null"
     eval ${grepcommand}
 
-    grepcommand="cat encountered_exceptions_list 2>/dev/null | wc -l"
+    grepcommand="cat encountered_exceptions_list_${logfile} 2>/dev/null | wc -l"
     # using eval here since otherwise the pattern is translated to a
     # a weirdly quoted stringlist
     RC=$(eval ${grepcommand})

From 3f8a3843ae92a4287561ce08c191f493b0e6f664 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Nov 2025 11:31:34 +0100
Subject: [PATCH 1076/1764] GPU Standalone: Add GPUCA_BUILD_DEBUG_HOSTONLY
 debug option

---
 GPU/GPUTracking/Base/hip/CMakeLists.txt       | 6 ++++++
 GPU/GPUTracking/Standalone/cmake/config.cmake | 1 +
 dependencies/FindO2GPU.cmake                  | 8 ++++----
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 17bbf46795761..501509d8dfcf6 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -11,6 +11,12 @@
 
 set(MODULE GPUTrackingHIP)
 
+if(GPUCA_BUILD_DEBUG AND GPUCA_BUILD_DEBUG_HOSTONLY)
+  set(CMAKE_BUILD_TYPE RELEASE)
+  set(CMAKE_HIP_FLAGS_RELEASE "${CMAKE_HIP_FLAGS_RELEASE} -O3 -march=native -ggdb -fno-sanitize=all -DNDEBUG")
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -march=native -ggdb -fno-sanitize=all -DNDEBUG")
+endif()
+
 # -------------------------------- Options -------------------------------------------------------
 # set(GPUCA_HIP_HIPIFY_FROM_CUDA 0) # Use local HIP source files
 
diff --git a/GPU/GPUTracking/Standalone/cmake/config.cmake b/GPU/GPUTracking/Standalone/cmake/config.cmake
index 88fe418d40e5b..ca723063b6d3b 100644
--- a/GPU/GPUTracking/Standalone/cmake/config.cmake
+++ b/GPU/GPUTracking/Standalone/cmake/config.cmake
@@ -28,6 +28,7 @@ set(GPUCA_CONFIG_GL3W 0)
 set(GPUCA_CONFIG_O2 1)
 set(GPUCA_BUILD_DEBUG 0)
 set(GPUCA_BUILD_DEBUG_SANITIZE 0)
+set(GPUCA_BUILD_DEBUG_HOSTONLY 0)
 set(GPUCA_DETERMINISTIC_MODE 0)             # OFF / NO_FAST_MATH / OPTO2 / GPU / WHOLEO2
 #set(GPUCA_CUDA_GCCBIN c++-14)
 #set(GPUCA_OPENCL_CLANGBIN clang-20)
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 5815657ff6386..0be3448ed6fce 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 6
+# FindO2GPU.cmake Version 7
 
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
@@ -166,14 +166,14 @@ if(ENABLE_CUDA)
     if (NOT ENABLE_CUDA STREQUAL "AUTO")
       string(APPEND CMAKE_CUDA_FLAGS " --allow-unsupported-compiler")
     endif()
-    if(CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
+    if(CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG" AND NOT GPUCA_BUILD_DEBUG_HOSTONLY)
       string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -lineinfo -Xptxas -O0")
     else()
       string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -Xptxas -O4 -Xcompiler -O4")
     endif()
     if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
       string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " ${GPUCA_CUDA_NO_FAST_MATH_FLAGS}")
-    elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
+    elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG" OR GPUCA_BUILD_DEBUG_HOSTONLY)
       string(APPEND CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -use_fast_math ${GPUCA_CUDA_DENORMALS_FLAGS}")
     endif()
     if(CMAKE_CXX_FLAGS MATCHES "(^| )-Werror( |$)")
@@ -314,7 +314,7 @@ if(ENABLE_HIP)
     endif()
     if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH})
       string(APPEND CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " ${GPUCA_CXX_NO_FAST_MATH_FLAGS}")
-    elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
+    elseif(NOT CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG" OR GPUCA_BUILD_DEBUG_HOSTONLY)
       string(APPEND CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} " -ffast-math -O3")
     endif()
     string(REGEX REPLACE "(gfx1[0-9]+;?)" "" CMAKE_HIP_ARCHITECTURES "${CMAKE_HIP_ARCHITECTURES}") # ROCm currently doesn’t support integrated graphics

From 580d11efdf866a2ede187655f612408870d81e0c Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 27 Nov 2025 02:01:31 +0100
Subject: [PATCH 1077/1764] Methods for Kalman filter linearized wrt reference
 track

---
 DataFormats/Reconstruction/CMakeLists.txt     |   1 +
 .../TrackParametrization.h                    |   1 +
 .../TrackParametrizationWithError.h           |  11 +-
 .../src/TrackParametrization.cxx              |  32 +
 .../src/TrackParametrizationWithError.cxx     | 565 +++++++++++++++++-
 .../Base/include/DetectorsBase/Propagator.h   |  28 +
 Detectors/Base/src/Propagator.cxx             | 138 ++++-
 7 files changed, 750 insertions(+), 26 deletions(-)

diff --git a/DataFormats/Reconstruction/CMakeLists.txt b/DataFormats/Reconstruction/CMakeLists.txt
index ffd88df2412f9..d3ca8fdc70ad6 100644
--- a/DataFormats/Reconstruction/CMakeLists.txt
+++ b/DataFormats/Reconstruction/CMakeLists.txt
@@ -8,6 +8,7 @@
 # In applying this license CERN does not waive the privileges and immunities
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
+# add_compile_options(-O0 -g -fPIC)
 
 o2_add_library(ReconstructionDataFormats
                SOURCES src/TrackParametrization.cxx
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index 8cb22efd39e38..1d6c4d9f0e4ea 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -229,6 +229,7 @@ class TrackParametrization
   // parameters manipulation
   GPUd() bool correctForELoss(value_t xrho, bool anglecorr = false);
   GPUd() bool rotateParam(value_t alpha);
+  GPUd() bool rotateParam(value_t& alpha, value_t& ca, value_t& sa);
   GPUd() bool propagateParamTo(value_t xk, value_t b);
   GPUd() bool propagateParamTo(value_t xk, const dim3_t& b);
   GPUd() void invertParam();
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
index cd9d1517a81b1..0fc01e6db61a2 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
@@ -89,9 +89,14 @@ class TrackParametrizationWithError : public TrackParametrization<value_T>
   // parameters + covmat manipulation
   GPUd() bool testRotate(value_t alpha) const;
   GPUd() bool rotate(value_t alpha);
-  GPUd() bool propagateTo(value_t xk, value_t b);
+  GPUd() bool rotate(value_t alpha, TrackParametrization<value_T>& linRef, value_t bz);
+  GPUd() bool propagateTo(value_t xk, value_t bz);
+  GPUd() bool propagateTo(value_t xk, TrackParametrization<value_T>& linRef, value_t bz);
+  GPUd() bool propagateTo(value_t xk, value_t bz, TrackParametrization<value_T>* linRef) { return linRef ? propagateTo(xk, *linRef, bz) : propagateTo(xk, bz); }
   GPUd() bool propagateTo(value_t xk, const dim3_t& b);
-  GPUd() bool propagateToDCA(const o2::dataformats::VertexBase& vtx, value_t b, o2::dataformats::DCA* dca = nullptr, value_t maxD = 999.f);
+  GPUd() bool propagateTo(value_t xk, TrackParametrization<value_T>& linRef, const dim3_t& b);
+  GPUd() bool propagateTo(value_t xk, const dim3_t& b, TrackParametrization<value_T>* linRef) { return linRef ? propagateTo(xk, *linRef, b) : propagateTo(xk, b); }
+  GPUd() bool propagateToDCA(const o2::dataformats::VertexBase& vtx, value_t bz, o2::dataformats::DCA* dca = nullptr, value_t maxD = 999.f);
   GPUd() void invert();
   GPUd() value_t getPredictedChi2(const dim2_t& p, const dim3_t& cov) const;
   GPUd() value_t getPredictedChi2Quiet(const dim2_t& p, const dim3_t& cov) const;
@@ -118,7 +123,7 @@ class TrackParametrizationWithError : public TrackParametrization<value_T>
   GPUd() bool update(const BaseCluster<T>& p);
 
   GPUd() bool correctForMaterial(value_t x2x0, value_t xrho, bool anglecorr = false);
-
+  GPUd() bool correctForMaterial(TrackParametrization<value_T>& linRef, value_t x2x0, value_t xrho, bool anglecorr = false);
   GPUd() void resetCovariance(value_t s2 = 0);
   GPUd() void checkCovariance();
   GPUd() void checkCorrelations();
diff --git a/DataFormats/Reconstruction/src/TrackParametrization.cxx b/DataFormats/Reconstruction/src/TrackParametrization.cxx
index 7086e4d93cec8..7fe677a6e1c7a 100644
--- a/DataFormats/Reconstruction/src/TrackParametrization.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrization.cxx
@@ -188,6 +188,38 @@ GPUd() bool TrackParametrization<value_T>::rotateParam(value_t alpha)
   return true;
 }
 
+//______________________________________________________________
+template <typename value_T>
+GPUd() bool TrackParametrization<value_T>::rotateParam(value_t& alpha, value_t& ca, value_t& sa)
+{
+  // rotate to alpha frame
+  if (gpu::CAMath::Abs(getSnp()) > constants::math::Almost1) {
+    LOGP(debug, "Precondition is not satisfied: |sin(phi)|>1 ! {:f}", getSnp());
+    return false;
+  }
+  //
+  math_utils::detail::bringToPMPi<value_t>(alpha);
+  math_utils::detail::sincos(alpha - getAlpha(), sa, ca);
+  value_t snp = getSnp(), csp = gpu::CAMath::Sqrt((1.f - snp) * (1.f + snp)); // Improve precision
+  // RS: check if rotation does no invalidate track model (cos(local_phi)>=0, i.e. particle direction in local frame is along the X axis
+  if ((csp * ca + snp * sa) < 0) {
+    // LOGF(warning,"Rotation failed: local cos(phi) would become {:.2f}", csp * ca + snp * sa);
+    return false;
+  }
+  //
+  value_t tmp = snp * ca - csp * sa;
+  if (gpu::CAMath::Abs(tmp) > constants::math::Almost1) {
+    LOGP(debug, "Rotation failed: new snp {:.2f}", tmp);
+    return false;
+  }
+  value_t xold = getX(), yold = getY();
+  mAlpha = alpha;
+  mX = xold * ca + yold * sa;
+  mP[kY] = -xold * sa + yold * ca;
+  mP[kSnp] = tmp;
+  return true;
+}
+
 //____________________________________________________________
 template <typename value_T>
 GPUd() bool TrackParametrization<value_T>::propagateParamTo(value_t xk, const dim3_t& b)
diff --git a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
index 01849bd0c9e8f..2f8f15f783c60 100644
--- a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
@@ -43,7 +43,7 @@ GPUd() void TrackParametrizationWithError<value_T>::invert()
 
 //______________________________________________________________
 template <typename value_T>
-GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, value_t b)
+GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, value_t bz)
 {
   //----------------------------------------------------------------
   // propagate this track to the plane X=xk (cm) in the field "b" (kG)
@@ -52,7 +52,7 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, valu
   if (gpu::CAMath::Abs(dx) < constants::math::Almost0) {
     return true;
   }
-  value_t crv = this->getCurvature(b);
+  value_t crv = this->getCurvature(bz);
   value_t x2r = crv * dx;
   value_t f1 = this->getSnp(), f2 = f1 + x2r;
   if ((gpu::CAMath::Abs(f1) > constants::math::Almost1) || (gpu::CAMath::Abs(f2) > constants::math::Almost1)) {
@@ -66,7 +66,8 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, valu
   if (gpu::CAMath::Abs(r2) < constants::math::Almost0) {
     return false;
   }
-  double dy2dx = (f1 + f2) / (r1 + r2);
+  double r1pr2Inv = 1. / (r1 + r2);
+  double dy2dx = (f1 + f2) * r1pr2Inv;
   bool arcz = gpu::CAMath::Abs(x2r) > 0.05f;
   params_t dP{0.f};
   if (arcz) {
@@ -106,14 +107,110 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, valu
           &c44 = mC[kSigQ2Pt2];
 
   // evaluate matrix in double prec.
-  double rinv = 1. / r1;
-  double r3inv = rinv * rinv * rinv;
-  double f24 = dx * b * constants::math::B2C; // x2r/mP[kQ2Pt];
-  double f02 = dx * r3inv;
-  double f04 = 0.5 * f24 * f02;
-  double f12 = f02 * this->getTgl() * f1;
-  double f14 = 0.5 * f24 * f12; // 0.5*f24*f02*getTgl()*f1;
-  double f13 = dx * rinv;
+  value_t kb = bz * constants::math::B2C;
+  double r2inv = 1. / r2, r1inv = 1. / r1;
+  double dx2r1pr2 = dx * r1pr2Inv;
+
+  double hh = dx2r1pr2 * r2inv * (1. + r1 * r2 + f1 * f2), jj = dx * (dy2dx - f2 * r2inv);
+  double f02 = hh * r1inv;
+  double f04 = hh * dx2r1pr2 * kb;
+  double f24 = dx * kb; // x2r/mP[kQ2Pt];
+  double f12 = this->getTgl() * (f02 * f2 + jj);
+  double f13 = dx * (r2 + f2 * dy2dx);
+  double f14 = this->getTgl() * (f04 * f2 + jj * f24);
+
+  // b = C*ft
+  double b00 = f02 * c20 + f04 * c40, b01 = f12 * c20 + f14 * c40 + f13 * c30;
+  double b02 = f24 * c40;
+  double b10 = f02 * c21 + f04 * c41, b11 = f12 * c21 + f14 * c41 + f13 * c31;
+  double b12 = f24 * c41;
+  double b20 = f02 * c22 + f04 * c42, b21 = f12 * c22 + f14 * c42 + f13 * c32;
+  double b22 = f24 * c42;
+  double b40 = f02 * c42 + f04 * c44, b41 = f12 * c42 + f14 * c44 + f13 * c43;
+  double b42 = f24 * c44;
+  double b30 = f02 * c32 + f04 * c43, b31 = f12 * c32 + f14 * c43 + f13 * c33;
+  double b32 = f24 * c43;
+
+  // a = f*b = f*C*ft
+  double a00 = f02 * b20 + f04 * b40, a01 = f02 * b21 + f04 * b41, a02 = f02 * b22 + f04 * b42;
+  double a11 = f12 * b21 + f14 * b41 + f13 * b31, a12 = f12 * b22 + f14 * b42 + f13 * b32;
+  double a22 = f24 * b42;
+
+  // F*C*Ft = C + (b + bt + a)
+  c00 += b00 + b00 + a00;
+  c10 += b10 + b01 + a01;
+  c20 += b20 + b02 + a02;
+  c30 += b30;
+  c40 += b40;
+  c11 += b11 + b11 + a11;
+  c21 += b21 + b12 + a12;
+  c31 += b31;
+  c41 += b41;
+  c22 += b22 + b22 + a22;
+  c32 += b32;
+  c42 += b42;
+
+  checkCovariance();
+
+  return true;
+}
+
+//______________________________________________________________
+template <typename value_T>
+GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, TrackParametrization<value_T>& linRef0, value_t bz)
+{
+  //----------------------------------------------------------------
+  // propagate this track to the plane X=xk (cm) in the field "b" (kG), using linRef as linearization point
+  //----------------------------------------------------------------
+  if (this->getAbsCharge() == 0) {
+    bz = 0;
+  }
+  value_t dx = xk - this->getX();
+  if (gpu::CAMath::Abs(dx) < constants::math::Almost0) {
+    this->setX(xk);
+    linRef0.setX(xk);
+    return true;
+  }
+  // propagate reference track
+  TrackParametrization<value_T> linRef1 = linRef0;
+  if (!linRef1.propagateTo(xk, bz)) {
+    return false;
+  }
+  value_t kb = bz * constants::math::B2C;
+  // evaluate in double prec.
+  double snpRef0 = linRef0.getSnp(), cspRef0 = gpu::CAMath::Sqrt((1 - snpRef0) * (1 + snpRef0));
+  double snpRef1 = linRef1.getSnp(), cspRef1 = gpu::CAMath::Sqrt((1 - snpRef1) * (1 + snpRef1));
+  double cspRef0Inv = 1 / cspRef0, cspRef1Inv = 1 / cspRef1, cc = cspRef0 + cspRef1, ccInv = 1 / cc, dy2dx = (snpRef0 + snpRef1) * ccInv;
+  double dxccInv = dx * ccInv, hh = dxccInv * cspRef1Inv * (1 + cspRef0 * cspRef1 + snpRef0 * snpRef1), jj = dx * (dy2dx - snpRef1 * cspRef1Inv);
+
+  double f02 = hh * cspRef0Inv;
+  double f04 = hh * dxccInv * kb;
+  double f24 = dx * kb;
+  double f12 = linRef0.getTgl() * (f02 * snpRef1 + jj);
+  double f13 = dx * (cspRef1 + snpRef1 * dy2dx); // dS
+  double f14 = linRef0.getTgl() * (f04 * snpRef1 + jj * f24);
+
+  // difference between the current and reference state
+  value_t diff[5];
+  for (int i = 0; i < 5; i++) {
+    diff[i] = this->getParam(i) - linRef0.getParam(i);
+  }
+  value_t snpUpd = snpRef1 + diff[kSnp] + f24 * diff[kQ2Pt];
+  if (gpu::CAMath::Abs(snpUpd) > constants::math::Almost1) {
+    return false;
+  }
+  linRef0 = linRef1; // update reference track
+  this->setX(xk);
+  this->setY(linRef1.getY() + diff[kY] + f02 * diff[kSnp] + f04 * diff[kQ2Pt]);
+  this->setZ(linRef1.getZ() + diff[kZ] + f13 * diff[kTgl] + f14 * diff[kQ2Pt]);
+  this->setSnp(snpUpd);
+  this->setTgl(linRef1.getTgl() + diff[kTgl]);
+  this->setQ2Pt(linRef1.getQ2Pt() + diff[kQ2Pt]);
+
+  value_t &c00 = mC[kSigY2], &c10 = mC[kSigZY], &c11 = mC[kSigZ2], &c20 = mC[kSigSnpY], &c21 = mC[kSigSnpZ],
+          &c22 = mC[kSigSnp2], &c30 = mC[kSigTglY], &c31 = mC[kSigTglZ], &c32 = mC[kSigTglSnp], &c33 = mC[kSigTgl2],
+          &c40 = mC[kSigQ2PtY], &c41 = mC[kSigQ2PtZ], &c42 = mC[kSigQ2PtSnp], &c43 = mC[kSigQ2PtTgl],
+          &c44 = mC[kSigQ2Pt2];
 
   // b = C*ft
   double b00 = f02 * c20 + f04 * c40, b01 = f12 * c20 + f14 * c40 + f13 * c30;
@@ -158,6 +255,7 @@ GPUd() bool TrackParametrizationWithError<value_T>::testRotate(value_t) const
   // no ops
   return true;
 }
+
 //______________________________________________________________
 template <typename value_T>
 GPUd() bool TrackParametrizationWithError<value_T>::rotate(value_t alpha)
@@ -213,6 +311,101 @@ GPUd() bool TrackParametrizationWithError<value_T>::rotate(value_t alpha)
   return true;
 }
 
+//______________________________________________________________
+template <typename value_T>
+GPUd() bool TrackParametrizationWithError<value_T>::rotate(value_t alpha, TrackParametrization<value_T>& linRef0, value_t bz)
+{
+  // RS: similar to int32_t GPUTPCGMPropagator::RotateToAlpha(float newAlpha), i.e. rotate the track to new frame alpha, using linRef as linearization point
+  // rotate to alpha frame the reference (linearization point) trackParam, then align the current track to it
+  if (gpu::CAMath::Abs(this->getSnp()) > constants::math::Almost1) {
+    LOGP(debug, "Precondition is not satisfied: |sin(phi)|>1 ! {:f}", this->getSnp());
+    return false;
+  }
+  //
+  math_utils::detail::bringToPMPi<value_t>(alpha);
+  //
+  value_t ca = 0, sa = 0;
+  TrackParametrization<value_T> linRef1 = linRef0;
+  // rotate the reference, adjusting alpha to +-pi, return precalculated cos and sin of alpha - alphaOld
+  if (!linRef1.rotateParam(alpha, ca, sa)) {
+    return false;
+  }
+
+  value_t trackX = this->getX() * ca + this->getY() * sa; // X of the rotated current track
+  if (!linRef1.propagateParamTo(trackX, bz)) {
+    return false;
+  }
+
+  // now rotate the current track
+  value_t snp = this->getSnp(), csp = gpu::CAMath::Sqrt((1.f - snp) * (1.f + snp)), updSnp = snp * ca - csp * sa;
+  if ((csp * ca + snp * sa) < 0 || gpu::CAMath::Abs(updSnp) > constants::math::Almost1) {
+    // LOGP(warning,"Rotation failed: local cos(phi) would become {:.2f}", csp * ca + snp * sa);
+    return false;
+  }
+  this->setY(-sa * this->getX() + ca * this->getY());
+  this->setX(trackX);
+  this->setSnp(updSnp);
+  this->setAlpha(alpha);
+
+  // rotate covariance, accounting for the extra error from the rotated X
+  value_t snpRef0 = linRef0.getSnp(), cspRef0 = gpu::CAMath::Sqrt((value_t(1) - snpRef0) * (value_t(1) + snpRef0)); // original reference
+  value_t snpRef1 = linRef1.getSnp(), cspRef1 = ca * cspRef0 + sa * snpRef0;                                        // rotated reference
+  value_t rr = cspRef1 / cspRef0;                                                                                   // cos1_ref / cos0_ref
+
+  // "extra row" of the lower triangle of cov. matrix
+  value_t cXSigY = mC[kSigY2] * ca * sa;
+  value_t cXSigZ = mC[kSigZY] * sa;
+  value_t cXSigSnp = mC[kSigSnpY] * rr * sa;
+  value_t cXSigTgl = mC[kSigTglY] * sa;
+  value_t cXSigQ2Pt = mC[kSigQ2PtY] * sa;
+  value_t cSigX2 = mC[kSigY2] * sa * sa;
+
+  // plane rotation of existing cov matrix
+  mC[kSigY2] *= ca * ca;
+  mC[kSigZY] *= ca;
+  mC[kSigSnpY] *= ca * rr;
+  mC[kSigSnpZ] *= rr;
+  mC[kSigSnp2] *= rr * rr;
+  mC[kSigTglY] *= ca;
+  mC[kSigTglSnp] *= rr;
+  mC[kSigQ2PtY] *= ca;
+  mC[kSigQ2PtSnp] *= rr;
+
+  // transport covariance from pseudo 6x6 matrix to usual 5x5, Jacobian (trust to Sergey):
+  auto cspRef1Inv = value_t(1) / cspRef1;
+  auto j3 = -snpRef1 * cspRef1Inv;          // -pYmod/pXmod = -tg_pho = -sin_phi_mod / cos_phi_mod
+  auto j4 = -linRef1.getTgl() * cspRef1Inv; // -pZmod/pXmod = -tgl_mod / cos_phi_mod
+  auto j5 = linRef1.getCurvature(bz);
+  //       Y  Z Sin DzDs q/p  X
+  //  { {  1, 0, 0,  0,  0,  j3 }, // Y
+  //    {  0, 1, 0,  0,  0,  j4 }, // Z
+  //    {  0, 0, 1,  0,  0,  j5 }, // snp
+  //    {  0, 0, 0,  1,  0,   0 }, // tgl
+  //    {  0, 0, 0,  0,  1,   0 } }; // q/pt
+  auto hXSigY = cXSigY + cSigX2 * j3;
+  auto hXSigZ = cXSigZ + cSigX2 * j4;
+  auto hXSigSnp = cXSigSnp + cSigX2 * j5;
+
+  mC[kSigY2] += j3 * (cXSigY + hXSigY);
+  mC[kSigZ2] += j4 * (cXSigZ + hXSigZ);
+  mC[kSigSnpY] += cXSigSnp * j3 + hXSigY * j5;
+  mC[kSigSnp2] += j5 * (cXSigSnp + hXSigSnp);
+  mC[kSigTglZ] += cXSigTgl * j4;
+  mC[kSigQ2PtY] += cXSigQ2Pt * j3;
+  mC[kSigQ2PtSnp] += cXSigQ2Pt * j5;
+
+  mC[kSigZY] += cXSigZ * j3 + hXSigY * j4;
+  mC[kSigSnpZ] += cXSigSnp * j4 + hXSigZ * j5;
+  mC[kSigTglY] += cXSigTgl * j3;
+  mC[kSigTglSnp] += cXSigTgl * j5;
+  mC[kSigQ2PtZ] += cXSigQ2Pt * j4;
+
+  checkCovariance();
+  linRef0 = linRef1;
+
+  return true;
+}
+
 //_______________________________________________________________________
 template <typename value_T>
 GPUd() bool TrackParametrizationWithError<value_T>::propagateToDCA(const o2::dataformats::VertexBase& vtx, value_t b, o2::dataformats::DCA* dca, value_t maxD)
@@ -476,8 +669,8 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, cons
   if (gpu::CAMath::Abs(r2) < constants::math::Almost0) {
     return false;
   }
-
-  value_t dy2dx = (f1 + f2) / (r1 + r2);
+  double r1pr2Inv = 1. / (r1 + r2), r2inv = 1. / r2, r1inv = 1. / r1;
+  double dy2dx = (f1 + f2) * r1pr2Inv, dx2r1pr2 = dx * r1pr2Inv;
   value_t step = (gpu::CAMath::Abs(x2r) < 0.05f) ? dx * gpu::CAMath::Abs(r2 + f2 * dy2dx)                                                   // chord
                                                  : 2.f * gpu::CAMath::ASin(0.5f * dx * gpu::CAMath::Sqrt(1.f + dy2dx * dy2dx) * crv) / crv; // arc
   step *= gpu::CAMath::Sqrt(1.f + this->getTgl() * this->getTgl());
@@ -493,15 +686,16 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, cons
           &c22 = mC[kSigSnp2], &c30 = mC[kSigTglY], &c31 = mC[kSigTglZ], &c32 = mC[kSigTglSnp], &c33 = mC[kSigTgl2],
           &c40 = mC[kSigQ2PtY], &c41 = mC[kSigQ2PtZ], &c42 = mC[kSigQ2PtSnp], &c43 = mC[kSigQ2PtTgl],
           &c44 = mC[kSigQ2Pt2];
+
   // evaluate matrix in double prec.
-  double rinv = 1. / r1;
-  double r3inv = rinv * rinv * rinv;
-  double f24 = dx * b[2] * constants::math::B2C; // x2r/track[kQ2Pt];
-  double f02 = dx * r3inv;
-  double f04 = 0.5 * f24 * f02;
-  double f12 = f02 * this->getTgl() * f1;
-  double f14 = 0.5 * f24 * f12; // 0.5*f24*f02*getTgl()*f1;
-  double f13 = dx * rinv;
+  value_t kb = b[2] * constants::math::B2C;
+  double hh = dx2r1pr2 * r2inv * (1. + r1 * r2 + f1 * f2), jj = dx * (dy2dx - f2 * r2inv);
+  double f02 = hh * r1inv;
+  double f04 = hh * dx2r1pr2 * kb;
+  double f24 = dx * kb; // x2r/mP[kQ2Pt];
+  double f12 = this->getTgl() * (f02 * f2 + jj);
+  double f13 = dx * (r2 + f2 * dy2dx);
+  double f14 = this->getTgl() * (f04 * f2 + jj * f24);
 
   // b = C*ft
   double b00 = f02 * c20 + f04 * c40, b01 = f12 * c20 + f14 * c40 + f13 * c30;
@@ -604,6 +798,198 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, cons
   return true;
 }
 
+//____________________________________________________________
+template <typename value_T>
+GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, TrackParametrization<value_T>& linRef0, const dim3_t& b)
+{
+  //----------------------------------------------------------------
+  // Extrapolate this track to the plane X=xk in the field b[].
+  //
+  // X [cm] is in the "tracking coordinate system" of this track.
+  // b[]={Bx,By,Bz} [kG] is in the Global coordidate system.
+  //----------------------------------------------------------------
+
+  value_t dx = xk - this->getX();
+  if (gpu::CAMath::Abs(dx) < constants::math::Almost0) {
+    return true;
+  }
+  // Do not propagate tracks outside the ALICE detector
+  if (gpu::CAMath::Abs(dx) > 1e5 || gpu::CAMath::Abs(this->getY()) > 1e5 || gpu::CAMath::Abs(this->getZ()) > 1e5) {
+    LOG(warning) << "Anomalous track, target X:" << xk;
+    //    print();
+    return false;
+  }
+  if (gpu::CAMath::Abs(dx) < constants::math::Almost0) {
+    this->setX(xk);
+    linRef0.setX(xk);
+    return true;
+  }
+  // preliminary calculations to find the step size
+  value_t crv = (gpu::CAMath::Abs(b[2]) < constants::math::Almost0) ? 0.f : linRef0.getCurvature(b[2]);
+  if (gpu::CAMath::Abs(crv) < constants::math::Almost0) {
+    return propagateTo(xk, linRef0, 0.);
+  }
+  value_t kb = b[2] * constants::math::B2C, x2r = crv * dx;
+  // evaluate in double prec.
+  value_t snpRef0 = linRef0.getSnp(), snpRef1 = snpRef0 + x2r;
+  if ((gpu::CAMath::Abs(snpRef0) > constants::math::Almost1) || (gpu::CAMath::Abs(snpRef1) > constants::math::Almost1)) {
+    return false;
+  }
+  value_t cspRef0 = gpu::CAMath::Sqrt((1 - snpRef0) * (1 + snpRef0)), cspRef1 = gpu::CAMath::Sqrt((1 - snpRef1) * (1 + snpRef1));
+  if (gpu::CAMath::Abs(cspRef0) < constants::math::Almost0 || gpu::CAMath::Abs(cspRef1) < constants::math::Almost0) {
+    return false;
+  }
+  value_t cspRef0Inv = value_t(1) / cspRef0, cspRef1Inv = value_t(1) / cspRef1, cc = cspRef0 + cspRef1, ccInv = value_t(1) / cc, dy2dx = (snpRef0 + snpRef1) * ccInv;
+  value_t step = (gpu::CAMath::Abs(crv * dx) < 0.05f) ? dx * (cspRef1 + snpRef1 * dy2dx) : 2. * gpu::CAMath::ASin(0.5 * dx * gpu::CAMath::Sqrt(1.f + dy2dx * dy2dx) * crv) / crv; // arc
+  step *= gpu::CAMath::Sqrt(1.f + linRef0.getTgl() * linRef0.getTgl());
+
+  //
+  // get the track x,y,z,px/p,py/p,pz/p,p,sinAlpha,cosAlpha in the Global System
+  std::array<value_t, 9> vecLab{0.f};
+  if (!linRef0.getPosDirGlo(vecLab)) {
+    return false;
+  }
+  //
+  // Rotate to the system where Bx=By=0.
+  value_t bxy2 = b[0] * b[0] + b[1] * b[1];
+  value_t bt = gpu::CAMath::Sqrt(bxy2);
+  value_t cosphi = 1.f, sinphi = 0.f;
+  if (bt > constants::math::Almost0) {
+    cosphi = b[0] / bt;
+    sinphi = b[1] / bt;
+  }
+  value_t bb = gpu::CAMath::Sqrt(bxy2 + b[2] * b[2]);
+  value_t costet = 1., sintet = 0.;
+  if (bb > constants::math::Almost0) {
+    costet = b[2] / bb;
+    sintet = bt / bb;
+  }
+  std::array<value_t, 7> vect{costet * cosphi * vecLab[0] + costet * sinphi * vecLab[1] - sintet * vecLab[2],
+                              -sinphi * vecLab[0] + cosphi * vecLab[1],
+                              sintet * cosphi * vecLab[0] + sintet * sinphi * vecLab[1] + costet * vecLab[2],
+                              costet * cosphi * vecLab[3] + costet * sinphi * vecLab[4] - sintet * vecLab[5],
+                              -sinphi * vecLab[3] + cosphi * vecLab[4],
+                              sintet * cosphi * vecLab[3] + sintet * sinphi * vecLab[4] + costet * vecLab[5],
+                              vecLab[6]};
+
+  // Do the helix step
+  value_t q = this->getCharge();
+  g3helx3(q * bb, step, vect);
+
+  // Rotate back to the Global System
+  vecLab[0] = cosphi * costet * vect[0] - sinphi * vect[1] + cosphi * sintet * vect[2];
+  vecLab[1] = sinphi * costet * vect[0] + cosphi * vect[1] + sinphi * sintet * vect[2];
+  vecLab[2] = -sintet * vect[0] + costet * vect[2];
+
+  vecLab[3] = cosphi * costet * vect[3] - sinphi * vect[4] + cosphi * sintet * vect[5];
+  vecLab[4] = sinphi * costet * vect[3] + cosphi * vect[4] + sinphi * sintet * vect[5];
+  vecLab[5] = -sintet * vect[3] + costet * vect[5];
+
+  // Rotate back to the Tracking System
+  value_t sinalp = -vecLab[7], cosalp = vecLab[8];
+  value_t t = cosalp * vecLab[0] - sinalp * vecLab[1];
+  vecLab[1] = sinalp * vecLab[0] + cosalp * vecLab[1];
+  vecLab[0] = t;
+  t = cosalp * vecLab[3] - sinalp * vecLab[4];
+  vecLab[4] = sinalp * vecLab[3] + cosalp * vecLab[4];
+  vecLab[3] = t;
+
+  // Do the final correcting step to the target plane (linear approximation)
+  value_t x = vecLab[0], y = vecLab[1], z = vecLab[2];
+  if (gpu::CAMath::Abs(dx) > constants::math::Almost0) {
+    if (gpu::CAMath::Abs(vecLab[3]) < constants::math::Almost0) {
+      return false;
+    }
+    auto dxFin = xk - vecLab[0];
+    x += dxFin;
+    y += vecLab[4] / vecLab[3] * dxFin;
+    z += vecLab[5] / vecLab[3] * dxFin;
+  }
+
+  // Calculate the track parameters
+  auto linRef1 = linRef0;
+  t = 1.f / gpu::CAMath::Sqrt(vecLab[3] * vecLab[3] + vecLab[4] * vecLab[4]);
+  linRef1.setX(xk);
+  linRef1.setY(y);
+  linRef1.setZ(z);
+  linRef1.setSnp(snpRef1 = vecLab[4] * t); // reassign snpRef1
+  linRef1.setTgl(vecLab[5] * t);
+  linRef1.setQ2Pt(q * t / vecLab[6]);
+
+  // recalculate parameters of the transported ref track needed for transport of this:
+  cspRef1 = gpu::CAMath::Sqrt((1 - snpRef1) * (1 + snpRef1));
+  cspRef1Inv = value_t(1) / cspRef1;
+  cc = cspRef0 + cspRef1;
+  ccInv = value_t(1) / cc;
+  dy2dx = (snpRef0 + snpRef1) * ccInv;
+  double dxccInv = dx * ccInv, hh = dxccInv * cspRef1Inv * (1 + cspRef0 * cspRef1 + snpRef0 * snpRef1), jj = dx * (dy2dx - snpRef1 * cspRef1Inv);
+  double f02 = hh * cspRef0Inv;
+  double f04 = hh * dxccInv * kb;
+  double f24 = dx * kb;
+  double f12 = linRef0.getTgl() * (f02 * snpRef1 + jj);
+  double f13 = dx * (cspRef1 + snpRef1 * dy2dx); // dS
+  double f14 = linRef0.getTgl() * (f04 * snpRef1 + jj * f24);
+
+  // difference between the current and reference state
+  value_t diff[5];
+  for (int i = 0; i < 5; i++) {
+    diff[i] = this->getParam(i) - linRef0.getParam(i);
+  }
+  value_t snpUpd = snpRef1 + diff[kSnp] + f24 * diff[kQ2Pt];
+  if (gpu::CAMath::Abs(snpUpd) > constants::math::Almost1) {
+    return false;
+  }
+  this->setX(xk);
+  this->setY(linRef1.getY() + diff[kY] + f02 * diff[kSnp] + f04 * diff[kQ2Pt]);
+  this->setZ(linRef1.getZ() + diff[kZ] + f13 * diff[kTgl] + f14 * diff[kQ2Pt]);
+  this->setSnp(snpUpd);
+  this->setTgl(linRef1.getTgl() + diff[kTgl]);
+  this->setQ2Pt(linRef1.getQ2Pt() + diff[kQ2Pt]);
+
+  linRef0 = linRef1; // update reference track
+
+  // matrix transformed with Bz component only
+  value_t &c00 = mC[kSigY2], &c10 = mC[kSigZY], &c11 = mC[kSigZ2], &c20 = mC[kSigSnpY], &c21 = mC[kSigSnpZ],
+          &c22 = mC[kSigSnp2], &c30 = mC[kSigTglY], &c31 = mC[kSigTglZ], &c32 = mC[kSigTglSnp], &c33 = mC[kSigTgl2],
+          &c40 = mC[kSigQ2PtY], &c41 = mC[kSigQ2PtZ], &c42 = mC[kSigQ2PtSnp], &c43 = mC[kSigQ2PtTgl],
+          &c44 = mC[kSigQ2Pt2];
+
+  // b = C*ft
+  double b00 = f02 * c20 + f04 * c40, b01 = f12 * c20 + f14 * c40 + f13 * c30;
+  double b02 = f24 * c40;
+  double b10 = f02 * c21 + f04 * c41, b11 = f12 * c21 + f14 * c41 + f13 * c31;
+  double b12 = f24 * c41;
+  double b20 = f02 * c22 + f04 * c42, b21 = f12 * c22 + f14 * c42 + f13 * c32;
+  double b22 = f24 * c42;
+  double b40 = f02 * c42 + f04 * c44, b41 = f12 * c42 + f14 * c44 + f13 * c43;
+  double b42 = f24 * c44;
+  double b30 = f02 * c32 + f04 * c43, b31 = f12 * c32 + f14 * c43 + f13 * c33;
+  double b32 = f24 * c43;
+
+  // a = f*b = f*C*ft
+  double a00 = f02 * b20 + f04 * b40, a01 = f02 * b21 + f04 * b41, a02 = f02 * b22 + f04 * b42;
+  double a11 = f12 * b21 + f14 * b41 + f13 * b31, a12 = f12 * b22 + f14 * b42 + f13 * b32;
+  double a22 = f24 * b42;
+
+  // F*C*Ft = C + (b + bt + a)
+  c00 += b00 + b00 + a00;
+  c10 += b10 + b01 + a01;
+  c20 += b20 + b02 + a02;
+  c30 += b30;
+  c40 += b40;
+  c11 += b11 + b11 + a11;
+  c21 += b21 + b12 + a12;
+  c31 += b31;
+  c41 += b41;
+  c22 += b22 + b22 + a22;
+  c32 += b32;
+  c42 += b42;
+
+  checkCovariance();
+
+  return true;
+}
+
 //______________________________________________
 template <typename value_T>
 GPUd() void TrackParametrizationWithError<value_T>::checkCorrelations()
@@ -1121,6 +1507,143 @@ GPUd() bool TrackParametrizationWithError<value_T>::correctForMaterial(value_t x
   return true;
 }
 
+//______________________________________________
+template <typename value_T>
+GPUd() bool TrackParametrizationWithError<value_T>::correctForMaterial(TrackParametrization<value_T>& linRef, value_t x2x0, value_t xrho, bool anglecorr)
+{
+  //------------------------------------------------------------------
+  // This function corrects the reference and current track parameters for the crossed material
+  // "x2x0"   - X/X0, the thickness in units of the radiation length.
+  // "xrho" - is the product length*density (g/cm^2).
+  //     It should be passed as negative when propagating tracks
+  //     from the intreaction point to the outside of the central barrel.
+  // "dedx" - mean enery loss (GeV/(g/cm^2), if <=kCalcdEdxAuto : calculate on the fly
+  // "anglecorr" - switch for the angular correction
+  //------------------------------------------------------------------
+  constexpr value_t kMSConst2 = 0.0136f * 0.0136f;
+  constexpr value_t kMinP = 0.01f; // kill below this momentum
+
+  value_t csp2 = (1.f - linRef.getSnp()) * (1.f + linRef.getSnp()); // cos(phi)^2
+  value_t cst2I = (1.f + linRef.getTgl() * linRef.getTgl());        // 1/cos(lambda)^2
+  if (anglecorr) {                                                  // Apply angle correction, if requested
+    value_t angle = gpu::CAMath::Sqrt(cst2I / csp2);
+    x2x0 *= angle;
+    xrho *= angle;
+  }
+  auto pid = linRef.getPID();
+  auto m = pid.getMass();
+  int charge2 = linRef.getAbsCharge() * linRef.getAbsCharge();
+  value_t p = linRef.getP(), p0 = p, p02 = p * p, e2 = p02 + pid.getMass2(), massInv = 1. / m, bg = p * massInv, dETot = 0.;
+  value_t e = gpu::CAMath::Sqrt(e2), e0 = e;
+  if (m > 0 && xrho != 0.f) {
+    value_t ekin = e - m, dedx = this->getdEdxBBOpt(bg);
+#ifdef _BB_NONCONST_CORR_
+    value_t dedxDer = 0., dedx1 = dedx;
+#endif
+    if (charge2 != 1) {
+      dedx *= charge2;
+    }
+    value_t dE = dedx * xrho;
+    int na = 1 + int(gpu::CAMath::Abs(dE) / ekin * ELoss2EKinThreshInv);
+    if (na > MaxELossIter) {
+      na = MaxELossIter;
+    }
+    if (na > 1) {
+      dE /= na;
+      xrho /= na;
+#ifdef _BB_NONCONST_CORR_
+      dedxDer = this->getBetheBlochSolidDerivativeApprox(dedx1, bg); // require correction for non-constantness of dedx vs betagamma
+      if (charge2 != 1) {
+        dedxDer *= charge2;
+      }
+#endif
+    }
+    while (na--) {
+#ifdef _BB_NONCONST_CORR_
+      if (dedxDer != 0.) { // correction for non-constantness of dedx vs beta*gamma (in linear approximation): for a single step dE -> dE * [(exp(dedxDer) - 1)/dedxDer]
+        if (xrho < 0) {
+          dedxDer = -dedxDer; // E.loss ( -> positive derivative)
+        }
+        auto corrC = (gpu::CAMath::Exp(dedxDer) - 1.) / dedxDer;
+        dE *= corrC;
+      }
+#endif
+      e += dE;
+      if (e > m) { // stopped
+        p = gpu::CAMath::Sqrt(e * e - pid.getMass2());
+      } else {
+        return false;
+      }
+      if (na) {
+        bg = p * massInv;
+        dedx = this->getdEdxBBOpt(bg);
+#ifdef _BB_NONCONST_CORR_
+        dedxDer = this->getBetheBlochSolidDerivativeApprox(dedx, bg);
+#endif
+        if (charge2 != 1) {
+          dedx *= charge2;
+#ifdef _BB_NONCONST_CORR_
+          dedxDer *= charge2;
+#endif
+        }
+        dE = dedx * xrho;
+      }
+    }
+
+    if (p < kMinP) {
+      return false;
+    }
+    dETot = e - e0;
+  } // end of e.loss correction
+
+  // Calculating the multiple scattering corrections******************
+  value_t& fC22 = mC[kSigSnp2];
+  value_t& fC33 = mC[kSigTgl2];
+  value_t& fC43 = mC[kSigQ2PtTgl];
+  value_t& fC44 = mC[kSigQ2Pt2];
+  //
+  value_t cC22(0.f), cC33(0.f), cC43(0.f), cC44(0.f);
+  if (x2x0 != 0.f) {
+    value_t beta2 = p02 / e2, theta2 = kMSConst2 / (beta2 * p02) * gpu::CAMath::Abs(x2x0);
+    value_t fp34 = linRef.getTgl();
+    if (charge2 != 1) {
+      theta2 *= charge2;
+      fp34 *= linRef.getCharge2Pt();
+    }
+    if (theta2 > constants::math::PI * constants::math::PI) {
+      return false;
+    }
+    value_t t2c2I = theta2 * cst2I;
+    cC22 = t2c2I * csp2;
+    cC33 = t2c2I * cst2I;
+    cC43 = t2c2I * fp34;
+    cC44 = theta2 * fp34 * fp34;
+    // optimize this
+    //    cC22 = theta2*((1.-getSnp())*(1.+getSnp()))*(1. + this->getTgl()*getTgl());
+    //    cC33 = theta2*(1. + this->getTgl()*getTgl())*(1. + this->getTgl()*getTgl());
+    //    cC43 = theta2*getTgl()*this->getQ2Pt()*(1. + this->getTgl()*getTgl());
+    //    cC44 = theta2*getTgl()*this->getQ2Pt()*getTgl()*this->getQ2Pt();
+  }
+
+  // the energy loss correction contribution to cov.matrix: approximate energy loss fluctuation (M.Ivanov)
+  constexpr value_t knst = 0.0007f; // To be tuned.
+  value_t sigmadE = knst * gpu::CAMath::Sqrt(gpu::CAMath::Abs(dETot)) * e0 / p02 * linRef.getCharge2Pt();
+  cC44 += sigmadE * sigmadE;
+
+  // Applying the corrections*****************************
+  fC22 += cC22;
+  fC33 += cC33;
+  fC43 += cC43;
+  fC44 += cC44;
+  auto pscale = p0 / p;
+  linRef.setQ2Pt(linRef.getQ2Pt() * pscale);
+  this->setQ2Pt(this->getQ2Pt() * pscale);
+
+  checkCovariance();
+
+  return true;
+}
+
 //______________________________________________________________
 template <typename value_T>
 GPUd() bool TrackParametrizationWithError<value_T>::getCovXYZPxPyPzGlo(std::array<value_t, kLabCovMatSize>& cv) const
diff --git a/Detectors/Base/include/DetectorsBase/Propagator.h b/Detectors/Base/include/DetectorsBase/Propagator.h
index d9b1522f4295b..6fa750577255d 100644
--- a/Detectors/Base/include/DetectorsBase/Propagator.h
+++ b/Detectors/Base/include/DetectorsBase/Propagator.h
@@ -76,6 +76,10 @@ class PropagatorImpl
                                  value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
                                  track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
 
+  GPUd() bool PropagateToXBxByBz(TrackParCov_t& track, TrackPar_t& linRef, value_type x,
+                                 value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
+                                 track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
+
   GPUd() bool PropagateToXBxByBz(TrackPar_t& track, value_type x,
                                  value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
                                  track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
@@ -84,6 +88,10 @@ class PropagatorImpl
                            value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
                            track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
 
+  GPUd() bool propagateToX(TrackParCov_t& track, TrackPar_t& linRef, value_type x, value_type bZ,
+                           value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
+                           track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
+
   GPUd() bool propagateToX(TrackPar_t& track, value_type x, value_type bZ,
                            value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
                            track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
@@ -95,6 +103,26 @@ class PropagatorImpl
     return bzOnly ? propagateToX(track, x, getBz(track.getXYZGlo()), maxSnp, maxStep, matCorr, tofInfo, signCorr) : PropagateToXBxByBz(track, x, maxSnp, maxStep, matCorr, tofInfo, signCorr);
   }
 
+  GPUd() bool propagateToX(TrackParCov_t& track, TrackPar_t* linRef, value_type x, value_type bZ,
+                           value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
+                           track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const
+  {
+    return linRef ? propagateToX(track, *linRef, x, bZ, maxSnp, maxStep, matCorr, tofInfo, signCorr) : propagateToX(track, x, bZ, maxSnp, maxStep, matCorr, tofInfo, signCorr);
+  }
+
+  GPUd() bool PropagateToXBxByBz(TrackParCov_t& track, TrackPar_t* linRef, value_type x,
+                                 value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, MatCorrType matCorr = MatCorrType::USEMatCorrLUT,
+                                 track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const
+  {
+    return linRef ? PropagateToXBxByBz(track, *linRef, x, maxSnp, maxStep, matCorr, tofInfo, signCorr) : PropagateToXBxByBz(track, x, maxSnp, maxStep, matCorr, tofInfo, signCorr);
+  }
+
+  GPUd() bool propagateTo(TrackParCov_t& track, TrackPar_t* linRef, value_type x, bool bzOnly = false, value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP,
+                          MatCorrType matCorr = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const
+  {
+    return bzOnly ? propagateToX(track, linRef, x, getBz(track.getXYZGlo()), maxSnp, maxStep, matCorr, tofInfo, signCorr) : PropagateToXBxByBz(track, linRef, x, maxSnp, maxStep, matCorr, tofInfo, signCorr);
+  }
+
   template <typename track_T>
   GPUd() bool propagateToAlphaX(track_T& track, value_type alpha, value_type x, bool bzOnly = false, value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, int minSteps = 1,
                                 MatCorrType matCorr = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
diff --git a/Detectors/Base/src/Propagator.cxx b/Detectors/Base/src/Propagator.cxx
index 0763eb48ff474..02e7a05080ac5 100644
--- a/Detectors/Base/src/Propagator.cxx
+++ b/Detectors/Base/src/Propagator.cxx
@@ -218,6 +218,75 @@ GPUd() bool PropagatorImpl<value_T>::PropagateToXBxByBz(TrackParCov_t& track, va
   return true;
 }
 
+//_______________________________________________________________________
+template <typename value_T>
+GPUd() bool PropagatorImpl<value_T>::PropagateToXBxByBz(TrackParCov_t& track, TrackPar_t& linRef, value_type xToGo, value_type maxSnp, value_type maxStep,
+                                                        PropagatorImpl<value_T>::MatCorrType matCorr, track::TrackLTIntegral* tofInfo, int signCorr) const
+{
+  //----------------------------------------------------------------
+  //
+  // Propagates the track to the plane X=xk (cm), using linRef as a Kalman linearisation point.
+  // taking into account all the three components of the magnetic field
+  // and correcting for the crossed material.
+  //
+  // maxStep  - maximal step for propagation
+  // tofInfo  - optional container for track length and PID-dependent TOF integration
+  //
+  // matCorr  - material correction type, it is up to the user to make sure the pointer is attached (if LUT is requested)
+  //----------------------------------------------------------------
+  auto dx = xToGo - track.getX();
+  int dir = dx > 0.f ? 1 : -1;
+  if (!signCorr) {
+    signCorr = -dir; // sign of eloss correction is not imposed
+  }
+
+  std::array<value_type, 3> b{};
+  while (math_utils::detail::abs<value_type>(dx) > Epsilon) {
+    auto step = math_utils::detail::min<value_type>(math_utils::detail::abs<value_type>(dx), maxStep);
+    if (dir < 0) {
+      step = -step;
+    }
+    auto x = track.getX() + step;
+    auto xyz0 = linRef.getXYZGlo();
+    getFieldXYZ(xyz0, &b[0]);
+
+    auto correct = [&track, &linRef, &xyz0, tofInfo, matCorr, signCorr, this]() {
+      bool res = true;
+      if (matCorr != MatCorrType::USEMatCorrNONE) {
+        auto xyz1 = linRef.getXYZGlo();
+        auto mb = this->getMatBudget(matCorr, xyz0, xyz1);
+        if (!track.correctForMaterial(linRef, mb.meanX2X0, mb.getXRho(signCorr))) {
+          res = false;
+        }
+        if (tofInfo) {
+          tofInfo->addStep(mb.length, linRef.getQ2P2()); // fill L,ToF info using already calculated step length
+          tofInfo->addX2X0(mb.meanX2X0);
+          tofInfo->addXRho(mb.getXRho(signCorr));
+        }
+      } else if (tofInfo) { // if tofInfo filling was requested w/o material correction, we need to calculate the step lenght
+        auto xyz1 = linRef.getXYZGlo();
+        math_utils::Vector3D<value_type> stepV(xyz1.X() - xyz0.X(), xyz1.Y() - xyz0.Y(), xyz1.Z() - xyz0.Z());
+        tofInfo->addStep(stepV.R(), linRef.getQ2P2());
+      }
+      return res;
+    };
+
+    if (!track.propagateTo(x, linRef, b)) {
+      return false;
+    }
+    if (maxSnp > 0 && math_utils::detail::abs<value_type>(track.getSnp()) >= maxSnp) {
+      correct();
+      return false;
+    }
+    if (!correct()) {
+      return false;
+    }
+    dx = xToGo - track.getX();
+  }
+  track.setX(xToGo);
+  return true;
+}
+
 //_______________________________________________________________________
 template <typename value_T>
 GPUd() bool PropagatorImpl<value_T>::PropagateToXBxByBz(TrackPar_t& track, value_type xToGo, value_type maxSnp, value_type maxStep,
@@ -295,8 +364,7 @@ GPUd() bool PropagatorImpl<value_T>::propagateToX(TrackParCov_t& track, value_ty
   //----------------------------------------------------------------
   //
   // Propagates the track to the plane X=xk (cm)
-  // taking into account all the three components of the magnetic field
-  // and correcting for the crossed material.
+  // Use bz only and correct for the crossed material.
   //
   // maxStep  - maximal step for propagation
   // tofInfo  - optional container for track length and PID-dependent TOF integration
@@ -352,6 +420,72 @@ GPUd() bool PropagatorImpl<value_T>::propagateToX(TrackParCov_t& track, value_ty
   return true;
 }
 
+//_______________________________________________________________________
+template <typename value_T>
+GPUd() bool PropagatorImpl<value_T>::propagateToX(TrackParCov_t& track, TrackPar_t& linRef, value_type xToGo, value_type bZ, value_type maxSnp, value_type maxStep,
+                                                  PropagatorImpl<value_T>::MatCorrType matCorr, track::TrackLTIntegral* tofInfo, int signCorr) const
+{
+  //----------------------------------------------------------------
+  //
+  // Propagates the track to the plane X=xk (cm), using linRef as a Kalman linearisation point.
+  // Use bz only and correct for the crossed material if requested.
+  //
+  // maxStep  - maximal step for propagation
+  // tofInfo  - optional container for track length and PID-dependent TOF integration
+  //
+  // matCorr  - material correction type, it is up to the user to make sure the pointer is attached (if LUT is requested)
+  //----------------------------------------------------------------
+  auto dx = xToGo - track.getX();
+  int dir = dx > 0.f ? 1 : -1;
+  if (!signCorr) {
+    signCorr = -dir; // sign of eloss correction is not imposed
+  }
+
+  while (math_utils::detail::abs<value_type>(dx) > Epsilon) {
+    auto step = math_utils::detail::min<value_type>(math_utils::detail::abs<value_type>(dx), maxStep);
+    if (dir < 0) {
+      step = -step;
+    }
+    auto x = track.getX() + step;
+    auto xyz0 = linRef.getXYZGlo();
+
+    auto correct = [&track, &linRef, &xyz0, tofInfo, matCorr, signCorr, this]() {
+      bool res = true;
+      if (matCorr != MatCorrType::USEMatCorrNONE) {
+        auto xyz1 = linRef.getXYZGlo();
+        auto mb = this->getMatBudget(matCorr, xyz0, xyz1);
+        if (!track.correctForMaterial(linRef, mb.meanX2X0, mb.getXRho(signCorr))) {
+          res = false;
+        }
+        if (tofInfo) {
+          tofInfo->addStep(mb.length, linRef.getQ2P2()); // fill L,ToF info using already calculated step length
+          tofInfo->addX2X0(mb.meanX2X0);
+          tofInfo->addXRho(mb.getXRho(signCorr));
+        }
+      } else if (tofInfo) { // if tofInfo filling was requested w/o material correction, we need to calculate the step lenght
+        auto xyz1 = linRef.getXYZGlo();
+        math_utils::Vector3D<value_type> stepV(xyz1.X() - xyz0.X(), xyz1.Y() - xyz0.Y(), xyz1.Z() - xyz0.Z());
+        tofInfo->addStep(stepV.R(), linRef.getQ2P2());
+      }
+      return res;
+    };
+
+    if (!track.propagateTo(x, linRef, bZ)) { // linRef also updated
+      return false;
+    }
+    if (maxSnp > 0 && math_utils::detail::abs<value_type>(track.getSnp()) >= maxSnp) {
+      correct();
+      return false;
+    }
+    if (!correct()) {
+      return false;
+    }
+    dx = xToGo - track.getX();
+  }
+  track.setX(xToGo);
+  return true;
+}
+
 //_______________________________________________________________________
 template <typename value_T>
 GPUd() bool PropagatorImpl<value_T>::propagateToX(TrackPar_t& track, value_type xToGo, value_type bZ, value_type maxSnp, value_type maxStep,

From e82e4599fb904e9103661cf43c0eefb3fca41411 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 28 Nov 2025 17:34:48 +0100
Subject: [PATCH 1078/1764] Addapt ITS trackign to KF with external lin.ref

At the moment reseeding of lin.ref is not done, it is taken from the existing track seed
---
 .../include/ITStracking/Configuration.h       |  1 +
 .../include/ITStracking/TrackerTraits.h       |  2 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 82 +++++++++++++++----
 3 files changed, 66 insertions(+), 19 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index d7c4e27add739..3ed9e16373e22 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -66,6 +66,7 @@ struct TrackingParameters {
   o2::base::PropagatorImpl<float>::MatCorrType CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
   float MaxChi2ClusterAttachment = 60.f;
   float MaxChi2NDF = 30.f;
+  int reseedIfShorter = 7; // reseed for the final track with this and shorter length
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
   unsigned char StartLayerMask = 0x7F;
   bool FindShortTracks = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index ee64cacb8fa2a..4d98b96abcd9d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -93,7 +93,7 @@ class TrackerTraits
 
  private:
   track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3);
-  bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0);
+  bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0, o2::track::TrackPar* refLin = nullptr);
 
   bool mApplySmoothing = false;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 3a58ad1c000b7..76615bb0c5d06 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -765,21 +765,57 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
       auto forSeed = [&](auto Tag, int iSeed, int offset = 0) {
         const auto& seed{trackSeeds[iSeed]};
         TrackITSExt temporaryTrack{seed};
-        temporaryTrack.resetCovariance();
         temporaryTrack.setChi2(0);
         for (int iL{0}; iL < nLayers; ++iL) {
           temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
         }
-
-        bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
+        o2::track::TrackPar linRef{seed};
+        // do we want to reseed the track to get a stable reference?
+        /*{
+          int ncl = temporaryTrack.getNClusters();
+          if (ncl <= mTrkParams[0].reseedIfShorter) {
+            int lrMin = 999, lrMax = 0, lrMid = 0; // find midpoint
+            if (ncl == mTrkParams[0].NLayers) {
+              lrMin = 0;
+              lrMax = mTrkParams[0].NLayers - 1;
+              lrMid = (lrMin + lrMax) / 2;
+            } else {
+              for (int iL{0}; iL < nLayers; ++iL) {
+          if (seed.getCluster(iL) != constants::UnusedIndex) {
+            if (iL<lrMin) {
+              lrMin  = iL;
+            }
+            if (iL>lrMax) {
+              lrMax  = iL;
+            }
+          }
+              }
+              lrMid = lrMin+1;
+              float midR = 0.5*(mTrkParams[0].LayerRadii[lrMax] + mTrkParams[0].LayerRadii[lrMin]), dstMidR = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[lrMid]);
+              // find the midpoint as closest to the midR
+              for (int iL{lrMid+1}; iL < lrMax-1; ++iL) {
+          auto dst = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[iL]);
+          if (dst < dstMidR) {
+            lrMid = iL;
+            dstMidR = dst;
+          }
+              }
+            }
+          }
+          // RS TODO build seed: at the moment skip this: not sure how it will affect the GPU part)
+              }*/
+        temporaryTrack.resetCovariance();
+        temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
+        bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, o2::constants::math::VeryBig, 0, &linRef);
         if (!fitSuccess) {
           return 0;
         }
 
         temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
         temporaryTrack.resetCovariance();
+        temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
         temporaryTrack.setChi2(0);
-        fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f);
+        fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f, 0, &linRef);
         if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
           return 0;
         }
@@ -1045,7 +1081,7 @@ void TrackerTraits<nLayers>::findShortPrimaries()
 }
 
 template <int nLayers>
-bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut, float chi2ndfcut, float maxQoverPt, int nCl)
+bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut, float chi2ndfcut, float maxQoverPt, int nCl, o2::track::TrackPar* linRef)
 {
   auto propInstance = o2::base::Propagator::Instance();
 
@@ -1054,21 +1090,31 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
       continue;
     }
     const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer)[track.getClusterIndex(iLayer)];
-
-    if (!track.rotate(trackingHit.alphaTrackingFrame)) {
-      return false;
-    }
-
-    if (!propInstance->propagateToX(track, trackingHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
-      return false;
-    }
-
-    if (mTrkParams[0].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-      if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
-        continue;
+    if (linRef) {
+      if (!track.rotate(trackingHit.alphaTrackingFrame, *linRef, getBz())) {
+        return false;
+      }
+      if (!propInstance->propagateToX(track, *linRef, trackingHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
+        return false;
+      }
+      if (mTrkParams[0].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+        if (!track.correctForMaterial(*linRef, mTrkParams[0].LayerxX0[iLayer], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
+          continue;
+        }
+      }
+    } else {
+      if (!track.rotate(trackingHit.alphaTrackingFrame)) {
+        return false;
+      }
+      if (!propInstance->propagateToX(track, trackingHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
+        return false;
+      }
+      if (mTrkParams[0].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+        if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
+          continue;
+        }
       }
     }
-
     auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
     if ((nCl >= 3 && predChi2 > chi2clcut) || predChi2 < 0.f) {
       return false;

From 9e9f5bf948ae619357f83fd399d710d3e271cf74 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 28 Nov 2025 22:53:00 +0100
Subject: [PATCH 1079/1764] Unbinned residuals with ITS refit and PV point
 added

With scdcalib.refitITS=true (default) the ITS track outer param will be refitted from scratch using
stable Kalman filter staring from the inner param (and using it as as linearization point) and imposing
PID of the global track (if any).
Note that the reconstruction is done with extra syst.errors on the ITS clusters (20 microns): they can be
added also for this refit with usual ITSCATrackerParam.sysErrY2... settings (though this is not necessary).

The track residuals wrt the PV are added to the unbinned residuals with identified of padrow 190.
Note that PV residuals interpretation differs from the rest: they are provided at the PCA of the track to PV,
with PV rotated to the frame of the track. The X of the vertex in this frame is stored in the channel slot
mapped from [-0.5:0.5] to short; the alpha of the track frame is stored as the angle in [-pi : pi] mapped to short:

auto dy = yv - trkAtPCA.getY(), auto dz = zv - trkAtPCA.getZ();
short compXV = static_cast<short>(xv * 0x7fff / param::MaxVtxX); // MaxVtxX = 0.5 cm
mClRes.emplace_back(dy, dz, trkAtPCA.getAlpha() / TMath::Pi(), trkWorkITS.getY(), trkWorkITS.getZ(), 190, -1, compXV);
---
 .../calibration/SpacePoints/CMakeLists.txt    |   1 +
 .../SpacePoints/SpacePointsCalibConfParam.h   |   1 +
 .../SpacePoints/SpacePointsCalibParam.h       |   1 +
 .../include/SpacePoints/TrackInterpolation.h  |   4 +
 .../SpacePoints/src/TrackInterpolation.cxx    | 107 +++++++++++++++++-
 5 files changed, 111 insertions(+), 3 deletions(-)

diff --git a/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt b/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
index 566558b7e982f..510cff4f7760c 100644
--- a/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
+++ b/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
@@ -8,6 +8,7 @@
 # In applying this license CERN does not waive the privileges and immunities
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
+# add_compile_options(-O0 -g -fPIC)
 
 o2_add_library(SpacePoints
                SOURCES src/SpacePointsCalibParam.cxx
diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h
index 819ca7b0ae07f..6b18df54bc903 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h
@@ -41,6 +41,7 @@ struct SpacePointsCalibConfParam : public o2::conf::ConfigurableParamHelper<Spac
   int minTOFTRDPVContributors = 2;      ///< min contributors from TRD or TOF (fast detectors) to consider tracks of this PV
   bool ignoreNonPVContrib = true;       ///< flag if tracks which did not contribute to the PV should be ignored or not
   bool enableTrackDownsampling = false; ///< flag if track sampling shall be enabled or not
+  bool refitITS = true;                 ///< refit ITS tracks with PID attached to the seed
   float tsalisThreshold = 1.f;          ///< in case the sampling functions returns a value smaller than this the track is discarded (1. means no downsampling)
 
   // other settings for track interpolation
diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h
index 535dd23d7a8ae..34bb70899ff56 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibParam.h
@@ -58,6 +58,7 @@ static constexpr float MaxY = 50.f;      ///< max value for y position (sector c
 static constexpr float MaxZ = 300.f;     ///< max value for z position
 static constexpr float MaxTgSlp = 1.f;   ///< max value for phi (from snp, converted to tangens)
 static constexpr float MaxTRDSlope = 5.; ///< max value for the TRD tracklet getDy
+static constexpr float MaxVtxX = 0.5;    ///< max X value of the PV rotated to the frame of track at its DCA to PV
 // miscellaneous
 static constexpr float sEps = 1e-6f; ///< small number for float comparisons
 
diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
index eaaea3f26b995..992925179ffce 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
@@ -239,6 +239,8 @@ class TrackInterpolation
   /// Reset cache and output vectors
   void reset();
 
+  // refit ITS track taking PID (unless already refitted) from the seed and reassign to the seed
+  bool refITSTrack(o2::dataformats::GlobalTrackID, int iSeed);
   // -------------------------------------- outlier rejection --------------------------------------------------
 
   /// Validates the given input track and its residuals
@@ -328,6 +330,7 @@ class TrackInterpolation
   std::vector<o2::dataformats::GlobalTrackID> mGIDs{};                      ///< GIDs of input tracks
   std::vector<o2::globaltracking::RecoContainer::GlobalIDSet> mGIDtables{}; ///< GIDs of contributors from single detectors for each seed
   std::vector<float> mTrackTimes{};                                         ///< time estimates for all input tracks in micro seconds
+  std::vector<int> mTrackPVID{};                                            ///< track vertex index (if any)
   std::vector<o2::track::TrackParCov> mSeeds{};                             ///< seeding track parameters (ITS tracks)
   std::vector<int> mParentID{};                                             ///< entry of more global parent track for skimmed seeds (-1: no parent)
   std::map<int, int> mTrackTypes;                                           ///< mapping of track source to array index in mTrackIndices
@@ -337,6 +340,7 @@ class TrackInterpolation
   // ITS specific input only needed for debugging
   gsl::span<const int> mITSTrackClusIdx;                    ///< input ITS track cluster indices span
   std::vector<o2::BaseCluster<float>> mITSClustersArray;    ///< ITS clusters created in run() method from compact clusters
+  std::vector<int> mITSRefitSeedID;                         ///< seed ID first using refitted ITS track
   const o2::itsmft::TopologyDictionary* mITSDict = nullptr; ///< cluster patterns dictionary
 
   // output
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index f9861bb26ff93..6da293bb33022 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -221,6 +221,9 @@ void TrackInterpolation::prepareInputTrackSample(const o2::globaltracking::RecoC
   int nv = vtxRefs.size() - 1;
   GTrackID::mask_t allowedSources = GTrackID::getSourcesMask("ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF") & mSourcesConfigured;
   constexpr std::array<int, 3> SrcFast = {int(GTrackID::ITSTPCTRD), int(GTrackID::ITSTPCTOF), int(GTrackID::ITSTPCTRDTOF)};
+  if (mParams->refitITS) {
+    mITSRefitSeedID.resize(mRecoCont->getITSTracks().size(), -1);
+  }
 
   for (int iv = 0; iv < nv; iv++) {
     LOGP(debug, "processing PV {} of {}", iv, nv);
@@ -281,6 +284,7 @@ void TrackInterpolation::prepareInputTrackSample(const o2::globaltracking::RecoC
         mGIDtables.push_back(gidTable);
         mTrackTimes.push_back(pv.getTimeStamp().getTimeStamp());
         mTrackIndices[mTrackTypes[vid.getSource()]].push_back(nTrackSeeds++);
+        mTrackPVID.push_back(iv);
       }
     }
   }
@@ -360,13 +364,13 @@ void TrackInterpolation::process()
     if (mParams->enableTrackDownsampling && !isTrackSelected(mSeeds[seedIndex])) {
       continue;
     }
-
     auto addPart = [this, seedIndex](GTrackID::Source src) {
       this->mGIDs.push_back(this->mGIDtables[seedIndex][src]);
       this->mGIDtables.push_back(this->mRecoCont->getSingleDetectorRefs(this->mGIDs.back()));
       this->mTrackTimes.push_back(this->mTrackTimes[seedIndex]);
       this->mSeeds.push_back(this->mSeeds[seedIndex]);
       this->mParentID.push_back(seedIndex); // store parent seed id
+      this->mTrackPVID.push_back(this->mTrackPVID[seedIndex]);
     };
 
     GTrackID::mask_t partsAdded;
@@ -450,9 +454,12 @@ void TrackInterpolation::interpolateTrack(int iSeed)
       (*trackDataExtended).clsITS.push_back(clsITS);
     }
   }
+  if (mParams->refitITS && !refITSTrack(gidTable[GTrackID::ITS], iSeed)) {
+    return;
+  }
   trackData.gid = mGIDs[iSeed];
   trackData.par = mSeeds[iSeed];
-  auto& trkWork = mSeeds[iSeed];
+  auto trkWork = mSeeds[iSeed];
   o2::track::TrackPar trkInner{trkWork};
   // reset the cache array (sufficient to set cluster available to zero)
   for (auto& elem : mCache) {
@@ -734,6 +741,27 @@ void TrackInterpolation::interpolateTrack(int iSeed)
             trackData.nExtDetResid++;
           }
         }
+        if (!stopPropagation) { // add residual to PV
+          const auto& pv = mRecoCont->getPrimaryVertices()[mTrackPVID[iSeed]];
+          o2::math_utils::Point3D<float> vtx{pv.getX(), pv.getY(), pv.getZ()};
+          if (!propagator->propagateToDCA(vtx, trkWorkITS, mBz, mParams->maxStep, mMatCorr)) {
+            LOGP(debug, "Failed propagation to DCA to PV ({} {} {}), {}", pv.getX(), pv.getY(), pv.getZ(), trkWorkITS.asString());
+            stopPropagation = true;
+            break;
+          }
+          // rotate PV to the track frame
+          float sn, cs, alpha = trkWorkITS.getAlpha();
+          math_utils::detail::bringToPMPi(alpha);
+          math_utils::detail::sincos<float>(alpha, sn, cs);
+          float xv = vtx.X() * cs + vtx.Y() * sn, yv = -vtx.X() * sn + vtx.Y() * cs, zv = vtx.Z();
+          auto dy = yv - trkWorkITS.getY();
+          auto dz = zv - trkWorkITS.getZ();
+          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && abs(xv) < param::MaxVtxX) {
+            short compXV = static_cast<short>(xv * 0x7fff / param::MaxVtxX);
+            mClRes.emplace_back(dy, dz, alpha / TMath::Pi(), trkWorkITS.getY(), trkWorkITS.getZ(), 190, -1, compXV);
+            trackData.nExtDetResid++;
+          }
+        }
         break;
       }
     }
@@ -826,6 +854,9 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
       (*trackDataExtended).clsITS.push_back(clsITS);
     }
   }
+  if (mParams->refitITS && !refITSTrack(gidTable[GTrackID::ITS], iSeed)) {
+    return;
+  }
   trackData.gid = mGIDs[iSeed];
   trackData.par = mSeeds[iSeed];
 
@@ -987,7 +1018,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
           int chip = cls.getSensorID();
           float chipX, chipAlpha;
           geom->getSensorXAlphaRefPlane(cls.getSensorID(), chipX, chipAlpha);
-          if (!trkWorkITS.rotate(chipAlpha) || !propagator->PropagateToXBxByBz(trkWorkITS, chipX, mParams->maxSnp, mParams->maxStep, mMatCorr)) {
+          if (!trkWorkITS.rotate(chipAlpha) || !propagator->propagateToX(trkWorkITS, chipX, mBz, mParams->maxSnp, mParams->maxStep, mMatCorr)) {
             LOGP(debug, "Failed final propagation to ITS X={} alpha={}", chipX, chipAlpha);
             stopPropagation = true;
             break;
@@ -1000,6 +1031,27 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
             trackData.nExtDetResid++;
           }
         }
+        if (!stopPropagation) { // add residual to PV
+          const auto& pv = mRecoCont->getPrimaryVertices()[mTrackPVID[iSeed]];
+          o2::math_utils::Point3D<float> vtx{pv.getX(), pv.getY(), pv.getZ()};
+          if (!propagator->propagateToDCA(vtx, trkWorkITS, mBz, mParams->maxStep, mMatCorr)) {
+            LOGP(debug, "Failed propagation to DCA to PV ({} {} {}), {}", pv.getX(), pv.getY(), pv.getZ(), trkWorkITS.asString());
+            stopPropagation = true;
+            break;
+          }
+          // rotate PV to the track frame
+          float sn, cs, alpha = trkWorkITS.getAlpha();
+          math_utils::detail::bringToPMPi(alpha);
+          math_utils::detail::sincos<float>(alpha, sn, cs);
+          float xv = vtx.X() * cs + vtx.Y() * sn, yv = -vtx.X() * sn + vtx.Y() * cs, zv = vtx.Z();
+          auto dy = yv - trkWorkITS.getY();
+          auto dz = zv - trkWorkITS.getZ();
+          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && abs(xv) < param::MaxVtxX) {
+            short compXV = static_cast<short>(xv * 0x7fff / param::MaxVtxX);
+            mClRes.emplace_back(dy, dz, alpha / TMath::Pi(), trkWorkITS.getY(), trkWorkITS.getZ(), 190, -1, compXV);
+            trackData.nExtDetResid++;
+          }
+        }
         break;
       }
     }
@@ -1403,6 +1455,8 @@ void TrackInterpolation::reset()
   mGIDtables.clear();
   mTrackTimes.clear();
   mSeeds.clear();
+  mITSRefitSeedID.clear();
+  mTrackPVID.clear();
 }
 
 //______________________________________________
@@ -1416,3 +1470,50 @@ void TrackInterpolation::setTPCVDrift(const o2::tpc::VDriftCorrFact& v)
     o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mFastTransform, 0, 1.0, mTPCVDriftRef, mTPCDriftTimeOffsetRef);
   }
 }
+
+//______________________________________________
+bool TrackInterpolation::refITSTrack(o2::dataformats::GlobalTrackID gid, int seedID)
+{
+  // refit ITS track outwards taking PID (unless already refitted) from the seed and reassign to the seed
+  auto& seed = mSeeds[seedID];
+  int refitID = mITSRefitSeedID[gid.getIndex()];
+  if (refitID >= 0) { // track was already refitted
+    if (mSeeds[refitID].getPID() == seed.getPID()) {
+      seed = mSeeds[refitID];
+    }
+    return true;
+  }
+  const auto& trkITS = mRecoCont->getITSTrack(gid);
+  // fetch clusters
+  auto nCl = trkITS.getNumberOfClusters();
+  auto clEntry = trkITS.getFirstClusterEntry();
+  o2::track::TrackParCov track(trkITS); // start from the inner param
+  track.setPID(seed.getPID());
+  o2::track::TrackPar refLin(track); // and use it also as linearization reference
+  auto geom = o2::its::GeometryTGeo::Instance();
+  auto prop = o2::base::Propagator::Instance();
+  for (int iCl = nCl - 1; iCl >= 0; iCl--) { // clusters are stored from outer to inner layers
+    const auto& cls = mITSClustersArray[mITSTrackClusIdx[clEntry + iCl]];
+    int chip = cls.getSensorID();
+    float chipX, chipAlpha;
+    geom->getSensorXAlphaRefPlane(cls.getSensorID(), chipX, chipAlpha);
+    if (!track.rotate(chipAlpha, refLin, mBz)) {
+      LOGP(debug, "failed to rotate ITS tracks to alpha={} for the refit: {}", chipAlpha, track.asString());
+      return false;
+    }
+    if (!prop->propagateToX(track, refLin, cls.getX(), mBz, o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, o2::base::PropagatorF::MatCorrType::USEMatCorrLUT)) {
+      LOGP(debug, "failed to propagate ITS tracks to X={}: {}", cls.getX(), track.asString());
+      return false;
+    }
+    std::array<float, 2> posTF{cls.getY(), cls.getZ()};
+    std::array<float, 3> covTF{cls.getSigmaY2(), cls.getSigmaYZ(), cls.getSigmaZ2()};
+    if (!track.update(posTF, covTF)) {
+      LOGP(debug, "failed to update ITS tracks by cluster ({},{})/({},{},{})", track.asString(), cls.getY(), cls.getZ(), cls.getSigmaY2(), cls.getSigmaYZ(), cls.getSigmaZ2());
+      return false;
+    }
+  }
+  seed = track;
+  // memorize that this ITS track was already refitted
+  mITSRefitSeedID[gid.getIndex()] = seedID;
+  return true;
+}

From 4f75f1076cf0a8f330313458f821b9e763babb1d Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Fri, 28 Nov 2025 08:39:08 +0100
Subject: [PATCH 1080/1764] Generalize path/file finding for external collision
 context

---
 Steer/src/CollisionContextTool.cxx | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index 5287e1ef32799..a6c2b0e62e0ca 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -260,8 +260,15 @@ bool copy_collision_context(const std::string& external_path, int this_tf_id, in
 {
   namespace fs = std::filesystem;
   try {
-    // Construct source file path
-    fs::path filename = fs::path(external_path) / ("collission_context_" + std::to_string(this_tf_id) + ".root");
+    fs::path filename;
+    if (fs::exists(external_path) && fs::is_regular_file(external_path)) {
+      std::cout << "external_path is an existing file: " << external_path << "\n";
+      // use it directly
+      filename = fs::path(external_path);
+    } else {
+      // Construct source file path
+      filename = fs::path(external_path) / ("collission_context_" + std::to_string(this_tf_id) + ".root");
+    }
 
     LOG(info) << "Checking existence of file: " << filename;
 

From 15087d6d60f9e802669c5fb343535e3968b2a317 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 30 Nov 2025 01:07:58 +0100
Subject: [PATCH 1081/1764] Possibility to select shorter ITS tracks for
 special output of trackMCStudy

---
 .../study/include/GlobalTrackingStudy/TrackMCStudyConfig.h     | 1 +
 Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx    | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
index e67abe6de3315..ed78ba2a710ec 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudyConfig.h
@@ -34,6 +34,7 @@ struct TrackMCStudyConfig : o2::conf::ConfigurableParamHelper<TrackMCStudyConfig
   int nTBPerOccBin = 48;  // number of TB per occ bin
   float rejectClustersResStat = 0.1;
   float maxTPCRefExtrap = 2;                   // max dX to extrapolate the track ref when extrapolating track true posions
+  int minITSClForITSoutput = 7;                // create special ITS otput only for long enough tracks
   int decayPDG[5] = {310, 3122, 411, 421, -1}; // decays to study, must end by -1
   O2ParamDef(TrackMCStudyConfig, "trmcconf");
 };
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index cf04c7c653e40..c4a0a30116557 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -1303,6 +1303,7 @@ void TrackMCStudy::processITSTracks(const o2::globaltracking::RecoContainer& rec
   const auto itsClRefs = recoData.getITSTracksClusterRefs();
   const auto clusITS = recoData.getITSClusters();
   const auto patterns = recoData.getITSClustersPatterns();
+  const auto& params = o2::trackstudy::TrackMCStudyConfig::Instance();
   auto pattIt = patterns.begin();
   mITSClustersArray.clear();
   mITSClustersArray.reserve(clusITS.size());
@@ -1324,7 +1325,7 @@ void TrackMCStudy::processITSTracks(const o2::globaltracking::RecoContainer& rec
     const auto& itsLb = itsLbls[itr];
     //    LOGP(info,"proc {} {} {}",itr0, itr, itsLb.asString());
     int nCl = itsTr.getNClusters();
-    if (itsLb.isFake() || nCl != 7) {
+    if (itsLb.isFake() || nCl < params.minITSClForITSoutput) {
       continue;
     }
     auto entrySel = mSelMCTracks.find(itsLb);

From 99053b4e8b5f690fddac0469fe146d9aca056fdc Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 30 Nov 2025 01:08:50 +0100
Subject: [PATCH 1082/1764] Optionally reseed track before refit, shift
 reference to cluster

---
 .../include/ITStracking/Configuration.h       |   3 +-
 .../include/ITStracking/TrackerTraits.h       |   1 +
 .../include/ITStracking/TrackingConfigParam.h |   3 +-
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |   3 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 101 ++++++++++--------
 5 files changed, 63 insertions(+), 48 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 3ed9e16373e22..9a6452270d144 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -66,9 +66,10 @@ struct TrackingParameters {
   o2::base::PropagatorImpl<float>::MatCorrType CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
   float MaxChi2ClusterAttachment = 60.f;
   float MaxChi2NDF = 30.f;
-  int reseedIfShorter = 7; // reseed for the final track with this and shorter length
+  int reseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
   unsigned char StartLayerMask = 0x7F;
+  bool shiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool FindShortTracks = false;
   bool PerPrimaryVertexProcessing = false;
   bool SaveTimeBenchmarks = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 4d98b96abcd9d..f582b5ef3aec5 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -93,6 +93,7 @@ class TrackerTraits
 
  private:
   track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3);
+  TrackITSExt seedTrackForRefit(const CellSeedN& seed);
   bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0, o2::track::TrackPar* refLin = nullptr);
 
   bool mApplySmoothing = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 6c4ecc5ab424d..2a3506f17fa2f 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -96,7 +96,8 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   int trackingMode = -1;                   // -1: unset, 0=sync, 1=async, 2=cosmics used by gpuwf only
   bool doUPCIteration = false;             // Perform an additional iteration for UPC events on tagged vertices. You want to combine this config with VertexerParamConfig.nIterations=2
   int nIterations = MaxIter;               // overwrite the number of iterations
-
+  int reseedIfShorter = 6;                 // for the final refit reseed the track with circle if they are shorter than this value
+  bool shiftRefToCluster{true};            // TrackFit: after update shift the linearization reference to cluster
   bool createArtefactLabels{false}; // create on-the-fly labels for the artefacts
 
   int nThreads = 1;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index df736b3c7efdb..c6ed343033996 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -186,7 +186,8 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       int lslot = tc.MaxTrackLength - ilg;
       p.MinPt[lslot] *= bFactor;
     }
-
+    p.reseedIfShorter = tc.reseedIfShorter;
+    p.shiftRefToCluster = tc.shiftRefToCluster;
     p.createArtefactLabels = tc.createArtefactLabels;
 
     p.PrintMemory = tc.printMemory;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 76615bb0c5d06..5c5eb47216051 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -763,55 +763,15 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
     bounded_vector<TrackITSExt> tracks(mMemoryPool.get());
     mTaskArena->execute([&] {
       auto forSeed = [&](auto Tag, int iSeed, int offset = 0) {
-        const auto& seed{trackSeeds[iSeed]};
-        TrackITSExt temporaryTrack{seed};
-        temporaryTrack.setChi2(0);
-        for (int iL{0}; iL < nLayers; ++iL) {
-          temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
-        }
-        o2::track::TrackPar linRef{seed};
-        // do we want to reseed the track to get a stable reference?
-        /*{
-          int ncl = temporaryTrack.getNClusters();
-          if (ncl <= mTrkParams[0].reseedIfShorter) {
-            int lrMin = 999, lrMax = 0, lrMid = 0; // find midpoint
-            if (ncl == mTrkParams[0].NLayers) {
-              lrMin = 0;
-              lrMax = mTrkParams[0].NLayers - 1;
-              lrMid = (lrMin + lrMax) / 2;
-            } else {
-              for (int iL{0}; iL < nLayers; ++iL) {
-          if (seed.getCluster(iL) != constants::UnusedIndex) {
-            if (iL<lrMin) {
-              lrMin  = iL;
-            }
-            if (iL>lrMax) {
-              lrMax  = iL;
-            }
-          }
-              }
-              lrMid = lrMin+1;
-              float midR = 0.5*(mTrkParams[0].LayerRadii[lrMax] + mTrkParams[0].LayerRadii[lrMin]), dstMidR = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[lrMid]);
-              // find the midpoint as closest to the midR
-              for (int iL{lrMid+1}; iL < lrMax-1; ++iL) {
-          auto dst = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[iL]);
-          if (dst < dstMidR) {
-            lrMid = iL;
-            dstMidR = dst;
-          }
-              }
-            }
-          }
-          // RS TODO build seed: at the moment skip this: not sure how it will affect the GPU part)
-              }*/
-        temporaryTrack.resetCovariance();
-        temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
+        TrackITSExt temporaryTrack = seedTrackForRefit(trackSeeds[iSeed]);
+        o2::track::TrackPar linRef{temporaryTrack};
+        o2::track::TrackParCov savTr = temporaryTrack; // REMOVE
         bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, o2::constants::math::VeryBig, 0, &linRef);
         if (!fitSuccess) {
           return 0;
         }
-
         temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+        linRef = temporaryTrack.getParamOut(); // use refitted track as lin.reference
         temporaryTrack.resetCovariance();
         temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
         temporaryTrack.setChi2(0);
@@ -819,7 +779,6 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
           return 0;
         }
-
         if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
           tracks.push_back(temporaryTrack);
         } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
@@ -1123,6 +1082,10 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
     if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
       return false;
     }
+    if (linRef && mTrkParams[0].shiftRefToCluster) { // displace the reference to the last updated cluster
+      linRef->setY(trackingHit.positionTrackingFrame[0]);
+      linRef->setZ(trackingHit.positionTrackingFrame[1]);
+    }
     nCl++;
   }
   return std::abs(track.getQ2Pt()) < maxQoverPt && track.getChi2() < chi2ndfcut * (nCl * 2 - 5);
@@ -1240,6 +1203,54 @@ bool TrackerTraits<nLayers>::trackFollowing(TrackITSExt* track, int rof, bool ou
   return swapped;
 }
 
+// create a new seed either from the existing track inner param or reseed from the edgepointd and cluster in the middle
+template <int nLayers>
+TrackITSExt TrackerTraits<nLayers>::seedTrackForRefit(const CellSeedN& seed)
+{
+  TrackITSExt temporaryTrack(seed);
+  for (int iL = 0; iL < nLayers; ++iL) {
+    temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
+  }
+  int ncl = temporaryTrack.getNClusters();
+  if (ncl < mTrkParams[0].reseedIfShorter) { // reseed with circle passing via edges and the midpoint
+    int lrMin = 999, lrMax = 0, lrMid = 0;
+    if (ncl == mTrkParams[0].NLayers) {
+      lrMin = 0;
+      lrMax = mTrkParams[0].NLayers - 1;
+      lrMid = (lrMin + lrMax) / 2;
+    } else {
+      for (int iL = 0; iL < nLayers; ++iL) {
+        if (seed.getCluster(iL) != constants::UnusedIndex) {
+          if (iL < lrMin) {
+            lrMin = iL;
+          }
+          if (iL > lrMax) {
+            lrMax = iL;
+          }
+        }
+      }
+      lrMid = lrMin + 1;
+      float midR = 0.5 * (mTrkParams[0].LayerRadii[lrMax] + mTrkParams[0].LayerRadii[lrMin]), dstMidR = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[lrMid]);
+      for (int iL = lrMid + 1; iL < lrMax; ++iL) { // find the midpoint as closest to the midR
+        auto dst = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[iL]);
+        if (dst < dstMidR) {
+          lrMid = iL;
+          dstMidR = dst;
+        }
+      }
+    }
+    const auto& cluster0_tf = mTimeFrame->getTrackingFrameInfoOnLayer(lrMin)[seed.getCluster(lrMin)]; // if the sensor frame!
+    const auto& cluster1_gl = mTimeFrame->getUnsortedClusters()[lrMid][seed.getCluster(lrMid)];       // global frame
+    const auto& cluster2_gl = mTimeFrame->getUnsortedClusters()[lrMax][seed.getCluster(lrMax)];       // global frame
+    temporaryTrack.getParamIn() = buildTrackSeed(cluster2_gl, cluster1_gl, cluster0_tf);
+    temporaryTrack.setQ2Pt(-temporaryTrack.getQ2Pt()); // we are calling buildTrackSeed with the clusters order opposite to what it expects
+    temporaryTrack.setSnp(-temporaryTrack.getSnp());   // we are calling buildTrackSeed with the clusters order opposite to what it expects
+  }
+  temporaryTrack.resetCovariance();
+  temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
+  return temporaryTrack;
+}
+
 /// Clusters are given from inside outward (cluster3 is the outermost). The outermost cluster is given in the tracking
 /// frame coordinates whereas the others are referred to the global frame.
 template <int nLayers>

From d99e306eaa32d4878708aaea8b03329b499f7cce Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 30 Nov 2025 01:09:37 +0100
Subject: [PATCH 1083/1764] Optionally shift ITS track reference to cluster
 after update

---
 .../include/SpacePoints/SpacePointsCalibConfParam.h           | 1 +
 .../TPC/calibration/SpacePoints/src/TrackInterpolation.cxx    | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h
index 6b18df54bc903..8b884209dd697 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/SpacePointsCalibConfParam.h
@@ -42,6 +42,7 @@ struct SpacePointsCalibConfParam : public o2::conf::ConfigurableParamHelper<Spac
   bool ignoreNonPVContrib = true;       ///< flag if tracks which did not contribute to the PV should be ignored or not
   bool enableTrackDownsampling = false; ///< flag if track sampling shall be enabled or not
   bool refitITS = true;                 ///< refit ITS tracks with PID attached to the seed
+  bool shiftRefToCluster = true;        ///< when reftting the ITS track, shift the lin.reference to cluster after every update (better material matching)
   float tsalisThreshold = 1.f;          ///< in case the sampling functions returns a value smaller than this the track is discarded (1. means no downsampling)
 
   // other settings for track interpolation
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index 6da293bb33022..dddb0a5c435bc 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -1511,6 +1511,10 @@ bool TrackInterpolation::refITSTrack(o2::dataformats::GlobalTrackID gid, int see
       LOGP(debug, "failed to update ITS tracks by cluster ({},{})/({},{},{})", track.asString(), cls.getY(), cls.getZ(), cls.getSigmaY2(), cls.getSigmaYZ(), cls.getSigmaZ2());
       return false;
     }
+    if (mParams->shiftRefToCluster) {
+      refLin.setY(posTF[0]);
+      refLin.setZ(posTF[1]);
+    }
   }
   seed = track;
   // memorize that this ITS track was already refitted

From 22e2e612661a00ff6f3fd6e6ce91a6f2e53b4b03 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Thu, 20 Nov 2025 10:56:51 +0100
Subject: [PATCH 1084/1764] GPU: Implement TPC timebin cut.

---
 .../Global/GPUChainTrackingClusterizer.cxx    |  14 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     | 307 +++++++++---------
 .../TPCClusterFinder/GPUTPCCFDecodeZS.h       |  27 +-
 GPU/GPUTracking/kernels.cmake                 |   6 +-
 4 files changed, 185 insertions(+), 169 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 5426f0eafdad6..7b0c54cda5cb1 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -588,7 +588,8 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     return ForwardTPCDigits();
   }
 #ifdef GPUCA_TPC_GEOMETRY_O2
-  [[maybe_unused]] int32_t tpcTimeBinCut = (mUpdateNewCalibObjects && mNewCalibValues->newTPCTimeBinCut) ? mNewCalibValues->tpcTimeBinCut : param().tpcCutTimeBin; // TODO: Implement time bin cut fultering
+  int32_t tpcTimeBinCut = (mUpdateNewCalibObjects && mNewCalibValues->newTPCTimeBinCut) ? mNewCalibValues->tpcTimeBinCut : param().tpcCutTimeBin;
+
   mRec->PushNonPersistentMemory(qStr2Tag("TPCCLUST"));
   const auto& threadContext = GetThreadContext();
   const bool doGPU = GetRecoStepsGPU() & RecoStep::TPCClusterFinding;
@@ -911,13 +912,13 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
               break;
             case ZSVersionRowBased10BitADC:
             case ZSVersionRowBased12BitADC:
-              runKernel<GPUTPCCFDecodeZS>({GetGridBlk(nBlocks, lane), {iSector}}, firstHBF);
+              runKernel<GPUTPCCFDecodeZS>({GetGridBlk(nBlocks, lane), {iSector}}, firstHBF, tpcTimeBinCut);
               break;
             case ZSVersionLinkBasedWithMeta:
-              runKernel<GPUTPCCFDecodeZSLink>({GetGridBlk(nBlocks, lane), {iSector}}, firstHBF);
+              runKernel<GPUTPCCFDecodeZSLink>({GetGridBlk(nBlocks, lane), {iSector}}, firstHBF, tpcTimeBinCut);
               break;
             case ZSVersionDenseLinkBased:
-              runKernel<GPUTPCCFDecodeZSDenseLink>({GetGridBlk(nBlocks, lane), {iSector}}, firstHBF);
+              runKernel<GPUTPCCFDecodeZSDenseLink>({GetGridBlk(nBlocks, lane), {iSector}}, firstHBF, tpcTimeBinCut);
               break;
           }
           TransferMemoryResourceLinkToHost(RecoStep::TPCClusterFinding, clusterer.mMemoryId, lane);
@@ -1273,6 +1274,11 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
     mTriggerBuffer->triggers.clear();
   }
 
+  // Number of clusters is logged by tracking. This ensures clusters are still printed if it's not running
+  if (!(GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking)) {
+    GPUInfo("Event has %zu TPC Clusters", nClsTotal);
+  }
+
   ClusterNativeAccess::ConstMCLabelContainerView* mcLabelsConstView = nullptr;
   if (propagateMCLabels) {
     // TODO: write to buffer directly
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index 54af72f08a432..7ba32bd43275b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -36,12 +36,12 @@ using namespace o2::tpc::constants;
 // ===========================================================================
 
 template <>
-GPUdii() void GPUTPCCFDecodeZS::Thread<GPUTPCCFDecodeZS::decodeZS>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF)
+GPUdii() void GPUTPCCFDecodeZS::Thread<GPUTPCCFDecodeZS::decodeZS>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF, int32_t tpcTimeBinCut)
 {
-  GPUTPCCFDecodeZS::decode(clusterer, smem, nBlocks, nThreads, iBlock, iThread, firstHBF);
+  GPUTPCCFDecodeZS::decode(clusterer, smem, nBlocks, nThreads, iBlock, iThread, firstHBF, tpcTimeBinCut);
 }
 
-GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUSharedMemory& s, int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t firstHBF)
+GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUSharedMemory& s, int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t firstHBF, int32_t tpcTimeBinCut)
 {
   const uint32_t sector = clusterer.mISector;
 #ifdef GPUCA_GPUCODE
@@ -173,12 +173,14 @@ GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUShared
                   }
                   const CfFragment& fragment = clusterer.mPmemory->fragment;
                   TPCTime globalTime = timeBin + l;
-                  bool inFragment = fragment.contains(globalTime);
+                  bool discardTimeBin = not fragment.contains(globalTime);
+                  discardTimeBin |= (tpcTimeBinCut > 0 && globalTime > tpcTimeBinCut);
+
                   Row row = rowOffset + m;
-                  CfChargePos pos(row, Pad(pad), inFragment ? fragment.toLocal(globalTime) : INVALID_TIME_BIN);
+                  CfChargePos pos(row, Pad(pad), discardTimeBin ? INVALID_TIME_BIN : fragment.toLocal(globalTime));
                   positions[nDigitsTmp++] = pos;
 
-                  if (inFragment) {
+                  if (!discardTimeBin) {
                     float q = float(byte & mask) * decodeBitsFactor;
                     q *= clusterer.GetConstantMem()->calibObjects.tpcPadGain->getGainCorrection(sector, row, pad);
                     chargeMap[pos] = PackedCharge(q);
@@ -209,71 +211,69 @@ GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUShared
 // ===========================================================================
 
 template <>
-GPUdii() void GPUTPCCFDecodeZSLink::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF)
+GPUdii() void GPUTPCCFDecodeZSLink::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF, int32_t tpcTimeBinCut)
 {
-  Decode<GPUTPCCFDecodeZSLink>(nBlocks, nThreads, iBlock, iThread, smem, clusterer, firstHBF);
+  Decode<GPUTPCCFDecodeZSLink>(nBlocks, nThreads, iBlock, iThread, smem, clusterer, firstHBF, tpcTimeBinCut);
 }
 
-GPUd() size_t GPUTPCCFDecodeZSLink::DecodePage(GPUSharedMemory& smem, processorType& clusterer, int32_t iBlock, int32_t nThreads, int32_t iThread, const uint8_t* page, uint32_t pageDigitOffset, int32_t firstHBF)
+GPUd() size_t GPUTPCCFDecodeZSLink::DecodePage(GPUSharedMemory& smem, DecodeCtx& ctx)
 {
-  const CfFragment& fragment = clusterer.mPmemory->fragment;
+  const CfFragment& fragment = ctx.clusterer.mPmemory->fragment;
 
-  const auto* rdHdr = ConsumeHeader<header::RAWDataHeader>(page);
+  const auto* rdHdr = ConsumeHeader<header::RAWDataHeader>(ctx.page);
 
   if (o2::raw::RDHUtils::getMemorySize(*rdHdr) == sizeof(o2::header::RAWDataHeader)) {
-    return pageDigitOffset;
+    return ctx.pageDigitOffset;
   }
 
   [[maybe_unused]] int32_t nDecoded = 0;
-  const auto* decHdr = ConsumeHeader<TPCZSHDRV2>(page);
-  ConsumeBytes(page, decHdr->firstZSDataOffset * 16);
+  const auto* decHdr = ConsumeHeader<TPCZSHDRV2>(ctx.page);
+  ConsumeBytes(ctx.page, decHdr->firstZSDataOffset * 16);
 
   assert(decHdr->version == ZSVersionLinkBasedWithMeta);
   assert(decHdr->magicWord == o2::tpc::zerosupp_link_based::CommonHeader::MagicWordLinkZSMetaHeader);
 
   for (uint32_t t = 0; t < decHdr->nTimebinHeaders; t++) {
-    const auto* tbHdr = ConsumeHeader<zerosupp_link_based::CommonHeader>(page);
-    const auto* adcData = ConsumeBytes(page, tbHdr->numWordsPayload * 16); // Page now points to next timebin or past the page
+    const auto* tbHdr = ConsumeHeader<zerosupp_link_based::CommonHeader>(ctx.page);
+    const auto* adcData = ConsumeBytes(ctx.page, tbHdr->numWordsPayload * 16); // Page now points to next timebin or past the page
 
-    int32_t timeBin = (decHdr->timeOffset + tbHdr->bunchCrossing + (uint64_t)(o2::raw::RDHUtils::getHeartBeatOrbit(*rdHdr) - firstHBF) * o2::constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
+    int32_t timeBin = (decHdr->timeOffset + tbHdr->bunchCrossing + (uint64_t)(o2::raw::RDHUtils::getHeartBeatOrbit(*rdHdr) - ctx.firstHBF) * o2::constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
 
     uint32_t channelMask[3];
     GetChannelBitmask(*tbHdr, channelMask);
     uint32_t nAdc = CAMath::Popcount(channelMask[0]) + CAMath::Popcount(channelMask[1]) + CAMath::Popcount(channelMask[2]);
 
-    bool inFragment = fragment.contains(timeBin);
     nDecoded += nAdc;
 
-    // TimeBin not in fragment: Skip this timebin header and fill positions with dummy values instead
-    if (not inFragment) {
-      pageDigitOffset += FillWithInvalid(clusterer, iThread, nThreads, pageDigitOffset, nAdc);
-      continue;
-    }
+    bool discardTimeBin = not fragment.contains(timeBin);
+    discardTimeBin |= (ctx.tpcTimeBinCut > 0 && timeBin > ctx.tpcTimeBinCut);
 
+    if (discardTimeBin) {
+      FillWithInvalid(ctx.clusterer, ctx.iThread, ctx.nThreads, ctx.pageDigitOffset, nAdc);
+    } else {
 #ifdef GPUCA_GPUCODE
-    DecodeTBMultiThread(
-      clusterer,
-      iThread,
-      smem,
-      adcData,
-      nAdc,
-      channelMask,
-      timeBin,
-      decHdr->cruID,
-      tbHdr->fecInPartition,
-      pageDigitOffset);
+      DecodeTBMultiThread(
+        smem,
+        ctx,
+        adcData,
+        nAdc,
+        channelMask,
+        timeBin,
+        decHdr->cruID,
+        tbHdr->fecInPartition);
 #else // CPU
-    DecodeTBSingleThread(
-      clusterer,
-      adcData,
-      nAdc,
-      channelMask,
-      timeBin,
-      decHdr->cruID,
-      tbHdr->fecInPartition,
-      pageDigitOffset);
+      DecodeTBSingleThread(
+        ctx,
+        adcData,
+        nAdc,
+        channelMask,
+        timeBin,
+        decHdr->cruID,
+        tbHdr->fecInPartition);
 #endif
-    pageDigitOffset += nAdc;
+    }
+
+    ctx.pageDigitOffset += nAdc;
   } // for (uint32_t t = 0; t < decHdr->nTimebinHeaders; t++)
 
 #ifdef GPUCA_CHECK_TPCZS_CORRUPTION
@@ -286,20 +286,20 @@ GPUd() size_t GPUTPCCFDecodeZSLink::DecodePage(GPUSharedMemory& smem, processorT
     #endif*/
   }
 #endif
-  return pageDigitOffset;
+
+  return ctx.pageDigitOffset;
 }
 
 GPUd() void GPUTPCCFDecodeZSLink::DecodeTBSingleThread(
-  processorType& clusterer,
+  DecodeCtx& ctx,
   const uint8_t* adcData,
   uint32_t nAdc,
   const uint32_t* channelMask,
   int32_t timeBin,
   int32_t cru,
-  int32_t fecInPartition,
-  uint32_t pageDigitOffset)
+  int32_t fecInPartition)
 {
-  const CfFragment& fragment = clusterer.mPmemory->fragment;
+  const CfFragment& fragment = ctx.clusterer.mPmemory->fragment;
 
   if constexpr (TPCZSHDRV2::TIGHTLY_PACKED_V3) {
 
@@ -317,9 +317,9 @@ GPUd() void GPUTPCCFDecodeZSLink::DecodeTBSingleThread(
         }
 
         // Unpack data for cluster finder
-        o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(clusterer, cru, rawFECChannel, fecInPartition);
+        o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(ctx.clusterer, cru, rawFECChannel, fecInPartition);
 
-        WriteCharge(clusterer, byte, padAndRow, fragment.toLocal(timeBin), pageDigitOffset + nSamplesWritten);
+        WriteCharge(ctx.clusterer, byte, padAndRow, fragment.toLocal(timeBin), ctx.pageDigitOffset + nSamplesWritten);
 
         byte = byte >> DECODE_BITS;
         bits -= DECODE_BITS;
@@ -337,31 +337,29 @@ GPUd() void GPUTPCCFDecodeZSLink::DecodeTBSingleThread(
 
       uint32_t adc = (adcData64[j / TPCZSHDRV2::SAMPLESPER64BIT] >> ((j % TPCZSHDRV2::SAMPLESPER64BIT) * DECODE_BITS)) & DECODE_MASK;
 
-      o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(clusterer, cru, rawFECChannel, fecInPartition);
+      o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(ctx.clusterer, cru, rawFECChannel, fecInPartition);
       float charge = ADCToFloat(adc, DECODE_MASK, DECODE_BITS_FACTOR);
-      WriteCharge(clusterer, charge, padAndRow, fragment.toLocal(timeBin), pageDigitOffset + j);
+      WriteCharge(ctx.clusterer, charge, padAndRow, fragment.toLocal(timeBin), ctx.pageDigitOffset + j);
       rawFECChannel++;
     }
   }
 }
 
 GPUd() void GPUTPCCFDecodeZSLink::DecodeTBMultiThread(
-  processorType& clusterer,
-  int32_t iThread,
   GPUSharedMemory& smem,
+  DecodeCtx& ctx,
   const uint8_t* adcData,
   uint32_t nAdc,
   const uint32_t* channelMask,
   int32_t timeBin,
   int32_t cru,
-  int32_t fecInPartition,
-  uint32_t pageDigitOffset)
+  int32_t fecInPartition)
 {
   constexpr int32_t NTHREADS = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFDecodeZSLink);
   static_assert(NTHREADS == GPUCA_WARP_SIZE, "Decoding TB Headers in parallel assumes block size is a single warp.");
 
   uint8_t blockOffset = 0;
-  for (uint8_t i = iThread; blockOffset < nAdc; i += NTHREADS) {
+  for (uint8_t i = ctx.iThread; blockOffset < nAdc; i += NTHREADS) {
 
     uint8_t rawFECChannel = i;
 
@@ -429,10 +427,10 @@ GPUd() void GPUTPCCFDecodeZSLink::DecodeTBMultiThread(
       adc = (adcData64[myOffset / TPCZSHDRV2::SAMPLESPER64BIT] >> ((myOffset % TPCZSHDRV2::SAMPLESPER64BIT) * DECODE_BITS)) & DECODE_MASK;
     }
 
-    o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(clusterer, cru, rawFECChannel, fecInPartition);
-    const CfFragment& fragment = clusterer.mPmemory->fragment;
+    o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(ctx.clusterer, cru, rawFECChannel, fecInPartition);
+    const CfFragment& fragment = ctx.clusterer.mPmemory->fragment;
     float charge = ADCToFloat(adc, DECODE_MASK, DECODE_BITS_FACTOR);
-    WriteCharge(clusterer, charge, padAndRow, fragment.toLocal(timeBin), pageDigitOffset + myOffset);
+    WriteCharge(ctx.clusterer, charge, padAndRow, fragment.toLocal(timeBin), ctx.pageDigitOffset + myOffset);
 
   } // for (uint8_t i = iThread; blockOffset < nAdc; i += NThreads)
 }
@@ -462,7 +460,7 @@ GPUd() bool GPUTPCCFDecodeZSLink::ChannelIsActive(const uint32_t* chan, uint8_t
 // ===========================================================================
 
 template <class Decoder>
-GPUd() void GPUTPCCFDecodeZSLinkBase::Decode(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, typename Decoder::GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF)
+GPUd() void GPUTPCCFDecodeZSLinkBase::Decode(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, typename Decoder::GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF, int32_t tpcTimeBinCut)
 {
   const uint32_t sector = clusterer.mISector;
 
@@ -507,7 +505,18 @@ GPUd() void GPUTPCCFDecodeZSLinkBase::Decode(int32_t nBlocks, int32_t nThreads,
 #endif
       }
 
-      pageDigitOffset = Decoder::DecodePage(smem, clusterer, iBlock, nThreads, iThread, page, pageDigitOffset, firstHBF);
+      DecodeCtx ctx{
+        .clusterer = clusterer,
+        .page = page,
+        .iBlock = iBlock,
+        .nThreads = nThreads,
+        .iThread = iThread,
+        .pageDigitOffset = pageDigitOffset,
+        .firstHBF = firstHBF,
+        .tpcTimeBinCut = tpcTimeBinCut,
+      };
+
+      pageDigitOffset = Decoder::DecodePage(smem, ctx);
     } // [CPU] for (uint32_t j = minJ; j < maxJ; j++)
   } // [CPU] for (uint32_t i = clusterer.mMinMaxCN[endpoint].zsPtrFirst; i < clusterer.mMinMaxCN[endpoint].zsPtrLast; i++)
 
@@ -585,12 +594,12 @@ GPUd() uint16_t GPUTPCCFDecodeZSLinkBase::FillWithInvalid(processorType& cluster
 // ===========================================================================
 
 template <>
-GPUd() void GPUTPCCFDecodeZSDenseLink::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF)
+GPUd() void GPUTPCCFDecodeZSDenseLink::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF, int32_t tpcTimeBinCut)
 {
-  Decode<GPUTPCCFDecodeZSDenseLink>(nBlocks, nThreads, iBlock, iThread, smem, clusterer, firstHBF);
+  Decode<GPUTPCCFDecodeZSDenseLink>(nBlocks, nThreads, iBlock, iThread, smem, clusterer, firstHBF, tpcTimeBinCut);
 }
 
-GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, processorType& clusterer, int32_t iBlock, int32_t nThreads, int32_t iThread, const uint8_t* page, uint32_t pageDigitOffset, int32_t firstHBF)
+GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, DecodeCtx& ctx)
 {
 #ifdef GPUCA_GPUCODE
   constexpr bool DecodeInParallel = true;
@@ -598,11 +607,11 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
   constexpr bool DecodeInParallel = false;
 #endif
 
-  const uint8_t* const pageStart = page;
+  const uint8_t* const pageStart = ctx.page;
 
-  const auto* rawDataHeader = Peek<header::RAWDataHeader>(page);
-  const auto* decHeader = Peek<TPCZSHDRV2>(page, raw::RDHUtils::getMemorySize(*rawDataHeader) - sizeof(TPCZSHDRV2));
-  ConsumeHeader<header::RAWDataHeader>(page);
+  const auto* rawDataHeader = Peek<header::RAWDataHeader>(ctx.page);
+  const auto* decHeader = Peek<TPCZSHDRV2>(ctx.page, raw::RDHUtils::getMemorySize(*rawDataHeader) - sizeof(TPCZSHDRV2));
+  ConsumeHeader<header::RAWDataHeader>(ctx.page);
 
   uint16_t nSamplesWritten = 0;
   const uint16_t nSamplesInPage = decHeader->nADCsamples;
@@ -612,7 +621,7 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
 
   const bool extendsToNextPage = decHeader->flags & TPCZSHDRV2::ZSFlags::payloadExtendsToNextPage;
 
-  ConsumeBytes(page, decHeader->firstZSDataOffset - sizeof(o2::header::RAWDataHeader));
+  ConsumeBytes(ctx.page, decHeader->firstZSDataOffset - sizeof(o2::header::RAWDataHeader));
 
   int err = GPUErrors::ERROR_NONE;
 
@@ -626,7 +635,7 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
 
   for (uint16_t i = 0; i < decHeader->nTimebinHeaders && !err; i++) {
 
-    ptrdiff_t sizeLeftInPage = payloadEnd - page;
+    ptrdiff_t sizeLeftInPage = payloadEnd - ctx.page;
     if (sizeLeftInPage <= 0) {
       err = GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;
       break;
@@ -642,13 +651,13 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
       }
 
       if ((uint16_t)(raw::RDHUtils::getPageCounter(rawDataHeader) + 1) == raw::RDHUtils::getPageCounter(nextPage)) {
-        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
+        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(smem, ctx, rawDataHeader, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
       } else {
         err = GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF;
         break;
       }
     } else {
-      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
+      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(smem, ctx, rawDataHeader, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
     }
 
     // Abort decoding the page if an error was detected.
@@ -658,33 +667,33 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
     }
 
     nSamplesWritten += nSamplesWrittenTB;
-    pageDigitOffset += nSamplesWrittenTB;
+    ctx.pageDigitOffset += nSamplesWrittenTB;
   } // for (uint16_t i = 0; i < decHeader->nTimebinHeaders; i++)
 
   if (nSamplesWritten != nSamplesInPage) {
     if (nSamplesWritten < nSamplesInPage) {
-      pageDigitOffset += FillWithInvalid(clusterer, iThread, nThreads, pageDigitOffset, nSamplesInPage - nSamplesWritten);
+      ctx.pageDigitOffset += FillWithInvalid(ctx.clusterer, ctx.iThread, ctx.nThreads, ctx.pageDigitOffset, nSamplesInPage - nSamplesWritten);
     }
     err = !err ? GPUErrors::ERROR_TPCZS_INVALID_NADC : err; // Ensure we don't overwrite any previous error
   }
 
-  if (iThread == 0 && err) {
+  if (ctx.iThread == 0 && err) {
     [[maybe_unused]] bool dumpPage = false;
 
     if (err == GPUErrors::ERROR_TPCZS_VERSION_MISMATCH) {
-      clusterer.raiseError(err, decHeader->version, ZSVersionDenseLinkBased);
+      ctx.clusterer.raiseError(err, decHeader->version, ZSVersionDenseLinkBased);
     } else if (err == GPUErrors::ERROR_TPCZS_INVALID_MAGIC_WORD) {
-      clusterer.raiseError(err, decHeader->magicWord);
+      ctx.clusterer.raiseError(err, decHeader->magicWord);
     } else if (err == GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF) {
-      clusterer.raiseError(err, clusterer.mISector * 1000 + decHeader->cruID, raw::RDHUtils::getPageCounter(rawDataHeader), raw::RDHUtils::getPageCounter(nextPage));
+      ctx.clusterer.raiseError(err, ctx.clusterer.mISector * 1000 + decHeader->cruID, raw::RDHUtils::getPageCounter(rawDataHeader), raw::RDHUtils::getPageCounter(nextPage));
     } else if (err == GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW) {
-      clusterer.raiseError(err, extendsToNextPage);
+      ctx.clusterer.raiseError(err, extendsToNextPage);
       dumpPage = true;
     } else if (err == GPUErrors::ERROR_TPCZS_INVALID_NADC) {
-      clusterer.raiseError(err, nSamplesInPage, nSamplesWritten, extendsToNextPage);
+      ctx.clusterer.raiseError(err, nSamplesInPage, nSamplesWritten, extendsToNextPage);
       dumpPage = true;
     } else {
-      clusterer.raiseError(GPUErrors::ERROR_TPCZS_UNKNOWN, err);
+      ctx.clusterer.raiseError(GPUErrors::ERROR_TPCZS_UNKNOWN, err);
     }
 
 #ifdef GPUCA_CHECK_TPCZS_CORRUPTION
@@ -700,18 +709,14 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, pro
 #endif
   }
 
-  return pageDigitOffset;
+  return ctx.pageDigitOffset;
 }
 
 template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
 GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
-  processorType& clusterer,
   [[maybe_unused]] GPUSharedMemory& smem,
-  int32_t iThread,
-  const uint8_t*& page,
-  uint32_t pageDigitOffset,
+  DecodeCtx& ctx,
   const header::RAWDataHeader* rawDataHeader,
-  int32_t firstHBF,
   int32_t cru,
   uint16_t nSamplesLeftInPage,
   const uint8_t* payloadEnd,
@@ -719,11 +724,11 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
 {
 
   if constexpr (DecodeInParallel) {
-    return DecodeTBMultiThread<PayloadExtendsToNextPage>(clusterer, smem, iThread, page, pageDigitOffset, rawDataHeader, firstHBF, cru, nSamplesLeftInPage, payloadEnd, nextPage);
+    return DecodeTBMultiThread<PayloadExtendsToNextPage>(smem, ctx, rawDataHeader, cru, nSamplesLeftInPage, payloadEnd, nextPage);
   } else {
     int16_t nSamplesWritten = 0;
-    if (iThread == 0) {
-      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(clusterer, page, pageDigitOffset, rawDataHeader, firstHBF, cru, nSamplesLeftInPage, payloadEnd, nextPage);
+    if (ctx.iThread == 0) {
+      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(ctx, rawDataHeader, cru, nSamplesLeftInPage, payloadEnd, nextPage);
     }
     return warp_broadcast(nSamplesWritten, 0);
   }
@@ -731,13 +736,9 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
 
 template <bool PayloadExtendsToNextPage>
 GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
-  processorType& clusterer,
   GPUSharedMemory& smem,
-  const int32_t iThread,
-  const uint8_t*& page,
-  uint32_t pageDigitOffset,
+  DecodeCtx& ctx,
   const header::RAWDataHeader* rawDataHeader,
-  int32_t firstHBF,
   int32_t cru,
   uint16_t nSamplesLeftInPage,
   const uint8_t* payloadEnd,
@@ -766,45 +767,45 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
   constexpr int32_t NTHREADS = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFDecodeZSDenseLink);
   static_assert(NTHREADS == GPUCA_WARP_SIZE, "Decoding TB Headers in parallel assumes block size is a single warp.");
 
-  const CfFragment& fragment = clusterer.mPmemory->fragment;
+  const CfFragment& fragment = ctx.clusterer.mPmemory->fragment;
 
   // Read timebin block header
-  uint16_t tbbHdr = ConsumeByte(page);
-  MAYBE_PAGE_OVERFLOW(page);
-  tbbHdr |= static_cast<uint16_t>(ConsumeByte(page)) << CHAR_BIT;
-  MAYBE_PAGE_OVERFLOW(page);
+  uint16_t tbbHdr = ConsumeByte(ctx.page);
+  MAYBE_PAGE_OVERFLOW(ctx.page);
+  tbbHdr |= static_cast<uint16_t>(ConsumeByte(ctx.page)) << CHAR_BIT;
+  MAYBE_PAGE_OVERFLOW(ctx.page);
 
   uint8_t nLinksInTimebin = tbbHdr & 0x000F;
   uint16_t linkBC = (tbbHdr & 0xFFF0) >> 4;
-  int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
+  int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - ctx.firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
 
   int16_t nSamplesInTB = 0;
 
   // Read timebin link headers
   for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++) {
-    uint8_t timebinLinkHeaderStart = ConsumeByte(page);
-    MAYBE_PAGE_OVERFLOW(page);
+    uint8_t timebinLinkHeaderStart = ConsumeByte(ctx.page);
+    MAYBE_PAGE_OVERFLOW(ctx.page);
 
-    if (iThread == 0) {
+    if (ctx.iThread == 0) {
       smem.linkIds[iLink] = timebinLinkHeaderStart & 0b00011111;
     }
     bool bitmaskIsFlat = timebinLinkHeaderStart & 0b00100000;
 
     uint16_t bitmaskL2 = 0x03FF;
     if (not bitmaskIsFlat) {
-      bitmaskL2 = static_cast<uint16_t>(timebinLinkHeaderStart & 0b11000000) << 2 | static_cast<uint16_t>(ConsumeByte(page));
-      MAYBE_PAGE_OVERFLOW(page);
+      bitmaskL2 = static_cast<uint16_t>(timebinLinkHeaderStart & 0b11000000) << 2 | static_cast<uint16_t>(ConsumeByte(ctx.page));
+      MAYBE_PAGE_OVERFLOW(ctx.page);
     }
 
     int32_t nBytesBitmask = CAMath::Popcount(bitmaskL2);
 
-    for (int32_t chan = iThread; chan < CAMath::nextMultipleOf<NTHREADS>(80); chan += NTHREADS) {
+    for (int32_t chan = ctx.iThread; chan < CAMath::nextMultipleOf<NTHREADS>(80); chan += NTHREADS) {
       int32_t chanL2Idx = chan / 8;
       bool l2 = TEST_BIT(bitmaskL2, chanL2Idx);
 
       int32_t chanByteOffset = nBytesBitmask - 1 - CAMath::Popcount(bitmaskL2 >> (chanL2Idx + 1));
 
-      uint8_t myChannelHasData = (chan < 80 && l2 ? TEST_BIT(PEEK_OVERFLOW(page, chanByteOffset), chan % 8) : 0);
+      uint8_t myChannelHasData = (chan < 80 && l2 ? TEST_BIT(PEEK_OVERFLOW(ctx.page, chanByteOffset), chan % 8) : 0);
 
       int32_t nSamplesStep;
       int32_t threadSampleOffset = CfUtils::warpPredicateScan(myChannelHasData, &nSamplesStep);
@@ -816,10 +817,10 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
       nSamplesInTB += nSamplesStep;
     }
 
-    ConsumeBytes(page, nBytesBitmask);
-    MAYBE_PAGE_OVERFLOW(page);
+    ConsumeBytes(ctx.page, nBytesBitmask);
+    MAYBE_PAGE_OVERFLOW(ctx.page);
 
-    if (iThread == 0) {
+    if (ctx.iThread == 0) {
       smem.samplesPerLinkEnd[iLink] = nSamplesInTB;
     }
 
@@ -833,31 +834,31 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
   // This needs to happen BEFORE checking if the timebin is in fragment
   // to ensure ADC bytes are always consumed, even if data isn't decoded
-  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
-  MAYBE_PAGE_OVERFLOW(page);
+  const uint8_t* adcData = ConsumeBytes(ctx.page, (nSamplesInTB * DECODE_BITS + 7) / 8);
+  MAYBE_PAGE_OVERFLOW(ctx.page);
 
-  if (not fragment.contains(timeBin)) {
-    return FillWithInvalid(clusterer, iThread, NTHREADS, pageDigitOffset, nSamplesInTB);
+  bool discardTimeBin = not fragment.contains(timeBin);
+  discardTimeBin |= (ctx.tpcTimeBinCut > 0 && timeBin > ctx.tpcTimeBinCut);
+
+  if (discardTimeBin) {
+    return FillWithInvalid(ctx.clusterer, ctx.iThread, NTHREADS, ctx.pageDigitOffset, nSamplesInTB);
   }
 
   // Unpack ADC
   int32_t iLink = 0;
-  for (uint16_t sample = iThread; sample < nSamplesInTB; sample += NTHREADS) {
+  for (uint16_t sample = ctx.iThread; sample < nSamplesInTB; sample += NTHREADS) {
     const uint16_t adcBitOffset = sample * DECODE_BITS;
     uint16_t adcByteOffset = adcBitOffset / CHAR_BIT;
     const uint8_t adcOffsetInByte = adcBitOffset - adcByteOffset * CHAR_BIT;
 
-    uint8_t bits = 0;
-    uint16_t byte = 0;
-
     static_assert(DECODE_BITS <= sizeof(uint16_t) * CHAR_BIT);
 
-    while (bits < DECODE_BITS) {
-      byte |= static_cast<uint16_t>(PEEK_OVERFLOW(adcData, adcByteOffset)) << bits;
+    uint16_t adc = 0;
+    for (uint8_t bits = 0; bits < DECODE_BITS; bits += CHAR_BIT) {
+      adc |= static_cast<uint16_t>(PEEK_OVERFLOW(adcData, adcByteOffset)) << bits;
       adcByteOffset++;
-      bits += CHAR_BIT;
     }
-    byte >>= adcOffsetInByte;
+    adc >>= adcOffsetInByte;
 
     while (smem.samplesPerLinkEnd[iLink] <= sample) {
       iLink++;
@@ -866,10 +867,10 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
     int32_t rawFECChannelLink = smem.rawFECChannels[sample];
 
     // Unpack data for cluster finder
-    o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(clusterer, cru, rawFECChannelLink, smem.linkIds[iLink]);
+    o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(ctx.clusterer, cru, rawFECChannelLink, smem.linkIds[iLink]);
 
-    float charge = ADCToFloat(byte, DECODE_MASK, DECODE_BITS_FACTOR);
-    WriteCharge(clusterer, charge, padAndRow, fragment.toLocal(timeBin), pageDigitOffset + sample);
+    float charge = ADCToFloat(adc, DECODE_MASK, DECODE_BITS_FACTOR);
+    WriteCharge(ctx.clusterer, charge, padAndRow, fragment.toLocal(timeBin), ctx.pageDigitOffset + sample);
 
   } // for (uint16_t sample = iThread; sample < nSamplesInTB; sample += NTHREADS)
 
@@ -884,15 +885,12 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 
 template <bool PayloadExtendsToNextPage>
 GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
-  processorType& clusterer,
-  const uint8_t*& page,
-  uint32_t pageDigitOffset,
+  DecodeCtx& ctx,
   const header::RAWDataHeader* rawDataHeader,
-  int32_t firstHBF,
   int32_t cru,
   uint16_t nSamplesLeftInPage,
-  [[maybe_unused]] const uint8_t* payloadEnd,
-  [[maybe_unused]] const uint8_t* nextPage)
+  const uint8_t* payloadEnd,
+  const uint8_t* nextPage)
 {
 #define MAYBE_PAGE_OVERFLOW(pagePtr)                               \
   if constexpr (PayloadExtendsToNextPage) {                        \
@@ -909,28 +907,28 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
 
   using zerosupp_link_based::ChannelPerTBHeader;
 
-  const CfFragment& fragment = clusterer.mPmemory->fragment;
+  const CfFragment& fragment = ctx.clusterer.mPmemory->fragment;
 
   uint8_t linkIds[MaxNLinksPerTimebin];
   uint8_t channelMasks[MaxNLinksPerTimebin * 10] = {0};
   uint16_t nSamplesWritten = 0;
 
   // Read timebin block header
-  uint16_t tbbHdr = ConsumeByte(page);
-  MAYBE_PAGE_OVERFLOW(page);
-  tbbHdr |= static_cast<uint16_t>(ConsumeByte(page)) << CHAR_BIT;
-  MAYBE_PAGE_OVERFLOW(page);
+  uint16_t tbbHdr = ConsumeByte(ctx.page);
+  MAYBE_PAGE_OVERFLOW(ctx.page);
+  tbbHdr |= static_cast<uint16_t>(ConsumeByte(ctx.page)) << CHAR_BIT;
+  MAYBE_PAGE_OVERFLOW(ctx.page);
 
   uint8_t nLinksInTimebin = tbbHdr & 0x000F;
   uint16_t linkBC = (tbbHdr & 0xFFF0) >> 4;
-  int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
+  int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - ctx.firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
 
   uint16_t nSamplesInTB = 0;
 
   // Read timebin link headers
   for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++) {
-    uint8_t timebinLinkHeaderStart = ConsumeByte(page);
-    MAYBE_PAGE_OVERFLOW(page);
+    uint8_t timebinLinkHeaderStart = ConsumeByte(ctx.page);
+    MAYBE_PAGE_OVERFLOW(ctx.page);
 
     linkIds[iLink] = timebinLinkHeaderStart & 0b00011111;
 
@@ -938,15 +936,15 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
 
     uint16_t bitmaskL2 = 0x0FFF;
     if (not bitmaskIsFlat) {
-      bitmaskL2 = static_cast<uint16_t>(timebinLinkHeaderStart & 0b11000000) << 2 | static_cast<uint16_t>(ConsumeByte(page));
-      MAYBE_PAGE_OVERFLOW(page);
+      bitmaskL2 = static_cast<uint16_t>(timebinLinkHeaderStart & 0b11000000) << 2 | static_cast<uint16_t>(ConsumeByte(ctx.page));
+      MAYBE_PAGE_OVERFLOW(ctx.page);
     }
 
     for (int32_t i = 0; i < 10; i++) {
       if (bitmaskL2 & 1 << i) {
-        nSamplesInTB += CAMath::Popcount(*Peek(page));
-        channelMasks[10 * iLink + i] = ConsumeByte(page);
-        MAYBE_PAGE_OVERFLOW(page);
+        nSamplesInTB += CAMath::Popcount(*Peek(ctx.page));
+        channelMasks[10 * iLink + i] = ConsumeByte(ctx.page);
+        MAYBE_PAGE_OVERFLOW(ctx.page);
       }
     }
 
@@ -956,11 +954,14 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
     return -GPUErrors::ERROR_TPCZS_INVALID_NADC;
   }
 
-  const uint8_t* adcData = ConsumeBytes(page, (nSamplesInTB * DECODE_BITS + 7) / 8);
-  MAYBE_PAGE_OVERFLOW(page);
+  const uint8_t* adcData = ConsumeBytes(ctx.page, (nSamplesInTB * DECODE_BITS + 7) / 8);
+  MAYBE_PAGE_OVERFLOW(ctx.page);
+
+  bool discardTimeBin = not fragment.contains(timeBin);
+  discardTimeBin |= (ctx.tpcTimeBinCut > 0 && timeBin > ctx.tpcTimeBinCut);
 
-  if (not fragment.contains(timeBin)) {
-    return FillWithInvalid(clusterer, 0, 1, pageDigitOffset, nSamplesInTB);
+  if (discardTimeBin) {
+    return FillWithInvalid(ctx.clusterer, 0, 1, ctx.pageDigitOffset, nSamplesInTB);
   }
 
   // Unpack ADC
@@ -982,10 +983,10 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
       int32_t rawFECChannelLink = rawFECChannel % ChannelPerTBHeader;
 
       // Unpack data for cluster finder
-      o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(clusterer, cru, rawFECChannelLink, linkIds[iLink]);
+      o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(ctx.clusterer, cru, rawFECChannelLink, linkIds[iLink]);
 
       float charge = ADCToFloat(byte, DECODE_MASK, DECODE_BITS_FACTOR);
-      WriteCharge(clusterer, charge, padAndRow, fragment.toLocal(timeBin), pageDigitOffset + nSamplesWritten);
+      WriteCharge(ctx.clusterer, charge, padAndRow, fragment.toLocal(timeBin), ctx.pageDigitOffset + nSamplesWritten);
 
       byte >>= DECODE_BITS;
       bits -= DECODE_BITS;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
index 4697462a8c504..750df643f2d10 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
@@ -45,7 +45,7 @@ class GPUTPCCFDecodeZS : public GPUKernelTemplate
     decodeZS,
   };
 
-  static GPUd() void decode(GPUTPCClusterFinder& clusterer, GPUSharedMemory& s, int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t firstHBF);
+  static GPUd() void decode(GPUTPCClusterFinder& clusterer, GPUSharedMemory& s, int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t firstHBF, int32_t tpcTimeBinCut);
 
   typedef GPUTPCClusterFinder processorType;
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
@@ -77,8 +77,17 @@ class GPUTPCCFDecodeZSLinkBase : public GPUKernelTemplate
     return GPUDataTypes::RecoStep::TPCClusterFinding;
   }
 
+  struct DecodeCtx {
+    processorType& clusterer;
+    const uint8_t* page;
+    int32_t iBlock, nThreads, iThread;
+    uint32_t pageDigitOffset;
+    int32_t firstHBF;
+    int32_t tpcTimeBinCut;
+  };
+
   template <class Decoder>
-  GPUd() static void Decode(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, typename Decoder::GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF);
+  GPUd() static void Decode(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, typename Decoder::GPUSharedMemory& smem, processorType& clusterer, int32_t firstHBF, int32_t tpcTimeBinCut);
 
   GPUd() static o2::tpc::PadPos GetPadAndRowFromFEC(processorType& clusterer, int32_t cru, int32_t rawFecChannel, int32_t fecInPartition);
   GPUd() static void WriteCharge(processorType& clusterer, float charge, o2::tpc::PadPos pos, tpccf::TPCFragmentTime localTime, size_t positionOffset);
@@ -134,13 +143,13 @@ class GPUTPCCFDecodeZSLink : public GPUTPCCFDecodeZSLinkBase
   template <int32_t iKernel = defaultKernel, typename... Args>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, Args... args);
 
-  GPUd() static size_t DecodePage(GPUSharedMemory& smem, processorType& clusterer, int32_t iBlock, int32_t nThreads, int32_t iThread, const uint8_t* page, uint32_t pageDigitOffset, int32_t firstHBF);
+  GPUd() static size_t DecodePage(GPUSharedMemory& smem, DecodeCtx& ctx);
 
   GPUd() static void GetChannelBitmask(const tpc::zerosupp_link_based::CommonHeader& tbHdr, uint32_t* chan);
   GPUd() static bool ChannelIsActive(const uint32_t* chan, uint8_t chanIndex);
 
-  GPUd() static void DecodeTBSingleThread(processorType& clusterer, const uint8_t* adcData, uint32_t nAdc, const uint32_t* channelMask, int32_t timeBin, int32_t cru, int32_t fecInPartition, uint32_t pageDigitOffset);
-  GPUd() static void DecodeTBMultiThread(processorType& clusterer, int32_t iThread, GPUSharedMemory& smem, const uint8_t* adcData, uint32_t nAdc, const uint32_t* channelMask, int32_t timeBin, int32_t cru, int32_t fecInPartition, uint32_t pageDigitOffset);
+  GPUd() static void DecodeTBSingleThread(DecodeCtx& ctx, const uint8_t* adcData, uint32_t nAdc, const uint32_t* channelMask, int32_t timeBin, int32_t cru, int32_t fecInPartition);
+  GPUd() static void DecodeTBMultiThread(GPUSharedMemory& smem, DecodeCtx& ctx, const uint8_t* adcData, uint32_t nAdc, const uint32_t* channelMask, int32_t timeBin, int32_t cru, int32_t fecInPartition);
 };
 
 class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
@@ -163,7 +172,7 @@ class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
   template <int32_t iKernel = defaultKernel, typename... Args>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer, Args... args);
 
-  GPUd() static uint32_t DecodePage(GPUSharedMemory& smem, processorType& clusterer, int32_t iBlock, int32_t nThreads, int32_t iThread, const uint8_t* page, uint32_t pageDigitOffset, int32_t firstHBF);
+  GPUd() static uint32_t DecodePage(GPUSharedMemory& smem, DecodeCtx& ctx);
 
   GPUd() static bool ChannelIsActive(const uint8_t* chan, uint16_t chanIndex);
 
@@ -171,13 +180,13 @@ class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
   // Returns the number of samples decoded from the page
   // or negative value to indicate an error (no samples are written in this case)
   template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTB(processorType& clusterer, GPUSharedMemory& smem, int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTB(GPUSharedMemory& smem, DecodeCtx& ctx, const header::RAWDataHeader* rawDataHeader, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 
   template <bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTBSingleThread(processorType& clusterer, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTBSingleThread(DecodeCtx& ctx, const header::RAWDataHeader* rawDataHeader, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 
   template <bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTBMultiThread(processorType& clusterer, GPUSharedMemory& smem, const int32_t iThread, const uint8_t*& page, uint32_t pageDigitOffset, const header::RAWDataHeader* rawDataHeader, int32_t firstHBF, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTBMultiThread(GPUSharedMemory& smem, DecodeCtx& ctx, const header::RAWDataHeader* rawDataHeader, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index e7271a9affbba..4d1abe9f5b064 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -118,9 +118,9 @@ o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanUp"                      "= TPC
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanTop"                     "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t nElems)
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, scanDown"                    "= TPCCLUSTERFINDER"                                    LB int32_t iBuf uint32_t offset int32_t nElems)
 o2_gpu_add_kernel("GPUTPCCFStreamCompaction, compactDigits"               "= TPCCLUSTERFINDER"                                    LB int32_t iBuf int32_t stage CfChargePos* in CfChargePos* out)
-o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                      "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                                  "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF)
-o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS ERRORS"                               LB int32_t firstHBF)
+o2_gpu_add_kernel("GPUTPCCFDecodeZS"                                      "= TPCCLUSTERFINDER"                                    LB int32_t firstHBF int32_t tpcTimeBinCut)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSLink"                                  "GPUTPCCFDecodeZS"                                      LB int32_t firstHBF int32_t tpcTimeBinCut)
+o2_gpu_add_kernel("GPUTPCCFDecodeZSDenseLink"                             "GPUTPCCFDecodeZS ERRORS"                               LB int32_t firstHBF int32_t tpcTimeBinCut)
 o2_gpu_add_kernel("GPUTPCCFGather"                                        "="                                                     LB o2::tpc::ClusterNative* dest)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode0asGPU"                    "= GLOBALREFIT "                                        LB)
 o2_gpu_add_kernel("GPUTrackingRefitKernel, mode1asTrackParCov"            "= GLOBALREFIT "                                        LB)

From 15b5e54028b335b0ef3aee75d18ed3a625ac9202 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 28 Nov 2025 22:46:57 +0100
Subject: [PATCH 1085/1764] Case-insensitive index access

* fix the Binding node always using #_Table_ instead of _Label_ for
  custom index colums
* use case-insensitive comparison for looking up index columns in
  soa::Table and arrow::Table, as the custom-declared index columns
  may have inconsistent capitalization in their names
---
 Framework/Core/include/Framework/ASoA.h       | 12 ++++++++--
 Framework/Core/src/ArrowTableSlicingCache.cxx | 24 ++++++++++++++++---
 2 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index a30363605af36..43079a4634e97 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1376,7 +1376,15 @@ static constexpr std::string getLabelFromType()
 template <typename... C>
 static constexpr auto hasColumnForKey(framework::pack<C...>, std::string const& key)
 {
-  return ((C::inherited_t::mLabel == key) || ...);
+  auto caseInsensitiveCompare = [](const std::string_view& str1, const std::string& str2) {
+    return std::ranges::equal(
+      str1, str2,
+      [](char c1, char c2) {
+        return std::tolower(static_cast<unsigned char>(c1)) ==
+               std::tolower(static_cast<unsigned char>(c2));
+      });
+  };
+  return (caseInsensitiveCompare(C::inherited_t::mLabel, key) || ...);
 }
 
 template <TableRef ref>
@@ -2866,7 +2874,7 @@ consteval auto getIndexTargets()
     o2::soa::Binding getCurrentRaw() const { return mBinding; }                                                                 \
     o2::soa::Binding mBinding;                                                                                                  \
   };                                                                                                                            \
-  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" #_Table_ _Suffix_, _Name_##Id::hash, o2::framework::expressions::selectArrowType<_Type_>() }
+  [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_##Id { "fIndex" _Label_ _Suffix_, _Name_##Id::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
 #define DECLARE_SOA_INDEX_COLUMN_FULL(_Name_, _Getter_, _Type_, _Table_, _Suffix_) DECLARE_SOA_INDEX_COLUMN_FULL_CUSTOM(_Name_, _Getter_, _Type_, _Table_, #_Table_, _Suffix_)
 #define DECLARE_SOA_INDEX_COLUMN(_Name_, _Getter_) DECLARE_SOA_INDEX_COLUMN_FULL(_Name_, _Getter_, int32_t, _Name_##s, "")
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 373c98516bb09..72ced958c510c 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -19,6 +19,24 @@
 namespace o2::framework
 {
 
+namespace {
+std::shared_ptr<arrow::ChunkedArray> GetColumnByNameCI(std::shared_ptr<arrow::Table> const& table, std::string const& key)
+{
+  auto const& fields = table->schema()->fields();
+  auto target = std::find_if(fields.begin(), fields.end(), [&key](std::shared_ptr<arrow::Field> const& field){
+    return [](std::string_view const& s1, std::string_view const& s2){
+      return std::ranges::equal(
+        s1, s2,
+        [](char c1, char c2){
+          return std::tolower(static_cast<unsigned char>(c1)) == std::tolower(static_cast<unsigned char>(c2));
+        }
+        );
+    }(field->name(), key);
+  });
+  return table->column(std::distance(fields.begin(), target));
+}
+}
+
 void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled = true)
 {
   auto locate = std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.binding == binding) && (entry.key == key); });
@@ -99,7 +117,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
   validateOrder(bindingsKeys[pos], table);
 
   int maxValue = -1;
-  auto column = table->GetColumnByName(k);
+  auto column = GetColumnByNameCI(table, k);
 
   // starting from the end, find the first positive value, in a sorted column it is the largest index
   for (auto iChunk = column->num_chunks() - 1; iChunk >= 0; --iChunk) {
@@ -155,7 +173,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
   if (!e) {
     throw runtime_error_f("Disabled unsorted cache %s/%s update requested", b.c_str(), k.c_str());
   }
-  auto column = table->GetColumnByName(k);
+  auto column = GetColumnByNameCI(table, k);
   auto row = 0;
   for (auto iChunk = 0; iChunk < column->num_chunks(); ++iChunk) {
     auto chunk = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(iChunk)->data());
@@ -252,7 +270,7 @@ SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedForPos(int pos) con
 void ArrowTableSlicingCache::validateOrder(Entry const& bindingKey, const std::shared_ptr<arrow::Table>& input)
 {
   auto const& [target, key, enabled] = bindingKey;
-  auto column = input->GetColumnByName(key);
+  auto column = o2::framework::GetColumnByNameCI(input, key);
   auto array0 = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(0)->data());
   int32_t prev = 0;
   int32_t cur = array0.Value(0);

From 687291f970115c895f5be331860a7ca4997b54bf Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Fri, 28 Nov 2025 21:52:32 +0000
Subject: [PATCH 1086/1764] Please consider the following formatting changes

---
 Framework/Core/src/ArrowTableSlicingCache.cxx | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 72ced958c510c..75b4bbfac701d 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -19,23 +19,23 @@
 namespace o2::framework
 {
 
-namespace {
+namespace
+{
 std::shared_ptr<arrow::ChunkedArray> GetColumnByNameCI(std::shared_ptr<arrow::Table> const& table, std::string const& key)
 {
   auto const& fields = table->schema()->fields();
-  auto target = std::find_if(fields.begin(), fields.end(), [&key](std::shared_ptr<arrow::Field> const& field){
-    return [](std::string_view const& s1, std::string_view const& s2){
+  auto target = std::find_if(fields.begin(), fields.end(), [&key](std::shared_ptr<arrow::Field> const& field) {
+    return [](std::string_view const& s1, std::string_view const& s2) {
       return std::ranges::equal(
         s1, s2,
-        [](char c1, char c2){
+        [](char c1, char c2) {
           return std::tolower(static_cast<unsigned char>(c1)) == std::tolower(static_cast<unsigned char>(c2));
-        }
-        );
+        });
     }(field->name(), key);
   });
   return table->column(std::distance(fields.begin(), target));
 }
-}
+} // namespace
 
 void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled = true)
 {

From 0ec9c27391866861153935d71a2e53090cc5c277 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 1 Dec 2025 13:50:31 +0100
Subject: [PATCH 1087/1764] Exclude TPC CalDet test in dataflow builds

---
 Detectors/TPC/base/CMakeLists.txt | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Detectors/TPC/base/CMakeLists.txt b/Detectors/TPC/base/CMakeLists.txt
index 8c796d7e4ff13..a82214d8c070f 100644
--- a/Detectors/TPC/base/CMakeLists.txt
+++ b/Detectors/TPC/base/CMakeLists.txt
@@ -80,12 +80,16 @@ o2_add_test(Base
             SOURCES test/testTPCBase.cxx
             LABELS tpc)
 
-o2_add_test(CalDet
+if(BUILD_SIMULATION)
+  # this test needs CCDB/XROOTD which is for sure
+  # available in the default-o2 software stack
+  o2_add_test(CalDet
             COMPONENT_NAME tpc
             PUBLIC_LINK_LIBRARIES O2::TPCBase
             SOURCES test/testTPCCalDet.cxx
             ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage
             LABELS tpc)
+endif()
 
 o2_add_test(Mapper
             COMPONENT_NAME tpc

From 652c89bcfd4525c0e704e75b0b18c72a2259ca9d Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 30 Nov 2025 21:36:33 +0100
Subject: [PATCH 1088/1764] Use linearization ref. in AB refit

---
 Detectors/GlobalTracking/src/MatchTPCITS.cxx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index 9c1a32a262e51..5f99ad2202073 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -1754,21 +1754,21 @@ bool MatchTPCITS::refitABTrack(int iITSAB, const TPCABSeed& seed, pmr::vector<o2
   auto geom = o2::its::GeometryTGeo::Instance();
   auto propagator = o2::base::Propagator::Instance();
   tracOut.resetCovariance();
+  o2::track::TrackPar refLin(tracOut);
   propagator->estimateLTFast(tofL, winLink); // guess about initial value for the track integral from the origin
   // refit track outward in the ITS
   const auto& itsClRefs = ABTrackletRefs[iITSAB];
   int nclRefit = 0, ncl = itsClRefs.getNClusters();
-
   float chi2 = 0.f;
   // NOTE: the ITS cluster absolute indices are stored from inner to outer layers
   for (int icl = itsClRefs.getFirstEntry(); icl < itsClRefs.getEntriesBound(); icl++) {
     const auto& clus = mITSClustersArray[ABTrackletClusterIDs[icl]];
     float alpha = geom->getSensorRefAlpha(clus.getSensorID()), x = clus.getX();
-    if (!tracOut.rotate(alpha) ||
+    if (!tracOut.rotate(alpha, refLin, propagator->getNominalBz()) ||
         // note: here we also calculate the L,T integral
         // note: we should eventually use TPC pid in the refit (TODO)
         // note: since we are at small R, we can use field BZ component at origin rather than 3D field
-        !propagator->propagateToX(tracOut, x, propagator->getNominalBz(), MaxSnp, maxStep, mUseMatCorrFlag, &tofL)) {
+        !propagator->propagateToX(tracOut, refLin, x, propagator->getNominalBz(), MaxSnp, maxStep, mUseMatCorrFlag, &tofL)) {
       break;
     }
     chi2 += tracOut.getPredictedChi2(clus);
@@ -1789,7 +1789,7 @@ bool MatchTPCITS::refitABTrack(int iITSAB, const TPCABSeed& seed, pmr::vector<o2
   {
     float xtogo = 0;
     if (!tracOut.getXatLabR(o2::constants::geom::XTPCInnerRef, xtogo, mBz, o2::track::DirOutward) ||
-        !propagator->PropagateToXBxByBz(tracOut, xtogo, MaxSnp, 10., mUseMatCorrFlag, &tofL)) {
+        !propagator->PropagateToXBxByBz(tracOut, refLin, xtogo, MaxSnp, 10., mUseMatCorrFlag, &tofL)) {
       LOG(debug) << "Propagation to inner TPC boundary X=" << xtogo << " failed, Xtr=" << tracOut.getX() << " snp=" << tracOut.getSnp();
       matchedTracks.pop_back(); // destroy failed track
       return false;

From a8770865dead616d23268adc421c84eb9c0dbc4e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 1 Dec 2025 14:55:37 +0100
Subject: [PATCH 1089/1764] GPU TPC: Don't cut on goodLeg flag, now marked on
 track level

---
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index e911275da1e55..9224904e104c1 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -33,7 +33,6 @@ using namespace o2::tpc;
 using namespace o2::tpc::constants;
 
 GPUdi() static constexpr uint8_t getFlagsReject() { return GPUTPCGMMergedTrackHit::flagReject | GPUTPCGMMergedTrackHit::flagHighIncl; }
-GPUdi() static uint32_t getFlagsRequired(const GPUSettingsRec& rec) { return gputpcgmmergertypes::attachGoodLeg; }
 
 namespace o2::gpu::internal
 {
@@ -56,7 +55,6 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
   const GPUdEdxInfo* tracksdEdx = merger.MergedTracksdEdx();
 
   constexpr uint8_t flagsReject = getFlagsReject();
-  const uint32_t flagsRequired = getFlagsRequired(merger.Param().rec);
   bool cutOnTrackdEdx = merger.Param().par.dodEdx && merger.Param().dodEdxEnabled && merger.Param().rec.tpc.minTrackdEdxMax2Tot > 0.f;
 
   GPUTPCGMMerger::tmpSort* GPUrestrict() trackSort = merger.TrackSortO2();
@@ -71,7 +69,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
 
     uint32_t nCl = 0;
     for (uint32_t j = 0; j < tracks[i].NClusters(); j++) {
-      if ((trackClusters[tracks[i].FirstClusterRef() + j].state & flagsReject) || (merger.ClusterAttachment()[trackClusters[tracks[i].FirstClusterRef() + j].num] & flagsRequired) != flagsRequired) {
+      if ((trackClusters[tracks[i].FirstClusterRef() + j].state & flagsReject)) {
         continue;
       }
       nCl++;
@@ -115,7 +113,6 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
   const int32_t nTracks = merger.NOutputTracksTPCO2();
   const GPUTPCGMMergedTrackHit* trackClusters = merger.Clusters();
   constexpr uint8_t flagsReject = getFlagsReject();
-  const uint32_t flagsRequired = getFlagsRequired(merger.Param().rec);
   TrackTPC* outputTracks = merger.OutputTracksTPCO2();
   uint32_t* clusRefs = merger.OutputClusRefsTPCO2();
   const auto& param = merger.Param();
@@ -191,7 +188,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
     int32_t sector1 = 0, sector2 = 0;
     const o2::tpc::ClusterNativeAccess* GPUrestrict() clusters = merger.GetConstantMem()->ioPtrs.clustersNative;
     for (uint32_t j = 0; j < track.NClusters(); j++) {
-      if ((trackClusters[track.FirstClusterRef() + j].state & flagsReject) || (merger.ClusterAttachment()[trackClusters[track.FirstClusterRef() + j].num] & flagsRequired) != flagsRequired) {
+      if ((trackClusters[track.FirstClusterRef() + j].state & flagsReject)) {
         continue;
       }
       int32_t clusterIdGlobal = trackClusters[track.FirstClusterRef() + j].num;

From a807b70ee17ff00c0cfdf17175f2ad934f249788 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 2 Dec 2025 10:58:39 +0100
Subject: [PATCH 1090/1764] DPL: remove direct dependency on fair::mq::Device
 from the FairMQDeviceProxy

---
 .../include/Framework/FairMQDeviceProxy.h     |  4 ++-
 Framework/Core/src/CommonMessageBackends.cxx  | 13 ++++++++-
 .../Core/src/ExternalFairMQDeviceProxy.cxx    | 13 ++++++++-
 Framework/Core/src/FairMQDeviceProxy.cxx      | 28 ++++++++-----------
 4 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/Framework/Core/include/Framework/FairMQDeviceProxy.h b/Framework/Core/include/Framework/FairMQDeviceProxy.h
index ab0d094c18486..dbdade465f09c 100644
--- a/Framework/Core/include/Framework/FairMQDeviceProxy.h
+++ b/Framework/Core/include/Framework/FairMQDeviceProxy.h
@@ -38,7 +38,9 @@ class FairMQDeviceProxy
   FairMQDeviceProxy() = default;
   FairMQDeviceProxy(FairMQDeviceProxy const&) = delete;
   void bind(std::vector<OutputRoute> const& outputs, std::vector<InputRoute> const& inputs,
-            std::vector<ForwardRoute> const& forwards, fair::mq::Device& device);
+            std::vector<ForwardRoute> const& forwards,
+            std::function<fair::mq::Channel&(std::string const&)> bindChannelByName,
+            std::function<bool(void)> newStateRequestedCallback);
 
   /// Retrieve the transport associated to a given route.
   [[nodiscard]] OutputRoute const& getOutputRoute(RouteIndex routeIndex) const { return mOutputs.at(routeIndex.value); }
diff --git a/Framework/Core/src/CommonMessageBackends.cxx b/Framework/Core/src/CommonMessageBackends.cxx
index 79bd84307df15..25bf6a138dee4 100644
--- a/Framework/Core/src/CommonMessageBackends.cxx
+++ b/Framework/Core/src/CommonMessageBackends.cxx
@@ -57,7 +57,18 @@ o2::framework::ServiceSpec CommonMessageBackends::fairMQDeviceProxy()
       /// some of the channels are added only later on to the party,
       /// (e.g. by ECS) and Init might not be late enough to
       /// account for them.
-      proxy->bind(outputs, inputs, forwards, *device); },
+      std::function<fair::mq::Channel&(std::string const&)> bindByName = [device](std::string const& channelName) -> fair::mq::Channel& {
+        auto channel = device->GetChannels().find(channelName);
+        if (channel == device->GetChannels().end()) {
+          LOGP(fatal, "Expected channel {} not configured.", channelName);
+        }
+         return channel->second.at(0);
+      };
+
+      std::function<bool()> newStateCallback = [device]() -> bool {
+        return device->NewStatePending();
+      };
+      proxy->bind(outputs, inputs, forwards, bindByName, newStateCallback); },
   };
 }
 
diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index 99176de0d9db6..b4bfc991db9ae 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -1090,7 +1090,18 @@ DataProcessorSpec specifyFairMQDeviceMultiOutputProxy(char const* name,
 
         channelNames->emplace_back(std::move(channel));
       }
-      proxy.bind(mutableDeviceSpec.outputs, mutableDeviceSpec.inputs, mutableDeviceSpec.forwards, *device);
+      std::function<fair::mq::Channel&(std::string const&)> bindByName = [device](std::string const& channelName) -> fair::mq::Channel& {
+        auto channel = device->GetChannels().find(channelName);
+        if (channel == device->GetChannels().end()) {
+          LOGP(fatal, "Expected channel {} not configured.", channelName);
+        }
+        return channel->second.at(0);
+      };
+
+      std::function<bool()> newStateCallback = [device]() -> bool {
+        return device->NewStatePending();
+      };
+      proxy.bind(mutableDeviceSpec.outputs, mutableDeviceSpec.inputs, mutableDeviceSpec.forwards, bindByName, newStateCallback);
     };
     // We need to clear the channels on stop, because we will check and add them
     auto channelConfigurationDisposer = [&deviceSpec]() {
diff --git a/Framework/Core/src/FairMQDeviceProxy.cxx b/Framework/Core/src/FairMQDeviceProxy.cxx
index bdffddd5a4d1a..e121084b866a2 100644
--- a/Framework/Core/src/FairMQDeviceProxy.cxx
+++ b/Framework/Core/src/FairMQDeviceProxy.cxx
@@ -230,7 +230,8 @@ std::unique_ptr<fair::mq::Message> FairMQDeviceProxy::createForwardMessage(Route
 
 void FairMQDeviceProxy::bind(std::vector<OutputRoute> const& outputs, std::vector<InputRoute> const& inputs,
                              std::vector<ForwardRoute> const& forwards,
-                             fair::mq::Device& device)
+                             std::function<fair::mq::Channel&(std::string const&)> bindChannelByName,
+                             std::function<bool(void)> newStatePending)
 {
   mOutputs.clear();
   mOutputRoutes.clear();
@@ -258,14 +259,11 @@ void FairMQDeviceProxy::bind(std::vector<OutputRoute> const& outputs, std::vecto
       if (channelPos == channelNameToChannel.end()) {
         channelIndex = ChannelIndex{(int)mOutputChannelInfos.size()};
         ChannelAccountingType dplChannel = (route.channel.rfind("from_", 0) == 0) ? ChannelAccountingType::DPL : ChannelAccountingType::RAWFMQ;
-        auto channel = device.GetChannels().find(route.channel);
-        if (channel == device.GetChannels().end()) {
-          LOGP(fatal, "Expected channel {} not configured.", route.channel);
-        }
+        auto& channel = bindChannelByName(route.channel);
         OutputChannelInfo info{
           .name = route.channel,
           .channelType = dplChannel,
-          .channel = channel->second.at(0),
+          .channel = channel,
           .policy = route.policy,
           .index = channelIndex,
         };
@@ -305,11 +303,9 @@ void FairMQDeviceProxy::bind(std::vector<OutputRoute> const& outputs, std::vecto
 
       if (channelPos == channelNameToChannel.end()) {
         channelIndex = ChannelIndex{(int)mInputChannels.size()};
-        auto channel = device.GetChannels().find(route.sourceChannel);
-        if (channel == device.GetChannels().end()) {
-          LOGP(fatal, "Expected channel {} not configured.", route.sourceChannel);
-        }
-        mInputChannels.push_back(&channel->second.at(0));
+        fair::mq::Channel& channel = bindChannelByName(route.sourceChannel);
+
+        mInputChannels.push_back(&channel);
         mInputChannelNames.push_back(route.sourceChannel);
         channelNameToChannel[route.sourceChannel] = channelIndex;
         LOGP(detail, "Binding channel {} to channel index {}", route.sourceChannel, channelIndex.value);
@@ -341,12 +337,10 @@ void FairMQDeviceProxy::bind(std::vector<OutputRoute> const& outputs, std::vecto
 
       if (channelPos == channelNameToChannel.end()) {
         channelIndex = ChannelIndex{(int)mForwardChannelInfos.size()};
-        auto channel = device.GetChannels().find(route.channel);
-        if (channel == device.GetChannels().end()) {
-          LOGP(fatal, "Expected channel {} not configured.", route.channel);
-        }
+        auto& channel = bindChannelByName(route.channel);
+
         ChannelAccountingType dplChannel = (route.channel.rfind("from_", 0) == 0) ? ChannelAccountingType::DPL : ChannelAccountingType::RAWFMQ;
-        mForwardChannelInfos.push_back(ForwardChannelInfo{.name = route.channel, .channelType = dplChannel, .channel = channel->second.at(0), .policy = route.policy, .index = channelIndex});
+        mForwardChannelInfos.push_back(ForwardChannelInfo{.name = route.channel, .channelType = dplChannel, .channel = channel, .policy = route.policy, .index = channelIndex});
         mForwardChannelStates.push_back(ForwardChannelState{0});
         channelNameToChannel[route.channel] = channelIndex;
         LOGP(detail, "Binding forward channel {} to channel index {}", route.channel, channelIndex.value);
@@ -368,6 +362,6 @@ void FairMQDeviceProxy::bind(std::vector<OutputRoute> const& outputs, std::vecto
       LOGP(detail, "Forward route {}@{}%{} to index {} and channelIndex {}", DataSpecUtils::describe(route.matcher), route.timeslice, route.maxTimeslices, fi, state.channel.value);
     }
   }
-  mStateChangeCallback = [&device]() -> bool { return device.NewStatePending(); };
+  mStateChangeCallback = newStatePending;
 }
 } // namespace o2::framework

From 3c161fc076203b1f7d357b216e3e545304091e67 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 28 Nov 2025 23:14:19 +0100
Subject: [PATCH 1091/1764] FST: Switch to using jobutils2.sh

---
 prodtests/full_system_test.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 6100e3ed87a2c..a799afbbbfd3d 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -31,7 +31,7 @@ fi
 # --> the taskwrapper as a simple control and monitoring tool
 #     (look inside the jobutils.sh file for documentation)
 # --> utilities to query CPU count
-. ${O2_ROOT}/share/scripts/jobutils.sh
+. ${O2_ROOT}/share/scripts/jobutils2.sh
 
 # make sure that correct format will be used irrespecive of the locale
 export LC_NUMERIC=C

From 69c43d59ae93ac77dd7bb1484e2ec6bb0e935cc0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 2 Dec 2025 20:57:29 +0100
Subject: [PATCH 1092/1764] GPU QA: Fix some histogram names / titles / axes

---
 GPU/GPUTracking/qa/GPUQA.cxx | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index ce4a4a81db02c..9047f0bfce6f2 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -176,6 +176,7 @@ static const constexpr char* CLUSTER_NAMES[GPUQA::N_CLS_HIST] = {"Correctly atta
 static const constexpr char* CLUSTER_TITLES[GPUQA::N_CLS_TYPE] = {"Clusters Pt Distribution / Attachment", "Clusters Pt Distribution / Attachment (relative to all clusters)", "Clusters Pt Distribution / Attachment (integrated)"};
 static const constexpr char* CLUSTER_NAMES_SHORT[GPUQA::N_CLS_HIST] = {"Attached", "Fake", "AttachAdjacent", "FakeAdjacent", "FoundTracks", "Physics", "Protected", "All"};
 static const constexpr char* CLUSTER_TYPES[GPUQA::N_CLS_TYPE] = {"", "Ratio", "Integral"};
+static const constexpr char* REJECTED_NAMES[3] = {"All", "Rejected", "Fraction"};
 static const constexpr int32_t COLORS_HEX[COLORCOUNT] = {0xB03030, 0x00A000, 0x0000C0, 0x9400D3, 0x19BBBF, 0xF25900, 0x7F7F7F, 0xFFD700, 0x07F707, 0x07F7F7, 0xF08080, 0x000000};
 
 static const constexpr int32_t CONFIG_DASHED_MARKERS = 0;
@@ -525,7 +526,7 @@ int32_t GPUQA::InitQACreateHistograms()
     }
 
     createHist(mPadRow[0], "padrow0", "padrow0", GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
-    createHist(mPadRow[1], "padrow0", "padrow0", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
+    createHist(mPadRow[1], "padrow1", "padrow1", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
   }
 
   if (mQATasks & taskTrackStatistics) {
@@ -2863,14 +2864,16 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
       mPPadRow[i]->cd();
       e->SetOption("colz");
-      e->GetXaxis()->SetTitle("First MC Pad Row");
+      e->SetTitle("First Track Pad Row");
+      e->GetXaxis()->SetTitle(i ? "Phi (sector)" : "First MC Pad Row");
       e->GetYaxis()->SetTitle("First Pad Row");
       e->Draw();
       mCPadRow[i]->cd();
-      snprintf(name, 2048, "plots/padrow%d.pdf", i);
+      static const constexpr char* PADROW_NAMES[2] = {"MC", "Phi"};
+      snprintf(name, 2048, "plots/padRow%s.pdf", PADROW_NAMES[i]);
       mCPadRow[i]->Print(name);
       if (mConfig.writeRootFiles) {
-        snprintf(name, 2048, "plots/padrow%d.root", i);
+        snprintf(name, 2048, "plots/padRow%s.root", PADROW_NAMES[i]);
         mCPadRow[i]->Print(name);
       }
     }
@@ -3052,13 +3055,14 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
           mClRej[i]->Write();
         }
         mPClRej[i]->cd();
+        mClRej[i]->SetTitle(REJECTED_NAMES[i]);
         mClRej[i]->SetOption("colz");
         mClRej[i]->Draw();
         mCClRej[i]->cd();
-        snprintf(name, 2048, "plots/clustersRej%d.pdf", i);
+        snprintf(name, 2048, "plots/clustersRej%d%s.pdf", i, REJECTED_NAMES[i]);
         mCClRej[i]->Print(name);
         if (mConfig.writeRootFiles) {
-          snprintf(name, 2048, "plots/clustersRej%d.root", i);
+          snprintf(name, 2048, "plots/clustersRej%d%s.root", i, REJECTED_NAMES[i]);
           mCClRej[i]->Print(name);
         }
       }
@@ -3092,11 +3096,14 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         delete proj2;
         e->SetMinimum(-0.02);
         e->SetMaximum(0.22);
+        e->SetTitle("Rejected Clusters");
+        e->GetXaxis()->SetTitle("Pad Row");
+        e->GetYaxis()->SetTitle("Rejected Clusters (fraction)");
         e->Draw(k == 0 ? "" : "same");
       }
-      mPClRejP->Print("plots/clustersRejP.pdf"); // TODO: Add option to write pngs
+      mPClRejP->Print("plots/clustersRejProjected.pdf"); // TODO: Add option to write pngs
       if (mConfig.writeRootFiles) {
-        mPClRejP->Print("plots/clustersRejP.root");
+        mPClRejP->Print("plots/clustersRejProjected.root");
       }
     }
   }

From c2b6369b11dcdaa85fb8574ed20a6262c688f070 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 2 Dec 2025 21:24:24 +0100
Subject: [PATCH 1093/1764] GPU QA: Add padrowphi1 histogram

---
 GPU/GPUTracking/qa/GPUQA.cxx | 14 +++++++++-----
 GPU/GPUTracking/qa/GPUQA.h   |  6 +++---
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 9047f0bfce6f2..53a4c7de99296 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -527,6 +527,7 @@ int32_t GPUQA::InitQACreateHistograms()
 
     createHist(mPadRow[0], "padrow0", "padrow0", GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
     createHist(mPadRow[1], "padrow1", "padrow1", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
+    createHist(mPadRow[2], "padrow2", "padrow2", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
   }
 
   if (mQATasks & taskTrackStatistics) {
@@ -1114,8 +1115,11 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           const auto& trk = mTracking->mIOPtrs.mergedTracks[i];
           if (trk.OK() && lowestPadRow[i] != 255 && trk.NClustersFitted() > 70 && CAMath::Abs(trk.GetParam().GetQPt()) < 0.5) {
             int32_t lowestRow = CAMath::Min(mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef()].row, mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef() + trk.NClusters() - 1].row);
-            mPadRow[0]->Fill((float)lowestPadRow[i], (float)lowestRow, 1.f);
+            mPadRow[0]->Fill(lowestPadRow[i], lowestRow, 1.f);
             mPadRow[1]->Fill(CAMath::ATan2(trk.GetParam().GetY(), trk.GetParam().GetX()), lowestRow, 1.f);
+            if (lowestPadRow[i] == 0 && lowestRow != 0) {
+              mPadRow[2]->Fill(CAMath::ATan2(trk.GetParam().GetY(), trk.GetParam().GetX()), lowestRow, 1.f);
+            }
           }
         }
       }
@@ -2278,7 +2282,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mPClRejP = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPClRejP->Draw();
 
-      for (int32_t i = 0; i < 2; i++) {
+      for (int32_t i = 0; i < 3; i++) {
         snprintf(name, 2048, "cpadrow%d", i);
         mCPadRow[i] = createGarbageCollected<TCanvas>(name, "First Track Pad Row", 0, 0, 700, 700. * 2. / 3.);
         mCPadRow[i]->cd();
@@ -2857,19 +2861,19 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
     }
 
-    for (int32_t i = 0; i < 2; i++) {
+    for (int32_t i = 0; i < 3; i++) {
       auto* e = mPadRow[i];
       if (tout && !mConfig.inputHistogramsOnly) {
         e->Write();
       }
       mPPadRow[i]->cd();
       e->SetOption("colz");
-      e->SetTitle("First Track Pad Row");
+      e->SetTitle(i == 2 ? "First Track Pad Row (row_{MC} = 0, row_{trk} #ne 0)" : "First Track Pad Row");
       e->GetXaxis()->SetTitle(i ? "Phi (sector)" : "First MC Pad Row");
       e->GetYaxis()->SetTitle("First Pad Row");
       e->Draw();
       mCPadRow[i]->cd();
-      static const constexpr char* PADROW_NAMES[2] = {"MC", "Phi"};
+      static const constexpr char* PADROW_NAMES[3] = {"MC", "Phi", "Phi1"};
       snprintf(name, 2048, "plots/padRow%s.pdf", PADROW_NAMES[i]);
       mCPadRow[i]->Print(name);
       if (mConfig.writeRootFiles) {
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index f6225c2d38276..54d1ceed9d365 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -323,9 +323,9 @@ class GPUQA
   TPad* mPClRej[3];
   TPad* mPClRejP;
 
-  TH2F* mPadRow[2];
-  TCanvas* mCPadRow[2];
-  TPad* mPPadRow[2];
+  TH2F* mPadRow[3];
+  TCanvas* mCPadRow[3];
+  TPad* mPPadRow[3];
 
   std::vector<TH2F*> mHistClusterCount;
 

From 1f0b9466f009e7afe348e8e4436e86e1935b020a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 2 Dec 2025 21:44:30 +0100
Subject: [PATCH 1094/1764] GPU QA: add plotsDir option

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 GPU/GPUTracking/qa/GPUQA.cxx                  | 46 +++++++++----------
 2 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index dc1742453ef39..163a01eb1a2c7 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -530,6 +530,7 @@ AddOption(minNClFindable, uint32_t, 70, "", 0, "Minimum number of (weighted) MC
 AddOption(minNClEff, uint32_t, 10, "", 0, "Minimum number of (weighted) MC clusters for a track to contribute to all-tracks efficiency histogramm")
 AddOption(minNClRes, uint32_t, 40, "", 0, "Minimum number of (weighted) MC clusters for a track to contribute to resolution histogram")
 AddOption(perfFigure, int32_t, 0, "", 0, "Show as performance figure, positive value for MC, negative value for data")
+AddOption(plotsDir, std::string, "plots", "", 0, "Directory to write plots to")
 AddShortcut("compare", 0, "--QAinput", "Compare QA histograms", "--qa", "--QAinputHistogramsOnly")
 AddHelp("help", 'h')
 EndConfig()
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 53a4c7de99296..ccda942254a6f 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -830,7 +830,7 @@ int32_t GPUQA::InitQA(int32_t tasks)
   }
 
   if (mConfig.enableLocalOutput) {
-    mkdir("plots", S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+    mkdir(mConfig.plotsDir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
   }
 
 #ifdef GPUCA_O2_LIB
@@ -2394,9 +2394,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         continue;
       }
       doPerfFigure(0.2, 0.295, 0.025);
-      mCEff[ii]->Print(Form("plots/eff_vs_%s.pdf", VSPARAMETER_NAMES[ii]));
+      mCEff[ii]->Print(Form("%s/eff_vs_%s.pdf", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii]));
       if (mConfig.writeRootFiles) {
-        mCEff[ii]->Print(Form("plots/eff_vs_%s.root", VSPARAMETER_NAMES[ii]));
+        mCEff[ii]->Print(Form("%s/eff_vs_%s.root", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii]));
       }
     }
   }
@@ -2632,9 +2632,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
           continue;
         }
         doPerfFigure(0.2, 0.295, 0.025);
-        can->Print(Form(p ? "plots/pull_vs_%s.pdf" : "plots/res_vs_%s.pdf", VSPARAMETER_NAMES[ii]));
+        can->Print(Form(p ? "%s/pull_vs_%s.pdf" : "%s/res_vs_%s.pdf", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii]));
         if (mConfig.writeRootFiles) {
-          can->Print(Form(p ? "plots/pull_vs_%s.root" : "plots/res_vs_%s.root", VSPARAMETER_NAMES[ii]));
+          can->Print(Form(p ? "%s/pull_vs_%s.root" : "%s/res_vs_%s.root", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii]));
         }
       }
     }
@@ -2703,9 +2703,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         continue;
       }
 
-      can->Print(p ? "plots/pull_integral.pdf" : "plots/res_integral.pdf");
+      can->Print(Form(p ? "%s/pull_integral.pdf" : "%s/res_integral.pdf", mConfig.plotsDir.c_str()));
       if (mConfig.writeRootFiles) {
-        can->Print(p ? "plots/pull_integral.root" : "plots/res_integral.root");
+        can->Print(Form(p ? "%s/pull_integral.root" : "%s/res_integral.root", mConfig.plotsDir.c_str()));
       }
     }
   }
@@ -2855,9 +2855,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
       doPerfFigure(i == 0 ? 0.37 : (i == 1 ? 0.34 : 0.6), 0.295, 0.030);
       mCClust[i]->cd();
-      mCClust[i]->Print(i == 2 ? "plots/clusters_integral.pdf" : i == 1 ? "plots/clusters_relative.pdf" : "plots/clusters.pdf");
+      mCClust[i]->Print(Form(i == 2 ? "%s/clusters_integral.pdf" : i == 1 ? "%s/clusters_relative.pdf" : "%s/clusters.pdf", mConfig.plotsDir.c_str()));
       if (mConfig.writeRootFiles) {
-        mCClust[i]->Print(i == 2 ? "plots/clusters_integral.root" : i == 1 ? "plots/clusters_relative.root" : "plots/clusters.root");
+        mCClust[i]->Print(Form(i == 2 ? "%s/clusters_integral.root" : i == 1 ? "%s/clusters_relative.root" : "%s/clusters.root", mConfig.plotsDir.c_str()));
       }
     }
 
@@ -2874,10 +2874,10 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       e->Draw();
       mCPadRow[i]->cd();
       static const constexpr char* PADROW_NAMES[3] = {"MC", "Phi", "Phi1"};
-      snprintf(name, 2048, "plots/padRow%s.pdf", PADROW_NAMES[i]);
+      snprintf(name, 2048, "%s/padRow%s.pdf", mConfig.plotsDir.c_str(), PADROW_NAMES[i]);
       mCPadRow[i]->Print(name);
       if (mConfig.writeRootFiles) {
-        snprintf(name, 2048, "plots/padRow%s.root", PADROW_NAMES[i]);
+        snprintf(name, 2048, "%s/padRow%s.root", mConfig.plotsDir.c_str(), PADROW_NAMES[i]);
         mCPadRow[i]->Print(name);
       }
     }
@@ -2941,9 +2941,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     mLTracks->Draw();
     doPerfFigure(0.63, 0.7, 0.030);
     mCTracks->cd();
-    mCTracks->Print("plots/tracks.pdf");
+    mCTracks->Print(Form("%s/tracks.pdf", mConfig.plotsDir.c_str()));
     if (mConfig.writeRootFiles) {
-      mCTracks->Print("plots/tracks.root");
+      mCTracks->Print(Form("%s/tracks.root", mConfig.plotsDir.c_str()));
     }
 
     for (int32_t i = 0; i < 2; i++) {
@@ -2987,10 +2987,10 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mLT0[i]->Draw();
       doPerfFigure(0.63, 0.7, 0.030);
       mCT0[i]->cd();
-      snprintf(name, 2048, "plots/t0%s.pdf", i ? "_res" : "");
+      snprintf(name, 2048, "%s/t0%s.pdf", mConfig.plotsDir.c_str(), i ? "_res" : "");
       mCT0[i]->Print(name);
       if (mConfig.writeRootFiles) {
-        snprintf(name, 2048, "plots/t0%s.root", i ? "_res" : "");
+        snprintf(name, 2048, "%s/t0%s.root", mConfig.plotsDir.c_str(), i ? "_res" : "");
         mCT0[i]->Print(name);
       }
 
@@ -3034,10 +3034,10 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mLNCl[i]->Draw();
       doPerfFigure(0.6, 0.7, 0.030);
       mCNCl[i]->cd();
-      snprintf(name, 2048, "plots/nClusters%s.pdf", i ? "_corrected" : "");
+      snprintf(name, 2048, "%s/nClusters%s.pdf", mConfig.plotsDir.c_str(), i ? "_corrected" : "");
       mCNCl[i]->Print(name);
       if (mConfig.writeRootFiles) {
-        snprintf(name, 2048, "plots/nClusters%s.root", i ? "_corrected" : "");
+        snprintf(name, 2048, "%s/nClusters%s.root", mConfig.plotsDir.c_str(), i ? "_corrected" : "");
         mCNCl[i]->Print(name);
       }
     }
@@ -3046,9 +3046,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     mClXY->SetOption("colz");
     mClXY->Draw();
     mCClXY->cd();
-    mCClXY->Print("plots/clustersXY.pdf");
+    mCClXY->Print(Form("%s/clustersXY.pdf", mConfig.plotsDir.c_str()));
     if (mConfig.writeRootFiles) {
-      mCClXY->Print("plots/clustersXY.root");
+      mCClXY->Print(Form("%s/clustersXY.root", mConfig.plotsDir.c_str()));
     }
 
     if (mQATasks & taskClusterCounts) {
@@ -3063,10 +3063,10 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         mClRej[i]->SetOption("colz");
         mClRej[i]->Draw();
         mCClRej[i]->cd();
-        snprintf(name, 2048, "plots/clustersRej%d%s.pdf", i, REJECTED_NAMES[i]);
+        snprintf(name, 2048, "%s/clustersRej%d%s.pdf", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i]);
         mCClRej[i]->Print(name);
         if (mConfig.writeRootFiles) {
-          snprintf(name, 2048, "plots/clustersRej%d%s.root", i, REJECTED_NAMES[i]);
+          snprintf(name, 2048, "%s/clustersRej%d%s.root", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i]);
           mCClRej[i]->Print(name);
         }
       }
@@ -3105,9 +3105,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         e->GetYaxis()->SetTitle("Rejected Clusters (fraction)");
         e->Draw(k == 0 ? "" : "same");
       }
-      mPClRejP->Print("plots/clustersRejProjected.pdf"); // TODO: Add option to write pngs
+      mPClRejP->Print(Form("%s/clustersRejProjected.pdf", mConfig.plotsDir.c_str())); // TODO: Add option to write pngs
       if (mConfig.writeRootFiles) {
-        mPClRejP->Print("plots/clustersRejProjected.root");
+        mPClRejP->Print(Form("%s/clustersRejProjected.root", mConfig.plotsDir.c_str()));
       }
     }
   }

From 863af5c096baf78c65c978eb16063565810c4323 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 2 Dec 2025 21:56:57 +0100
Subject: [PATCH 1095/1764] GPU QA: Add option to write other files but ROOT

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  | 52 +++++++++----------
 2 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 163a01eb1a2c7..5a075bf7f9a02 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -516,7 +516,7 @@ AddOption(filterPID, int32_t, -1, "", 0, "Filter for Particle Type (0 Electron,
 AddOption(nativeFitResolutions, bool, false, "", 0, "Create resolution histograms in the native fit units (sin(phi), tan(lambda), Q/Pt)")
 AddOption(enableLocalOutput, bool, true, "", 0, "Enable normal output to local PDF files / console")
 AddOption(dumpToROOT, int32_t, 0, "", 0, "Dump all clusters and tracks to a ROOT file, 1 = combined TNTUple dump, 2 = also individual cluster / track branch dump")
-AddOption(writeRootFiles, bool, false, "", 0, "Create ROOT canvas files")
+AddOption(writeFileExt, std::string, "", "", 0, "Write extra output file with given extension (default ROOT Canvas)", def("root"))
 AddOption(writeMCLabels, bool, false, "", 0, "Store mc labels to file for later matching")
 AddOptionVec(matchMCLabels, std::string, "", 0, "Read labels from files and match them, only process tracks where labels differ")
 AddOption(compareTrackStatus, uint32_t, 0, "", 0, "0 = disabled, 1 = write status file, 2 = read status file and compare with current tracks")
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index ccda942254a6f..6adcd975ec45f 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -2084,11 +2084,11 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
   }
 
   std::vector<Color_t> colorNums(COLORCOUNT);
-  if (!(qcout || mConfig.writeRootFiles)) {
+  if (!(qcout || mConfig.writeFileExt == "root" || mConfig.writeFileExt == "C")) {
     [[maybe_unused]] static int32_t initColorsInitialized = initColors();
   }
   for (int32_t i = 0; i < COLORCOUNT; i++) {
-    colorNums[i] = (qcout || mConfig.writeRootFiles) ? defaultColorNums[i] : mColors[i]->GetNumber();
+    colorNums[i] = (qcout || mConfig.writeFileExt == "root" || mConfig.writeFileExt == "C") ? defaultColorNums[i] : mColors[i]->GetNumber();
   }
 
   bool mcAvail = mcPresent();
@@ -2395,8 +2395,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
       doPerfFigure(0.2, 0.295, 0.025);
       mCEff[ii]->Print(Form("%s/eff_vs_%s.pdf", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii]));
-      if (mConfig.writeRootFiles) {
-        mCEff[ii]->Print(Form("%s/eff_vs_%s.root", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii]));
+      if (mConfig.writeFileExt != "") {
+        mCEff[ii]->Print(Form("%s/eff_vs_%s.%s", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii], mConfig.writeFileExt.c_str()));
       }
     }
   }
@@ -2633,8 +2633,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         }
         doPerfFigure(0.2, 0.295, 0.025);
         can->Print(Form(p ? "%s/pull_vs_%s.pdf" : "%s/res_vs_%s.pdf", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii]));
-        if (mConfig.writeRootFiles) {
-          can->Print(Form(p ? "%s/pull_vs_%s.root" : "%s/res_vs_%s.root", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii]));
+        if (mConfig.writeFileExt != "") {
+          can->Print(Form(p ? "%s/pull_vs_%s.%s" : "%s/res_vs_%s.%s", mConfig.plotsDir.c_str(), VSPARAMETER_NAMES[ii], mConfig.writeFileExt.c_str()));
         }
       }
     }
@@ -2704,8 +2704,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
 
       can->Print(Form(p ? "%s/pull_integral.pdf" : "%s/res_integral.pdf", mConfig.plotsDir.c_str()));
-      if (mConfig.writeRootFiles) {
-        can->Print(Form(p ? "%s/pull_integral.root" : "%s/res_integral.root", mConfig.plotsDir.c_str()));
+      if (mConfig.writeFileExt != "") {
+        can->Print(Form(p ? "%s/pull_integral.%s" : "%s/res_integral.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
       }
     }
   }
@@ -2856,8 +2856,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       doPerfFigure(i == 0 ? 0.37 : (i == 1 ? 0.34 : 0.6), 0.295, 0.030);
       mCClust[i]->cd();
       mCClust[i]->Print(Form(i == 2 ? "%s/clusters_integral.pdf" : i == 1 ? "%s/clusters_relative.pdf" : "%s/clusters.pdf", mConfig.plotsDir.c_str()));
-      if (mConfig.writeRootFiles) {
-        mCClust[i]->Print(Form(i == 2 ? "%s/clusters_integral.root" : i == 1 ? "%s/clusters_relative.root" : "%s/clusters.root", mConfig.plotsDir.c_str()));
+      if (mConfig.writeFileExt != "") {
+        mCClust[i]->Print(Form(i == 2 ? "%s/clusters_integral.%s" : i == 1 ? "%s/clusters_relative.%s" : "%s/clusters.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
       }
     }
 
@@ -2876,8 +2876,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       static const constexpr char* PADROW_NAMES[3] = {"MC", "Phi", "Phi1"};
       snprintf(name, 2048, "%s/padRow%s.pdf", mConfig.plotsDir.c_str(), PADROW_NAMES[i]);
       mCPadRow[i]->Print(name);
-      if (mConfig.writeRootFiles) {
-        snprintf(name, 2048, "%s/padRow%s.root", mConfig.plotsDir.c_str(), PADROW_NAMES[i]);
+      if (mConfig.writeFileExt != "") {
+        snprintf(name, 2048, "%s/padRow%s.%s", mConfig.plotsDir.c_str(), PADROW_NAMES[i], mConfig.writeFileExt.c_str());
         mCPadRow[i]->Print(name);
       }
     }
@@ -2942,8 +2942,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     doPerfFigure(0.63, 0.7, 0.030);
     mCTracks->cd();
     mCTracks->Print(Form("%s/tracks.pdf", mConfig.plotsDir.c_str()));
-    if (mConfig.writeRootFiles) {
-      mCTracks->Print(Form("%s/tracks.root", mConfig.plotsDir.c_str()));
+    if (mConfig.writeFileExt != "") {
+      mCTracks->Print(Form("%s/tracks.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
     }
 
     for (int32_t i = 0; i < 2; i++) {
@@ -2989,8 +2989,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mCT0[i]->cd();
       snprintf(name, 2048, "%s/t0%s.pdf", mConfig.plotsDir.c_str(), i ? "_res" : "");
       mCT0[i]->Print(name);
-      if (mConfig.writeRootFiles) {
-        snprintf(name, 2048, "%s/t0%s.root", mConfig.plotsDir.c_str(), i ? "_res" : "");
+      if (mConfig.writeFileExt != "") {
+        snprintf(name, 2048, "%s/t0%s.%s", mConfig.plotsDir.c_str(), i ? "_res" : "", mConfig.writeFileExt.c_str());
         mCT0[i]->Print(name);
       }
 
@@ -3036,8 +3036,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mCNCl[i]->cd();
       snprintf(name, 2048, "%s/nClusters%s.pdf", mConfig.plotsDir.c_str(), i ? "_corrected" : "");
       mCNCl[i]->Print(name);
-      if (mConfig.writeRootFiles) {
-        snprintf(name, 2048, "%s/nClusters%s.root", mConfig.plotsDir.c_str(), i ? "_corrected" : "");
+      if (mConfig.writeFileExt != "") {
+        snprintf(name, 2048, "%s/nClusters%s.%s", mConfig.plotsDir.c_str(), i ? "_corrected" : "", mConfig.writeFileExt.c_str());
         mCNCl[i]->Print(name);
       }
     }
@@ -3047,8 +3047,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     mClXY->Draw();
     mCClXY->cd();
     mCClXY->Print(Form("%s/clustersXY.pdf", mConfig.plotsDir.c_str()));
-    if (mConfig.writeRootFiles) {
-      mCClXY->Print(Form("%s/clustersXY.root", mConfig.plotsDir.c_str()));
+    if (mConfig.writeFileExt != "") {
+      mCClXY->Print(Form("%s/clustersXY.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
     }
 
     if (mQATasks & taskClusterCounts) {
@@ -3065,8 +3065,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         mCClRej[i]->cd();
         snprintf(name, 2048, "%s/clustersRej%d%s.pdf", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i]);
         mCClRej[i]->Print(name);
-        if (mConfig.writeRootFiles) {
-          snprintf(name, 2048, "%s/clustersRej%d%s.root", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i]);
+        if (mConfig.writeFileExt != "") {
+          snprintf(name, 2048, "%s/clustersRej%d%s.%s", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i], mConfig.writeFileExt.c_str());
           mCClRej[i]->Print(name);
         }
       }
@@ -3105,9 +3105,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         e->GetYaxis()->SetTitle("Rejected Clusters (fraction)");
         e->Draw(k == 0 ? "" : "same");
       }
-      mPClRejP->Print(Form("%s/clustersRejProjected.pdf", mConfig.plotsDir.c_str())); // TODO: Add option to write pngs
-      if (mConfig.writeRootFiles) {
-        mPClRejP->Print(Form("%s/clustersRejProjected.root", mConfig.plotsDir.c_str()));
+      mPClRejP->Print(Form("%s/clustersRejProjected.pdf", mConfig.plotsDir.c_str()));
+      if (mConfig.writeFileExt != "") {
+        mPClRejP->Print(Form("%s/clustersRejProjected.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
       }
     }
   }
@@ -3131,7 +3131,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
   if (!qcout) {
     clearGarbagageCollector();
   }
-  GPUInfo("GPU TPC QA histograms have been written to %s files", mConfig.writeRootFiles ? ".pdf and .root" : ".pdf");
+  GPUInfo("GPU TPC QA histograms have been written to pdf%s%s files", (mConfig.writeFileExt == "" ? "" : " and ", mConfig.writeFileExt.c_str());
   gErrorIgnoreLevel = oldRootIgnoreLevel;
   return (0);
 }

From f75706c4f8a2ba6a6c792a101946f7c6092b624c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 2 Dec 2025 22:18:23 +0100
Subject: [PATCH 1096/1764] GPU QA: Get rid of several sprintf

---
 GPU/GPUTracking/qa/GPUQA.cxx | 110 +++++++++++++----------------------
 1 file changed, 39 insertions(+), 71 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 6adcd975ec45f..689dc20cb1606 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -2118,10 +2118,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     // Create Canvas / Pads for Efficiency Histograms
     if (mQATasks & taskTrackingEff) {
       for (int32_t ii = 0; ii < 6; ii++) {
-        int32_t i = ii == 5 ? 4 : ii;
-        snprintf(fname, 1024, "eff_vs_%s_layout", VSPARAMETER_NAMES[ii]);
-        snprintf(name, 2048, "Efficiency versus %s", VSPARAMETER_NAMES[i]);
-        mCEff[ii] = createGarbageCollected<TCanvas>(fname, name, 0, 0, 700, 700. * 2. / 3.);
+        snprintf(name, 1024, "eff_vs_%s_layout", VSPARAMETER_NAMES[ii]);
+        mCEff[ii] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCEff[ii]->cd();
         float dy = 1. / 2.;
         mPEff[ii][0] = createGarbageCollected<TPad>("p0", "", 0.0, dy * 0, 0.5, dy * 1);
@@ -2144,15 +2142,12 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     // Create Canvas / Pads for Resolution Histograms
     if (mQATasks & taskTrackingRes) {
       for (int32_t ii = 0; ii < 7; ii++) {
-        int32_t i = ii == 5 ? 4 : ii;
         if (ii == 6) {
-          snprintf(fname, 1024, "res_integral_layout");
-          snprintf(name, 2048, "Integral Resolution");
+          snprintf(name, 1024, "res_integral_layout");
         } else {
-          snprintf(fname, 1024, "res_vs_%s_layout", VSPARAMETER_NAMES[ii]);
-          snprintf(name, 2048, "Resolution versus %s", VSPARAMETER_NAMES[i]);
+          snprintf(name, 1024, "res_vs_%s_layout", VSPARAMETER_NAMES[ii]);
         }
-        mCRes[ii] = createGarbageCollected<TCanvas>(fname, name, 0, 0, 700, 700. * 2. / 3.);
+        mCRes[ii] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCRes[ii]->cd();
         gStyle->SetOptFit(1);
 
@@ -2185,16 +2180,12 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     // Create Canvas / Pads for Pull Histograms
     if (mQATasks & taskTrackingResPull) {
       for (int32_t ii = 0; ii < 7; ii++) {
-        int32_t i = ii == 5 ? 4 : ii;
-
         if (ii == 6) {
-          snprintf(fname, 1024, "pull_integral_layout");
-          snprintf(name, 2048, "Integral Pull");
+          snprintf(name, 1024, "pull_integral_layout");
         } else {
-          snprintf(fname, 1024, "pull_vs_%s_layout", VSPARAMETER_NAMES[ii]);
-          snprintf(name, 2048, "Pull versus %s", VSPARAMETER_NAMES[i]);
+          snprintf(name, 1024, "pull_vs_%s_layout", VSPARAMETER_NAMES[ii]);
         }
-        mCPull[ii] = createGarbageCollected<TCanvas>(fname, name, 0, 0, 700, 700. * 2. / 3.);
+        mCPull[ii] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCPull[ii]->cd();
         gStyle->SetOptFit(1);
 
@@ -2227,8 +2218,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     // Create Canvas for Cluster Histos
     if (mQATasks & taskClusterAttach) {
       for (int32_t i = 0; i < 3; i++) {
-        snprintf(fname, 1024, "clusters_%s_layout", CLUSTER_TYPES[i]);
-        mCClust[i] = createGarbageCollected<TCanvas>(fname, CLUSTER_TITLES[i], 0, 0, 700, 700. * 2. / 3.);
+        snprintf(name, 1024, "clusters_%s_layout", CLUSTER_TYPES[i]);
+        mCClust[i] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCClust[i]->cd();
         mPClust[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
         mPClust[i]->Draw();
@@ -2240,7 +2231,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
 
     // Create Canvas for track statistic histos
     if (mQATasks & taskTrackStatistics) {
-      mCTracks = createGarbageCollected<TCanvas>("ctrackspt", "Track Pt", 0, 0, 700, 700. * 2. / 3.);
+      mCTracks = createGarbageCollected<TCanvas>("ctrackspt", "ctrackspt", 0, 0, 700, 700. * 2. / 3.);
       mCTracks->cd();
       mPTracks = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPTracks->Draw();
@@ -2249,7 +2240,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
 
       for (int32_t i = 0; i < 2; i++) {
         snprintf(name, 2048, "ctrackst0%d", i);
-        mCT0[i] = createGarbageCollected<TCanvas>(name, "Track T0", 0, 0, 700, 700. * 2. / 3.);
+        mCT0[i] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCT0[i]->cd();
         mPT0[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
         mPT0[i]->Draw();
@@ -2257,7 +2248,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         SetLegend(mLT0[i]);
 
         snprintf(name, 2048, "cncl%d", i);
-        mCNCl[i] = createGarbageCollected<TCanvas>(name, i ? "Number of clusters (corrected for multiple per row)" : "Number of clusters per track", 0, 0, 700, 700. * 2. / 3.);
+        mCNCl[i] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCNCl[i]->cd();
         mPNCl[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
         mPNCl[i]->Draw();
@@ -2265,26 +2256,26 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         SetLegend(mLNCl[i], true);
       }
 
-      mCClXY = createGarbageCollected<TCanvas>("clxy", "Number of clusters per X / Y", 0, 0, 700, 700. * 2. / 3.);
+      mCClXY = createGarbageCollected<TCanvas>("clxy", "clxy", 0, 0, 700, 700. * 2. / 3.);
       mCClXY->cd();
       mPClXY = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPClXY->Draw();
 
       for (int32_t i = 0; i < 3; i++) {
         snprintf(name, 2048, "cnclrej%d", i);
-        mCClRej[i] = createGarbageCollected<TCanvas>(name, i == 0 ? "Number of clusters" : (i == 1 ? "Rejected Clusters" : "Fraction of Rejected Clusters"), 0, 0, 700, 700. * 2. / 3.);
+        mCClRej[i] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCClRej[i]->cd();
         mPClRej[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
         mPClRej[i]->Draw();
       }
-      mCClRejP = createGarbageCollected<TCanvas>("cnclrejp", "Fraction of Rejected Clusters", 0, 0, 700, 700. * 2. / 3.);
+      mCClRejP = createGarbageCollected<TCanvas>("cnclrejp", "cnclrejp", 0, 0, 700, 700. * 2. / 3.);
       mCClRejP->cd();
       mPClRejP = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPClRejP->Draw();
 
       for (int32_t i = 0; i < 3; i++) {
         snprintf(name, 2048, "cpadrow%d", i);
-        mCPadRow[i] = createGarbageCollected<TCanvas>(name, "First Track Pad Row", 0, 0, 700, 700. * 2. / 3.);
+        mCPadRow[i] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCPadRow[i]->cd();
         mPPadRow[i] = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
         mPPadRow[i]->Draw();
@@ -2370,8 +2361,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
             e->Draw(k || l ? "same P" : "AP");
             if (j == 0) {
               GetName(fname, k);
-              snprintf(name, 2048, "%s%s", fname, EFF_NAMES[l]);
-              mLEff[ii]->AddEntry(e, name, "l");
+              mLEff[ii]->AddEntry(e, Form("%s%s", fname, EFF_NAMES[l]), "l");
             }
           }
           if (!mConfig.enableLocalOutput && !mConfig.shipToQCAsCanvas) {
@@ -2503,10 +2493,8 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
             if (mConfig.inputHistogramsOnly) {
               dstIntegral = createGarbageCollected<TH1D>();
             }
-            snprintf(fname, 1024, p ? "IntPull%s" : "IntRes%s", VSPARAMETER_NAMES[j]);
-            snprintf(name, 2048, p ? "%s Pull" : "%s Resolution", p || mConfig.nativeFitResolutions ? PARAMETER_NAMES_NATIVE[j] : PARAMETER_NAMES[j]);
-            dstIntegral->SetName(fname);
-            dstIntegral->SetTitle(name);
+            dstIntegral->SetName(Form(p ? "IntPull%s" : "IntRes%s", VSPARAMETER_NAMES[j]));
+            dstIntegral->SetTitle(Form(p ? "%s Pull" : "%s Resolution", p || mConfig.nativeFitResolutions ? PARAMETER_NAMES_NATIVE[j] : PARAMETER_NAMES[j]));
           }
           if (mConfig.enableLocalOutput || mConfig.shipToQCAsCanvas) {
             pad->cd();
@@ -2557,8 +2545,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
             for (int32_t l = 0; l < 2; l++) {
               TH1F* e = dst[l];
               if (!mConfig.inputHistogramsOnly && k == 0) {
-                snprintf(name, 2048, p ? "%s Pull" : "%s Resolution", p || mConfig.nativeFitResolutions ? PARAMETER_NAMES_NATIVE[j] : PARAMETER_NAMES[j]);
-                e->SetTitle(name);
+                e->SetTitle(Form(p ? "%s Pull" : "%s Resolution", p || mConfig.nativeFitResolutions ? PARAMETER_NAMES_NATIVE[j] : PARAMETER_NAMES[j]));
                 e->SetStats(kFALSE);
                 if (tout) {
                   if (l == 0) {
@@ -2598,12 +2585,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
               e->Draw(k || l ? "same" : "");
               if (j == 0) {
                 GetName(fname, k);
-                if (p) {
-                  snprintf(name, 2048, "%s%s", fname, l ? "Mean" : "Pull");
-                } else {
-                  snprintf(name, 2048, "%s%s", fname, l ? "Mean" : "Resolution");
-                }
-                leg->AddEntry(e, name, "l");
+                leg->AddEntry(e, Form("%s%s", fname, l ? "Mean" : (p ? "Pull" : "Resolution")), "l");
               }
             }
           }
@@ -2823,8 +2805,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
           e->SetLineColor(colorNums[numColor++ % COLORCOUNT]);
           e->Draw(j == end - 1 && k == 0 ? "" : "same");
           GetName(fname, k);
-          snprintf(name, 2048, "%s%s", fname, CLUSTER_NAMES[j - begin]);
-          mLClust[i]->AddEntry(e, name, "l");
+          mLClust[i]->AddEntry(e, Form("%s%s", fname, CLUSTER_NAMES[j - begin]), "l");
         }
       }
       if (ConfigNumInputs == 1) {
@@ -2868,17 +2849,15 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
       mPPadRow[i]->cd();
       e->SetOption("colz");
-      e->SetTitle(i == 2 ? "First Track Pad Row (row_{MC} = 0, row_{trk} #ne 0)" : "First Track Pad Row");
-      e->GetXaxis()->SetTitle(i ? "Phi (sector)" : "First MC Pad Row");
+      e->SetTitle(i == 2 ? "First Track Pad Row (row_{MC} = 0, row_{trk} > 0)" : "First Track Pad Row");
+      e->GetXaxis()->SetTitle(i ? "#Phi (sector)" : "First MC Pad Row");
       e->GetYaxis()->SetTitle("First Pad Row");
       e->Draw();
       mCPadRow[i]->cd();
       static const constexpr char* PADROW_NAMES[3] = {"MC", "Phi", "Phi1"};
-      snprintf(name, 2048, "%s/padRow%s.pdf", mConfig.plotsDir.c_str(), PADROW_NAMES[i]);
-      mCPadRow[i]->Print(name);
+      mCPadRow[i]->Print(Form("%s/padRow%s.pdf", mConfig.plotsDir.c_str(), PADROW_NAMES[i]));
       if (mConfig.writeFileExt != "") {
-        snprintf(name, 2048, "%s/padRow%s.%s", mConfig.plotsDir.c_str(), PADROW_NAMES[i], mConfig.writeFileExt.c_str());
-        mCPadRow[i]->Print(name);
+        mCPadRow[i]->Print(Form("%s/padRow%s.%s", mConfig.plotsDir.c_str(), PADROW_NAMES[i], mConfig.writeFileExt.c_str()));
       }
     }
   }
@@ -2935,8 +2914,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       e->SetLineColor(colorNums[k % COLORCOUNT]);
       e->Draw(k == 0 ? "" : "same");
       GetName(fname, k, mConfig.inputHistogramsOnly);
-      snprintf(name, 2048, mConfig.inputHistogramsOnly ? "%s" : "%sTrack #it{p}_{T}", fname);
-      mLTracks->AddEntry(e, name, "l");
+      mLTracks->AddEntry(e, Form(mConfig.inputHistogramsOnly ? "%s" : "%sTrack #it{p}_{T}", fname), "l");
     }
     mLTracks->Draw();
     doPerfFigure(0.63, 0.7, 0.030);
@@ -2981,17 +2959,14 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         e->SetLineColor(colorNums[k % COLORCOUNT]);
         e->Draw(k == 0 ? "" : "same");
         GetName(fname, k, mConfig.inputHistogramsOnly);
-        snprintf(name, 2048, mConfig.inputHistogramsOnly ? "%s (%s)" : "%sTrack t_{0} %s", fname, i ? "" : "resolution");
-        mLT0[i]->AddEntry(e, name, "l");
+        mLT0[i]->AddEntry(e, Form(mConfig.inputHistogramsOnly ? "%s (%s)" : "%sTrack t_{0} %s", fname, i ? "" : "resolution"), "l");
       }
       mLT0[i]->Draw();
       doPerfFigure(0.63, 0.7, 0.030);
       mCT0[i]->cd();
-      snprintf(name, 2048, "%s/t0%s.pdf", mConfig.plotsDir.c_str(), i ? "_res" : "");
-      mCT0[i]->Print(name);
+      mCT0[i]->Print(Form("%s/t0%s.pdf", mConfig.plotsDir.c_str(), i ? "_res" : ""));
       if (mConfig.writeFileExt != "") {
-        snprintf(name, 2048, "%s/t0%s.%s", mConfig.plotsDir.c_str(), i ? "_res" : "", mConfig.writeFileExt.c_str());
-        mCT0[i]->Print(name);
+        mCT0[i]->Print(Form("%s/t0%s.%s", mConfig.plotsDir.c_str(), i ? "_res" : "", mConfig.writeFileExt.c_str()));
       }
 
       tmpMax = 0.;
@@ -3028,17 +3003,14 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         e->SetLineColor(colorNums[k % COLORCOUNT]);
         e->Draw(k == 0 ? "" : "same");
         GetName(fname, k, mConfig.inputHistogramsOnly);
-        snprintf(name, 2048, mConfig.inputHistogramsOnly ? "%s" : (i ? "%sN_{Clusters}" : "%sN_{Rows with Clusters}"), fname);
-        mLNCl[i]->AddEntry(e, name, "l");
+        mLNCl[i]->AddEntry(e, Form(mConfig.inputHistogramsOnly ? "%s" : (i ? "%sN_{Clusters}" : "%sN_{Rows with Clusters}"), fname), "l");
       }
       mLNCl[i]->Draw();
       doPerfFigure(0.6, 0.7, 0.030);
       mCNCl[i]->cd();
-      snprintf(name, 2048, "%s/nClusters%s.pdf", mConfig.plotsDir.c_str(), i ? "_corrected" : "");
-      mCNCl[i]->Print(name);
+      mCNCl[i]->Print(Form("%s/nClusters%s.pdf", mConfig.plotsDir.c_str(), i ? "_corrected" : ""));
       if (mConfig.writeFileExt != "") {
-        snprintf(name, 2048, "%s/nClusters%s.%s", mConfig.plotsDir.c_str(), i ? "_corrected" : "", mConfig.writeFileExt.c_str());
-        mCNCl[i]->Print(name);
+        mCNCl[i]->Print(Form("%s/nClusters%s.%s", mConfig.plotsDir.c_str(), i ? "_corrected" : "", mConfig.writeFileExt.c_str()));
       }
     }
 
@@ -3063,11 +3035,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         mClRej[i]->SetOption("colz");
         mClRej[i]->Draw();
         mCClRej[i]->cd();
-        snprintf(name, 2048, "%s/clustersRej%d%s.pdf", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i]);
-        mCClRej[i]->Print(name);
+        mCClRej[i]->Print(Form("%s/clustersRej%d%s.pdf", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i]));
         if (mConfig.writeFileExt != "") {
-          snprintf(name, 2048, "%s/clustersRej%d%s.%s", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i], mConfig.writeFileExt.c_str());
-          mCClRej[i]->Print(name);
+          mCClRej[i]->Print(Form("%s/clustersRej%d%s.%s", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i], mConfig.writeFileExt.c_str()));
         }
       }
 
@@ -3077,15 +3047,13 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         if (GetHist(tmp, tin, k, nNewInput) == nullptr) {
           continue;
         }
-        snprintf(name, 2048, "clrejptmp1%d", k); // TODO: Clean up names, and how names are written to char arrays
-        TH1D* proj1 = tmp->ProjectionY(name);
+        TH1D* proj1 = tmp->ProjectionY(Form("clrejptmp1%d", k)); // TODO: Clean up names
         proj1->SetDirectory(nullptr);
         tmp = mClRej[1];
         if (GetHist(tmp, tin, k, nNewInput) == nullptr) {
           continue;
         }
-        snprintf(name, 2048, "clrejptmp2%d", k); // TODO: Clean up names, and how names are written to char arrays
-        TH1D* proj2 = tmp->ProjectionY(name);
+        TH1D* proj2 = tmp->ProjectionY(Form("clrejptmp2%d", k));
         proj2->SetDirectory(nullptr);
 
         auto* e = mClRejP;
@@ -3131,7 +3099,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
   if (!qcout) {
     clearGarbagageCollector();
   }
-  GPUInfo("GPU TPC QA histograms have been written to pdf%s%s files", (mConfig.writeFileExt == "" ? "" : " and ", mConfig.writeFileExt.c_str());
+  GPUInfo("GPU TPC QA histograms have been written to pdf%s%s files", mConfig.writeFileExt == "" ? "" : " and ", mConfig.writeFileExt.c_str());
   gErrorIgnoreLevel = oldRootIgnoreLevel;
   return (0);
 }

From c93179f2f80d6ab30e03cdd00d1fe68b89ed9dbf Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Mon, 1 Dec 2025 14:14:33 +0100
Subject: [PATCH 1097/1764] GPU: Unify GPU and CPU versions of TPC ZS decoders.

---
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     | 221 +-----------------
 .../TPCClusterFinder/GPUTPCCFDecodeZS.h       |  11 +-
 2 files changed, 7 insertions(+), 225 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index 7ba32bd43275b..67a3083d4a1ce 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -251,8 +251,7 @@ GPUd() size_t GPUTPCCFDecodeZSLink::DecodePage(GPUSharedMemory& smem, DecodeCtx&
     if (discardTimeBin) {
       FillWithInvalid(ctx.clusterer, ctx.iThread, ctx.nThreads, ctx.pageDigitOffset, nAdc);
     } else {
-#ifdef GPUCA_GPUCODE
-      DecodeTBMultiThread(
+      DecodeTB(
         smem,
         ctx,
         adcData,
@@ -261,16 +260,6 @@ GPUd() size_t GPUTPCCFDecodeZSLink::DecodePage(GPUSharedMemory& smem, DecodeCtx&
         timeBin,
         decHdr->cruID,
         tbHdr->fecInPartition);
-#else // CPU
-      DecodeTBSingleThread(
-        ctx,
-        adcData,
-        nAdc,
-        channelMask,
-        timeBin,
-        decHdr->cruID,
-        tbHdr->fecInPartition);
-#endif
     }
 
     ctx.pageDigitOffset += nAdc;
@@ -290,62 +279,7 @@ GPUd() size_t GPUTPCCFDecodeZSLink::DecodePage(GPUSharedMemory& smem, DecodeCtx&
   return ctx.pageDigitOffset;
 }
 
-GPUd() void GPUTPCCFDecodeZSLink::DecodeTBSingleThread(
-  DecodeCtx& ctx,
-  const uint8_t* adcData,
-  uint32_t nAdc,
-  const uint32_t* channelMask,
-  int32_t timeBin,
-  int32_t cru,
-  int32_t fecInPartition)
-{
-  const CfFragment& fragment = ctx.clusterer.mPmemory->fragment;
-
-  if constexpr (TPCZSHDRV2::TIGHTLY_PACKED_V3) {
-
-    uint32_t byte = 0, bits = 0, nSamplesWritten = 0, rawFECChannel = 0;
-
-    // unpack adc values, assume tightly packed data
-    while (nSamplesWritten < nAdc) {
-      byte |= adcData[0] << bits;
-      adcData++;
-      bits += CHAR_BIT;
-      while (bits >= DECODE_BITS) {
-
-        // Find next channel with data
-        for (; !ChannelIsActive(channelMask, rawFECChannel); rawFECChannel++) {
-        }
-
-        // Unpack data for cluster finder
-        o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(ctx.clusterer, cru, rawFECChannel, fecInPartition);
-
-        WriteCharge(ctx.clusterer, byte, padAndRow, fragment.toLocal(timeBin), ctx.pageDigitOffset + nSamplesWritten);
-
-        byte = byte >> DECODE_BITS;
-        bits -= DECODE_BITS;
-        nSamplesWritten++;
-        rawFECChannel++; // Ensure we don't decode same channel twice
-      } // while (bits >= DECODE_BITS)
-    } // while (nSamplesWritten < nAdc)
-
-  } else { // ! TPCZSHDRV2::TIGHTLY_PACKED_V3
-    uint32_t rawFECChannel = 0;
-    const uint64_t* adcData64 = (const uint64_t*)adcData;
-    for (uint32_t j = 0; j < nAdc; j++) {
-      for (; !ChannelIsActive(channelMask, rawFECChannel); rawFECChannel++) {
-      }
-
-      uint32_t adc = (adcData64[j / TPCZSHDRV2::SAMPLESPER64BIT] >> ((j % TPCZSHDRV2::SAMPLESPER64BIT) * DECODE_BITS)) & DECODE_MASK;
-
-      o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(ctx.clusterer, cru, rawFECChannel, fecInPartition);
-      float charge = ADCToFloat(adc, DECODE_MASK, DECODE_BITS_FACTOR);
-      WriteCharge(ctx.clusterer, charge, padAndRow, fragment.toLocal(timeBin), ctx.pageDigitOffset + j);
-      rawFECChannel++;
-    }
-  }
-}
-
-GPUd() void GPUTPCCFDecodeZSLink::DecodeTBMultiThread(
+GPUd() void GPUTPCCFDecodeZSLink::DecodeTB(
   GPUSharedMemory& smem,
   DecodeCtx& ctx,
   const uint8_t* adcData,
@@ -601,12 +535,6 @@ GPUd() void GPUTPCCFDecodeZSDenseLink::Thread<0>(int32_t nBlocks, int32_t nThrea
 
 GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, DecodeCtx& ctx)
 {
-#ifdef GPUCA_GPUCODE
-  constexpr bool DecodeInParallel = true;
-#else
-  constexpr bool DecodeInParallel = false;
-#endif
-
   const uint8_t* const pageStart = ctx.page;
 
   const auto* rawDataHeader = Peek<header::RAWDataHeader>(ctx.page);
@@ -651,13 +579,13 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, Dec
       }
 
       if ((uint16_t)(raw::RDHUtils::getPageCounter(rawDataHeader) + 1) == raw::RDHUtils::getPageCounter(nextPage)) {
-        nSamplesWrittenTB = DecodeTB<DecodeInParallel, true>(smem, ctx, rawDataHeader, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
+        nSamplesWrittenTB = DecodeTB<true>(smem, ctx, rawDataHeader, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
       } else {
         err = GPUErrors::ERROR_TPCZS_INCOMPLETE_HBF;
         break;
       }
     } else {
-      nSamplesWrittenTB = DecodeTB<DecodeInParallel, false>(smem, ctx, rawDataHeader, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
+      nSamplesWrittenTB = DecodeTB<false>(smem, ctx, rawDataHeader, decHeader->cruID, nSamplesLeftInPage, payloadEnd, nextPage);
     }
 
     // Abort decoding the page if an error was detected.
@@ -712,30 +640,8 @@ GPUd() uint32_t GPUTPCCFDecodeZSDenseLink::DecodePage(GPUSharedMemory& smem, Dec
   return ctx.pageDigitOffset;
 }
 
-template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
-  [[maybe_unused]] GPUSharedMemory& smem,
-  DecodeCtx& ctx,
-  const header::RAWDataHeader* rawDataHeader,
-  int32_t cru,
-  uint16_t nSamplesLeftInPage,
-  const uint8_t* payloadEnd,
-  const uint8_t* nextPage)
-{
-
-  if constexpr (DecodeInParallel) {
-    return DecodeTBMultiThread<PayloadExtendsToNextPage>(smem, ctx, rawDataHeader, cru, nSamplesLeftInPage, payloadEnd, nextPage);
-  } else {
-    int16_t nSamplesWritten = 0;
-    if (ctx.iThread == 0) {
-      nSamplesWritten = DecodeTBSingleThread<PayloadExtendsToNextPage>(ctx, rawDataHeader, cru, nSamplesLeftInPage, payloadEnd, nextPage);
-    }
-    return warp_broadcast(nSamplesWritten, 0);
-  }
-}
-
 template <bool PayloadExtendsToNextPage>
-GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
+GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
   GPUSharedMemory& smem,
   DecodeCtx& ctx,
   const header::RAWDataHeader* rawDataHeader,
@@ -883,123 +789,6 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBMultiThread(
 #undef MAYBE_PAGE_OVERFLOW
 }
 
-template <bool PayloadExtendsToNextPage>
-GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTBSingleThread(
-  DecodeCtx& ctx,
-  const header::RAWDataHeader* rawDataHeader,
-  int32_t cru,
-  uint16_t nSamplesLeftInPage,
-  const uint8_t* payloadEnd,
-  const uint8_t* nextPage)
-{
-#define MAYBE_PAGE_OVERFLOW(pagePtr)                               \
-  if constexpr (PayloadExtendsToNextPage) {                        \
-    if (pagePtr >= payloadEnd && pagePtr < nextPage) {             \
-      ptrdiff_t diff = pagePtr - payloadEnd;                       \
-      pagePtr = nextPage;                                          \
-      ConsumeBytes(pagePtr, sizeof(header::RAWDataHeader) + diff); \
-    }                                                              \
-  } else {                                                         \
-    if (pagePtr > payloadEnd) {                                    \
-      return -GPUErrors::ERROR_TPCZS_PAGE_OVERFLOW;                \
-    }                                                              \
-  }
-
-  using zerosupp_link_based::ChannelPerTBHeader;
-
-  const CfFragment& fragment = ctx.clusterer.mPmemory->fragment;
-
-  uint8_t linkIds[MaxNLinksPerTimebin];
-  uint8_t channelMasks[MaxNLinksPerTimebin * 10] = {0};
-  uint16_t nSamplesWritten = 0;
-
-  // Read timebin block header
-  uint16_t tbbHdr = ConsumeByte(ctx.page);
-  MAYBE_PAGE_OVERFLOW(ctx.page);
-  tbbHdr |= static_cast<uint16_t>(ConsumeByte(ctx.page)) << CHAR_BIT;
-  MAYBE_PAGE_OVERFLOW(ctx.page);
-
-  uint8_t nLinksInTimebin = tbbHdr & 0x000F;
-  uint16_t linkBC = (tbbHdr & 0xFFF0) >> 4;
-  int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - ctx.firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
-
-  uint16_t nSamplesInTB = 0;
-
-  // Read timebin link headers
-  for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++) {
-    uint8_t timebinLinkHeaderStart = ConsumeByte(ctx.page);
-    MAYBE_PAGE_OVERFLOW(ctx.page);
-
-    linkIds[iLink] = timebinLinkHeaderStart & 0b00011111;
-
-    bool bitmaskIsFlat = timebinLinkHeaderStart & 0b00100000;
-
-    uint16_t bitmaskL2 = 0x0FFF;
-    if (not bitmaskIsFlat) {
-      bitmaskL2 = static_cast<uint16_t>(timebinLinkHeaderStart & 0b11000000) << 2 | static_cast<uint16_t>(ConsumeByte(ctx.page));
-      MAYBE_PAGE_OVERFLOW(ctx.page);
-    }
-
-    for (int32_t i = 0; i < 10; i++) {
-      if (bitmaskL2 & 1 << i) {
-        nSamplesInTB += CAMath::Popcount(*Peek(ctx.page));
-        channelMasks[10 * iLink + i] = ConsumeByte(ctx.page);
-        MAYBE_PAGE_OVERFLOW(ctx.page);
-      }
-    }
-
-  } // for (uint8_t iLink = 0; iLink < nLinksInTimebin; iLink++)
-
-  if (nSamplesInTB > nSamplesLeftInPage) {
-    return -GPUErrors::ERROR_TPCZS_INVALID_NADC;
-  }
-
-  const uint8_t* adcData = ConsumeBytes(ctx.page, (nSamplesInTB * DECODE_BITS + 7) / 8);
-  MAYBE_PAGE_OVERFLOW(ctx.page);
-
-  bool discardTimeBin = not fragment.contains(timeBin);
-  discardTimeBin |= (ctx.tpcTimeBinCut > 0 && timeBin > ctx.tpcTimeBinCut);
-
-  if (discardTimeBin) {
-    return FillWithInvalid(ctx.clusterer, 0, 1, ctx.pageDigitOffset, nSamplesInTB);
-  }
-
-  // Unpack ADC
-  uint32_t byte = 0, bits = 0;
-  uint16_t rawFECChannel = 0;
-
-  // unpack adc values, assume tightly packed data
-  while (nSamplesWritten < nSamplesInTB) {
-    byte |= static_cast<uint32_t>(ConsumeByte(adcData)) << bits;
-    MAYBE_PAGE_OVERFLOW(adcData);
-    bits += CHAR_BIT;
-    while (bits >= DECODE_BITS) {
-
-      // Find next channel with data
-      for (; !ChannelIsActive(channelMasks, rawFECChannel); rawFECChannel++) {
-      }
-
-      int32_t iLink = rawFECChannel / ChannelPerTBHeader;
-      int32_t rawFECChannelLink = rawFECChannel % ChannelPerTBHeader;
-
-      // Unpack data for cluster finder
-      o2::tpc::PadPos padAndRow = GetPadAndRowFromFEC(ctx.clusterer, cru, rawFECChannelLink, linkIds[iLink]);
-
-      float charge = ADCToFloat(byte, DECODE_MASK, DECODE_BITS_FACTOR);
-      WriteCharge(ctx.clusterer, charge, padAndRow, fragment.toLocal(timeBin), ctx.pageDigitOffset + nSamplesWritten);
-
-      byte >>= DECODE_BITS;
-      bits -= DECODE_BITS;
-      nSamplesWritten++;
-      rawFECChannel++; // Ensure we don't decode same channel twice
-    } // while (bits >= DECODE_BITS)
-  } // while (nSamplesWritten < nAdc)
-
-  return nSamplesWritten;
-
-#undef MAYBE_PAGE_OVERFLOW
-}
-
 GPUd() bool GPUTPCCFDecodeZSDenseLink::ChannelIsActive(const uint8_t* chan, uint16_t chanIndex)
 {
   constexpr uint8_t N_BITS_PER_ENTRY = sizeof(*chan) * CHAR_BIT;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
index 750df643f2d10..b8d8765e0b2f2 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
@@ -148,8 +148,7 @@ class GPUTPCCFDecodeZSLink : public GPUTPCCFDecodeZSLinkBase
   GPUd() static void GetChannelBitmask(const tpc::zerosupp_link_based::CommonHeader& tbHdr, uint32_t* chan);
   GPUd() static bool ChannelIsActive(const uint32_t* chan, uint8_t chanIndex);
 
-  GPUd() static void DecodeTBSingleThread(DecodeCtx& ctx, const uint8_t* adcData, uint32_t nAdc, const uint32_t* channelMask, int32_t timeBin, int32_t cru, int32_t fecInPartition);
-  GPUd() static void DecodeTBMultiThread(GPUSharedMemory& smem, DecodeCtx& ctx, const uint8_t* adcData, uint32_t nAdc, const uint32_t* channelMask, int32_t timeBin, int32_t cru, int32_t fecInPartition);
+  GPUd() static void DecodeTB(GPUSharedMemory& smem, DecodeCtx& ctx, const uint8_t* adcData, uint32_t nAdc, const uint32_t* channelMask, int32_t timeBin, int32_t cru, int32_t fecInPartition);
 };
 
 class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
@@ -179,14 +178,8 @@ class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
   // Decode a single timebin within an 8kb page.
   // Returns the number of samples decoded from the page
   // or negative value to indicate an error (no samples are written in this case)
-  template <bool DecodeInParallel, bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTB(GPUSharedMemory& smem, DecodeCtx& ctx, const header::RAWDataHeader* rawDataHeader, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
-
   template <bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTBSingleThread(DecodeCtx& ctx, const header::RAWDataHeader* rawDataHeader, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
-
-  template <bool PayloadExtendsToNextPage>
-  GPUd() static int16_t DecodeTBMultiThread(GPUSharedMemory& smem, DecodeCtx& ctx, const header::RAWDataHeader* rawDataHeader, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
+  GPUd() static int16_t DecodeTB(GPUSharedMemory& smem, DecodeCtx& ctx, const header::RAWDataHeader* rawDataHeader, int32_t cru, uint16_t nSamplesLeftInPage, const uint8_t* payloadEnd, const uint8_t* nextPage);
 };
 
 } // namespace o2::gpu

From 3563a504b0b34b3e6243a897639b123dbba20ad0 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Mon, 1 Dec 2025 14:15:48 +0100
Subject: [PATCH 1098/1764] GPU: Remove unused code in ZS decoder.

---
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     | 33 +------------------
 .../TPCClusterFinder/GPUTPCCFDecodeZS.h       |  2 +-
 2 files changed, 2 insertions(+), 33 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index 67a3083d4a1ce..e20f5d8b0f074 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -23,6 +23,7 @@
 #include "TPCPadGainCalib.h"
 #include "TPCZSLinkMapping.h"
 #include "GPUTPCGeometry.h"
+#include "DetectorsRaw/RDHUtils.h"
 
 using namespace o2::gpu;
 using namespace o2::gpu::tpccf;
@@ -302,26 +303,6 @@ GPUd() void GPUTPCCFDecodeZSLink::DecodeTB(
     uint8_t myOffset = warp_scan_inclusive_add(myChannelActive) - 1 + blockOffset;
     blockOffset = warp_broadcast(myOffset, NTHREADS - 1) + 1;
 
-    // Decode entire timebin at once if we have enough threads
-    // This should further improve performance, but code below is buggy...
-    // if (nAdc <= NThreads) {
-    //   for (int32_t j = 1; blockOffset < nAdc; j++) {
-    //     rawFECChannel = myChannelActive ? rawFECChannel : (iThread + j*NThreads - myOffset);
-
-    //     bool iAmIdle = not myChannelActive;
-
-    //     myChannelActive =
-    //       rawFECChannel < zerosupp_link_based::CommonHeaderlPerTBHeader
-    //         ? BitIsSet(channelMask, rawFECChannel)
-    //         : false;
-
-    //     uint8_t newOffset = warp_scan_inclusive_add(static_cast<uint8_t>(myChannelActive && iAmIdle)) - 1 + blockOffset;
-    //     blockOffset = warp_broadcast(newOffset, NThreads - 1) + 1;
-
-    //     myOffset = iAmIdle ? newOffset : myOffset;
-    //   }
-    // }
-
     if (not myChannelActive) {
       continue;
     }
@@ -331,28 +312,16 @@ GPUd() void GPUTPCCFDecodeZSLink::DecodeTB(
 
     if constexpr (TPCZSHDRV2::TIGHTLY_PACKED_V3) {
 
-      // Try to access adcData with 4 byte reads instead of 1 byte.
-      // You'd think this would improve performace, but it's actually slower...
-      // const uint32_t* adcDataU32 = reinterpret_cast<const uint32_t*>(adcData);
-
       uint32_t adcBitOffset = myOffset * DECODE_BITS;
       uint32_t adcByteOffset = adcBitOffset / CHAR_BIT;
       uint32_t adcOffsetInByte = adcBitOffset - adcByteOffset * CHAR_BIT;
-      // uint32_t adcByteOffset = adcBitOffset / 32;
-      // uint32_t adcOffsetInByte = adcBitOffset - adcByteOffset * 32;
 
       uint32_t byte = 0, bits = 0;
 
-      // uint32_t byte = adcDataU32[adcByteOffset] >> adcOffsetInByte;
-      // uint32_t bits = 32 - adcOffsetInByte;
-      // adcByteOffset++;
-
       while (bits < DECODE_BITS) {
         byte |= ((uint32_t)adcData[adcByteOffset]) << bits;
-        // byte |= adcDataU32[adcByteOffset] << bits;
         adcByteOffset++;
         bits += CHAR_BIT;
-        // bits += 32;
       }
       adc = byte >> adcOffsetInByte;
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
index b8d8765e0b2f2..c633a5ebc2774 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
@@ -21,7 +21,7 @@
 #include "TPCBase/PadPos.h"
 #include "DataFormatsTPC/ZeroSuppression.h"
 #include "DataFormatsTPC/ZeroSuppressionLinkBased.h"
-#include "DetectorsRaw/RDHUtils.h"
+#include "Headers/RAWDataHeader.h"
 
 namespace o2::gpu
 {

From 1108c25afcf1d842c4c139c5a64a692fa7a79054 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 1 Dec 2025 14:22:39 +0100
Subject: [PATCH 1099/1764] ITS: GPU: adapt seed refit

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  10 +-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  16 +-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 196 +++++++++++++-----
 .../include/ITStracking/Configuration.h       |   4 +-
 .../include/ITStracking/TrackerTraits.h       |   2 +-
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |   4 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  40 ++--
 7 files changed, 180 insertions(+), 92 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 69d6799686654..a4e4328b3aa22 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -209,13 +209,17 @@ void processNeighboursHandler(const int startLayer,
 template <int nLayers = 7>
 void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const TrackingFrameInfo** foundTrackingFrameInfo,
+                      const Cluster** unsortedClusters,
                       o2::its::TrackITSExt* tracks,
-                      std::vector<float>& minPtsHost,
+                      const std::vector<float>& layerRadiiHost,
+                      const std::vector<float>& minPtsHost,
                       const unsigned int nSeeds,
                       const float Bz,
                       const int startLevel,
-                      float maxChi2ClusterAttachment,
-                      float maxChi2NDF,
+                      const float maxChi2ClusterAttachment,
+                      const float maxChi2NDF,
+                      const int reseedIfShorter,
+                      const bool shiftRefToCluster,
                       const o2::base::Propagator* propagator,
                       const o2::base::PropagatorF::MatCorrType matCorrType,
                       const int nBlocks,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 05810f0074811..f94147747a475 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -325,17 +325,21 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
     mTimeFrameGPU->createTrackITSExtDevice(trackSeeds);
     mTimeFrameGPU->loadTrackSeedsDevice(trackSeeds);
 
-    trackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),             // CellSeed* trackSeeds
-                     mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(), // TrackingFrameInfo** foundTrackingFrameInfo
-                     mTimeFrameGPU->getDeviceTrackITSExt(),            // o2::its::TrackITSExt* tracks
-                     this->mTrkParams[iteration].MinPt,                // std::vector<float>& minPtsHost,
+    trackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),             // CellSeed*
+                     mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(), // TrackingFrameInfo**
+                     mTimeFrameGPU->getDeviceArrayUnsortedClusters(),  // Cluster**
+                     mTimeFrameGPU->getDeviceTrackITSExt(),            // o2::its::TrackITSExt*
+                     this->mTrkParams[iteration].LayerRadii,           // const std::vector<float>&
+                     this->mTrkParams[iteration].MinPt,                // const std::vector<float>&
                      trackSeeds.size(),                                // const size_t nSeeds
                      this->mBz,                                        // const float Bz
                      startLevel,                                       // const int startLevel,
                      this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
                      this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
-                     mTimeFrameGPU->getDevicePropagator(),             // const o2::base::Propagator* propagator
-                     this->mTrkParams[0].CorrType,                     // o2::base::PropagatorImpl<float>::MatCorrType
+                     this->mTrkParams[0].ReseedIfShorter,
+                     this->mTrkParams[0].ShiftRefToCluster,
+                     mTimeFrameGPU->getDevicePropagator(), // const o2::base::Propagator* propagator
+                     this->mTrkParams[0].CorrType,         // o2::base::PropagatorImpl<float>::MatCorrType
                      conf.nBlocksTracksSeeds[iteration],
                      conf.nThreadsTracksSeeds[iteration]);
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 71f1281401e9d..27d7fa97f7b5c 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -57,35 +57,56 @@ GPUdii() bool fitTrack(TrackITSExt& track,
                        float bz,
                        const TrackingFrameInfo** tfInfos,
                        const o2::base::Propagator* prop,
-                       o2::base::PropagatorF::MatCorrType matCorrType)
+                       o2::base::PropagatorF::MatCorrType matCorrType,
+                       o2::track::TrackPar* linRef,
+                       const bool shiftRefToCluster)
 {
   for (int iLayer{start}; iLayer != end; iLayer += step) {
     if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
       continue;
     }
     const TrackingFrameInfo& trackingHit = tfInfos[iLayer][track.getClusterIndex(iLayer)];
-    if (!track.o2::track::TrackParCovF::rotate(trackingHit.alphaTrackingFrame)) {
-      return false;
-    }
-
-    if (!prop->propagateToX(track,
-                            trackingHit.xTrackingFrame,
-                            bz,
-                            o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                            o2::base::PropagatorImpl<float>::MAX_STEP,
-                            matCorrType)) {
-      return false;
-    }
+    if (linRef) {
+      if (!track.o2::track::TrackParCovF::rotate(trackingHit.alphaTrackingFrame, *linRef, bz)) {
+        return false;
+      }
+      if (!prop->propagateToX(track,
+                              *linRef,
+                              trackingHit.xTrackingFrame,
+                              bz,
+                              o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+                              o2::base::PropagatorImpl<float>::MAX_STEP,
+                              matCorrType)) {
 
-    if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-      const float xx0 = (iLayer > 2) ? 1.e-2f : 5.e-3f; // Rough layer thickness
-      if (!track.correctForMaterial(xx0, xx0 * constants::Radl * constants::Rho, true)) {
         return false;
       }
+      if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+        const float xx0 = (iLayer > 2) ? 1.e-2f : 5.e-3f; // Rough layer thickness
+        if (!track.correctForMaterial(*linRef, xx0, xx0 * constants::Radl * constants::Rho, true)) {
+          return false;
+        }
+      }
+    } else {
+      if (!track.o2::track::TrackParCovF::rotate(trackingHit.alphaTrackingFrame)) {
+        return false;
+      }
+      if (!prop->propagateToX(track,
+                              trackingHit.xTrackingFrame,
+                              bz,
+                              o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+                              o2::base::PropagatorImpl<float>::MAX_STEP,
+                              matCorrType)) {
+        return false;
+      }
+      if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+        const float xx0 = (iLayer > 2) ? 1.e-2f : 5.e-3f; // Rough layer thickness
+        if (!track.correctForMaterial(xx0, xx0 * constants::Radl * constants::Rho, true)) {
+          return false;
+        }
+      }
     }
 
     auto predChi2{track.getPredictedChi2(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
-
     if ((nCl >= 3 && predChi2 > chi2clcut) || predChi2 < 0.f) {
       return false;
     }
@@ -93,6 +114,10 @@ GPUdii() bool fitTrack(TrackITSExt& track,
     if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
       return false;
     }
+    if (linRef && shiftRefToCluster) { // displace the reference to the last updated cluster
+      linRef->setY(trackingHit.positionTrackingFrame[0]);
+      linRef->setZ(trackingHit.positionTrackingFrame[1]);
+    }
     nCl++;
   }
   return o2::gpu::CAMath::Abs(track.getQ2Pt()) < maxQoverPt && track.getChi2() < chi2ndfcut * (nCl * 2 - 5);
@@ -101,7 +126,8 @@ GPUdii() bool fitTrack(TrackITSExt& track,
 GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
                                                const Cluster& cluster2,
                                                const TrackingFrameInfo& tf3,
-                                               const float bz)
+                                               const float bz,
+                                               const bool reverse = false)
 {
   const float ca = o2::gpu::CAMath::Cos(tf3.alphaTrackingFrame), sa = o2::gpu::CAMath::Sin(tf3.alphaTrackingFrame);
   const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
@@ -115,12 +141,13 @@ GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
   const float z3 = tf3.positionTrackingFrame[1];
 
   const bool zeroField{o2::gpu::CAMath::Abs(bz) < o2::constants::math::Almost0};
-  const float tgp = zeroField ? o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1) : 1.f;
-  const float crv = zeroField ? 1.f : math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
-  const float snp = zeroField ? tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp) : crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
+  const float sign = (reverse) ? -1.f : 1.f;
+  const float tgp = zeroField ? sign * o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1) : 1.f;
+  const float crv = sign * (zeroField ? 1.f : math_utils::computeCurvature(x3, y3, x2, y2, x1, y1));
+  const float snp = (zeroField ? tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp) : crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1)));
   const float tgl12 = math_utils::computeTanDipAngle(x1, y1, x2, y2, z1, z2);
   const float tgl23 = math_utils::computeTanDipAngle(x2, y2, x3, y3, z2, z3);
-  const float q2pt = zeroField ? 1.f / o2::track::kMostProbablePt : crv / (bz * o2::constants::math::B2C);
+  const float q2pt = zeroField ? sign / o2::track::kMostProbablePt : crv / (bz * o2::constants::math::B2C);
   const float q2pt2 = crv * crv;
   const float sg2q2pt = o2::track::kC1Pt2max * (q2pt2 > 0.0005 ? (q2pt2 < 1 ? q2pt2 : 1) : 0.0005);
   return track::TrackParCov(tf3.xTrackingFrame, tf3.alphaTrackingFrame,
@@ -132,6 +159,52 @@ GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
                              0.f, 0.f, 0.f, 0.f, sg2q2pt});
 }
 
+template <int nLayers>
+GPUdii() TrackITSExt seedTrackForRefit(const CellSeed<nLayers>& seed,
+                                       const TrackingFrameInfo** foundTrackingFrameInfo,
+                                       const Cluster** unsortedClusters,
+                                       const float* layerRadii,
+                                       const float bz,
+                                       const int reseedIfShorter)
+{
+  TrackITSExt temporaryTrack(seed);
+  int lrMin = nLayers, lrMax = 0, lrMid = 0;
+  for (int iL{0}; iL < nLayers; ++iL) {
+    const int idx = seed.getCluster(iL);
+    temporaryTrack.setExternalClusterIndex(iL, idx, idx != constants::UnusedIndex);
+    if (idx != constants::UnusedIndex) {
+      // TODO only works if does not have holes
+      lrMin = o2::gpu::CAMath::Min(lrMin, iL);
+      lrMax = o2::gpu::CAMath::Max(lrMax, iL);
+    }
+  }
+  const int ncl = temporaryTrack.getNClusters();
+  if (ncl < reseedIfShorter && ncl > 0) { // need to check if there are any clusters since we keep invalidate seeeds around
+    if (ncl == nLayers) {
+      lrMin = 0;
+      lrMax = nLayers - 1;
+      lrMid = (lrMin + lrMax) / 2;
+    } else {
+      lrMid = lrMin + 1;
+      float midR = 0.5f * (layerRadii[lrMax] + layerRadii[lrMin]), dstMidR = o2::gpu::CAMath::Abs(midR - layerRadii[lrMid]);
+      for (int iL = lrMid + 1; iL < lrMax; ++iL) { // find the midpoint as closest to the midR
+        auto dst = o2::gpu::GPUCommonMath::Abs(midR - layerRadii[iL]);
+        if (dst < dstMidR) {
+          lrMid = iL;
+          dstMidR = dst;
+        }
+      }
+    }
+    const auto& cluster0_tf = foundTrackingFrameInfo[lrMin][seed.getCluster(lrMin)];
+    const auto& cluster1_gl = unsortedClusters[lrMid][seed.getCluster(lrMid)];
+    const auto& cluster2_gl = unsortedClusters[lrMax][seed.getCluster(lrMax)];
+    temporaryTrack.getParamIn() = buildTrackSeed(cluster2_gl, cluster1_gl, cluster0_tf, bz, true);
+  }
+  temporaryTrack.resetCovariance();
+  temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
+  return temporaryTrack;
+}
+
 struct sort_tracklets {
   GPUhd() bool operator()(const Tracklet& a, const Tracklet& b)
   {
@@ -206,27 +279,23 @@ template <int nLayers>
 GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   CellSeed<nLayers>* trackSeeds,
   const TrackingFrameInfo** foundTrackingFrameInfo,
+  const Cluster** unsortedClusters,
   o2::its::TrackITSExt* tracks,
+  const float* layerRadii,
   const float* minPts,
   const unsigned int nSeeds,
   const float bz,
   const int startLevel,
-  float maxChi2ClusterAttachment,
-  float maxChi2NDF,
+  const float maxChi2ClusterAttachment,
+  const float maxChi2NDF,
+  const int reseedIfShorter,
+  const bool shifRefToCluster,
   const o2::base::Propagator* propagator,
   const o2::base::PropagatorF::MatCorrType matCorrType)
 {
   for (int iCurrentTrackSeedIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentTrackSeedIndex < nSeeds; iCurrentTrackSeedIndex += blockDim.x * gridDim.x) {
-    auto& seed = trackSeeds[iCurrentTrackSeedIndex];
-
-    TrackITSExt temporaryTrack{seed};
-
-    temporaryTrack.resetCovariance();
-    temporaryTrack.setChi2(0);
-    auto& clusters = seed.getClusters();
-    for (int iL{0}; iL < nLayers; ++iL) {
-      temporaryTrack.setExternalClusterIndex(iL, clusters[iL], clusters[iL] != constants::UnusedIndex);
-    }
+    TrackITSExt temporaryTrack = seedTrackForRefit<nLayers>(trackSeeds[iCurrentTrackSeedIndex], foundTrackingFrameInfo, unsortedClusters, layerRadii, bz, reseedIfShorter);
+    o2::track::TrackPar linRef{temporaryTrack};
     bool fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
                                0,                            // int lastLayer,
                                nLayers,                      // int firstLayer,
@@ -238,14 +307,17 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
                                bz,                           // float bz,
                                foundTrackingFrameInfo,       // TrackingFrameInfo** trackingFrameInfo,
                                propagator,                   // const o2::base::Propagator* propagator,
-                               matCorrType);                 // o2::base::PropagatorF::MatCorrType matCorrType
+                               matCorrType,                  // o2::base::PropagatorF::MatCorrType matCorrType
+                               &linRef,
+                               shifRefToCluster);
     if (!fitSuccess) {
       continue;
     }
     temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+    linRef = temporaryTrack.getParamOut(); // use refitted track as lin.reference
     temporaryTrack.resetCovariance();
+    temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
     temporaryTrack.setChi2(0);
-
     fitSuccess = fitTrack(temporaryTrack,           // TrackITSExt& track,
                           nLayers - 1,              // int lastLayer,
                           -1,                       // int firstLayer,
@@ -257,7 +329,9 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
                           bz,                       // float bz,
                           foundTrackingFrameInfo,   // TrackingFrameInfo** trackingFrameInfo,
                           propagator,               // const o2::base::Propagator* propagator,
-                          matCorrType);             // o2::base::PropagatorF::MatCorrType matCorrType
+                          matCorrType,              // o2::base::PropagatorF::MatCorrType matCorrType
+                          &linRef,
+                          shifRefToCluster);
     if (!fitSuccess || temporaryTrack.getPt() < minPts[nLayers - temporaryTrack.getNClusters()]) {
       continue;
     }
@@ -1088,34 +1162,42 @@ void processNeighboursHandler(const int startLayer,
 template <int nLayers>
 void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const TrackingFrameInfo** foundTrackingFrameInfo,
+                      const Cluster** unsortedClusters,
                       o2::its::TrackITSExt* tracks,
-                      std::vector<float>& minPtsHost,
+                      const std::vector<float>& layerRadiiHost,
+                      const std::vector<float>& minPtsHost,
                       const unsigned int nSeeds,
                       const float bz,
                       const int startLevel,
-                      float maxChi2ClusterAttachment,
-                      float maxChi2NDF,
+                      const float maxChi2ClusterAttachment,
+                      const float maxChi2NDF,
+                      const int reseedIfShorter,
+                      const bool shiftRefToCluster,
                       const o2::base::Propagator* propagator,
                       const o2::base::PropagatorF::MatCorrType matCorrType,
                       const int nBlocks,
                       const int nThreads)
 {
   thrust::device_vector<float> minPts(minPtsHost);
+  thrust::device_vector<float> layerRadii(layerRadiiHost);
   gpu::fitTrackSeedsKernel<<<nBlocks, nThreads>>>(
-    trackSeeds,                           // CellSeed*
-    foundTrackingFrameInfo,               // TrackingFrameInfo**
-    tracks,                               // TrackITSExt*
-    thrust::raw_pointer_cast(&minPts[0]), // const float* minPts,
-    nSeeds,                               // const unsigned int
-    bz,                                   // const float
-    startLevel,                           // const int
-    maxChi2ClusterAttachment,             // float
-    maxChi2NDF,                           // float
-    propagator,                           // const o2::base::Propagator*
-    matCorrType);                         // o2::base::PropagatorF::MatCorrType
+    trackSeeds,                               // CellSeed*
+    foundTrackingFrameInfo,                   // TrackingFrameInfo**
+    unsortedClusters,                         // Cluster**
+    tracks,                                   // TrackITSExt*
+    thrust::raw_pointer_cast(&layerRadii[0]), // const float*
+    thrust::raw_pointer_cast(&minPts[0]),     // const float*
+    nSeeds,                                   // const unsigned int
+    bz,                                       // const float
+    startLevel,                               // const int
+    maxChi2ClusterAttachment,                 // float
+    maxChi2NDF,                               // float
+    reseedIfShorter,                          // int
+    shiftRefToCluster,                        // bool
+    propagator,                               // const o2::base::Propagator*
+    matCorrType);                             // o2::base::PropagatorF::MatCorrType
   thrust::device_ptr<o2::its::TrackITSExt> tr_ptr(tracks);
   thrust::sort(tr_ptr, tr_ptr + nSeeds, gpu::compare_track_chi2());
-  GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
 }
 
 /// Explicit instantiation of ITS2 handlers
@@ -1281,13 +1363,17 @@ template void processNeighboursHandler<7>(const int startLayer,
 
 template void trackSeedHandler(CellSeed<7>* trackSeeds,
                                const TrackingFrameInfo** foundTrackingFrameInfo,
+                               const Cluster** unsortedClusters,
                                o2::its::TrackITSExt* tracks,
-                               std::vector<float>& minPtsHost,
+                               const std::vector<float>& layerRadiiHost,
+                               const std::vector<float>& minPtsHost,
                                const unsigned int nSeeds,
                                const float bz,
                                const int startLevel,
-                               float maxChi2ClusterAttachment,
-                               float maxChi2NDF,
+                               const float maxChi2ClusterAttachment,
+                               const float maxChi2NDF,
+                               const int reseedIfShorter,
+                               const bool shiftRefToCluster,
                                const o2::base::Propagator* propagator,
                                const o2::base::PropagatorF::MatCorrType matCorrType,
                                const int nBlocks,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 9a6452270d144..000c8fe822498 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -66,10 +66,10 @@ struct TrackingParameters {
   o2::base::PropagatorImpl<float>::MatCorrType CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
   float MaxChi2ClusterAttachment = 60.f;
   float MaxChi2NDF = 30.f;
-  int reseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
+  int ReseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
   unsigned char StartLayerMask = 0x7F;
-  bool shiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
+  bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool FindShortTracks = false;
   bool PerPrimaryVertexProcessing = false;
   bool SaveTimeBenchmarks = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index f582b5ef3aec5..ddc32ed18cbfe 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -92,7 +92,7 @@ class TrackerTraits
   virtual int getTFNumberOfCells() const { return mTimeFrame->getNumberOfCells(); }
 
  private:
-  track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3);
+  track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse = false);
   TrackITSExt seedTrackForRefit(const CellSeedN& seed);
   bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0, o2::track::TrackPar* refLin = nullptr);
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index c6ed343033996..87787eeee03a9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -186,8 +186,8 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       int lslot = tc.MaxTrackLength - ilg;
       p.MinPt[lslot] *= bFactor;
     }
-    p.reseedIfShorter = tc.reseedIfShorter;
-    p.shiftRefToCluster = tc.shiftRefToCluster;
+    p.ReseedIfShorter = tc.reseedIfShorter;
+    p.ShiftRefToCluster = tc.shiftRefToCluster;
     p.createArtefactLabels = tc.createArtefactLabels;
 
     p.PrintMemory = tc.printMemory;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 5c5eb47216051..e6d3441f0bc06 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -765,7 +765,6 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
       auto forSeed = [&](auto Tag, int iSeed, int offset = 0) {
         TrackITSExt temporaryTrack = seedTrackForRefit(trackSeeds[iSeed]);
         o2::track::TrackPar linRef{temporaryTrack};
-        o2::track::TrackParCov savTr = temporaryTrack; // REMOVE
         bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, o2::constants::math::VeryBig, 0, &linRef);
         if (!fitSuccess) {
           return 0;
@@ -773,7 +772,7 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
         linRef = temporaryTrack.getParamOut(); // use refitted track as lin.reference
         temporaryTrack.resetCovariance();
-        temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
+        temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
         temporaryTrack.setChi2(0);
         fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f, 0, &linRef);
         if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
@@ -1082,7 +1081,7 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
     if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
       return false;
     }
-    if (linRef && mTrkParams[0].shiftRefToCluster) { // displace the reference to the last updated cluster
+    if (linRef && mTrkParams[0].ShiftRefToCluster) { // displace the reference to the last updated cluster
       linRef->setY(trackingHit.positionTrackingFrame[0]);
       linRef->setZ(trackingHit.positionTrackingFrame[1]);
     }
@@ -1208,27 +1207,22 @@ template <int nLayers>
 TrackITSExt TrackerTraits<nLayers>::seedTrackForRefit(const CellSeedN& seed)
 {
   TrackITSExt temporaryTrack(seed);
+  int lrMin = nLayers, lrMax = 0, lrMid = 0;
   for (int iL = 0; iL < nLayers; ++iL) {
-    temporaryTrack.setExternalClusterIndex(iL, seed.getCluster(iL), seed.getCluster(iL) != constants::UnusedIndex);
+    const int idx = seed.getCluster(iL);
+    temporaryTrack.setExternalClusterIndex(iL, idx, idx != constants::UnusedIndex);
+    if (idx != constants::UnusedIndex) {
+      lrMin = o2::gpu::CAMath::Min(lrMin, iL);
+      lrMax = o2::gpu::CAMath::Max(lrMax, iL);
+    }
   }
   int ncl = temporaryTrack.getNClusters();
-  if (ncl < mTrkParams[0].reseedIfShorter) { // reseed with circle passing via edges and the midpoint
-    int lrMin = 999, lrMax = 0, lrMid = 0;
+  if (ncl < mTrkParams[0].ReseedIfShorter) { // reseed with circle passing via edges and the midpoint
     if (ncl == mTrkParams[0].NLayers) {
       lrMin = 0;
       lrMax = mTrkParams[0].NLayers - 1;
       lrMid = (lrMin + lrMax) / 2;
     } else {
-      for (int iL = 0; iL < nLayers; ++iL) {
-        if (seed.getCluster(iL) != constants::UnusedIndex) {
-          if (iL < lrMin) {
-            lrMin = iL;
-          }
-          if (iL > lrMax) {
-            lrMax = iL;
-          }
-        }
-      }
       lrMid = lrMin + 1;
       float midR = 0.5 * (mTrkParams[0].LayerRadii[lrMax] + mTrkParams[0].LayerRadii[lrMin]), dstMidR = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[lrMid]);
       for (int iL = lrMid + 1; iL < lrMax; ++iL) { // find the midpoint as closest to the midR
@@ -1242,19 +1236,17 @@ TrackITSExt TrackerTraits<nLayers>::seedTrackForRefit(const CellSeedN& seed)
     const auto& cluster0_tf = mTimeFrame->getTrackingFrameInfoOnLayer(lrMin)[seed.getCluster(lrMin)]; // if the sensor frame!
     const auto& cluster1_gl = mTimeFrame->getUnsortedClusters()[lrMid][seed.getCluster(lrMid)];       // global frame
     const auto& cluster2_gl = mTimeFrame->getUnsortedClusters()[lrMax][seed.getCluster(lrMax)];       // global frame
-    temporaryTrack.getParamIn() = buildTrackSeed(cluster2_gl, cluster1_gl, cluster0_tf);
-    temporaryTrack.setQ2Pt(-temporaryTrack.getQ2Pt()); // we are calling buildTrackSeed with the clusters order opposite to what it expects
-    temporaryTrack.setSnp(-temporaryTrack.getSnp());   // we are calling buildTrackSeed with the clusters order opposite to what it expects
+    temporaryTrack.getParamIn() = buildTrackSeed(cluster2_gl, cluster1_gl, cluster0_tf, true);
   }
   temporaryTrack.resetCovariance();
-  temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[14], 14);
+  temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
   return temporaryTrack;
 }
 
 /// Clusters are given from inside outward (cluster3 is the outermost). The outermost cluster is given in the tracking
 /// frame coordinates whereas the others are referred to the global frame.
 template <int nLayers>
-track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3)
+track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse)
 {
   float ca{-999.f}, sa{-999.f};
   o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
@@ -1267,12 +1259,14 @@ track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster
   const float x3 = tf3.xTrackingFrame;
   const float y3 = tf3.positionTrackingFrame[0];
   const float z3 = tf3.positionTrackingFrame[1];
+  const float sign = (reverse) ? -1.f : 1.f;
   float tgp{1.f}, crv{1.f}, snp{-999.f}, tgl12{-999.f}, tgl23{-999.f}, q2pt{1.f / track::kMostProbablePt}, q2pt2{1.f}, sg2q2pt{-999.f};
   if (mIsZeroField) {
-    tgp = o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
+    tgp = sign * o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
     snp = tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
+    q2pt *= sign;
   } else {
-    crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
+    crv = sign * math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
     snp = crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
     q2pt = crv / (mBz * o2::constants::math::B2C);
     q2pt2 = crv * crv;

From e12ca36e0a505f502a45a64eae6bde32e1ee4d90 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 1 Dec 2025 20:16:57 +0100
Subject: [PATCH 1100/1764] ITS: simplify buildTrackSeed

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 46 ++++++++++---------
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 35 +++++++-------
 2 files changed, 43 insertions(+), 38 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 27d7fa97f7b5c..d9136cb96d00e 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -129,34 +129,36 @@ GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
                                                const float bz,
                                                const bool reverse = false)
 {
-  const float ca = o2::gpu::CAMath::Cos(tf3.alphaTrackingFrame), sa = o2::gpu::CAMath::Sin(tf3.alphaTrackingFrame);
+  const float sign = reverse ? -1.f : 1.f;
+
+  float ca, sa;
+  o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
+
   const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
   const float y1 = -cluster1.xCoordinate * sa + cluster1.yCoordinate * ca;
-  const float z1 = cluster1.zCoordinate;
   const float x2 = cluster2.xCoordinate * ca + cluster2.yCoordinate * sa;
   const float y2 = -cluster2.xCoordinate * sa + cluster2.yCoordinate * ca;
-  const float z2 = cluster2.zCoordinate;
   const float x3 = tf3.xTrackingFrame;
   const float y3 = tf3.positionTrackingFrame[0];
-  const float z3 = tf3.positionTrackingFrame[1];
-
-  const bool zeroField{o2::gpu::CAMath::Abs(bz) < o2::constants::math::Almost0};
-  const float sign = (reverse) ? -1.f : 1.f;
-  const float tgp = zeroField ? sign * o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1) : 1.f;
-  const float crv = sign * (zeroField ? 1.f : math_utils::computeCurvature(x3, y3, x2, y2, x1, y1));
-  const float snp = (zeroField ? tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp) : crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1)));
-  const float tgl12 = math_utils::computeTanDipAngle(x1, y1, x2, y2, z1, z2);
-  const float tgl23 = math_utils::computeTanDipAngle(x2, y2, x3, y3, z2, z3);
-  const float q2pt = zeroField ? sign / o2::track::kMostProbablePt : crv / (bz * o2::constants::math::B2C);
-  const float q2pt2 = crv * crv;
-  const float sg2q2pt = o2::track::kC1Pt2max * (q2pt2 > 0.0005 ? (q2pt2 < 1 ? q2pt2 : 1) : 0.0005);
-  return track::TrackParCov(tf3.xTrackingFrame, tf3.alphaTrackingFrame,
-                            {y3, z3, snp, 0.5f * (tgl12 + tgl23), q2pt},
-                            {tf3.covarianceTrackingFrame[0],
-                             tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2],
-                             0.f, 0.f, track::kCSnp2max,
-                             0.f, 0.f, 0.f, track::kCTgl2max,
-                             0.f, 0.f, 0.f, 0.f, sg2q2pt});
+
+  float snp, q2pt, q2pt2;
+  if (o2::gpu::CAMath::Abs(bz) < 0.01f) {
+    const float tgp = o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
+    snp = sign * tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
+    q2pt = sign / track::kMostProbablePt;
+    q2pt2 = 1.f;
+  } else {
+    const float crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
+    snp = sign * crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
+    q2pt = sign * crv / (bz * o2::constants::math::B2C);
+    q2pt2 = crv * crv;
+  }
+
+  const float tgl = 0.5f * (math_utils::computeTanDipAngle(x1, y1, x2, y2, cluster1.zCoordinate, cluster2.zCoordinate) +
+                            math_utils::computeTanDipAngle(x2, y2, x3, y3, cluster2.zCoordinate, tf3.positionTrackingFrame[1]));
+  const float sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005f ? (q2pt2 < 1.f ? q2pt2 : 1.f) : 0.0005f);
+
+  return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index e6d3441f0bc06..6b237ad0a63e8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -1248,33 +1248,36 @@ TrackITSExt TrackerTraits<nLayers>::seedTrackForRefit(const CellSeedN& seed)
 template <int nLayers>
 track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse)
 {
-  float ca{-999.f}, sa{-999.f};
+  const float sign = reverse ? -1.f : 1.f;
+
+  float ca, sa;
   o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
+
   const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
   const float y1 = -cluster1.xCoordinate * sa + cluster1.yCoordinate * ca;
-  const float z1 = cluster1.zCoordinate;
   const float x2 = cluster2.xCoordinate * ca + cluster2.yCoordinate * sa;
   const float y2 = -cluster2.xCoordinate * sa + cluster2.yCoordinate * ca;
-  const float z2 = cluster2.zCoordinate;
   const float x3 = tf3.xTrackingFrame;
   const float y3 = tf3.positionTrackingFrame[0];
-  const float z3 = tf3.positionTrackingFrame[1];
-  const float sign = (reverse) ? -1.f : 1.f;
-  float tgp{1.f}, crv{1.f}, snp{-999.f}, tgl12{-999.f}, tgl23{-999.f}, q2pt{1.f / track::kMostProbablePt}, q2pt2{1.f}, sg2q2pt{-999.f};
+
+  float snp, q2pt, q2pt2;
   if (mIsZeroField) {
-    tgp = sign * o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
-    snp = tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
-    q2pt *= sign;
+    const float tgp = o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
+    snp = sign * tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
+    q2pt = sign / track::kMostProbablePt;
+    q2pt2 = 1.f;
   } else {
-    crv = sign * math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
-    snp = crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
-    q2pt = crv / (mBz * o2::constants::math::B2C);
+    const float crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
+    snp = sign * crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
+    q2pt = sign * crv / (mBz * o2::constants::math::B2C);
     q2pt2 = crv * crv;
   }
-  tgl12 = math_utils::computeTanDipAngle(x1, y1, x2, y2, z1, z2);
-  tgl23 = math_utils::computeTanDipAngle(x2, y2, x3, y3, z2, z3);
-  sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005f ? (q2pt2 < 1.f ? q2pt2 : 1.f) : 0.0005f);
-  return {tf3.xTrackingFrame, tf3.alphaTrackingFrame, {y3, z3, snp, 0.5f * (tgl12 + tgl23), q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
+
+  const float tgl = 0.5f * (math_utils::computeTanDipAngle(x1, y1, x2, y2, cluster1.zCoordinate, cluster2.zCoordinate) +
+                            math_utils::computeTanDipAngle(x2, y2, x3, y3, cluster2.zCoordinate, tf3.positionTrackingFrame[1]));
+  const float sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005f ? (q2pt2 < 1.f ? q2pt2 : 1.f) : 0.0005f);
+
+  return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
 }
 
 template <int nLayers>

From 5b0ae4534dd54d57897ab57a90ec28523e82b3b8 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 3 Dec 2025 11:23:06 +0100
Subject: [PATCH 1101/1764] DPL: sanity check silently skipping
 DataProcessingDevice

When either DomainInfoHeader or SourceInfoHeader is present, we skip their
processing. However we should complain if actual data is attached to the same
message, because it will also be skipped.
---
 Framework/Core/src/DataProcessingDevice.cxx | 29 ++++++++++-----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 3b430378dc0b0..3e9a0a3d996b9 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -558,25 +558,18 @@ static auto toBeForwardedHeader = [](void* header) -> bool {
   if (header == nullptr) {
     return false;
   }
-  auto sih = o2::header::get<SourceInfoHeader*>(header);
-  if (sih) {
-    return false;
-  }
-
-  auto dih = o2::header::get<DomainInfoHeader*>(header);
-  if (dih) {
-    return false;
-  }
-
   auto dh = o2::header::get<DataHeader*>(header);
   if (!dh) {
     return false;
   }
-  auto dph = o2::header::get<DataProcessingHeader*>(header);
-  if (!dph) {
-    return false;
+  bool retval = !o2::header::get<SourceInfoHeader*>(header) &&
+                !o2::header::get<DomainInfoHeader*>(header) &&
+                o2::header::get<DataProcessingHeader*>(header);
+  // DataHeader is there. Complain if we have unexpected headers present / missing
+  if (!retval) {
+    LOGP(error, "Dropping data because of malformed header structure");
   }
-  return true;
+  return retval;
 };
 
 static auto toBeforwardedMessageSet = [](std::vector<ChannelIndex>& cachedForwardingChoices,
@@ -1858,11 +1851,15 @@ void DataProcessingDevice::handleData(ServiceRegistryRef ref, InputChannelInfo&
     for (size_t pi = 0; pi < parts.Size(); pi += 2) {
       auto* headerData = parts.At(pi)->GetData();
       auto sih = o2::header::get<SourceInfoHeader*>(headerData);
+      auto dh = o2::header::get<DataHeader*>(headerData);
       if (sih) {
         O2_SIGNPOST_EVENT_EMIT(device, cid, "handle_data", "Got SourceInfoHeader with state %d", (int)sih->state);
         info.state = sih->state;
         insertInputInfo(pi, 2, InputType::SourceInfo, info.id);
         state.lastActiveDataProcessor = &context;
+        if (dh) {
+          LOGP(error, "Found data attached to a SourceInfoHeader");
+        }
         continue;
       }
       auto dih = o2::header::get<DomainInfoHeader*>(headerData);
@@ -1870,9 +1867,11 @@ void DataProcessingDevice::handleData(ServiceRegistryRef ref, InputChannelInfo&
         O2_SIGNPOST_EVENT_EMIT(device, cid, "handle_data", "Got DomainInfoHeader with oldestPossibleTimeslice %d", (int)dih->oldestPossibleTimeslice);
         insertInputInfo(pi, 2, InputType::DomainInfo, info.id);
         state.lastActiveDataProcessor = &context;
+        if (dh) {
+          LOGP(error, "Found data attached to a DomainInfoHeader");
+        }
         continue;
       }
-      auto dh = o2::header::get<DataHeader*>(headerData);
       if (!dh) {
         insertInputInfo(pi, 0, InputType::Invalid, info.id);
         O2_SIGNPOST_EVENT_EMIT_ERROR(device, cid, "handle_data", "Header is not a DataHeader?");

From a5c604de4c1f17839edd7801155024af739f7967 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Tue, 2 Dec 2025 14:24:23 +0100
Subject: [PATCH 1102/1764] GPU: Add throughput to pad filter kernel timer.

---
 GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 7b0c54cda5cb1..fdce8ef5a127d 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -964,6 +964,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           int32_t nBlocks = TPC_PADS_IN_SECTOR / GPUTPCCFCheckPadBaseline::PadsPerCacheline;
 
           runKernel<GPUTPCCFCheckPadBaseline>({GetGridBlk(nBlocks, lane), {iSector}});
+          getKernelTimer<GPUTPCCFCheckPadBaseline>(RecoStep::TPCClusterFinding, iSector, TPC_PADS_IN_SECTOR * fragment.lengthWithoutOverlap() * sizeof(PackedCharge), false);
         }
 
         runKernel<GPUTPCCFPeakFinder>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});

From 754936f607b76114cdfd282e34684bc3ee62f454 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 4 Dec 2025 15:37:45 +0100
Subject: [PATCH 1103/1764] Use stable lin.ref. point for alignment track
 initial fit

---
 Detectors/Align/include/Align/AlignConfig.h   |  1 +
 .../Align/include/Align/AlignmentTrack.h      | 42 +++++++--------
 Detectors/Align/src/AlignmentTrack.cxx        | 51 ++++++++++++-------
 .../Base/include/DetectorsBase/Propagator.h   |  3 ++
 Detectors/Base/src/Propagator.cxx             | 17 +++++++
 5 files changed, 75 insertions(+), 39 deletions(-)

diff --git a/Detectors/Align/include/Align/AlignConfig.h b/Detectors/Align/include/Align/AlignConfig.h
index 91b503c2c923e..e72d436a14e3b 100644
--- a/Detectors/Align/include/Align/AlignConfig.h
+++ b/Detectors/Align/include/Align/AlignConfig.h
@@ -85,6 +85,7 @@ struct AlignConfig : public o2::conf::ConfigurableParamHelper<AlignConfig> {
   float controlFraction = -1.;     // fraction for which control output is requested, if negative - only 1st instance of device will write them
   float MPRecOutFraction = -1.;    // compact Millepede2Record fraction, if negative - only 1st instance of device will write them
 
+  bool useLinRef = true;      // use initial track for lienarization reference point
   bool MilleOut = true;       // Mille output
   bool KalmanResid = true;    // Kalman residuals
   bool MilleOutBin = true;    // text vs binary output for mille data
diff --git a/Detectors/Align/include/Align/AlignmentTrack.h b/Detectors/Align/include/Align/AlignmentTrack.h
index ef4552cb9a37d..cb69f11cbf85c 100644
--- a/Detectors/Align/include/Align/AlignmentTrack.h
+++ b/Detectors/Align/include/Align/AlignmentTrack.h
@@ -39,6 +39,7 @@ class AlignmentTrack : public trackParam_t, public TObject
 {
  public:
   using trackParam_t = o2::track::TrackParametrizationWithError<double>;
+  using trackPar_t = o2::track::TrackParametrization<double>;
   using PropagatorD = o2::base::PropagatorD;
   using MatCorrType = PropagatorD::MatCorrType;
   using GTrackID = o2::dataformats::GlobalTrackID;
@@ -83,9 +84,9 @@ class AlignmentTrack : public trackParam_t, public TObject
   //
   template <typename P>
   void copyFrom(const o2::track::TrackParametrizationWithError<P>& trc);
-  bool propagateToPoint(trackParam_t& tr, const AlignmentPoint* pnt, double maxStep, double maxSnp = 0.95, MatCorrType mt = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tLT = nullptr, int signCorr = 0);
-  bool propagateParamToPoint(trackParam_t& tr, const AlignmentPoint* pnt, double maxStep = 3, double maxSnp = 0.95, MatCorrType mt = MatCorrType::USEMatCorrLUT, int signCorr = 0);             // param only
-  bool propagateParamToPoint(trackParam_t* trSet, int nTr, const AlignmentPoint* pnt, double maxStep = 3, double maxSnp = 0.95, MatCorrType mt = MatCorrType::USEMatCorrLUT, int signCorr = 0); // params only
+  bool propagateToPoint(trackParam_t& tr, trackPar_t* linRef, const AlignmentPoint* pnt, double maxStep, double maxSnp = 0.95, MatCorrType mt = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tLT = nullptr, int signCorr = 0);
+  bool propagateParamToPoint(trackPar_t& tr, const AlignmentPoint* pnt, double maxStep = 3, double maxSnp = 0.95, MatCorrType mt = MatCorrType::USEMatCorrLUT, int signCorr = 0);             // param only
+  bool propagateParamToPoint(trackPar_t* trSet, int nTr, const AlignmentPoint* pnt, double maxStep = 3, double maxSnp = 0.95, MatCorrType mt = MatCorrType::USEMatCorrLUT, int signCorr = 0); // params only
   //
   bool calcResiduals(const double* params = nullptr);
   bool calcResidDeriv(double* params = nullptr);
@@ -119,23 +120,23 @@ class AlignmentTrack : public trackParam_t, public TObject
   void imposePtBOff(double pt) { setQ2Pt(1. / pt); }
   // propagation methods
   void copyFrom(const trackParam_t* etp);
-  bool applyMatCorr(trackParam_t& trPar, const double* corrDiag, const AlignmentPoint* pnt);
-  bool applyMatCorr(trackParam_t* trSet, int ntr, const double* corrDiaf, const AlignmentPoint* pnt);
-  bool applyMatCorr(trackParam_t& trPar, const double* corrpar);
+  bool applyMatCorr(trackPar_t& trPar, const double* corrDiag, const AlignmentPoint* pnt);
+  bool applyMatCorr(trackPar_t* trSet, int ntr, const double* corrDiaf, const AlignmentPoint* pnt);
+  bool applyMatCorr(trackPar_t& trPar, const double* corrpar);
   //
   double getResidual(int dim, int pntID) const { return mResid[dim][pntID]; }
   const double* getDResDLoc(int dim, int pntID) const { return mDResDLoc[dim].data() + (pntID * mNLocPar); }
   const double* getDResDGlo(int dim, int id) const { return mDResDGlo[dim].data() + id; }
   const int* getGloParID() const { return mGloParID.data(); }
   //
-  void setParams(trackParam_t& tr, double x, double alp, const double* par, bool add);
-  void setParams(trackParam_t* trSet, int ntr, double x, double alp, const double* par, bool add);
-  void setParam(trackParam_t& tr, int par, double val);
-  void setParam(trackParam_t* trSet, int ntr, int par, double val);
-  void modParam(trackParam_t& tr, int par, double delta);
-  void modParam(trackParam_t* trSet, int ntr, int par, double delta);
+  void setParams(trackPar_t& tr, double x, double alp, const double* par, bool add);
+  void setParams(trackPar_t* trSet, int ntr, double x, double alp, const double* par, bool add);
+  void setParam(trackPar_t& tr, int par, double val);
+  void setParam(trackPar_t* trSet, int ntr, int par, double val);
+  void modParam(trackPar_t& tr, int par, double delta);
+  void modParam(trackPar_t* trSet, int ntr, int par, double delta);
   //
-  void richardsonDeriv(const trackParam_t* trSet, const double* delta,
+  void richardsonDeriv(const trackPar_t* trSet, const double* delta,
                        const AlignmentPoint* pnt, double& derY, double& derZ);
   //
   const double* getLocPars() const { return mLocPar.data(); }
@@ -179,13 +180,14 @@ class AlignmentTrack : public trackParam_t, public TObject
   std::vector<double> mLocPar;              // local parameters array
   std::vector<int> mGloParID;               // IDs of relevant global params
  private:
-  bool propagate(trackParam_t& tr, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, track::TrackLTIntegral* tLT, int signCorr = 0);
+  bool propagate(trackParam_t& tr, trackPar_t* linRef, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, track::TrackLTIntegral* tLT, int signCorr = 0);
+  bool propagate(trackPar_t& tr, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, track::TrackLTIntegral* tLT, int signCorr = 0);
   //
   ClassDefOverride(AlignmentTrack, 2)
 };
 
 //____________________________________________________________________________________________
-inline void AlignmentTrack::setParams(trackParam_t& tr, double x, double alp, const double* par, bool add)
+inline void AlignmentTrack::setParams(trackPar_t& tr, double x, double alp, const double* par, bool add)
 {
   // set track params
   const double kDefQ2PtCosm = 1;
@@ -205,7 +207,7 @@ inline void AlignmentTrack::setParams(trackParam_t& tr, double x, double alp, co
 }
 
 //____________________________________________________________________________________________
-inline void AlignmentTrack::setParams(trackParam_t* trSet, int ntr, double x, double alp, const double* par, bool add)
+inline void AlignmentTrack::setParams(trackPar_t* trSet, int ntr, double x, double alp, const double* par, bool add)
 {
   // set parames for multiple tracks (VECTORIZE THIS)
   if (!add) { // full parameter supplied
@@ -224,14 +226,14 @@ inline void AlignmentTrack::setParams(trackParam_t* trSet, int ntr, double x, do
 }
 
 //____________________________________________________________________________________________
-inline void AlignmentTrack::setParam(trackParam_t& tr, int par, double val)
+inline void AlignmentTrack::setParam(trackPar_t& tr, int par, double val)
 {
   // set track parameter
   tr.setParam(val, par);
 }
 
 //____________________________________________________________________________________________
-inline void AlignmentTrack::setParam(trackParam_t* trSet, int ntr, int par, double val)
+inline void AlignmentTrack::setParam(trackPar_t* trSet, int ntr, int par, double val)
 {
   // set parames for multiple tracks (VECTORIZE THIS)
   for (int i = 0; i < ntr; ++i) {
@@ -240,7 +242,7 @@ inline void AlignmentTrack::setParam(trackParam_t* trSet, int ntr, int par, doub
 }
 
 //____________________________________________________________________________________________
-inline void AlignmentTrack::modParam(trackParam_t& tr, int par, double delta)
+inline void AlignmentTrack::modParam(trackPar_t& tr, int par, double delta)
 {
   // modify track parameter
   const auto val = tr.getParam(par) + delta;
@@ -248,7 +250,7 @@ inline void AlignmentTrack::modParam(trackParam_t& tr, int par, double delta)
 }
 
 //____________________________________________________________________________________________
-inline void AlignmentTrack::modParam(trackParam_t* trSet, int ntr, int par, double delta)
+inline void AlignmentTrack::modParam(trackPar_t* trSet, int ntr, int par, double delta)
 {
   // modify track parameter (VECTORIZE THOS)
   for (int i = 0; i < ntr; ++i) {
diff --git a/Detectors/Align/src/AlignmentTrack.cxx b/Detectors/Align/src/AlignmentTrack.cxx
index 554d30e246e29..644ee07c64984 100644
--- a/Detectors/Align/src/AlignmentTrack.cxx
+++ b/Detectors/Align/src/AlignmentTrack.cxx
@@ -168,7 +168,7 @@ bool AlignmentTrack::calcResidDeriv(double* extendedParams, bool invert, int pFr
   // (like http://root.cern.ch/root/html/ROOT__Math__RichardsonDerivator.html)
   //
   const auto& algConf = AlignConfig::Instance();
-  trackParam_t probD[kNRDClones]; // use this to vary supplied param for derivative calculation
+  trackPar_t probD[kNRDClones]; // use this to vary supplied param for derivative calculation
   double varDelta[kRichardsonN];
   const int kInvElem[kNKinParBON] = {-1, 1, 1, -1, -1};
   //
@@ -511,7 +511,7 @@ bool AlignmentTrack::calcResiduals(const double* extendedParams, bool invert, in
 }
 
 //______________________________________________________
-bool AlignmentTrack::propagateParamToPoint(trackParam_t* tr, int nTr, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, int signCorr)
+bool AlignmentTrack::propagateParamToPoint(trackPar_t* tr, int nTr, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, int signCorr)
 {
   // Propagate set of tracks to the point  (only parameters, no error matrix)
   // VECTORIZE this
@@ -521,7 +521,7 @@ bool AlignmentTrack::propagateParamToPoint(trackParam_t* tr, int nTr, const Alig
     if (!propagateParamToPoint(tr[itr], pnt, maxStep, maxSnp, mt, signCorr)) {
       if (algConf.verbose > 2) {
         LOG(error) << "Failed on clone " << itr << " propagation ";
-        tr[itr].print();
+        tr[itr].printParam();
         pnt->print(AlignmentPoint::kMeasurementBit | AlignmentPoint::kMaterialBit);
       }
       return false;
@@ -531,21 +531,33 @@ bool AlignmentTrack::propagateParamToPoint(trackParam_t* tr, int nTr, const Alig
 }
 
 //______________________________________________________
-bool AlignmentTrack::propagateParamToPoint(trackParam_t& tr, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, int signCorr)
+bool AlignmentTrack::propagateParamToPoint(trackPar_t& tr, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, int signCorr)
 {
   // propagate tracks to the point (only parameters, no error matrix)
   return propagate(tr, pnt, maxStep, maxSnp, mt, nullptr, signCorr);
 }
 
 //______________________________________________________
-bool AlignmentTrack::propagateToPoint(trackParam_t& tr, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, track::TrackLTIntegral* tLT, int signCorr)
+bool AlignmentTrack::propagateToPoint(trackParam_t& tr, trackPar_t* linRef, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, track::TrackLTIntegral* tLT, int signCorr)
 {
   // propagate tracks to the point. If matCor is true, then material corrections will be applied.
   // if matPar pointer is provided, it will be filled by total x2x0 and signed xrho
-  return propagate(tr, pnt, maxStep, maxSnp, mt, tLT, signCorr);
+  return propagate(tr, linRef, pnt, maxStep, maxSnp, mt, tLT, signCorr);
 }
 
-bool AlignmentTrack::propagate(trackParam_t& track, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, track::TrackLTIntegral* tLT, int signCorr)
+bool AlignmentTrack::propagate(trackParam_t& track, trackPar_t* linRef, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, track::TrackLTIntegral* tLT, int signCorr)
+{
+  if (signCorr == 0) { // auto
+    // calculate the sign of the energy loss correction and ensure the upper leg of cosmics is calculated correctly.
+    double dx = pnt->getXTracking() - track.getX();
+    int dir = dx > 0.f ? 1 : -1;
+    signCorr = pnt->isInvDir() ? dir : -dir; // propagation along the track direction should have signCorr=-1
+  }
+  // do propagation in at least 2 step to reveal eventual effect of MS on the position
+  return PropagatorD::Instance()->propagateToAlphaX(track, linRef, pnt->getAlphaSens(), pnt->getXTracking(), pnt->getUseBzOnly(), maxSnp, maxStep, 2, mt, tLT, signCorr);
+}
+
+bool AlignmentTrack::propagate(trackPar_t& track, const AlignmentPoint* pnt, double maxStep, double maxSnp, MatCorrType mt, track::TrackLTIntegral* tLT, int signCorr)
 {
   if (signCorr == 0) { // auto
     // calculate the sign of the energy loss correction and ensure the upper leg of cosmics is calculated correctly.
@@ -603,7 +615,7 @@ bool AlignmentTrack::ApplyMS(trackParam_t& trPar, double tms,double pms)
 */
 
 //______________________________________________________
-bool AlignmentTrack::applyMatCorr(trackParam_t& trPar, const double* corrPar, const AlignmentPoint* pnt)
+bool AlignmentTrack::applyMatCorr(trackPar_t& trPar, const double* corrPar, const AlignmentPoint* pnt)
 {
   // Modify track param (e.g. trackParam_t) in the tracking frame
   // by delta accounting for material effects
@@ -630,7 +642,7 @@ bool AlignmentTrack::applyMatCorr(trackParam_t& trPar, const double* corrPar, co
 }
 
 //______________________________________________________
-bool AlignmentTrack::applyMatCorr(trackParam_t& trPar, const double* corr)
+bool AlignmentTrack::applyMatCorr(trackPar_t& trPar, const double* corr)
 {
   // Modify track param (e.g. trackParam_t) in the tracking frame
   // by delta accounting for material effects
@@ -645,7 +657,7 @@ bool AlignmentTrack::applyMatCorr(trackParam_t& trPar, const double* corr)
         printf("%+.3e ", corr[i]);
       }
       printf("\n");
-      trPar.print();
+      trPar.printParam();
     }
     return false;
   }
@@ -656,7 +668,7 @@ bool AlignmentTrack::applyMatCorr(trackParam_t& trPar, const double* corr)
 }
 
 //______________________________________________________
-bool AlignmentTrack::applyMatCorr(trackParam_t* trSet, int ntr, const double* corrDiag, const AlignmentPoint* pnt)
+bool AlignmentTrack::applyMatCorr(trackPar_t* trSet, int ntr, const double* corrDiag, const AlignmentPoint* pnt)
 {
   // Modify set of track params (e.g. trackParam_t) in the tracking frame
   // by delta accounting for material effects
@@ -683,7 +695,7 @@ bool AlignmentTrack::applyMatCorr(trackParam_t* trSet, int ntr, const double* co
     if (!applyMatCorr(trSet[itr], corr)) {
       if (algConf.verbose > 2) {
         LOGP(error, "Failed on clone {} materials", itr);
-        trSet[itr].print();
+        trSet[itr].printParam();
       }
       return false;
     }
@@ -732,7 +744,7 @@ double AlignmentTrack::richardsonExtrap(const double* val, int ord)
 }
 
 //______________________________________________
-void AlignmentTrack::richardsonDeriv(const trackParam_t* trSet, const double* delta, const AlignmentPoint* pnt, double& derY, double& derZ)
+void AlignmentTrack::richardsonDeriv(const trackPar_t* trSet, const double* delta, const AlignmentPoint* pnt, double& derY, double& derZ)
 {
   // Calculate Richardson derivatives for diagonalized Y and Z from a set of kRichardsonN pairs
   // of tracks with same parameter of i-th pair varied by +-delta[i]
@@ -882,7 +894,7 @@ bool AlignmentTrack::iniFit()
     //
     // propagate to reference point, which is the inner point of lower leg
     const AlignmentPoint* refP = getPoint(getInnerPointID());
-    if (!propagateToPoint(trcU, refP, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), nullptr, -1)) { // moving along the track: energy is lost
+    if (!propagateToPoint(trcU, nullptr, refP, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), nullptr, -1)) { // moving along the track: energy is lost
       return false;
     }
     //
@@ -1024,6 +1036,7 @@ bool AlignmentTrack::fitLeg(trackParam_t& trc, int pFrom, int pTo, bool& inv)
     }
     return false;
   }
+  trackPar_t linRef(trc), *linRefP = algConf.useLinRef ? &linRef : nullptr;
   trc.setCov(kIniErr);
   trc.setCov(16 * trc.getQ2Pt() * trc.getQ2Pt(), 4, 4); // lowest diagonal element (Q2Pt2)
   //
@@ -1042,7 +1055,7 @@ bool AlignmentTrack::fitLeg(trackParam_t& trc, int pFrom, int pTo, bool& inv)
   int pntCnt = 0;
   for (int ip = pFrom; ip != pTo; ip += pinc) { // inward fit from outer point
     AlignmentPoint* pnt = getPoint(ip);
-    if (!propagateToPoint(trc, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), nullptr, signELoss)) { // against track direction : e.loss is compensated
+    if (!propagateToPoint(trc, linRefP, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), nullptr, signELoss)) { // against track direction : e.loss is compensated
       if (algConf.verbose > 2) {
         LOGF(warn, "Failed on propagateToPoint %d (%d : %d) %f", ip, pFrom, pTo, pnt->getXTracking());
         trc.print();
@@ -1139,7 +1152,7 @@ bool AlignmentTrack::residKalman()
       trc.invert();
       inv = !inv;
     }
-    if (!propagateToPoint(trc, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), nullptr, signELoss)) {
+    if (!propagateToPoint(trc, nullptr, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), nullptr, signELoss)) {
       return false;
     }
     if (!pnt->containsMeasurement()) {
@@ -1178,7 +1191,7 @@ bool AlignmentTrack::residKalman()
       trc.invert();
       inv = !inv;
     }
-    if (!propagateToPoint(trc, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), nullptr, signELoss)) { // we are going along track direction, e.loss is applied
+    if (!propagateToPoint(trc, nullptr, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), nullptr, signELoss)) { // we are going along track direction, e.loss is applied
       return false;
     }
     if (!pnt->containsMeasurement()) {
@@ -1335,7 +1348,7 @@ bool AlignmentTrack::processMaterials(trackParam_t& trc, int pFrom, int pTo)
     //
     matTL.clearFast();
     //    printf("-> ProcMat %d (%d->%d)\n",ip,pFrom,pTo);
-    if (!propagateToPoint(trc, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), &matTL, signELoss)) { // with material corrections
+    if (!propagateToPoint(trc, nullptr, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType(algConf.matCorType), &matTL, signELoss)) { // with material corrections
       if (algConf.verbose > 2) {
         LOG(error) << "Failed to take track to point" << ip << " (dir: " << pFrom << "->" << pTo << ") with mat.corr.";
         trc.print();
@@ -1346,7 +1359,7 @@ bool AlignmentTrack::processMaterials(trackParam_t& trc, int pFrom, int pTo)
     //
     // is there enough material to consider the point as a scatterer?
     bool hasMaterial = matTL.getX2X0() > minX2X0;
-    if (!propagateToPoint(tr0, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType::USEMatCorrNONE, nullptr, signELoss)) { // no material corrections
+    if (!propagateToPoint(tr0, nullptr, pnt, algConf.maxStep, algConf.maxSnp, MatCorrType::USEMatCorrNONE, nullptr, signELoss)) { // no material corrections
       if (algConf.verbose > 2) {
         LOG(error) << "Failed to take track to point" << ip << " (dir: " << pFrom << "->" << pTo << ") with mat.corr.";
         tr0.print();
diff --git a/Detectors/Base/include/DetectorsBase/Propagator.h b/Detectors/Base/include/DetectorsBase/Propagator.h
index 6fa750577255d..75b9446aebade 100644
--- a/Detectors/Base/include/DetectorsBase/Propagator.h
+++ b/Detectors/Base/include/DetectorsBase/Propagator.h
@@ -127,6 +127,9 @@ class PropagatorImpl
   GPUd() bool propagateToAlphaX(track_T& track, value_type alpha, value_type x, bool bzOnly = false, value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, int minSteps = 1,
                                 MatCorrType matCorr = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
 
+  GPUd() bool propagateToAlphaX(TrackParCov_t& track, TrackPar_t* linRef, value_type alpha, value_type x, bool bzOnly = false, value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP, int minSteps = 1,
+                                MatCorrType matCorr = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
+
   template <typename track_T>
   GPUd() bool propagateToR(track_T& track, value_type r, bool bzOnly = false, value_type maxSnp = MAX_SIN_PHI, value_type maxStep = MAX_STEP,
                            MatCorrType matCorr = MatCorrType::USEMatCorrLUT, track::TrackLTIntegral* tofInfo = nullptr, int signCorr = 0) const;
diff --git a/Detectors/Base/src/Propagator.cxx b/Detectors/Base/src/Propagator.cxx
index 02e7a05080ac5..a5983cab8e257 100644
--- a/Detectors/Base/src/Propagator.cxx
+++ b/Detectors/Base/src/Propagator.cxx
@@ -648,6 +648,23 @@ GPUd() bool PropagatorImpl<value_T>::propagateToR(track_T& track, value_type r,
   return propagateToX(track, xfin, bzOnly, maxSnp, maxStep, matCorr, tofInfo, signCorr);
 }
 
+template <typename value_T>
+GPUd() bool PropagatorImpl<value_T>::propagateToAlphaX(TrackParCov_t& track, TrackPar_t* linRef, value_type alpha, value_type x, bool bzOnly, value_type maxSnp, value_type maxStep, int minSteps,
+                                                       MatCorrType matCorr, track::TrackLTIntegral* tofInfo, int signCorr) const
+{
+  // propagate to alpha,X, if needed in a few steps
+  auto snp = track.getSnpAt(alpha, x, getNominalBz());
+  // apply safety factor 0.9 for crude rotation estimate
+  if (math_utils::detail::abs<value_type>(snp) < maxSnp * 0.9 && (linRef ? track.rotate(alpha, *linRef, getNominalBz()) : track.rotate(alpha))) {
+    auto dx = math_utils::detail::abs<value_type>(x - track.getX());
+    if (dx < Epsilon) {
+      return true;
+    }
+    return propagateTo(track, linRef, x, bzOnly, maxSnp, math_utils::detail::min<value_type>(dx / minSteps, maxStep), matCorr, tofInfo, signCorr);
+  }
+  return false;
+}
+
 //_______________________________________________________________________
 template <typename value_T>
 template <typename track_T>

From 99a77145c00dd215ddbc537b046173b1cbc13724 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Thu, 4 Dec 2025 21:25:19 +0100
Subject: [PATCH 1104/1764] Add possibility for head only object

In case the file name is set to 'headersOnly' an empty object with only
headers is created. This is e.g. necessary for pure redirect entries.
---
 CCDB/src/UploadTool.cxx | 54 +++++++++++++++++++++++------------------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/CCDB/src/UploadTool.cxx b/CCDB/src/UploadTool.cxx
index 44b8d8e20bc7d..83b395bedb046 100644
--- a/CCDB/src/UploadTool.cxx
+++ b/CCDB/src/UploadTool.cxx
@@ -147,33 +147,41 @@ int main(int argc, char* argv[])
     meta[p.first] = p.second;
   }
 
-  TFile f(filename.c_str());
-  auto key = f.GetKey(keyname.c_str());
-  if (key) {
-    // get type of key
-    auto classname = key->GetClassName();
-    auto tcl = TClass::GetClass(classname);
-    auto object = f.Get<void>(keyname.c_str());
-    if (tcl->InheritsFrom("TTree")) {
-      auto tree = static_cast<TTree*>(object);
-      tree->LoadBaskets(0x1L << 32); // make tree memory based
-      tree->SetDirectory(nullptr);
-    }
-    // convert classname to typeinfo
-    // typeinfo
-    auto ti = tcl->GetTypeInfo();
-
-    std::cout << " Uploading an object of type " << key->GetClassName()
-              << " to path " << path << " with timestamp validity from " << starttimestamp
-              << " to " << endtimestamp << "\n";
-
-    api.storeAsTFile_impl(object, *ti, path, meta, starttimestamp, endtimestamp);
+  if (filename == "headersOnly") {
+    api.storeAsBinaryFile(nullptr, 0, "ignored", "", path, meta, starttimestamp, endtimestamp);
     if (!api.isSnapshotMode() && meta.find("adjustableEOV") != meta.end() && meta.find("default") == meta.end()) {
-      o2::ccdb::CcdbObjectInfo oi(path, classname, filename, meta, starttimestamp, endtimestamp);
+      o2::ccdb::CcdbObjectInfo oi(path, "", "", meta, starttimestamp, endtimestamp);
       o2::ccdb::adjustOverriddenEOV(api, oi);
     }
   } else {
-    std::cerr << "Key " << keyname << " does not exist\n";
+    TFile f(filename.c_str());
+    auto key = f.GetKey(keyname.c_str());
+    if (key) {
+      // get type of key
+      auto classname = key->GetClassName();
+      auto tcl = TClass::GetClass(classname);
+      auto object = f.Get<void>(keyname.c_str());
+      if (tcl->InheritsFrom("TTree")) {
+        auto tree = static_cast<TTree*>(object);
+        tree->LoadBaskets(0x1L << 32); // make tree memory based
+        tree->SetDirectory(nullptr);
+      }
+      // convert classname to typeinfo
+      // typeinfo
+      auto ti = tcl->GetTypeInfo();
+
+      std::cout << " Uploading an object of type " << key->GetClassName()
+                << " to path " << path << " with timestamp validity from " << starttimestamp
+                << " to " << endtimestamp << "\n";
+
+      api.storeAsTFile_impl(object, *ti, path, meta, starttimestamp, endtimestamp);
+      if (!api.isSnapshotMode() && meta.find("adjustableEOV") != meta.end() && meta.find("default") == meta.end()) {
+        o2::ccdb::CcdbObjectInfo oi(path, classname, filename, meta, starttimestamp, endtimestamp);
+        o2::ccdb::adjustOverriddenEOV(api, oi);
+      }
+    } else {
+      std::cerr << "Key " << keyname << " does not exist\n";
+    }
   }
 
   return 0;

From 348e9b1a7fd56c499caafe255485af6aff9e0c04 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 5 Dec 2025 11:11:45 +0100
Subject: [PATCH 1105/1764] DPL: refactor input forwarding routing

Separate routing of the forwarding to a separate helper.

Add test for said helper.
---
 Framework/Core/CMakeLists.txt                 |   1 +
 .../include/Framework/DataProcessingHelpers.h |  11 +-
 Framework/Core/src/DataProcessingDevice.cxx   | 125 +---
 Framework/Core/src/DataProcessingHelpers.cxx  | 134 ++++
 Framework/Core/test/test_ForwardInputs.cxx    | 691 ++++++++++++++++++
 5 files changed, 838 insertions(+), 124 deletions(-)
 create mode 100644 Framework/Core/test/test_ForwardInputs.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index ce8fbb0dc55f7..fe8a91eaa0449 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -224,6 +224,7 @@ add_executable(o2-test-framework-core
               test/test_FairMQOptionsRetriever.cxx
               test/test_FairMQResizableBuffer.cxx
               test/test_FairMQ.cxx
+              test/test_ForwardInputs.cxx
               test/test_FrameworkDataFlowToDDS.cxx
               test/test_FrameworkDataFlowToO2Control.cxx
               test/test_Graphviz.cxx
diff --git a/Framework/Core/include/Framework/DataProcessingHelpers.h b/Framework/Core/include/Framework/DataProcessingHelpers.h
index d8d8b7caf9d0a..be02aae5d2f69 100644
--- a/Framework/Core/include/Framework/DataProcessingHelpers.h
+++ b/Framework/Core/include/Framework/DataProcessingHelpers.h
@@ -12,6 +12,10 @@
 #define O2_FRAMEWORK_DATAPROCESSINGHELPERS_H_
 
 #include <cstddef>
+#include "Framework/TimesliceSlot.h"
+#include "Framework/TimesliceIndex.h"
+#include <fairmq/FwdDecls.h>
+#include <vector>
 
 namespace o2::framework
 {
@@ -23,6 +27,9 @@ struct OutputChannelSpec;
 struct OutputChannelState;
 struct ProcessingPolicies;
 struct DeviceSpec;
+struct FairMQDeviceProxy;
+struct MessageSet;
+struct ChannelIndex;
 enum struct StreamingState;
 enum struct TransitionHandlingState;
 
@@ -45,7 +52,9 @@ struct DataProcessingHelpers {
   static bool hasOnlyGenerated(DeviceSpec const& spec);
   /// starts the EoS timers and returns the new TransitionHandlingState in case as new state is requested
   static TransitionHandlingState updateStateTransition(ServiceRegistryRef const& ref, ProcessingPolicies const& policies);
+  /// Helper to route messages for forwarding
+  static std::vector<fair::mq::Parts> routeForwardedMessages(FairMQDeviceProxy& proxy, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
+                                                             TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume);
 };
-
 } // namespace o2::framework
 #endif // O2_FRAMEWORK_DATAPROCESSINGHELPERS_H_
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 3e9a0a3d996b9..406e93aaae98e 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -550,69 +550,6 @@ void on_signal_callback(uv_signal_t* handle, int signum)
   O2_SIGNPOST_END(device, sid, "signal_state", "Done processing signals.");
 }
 
-static auto toBeForwardedHeader = [](void* header) -> bool {
-  // If is now possible that the record is not complete when
-  // we forward it, because of a custom completion policy.
-  // this means that we need to skip the empty entries in the
-  // record for being forwarded.
-  if (header == nullptr) {
-    return false;
-  }
-  auto dh = o2::header::get<DataHeader*>(header);
-  if (!dh) {
-    return false;
-  }
-  bool retval = !o2::header::get<SourceInfoHeader*>(header) &&
-                !o2::header::get<DomainInfoHeader*>(header) &&
-                o2::header::get<DataProcessingHeader*>(header);
-  // DataHeader is there. Complain if we have unexpected headers present / missing
-  if (!retval) {
-    LOGP(error, "Dropping data because of malformed header structure");
-  }
-  return retval;
-};
-
-static auto toBeforwardedMessageSet = [](std::vector<ChannelIndex>& cachedForwardingChoices,
-                                         FairMQDeviceProxy& proxy,
-                                         std::unique_ptr<fair::mq::Message>& header,
-                                         std::unique_ptr<fair::mq::Message>& payload,
-                                         size_t total,
-                                         bool consume) {
-  if (header.get() == nullptr) {
-    // Missing an header is not an error anymore.
-    // it simply means that we did not receive the
-    // given input, but we were asked to
-    // consume existing, so we skip it.
-    return false;
-  }
-  if (payload.get() == nullptr && consume == true) {
-    // If the payload is not there, it means we already
-    // processed it with ConsumeExisiting. Therefore we
-    // need to do something only if this is the last consume.
-    header.reset(nullptr);
-    return false;
-  }
-
-  auto fdph = o2::header::get<DataProcessingHeader*>(header->GetData());
-  if (fdph == nullptr) {
-    LOG(error) << "Data is missing DataProcessingHeader";
-    return false;
-  }
-  auto fdh = o2::header::get<DataHeader*>(header->GetData());
-  if (fdh == nullptr) {
-    LOG(error) << "Data is missing DataHeader";
-    return false;
-  }
-
-  // We need to find the forward route only for the first
-  // part of a split payload. All the others will use the same.
-  // but always check if we have a sequence of multiple payloads
-  if (fdh->splitPayloadIndex == 0 || fdh->splitPayloadParts <= 1 || total > 1) {
-    proxy.getMatchingForwardChannelIndexes(cachedForwardingChoices, *fdh, fdph->startTime);
-  }
-  return cachedForwardingChoices.empty() == false;
-};
-
 struct DecongestionContext {
   ServiceRegistryRef ref;
   TimesliceIndex::OldestOutputInfo oldestTimeslice;
@@ -653,67 +590,9 @@ auto decongestionCallbackLate = [](AsyncTask& task, size_t aid) -> void {
 static auto forwardInputs = [](ServiceRegistryRef registry, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
                                TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume = true) {
   auto& proxy = registry.get<FairMQDeviceProxy>();
-  // we collect all messages per forward in a map and send them together
-  std::vector<fair::mq::Parts> forwardedParts;
-  forwardedParts.resize(proxy.getNumForwards());
-  std::vector<ChannelIndex> cachedForwardingChoices{};
-  O2_SIGNPOST_ID_GENERATE(sid, forwarding);
-  O2_SIGNPOST_START(forwarding, sid, "forwardInputs", "Starting forwarding for slot %zu with oldestTimeslice %zu %{public}s%{public}s%{public}s",
-                    slot.index, oldestTimeslice.timeslice.value, copy ? "with copy" : "", copy && consume ? " and " : "", consume ? "with consume" : "");
-
-  for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
-    auto& messageSet = currentSetOfInputs[ii];
-    // In case the messageSet is empty, there is nothing to be done.
-    if (messageSet.size() == 0) {
-      continue;
-    }
-    if (!toBeForwardedHeader(messageSet.header(0)->GetData())) {
-      continue;
-    }
-    cachedForwardingChoices.clear();
-
-    for (size_t pi = 0; pi < currentSetOfInputs[ii].size(); ++pi) {
-      auto& messageSet = currentSetOfInputs[ii];
-      auto& header = messageSet.header(pi);
-      auto& payload = messageSet.payload(pi);
-      auto total = messageSet.getNumberOfPayloads(pi);
-
-      if (!toBeforwardedMessageSet(cachedForwardingChoices, proxy, header, payload, total, consume)) {
-        continue;
-      }
+  auto forwardedParts = DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copy, consume);
 
-      // In case of more than one forward route, we need to copy the message.
-      // This will eventually use the same mamory if running with the same backend.
-      if (cachedForwardingChoices.size() > 1) {
-        copy = true;
-      }
-      auto* dh = o2::header::get<DataHeader*>(header->GetData());
-      auto* dph = o2::header::get<DataProcessingHeader*>(header->GetData());
-
-      if (copy) {
-        for (auto& cachedForwardingChoice : cachedForwardingChoices) {
-          auto&& newHeader = header->GetTransport()->CreateMessage();
-          O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding a copy of %{public}s to route %d.",
-                                 fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), cachedForwardingChoice.value);
-          newHeader->Copy(*header);
-          forwardedParts[cachedForwardingChoice.value].AddPart(std::move(newHeader));
-
-          for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) {
-            auto&& newPayload = header->GetTransport()->CreateMessage();
-            newPayload->Copy(*messageSet.payload(pi, payloadIndex));
-            forwardedParts[cachedForwardingChoice.value].AddPart(std::move(newPayload));
-          }
-        }
-      } else {
-        O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding %{public}s to route %d.",
-                               fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), cachedForwardingChoices.back().value);
-        forwardedParts[cachedForwardingChoices.back().value].AddPart(std::move(messageSet.header(pi)));
-        for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) {
-          forwardedParts[cachedForwardingChoices.back().value].AddPart(std::move(messageSet.payload(pi, payloadIndex)));
-        }
-      }
-    }
-  }
+  O2_SIGNPOST_ID_GENERATE(sid, forwarding);
   O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding %zu messages", forwardedParts.size());
   for (int fi = 0; fi < proxy.getNumForwardChannels(); fi++) {
     if (forwardedParts[fi].Size() == 0) {
diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index e144f426372b1..9c53bbf8b2c10 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -16,6 +16,7 @@
 #include "MemoryResources/MemoryResources.h"
 #include "Framework/FairMQDeviceProxy.h"
 #include "Headers/DataHeader.h"
+#include "Headers/DataHeaderHelpers.h"
 #include "Headers/Stack.h"
 #include "Framework/Logger.h"
 #include "Framework/SendingPolicy.h"
@@ -31,6 +32,8 @@
 #include "Framework/ControlService.h"
 #include "Framework/DataProcessingContext.h"
 #include "Framework/DeviceStateEnums.h"
+#include "Headers/DataHeader.h"
+#include "Framework/DataProcessingHeader.h"
 
 #include <fairmq/Device.h>
 #include <fairmq/Channel.h>
@@ -41,6 +44,7 @@
 O2_DECLARE_DYNAMIC_LOG(device);
 // Stream which keeps track of the calibration lifetime logic
 O2_DECLARE_DYNAMIC_LOG(calibration);
+O2_DECLARE_DYNAMIC_LOG(forwarding);
 
 namespace o2::framework
 {
@@ -217,4 +221,134 @@ TransitionHandlingState DataProcessingHelpers::updateStateTransition(ServiceRegi
   }
 }
 
+static auto toBeForwardedHeader = [](void* header) -> bool {
+  // If is now possible that the record is not complete when
+  // we forward it, because of a custom completion policy.
+  // this means that we need to skip the empty entries in the
+  // record for being forwarded.
+  if (header == nullptr) {
+    return false;
+  }
+  auto dh = o2::header::get<header::DataHeader*>(header);
+  if (!dh) {
+    return false;
+  }
+  bool retval = !o2::header::get<SourceInfoHeader*>(header) &&
+                !o2::header::get<DomainInfoHeader*>(header) &&
+                o2::header::get<DataProcessingHeader*>(header);
+  // DataHeader is there. Complain if we have unexpected headers present / missing
+  if (!retval) {
+    LOGP(error, "Dropping data because of malformed header structure");
+  }
+  return retval;
+};
+
+static auto toBeforwardedMessageSet = [](std::vector<ChannelIndex>& cachedForwardingChoices,
+                                         FairMQDeviceProxy& proxy,
+                                         std::unique_ptr<fair::mq::Message>& header,
+                                         std::unique_ptr<fair::mq::Message>& payload,
+                                         size_t total,
+                                         bool consume) {
+  if (header.get() == nullptr) {
+    // Missing an header is not an error anymore.
+    // it simply means that we did not receive the
+    // given input, but we were asked to
+    // consume existing, so we skip it.
+    return false;
+  }
+  if (payload.get() == nullptr && consume == true) {
+    // If the payload is not there, it means we already
+    // processed it with ConsumeExisiting. Therefore we
+    // need to do something only if this is the last consume.
+    header.reset(nullptr);
+    return false;
+  }
+
+  auto fdph = o2::header::get<DataProcessingHeader*>(header->GetData());
+  if (fdph == nullptr) {
+    LOG(error) << "Data is missing DataProcessingHeader";
+    return false;
+  }
+  auto fdh = o2::header::get<header::DataHeader*>(header->GetData());
+  if (fdh == nullptr) {
+    LOG(error) << "Data is missing DataHeader";
+    return false;
+  }
+
+  // We need to find the forward route only for the first
+  // part of a split payload. All the others will use the same.
+  // but always check if we have a sequence of multiple payloads
+  if (fdh->splitPayloadIndex == 0 || fdh->splitPayloadParts <= 1 || total > 1) {
+    proxy.getMatchingForwardChannelIndexes(cachedForwardingChoices, *fdh, fdph->startTime);
+  }
+  return cachedForwardingChoices.empty() == false;
+};
+
+std::vector<fair::mq::Parts> DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
+                                                                           TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume)
+{
+  // we collect all messages per forward in a map and send them together
+  std::vector<fair::mq::Parts> forwardedParts;
+  forwardedParts.resize(proxy.getNumForwards());
+  std::vector<ChannelIndex> cachedForwardingChoices{};
+  O2_SIGNPOST_ID_GENERATE(sid, forwarding);
+  O2_SIGNPOST_START(forwarding, sid, "forwardInputs", "Starting forwarding for slot %zu with oldestTimeslice %zu %{public}s%{public}s%{public}s",
+                    slot.index, oldestTimeslice.timeslice.value, copy ? "with copy" : "", copy && consume ? " and " : "", consume ? "with consume" : "");
+
+  for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
+    auto& messageSet = currentSetOfInputs[ii];
+    // In case the messageSet is empty, there is nothing to be done.
+    if (messageSet.size() == 0) {
+      continue;
+    }
+    if (!toBeForwardedHeader(messageSet.header(0)->GetData())) {
+      continue;
+    }
+    cachedForwardingChoices.clear();
+
+    for (size_t pi = 0; pi < currentSetOfInputs[ii].size(); ++pi) {
+      auto& messageSet = currentSetOfInputs[ii];
+      auto& header = messageSet.header(pi);
+      auto& payload = messageSet.payload(pi);
+      auto total = messageSet.getNumberOfPayloads(pi);
+
+      if (!toBeforwardedMessageSet(cachedForwardingChoices, proxy, header, payload, total, consume)) {
+        continue;
+      }
+
+      // In case of more than one forward route, we need to copy the message.
+      // This will eventually use the same mamory if running with the same backend.
+      if (cachedForwardingChoices.size() > 1) {
+        copy = true;
+      }
+      auto* dh = o2::header::get<header::DataHeader*>(header->GetData());
+      auto* dph = o2::header::get<DataProcessingHeader*>(header->GetData());
+
+      if (copy) {
+        for (auto& cachedForwardingChoice : cachedForwardingChoices) {
+          auto&& newHeader = header->GetTransport()->CreateMessage();
+          O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding a copy of %{public}s to route %d.",
+                                 fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), cachedForwardingChoice.value);
+          newHeader->Copy(*header);
+          forwardedParts[cachedForwardingChoice.value].AddPart(std::move(newHeader));
+
+          for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) {
+            auto&& newPayload = header->GetTransport()->CreateMessage();
+            newPayload->Copy(*messageSet.payload(pi, payloadIndex));
+            forwardedParts[cachedForwardingChoice.value].AddPart(std::move(newPayload));
+          }
+        }
+      } else {
+        O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding %{public}s to route %d.",
+                               fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), cachedForwardingChoices.back().value);
+        forwardedParts[cachedForwardingChoices.back().value].AddPart(std::move(messageSet.header(pi)));
+        for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) {
+          forwardedParts[cachedForwardingChoices.back().value].AddPart(std::move(messageSet.payload(pi, payloadIndex)));
+        }
+      }
+    }
+  }
+  return forwardedParts;
+};
+
 } // namespace o2::framework
diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
new file mode 100644
index 0000000000000..1406110e0e9ee
--- /dev/null
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -0,0 +1,691 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <catch_amalgamated.hpp>
+#include "Headers/DataHeader.h"
+#include "Framework/DataProcessingHeader.h"
+#include "Framework/DataProcessingHelpers.h"
+#include "Framework/SourceInfoHeader.h"
+#include "Framework/DomainInfoHeader.h"
+#include "Framework/ServiceRegistry.h"
+#include "Framework/ServiceRegistryRef.h"
+#include "Framework/Signpost.h"
+#include "Framework/MessageSet.h"
+#include "Framework/FairMQDeviceProxy.h"
+#include "Headers/Stack.h"
+#include "MemoryResources/MemoryResources.h"
+#include <fairmq/TransportFactory.h>
+#include <fairmq/Channel.h>
+#include <vector>
+
+O2_DECLARE_DYNAMIC_LOG(forwarding);
+using namespace o2::framework;
+
+TEST_CASE("ForwardInputsEmpty")
+{
+  o2::header::DataHeader dh;
+  dh.dataDescription = "CLUSTERS";
+  dh.dataOrigin = "TPC";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {1}};
+  std::vector<MessageSet> currentSetOfInputs;
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.empty());
+}
+
+TEST_CASE("ForwardInputsSingleMessageSingleRoute")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B")};
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{ForwardRoute{
+    .timeslice = 0,
+    .maxTimeslices = 1,
+    .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+    .channel = "from_A_to_B",
+    .policy = nullptr,
+  }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 1);    // One route
+  REQUIRE(result[0].Size() == 2); // Two messages for that route
+}
+
+TEST_CASE("ForwardInputsSingleMessageSingleRouteAtEOS")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+
+  o2::framework::SourceInfoHeader sih{};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B")};
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{ForwardRoute{
+    .timeslice = 0,
+    .maxTimeslices = 1,
+    .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+    .channel = "from_A_to_B",
+    .policy = nullptr,
+  }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph, sih});
+  REQUIRE(o2::header::get<SourceInfoHeader*>(header->GetData()));
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 1);    // One route
+  REQUIRE(result[0].Size() == 0); // FIXME: this is an actual error. It should be 2
+  // Correct behavior below:
+  // REQUIRE(result[0].Size() == 2);
+  // REQUIRE(o2::header::get<SourceInfoHeader*>(result[0].At(0)->GetData()) == nullptr);
+}
+
+TEST_CASE("ForwardInputsSingleMessageSingleRouteWithOldestPossible")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+
+  o2::framework::DomainInfoHeader dih{};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B")};
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{ForwardRoute{
+    .timeslice = 0,
+    .maxTimeslices = 1,
+    .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+    .channel = "from_A_to_B",
+    .policy = nullptr,
+  }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph, dih});
+  REQUIRE(o2::header::get<DomainInfoHeader*>(header->GetData()));
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 1);    // One route
+  REQUIRE(result[0].Size() == 0); // FIXME: this is actually wrong
+  // FIXME: actually correct behavior below
+  // REQUIRE(result[0].Size() == 2);                                                     // Two messages
+  // REQUIRE(o2::header::get<DomainInfoHeader*>(result[0].At(0)->GetData()) == nullptr); // it should not have the end of stream
+}
+
+TEST_CASE("ForwardInputsSingleMessageMultipleRoutes")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B"),
+    fair::mq::Channel("from_A_to_C"),
+  };
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+      .channel = "from_A_to_B",
+      .policy = nullptr,
+    },
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding2", ConcreteDataMatcher{"TST", "A", 0}},
+      .channel = "from_A_to_C",
+      .policy = nullptr,
+    }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 2);    // Two routes
+  REQUIRE(result[0].Size() == 2); // Two messages per route
+  REQUIRE(result[1].Size() == 0); // Only the first DPL matched channel matters
+}
+
+TEST_CASE("ForwardInputsSingleMessageMultipleRoutesExternals")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("external"),
+    fair::mq::Channel("from_A_to_C"),
+  };
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+      .channel = "external",
+      .policy = nullptr,
+    },
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding2", ConcreteDataMatcher{"TST", "A", 0}},
+      .channel = "from_A_to_C",
+      .policy = nullptr,
+    }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 2);    // Two routes
+  REQUIRE(result[0].Size() == 2); // With external matching channels, we need to copy and then forward
+  REQUIRE(result[1].Size() == 2); //
+}
+
+TEST_CASE("ForwardInputsMultiMessageMultipleRoutes")
+{
+  o2::header::DataHeader dh1;
+  dh1.dataOrigin = "TST";
+  dh1.dataDescription = "A";
+  dh1.subSpecification = 0;
+  dh1.splitPayloadIndex = 0;
+  dh1.splitPayloadParts = 1;
+
+  o2::header::DataHeader dh2;
+  dh2.dataOrigin = "TST";
+  dh2.dataDescription = "B";
+  dh2.subSpecification = 0;
+  dh2.splitPayloadIndex = 0;
+  dh2.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B"),
+    fair::mq::Channel("from_A_to_C"),
+  };
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+      .channel = "from_A_to_B",
+      .policy = nullptr,
+    },
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding2", ConcreteDataMatcher{"TST", "B", 0}},
+      .channel = "from_A_to_C",
+      .policy = nullptr,
+    }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload1(transport->CreateMessage());
+  fair::mq::MessagePtr payload2(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header1 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh1, dph});
+  MessageSet messageSet1;
+  messageSet1.add(PartRef{std::move(header1), std::move(payload1)});
+  REQUIRE(messageSet1.size() == 1);
+
+  auto header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
+  MessageSet messageSet2;
+  messageSet2.add(PartRef{std::move(header2), std::move(payload2)});
+  REQUIRE(messageSet2.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet1));
+  currentSetOfInputs.emplace_back(std::move(messageSet2));
+  REQUIRE(currentSetOfInputs.size() == 2);
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 2);    // Two routes
+  REQUIRE(result[0].Size() == 2); //
+  REQUIRE(result[1].Size() == 2); //
+}
+
+TEST_CASE("ForwardInputsSingleMessageMultipleRoutesOnlyOneMatches")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B"),
+    fair::mq::Channel("from_A_to_C"),
+  };
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "B", 0}},
+      .channel = "from_A_to_B",
+      .policy = nullptr,
+    },
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+      .channel = "from_A_to_C",
+      .policy = nullptr,
+    }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 2);    // Two routes
+  REQUIRE(result[0].Size() == 0); // Two messages per route
+  REQUIRE(result[1].Size() == 2); // Two messages per route
+}
+
+TEST_CASE("ForwardInputsSplitPayload")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 2;
+
+  o2::header::DataHeader dh2;
+  dh2.dataOrigin = "TST";
+  dh2.dataDescription = "B";
+  dh2.subSpecification = 0;
+  dh2.splitPayloadIndex = 0;
+  dh2.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B"),
+    fair::mq::Channel("from_A_to_C"),
+  };
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "B", 0}},
+      .channel = "from_A_to_B",
+      .policy = nullptr,
+    },
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+      .channel = "from_A_to_C",
+      .policy = nullptr,
+    }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload1(transport->CreateMessage());
+  fair::mq::MessagePtr payload2(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+  std::vector<std::unique_ptr<fair::mq::Message>> messages;
+  messages.push_back(std::move(header));
+  messages.push_back(std::move(payload1));
+  messages.push_back(std::move(payload2));
+  auto fillMessages = [&messages](size_t t) -> fair::mq::MessagePtr {
+    return std::move(messages[t]);
+  };
+  messageSet.add(fillMessages, 3);
+  auto header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
+  PartRef part{std::move(header2), transport->CreateMessage()};
+  messageSet.add(std::move(part));
+
+  REQUIRE(messageSet.size() == 2);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 2);  // Two routes
+  CHECK(result[0].Size() == 2); // No messages on this route
+  CHECK(result[1].Size() == 5); // FIXME: Multipart matching has side effects also for the elements
+  // CHECK(result[1].Size() == 3); // FIXME: the correct forwarding is that only the multipart goes to the same route
+}
+
+TEST_CASE("ForwardInputEOSSingleRoute")
+{
+  o2::framework::SourceInfoHeader sih{};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B")};
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{ForwardRoute{
+    .timeslice = 0,
+    .maxTimeslices = 1,
+    .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+    .channel = "from_A_to_B",
+    .policy = nullptr,
+  }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, sih});
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 1);    // One route
+  REQUIRE(result[0].Size() == 0); // Oldest possible timeframe should not be forwarded
+}
+
+TEST_CASE("ForwardInputOldestPossibleSingleRoute")
+{
+  o2::framework::DomainInfoHeader dih{};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B")};
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{ForwardRoute{
+    .timeslice = 0,
+    .maxTimeslices = 1,
+    .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+    .channel = "from_A_to_B",
+    .policy = nullptr,
+  }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dih});
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  REQUIRE(result.size() == 1);    // One route
+  REQUIRE(result[0].Size() == 0); // Oldest possible timeframe should not be forwarded
+}

From b6c63a0b2c0072f00673ca29b38479713f4bbdf1 Mon Sep 17 00:00:00 2001
From: Rita Sadek <rita.sadek@cern.ch>
Date: Sat, 6 Dec 2025 05:41:47 -0800
Subject: [PATCH 1106/1764] [FT3] Modular structure for OT disks - first
 version of modules structure with dynamic disks paving for ALICE 3 sensors
 and initial material estimations (#14816)

Co-authored-by: Rita Sadek <rsadek@Ritas-MBP.dhcp.lbl.gov>
---
 .../ALICE3/FT3/simulation/CMakeLists.txt      |   8 +-
 .../include/FT3Simulation/FT3Layer.h          |  19 +
 .../include/FT3Simulation/FT3Module.h         |  45 ++
 .../ALICE3/FT3/simulation/src/Detector.cxx    |  22 +-
 .../ALICE3/FT3/simulation/src/FT3Layer.cxx    | 182 ++++-
 .../ALICE3/FT3/simulation/src/FT3Module.cxx   | 699 ++++++++++++++++++
 6 files changed, 967 insertions(+), 8 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h
 create mode 100644 Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/FT3/simulation/CMakeLists.txt
index 89f8c23797fac..23414d4ae7269 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/CMakeLists.txt
@@ -10,14 +10,18 @@
 # or submit itself to any jurisdiction.
 
 o2_add_library(FT3Simulation
-               SOURCES src/FT3Layer.cxx
+               SOURCES
+                       src/FT3Module.cxx
+                       src/FT3Layer.cxx
                        src/Detector.cxx
                PUBLIC_LINK_LIBRARIES O2::FT3Base
                                      O2::ITSMFTSimulation
                                      ROOT::Physics)
 
 o2_target_root_dictionary(FT3Simulation
-                          HEADERS include/FT3Simulation/Detector.h
+                          HEADERS
+                                  include/FT3Simulation/FT3Module.h
+                                  include/FT3Simulation/Detector.h
                                   include/FT3Simulation/FT3Layer.h)
 
 o2_data_file(COPY data  DESTINATION Detectors/FT3/simulation)
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
index 7159f2a6d1d9f..44a0ef0f7d8bc 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
@@ -18,6 +18,7 @@
 #include <TGeoManager.h>            // for gGeoManager
 #include "Rtypes.h"                 // for Double_t, Int_t, Bool_t, etc
 #include "FT3Simulation/Detector.h" // for Detector, Detector::Model
+#include "FT3Simulation/FT3Module.h"
 
 class TGeoVolume;
 
@@ -57,6 +58,24 @@ class FT3Layer : public TObject
   /// \param motherVolume the TGeoVolume owing the volume structure
   virtual void createLayer(TGeoVolume* motherVolume);
 
+  static void initialize_mat();
+
+  // create layer for disk support
+  void createSeparationLayer(TGeoVolume* motherVolume, const std::string& separationLayerName);
+  void createSeparationLayer_waterCooling(TGeoVolume* motherVolume, const std::string& separationLayerName);
+
+  static TGeoMaterial* carbonFiberMat;
+  static TGeoMedium* medCarbonFiber;
+
+  static TGeoMaterial* kaptonMat;
+  static TGeoMedium* kaptonMed;
+
+  static TGeoMaterial* waterMat;
+  static TGeoMedium* waterMed;
+
+  static TGeoMaterial* foamMat;
+  static TGeoMedium* medFoam;
+
  private:
   Int_t mLayerNumber = -1; ///< Current layer number
   Int_t mDirection;        ///< Layer direction 0=Forward 1 = Backward
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h
new file mode 100644
index 0000000000000..15ac6be995646
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h
@@ -0,0 +1,45 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FT3Module.h
+/// \brief Definition of the FT3Module class
+
+#ifndef FT3MODULE_H
+#define FT3MODULE_H
+
+#include <TGeoVolume.h>
+#include <string>
+
+class FT3Module
+{
+
+ public:
+  static void initialize_materials();
+  static TGeoMaterial* siliconMat;
+  static TGeoMedium* siliconMed;
+  static TGeoMaterial* copperMat;
+  static TGeoMedium* copperMed;
+  static TGeoMaterial* kaptonMat;
+  static TGeoMedium* kaptonMed;
+  static TGeoMaterial* epoxyMat;
+  static TGeoMedium* epoxyMed;
+  static TGeoMaterial* AluminumMat;
+  static TGeoMedium* AluminumMed;
+
+  const char* mDetName;
+
+  static void createModule(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume);
+
+ private:
+  static void create_layout(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume);
+};
+
+#endif // FT3MODULE_H
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index ce132fdb33cd3..aab8ae070d936 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -40,6 +40,8 @@
 
 #include <cstdio> // for NULL, snprintf
 
+#define MAX_SENSORS 2000
+
 class FairModule;
 
 class TGeoMedium;
@@ -729,9 +731,23 @@ void Detector::defineSensitiveVolumes()
     for (int direction : {0, 1}) {
       for (int iLayer = 0; iLayer < mNumberOfLayers; iLayer++) {
         volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer);
-        v = geoManager->GetVolume(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer));
-        LOG(info) << "Adding FT3 Sensitive Volume => " << v->GetName();
-        AddSensitiveVolume(v);
+        if (iLayer < 3) { // ML disks
+          v = geoManager->GetVolume(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer));
+          AddSensitiveVolume(v);
+        } else { // OT disks
+          for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) {
+            std::string sensor_name_front = "FT3sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+            std::string sensor_name_back = "FT3sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+            v = geoManager->GetVolume(sensor_name_front.c_str());
+            if (v) {
+              AddSensitiveVolume(v);
+            }
+            v = geoManager->GetVolume(sensor_name_back.c_str());
+            if (v) {
+              AddSensitiveVolume(v);
+            }
+          }
+        }
       }
     }
   }
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
index 01b512b996af2..97f42eca6143f 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -28,7 +28,10 @@
 #include "TMathBase.h"          // for Abs
 #include <TMath.h>              // for Sin, RadToDeg, DegToRad, Cos, Tan, etc
 
+#include <TGeoBBox.h>
+#include <string>
 #include <cstdio> // for snprintf
+#include <cmath>
 
 class TGeoMedium;
 
@@ -40,6 +43,18 @@ ClassImp(FT3Layer);
 
 FT3Layer::~FT3Layer() = default;
 
+TGeoMaterial* FT3Layer::carbonFiberMat = nullptr;
+TGeoMedium* FT3Layer::medCarbonFiber = nullptr;
+
+TGeoMaterial* FT3Layer::kaptonMat = nullptr;
+TGeoMedium* FT3Layer::kaptonMed = nullptr;
+
+TGeoMaterial* FT3Layer::waterMat = nullptr;
+TGeoMedium* FT3Layer::waterMed = nullptr;
+
+TGeoMaterial* FT3Layer::foamMat = nullptr;
+TGeoMedium* FT3Layer::medFoam = nullptr;
+
 FT3Layer::FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0)
 {
   // Creates a simple parametrized EndCap layer covering the given
@@ -59,10 +74,157 @@ FT3Layer::FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerNam
   LOG(info) << "   Layer z = " << mZ << " ; R_in = " << mInnerRadius << " ; R_out = " << mOuterRadius << " ; x2X0 = " << mx2X0 << " ; ChipThickness = " << mChipThickness;
 }
 
+void FT3Layer::initialize_mat()
+{
+
+  if (carbonFiberMat) {
+    return;
+  }
+
+  carbonFiberMat = new TGeoMaterial("CarbonFiber", 12.0, 6.0, 1.6);
+  medCarbonFiber = new TGeoMedium("CarbonFiber", 1, carbonFiberMat);
+
+  auto* itsC = new TGeoElement("FT3_C", "Carbon", 6, 12.0107);
+
+  auto* itsFoam = new TGeoMixture("FT3_Foam", 1);
+  itsFoam->AddElement(itsC, 1);
+  itsFoam->SetDensity(0.17);
+
+  medFoam = new TGeoMedium("FT3_Foam", 1, itsFoam);
+  foamMat = medFoam->GetMaterial();
+
+  kaptonMat = new TGeoMaterial("Kapton (cooling pipe)", 13.84, 6.88, 1.346);
+  kaptonMed = new TGeoMedium("Kapton (cooling pipe)", 1, kaptonMat);
+
+  waterMat = new TGeoMaterial("Water", 18.01528, 8.0, 1.064);
+  waterMed = new TGeoMedium("Water", 2, waterMat);
+}
+
+static double y_circle(double x, double radius)
+{
+  return (x * x < radius * radius) ? std::sqrt(radius * radius - x * x) : 0;
+}
+
+void FT3Layer::createSeparationLayer_waterCooling(TGeoVolume* motherVolume, const std::string& separationLayerName)
+{
+
+  FT3Layer::initialize_mat();
+
+  double carbonFiberThickness = 0.01;
+  double foamSpacingThickness = 0.5;
+
+  TGeoTube* carbonFiberLayer = new TGeoTube(mInnerRadius, mOuterRadius, carbonFiberThickness / 2);
+
+  // volumes
+  TGeoVolume* carbonFiberLayerVol1 = new TGeoVolume((separationLayerName + "_CarbonFiber1").c_str(), carbonFiberLayer, medCarbonFiber);
+  TGeoVolume* carbonFiberLayerVol2 = new TGeoVolume((separationLayerName + "_CarbonFiber2").c_str(), carbonFiberLayer, medCarbonFiber);
+
+  carbonFiberLayerVol1->SetLineColor(kGray + 2);
+  carbonFiberLayerVol2->SetLineColor(kGray + 2);
+
+  double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0;
+
+  motherVolume->AddNode(carbonFiberLayerVol1, 1, new TGeoTranslation(0, 0, mZ - zSeparation));
+  motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, mZ + zSeparation));
+
+  double pipeOuterRadius = 0.20;
+  double kaptonThickness = 0.0025;
+  double pipeInnerRadius = pipeOuterRadius - kaptonThickness;
+  double pipeMaxLength = mOuterRadius * 2.0;
+
+  int name_it = 0;
+
+  // positions of the pipes depending on the overlap of the sensors inactive regions: (ALICE 3 dimensions)
+  // partial:
+  //  std::vector<double> X_pos = {-63.2, -58.4, -53.6, -48.8, -44.0, -39.199999999999996, -34.4, -29.599999999999994, -24.799999999999997, -19.999999999999993, -15.199999999999998, -10.399999999999993, -5.599999999999998, -0.7999999999999936, 4.000000000000002, 8.800000000000006, 13.600000000000001, 18.400000000000006, 23.200000000000003, 28.000000000000007, 32.800000000000004, 37.60000000000001, 42.400000000000006, 47.20000000000001, 52.00000000000001, 56.80000000000001, 61.60000000000001, 66.4};
+  // complete:
+  // std::vector<double> X_pos = {-63.4, -58.8, -54.199999999999996, -49.599999999999994, -44.99999999999999, -40.39999999999999, -35.79999999999999, -31.199999999999992, -26.59999999999999, -21.999999999999993, -17.39999999999999, -12.799999999999994, -8.199999999999992, -3.5999999999999934, 1.000000000000008, 5.600000000000007, 10.200000000000008, 14.800000000000008, 19.40000000000001, 24.000000000000007, 28.60000000000001, 33.20000000000001, 37.80000000000001, 42.40000000000001, 47.000000000000014, 51.600000000000016, 56.20000000000002, 60.80000000000002, 65.40000000000002};
+  std::vector<double> X_pos = {-62.3168, -57.9836, -53.650400000000005, -49.317200000000014, -44.984000000000016, -40.65080000000002, -36.31760000000002, -31.984400000000026, -27.65120000000003, -23.318000000000037, -18.98480000000004, -14.651600000000043, -10.318400000000047, -5.98520000000005, -1.6520000000000519, 2.6811999999999445, 7.014399999999941, 11.347599999999936, 15.680799999999934, 20.01399999999993, 24.347199999999926, 28.68039999999992, 33.013599999999926, 37.34679999999992, 41.980000000000004, 46.613200000000006, 51.246399999999994, 55.87960000000001, 60.5128};
+
+  for (double xPos : X_pos) {
+
+    double pipeLength = pipeMaxLength;
+    double yMax = 0.0;
+
+    TGeoRotation* rotation = new TGeoRotation();
+    rotation->RotateX(90);
+
+    if (std::abs(xPos) < mInnerRadius) {
+      double yInner = std::abs(y_circle(xPos, mInnerRadius));
+      double yOuter = std::abs(y_circle(xPos, mOuterRadius));
+
+      yMax = 2 * yOuter;
+      pipeLength = yMax;
+
+      double positiveYLength = yOuter - yInner;
+
+      TGeoVolume* kaptonPipePos = new TGeoVolume((separationLayerName + "_KaptonPipePos_" + std::to_string(name_it)).c_str(), new TGeoTube(pipeInnerRadius, pipeOuterRadius, positiveYLength / 2), kaptonMed);
+      kaptonPipePos->SetLineColor(kGray);
+      TGeoVolume* waterVolumePos = new TGeoVolume((separationLayerName + "_WaterVolumePos_" + std::to_string(name_it)).c_str(), new TGeoTube(0.0, pipeInnerRadius, positiveYLength / 2), waterMed);
+      waterVolumePos->SetLineColor(kBlue);
+
+      motherVolume->AddNode(waterVolumePos, 1, new TGeoCombiTrans(xPos, (yInner + yOuter) / 2.0, mZ, rotation));
+
+      TGeoVolume* kaptonPipeNeg = new TGeoVolume((separationLayerName + "_KaptonPipeNeg_" + std::to_string(name_it)).c_str(), new TGeoTube(pipeInnerRadius, pipeOuterRadius, positiveYLength / 2), kaptonMed);
+      kaptonPipeNeg->SetLineColor(kGray);
+      TGeoVolume* waterVolumeNeg = new TGeoVolume((separationLayerName + "_WaterVolumeNeg_" + std::to_string(name_it)).c_str(), new TGeoTube(0.0, pipeInnerRadius, positiveYLength / 2), waterMed);
+      waterVolumeNeg->SetLineColor(kBlue);
+
+      motherVolume->AddNode(waterVolumeNeg, 1, new TGeoCombiTrans(xPos, -(yInner + yOuter) / 2.0, mZ, rotation));
+
+      motherVolume->AddNode(kaptonPipePos, 1, new TGeoCombiTrans(xPos, (yInner + yOuter) / 2.0, mZ, rotation));
+      motherVolume->AddNode(kaptonPipeNeg, 1, new TGeoCombiTrans(xPos, -(yInner + yOuter) / 2.0, mZ, rotation));
+
+    } else {
+
+      double yOuter = std::abs(y_circle(xPos, mOuterRadius));
+      yMax = 2 * yOuter;
+      pipeLength = yMax;
+
+      TGeoVolume* kaptonPipe = new TGeoVolume((separationLayerName + "_KaptonPipe_" + std::to_string(name_it)).c_str(), new TGeoTube(pipeInnerRadius, pipeOuterRadius, pipeLength / 2), kaptonMed);
+      kaptonPipe->SetLineColor(kGray);
+      TGeoVolume* waterVolume = new TGeoVolume((separationLayerName + "_WaterVolume_" + std::to_string(name_it)).c_str(), new TGeoTube(0.0, pipeInnerRadius, pipeLength / 2), waterMed);
+      waterVolume->SetLineColor(kBlue);
+
+      motherVolume->AddNode(waterVolume, 1, new TGeoCombiTrans(xPos, 0, mZ, rotation));
+      motherVolume->AddNode(kaptonPipe, 1, new TGeoCombiTrans(xPos, 0, mZ, rotation));
+    }
+
+    name_it++;
+  }
+}
+
+void FT3Layer::createSeparationLayer(TGeoVolume* motherVolume, const std::string& separationLayerName)
+{
+
+  FT3Layer::initialize_mat();
+
+  double carbonFiberThickness = 0.01;
+  double foamSpacingThickness = 1.0;
+
+  TGeoTube* carbonFiberLayer = new TGeoTube(mInnerRadius, mOuterRadius, carbonFiberThickness / 2);
+  TGeoTube* foamLayer = new TGeoTube(mInnerRadius, mOuterRadius, foamSpacingThickness / 2);
+
+  // volumes
+  TGeoVolume* carbonFiberLayerVol1 = new TGeoVolume((separationLayerName + "_CarbonFiber1").c_str(), carbonFiberLayer, medCarbonFiber);
+  TGeoVolume* foamLayerVol = new TGeoVolume((separationLayerName + "_Foam").c_str(), foamLayer, medFoam);
+  TGeoVolume* carbonFiberLayerVol2 = new TGeoVolume((separationLayerName + "_CarbonFiber2").c_str(), carbonFiberLayer, medCarbonFiber);
+
+  carbonFiberLayerVol1->SetLineColor(kGray + 2);
+  foamLayerVol->SetLineColor(kBlack);
+  foamLayerVol->SetFillColorAlpha(kBlack, 1.0);
+  carbonFiberLayerVol2->SetLineColor(kGray + 2);
+
+  double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0;
+
+  motherVolume->AddNode(carbonFiberLayerVol1, 1, new TGeoTranslation(0, 0, mZ - zSeparation));
+  motherVolume->AddNode(foamLayerVol, 1, new TGeoTranslation(0, 0, mZ));
+  motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, mZ + zSeparation));
+}
+
 void FT3Layer::createLayer(TGeoVolume* motherVolume)
 {
-  if (mLayerNumber >= 0) {
-    // Create tube, set sensitive volume, add to mother volume
+  if (mLayerNumber >= 0 && mLayerNumber < 3) {
 
     std::string chipName = o2::ft3::GeometryTGeo::getFT3ChipPattern() + std::to_string(mLayerNumber),
                 sensName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), mDirection, mLayerNumber);
@@ -93,6 +255,20 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
 
-    return;
+  } else if (mLayerNumber >= 3) {
+
+    FT3Module module;
+
+    // layer structure
+    std::string frontLayerName = o2::ft3::GeometryTGeo::getFT3LayerPattern() + std::to_string(mDirection) + std::to_string(mLayerNumber) + "_Front";
+    std::string backLayerName = o2::ft3::GeometryTGeo::getFT3LayerPattern() + std::to_string(mDirection) + std::to_string(mLayerNumber) + "_Back";
+    std::string separationLayerName = "FT3SeparationLayer" + std::to_string(mDirection) + std::to_string(mLayerNumber);
+
+    // createSeparationLayer_waterCooling(motherVolume, separationLayerName);
+    createSeparationLayer(motherVolume, separationLayerName);
+
+    // create disk faces
+    module.createModule(mZ, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "front", "rectangular", motherVolume);
+    module.createModule(mZ, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "back", "rectangular", motherVolume);
   }
 }
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
new file mode 100644
index 0000000000000..87f5f27da6a38
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -0,0 +1,699 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FT3Module.cxx
+/// \brief Implementation of the FT3Module class
+
+#include "FT3Simulation/FT3Module.h"
+#include <TGeoManager.h>
+#include <TGeoMaterial.h>
+#include <TGeoMedium.h>
+#include <TGeoBBox.h>
+#include <TGeoMatrix.h>
+#include <cmath>
+#include <iostream>
+#include <vector>
+#include <set>
+#include <algorithm>
+
+TGeoMaterial* FT3Module::siliconMat = nullptr;
+TGeoMedium* FT3Module::siliconMed = nullptr;
+
+TGeoMaterial* FT3Module::copperMat = nullptr;
+TGeoMedium* FT3Module::copperMed = nullptr;
+
+TGeoMaterial* FT3Module::kaptonMat = nullptr;
+TGeoMedium* FT3Module::kaptonMed = nullptr;
+
+TGeoMaterial* FT3Module::epoxyMat = nullptr;
+TGeoMedium* FT3Module::epoxyMed = nullptr;
+
+TGeoMaterial* FT3Module::AluminumMat = nullptr;
+TGeoMedium* FT3Module::AluminumMed = nullptr;
+
+void FT3Module::initialize_materials()
+{
+
+  if (siliconMat) {
+    return;
+  }
+
+  TGeoManager* gGeoManager = gGeoManager;
+
+  auto* itsH = new TGeoElement("FT3_H", "Hydrogen", 1, 1.00794);
+  auto* itsC = new TGeoElement("FT3_C", "Carbon", 6, 12.0107);
+  auto* itsO = new TGeoElement("FT3_O", "Oxygen", 8, 15.994);
+
+  siliconMat = new TGeoMaterial("FT3_Silicon", 28.0855, 14, 2.33);
+  siliconMed = new TGeoMedium("FT3_Silicon", 1, siliconMat);
+
+  copperMat = new TGeoMaterial("FT3_Copper", 63.546, 29, 8.96);
+  copperMed = new TGeoMedium("FT3_Copper", 2, copperMat);
+
+  kaptonMat = new TGeoMaterial("FT3_Kapton", 13.84, 6.88, 1.346);
+  kaptonMed = new TGeoMedium("FT3_Kapton", 3, kaptonMat);
+
+  // Epoxy: C18 H19 O3
+  auto* itsEpoxy = new TGeoMixture("FT3_Epoxy", 3);
+  itsEpoxy->AddElement(itsC, 18);
+  itsEpoxy->AddElement(itsH, 19);
+  itsEpoxy->AddElement(itsO, 3);
+  itsEpoxy->SetDensity(2.186);
+
+  epoxyMed = new TGeoMedium("FT3_Epoxy", 4, itsEpoxy);
+  epoxyMat = epoxyMed->GetMaterial();
+
+  AluminumMat = new TGeoMaterial("Aluminum", 26.98, 13, 2.7);
+  AluminumMed = new TGeoMedium("Aluminum", 5, AluminumMat);
+}
+
+double calculate_y_circle(double x, double radius)
+{
+  return (x * x < radius * radius) ? std::sqrt(radius * radius - x * x) : 0;
+}
+
+void FT3Module::create_layout(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume)
+{
+
+  TGeoManager* gGeoManager = gGeoManager;
+
+  FT3Module::initialize_materials();
+
+  // double sensor_width = 2.5;
+  // double sensor_height = 9.6;
+  // double active_width = 2.3;
+  // double active_height = 9.6;
+
+  double sensor_width = 5.0;
+  double sensor_height = 9.6;
+  double inactive_width = 0.2; // per side
+  double active_width = 4.6;
+  double active_height = 9.6;
+
+  double silicon_thickness = 0.01;
+  double copper_thickness = 0.006;
+  double kapton_thickness = 0.03;
+  double epoxy_thickness = 0.0012;
+
+  double carbonFiberThickness = 0.01;
+
+  double foamSpacingThickness = 0.5;
+
+  int dist_offset = 0;
+
+  double x_offset;
+  double y_offset;
+
+  double z_offset = (face == "front") ? -foamSpacingThickness / 2.0 - carbonFiberThickness : foamSpacingThickness / 2.0 + carbonFiberThickness;
+
+  // offset correction
+  if (sensor_height == 3.2 && sensor_width == 2.5) {
+    x_offset = 0.8;
+    y_offset = 1.5;
+  } else if (sensor_height == 19.2 && sensor_width == 5) {
+    x_offset = 0.7;
+    y_offset = 9;
+
+  } else {
+    x_offset = sensor_width / 2;
+    y_offset = sensor_height / 2;
+  }
+
+  double x_condition_min = 0;
+  double x_condition_max = 0;
+  double offset_Rin_lower = 0;
+  double offset_Rin_upper = 0;
+  bool adjust_bottom_y_pos = false;
+  bool adjust_bottom_y_neg = false;
+  double x_adjust_bottom_y_pos = 0;
+  double bottom_y_pos_value = 0;
+  double bottom_y_neg_value = 0;
+
+  if (Rin == 7 && sensor_height == 9.6 && sensor_width == 5) {
+    x_condition_min = -Rin - 2;
+    x_condition_max = Rin;
+    adjust_bottom_y_pos = true;
+    adjust_bottom_y_neg = true;
+    x_adjust_bottom_y_pos = 3.5;
+    bottom_y_pos_value = 3.5;
+    bottom_y_neg_value = -3.5;
+
+    dist_offset = 2;
+
+  } else if (Rin == 5 && sensor_height == 9.6 && sensor_width == 5) {
+    x_condition_min = -Rin - 6;
+    x_condition_max = Rin;
+    adjust_bottom_y_pos = true;
+    adjust_bottom_y_neg = true;
+    x_adjust_bottom_y_pos = 3.5;
+    bottom_y_pos_value = 3.5;
+    bottom_y_neg_value = -3.5;
+  } else if ((Rin == 5 || Rin == 7) && sensor_height == 19.2) {
+    x_condition_min = -Rin - 3;
+    x_condition_max = Rin - 0.2;
+    dist_offset = 2;
+    adjust_bottom_y_pos = false;
+    adjust_bottom_y_neg = false;
+  } else if (Rin == 5 && sensor_height == 3.2) {
+    x_condition_min = -(Rin + 2.6);
+    x_condition_max = Rin + 1.5;
+    adjust_bottom_y_pos = true;
+    adjust_bottom_y_neg = true;
+    x_adjust_bottom_y_pos = 3.5;
+    bottom_y_pos_value = 3.5;
+    bottom_y_neg_value = -3.5;
+  } else if (Rin == 7 && sensor_height == 3.2) {
+    x_condition_min = -Rin - 1;
+    x_condition_max = Rin - 0.2;
+    adjust_bottom_y_pos = true;
+    adjust_bottom_y_neg = true;
+    x_adjust_bottom_y_pos = 3.5;
+    bottom_y_pos_value = 3.5;
+    bottom_y_neg_value = -3.5;
+  } else if (Rin == 5 && sensor_height == 9.6 && sensor_width == 2.5) {
+    x_condition_min = -(Rin + 2.6);
+    x_condition_max = Rin;
+    adjust_bottom_y_pos = true;
+    adjust_bottom_y_neg = true;
+    x_adjust_bottom_y_pos = 3.5;
+    bottom_y_pos_value = 3.5;
+    bottom_y_neg_value = -3.5;
+  } else if (Rin == 7 && sensor_height == 9.6 && sensor_width == 2.5) {
+    x_condition_min = -Rin - 2.6;
+    x_condition_max = Rin + 1;
+    dist_offset = 2;
+    adjust_bottom_y_pos = true;
+    adjust_bottom_y_neg = true;
+    x_adjust_bottom_y_pos = 5.5;
+    bottom_y_pos_value = 3.5;
+    bottom_y_neg_value = -3.5;
+  } else {
+    std::cout << "Different config - to determine offsets needed." << std::endl;
+    x_condition_min = -Rin;
+    x_condition_max = Rin;
+    adjust_bottom_y_pos = false;
+    adjust_bottom_y_neg = false;
+  }
+
+  double Rin_offset = (sensor_height == 19.2) ? 1 : 0;
+  double Rout_offset = (sensor_height == 19.2) ? 1 : 0;
+
+  offset_Rin_lower = Rin - Rin_offset;
+  offset_Rin_upper = Rout + Rout_offset;
+
+  std::set<std::pair<double, double>> placed_sensors;
+  int sensor_count = 0;
+
+  int placementCounter = 0;
+  bool justSkipped = false;
+
+  std::vector<double> X_positions;
+  std::vector<int> justSkipped1;
+
+  if (sensor_width == 2.5) {
+    // logic for placement - x positions with complete overlap
+    if (face == "front") {
+      X_positions = {-63.4, -60.9, -54.2, -51.7, -45.0, -42.5, -35.8, -33.3, -26.6, -24.1, -17.4, -14.9,
+                     -8.2, -5.7, 1.0, 3.5, 10.2, 12.7, 19.4, 21.9, 28.6, 31.1, 37.8, 40.3, 47.0, 49.5,
+                     56.2, 58.7, 65.4};
+      justSkipped1 = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
+    } else if (face == "back") {
+      X_positions = {-65.5, -58.8, -56.3, -49.6, -47.1, -40.4, -37.9, -31.2, -28.7, -22.0, -19.5, -12.8,
+                     -10.3, -3.6, -1.1, 5.6, 8.1, 14.8, 17.3, 24.0, 26.5, 33.2, 35.7, 42.4, 44.9,
+                     51.6, 54.1, 60.8, 63.3};
+      justSkipped1 = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
+    }
+  } else {
+    // filling for sensors with 2x width, each row skipped
+    if (face == "front") {
+      X_positions = {-63.4, -54.2, -45, -35.8, -26.6, -17.4, -8.2, 1., 10.2, 19.4, 28.6, 37.8, 47., 56.2, 65.4};
+      justSkipped1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+    } else if (face == "back") {
+      X_positions = {-58.8, -49.6, -40.4, -31.2, -22, -12.8, -3.6, 5.6, 14.8, 24, 33.2, 42.4, 51.6, 60.8};
+      justSkipped1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+    }
+  }
+
+  if (layout_type == "rectangular") {
+
+    double x_start = -Rout;
+    double x_end = Rout;
+
+    std::vector<double> x_positions;
+    for (double x = x_start; x <= x_end; x += sensor_width) {
+      x_positions.push_back(x);
+    }
+
+    int rowCounter = 0;
+    const int rowsToAlternate = 2;
+
+    for (size_t i = 0; i < X_positions.size(); ++i) {
+
+      double x = X_positions[i];
+      bool justSkippedValue = justSkipped1[i];
+
+      std::vector<double> y_positions_positive;
+      std::vector<double> y_positions_negative;
+
+      for (double y = -Rout - Rin_offset; y <= Rout + Rin_offset; y += sensor_height) {
+        std::vector<std::pair<double, double>> corners = {
+          {x, y},
+          {x + sensor_width, y},
+          {x, y + sensor_height},
+          {x + sensor_width, y + sensor_height}};
+
+        bool within_bounds = std::all_of(corners.begin(), corners.end(), [&](const std::pair<double, double>& corner) {
+          double cx = corner.first;
+          double cy = corner.second;
+          return (offset_Rin_lower <= std::sqrt(cx * cx + cy * cy) && std::sqrt(cx * cx + cy * cy) <= offset_Rin_upper);
+        });
+
+        if (within_bounds) {
+          if (y >= 0) {
+            y_positions_positive.push_back(y);
+          } else {
+            y_positions_negative.push_back(y);
+          }
+        }
+      }
+
+      // adjust y positions near inner circle for positive y
+      if (x_condition_min <= x && x <= x_condition_max && !y_positions_positive.empty()) {
+        double first_y_pos = y_positions_positive.front();
+        double last_y_pos = y_positions_positive.back() - sensor_height;
+        double top_y_pos = std::min(calculate_y_circle(x, Rout), calculate_y_circle(x + sensor_width, Rout));
+        double bottom_y_pos = std::max(calculate_y_circle(x, Rin), calculate_y_circle(x + sensor_width, Rin));
+        double top_distance_pos = top_y_pos - last_y_pos;
+
+        if (adjust_bottom_y_pos && x > x_adjust_bottom_y_pos) {
+          bottom_y_pos = bottom_y_pos_value;
+        }
+
+        double bottom_distance_pos = first_y_pos - bottom_y_pos;
+
+        if (std::abs(top_distance_pos + bottom_distance_pos) >= sensor_height) {
+          for (auto& y : y_positions_positive) {
+            y -= bottom_distance_pos - 0.2;
+          }
+          y_positions_positive.push_back(y_positions_positive.back() + sensor_height);
+        }
+      }
+
+      // adjust y positions near inner circle for negative y
+      if (x_condition_min <= x && x <= x_condition_max && !y_positions_negative.empty()) {
+        double first_y_neg = y_positions_negative.front();
+        double last_y_neg = y_positions_negative.back() + sensor_height;
+        double top_y_neg = -std::min(calculate_y_circle(x, Rout), calculate_y_circle(x + sensor_width, Rout));
+        double bottom_y_neg = -std::max(calculate_y_circle(x, Rin), calculate_y_circle(x + sensor_width, Rin));
+        double top_distance_neg = -(top_y_neg - first_y_neg);
+
+        if (adjust_bottom_y_neg && x > x_adjust_bottom_y_pos) {
+          bottom_y_neg = bottom_y_neg_value;
+        }
+
+        double bottom_distance_neg = -(last_y_neg - bottom_y_neg);
+
+        top_distance_neg = std::abs(top_distance_neg);
+        bottom_distance_neg = std::abs(bottom_distance_neg);
+        std::sort(y_positions_negative.begin(), y_positions_negative.end());
+
+        if (std::abs(top_distance_neg + bottom_distance_neg) >= sensor_height) {
+          if (sensor_height == 19.2) {
+            for (auto& y : y_positions_negative) {
+              y -= bottom_distance_neg;
+            }
+          } else {
+            for (auto& y : y_positions_negative) {
+              y += bottom_distance_neg - 0.2;
+            }
+          }
+          y_positions_negative.push_back(y_positions_negative.front() - sensor_height);
+        }
+      }
+
+      // adjust positions for the rest of the disk
+      if ((x < x_condition_min || x > x_condition_max) && !y_positions_negative.empty() && !y_positions_positive.empty()) {
+        double first_y_neg = y_positions_negative.front();
+        double last_y_pos = y_positions_positive.back() + sensor_height;
+        double top_y_pos = std::min(calculate_y_circle(x, Rout), calculate_y_circle(x + sensor_width, Rout));
+        double bottom_y_pos = -top_y_pos;
+
+        double top_distance_pos = std::abs(top_y_pos - last_y_pos);
+        double bottom_distance_pos = std::abs(first_y_neg - bottom_y_pos);
+
+        if (top_distance_pos + bottom_distance_pos >= sensor_height) {
+          for (auto& y : y_positions_positive) {
+            y += top_distance_pos - 0.2;
+          }
+          for (auto& y : y_positions_negative) {
+            y += top_distance_pos - 0.2;
+          }
+          double new_y = y_positions_negative.front() - sensor_height;
+
+          if (static_cast<int>(new_y) > static_cast<int>(bottom_y_pos)) {
+            y_positions_negative.push_back(new_y);
+          }
+        }
+
+        // Make symmetric adjustments
+        std::sort(y_positions_negative.begin(), y_positions_negative.end());
+        std::sort(y_positions_positive.begin(), y_positions_positive.end());
+
+        double first_y_pos = y_positions_negative.front();
+
+        last_y_pos = y_positions_positive.back() + sensor_height;
+
+        top_y_pos = std::min(calculate_y_circle(x, Rout), calculate_y_circle(x + sensor_width, Rout));
+        bottom_y_pos = -top_y_pos;
+        top_distance_pos = std::abs(top_y_pos - last_y_pos);
+        bottom_distance_pos = std::abs(first_y_pos - bottom_y_pos);
+
+        double Lb = (bottom_distance_pos + top_distance_pos) / 2;
+
+        if (top_distance_pos < Lb) {
+          double shift = Lb - top_distance_pos;
+          for (auto& y : y_positions_negative) {
+            y -= shift;
+          }
+          for (auto& y : y_positions_positive) {
+            y -= shift;
+          }
+        } else if (top_distance_pos > Lb) {
+          double shift = top_distance_pos - Lb;
+          for (auto& y : y_positions_negative) {
+            y += shift;
+          }
+          for (auto& y : y_positions_positive) {
+            y += shift;
+          }
+        }
+      }
+
+      std::vector<double> y_positions = y_positions_positive;
+      y_positions.insert(y_positions.end(), y_positions_negative.begin(), y_positions_negative.end());
+
+      for (double y : y_positions) {
+
+        int SiColor;
+        double R_material_threshold = 0;
+
+        if (placed_sensors.find({x, y}) == placed_sensors.end()) {
+          placed_sensors.insert({x, y});
+          TGeoVolume* sensor;
+
+          double inactive_width = (sensor_width - active_width) / 2;
+          double left_inactive_x_shift;
+          double right_inactive_x_shift;
+          double active_x_shift_sensor;
+
+          if (face == "front") {
+
+            double active_x_shift, inactive_x_shift;
+
+            if (justSkippedValue) {
+              active_x_shift = x + inactive_width / 2;
+              active_x_shift_sensor = active_x_shift + inactive_width;
+
+              inactive_x_shift = x - active_width / 2 + inactive_width / 2;
+            } else {
+              active_x_shift = x - inactive_width / 2;
+              active_x_shift_sensor = active_x_shift - inactive_width;
+
+              inactive_x_shift = x + active_width / 2 - inactive_width / 2;
+            }
+
+            double inactive_x_shift_left, inactive_x_shift_right;
+
+            if (sensor_width == 5.0) {
+
+              inactive_x_shift_left = x - sensor_width / 2 + inactive_width;
+              inactive_x_shift_right = x + sensor_width / 2;
+            }
+
+            std::vector<std::pair<double, double>> corners_shifted = {
+              {x, y},
+              {x + sensor_width, y},
+              {x, y + sensor_height},
+              {x + sensor_width, y + sensor_height}};
+
+            bool within_bounds = true;
+            for (const auto& corner : corners_shifted) {
+              double cx = corner.first;
+              double cy = corner.second;
+              double dist = std::sqrt(cx * cx + cy * cy);
+
+              if (Rin > dist || dist >= Rout) {
+                within_bounds = false;
+                break;
+              }
+            }
+
+            if (within_bounds) {
+
+              double r_squared = (x + x_offset) * (x + x_offset) + (y + y_offset) * (y + y_offset);
+
+              if (r_squared < R_material_threshold * R_material_threshold) {
+                silicon_thickness = 0.005;
+                copper_thickness = 0.00475;
+                kapton_thickness = 0.03;
+                epoxy_thickness = 0.0012;
+
+                SiColor = kOrange;
+              } else {
+                silicon_thickness = 0.01;
+                copper_thickness = 0.006;
+                kapton_thickness = 0.03;
+                epoxy_thickness = 0.0012;
+
+                SiColor = kGreen;
+              }
+
+              if (sensor_width == 2.5) {
+                // silicon
+                std::string sensor_name = "FT3sensor_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, active_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(SiColor);
+                sensor->SetFillColorAlpha(SiColor, 0.4);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift_sensor + x_offset, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
+
+                std::string inactive_name = "FT3inactive_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(inactive_name.c_str(), siliconMed, (sensor_width - active_width) / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(kRed);
+                sensor->SetFillColorAlpha(kRed, 1.0);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
+
+              } else {
+
+                std::string sensor_name = "FT3sensor_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(SiColor);
+                sensor->SetFillColorAlpha(SiColor, 0.4);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + x + inactive_width / 2, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
+
+                std::string inactive_name_left = "FT3inactive_left_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(inactive_name_left.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(kRed);
+                sensor->SetFillColorAlpha(kRed, 1.0);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift_left, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
+
+                std::string inactive_name_right = "FT3inactive_right_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(inactive_name_right.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(kRed);
+                sensor->SetFillColorAlpha(kRed, 1.0);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift_right, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
+              }
+
+              // silicon-to-FPC epoxy glue
+              std::string glue_up_name = "FT3glue_up_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+              sensor = gGeoManager->MakeBox(glue_up_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
+              sensor->SetLineColor(kBlue);
+              sensor->SetFillColorAlpha(kBlue, 1.0);
+              motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + active_x_shift, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness / 2));
+
+              if (r_squared < R_material_threshold * R_material_threshold) {
+                std::string alu_name = "FT3aluminum_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(alu_name.c_str(), AluminumMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
+                sensor->SetLineColor(kBlack);
+                sensor->SetFillColorAlpha(kBlack, 0.4);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness / 2));
+
+              } else {
+                std::string copper_name = "FT3copper_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(copper_name.c_str(), copperMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
+                sensor->SetLineColor(kBlack);
+                sensor->SetFillColorAlpha(kBlack, 0.4);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness / 2));
+              }
+
+              // kapton
+              std::string fpc_name = "FT3fpc_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+              sensor = gGeoManager->MakeBox(fpc_name.c_str(), kaptonMed, sensor_width / 2, sensor_height / 2, kapton_thickness / 2);
+              sensor->SetLineColor(kGreen);
+              sensor->SetFillColorAlpha(kGreen, 0.4);
+              motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness / 2));
+
+              // FPC-to-support epoxy glue
+              std::string glue_down_name = "FT3glue_down_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+              sensor = gGeoManager->MakeBox(glue_down_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
+              sensor->SetLineColor(kBlue);
+              sensor->SetFillColorAlpha(kBlue, 1.0);
+              motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + active_x_shift, y + y_offset, mZ + z_offset - epoxy_thickness / 2));
+            }
+          } else {
+            double x_shifted = x;
+            double inactive_x_shift, active_x_shift;
+            double active_x_shift_sensor;
+
+            if (justSkippedValue) {
+              active_x_shift = x + inactive_width / 2;
+              active_x_shift_sensor = active_x_shift + inactive_width;
+
+              inactive_x_shift = x - active_width / 2 + inactive_width / 2;
+            } else {
+              active_x_shift = x - inactive_width / 2;
+              active_x_shift_sensor = active_x_shift - inactive_width;
+
+              inactive_x_shift = x + active_width / 2 - inactive_width / 2;
+            }
+
+            double inactive_x_shift_left, inactive_x_shift_right;
+
+            if (sensor_width == 5.0) {
+
+              inactive_x_shift_left = x - sensor_width / 2 + inactive_width;
+              inactive_x_shift_right = x + sensor_width / 2;
+            }
+
+            std::vector<std::pair<double, double>> corners_shifted = {
+              {x_shifted, y},
+              {x_shifted + sensor_width, y},
+              {x_shifted, y + sensor_height},
+              {x_shifted + sensor_width, y + sensor_height}};
+
+            bool within_bounds = true;
+            for (const auto& corner : corners_shifted) {
+              double cx = corner.first;
+              double cy = corner.second;
+              double dist = std::sqrt(cx * cx + cy * cy);
+
+              if (Rin > dist + dist_offset || dist >= Rout) {
+                within_bounds = false;
+                break;
+              }
+            }
+
+            if (within_bounds) {
+
+              double r_squared = (x + x_offset) * (x + x_offset) + (y + y_offset) * (y + y_offset);
+
+              if (r_squared < R_material_threshold * R_material_threshold) {
+                silicon_thickness = 0.005;
+                copper_thickness = 0.00475; // thinner -> + replaced by alu
+                kapton_thickness = 0.03;
+                epoxy_thickness = 0.0006;
+
+                SiColor = kOrange;
+              } else {
+                silicon_thickness = 0.01;
+                copper_thickness = 0.006;
+                kapton_thickness = 0.03;
+                epoxy_thickness = 0.0012;
+
+                SiColor = kGreen;
+              }
+
+              // FPC-to-support epoxy glue
+              std::string glue_down_name = "FT3glue_down_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+              sensor = gGeoManager->MakeBox(glue_down_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
+              sensor->SetLineColor(kBlue);
+              sensor->SetFillColorAlpha(kBlue, 1.0);
+              motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + active_x_shift, y + y_offset, mZ + z_offset + epoxy_thickness / 2));
+
+              // Kapton
+              std::string fpc_name = "FT3fpc_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+              sensor = gGeoManager->MakeBox(fpc_name.c_str(), kaptonMed, sensor_width / 2, sensor_height / 2, kapton_thickness / 2);
+              sensor->SetLineColor(kGreen);
+              sensor->SetFillColorAlpha(kGreen, 0.4);
+              motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness / 2));
+
+              if (r_squared < R_material_threshold * R_material_threshold) {
+                // replace copper with alu
+                std::string alu_name = "FT3aluminum_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(alu_name.c_str(), AluminumMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
+                sensor->SetLineColor(kBlack);
+                sensor->SetFillColorAlpha(kBlack, 0.4);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness / 2));
+
+              } else {
+                std::string copper_name = "FT3copper_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(copper_name.c_str(), copperMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
+                sensor->SetLineColor(kBlack);
+                sensor->SetFillColorAlpha(kBlack, 0.4);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness / 2));
+              }
+
+              // silicon-to-FPC epoxy glue
+              std::string glue_up_name = "FT3glue_up_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+              sensor = gGeoManager->MakeBox(glue_up_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
+              sensor->SetLineColor(kBlue);
+              sensor->SetFillColorAlpha(kBlue, 1.0);
+              motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + active_x_shift, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness / 2));
+
+              if (sensor_width == 2.5) {
+
+                std::string sensor_name = "FT3sensor_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, active_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(SiColor);
+                sensor->SetFillColorAlpha(SiColor, 0.4);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift_sensor + x_offset, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
+
+                std::string inactive_name = "FT3inactive_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(inactive_name.c_str(), siliconMed, (sensor_width - active_width) / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(kRed);
+                sensor->SetFillColorAlpha(kRed, 1.0);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
+
+              } else {
+                // active (4.6 cm centered)
+                std::string sensor_name = "FT3sensor_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(SiColor);
+                sensor->SetFillColorAlpha(SiColor, 0.4);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + x_shifted + inactive_width / 2, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
+
+                // left inactive strip
+                std::string inactive_name_left = "FT3inactive_left_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(inactive_name_left.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(kRed);
+                sensor->SetFillColorAlpha(kRed, 1.0);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift_left, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
+
+                // right inactive strip
+                std::string inactive_name_right = "FT3inactive_right_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                sensor = gGeoManager->MakeBox(inactive_name_right.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor->SetLineColor(kRed);
+                sensor->SetFillColorAlpha(kRed, 1.0);
+                motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift_right, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
+              }
+            }
+          }
+        }
+      }
+
+      rowCounter++;
+    }
+  }
+}
+
+void FT3Module::createModule(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume)
+{
+  create_layout(mZ, layerNumber, direction, Rin, Rout, overlap, face, layout_type, motherVolume);
+}

From 7b3397d53e879a22bad604ca5551607c33744d6c Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sat, 6 Dec 2025 14:46:53 +0100
Subject: [PATCH 1107/1764] Fix for headers-only CCDB uploads

---
 CCDB/src/CcdbApi.cxx    | 14 ++++++++++++--
 CCDB/src/UploadTool.cxx |  3 +++
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index 8b3c9e0c619c3..90776d6972e2c 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -375,6 +375,10 @@ int CcdbApi::storeAsBinaryFile(const char* buffer, size_t size, const std::strin
     sanitizedEndValidityTimestamp = getFutureTimestamp(60 * 60 * 24 * 1);
   }
   if (mInSnapshotMode) { // write local file
+    if (filename.empty() || buffer == nullptr || size == 0) {
+      LOGP(alarm, "Snapshot mode does not support headers-only upload");
+      return -3;
+    }
     auto pthLoc = getSnapshotDir(mSnapshotTopPath, path);
     o2::utils::createDirectoriesIfAbsent(pthLoc);
     auto flLoc = getSnapshotFile(mSnapshotTopPath, path, filename);
@@ -418,8 +422,14 @@ int CcdbApi::storeAsBinaryFile(const char* buffer, size_t size, const std::strin
     auto mime = curl_mime_init(curl);
     auto field = curl_mime_addpart(mime);
     curl_mime_name(field, "send");
-    curl_mime_filedata(field, filename.c_str());
-    curl_mime_data(field, buffer, size);
+    if (filename.empty()) {
+      curl_mime_filedata(field, filename.c_str());
+    }
+    if (buffer != nullptr && size > 0) {
+      curl_mime_data(field, buffer, size);
+    } else {
+      curl_mime_data(field, "", 0);
+    }
 
     struct curl_slist* headerlist = nullptr;
     static const char buf[] = "Expect:";
diff --git a/CCDB/src/UploadTool.cxx b/CCDB/src/UploadTool.cxx
index 83b395bedb046..9aba417b4f4a9 100644
--- a/CCDB/src/UploadTool.cxx
+++ b/CCDB/src/UploadTool.cxx
@@ -148,6 +148,9 @@ int main(int argc, char* argv[])
   }
 
   if (filename == "headersOnly") {
+    auto ent = meta.find("Redirect");
+    std::cout << " Uploading a headers-only object to path " << path << " with timestamp validity from " << starttimestamp << " to " << endtimestamp
+              << " Redirection to: " << ((ent != meta.end()) ? ent->second : std::string{"none"}) << "\n";
     api.storeAsBinaryFile(nullptr, 0, "ignored", "", path, meta, starttimestamp, endtimestamp);
     if (!api.isSnapshotMode() && meta.find("adjustableEOV") != meta.end() && meta.find("default") == meta.end()) {
       o2::ccdb::CcdbObjectInfo oi(path, "", "", meta, starttimestamp, endtimestamp);

From 1485ea0e4eae2f8e81f0dec243a4cf2bbd8383a8 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 5 Dec 2025 17:44:25 +0100
Subject: [PATCH 1108/1764] DPL: test for ConsumeExisting when forwarding

---
 Framework/Core/test/test_ForwardInputs.cxx | 54 ++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
index 1406110e0e9ee..b1f42fb0398ca 100644
--- a/Framework/Core/test/test_ForwardInputs.cxx
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -107,6 +107,60 @@ TEST_CASE("ForwardInputsSingleMessageSingleRoute")
   REQUIRE(result[0].Size() == 2); // Two messages for that route
 }
 
+TEST_CASE("ForwardInputsSingleMessageSingleRouteNoConsume")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 0;
+  dh.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B")};
+
+  bool copyByDefault = false;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{ForwardRoute{
+    .timeslice = 0,
+    .maxTimeslices = 1,
+    .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+    .channel = "from_A_to_B",
+    .policy = nullptr,
+  }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
+  std::vector<MessageSet> currentSetOfInputs;
+  MessageSet messageSet;
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(nullptr);
+  REQUIRE(payload.get() == nullptr);
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  REQUIRE(messageSet.size() == 1);
+  currentSetOfInputs.emplace_back(std::move(messageSet));
+
+  TimesliceSlot slot{0};
+
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, true);
+  REQUIRE(result.size() == 1);
+  REQUIRE(result[0].Size() == 0); // Because there is a nullptr, we do not forward this as it was already consumed.
+}
+
 TEST_CASE("ForwardInputsSingleMessageSingleRouteAtEOS")
 {
   o2::header::DataHeader dh;

From 1cd002bf0ff0f4c21fd68136694abeade613a10e Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 7 Dec 2025 01:43:40 +0100
Subject: [PATCH 1109/1764] add missing reset ot ITS track before the refit

---
 .../TPC/calibration/SpacePoints/src/TrackInterpolation.cxx      | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index dddb0a5c435bc..7db5b7455f1a7 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -1488,6 +1488,8 @@ bool TrackInterpolation::refITSTrack(o2::dataformats::GlobalTrackID gid, int see
   auto nCl = trkITS.getNumberOfClusters();
   auto clEntry = trkITS.getFirstClusterEntry();
   o2::track::TrackParCov track(trkITS); // start from the inner param
+  track.resetCovariance();
+  track.setCov(track.getQ2Pt() * track.getQ2Pt() * track.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
   track.setPID(seed.getPID());
   o2::track::TrackPar refLin(track); // and use it also as linearization reference
   auto geom = o2::its::GeometryTGeo::Instance();

From 53130312eeee1ef0c1fff93f9f472ed0a21f2f3a Mon Sep 17 00:00:00 2001
From: Sean Murray <hamiltonthomas@gmail.com>
Date: Mon, 3 Feb 2025 14:05:32 +0100
Subject: [PATCH 1110/1764] TRD add digit phases to CTF encoding, collapse
 phases on reading.

---
 .../TRD/include/DataFormatsTRD/Digit.h        |  6 +-
 .../TRD/include/DataFormatsTRD/PHData.h       | 60 +++++++++++++++++++
 .../Detectors/TRD/src/DataFormatsTRDLinkDef.h |  2 +
 DataFormats/Detectors/TRD/src/Digit.cxx       |  9 ++-
 .../include/TRDCalibration/PulseHeight.h      |  2 +
 Detectors/TRD/calibration/src/PulseHeight.cxx |  6 ++
 Detectors/TRD/qc/src/RawDataManager.cxx       |  2 +
 .../include/TRDReconstruction/CTFCoder.h      |  4 +-
 .../include/TRDReconstruction/CTFHelper.h     |  4 +-
 .../TRD/reconstruction/src/CruRawReader.cxx   |  4 ++
 .../include/TRDWorkflow/TRDPulseHeightSpec.h  |  2 +
 11 files changed, 94 insertions(+), 7 deletions(-)

diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/Digit.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/Digit.h
index 28ec6c76f4bef..9eba0318a5a13 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/Digit.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/Digit.h
@@ -59,7 +59,7 @@ class Digit
   Digit(int det, int row, int pad, ArrayADC adc, int phase = 0);
   Digit(int det, int row, int pad); // add adc data and pretrigger phase in a separate step
   Digit(int det, int rob, int mcm, int channel, ArrayADC adc, int phase = 0);
-  Digit(int det, int rob, int mcm, int channel); // add adc data in a seperate step
+  Digit(int det, int rob, int mcm, int channel, int phase = 0); // add adc data
 
   // Copy
   Digit(const Digit&) = default;
@@ -74,9 +74,11 @@ class Digit
   void setDetector(int det) { mDetector = ((mDetector & 0xf000) | (det & 0xfff)); }
   void setADC(ArrayADC const& adc) { mADC = adc; }
   void setADC(const gsl::span<ADC_t>& adc) { std::copy(adc.begin(), adc.end(), mADC.begin()); }
-  void setPreTrigPhase(int phase) { mDetector = (((phase & 0xf) << 12) | (mDetector & 0xfff)); }
+  // set the trigger phase make sure it is mapped to 2 bits as it can only have 4 valid numbers shifted 0,3,6,9 or 1,4,7,10 etc.
+  void setPreTrigPhase(int phase);
   // Get methods
   int getDetector() const { return mDetector & 0xfff; }
+  int getDetectorInFull() const { return mDetector; } // return the entire mDetector 16 bits, so far only for CTF encoding.
   int getHCId() const { return (mDetector & 0xfff) * 2 + (mROB % 2); }
   int getPadRow() const { return HelperMethods::getPadRowFromMCM(mROB, mMCM); }
   int getPadCol() const { return HelperMethods::getPadColFromADC(mROB, mMCM, mChannel); }
diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/PHData.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/PHData.h
index b8873a5247d03..fc46ca0207993 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/PHData.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/PHData.h
@@ -61,6 +61,66 @@ class PHData
 
   ClassDefNV(PHData, 1);
 };
+
+/*
+  This data type is used to send around the information required to fill PH plots per chamber
+
+  |19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
+  -------------------------------------------------------------
+  |type |nNeighb |   time bin   |        detector number      |
+  -------------------------------------------------------------
+*/
+/*
+  This data type is used to send around the information required to fill PH plots per chamber
+
+  |15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
+  ------------------------------------------------
+  |                 ADC sum for all neigbours     |
+  ------------------------------------------------
+*/
+
+class PHDataHD
+{
+ public:
+  enum Origin : uint8_t {
+    ITSTPCTRD,
+    TPCTRD,
+    TRACKLET,
+    OTHER
+  };
+
+  PHDataHD() = default;
+  PHDataHD(int adc, int det, int tb, int nb, int type) { set(adc, det, tb, nb, type); }
+
+  void set(int adc, int det, int tb, int nb, int type)
+  {
+    mDetector = det;
+    mTimeBin = tb;
+    mType = type;
+    mNNeighbours = nb;
+    mADC = adc;
+  }
+
+  // the ADC sum for given time bin for up to three neighbours
+  int getADC() const { return mADC; }
+  // the TRD detector number
+  int getDetector() const { return mDetector; }
+  // the given time bin
+  int getTimebin() const { return mTimeBin; }
+  // number of neighbouring digits for which the ADC is accumulated
+  int getNNeighbours() const { return mNNeighbours; }
+  // the origin of this point: digit on ITS-TPC-TRD track, ... (see enum Origin above)
+  int getType() const { return mType; }
+
+ private:
+  uint16_t mDetector{0};
+  uint8_t mTimeBin{0};
+  uint8_t mType{0};
+  uint8_t mNNeighbours{0};
+  uint16_t mADC{0};
+
+  ClassDefNV(PHDataHD, 1);
+};
 } // namespace o2::trd
 
 #endif // ALICEO2_TRD_PHDATA_H_
diff --git a/DataFormats/Detectors/TRD/src/DataFormatsTRDLinkDef.h b/DataFormats/Detectors/TRD/src/DataFormatsTRDLinkDef.h
index 250a33b2c98e2..c6d36a7aee495 100644
--- a/DataFormats/Detectors/TRD/src/DataFormatsTRDLinkDef.h
+++ b/DataFormats/Detectors/TRD/src/DataFormatsTRDLinkDef.h
@@ -43,6 +43,7 @@
 #pragma link C++ class o2::trd::ChannelInfo + ;
 #pragma link C++ class o2::trd::ChannelInfoContainer + ;
 #pragma link C++ struct o2::trd::PHData + ;
+#pragma link C++ struct o2::trd::PHDataHD + ;
 #pragma link C++ class o2::trd::TRDDataCountersPerTimeFrame + ;
 #pragma link C++ class o2::trd::DataCountersPerTrigger + ;
 #pragma link C++ class std::vector < o2::trd::Tracklet64> + ;
@@ -56,6 +57,7 @@
 #pragma link C++ class std::vector < o2::trd::GainCalibHistos> + ;
 #pragma link C++ class std::vector < o2::trd::T0FitHistos> + ;
 #pragma link C++ class std::vector < o2::trd::PHData> + ;
+#pragma link C++ class std::vector < o2::trd::PHDataHD> + ;
 #pragma link C++ class std::vector < o2::trd::KrCluster> + ;
 #pragma link C++ class std::vector < o2::trd::KrClusterTriggerRecord> + ;
 #pragma link C++ class std::vector < o2::trd::DataCountersPerTrigger> + ;
diff --git a/DataFormats/Detectors/TRD/src/Digit.cxx b/DataFormats/Detectors/TRD/src/Digit.cxx
index 9e94fe22068bb..37d6638ac0996 100644
--- a/DataFormats/Detectors/TRD/src/Digit.cxx
+++ b/DataFormats/Detectors/TRD/src/Digit.cxx
@@ -12,6 +12,7 @@
 #include "DataFormatsTRD/Digit.h"
 #include <iostream>
 #include <algorithm>
+#include "fairlogger/Logger.h"
 
 namespace o2::trd
 {
@@ -46,12 +47,18 @@ Digit::Digit(int det, int rob, int mcm, int channel, ArrayADC adc, int pretrigph
   setPreTrigPhase(pretrigphase);
 }
 
-Digit::Digit(int det, int rob, int mcm, int channel) // add adc data in a seperate step
+Digit::Digit(int det, int rob, int mcm, int channel, int pretrigphase) // add adc data in a seperate step
 {
   setDetector(det);
   setROB(rob);
   setMCM(mcm);
   setChannel(channel);
+  setPreTrigPhase(pretrigphase);
+}
+
+void Digit::setPreTrigPhase(int phase)
+{
+  mDetector = ((((phase) & 0x3) << 12) | (mDetector & 0xfff));
 }
 
 bool Digit::isSharedDigit() const
diff --git a/Detectors/TRD/calibration/include/TRDCalibration/PulseHeight.h b/Detectors/TRD/calibration/include/TRDCalibration/PulseHeight.h
index 3fc70603da7d5..52305cc585b34 100644
--- a/Detectors/TRD/calibration/include/TRDCalibration/PulseHeight.h
+++ b/Detectors/TRD/calibration/include/TRDCalibration/PulseHeight.h
@@ -61,6 +61,7 @@ class PulseHeight
 
   /// Access to output
   const std::vector<PHData>& getPHData() { return mPHValues; }
+  const std::vector<PHDataHD>& getPHDataHD() { return mPHValuesHD; }
 
   void createOutputFile();
   void closeOutputFile();
@@ -77,6 +78,7 @@ class PulseHeight
 
   // output
   std::vector<PHData> mPHValues, *mPHValuesPtr{&mPHValues}; ///< vector of values used to fill the PH spectra per detector
+  std::vector<PHDataHD> mPHValuesHD, *mPHValuesHDPtr{&mPHValuesHD}; ///< vector of values used to fill the High definition PH spectra per detector with pretrigger phase
   std::vector<int> mDistances, *mDistancesPtr{&mDistances}; ///< pad distance between tracklet column and digit ADC maximum
   std::unique_ptr<TFile> mOutFile{nullptr};                 ///< output file
   std::unique_ptr<TTree> mOutTree{nullptr};                 ///< output tree
diff --git a/Detectors/TRD/calibration/src/PulseHeight.cxx b/Detectors/TRD/calibration/src/PulseHeight.cxx
index 1981fe528f0f5..44446d40df438 100644
--- a/Detectors/TRD/calibration/src/PulseHeight.cxx
+++ b/Detectors/TRD/calibration/src/PulseHeight.cxx
@@ -23,6 +23,7 @@ using namespace o2::trd::constants;
 void PulseHeight::reset()
 {
   mPHValues.clear();
+  mPHValuesHD.clear();
   mDistances.clear();
 }
 
@@ -39,6 +40,7 @@ void PulseHeight::createOutputFile()
   }
   mOutTree = std::make_unique<TTree>("ph", "Data points for PH histograms");
   mOutTree->Branch("values", &mPHValuesPtr);
+  mOutTree->Branch("valuesHD", &mPHValuesHDPtr);
   mOutTree->Branch("dist", &mDistancesPtr);
   mWriteOutput = true;
   LOG(info) << "Writing PH data points to local file trd_PH.root";
@@ -178,13 +180,17 @@ void PulseHeight::findDigitsForTracklet(const Tracklet64& trklt, const TriggerRe
       mDistances.push_back(digitTrackletDistance);
       for (int iTb = 0; iTb < TIMEBINS; ++iTb) {
         uint16_t phVal = digit.getADC()[iTb];
+        uint16_t phValHD = (digit.getADC()[iTb] << 2) + digit.getPreTrigPhase();
         if (left) {
           phVal += digitLeft->getADC()[iTb];
+          phValHD += (digitLeft->getADC()[iTb] << 2) + digit.getPreTrigPhase();
         }
         if (right) {
           phVal += digitRight->getADC()[iTb];
+          phValHD += (digitRight->getADC()[iTb] << 2) + digit.getPreTrigPhase();
         }
         mPHValues.emplace_back(phVal, trkltDet, iTb, nNeighbours, type);
+        mPHValuesHD.emplace_back(phValHD, trkltDet, iTb, nNeighbours, type);
       }
     }
   }
diff --git a/Detectors/TRD/qc/src/RawDataManager.cxx b/Detectors/TRD/qc/src/RawDataManager.cxx
index 1add53cae12ac..c53cd434e6b7b 100644
--- a/Detectors/TRD/qc/src/RawDataManager.cxx
+++ b/Detectors/TRD/qc/src/RawDataManager.cxx
@@ -23,6 +23,8 @@
 
 #include <set>
 #include <utility>
+#include <algorithm>
+#include <execution>
 
 using namespace o2::trd;
 
diff --git a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
index 107a05a397c00..27e089fcf3555 100644
--- a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
+++ b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
@@ -259,8 +259,8 @@ o2::ctf::CTFIOSize CTFCoder::decode(const CTF::base& ec, VTRG& trigVec, VTRK& tr
       uint32_t firstEntryDig = digVec.size();
       int16_t cid = 0;
       for (uint32_t id = 0; id < entriesDig[itrig]; id++) {
-        cid += CIDDig[digCount]; // 1st digit of trigger was encoded with abs CID, then increments
-        auto& dig = digVec.emplace_back(cid, ROBDig[digCount], MCMDig[digCount], chanDig[digCount]);
+        cid += CIDDig[digCount]; // as cid has phase, its stored fully not  // 1st digit of trigger was encoded with abs CID, then increments
+        auto& dig = digVec.emplace_back(cid & 0xfff, ROBDig[digCount], MCMDig[digCount], chanDig[digCount], (cid >> 12) & 0x3);
         dig.setADC({&ADCDig[adcCount], constants::TIMEBINS});
         digCount++;
         adcCount += constants::TIMEBINS;
diff --git a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFHelper.h b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFHelper.h
index 316f2c8a5c7f0..bb41ea9658c9d 100644
--- a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFHelper.h
+++ b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFHelper.h
@@ -288,12 +288,12 @@ class CTFHelper
     // assume sorting in CID: for the 1st digit of the trigger return the abs CID, for the following ones: difference to previous CID
     value_type operator*() const
     {
-      return (*mTrigStart)[mIndex] ? mData[mIndex].getDetector() : mData[mIndex].getDetector() - mData[mIndex - 1].getDetector();
+      return (*mTrigStart)[mIndex] ? mData[mIndex].getDetectorInFull() : mData[mIndex].getDetectorInFull() - mData[mIndex - 1].getDetectorInFull();
     }
     value_type operator[](difference_type i) const
     {
       size_t id = mIndex + i;
-      return (*mTrigStart)[id] ? mData[id].getDetector() : mData[id].getDetector() - mData[id - 1].getDetector();
+      return (*mTrigStart)[id] ? mData[id].getDetectorInFull() : mData[id].getDetectorInFull() - mData[id - 1].getDetectorInFull();
     }
   };
 
diff --git a/Detectors/TRD/reconstruction/src/CruRawReader.cxx b/Detectors/TRD/reconstruction/src/CruRawReader.cxx
index b4a37956759b9..05666691370db 100644
--- a/Detectors/TRD/reconstruction/src/CruRawReader.cxx
+++ b/Detectors/TRD/reconstruction/src/CruRawReader.cxx
@@ -301,6 +301,9 @@ bool CruRawReader::parseDigitHCHeaders(int hcid)
         DigitHCHeader1 header1;
         header1.word = headers[headerwordcount];
         mPreTriggerPhase = header1.ptrigphase;
+        mPreTriggerPhase &= 0x0f;
+        mPreTriggerPhase /= 3; // remove the "gaps" in the pre trigger phase, so we dont have to sort it out later.
+        LOGP(debug, "Found pretrigger phase of Phase:{:x}", mPreTriggerPhase);
 
         headersfound.set(0);
         if ((header1.numtimebins > TIMEBINS) || (header1.numtimebins < 3) || mTimeBinsFixed && header1.numtimebins != mTimeBins) {
@@ -802,6 +805,7 @@ int CruRawReader::parseDigitLinkData(int maxWords32, int hcid, int& wordsRejecte
           if (exitChannelLoop) {
             break;
           }
+          LOGP(debug, "Adding digit to event record det: {} rob: {} mcm: {} channel: {} Phase:{:x}", hcid / 2, (int)mcmHeader.rob, (int)mcmHeader.mcm, iChannel, mPreTriggerPhase);
           mEventRecords.getCurrentEventRecord().addDigit(Digit(hcid / 2, (int)mcmHeader.rob, (int)mcmHeader.mcm, iChannel, adcValues, mPreTriggerPhase));
           ++mDigitsFound;
         } // end active channel
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h
index 536353c7a9e90..3cfbb16644e54 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h
@@ -58,6 +58,8 @@ class PuseHeightDevice : public o2::framework::Task
     if (mRunStopRequested) {
       std::vector<PHData> mPHValues{}; // the calibration expects data at every TF, so inject dummy
       pc.outputs().snapshot(Output{"TRD", "PULSEHEIGHT", 0}, mPHValues);
+      std::vector<PHDataHD> mPHValuesHD{}; // the calibration expects data at every TF, so inject dummy
+      pc.outputs().snapshot(Output{"TRD", "PULSEHEIGHTHD", 0}, mPHValuesHD);
       return;
     }
     RecoContainer recoData;

From 3cbed2e40e0d3b43efe5e4e016559375f6b1dde9 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Fri, 5 Dec 2025 17:41:23 +0100
Subject: [PATCH 1111/1764] Add GRPLHCIF to AggregatedRunInfo

---
 .../include/DataFormatsParameters/AggregatedRunInfo.h     | 4 +++-
 DataFormats/Parameters/src/AggregatedRunInfo.cxx          | 8 +++++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h b/DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h
index bd2cb0c5cbb27..d0347114b5b4c 100644
--- a/DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h
+++ b/DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h
@@ -23,6 +23,7 @@ namespace o2::parameters
 {
 
 class GRPECSObject;
+class GRPLHCIFData;
 
 /// Composite struct where one may collect important global properties of data "runs"
 /// aggregated from various sources (GRPECS, RunInformation CCDB entries, etc.).
@@ -39,8 +40,9 @@ struct AggregatedRunInfo {
 
   // we may have pointers to actual data source objects GRPECS, ...
   const o2::parameters::GRPECSObject* grpECS = nullptr; // pointer to GRPECSobject (fetched during struct building)
+  const o2::parameters::GRPLHCIFData* grpLHC = nullptr;
 
-  static AggregatedRunInfo buildAggregatedRunInfo(int runnumber, long sorMS, long eorMS, long orbitResetMUS, const o2::parameters::GRPECSObject* grpecs, const std::vector<Long64_t>* ctfFirstRunOrbitVec);
+  static AggregatedRunInfo buildAggregatedRunInfo(int runnumber, long sorMS, long eorMS, long orbitResetMUS, const o2::parameters::GRPECSObject* grpecs, const std::vector<Long64_t>* ctfFirstRunOrbitVec, const o2::parameters::GRPLHCIFData* grplhcif = nullptr);
 
   // fills and returns AggregatedRunInfo for a given data run number.
   static AggregatedRunInfo buildAggregatedRunInfo_DATA(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber);
diff --git a/DataFormats/Parameters/src/AggregatedRunInfo.cxx b/DataFormats/Parameters/src/AggregatedRunInfo.cxx
index 5495ae73bd6ca..40402a33af68b 100644
--- a/DataFormats/Parameters/src/AggregatedRunInfo.cxx
+++ b/DataFormats/Parameters/src/AggregatedRunInfo.cxx
@@ -15,6 +15,7 @@
 #include "DataFormatsParameters/AggregatedRunInfo.h"
 #include "CCDB/BasicCCDBManager.h"
 #include "DataFormatsParameters/GRPECSObject.h"
+#include "DataFormatsParameters/GRPLHCIFData.h"
 #include "CommonConstants/LHCConstants.h"
 #include "Framework/Logger.h"
 #include <map>
@@ -42,14 +43,15 @@ o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo_DATA
   std::map<std::string, std::string> metadata;
   metadata["runNumber"] = Form("%d", runnumber);
   auto grpecs = ccdb.getSpecific<o2::parameters::GRPECSObject>("GLO/Config/GRPECS", run_mid_timestamp, metadata);
+  auto grplhcif = ccdb.getSpecific<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF", run_mid_timestamp); // no run metadata here
   bool oldFatalState = ccdb.getFatalWhenNull();
   ccdb.setFatalWhenNull(false);
   auto ctp_first_run_orbit = ccdb.getForTimeStamp<std::vector<Long64_t>>("CTP/Calib/FirstRunOrbit", run_mid_timestamp);
   ccdb.setFatalWhenNull(oldFatalState);
-  return buildAggregatedRunInfo(runnumber, sor, eor, tsOrbitReset, grpecs, ctp_first_run_orbit);
+  return buildAggregatedRunInfo(runnumber, sor, eor, tsOrbitReset, grpecs, ctp_first_run_orbit, grplhcif);
 }
 
-o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(int runnumber, long sorMS, long eorMS, long orbitResetMUS, const o2::parameters::GRPECSObject* grpecs, const std::vector<Long64_t>* ctfFirstRunOrbitVec)
+o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(int runnumber, long sorMS, long eorMS, long orbitResetMUS, const o2::parameters::GRPECSObject* grpecs, const std::vector<Long64_t>* ctfFirstRunOrbitVec, const o2::parameters::GRPLHCIFData* grplhcif)
 {
   auto nOrbitsPerTF = grpecs->getNHBFPerTF();
   // calculate SOR/EOR orbits
@@ -81,7 +83,7 @@ o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(int
       orbitSOR = (orbitSOR / nOrbitsPerTF + 1) * nOrbitsPerTF;
     }
   }
-  return AggregatedRunInfo{runnumber, sorMS, eorMS, nOrbitsPerTF, orbitResetMUS, orbitSOR, orbitEOR, grpecs};
+  return AggregatedRunInfo{runnumber, sorMS, eorMS, nOrbitsPerTF, orbitResetMUS, orbitSOR, orbitEOR, grpecs, grplhcif};
 }
 
 namespace

From 6db969d4c5c835def1263a38c9251e8faf7cb029 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Fri, 5 Dec 2025 17:44:30 +0100
Subject: [PATCH 1112/1764] Introducing non-uniform mu InteractionSampler

Provides a novel InteractionSampler for collision structure
which is able to sample (orbit,bc) values according to an
externally given hNBcVTX distribution (obtained from FIT, EventSelection)

A unit test which shows and tests the new feature.

Fixes https://its.cern.ch/jira/browse/O2-6450
---
 DataFormats/simulation/CMakeLists.txt         |  5 +
 .../SimulationDataFormat/InteractionSampler.h | 25 +++++
 .../simulation/src/InteractionSampler.cxx     | 97 ++++++++++++++++++-
 .../simulation/src/SimulationDataLinkDef.h    |  1 +
 .../test/testInteractionSampler.cxx           | 76 +++++++++++++++
 5 files changed, 203 insertions(+), 1 deletion(-)
 create mode 100644 DataFormats/simulation/test/testInteractionSampler.cxx

diff --git a/DataFormats/simulation/CMakeLists.txt b/DataFormats/simulation/CMakeLists.txt
index fac67cc927562..33c91337c77e9 100644
--- a/DataFormats/simulation/CMakeLists.txt
+++ b/DataFormats/simulation/CMakeLists.txt
@@ -55,6 +55,11 @@ o2_target_root_dictionary(
 # * src/SimulationDataLinkDef.h
 # * and not src/SimulationDataFormatLinkDef.h
 
+o2_add_test(InteractionSampler
+            SOURCES test/testInteractionSampler.cxx
+            COMPONENT_NAME SimulationDataFormat
+            PUBLIC_LINK_LIBRARIES O2::SimulationDataFormat)
+
 o2_add_test(BasicHits
             SOURCES test/testBasicHits.cxx
             COMPONENT_NAME SimulationDataFormat
diff --git a/DataFormats/simulation/include/SimulationDataFormat/InteractionSampler.h b/DataFormats/simulation/include/SimulationDataFormat/InteractionSampler.h
index d2ccec147cc4f..47dd4f5e4652d 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/InteractionSampler.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/InteractionSampler.h
@@ -22,6 +22,7 @@
 #include "CommonDataFormat/BunchFilling.h"
 #include "CommonConstants/LHCConstants.h"
 #include "MathUtils/RandomRing.h"
+#include <TH1F.h>
 
 namespace o2
 {
@@ -130,6 +131,30 @@ class FixedSkipBC_InteractionSampler : public InteractionSampler
   ClassDef(FixedSkipBC_InteractionSampler, 1);
 };
 
+// A version of the interaction sampler which can sample according to non-uniform mu(bc) as
+// observed during data taking.
+class NonUniformMuInteractionSampler : public InteractionSampler
+{
+ public:
+  NonUniformMuInteractionSampler() : InteractionSampler() { mBCIntensityScales.resize(o2::constants::lhc::LHCMaxBunches, 1); }
+  bool setBCIntensityScales(const std::vector<float>& scales_from_vector);
+  bool setBCIntensityScales(const TH1F& scales_from_histo); // initialize scales
+
+  // helper function to determine the scales from a histogram (count from event selection analysis)
+  std::vector<float> determineBCIntensityScalesFromHistogram(const TH1F& scales_from_histo);
+
+  const std::vector<float>& getBCIntensityScales() const { return mBCIntensityScales; }
+
+ protected:
+  int simulateInteractingBC() override;
+  int getBCJump() const;
+
+ private:
+  // non-uniformity
+  std::vector<float> mBCIntensityScales;
+  ClassDef(NonUniformMuInteractionSampler, 1);
+};
+
 } // namespace steer
 } // namespace o2
 
diff --git a/DataFormats/simulation/src/InteractionSampler.cxx b/DataFormats/simulation/src/InteractionSampler.cxx
index 5e14e22e5f8db..61b2c4f61bc08 100644
--- a/DataFormats/simulation/src/InteractionSampler.cxx
+++ b/DataFormats/simulation/src/InteractionSampler.cxx
@@ -115,8 +115,8 @@ const o2::InteractionTimeRecord& InteractionSampler::generateCollisionTime()
 int InteractionSampler::simulateInteractingBC()
 {
   // Returns number of collisions assigned to selected BC
-
   nextCollidingBC(mBCJumpGenerator.getNextValue());
+
   // once BC is decided, enforce at least one interaction
   int ncoll = mNCollBCGenerator.getNextValue();
 
@@ -162,3 +162,98 @@ void InteractionSampler::setBunchFilling(const std::string& bcFillingFile)
   mBCFilling = *bc;
   delete bc;
 }
+
+// ________________________________________________
+bool NonUniformMuInteractionSampler::setBCIntensityScales(const std::vector<float>& scales_from_vector)
+{
+  // Sets the intensity scales per bunch crossing index
+  // The length of this vector needs to be compatible with the bunch filling chosen
+  mBCIntensityScales = scales_from_vector;
+
+  if (scales_from_vector.size() != mInteractingBCs.size()) {
+    LOG(error) << "Scaling factors and bunch filling scheme are not compatible. Not doing anything";
+    return false;
+  }
+
+  float sum = 0.;
+  for (auto v : mBCIntensityScales) {
+    sum += std::abs(v);
+  }
+  if (sum == 0) {
+    LOGP(warn, "total intensity is 0, assuming uniform");
+    for (auto& v : mBCIntensityScales) {
+      v = 1.f;
+    }
+  } else { // normalize
+    float norm = mBCIntensityScales.size() / sum;
+    for (auto& v : mBCIntensityScales) {
+      v = std::abs(v) * norm;
+    }
+  }
+  return false;
+}
+
+// ________________________________________________
+
+bool NonUniformMuInteractionSampler::setBCIntensityScales(const TH1F& hist)
+{
+  return setBCIntensityScales(determineBCIntensityScalesFromHistogram(hist));
+}
+
+std::vector<float> NonUniformMuInteractionSampler::determineBCIntensityScalesFromHistogram(const TH1F& hist)
+{
+  std::vector<float> scales;
+  // we go through the BCs and query the count from histogram
+  for (auto bc : mInteractingBCs) {
+    scales.push_back(hist.GetBinContent(bc + 1));
+  }
+  return scales;
+}
+
+int NonUniformMuInteractionSampler::getBCJump() const
+{
+  auto muFunc = [this](int bc_position) {
+    return mBCIntensityScales[bc_position % mInteractingBCs.size()] * mMuBC;
+  };
+
+  double U = gRandom->Rndm();    // uniform (0,1)
+  double T = -std::log(1.0 - U); // threshold
+  double sumMu = 0.0;
+  int offset = 0;
+  auto bcStart = mCurrBCIdx; // the current bc
+
+  while (sumMu < T) {
+    auto mu_here = muFunc(bcStart + offset); // mu at next BC
+    sumMu += mu_here;
+    if (sumMu >= T) {
+      break; // found BC with at least one collision
+    }
+    ++offset;
+  }
+  return offset;
+}
+
+int NonUniformMuInteractionSampler::simulateInteractingBC()
+{
+  nextCollidingBC(getBCJump());
+
+  auto muFunc = [this](int bc_position) {
+    return mBCIntensityScales[bc_position % mInteractingBCs.size()] * mMuBC;
+  };
+
+  // now sample number of collisions in chosenBC, conditioned >=1:
+  double mu_chosen = muFunc(mCurrBCIdx); // or does it need to be mCurrBCIdx
+  int ncoll = 0;
+  do {
+    ncoll = gRandom->Poisson(mu_chosen);
+  } while (ncoll == 0);
+
+  // assign random time withing a bunch
+  for (int i = ncoll; i--;) {
+    mTimeInBC.push_back(mCollTimeGenerator.getNextValue());
+  }
+  if (ncoll > 1) { // sort in DECREASING time order (we are reading vector from the end)
+    std::sort(mTimeInBC.begin(), mTimeInBC.end(), [](const float a, const float b) { return a > b; });
+  }
+  return ncoll;
+}
\ No newline at end of file
diff --git a/DataFormats/simulation/src/SimulationDataLinkDef.h b/DataFormats/simulation/src/SimulationDataLinkDef.h
index 15abe9d50390f..8f74bd757e791 100644
--- a/DataFormats/simulation/src/SimulationDataLinkDef.h
+++ b/DataFormats/simulation/src/SimulationDataLinkDef.h
@@ -25,6 +25,7 @@
 
 #pragma link C++ class o2::steer::InteractionSampler + ;
 #pragma link C++ class o2::steer::FixedSkipBC_InteractionSampler + ;
+#pragma link C++ class o2::steer::NonUniformMuInteractionSampler + ;
 #pragma link C++ class o2::sim::StackParam + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::sim::StackParam> + ;
 #pragma link C++ class o2::MCTrackT < double> + ;
diff --git a/DataFormats/simulation/test/testInteractionSampler.cxx b/DataFormats/simulation/test/testInteractionSampler.cxx
new file mode 100644
index 0000000000000..b1b3691884ccf
--- /dev/null
+++ b/DataFormats/simulation/test/testInteractionSampler.cxx
@@ -0,0 +1,76 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#define BOOST_TEST_MODULE Test InteractionSampler class
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_DYN_LINK
+
+#include <boost/test/unit_test.hpp>
+#include "SimulationDataFormat/InteractionSampler.h"
+#include "CCDB/BasicCCDBManager.h"
+#include "DataFormatsParameters/AggregatedRunInfo.h"
+#include "DataFormatsParameters/GRPLHCIFData.h"
+#include "TFile.h"
+#include "TGrid.h"
+#include <TH1F.h>
+
+namespace o2
+{
+
+BOOST_AUTO_TEST_CASE(NonUniformSampler)
+{
+  auto run_number = 559827;
+  TGrid::Connect("alien");
+  if (gGrid) {
+    auto runInfo = o2::parameters::AggregatedRunInfo::buildAggregatedRunInfo(o2::ccdb::BasicCCDBManager::instance(), run_number);
+
+    o2::steer::NonUniformMuInteractionSampler sampler;
+    sampler.setBunchFilling(runInfo.grpLHC->getBunchFilling());
+
+    // the test distribution provided by Igor Altsybeev
+    auto distr_file = TFile::Open("alien:///alice/cern.ch/user/s/swenzel/AliceO2_TestData/NBcVTX_559827/hBcTVX_data_PbPb_24ar_559827.root");
+
+    //
+    if (distr_file && !distr_file->IsZombie()) {
+      auto hist = distr_file->Get<TH1F>("hBcTVX");
+      if (hist) {
+        sampler.init();
+        sampler.setBCIntensityScales(*hist);
+
+        // sample into a vector of a certain size
+        std::vector<o2::InteractionTimeRecord> samples;
+
+        int N = 100000;
+        samples.resize(N);
+
+        sampler.generateCollisionTimes(samples);
+
+        // fill an output histogram
+        auto output_hist = (TH1F*)hist->Clone("h2"); // make a full copy
+        output_hist->Reset();
+
+        for (const auto& sample : samples) {
+          output_hist->Fill(sample.bc);
+        }
+
+        // Write out
+        auto fout = TFile::Open("NBCVTX_out.root", "RECREATE");
+        fout->WriteObject(output_hist, "NBcVTX");
+        fout->Close();
+
+        // compare mean values of original and newly sampled hist
+        BOOST_CHECK_CLOSE(hist->GetMean(), output_hist->GetMean(), 0.5);
+      }
+    }
+  }
+}
+
+} // namespace o2

From ff367092f58c49e08c707f5fc5dec6ae3524ba17 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 8 Dec 2025 10:19:38 +0100
Subject: [PATCH 1113/1764] DPL: drop support for FairMQ versions without
 shallow copy

---
 .../include/Framework/CompletionPolicyHelpers.h    |  3 +--
 Framework/Core/src/CompletionPolicy.cxx            |  4 ----
 Framework/Core/src/CompletionPolicyHelpers.cxx     |  4 ----
 Framework/Core/src/DataProcessingDevice.cxx        | 14 --------------
 Framework/Core/src/DataRelayer.cxx                 | 10 ----------
 5 files changed, 1 insertion(+), 34 deletions(-)

diff --git a/Framework/Core/include/Framework/CompletionPolicyHelpers.h b/Framework/Core/include/Framework/CompletionPolicyHelpers.h
index aa336d040d30d..7f77e4a96f76f 100644
--- a/Framework/Core/include/Framework/CompletionPolicyHelpers.h
+++ b/Framework/Core/include/Framework/CompletionPolicyHelpers.h
@@ -44,10 +44,9 @@ struct CompletionPolicyHelpers {
   /// When any of the parts of the record have been received, consume them.
   static CompletionPolicy consumeWhenAny(const char* name, CompletionPolicy::Matcher matcher);
 
-#if __has_include(<fairmq/shmem/Message.h>)
   /// When any of the parts which has arrived has a refcount of 1.
   static CompletionPolicy consumeWhenAnyZeroCount(const char* name, CompletionPolicy::Matcher matcher);
-#endif
+
   /// Default matcher applies for all devices
   static CompletionPolicy consumeWhenAny(CompletionPolicy::Matcher matcher = [](auto const&) -> bool { return true; })
   {
diff --git a/Framework/Core/src/CompletionPolicy.cxx b/Framework/Core/src/CompletionPolicy.cxx
index ec8997e32c5db..a09028b9249f3 100644
--- a/Framework/Core/src/CompletionPolicy.cxx
+++ b/Framework/Core/src/CompletionPolicy.cxx
@@ -26,11 +26,7 @@ std::vector<CompletionPolicy>
 {
   return {
     CompletionPolicyHelpers::consumeWhenAllOrdered("internal-dpl-aod-writer"),
-#if __has_include(<fairmq/shmem/Message.h>)
     CompletionPolicyHelpers::consumeWhenAnyZeroCount("internal-dpl-injected-dummy-sink", [](DeviceSpec const& s) { return s.name.find("internal-dpl-injected-dummy-sink") != std::string::npos; }),
-#else
-    CompletionPolicyHelpers::consumeWhenAny("internal-dpl-injected-dummy-sink", [](DeviceSpec const& s) { return s.name.find("internal-dpl-injected-dummy-sink") != std::string::npos; }),
-#endif
     CompletionPolicyHelpers::consumeWhenAll()};
 }
 
diff --git a/Framework/Core/src/CompletionPolicyHelpers.cxx b/Framework/Core/src/CompletionPolicyHelpers.cxx
index e682f9a7c7dd6..67c726b7f4368 100644
--- a/Framework/Core/src/CompletionPolicyHelpers.cxx
+++ b/Framework/Core/src/CompletionPolicyHelpers.cxx
@@ -19,9 +19,7 @@
 #include "Framework/TimingInfo.h"
 #include "DecongestionService.h"
 #include "Framework/Signpost.h"
-#if __has_include(<fairmq/shmem/Message.h>)
 #include <fairmq/shmem/Message.h>
-#endif
 
 #include <cassert>
 #include <regex>
@@ -252,7 +250,6 @@ CompletionPolicy CompletionPolicyHelpers::consumeExistingWhenAny(const char* nam
     }};
 }
 
-#if __has_include(<fairmq/shmem/Message.h>)
 CompletionPolicy CompletionPolicyHelpers::consumeWhenAnyZeroCount(const char* name, CompletionPolicy::Matcher matcher)
 {
   auto callback = [](InputSpan const& inputs, std::vector<InputSpec> const&, ServiceRegistryRef& ref) -> CompletionPolicy::CompletionOp {
@@ -265,7 +262,6 @@ CompletionPolicy CompletionPolicyHelpers::consumeWhenAnyZeroCount(const char* na
   };
   return CompletionPolicy{name, matcher, callback, false};
 }
-#endif
 
 CompletionPolicy CompletionPolicyHelpers::consumeWhenAny(const char* name, CompletionPolicy::Matcher matcher)
 {
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 406e93aaae98e..40f1061e60332 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -59,9 +59,7 @@
 #include <fairmq/Parts.h>
 #include <fairmq/Socket.h>
 #include <fairmq/ProgOptions.h>
-#if __has_include(<fairmq/shmem/Message.h>)
 #include <fairmq/shmem/Message.h>
-#endif
 #include <Configuration/ConfigurationInterface.h>
 #include <Configuration/ConfigurationFactory.h>
 #include <Monitoring/Monitoring.h>
@@ -1046,14 +1044,6 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
       if (forwarded.matcher.lifetime != Lifetime::Condition) {
         onlyConditions = false;
       }
-#if !__has_include(<fairmq/shmem/Message.h>)
-      if (strncmp(DataSpecUtils::asConcreteOrigin(forwarded.matcher).str, "AOD", 3) == 0) {
-        context.canForwardEarly = false;
-        overriddenEarlyForward = true;
-        LOG(detail) << "Cannot forward early because of AOD input: " << DataSpecUtils::describe(forwarded.matcher);
-        break;
-      }
-#endif
       if (DataSpecUtils::partialMatch(forwarded.matcher, o2::header::DataDescription{"RAWDATA"}) && deviceContext.processingPolicies.earlyForward == EarlyForwardPolicy::NORAW) {
         context.canForwardEarly = false;
         overriddenEarlyForward = true;
@@ -2058,14 +2048,10 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     auto nofPartsGetter = [&currentSetOfInputs](size_t i) -> size_t {
       return currentSetOfInputs[i].getNumberOfPairs();
     };
-#if __has_include(<fairmq/shmem/Message.h>)
     auto refCountGetter = [&currentSetOfInputs](size_t idx) -> int {
       auto& header = static_cast<const fair::mq::shmem::Message&>(*currentSetOfInputs[idx].header(0));
       return header.GetRefCount();
     };
-#else
-    std::function<int(size_t)> refCountGetter = nullptr;
-#endif
     return InputSpan{getter, nofPartsGetter, refCountGetter, currentSetOfInputs.size()};
   };
 
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 06e920112649e..df95aeda92a2b 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -47,9 +47,7 @@
 #include <fairlogger/Logger.h>
 #include <fairmq/Channel.h>
 #include <functional>
-#if __has_include(<fairmq/shmem/Message.h>)
 #include <fairmq/shmem/Message.h>
-#endif
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 #include <span>
@@ -215,14 +213,10 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       auto nPartsGetter = [&partial](size_t idx) {
         return partial[idx].size();
       };
-#if __has_include(<fairmq/shmem/Message.h>)
       auto refCountGetter = [&partial](size_t idx) -> int {
         auto& header = static_cast<const fair::mq::shmem::Message&>(*partial[idx].header(0));
         return header.GetRefCount();
       };
-#else
-      std::function<int(size_t)> refCountGetter = nullptr;
-#endif
       InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
       // Setup the input span
 
@@ -781,14 +775,10 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
     auto nPartsGetter = [&partial](size_t idx) {
       return partial[idx].size();
     };
-#if __has_include(<fairmq/shmem/Message.h>)
     auto refCountGetter = [&partial](size_t idx) -> int {
       auto& header = static_cast<const fair::mq::shmem::Message&>(*partial[idx].header(0));
       return header.GetRefCount();
     };
-#else
-    std::function<int(size_t)> refCountGetter = nullptr;
-#endif
     InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
     CompletionPolicy::CompletionOp action = mCompletionPolicy.callbackFull(span, mInputs, mContext);
 

From 1add74e3bf64b1ad7dde54675e7d5af2718695d9 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 8 Dec 2025 22:54:07 +0100
Subject: [PATCH 1114/1764] workflow to study ITS residuals

---
 .../study/CMakeLists.txt                      |   9 +
 .../include/GlobalTrackingStudy/CheckResid.h  |  27 +
 .../GlobalTrackingStudy/CheckResidConfig.h    |  38 ++
 .../GlobalTrackingStudy/CheckResidTypes.h     |  42 ++
 .../study/src/CheckResid.cxx                  | 556 ++++++++++++++++++
 .../study/src/CheckResidConfig.cxx            |  14 +
 .../study/src/GlobalTrackingStudyLinkDef.h    |   6 +
 .../study/src/check-resid-workflow.cxx        |  78 +++
 8 files changed, 770 insertions(+)
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidTypes.h
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/src/CheckResidConfig.cxx
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx

diff --git a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
index 776d3946283c3..df42af503db46 100644
--- a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
+++ b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
@@ -25,6 +25,8 @@ o2_add_library(GlobalTrackingStudy
                        src/TrackMCStudyConfig.cxx
                        src/TrackMCStudyTypes.cxx
                        src/TPCClusSelector.cxx
+                       src/CheckResid.cxx
+                       src/CheckResidConfig.cxx
                PUBLIC_LINK_LIBRARIES O2::GlobalTracking
                                      O2::GlobalTrackingWorkflowReaders
                                      O2::GlobalTrackingWorkflowHelpers
@@ -38,6 +40,8 @@ o2_target_root_dictionary(GlobalTrackingStudy
                                   include/GlobalTrackingStudy/TrackInfoExt.h
                                   include/GlobalTrackingStudy/TrackMCStudyConfig.h
                                   include/GlobalTrackingStudy/TrackMCStudyTypes.h
+                                  include/GlobalTrackingStudy/CheckResidTypes.h
+                                  include/GlobalTrackingStudy/CheckResidConfig.h
                           LINKDEF src/GlobalTrackingStudyLinkDef.h
 )
 
@@ -76,6 +80,11 @@ o2_add_executable(dump-workfow
                   SOURCES src/track-dump-workflow.cxx
                   PUBLIC_LINK_LIBRARIES O2::GlobalTrackingStudy)
 
+o2_add_executable(resid-workfow
+                  COMPONENT_NAME check
+                  SOURCES src/check-resid-workflow.cxx
+                  PUBLIC_LINK_LIBRARIES O2::GlobalTrackingStudy)
+
 if (OpenMP_CXX_FOUND)
     target_compile_definitions(${targetName} PRIVATE WITH_OPENMP)
     target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX)
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h
new file mode 100644
index 0000000000000..a78fa5e8d41da
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h
@@ -0,0 +1,27 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_CHECK_RESID_H
+#define O2_CHECK_RESID_H
+
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "Framework/Task.h"
+#include "Framework/DataProcessorSpec.h"
+// #include "TPCCalibration/CorrectionMapsLoader.h"
+
+namespace o2::checkresid
+{
+/// create a processor spec
+o2::framework::DataProcessorSpec getCheckResidSpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC /*, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts*/);
+
+} // namespace o2::checkresid
+
+#endif // O2_CHECK_RESID_H
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
new file mode 100644
index 0000000000000..53dffeed7ad69
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
@@ -0,0 +1,38 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_CHECK_RESID_CONFIG_H
+#define O2_CHECK_RESID_CONFIG_H
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2::checkresid
+{
+struct CheckResidConfig : o2::conf::ConfigurableParamHelper<CheckResidConfig> {
+  int minPVContributors = 10;
+  int minTPCCl = 60;
+  int minITSCl = 7;
+  float minPt = 0.4f;
+  float maxPt = 100.f;
+  float rCompIBOB = 12.f;
+
+  bool pvcontribOnly = true;
+  bool addPVAsCluster = true;
+  bool refitPV = true;
+  bool useStableRef = true;
+  bool doIBOB = true;
+  bool doResid = true;
+
+  O2ParamDef(CheckResidConfig, "checkresid");
+};
+} // namespace o2::checkresid
+
+#endif
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidTypes.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidTypes.h
new file mode 100644
index 0000000000000..ebb6a7aabe9fa
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidTypes.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_CHECK_RESID_TYPES_H
+#define O2_CHECK_RESID_TYPES_H
+
+#include "ReconstructionDataFormats/Track.h"
+
+namespace o2::checkresid
+{
+struct Point {
+  float dy = 0.f;
+  float dz = 0.f;
+  float sig2y = 0.f;
+  float sig2z = 0.f;
+  float phi = 0.f;
+  float z = 0.f;
+  int16_t sens = -1;
+  int8_t lr = -1; // -1 = vtx
+  ClassDefNV(Point, 1)
+};
+
+struct Track {
+  o2::dataformats::GlobalTrackID gid{};
+  o2::track::TrackPar track;
+  o2::track::TrackParCov trIBOut;
+  o2::track::TrackParCov trOBInw;
+  std::vector<Point> points;
+  ClassDefNV(Track, 1)
+};
+
+} // namespace o2::checkresid
+
+#endif
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
new file mode 100644
index 0000000000000..34643928db344
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
@@ -0,0 +1,556 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GlobalTrackingStudy/CheckResid.h"
+#include "GlobalTrackingStudy/CheckResidTypes.h"
+#include "GlobalTrackingStudy/CheckResidConfig.h"
+#include <vector>
+#include "ReconstructionDataFormats/Track.h"
+#include <TStopwatch.h>
+#include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "DataFormatsITSMFT/TrkClusRef.h"
+#include "DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h"
+#include "ReconstructionDataFormats/TrackTPCITS.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "DataFormatsCalibration/MeanVertexObject.h"
+#include "DetectorsBase/Propagator.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "SimulationDataFormat/MCEventLabel.h"
+#include "SimulationDataFormat/MCUtils.h"
+#include "CommonUtils/NameConf.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/DeviceSpec.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "ITStracking/IOUtils.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "ReconstructionDataFormats/PrimaryVertex.h"
+#include "CommonUtils/TreeStreamRedirector.h"
+#include "ReconstructionDataFormats/VtxTrackRef.h"
+#include "DetectorsVertexing/PVertexer.h"
+
+#ifdef WITH_OPENMP
+#include <omp.h>
+#endif
+
+namespace o2::checkresid
+{
+
+using namespace o2::framework;
+using DetID = o2::detectors::DetID;
+using DataRequest = o2::globaltracking::DataRequest;
+
+using PVertex = o2::dataformats::PrimaryVertex;
+using V2TRef = o2::dataformats::VtxTrackRef;
+using VTIndex = o2::dataformats::VtxTrackIndex;
+using GTrackID = o2::dataformats::GlobalTrackID;
+using timeEst = o2::dataformats::TimeStampWithError<float, float>;
+
+class CheckResidSpec : public Task
+{
+ public:
+  CheckResidSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC /*, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts*/)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC)
+  {
+    /*
+    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
+    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
+    */
+  }
+  ~CheckResidSpec() final = default;
+  void init(InitContext& ic) final;
+  void run(ProcessingContext& pc) final;
+  void endOfStream(EndOfStreamContext& ec) final;
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
+  void process();
+
+ private:
+  void updateTimeDependentParams(ProcessingContext& pc);
+  bool refitPV(o2::dataformats::PrimaryVertex& pv, int vid);
+  bool refitITStrack(o2::track::TrackParCov& track, GTrackID gid);
+  bool processITSTrack(const o2::its::TrackITS& iTrack, const o2::dataformats::PrimaryVertex& pv, o2::checkresid::Track& resTrack);
+
+  o2::globaltracking::RecoContainer* mRecoData = nullptr;
+  int mNThreads = 1;
+  float mITSROFrameLengthMUS = 0.f;
+  o2::dataformats::MeanVertexObject mMeanVtx{};
+  std::vector<o2::BaseCluster<float>> mITSClustersArray;    ///< ITS clusters created in run() method from compact clusters
+  const o2::itsmft::TopologyDictionary* mITSDict = nullptr; ///< cluster patterns dictionary
+  o2::vertexing::PVertexer mVertexer;
+  std::shared_ptr<DataRequest> mDataRequest;
+  std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
+  bool mUseMC{false}; ///< MC flag
+  std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
+  GTrackID::mask_t mTracksSrc{};
+};
+
+void CheckResidSpec::init(InitContext& ic)
+{
+  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
+  int lane = ic.services().get<const o2::framework::DeviceSpec>().inputTimesliceId;
+  int maxLanes = ic.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices;
+  std::string dbgnm = maxLanes == 1 ? "checkResid.root" : fmt::format("checkResid_t{}.root", lane);
+  mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(dbgnm.c_str(), "recreate");
+  mNThreads = ic.options().get<int>("nthreads");
+#ifndef WITH_OPENMP
+  if (mNThreads > 1) {
+    LOGP(warn, "No OpenMP");
+  }
+  mNThreads = 1;
+#endif
+  // mTPCCorrMapsLoader.init(ic);
+}
+
+void CheckResidSpec::run(ProcessingContext& pc)
+{
+  o2::globaltracking::RecoContainer recoData;
+  mRecoData = &recoData;
+  mRecoData->collectData(pc, *mDataRequest.get()); // select tracks of needed type, with minimal cuts, the real selected will be done in the vertexer
+  mRecoData = &recoData;
+  updateTimeDependentParams(pc); // Make sure this is called after recoData.collectData, which may load some conditions
+  process();
+  mRecoData = nullptr;
+}
+
+void CheckResidSpec::updateTimeDependentParams(ProcessingContext& pc)
+{
+  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+  pc.inputs().get<o2::dataformats::MeanVertexObject*>("meanvtx");
+  // mTPCVDriftHelper.extractCCDBInputs(pc);
+  // mTPCCorrMapsLoader.extractCCDBInputs(pc);
+  static bool initOnceDone = false;
+  if (!initOnceDone) { // this params need to be queried only once
+    initOnceDone = true;
+    // Note: reading of the ITS AlpideParam needed for ITS timing is done by the RecoContainer
+    auto grp = o2::base::GRPGeomHelper::instance().getGRPECS();
+    const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
+    if (!grp->isDetContinuousReadOut(DetID::ITS)) {
+      mITSROFrameLengthMUS = alpParams.roFrameLengthTrig / 1.e3; // ITS ROFrame duration in \mus
+    } else {
+      mITSROFrameLengthMUS = alpParams.roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingNS * 1e-3; // ITS ROFrame duration in \mus
+    }
+    auto geom = o2::its::GeometryTGeo::Instance();
+    geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2G));
+    o2::conf::ConfigurableParam::updateFromString("pvertexer.useMeanVertexConstraint=false");
+    mVertexer.init();
+  }
+  bool updateMaps = false;
+  /*
+  if (mTPCCorrMapsLoader.isUpdated()) {
+    mTPCCorrMapsLoader.acknowledgeUpdate();
+    updateMaps = true;
+  }
+  if (mTPCVDriftHelper.isUpdated()) {
+    LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
+         mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
+         mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
+         mTPCVDriftHelper.getSourceName());
+    mTPCVDriftHelper.acknowledgeUpdate();
+    updateMaps = true;
+  }
+  if (updateMaps) {
+    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
+  }
+  */
+}
+
+void CheckResidSpec::process()
+{
+  if (!mITSDict) {
+    LOGP(fatal, "ITS data is not loaded");
+  }
+  const auto itsTracks = mRecoData->getITSTracks();
+  //  const auto itsLbls = mRecoData->getITSTracksMCLabels();
+  const auto itsClRefs = mRecoData->getITSTracksClusterRefs();
+  const auto clusITS = mRecoData->getITSClusters();
+  const auto patterns = mRecoData->getITSClustersPatterns();
+  const auto& params = o2::checkresid::CheckResidConfig::Instance();
+  auto pattIt = patterns.begin();
+  mITSClustersArray.clear();
+  mITSClustersArray.reserve(clusITS.size());
+
+  o2::its::ioutils::convertCompactClusters(clusITS, pattIt, mITSClustersArray, mITSDict);
+
+  auto pvvec = mRecoData->getPrimaryVertices();
+  auto trackIndex = mRecoData->getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
+  auto vtxRefs = mRecoData->getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
+  auto prop = o2::base::Propagator::Instance();
+  static int TFCount = 0;
+  int nv = vtxRefs.size() - 1;
+  std::vector<std::vector<checkresid::Track>> slots;
+  slots.resize(mNThreads);
+  int nvGood = 0, nvUse = 0, nvRefFail = 0;
+  long pvFitDuration{};
+  for (int iv = 0; iv < nv; iv++) {
+    const auto& vtref = vtxRefs[iv];
+    auto pve = pvvec[iv];
+    if (pve.getNContributors() < params.minPVContributors) {
+      continue;
+    }
+    nvGood++;
+    if (params.refitPV) {
+      auto tStartPVF = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+      bool res = refitPV(pve, iv);
+      pvFitDuration += std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count() - tStartPVF;
+      if (!res) {
+        nvRefFail++;
+        continue;
+      }
+    }
+    nvUse++;
+    for (int is = 0; is < GTrackID::NSources; is++) {
+      if (!mTracksSrc[is] || !mRecoData->isTrackSourceLoaded(is)) {
+        continue;
+      }
+      int idMin = vtref.getFirstEntryOfSource(is), idMax = idMin + vtref.getEntriesOfSource(is);
+      DetID::mask_t dm = GTrackID::getSourceDetectorsMask(is);
+      if (!dm[DetID::ITS]) {
+        continue;
+      }
+      if (dm[DetID::TPC] && params.minTPCCl > 0 && !mRecoData->isTrackSourceLoaded(GTrackID::TPC)) {
+        LOGP(fatal, "Cut on TPC tracks is requested by they are not loaded");
+      }
+#ifdef WITH_OPENMP
+#pragma omp parallel for schedule(dynamic) num_threads(mNThreads)
+#endif
+      for (int i = idMin; i < idMax; i++) {
+        auto vid = trackIndex[i];
+        bool pvCont = vid.isPVContributor();
+        if (!pvCont && params.pvcontribOnly) {
+          continue;
+        }
+        if (dm[DetID::TPC] && params.minTPCCl > 0 && mRecoData->getTPCTrack(mRecoData->getTPCContributorGID(vid)).getNClusters() < params.minTPCCl) {
+          continue;
+        }
+        auto gidITS = mRecoData->getITSContributorGID(vid);
+        if (gidITS.getSource() != GTrackID::ITS) {
+          continue;
+        }
+        const auto& trc = mRecoData->getTrackParam(vid);
+        auto pt = trc.getPt();
+        if (pt < params.minPt || pt > params.maxPt) {
+          continue;
+        }
+        const auto& itsTrack = mRecoData->getITSTrack(gidITS);
+        if (itsTrack.getNClusters() < params.minITSCl) {
+          continue;
+        }
+#ifdef WITH_OPENMP
+        auto& accum = slots[omp_get_thread_num()];
+#else
+        auto& accum = slots[0];
+#endif
+        auto& resTrack = accum.emplace_back();
+        if (!processITSTrack(itsTrack, pve, resTrack)) {
+          accum.pop_back();
+          continue;
+        }
+      }
+    }
+  }
+  // output
+  for (const auto& accum : slots) {
+    for (const auto& tr : accum) {
+      (*mDBGOut) << "res" << "tr=" << tr << "\n";
+    }
+  }
+  LOGP(info, "processed {} PVs out of {} good vertices (out of {} in total), PV refits took {} mus, {} refits failed", nvUse, nvGood, nv, pvFitDuration, nvRefFail);
+  TFCount++;
+}
+
+bool CheckResidSpec::processITSTrack(const o2::its::TrackITS& iTrack, const o2::dataformats::PrimaryVertex& pv, o2::checkresid::Track& resTrack)
+{
+  const auto itsClRefs = mRecoData->getITSTracksClusterRefs();
+  auto trFitInw = iTrack.getParamOut(); // seed for inward refit
+  auto trFitOut = iTrack.getParamIn();  // seed for outward refit
+  auto prop = o2::base::Propagator::Instance();
+  auto geom = o2::its::GeometryTGeo::Instance();
+  float pvAlpha = 0;
+  float bz = prop->getNominalBz();
+  std::array<const o2::BaseCluster<float>*, 8> clArr{};
+  const auto& params = CheckResidConfig::Instance();
+  std::array<o2::track::TrackParCov, 8> extrapOut, extrapInw; // 2-way Kalman extrapolations, vertex + 7 layers
+
+  auto rotateTrack = [bz](o2::track::TrackParCov& tr, float alpha, o2::track::TrackPar* refLin) {
+    return refLin ? tr.rotate(alpha, *refLin, bz) : tr.rotate(alpha);
+  };
+
+  auto accountCluster = [&](int i, std::array<o2::track::TrackParCov, 8>& extrapDest, o2::track::TrackParCov& tr, o2::track::TrackPar* refLin) {
+    if (clArr[i]) { // update with cluster
+      if (!rotateTrack(tr, i == 0 ? pvAlpha : geom->getSensorRefAlpha(clArr[i]->getSensorID()), refLin) ||
+          !prop->propagateTo(tr, refLin, clArr[i]->getX(), true)) {
+        return 0;
+      }
+      extrapDest[i] = tr; // before update
+      if (!tr.update(*clArr[i])) {
+        return 0;
+      }
+    } else {
+      extrapDest[i].invalidate();
+      return -1;
+    }
+    return 1;
+  };
+
+  auto inv2d = [](float s00, float s11, float s01) -> std::array<float, 3> {
+    auto det = s00 * s11 - s01 * s01;
+    if (det < 1e-16) {
+      return {0.f, 0.f, 0.f};
+    }
+    det = 1.f / det;
+    return {s11 * det, s00 * det, -s01 * det};
+  };
+
+  resTrack.points.clear();
+  if (!prop->propagateToDCA(pv, trFitOut, bz)) {
+    return false;
+  }
+  float cosAlp, sinAlp;
+  pvAlpha = trFitOut.getAlpha();
+  o2::math_utils::sincos(trFitOut.getAlpha(), sinAlp, cosAlp); // vertex position rotated to track frame
+  o2::BaseCluster<float> bcPV;
+  if (params.addPVAsCluster) {
+    bcPV.setXYZ(pv.getX() * cosAlp + pv.getY() * sinAlp, -pv.getX() * sinAlp + pv.getY() * cosAlp, pv.getZ());
+    bcPV.setSigmaY2(0.5 * (pv.getSigmaX2() + pv.getSigmaY2()));
+    bcPV.setSigmaZ2(pv.getSigmaZ2());
+    bcPV.setSensorID(-1);
+    clArr[0] = &bcPV;
+  }
+  // collect all track clusters to array, placing them to layer+1 slot
+  int nCl = iTrack.getNClusters();
+  for (int i = 0; i < nCl; i++) { // clusters are ordered from the outermost to the innermost
+    const auto& curClu = mITSClustersArray[itsClRefs[iTrack.getClusterEntry(i)]];
+
+    int llr = geom->getLayer(curClu.getSensorID());
+    if (clArr[1 + llr]) {
+      LOGP(error, "Cluster at lr {} was already assigned, old sens {}, new sens {}", llr, clArr[1 + llr]->getSensorID(), curClu.getSensorID());
+    }
+    clArr[1 + geom->getLayer(curClu.getSensorID())] = &curClu;
+  }
+  o2::track::TrackPar refLinInw0, refLinOut0, *refLinOut = nullptr, *refLinInw = nullptr;
+  o2::track::TrackPar refLinIBOut0, refLinOBInw0, *refLinOBInw = nullptr, *refLinIBOut = nullptr;
+  if (params.useStableRef) {
+    refLinOut = &(refLinOut0 = trFitOut);
+    refLinInw = &(refLinInw0 = trFitInw);
+  }
+  trFitOut.resetCovariance();
+  trFitOut.setCov(trFitOut.getQ2Pt() * trFitOut.getQ2Pt() * trFitOut.getCov()[14], 14);
+  trFitInw.resetCovariance();
+  trFitInw.setCov(trFitInw.getQ2Pt() * trFitInw.getQ2Pt() * trFitInw.getCov()[14], 14);
+  // fit in inward and outward direction
+  for (int i = 0; i <= 7; i++) {
+    int resOut, resInw;
+    // process resOut in ascending order (0-->7) and resInw in descending order (7-->0)
+    if (!(resOut = accountCluster(i, extrapOut, trFitOut, refLinOut)) || !(resInw = accountCluster(7 - i, extrapInw, trFitInw, refLinInw))) {
+      return false;
+    }
+    // at layer 3, find the IB track (trIBOut) and the OB track (trOBInw)
+    // propagate both trcaks to a common radius, RCompIBOB (12cm), and rotates
+    // them to the same reference frame for comparison
+    if (i == 3 && resOut == 1 && resInw == 1 && params.doIBOB && nCl == 7) {
+      resTrack.trIBOut = trFitOut; // outward track updated at outermost IB layer
+      resTrack.trOBInw = trFitInw; // inward track updated at innermost OB layer
+      o2::track::TrackPar refLinIBOut0, refLinIBIn0;
+      if (refLinOut) {
+        refLinIBOut = &(refLinIBOut0 = refLinOut0);
+        refLinOBInw = &(refLinOBInw0 = refLinInw0);
+      }
+      float xRref;
+      if (!resTrack.trOBInw.getXatLabR(params.rCompIBOB, xRref, bz) ||
+          !prop->propagateTo(resTrack.trOBInw, refLinOBInw, xRref, true) ||
+          !rotateTrack(resTrack.trOBInw, resTrack.trOBInw.getPhiPos(), refLinOBInw) || // propagate OB track to ref R and rotate
+          !rotateTrack(resTrack.trIBOut, resTrack.trOBInw.getAlpha(), refLinIBOut) ||
+          !prop->propagateTo(resTrack.trIBOut, refLinIBOut, resTrack.trOBInw.getX(), true)) { // rotate OB track to same frame and propagate to same X
+                                                                                              // if any propagation or rotation steps fail, invalidate both tracks
+        return false;
+      }
+    }
+  }
+
+  bool innerDone = false;
+  if (params.doResid) {
+    for (int i = 0; i <= 7; i++) {
+      if (clArr[i]) {
+        // calculate interpolation as a weighted mean of inward/outward extrapolations to this layer
+        const auto &tInw = extrapInw[i], &tOut = extrapOut[i];
+        auto wInw = inv2d(tInw.getSigmaY2(), tInw.getSigmaZ2(), tInw.getSigmaZY());
+        auto wOut = inv2d(tOut.getSigmaY2(), tOut.getSigmaZ2(), tOut.getSigmaZY());
+        if (wInw[0] == 0.f || wOut[0] == 0.f) {
+          return -1;
+        }
+        std::array<float, 3> wTot = {wInw[0] + wOut[0], wInw[1] + wOut[1], wInw[2] + wOut[2]};
+        auto cTot = inv2d(wTot[0], wTot[1], wTot[2]);
+        auto ywi = wInw[0] * tInw.getY() + wInw[2] * tInw.getZ() + wOut[0] * tOut.getY() + wOut[2] * tOut.getZ();
+        auto zwi = wInw[2] * tInw.getY() + wInw[1] * tInw.getZ() + wOut[2] * tOut.getY() + wOut[1] * tOut.getZ();
+        auto yw = ywi * cTot[0] + zwi * cTot[2];
+        auto zw = ywi * cTot[2] + zwi * cTot[1];
+        // posCl.push_back(clArr[i]->getXYZGlo(*o2::its::GeometryTGeo::Instance()));
+        auto phi = i == 0 ? tInw.getPhi() : tInw.getPhiPos();
+        o2::math_utils::bringTo02Pi(phi);
+        resTrack.points.emplace_back(clArr[i]->getY() - yw, clArr[i]->getZ() - zw, cTot[0] + clArr[i]->getSigmaY2(), cTot[1] + clArr[i]->getSigmaZ2(), phi, clArr[i]->getZ(), clArr[i]->getSensorID(), i - 1);
+        if (!innerDone) {
+          resTrack.track = tInw;
+          innerDone = true;
+        }
+      } else {
+        LOGP(warn, "No cluster on lr {}", i);
+      }
+    }
+  }
+  return true;
+}
+
+bool CheckResidSpec::refitPV(o2::dataformats::PrimaryVertex& pv, int vid)
+{
+  const auto& params = o2::checkresid::CheckResidConfig::Instance();
+  std::vector<o2::track::TrackParCov> tracks;
+  std::vector<bool> useTrack;
+  std::vector<GTrackID> gidsITS;
+  int ntr = pv.getNContributors();
+  tracks.reserve(ntr);
+  useTrack.reserve(ntr);
+  gidsITS.reserve(ntr);
+  const auto& vtref = mRecoData->getPrimaryVertexMatchedTrackRefs()[vid];
+  auto trackIndex = mRecoData->getPrimaryVertexMatchedTracks();
+  int itr = vtref.getFirstEntry(), itLim = itr + vtref.getEntries();
+  for (; itr < itLim; itr++) {
+    auto vid = trackIndex[itr];
+    if (vid.isPVContributor()) {
+      tracks.emplace_back().setPID(mRecoData->getTrackParam(vid).getPID());
+      gidsITS.push_back(mRecoData->getITSContributorGID(vid));
+    }
+  }
+  ntr = tracks.size();
+  useTrack.resize(ntr);
+#ifdef WITH_OPENMP
+#pragma omp parallel for schedule(dynamic) num_threads(mNThreads)
+#endif
+  for (int itr = 0; itr < ntr; itr++) {
+    if (!(useTrack[itr] = refitITStrack(tracks[itr], gidsITS[itr]))) {
+      tracks[itr] = mRecoData->getTrackParam(gidsITS[itr]); // this track will not be used but participates in prepareVertexRefit
+    }
+  }
+  ntr = 0;
+  for (auto v : useTrack) {
+    ntr++;
+  }
+  if (ntr < params.minPVContributors || !mVertexer.prepareVertexRefit(tracks, pv)) {
+    return false;
+  }
+  // readjust vertexZ
+  const auto& pool = mVertexer.getTracksPool();
+  float zUpd = 0;
+  for (const auto& t : pool) {
+    zUpd += t.z;
+  }
+  if (pool.size()) {
+    pv.setZ(zUpd / pool.size());
+    mVertexer.prepareVertexRefit(tracks, pv);
+  }
+  pv = mVertexer.refitVertex(useTrack, pv);
+  return pv.getChi2() > 0.f;
+}
+
+bool CheckResidSpec::refitITStrack(o2::track::TrackParCov& track, GTrackID gid)
+{
+  // destination tack might have non-default PID assigned
+  const auto& trkITS = mRecoData->getITSTrack(gid);
+  const auto itsClRefs = mRecoData->getITSTracksClusterRefs();
+  const auto& params = CheckResidConfig::Instance();
+  auto pid = track.getPID();
+  track = trkITS.getParamOut();
+  track.setPID(pid);
+  auto nCl = trkITS.getNumberOfClusters();
+  auto geom = o2::its::GeometryTGeo::Instance();
+  auto prop = o2::base::Propagator::Instance();
+  float bz = prop->getNominalBz();
+  o2::track::TrackPar refLin{track};
+
+  for (int iCl = 0; iCl < nCl; iCl++) { // clusters are stored from outer to inner layers
+    const auto& cls = mITSClustersArray[itsClRefs[trkITS.getClusterEntry(iCl)]];
+    auto alpha = geom->getSensorRefAlpha(cls.getSensorID());
+    if (!(params.useStableRef ? track.rotate(alpha, refLin, bz) : track.rotate(alpha)) ||
+        !prop->propagateTo(track, params.useStableRef ? &refLin : nullptr, cls.getX(), true)) {
+      LOGP(debug, "refitITStrack failed on propagation to cl#{}, alpha={}, x={} | {}", iCl, alpha, cls.getX(), track.asString());
+      return false;
+    }
+    if (!track.update(cls)) {
+      LOGP(debug, "refitITStrack failed on update with cl#{}, | {}", iCl, track.asString());
+      return false;
+    }
+  }
+  return true;
+}
+
+void CheckResidSpec::endOfStream(EndOfStreamContext& ec)
+{
+  mDBGOut.reset();
+}
+
+void CheckResidSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+{
+  if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
+    return;
+  }
+  /*
+  if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
+    return;
+  }
+  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
+    return;
+  }
+  */
+  if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
+    LOG(info) << "Imposing new MeanVertex: " << ((const o2::dataformats::MeanVertexObject*)obj)->asString();
+    mMeanVtx = *(const o2::dataformats::MeanVertexObject*)obj;
+    return;
+  }
+  if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
+    LOG(info) << "cluster dictionary updated";
+    mITSDict = (const o2::itsmft::TopologyDictionary*)obj;
+    return;
+  }
+}
+
+DataProcessorSpec getCheckResidSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC /*, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts*/)
+{
+  std::vector<OutputSpec> outputs;
+  auto dataRequest = std::make_shared<DataRequest>();
+  dataRequest->requestTracks(srcTracks, useMC);
+  dataRequest->requestClusters(srcClusters, useMC);
+  dataRequest->requestPrimaryVertices(useMC);
+  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
+                                                              true,                              // GRPECS=true
+                                                              true,                              // GRPLHCIF
+                                                              true,                              // GRPMagField
+                                                              true,                              // askMatLUT
+                                                              o2::base::GRPGeomRequest::Aligned, // geometry
+                                                              dataRequest->inputs,
+                                                              true);
+  dataRequest->inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
+  Options opts{
+    {"nthreads", VariantType::Int, 1, {"number of threads"}},
+  };
+  //  o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
+  //  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+
+  return DataProcessorSpec{
+    "check-resid",
+    dataRequest->inputs,
+    outputs,
+    AlgorithmSpec{adaptFromTask<CheckResidSpec>(dataRequest, ggRequest, srcTracks, useMC /*, sclOpts*/)},
+    opts};
+}
+
+} // namespace o2::checkresid
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResidConfig.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidConfig.cxx
new file mode 100644
index 0000000000000..a754d1196017f
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidConfig.cxx
@@ -0,0 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GlobalTrackingStudy/CheckResidConfig.h"
+
+O2ParamImpl(o2::checkresid::CheckResidConfig);
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h b/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
index 6075429b0b16e..416820fc9aebb 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
+++ b/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
@@ -43,4 +43,10 @@
 #pragma link C++ class o2::trackstudy::ITSHitInfo + ;
 #pragma link C++ class std::vector < o2::trackstudy::ITSHitInfo> + ;
 
+#pragma link C++ class o2::checkresid::Point + ;
+#pragma link C++ class std::vector < o2::checkresid::Point> + ;
+#pragma link C++ class o2::checkresid::Track + ;
+#pragma link C++ class o2::checkresid::CheckResidConfig + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::checkresid::CheckResidConfig> + ;
+
 #endif
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
new file mode 100644
index 0000000000000..b8230b59405d8
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
@@ -0,0 +1,78 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "GlobalTrackingStudy/CheckResid.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/CompletionPolicy.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/CompletionPolicyHelpers.h"
+#include "Framework/CallbacksPolicy.h"
+#include "DetectorsBase/DPLWorkflowUtils.h"
+#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCWorkflow/TPCScalerSpec.h"
+
+using namespace o2::framework;
+using GID = o2::dataformats::GlobalTrackID;
+using DetID = o2::detectors::DetID;
+
+// ------------------------------------------------------------------
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
+{
+  o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  // option allowing to set parameters
+  std::vector<o2::framework::ConfigParamSpec> options{
+    {"enable-mc", o2::framework::VariantType::Bool, false, {"enable MC propagation"}},
+    {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of track sources to use"}},
+    {"cluster-sources", VariantType::String, "ITS", {"comma-separated list of cluster sources to use"}},
+    {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  //  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::raw::HBFUtilsInitializer::addConfigOption(options);
+  std::swap(workflowOptions, options);
+}
+
+// ------------------------------------------------------------------
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
+{
+  WorkflowSpec specs;
+
+  GID::mask_t allowedSourcesTrc = GID::getSourcesMask("ITS,TPC,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
+  GID::mask_t allowedSourcesClus = GID::getSourcesMask("ITS");
+
+  // Update the (declared) parameters if changed from the command line
+  o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
+  //  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto useMC = configcontext.options().get<bool>("enable-mc");
+
+  GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
+  GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(configcontext.options().get<std::string>("cluster-sources"));
+  o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC);
+  o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); // P-vertex is always needed
+
+  specs.emplace_back(o2::checkresid::getCheckResidSpec(srcTrc, srcCls, useMC));
+
+  // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
+  o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
+
+  return std::move(specs);
+}

From 93ff0dcf60e8bd709de653fc354dc5cd05cf760c Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Tue, 9 Dec 2025 22:41:25 +0100
Subject: [PATCH 1115/1764] ALICE3-TRK: adjusted VD segmentation taking into
 account gaps between adjacent layers (#14903)

---
 Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index 172d993be7283..a5a60422f77eb 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -49,8 +49,9 @@ namespace layer
 constexpr double pitchX{10 * mu};                                                                                                                        // pitch of the row
 constexpr double pitchZ{10 * mu};                                                                                                                        // pitch of the column
 constexpr double totalThickness{silicon::thickness + metalstack::thickness};                                                                             // total thickness of the chip
+constexpr std::array<double, nLayers> gaps{1.63 * mm, 1.2 * mm, 1.2 * mm};                                                                               // gaps between two consecutive petals
 constexpr std::array<double, nLayers> radii{0.5 * cm, 1.2 * cm, 2.5 * cm};                                                                               // radius of layer in cm
-constexpr std::array<double, nLayers> width{radii[0] * 2 * M_PI / 4, radii[1] * 2 * M_PI / 4, radii[2] * 2 * M_PI / 4};                                  // width of the quarter of layer in cm
+constexpr std::array<double, nLayers> width{radii[0] * 2 * M_PI / 4 - gaps[0], radii[1] * 2 * M_PI / 4 - gaps[1], radii[2] * 2 * M_PI / 4 - gaps[2]};    // width of the quarter of layer in cm
 constexpr double length{50 * cm};                                                                                                                        // length of the layer
 constexpr int nCols{static_cast<int>(length / pitchZ)};                                                                                                  // number of columns in the chip
 constexpr std::array<int, nLayers> nRows{static_cast<int>(width[0] / pitchX), static_cast<int>(width[1] / pitchX), static_cast<int>(width[2] / pitchX)}; // number of rows in the chip. For the moment is different for each layer since a siner segmentation in repetitive units is stil to be implemented

From 82a55b7f67dce4512a3a39bb361046a468d377a8 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 4 Dec 2025 11:35:58 +0100
Subject: [PATCH 1116/1764] DPL: refactor ccdb-fetcher service devic injection

---
 Framework/Core/src/WorkflowHelpers.cxx | 154 ++++++++++---------------
 1 file changed, 61 insertions(+), 93 deletions(-)

diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 61443f5f71616..034524ff0af8e 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -488,116 +488,84 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     extraSpecs.push_back(timePipeline(aodReader, ctx.options().get<int64_t>("readers")));
   }
 
-  ConcreteDataMatcher dstf{"FLP", "DISTSUBTIMEFRAME", 0xccdb};
-  if (ccdbBackend.outputs.empty() == false) {
-    ccdbBackend.outputs.push_back(OutputSpec{"CTP", "OrbitReset", 0});
-    InputSpec matcher{"dstf", "FLP", "DISTSUBTIMEFRAME", 0xccdb};
-    bool providesDISTSTF = false;
-    // Check if any of the provided outputs is a DISTSTF
-    // Check if any of the requested inputs is for a 0xccdb message
-    for (auto& dp : workflow) {
-      for (auto& output : dp.outputs) {
-        if (DataSpecUtils::match(matcher, output)) {
-          providesDISTSTF = true;
-          dstf = DataSpecUtils::asConcreteDataMatcher(output);
-          break;
-        }
-      }
-      if (providesDISTSTF) {
-        break;
-      }
+  // ConcreteDataMatcher dstf{"FLP", "DISTSUBTIMEFRAME", 0xccdb};
+  InputSpec matcher{"dstf", "FLP", "DISTSUBTIMEFRAME", 0xccdb};
+  auto& dstf = std::get<ConcreteDataMatcher>(matcher.matcher);
+  // Check if any of the provided outputs is a DISTSTF
+  // Check if any of the requested inputs is for a 0xccdb message
+  bool providesDISTSTF = std::any_of(workflow.begin(), workflow.end(),
+                                     [&matcher](auto const& dp) {
+                                       return std::any_of(dp.outputs.begin(), dp.outputs.end(), [&matcher](auto const& output){
+                                         return DataSpecUtils::match(matcher, output);
+                                       });
+                                     });
+
+  // If there is no CCDB requested, but we still ask for a FLP/DISTSUBTIMEFRAME/0xccdb
+  // we add to the first data processor which has no inputs (apart from
+  // enumerations / timers) the responsibility to provide the DISTSUBTIMEFRAME
+  bool requiresDISTSUBTIMEFRAME = std::any_of(workflow.begin(), workflow.end(),
+                                                [&dstf](auto const& dp) {
+                                                return std::any_of(dp.inputs.begin(), dp.inputs.end(), [&dstf](auto const& input){
+                                                  return DataSpecUtils::match(input, dstf);
+                                                });
+                                              });
+
+  // We find the first device which has either just enumerations or
+  // just timers, and we will add the DISTSUBTIMEFRAME to it.
+  // Notice how we do so in a stable manner by sorting the devices
+  // by name.
+  int enumCandidate = -1;
+  int timerCandidate = -1;
+  for (auto wi = 0U; wi < workflow.size(); ++wi) {
+    auto& dp = workflow[wi];
+    if (dp.inputs.size() != 1) {
+      continue;
+    }
+    auto lifetime = dp.inputs[0].lifetime;
+    if (lifetime == Lifetime::Enumeration && (enumCandidate == -1 || workflow[enumCandidate].name > dp.name)) {
+        enumCandidate = wi;
     }
-    // * If there are AOD outputs we use TFNumber as the CCDB clock
-    // * If one device provides a DISTSTF we use that as the CCDB clock
-    // * If one of the devices provides a timer we use that as the CCDB clock
-    // * If none of the above apply add to the first data processor
-    //   which has no inputs apart from enumerations the responsibility
-    //   to provide the DISTSUBTIMEFRAME.
+    if (lifetime == Lifetime::Timer && (timerCandidate == -1 || workflow[timerCandidate].name > dp.name)) {
+      timerCandidate = wi;
+    }
+  }
+
+  // * If there are AOD outputs we use TFNumber as the CCDB clock
+  // * If one device provides a DISTSTF we use that as the CCDB clock
+  // * If one of the devices provides a timer we use that as the CCDB clock
+  // * If none of the above apply, add to the first data processor
+  //   which has no inputs apart from enumerations the responsibility
+  //   to provide the DISTSUBTIMEFRAME.
+  if (ccdbBackend.outputs.empty() == false) {
     if (aodReader.outputs.empty() == false) {
+      // fetcher clock follows AOD source (TFNumber)
       ccdbBackend.inputs.push_back(InputSpec{"tfn", "TFN", "TFNumber"});
     } else if (providesDISTSTF) {
+      // fetcher clock follows DSTF/ccdb source (DISTSUBTIMEFRAME)
       ccdbBackend.inputs.push_back(InputSpec{"tfn", dstf, Lifetime::Timeframe});
     } else {
-      // We find the first device which has either just enumerations or
-      // just timers, and we add the DISTSUBTIMEFRAME to it.
-      // Notice how we do so in a stable manner by sorting the devices
-      // by name.
-      int enumCandidate = -1;
-      int timerCandidate = -1;
-      for (size_t wi = 0; wi < workflow.size(); wi++) {
-        auto& dp = workflow[wi];
-        if (dp.inputs.size() != 1) {
-          continue;
-        }
-        auto lifetime = dp.inputs[0].lifetime;
-        if (lifetime == Lifetime::Enumeration && (enumCandidate == -1 || workflow[enumCandidate].name > dp.name)) {
-          enumCandidate = wi;
-        }
-        if (lifetime == Lifetime::Timer && (timerCandidate == -1 || workflow[timerCandidate].name > dp.name)) {
-          timerCandidate = wi;
-        }
-      }
       if (enumCandidate != -1) {
-        auto& dp = workflow[enumCandidate];
-        DataSpecUtils::updateOutputList(dp.outputs, OutputSpec{{"ccdb-diststf"}, dstf, Lifetime::Timeframe});
+        // add DSTF/ccdb source to the enumeration-driven source explicitly
+        // fetcher clock is provided by enumeration-driven source (DISTSUBTIMEFRAME)
+        DataSpecUtils::updateOutputList(workflow[enumCandidate].outputs, OutputSpec{{"ccdb-diststf"}, dstf, Lifetime::Timeframe});
         ccdbBackend.inputs.push_back(InputSpec{"tfn", dstf, Lifetime::Timeframe});
       } else if (timerCandidate != -1) {
-        auto& dp = workflow[timerCandidate];
-        dstf = DataSpecUtils::asConcreteDataMatcher(dp.outputs[0]);
-        ccdbBackend.inputs.push_back(InputSpec{{"tfn"}, dstf, Lifetime::Timeframe});
+        // fetcher clock is proived by timer source
+        auto timer_dstf = DataSpecUtils::asConcreteDataMatcher(workflow[timerCandidate].outputs[0]);
+        ccdbBackend.inputs.push_back(InputSpec{"tfn", timer_dstf, Lifetime::Timeframe});
       }
     }
 
+    ccdbBackend.outputs.push_back(OutputSpec{"CTP", "OrbitReset", 0});
     // Load the CCDB backend from the plugin
     ccdbBackend.algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "CCDBFetcherPlugin", ctx);
     extraSpecs.push_back(ccdbBackend);
-  } else {
-    // If there is no CCDB requested, but we still ask for a FLP/DISTSUBTIMEFRAME/0xccdb
-    // we add to the first data processor which has no inputs (apart from
-    // enumerations / timers) the responsibility to provide the DISTSUBTIMEFRAME
-    bool requiresDISTSUBTIMEFRAME = false;
-    for (auto& dp : workflow) {
-      for (auto& input : dp.inputs) {
-        if (DataSpecUtils::match(input, dstf)) {
-          requiresDISTSUBTIMEFRAME = true;
-          break;
-        }
-      }
-    }
-    if (requiresDISTSUBTIMEFRAME) {
-      // We find the first device which has either just enumerations or
-      // just timers, and we add the DISTSUBTIMEFRAME to it.
-      // Notice how we do so in a stable manner by sorting the devices
-      // by name.
-      int enumCandidate = -1;
-      int timerCandidate = -1;
-      for (size_t wi = 0; wi < workflow.size(); wi++) {
-        auto& dp = workflow[wi];
-        if (dp.inputs.size() != 1) {
-          continue;
-        }
-        auto lifetime = dp.inputs[0].lifetime;
-        if (lifetime == Lifetime::Enumeration && (enumCandidate == -1 || workflow[enumCandidate].name > dp.name)) {
-          enumCandidate = wi;
-        }
-        if (lifetime == Lifetime::Timer && (timerCandidate == -1 || workflow[timerCandidate].name > dp.name)) {
-          timerCandidate = wi;
-        }
-      }
-      if (enumCandidate != -1) {
-        auto& dp = workflow[enumCandidate];
-        DataSpecUtils::updateOutputList(dp.outputs, OutputSpec{{"ccdb-diststf"}, dstf, Lifetime::Timeframe});
-        ccdbBackend.inputs.push_back(InputSpec{"tfn", dstf, Lifetime::Timeframe});
-      } else if (timerCandidate != -1) {
-        auto& dp = workflow[timerCandidate];
-        dstf = DataSpecUtils::asConcreteDataMatcher(dp.outputs[0]);
-        ccdbBackend.inputs.push_back(InputSpec{{"tfn"}, dstf, Lifetime::Timeframe});
-      }
-    }
+  } else if (requiresDISTSUBTIMEFRAME && enumCandidate != -1) {
+    // add DSTF/ccdb source to the enumeration-driven source explicitly if it is required in the workflow
+    DataSpecUtils::updateOutputList(workflow[enumCandidate].outputs, OutputSpec{{"ccdb-diststf"}, dstf, Lifetime::Timeframe});
   }
 
-  // add the Analysys CCDB backend which reads CCDB objects using a provided
-  // table
+  // add the Analysys CCDB backend which reads CCDB objects using a provided table
   if (analysisCCDBBackend.outputs.empty() == false) {
     // add normal reader
     auto&& algo = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);

From df0e932eed2d5821b3e8d21aa2ba815ff06b272b Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 8 Dec 2025 10:14:57 +0100
Subject: [PATCH 1117/1764] remove commented code

---
 Framework/Core/src/WorkflowHelpers.cxx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 034524ff0af8e..8d273b2f33273 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -488,7 +488,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     extraSpecs.push_back(timePipeline(aodReader, ctx.options().get<int64_t>("readers")));
   }
 
-  // ConcreteDataMatcher dstf{"FLP", "DISTSUBTIMEFRAME", 0xccdb};
   InputSpec matcher{"dstf", "FLP", "DISTSUBTIMEFRAME", 0xccdb};
   auto& dstf = std::get<ConcreteDataMatcher>(matcher.matcher);
   // Check if any of the provided outputs is a DISTSTF

From 7547f2843760f943f5eb09c0a1e570fce26e04d7 Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Mon, 8 Dec 2025 09:21:45 +0000
Subject: [PATCH 1118/1764] Please consider the following formatting changes

---
 Framework/Core/src/WorkflowHelpers.cxx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 8d273b2f33273..17f6c9eb7ddb6 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -494,7 +494,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   // Check if any of the requested inputs is for a 0xccdb message
   bool providesDISTSTF = std::any_of(workflow.begin(), workflow.end(),
                                      [&matcher](auto const& dp) {
-                                       return std::any_of(dp.outputs.begin(), dp.outputs.end(), [&matcher](auto const& output){
+                                       return std::any_of(dp.outputs.begin(), dp.outputs.end(), [&matcher](auto const& output) {
                                          return DataSpecUtils::match(matcher, output);
                                        });
                                      });
@@ -503,8 +503,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   // we add to the first data processor which has no inputs (apart from
   // enumerations / timers) the responsibility to provide the DISTSUBTIMEFRAME
   bool requiresDISTSUBTIMEFRAME = std::any_of(workflow.begin(), workflow.end(),
-                                                [&dstf](auto const& dp) {
-                                                return std::any_of(dp.inputs.begin(), dp.inputs.end(), [&dstf](auto const& input){
+                                              [&dstf](auto const& dp) {
+                                                return std::any_of(dp.inputs.begin(), dp.inputs.end(), [&dstf](auto const& input) {
                                                   return DataSpecUtils::match(input, dstf);
                                                 });
                                               });
@@ -522,7 +522,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     }
     auto lifetime = dp.inputs[0].lifetime;
     if (lifetime == Lifetime::Enumeration && (enumCandidate == -1 || workflow[enumCandidate].name > dp.name)) {
-        enumCandidate = wi;
+      enumCandidate = wi;
     }
     if (lifetime == Lifetime::Timer && (timerCandidate == -1 || workflow[timerCandidate].name > dp.name)) {
       timerCandidate = wi;

From 7ffc8976438775c755c4cd2af90591b73c1341f7 Mon Sep 17 00:00:00 2001
From: Martin Eide <43970264+mrtineide@users.noreply.github.com>
Date: Wed, 26 Nov 2025 16:07:17 +0100
Subject: [PATCH 1119/1764] Use new User Agent in CCDB

---
 CCDB/src/CcdbApi.cxx | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index 90776d6972e2c..f083d97b533df 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -40,13 +40,13 @@
 #include <algorithm>
 #include <filesystem>
 #include <boost/algorithm/string.hpp>
-#include <boost/asio/ip/host_name.hpp>
 #include <iostream>
 #include <mutex>
 #include <boost/interprocess/sync/named_semaphore.hpp>
 #include <regex>
 #include <cstdio>
 #include <string>
+#include <TAlienUserAgent.h>
 #include <unordered_set>
 #include "rapidjson/document.h"
 #include "rapidjson/writer.h"
@@ -117,13 +117,7 @@ CcdbApi::~CcdbApi()
 
 void CcdbApi::setUniqueAgentID()
 {
-  std::string host = boost::asio::ip::host_name();
-  char const* jobID = getenv("ALIEN_PROC_ID");
-  if (jobID) {
-    mUniqueAgentID = fmt::format("{}-{}-{}-{}", host, getCurrentTimestamp() / 1000, o2::utils::Str::getRandomString(6), jobID);
-  } else {
-    mUniqueAgentID = fmt::format("{}-{}-{}", host, getCurrentTimestamp() / 1000, o2::utils::Str::getRandomString(6));
-  }
+  mUniqueAgentID = TAlienUserAgent::BasedOnEnvironment().ToString();
 }
 
 bool CcdbApi::checkAlienToken()

From cb613568bf8594e0748e48f4fe4bf564ae959359 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Wed, 10 Dec 2025 09:30:10 +0100
Subject: [PATCH 1120/1764] Several bug fixes in PHOS calibrator

* avoid integer overflow
* initialize variables
* fix other evident logic bugs
* check before talking to bitset

Hopefully fixes/avoids a Exception while running: bitset::test: __position (which is 18446744073709548060) >= _Nb (which is 14337)
observed in the ARM CI.
---
 .../include/PHOSCalibWorkflow/TurnOnHistos.h     |  6 +++---
 .../PHOS/calib/src/PHOSRunbyrunCalibrator.cxx    |  6 +++---
 .../PHOS/calib/src/PHOSTurnonCalibrator.cxx      | 16 +++++++++-------
 3 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h b/Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h
index 4457da2e100ad..046b8b3c39622 100644
--- a/Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h
+++ b/Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h
@@ -21,7 +21,7 @@
 
 #include <bitset>
 #include <array>
-#include "TObject.h"
+#include "TObject.h" // # RTYpe ?
 
 namespace o2
 {
@@ -76,7 +76,7 @@ class TurnOnHistos
   /// \param bitset with channels fired in event
   void fillFiredMap(const std::bitset<NCHANNELS>& bs)
   {
-    for (short i = NCHANNELS; --i;) {
+    for (size_t i = 0; i < NCHANNELS; ++i) {
       if (bs[i]) {
         mGoodMap[i]++;
       }
@@ -87,7 +87,7 @@ class TurnOnHistos
   /// \param bitset with channels fired in event
   void fillNoisyMap(const std::bitset<NCHANNELS>& bs)
   {
-    for (short i = NCHANNELS; --i;) {
+    for (size_t i = 0; i < NCHANNELS; ++i) {
       if (bs[i]) {
         mNoisyMap[i]++;
       }
diff --git a/Detectors/PHOS/calib/src/PHOSRunbyrunCalibrator.cxx b/Detectors/PHOS/calib/src/PHOSRunbyrunCalibrator.cxx
index baa20307b0fbd..63e51f06c0e64 100644
--- a/Detectors/PHOS/calib/src/PHOSRunbyrunCalibrator.cxx
+++ b/Detectors/PHOS/calib/src/PHOSRunbyrunCalibrator.cxx
@@ -127,11 +127,11 @@ bool PHOSRunbyrunSlot::checkCluster(const Cluster& clu)
     return false;
   }
   // First check BadMap
-  float posX, posZ;
+  float posX{0}, posZ{0};
   clu.getLocalPosition(posX, posZ);
-  short absId;
+  short absId{0};
   Geometry::relPosToAbsId(clu.module(), posX, posZ, absId);
-  if (!mBadMap->isChannelGood(absId)) {
+  if (mBadMap && absId >= 0 && !mBadMap->isChannelGood(absId)) {
     return false;
   }
   return (clu.getEnergy() > 0.3 && clu.getMultiplicity() > 1);
diff --git a/Detectors/PHOS/calib/src/PHOSTurnonCalibrator.cxx b/Detectors/PHOS/calib/src/PHOSTurnonCalibrator.cxx
index 5413b20f491b8..432090c280ff8 100644
--- a/Detectors/PHOS/calib/src/PHOSTurnonCalibrator.cxx
+++ b/Detectors/PHOS/calib/src/PHOSTurnonCalibrator.cxx
@@ -36,7 +36,7 @@ PHOSTurnonSlot::PHOSTurnonSlot(bool useCCDB) : mUseCCDB(useCCDB)
 PHOSTurnonSlot::PHOSTurnonSlot(const PHOSTurnonSlot& other)
 {
   mUseCCDB = other.mUseCCDB;
-  mRunStartTime = other.mUseCCDB;
+  mRunStartTime = other.mRunStartTime;
   mFiredTiles.reset();
   mNoisyTiles.reset();
   mTurnOnHistos = std::make_unique<TurnOnHistos>();
@@ -91,15 +91,17 @@ void PHOSTurnonSlot::scanClusters(const gsl::span<const Cell>& cells, const Trig
   for (int i = firstCellInEvent; i < lastCellInEvent; i++) {
     const Cell& c = cells[i];
     if (c.getTRU()) {
-      mNoisyTiles.set(c.getTRUId() - Geometry::getTotalNCells() - 1);
+      auto channel = c.getTRUId() - Geometry::getTotalNCells() - 1;
+      if (channel >= 0) {
+        mNoisyTiles.set(channel);
+      }
     }
   }
 
   // Copy to have good and noisy map
   mFiredTiles.reset();
-  char mod;
-  float x, z;
-  short ddl;
+  float x{0}, z{0};
+  short ddl{0};
   int firstCluInEvent = clutr.getFirstEntry();
   int lastCluInEvent = firstCluInEvent + clutr.getNumberOfObjects();
   for (int i = firstCluInEvent; i < lastCluInEvent; i++) {
@@ -107,7 +109,7 @@ void PHOSTurnonSlot::scanClusters(const gsl::span<const Cell>& cells, const Trig
     if (clu.getEnergy() < 1.e-4) {
       continue;
     }
-    mod = clu.module();
+    char mod = clu.module();
     clu.getLocalPosition(x, z);
     // TODO: do we need separate 2x2 and 4x4 spectra? Switch?
     //  short truId2x2 = Geometry::relPosToTruId(mod, x, z, 0);
@@ -123,7 +125,7 @@ void PHOSTurnonSlot::scanClusters(const gsl::span<const Cell>& cells, const Trig
   // Fill final good and noisy maps
   mTurnOnHistos->fillFiredMap(mFiredTiles);
   mNoisyTiles ^= mFiredTiles;
-  mTurnOnHistos->fillNoisyMap(mFiredTiles);
+  mTurnOnHistos->fillNoisyMap(mNoisyTiles);
 }
 //==============================================
 

From d7257f81749184b56564cbf373518e9cac37ec2e Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Wed, 10 Dec 2025 20:37:02 +0100
Subject: [PATCH 1121/1764] fixup

---
 Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h b/Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h
index 046b8b3c39622..0814fe0da4547 100644
--- a/Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h
+++ b/Detectors/PHOS/calib/include/PHOSCalibWorkflow/TurnOnHistos.h
@@ -21,7 +21,7 @@
 
 #include <bitset>
 #include <array>
-#include "TObject.h" // # RTYpe ?
+#include "TObject.h"
 
 namespace o2
 {

From fb08487608f0276c1b71dd848deeb86dec9230bb Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 11 Dec 2025 13:53:33 +0100
Subject: [PATCH 1122/1764] Demote warning to debug level

---
 Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
index 34643928db344..691d731503b88 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
@@ -404,7 +404,7 @@ bool CheckResidSpec::processITSTrack(const o2::its::TrackITS& iTrack, const o2::
           innerDone = true;
         }
       } else {
-        LOGP(warn, "No cluster on lr {}", i);
+        LOGP(debug, "No cluster on lr {}", i);
       }
     }
   }

From 1c3bfa0d941dcdf6983173280d33cb1c2ad9cef4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 3 Dec 2025 21:06:04 +0100
Subject: [PATCH 1123/1764] GPU QA: Add pad row vs occuapncy histogram

---
 GPU/GPUTracking/qa/GPUQA.cxx | 68 +++++++++++++++++++++++-------------
 GPU/GPUTracking/qa/GPUQA.h   |  6 ++--
 2 files changed, 47 insertions(+), 27 deletions(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 689dc20cb1606..28b603f77e2ff 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -152,6 +152,7 @@ static constexpr float PT_MIN_CLUST = 0.01;
 static constexpr float PT_MAX = 20;
 static constexpr float ETA_MAX = 1.5;
 static constexpr float ETA_MAX2 = 0.9;
+static constexpr int32_t PADROW_CHECK_MINCLS = 50;
 
 static constexpr bool CLUST_HIST_INT_SUM = false;
 
@@ -525,9 +526,10 @@ int32_t GPUQA::InitQACreateHistograms()
       createHist(mClusters[i], name, name, AXIS_BINS[4], binsPt.get());
     }
 
-    createHist(mPadRow[0], "padrow0", "padrow0", GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
-    createHist(mPadRow[1], "padrow1", "padrow1", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
-    createHist(mPadRow[2], "padrow2", "padrow2", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
+    createHist(mPadRow[0], "padrow0", "padrow0", GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS, GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[1], "padrow1", "padrow1", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[2], "padrow2", "padrow2", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[3], "padrow3", "padrow3", 100.f, 0, 300000, GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS);
   }
 
   if (mQATasks & taskTrackStatistics) {
@@ -968,7 +970,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             nClusters++;
             uint32_t hitId = mTracking->mIOPtrs.mergedTrackHits[track.FirstClusterRef() + k].num;
             if (hitId >= GetNMCLabels()) {
-              GPUError("Invalid hit id %u > %d (nClusters %d)", hitId, GetNMCLabels(), mTracking->mIOPtrs.clustersNative ? mTracking->mIOPtrs.clustersNative->nClustersTotal : 0);
+              GPUError("Invalid hit id %u > %d (nClusters %d)", hitId, GetNMCLabels(), clNative ? clNative->nClustersTotal : 0);
               throw std::runtime_error("qa error");
             }
             acc.addLabel(hitId);
@@ -1069,7 +1071,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
     }
-    if ((mQATasks & taskClusterAttach)) {
+    if ((mQATasks & taskClusterAttach) && !tracksExternal) {
       std::vector<uint8_t> lowestPadRow(mTracking->mIOPtrs.nMergedTracks);
       // fill cluster adjacent status
       if (mTracking->mIOPtrs.mergedTrackHitAttachment) {
@@ -1096,12 +1098,12 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           }
         }
       }
-      if (mTracking->mIOPtrs.nMergedTracks && mTracking->mIOPtrs.clustersNative) {
+      if (mTracking->mIOPtrs.nMergedTracks && clNative) {
         std::fill(lowestPadRow.begin(), lowestPadRow.end(), 255);
         for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
           for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
-            for (uint32_t iCl = 0; iCl < mTracking->mIOPtrs.clustersNative->nClusters[iSector][iRow]; iCl++) {
-              int32_t i = mTracking->mIOPtrs.clustersNative->clusterOffset[iSector][iRow] + iCl;
+            for (uint32_t iCl = 0; iCl < clNative->nClusters[iSector][iRow]; iCl++) {
+              int32_t i = clNative->clusterOffset[iSector][iRow] + iCl;
               for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
                 uint32_t trackId = GetMCTrackObj(mTrackMCLabelsReverse, GetMCLabel(i, j));
                 if (trackId < lowestPadRow.size() && lowestPadRow[trackId] > iRow) {
@@ -1113,12 +1115,21 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
         for (uint32_t i = 0; i < mTracking->mIOPtrs.nMergedTracks; i++) {
           const auto& trk = mTracking->mIOPtrs.mergedTracks[i];
-          if (trk.OK() && lowestPadRow[i] != 255 && trk.NClustersFitted() > 70 && CAMath::Abs(trk.GetParam().GetQPt()) < 0.5) {
-            int32_t lowestRow = CAMath::Min(mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef()].row, mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef() + trk.NClusters() - 1].row);
+          if (trk.OK() && lowestPadRow[i] != 255 && trk.NClustersFitted() >= PADROW_CHECK_MINCLS && CAMath::Abs(trk.GetParam().GetQPt()) < 1.0) {
+            const auto& lowestCl = mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef()].row < mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef() + trk.NClusters() - 1].row ? mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef()] : mTracking->mIOPtrs.mergedTrackHits[trk.FirstClusterRef() + trk.NClusters() - 1];
+            const int32_t lowestRow = lowestCl.row;
             mPadRow[0]->Fill(lowestPadRow[i], lowestRow, 1.f);
             mPadRow[1]->Fill(CAMath::ATan2(trk.GetParam().GetY(), trk.GetParam().GetX()), lowestRow, 1.f);
-            if (lowestPadRow[i] == 0 && lowestRow != 0) {
-              mPadRow[2]->Fill(CAMath::ATan2(trk.GetParam().GetY(), trk.GetParam().GetX()), lowestRow, 1.f);
+            if (lowestPadRow[i] < 10 && lowestRow > lowestPadRow[i] + 3) {
+              const auto& cl = clNative->clustersLinear[lowestCl.num];
+              float x, y, z;
+              mTracking->GetTPCTransformHelper()->Transform(lowestCl.sector, lowestCl.row, cl.getPad(), cl.getTime(), x, y, z, trk.GetParam().GetTOffset());
+              float phi = CAMath::ATan2(y, x);
+              mPadRow[2]->Fill(phi, lowestRow, 1.f);
+              if (CAMath::Abs(phi) < 0.15) {
+                const float time = cl.getTime();
+                mPadRow[3]->Fill(mTracking->GetParam().GetUnscaledMult(time), lowestRow, 1.f);
+              }
             }
           }
         }
@@ -1485,7 +1496,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       }
     }
 
-    if (mQATasks & taskClusterAttach) {
+    if ((mQATasks & taskClusterAttach) && !tracksExternal) {
       // Fill cluster histograms
       for (uint32_t iTrk = 0; iTrk < nReconstructedTracks; iTrk++) {
         const GPUTPCGMMergedTrack& track = mTracking->mIOPtrs.mergedTracks[iTrk];
@@ -1715,7 +1726,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     GPUWarning("No MC information available, only running partial TPC QA!");
   } // mcAvail
 
-  if (mQATasks & taskTrackStatistics) {
+  if ((mQATasks & taskTrackStatistics) && !tracksExternal) {
     // Fill track statistic histograms
     std::vector<std::array<float, 3>> clusterAttachCounts;
     if (mcAvail) {
@@ -1815,8 +1826,8 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
   if (mQATasks & taskClusterCounts) {
     for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
       for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
-        for (uint32_t iCl = 0; iCl < mTracking->mIOPtrs.clustersNative->nClusters[iSector][iRow]; iCl++) {
-          uint32_t i = mTracking->mIOPtrs.clustersNative->clusterOffset[iSector][iRow] + iCl;
+        for (uint32_t iCl = 0; iCl < clNative->nClusters[iSector][iRow]; iCl++) {
+          uint32_t i = clNative->clusterOffset[iSector][iRow] + iCl;
           int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
           const auto& r = checkClusterState<true>(attach, &mClusterCounts);
 
@@ -1873,8 +1884,8 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           if (r.unattached) {
             mClusterCounts.nUnattached++;
           }
-          if (mTracking && mTracking->mIOPtrs.clustersNative) {
-            const auto& cl = mTracking->mIOPtrs.clustersNative->clustersLinear[i];
+          if (mTracking && clNative) {
+            const auto& cl = clNative->clustersLinear[i];
             mClRej[0]->Fill(cl.getPad() - GPUTPCGeometry::NPads(iRow) / 2 + 0.5, iRow, 1.f);
             if (!r.unattached && !r.protect) {
               mClRej[1]->Fill(cl.getPad() - GPUTPCGeometry::NPads(iRow) / 2 + 0.5, iRow, 1.f);
@@ -1895,7 +1906,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     GPUInfo("QA Time: Cluster Counts:\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
   }
 
-  if (mConfig.dumpToROOT) {
+  if (mConfig.dumpToROOT && !tracksExternal) {
     if (!clNative || !mTracking || !mTracking->mIOPtrs.mergedTrackHitAttachment || !mTracking->mIOPtrs.mergedTracks) {
       throw std::runtime_error("Cannot dump non o2::tpc::clusterNative clusters, need also hit attachmend and GPU tracks");
     }
@@ -2273,7 +2284,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mPClRejP = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPClRejP->Draw();
 
-      for (int32_t i = 0; i < 3; i++) {
+      for (int32_t i = 0; i < 4; i++) {
         snprintf(name, 2048, "cpadrow%d", i);
         mCPadRow[i] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
         mCPadRow[i]->cd();
@@ -2842,19 +2853,28 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
     }
 
-    for (int32_t i = 0; i < 3; i++) {
+    for (int32_t i = 0; i < 4; i++) {
       auto* e = mPadRow[i];
       if (tout && !mConfig.inputHistogramsOnly) {
         e->Write();
       }
       mPPadRow[i]->cd();
       e->SetOption("colz");
-      e->SetTitle(i == 2 ? "First Track Pad Row (row_{MC} = 0, row_{trk} > 0)" : "First Track Pad Row");
-      e->GetXaxis()->SetTitle(i ? "#Phi (sector)" : "First MC Pad Row");
+      std::string title = "First Track Pad Row (p_{T} > 1GeV, N_{Cl} #geq " + std::to_string(PADROW_CHECK_MINCLS);
+      if (i >= 2) {
+        title += ", row_{trk} > row_{MC} + 3, row_{MC} < 10";
+      }
+      if (i >= 3) {
+        title += ", #Phi_{Cl} < 0.15";
+      }
+      title += ")";
+
+      e->SetTitle(title.c_str());
+      e->GetXaxis()->SetTitle(i == 3 ? "Local Occupancy" : (i ? "#Phi_{Cl} (sector)" : "First MC Pad Row"));
       e->GetYaxis()->SetTitle("First Pad Row");
       e->Draw();
       mCPadRow[i]->cd();
-      static const constexpr char* PADROW_NAMES[3] = {"MC", "Phi", "Phi1"};
+      static const constexpr char* PADROW_NAMES[4] = {"MC", "Phi", "Phi1", "Occ"};
       mCPadRow[i]->Print(Form("%s/padRow%s.pdf", mConfig.plotsDir.c_str(), PADROW_NAMES[i]));
       if (mConfig.writeFileExt != "") {
         mCPadRow[i]->Print(Form("%s/padRow%s.%s", mConfig.plotsDir.c_str(), PADROW_NAMES[i], mConfig.writeFileExt.c_str()));
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 54d1ceed9d365..7303ed62a9562 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -323,9 +323,9 @@ class GPUQA
   TPad* mPClRej[3];
   TPad* mPClRejP;
 
-  TH2F* mPadRow[3];
-  TCanvas* mCPadRow[3];
-  TPad* mPPadRow[3];
+  TH2F* mPadRow[4];
+  TCanvas* mCPadRow[4];
+  TPad* mPPadRow[4];
 
   std::vector<TH2F*> mHistClusterCount;
 

From 215ac60fe27a46657b82fa2434923c28797c8d3d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 4 Dec 2025 12:55:58 +0100
Subject: [PATCH 1124/1764] GPU QA Standalone: By default write histograms to
 output root file in plots folder

---
 GPU/GPUTracking/Standalone/Benchmark/standalone.cxx | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index ca26f26d32612..857803d913372 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -197,6 +197,9 @@ int32_t ReadConfiguration(int argc, char** argv)
     printf("Can only produce QA pdf output when input files are specified!\n");
     return 1;
   }
+  if (configStandalone.QA.enableLocalOutput && !configStandalone.QA.inputHistogramsOnly && configStandalone.QA.output == "" && configStandalone.QA.plotsDir != "") {
+    configStandalone.QA.output = configStandalone.QA.plotsDir + "/output.root";
+  }
   if (configStandalone.QA.inputHistogramsOnly) {
     configStandalone.rundEdx = false;
     configStandalone.noEvents = true;

From 4b0f130b0f0b5387247a075075add83a4cb09a32 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 3 Dec 2025 21:13:34 +0100
Subject: [PATCH 1125/1764] GPU: Remove non-working MI100 serialization
 workaround and obsolete StuckProtection

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |  2 --
 .../Base/opencl/GPUReconstructionOCL.cxx      | 21 -------------------
 .../Base/opencl/GPUReconstructionOCL.h        |  1 -
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 --
 GPU/GPUTracking/Global/GPUChain.h             |  2 --
 .../Global/GPUChainTrackingSectorTracker.cxx  |  3 ---
 prodtests/full-system-test/dpl-workflow.sh    |  2 --
 7 files changed, 33 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index a78a482db4e7a..d621d45fcd92b 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -88,8 +88,6 @@ class GPUReconstructionCPU : public GPUReconstructionProcessing::KernelInterface
   int32_t ExitDevice() override;
   int32_t GetThread();
 
-  virtual int32_t DoStuckProtection(int32_t stream, deviceEvent event) { return 0; }
-
   // Pointers to tracker classes
   GPUProcessorProcessors mProcShadow; // Host copy of tracker objects that will be used on the GPU
   GPUConstantMem*& mProcessorsShadow = mProcShadow.mProcessorsProc;
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
index 271fe494860cd..6954cfb3d6211 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.cxx
@@ -470,27 +470,6 @@ void GPUReconstructionOCL::ReleaseEvent(deviceEvent ev) { GPUChkErr(clReleaseEve
 
 void GPUReconstructionOCL::RecordMarker(deviceEvent* ev, int32_t stream) { GPUChkErr(clEnqueueMarkerWithWaitList(mInternals->command_queue[stream], 0, nullptr, ev->getEventList<cl_event>())); }
 
-int32_t GPUReconstructionOCL::DoStuckProtection(int32_t stream, deviceEvent event)
-{
-  if (GetProcessingSettings().stuckProtection) {
-    cl_int tmp = 0;
-    for (int32_t i = 0; i <= GetProcessingSettings().stuckProtection / 50; i++) {
-      usleep(50);
-      clGetEventInfo(event.get<cl_event>(), CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(tmp), &tmp, nullptr);
-      if (tmp == CL_COMPLETE) {
-        break;
-      }
-    }
-    if (tmp != CL_COMPLETE) {
-      mGPUStuck = 1;
-      GPUErrorReturn("GPU Stuck, future processing in this component is disabled, skipping event (GPU Event State %d)", (int32_t)tmp);
-    }
-  } else {
-    clFinish(mInternals->command_queue[stream]);
-  }
-  return 0;
-}
-
 void GPUReconstructionOCL::SynchronizeGPU()
 {
   for (int32_t i = 0; i < mNStreams; i++) {
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
index 958d5186bf41a..a52db1f2a737a 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCL.h
@@ -43,7 +43,6 @@ class GPUReconstructionOCL : public GPUReconstructionProcessing::KernelInterface
   virtual int32_t GPUChkErrInternal(const int64_t error, const char* file, int32_t line) const override;
 
   void SynchronizeGPU() override;
-  int32_t DoStuckProtection(int32_t stream, deviceEvent event) override;
   int32_t GPUDebug(const char* state = "UNKNOWN", int32_t stream = -1, bool force = false) override;
   void SynchronizeStream(int32_t stream) override;
   void SynchronizeEvents(deviceEvent* evList, int32_t nEvents = 1) override;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 5a075bf7f9a02..d70fac115eab7 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -301,7 +301,6 @@ BeginSubConfig(GPUSettingsProcessing, proc, configStandalone, "PROC", 0, "Proces
 AddOption(deviceNum, int32_t, -1, "gpuDevice", 0, "Set GPU device to use (-1: automatic, -2: for round-robin usage in timeslice-pipeline)")
 AddOption(gpuDeviceOnly, bool, false, "", 0, "Use only GPU as device (i.e. no CPU for OpenCL)")
 AddOption(globalInitMutex, bool, false, "", 0, "Use global mutex to synchronize initialization of multiple GPU instances")
-AddOption(stuckProtection, int32_t, 0, "", 0, "Timeout in us, When AMD GPU is stuck, just continue processing and skip tracking, do not crash or stall the chain")
 AddOption(trdNCandidates, int32_t, 3, "", 0, "Number of branching track candidates for single input track during propagation")
 AddOption(trdTrackModelO2, bool, false, "", 0, "Use O2 track model instead of GPU track model for TRD tracking")
 AddOption(debugLevel, int32_t, -1, "debug", 'd', "Set debug level (-2 = silent, -1 = autoselect (-2 for O2, 0 for standalone))")
@@ -383,7 +382,6 @@ AddOption(debugOnFailureMaxN, uint32_t, 1, "", 0, "Max number of times to run th
 AddOption(debugOnFailureMaxFiles, uint32_t, 0, "", 0, "Max number of files to have in the target folder")
 AddOption(debugOnFailureMaxSize, uint32_t, 0, "", 0, "Max size of existing dumps in the target folder in GB")
 AddOption(debugOnFailureDirectory, std::string, ".", "", 0, "Target folder for debug / dump")
-AddOption(amdMI100SerializationWorkaround, bool, false, "", 0, "Enable workaround that mitigates MI100 serialization bug")
 AddOption(memoryStat, bool, false, "", 0, "Print memory statistics")
 AddVariable(eventDisplay, o2::gpu::GPUDisplayFrontendInterface*, nullptr)
 AddSubConfig(GPUSettingsProcessingRTC, rtc)
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index 9ce3da1092e83..6831fbd15080a 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -224,8 +224,6 @@ class GPUChain
 
   inline GPUChain* GetNextChainInQueue() { return mRec->GetNextChainInQueue(); }
 
-  virtual int32_t DoStuckProtection(int32_t stream, deviceEvent event) { return 0; }
-
   template <class T, class S, typename... Args>
   bool DoDebugAndDump(RecoStep step, uint32_t mask, T& processor, S T::*func, Args&&... args)
   {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 122eb709b4356..e2d68f10819fb 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -149,9 +149,6 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     GPUTPCTracker& trk = processors()->tpcTrackers[iSector];
     GPUTPCTracker& trkShadow = doGPU ? processorsShadow()->tpcTrackers[iSector] : trk;
     int32_t useStream = StreamForSector(iSector);
-    if (GetProcessingSettings().amdMI100SerializationWorkaround) {
-      SynchronizeStream(useStream); // TODO: Remove this workaround once fixed on MI100
-    }
 
     if (GetProcessingSettings().debugLevel >= 3) {
       GPUInfo("Creating Sector Data (Sector %d)", iSector);
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index ce5607d361cbe..754349c87eecc 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -284,8 +284,6 @@ if [[ $GPUTYPE == "HIP" ]]; then
   if [[ ${EPN_NODE_MI100:-} == "1" && ${DISABLE_MI100_SERIALIZATION:-0} != 1 ]]; then
     if [[ -n ${OPTIMIZED_PARALLEL_ASYNC:-} ]] || [[ $EPNSYNCMODE == 1 && ${FULL_MI100_SERIALIZATION:-0} == 1 ]]; then
       GPU_CONFIG_KEY+="GPU_proc.serializeGPU=3;"
-    elif [[ $EPNSYNCMODE == 1 ]]; then
-      GPU_CONFIG_KEY+="GPU_proc.amdMI100SerializationWorkaround=1;"
     fi
   fi
   #export HSA_TOOLS_LIB=/opt/rocm/lib/librocm-debug-agent.so.2

From 534219337bb9ccaebaca12b902bdac2a3fb513a2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 8 Dec 2025 09:32:03 +0100
Subject: [PATCH 1126/1764] GPU QA: Dump also text output to output folder

---
 GPU/GPUTracking/qa/GPUQA.cxx | 11 ++++++++++-
 GPU/GPUTracking/qa/GPUQA.h   |  2 ++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 28b603f77e2ff..3c176031dec08 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -3141,7 +3141,9 @@ void GPUQA::PrintClusterCount(int32_t mode, int32_t& num, const char* name, uint
     createHist(mHistClusterCount[num], name2, name, 1000, 0, mConfig.histMaxNClusters, 1000, 0, 100);
   } else if (mode == 0) {
     if (normalization && mConfig.enableLocalOutput) {
-      printf("\t%40s: %'12" PRIu64 " (%6.2f%%)\n", name, n, 100.f * n / normalization);
+      for (uint32_t i = 0; i < 1 + (mTextDump != nullptr); i++) {
+        fprintf(i ? mTextDump : stdout, "\t%40s: %'12" PRIu64 " (%6.2f%%)\n", name, n, 100.f * n / normalization);
+      }
     }
     if (mConfig.clusterRejectionHistograms) {
       float ratio = 100.f * n / std::max<uint64_t>(normalization, 1);
@@ -3153,6 +3155,9 @@ void GPUQA::PrintClusterCount(int32_t mode, int32_t& num, const char* name, uint
 
 int32_t GPUQA::DoClusterCounts(uint64_t* attachClusterCounts, int32_t mode)
 {
+  if (mConfig.enableLocalOutput && !mConfig.inputHistogramsOnly && mConfig.plotsDir != "") {
+    mTextDump = fopen((mConfig.plotsDir + "/clusterCounts.txt").c_str(), "w+");
+  }
   int32_t num = 0;
   if (mcPresent() && (mQATasks & taskClusterAttach) && attachClusterCounts) {
     for (int32_t i = 0; i < N_CLS_HIST; i++) { // TODO: Check that these counts are still printed correctly!
@@ -3191,6 +3196,10 @@ int32_t GPUQA::DoClusterCounts(uint64_t* attachClusterCounts, int32_t mode)
     PrintClusterCount(mode, num, "Correctly Attached all-trk normalized", mClusterCounts.nCorrectlyAttachedNormalized, mClusterCounts.nTotal);
     PrintClusterCount(mode, num, "Correctly Attached non-fake normalized", mClusterCounts.nCorrectlyAttachedNormalizedNonFake, mClusterCounts.nTotal);
   }
+  if (mTextDump) {
+    fclose(mTextDump);
+    mTextDump = nullptr;
+  }
   return num;
 }
 
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 7303ed62a9562..b42fa804c6212 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -62,6 +62,7 @@ class GPUQA
 #else
 
 #include "GPUTPCDef.h"
+#include <cstdio>
 #include <cmath>
 #include <vector>
 #include <memory>
@@ -365,6 +366,7 @@ class GPUQA
   int32_t mMCTrackMin = -1, mMCTrackMax = -1;
 
   const o2::tpc::ClusterNativeAccess* mClNative = nullptr;
+  FILE* mTextDump = nullptr;
 };
 
 inline bool GPUQA::SuppressTrack(int32_t iTrack) const { return (mConfig.matchMCLabels.size() && !mGoodTracks[mNEvents][iTrack]); }

From 7eb731a2da99bc377efdb2b5cd0c33a54fa49137 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 10 Dec 2025 19:16:24 +0100
Subject: [PATCH 1127/1764] GPU QA: Fix some task number inconsistencies

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx |   4 +-
 GPU/GPUTracking/qa/GPUQA.cxx                | 223 ++++++++++----------
 GPU/GPUTracking/qa/GPUQA.h                  |  16 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx        |   2 +-
 4 files changed, 131 insertions(+), 114 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 14d0e04eb4dd3..0e7d4bc4f436e 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -475,7 +475,7 @@ int32_t GPUChainTracking::ForceInitQA()
     qa.reset(new GPUQA(this));
   }
   if (!GetQA()->IsInitialized()) {
-    return GetQA()->InitQA();
+    return GetQA()->InitQA(GetProcessingSettings().runQA <= 0 ? -GetProcessingSettings().runQA : GPUQA::tasksAutomatic);
   }
   return 0;
 }
@@ -690,7 +690,7 @@ int32_t GPUChainTracking::RunChain()
   }
   const bool needQA = GPUQA::QAAvailable() && (GetProcessingSettings().runQA || (GetProcessingSettings().eventDisplay && (mIOPtrs.nMCInfosTPC || GetProcessingSettings().runMC)));
   if (needQA && GetQA()->IsInitialized() == false) {
-    if (GetQA()->InitQA(GetProcessingSettings().runQA ? -GetProcessingSettings().runQA : -1)) {
+    if (GetQA()->InitQA(GetProcessingSettings().runQA <= 0 ? -GetProcessingSettings().runQA : GPUQA::tasksAutomatic)) {
       return 1;
     }
   }
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 3c176031dec08..852ac5c1feefb 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -544,7 +544,8 @@ int32_t GPUQA::InitQACreateHistograms()
     createHist(mT0[0], "tracks_t0", "tracks_t0", (maxTime + 1) / 10, 0, maxTime);
     createHist(mT0[1], "tracks_t0_res", "tracks_t0_res", 1000, -100, 100);
     createHist(mClXY, "clXY", "clXY", 1000, -250, 250, 1000, -250, 250); // TODO: Pass name only once
-
+  }
+  if (mQATasks & taskClusterRejection) {
     const int padCount = GPUTPCGeometry::NPads(GPUCA_ROW_COUNT - 1);
     for (int32_t i = 0; i < 3; i++) {
       snprintf(name, 2048, "clrej_%d", i);
@@ -577,8 +578,8 @@ int32_t GPUQA::InitQACreateHistograms()
 
 int32_t GPUQA::loadHistograms(std::vector<TH1F>& i1, std::vector<TH2F>& i2, std::vector<TH1D>& i3, std::vector<TGraphAsymmErrors>& i4, int32_t tasks)
 {
-  if (tasks == -1) {
-    tasks = taskDefaultPostprocess;
+  if (tasks == tasksAutomatic) {
+    tasks = tasksDefaultPostprocess;
   }
   if (mQAInitialized && (!mHaveExternalHists || tasks != mQATasks)) {
     throw std::runtime_error("QA not initialized or initialized with different task array");
@@ -593,7 +594,7 @@ int32_t GPUQA::loadHistograms(std::vector<TH1F>& i1, std::vector<TH2F>& i2, std:
   mHistGraph_pos.clear();
   mHaveExternalHists = true;
   if (mConfig.noMC) {
-    tasks &= tasksNoQC;
+    tasks &= tasksAllNoQC;
   }
   mQATasks = tasks;
   if (InitQACreateHistograms()) {
@@ -806,8 +807,8 @@ int32_t GPUQA::InitQA(int32_t tasks)
   if (mQAInitialized) {
     throw std::runtime_error("QA already initialized");
   }
-  if (tasks == -1) {
-    tasks = taskDefault;
+  if (tasks == tasksAutomatic) {
+    tasks = tasksDefault;
   }
 
   mHist1D = new std::vector<TH1F>;
@@ -815,7 +816,7 @@ int32_t GPUQA::InitQA(int32_t tasks)
   mHist1Dd = new std::vector<TH1D>;
   mHistGraph = new std::vector<TGraphAsymmErrors>;
   if (mConfig.noMC) {
-    tasks &= tasksNoQC;
+    tasks &= tasksAllNoQC;
   }
   mQATasks = tasks;
 
@@ -1823,7 +1824,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
 
   uint32_t nCl = clNative ? clNative->nClustersTotal : mTracking->GetProcessors()->tpcMerger.NMaxClusters();
   mClusterCounts.nTotal += nCl;
-  if (mQATasks & taskClusterCounts) {
+  if (mQATasks & (taskClusterCounts | taskClusterRejection)) {
     for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
       for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
         for (uint32_t iCl = 0; iCl < clNative->nClusters[iSector][iRow]; iCl++) {
@@ -1831,64 +1832,68 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
           const auto& r = checkClusterState<true>(attach, &mClusterCounts);
 
-          if (mcAvail) {
-            float totalWeight = 0, weight400 = 0, weight40 = 0;
-            for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
-              const auto& label = GetMCLabel(i, j);
-              if (GetMCLabelID(label) >= 0) {
-                totalWeight += GetMCLabelWeight(label);
-                if (GetMCTrackObj(mMCParam, label).pt >= 0.4) {
-                  weight400 += GetMCLabelWeight(label);
-                }
-                if (GetMCTrackObj(mMCParam, label).pt <= 0.04) {
-                  weight40 += GetMCLabelWeight(label);
+          if (mQATasks & taskClusterRejection) {
+            if (mcAvail) {
+              float totalWeight = 0, weight400 = 0, weight40 = 0;
+              for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
+                const auto& label = GetMCLabel(i, j);
+                if (GetMCLabelID(label) >= 0) {
+                  totalWeight += GetMCLabelWeight(label);
+                  if (GetMCTrackObj(mMCParam, label).pt >= 0.4) {
+                    weight400 += GetMCLabelWeight(label);
+                  }
+                  if (GetMCTrackObj(mMCParam, label).pt <= 0.04) {
+                    weight40 += GetMCLabelWeight(label);
+                  }
                 }
               }
-            }
-            if (totalWeight > 0 && 10.f * weight400 >= totalWeight) {
-              if (!r.unattached && !r.protect && !r.physics) {
-                mClusterCounts.nFakeRemove400++;
-                int32_t totalFake = weight400 < 0.9f * totalWeight;
-                if (totalFake) {
-                  mClusterCounts.nFullFakeRemove400++;
-                }
-                /*printf("Fake removal (%d): Hit %7d, attached %d lowPt %d looper %d tube200 %d highIncl %d tube %d bad %d recPt %7.2f recLabel %6d", totalFake, i, (int32_t) (mClusterParam[i].attached || mClusterParam[i].fakeAttached),
-                    (int32_t) lowPt, (int32_t) ((attach & gputpcgmmergertypes::attachGoodLeg) == 0), (int32_t) ((attach & gputpcgmmergertypes::attachTube) && mev200),
-                    (int32_t) ((attach & gputpcgmmergertypes::attachHighIncl) != 0), (int32_t) ((attach & gputpcgmmergertypes::attachTube) != 0), (int32_t) ((attach & gputpcgmmergertypes::attachGood) == 0),
-                    fabsf(qpt) > 0 ? 1.f / qpt : 0.f, id);
-                for (int32_t j = 0;j < GetMCLabelNID(i);j++)
-                {
-                    //if (GetMCLabelID(i, j) < 0) break;
-                    printf(" - label%d %6d weight %5d", j, GetMCLabelID(i, j), (int32_t) GetMCLabelWeight(i, j));
-                    if (GetMCLabelID(i, j) >= 0) printf(" - pt %7.2f", mMCParam[GetMCLabelID(i, j)].pt);
-                    else printf("             ");
+              if (totalWeight > 0 && 10.f * weight400 >= totalWeight) {
+                if (!r.unattached && !r.protect && !r.physics) {
+                  mClusterCounts.nFakeRemove400++;
+                  int32_t totalFake = weight400 < 0.9f * totalWeight;
+                  if (totalFake) {
+                    mClusterCounts.nFullFakeRemove400++;
+                  }
+                  /*printf("Fake removal (%d): Hit %7d, attached %d lowPt %d looper %d tube200 %d highIncl %d tube %d bad %d recPt %7.2f recLabel %6d", totalFake, i, (int32_t) (mClusterParam[i].attached || mClusterParam[i].fakeAttached),
+                      (int32_t) lowPt, (int32_t) ((attach & gputpcgmmergertypes::attachGoodLeg) == 0), (int32_t) ((attach & gputpcgmmergertypes::attachTube) && mev200),
+                      (int32_t) ((attach & gputpcgmmergertypes::attachHighIncl) != 0), (int32_t) ((attach & gputpcgmmergertypes::attachTube) != 0), (int32_t) ((attach & gputpcgmmergertypes::attachGood) == 0),
+                      fabsf(qpt) > 0 ? 1.f / qpt : 0.f, id);
+                  for (int32_t j = 0;j < GetMCLabelNID(i);j++)
+                  {
+                      //if (GetMCLabelID(i, j) < 0) break;
+                      printf(" - label%d %6d weight %5d", j, GetMCLabelID(i, j), (int32_t) GetMCLabelWeight(i, j));
+                      if (GetMCLabelID(i, j) >= 0) printf(" - pt %7.2f", mMCParam[GetMCLabelID(i, j)].pt);
+                      else printf("             ");
+                  }
+                  printf("\n");*/
                 }
-                printf("\n");*/
+                mClusterCounts.nAbove400++;
               }
-              mClusterCounts.nAbove400++;
-            }
-            if (totalWeight > 0 && weight40 >= 0.9 * totalWeight) {
-              mClusterCounts.nBelow40++;
-              if (r.protect || r.physics) {
-                mClusterCounts.nFakeProtect40++;
+              if (totalWeight > 0 && weight40 >= 0.9 * totalWeight) {
+                mClusterCounts.nBelow40++;
+                if (r.protect || r.physics) {
+                  mClusterCounts.nFakeProtect40++;
+                }
               }
             }
-          }
 
-          if (r.physics) {
-            mClusterCounts.nPhysics++;
-          }
-          if (r.protect) {
-            mClusterCounts.nProt++;
-          }
-          if (r.unattached) {
-            mClusterCounts.nUnattached++;
+            if (r.physics) {
+              mClusterCounts.nPhysics++;
+            }
+            if (r.protect) {
+              mClusterCounts.nProt++;
+            }
+            if (r.unattached) {
+              mClusterCounts.nUnattached++;
+            }
           }
-          if (mTracking && clNative) {
-            const auto& cl = clNative->clustersLinear[i];
-            mClRej[0]->Fill(cl.getPad() - GPUTPCGeometry::NPads(iRow) / 2 + 0.5, iRow, 1.f);
-            if (!r.unattached && !r.protect) {
-              mClRej[1]->Fill(cl.getPad() - GPUTPCGeometry::NPads(iRow) / 2 + 0.5, iRow, 1.f);
+          if (mQATasks & taskClusterRejection) {
+            if (mTracking && clNative) {
+              const auto& cl = clNative->clustersLinear[i];
+              mClRej[0]->Fill(cl.getPad() - GPUTPCGeometry::NPads(iRow) / 2 + 0.5, iRow, 1.f);
+              if (!r.unattached && !r.protect) {
+                mClRej[1]->Fill(cl.getPad() - GPUTPCGeometry::NPads(iRow) / 2 + 0.5, iRow, 1.f);
+              }
             }
           }
         }
@@ -2271,7 +2276,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mCClXY->cd();
       mPClXY = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPClXY->Draw();
+    }
 
+    if (mQATasks & taskClusterRejection) {
       for (int32_t i = 0; i < 3; i++) {
         snprintf(name, 2048, "cnclrej%d", i);
         mCClRej[i] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
@@ -2283,7 +2290,9 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       mCClRejP->cd();
       mPClRejP = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
       mPClRejP->Draw();
+    }
 
+    if (mQATasks & taskClusterAttach) {
       for (int32_t i = 0; i < 4; i++) {
         snprintf(name, 2048, "cpadrow%d", i);
         mCPadRow[i] = createGarbageCollected<TCanvas>(name, name, 0, 0, 700, 700. * 2. / 3.);
@@ -3034,7 +3043,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
     }
 
-    mPClXY->cd();
+    mPClXY->cd(); // TODO: This should become a separate task category
     mClXY->SetOption("colz");
     mClXY->Draw();
     mCClXY->cd();
@@ -3042,61 +3051,61 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     if (mConfig.writeFileExt != "") {
       mCClXY->Print(Form("%s/clustersXY.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
     }
+  }
 
-    if (mQATasks & taskClusterCounts) {
-      mClRej[2]->Divide(mClRej[1], mClRej[0]);
+  if (mQATasks & taskClusterRejection) {
+    mClRej[2]->Divide(mClRej[1], mClRej[0]);
 
-      for (int32_t i = 0; i < 3; i++) {
-        if (tout && !mConfig.inputHistogramsOnly) {
-          mClRej[i]->Write();
-        }
-        mPClRej[i]->cd();
-        mClRej[i]->SetTitle(REJECTED_NAMES[i]);
-        mClRej[i]->SetOption("colz");
-        mClRej[i]->Draw();
-        mCClRej[i]->cd();
-        mCClRej[i]->Print(Form("%s/clustersRej%d%s.pdf", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i]));
-        if (mConfig.writeFileExt != "") {
-          mCClRej[i]->Print(Form("%s/clustersRej%d%s.%s", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i], mConfig.writeFileExt.c_str()));
-        }
+    for (int32_t i = 0; i < 3; i++) {
+      if (tout && !mConfig.inputHistogramsOnly) {
+        mClRej[i]->Write();
+      }
+      mPClRej[i]->cd();
+      mClRej[i]->SetTitle(REJECTED_NAMES[i]);
+      mClRej[i]->SetOption("colz");
+      mClRej[i]->Draw();
+      mCClRej[i]->cd();
+      mCClRej[i]->Print(Form("%s/clustersRej%d%s.pdf", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i]));
+      if (mConfig.writeFileExt != "") {
+        mCClRej[i]->Print(Form("%s/clustersRej%d%s.%s", mConfig.plotsDir.c_str(), i, REJECTED_NAMES[i], mConfig.writeFileExt.c_str()));
       }
+    }
 
-      mPClRejP->cd();
-      for (int32_t k = 0; k < ConfigNumInputs; k++) {
-        auto* tmp = mClRej[0];
-        if (GetHist(tmp, tin, k, nNewInput) == nullptr) {
-          continue;
-        }
-        TH1D* proj1 = tmp->ProjectionY(Form("clrejptmp1%d", k)); // TODO: Clean up names
-        proj1->SetDirectory(nullptr);
-        tmp = mClRej[1];
-        if (GetHist(tmp, tin, k, nNewInput) == nullptr) {
-          continue;
-        }
-        TH1D* proj2 = tmp->ProjectionY(Form("clrejptmp2%d", k));
-        proj2->SetDirectory(nullptr);
+    mPClRejP->cd();
+    for (int32_t k = 0; k < ConfigNumInputs; k++) {
+      auto* tmp = mClRej[0];
+      if (GetHist(tmp, tin, k, nNewInput) == nullptr) {
+        continue;
+      }
+      TH1D* proj1 = tmp->ProjectionY(Form("clrejptmp1%d", k)); // TODO: Clean up names
+      proj1->SetDirectory(nullptr);
+      tmp = mClRej[1];
+      if (GetHist(tmp, tin, k, nNewInput) == nullptr) {
+        continue;
+      }
+      TH1D* proj2 = tmp->ProjectionY(Form("clrejptmp2%d", k));
+      proj2->SetDirectory(nullptr);
 
-        auto* e = mClRejP;
-        if (GetHist(e, tin, k, nNewInput) == nullptr) {
-          continue;
-        }
-        e->Divide(proj2, proj1);
-        if (tout && !mConfig.inputHistogramsOnly && k == 0) {
-          e->Write();
-        }
-        delete proj1;
-        delete proj2;
-        e->SetMinimum(-0.02);
-        e->SetMaximum(0.22);
-        e->SetTitle("Rejected Clusters");
-        e->GetXaxis()->SetTitle("Pad Row");
-        e->GetYaxis()->SetTitle("Rejected Clusters (fraction)");
-        e->Draw(k == 0 ? "" : "same");
+      auto* e = mClRejP;
+      if (GetHist(e, tin, k, nNewInput) == nullptr) {
+        continue;
       }
-      mPClRejP->Print(Form("%s/clustersRejProjected.pdf", mConfig.plotsDir.c_str()));
-      if (mConfig.writeFileExt != "") {
-        mPClRejP->Print(Form("%s/clustersRejProjected.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
+      e->Divide(proj2, proj1);
+      if (tout && !mConfig.inputHistogramsOnly && k == 0) {
+        e->Write();
       }
+      delete proj1;
+      delete proj2;
+      e->SetMinimum(-0.02);
+      e->SetMaximum(0.22);
+      e->SetTitle("Rejected Clusters");
+      e->GetXaxis()->SetTitle("Pad Row");
+      e->GetYaxis()->SetTitle("Rejected Clusters (fraction)");
+      e->Draw(k == 0 ? "" : "same");
+    }
+    mPClRejP->Print(Form("%s/clustersRejProjected.pdf", mConfig.plotsDir.c_str()));
+    if (mConfig.writeFileExt != "") {
+      mPClRejP->Print(Form("%s/clustersRejProjected.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
     }
   }
 
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index b42fa804c6212..3dd49e2ec1373 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -56,6 +56,10 @@ class GPUQA
   static bool QAAvailable() { return false; }
   static bool IsInitialized() { return false; }
   void UpdateChain(GPUChainTracking* chain) {}
+
+  enum QA_TASKS {
+    tasksAutomatic = 0
+  };
 };
 } // namespace o2::gpu
 
@@ -146,16 +150,20 @@ class GPUQA
 
   static constexpr int32_t MC_LABEL_INVALID = -1e9;
 
-  enum QA_TASKS {
+  enum QA_TASKS { // TODO: make this in32_t typed
     taskTrackingEff = 1,
     taskTrackingRes = 2,
     taskTrackingResPull = 4,
+    tasksAllMC = 8 - 1,
     taskClusterAttach = 8,
     taskTrackStatistics = 16,
     taskClusterCounts = 32,
-    taskDefault = 63,
-    taskDefaultPostprocess = 31,
-    tasksNoQC = 56
+    taskClusterRejection = 64,
+    tasksAll = 128 - 1,
+    tasksDefault = tasksAll,
+    tasksDefaultPostprocess = tasksDefault & ~taskClusterCounts,
+    tasksAllNoQC = tasksAll & ~tasksAllMC,
+    tasksAutomatic = -1
   };
 
  private:
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index d7ea772c31653..fb1d489a8479d 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -180,7 +180,7 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     mConfig->configQA.shipToQC = true;
     if (!mConfig->configProcessing.runQA) {
       mConfig->configQA.enableLocalOutput = false;
-      mQATaskMask = (mSpecConfig.processMC ? 15 : 0) | (mConfig->configQA.clusterRejectionHistograms ? 32 : 0);
+      mQATaskMask = (mSpecConfig.processMC ? 15 : 0) | (mConfig->configQA.clusterRejectionHistograms ? 32 : 0); // TODO: Clean up using numeric flags!
       mConfig->configProcessing.runQA = -mQATaskMask;
     }
   }

From 4d0047ce8f4c45fe0ed7abe664b230a163d39d78 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 29 Oct 2025 14:45:23 +0100
Subject: [PATCH 1128/1764] GPU TPC: Fix deterministic mode in combination of
 propagation of MC labels

---
 GPU/GPUTracking/Global/GPUChainTracking.h     |  1 +
 .../Global/GPUChainTrackingClusterizer.cxx    | 92 ++++++++++++++-----
 2 files changed, 72 insertions(+), 21 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 8de49cc954e35..4b07aadfad357 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -306,6 +306,7 @@ class GPUChainTracking : public GPUChain
   void RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* clusters, std::function<o2::tpc::ClusterNative*(size_t)> allocator, bool applyClusterCuts);
   bool NeedTPCClustersOnGPU();
   void WriteReducedClusters();
+  void SortClusters(bool buildNativeGPU, bool propagateMCLabels, o2::tpc::ClusterNativeAccess* clusterAccess, o2::tpc::ClusterNative* clusters);
   template <int32_t I>
   int32_t RunTRDTrackingInternal();
   uint32_t StreamForSector(uint32_t sector) const;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index fdce8ef5a127d..c4566ffb968a7 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -57,6 +57,8 @@
 #include "utils/VcShim.h"
 #include "utils/strtag.h"
 #include <fstream>
+#include <numeric>
+#include <vector>
 
 using namespace o2::gpu;
 using namespace o2::tpc;
@@ -762,14 +764,13 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   ClusterNative* tmpNativeClusters = nullptr;
   std::unique_ptr<ClusterNative[]> tmpNativeClusterBuffer;
 
-  // setup MC Labels
-  bool propagateMCLabels = GetProcessingSettings().runMC && processors()->ioPtrs.tpcPackedDigits && processors()->ioPtrs.tpcPackedDigits->tpcDigitsMC;
+  const bool buildNativeGPU = doGPU && NeedTPCClustersOnGPU();
+  const bool buildNativeHost = (mRec->GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCClusters) || GetProcessingSettings().deterministicGPUReconstruction; // TODO: Should do this also when clusters are needed for later steps on the host but not requested as output
+  const bool propagateMCLabels = buildNativeHost && GetProcessingSettings().runMC && processors()->ioPtrs.tpcPackedDigits && processors()->ioPtrs.tpcPackedDigits->tpcDigitsMC;
+  const bool sortClusters = buildNativeHost && (GetProcessingSettings().deterministicGPUReconstruction || GetProcessingSettings().debugLevel >= 4);
 
   auto* digitsMC = propagateMCLabels ? processors()->ioPtrs.tpcPackedDigits->tpcDigitsMC : nullptr;
 
-  bool buildNativeGPU = doGPU && NeedTPCClustersOnGPU();
-  bool buildNativeHost = (mRec->GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCClusters) || GetProcessingSettings().deterministicGPUReconstruction; // TODO: Should do this also when clusters are needed for later steps on the host but not requested as output
-
   mInputsHost->mNClusterNative = mInputsShadow->mNClusterNative = mRec->MemoryScalers()->nTPCHits * tpcHitLowOccupancyScalingFactor;
   if (buildNativeGPU) {
     AllocateRegisteredMemory(mInputsHost->mResourceClusterNativeBuffer);
@@ -1281,21 +1282,20 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   }
 
   ClusterNativeAccess::ConstMCLabelContainerView* mcLabelsConstView = nullptr;
-  if (propagateMCLabels) {
-    // TODO: write to buffer directly
+  if (propagateMCLabels) { // TODO: write to buffer directly
     o2::dataformats::MCTruthContainer<o2::MCCompLabel> mcLabels;
     std::pair<ConstMCLabelContainer*, ConstMCLabelContainerView*> buffer;
-    if (!GetProcessingSettings().tpcWriteClustersAfterRejection && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)] && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)]->useExternal()) {
-      if (!mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)]->allocator) {
+    auto& labelOutputControl = mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)];
+    if (!GetProcessingSettings().tpcWriteClustersAfterRejection && !sortClusters && labelOutputControl && labelOutputControl->useExternal()) {
+      if (!labelOutputControl->allocator) {
         throw std::runtime_error("Cluster MC Label buffer missing");
       }
-      ClusterNativeAccess::ConstMCLabelContainerViewWithBuffer* container = reinterpret_cast<ClusterNativeAccess::ConstMCLabelContainerViewWithBuffer*>(mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)]->allocator(0));
+      ClusterNativeAccess::ConstMCLabelContainerViewWithBuffer* container = reinterpret_cast<ClusterNativeAccess::ConstMCLabelContainerViewWithBuffer*>(labelOutputControl->allocator(0));
       buffer = {&container->first, &container->second};
     } else {
       mIOMem.clusterNativeMCView = std::make_unique<ConstMCLabelContainerView>();
       mIOMem.clusterNativeMCBuffer = std::make_unique<ConstMCLabelContainer>();
-      buffer.first = mIOMem.clusterNativeMCBuffer.get();
-      buffer.second = mIOMem.clusterNativeMCView.get();
+      buffer = {mIOMem.clusterNativeMCBuffer.get(), mIOMem.clusterNativeMCView.get()};
     }
 
     assert(propagateMCLabels ? mcLinearLabels.header.size() == nClsTotal : true);
@@ -1350,15 +1350,8 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   if (doGPU && synchronizeCalibUpdate) {
     SynchronizeStream(0);
   }
-  if (buildNativeHost && (GetProcessingSettings().deterministicGPUReconstruction || GetProcessingSettings().debugLevel >= 4)) {
-    for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-        std::sort(&tmpNativeClusters[tmpNativeAccess->clusterOffset[i][j]], &tmpNativeClusters[tmpNativeAccess->clusterOffset[i][j] + tmpNativeAccess->nClusters[i][j]]);
-      }
-    }
-    if (buildNativeGPU) {
-      GPUMemCpy(RecoStep::TPCClusterFinding, (void*)mInputsShadow->mPclusterNativeBuffer, (const void*)tmpNativeClusters, nClsTotal * sizeof(tmpNativeClusters[0]), -1, true);
-    }
+  if (sortClusters) {
+    SortClusters(buildNativeGPU, propagateMCLabels, tmpNativeAccess, tmpNativeClusters);
   }
   mRec->MemoryScalers()->nTPCHits = nClsTotal;
   mRec->PopNonPersistentMemory(RecoStep::TPCClusterFinding, qStr2Tag("TPCCLUST"));
@@ -1374,3 +1367,60 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 #endif
   return 0;
 }
+
+void GPUChainTracking::SortClusters(bool buildNativeGPU, bool propagateMCLabels, ClusterNativeAccess* clusterAccess, ClusterNative* clusters)
+{
+  if (propagateMCLabels) {
+    std::vector<uint32_t> clsOrder(clusterAccess->nClustersTotal);
+    std::iota(clsOrder.begin(), clsOrder.end(), 0);
+    std::vector<ClusterNative> tmpClusters;
+    for (uint32_t i = 0; i < NSECTORS; i++) {
+      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+        const uint32_t offset = clusterAccess->clusterOffset[i][j];
+        std::sort(&clsOrder[offset], &clsOrder[offset + clusterAccess->nClusters[i][j]], [&clusters](const uint32_t a, const uint32_t b) {
+          return clusters[a] < clusters[b];
+        });
+        tmpClusters.resize(clusterAccess->nClusters[i][j]);
+        memcpy(tmpClusters.data(), &clusters[offset], clusterAccess->nClusters[i][j] * sizeof(tmpClusters[0]));
+        for (uint32_t k = 0; k < tmpClusters.size(); k++) {
+          clusters[offset + k] = tmpClusters[clsOrder[offset + k] - offset];
+        }
+      }
+    }
+    tmpClusters.clear();
+
+    std::pair<o2::dataformats::ConstMCLabelContainer*, o2::dataformats::ConstMCLabelContainerView*> labelBuffer;
+    GPUOutputControl* labelOutput = mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clusterLabels)];
+    std::unique_ptr<ConstMCLabelContainerView> tmpUniqueContainerView;
+    std::unique_ptr<ConstMCLabelContainer> tmpUniqueContainerBuffer;
+    if (labelOutput && labelOutput->allocator) {
+      ClusterNativeAccess::ConstMCLabelContainerViewWithBuffer* labelContainer = reinterpret_cast<ClusterNativeAccess::ConstMCLabelContainerViewWithBuffer*>(labelOutput->allocator(0));
+      labelBuffer = {&labelContainer->first, &labelContainer->second};
+    } else {
+      tmpUniqueContainerView = std::move(mIOMem.clusterNativeMCView);
+      tmpUniqueContainerBuffer = std::move(mIOMem.clusterNativeMCBuffer);
+      mIOMem.clusterNativeMCView = std::make_unique<ConstMCLabelContainerView>();
+      mIOMem.clusterNativeMCBuffer = std::make_unique<ConstMCLabelContainer>();
+      labelBuffer = {mIOMem.clusterNativeMCBuffer.get(), mIOMem.clusterNativeMCView.get()};
+    }
+
+    o2::dataformats::MCLabelContainer tmpContainer;
+    for (uint32_t i = 0; i < clusterAccess->nClustersTotal; i++) {
+      for (const auto& element : clusterAccess->clustersMCTruth->getLabels(clsOrder[i])) {
+        tmpContainer.addElement(i, element);
+      }
+    }
+    tmpContainer.flatten_to(*labelBuffer.first);
+    *labelBuffer.second = *labelBuffer.first;
+    clusterAccess->clustersMCTruth = labelBuffer.second;
+  } else {
+    for (uint32_t i = 0; i < NSECTORS; i++) {
+      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+        std::sort(&clusters[clusterAccess->clusterOffset[i][j]], &clusters[clusterAccess->clusterOffset[i][j] + clusterAccess->nClusters[i][j]]);
+      }
+    }
+  }
+  if (buildNativeGPU) {
+    GPUMemCpy(RecoStep::TPCClusterFinding, (void*)mInputsShadow->mPclusterNativeBuffer, (const void*)clusters, clusterAccess->nClustersTotal * sizeof(clusters[0]), -1, true);
+  }
+}

From 07e63da6ecc1733b0d6b5ce28afc7c852f1b0a89 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 12 Dec 2025 10:19:12 +0100
Subject: [PATCH 1129/1764] DPL: fix reversed index when filling
 DataProcessingStates

---
 Framework/Core/src/DataRelayer.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index df95aeda92a2b..01e7a2b29fd35 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -1055,7 +1055,7 @@ void DataRelayer::sendContextState()
   char* buffer = relayerSlotState + written;
   for (size_t ci = 0; ci < mTimesliceIndex.size(); ++ci) {
     for (size_t si = 0; si < mDistinctRoutesIndex.size(); ++si) {
-      int index = si * mTimesliceIndex.size() + ci;
+      int index = ci * mDistinctRoutesIndex.size() + si;
       int value = static_cast<int>(mCachedStateMetrics[index]);
       buffer[si] = value + '0';
       // Anything which is done is actually already empty,

From 16f1a93b6982837ef3f188a4b9067888d843e874 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 13 Dec 2025 09:17:14 +0100
Subject: [PATCH 1130/1764] Cleanup jobutils2 to work on ARM (#14901)

---
 Utilities/Tools/jobutils2.sh | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/Utilities/Tools/jobutils2.sh b/Utilities/Tools/jobutils2.sh
index ba96b97da090b..b7c8466f54313 100644
--- a/Utilities/Tools/jobutils2.sh
+++ b/Utilities/Tools/jobutils2.sh
@@ -395,10 +395,13 @@ getNumberOfPhysicalCPUCores() {
     fi
   else
     # Do something under GNU/Linux platform
-    CORESPERSOCKET=`lscpu | grep "Core(s) per socket" | awk '{print $4}'`
-    SOCKETS=`lscpu | grep "Socket(s)" | awk '{print $2}'`
+    #
+    # Gets the cores per socket by counting unique cores on socket 0.
+    # Gets sockets by counting unique socket ids. The grepping is done in any case  to avoid matching comments.
+    CORESPERSOCKET=$(lscpu -p=cpu,socket | grep "^[0-9]\+,0" | sort | uniq | wc -l)
+    SOCKETS=$(lscpu -p=socket | grep -e "^[0-9]" | sort | uniq | wc -l)
   fi
-  N=`bc <<< "${CORESPERSOCKET}*${SOCKETS}"`
+  N=$((${CORESPERSOCKET}*${SOCKETS}))
   echo "${N}"
 }
 

From c628d2979878efaeda5a4cabbea11b653c3e369d Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Tue, 9 Dec 2025 16:39:01 +0100
Subject: [PATCH 1131/1764] Integrate non-uniform InteractionSampler into
 CollisionContextTool

Possibility to inject non-uniform MU(BC) distributions into the
collision context creation.

Distributions can come from ROOT file or CCDB and follow a format
from EventSelectionQA (histogram hBcTVX).

Example:

```
 --nontrivial-mu-distribution ccdb://http://ccdb-test.cern.ch:8080/GLO/CALIB/EVSELQA/HBCTVX'
```
---
 .../simulation/src/InteractionSampler.cxx     |  3 +
 Steer/src/CollisionContextTool.cxx            | 79 ++++++++++++++++++-
 2 files changed, 79 insertions(+), 3 deletions(-)

diff --git a/DataFormats/simulation/src/InteractionSampler.cxx b/DataFormats/simulation/src/InteractionSampler.cxx
index 61b2c4f61bc08..f3ece5c51f90b 100644
--- a/DataFormats/simulation/src/InteractionSampler.cxx
+++ b/DataFormats/simulation/src/InteractionSampler.cxx
@@ -202,6 +202,9 @@ bool NonUniformMuInteractionSampler::setBCIntensityScales(const TH1F& hist)
 
 std::vector<float> NonUniformMuInteractionSampler::determineBCIntensityScalesFromHistogram(const TH1F& hist)
 {
+  if (mInteractingBCs.size() == 0) {
+    LOG(error) << " Initialize bunch crossing scheme before assigning scales";
+  }
   std::vector<float> scales;
   // we go through the BCs and query the count from histogram
   for (auto bc : mInteractingBCs) {
diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index a6c2b0e62e0ca..b884909aedd9d 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -29,6 +29,9 @@
 #include "DataFormatsParameters/GRPLHCIFData.h"
 #include "SimConfig/SimConfig.h"
 #include <filesystem>
+#include <sstream>
+#include <vector>
+#include <numeric>
 
 //
 // Created by Sandro Wenzel on 13.07.21.
@@ -64,6 +67,8 @@ struct Options {
                                   // This is useful when someone else is creating the contexts (MC-data embedding) and we
                                   // merely want to pass these through. If this is given, we simply take the timeframe ID, number of orbits
                                   // and copy the right amount of timeframes into the destination folder (implies individualTFextraction)
+  std::string nontrivial_mu_distribution = ""; // path to fetch a non-uniform MC(BC) distribution for the interaction sampler
+                                               // can be: (a) ccdb, (b) a ROOT file with the histogram included
 };
 
 enum class InteractionLockMode {
@@ -72,6 +77,28 @@ enum class InteractionLockMode {
   MINTIMEDISTANCE
 };
 
+struct CcdbUrl {
+  std::string server;   // may include http:// or https://
+  std::string port;     // empty if none
+  std::string fullPath; // everything after server[:port]/
+};
+
+std::optional<CcdbUrl> parseCcdbRegex(const std::string& url)
+{
+  static const std::regex re(
+    R"(^(?:ccdb://)(https?://[^/:]+|[^/:]+)(?::(\d+))?/(.+)$)");
+  std::smatch m;
+  if (!std::regex_match(url, m, re)) {
+    return std::nullopt;
+  }
+
+  CcdbUrl out;
+  out.server = m[1].str();   // server (may include http:// or https://)
+  out.port = m[2].str();     // optional port
+  out.fullPath = m[3].str(); // remainder
+  return out;
+}
+
 struct InteractionSpec {
   std::string name; // name (prefix for transport simulation); may also serve as unique identifier
   float interactionRate;
@@ -216,8 +243,8 @@ bool parseOptions(int argc, char* argv[], Options& optvalues)
     "timestamp", bpo::value<long>(&optvalues.timestamp)->default_value(-1L), "Timestamp for CCDB queries / anchoring")(
     "extract-per-timeframe", bpo::value<std::string>(&optvalues.individualTFextraction)->default_value(""),
     "Extract individual timeframe contexts. Format required: time_frame_prefix[:comma_separated_list_of_signals_to_offset]")(
-    "import-external", bpo::value<std::string>(&optvalues.external_path)->default_value(""),
-    "Take collision contexts (per timeframe) from external files for instance for data-anchoring use-case. Needs timeframeID and number of orbits to be given as well.");
+    "import-external", bpo::value<std::string>(&optvalues.external_path)->default_value(""), "Take collision contexts (per timeframe) from external files for instance for data-anchoring use-case. Needs timeframeID and number of orbits to be given as well.")(
+    "nontrivial-mu-distribution", bpo::value<std::string>(&optvalues.nontrivial_mu_distribution)->default_value(""), "Distribution for MU(BC)");
 
   options.add_options()("help,h", "Produce help message.");
 
@@ -397,6 +424,46 @@ int main(int argc, char* argv[])
     auto mode = ispecs[id].syncmode;
     if (mode == InteractionLockMode::NOLOCK) {
       auto sampler = std::make_unique<o2::steer::InteractionSampler>();
+      TH1F* mu_hist = nullptr;
+
+      // we check if there is a realistic bunch crossing distribution available
+      const auto& mu_distr_source = options.nontrivial_mu_distribution;
+      if (mu_distr_source.size() > 0) {
+        if (mu_distr_source.find("ccdb") == 0) {
+          auto ccdb_info_wrapper = parseCcdbRegex(mu_distr_source);
+          if (!ccdb_info_wrapper.has_value()) {
+            LOG(error) << "Could not parse CCDB path for mu(bc) distribution";
+          } else {
+            auto& ccdb_info = ccdb_info_wrapper.value();
+
+            // for now construct a specific CCDBManager for this query
+            o2::ccdb::CCDBManagerInstance ccdb_inst(ccdb_info.server + std::string(":") + ccdb_info.port);
+            ccdb_inst.setFatalWhenNull(false);
+            auto local_hist = ccdb_inst.getForTimeStamp<TH1F>(ccdb_info.fullPath, options.timestamp);
+            if (local_hist) {
+              mu_hist = (TH1F*)(local_hist->Clone("h2")); // we need to clone since ownership of local_hist is with TFile
+            } else {
+              LOG(warn) << "No mu(bc) distribution found on CCDB. Using uniform one";
+            }
+          }
+        } else {
+          // we interpret the file as a ROOT file and open it to extract the wanted histogram
+          auto mudistr_file = TFile::Open(mu_distr_source.c_str(), "OPEN");
+          if (mudistr_file && !mudistr_file->IsZombie()) {
+            auto local_hist = mudistr_file->Get<TH1F>("hBcTVX");
+            mu_hist = (TH1F*)(local_hist->Clone("h2")); // we need to clone since ownership of local_hist is with TFile
+            mudistr_file->Close();
+          }
+        }
+        if (mu_hist) {
+          LOG(info) << "Found an external mu distribution with mean BC value " << mu_hist->GetMean();
+
+          // do some checks
+
+          // reset to correct interaction Sampler type
+          sampler.reset(new o2::steer::NonUniformMuInteractionSampler());
+        }
+      }
 
       // for debug purposes: allows to instantiate trivial sampler
       if (const char* env = getenv("ALICEO2_ENFORCE_TRIVIAL_BC_SAMPLER")) {
@@ -418,11 +485,17 @@ int main(int argc, char* argv[])
       if (!options.bcpatternfile.empty()) {
         setBCFillingHelper(*sampler, options.bcpatternfile);
       }
+      sampler->init();
+      if (auto sampler_cast = dynamic_cast<o2::steer::NonUniformMuInteractionSampler*>(sampler.get())) {
+        if (mu_hist) {
+          sampler_cast->setBCIntensityScales(*mu_hist);
+        }
+      }
+
       o2::InteractionTimeRecord record;
       // this loop makes sure that the first collision is within the range of orbits asked (if noEmptyTF is enabled)
       do {
         sampler->setFirstIR(o2::InteractionRecord(options.firstBC, orbitstart));
-        sampler->init();
         record = sampler->generateCollisionTime();
       } while (options.noEmptyTF && usetimeframelength && record.orbit >= orbitstart + orbits_total);
       int count = 0;

From deff3d8eb8595991c19dd4e5b166980c08c1ba98 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <48915672+matthias-kleiner@users.noreply.github.com>
Date: Sat, 13 Dec 2025 19:26:36 +0100
Subject: [PATCH 1132/1764] TPC: Use CTP as fallback if no IDCs are available
 (#14919)

* TPC: Use CTP as fallback if no IDCs are available

* Dont update map as only the lumi is updated
---
 .../TPCCalibration/CorrectionMapsLoader.h     |  1 +
 .../calibration/src/CorrectionMapsLoader.cxx  | 37 +++++++++++++++++--
 2 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
index a907b83fe49bf..5a11ce3ea24e5 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
@@ -79,6 +79,7 @@ class CorrectionMapsLoader : public o2::gpu::CorrectionMapsHelper
   float mInstLumiCTPFactor = 1.0; // multiplicative factor for inst. lumi
   int mLumiCTPSource = 0;         // 0: main, 1: alternative CTP lumi source
   std::unique_ptr<o2::gpu::TPCFastTransform> mCorrMapMShape{nullptr};
+  bool mIDC2CTPFallbackActive = false; // flag indicating that fallback from IDC to CTP scaling is active
 #endif
 };
 
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index 0e4a5e2a73df4..e9d7474699ce2 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -53,6 +53,37 @@ void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
   o2::ctp::LumiInfo lumiObj;
   static o2::ctp::LumiInfo lumiPrev;
 
+  if (getLumiScaleType() == 2 || mIDC2CTPFallbackActive) {
+    float tpcScaler = pc.inputs().get<float>("tpcscaler");
+    // check if tpcScaler is valid and CTP fallback is allowed
+    if (tpcScaler == -1.f) {
+      const bool canUseCTPScaling = mCorrMap && mCorrMapRef && mCorrMap->isIDCSet() && mCorrMapRef->isIDCSet() && mCorrMap->isLumiSet() && mCorrMapRef->isLumiSet();
+      if (canUseCTPScaling) {
+        LOGP(info, "Invalid TPC scaler value {} received for IDC-based scaling! Using CTP fallback", tpcScaler);
+        mIDC2CTPFallbackActive = true;
+        setMeanLumi(mCorrMap->getLumi(), false);
+        setMeanLumiRef(mCorrMapRef->getLumi());
+        setLumiScaleType(1);
+      } else if (mCorrMap) {
+        // CTP scaling is not possible, dont do any scaling to avoid applying wrong corrections
+        const float storedIDC = mCorrMap->getIDC();
+        LOGP(warning, "Invalid TPC scaler value {} received for IDC-based scaling! CTP fallback not possible, using stored IDC of {} from the map to avoid applying wrong corrections", tpcScaler, storedIDC);
+        setInstLumi(storedIDC);
+      }
+    } else {
+      if (mIDC2CTPFallbackActive) {
+        // reset back to normal operation
+        LOGP(info, "Valid TPC scaler value {} received, switching back to IDC-based scaling", tpcScaler);
+        mIDC2CTPFallbackActive = false;
+        setMeanLumi(mCorrMap->getIDC(), false);
+        setMeanLumiRef(mCorrMapRef->getIDC());
+        setLumiScaleType(2);
+      }
+      // correct IDC received
+      setInstLumi(tpcScaler);
+    }
+  }
+
   if (getLumiCTPAvailable() && mInstCTPLumiOverride <= 0.) {
     if (pc.inputs().get<gsl::span<char>>("CTPLumi").size() == sizeof(o2::ctp::LumiInfo)) {
       lumiPrev = lumiObj = pc.inputs().get<o2::ctp::LumiInfo>("CTPLumi");
@@ -67,10 +98,7 @@ void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
       setInstLumi(getInstLumiCTP());
     }
   }
-  if (getLumiScaleType() == 2) {
-    float tpcScaler = pc.inputs().get<float>("tpcscaler");
-    setInstLumi(tpcScaler);
-  }
+
   if (getUseMShapeCorrection()) {
     LOGP(info, "Setting M-Shape map");
     const auto mapMShape = pc.inputs().get<o2::gpu::TPCFastTransform*>("mshape");
@@ -317,6 +345,7 @@ void CorrectionMapsLoader::copySettings(const CorrectionMapsLoader& src)
   mLumiCTPSource = src.mLumiCTPSource;
   mLumiScaleMode = src.mLumiScaleMode;
   mScaleInverse = src.getScaleInverse();
+  mIDC2CTPFallbackActive = src.mIDC2CTPFallbackActive;
 }
 
 void CorrectionMapsLoader::updateInverse()

From 519b2f7b7d84edd893cc28a55569497fd6d6fdf2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 30 Oct 2025 16:57:23 +0100
Subject: [PATCH 1133/1764] GPU: Unify applying settings for sync reco between
 standalone and GPUWorkflow

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx   | 14 ++++++++++
 GPU/GPUTracking/Global/GPUChainTracking.h     |  3 ++
 GPU/GPUTracking/Interface/GPUO2Interface.cxx  |  5 ++++
 GPU/GPUTracking/Interface/GPUO2Interface.h    |  3 ++
 .../Standalone/Benchmark/standalone.cxx       | 28 ++++++-------------
 GPU/Workflow/src/GPUWorkflowSpec.cxx          | 11 ++------
 6 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 0e7d4bc4f436e..8a0d45a33ca93 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -1007,3 +1007,17 @@ void GPUChainTracking::SetO2Propagator(const o2::base::Propagator* prop)
     GPUFatal("GPU magnetic field for propagator requested, but received an O2 propagator without GPU field");
   }
 }
+
+void GPUChainTracking::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode)
+{
+  if (syncMode) {
+    rec.useMatLUT = false;
+    rec.tpc.rebuildTrackMaxNonIntCov = 0.f;
+  }
+  if (proc.rtc.optSpecialCode == -1) {
+    proc.rtc.optSpecialCode = syncMode;
+  }
+  if (dEdxMode != -2) {
+    steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, dEdxMode == -1 ? !syncMode : dEdxMode > 0);
+  }
+}
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 4b07aadfad357..7d70e0b667946 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -66,6 +66,8 @@ struct GPUNewCalibValues;
 struct GPUTriggerOutputs;
 struct CfFragment;
 class GPUTPCClusterFinder;
+struct GPUSettingsProcessing;
+struct GPUSettingsRec;
 
 class GPUChainTracking : public GPUChain
 {
@@ -86,6 +88,7 @@ class GPUChainTracking : public GPUChain
   void ClearErrorCodes(bool cpuOnly = false);
   int32_t DoQueuedUpdates(int32_t stream, bool updateSlave = true); // Forces doing queue calib updates, don't call when you are not sure you are allowed to do so!
   bool QARanForTF() const { return mFractionalQAEnabled; }
+  static void ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode = -2);
 
   // Structures for input and output data
   GPUTrackingInOutPointers& mIOPtrs;
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index d04db5e9bf271..95a57a4b17c4b 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -268,3 +268,8 @@ void GPUO2Interface::UseGPUPolynomialFieldInPropagator(o2::base::Propagator* pro
 {
   prop->setGPUField(&mCtx[0].mRec->GetParam().polynomialField);
 }
+
+void GPUO2Interface::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode)
+{
+  GPUChainTracking::ApplySyncSettings(proc, rec, steps, syncMode, dEdxMode);
+}
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.h b/GPU/GPUTracking/Interface/GPUO2Interface.h
index 00c72cc5e3359..3b4dde2cb0f96 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.h
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.h
@@ -56,6 +56,8 @@ struct GPUInterfaceInputUpdate;
 struct GPUTrackingOutputs;
 struct GPUConstantMem;
 struct GPUNewCalibValues;
+struct GPUSettingsProcessing;
+struct GPUSettingsRec;
 
 struct GPUO2Interface_processingContext;
 struct GPUO2Interface_Internals;
@@ -80,6 +82,7 @@ class GPUO2Interface
 
   // Updates all calibration objects that are != nullptr in newCalib
   int32_t UpdateCalibration(const GPUCalibObjectsConst& newCalib, const GPUNewCalibValues& newVals, uint32_t iThread = 0);
+  static void ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode = -2);
 
   int32_t registerMemoryForGPU(const void* ptr, size_t size);
   int32_t unregisterMemoryForGPU(const void* ptr);
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 857803d913372..1b3603a226af0 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -377,9 +377,6 @@ int32_t SetupReconstruction()
   } else if (chainTracking->GetTRDGeometry() == nullptr) {
     steps.steps.setBits(GPUDataTypes::RecoStep::TRDTracking, false);
   }
-  if (configStandalone.rundEdx != -1) {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, configStandalone.rundEdx > 0);
-  }
   if (configStandalone.runCompression != -1) {
     steps.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, configStandalone.runCompression > 0);
   }
@@ -434,23 +431,15 @@ int32_t SetupReconstruction()
     }
   }
 
-  bool runAsyncQA = procSet.runQA && !configStandalone.testSyncAsyncQcInSync;
-  if (configStandalone.testSyncAsync || configStandalone.testSync) {
-    // Set settings for synchronous
-    if (configStandalone.rundEdx == -1) {
-      steps.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, 0);
-    }
-    recSet.useMatLUT = false;
-    if (configStandalone.testSyncAsync) {
-      procSet.eventDisplay = nullptr;
-      if (!configStandalone.testSyncAsyncQcInSync) {
-        procSet.runQA = false;
-      }
+  // Set settings for synchronous
+  GPUChainTracking::ApplySyncSettings(procSet, recSet, steps.steps, configStandalone.testSyncAsync || configStandalone.testSync, configStandalone.rundEdx);
+  int32_t runAsyncQA = procSet.runQA && !configStandalone.testSyncAsyncQcInSync ? procSet.runQA : 0;
+  if (configStandalone.testSyncAsync) {
+    procSet.eventDisplay = nullptr;
+    if (!configStandalone.testSyncAsyncQcInSync) {
+      procSet.runQA = false;
     }
   }
-  if (configStandalone.proc.rtc.optSpecialCode == -1) {
-    configStandalone.proc.rtc.optSpecialCode = configStandalone.testSyncAsync || configStandalone.testSync;
-  }
 
   rec->SetSettings(&grp, &recSet, &procSet, &steps);
   if (configStandalone.proc.doublePipeline) {
@@ -470,13 +459,12 @@ int32_t SetupReconstruction()
     procSet.runQA = runAsyncQA;
     procSet.eventDisplay = eventDisplay.get();
     procSet.runCompressionStatistics = 0;
-    procSet.rtc.optSpecialCode = 0;
     if (recSet.tpc.rejectionStrategy >= GPUSettings::RejectionStrategyB) {
       procSet.tpcInputWithClusterRejection = 1;
     }
     recSet.tpc.disableRefitAttachment = 0xFF;
     recSet.maxTrackQPtB5 = CAMath::Min(recSet.maxTrackQPtB5, recSet.tpc.rejectQPtB5);
-    recSet.useMatLUT = true;
+    GPUChainTracking::ApplySyncSettings(procSet, recSet, steps.steps, false, configStandalone.rundEdx);
     recAsync->SetSettings(&grp, &recSet, &procSet, &steps);
   }
 
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index fb1d489a8479d..ca929bb025f80 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -185,20 +185,15 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     }
   }
   mConfig->configInterface.outputToExternalBuffers = true;
-  if (mConfParam->synchronousProcessing) {
-    mConfig->configReconstruction.useMatLUT = false;
-  }
-  if (mConfig->configProcessing.rtc.optSpecialCode == -1) {
-    mConfig->configProcessing.rtc.optSpecialCode = mConfParam->synchronousProcessing;
-  }
+  const bool runTracking = mSpecConfig.outputTracks || mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat;
+  GPUO2Interface::ApplySyncSettings(mConfig->configProcessing, mConfig->configReconstruction, mConfig->configWorkflow.steps, mConfParam->synchronousProcessing, runTracking ? mConfParam->rundEdx : -2);
 
   // Configure the "GPU workflow" i.e. which steps we run on the GPU (or CPU)
-  if (mSpecConfig.outputTracks || mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat) {
+  if (runTracking) {
     mConfig->configWorkflow.steps.set(GPUDataTypes::RecoStep::TPCConversion,
                                       GPUDataTypes::RecoStep::TPCSectorTracking,
                                       GPUDataTypes::RecoStep::TPCMerging);
     mConfig->configWorkflow.outputs.set(GPUDataTypes::InOutType::TPCMergedTracks);
-    mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, mConfParam->rundEdx == -1 ? !mConfParam->synchronousProcessing : mConfParam->rundEdx);
   }
   if (mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat) {
     mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, true);

From d6d20b4ec4049593fbe5d49b9bc667976ceaf98c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 11 Dec 2025 20:56:56 +0100
Subject: [PATCH 1134/1764] GPU DataTypes / QA: Clean up some data types /
 enums

---
 .../DataFormatsTRD/RecoInputContainer.h       |  2 +-
 .../include/ITStracking/TrackingInterface.h   |  2 +-
 .../include/ITSWorkflow/RecoWorkflow.h        |  4 +-
 .../include/ITSWorkflow/TrackerSpec.h         | 12 ++-
 .../ITSMFT/ITS/workflow/src/RecoWorkflow.cxx  |  2 +-
 .../ITSMFT/ITS/workflow/src/TrackerSpec.cxx   |  4 +-
 .../ITS/workflow/src/its-reco-workflow.cxx    |  2 +-
 .../reconstruction/test/testGPUCATracking.cxx | 10 +--
 Detectors/TPC/workflow/src/ZSSpec.cxx         |  2 +-
 .../workflow/src/TRDGlobalTrackingSpec.cxx    |  4 +-
 .../include/TRKWorkflow/RecoWorkflow.h        |  4 +-
 .../include/TRKWorkflow/TrackerSpec.h         |  8 +-
 .../ALICE3/TRK/workflow/src/RecoWorkflow.cxx  |  4 +-
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   |  4 +-
 .../TRK/workflow/src/trk-reco-workflow.cxx    |  2 +-
 .../include/ITS3Workflow/RecoWorkflow.h       |  6 +-
 .../include/ITS3Workflow/TrackerSpec.h        | 12 ++-
 .../ITS3/workflow/src/RecoWorkflow.cxx        |  2 +-
 .../ITS3/workflow/src/TrackerSpec.cxx         |  4 +-
 .../ITS3/workflow/src/its3-reco-workflow.cxx  |  2 +-
 GPU/GPUTracking/Base/GPUConstantMem.h         |  2 +-
 GPU/GPUTracking/Base/GPUGeneralKernels.h      |  9 ++-
 GPU/GPUTracking/Base/GPUParam.cxx             |  4 +-
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 10 +--
 GPU/GPUTracking/Base/GPUReconstruction.h      | 14 ++--
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx | 14 ++--
 .../Base/GPUReconstructionCPUKernels.h        |  4 +-
 .../Base/GPUReconstructionConvert.cxx         |  2 +-
 .../Base/GPUReconstructionIncludes.h          |  2 +-
 .../Base/GPUReconstructionLibrary.cxx         | 10 +--
 .../Base/GPUReconstructionProcessing.h        | 12 +--
 .../Base/GPUReconstructionTimeframe.h         |  2 +-
 GPU/GPUTracking/CMakeLists.txt                | 13 ++-
 .../DataCompression/GPUTPCCompression.cxx     |  6 +-
 .../GPUTPCCompressionKernels.h                |  2 +-
 .../GPUTPCDecompressionKernels.h              |  2 +-
 GPU/GPUTracking/DataTypes/GPUConfigDump.cxx   |  2 +-
 ...PUDataTypes.cxx => GPUDataTypesConfig.cxx} | 10 +--
 .../DataTypes/GPUDataTypesConfig.h            | 80 +++++++++++++++++++
 .../{GPUDataTypes.h => GPUDataTypesIO.h}      | 66 +++------------
 GPU/GPUTracking/DataTypes/GPUDataTypesQA.h    | 42 ++++++++++
 .../DataTypes/GPUO2ConfigurableParam.cxx      |  4 +-
 GPU/GPUTracking/DataTypes/GPUSettings.h       |  4 +-
 GPU/GPUTracking/Global/GPUChain.cxx           | 12 +--
 GPU/GPUTracking/Global/GPUChain.h             | 12 +--
 GPU/GPUTracking/Global/GPUChainITS.cxx        |  2 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   | 73 +++++++++--------
 GPU/GPUTracking/Global/GPUChainTracking.h     |  5 +-
 .../Global/GPUChainTrackingClusterizer.cxx    | 10 +--
 .../GPUChainTrackingDebugAndProfiling.cxx     |  2 +-
 .../Global/GPUChainTrackingTransformation.cxx |  4 +-
 GPU/GPUTracking/Global/GPUErrors.cxx          |  2 +-
 .../Global/GPUTrackingInputProvider.cxx       |  6 +-
 GPU/GPUTracking/Interface/GPUO2Interface.cxx  |  8 +-
 GPU/GPUTracking/Interface/GPUO2Interface.h    |  5 +-
 .../Interface/GPUO2InterfaceConfiguration.cxx |  2 +-
 .../Interface/GPUO2InterfaceConfiguration.h   |  2 +-
 .../Interface/GPUO2InterfaceDisplay.h         |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  8 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h    |  2 +-
 .../Merger/GPUTPCGlobalDebugSortKernels.h     |  2 +-
 .../Refit/GPUTrackingRefitKernel.h            |  2 +-
 .../SectorTracker/GPUTPCCreateOccupancyMap.h  |  2 +-
 .../SectorTracker/GPUTPCCreateTrackingData.h  |  2 +-
 .../GPUTPCExtrapolationTracking.cxx           | 26 +++---
 .../GPUTPCExtrapolationTracking.h             |  4 +-
 .../SectorTracker/GPUTPCNeighboursCleaner.h   |  2 +-
 .../SectorTracker/GPUTPCNeighboursFinder.h    |  2 +-
 .../GPUTPCSectorDebugSortKernels.h            |  2 +-
 .../SectorTracker/GPUTPCStartHitsFinder.h     |  2 +-
 .../SectorTracker/GPUTPCStartHitsSorter.h     |  2 +-
 .../SectorTracker/GPUTPCTracker.cxx           | 10 +--
 .../SectorTracker/GPUTPCTrackletConstructor.h |  2 +-
 .../SectorTracker/GPUTPCTrackletSelector.h    |  2 +-
 .../Standalone/Benchmark/standalone.cxx       | 76 +++++++++---------
 .../TPCClusterFinder/GPUTPCCFChainContext.h   |  2 +-
 .../GPUTPCCFChargeMapFiller.h                 |  4 +-
 .../GPUTPCCFCheckPadBaseline.h                |  4 +-
 .../TPCClusterFinder/GPUTPCCFClusterizer.h    |  4 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.h       |  8 +-
 .../TPCClusterFinder/GPUTPCCFDeconvolution.h  |  4 +-
 .../TPCClusterFinder/GPUTPCCFGather.h         |  4 +-
 .../GPUTPCCFMCLabelFlattener.h                |  4 +-
 .../GPUTPCCFNoiseSuppression.h                |  4 +-
 .../TPCClusterFinder/GPUTPCCFPeakFinder.h     |  4 +-
 .../GPUTPCCFStreamCompaction.h                |  4 +-
 .../TPCClusterFinder/GPUTPCClusterFinder.cxx  | 16 ++--
 .../TPCClusterFinder/GPUTPCClusterFinder.h    |  2 +-
 .../GPUTPCNNClusterizerKernels.h              |  4 +-
 .../TRDTracking/GPUTRDTrackerKernels.h        |  2 +-
 .../TRDTracking/macros/run_trd_tracker.C      |  4 +-
 GPU/GPUTracking/dEdx/GPUdEdx.h                |  1 +
 GPU/GPUTracking/display/GPUDisplay.h          |  1 +
 .../display/render/GPUDisplayDraw.cxx         |  3 +-
 GPU/GPUTracking/qa/GPUQA.h                    | 22 +----
 .../GPUWorkflowHelper/GPUWorkflowHelper.h     |  2 +-
 GPU/Workflow/src/GPUWorkflowInternal.h        |  2 +-
 GPU/Workflow/src/GPUWorkflowPipeline.cxx      |  2 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          | 45 ++++++-----
 doc/data/2021-01-o2_prs.json                  |  4 +-
 100 files changed, 462 insertions(+), 397 deletions(-)
 rename GPU/GPUTracking/DataTypes/{GPUDataTypes.cxx => GPUDataTypesConfig.cxx} (73%)
 create mode 100644 GPU/GPUTracking/DataTypes/GPUDataTypesConfig.h
 rename GPU/GPUTracking/DataTypes/{GPUDataTypes.h => GPUDataTypesIO.h} (74%)
 create mode 100644 GPU/GPUTracking/DataTypes/GPUDataTypesQA.h

diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/RecoInputContainer.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/RecoInputContainer.h
index 353f635306e68..032dd4162a785 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/RecoInputContainer.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/RecoInputContainer.h
@@ -27,7 +27,7 @@
 #include "Framework/InputRecord.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 
 #include <gsl/span>
 #include <memory>
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index d31b1f11a4983..a882ca9b779c4 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -24,7 +24,7 @@
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "DataFormatsCalibration/MeanVertexObject.h"
 
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUO2ExternalUser.h"
 #include "GPUChainITS.h"
 
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
index 011ee6b88ff6f..90b38acb34a95 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
@@ -16,7 +16,7 @@
 
 #include "Framework/WorkflowSpec.h"
 #include "ITStracking/Configuration.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesConfig.h"
 
 namespace o2
 {
@@ -28,7 +28,7 @@ namespace reco_workflow
 
 framework::WorkflowSpec getWorkflow(bool useMC, bool useCMtracker, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
                                     bool upstreamDigits = false, bool upstreamClusters = false, bool disableRootOutput = false, bool useGeom = false, int useTrig = 0,
-                                    bool useGPUWF = false, o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
+                                    bool useGPUWF = false, o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
 }
 
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
index ee5ba4d5cc61c..01eb7cb7b69aa 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
@@ -23,11 +23,17 @@
 
 #include "ITStracking/TrackingInterface.h"
 
-#include "GPUDataTypes.h"
+#include "GPUDataTypesConfig.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 
 #include "TStopwatch.h"
 
+namespace o2::gpu
+{
+class GPUReconstruction;
+class GPUChainITS;
+} // namespace o2::gpu
+
 namespace o2::its
 {
 
@@ -39,7 +45,7 @@ class TrackerDPL : public framework::Task
              int trgType,
              const TrackingMode::Type trMode = TrackingMode::Unset,
              const bool overrBeamEst = false,
-             o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
+             o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
   void init(framework::InitContext& ic) final;
   void run(framework::ProcessingContext& pc) final;
@@ -57,7 +63,7 @@ class TrackerDPL : public framework::Task
   TStopwatch mTimer;
 };
 
-framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, TrackingMode::Type trMode, const bool overrBeamEst = false, o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, TrackingMode::Type trMode, const bool overrBeamEst = false, o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
 
 } // namespace o2::its
 
diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index f375eaf67c04f..368ca6909240f 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -38,7 +38,7 @@ framework::WorkflowSpec getWorkflow(bool useMC,
                                     bool useGeom,
                                     int useTrig,
                                     bool useGPUWF,
-                                    o2::gpu::GPUDataTypes::DeviceType dtype)
+                                    o2::gpu::gpudatatypes::DeviceType dtype)
 {
   framework::WorkflowSpec specs;
   if (!(upstreamDigits || upstreamClusters)) {
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index dbfd5edf839ae..12d84ca7ab6ad 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -28,7 +28,7 @@ TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        int trgType,
                        const TrackingMode::Type trMode,
                        const bool overrBeamEst,
-                       o2::gpu::GPUDataTypes::DeviceType dType) : mGGCCDBRequest(gr),
+                       o2::gpu::gpudatatypes::DeviceType dType) : mGGCCDBRequest(gr),
                                                                   mRecChain{o2::gpu::GPUReconstruction::CreateInstance(dType, true)},
                                                                   mITSTrackingInterface{isMC, trgType, overrBeamEst}
 {
@@ -78,7 +78,7 @@ void TrackerDPL::end()
   LOGF(info, "ITS CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::GPUDataTypes::DeviceType dType)
+DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::gpudatatypes::DeviceType dType)
 {
   std::vector<InputSpec> inputs;
 
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
index 4b9053436d44c..4e1721f4194b0 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
@@ -69,7 +69,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto trmode = configcontext.options().get<std::string>("tracking-mode");
   auto selTrig = configcontext.options().get<std::string>("select-with-triggers");
   auto useGpuWF = configcontext.options().get<bool>("use-gpu-workflow");
-  auto gpuDevice = static_cast<o2::gpu::GPUDataTypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
+  auto gpuDevice = static_cast<o2::gpu::gpudatatypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
   auto extDigits = configcontext.options().get<bool>("digits-from-upstream");
   auto extClusters = configcontext.options().get<bool>("clusters-from-upstream");
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
diff --git a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
index 3e196fa9bb7cc..5c66e4635987f 100644
--- a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
+++ b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
@@ -55,7 +55,7 @@ BOOST_AUTO_TEST_CASE(CATracking_test1)
   bool continuous = false;     // time frame data v.s. triggered events
 
   GPUO2InterfaceConfiguration config;
-  config.configDeviceBackend.deviceType = GPUDataTypes::DeviceType::CPU;
+  config.configDeviceBackend.deviceType = gpudatatypes::DeviceType::CPU;
   config.configDeviceBackend.forceDeviceType = true;
 
   config.configProcessing.ompThreads = 4;         // 4 threads if we run on the CPU, 1 = default, 0 = auto-detect
@@ -69,10 +69,10 @@ BOOST_AUTO_TEST_CASE(CATracking_test1)
   config.configReconstruction.tpc.searchWindowDZDR = 2.5f; // Should always be 2.5 for looper-finding and/or continuous tracking
   config.configReconstruction.tpc.trackReferenceX = refX;
 
-  config.configWorkflow.steps.set(GPUDataTypes::RecoStep::TPCConversion, GPUDataTypes::RecoStep::TPCSectorTracking,
-                                  GPUDataTypes::RecoStep::TPCMerging, GPUDataTypes::RecoStep::TPCCompression, GPUDataTypes::RecoStep::TPCdEdx);
-  config.configWorkflow.inputs.set(GPUDataTypes::InOutType::TPCClusters);
-  config.configWorkflow.outputs.set(GPUDataTypes::InOutType::TPCMergedTracks);
+  config.configWorkflow.steps.set(gpudatatypes::RecoStep::TPCConversion, gpudatatypes::RecoStep::TPCSectorTracking,
+                                  gpudatatypes::RecoStep::TPCMerging, gpudatatypes::RecoStep::TPCCompression, gpudatatypes::RecoStep::TPCdEdx);
+  config.configWorkflow.inputs.set(gpudatatypes::InOutType::TPCClusters);
+  config.configWorkflow.outputs.set(gpudatatypes::InOutType::TPCMergedTracks);
 
   std::unique_ptr<TPCFastTransform> fastTransform(TPCFastTransformHelperO2::instance()->create(0));
   std::unique_ptr<CorrectionMapsHelper> fastTransformHelper(new CorrectionMapsHelper());
diff --git a/Detectors/TPC/workflow/src/ZSSpec.cxx b/Detectors/TPC/workflow/src/ZSSpec.cxx
index ccd59de42f000..c24647f6ae240 100644
--- a/Detectors/TPC/workflow/src/ZSSpec.cxx
+++ b/Detectors/TPC/workflow/src/ZSSpec.cxx
@@ -22,7 +22,7 @@
 #include "DataFormatsTPC/ZeroSuppression.h"
 #include "DataFormatsTPC/Helpers.h"
 #include "DataFormatsTPC/Digit.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUHostDataTypes.h"
 #include "GPUO2InterfaceConfiguration.h"
 #include "TPCBase/Sector.h"
diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index 598ce3c35c98c..9588888df5fc6 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -46,7 +46,7 @@
 #include "GPUO2InterfaceConfiguration.h"
 #include "GPUO2InterfaceUtils.h"
 #include "GPUSettings.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUTRDDef.h"
 #include "GPUTRDTrack.h"
 #include "GPUTRDTrackletWord.h"
@@ -103,7 +103,7 @@ void TRDGlobalTracking::updateTimeDependentParams(ProcessingContext& pc)
     mFlatGeo = std::make_unique<GeometryFlat>(*geo);
 
     GPURecoStepConfiguration cfgRecoStep;
-    cfgRecoStep.steps = GPUDataTypes::RecoStep::NoRecoStep;
+    cfgRecoStep.steps = gpudatatypes::RecoStep::NoRecoStep;
     cfgRecoStep.inputs.clear();
     cfgRecoStep.outputs.clear();
     mRec = GPUReconstruction::CreateInstance("CPU", true);
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
index 0c2489aa4b9c4..98d4154f11dd8 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
@@ -13,7 +13,7 @@
 #define O2_TRK_RECOWORKFLOW_H
 
 #include "Framework/WorkflowSpec.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesConfig.h"
 
 namespace o2::trk
 {
@@ -25,7 +25,7 @@ o2::framework::WorkflowSpec getWorkflow(bool useMC,
                                         bool upstreamClusters = false,
                                         bool disableRootOutput = false,
                                         bool useGPUWF = false,
-                                        o2::gpu::GPUDataTypes::DeviceType dType = o2::gpu::GPUDataTypes::DeviceType::CPU);
+                                        o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
 }
 
 } // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
index 3c82a4fd7b89d..dac1826e21cf6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
@@ -20,7 +20,7 @@
 #include "Framework/Task.h"
 
 #include "ITStracking/TrackingInterface.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesConfig.h"
 
 #include "DetectorsBase/GRPGeomHelper.h"
 
@@ -33,7 +33,7 @@ class TrackerDPL : public framework::Task
  public:
   TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
              bool isMC,
-             gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+             gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
   void init(framework::InitContext& ic) final;
   void run(framework::ProcessingContext& pc) final;
@@ -50,7 +50,7 @@ class TrackerDPL : public framework::Task
   TStopwatch mTimer;
 };
 
-framework::DataProcessorSpec getTrackerSpec(bool useMC, gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
 
 } // namespace o2::trk
-#endif /* O2_TRK_TRACKERDPL */
\ No newline at end of file
+#endif /* O2_TRK_TRACKERDPL */
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
index 3b2b44729b259..09d447a576e48 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
@@ -21,11 +21,11 @@ framework::WorkflowSpec getWorkflow(bool useMC,
                                     bool upstreamClusters,
                                     bool disableRootOutput,
                                     bool useGPUWF,
-                                    o2::gpu::GPUDataTypes::DeviceType dtype)
+                                    o2::gpu::gpudatatypes::DeviceType dtype)
 {
   framework::WorkflowSpec specs;
   specs.emplace_back(o2::trk::getTrackerSpec(useMC, dtype));
   return specs;
 }
 
-} // namespace o2::trk::reco_workflow
\ No newline at end of file
+} // namespace o2::trk::reco_workflow
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
index 4057bab3b948f..868a8acc0fc6e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -25,7 +25,7 @@ using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        bool isMC,
-                       o2::gpu::GPUDataTypes::DeviceType dType)
+                       o2::gpu::gpudatatypes::DeviceType dType)
 {
   // mITSTrackingInterface.setTrackingMode(trMode);
 }
@@ -67,7 +67,7 @@ void TrackerDPL::endOfStream(EndOfStreamContext& ec)
   LOGF(info, "TRK CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTrackerSpec(bool useMC, o2::gpu::GPUDataTypes::DeviceType dType)
+DataProcessorSpec getTrackerSpec(bool useMC, o2::gpu::gpudatatypes::DeviceType dType)
 {
   std::vector<InputSpec> inputs;
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
index 0f75d42710400..8f44b01da1c9c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
@@ -67,7 +67,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // Update the (declared) parameters if changed from the command line
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   auto useGpuWF = configcontext.options().get<bool>("use-gpu-workflow");
-  auto gpuDevice = static_cast<o2::gpu::GPUDataTypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
+  auto gpuDevice = static_cast<o2::gpu::gpudatatypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
   auto extDigits = configcontext.options().get<bool>("digits-from-upstream");
   auto extClusters = configcontext.options().get<bool>("clusters-from-upstream");
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
index 592a34d94a3ca..010e1cd0a8127 100644
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
+++ b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/RecoWorkflow.h
@@ -16,16 +16,14 @@
 
 #include "Framework/WorkflowSpec.h"
 #include "ITStracking/Configuration.h"
-#include "GPUO2Interface.h"
-#include "GPUReconstruction.h"
-#include "GPUChainITS.h"
+#include "GPUDataTypesConfig.h"
 
 namespace o2::its3::reco_workflow
 {
 
 framework::WorkflowSpec getWorkflow(bool useMC,
                                     its::TrackingMode::Type trmode,
-                                    o2::gpu::GPUDataTypes::DeviceType dtype,
+                                    o2::gpu::gpudatatypes::DeviceType dtype,
                                     bool useGPUWorkflow,
                                     bool upstreamDigits,
                                     bool upstreamClusters,
diff --git a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h
index 42f71b6ccebe0..66d58a5f5a92c 100644
--- a/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h
+++ b/Detectors/Upgrades/ITS3/workflow/include/ITS3Workflow/TrackerSpec.h
@@ -23,11 +23,17 @@
 
 #include "ITS3Reconstruction/TrackingInterface.h"
 
-#include "GPUDataTypes.h"
+#include "GPUDataTypesConfig.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 
 #include "TStopwatch.h"
 
+namespace o2::gpu
+{
+class GPUReconstruction;
+class GPUChainITS;
+} // namespace o2::gpu
+
 namespace o2::its3
 {
 
@@ -39,7 +45,7 @@ class TrackerDPL : public framework::Task
              int trgType,
              its::TrackingMode::Type trmode = its::TrackingMode::Unset,
              const bool overrBeamEst = false,
-             gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+             gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
   TrackerDPL(const TrackerDPL&) = delete;
   TrackerDPL(TrackerDPL&&) = delete;
@@ -63,7 +69,7 @@ class TrackerDPL : public framework::Task
 
 /// create a processor spec
 /// run ITS CA tracker
-framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, its::TrackingMode::Type trMode, const bool overrBeamEst = false, gpu::GPUDataTypes::DeviceType dType = gpu::GPUDataTypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, its::TrackingMode::Type trMode, const bool overrBeamEst = false, gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
 
 } // namespace o2::its3
 
diff --git a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
index 8a1c1ef73cf2b..004c3f6097167 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
@@ -26,7 +26,7 @@ static std::shared_ptr<o2::gpu::GPURecoWorkflowSpec> gTask;
 namespace o2::its3::reco_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC, its::TrackingMode::Type trmode, o2::gpu::GPUDataTypes::DeviceType dtype, bool useGPUWorkflow,
+framework::WorkflowSpec getWorkflow(bool useMC, its::TrackingMode::Type trmode, o2::gpu::gpudatatypes::DeviceType dtype, bool useGPUWorkflow,
                                     bool upstreamDigits, bool upstreamClusters, bool disableRootOutput, bool useGeom, int useTrig, bool overrideBeamPosition)
 {
   framework::WorkflowSpec specs;
diff --git a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
index 216056153d095..0326c12f804e0 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
@@ -44,7 +44,7 @@ TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        int trgType,
                        its::TrackingMode::Type trMode,
                        const bool overrBeamEst,
-                       o2::gpu::GPUDataTypes::DeviceType dType) : mGGCCDBRequest(gr),
+                       o2::gpu::gpudatatypes::DeviceType dType) : mGGCCDBRequest(gr),
                                                                   mRecChain{o2::gpu::GPUReconstruction::CreateInstance(dType, true)},
                                                                   mITS3TrackingInterface{isMC, trgType, overrBeamEst}
 {
@@ -88,7 +88,7 @@ void TrackerDPL::endOfStream(EndOfStreamContext& ec)
   LOGF(info, "ITS3 CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, its::TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::GPUDataTypes::DeviceType dType)
+DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, its::TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::gpudatatypes::DeviceType dType)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("compClusters", "ITS", "COMPCLUSTERS", 0, Lifetime::Timeframe);
diff --git a/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
index e4c78b3323a5e..018ad807a974a 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/its3-reco-workflow.cxx
@@ -63,7 +63,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto beamPosOVerride = configcontext.options().get<bool>("ccdb-meanvertex-seed");
   auto trmode = configcontext.options().get<std::string>("tracking-mode");
   auto selTrig = configcontext.options().get<std::string>("select-with-triggers");
-  auto gpuDevice = static_cast<o2::gpu::GPUDataTypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
+  auto gpuDevice = static_cast<o2::gpu::gpudatatypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
   auto extDigits = configcontext.options().get<bool>("digits-from-upstream");
   auto extClusters = configcontext.options().get<bool>("clusters-from-upstream");
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
diff --git a/GPU/GPUTracking/Base/GPUConstantMem.h b/GPU/GPUTracking/Base/GPUConstantMem.h
index c496151c3dfd0..efb83a7e874c8 100644
--- a/GPU/GPUTracking/Base/GPUConstantMem.h
+++ b/GPU/GPUTracking/Base/GPUConstantMem.h
@@ -17,7 +17,7 @@
 
 #include "GPUTPCTracker.h"
 #include "GPUParam.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUErrors.h"
 
 #include "GPUTPCGMMerger.h"
diff --git a/GPU/GPUTracking/Base/GPUGeneralKernels.h b/GPU/GPUTracking/Base/GPUGeneralKernels.h
index eb816c91f5909..871cc21ee2bfa 100644
--- a/GPU/GPUTracking/Base/GPUGeneralKernels.h
+++ b/GPU/GPUTracking/Base/GPUGeneralKernels.h
@@ -16,7 +16,8 @@
 #define GPUGENERALKERNELS_H
 
 #include "GPUDef.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
+#include "GPUDataTypesConfig.h"
 
 #if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_COMPILEKERNELS) && !defined(GPUCA_GPUCODE_HOSTONLY)
 #if defined(__CUDACC__)
@@ -79,7 +80,7 @@ class GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUConstantMem processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::NoRecoStep; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::NoRecoStep; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return &processors;
@@ -94,7 +95,7 @@ class GPUKernelTemplate
 class GPUMemClean16 : public GPUKernelTemplate
 {
  public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::NoRecoStep; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::NoRecoStep; }
   template <int32_t iKernel = defaultKernel>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors, GPUglobalref() void* ptr, uint64_t size);
 };
@@ -103,7 +104,7 @@ class GPUMemClean16 : public GPUKernelTemplate
 class GPUitoa : public GPUKernelTemplate
 {
  public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::NoRecoStep; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::NoRecoStep; }
   template <int32_t iKernel = defaultKernel>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors, GPUglobalref() int32_t* ptr, uint64_t size);
 };
diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index 7095766e8512e..aa4c3c7671c93 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -18,7 +18,7 @@
 #include "GPUCommonMath.h"
 #include "GPUCommonConstants.h"
 #include "GPUTPCGMPolynomialFieldManager.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUConstantMem.h"
 #include "DetectorsBase/Propagator.h"
 #include "GPUTPCGeometry.h"
@@ -127,7 +127,7 @@ void GPUParam::UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessi
     UpdateRun3ClusterErrors(p->param.tpcErrorParamY, p->param.tpcErrorParamZ);
   }
   if (w) {
-    par.dodEdx = dodEdxEnabled = w->steps.isSet(GPUDataTypes::RecoStep::TPCdEdx);
+    par.dodEdx = dodEdxEnabled = w->steps.isSet(gpudatatypes::RecoStep::TPCdEdx);
     if (dodEdxEnabled && p && p->tpcDownscaledEdx != 0) {
       dodEdxEnabled = (rand() % 100) < p->tpcDownscaledEdx;
     }
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index cae7c5025609b..ef336526080b9 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -296,7 +296,7 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
   if (!GetProcessingSettings().createO2Output || !IsGPU()) {
     mProcessingSettings->clearO2OutputFromGPU = false;
   }
-  if (!(mRecoSteps.stepsGPUMask & GPUDataTypes::RecoStep::TPCMerging)) {
+  if (!(mRecoSteps.stepsGPUMask & gpudatatypes::RecoStep::TPCMerging)) {
     mProcessingSettings->mergerSortTracks = false;
   }
   if (GetProcessingSettings().debugLevel > 3 || !IsGPU() || GetProcessingSettings().deterministicGPUReconstruction) {
@@ -902,7 +902,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag, cons
     GPUFatal("Tag mismatch when popping non persistent memory from stack : pop %s vs on stack %s", qTag2Str(tag).c_str(), qTag2Str(std::get<4>(mNonPersistentMemoryStack.back())).c_str());
   }
   if (!proc && (GetProcessingSettings().debugLevel >= 3 || GetProcessingSettings().allocDebugLevel) && (IsGPU() || GetProcessingSettings().forceHostMemoryPoolSize)) {
-    printf("Allocated memory after %30s (%8s) (Stack %zu): ", GPUDataTypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<4>(mNonPersistentMemoryStack.back())).c_str(), mNonPersistentMemoryStack.size());
+    printf("Allocated memory after %30s (%8s) (Stack %zu): ", gpudatatypes::RECO_STEP_NAMES[getRecoStepNum(step, true)], qTag2Str(std::get<4>(mNonPersistentMemoryStack.back())).c_str(), mNonPersistentMemoryStack.size());
     PrintMemoryOverview();
     printf("%76s", "");
     PrintMemoryMax();
@@ -1074,8 +1074,8 @@ constexpr static inline int32_t getStepNum(T step, bool validCheck, int32_t N, c
 } // anonymous namespace
 } // namespace o2::gpu::internal
 
-int32_t GPUReconstruction::getRecoStepNum(RecoStep step, bool validCheck) { return internal::getStepNum(step, validCheck, GPUDataTypes::N_RECO_STEPS, "Invalid Reco Step"); }
-int32_t GPUReconstruction::getGeneralStepNum(GeneralStep step, bool validCheck) { return internal::getStepNum(step, validCheck, GPUDataTypes::N_GENERAL_STEPS, "Invalid General Step"); }
+int32_t GPUReconstruction::getRecoStepNum(RecoStep step, bool validCheck) { return internal::getStepNum(step, validCheck, gpudatatypes::N_RECO_STEPS, "Invalid Reco Step"); }
+int32_t GPUReconstruction::getGeneralStepNum(GeneralStep step, bool validCheck) { return internal::getStepNum(step, validCheck, gpudatatypes::N_GENERAL_STEPS, "Invalid General Step"); }
 
 void GPUReconstruction::RunPipelineWorker()
 {
@@ -1222,7 +1222,7 @@ void GPUReconstruction::UpdateSettings(const GPUSettingsGRP* g, const GPUSetting
     mProcessingSettings->resetTimers = p->resetTimers;
   }
   GPURecoStepConfiguration* w = nullptr;
-  if (mRecoSteps.steps.isSet(GPUDataTypes::RecoStep::TPCdEdx)) {
+  if (mRecoSteps.steps.isSet(gpudatatypes::RecoStep::TPCdEdx)) {
     w = &mRecoSteps;
   }
   param().UpdateSettings(g, p, w, d);
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index fa636fa416538..b5dd29f940143 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -27,7 +27,7 @@
 #include <unordered_set>
 #include <atomic>
 
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUMemoryResource.h"
 #include "GPUOutputControl.h"
 #include "GPUParam.h"
@@ -83,12 +83,12 @@ class GPUReconstruction
   // General definitions
   constexpr static uint32_t NSECTORS = GPUCA_NSECTORS;
 
-  using GeometryType = GPUDataTypes::GeometryType;
-  using DeviceType = GPUDataTypes::DeviceType;
-  using RecoStep = GPUDataTypes::RecoStep;
-  using GeneralStep = GPUDataTypes::GeneralStep;
-  using RecoStepField = GPUDataTypes::RecoStepField;
-  using InOutTypeField = GPUDataTypes::InOutTypeField;
+  using GeometryType = gpudatatypes::GeometryType;
+  using DeviceType = gpudatatypes::DeviceType;
+  using RecoStep = gpudatatypes::RecoStep;
+  using GeneralStep = gpudatatypes::GeneralStep;
+  using RecoStepField = gpudatatypes::RecoStepField;
+  using InOutTypeField = gpudatatypes::InOutTypeField;
 
   static constexpr const char* const GEOMETRY_TYPE_NAMES[] = {"INVALID", "ALIROOT", "O2"};
 #ifdef GPUCA_TPC_GEOMETRY_O2
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 3da96654b895d..409c28b8bf328 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -262,7 +262,7 @@ int32_t GPUReconstructionCPU::RunChains()
     nEventReport += "   (avergage of " + std::to_string(mStatNEvents) + " runs)";
   }
   double kernelTotal = 0;
-  std::vector<double> kernelStepTimes(GPUDataTypes::N_RECO_STEPS, 0.);
+  std::vector<double> kernelStepTimes(gpudatatypes::N_RECO_STEPS, 0.);
 
   if (GetProcessingSettings().debugLevel >= 1) {
     for (uint32_t i = 0; i < mTimers.size(); i++) {
@@ -296,17 +296,17 @@ int32_t GPUReconstructionCPU::RunChains()
     }
   }
   if (GetProcessingSettings().recoTaskTiming) {
-    for (int32_t i = 0; i < GPUDataTypes::N_RECO_STEPS; i++) {
+    for (int32_t i = 0; i < gpudatatypes::N_RECO_STEPS; i++) {
       if (kernelStepTimes[i] != 0. || mTimersRecoSteps[i].timerTotal.GetElapsedTime() != 0.) {
         printf("Execution Time: Step              : %11s %38s Time: %'10.0f us %64s ( Total Time : %'14.0f us, CPU Time : %'14.0f us, %'7.2fx )\n", "Tasks",
-               GPUDataTypes::RECO_STEP_NAMES[i], kernelStepTimes[i] * 1000000 / mStatNEvents, "", mTimersRecoSteps[i].timerTotal.GetElapsedTime() * 1000000 / mStatNEvents, mTimersRecoSteps[i].timerCPU * 1000000 / mStatNEvents, mTimersRecoSteps[i].timerCPU / mTimersRecoSteps[i].timerTotal.GetElapsedTime());
+               gpudatatypes::RECO_STEP_NAMES[i], kernelStepTimes[i] * 1000000 / mStatNEvents, "", mTimersRecoSteps[i].timerTotal.GetElapsedTime() * 1000000 / mStatNEvents, mTimersRecoSteps[i].timerCPU * 1000000 / mStatNEvents, mTimersRecoSteps[i].timerCPU / mTimersRecoSteps[i].timerTotal.GetElapsedTime());
       }
       if (mTimersRecoSteps[i].bytesToGPU) {
-        printf("Execution Time: Step (D %8ux): %11s %38s Time: %'10.0f us (%8.3f GB/s - %'14zu bytes - %'14zu per call)\n", mTimersRecoSteps[i].countToGPU, "DMA to GPU", GPUDataTypes::RECO_STEP_NAMES[i], mTimersRecoSteps[i].timerToGPU.GetElapsedTime() * 1000000 / mStatNEvents,
+        printf("Execution Time: Step (D %8ux): %11s %38s Time: %'10.0f us (%8.3f GB/s - %'14zu bytes - %'14zu per call)\n", mTimersRecoSteps[i].countToGPU, "DMA to GPU", gpudatatypes::RECO_STEP_NAMES[i], mTimersRecoSteps[i].timerToGPU.GetElapsedTime() * 1000000 / mStatNEvents,
                mTimersRecoSteps[i].bytesToGPU / mTimersRecoSteps[i].timerToGPU.GetElapsedTime() * 1e-9, mTimersRecoSteps[i].bytesToGPU / mStatNEvents, mTimersRecoSteps[i].bytesToGPU / mTimersRecoSteps[i].countToGPU);
       }
       if (mTimersRecoSteps[i].bytesToHost) {
-        printf("Execution Time: Step (D %8ux): %11s %38s Time: %'10.0f us (%8.3f GB/s - %'14zu bytes - %'14zu per call)\n", mTimersRecoSteps[i].countToHost, "DMA to Host", GPUDataTypes::RECO_STEP_NAMES[i], mTimersRecoSteps[i].timerToHost.GetElapsedTime() * 1000000 / mStatNEvents,
+        printf("Execution Time: Step (D %8ux): %11s %38s Time: %'10.0f us (%8.3f GB/s - %'14zu bytes - %'14zu per call)\n", mTimersRecoSteps[i].countToHost, "DMA to Host", gpudatatypes::RECO_STEP_NAMES[i], mTimersRecoSteps[i].timerToHost.GetElapsedTime() * 1000000 / mStatNEvents,
                mTimersRecoSteps[i].bytesToHost / mTimersRecoSteps[i].timerToHost.GetElapsedTime() * 1e-9, mTimersRecoSteps[i].bytesToHost / mStatNEvents, mTimersRecoSteps[i].bytesToHost / mTimersRecoSteps[i].countToHost);
       }
       if (GetProcessingSettings().resetTimers) {
@@ -319,9 +319,9 @@ int32_t GPUReconstructionCPU::RunChains()
         mTimersRecoSteps[i].countToHost = 0;
       }
     }
-    for (int32_t i = 0; i < GPUDataTypes::N_GENERAL_STEPS; i++) {
+    for (int32_t i = 0; i < gpudatatypes::N_GENERAL_STEPS; i++) {
       if (mTimersGeneralSteps[i].GetElapsedTime() != 0.) {
-        printf("Execution Time: General Step      : %50s Time: %'10.0f us\n", GPUDataTypes::GENERAL_STEP_NAMES[i], mTimersGeneralSteps[i].GetElapsedTime() * 1000000 / mStatNEvents);
+        printf("Execution Time: General Step      : %50s Time: %'10.0f us\n", gpudatatypes::GENERAL_STEP_NAMES[i], mTimersGeneralSteps[i].GetElapsedTime() * 1000000 / mStatNEvents);
       }
     }
     if (GetProcessingSettings().debugLevel >= 1) {
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h b/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
index 7bf819a74e1b6..0c19941c40ea4 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
@@ -26,8 +26,8 @@ template <class S, int32_t I, typename... Args>
 inline void GPUReconstructionCPU::runKernelInterface(krnlSetup&& setup, Args const&... args)
 {
   HighResTimer* t = nullptr;
-  GPUDataTypes::RecoStep myStep = S::GetRecoStep() == GPUDataTypes::RecoStep::NoRecoStep ? setup.x.step : S::GetRecoStep();
-  if (myStep == GPUDataTypes::RecoStep::NoRecoStep) {
+  gpudatatypes::RecoStep myStep = S::GetRecoStep() == gpudatatypes::RecoStep::NoRecoStep ? setup.x.step : S::GetRecoStep();
+  if (myStep == gpudatatypes::RecoStep::NoRecoStep) {
     throw std::runtime_error("Failure running general kernel without defining RecoStep");
   }
   int32_t cpuFallback = IsGPU() ? (setup.x.device == krnlDeviceType::CPU ? 2 : (mRecoSteps.stepsGPUMask & myStep) != myStep) : 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
index 6bffdc3560d4a..a4b17b81bf5ac 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
@@ -23,7 +23,7 @@
 #include "TPCFastTransform.h"
 #include "GPUTPCClusterData.h"
 #include "GPUO2DataTypes.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUTPCGeometry.h"
 #include "AliHLTTPCRawCluster.h" // VS: It can not be removed. Used in line 93.
 #include "GPUParam.h"
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludes.h b/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
index d3f11d86a731d..4c057521fe6e7 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludes.h
@@ -24,7 +24,7 @@
 
 #include "GPUDef.h"
 #include "GPULogging.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 
 #include <iostream>
 #include <fstream>
diff --git a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
index c70c5d8c51d6f..2e22d4c07e77e 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionLibrary.cxx
@@ -62,15 +62,15 @@ GPUReconstruction* GPUReconstruction::CreateInstance(const GPUSettingsDeviceBack
 
   if (retVal == nullptr) {
     if (cfg.forceDeviceType) {
-      GPUError("Error: Could not load GPUReconstruction for specified device: %s (%u)", GPUDataTypes::DEVICE_TYPE_NAMES[type], cfg.deviceType);
+      GPUError("Error: Could not load GPUReconstruction for specified device: %s (%u)", gpudatatypes::DEVICE_TYPE_NAMES[type], cfg.deviceType);
     } else if (type != DeviceType::CPU) {
-      GPUError("Could not load GPUReconstruction for device type %s (%u), falling back to CPU version", GPUDataTypes::DEVICE_TYPE_NAMES[type], cfg.deviceType);
+      GPUError("Could not load GPUReconstruction for device type %s (%u), falling back to CPU version", gpudatatypes::DEVICE_TYPE_NAMES[type], cfg.deviceType);
       GPUSettingsDeviceBackend cfg2 = cfg;
       cfg2.deviceType = DeviceType::CPU;
       retVal = CreateInstance(cfg2);
     }
   } else {
-    GPUInfo("Created GPUReconstruction instance for device type %s (%u)%s", GPUDataTypes::DEVICE_TYPE_NAMES[type], cfg.deviceType, cfg.master ? " (slave)" : "");
+    GPUInfo("Created GPUReconstruction instance for device type %s (%u)%s", gpudatatypes::DEVICE_TYPE_NAMES[type], cfg.deviceType, cfg.master ? " (slave)" : "");
   }
 
   return retVal;
@@ -107,14 +107,14 @@ std::shared_ptr<GPUReconstruction::LibraryLoader>* GPUReconstruction::GetLibrary
     return nullptr;
   }
   if (verbose) {
-    GPUInfo("%s Support not compiled in for device type %u (%s)", GPUDataTypes::DEVICE_TYPE_NAMES[type], (uint32_t)type, GPUDataTypes::DEVICE_TYPE_NAMES[type]);
+    GPUInfo("%s Support not compiled in for device type %u (%s)", gpudatatypes::DEVICE_TYPE_NAMES[type], (uint32_t)type, gpudatatypes::DEVICE_TYPE_NAMES[type]);
   }
   return nullptr;
 }
 
 GPUReconstruction* GPUReconstruction::CreateInstance(const char* type, bool forceType, GPUReconstruction* master)
 {
-  DeviceType t = GPUDataTypes::GetDeviceType(type);
+  DeviceType t = gpudatatypes::GetDeviceType(type);
   if (t == DeviceType::INVALID_DEVICE) {
     GPUError("Invalid device type: %s", type);
     return nullptr;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index 9e611e57148c6..f582610b57973 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -92,14 +92,14 @@ class GPUReconstructionProcessing : public GPUReconstruction
   };
 
   struct krnlExec {
-    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto) : nBlocks(b), nThreads(t), stream(s), device(d), step(GPUDataTypes::RecoStep::NoRecoStep) {}
-    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUDataTypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(GPUReconstruction::krnlDeviceType::Auto), step(st) {}
-    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(d), step(st) {}
+    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto) : nBlocks(b), nThreads(t), stream(s), device(d), step(gpudatatypes::RecoStep::NoRecoStep) {}
+    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, gpudatatypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(GPUReconstruction::krnlDeviceType::Auto), step(st) {}
+    constexpr krnlExec(uint32_t b, uint32_t t, int32_t s, GPUReconstruction::krnlDeviceType d, gpudatatypes::RecoStep st) : nBlocks(b), nThreads(t), stream(s), device(d), step(st) {}
     uint32_t nBlocks;
     uint32_t nThreads;
     int32_t stream;
     GPUReconstruction::krnlDeviceType device;
-    GPUDataTypes::RecoStep step;
+    gpudatatypes::RecoStep step;
   };
   struct krnlRunRange {
     constexpr krnlRunRange() = default;
@@ -198,10 +198,10 @@ class GPUReconstructionProcessing : public GPUReconstruction
     size_t memSize; // Memory size for memory bandwidth computation
   };
 
-  HighResTimer mTimersGeneralSteps[GPUDataTypes::N_GENERAL_STEPS];
+  HighResTimer mTimersGeneralSteps[gpudatatypes::N_GENERAL_STEPS];
 
   std::vector<std::unique_ptr<timerMeta>> mTimers;
-  RecoStepTimerMeta mTimersRecoSteps[GPUDataTypes::N_RECO_STEPS];
+  RecoStepTimerMeta mTimersRecoSteps[gpudatatypes::N_RECO_STEPS];
   HighResTimer mTimerTotal;
   template <class T, int32_t I = 0>
   HighResTimer& getKernelTimer(RecoStep step, int32_t num = 0, size_t addMemorySize = 0, bool increment = true);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.h b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.h
index 47cbfa0a1a5b6..14fc949240a7f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.h
@@ -16,7 +16,7 @@
 #define GPURECONSTRUCTIONTIMEFRAME_H
 
 #include "GPUChainTracking.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUTPCGeometry.h"
 #include <vector>
 #include <random>
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 6dd718f07a9f1..6a60eb9edd6d0 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -64,11 +64,11 @@ set(SRCS
     TRDTracking/GPUTRDTrackerKernels.cxx
     Base/GPUParam.cxx)
 
-set(SRCS_DATATYPES DataTypes/GPUDataTypes.cxx DataTypes/GPUConfigDump.cxx DataTypes/GPUTPCGMPolynomialField.cxx)
+set(SRCS_DATATYPES DataTypes/GPUDataTypesConfig.cxx DataTypes/GPUConfigDump.cxx DataTypes/GPUTPCGMPolynomialField.cxx)
 
 set(HDRS_CINT_O2 Merger/GPUTPCGMTrackParam.h Merger/GPUTPCGMMergedTrack.h Merger/GPUTPCGMSectorTrack.h Merger/GPUTPCGMBorderTrack.h TRDTracking/GPUTRDInterfaces.h)
 set(HDRS_CINT_DATATYPES DataTypes/GPUTPCGMMergedTrackHit.h)
-set(HDRS_CINT_O2_ADDITIONAL DataTypes/GPUSettings.h Definitions/GPUSettingsList.h DataTypes/GPUDataTypes.h DataTypes/GPUTRDTrack.h DataTypes/CalibdEdxTrackTopologyPol.h DataTypes/CalibdEdxTrackTopologySpline.h) # Manual dependencies for ROOT dictionary generation
+set(HDRS_CINT_O2_ADDITIONAL DataTypes/GPUSettings.h Definitions/GPUSettingsList.h DataTypes/GPUDataTypesIO.h DataTypes/GPUDataTypesConfig.h DataTypes/GPUDataTypesQA.h DataTypes/GPUTRDTrack.h DataTypes/CalibdEdxTrackTopologyPol.h DataTypes/CalibdEdxTrackTopologySpline.h) # Manual dependencies for ROOT dictionary generation
 
 set(SRCS_NO_CINT
     DataTypes/GPUMemorySizeScalers.cxx
@@ -107,6 +107,9 @@ set(SRCS_NO_H SectorTracker/GPUTPCTrackerDump.cxx
               Global/GPUChainTrackingIO.cxx)
 
 set(HDRS_INSTALL
+    ${HDRS_CINT_O2}
+    ${HDRS_CINT_DATATYPES}
+    ${HDRS_CINT_O2_ADDITIONAL}
     Base/GPUConstantMem.h
     Base/GPUParam.inc
     Base/GPUParamRTC.h
@@ -123,9 +126,7 @@ set(HDRS_INSTALL
     DataTypes/GPUHostDataTypes.h
     DataTypes/GPUO2DataTypes.h
     DataTypes/GPUOutputControl.h
-    DataTypes/GPUSettings.h
     DataTypes/GPUTPCGeometry.h
-    DataTypes/GPUTPCGMMergedTrackHit.h
     DataTypes/GPUTRDDef.h
     DataTypes/GPUTRDInterfaceO2Track.h
     DataTypes/GPUTriggerOutputs.h
@@ -139,13 +140,10 @@ set(HDRS_INSTALL
     Definitions/GPUDef.h
     Definitions/GPUDefMacros.h
     Definitions/GPULogging.h
-    Definitions/GPUSettingsList.h
     Global/GPUChainTrackingDefs.h
     Global/GPUChainTrackingDebug.h
     Global/GPUChainTrackingGetters.inc
     Global/GPUErrorCodes.h
-    Merger/GPUTPCGMBorderTrack.h
-    Merger/GPUTPCGMMergedTrack.h
     Merger/GPUTPCGMMergerTypes.h
     qa/GPUQAHelper.h
     qconfigoptions.h
@@ -160,7 +158,6 @@ set(HDRS_INSTALL
     SectorTracker/GPUTPCTrackLinearisation.h
     TPCConvert/GPUTPCConvertImpl.h
     TRDTracking/GPUTRDGeometry.h
-    TRDTracking/GPUTRDInterfaces.h
     TRDTracking/GPUTRDSpacePoint.h
     TRDTracking/GPUTRDTrackData.h
     TRDTracking/GPUTRDTrackerDebug.h
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index 85cd9598e0bf1..efb7a4af3f323 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -38,7 +38,7 @@ void* GPUTPCCompression::SetPointersOutputHost(void* mem)
 
 void* GPUTPCCompression::SetPointersScratch(void* mem)
 {
-  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   computePointerWithAlignment(mem, mClusterStatus, mMaxClusters);
   if (gatherMode >= 2) {
     computePointerWithAlignment(mem, mAttachedClusterFirstIndex, mMaxTracks);
@@ -51,7 +51,7 @@ void* GPUTPCCompression::SetPointersScratch(void* mem)
 
 void* GPUTPCCompression::SetPointersOutput(void* mem)
 {
-  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   computePointerWithAlignment(mem, mAttachedClusterFirstIndex, mMaxTrackClusters);
   if (gatherMode == 1) {
     SetPointersCompressedClusters(mem, mPtrs, mMaxTrackClusters, mMaxTracks, mMaxClustersInCache, false);
@@ -106,7 +106,7 @@ void* GPUTPCCompression::SetPointersMemory(void* mem)
 void GPUTPCCompression::RegisterMemoryAllocation()
 {
   AllocateAndInitializeLate();
-  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   mMemoryResOutputHost = mRec->RegisterMemoryAllocation(this, &GPUTPCCompression::SetPointersOutputHost, GPUMemoryResource::MEMORY_OUTPUT_FLAG | GPUMemoryResource::MEMORY_HOST | GPUMemoryResource::MEMORY_CUSTOM, "TPCCompressionOutputHost");
   if (gatherMode == 3) {
     mMemoryResOutputGPU = mRec->RegisterMemoryAllocation(this, &GPUTPCCompression::SetPointersOutputGPU, GPUMemoryResource::MEMORY_SCRATCH | GPUMemoryResource::MEMORY_GPU | GPUMemoryResource::MEMORY_CUSTOM | GPUMemoryResource::MEMORY_STACK, "TPCCompressionOutputGPU");
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
index 81817abf1e6d6..2236f15af9725 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
@@ -27,7 +27,7 @@ namespace o2::gpu
 class GPUTPCCompressionKernels : public GPUKernelTemplate
 {
  public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCCompression; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCCompression; }
 
   enum K : int32_t {
     step0attached = 0,
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
index 1ea93e4acb9d0..2140cfbe5166d 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
@@ -27,7 +27,7 @@ namespace o2::gpu
 class GPUTPCDecompressionKernels : public GPUKernelTemplate
 {
  public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCDecompression; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCDecompression; }
 
   enum K : int32_t {
     step0attached = 0,
diff --git a/GPU/GPUTracking/DataTypes/GPUConfigDump.cxx b/GPU/GPUTracking/DataTypes/GPUConfigDump.cxx
index 7ec2df3a2f186..56543d5f2e43d 100644
--- a/GPU/GPUTracking/DataTypes/GPUConfigDump.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUConfigDump.cxx
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 #include "GPUConfigDump.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUSettings.h"
 
 #include <functional>
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.cxx b/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.cxx
similarity index 73%
rename from GPU/GPUTracking/DataTypes/GPUDataTypes.cxx
rename to GPU/GPUTracking/DataTypes/GPUDataTypesConfig.cxx
index c544ac610cdfa..80ca919dd29e1 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.cxx
@@ -9,19 +9,15 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUDataTypes.cxx
+/// \file GPUDataTypesConfig.cxx
 /// \author David Rohr
 
-#include "GPUDataTypes.h"
+#include "GPUDataTypesConfig.h"
 #include <cstring>
 
 using namespace o2::gpu;
 
-constexpr const char* const GPUDataTypes::DEVICE_TYPE_NAMES[];
-constexpr const char* const GPUDataTypes::RECO_STEP_NAMES[];
-constexpr const char* const GPUDataTypes::GENERAL_STEP_NAMES[];
-
-GPUDataTypes::DeviceType GPUDataTypes::GetDeviceType(const char* type)
+gpudatatypes::DeviceType gpudatatypes::GetDeviceType(const char* type)
 {
   for (uint32_t i = 1; i < sizeof(DEVICE_TYPE_NAMES) / sizeof(DEVICE_TYPE_NAMES[0]); i++) {
     if (strcmp(DEVICE_TYPE_NAMES[i], type) == 0) {
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.h b/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.h
new file mode 100644
index 0000000000000..6535bb93770c4
--- /dev/null
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesConfig.h
@@ -0,0 +1,80 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDataTypesConfig.h
+/// \author David Rohr
+
+#ifndef GPUDATATYPESCONFIG_H
+#define GPUDATATYPESCONFIG_H
+
+#include "GPUCommonDef.h"
+
+// These are basic and non-complex data types, which will also be visible on the GPU.
+// Please add complex data types required on the host but not GPU to GPUHostDataTypes.h and forward-declare!
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits> // for bitfield below
+#include <cstddef>
+#endif
+
+namespace o2::gpu
+{
+#include "utils/bitfield.h"
+
+namespace gpudatatypes
+{
+// clang-format off
+enum class GeometryType : uint32_t { RESERVED_GEOMETRY = 0, ALIROOT = 1, O2 = 2 };
+enum DeviceType : uint32_t { INVALID_DEVICE = 0, CPU = 1, CUDA = 2, HIP = 3, OCL = 4 };
+enum class GeneralStep : uint32_t { Prepare = 1, QA = 2 };
+// clang-format on
+
+enum class RecoStep : uint32_t { TPCConversion = 1,
+                                 TPCSectorTracking = 2,
+                                 TPCMerging = 4,
+                                 TPCCompression = 8,
+                                 TRDTracking = 16,
+                                 ITSTracking = 32,
+                                 TPCdEdx = 64,
+                                 TPCClusterFinding = 128,
+                                 TPCDecompression = 256,
+                                 Refit = 512,
+                                 AllRecoSteps = 0x7FFFFFFF,
+                                 NoRecoStep = 0 };
+enum class InOutType : uint32_t { TPCClusters = 1,
+                                  OBSOLETE = 2,
+                                  TPCMergedTracks = 4,
+                                  TPCCompressedClusters = 8,
+                                  TRDTracklets = 16,
+                                  TRDTracks = 32,
+                                  TPCRaw = 64,
+                                  ITSClusters = 128,
+                                  ITSTracks = 256 };
+#ifndef __OPENCL__
+static constexpr const char* const DEVICE_TYPE_NAMES[] = {"INVALID", "CPU", "CUDA", "HIP", "OCL"};
+static constexpr const char* const RECO_STEP_NAMES[] = {"TPC Transformation", "TPC Sector Tracking", "TPC Track Merging and Fit", "TPC Compression", "TRD Tracking", "ITS Tracking", "TPC dEdx Computation", "TPC Cluster Finding", "TPC Decompression", "Global Refit"};
+static constexpr const char* const GENERAL_STEP_NAMES[] = {"Prepare", "QA"};
+constexpr static int32_t N_RECO_STEPS = sizeof(gpudatatypes::RECO_STEP_NAMES) / sizeof(gpudatatypes::RECO_STEP_NAMES[0]);
+constexpr static int32_t N_GENERAL_STEPS = sizeof(gpudatatypes::GENERAL_STEP_NAMES) / sizeof(gpudatatypes::GENERAL_STEP_NAMES[0]);
+#endif
+typedef bitfield<RecoStep, uint32_t> RecoStepField;
+typedef bitfield<InOutType, uint32_t> InOutTypeField;
+DeviceType GetDeviceType(const char* type);
+} // namespace gpudatatypes
+
+struct GPURecoStepConfiguration {
+  gpudatatypes::RecoStepField steps = 0;
+  gpudatatypes::RecoStepField stepsGPUMask = gpudatatypes::RecoStep::AllRecoSteps;
+  gpudatatypes::InOutTypeField inputs = 0;
+  gpudatatypes::InOutTypeField outputs = 0;
+};
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypes.h b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
similarity index 74%
rename from GPU/GPUTracking/DataTypes/GPUDataTypes.h
rename to GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
index 8bf8084e048fd..fd98cba1dadaa 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypes.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
@@ -9,18 +9,17 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUDataTypes.h
+/// \file GPUDataTypesIO.h
 /// \author David Rohr
 
-#ifndef GPUDATATYPES_H
-#define GPUDATATYPES_H
+#ifndef GPUDATATYPESIO_H
+#define GPUDATATYPESIO_H
 
 #include "GPUCommonDef.h"
 
 // These are basic and non-complex data types, which will also be visible on the GPU.
 // Please add complex data types required on the host but not GPU to GPUHostDataTypes.h and forward-declare!
 #ifndef GPUCA_GPUCODE_DEVICE
-#include <type_traits> // for bitfield below
 #include <cstddef>
 #endif
 #include "GPUTRDDef.h"
@@ -96,8 +95,6 @@ class TPCFastTransform;
 struct TPCPadGainCalib;
 struct TPCZSLinkMapping;
 
-#include "utils/bitfield.h"
-
 class GPUTPCTrack;
 class GPUTPCHitId;
 class GPUTPCGMMergedTrack;
@@ -111,55 +108,10 @@ struct GPUTRDTrackletLabels;
 struct GPUTPCDigitsMCInput;
 struct GPUSettingsTF;
 
-class GPUDataTypes
+namespace gpudatatypes
 {
- public:
-  // clang-format off
-  enum class GeometryType : uint32_t { RESERVED_GEOMETRY = 0, ALIROOT = 1, O2 = 2 };
-  enum DeviceType : uint32_t { INVALID_DEVICE = 0, CPU = 1, CUDA = 2, HIP = 3, OCL = 4 };
-  enum class GeneralStep { Prepare = 1, QA = 2 };
-  // clang-format on
-
-  enum class RecoStep { TPCConversion = 1,
-                        TPCSectorTracking = 2,
-                        TPCMerging = 4,
-                        TPCCompression = 8,
-                        TRDTracking = 16,
-                        ITSTracking = 32,
-                        TPCdEdx = 64,
-                        TPCClusterFinding = 128,
-                        TPCDecompression = 256,
-                        Refit = 512,
-                        AllRecoSteps = 0x7FFFFFFF,
-                        NoRecoStep = 0 };
-  enum class InOutType { TPCClusters = 1,
-                         OBSOLETE = 2,
-                         TPCMergedTracks = 4,
-                         TPCCompressedClusters = 8,
-                         TRDTracklets = 16,
-                         TRDTracks = 32,
-                         TPCRaw = 64,
-                         ITSClusters = 128,
-                         ITSTracks = 256 };
-#ifndef __OPENCL__
-  static constexpr const char* const DEVICE_TYPE_NAMES[] = {"INVALID", "CPU", "CUDA", "HIP", "OCL"};
-  static constexpr const char* const RECO_STEP_NAMES[] = {"TPC Transformation", "TPC Sector Tracking", "TPC Track Merging and Fit", "TPC Compression", "TRD Tracking", "ITS Tracking", "TPC dEdx Computation", "TPC Cluster Finding", "TPC Decompression", "Global Refit"};
-  static constexpr const char* const GENERAL_STEP_NAMES[] = {"Prepare", "QA"};
-  constexpr static int32_t N_RECO_STEPS = sizeof(GPUDataTypes::RECO_STEP_NAMES) / sizeof(GPUDataTypes::RECO_STEP_NAMES[0]);
-  constexpr static int32_t N_GENERAL_STEPS = sizeof(GPUDataTypes::GENERAL_STEP_NAMES) / sizeof(GPUDataTypes::GENERAL_STEP_NAMES[0]);
-#endif
-  typedef bitfield<RecoStep, uint32_t> RecoStepField;
-  typedef bitfield<InOutType, uint32_t> InOutTypeField;
-  static constexpr uint32_t NSECTORS = 36;
-  static DeviceType GetDeviceType(const char* type);
-};
-
-struct GPURecoStepConfiguration {
-  GPUDataTypes::RecoStepField steps = 0;
-  GPUDataTypes::RecoStepField stepsGPUMask = GPUDataTypes::RecoStep::AllRecoSteps;
-  GPUDataTypes::InOutTypeField inputs = 0;
-  GPUDataTypes::InOutTypeField outputs = 0;
-};
+static constexpr uint32_t NSECTORS = 36;
+} // namespace gpudatatypes
 
 template <class T>
 struct DefaultPtr {
@@ -191,7 +143,7 @@ typedef GPUCalibObjectsTemplate<DefaultPtr> GPUCalibObjects; // NOTE: These 2 mu
 typedef GPUCalibObjectsTemplate<ConstPtr> GPUCalibObjectsConst;
 
 struct GPUTrackingInOutZS {
-  static constexpr uint32_t NSECTORS = GPUDataTypes::NSECTORS;
+  static constexpr uint32_t NSECTORS = gpudatatypes::NSECTORS;
   static constexpr uint32_t NENDPOINTS = 20;
   struct GPUTrackingInOutZSSector {
     const void* const* zsPtr[NENDPOINTS];
@@ -209,7 +161,7 @@ struct GPUTrackingInOutZS {
 };
 
 struct GPUTrackingInOutDigits {
-  static constexpr uint32_t NSECTORS = GPUDataTypes::NSECTORS;
+  static constexpr uint32_t NSECTORS = gpudatatypes::NSECTORS;
   const o2::tpc::Digit* tpcDigits[NSECTORS] = {nullptr};
   size_t nTPCDigits[NSECTORS] = {0};
   const GPUTPCDigitsMCInput* tpcDigitsMC = nullptr;
@@ -219,7 +171,7 @@ struct GPUTrackingInOutPointers {
   GPUTrackingInOutPointers() = default;
 
   // TPC
-  static constexpr uint32_t NSECTORS = GPUDataTypes::NSECTORS;
+  static constexpr uint32_t NSECTORS = gpudatatypes::NSECTORS;
   const GPUTrackingInOutZS* tpcZS = nullptr;
   const GPUTrackingInOutDigits* tpcPackedDigits = nullptr;
   const GPUTPCClusterData* clusterData[NSECTORS] = {nullptr};
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypesQA.h b/GPU/GPUTracking/DataTypes/GPUDataTypesQA.h
new file mode 100644
index 0000000000000..6ec6de0ed4a57
--- /dev/null
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesQA.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUDataTypesIO.h
+/// \author David Rohr
+
+#ifndef GPUDATATYPESQA_H
+#define GPUDATATYPESQA_H
+
+#include "GPUCommonDef.h"
+
+#include <cstddef>
+
+namespace o2::gpu::gpudatatypes::gpuqa
+{
+enum gpuQATaskIds : int32_t {
+  tasksNone = 0,
+  taskTrackingEff = 1,
+  taskTrackingRes = 2,
+  taskTrackingResPull = 4,
+  taskClusterAttach = 8,
+  tasksAllMC = 16 - 1,
+  taskTrackStatistics = 16,
+  taskClusterCounts = 32,
+  taskClusterRejection = 64,
+  tasksAll = 128 - 1,
+  tasksDefault = tasksAll,
+  tasksDefaultPostprocess = tasksDefault & ~taskClusterCounts,
+  tasksAllNoQC = tasksAll & ~tasksAllMC,
+  tasksAutomatic = -1
+};
+} // namespace o2::gpu::gpudatatypes::gpuqa
+
+#endif
diff --git a/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
index f5b3ea8b285f5..60fdbe8042c2d 100644
--- a/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
@@ -14,7 +14,7 @@
 
 #include "GPUO2ConfigurableParam.h"
 #include "Interface/GPUO2InterfaceConfiguration.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUConfigDump.h"
 
 using namespace o2::gpu;
@@ -122,7 +122,7 @@ GPUSettingsO2 GPUO2InterfaceConfiguration::ReadConfigurableParam(GPUO2InterfaceC
   if (obj.configReconstruction.tpc.trackReferenceX == 1000.f) {
     obj.configReconstruction.tpc.trackReferenceX = 83.f;
   }
-  obj.configDeviceBackend.deviceType = GPUDataTypes::GetDeviceType(global.deviceType.c_str());
+  obj.configDeviceBackend.deviceType = gpudatatypes::GetDeviceType(global.deviceType.c_str());
   obj.configDeviceBackend.forceDeviceType = global.forceDeviceType;
   return global;
 }
diff --git a/GPU/GPUTracking/DataTypes/GPUSettings.h b/GPU/GPUTracking/DataTypes/GPUSettings.h
index 9e3a3e9bd6ce8..34b378b046aec 100644
--- a/GPU/GPUTracking/DataTypes/GPUSettings.h
+++ b/GPU/GPUTracking/DataTypes/GPUSettings.h
@@ -16,7 +16,7 @@
 #define GPUSETTINGS_H
 
 #include "GPUCommonDef.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesConfig.h"
 #include "GPUTPCGMMergedTrackHit.h"
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <vector>
@@ -73,7 +73,7 @@ struct GPUSettingsTF {
 
 // Settings defining the setup of the GPUReconstruction processing (basically selecting the device / class instance)
 struct GPUSettingsDeviceBackend {
-  uint32_t deviceType = GPUDataTypes::DeviceType::CPU; // Device type, shall use GPUDataTypes::DEVICE_TYPE constants, e.g. CPU / CUDA
+  uint32_t deviceType = gpudatatypes::DeviceType::CPU; // Device type, shall use gpudatatypes::DEVICE_TYPE constants, e.g. CPU / CUDA
   uint8_t forceDeviceType = 1;                         // Fail if device initialization fails, otherwise falls back to CPU
   GPUReconstruction* master = nullptr;                 // GPUReconstruction master object
 };
diff --git a/GPU/GPUTracking/Global/GPUChain.cxx b/GPU/GPUTracking/Global/GPUChain.cxx
index 300de31a509ba..fe0cf59c6c28e 100644
--- a/GPU/GPUTracking/Global/GPUChain.cxx
+++ b/GPU/GPUTracking/Global/GPUChain.cxx
@@ -18,33 +18,33 @@ using namespace o2::gpu;
 constexpr GPUChain::krnlRunRange GPUChain::krnlRunRangeNone;
 constexpr GPUChain::krnlEvent GPUChain::krnlEventNone;
 
-GPUChain::krnlExec GPUChain::GetGrid(uint32_t totalItems, uint32_t nThreads, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st)
+GPUChain::krnlExec GPUChain::GetGrid(uint32_t totalItems, uint32_t nThreads, int32_t stream, GPUReconstruction::krnlDeviceType d, gpudatatypes::RecoStep st)
 {
   const uint32_t nBlocks = (totalItems + nThreads - 1) / nThreads;
   return {nBlocks, nThreads, stream, d, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGrid(uint32_t totalItems, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st)
+GPUChain::krnlExec GPUChain::GetGrid(uint32_t totalItems, int32_t stream, GPUReconstruction::krnlDeviceType d, gpudatatypes::RecoStep st)
 {
   return {(uint32_t)-1, totalItems, stream, d, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGridBlk(uint32_t nBlocks, int32_t stream, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st)
+GPUChain::krnlExec GPUChain::GetGridBlk(uint32_t nBlocks, int32_t stream, GPUReconstruction::krnlDeviceType d, gpudatatypes::RecoStep st)
 {
   return {(uint32_t)-2, nBlocks, stream, d, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGridBlkStep(uint32_t nBlocks, int32_t stream, GPUDataTypes::RecoStep st)
+GPUChain::krnlExec GPUChain::GetGridBlkStep(uint32_t nBlocks, int32_t stream, gpudatatypes::RecoStep st)
 {
   return {(uint32_t)-2, nBlocks, stream, GPUReconstruction::krnlDeviceType::Auto, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d, GPUDataTypes::RecoStep st)
+GPUChain::krnlExec GPUChain::GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d, gpudatatypes::RecoStep st)
 {
   return {(uint32_t)-3, 0, stream, d, st};
 }
 
-GPUChain::krnlExec GPUChain::GetGridAutoStep(int32_t stream, GPUDataTypes::RecoStep st)
+GPUChain::krnlExec GPUChain::GetGridAutoStep(int32_t stream, gpudatatypes::RecoStep st)
 {
   return {(uint32_t)-3, 0, stream, GPUReconstruction::krnlDeviceType::Auto, st};
 }
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index 6831fbd15080a..907ed7ea97c12 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -200,15 +200,15 @@ class GPUChain
     return mRec->getTimer<T, J>(name, num);
   }
   // Get GRID with NBLOCKS minimal such that nThreads * NBLOCS >= totalItems
-  krnlExec GetGrid(uint32_t totalItems, uint32_t nThreads, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
+  krnlExec GetGrid(uint32_t totalItems, uint32_t nThreads, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, gpudatatypes::RecoStep st = gpudatatypes::RecoStep::NoRecoStep);
   // Get GRID with NBLOCKS minimal such that ideal number of threads * NBLOCKS >= totalItems
-  krnlExec GetGrid(uint32_t totalItems, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
+  krnlExec GetGrid(uint32_t totalItems, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, gpudatatypes::RecoStep st = gpudatatypes::RecoStep::NoRecoStep);
   // Get GRID with specified number of blocks, each block with ideal number of threads
-  krnlExec GetGridBlk(uint32_t nBlocks, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
-  krnlExec GetGridBlkStep(uint32_t nBlocks, int32_t stream, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
+  krnlExec GetGridBlk(uint32_t nBlocks, int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, gpudatatypes::RecoStep st = gpudatatypes::RecoStep::NoRecoStep);
+  krnlExec GetGridBlkStep(uint32_t nBlocks, int32_t stream, gpudatatypes::RecoStep st = gpudatatypes::RecoStep::NoRecoStep);
   // Get GRID with ideal number of threads / blocks for GPU
-  krnlExec GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
-  krnlExec GetGridAutoStep(int32_t stream, GPUDataTypes::RecoStep st = GPUDataTypes::RecoStep::NoRecoStep);
+  krnlExec GetGridAuto(int32_t stream, GPUReconstruction::krnlDeviceType d = GPUReconstruction::krnlDeviceType::Auto, gpudatatypes::RecoStep st = gpudatatypes::RecoStep::NoRecoStep);
+  krnlExec GetGridAutoStep(int32_t stream, gpudatatypes::RecoStep st = gpudatatypes::RecoStep::NoRecoStep);
 
   inline uint32_t BlockCount() const { return mRec->mMultiprocessorCount; }
   inline uint32_t WarpSize() const { return mRec->mWarpSize; }
diff --git a/GPU/GPUTracking/Global/GPUChainITS.cxx b/GPU/GPUTracking/Global/GPUChainITS.cxx
index c72023bdf42ce..598f7a61cac1a 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.cxx
+++ b/GPU/GPUTracking/Global/GPUChainITS.cxx
@@ -36,7 +36,7 @@ class GPUFrameworkExternalAllocator final : public o2::its::ExternalAllocator
   }
   void popTagOffStack(uint64_t tag) final
   {
-    mFWReco->PopNonPersistentMemory(GPUDataTypes::RecoStep::ITSTracking, tag);
+    mFWReco->PopNonPersistentMemory(gpudatatypes::RecoStep::ITSTracking, tag);
   }
   void setReconstructionFramework(o2::gpu::GPUReconstruction* fwr) { mFWReco = fwr; }
 
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 8a0d45a33ca93..f370b756e2cdb 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -168,78 +168,78 @@ void GPUChainTracking::MemorySize(size_t& gpuMem, size_t& pageLockedHostMem)
 
 bool GPUChainTracking::ValidateSteps()
 {
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCdEdx) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging)) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCdEdx) && !(GetRecoSteps() & gpudatatypes::RecoStep::TPCMerging)) {
     GPUError("Invalid Reconstruction Step Setting: dEdx requires TPC Merger to be active");
     return false;
   }
-  if ((GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCdEdx) && !(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCMerging)) {
+  if ((GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCdEdx) && !(GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCMerging)) {
     GPUError("Invalid GPU Reconstruction Step Setting: dEdx requires TPC Merger to be active");
     return false;
   }
-  if (((GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging)) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCConversion)) {
+  if (((GetRecoSteps() & gpudatatypes::RecoStep::TPCSectorTracking) || (GetRecoSteps() & gpudatatypes::RecoStep::TPCMerging)) && !(GetRecoSteps() & gpudatatypes::RecoStep::TPCConversion)) {
     GPUError("Invalid Reconstruction Step Setting: Tracking requires TPC Conversion to be active");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) && !(GetRecoStepsInputs() & GPUDataTypes::InOutType::TPCRaw)) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCClusterFinding) && !(GetRecoStepsInputs() & gpudatatypes::InOutType::TPCRaw)) {
     GPUError("Invalid input, TPC Clusterizer needs TPC raw input");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCConversion)) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCMerging) && !(GetRecoSteps() & gpudatatypes::RecoStep::TPCConversion)) {
     GPUError("Invalid input / output / step, merger cannot read/store sectors tracks and needs TPC conversion");
     return false;
   }
-  bool tpcClustersAvail = (GetRecoStepsInputs() & GPUDataTypes::InOutType::TPCClusters) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCDecompression);
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && !tpcClustersAvail) {
+  bool tpcClustersAvail = (GetRecoStepsInputs() & gpudatatypes::InOutType::TPCClusters) || (GetRecoSteps() & gpudatatypes::RecoStep::TPCClusterFinding) || (GetRecoSteps() & gpudatatypes::RecoStep::TPCDecompression);
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCMerging) && !tpcClustersAvail) {
     GPUError("Invalid Inputs for track merging, TPC Clusters required");
     return false;
   }
 #ifndef GPUCA_TPC_GEOMETRY_O2
-  if (GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) {
+  if (GetRecoSteps() & gpudatatypes::RecoStep::TPCClusterFinding) {
     GPUError("Can not run TPC GPU Cluster Finding with Run 2 Data");
     return false;
   }
 #endif
-  if (((GetRecoSteps() & GPUDataTypes::RecoStep::TPCConversion) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCCompression) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCdEdx)) && !tpcClustersAvail) {
+  if (((GetRecoSteps() & gpudatatypes::RecoStep::TPCConversion) || (GetRecoSteps() & gpudatatypes::RecoStep::TPCSectorTracking) || (GetRecoSteps() & gpudatatypes::RecoStep::TPCCompression) || (GetRecoSteps() & gpudatatypes::RecoStep::TPCdEdx)) && !tpcClustersAvail) {
     GPUError("Missing input for TPC Cluster conversion / sector tracking / compression / dEdx: TPC Clusters required");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking)) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCMerging) && !(GetRecoSteps() & gpudatatypes::RecoStep::TPCSectorTracking)) {
     GPUError("Input for TPC merger missing");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCCompression) && !((GetRecoStepsInputs() & GPUDataTypes::InOutType::TPCMergedTracks) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging))) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCCompression) && !((GetRecoStepsInputs() & gpudatatypes::InOutType::TPCMergedTracks) || (GetRecoSteps() & gpudatatypes::RecoStep::TPCMerging))) {
     GPUError("Input for TPC compressor missing");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TRDTracking) && (!((GetRecoStepsInputs() & GPUDataTypes::InOutType::TPCMergedTracks) || (GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging)) || !(GetRecoStepsInputs() & GPUDataTypes::InOutType::TRDTracklets))) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TRDTracking) && (!((GetRecoStepsInputs() & gpudatatypes::InOutType::TPCMergedTracks) || (GetRecoSteps() & gpudatatypes::RecoStep::TPCMerging)) || !(GetRecoStepsInputs() & gpudatatypes::InOutType::TRDTracklets))) {
     GPUError("Input for TRD Tracker missing");
     return false;
   }
-  if ((GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCRaw) || (GetRecoStepsOutputs() & GPUDataTypes::InOutType::TRDTracklets)) {
+  if ((GetRecoStepsOutputs() & gpudatatypes::InOutType::TPCRaw) || (GetRecoStepsOutputs() & gpudatatypes::InOutType::TRDTracklets)) {
     GPUError("TPC Raw / TPC Clusters / TRD Tracklets cannot be output");
     return false;
   }
-  if ((GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCMergedTracks) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCMerging)) {
+  if ((GetRecoStepsOutputs() & gpudatatypes::InOutType::TPCMergedTracks) && !(GetRecoSteps() & gpudatatypes::RecoStep::TPCMerging)) {
     GPUError("No TPC Merged Track Output available");
     return false;
   }
-  if ((GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCCompressedClusters) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCCompression)) {
+  if ((GetRecoStepsOutputs() & gpudatatypes::InOutType::TPCCompressedClusters) && !(GetRecoSteps() & gpudatatypes::RecoStep::TPCCompression)) {
     GPUError("No TPC Compression Output available");
     return false;
   }
-  if ((GetRecoStepsOutputs() & GPUDataTypes::InOutType::TRDTracks) && !(GetRecoSteps() & GPUDataTypes::RecoStep::TRDTracking)) {
+  if ((GetRecoStepsOutputs() & gpudatatypes::InOutType::TRDTracks) && !(GetRecoSteps() & gpudatatypes::RecoStep::TRDTracking)) {
     GPUError("No TRD Tracker Output available");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCdEdx) && (processors()->calibObjects.dEdxCalibContainer == nullptr)) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCdEdx) && (processors()->calibObjects.dEdxCalibContainer == nullptr)) {
     GPUError("Cannot run dE/dx without dE/dx calibration container object");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) && processors()->calibObjects.tpcPadGain == nullptr) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCClusterFinding) && processors()->calibObjects.tpcPadGain == nullptr) {
     GPUError("Cannot run gain calibration without calibration object");
     return false;
   }
-  if ((GetRecoSteps() & GPUDataTypes::RecoStep::TPCClusterFinding) && processors()->calibObjects.tpcZSLinkMapping == nullptr && mIOPtrs.tpcZS != nullptr) {
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TPCClusterFinding) && processors()->calibObjects.tpcZSLinkMapping == nullptr && mIOPtrs.tpcZS != nullptr) {
     GPUError("Cannot run TPC ZS Decoder without mapping object. (tpczslinkmapping.dump missing?)");
     return false;
   }
@@ -248,7 +248,7 @@ bool GPUChainTracking::ValidateSteps()
 
 bool GPUChainTracking::ValidateSettings()
 {
-  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
+  int32_t gatherMode = mRec->GetProcessingSettings().tpcCompressionGatherMode == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression).par_COMP_GATHER_MODE : mRec->GetProcessingSettings().tpcCompressionGatherMode;
   if ((param().rec.tpc.nWays & 1) == 0) {
     GPUError("nWay setting musst be odd number!");
     return false;
@@ -265,7 +265,7 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("NStreams of %d insufficient for %d nTPCClustererLanes", mRec->NStreams(), (int32_t)GetProcessingSettings().nTPCClustererLanes);
     return false;
   }
-  if ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && GetProcessingSettings().noGPUMemoryRegistration && gatherMode != 3) {
+  if ((mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression) && GetProcessingSettings().noGPUMemoryRegistration && gatherMode != 3) {
     GPUError("noGPUMemoryRegistration only possible with gather mode 3 (set to %d / %d)", mRec->GetProcessingSettings().tpcCompressionGatherMode, gatherMode);
     return false;
   }
@@ -273,7 +273,7 @@ bool GPUChainTracking::ValidateSettings()
     GPUError("Clusterizer and merger Sanity checks only supported when not running on GPU");
     return false;
   }
-  if (GetProcessingSettings().tpcWriteClustersAfterRejection && (mRec->IsGPU() || param().rec.tpc.compressionTypeMask || !(GetRecoSteps() & GPUDataTypes::RecoStep::TPCCompression))) {
+  if (GetProcessingSettings().tpcWriteClustersAfterRejection && (mRec->IsGPU() || param().rec.tpc.compressionTypeMask || !(GetRecoSteps() & gpudatatypes::RecoStep::TPCCompression))) {
     GPUError("tpcWriteClustersAfterRejection requires compressionTypeMask = 0, no GPU usage, and compression enabled");
     return false;
   }
@@ -282,13 +282,13 @@ bool GPUChainTracking::ValidateSettings()
       GPUError("Cannot use double pipeline with tpcFreeAllocatedMemoryAfterProcessing");
       return false;
     }
-    if (!GetRecoStepsOutputs().isOnlySet(GPUDataTypes::InOutType::TPCMergedTracks, GPUDataTypes::InOutType::TPCCompressedClusters, GPUDataTypes::InOutType::TPCClusters)) {
+    if (!GetRecoStepsOutputs().isOnlySet(gpudatatypes::InOutType::TPCMergedTracks, gpudatatypes::InOutType::TPCCompressedClusters, gpudatatypes::InOutType::TPCClusters)) {
       GPUError("Invalid outputs for double pipeline mode 0x%x", (uint32_t)GetRecoStepsOutputs());
       return false;
     }
-    if (((GetRecoStepsOutputs().isSet(GPUDataTypes::InOutType::TPCCompressedClusters) && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::compressedClusters)] == nullptr) ||
-         (GetRecoStepsOutputs().isSet(GPUDataTypes::InOutType::TPCClusters) && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)] == nullptr) ||
-         (GetRecoStepsOutputs().isSet(GPUDataTypes::InOutType::TPCMergedTracks) && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::tpcTracks)] == nullptr) ||
+    if (((GetRecoStepsOutputs().isSet(gpudatatypes::InOutType::TPCCompressedClusters) && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::compressedClusters)] == nullptr) ||
+         (GetRecoStepsOutputs().isSet(gpudatatypes::InOutType::TPCClusters) && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::clustersNative)] == nullptr) ||
+         (GetRecoStepsOutputs().isSet(gpudatatypes::InOutType::TPCMergedTracks) && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::tpcTracks)] == nullptr) ||
          (GetProcessingSettings().outputSharedClusterMap && mSubOutputControls[GPUTrackingOutputs::getIndex(&GPUTrackingOutputs::sharedClusterMap)] == nullptr))) {
       GPUError("Must use external output for double pipeline mode");
       return false;
@@ -297,16 +297,16 @@ bool GPUChainTracking::ValidateSettings()
       GPUError("Double pipeline incompatible to compression mode 1");
       return false;
     }
-    if (!(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) || !(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding) || param().rec.fwdTPCDigitsAsClusters) {
+    if (!(GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression) || !(GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding) || param().rec.fwdTPCDigitsAsClusters) {
       GPUError("Invalid reconstruction settings for double pipeline: Needs compression and cluster finding");
       return false;
     }
   }
-  if ((GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && !(GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression) && (gatherMode == 1 || gatherMode == 3)) {
+  if ((GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression) && !(GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression) && (gatherMode == 1 || gatherMode == 3)) {
     GPUError("Invalid tpcCompressionGatherMode for compression on CPU");
     return false;
   }
-  if (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0 && (GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding || GetProcessingSettings().runMC)) {
+  if (GetProcessingSettings().tpcApplyClusterFilterOnCPU > 0 && (GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding || GetProcessingSettings().runMC)) {
     GPUError("tpcApplyClusterFilterOnCPU cannot be used with GPU clusterization or with MC labels");
     return false;
   }
@@ -332,9 +332,9 @@ int32_t GPUChainTracking::Init()
   const auto& threadContext = GetThreadContext();
   if (GetProcessingSettings().debugLevel >= 1) {
     printf("Enabled Reconstruction Steps: 0x%x (on GPU: 0x%x)", (int32_t)GetRecoSteps().get(), (int32_t)GetRecoStepsGPU().get());
-    for (uint32_t i = 0; i < sizeof(GPUDataTypes::RECO_STEP_NAMES) / sizeof(GPUDataTypes::RECO_STEP_NAMES[0]); i++) {
+    for (uint32_t i = 0; i < sizeof(gpudatatypes::RECO_STEP_NAMES) / sizeof(gpudatatypes::RECO_STEP_NAMES[0]); i++) {
       if (GetRecoSteps().isSet(1u << i)) {
-        printf(" - %s", GPUDataTypes::RECO_STEP_NAMES[i]);
+        printf(" - %s", gpudatatypes::RECO_STEP_NAMES[i]);
         if (GetRecoStepsGPU().isSet(1u << i)) {
           printf(" (G)");
         }
@@ -475,7 +475,7 @@ int32_t GPUChainTracking::ForceInitQA()
     qa.reset(new GPUQA(this));
   }
   if (!GetQA()->IsInitialized()) {
-    return GetQA()->InitQA(GetProcessingSettings().runQA <= 0 ? -GetProcessingSettings().runQA : GPUQA::tasksAutomatic);
+    return GetQA()->InitQA(GetProcessingSettings().runQA <= 0 ? -GetProcessingSettings().runQA : gpudatatypes::gpuqa::tasksAutomatic);
   }
   return 0;
 }
@@ -640,7 +640,7 @@ int32_t GPUChainTracking::DoQueuedUpdates(int32_t stream, bool updateSlave)
         pDst[i] = pSrc[i];
       }
     }
-    if (mNewCalibObjects->trdGeometry && (GetRecoSteps() & GPUDataTypes::RecoStep::TRDTracking)) {
+    if (mNewCalibObjects->trdGeometry && (GetRecoSteps() & gpudatatypes::RecoStep::TRDTracking)) {
       if (GetProcessingSettings().trdTrackModelO2) {
         processors()->trdTrackerO2.UpdateGeometry();
         if (mRec->IsGPU()) {
@@ -690,7 +690,7 @@ int32_t GPUChainTracking::RunChain()
   }
   const bool needQA = GPUQA::QAAvailable() && (GetProcessingSettings().runQA || (GetProcessingSettings().eventDisplay && (mIOPtrs.nMCInfosTPC || GetProcessingSettings().runMC)));
   if (needQA && GetQA()->IsInitialized() == false) {
-    if (GetQA()->InitQA(GetProcessingSettings().runQA <= 0 ? -GetProcessingSettings().runQA : GPUQA::tasksAutomatic)) {
+    if (GetQA()->InitQA(GetProcessingSettings().runQA <= 0 ? -GetProcessingSettings().runQA : gpudatatypes::gpuqa::tasksAutomatic)) {
       return 1;
     }
   }
@@ -1008,16 +1008,15 @@ void GPUChainTracking::SetO2Propagator(const o2::base::Propagator* prop)
   }
 }
 
-void GPUChainTracking::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode)
+void GPUChainTracking::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, gpudatatypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode)
 {
   if (syncMode) {
     rec.useMatLUT = false;
-    rec.tpc.rebuildTrackMaxNonIntCov = 0.f;
   }
   if (proc.rtc.optSpecialCode == -1) {
     proc.rtc.optSpecialCode = syncMode;
   }
   if (dEdxMode != -2) {
-    steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, dEdxMode == -1 ? !syncMode : dEdxMode > 0);
+    steps.setBits(gpudatatypes::RecoStep::TPCdEdx, dEdxMode == -1 ? !syncMode : dEdxMode > 0);
   }
 }
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 7d70e0b667946..2dd1ece856ecf 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -16,7 +16,8 @@
 #define GPUCHAINTRACKING_H
 
 #include "GPUChain.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
+#include "GPUDataTypesConfig.h"
 #include <atomic>
 #include <mutex>
 #include <functional>
@@ -88,7 +89,7 @@ class GPUChainTracking : public GPUChain
   void ClearErrorCodes(bool cpuOnly = false);
   int32_t DoQueuedUpdates(int32_t stream, bool updateSlave = true); // Forces doing queue calib updates, don't call when you are not sure you are allowed to do so!
   bool QARanForTF() const { return mFractionalQAEnabled; }
-  static void ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode = -2);
+  static void ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, gpudatatypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode = -2);
 
   // Structures for input and output data
   GPUTrackingInOutPointers& mIOPtrs;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index c4566ffb968a7..7629086272ed6 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -68,7 +68,7 @@ using namespace o2::dataformats;
 #ifdef GPUCA_TPC_GEOMETRY_O2
 std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCountUpdate(uint32_t iSector, const CfFragment& fragment)
 {
-  bool doGPU = mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding;
+  bool doGPU = mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding;
   GPUTPCClusterFinder& clusterer = processors()->tpcClusterer[iSector];
   GPUTPCClusterFinder::ZSOffset* o = processors()->tpcClusterer[iSector].mPzsOffsets;
   uint32_t digits = 0;
@@ -169,7 +169,7 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCount(uint
   uint32_t nPages = 0;
   uint32_t endpointAdcSamples[GPUTrackingInOutZS::NENDPOINTS];
   memset(endpointAdcSamples, 0, sizeof(endpointAdcSamples));
-  bool doGPU = mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding;
+  bool doGPU = mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding;
   int32_t firstHBF = (mIOPtrs.settingsTF && mIOPtrs.settingsTF->hasTfStartOrbit) ? mIOPtrs.settingsTF->tfStartOrbit : ((mIOPtrs.tpcZS->sector[iSector].count[0] && mIOPtrs.tpcZS->sector[iSector].nZSPtr[0][0]) ? o2::raw::RDHUtils::getHeartBeatOrbit(*(const o2::header::RAWDataHeader*)mIOPtrs.tpcZS->sector[iSector].zsPtr[0][0]) : 0);
 
   for (uint16_t j = 0; j < GPUTrackingInOutZS::NENDPOINTS; j++) {
@@ -475,7 +475,7 @@ std::pair<uint32_t, uint32_t> GPUChainTracking::RunTPCClusterizer_transferZS(int
 
 int32_t GPUChainTracking::RunTPCClusterizer_prepare(bool restorePointers)
 {
-  bool doGPU = mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding;
+  bool doGPU = mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding;
   if (restorePointers) {
     for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
       processors()->tpcClusterer[iSector].mPzsOffsets = mCFContext->ptrSave[iSector].zsOffsetHost;
@@ -765,7 +765,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   std::unique_ptr<ClusterNative[]> tmpNativeClusterBuffer;
 
   const bool buildNativeGPU = doGPU && NeedTPCClustersOnGPU();
-  const bool buildNativeHost = (mRec->GetRecoStepsOutputs() & GPUDataTypes::InOutType::TPCClusters) || GetProcessingSettings().deterministicGPUReconstruction; // TODO: Should do this also when clusters are needed for later steps on the host but not requested as output
+  const bool buildNativeHost = (mRec->GetRecoStepsOutputs() & gpudatatypes::InOutType::TPCClusters) || GetProcessingSettings().deterministicGPUReconstruction; // TODO: Should do this also when clusters are needed for later steps on the host but not requested as output
   const bool propagateMCLabels = buildNativeHost && GetProcessingSettings().runMC && processors()->ioPtrs.tpcPackedDigits && processors()->ioPtrs.tpcPackedDigits->tpcDigitsMC;
   const bool sortClusters = buildNativeHost && (GetProcessingSettings().deterministicGPUReconstruction || GetProcessingSettings().debugLevel >= 4);
 
@@ -1277,7 +1277,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   }
 
   // Number of clusters is logged by tracking. This ensures clusters are still printed if it's not running
-  if (!(GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking)) {
+  if (!(GetRecoSteps() & gpudatatypes::RecoStep::TPCSectorTracking)) {
     GPUInfo("Event has %zu TPC Clusters", nClsTotal);
   }
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index fab7179876c04..fd3c03a8b29ec 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -240,7 +240,7 @@ void GPUChainTracking::PrintOutputStat()
   }
 
   char trdText[1024] = "";
-  if (GetRecoSteps() & GPUDataTypes::RecoStep::TRDTracking) {
+  if (GetRecoSteps() & gpudatatypes::RecoStep::TRDTracking) {
     int32_t nTRDTracks = 0;
     int32_t nTRDTracklets = 0;
     for (uint32_t k = 0; k < mIOPtrs.nTRDTracks; k++) {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
index 83ddc45830621..8b36c9520659e 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
@@ -32,7 +32,7 @@ using namespace o2::tpc;
 
 bool GPUChainTracking::NeedTPCClustersOnGPU()
 {
-  return (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCConversion) || (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCMerging) || (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCCompression);
+  return (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCConversion) || (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCSectorTracking) || (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCMerging) || (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCCompression);
 }
 
 int32_t GPUChainTracking::ConvertNativeToClusterData()
@@ -41,7 +41,7 @@ int32_t GPUChainTracking::ConvertNativeToClusterData()
   const auto& threadContext = GetThreadContext();
 
   bool transferClusters = false;
-  if (mRec->IsGPU() && !(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding) && NeedTPCClustersOnGPU()) {
+  if (mRec->IsGPU() && !(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding) && NeedTPCClustersOnGPU()) {
     mInputsHost->mNClusterNative = mInputsShadow->mNClusterNative = mIOPtrs.clustersNative->nClustersTotal;
     AllocateRegisteredMemory(mInputsHost->mResourceClusterNativeBuffer);
     processorsShadow()->ioPtrs.clustersNative = mInputsShadow->mPclusterNativeAccess;
diff --git a/GPU/GPUTracking/Global/GPUErrors.cxx b/GPU/GPUTracking/Global/GPUErrors.cxx
index 4baa299c6b976..dfe7a84f0f179 100644
--- a/GPU/GPUTracking/Global/GPUErrors.cxx
+++ b/GPU/GPUTracking/Global/GPUErrors.cxx
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 #include "GPUErrors.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUCommonMath.h"
 #include "GPUDefMacros.h"
 #include "GPULogging.h"
diff --git a/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx b/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
index 9bb8b230e9e0b..dc47b6c0a6663 100644
--- a/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
+++ b/GPU/GPUTracking/Global/GPUTrackingInputProvider.cxx
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 #include "GPUTrackingInputProvider.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUTRDTrackletWord.h"
 #include "GPUReconstruction.h"
 #include "GPUTPCClusterOccupancyMap.h"
@@ -28,7 +28,7 @@ using namespace o2::tpc;
 void GPUTrackingInputProvider::InitializeProcessor() {}
 void* GPUTrackingInputProvider::SetPointersInputZS(void* mem)
 {
-  if (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding) {
+  if (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding) {
     computePointerWithAlignment(mem, mPzsMeta);
     computePointerWithAlignment(mem, mPzsSizes, GPUTrackingInOutZS::NSECTORS * GPUTrackingInOutZS::NENDPOINTS);
     computePointerWithAlignment(mem, mPzsPtrs, GPUTrackingInOutZS::NSECTORS * GPUTrackingInOutZS::NENDPOINTS);
@@ -101,7 +101,7 @@ void GPUTrackingInputProvider::RegisterMemoryAllocation()
 
 void GPUTrackingInputProvider::SetMaxData(const GPUTrackingInOutPointers& io)
 {
-  mHoldTPCZS = io.tpcZS && (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding);
+  mHoldTPCZS = io.tpcZS && (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding);
   mHoldTPCClusterNative = (io.tpcZS || io.tpcPackedDigits || io.clustersNative || io.tpcCompressedClusters) && (mRec->IsGPU() || io.tpcCompressedClusters);
   mHoldTPCOccupancyMap = (io.tpcZS || io.tpcPackedDigits || io.clustersNative || io.tpcCompressedClusters) && (mRec->GetParam().rec.tpc.occupancyMapTimeBins || mRec->GetParam().rec.tpc.sysClusErrorC12Norm);
   mHoldTPCClusterNativeOutput = io.tpcZS || io.tpcPackedDigits || io.tpcCompressedClusters;
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.cxx b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
index 95a57a4b17c4b..ced3016dc15b1 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.cxx
@@ -60,10 +60,10 @@ int32_t GPUO2Interface::Initialize(const GPUO2InterfaceConfiguration& config)
   mConfig.reset(new GPUO2InterfaceConfiguration(config));
   mNContexts = mConfig->configProcessing.doublePipeline ? 2 : 1;
   mCtx.reset(new GPUO2Interface_processingContext[mNContexts]);
-  if (mConfig->configWorkflow.inputs.isSet(GPUDataTypes::InOutType::TPCRaw)) {
+  if (mConfig->configWorkflow.inputs.isSet(gpudatatypes::InOutType::TPCRaw)) {
     mConfig->configGRP.needsClusterer = 1;
   }
-  if (mConfig->configWorkflow.inputs.isSet(GPUDataTypes::InOutType::TPCCompressedClusters)) {
+  if (mConfig->configWorkflow.inputs.isSet(gpudatatypes::InOutType::TPCCompressedClusters)) {
     mConfig->configGRP.doCompClusterDecode = 1;
   }
   for (uint32_t i = 0; i < mNContexts; i++) {
@@ -89,7 +89,7 @@ int32_t GPUO2Interface::Initialize(const GPUO2InterfaceConfiguration& config)
     mCtx[i].mRec->SetSettings(&mConfig->configGRP, &mConfig->configReconstruction, &mConfig->configProcessing, &mConfig->configWorkflow);
     mCtx[i].mChain->SetCalibObjects(mConfig->configCalib);
 
-    if (i == 0 && mConfig->configWorkflow.steps.isSet(GPUDataTypes::RecoStep::ITSTracking)) {
+    if (i == 0 && mConfig->configWorkflow.steps.isSet(gpudatatypes::RecoStep::ITSTracking)) {
       mChainITS = mCtx[i].mRec->AddChain<GPUChainITS>();
     }
 
@@ -269,7 +269,7 @@ void GPUO2Interface::UseGPUPolynomialFieldInPropagator(o2::base::Propagator* pro
   prop->setGPUField(&mCtx[0].mRec->GetParam().polynomialField);
 }
 
-void GPUO2Interface::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode)
+void GPUO2Interface::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, gpudatatypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode)
 {
   GPUChainTracking::ApplySyncSettings(proc, rec, steps, syncMode, dEdxMode);
 }
diff --git a/GPU/GPUTracking/Interface/GPUO2Interface.h b/GPU/GPUTracking/Interface/GPUO2Interface.h
index 3b4dde2cb0f96..ca56018908b41 100644
--- a/GPU/GPUTracking/Interface/GPUO2Interface.h
+++ b/GPU/GPUTracking/Interface/GPUO2Interface.h
@@ -17,7 +17,8 @@
 
 #include "GPUO2ExternalUser.h"
 #include "GPUCommonDef.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
+#include "GPUDataTypesConfig.h"
 
 #include <memory>
 #include <array>
@@ -82,7 +83,7 @@ class GPUO2Interface
 
   // Updates all calibration objects that are != nullptr in newCalib
   int32_t UpdateCalibration(const GPUCalibObjectsConst& newCalib, const GPUNewCalibValues& newVals, uint32_t iThread = 0);
-  static void ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, GPUDataTypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode = -2);
+  static void ApplySyncSettings(GPUSettingsProcessing& proc, GPUSettingsRec& rec, gpudatatypes::RecoStepField& steps, bool syncMode, int32_t dEdxMode = -2);
 
   int32_t registerMemoryForGPU(const void* ptr, size_t size);
   int32_t unregisterMemoryForGPU(const void* ptr);
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.cxx
index 54477f550b3d4..606f2bfc829e5 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.cxx
@@ -13,7 +13,7 @@
 /// \author David Rohr
 
 #include "GPUO2InterfaceConfiguration.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 
 using namespace o2::gpu;
 
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.h b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.h
index f378fc2c4fb7b..0f8a3784f0a88 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.h
@@ -17,7 +17,7 @@
 
 #include "GPUO2ExternalUser.h"
 #include "GPUSettings.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUHostDataTypes.h"
 #include "GPUOutputControl.h"
 #include "DataFormatsTPC/Constants.h"
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.h b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.h
index a7e9d309b6d3d..c0946bab0076d 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceDisplay.h
@@ -18,7 +18,7 @@
 #include "GPUO2ExternalUser.h"
 #include <memory>
 #include <vector>
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 
 namespace o2::gpu
 {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 8793f3bb399c8..260781c17406b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -420,7 +420,7 @@ void* GPUTPCGMMerger::SetPointersMemory(void* mem)
 void* GPUTPCGMMerger::SetPointersRefitScratch(void* mem)
 {
   computePointerWithAlignment(mem, mTrackOrderAttach, mNMaxTracks);
-  const bool mergerSortTracks = mRec->GetProcessingSettings().mergerSortTracks == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCMerging).par_SORT_BEFORE_FIT : mRec->GetProcessingSettings().mergerSortTracks;
+  const bool mergerSortTracks = mRec->GetProcessingSettings().mergerSortTracks == -1 ? mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCMerging).par_SORT_BEFORE_FIT : mRec->GetProcessingSettings().mergerSortTracks;
   if (mergerSortTracks) {
     computePointerWithAlignment(mem, mTrackOrderProcess, mNMaxTracks);
   }
@@ -443,7 +443,7 @@ void* GPUTPCGMMerger::SetPointersOutput(void* mem)
 
 void* GPUTPCGMMerger::SetPointersOutputState(void* mem)
 {
-  if ((mRec->GetRecoSteps() & GPUDataTypes::RecoStep::Refit) || mRec->GetProcessingSettings().outputSharedClusterMap) {
+  if ((mRec->GetRecoSteps() & gpudatatypes::RecoStep::Refit) || mRec->GetProcessingSettings().outputSharedClusterMap) {
     computePointerWithAlignment(mem, mClusterStateExt, mNMaxClusters);
   } else {
     mClusterStateExt = nullptr;
@@ -515,7 +515,7 @@ void GPUTPCGMMerger::SetMaxData(const GPUTrackingInOutPointers& io)
   }
   if (io.clustersNative) {
     mNMaxClusters = io.clustersNative->nClustersTotal;
-  } else if (mRec->GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking) {
+  } else if (mRec->GetRecoSteps() & gpudatatypes::RecoStep::TPCSectorTracking) {
     mNMaxClusters = 0;
     for (int32_t i = 0; i < NSECTORS; i++) {
       mNMaxClusters += mRec->GetConstantMem().tpcTrackers[i].NHitsTotal();
@@ -533,7 +533,7 @@ int32_t GPUTPCGMMerger::CheckSectors()
       throw std::runtime_error("mNMaxSingleSectorTracks too small");
     }
   }
-  if (!(mRec->GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking)) {
+  if (!(mRec->GetRecoSteps() & gpudatatypes::RecoStep::TPCSectorTracking)) {
     throw std::runtime_error("Must run also sector tracking");
   }
   return 0;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h
index dec72b1d431e6..5d00451516aa8 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.h
@@ -24,7 +24,7 @@ namespace o2::gpu
 class GPUTPCGMMergerGeneral : public GPUKernelTemplate
 {
  public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCMerging; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCMerging; }
   typedef GPUTPCGMMerger processorType;
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.h b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.h
index 726e8cee1f7a7..87204449749b6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.h
@@ -32,7 +32,7 @@ class GPUTPCGlobalDebugSortKernels : public GPUKernelTemplate
            mergedTracks1 = 2,
            mergedTracks2 = 3,
            borderTracks = 4 };
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCMerging; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCMerging; }
   typedef GPUTPCGMMerger processorType;
   GPUhdi() static processorType* Processor(GPUConstantMem& processors) { return &processors.tpcMerger; }
 
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefitKernel.h b/GPU/GPUTracking/Refit/GPUTrackingRefitKernel.h
index 9b99ffb8402c0..a397e349d29fb 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefitKernel.h
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefitKernel.h
@@ -24,7 +24,7 @@ namespace o2::gpu
 class GPUTrackingRefitKernel : public GPUKernelTemplate
 {
  public:
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCCompression; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCCompression; }
 
   enum K : int32_t {
     mode0asGPU = 0,
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.h b/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.h
index de8eb8622adb1..2faf0ec668a6f 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.h
@@ -29,7 +29,7 @@ class GPUTPCCreateOccupancyMap : public GPUKernelTemplate
   enum K { defaultKernel = 0,
            fill = 0,
            fold = 1 };
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   template <int32_t iKernel = defaultKernel, typename... Args>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors, Args... args);
 };
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCCreateTrackingData.h b/GPU/GPUTracking/SectorTracker/GPUTPCCreateTrackingData.h
index dc1beacf79d02..8085124653332 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCCreateTrackingData.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCCreateTrackingData.h
@@ -32,7 +32,7 @@ class GPUTPCCreateTrackingData : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
index eaaefcb278ffe..ee403116cc6da 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
@@ -167,11 +167,11 @@ GPUdii() void GPUTPCExtrapolationTracking::Thread<0>(int32_t nBlocks, int32_t nT
     return;
   }
   const int32_t iSector = tracker.ISector();
-  int32_t sectorLeft = (iSector + (GPUDataTypes::NSECTORS / 2 - 1)) % (GPUDataTypes::NSECTORS / 2);
-  int32_t sectorRight = (iSector + 1) % (GPUDataTypes::NSECTORS / 2);
-  if (iSector >= (int32_t)GPUDataTypes::NSECTORS / 2) {
-    sectorLeft += GPUDataTypes::NSECTORS / 2;
-    sectorRight += GPUDataTypes::NSECTORS / 2;
+  int32_t sectorLeft = (iSector + (gpudatatypes::NSECTORS / 2 - 1)) % (gpudatatypes::NSECTORS / 2);
+  int32_t sectorRight = (iSector + 1) % (gpudatatypes::NSECTORS / 2);
+  if (iSector >= (int32_t)gpudatatypes::NSECTORS / 2) {
+    sectorLeft += gpudatatypes::NSECTORS / 2;
+    sectorRight += gpudatatypes::NSECTORS / 2;
   }
   PerformExtrapolationTracking(nBlocks, nThreads, iBlock, iThread, tracker.GetConstantMem()->tpcTrackers[sectorLeft], smem, tracker, true);
   PerformExtrapolationTracking(nBlocks, nThreads, iBlock, iThread, tracker.GetConstantMem()->tpcTrackers[sectorRight], smem, tracker, false);
@@ -180,22 +180,22 @@ GPUdii() void GPUTPCExtrapolationTracking::Thread<0>(int32_t nBlocks, int32_t nT
 GPUd() int32_t GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorOrder(int32_t iSector)
 {
   iSector++;
-  if (iSector == GPUDataTypes::NSECTORS / 2) {
+  if (iSector == gpudatatypes::NSECTORS / 2) {
     iSector = 0;
   }
-  if (iSector == GPUDataTypes::NSECTORS) {
-    iSector = GPUDataTypes::NSECTORS / 2;
+  if (iSector == gpudatatypes::NSECTORS) {
+    iSector = gpudatatypes::NSECTORS / 2;
   }
   return iSector;
 }
 
 GPUd() void GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorLeftRight(uint32_t iSector, uint32_t& left, uint32_t& right)
 {
-  left = (iSector + (GPUDataTypes::NSECTORS / 2 - 1)) % (GPUDataTypes::NSECTORS / 2);
-  right = (iSector + 1) % (GPUDataTypes::NSECTORS / 2);
-  if (iSector >= (int32_t)GPUDataTypes::NSECTORS / 2) {
-    left += GPUDataTypes::NSECTORS / 2;
-    right += GPUDataTypes::NSECTORS / 2;
+  left = (iSector + (gpudatatypes::NSECTORS / 2 - 1)) % (gpudatatypes::NSECTORS / 2);
+  right = (iSector + 1) % (gpudatatypes::NSECTORS / 2);
+  if (iSector >= (int32_t)gpudatatypes::NSECTORS / 2) {
+    left += gpudatatypes::NSECTORS / 2;
+    right += gpudatatypes::NSECTORS / 2;
   }
 }
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
index 91a33d132f136..9e39ba0ce258d 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
@@ -30,7 +30,7 @@ class GPUTPCExtrapolationTracking : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
@@ -50,7 +50,7 @@ class GPUTPCExtrapolationTrackingCopyNumbers : public GPUKernelTemplate
 {
  public:
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
index de79b268aea78..2caf09e4886df 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
@@ -38,7 +38,7 @@ class GPUTPCNeighboursCleaner : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
index 6bdc637b6bad6..ea574b5576d37 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
@@ -48,7 +48,7 @@ class GPUTPCNeighboursFinder : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCSectorDebugSortKernels.h b/GPU/GPUTracking/SectorTracker/GPUTPCSectorDebugSortKernels.h
index 520a791b0eb43..8b994be687e72 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCSectorDebugSortKernels.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCSectorDebugSortKernels.h
@@ -30,7 +30,7 @@ class GPUTPCSectorDebugSortKernels : public GPUKernelTemplate
            hitData = 0,
            startHits = 1,
            sectorTracks = 2 };
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   typedef GPUTPCTracker processorType;
   GPUhdi() static processorType* Processor(GPUConstantMem& processors) { return processors.tpcTrackers; }
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
index c834b17369f0f..c62eeb315b1f8 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
@@ -38,7 +38,7 @@ class GPUTPCStartHitsFinder : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
index 0e2fd96dd2690..1cee79d292b84 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
@@ -38,7 +38,7 @@ class GPUTPCStartHitsSorter : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index c5e6a21460a36..03931f73a4a12 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -53,7 +53,7 @@ void GPUTPCTracker::InitializeProcessor()
 
 void* GPUTPCTracker::SetPointersDataLinks(void* mem) { return mData.SetPointersLinks(mem); }
 void* GPUTPCTracker::SetPointersDataWeights(void* mem) { return mData.SetPointersWeights(mem); }
-void* GPUTPCTracker::SetPointersDataScratch(void* mem) { return mData.SetPointersScratch(mem, mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCMerging); }
+void* GPUTPCTracker::SetPointersDataScratch(void* mem) { return mData.SetPointersScratch(mem, mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCMerging); }
 void* GPUTPCTracker::SetPointersDataRows(void* mem) { return mData.SetPointersRows(mem); }
 
 void* GPUTPCTracker::SetPointersScratch(void* mem)
@@ -62,7 +62,7 @@ void* GPUTPCTracker::SetPointersScratch(void* mem)
   if (mRec->GetProcessingSettings().memoryAllocationStrategy != GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
     mem = SetPointersTracklets(mem);
   }
-  if (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) {
+  if (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCSectorTracking) {
     computePointerWithAlignment(mem, mTrackletTmpStartHits, GPUCA_ROW_COUNT * mNMaxRowStartHits);
     computePointerWithAlignment(mem, mRowStartHitCountOffset, GPUCA_ROW_COUNT);
   }
@@ -74,7 +74,7 @@ void* GPUTPCTracker::SetPointersScratchHost(void* mem)
   if (mRec->GetProcessingSettings().keepDisplayMemory) {
     computePointerWithAlignment(mem, mLinkTmpMemory, mRec->Res(mMemoryResLinks).Size());
   }
-  mem = mData.SetPointersClusterIds(mem, mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCMerging);
+  mem = mData.SetPointersClusterIds(mem, mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCMerging);
   return mem;
 }
 
@@ -86,7 +86,7 @@ void* GPUTPCTracker::SetPointersCommon(void* mem)
 
 bool GPUTPCTracker::MemoryReuseAllowed()
 {
-  return !mRec->GetProcessingSettings().keepDisplayMemory && ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
+  return !mRec->GetProcessingSettings().keepDisplayMemory && ((mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCSectorTracking) || mRec->GetProcessingSettings().inKernelParallel == 1 || mRec->GetProcessingSettings().nHostThreads == 1);
 }
 
 void GPUTPCTracker::RegisterMemoryAllocation()
@@ -158,7 +158,7 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   }
   mNMaxTrackHits = mRec->MemoryScalers()->NTPCSectorTrackHits(mData.NumberOfHits(), mRec->GetProcessingSettings().tpcInputWithClusterRejection);
 
-  if (mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCSectorTracking).par_SORT_STARTHITS) {
+  if (mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCSectorTracking).par_SORT_STARTHITS) {
     if (mNMaxStartHits > mNMaxRowStartHits * GPUCA_ROW_COUNT) {
       mNMaxStartHits = mNMaxRowStartHits * GPUCA_ROW_COUNT;
     }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
index 031c32b2b4334..120797ad4f1eb 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
@@ -85,7 +85,7 @@ class GPUTPCTrackletConstructor : public GPUKernelTemplate
   GPUd() static int32_t GPUTPCTrackletConstructorExtrapolationTracking(GPUconstantref() GPUTPCTracker& tracker, GPUsharedref() T& sMem, GPUTPCTrackParam& tParam, int32_t startrow, int32_t increment, int32_t iTracklet, calink* rowHits);
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
index 070e02fad8222..6a4a7d9013e5a 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
@@ -41,7 +41,7 @@ class GPUTPCTrackletSelector : public GPUKernelTemplate
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TPCSectorTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TPCSectorTracking; }
   GPUhdi() static processorType* Processor(GPUConstantMem& processors)
   {
     return processors.tpcTrackers;
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 1b3603a226af0..b9825bc6da481 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -371,45 +371,45 @@ int32_t SetupReconstruction()
     procSet.runMC = true;
   }
 
-  steps.steps = GPUDataTypes::RecoStep::AllRecoSteps;
+  steps.steps = gpudatatypes::RecoStep::AllRecoSteps;
   if (configStandalone.runTRD != -1) {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TRDTracking, configStandalone.runTRD > 0);
+    steps.steps.setBits(gpudatatypes::RecoStep::TRDTracking, configStandalone.runTRD > 0);
   } else if (chainTracking->GetTRDGeometry() == nullptr) {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TRDTracking, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TRDTracking, false);
   }
   if (configStandalone.runCompression != -1) {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, configStandalone.runCompression > 0);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCCompression, configStandalone.runCompression > 0);
   }
   if (configStandalone.runTransformation != -1) {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCConversion, configStandalone.runTransformation > 0);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCConversion, configStandalone.runTransformation > 0);
   }
-  steps.steps.setBits(GPUDataTypes::RecoStep::Refit, configStandalone.runRefit);
+  steps.steps.setBits(gpudatatypes::RecoStep::Refit, configStandalone.runRefit);
   if (!configStandalone.runMerger) {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCMerging, false);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TRDTracking, false);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, false);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, false);
-    steps.steps.setBits(GPUDataTypes::RecoStep::Refit, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCMerging, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TRDTracking, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCdEdx, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCCompression, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::Refit, false);
   }
 
   if (configStandalone.TF.bunchSim || configStandalone.TF.nMerge) {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TRDTracking, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TRDTracking, false);
   }
-  steps.inputs.set(GPUDataTypes::InOutType::TPCClusters, GPUDataTypes::InOutType::TRDTracklets);
-  steps.steps.setBits(GPUDataTypes::RecoStep::TPCDecompression, false);
-  steps.inputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, false);
+  steps.inputs.set(gpudatatypes::InOutType::TPCClusters, gpudatatypes::InOutType::TRDTracklets);
+  steps.steps.setBits(gpudatatypes::RecoStep::TPCDecompression, false);
+  steps.inputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, false);
   if (grp.doCompClusterDecode) {
-    steps.inputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, true);
-    steps.inputs.setBits(GPUDataTypes::InOutType::TPCClusters, false);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, false);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCClusterFinding, false);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCDecompression, true);
-    steps.outputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, false);
+    steps.inputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, true);
+    steps.inputs.setBits(gpudatatypes::InOutType::TPCClusters, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCCompression, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCClusterFinding, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCDecompression, true);
+    steps.outputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, false);
   } else if (grp.needsClusterer) {
-    steps.inputs.setBits(GPUDataTypes::InOutType::TPCRaw, true);
-    steps.inputs.setBits(GPUDataTypes::InOutType::TPCClusters, false);
+    steps.inputs.setBits(gpudatatypes::InOutType::TPCRaw, true);
+    steps.inputs.setBits(gpudatatypes::InOutType::TPCClusters, false);
   } else {
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCClusterFinding, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCClusterFinding, false);
   }
 
   if (configStandalone.recoSteps >= 0) {
@@ -420,12 +420,12 @@ int32_t SetupReconstruction()
   }
 
   steps.outputs.clear();
-  steps.outputs.setBits(GPUDataTypes::InOutType::TPCMergedTracks, steps.steps.isSet(GPUDataTypes::RecoStep::TPCMerging));
-  steps.outputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, steps.steps.isSet(GPUDataTypes::RecoStep::TPCCompression));
-  steps.outputs.setBits(GPUDataTypes::InOutType::TRDTracks, steps.steps.isSet(GPUDataTypes::RecoStep::TRDTracking));
-  steps.outputs.setBits(GPUDataTypes::InOutType::TPCClusters, steps.steps.isSet(GPUDataTypes::RecoStep::TPCClusterFinding));
+  steps.outputs.setBits(gpudatatypes::InOutType::TPCMergedTracks, steps.steps.isSet(gpudatatypes::RecoStep::TPCMerging));
+  steps.outputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, steps.steps.isSet(gpudatatypes::RecoStep::TPCCompression));
+  steps.outputs.setBits(gpudatatypes::InOutType::TRDTracks, steps.steps.isSet(gpudatatypes::RecoStep::TRDTracking));
+  steps.outputs.setBits(gpudatatypes::InOutType::TPCClusters, steps.steps.isSet(gpudatatypes::RecoStep::TPCClusterFinding));
 
-  if (steps.steps.isSet(GPUDataTypes::RecoStep::TRDTracking)) {
+  if (steps.steps.isSet(gpudatatypes::RecoStep::TRDTracking)) {
     if (procSet.createO2Output && !procSet.trdTrackModelO2) {
       procSet.createO2Output = 1; // Must not be 2, to make sure TPC GPU tracks are still available for TRD
     }
@@ -447,14 +447,14 @@ int32_t SetupReconstruction()
   }
   if (configStandalone.testSyncAsync) { // TODO: Add --async mode / flag
     // Set settings for asynchronous
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCDecompression, true);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCdEdx, true);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, false);
-    steps.steps.setBits(GPUDataTypes::RecoStep::TPCClusterFinding, false);
-    steps.inputs.setBits(GPUDataTypes::InOutType::TPCRaw, false);
-    steps.inputs.setBits(GPUDataTypes::InOutType::TPCClusters, false);
-    steps.inputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, true);
-    steps.outputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCDecompression, true);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCdEdx, true);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCCompression, false);
+    steps.steps.setBits(gpudatatypes::RecoStep::TPCClusterFinding, false);
+    steps.inputs.setBits(gpudatatypes::InOutType::TPCRaw, false);
+    steps.inputs.setBits(gpudatatypes::InOutType::TPCClusters, false);
+    steps.inputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, true);
+    steps.outputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, false);
     procSet.runMC = false;
     procSet.runQA = runAsyncQA;
     procSet.eventDisplay = eventDisplay.get();
@@ -724,7 +724,7 @@ int32_t main(int argc, char** argv)
   eventsDir = std::string(configStandalone.absoluteEventsDir ? "" : "events/") + configStandalone.eventsDir + "/";
 
   GPUSettingsDeviceBackend deviceSet;
-  deviceSet.deviceType = configStandalone.runGPU ? GPUDataTypes::GetDeviceType(configStandalone.gpuType.c_str()) : GPUDataTypes::DeviceType::CPU;
+  deviceSet.deviceType = configStandalone.runGPU ? gpudatatypes::GetDeviceType(configStandalone.gpuType.c_str()) : gpudatatypes::DeviceType::CPU;
   deviceSet.forceDeviceType = configStandalone.runGPUforce;
   deviceSet.master = nullptr;
   recUnique.reset(GPUReconstruction::CreateInstance(deviceSet));
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChainContext.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChainContext.h
index 2344c089a4436..40dd379eae30a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChainContext.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChainContext.h
@@ -16,7 +16,7 @@
 #define O2_GPU_TPCCFCHAINCONTEXT_H
 
 #include "clusterFinderDefs.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUTPCClusterFinder.h"
 #include "CfFragment.h"
 #include <vector>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.h
index 800ba786c2105..3ca6b52238ed7 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChargeMapFiller.h
@@ -47,9 +47,9 @@ class GPUTPCCFChargeMapFiller : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
index 2403aa6d29ecd..25c93a4649662 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
@@ -43,9 +43,9 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
index 70e21db81756c..09814b464651c 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFClusterizer.h
@@ -49,9 +49,9 @@ class GPUTPCCFClusterizer : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
index c633a5ebc2774..b8ff90f511057 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
@@ -53,9 +53,9 @@ class GPUTPCCFDecodeZS : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel, typename... Args>
@@ -72,9 +72,9 @@ class GPUTPCCFDecodeZSLinkBase : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   struct DecodeCtx {
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
index 902e3a28fd21b..2debce3dc0d6c 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDeconvolution.h
@@ -42,9 +42,9 @@ class GPUTPCCFDeconvolution : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFGather.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFGather.h
index 210853237b86e..50fbe63eb6dac 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFGather.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFGather.h
@@ -32,9 +32,9 @@ class GPUTPCCFGather : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.h
index 6bdec7760527c..cc39938b70d21 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.h
@@ -44,9 +44,9 @@ class GPUTPCCFMCLabelFlattener : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
index 59196da11079b..27095bb17c1e9 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFNoiseSuppression.h
@@ -48,9 +48,9 @@ class GPUTPCCFNoiseSuppression : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.h
index e480518ddc9dd..eeda0cecb3bc3 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.h
@@ -42,9 +42,9 @@ class GPUTPCCFPeakFinder : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
index a5ea8b24e9522..3b9b7e2b8329a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFStreamCompaction.h
@@ -51,9 +51,9 @@ class GPUTPCCFStreamCompaction : public GPUKernelTemplate
     return processors.tpcClusterer;
   }
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   template <int32_t iKernel = GPUKernelTemplate::defaultKernel, typename... Args>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
index 541edaa689c6c..44b005eb20233 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
@@ -48,7 +48,7 @@ void* GPUTPCClusterFinder::SetPointersMemory(void* mem)
 
 void* GPUTPCClusterFinder::SetPointersInput(void* mem)
 {
-  if (mNMaxPages == 0 && (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding)) {
+  if (mNMaxPages == 0 && (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding)) {
     computePointerWithAlignment(mem, mPdigits, mNMaxDigits);
   }
   return mem;
@@ -56,7 +56,7 @@ void* GPUTPCClusterFinder::SetPointersInput(void* mem)
 
 void* GPUTPCClusterFinder::SetPointersZSOffset(void* mem)
 {
-  const int32_t n = (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding) ? mNMaxPages : GPUTrackingInOutZS::NENDPOINTS;
+  const int32_t n = (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding) ? mNMaxPages : GPUTrackingInOutZS::NENDPOINTS;
   if (n) {
     computePointerWithAlignment(mem, mPzsOffsets, n);
   }
@@ -65,7 +65,7 @@ void* GPUTPCClusterFinder::SetPointersZSOffset(void* mem)
 
 void* GPUTPCClusterFinder::SetPointersZS(void* mem)
 {
-  if (mNMaxPages && (mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding)) {
+  if (mNMaxPages && (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding)) {
     computePointerWithAlignment(mem, mPzs, mNMaxPages * TPCZSHDR::TPC_ZS_PAGE_SIZE);
   }
   return mem;
@@ -92,7 +92,7 @@ void* GPUTPCClusterFinder::SetPointersScratch(void* mem)
   computePointerWithAlignment(mem, mPchargeMap, TPCMapMemoryLayout<decltype(*mPchargeMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen));
   computePointerWithAlignment(mem, mPpeakMap, TPCMapMemoryLayout<decltype(*mPpeakMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen));
   computePointerWithAlignment(mem, mPclusterByRow, GPUCA_ROW_COUNT * mNMaxClusterPerRow);
-  if ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding)) {
+  if ((mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding)) {
     computePointerWithAlignment(mem, mPscanBuf, mBufSize * mNBufs);
   }
   return mem;
@@ -131,15 +131,15 @@ void GPUTPCClusterFinder::SetMaxData(const GPUTrackingInOutPointers& io)
   if (mRec->GetProcessingSettings().tpcIncreasedMinClustersPerRow) {
     mNMaxClusterPerRow = std::max<uint32_t>(mNMaxClusterPerRow, mRec->GetProcessingSettings().tpcIncreasedMinClustersPerRow);
   }
-  if ((mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding)) {
-    mBufSize = nextMultipleOf(mNMaxDigitsFragment, std::max<int32_t>(GPUCA_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
+  if ((mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding)) {
+    mBufSize = nextMultipleOf(mNMaxDigitsFragment, std::max<int32_t>(GPUCA_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
     mNBufs = getNSteps(mBufSize);
   }
 }
 
 void GPUTPCClusterFinder::SetNMaxDigits(size_t nDigits, size_t nPages, size_t nDigitsFragment, size_t nDigitsEndpointMax)
 {
-  mNMaxDigits = nextMultipleOf(nDigits, std::max<int32_t>(GPUCA_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
+  mNMaxDigits = nextMultipleOf(nDigits, std::max<int32_t>(GPUCA_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
   mNMaxPages = nPages;
   mNMaxDigitsFragment = nDigitsFragment;
   mNMaxDigitsEndpoint = nDigitsEndpointMax;
@@ -151,7 +151,7 @@ uint32_t GPUTPCClusterFinder::getNSteps(size_t items) const
     return 0;
   }
   uint32_t c = 1;
-  const size_t scanWorkgroupSize = mRec->getGPUParameters(mRec->GetRecoStepsGPU() & GPUDataTypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE;
+  const size_t scanWorkgroupSize = mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE;
   size_t capacity = scanWorkgroupSize;
   while (items > capacity) {
     capacity *= scanWorkgroupSize;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
index 35e2a7297338f..6958134d7d716 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
@@ -17,7 +17,7 @@
 
 #include "GPUDef.h"
 #include "GPUProcessor.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "CfFragment.h"
 
 namespace o2
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
index 9353722568b1f..c77a99bec3a70 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCNNClusterizerKernels.h
@@ -44,9 +44,9 @@ class GPUTPCNNClusterizerKernels : public GPUKernelTemplate
     uint8_t innerAboveThreshold[SCRATCH_PAD_WORK_GROUP_SIZE];
   };
 
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep()
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep()
   {
-    return GPUDataTypes::RecoStep::TPCClusterFinding;
+    return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
   enum K : int32_t {
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.h b/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.h
index 21135ddc48dfa..f9d500a72597a 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTrackerKernels.h
@@ -26,7 +26,7 @@ class GPUTRDTrackerKernels : public GPUKernelTemplate
   enum K { defaultKernel = 0,
            gpuVersion = 0,
            o2Version = 1 };
-  GPUhdi() constexpr static GPUDataTypes::RecoStep GetRecoStep() { return GPUDataTypes::RecoStep::TRDTracking; }
+  GPUhdi() constexpr static gpudatatypes::RecoStep GetRecoStep() { return gpudatatypes::RecoStep::TRDTracking; }
   template <int32_t iKernel = defaultKernel, class T>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& processors, T* externalInstance = nullptr);
 };
diff --git a/GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C b/GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C
index 3d86a77b6d9cc..acfcf92370b00 100644
--- a/GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C
+++ b/GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C
@@ -17,7 +17,7 @@
 #include "GPUReconstruction.h"
 #include "GPUChainTracking.h"
 #include "GPUSettings.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUTRDDef.h"
 #include "GPUTRDTrack.h"
 #include "GPUTRDTracker.h"
@@ -70,7 +70,7 @@ void run_trd_tracker(std::string path = "./",
   GPUSettingsProcessing cfgDeviceProcessing; // also keep defaults here, or adjust debug level
   cfgDeviceProcessing.debugLevel = 5;
   GPURecoStepConfiguration cfgRecoStep;
-  cfgRecoStep.steps = GPUDataTypes::RecoStep::NoRecoStep;
+  cfgRecoStep.steps = gpudatatypes::RecoStep::NoRecoStep;
   cfgRecoStep.inputs.clear();
   cfgRecoStep.outputs.clear();
   auto rec = GPUReconstruction::CreateInstance("CPU", true);
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index 758c2a7eabfca..e64e2b37945c8 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -23,6 +23,7 @@
 #include "CalibdEdxContainer.h"
 #include "GPUTPCGeometry.h"
 #include "GPUDebugStreamer.h"
+#include "GPUDataTypesIO.h"
 
 namespace o2::gpu
 {
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index 837995ef38bb4..b0c1c1d11f2cf 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -37,6 +37,7 @@ class GPUTPCTracker;
 struct GPUParam;
 class GPUQA;
 class GPUTRDGeometry;
+class GPUTPCGMPropagator;
 
 class GPUDisplay : public GPUDisplayInterface
 {
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 4953815a6fc19..6447d30daefe3 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -817,7 +817,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
 
   int32_t numThreads = getNumThreads();
   tbb::task_arena(numThreads).execute([&] {
-    if (mChain && (mChain->GetRecoSteps() & GPUDataTypes::RecoStep::TPCSectorTracking)) {
+    if (mChain && (mChain->GetRecoSteps() & gpudatatypes::RecoStep::TPCSectorTracking)) {
       tbb::parallel_for(0, NSECTORS, [&](int32_t iSector) {
         GPUTPCTracker& tracker = (GPUTPCTracker&)sectorTracker(iSector);
         tracker.SetPointersDataLinks(tracker.LinkTmpMemory());
@@ -964,7 +964,6 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
     if (timer.IsRunning()) {
       GPUInfo("Display Time: Vertex Clusters:\t\t\t%6.0f us", timer.GetCurrentElapsedTime(true) * 1e6);
     }
-
   });
   // End omp parallel
 
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 3dd49e2ec1373..346c56a898806 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -16,6 +16,7 @@
 #define GPUQA_H
 
 #include "GPUSettings.h"
+#include "GPUDataTypesQA.h"
 struct AliHLTTPCClusterMCWeight;
 class TH1F;
 class TH2F;
@@ -56,16 +57,13 @@ class GPUQA
   static bool QAAvailable() { return false; }
   static bool IsInitialized() { return false; }
   void UpdateChain(GPUChainTracking* chain) {}
-
-  enum QA_TASKS {
-    tasksAutomatic = 0
-  };
 };
 } // namespace o2::gpu
 
 #else
 
 #include "GPUTPCDef.h"
+#include "GPUDataTypesIO.h"
 #include <cstdio>
 #include <cmath>
 #include <vector>
@@ -150,21 +148,7 @@ class GPUQA
 
   static constexpr int32_t MC_LABEL_INVALID = -1e9;
 
-  enum QA_TASKS { // TODO: make this in32_t typed
-    taskTrackingEff = 1,
-    taskTrackingRes = 2,
-    taskTrackingResPull = 4,
-    tasksAllMC = 8 - 1,
-    taskClusterAttach = 8,
-    taskTrackStatistics = 16,
-    taskClusterCounts = 32,
-    taskClusterRejection = 64,
-    tasksAll = 128 - 1,
-    tasksDefault = tasksAll,
-    tasksDefaultPostprocess = tasksDefault & ~taskClusterCounts,
-    tasksAllNoQC = tasksAll & ~tasksAllMC,
-    tasksAutomatic = -1
-  };
+  using enum gpudatatypes::gpuqa::gpuQATaskIds;
 
  private:
   struct additionalMCParameters {
diff --git a/GPU/Workflow/helper/include/GPUWorkflowHelper/GPUWorkflowHelper.h b/GPU/Workflow/helper/include/GPUWorkflowHelper/GPUWorkflowHelper.h
index 225b6f75b1511..2802811b2e02b 100644
--- a/GPU/Workflow/helper/include/GPUWorkflowHelper/GPUWorkflowHelper.h
+++ b/GPU/Workflow/helper/include/GPUWorkflowHelper/GPUWorkflowHelper.h
@@ -14,7 +14,7 @@
 
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include <memory>
 
 namespace o2::gpu
diff --git a/GPU/Workflow/src/GPUWorkflowInternal.h b/GPU/Workflow/src/GPUWorkflowInternal.h
index 73d3676f3d84a..1ad6f3df13f5a 100644
--- a/GPU/Workflow/src/GPUWorkflowInternal.h
+++ b/GPU/Workflow/src/GPUWorkflowInternal.h
@@ -15,7 +15,7 @@
 #ifndef O2_GPU_GPUWORKFLOWINTERNAL_H
 #define O2_GPU_GPUWORKFLOWINTERNAL_H
 
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include <mutex>
 #include <thread>
 #include <condition_variable>
diff --git a/GPU/Workflow/src/GPUWorkflowPipeline.cxx b/GPU/Workflow/src/GPUWorkflowPipeline.cxx
index ba395cd98d64d..f0aeb8089e27a 100644
--- a/GPU/Workflow/src/GPUWorkflowPipeline.cxx
+++ b/GPU/Workflow/src/GPUWorkflowPipeline.cxx
@@ -15,7 +15,7 @@
 #include "GPUWorkflow/GPUWorkflowSpec.h"
 #include "GPUO2InterfaceConfiguration.h"
 #include "GPUO2Interface.h"
-#include "GPUDataTypes.h"
+#include "GPUDataTypesIO.h"
 #include "GPUSettings.h"
 #include "GPUWorkflowInternal.h"
 
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index ca929bb025f80..6011cc3dc3e9f 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -79,6 +79,7 @@
 #include "DetectorsRaw/RDHUtils.h"
 #include "ITStracking/TrackingInterface.h"
 #include "GPUWorkflowInternal.h"
+#include "GPUDataTypesQA.h"
 // #include "Framework/ThreadPool.h"
 
 #include <TStopwatch.h>
@@ -180,7 +181,7 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     mConfig->configQA.shipToQC = true;
     if (!mConfig->configProcessing.runQA) {
       mConfig->configQA.enableLocalOutput = false;
-      mQATaskMask = (mSpecConfig.processMC ? 15 : 0) | (mConfig->configQA.clusterRejectionHistograms ? 32 : 0); // TODO: Clean up using numeric flags!
+      mQATaskMask = (mSpecConfig.processMC ? gpudatatypes::gpuqa::tasksAllMC : gpudatatypes::gpuqa::tasksNone) | (mConfig->configQA.clusterRejectionHistograms ? gpudatatypes::gpuqa::taskClusterCounts : gpudatatypes::gpuqa::tasksNone);
       mConfig->configProcessing.runQA = -mQATaskMask;
     }
   }
@@ -190,39 +191,39 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
 
   // Configure the "GPU workflow" i.e. which steps we run on the GPU (or CPU)
   if (runTracking) {
-    mConfig->configWorkflow.steps.set(GPUDataTypes::RecoStep::TPCConversion,
-                                      GPUDataTypes::RecoStep::TPCSectorTracking,
-                                      GPUDataTypes::RecoStep::TPCMerging);
-    mConfig->configWorkflow.outputs.set(GPUDataTypes::InOutType::TPCMergedTracks);
+    mConfig->configWorkflow.steps.set(gpudatatypes::RecoStep::TPCConversion,
+                                      gpudatatypes::RecoStep::TPCSectorTracking,
+                                      gpudatatypes::RecoStep::TPCMerging);
+    mConfig->configWorkflow.outputs.set(gpudatatypes::InOutType::TPCMergedTracks);
   }
   if (mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat) {
-    mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, true);
-    mConfig->configWorkflow.outputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, true);
+    mConfig->configWorkflow.steps.setBits(gpudatatypes::RecoStep::TPCCompression, true);
+    mConfig->configWorkflow.outputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, true);
   }
-  mConfig->configWorkflow.inputs.set(GPUDataTypes::InOutType::TPCClusters);
+  mConfig->configWorkflow.inputs.set(gpudatatypes::InOutType::TPCClusters);
   if (mSpecConfig.caClusterer) { // Override some settings if we have raw data as input
-    mConfig->configWorkflow.inputs.set(GPUDataTypes::InOutType::TPCRaw);
-    mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCClusterFinding, true);
-    mConfig->configWorkflow.outputs.setBits(GPUDataTypes::InOutType::TPCClusters, true);
+    mConfig->configWorkflow.inputs.set(gpudatatypes::InOutType::TPCRaw);
+    mConfig->configWorkflow.steps.setBits(gpudatatypes::RecoStep::TPCClusterFinding, true);
+    mConfig->configWorkflow.outputs.setBits(gpudatatypes::InOutType::TPCClusters, true);
   }
   if (mSpecConfig.decompressTPC) {
-    mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCCompression, false);
-    mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TPCDecompression, true);
-    mConfig->configWorkflow.inputs.set(GPUDataTypes::InOutType::TPCCompressedClusters);
-    mConfig->configWorkflow.outputs.setBits(GPUDataTypes::InOutType::TPCClusters, true);
-    mConfig->configWorkflow.outputs.setBits(GPUDataTypes::InOutType::TPCCompressedClusters, false);
+    mConfig->configWorkflow.steps.setBits(gpudatatypes::RecoStep::TPCCompression, false);
+    mConfig->configWorkflow.steps.setBits(gpudatatypes::RecoStep::TPCDecompression, true);
+    mConfig->configWorkflow.inputs.set(gpudatatypes::InOutType::TPCCompressedClusters);
+    mConfig->configWorkflow.outputs.setBits(gpudatatypes::InOutType::TPCClusters, true);
+    mConfig->configWorkflow.outputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, false);
     if (mTPCSectorMask != 0xFFFFFFFFF) {
       throw std::invalid_argument("Cannot run TPC decompression with a sector mask");
     }
   }
   if (mSpecConfig.runTRDTracking) {
-    mConfig->configWorkflow.inputs.setBits(GPUDataTypes::InOutType::TRDTracklets, true);
-    mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::TRDTracking, true);
+    mConfig->configWorkflow.inputs.setBits(gpudatatypes::InOutType::TRDTracklets, true);
+    mConfig->configWorkflow.steps.setBits(gpudatatypes::RecoStep::TRDTracking, true);
   }
   if (mSpecConfig.runITSTracking) {
-    mConfig->configWorkflow.inputs.setBits(GPUDataTypes::InOutType::ITSClusters, true);
-    mConfig->configWorkflow.outputs.setBits(GPUDataTypes::InOutType::ITSTracks, true);
-    mConfig->configWorkflow.steps.setBits(GPUDataTypes::RecoStep::ITSTracking, true);
+    mConfig->configWorkflow.inputs.setBits(gpudatatypes::InOutType::ITSClusters, true);
+    mConfig->configWorkflow.outputs.setBits(gpudatatypes::InOutType::ITSTracks, true);
+    mConfig->configWorkflow.steps.setBits(gpudatatypes::RecoStep::ITSTracking, true);
   }
   if (mSpecConfig.outputSharedClusterMap) {
     mConfig->configProcessing.outputSharedClusterMap = true;
@@ -935,7 +936,7 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
     }
   }
 
-  if (mConfig->configWorkflow.outputs.isSet(GPUDataTypes::InOutType::TPCMergedTracks)) {
+  if (mConfig->configWorkflow.outputs.isSet(gpudatatypes::InOutType::TPCMergedTracks)) {
     LOG(info) << "found " << ptrs.nOutputTracksTPCO2 << " track(s)";
   }
 
diff --git a/doc/data/2021-01-o2_prs.json b/doc/data/2021-01-o2_prs.json
index 06cd97dd6d7b7..4ccf435f6086a 100644
--- a/doc/data/2021-01-o2_prs.json
+++ b/doc/data/2021-01-o2_prs.json
@@ -895,7 +895,7 @@
                 },
                 {
                   "node": {
-                    "path": "GPU/GPUTracking/Base/GPUDataTypes.h"
+                    "path": "GPU/GPUTracking/Base/GPUDataTypesIO.h"
                   }
                 },
                 {
@@ -2445,7 +2445,7 @@
                 },
                 {
                   "node": {
-                    "path": "GPU/GPUTracking/DataTypes/GPUDataTypes.h"
+                    "path": "GPU/GPUTracking/DataTypes/GPUDataTypesIO.h"
                   }
                 },
                 {

From 670518f435ac5c22c532fbd5d4d696873d8d2db7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 14 Dec 2025 09:43:01 +0100
Subject: [PATCH 1135/1764] Upgrades ECal: Fix codechecker violation

---
 Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx
index 77f7d9219ef6b..f792344f1f50f 100644
--- a/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx
+++ b/Detectors/Upgrades/ALICE3/ECal/DataFormatsECal/src/Cluster.cxx
@@ -50,7 +50,8 @@ int Cluster::getMcTrackID() const
 TLorentzVector Cluster::getMomentum() const
 {
   double r = std::sqrt(mX * mX + mY * mY + mZ * mZ);
-  if (r == 0)
+  if (r == 0) {
     return TLorentzVector();
+  }
   return TLorentzVector(mE * mX / r, mE * mY / r, mE * mZ / r, mE);
 }

From 303fbca420a30dbab975740f576c8673480943a4 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Sun, 14 Dec 2025 22:11:27 +0100
Subject: [PATCH 1136/1764] add previously list init function call

---
 Steer/src/CollisionContextTool.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index b884909aedd9d..6bee407c01264 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -496,6 +496,7 @@ int main(int argc, char* argv[])
       // this loop makes sure that the first collision is within the range of orbits asked (if noEmptyTF is enabled)
       do {
         sampler->setFirstIR(o2::InteractionRecord(options.firstBC, orbitstart));
+        sampler->init();
         record = sampler->generateCollisionTime();
       } while (options.noEmptyTF && usetimeframelength && record.orbit >= orbitstart + orbits_total);
       int count = 0;

From 92f73dd45a43ac26c4fe1f577b75e992b32a84ad Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 15 Dec 2025 11:29:58 +0100
Subject: [PATCH 1137/1764] DPL GUI: Fix activity display (#14916)

---
 .../src/FrameworkGUIDataRelayerUsage.cxx      | 60 ++++++++++---------
 1 file changed, 31 insertions(+), 29 deletions(-)

diff --git a/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx b/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
index 1d3b4f24ea34c..86558d22b973d 100644
--- a/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDataRelayerUsage.cxx
@@ -43,7 +43,7 @@ struct HeatMapHelper {
   {
     float padding = 1;
     // add slider to scroll between the grid display windows
-    size_t nw = getNumRecords() / WND;
+    size_t nw = getNumRecords() < WND ? 1 : getNumRecords() / WND;
     ImGui::PushItemWidth(sizeHint.x);
     ImGui::SliderInt("##window", &v, 1, nw, "wnd: %d", ImGuiSliderFlags_AlwaysClamp);
     ImVec2 sliderMin = ImGui::GetItemRectMin();
@@ -51,7 +51,7 @@ struct HeatMapHelper {
     constexpr float MAX_BOX_X_SIZE = 16.f;
     constexpr float MAX_BOX_Y_SIZE = 16.f;
 
-    ImVec2 size = ImVec2(sizeHint.x, std::min(sizeHint.y, MAX_BOX_Y_SIZE * getNumItems(0) + 2));
+    ImVec2 size = ImVec2(sizeHint.x, std::min(sizeHint.y, MAX_BOX_Y_SIZE * getNumInputs() + 2));
     ImU32 BORDER_COLOR = ImColor(200, 200, 200, 255);
     ImU32 BACKGROUND_COLOR = ImColor(20, 20, 20, 255);
     ImU32 BORDER_COLOR_A = ImColor(200, 200, 200, 0);
@@ -75,19 +75,22 @@ struct HeatMapHelper {
     const static auto colorE = ImColor(ImVec4{0, 0, 0, 0});
 
     drawList->PrimReserve(nw * 6, nw * 4);
-    for (size_t iw = 0; iw < nw; ++iw) {
-      ImVec2 xOffset{iw * xsz + 2 * padding, 0};
+    for (size_t iw = 1; iw <= nw; ++iw) {
+      ImVec2 xOffset{(iw - 1) * xsz + 2 * padding, 0};
       ImVec2 xSize{xsz - 2 * padding, 0};
       ImVec2 yOffset{0, 2 * padding};
-      ImVec2 ySize{0, 16 - 4 * padding};
-      bool active = 0;
-      for (size_t ir = iw; ir < ((iw + WND > getNumRecords()) ? getNumRecords() : iw + WND); ++ir) {
-        for (size_t i = 0; i < getNumItems(ir); ++i) {
-          active = getValue(*getItem(ir, i)) > 0;
+      ImVec2 ySize{0, MAX_BOX_Y_SIZE - 4 * padding};
+      bool active = false;
+      for (size_t ir = (iw - 1) * WND; ir < ((iw * WND > getNumRecords()) ? getNumRecords() : iw * WND); ++ir) {
+        for (size_t i = 0; i < getNumItems(getRecord(ir)); ++i) {
+          active = getValue(*getItem(getRecord(ir), i)) > 0;
           if (active) {
             break;
           }
         }
+        if (active) {
+          break;
+        }
       }
       drawList->PrimRect(
         xOffset + yOffset + winPos,
@@ -96,47 +99,46 @@ struct HeatMapHelper {
     }
 
     // display the grid
-    size_t recordsWindow = v * WND;
     auto boxSizeX = std::min(size.x / WND, MAX_BOX_X_SIZE);
-    auto numInputs = getNumInputs();
+    auto boxSizeY = std::min(size.y / getNumInputs(), MAX_BOX_Y_SIZE);
+
     winPos = ImGui::GetCursorScreenPos() + ImVec2{0, 7};
-    ImGui::InvisibleButton("sensible area", ImVec2(size.x, size.y));
+    ImGui::InvisibleButton("sensitive area", ImVec2(size.x, size.y));
     if (ImGui::IsItemHovered()) {
       auto pos = ImGui::GetMousePos() - winPos;
-      auto slot = (v - 1) * WND + std::lround(std::trunc(pos.x / size.x * WND));
-      auto row = std::lround(std::trunc(pos.y / size.y * numInputs));
+      auto slot = (v - 1) * WND + std::lround(std::trunc(pos.x / boxSizeX));
+      auto row = std::lround(std::trunc(pos.y / boxSizeY));
       describeCell(row, slot);
     }
 
+    // background
     drawList->AddRectFilled(
       ImVec2(0., 0.) + winPos,
       ImVec2{size.x, size.y} + winPos,
       BACKGROUND_COLOR);
+    // border
     drawList->AddRect(
       ImVec2(0. - 1, -1) + winPos,
       ImVec2{size.x + 1, size.y - 1} + winPos,
       BORDER_COLOR);
 
-    size_t totalRects = 0;
-    for (size_t ri = (v - 1) * WND; ri < recordsWindow; ri++) {
-      auto record = getRecord(ri);
-      totalRects += getNumItems(record);
-    }
-
-    drawList->PrimReserve(totalRects * 6, totalRects * 4);
-    for (size_t ri = (v - 1) * WND; ri < recordsWindow; ri++) {
+    // heatmap
+    size_t totalPrims = WND * getNumInputs();
+    drawList->PrimReserve(totalPrims * 6, totalPrims * 4);
+    for (size_t ri = (v - 1) * WND; ri < (((size_t)(v)*WND > getNumRecords()) ? getNumRecords() : v * WND); ++ri) {
       auto record = getRecord(ri);
-      ImVec2 xOffset{((ri - (v - 1) * WND) * boxSizeX) + padding, 0};
+      ImVec2 xOffset{((float)(ri - (v - 1) * WND) * boxSizeX) + padding, 0};
       ImVec2 xSize{boxSizeX - 2 * padding, 0};
-      auto me = getNumItems(record);
-      auto boxSizeY = std::min(size.y / me, MAX_BOX_Y_SIZE);
-      for (size_t mi = 0; mi < me; mi++) {
-        ImVec2 yOffSet{0, (mi * boxSizeY) + padding};
+
+      for (auto mi = 0U; mi < getNumItems(record); mi++) {
+        ImVec2 yOffSet{0, ((float)mi * boxSizeY) + padding};
         ImVec2 ySize{0, boxSizeY - 2 * padding};
 
+        ImVec2 A = xOffset + yOffSet + winPos;
+        ImVec2 B = xOffset + xSize + yOffSet + ySize + winPos;
+
         drawList->PrimRect(
-          xOffset + yOffSet + winPos,
-          xOffset + xSize + yOffSet + ySize + winPos,
+          A, B,
           getColor(getValue(*getItem(record, mi))));
       }
     }

From 4090041b401c7aa6c919ca923126fff950cbccd1 Mon Sep 17 00:00:00 2001
From: iravasen <ivan.ravasenga@cern.ch>
Date: Mon, 15 Dec 2025 19:41:39 +0100
Subject: [PATCH 1138/1764] ITS calib: change option name to avoid ambiguity
 (#14920)

---
 Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
index 0a08841059d63..ce0b840f4a037 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/ThresholdCalibratorSpec.cxx
@@ -74,7 +74,7 @@ void ITSThresholdCalibrator::init(InitContext& ic)
     LOG(warning) << "mColStep = " << mColStep << ": saving s-curves of only 1 pixel (pix 0) per row";
   }
 
-  isLocal = ic.options().get<bool>("local");
+  isLocal = ic.options().get<bool>("local-processing");
 
   std::string fittype = ic.options().get<std::string>("fittype");
   if (fittype == "derivative") {
@@ -2069,7 +2069,7 @@ DataProcessorSpec getITSThresholdCalibratorSpec(const ITSCalibInpConf& inpConf)
             {"meb-select", VariantType::Int, -1, {"Select from which multi-event buffer consider the hits: 0,1 or 2"}},
             {"s-curve-col-step", VariantType::Int, 8, {"save s-curves points to tree every s-curve-col-step  pixels on 1 row"}},
             {"percentage-cut", VariantType::Int, 25, {"discard chip in ITHR/VCASN scan if the percentage of success is less than this cut"}},
-            {"local", VariantType::Bool, false, {"Enable in case of data replay of scans processed row by row or in 1 go in finalize() but with partial data in the raw TF (e.g. data dump stopped before the real end of run)"}}}};
+            {"local-processing", VariantType::Bool, false, {"Enable in case of data replay of scans processed row by row or in 1 go in finalize() but with partial data in the raw TF (e.g. data dump stopped before the real end of run)"}}}};
 }
 } // namespace its
 } // namespace o2

From 2eba0da0195570e9987ee2a65ff5193ebdffbacd Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 11 Nov 2025 10:05:19 +0100
Subject: [PATCH 1139/1764] Common: add host symbols to RangeRef

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/CommonDataFormat/RangeReference.h | 38 +++++++++----------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/DataFormats/common/include/CommonDataFormat/RangeReference.h b/DataFormats/common/include/CommonDataFormat/RangeReference.h
index 0308d3b8af937..3d0c58298de03 100644
--- a/DataFormats/common/include/CommonDataFormat/RangeReference.h
+++ b/DataFormats/common/include/CommonDataFormat/RangeReference.h
@@ -29,23 +29,23 @@ template <typename FirstEntry = int, typename NElem = int>
 class RangeReference
 {
  public:
-  GPUd() RangeReference(FirstEntry ent, NElem n) { set(ent, n); }
-  GPUdDefault() RangeReference(const RangeReference<FirstEntry, NElem>& src) = default;
-  GPUdDefault() RangeReference() = default;
-  GPUdDefault() ~RangeReference() = default;
-  GPUd() void set(FirstEntry ent, NElem n)
+  GPUhd() RangeReference(FirstEntry ent, NElem n) { set(ent, n); }
+  GPUhdDefault() RangeReference(const RangeReference<FirstEntry, NElem>& src) = default;
+  GPUhdDefault() RangeReference() = default;
+  GPUhdDefault() ~RangeReference() = default;
+  GPUhd() void set(FirstEntry ent, NElem n)
   {
     mFirstEntry = ent;
     mEntries = n;
   }
-  GPUd() void clear() { set(0, 0); }
-  GPUd() FirstEntry getFirstEntry() const { return mFirstEntry; }
-  GPUd() FirstEntry getEntriesBound() const { return mFirstEntry + mEntries; }
-  GPUd() NElem getEntries() const { return mEntries; }
-  GPUd() void setFirstEntry(FirstEntry ent) { mFirstEntry = ent; }
-  GPUd() void setEntries(NElem n) { mEntries = n; }
-  GPUd() void changeEntriesBy(NElem inc) { mEntries += inc; }
-  GPUd() bool operator==(const RangeReference& other) const
+  GPUhd() void clear() { set(0, 0); }
+  GPUhd() FirstEntry getFirstEntry() const { return mFirstEntry; }
+  GPUhd() FirstEntry getEntriesBound() const { return mFirstEntry + mEntries; }
+  GPUhd() NElem getEntries() const { return mEntries; }
+  GPUhd() void setFirstEntry(FirstEntry ent) { mFirstEntry = ent; }
+  GPUhd() void setEntries(NElem n) { mEntries = n; }
+  GPUhd() void changeEntriesBy(NElem inc) { mEntries += inc; }
+  GPUhd() bool operator==(const RangeReference& other) const
   {
     return mFirstEntry == other.mFirstEntry && mEntries == other.mEntries;
   }
@@ -68,21 +68,21 @@ class RangeRefComp
   static constexpr Base MaskN = ((0x1 << NBitsN) - 1);
   static constexpr Base MaskR = (~Base(0)) & (~MaskN);
   Base mData = 0; ///< packed 1st entry reference + N entries
-  GPUd() void sanityCheck()
+  GPUhd() void sanityCheck()
   {
     static_assert(NBitsN < NBitsTotal, "NBitsN too large");
   }
 
  public:
-  GPUd() RangeRefComp(int ent, int n) { set(ent, n); }
-  GPUdDefault() RangeRefComp() = default;
-  GPUdDefault() RangeRefComp(const RangeRefComp& src) = default;
+  GPUhd() RangeRefComp(int ent, int n) { set(ent, n); }
+  GPUhdDefault() RangeRefComp() = default;
+  GPUhdDefault() RangeRefComp(const RangeRefComp& src) = default;
   GPUhd() void set(int ent, int n)
   {
     mData = (Base(ent) << NBitsN) + (Base(n) & MaskN);
   }
-  GPUd() static constexpr Base getMaxFirstEntry() { return MaskR >> NBitsN; }
-  GPUd() static constexpr Base getMaxEntries() { return MaskN; }
+  GPUhd() static constexpr Base getMaxFirstEntry() { return MaskR >> NBitsN; }
+  GPUhd() static constexpr Base getMaxEntries() { return MaskN; }
   GPUhd() int getFirstEntry() const { return mData >> NBitsN; }
   GPUhd() int getEntries() const { return mData & ((0x1 << NBitsN) - 1); }
   GPUhd() int getEntriesBound() const { return getFirstEntry() + getEntries(); }

From 33a68caa22edc089ec63ccb92a15890d5b3871b2 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 7 Nov 2025 10:37:22 +0100
Subject: [PATCH 1140/1764] Common: new linkdef for TimeStamp

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 DataFormats/common/src/CommonDataFormatLinkDef.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/DataFormats/common/src/CommonDataFormatLinkDef.h b/DataFormats/common/src/CommonDataFormatLinkDef.h
index 631305cd28f13..d66e89af637cc 100644
--- a/DataFormats/common/src/CommonDataFormatLinkDef.h
+++ b/DataFormats/common/src/CommonDataFormatLinkDef.h
@@ -26,10 +26,12 @@
 #pragma link C++ class o2::dataformats::TimeStamp < float> + ;
 #pragma link C++ class o2::dataformats::TimeStamp < double> + ;
 #pragma link C++ class o2::dataformats::TimeStamp < int> + ;
-#pragma link C++ class o2::dataformats::TimeStamp < Float16_t > + ;
+#pragma link C++ class o2::dataformats::TimeStamp < uint32_t> + ;
+#pragma link C++ class o2::dataformats::TimeStamp < Float16_t> + ;
 #pragma link C++ class o2::dataformats::TimeStampWithError < float, float> + ;
 #pragma link C++ class o2::dataformats::TimeStampWithError < double, double> + ;
 #pragma link C++ class o2::dataformats::TimeStampWithError < int, int> + ;
+#pragma link C++ class o2::dataformats::TimeStampWithError < uint32_t, uint16_t> + ;
 
 #pragma link C++ class o2::dataformats::EvIndex < int, int> + ;
 #pragma link C++ class o2::dataformats::RangeReference < int, int> + ;

From 73948550572a8c1a1280290b15043b9aef17a50e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 25 Nov 2025 14:52:37 +0100
Subject: [PATCH 1141/1764] Reco: Add cov setters for ind. elements

---
 .../ReconstructionDataFormats/Vertex.h        | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
index 2d13e029f8c00..cb1c9d5d87c7f 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
@@ -45,9 +45,17 @@ class VertexBase
   static constexpr int kNCov = 6;
   GPUhdDefault() VertexBase() = default;
   GPUhdDefault() ~VertexBase() = default;
-  GPUhd() VertexBase(const math_utils::Point3D<float>& pos, const std::array<float, kNCov>& cov) : mPos(pos), mCov(cov)
+  GPUhd() VertexBase(const float* pos, const float* cov)
   {
+    mPos = math_utils::Point3D<float>(pos[0], pos[1], pos[2]);
+    mCov[kCovXX] = cov[kCovXX];
+    mCov[kCovXY] = cov[kCovXY];
+    mCov[kCovXZ] = cov[kCovXZ];
+    mCov[kCovYY] = cov[kCovYY];
+    mCov[kCovYZ] = cov[kCovYZ];
+    mCov[kCovZZ] = cov[kCovZZ];
   }
+  GPUhd() VertexBase(const math_utils::Point3D<float>& pos, const std::array<float, kNCov>& cov) : mPos(pos), mCov(cov) {}
 
 #if !defined(GPUCA_NO_FMT) && !defined(GPUCA_GPUCODE_DEVICE)
   void print() const;
@@ -58,6 +66,7 @@ class VertexBase
   GPUhd() float getX() const { return mPos.X(); }
   GPUhd() float getY() const { return mPos.Y(); }
   GPUhd() float getZ() const { return mPos.Z(); }
+  GPUhd() float getR() const { return gpu::CAMath::Hypot(mPos.X(), mPos.Y()); }
   GPUd() float getSigmaX2() const { return mCov[kCovXX]; }
   GPUd() float getSigmaY2() const { return mCov[kCovYY]; }
   GPUd() float getSigmaZ2() const { return mCov[kCovZZ]; }
@@ -69,6 +78,7 @@ class VertexBase
   GPUd() float getSigmaZ() const { return gpu::CAMath::Sqrt(getSigmaZ2()); }
 
   GPUd() const std::array<float, kNCov>& getCov() const { return mCov; }
+  GPUd() float getCov(int e) const { return mCov[e]; }
 
   GPUd() math_utils::Point3D<float> getXYZ() const { return mPos; }
   GPUd() math_utils::Point3D<float>& getXYZ() { return mPos; }
@@ -105,6 +115,7 @@ class VertexBase
     setSigmaYZ(syz);
   }
   GPUd() void setCov(const std::array<float, kNCov>& cov) { mCov = cov; }
+  GPUd() void setCov(float c, int e) { mCov[e] = c; }
 
   bool operator==(const VertexBase& other) const;
   bool operator!=(const VertexBase& other) const { return !(*this == other); }
@@ -133,10 +144,8 @@ class Vertex : public VertexBase
 
   GPUhdDefault() Vertex() = default;
   GPUhdDefault() ~Vertex() = default;
-  GPUhd() Vertex(const math_utils::Point3D<float>& pos, const std::array<float, kNCov>& cov, ushort nCont, float chi2)
-    : VertexBase(pos, cov), mChi2(chi2), mNContributors(nCont)
-  {
-  }
+  GPUhd() Vertex(const float* pos, const float* cov, ushort nCont, float chi2) : VertexBase(pos, cov), mChi2(chi2), mNContributors(nCont) {}
+  GPUhd() Vertex(const math_utils::Point3D<float>& pos, const std::array<float, kNCov>& cov, ushort nCont, float chi2) : VertexBase(pos, cov), mChi2(chi2), mNContributors(nCont) {}
 
 #if !defined(GPUCA_NO_FMT) && !defined(GPUCA_GPUCODE_DEVICE)
   void print() const;

From 0244a9838fd7dfff28a8fbff1fa0597af6a6234f Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 16 Dec 2025 11:37:27 +0100
Subject: [PATCH 1142/1764] ITSMFT&ITS3&TRK: load response functions from ccdb
 (#14902)

* ITSMFT&ITS3: load response functions from ccdb

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* TRK: load response function from ccdb

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../data/AlpideResponseData/CMakeLists.txt    | 25 --------
 .../include/ITSMFTSimulation/Digitizer.h      | 10 ++--
 .../common/simulation/src/Digitizer.cxx       | 30 ++--------
 .../include/TRKSimulation/DigiParams.h        | 11 ++--
 .../include/TRKSimulation/Digitizer.h         | 12 ++--
 .../ALICE3/TRK/simulation/src/DigiParams.cxx  | 13 +++-
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   | 10 +---
 .../TRK/simulation/src/TRKSimulationLinkDef.h |  1 +
 Detectors/Upgrades/ITS3/CMakeLists.txt        |  1 -
 Detectors/Upgrades/ITS3/data/CMakeLists.txt   | 34 -----------
 .../include/ITS3Simulation/DigiParams.h       |  9 +--
 .../include/ITS3Simulation/Digitizer.h        | 20 +++----
 .../ITS3/simulation/src/DigiParams.cxx        | 10 ++--
 .../ITS3/simulation/src/Digitizer.cxx         | 59 +++++--------------
 .../src/ITS3DigitizerSpec.cxx                 | 15 +++++
 .../src/ITSMFTDigitizerSpec.cxx               | 14 +++++
 .../src/TRKDigitizerSpec.cxx                  |  6 ++
 17 files changed, 106 insertions(+), 174 deletions(-)
 delete mode 100644 Detectors/Upgrades/ITS3/data/CMakeLists.txt

diff --git a/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt b/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
index d1f3e756394b1..f985857afa88c 100644
--- a/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
+++ b/Detectors/ITSMFT/common/data/AlpideResponseData/CMakeLists.txt
@@ -9,33 +9,8 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-
 o2_add_executable(alpide-response-generator
                   SOURCES AlpideResponse.cxx
                   PUBLIC_LINK_LIBRARIES O2::ITSMFTSimulation
                                         ROOT::Core
                   TARGETVARNAME targetName)
-
-set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/Detectors/ITSMFT/common/data/AlpideResponseData/AlpideResponse.cxx)
-
-if(ITSRESPONSE)
-  message(STATUS "ITSRESPONSE option provided, setting ITSRESPONSE_DIR from it: " ${ITSRESPONSE})
-  set(ITSRESPONSE_DIR ${ITSRESPONSE} CACHE PATH "ITSResponse directory")
-else()
-  message(STATUS "ITSRESPONSE option not provided, setting ITSRESPONSE_DIR from environment ITSRESPONSE_ROOT: " $ENV{ITSRESPONSE_ROOT})
-  set(ITSRESPONSE_DIR $ENV{ITSRESPONSE_ROOT} CACHE PATH "ITSResponse directory")
-endif()
-
-add_custom_command(TARGET O2exe-alpide-response-generator POST_BUILD
-                   COMMAND ${CMAKE_BINARY_DIR}/stage/bin/o2-alpide-response-generator -i ${ITSRESPONSE_DIR}/response/AlpideResponseData/ -o ${CMAKE_CURRENT_BINARY_DIR}/
-                   BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/AlpideResponseData.root
-                   COMMENT "Generating AlpideResponseData.root"
-)
-
-# # Add a target that depends on the custom command output
-add_custom_target(
-  GenerateAlpideResponse ALL
-  DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/AlpideResponseData.root
-)
-
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/AlpideResponseData.root" DESTINATION "${CMAKE_INSTALL_PREFIX}/share/Detectors/ITSMFT/data/AlpideResponseData/")
diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
index e3995068c52cf..670dd32bf9f46 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
@@ -62,6 +62,7 @@ class Digitizer : public TObject
   void setDeadChannelsMap(const o2::itsmft::NoiseMap* mp) { mDeadChanMap = mp; }
 
   void init();
+  void setAlpideResponse(const o2::itsmft::AlpideSimResponse* resp, int i) { mAlpSimResp[i] = resp; }
 
   auto getChipResponse(int chipID);
 
@@ -124,11 +125,10 @@ class Digitizer : public TObject
   uint32_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)
 
   int mNumberOfChips = 0;
-  o2::itsmft::AlpideSimResponse* mAlpSimRespMFT = nullptr;
-  o2::itsmft::AlpideSimResponse* mAlpSimRespIB = nullptr;
-  o2::itsmft::AlpideSimResponse* mAlpSimRespOB = nullptr;
-  o2::itsmft::AlpideSimResponse mAlpSimResp[2]; // simulated response
-  std::string mResponseFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
+  const o2::itsmft::AlpideSimResponse* mAlpSimRespMFT = nullptr;
+  const o2::itsmft::AlpideSimResponse* mAlpSimRespIB = nullptr;
+  const o2::itsmft::AlpideSimResponse* mAlpSimRespOB = nullptr;
+  const o2::itsmft::AlpideSimResponse* mAlpSimResp[2]; // simulated response
   const o2::itsmft::GeometryTGeo* mGeometry = nullptr; ///< ITS OR MFT upgrade geometry
 
   std::vector<o2::itsmft::ChipDigitsContainer> mChips; ///< Array of chips digits containers
diff --git a/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx b/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
index e5dd35e6a084d..53e0a2fcb096f 100644
--- a/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
+++ b/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
@@ -48,24 +48,6 @@ void Digitizer::init()
       mChips[i].setDeadChanMap(mDeadChanMap);
     }
   }
-  // initializing for both collection tables
-  /*for (int i = 0; i < 2; i++) {
-    mAlpSimResp[i].initData(i);
-  }*/
-
-  // importing the charge collection tables
-  // (initialized while building O2)
-  auto file = TFile::Open(mResponseFile.data());
-  if (!file) {
-    LOG(fatal) << "Cannot open response file " << mResponseFile;
-  }
-  /*std::string response = "response";
-  for (int i=0; i<2; i++) {
-    response.append(std::to_string(i));
-    mAlpSimResp[i] = *(o2::itsmft::AlpideSimResponse*)file->Get(response.data());
-  }*/
-  mAlpSimResp[0] = *(o2::itsmft::AlpideSimResponse*)file->Get("response0");
-  mAlpSimResp[1] = *(o2::itsmft::AlpideSimResponse*)file->Get("response1");
 
   // importing the parameters from DPLDigitizerParam.h
   auto& doptMFT = DPLDigitizerParam<o2::detectors::DetID::MFT>::Instance();
@@ -73,29 +55,29 @@ void Digitizer::init()
 
   // initializing response according to detector and back-bias value
   if (doptMFT.Vbb == 0.0) { // for MFT
-    mAlpSimRespMFT = mAlpSimResp;
+    mAlpSimRespMFT = mAlpSimResp[0];
     LOG(info) << "Choosing Vbb=0V for MFT";
   } else if (doptMFT.Vbb == 3.0) {
-    mAlpSimRespMFT = mAlpSimResp + 1;
+    mAlpSimRespMFT = mAlpSimResp[1];
     LOG(info) << "Choosing Vbb=-3V for MFT";
   } else {
     LOG(fatal) << "Invalid MFT back-bias value";
   }
 
   if (doptITS.IBVbb == 0.0) { // for ITS Inner Barrel
-    mAlpSimRespIB = mAlpSimResp;
+    mAlpSimRespIB = mAlpSimResp[0];
     LOG(info) << "Choosing Vbb=0V for ITS IB";
   } else if (doptITS.IBVbb == 3.0) {
-    mAlpSimRespIB = mAlpSimResp + 1;
+    mAlpSimRespIB = mAlpSimResp[1];
     LOG(info) << "Choosing Vbb=-3V for ITS IB";
   } else {
     LOG(fatal) << "Invalid ITS Inner Barrel back-bias value";
   }
   if (doptITS.OBVbb == 0.0) { // for ITS Outter Barrel
-    mAlpSimRespOB = mAlpSimResp;
+    mAlpSimRespOB = mAlpSimResp[0];
     LOG(info) << "Choosing Vbb=0V for ITS OB";
   } else if (doptITS.OBVbb == 3.0) {
-    mAlpSimRespOB = mAlpSimResp + 1;
+    mAlpSimRespOB = mAlpSimResp[1];
     LOG(info) << "Choosing Vbb=-3V for ITS OB";
   } else {
     LOG(fatal) << "Invalid ITS Outter Barrel back-bias value";
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
index 970b20c48816e..0463a68a77c3e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
@@ -16,7 +16,8 @@
 #define ALICEO2_TRK_DIGIPARAMS_H
 
 #include <Rtypes.h>
-#include <ITSMFTSimulation/AlpideSignalTrapezoid.h>
+#include "ITSMFTSimulation/AlpideSignalTrapezoid.h"
+#include "ITSMFTSimulation/AlpideSimResponse.h"
 #include "TRKBase/TRKBaseParam.h"
 #include "TRKBase/GeometryTGeo.h"
 
@@ -91,8 +92,8 @@ class DigiParams
 
   bool isTimeOffsetSet() const { return mTimeOffset > -infTime; }
 
-  const o2::trk::ChipSimResponse* getAlpSimResponse() const { return mAlpSimResponse; }
-  void setAlpSimResponse(const o2::trk::ChipSimResponse* par) { mAlpSimResponse = par; }
+  const o2::trk::ChipSimResponse* getAlpSimResponse() const { return mAlpSimResponse.get(); }
+  void setAlpSimResponse(const o2::itsmft::AlpideSimResponse*);
 
   const SignalShape& getSignalShape() const { return mSignalShape; }
   SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
@@ -122,7 +123,7 @@ class DigiParams
 
   o2::itsmft::AlpideSignalTrapezoid mSignalShape; ///< signal timeshape parameterization
 
-  const o2::trk::ChipSimResponse* mAlpSimResponse = nullptr; //!< pointer on external response
+  std::unique_ptr<o2::trk::ChipSimResponse> mAlpSimResponse; //!< pointer on external response
 
   // auxiliary precalculated parameters
   float mROFrameLengthInv = 0; ///< inverse length of RO frame in ns
@@ -132,4 +133,4 @@ class DigiParams
 } // namespace trk
 } // namespace o2
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
index 8e7173af8b820..221d7b342bf59 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
@@ -51,7 +51,7 @@ class Digitizer
 
   void init();
 
-  o2::trk::ChipSimResponse* getChipResponse(int chipID);
+  const o2::trk::ChipSimResponse* getChipResponse(int chipID);
 
   /// Steer conversion of hits to digits
   void process(const std::vector<o2::trk::Hit>* hits, int evID, int srcID);
@@ -66,7 +66,6 @@ class Digitizer
   bool isContinuous() const { return mParams.isContinuous(); }
   void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
 
-  void setDigiParams(const o2::trk::DigiParams& par) { mParams = par; }
   const o2::trk::DigiParams& getDigitParams() const { return mParams; }
 
   // provide the common trk::GeometryTGeo to access matrices and segmentation
@@ -142,12 +141,9 @@ class Digitizer
 
   int mNumberOfChips = 0;
 
-  o2::trk::ChipSimResponse* mChipSimResp = nullptr;     // simulated response
-  o2::trk::ChipSimResponse* mChipSimRespVD = nullptr;   // simulated response for VD chips
-  o2::trk::ChipSimResponse* mChipSimRespMLOT = nullptr; // simulated response for ML/OT chips
-
-  // std::string mResponseFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
-  std::string mResponseFile = "$(O2_ROOT)/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/APTSResponseData.root"; /// using temporarly the APTS response
+  const o2::trk::ChipSimResponse* mChipSimResp = nullptr;     // simulated response
+  const o2::trk::ChipSimResponse* mChipSimRespVD = nullptr;   // simulated response for VD chips
+  const o2::trk::ChipSimResponse* mChipSimRespMLOT = nullptr; // simulated response for ML/OT chips
 
   bool mSimRespOrientation{false};   // wether the orientation in the response function is flipped
   float mSimRespVDShift{0.f};        // adjusting the Y-shift in the APTS response function to match sensor local coord.
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
index df6f46ac0ecb0..ca4685d53de2a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
@@ -12,9 +12,10 @@
 /// \file DigiParams.cxx
 /// \brief Implementation of the TRK digitization steering params. Based on the ITS2 code.
 
-#include <fairlogger/Logger.h> // for LOG
-#include "TRKSimulation/DigiParams.h"
 #include <cassert>
+#include "Framework/Logger.h"
+#include "TRKSimulation/DigiParams.h"
+#include "TRKSimulation/ChipSimResponse.h"
 
 using namespace o2::trk;
 
@@ -70,3 +71,11 @@ void DigiParams::print() const
   printf("Charge time-response:\n");
   mSignalShape.print();
 }
+
+void DigiParams::setAlpSimResponse(const o2::itsmft::AlpideSimResponse* resp)
+{
+  if (!resp) {
+    LOGP(fatal, "cannot set response function from null");
+  }
+  mAlpSimResponse = std::make_unique<o2::trk::ChipSimResponse>(resp);
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 20509782f21ee..3ee952801f0c3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -48,15 +48,9 @@ void Digitizer::init()
       mChips[i].setDeadChanMap(mDeadChanMap);
     }
   }
-  // importing the charge collection tables
-  // (initialized while building O2)
-  auto file = TFile::Open(mResponseFile.data());
-  if (!file) {
-    LOG(fatal) << "Cannot open response file " << mResponseFile;
-  }
 
   // setting the correct response function (for the moment, for both VD and MLOT the APTS response function is udes)
-  mChipSimResp = (o2::trk::ChipSimResponse*)file->Get("response1");
+  mChipSimResp = mParams.getAlpSimResponse();
   mChipSimRespVD = mChipSimResp;   /// for the moment considering the same response
   mChipSimRespMLOT = mChipSimResp; /// for the moment considering the same response
 
@@ -92,7 +86,7 @@ void Digitizer::init()
   mIRFirstSampledTF = o2::raw::HBFUtils::Instance().getFirstSampledTFIR();
 }
 
-o2::trk::ChipSimResponse* Digitizer::getChipResponse(int chipID)
+const o2::trk::ChipSimResponse* Digitizer::getChipResponse(int chipID)
 {
   if (mGeometry->getSubDetID(chipID) == 0) { /// VD
     return mChipSimRespVD;
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
index 9af868a2de44c..fec9cb6631a6f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
@@ -24,6 +24,7 @@
 #pragma link C++ class o2::trk::Detector + ;
 #pragma link C++ class o2::base::DetImpl < o2::trk::Detector> + ;
 #pragma link C++ class o2::trk::Digitizer + ;
+#pragma link C++ class o2::trk::ChipSimResponse + ;
 
 #pragma link C++ class o2::trk::DPLDigitizerParam < o2::detectors::DetID::TRK> + ;
 #pragma link C++ class o2::trk::DPLDigitizerParam < o2::detectors::DetID::FT3> + ;
diff --git a/Detectors/Upgrades/ITS3/CMakeLists.txt b/Detectors/Upgrades/ITS3/CMakeLists.txt
index 5e40e59ad0068..bdaf1b4bf4292 100644
--- a/Detectors/Upgrades/ITS3/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/CMakeLists.txt
@@ -12,7 +12,6 @@
 #add_compile_options(-O0 -g -fPIC -fsanitize=address)
 #add_link_options(-fsanitize=address)
 
-add_subdirectory(data)
 add_subdirectory(simulation)
 add_subdirectory(alignment)
 add_subdirectory(base)
diff --git a/Detectors/Upgrades/ITS3/data/CMakeLists.txt b/Detectors/Upgrades/ITS3/data/CMakeLists.txt
deleted file mode 100644
index 7a807fd670370..0000000000000
--- a/Detectors/Upgrades/ITS3/data/CMakeLists.txt
+++ /dev/null
@@ -1,34 +0,0 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-# All rights not expressly granted are reserved.
-#
-# This software is distributed under the terms of the GNU General Public
-# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-#
-# In applying this license CERN does not waive the privileges and immunities
-# granted to it by virtue of its status as an Intergovernmental Organization
-# or submit itself to any jurisdiction.
-
-set(APTS_RESPONSE_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/APTSResponseData.root")
-
-add_custom_command(
-  OUTPUT ${APTS_RESPONSE_OUTPUT}
-  COMMAND ${CMAKE_BINARY_DIR}/stage/bin/o2-alpide-response-generator
-    -c APTS
-    -i ${ITSRESPONSE_DIR}/response/ITS3ChipResponseData/AptsResponseData/
-    -o ${CMAKE_CURRENT_BINARY_DIR}/
-  DEPENDS GenerateAlpideResponse
-          ${ITSRESPONSE_DIR}/response/ITS3ChipResponseData/AptsResponseData/
-  COMMENT "Generating APTSResponseData.root"
-  VERBATIM
-)
-
-add_custom_target(
-  GenerateAPTSResponse ALL
-  DEPENDS ${APTS_RESPONSE_OUTPUT}
-)
-
-install(
-  FILES ${APTS_RESPONSE_OUTPUT}
-  DESTINATION "${CMAKE_INSTALL_PREFIX}/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/"
-)
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
index 5764dfbd7d593..e3a2a5d0d0efb 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DigiParams.h
@@ -48,16 +48,17 @@ class DigiParams final : public o2::itsmft::DigiParams
   const o2::itsmft::AlpideSimResponse* getOBSimResponse() const { return mOBSimResponse; }
   void setOBSimResponse(const o2::itsmft::AlpideSimResponse* response) { mOBSimResponse = response; }
 
-  o2::its3::ChipSimResponse* getIBSimResponse() const { return mIBSimResponse; }
-  void setIBSimResponse(o2::its3::ChipSimResponse* response);
+  o2::its3::ChipSimResponse* getIBSimResponse() const { return mIBSimResponse.get(); }
+  void setIBSimResponse(const o2::itsmft::AlpideSimResponse* resp);
 
   bool hasResponseFunctions() const { return mIBSimResponse != nullptr && mOBSimResponse != nullptr; }
 
   void print() const final;
 
  private:
-  const o2::itsmft::AlpideSimResponse* mOBSimResponse = nullptr; //!< pointer to external response
-  o2::its3::ChipSimResponse* mIBSimResponse = nullptr;           //!< pointer to external response
+  const o2::itsmft::AlpideSimResponse* mOBSimResponse = nullptr;       //!< pointer to external response
+  const o2::itsmft::AlpideSimResponse* mIBSimResponseExt = nullptr;    //!< pointer to external response
+  std::unique_ptr<o2::its3::ChipSimResponse> mIBSimResponse = nullptr; //!< pointer to external response
 
   ClassDef(DigiParams, 1);
 };
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
index a2dd1102091da..866973083983b 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/Digitizer.h
@@ -42,7 +42,7 @@ class Digitizer : public TObject
   using ExtraDig = std::vector<itsmft::PreDigitLabelRef>; ///< container for extra contributions to PreDigits
 
  public:
-  ~Digitizer();
+  ~Digitizer() = default;
 
   void setDigits(std::vector<o2::itsmft::Digit>* dig) { mDigits = dig; }
   void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
@@ -111,18 +111,18 @@ class Digitizer : public TObject
 
   static constexpr std::array<o2::its3::SegmentationMosaix, 3> mIBSegmentations{0, 1, 2};
 
-  o2::its3::ChipSimResponse* mSimRespIB = nullptr;     // simulated response for IB
-  o2::itsmft::AlpideSimResponse* mSimRespOB = nullptr; // simulated response for OB
-  bool mSimRespIBOrientation{false};                   // wether the orientation in the IB response function is flipped
-  float mSimRespIBShift{0.f};                          // adjusting the Y-shift in the IB response function to match sensor local coord.
-  float mSimRespIBScaleX{1.f};                         // scale x-local coordinate to response function x-coordinate
-  float mSimRespIBScaleZ{1.f};                         // scale z-local coordinate to response function z-coordinate
-  float mSimRespOBShift{0.f};                          // adjusting the Y-shift in the OB response function to match sensor local coord.
+  const o2::its3::ChipSimResponse* mSimRespIB = nullptr;     // simulated response for IB
+  const o2::itsmft::AlpideSimResponse* mSimRespOB = nullptr; // simulated response for OB
+  bool mSimRespIBOrientation{false};                         // wether the orientation in the IB response function is flipped
+  float mSimRespIBShift{0.f};                                // adjusting the Y-shift in the IB response function to match sensor local coord.
+  float mSimRespIBScaleX{1.f};                               // scale x-local coordinate to response function x-coordinate
+  float mSimRespIBScaleZ{1.f};                               // scale z-local coordinate to response function z-coordinate
+  float mSimRespOBShift{0.f};                                // adjusting the Y-shift in the OB response function to match sensor local coord.
 
   const o2::its::GeometryTGeo* mGeometry = nullptr; ///< ITS3 geometry
 
-  std::vector<o2::its3::ChipDigitsContainer> mChips;   ///< Array of chips digits containers
-  std::deque<std::unique_ptr<ExtraDig>> mExtraBuff;    ///< burrer (per roFrame) for extra digits
+  std::vector<o2::its3::ChipDigitsContainer> mChips; ///< Array of chips digits containers
+  std::deque<std::unique_ptr<ExtraDig>> mExtraBuff;  ///< burrer (per roFrame) for extra digits
 
   std::vector<o2::itsmft::Digit>* mDigits = nullptr;                       //! output digits
   std::vector<o2::itsmft::ROFRecord>* mROFRecords = nullptr;               //! output ROF records
diff --git a/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx b/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx
index afa02ec44741d..e5923d0bb7a1e 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/DigiParams.cxx
@@ -69,12 +69,14 @@ void DigiParams::print() const
   getSignalShape().print();
 }
 
-void DigiParams::setIBSimResponse(o2::its3::ChipSimResponse* response)
+void DigiParams::setIBSimResponse(const o2::itsmft::AlpideSimResponse* resp)
 {
-  mIBSimResponse = response;
-  if (mIBSimResponse) {
-    mIBSimResponse->computeCentreFromData();
+  if (!resp) {
+    LOGP(fatal, "cannot set response from nullptr");
   }
+  mIBSimResponseExt = resp;
+  mIBSimResponse = std::make_unique<o2::its3::ChipSimResponse>(mIBSimResponseExt);
+  mIBSimResponse->computeCentreFromData();
 }
 
 } // namespace o2::its3
diff --git a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
index 7dd7110801f4a..4560a656c1762 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
@@ -35,11 +35,6 @@ using o2::itsmft::PreDigit;
 
 using namespace o2::its3;
 
-Digitizer::~Digitizer()
-{
-  delete mSimRespIB;
-}
-
 void Digitizer::init()
 {
   const int numOfChips = mGeometry->getNumberOfChips();
@@ -53,46 +48,22 @@ void Digitizer::init()
   }
 
   if (!mParams.hasResponseFunctions()) {
-    auto loadSetResponseFunc = [&](const char* fileIB, const char* nameIB, const char* fileOB, const char* nameOB) {
-      LOGP(info, "Loading response function IB={}:{} ; OB={}:{}", nameIB, fileIB, nameOB, fileOB);
-      auto fIB = TFile::Open(fileIB, "READ");
-      if (!fIB || fIB->IsZombie() || !fIB->IsOpen()) {
-        LOGP(fatal, "Cannot open file {}", fileIB);
-      }
-      auto fOB = TFile::Open(fileOB, "READ");
-      if (!fOB || fOB->IsZombie() || !fOB->IsOpen()) {
-        LOGP(fatal, "Cannot open file {}", fileOB);
-      }
-      if ((mSimRespIB = new o2::its3::ChipSimResponse(fIB->Get<o2::itsmft::AlpideSimResponse>(nameIB))) == nullptr) {
-        LOGP(fatal, "Cannot create response function for IB");
-      }
-      if ((mSimRespOB = fOB->Get<o2::itsmft::AlpideSimResponse>(nameOB)) == nullptr) {
-        LOGP(fatal, "Cannot create response function for OB");
-      }
-      mParams.setIBSimResponse(mSimRespIB);
-      mParams.setOBSimResponse(mSimRespOB);
-      fIB->Close();
-      fOB->Close();
-    };
-
-    if (const auto& func = ITS3Params::Instance().chipResponseFunction; func == "Alpide") {
-      constexpr const char* responseFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
-      loadSetResponseFunc(responseFile, "response0", responseFile, "response0");
-      mSimRespIBScaleX = o2::itsmft::SegmentationAlpide::PitchRow / SegmentationIB::PitchRow;
-      mSimRespIBScaleZ = o2::itsmft::SegmentationAlpide::PitchCol / SegmentationIB::PitchCol;
-    } else if (func == "APTS") {
-      constexpr const char* responseFileIB = "$(O2_ROOT)/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/APTSResponseData.root";
-      constexpr const char* responseFileOB = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
-      loadSetResponseFunc(responseFileIB, "response1", responseFileOB, "response0");
-      mSimRespIBScaleX = constants::pixelarray::pixels::apts::pitchX / SegmentationIB::PitchRow;
-      mSimRespIBScaleZ = constants::pixelarray::pixels::apts::pitchZ / SegmentationIB::PitchCol;
-      mSimRespIBOrientation = true;
-    } else {
-      LOGP(fatal, "ResponseFunction '{}' not implemented!", func);
-    }
-    mSimRespIBShift = mSimRespIB->getDepthMax() - constants::silicon::thickness / 2.f;
-    mSimRespOBShift = mSimRespOB->getDepthMax() - SegmentationOB::SensorLayerThickness / 2.f;
+    LOGP(fatal, "No response functions set!");
+  }
+  if (const auto& func = ITS3Params::Instance().chipResponseFunction; func == "Alpide") {
+    mSimRespIBScaleX = o2::itsmft::SegmentationAlpide::PitchRow / SegmentationIB::PitchRow;
+    mSimRespIBScaleZ = o2::itsmft::SegmentationAlpide::PitchCol / SegmentationIB::PitchCol;
+  } else if (func == "APTS") {
+    mSimRespIBScaleX = constants::pixelarray::pixels::apts::pitchX / SegmentationIB::PitchRow;
+    mSimRespIBScaleZ = constants::pixelarray::pixels::apts::pitchZ / SegmentationIB::PitchCol;
+    mSimRespIBOrientation = true;
+  } else {
+    LOGP(fatal, "ResponseFunction '{}' not implemented!", func);
   }
+  mSimRespIB = mParams.getIBSimResponse();
+  mSimRespOB = mParams.getOBSimResponse();
+  mSimRespIBShift = mSimRespIB->getDepthMax() - constants::silicon::thickness / 2.f;
+  mSimRespOBShift = mSimRespOB->getDepthMax() - SegmentationOB::SensorLayerThickness / 2.f;
 
   mParams.print();
   LOGP(info, "IB shift = {} ; OB shift = {}", mSimRespIBShift, mSimRespOBShift);
diff --git a/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
index af0af091d40e8..639203bdd6d38 100644
--- a/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
@@ -254,6 +254,11 @@ class ITS3DPLDigitizerTask : BaseDPLDigitizer
         pc.inputs().get<o2::itsmft::NoiseMap*>("IT3_dead"); // trigger final ccdb update
       }
 
+      pc.inputs().get<o2::itsmft::AlpideSimResponse*>("IT3_alpiderespvbb0");
+      if (o2::its3::ITS3Params::Instance().chipResponseFunction != "Alpide") {
+        pc.inputs().get<o2::itsmft::AlpideSimResponse*>("IT3_aptsresp");
+      }
+
       // init digitizer
       mDigitizer.init();
     }
@@ -273,6 +278,14 @@ class ITS3DPLDigitizerTask : BaseDPLDigitizer
       mDigitizer.setDeadChannelsMap((o2::itsmft::NoiseMap*)obj);
       return;
     }
+    if (matcher == ConcreteDataMatcher(mOrigin, "ALPIDERESPVbb0", 0)) {
+      LOG(info) << mID.getName() << " loaded AlpideResponseData for Vbb=0V";
+      mDigitizer.getParams().setOBSimResponse((o2::itsmft::AlpideSimResponse*)obj);
+    }
+    if (matcher == ConcreteDataMatcher(mOrigin, "APTSRESP", 0)) {
+      LOG(info) << mID.getName() << " loaded APTSResponseData";
+      mDigitizer.getParams().setIBSimResponse((o2::itsmft::AlpideSimResponse*)obj);
+    }
   }
 
  private:
@@ -306,6 +319,8 @@ DataProcessorSpec getITS3DigitizerSpec(int channel, bool mctruth)
   if (o2::its3::ITS3Params::Instance().useDeadChannelMap) {
     inputs.emplace_back("IT3_dead", "IT3", "DEADMAP", 0, Lifetime::Condition, ccdbParamSpec("IT3/Calib/DeadMap"));
   }
+  inputs.emplace_back("IT3_alpiderespvbb0", "IT3", "ALPIDERESPVbb0", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbb0"));
+  inputs.emplace_back("IT3_aptsresp", "IT3", "APTSRESP", 0, Lifetime::Condition, ccdbParamSpec("IT3/Calib/APTSResponse"));
 
   return DataProcessorSpec{detStr + "Digitizer",
                            inputs, makeOutChannels(detOrig, mctruth),
diff --git a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
index 72ec65b2e522b..b40e377d58ca2 100644
--- a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
@@ -222,6 +222,14 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
       }
       return;
     }
+    if (matcher == ConcreteDataMatcher(mOrigin, "ALPIDERESPVbb0", 0)) {
+      LOG(info) << mID.getName() << " loaded AlpideResponseData for Vbb=0V";
+      mDigitizer.setAlpideResponse((o2::itsmft::AlpideSimResponse*)obj, 0);
+    }
+    if (matcher == ConcreteDataMatcher(mOrigin, "ALPIDERESPVbbM3", 0)) {
+      LOG(info) << mID.getName() << " loaded AlpideResponseData for Vbb=-3V";
+      mDigitizer.setAlpideResponse((o2::itsmft::AlpideSimResponse*)obj, 1);
+    }
   }
 
  protected:
@@ -236,6 +244,8 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
     // TODO: the code should run even if this object does not exist. Or: create default object
     pc.inputs().get<o2::itsmft::TimeDeadMap*>(detstr + "_time_dead");
     pc.inputs().get<o2::itsmft::DPLAlpideParam<DETID>*>(detstr + "_alppar");
+    pc.inputs().get<o2::itsmft::AlpideSimResponse*>(detstr + "_alpiderespvbb0");
+    pc.inputs().get<o2::itsmft::AlpideSimResponse*>(detstr + "_alpiderespvbbm3");
 
     auto& dopt = o2::itsmft::DPLDigitizerParam<DETID>::Instance();
     auto& aopt = o2::itsmft::DPLAlpideParam<DETID>::Instance();
@@ -365,6 +375,8 @@ DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth)
   inputs.emplace_back("ITS_dead", "ITS", "DEADMAP", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/DeadMap"));
   inputs.emplace_back("ITS_time_dead", "ITS", "TimeDeadMap", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/TimeDeadMap"));
   inputs.emplace_back("ITS_alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+  inputs.emplace_back("ITS_alpiderespvbb0", "ITS", "ALPIDERESPVbb0", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbb0"));
+  inputs.emplace_back("ITS_alpiderespvbbm3", "ITS", "ALPIDERESPVbbM3", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbbM3"));
 
   return DataProcessorSpec{(detStr + "Digitizer").c_str(),
                            inputs, makeOutChannels(detOrig, mctruth),
@@ -384,6 +396,8 @@ DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth)
   inputs.emplace_back("MFT_dead", "MFT", "DEADMAP", 0, Lifetime::Condition, ccdbParamSpec("MFT/Calib/DeadMap"));
   inputs.emplace_back("MFT_time_dead", "MFT", "TimeDeadMap", 0, Lifetime::Condition, ccdbParamSpec("MFT/Calib/TimeDeadMap"));
   inputs.emplace_back("MFT_alppar", "MFT", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("MFT/Config/AlpideParam"));
+  inputs.emplace_back("MFT_alpiderespvbb0", "MFT", "ALPIDERESPVbb0", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbb0"));
+  inputs.emplace_back("MFT_alpiderespvbbm3", "MFT", "ALPIDERESPVbbM3", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbbM3"));
   parHelper << "Params as " << o2::itsmft::DPLDigitizerParam<ITSDPLDigitizerTask::DETID>::getParamName().data() << ".<param>=value;... with"
             << o2::itsmft::DPLDigitizerParam<ITSDPLDigitizerTask::DETID>::Instance()
             << " or " << o2::itsmft::DPLAlpideParam<ITSDPLDigitizerTask::DETID>::getParamName().data() << ".<param>=value;... with"
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
index 37355cb5752c4..a3d4d1f245fc5 100644
--- a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
@@ -244,6 +244,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       // if (oTRKParams::Instance().useDeadChannelMap) {
       //   pc.inputs().get<o2::itsmft::NoiseMap*>("TRK_dead"); // trigger final ccdb update
       // }
+      pc.inputs().get<o2::itsmft::AlpideSimResponse*>("TRK_aptsresp");
 
       // init digitizer
       mDigitizer.init();
@@ -264,6 +265,10 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     //   mDigitizer.setDeadChannelsMap((o2::itsmft::NoiseMap*)obj);
     //   return;
     // }
+    if (matcher == ConcreteDataMatcher(mOrigin, "APTSRESP", 0)) {
+      LOG(info) << mID.getName() << " loaded APTSResponseData";
+      mDigitizer.getParams().setAlpSimResponse((const o2::itsmft::AlpideSimResponse*)obj);
+    }
   }
 
  private:
@@ -297,6 +302,7 @@ DataProcessorSpec getTRKDigitizerSpec(int channel, bool mctruth)
   // if (oTRKParams::Instance().useDeadChannelMap) {
   //   inputs.emplace_back("TRK_dead", "TRK", "DEADMAP", 0, Lifetime::Condition, ccdbParamSpec("TRK/Calib/DeadMap"));
   // }
+  inputs.emplace_back("TRK_aptsresp", "TRK", "APTSRESP", 0, Lifetime::Condition, ccdbParamSpec("IT3/Calib/APTSResponse"));
 
   return DataProcessorSpec{detStr + "Digitizer",
                            inputs, makeOutChannels(detOrig, mctruth),

From 1bcfeed348dd3bbc16345b622f2d03bc1626f0c0 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sawenzel@gmail.com>
Date: Tue, 16 Dec 2025 12:40:18 +0100
Subject: [PATCH 1143/1764] Update CODEOWNERS

---
 CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 117ff0d92b272..26021d458ad76 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -34,7 +34,7 @@
 /DataFormats/Detectors/GlobalTracking          @shahor02
 /DataFormats/Detectors/GlobalTrackingWorkflow  @shahor02
 /DataFormats/Detectors/HMPID                   @gvolpe79
-/DataFormats/Detectors/ITSMFT                  @fprino @mcoquet642 @mconcas @shahor02
+/DataFormats/Detectors/ITSMFT                  @fprino @mcoquet642 @shahor02
 /DataFormats/Detectors/MUON                    @AliceO2Group/muon-experts @shahor02
 /DataFormats/Detectors/PHOS                    @peressounko @kharlov
 /DataFormats/Detectors/Passive                 @sawenzel

From 528a5a59130c425ad933531cc65a54dc371e28ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Tue, 16 Dec 2025 16:50:47 +0100
Subject: [PATCH 1144/1764] Refine parameter getter methods with error handling
 (#14794)

Updated getter functions to specify return types and added error logging for missing parameters.
---
 .../TOF/include/DataFormatsTOF/ParameterContainers.h   | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h b/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
index e64bf8aa3e276..224906e43b8c6 100644
--- a/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
+++ b/DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h
@@ -210,7 +210,13 @@ class ParameterCollection : public TNamed
   }
 
   /// @brief getter for the parameters stored in the container matching to a pass
-  const auto& getPars(const std::string& pass) const { return mParameters.at(pass); }
+  const std::unordered_map<std::string, paramvar_t>& getPars(const std::string& pass) const
+  {
+    if (!hasKey(pass)) {
+      LOG(fatal) << "Parameters for pass " << pass << " not found!";
+    }
+    return mParameters.at(pass);
+  }
 
   /// @brief printing function for the content of the pass
   /// @param pass pass to print
@@ -221,7 +227,7 @@ class ParameterCollection : public TNamed
 
   /// @brief Getter of the full map of parameters stored in the container
   /// @return returns the full map of parameters
-  const auto& getFullMap() { return mParameters; }
+  const std::unordered_map<std::string, std::unordered_map<std::string, paramvar_t>>& getFullMap() const { return mParameters; }
 
   /// Loader from file
   /// \param FileName name of the input file

From 70b10405ca2ffe3103bc01b26fde13b1a13ea6c9 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 16 Dec 2025 22:02:47 +0100
Subject: [PATCH 1145/1764] DPL: modernize workflow construction code using
 ranges (#14907)

---
 .../Framework/AnalysisSupportHelpers.h        |   5 -
 .../Core/include/Framework/DataSpecViews.h    |  43 +++++-
 Framework/Core/src/AnalysisSupportHelpers.cxx | 127 +++++-------------
 Framework/Core/src/ArrowSupport.cxx           |  60 +++------
 Framework/Core/src/WorkflowHelpers.cxx        |  64 +++------
 5 files changed, 114 insertions(+), 185 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisSupportHelpers.h b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
index cc4d45a46c8bc..c0eeb3bd9697d 100644
--- a/Framework/Core/include/Framework/AnalysisSupportHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
@@ -39,11 +39,6 @@ struct AnalysisSupportHelpers {
                                          std::vector<InputSpec> const& requestedSpecials,
                                          std::vector<InputSpec>& requestedAODs,
                                          DataProcessorSpec& publisher);
-  static void addMissingOutputsToAnalysisCCDBFetcher(std::vector<OutputSpec> const& providedSpecials,
-                                                     std::vector<InputSpec> const& requestedSpecials,
-                                                     std::vector<InputSpec>& requestedAODs,
-                                                     std::vector<InputSpec>& requestedDYNs,
-                                                     DataProcessorSpec& publisher);
   static void addMissingOutputsToBuilder(std::vector<InputSpec> const& requestedSpecials,
                                          std::vector<InputSpec>& requestedAODs,
                                          std::vector<InputSpec>& requestedDYNs,
diff --git a/Framework/Core/include/Framework/DataSpecViews.h b/Framework/Core/include/Framework/DataSpecViews.h
index 0782cefd0f632..162a12419594e 100644
--- a/Framework/Core/include/Framework/DataSpecViews.h
+++ b/Framework/Core/include/Framework/DataSpecViews.h
@@ -31,6 +31,32 @@ static auto filter_not_matching(auto const& provided)
   return std::views::filter([&provided](auto const& input) { return std::none_of(provided.begin(), provided.end(), [&input](auto const& output) { return DataSpecUtils::match(input, output); }); });
 }
 
+static auto filter_matching(auto const& provided)
+{
+  return std::views::filter([&provided](auto const& input) { return std::any_of(provided.begin(), provided.end(), [&input](auto const& output) { return DataSpecUtils::match(input, output); }); });
+}
+
+static auto filter_string_params_with(std::string match)
+{
+  return std::views::filter([match](auto const& param) {
+    return (param.type == VariantType::String) && (param.name.find(match) != std::string::npos);
+  });
+}
+
+static auto input_to_output_specs()
+{
+  return std::views::transform([](auto const& input) {
+    auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
+    return OutputSpec{concrete.origin, concrete.description, concrete.subSpec, input.lifetime, input.metadata};
+  });
+}
+
+static auto params_to_input_specs()
+{
+  return std::views::transform([](auto const& param) {
+    return DataSpecUtils::fromMetadataString(param.defaultValue.template get<std::string>());
+  });
+}
 } // namespace o2::framework::views
 //
 namespace o2::framework::sinks
@@ -54,7 +80,7 @@ struct update_input_list {
   template <std::ranges::input_range R>
   friend Container& operator|(R&& r, update_input_list self)
   {
-    for (auto& item : r) {
+    for (auto const& item : r) {
       auto copy = item;
       DataSpecUtils::updateInputList(self.c, std::move(copy));
     }
@@ -62,6 +88,21 @@ struct update_input_list {
   }
 };
 
+template <class Container>
+struct update_output_list {
+  Container& c;
+  // ends the pipeline, returns the container
+  template <std::ranges::input_range R>
+  friend Container& operator|(R&& r, update_output_list self)
+  {
+    for (auto const& item : r) {
+      auto copy = item;
+      DataSpecUtils::updateOutputList(self.c, std::move(copy));
+    }
+    return self.c;
+  }
+};
+
 } // namespace o2::framework::sinks
 
 #endif // O2_FRAMEWORK_DATASPECVIEWS_H_
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index b5c898faa515a..e59f36c72bdab 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -11,10 +11,7 @@
 
 #include "Framework/AnalysisSupportHelpers.h"
 #include "Framework/DataOutputDirector.h"
-#include "Framework/OutputObjHeader.h"
-#include "Framework/ControlService.h"
-#include "Framework/EndOfStreamContext.h"
-#include "Framework/DeviceSpec.h"
+#include "Framework/DataSpecViews.h"
 #include "Framework/PluginManager.h"
 #include "Framework/ConfigContext.h"
 #include "WorkflowHelpers.h"
@@ -129,30 +126,11 @@ void AnalysisSupportHelpers::addMissingOutputsToReader(std::vector<OutputSpec> c
                                                        std::vector<InputSpec> const& requestedInputs,
                                                        DataProcessorSpec& publisher)
 {
-  auto matchingOutputFor = [](InputSpec const& requested) {
-    return [&requested](OutputSpec const& provided) {
-      return DataSpecUtils::match(requested, provided);
-    };
-  };
-  for (InputSpec const& requested : requestedInputs) {
-    auto provided = std::find_if(providedOutputs.begin(),
-                                 providedOutputs.end(),
-                                 matchingOutputFor(requested));
-
-    if (provided != providedOutputs.end()) {
-      continue;
-    }
-
-    auto inList = std::find_if(publisher.outputs.begin(),
-                               publisher.outputs.end(),
-                               matchingOutputFor(requested));
-    if (inList != publisher.outputs.end()) {
-      continue;
-    }
-
-    auto concrete = DataSpecUtils::asConcreteDataMatcher(requested);
-    publisher.outputs.emplace_back(concrete.origin, concrete.description, concrete.subSpec, requested.lifetime, requested.metadata);
-  }
+  requestedInputs |
+    views::filter_not_matching(providedOutputs) |   // filter the inputs that are already provided
+    views::filter_not_matching(publisher.outputs) | // filter the inputs that are already covered
+    views::input_to_output_specs() |
+    sinks::append_to{publisher.outputs}; // append them to the publisher outputs
 }
 
 void AnalysisSupportHelpers::addMissingOutputsToSpawner(std::vector<OutputSpec> const& providedSpecials,
@@ -160,25 +138,20 @@ void AnalysisSupportHelpers::addMissingOutputsToSpawner(std::vector<OutputSpec>
                                                         std::vector<InputSpec>& requestedAODs,
                                                         DataProcessorSpec& publisher)
 {
-  for (auto& input : requestedSpecials) {
-    if (std::any_of(providedSpecials.begin(), providedSpecials.end(), [&input](auto const& x) {
-          return DataSpecUtils::match(input, x);
-        })) {
-      continue;
-    }
-    auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
-    publisher.outputs.emplace_back(concrete.origin, concrete.description, concrete.subSpec);
-    for (auto& i : input.metadata) {
-      if ((i.type == VariantType::String) && (i.name.find("input:") != std::string::npos)) {
-        auto spec = DataSpecUtils::fromMetadataString(i.defaultValue.get<std::string>());
-        auto j = std::find(publisher.inputs.begin(), publisher.inputs.end(), spec);
-        if (j == publisher.inputs.end()) {
-          publisher.inputs.push_back(spec);
-        }
-        DataSpecUtils::updateInputList(requestedAODs, std::move(spec));
-      }
-    }
+  requestedSpecials |
+    views::filter_not_matching(providedSpecials) | // filter the inputs that are already provided
+    views::input_to_output_specs() |
+    sinks::append_to{publisher.outputs}; // append them to the publisher outputs
+
+  std::vector<InputSpec> additionalInputs;
+  for (auto& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
+    input.metadata |
+      views::filter_string_params_with("input:") |
+      views::params_to_input_specs() |
+      sinks::update_input_list{additionalInputs}; // store into a temporary
   }
+  additionalInputs | sinks::update_input_list{requestedAODs};    // update requestedAODs
+  additionalInputs | sinks::update_input_list{publisher.inputs}; // update publisher inputs
 }
 
 void AnalysisSupportHelpers::addMissingOutputsToBuilder(std::vector<InputSpec> const& requestedSpecials,
@@ -186,52 +159,26 @@ void AnalysisSupportHelpers::addMissingOutputsToBuilder(std::vector<InputSpec> c
                                                         std::vector<InputSpec>& requestedDYNs,
                                                         DataProcessorSpec& publisher)
 {
-  for (auto& input : requestedSpecials) {
-    auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
-    publisher.outputs.emplace_back(concrete.origin, concrete.description, concrete.subSpec);
-    for (auto& i : input.metadata) {
-      if ((i.type == VariantType::String) && (i.name.find("input:") != std::string::npos)) {
-        auto spec = DataSpecUtils::fromMetadataString(i.defaultValue.get<std::string>());
-        auto j = std::find_if(publisher.inputs.begin(), publisher.inputs.end(), [&](auto x) { return x.binding == spec.binding; });
-        if (j == publisher.inputs.end()) {
-          publisher.inputs.push_back(spec);
-        }
-        if (DataSpecUtils::partialMatch(spec, AODOrigins)) {
-          DataSpecUtils::updateInputList(requestedAODs, std::move(spec));
-        } else if (DataSpecUtils::partialMatch(spec, header::DataOrigin{"DYN"})) {
-          DataSpecUtils::updateInputList(requestedDYNs, std::move(spec));
-        }
-      }
-    }
+  requestedSpecials |
+    views::input_to_output_specs() |
+    sinks::append_to{publisher.outputs}; // append them to the publisher outputs
+
+  std::vector<InputSpec> additionalInputs;
+  for (auto const& input : requestedSpecials) {
+    input.metadata |
+      views::filter_string_params_with("input:") |
+      views::params_to_input_specs() |
+      sinks::update_input_list{additionalInputs}; // store into a temporary
   }
-}
 
-void AnalysisSupportHelpers::addMissingOutputsToAnalysisCCDBFetcher(
-  std::vector<OutputSpec> const& providedSpecials,
-  std::vector<InputSpec> const& requestedSpecials,
-  std::vector<InputSpec>& requestedAODs,
-  std::vector<InputSpec>& requestedDYNs,
-  DataProcessorSpec& publisher)
-{
-  for (auto& input : requestedSpecials) {
-    auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
-    publisher.outputs.emplace_back(concrete.origin, concrete.description, concrete.subSpec);
-    // FIXME: good enough for now...
-    for (auto& i : input.metadata) {
-      if ((i.type == VariantType::String) && (i.name.find("input:") != std::string::npos)) {
-        auto spec = DataSpecUtils::fromMetadataString(i.defaultValue.get<std::string>());
-        auto j = std::find_if(publisher.inputs.begin(), publisher.inputs.end(), [&](auto x) { return x.binding == spec.binding; });
-        if (j == publisher.inputs.end()) {
-          publisher.inputs.push_back(spec);
-        }
-        if (DataSpecUtils::partialMatch(spec, AODOrigins)) {
-          DataSpecUtils::updateInputList(requestedAODs, std::move(spec));
-        } else if (DataSpecUtils::partialMatch(spec, header::DataOrigin{"DYN"})) {
-          DataSpecUtils::updateInputList(requestedDYNs, std::move(spec));
-        }
-      }
-    }
-  }
+  additionalInputs | sinks::update_input_list{publisher.inputs}; // update publisher inputs
+  // FIXME: until we have a single list of pairs
+  additionalInputs |
+    views::partial_match_filter(AODOrigins) |
+    sinks::update_input_list{requestedAODs}; // update requestedAODs
+  additionalInputs |
+    views::partial_match_filter(header::DataOrigin{"DYN"}) |
+    sinks::update_input_list{requestedDYNs}; // update requestedDYNs
 }
 
 // =============================================================================
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index cf2d364027932..26594252e888b 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -595,23 +595,16 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
       ac.providedTIMs.clear();
       ac.requestedTIMs.clear();
 
-
       auto inputSpecLessThan = [](InputSpec const& lhs, InputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
       auto outputSpecLessThan = [](OutputSpec const& lhs, OutputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
 
       if (builder != workflow.end()) {
         // collect currently requested IDXs
         ac.requestedIDXs.clear();
-        for (auto& d : workflow) {
-          if (d.name == builder->name) {
-            continue;
-          }
-          for (auto& i : d.inputs) {
-            if (DataSpecUtils::partialMatch(i, header::DataOrigin{"IDX"})) {
-              auto copy = i;
-              DataSpecUtils::updateInputList(ac.requestedIDXs, std::move(copy));
-            }
-          }
+        for (auto& d : workflow | views::exclude_by_name(builder->name)) {
+          d.inputs |
+            views::partial_match_filter(header::DataOrigin{"IDX"}) |
+            sinks::update_input_list{ac.requestedIDXs};
         }
         // recreate inputs and outputs
         builder->inputs.clear();
@@ -624,37 +617,27 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
 
       if (spawner != workflow.end()) {
         // collect currently requested DYNs
-        for (auto& d : workflow) {
-          if (d.name == spawner->name) {
-            continue;
-          }
-          for (auto const& i : d.inputs) {
-            if (DataSpecUtils::partialMatch(i, header::DataOrigin{"DYN"})) {
-              auto copy = i;
-              DataSpecUtils::updateInputList(ac.requestedDYNs, std::move(copy));
-            }
-          }
-          for (auto const& o : d.outputs) {
-            if (DataSpecUtils::partialMatch(o, header::DataOrigin{"DYN"})) {
-              ac.providedDYNs.emplace_back(o);
-            }
-          }
+        for (auto& d : workflow | views::exclude_by_name(spawner->name)) {
+          d.inputs |
+            views::partial_match_filter(header::DataOrigin{"DYN"}) |
+            sinks::update_input_list{ac.requestedDYNs};
+          d.outputs |
+            views::partial_match_filter(header::DataOrigin{"DYN"}) |
+            sinks::append_to{ac.providedDYNs};
         }
         std::sort(ac.requestedDYNs.begin(), ac.requestedDYNs.end(), inputSpecLessThan);
         std::sort(ac.providedDYNs.begin(), ac.providedDYNs.end(), outputSpecLessThan);
         ac.spawnerInputs.clear();
-        for (auto& input : ac.requestedDYNs) {
-          if (std::none_of(ac.providedDYNs.begin(), ac.providedDYNs.end(), [&input](auto const& x) { return DataSpecUtils::match(input, x); })) {
-            ac.spawnerInputs.emplace_back(input);
-          }
-        }
+        ac.requestedDYNs |
+          views::filter_not_matching(ac.providedDYNs) |
+          sinks::append_to{ac.spawnerInputs};
         // recreate inputs and outputs
         spawner->outputs.clear();
         spawner->inputs.clear();
+        AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, *spawner);
         // replace AlgorithmSpec
         // FIXME: it should be made more generic, so it does not need replacement...
         spawner->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx);
-        AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, *spawner);
       }
 
       if (analysisCCDB != workflow.end()) {
@@ -675,7 +658,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         // FIXME: it should be made more generic, so it does not need replacement...
         // FIXME how can I make the lookup depend on DYN tables as well??
         analysisCCDB->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
-        AnalysisSupportHelpers::addMissingOutputsToAnalysisCCDBFetcher({}, ac.analysisCCDBInputs, ac.requestedAODs, ac.requestedDYNs, *analysisCCDB);
+        AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.analysisCCDBInputs, ac.requestedAODs, ac.requestedDYNs, *analysisCCDB);
       }
 
       if (writer != workflow.end()) {
@@ -686,12 +669,9 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         // If reader and/or builder were adjusted, remove unneeded outputs
         // update currently requested AODs
         for (auto& d : workflow) {
-          for (auto const& i : d.inputs) {
-            if (DataSpecUtils::partialMatch(i, AODOrigins)) {
-              auto copy = i;
-              DataSpecUtils::updateInputList(ac.requestedAODs, std::move(copy));
-            }
-          }
+          d.inputs |
+            views::partial_match_filter(AODOrigins) |
+            sinks::update_input_list{ac.requestedAODs};
         }
 
         // remove unmatched outputs
@@ -705,8 +685,6 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         }
       }
 
-
-
       // replace writer as some outputs may have become dangling and some are now consumed
       auto [outputsInputs, isDangling] = WorkflowHelpers::analyzeOutputs(workflow);
 
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 17f6c9eb7ddb6..02141678fec7c 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -19,7 +19,6 @@
 #include "Framework/DataSpecUtils.h"
 #include "Framework/DataSpecViews.h"
 #include "Framework/DataAllocator.h"
-#include "Framework/ControlService.h"
 #include "Framework/RawDeviceService.h"
 #include "Framework/StringHelpers.h"
 #include "Framework/ChannelSpecHelpers.h"
@@ -157,18 +156,6 @@ int defaultConditionQueryRateMultiplier()
 
 void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext& ctx)
 {
-  auto fakeCallback = AlgorithmSpec{[](InitContext& ic) {
-    LOG(info) << "This is not a real device, merely a placeholder for external inputs";
-    LOG(info) << "To be hidden / removed at some point.";
-    // mark this dummy process as ready-to-quit
-    ic.services().get<ControlService>().readyToQuit(QuitRequest::Me);
-
-    return [](ProcessingContext& pc) {
-      // this callback is never called since there is no expiring input
-      pc.services().get<RawDeviceService>().waitFor(2000);
-    };
-  }};
-
   DataProcessorSpec ccdbBackend{
     .name = "internal-dpl-ccdb-backend",
     .outputs = {},
@@ -281,20 +268,9 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       processor.options.push_back(ConfigParamSpec{"end-value-enumeration", VariantType::Int64, -1ll, {"final value for the enumeration"}});
       processor.options.push_back(ConfigParamSpec{"step-value-enumeration", VariantType::Int64, 1ll, {"step between one value and the other"}});
     }
-    bool hasTimeframeInputs = false;
-    for (auto& input : processor.inputs) {
-      if (input.lifetime == Lifetime::Timeframe) {
-        hasTimeframeInputs = true;
-        break;
-      }
-    }
-    bool hasTimeframeOutputs = false;
-    for (auto& output : processor.outputs) {
-      if (output.lifetime == Lifetime::Timeframe) {
-        hasTimeframeOutputs = true;
-        break;
-      }
-    }
+    bool hasTimeframeInputs = std::any_of(processor.inputs.begin(), processor.inputs.end(), [](auto const& input) { return input.lifetime == Lifetime::Timeframe; });
+    bool hasTimeframeOutputs = std::any_of(processor.outputs.begin(), processor.outputs.end(), [](auto const& output) { return output.lifetime == Lifetime::Timeframe; });
+
     // A timeframeSink consumes timeframes without creating new
     // timeframe data.
     bool timeframeSink = hasTimeframeInputs && !hasTimeframeOutputs;
@@ -304,14 +280,13 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
         uint32_t hash = runtime_hash(processor.name.c_str());
         bool hasMatch = false;
         ConcreteDataMatcher summaryMatcher = ConcreteDataMatcher{"DPL", "SUMMARY", static_cast<DataAllocator::SubSpecificationType>(hash)};
-        for (auto& output : processor.outputs) {
-          if (DataSpecUtils::match(output, summaryMatcher)) {
-            O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "output enumeration", "%{public}s already there in %{public}s",
-                                   DataSpecUtils::describe(output).c_str(), processor.name.c_str());
-            hasMatch = true;
-            break;
-          }
+        auto summaryOutput = std::find_if(processor.outputs.begin(), processor.outputs.end(), [&summaryMatcher](auto const& output) { return DataSpecUtils::match(output, summaryMatcher); });
+        if (summaryOutput != processor.outputs.end()) {
+          O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "output enumeration", "%{public}s already there in %{public}s",
+                                 DataSpecUtils::describe(*summaryOutput).c_str(), processor.name.c_str());
+          hasMatch = true;
         }
+
         if (!hasMatch) {
           O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "output enumeration", "Adding DPL/SUMMARY/%d to %{public}s", hash, processor.name.c_str());
           processor.outputs.push_back(OutputSpec{{"dpl-summary"}, ConcreteDataMatcher{"DPL", "SUMMARY", static_cast<DataAllocator::SubSpecificationType>(hash)}});
@@ -339,18 +314,12 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
           timer.outputs.emplace_back(OutputSpec{concrete.origin, concrete.description, concrete.subSpec, Lifetime::Enumeration});
         } break;
         case Lifetime::Condition: {
-          for (auto& option : processor.options) {
-            if (option.name == "condition-backend") {
-              hasConditionOption = true;
-              break;
-            }
-          }
-          if (hasConditionOption == false) {
+          requestedCCDBs.emplace_back(input);
+          if ((hasConditionOption == false) && std::none_of(processor.options.begin(), processor.options.end(), [](auto const& option) { return (option.name.compare("condition-backend") == 0); })) {
             processor.options.emplace_back(ConfigParamSpec{"condition-backend", VariantType::String, defaultConditionBackend(), {"URL for CCDB"}});
             processor.options.emplace_back(ConfigParamSpec{"condition-timestamp", VariantType::Int64, 0ll, {"Force timestamp for CCDB lookup"}});
             hasConditionOption = true;
           }
-          requestedCCDBs.emplace_back(input);
         } break;
         case Lifetime::OutOfBand: {
           auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
@@ -422,14 +391,10 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   ac.requestedTIMs | views::filter_not_matching(ac.providedTIMs) | sinks::append_to{ac.analysisCCDBInputs};
   DeploymentMode deploymentMode = DefaultsHelpers::deploymentMode();
   if (deploymentMode != DeploymentMode::OnlineDDS && deploymentMode != DeploymentMode::OnlineECS) {
-    AnalysisSupportHelpers::addMissingOutputsToAnalysisCCDBFetcher({}, ac.analysisCCDBInputs, ac.requestedAODs, ac.requestedTIMs, analysisCCDBBackend);
+    AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.analysisCCDBInputs, ac.requestedAODs, ac.requestedTIMs, analysisCCDBBackend);
   }
 
-  for (auto& input : ac.requestedDYNs) {
-    if (std::none_of(ac.providedDYNs.begin(), ac.providedDYNs.end(), [&input](auto const& x) { return DataSpecUtils::match(input, x); })) {
-      ac.spawnerInputs.emplace_back(input);
-    }
-  }
+  ac.requestedDYNs | views::filter_not_matching(ac.providedDYNs) | sinks::append_to{ac.spawnerInputs};
 
   DataProcessorSpec aodSpawner{
     "internal-dpl-aod-spawner",
@@ -440,6 +405,9 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, aodSpawner);
 
   AnalysisSupportHelpers::addMissingOutputsToReader(ac.providedAODs, ac.requestedAODs, aodReader);
+
+  std::sort(requestedCCDBs.begin(), requestedCCDBs.end(), inputSpecLessThan);
+  std::sort(providedCCDBs.begin(), providedCCDBs.end(), outputSpecLessThan);
   AnalysisSupportHelpers::addMissingOutputsToReader(providedCCDBs, requestedCCDBs, ccdbBackend);
 
   std::vector<DataProcessorSpec> extraSpecs;

From a8feeedb8e05bc06b6fd4186199a2cfc7fe89204 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 17 Dec 2025 09:13:23 +0100
Subject: [PATCH 1146/1764] Avoid early initialization of Cling

Requires v6-36-04-alice7 in order to compile / work.
---
 .../TPC/base/src/TPCFlagsMemberCustomStreamer.cxx    | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx b/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
index dca7ba35004c9..27ebfeb3c64bb 100644
--- a/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
+++ b/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
@@ -71,16 +71,10 @@ namespace ROOT
 {
 static __attribute__((used)) int _R__dummyStreamer_3 =
   ([]() {
-    auto cl = TClass::GetClass<o2::tpc::CalArray<o2::tpc::PadFlags>>();
-    if (cl) {
-      if (!getenv("TPC_PADFLAGS_STREAMER_OFF")) {
-        cl->AdoptMemberStreamer("mData", new TMemberStreamer(MemberVectorPadFlagsStreamer));
-      }
-    } else {
-      // we should never come here ... and if we do we should assert/fail
-      assert(false);
+    if (!getenv("TPC_PADFLAGS_STREAMER_OFF")) {
+      ROOT::GenerateInitInstance((o2::tpc::CalArray<o2::tpc::PadFlags> *)nullptr)->AdoptMemberStreamer("mData", new TMemberStreamer(MemberVectorPadFlagsStreamer));
     }
     return 0;
   })();
 } // namespace ROOT
-#endif
\ No newline at end of file
+#endif

From 4804b1c165d38b5163376d94f19bc35d88681897 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 20 Nov 2025 15:16:43 +0100
Subject: [PATCH 1147/1764] Common: EnumFlags add set

---
 Common/Utils/include/CommonUtils/EnumFlags.h | 148 +++++---
 Common/Utils/test/testEnumFlags.cxx          | 345 +++++++++++++++++++
 2 files changed, 449 insertions(+), 44 deletions(-)

diff --git a/Common/Utils/include/CommonUtils/EnumFlags.h b/Common/Utils/include/CommonUtils/EnumFlags.h
index 4bd1a9e641056..e7481c903e666 100644
--- a/Common/Utils/include/CommonUtils/EnumFlags.h
+++ b/Common/Utils/include/CommonUtils/EnumFlags.h
@@ -54,10 +54,12 @@ concept EnumFlagHelper = requires {
 // functions and also check via concepts expected properties of the enum.
 // This is very much inspired by much more extensive libraries like magic_enum.
 // Inspiration by its c++20 version (https://github.com/fix8mt/conjure_enum).
+// NOTE: Cannot detect if bit values past the underlying type are defined.
 template <EnumFlagHelper E>
 struct FlagsHelper final {
   using U = std::underlying_type_t<E>;
   using UMax = uint64_t; // max represetable type
+  static_assert(std::numeric_limits<U>::digits <= std::numeric_limits<UMax>::digits, "Underlying type has more digits than max supported digits");
 
   static constexpr bool isScoped() noexcept
   {
@@ -108,7 +110,7 @@ struct FlagsHelper final {
   static constexpr size_t MaxUnderScan{std::numeric_limits<U>::digits}; // Maximum digits the underlying type has
   static constexpr size_t MaxScan{MaxUnderScan + MarginScan};
 
-  // Checks if a given 'localation' contains an enum.
+  // Checks if a given 'location' contains an enum.
   template <E e>
   static constexpr bool isValid() noexcept
   {
@@ -128,14 +130,14 @@ struct FlagsHelper final {
       // check if this is an anonymous enum
       return true;
     }
-    return false;
-#else
+#elif __GNUC__
     else if constexpr (tpeek_v<e>[tp + getSpec<SVal::Start, SType::Enum_t>().size()] != '(' && tpeek_v<e>.find_first_of(getSpec<SVal::End, SType::Enum_t>(), tp + getSpec<SVal::Start, SType::Enum_t>().size()) != std::string_view::npos) {
       return true;
-    } else {
-      return false;
     }
+#else
+#error Unsupported compiler
 #endif
+    return false;
   }
 
   // Extract which values are present in the enum by checking all values in
@@ -161,7 +163,7 @@ struct FlagsHelper final {
   static constexpr auto Max_v{Values.back()};                                                          // Enum last entry
   static constexpr auto Min_u_v{static_cast<size_t>(Min_v)};                                           // Enum first entry as size_t
   static constexpr auto Max_u_v{static_cast<size_t>(Max_v)};                                           // Enum last entry as size_t
-  static_assert(Max_u_v < std::numeric_limits<U>::digits, "Max Bit is beyond allow range defered from underlying type");
+  static_assert(Max_u_v < std::numeric_limits<U>::digits, "Max Bit is beyond allow range deferred from underlying type");
   static constexpr bool isContinuous() noexcept { return (Max_u_v - Min_u_v + 1) == count(); } // Is the enum continuous
   static constexpr UMax makeMaxRep(size_t min, size_t max)
   {
@@ -258,7 +260,7 @@ struct FlagsHelper final {
   static constexpr std::optional<E> fromString(std::string_view str) noexcept
   {
     for (size_t i{0}; i < count(); ++i) {
-      if (Names[i] == str || NamesScoped[i] == str) {
+      if (isIEqual(Names[i], str) || isIEqual(NamesScoped[i], str)) {
         return Values[i];
       }
     }
@@ -277,7 +279,7 @@ struct FlagsHelper final {
     return toLower(a) == toLower(b);
   }
 
-  // Case-insensitive comparision for string_view.
+  // Case-insensitive comparison for string_view.
   static constexpr bool isIEqual(std::string_view s1, std::string_view s2) noexcept
   {
     if (s1.size() != s2.size()) {
@@ -294,7 +296,7 @@ struct FlagsHelper final {
   static constexpr std::string_view None{"none"};
   static constexpr bool hasNone() noexcept
   {
-    // check that enum does not contain memeber named 'none'
+    // check that enum does not contain member named 'none'
     for (size_t i{0}; i < count(); ++i) {
       if (isIEqual(Names[i], None)) {
         return true;
@@ -306,7 +308,7 @@ struct FlagsHelper final {
   static constexpr std::string_view All{"all"};
   static constexpr bool hasAll() noexcept
   {
-    // check that enum does not contain memeber named 'all'
+    // check that enum does not contain member named 'all'
     for (size_t i{0}; i < count(); ++i) {
       if (isIEqual(Names[i], All)) {
         return true;
@@ -332,7 +334,7 @@ concept EnumFlag = requires {
 };
 
 /**
- * \brief Classs to aggregate and manage enum-based on-off flags.
+ * \brief Class to aggregate and manage enum-based on-off flags.
  *
  * This class manages flags as bits in the underlying type of an enum (upto 64 bits), allowing
  * manipulation via enum member names. It supports operations akin to std::bitset
@@ -355,6 +357,7 @@ concept EnumFlag = requires {
 template <EnumFlag E>
 class EnumFlags
 {
+  static constexpr int DefaultBase{2};
   using H = details::enum_flags::FlagsHelper<E>;
   using U = std::underlying_type_t<E>;
   U mBits{0};
@@ -388,9 +391,10 @@ class EnumFlags
     std::for_each(flags.begin(), flags.end(), [this](const E f) noexcept { mBits |= to_bit(f); });
   }
   // Init from a string.
-  EnumFlags(const std::string& str)
+  //
+  explicit EnumFlags(const std::string& str, int base = DefaultBase)
   {
-    set(str);
+    set(str, base);
   }
   // Destructor.
   constexpr ~EnumFlags() = default;
@@ -413,14 +417,14 @@ class EnumFlags
   // Sets flags from a string representation.
   // This can be either from a number representation (binary or digits) or
   // a concatenation of the enums members name e.g., 'Enum1|Enum2|...'
-  void set(const std::string& s = "", int base = 2)
+  void set(const std::string& s, int base = DefaultBase)
   {
-    // on throw restore previous state and rethrow
-    const U prev = mBits;
-    reset();
     if (s.empty()) { // no-op
       return;
     }
+    // on throw restore previous state and rethrow
+    const U prev = mBits;
+    reset();
     try {
       setImpl(s, base);
     } catch (const std::exception& e) {
@@ -441,39 +445,42 @@ class EnumFlags
   }
 
   // Resets a specific flag.
-  template <typename T>
-    requires std::is_same_v<T, E>
+  template <std::same_as<E> T>
   constexpr void reset(T t)
   {
     mBits &= ~to_bit(t);
   }
 
   // Tests if a specific flag is set.
-  template <typename T>
-    requires std::is_same_v<T, E>
+  template <std::same_as<E> T>
   [[nodiscard]] constexpr bool test(T t) const noexcept
   {
     return (mBits & to_bit(t)) != None;
   }
 
   // Tests if all specified flags are set.
-  template <typename... Ts>
+  template <std::same_as<E>... Ts>
   [[nodiscard]] constexpr bool test(Ts... flags) const noexcept
   {
     return ((test(flags) && ...));
   }
 
   // Sets a specific flag.
-  template <typename T>
-    requires std::is_same_v<T, E>
+  template <std::same_as<E> T>
   constexpr void set(T t) noexcept
   {
     mBits |= to_bit(t);
   }
 
+  // Sets multiple specific flags.
+  template <std::same_as<E>... Ts>
+  constexpr void set(Ts... flags) noexcept
+  {
+    (set(flags), ...);
+  }
+
   // Toggles a specific flag.
-  template <typename T>
-    requires std::is_same_v<T, E>
+  template <std::same_as<E> T>
   constexpr void toggle(T t) noexcept
   {
     mBits ^= to_bit(t);
@@ -538,8 +545,7 @@ class EnumFlags
   }
 
   // Check if given flag is set.
-  template <typename T>
-    requires std::is_same_v<T, E>
+  template <std::same_as<E> T>
   [[nodiscard]] constexpr bool operator[](const T t) const noexcept
   {
     return test(t);
@@ -564,8 +570,7 @@ class EnumFlags
   constexpr EnumFlags& operator=(EnumFlags&& o) = default;
 
   // Performs a bitwise OR with a flag.
-  template <typename T>
-    requires std::is_same_v<T, E>
+  template <std::same_as<E> T>
   constexpr EnumFlags& operator|=(T t) noexcept
   {
     mBits |= to_bit(t);
@@ -573,8 +578,7 @@ class EnumFlags
   }
 
   // Performs a bitwise AND with a flag.
-  template <typename T>
-    requires std::is_same_v<T, E>
+  template <std::same_as<E> T>
   constexpr EnumFlags& operator&=(T t) noexcept
   {
     mBits &= to_bit(t);
@@ -582,8 +586,7 @@ class EnumFlags
   }
 
   // Returns a flag set with a bitwise AND.
-  template <typename T>
-    requires std::is_same_v<T, E>
+  template <std::same_as<E> T>
   constexpr EnumFlags operator&(T t) const noexcept
   {
     return EnumFlags(mBits & to_bit(t));
@@ -685,32 +688,89 @@ class EnumFlags
   // Set implementation, bits was zeroed before.
   void setImpl(const std::string& s, int base = 2)
   {
+    // Helper to check if character is valid for given base
+    auto isValidForBase = [](unsigned char c, int base) -> bool {
+      if (base == 2) {
+        return c == '0' || c == '1';
+      }
+      if (base == 10) {
+        return std::isdigit(c);
+      }
+      if (base == 16) {
+        return std::isdigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
+      }
+      return false;
+    };
+
+    // hex
+    if (base == 16) {
+      std::string_view hex_str{s};
+      // Strip optional 0x or 0X prefix
+      if (s.size() >= 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
+        hex_str.remove_prefix(2);
+      }
+      if (hex_str.empty()) {
+        throw std::invalid_argument("Empty hexadecimal string.");
+      }
+      if (!std::all_of(hex_str.begin(), hex_str.end(), [&](unsigned char c) { return isValidForBase(c, 16); })) {
+        throw std::invalid_argument("Invalid hexadecimal string.");
+      }
+      typename H::UMax v = std::stoul(std::string(hex_str), nullptr, 16);
+      if (v > H::MaxRep) {
+        throw std::out_of_range("Value exceeds enum range.");
+      }
+      mBits = static_cast<U>(v);
+      return;
+    }
+
+    // decimal and binary
     if (std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isdigit(c); })) {
-      if (base == 2) { // check of only 0 and 1 in string
-        if (!std::all_of(s.begin(), s.end(), [](char c) { return c == '0' || c == '1'; })) {
+      if (base == 2) {
+        // Binary: check only 0 and 1
+        if (!std::all_of(s.begin(), s.end(), [&](unsigned char c) { return isValidForBase(c, 2); })) {
           throw std::invalid_argument("Invalid binary string.");
         }
       }
-      typename H::UMax v = std::stoul(s, nullptr, base);
+      typename H::UMax v = std::stoul(std::string(s), nullptr, base);
       if (v > H::MaxRep) {
-        throw std::out_of_range("Values exceeds enum range.");
+        throw std::out_of_range("Value exceeds enum range.");
       }
       mBits = static_cast<U>(v);
-    } else if (std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isalnum(c) != 0 || c == '|' || c == ' ' || c == ':' || c == ',' || c == ';'; })) {
+    }
+    // enum name strings
+    else if (std::all_of(s.begin(), s.end(), [](unsigned char c) { return std::isalnum(c) != 0 || c == '|' || c == ' ' || c == ':' || c == ',' || c == ';'; })) {
       std::string cs{s};
       std::transform(cs.begin(), cs.end(), cs.begin(), [](unsigned char c) { return std::tolower(c); });
+
       if (cs == H::All) {
         mBits = All;
       } else if (cs == H::None) {
         mBits = None;
       } else {
-        // accept as delimiter ' ', '|', ';', ','
+        // Detect delimiter and ensure only one type is used
         char token = ' ';
-        std::string::size_type pos = s.find_first_of(",|;");
-        if (pos != std::string::npos) {
-          token = s[pos];
+        size_t pipePos = s.find('|');
+        size_t commaPos = s.find(',');
+        size_t semiPos = s.find(';');
+
+        // Count how many different delimiters exist
+        int delimiterCount = (pipePos != std::string_view::npos ? 1 : 0) +
+                             (commaPos != std::string_view::npos ? 1 : 0) +
+                             (semiPos != std::string_view::npos ? 1 : 0);
+
+        if (delimiterCount > 1) {
+          throw std::invalid_argument("Mixed delimiters not allowed!");
+        }
+
+        if (pipePos != std::string_view::npos) {
+          token = '|';
+        } else if (commaPos != std::string_view::npos) {
+          token = ',';
+        } else if (semiPos != std::string_view::npos) {
+          token = ';';
         }
-        for (const auto& tok : Str::tokenize(s, token)) {
+
+        for (const auto& tok : Str::tokenize(std::string(s), token)) {
           if (auto e = H::fromString(tok)) {
             mBits |= to_bit(*e);
           } else {
diff --git a/Common/Utils/test/testEnumFlags.cxx b/Common/Utils/test/testEnumFlags.cxx
index 80f85c847653b..9101ffb97fdfe 100644
--- a/Common/Utils/test/testEnumFlags.cxx
+++ b/Common/Utils/test/testEnumFlags.cxx
@@ -74,11 +74,22 @@ BOOST_AUTO_TEST_CASE(Flags_test)
   multipleFlags.reset();
   BOOST_TEST(!multipleFlags.any());
 
+  // Test multiset
+  multipleFlags.reset();
+  multipleFlags.set(TestEnum::Bit2, TestEnum::Bit4);
+  BOOST_TEST(!multipleFlags.test(TestEnum::Bit1));
+  BOOST_TEST(multipleFlags.test(TestEnum::Bit2));
+  BOOST_TEST(!multipleFlags.test(TestEnum::Bit3));
+  BOOST_TEST(multipleFlags.test(TestEnum::Bit4));
+  BOOST_TEST(!multipleFlags.test(TestEnum::Bit5VeryLongName));
+
   // Test operator|
   EFlags combinedFlags = flag1 | EFlags(TestEnum::Bit2);
   BOOST_TEST(combinedFlags.test(TestEnum::Bit1));
   BOOST_TEST(combinedFlags.test(TestEnum::Bit2));
   BOOST_TEST(!combinedFlags.test(TestEnum::Bit3));
+  combinedFlags |= TestEnum::Bit5VeryLongName;
+  BOOST_TEST(combinedFlags.test(TestEnum::Bit5VeryLongName));
 
   // Test operator[]
   BOOST_TEST(combinedFlags[TestEnum::Bit1]);
@@ -306,3 +317,337 @@ BOOST_AUTO_TEST_CASE(Flags_test)
     BOOST_CHECK(!test.test(TestEnumLong::Bit1, TestEnumLong::Bit23));
   }
 }
+
+BOOST_AUTO_TEST_CASE(Flags_case_insensitive_test)
+{
+  using EFlags = o2::utils::EnumFlags<TestEnum>;
+
+  // Test case-insensitive flag names
+  {
+    EFlags flags("bit1"); // lowercase
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(!flags.test(TestEnum::Bit2));
+  }
+
+  {
+    EFlags flags("BIT2"); // uppercase
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+    BOOST_CHECK(!flags.test(TestEnum::Bit1));
+  }
+
+  {
+    EFlags flags("BiT3"); // mixed case
+    BOOST_CHECK(flags.test(TestEnum::Bit3));
+  }
+
+  {
+    EFlags flags("bit1|BIT2|BiT3"); // mixed case with delimiter
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+    BOOST_CHECK(flags.test(TestEnum::Bit3));
+  }
+
+  // Test special keywords case-insensitive
+  {
+    EFlags flags("ALL");
+    BOOST_CHECK(flags.all());
+  }
+
+  {
+    EFlags flags("None");
+    BOOST_CHECK(!flags.any());
+  }
+}
+
+BOOST_AUTO_TEST_CASE(Flags_error_recovery_test)
+{
+  using EFlags = o2::utils::EnumFlags<TestEnum>;
+
+  // Test that previous state is restored on exception
+  {
+    EFlags flags({TestEnum::Bit1, TestEnum::Bit2});
+    auto previousValue = flags.value();
+
+    // Try to set with invalid string
+    BOOST_CHECK_THROW(flags.set("InvalidFlag"), std::invalid_argument);
+
+    // Verify state was restored
+    BOOST_CHECK_EQUAL(flags.value(), previousValue);
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+  }
+
+  {
+    EFlags flags({TestEnum::Bit3, TestEnum::Bit4});
+    auto previousValue = flags.value();
+
+    // Try to set with out-of-range value
+    BOOST_CHECK_THROW(flags.set("999999", 10), std::out_of_range);
+
+    // Verify state was restored
+    BOOST_CHECK_EQUAL(flags.value(), previousValue);
+    BOOST_CHECK(flags.test(TestEnum::Bit3));
+    BOOST_CHECK(flags.test(TestEnum::Bit4));
+  }
+
+  {
+    EFlags flags(TestEnum::Bit5VeryLongName);
+    auto previousValue = flags.value();
+
+    // Try to set with invalid binary string
+    BOOST_CHECK_THROW(flags.set("10102", 2), std::invalid_argument);
+
+    // Verify state was restored
+    BOOST_CHECK_EQUAL(flags.value(), previousValue);
+    BOOST_CHECK(flags.test(TestEnum::Bit5VeryLongName));
+  }
+}
+
+BOOST_AUTO_TEST_CASE(Flags_whitespace_handling_test)
+{
+  using EFlags = o2::utils::EnumFlags<TestEnum>;
+
+  // Test leading/trailing whitespace
+  {
+    EFlags flags("  Bit1  ");
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+  }
+
+  {
+    EFlags flags("  Bit1 | Bit2  ");
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+  }
+
+  // Test excessive whitespace between flags
+  {
+    EFlags flags("Bit1    |    Bit3");
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit3));
+    BOOST_CHECK(!flags.test(TestEnum::Bit2));
+  }
+
+  // Test tabs and other whitespace (should work with space delimiter)
+  {
+    EFlags flags("Bit1 Bit2 Bit3");
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+    BOOST_CHECK(flags.test(TestEnum::Bit3));
+  }
+}
+
+BOOST_AUTO_TEST_CASE(Flags_count_bits_test)
+{
+  using EFlags = o2::utils::EnumFlags<TestEnum>;
+
+  // Test counting set bits
+  {
+    EFlags flags;
+    BOOST_CHECK_EQUAL(flags.count(), 0);
+  }
+
+  {
+    EFlags flags(TestEnum::Bit1);
+    BOOST_CHECK_EQUAL(flags.count(), 1);
+  }
+
+  {
+    EFlags flags({TestEnum::Bit1, TestEnum::Bit2});
+    BOOST_CHECK_EQUAL(flags.count(), 2);
+  }
+
+  {
+    EFlags flags({TestEnum::Bit1, TestEnum::Bit2, TestEnum::Bit3, TestEnum::Bit4});
+    BOOST_CHECK_EQUAL(flags.count(), 4);
+  }
+
+  {
+    EFlags flags(EFlags::All);
+    BOOST_CHECK_EQUAL(flags.count(), 5); // TestEnum has 5 members
+  }
+
+  // Test count after operations
+  {
+    EFlags flags({TestEnum::Bit1, TestEnum::Bit2, TestEnum::Bit3});
+    BOOST_CHECK_EQUAL(flags.count(), 3);
+
+    flags.reset(TestEnum::Bit2);
+    BOOST_CHECK_EQUAL(flags.count(), 2);
+
+    flags.set(TestEnum::Bit4);
+    BOOST_CHECK_EQUAL(flags.count(), 3);
+
+    flags.toggle(TestEnum::Bit1);
+    BOOST_CHECK_EQUAL(flags.count(), 2);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(Flags_mixed_delimiter_validation_test)
+{
+  using EFlags = o2::utils::EnumFlags<TestEnum>;
+
+  // Test that mixed delimiters throw an error
+  {
+    BOOST_CHECK_THROW(EFlags("Bit1|Bit2,Bit3"), std::invalid_argument);
+  }
+
+  {
+    BOOST_CHECK_THROW(EFlags("Bit1;Bit2|Bit3"), std::invalid_argument);
+  }
+
+  {
+    BOOST_CHECK_THROW(EFlags("Bit1,Bit2;Bit3"), std::invalid_argument);
+  }
+
+  {
+    BOOST_CHECK_THROW(EFlags("Bit1|Bit2,Bit3;Bit4"), std::invalid_argument);
+  }
+
+  // Test that single delimiter types work
+  {
+    EFlags flags1("Bit1|Bit2|Bit3");
+    BOOST_CHECK_EQUAL(flags1.count(), 3);
+  }
+
+  {
+    EFlags flags2("Bit1,Bit2,Bit3");
+    BOOST_CHECK_EQUAL(flags2.count(), 3);
+  }
+
+  {
+    EFlags flags3("Bit1;Bit2;Bit3");
+    BOOST_CHECK_EQUAL(flags3.count(), 3);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(Flags_empty_and_edge_cases_test)
+{
+  using EFlags = o2::utils::EnumFlags<TestEnum>;
+
+  // Test empty string
+  {
+    EFlags flags({TestEnum::Bit1, TestEnum::Bit2});
+    flags.set(""); // Should be no-op
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+  }
+
+  // Test with only whitespace
+  {
+    EFlags flags({TestEnum::Bit1});
+    flags.set("   "); // Should result in empty after tokenization
+    // Depending on implementation, this might clear or throw
+    // Adjust expectation based on actual behavior
+  }
+
+  // Test duplicate flags (should work, setting same bit twice is idempotent)
+  {
+    EFlags flags("Bit1|Bit1|Bit1");
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK_EQUAL(flags.count(), 1);
+  }
+
+  // Test scoped and unscoped mixed
+  {
+    EFlags flags("Bit1|TestEnum::Bit2");
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+  }
+}
+
+BOOST_AUTO_TEST_CASE(Flags_binary_decimal_parsing_test)
+{
+  using EFlags = o2::utils::EnumFlags<TestEnum>;
+
+  // Test binary parsing
+  {
+    EFlags flags("101", 2);
+    BOOST_CHECK(flags.test(TestEnum::Bit1));  // bit 0
+    BOOST_CHECK(!flags.test(TestEnum::Bit2)); // bit 1
+    BOOST_CHECK(flags.test(TestEnum::Bit3));  // bit 2
+  }
+
+  // Test decimal parsing
+  {
+    EFlags flags("7", 10); // 7 = 0b111
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+    BOOST_CHECK(flags.test(TestEnum::Bit3));
+    BOOST_CHECK(!flags.test(TestEnum::Bit4));
+  }
+
+  // Test hexadecimal parsing
+  {
+    EFlags flags("F", 16); // 15 = 0b1111
+    BOOST_CHECK(flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+    BOOST_CHECK(flags.test(TestEnum::Bit3));
+    BOOST_CHECK(flags.test(TestEnum::Bit4));
+    BOOST_CHECK(!flags.test(TestEnum::Bit5VeryLongName));
+  }
+
+  // Test hexadecimal with 0x prefix
+  {
+    EFlags flags("0xA", 16); // 10 = 0b1010
+    BOOST_CHECK(!flags.test(TestEnum::Bit1));
+    BOOST_CHECK(flags.test(TestEnum::Bit2));
+    BOOST_CHECK(!flags.test(TestEnum::Bit3));
+    BOOST_CHECK(flags.test(TestEnum::Bit4));
+  }
+
+  // Test hexadecimal with 0X prefix (uppercase)
+  {
+    EFlags flags("0X1F", 16); // 31 = all 5 bits
+    BOOST_CHECK(flags.all());
+  }
+
+  // Test lowercase hex digits
+  {
+    EFlags flags("0xa", 16);
+    BOOST_CHECK_EQUAL(flags.value(), 10);
+  }
+
+  // Test thros
+  {
+    BOOST_CHECK_THROW(EFlags("0xAbCd", 16), std::out_of_range);
+  }
+
+  // Test invalid binary string (contains 2)
+  {
+    BOOST_CHECK_THROW(EFlags("1012", 2), std::invalid_argument);
+  }
+
+  // Test out of range for base
+  {
+    BOOST_CHECK_THROW(EFlags("100000", 2), std::out_of_range);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(Flags_operator_bool_test)
+{
+  using EFlags = o2::utils::EnumFlags<TestEnum>;
+
+  // Test explicit bool conversion
+  {
+    EFlags empty;
+    BOOST_CHECK(!static_cast<bool>(empty));
+  }
+
+  {
+    EFlags withFlag(TestEnum::Bit1);
+    BOOST_CHECK(static_cast<bool>(withFlag));
+  }
+
+  // Test in conditional
+  {
+    EFlags flags;
+    if (flags) {
+      BOOST_FAIL("Empty flags should be false");
+    }
+
+    flags.set(TestEnum::Bit1);
+    if (!flags) {
+      BOOST_FAIL("Non-empty flags should be true");
+    }
+  }
+}

From 73c5a52720543e6405c8e6dd9e1ffa70c645d508 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 22 Dec 2025 21:06:16 +0100
Subject: [PATCH 1148/1764] DCA Fitter GPU: Disable failing test, which was not
 active before and seems broken

---
 Common/DCAFitter/GPU/cuda/CMakeLists.txt | 22 +++++++++++-----------
 Common/DCAFitter/GPU/hip/CMakeLists.txt  | 24 ++++++++++++------------
 GPU/Common/CMakeLists.txt                | 20 ++++++++++----------
 3 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/Common/DCAFitter/GPU/cuda/CMakeLists.txt b/Common/DCAFitter/GPU/cuda/CMakeLists.txt
index ddc1d09445d7f..6b89207279fe0 100644
--- a/Common/DCAFitter/GPU/cuda/CMakeLists.txt
+++ b/Common/DCAFitter/GPU/cuda/CMakeLists.txt
@@ -22,14 +22,14 @@ o2_add_library(DCAFitterCUDA
 set_property(TARGET ${targetName} PROPERTY CUDA_SEPARABLE_COMPILATION ON)
 # add_compile_options(-lineinfo)
 
-o2_add_test(DCAFitterNCUDA
-            SOURCES test/testDCAFitterNGPU.cxx
-            PUBLIC_LINK_LIBRARIES O2::ReconstructionDataFormats
-                                  O2::DCAFitterCUDA
-                                  O2::DCAFitter
-                                  ROOT::Core
-                                  ROOT::Physics
-            COMPONENT_NAME gpu
-            LABELS vertexing
-            ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage
-            VMCWORKDIR=${CMAKE_BINARY_DIR}/stage/${CMAKE_INSTALL_DATADIR})
\ No newline at end of file
+#o2_add_test(DCAFitterNCUDA
+#            SOURCES test/testDCAFitterNGPU.cxx
+#            PUBLIC_LINK_LIBRARIES O2::ReconstructionDataFormats
+#                                  O2::DCAFitterCUDA
+#                                  O2::DCAFitter
+#                                  ROOT::Core
+#                                  ROOT::Physics
+#            COMPONENT_NAME gpu
+#            LABELS vertexing
+#            ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage
+#            VMCWORKDIR=${CMAKE_BINARY_DIR}/stage/${CMAKE_INSTALL_DATADIR})
diff --git a/Common/DCAFitter/GPU/hip/CMakeLists.txt b/Common/DCAFitter/GPU/hip/CMakeLists.txt
index f62759bb6ea2c..5e7821a0b8946 100644
--- a/Common/DCAFitter/GPU/hip/CMakeLists.txt
+++ b/Common/DCAFitter/GPU/hip/CMakeLists.txt
@@ -21,15 +21,15 @@ o2_add_hipified_library(DCAFitterHIP
                         PRIVATE_LINK_LIBRARIES O2::GPUTrackingHIPExternalProvider
                         TARGETVARNAME targetNAme)
 
-o2_add_test(DCAFitterNHIP
-            SOURCES ../cuda/test/testDCAFitterNGPU.cxx
-            PUBLIC_LINK_LIBRARIES O2::ReconstructionDataFormats
-                                  O2::DCAFitterHIP
-                                  O2::DCAFitter
-                                  ROOT::Core
-                                  ROOT::Physics
-            HIPIFIED test
-            COMPONENT_NAME gpu
-            LABELS vertexing
-            ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage
-            VMCWORKDIR=${CMAKE_BINARY_DIR}/stage/${CMAKE_INSTALL_DATADIR})
\ No newline at end of file
+#o2_add_test(DCAFitterNHIP
+#            SOURCES ../cuda/test/testDCAFitterNGPU.cxx
+#            PUBLIC_LINK_LIBRARIES O2::ReconstructionDataFormats
+#                                  O2::DCAFitterHIP
+#                                  O2::DCAFitter
+#                                  ROOT::Core
+#                                  ROOT::Physics
+#            HIPIFIED test
+#            COMPONENT_NAME gpu
+#            LABELS vertexing
+#            ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage
+#            VMCWORKDIR=${CMAKE_BINARY_DIR}/stage/${CMAKE_INSTALL_DATADIR})
diff --git a/GPU/Common/CMakeLists.txt b/GPU/Common/CMakeLists.txt
index b1a4b2107019c..8f7a7c2e169ed 100644
--- a/GPU/Common/CMakeLists.txt
+++ b/GPU/Common/CMakeLists.txt
@@ -52,16 +52,16 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                 COMPONENT_NAME GPU
                 LABELS gpu)
   endif()
-  if (HIP_ENABLED)
-    o2_add_test(SMatrixImpHIP NAME test_SMatrixImpHIP
-                SOURCES test/testSMatrixImp.cu
-                HIPIFIED test
-                PUBLIC_LINK_LIBRARIES O2::${MODULE}
-                                      O2::MathUtils
-                                      ROOT::Core
-                COMPONENT_NAME GPU
-                LABELS gpu)
-  endif()
+#  if (HIP_ENABLED)
+#    o2_add_test(SMatrixImpHIP NAME test_SMatrixImpHIP
+#                SOURCES test/testSMatrixImp.cu
+#                HIPIFIED test
+#                PUBLIC_LINK_LIBRARIES O2::${MODULE}
+#                                      O2::MathUtils
+#                                      ROOT::Core
+#                COMPONENT_NAME GPU
+#                LABELS gpu)
+#  endif()
 endif()
 
 install(FILES ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)

From bfcff02b88be6053c154e385acefd235dfed69d4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 24 Dec 2025 23:16:32 +0100
Subject: [PATCH 1149/1764] Fix some codechecker violations (#14936)

---
 .../CPV/reconstruction/include/CPVReconstruction/CTFCoder.h   | 2 +-
 .../CTP/reconstruction/include/CTPReconstruction/CTFCoder.h   | 2 +-
 .../reconstruction/include/EMCALReconstruction/CTFCoder.h     | 2 +-
 .../FDD/reconstruction/include/FDDReconstruction/CTFCoder.h   | 2 +-
 .../FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h   | 2 +-
 .../FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h   | 2 +-
 Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx     | 2 +-
 Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx        | 2 +-
 Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx  | 2 +-
 Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx   | 2 +-
 Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx  | 4 ++--
 .../reconstruction/include/HMPIDReconstruction/CTFCoder.h     | 2 +-
 .../ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx      | 1 -
 .../reconstruction/include/ITSMFTReconstruction/CTFCoder.h    | 2 +-
 Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h              | 2 +-
 Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h              | 2 +-
 .../PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h | 2 +-
 .../TOF/reconstruction/include/TOFReconstruction/CTFCoder.h   | 2 +-
 .../TPC/reconstruction/include/TPCReconstruction/CTFCoder.h   | 2 +-
 .../TRD/reconstruction/include/TRDReconstruction/CTFCoder.h   | 2 +-
 .../ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h   | 2 +-
 Framework/Utils/include/DPLUtils/RootTreeWriter.h             | 2 +-
 22 files changed, 22 insertions(+), 23 deletions(-)

diff --git a/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h b/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
index e9bd0f7249ef1..ab5082b5c748c 100644
--- a/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
+++ b/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
@@ -32,7 +32,7 @@ namespace o2
 namespace cpv
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::CPV) {}
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
index 9189df5d12685..87657f6a6f8c6 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
@@ -34,7 +34,7 @@ namespace o2
 namespace ctp
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::CTP) {}
diff --git a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
index 1617a9f1a7d54..23deb75ffb049 100644
--- a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
+++ b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
@@ -32,7 +32,7 @@ namespace o2
 namespace emcal
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::EMC) {}
diff --git a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
index dc11174908c75..94a0c6f64659d 100644
--- a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
+++ b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
@@ -33,7 +33,7 @@ namespace o2
 namespace fdd
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FDD) {}
diff --git a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
index 4d749dbc90b42..65646c161dde5 100644
--- a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
+++ b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
@@ -34,7 +34,7 @@ namespace o2
 namespace ft0
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FT0) {}
diff --git a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
index cbec444ef11be..4398e19c0a5ed 100644
--- a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
+++ b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
@@ -30,7 +30,7 @@ namespace o2
 namespace fv0
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FV0) {}
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx b/Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx
index dbf34b8eb14ad..d02f1df3903ec 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx
@@ -48,7 +48,7 @@ using TBracket = o2::math_utils::Bracketf_t;
 
 using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 
-class DumpTracksSpec : public Task
+class DumpTracksSpec final : public Task
 {
  public:
   DumpTracksSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC)
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
index 1e141a29d3f55..0129d19b02346 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
@@ -68,7 +68,7 @@ using V0ID = o2::dataformats::V0Index;
 
 using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 
-class SVStudySpec : public Task
+class SVStudySpec final : public Task
 {
  public:
   SVStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useTPCCl, bool useMC)
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
index 09ef766aa1536..05e6a122adec9 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
@@ -47,7 +47,7 @@ using TBracket = o2::math_utils::Bracketf_t;
 
 using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 
-class TPCTrackStudySpec : public Task
+class TPCTrackStudySpec final : public Task
 {
  public:
   TPCTrackStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, GTrackID::mask_t src, bool useMC)
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index c4a0a30116557..8f6604b029605 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -83,7 +83,7 @@ using TBracket = o2::math_utils::Bracketf_t;
 
 using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 
-class TrackMCStudy : public Task
+class TrackMCStudy final : public Task
 {
  public:
   TrackMCStudy(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool checkSV)
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index 531ee03290201..b8a8f97737b4d 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -67,7 +67,7 @@ using TBracket = o2::math_utils::Bracketf_t;
 
 using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 
-class TrackingStudySpec : public Task
+class TrackingStudySpec final : public Task
 {
  public:
   TrackingStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
@@ -444,7 +444,7 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
         }
         bool ambig = vid.isAmbiguous();
         auto trc = recoData.getTrackParam(vid);
-        if (abs(trc.getEta()) > mMaxEta) {
+        if (fabs(trc.getEta()) > mMaxEta) {
           continue;
         }
         if (iv < nv - 1 && is == GTrackID::TPC && tpcTr && !tpcTr->hasBothSidesClusters()) { // for unconstrained TPC tracks correct track Z
diff --git a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h b/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
index da2461c2759ba..39242355a3de9 100644
--- a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
+++ b/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
@@ -32,7 +32,7 @@ namespace o2
 namespace hmpid
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::HMP) {}
diff --git a/Detectors/ITSMFT/ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx b/Detectors/ITSMFT/ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx
index 1fc4442e3bdbf..90ed033ed67da 100644
--- a/Detectors/ITSMFT/ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx
+++ b/Detectors/ITSMFT/ITS/QC/TestDataReaderWorkflow/src/TestDataReader.cxx
@@ -509,7 +509,6 @@ void TestDataReader::run(ProcessingContext& pc)
 
 std::vector<string> TestDataReader::GetFName(std::string folder)
 {
-
   DIR* dirp;
 
   char cstr[folder.size() + 1];
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
index 2d4aabc94fc82..94c14424f6ce3 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
@@ -39,7 +39,7 @@ namespace o2
 namespace itsmft
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   using PMatrix = std::array<std::array<bool, ClusterPattern::MaxRowSpan + 2>, ClusterPattern::MaxColSpan + 2>;
diff --git a/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h b/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
index fc090c5c7e16d..2d65cbbaea614 100644
--- a/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
+++ b/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
@@ -34,7 +34,7 @@ namespace o2
 namespace mch
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::MCH) {}
diff --git a/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h b/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
index 3071b65db47b1..5afc42550ae3e 100644
--- a/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
+++ b/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
@@ -34,7 +34,7 @@ namespace o2
 namespace mid
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::MID) {}
diff --git a/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h b/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
index 96ee5093bacca..8a7172f634a33 100644
--- a/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
+++ b/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
@@ -32,7 +32,7 @@ namespace o2
 namespace phos
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::PHS) {}
diff --git a/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h b/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
index e559dcce7a1da..e7a203cfcb25e 100644
--- a/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
+++ b/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
@@ -31,7 +31,7 @@ namespace o2
 namespace tof
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TOF) {}
diff --git a/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h b/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
index ab49d0d49d79b..12d66ef6a6e7c 100644
--- a/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
+++ b/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
@@ -119,7 +119,7 @@ struct MergedColumnsDecoder {
 
 } // namespace detail
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TPC) {}
diff --git a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
index 27e089fcf3555..9eeaf19db5025 100644
--- a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
+++ b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
@@ -33,7 +33,7 @@ namespace o2
 namespace trd
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TRD) {}
diff --git a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
index c2f2163600f29..f8823e4fc66a5 100644
--- a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
+++ b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
@@ -32,7 +32,7 @@ namespace o2
 namespace zdc
 {
 
-class CTFCoder : public o2::ctf::CTFCoderBase
+class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
   CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::ZDC) {}
diff --git a/Framework/Utils/include/DPLUtils/RootTreeWriter.h b/Framework/Utils/include/DPLUtils/RootTreeWriter.h
index 0161c67396543..b937a83f5972a 100644
--- a/Framework/Utils/include/DPLUtils/RootTreeWriter.h
+++ b/Framework/Utils/include/DPLUtils/RootTreeWriter.h
@@ -714,7 +714,7 @@ class RootTreeWriter
         impl.start = &(data[0]);
         impl.end = &(data[data.size() - 1]) + 1; // end pointer (beyond last element)
         impl.cap = impl.end;
-        std::memcpy(&v, &impl, sizeof(VecBase));
+        std::memcpy((void*)&v, (const void*)&impl, sizeof(VecBase));
       };
 
       // if the value type is messagable and has a ROOT dictionary, two serialization methods are possible

From 89cebea4fdb75bb6bf85a9f5d33cb021a3093cb4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 25 Dec 2025 18:44:28 +0100
Subject: [PATCH 1150/1764] GPU: Support virtual and real architectures in RTC

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 7f595b28a582a..e7a579bec794d 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -41,9 +41,11 @@ set(GPU_RTC_FLAGS "${CMAKE_CUDA_FLAGS} ${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPP
 set(GPU_RTC_FLAGS_ARCH "")
 if(CUDA_COMPUTETARGET)
     foreach(CUDA_ARCH ${CUDA_COMPUTETARGET})
-        set(GPU_RTC_FLAGS_ARCH "${GPU_RTC_FLAGS_ARCH} -gencode arch=compute_${CUDA_ARCH},code=sm_${CUDA_ARCH}")
+        string(REGEX REPLACE "-.*$" "" CUDA_ARCH_STRIPPED "${CUDA_ARCH}")
+        set(GPU_RTC_FLAGS_ARCH "${GPU_RTC_FLAGS_ARCH} -gencode arch=compute_${CUDA_ARCH_STRIPPED},code=sm_${CUDA_ARCH_STRIPPED}")
     endforeach()
     list (GET CUDA_COMPUTETARGET 0 RTC_CUDA_ARCH)
+    string(REGEX REPLACE "-.*$" "" RTC_CUDA_ARCH "${RTC_CUDA_ARCH}")
     set(RTC_CUDA_ARCH "${RTC_CUDA_ARCH}0")
 else()
     set(RTC_CUDA_ARCH "750")

From 0bc34efd29e2b0cc4dade68f538da91046d4ae48 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 25 Dec 2025 16:02:08 +0100
Subject: [PATCH 1151/1764] GPU: Change default CUDA architectures to 80-real
 86-real 89-real 120-real 75-virtual

---
 dependencies/FindO2GPU.cmake | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 0be3448ed6fce..6ca311905e01c 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 7
+# FindO2GPU.cmake Version 8
 
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
@@ -32,7 +32,7 @@ if(CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
 endif()
 
 if(CUDA_COMPUTETARGET AND CUDA_COMPUTETARGET STREQUAL "default")
-  set(CUDA_COMPUTETARGET 86 89)
+  set(CUDA_COMPUTETARGET 80-real 86-real 89-real 120-real 75-virtual)
 endif()
 
 if(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET STREQUAL "default")

From cf919bf9a720c0b4135de03feaec600c84111c95 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 29 Dec 2025 22:27:33 +0100
Subject: [PATCH 1152/1764] GPU Workflow: Fix setting of dEdx processing step

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx | 2 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx        | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index f370b756e2cdb..5c951053e155b 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -1017,6 +1017,6 @@ void GPUChainTracking::ApplySyncSettings(GPUSettingsProcessing& proc, GPUSetting
     proc.rtc.optSpecialCode = syncMode;
   }
   if (dEdxMode != -2) {
-    steps.setBits(gpudatatypes::RecoStep::TPCdEdx, dEdxMode == -1 ? !syncMode : dEdxMode > 0);
+    steps.setBits(gpudatatypes::RecoStep::TPCdEdx, dEdxMode == -1 ? !syncMode : (dEdxMode > 0));
   }
 }
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 6011cc3dc3e9f..2d5a955a5e911 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -187,7 +187,6 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
   }
   mConfig->configInterface.outputToExternalBuffers = true;
   const bool runTracking = mSpecConfig.outputTracks || mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat;
-  GPUO2Interface::ApplySyncSettings(mConfig->configProcessing, mConfig->configReconstruction, mConfig->configWorkflow.steps, mConfParam->synchronousProcessing, runTracking ? mConfParam->rundEdx : -2);
 
   // Configure the "GPU workflow" i.e. which steps we run on the GPU (or CPU)
   if (runTracking) {
@@ -196,6 +195,8 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
                                       gpudatatypes::RecoStep::TPCMerging);
     mConfig->configWorkflow.outputs.set(gpudatatypes::InOutType::TPCMergedTracks);
   }
+  GPUO2Interface::ApplySyncSettings(mConfig->configProcessing, mConfig->configReconstruction, mConfig->configWorkflow.steps, mConfParam->synchronousProcessing, runTracking ? mConfParam->rundEdx : -2);
+
   if (mSpecConfig.outputCompClustersRoot || mSpecConfig.outputCompClustersFlat) {
     mConfig->configWorkflow.steps.setBits(gpudatatypes::RecoStep::TPCCompression, true);
     mConfig->configWorkflow.outputs.setBits(gpudatatypes::InOutType::TPCCompressedClusters, true);

From 02fde5c462bc123a8d882f9ec1e0796c2a40e540 Mon Sep 17 00:00:00 2001
From: Diego Stocco <diego.stocco@cern.ch>
Date: Mon, 24 Nov 2025 11:34:09 +0100
Subject: [PATCH 1153/1764] Increase time range search to include QCDB objects
 created after EOR

---
 Detectors/MUON/MID/Calibration/macros/build_rejectlist.C | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/Detectors/MUON/MID/Calibration/macros/build_rejectlist.C b/Detectors/MUON/MID/Calibration/macros/build_rejectlist.C
index 5cec2c611bcf8..06aca991be338 100644
--- a/Detectors/MUON/MID/Calibration/macros/build_rejectlist.C
+++ b/Detectors/MUON/MID/Calibration/macros/build_rejectlist.C
@@ -28,7 +28,6 @@
 #include "TGraph.h"
 #include "TTimeStamp.h"
 #include "CCDB/CcdbApi.h"
-#include "DataFormatsParameters/GRPECSObject.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DataFormatsMID/ColumnData.h"
 #include "MIDBase/ColumnDataHandler.h"
@@ -111,12 +110,18 @@ std::string timeRangeToString(long start, long end)
 std::vector<MDStruct> findObjectsMDInPeriod(long start, long end, const o2::ccdb::CcdbApi& api, const char* path)
 {
   std::vector<MDStruct> mds;
-  auto out = api.list(path, false, "application/json", getTSMS(end), getTSMS(start));
+  long creationDelayMS = 300000; // The objects can be created up to 5 minutes after the end of run
+  auto out = api.list(path, false, "application/json", getTSMS(end) + creationDelayMS, getTSMS(start));
   rapidjson::Document doc;
   doc.Parse(out.c_str());
   for (auto& obj : doc["objects"].GetArray()) {
     MDStruct md;
     md.start = obj["validFrom"].GetInt64();
+    if (getTSMS(end) < getTSMS(md.start)) {
+      // Since we query on the creation time, adding a delay
+      // we need to cross-check here that we are within the run
+      continue;
+    }
     md.end = obj["validUntil"].GetInt64();
     md.runNumber = std::atoi(obj["RunNumber"].GetString());
     md.runType = obj["RunType"].GetString();

From b8c867dbb27d08e9ecf3134aeb72886fbb3c878c Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Thu, 25 Sep 2025 15:57:50 +0200
Subject: [PATCH 1154/1764] First implementation of loopers inclusion in base
 Generator class

---
 .../SimConfig/include/SimConfig/SimConfig.h   |   3 +
 Common/SimConfig/src/SimConfig.cxx            |   2 +
 Generators/CMakeLists.txt                     |  13 +
 Generators/include/Generators/Generator.h     |  13 +
 .../include/Generators/TPCLoopersParam.h      |  48 ++
 Generators/include/TPCLoopers.h               | 127 +++++
 .../share/egconfig/ScalerComptonParams.json   |  28 ++
 .../share/egconfig/ScalerPairParams.json      |  34 ++
 Generators/share/egconfig/gaussian_params.csv |   4 +
 Generators/share/egconfig/poisson_params.csv  |   3 +
 Generators/src/Generator.cxx                  | 442 ++++++++++++------
 Generators/src/GeneratorsLinkDef.h            |   4 +
 Generators/src/TPCLoopers.cxx                 | 417 +++++++++++++++++
 Generators/src/TPCLoopersParam.cxx            |  15 +
 14 files changed, 1007 insertions(+), 146 deletions(-)
 create mode 100644 Generators/include/Generators/TPCLoopersParam.h
 create mode 100644 Generators/include/TPCLoopers.h
 create mode 100644 Generators/share/egconfig/ScalerComptonParams.json
 create mode 100644 Generators/share/egconfig/ScalerPairParams.json
 create mode 100644 Generators/share/egconfig/gaussian_params.csv
 create mode 100644 Generators/share/egconfig/poisson_params.csv
 create mode 100644 Generators/src/TPCLoopers.cxx
 create mode 100644 Generators/src/TPCLoopersParam.cxx

diff --git a/Common/SimConfig/include/SimConfig/SimConfig.h b/Common/SimConfig/include/SimConfig/SimConfig.h
index be88d9fbd8c33..8642a0e5bc225 100644
--- a/Common/SimConfig/include/SimConfig/SimConfig.h
+++ b/Common/SimConfig/include/SimConfig/SimConfig.h
@@ -52,6 +52,7 @@ struct SimConfigData {
   std::vector<std::string> mActiveModules;            // list of active modules
   std::vector<std::string> mReadoutDetectors;         // list of readout detectors
   std::string mMCEngine;                              // chosen VMC engine
+  bool mNoLoopers = false;                            // Disable automatic TPC loopers
   std::string mGenerator;                             // chosen VMC generator
   std::string mTrigger;                               // chosen VMC generator trigger
   unsigned int mNEvents;                              // number of events to be simulated
@@ -138,6 +139,8 @@ class SimConfig
   // get selected active detectors
   std::vector<std::string> const& getActiveModules() const { return mConfigData.mActiveModules; }
   std::vector<std::string> const& getReadoutDetectors() const { return mConfigData.mReadoutDetectors; }
+  // get loopers veto
+  bool getLoopersVeto() const { return mConfigData.mNoLoopers; }
 
   // static helper functions to determine list of active / readout modules
   // can also be used from outside
diff --git a/Common/SimConfig/src/SimConfig.cxx b/Common/SimConfig/src/SimConfig.cxx
index 15879687872d5..5ddc3199e3d4a 100644
--- a/Common/SimConfig/src/SimConfig.cxx
+++ b/Common/SimConfig/src/SimConfig.cxx
@@ -74,6 +74,7 @@ void SimConfig::initOptions(boost::program_options::options_description& options
     "run", bpo::value<int>()->default_value(-1), "ALICE run number")(
     "asservice", bpo::value<bool>()->default_value(false), "run in service/server mode")(
     "noGeant", bpo::bool_switch(), "prohibits any Geant transport/physics (by using tight cuts)")(
+    "noLoopers", bpo::bool_switch(), "disable automatic TPC loopers")(
     "forwardKine", bpo::bool_switch(), "forward kinematics on a FairMQ channel")(
     "noDiscOutput", bpo::bool_switch(), "switch off writing sim results to disc (useful in combination with forwardKine)");
   options.add_options()("fromCollContext", bpo::value<std::string>()->default_value(""), "Use a pregenerated collision context to infer number of events to simulate, how to embedd them, the vertex position etc. Takes precedence of other options such as \"--nEvents\". The format is COLLISIONCONTEXTFILE.root[:SIGNALNAME] where SIGNALNAME is the event part in the context which is relevant.");
@@ -297,6 +298,7 @@ bool SimConfig::resetFromParsedMap(boost::program_options::variables_map const&
   using o2::detectors::DetID;
   mConfigData.mMCEngine = vm["mcEngine"].as<std::string>();
   mConfigData.mNoGeant = vm["noGeant"].as<bool>();
+  mConfigData.mNoLoopers = vm["noLoopers"].as<bool>();
 
   // Reset modules and detectors as they are anyway re-parsed
   mConfigData.mReadoutDetectors.clear();
diff --git a/Generators/CMakeLists.txt b/Generators/CMakeLists.txt
index 02caa63df0d43..56fe8b8fc2284 100644
--- a/Generators/CMakeLists.txt
+++ b/Generators/CMakeLists.txt
@@ -41,6 +41,8 @@ o2_add_library(Generators
                        src/GeneratorTParticleParam.cxx
                        src/GeneratorService.cxx
                        src/FlowMapper.cxx
+                       $<$<BOOL:${onnxruntime_FOUND}>:src/TPCLoopers.cxx>
+                       $<$<BOOL:${onnxruntime_FOUND}>:src/TPCLoopersParam.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/DecayerPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8Param.cxx>
@@ -53,6 +55,7 @@ o2_add_library(Generators
                PUBLIC_LINK_LIBRARIES FairRoot::Base O2::SimConfig O2::CommonUtils O2::DetectorsBase O2::ZDCBase
                                      O2::SimulationDataFormat ${pythiaTarget} ${hepmcTarget}
                                      FairRoot::Gen
+                                     $<$<BOOL:${onnxruntime_FOUND}>:onnxruntime::onnxruntime>
                TARGETVARNAME targetName)
 
 if(pythia_FOUND)
@@ -63,6 +66,10 @@ if(HepMC3_FOUND)
   target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_HEPMC3)
 endif()
 
+if(onnxruntime_FOUND)
+  target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_ONNXRUNTIME)
+endif()
+
 set(headers
     include/Generators/Generator.h
     include/Generators/Trigger.h
@@ -88,6 +95,12 @@ set(headers
     include/Generators/FlowMapper.h
     )
 
+if(onnxruntime_FOUND)
+  list(APPEND headers 
+              include/Generators/TPCLoopers.h
+              include/Generators/TPCLoopersParam.h)
+endif()
+
 if(pythia_FOUND)
   list(APPEND headers
               include/Generators/GeneratorPythia8.h
diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index bd35a00793e2d..374d53f324399 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -17,6 +17,10 @@
 #include "FairGenerator.h"
 #include "TParticle.h"
 #include "Generators/Trigger.h"
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+#include "Generators/TPCLoopers.h"
+#include "Generators/TPCLoopersParam.h"
+#endif
 #include <functional>
 #include <vector>
 #include <unordered_map>
@@ -73,6 +77,7 @@ class Generator : public FairGenerator
   /** methods to override **/
   virtual Bool_t generateEvent() = 0;   // generates event (in structure internal to generator)
   virtual Bool_t importParticles() = 0; // fills the mParticles vector (transfer from generator state)
+  Bool_t loopers();                     // adds loopers to the event in case TPC is used
   virtual void updateHeader(o2::dataformats::MCEventHeader* eventHeader) {};
   Bool_t triggerEvent();
 
@@ -154,6 +159,8 @@ class Generator : public FairGenerator
  private:
   void updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const;
 
+  // loopers flag
+  Bool_t mAddLoopers = kFALSE;
   // collect an ID and a short description of sub-generator entities
   std::unordered_map<int, std::string> mSubGeneratorsIdToDesc;
   // the current ID of the sub-generator used in the current event (if applicable)
@@ -162,6 +169,12 @@ class Generator : public FairGenerator
   // global static information about (upper limit of) number of events to be generated
   static unsigned int gTotalNEvents;
 
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+  // Loopers generator instance
+  std::unique_ptr<o2::eventgen::GenTPCLoopers> mLoopersGen = nullptr;
+#endif
+  void initLoopersGen();
+
   ClassDefOverride(Generator, 2);
 
 }; /** class Generator **/
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
new file mode 100644
index 0000000000000..ceeea201538b2
--- /dev/null
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -0,0 +1,48 @@
+// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \author M+Giacalone - September 2025
+
+#ifndef ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
+#define ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2
+{
+namespace eventgen
+{
+
+/**
+ ** a parameter class/struct to keep the settings of
+ ** the tpc loopers event-generator and
+ ** allow the user to modify them
+ **/
+struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
+  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";  // ONNX model for e+e- pair production
+  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton"; // ONNX model for Compton scattering
+  std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv"; // file with Poissonian parameters
+  std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv"; // file with Gaussian parameters
+  std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json"; // file with scaler parameters for e+e- pair production
+  std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
+  bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
+  int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
+  float fraction_pairs = 0.08; // fraction of loopers
+  std::array<float, 2> multiplier = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
+  std::array<unsigned int, 2> fixedNLoopers = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
+};
+
+} // end namespace eventgen
+} // end namespace o2
+
+#endif // ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
new file mode 100644
index 0000000000000..70146a82baf60
--- /dev/null
+++ b/Generators/include/TPCLoopers.h
@@ -0,0 +1,127 @@
+#ifndef ALICEO2_EVENTGEN_TPCLOOPERS_H_
+#define ALICEO2_EVENTGEN_TPCLOOPERS_H_
+
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+#include <onnxruntime_cxx_api.h>
+#endif
+#include <iostream>
+#include <vector>
+#include <fstream>
+#include <rapidjson/document.h>
+#include "CCDB/CCDBTimeStampUtils.h"
+#include "CCDB/CcdbApi.h"
+#include "DetectorsRaw/HBFUtils.h"
+#include "TRandom3.h"
+#include "TDatabasePDG.h"
+#include <SimulationDataFormat/DigitizationContext.h>
+#include <SimulationDataFormat/ParticleStatus.h>
+#include "SimulationDataFormat/MCGenProperties.h"
+#include "TParticle.h"
+#include <filesystem>
+
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+// Static Ort::Env instance for multiple onnx model loading
+extern Ort::Env global_env;
+#endif
+
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+// This class is responsible for loading the scaler parameters from a JSON file
+// and applying the inverse transformation to the generated data.
+struct Scaler
+{
+    std::vector<double> normal_min;
+    std::vector<double> normal_max;
+    std::vector<double> outlier_center;
+    std::vector<double> outlier_scale;
+
+    void load(const std::string &filename);
+
+    std::vector<double> inverse_transform(const std::vector<double> &input);
+
+private:
+    std::vector<double> jsonArrayToVector(const rapidjson::Value &jsonArray);
+};
+
+// This class loads the ONNX model and generates samples using it.
+class ONNXGenerator
+{
+public:
+    ONNXGenerator(Ort::Env &shared_env, const std::string &model_path);
+
+    std::vector<double> generate_sample();
+
+private:
+    Ort::Env &env;
+    Ort::Session session;
+    TRandom3 rand_gen;
+};
+#endif // GENERATORS_WITH_ONNXRUNTIME
+
+namespace o2
+{
+namespace eventgen
+{
+
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+class GenTPCLoopers
+{
+    public:
+        GenTPCLoopers(std::string model_pairs = "tpcloopmodel.onnx", std::string model_compton = "tpcloopmodelcompton.onnx",
+                      std::string poisson = "poisson.csv", std::string gauss = "gauss.csv", std::string scaler_pair = "scaler_pair.json",
+                      std::string scaler_compton = "scaler_compton.json");
+    
+        Bool_t generateEvent();
+
+        Bool_t generateEvent(double &time_limit);
+
+        std::vector<TParticle> importParticles();
+
+        unsigned int PoissonPairs();
+
+        unsigned int GaussianElectrons();
+
+        void SetNLoopers(unsigned int &nsig_pair, unsigned int &nsig_compton);
+
+        void SetMultiplier(std::array<float, 2> &mult);
+
+        void setFlatGas(Bool_t &flat, const Int_t &number = -1);
+
+        void setFractionPairs(float &fractionPairs);
+
+    private:
+        std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
+        std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
+        std::unique_ptr<Scaler> mScaler_pair = nullptr;
+        std::unique_ptr<Scaler> mScaler_compton = nullptr;
+        double mPoisson[3] = {0.0, 0.0, 0.0}; // Mu, Min and Max of Poissonian
+        double mGauss[4] = {0.0, 0.0, 0.0, 0.0}; // Mean, Std, Min, Max
+        std::vector<std::vector<double>> mGenPairs;
+        std::vector<std::vector<double>> mGenElectrons;
+        unsigned int mNLoopersPairs = -1;
+        unsigned int mNLoopersCompton = -1;
+        std::array<float, 2> mMultiplier = {1., 1.};
+        bool mPoissonSet = false;
+        bool mGaussSet = false;
+        // Random number generator
+        TRandom3 mRandGen;
+        // Masses of the electrons and positrons
+        TDatabasePDG *mPDG = TDatabasePDG::Instance();
+        double mMass_e = mPDG->GetParticle(11)->Mass();
+        double mMass_p = mPDG->GetParticle(-11)->Mass();
+        int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
+        TFile *mContextFile = nullptr;                                  // Input collision context file
+        o2::steer::DigitizationContext *mCollisionContext = nullptr;    // Pointer to the digitization context
+        std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
+        Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
+        Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
+        double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
+        double mTimeLimit = 0.0;                                        // Time limit for the current event
+        double mTimeEnd = 0.0;                                          // Time limit for the last event
+        float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
+};
+#endif // GENERATORS_WITH_ONNXRUNTIME
+
+} // namespace eventgen
+} // namespace o2
+
+#endif // ALICEO2_EVENTGEN_TPCLOOPERS_H_
\ No newline at end of file
diff --git a/Generators/share/egconfig/ScalerComptonParams.json b/Generators/share/egconfig/ScalerComptonParams.json
new file mode 100644
index 0000000000000..d8e654847f46e
--- /dev/null
+++ b/Generators/share/egconfig/ScalerComptonParams.json
@@ -0,0 +1,28 @@
+{
+    "normal": {
+        "min": [
+            -0.0108811147511005,
+            -0.0098758740350604,
+            -0.0103233363479375,
+            -260.0542297363281,
+            -259.80059814453125
+        ],
+        "max": [
+            0.0108060473576188,
+            0.0103057539090514,
+            0.0106524610891938,
+            260.0343933105469,
+            259.62890625
+        ]
+    },
+    "outlier": {
+        "center": [
+            -71.39387130737305,
+            96791.23828125
+        ],
+        "scale": [
+            265.9389114379883,
+            230762.30981445312
+        ]
+    }
+}
\ No newline at end of file
diff --git a/Generators/share/egconfig/ScalerPairParams.json b/Generators/share/egconfig/ScalerPairParams.json
new file mode 100644
index 0000000000000..61434bfa2462e
--- /dev/null
+++ b/Generators/share/egconfig/ScalerPairParams.json
@@ -0,0 +1,34 @@
+{
+    "normal": {
+        "min": [
+            -0.0073022879660129,
+            -0.0077305701561272,
+            -0.0076750442385673,
+            -0.0082916170358657,
+            -0.0079681202769279,
+            -0.0077468422241508,
+            -255.6164093017578,
+            -252.9441680908203
+        ],
+        "max": [
+            0.007688719779253,
+            0.0077241472899913,
+            0.0075828479602932,
+            0.00813714787364,
+            0.0083825681358575,
+            0.0073839174583554,
+            256.2904968261719,
+            253.4925842285156
+        ]
+    },
+    "outlier": {
+        "center": [
+            -79.66580963134766,
+            141535.640625
+        ],
+        "scale": [
+            250.8921127319336,
+            222363.16015625
+        ]
+    }
+}
\ No newline at end of file
diff --git a/Generators/share/egconfig/gaussian_params.csv b/Generators/share/egconfig/gaussian_params.csv
new file mode 100644
index 0000000000000..8e07c22dd30bf
--- /dev/null
+++ b/Generators/share/egconfig/gaussian_params.csv
@@ -0,0 +1,4 @@
+9.611554230339172022e+01
+1.963570744941765867e+01
+4.300000000000000000e+01
+1.690000000000000000e+02
diff --git a/Generators/share/egconfig/poisson_params.csv b/Generators/share/egconfig/poisson_params.csv
new file mode 100644
index 0000000000000..ef26bd973d34c
--- /dev/null
+++ b/Generators/share/egconfig/poisson_params.csv
@@ -0,0 +1,3 @@
+3.165383056343737511e+00
+1.000000000000000000e+00
+1.200000000000000000e+01
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 9204ede98215e..153ef5cd5e35e 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -17,11 +17,14 @@
 #include "SimulationDataFormat/MCEventHeader.h"
 #include "SimulationDataFormat/ParticleStatus.h"
 #include "SimulationDataFormat/MCGenProperties.h"
+#include <SimConfig/SimConfig.h>
 #include "FairPrimaryGenerator.h"
 #include <fairlogger/Logger.h>
 #include <cmath>
 #include "TClonesArray.h"
 #include "TParticle.h"
+#include "TSystem.h"
+#include "TGrid.h"
 
 namespace o2
 {
@@ -39,6 +42,18 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
   /** default constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
+  auto simConfig = o2::conf::SimConfig::Instance();
+  auto noLoops = simConfig.getLoopersVeto();
+  if (!noLoops) {
+    bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
+    if (transport) {
+      bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
+      if (tpcActive) {
+        mAddLoopers = kTRUE;
+        initLoopersGen();
+      }
+    }
+  }
 }
 
 /*****************************************************************/
@@ -49,6 +64,102 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
   /** constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
+  auto simConfig = o2::conf::SimConfig::Instance();
+  auto noLoops = simConfig.getLoopersVeto();
+  if (!noLoops) {
+    bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
+    if (transport) {
+      bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
+      if (tpcActive) {
+        mAddLoopers = kTRUE;
+        initLoopersGen();
+      }
+    }
+  }
+}
+
+/*****************************************************************/
+
+void Generator::initLoopersGen()
+{
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+  // Expand all environment paths
+  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
+  std::string model_pairs = gSystem->ExpandPathName(loopersParam.model_pairs.c_str());
+  std::string model_compton = gSystem->ExpandPathName(loopersParam.model_compton.c_str());
+  const auto& scaler_pair = gSystem->ExpandPathName(loopersParam.scaler_pair.c_str());
+  const auto& scaler_compton = gSystem->ExpandPathName(loopersParam.scaler_compton.c_str());
+  const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
+  const auto& gauss = gSystem->ExpandPathName(loopersParam.gauss.c_str());
+  auto flat_gas = loopersParam.flat_gas;
+  const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
+  auto fraction_pairs = loopersParam.fraction_pairs;
+  auto multiplier = loopersParam.multiplier;
+  auto fixedNLoopers = loopersParam.fixedNLoopers;
+  const std::array<std::string, 2> models = {model_pairs, model_compton};
+  const std::array<std::string, 2> local_names = {"WGANpair.onnx", "WGANcompton.onnx"};
+  const std::array<bool, 2> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://")};
+  const std::array<bool, 2> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://")};
+  if (std::any_of(isAlien.begin(), isAlien.end(), [](bool v) { return v; })) {
+    if (!gGrid) {
+      TGrid::Connect("alien://");
+      if (!gGrid) {
+        LOG(fatal) << "AliEn connection failed, check token.";
+        exit(1);
+      }
+    }
+    for (size_t i = 0; i < models.size(); ++i) {
+      if (isAlien[i] && !TFile::Cp(models[i].c_str(), local_names[i].c_str())) {
+        LOG(fatal) << "Error: Model file " << models[i] << " does not exist!";
+        exit(1);
+      }
+    }
+  }
+  if (std::any_of(isCCDB.begin(), isCCDB.end(), [](bool v) { return v; })) {
+    o2::ccdb::CcdbApi ccdb_api;
+    ccdb_api.init("http://alice-ccdb.cern.ch");
+    for (size_t i = 0; i < models.size(); ++i) {
+      if (isCCDB[i]) {
+        auto model_path = models[i].substr(7); // Remove "ccdb://"
+        // Treat filename if provided in the CCDB path
+        auto extension = model_path.find(".onnx");
+        if (extension != std::string::npos) {
+          auto last_slash = model_path.find_last_of('/');
+          model_path = model_path.substr(0, last_slash);
+        }
+        std::map<std::string, std::string> filter;
+        if (!ccdb_api.retrieveBlob(model_path, "./", filter, o2::ccdb::getCurrentTimestamp(), false, local_names[i].c_str())) {
+          LOG(fatal) << "Error: issues in retrieving " << model_path << " from CCDB!";
+          exit(1);
+        }
+      }
+    }
+  }
+  model_pairs = isAlien[0] || isCCDB[0] ? local_names[0] : model_pairs;
+  model_compton = isAlien[1] || isCCDB[1] ? local_names[1] : model_compton;
+  try {
+    // Create the TPC loopers generator with the provided parameters
+    mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
+
+    // Configure the generator with flat gas loopers if enabled (default)
+    if (flat_gas) {
+      mLoopersGen->setFlatGas(flat_gas, nFlatGasLoopers);
+      mLoopersGen->setFractionPairs(fraction_pairs);
+    } else {
+      // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
+      // Multiplier is applied only with distribution sampling
+      // This configuration can be used for testing purposes, in all other cases flat gas is recommended
+      mLoopersGen->SetNLoopers(fixedNLoopers[0], fixedNLoopers[1]);
+      mLoopersGen->SetMultiplier(multiplier);
+    }
+    LOG(info) << "TPC Loopers generator initialized successfully";
+  } catch (const std::exception& e) {
+    LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
+    mLoopersGen.reset();
+  }
+#else
+  LOG(warn) << "ONNX Runtime support not available, cannot initialize TPC loopers generator";
+#endif
 }
 
 /*****************************************************************/
@@ -65,191 +176,230 @@ Bool_t
 /*****************************************************************/
 
 Bool_t
-  Generator::ReadEvent(FairPrimaryGenerator* primGen)
+  Generator::loopers()
 {
-  /** read event **/
-
-  /** endless generate-and-trigger loop **/
-  while (true) {
-    mReadEventCounter++;
-
-    /** clear particle vector **/
-    mParticles.clear();
-
-    /** reset the sub-generator ID **/
-    mSubGeneratorId = -1;
-
-    /** generate event **/
-    if (!generateEvent()) {
-      LOG(error) << "ReadEvent failed in generateEvent";
-      return kFALSE;
-    }
-
-    /** import particles **/
-    if (!importParticles()) {
-      LOG(error) << "ReadEvent failed in importParticles";
-      return kFALSE;
-    }
-
-    if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
-      LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
-    }
-
-    if (!mSubGeneratorsIdToDesc.empty() && mSubGeneratorId < 0) {
-      LOG(fatal) << "ReadEvent failed because SubGenerator description given but sub-generator not set";
-    }
-
-    /** trigger event **/
-    if (triggerEvent()) {
-      mTriggerOkHook(mParticles, mReadEventCounter);
-      break;
-    } else {
-      mTriggerFalseHook(mParticles, mReadEventCounter);
-    }
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+  if (!mLoopersGen) {
+    LOG(error) << "Loopers generator not initialized";
+    return kFALSE;
   }
 
-  /** add tracks **/
-  if (!addTracks(primGen)) {
-    LOG(error) << "ReadEvent failed in addTracks";
+  // Generate loopers using the initialized TPC loopers generator
+  if (!mLoopersGen->generateEvent()) {
+    LOG(error) << "Failed to generate loopers event";
     return kFALSE;
   }
-
-  /** update header **/
-  auto header = primGen->GetEvent();
-  auto o2header = dynamic_cast<o2::dataformats::MCEventHeader*>(header);
-  if (!header) {
-    LOG(fatal) << "MC event header is not a 'o2::dataformats::MCEventHeader' object";
+  const auto& looperParticles = mLoopersGen->importParticles();
+  if (looperParticles.empty()) {
+    LOG(error) << "Failed to import loopers particles";
     return kFALSE;
   }
-  updateHeader(o2header);
-  updateSubGeneratorInformation(o2header);
+  // Append the generated looper particles to the main particle list
+  mParticles.insert(mParticles.end(), looperParticles.begin(), looperParticles.end());
 
-  /** success **/
+  LOG(debug) << "Added " << looperParticles.size() << " looper particles";
+  return kTRUE;
+#else
+  LOG(warn) << "ONNX Runtime support not available, skipping TPC loopers generation";
   return kTRUE;
+#endif
 }
+  /*****************************************************************/
+
+  Bool_t
+    Generator::ReadEvent(FairPrimaryGenerator * primGen)
+  {
+    /** read event **/
+
+    /** endless generate-and-trigger loop **/
+    while (true) {
+      mReadEventCounter++;
+
+      /** clear particle vector **/
+      mParticles.clear();
+
+      /** reset the sub-generator ID **/
+      mSubGeneratorId = -1;
+
+      /** generate event **/
+      if (!generateEvent()) {
+        LOG(error) << "ReadEvent failed in generateEvent";
+        return kFALSE;
+      }
+
+      /** import particles **/
+      if (!importParticles()) {
+        LOG(error) << "ReadEvent failed in importParticles";
+        return kFALSE;
+      }
+
+      /** Add loopers **/
+      if(mAddLoopers){
+        if (!loopers()) {
+          LOG(error) << "ReadEvent failed in loopers";
+          return kFALSE;
+        }
+      }
+
+      if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
+        LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
+      }
+
+      if (!mSubGeneratorsIdToDesc.empty() && mSubGeneratorId < 0) {
+        LOG(fatal) << "ReadEvent failed because SubGenerator description given but sub-generator not set";
+      }
+
+      /** trigger event **/
+      if (triggerEvent()) {
+        mTriggerOkHook(mParticles, mReadEventCounter);
+        break;
+      } else {
+        mTriggerFalseHook(mParticles, mReadEventCounter);
+      }
+    }
 
-/*****************************************************************/
+    /** add tracks **/
+    if (!addTracks(primGen)) {
+      LOG(error) << "ReadEvent failed in addTracks";
+      return kFALSE;
+    }
 
-Bool_t
-  Generator::addTracks(FairPrimaryGenerator* primGen)
-{
-  /** add tracks **/
+    /** update header **/
+    auto header = primGen->GetEvent();
+    auto o2header = dynamic_cast<o2::dataformats::MCEventHeader*>(header);
+    if (!header) {
+      LOG(fatal) << "MC event header is not a 'o2::dataformats::MCEventHeader' object";
+      return kFALSE;
+    }
+    updateHeader(o2header);
+    updateSubGeneratorInformation(o2header);
 
-  auto o2primGen = dynamic_cast<PrimaryGenerator*>(primGen);
-  if (!o2primGen) {
-    LOG(fatal) << "PrimaryGenerator is not a o2::eventgen::PrimaryGenerator";
-    return kFALSE;
+    /** success **/
+    return kTRUE;
   }
 
-  /** loop over particles **/
-  for (const auto& particle : mParticles) {
-    o2primGen->AddTrack(particle.GetPdgCode(),
-                        particle.Px() * mMomentumUnit,
-                        particle.Py() * mMomentumUnit,
-                        particle.Pz() * mMomentumUnit,
-                        particle.Vx() * mPositionUnit,
-                        particle.Vy() * mPositionUnit,
-                        particle.Vz() * mPositionUnit,
-                        particle.GetMother(0),
-                        particle.GetMother(1),
-                        particle.GetDaughter(0),
-                        particle.GetDaughter(1),
-                        particle.TestBit(ParticleStatus::kToBeDone),
-                        particle.Energy() * mEnergyUnit,
-                        particle.T() * mTimeUnit,
-                        particle.GetWeight(),
-                        (TMCProcess)particle.GetUniqueID(),
-                        particle.GetStatusCode()); // generator status information passed as status code field
-  }
+  /*****************************************************************/
 
-  /** success **/
-  return kTRUE;
-}
+  Bool_t
+    Generator::addTracks(FairPrimaryGenerator * primGen)
+  {
+    /** add tracks **/
 
-/*****************************************************************/
+    auto o2primGen = dynamic_cast<PrimaryGenerator*>(primGen);
+    if (!o2primGen) {
+      LOG(fatal) << "PrimaryGenerator is not a o2::eventgen::PrimaryGenerator";
+      return kFALSE;
+    }
 
-Bool_t
-  Generator::boostEvent()
-{
-  /** boost event **/
+    /** loop over particles **/
+    for (const auto& particle : mParticles) {
+      o2primGen->AddTrack(particle.GetPdgCode(),
+                          particle.Px() * mMomentumUnit,
+                          particle.Py() * mMomentumUnit,
+                          particle.Pz() * mMomentumUnit,
+                          particle.Vx() * mPositionUnit,
+                          particle.Vy() * mPositionUnit,
+                          particle.Vz() * mPositionUnit,
+                          particle.GetMother(0),
+                          particle.GetMother(1),
+                          particle.GetDaughter(0),
+                          particle.GetDaughter(1),
+                          particle.TestBit(ParticleStatus::kToBeDone),
+                          particle.Energy() * mEnergyUnit,
+                          particle.T() * mTimeUnit,
+                          particle.GetWeight(),
+                          (TMCProcess)particle.GetUniqueID(),
+                          particle.GetStatusCode()); // generator status information passed as status code field
+    }
 
-  /** success **/
-  return kTRUE;
-}
+    /** success **/
+    return kTRUE;
+  }
 
-/*****************************************************************/
+  /*****************************************************************/
 
-Bool_t
-  Generator::triggerEvent()
-{
-  /** trigger event **/
+  Bool_t
+    Generator::boostEvent()
+  {
+    /** boost event **/
 
-  /** check trigger presence **/
-  if (mTriggers.size() == 0 && mDeepTriggers.size() == 0) {
+    /** success **/
     return kTRUE;
   }
 
-  /** check trigger mode **/
-  Bool_t triggered;
-  if (mTriggerMode == kTriggerOFF) {
-    return kTRUE;
-  } else if (mTriggerMode == kTriggerOR) {
-    triggered = kFALSE;
-  } else if (mTriggerMode == kTriggerAND) {
-    triggered = kTRUE;
-  } else {
-    return kTRUE;
-  }
+  /*****************************************************************/
 
-  /** loop over triggers **/
-  for (const auto& trigger : mTriggers) {
-    auto retval = trigger(mParticles);
-    if (mTriggerMode == kTriggerOR) {
-      triggered |= retval;
+  Bool_t
+    Generator::triggerEvent()
+  {
+    /** trigger event **/
+
+    /** check trigger presence **/
+    if (mTriggers.size() == 0 && mDeepTriggers.size() == 0) {
+      return kTRUE;
     }
-    if (mTriggerMode == kTriggerAND) {
-      triggered &= retval;
+
+    /** check trigger mode **/
+    Bool_t triggered;
+    if (mTriggerMode == kTriggerOFF) {
+      return kTRUE;
+    } else if (mTriggerMode == kTriggerOR) {
+      triggered = kFALSE;
+    } else if (mTriggerMode == kTriggerAND) {
+      triggered = kTRUE;
+    } else {
+      return kTRUE;
     }
-  }
 
-  /** loop over deep triggers **/
-  for (const auto& trigger : mDeepTriggers) {
-    auto retval = trigger(mInterface, mInterfaceName);
-    if (mTriggerMode == kTriggerOR) {
-      triggered |= retval;
+    /** loop over triggers **/
+    for (const auto& trigger : mTriggers) {
+      auto retval = trigger(mParticles);
+      if (mTriggerMode == kTriggerOR) {
+        triggered |= retval;
+      }
+      if (mTriggerMode == kTriggerAND) {
+        triggered &= retval;
+      }
     }
-    if (mTriggerMode == kTriggerAND) {
-      triggered &= retval;
+
+    /** loop over deep triggers **/
+    for (const auto& trigger : mDeepTriggers) {
+      auto retval = trigger(mInterface, mInterfaceName);
+      if (mTriggerMode == kTriggerOR) {
+        triggered |= retval;
+      }
+      if (mTriggerMode == kTriggerAND) {
+        triggered &= retval;
+      }
     }
-  }
 
-  /** return **/
-  return triggered;
-}
+    /** return **/
+    return triggered;
+  }
 
-/*****************************************************************/
+  /*****************************************************************/
 
-void Generator::addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription)
-{
-  if (subGeneratorId < 0) {
-    LOG(fatal) << "Sub-generator IDs must be >= 0, instead, passed value is " << subGeneratorId;
+  void Generator::addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription)
+  {
+    if (subGeneratorId < 0) {
+      LOG(fatal) << "Sub-generator IDs must be >= 0, instead, passed value is " << subGeneratorId;
+    }
+    mSubGeneratorsIdToDesc.insert({subGeneratorId, subGeneratorDescription});
   }
-  mSubGeneratorsIdToDesc.insert({subGeneratorId, subGeneratorDescription});
-}
 
-/*****************************************************************/
+  /*****************************************************************/
 
-void Generator::updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const
-{
-  if (mSubGeneratorId < 0) {
-    return;
+  void Generator::updateSubGeneratorInformation(o2::dataformats::MCEventHeader * header) const
+  {
+    if (mSubGeneratorId < 0) {
+      return;
+    }
+    header->putInfo<int>(o2::mcgenid::GeneratorProperty::SUBGENERATORID, mSubGeneratorId);
+    header->putInfo<std::unordered_map<int, std::string>>(o2::mcgenid::GeneratorProperty::SUBGENERATORDESCRIPTIONMAP, mSubGeneratorsIdToDesc);
   }
-  header->putInfo<int>(o2::mcgenid::GeneratorProperty::SUBGENERATORID, mSubGeneratorId);
-  header->putInfo<std::unordered_map<int, std::string>>(o2::mcgenid::GeneratorProperty::SUBGENERATORDESCRIPTIONMAP, mSubGeneratorsIdToDesc);
-}
 
-/*****************************************************************/
-/*****************************************************************/
+  /*****************************************************************/
+  /*****************************************************************/
 
 } /* namespace eventgen */
 } /* namespace o2 */
diff --git a/Generators/src/GeneratorsLinkDef.h b/Generators/src/GeneratorsLinkDef.h
index 2b8d42f86bf9b..97896d8225042 100644
--- a/Generators/src/GeneratorsLinkDef.h
+++ b/Generators/src/GeneratorsLinkDef.h
@@ -35,6 +35,10 @@
 #pragma link C++ class o2::eventgen::GeneratorFromEventPool + ;
 #pragma link C++ class o2::eventgen::GeneratorEventPoolParam + ;
 #pragma link C++ class o2::eventgen::EventPoolGenConfig + ;
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+#pragma link C++ class o2::eventgen::GenTPCLoopers + ;
+#pragma link C++ class o2::eventgen::GenTPCLoopersParam + ;
+#endif
 #pragma link C++ class o2::conf::ConfigurableParamPromoter < o2::eventgen::GeneratorEventPoolParam, o2::eventgen::EventPoolGenConfig> + ;
 #ifdef GENERATORS_WITH_HEPMC3
 #pragma link C++ class o2::eventgen::GeneratorHepMC + ;
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
new file mode 100644
index 0000000000000..4eacb7674599c
--- /dev/null
+++ b/Generators/src/TPCLoopers.cxx
@@ -0,0 +1,417 @@
+#include "Generators/TPCLoopers.h"
+
+// Static Ort::Env instance for multiple onnx model loading
+Ort::Env global_env(ORT_LOGGING_LEVEL_WARNING, "GlobalEnv");
+
+// This class is responsible for loading the scaler parameters from a JSON file
+// and applying the inverse transformation to the generated data.
+
+void Scaler::load(const std::string &filename)
+{
+  std::ifstream file(filename);
+  if (!file.is_open()) {
+    throw std::runtime_error("Error: Could not open scaler file!");
+  }
+
+  std::string json_str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+  file.close();
+
+  rapidjson::Document doc;
+  doc.Parse(json_str.c_str());
+
+  if (doc.HasParseError()) {
+    throw std::runtime_error("Error: JSON parsing failed!");
+  }
+
+  normal_min = jsonArrayToVector(doc["normal"]["min"]);
+  normal_max = jsonArrayToVector(doc["normal"]["max"]);
+  outlier_center = jsonArrayToVector(doc["outlier"]["center"]);
+  outlier_scale = jsonArrayToVector(doc["outlier"]["scale"]);
+  std::vector<double> normal_min;
+  std::vector<double> normal_max;
+  std::vector<double> outlier_center;
+  std::vector<double> outlier_scale;
+}  
+
+std::vector<double> Scaler::inverse_transform(const std::vector<double> &input)
+{
+    std::vector<double> output;
+    for (int i = 0; i < input.size(); ++i)
+    {
+        if (i < input.size() - 2)
+            output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
+        else
+            output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
+    }
+
+    return output;
+}
+
+std::vector<double> Scaler::jsonArrayToVector(const rapidjson::Value &jsonArray)
+{
+    std::vector<double> vec;
+    for (int i = 0; i < jsonArray.Size(); ++i)
+    {
+        vec.push_back(jsonArray[i].GetDouble());
+    }
+    return vec;
+}
+
+// This class loads the ONNX model and generates samples using it.
+
+ONNXGenerator::ONNXGenerator(Ort::Env& shared_env, const std::string& model_path)
+: env(shared_env), session(env, model_path.c_str(), Ort::SessionOptions{})
+{
+    // Create session options
+    Ort::SessionOptions session_options;
+    session = Ort::Session(env, model_path.c_str(), session_options);
+}
+
+std::vector<double> ONNXGenerator::generate_sample()
+{
+    Ort::AllocatorWithDefaultOptions allocator;
+
+    // Generate a latent vector (z)
+    std::vector<float> z(100);
+    for (auto &v : z)
+        v = rand_gen.Gaus(0.0, 1.0);
+
+    // Prepare input tensor
+    std::vector<int64_t> input_shape = {1, 100};
+    // Get memory information
+    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+
+    // Create input tensor correctly
+    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
+        memory_info, z.data(), z.size(), input_shape.data(), input_shape.size());
+    // Run inference
+    const char *input_names[] = {"z"};
+    const char *output_names[] = {"output"};
+    auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, 1);
+
+    // Extract output
+    float *output_data = output_tensors.front().GetTensorMutableData<float>();
+    // Get the size of the output tensor
+    auto output_tensor_info = output_tensors.front().GetTensorTypeAndShapeInfo();
+    size_t output_data_size = output_tensor_info.GetElementCount(); // Total number of elements in the tensor
+    std::vector<double> output;
+    for (int i = 0; i < output_data_size; ++i)
+    {
+        output.push_back(output_data[i]);
+    }
+
+    return output;
+}
+
+namespace o2
+{
+namespace eventgen
+{
+
+GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
+                std::string poisson, std::string gauss, std::string scaler_pair,
+                std::string scaler_compton)
+{
+    // Checking if the model files exist and are not empty
+    std::ifstream model_file[2];
+    model_file[0].open(model_pairs);
+    model_file[1].open(model_compton);
+    if (!model_file[0].is_open() || model_file[0].peek() == std::ifstream::traits_type::eof())
+    {
+        LOG(fatal) << "Error: Pairs model file is empty or does not exist!";
+        exit(1);
+    }
+    if (!model_file[1].is_open() || model_file[1].peek() == std::ifstream::traits_type::eof())
+    {
+        LOG(fatal) << "Error: Compton model file is empty or does not exist!";
+        exit(1);
+    }
+    model_file[0].close();
+    model_file[1].close();
+    // Checking if the scaler files exist and are not empty
+    std::ifstream scaler_file[2];
+    scaler_file[0].open(scaler_pair);
+    scaler_file[1].open(scaler_compton);
+    if (!scaler_file[0].is_open() || scaler_file[0].peek() == std::ifstream::traits_type::eof())
+    {
+        LOG(fatal) << "Error: Pairs scaler file is empty or does not exist!";
+        exit(1);
+    }
+    if (!scaler_file[1].is_open() || scaler_file[1].peek() == std::ifstream::traits_type::eof())
+    {
+        LOG(fatal) << "Error: Compton scaler file is empty or does not exist!";
+        exit(1);
+    }
+    scaler_file[0].close();
+    scaler_file[1].close();
+    // Checking if the poisson file exists and it's not empty
+    if (poisson != "")
+    {
+        std::ifstream poisson_file(poisson);
+        if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof())
+        {
+            LOG(fatal) << "Error: Poisson file is empty or does not exist!";
+            exit(1);
+        }
+        else
+        {
+            poisson_file >> mPoisson[0] >> mPoisson[1] >> mPoisson[2];
+            poisson_file.close();
+            mPoissonSet = true;
+        }
+    }
+    // Checking if the gauss file exists and it's not empty
+    if (gauss != "")
+    {
+        std::ifstream gauss_file(gauss);
+        if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof())
+        {
+            LOG(fatal) << "Error: Gauss file is empty or does not exist!";
+            exit(1);
+        }
+        else
+        {
+            gauss_file >> mGauss[0] >> mGauss[1] >> mGauss[2] >> mGauss[3];
+            gauss_file.close();
+            mGaussSet = true;
+        }
+    }
+    mONNX_pair = std::make_unique<ONNXGenerator>(global_env, model_pairs);
+    mScaler_pair = std::make_unique<Scaler>();
+    mScaler_pair->load(scaler_pair);
+    mONNX_compton = std::make_unique<ONNXGenerator>(global_env, model_compton);
+    mScaler_compton = std::make_unique<Scaler>();
+    mScaler_compton->load(scaler_compton);
+}
+
+Bool_t GenTPCLoopers::generateEvent()
+{
+  // Clear the vector of pairs
+  mGenPairs.clear();
+  // Clear the vector of compton electrons
+  mGenElectrons.clear();
+  if (mFlatGas) {
+    unsigned int nLoopers, nLoopersPairs, nLoopersCompton;
+    LOG(debug) << "mCurrentEvent is " << mCurrentEvent;
+    LOG(debug) << "Current event time: " << ((mCurrentEvent < mInteractionTimeRecords.size() - 1) ? std::to_string(mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns()) : std::to_string(mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns())) << " ns";
+    LOG(debug) << "Current time offset wrt BC: " << mInteractionTimeRecords[mCurrentEvent].getTimeOffsetWrtBC() << " ns";
+    mTimeLimit = (mCurrentEvent < mInteractionTimeRecords.size() - 1) ? mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns() : mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns();
+    // With flat gas the number of loopers are adapted based on time interval widths
+    nLoopers = mFlatGasNumber * (mTimeLimit / mIntTimeRecMean);
+    nLoopersPairs = static_cast<unsigned int>(std::round(nLoopers * mLoopsFractionPairs));
+    nLoopersCompton = nLoopers - nLoopersPairs;
+    SetNLoopers(nLoopersPairs, nLoopersCompton);
+    LOG(info) << "Flat gas loopers: " << nLoopers << " (pairs: " << nLoopersPairs << ", compton: " << nLoopersCompton << ")";
+    generateEvent(mTimeLimit);
+    mCurrentEvent++;
+  } else {
+    // Set number of loopers if poissonian params are available
+    if (mPoissonSet) {
+      mNLoopersPairs = static_cast<unsigned int>(std::round(mMultiplier[0] * PoissonPairs()));
+    }
+    if (mGaussSet) {
+      mNLoopersCompton = static_cast<unsigned int>(std::round(mMultiplier[1] * GaussianElectrons()));
+    }
+    // Generate pairs
+    for (int i = 0; i < mNLoopersPairs; ++i) {
+      std::vector<double> pair = mONNX_pair->generate_sample();
+      // Apply the inverse transformation using the scaler
+      std::vector<double> transformed_pair = mScaler_pair->inverse_transform(pair);
+      mGenPairs.push_back(transformed_pair);
+    }
+    // Generate compton electrons
+    for (int i = 0; i < mNLoopersCompton; ++i) {
+      std::vector<double> electron = mONNX_compton->generate_sample();
+      // Apply the inverse transformation using the scaler
+      std::vector<double> transformed_electron = mScaler_compton->inverse_transform(electron);
+      mGenElectrons.push_back(transformed_electron);
+    }
+  }
+  return true;
+}
+
+Bool_t GenTPCLoopers::generateEvent(double& time_limit)
+{
+  LOG(info) << "Time constraint for loopers: " << time_limit << " ns";
+  // Generate pairs
+  for (int i = 0; i < mNLoopersPairs; ++i) {
+    std::vector<double> pair = mONNX_pair->generate_sample();
+    // Apply the inverse transformation using the scaler
+    std::vector<double> transformed_pair = mScaler_pair->inverse_transform(pair);
+    transformed_pair[9] = gRandom->Uniform(0., time_limit); // Regenerate time, scaling is not needed because time_limit is already in nanoseconds
+    mGenPairs.push_back(transformed_pair);
+  }
+  // Generate compton electrons
+  for (int i = 0; i < mNLoopersCompton; ++i) {
+    std::vector<double> electron = mONNX_compton->generate_sample();
+    // Apply the inverse transformation using the scaler
+    std::vector<double> transformed_electron = mScaler_compton->inverse_transform(electron);
+    transformed_electron[6] = gRandom->Uniform(0., time_limit); // Regenerate time, scaling is not needed because time_limit is already in nanoseconds
+    mGenElectrons.push_back(transformed_electron);
+  }
+  LOG(info) << "Generated Particles with time limit";
+  return true;
+}
+
+std::vector<TParticle> GenTPCLoopers::importParticles()
+{
+  std::vector<TParticle> particles;
+  // Get looper pairs from the event
+  for (auto& pair : mGenPairs) {
+    double px_e, py_e, pz_e, px_p, py_p, pz_p;
+    double vx, vy, vz, time;
+    double e_etot, p_etot;
+    px_e = pair[0];
+    py_e = pair[1];
+    pz_e = pair[2];
+    px_p = pair[3];
+    py_p = pair[4];
+    pz_p = pair[5];
+    vx = pair[6];
+    vy = pair[7];
+    vz = pair[8];
+    time = pair[9];
+    e_etot = TMath::Sqrt(px_e * px_e + py_e * py_e + pz_e * pz_e + mMass_e * mMass_e);
+    p_etot = TMath::Sqrt(px_p * px_p + py_p * py_p + pz_p * pz_p + mMass_p * mMass_p);
+    // Push the electron
+    TParticle electron(11, 1, -1, -1, -1, -1, px_e, py_e, pz_e, e_etot, vx, vy, vz, time / 1e9);
+    electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
+    electron.SetBit(ParticleStatus::kToBeDone, //
+                    o2::mcgenstatus::getHepMCStatusCode(electron.GetStatusCode()) == 1);
+    particles.push_back(electron);
+    // Push the positron
+    TParticle positron(-11, 1, -1, -1, -1, -1, px_p, py_p, pz_p, p_etot, vx, vy, vz, time / 1e9);
+    positron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(positron.GetStatusCode(), 0).fullEncoding);
+    positron.SetBit(ParticleStatus::kToBeDone, //
+                    o2::mcgenstatus::getHepMCStatusCode(positron.GetStatusCode()) == 1);
+    particles.push_back(positron);
+  }
+  // Get compton electrons from the event
+  for (auto& compton : mGenElectrons) {
+    double px, py, pz;
+    double vx, vy, vz, time;
+    double etot;
+    px = compton[0];
+    py = compton[1];
+    pz = compton[2];
+    vx = compton[3];
+    vy = compton[4];
+    vz = compton[5];
+    time = compton[6];
+    etot = TMath::Sqrt(px * px + py * py + pz * pz + mMass_e * mMass_e);
+    // Push the electron
+    TParticle electron(11, 1, -1, -1, -1, -1, px, py, pz, etot, vx, vy, vz, time / 1e9);
+    electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
+    electron.SetBit(ParticleStatus::kToBeDone, //
+                    o2::mcgenstatus::getHepMCStatusCode(electron.GetStatusCode()) == 1);
+    particles.push_back(electron);
+  }
+
+  return particles;
+}
+
+unsigned int GenTPCLoopers::PoissonPairs()
+{
+  unsigned int poissonValue;
+  do {
+    // Generate a Poisson-distributed random number with mean mPoisson[0]
+    poissonValue = mRandGen.Poisson(mPoisson[0]);
+  } while (poissonValue < mPoisson[1] || poissonValue > mPoisson[2]); // Regenerate if out of range
+
+  return poissonValue;
+}
+
+unsigned int GenTPCLoopers::GaussianElectrons()
+{
+  unsigned int gaussValue;
+  do {
+    // Generate a Normal-distributed random number with mean mGass[0] and stddev mGauss[1]
+    gaussValue = mRandGen.Gaus(mGauss[0], mGauss[1]);
+  } while (gaussValue < mGauss[2] || gaussValue > mGauss[3]); // Regenerate if out of range
+
+  return gaussValue;
+}
+
+void GenTPCLoopers::SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_compton)
+{
+  if (mFlatGas) {
+    mNLoopersPairs = nsig_pair;
+    mNLoopersCompton = nsig_compton;
+  } else {
+    if (mPoissonSet) {
+      LOG(info) << "Poissonian parameters correctly loaded.";
+    } else {
+      mNLoopersPairs = nsig_pair;
+    }
+    if (mGaussSet) {
+      LOG(info) << "Gaussian parameters correctly loaded.";
+    } else {
+      mNLoopersCompton = nsig_compton;
+    }
+  }
+}
+
+void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
+{
+    // Multipliers will work only if the poissonian and gaussian parameters are set
+    // otherwise they will be ignored
+    if (mult[0] < 0 || mult[1] < 0)
+    {
+        LOG(fatal) << "Error: Multiplier values must be non-negative!";
+        exit(1);
+    } else {
+        LOG(info) << "Multiplier values set to: Pair = " << mult[0] << ", Compton = " << mult[1];
+        mMultiplier[0] = mult[0];
+        mMultiplier[1] = mult[1];
+    }
+}
+
+void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number)
+{
+  mFlatGas = flat;
+  if (mFlatGas) {
+    if (number < 0) {
+      LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
+      mFlatGas = false;
+      mFlatGasNumber = -1;
+    } else {
+      mFlatGasNumber = number;
+      mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
+      mCollisionContext = mContextFile ? (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext") : nullptr;
+      mInteractionTimeRecords = mCollisionContext ? mCollisionContext->getEventRecords() : std::vector<o2::InteractionTimeRecord>{};
+      if (mInteractionTimeRecords.empty()) {
+        LOG(error) << "Error: No interaction time records found in the collision context!";
+        exit(1);
+      } else {
+        LOG(info) << "Interaction Time records has " << mInteractionTimeRecords.size() << " entries.";
+        mCollisionContext->printCollisionSummary();
+      }
+      for (int c = 0; c < mInteractionTimeRecords.size() - 1; c++) {
+        mIntTimeRecMean += mInteractionTimeRecords[c + 1].bc2ns() - mInteractionTimeRecords[c].bc2ns();
+      }
+      mIntTimeRecMean /= (mInteractionTimeRecords.size() - 1); // Average interaction time record used as reference
+      const auto& hbfUtils = o2::raw::HBFUtils::Instance();
+      // Get the start time of the second orbit after the last interaction record
+      const auto& lastIR = mInteractionTimeRecords.back();
+      o2::InteractionRecord finalOrbitIR(0, lastIR.orbit + 2); // Final orbit, BC = 0
+      mTimeEnd = finalOrbitIR.bc2ns();
+      LOG(debug) << "Final orbit start time: " << mTimeEnd << " ns while last interaction record time is " << mInteractionTimeRecords.back().bc2ns() << " ns";
+    }
+  } else {
+    mFlatGasNumber = -1;
+  }
+  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per event: " << mFlatGasNumber;
+}
+
+void GenTPCLoopers::setFractionPairs(float& fractionPairs)
+{
+  if (fractionPairs < 0 || fractionPairs > 1) {
+    LOG(fatal) << "Error: Loops fraction for pairs must be in the range [0, 1].";
+    exit(1);
+  }
+  mLoopsFractionPairs = fractionPairs;
+  LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
+}
+
+} // namespace eventgen
+} // namespace o2
\ No newline at end of file
diff --git a/Generators/src/TPCLoopersParam.cxx b/Generators/src/TPCLoopersParam.cxx
new file mode 100644
index 0000000000000..0202a8ced0535
--- /dev/null
+++ b/Generators/src/TPCLoopersParam.cxx
@@ -0,0 +1,15 @@
+// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \author M+Giacalone - September 2025
+
+#include "Generators/TPCLoopersParam.h"
+O2ParamImpl(o2::eventgen::GenTPCLoopersParam);

From 4b6530fbc6a93963de72035d123b6666b2991e32 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 26 Sep 2025 15:57:46 +0200
Subject: [PATCH 1155/1764] Various improvements

Fixed arrays in TPCLoopersParams and implemented comments
---
 .../SimConfig/include/SimConfig/SimConfig.h   |   3 -
 Common/SimConfig/src/SimConfig.cxx            |   2 -
 Generators/CMakeLists.txt                     |   4 +-
 Generators/include/Generators/Generator.h     |  11 +-
 .../include/Generators/TPCLoopersParam.h      |   5 +-
 Generators/include/TPCLoopers.h               |  12 +-
 Generators/src/Generator.cxx                  | 392 +++++++++---------
 Generators/src/GeneratorsLinkDef.h            |   2 +-
 Generators/src/TPCLoopers.cxx                 |   3 -
 9 files changed, 214 insertions(+), 220 deletions(-)

diff --git a/Common/SimConfig/include/SimConfig/SimConfig.h b/Common/SimConfig/include/SimConfig/SimConfig.h
index 8642a0e5bc225..be88d9fbd8c33 100644
--- a/Common/SimConfig/include/SimConfig/SimConfig.h
+++ b/Common/SimConfig/include/SimConfig/SimConfig.h
@@ -52,7 +52,6 @@ struct SimConfigData {
   std::vector<std::string> mActiveModules;            // list of active modules
   std::vector<std::string> mReadoutDetectors;         // list of readout detectors
   std::string mMCEngine;                              // chosen VMC engine
-  bool mNoLoopers = false;                            // Disable automatic TPC loopers
   std::string mGenerator;                             // chosen VMC generator
   std::string mTrigger;                               // chosen VMC generator trigger
   unsigned int mNEvents;                              // number of events to be simulated
@@ -139,8 +138,6 @@ class SimConfig
   // get selected active detectors
   std::vector<std::string> const& getActiveModules() const { return mConfigData.mActiveModules; }
   std::vector<std::string> const& getReadoutDetectors() const { return mConfigData.mReadoutDetectors; }
-  // get loopers veto
-  bool getLoopersVeto() const { return mConfigData.mNoLoopers; }
 
   // static helper functions to determine list of active / readout modules
   // can also be used from outside
diff --git a/Common/SimConfig/src/SimConfig.cxx b/Common/SimConfig/src/SimConfig.cxx
index 5ddc3199e3d4a..15879687872d5 100644
--- a/Common/SimConfig/src/SimConfig.cxx
+++ b/Common/SimConfig/src/SimConfig.cxx
@@ -74,7 +74,6 @@ void SimConfig::initOptions(boost::program_options::options_description& options
     "run", bpo::value<int>()->default_value(-1), "ALICE run number")(
     "asservice", bpo::value<bool>()->default_value(false), "run in service/server mode")(
     "noGeant", bpo::bool_switch(), "prohibits any Geant transport/physics (by using tight cuts)")(
-    "noLoopers", bpo::bool_switch(), "disable automatic TPC loopers")(
     "forwardKine", bpo::bool_switch(), "forward kinematics on a FairMQ channel")(
     "noDiscOutput", bpo::bool_switch(), "switch off writing sim results to disc (useful in combination with forwardKine)");
   options.add_options()("fromCollContext", bpo::value<std::string>()->default_value(""), "Use a pregenerated collision context to infer number of events to simulate, how to embedd them, the vertex position etc. Takes precedence of other options such as \"--nEvents\". The format is COLLISIONCONTEXTFILE.root[:SIGNALNAME] where SIGNALNAME is the event part in the context which is relevant.");
@@ -298,7 +297,6 @@ bool SimConfig::resetFromParsedMap(boost::program_options::variables_map const&
   using o2::detectors::DetID;
   mConfigData.mMCEngine = vm["mcEngine"].as<std::string>();
   mConfigData.mNoGeant = vm["noGeant"].as<bool>();
-  mConfigData.mNoLoopers = vm["noLoopers"].as<bool>();
 
   // Reset modules and detectors as they are anyway re-parsed
   mConfigData.mReadoutDetectors.clear();
diff --git a/Generators/CMakeLists.txt b/Generators/CMakeLists.txt
index 56fe8b8fc2284..f1921b8d8d72a 100644
--- a/Generators/CMakeLists.txt
+++ b/Generators/CMakeLists.txt
@@ -67,7 +67,7 @@ if(HepMC3_FOUND)
 endif()
 
 if(onnxruntime_FOUND)
-  target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_ONNXRUNTIME)
+  target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_TPCLOOPERS)
 endif()
 
 set(headers
@@ -96,7 +96,7 @@ set(headers
     )
 
 if(onnxruntime_FOUND)
-  list(APPEND headers 
+  list(APPEND headers
               include/Generators/TPCLoopers.h
               include/Generators/TPCLoopersParam.h)
 endif()
diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 374d53f324399..4b68112517893 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -17,7 +17,8 @@
 #include "FairGenerator.h"
 #include "TParticle.h"
 #include "Generators/Trigger.h"
-#ifdef GENERATORS_WITH_ONNXRUNTIME
+#include "CCDB/BasicCCDBManager.h"
+#ifdef GENERATORS_WITH_TPCLOOPERS
 #include "Generators/TPCLoopers.h"
 #include "Generators/TPCLoopersParam.h"
 #endif
@@ -77,7 +78,7 @@ class Generator : public FairGenerator
   /** methods to override **/
   virtual Bool_t generateEvent() = 0;   // generates event (in structure internal to generator)
   virtual Bool_t importParticles() = 0; // fills the mParticles vector (transfer from generator state)
-  Bool_t loopers();                     // adds loopers to the event in case TPC is used
+  Bool_t finalizeEvent();               // final part of event generation that can be customised using external macros
   virtual void updateHeader(o2::dataformats::MCEventHeader* eventHeader) {};
   Bool_t triggerEvent();
 
@@ -160,7 +161,7 @@ class Generator : public FairGenerator
   void updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const;
 
   // loopers flag
-  Bool_t mAddLoopers = kFALSE;
+  Bool_t mAddTPCLoopers = kFALSE;  // Flag is automatically set to true if TPC is in readout detectors, loopers are not vetoed and transport is enabled
   // collect an ID and a short description of sub-generator entities
   std::unordered_map<int, std::string> mSubGeneratorsIdToDesc;
   // the current ID of the sub-generator used in the current event (if applicable)
@@ -169,11 +170,11 @@ class Generator : public FairGenerator
   // global static information about (upper limit of) number of events to be generated
   static unsigned int gTotalNEvents;
 
-#ifdef GENERATORS_WITH_ONNXRUNTIME
+#ifdef GENERATORS_WITH_TPCLOOPERS
   // Loopers generator instance
   std::unique_ptr<o2::eventgen::GenTPCLoopers> mLoopersGen = nullptr;
-#endif
   void initLoopersGen();
+#endif
 
   ClassDefOverride(Generator, 2);
 
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index ceeea201538b2..9430f4e05ac6e 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -28,6 +28,7 @@ namespace eventgen
  ** allow the user to modify them
  **/
 struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
+  bool loopersVeto = false; // if true, no loopers are generated
   std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";  // ONNX model for e+e- pair production
   std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton"; // ONNX model for Compton scattering
   std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv"; // file with Poissonian parameters
@@ -37,8 +38,8 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
   int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
   float fraction_pairs = 0.08; // fraction of loopers
-  std::array<float, 2> multiplier = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
-  std::array<unsigned int, 2> fixedNLoopers = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
+  unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 70146a82baf60..1c1f3585eb3ab 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -1,7 +1,7 @@
 #ifndef ALICEO2_EVENTGEN_TPCLOOPERS_H_
 #define ALICEO2_EVENTGEN_TPCLOOPERS_H_
 
-#ifdef GENERATORS_WITH_ONNXRUNTIME
+#ifdef GENERATORS_WITH_TPCLOOPERS
 #include <onnxruntime_cxx_api.h>
 #endif
 #include <iostream>
@@ -19,12 +19,10 @@
 #include "TParticle.h"
 #include <filesystem>
 
-#ifdef GENERATORS_WITH_ONNXRUNTIME
+#ifdef GENERATORS_WITH_TPCLOOPERS
 // Static Ort::Env instance for multiple onnx model loading
 extern Ort::Env global_env;
-#endif
 
-#ifdef GENERATORS_WITH_ONNXRUNTIME
 // This class is responsible for loading the scaler parameters from a JSON file
 // and applying the inverse transformation to the generated data.
 struct Scaler
@@ -55,14 +53,14 @@ class ONNXGenerator
     Ort::Session session;
     TRandom3 rand_gen;
 };
-#endif // GENERATORS_WITH_ONNXRUNTIME
+#endif // GENERATORS_WITH_TPCLOOPERS
 
 namespace o2
 {
 namespace eventgen
 {
 
-#ifdef GENERATORS_WITH_ONNXRUNTIME
+#ifdef GENERATORS_WITH_TPCLOOPERS
 class GenTPCLoopers
 {
     public:
@@ -119,7 +117,7 @@ class GenTPCLoopers
         double mTimeEnd = 0.0;                                          // Time limit for the last event
         float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
 };
-#endif // GENERATORS_WITH_ONNXRUNTIME
+#endif // GENERATORS_WITH_TPCLOOPERS
 
 } // namespace eventgen
 } // namespace o2
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 153ef5cd5e35e..6fc9f378148d3 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -42,18 +42,20 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
   /** default constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
-  auto simConfig = o2::conf::SimConfig::Instance();
-  auto noLoops = simConfig.getLoopersVeto();
-  if (!noLoops) {
+#ifdef GENERATORS_WITH_TPCLOOPERS
+  const auto& simConfig = o2::conf::SimConfig::Instance();
+  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
+  if (!loopersParam.loopersVeto) {
     bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        mAddLoopers = kTRUE;
+        mAddTPCLoopers = kTRUE;
         initLoopersGen();
       }
     }
   }
+#endif
 }
 
 /*****************************************************************/
@@ -64,25 +66,26 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
   /** constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
-  auto simConfig = o2::conf::SimConfig::Instance();
-  auto noLoops = simConfig.getLoopersVeto();
-  if (!noLoops) {
+#ifdef GENERATORS_WITH_TPCLOOPERS
+  const auto& simConfig = o2::conf::SimConfig::Instance();
+  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
+  if (!loopersParam.loopersVeto) {
     bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        mAddLoopers = kTRUE;
+        mAddTPCLoopers = kTRUE;
         initLoopersGen();
       }
     }
   }
+#endif
 }
 
 /*****************************************************************/
-
+#ifdef GENERATORS_WITH_TPCLOOPERS
 void Generator::initLoopersGen()
 {
-#ifdef GENERATORS_WITH_ONNXRUNTIME
   // Expand all environment paths
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
   std::string model_pairs = gSystem->ExpandPathName(loopersParam.model_pairs.c_str());
@@ -94,8 +97,9 @@ void Generator::initLoopersGen()
   auto flat_gas = loopersParam.flat_gas;
   const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
   auto fraction_pairs = loopersParam.fraction_pairs;
-  auto multiplier = loopersParam.multiplier;
-  auto fixedNLoopers = loopersParam.fixedNLoopers;
+  std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
+  unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
+  unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
   const std::array<std::string, 2> models = {model_pairs, model_compton};
   const std::array<std::string, 2> local_names = {"WGANpair.onnx", "WGANcompton.onnx"};
   const std::array<bool, 2> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://")};
@@ -116,8 +120,10 @@ void Generator::initLoopersGen()
     }
   }
   if (std::any_of(isCCDB.begin(), isCCDB.end(), [](bool v) { return v; })) {
-    o2::ccdb::CcdbApi ccdb_api;
-    ccdb_api.init("http://alice-ccdb.cern.ch");
+    auto& ccdb = o2::ccdb::BasicCCDBManager::instance();
+    ccdb.setURL("http://alice-ccdb.cern.ch");
+    // Get underlying CCDB API from BasicCCDBManager
+    auto& ccdb_api = ccdb.getCCDBAccessor();
     for (size_t i = 0; i < models.size(); ++i) {
       if (isCCDB[i]) {
         auto model_path = models[i].substr(7); // Remove "ccdb://"
@@ -149,7 +155,7 @@ void Generator::initLoopersGen()
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
       // Multiplier is applied only with distribution sampling
       // This configuration can be used for testing purposes, in all other cases flat gas is recommended
-      mLoopersGen->SetNLoopers(fixedNLoopers[0], fixedNLoopers[1]);
+      mLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
       mLoopersGen->SetMultiplier(multiplier);
     }
     LOG(info) << "TPC Loopers generator initialized successfully";
@@ -157,10 +163,8 @@ void Generator::initLoopersGen()
     LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
     mLoopersGen.reset();
   }
-#else
-  LOG(warn) << "ONNX Runtime support not available, cannot initialize TPC loopers generator";
-#endif
 }
+#endif
 
 /*****************************************************************/
 
@@ -176,230 +180,228 @@ Bool_t
 /*****************************************************************/
 
 Bool_t
-  Generator::loopers()
+  Generator::finalizeEvent()
 {
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-  if (!mLoopersGen) {
-    LOG(error) << "Loopers generator not initialized";
-    return kFALSE;
-  }
+#ifdef GENERATORS_WITH_TPCLOOPERS
+  if(mAddTPCLoopers) {
+    if (!mLoopersGen) {
+      LOG(error) << "Loopers generator not initialized";
+      return kFALSE;
+    }
 
-  // Generate loopers using the initialized TPC loopers generator
-  if (!mLoopersGen->generateEvent()) {
-    LOG(error) << "Failed to generate loopers event";
-    return kFALSE;
-  }
-  const auto& looperParticles = mLoopersGen->importParticles();
-  if (looperParticles.empty()) {
-    LOG(error) << "Failed to import loopers particles";
-    return kFALSE;
-  }
-  // Append the generated looper particles to the main particle list
-  mParticles.insert(mParticles.end(), looperParticles.begin(), looperParticles.end());
+    // Generate loopers using the initialized TPC loopers generator
+    if (!mLoopersGen->generateEvent()) {
+      LOG(error) << "Failed to generate loopers event";
+      return kFALSE;
+    }
+    const auto& looperParticles = mLoopersGen->importParticles();
+    if (looperParticles.empty()) {
+      LOG(error) << "Failed to import loopers particles";
+      return kFALSE;
+    }
+    // Append the generated looper particles to the main particle list
+    mParticles.insert(mParticles.end(), looperParticles.begin(), looperParticles.end());
 
-  LOG(debug) << "Added " << looperParticles.size() << " looper particles";
-  return kTRUE;
-#else
-  LOG(warn) << "ONNX Runtime support not available, skipping TPC loopers generation";
-  return kTRUE;
+    LOG(debug) << "Added " << looperParticles.size() << " looper particles";
+  }
 #endif
+  return kTRUE;
 }
-  /*****************************************************************/
 
-  Bool_t
-    Generator::ReadEvent(FairPrimaryGenerator * primGen)
-  {
-    /** read event **/
-
-    /** endless generate-and-trigger loop **/
-    while (true) {
-      mReadEventCounter++;
+/*****************************************************************/
 
-      /** clear particle vector **/
-      mParticles.clear();
+Bool_t
+  Generator::ReadEvent(FairPrimaryGenerator* primGen)
+{
+  /** read event **/
 
-      /** reset the sub-generator ID **/
-      mSubGeneratorId = -1;
+  /** endless generate-and-trigger loop **/
+  while (true) {
+    mReadEventCounter++;
 
-      /** generate event **/
-      if (!generateEvent()) {
-        LOG(error) << "ReadEvent failed in generateEvent";
-        return kFALSE;
-      }
+    /** clear particle vector **/
+    mParticles.clear();
 
-      /** import particles **/
-      if (!importParticles()) {
-        LOG(error) << "ReadEvent failed in importParticles";
-        return kFALSE;
-      }
+    /** reset the sub-generator ID **/
+    mSubGeneratorId = -1;
 
-      /** Add loopers **/
-      if(mAddLoopers){
-        if (!loopers()) {
-          LOG(error) << "ReadEvent failed in loopers";
-          return kFALSE;
-        }
-      }
+    /** generate event **/
+    if (!generateEvent()) {
+      LOG(error) << "ReadEvent failed in generateEvent";
+      return kFALSE;
+    }
 
-      if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
-        LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
-      }
+    /** import particles **/
+    if (!importParticles()) {
+      LOG(error) << "ReadEvent failed in importParticles";
+      return kFALSE;
+    }
 
-      if (!mSubGeneratorsIdToDesc.empty() && mSubGeneratorId < 0) {
-        LOG(fatal) << "ReadEvent failed because SubGenerator description given but sub-generator not set";
-      }
+    /** Event finalization**/
+    if(!finalizeEvent()) {
+      LOG(error) << "ReadEvent failed in finalizeEvent";
+      return kFALSE;
+    }
 
-      /** trigger event **/
-      if (triggerEvent()) {
-        mTriggerOkHook(mParticles, mReadEventCounter);
-        break;
-      } else {
-        mTriggerFalseHook(mParticles, mReadEventCounter);
-      }
+    if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
+      LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
     }
 
-    /** add tracks **/
-    if (!addTracks(primGen)) {
-      LOG(error) << "ReadEvent failed in addTracks";
-      return kFALSE;
+    if (!mSubGeneratorsIdToDesc.empty() && mSubGeneratorId < 0) {
+      LOG(fatal) << "ReadEvent failed because SubGenerator description given but sub-generator not set";
     }
 
-    /** update header **/
-    auto header = primGen->GetEvent();
-    auto o2header = dynamic_cast<o2::dataformats::MCEventHeader*>(header);
-    if (!header) {
-      LOG(fatal) << "MC event header is not a 'o2::dataformats::MCEventHeader' object";
-      return kFALSE;
+    /** trigger event **/
+    if (triggerEvent()) {
+      mTriggerOkHook(mParticles, mReadEventCounter);
+      break;
+    } else {
+      mTriggerFalseHook(mParticles, mReadEventCounter);
     }
-    updateHeader(o2header);
-    updateSubGeneratorInformation(o2header);
+  }
 
-    /** success **/
-    return kTRUE;
+  /** add tracks **/
+  if (!addTracks(primGen)) {
+    LOG(error) << "ReadEvent failed in addTracks";
+    return kFALSE;
+  }
+
+  /** update header **/
+  auto header = primGen->GetEvent();
+  auto o2header = dynamic_cast<o2::dataformats::MCEventHeader*>(header);
+  if (!header) {
+    LOG(fatal) << "MC event header is not a 'o2::dataformats::MCEventHeader' object";
+    return kFALSE;
   }
+  updateHeader(o2header);
+  updateSubGeneratorInformation(o2header);
 
-  /*****************************************************************/
+  /** success **/
+  return kTRUE;
+}
 
-  Bool_t
-    Generator::addTracks(FairPrimaryGenerator * primGen)
-  {
-    /** add tracks **/
+/*****************************************************************/
 
-    auto o2primGen = dynamic_cast<PrimaryGenerator*>(primGen);
-    if (!o2primGen) {
-      LOG(fatal) << "PrimaryGenerator is not a o2::eventgen::PrimaryGenerator";
-      return kFALSE;
-    }
+Bool_t
+  Generator::addTracks(FairPrimaryGenerator* primGen)
+{
+  /** add tracks **/
 
-    /** loop over particles **/
-    for (const auto& particle : mParticles) {
-      o2primGen->AddTrack(particle.GetPdgCode(),
-                          particle.Px() * mMomentumUnit,
-                          particle.Py() * mMomentumUnit,
-                          particle.Pz() * mMomentumUnit,
-                          particle.Vx() * mPositionUnit,
-                          particle.Vy() * mPositionUnit,
-                          particle.Vz() * mPositionUnit,
-                          particle.GetMother(0),
-                          particle.GetMother(1),
-                          particle.GetDaughter(0),
-                          particle.GetDaughter(1),
-                          particle.TestBit(ParticleStatus::kToBeDone),
-                          particle.Energy() * mEnergyUnit,
-                          particle.T() * mTimeUnit,
-                          particle.GetWeight(),
-                          (TMCProcess)particle.GetUniqueID(),
-                          particle.GetStatusCode()); // generator status information passed as status code field
-    }
+  auto o2primGen = dynamic_cast<PrimaryGenerator*>(primGen);
+  if (!o2primGen) {
+    LOG(fatal) << "PrimaryGenerator is not a o2::eventgen::PrimaryGenerator";
+    return kFALSE;
+  }
 
-    /** success **/
-    return kTRUE;
+  /** loop over particles **/
+  for (const auto& particle : mParticles) {
+    o2primGen->AddTrack(particle.GetPdgCode(),
+                        particle.Px() * mMomentumUnit,
+                        particle.Py() * mMomentumUnit,
+                        particle.Pz() * mMomentumUnit,
+                        particle.Vx() * mPositionUnit,
+                        particle.Vy() * mPositionUnit,
+                        particle.Vz() * mPositionUnit,
+                        particle.GetMother(0),
+                        particle.GetMother(1),
+                        particle.GetDaughter(0),
+                        particle.GetDaughter(1),
+                        particle.TestBit(ParticleStatus::kToBeDone),
+                        particle.Energy() * mEnergyUnit,
+                        particle.T() * mTimeUnit,
+                        particle.GetWeight(),
+                        (TMCProcess)particle.GetUniqueID(),
+                        particle.GetStatusCode()); // generator status information passed as status code field
   }
 
-  /*****************************************************************/
+  /** success **/
+  return kTRUE;
+}
+
+/*****************************************************************/
 
-  Bool_t
-    Generator::boostEvent()
-  {
-    /** boost event **/
+Bool_t
+  Generator::boostEvent()
+{
+  /** boost event **/
+
+  /** success **/
+  return kTRUE;
+}
+
+/*****************************************************************/
+
+Bool_t
+  Generator::triggerEvent()
+{
+  /** trigger event **/
 
-    /** success **/
+  /** check trigger presence **/
+  if (mTriggers.size() == 0 && mDeepTriggers.size() == 0) {
     return kTRUE;
   }
 
-  /*****************************************************************/
-
-  Bool_t
-    Generator::triggerEvent()
-  {
-    /** trigger event **/
+  /** check trigger mode **/
+  Bool_t triggered;
+  if (mTriggerMode == kTriggerOFF) {
+    return kTRUE;
+  } else if (mTriggerMode == kTriggerOR) {
+    triggered = kFALSE;
+  } else if (mTriggerMode == kTriggerAND) {
+    triggered = kTRUE;
+  } else {
+    return kTRUE;
+  }
 
-    /** check trigger presence **/
-    if (mTriggers.size() == 0 && mDeepTriggers.size() == 0) {
-      return kTRUE;
+  /** loop over triggers **/
+  for (const auto& trigger : mTriggers) {
+    auto retval = trigger(mParticles);
+    if (mTriggerMode == kTriggerOR) {
+      triggered |= retval;
     }
-
-    /** check trigger mode **/
-    Bool_t triggered;
-    if (mTriggerMode == kTriggerOFF) {
-      return kTRUE;
-    } else if (mTriggerMode == kTriggerOR) {
-      triggered = kFALSE;
-    } else if (mTriggerMode == kTriggerAND) {
-      triggered = kTRUE;
-    } else {
-      return kTRUE;
+    if (mTriggerMode == kTriggerAND) {
+      triggered &= retval;
     }
+  }
 
-    /** loop over triggers **/
-    for (const auto& trigger : mTriggers) {
-      auto retval = trigger(mParticles);
-      if (mTriggerMode == kTriggerOR) {
-        triggered |= retval;
-      }
-      if (mTriggerMode == kTriggerAND) {
-        triggered &= retval;
-      }
+  /** loop over deep triggers **/
+  for (const auto& trigger : mDeepTriggers) {
+    auto retval = trigger(mInterface, mInterfaceName);
+    if (mTriggerMode == kTriggerOR) {
+      triggered |= retval;
     }
-
-    /** loop over deep triggers **/
-    for (const auto& trigger : mDeepTriggers) {
-      auto retval = trigger(mInterface, mInterfaceName);
-      if (mTriggerMode == kTriggerOR) {
-        triggered |= retval;
-      }
-      if (mTriggerMode == kTriggerAND) {
-        triggered &= retval;
-      }
+    if (mTriggerMode == kTriggerAND) {
+      triggered &= retval;
     }
-
-    /** return **/
-    return triggered;
   }
 
-  /*****************************************************************/
+  /** return **/
+  return triggered;
+}
 
-  void Generator::addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription)
-  {
-    if (subGeneratorId < 0) {
-      LOG(fatal) << "Sub-generator IDs must be >= 0, instead, passed value is " << subGeneratorId;
-    }
-    mSubGeneratorsIdToDesc.insert({subGeneratorId, subGeneratorDescription});
+/*****************************************************************/
+
+void Generator::addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription)
+{
+  if (subGeneratorId < 0) {
+    LOG(fatal) << "Sub-generator IDs must be >= 0, instead, passed value is " << subGeneratorId;
   }
+  mSubGeneratorsIdToDesc.insert({subGeneratorId, subGeneratorDescription});
+}
 
-  /*****************************************************************/
+/*****************************************************************/
 
-  void Generator::updateSubGeneratorInformation(o2::dataformats::MCEventHeader * header) const
-  {
-    if (mSubGeneratorId < 0) {
-      return;
-    }
-    header->putInfo<int>(o2::mcgenid::GeneratorProperty::SUBGENERATORID, mSubGeneratorId);
-    header->putInfo<std::unordered_map<int, std::string>>(o2::mcgenid::GeneratorProperty::SUBGENERATORDESCRIPTIONMAP, mSubGeneratorsIdToDesc);
+void Generator::updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const
+{
+  if (mSubGeneratorId < 0) {
+    return;
   }
+  header->putInfo<int>(o2::mcgenid::GeneratorProperty::SUBGENERATORID, mSubGeneratorId);
+  header->putInfo<std::unordered_map<int, std::string>>(o2::mcgenid::GeneratorProperty::SUBGENERATORDESCRIPTIONMAP, mSubGeneratorsIdToDesc);
+}
 
-  /*****************************************************************/
-  /*****************************************************************/
+/*****************************************************************/
+/*****************************************************************/
 
 } /* namespace eventgen */
 } /* namespace o2 */
diff --git a/Generators/src/GeneratorsLinkDef.h b/Generators/src/GeneratorsLinkDef.h
index 97896d8225042..24b3f2e452498 100644
--- a/Generators/src/GeneratorsLinkDef.h
+++ b/Generators/src/GeneratorsLinkDef.h
@@ -35,7 +35,7 @@
 #pragma link C++ class o2::eventgen::GeneratorFromEventPool + ;
 #pragma link C++ class o2::eventgen::GeneratorEventPoolParam + ;
 #pragma link C++ class o2::eventgen::EventPoolGenConfig + ;
-#ifdef GENERATORS_WITH_ONNXRUNTIME
+#ifdef GENERATORS_WITH_TPCLOOPERS
 #pragma link C++ class o2::eventgen::GenTPCLoopers + ;
 #pragma link C++ class o2::eventgen::GenTPCLoopersParam + ;
 #endif
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 4eacb7674599c..109461ab71dfa 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -382,9 +382,6 @@ void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number)
       if (mInteractionTimeRecords.empty()) {
         LOG(error) << "Error: No interaction time records found in the collision context!";
         exit(1);
-      } else {
-        LOG(info) << "Interaction Time records has " << mInteractionTimeRecords.size() << " entries.";
-        mCollisionContext->printCollisionSummary();
       }
       for (int c = 0; c < mInteractionTimeRecords.size() - 1; c++) {
         mIntTimeRecMean += mInteractionTimeRecords[c + 1].bc2ns() - mInteractionTimeRecords[c].bc2ns();

From 8f8606a66c8499de6df999795d595f3dbab9e5b3 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Sun, 12 Oct 2025 17:24:31 +0200
Subject: [PATCH 1156/1764] Vetoing loopers for FlatGas and \!collisioncontext

---
 Generators/include/Generators/Generator.h |  2 +-
 Generators/src/Generator.cxx              | 21 ++++++++++++++++-----
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 4b68112517893..67277e20736ce 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -173,7 +173,7 @@ class Generator : public FairGenerator
 #ifdef GENERATORS_WITH_TPCLOOPERS
   // Loopers generator instance
   std::unique_ptr<o2::eventgen::GenTPCLoopers> mLoopersGen = nullptr;
-  void initLoopersGen();
+  bool initLoopersGen();
 #endif
 
   ClassDefOverride(Generator, 2);
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 6fc9f378148d3..50b11c0c7bb53 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -50,8 +50,9 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        mAddTPCLoopers = kTRUE;
-        initLoopersGen();
+        if(initLoopersGen()){
+          mAddTPCLoopers = kTRUE;
+        }
       }
     }
   }
@@ -74,8 +75,9 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        mAddTPCLoopers = kTRUE;
-        initLoopersGen();
+        if (initLoopersGen()) {
+          mAddTPCLoopers = kTRUE;
+        }
       }
     }
   }
@@ -84,7 +86,7 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
 
 /*****************************************************************/
 #ifdef GENERATORS_WITH_TPCLOOPERS
-void Generator::initLoopersGen()
+bool Generator::initLoopersGen()
 {
   // Expand all environment paths
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
@@ -95,6 +97,14 @@ void Generator::initLoopersGen()
   const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
   const auto& gauss = gSystem->ExpandPathName(loopersParam.gauss.c_str());
   auto flat_gas = loopersParam.flat_gas;
+  if (flat_gas) {
+    bool isContext = std::filesystem::exists("collisioncontext.root");
+    if (!isContext) {
+      LOG(warning) << "Warning: No collisioncontext.root file found!";
+      LOG(warning) << "Loopers will be kept OFF.";
+      return kFALSE;
+    }
+  }
   const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
   auto fraction_pairs = loopersParam.fraction_pairs;
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
@@ -163,6 +173,7 @@ void Generator::initLoopersGen()
     LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
     mLoopersGen.reset();
   }
+  return kTRUE;
 }
 #endif
 

From 32c0f318ec9737e7c1718c373d3c9660ddff477c Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 24 Oct 2025 16:42:27 +0200
Subject: [PATCH 1157/1764] Implemented rate and collision system dependence
 (default)

---
 .../include/Generators/TPCLoopersParam.h      |  4 ++
 Generators/include/TPCLoopers.h               |  8 ++-
 Generators/src/Generator.cxx                  | 28 +++++---
 Generators/src/TPCLoopers.cxx                 | 64 ++++++++++++++++---
 4 files changed, 87 insertions(+), 17 deletions(-)

diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 9430f4e05ac6e..8571013cdec48 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -35,11 +35,15 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv"; // file with Gaussian parameters
   std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json"; // file with scaler parameters for e+e- pair production
   std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
+  std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
+  std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
+  int intrate = 50000;                                                                          // interaction rate
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
   int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
   float fraction_pairs = 0.08; // fraction of loopers
   float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
   unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  float adjust_flatgas = 0.f; // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 1c1f3585eb3ab..265581b5f885d 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -17,6 +17,7 @@
 #include <SimulationDataFormat/ParticleStatus.h>
 #include "SimulationDataFormat/MCGenProperties.h"
 #include "TParticle.h"
+#include "TF1.h"
 #include <filesystem>
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
@@ -82,10 +83,14 @@ class GenTPCLoopers
 
         void SetMultiplier(std::array<float, 2> &mult);
 
-        void setFlatGas(Bool_t &flat, const Int_t &number = -1);
+        void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
 
         void setFractionPairs(float &fractionPairs);
 
+        void SetRate(const std::string &rateFile, const bool &isPbPb, const int &intRate);
+
+        void SetAdjust(const float &adjust);
+
     private:
         std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
         std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
@@ -111,6 +116,7 @@ class GenTPCLoopers
         o2::steer::DigitizationContext *mCollisionContext = nullptr;    // Pointer to the digitization context
         std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
         Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
+        Bool_t mFlatGasOrbit = false;                                   // Flag to indicate if flat gas loopers are per orbit
         Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
         double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
         double mTimeLimit = 0.0;                                        // Time limit for the current event
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 50b11c0c7bb53..fea1a38f1a146 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -92,6 +92,7 @@ bool Generator::initLoopersGen()
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
   std::string model_pairs = gSystem->ExpandPathName(loopersParam.model_pairs.c_str());
   std::string model_compton = gSystem->ExpandPathName(loopersParam.model_compton.c_str());
+  std::string nclxrate = gSystem->ExpandPathName(loopersParam.nclxrate.c_str());
   const auto& scaler_pair = gSystem->ExpandPathName(loopersParam.scaler_pair.c_str());
   const auto& scaler_compton = gSystem->ExpandPathName(loopersParam.scaler_compton.c_str());
   const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
@@ -110,10 +111,10 @@ bool Generator::initLoopersGen()
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
   unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
   unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
-  const std::array<std::string, 2> models = {model_pairs, model_compton};
-  const std::array<std::string, 2> local_names = {"WGANpair.onnx", "WGANcompton.onnx"};
-  const std::array<bool, 2> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://")};
-  const std::array<bool, 2> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://")};
+  const std::array<std::string, 3> models = {model_pairs, model_compton, nclxrate};
+  const std::array<std::string, 3> local_names = {"WGANpair.onnx", "WGANcompton.onnx", "nclxrate.root"};
+  const std::array<bool, 3> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://"), models[2].starts_with("alien://")};
+  const std::array<bool, 3> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://"), models[2].starts_with("ccdb://")};
   if (std::any_of(isAlien.begin(), isAlien.end(), [](bool v) { return v; })) {
     if (!gGrid) {
       TGrid::Connect("alien://");
@@ -153,14 +154,25 @@ bool Generator::initLoopersGen()
   }
   model_pairs = isAlien[0] || isCCDB[0] ? local_names[0] : model_pairs;
   model_compton = isAlien[1] || isCCDB[1] ? local_names[1] : model_compton;
+  nclxrate = isAlien[2] || isCCDB[2] ? local_names[2] : nclxrate;
   try {
     // Create the TPC loopers generator with the provided parameters
     mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
-
-    // Configure the generator with flat gas loopers if enabled (default)
+    auto& colsys = loopersParam.colsys;
+    auto &intrate = loopersParam.intrate;
+    // Configure the generator with flat gas loopers defined per orbit with clusters/track info
     if (flat_gas) {
-      mLoopersGen->setFlatGas(flat_gas, nFlatGasLoopers);
-      mLoopersGen->setFractionPairs(fraction_pairs);
+      if (colsys != "PbPb" && colsys != "pp") {
+        LOG(fatal) << "Error: collision system must be either 'PbPb' or 'pp'";
+        exit(1);
+      } else {
+        if (intrate <= 0) {
+          LOG(fatal) << "Error: interaction rate must be positive!";
+          exit(1);
+        }
+        mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
+        mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
+      }
     } else {
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
       // Multiplier is applied only with distribution sampling
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 109461ab71dfa..b771b53ed33d2 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -197,7 +197,8 @@ Bool_t GenTPCLoopers::generateEvent()
     LOG(debug) << "Current time offset wrt BC: " << mInteractionTimeRecords[mCurrentEvent].getTimeOffsetWrtBC() << " ns";
     mTimeLimit = (mCurrentEvent < mInteractionTimeRecords.size() - 1) ? mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns() : mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns();
     // With flat gas the number of loopers are adapted based on time interval widths
-    nLoopers = mFlatGasNumber * (mTimeLimit / mIntTimeRecMean);
+    // The denominator is either the LHC orbit (if mFlatGasOrbit is true) or the mean interaction time record interval
+    nLoopers = mFlatGasOrbit ? (mFlatGasNumber * (mTimeLimit / o2::constants::lhc::LHCOrbitNS)) : (mFlatGasNumber * (mTimeLimit / mIntTimeRecMean));
     nLoopersPairs = static_cast<unsigned int>(std::round(nLoopers * mLoopsFractionPairs));
     nLoopersCompton = nLoopers - nLoopersPairs;
     SetNLoopers(nLoopersPairs, nLoopersCompton);
@@ -366,22 +367,34 @@ void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
     }
 }
 
-void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number)
+void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int_t& nloopers_orbit = -1)
 {
   mFlatGas = flat;
   if (mFlatGas) {
-    if (number < 0) {
-      LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
-      mFlatGas = false;
-      mFlatGasNumber = -1;
+    if (nloopers_orbit > 0) {
+      mFlatGasOrbit = true;
+      mFlatGasNumber = nloopers_orbit;
+      LOG(info) << "Flat gas loopers will be generated using orbit reference.";
     } else {
-      mFlatGasNumber = number;
+      mFlatGasOrbit = false;
+      if (number < 0) {
+        LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
+        mFlatGas = false;
+        mFlatGasNumber = -1;
+      } else {
+        mFlatGasNumber = number;
+      }
+    }
+    if (mFlatGas) {
       mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
       mCollisionContext = mContextFile ? (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext") : nullptr;
       mInteractionTimeRecords = mCollisionContext ? mCollisionContext->getEventRecords() : std::vector<o2::InteractionTimeRecord>{};
       if (mInteractionTimeRecords.empty()) {
         LOG(error) << "Error: No interaction time records found in the collision context!";
         exit(1);
+      } else {
+        LOG(info) << "Interaction Time records has " << mInteractionTimeRecords.size() << " entries.";
+        mCollisionContext->printCollisionSummary();
       }
       for (int c = 0; c < mInteractionTimeRecords.size() - 1; c++) {
         mIntTimeRecMean += mInteractionTimeRecords[c + 1].bc2ns() - mInteractionTimeRecords[c].bc2ns();
@@ -397,7 +410,7 @@ void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number)
   } else {
     mFlatGasNumber = -1;
   }
-  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per event: " << mFlatGasNumber;
+  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per " << (mFlatGasOrbit ? "orbit " : "event ") << mFlatGasNumber;
 }
 
 void GenTPCLoopers::setFractionPairs(float& fractionPairs)
@@ -410,5 +423,40 @@ void GenTPCLoopers::setFractionPairs(float& fractionPairs)
   LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
 }
 
+void GenTPCLoopers::SetRate(const std::string &rateFile, const bool &isPbPb = true, const int &intRate = 50000)
+{
+  // Checking if the rate file exists and is not empty
+  TFile rate_file(rateFile.c_str(), "READ");
+  if (!rate_file.IsOpen() || rate_file.IsZombie()) {
+    LOG(fatal) << "Error: Rate file is empty or does not exist!";
+    exit(1);
+  }
+  const char* fitName = isPbPb ? "fitPbPb" : "fitpp";
+  auto fit = (TF1*)rate_file.Get(fitName);
+  if (!fit) {
+    LOG(fatal) << "Error: Could not find fit function '" << fitName << "' in rate file!";
+    exit(1);
+  }
+  auto ref = static_cast<int>(std::floor(fit->Eval(intRate / 1000.))); // fit expects rate in kHz
+  rate_file.Close();
+  if (ref <= 0) {
+    LOG(fatal) << "Computed flat gas number reference per orbit is <=0";
+    exit(1);
+  } else {
+    LOG(info) << "Set flat gas number to " << ref << " loopers per orbit using " << fitName << " from " << intRate << " Hz interaction rate.";
+    auto flat = true;
+    setFlatGas(flat, -1, ref);
+  }
+}
+
+void GenTPCLoopers::SetAdjust(const float& adjust = 0.f)
+{
+  if (mFlatGas && mFlatGasOrbit && adjust >= -1.f && adjust != 0.f) {
+    LOG(info) << "Adjusting flat gas number per orbit by " << adjust * 100.f << "%";
+    mFlatGasNumber = static_cast<int>(std::round(mFlatGasNumber * (1.f + adjust)));
+    LOG(info) << "New flat gas number per orbit: " << mFlatGasNumber;
+  }
+}
+
 } // namespace eventgen
 } // namespace o2
\ No newline at end of file

From a6f60e12edf933dbeb724b9ba7c51a4c5e49cffc Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Thu, 20 Nov 2025 22:40:33 +0100
Subject: [PATCH 1158/1764] Set automatic interaction rate from collision
 context

---
 .../include/Generators/TPCLoopersParam.h      |  4 ++--
 Generators/include/TPCLoopers.h               |  3 +++
 Generators/src/Generator.cxx                  | 10 +++++-----
 Generators/src/TPCLoopers.cxx                 | 19 +++++++++++++++++--
 4 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 8571013cdec48..74c3cf4cff0ad 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -37,9 +37,9 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
   std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
   std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
-  int intrate = 50000;                                                                          // interaction rate
+  int intrate = -1;                                                                             // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
-  int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
+  unsigned int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
   float fraction_pairs = 0.08; // fraction of loopers
   float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
   unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 265581b5f885d..8a4dc0030aa21 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -91,6 +91,8 @@ class GenTPCLoopers
 
         void SetAdjust(const float &adjust);
 
+        unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
+
     private:
         std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
         std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
@@ -122,6 +124,7 @@ class GenTPCLoopers
         double mTimeLimit = 0.0;                                        // Time limit for the current event
         double mTimeEnd = 0.0;                                          // Time limit for the last event
         float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
+        int mInteractionRate = 50000;                                   // Interaction rate in Hz
 };
 #endif // GENERATORS_WITH_TPCLOOPERS
 
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index fea1a38f1a146..18e28e4cc2668 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -107,7 +107,7 @@ bool Generator::initLoopersGen()
     }
   }
   const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
-  auto fraction_pairs = loopersParam.fraction_pairs;
+  const auto& fraction_pairs = loopersParam.fraction_pairs;
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
   unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
   unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
@@ -166,10 +166,6 @@ bool Generator::initLoopersGen()
         LOG(fatal) << "Error: collision system must be either 'PbPb' or 'pp'";
         exit(1);
       } else {
-        if (intrate <= 0) {
-          LOG(fatal) << "Error: interaction rate must be positive!";
-          exit(1);
-        }
         mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
         mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
       }
@@ -217,6 +213,10 @@ Bool_t
       LOG(error) << "Failed to generate loopers event";
       return kFALSE;
     }
+    if (mLoopersGen->getNLoopers() == 0) {
+      LOG(warning) << "No loopers generated for this event";
+      return kTRUE;
+    }
     const auto& looperParticles = mLoopersGen->importParticles();
     if (looperParticles.empty()) {
       LOG(error) << "Failed to import loopers particles";
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index b771b53ed33d2..0fb76fcd8c3a9 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -437,13 +437,28 @@ void GenTPCLoopers::SetRate(const std::string &rateFile, const bool &isPbPb = tr
     LOG(fatal) << "Error: Could not find fit function '" << fitName << "' in rate file!";
     exit(1);
   }
-  auto ref = static_cast<int>(std::floor(fit->Eval(intRate / 1000.))); // fit expects rate in kHz
+  mInteractionRate = intRate;
+  if (mInteractionRate < 0) {
+    mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
+    if (!mContextFile || mContextFile->IsZombie()) {
+      LOG(fatal) << "Error: Interaction rate not provided and collision context file not found!";
+      exit(1);
+    }
+    mCollisionContext = (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext");
+    mInteractionRate = std::floor(mCollisionContext->getDigitizerInteractionRate());
+    LOG(info) << "Interaction rate retrieved from collision context: " << mInteractionRate << " Hz";
+    if (mInteractionRate < 0) {
+      LOG(fatal) << "Error: Invalid interaction rate retrieved from collision context!";
+      exit(1);
+    }
+  }
+  auto ref = static_cast<int>(std::floor(fit->Eval(mInteractionRate / 1000.))); // fit expects rate in kHz
   rate_file.Close();
   if (ref <= 0) {
     LOG(fatal) << "Computed flat gas number reference per orbit is <=0";
     exit(1);
   } else {
-    LOG(info) << "Set flat gas number to " << ref << " loopers per orbit using " << fitName << " from " << intRate << " Hz interaction rate.";
+    LOG(info) << "Set flat gas number to " << ref << " loopers per orbit using " << fitName << " from " << mInteractionRate << " Hz interaction rate.";
     auto flat = true;
     setFlatGas(flat, -1, ref);
   }

From b48d4ec35cdb9252783a46916898d4bfbac928f3 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Mon, 24 Nov 2025 10:11:42 +0100
Subject: [PATCH 1159/1764] Fixed bug + cleaned code

---
 Generators/include/Generators/TPCLoopersParam.h | 4 ++--
 Generators/src/Generator.cxx                    | 4 +---
 Generators/src/TPCLoopers.cxx                   | 4 ----
 3 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 74c3cf4cff0ad..24d905c59c967 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -39,8 +39,8 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
   int intrate = -1;                                                                             // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
-  unsigned int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
-  float fraction_pairs = 0.08; // fraction of loopers
+  unsigned int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
+  float fraction_pairs = 0.08;         // fraction of loopers [currently unused, kept for possible future debug developments]
   float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
   unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
   float adjust_flatgas = 0.f; // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 18e28e4cc2668..9e083913c3bc7 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -106,8 +106,6 @@ bool Generator::initLoopersGen()
       return kFALSE;
     }
   }
-  const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
-  const auto& fraction_pairs = loopersParam.fraction_pairs;
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
   unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
   unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
@@ -170,7 +168,7 @@ bool Generator::initLoopersGen()
         mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
       }
     } else {
-      // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
+      // Otherwise, Poisson+Gauss sampling or fixed number of loopers per event will be used
       // Multiplier is applied only with distribution sampling
       // This configuration can be used for testing purposes, in all other cases flat gas is recommended
       mLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 0fb76fcd8c3a9..07af5b25f99f9 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -27,10 +27,6 @@ void Scaler::load(const std::string &filename)
   normal_max = jsonArrayToVector(doc["normal"]["max"]);
   outlier_center = jsonArrayToVector(doc["outlier"]["center"]);
   outlier_scale = jsonArrayToVector(doc["outlier"]["scale"]);
-  std::vector<double> normal_min;
-  std::vector<double> normal_max;
-  std::vector<double> outlier_center;
-  std::vector<double> outlier_scale;
 }  
 
 std::vector<double> Scaler::inverse_transform(const std::vector<double> &input)

From e7a790b31d71d01e91a2a40123327febda65905f Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Mon, 24 Nov 2025 20:22:39 +0100
Subject: [PATCH 1160/1764] Improved logging + colsys check

---
 Generators/src/Generator.cxx  | 31 ++++++++++++++++++++-----------
 Generators/src/TPCLoopers.cxx |  6 ++++--
 2 files changed, 24 insertions(+), 13 deletions(-)

diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 9e083913c3bc7..9c16c0dfb7e92 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -50,11 +50,15 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        if(initLoopersGen()){
+        if (initLoopersGen()) {
           mAddTPCLoopers = kTRUE;
         }
+      } else {
+        LOG(info) << "TPC not active in readout detectors: loopers fast generator disabled.";
       }
     }
+  } else {
+    LOG(info) << "Loopers fast generator turned OFF with veto flag.";
   }
 #endif
 }
@@ -78,8 +82,12 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
         if (initLoopersGen()) {
           mAddTPCLoopers = kTRUE;
         }
+      } else {
+        LOG(info) << "TPC not active in readout detectors: loopers fast generator disabled.";
       }
     }
+  } else {
+    LOG(info) << "Loopers fast generator turned OFF with veto flag.";
   }
 #endif
 }
@@ -97,8 +105,14 @@ bool Generator::initLoopersGen()
   const auto& scaler_compton = gSystem->ExpandPathName(loopersParam.scaler_compton.c_str());
   const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
   const auto& gauss = gSystem->ExpandPathName(loopersParam.gauss.c_str());
-  auto flat_gas = loopersParam.flat_gas;
+  const auto& flat_gas = loopersParam.flat_gas;
+  const auto& colsys = loopersParam.colsys;
   if (flat_gas) {
+    if (colsys != "PbPb" && colsys != "pp") {
+      LOG(warning) << "Automatic background loopers configuration supports only 'pp' and 'PbPb' systems.";
+      LOG(warning) << "Fast loopers generator will remain OFF.";
+      return kFALSE;
+    }
     bool isContext = std::filesystem::exists("collisioncontext.root");
     if (!isContext) {
       LOG(warning) << "Warning: No collisioncontext.root file found!";
@@ -156,17 +170,12 @@ bool Generator::initLoopersGen()
   try {
     // Create the TPC loopers generator with the provided parameters
     mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
-    auto& colsys = loopersParam.colsys;
-    auto &intrate = loopersParam.intrate;
+    const auto &intrate = loopersParam.intrate;
     // Configure the generator with flat gas loopers defined per orbit with clusters/track info
+    // If intrate is negative (default), automatic IR from collisioncontext.root will be used
     if (flat_gas) {
-      if (colsys != "PbPb" && colsys != "pp") {
-        LOG(fatal) << "Error: collision system must be either 'PbPb' or 'pp'";
-        exit(1);
-      } else {
-        mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
-        mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
-      }
+      mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
+      mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
     } else {
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers per event will be used
       // Multiplier is applied only with distribution sampling
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 07af5b25f99f9..ac1123b8d0bbd 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -141,7 +141,7 @@ GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
     scaler_file[0].close();
     scaler_file[1].close();
     // Checking if the poisson file exists and it's not empty
-    if (poisson != "")
+    if (poisson != "" && poisson != "None" && poisson != "none")
     {
         std::ifstream poisson_file(poisson);
         if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof())
@@ -157,7 +157,7 @@ GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
         }
     }
     // Checking if the gauss file exists and it's not empty
-    if (gauss != "")
+    if (gauss != "" && gauss != "None" && gauss != "none")
     {
         std::ifstream gauss_file(gauss);
         if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof())
@@ -205,9 +205,11 @@ Bool_t GenTPCLoopers::generateEvent()
     // Set number of loopers if poissonian params are available
     if (mPoissonSet) {
       mNLoopersPairs = static_cast<unsigned int>(std::round(mMultiplier[0] * PoissonPairs()));
+      LOG(debug) << "Generated loopers pairs (Poisson): " << mNLoopersPairs;
     }
     if (mGaussSet) {
       mNLoopersCompton = static_cast<unsigned int>(std::round(mMultiplier[1] * GaussianElectrons()));
+      LOG(debug) << "Generated compton electrons (Gauss): " << mNLoopersCompton;
     }
     // Generate pairs
     for (int i = 0; i < mNLoopersPairs; ++i) {

From 569255b67223793d520de38f90463bc2f8ca6917 Mon Sep 17 00:00:00 2001
From: ALICE Action Bot <alibuild@cern.ch>
Date: Tue, 25 Nov 2025 07:47:04 +0000
Subject: [PATCH 1161/1764] Please consider the following formatting changes

---
 Generators/include/Generators/Generator.h     |   2 +-
 .../include/Generators/TPCLoopersParam.h      |  24 +-
 Generators/include/TPCLoopers.h               | 155 ++++++-----
 .../share/egconfig/ScalerComptonParams.json   |  52 ++--
 .../share/egconfig/ScalerPairParams.json      |  64 ++---
 Generators/src/Generator.cxx                  |   6 +-
 Generators/src/TPCLoopers.cxx                 | 256 ++++++++----------
 7 files changed, 271 insertions(+), 288 deletions(-)

diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 67277e20736ce..5a4921e036ca3 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -161,7 +161,7 @@ class Generator : public FairGenerator
   void updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const;
 
   // loopers flag
-  Bool_t mAddTPCLoopers = kFALSE;  // Flag is automatically set to true if TPC is in readout detectors, loopers are not vetoed and transport is enabled
+  Bool_t mAddTPCLoopers = kFALSE; // Flag is automatically set to true if TPC is in readout detectors, loopers are not vetoed and transport is enabled
   // collect an ID and a short description of sub-generator entities
   std::unordered_map<int, std::string> mSubGeneratorsIdToDesc;
   // the current ID of the sub-generator used in the current event (if applicable)
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 24d905c59c967..49c8e5f5927b6 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -28,22 +28,22 @@ namespace eventgen
  ** allow the user to modify them
  **/
 struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
-  bool loopersVeto = false; // if true, no loopers are generated
-  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";  // ONNX model for e+e- pair production
-  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton"; // ONNX model for Compton scattering
-  std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv"; // file with Poissonian parameters
-  std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv"; // file with Gaussian parameters
-  std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json"; // file with scaler parameters for e+e- pair production
+  bool loopersVeto = false;                                                                     // if true, no loopers are generated
+  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";                          // ONNX model for e+e- pair production
+  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton";                     // ONNX model for Compton scattering
+  std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv";              // file with Poissonian parameters
+  std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv";               // file with Gaussian parameters
+  std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json";       // file with scaler parameters for e+e- pair production
   std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
   std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
   std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
   int intrate = -1;                                                                             // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
-  bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
-  unsigned int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
-  float fraction_pairs = 0.08;         // fraction of loopers [currently unused, kept for possible future debug developments]
-  float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
-  unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
-  float adjust_flatgas = 0.f; // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
+  bool flat_gas = true;                                                                         // if true, the gas density is considered flat in the TPC volume
+  unsigned int nFlatGasLoopers = 500;                                                           // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
+  float fraction_pairs = 0.08;                                                                  // fraction of loopers [currently unused, kept for possible future debug developments]
+  float multiplier[2] = {1., 1.};                                                               // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
+  unsigned int fixedNLoopers[2] = {1, 1};                                                       // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  float adjust_flatgas = 0.f;                                                                   // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 8a4dc0030aa21..9addcf844e09d 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -26,33 +26,32 @@ extern Ort::Env global_env;
 
 // This class is responsible for loading the scaler parameters from a JSON file
 // and applying the inverse transformation to the generated data.
-struct Scaler
-{
-    std::vector<double> normal_min;
-    std::vector<double> normal_max;
-    std::vector<double> outlier_center;
-    std::vector<double> outlier_scale;
+struct Scaler {
+  std::vector<double> normal_min;
+  std::vector<double> normal_max;
+  std::vector<double> outlier_center;
+  std::vector<double> outlier_scale;
 
-    void load(const std::string &filename);
+  void load(const std::string& filename);
 
-    std::vector<double> inverse_transform(const std::vector<double> &input);
+  std::vector<double> inverse_transform(const std::vector<double>& input);
 
-private:
-    std::vector<double> jsonArrayToVector(const rapidjson::Value &jsonArray);
+ private:
+  std::vector<double> jsonArrayToVector(const rapidjson::Value& jsonArray);
 };
 
 // This class loads the ONNX model and generates samples using it.
 class ONNXGenerator
 {
-public:
-    ONNXGenerator(Ort::Env &shared_env, const std::string &model_path);
+ public:
+  ONNXGenerator(Ort::Env& shared_env, const std::string& model_path);
 
-    std::vector<double> generate_sample();
+  std::vector<double> generate_sample();
 
-private:
-    Ort::Env &env;
-    Ort::Session session;
-    TRandom3 rand_gen;
+ private:
+  Ort::Env& env;
+  Ort::Session session;
+  TRandom3 rand_gen;
 };
 #endif // GENERATORS_WITH_TPCLOOPERS
 
@@ -64,67 +63,67 @@ namespace eventgen
 #ifdef GENERATORS_WITH_TPCLOOPERS
 class GenTPCLoopers
 {
-    public:
-        GenTPCLoopers(std::string model_pairs = "tpcloopmodel.onnx", std::string model_compton = "tpcloopmodelcompton.onnx",
-                      std::string poisson = "poisson.csv", std::string gauss = "gauss.csv", std::string scaler_pair = "scaler_pair.json",
-                      std::string scaler_compton = "scaler_compton.json");
-    
-        Bool_t generateEvent();
-
-        Bool_t generateEvent(double &time_limit);
-
-        std::vector<TParticle> importParticles();
-
-        unsigned int PoissonPairs();
-
-        unsigned int GaussianElectrons();
-
-        void SetNLoopers(unsigned int &nsig_pair, unsigned int &nsig_compton);
-
-        void SetMultiplier(std::array<float, 2> &mult);
-
-        void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
-
-        void setFractionPairs(float &fractionPairs);
-
-        void SetRate(const std::string &rateFile, const bool &isPbPb, const int &intRate);
-
-        void SetAdjust(const float &adjust);
-
-        unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
-
-    private:
-        std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
-        std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
-        std::unique_ptr<Scaler> mScaler_pair = nullptr;
-        std::unique_ptr<Scaler> mScaler_compton = nullptr;
-        double mPoisson[3] = {0.0, 0.0, 0.0}; // Mu, Min and Max of Poissonian
-        double mGauss[4] = {0.0, 0.0, 0.0, 0.0}; // Mean, Std, Min, Max
-        std::vector<std::vector<double>> mGenPairs;
-        std::vector<std::vector<double>> mGenElectrons;
-        unsigned int mNLoopersPairs = -1;
-        unsigned int mNLoopersCompton = -1;
-        std::array<float, 2> mMultiplier = {1., 1.};
-        bool mPoissonSet = false;
-        bool mGaussSet = false;
-        // Random number generator
-        TRandom3 mRandGen;
-        // Masses of the electrons and positrons
-        TDatabasePDG *mPDG = TDatabasePDG::Instance();
-        double mMass_e = mPDG->GetParticle(11)->Mass();
-        double mMass_p = mPDG->GetParticle(-11)->Mass();
-        int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
-        TFile *mContextFile = nullptr;                                  // Input collision context file
-        o2::steer::DigitizationContext *mCollisionContext = nullptr;    // Pointer to the digitization context
-        std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
-        Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
-        Bool_t mFlatGasOrbit = false;                                   // Flag to indicate if flat gas loopers are per orbit
-        Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
-        double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
-        double mTimeLimit = 0.0;                                        // Time limit for the current event
-        double mTimeEnd = 0.0;                                          // Time limit for the last event
-        float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
-        int mInteractionRate = 50000;                                   // Interaction rate in Hz
+ public:
+  GenTPCLoopers(std::string model_pairs = "tpcloopmodel.onnx", std::string model_compton = "tpcloopmodelcompton.onnx",
+                std::string poisson = "poisson.csv", std::string gauss = "gauss.csv", std::string scaler_pair = "scaler_pair.json",
+                std::string scaler_compton = "scaler_compton.json");
+
+  Bool_t generateEvent();
+
+  Bool_t generateEvent(double& time_limit);
+
+  std::vector<TParticle> importParticles();
+
+  unsigned int PoissonPairs();
+
+  unsigned int GaussianElectrons();
+
+  void SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_compton);
+
+  void SetMultiplier(std::array<float, 2>& mult);
+
+  void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
+
+  void setFractionPairs(float& fractionPairs);
+
+  void SetRate(const std::string& rateFile, const bool& isPbPb, const int& intRate);
+
+  void SetAdjust(const float& adjust);
+
+  unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
+
+ private:
+  std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
+  std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
+  std::unique_ptr<Scaler> mScaler_pair = nullptr;
+  std::unique_ptr<Scaler> mScaler_compton = nullptr;
+  double mPoisson[3] = {0.0, 0.0, 0.0};    // Mu, Min and Max of Poissonian
+  double mGauss[4] = {0.0, 0.0, 0.0, 0.0}; // Mean, Std, Min, Max
+  std::vector<std::vector<double>> mGenPairs;
+  std::vector<std::vector<double>> mGenElectrons;
+  unsigned int mNLoopersPairs = -1;
+  unsigned int mNLoopersCompton = -1;
+  std::array<float, 2> mMultiplier = {1., 1.};
+  bool mPoissonSet = false;
+  bool mGaussSet = false;
+  // Random number generator
+  TRandom3 mRandGen;
+  // Masses of the electrons and positrons
+  TDatabasePDG* mPDG = TDatabasePDG::Instance();
+  double mMass_e = mPDG->GetParticle(11)->Mass();
+  double mMass_p = mPDG->GetParticle(-11)->Mass();
+  int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
+  TFile* mContextFile = nullptr;                                  // Input collision context file
+  o2::steer::DigitizationContext* mCollisionContext = nullptr;    // Pointer to the digitization context
+  std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
+  Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
+  Bool_t mFlatGasOrbit = false;                                   // Flag to indicate if flat gas loopers are per orbit
+  Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
+  double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
+  double mTimeLimit = 0.0;                                        // Time limit for the current event
+  double mTimeEnd = 0.0;                                          // Time limit for the last event
+  float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
+  int mInteractionRate = 50000;                                   // Interaction rate in Hz
 };
 #endif // GENERATORS_WITH_TPCLOOPERS
 
diff --git a/Generators/share/egconfig/ScalerComptonParams.json b/Generators/share/egconfig/ScalerComptonParams.json
index d8e654847f46e..157647fee2db7 100644
--- a/Generators/share/egconfig/ScalerComptonParams.json
+++ b/Generators/share/egconfig/ScalerComptonParams.json
@@ -1,28 +1,28 @@
 {
-    "normal": {
-        "min": [
-            -0.0108811147511005,
-            -0.0098758740350604,
-            -0.0103233363479375,
-            -260.0542297363281,
-            -259.80059814453125
-        ],
-        "max": [
-            0.0108060473576188,
-            0.0103057539090514,
-            0.0106524610891938,
-            260.0343933105469,
-            259.62890625
-        ]
-    },
-    "outlier": {
-        "center": [
-            -71.39387130737305,
-            96791.23828125
-        ],
-        "scale": [
-            265.9389114379883,
-            230762.30981445312
-        ]
-    }
+  "normal": {
+    "min": [
+      -0.0108811147511005,
+      -0.0098758740350604,
+      -0.0103233363479375,
+      -260.0542297363281,
+      -259.80059814453125
+    ],
+    "max": [
+      0.0108060473576188,
+      0.0103057539090514,
+      0.0106524610891938,
+      260.0343933105469,
+      259.62890625
+    ]
+  },
+  "outlier": {
+    "center": [
+      -71.39387130737305,
+      96791.23828125
+    ],
+    "scale": [
+      265.9389114379883,
+      230762.30981445312
+    ]
+  }
 }
\ No newline at end of file
diff --git a/Generators/share/egconfig/ScalerPairParams.json b/Generators/share/egconfig/ScalerPairParams.json
index 61434bfa2462e..57cdac421d3f6 100644
--- a/Generators/share/egconfig/ScalerPairParams.json
+++ b/Generators/share/egconfig/ScalerPairParams.json
@@ -1,34 +1,34 @@
 {
-    "normal": {
-        "min": [
-            -0.0073022879660129,
-            -0.0077305701561272,
-            -0.0076750442385673,
-            -0.0082916170358657,
-            -0.0079681202769279,
-            -0.0077468422241508,
-            -255.6164093017578,
-            -252.9441680908203
-        ],
-        "max": [
-            0.007688719779253,
-            0.0077241472899913,
-            0.0075828479602932,
-            0.00813714787364,
-            0.0083825681358575,
-            0.0073839174583554,
-            256.2904968261719,
-            253.4925842285156
-        ]
-    },
-    "outlier": {
-        "center": [
-            -79.66580963134766,
-            141535.640625
-        ],
-        "scale": [
-            250.8921127319336,
-            222363.16015625
-        ]
-    }
+  "normal": {
+    "min": [
+      -0.0073022879660129,
+      -0.0077305701561272,
+      -0.0076750442385673,
+      -0.0082916170358657,
+      -0.0079681202769279,
+      -0.0077468422241508,
+      -255.6164093017578,
+      -252.9441680908203
+    ],
+    "max": [
+      0.007688719779253,
+      0.0077241472899913,
+      0.0075828479602932,
+      0.00813714787364,
+      0.0083825681358575,
+      0.0073839174583554,
+      256.2904968261719,
+      253.4925842285156
+    ]
+  },
+  "outlier": {
+    "center": [
+      -79.66580963134766,
+      141535.640625
+    ],
+    "scale": [
+      250.8921127319336,
+      222363.16015625
+    ]
+  }
 }
\ No newline at end of file
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 9c16c0dfb7e92..ce49254799587 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -170,7 +170,7 @@ bool Generator::initLoopersGen()
   try {
     // Create the TPC loopers generator with the provided parameters
     mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
-    const auto &intrate = loopersParam.intrate;
+    const auto& intrate = loopersParam.intrate;
     // Configure the generator with flat gas loopers defined per orbit with clusters/track info
     // If intrate is negative (default), automatic IR from collisioncontext.root will be used
     if (flat_gas) {
@@ -209,7 +209,7 @@ Bool_t
   Generator::finalizeEvent()
 {
 #ifdef GENERATORS_WITH_TPCLOOPERS
-  if(mAddTPCLoopers) {
+  if (mAddTPCLoopers) {
     if (!mLoopersGen) {
       LOG(error) << "Loopers generator not initialized";
       return kFALSE;
@@ -268,7 +268,7 @@ Bool_t
     }
 
     /** Event finalization**/
-    if(!finalizeEvent()) {
+    if (!finalizeEvent()) {
       LOG(error) << "ReadEvent failed in finalizeEvent";
       return kFALSE;
     }
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index ac1123b8d0bbd..258b6cce07b5b 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -6,7 +6,7 @@ Ort::Env global_env(ORT_LOGGING_LEVEL_WARNING, "GlobalEnv");
 // This class is responsible for loading the scaler parameters from a JSON file
 // and applying the inverse transformation to the generated data.
 
-void Scaler::load(const std::string &filename)
+void Scaler::load(const std::string& filename)
 {
   std::ifstream file(filename);
   if (!file.is_open()) {
@@ -27,76 +27,73 @@ void Scaler::load(const std::string &filename)
   normal_max = jsonArrayToVector(doc["normal"]["max"]);
   outlier_center = jsonArrayToVector(doc["outlier"]["center"]);
   outlier_scale = jsonArrayToVector(doc["outlier"]["scale"]);
-}  
+}
 
-std::vector<double> Scaler::inverse_transform(const std::vector<double> &input)
+std::vector<double> Scaler::inverse_transform(const std::vector<double>& input)
 {
-    std::vector<double> output;
-    for (int i = 0; i < input.size(); ++i)
-    {
-        if (i < input.size() - 2)
-            output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
-        else
-            output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
-    }
+  std::vector<double> output;
+  for (int i = 0; i < input.size(); ++i) {
+    if (i < input.size() - 2)
+      output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
+    else
+      output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
+  }
 
-    return output;
+  return output;
 }
 
-std::vector<double> Scaler::jsonArrayToVector(const rapidjson::Value &jsonArray)
+std::vector<double> Scaler::jsonArrayToVector(const rapidjson::Value& jsonArray)
 {
-    std::vector<double> vec;
-    for (int i = 0; i < jsonArray.Size(); ++i)
-    {
-        vec.push_back(jsonArray[i].GetDouble());
-    }
-    return vec;
+  std::vector<double> vec;
+  for (int i = 0; i < jsonArray.Size(); ++i) {
+    vec.push_back(jsonArray[i].GetDouble());
+  }
+  return vec;
 }
 
 // This class loads the ONNX model and generates samples using it.
 
 ONNXGenerator::ONNXGenerator(Ort::Env& shared_env, const std::string& model_path)
-: env(shared_env), session(env, model_path.c_str(), Ort::SessionOptions{})
+  : env(shared_env), session(env, model_path.c_str(), Ort::SessionOptions{})
 {
-    // Create session options
-    Ort::SessionOptions session_options;
-    session = Ort::Session(env, model_path.c_str(), session_options);
+  // Create session options
+  Ort::SessionOptions session_options;
+  session = Ort::Session(env, model_path.c_str(), session_options);
 }
 
 std::vector<double> ONNXGenerator::generate_sample()
 {
-    Ort::AllocatorWithDefaultOptions allocator;
-
-    // Generate a latent vector (z)
-    std::vector<float> z(100);
-    for (auto &v : z)
-        v = rand_gen.Gaus(0.0, 1.0);
-
-    // Prepare input tensor
-    std::vector<int64_t> input_shape = {1, 100};
-    // Get memory information
-    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-
-    // Create input tensor correctly
-    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
-        memory_info, z.data(), z.size(), input_shape.data(), input_shape.size());
-    // Run inference
-    const char *input_names[] = {"z"};
-    const char *output_names[] = {"output"};
-    auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, 1);
-
-    // Extract output
-    float *output_data = output_tensors.front().GetTensorMutableData<float>();
-    // Get the size of the output tensor
-    auto output_tensor_info = output_tensors.front().GetTensorTypeAndShapeInfo();
-    size_t output_data_size = output_tensor_info.GetElementCount(); // Total number of elements in the tensor
-    std::vector<double> output;
-    for (int i = 0; i < output_data_size; ++i)
-    {
-        output.push_back(output_data[i]);
-    }
+  Ort::AllocatorWithDefaultOptions allocator;
+
+  // Generate a latent vector (z)
+  std::vector<float> z(100);
+  for (auto& v : z)
+    v = rand_gen.Gaus(0.0, 1.0);
+
+  // Prepare input tensor
+  std::vector<int64_t> input_shape = {1, 100};
+  // Get memory information
+  Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+
+  // Create input tensor correctly
+  Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
+    memory_info, z.data(), z.size(), input_shape.data(), input_shape.size());
+  // Run inference
+  const char* input_names[] = {"z"};
+  const char* output_names[] = {"output"};
+  auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, 1);
+
+  // Extract output
+  float* output_data = output_tensors.front().GetTensorMutableData<float>();
+  // Get the size of the output tensor
+  auto output_tensor_info = output_tensors.front().GetTensorTypeAndShapeInfo();
+  size_t output_data_size = output_tensor_info.GetElementCount(); // Total number of elements in the tensor
+  std::vector<double> output;
+  for (int i = 0; i < output_data_size; ++i) {
+    output.push_back(output_data[i]);
+  }
 
-    return output;
+  return output;
 }
 
 namespace o2
@@ -105,79 +102,67 @@ namespace eventgen
 {
 
 GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
-                std::string poisson, std::string gauss, std::string scaler_pair,
-                std::string scaler_compton)
+                             std::string poisson, std::string gauss, std::string scaler_pair,
+                             std::string scaler_compton)
 {
-    // Checking if the model files exist and are not empty
-    std::ifstream model_file[2];
-    model_file[0].open(model_pairs);
-    model_file[1].open(model_compton);
-    if (!model_file[0].is_open() || model_file[0].peek() == std::ifstream::traits_type::eof())
-    {
-        LOG(fatal) << "Error: Pairs model file is empty or does not exist!";
-        exit(1);
-    }
-    if (!model_file[1].is_open() || model_file[1].peek() == std::ifstream::traits_type::eof())
-    {
-        LOG(fatal) << "Error: Compton model file is empty or does not exist!";
-        exit(1);
-    }
-    model_file[0].close();
-    model_file[1].close();
-    // Checking if the scaler files exist and are not empty
-    std::ifstream scaler_file[2];
-    scaler_file[0].open(scaler_pair);
-    scaler_file[1].open(scaler_compton);
-    if (!scaler_file[0].is_open() || scaler_file[0].peek() == std::ifstream::traits_type::eof())
-    {
-        LOG(fatal) << "Error: Pairs scaler file is empty or does not exist!";
-        exit(1);
-    }
-    if (!scaler_file[1].is_open() || scaler_file[1].peek() == std::ifstream::traits_type::eof())
-    {
-        LOG(fatal) << "Error: Compton scaler file is empty or does not exist!";
-        exit(1);
-    }
-    scaler_file[0].close();
-    scaler_file[1].close();
-    // Checking if the poisson file exists and it's not empty
-    if (poisson != "" && poisson != "None" && poisson != "none")
-    {
-        std::ifstream poisson_file(poisson);
-        if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof())
-        {
-            LOG(fatal) << "Error: Poisson file is empty or does not exist!";
-            exit(1);
-        }
-        else
-        {
-            poisson_file >> mPoisson[0] >> mPoisson[1] >> mPoisson[2];
-            poisson_file.close();
-            mPoissonSet = true;
-        }
+  // Checking if the model files exist and are not empty
+  std::ifstream model_file[2];
+  model_file[0].open(model_pairs);
+  model_file[1].open(model_compton);
+  if (!model_file[0].is_open() || model_file[0].peek() == std::ifstream::traits_type::eof()) {
+    LOG(fatal) << "Error: Pairs model file is empty or does not exist!";
+    exit(1);
+  }
+  if (!model_file[1].is_open() || model_file[1].peek() == std::ifstream::traits_type::eof()) {
+    LOG(fatal) << "Error: Compton model file is empty or does not exist!";
+    exit(1);
+  }
+  model_file[0].close();
+  model_file[1].close();
+  // Checking if the scaler files exist and are not empty
+  std::ifstream scaler_file[2];
+  scaler_file[0].open(scaler_pair);
+  scaler_file[1].open(scaler_compton);
+  if (!scaler_file[0].is_open() || scaler_file[0].peek() == std::ifstream::traits_type::eof()) {
+    LOG(fatal) << "Error: Pairs scaler file is empty or does not exist!";
+    exit(1);
+  }
+  if (!scaler_file[1].is_open() || scaler_file[1].peek() == std::ifstream::traits_type::eof()) {
+    LOG(fatal) << "Error: Compton scaler file is empty or does not exist!";
+    exit(1);
+  }
+  scaler_file[0].close();
+  scaler_file[1].close();
+  // Checking if the poisson file exists and it's not empty
+  if (poisson != "" && poisson != "None" && poisson != "none") {
+    std::ifstream poisson_file(poisson);
+    if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof()) {
+      LOG(fatal) << "Error: Poisson file is empty or does not exist!";
+      exit(1);
+    } else {
+      poisson_file >> mPoisson[0] >> mPoisson[1] >> mPoisson[2];
+      poisson_file.close();
+      mPoissonSet = true;
     }
-    // Checking if the gauss file exists and it's not empty
-    if (gauss != "" && gauss != "None" && gauss != "none")
-    {
-        std::ifstream gauss_file(gauss);
-        if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof())
-        {
-            LOG(fatal) << "Error: Gauss file is empty or does not exist!";
-            exit(1);
-        }
-        else
-        {
-            gauss_file >> mGauss[0] >> mGauss[1] >> mGauss[2] >> mGauss[3];
-            gauss_file.close();
-            mGaussSet = true;
-        }
+  }
+  // Checking if the gauss file exists and it's not empty
+  if (gauss != "" && gauss != "None" && gauss != "none") {
+    std::ifstream gauss_file(gauss);
+    if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof()) {
+      LOG(fatal) << "Error: Gauss file is empty or does not exist!";
+      exit(1);
+    } else {
+      gauss_file >> mGauss[0] >> mGauss[1] >> mGauss[2] >> mGauss[3];
+      gauss_file.close();
+      mGaussSet = true;
     }
-    mONNX_pair = std::make_unique<ONNXGenerator>(global_env, model_pairs);
-    mScaler_pair = std::make_unique<Scaler>();
-    mScaler_pair->load(scaler_pair);
-    mONNX_compton = std::make_unique<ONNXGenerator>(global_env, model_compton);
-    mScaler_compton = std::make_unique<Scaler>();
-    mScaler_compton->load(scaler_compton);
+  }
+  mONNX_pair = std::make_unique<ONNXGenerator>(global_env, model_pairs);
+  mScaler_pair = std::make_unique<Scaler>();
+  mScaler_pair->load(scaler_pair);
+  mONNX_compton = std::make_unique<ONNXGenerator>(global_env, model_compton);
+  mScaler_compton = std::make_unique<Scaler>();
+  mScaler_compton->load(scaler_compton);
 }
 
 Bool_t GenTPCLoopers::generateEvent()
@@ -352,17 +337,16 @@ void GenTPCLoopers::SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_comp
 
 void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
 {
-    // Multipliers will work only if the poissonian and gaussian parameters are set
-    // otherwise they will be ignored
-    if (mult[0] < 0 || mult[1] < 0)
-    {
-        LOG(fatal) << "Error: Multiplier values must be non-negative!";
-        exit(1);
-    } else {
-        LOG(info) << "Multiplier values set to: Pair = " << mult[0] << ", Compton = " << mult[1];
-        mMultiplier[0] = mult[0];
-        mMultiplier[1] = mult[1];
-    }
+  // Multipliers will work only if the poissonian and gaussian parameters are set
+  // otherwise they will be ignored
+  if (mult[0] < 0 || mult[1] < 0) {
+    LOG(fatal) << "Error: Multiplier values must be non-negative!";
+    exit(1);
+  } else {
+    LOG(info) << "Multiplier values set to: Pair = " << mult[0] << ", Compton = " << mult[1];
+    mMultiplier[0] = mult[0];
+    mMultiplier[1] = mult[1];
+  }
 }
 
 void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int_t& nloopers_orbit = -1)
@@ -421,7 +405,7 @@ void GenTPCLoopers::setFractionPairs(float& fractionPairs)
   LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
 }
 
-void GenTPCLoopers::SetRate(const std::string &rateFile, const bool &isPbPb = true, const int &intRate = 50000)
+void GenTPCLoopers::SetRate(const std::string& rateFile, const bool& isPbPb = true, const int& intRate = 50000)
 {
   // Checking if the rate file exists and is not empty
   TFile rate_file(rateFile.c_str(), "READ");

From 6837bccb95a137dd24d42d44fd4db5579ad3dbf9 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Tue, 25 Nov 2025 08:54:19 +0100
Subject: [PATCH 1162/1764] Add copyright headers

---
 Generators/include/TPCLoopers.h | 13 +++++++++++++
 Generators/src/TPCLoopers.cxx   | 13 +++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 9addcf844e09d..57d178667b497 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -1,3 +1,16 @@
+// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \author M+Giacalone - September 2025
+
 #ifndef ALICEO2_EVENTGEN_TPCLOOPERS_H_
 #define ALICEO2_EVENTGEN_TPCLOOPERS_H_
 
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 258b6cce07b5b..8dff795de40a3 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -1,3 +1,16 @@
+// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \author M+Giacalone - September 2025
+
 #include "Generators/TPCLoopers.h"
 
 // Static Ort::Env instance for multiple onnx model loading

From 1989aed2c6064aaec4d11dfaba2a08d101fed386 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Tue, 25 Nov 2025 12:55:13 +0100
Subject: [PATCH 1163/1764] Corrected include folder

---
 Generators/CMakeLists.txt                     | 19 ++---
 Generators/include/Generators/Generator.h     |  5 +-
 .../include/{ => Generators}/TPCLoopers.h     | 44 ++++++-----
 .../include/Generators/TPCLoopersParam.h      | 35 ++++----
 Generators/share/TPCLoopers/README.md         | 79 +++++++++++++++++++
 .../ScalerComptonParams.json                  |  0
 .../ScalerPairParams.json                     |  0
 .../gaussian_params.csv                       |  0
 .../poisson_params.csv                        |  0
 Generators/src/Generator.cxx                  | 28 ++++---
 Generators/src/TPCLoopers.cxx                 | 40 +++++++---
 11 files changed, 172 insertions(+), 78 deletions(-)
 rename Generators/include/{ => Generators}/TPCLoopers.h (71%)
 create mode 100644 Generators/share/TPCLoopers/README.md
 rename Generators/share/{egconfig => TPCLoopers}/ScalerComptonParams.json (100%)
 rename Generators/share/{egconfig => TPCLoopers}/ScalerPairParams.json (100%)
 rename Generators/share/{egconfig => TPCLoopers}/gaussian_params.csv (100%)
 rename Generators/share/{egconfig => TPCLoopers}/poisson_params.csv (100%)

diff --git a/Generators/CMakeLists.txt b/Generators/CMakeLists.txt
index f1921b8d8d72a..287536ff118f7 100644
--- a/Generators/CMakeLists.txt
+++ b/Generators/CMakeLists.txt
@@ -41,8 +41,8 @@ o2_add_library(Generators
                        src/GeneratorTParticleParam.cxx
                        src/GeneratorService.cxx
                        src/FlowMapper.cxx
-                       $<$<BOOL:${onnxruntime_FOUND}>:src/TPCLoopers.cxx>
-                       $<$<BOOL:${onnxruntime_FOUND}>:src/TPCLoopersParam.cxx>
+                       src/TPCLoopers.cxx
+                       src/TPCLoopersParam.cxx
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/DecayerPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8Param.cxx>
@@ -55,7 +55,7 @@ o2_add_library(Generators
                PUBLIC_LINK_LIBRARIES FairRoot::Base O2::SimConfig O2::CommonUtils O2::DetectorsBase O2::ZDCBase
                                      O2::SimulationDataFormat ${pythiaTarget} ${hepmcTarget}
                                      FairRoot::Gen
-                                     $<$<BOOL:${onnxruntime_FOUND}>:onnxruntime::onnxruntime>
+                                     onnxruntime::onnxruntime
                TARGETVARNAME targetName)
 
 if(pythia_FOUND)
@@ -66,9 +66,7 @@ if(HepMC3_FOUND)
   target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_HEPMC3)
 endif()
 
-if(onnxruntime_FOUND)
-  target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_TPCLOOPERS)
-endif()
+target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_TPCLOOPERS)
 
 set(headers
     include/Generators/Generator.h
@@ -95,11 +93,9 @@ set(headers
     include/Generators/FlowMapper.h
     )
 
-if(onnxruntime_FOUND)
-  list(APPEND headers
-              include/Generators/TPCLoopers.h
-              include/Generators/TPCLoopersParam.h)
-endif()
+list(APPEND headers
+            include/Generators/TPCLoopers.h
+            include/Generators/TPCLoopersParam.h)
 
 if(pythia_FOUND)
   list(APPEND headers
@@ -171,4 +167,5 @@ endif()
 
 o2_data_file(COPY share/external DESTINATION Generators)
 o2_data_file(COPY share/egconfig DESTINATION Generators)
+o2_data_file(COPY share/TPCLoopers DESTINATION Generators)
 o2_data_file(COPY share/pythia8 DESTINATION Generators)
diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 5a4921e036ca3..3484601aa42bb 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -17,7 +17,6 @@
 #include "FairGenerator.h"
 #include "TParticle.h"
 #include "Generators/Trigger.h"
-#include "CCDB/BasicCCDBManager.h"
 #ifdef GENERATORS_WITH_TPCLOOPERS
 #include "Generators/TPCLoopers.h"
 #include "Generators/TPCLoopersParam.h"
@@ -172,8 +171,8 @@ class Generator : public FairGenerator
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
   // Loopers generator instance
-  std::unique_ptr<o2::eventgen::GenTPCLoopers> mLoopersGen = nullptr;
-  bool initLoopersGen();
+  std::unique_ptr<o2::eventgen::GenTPCLoopers> mTPCLoopersGen = nullptr;
+  bool initTPCLoopersGen();
 #endif
 
   ClassDefOverride(Generator, 2);
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/Generators/TPCLoopers.h
similarity index 71%
rename from Generators/include/TPCLoopers.h
rename to Generators/include/Generators/TPCLoopers.h
index 57d178667b497..6a1d3ef262e22 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/Generators/TPCLoopers.h
@@ -17,21 +17,11 @@
 #ifdef GENERATORS_WITH_TPCLOOPERS
 #include <onnxruntime_cxx_api.h>
 #endif
-#include <iostream>
 #include <vector>
-#include <fstream>
 #include <rapidjson/document.h>
-#include "CCDB/CCDBTimeStampUtils.h"
-#include "CCDB/CcdbApi.h"
-#include "DetectorsRaw/HBFUtils.h"
 #include "TRandom3.h"
-#include "TDatabasePDG.h"
 #include <SimulationDataFormat/DigitizationContext.h>
-#include <SimulationDataFormat/ParticleStatus.h>
-#include "SimulationDataFormat/MCGenProperties.h"
 #include "TParticle.h"
-#include "TF1.h"
-#include <filesystem>
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
 // Static Ort::Env instance for multiple onnx model loading
@@ -39,6 +29,8 @@ extern Ort::Env global_env;
 
 // This class is responsible for loading the scaler parameters from a JSON file
 // and applying the inverse transformation to the generated data.
+// Inferenced output is scaled (min-max normalization or robust scaling for outlier features) during training,
+// so we need to revert this transformation to get physical values.
 struct Scaler {
   std::vector<double> normal_min;
   std::vector<double> normal_max;
@@ -74,6 +66,20 @@ namespace eventgen
 {
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
+/**
+ * Generator for TPC Loopers based on pre-trained ONNX models.
+ * Currently it generates loopers as electron-positron pairs and Compton electrons
+ * according to specified distributions and parameters.
+ * This can be extended to other types of background processes in the future (e.g. slow neutron spallation products, saturation tail).
+ * Multiple configuration options are available:
+ * - Flat gas: loopers are generated uniformly per event taking a reference value which can be either the LHC orbit time or the average interaction time record interval from the collision context.
+ *   ==> Current automatic setup (default) sets the interaction rate automatically from the collision context and the reference value per orbit is calculated from an external file.
+ *   ==> Number of loopers per orbit can be adjusted via a specific parameter.
+ * - Poisson + Gaussian sampling: number of loopers are sampled from Poissonian (for pairs) and Gaussian (for Compton electrons) distributions based on provided parameters.
+ *   ==> flat gas must be disabled to use this option.
+ * - Fixed number of loopers per event
+ *   ==> flat gas must be disabled to use this option and Poissonian/Gaussian parameters file should be set to None
+ */
 class GenTPCLoopers
 {
  public:
@@ -83,7 +89,7 @@ class GenTPCLoopers
 
   Bool_t generateEvent();
 
-  Bool_t generateEvent(double& time_limit);
+  Bool_t generateEvent(double time_limit);
 
   std::vector<TParticle> importParticles();
 
@@ -91,17 +97,17 @@ class GenTPCLoopers
 
   unsigned int GaussianElectrons();
 
-  void SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_compton);
+  void SetNLoopers(unsigned int nsig_pair, unsigned int nsig_compton);
 
-  void SetMultiplier(std::array<float, 2>& mult);
+  void SetMultiplier(const std::array<float, 2>& mult);
 
-  void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
+  void setFlatGas(Bool_t flat, Int_t number = -1, Int_t nloopers_orbit = -1);
 
-  void setFractionPairs(float& fractionPairs);
+  void setFractionPairs(float fractionPairs);
 
-  void SetRate(const std::string& rateFile, const bool& isPbPb, const int& intRate);
+  void SetRate(const std::string& rateFile, bool isPbPb, int intRate = 50000);
 
-  void SetAdjust(const float& adjust);
+  void SetAdjust(float adjust = 0.f);
 
   unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
 
@@ -121,10 +127,6 @@ class GenTPCLoopers
   bool mGaussSet = false;
   // Random number generator
   TRandom3 mRandGen;
-  // Masses of the electrons and positrons
-  TDatabasePDG* mPDG = TDatabasePDG::Instance();
-  double mMass_e = mPDG->GetParticle(11)->Mass();
-  double mMass_p = mPDG->GetParticle(-11)->Mass();
   int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
   TFile* mContextFile = nullptr;                                  // Input collision context file
   o2::steer::DigitizationContext* mCollisionContext = nullptr;    // Pointer to the digitization context
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 49c8e5f5927b6..87e4510d6e617 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -24,26 +24,27 @@ namespace eventgen
 
 /**
  ** a parameter class/struct to keep the settings of
- ** the tpc loopers event-generator and
+ ** the TPC loopers event-generator and
  ** allow the user to modify them
  **/
 struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
-  bool loopersVeto = false;                                                                     // if true, no loopers are generated
-  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";                          // ONNX model for e+e- pair production
-  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton";                     // ONNX model for Compton scattering
-  std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv";              // file with Poissonian parameters
-  std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv";               // file with Gaussian parameters
-  std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json";       // file with scaler parameters for e+e- pair production
-  std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
-  std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
-  std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
-  int intrate = -1;                                                                             // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
-  bool flat_gas = true;                                                                         // if true, the gas density is considered flat in the TPC volume
-  unsigned int nFlatGasLoopers = 500;                                                           // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
-  float fraction_pairs = 0.08;                                                                  // fraction of loopers [currently unused, kept for possible future debug developments]
-  float multiplier[2] = {1., 1.};                                                               // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
-  unsigned int fixedNLoopers[2] = {1, 1};                                                       // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
-  float adjust_flatgas = 0.f;                                                                   // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
+  bool loopersVeto = false; // if true, no loopers are generated
+  // Current files are set to custom user CCDB paths, TO BE CHANGED
+  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";                            // ONNX model for e+e- pair production
+  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton";                       // ONNX model for Compton scattering
+  std::string poisson = "${O2_ROOT}/share/Generators/TPCLoopers/poisson_params.csv";              // file with Poissonian parameters
+  std::string gauss = "${O2_ROOT}/share/Generators/TPCLoopers/gaussian_params.csv";               // file with Gaussian parameters
+  std::string scaler_pair = "${O2_ROOT}/share/Generators/TPCLoopers/ScalerPairParams.json";       // file with scaler parameters for e+e- pair production
+  std::string scaler_compton = "${O2_ROOT}/share/Generators/TPCLoopers/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
+  std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                            // file with clusters/rate information per orbit
+  std::string colsys = "PbPb";                                                                    // collision system  (PbPb or pp)
+  int intrate = -1;                                                                               // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
+  bool flat_gas = true;                                                                           // if true, the gas density is considered flat in the TPC volume
+  unsigned int nFlatGasLoopers = 500;                                                             // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
+  float fraction_pairs = 0.08;                                                                    // fraction of loopers [currently unused, kept for possible future debug developments]
+  float multiplier[2] = {1., 1.};                                                                 // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
+  unsigned int fixedNLoopers[2] = {1, 1};                                                         // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  float adjust_flatgas = 0.f;                                                                     // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 
diff --git a/Generators/share/TPCLoopers/README.md b/Generators/share/TPCLoopers/README.md
new file mode 100644
index 0000000000000..0e0ac858b8809
--- /dev/null
+++ b/Generators/share/TPCLoopers/README.md
@@ -0,0 +1,79 @@
+# TPC Loopers Generator - Parameter Files
+
+This directory contains parameter files used by the TPC Loopers event generator in ALICE O2.
+
+## Overview
+
+The TPC Loopers generator uses pre-trained ONNX models to generate realistic looper particles based on machine learning models trained on full GEANT4 slow neutron transport simulations. The parameter files in this directory provide:
+- Example statistical distribution parameters for sampling the number of loopers per event
+- **Mandatory** scaling parameters for transforming the ONNX model outputs to physical values
+
+## Files Description
+
+### Statistical Sampling Parameters
+
+The files provided in the folder are examples based on the training dataset.
+
+#### `gaussian_params.csv`
+Parameters for Gaussian distribution used to sample the number of Compton electrons per event.
+
+**Format:** Four values (one per line)
+1. Mean (μ)
+2. Standard deviation (σ)
+3. Minimum value
+4. Maximum value
+
+#### `poisson_params.csv`
+Parameters for Poisson distribution used to sample the number of electron-positron pairs per event.
+
+**Format:** Three values (one per line)
+1. Lambda (λ) parameter
+2. Minimum value
+3. Maximum value
+
+### Scaler Parameters
+
+These JSON files contain the parameters for inverse transformation of the ONNX models output. They should be kept as they are
+unless a new version of the models is released.
+
+#### `ScalerComptonParams.json`
+Scaler parameters for Compton electron generation model.
+
+**Structure:**
+```json
+{
+  "normal": {
+    "min": [array of 5 min values for min-max normalization],
+    "max": [array of 5 max values for min-max normalization]
+  },
+  "outlier": {
+    "center": [array of 2 center values for robust scaling],
+    "scale": [array of 2 scale values for robust scaling]
+  }
+}
+```
+
+- **normal**: Min-max normalization parameters for standard features (`Px`, `Py`, `Pz`, `VertexCoordinatesX`, `VertexCoordinatesY`)
+- **outlier**: Robust scaler parameters (center and scale) for outlier features (`VertexCoordinatesZ`,`time`)
+
+#### `ScalerPairParams.json`
+Scaler parameters for electron-positron pair generation model.
+
+**Structure:**
+```json
+{
+  "normal": {
+    "min": [array of 8 min values for min-max normalization],
+    "max": [array of 8 max values for min-max normalization]
+  },
+  "outlier": {
+    "center": [array of 2 center values for robust scaling],
+    "scale": [array of 2 scale values for robust scaling]
+  }
+}
+```
+
+- **normal**: Min-max normalization parameters for standard features (`Px_e`, `Py_e`, `Pz_e`,`Px_p`, `Py_p`, `Pz_p`, `VertexCoordinatesX`, `VertexCoordinatesY`)
+- **outlier**: Robust scaler parameters (center and scale) for outlier features (`VertexCoordinatesZ`,`time`)
+---
+*Author: M. Giacalone - September 2025*
diff --git a/Generators/share/egconfig/ScalerComptonParams.json b/Generators/share/TPCLoopers/ScalerComptonParams.json
similarity index 100%
rename from Generators/share/egconfig/ScalerComptonParams.json
rename to Generators/share/TPCLoopers/ScalerComptonParams.json
diff --git a/Generators/share/egconfig/ScalerPairParams.json b/Generators/share/TPCLoopers/ScalerPairParams.json
similarity index 100%
rename from Generators/share/egconfig/ScalerPairParams.json
rename to Generators/share/TPCLoopers/ScalerPairParams.json
diff --git a/Generators/share/egconfig/gaussian_params.csv b/Generators/share/TPCLoopers/gaussian_params.csv
similarity index 100%
rename from Generators/share/egconfig/gaussian_params.csv
rename to Generators/share/TPCLoopers/gaussian_params.csv
diff --git a/Generators/share/egconfig/poisson_params.csv b/Generators/share/TPCLoopers/poisson_params.csv
similarity index 100%
rename from Generators/share/egconfig/poisson_params.csv
rename to Generators/share/TPCLoopers/poisson_params.csv
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index ce49254799587..465a8ffb7ee22 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -25,6 +25,8 @@
 #include "TParticle.h"
 #include "TSystem.h"
 #include "TGrid.h"
+#include "CCDB/BasicCCDBManager.h"
+#include <filesystem>
 
 namespace o2
 {
@@ -50,7 +52,7 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        if (initLoopersGen()) {
+        if (initTPCLoopersGen()) {
           mAddTPCLoopers = kTRUE;
         }
       } else {
@@ -79,7 +81,7 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        if (initLoopersGen()) {
+        if (initTPCLoopersGen()) {
           mAddTPCLoopers = kTRUE;
         }
       } else {
@@ -94,7 +96,7 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
 
 /*****************************************************************/
 #ifdef GENERATORS_WITH_TPCLOOPERS
-bool Generator::initLoopersGen()
+bool Generator::initTPCLoopersGen()
 {
   // Expand all environment paths
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
@@ -169,24 +171,24 @@ bool Generator::initLoopersGen()
   nclxrate = isAlien[2] || isCCDB[2] ? local_names[2] : nclxrate;
   try {
     // Create the TPC loopers generator with the provided parameters
-    mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
+    mTPCLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
     const auto& intrate = loopersParam.intrate;
     // Configure the generator with flat gas loopers defined per orbit with clusters/track info
     // If intrate is negative (default), automatic IR from collisioncontext.root will be used
     if (flat_gas) {
-      mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
-      mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
+      mTPCLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
+      mTPCLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
     } else {
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers per event will be used
       // Multiplier is applied only with distribution sampling
       // This configuration can be used for testing purposes, in all other cases flat gas is recommended
-      mLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
-      mLoopersGen->SetMultiplier(multiplier);
+      mTPCLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
+      mTPCLoopersGen->SetMultiplier(multiplier);
     }
     LOG(info) << "TPC Loopers generator initialized successfully";
   } catch (const std::exception& e) {
     LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
-    mLoopersGen.reset();
+    mTPCLoopersGen.reset();
   }
   return kTRUE;
 }
@@ -210,21 +212,21 @@ Bool_t
 {
 #ifdef GENERATORS_WITH_TPCLOOPERS
   if (mAddTPCLoopers) {
-    if (!mLoopersGen) {
+    if (!mTPCLoopersGen) {
       LOG(error) << "Loopers generator not initialized";
       return kFALSE;
     }
 
     // Generate loopers using the initialized TPC loopers generator
-    if (!mLoopersGen->generateEvent()) {
+    if (!mTPCLoopersGen->generateEvent()) {
       LOG(error) << "Failed to generate loopers event";
       return kFALSE;
     }
-    if (mLoopersGen->getNLoopers() == 0) {
+    if (mTPCLoopersGen->getNLoopers() == 0) {
       LOG(warning) << "No loopers generated for this event";
       return kTRUE;
     }
-    const auto& looperParticles = mLoopersGen->importParticles();
+    const auto& looperParticles = mTPCLoopersGen->importParticles();
     if (looperParticles.empty()) {
       LOG(error) << "Failed to import loopers particles";
       return kFALSE;
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 8dff795de40a3..6e5af7c0c84d8 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -12,6 +12,16 @@
 /// \author M+Giacalone - September 2025
 
 #include "Generators/TPCLoopers.h"
+#include "CCDB/CCDBTimeStampUtils.h"
+#include "CCDB/CcdbApi.h"
+#include "DetectorsRaw/HBFUtils.h"
+#include "TF1.h"
+#include <filesystem>
+#include <SimulationDataFormat/ParticleStatus.h>
+#include "SimulationDataFormat/MCGenProperties.h"
+#include <iostream>
+#include <fstream>
+#include "TDatabasePDG.h"
 
 // Static Ort::Env instance for multiple onnx model loading
 Ort::Env global_env(ORT_LOGGING_LEVEL_WARNING, "GlobalEnv");
@@ -46,10 +56,11 @@ std::vector<double> Scaler::inverse_transform(const std::vector<double>& input)
 {
   std::vector<double> output;
   for (int i = 0; i < input.size(); ++i) {
-    if (i < input.size() - 2)
+    if (i < input.size() - 2) {
       output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
-    else
+    } else {
       output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
+    }
   }
 
   return output;
@@ -80,8 +91,9 @@ std::vector<double> ONNXGenerator::generate_sample()
 
   // Generate a latent vector (z)
   std::vector<float> z(100);
-  for (auto& v : z)
+  for (auto& v : z) {
     v = rand_gen.Gaus(0.0, 1.0);
+  }
 
   // Prepare input tensor
   std::vector<int64_t> input_shape = {1, 100};
@@ -227,7 +239,7 @@ Bool_t GenTPCLoopers::generateEvent()
   return true;
 }
 
-Bool_t GenTPCLoopers::generateEvent(double& time_limit)
+Bool_t GenTPCLoopers::generateEvent(double time_limit)
 {
   LOG(info) << "Time constraint for loopers: " << time_limit << " ns";
   // Generate pairs
@@ -253,6 +265,8 @@ Bool_t GenTPCLoopers::generateEvent(double& time_limit)
 std::vector<TParticle> GenTPCLoopers::importParticles()
 {
   std::vector<TParticle> particles;
+  const double mass_e = TDatabasePDG::Instance()->GetParticle(11)->Mass();
+  const double mass_p = TDatabasePDG::Instance()->GetParticle(-11)->Mass();
   // Get looper pairs from the event
   for (auto& pair : mGenPairs) {
     double px_e, py_e, pz_e, px_p, py_p, pz_p;
@@ -268,8 +282,8 @@ std::vector<TParticle> GenTPCLoopers::importParticles()
     vy = pair[7];
     vz = pair[8];
     time = pair[9];
-    e_etot = TMath::Sqrt(px_e * px_e + py_e * py_e + pz_e * pz_e + mMass_e * mMass_e);
-    p_etot = TMath::Sqrt(px_p * px_p + py_p * py_p + pz_p * pz_p + mMass_p * mMass_p);
+    e_etot = TMath::Sqrt(px_e * px_e + py_e * py_e + pz_e * pz_e + mass_e * mass_e);
+    p_etot = TMath::Sqrt(px_p * px_p + py_p * py_p + pz_p * pz_p + mass_p * mass_p);
     // Push the electron
     TParticle electron(11, 1, -1, -1, -1, -1, px_e, py_e, pz_e, e_etot, vx, vy, vz, time / 1e9);
     electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
@@ -295,7 +309,7 @@ std::vector<TParticle> GenTPCLoopers::importParticles()
     vy = compton[4];
     vz = compton[5];
     time = compton[6];
-    etot = TMath::Sqrt(px * px + py * py + pz * pz + mMass_e * mMass_e);
+    etot = TMath::Sqrt(px * px + py * py + pz * pz + mass_e * mass_e);
     // Push the electron
     TParticle electron(11, 1, -1, -1, -1, -1, px, py, pz, etot, vx, vy, vz, time / 1e9);
     electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
@@ -329,7 +343,7 @@ unsigned int GenTPCLoopers::GaussianElectrons()
   return gaussValue;
 }
 
-void GenTPCLoopers::SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_compton)
+void GenTPCLoopers::SetNLoopers(unsigned int nsig_pair, unsigned int nsig_compton)
 {
   if (mFlatGas) {
     mNLoopersPairs = nsig_pair;
@@ -348,7 +362,7 @@ void GenTPCLoopers::SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_comp
   }
 }
 
-void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
+void GenTPCLoopers::SetMultiplier(const std::array<float, 2>& mult)
 {
   // Multipliers will work only if the poissonian and gaussian parameters are set
   // otherwise they will be ignored
@@ -362,7 +376,7 @@ void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
   }
 }
 
-void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int_t& nloopers_orbit = -1)
+void GenTPCLoopers::setFlatGas(Bool_t flat, Int_t number, Int_t nloopers_orbit)
 {
   mFlatGas = flat;
   if (mFlatGas) {
@@ -408,7 +422,7 @@ void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int
   LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per " << (mFlatGasOrbit ? "orbit " : "event ") << mFlatGasNumber;
 }
 
-void GenTPCLoopers::setFractionPairs(float& fractionPairs)
+void GenTPCLoopers::setFractionPairs(float fractionPairs)
 {
   if (fractionPairs < 0 || fractionPairs > 1) {
     LOG(fatal) << "Error: Loops fraction for pairs must be in the range [0, 1].";
@@ -418,7 +432,7 @@ void GenTPCLoopers::setFractionPairs(float& fractionPairs)
   LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
 }
 
-void GenTPCLoopers::SetRate(const std::string& rateFile, const bool& isPbPb = true, const int& intRate = 50000)
+void GenTPCLoopers::SetRate(const std::string& rateFile, bool isPbPb = true, int intRate)
 {
   // Checking if the rate file exists and is not empty
   TFile rate_file(rateFile.c_str(), "READ");
@@ -459,7 +473,7 @@ void GenTPCLoopers::SetRate(const std::string& rateFile, const bool& isPbPb = tr
   }
 }
 
-void GenTPCLoopers::SetAdjust(const float& adjust = 0.f)
+void GenTPCLoopers::SetAdjust(float adjust)
 {
   if (mFlatGas && mFlatGasOrbit && adjust >= -1.f && adjust != 0.f) {
     LOG(info) << "Adjusting flat gas number per orbit by " << adjust * 100.f << "%";

From 2a9acbed7eb2a7047b910122e6b8c8373e5a7d9b Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1164/1764] Revert "Corrected include folder"

This reverts commit 1989aed2c6064aaec4d11dfaba2a08d101fed386.
---
 Generators/CMakeLists.txt                     | 19 +++--
 Generators/include/Generators/Generator.h     |  5 +-
 .../include/Generators/TPCLoopersParam.h      | 35 ++++----
 .../include/{Generators => }/TPCLoopers.h     | 44 +++++------
 Generators/share/TPCLoopers/README.md         | 79 -------------------
 .../ScalerComptonParams.json                  |  0
 .../ScalerPairParams.json                     |  0
 .../gaussian_params.csv                       |  0
 .../poisson_params.csv                        |  0
 Generators/src/Generator.cxx                  | 28 +++----
 Generators/src/TPCLoopers.cxx                 | 40 +++-------
 11 files changed, 78 insertions(+), 172 deletions(-)
 rename Generators/include/{Generators => }/TPCLoopers.h (71%)
 delete mode 100644 Generators/share/TPCLoopers/README.md
 rename Generators/share/{TPCLoopers => egconfig}/ScalerComptonParams.json (100%)
 rename Generators/share/{TPCLoopers => egconfig}/ScalerPairParams.json (100%)
 rename Generators/share/{TPCLoopers => egconfig}/gaussian_params.csv (100%)
 rename Generators/share/{TPCLoopers => egconfig}/poisson_params.csv (100%)

diff --git a/Generators/CMakeLists.txt b/Generators/CMakeLists.txt
index 287536ff118f7..f1921b8d8d72a 100644
--- a/Generators/CMakeLists.txt
+++ b/Generators/CMakeLists.txt
@@ -41,8 +41,8 @@ o2_add_library(Generators
                        src/GeneratorTParticleParam.cxx
                        src/GeneratorService.cxx
                        src/FlowMapper.cxx
-                       src/TPCLoopers.cxx
-                       src/TPCLoopersParam.cxx
+                       $<$<BOOL:${onnxruntime_FOUND}>:src/TPCLoopers.cxx>
+                       $<$<BOOL:${onnxruntime_FOUND}>:src/TPCLoopersParam.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/DecayerPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8Param.cxx>
@@ -55,7 +55,7 @@ o2_add_library(Generators
                PUBLIC_LINK_LIBRARIES FairRoot::Base O2::SimConfig O2::CommonUtils O2::DetectorsBase O2::ZDCBase
                                      O2::SimulationDataFormat ${pythiaTarget} ${hepmcTarget}
                                      FairRoot::Gen
-                                     onnxruntime::onnxruntime
+                                     $<$<BOOL:${onnxruntime_FOUND}>:onnxruntime::onnxruntime>
                TARGETVARNAME targetName)
 
 if(pythia_FOUND)
@@ -66,7 +66,9 @@ if(HepMC3_FOUND)
   target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_HEPMC3)
 endif()
 
-target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_TPCLOOPERS)
+if(onnxruntime_FOUND)
+  target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_TPCLOOPERS)
+endif()
 
 set(headers
     include/Generators/Generator.h
@@ -93,9 +95,11 @@ set(headers
     include/Generators/FlowMapper.h
     )
 
-list(APPEND headers
-            include/Generators/TPCLoopers.h
-            include/Generators/TPCLoopersParam.h)
+if(onnxruntime_FOUND)
+  list(APPEND headers
+              include/Generators/TPCLoopers.h
+              include/Generators/TPCLoopersParam.h)
+endif()
 
 if(pythia_FOUND)
   list(APPEND headers
@@ -167,5 +171,4 @@ endif()
 
 o2_data_file(COPY share/external DESTINATION Generators)
 o2_data_file(COPY share/egconfig DESTINATION Generators)
-o2_data_file(COPY share/TPCLoopers DESTINATION Generators)
 o2_data_file(COPY share/pythia8 DESTINATION Generators)
diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 3484601aa42bb..5a4921e036ca3 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -17,6 +17,7 @@
 #include "FairGenerator.h"
 #include "TParticle.h"
 #include "Generators/Trigger.h"
+#include "CCDB/BasicCCDBManager.h"
 #ifdef GENERATORS_WITH_TPCLOOPERS
 #include "Generators/TPCLoopers.h"
 #include "Generators/TPCLoopersParam.h"
@@ -171,8 +172,8 @@ class Generator : public FairGenerator
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
   // Loopers generator instance
-  std::unique_ptr<o2::eventgen::GenTPCLoopers> mTPCLoopersGen = nullptr;
-  bool initTPCLoopersGen();
+  std::unique_ptr<o2::eventgen::GenTPCLoopers> mLoopersGen = nullptr;
+  bool initLoopersGen();
 #endif
 
   ClassDefOverride(Generator, 2);
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 87e4510d6e617..49c8e5f5927b6 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -24,27 +24,26 @@ namespace eventgen
 
 /**
  ** a parameter class/struct to keep the settings of
- ** the TPC loopers event-generator and
+ ** the tpc loopers event-generator and
  ** allow the user to modify them
  **/
 struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
-  bool loopersVeto = false; // if true, no loopers are generated
-  // Current files are set to custom user CCDB paths, TO BE CHANGED
-  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";                            // ONNX model for e+e- pair production
-  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton";                       // ONNX model for Compton scattering
-  std::string poisson = "${O2_ROOT}/share/Generators/TPCLoopers/poisson_params.csv";              // file with Poissonian parameters
-  std::string gauss = "${O2_ROOT}/share/Generators/TPCLoopers/gaussian_params.csv";               // file with Gaussian parameters
-  std::string scaler_pair = "${O2_ROOT}/share/Generators/TPCLoopers/ScalerPairParams.json";       // file with scaler parameters for e+e- pair production
-  std::string scaler_compton = "${O2_ROOT}/share/Generators/TPCLoopers/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
-  std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                            // file with clusters/rate information per orbit
-  std::string colsys = "PbPb";                                                                    // collision system  (PbPb or pp)
-  int intrate = -1;                                                                               // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
-  bool flat_gas = true;                                                                           // if true, the gas density is considered flat in the TPC volume
-  unsigned int nFlatGasLoopers = 500;                                                             // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
-  float fraction_pairs = 0.08;                                                                    // fraction of loopers [currently unused, kept for possible future debug developments]
-  float multiplier[2] = {1., 1.};                                                                 // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
-  unsigned int fixedNLoopers[2] = {1, 1};                                                         // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
-  float adjust_flatgas = 0.f;                                                                     // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
+  bool loopersVeto = false;                                                                     // if true, no loopers are generated
+  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";                          // ONNX model for e+e- pair production
+  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton";                     // ONNX model for Compton scattering
+  std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv";              // file with Poissonian parameters
+  std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv";               // file with Gaussian parameters
+  std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json";       // file with scaler parameters for e+e- pair production
+  std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
+  std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
+  std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
+  int intrate = -1;                                                                             // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
+  bool flat_gas = true;                                                                         // if true, the gas density is considered flat in the TPC volume
+  unsigned int nFlatGasLoopers = 500;                                                           // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
+  float fraction_pairs = 0.08;                                                                  // fraction of loopers [currently unused, kept for possible future debug developments]
+  float multiplier[2] = {1., 1.};                                                               // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
+  unsigned int fixedNLoopers[2] = {1, 1};                                                       // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  float adjust_flatgas = 0.f;                                                                   // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 
diff --git a/Generators/include/Generators/TPCLoopers.h b/Generators/include/TPCLoopers.h
similarity index 71%
rename from Generators/include/Generators/TPCLoopers.h
rename to Generators/include/TPCLoopers.h
index 6a1d3ef262e22..57d178667b497 100644
--- a/Generators/include/Generators/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -17,11 +17,21 @@
 #ifdef GENERATORS_WITH_TPCLOOPERS
 #include <onnxruntime_cxx_api.h>
 #endif
+#include <iostream>
 #include <vector>
+#include <fstream>
 #include <rapidjson/document.h>
+#include "CCDB/CCDBTimeStampUtils.h"
+#include "CCDB/CcdbApi.h"
+#include "DetectorsRaw/HBFUtils.h"
 #include "TRandom3.h"
+#include "TDatabasePDG.h"
 #include <SimulationDataFormat/DigitizationContext.h>
+#include <SimulationDataFormat/ParticleStatus.h>
+#include "SimulationDataFormat/MCGenProperties.h"
 #include "TParticle.h"
+#include "TF1.h"
+#include <filesystem>
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
 // Static Ort::Env instance for multiple onnx model loading
@@ -29,8 +39,6 @@ extern Ort::Env global_env;
 
 // This class is responsible for loading the scaler parameters from a JSON file
 // and applying the inverse transformation to the generated data.
-// Inferenced output is scaled (min-max normalization or robust scaling for outlier features) during training,
-// so we need to revert this transformation to get physical values.
 struct Scaler {
   std::vector<double> normal_min;
   std::vector<double> normal_max;
@@ -66,20 +74,6 @@ namespace eventgen
 {
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
-/**
- * Generator for TPC Loopers based on pre-trained ONNX models.
- * Currently it generates loopers as electron-positron pairs and Compton electrons
- * according to specified distributions and parameters.
- * This can be extended to other types of background processes in the future (e.g. slow neutron spallation products, saturation tail).
- * Multiple configuration options are available:
- * - Flat gas: loopers are generated uniformly per event taking a reference value which can be either the LHC orbit time or the average interaction time record interval from the collision context.
- *   ==> Current automatic setup (default) sets the interaction rate automatically from the collision context and the reference value per orbit is calculated from an external file.
- *   ==> Number of loopers per orbit can be adjusted via a specific parameter.
- * - Poisson + Gaussian sampling: number of loopers are sampled from Poissonian (for pairs) and Gaussian (for Compton electrons) distributions based on provided parameters.
- *   ==> flat gas must be disabled to use this option.
- * - Fixed number of loopers per event
- *   ==> flat gas must be disabled to use this option and Poissonian/Gaussian parameters file should be set to None
- */
 class GenTPCLoopers
 {
  public:
@@ -89,7 +83,7 @@ class GenTPCLoopers
 
   Bool_t generateEvent();
 
-  Bool_t generateEvent(double time_limit);
+  Bool_t generateEvent(double& time_limit);
 
   std::vector<TParticle> importParticles();
 
@@ -97,17 +91,17 @@ class GenTPCLoopers
 
   unsigned int GaussianElectrons();
 
-  void SetNLoopers(unsigned int nsig_pair, unsigned int nsig_compton);
+  void SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_compton);
 
-  void SetMultiplier(const std::array<float, 2>& mult);
+  void SetMultiplier(std::array<float, 2>& mult);
 
-  void setFlatGas(Bool_t flat, Int_t number = -1, Int_t nloopers_orbit = -1);
+  void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
 
-  void setFractionPairs(float fractionPairs);
+  void setFractionPairs(float& fractionPairs);
 
-  void SetRate(const std::string& rateFile, bool isPbPb, int intRate = 50000);
+  void SetRate(const std::string& rateFile, const bool& isPbPb, const int& intRate);
 
-  void SetAdjust(float adjust = 0.f);
+  void SetAdjust(const float& adjust);
 
   unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
 
@@ -127,6 +121,10 @@ class GenTPCLoopers
   bool mGaussSet = false;
   // Random number generator
   TRandom3 mRandGen;
+  // Masses of the electrons and positrons
+  TDatabasePDG* mPDG = TDatabasePDG::Instance();
+  double mMass_e = mPDG->GetParticle(11)->Mass();
+  double mMass_p = mPDG->GetParticle(-11)->Mass();
   int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
   TFile* mContextFile = nullptr;                                  // Input collision context file
   o2::steer::DigitizationContext* mCollisionContext = nullptr;    // Pointer to the digitization context
diff --git a/Generators/share/TPCLoopers/README.md b/Generators/share/TPCLoopers/README.md
deleted file mode 100644
index 0e0ac858b8809..0000000000000
--- a/Generators/share/TPCLoopers/README.md
+++ /dev/null
@@ -1,79 +0,0 @@
-# TPC Loopers Generator - Parameter Files
-
-This directory contains parameter files used by the TPC Loopers event generator in ALICE O2.
-
-## Overview
-
-The TPC Loopers generator uses pre-trained ONNX models to generate realistic looper particles based on machine learning models trained on full GEANT4 slow neutron transport simulations. The parameter files in this directory provide:
-- Example statistical distribution parameters for sampling the number of loopers per event
-- **Mandatory** scaling parameters for transforming the ONNX model outputs to physical values
-
-## Files Description
-
-### Statistical Sampling Parameters
-
-The files provided in the folder are examples based on the training dataset.
-
-#### `gaussian_params.csv`
-Parameters for Gaussian distribution used to sample the number of Compton electrons per event.
-
-**Format:** Four values (one per line)
-1. Mean (μ)
-2. Standard deviation (σ)
-3. Minimum value
-4. Maximum value
-
-#### `poisson_params.csv`
-Parameters for Poisson distribution used to sample the number of electron-positron pairs per event.
-
-**Format:** Three values (one per line)
-1. Lambda (λ) parameter
-2. Minimum value
-3. Maximum value
-
-### Scaler Parameters
-
-These JSON files contain the parameters for inverse transformation of the ONNX models output. They should be kept as they are
-unless a new version of the models is released.
-
-#### `ScalerComptonParams.json`
-Scaler parameters for Compton electron generation model.
-
-**Structure:**
-```json
-{
-  "normal": {
-    "min": [array of 5 min values for min-max normalization],
-    "max": [array of 5 max values for min-max normalization]
-  },
-  "outlier": {
-    "center": [array of 2 center values for robust scaling],
-    "scale": [array of 2 scale values for robust scaling]
-  }
-}
-```
-
-- **normal**: Min-max normalization parameters for standard features (`Px`, `Py`, `Pz`, `VertexCoordinatesX`, `VertexCoordinatesY`)
-- **outlier**: Robust scaler parameters (center and scale) for outlier features (`VertexCoordinatesZ`,`time`)
-
-#### `ScalerPairParams.json`
-Scaler parameters for electron-positron pair generation model.
-
-**Structure:**
-```json
-{
-  "normal": {
-    "min": [array of 8 min values for min-max normalization],
-    "max": [array of 8 max values for min-max normalization]
-  },
-  "outlier": {
-    "center": [array of 2 center values for robust scaling],
-    "scale": [array of 2 scale values for robust scaling]
-  }
-}
-```
-
-- **normal**: Min-max normalization parameters for standard features (`Px_e`, `Py_e`, `Pz_e`,`Px_p`, `Py_p`, `Pz_p`, `VertexCoordinatesX`, `VertexCoordinatesY`)
-- **outlier**: Robust scaler parameters (center and scale) for outlier features (`VertexCoordinatesZ`,`time`)
----
-*Author: M. Giacalone - September 2025*
diff --git a/Generators/share/TPCLoopers/ScalerComptonParams.json b/Generators/share/egconfig/ScalerComptonParams.json
similarity index 100%
rename from Generators/share/TPCLoopers/ScalerComptonParams.json
rename to Generators/share/egconfig/ScalerComptonParams.json
diff --git a/Generators/share/TPCLoopers/ScalerPairParams.json b/Generators/share/egconfig/ScalerPairParams.json
similarity index 100%
rename from Generators/share/TPCLoopers/ScalerPairParams.json
rename to Generators/share/egconfig/ScalerPairParams.json
diff --git a/Generators/share/TPCLoopers/gaussian_params.csv b/Generators/share/egconfig/gaussian_params.csv
similarity index 100%
rename from Generators/share/TPCLoopers/gaussian_params.csv
rename to Generators/share/egconfig/gaussian_params.csv
diff --git a/Generators/share/TPCLoopers/poisson_params.csv b/Generators/share/egconfig/poisson_params.csv
similarity index 100%
rename from Generators/share/TPCLoopers/poisson_params.csv
rename to Generators/share/egconfig/poisson_params.csv
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 465a8ffb7ee22..ce49254799587 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -25,8 +25,6 @@
 #include "TParticle.h"
 #include "TSystem.h"
 #include "TGrid.h"
-#include "CCDB/BasicCCDBManager.h"
-#include <filesystem>
 
 namespace o2
 {
@@ -52,7 +50,7 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        if (initTPCLoopersGen()) {
+        if (initLoopersGen()) {
           mAddTPCLoopers = kTRUE;
         }
       } else {
@@ -81,7 +79,7 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        if (initTPCLoopersGen()) {
+        if (initLoopersGen()) {
           mAddTPCLoopers = kTRUE;
         }
       } else {
@@ -96,7 +94,7 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
 
 /*****************************************************************/
 #ifdef GENERATORS_WITH_TPCLOOPERS
-bool Generator::initTPCLoopersGen()
+bool Generator::initLoopersGen()
 {
   // Expand all environment paths
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
@@ -171,24 +169,24 @@ bool Generator::initTPCLoopersGen()
   nclxrate = isAlien[2] || isCCDB[2] ? local_names[2] : nclxrate;
   try {
     // Create the TPC loopers generator with the provided parameters
-    mTPCLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
+    mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
     const auto& intrate = loopersParam.intrate;
     // Configure the generator with flat gas loopers defined per orbit with clusters/track info
     // If intrate is negative (default), automatic IR from collisioncontext.root will be used
     if (flat_gas) {
-      mTPCLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
-      mTPCLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
+      mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
+      mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
     } else {
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers per event will be used
       // Multiplier is applied only with distribution sampling
       // This configuration can be used for testing purposes, in all other cases flat gas is recommended
-      mTPCLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
-      mTPCLoopersGen->SetMultiplier(multiplier);
+      mLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
+      mLoopersGen->SetMultiplier(multiplier);
     }
     LOG(info) << "TPC Loopers generator initialized successfully";
   } catch (const std::exception& e) {
     LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
-    mTPCLoopersGen.reset();
+    mLoopersGen.reset();
   }
   return kTRUE;
 }
@@ -212,21 +210,21 @@ Bool_t
 {
 #ifdef GENERATORS_WITH_TPCLOOPERS
   if (mAddTPCLoopers) {
-    if (!mTPCLoopersGen) {
+    if (!mLoopersGen) {
       LOG(error) << "Loopers generator not initialized";
       return kFALSE;
     }
 
     // Generate loopers using the initialized TPC loopers generator
-    if (!mTPCLoopersGen->generateEvent()) {
+    if (!mLoopersGen->generateEvent()) {
       LOG(error) << "Failed to generate loopers event";
       return kFALSE;
     }
-    if (mTPCLoopersGen->getNLoopers() == 0) {
+    if (mLoopersGen->getNLoopers() == 0) {
       LOG(warning) << "No loopers generated for this event";
       return kTRUE;
     }
-    const auto& looperParticles = mTPCLoopersGen->importParticles();
+    const auto& looperParticles = mLoopersGen->importParticles();
     if (looperParticles.empty()) {
       LOG(error) << "Failed to import loopers particles";
       return kFALSE;
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 6e5af7c0c84d8..8dff795de40a3 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -12,16 +12,6 @@
 /// \author M+Giacalone - September 2025
 
 #include "Generators/TPCLoopers.h"
-#include "CCDB/CCDBTimeStampUtils.h"
-#include "CCDB/CcdbApi.h"
-#include "DetectorsRaw/HBFUtils.h"
-#include "TF1.h"
-#include <filesystem>
-#include <SimulationDataFormat/ParticleStatus.h>
-#include "SimulationDataFormat/MCGenProperties.h"
-#include <iostream>
-#include <fstream>
-#include "TDatabasePDG.h"
 
 // Static Ort::Env instance for multiple onnx model loading
 Ort::Env global_env(ORT_LOGGING_LEVEL_WARNING, "GlobalEnv");
@@ -56,11 +46,10 @@ std::vector<double> Scaler::inverse_transform(const std::vector<double>& input)
 {
   std::vector<double> output;
   for (int i = 0; i < input.size(); ++i) {
-    if (i < input.size() - 2) {
+    if (i < input.size() - 2)
       output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
-    } else {
+    else
       output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
-    }
   }
 
   return output;
@@ -91,9 +80,8 @@ std::vector<double> ONNXGenerator::generate_sample()
 
   // Generate a latent vector (z)
   std::vector<float> z(100);
-  for (auto& v : z) {
+  for (auto& v : z)
     v = rand_gen.Gaus(0.0, 1.0);
-  }
 
   // Prepare input tensor
   std::vector<int64_t> input_shape = {1, 100};
@@ -239,7 +227,7 @@ Bool_t GenTPCLoopers::generateEvent()
   return true;
 }
 
-Bool_t GenTPCLoopers::generateEvent(double time_limit)
+Bool_t GenTPCLoopers::generateEvent(double& time_limit)
 {
   LOG(info) << "Time constraint for loopers: " << time_limit << " ns";
   // Generate pairs
@@ -265,8 +253,6 @@ Bool_t GenTPCLoopers::generateEvent(double time_limit)
 std::vector<TParticle> GenTPCLoopers::importParticles()
 {
   std::vector<TParticle> particles;
-  const double mass_e = TDatabasePDG::Instance()->GetParticle(11)->Mass();
-  const double mass_p = TDatabasePDG::Instance()->GetParticle(-11)->Mass();
   // Get looper pairs from the event
   for (auto& pair : mGenPairs) {
     double px_e, py_e, pz_e, px_p, py_p, pz_p;
@@ -282,8 +268,8 @@ std::vector<TParticle> GenTPCLoopers::importParticles()
     vy = pair[7];
     vz = pair[8];
     time = pair[9];
-    e_etot = TMath::Sqrt(px_e * px_e + py_e * py_e + pz_e * pz_e + mass_e * mass_e);
-    p_etot = TMath::Sqrt(px_p * px_p + py_p * py_p + pz_p * pz_p + mass_p * mass_p);
+    e_etot = TMath::Sqrt(px_e * px_e + py_e * py_e + pz_e * pz_e + mMass_e * mMass_e);
+    p_etot = TMath::Sqrt(px_p * px_p + py_p * py_p + pz_p * pz_p + mMass_p * mMass_p);
     // Push the electron
     TParticle electron(11, 1, -1, -1, -1, -1, px_e, py_e, pz_e, e_etot, vx, vy, vz, time / 1e9);
     electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
@@ -309,7 +295,7 @@ std::vector<TParticle> GenTPCLoopers::importParticles()
     vy = compton[4];
     vz = compton[5];
     time = compton[6];
-    etot = TMath::Sqrt(px * px + py * py + pz * pz + mass_e * mass_e);
+    etot = TMath::Sqrt(px * px + py * py + pz * pz + mMass_e * mMass_e);
     // Push the electron
     TParticle electron(11, 1, -1, -1, -1, -1, px, py, pz, etot, vx, vy, vz, time / 1e9);
     electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
@@ -343,7 +329,7 @@ unsigned int GenTPCLoopers::GaussianElectrons()
   return gaussValue;
 }
 
-void GenTPCLoopers::SetNLoopers(unsigned int nsig_pair, unsigned int nsig_compton)
+void GenTPCLoopers::SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_compton)
 {
   if (mFlatGas) {
     mNLoopersPairs = nsig_pair;
@@ -362,7 +348,7 @@ void GenTPCLoopers::SetNLoopers(unsigned int nsig_pair, unsigned int nsig_compto
   }
 }
 
-void GenTPCLoopers::SetMultiplier(const std::array<float, 2>& mult)
+void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
 {
   // Multipliers will work only if the poissonian and gaussian parameters are set
   // otherwise they will be ignored
@@ -376,7 +362,7 @@ void GenTPCLoopers::SetMultiplier(const std::array<float, 2>& mult)
   }
 }
 
-void GenTPCLoopers::setFlatGas(Bool_t flat, Int_t number, Int_t nloopers_orbit)
+void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int_t& nloopers_orbit = -1)
 {
   mFlatGas = flat;
   if (mFlatGas) {
@@ -422,7 +408,7 @@ void GenTPCLoopers::setFlatGas(Bool_t flat, Int_t number, Int_t nloopers_orbit)
   LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per " << (mFlatGasOrbit ? "orbit " : "event ") << mFlatGasNumber;
 }
 
-void GenTPCLoopers::setFractionPairs(float fractionPairs)
+void GenTPCLoopers::setFractionPairs(float& fractionPairs)
 {
   if (fractionPairs < 0 || fractionPairs > 1) {
     LOG(fatal) << "Error: Loops fraction for pairs must be in the range [0, 1].";
@@ -432,7 +418,7 @@ void GenTPCLoopers::setFractionPairs(float fractionPairs)
   LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
 }
 
-void GenTPCLoopers::SetRate(const std::string& rateFile, bool isPbPb = true, int intRate)
+void GenTPCLoopers::SetRate(const std::string& rateFile, const bool& isPbPb = true, const int& intRate = 50000)
 {
   // Checking if the rate file exists and is not empty
   TFile rate_file(rateFile.c_str(), "READ");
@@ -473,7 +459,7 @@ void GenTPCLoopers::SetRate(const std::string& rateFile, bool isPbPb = true, int
   }
 }
 
-void GenTPCLoopers::SetAdjust(float adjust)
+void GenTPCLoopers::SetAdjust(const float& adjust = 0.f)
 {
   if (mFlatGas && mFlatGasOrbit && adjust >= -1.f && adjust != 0.f) {
     LOG(info) << "Adjusting flat gas number per orbit by " << adjust * 100.f << "%";

From 63794a47f05379a1a293c1ace1e64ae392d59175 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1165/1764] Revert "Add copyright headers"

This reverts commit 6837bccb95a137dd24d42d44fd4db5579ad3dbf9.
---
 Generators/include/TPCLoopers.h | 13 -------------
 Generators/src/TPCLoopers.cxx   | 13 -------------
 2 files changed, 26 deletions(-)

diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 57d178667b497..9addcf844e09d 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -1,16 +1,3 @@
-// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author M+Giacalone - September 2025
-
 #ifndef ALICEO2_EVENTGEN_TPCLOOPERS_H_
 #define ALICEO2_EVENTGEN_TPCLOOPERS_H_
 
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 8dff795de40a3..258b6cce07b5b 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -1,16 +1,3 @@
-// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author M+Giacalone - September 2025
-
 #include "Generators/TPCLoopers.h"
 
 // Static Ort::Env instance for multiple onnx model loading

From 7744200e31549fbbcf8078013cbf8eb497803ef3 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1166/1764] Revert "Please consider the following formatting
 changes"

This reverts commit 569255b67223793d520de38f90463bc2f8ca6917.
---
 Generators/include/Generators/Generator.h     |   2 +-
 .../include/Generators/TPCLoopersParam.h      |  24 +-
 Generators/include/TPCLoopers.h               | 155 +++++------
 .../share/egconfig/ScalerComptonParams.json   |  52 ++--
 .../share/egconfig/ScalerPairParams.json      |  64 ++---
 Generators/src/Generator.cxx                  |   6 +-
 Generators/src/TPCLoopers.cxx                 | 256 ++++++++++--------
 7 files changed, 288 insertions(+), 271 deletions(-)

diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 5a4921e036ca3..67277e20736ce 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -161,7 +161,7 @@ class Generator : public FairGenerator
   void updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const;
 
   // loopers flag
-  Bool_t mAddTPCLoopers = kFALSE; // Flag is automatically set to true if TPC is in readout detectors, loopers are not vetoed and transport is enabled
+  Bool_t mAddTPCLoopers = kFALSE;  // Flag is automatically set to true if TPC is in readout detectors, loopers are not vetoed and transport is enabled
   // collect an ID and a short description of sub-generator entities
   std::unordered_map<int, std::string> mSubGeneratorsIdToDesc;
   // the current ID of the sub-generator used in the current event (if applicable)
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 49c8e5f5927b6..24d905c59c967 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -28,22 +28,22 @@ namespace eventgen
  ** allow the user to modify them
  **/
 struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
-  bool loopersVeto = false;                                                                     // if true, no loopers are generated
-  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";                          // ONNX model for e+e- pair production
-  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton";                     // ONNX model for Compton scattering
-  std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv";              // file with Poissonian parameters
-  std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv";               // file with Gaussian parameters
-  std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json";       // file with scaler parameters for e+e- pair production
+  bool loopersVeto = false; // if true, no loopers are generated
+  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";  // ONNX model for e+e- pair production
+  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton"; // ONNX model for Compton scattering
+  std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv"; // file with Poissonian parameters
+  std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv"; // file with Gaussian parameters
+  std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json"; // file with scaler parameters for e+e- pair production
   std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
   std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
   std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
   int intrate = -1;                                                                             // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
-  bool flat_gas = true;                                                                         // if true, the gas density is considered flat in the TPC volume
-  unsigned int nFlatGasLoopers = 500;                                                           // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
-  float fraction_pairs = 0.08;                                                                  // fraction of loopers [currently unused, kept for possible future debug developments]
-  float multiplier[2] = {1., 1.};                                                               // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
-  unsigned int fixedNLoopers[2] = {1, 1};                                                       // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
-  float adjust_flatgas = 0.f;                                                                   // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
+  bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
+  unsigned int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
+  float fraction_pairs = 0.08;         // fraction of loopers [currently unused, kept for possible future debug developments]
+  float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
+  unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  float adjust_flatgas = 0.f; // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 9addcf844e09d..8a4dc0030aa21 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -26,32 +26,33 @@ extern Ort::Env global_env;
 
 // This class is responsible for loading the scaler parameters from a JSON file
 // and applying the inverse transformation to the generated data.
-struct Scaler {
-  std::vector<double> normal_min;
-  std::vector<double> normal_max;
-  std::vector<double> outlier_center;
-  std::vector<double> outlier_scale;
+struct Scaler
+{
+    std::vector<double> normal_min;
+    std::vector<double> normal_max;
+    std::vector<double> outlier_center;
+    std::vector<double> outlier_scale;
 
-  void load(const std::string& filename);
+    void load(const std::string &filename);
 
-  std::vector<double> inverse_transform(const std::vector<double>& input);
+    std::vector<double> inverse_transform(const std::vector<double> &input);
 
- private:
-  std::vector<double> jsonArrayToVector(const rapidjson::Value& jsonArray);
+private:
+    std::vector<double> jsonArrayToVector(const rapidjson::Value &jsonArray);
 };
 
 // This class loads the ONNX model and generates samples using it.
 class ONNXGenerator
 {
- public:
-  ONNXGenerator(Ort::Env& shared_env, const std::string& model_path);
+public:
+    ONNXGenerator(Ort::Env &shared_env, const std::string &model_path);
 
-  std::vector<double> generate_sample();
+    std::vector<double> generate_sample();
 
- private:
-  Ort::Env& env;
-  Ort::Session session;
-  TRandom3 rand_gen;
+private:
+    Ort::Env &env;
+    Ort::Session session;
+    TRandom3 rand_gen;
 };
 #endif // GENERATORS_WITH_TPCLOOPERS
 
@@ -63,67 +64,67 @@ namespace eventgen
 #ifdef GENERATORS_WITH_TPCLOOPERS
 class GenTPCLoopers
 {
- public:
-  GenTPCLoopers(std::string model_pairs = "tpcloopmodel.onnx", std::string model_compton = "tpcloopmodelcompton.onnx",
-                std::string poisson = "poisson.csv", std::string gauss = "gauss.csv", std::string scaler_pair = "scaler_pair.json",
-                std::string scaler_compton = "scaler_compton.json");
-
-  Bool_t generateEvent();
-
-  Bool_t generateEvent(double& time_limit);
-
-  std::vector<TParticle> importParticles();
-
-  unsigned int PoissonPairs();
-
-  unsigned int GaussianElectrons();
-
-  void SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_compton);
-
-  void SetMultiplier(std::array<float, 2>& mult);
-
-  void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
-
-  void setFractionPairs(float& fractionPairs);
-
-  void SetRate(const std::string& rateFile, const bool& isPbPb, const int& intRate);
-
-  void SetAdjust(const float& adjust);
-
-  unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
-
- private:
-  std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
-  std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
-  std::unique_ptr<Scaler> mScaler_pair = nullptr;
-  std::unique_ptr<Scaler> mScaler_compton = nullptr;
-  double mPoisson[3] = {0.0, 0.0, 0.0};    // Mu, Min and Max of Poissonian
-  double mGauss[4] = {0.0, 0.0, 0.0, 0.0}; // Mean, Std, Min, Max
-  std::vector<std::vector<double>> mGenPairs;
-  std::vector<std::vector<double>> mGenElectrons;
-  unsigned int mNLoopersPairs = -1;
-  unsigned int mNLoopersCompton = -1;
-  std::array<float, 2> mMultiplier = {1., 1.};
-  bool mPoissonSet = false;
-  bool mGaussSet = false;
-  // Random number generator
-  TRandom3 mRandGen;
-  // Masses of the electrons and positrons
-  TDatabasePDG* mPDG = TDatabasePDG::Instance();
-  double mMass_e = mPDG->GetParticle(11)->Mass();
-  double mMass_p = mPDG->GetParticle(-11)->Mass();
-  int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
-  TFile* mContextFile = nullptr;                                  // Input collision context file
-  o2::steer::DigitizationContext* mCollisionContext = nullptr;    // Pointer to the digitization context
-  std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
-  Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
-  Bool_t mFlatGasOrbit = false;                                   // Flag to indicate if flat gas loopers are per orbit
-  Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
-  double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
-  double mTimeLimit = 0.0;                                        // Time limit for the current event
-  double mTimeEnd = 0.0;                                          // Time limit for the last event
-  float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
-  int mInteractionRate = 50000;                                   // Interaction rate in Hz
+    public:
+        GenTPCLoopers(std::string model_pairs = "tpcloopmodel.onnx", std::string model_compton = "tpcloopmodelcompton.onnx",
+                      std::string poisson = "poisson.csv", std::string gauss = "gauss.csv", std::string scaler_pair = "scaler_pair.json",
+                      std::string scaler_compton = "scaler_compton.json");
+    
+        Bool_t generateEvent();
+
+        Bool_t generateEvent(double &time_limit);
+
+        std::vector<TParticle> importParticles();
+
+        unsigned int PoissonPairs();
+
+        unsigned int GaussianElectrons();
+
+        void SetNLoopers(unsigned int &nsig_pair, unsigned int &nsig_compton);
+
+        void SetMultiplier(std::array<float, 2> &mult);
+
+        void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
+
+        void setFractionPairs(float &fractionPairs);
+
+        void SetRate(const std::string &rateFile, const bool &isPbPb, const int &intRate);
+
+        void SetAdjust(const float &adjust);
+
+        unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
+
+    private:
+        std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
+        std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
+        std::unique_ptr<Scaler> mScaler_pair = nullptr;
+        std::unique_ptr<Scaler> mScaler_compton = nullptr;
+        double mPoisson[3] = {0.0, 0.0, 0.0}; // Mu, Min and Max of Poissonian
+        double mGauss[4] = {0.0, 0.0, 0.0, 0.0}; // Mean, Std, Min, Max
+        std::vector<std::vector<double>> mGenPairs;
+        std::vector<std::vector<double>> mGenElectrons;
+        unsigned int mNLoopersPairs = -1;
+        unsigned int mNLoopersCompton = -1;
+        std::array<float, 2> mMultiplier = {1., 1.};
+        bool mPoissonSet = false;
+        bool mGaussSet = false;
+        // Random number generator
+        TRandom3 mRandGen;
+        // Masses of the electrons and positrons
+        TDatabasePDG *mPDG = TDatabasePDG::Instance();
+        double mMass_e = mPDG->GetParticle(11)->Mass();
+        double mMass_p = mPDG->GetParticle(-11)->Mass();
+        int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
+        TFile *mContextFile = nullptr;                                  // Input collision context file
+        o2::steer::DigitizationContext *mCollisionContext = nullptr;    // Pointer to the digitization context
+        std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
+        Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
+        Bool_t mFlatGasOrbit = false;                                   // Flag to indicate if flat gas loopers are per orbit
+        Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
+        double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
+        double mTimeLimit = 0.0;                                        // Time limit for the current event
+        double mTimeEnd = 0.0;                                          // Time limit for the last event
+        float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
+        int mInteractionRate = 50000;                                   // Interaction rate in Hz
 };
 #endif // GENERATORS_WITH_TPCLOOPERS
 
diff --git a/Generators/share/egconfig/ScalerComptonParams.json b/Generators/share/egconfig/ScalerComptonParams.json
index 157647fee2db7..d8e654847f46e 100644
--- a/Generators/share/egconfig/ScalerComptonParams.json
+++ b/Generators/share/egconfig/ScalerComptonParams.json
@@ -1,28 +1,28 @@
 {
-  "normal": {
-    "min": [
-      -0.0108811147511005,
-      -0.0098758740350604,
-      -0.0103233363479375,
-      -260.0542297363281,
-      -259.80059814453125
-    ],
-    "max": [
-      0.0108060473576188,
-      0.0103057539090514,
-      0.0106524610891938,
-      260.0343933105469,
-      259.62890625
-    ]
-  },
-  "outlier": {
-    "center": [
-      -71.39387130737305,
-      96791.23828125
-    ],
-    "scale": [
-      265.9389114379883,
-      230762.30981445312
-    ]
-  }
+    "normal": {
+        "min": [
+            -0.0108811147511005,
+            -0.0098758740350604,
+            -0.0103233363479375,
+            -260.0542297363281,
+            -259.80059814453125
+        ],
+        "max": [
+            0.0108060473576188,
+            0.0103057539090514,
+            0.0106524610891938,
+            260.0343933105469,
+            259.62890625
+        ]
+    },
+    "outlier": {
+        "center": [
+            -71.39387130737305,
+            96791.23828125
+        ],
+        "scale": [
+            265.9389114379883,
+            230762.30981445312
+        ]
+    }
 }
\ No newline at end of file
diff --git a/Generators/share/egconfig/ScalerPairParams.json b/Generators/share/egconfig/ScalerPairParams.json
index 57cdac421d3f6..61434bfa2462e 100644
--- a/Generators/share/egconfig/ScalerPairParams.json
+++ b/Generators/share/egconfig/ScalerPairParams.json
@@ -1,34 +1,34 @@
 {
-  "normal": {
-    "min": [
-      -0.0073022879660129,
-      -0.0077305701561272,
-      -0.0076750442385673,
-      -0.0082916170358657,
-      -0.0079681202769279,
-      -0.0077468422241508,
-      -255.6164093017578,
-      -252.9441680908203
-    ],
-    "max": [
-      0.007688719779253,
-      0.0077241472899913,
-      0.0075828479602932,
-      0.00813714787364,
-      0.0083825681358575,
-      0.0073839174583554,
-      256.2904968261719,
-      253.4925842285156
-    ]
-  },
-  "outlier": {
-    "center": [
-      -79.66580963134766,
-      141535.640625
-    ],
-    "scale": [
-      250.8921127319336,
-      222363.16015625
-    ]
-  }
+    "normal": {
+        "min": [
+            -0.0073022879660129,
+            -0.0077305701561272,
+            -0.0076750442385673,
+            -0.0082916170358657,
+            -0.0079681202769279,
+            -0.0077468422241508,
+            -255.6164093017578,
+            -252.9441680908203
+        ],
+        "max": [
+            0.007688719779253,
+            0.0077241472899913,
+            0.0075828479602932,
+            0.00813714787364,
+            0.0083825681358575,
+            0.0073839174583554,
+            256.2904968261719,
+            253.4925842285156
+        ]
+    },
+    "outlier": {
+        "center": [
+            -79.66580963134766,
+            141535.640625
+        ],
+        "scale": [
+            250.8921127319336,
+            222363.16015625
+        ]
+    }
 }
\ No newline at end of file
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index ce49254799587..9c16c0dfb7e92 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -170,7 +170,7 @@ bool Generator::initLoopersGen()
   try {
     // Create the TPC loopers generator with the provided parameters
     mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
-    const auto& intrate = loopersParam.intrate;
+    const auto &intrate = loopersParam.intrate;
     // Configure the generator with flat gas loopers defined per orbit with clusters/track info
     // If intrate is negative (default), automatic IR from collisioncontext.root will be used
     if (flat_gas) {
@@ -209,7 +209,7 @@ Bool_t
   Generator::finalizeEvent()
 {
 #ifdef GENERATORS_WITH_TPCLOOPERS
-  if (mAddTPCLoopers) {
+  if(mAddTPCLoopers) {
     if (!mLoopersGen) {
       LOG(error) << "Loopers generator not initialized";
       return kFALSE;
@@ -268,7 +268,7 @@ Bool_t
     }
 
     /** Event finalization**/
-    if (!finalizeEvent()) {
+    if(!finalizeEvent()) {
       LOG(error) << "ReadEvent failed in finalizeEvent";
       return kFALSE;
     }
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 258b6cce07b5b..ac1123b8d0bbd 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -6,7 +6,7 @@ Ort::Env global_env(ORT_LOGGING_LEVEL_WARNING, "GlobalEnv");
 // This class is responsible for loading the scaler parameters from a JSON file
 // and applying the inverse transformation to the generated data.
 
-void Scaler::load(const std::string& filename)
+void Scaler::load(const std::string &filename)
 {
   std::ifstream file(filename);
   if (!file.is_open()) {
@@ -27,73 +27,76 @@ void Scaler::load(const std::string& filename)
   normal_max = jsonArrayToVector(doc["normal"]["max"]);
   outlier_center = jsonArrayToVector(doc["outlier"]["center"]);
   outlier_scale = jsonArrayToVector(doc["outlier"]["scale"]);
-}
+}  
 
-std::vector<double> Scaler::inverse_transform(const std::vector<double>& input)
+std::vector<double> Scaler::inverse_transform(const std::vector<double> &input)
 {
-  std::vector<double> output;
-  for (int i = 0; i < input.size(); ++i) {
-    if (i < input.size() - 2)
-      output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
-    else
-      output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
-  }
+    std::vector<double> output;
+    for (int i = 0; i < input.size(); ++i)
+    {
+        if (i < input.size() - 2)
+            output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
+        else
+            output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
+    }
 
-  return output;
+    return output;
 }
 
-std::vector<double> Scaler::jsonArrayToVector(const rapidjson::Value& jsonArray)
+std::vector<double> Scaler::jsonArrayToVector(const rapidjson::Value &jsonArray)
 {
-  std::vector<double> vec;
-  for (int i = 0; i < jsonArray.Size(); ++i) {
-    vec.push_back(jsonArray[i].GetDouble());
-  }
-  return vec;
+    std::vector<double> vec;
+    for (int i = 0; i < jsonArray.Size(); ++i)
+    {
+        vec.push_back(jsonArray[i].GetDouble());
+    }
+    return vec;
 }
 
 // This class loads the ONNX model and generates samples using it.
 
 ONNXGenerator::ONNXGenerator(Ort::Env& shared_env, const std::string& model_path)
-  : env(shared_env), session(env, model_path.c_str(), Ort::SessionOptions{})
+: env(shared_env), session(env, model_path.c_str(), Ort::SessionOptions{})
 {
-  // Create session options
-  Ort::SessionOptions session_options;
-  session = Ort::Session(env, model_path.c_str(), session_options);
+    // Create session options
+    Ort::SessionOptions session_options;
+    session = Ort::Session(env, model_path.c_str(), session_options);
 }
 
 std::vector<double> ONNXGenerator::generate_sample()
 {
-  Ort::AllocatorWithDefaultOptions allocator;
-
-  // Generate a latent vector (z)
-  std::vector<float> z(100);
-  for (auto& v : z)
-    v = rand_gen.Gaus(0.0, 1.0);
-
-  // Prepare input tensor
-  std::vector<int64_t> input_shape = {1, 100};
-  // Get memory information
-  Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-
-  // Create input tensor correctly
-  Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
-    memory_info, z.data(), z.size(), input_shape.data(), input_shape.size());
-  // Run inference
-  const char* input_names[] = {"z"};
-  const char* output_names[] = {"output"};
-  auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, 1);
-
-  // Extract output
-  float* output_data = output_tensors.front().GetTensorMutableData<float>();
-  // Get the size of the output tensor
-  auto output_tensor_info = output_tensors.front().GetTensorTypeAndShapeInfo();
-  size_t output_data_size = output_tensor_info.GetElementCount(); // Total number of elements in the tensor
-  std::vector<double> output;
-  for (int i = 0; i < output_data_size; ++i) {
-    output.push_back(output_data[i]);
-  }
+    Ort::AllocatorWithDefaultOptions allocator;
+
+    // Generate a latent vector (z)
+    std::vector<float> z(100);
+    for (auto &v : z)
+        v = rand_gen.Gaus(0.0, 1.0);
+
+    // Prepare input tensor
+    std::vector<int64_t> input_shape = {1, 100};
+    // Get memory information
+    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+
+    // Create input tensor correctly
+    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
+        memory_info, z.data(), z.size(), input_shape.data(), input_shape.size());
+    // Run inference
+    const char *input_names[] = {"z"};
+    const char *output_names[] = {"output"};
+    auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, 1);
+
+    // Extract output
+    float *output_data = output_tensors.front().GetTensorMutableData<float>();
+    // Get the size of the output tensor
+    auto output_tensor_info = output_tensors.front().GetTensorTypeAndShapeInfo();
+    size_t output_data_size = output_tensor_info.GetElementCount(); // Total number of elements in the tensor
+    std::vector<double> output;
+    for (int i = 0; i < output_data_size; ++i)
+    {
+        output.push_back(output_data[i]);
+    }
 
-  return output;
+    return output;
 }
 
 namespace o2
@@ -102,67 +105,79 @@ namespace eventgen
 {
 
 GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
-                             std::string poisson, std::string gauss, std::string scaler_pair,
-                             std::string scaler_compton)
+                std::string poisson, std::string gauss, std::string scaler_pair,
+                std::string scaler_compton)
 {
-  // Checking if the model files exist and are not empty
-  std::ifstream model_file[2];
-  model_file[0].open(model_pairs);
-  model_file[1].open(model_compton);
-  if (!model_file[0].is_open() || model_file[0].peek() == std::ifstream::traits_type::eof()) {
-    LOG(fatal) << "Error: Pairs model file is empty or does not exist!";
-    exit(1);
-  }
-  if (!model_file[1].is_open() || model_file[1].peek() == std::ifstream::traits_type::eof()) {
-    LOG(fatal) << "Error: Compton model file is empty or does not exist!";
-    exit(1);
-  }
-  model_file[0].close();
-  model_file[1].close();
-  // Checking if the scaler files exist and are not empty
-  std::ifstream scaler_file[2];
-  scaler_file[0].open(scaler_pair);
-  scaler_file[1].open(scaler_compton);
-  if (!scaler_file[0].is_open() || scaler_file[0].peek() == std::ifstream::traits_type::eof()) {
-    LOG(fatal) << "Error: Pairs scaler file is empty or does not exist!";
-    exit(1);
-  }
-  if (!scaler_file[1].is_open() || scaler_file[1].peek() == std::ifstream::traits_type::eof()) {
-    LOG(fatal) << "Error: Compton scaler file is empty or does not exist!";
-    exit(1);
-  }
-  scaler_file[0].close();
-  scaler_file[1].close();
-  // Checking if the poisson file exists and it's not empty
-  if (poisson != "" && poisson != "None" && poisson != "none") {
-    std::ifstream poisson_file(poisson);
-    if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof()) {
-      LOG(fatal) << "Error: Poisson file is empty or does not exist!";
-      exit(1);
-    } else {
-      poisson_file >> mPoisson[0] >> mPoisson[1] >> mPoisson[2];
-      poisson_file.close();
-      mPoissonSet = true;
+    // Checking if the model files exist and are not empty
+    std::ifstream model_file[2];
+    model_file[0].open(model_pairs);
+    model_file[1].open(model_compton);
+    if (!model_file[0].is_open() || model_file[0].peek() == std::ifstream::traits_type::eof())
+    {
+        LOG(fatal) << "Error: Pairs model file is empty or does not exist!";
+        exit(1);
     }
-  }
-  // Checking if the gauss file exists and it's not empty
-  if (gauss != "" && gauss != "None" && gauss != "none") {
-    std::ifstream gauss_file(gauss);
-    if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof()) {
-      LOG(fatal) << "Error: Gauss file is empty or does not exist!";
-      exit(1);
-    } else {
-      gauss_file >> mGauss[0] >> mGauss[1] >> mGauss[2] >> mGauss[3];
-      gauss_file.close();
-      mGaussSet = true;
+    if (!model_file[1].is_open() || model_file[1].peek() == std::ifstream::traits_type::eof())
+    {
+        LOG(fatal) << "Error: Compton model file is empty or does not exist!";
+        exit(1);
     }
-  }
-  mONNX_pair = std::make_unique<ONNXGenerator>(global_env, model_pairs);
-  mScaler_pair = std::make_unique<Scaler>();
-  mScaler_pair->load(scaler_pair);
-  mONNX_compton = std::make_unique<ONNXGenerator>(global_env, model_compton);
-  mScaler_compton = std::make_unique<Scaler>();
-  mScaler_compton->load(scaler_compton);
+    model_file[0].close();
+    model_file[1].close();
+    // Checking if the scaler files exist and are not empty
+    std::ifstream scaler_file[2];
+    scaler_file[0].open(scaler_pair);
+    scaler_file[1].open(scaler_compton);
+    if (!scaler_file[0].is_open() || scaler_file[0].peek() == std::ifstream::traits_type::eof())
+    {
+        LOG(fatal) << "Error: Pairs scaler file is empty or does not exist!";
+        exit(1);
+    }
+    if (!scaler_file[1].is_open() || scaler_file[1].peek() == std::ifstream::traits_type::eof())
+    {
+        LOG(fatal) << "Error: Compton scaler file is empty or does not exist!";
+        exit(1);
+    }
+    scaler_file[0].close();
+    scaler_file[1].close();
+    // Checking if the poisson file exists and it's not empty
+    if (poisson != "" && poisson != "None" && poisson != "none")
+    {
+        std::ifstream poisson_file(poisson);
+        if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof())
+        {
+            LOG(fatal) << "Error: Poisson file is empty or does not exist!";
+            exit(1);
+        }
+        else
+        {
+            poisson_file >> mPoisson[0] >> mPoisson[1] >> mPoisson[2];
+            poisson_file.close();
+            mPoissonSet = true;
+        }
+    }
+    // Checking if the gauss file exists and it's not empty
+    if (gauss != "" && gauss != "None" && gauss != "none")
+    {
+        std::ifstream gauss_file(gauss);
+        if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof())
+        {
+            LOG(fatal) << "Error: Gauss file is empty or does not exist!";
+            exit(1);
+        }
+        else
+        {
+            gauss_file >> mGauss[0] >> mGauss[1] >> mGauss[2] >> mGauss[3];
+            gauss_file.close();
+            mGaussSet = true;
+        }
+    }
+    mONNX_pair = std::make_unique<ONNXGenerator>(global_env, model_pairs);
+    mScaler_pair = std::make_unique<Scaler>();
+    mScaler_pair->load(scaler_pair);
+    mONNX_compton = std::make_unique<ONNXGenerator>(global_env, model_compton);
+    mScaler_compton = std::make_unique<Scaler>();
+    mScaler_compton->load(scaler_compton);
 }
 
 Bool_t GenTPCLoopers::generateEvent()
@@ -337,16 +352,17 @@ void GenTPCLoopers::SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_comp
 
 void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
 {
-  // Multipliers will work only if the poissonian and gaussian parameters are set
-  // otherwise they will be ignored
-  if (mult[0] < 0 || mult[1] < 0) {
-    LOG(fatal) << "Error: Multiplier values must be non-negative!";
-    exit(1);
-  } else {
-    LOG(info) << "Multiplier values set to: Pair = " << mult[0] << ", Compton = " << mult[1];
-    mMultiplier[0] = mult[0];
-    mMultiplier[1] = mult[1];
-  }
+    // Multipliers will work only if the poissonian and gaussian parameters are set
+    // otherwise they will be ignored
+    if (mult[0] < 0 || mult[1] < 0)
+    {
+        LOG(fatal) << "Error: Multiplier values must be non-negative!";
+        exit(1);
+    } else {
+        LOG(info) << "Multiplier values set to: Pair = " << mult[0] << ", Compton = " << mult[1];
+        mMultiplier[0] = mult[0];
+        mMultiplier[1] = mult[1];
+    }
 }
 
 void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int_t& nloopers_orbit = -1)
@@ -405,7 +421,7 @@ void GenTPCLoopers::setFractionPairs(float& fractionPairs)
   LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
 }
 
-void GenTPCLoopers::SetRate(const std::string& rateFile, const bool& isPbPb = true, const int& intRate = 50000)
+void GenTPCLoopers::SetRate(const std::string &rateFile, const bool &isPbPb = true, const int &intRate = 50000)
 {
   // Checking if the rate file exists and is not empty
   TFile rate_file(rateFile.c_str(), "READ");

From 755d43950918deebb1559ef7cb3480d796b2a428 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1167/1764] Revert "Improved logging + colsys check"

This reverts commit e7a790b31d71d01e91a2a40123327febda65905f.
---
 Generators/src/Generator.cxx  | 31 +++++++++++--------------------
 Generators/src/TPCLoopers.cxx |  6 ++----
 2 files changed, 13 insertions(+), 24 deletions(-)

diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 9c16c0dfb7e92..9e083913c3bc7 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -50,15 +50,11 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        if (initLoopersGen()) {
+        if(initLoopersGen()){
           mAddTPCLoopers = kTRUE;
         }
-      } else {
-        LOG(info) << "TPC not active in readout detectors: loopers fast generator disabled.";
       }
     }
-  } else {
-    LOG(info) << "Loopers fast generator turned OFF with veto flag.";
   }
 #endif
 }
@@ -82,12 +78,8 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
         if (initLoopersGen()) {
           mAddTPCLoopers = kTRUE;
         }
-      } else {
-        LOG(info) << "TPC not active in readout detectors: loopers fast generator disabled.";
       }
     }
-  } else {
-    LOG(info) << "Loopers fast generator turned OFF with veto flag.";
   }
 #endif
 }
@@ -105,14 +97,8 @@ bool Generator::initLoopersGen()
   const auto& scaler_compton = gSystem->ExpandPathName(loopersParam.scaler_compton.c_str());
   const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
   const auto& gauss = gSystem->ExpandPathName(loopersParam.gauss.c_str());
-  const auto& flat_gas = loopersParam.flat_gas;
-  const auto& colsys = loopersParam.colsys;
+  auto flat_gas = loopersParam.flat_gas;
   if (flat_gas) {
-    if (colsys != "PbPb" && colsys != "pp") {
-      LOG(warning) << "Automatic background loopers configuration supports only 'pp' and 'PbPb' systems.";
-      LOG(warning) << "Fast loopers generator will remain OFF.";
-      return kFALSE;
-    }
     bool isContext = std::filesystem::exists("collisioncontext.root");
     if (!isContext) {
       LOG(warning) << "Warning: No collisioncontext.root file found!";
@@ -170,12 +156,17 @@ bool Generator::initLoopersGen()
   try {
     // Create the TPC loopers generator with the provided parameters
     mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
-    const auto &intrate = loopersParam.intrate;
+    auto& colsys = loopersParam.colsys;
+    auto &intrate = loopersParam.intrate;
     // Configure the generator with flat gas loopers defined per orbit with clusters/track info
-    // If intrate is negative (default), automatic IR from collisioncontext.root will be used
     if (flat_gas) {
-      mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
-      mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
+      if (colsys != "PbPb" && colsys != "pp") {
+        LOG(fatal) << "Error: collision system must be either 'PbPb' or 'pp'";
+        exit(1);
+      } else {
+        mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
+        mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
+      }
     } else {
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers per event will be used
       // Multiplier is applied only with distribution sampling
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index ac1123b8d0bbd..07af5b25f99f9 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -141,7 +141,7 @@ GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
     scaler_file[0].close();
     scaler_file[1].close();
     // Checking if the poisson file exists and it's not empty
-    if (poisson != "" && poisson != "None" && poisson != "none")
+    if (poisson != "")
     {
         std::ifstream poisson_file(poisson);
         if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof())
@@ -157,7 +157,7 @@ GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
         }
     }
     // Checking if the gauss file exists and it's not empty
-    if (gauss != "" && gauss != "None" && gauss != "none")
+    if (gauss != "")
     {
         std::ifstream gauss_file(gauss);
         if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof())
@@ -205,11 +205,9 @@ Bool_t GenTPCLoopers::generateEvent()
     // Set number of loopers if poissonian params are available
     if (mPoissonSet) {
       mNLoopersPairs = static_cast<unsigned int>(std::round(mMultiplier[0] * PoissonPairs()));
-      LOG(debug) << "Generated loopers pairs (Poisson): " << mNLoopersPairs;
     }
     if (mGaussSet) {
       mNLoopersCompton = static_cast<unsigned int>(std::round(mMultiplier[1] * GaussianElectrons()));
-      LOG(debug) << "Generated compton electrons (Gauss): " << mNLoopersCompton;
     }
     // Generate pairs
     for (int i = 0; i < mNLoopersPairs; ++i) {

From 208f9eac7a888ee407fa18f3e475901a53d6c571 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1168/1764] Revert "Fixed bug + cleaned code"

This reverts commit b48d4ec35cdb9252783a46916898d4bfbac928f3.
---
 Generators/include/Generators/TPCLoopersParam.h | 4 ++--
 Generators/src/Generator.cxx                    | 4 +++-
 Generators/src/TPCLoopers.cxx                   | 4 ++++
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 24d905c59c967..74c3cf4cff0ad 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -39,8 +39,8 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
   int intrate = -1;                                                                             // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
-  unsigned int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
-  float fraction_pairs = 0.08;         // fraction of loopers [currently unused, kept for possible future debug developments]
+  unsigned int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
+  float fraction_pairs = 0.08; // fraction of loopers
   float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
   unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
   float adjust_flatgas = 0.f; // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 9e083913c3bc7..18e28e4cc2668 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -106,6 +106,8 @@ bool Generator::initLoopersGen()
       return kFALSE;
     }
   }
+  const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
+  const auto& fraction_pairs = loopersParam.fraction_pairs;
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
   unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
   unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
@@ -168,7 +170,7 @@ bool Generator::initLoopersGen()
         mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
       }
     } else {
-      // Otherwise, Poisson+Gauss sampling or fixed number of loopers per event will be used
+      // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
       // Multiplier is applied only with distribution sampling
       // This configuration can be used for testing purposes, in all other cases flat gas is recommended
       mLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 07af5b25f99f9..0fb76fcd8c3a9 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -27,6 +27,10 @@ void Scaler::load(const std::string &filename)
   normal_max = jsonArrayToVector(doc["normal"]["max"]);
   outlier_center = jsonArrayToVector(doc["outlier"]["center"]);
   outlier_scale = jsonArrayToVector(doc["outlier"]["scale"]);
+  std::vector<double> normal_min;
+  std::vector<double> normal_max;
+  std::vector<double> outlier_center;
+  std::vector<double> outlier_scale;
 }  
 
 std::vector<double> Scaler::inverse_transform(const std::vector<double> &input)

From 6baae3eaf5599d35a2e24ca3a909d22baf808e89 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1169/1764] Revert "Set automatic interaction rate from
 collision context"

This reverts commit a6f60e12edf933dbeb724b9ba7c51a4c5e49cffc.
---
 .../include/Generators/TPCLoopersParam.h      |  4 ++--
 Generators/include/TPCLoopers.h               |  3 ---
 Generators/src/Generator.cxx                  | 10 +++++-----
 Generators/src/TPCLoopers.cxx                 | 19 ++-----------------
 4 files changed, 9 insertions(+), 27 deletions(-)

diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 74c3cf4cff0ad..8571013cdec48 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -37,9 +37,9 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
   std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
   std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
-  int intrate = -1;                                                                             // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
+  int intrate = 50000;                                                                          // interaction rate
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
-  unsigned int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
+  int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
   float fraction_pairs = 0.08; // fraction of loopers
   float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
   unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 8a4dc0030aa21..265581b5f885d 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -91,8 +91,6 @@ class GenTPCLoopers
 
         void SetAdjust(const float &adjust);
 
-        unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
-
     private:
         std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
         std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
@@ -124,7 +122,6 @@ class GenTPCLoopers
         double mTimeLimit = 0.0;                                        // Time limit for the current event
         double mTimeEnd = 0.0;                                          // Time limit for the last event
         float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
-        int mInteractionRate = 50000;                                   // Interaction rate in Hz
 };
 #endif // GENERATORS_WITH_TPCLOOPERS
 
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 18e28e4cc2668..fea1a38f1a146 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -107,7 +107,7 @@ bool Generator::initLoopersGen()
     }
   }
   const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
-  const auto& fraction_pairs = loopersParam.fraction_pairs;
+  auto fraction_pairs = loopersParam.fraction_pairs;
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
   unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
   unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
@@ -166,6 +166,10 @@ bool Generator::initLoopersGen()
         LOG(fatal) << "Error: collision system must be either 'PbPb' or 'pp'";
         exit(1);
       } else {
+        if (intrate <= 0) {
+          LOG(fatal) << "Error: interaction rate must be positive!";
+          exit(1);
+        }
         mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
         mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
       }
@@ -213,10 +217,6 @@ Bool_t
       LOG(error) << "Failed to generate loopers event";
       return kFALSE;
     }
-    if (mLoopersGen->getNLoopers() == 0) {
-      LOG(warning) << "No loopers generated for this event";
-      return kTRUE;
-    }
     const auto& looperParticles = mLoopersGen->importParticles();
     if (looperParticles.empty()) {
       LOG(error) << "Failed to import loopers particles";
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 0fb76fcd8c3a9..b771b53ed33d2 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -437,28 +437,13 @@ void GenTPCLoopers::SetRate(const std::string &rateFile, const bool &isPbPb = tr
     LOG(fatal) << "Error: Could not find fit function '" << fitName << "' in rate file!";
     exit(1);
   }
-  mInteractionRate = intRate;
-  if (mInteractionRate < 0) {
-    mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
-    if (!mContextFile || mContextFile->IsZombie()) {
-      LOG(fatal) << "Error: Interaction rate not provided and collision context file not found!";
-      exit(1);
-    }
-    mCollisionContext = (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext");
-    mInteractionRate = std::floor(mCollisionContext->getDigitizerInteractionRate());
-    LOG(info) << "Interaction rate retrieved from collision context: " << mInteractionRate << " Hz";
-    if (mInteractionRate < 0) {
-      LOG(fatal) << "Error: Invalid interaction rate retrieved from collision context!";
-      exit(1);
-    }
-  }
-  auto ref = static_cast<int>(std::floor(fit->Eval(mInteractionRate / 1000.))); // fit expects rate in kHz
+  auto ref = static_cast<int>(std::floor(fit->Eval(intRate / 1000.))); // fit expects rate in kHz
   rate_file.Close();
   if (ref <= 0) {
     LOG(fatal) << "Computed flat gas number reference per orbit is <=0";
     exit(1);
   } else {
-    LOG(info) << "Set flat gas number to " << ref << " loopers per orbit using " << fitName << " from " << mInteractionRate << " Hz interaction rate.";
+    LOG(info) << "Set flat gas number to " << ref << " loopers per orbit using " << fitName << " from " << intRate << " Hz interaction rate.";
     auto flat = true;
     setFlatGas(flat, -1, ref);
   }

From c035dd9e71953c8829c7afbdd5a7596061b006c0 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1170/1764] Revert "Implemented rate and collision system
 dependence (default)"

This reverts commit 32c0f318ec9737e7c1718c373d3c9660ddff477c.
---
 .../include/Generators/TPCLoopersParam.h      |  4 --
 Generators/include/TPCLoopers.h               |  8 +--
 Generators/src/Generator.cxx                  | 28 +++-----
 Generators/src/TPCLoopers.cxx                 | 64 +++----------------
 4 files changed, 17 insertions(+), 87 deletions(-)

diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 8571013cdec48..9430f4e05ac6e 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -35,15 +35,11 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv"; // file with Gaussian parameters
   std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json"; // file with scaler parameters for e+e- pair production
   std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
-  std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                          // file with clusters/rate information per orbit
-  std::string colsys = "PbPb";                                                                  // collision system  (PbPb or pp)
-  int intrate = 50000;                                                                          // interaction rate
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
   int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
   float fraction_pairs = 0.08; // fraction of loopers
   float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
   unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
-  float adjust_flatgas = 0.f; // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 265581b5f885d..1c1f3585eb3ab 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -17,7 +17,6 @@
 #include <SimulationDataFormat/ParticleStatus.h>
 #include "SimulationDataFormat/MCGenProperties.h"
 #include "TParticle.h"
-#include "TF1.h"
 #include <filesystem>
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
@@ -83,14 +82,10 @@ class GenTPCLoopers
 
         void SetMultiplier(std::array<float, 2> &mult);
 
-        void setFlatGas(Bool_t& flat, const Int_t& number, const Int_t& nloopers_orbit);
+        void setFlatGas(Bool_t &flat, const Int_t &number = -1);
 
         void setFractionPairs(float &fractionPairs);
 
-        void SetRate(const std::string &rateFile, const bool &isPbPb, const int &intRate);
-
-        void SetAdjust(const float &adjust);
-
     private:
         std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
         std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
@@ -116,7 +111,6 @@ class GenTPCLoopers
         o2::steer::DigitizationContext *mCollisionContext = nullptr;    // Pointer to the digitization context
         std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
         Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
-        Bool_t mFlatGasOrbit = false;                                   // Flag to indicate if flat gas loopers are per orbit
         Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
         double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
         double mTimeLimit = 0.0;                                        // Time limit for the current event
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index fea1a38f1a146..50b11c0c7bb53 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -92,7 +92,6 @@ bool Generator::initLoopersGen()
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
   std::string model_pairs = gSystem->ExpandPathName(loopersParam.model_pairs.c_str());
   std::string model_compton = gSystem->ExpandPathName(loopersParam.model_compton.c_str());
-  std::string nclxrate = gSystem->ExpandPathName(loopersParam.nclxrate.c_str());
   const auto& scaler_pair = gSystem->ExpandPathName(loopersParam.scaler_pair.c_str());
   const auto& scaler_compton = gSystem->ExpandPathName(loopersParam.scaler_compton.c_str());
   const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
@@ -111,10 +110,10 @@ bool Generator::initLoopersGen()
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
   unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
   unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
-  const std::array<std::string, 3> models = {model_pairs, model_compton, nclxrate};
-  const std::array<std::string, 3> local_names = {"WGANpair.onnx", "WGANcompton.onnx", "nclxrate.root"};
-  const std::array<bool, 3> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://"), models[2].starts_with("alien://")};
-  const std::array<bool, 3> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://"), models[2].starts_with("ccdb://")};
+  const std::array<std::string, 2> models = {model_pairs, model_compton};
+  const std::array<std::string, 2> local_names = {"WGANpair.onnx", "WGANcompton.onnx"};
+  const std::array<bool, 2> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://")};
+  const std::array<bool, 2> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://")};
   if (std::any_of(isAlien.begin(), isAlien.end(), [](bool v) { return v; })) {
     if (!gGrid) {
       TGrid::Connect("alien://");
@@ -154,25 +153,14 @@ bool Generator::initLoopersGen()
   }
   model_pairs = isAlien[0] || isCCDB[0] ? local_names[0] : model_pairs;
   model_compton = isAlien[1] || isCCDB[1] ? local_names[1] : model_compton;
-  nclxrate = isAlien[2] || isCCDB[2] ? local_names[2] : nclxrate;
   try {
     // Create the TPC loopers generator with the provided parameters
     mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
-    auto& colsys = loopersParam.colsys;
-    auto &intrate = loopersParam.intrate;
-    // Configure the generator with flat gas loopers defined per orbit with clusters/track info
+
+    // Configure the generator with flat gas loopers if enabled (default)
     if (flat_gas) {
-      if (colsys != "PbPb" && colsys != "pp") {
-        LOG(fatal) << "Error: collision system must be either 'PbPb' or 'pp'";
-        exit(1);
-      } else {
-        if (intrate <= 0) {
-          LOG(fatal) << "Error: interaction rate must be positive!";
-          exit(1);
-        }
-        mLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
-        mLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
-      }
+      mLoopersGen->setFlatGas(flat_gas, nFlatGasLoopers);
+      mLoopersGen->setFractionPairs(fraction_pairs);
     } else {
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
       // Multiplier is applied only with distribution sampling
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index b771b53ed33d2..109461ab71dfa 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -197,8 +197,7 @@ Bool_t GenTPCLoopers::generateEvent()
     LOG(debug) << "Current time offset wrt BC: " << mInteractionTimeRecords[mCurrentEvent].getTimeOffsetWrtBC() << " ns";
     mTimeLimit = (mCurrentEvent < mInteractionTimeRecords.size() - 1) ? mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns() : mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns();
     // With flat gas the number of loopers are adapted based on time interval widths
-    // The denominator is either the LHC orbit (if mFlatGasOrbit is true) or the mean interaction time record interval
-    nLoopers = mFlatGasOrbit ? (mFlatGasNumber * (mTimeLimit / o2::constants::lhc::LHCOrbitNS)) : (mFlatGasNumber * (mTimeLimit / mIntTimeRecMean));
+    nLoopers = mFlatGasNumber * (mTimeLimit / mIntTimeRecMean);
     nLoopersPairs = static_cast<unsigned int>(std::round(nLoopers * mLoopsFractionPairs));
     nLoopersCompton = nLoopers - nLoopersPairs;
     SetNLoopers(nLoopersPairs, nLoopersCompton);
@@ -367,34 +366,22 @@ void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
     }
 }
 
-void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int_t& nloopers_orbit = -1)
+void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number)
 {
   mFlatGas = flat;
   if (mFlatGas) {
-    if (nloopers_orbit > 0) {
-      mFlatGasOrbit = true;
-      mFlatGasNumber = nloopers_orbit;
-      LOG(info) << "Flat gas loopers will be generated using orbit reference.";
+    if (number < 0) {
+      LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
+      mFlatGas = false;
+      mFlatGasNumber = -1;
     } else {
-      mFlatGasOrbit = false;
-      if (number < 0) {
-        LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
-        mFlatGas = false;
-        mFlatGasNumber = -1;
-      } else {
-        mFlatGasNumber = number;
-      }
-    }
-    if (mFlatGas) {
+      mFlatGasNumber = number;
       mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
       mCollisionContext = mContextFile ? (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext") : nullptr;
       mInteractionTimeRecords = mCollisionContext ? mCollisionContext->getEventRecords() : std::vector<o2::InteractionTimeRecord>{};
       if (mInteractionTimeRecords.empty()) {
         LOG(error) << "Error: No interaction time records found in the collision context!";
         exit(1);
-      } else {
-        LOG(info) << "Interaction Time records has " << mInteractionTimeRecords.size() << " entries.";
-        mCollisionContext->printCollisionSummary();
       }
       for (int c = 0; c < mInteractionTimeRecords.size() - 1; c++) {
         mIntTimeRecMean += mInteractionTimeRecords[c + 1].bc2ns() - mInteractionTimeRecords[c].bc2ns();
@@ -410,7 +397,7 @@ void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number = -1, const Int
   } else {
     mFlatGasNumber = -1;
   }
-  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per " << (mFlatGasOrbit ? "orbit " : "event ") << mFlatGasNumber;
+  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per event: " << mFlatGasNumber;
 }
 
 void GenTPCLoopers::setFractionPairs(float& fractionPairs)
@@ -423,40 +410,5 @@ void GenTPCLoopers::setFractionPairs(float& fractionPairs)
   LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
 }
 
-void GenTPCLoopers::SetRate(const std::string &rateFile, const bool &isPbPb = true, const int &intRate = 50000)
-{
-  // Checking if the rate file exists and is not empty
-  TFile rate_file(rateFile.c_str(), "READ");
-  if (!rate_file.IsOpen() || rate_file.IsZombie()) {
-    LOG(fatal) << "Error: Rate file is empty or does not exist!";
-    exit(1);
-  }
-  const char* fitName = isPbPb ? "fitPbPb" : "fitpp";
-  auto fit = (TF1*)rate_file.Get(fitName);
-  if (!fit) {
-    LOG(fatal) << "Error: Could not find fit function '" << fitName << "' in rate file!";
-    exit(1);
-  }
-  auto ref = static_cast<int>(std::floor(fit->Eval(intRate / 1000.))); // fit expects rate in kHz
-  rate_file.Close();
-  if (ref <= 0) {
-    LOG(fatal) << "Computed flat gas number reference per orbit is <=0";
-    exit(1);
-  } else {
-    LOG(info) << "Set flat gas number to " << ref << " loopers per orbit using " << fitName << " from " << intRate << " Hz interaction rate.";
-    auto flat = true;
-    setFlatGas(flat, -1, ref);
-  }
-}
-
-void GenTPCLoopers::SetAdjust(const float& adjust = 0.f)
-{
-  if (mFlatGas && mFlatGasOrbit && adjust >= -1.f && adjust != 0.f) {
-    LOG(info) << "Adjusting flat gas number per orbit by " << adjust * 100.f << "%";
-    mFlatGasNumber = static_cast<int>(std::round(mFlatGasNumber * (1.f + adjust)));
-    LOG(info) << "New flat gas number per orbit: " << mFlatGasNumber;
-  }
-}
-
 } // namespace eventgen
 } // namespace o2
\ No newline at end of file

From fdce0869312a4e2c1a77a82b7c60c68e77bf203e Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1171/1764] Revert "Vetoing loopers for FlatGas and
 \!collisioncontext"

This reverts commit 8f8606a66c8499de6df999795d595f3dbab9e5b3.
---
 Generators/include/Generators/Generator.h |  2 +-
 Generators/src/Generator.cxx              | 21 +++++----------------
 2 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 67277e20736ce..4b68112517893 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -173,7 +173,7 @@ class Generator : public FairGenerator
 #ifdef GENERATORS_WITH_TPCLOOPERS
   // Loopers generator instance
   std::unique_ptr<o2::eventgen::GenTPCLoopers> mLoopersGen = nullptr;
-  bool initLoopersGen();
+  void initLoopersGen();
 #endif
 
   ClassDefOverride(Generator, 2);
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 50b11c0c7bb53..6fc9f378148d3 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -50,9 +50,8 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        if(initLoopersGen()){
-          mAddTPCLoopers = kTRUE;
-        }
+        mAddTPCLoopers = kTRUE;
+        initLoopersGen();
       }
     }
   }
@@ -75,9 +74,8 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        if (initLoopersGen()) {
-          mAddTPCLoopers = kTRUE;
-        }
+        mAddTPCLoopers = kTRUE;
+        initLoopersGen();
       }
     }
   }
@@ -86,7 +84,7 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
 
 /*****************************************************************/
 #ifdef GENERATORS_WITH_TPCLOOPERS
-bool Generator::initLoopersGen()
+void Generator::initLoopersGen()
 {
   // Expand all environment paths
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
@@ -97,14 +95,6 @@ bool Generator::initLoopersGen()
   const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
   const auto& gauss = gSystem->ExpandPathName(loopersParam.gauss.c_str());
   auto flat_gas = loopersParam.flat_gas;
-  if (flat_gas) {
-    bool isContext = std::filesystem::exists("collisioncontext.root");
-    if (!isContext) {
-      LOG(warning) << "Warning: No collisioncontext.root file found!";
-      LOG(warning) << "Loopers will be kept OFF.";
-      return kFALSE;
-    }
-  }
   const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
   auto fraction_pairs = loopersParam.fraction_pairs;
   std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
@@ -173,7 +163,6 @@ bool Generator::initLoopersGen()
     LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
     mLoopersGen.reset();
   }
-  return kTRUE;
 }
 #endif
 

From d1a8157599ca1ce2ba45dc133210908b0f85583b Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1172/1764] Revert "Various improvements"

This reverts commit 4b6530fbc6a93963de72035d123b6666b2991e32.
---
 .../SimConfig/include/SimConfig/SimConfig.h   |   3 +
 Common/SimConfig/src/SimConfig.cxx            |   2 +
 Generators/CMakeLists.txt                     |   4 +-
 Generators/include/Generators/Generator.h     |  11 +-
 .../include/Generators/TPCLoopersParam.h      |   5 +-
 Generators/include/TPCLoopers.h               |  12 +-
 Generators/src/Generator.cxx                  | 392 +++++++++---------
 Generators/src/GeneratorsLinkDef.h            |   2 +-
 Generators/src/TPCLoopers.cxx                 |   3 +
 9 files changed, 220 insertions(+), 214 deletions(-)

diff --git a/Common/SimConfig/include/SimConfig/SimConfig.h b/Common/SimConfig/include/SimConfig/SimConfig.h
index be88d9fbd8c33..8642a0e5bc225 100644
--- a/Common/SimConfig/include/SimConfig/SimConfig.h
+++ b/Common/SimConfig/include/SimConfig/SimConfig.h
@@ -52,6 +52,7 @@ struct SimConfigData {
   std::vector<std::string> mActiveModules;            // list of active modules
   std::vector<std::string> mReadoutDetectors;         // list of readout detectors
   std::string mMCEngine;                              // chosen VMC engine
+  bool mNoLoopers = false;                            // Disable automatic TPC loopers
   std::string mGenerator;                             // chosen VMC generator
   std::string mTrigger;                               // chosen VMC generator trigger
   unsigned int mNEvents;                              // number of events to be simulated
@@ -138,6 +139,8 @@ class SimConfig
   // get selected active detectors
   std::vector<std::string> const& getActiveModules() const { return mConfigData.mActiveModules; }
   std::vector<std::string> const& getReadoutDetectors() const { return mConfigData.mReadoutDetectors; }
+  // get loopers veto
+  bool getLoopersVeto() const { return mConfigData.mNoLoopers; }
 
   // static helper functions to determine list of active / readout modules
   // can also be used from outside
diff --git a/Common/SimConfig/src/SimConfig.cxx b/Common/SimConfig/src/SimConfig.cxx
index 15879687872d5..5ddc3199e3d4a 100644
--- a/Common/SimConfig/src/SimConfig.cxx
+++ b/Common/SimConfig/src/SimConfig.cxx
@@ -74,6 +74,7 @@ void SimConfig::initOptions(boost::program_options::options_description& options
     "run", bpo::value<int>()->default_value(-1), "ALICE run number")(
     "asservice", bpo::value<bool>()->default_value(false), "run in service/server mode")(
     "noGeant", bpo::bool_switch(), "prohibits any Geant transport/physics (by using tight cuts)")(
+    "noLoopers", bpo::bool_switch(), "disable automatic TPC loopers")(
     "forwardKine", bpo::bool_switch(), "forward kinematics on a FairMQ channel")(
     "noDiscOutput", bpo::bool_switch(), "switch off writing sim results to disc (useful in combination with forwardKine)");
   options.add_options()("fromCollContext", bpo::value<std::string>()->default_value(""), "Use a pregenerated collision context to infer number of events to simulate, how to embedd them, the vertex position etc. Takes precedence of other options such as \"--nEvents\". The format is COLLISIONCONTEXTFILE.root[:SIGNALNAME] where SIGNALNAME is the event part in the context which is relevant.");
@@ -297,6 +298,7 @@ bool SimConfig::resetFromParsedMap(boost::program_options::variables_map const&
   using o2::detectors::DetID;
   mConfigData.mMCEngine = vm["mcEngine"].as<std::string>();
   mConfigData.mNoGeant = vm["noGeant"].as<bool>();
+  mConfigData.mNoLoopers = vm["noLoopers"].as<bool>();
 
   // Reset modules and detectors as they are anyway re-parsed
   mConfigData.mReadoutDetectors.clear();
diff --git a/Generators/CMakeLists.txt b/Generators/CMakeLists.txt
index f1921b8d8d72a..56fe8b8fc2284 100644
--- a/Generators/CMakeLists.txt
+++ b/Generators/CMakeLists.txt
@@ -67,7 +67,7 @@ if(HepMC3_FOUND)
 endif()
 
 if(onnxruntime_FOUND)
-  target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_TPCLOOPERS)
+  target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_ONNXRUNTIME)
 endif()
 
 set(headers
@@ -96,7 +96,7 @@ set(headers
     )
 
 if(onnxruntime_FOUND)
-  list(APPEND headers
+  list(APPEND headers 
               include/Generators/TPCLoopers.h
               include/Generators/TPCLoopersParam.h)
 endif()
diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 4b68112517893..374d53f324399 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -17,8 +17,7 @@
 #include "FairGenerator.h"
 #include "TParticle.h"
 #include "Generators/Trigger.h"
-#include "CCDB/BasicCCDBManager.h"
-#ifdef GENERATORS_WITH_TPCLOOPERS
+#ifdef GENERATORS_WITH_ONNXRUNTIME
 #include "Generators/TPCLoopers.h"
 #include "Generators/TPCLoopersParam.h"
 #endif
@@ -78,7 +77,7 @@ class Generator : public FairGenerator
   /** methods to override **/
   virtual Bool_t generateEvent() = 0;   // generates event (in structure internal to generator)
   virtual Bool_t importParticles() = 0; // fills the mParticles vector (transfer from generator state)
-  Bool_t finalizeEvent();               // final part of event generation that can be customised using external macros
+  Bool_t loopers();                     // adds loopers to the event in case TPC is used
   virtual void updateHeader(o2::dataformats::MCEventHeader* eventHeader) {};
   Bool_t triggerEvent();
 
@@ -161,7 +160,7 @@ class Generator : public FairGenerator
   void updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const;
 
   // loopers flag
-  Bool_t mAddTPCLoopers = kFALSE;  // Flag is automatically set to true if TPC is in readout detectors, loopers are not vetoed and transport is enabled
+  Bool_t mAddLoopers = kFALSE;
   // collect an ID and a short description of sub-generator entities
   std::unordered_map<int, std::string> mSubGeneratorsIdToDesc;
   // the current ID of the sub-generator used in the current event (if applicable)
@@ -170,11 +169,11 @@ class Generator : public FairGenerator
   // global static information about (upper limit of) number of events to be generated
   static unsigned int gTotalNEvents;
 
-#ifdef GENERATORS_WITH_TPCLOOPERS
+#ifdef GENERATORS_WITH_ONNXRUNTIME
   // Loopers generator instance
   std::unique_ptr<o2::eventgen::GenTPCLoopers> mLoopersGen = nullptr;
-  void initLoopersGen();
 #endif
+  void initLoopersGen();
 
   ClassDefOverride(Generator, 2);
 
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
index 9430f4e05ac6e..ceeea201538b2 100644
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -28,7 +28,6 @@ namespace eventgen
  ** allow the user to modify them
  **/
 struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
-  bool loopersVeto = false; // if true, no loopers are generated
   std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";  // ONNX model for e+e- pair production
   std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton"; // ONNX model for Compton scattering
   std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv"; // file with Poissonian parameters
@@ -38,8 +37,8 @@ struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoope
   bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
   int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
   float fraction_pairs = 0.08; // fraction of loopers
-  float multiplier[2] = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
-  unsigned int fixedNLoopers[2] = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  std::array<float, 2> multiplier = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
+  std::array<unsigned int, 2> fixedNLoopers = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
   O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
 };
 
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
index 1c1f3585eb3ab..70146a82baf60 100644
--- a/Generators/include/TPCLoopers.h
+++ b/Generators/include/TPCLoopers.h
@@ -1,7 +1,7 @@
 #ifndef ALICEO2_EVENTGEN_TPCLOOPERS_H_
 #define ALICEO2_EVENTGEN_TPCLOOPERS_H_
 
-#ifdef GENERATORS_WITH_TPCLOOPERS
+#ifdef GENERATORS_WITH_ONNXRUNTIME
 #include <onnxruntime_cxx_api.h>
 #endif
 #include <iostream>
@@ -19,10 +19,12 @@
 #include "TParticle.h"
 #include <filesystem>
 
-#ifdef GENERATORS_WITH_TPCLOOPERS
+#ifdef GENERATORS_WITH_ONNXRUNTIME
 // Static Ort::Env instance for multiple onnx model loading
 extern Ort::Env global_env;
+#endif
 
+#ifdef GENERATORS_WITH_ONNXRUNTIME
 // This class is responsible for loading the scaler parameters from a JSON file
 // and applying the inverse transformation to the generated data.
 struct Scaler
@@ -53,14 +55,14 @@ class ONNXGenerator
     Ort::Session session;
     TRandom3 rand_gen;
 };
-#endif // GENERATORS_WITH_TPCLOOPERS
+#endif // GENERATORS_WITH_ONNXRUNTIME
 
 namespace o2
 {
 namespace eventgen
 {
 
-#ifdef GENERATORS_WITH_TPCLOOPERS
+#ifdef GENERATORS_WITH_ONNXRUNTIME
 class GenTPCLoopers
 {
     public:
@@ -117,7 +119,7 @@ class GenTPCLoopers
         double mTimeEnd = 0.0;                                          // Time limit for the last event
         float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
 };
-#endif // GENERATORS_WITH_TPCLOOPERS
+#endif // GENERATORS_WITH_ONNXRUNTIME
 
 } // namespace eventgen
 } // namespace o2
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 6fc9f378148d3..153ef5cd5e35e 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -42,20 +42,18 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
   /** default constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
-#ifdef GENERATORS_WITH_TPCLOOPERS
-  const auto& simConfig = o2::conf::SimConfig::Instance();
-  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
-  if (!loopersParam.loopersVeto) {
+  auto simConfig = o2::conf::SimConfig::Instance();
+  auto noLoops = simConfig.getLoopersVeto();
+  if (!noLoops) {
     bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        mAddTPCLoopers = kTRUE;
+        mAddLoopers = kTRUE;
         initLoopersGen();
       }
     }
   }
-#endif
 }
 
 /*****************************************************************/
@@ -66,26 +64,25 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
   /** constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
-#ifdef GENERATORS_WITH_TPCLOOPERS
-  const auto& simConfig = o2::conf::SimConfig::Instance();
-  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
-  if (!loopersParam.loopersVeto) {
+  auto simConfig = o2::conf::SimConfig::Instance();
+  auto noLoops = simConfig.getLoopersVeto();
+  if (!noLoops) {
     bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
     if (transport) {
       bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
       if (tpcActive) {
-        mAddTPCLoopers = kTRUE;
+        mAddLoopers = kTRUE;
         initLoopersGen();
       }
     }
   }
-#endif
 }
 
 /*****************************************************************/
-#ifdef GENERATORS_WITH_TPCLOOPERS
+
 void Generator::initLoopersGen()
 {
+#ifdef GENERATORS_WITH_ONNXRUNTIME
   // Expand all environment paths
   const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
   std::string model_pairs = gSystem->ExpandPathName(loopersParam.model_pairs.c_str());
@@ -97,9 +94,8 @@ void Generator::initLoopersGen()
   auto flat_gas = loopersParam.flat_gas;
   const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
   auto fraction_pairs = loopersParam.fraction_pairs;
-  std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
-  unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
-  unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
+  auto multiplier = loopersParam.multiplier;
+  auto fixedNLoopers = loopersParam.fixedNLoopers;
   const std::array<std::string, 2> models = {model_pairs, model_compton};
   const std::array<std::string, 2> local_names = {"WGANpair.onnx", "WGANcompton.onnx"};
   const std::array<bool, 2> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://")};
@@ -120,10 +116,8 @@ void Generator::initLoopersGen()
     }
   }
   if (std::any_of(isCCDB.begin(), isCCDB.end(), [](bool v) { return v; })) {
-    auto& ccdb = o2::ccdb::BasicCCDBManager::instance();
-    ccdb.setURL("http://alice-ccdb.cern.ch");
-    // Get underlying CCDB API from BasicCCDBManager
-    auto& ccdb_api = ccdb.getCCDBAccessor();
+    o2::ccdb::CcdbApi ccdb_api;
+    ccdb_api.init("http://alice-ccdb.cern.ch");
     for (size_t i = 0; i < models.size(); ++i) {
       if (isCCDB[i]) {
         auto model_path = models[i].substr(7); // Remove "ccdb://"
@@ -155,7 +149,7 @@ void Generator::initLoopersGen()
       // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
       // Multiplier is applied only with distribution sampling
       // This configuration can be used for testing purposes, in all other cases flat gas is recommended
-      mLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
+      mLoopersGen->SetNLoopers(fixedNLoopers[0], fixedNLoopers[1]);
       mLoopersGen->SetMultiplier(multiplier);
     }
     LOG(info) << "TPC Loopers generator initialized successfully";
@@ -163,8 +157,10 @@ void Generator::initLoopersGen()
     LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
     mLoopersGen.reset();
   }
-}
+#else
+  LOG(warn) << "ONNX Runtime support not available, cannot initialize TPC loopers generator";
 #endif
+}
 
 /*****************************************************************/
 
@@ -180,228 +176,230 @@ Bool_t
 /*****************************************************************/
 
 Bool_t
-  Generator::finalizeEvent()
+  Generator::loopers()
 {
-#ifdef GENERATORS_WITH_TPCLOOPERS
-  if(mAddTPCLoopers) {
-    if (!mLoopersGen) {
-      LOG(error) << "Loopers generator not initialized";
-      return kFALSE;
-    }
-
-    // Generate loopers using the initialized TPC loopers generator
-    if (!mLoopersGen->generateEvent()) {
-      LOG(error) << "Failed to generate loopers event";
-      return kFALSE;
-    }
-    const auto& looperParticles = mLoopersGen->importParticles();
-    if (looperParticles.empty()) {
-      LOG(error) << "Failed to import loopers particles";
-      return kFALSE;
-    }
-    // Append the generated looper particles to the main particle list
-    mParticles.insert(mParticles.end(), looperParticles.begin(), looperParticles.end());
+#ifdef GENERATORS_WITH_ONNXRUNTIME
+  if (!mLoopersGen) {
+    LOG(error) << "Loopers generator not initialized";
+    return kFALSE;
+  }
 
-    LOG(debug) << "Added " << looperParticles.size() << " looper particles";
+  // Generate loopers using the initialized TPC loopers generator
+  if (!mLoopersGen->generateEvent()) {
+    LOG(error) << "Failed to generate loopers event";
+    return kFALSE;
   }
-#endif
+  const auto& looperParticles = mLoopersGen->importParticles();
+  if (looperParticles.empty()) {
+    LOG(error) << "Failed to import loopers particles";
+    return kFALSE;
+  }
+  // Append the generated looper particles to the main particle list
+  mParticles.insert(mParticles.end(), looperParticles.begin(), looperParticles.end());
+
+  LOG(debug) << "Added " << looperParticles.size() << " looper particles";
+  return kTRUE;
+#else
+  LOG(warn) << "ONNX Runtime support not available, skipping TPC loopers generation";
   return kTRUE;
+#endif
 }
+  /*****************************************************************/
 
-/*****************************************************************/
+  Bool_t
+    Generator::ReadEvent(FairPrimaryGenerator * primGen)
+  {
+    /** read event **/
 
-Bool_t
-  Generator::ReadEvent(FairPrimaryGenerator* primGen)
-{
-  /** read event **/
+    /** endless generate-and-trigger loop **/
+    while (true) {
+      mReadEventCounter++;
 
-  /** endless generate-and-trigger loop **/
-  while (true) {
-    mReadEventCounter++;
+      /** clear particle vector **/
+      mParticles.clear();
 
-    /** clear particle vector **/
-    mParticles.clear();
+      /** reset the sub-generator ID **/
+      mSubGeneratorId = -1;
 
-    /** reset the sub-generator ID **/
-    mSubGeneratorId = -1;
+      /** generate event **/
+      if (!generateEvent()) {
+        LOG(error) << "ReadEvent failed in generateEvent";
+        return kFALSE;
+      }
 
-    /** generate event **/
-    if (!generateEvent()) {
-      LOG(error) << "ReadEvent failed in generateEvent";
-      return kFALSE;
-    }
+      /** import particles **/
+      if (!importParticles()) {
+        LOG(error) << "ReadEvent failed in importParticles";
+        return kFALSE;
+      }
 
-    /** import particles **/
-    if (!importParticles()) {
-      LOG(error) << "ReadEvent failed in importParticles";
-      return kFALSE;
-    }
+      /** Add loopers **/
+      if(mAddLoopers){
+        if (!loopers()) {
+          LOG(error) << "ReadEvent failed in loopers";
+          return kFALSE;
+        }
+      }
 
-    /** Event finalization**/
-    if(!finalizeEvent()) {
-      LOG(error) << "ReadEvent failed in finalizeEvent";
-      return kFALSE;
-    }
+      if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
+        LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
+      }
 
-    if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
-      LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
-    }
+      if (!mSubGeneratorsIdToDesc.empty() && mSubGeneratorId < 0) {
+        LOG(fatal) << "ReadEvent failed because SubGenerator description given but sub-generator not set";
+      }
 
-    if (!mSubGeneratorsIdToDesc.empty() && mSubGeneratorId < 0) {
-      LOG(fatal) << "ReadEvent failed because SubGenerator description given but sub-generator not set";
+      /** trigger event **/
+      if (triggerEvent()) {
+        mTriggerOkHook(mParticles, mReadEventCounter);
+        break;
+      } else {
+        mTriggerFalseHook(mParticles, mReadEventCounter);
+      }
     }
 
-    /** trigger event **/
-    if (triggerEvent()) {
-      mTriggerOkHook(mParticles, mReadEventCounter);
-      break;
-    } else {
-      mTriggerFalseHook(mParticles, mReadEventCounter);
+    /** add tracks **/
+    if (!addTracks(primGen)) {
+      LOG(error) << "ReadEvent failed in addTracks";
+      return kFALSE;
     }
-  }
 
-  /** add tracks **/
-  if (!addTracks(primGen)) {
-    LOG(error) << "ReadEvent failed in addTracks";
-    return kFALSE;
-  }
+    /** update header **/
+    auto header = primGen->GetEvent();
+    auto o2header = dynamic_cast<o2::dataformats::MCEventHeader*>(header);
+    if (!header) {
+      LOG(fatal) << "MC event header is not a 'o2::dataformats::MCEventHeader' object";
+      return kFALSE;
+    }
+    updateHeader(o2header);
+    updateSubGeneratorInformation(o2header);
 
-  /** update header **/
-  auto header = primGen->GetEvent();
-  auto o2header = dynamic_cast<o2::dataformats::MCEventHeader*>(header);
-  if (!header) {
-    LOG(fatal) << "MC event header is not a 'o2::dataformats::MCEventHeader' object";
-    return kFALSE;
+    /** success **/
+    return kTRUE;
   }
-  updateHeader(o2header);
-  updateSubGeneratorInformation(o2header);
 
-  /** success **/
-  return kTRUE;
-}
+  /*****************************************************************/
 
-/*****************************************************************/
+  Bool_t
+    Generator::addTracks(FairPrimaryGenerator * primGen)
+  {
+    /** add tracks **/
 
-Bool_t
-  Generator::addTracks(FairPrimaryGenerator* primGen)
-{
-  /** add tracks **/
+    auto o2primGen = dynamic_cast<PrimaryGenerator*>(primGen);
+    if (!o2primGen) {
+      LOG(fatal) << "PrimaryGenerator is not a o2::eventgen::PrimaryGenerator";
+      return kFALSE;
+    }
 
-  auto o2primGen = dynamic_cast<PrimaryGenerator*>(primGen);
-  if (!o2primGen) {
-    LOG(fatal) << "PrimaryGenerator is not a o2::eventgen::PrimaryGenerator";
-    return kFALSE;
-  }
+    /** loop over particles **/
+    for (const auto& particle : mParticles) {
+      o2primGen->AddTrack(particle.GetPdgCode(),
+                          particle.Px() * mMomentumUnit,
+                          particle.Py() * mMomentumUnit,
+                          particle.Pz() * mMomentumUnit,
+                          particle.Vx() * mPositionUnit,
+                          particle.Vy() * mPositionUnit,
+                          particle.Vz() * mPositionUnit,
+                          particle.GetMother(0),
+                          particle.GetMother(1),
+                          particle.GetDaughter(0),
+                          particle.GetDaughter(1),
+                          particle.TestBit(ParticleStatus::kToBeDone),
+                          particle.Energy() * mEnergyUnit,
+                          particle.T() * mTimeUnit,
+                          particle.GetWeight(),
+                          (TMCProcess)particle.GetUniqueID(),
+                          particle.GetStatusCode()); // generator status information passed as status code field
+    }
 
-  /** loop over particles **/
-  for (const auto& particle : mParticles) {
-    o2primGen->AddTrack(particle.GetPdgCode(),
-                        particle.Px() * mMomentumUnit,
-                        particle.Py() * mMomentumUnit,
-                        particle.Pz() * mMomentumUnit,
-                        particle.Vx() * mPositionUnit,
-                        particle.Vy() * mPositionUnit,
-                        particle.Vz() * mPositionUnit,
-                        particle.GetMother(0),
-                        particle.GetMother(1),
-                        particle.GetDaughter(0),
-                        particle.GetDaughter(1),
-                        particle.TestBit(ParticleStatus::kToBeDone),
-                        particle.Energy() * mEnergyUnit,
-                        particle.T() * mTimeUnit,
-                        particle.GetWeight(),
-                        (TMCProcess)particle.GetUniqueID(),
-                        particle.GetStatusCode()); // generator status information passed as status code field
+    /** success **/
+    return kTRUE;
   }
 
-  /** success **/
-  return kTRUE;
-}
-
-/*****************************************************************/
+  /*****************************************************************/
 
-Bool_t
-  Generator::boostEvent()
-{
-  /** boost event **/
-
-  /** success **/
-  return kTRUE;
-}
-
-/*****************************************************************/
-
-Bool_t
-  Generator::triggerEvent()
-{
-  /** trigger event **/
+  Bool_t
+    Generator::boostEvent()
+  {
+    /** boost event **/
 
-  /** check trigger presence **/
-  if (mTriggers.size() == 0 && mDeepTriggers.size() == 0) {
+    /** success **/
     return kTRUE;
   }
 
-  /** check trigger mode **/
-  Bool_t triggered;
-  if (mTriggerMode == kTriggerOFF) {
-    return kTRUE;
-  } else if (mTriggerMode == kTriggerOR) {
-    triggered = kFALSE;
-  } else if (mTriggerMode == kTriggerAND) {
-    triggered = kTRUE;
-  } else {
-    return kTRUE;
-  }
+  /*****************************************************************/
 
-  /** loop over triggers **/
-  for (const auto& trigger : mTriggers) {
-    auto retval = trigger(mParticles);
-    if (mTriggerMode == kTriggerOR) {
-      triggered |= retval;
+  Bool_t
+    Generator::triggerEvent()
+  {
+    /** trigger event **/
+
+    /** check trigger presence **/
+    if (mTriggers.size() == 0 && mDeepTriggers.size() == 0) {
+      return kTRUE;
     }
-    if (mTriggerMode == kTriggerAND) {
-      triggered &= retval;
+
+    /** check trigger mode **/
+    Bool_t triggered;
+    if (mTriggerMode == kTriggerOFF) {
+      return kTRUE;
+    } else if (mTriggerMode == kTriggerOR) {
+      triggered = kFALSE;
+    } else if (mTriggerMode == kTriggerAND) {
+      triggered = kTRUE;
+    } else {
+      return kTRUE;
     }
-  }
 
-  /** loop over deep triggers **/
-  for (const auto& trigger : mDeepTriggers) {
-    auto retval = trigger(mInterface, mInterfaceName);
-    if (mTriggerMode == kTriggerOR) {
-      triggered |= retval;
+    /** loop over triggers **/
+    for (const auto& trigger : mTriggers) {
+      auto retval = trigger(mParticles);
+      if (mTriggerMode == kTriggerOR) {
+        triggered |= retval;
+      }
+      if (mTriggerMode == kTriggerAND) {
+        triggered &= retval;
+      }
     }
-    if (mTriggerMode == kTriggerAND) {
-      triggered &= retval;
+
+    /** loop over deep triggers **/
+    for (const auto& trigger : mDeepTriggers) {
+      auto retval = trigger(mInterface, mInterfaceName);
+      if (mTriggerMode == kTriggerOR) {
+        triggered |= retval;
+      }
+      if (mTriggerMode == kTriggerAND) {
+        triggered &= retval;
+      }
     }
-  }
 
-  /** return **/
-  return triggered;
-}
+    /** return **/
+    return triggered;
+  }
 
-/*****************************************************************/
+  /*****************************************************************/
 
-void Generator::addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription)
-{
-  if (subGeneratorId < 0) {
-    LOG(fatal) << "Sub-generator IDs must be >= 0, instead, passed value is " << subGeneratorId;
+  void Generator::addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription)
+  {
+    if (subGeneratorId < 0) {
+      LOG(fatal) << "Sub-generator IDs must be >= 0, instead, passed value is " << subGeneratorId;
+    }
+    mSubGeneratorsIdToDesc.insert({subGeneratorId, subGeneratorDescription});
   }
-  mSubGeneratorsIdToDesc.insert({subGeneratorId, subGeneratorDescription});
-}
 
-/*****************************************************************/
+  /*****************************************************************/
 
-void Generator::updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const
-{
-  if (mSubGeneratorId < 0) {
-    return;
+  void Generator::updateSubGeneratorInformation(o2::dataformats::MCEventHeader * header) const
+  {
+    if (mSubGeneratorId < 0) {
+      return;
+    }
+    header->putInfo<int>(o2::mcgenid::GeneratorProperty::SUBGENERATORID, mSubGeneratorId);
+    header->putInfo<std::unordered_map<int, std::string>>(o2::mcgenid::GeneratorProperty::SUBGENERATORDESCRIPTIONMAP, mSubGeneratorsIdToDesc);
   }
-  header->putInfo<int>(o2::mcgenid::GeneratorProperty::SUBGENERATORID, mSubGeneratorId);
-  header->putInfo<std::unordered_map<int, std::string>>(o2::mcgenid::GeneratorProperty::SUBGENERATORDESCRIPTIONMAP, mSubGeneratorsIdToDesc);
-}
 
-/*****************************************************************/
-/*****************************************************************/
+  /*****************************************************************/
+  /*****************************************************************/
 
 } /* namespace eventgen */
 } /* namespace o2 */
diff --git a/Generators/src/GeneratorsLinkDef.h b/Generators/src/GeneratorsLinkDef.h
index 24b3f2e452498..97896d8225042 100644
--- a/Generators/src/GeneratorsLinkDef.h
+++ b/Generators/src/GeneratorsLinkDef.h
@@ -35,7 +35,7 @@
 #pragma link C++ class o2::eventgen::GeneratorFromEventPool + ;
 #pragma link C++ class o2::eventgen::GeneratorEventPoolParam + ;
 #pragma link C++ class o2::eventgen::EventPoolGenConfig + ;
-#ifdef GENERATORS_WITH_TPCLOOPERS
+#ifdef GENERATORS_WITH_ONNXRUNTIME
 #pragma link C++ class o2::eventgen::GenTPCLoopers + ;
 #pragma link C++ class o2::eventgen::GenTPCLoopersParam + ;
 #endif
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
index 109461ab71dfa..4eacb7674599c 100644
--- a/Generators/src/TPCLoopers.cxx
+++ b/Generators/src/TPCLoopers.cxx
@@ -382,6 +382,9 @@ void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number)
       if (mInteractionTimeRecords.empty()) {
         LOG(error) << "Error: No interaction time records found in the collision context!";
         exit(1);
+      } else {
+        LOG(info) << "Interaction Time records has " << mInteractionTimeRecords.size() << " entries.";
+        mCollisionContext->printCollisionSummary();
       }
       for (int c = 0; c < mInteractionTimeRecords.size() - 1; c++) {
         mIntTimeRecMean += mInteractionTimeRecords[c + 1].bc2ns() - mInteractionTimeRecords[c].bc2ns();

From 707f03c2236c902b0042dd523ab0fde29445be06 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 5 Jan 2026 10:21:41 +0100
Subject: [PATCH 1173/1764] Revert "First implementation of loopers inclusion
 in base Generator class"

This reverts commit b8c867dbb27d08e9ecf3134aeb72886fbb3c878c.
---
 .../SimConfig/include/SimConfig/SimConfig.h   |   3 -
 Common/SimConfig/src/SimConfig.cxx            |   2 -
 Generators/CMakeLists.txt                     |  13 -
 Generators/include/Generators/Generator.h     |  13 -
 .../include/Generators/TPCLoopersParam.h      |  48 --
 Generators/include/TPCLoopers.h               | 127 -----
 .../share/egconfig/ScalerComptonParams.json   |  28 --
 .../share/egconfig/ScalerPairParams.json      |  34 --
 Generators/share/egconfig/gaussian_params.csv |   4 -
 Generators/share/egconfig/poisson_params.csv  |   3 -
 Generators/src/Generator.cxx                  | 442 ++++++------------
 Generators/src/GeneratorsLinkDef.h            |   4 -
 Generators/src/TPCLoopers.cxx                 | 417 -----------------
 Generators/src/TPCLoopersParam.cxx            |  15 -
 14 files changed, 146 insertions(+), 1007 deletions(-)
 delete mode 100644 Generators/include/Generators/TPCLoopersParam.h
 delete mode 100644 Generators/include/TPCLoopers.h
 delete mode 100644 Generators/share/egconfig/ScalerComptonParams.json
 delete mode 100644 Generators/share/egconfig/ScalerPairParams.json
 delete mode 100644 Generators/share/egconfig/gaussian_params.csv
 delete mode 100644 Generators/share/egconfig/poisson_params.csv
 delete mode 100644 Generators/src/TPCLoopers.cxx
 delete mode 100644 Generators/src/TPCLoopersParam.cxx

diff --git a/Common/SimConfig/include/SimConfig/SimConfig.h b/Common/SimConfig/include/SimConfig/SimConfig.h
index 8642a0e5bc225..be88d9fbd8c33 100644
--- a/Common/SimConfig/include/SimConfig/SimConfig.h
+++ b/Common/SimConfig/include/SimConfig/SimConfig.h
@@ -52,7 +52,6 @@ struct SimConfigData {
   std::vector<std::string> mActiveModules;            // list of active modules
   std::vector<std::string> mReadoutDetectors;         // list of readout detectors
   std::string mMCEngine;                              // chosen VMC engine
-  bool mNoLoopers = false;                            // Disable automatic TPC loopers
   std::string mGenerator;                             // chosen VMC generator
   std::string mTrigger;                               // chosen VMC generator trigger
   unsigned int mNEvents;                              // number of events to be simulated
@@ -139,8 +138,6 @@ class SimConfig
   // get selected active detectors
   std::vector<std::string> const& getActiveModules() const { return mConfigData.mActiveModules; }
   std::vector<std::string> const& getReadoutDetectors() const { return mConfigData.mReadoutDetectors; }
-  // get loopers veto
-  bool getLoopersVeto() const { return mConfigData.mNoLoopers; }
 
   // static helper functions to determine list of active / readout modules
   // can also be used from outside
diff --git a/Common/SimConfig/src/SimConfig.cxx b/Common/SimConfig/src/SimConfig.cxx
index 5ddc3199e3d4a..15879687872d5 100644
--- a/Common/SimConfig/src/SimConfig.cxx
+++ b/Common/SimConfig/src/SimConfig.cxx
@@ -74,7 +74,6 @@ void SimConfig::initOptions(boost::program_options::options_description& options
     "run", bpo::value<int>()->default_value(-1), "ALICE run number")(
     "asservice", bpo::value<bool>()->default_value(false), "run in service/server mode")(
     "noGeant", bpo::bool_switch(), "prohibits any Geant transport/physics (by using tight cuts)")(
-    "noLoopers", bpo::bool_switch(), "disable automatic TPC loopers")(
     "forwardKine", bpo::bool_switch(), "forward kinematics on a FairMQ channel")(
     "noDiscOutput", bpo::bool_switch(), "switch off writing sim results to disc (useful in combination with forwardKine)");
   options.add_options()("fromCollContext", bpo::value<std::string>()->default_value(""), "Use a pregenerated collision context to infer number of events to simulate, how to embedd them, the vertex position etc. Takes precedence of other options such as \"--nEvents\". The format is COLLISIONCONTEXTFILE.root[:SIGNALNAME] where SIGNALNAME is the event part in the context which is relevant.");
@@ -298,7 +297,6 @@ bool SimConfig::resetFromParsedMap(boost::program_options::variables_map const&
   using o2::detectors::DetID;
   mConfigData.mMCEngine = vm["mcEngine"].as<std::string>();
   mConfigData.mNoGeant = vm["noGeant"].as<bool>();
-  mConfigData.mNoLoopers = vm["noLoopers"].as<bool>();
 
   // Reset modules and detectors as they are anyway re-parsed
   mConfigData.mReadoutDetectors.clear();
diff --git a/Generators/CMakeLists.txt b/Generators/CMakeLists.txt
index 56fe8b8fc2284..02caa63df0d43 100644
--- a/Generators/CMakeLists.txt
+++ b/Generators/CMakeLists.txt
@@ -41,8 +41,6 @@ o2_add_library(Generators
                        src/GeneratorTParticleParam.cxx
                        src/GeneratorService.cxx
                        src/FlowMapper.cxx
-                       $<$<BOOL:${onnxruntime_FOUND}>:src/TPCLoopers.cxx>
-                       $<$<BOOL:${onnxruntime_FOUND}>:src/TPCLoopersParam.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/DecayerPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8Param.cxx>
@@ -55,7 +53,6 @@ o2_add_library(Generators
                PUBLIC_LINK_LIBRARIES FairRoot::Base O2::SimConfig O2::CommonUtils O2::DetectorsBase O2::ZDCBase
                                      O2::SimulationDataFormat ${pythiaTarget} ${hepmcTarget}
                                      FairRoot::Gen
-                                     $<$<BOOL:${onnxruntime_FOUND}>:onnxruntime::onnxruntime>
                TARGETVARNAME targetName)
 
 if(pythia_FOUND)
@@ -66,10 +63,6 @@ if(HepMC3_FOUND)
   target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_HEPMC3)
 endif()
 
-if(onnxruntime_FOUND)
-  target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_ONNXRUNTIME)
-endif()
-
 set(headers
     include/Generators/Generator.h
     include/Generators/Trigger.h
@@ -95,12 +88,6 @@ set(headers
     include/Generators/FlowMapper.h
     )
 
-if(onnxruntime_FOUND)
-  list(APPEND headers 
-              include/Generators/TPCLoopers.h
-              include/Generators/TPCLoopersParam.h)
-endif()
-
 if(pythia_FOUND)
   list(APPEND headers
               include/Generators/GeneratorPythia8.h
diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 374d53f324399..bd35a00793e2d 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -17,10 +17,6 @@
 #include "FairGenerator.h"
 #include "TParticle.h"
 #include "Generators/Trigger.h"
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-#include "Generators/TPCLoopers.h"
-#include "Generators/TPCLoopersParam.h"
-#endif
 #include <functional>
 #include <vector>
 #include <unordered_map>
@@ -77,7 +73,6 @@ class Generator : public FairGenerator
   /** methods to override **/
   virtual Bool_t generateEvent() = 0;   // generates event (in structure internal to generator)
   virtual Bool_t importParticles() = 0; // fills the mParticles vector (transfer from generator state)
-  Bool_t loopers();                     // adds loopers to the event in case TPC is used
   virtual void updateHeader(o2::dataformats::MCEventHeader* eventHeader) {};
   Bool_t triggerEvent();
 
@@ -159,8 +154,6 @@ class Generator : public FairGenerator
  private:
   void updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const;
 
-  // loopers flag
-  Bool_t mAddLoopers = kFALSE;
   // collect an ID and a short description of sub-generator entities
   std::unordered_map<int, std::string> mSubGeneratorsIdToDesc;
   // the current ID of the sub-generator used in the current event (if applicable)
@@ -169,12 +162,6 @@ class Generator : public FairGenerator
   // global static information about (upper limit of) number of events to be generated
   static unsigned int gTotalNEvents;
 
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-  // Loopers generator instance
-  std::unique_ptr<o2::eventgen::GenTPCLoopers> mLoopersGen = nullptr;
-#endif
-  void initLoopersGen();
-
   ClassDefOverride(Generator, 2);
 
 }; /** class Generator **/
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
deleted file mode 100644
index ceeea201538b2..0000000000000
--- a/Generators/include/Generators/TPCLoopersParam.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author M+Giacalone - September 2025
-
-#ifndef ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
-#define ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
-
-#include "CommonUtils/ConfigurableParam.h"
-#include "CommonUtils/ConfigurableParamHelper.h"
-
-namespace o2
-{
-namespace eventgen
-{
-
-/**
- ** a parameter class/struct to keep the settings of
- ** the tpc loopers event-generator and
- ** allow the user to modify them
- **/
-struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
-  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";  // ONNX model for e+e- pair production
-  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton"; // ONNX model for Compton scattering
-  std::string poisson = "${O2_ROOT}/share/Generators/egconfig/poisson_params.csv"; // file with Poissonian parameters
-  std::string gauss = "${O2_ROOT}/share/Generators/egconfig/gaussian_params.csv"; // file with Gaussian parameters
-  std::string scaler_pair = "${O2_ROOT}/share/Generators/egconfig/ScalerPairParams.json"; // file with scaler parameters for e+e- pair production
-  std::string scaler_compton = "${O2_ROOT}/share/Generators/egconfig/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
-  bool flat_gas = true; // if true, the gas density is considered flat in the TPC volume
-  int nFlatGasLoopers = 500;  // number of loopers to be generated per event in case of flat gas
-  float fraction_pairs = 0.08; // fraction of loopers
-  std::array<float, 2> multiplier = {1., 1.}; // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
-  std::array<unsigned int, 2> fixedNLoopers = {1, 1}; // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
-  O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
-};
-
-} // end namespace eventgen
-} // end namespace o2
-
-#endif // ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
diff --git a/Generators/include/TPCLoopers.h b/Generators/include/TPCLoopers.h
deleted file mode 100644
index 70146a82baf60..0000000000000
--- a/Generators/include/TPCLoopers.h
+++ /dev/null
@@ -1,127 +0,0 @@
-#ifndef ALICEO2_EVENTGEN_TPCLOOPERS_H_
-#define ALICEO2_EVENTGEN_TPCLOOPERS_H_
-
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-#include <onnxruntime_cxx_api.h>
-#endif
-#include <iostream>
-#include <vector>
-#include <fstream>
-#include <rapidjson/document.h>
-#include "CCDB/CCDBTimeStampUtils.h"
-#include "CCDB/CcdbApi.h"
-#include "DetectorsRaw/HBFUtils.h"
-#include "TRandom3.h"
-#include "TDatabasePDG.h"
-#include <SimulationDataFormat/DigitizationContext.h>
-#include <SimulationDataFormat/ParticleStatus.h>
-#include "SimulationDataFormat/MCGenProperties.h"
-#include "TParticle.h"
-#include <filesystem>
-
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-// Static Ort::Env instance for multiple onnx model loading
-extern Ort::Env global_env;
-#endif
-
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-// This class is responsible for loading the scaler parameters from a JSON file
-// and applying the inverse transformation to the generated data.
-struct Scaler
-{
-    std::vector<double> normal_min;
-    std::vector<double> normal_max;
-    std::vector<double> outlier_center;
-    std::vector<double> outlier_scale;
-
-    void load(const std::string &filename);
-
-    std::vector<double> inverse_transform(const std::vector<double> &input);
-
-private:
-    std::vector<double> jsonArrayToVector(const rapidjson::Value &jsonArray);
-};
-
-// This class loads the ONNX model and generates samples using it.
-class ONNXGenerator
-{
-public:
-    ONNXGenerator(Ort::Env &shared_env, const std::string &model_path);
-
-    std::vector<double> generate_sample();
-
-private:
-    Ort::Env &env;
-    Ort::Session session;
-    TRandom3 rand_gen;
-};
-#endif // GENERATORS_WITH_ONNXRUNTIME
-
-namespace o2
-{
-namespace eventgen
-{
-
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-class GenTPCLoopers
-{
-    public:
-        GenTPCLoopers(std::string model_pairs = "tpcloopmodel.onnx", std::string model_compton = "tpcloopmodelcompton.onnx",
-                      std::string poisson = "poisson.csv", std::string gauss = "gauss.csv", std::string scaler_pair = "scaler_pair.json",
-                      std::string scaler_compton = "scaler_compton.json");
-    
-        Bool_t generateEvent();
-
-        Bool_t generateEvent(double &time_limit);
-
-        std::vector<TParticle> importParticles();
-
-        unsigned int PoissonPairs();
-
-        unsigned int GaussianElectrons();
-
-        void SetNLoopers(unsigned int &nsig_pair, unsigned int &nsig_compton);
-
-        void SetMultiplier(std::array<float, 2> &mult);
-
-        void setFlatGas(Bool_t &flat, const Int_t &number = -1);
-
-        void setFractionPairs(float &fractionPairs);
-
-    private:
-        std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
-        std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
-        std::unique_ptr<Scaler> mScaler_pair = nullptr;
-        std::unique_ptr<Scaler> mScaler_compton = nullptr;
-        double mPoisson[3] = {0.0, 0.0, 0.0}; // Mu, Min and Max of Poissonian
-        double mGauss[4] = {0.0, 0.0, 0.0, 0.0}; // Mean, Std, Min, Max
-        std::vector<std::vector<double>> mGenPairs;
-        std::vector<std::vector<double>> mGenElectrons;
-        unsigned int mNLoopersPairs = -1;
-        unsigned int mNLoopersCompton = -1;
-        std::array<float, 2> mMultiplier = {1., 1.};
-        bool mPoissonSet = false;
-        bool mGaussSet = false;
-        // Random number generator
-        TRandom3 mRandGen;
-        // Masses of the electrons and positrons
-        TDatabasePDG *mPDG = TDatabasePDG::Instance();
-        double mMass_e = mPDG->GetParticle(11)->Mass();
-        double mMass_p = mPDG->GetParticle(-11)->Mass();
-        int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
-        TFile *mContextFile = nullptr;                                  // Input collision context file
-        o2::steer::DigitizationContext *mCollisionContext = nullptr;    // Pointer to the digitization context
-        std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
-        Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
-        Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
-        double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
-        double mTimeLimit = 0.0;                                        // Time limit for the current event
-        double mTimeEnd = 0.0;                                          // Time limit for the last event
-        float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
-};
-#endif // GENERATORS_WITH_ONNXRUNTIME
-
-} // namespace eventgen
-} // namespace o2
-
-#endif // ALICEO2_EVENTGEN_TPCLOOPERS_H_
\ No newline at end of file
diff --git a/Generators/share/egconfig/ScalerComptonParams.json b/Generators/share/egconfig/ScalerComptonParams.json
deleted file mode 100644
index d8e654847f46e..0000000000000
--- a/Generators/share/egconfig/ScalerComptonParams.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-    "normal": {
-        "min": [
-            -0.0108811147511005,
-            -0.0098758740350604,
-            -0.0103233363479375,
-            -260.0542297363281,
-            -259.80059814453125
-        ],
-        "max": [
-            0.0108060473576188,
-            0.0103057539090514,
-            0.0106524610891938,
-            260.0343933105469,
-            259.62890625
-        ]
-    },
-    "outlier": {
-        "center": [
-            -71.39387130737305,
-            96791.23828125
-        ],
-        "scale": [
-            265.9389114379883,
-            230762.30981445312
-        ]
-    }
-}
\ No newline at end of file
diff --git a/Generators/share/egconfig/ScalerPairParams.json b/Generators/share/egconfig/ScalerPairParams.json
deleted file mode 100644
index 61434bfa2462e..0000000000000
--- a/Generators/share/egconfig/ScalerPairParams.json
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-    "normal": {
-        "min": [
-            -0.0073022879660129,
-            -0.0077305701561272,
-            -0.0076750442385673,
-            -0.0082916170358657,
-            -0.0079681202769279,
-            -0.0077468422241508,
-            -255.6164093017578,
-            -252.9441680908203
-        ],
-        "max": [
-            0.007688719779253,
-            0.0077241472899913,
-            0.0075828479602932,
-            0.00813714787364,
-            0.0083825681358575,
-            0.0073839174583554,
-            256.2904968261719,
-            253.4925842285156
-        ]
-    },
-    "outlier": {
-        "center": [
-            -79.66580963134766,
-            141535.640625
-        ],
-        "scale": [
-            250.8921127319336,
-            222363.16015625
-        ]
-    }
-}
\ No newline at end of file
diff --git a/Generators/share/egconfig/gaussian_params.csv b/Generators/share/egconfig/gaussian_params.csv
deleted file mode 100644
index 8e07c22dd30bf..0000000000000
--- a/Generators/share/egconfig/gaussian_params.csv
+++ /dev/null
@@ -1,4 +0,0 @@
-9.611554230339172022e+01
-1.963570744941765867e+01
-4.300000000000000000e+01
-1.690000000000000000e+02
diff --git a/Generators/share/egconfig/poisson_params.csv b/Generators/share/egconfig/poisson_params.csv
deleted file mode 100644
index ef26bd973d34c..0000000000000
--- a/Generators/share/egconfig/poisson_params.csv
+++ /dev/null
@@ -1,3 +0,0 @@
-3.165383056343737511e+00
-1.000000000000000000e+00
-1.200000000000000000e+01
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 153ef5cd5e35e..9204ede98215e 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -17,14 +17,11 @@
 #include "SimulationDataFormat/MCEventHeader.h"
 #include "SimulationDataFormat/ParticleStatus.h"
 #include "SimulationDataFormat/MCGenProperties.h"
-#include <SimConfig/SimConfig.h>
 #include "FairPrimaryGenerator.h"
 #include <fairlogger/Logger.h>
 #include <cmath>
 #include "TClonesArray.h"
 #include "TParticle.h"
-#include "TSystem.h"
-#include "TGrid.h"
 
 namespace o2
 {
@@ -42,18 +39,6 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
   /** default constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
-  auto simConfig = o2::conf::SimConfig::Instance();
-  auto noLoops = simConfig.getLoopersVeto();
-  if (!noLoops) {
-    bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
-    if (transport) {
-      bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
-      if (tpcActive) {
-        mAddLoopers = kTRUE;
-        initLoopersGen();
-      }
-    }
-  }
 }
 
 /*****************************************************************/
@@ -64,102 +49,6 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
   /** constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
-  auto simConfig = o2::conf::SimConfig::Instance();
-  auto noLoops = simConfig.getLoopersVeto();
-  if (!noLoops) {
-    bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
-    if (transport) {
-      bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
-      if (tpcActive) {
-        mAddLoopers = kTRUE;
-        initLoopersGen();
-      }
-    }
-  }
-}
-
-/*****************************************************************/
-
-void Generator::initLoopersGen()
-{
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-  // Expand all environment paths
-  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
-  std::string model_pairs = gSystem->ExpandPathName(loopersParam.model_pairs.c_str());
-  std::string model_compton = gSystem->ExpandPathName(loopersParam.model_compton.c_str());
-  const auto& scaler_pair = gSystem->ExpandPathName(loopersParam.scaler_pair.c_str());
-  const auto& scaler_compton = gSystem->ExpandPathName(loopersParam.scaler_compton.c_str());
-  const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
-  const auto& gauss = gSystem->ExpandPathName(loopersParam.gauss.c_str());
-  auto flat_gas = loopersParam.flat_gas;
-  const auto& nFlatGasLoopers = loopersParam.nFlatGasLoopers;
-  auto fraction_pairs = loopersParam.fraction_pairs;
-  auto multiplier = loopersParam.multiplier;
-  auto fixedNLoopers = loopersParam.fixedNLoopers;
-  const std::array<std::string, 2> models = {model_pairs, model_compton};
-  const std::array<std::string, 2> local_names = {"WGANpair.onnx", "WGANcompton.onnx"};
-  const std::array<bool, 2> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://")};
-  const std::array<bool, 2> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://")};
-  if (std::any_of(isAlien.begin(), isAlien.end(), [](bool v) { return v; })) {
-    if (!gGrid) {
-      TGrid::Connect("alien://");
-      if (!gGrid) {
-        LOG(fatal) << "AliEn connection failed, check token.";
-        exit(1);
-      }
-    }
-    for (size_t i = 0; i < models.size(); ++i) {
-      if (isAlien[i] && !TFile::Cp(models[i].c_str(), local_names[i].c_str())) {
-        LOG(fatal) << "Error: Model file " << models[i] << " does not exist!";
-        exit(1);
-      }
-    }
-  }
-  if (std::any_of(isCCDB.begin(), isCCDB.end(), [](bool v) { return v; })) {
-    o2::ccdb::CcdbApi ccdb_api;
-    ccdb_api.init("http://alice-ccdb.cern.ch");
-    for (size_t i = 0; i < models.size(); ++i) {
-      if (isCCDB[i]) {
-        auto model_path = models[i].substr(7); // Remove "ccdb://"
-        // Treat filename if provided in the CCDB path
-        auto extension = model_path.find(".onnx");
-        if (extension != std::string::npos) {
-          auto last_slash = model_path.find_last_of('/');
-          model_path = model_path.substr(0, last_slash);
-        }
-        std::map<std::string, std::string> filter;
-        if (!ccdb_api.retrieveBlob(model_path, "./", filter, o2::ccdb::getCurrentTimestamp(), false, local_names[i].c_str())) {
-          LOG(fatal) << "Error: issues in retrieving " << model_path << " from CCDB!";
-          exit(1);
-        }
-      }
-    }
-  }
-  model_pairs = isAlien[0] || isCCDB[0] ? local_names[0] : model_pairs;
-  model_compton = isAlien[1] || isCCDB[1] ? local_names[1] : model_compton;
-  try {
-    // Create the TPC loopers generator with the provided parameters
-    mLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
-
-    // Configure the generator with flat gas loopers if enabled (default)
-    if (flat_gas) {
-      mLoopersGen->setFlatGas(flat_gas, nFlatGasLoopers);
-      mLoopersGen->setFractionPairs(fraction_pairs);
-    } else {
-      // Otherwise, Poisson+Gauss sampling or fixed number of loopers will be used
-      // Multiplier is applied only with distribution sampling
-      // This configuration can be used for testing purposes, in all other cases flat gas is recommended
-      mLoopersGen->SetNLoopers(fixedNLoopers[0], fixedNLoopers[1]);
-      mLoopersGen->SetMultiplier(multiplier);
-    }
-    LOG(info) << "TPC Loopers generator initialized successfully";
-  } catch (const std::exception& e) {
-    LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
-    mLoopersGen.reset();
-  }
-#else
-  LOG(warn) << "ONNX Runtime support not available, cannot initialize TPC loopers generator";
-#endif
 }
 
 /*****************************************************************/
@@ -176,230 +65,191 @@ Bool_t
 /*****************************************************************/
 
 Bool_t
-  Generator::loopers()
+  Generator::ReadEvent(FairPrimaryGenerator* primGen)
 {
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-  if (!mLoopersGen) {
-    LOG(error) << "Loopers generator not initialized";
-    return kFALSE;
+  /** read event **/
+
+  /** endless generate-and-trigger loop **/
+  while (true) {
+    mReadEventCounter++;
+
+    /** clear particle vector **/
+    mParticles.clear();
+
+    /** reset the sub-generator ID **/
+    mSubGeneratorId = -1;
+
+    /** generate event **/
+    if (!generateEvent()) {
+      LOG(error) << "ReadEvent failed in generateEvent";
+      return kFALSE;
+    }
+
+    /** import particles **/
+    if (!importParticles()) {
+      LOG(error) << "ReadEvent failed in importParticles";
+      return kFALSE;
+    }
+
+    if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
+      LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
+    }
+
+    if (!mSubGeneratorsIdToDesc.empty() && mSubGeneratorId < 0) {
+      LOG(fatal) << "ReadEvent failed because SubGenerator description given but sub-generator not set";
+    }
+
+    /** trigger event **/
+    if (triggerEvent()) {
+      mTriggerOkHook(mParticles, mReadEventCounter);
+      break;
+    } else {
+      mTriggerFalseHook(mParticles, mReadEventCounter);
+    }
   }
 
-  // Generate loopers using the initialized TPC loopers generator
-  if (!mLoopersGen->generateEvent()) {
-    LOG(error) << "Failed to generate loopers event";
+  /** add tracks **/
+  if (!addTracks(primGen)) {
+    LOG(error) << "ReadEvent failed in addTracks";
     return kFALSE;
   }
-  const auto& looperParticles = mLoopersGen->importParticles();
-  if (looperParticles.empty()) {
-    LOG(error) << "Failed to import loopers particles";
+
+  /** update header **/
+  auto header = primGen->GetEvent();
+  auto o2header = dynamic_cast<o2::dataformats::MCEventHeader*>(header);
+  if (!header) {
+    LOG(fatal) << "MC event header is not a 'o2::dataformats::MCEventHeader' object";
     return kFALSE;
   }
-  // Append the generated looper particles to the main particle list
-  mParticles.insert(mParticles.end(), looperParticles.begin(), looperParticles.end());
+  updateHeader(o2header);
+  updateSubGeneratorInformation(o2header);
 
-  LOG(debug) << "Added " << looperParticles.size() << " looper particles";
-  return kTRUE;
-#else
-  LOG(warn) << "ONNX Runtime support not available, skipping TPC loopers generation";
+  /** success **/
   return kTRUE;
-#endif
 }
-  /*****************************************************************/
-
-  Bool_t
-    Generator::ReadEvent(FairPrimaryGenerator * primGen)
-  {
-    /** read event **/
-
-    /** endless generate-and-trigger loop **/
-    while (true) {
-      mReadEventCounter++;
-
-      /** clear particle vector **/
-      mParticles.clear();
-
-      /** reset the sub-generator ID **/
-      mSubGeneratorId = -1;
-
-      /** generate event **/
-      if (!generateEvent()) {
-        LOG(error) << "ReadEvent failed in generateEvent";
-        return kFALSE;
-      }
-
-      /** import particles **/
-      if (!importParticles()) {
-        LOG(error) << "ReadEvent failed in importParticles";
-        return kFALSE;
-      }
-
-      /** Add loopers **/
-      if(mAddLoopers){
-        if (!loopers()) {
-          LOG(error) << "ReadEvent failed in loopers";
-          return kFALSE;
-        }
-      }
-
-      if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
-        LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
-      }
-
-      if (!mSubGeneratorsIdToDesc.empty() && mSubGeneratorId < 0) {
-        LOG(fatal) << "ReadEvent failed because SubGenerator description given but sub-generator not set";
-      }
-
-      /** trigger event **/
-      if (triggerEvent()) {
-        mTriggerOkHook(mParticles, mReadEventCounter);
-        break;
-      } else {
-        mTriggerFalseHook(mParticles, mReadEventCounter);
-      }
-    }
 
-    /** add tracks **/
-    if (!addTracks(primGen)) {
-      LOG(error) << "ReadEvent failed in addTracks";
-      return kFALSE;
-    }
+/*****************************************************************/
 
-    /** update header **/
-    auto header = primGen->GetEvent();
-    auto o2header = dynamic_cast<o2::dataformats::MCEventHeader*>(header);
-    if (!header) {
-      LOG(fatal) << "MC event header is not a 'o2::dataformats::MCEventHeader' object";
-      return kFALSE;
-    }
-    updateHeader(o2header);
-    updateSubGeneratorInformation(o2header);
+Bool_t
+  Generator::addTracks(FairPrimaryGenerator* primGen)
+{
+  /** add tracks **/
 
-    /** success **/
-    return kTRUE;
+  auto o2primGen = dynamic_cast<PrimaryGenerator*>(primGen);
+  if (!o2primGen) {
+    LOG(fatal) << "PrimaryGenerator is not a o2::eventgen::PrimaryGenerator";
+    return kFALSE;
   }
 
-  /*****************************************************************/
+  /** loop over particles **/
+  for (const auto& particle : mParticles) {
+    o2primGen->AddTrack(particle.GetPdgCode(),
+                        particle.Px() * mMomentumUnit,
+                        particle.Py() * mMomentumUnit,
+                        particle.Pz() * mMomentumUnit,
+                        particle.Vx() * mPositionUnit,
+                        particle.Vy() * mPositionUnit,
+                        particle.Vz() * mPositionUnit,
+                        particle.GetMother(0),
+                        particle.GetMother(1),
+                        particle.GetDaughter(0),
+                        particle.GetDaughter(1),
+                        particle.TestBit(ParticleStatus::kToBeDone),
+                        particle.Energy() * mEnergyUnit,
+                        particle.T() * mTimeUnit,
+                        particle.GetWeight(),
+                        (TMCProcess)particle.GetUniqueID(),
+                        particle.GetStatusCode()); // generator status information passed as status code field
+  }
 
-  Bool_t
-    Generator::addTracks(FairPrimaryGenerator * primGen)
-  {
-    /** add tracks **/
+  /** success **/
+  return kTRUE;
+}
 
-    auto o2primGen = dynamic_cast<PrimaryGenerator*>(primGen);
-    if (!o2primGen) {
-      LOG(fatal) << "PrimaryGenerator is not a o2::eventgen::PrimaryGenerator";
-      return kFALSE;
-    }
+/*****************************************************************/
 
-    /** loop over particles **/
-    for (const auto& particle : mParticles) {
-      o2primGen->AddTrack(particle.GetPdgCode(),
-                          particle.Px() * mMomentumUnit,
-                          particle.Py() * mMomentumUnit,
-                          particle.Pz() * mMomentumUnit,
-                          particle.Vx() * mPositionUnit,
-                          particle.Vy() * mPositionUnit,
-                          particle.Vz() * mPositionUnit,
-                          particle.GetMother(0),
-                          particle.GetMother(1),
-                          particle.GetDaughter(0),
-                          particle.GetDaughter(1),
-                          particle.TestBit(ParticleStatus::kToBeDone),
-                          particle.Energy() * mEnergyUnit,
-                          particle.T() * mTimeUnit,
-                          particle.GetWeight(),
-                          (TMCProcess)particle.GetUniqueID(),
-                          particle.GetStatusCode()); // generator status information passed as status code field
-    }
+Bool_t
+  Generator::boostEvent()
+{
+  /** boost event **/
 
-    /** success **/
-    return kTRUE;
-  }
+  /** success **/
+  return kTRUE;
+}
 
-  /*****************************************************************/
+/*****************************************************************/
 
-  Bool_t
-    Generator::boostEvent()
-  {
-    /** boost event **/
+Bool_t
+  Generator::triggerEvent()
+{
+  /** trigger event **/
 
-    /** success **/
+  /** check trigger presence **/
+  if (mTriggers.size() == 0 && mDeepTriggers.size() == 0) {
     return kTRUE;
   }
 
-  /*****************************************************************/
-
-  Bool_t
-    Generator::triggerEvent()
-  {
-    /** trigger event **/
+  /** check trigger mode **/
+  Bool_t triggered;
+  if (mTriggerMode == kTriggerOFF) {
+    return kTRUE;
+  } else if (mTriggerMode == kTriggerOR) {
+    triggered = kFALSE;
+  } else if (mTriggerMode == kTriggerAND) {
+    triggered = kTRUE;
+  } else {
+    return kTRUE;
+  }
 
-    /** check trigger presence **/
-    if (mTriggers.size() == 0 && mDeepTriggers.size() == 0) {
-      return kTRUE;
+  /** loop over triggers **/
+  for (const auto& trigger : mTriggers) {
+    auto retval = trigger(mParticles);
+    if (mTriggerMode == kTriggerOR) {
+      triggered |= retval;
     }
-
-    /** check trigger mode **/
-    Bool_t triggered;
-    if (mTriggerMode == kTriggerOFF) {
-      return kTRUE;
-    } else if (mTriggerMode == kTriggerOR) {
-      triggered = kFALSE;
-    } else if (mTriggerMode == kTriggerAND) {
-      triggered = kTRUE;
-    } else {
-      return kTRUE;
+    if (mTriggerMode == kTriggerAND) {
+      triggered &= retval;
     }
+  }
 
-    /** loop over triggers **/
-    for (const auto& trigger : mTriggers) {
-      auto retval = trigger(mParticles);
-      if (mTriggerMode == kTriggerOR) {
-        triggered |= retval;
-      }
-      if (mTriggerMode == kTriggerAND) {
-        triggered &= retval;
-      }
+  /** loop over deep triggers **/
+  for (const auto& trigger : mDeepTriggers) {
+    auto retval = trigger(mInterface, mInterfaceName);
+    if (mTriggerMode == kTriggerOR) {
+      triggered |= retval;
     }
-
-    /** loop over deep triggers **/
-    for (const auto& trigger : mDeepTriggers) {
-      auto retval = trigger(mInterface, mInterfaceName);
-      if (mTriggerMode == kTriggerOR) {
-        triggered |= retval;
-      }
-      if (mTriggerMode == kTriggerAND) {
-        triggered &= retval;
-      }
+    if (mTriggerMode == kTriggerAND) {
+      triggered &= retval;
     }
-
-    /** return **/
-    return triggered;
   }
 
-  /*****************************************************************/
+  /** return **/
+  return triggered;
+}
+
+/*****************************************************************/
 
-  void Generator::addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription)
-  {
-    if (subGeneratorId < 0) {
-      LOG(fatal) << "Sub-generator IDs must be >= 0, instead, passed value is " << subGeneratorId;
-    }
-    mSubGeneratorsIdToDesc.insert({subGeneratorId, subGeneratorDescription});
+void Generator::addSubGenerator(int subGeneratorId, std::string const& subGeneratorDescription)
+{
+  if (subGeneratorId < 0) {
+    LOG(fatal) << "Sub-generator IDs must be >= 0, instead, passed value is " << subGeneratorId;
   }
+  mSubGeneratorsIdToDesc.insert({subGeneratorId, subGeneratorDescription});
+}
 
-  /*****************************************************************/
+/*****************************************************************/
 
-  void Generator::updateSubGeneratorInformation(o2::dataformats::MCEventHeader * header) const
-  {
-    if (mSubGeneratorId < 0) {
-      return;
-    }
-    header->putInfo<int>(o2::mcgenid::GeneratorProperty::SUBGENERATORID, mSubGeneratorId);
-    header->putInfo<std::unordered_map<int, std::string>>(o2::mcgenid::GeneratorProperty::SUBGENERATORDESCRIPTIONMAP, mSubGeneratorsIdToDesc);
+void Generator::updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const
+{
+  if (mSubGeneratorId < 0) {
+    return;
   }
+  header->putInfo<int>(o2::mcgenid::GeneratorProperty::SUBGENERATORID, mSubGeneratorId);
+  header->putInfo<std::unordered_map<int, std::string>>(o2::mcgenid::GeneratorProperty::SUBGENERATORDESCRIPTIONMAP, mSubGeneratorsIdToDesc);
+}
 
-  /*****************************************************************/
-  /*****************************************************************/
+/*****************************************************************/
+/*****************************************************************/
 
 } /* namespace eventgen */
 } /* namespace o2 */
diff --git a/Generators/src/GeneratorsLinkDef.h b/Generators/src/GeneratorsLinkDef.h
index 97896d8225042..2b8d42f86bf9b 100644
--- a/Generators/src/GeneratorsLinkDef.h
+++ b/Generators/src/GeneratorsLinkDef.h
@@ -35,10 +35,6 @@
 #pragma link C++ class o2::eventgen::GeneratorFromEventPool + ;
 #pragma link C++ class o2::eventgen::GeneratorEventPoolParam + ;
 #pragma link C++ class o2::eventgen::EventPoolGenConfig + ;
-#ifdef GENERATORS_WITH_ONNXRUNTIME
-#pragma link C++ class o2::eventgen::GenTPCLoopers + ;
-#pragma link C++ class o2::eventgen::GenTPCLoopersParam + ;
-#endif
 #pragma link C++ class o2::conf::ConfigurableParamPromoter < o2::eventgen::GeneratorEventPoolParam, o2::eventgen::EventPoolGenConfig> + ;
 #ifdef GENERATORS_WITH_HEPMC3
 #pragma link C++ class o2::eventgen::GeneratorHepMC + ;
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
deleted file mode 100644
index 4eacb7674599c..0000000000000
--- a/Generators/src/TPCLoopers.cxx
+++ /dev/null
@@ -1,417 +0,0 @@
-#include "Generators/TPCLoopers.h"
-
-// Static Ort::Env instance for multiple onnx model loading
-Ort::Env global_env(ORT_LOGGING_LEVEL_WARNING, "GlobalEnv");
-
-// This class is responsible for loading the scaler parameters from a JSON file
-// and applying the inverse transformation to the generated data.
-
-void Scaler::load(const std::string &filename)
-{
-  std::ifstream file(filename);
-  if (!file.is_open()) {
-    throw std::runtime_error("Error: Could not open scaler file!");
-  }
-
-  std::string json_str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-  file.close();
-
-  rapidjson::Document doc;
-  doc.Parse(json_str.c_str());
-
-  if (doc.HasParseError()) {
-    throw std::runtime_error("Error: JSON parsing failed!");
-  }
-
-  normal_min = jsonArrayToVector(doc["normal"]["min"]);
-  normal_max = jsonArrayToVector(doc["normal"]["max"]);
-  outlier_center = jsonArrayToVector(doc["outlier"]["center"]);
-  outlier_scale = jsonArrayToVector(doc["outlier"]["scale"]);
-  std::vector<double> normal_min;
-  std::vector<double> normal_max;
-  std::vector<double> outlier_center;
-  std::vector<double> outlier_scale;
-}  
-
-std::vector<double> Scaler::inverse_transform(const std::vector<double> &input)
-{
-    std::vector<double> output;
-    for (int i = 0; i < input.size(); ++i)
-    {
-        if (i < input.size() - 2)
-            output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
-        else
-            output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
-    }
-
-    return output;
-}
-
-std::vector<double> Scaler::jsonArrayToVector(const rapidjson::Value &jsonArray)
-{
-    std::vector<double> vec;
-    for (int i = 0; i < jsonArray.Size(); ++i)
-    {
-        vec.push_back(jsonArray[i].GetDouble());
-    }
-    return vec;
-}
-
-// This class loads the ONNX model and generates samples using it.
-
-ONNXGenerator::ONNXGenerator(Ort::Env& shared_env, const std::string& model_path)
-: env(shared_env), session(env, model_path.c_str(), Ort::SessionOptions{})
-{
-    // Create session options
-    Ort::SessionOptions session_options;
-    session = Ort::Session(env, model_path.c_str(), session_options);
-}
-
-std::vector<double> ONNXGenerator::generate_sample()
-{
-    Ort::AllocatorWithDefaultOptions allocator;
-
-    // Generate a latent vector (z)
-    std::vector<float> z(100);
-    for (auto &v : z)
-        v = rand_gen.Gaus(0.0, 1.0);
-
-    // Prepare input tensor
-    std::vector<int64_t> input_shape = {1, 100};
-    // Get memory information
-    Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
-
-    // Create input tensor correctly
-    Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
-        memory_info, z.data(), z.size(), input_shape.data(), input_shape.size());
-    // Run inference
-    const char *input_names[] = {"z"};
-    const char *output_names[] = {"output"};
-    auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, 1);
-
-    // Extract output
-    float *output_data = output_tensors.front().GetTensorMutableData<float>();
-    // Get the size of the output tensor
-    auto output_tensor_info = output_tensors.front().GetTensorTypeAndShapeInfo();
-    size_t output_data_size = output_tensor_info.GetElementCount(); // Total number of elements in the tensor
-    std::vector<double> output;
-    for (int i = 0; i < output_data_size; ++i)
-    {
-        output.push_back(output_data[i]);
-    }
-
-    return output;
-}
-
-namespace o2
-{
-namespace eventgen
-{
-
-GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
-                std::string poisson, std::string gauss, std::string scaler_pair,
-                std::string scaler_compton)
-{
-    // Checking if the model files exist and are not empty
-    std::ifstream model_file[2];
-    model_file[0].open(model_pairs);
-    model_file[1].open(model_compton);
-    if (!model_file[0].is_open() || model_file[0].peek() == std::ifstream::traits_type::eof())
-    {
-        LOG(fatal) << "Error: Pairs model file is empty or does not exist!";
-        exit(1);
-    }
-    if (!model_file[1].is_open() || model_file[1].peek() == std::ifstream::traits_type::eof())
-    {
-        LOG(fatal) << "Error: Compton model file is empty or does not exist!";
-        exit(1);
-    }
-    model_file[0].close();
-    model_file[1].close();
-    // Checking if the scaler files exist and are not empty
-    std::ifstream scaler_file[2];
-    scaler_file[0].open(scaler_pair);
-    scaler_file[1].open(scaler_compton);
-    if (!scaler_file[0].is_open() || scaler_file[0].peek() == std::ifstream::traits_type::eof())
-    {
-        LOG(fatal) << "Error: Pairs scaler file is empty or does not exist!";
-        exit(1);
-    }
-    if (!scaler_file[1].is_open() || scaler_file[1].peek() == std::ifstream::traits_type::eof())
-    {
-        LOG(fatal) << "Error: Compton scaler file is empty or does not exist!";
-        exit(1);
-    }
-    scaler_file[0].close();
-    scaler_file[1].close();
-    // Checking if the poisson file exists and it's not empty
-    if (poisson != "")
-    {
-        std::ifstream poisson_file(poisson);
-        if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof())
-        {
-            LOG(fatal) << "Error: Poisson file is empty or does not exist!";
-            exit(1);
-        }
-        else
-        {
-            poisson_file >> mPoisson[0] >> mPoisson[1] >> mPoisson[2];
-            poisson_file.close();
-            mPoissonSet = true;
-        }
-    }
-    // Checking if the gauss file exists and it's not empty
-    if (gauss != "")
-    {
-        std::ifstream gauss_file(gauss);
-        if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof())
-        {
-            LOG(fatal) << "Error: Gauss file is empty or does not exist!";
-            exit(1);
-        }
-        else
-        {
-            gauss_file >> mGauss[0] >> mGauss[1] >> mGauss[2] >> mGauss[3];
-            gauss_file.close();
-            mGaussSet = true;
-        }
-    }
-    mONNX_pair = std::make_unique<ONNXGenerator>(global_env, model_pairs);
-    mScaler_pair = std::make_unique<Scaler>();
-    mScaler_pair->load(scaler_pair);
-    mONNX_compton = std::make_unique<ONNXGenerator>(global_env, model_compton);
-    mScaler_compton = std::make_unique<Scaler>();
-    mScaler_compton->load(scaler_compton);
-}
-
-Bool_t GenTPCLoopers::generateEvent()
-{
-  // Clear the vector of pairs
-  mGenPairs.clear();
-  // Clear the vector of compton electrons
-  mGenElectrons.clear();
-  if (mFlatGas) {
-    unsigned int nLoopers, nLoopersPairs, nLoopersCompton;
-    LOG(debug) << "mCurrentEvent is " << mCurrentEvent;
-    LOG(debug) << "Current event time: " << ((mCurrentEvent < mInteractionTimeRecords.size() - 1) ? std::to_string(mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns()) : std::to_string(mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns())) << " ns";
-    LOG(debug) << "Current time offset wrt BC: " << mInteractionTimeRecords[mCurrentEvent].getTimeOffsetWrtBC() << " ns";
-    mTimeLimit = (mCurrentEvent < mInteractionTimeRecords.size() - 1) ? mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns() : mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns();
-    // With flat gas the number of loopers are adapted based on time interval widths
-    nLoopers = mFlatGasNumber * (mTimeLimit / mIntTimeRecMean);
-    nLoopersPairs = static_cast<unsigned int>(std::round(nLoopers * mLoopsFractionPairs));
-    nLoopersCompton = nLoopers - nLoopersPairs;
-    SetNLoopers(nLoopersPairs, nLoopersCompton);
-    LOG(info) << "Flat gas loopers: " << nLoopers << " (pairs: " << nLoopersPairs << ", compton: " << nLoopersCompton << ")";
-    generateEvent(mTimeLimit);
-    mCurrentEvent++;
-  } else {
-    // Set number of loopers if poissonian params are available
-    if (mPoissonSet) {
-      mNLoopersPairs = static_cast<unsigned int>(std::round(mMultiplier[0] * PoissonPairs()));
-    }
-    if (mGaussSet) {
-      mNLoopersCompton = static_cast<unsigned int>(std::round(mMultiplier[1] * GaussianElectrons()));
-    }
-    // Generate pairs
-    for (int i = 0; i < mNLoopersPairs; ++i) {
-      std::vector<double> pair = mONNX_pair->generate_sample();
-      // Apply the inverse transformation using the scaler
-      std::vector<double> transformed_pair = mScaler_pair->inverse_transform(pair);
-      mGenPairs.push_back(transformed_pair);
-    }
-    // Generate compton electrons
-    for (int i = 0; i < mNLoopersCompton; ++i) {
-      std::vector<double> electron = mONNX_compton->generate_sample();
-      // Apply the inverse transformation using the scaler
-      std::vector<double> transformed_electron = mScaler_compton->inverse_transform(electron);
-      mGenElectrons.push_back(transformed_electron);
-    }
-  }
-  return true;
-}
-
-Bool_t GenTPCLoopers::generateEvent(double& time_limit)
-{
-  LOG(info) << "Time constraint for loopers: " << time_limit << " ns";
-  // Generate pairs
-  for (int i = 0; i < mNLoopersPairs; ++i) {
-    std::vector<double> pair = mONNX_pair->generate_sample();
-    // Apply the inverse transformation using the scaler
-    std::vector<double> transformed_pair = mScaler_pair->inverse_transform(pair);
-    transformed_pair[9] = gRandom->Uniform(0., time_limit); // Regenerate time, scaling is not needed because time_limit is already in nanoseconds
-    mGenPairs.push_back(transformed_pair);
-  }
-  // Generate compton electrons
-  for (int i = 0; i < mNLoopersCompton; ++i) {
-    std::vector<double> electron = mONNX_compton->generate_sample();
-    // Apply the inverse transformation using the scaler
-    std::vector<double> transformed_electron = mScaler_compton->inverse_transform(electron);
-    transformed_electron[6] = gRandom->Uniform(0., time_limit); // Regenerate time, scaling is not needed because time_limit is already in nanoseconds
-    mGenElectrons.push_back(transformed_electron);
-  }
-  LOG(info) << "Generated Particles with time limit";
-  return true;
-}
-
-std::vector<TParticle> GenTPCLoopers::importParticles()
-{
-  std::vector<TParticle> particles;
-  // Get looper pairs from the event
-  for (auto& pair : mGenPairs) {
-    double px_e, py_e, pz_e, px_p, py_p, pz_p;
-    double vx, vy, vz, time;
-    double e_etot, p_etot;
-    px_e = pair[0];
-    py_e = pair[1];
-    pz_e = pair[2];
-    px_p = pair[3];
-    py_p = pair[4];
-    pz_p = pair[5];
-    vx = pair[6];
-    vy = pair[7];
-    vz = pair[8];
-    time = pair[9];
-    e_etot = TMath::Sqrt(px_e * px_e + py_e * py_e + pz_e * pz_e + mMass_e * mMass_e);
-    p_etot = TMath::Sqrt(px_p * px_p + py_p * py_p + pz_p * pz_p + mMass_p * mMass_p);
-    // Push the electron
-    TParticle electron(11, 1, -1, -1, -1, -1, px_e, py_e, pz_e, e_etot, vx, vy, vz, time / 1e9);
-    electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
-    electron.SetBit(ParticleStatus::kToBeDone, //
-                    o2::mcgenstatus::getHepMCStatusCode(electron.GetStatusCode()) == 1);
-    particles.push_back(electron);
-    // Push the positron
-    TParticle positron(-11, 1, -1, -1, -1, -1, px_p, py_p, pz_p, p_etot, vx, vy, vz, time / 1e9);
-    positron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(positron.GetStatusCode(), 0).fullEncoding);
-    positron.SetBit(ParticleStatus::kToBeDone, //
-                    o2::mcgenstatus::getHepMCStatusCode(positron.GetStatusCode()) == 1);
-    particles.push_back(positron);
-  }
-  // Get compton electrons from the event
-  for (auto& compton : mGenElectrons) {
-    double px, py, pz;
-    double vx, vy, vz, time;
-    double etot;
-    px = compton[0];
-    py = compton[1];
-    pz = compton[2];
-    vx = compton[3];
-    vy = compton[4];
-    vz = compton[5];
-    time = compton[6];
-    etot = TMath::Sqrt(px * px + py * py + pz * pz + mMass_e * mMass_e);
-    // Push the electron
-    TParticle electron(11, 1, -1, -1, -1, -1, px, py, pz, etot, vx, vy, vz, time / 1e9);
-    electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
-    electron.SetBit(ParticleStatus::kToBeDone, //
-                    o2::mcgenstatus::getHepMCStatusCode(electron.GetStatusCode()) == 1);
-    particles.push_back(electron);
-  }
-
-  return particles;
-}
-
-unsigned int GenTPCLoopers::PoissonPairs()
-{
-  unsigned int poissonValue;
-  do {
-    // Generate a Poisson-distributed random number with mean mPoisson[0]
-    poissonValue = mRandGen.Poisson(mPoisson[0]);
-  } while (poissonValue < mPoisson[1] || poissonValue > mPoisson[2]); // Regenerate if out of range
-
-  return poissonValue;
-}
-
-unsigned int GenTPCLoopers::GaussianElectrons()
-{
-  unsigned int gaussValue;
-  do {
-    // Generate a Normal-distributed random number with mean mGass[0] and stddev mGauss[1]
-    gaussValue = mRandGen.Gaus(mGauss[0], mGauss[1]);
-  } while (gaussValue < mGauss[2] || gaussValue > mGauss[3]); // Regenerate if out of range
-
-  return gaussValue;
-}
-
-void GenTPCLoopers::SetNLoopers(unsigned int& nsig_pair, unsigned int& nsig_compton)
-{
-  if (mFlatGas) {
-    mNLoopersPairs = nsig_pair;
-    mNLoopersCompton = nsig_compton;
-  } else {
-    if (mPoissonSet) {
-      LOG(info) << "Poissonian parameters correctly loaded.";
-    } else {
-      mNLoopersPairs = nsig_pair;
-    }
-    if (mGaussSet) {
-      LOG(info) << "Gaussian parameters correctly loaded.";
-    } else {
-      mNLoopersCompton = nsig_compton;
-    }
-  }
-}
-
-void GenTPCLoopers::SetMultiplier(std::array<float, 2>& mult)
-{
-    // Multipliers will work only if the poissonian and gaussian parameters are set
-    // otherwise they will be ignored
-    if (mult[0] < 0 || mult[1] < 0)
-    {
-        LOG(fatal) << "Error: Multiplier values must be non-negative!";
-        exit(1);
-    } else {
-        LOG(info) << "Multiplier values set to: Pair = " << mult[0] << ", Compton = " << mult[1];
-        mMultiplier[0] = mult[0];
-        mMultiplier[1] = mult[1];
-    }
-}
-
-void GenTPCLoopers::setFlatGas(Bool_t& flat, const Int_t& number)
-{
-  mFlatGas = flat;
-  if (mFlatGas) {
-    if (number < 0) {
-      LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
-      mFlatGas = false;
-      mFlatGasNumber = -1;
-    } else {
-      mFlatGasNumber = number;
-      mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
-      mCollisionContext = mContextFile ? (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext") : nullptr;
-      mInteractionTimeRecords = mCollisionContext ? mCollisionContext->getEventRecords() : std::vector<o2::InteractionTimeRecord>{};
-      if (mInteractionTimeRecords.empty()) {
-        LOG(error) << "Error: No interaction time records found in the collision context!";
-        exit(1);
-      } else {
-        LOG(info) << "Interaction Time records has " << mInteractionTimeRecords.size() << " entries.";
-        mCollisionContext->printCollisionSummary();
-      }
-      for (int c = 0; c < mInteractionTimeRecords.size() - 1; c++) {
-        mIntTimeRecMean += mInteractionTimeRecords[c + 1].bc2ns() - mInteractionTimeRecords[c].bc2ns();
-      }
-      mIntTimeRecMean /= (mInteractionTimeRecords.size() - 1); // Average interaction time record used as reference
-      const auto& hbfUtils = o2::raw::HBFUtils::Instance();
-      // Get the start time of the second orbit after the last interaction record
-      const auto& lastIR = mInteractionTimeRecords.back();
-      o2::InteractionRecord finalOrbitIR(0, lastIR.orbit + 2); // Final orbit, BC = 0
-      mTimeEnd = finalOrbitIR.bc2ns();
-      LOG(debug) << "Final orbit start time: " << mTimeEnd << " ns while last interaction record time is " << mInteractionTimeRecords.back().bc2ns() << " ns";
-    }
-  } else {
-    mFlatGasNumber = -1;
-  }
-  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per event: " << mFlatGasNumber;
-}
-
-void GenTPCLoopers::setFractionPairs(float& fractionPairs)
-{
-  if (fractionPairs < 0 || fractionPairs > 1) {
-    LOG(fatal) << "Error: Loops fraction for pairs must be in the range [0, 1].";
-    exit(1);
-  }
-  mLoopsFractionPairs = fractionPairs;
-  LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
-}
-
-} // namespace eventgen
-} // namespace o2
\ No newline at end of file
diff --git a/Generators/src/TPCLoopersParam.cxx b/Generators/src/TPCLoopersParam.cxx
deleted file mode 100644
index 0202a8ced0535..0000000000000
--- a/Generators/src/TPCLoopersParam.cxx
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author M+Giacalone - September 2025
-
-#include "Generators/TPCLoopersParam.h"
-O2ParamImpl(o2::eventgen::GenTPCLoopersParam);

From 51f8cefb58b705ba534d65bee42528c0a5d4221a Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Wed, 17 Dec 2025 14:17:57 +0100
Subject: [PATCH 1174/1764] Moved configFile check + expand env vars

---
 Generators/src/GeneratorFactory.cxx |  5 -----
 Generators/src/GeneratorHybrid.cxx  | 12 +++++++++---
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/Generators/src/GeneratorFactory.cxx b/Generators/src/GeneratorFactory.cxx
index 4102bd8ffd9b2..d04e785402915 100644
--- a/Generators/src/GeneratorFactory.cxx
+++ b/Generators/src/GeneratorFactory.cxx
@@ -279,11 +279,6 @@ void GeneratorFactory::setPrimaryGenerator(o2::conf::SimConfig const& conf, Fair
       LOG(fatal) << "No configuration file provided for hybrid generator";
       return;
     }
-    // check if file named config exists and it's not empty
-    else if (gSystem->AccessPathName(config.c_str())) {
-      LOG(fatal) << "Configuration file for hybrid generator does not exist";
-      return;
-    }
     auto& hybrid = o2::eventgen::GeneratorHybrid::Instance(config);
     primGen->AddGenerator(&hybrid);
 #endif
diff --git a/Generators/src/GeneratorHybrid.cxx b/Generators/src/GeneratorHybrid.cxx
index 370671a977a5c..2a13f9876e717 100644
--- a/Generators/src/GeneratorHybrid.cxx
+++ b/Generators/src/GeneratorHybrid.cxx
@@ -615,17 +615,23 @@ Bool_t GeneratorHybrid::confSetter(const auto& gen)
 
 Bool_t GeneratorHybrid::parseJSON(const std::string& path)
 {
+  auto expandedPath = o2::utils::expandShellVarsInFileName(path);
+  // Check if configuration file exists
+  if (gSystem->AccessPathName(expandedPath.c_str())) {
+    LOG(fatal) << "Configuration file " << expandedPath << " for hybrid generator does not exist";
+    return false;
+  }
   // Parse JSON file to build map
-  std::ifstream fileStream(path, std::ios::in);
+  std::ifstream fileStream(expandedPath, std::ios::in);
   if (!fileStream.is_open()) {
-    LOG(error) << "Cannot open " << path;
+    LOG(error) << "Cannot open " << expandedPath;
     return false;
   }
   rapidjson::IStreamWrapper isw(fileStream);
   rapidjson::Document doc;
   doc.ParseStream(isw);
   if (doc.HasParseError()) {
-    LOG(error) << "Error parsing provided json file " << path;
+    LOG(error) << "Error parsing provided json file " << expandedPath;
     LOG(error) << "  - Error -> " << rapidjson::GetParseError_En(doc.GetParseError());
     return false;
   }

From 7211829480227b643715c57b2ac5e80a6bd17846 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Tue, 2 Dec 2025 10:14:58 +0100
Subject: [PATCH 1175/1764] dpl-workflow.sh: add relaxed GPU_rec_tpc async cuts
 also as default for sync

---
 prodtests/full-system-test/dpl-workflow.sh | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 754349c87eecc..db491da5ebec5 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -145,6 +145,8 @@ if [[ $SYNCMODE == 1 ]]; then
     fi
   fi
   GPU_CONFIG_KEY+="GPU_global.synchronousProcessing=1;GPU_proc.clearO2OutputFromGPU=1;"
+  # relaxed cuts also used for async reconstruction, they require scaling of the GPU memory
+  GPU_CONFIG_KEY+="GPU_rec_tpc.trackletMinSharedNormFactor=1.;GPU_rec_tpc.trackletMaxSharedFraction=0.3;GPU_rec_tpc.rejectIFCLowRadiusCluster=1;GPU_rec_tpc.extrapolationTrackingRowRange=100;GPU_rec_tpc.clusterError2AdditionalYSeeding=0.1;GPU_rec_tpc.clusterError2AdditionalZSeeding=0.15;GPU_proc.memoryScalingFactor=1.2;"
   has_processing_step TPC_DEDX && GPU_CONFIG_KEY+="GPU_global.rundEdx=1;"
   has_detector ITS && TRD_FILTER_CONFIG+=" --filter-trigrec"
 else

From 35b0becfa59f1d9be85f65a2ca829f99e93ef5f0 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 15 Dec 2025 11:02:17 +0100
Subject: [PATCH 1176/1764] Fix code checker issue

---
 Detectors/ITSMFT/ITS/postprocessing/studies/src/PIDStudy.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/PIDStudy.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/PIDStudy.cxx
index 4b0f553eb774b..9a7f6c218cd12 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/PIDStudy.cxx
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/PIDStudy.cxx
@@ -91,7 +91,7 @@ class PIDStudy : public Task
            std::shared_ptr<o2::base::GRPGeomRequest> gr,
            bool isMC,
            std::shared_ptr<o2::steer::MCKinematicsReader> kineReader) : mDataRequest{dr}, mGGCCDBRequest(gr), mUseMC(isMC), mKineReader(kineReader){};
-  ~PIDStudy() final = default;
+  ~PIDStudy() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext&) final;
   void endOfStream(EndOfStreamContext&) final;

From ea23c378e45c2e2c84a707cd03abd044e52572ea Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 15 Dec 2025 11:02:17 +0100
Subject: [PATCH 1177/1764] MathUtils: move BetheBlochAleph to a common header

---
 .../include/MathUtils/BetheBlochAleph.h       | 35 +++++++++++++++++++
 .../include/DataFormatsTPC/BetheBlochAleph.h  | 18 +++-------
 2 files changed, 39 insertions(+), 14 deletions(-)
 create mode 100644 Common/MathUtils/include/MathUtils/BetheBlochAleph.h

diff --git a/Common/MathUtils/include/MathUtils/BetheBlochAleph.h b/Common/MathUtils/include/MathUtils/BetheBlochAleph.h
new file mode 100644
index 0000000000000..bd72faffb0503
--- /dev/null
+++ b/Common/MathUtils/include/MathUtils/BetheBlochAleph.h
@@ -0,0 +1,35 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef AliceO2_COMMON_BETHEBLOCH_H_
+#define AliceO2_COMMON_BETHEBLOCH_H_
+
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
+
+namespace o2::common
+{
+
+template <typename T>
+GPUdi() T BetheBlochAleph(T bg, T kp1, T kp2, T kp3, T kp4, T kp5)
+{
+  T beta = bg / o2::gpu::GPUCommonMath::Sqrt(static_cast<T>(1.) + bg * bg);
+
+  T aa = o2::gpu::GPUCommonMath::Pow(beta, kp4);
+  T bb = o2::gpu::GPUCommonMath::Pow(static_cast<T>(1.) / bg, kp5);
+  bb = o2::gpu::GPUCommonMath::Log(kp3 + bb);
+
+  return (kp2 - aa - bb) * kp1 / aa;
+}
+
+} // namespace o2::common
+
+#endif
diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/BetheBlochAleph.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/BetheBlochAleph.h
index e8fe7457f3091..28b224298f36f 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/BetheBlochAleph.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/BetheBlochAleph.h
@@ -12,27 +12,17 @@
 #ifndef AliceO2_TPC_BETHEBLOCH_H_
 #define AliceO2_TPC_BETHEBLOCH_H_
 
-#include "GPUCommonDef.h"
-#include "GPUCommonMath.h"
+#include "MathUtils/BetheBlochAleph.h"
 
-namespace o2
-{
-namespace tpc
+namespace o2::tpc
 {
 
 template <typename T>
 GPUdi() T BetheBlochAleph(T bg, T kp1, T kp2, T kp3, T kp4, T kp5)
 {
-  T beta = bg / o2::gpu::GPUCommonMath::Sqrt(static_cast<T>(1.) + bg * bg);
-
-  T aa = o2::gpu::GPUCommonMath::Pow(beta, kp4);
-  T bb = o2::gpu::GPUCommonMath::Pow(static_cast<T>(1.) / bg, kp5);
-  bb = o2::gpu::GPUCommonMath::Log(kp3 + bb);
-
-  return (kp2 - aa - bb) * kp1 / aa;
+  return o2::common::BetheBlochAleph(bg, kp1, kp2, kp3, kp4, kp5);
 }
 
-} // namespace tpc
-} // namespace o2
+} // namespace o2::tpc
 
 #endif

From d6f6148d1a89eb2bfd955541ffa0717178cb122e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Dec 2025 15:25:59 +0000
Subject: [PATCH 1178/1764] Bump actions/cache from 4 to 5

Bumps [actions/cache](https://github.com/actions/cache) from 4 to 5.
- [Release notes](https://github.com/actions/cache/releases)
- [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md)
- [Commits](https://github.com/actions/cache/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/cache
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/reports.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/reports.yml b/.github/workflows/reports.yml
index 936be948b7218..5a04e56382fb3 100644
--- a/.github/workflows/reports.yml
+++ b/.github/workflows/reports.yml
@@ -22,7 +22,7 @@ jobs:
       uses: actions/setup-python@v6
       with:
         python-version: '3.10'
-    - uses: actions/cache@v4
+    - uses: actions/cache@v5
       name: Configure pip caching
       with:
         path: ~/.cache/pip

From aab079f2ba980913451b4902749e8f424fcebdaa Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 6 Jan 2026 10:59:20 +0100
Subject: [PATCH 1179/1764] DataModel: improve DataHeader formatter

Add splitPayloadIndex / splitPayloadParts to the default printout
---
 DataFormats/Headers/include/Headers/DataHeaderHelpers.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/DataFormats/Headers/include/Headers/DataHeaderHelpers.h b/DataFormats/Headers/include/Headers/DataHeaderHelpers.h
index aa93414cfb99f..4f7e49acb4d98 100644
--- a/DataFormats/Headers/include/Headers/DataHeaderHelpers.h
+++ b/DataFormats/Headers/include/Headers/DataHeaderHelpers.h
@@ -79,7 +79,8 @@ struct fmt::formatter<o2::header::DataHeader> {
                  fmt::format("  payloadSize  : {}\n", (long long unsigned int)h.payloadSize) +
                  fmt::format("  firstTForbit : {}\n", h.firstTForbit) +
                  fmt::format("  tfCounter    : {}\n", h.tfCounter) +
-                 fmt::format("  runNumber    : {}\n", h.runNumber);
+                 fmt::format("  runNumber    : {}\n", h.runNumber) +
+                 fmt::format("  split        : {}/{}\n", h.splitPayloadIndex, h.splitPayloadParts);
       return fmt::format_to(ctx.out(), "{}", res);
     } else {
       auto res = fmt::format("{}/{}/{}",

From a5f88b79468c20cf515488c3f69f98fb2839830f Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 1 Dec 2025 12:49:46 +0100
Subject: [PATCH 1180/1764] AnalysisContext -> DanglingEdgesContext

---
 .../AnalysisSupport/src/AODReaderHelpers.cxx  |  6 +-
 .../AnalysisSupport/src/AODWriterHelpers.cxx  |  6 +-
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   |  4 +-
 .../Framework/AnalysisSupportHelpers.h        |  2 +-
 ...alysisContext.h => DanglingEdgesContext.h} |  8 +-
 Framework/Core/src/AnalysisSupportHelpers.cxx |  6 +-
 Framework/Core/src/ArrowSupport.cxx           | 64 +++++++-------
 Framework/Core/src/WorkflowHelpers.cxx        | 85 +++++++++----------
 8 files changed, 90 insertions(+), 91 deletions(-)
 rename Framework/Core/include/Framework/{AnalysisContext.h => DanglingEdgesContext.h} (92%)

diff --git a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
index 40aa5a9537c7f..045ef072a3040 100644
--- a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
@@ -19,7 +19,7 @@
 #include "Framework/AlgorithmSpec.h"
 #include "Framework/DataSpecUtils.h"
 #include "Framework/ConfigContext.h"
-#include "Framework/AnalysisContext.h"
+#include "Framework/DanglingEdgesContext.h"
 
 namespace o2::framework::readers
 {
@@ -81,7 +81,7 @@ struct Buildable {
 
 AlgorithmSpec AODReaderHelpers::indexBuilderCallback(ConfigContext const& ctx)
 {
-  auto& ac = ctx.services().get<AnalysisContext>();
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
   return AlgorithmSpec::InitCallback{[requested = ac.requestedIDXs](InitContext& /*ic*/) {
     std::vector<Buildable> buildables;
     for (auto& i : requested) {
@@ -183,7 +183,7 @@ struct Spawnable {
 
 AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(ConfigContext const& ctx)
 {
-  auto& ac = ctx.services().get<AnalysisContext>();
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
   return AlgorithmSpec::InitCallback{[requested = ac.spawnerInputs](InitContext& /*ic*/) {
     std::vector<Spawnable> spawnables;
     for (auto& i : requested) {
diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index bcf27d0be5ba3..5a43683afd364 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -8,7 +8,7 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-#include "Framework/AnalysisContext.h"
+#include "Framework/DanglingEdgesContext.h"
 #include "Framework/ConfigContext.h"
 #include "Framework/ControlService.h"
 #include "AODWriterHelpers.h"
@@ -62,7 +62,7 @@ const static std::unordered_map<OutputObjHandlingPolicy, std::string> ROOTfileNa
 
 AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
 {
-  auto& ac = ctx.services().get<AnalysisContext>();
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
   auto dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
   int compressionLevel = 505;
   if (ctx.options().hasOption("aod-writer-compression")) {
@@ -245,7 +245,7 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
 AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 {
   using namespace monitoring;
-  auto& ac = ctx.services().get<AnalysisContext>();
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
   auto tskmap = ac.outTskMap;
   auto objmap = ac.outObjHistMap;
 
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index aba1f3ed4e13d..fcc856669cd92 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -18,7 +18,7 @@
 #include "Framework/RawDeviceService.h"
 #include "Framework/Output.h"
 #include "Framework/Signpost.h"
-#include "Framework/AnalysisContext.h"
+#include "Framework/DanglingEdgesContext.h"
 #include "Framework/ConfigContext.h"
 #include "Framework/ConfigContext.h"
 #include <arrow/array/builder_binary.h>
@@ -69,7 +69,7 @@ void fillValidRoutes(CCDBFetcherHelper& helper, std::vector<o2::framework::Outpu
 
 AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
 {
-  auto& ac = ctx.services().get<AnalysisContext>();
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
   std::vector<std::shared_ptr<arrow::Schema>> schemas;
   auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
 
diff --git a/Framework/Core/include/Framework/AnalysisSupportHelpers.h b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
index c0eeb3bd9697d..ef1d056b62f2b 100644
--- a/Framework/Core/include/Framework/AnalysisSupportHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
@@ -14,7 +14,7 @@
 #include "Framework/OutputSpec.h"
 #include "Framework/InputSpec.h"
 #include "Framework/DataProcessorSpec.h"
-#include "Framework/AnalysisContext.h"
+#include "Framework/DanglingEdgesContext.h"
 #include "Headers/DataHeader.h"
 #include <array>
 
diff --git a/Framework/Core/include/Framework/AnalysisContext.h b/Framework/Core/include/Framework/DanglingEdgesContext.h
similarity index 92%
rename from Framework/Core/include/Framework/AnalysisContext.h
rename to Framework/Core/include/Framework/DanglingEdgesContext.h
index 7d1544ed312a4..90a88974db038 100644
--- a/Framework/Core/include/Framework/AnalysisContext.h
+++ b/Framework/Core/include/Framework/DanglingEdgesContext.h
@@ -8,8 +8,8 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-#ifndef O2_FRAMEWORK_ANALYSISCONTEXT_H_
-#define O2_FRAMEWORK_ANALYSISCONTEXT_H_
+#ifndef O2_FRAMEWORK_DANGLINGEDGESCONTEXT_H_
+#define O2_FRAMEWORK_DANGLINGEDGESCONTEXT_H_
 
 #include <vector>
 #include "Framework/InputSpec.h"
@@ -32,7 +32,7 @@ struct OutputObjectInfo {
 // This will keep track of the inputs which have
 // been requested and for which we will need to inject
 // some source device.
-struct AnalysisContext {
+struct DanglingEdgesContext {
   std::vector<InputSpec> requestedAODs;
   std::vector<OutputSpec> providedAODs;
   std::vector<InputSpec> requestedDYNs;
@@ -63,4 +63,4 @@ struct AnalysisContext {
 extern template class std::vector<o2::framework::OutputObjectInfo>;
 extern template class std::vector<o2::framework::OutputTaskInfo>;
 
-#endif // O2_FRAMEWORK_ANALYSISCONTEXT_H_
+#endif // O2_FRAMEWORK_DANGLINGEDGESCONTEXT_H_
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index e59f36c72bdab..15b56f9afbff5 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -25,8 +25,8 @@ namespace o2::framework
 std::shared_ptr<DataOutputDirector> AnalysisSupportHelpers::getDataOutputDirector(ConfigContext const& ctx)
 {
   auto const& options = ctx.options();
-  auto const& OutputsInputs = ctx.services().get<AnalysisContext>().outputsInputs;
-  auto const& isDangling = ctx.services().get<AnalysisContext>().isDangling;
+  auto const& OutputsInputs = ctx.services().get<DanglingEdgesContext>().outputsInputs;
+  auto const& isDangling = ctx.services().get<DanglingEdgesContext>().isDangling;
 
   std::shared_ptr<DataOutputDirector> dod = std::make_shared<DataOutputDirector>();
 
@@ -200,7 +200,7 @@ DataProcessorSpec AnalysisSupportHelpers::getOutputObjHistSink(ConfigContext con
 DataProcessorSpec
   AnalysisSupportHelpers::getGlobalAODSink(ConfigContext const& ctx)
 {
-  auto& ac = ctx.services().get<AnalysisContext>();
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
 
   // the command line options relevant for the writer are global
   // see runDataProcessing.h
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 26594252e888b..ee4275281ab31 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -588,23 +588,23 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
       auto builder = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-index-builder"; });
       auto reader = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-reader"; });
       auto writer = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-writer"; });
-      auto &ac = ctx.services().get<AnalysisContext>();
-      ac.requestedAODs.clear();
-      ac.requestedDYNs.clear();
-      ac.providedDYNs.clear();
-      ac.providedTIMs.clear();
-      ac.requestedTIMs.clear();
+      auto& dec = ctx.services().get<DanglingEdgesContext>();
+      dec.requestedAODs.clear();
+      dec.requestedDYNs.clear();
+      dec.providedDYNs.clear();
+      dec.providedTIMs.clear();
+      dec.requestedTIMs.clear();
 
       auto inputSpecLessThan = [](InputSpec const& lhs, InputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
       auto outputSpecLessThan = [](OutputSpec const& lhs, OutputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
 
       if (builder != workflow.end()) {
         // collect currently requested IDXs
-        ac.requestedIDXs.clear();
+        dec.requestedIDXs.clear();
         for (auto& d : workflow | views::exclude_by_name(builder->name)) {
           d.inputs |
             views::partial_match_filter(header::DataOrigin{"IDX"}) |
-            sinks::update_input_list{ac.requestedIDXs};
+            sinks::update_input_list{dec.requestedIDXs};
         }
         // recreate inputs and outputs
         builder->inputs.clear();
@@ -612,7 +612,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         // replace AlgorithmSpec
         //  FIXME: it should be made more generic, so it does not need replacement...
         builder->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx); // readers::AODReaderHelpers::indexBuilderCallback(ctx);
-        AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.requestedIDXs, ac.requestedAODs, ac.requestedDYNs, *builder);
+        AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.requestedIDXs, dec.requestedAODs, dec.requestedDYNs, *builder);
       }
 
       if (spawner != workflow.end()) {
@@ -620,21 +620,21 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         for (auto& d : workflow | views::exclude_by_name(spawner->name)) {
           d.inputs |
             views::partial_match_filter(header::DataOrigin{"DYN"}) |
-            sinks::update_input_list{ac.requestedDYNs};
+            sinks::update_input_list{dec.requestedDYNs};
           d.outputs |
             views::partial_match_filter(header::DataOrigin{"DYN"}) |
-            sinks::append_to{ac.providedDYNs};
+            sinks::append_to{dec.providedDYNs};
         }
-        std::sort(ac.requestedDYNs.begin(), ac.requestedDYNs.end(), inputSpecLessThan);
-        std::sort(ac.providedDYNs.begin(), ac.providedDYNs.end(), outputSpecLessThan);
-        ac.spawnerInputs.clear();
-        ac.requestedDYNs |
-          views::filter_not_matching(ac.providedDYNs) |
-          sinks::append_to{ac.spawnerInputs};
+        std::sort(dec.requestedDYNs.begin(), dec.requestedDYNs.end(), inputSpecLessThan);
+        std::sort(dec.providedDYNs.begin(), dec.providedDYNs.end(), outputSpecLessThan);
+        dec.spawnerInputs.clear();
+        dec.requestedDYNs |
+          views::filter_not_matching(dec.providedDYNs) |
+          sinks::append_to{dec.spawnerInputs};
         // recreate inputs and outputs
         spawner->outputs.clear();
         spawner->inputs.clear();
-        AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, *spawner);
+        AnalysisSupportHelpers::addMissingOutputsToSpawner({}, dec.spawnerInputs, dec.requestedAODs, *spawner);
         // replace AlgorithmSpec
         // FIXME: it should be made more generic, so it does not need replacement...
         spawner->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx);
@@ -642,14 +642,14 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
 
       if (analysisCCDB != workflow.end()) {
         for (auto& d : workflow | views::exclude_by_name(analysisCCDB->name)) {
-          d.inputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::update_input_list{ac.requestedTIMs};
-          d.outputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::append_to{ac.providedTIMs};
+          d.inputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::update_input_list{dec.requestedTIMs};
+          d.outputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::append_to{dec.providedTIMs};
         }
-        std::sort(ac.requestedTIMs.begin(), ac.requestedTIMs.end(), inputSpecLessThan);
-        std::sort(ac.providedTIMs.begin(), ac.providedTIMs.end(), outputSpecLessThan);
+        std::sort(dec.requestedTIMs.begin(), dec.requestedTIMs.end(), inputSpecLessThan);
+        std::sort(dec.providedTIMs.begin(), dec.providedTIMs.end(), outputSpecLessThan);
         // Use ranges::to<std::vector<>> in C++23...
-        ac.analysisCCDBInputs.clear();
-        ac.requestedTIMs | views::filter_not_matching(ac.providedTIMs) | sinks::append_to{ac.analysisCCDBInputs};
+        dec.analysisCCDBInputs.clear();
+        dec.requestedTIMs | views::filter_not_matching(dec.providedTIMs) | sinks::append_to{dec.analysisCCDBInputs};
 
         // recreate inputs and outputs
         analysisCCDB->outputs.clear();
@@ -658,7 +658,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         // FIXME: it should be made more generic, so it does not need replacement...
         // FIXME how can I make the lookup depend on DYN tables as well??
         analysisCCDB->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
-        AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.analysisCCDBInputs, ac.requestedAODs, ac.requestedDYNs, *analysisCCDB);
+        AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.analysisCCDBInputs, dec.requestedAODs, dec.requestedDYNs, *analysisCCDB);
       }
 
       if (writer != workflow.end()) {
@@ -671,12 +671,12 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         for (auto& d : workflow) {
           d.inputs |
             views::partial_match_filter(AODOrigins) |
-            sinks::update_input_list{ac.requestedAODs};
+            sinks::update_input_list{dec.requestedAODs};
         }
 
         // remove unmatched outputs
         auto o_end = std::remove_if(reader->outputs.begin(), reader->outputs.end(), [&](OutputSpec const& o) {
-          return !DataSpecUtils::partialMatch(o, o2::header::DataDescription{"TFNumber"}) && !DataSpecUtils::partialMatch(o, o2::header::DataDescription{"TFFilename"}) && std::none_of(ac.requestedAODs.begin(), ac.requestedAODs.end(), [&](InputSpec const& i) { return DataSpecUtils::match(i, o); });
+          return !DataSpecUtils::partialMatch(o, o2::header::DataDescription{"TFNumber"}) && !DataSpecUtils::partialMatch(o, o2::header::DataDescription{"TFFilename"}) && std::none_of(dec.requestedAODs.begin(), dec.requestedAODs.end(), [&](InputSpec const& i) { return DataSpecUtils::match(i, o); });
         });
         reader->outputs.erase(o_end, reader->outputs.end());
         if (reader->outputs.empty()) {
@@ -694,22 +694,22 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
       // select outputs of type AOD which need to be saved
       // ATTENTION: if there are dangling outputs the getGlobalAODSink
       // has to be created in any case!
-      ac.outputsInputsAOD.clear();
+      dec.outputsInputsAOD.clear();
 
       for (auto ii = 0u; ii < outputsInputs.size(); ii++) {
         if (DataSpecUtils::partialMatch(outputsInputs[ii], extendedAODOrigins)) {
           auto ds = dod->getDataOutputDescriptors(outputsInputs[ii]);
           if (!ds.empty() || isDangling[ii]) {
-            ac.outputsInputsAOD.emplace_back(outputsInputs[ii]);
+            dec.outputsInputsAOD.emplace_back(outputsInputs[ii]);
           }
         }
       }
 
       // file sink for any AOD output
-      if (!ac.outputsInputsAOD.empty()) {
+      if (!dec.outputsInputsAOD.empty()) {
         // add TFNumber and TFFilename as input to the writer
-        ac.outputsInputsAOD.emplace_back("tfn", "TFN", "TFNumber");
-        ac.outputsInputsAOD.emplace_back("tff", "TFF", "TFFilename");
+        dec.outputsInputsAOD.emplace_back("tfn", "TFN", "TFNumber");
+        dec.outputsInputsAOD.emplace_back("tff", "TFF", "TFFilename");
         workflow.push_back(AnalysisSupportHelpers::getGlobalAODSink(ctx));
       }
       // Move the dummy sink at the end, if needed
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 02141678fec7c..fdcdb6093a111 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -247,8 +247,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     aodReader.options.emplace_back(ConfigParamSpec{"channel-config", VariantType::String, rateLimitingChannelConfigInput, {"how many timeframes can be in flight at the same time"}});
   }
 
-  ctx.services().registerService(ServiceRegistryHelpers::handleForService<AnalysisContext>(new AnalysisContext));
-  auto& ac = ctx.services().get<AnalysisContext>();
+  ctx.services().registerService(ServiceRegistryHelpers::handleForService<DanglingEdgesContext>(new DanglingEdgesContext));
+  auto& dec = ctx.services().get<DanglingEdgesContext>();
 
   std::vector<InputSpec> requestedCCDBs;
   std::vector<OutputSpec> providedCCDBs;
@@ -257,7 +257,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     auto& processor = workflow[wi];
     auto name = processor.name;
     auto hash = runtime_hash(name.c_str());
-    ac.outTskMap.push_back({hash, name});
+    dec.outTskMap.push_back({hash, name});
 
     std::string prefix = "internal-dpl-";
     if (processor.inputs.empty() && processor.name.compare(0, prefix.size(), prefix) != 0) {
@@ -336,16 +336,16 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
           break;
       }
       if (DataSpecUtils::partialMatch(input, AODOrigins)) {
-        DataSpecUtils::updateInputList(ac.requestedAODs, InputSpec{input});
+        DataSpecUtils::updateInputList(dec.requestedAODs, InputSpec{input});
       }
       if (DataSpecUtils::partialMatch(input, header::DataOrigin{"DYN"})) {
-        DataSpecUtils::updateInputList(ac.requestedDYNs, InputSpec{input});
+        DataSpecUtils::updateInputList(dec.requestedDYNs, InputSpec{input});
       }
       if (DataSpecUtils::partialMatch(input, header::DataOrigin{"IDX"})) {
-        DataSpecUtils::updateInputList(ac.requestedIDXs, InputSpec{input});
+        DataSpecUtils::updateInputList(dec.requestedIDXs, InputSpec{input});
       }
       if (DataSpecUtils::partialMatch(input, header::DataOrigin{"ATIM"})) {
-        DataSpecUtils::updateInputList(ac.requestedTIMs, InputSpec{input});
+        DataSpecUtils::updateInputList(dec.requestedTIMs, InputSpec{input});
       }
     }
 
@@ -353,16 +353,16 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
     for (auto& output : processor.outputs) {
       if (DataSpecUtils::partialMatch(output, AODOrigins)) {
-        ac.providedAODs.emplace_back(output);
+        dec.providedAODs.emplace_back(output);
       } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"DYN"})) {
-        ac.providedDYNs.emplace_back(output);
+        dec.providedDYNs.emplace_back(output);
       } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"ATIM"})) {
-        ac.providedTIMs.emplace_back(output);
+        dec.providedTIMs.emplace_back(output);
       } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"ATSK"})) {
-        ac.providedOutputObjHist.emplace_back(output);
-        auto it = std::find_if(ac.outObjHistMap.begin(), ac.outObjHistMap.end(), [&](auto&& x) { return x.id == hash; });
-        if (it == ac.outObjHistMap.end()) {
-          ac.outObjHistMap.push_back({hash, {output.binding.value}});
+        dec.providedOutputObjHist.emplace_back(output);
+        auto it = std::find_if(dec.outObjHistMap.begin(), dec.outObjHistMap.end(), [&](auto&& x) { return x.id == hash; });
+        if (it == dec.outObjHistMap.end()) {
+          dec.outObjHistMap.push_back({hash, {output.binding.value}});
         } else {
           it->bindings.push_back(output.binding.value);
         }
@@ -375,10 +375,10 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   auto inputSpecLessThan = [](InputSpec const& lhs, InputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
   auto outputSpecLessThan = [](OutputSpec const& lhs, OutputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
-  std::sort(ac.requestedDYNs.begin(), ac.requestedDYNs.end(), inputSpecLessThan);
-  std::sort(ac.requestedTIMs.begin(), ac.requestedTIMs.end(), inputSpecLessThan);
-  std::sort(ac.providedDYNs.begin(), ac.providedDYNs.end(), outputSpecLessThan);
-  std::sort(ac.providedTIMs.begin(), ac.providedTIMs.end(), outputSpecLessThan);
+  std::sort(dec.requestedDYNs.begin(), dec.requestedDYNs.end(), inputSpecLessThan);
+  std::sort(dec.requestedTIMs.begin(), dec.requestedTIMs.end(), inputSpecLessThan);
+  std::sort(dec.providedDYNs.begin(), dec.providedDYNs.end(), outputSpecLessThan);
+  std::sort(dec.providedTIMs.begin(), dec.providedTIMs.end(), outputSpecLessThan);
 
   DataProcessorSpec indexBuilder{
     "internal-dpl-aod-index-builder",
@@ -386,15 +386,15 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     {},
     PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx), // readers::AODReaderHelpers::indexBuilderCallback(ctx),
     {}};
-  AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.requestedIDXs, ac.requestedAODs, ac.requestedDYNs, indexBuilder);
+  AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.requestedIDXs, dec.requestedAODs, dec.requestedDYNs, indexBuilder);
 
-  ac.requestedTIMs | views::filter_not_matching(ac.providedTIMs) | sinks::append_to{ac.analysisCCDBInputs};
+  dec.requestedTIMs | views::filter_not_matching(dec.providedTIMs) | sinks::append_to{dec.analysisCCDBInputs};
   DeploymentMode deploymentMode = DefaultsHelpers::deploymentMode();
   if (deploymentMode != DeploymentMode::OnlineDDS && deploymentMode != DeploymentMode::OnlineECS) {
-    AnalysisSupportHelpers::addMissingOutputsToBuilder(ac.analysisCCDBInputs, ac.requestedAODs, ac.requestedTIMs, analysisCCDBBackend);
+    AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.analysisCCDBInputs, dec.requestedAODs, dec.requestedTIMs, analysisCCDBBackend);
   }
 
-  ac.requestedDYNs | views::filter_not_matching(ac.providedDYNs) | sinks::append_to{ac.spawnerInputs};
+  dec.requestedDYNs | views::filter_not_matching(dec.providedDYNs) | sinks::append_to{dec.spawnerInputs};
 
   DataProcessorSpec aodSpawner{
     "internal-dpl-aod-spawner",
@@ -402,9 +402,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     {},
     PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx), // readers::AODReaderHelpers::aodSpawnerCallback(ctx),
     {}};
-  AnalysisSupportHelpers::addMissingOutputsToSpawner({}, ac.spawnerInputs, ac.requestedAODs, aodSpawner);
-
-  AnalysisSupportHelpers::addMissingOutputsToReader(ac.providedAODs, ac.requestedAODs, aodReader);
+  AnalysisSupportHelpers::addMissingOutputsToSpawner({}, dec.spawnerInputs, dec.requestedAODs, aodSpawner);
+  AnalysisSupportHelpers::addMissingOutputsToReader(dec.providedAODs, dec.requestedAODs, aodReader);
 
   std::sort(requestedCCDBs.begin(), requestedCCDBs.end(), inputSpecLessThan);
   std::sort(providedCCDBs.begin(), providedCCDBs.end(), outputSpecLessThan);
@@ -547,7 +546,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   // This is to inject a file sink so that any dangling ATSK object is written
   // to a ROOT file.
-  if (ac.providedOutputObjHist.empty() == false) {
+  if (dec.providedOutputObjHist.empty() == false) {
     auto rootSink = AnalysisSupportHelpers::getOutputObjHistSink(ctx);
     extraSpecs.push_back(rootSink);
   }
@@ -557,8 +556,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   /// Analyze all ouputs
   auto [outputsInputsTmp, isDanglingTmp] = analyzeOutputs(workflow);
-  ac.isDangling = isDanglingTmp;
-  ac.outputsInputs = outputsInputsTmp;
+  dec.isDangling = isDanglingTmp;
+  dec.outputsInputs = outputsInputsTmp;
 
   // create DataOutputDescriptor
   std::shared_ptr<DataOutputDirector> dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
@@ -566,28 +565,28 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   // select outputs of type AOD which need to be saved
   // ATTENTION: if there are dangling outputs the getGlobalAODSink
   // has to be created in any case!
-  for (auto ii = 0u; ii < ac.outputsInputs.size(); ii++) {
-    if (DataSpecUtils::partialMatch(ac.outputsInputs[ii], extendedAODOrigins)) {
-      auto ds = dod->getDataOutputDescriptors(ac.outputsInputs[ii]);
-      if (ds.size() > 0 || ac.isDangling[ii]) {
-        ac.outputsInputsAOD.emplace_back(ac.outputsInputs[ii]);
+  for (auto ii = 0u; ii < dec.outputsInputs.size(); ii++) {
+    if (DataSpecUtils::partialMatch(dec.outputsInputs[ii], extendedAODOrigins)) {
+      auto ds = dod->getDataOutputDescriptors(dec.outputsInputs[ii]);
+      if (ds.size() > 0 || dec.isDangling[ii]) {
+        dec.outputsInputsAOD.emplace_back(dec.outputsInputs[ii]);
       }
     }
   }
 
   // file sink for any AOD output
-  if (ac.outputsInputsAOD.size() > 0) {
+  if (dec.outputsInputsAOD.size() > 0) {
     // add TFNumber and TFFilename as input to the writer
-    ac.outputsInputsAOD.emplace_back(InputSpec{"tfn", "TFN", "TFNumber"});
-    ac.outputsInputsAOD.emplace_back(InputSpec{"tff", "TFF", "TFFilename"});
+    dec.outputsInputsAOD.emplace_back(InputSpec{"tfn", "TFN", "TFNumber"});
+    dec.outputsInputsAOD.emplace_back(InputSpec{"tff", "TFF", "TFFilename"});
     auto fileSink = AnalysisSupportHelpers::getGlobalAODSink(ctx);
     extraSpecs.push_back(fileSink);
 
-    auto it = std::find_if(ac.outputsInputs.begin(), ac.outputsInputs.end(), [](InputSpec& spec) -> bool {
+    auto it = std::find_if(dec.outputsInputs.begin(), dec.outputsInputs.end(), [](InputSpec& spec) -> bool {
       return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
     });
-    size_t ii = std::distance(ac.outputsInputs.begin(), it);
-    ac.isDangling[ii] = false;
+    size_t ii = std::distance(dec.outputsInputs.begin(), it);
+    dec.isDangling[ii] = false;
   }
 
   workflow.insert(workflow.end(), extraSpecs.begin(), extraSpecs.end());
@@ -595,20 +594,20 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   // Select dangling outputs which are not of type AOD
   std::vector<InputSpec> redirectedOutputsInputs;
-  for (auto ii = 0u; ii < ac.outputsInputs.size(); ii++) {
+  for (auto ii = 0u; ii < dec.outputsInputs.size(); ii++) {
     if (ctx.options().get<std::string>("forwarding-policy") == "none") {
       continue;
     }
     // We forward to the output proxy all the inputs only if they are dangling
     // or if the forwarding policy is "proxy".
-    if (!ac.isDangling[ii] && (ctx.options().get<std::string>("forwarding-policy") != "all")) {
+    if (!dec.isDangling[ii] && (ctx.options().get<std::string>("forwarding-policy") != "all")) {
       continue;
     }
     // AODs are skipped in any case.
-    if (DataSpecUtils::partialMatch(ac.outputsInputs[ii], extendedAODOrigins)) {
+    if (DataSpecUtils::partialMatch(dec.outputsInputs[ii], extendedAODOrigins)) {
       continue;
     }
-    redirectedOutputsInputs.emplace_back(ac.outputsInputs[ii]);
+    redirectedOutputsInputs.emplace_back(dec.outputsInputs[ii]);
   }
 
   std::vector<InputSpec> unmatched;

From 027cad2deaa056cd2bca7c465bd1f74309005ed1 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 2 Dec 2025 09:48:09 +0100
Subject: [PATCH 1181/1764] Propagate dangling edges context to init context
 and delay algo loading

---
 .../AnalysisSupport/src/AODReaderHelpers.cxx  | 16 ++++----
 .../AnalysisSupport/src/AODReaderHelpers.h    |  4 +-
 Framework/Core/src/ArrowSupport.cxx           | 20 ++++++----
 Framework/Core/src/WorkflowHelpers.cxx        | 38 +++++--------------
 Framework/Core/src/runDataProcessing.cxx      |  5 +++
 5 files changed, 37 insertions(+), 46 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
index 045ef072a3040..7f08dd0b36a64 100644
--- a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
@@ -79,12 +79,12 @@ struct Buildable {
 
 } // namespace
 
-AlgorithmSpec AODReaderHelpers::indexBuilderCallback(ConfigContext const& ctx)
+AlgorithmSpec AODReaderHelpers::indexBuilderCallback(ConfigContext const& /*ctx*/)
 {
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
-  return AlgorithmSpec::InitCallback{[requested = ac.requestedIDXs](InitContext& /*ic*/) {
+  return AlgorithmSpec::InitCallback{[](InitContext& ic) {
+    auto const& requested = ic.services().get<DanglingEdgesContext>().requestedIDXs;
     std::vector<Buildable> buildables;
-    for (auto& i : requested) {
+    for (auto const& i : requested) {
       buildables.emplace_back(i);
     }
     std::vector<Builder> builders;
@@ -181,12 +181,12 @@ struct Spawnable {
 
 } // namespace
 
-AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(ConfigContext const& ctx)
+AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(ConfigContext const& /*ctx*/)
 {
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
-  return AlgorithmSpec::InitCallback{[requested = ac.spawnerInputs](InitContext& /*ic*/) {
+  return AlgorithmSpec::InitCallback{[](InitContext& ic) {
+    auto const& requested = ic.services().get<DanglingEdgesContext>().spawnerInputs;
     std::vector<Spawnable> spawnables;
-    for (auto& i : requested) {
+    for (auto const& i : requested) {
       spawnables.emplace_back(i);
     }
     std::vector<Spawner> spawners;
diff --git a/Framework/AnalysisSupport/src/AODReaderHelpers.h b/Framework/AnalysisSupport/src/AODReaderHelpers.h
index 197907ca3ccb1..848ef6b696713 100644
--- a/Framework/AnalysisSupport/src/AODReaderHelpers.h
+++ b/Framework/AnalysisSupport/src/AODReaderHelpers.h
@@ -20,8 +20,8 @@ namespace o2::framework::readers
 
 struct AODReaderHelpers {
   static AlgorithmSpec rootFileReaderCallback();
-  static AlgorithmSpec aodSpawnerCallback(ConfigContext const& ctx);
-  static AlgorithmSpec indexBuilderCallback(ConfigContext const& ctx);
+  static AlgorithmSpec aodSpawnerCallback(ConfigContext const& /*ctx*/);
+  static AlgorithmSpec indexBuilderCallback(ConfigContext const& /*ctx*/);
 };
 
 } // namespace o2::framework::readers
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index ee4275281ab31..c0280b144e146 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -13,6 +13,7 @@
 #include "Framework/ArrowContext.h"
 #include "Framework/ArrowTableSlicingCache.h"
 #include "Framework/DataProcessor.h"
+#include "Framework/CommonDataProcessors.h"
 #include "Framework/DataProcessingStats.h"
 #include "Framework/ServiceRegistry.h"
 #include "Framework/ConfigContext.h"
@@ -609,9 +610,9 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         // recreate inputs and outputs
         builder->inputs.clear();
         builder->outputs.clear();
-        // replace AlgorithmSpec
-        //  FIXME: it should be made more generic, so it does not need replacement...
-        builder->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx); // readers::AODReaderHelpers::indexBuilderCallback(ctx);
+
+        // load real AlgorithmSpec before deployment
+        builder->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx);
         AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.requestedIDXs, dec.requestedAODs, dec.requestedDYNs, *builder);
       }
 
@@ -634,10 +635,10 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         // recreate inputs and outputs
         spawner->outputs.clear();
         spawner->inputs.clear();
-        AnalysisSupportHelpers::addMissingOutputsToSpawner({}, dec.spawnerInputs, dec.requestedAODs, *spawner);
-        // replace AlgorithmSpec
-        // FIXME: it should be made more generic, so it does not need replacement...
+
+        // load real AlgorithmSpec before deployment
         spawner->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx);
+        AnalysisSupportHelpers::addMissingOutputsToSpawner({}, dec.spawnerInputs, dec.requestedAODs, *spawner);
       }
 
       if (analysisCCDB != workflow.end()) {
@@ -654,8 +655,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         // recreate inputs and outputs
         analysisCCDB->outputs.clear();
         analysisCCDB->inputs.clear();
-        // replace AlgorithmSpec
-        // FIXME: it should be made more generic, so it does not need replacement...
+        // load real AlgorithmSpec before deployment
         // FIXME how can I make the lookup depend on DYN tables as well??
         analysisCCDB->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
         AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.analysisCCDBInputs, dec.requestedAODs, dec.requestedDYNs, *analysisCCDB);
@@ -682,6 +682,10 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         if (reader->outputs.empty()) {
           // nothing to read
           workflow.erase(reader);
+        } else {
+          // load reader algorithm before deployment
+          auto&& algo = PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx);
+          reader->algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(algo);
         }
       }
 
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index fdcdb6093a111..fd9099e1aa24e 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -156,6 +156,7 @@ int defaultConditionQueryRateMultiplier()
 
 void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext& ctx)
 {
+  int rateLimitingIPCID = std::stoi(ctx.options().get<std::string>("timeframes-rate-limit-ipcid"));
   DataProcessorSpec ccdbBackend{
     .name = "internal-dpl-ccdb-backend",
     .outputs = {},
@@ -230,23 +231,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
                 ConfigParamSpec{"step-value-enumeration", VariantType::Int64, 1ll, {"step between one value and the other"}}},
     .requiredServices = CommonServices::defaultServices("O2FrameworkAnalysisSupport:RunSummary")};
 
-  // AOD reader can be rate limited
-  int rateLimitingIPCID = std::stoi(ctx.options().get<std::string>("timeframes-rate-limit-ipcid"));
-  std::string rateLimitingChannelConfigInput;
-  std::string rateLimitingChannelConfigOutput;
-  bool internalRateLimiting = false;
-
-  // In case we have rate-limiting requested, any device without an input will get one on the special
-  // "DPL/RATE" message.
-  if (rateLimitingIPCID >= 0) {
-    rateLimitingChannelConfigInput = fmt::format("name=metric-feedback,type=pull,method=connect,address=ipc://{}metric-feedback-{},transport=shmem,rateLogging=0",
-                                                 ChannelSpecHelpers::defaultIPCFolder(), rateLimitingIPCID);
-    rateLimitingChannelConfigOutput = fmt::format("name=metric-feedback,type=push,method=bind,address=ipc://{}metric-feedback-{},transport=shmem,rateLogging=0",
-                                                  ChannelSpecHelpers::defaultIPCFolder(), rateLimitingIPCID);
-    internalRateLimiting = true;
-    aodReader.options.emplace_back(ConfigParamSpec{"channel-config", VariantType::String, rateLimitingChannelConfigInput, {"how many timeframes can be in flight at the same time"}});
-  }
-
   ctx.services().registerService(ServiceRegistryHelpers::handleForService<DanglingEdgesContext>(new DanglingEdgesContext));
   auto& dec = ctx.services().get<DanglingEdgesContext>();
 
@@ -274,7 +258,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     // A timeframeSink consumes timeframes without creating new
     // timeframe data.
     bool timeframeSink = hasTimeframeInputs && !hasTimeframeOutputs;
-    if (std::stoi(ctx.options().get<std::string>("timeframes-rate-limit-ipcid")) != -1) {
+    if (rateLimitingIPCID != -1) {
       if (timeframeSink && processor.name.find("internal-dpl-injected-dummy-sink") == std::string::npos) {
         O2_SIGNPOST_ID_GENERATE(sid, workflow_helpers);
         uint32_t hash = runtime_hash(processor.name.c_str());
@@ -384,7 +368,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     "internal-dpl-aod-index-builder",
     {},
     {},
-    PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx), // readers::AODReaderHelpers::indexBuilderCallback(ctx),
+    AlgorithmSpec::dummyAlgorithm(), // real algorithm will be set in adjustTopology
     {}};
   AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.requestedIDXs, dec.requestedAODs, dec.requestedDYNs, indexBuilder);
 
@@ -400,7 +384,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     "internal-dpl-aod-spawner",
     {},
     {},
-    PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx), // readers::AODReaderHelpers::aodSpawnerCallback(ctx),
+    AlgorithmSpec::dummyAlgorithm(), // real algorithm will be set in adjustTopology
     {}};
   AnalysisSupportHelpers::addMissingOutputsToSpawner({}, dec.spawnerInputs, dec.requestedAODs, aodSpawner);
   AnalysisSupportHelpers::addMissingOutputsToReader(dec.providedAODs, dec.requestedAODs, aodReader);
@@ -431,13 +415,11 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     auto mctracks2aod = std::find_if(workflow.begin(), workflow.end(), [](auto const& x) { return x.name == "mctracks-to-aod"; });
     if (mctracks2aod == workflow.end()) {
       // add normal reader
-      auto&& algo = PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx);
-      aodReader.algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(algo);
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
       aodReader.outputs.emplace_back(OutputSpec{"TFF", "TFFilename"});
     } else {
-      // AODs are being injected on-the-fly, add dummy reader
-      auto algo = AlgorithmSpec{
+      // AODs are being injected on-the-fly, add error-handler reader
+      aodReader.algorithm = AlgorithmSpec{
         adaptStateful(
           [outputs = aodReader.outputs](DeviceSpec const&) {
             LOGP(warn, "Workflow with injected AODs has unsatisfied inputs:");
@@ -448,7 +430,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
             // to ensure the output type for adaptStateful
             return adaptStateless([](DataAllocator&) {});
           })};
-      aodReader.algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(algo);
     }
     auto concrete = DataSpecUtils::asConcreteDataMatcher(aodReader.inputs[0]);
     timer.outputs.emplace_back(concrete.origin, concrete.description, concrete.subSpec, Lifetime::Enumeration);
@@ -533,9 +514,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   // add the Analysys CCDB backend which reads CCDB objects using a provided table
   if (analysisCCDBBackend.outputs.empty() == false) {
-    // add normal reader
-    auto&& algo = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
-    analysisCCDBBackend.algorithm = algo;
     extraSpecs.push_back(analysisCCDBBackend);
   }
 
@@ -637,6 +615,10 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       extraSpecs.push_back(CommonDataProcessors::getScheduledDummySink(ignored));
     } else {
       O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting rate limited dummy sink");
+      std::string rateLimitingChannelConfigOutput;
+      if (rateLimitingIPCID != -1) {
+        rateLimitingChannelConfigOutput = fmt::format("name=metric-feedback,type=push,method=bind,address=ipc://{}metric-feedback-{},transport=shmem,rateLogging=0", ChannelSpecHelpers::defaultIPCFolder(), rateLimitingIPCID);
+      }
       extraSpecs.push_back(CommonDataProcessors::getDummySink(ignored, rateLimitingChannelConfigOutput));
     }
   }
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index c36b1deadeefb..14bdb2d8c72d9 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -9,6 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 #include <memory>
+#include "Framework/DanglingEdgesContext.h"
 #include "Framework/TopologyPolicyHelpers.h"
 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
 #include <stdexcept>
@@ -1016,6 +1017,7 @@ void doDefaultWorkflowTerminationHook()
 }
 
 int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
+            DanglingEdgesContext& danglingEdgesContext,
             RunningWorkflowInfo const& runningWorkflow,
             RunningDeviceRef ref,
             DriverConfig const& driverConfig,
@@ -1078,6 +1080,7 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
                                      &spec,
                                      &quotaEvaluator,
                                      &serviceRegistry,
+                                     &danglingEdgesContext,
                                      &deviceState,
                                      &deviceProxy,
                                      &processingPolicies,
@@ -1101,6 +1104,7 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
     serviceRef.registerService(ServiceRegistryHelpers::handleForService<RunningWorkflowInfo const>(&runningWorkflow));
     serviceRef.registerService(ServiceRegistryHelpers::handleForService<DeviceContext>(deviceContext.get()));
     serviceRef.registerService(ServiceRegistryHelpers::handleForService<DriverConfig const>(&driverConfig));
+    serviceRef.registerService(ServiceRegistryHelpers::handleForService<DanglingEdgesContext>(&danglingEdgesContext));
 
     auto device = std::make_unique<DataProcessingDevice>(ref, serviceRegistry);
 
@@ -1953,6 +1957,7 @@ int runStateMachine(DataProcessorSpecs const& workflow,
           if (runningWorkflow.devices[di].id == frameworkId) {
             return doChild(driverInfo.argc, driverInfo.argv,
                            serviceRegistry,
+                           driverInfo.configContext->services().get<DanglingEdgesContext>(),
                            runningWorkflow, ref,
                            driverConfig,
                            driverInfo.processingPolicies,

From 91a991f6baa4c002180612a7586edfa302ff940b Mon Sep 17 00:00:00 2001
From: Piotr Konopka <piotr.jan.konopka@cern.ch>
Date: Tue, 16 Dec 2025 16:42:24 +0100
Subject: [PATCH 1182/1764] DPL: allow to disable oldest possible timeframe
 propagation with a label

This allows to disable all DomainInfoHeader propagation with a corresponding DataProcessorLabel.
It addresses the issue reported in QC-1320, where remote QC workflows were getting flooded with a DIH for each QC task instance in the setup.
---
 Framework/Core/CMakeLists.txt                 |  1 +
 .../Core/include/Framework/CommonLabels.h     | 26 +++++++++++++++++++
 Framework/Core/src/CommonLabels.cxx           | 19 ++++++++++++++
 Framework/Core/src/CommonServices.cxx         |  7 +++++
 Framework/Core/src/DataProcessingHelpers.cxx  |  7 +++++
 Framework/Core/src/DecongestionService.h      |  2 ++
 6 files changed, 62 insertions(+)
 create mode 100644 Framework/Core/include/Framework/CommonLabels.h
 create mode 100644 Framework/Core/src/CommonLabels.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index fe8a91eaa0449..1daba5dbc9798 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -108,6 +108,7 @@ o2_add_library(Framework
                        src/SimpleOptionsRetriever.cxx
                        src/O2ControlHelpers.cxx
                        src/O2ControlLabels.cxx
+                       src/CommonLabels.cxx
                        src/O2ControlParameters.cxx
                        src/O2DataModelHelpers.cxx
                        src/OutputSpec.cxx
diff --git a/Framework/Core/include/Framework/CommonLabels.h b/Framework/Core/include/Framework/CommonLabels.h
new file mode 100644
index 0000000000000..8be41a33af41d
--- /dev/null
+++ b/Framework/Core/include/Framework/CommonLabels.h
@@ -0,0 +1,26 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_FRAMEWORK_COMMONLABELS_H
+#define O2_FRAMEWORK_COMMONLABELS_H
+
+#include "Framework/DataProcessorLabel.h"
+
+namespace o2::framework
+{
+
+// Label to disable forwarding/advertising of DomainInfoHeader (oldest possible outputs)
+// When present on a DataProcessor, no DomainInfoHeader messages will be sent downstream.
+const extern DataProcessorLabel suppressDomainInfoLabel;
+
+} // namespace o2::framework
+
+#endif // O2_FRAMEWORK_COMMONLABELS_H
diff --git a/Framework/Core/src/CommonLabels.cxx b/Framework/Core/src/CommonLabels.cxx
new file mode 100644
index 0000000000000..f728e194f611b
--- /dev/null
+++ b/Framework/Core/src/CommonLabels.cxx
@@ -0,0 +1,19 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Framework/CommonLabels.h"
+
+namespace o2::framework
+{
+
+const DataProcessorLabel suppressDomainInfoLabel = {"suppress-domain-info"};
+
+} // namespace o2::framework
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 3aa46269bdd7e..f786d99fd2c0d 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -45,6 +45,7 @@
 #include "Framework/DefaultsHelpers.h"
 #include "Framework/Signpost.h"
 #include "Framework/DriverConfig.h"
+#include "Framework/CommonLabels.h"
 
 #include "TextDriverClient.h"
 #include "WSDriverClient.h"
@@ -604,6 +605,12 @@ o2::framework::ServiceSpec
           break;
         }
       }
+      for (const auto& label : services.get<DeviceSpec const>().labels) {
+        if (label == suppressDomainInfoLabel) {
+          decongestion->suppressDomainInfo = true;
+          break;
+        }
+      }
       auto& queue = services.get<AsyncQueue>();
       decongestion->oldestPossibleTimesliceTask = AsyncQueueHelpers::create(queue, {.name = "oldest-possible-timeslice", .score = 100});
       return ServiceHandle{TypeIdHelpers::uniqueId<DecongestionService>(), decongestion, ServiceKind::Serial};
diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index 9c53bbf8b2c10..aea682a8d00c3 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -34,6 +34,7 @@
 #include "Framework/DeviceStateEnums.h"
 #include "Headers/DataHeader.h"
 #include "Framework/DataProcessingHeader.h"
+#include "DecongestionService.h"
 
 #include <fairmq/Device.h>
 #include <fairmq/Channel.h>
@@ -83,6 +84,9 @@ void doSendOldestPossibleTimeframe(ServiceRegistryRef ref, fair::mq::TransportFa
 
 bool DataProcessingHelpers::sendOldestPossibleTimeframe(ServiceRegistryRef const& ref, ForwardChannelInfo const& info, ForwardChannelState& state, size_t timeslice)
 {
+  if (ref.get<DecongestionService>().suppressDomainInfo) {
+    return false;
+  }
   if (state.oldestForChannel.value >= timeslice) {
     return false;
   }
@@ -93,6 +97,9 @@ bool DataProcessingHelpers::sendOldestPossibleTimeframe(ServiceRegistryRef const
 
 bool DataProcessingHelpers::sendOldestPossibleTimeframe(ServiceRegistryRef const& ref, OutputChannelInfo const& info, OutputChannelState& state, size_t timeslice)
 {
+  if (ref.get<DecongestionService>().suppressDomainInfo) {
+    return false;
+  }
   if (state.oldestForChannel.value >= timeslice) {
     return false;
   }
diff --git a/Framework/Core/src/DecongestionService.h b/Framework/Core/src/DecongestionService.h
index c45e9a36217ec..1a42d3577bc0a 100644
--- a/Framework/Core/src/DecongestionService.h
+++ b/Framework/Core/src/DecongestionService.h
@@ -18,6 +18,8 @@ namespace o2::framework
 struct DecongestionService {
   /// Wether we are a source in the processing chain
   bool isFirstInTopology = true;
+  /// do not advertise/forward DomainInfoHeader from this device
+  bool suppressDomainInfo = false;
   /// The last timeslice which the ExpirationHandler::Creator callback
   /// created. This can be used to skip dummy iterations.
   size_t nextEnumerationTimeslice = 0;

From 9bbf6ecca2da073db51497ab83d380e4cff355e5 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 7 Jan 2026 10:53:36 +0100
Subject: [PATCH 1183/1764] DPL: more refactoring of the forwarding code

Use a single helper function to improve readability.
---
 .../include/Framework/DataProcessingHelpers.h |   5 +-
 Framework/Core/src/DataProcessingDevice.cxx   |   6 +-
 Framework/Core/src/DataProcessingHelpers.cxx  | 158 +++++++-----------
 Framework/Core/test/test_ForwardInputs.cxx    |  62 ++-----
 4 files changed, 84 insertions(+), 147 deletions(-)

diff --git a/Framework/Core/include/Framework/DataProcessingHelpers.h b/Framework/Core/include/Framework/DataProcessingHelpers.h
index be02aae5d2f69..34bb87613d920 100644
--- a/Framework/Core/include/Framework/DataProcessingHelpers.h
+++ b/Framework/Core/include/Framework/DataProcessingHelpers.h
@@ -53,8 +53,9 @@ struct DataProcessingHelpers {
   /// starts the EoS timers and returns the new TransitionHandlingState in case as new state is requested
   static TransitionHandlingState updateStateTransition(ServiceRegistryRef const& ref, ProcessingPolicies const& policies);
   /// Helper to route messages for forwarding
-  static std::vector<fair::mq::Parts> routeForwardedMessages(FairMQDeviceProxy& proxy, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
-                                                             TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume);
+  static std::vector<fair::mq::Parts> routeForwardedMessages(FairMQDeviceProxy& proxy,
+                                                   std::vector<MessageSet>& currentSetOfInputs,
+                                                   const bool copyByDefault, bool consume);
 };
 } // namespace o2::framework
 #endif // O2_FRAMEWORK_DATAPROCESSINGHELPERS_H_
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 40f1061e60332..63c333561f24e 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -588,10 +588,12 @@ auto decongestionCallbackLate = [](AsyncTask& task, size_t aid) -> void {
 static auto forwardInputs = [](ServiceRegistryRef registry, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
                                TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume = true) {
   auto& proxy = registry.get<FairMQDeviceProxy>();
-  auto forwardedParts = DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copy, consume);
 
   O2_SIGNPOST_ID_GENERATE(sid, forwarding);
-  O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding %zu messages", forwardedParts.size());
+  O2_SIGNPOST_START(forwarding, sid, "forwardInputs", "Starting forwarding for slot %zu with oldestTimeslice %zu %{public}s%{public}s%{public}s",
+                    slot.index, oldestTimeslice.timeslice.value, copy ? "with copy" : "", copy && consume ? " and " : "", consume ? "with consume" : "");
+  auto forwardedParts = DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copy, consume);
+
   for (int fi = 0; fi < proxy.getNumForwardChannels(); fi++) {
     if (forwardedParts[fi].Size() == 0) {
       continue;
diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index aea682a8d00c3..76730e9edab4e 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -228,129 +228,99 @@ TransitionHandlingState DataProcessingHelpers::updateStateTransition(ServiceRegi
   }
 }
 
-static auto toBeForwardedHeader = [](void* header) -> bool {
-  // If is now possible that the record is not complete when
-  // we forward it, because of a custom completion policy.
-  // this means that we need to skip the empty entries in the
-  // record for being forwarded.
-  if (header == nullptr) {
-    return false;
-  }
-  auto dh = o2::header::get<header::DataHeader*>(header);
-  if (!dh) {
-    return false;
-  }
-  bool retval = !o2::header::get<SourceInfoHeader*>(header) &&
-                !o2::header::get<DomainInfoHeader*>(header) &&
-                o2::header::get<DataProcessingHeader*>(header);
-  // DataHeader is there. Complain if we have unexpected headers present / missing
-  if (!retval) {
-    LOGP(error, "Dropping data because of malformed header structure");
-  }
-  return retval;
-};
-
-static auto toBeforwardedMessageSet = [](std::vector<ChannelIndex>& cachedForwardingChoices,
-                                         FairMQDeviceProxy& proxy,
-                                         std::unique_ptr<fair::mq::Message>& header,
-                                         std::unique_ptr<fair::mq::Message>& payload,
-                                         size_t total,
-                                         bool consume) {
-  if (header.get() == nullptr) {
-    // Missing an header is not an error anymore.
-    // it simply means that we did not receive the
-    // given input, but we were asked to
-    // consume existing, so we skip it.
-    return false;
-  }
-  if (payload.get() == nullptr && consume == true) {
-    // If the payload is not there, it means we already
-    // processed it with ConsumeExisiting. Therefore we
-    // need to do something only if this is the last consume.
-    header.reset(nullptr);
-    return false;
-  }
-
-  auto fdph = o2::header::get<DataProcessingHeader*>(header->GetData());
-  if (fdph == nullptr) {
-    LOG(error) << "Data is missing DataProcessingHeader";
-    return false;
-  }
-  auto fdh = o2::header::get<header::DataHeader*>(header->GetData());
-  if (fdh == nullptr) {
-    LOG(error) << "Data is missing DataHeader";
-    return false;
-  }
-
-  // We need to find the forward route only for the first
-  // part of a split payload. All the others will use the same.
-  // but always check if we have a sequence of multiple payloads
-  if (fdh->splitPayloadIndex == 0 || fdh->splitPayloadParts <= 1 || total > 1) {
-    proxy.getMatchingForwardChannelIndexes(cachedForwardingChoices, *fdh, fdph->startTime);
-  }
-  return cachedForwardingChoices.empty() == false;
-};
-
-std::vector<fair::mq::Parts> DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
-                                                                           TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume)
+auto DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy,
+                                                   std::vector<MessageSet>& currentSetOfInputs,
+                                                   const bool copyByDefault, bool consume) -> std::vector<fair::mq::Parts>
 {
   // we collect all messages per forward in a map and send them together
   std::vector<fair::mq::Parts> forwardedParts;
   forwardedParts.resize(proxy.getNumForwards());
-  std::vector<ChannelIndex> cachedForwardingChoices{};
+  std::vector<ChannelIndex> forwardingChoices{};
   O2_SIGNPOST_ID_GENERATE(sid, forwarding);
-  O2_SIGNPOST_START(forwarding, sid, "forwardInputs", "Starting forwarding for slot %zu with oldestTimeslice %zu %{public}s%{public}s%{public}s",
-                    slot.index, oldestTimeslice.timeslice.value, copy ? "with copy" : "", copy && consume ? " and " : "", consume ? "with consume" : "");
 
   for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
     auto& messageSet = currentSetOfInputs[ii];
-    // In case the messageSet is empty, there is nothing to be done.
-    if (messageSet.size() == 0) {
-      continue;
-    }
-    if (!toBeForwardedHeader(messageSet.header(0)->GetData())) {
-      continue;
-    }
-    cachedForwardingChoices.clear();
+    forwardingChoices.clear();
 
-    for (size_t pi = 0; pi < currentSetOfInputs[ii].size(); ++pi) {
-      auto& messageSet = currentSetOfInputs[ii];
+    for (size_t pi = 0; pi < messageSet.size(); ++pi) {
       auto& header = messageSet.header(pi);
+
+      // If is now possible that the record is not complete when
+      // we forward it, because of a custom completion policy.
+      // this means that we need to skip the empty entries in the
+      // record for being forwarded.
+      if (header->GetData() == nullptr) {
+        continue;
+      }
+      auto dih = o2::header::get<DomainInfoHeader*>(header->GetData());
+      if (dih) {
+        continue;
+      }
+      auto sih = o2::header::get<SourceInfoHeader*>(header->GetData());
+      if (sih) {
+        continue;
+      }
+
+      auto dph = o2::header::get<DataProcessingHeader*>(header->GetData());
+      auto dh = o2::header::get<o2::header::DataHeader*>(header->GetData());
+
+      if (dph == nullptr || dh == nullptr) {
+        // Complain only if this is not an out-of-band message
+        LOGP(error, "Data is missing {}{}{}",
+             dph ? "DataProcessingHeader" : "", dph || dh ? "and" : "", dh ? "DataHeader" : "");
+        continue;
+      }
+
       auto& payload = messageSet.payload(pi);
-      auto total = messageSet.getNumberOfPayloads(pi);
 
-      if (!toBeforwardedMessageSet(cachedForwardingChoices, proxy, header, payload, total, consume)) {
+      if (payload.get() == nullptr && consume == true) {
+        // If the payload is not there, it means we already
+        // processed it with ConsumeExisiting. Therefore we
+        // need to do something only if this is the last consume.
+        header.reset(nullptr);
         continue;
       }
 
-      // In case of more than one forward route, we need to copy the message.
-      // This will eventually use the same mamory if running with the same backend.
-      if (cachedForwardingChoices.size() > 1) {
-        copy = true;
+      // We need to find the forward route only for the first
+      // part of a split payload. All the others will use the same.
+      // Therefore, we reset and recompute the forwarding choice:
+      //
+      // - If this is the first payload of a [header0][payload0][header0][payload1] sequence,
+      //   which is actually always created and handled together
+      // - If the message is not a multipart (splitPayloadParts 0) or has only one part
+      // - If it's a message of the kind [header0][payload1][payload2][payload3]... and therefore
+      //   we will already use the same choice in the for loop below.
+      if (dh->splitPayloadIndex == 0 || dh->splitPayloadParts <= 1 || messageSet.getNumberOfPayloads(pi) > 0) {
+        proxy.getMatchingForwardChannelIndexes(forwardingChoices, *dh, dph->startTime);
       }
-      auto* dh = o2::header::get<header::DataHeader*>(header->GetData());
-      auto* dph = o2::header::get<DataProcessingHeader*>(header->GetData());
 
-      if (copy) {
-        for (auto& cachedForwardingChoice : cachedForwardingChoices) {
+      if (forwardingChoices.empty()) {
+        // Nothing to forward go to the next messageset
+        continue;
+      }
+
+      // In case of more than one forward route, we need to copy the message.
+      // This will eventually use the same memory if running with the same backend.
+      if (copyByDefault || forwardingChoices.size() > 1) {
+        for (auto& choice : forwardingChoices) {
           auto&& newHeader = header->GetTransport()->CreateMessage();
           O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding a copy of %{public}s to route %d.",
-                                 fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), cachedForwardingChoice.value);
+                                 fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), choice.value);
           newHeader->Copy(*header);
-          forwardedParts[cachedForwardingChoice.value].AddPart(std::move(newHeader));
+          forwardedParts[choice.value].AddPart(std::move(newHeader));
 
           for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) {
             auto&& newPayload = header->GetTransport()->CreateMessage();
             newPayload->Copy(*messageSet.payload(pi, payloadIndex));
-            forwardedParts[cachedForwardingChoice.value].AddPart(std::move(newPayload));
+            forwardedParts[choice.value].AddPart(std::move(newPayload));
           }
         }
       } else {
         O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding %{public}s to route %d.",
-                               fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), cachedForwardingChoices.back().value);
-        forwardedParts[cachedForwardingChoices.back().value].AddPart(std::move(messageSet.header(pi)));
+                               fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), forwardingChoices.back().value);
+        forwardedParts[forwardingChoices.back().value].AddPart(std::move(messageSet.header(pi)));
         for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) {
-          forwardedParts[cachedForwardingChoices.back().value].AddPart(std::move(messageSet.payload(pi, payloadIndex)));
+          forwardedParts[forwardingChoices.back().value].AddPart(std::move(messageSet.payload(pi, payloadIndex)));
         }
       }
     }
diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
index b1f42fb0398ca..5add90ec8f18e 100644
--- a/Framework/Core/test/test_ForwardInputs.cxx
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -15,8 +15,6 @@
 #include "Framework/DataProcessingHelpers.h"
 #include "Framework/SourceInfoHeader.h"
 #include "Framework/DomainInfoHeader.h"
-#include "Framework/ServiceRegistry.h"
-#include "Framework/ServiceRegistryRef.h"
 #include "Framework/Signpost.h"
 #include "Framework/MessageSet.h"
 #include "Framework/FairMQDeviceProxy.h"
@@ -45,11 +43,9 @@ TEST_CASE("ForwardInputsEmpty")
   bool copyByDefault = true;
   FairMQDeviceProxy proxy;
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {1}};
   std::vector<MessageSet> currentSetOfInputs;
-  TimesliceSlot slot{0};
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.empty());
 }
 
@@ -88,7 +84,6 @@ TEST_CASE("ForwardInputsSingleMessageSingleRoute")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -100,9 +95,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRoute")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 2); // Two messages for that route
 }
@@ -141,7 +134,6 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteNoConsume")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -154,9 +146,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteNoConsume")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, true);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, true);
   REQUIRE(result.size() == 1);
   REQUIRE(result[0].Size() == 0); // Because there is a nullptr, we do not forward this as it was already consumed.
 }
@@ -199,7 +189,6 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteAtEOS")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -212,11 +201,10 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteAtEOS")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
-  REQUIRE(result[0].Size() == 0); // FIXME: this is an actual error. It should be 2
+  REQUIRE(result[0].Size() == 0); // FIXME: this is an actual error. It should be 2. However it cannot really happen.
   // Correct behavior below:
   // REQUIRE(result[0].Size() == 2);
   // REQUIRE(o2::header::get<SourceInfoHeader*>(result[0].At(0)->GetData()) == nullptr);
@@ -260,7 +248,6 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteWithOldestPossible")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -273,9 +260,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteWithOldestPossible")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 0); // FIXME: this is actually wrong
   // FIXME: actually correct behavior below
@@ -329,7 +314,6 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutes")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -341,9 +325,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutes")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);    // Two routes
   REQUIRE(result[0].Size() == 2); // Two messages per route
   REQUIRE(result[1].Size() == 0); // Only the first DPL matched channel matters
@@ -395,7 +377,6 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesExternals")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -407,9 +388,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesExternals")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);    // Two routes
   REQUIRE(result[0].Size() == 2); // With external matching channels, we need to copy and then forward
   REQUIRE(result[1].Size() == 2); //
@@ -468,7 +447,6 @@ TEST_CASE("ForwardInputsMultiMessageMultipleRoutes")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
@@ -488,9 +466,7 @@ TEST_CASE("ForwardInputsMultiMessageMultipleRoutes")
   currentSetOfInputs.emplace_back(std::move(messageSet2));
   REQUIRE(currentSetOfInputs.size() == 2);
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);    // Two routes
   REQUIRE(result[0].Size() == 2); //
   REQUIRE(result[1].Size() == 2); //
@@ -542,7 +518,6 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesOnlyOneMatches")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -554,9 +529,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesOnlyOneMatches")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);    // Two routes
   REQUIRE(result[0].Size() == 0); // Two messages per route
   REQUIRE(result[1].Size() == 2); // Two messages per route
@@ -615,7 +588,6 @@ TEST_CASE("ForwardInputsSplitPayload")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -639,9 +611,7 @@ TEST_CASE("ForwardInputsSplitPayload")
   REQUIRE(messageSet.size() == 2);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);  // Two routes
   CHECK(result[0].Size() == 2); // No messages on this route
   CHECK(result[1].Size() == 5); // FIXME: Multipart matching has side effects also for the elements
@@ -677,7 +647,6 @@ TEST_CASE("ForwardInputEOSSingleRoute")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -689,9 +658,7 @@ TEST_CASE("ForwardInputEOSSingleRoute")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 0); // Oldest possible timeframe should not be forwarded
 }
@@ -725,7 +692,6 @@ TEST_CASE("ForwardInputOldestPossibleSingleRoute")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  TimesliceIndex::OldestOutputInfo oldestTimeslice{.timeslice = {0}};
   std::vector<MessageSet> currentSetOfInputs;
   MessageSet messageSet;
 
@@ -737,9 +703,7 @@ TEST_CASE("ForwardInputOldestPossibleSingleRoute")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  TimesliceSlot slot{0};
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, slot, currentSetOfInputs, oldestTimeslice, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 0); // Oldest possible timeframe should not be forwarded
 }

From 0e958cabd29f9dd6cba3fb1c20c318067807714b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 7 Jan 2026 10:53:36 +0100
Subject: [PATCH 1184/1764] DPL: fix routing issues in forwarding

If one (header, payload, ...) tuple in a MessageSet was to be copied,
all the subsequent ones would have been copied.

If one (header, payload, ...) tuple got redirected to more than one destination,
all the subsequent ones would have been redirected there.
---
 Framework/Core/src/DataProcessingHelpers.cxx | 2 +-
 Framework/Core/test/test_ForwardInputs.cxx   | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index 76730e9edab4e..90dcee52d73da 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -240,7 +240,6 @@ auto DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy,
 
   for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
     auto& messageSet = currentSetOfInputs[ii];
-    forwardingChoices.clear();
 
     for (size_t pi = 0; pi < messageSet.size(); ++pi) {
       auto& header = messageSet.header(pi);
@@ -291,6 +290,7 @@ auto DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy,
       // - If it's a message of the kind [header0][payload1][payload2][payload3]... and therefore
       //   we will already use the same choice in the for loop below.
       if (dh->splitPayloadIndex == 0 || dh->splitPayloadParts <= 1 || messageSet.getNumberOfPayloads(pi) > 0) {
+        forwardingChoices.clear();
         proxy.getMatchingForwardChannelIndexes(forwardingChoices, *dh, dph->startTime);
       }
 
diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
index 5add90ec8f18e..7ddbc831edad2 100644
--- a/Framework/Core/test/test_ForwardInputs.cxx
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -614,8 +614,7 @@ TEST_CASE("ForwardInputsSplitPayload")
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);  // Two routes
   CHECK(result[0].Size() == 2); // No messages on this route
-  CHECK(result[1].Size() == 5); // FIXME: Multipart matching has side effects also for the elements
-  // CHECK(result[1].Size() == 3); // FIXME: the correct forwarding is that only the multipart goes to the same route
+  CHECK(result[1].Size() == 3);
 }
 
 TEST_CASE("ForwardInputEOSSingleRoute")

From c426fe5cb1ad85f34394d53e6c15a19283cae76e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 10 Nov 2025 10:30:15 +0100
Subject: [PATCH 1185/1764] ITS: remove CookedTracker

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/reconstruction/CMakeLists.txt  |   7 +-
 .../ITSReconstruction/CookedConfigParam.h     |  42 -
 .../include/ITSReconstruction/CookedTracker.h | 267 ------
 .../reconstruction/src/CookedConfigParam.cxx  |  22 -
 .../ITS/reconstruction/src/CookedTracker.cxx  | 865 ------------------
 .../reconstruction/src/CookedTrackerLinkDef.h |  26 -
 .../src/ITSReconstructionLinkDef.h            |   4 -
 Detectors/ITSMFT/ITS/workflow/CMakeLists.txt  |   1 -
 .../include/ITSWorkflow/CookedTrackerSpec.h   |  75 --
 .../include/ITSWorkflow/RecoWorkflow.h        |   2 +-
 .../ITS/workflow/src/CookedTrackerSpec.cxx    | 327 -------
 .../ITSMFT/ITS/workflow/src/RecoWorkflow.cxx  |  60 +-
 .../ITS/workflow/src/its-reco-workflow.cxx    |   5 +-
 macro/CMakeLists.txt                          |  34 -
 macro/run_trac_its.C                          | 222 -----
 15 files changed, 30 insertions(+), 1929 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/CookedConfigParam.h
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/CookedTracker.h
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/src/CookedConfigParam.cxx
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/src/CookedTracker.cxx
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/src/CookedTrackerLinkDef.h
 delete mode 100644 Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
 delete mode 100644 Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
 delete mode 100644 macro/run_trac_its.C

diff --git a/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt b/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
index 3e1544c65b9de..a5004418599e4 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
@@ -11,8 +11,6 @@
 
 o2_add_library(ITSReconstruction
         SOURCES src/ClustererTask.cxx
-                src/CookedTracker.cxx
-                src/CookedConfigParam.cxx
                 src/RecoGeomHelper.cxx
                 src/FastMultEstConfig.cxx
                 src/FastMultEst.cxx
@@ -24,9 +22,6 @@ o2_add_library(ITSReconstruction
 o2_target_root_dictionary(
   ITSReconstruction
   HEADERS include/ITSReconstruction/ClustererTask.h
-          include/ITSReconstruction/CookedTracker.h
-          include/ITSReconstruction/CookedConfigParam.h
           include/ITSReconstruction/RecoGeomHelper.h
           include/ITSReconstruction/FastMultEst.h
-          include/ITSReconstruction/FastMultEstConfig.h
-  LINKDEF src/CookedTrackerLinkDef.h)
+          include/ITSReconstruction/FastMultEstConfig.h)
diff --git a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/CookedConfigParam.h b/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/CookedConfigParam.h
deleted file mode 100644
index bfc111d0a3803..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/CookedConfigParam.h
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef ALICEO2_COOKEDTRACKINGPARAM_H_
-#define ALICEO2_COOKEDTRACKINGPARAM_H_
-
-#include "CommonUtils/ConfigurableParamHelper.h"
-
-namespace o2
-{
-namespace its
-{
-
-struct CookedConfigParam : public o2::conf::ConfigurableParamHelper<CookedConfigParam> {
-  // seed "windows" in z and phi: makeSeeds
-  float zWin = 0.33;
-  float minPt = 0.05;
-  // Maximal accepted impact parameters for the seeds
-  float maxDCAxy = 3.;
-  float maxDCAz = 3.;
-  // Space-point resolution
-  float sigma = 0.0005;
-  // Tracking "road" from layer to layer
-  float roadY = 0.2;
-  float roadZ = 0.3;
-  // Minimal number of attached clusters
-  int minNumberOfClusters = 4;
-
-  O2ParamDef(CookedConfigParam, "ITSCookedTracker");
-};
-
-} // namespace its
-} // namespace o2
-#endif
diff --git a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/CookedTracker.h b/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/CookedTracker.h
deleted file mode 100644
index 918f7f82cbff8..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/CookedTracker.h
+++ /dev/null
@@ -1,267 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file CookedTracker.h
-/// \brief Definition of the "Cooked Matrix" ITS tracker
-/// \author iouri.belikov@cern.ch
-
-#ifndef ALICEO2_ITS_COOKEDTRACKER_H
-#define ALICEO2_ITS_COOKEDTRACKER_H
-
-//-------------------------------------------------------------------------
-//                   A stand-alone ITS tracker
-//    The pattern recongintion based on the "cooked covariance" approach
-//-------------------------------------------------------------------------
-
-#include <vector>
-#include <tuple>
-#include "ITSBase/GeometryTGeo.h"
-#include "MathUtils/Cartesian.h"
-#include "DataFormatsITSMFT/Cluster.h"
-#include "DataFormatsITS/TrackITS.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "ReconstructionDataFormats/Vertex.h"
-#include "ITSReconstruction/CookedConfigParam.h"
-
-using Point3Df = o2::math_utils::Point3D<float>;
-
-namespace o2
-{
-class MCCompLabel;
-namespace dataformats
-{
-template <typename T>
-class MCTruthContainer;
-}
-namespace itsmft
-{
-class TopologyDictionary;
-class CompClusterExt;
-} // namespace itsmft
-namespace its
-{
-class CookedTracker
-{
-  using Cluster = o2::itsmft::Cluster;
-  using CompClusterExt = o2::itsmft::CompClusterExt;
-  using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
- public:
-  CookedTracker(Int_t nThreads = 1);
-  CookedTracker(const CookedTracker&) = delete;
-  CookedTracker& operator=(const CookedTracker& tr) = delete;
-  ~CookedTracker() = default;
-
-  void setConfigParams()
-  {
-    const auto& par = CookedConfigParam::Instance();
-    LOG(info) << " Setting configurable parameters...";
-
-    gzWin = par.zWin;
-    gminPt = par.minPt;
-    gmaxDCAxy = par.maxDCAxy;
-    gmaxDCAz = par.maxDCAz;
-    gSigma2 = par.sigma * par.sigma;
-    gRoadY = par.roadY;
-    gRoadZ = par.roadZ;
-    gminNumberOfClusters = par.minNumberOfClusters;
-  }
-  void setParameters(const std::vector<float>& par)
-  {
-    gzWin = par[0];
-    gminPt = par[1];
-    gmaxDCAxy = par[3];
-    gmaxDCAz = par[4];
-    gSeedingLayer1 = par[5];
-    gSeedingLayer2 = par[6];
-    gSeedingLayer3 = par[7];
-    gSigma2 = par[8] * par[8];
-    gmaxChi2PerCluster = par[9];
-    gmaxChi2PerTrack = par[10];
-    gRoadY = par[11];
-    gRoadZ = par[12];
-    gminNumberOfClusters = par[13];
-  }
-  void setParametersCosmics()
-  {
-    // seed "windows" in z and phi: makeSeeds
-    gzWin = 84.; // length of the L3
-    gminPt = 10.;
-    // Maximal accepted impact parameters for the seeds
-    gmaxDCAxy = 19.4; // radius of the L3
-    gmaxDCAz = 42.;   // half-lenght of the L3
-    // Space point resolution
-    gSigma2 = 0.2 * 0.2;
-    // Tracking "road" from layer to layer
-    gRoadY = 1.5; // Chip size in Y
-    gRoadZ = 3.0; // Chip size in Z
-  }
-
-  void setVertices(const std::vector<Vertex>& vertices)
-  {
-    mVertices = &vertices;
-  }
-
-  Double_t getX() const { return mX; }
-  Double_t getY() const { return mY; }
-  Double_t getZ() const { return mZ; }
-  Double_t getSigmaX() const { return mSigmaX; }
-  Double_t getSigmaY() const { return mSigmaY; }
-  Double_t getSigmaZ() const { return mSigmaZ; }
-  o2::MCCompLabel cookLabel(TrackITSExt& t, Float_t wrong) const;
-  void setExternalIndices(TrackITSExt& t) const;
-  Double_t getBz() const;
-  void setBz(Double_t bz) { mBz = bz; }
-
-  void setNumberOfThreads(Int_t n) { mNumOfThreads = n; }
-  Int_t getNumberOfThreads() const { return mNumOfThreads; }
-
-  using TrackInserter = std::function<int(const TrackITSExt& t)>;
-  // These functions must be implemented
-  template <typename U, typename V>
-  void process(gsl::span<const CompClusterExt> clusters, gsl::span<const unsigned char>::iterator& it, const o2::itsmft::TopologyDictionary* dict, U& tracks, V& clusIdx, o2::itsmft::ROFRecord& rof)
-  {
-    TrackInserter inserter = [&tracks, &clusIdx, this](const TrackITSExt& t) -> int {
-      // convert internal track to output format
-      auto& trackNew = tracks.emplace_back(t);
-      int noc = t.getNumberOfClusters();
-      int clEntry = clusIdx.size();
-      for (int i = 0; i < noc; i++) {
-        const Cluster* c = this->getCluster(t.getClusterIndex(i));
-        Int_t idx = c - &mClusterCache[0]; // Index of this cluster in event
-        clusIdx.emplace_back(this->mFirstInFrame + idx);
-      }
-      trackNew.setClusterRefs(clEntry, noc);
-      trackNew.setPattern(0x7f); // this tracker finds only complete tracks
-      return tracks.size();
-    };
-    process(clusters, it, dict, inserter, rof);
-  }
-  void process(gsl::span<const CompClusterExt> const& clusters, gsl::span<const unsigned char>::iterator& it, const o2::itsmft::TopologyDictionary* dict, TrackInserter& inserter, o2::itsmft::ROFRecord& rof);
-  const Cluster* getCluster(Int_t index) const;
-
-  void setGeometry(o2::its::GeometryTGeo* geom);
-  void setMCTruthContainers(const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* clsLabels, std::vector<o2::MCCompLabel>* trkLabels)
-  {
-    mClsLabels = clsLabels;
-    mTrkLabels = trkLabels;
-  }
-
-  void setContinuousMode(bool mode) { mContinuousMode = mode; }
-  bool getContinuousMode() { return mContinuousMode; }
-
-  static void setMostProbablePt(float pt) { mMostProbablePt = pt; }
-  static auto getMostProbablePt() { return mMostProbablePt; }
-
-  // internal helper classes
-  class ThreadData;
-  class Layer;
-
- protected:
-  static constexpr int kNLayers = 7;
-  int loadClusters();
-  void unloadClusters();
-  std::tuple<int, int> processLoadedClusters(TrackInserter& inserter);
-
-  std::vector<TrackITSExt> trackInThread(Int_t first, Int_t last);
-  o2::its::TrackITSExt cookSeed(const Point3Df& r1, Point3Df& r2, const Point3Df& tr3, float rad2, float rad3, float_t alpha, float_t bz);
-  void makeSeeds(std::vector<TrackITSExt>& seeds, Int_t first, Int_t last);
-  void trackSeeds(std::vector<TrackITSExt>& seeds);
-
-  Bool_t attachCluster(Int_t& volID, Int_t nl, Int_t ci, TrackITSExt& t, const TrackITSExt& o) const;
-
-  void makeBackPropParam(std::vector<TrackITSExt>& seeds) const;
-  bool makeBackPropParam(TrackITSExt& track) const;
-
- private:
-  /*** Tracking parameters ***/
-  // seed "windows" in z and phi: makeSeeds
-  static Float_t gzWin;
-  static Float_t gminPt;
-  static Float_t mMostProbablePt; ///< settable most probable pt
-  // Maximal accepted impact parameters for the seeds
-  static Float_t gmaxDCAxy;
-  static Float_t gmaxDCAz;
-  // Layers for the seeding
-  static Int_t gSeedingLayer1;
-  static Int_t gSeedingLayer2;
-  static Int_t gSeedingLayer3;
-  // Space point resolution
-  static Float_t gSigma2;
-  // Max accepted chi2
-  static Float_t gmaxChi2PerCluster;
-  static Float_t gmaxChi2PerTrack;
-  // Tracking "road" from layer to layer
-  static Float_t gRoadY;
-  static Float_t gRoadZ;
-  // Minimal number of attached clusters
-  static Int_t gminNumberOfClusters;
-
-  bool mContinuousMode = true;                                                    ///< triggered or cont. mode
-  const o2::its::GeometryTGeo* mGeom = nullptr;                                   /// interface to geometry
-  const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mClsLabels = nullptr; /// Cluster MC labels
-  std::vector<o2::MCCompLabel>* mTrkLabels = nullptr;                             /// Track MC labels
-  std::uint32_t mFirstInFrame = 0;                                                ///< Index of the 1st cluster of a frame (within the loaded vector of clusters)
-
-  Int_t mNumOfThreads; ///< Number of tracking threads
-
-  Double_t mBz; ///< Effective Z-component of the magnetic field (kG)
-
-  const std::vector<Vertex>* mVertices = nullptr;
-  Double_t mX = 0.; ///< X-coordinate of the primary vertex
-  Double_t mY = 0.; ///< Y-coordinate of the primary vertex
-  Double_t mZ = 0.; ///< Z-coordinate of the primary vertex
-
-  Double_t mSigmaX = 2.; ///< error of the primary vertex position in X
-  Double_t mSigmaY = 2.; ///< error of the primary vertex position in Y
-  Double_t mSigmaZ = 2.; ///< error of the primary vertex position in Z
-
-  static Layer sLayers[kNLayers];  ///< Layers filled with clusters
-  std::vector<TrackITSExt> mSeeds; ///< Track seeds
-
-  std::vector<Cluster> mClusterCache;
-
-  ClassDefNV(CookedTracker, 1);
-};
-
-class CookedTracker::Layer
-{
- public:
-  Layer();
-  Layer(const Layer&) = delete;
-  Layer& operator=(const Layer& tr) = delete;
-
-  void init();
-  Bool_t insertCluster(const Cluster* c);
-  void setR(Double_t r) { mR = r; }
-  void unloadClusters();
-  void selectClusters(std::vector<Int_t>& s, Float_t phi, Float_t dy, Float_t z, Float_t dz);
-  Int_t findClusterIndex(Float_t z) const;
-  Float_t getR() const { return mR; }
-  const Cluster* getCluster(Int_t i) const { return mClusters[i]; }
-  Float_t getAlphaRef(Int_t i) const { return mAlphaRef[i]; }
-  Float_t getClusterPhi(Int_t i) const { return mPhi[i]; }
-  Int_t getNumberOfClusters() const { return mClusters.size(); }
-  void setGeometry(o2::its::GeometryTGeo* geom) { mGeom = geom; }
-
- protected:
-  enum { kNSectors = 21 };
-
-  Float_t mR;                                             ///< mean radius of this layer
-  const o2::its::GeometryTGeo* mGeom = nullptr;           ///< interface to geometry
-  std::vector<const Cluster*> mClusters;                  ///< All clusters
-  std::vector<Float_t> mAlphaRef;                         ///< alpha of the reference plane
-  std::vector<Float_t> mPhi;                              ///< cluster phi
-  std::vector<std::pair<int, float>> mSectors[kNSectors]; ///< Cluster indices sector-by-sector
-};
-} // namespace its
-} // namespace o2
-#endif /* ALICEO2_ITS_COOKEDTRACKER_H */
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/CookedConfigParam.cxx b/Detectors/ITSMFT/ITS/reconstruction/src/CookedConfigParam.cxx
deleted file mode 100644
index 81087744b04a9..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/src/CookedConfigParam.cxx
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "ITSReconstruction/CookedConfigParam.h"
-
-namespace o2
-{
-namespace its
-{
-static auto& sITSCookedTrackerParam = o2::its::CookedConfigParam::Instance();
-
-O2ParamImpl(o2::its::CookedConfigParam);
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/CookedTracker.cxx b/Detectors/ITSMFT/ITS/reconstruction/src/CookedTracker.cxx
deleted file mode 100644
index 5c804f6705dfd..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/src/CookedTracker.cxx
+++ /dev/null
@@ -1,865 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file CookedTracker.cxx
-/// \brief Implementation of the "Cooked Matrix" ITS tracker
-/// \author iouri.belikov@cern.ch
-
-//-------------------------------------------------------------------------
-//                     A stand-alone ITS tracker
-//    The pattern recongintion based on the "cooked covariance" approach
-//-------------------------------------------------------------------------
-#include <chrono>
-#include <future>
-#include <map>
-
-#include <TGeoGlobalMagField.h>
-#include <TMath.h>
-
-#include <fairlogger/Logger.h>
-
-#include "CommonConstants/MathConstants.h"
-#include "DetectorsBase/Propagator.h"
-#include "Field/MagneticField.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "DataFormatsITSMFT/TopologyDictionary.h"
-#include "ITSReconstruction/CookedTracker.h"
-#include "MathUtils/Utils.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-
-using namespace o2::its;
-using namespace o2::itsmft;
-using namespace o2::constants::math;
-using o2::field::MagneticField;
-using Label = o2::MCCompLabel;
-
-/*** Tracking parameters ***/
-// seed "windows" in z and phi: makeSeeds
-Float_t CookedTracker::gzWin = 0.33;
-Float_t CookedTracker::gminPt = 0.05;
-Float_t CookedTracker::mMostProbablePt = o2::track::kMostProbablePt;
-// Maximal accepted impact parameters for the seeds
-Float_t CookedTracker::gmaxDCAxy = 3.;
-Float_t CookedTracker::gmaxDCAz = 3.;
-// Layers for the seeding
-Int_t CookedTracker::gSeedingLayer1 = 6;
-Int_t CookedTracker::gSeedingLayer2 = 4;
-Int_t CookedTracker::gSeedingLayer3 = 5;
-// Space point resolution
-Float_t CookedTracker::gSigma2 = 0.0005 * 0.0005;
-// Max accepted chi2
-Float_t CookedTracker::gmaxChi2PerCluster = 20.;
-Float_t CookedTracker::gmaxChi2PerTrack = 30.;
-// Tracking "road" from layer to layer
-Float_t CookedTracker::gRoadY = 0.2;
-Float_t CookedTracker::gRoadZ = 0.3;
-// Minimal number of attached clusters
-Int_t CookedTracker::gminNumberOfClusters = 4;
-
-const float kPI = 3.14159f;
-const float k2PI = 2 * kPI;
-
-//************************************************
-// TODO:
-//************************************************
-// Seeding:
-// Precalculate cylidnrical (r,phi) for the clusters;
-// use exact r's for the clusters
-
-CookedTracker::Layer CookedTracker::sLayers[CookedTracker::kNLayers];
-
-CookedTracker::CookedTracker(Int_t n) : mNumOfThreads(n), mBz(0.)
-{
-  //--------------------------------------------------------------------
-  // This default constructor needs to be provided
-  //--------------------------------------------------------------------
-  const Double_t klRadius[7] = {2.34, 3.15, 3.93, 19.61, 24.55, 34.39, 39.34}; // tdr6
-
-  for (Int_t i = 0; i < kNLayers; i++) {
-    sLayers[i].setR(klRadius[i]);
-  }
-}
-
-//__________________________________________________________________________
-Label CookedTracker::cookLabel(TrackITSExt& t, Float_t wrong) const
-{
-  //--------------------------------------------------------------------
-  // This function "cooks" a track label.
-  // A label<0 indicates that some of the clusters are wrongly assigned.
-  //--------------------------------------------------------------------
-  Int_t noc = t.getNumberOfClusters();
-  std::map<Label, int> labelOccurence;
-
-  for (int i = noc; i--;) {
-    const Cluster* c = getCluster(t.getClusterIndex(i));
-    Int_t idx = c - &mClusterCache[0] + mFirstInFrame; // Index of this cluster in event
-    auto labels = mClsLabels->getLabels(idx);
-
-    for (auto lab : labels) { // check all labels of the cluster
-      if (lab.isEmpty()) {
-        break; // all following labels will be empty also
-      }
-      // was this label already accounted for ?
-      labelOccurence[lab]++;
-    }
-  }
-  Label lab;
-  Int_t maxL = 0; // find most encountered label
-  for (auto [label, count] : labelOccurence) {
-    if (count <= maxL) {
-      continue;
-    }
-    maxL = count;
-    lab = label;
-  }
-
-  if ((1. - Float_t(maxL) / noc) > wrong) {
-    // change the track ID to negative
-    lab.setFakeFlag();
-  }
-  // t.SetFakeRatio((1.- Float_t(maxL)/noc));
-  return lab;
-}
-
-Double_t CookedTracker::getBz() const
-{
-  return mBz;
-}
-
-static Double_t f1(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3)
-{
-  //-----------------------------------------------------------------
-  // Initial approximation of the track curvature
-  //-----------------------------------------------------------------
-  Double_t d = (x2 - x1) * (y3 - y2) - (x3 - x2) * (y2 - y1);
-  Double_t a =
-    0.5 * ((y3 - y2) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1) - (y2 - y1) * (y3 * y3 - y2 * y2 + x3 * x3 - x2 * x2));
-  Double_t b =
-    0.5 * ((x2 - x1) * (y3 * y3 - y2 * y2 + x3 * x3 - x2 * x2) - (x3 - x2) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1));
-
-  Double_t xr = TMath::Abs(d / (d * x1 - a)), yr = TMath::Abs(d / (d * y1 - b));
-
-  Double_t crv = xr * yr / sqrt(xr * xr + yr * yr);
-  if (d > 0) {
-    crv = -crv;
-  }
-
-  return crv;
-}
-
-static Double_t f2(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t x3, Double_t y3)
-{
-  //-----------------------------------------------------------------
-  // Initial approximation of the x-coordinate of the center of curvature
-  //-----------------------------------------------------------------
-
-  Double_t k1 = (y2 - y1) / (x2 - x1), k2 = (y3 - y2) / (x3 - x2);
-  Double_t x0 = 0.5 * (k1 * k2 * (y1 - y3) + k2 * (x1 + x2) - k1 * (x2 + x3)) / (k2 - k1);
-
-  return x0;
-}
-
-static Double_t f3(Double_t x1, Double_t y1, Double_t x2, Double_t y2, Double_t z1, Double_t z2)
-{
-  //-----------------------------------------------------------------
-  // Initial approximation of the tangent of the track dip angle
-  //-----------------------------------------------------------------
-  return (z1 - z2) / sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
-}
-
-o2::its::TrackITSExt CookedTracker::cookSeed(const Point3Df& r1, Point3Df& r2, const Point3Df& tr3, float rad2, float rad3, float_t alpha, float_t bz)
-// const  Float_t r1[4], const Float_t r2[4], const Float_t tr3[4], Double_t alpha, Double_t bz)
-{
-  //--------------------------------------------------------------------
-  // This is the main cooking function.
-  // Creates seed parameters out of provided clusters.
-  //--------------------------------------------------------------------
-
-  Double_t ca = TMath::Cos(alpha), sa = TMath::Sin(alpha);
-  Double_t x1 = r1.X() * ca + r1.Y() * sa, y1 = -r1.X() * sa + r1.Y() * ca, z1 = r1.Z();
-  Double_t x2 = r2.X() * ca + r2.Y() * sa, y2 = -r2.X() * sa + r2.Y() * ca, z2 = r2.Z();
-  Double_t x3 = tr3.X(), y3 = tr3.Y(), z3 = tr3.Z();
-
-  std::array<float, 5> par;
-  par[0] = y3;
-  par[1] = z3;
-  Double_t crv = f1(x1, y1, x2, y2, x3, y3); // curvature
-  Double_t x0 = f2(x1, y1, x2, y2, x3, y3);  // x-coordinate of the center
-  Double_t tgl12 = f3(x1, y1, x2, y2, z1, z2);
-  Double_t tgl23 = f3(x2, y2, x3, y3, z2, z3);
-
-  Double_t sf = crv * (x3 - x0); // FIXME: sf must never be >= kAlmost1
-  par[2] = sf;
-
-  par[3] = 0.5 * (tgl12 + tgl23);
-  par[4] = (TMath::Abs(bz) < Almost0) ? 1 / CookedTracker::getMostProbablePt() : crv / (bz * B2C);
-
-  std::array<float, 15> cov;
-  /*
-  for (Int_t i=0; i<15; i++) cov[i]=0.;
-  cov[0] =gSigma2*10;
-  cov[2] =gSigma2*10;
-  cov[5] =0.007*0.007*10;   //FIXME all these lines
-  cov[9] =0.007*0.007*10;
-  cov[14]=0.1*0.1*10;
-  */
-  const Double_t dlt = 0.0005;
-  Double_t fy = 1. / (rad2 - rad3);
-  Double_t tz = fy;
-  const auto big = sqrt(o2::constants::math::VeryBig);
-  auto cy = big;
-  if (TMath::Abs(bz) >= Almost0) {
-    auto tmp = dlt * bz * B2C;
-    cy = (f1(x1, y1, x2, y2 + dlt, x3, y3) - crv) / tmp;
-    cy *= 20; // FIXME: MS contribution to the cov[14]
-  }
-  Double_t s2 = gSigma2;
-
-  cov[0] = s2;
-  cov[1] = 0.;
-  cov[2] = s2;
-  cov[3] = s2 * fy;
-  cov[4] = 0.;
-  cov[5] = s2 * fy * fy;
-  cov[6] = 0.;
-  cov[7] = s2 * tz;
-  cov[8] = 0.;
-  cov[9] = s2 * tz * tz;
-  cov[10] = s2 * cy;
-  cov[11] = 0.;
-  cov[12] = s2 * fy * cy;
-  cov[13] = 0.;
-  cov[14] = s2 * cy * cy;
-
-  return o2::its::TrackITSExt(x3, alpha, par, cov);
-}
-
-void CookedTracker::makeSeeds(std::vector<TrackITSExt>& seeds, Int_t first, Int_t last)
-{
-  //--------------------------------------------------------------------
-  // This is the main pattern recongition function.
-  // Creates seeds out of two clusters and another point.
-  //--------------------------------------------------------------------
-  const float zv = getZ();
-
-  Layer& layer1 = sLayers[gSeedingLayer1];
-  Layer& layer2 = sLayers[gSeedingLayer2];
-  Layer& layer3 = sLayers[gSeedingLayer3];
-
-  auto bz = getBz();
-  const Double_t maxC = (TMath::Abs(bz) < Almost0) ? 0.03 : TMath::Abs(bz * B2C / gminPt);
-  const Double_t kpWinC = TMath::ASin(0.5 * maxC * layer1.getR()) - TMath::ASin(0.5 * maxC * layer2.getR());
-  const Double_t kpWinD = 2 * (TMath::ASin(gmaxDCAxy / layer2.getR()) - TMath::ASin(gmaxDCAxy / layer1.getR()));
-  const Double_t kpWin = std::max(kpWinC, kpWinD);
-
-  for (Int_t n1 = first; n1 < last; n1++) {
-    const Cluster* c1 = layer1.getCluster(n1);
-    //
-    //auto lab = (mClsLabels->getLabels(c1 - &mClusterCache[0] + mFirstInFrame))[0];
-    //
-    auto xyz1 = c1->getXYZGloRot(*mGeom);
-    auto z1 = xyz1.Z();
-    auto r1 = xyz1.rho();
-
-    auto phi1 = layer1.getClusterPhi(n1);
-    auto tgl = std::abs((z1 - zv) / r1);
-
-    auto zr2 = zv + layer2.getR() / r1 * (z1 - zv);
-    auto phir2 = phi1;
-    auto dz2 = gzWin * (1 + 2 * tgl);
-
-    std::vector<Int_t> selected2;
-    float dy2 = kpWin * layer2.getR();
-    layer2.selectClusters(selected2, phir2, dy2, zr2, dz2);
-    for (auto n2 : selected2) {
-      const Cluster* c2 = layer2.getCluster(n2);
-      //
-      //if ((mClsLabels->getLabels(c2 - &mClusterCache[0] + mFirstInFrame))[0] != lab) continue;
-      //
-      auto xyz2 = c2->getXYZGloRot(*mGeom);
-      auto z2 = xyz2.Z();
-      auto r2 = xyz2.rho();
-
-      auto dx = xyz2.X() - xyz1.X(), dy = xyz2.Y() - xyz1.Y();
-      auto d = (dx * xyz1.Y() - dy * xyz1.X()) / TMath::Sqrt(dx * dx + dy * dy);
-      auto phir3 = phi1 + TMath::ASin(d / r1) - TMath::ASin(d / layer3.getR());
-
-      auto zr3 = z1 + (layer3.getR() - r1) / (r2 - r1) * (z2 - z1);
-      auto dz3 = 0.5f * dz2;
-
-      std::vector<Int_t> selected3;
-      float dy3 = 0.1 * kpWin * layer3.getR(); //Fixme
-      layer3.selectClusters(selected3, phir3, dy3, zr3, dz3);
-      for (auto n3 : selected3) {
-        const Cluster* c3 = layer3.getCluster(n3);
-        //
-        //if ((mClsLabels->getLabels(c3 - &mClusterCache[0] + mFirstInFrame))[0] != lab) continue;
-        //
-        auto xyz3 = c3->getXYZGloRot(*mGeom);
-        auto z3 = xyz3.Z();
-        auto r3 = xyz3.rho();
-
-        zr3 = z1 + (r3 - r1) / (r2 - r1) * (z2 - z1);
-        if (std::abs(z3 - zr3) > 0.2 * dz3) {
-          continue;
-        }
-
-        const Point3Df& txyz2 = c2->getXYZ(); // tracking coordinates
-
-        TrackITSExt seed = cookSeed(xyz1, xyz3, txyz2, layer2.getR(), layer3.getR(), layer2.getAlphaRef(n2), getBz());
-
-        float ip[2];
-        seed.getImpactParams(getX(), getY(), getZ(), getBz(), ip);
-        if (TMath::Abs(ip[0]) > gmaxDCAxy) {
-          continue;
-        }
-        if (TMath::Abs(ip[1]) > gmaxDCAz) {
-          continue;
-        }
-        {
-          Double_t xx0 = 0.008; // Rough layer thickness
-          Double_t radl = 9.36; // Radiation length of Si [cm]
-          Double_t rho = 2.33;  // Density of Si [g/cm^3]
-          if (!seed.correctForMaterial(xx0, xx0 * radl * rho, kTRUE)) {
-            continue;
-          }
-        }
-        seed.setClusterIndex(gSeedingLayer1, n1);
-        seed.setClusterIndex(gSeedingLayer3, n3);
-        seed.setClusterIndex(gSeedingLayer2, n2);
-        seeds.push_back(seed);
-      }
-    }
-  }
-  /*
-  for (Int_t n1 = 0; n1 < nClusters1; n1++) {
-    Cluster* c1 = layer1.getCluster(n1);
-    ((Cluster*)c1)->goToFrameTrk();
-  }
-  for (Int_t n2 = 0; n2 < nClusters2; n2++) {
-    Cluster* c2 = layer2.getCluster(n2);
-    ((Cluster*)c2)->goToFrameTrk();
-  }
-  for (Int_t n3 = 0; n3 < nClusters3; n3++) {
-    Cluster* c3 = layer3.getCluster(n3);
-    ((Cluster*)c3)->goToFrameTrk();
-  }
-  */
-}
-
-void CookedTracker::trackSeeds(std::vector<TrackITSExt>& seeds)
-{
-  //--------------------------------------------------------------------
-  // Loop over a subset of track seeds
-  //--------------------------------------------------------------------
-  std::vector<bool> used[gSeedingLayer2];
-  std::vector<Int_t> selec[gSeedingLayer2];
-  for (Int_t l = gSeedingLayer2 - 1; l >= 0; l--) {
-    Int_t n = sLayers[l].getNumberOfClusters();
-    used[l].resize(n, false);
-    selec[l].reserve(n / 100);
-  }
-
-  for (auto& track : seeds) {
-    auto x = track.getX();
-    auto y = track.getY();
-    Float_t phi = track.getAlpha() + TMath::ATan2(y, x);
-    o2::math_utils::bringTo02Pi(phi);
-    float ip[2];
-    track.getImpactParams(getX(), getY(), getZ(), getBz(), ip);
-
-    auto z = track.getZ();
-    auto crv = track.getCurvature(getBz());
-    auto tgl = track.getTgl();
-    Float_t r1 = sLayers[gSeedingLayer2].getR();
-
-    for (Int_t l = gSeedingLayer2 - 1; l >= 0; l--) {
-      Float_t r2 = sLayers[l].getR();
-      selec[l].clear();
-      if (TMath::Abs(ip[0]) > r2) {
-        break;
-      }
-      if (TMath::Abs(crv) < gRoadY / (0.5 * r1 * 0.5 * r1)) {
-        phi += TMath::ASin(ip[0] / r2) - TMath::ASin(ip[0] / r1);
-        z += tgl * (TMath::Sqrt(r2 * r2 - ip[0] * ip[0]) - TMath::Sqrt(r1 * r1 - ip[0] * ip[0]));
-      } else { // Fixme
-        phi += 0.5 * crv * (r2 - r1);
-        z += tgl / (0.5 * crv) * (TMath::ASin(0.5 * crv * r2) - TMath::ASin(0.5 * crv * r1));
-      }
-      sLayers[l].selectClusters(selec[l], phi, gRoadY, z, gRoadZ * (1 + 2 * std::abs(tgl)));
-      r1 = r2;
-    }
-
-    TrackITSExt best(track);
-
-    Int_t volID = -1;
-    for (auto& ci3 : selec[3]) {
-      TrackITSExt t3(track);
-      if (used[3][ci3]) {
-        continue;
-      }
-      if (!attachCluster(volID, 3, ci3, t3, track)) {
-        continue;
-      }
-      if (t3.isBetter(best, gmaxChi2PerTrack)) {
-        best = t3;
-      }
-
-      for (auto& ci2 : selec[2]) {
-        TrackITSExt t2(t3);
-        if (used[2][ci2]) {
-          continue;
-        }
-        if (!attachCluster(volID, 2, ci2, t2, t3)) {
-          continue;
-        }
-        if (t2.isBetter(best, gmaxChi2PerTrack)) {
-          best = t2;
-        }
-
-        for (auto& ci1 : selec[1]) {
-          TrackITSExt t1(t2);
-          if (used[1][ci1]) {
-            continue;
-          }
-          if (!attachCluster(volID, 1, ci1, t1, t2)) {
-            continue;
-          }
-          if (t1.isBetter(best, gmaxChi2PerTrack)) {
-            best = t1;
-          }
-
-          for (auto& ci0 : selec[0]) {
-            TrackITSExt t0(t1);
-            if (used[0][ci0]) {
-              continue;
-            }
-            if (!attachCluster(volID, 0, ci0, t0, t1)) {
-              continue;
-            }
-            if (t0.isBetter(best, gmaxChi2PerTrack)) {
-              best = t0;
-            }
-            volID = -1;
-          }
-        }
-      }
-    }
-
-    if (best.getNumberOfClusters() >= gminNumberOfClusters) {
-      Int_t noc = best.getNumberOfClusters();
-      for (Int_t ic = 3; ic < noc; ic++) {
-        Int_t index = best.getClusterIndex(ic);
-        Int_t l = (index & 0xf0000000) >> 28, c = (index & 0x0fffffff);
-        used[l][c] = true;
-      }
-    }
-    track = best;
-  }
-}
-
-std::vector<TrackITSExt> CookedTracker::trackInThread(Int_t first, Int_t last)
-{
-  //--------------------------------------------------------------------
-  // This function is passed to a tracking thread
-  //--------------------------------------------------------------------
-  std::vector<TrackITSExt> seeds;
-  seeds.reserve(last - first + 1);
-
-  for (const auto& vtx : *mVertices) {
-    mX = vtx.getX();
-    mY = vtx.getY();
-    mZ = vtx.getZ();
-    makeSeeds(seeds, first, last);
-  }
-
-  std::sort(seeds.begin(), seeds.end());
-
-  trackSeeds(seeds);
-
-  makeBackPropParam(seeds);
-
-  return seeds;
-}
-
-void CookedTracker::process(gsl::span<const o2::itsmft::CompClusterExt> const& clusters,
-                            gsl::span<const unsigned char>::iterator& pattIt,
-                            const o2::itsmft::TopologyDictionary* dict,
-                            TrackInserter& inserter,
-                            o2::itsmft::ROFRecord& rof)
-{
-  //--------------------------------------------------------------------
-  // This is the main tracking function
-  //--------------------------------------------------------------------
-  if (mVertices == nullptr || mVertices->empty()) {
-    LOG(info) << "Not a single primary vertex provided. Skipping...\n";
-    return;
-  }
-  LOG(info) << "\n CookedTracker::process(), number of threads: " << mNumOfThreads;
-
-  auto start = std::chrono::system_clock::now();
-
-  mFirstInFrame = rof.getFirstEntry();
-
-  mClusterCache.reserve(rof.getNEntries());
-  auto clusters_in_frame = rof.getROFData(clusters);
-  for (const auto& comp : clusters_in_frame) {
-
-    auto pattID = comp.getPatternID();
-    o2::math_utils::Point3D<float> locXYZ;
-    float sigmaY2 = gSigma2, sigmaZ2 = gSigma2;
-    if (pattID != itsmft::CompCluster::InvalidPatternID) {
-      sigmaY2 = gSigma2; //dict.getErr2X(pattID);
-      sigmaZ2 = gSigma2; //dict.getErr2Z(pattID);
-      if (!dict->isGroup(pattID)) {
-        locXYZ = dict->getClusterCoordinates(comp);
-      } else {
-        o2::itsmft::ClusterPattern patt(pattIt);
-        locXYZ = dict->getClusterCoordinates(comp, patt);
-      }
-    } else {
-      o2::itsmft::ClusterPattern patt(pattIt);
-      locXYZ = dict->getClusterCoordinates(comp, patt, false);
-    }
-    auto sensorID = comp.getSensorID();
-    // Inverse transformation to the local --> tracking
-    auto trkXYZ = mGeom->getMatrixT2L(sensorID) ^ locXYZ;
-
-    Cluster c;
-    c.setSensorID(sensorID);
-    c.setPos(trkXYZ);
-    c.setErrors(sigmaY2, sigmaZ2, 0.f);
-    mClusterCache.push_back(c);
-  }
-
-  auto nClFrame = loadClusters();
-
-  auto end = std::chrono::system_clock::now();
-  std::chrono::duration<double> diff = end - start;
-  LOG(info) << "Loading clusters: " << nClFrame << " in a single frame : " << diff.count() << " s";
-
-  start = end;
-
-  auto [first, number] = processLoadedClusters(inserter);
-  rof.setFirstEntry(first);
-  rof.setNEntries(number);
-
-  unloadClusters();
-  end = std::chrono::system_clock::now();
-  diff = end - start;
-  LOG(info) << "Processing time/clusters for single frame : " << diff.count() << " / " << nClFrame << " s";
-
-  start = end;
-}
-
-std::tuple<int, int> CookedTracker::processLoadedClusters(TrackInserter& inserter)
-{
-  //--------------------------------------------------------------------
-  // This is the main tracking function for single frame, it is assumed that only clusters
-  // which may contribute to this frame is loaded
-  //--------------------------------------------------------------------
-  Int_t numOfClusters = sLayers[gSeedingLayer1].getNumberOfClusters();
-  if (!numOfClusters) {
-    return {0, 0};
-  }
-
-  std::vector<std::future<std::vector<TrackITSExt>>> futures(mNumOfThreads);
-  std::vector<std::vector<TrackITSExt>> seedArray(mNumOfThreads);
-
-  for (Int_t t = 0, first = 0; t < mNumOfThreads; t++) {
-    Int_t rem = t < (numOfClusters % mNumOfThreads) ? 1 : 0;
-    Int_t last = first + (numOfClusters / mNumOfThreads) + rem;
-    futures[t] = std::async(std::launch::async, &CookedTracker::trackInThread, this, first, last);
-    first = last;
-  }
-  Int_t nSeeds = 0, ngood = 0;
-  int nAllTracks = 0, nTracks = 0;
-  for (Int_t t = 0; t < mNumOfThreads; t++) {
-    seedArray[t] = futures[t].get();
-    nSeeds += seedArray[t].size();
-    for (auto& track : seedArray[t]) {
-      if (track.getNumberOfClusters() < gminNumberOfClusters) {
-        continue;
-      }
-
-      o2::dataformats::VertexBase vtx;
-      track.propagateToDCA(vtx, getBz());
-
-      nAllTracks = inserter(track);
-      nTracks++;
-      if (mTrkLabels) {
-        Label label = cookLabel(track, 0.); // For comparison only
-        if (label.getTrackID() >= 0) {
-          ngood++;
-        }
-        // the inserter returns the size of the track vector, the index of the last
-        // inserted track is thus n - 1
-        mTrkLabels->emplace_back(label);
-      }
-    }
-  }
-
-  if (nSeeds) {
-    LOG(info) << "Found tracks: " << nTracks;
-    LOG(info) << "CookedTracker::processLoadedClusters(), good_tracks:/seeds: " << ngood << '/' << nSeeds << "-> "
-              << Float_t(ngood) / nSeeds << '\n';
-  }
-  // returning index of the first track and the number of add tracks
-  // inserted in this call
-  return {nAllTracks - nTracks, nTracks};
-}
-
-//____________________________________________________________
-void CookedTracker::makeBackPropParam(std::vector<TrackITSExt>& seeds) const
-{
-  // refit in backward direction
-  for (auto& track : seeds) {
-    if (track.getNumberOfClusters() < gminNumberOfClusters) {
-      continue;
-    }
-    makeBackPropParam(track);
-  }
-}
-
-//____________________________________________________________
-bool CookedTracker::makeBackPropParam(TrackITSExt& track) const
-{
-  // refit in backward direction
-  auto backProp = track.getParamOut();
-  backProp = track;
-  backProp.resetCovariance();
-  auto propagator = o2::base::Propagator::Instance();
-
-  Int_t noc = track.getNumberOfClusters();
-  for (int ic = noc; ic--;) { // cluster indices are stored in inward direction
-    Int_t index = track.getClusterIndex(ic);
-    const Cluster* c = getCluster(index);
-    float alpha = mGeom->getSensorRefAlpha(c->getSensorID());
-    if (!backProp.rotate(alpha)) {
-      return false;
-    }
-    if (!propagator->PropagateToXBxByBz(backProp, c->getX())) {
-      return false;
-    }
-    if (!backProp.update(static_cast<const o2::BaseCluster<float>&>(*c))) {
-      return false;
-    }
-  }
-  track.getParamOut() = backProp;
-  return true;
-}
-
-int CookedTracker::loadClusters()
-{
-  //--------------------------------------------------------------------
-  // This function reads the ITSU clusters from the tree,
-  // sort them, distribute over the internal tracker arrays, etc
-  //--------------------------------------------------------------------
-
-  if (mClusterCache.empty()) {
-    return 0;
-  }
-
-  for (const auto& c : mClusterCache) {
-    Int_t layer = mGeom->getLayer(c.getSensorID());
-    sLayers[layer].insertCluster(&c);
-  }
-
-  std::vector<std::future<void>> fut;
-  for (Int_t l = 0; l < kNLayers; l += mNumOfThreads) {
-    for (Int_t t = 0; t < mNumOfThreads; t++) {
-      if (l + t >= kNLayers) {
-        break;
-      }
-      auto f = std::async(std::launch::async, &CookedTracker::Layer::init, sLayers + (l + t));
-      fut.push_back(std::move(f));
-    }
-    for (size_t t = 0; t < fut.size(); t++) {
-      fut[t].wait();
-    }
-  }
-
-  return mClusterCache.size();
-}
-
-void CookedTracker::unloadClusters()
-{
-  //--------------------------------------------------------------------
-  // This function unloads ITSU clusters from the RAM
-  //--------------------------------------------------------------------
-  mClusterCache.clear();
-  for (Int_t i = 0; i < kNLayers; i++) {
-    sLayers[i].unloadClusters();
-  }
-}
-
-const Cluster* CookedTracker::getCluster(Int_t index) const
-{
-  //--------------------------------------------------------------------
-  //       Return pointer to a given cluster
-  //--------------------------------------------------------------------
-  Int_t l = (index & 0xf0000000) >> 28;
-  Int_t c = (index & 0x0fffffff) >> 00;
-  return sLayers[l].getCluster(c);
-}
-
-CookedTracker::Layer::Layer() : mR(0)
-{
-  //--------------------------------------------------------------------
-  // This default constructor needs to be provided
-  //--------------------------------------------------------------------
-}
-
-void CookedTracker::Layer::init()
-{
-  //--------------------------------------------------------------------
-  // Sort clusters and cache their reference plane info in a thread
-  //--------------------------------------------------------------------
-  std::sort(std::begin(mClusters), std::end(mClusters),
-            [](const Cluster* c1, const Cluster* c2) { return (c1->getZ() < c2->getZ()); });
-
-  Double_t r = 0.;
-  Int_t m = mClusters.size();
-  for (Int_t i = 0; i < m; i++) {
-    const Cluster* c = mClusters[i];
-    // Float_t xRef, aRef;
-    // mGeom->getSensorXAlphaRefPlane(c->getSensorID(),xRef, aRef);
-    mAlphaRef.push_back(mGeom->getSensorRefAlpha(c->getSensorID()));
-    auto xyz = c->getXYZGloRot(*mGeom);
-    r += xyz.rho();
-    Float_t phi = xyz.Phi();
-    o2::math_utils::bringTo02Pi(phi);
-    mPhi.push_back(phi);
-    Int_t s = phi * (int)kNSectors / k2PI;
-    mSectors[s < kNSectors ? s : kNSectors - 1].emplace_back(i, c->getZ());
-  }
-
-  if (m) {
-    mR = r / m;
-  }
-}
-
-void CookedTracker::Layer::unloadClusters()
-{
-  //--------------------------------------------------------------------
-  // Unload clusters from this layer
-  //--------------------------------------------------------------------
-  mClusters.clear();
-  mAlphaRef.clear();
-  mPhi.clear();
-  for (Int_t s = 0; s < kNSectors; s++) {
-    mSectors[s].clear();
-  }
-}
-
-Bool_t CookedTracker::Layer::insertCluster(const Cluster* c)
-{
-  //--------------------------------------------------------------------
-  // This function inserts a cluster to this layer
-  //--------------------------------------------------------------------
-  mClusters.push_back(c);
-  return kTRUE;
-}
-
-Int_t CookedTracker::Layer::findClusterIndex(Float_t z) const
-{
-  //--------------------------------------------------------------------
-  // This function returns the index of the first cluster with its fZ >= "z".
-  //--------------------------------------------------------------------
-  auto found = std::upper_bound(std::begin(mClusters), std::end(mClusters), z,
-                                [](Float_t zc, const Cluster* c) { return (zc < c->getZ()); });
-  return found - std::begin(mClusters);
-}
-
-void CookedTracker::Layer::selectClusters(std::vector<Int_t>& selec, Float_t phi, Float_t dy, Float_t z, Float_t dz)
-{
-  //--------------------------------------------------------------------
-  // This function selects clusters within the "road"
-  //--------------------------------------------------------------------
-  Float_t zMin = z - dz;
-  Float_t zMax = z + dz;
-
-  o2::math_utils::bringTo02Pi(phi);
-
-  Float_t dphi = dy / mR;
-
-  int smin = (phi - dphi) / k2PI * (int)kNSectors;
-  int ds = (phi + dphi) / k2PI * (int)kNSectors - smin + 1;
-
-  smin = (smin + kNSectors) % kNSectors;
-
-  for (int is = 0; is < ds; is++) {
-    Int_t s = (smin + is) % kNSectors;
-
-    auto cmp = [](Float_t zc, std::pair<int, float> p) { return (zc < p.second); };
-    auto imin = std::upper_bound(std::begin(mSectors[s]), std::end(mSectors[s]), zMin, cmp);
-    auto imax = std::upper_bound(imin, std::end(mSectors[s]), zMax, cmp);
-    for (; imin != imax; imin++) {
-      auto [i, zz] = *imin;
-      auto cdphi = std::abs(mPhi[i] - phi);
-      if (cdphi > dphi) {
-        if (cdphi > kPI) {
-          cdphi = k2PI - cdphi;
-        }
-        if (cdphi > dphi) {
-          continue; // check in Phi
-        }
-      }
-      selec.push_back(i);
-    }
-  }
-}
-
-Bool_t CookedTracker::attachCluster(Int_t& volID, Int_t nl, Int_t ci, TrackITSExt& t, const TrackITSExt& o) const
-{
-  //--------------------------------------------------------------------
-  // Try to attach a clusters with index ci to running track hypothesis
-  //--------------------------------------------------------------------
-  Layer& layer = sLayers[nl];
-  const Cluster* c = layer.getCluster(ci);
-
-  Int_t vid = c->getSensorID();
-
-  if (vid != volID) {
-    volID = vid;
-    t = o;
-    Double_t alpha = layer.getAlphaRef(ci);
-    if (!t.propagate(alpha, c->getX(), getBz())) {
-      return kFALSE;
-    }
-  }
-
-  Double_t chi2 = t.getPredictedChi2(*c);
-  if (chi2 > gmaxChi2PerCluster) {
-    return kFALSE;
-  }
-
-  if (!t.update(*c, chi2)) {
-    return kFALSE;
-  }
-  t.setClusterIndex(nl, ci);
-
-  Double_t xx0 = (nl > 2) ? 0.008 : 0.003; // Rough layer thickness
-  Double_t x0 = 9.36;                      // Radiation length of Si [cm]
-  Double_t rho = 2.33;                     // Density of Si [g/cm^3]
-  t.correctForMaterial(xx0, xx0 * x0 * rho, kTRUE);
-  return kTRUE;
-}
-
-void CookedTracker::setGeometry(o2::its::GeometryTGeo* geom)
-{
-  /// attach geometry interface
-  mGeom = geom;
-  for (Int_t i = 0; i < kNLayers; i++) {
-    sLayers[i].setGeometry(geom);
-  }
-}
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/CookedTrackerLinkDef.h b/Detectors/ITSMFT/ITS/reconstruction/src/CookedTrackerLinkDef.h
deleted file mode 100644
index 1e8596fbb224c..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/src/CookedTrackerLinkDef.h
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifdef __CLING__
-
-#pragma link off all globals;
-#pragma link off all classes;
-#pragma link off all functions;
-
-#pragma link C++ class o2::its::ClustererTask + ;
-#pragma link C++ class o2::its::CookedTracker + ;
-#pragma link C++ class o2::its::CookedConfigParam + ;
-#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::CookedConfigParam> + ;
-#pragma link C++ class o2::its::RecoGeomHelper + ;
-#pragma link C++ class o2::its::FastMultEst + ;
-#pragma link C++ class o2::its::FastMultEstConfig + ;
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/ITSReconstructionLinkDef.h b/Detectors/ITSMFT/ITS/reconstruction/src/ITSReconstructionLinkDef.h
index c93cf03d0ed3d..67622303fc840 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/src/ITSReconstructionLinkDef.h
+++ b/Detectors/ITSMFT/ITS/reconstruction/src/ITSReconstructionLinkDef.h
@@ -15,11 +15,7 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class o2::its::ClustererTask + ;
-#pragma link C++ class o2::its::CookedTracker + ;
-
 #pragma link C++ class o2::its::RecoGeomHelper + ;
-
 #pragma link C++ class o2::its::FastMultEst + ;
 #pragma link C++ class o2::its::FastMultEstConfig + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::FastMultEstConfig> + ;
diff --git a/Detectors/ITSMFT/ITS/workflow/CMakeLists.txt b/Detectors/ITSMFT/ITS/workflow/CMakeLists.txt
index 3609560eccf72..f0d50e59493d4 100644
--- a/Detectors/ITSMFT/ITS/workflow/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/workflow/CMakeLists.txt
@@ -16,7 +16,6 @@ o2_add_library(ITSWorkflow
                        src/ClustererSpec.cxx
                        src/ClusterWriterSpec.cxx
                        src/TrackerSpec.cxx
-                       src/CookedTrackerSpec.cxx
                        src/TrackWriterSpec.cxx
                        src/TrackReaderSpec.cxx
                        src/VertexReaderSpec.cxx
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
deleted file mode 100644
index 4ecc98eed9cfb..0000000000000
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/CookedTrackerSpec.h
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   CookedTrackerSpec.h
-
-#ifndef O2_ITS_COOKEDTRACKERDPL
-#define O2_ITS_COOKEDTRACKERDPL
-
-#include "Framework/DataProcessorSpec.h"
-#include "ITSReconstruction/CookedTracker.h"
-#include "ITStracking/TimeFrame.h"
-#include "ITStracking/Vertexer.h"
-#include "ITStracking/VertexerTraits.h"
-#include "ITStracking/BoundedAllocator.h"
-#include "DataFormatsParameters/GRPObject.h"
-#include "DataFormatsITSMFT/TopologyDictionary.h"
-#include "Framework/Task.h"
-#include "TStopwatch.h"
-#include "DetectorsBase/GRPGeomHelper.h"
-
-#include <oneapi/tbb/task_arena.h>
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace its
-{
-
-class CookedTrackerDPL : public Task
-{
- public:
-  CookedTrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, int trgType, TrackingMode::Type trMode);
-  ~CookedTrackerDPL() override = default;
-  void init(InitContext& ic) final;
-  void run(ProcessingContext& pc) final;
-  void endOfStream(framework::EndOfStreamContext& ec) final;
-  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
-  void setClusterDictionary(const o2::itsmft::TopologyDictionary* d) { mDict = d; }
-
- private:
-  void updateTimeDependentParams(ProcessingContext& pc);
-
-  std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
-  int mState = 0;
-  bool mUseMC = true;
-  bool mRunVertexer = true;
-  int mUseTriggers = 0;
-  TrackingMode::Type mMode = TrackingMode::Sync;
-  const o2::itsmft::TopologyDictionary* mDict = nullptr;
-  std::unique_ptr<o2::parameters::GRPObject> mGRP = nullptr;
-  o2::its::CookedTracker mTracker;
-  std::unique_ptr<VertexerTraits<7>> mVertexerTraitsPtr = nullptr;
-  std::unique_ptr<Vertexer<7>> mVertexerPtr = nullptr;
-  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
-  std::shared_ptr<tbb::task_arena> mTaskArena;
-  TStopwatch mTimer;
-};
-
-/// create a processor spec
-/// run ITS CookedMatrix tracker
-framework::DataProcessorSpec getCookedTrackerSpec(bool useMC, bool useGeom, int useTrig, TrackingMode::Type trMode);
-
-} // namespace its
-} // namespace o2
-
-#endif /* O2_ITS_COOKEDTRACKERDPL */
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
index 90b38acb34a95..1d5d829a6f79a 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
@@ -26,7 +26,7 @@ namespace its
 namespace reco_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC, bool useCMtracker, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
+framework::WorkflowSpec getWorkflow(bool useMC, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
                                     bool upstreamDigits = false, bool upstreamClusters = false, bool disableRootOutput = false, bool useGeom = false, int useTrig = 0,
                                     bool useGPUWF = false, o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
deleted file mode 100644
index b989a78e59b7c..0000000000000
--- a/Detectors/ITSMFT/ITS/workflow/src/CookedTrackerSpec.cxx
+++ /dev/null
@@ -1,327 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   CookedTrackerSpec.cxx
-
-#include <vector>
-
-#include "TGeoGlobalMagField.h"
-
-#include "Framework/ControlService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/CCDBParamSpec.h"
-#include "ITSWorkflow/CookedTrackerSpec.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "DataFormatsITSMFT/Cluster.h"
-#include "DataFormatsITS/TrackITS.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include <DataFormatsITSMFT/PhysTrigger.h>
-#include "ITSMFTBase/DPLAlpideParam.h"
-#include "DataFormatsTRD/TriggerRecord.h"
-
-#include "Field/MagneticField.h"
-#include "DetectorsBase/GeometryManager.h"
-#include "DetectorsBase/Propagator.h"
-#include "ITSBase/GeometryTGeo.h"
-#include "CommonDataFormat/IRFrame.h"
-#include "ITStracking/IOUtils.h"
-#include "DetectorsCommonDataFormats/DetectorNameConf.h"
-#include "CommonUtils/StringUtils.h"
-
-#include "ITSReconstruction/FastMultEstConfig.h"
-#include "ITSReconstruction/FastMultEst.h"
-#include "ITSMFTReconstruction/ClustererParam.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace its
-{
-
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
-CookedTrackerDPL::CookedTrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, int trgType, TrackingMode::Type trMode) : mGGCCDBRequest(gr), mUseMC(useMC), mUseTriggers{trgType}, mMode(trMode)
-{
-  mVertexerTraitsPtr = std::make_unique<VertexerTraits<7>>();
-  mVertexerPtr = std::make_unique<Vertexer<7>>(mVertexerTraitsPtr.get());
-}
-
-void CookedTrackerDPL::init(InitContext& ic)
-{
-  mTimer.Stop();
-  mTimer.Reset();
-  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
-  auto nthreads = ic.options().get<int>("nthreads");
-  mTracker.setNumberOfThreads(nthreads);
-  mTaskArena = std::make_shared<tbb::task_arena>(nthreads);
-  mMemoryPool = std::make_unique<BoundedMemoryResource>();
-  mVertexerPtr->setMemoryPool(mMemoryPool);
-  mVertexerPtr->setNThreads(nthreads, mTaskArena);
-  mVertexerTraitsPtr->setMemoryPool(mMemoryPool);
-}
-
-void CookedTrackerDPL::run(ProcessingContext& pc)
-{
-  mTimer.Start(false);
-  updateTimeDependentParams(pc);
-  auto compClusters = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compClusters");
-  gsl::span<const unsigned char> patterns = pc.inputs().get<gsl::span<unsigned char>>("patterns");
-
-  // code further down does assignment to the rofs and the altered object is used for output
-  // we therefore need a copy of the vector rather than an object created directly on the input data,
-  // the output vector however is created directly inside the message memory thus avoiding copy by
-  // snapshot
-  auto rofsinput = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
-  gsl::span<const o2::itsmft::PhysTrigger> physTriggers;
-  std::vector<o2::itsmft::PhysTrigger> fromTRD;
-  if (mUseTriggers == 2) { // use TRD triggers
-    o2::InteractionRecord ir{0, pc.services().get<o2::framework::TimingInfo>().firstTForbit};
-    auto trdTriggers = pc.inputs().get<gsl::span<o2::trd::TriggerRecord>>("phystrig");
-    for (const auto& trig : trdTriggers) {
-      if (trig.getBCData() >= ir && trig.getNumberOfTracklets()) {
-        ir = trig.getBCData();
-        fromTRD.emplace_back(o2::itsmft::PhysTrigger{ir, 0});
-      }
-    }
-    physTriggers = gsl::span<const o2::itsmft::PhysTrigger>(fromTRD.data(), fromTRD.size());
-  } else if (mUseTriggers == 1) { // use Phys triggers from ITS stream
-    physTriggers = pc.inputs().get<gsl::span<o2::itsmft::PhysTrigger>>("phystrig");
-  }
-
-  auto& rofs = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "ITSTrackROF", 0}, rofsinput.begin(), rofsinput.end());
-
-  std::unique_ptr<const o2::dataformats::MCTruthContainer<o2::MCCompLabel>> labels;
-  gsl::span<itsmft::MC2ROFRecord const> mc2rofs;
-  if (mUseMC) {
-    labels = pc.inputs().get<const o2::dataformats::MCTruthContainer<o2::MCCompLabel>*>("labels");
-    // get the array as read-onlt span, a snapshot is send forward
-    mc2rofs = pc.inputs().get<gsl::span<itsmft::MC2ROFRecord>>("MC2ROframes");
-  }
-  TimeFrame mTimeFrame;
-  mTimeFrame.setMemoryPool(mMemoryPool);
-
-  LOG(info) << "ITSCookedTracker pulled " << compClusters.size() << " clusters, in " << rofs.size() << " RO frames";
-
-  std::vector<o2::MCCompLabel> trackLabels;
-  if (mUseMC) {
-    mTracker.setMCTruthContainers(labels.get(), &trackLabels);
-  }
-
-  mVertexerPtr->adoptTimeFrame(mTimeFrame);
-
-  auto& vertROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "VERTICESROF", 0});
-  auto& vertices = pc.outputs().make<std::vector<Vertex>>(Output{"ITS", "VERTICES", 0});
-  auto& tracks = pc.outputs().make<std::vector<o2::its::TrackITS>>(Output{"ITS", "TRACKS", 0});
-  auto& clusIdx = pc.outputs().make<std::vector<int>>(Output{"ITS", "TRACKCLSID", 0});
-  auto& irFrames = pc.outputs().make<std::vector<o2::dataformats::IRFrame>>(Output{"ITS", "IRFRAMES", 0});
-
-  const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance(); // RS: this should come from CCDB
-  int nBCPerTF = mTracker.getContinuousMode() ? alpParams.roFrameLengthInBC : alpParams.roFrameLengthTrig;
-
-  gsl::span<const unsigned char>::iterator pattIt_timeframe = patterns.begin();
-  gsl::span<const unsigned char>::iterator pattIt_tracker = patterns.begin();
-  gsl::span<itsmft::ROFRecord> rofspan(rofs);
-  mTimeFrame.loadROFrameData(rofspan, compClusters, pattIt_timeframe, mDict, labels.get());
-
-  const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
-  FastMultEst multEst;                                     // mult estimator
-  std::vector<uint8_t> processingMask;
-  int cutVertexMult{0}, cutRandomMult = int(rofsinput.size()) - multEst.selectROFs(rofsinput, compClusters, physTriggers, processingMask);
-
-  // auto processingMask_ephemeral = processingMask;
-  mTimeFrame.setMultiplicityCutMask(processingMask);
-  float vertexerElapsedTime;
-  if (mRunVertexer) {
-    vertexerElapsedTime = mVertexerPtr->clustersToVertices([&](std::string s) { LOG(info) << s; });
-  }
-  LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms in {} ROFs", vertexerElapsedTime, rofspan.size());
-  for (size_t iRof{0}; iRof < rofspan.size(); ++iRof) {
-    auto& rof = rofspan[iRof];
-
-    auto& vtxROF = vertROFvec.emplace_back(rof); // register entry and number of vertices in the
-    vtxROF.setFirstEntry(vertices.size());
-    vtxROF.setNEntries(0);
-    if (!processingMask[iRof]) {
-      rof.setFirstEntry(tracks.size());
-      rof.setNEntries(0);
-      continue;
-    }
-
-    std::vector<o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>> vtxVecLoc;
-    for (auto& v : mTimeFrame.getPrimaryVertices(iRof)) {
-      vtxVecLoc.push_back(v);
-    }
-
-    if (multEstConf.isVtxMultCutRequested()) { // cut was requested
-      std::vector<o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>> vtxVecSel;
-      vtxVecSel.swap(vtxVecLoc);
-      int nv = vtxVecSel.size(), nrej = 0;
-      for (const auto& vtx : vtxVecSel) {
-        if (!multEstConf.isPassingVtxMultCut(vtx.getNContributors())) {
-          LOG(info) << "Found vertex mult. " << vtx.getNContributors() << " is outside of requested range " << multEstConf.cutMultVtxLow << " : " << multEstConf.cutMultVtxHigh << " | ROF " << rof.getBCData();
-          nrej++;
-          continue; // skip vertex of unwanted multiplicity
-        }
-        vtxVecLoc.push_back(vtx);
-      }
-      if (nv && (nrej == nv)) { // all vertices were rejected
-        cutVertexMult++;
-        processingMask[iRof] = false;
-      }
-    }
-    if (vtxVecLoc.empty()) {
-      if (multEstConf.cutMultVtxLow < 1) { // do blind search only if there is no cut on the low mult vertices
-        vtxVecLoc.emplace_back();
-      } else {
-        rof.setFirstEntry(tracks.size());
-        rof.setNEntries(0);
-        continue;
-      }
-    } else { // save vertices
-      vtxROF.setNEntries(vtxVecLoc.size());
-      for (const auto& vtx : vtxVecLoc) {
-        vertices.push_back(vtx);
-      }
-    }
-
-    mTracker.setVertices(vtxVecLoc);
-    mTracker.process(compClusters, pattIt_tracker, mDict, tracks, clusIdx, rof);
-    if (processingMask[iRof]) {
-      irFrames.emplace_back(rof.getBCData(), rof.getBCData() + nBCPerTF - 1).info = tracks.size();
-    }
-  }
-  LOGP(info, " - rejected {}/{} ROFs: random/mult.sel:{} (seed {}), vtx.sel:{}", cutRandomMult + cutVertexMult, rofspan.size(), cutRandomMult, multEst.lastRandomSeed, cutVertexMult);
-  LOG(info) << "ITSCookedTracker pushed " << tracks.size() << " tracks and " << vertices.size() << " vertices";
-
-  if (mUseMC) {
-    pc.outputs().snapshot(Output{"ITS", "TRACKSMCTR", 0}, trackLabels);
-    pc.outputs().snapshot(Output{"ITS", "ITSTrackMC2ROF", 0}, mc2rofs);
-  }
-  mTimer.Stop();
-}
-
-void CookedTrackerDPL::endOfStream(EndOfStreamContext& ec)
-{
-  LOGF(info, "ITS Cooked-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots",
-       mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
-}
-
-///_______________________________________
-void CookedTrackerDPL::updateTimeDependentParams(ProcessingContext& pc)
-{
-  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
-  static bool initOnceDone = false;
-  if (!initOnceDone) { // this params need to be queried only once
-    initOnceDone = true;
-    pc.inputs().get<o2::itsmft::TopologyDictionary*>("cldict"); // just to trigger the finaliseCCDB
-    pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("alppar");
-    if (pc.inputs().getPos("itsTGeo") >= 0) {
-      pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
-    }
-    mVertexerPtr->setParameters(TrackingMode::getVertexingParameters(mMode));
-    o2::its::GeometryTGeo* geom = o2::its::GeometryTGeo::Instance();
-    geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot,
-                                                   o2::math_utils::TransformType::T2G));
-    mTracker.setGeometry(geom);
-    mTracker.setConfigParams();
-    LOG(info) << "Tracking mode " << TrackingMode::toString(mMode);
-    if (mMode == TrackingMode::Cosmics) {
-      LOG(info) << "Setting cosmics parameters...";
-      mTracker.setParametersCosmics();
-      mRunVertexer = false;
-    }
-    mTracker.setBz(o2::base::Propagator::Instance()->getNominalBz());
-    bool continuous = o2::base::GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::ITS);
-    LOG(info) << "ITSCookedTracker RO: continuous=" << continuous;
-    mTracker.setContinuousMode(continuous);
-  }
-}
-
-///_______________________________________
-void CookedTrackerDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
-{
-  if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
-    return;
-  }
-  if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
-    LOG(info) << "cluster dictionary updated";
-    setClusterDictionary((const o2::itsmft::TopologyDictionary*)obj);
-    return;
-  }
-  // Note: strictly speaking, for Configurable params we don't need finaliseCCDB check, the singletons are updated at the CCDB fetcher level
-  if (matcher == ConcreteDataMatcher("ITS", "ALPIDEPARAM", 0)) {
-    LOG(info) << "Alpide param updated";
-    const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-    par.printKeyValues();
-    return;
-  }
-  if (matcher == ConcreteDataMatcher("ITS", "GEOMTGEO", 0)) {
-    LOG(info) << "ITS GeometryTGeo loaded from ccdb";
-    o2::its::GeometryTGeo::adopt((o2::its::GeometryTGeo*)obj);
-    return;
-  }
-}
-
-DataProcessorSpec getCookedTrackerSpec(bool useMC, bool useGeom, int trgType, TrackingMode::Type trmode)
-{
-  std::vector<InputSpec> inputs;
-  inputs.emplace_back("compClusters", "ITS", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("patterns", "ITS", "PATTERNS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ROframes", "ITS", "CLUSTERSROF", 0, Lifetime::Timeframe);
-  inputs.emplace_back("cldict", "ITS", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
-  inputs.emplace_back("alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
-  if (trgType == 1) {
-    inputs.emplace_back("phystrig", "ITS", "PHYSTRIG", 0, Lifetime::Timeframe);
-  } else if (trgType == 2) {
-    inputs.emplace_back("phystrig", "TRD", "TRKTRGRD", 0, Lifetime::Timeframe);
-  }
-
-  std::vector<OutputSpec> outputs;
-  outputs.emplace_back("ITS", "TRACKS", 0, Lifetime::Timeframe);
-  outputs.emplace_back("ITS", "TRACKCLSID", 0, Lifetime::Timeframe);
-  outputs.emplace_back("ITS", "ITSTrackROF", 0, Lifetime::Timeframe);
-  outputs.emplace_back("ITS", "VERTICES", 0, Lifetime::Timeframe);
-  outputs.emplace_back("ITS", "VERTICESROF", 0, Lifetime::Timeframe);
-  outputs.emplace_back("ITS", "IRFRAMES", 0, Lifetime::Timeframe);
-
-  if (useMC) {
-    inputs.emplace_back("labels", "ITS", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    inputs.emplace_back("MC2ROframes", "ITS", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
-    outputs.emplace_back("ITS", "TRACKSMCTR", 0, Lifetime::Timeframe);
-    outputs.emplace_back("ITS", "ITSTrackMC2ROF", 0, Lifetime::Timeframe);
-  }
-  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                                                                        // orbitResetTime
-                                                              true,                                                                         // GRPECS=true
-                                                              false,                                                                        // GRPLHCIF
-                                                              true,                                                                         // GRPMagField
-                                                              true,                                                                         // askMatLUT
-                                                              useGeom ? o2::base::GRPGeomRequest::Aligned : o2::base::GRPGeomRequest::None, // geometry
-                                                              inputs,
-                                                              true);
-  if (!useGeom) {
-    ggRequest->addInput({"itsTGeo", "ITS", "GEOMTGEO", 0, Lifetime::Condition, framework::ccdbParamSpec("ITS/Config/Geometry")}, inputs);
-  }
-  return DataProcessorSpec{
-    "its-cooked-tracker",
-    inputs,
-    outputs,
-    AlgorithmSpec{adaptFromTask<CookedTrackerDPL>(ggRequest,
-                                                  useMC,
-                                                  trgType,
-                                                  trmode)},
-    Options{{"nthreads", VariantType::Int, 1, {"Number of threads"}}}};
-}
-
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index 368ca6909240f..60e28556716f2 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -15,7 +15,6 @@
 #include "ITSWorkflow/ClustererSpec.h"
 #include "ITSWorkflow/ClusterWriterSpec.h"
 #include "ITSWorkflow/TrackerSpec.h"
-#include "ITSWorkflow/CookedTrackerSpec.h"
 #include "ITSWorkflow/TrackWriterSpec.h"
 #include "ITStracking/TrackingConfigParam.h"
 #include "ITSMFTWorkflow/DigitReaderSpec.h"
@@ -29,7 +28,6 @@ namespace o2::its::reco_workflow
 {
 
 framework::WorkflowSpec getWorkflow(bool useMC,
-                                    bool useCMtracker,
                                     TrackingMode::Type trmode,
                                     const bool overrideBeamPosition,
                                     bool upstreamDigits,
@@ -51,40 +49,36 @@ framework::WorkflowSpec getWorkflow(bool useMC,
     specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
   }
   if ((trmode != TrackingMode::Off) && (TrackerParamConfig::Instance().trackingMode != TrackingMode::Off)) {
-    if (useCMtracker) {
-      specs.emplace_back(o2::its::getCookedTrackerSpec(useMC, useGeom, useTrig, trmode));
-    } else {
-      if (useGPUWF) {
-        o2::gpu::GPURecoWorkflowSpec::Config cfg{
-          .itsTriggerType = useTrig,
-          .processMC = useMC,
-          .runITSTracking = true,
-          .itsOverrBeamEst = overrideBeamPosition,
-        };
+    if (useGPUWF) {
+      o2::gpu::GPURecoWorkflowSpec::Config cfg{
+        .itsTriggerType = useTrig,
+        .processMC = useMC,
+        .runITSTracking = true,
+        .itsOverrBeamEst = overrideBeamPosition,
+      };
 
-        Inputs ggInputs;
-        auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true,
-                                                                    useGeom ? o2::base::GRPGeomRequest::Aligned : o2::base::GRPGeomRequest::None,
-                                                                    ggInputs, true);
-        if (!useGeom) {
-          ggRequest->addInput({"itsTGeo", "ITS", "GEOMTGEO", 0, Lifetime::Condition, framework::ccdbParamSpec("ITS/Config/Geometry")}, ggInputs);
-        }
+      Inputs ggInputs;
+      auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false, true, false, true, true,
+                                                                  useGeom ? o2::base::GRPGeomRequest::Aligned : o2::base::GRPGeomRequest::None,
+                                                                  ggInputs, true);
+      if (!useGeom) {
+        ggRequest->addInput({"itsTGeo", "ITS", "GEOMTGEO", 0, Lifetime::Condition, framework::ccdbParamSpec("ITS/Config/Geometry")}, ggInputs);
+      }
 
-        static std::vector<InputSpec> policyData;
-        static std::shared_ptr<o2::gpu::GPURecoWorkflowSpec> task = std::make_shared<o2::gpu::GPURecoWorkflowSpec>(&policyData, cfg, std::vector<int>(), 0, ggRequest);
-        Inputs taskInputs = task->inputs();
-        Options taskOptions = task->options();
-        std::move(ggInputs.begin(), ggInputs.end(), std::back_inserter(taskInputs));
+      static std::vector<InputSpec> policyData;
+      static std::shared_ptr<o2::gpu::GPURecoWorkflowSpec> task = std::make_shared<o2::gpu::GPURecoWorkflowSpec>(&policyData, cfg, std::vector<int>(), 0, ggRequest);
+      Inputs taskInputs = task->inputs();
+      Options taskOptions = task->options();
+      std::move(ggInputs.begin(), ggInputs.end(), std::back_inserter(taskInputs));
 
-        specs.emplace_back(DataProcessorSpec{
-          .name = "its-gpu-tracker",
-          .inputs = taskInputs,
-          .outputs = task->outputs(),
-          .algorithm = AlgorithmSpec{adoptTask<o2::gpu::GPURecoWorkflowSpec>(task)},
-          .options = taskOptions});
-      } else {
-        specs.emplace_back(o2::its::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
-      }
+      specs.emplace_back(DataProcessorSpec{
+        .name = "its-gpu-tracker",
+        .inputs = taskInputs,
+        .outputs = task->outputs(),
+        .algorithm = AlgorithmSpec{adoptTask<o2::gpu::GPURecoWorkflowSpec>(task)},
+        .options = taskOptions});
+    } else {
+      specs.emplace_back(o2::its::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
     }
     if (!disableRootOutput) {
       specs.emplace_back(o2::its::getTrackWriterSpec(useMC));
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
index 4e1721f4194b0..8080883888d40 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
@@ -41,8 +41,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"clusters-from-upstream", o2::framework::VariantType::Bool, false, {"clusters will be provided from upstream, skip clusterizer"}},
     {"disable-root-output", o2::framework::VariantType::Bool, false, {"do not write output root files"}},
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}},
-    {"trackerCA", o2::framework::VariantType::Bool, false, {"use trackerCA (deprecated)"}}, // keep this around to not break scripts
-    {"trackerCM", o2::framework::VariantType::Bool, false, {"use trackerCM (default: trackerCA)"}},
+    {"trackerCA", o2::framework::VariantType::Bool, false, {"use trackerCA (deprecated)"}}, // FIXME: keep this around to not break scripts
     {"ccdb-meanvertex-seed", o2::framework::VariantType::Bool, false, {"use MeanVertex from CCDB if available to provide beam position seed (default: false)"}},
     {"select-with-triggers", o2::framework::VariantType::String, "none", {"use triggers to prescale processed ROFs: phys, trd, none"}},
     {"tracking-mode", o2::framework::VariantType::String, "sync", {"sync,async,cosmics,unset,off"}},
@@ -65,7 +64,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // Update the (declared) parameters if changed from the command line
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   auto beamPosOVerride = configcontext.options().get<bool>("ccdb-meanvertex-seed");
-  auto useCMtracker = configcontext.options().get<bool>("trackerCM");
   auto trmode = configcontext.options().get<std::string>("tracking-mode");
   auto selTrig = configcontext.options().get<std::string>("select-with-triggers");
   auto useGpuWF = configcontext.options().get<bool>("use-gpu-workflow");
@@ -90,7 +88,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     }
   }
   auto wf = o2::its::reco_workflow::getWorkflow(useMC,
-                                                useCMtracker,
                                                 o2::its::TrackingMode::fromString(trmode),
                                                 beamPosOVerride,
                                                 extDigits,
diff --git a/macro/CMakeLists.txt b/macro/CMakeLists.txt
index b5c51e50d3ffb..1c39a96db1b60 100644
--- a/macro/CMakeLists.txt
+++ b/macro/CMakeLists.txt
@@ -48,7 +48,6 @@ install(FILES CheckDigits_mft.C
               compareTOFClusters.C
               run_rawdecoding_its.C
               run_rawdecoding_mft.C
-              run_trac_its.C
               CreateBCPattern.C
               UploadDummyAlignment.C
               UploadMatBudLUT.C
@@ -336,20 +335,6 @@ o2_add_test_root_macro(CreateCTPOrbitResetObject.C
 # O2::DataFormatsITSMFT O2::DataFormatsParameters O2::DetectorsBase O2::Field
 # O2::ITSBase O2::ITStracking O2::MathUtils O2::SimulationDataFormat)
 
-# FIXME: move to subsystem dir
-o2_add_test_root_macro(run_trac_its.C
-                       PUBLIC_LINK_LIBRARIES O2::DetectorsCommonDataFormats
-                                             O2::DataFormatsITSMFT
-                                             O2::DataFormatsParameters
-                                             O2::DetectorsBase
-                                             O2::Field
-                                             O2::ITSBase
-                                             O2::ITSReconstruction
-                                             O2::ITStracking
-                                             O2::MathUtils
-                                             O2::SimulationDataFormat
-                        LABELS its)
-
 o2_add_test_root_macro(CreateGRPECSObject.C
                        PUBLIC_LINK_LIBRARIES O2::DataFormatsParameters
                                              O2::DetectorsCommonDataFormats
@@ -463,18 +448,6 @@ o2_add_test_root_macro(getTimeStamp.C
 # finished succesfully) set_tests_properties(run_clus_its_G3 PROPERTIES DEPENDS
 # run_digi_its_G3)
 
-# configure_file(${CMAKE_SOURCE_DIR}/macro/run_trac_its.sh
-# ${CMAKE_BINARY_DIR}/macro/run_trac_its.sh)
-# configure_file(${CMAKE_SOURCE_DIR}/macro/run_trac_its.C
-# ${CMAKE_BINARY_DIR}/macro/run_trac_its.C)
-
-# add_test_wrap(NAME run_trac_its_G3 COMMAND
-# ${CMAKE_BINARY_DIR}/macro/run_trac_its.sh 10 TGeant3)
-# set_tests_properties(run_trac_its_G3 PROPERTIES TIMEOUT 30)
-# set_tests_properties(run_trac_its_G3 PROPERTIES PASS_REGULAR_EXPRESSION Macro
-# finished succesfully) set_tests_properties(run_trac_its_G3 PROPERTIES DEPENDS
-# run_clus_its_G3)
-
 # #ITS tests with G4
 
 # add_test_wrap(NAME run_sim_its_G4 COMMAND
@@ -497,13 +470,6 @@ o2_add_test_root_macro(getTimeStamp.C
 # finished succesfully) set_tests_properties(run_clus_its_G4 PROPERTIES DEPENDS
 # run_digi_its_G4)
 
-# add_test_wrap(NAME run_trac_its_G4 COMMAND
-# ${CMAKE_BINARY_DIR}/macro/run_trac_its.sh 10 TGeant4)
-# set_tests_properties(run_trac_its_G4 PROPERTIES TIMEOUT 30)
-# set_tests_properties(run_trac_its_G4 PROPERTIES PASS_REGULAR_EXPRESSION Macro
-# finished succesfully) set_tests_properties(run_trac_its_G4 PROPERTIES DEPENDS
-# run_clus_its_G4)
-
 # GENERATE_ROOT_TEST_SCRIPT(${CMAKE_SOURCE_DIR}/macro/load_all_libs.C)
 # add_test_wrap(load_all_libs ${CMAKE_BINARY_DIR}/macro/load_all_libs.sh)
 # Set_Tests_Properties(load_all_libs PROPERTIES TIMEOUT 30)
diff --git a/macro/run_trac_its.C b/macro/run_trac_its.C
deleted file mode 100644
index 824e4ebcf5d79..0000000000000
--- a/macro/run_trac_its.C
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#if !defined(__CLING__) || defined(__ROOTCLING__)
-#include <memory>
-#include <string>
-
-#include <TChain.h>
-#include <TFile.h>
-#include <TTree.h>
-#include <TGeoGlobalMagField.h>
-
-#include <TStopwatch.h>
-
-#include <FairEventHeader.h>
-#include <FairGeoParSet.h>
-#include <FairMCEventHeader.h>
-#include "Framework/Logger.h"
-#include "DetectorsCommonDataFormats/DetID.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "DataFormatsParameters/GRPObject.h"
-#include "DetectorsBase/GeometryManager.h"
-#include "DetectorsBase/Propagator.h"
-#include "Field/MagneticField.h"
-#include "ITSBase/GeometryTGeo.h"
-#include "ITSReconstruction/CookedTracker.h"
-#include "MathUtils/Utils.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-#include "ReconstructionDataFormats/Vertex.h"
-#include "DetectorsCommonDataFormats/DetectorNameConf.h"
-#include "CCDB/BasicCCDBManager.h"
-#include "CCDB/CCDBTimeStampUtils.h"
-#include "DataFormatsITSMFT/TopologyDictionary.h"
-
-#include "ReconstructionDataFormats/PrimaryVertex.h" // hack to silence JIT compiler
-#include "ITStracking/ROframe.h"
-#include "ITStracking/IOUtils.h"
-#include "ITStracking/Vertexer.h"
-#include "ITStracking/VertexerTraits.h"
-
-using MCLabCont = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
-using MCLabContTr = std::vector<o2::MCCompLabel>;
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
-void run_trac_its(std::string path = "./", std::string outputfile = "o2trac_its.root",
-                  std::string inputClustersITS = "o2clus_its.root",
-                  std::string inputGeom = "",
-                  std::string inputGRP = "o2sim_grp.root",
-                  long timestamp = 0)
-{
-
-  // Setup timer
-  TStopwatch timer;
-
-  if (path.back() != '/') {
-    path += '/';
-  }
-
-  //-------- init geometry and field --------//
-  const auto grp = o2::parameters::GRPObject::loadFrom(path + inputGRP);
-  if (!grp) {
-    LOG(fatal) << "Cannot run w/o GRP object";
-  }
-  bool isITS = grp->isDetReadOut(o2::detectors::DetID::ITS);
-  if (!isITS) {
-    LOG(warning) << "ITS is not in the readoute";
-    return;
-  }
-  bool isContITS = grp->isDetContinuousReadOut(o2::detectors::DetID::ITS);
-  LOG(info) << "ITS is in " << (isContITS ? "CONTINUOS" : "TRIGGERED") << " readout mode";
-
-  o2::base::GeometryManager::loadGeometry(inputGeom);
-  auto gman = o2::its::GeometryTGeo::Instance();
-  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2GRot)); // request cached transforms
-
-  o2::base::Propagator::initFieldFromGRP(grp);
-  auto field = static_cast<o2::field::MagneticField*>(TGeoGlobalMagField::Instance()->GetField());
-  if (!field) {
-    LOG(fatal) << "Failed to load ma";
-  }
-
-  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
-  mgr.setURL("http://alice-ccdb.cern.ch");
-  mgr.setTimestamp(timestamp ? timestamp : o2::ccdb::getCurrentTimestamp());
-  const o2::itsmft::TopologyDictionary* dict = mgr.get<o2::itsmft::TopologyDictionary>("ITS/Calib/ClusterDictionary");
-
-  //>>>---------- attach input data --------------->>>
-  TChain itsClusters("o2sim");
-  itsClusters.AddFile((path + inputClustersITS).data());
-
-  if (!itsClusters.GetBranch("ITSClusterComp")) {
-    LOG(fatal) << "Did not find ITS clusters branch ITSClusterComp in the input tree";
-  }
-  std::vector<o2::itsmft::CompClusterExt>* cclusters = nullptr;
-  itsClusters.SetBranchAddress("ITSClusterComp", &cclusters);
-
-  if (!itsClusters.GetBranch("ITSClusterPatt")) {
-    LOG(fatal) << "Did not find ITS cluster patterns branch ITSClusterPatt in the input tree";
-  }
-  std::vector<unsigned char>* patterns = nullptr;
-  itsClusters.SetBranchAddress("ITSClusterPatt", &patterns);
-
-  MCLabCont* labels = nullptr;
-  if (!itsClusters.GetBranch("ITSClusterMCTruth")) {
-    LOG(warning) << "Did not find ITS clusters branch ITSClusterMCTruth in the input tree";
-  } else {
-    itsClusters.SetBranchAddress("ITSClusterMCTruth", &labels);
-  }
-
-  if (!itsClusters.GetBranch("ITSClustersROF")) {
-    LOG(fatal) << "Did not find ITS clusters branch ITSClustersROF in the input tree";
-  }
-
-  std::vector<o2::itsmft::MC2ROFRecord>* mc2rofs = nullptr;
-  if (!itsClusters.GetBranch("ITSClustersMC2ROF")) {
-    LOG(warning) << "Did not find ITSClustersMC2ROF branch in the input tree";
-  }
-  itsClusters.SetBranchAddress("ITSClustersMC2ROF", &mc2rofs);
-
-  std::vector<o2::itsmft::ROFRecord>* rofs = nullptr;
-  itsClusters.SetBranchAddress("ITSClustersROF", &rofs);
-
-  //>>>--------- create/attach output ------------->>>
-  // create/attach output tree
-  TFile outFile((path + outputfile).data(), "recreate");
-  TTree outTree("o2sim", "Cooked ITS Tracks");
-  std::vector<o2::its::TrackITS> tracksITS, *tracksITSPtr = &tracksITS;
-  std::vector<int> trackClIdx, *trackClIdxPtr = &trackClIdx;
-  std::vector<o2::itsmft::ROFRecord> vertROFvec, *vertROFvecPtr = &vertROFvec;
-  std::vector<Vertex> vertices, *verticesPtr = &vertices;
-
-  MCLabContTr trackLabels, *trackLabelsPtr = &trackLabels;
-  outTree.Branch("ITSTrack", &tracksITSPtr);
-  outTree.Branch("ITSTrackClusIdx", &trackClIdxPtr);
-  outTree.Branch("ITSTrackMCTruth", &trackLabelsPtr);
-  outTree.Branch("ITSTracksROF", &rofs);
-  outTree.Branch("ITSTracksMC2ROF", &mc2rofs);
-  outTree.Branch("Vertices", &verticesPtr);
-  outTree.Branch("VerticesROF", &vertROFvecPtr);
-  //<<<--------- create/attach output -------------<<<
-
-  //=================== INIT ==================
-  Int_t n = 1;            // Number of threads
-  Bool_t mcTruth = kTRUE; // kFALSE if no comparison with MC is needed
-  o2::its::CookedTracker tracker(n);
-  tracker.setContinuousMode(isContITS);
-  tracker.setBz(field->solenoidField()); // in kG
-  tracker.setGeometry(gman);
-  if (mcTruth) {
-    tracker.setMCTruthContainers(labels, trackLabelsPtr);
-  }
-  //===========================================
-
-  o2::its::VertexerTraits vertexerTraits;
-  o2::its::Vertexer vertexer(&vertexerTraits);
-
-  int nTFs = itsClusters.GetEntries();
-  for (int nt = 0; nt < nTFs; nt++) {
-    LOGP(info, "Processing timeframe {}/{}", nt, nTFs);
-    itsClusters.GetEntry(nt);
-    o2::its::TimeFrame tf;
-    gsl::span<o2::itsmft::ROFRecord> rofspan(*rofs);
-    gsl::span<const unsigned char> patt(*patterns);
-
-    auto pattIt = patt.begin();
-    auto pattIt_vertexer = patt.begin();
-    auto clSpan = gsl::span(cclusters->data(), cclusters->size());
-    std::vector<bool> processingMask(rofs->size(), true);
-    tf.loadROFrameData(rofspan, clSpan, pattIt_vertexer, dict, labels);
-    tf.setMultiplicityCutMask(processingMask);
-    vertexer.adoptTimeFrame(tf);
-    vertexer.clustersToVertices();
-    int iRof = 0;
-    for (auto& rof : *rofs) {
-      auto it = pattIt;
-
-      auto& vtxROF = vertROFvec.emplace_back(rof); // register entry and number of vertices in the
-      vtxROF.setFirstEntry(vertices.size());       // dedicated ROFRecord
-      std::vector<o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>> verticesL;
-      vtxROF.setNEntries(tf.getPrimaryVertices(iRof).size());
-
-      for (const auto& vtx : tf.getPrimaryVertices(iRof)) {
-        vertices.push_back(vtx);
-        verticesL.push_back(vtx);
-      }
-      if (tf.getPrimaryVertices(iRof).empty()) {
-        verticesL.emplace_back();
-      }
-      tracker.setVertices(verticesL);
-      tracker.process(clSpan, it, dict, tracksITS, trackClIdx, rof);
-      ++iRof;
-    }
-    outTree.Fill();
-    if (mcTruth) {
-      trackLabelsPtr->clear();
-      mc2rofs->clear();
-    }
-    tracksITSPtr->clear();
-    trackClIdxPtr->clear();
-    rofs->clear();
-    verticesPtr->clear();
-    vertROFvecPtr->clear();
-  }
-  outFile.cd();
-  outTree.Write();
-  outFile.Close();
-
-  timer.Stop();
-  timer.Print();
-}
-
-#endif

From f088a3566139cb874dcf01f0fea37627f2ec2e16 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 10 Nov 2025 10:27:16 +0100
Subject: [PATCH 1186/1764] ITS: remove old ClustererTask

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/reconstruction/CMakeLists.txt  |   6 +-
 .../include/ITSReconstruction/ClustererTask.h |  85 ---------
 .../ITS/reconstruction/src/ClustererTask.cxx  | 163 ------------------
 macro/CMakeLists.txt                          |   9 -
 macro/run_clus_itsSA.C                        |  65 -------
 5 files changed, 2 insertions(+), 326 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/ClustererTask.h
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/src/ClustererTask.cxx
 delete mode 100644 macro/run_clus_itsSA.C

diff --git a/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt b/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
index a5004418599e4..d2126be1da2c6 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
@@ -10,8 +10,7 @@
 # or submit itself to any jurisdiction.
 
 o2_add_library(ITSReconstruction
-        SOURCES src/ClustererTask.cxx
-                src/RecoGeomHelper.cxx
+        SOURCES src/RecoGeomHelper.cxx
                 src/FastMultEstConfig.cxx
                 src/FastMultEst.cxx
         PUBLIC_LINK_LIBRARIES O2::ITSBase
@@ -21,7 +20,6 @@ o2_add_library(ITSReconstruction
 
 o2_target_root_dictionary(
   ITSReconstruction
-  HEADERS include/ITSReconstruction/ClustererTask.h
-          include/ITSReconstruction/RecoGeomHelper.h
+  HEADERS include/ITSReconstruction/RecoGeomHelper.h
           include/ITSReconstruction/FastMultEst.h
           include/ITSReconstruction/FastMultEstConfig.h)
diff --git a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/ClustererTask.h b/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/ClustererTask.h
deleted file mode 100644
index 16ac9dd63c631..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/ClustererTask.h
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file ClustererTask.h
-/// \brief Definition of the ITS cluster finder task
-
-#ifndef ALICEO2_ITS_CLUSTERERTASK
-#define ALICEO2_ITS_CLUSTERERTASK
-
-#include "ITSMFTReconstruction/ChipMappingITS.h"
-#include "ITSMFTReconstruction/PixelReader.h"
-#include "ITSMFTReconstruction/RawPixelReader.h"
-#include "ITSMFTReconstruction/DigitPixelReader.h"
-#include "ITSMFTReconstruction/Clusterer.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include <memory>
-#include <limits>
-
-namespace o2
-{
-class MCCompLabel;
-namespace dataformats
-{
-template <typename T>
-class MCTruthContainer;
-}
-
-namespace its
-{
-
-class ClustererTask
-{
-  using Clusterer = o2::itsmft::Clusterer;
-  using CompCluster = o2::itsmft::CompCluster;
-  using CompClusterExt = o2::itsmft::CompClusterExt;
-  using MCTruth = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
-
- public:
-  ClustererTask(bool useMC = true, bool raw = false);
-  ~ClustererTask();
-
-  void Init();
-  Clusterer& getClusterer() { return mClusterer; }
-  void run(const std::string inpName, const std::string outName);
-  o2::itsmft::PixelReader* getReader() const { return (o2::itsmft::PixelReader*)mReader; }
-
-  void writeTree(std::string basename, int i);
-  void setMaxROframe(int max) { maxROframe = max; }
-  int getMaxROframe() const { return maxROframe; }
-
- private:
-  int maxROframe = std::numeric_limits<int>::max();                                   ///< maximal number of RO frames per a file
-  bool mRawDataMode = false;                                                          ///< input from raw data or MC digits
-  bool mUseMCTruth = true;                                                            ///< flag to use MCtruth if available
-  o2::itsmft::PixelReader* mReader = nullptr;                                         ///< Pointer on the relevant Pixel reader
-  std::unique_ptr<o2::itsmft::DigitPixelReader> mReaderMC;                            ///< reader for MC data
-  std::unique_ptr<o2::itsmft::RawPixelReader<o2::itsmft::ChipMappingITS>> mReaderRaw; ///< reader for raw data
-
-  Clusterer mClusterer;                                ///< Cluster finder
-
-  std::vector<CompClusterExt> mCompClus;               //!< vector of compact clusters
-
-  std::vector<o2::itsmft::ROFRecord> mROFRecVec;               //!< vector of ROFRecord references
-
-  MCTruth mClsLabels;               //! MC labels
-
-  std::vector<unsigned char> mPatterns;
-
-  ClassDefNV(ClustererTask, 2);
-};
-} // namespace its
-} // namespace o2
-
-#endif /* ALICEO2_ITS_CLUSTERERTASK */
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/ClustererTask.cxx b/Detectors/ITSMFT/ITS/reconstruction/src/ClustererTask.cxx
deleted file mode 100644
index fb4e4ac7b6fa2..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/src/ClustererTask.cxx
+++ /dev/null
@@ -1,163 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file  ClustererTask.cxx
-/// \brief Implementation of the ITS cluster finder task
-
-#include "DetectorsCommonDataFormats/DetID.h"
-#include "ITSReconstruction/ClustererTask.h"
-#include "MathUtils/Cartesian.h"
-#include "MathUtils/Utils.h"
-#include <fairlogger/Logger.h>
-#include <TFile.h>
-#include <TTree.h>
-
-using namespace o2::its;
-
-//_____________________________________________________________________
-ClustererTask::ClustererTask(bool useMC, bool raw) : mRawDataMode(raw),
-                                                     mUseMCTruth(useMC && (!raw))
-{
-  LOG(info) << Class()->GetName() << ": MC digits mode: " << (mRawDataMode ? "OFF" : "ON")
-            << " | Use MCtruth: " << (mUseMCTruth ? "ON" : "OFF");
-
-  mClusterer.setNChips(o2::itsmft::ChipMappingITS::getNChips());
-}
-
-//_____________________________________________________________________
-ClustererTask::~ClustererTask()
-{
-  mCompClus.clear();
-  mClsLabels.clear();
-}
-
-//_____________________________________________________________________
-void ClustererTask::Init()
-{
-  /// Inititializes the clusterer and connects input and output container
-
-  if (mReader) {
-    return; // already initialized
-  }
-
-  // create reader according to requested raw of MC mode
-  if (mRawDataMode) {
-    mReaderRaw = std::make_unique<o2::itsmft::RawPixelReader<o2::itsmft::ChipMappingITS>>();
-    mReader = mReaderRaw.get();
-  } else { // clusterizer of digits
-    mReaderMC = std::make_unique<o2::itsmft::DigitPixelReader>();
-    mReader = mReaderMC.get();
-  }
-
-  mClusterer.print();
-
-  return;
-}
-
-//_____________________________________________________________________
-void ClustererTask::run(const std::string inpName, const std::string outName)
-{
-  // standalone execution
-  Init(); // create reader, clusterer
-
-  if (mRawDataMode) {
-
-    mReaderRaw->openInput(inpName);
-    mClusterer.process(1, *mReaderRaw.get(), &mCompClus, &mPatterns, &mROFRecVec, nullptr);
-
-    auto basename = outName.substr(0, outName.size() - sizeof("root"));
-    auto nFiles = int(mROFRecVec.size() / maxROframe);
-    int i = 0;
-    for (; i < nFiles; i++) {
-      writeTree(basename, i);
-    }
-    writeTree(basename, i); // The remainder
-
-  } else {
-
-    mReaderMC->openInput(inpName, o2::detectors::DetID("ITS"));
-
-    TFile outFile(outName.data(), "new");
-    if (!outFile.IsOpen()) {
-      LOG(fatal) << "Failed to open output file " << outName;
-    }
-
-    TTree outTree("o2sim", "ITS Clusters");
-
-    auto compClusPtr = &mCompClus;
-    outTree.Branch("ITSClusterComp", &compClusPtr);
-
-    auto rofRecVecPtr = &mROFRecVec;
-    outTree.Branch("ITSClustersROF", &rofRecVecPtr);
-
-    auto clsLabelsPtr = &mClsLabels;
-    if (mUseMCTruth && mReaderMC->getDigitsMCTruth()) {
-      // digit labels are provided directly to clusterer
-      outTree.Branch("ITSClusterMCTruth", &clsLabelsPtr);
-    } else {
-      mUseMCTruth = false;
-    }
-    LOG(info) << Class()->GetName() << " | MCTruth: " << (mUseMCTruth ? "ON" : "OFF");
-
-    outTree.Branch("ITSClusterPatt", &mPatterns);
-
-    std::vector<o2::itsmft::MC2ROFRecord> mc2rof, *mc2rofPtr = &mc2rof;
-    if (mUseMCTruth) {
-      auto mc2rofOrig = mReaderMC->getMC2ROFRecords();
-      mc2rof.reserve(mc2rofOrig.size());
-      for (const auto& m2r : mc2rofOrig) { // clone from the span
-        mc2rof.push_back(m2r);
-      }
-      outTree.Branch("ITSClustersMC2ROF", mc2rofPtr);
-    }
-
-    // loop over entries of the input tree
-    while (mReaderMC->readNextEntry()) {
-      mClusterer.process(1, *mReaderMC.get(), &mCompClus, &mPatterns, &mROFRecVec, &mClsLabels);
-    }
-
-    outTree.Fill();
-    outTree.Write();
-  }
-
-  mClusterer.clear();
-}
-
-void ClustererTask::writeTree(std::string basename, int i)
-{
-  auto name = basename + std::to_string(i) + ".root";
-  TFile outFile(name.data(), "new");
-  if (!outFile.IsOpen()) {
-    LOG(fatal) << "Failed to open output file " << name;
-  }
-  TTree outTree("o2sim", "ITS Clusters");
-
-  size_t max = (i + 1) * maxROframe;
-  auto lastf = (max < mROFRecVec.size()) ? mROFRecVec.begin() + max : mROFRecVec.end();
-  std::vector<o2::itsmft::ROFRecord> rofRecBuffer(mROFRecVec.begin() + i * maxROframe, lastf);
-  std::vector<o2::itsmft::ROFRecord>* rofRecPtr = &rofRecBuffer;
-  outTree.Branch("ITSClustersROF", rofRecPtr);
-
-  auto first = rofRecBuffer[0].getFirstEntry();
-  auto last = rofRecBuffer.back().getFirstEntry() + rofRecBuffer.back().getNEntries();
-
-  std::vector<CompClusterExt> compClusBuffer, *compClusPtr = &compClusBuffer;
-  compClusBuffer.assign(&mCompClus[first], &mCompClus[last]);
-  outTree.Branch("ITSClusterComp", &compClusPtr);
-  outTree.Branch("ITSClusterPatt", &mPatterns);
-
-  for (auto& rof : rofRecBuffer) {
-    rof.setFirstEntry(rof.getFirstEntry() - first);
-  }
-
-  outTree.Fill();
-  outTree.Write();
-}
diff --git a/macro/CMakeLists.txt b/macro/CMakeLists.txt
index 1c39a96db1b60..0bb5650364b06 100644
--- a/macro/CMakeLists.txt
+++ b/macro/CMakeLists.txt
@@ -35,7 +35,6 @@ install(FILES CheckDigits_mft.C
               runTPCRefit.C
               run_CRUDataSkimming_its.C
               run_calib_tof.C
-              run_clus_itsSA.C
               run_clus_tof.C
               run_clus_tpc.C
               run_clus_emcal.C
@@ -243,14 +242,6 @@ o2_add_test_root_macro(run_calib_tof.C
                                              O2::DetectorsBase
                                              O2::GlobalTracking)
 
-# FIXME: move to subsystem dir
-o2_add_test_root_macro(run_clus_itsSA.C
-                       PUBLIC_LINK_LIBRARIES O2::DetectorsBase
-                                             O2::ITSReconstruction
-                                             O2::ITSMFTReconstruction
-                                             O2::ITSMFTBase
-                       LABELS its)
-
 # FIXME: move to subsystem dir
 o2_add_test_root_macro(run_clus_tof.C
                        PUBLIC_LINK_LIBRARIES O2::TOFReconstruction O2::Framework O2::TOFBase
diff --git a/macro/run_clus_itsSA.C b/macro/run_clus_itsSA.C
deleted file mode 100644
index a96cd66d5eeec..0000000000000
--- a/macro/run_clus_itsSA.C
+++ /dev/null
@@ -1,65 +0,0 @@
-#if !defined(__CLING__) || defined(__ROOTCLING__)
-#include <TStopwatch.h>
-#include "DetectorsBase/GeometryManager.h"
-#include "ITSReconstruction/ClustererTask.h"
-#include "ITSMFTReconstruction/Clusterer.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
-#include "CommonConstants/LHCConstants.h"
-#include "DetectorsCommonDataFormats/DetectorNameConf.h"
-#include <fairlogger/Logger.h>
-#include "CCDB/BasicCCDBManager.h"
-#include "CCDB/CCDBTimeStampUtils.h"
-#endif
-
-// Clusterization avoiding FairRunAna management.
-// Works both with MC digits and with "raw" data (in this case the last argument must be
-// set to true). The raw data should be prepared beforeahand from the MC digits using e.g.
-// o2::itsmft::RawPixelReader<o2::itsmft::ChipMappingITS> reader;
-// reader.convertDigits2Raw("dig.raw","o2dig.root","o2sim","ITSDigit");
-//
-// Use for MC mode:
-// root -b -q run_clus_itsSA.C+\(\"o2clus_its.root\",\"o2dig.root\"\) 2>&1 | tee clusSA.log
-//
-// Use for RAW mode:
-// root -b -q run_clus_itsSA.C+\(\"o2clus_its.root\",\"dig.raw\"\) 2>&1 | tee clusSARAW.log
-//
-
-void run_clus_itsSA(std::string inputfile = "rawits.bin", // input file name
-                    std::string outputfile = "clr.root",  // output file name (root or raw)
-                    bool raw = true,                      // flag if this is raw data
-                    int strobeBC = -1,                    // strobe length in BC for masking, if <0, get automatically (assume cont. readout)
-                    long timestamp = 0,
-                    bool withPatterns = true)
-{
-  // Initialize logger
-  FairLogger* logger = FairLogger::GetLogger();
-  logger->SetLogVerbosityLevel("LOW");
-  logger->SetLogScreenLevel("INFO");
-
-  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
-  mgr.setURL("http://alice-ccdb.cern.ch");
-  mgr.setTimestamp(timestamp ? timestamp : o2::ccdb::getCurrentTimestamp());
-  const o2::itsmft::TopologyDictionary* dict = mgr.get<o2::itsmft::TopologyDictionary>("ITS/Calib/ClusterDictionary");
-
-  TStopwatch timer;
-
-  // Setup clusterizer
-  Bool_t useMCTruth = kTRUE;  // kFALSE if no comparison with MC needed
-  o2::its::ClustererTask* clus = new o2::its::ClustererTask(useMCTruth, raw);
-  clus->setMaxROframe(2 << 21); // about 3 cluster files per a raw data chunk
-  clus->getClusterer().setDictionary(dict);
-
-  // Mask fired pixels separated by <= this number of BCs (for overflow pixels).
-  // In continuos mode strobe lenght should be used, in triggered one: signal shaping time (~7mus)
-  if (strobeBC < 0) {
-    const auto& dgParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-    strobeBC = dgParams.roFrameLengthInBC;
-  }
-  clus->getClusterer().setMaxBCSeparationToMask(strobeBC + 10);
-
-  clus->getClusterer().print();
-  clus->run(inputfile, outputfile);
-
-  timer.Stop();
-  timer.Print();
-}

From 4c3ba3d4518705622921f677129045ff25c380f4 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 8 Jan 2026 11:08:17 +0100
Subject: [PATCH 1187/1764] DPL: fix warnings

---
 Framework/Core/include/Framework/ServiceSpec.h   | 2 +-
 Framework/Core/include/Framework/StringHelpers.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ServiceSpec.h b/Framework/Core/include/Framework/ServiceSpec.h
index 5684889e85376..8ac0872edd1bf 100644
--- a/Framework/Core/include/Framework/ServiceSpec.h
+++ b/Framework/Core/include/Framework/ServiceSpec.h
@@ -31,7 +31,7 @@ struct DeviceSpec;
 struct ServiceRegistry;
 struct ServiceRegistryRef;
 struct DeviceState;
-struct ProcessingContext;
+class ProcessingContext;
 class EndOfStreamContext;
 struct ConfigContext;
 struct WorkflowSpecNode;
diff --git a/Framework/Core/include/Framework/StringHelpers.h b/Framework/Core/include/Framework/StringHelpers.h
index 8a2d892062f70..a2ee758435efc 100644
--- a/Framework/Core/include/Framework/StringHelpers.h
+++ b/Framework/Core/include/Framework/StringHelpers.h
@@ -171,7 +171,7 @@ constexpr auto get_str(const char (&str)[N])
 }
 
 template <int N>
-constexpr auto get_size(const char (&str)[N])
+constexpr auto get_size(const char (&)[N])
 {
   return N;
 }

From 96e2f45f8c95c91f81b063e9ce35ad056b257fe9 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 8 Jan 2026 11:08:17 +0100
Subject: [PATCH 1188/1764] DPL: avoid MessageSet abstractions when forwarding

This is most likely faster, and it will allow us to move
the early forwarding at an earlier stage where the data is not
yet in a MessageSet.
---
 .../include/Framework/DataProcessingHelpers.h |   9 +-
 Framework/Core/src/DataProcessingDevice.cxx   |   2 +-
 Framework/Core/src/DataProcessingHelpers.cxx  | 188 ++++++++++--------
 Framework/Core/test/test_ForwardInputs.cxx    |  27 ++-
 4 files changed, 127 insertions(+), 99 deletions(-)

diff --git a/Framework/Core/include/Framework/DataProcessingHelpers.h b/Framework/Core/include/Framework/DataProcessingHelpers.h
index 34bb87613d920..a9bd95b69f4c7 100644
--- a/Framework/Core/include/Framework/DataProcessingHelpers.h
+++ b/Framework/Core/include/Framework/DataProcessingHelpers.h
@@ -16,6 +16,7 @@
 #include "Framework/TimesliceIndex.h"
 #include <fairmq/FwdDecls.h>
 #include <vector>
+#include <span>
 
 namespace o2::framework
 {
@@ -53,9 +54,11 @@ struct DataProcessingHelpers {
   /// starts the EoS timers and returns the new TransitionHandlingState in case as new state is requested
   static TransitionHandlingState updateStateTransition(ServiceRegistryRef const& ref, ProcessingPolicies const& policies);
   /// Helper to route messages for forwarding
-  static std::vector<fair::mq::Parts> routeForwardedMessages(FairMQDeviceProxy& proxy,
-                                                   std::vector<MessageSet>& currentSetOfInputs,
-                                                   const bool copyByDefault, bool consume);
+  static std::vector<fair::mq::Parts> routeForwardedMessageSet(FairMQDeviceProxy& proxy, std::vector<MessageSet>& currentSetOfInputs,
+                                                               bool copy, bool consume);
+  /// Helper to route messages for forwarding
+  static void routeForwardedMessages(FairMQDeviceProxy& proxy, std::span<fair::mq::MessagePtr>& currentSetOfInputs, std::vector<fair::mq::Parts>& forwardedParts,
+                                     bool copy, bool consume);
 };
 } // namespace o2::framework
 #endif // O2_FRAMEWORK_DATAPROCESSINGHELPERS_H_
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 63c333561f24e..3925359b056b2 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -592,7 +592,7 @@ static auto forwardInputs = [](ServiceRegistryRef registry, TimesliceSlot slot,
   O2_SIGNPOST_ID_GENERATE(sid, forwarding);
   O2_SIGNPOST_START(forwarding, sid, "forwardInputs", "Starting forwarding for slot %zu with oldestTimeslice %zu %{public}s%{public}s%{public}s",
                     slot.index, oldestTimeslice.timeslice.value, copy ? "with copy" : "", copy && consume ? " and " : "", consume ? "with consume" : "");
-  auto forwardedParts = DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copy, consume);
+  auto forwardedParts = DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copy, consume);
 
   for (int fi = 0; fi < proxy.getNumForwardChannels(); fi++) {
     if (forwardedParts[fi].Size() == 0) {
diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index 90dcee52d73da..2f7a1f65f3bd3 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -228,102 +228,128 @@ TransitionHandlingState DataProcessingHelpers::updateStateTransition(ServiceRegi
   }
 }
 
-auto DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy,
-                                                   std::vector<MessageSet>& currentSetOfInputs,
-                                                   const bool copyByDefault, bool consume) -> std::vector<fair::mq::Parts>
+void DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy, std::span<fair::mq::MessagePtr>& messages, std::vector<fair::mq::Parts>& forwardedParts,
+                                                   const bool copyByDefault, bool consume)
 {
-  // we collect all messages per forward in a map and send them together
-  std::vector<fair::mq::Parts> forwardedParts;
-  forwardedParts.resize(proxy.getNumForwards());
-  std::vector<ChannelIndex> forwardingChoices{};
   O2_SIGNPOST_ID_GENERATE(sid, forwarding);
+  std::vector<ChannelIndex> forwardingChoices{};
+  size_t pi = 0;
+  while (pi < messages.size()) {
+    auto& header = messages[pi];
 
-  for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
-    auto& messageSet = currentSetOfInputs[ii];
+    // If is now possible that the record is not complete when
+    // we forward it, because of a custom completion policy.
+    // this means that we need to skip the empty entries in the
+    // record for being forwarded.
+    if (header->GetData() == nullptr) {
+      pi += 2;
+      continue;
+    }
+    auto dih = o2::header::get<DomainInfoHeader*>(header->GetData());
+    if (dih) {
+      pi += 2;
+      continue;
+    }
+    auto sih = o2::header::get<SourceInfoHeader*>(header->GetData());
+    if (sih) {
+      pi += 2;
+      continue;
+    }
 
-    for (size_t pi = 0; pi < messageSet.size(); ++pi) {
-      auto& header = messageSet.header(pi);
+    auto dph = o2::header::get<DataProcessingHeader*>(header->GetData());
+    auto dh = o2::header::get<o2::header::DataHeader*>(header->GetData());
 
-      // If is now possible that the record is not complete when
-      // we forward it, because of a custom completion policy.
-      // this means that we need to skip the empty entries in the
-      // record for being forwarded.
-      if (header->GetData() == nullptr) {
-        continue;
-      }
-      auto dih = o2::header::get<DomainInfoHeader*>(header->GetData());
-      if (dih) {
-        continue;
-      }
-      auto sih = o2::header::get<SourceInfoHeader*>(header->GetData());
-      if (sih) {
-        continue;
-      }
+    if (dph == nullptr || dh == nullptr) {
+      // Complain only if this is not an out-of-band message
+      LOGP(error, "Data is missing {}{}{}",
+           dph ? "DataProcessingHeader" : "", dph || dh ? "and" : "", dh ? "DataHeader" : "");
+      pi += 2;
+      continue;
+    }
 
-      auto dph = o2::header::get<DataProcessingHeader*>(header->GetData());
-      auto dh = o2::header::get<o2::header::DataHeader*>(header->GetData());
+    // At least one payload.
+    auto& payload = messages[pi + 1];
+    // Calculate the number of messages which should be handled together
+    // all in one go.
+    size_t numberOfMessages = 0;
+    if (dh->splitPayloadParts > 0 && dh->splitPayloadParts == dh->splitPayloadIndex) {
+      // Sequence of (header, payload[0], ... , payload[splitPayloadParts - 1]) pairs belonging together.
+      numberOfMessages = dh->splitPayloadParts + 1; // one is for the header
+    } else {
+      // Sequence of splitPayloadParts (header, payload) pairs belonging together.
+      // In case splitPayloadParts = 0, we consider this as a single message pair
+      numberOfMessages = (dh->splitPayloadParts > 0 ? dh->splitPayloadParts : 1) * 2;
+    }
 
-      if (dph == nullptr || dh == nullptr) {
-        // Complain only if this is not an out-of-band message
-        LOGP(error, "Data is missing {}{}{}",
-             dph ? "DataProcessingHeader" : "", dph || dh ? "and" : "", dh ? "DataHeader" : "");
-        continue;
-      }
+    if (payload.get() == nullptr && consume == true) {
+      // If the payload is not there, it means we already
+      // processed it with ConsumeExisiting. Therefore we
+      // need to do something only if this is the last consume.
+      header.reset(nullptr);
+      pi += numberOfMessages;
+      continue;
+    }
 
-      auto& payload = messageSet.payload(pi);
+    // We need to find the forward route only for the first
+    // part of a split payload. All the others will use the same.
+    // Therefore, we reset and recompute the forwarding choice:
+    //
+    // - If this is the first payload of a [header0][payload0][header0][payload1]... sequence,
+    //   which is actually always created and handled together. Notice that in this
+    //   case we have splitPayloadParts == splitPayloadIndex
+    // - If this is the first payload of a [header0][payload0][header1][payload1]... sequence
+    //   belonging to the same multipart message (and therefore we are guaranteed that they
+    //   need to be routed together).
+    // - If the message is not a multipart (splitPayloadParts 0) or has only one part
+    // - If it's a message of the kind [header0][payload1][payload2][payload3]... and therefore
+    //   we will already use the same choice in the for loop below.
+    //
 
-      if (payload.get() == nullptr && consume == true) {
-        // If the payload is not there, it means we already
-        // processed it with ConsumeExisiting. Therefore we
-        // need to do something only if this is the last consume.
-        header.reset(nullptr);
-        continue;
-      }
+    forwardingChoices.clear();
+    proxy.getMatchingForwardChannelIndexes(forwardingChoices, *dh, dph->startTime);
 
-      // We need to find the forward route only for the first
-      // part of a split payload. All the others will use the same.
-      // Therefore, we reset and recompute the forwarding choice:
-      //
-      // - If this is the first payload of a [header0][payload0][header0][payload1] sequence,
-      //   which is actually always created and handled together
-      // - If the message is not a multipart (splitPayloadParts 0) or has only one part
-      // - If it's a message of the kind [header0][payload1][payload2][payload3]... and therefore
-      //   we will already use the same choice in the for loop below.
-      if (dh->splitPayloadIndex == 0 || dh->splitPayloadParts <= 1 || messageSet.getNumberOfPayloads(pi) > 0) {
-        forwardingChoices.clear();
-        proxy.getMatchingForwardChannelIndexes(forwardingChoices, *dh, dph->startTime);
-      }
+    if (forwardingChoices.empty()) {
+      // Nothing to forward go to the next messageset
+      pi += numberOfMessages;
+      continue;
+    }
 
-      if (forwardingChoices.empty()) {
-        // Nothing to forward go to the next messageset
-        continue;
-      }
+    // In case of more than one forward route, we need to copy the message.
+    // This will eventually use the same memory if running with the same backend.
+    if (copyByDefault || forwardingChoices.size() > 1) {
+      for (auto& choice : forwardingChoices) {
+        O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding a copy of %{public}s to route %d.",
+                               fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), choice.value);
 
-      // In case of more than one forward route, we need to copy the message.
-      // This will eventually use the same memory if running with the same backend.
-      if (copyByDefault || forwardingChoices.size() > 1) {
-        for (auto& choice : forwardingChoices) {
-          auto&& newHeader = header->GetTransport()->CreateMessage();
-          O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding a copy of %{public}s to route %d.",
-                                 fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), choice.value);
-          newHeader->Copy(*header);
-          forwardedParts[choice.value].AddPart(std::move(newHeader));
-
-          for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) {
-            auto&& newPayload = header->GetTransport()->CreateMessage();
-            newPayload->Copy(*messageSet.payload(pi, payloadIndex));
-            forwardedParts[choice.value].AddPart(std::move(newPayload));
-          }
-        }
-      } else {
-        O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding %{public}s to route %d.",
-                               fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), forwardingChoices.back().value);
-        forwardedParts[forwardingChoices.back().value].AddPart(std::move(messageSet.header(pi)));
-        for (size_t payloadIndex = 0; payloadIndex < messageSet.getNumberOfPayloads(pi); ++payloadIndex) {
-          forwardedParts[forwardingChoices.back().value].AddPart(std::move(messageSet.payload(pi, payloadIndex)));
+        for (size_t ppi = pi; ppi < pi + numberOfMessages; ++ppi) {
+          auto&& newMsg = header->GetTransport()->CreateMessage();
+          newMsg->Copy(*messages[ppi]);
+          forwardedParts[choice.value].AddPart(std::move(newMsg));
         }
       }
+    } else {
+      O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding %{public}s to route %d.",
+                             fmt::format("{}/{}/{}@timeslice:{} tfCounter:{}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dph->startTime, dh->tfCounter).c_str(), forwardingChoices.back().value);
+      for (size_t ppi = pi; ppi < pi + numberOfMessages; ++ppi) {
+        forwardedParts[forwardingChoices.back().value].AddPart(std::move(messages[ppi]));
+      }
     }
+    pi += numberOfMessages;
+  }
+}
+
+auto DataProcessingHelpers::routeForwardedMessageSet(FairMQDeviceProxy& proxy,
+                                                     std::vector<MessageSet>& currentSetOfInputs,
+                                                     const bool copyByDefault, bool consume) -> std::vector<fair::mq::Parts>
+{
+  // we collect all messages per forward in a map and send them together
+  std::vector<fair::mq::Parts> forwardedParts;
+  forwardedParts.resize(proxy.getNumForwards());
+  std::vector<ChannelIndex> forwardingChoices{};
+
+  for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
+    auto span = std::span<fair::mq::MessagePtr>(currentSetOfInputs[ii].messages);
+    routeForwardedMessages(proxy, span, forwardedParts, copyByDefault, consume);
   }
   return forwardedParts;
 };
diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
index 7ddbc831edad2..fe9f70d1daadb 100644
--- a/Framework/Core/test/test_ForwardInputs.cxx
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -45,7 +45,7 @@ TEST_CASE("ForwardInputsEmpty")
 
   std::vector<MessageSet> currentSetOfInputs;
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.empty());
 }
 
@@ -95,7 +95,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRoute")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 2); // Two messages for that route
 }
@@ -146,7 +146,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteNoConsume")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, true);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, true);
   REQUIRE(result.size() == 1);
   REQUIRE(result[0].Size() == 0); // Because there is a nullptr, we do not forward this as it was already consumed.
 }
@@ -201,8 +201,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteAtEOS")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 0); // FIXME: this is an actual error. It should be 2. However it cannot really happen.
   // Correct behavior below:
@@ -260,7 +259,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteWithOldestPossible")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 0); // FIXME: this is actually wrong
   // FIXME: actually correct behavior below
@@ -325,7 +324,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutes")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);    // Two routes
   REQUIRE(result[0].Size() == 2); // Two messages per route
   REQUIRE(result[1].Size() == 0); // Only the first DPL matched channel matters
@@ -388,7 +387,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesExternals")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);    // Two routes
   REQUIRE(result[0].Size() == 2); // With external matching channels, we need to copy and then forward
   REQUIRE(result[1].Size() == 2); //
@@ -466,7 +465,7 @@ TEST_CASE("ForwardInputsMultiMessageMultipleRoutes")
   currentSetOfInputs.emplace_back(std::move(messageSet2));
   REQUIRE(currentSetOfInputs.size() == 2);
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);    // Two routes
   REQUIRE(result[0].Size() == 2); //
   REQUIRE(result[1].Size() == 2); //
@@ -529,7 +528,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesOnlyOneMatches")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);    // Two routes
   REQUIRE(result[0].Size() == 0); // Two messages per route
   REQUIRE(result[1].Size() == 2); // Two messages per route
@@ -541,7 +540,7 @@ TEST_CASE("ForwardInputsSplitPayload")
   dh.dataOrigin = "TST";
   dh.dataDescription = "A";
   dh.subSpecification = 0;
-  dh.splitPayloadIndex = 0;
+  dh.splitPayloadIndex = 2;
   dh.splitPayloadParts = 2;
 
   o2::header::DataHeader dh2;
@@ -611,7 +610,7 @@ TEST_CASE("ForwardInputsSplitPayload")
   REQUIRE(messageSet.size() == 2);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 2);  // Two routes
   CHECK(result[0].Size() == 2); // No messages on this route
   CHECK(result[1].Size() == 3);
@@ -657,7 +656,7 @@ TEST_CASE("ForwardInputEOSSingleRoute")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 0); // Oldest possible timeframe should not be forwarded
 }
@@ -702,7 +701,7 @@ TEST_CASE("ForwardInputOldestPossibleSingleRoute")
   REQUIRE(messageSet.size() == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
-  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, currentSetOfInputs, copyByDefault, consume);
+  auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.size() == 1);    // One route
   REQUIRE(result[0].Size() == 0); // Oldest possible timeframe should not be forwarded
 }

From bf75199a5345651cad229244d1f0a3f38dbbdb92 Mon Sep 17 00:00:00 2001
From: Florian Jonas <florian.jonas@cern.ch>
Date: Fri, 9 Jan 2026 16:18:37 +0100
Subject: [PATCH 1189/1764] [EMCAL] implementation of number of local maxima
 variable

* [EMCAL] implementation of number of local maxima variable

* Please consider the following formatting changes

* further optimizations of EMCAL evalNExMax

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../base/include/EMCALBase/ClusterFactory.h   |  4 ++
 .../EMCAL/base/include/EMCALBase/Geometry.h   |  8 +++
 Detectors/EMCAL/base/src/ClusterFactory.cxx   | 60 +++++++++++++++++++
 Detectors/EMCAL/base/src/Geometry.cxx         | 24 ++++++++
 4 files changed, 96 insertions(+)

diff --git a/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h b/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
index a7e81d38838a3..0c3438042ca77 100644
--- a/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
+++ b/Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h
@@ -401,6 +401,10 @@ class ClusterFactory
   /// in cell units
   void evalElipsAxis(gsl::span<const int> inputsIndices, AnalysisCluster& clusterAnalysis) const;
 
+  ///
+  /// Calculate the number of local maxima in the cluster
+  void evalNExMax(gsl::span<const int> inputsIndices, AnalysisCluster& clusterAnalysis) const;
+
   ///
   /// Time is set to the time of the digit with the maximum energy
   void evalTime(gsl::span<const int> inputsIndices, AnalysisCluster& clusterAnalysis) const;
diff --git a/Detectors/EMCAL/base/include/EMCALBase/Geometry.h b/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
index b4621d4b6e434..d07f42689bf7a 100644
--- a/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
+++ b/Detectors/EMCAL/base/include/EMCALBase/Geometry.h
@@ -429,6 +429,14 @@ class Geometry
   /// \return Position (0 - phi, 1 - eta) of the cell inside teh supermodule
   std::tuple<int, int> GetCellPhiEtaIndexInSModule(int supermoduleID, int moduleID, int phiInModule, int etaInModule) const;
 
+  /// \brief Get topological row and column of cell in SM (same as for clusteriser with artifical gaps)
+  /// \param supermoduleID super module number
+  /// \param moduleID module number
+  /// \param phiInModule index in phi direction in module
+  /// \param etaInModule index in phi direction in module
+  /// \return tuple with (row, column) of the cell, which is global numbering scheme
+  std::tuple<short, short> GetTopologicalRowColumn(int supermoduleID, int moduleID, int phiInModule, int etaInModule) const;
+
   /// \brief Adapt cell indices in supermodule to online indexing
   /// \param supermoduleID super module number of the channel/cell
   /// \param iphi row/phi cell index, modified for DCal
diff --git a/Detectors/EMCAL/base/src/ClusterFactory.cxx b/Detectors/EMCAL/base/src/ClusterFactory.cxx
index 342f54fd94591..970f7979ef86d 100644
--- a/Detectors/EMCAL/base/src/ClusterFactory.cxx
+++ b/Detectors/EMCAL/base/src/ClusterFactory.cxx
@@ -120,6 +120,9 @@ o2::emcal::AnalysisCluster ClusterFactory<InputType>::buildCluster(int clusterIn
   evalElipsAxis(inputsIndices, clusterAnalysis);
   evalDispersion(inputsIndices, clusterAnalysis);
 
+  // evaluate number of local maxima
+  evalNExMax(inputsIndices, clusterAnalysis);
+
   evalCoreEnergy(inputsIndices, clusterAnalysis);
   evalTime(inputsIndices, clusterAnalysis);
 
@@ -489,6 +492,63 @@ void ClusterFactory<InputType>::evalCoreEnergy(gsl::span<const int> inputsIndice
   clusterAnalysis.setCoreEnergy(coreEnergy);
 }
 
+///
+/// Calculate the number of local maxima in the cluster
+//____________________________________________________________________________
+template <class InputType>
+void ClusterFactory<InputType>::evalNExMax(gsl::span<const int> inputsIndices, AnalysisCluster& clusterAnalysis) const
+{
+  // Pre-compute cell indices and energies for all cells in cluster to avoid multiple expensive geometry lookups
+  const size_t n = inputsIndices.size();
+  std::vector<short> rows;
+  std::vector<short> columns;
+  std::vector<double> energies;
+
+  rows.reserve(n);
+  columns.reserve(n);
+  energies.reserve(n);
+
+  for (auto iInput : inputsIndices) {
+    auto [nSupMod, nModule, nIphi, nIeta] = mGeomPtr->GetCellIndex(mInputsContainer[iInput].getTower());
+
+    // get a nice topological indexing that is done in exactly the same way as used by the clusterizer
+    // this way we can handle the shared cluster cases correctly
+    const auto [row, column] = mGeomPtr->GetTopologicalRowColumn(nSupMod, nModule, nIphi, nIeta);
+
+    rows.push_back(row);
+    columns.push_back(column);
+    energies.push_back(mInputsContainer[iInput].getEnergy());
+  }
+
+  // Now find local maxima using pre-computed data
+  int nExMax = 0;
+  for (size_t i = 0; i < n; i++) {
+    // this cell is assumed to be local maximum unless we find a higher energy cell in the neighborhood
+    bool isExMax = true;
+
+    // loop over all other cells in cluster
+    for (size_t j = 0; j < n; j++) {
+      if (i == j)
+        continue;
+
+      // adjacent cell is any cell with adjacent phi or eta index
+      if (std::abs(rows[i] - rows[j]) <= 1 &&
+          std::abs(columns[i] - columns[j]) <= 1) {
+
+        // if there is a cell with higher energy than the current cell, it is not a local maximum
+        if (energies[j] > energies[i]) {
+          isExMax = false;
+          break;
+        }
+      }
+    }
+    if (isExMax) {
+      nExMax++;
+    }
+  }
+  clusterAnalysis.setNExMax(nExMax);
+}
+
 ///
 /// Calculates the axis of the shower ellipsoid in eta and phi
 /// in cell units
diff --git a/Detectors/EMCAL/base/src/Geometry.cxx b/Detectors/EMCAL/base/src/Geometry.cxx
index c194f570e47d1..3707e22f2da57 100644
--- a/Detectors/EMCAL/base/src/Geometry.cxx
+++ b/Detectors/EMCAL/base/src/Geometry.cxx
@@ -1103,6 +1103,30 @@ std::tuple<int, int> Geometry::GetCellPhiEtaIndexInSModule(int supermoduleID, in
   return std::make_tuple(phiInSupermodule, etaInSupermodule);
 }
 
+std::tuple<short, short> Geometry::GetTopologicalRowColumn(int supermoduleID, int moduleID, int phiInModule, int etaInModule) const
+{
+  auto [iphi, ieta] = GetCellPhiEtaIndexInSModule(supermoduleID, moduleID, phiInModule, etaInModule);
+  int row = iphi;
+  int column = ieta;
+
+  // Add shifts wrt. supermodule and type of calorimeter
+  // NOTE:
+  // * Rows (phi) are arranged that one space is left empty between supermodules in phi
+  //   This is due to the physical gap that forbids clustering
+  // * For DCAL, there is an additional empty column between two supermodules in eta
+  //   Again, this is to account for the gap in DCAL
+
+  row += supermoduleID / 2 * (24 + 1);
+  // In DCAL, leave a gap between two SMs with same phi
+  if (!IsDCALSM(supermoduleID)) { // EMCAL
+    column += supermoduleID % 2 * 48;
+  } else {
+    column += supermoduleID % 2 * (48 + 1);
+  }
+
+  return std::make_tuple(static_cast<short>(row), static_cast<short>(column));
+}
+
 std::tuple<int, int> Geometry::ShiftOnlineToOfflineCellIndexes(Int_t supermoduleID, Int_t iphi, Int_t ieta) const
 {
   if (supermoduleID == 13 || supermoduleID == 15 || supermoduleID == 17) {

From 696cf650cc142446b722e1b10212bfcc4d14f03d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 9 Jan 2026 11:39:02 +0100
Subject: [PATCH 1190/1764] DPL: fix a few warnings

---
 Framework/Core/include/Framework/GuiCallbackContext.h | 2 +-
 Framework/Core/include/Framework/InitContext.h        | 2 +-
 Framework/Core/include/Framework/ServiceRegistry.h    | 2 +-
 Framework/Core/include/Framework/ServiceSpec.h        | 4 ++--
 Framework/Core/src/TMessageSerializer.cxx             | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Framework/Core/include/Framework/GuiCallbackContext.h b/Framework/Core/include/Framework/GuiCallbackContext.h
index 1dbb6ec30e849..5bb3148621476 100644
--- a/Framework/Core/include/Framework/GuiCallbackContext.h
+++ b/Framework/Core/include/Framework/GuiCallbackContext.h
@@ -23,7 +23,7 @@ namespace o2::framework
 {
 
 struct GuiCallbackContext;
-class WSDPLHandler;
+struct WSDPLHandler;
 
 struct GuiRenderer {
   uv_timer_t drawTimer;
diff --git a/Framework/Core/include/Framework/InitContext.h b/Framework/Core/include/Framework/InitContext.h
index 8e616d276748b..7f6cec3c7a160 100644
--- a/Framework/Core/include/Framework/InitContext.h
+++ b/Framework/Core/include/Framework/InitContext.h
@@ -16,7 +16,7 @@
 namespace o2::framework
 {
 
-class ServiceRegistry;
+struct ServiceRegistry;
 class ConfigParamRegistry;
 
 // This is a utility class to reduce the amount of boilerplate when defining
diff --git a/Framework/Core/include/Framework/ServiceRegistry.h b/Framework/Core/include/Framework/ServiceRegistry.h
index ebafd466929ff..d6516e31be62d 100644
--- a/Framework/Core/include/Framework/ServiceRegistry.h
+++ b/Framework/Core/include/Framework/ServiceRegistry.h
@@ -158,7 +158,7 @@ struct ServiceRegistry {
   /// not bonded to a specific stream, e.g. the
   /// name of the data processor, its inputs and outputs,
   /// it's algorithm.
-  static Salt dataProcessorSalt(short dataProcessorId)
+  static Salt dataProcessorSalt(short /* dataProcessorId */)
   {
     // FIXME: old behaviour for now
     // return {0, dataProcessorId};
diff --git a/Framework/Core/include/Framework/ServiceSpec.h b/Framework/Core/include/Framework/ServiceSpec.h
index 8ac0872edd1bf..aa762b5d039e0 100644
--- a/Framework/Core/include/Framework/ServiceSpec.h
+++ b/Framework/Core/include/Framework/ServiceSpec.h
@@ -26,10 +26,10 @@ struct ProgOptions;
 namespace o2::framework
 {
 
-struct InitContext;
+class InitContext;
 struct DeviceSpec;
 struct ServiceRegistry;
-struct ServiceRegistryRef;
+class ServiceRegistryRef;
 struct DeviceState;
 class ProcessingContext;
 class EndOfStreamContext;
diff --git a/Framework/Core/src/TMessageSerializer.cxx b/Framework/Core/src/TMessageSerializer.cxx
index 81a1c6e537d09..bf9583f780957 100644
--- a/Framework/Core/src/TMessageSerializer.cxx
+++ b/Framework/Core/src/TMessageSerializer.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 #include <Framework/TMessageSerializer.h>
-#include <FairMQTransportFactory.h>
+#include <fairmq/TransportFactory.h>
 #include <algorithm>
 #include <memory>
 

From 67c2a31833ceafdfb6a497b94ea1ae6be3f17651 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 6 Jan 2026 10:59:37 +0100
Subject: [PATCH 1191/1764] TPC: move PadFlags and related classes to
 TPCBaseRecSim

o2::tpc::PadFlags and in particular vectors of thereof are affected by an old ROOT
bug in serializing `std::vector<enum struct : short>`.

Because of this we have a custom streamer which needs to be initialised very early in order
to function correctly.

This is fine, however, due to the fact we invoke `TClass::GetClass()` too early, ROOT is
forced a bunch of extra stuff, unneededly, resulting in much increased memory footprint
in analysis, which happens to use DataFormatsTPC.

This makes sure the custom streamer is not initialised statically by DataFormatsTPC and
prevents ROOT from loading the kitchen sink when the TClass::GetClass is invoked too early.
---
 .../TPC/include/DataFormatsTPC/Defs.h         | 17 -------
 .../Detectors/TPC/src/DataFormatsTPCLinkDef.h |  2 -
 Detectors/TPC/CMakeLists.txt                  |  1 +
 Detectors/TPC/base/CMakeLists.txt             | 21 +--------
 Detectors/TPC/base/src/TPCBaseLinkDef.h       |  8 ----
 .../TPC/base/test/testTPCCDBInterface.cxx     |  2 +-
 Detectors/TPC/baserecsim/CMakeLists.txt       | 35 +++++++++++++++
 .../include/TPCBaseRecSim}/CDBInterface.h     |  4 +-
 .../include/TPCBaseRecSim}/CDBTypes.h         |  0
 .../TPCBaseRecSim}/DeadChannelMapCreator.h    |  4 +-
 .../include/TPCBaseRecSim/PadFlags.h          | 44 +++++++++++++++++++
 .../include/TPCBaseRecSim}/Painter.h          |  0
 .../{base => baserecsim}/src/CDBInterface.cxx |  2 +-
 .../src/DeadChannelMapCreator.cxx             |  4 +-
 .../TPC/{base => baserecsim}/src/Painter.cxx  |  3 +-
 .../TPC/baserecsim/src/TPCBaseRecSimLinkDef.h | 27 ++++++++++++
 .../src/TPCFlagsMemberCustomStreamer.cxx      |  0
 .../test/testTPCCalDet.cxx                    |  2 +-
 Detectors/TPC/calibration/CMakeLists.txt      | 10 ++---
 .../include/TPCCalibration/IDCCCDBHelper.h    |  1 +
 .../include/TPCCalibration/IDCFactorization.h |  1 +
 .../macro/comparePedestalsAndNoise.C          |  4 +-
 .../calibration/macro/drawNoiseAndPedestal.C  |  4 +-
 Detectors/TPC/calibration/macro/drawPulser.C  |  2 +-
 .../TPC/calibration/macro/prepareCMFiles.C    |  2 +-
 .../TPC/calibration/macro/prepareITFiles.C    |  2 +-
 .../calibration/macro/preparePedestalFiles.C  |  2 +-
 .../TPC/calibration/src/CalculatedEdx.cxx     |  2 +-
 .../src/CalibPadGainTracksBase.cxx            |  2 +-
 .../calibration/src/CorrectionMapsLoader.cxx  |  2 +-
 .../TPC/calibration/src/IDCAverageGroup.cxx   |  3 +-
 .../TPC/calibration/src/IDCCCDBHelper.cxx     |  2 +-
 .../TPC/calibration/src/IDCDrawHelper.cxx     |  2 +-
 .../src/PressureTemperatureHelper.cxx         |  2 +-
 .../TPC/calibration/src/SACDrawHelper.cxx     |  2 +-
 .../TPC/calibration/src/VDriftHelper.cxx      |  2 +-
 Detectors/TPC/dcs/src/DCSConfigSpec.cxx       |  2 +-
 Detectors/TPC/dcs/src/DCSSpec.cxx             |  2 +-
 .../TPC/monitor/src/SimpleEventDisplayGUI.cxx |  2 +-
 Detectors/TPC/qc/macro/runClusters.C          |  2 +-
 Detectors/TPC/qc/macro/runPID.C               |  2 +-
 Detectors/TPC/qc/src/Clusters.cxx             |  2 +-
 Detectors/TPC/qc/src/IDCsVsSACs.cxx           |  2 +-
 Detectors/TPC/simulation/macro/toyCluster.C   |  2 +-
 .../TPC/simulation/src/DigitContainer.cxx     |  2 +-
 Detectors/TPC/simulation/src/Digitizer.cxx    |  2 +-
 .../TPC/simulation/src/ElectronTransport.cxx  |  2 +-
 .../TPC/simulation/src/GEMAmplification.cxx   |  2 +-
 Detectors/TPC/simulation/src/IDCSim.cxx       |  2 +-
 .../TPC/simulation/src/SAMPAProcessing.cxx    |  2 +-
 .../simulation/test/testTPCDigitContainer.cxx |  2 +-
 .../test/testTPCElectronTransport.cxx         |  2 +-
 .../test/testTPCGEMAmplification.cxx          |  2 +-
 .../test/testTPCSAMPAProcessing.cxx           |  2 +-
 Detectors/TPC/spacecharge/CMakeLists.txt      |  2 +-
 .../macro/createSCHistosFromHits.C            |  2 +-
 Detectors/TPC/spacecharge/src/SpaceCharge.cxx |  2 +-
 .../TPCWorkflow/CalibratorPadGainTracksSpec.h |  2 +-
 .../TPCWorkflow/TPCCalibPadGainTracksSpec.h   |  2 +-
 .../include/TPCWorkflow/TPCCalibPadRawSpec.h  |  2 +-
 .../include/TPCWorkflow/TPCFLPIDCSpec.h       |  2 +-
 .../include/TPCWorkflow/TPCFactorizeIDCSpec.h |  2 +-
 .../include/TPCWorkflow/TPCFactorizeSACSpec.h |  2 +-
 .../src/CalDetMergerPublisherSpec.cxx         |  2 +-
 Detectors/TPC/workflow/src/CalibdEdxSpec.cxx  |  2 +-
 .../TPC/workflow/src/CalibratordEdxSpec.cxx   |  2 +-
 .../TPC/workflow/src/SACProcessorSpec.cxx     |  2 +-
 .../src/TPCMergeIntegrateClusterSpec.cxx      |  2 +-
 Detectors/TPC/workflow/src/TPCScalerSpec.cxx  |  2 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |  4 +-
 GPU/Workflow/src/GPUWorkflowTPC.cxx           |  4 +-
 .../src/SimpleDigitizerWorkflow.cxx           |  2 +-
 .../src/TPCDigitizerSpec.cxx                  |  2 +-
 73 files changed, 183 insertions(+), 118 deletions(-)
 create mode 100644 Detectors/TPC/baserecsim/CMakeLists.txt
 rename Detectors/TPC/{base/include/TPCBase => baserecsim/include/TPCBaseRecSim}/CDBInterface.h (99%)
 rename Detectors/TPC/{base/include/TPCBase => baserecsim/include/TPCBaseRecSim}/CDBTypes.h (100%)
 rename Detectors/TPC/{base/include/TPCBase => baserecsim/include/TPCBaseRecSim}/DeadChannelMapCreator.h (98%)
 create mode 100644 Detectors/TPC/baserecsim/include/TPCBaseRecSim/PadFlags.h
 rename Detectors/TPC/{base/include/TPCBase => baserecsim/include/TPCBaseRecSim}/Painter.h (100%)
 rename Detectors/TPC/{base => baserecsim}/src/CDBInterface.cxx (99%)
 rename Detectors/TPC/{base => baserecsim}/src/DeadChannelMapCreator.cxx (98%)
 rename Detectors/TPC/{base => baserecsim}/src/Painter.cxx (99%)
 create mode 100644 Detectors/TPC/baserecsim/src/TPCBaseRecSimLinkDef.h
 rename Detectors/TPC/{base => baserecsim}/src/TPCFlagsMemberCustomStreamer.cxx (100%)
 rename Detectors/TPC/{base => baserecsim}/test/testTPCCalDet.cxx (99%)

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/Defs.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/Defs.h
index 9b8853a10535d..fa04586479a22 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/Defs.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/Defs.h
@@ -97,23 +97,6 @@ enum class StatisticsType {
   MeanStdDev   ///< Use mean and standard deviation
 };
 
-enum class PadFlags : unsigned short {
-  flagGoodPad = 1 << 0,      ///< flag for a good pad binary 0001
-  flagDeadPad = 1 << 1,      ///< flag for a dead pad binary 0010
-  flagUnknownPad = 1 << 2,   ///< flag for unknown status binary 0100
-  flagSaturatedPad = 1 << 3, ///< flag for saturated status binary 0100
-  flagHighPad = 1 << 4,      ///< flag for pad with extremly high IDC value
-  flagLowPad = 1 << 5,       ///< flag for pad with extremly low IDC value
-  flagSkip = 1 << 6,         ///< flag for defining a pad which is just ignored during the calculation of I1 and IDCDelta
-  flagFEC = 1 << 7,          ///< flag for a whole masked FEC
-  flagNeighbour = 1 << 8,    ///< flag if n neighbouring pads are outlier
-  flagAllNoneGood = flagDeadPad | flagUnknownPad | flagSaturatedPad | flagHighPad | flagLowPad | flagSkip | flagFEC | flagNeighbour,
-};
-
-inline PadFlags operator&(PadFlags a, PadFlags b) { return static_cast<PadFlags>(static_cast<int>(a) & static_cast<int>(b)); }
-inline PadFlags operator~(PadFlags a) { return static_cast<PadFlags>(~static_cast<int>(a)); }
-inline PadFlags operator|(PadFlags a, PadFlags b) { return static_cast<PadFlags>(static_cast<int>(a) | static_cast<int>(b)); }
-
 // default point definitions for PointND, PointNDlocal, PointNDglobal are in
 // MathUtils/CartesianND.h
 
diff --git a/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h b/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
index f463e9011c935..fd5abca99cb0f 100644
--- a/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
+++ b/DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h
@@ -22,7 +22,6 @@
 #pragma link C++ class o2::tpc::ClusterHardwareContainerFixedSize < 8192> + ;
 #pragma link C++ class o2::tpc::ClusterNativeContainer + ;
 #pragma link C++ class o2::tpc::Digit + ;
-#pragma link C++ enum o2::tpc::PadFlags + ; // enum itself
 #pragma link C++ class o2::tpc::ZeroSuppressedContainer8kb + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterNative> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterNativeContainer> + ;
@@ -30,7 +29,6 @@
 #pragma link C++ class std::vector < o2::tpc::ClusterHardwareContainerFixedSize < 8192>> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterHardwareContainer8kb> + ;
 #pragma link C++ class std::vector < o2::tpc::Digit> + ;
-#pragma link C++ class std::vector < o2::tpc::PadFlags> + ;
 #pragma link C++ class std::vector < o2::tpc::ZeroSuppressedContainer8kb> + ;
 #pragma link C++ class o2::tpc::TrackTPC + ;
 #pragma link C++ class o2::tpc::LaserTrack + ;
diff --git a/Detectors/TPC/CMakeLists.txt b/Detectors/TPC/CMakeLists.txt
index e3de1ca57c1be..aea0dee361874 100644
--- a/Detectors/TPC/CMakeLists.txt
+++ b/Detectors/TPC/CMakeLists.txt
@@ -10,6 +10,7 @@
 # or submit itself to any jurisdiction.
 
 add_subdirectory(base)
+add_subdirectory(baserecsim)
 add_subdirectory(reconstruction)
 add_subdirectory(calibration)
 add_subdirectory(simulation)
diff --git a/Detectors/TPC/base/CMakeLists.txt b/Detectors/TPC/base/CMakeLists.txt
index a82214d8c070f..6456207e50530 100644
--- a/Detectors/TPC/base/CMakeLists.txt
+++ b/Detectors/TPC/base/CMakeLists.txt
@@ -12,7 +12,6 @@
 o2_add_library(TPCBase
                SOURCES src/CalArray.cxx
                        src/CalDet.cxx
-                       src/CDBInterface.cxx
                        src/ContainerFactory.cxx
                        src/CRU.cxx
                        src/DigitPos.cxx
@@ -24,7 +23,6 @@ o2_add_library(TPCBase
                        src/PadRegionInfo.cxx
                        src/PadROCPos.cxx
                        src/PadSecPos.cxx
-                       src/Painter.cxx
                        src/ParameterDetector.cxx
                        src/ParameterElectronics.cxx
                        src/ParameterGas.cxx
@@ -37,16 +35,13 @@ o2_add_library(TPCBase
                        src/CRUCalibHelpers.cxx
                        src/IonTailSettings.cxx
                        src/FEEConfig.cxx
-                       src/DeadChannelMapCreator.cxx
                        src/CommonModeCorrection.cxx
                PUBLIC_LINK_LIBRARIES Vc::Vc Boost::boost O2::DataFormatsTPC
                                      O2::DetectorsRaw O2::CCDB FairRoot::Base)
 
 o2_target_root_dictionary(TPCBase
-                          EXTRA_PATCH src/TPCFlagsMemberCustomStreamer.cxx
                           HEADERS include/TPCBase/CalArray.h
                                   include/TPCBase/CalDet.h
-                                  include/TPCBase/CDBInterface.h
                                   include/TPCBase/ContainerFactory.h
                                   include/TPCBase/CRU.h
                                   include/TPCBase/DigitPos.h
@@ -58,7 +53,6 @@ o2_target_root_dictionary(TPCBase
                                   include/TPCBase/PadRegionInfo.h
                                   include/TPCBase/PadROCPos.h
                                   include/TPCBase/PadSecPos.h
-                                  include/TPCBase/Painter.h
                                   include/TPCBase/ParameterDetector.h
                                   include/TPCBase/ParameterElectronics.h
                                   include/TPCBase/ParameterGas.h
@@ -71,26 +65,13 @@ o2_target_root_dictionary(TPCBase
                                   include/TPCBase/CRUCalibHelpers.h
                                   include/TPCBase/IonTailSettings.h
                                   include/TPCBase/FEEConfig.h
-                                  include/TPCBase/DeadChannelMapCreator.h
-                                  include/TPCBase/CommonModeCorrection.h
-                                  include/TPCBase/CDBTypes.h)
+                                  include/TPCBase/CommonModeCorrection.h)
 o2_add_test(Base
             COMPONENT_NAME tpc
             PUBLIC_LINK_LIBRARIES O2::TPCBase
             SOURCES test/testTPCBase.cxx
             LABELS tpc)
 
-if(BUILD_SIMULATION)
-  # this test needs CCDB/XROOTD which is for sure
-  # available in the default-o2 software stack
-  o2_add_test(CalDet
-            COMPONENT_NAME tpc
-            PUBLIC_LINK_LIBRARIES O2::TPCBase
-            SOURCES test/testTPCCalDet.cxx
-            ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage
-            LABELS tpc)
-endif()
-
 o2_add_test(Mapper
             COMPONENT_NAME tpc
             PUBLIC_LINK_LIBRARIES O2::TPCBase
diff --git a/Detectors/TPC/base/src/TPCBaseLinkDef.h b/Detectors/TPC/base/src/TPCBaseLinkDef.h
index 4fdde1ca55518..2b7a7ff19542d 100644
--- a/Detectors/TPC/base/src/TPCBaseLinkDef.h
+++ b/Detectors/TPC/base/src/TPCBaseLinkDef.h
@@ -21,20 +21,15 @@
 #pragma link C++ class o2::tpc::CalArray < unsigned> + ;
 #pragma link C++ class o2::tpc::CalArray < short> + ;
 #pragma link C++ class o2::tpc::CalArray < bool> + ;
-#pragma link C++ class o2::tpc::CalArray < o2::tpc::PadFlags> + ;
 #pragma link C++ class o2::tpc::CalDet < float> + ;
 #pragma link C++ class o2::tpc::CalDet < double> + ;
 #pragma link C++ class o2::tpc::CalDet < int> + ;
 #pragma link C++ class o2::tpc::CalDet < unsigned> + ;
 #pragma link C++ class o2::tpc::CalDet < short> + ;
 #pragma link C++ class o2::tpc::CalDet < bool> + ;
-#pragma link C++ class o2::tpc::CalDet < o2::tpc::PadFlags> + ;
 #pragma link C++ class std::vector < o2::tpc::CalDet < float>> + ;
 #pragma link C++ class std::vector < o2::tpc::CalDet < float>*> + ;
 #pragma link C++ class std::unordered_map < std::string, o2::tpc::CalDet < float>> + ;
-#pragma link C++ enum o2::tpc::CDBType;
-#pragma link C++ class o2::tpc::CDBInterface;
-#pragma link C++ class o2::tpc::CDBStorage;
 #pragma link C++ class o2::tpc::ContainerFactory;
 #pragma link C++ class o2::tpc::CRU;
 #pragma link C++ class o2::tpc::DigitPos;
@@ -50,8 +45,6 @@
 #pragma link C++ class o2::tpc::ROC;
 #pragma link C++ class o2::tpc::Sector;
 
-#pragma link C++ class o2::tpc::painter + ;
-
 // #pragma link C++ class std::vector <TCanvas*> + ;
 #pragma link C++ class o2::tpc::ParameterDetector;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::tpc::ParameterDetector> + ;
@@ -90,5 +83,4 @@
 #pragma link C++ function o2::tpc::cru_calib_helpers::getCalPad < 2>(const std::string_view, const std::string_view, std::string_view)
 #pragma link C++ function o2::tpc::cru_calib_helpers::getCalPad < 6>(const std::string_view, const std::string_view, std::string_view)
 
-#pragma link C++ class o2::tpc::DeadChannelMapCreator + ;
 #endif
diff --git a/Detectors/TPC/base/test/testTPCCDBInterface.cxx b/Detectors/TPC/base/test/testTPCCDBInterface.cxx
index 5a5384a4134ed..a0f4142b3f807 100644
--- a/Detectors/TPC/base/test/testTPCCDBInterface.cxx
+++ b/Detectors/TPC/base/test/testTPCCDBInterface.cxx
@@ -21,7 +21,7 @@
 #include "TFile.h"
 
 // o2 includes
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/CalArray.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/Mapper.h"
diff --git a/Detectors/TPC/baserecsim/CMakeLists.txt b/Detectors/TPC/baserecsim/CMakeLists.txt
new file mode 100644
index 0000000000000..b6c0f2644aa81
--- /dev/null
+++ b/Detectors/TPC/baserecsim/CMakeLists.txt
@@ -0,0 +1,35 @@
+# Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(TPCBaseRecSim
+               SOURCES src/DeadChannelMapCreator.cxx
+                       src/Painter.cxx
+                       src/CDBInterface.cxx
+               PUBLIC_LINK_LIBRARIES O2::TPCBase)
+
+o2_target_root_dictionary(TPCBaseRecSim
+                          EXTRA_PATCH src/TPCFlagsMemberCustomStreamer.cxx
+                          HEADERS include/TPCBaseRecSim/Painter.h
+                                  include/TPCBaseRecSim/PadFlags.h
+                                  include/TPCBaseRecSim/DeadChannelMapCreator.h
+                                  include/TPCBaseRecSim/CDBTypes.h
+                                  include/TPCBaseRecSim/CDBInterface.h)
+
+if(BUILD_SIMULATION)
+  # this test needs CCDB/XROOTD which is for sure
+  # available in the default-o2 software stack
+  o2_add_test(CalDet
+            COMPONENT_NAME tpc
+            PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
+            SOURCES test/testTPCCalDet.cxx
+            ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage
+            LABELS tpc)
+endif()
diff --git a/Detectors/TPC/base/include/TPCBase/CDBInterface.h b/Detectors/TPC/baserecsim/include/TPCBaseRecSim/CDBInterface.h
similarity index 99%
rename from Detectors/TPC/base/include/TPCBase/CDBInterface.h
rename to Detectors/TPC/baserecsim/include/TPCBaseRecSim/CDBInterface.h
index 4c28744f0378a..5b2c8e6d48251 100644
--- a/Detectors/TPC/base/include/TPCBase/CDBInterface.h
+++ b/Detectors/TPC/baserecsim/include/TPCBaseRecSim/CDBInterface.h
@@ -25,8 +25,8 @@
 #include "CCDB/CcdbApi.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/FEEConfig.h"
-#include "TPCBase/CDBTypes.h"
-#include "TPCBase/DeadChannelMapCreator.h"
+#include "TPCBaseRecSim/CDBTypes.h"
+#include "TPCBaseRecSim/DeadChannelMapCreator.h"
 #include "DataFormatsTPC/LtrCalibData.h"
 #include "DataFormatsTPC/Defs.h"
 #include "CommonUtils/NameConf.h"
diff --git a/Detectors/TPC/base/include/TPCBase/CDBTypes.h b/Detectors/TPC/baserecsim/include/TPCBaseRecSim/CDBTypes.h
similarity index 100%
rename from Detectors/TPC/base/include/TPCBase/CDBTypes.h
rename to Detectors/TPC/baserecsim/include/TPCBaseRecSim/CDBTypes.h
diff --git a/Detectors/TPC/base/include/TPCBase/DeadChannelMapCreator.h b/Detectors/TPC/baserecsim/include/TPCBaseRecSim/DeadChannelMapCreator.h
similarity index 98%
rename from Detectors/TPC/base/include/TPCBase/DeadChannelMapCreator.h
rename to Detectors/TPC/baserecsim/include/TPCBaseRecSim/DeadChannelMapCreator.h
index 9d4317380f4bc..5a3fc38aa208b 100644
--- a/Detectors/TPC/base/include/TPCBase/DeadChannelMapCreator.h
+++ b/Detectors/TPC/baserecsim/include/TPCBaseRecSim/DeadChannelMapCreator.h
@@ -21,8 +21,8 @@
 
 #include "CCDB/CcdbApi.h"
 
-#include "DataFormatsTPC/Defs.h"
-#include "TPCBase/CDBTypes.h"
+#include "TPCBaseRecSim/PadFlags.h"
+#include "TPCBaseRecSim/CDBTypes.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/FEEConfig.h"
 
diff --git a/Detectors/TPC/baserecsim/include/TPCBaseRecSim/PadFlags.h b/Detectors/TPC/baserecsim/include/TPCBaseRecSim/PadFlags.h
new file mode 100644
index 0000000000000..e13a24adf407e
--- /dev/null
+++ b/Detectors/TPC/baserecsim/include/TPCBaseRecSim/PadFlags.h
@@ -0,0 +1,44 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// @file   Defs.h
+/// @author Jens Wiechula, Jens.Wiechula@ikf.uni-frankfurt.de
+///
+
+/// @brief  Global TPC definitions and constants
+
+#ifndef AliceO2_TPC_PadFlags_H
+#define AliceO2_TPC_PadFlags_H
+
+namespace o2::tpc
+{
+
+enum class PadFlags : unsigned short {
+  flagGoodPad = 1 << 0,      ///< flag for a good pad binary 0001
+  flagDeadPad = 1 << 1,      ///< flag for a dead pad binary 0010
+  flagUnknownPad = 1 << 2,   ///< flag for unknown status binary 0100
+  flagSaturatedPad = 1 << 3, ///< flag for saturated status binary 0100
+  flagHighPad = 1 << 4,      ///< flag for pad with extremly high IDC value
+  flagLowPad = 1 << 5,       ///< flag for pad with extremly low IDC value
+  flagSkip = 1 << 6,         ///< flag for defining a pad which is just ignored during the calculation of I1 and IDCDelta
+  flagFEC = 1 << 7,          ///< flag for a whole masked FEC
+  flagNeighbour = 1 << 8,    ///< flag if n neighbouring pads are outlier
+  flagAllNoneGood = flagDeadPad | flagUnknownPad | flagSaturatedPad | flagHighPad | flagLowPad | flagSkip | flagFEC | flagNeighbour,
+};
+
+inline PadFlags operator&(PadFlags a, PadFlags b) { return static_cast<PadFlags>(static_cast<int>(a) & static_cast<int>(b)); }
+inline PadFlags operator~(PadFlags a) { return static_cast<PadFlags>(~static_cast<int>(a)); }
+inline PadFlags operator|(PadFlags a, PadFlags b) { return static_cast<PadFlags>(static_cast<int>(a) | static_cast<int>(b)); }
+
+} // namespace o2::tpc
+
+#endif
diff --git a/Detectors/TPC/base/include/TPCBase/Painter.h b/Detectors/TPC/baserecsim/include/TPCBaseRecSim/Painter.h
similarity index 100%
rename from Detectors/TPC/base/include/TPCBase/Painter.h
rename to Detectors/TPC/baserecsim/include/TPCBaseRecSim/Painter.h
diff --git a/Detectors/TPC/base/src/CDBInterface.cxx b/Detectors/TPC/baserecsim/src/CDBInterface.cxx
similarity index 99%
rename from Detectors/TPC/base/src/CDBInterface.cxx
rename to Detectors/TPC/baserecsim/src/CDBInterface.cxx
index 06f6a360670dc..2aaf9c58cbe2c 100644
--- a/Detectors/TPC/base/src/CDBInterface.cxx
+++ b/Detectors/TPC/baserecsim/src/CDBInterface.cxx
@@ -28,7 +28,7 @@
 
 // o2 includes
 #include "DataFormatsTPC/CalibdEdxCorrection.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/ParameterDetector.h"
 #include "TPCBase/ParameterElectronics.h"
 #include "TPCBase/ParameterGEM.h"
diff --git a/Detectors/TPC/base/src/DeadChannelMapCreator.cxx b/Detectors/TPC/baserecsim/src/DeadChannelMapCreator.cxx
similarity index 98%
rename from Detectors/TPC/base/src/DeadChannelMapCreator.cxx
rename to Detectors/TPC/baserecsim/src/DeadChannelMapCreator.cxx
index 8c4e754fc5327..2d41e277b8583 100644
--- a/Detectors/TPC/base/src/DeadChannelMapCreator.cxx
+++ b/Detectors/TPC/baserecsim/src/DeadChannelMapCreator.cxx
@@ -14,8 +14,8 @@
 #include <type_traits>
 #include "CommonUtils/NameConf.h"
 #include "Framework/Logger.h"
-#include "TPCBase/DeadChannelMapCreator.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/DeadChannelMapCreator.h"
+#include "TPCBaseRecSim/Painter.h"
 
 using namespace o2::tpc;
 
diff --git a/Detectors/TPC/base/src/Painter.cxx b/Detectors/TPC/baserecsim/src/Painter.cxx
similarity index 99%
rename from Detectors/TPC/base/src/Painter.cxx
rename to Detectors/TPC/baserecsim/src/Painter.cxx
index ffbc149225212..a571b50607dd2 100644
--- a/Detectors/TPC/base/src/Painter.cxx
+++ b/Detectors/TPC/baserecsim/src/Painter.cxx
@@ -41,7 +41,8 @@
 #include "TPCBase/Mapper.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/CalArray.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
+#include "TPCBaseRecSim/PadFlags.h"
 #include "TPCBase/Utils.h"
 #include "DataFormatsTPC/LaserTrack.h"
 
diff --git a/Detectors/TPC/baserecsim/src/TPCBaseRecSimLinkDef.h b/Detectors/TPC/baserecsim/src/TPCBaseRecSimLinkDef.h
new file mode 100644
index 0000000000000..37822e3c02669
--- /dev/null
+++ b/Detectors/TPC/baserecsim/src/TPCBaseRecSimLinkDef.h
@@ -0,0 +1,27 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ enum o2::tpc::PadFlags + ; // enum itself
+#pragma link C++ class std::vector < o2::tpc::PadFlags> + ;
+#pragma link C++ enum o2::tpc::CDBType;
+#pragma link C++ class o2::tpc::CDBInterface;
+#pragma link C++ class o2::tpc::CDBStorage;
+#pragma link C++ class o2::tpc::CalArray < o2::tpc::PadFlags> + ;
+#pragma link C++ class o2::tpc::CalDet < o2::tpc::PadFlags> + ;
+#pragma link C++ class o2::tpc::painter + ;
+#pragma link C++ class o2::tpc::DeadChannelMapCreator + ;
+#endif
diff --git a/Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx b/Detectors/TPC/baserecsim/src/TPCFlagsMemberCustomStreamer.cxx
similarity index 100%
rename from Detectors/TPC/base/src/TPCFlagsMemberCustomStreamer.cxx
rename to Detectors/TPC/baserecsim/src/TPCFlagsMemberCustomStreamer.cxx
diff --git a/Detectors/TPC/base/test/testTPCCalDet.cxx b/Detectors/TPC/baserecsim/test/testTPCCalDet.cxx
similarity index 99%
rename from Detectors/TPC/base/test/testTPCCalDet.cxx
rename to Detectors/TPC/baserecsim/test/testTPCCalDet.cxx
index fda38c2d03e91..bf4cfddb780f0 100644
--- a/Detectors/TPC/base/test/testTPCCalDet.cxx
+++ b/Detectors/TPC/baserecsim/test/testTPCCalDet.cxx
@@ -24,7 +24,7 @@
 #include "TPCBase/CalDet.h"
 #include "TFile.h"
 #include "Framework/TypeTraits.h"
-#include "TPCBase/DeadChannelMapCreator.h"
+#include "TPCBaseRecSim/DeadChannelMapCreator.h"
 
 namespace o2::tpc
 {
diff --git a/Detectors/TPC/calibration/CMakeLists.txt b/Detectors/TPC/calibration/CMakeLists.txt
index e5cc25230d2fc..27f7f0200bb92 100644
--- a/Detectors/TPC/calibration/CMakeLists.txt
+++ b/Detectors/TPC/calibration/CMakeLists.txt
@@ -58,7 +58,7 @@ o2_add_library(TPCCalibration
                        src/DigitAdd.cxx
                        src/CorrectdEdxDistortions.cxx
                        src/PressureTemperatureHelper.cxx
-               PUBLIC_LINK_LIBRARIES O2::DataFormatsTPC O2::TPCBase
+               PUBLIC_LINK_LIBRARIES O2::DataFormatsTPC O2::TPCBaseRecSim
                                      O2::TPCReconstruction ROOT::Minuit
                                      Microsoft.GSL::GSL
                                      O2::DetectorsCalibration
@@ -118,16 +118,16 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/PressureTemperatureHelper.h)
 
 o2_add_test_root_macro(macro/comparePedestalsAndNoise.C
-                       PUBLIC_LINK_LIBRARIES O2::TPCBase
+                       PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
                        LABELS tpc)
 o2_add_test_root_macro(macro/drawNoiseAndPedestal.C
-                       PUBLIC_LINK_LIBRARIES O2::TPCBase
+                       PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
                        LABELS tpc)
 o2_add_test_root_macro(macro/drawPulser.C
-                       PUBLIC_LINK_LIBRARIES O2::TPCBase
+                       PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
                        LABELS tpc)
 o2_add_test_root_macro(macro/mergeNoiseAndPedestal.C
-                       PUBLIC_LINK_LIBRARIES O2::TPCBase
+                       PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
                        LABELS tpc)
 o2_add_test_root_macro(macro/runPedestal.C
                        PUBLIC_LINK_LIBRARIES O2::TPCCalibration
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/IDCCCDBHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/IDCCCDBHelper.h
index 1b8ba21774f57..744201205de76 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/IDCCCDBHelper.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/IDCCCDBHelper.h
@@ -17,6 +17,7 @@
 #define ALICEO2_TPC_IDCCCDBHELPER_H_
 #include <Framework/Logger.h>
 #include "DataFormatsTPC/Defs.h"
+#include "TPCBaseRecSim/PadFlags.h"
 #include "TPCBase/Sector.h"
 #include "Rtypes.h"
 
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/IDCFactorization.h b/Detectors/TPC/calibration/include/TPCCalibration/IDCFactorization.h
index 1fe6486722d95..510b6c44d613b 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/IDCFactorization.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/IDCFactorization.h
@@ -24,6 +24,7 @@
 #include "TPCCalibration/IDCContainer.h"
 #include "TPCCalibration/IDCGroupHelperSector.h"
 #include "DataFormatsTPC/Defs.h"
+#include "TPCBaseRecSim/PadFlags.h"
 #include <boost/property_tree/ptree.hpp>
 
 namespace o2::tpc
diff --git a/Detectors/TPC/calibration/macro/comparePedestalsAndNoise.C b/Detectors/TPC/calibration/macro/comparePedestalsAndNoise.C
index 5f998453d9515..04ba2fdeafc27 100644
--- a/Detectors/TPC/calibration/macro/comparePedestalsAndNoise.C
+++ b/Detectors/TPC/calibration/macro/comparePedestalsAndNoise.C
@@ -12,11 +12,11 @@
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 #include "TROOT.h"
 #include "TFile.h"
-#include "TPCBase/CalDet.h"
+#include "TPCBaseRecSim/CalDet.h"
 #include "TH1F.h"
 #include "TH2F.h"
 #include "TCanvas.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #endif
 
 std::tuple<TH1*, TH1*, TH1*, TH1*> getNoiseAndPedestalHistogram(const TString pedestalFile, int roc)
diff --git a/Detectors/TPC/calibration/macro/drawNoiseAndPedestal.C b/Detectors/TPC/calibration/macro/drawNoiseAndPedestal.C
index b4894ecf60eb9..45677ac7404ec 100644
--- a/Detectors/TPC/calibration/macro/drawNoiseAndPedestal.C
+++ b/Detectors/TPC/calibration/macro/drawNoiseAndPedestal.C
@@ -19,9 +19,9 @@
 #include "TH2.h"
 #include "TFile.h"
 #include "TPCBase/CalDet.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TPCBase/Utils.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPad.h"
 #include "TCanvas.h"
 #include "TH1F.h"
diff --git a/Detectors/TPC/calibration/macro/drawPulser.C b/Detectors/TPC/calibration/macro/drawPulser.C
index 97d14cfd95a58..3be3a958b0025 100644
--- a/Detectors/TPC/calibration/macro/drawPulser.C
+++ b/Detectors/TPC/calibration/macro/drawPulser.C
@@ -16,7 +16,7 @@
 #include "TH2.h"
 #include "TFile.h"
 #include "TPCBase/CalDet.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TPCBase/Utils.h"
 #include "TPCBase/Mapper.h"
 #include "TPad.h"
diff --git a/Detectors/TPC/calibration/macro/prepareCMFiles.C b/Detectors/TPC/calibration/macro/prepareCMFiles.C
index 08880ccbe4862..3bf18a9d14f8f 100644
--- a/Detectors/TPC/calibration/macro/prepareCMFiles.C
+++ b/Detectors/TPC/calibration/macro/prepareCMFiles.C
@@ -18,7 +18,7 @@
 #include "TFile.h"
 
 #include "Framework/Logger.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/Mapper.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/Utils.h"
diff --git a/Detectors/TPC/calibration/macro/prepareITFiles.C b/Detectors/TPC/calibration/macro/prepareITFiles.C
index eac0355e0ddfd..215ddb7909c8d 100644
--- a/Detectors/TPC/calibration/macro/prepareITFiles.C
+++ b/Detectors/TPC/calibration/macro/prepareITFiles.C
@@ -21,7 +21,7 @@
 #include "TFile.h"
 
 #include "Framework/Logger.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/Mapper.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/Utils.h"
diff --git a/Detectors/TPC/calibration/macro/preparePedestalFiles.C b/Detectors/TPC/calibration/macro/preparePedestalFiles.C
index 92bc1456e48d7..894827fffab1e 100644
--- a/Detectors/TPC/calibration/macro/preparePedestalFiles.C
+++ b/Detectors/TPC/calibration/macro/preparePedestalFiles.C
@@ -18,7 +18,7 @@
 #include "TFile.h"
 #include "TROOT.h"
 
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/Mapper.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/Utils.h"
diff --git a/Detectors/TPC/calibration/src/CalculatedEdx.cxx b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
index 11f83f1c7189e..478acda1189c2 100644
--- a/Detectors/TPC/calibration/src/CalculatedEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
@@ -21,7 +21,7 @@
 #include "DataFormatsTPC/ClusterNative.h"
 #include "DetectorsBase/Propagator.h"
 #include "CCDB/BasicCCDBManager.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "CalibdEdxTrackTopologyPol.h"
 #include "DataFormatsParameters/GRPMagField.h"
diff --git a/Detectors/TPC/calibration/src/CalibPadGainTracksBase.cxx b/Detectors/TPC/calibration/src/CalibPadGainTracksBase.cxx
index 2d8c34810324b..8a2ad1df19200 100644
--- a/Detectors/TPC/calibration/src/CalibPadGainTracksBase.cxx
+++ b/Detectors/TPC/calibration/src/CalibPadGainTracksBase.cxx
@@ -15,7 +15,7 @@
 #include "TPCCalibration/CalibPadGainTracksBase.h"
 #include "TPCCalibration/IDCDrawHelper.h"
 #include "TPCBase/ROC.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TPCCalibration/CalibTreeDump.h"
 #include "TPCBase/Mapper.h"
 
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index e9d7474699ce2..038fe3c34e140 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -12,7 +12,7 @@
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCCalibration/CorrMapParam.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "Framework/Logger.h"
 #include "Framework/ProcessingContext.h"
 #include "Framework/CCDBParamSpec.h"
diff --git a/Detectors/TPC/calibration/src/IDCAverageGroup.cxx b/Detectors/TPC/calibration/src/IDCAverageGroup.cxx
index f027a0a7d0056..63ab4d9e537ac 100644
--- a/Detectors/TPC/calibration/src/IDCAverageGroup.cxx
+++ b/Detectors/TPC/calibration/src/IDCAverageGroup.cxx
@@ -15,12 +15,13 @@
 #include "TPCCalibration/IDCDrawHelper.h"
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "TPCBase/Mapper.h"
+#include "TPCBaseRecSim/PadFlags.h"
 #include "CommonConstants/MathConstants.h"
 
 // root includes
 #include "TFile.h"
 #include "TKey.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TH2Poly.h"
 #include "TCanvas.h"
 #include "TLatex.h"
diff --git a/Detectors/TPC/calibration/src/IDCCCDBHelper.cxx b/Detectors/TPC/calibration/src/IDCCCDBHelper.cxx
index a9fb8f0c4675f..189d1035fc767 100644
--- a/Detectors/TPC/calibration/src/IDCCCDBHelper.cxx
+++ b/Detectors/TPC/calibration/src/IDCCCDBHelper.cxx
@@ -18,7 +18,7 @@
 #include "TPCBase/CalDet.h"
 #include "TPCBase/Mapper.h"
 #include "CommonUtils/TreeStreamRedirector.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 
 #include "TStyle.h"
 #include "TLine.h"
diff --git a/Detectors/TPC/calibration/src/IDCDrawHelper.cxx b/Detectors/TPC/calibration/src/IDCDrawHelper.cxx
index 3a0b11b4a3beb..a5181cc36706d 100644
--- a/Detectors/TPC/calibration/src/IDCDrawHelper.cxx
+++ b/Detectors/TPC/calibration/src/IDCDrawHelper.cxx
@@ -10,7 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "TPCCalibration/IDCDrawHelper.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TPCBase/Mapper.h"
 #include "TH2Poly.h"
 #include "TCanvas.h"
diff --git a/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx b/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
index 2de4ee2086426..4f22ef8e35a03 100644
--- a/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
+++ b/Detectors/TPC/calibration/src/PressureTemperatureHelper.cxx
@@ -14,7 +14,7 @@
 /// \author Matthias Kleiner <mkleiner@ikf.uni-frankfurt.de>
 
 #include "TPCCalibration/PressureTemperatureHelper.h"
-#include "TPCBase/CDBTypes.h"
+#include "TPCBaseRecSim/CDBTypes.h"
 #include "Framework/ProcessingContext.h"
 #include "DataFormatsTPC/DCS.h"
 #include "Framework/InputRecord.h"
diff --git a/Detectors/TPC/calibration/src/SACDrawHelper.cxx b/Detectors/TPC/calibration/src/SACDrawHelper.cxx
index 9779681b464b7..db5a1efee209e 100644
--- a/Detectors/TPC/calibration/src/SACDrawHelper.cxx
+++ b/Detectors/TPC/calibration/src/SACDrawHelper.cxx
@@ -10,7 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "TPCCalibration/SACDrawHelper.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TH2Poly.h"
 #include "TCanvas.h"
 #include "TLatex.h"
diff --git a/Detectors/TPC/calibration/src/VDriftHelper.cxx b/Detectors/TPC/calibration/src/VDriftHelper.cxx
index 71c4e50a63fcf..dc8f46af06828 100644
--- a/Detectors/TPC/calibration/src/VDriftHelper.cxx
+++ b/Detectors/TPC/calibration/src/VDriftHelper.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCCalibration/VDriftHelper.h"
 #include "DataFormatsTPC/LtrCalibData.h"
 #include "TPCBase/ParameterGas.h"
diff --git a/Detectors/TPC/dcs/src/DCSConfigSpec.cxx b/Detectors/TPC/dcs/src/DCSConfigSpec.cxx
index dc13d4ed83081..05ac93ea5e216 100644
--- a/Detectors/TPC/dcs/src/DCSConfigSpec.cxx
+++ b/Detectors/TPC/dcs/src/DCSConfigSpec.cxx
@@ -38,7 +38,7 @@
 #include "CCDB/CcdbApi.h"
 #include "CommonUtils/NameConf.h"
 
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/CRUCalibHelpers.h"
 #include "TPCBase/FEEConfig.h"
 #include "TPCBase/FECInfo.h"
diff --git a/Detectors/TPC/dcs/src/DCSSpec.cxx b/Detectors/TPC/dcs/src/DCSSpec.cxx
index 1b64ff7a75ba4..ea4e3a29ff630 100644
--- a/Detectors/TPC/dcs/src/DCSSpec.cxx
+++ b/Detectors/TPC/dcs/src/DCSSpec.cxx
@@ -30,7 +30,7 @@
 #include "DetectorsDCS/DeliveryType.h"
 #include "DetectorsDCS/AliasExpander.h"
 
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCdcs/DCSProcessor.h"
 #include "TPCdcs/DCSSpec.h"
 
diff --git a/Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx b/Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx
index 8784f096e3202..5509aa7473fc8 100644
--- a/Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx
+++ b/Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx
@@ -45,7 +45,7 @@
 #include "TPCBase/Mapper.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/CalArray.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "DataFormatsTPC/Constants.h"
 
 #include "TPCMonitor/SimpleEventDisplayGUI.h"
diff --git a/Detectors/TPC/qc/macro/runClusters.C b/Detectors/TPC/qc/macro/runClusters.C
index ea1d1b54f429e..2fd4c919be321 100644
--- a/Detectors/TPC/qc/macro/runClusters.C
+++ b/Detectors/TPC/qc/macro/runClusters.C
@@ -18,7 +18,7 @@
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "DataFormatsTPC/Constants.h"
 #include "TPCQC/Clusters.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #endif
 
 using namespace o2::tpc;
diff --git a/Detectors/TPC/qc/macro/runPID.C b/Detectors/TPC/qc/macro/runPID.C
index b015ac088334b..c693189a95652 100644
--- a/Detectors/TPC/qc/macro/runPID.C
+++ b/Detectors/TPC/qc/macro/runPID.C
@@ -25,7 +25,7 @@
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTPC/TrackCuts.h"
 #include "TPCBase/CalDet.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TPCBase/Utils.h"
 #include "DataFormatsTPC/ClusterNative.h"
 #include "TPCQC/PID.h"
diff --git a/Detectors/TPC/qc/src/Clusters.cxx b/Detectors/TPC/qc/src/Clusters.cxx
index 4bf59ced195ed..dc728a10a6570 100644
--- a/Detectors/TPC/qc/src/Clusters.cxx
+++ b/Detectors/TPC/qc/src/Clusters.cxx
@@ -18,7 +18,7 @@
 
 // o2 includes
 #include "TPCQC/Clusters.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TPCBase/ROC.h"
 #include "TPCBase/CRU.h"
 #include "TPCBase/Mapper.h"
diff --git a/Detectors/TPC/qc/src/IDCsVsSACs.cxx b/Detectors/TPC/qc/src/IDCsVsSACs.cxx
index 55e93f580d8a4..604a1030c3d67 100644
--- a/Detectors/TPC/qc/src/IDCsVsSACs.cxx
+++ b/Detectors/TPC/qc/src/IDCsVsSACs.cxx
@@ -25,7 +25,7 @@
 #include "TPCCalibration/SACFactorization.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/Mapper.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 
 TCanvas* o2::tpc::qc::IDCsVsSACs::drawComparisionSACandIDCZero(TCanvas* outputCanvas, int nbins1D, float xMin1D, float xMax1D, int nbins1DSAC, float xMin1DSAC, float xMax1DSAC) const
 {
diff --git a/Detectors/TPC/simulation/macro/toyCluster.C b/Detectors/TPC/simulation/macro/toyCluster.C
index d60e5a7c0f94e..7baeef1cb1a6b 100644
--- a/Detectors/TPC/simulation/macro/toyCluster.C
+++ b/Detectors/TPC/simulation/macro/toyCluster.C
@@ -44,7 +44,7 @@
 #include "TPCBase/Mapper.h"
 #include "TPCBase/ParameterDetector.h"
 #include "TPCBase/ParameterElectronics.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCSimulation/ElectronTransport.h"
 #include "TPCSimulation/SAMPAProcessing.h"
 #include "TPCSimulation/Point.h"
diff --git a/Detectors/TPC/simulation/src/DigitContainer.cxx b/Detectors/TPC/simulation/src/DigitContainer.cxx
index c2e7226706eb2..dfff4b91d6451 100644
--- a/Detectors/TPC/simulation/src/DigitContainer.cxx
+++ b/Detectors/TPC/simulation/src/DigitContainer.cxx
@@ -17,7 +17,7 @@
 #include <memory>
 #include <fairlogger/Logger.h>
 #include "TPCBase/Mapper.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/ParameterElectronics.h"
 #include "TPCBase/IonTailSettings.h"
 #include "SimConfig/DigiParams.h"
diff --git a/Detectors/TPC/simulation/src/Digitizer.cxx b/Detectors/TPC/simulation/src/Digitizer.cxx
index cb865d9f7f752..49abc0a0b99af 100644
--- a/Detectors/TPC/simulation/src/Digitizer.cxx
+++ b/Detectors/TPC/simulation/src/Digitizer.cxx
@@ -24,7 +24,7 @@
 #include "TPCSimulation/GEMAmplification.h"
 #include "TPCSimulation/Point.h"
 #include "TPCSimulation/SAMPAProcessing.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCSpaceCharge/SpaceCharge.h"
 #include "TPCBase/Mapper.h"
 #include "TPCCalibration/CorrMapParam.h"
diff --git a/Detectors/TPC/simulation/src/ElectronTransport.cxx b/Detectors/TPC/simulation/src/ElectronTransport.cxx
index f6b6f906ce862..f9e36aa642158 100644
--- a/Detectors/TPC/simulation/src/ElectronTransport.cxx
+++ b/Detectors/TPC/simulation/src/ElectronTransport.cxx
@@ -14,7 +14,7 @@
 /// \author Andi Mathis, TU München, andreas.mathis@ph.tum.de
 
 #include "TPCSimulation/ElectronTransport.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 
 #include <cmath>
 
diff --git a/Detectors/TPC/simulation/src/GEMAmplification.cxx b/Detectors/TPC/simulation/src/GEMAmplification.cxx
index 2dc363bf151b4..8d47464e9ef53 100644
--- a/Detectors/TPC/simulation/src/GEMAmplification.cxx
+++ b/Detectors/TPC/simulation/src/GEMAmplification.cxx
@@ -17,7 +17,7 @@
 #include <TStopwatch.h>
 #include "MathUtils/CachingTF1.h"
 #include <TFile.h>
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include <fstream>
 #include "Framework/Logger.h"
 #include <filesystem>
diff --git a/Detectors/TPC/simulation/src/IDCSim.cxx b/Detectors/TPC/simulation/src/IDCSim.cxx
index 45597393d8f2a..3958115d95f7c 100644
--- a/Detectors/TPC/simulation/src/IDCSim.cxx
+++ b/Detectors/TPC/simulation/src/IDCSim.cxx
@@ -16,7 +16,7 @@
 #include "TPCBase/Mapper.h"
 #include <fmt/format.h>
 #include "Framework/Logger.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "TH2Poly.h"
 #include "TCanvas.h"
 #include "TLatex.h"
diff --git a/Detectors/TPC/simulation/src/SAMPAProcessing.cxx b/Detectors/TPC/simulation/src/SAMPAProcessing.cxx
index 83f50832abfac..462008846fa04 100644
--- a/Detectors/TPC/simulation/src/SAMPAProcessing.cxx
+++ b/Detectors/TPC/simulation/src/SAMPAProcessing.cxx
@@ -14,7 +14,7 @@
 /// \author Andi Mathis, TU München, andreas.mathis@ph.tum.de
 
 #include "TPCSimulation/SAMPAProcessing.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 
 #include <fstream>
 #include <iostream>
diff --git a/Detectors/TPC/simulation/test/testTPCDigitContainer.cxx b/Detectors/TPC/simulation/test/testTPCDigitContainer.cxx
index 72e4dfaf6a0b2..73fca084507e5 100644
--- a/Detectors/TPC/simulation/test/testTPCDigitContainer.cxx
+++ b/Detectors/TPC/simulation/test/testTPCDigitContainer.cxx
@@ -23,7 +23,7 @@
 #include "DataFormatsTPC/Digit.h"
 #include "TPCSimulation/DigitContainer.h"
 #include "TPCSimulation/SAMPAProcessing.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 
 namespace o2
 {
diff --git a/Detectors/TPC/simulation/test/testTPCElectronTransport.cxx b/Detectors/TPC/simulation/test/testTPCElectronTransport.cxx
index 12732a52d7fa7..e42e60d5edabb 100644
--- a/Detectors/TPC/simulation/test/testTPCElectronTransport.cxx
+++ b/Detectors/TPC/simulation/test/testTPCElectronTransport.cxx
@@ -20,7 +20,7 @@
 #include "TPCSimulation/ElectronTransport.h"
 #include "TPCBase/ParameterGas.h"
 #include "TPCBase/ParameterDetector.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 
 #include "TH1D.h"
 #include "TF1.h"
diff --git a/Detectors/TPC/simulation/test/testTPCGEMAmplification.cxx b/Detectors/TPC/simulation/test/testTPCGEMAmplification.cxx
index 63c092deb59c2..8a3ce711b52ef 100644
--- a/Detectors/TPC/simulation/test/testTPCGEMAmplification.cxx
+++ b/Detectors/TPC/simulation/test/testTPCGEMAmplification.cxx
@@ -20,7 +20,7 @@
 #include "TPCSimulation/GEMAmplification.h"
 #include "TPCBase/ParameterGas.h"
 #include "TPCBase/ParameterGEM.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 
 #include "TH1D.h"
 #include "TF1.h"
diff --git a/Detectors/TPC/simulation/test/testTPCSAMPAProcessing.cxx b/Detectors/TPC/simulation/test/testTPCSAMPAProcessing.cxx
index a89ea335d60b5..05ed4393ea65c 100644
--- a/Detectors/TPC/simulation/test/testTPCSAMPAProcessing.cxx
+++ b/Detectors/TPC/simulation/test/testTPCSAMPAProcessing.cxx
@@ -18,7 +18,7 @@
 #define BOOST_TEST_DYN_LINK
 #include <boost/test/unit_test.hpp>
 #include "TPCSimulation/SAMPAProcessing.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 
 #include <fstream>
 #include <iostream>
diff --git a/Detectors/TPC/spacecharge/CMakeLists.txt b/Detectors/TPC/spacecharge/CMakeLists.txt
index a2f4cdb51becb..390e6c99c9c7e 100644
--- a/Detectors/TPC/spacecharge/CMakeLists.txt
+++ b/Detectors/TPC/spacecharge/CMakeLists.txt
@@ -15,7 +15,7 @@ o2_add_library(TPCSpaceCharge
                        src/PoissonSolver.cxx
                        src/TriCubic.cxx
                        src/DataContainer3D.cxx
-               PUBLIC_LINK_LIBRARIES O2::TPCBase
+               PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
                                      O2::Field
                                      Vc::Vc
                                      ROOT::Core
diff --git a/Detectors/TPC/spacecharge/macro/createSCHistosFromHits.C b/Detectors/TPC/spacecharge/macro/createSCHistosFromHits.C
index f6232018f3c59..cf4e5b2719b22 100644
--- a/Detectors/TPC/spacecharge/macro/createSCHistosFromHits.C
+++ b/Detectors/TPC/spacecharge/macro/createSCHistosFromHits.C
@@ -112,7 +112,7 @@ g++ -o createSCHistosFromHits createSCHistosFromHits.C -I ~/alice/sw/osx_x86-64/
 #include "TPCBase/ParameterDetector.h"
 #include "TPCBase/ParameterGEM.h"
 #include "TPCBase/ParameterElectronics.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCSimulation/ElectronTransport.h"
 #include "TPCSimulation/GEMAmplification.h"
 #include "TPCSimulation/SAMPAProcessing.h"
diff --git a/Detectors/TPC/spacecharge/src/SpaceCharge.cxx b/Detectors/TPC/spacecharge/src/SpaceCharge.cxx
index 07101bac15c23..9b6a572b46406 100644
--- a/Detectors/TPC/spacecharge/src/SpaceCharge.cxx
+++ b/Detectors/TPC/spacecharge/src/SpaceCharge.cxx
@@ -25,7 +25,7 @@
 #include "Field/MagneticField.h"
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "TPCBase/CalDet.h"
-#include "TPCBase/Painter.h"
+#include "TPCBaseRecSim/Painter.h"
 #include "MathUtils/Utils.h"
 #include "DataFormatsParameters/GRPMagField.h"
 #include "GPUDebugStreamer.h"
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/CalibratorPadGainTracksSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/CalibratorPadGainTracksSpec.h
index f9d5501196eb7..3ccef73a4a8fc 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/CalibratorPadGainTracksSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/CalibratorPadGainTracksSpec.h
@@ -22,7 +22,7 @@
 #include "CommonUtils/NameConf.h"
 #include "Framework/Task.h"
 #include "Framework/ConfigParamRegistry.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "DetectorsCalibration/Utils.h"
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
index 2491e5f71a889..516ea128acfe7 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
@@ -25,7 +25,7 @@
 #include "DataFormatsParameters/GRPObject.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "Framework/CCDBParamSpec.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCCalibration/VDriftHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "DetectorsBase/GRPGeomHelper.h"
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadRawSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadRawSpec.h
index 19cbeb05f7007..7579e334ff267 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadRawSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadRawSpec.h
@@ -34,7 +34,7 @@
 
 #include "DetectorsBase/TFIDInfoHelper.h"
 #include "DataFormatsTPC/TPCSectorHeader.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCCalibration/CalibPedestal.h"
 #include "TPCCalibration/CalibPulser.h"
 #include "TPCReconstruction/RawReaderCRU.h"
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
index ec3e158590661..e4b85ad7c04d9 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPIDCSpec.h
@@ -31,7 +31,7 @@
 #include "TPCCalibration/IDCFactorization.h"
 #include "Framework/CCDBParamSpec.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 
 using namespace o2::framework;
 using o2::header::gDataOriginTPC;
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h
index 667386e6481ca..c8384cf9c9264 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeIDCSpec.h
@@ -35,7 +35,7 @@
 #include "TPCBase/CRU.h"
 #include "CommonUtils/NameConf.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "DetectorsCalibration/Utils.h"
 #include "TPCCalibration/IDCCCDBHelper.h"
 
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeSACSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeSACSpec.h
index f191f5f44761b..1757f3e223e86 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeSACSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFactorizeSACSpec.h
@@ -29,7 +29,7 @@
 #include "CCDB/CcdbApi.h"
 #include "TPCWorkflow/TPCDistributeSACSpec.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "DetectorsCalibration/Utils.h"
 #include "Framework/InputRecordWalker.h"
 
diff --git a/Detectors/TPC/workflow/src/CalDetMergerPublisherSpec.cxx b/Detectors/TPC/workflow/src/CalDetMergerPublisherSpec.cxx
index a504ffa606b84..bb3c927e3df4d 100644
--- a/Detectors/TPC/workflow/src/CalDetMergerPublisherSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalDetMergerPublisherSpec.cxx
@@ -36,7 +36,7 @@
 #include "DetectorsCalibration/Utils.h"
 #include "CCDB/CcdbApi.h"
 #include "CCDB/CcdbObjectInfo.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/CalDet.h"
 #include "TPCBase/CRUCalibHelpers.h"
 #include "TPCWorkflow/CalibRawPartInfo.h"
diff --git a/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx b/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
index e3943f92235ab..7c2e2db8188e8 100644
--- a/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
@@ -29,7 +29,7 @@
 #include "GPUO2ConfigurableParam.h"
 #include "TPCCalibration/CalibdEdx.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
-#include "TPCBase/CDBTypes.h"
+#include "TPCBaseRecSim/CDBTypes.h"
 #include "TPCBase/Utils.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 
diff --git a/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx b/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
index 82e6d5075d7f0..87e339f0643f4 100644
--- a/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
@@ -33,7 +33,7 @@
 #include "TPCCalibration/CalibratordEdx.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "DetectorsBase/GRPGeomHelper.h"
-#include "TPCBase/CDBTypes.h"
+#include "TPCBaseRecSim/CDBTypes.h"
 #include "TPCBase/Utils.h"
 
 using namespace o2::framework;
diff --git a/Detectors/TPC/workflow/src/SACProcessorSpec.cxx b/Detectors/TPC/workflow/src/SACProcessorSpec.cxx
index e69533a0bb6d3..1d09b9f0a4fbe 100644
--- a/Detectors/TPC/workflow/src/SACProcessorSpec.cxx
+++ b/Detectors/TPC/workflow/src/SACProcessorSpec.cxx
@@ -25,7 +25,7 @@
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "Framework/CCDBParamSpec.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 
 #include "DataFormatsTPC/RawDataTypes.h"
 #include "TPCBase/RDHUtils.h"
diff --git a/Detectors/TPC/workflow/src/TPCMergeIntegrateClusterSpec.cxx b/Detectors/TPC/workflow/src/TPCMergeIntegrateClusterSpec.cxx
index 01538aab5ad90..2fdf0d001f475 100644
--- a/Detectors/TPC/workflow/src/TPCMergeIntegrateClusterSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCMergeIntegrateClusterSpec.cxx
@@ -25,7 +25,7 @@
 #include "DetectorsCommonDataFormats/FileMetaData.h"
 #include "Framework/DataTakingContext.h"
 #include "TPCCalibration/IDCFactorization.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/CalDet.h"
 
 #include <numeric>
diff --git a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
index 6065079c05e96..f185b5e08c7e7 100644
--- a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
@@ -19,7 +19,7 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/CCDBParamSpec.h"
 #include "Framework/ConfigParamRegistry.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "TPCCalibration/TPCScaler.h"
 #include "TPCCalibration/TPCMShapeCorrection.h"
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 2d5a955a5e911..7b1db436dbf7e 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -61,11 +61,11 @@
 #include "display/GPUDisplayInterface.h"
 #include "TPCBase/Sector.h"
 #include "TPCBase/Utils.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCCalibration/VDriftHelper.h"
 #include "CorrectionMapsHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
-#include "TPCBase/DeadChannelMapCreator.h"
+#include "TPCBaseRecSim/DeadChannelMapCreator.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "Algorithm/Parser.h"
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index 13a3c4b6162b8..2b2f81246fc04 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -56,12 +56,12 @@
 #include "display/GPUDisplayInterface.h"
 #include "TPCBase/Sector.h"
 #include "TPCBase/Utils.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCCalibration/VDriftHelper.h"
 #include "CorrectionMapsHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCCalibration/IDCContainer.h"
-#include "TPCBase/DeadChannelMapCreator.h"
+#include "TPCBaseRecSim/DeadChannelMapCreator.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "Algorithm/Parser.h"
diff --git a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
index ea5c6ba272ec6..c45c746064101 100644
--- a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
+++ b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
@@ -32,7 +32,7 @@
 #include "TPCDigitizerSpec.h"
 #include "TPCSimWorkflow/TPCDigitRootWriterSpec.h"
 #include "TPCBase/Sector.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 // needed in order to init the **SHARED** polyadist file (to be done before the digitizers initialize)
 #include "TPCSimulation/GEMAmplification.h"
 
diff --git a/Steer/DigitizerWorkflow/src/TPCDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TPCDigitizerSpec.cxx
index 381e1ecdd3e91..68476c3a92a6d 100644
--- a/Steer/DigitizerWorkflow/src/TPCDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TPCDigitizerSpec.cxx
@@ -33,7 +33,7 @@
 #include "Framework/Task.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DataFormatsTPC/TPCSectorHeader.h"
-#include "TPCBase/CDBInterface.h"
+#include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCBase/ParameterGEM.h"
 #include "DataFormatsTPC/Digit.h"
 #include "TPCSimulation/Digitizer.h"

From c21d7d7a7ec080bbf31523f910935b266405a3e2 Mon Sep 17 00:00:00 2001
From: Francesco Noferini <noferini@bo.infn.it>
Date: Mon, 12 Jan 2026 17:47:47 +0100
Subject: [PATCH 1192/1764] add TOF channel in TPC timeseries (#14945)

---
 Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
index 5007019d52910..ee3acc808ccb7 100644
--- a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
@@ -210,14 +210,14 @@ class TPCTimeSeries : public Task
       indicesITSTPC[tracksITSTPC[i].getRefTPC().getIndex()] = {i, idxVtx};
     }
 
-    std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int>> idxTPCTrackToTOFCluster; // store for each tpc track index the index to the TOF cluster
+    std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int, unsigned short>> idxTPCTrackToTOFCluster; // store for each tpc track index the index to the TOF cluster
 
     // get matches to TOF in case skimmed data is produced
     if (mUnbinnedWriter) {
       //   getLTIntegralOut(), ///< L,TOF integral calculated during the propagation
       //  getSignal()  mSignal = 0.0;              ///< TOF time in ps
       o2::track::TrackLTIntegral defLT;
-      idxTPCTrackToTOFCluster = std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int>>(tracksTPC.size(), {-1, -999, -999, defLT, 0, 0, 0});
+      idxTPCTrackToTOFCluster = std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int, unsigned short>>(tracksTPC.size(), {-1, -999, -999, defLT, 0, 0, 0, 0});
       const std::vector<gsl::span<const o2::dataformats::MatchInfoTOF>> tofMatches{recoData.getTPCTOFMatches(), recoData.getTPCTRDTOFMatches(), recoData.getITSTPCTOFMatches(), recoData.getITSTPCTRDTOFMatches()};
 
       const auto& ft0rec = recoData.getFT0RecPoints();
@@ -289,7 +289,7 @@ class TPCTimeSeries : public Task
               mask |= o2::dataformats::MatchInfoTOF::QualityFlags::hasT0_1BCbefore;
             }
 
-            idxTPCTrackToTOFCluster[refTPC] = {tpctofmatch.getIdxTOFCl(), tpctofmatch.getDXatTOF(), tpctofmatch.getDZatTOF(), ltIntegral, signal, deltaT, mask};
+            idxTPCTrackToTOFCluster[refTPC] = {tpctofmatch.getIdxTOFCl(), tpctofmatch.getDXatTOF(), tpctofmatch.getDZatTOF(), ltIntegral, signal, deltaT, mask, tpctofmatch.getChannel() % 8736};
           }
         }
       }
@@ -1122,7 +1122,7 @@ class TPCTimeSeries : public Task
     return isGoodTrack;
   }
 
-  void fillDCA(const gsl::span<const TrackTPC> tracksTPC, const gsl::span<const o2::dataformats::TrackTPCITS> tracksITSTPC, const gsl::span<const o2::dataformats::PrimaryVertex> vertices, const int iTrk, const int iThread, const std::unordered_map<unsigned int, std::array<int, 2>>& indicesITSTPC, const gsl::span<const o2::its::TrackITS> tracksITS, const std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int>>& idxTPCTrackToTOFCluster, const gsl::span<const o2::tof::Cluster> tofClusters)
+  void fillDCA(const gsl::span<const TrackTPC> tracksTPC, const gsl::span<const o2::dataformats::TrackTPCITS> tracksITSTPC, const gsl::span<const o2::dataformats::PrimaryVertex> vertices, const int iTrk, const int iThread, const std::unordered_map<unsigned int, std::array<int, 2>>& indicesITSTPC, const gsl::span<const o2::its::TrackITS> tracksITS, const std::vector<std::tuple<int, float, float, o2::track::TrackLTIntegral, double, float, unsigned int, unsigned short>>& idxTPCTrackToTOFCluster, const gsl::span<const o2::tof::Cluster> tofClusters)
   {
     const auto& trackFull = tracksTPC[iTrk];
     const bool isGoodTrack = checkTrack(trackFull);
@@ -1512,6 +1512,7 @@ class TPCTimeSeries : public Task
                             << "vertexTime=" << vertexTime                                    /// time stamp assigned to the vertex
                             << "trackTime0=" << trackTime0                                    /// time stamp assigned to the track
                             << "TOFmask=" << std::get<6>(idxTPCTrackToTOFCluster[iTrk])       /// delta T- TPC TOF
+                            << "TOFchannel=" << std::get<7>(idxTPCTrackToTOFCluster[iTrk])    /// TOF channel inside a sector
                             // TPC delta param
                             << "deltaTPCParamInOutTgl=" << deltaTPCParamInOutTgl
                             << "deltaTPCParamInOutQPt=" << deltaTPCParamInOutQPt

From ddcdd1f32cf09b7d153a90183eca358a1549eb0f Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 16 Dec 2025 11:34:09 +0100
Subject: [PATCH 1193/1764] reduce verbosity of ITS/MFT digitizer

---
 Detectors/ITSMFT/common/simulation/src/Digitizer.cxx | 10 +++++-----
 .../Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx | 12 ++++++------
 Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx |  8 ++++----
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx b/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
index 53e0a2fcb096f..4a8af0cbe9737 100644
--- a/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
+++ b/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
@@ -108,10 +108,10 @@ void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
 {
   // digitize single event, the time must have been set beforehand
 
-  LOG(info) << "Digitizing " << mGeometry->getName() << " hits of entry " << evID << " from source "
-            << srcID << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
-            << " cont.mode: " << isContinuous()
-            << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
+  LOG(debug) << "Digitizing " << mGeometry->getName() << " hits of entry " << evID << " from source "
+             << srcID << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
+             << " cont.mode: " << isContinuous()
+             << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
 
   // is there something to flush ?
   if (mNewROFrame > mROFrameMin) {
@@ -164,7 +164,7 @@ void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
       mNewROFrame = nbc / mParams.getROFrameLengthInBC();
       mIsBeforeFirstRO = false;
     }
-    LOG(info) << " NewROFrame " << mNewROFrame << " nbc " << nbc;
+    LOG(debug) << " NewROFrame " << mNewROFrame << " nbc " << nbc;
 
     // in continuous mode depends on starts of periodic readout frame
     mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC()) * o2::constants::lhc::LHCBunchSpacingNS;
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 3ee952801f0c3..7c988faebf2df 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -103,11 +103,11 @@ void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
 {
   // digitize single event, the time must have been set beforehand
 
-  LOG(info) << " Digitizing " << mGeometry->getName() << " (ID: " << mGeometry->getDetID()
-            << ") hits of entry " << evID << " from source " << srcID
-            << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
-            << " cont.mode: " << isContinuous()
-            << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
+  LOG(debug) << " Digitizing " << mGeometry->getName() << " (ID: " << mGeometry->getDetID()
+             << ") hits of entry " << evID << " from source " << srcID
+             << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
+             << " cont.mode: " << isContinuous()
+             << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
 
   std::cout << "Printing segmentation info: " << std::endl;
   SegmentationChip::Print();
@@ -159,7 +159,7 @@ void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
 
     mNewROFrame = nbc / mParams.getROFrameLengthInBC();
 
-    LOG(info) << " NewROFrame " << mNewROFrame << " = " << nbc << "/" << mParams.getROFrameLengthInBC() << " (nbc/mParams.getROFrameLengthInBC()";
+    LOG(debug) << " NewROFrame " << mNewROFrame << " = " << nbc << "/" << mParams.getROFrameLengthInBC() << " (nbc/mParams.getROFrameLengthInBC()";
 
     // in continuous mode depends on starts of periodic readout frame
     mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC()) * o2::constants::lhc::LHCBunchSpacingNS;
diff --git a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
index 4560a656c1762..4b0374d925401 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/Digitizer.cxx
@@ -76,10 +76,10 @@ void Digitizer::process(const std::vector<itsmft::Hit>* hits, int evID, int srcI
 {
   // digitize single event, the time must have been set beforehand
 
-  LOG(info) << "Digitizing " << mGeometry->getName() << " hits of entry " << evID << " from source "
-            << srcID << " at time " << mEventTime << " ROFrame = " << mNewROFrame << ")"
-            << " cont.mode: " << isContinuous()
-            << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
+  LOG(debug) << "Digitizing " << mGeometry->getName() << " hits of entry " << evID << " from source "
+             << srcID << " at time " << mEventTime << " ROFrame = " << mNewROFrame << ")"
+             << " cont.mode: " << isContinuous()
+             << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
 
   // is there something to flush ?
   if (mNewROFrame > mROFrameMin) {

From 1dc98c8718409275e68056f2d3fd21664804fffa Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Thu, 9 Jan 2025 15:27:48 +0100
Subject: [PATCH 1194/1764] TPC space-charge: Improve GEM frame charging-up
 distortions

Adding:
- downsampling of space-charge objects
- simulation of n-sectors only
- some helper functions
- weighted filling of charging-up of GEM frames for smoother potential
- set global distortions from function
---
 .../include/TPCSpaceCharge/DataContainer3D.h  |   3 +
 .../TPCSpaceCharge/PoissonSolverHelpers.h     |   3 +-
 .../include/TPCSpaceCharge/SpaceCharge.h      |  58 +++--
 .../TPC/spacecharge/src/DataContainer3D.cxx   |  31 ++-
 .../TPC/spacecharge/src/PoissonSolver.cxx     |  26 +-
 Detectors/TPC/spacecharge/src/SpaceCharge.cxx | 231 +++++++++++++-----
 6 files changed, 259 insertions(+), 93 deletions(-)

diff --git a/Detectors/TPC/spacecharge/include/TPCSpaceCharge/DataContainer3D.h b/Detectors/TPC/spacecharge/include/TPCSpaceCharge/DataContainer3D.h
index 79400c3d3d214..73638c5b2982f 100644
--- a/Detectors/TPC/spacecharge/include/TPCSpaceCharge/DataContainer3D.h
+++ b/Detectors/TPC/spacecharge/include/TPCSpaceCharge/DataContainer3D.h
@@ -186,6 +186,9 @@ struct DataContainer3D {
   /// print the matrix
   void print() const;
 
+  /// convert a data container to a new datacontainer with different grid definition (e.g. different number of vertices)
+  DataContainer3D<DataT> convert(const o2::tpc::RegularGrid3D<DataT>& gridNew, const o2::tpc::RegularGrid3D<DataT>& gridRef, const int threads = 1) const;
+
   /// operator overload
   DataContainer3D<DataT>& operator*=(const DataT value);
   DataContainer3D<DataT>& operator+=(const DataContainer3D<DataT>& other);
diff --git a/Detectors/TPC/spacecharge/include/TPCSpaceCharge/PoissonSolverHelpers.h b/Detectors/TPC/spacecharge/include/TPCSpaceCharge/PoissonSolverHelpers.h
index 218bddcf49402..933273d0b5eb9 100644
--- a/Detectors/TPC/spacecharge/include/TPCSpaceCharge/PoissonSolverHelpers.h
+++ b/Detectors/TPC/spacecharge/include/TPCSpaceCharge/PoissonSolverHelpers.h
@@ -19,6 +19,7 @@
 #define ALICEO2_TPC_POISSONSOLVERHELPERS_H_
 
 #include "CommonConstants/MathConstants.h"
+#include "DataFormatsTPC/Defs.h"
 
 namespace o2
 {
@@ -55,7 +56,7 @@ struct MGParameters {                                             ///< Parameter
   inline static int nMGCycle = 200;                               ///< number of multi grid cycle (V type)
   inline static int maxLoop = 7;                                  ///< the number of tree-deep of multi grid
   inline static int gamma = 1;                                    ///< number of iteration at coarsest level !TODO SET TO REASONABLE VALUE!
-  inline static bool normalizeGridToOneSector = false;            ///< the grid in phi direction is squashed from 2 Pi to (2 Pi / SECTORSPERSIDE). This can used to get the potential for phi symmetric sc density or boundary potentials
+  inline static int normalizeGridToNSector = SECTORSPERSIDE;      ///< the grid in phi direction is squashed from 2 Pi to (2 Pi / SECTORSPERSIDE). This can used to get the potential for phi symmetric sc density or boundary potentials
 };
 
 template <typename DataT = double>
diff --git a/Detectors/TPC/spacecharge/include/TPCSpaceCharge/SpaceCharge.h b/Detectors/TPC/spacecharge/include/TPCSpaceCharge/SpaceCharge.h
index ad76ec2b6da5b..d0c66d0ff3df1 100644
--- a/Detectors/TPC/spacecharge/include/TPCSpaceCharge/SpaceCharge.h
+++ b/Detectors/TPC/spacecharge/include/TPCSpaceCharge/SpaceCharge.h
@@ -204,10 +204,13 @@ class SpaceCharge
 
   /// simulate only one sector instead of 18 per side. This makes currently only sense for the static distortions (ToDo: simplify usage)
   /// phi max will be restricted to 2Pi/18 for this instance and for global instance of poisson solver
-  void setSimOneSector();
+  void setSimOneSector() { setSimNSector(1); }
+
+  /// simulate N sectors
+  void setSimNSector(const int nSectors);
 
   /// unsetting simulation of one sector
-  static void unsetSimOneSector();
+  static void unsetSimNSector();
 
   /// setting default potential (same potential for all GEM frames. The default value of 1000V are matched to distortions observed in laser data without X-Ray etc.
   /// \param side side of the TPC where the potential will be set
@@ -308,10 +311,24 @@ class SpaceCharge
   /// scaling the space-charge density for given stack
   void scaleChargeDensityStack(const float scalingFactor, const Sector sector, const GEMstack stack);
 
+  /// scale the potential by a scaling factor
+  /// \param scalingFactor factor to scale the potential
+  /// \param side side for which the potential will be scaled
+  void scalePotential(const DataT scalingFactor, const Side side) { mPotential[side] *= scalingFactor; }
+
   /// add space charge density from other object (this.mDensity = this.mDensity + other.mDensity)
   /// \param otherSC other space-charge object, which charge will be added to current object
   void addChargeDensity(const SpaceCharge<DataT>& otherSC);
 
+  /// add global corrections from other space charge object
+  void addGlobalCorrections(const SpaceCharge<DataT>& otherSC, const Side side);
+
+  /// convert space-charge object to new definition of number of vertices
+  /// \param nZNew new number of vertices in z direction
+  /// \param nRNew new number of vertices in r direction
+  /// \param nPhiNew new number of vertices in phi direction
+  void downSampleObject(const int nZNew, const int nRNew, const int nPhiNew);
+
   /// step 3: calculate the local distortions and corrections with an electric field
   /// \param type calculate local corrections or local distortions: type = o2::tpc::SpaceCharge<>::Type::Distortions or o2::tpc::SpaceCharge<>::Type::Corrections
   /// \param formulaStruct struct containing a method to evaluate the electric field Er, Ez, Ephi (analytical formula or by TriCubic interpolator)
@@ -415,6 +432,9 @@ class SpaceCharge
   /// \param phi global phi coordinate
   DataT getDensityCyl(const DataT z, const DataT r, const DataT phi, const Side side) const;
 
+  /// get the potential for list of given coordinate
+  std::vector<float> getDensityCyl(const std::vector<DataT>& z, const std::vector<DataT>& r, const std::vector<DataT>& phi, const Side side) const;
+
   /// get the potential for given coordinate
   /// \param z global z coordinate
   /// \param r global r coordinate
@@ -1184,6 +1204,10 @@ class SpaceCharge
   /// \param gCorr function returning global corrections for given global coordinate
   void setGlobalCorrections(const std::function<void(int sector, DataT gx, DataT gy, DataT gz, DataT& gCx, DataT& gCy, DataT& gCz)>& gCorr, const Side side);
 
+  /// setting the global distortions directly from input function provided in global coordinates
+  /// \param gDist function returning global distortions for given global coordinate
+  void setGlobalDistortions(const std::function<void(int sector, DataT gx, DataT gy, DataT gz, DataT& gCx, DataT& gCy, DataT& gCz)>& gDist, const Side side);
+
   /// set misalignment of ROC for shift in z
   /// \param sector sector for which the misalignment in z will be applied (if sector=-1 all sectors are shifted)
   /// \param type 0=IROC, 1=OROC, 2=IROC+OROC
@@ -1229,7 +1253,16 @@ class SpaceCharge
   /// \param tgl tgl of the track
   /// \param nPoints number of points used to calculate the DCAr
   /// \param pcstream if provided debug output is being created
-  float getDCAr(float tgl, const int nPoints, const float phi, o2::utils::TreeStreamRedirector* pcstream = nullptr) const;
+  float getDCAr(float tgl, const int nPoints, const float phi, float rStart = -1, o2::utils::TreeStreamRedirector* pcstream = nullptr) const;
+
+  /// \return returns nearest phi vertex for given phi position
+  size_t getNearestPhiVertex(const DataT phi, const Side side) const { return std::round(phi / getGridSpacingPhi(side)); }
+
+  /// \return returns nearest r vertex for given radius position
+  size_t getNearestRVertex(const DataT r, const Side side) const { return std::round((r - getRMin(side)) / getGridSpacingR(side) + 0.5); }
+
+  /// \return returns number of bins in phi direction for the gap between sectors and for the GEM frame
+  size_t getPhiBinsGapFrame(const Side side) const;
 
  private:
   ParamSpaceCharge mParamGrid{};                                                                          ///< parameters of the grid on which the calculations are performed
@@ -1352,15 +1385,6 @@ class SpaceCharge
   /// dump the created electron tracks with calculateElectronDriftPath function to a tree
   void dumpElectronTracksToTree(const std::vector<std::pair<std::vector<o2::math_utils::Point3D<float>>, std::array<DataT, 3>>>& electronTracks, const int nSamplingPoints, const char* outFile) const;
 
-  /// \return returns nearest phi vertex for given phi position
-  size_t getNearestPhiVertex(const DataT phi, const Side side) const { return std::round(phi / getGridSpacingPhi(side)); }
-
-  /// \return returns nearest r vertex for given radius position
-  size_t getNearestRVertex(const DataT r, const Side side) const { return std::round((r - getRMin(side)) / getGridSpacingR(side) + 0.5); }
-
-  /// \return returns number of bins in phi direction for the gap between sectors and for the GEM frame
-  size_t getPhiBinsGapFrame(const Side side) const;
-
   /// \return setting the boundary potential for given GEM stack
   void setPotentialBoundaryGEMFrameAlongPhi(const std::function<DataT(DataT)>& potentialFunc, const GEMstack stack, const bool bottom, const Side side, const bool outerFrame = false);
 
@@ -1372,16 +1396,16 @@ class SpaceCharge
 
   void initAllBuffers();
 
-  void setBoundaryFromIndices(const std::function<DataT(DataT)>& potentialFunc, const std::vector<size_t>& indices, const Side side);
+  void setBoundaryFromIndices(const std::function<DataT(DataT)>& potentialFunc, const std::vector<std::pair<size_t, float>>& indices, const Side side);
 
   /// get indices of the GEM frame along r
-  std::vector<size_t> getPotentialBoundaryGEMFrameAlongRIndices(const Side side) const;
+  std::vector<std::pair<size_t, float>> getPotentialBoundaryGEMFrameAlongRIndices(const Side side) const;
 
   /// get indices of the GEM frame along phi
-  std::vector<size_t> getPotentialBoundaryGEMFrameAlongPhiIndices(const GEMstack stack, const bool bottom, const Side side, const bool outerFrame, const bool noGap = false) const;
+  std::vector<std::pair<size_t, float>> getPotentialBoundaryGEMFrameAlongPhiIndices(const GEMstack stack, const bool bottom, const Side side, const bool outerFrame, const bool noGap = false) const;
 
   void setROCMisalignment(int stackType, int misalignmentType, int sector, const float potMin, const float potMax);
-  void fillROCMisalignment(const std::vector<size_t>& indicesTop, const std::vector<size_t>& indicesBottom, int sector, int misalignmentType, const std::pair<float, float>& deltaPotPar);
+  void fillROCMisalignment(const std::vector<std::pair<size_t, float>>& indicesTop, const std::vector<std::pair<size_t, float>>& indicesBottom, int sector, int misalignmentType, const std::pair<float, float>& deltaPotPar);
 
   /// set potentialsdue to ROD misalignment
   void initRodAlignmentVoltages(const MisalignmentType misalignmentType, const FCType fcType, const int sector, const Side side, const float deltaPot);
@@ -1389,6 +1413,8 @@ class SpaceCharge
   void calcGlobalDistCorrIterative(const DistCorrInterpolator<DataT>& globCorr, const int maxIter, const DataT approachZ, const DataT approachR, const DataT approachPhi, const DataT diffCorr, const SpaceCharge<DataT>* scSCale, float scale, const Type type);
   void calcGlobalDistCorrIterativeLinearCartesian(const DistCorrInterpolator<DataT>& globCorr, const int maxIter, const DataT approachX, const DataT approachY, const DataT approachZ, const DataT diffCorr, const SpaceCharge<DataT>* scSCale, float scale, const Type type);
 
+  void setGlobalDistCorr(const Type type, const std::function<void(int sector, DataT gx, DataT gy, DataT gz, DataT& gCx, DataT& gCy, DataT& gCz)>& gFunc, const Side side);
+
   ClassDefNV(SpaceCharge, 6);
 };
 
diff --git a/Detectors/TPC/spacecharge/src/DataContainer3D.cxx b/Detectors/TPC/spacecharge/src/DataContainer3D.cxx
index cd2802b975fd2..60d7c28b8c74e 100644
--- a/Detectors/TPC/spacecharge/src/DataContainer3D.cxx
+++ b/Detectors/TPC/spacecharge/src/DataContainer3D.cxx
@@ -331,7 +331,6 @@ void DataContainer3D<DataT>::dumpSlice(std::string_view treename, std::string_vi
   ROOT::RDataFrame dFrame(treename, fileIn);
 
   auto df = dFrame.Define("slice", [rangeiZ, rangeiR, rangeiPhi](const std::pair<long, std::vector<float>>& values, unsigned short nz, unsigned short nr, unsigned short nphi) {
-    const bool simOneSectorOnly = MGParameters::normalizeGridToOneSector;
     std::vector<size_t> ir;
     std::vector<size_t> iphi;
     std::vector<size_t> iz;
@@ -370,12 +369,12 @@ void DataContainer3D<DataT>::dumpSlice(std::string_view treename, std::string_vi
 
       const float rTmp = o2::tpc::GridProperties<float>::getRMin() + o2::tpc::GridProperties<float>::getGridSpacingR(nr) * iRTmp;
       const float zTmp = o2::tpc::GridProperties<float>::getZMin() + o2::tpc::GridProperties<float>::getGridSpacingZ(nz) * iZTmp;
-      const float phiTmp = o2::tpc::GridProperties<float>::getPhiMin() + o2::tpc::GridProperties<float>::getGridSpacingPhi(nphi) / (simOneSectorOnly ? SECTORSPERSIDE : 1) * iPhiTmp;
+      const float phiTmp = o2::tpc::GridProperties<float>::getPhiMin() + o2::tpc::GridProperties<float>::getGridSpacingPhi(nphi) * (MGParameters::normalizeGridToNSector / double(SECTORSPERSIDE)) * iPhiTmp;
 
       const float x = rTmp * std::cos(phiTmp);
       const float y = rTmp * std::sin(phiTmp);
       const LocalPosition3D pos(x, y, zTmp);
-      unsigned char secNum = simOneSectorOnly ? 0 : std::floor(phiTmp / SECPHIWIDTH);
+      unsigned char secNum = std::floor(phiTmp / SECPHIWIDTH);
       Sector sector(secNum + (pos.Z() < 0) * SECTORSPERSIDE);
       LocalPosition3D lPosTmp = Mapper::GlobalToLocal(pos, sector);
 
@@ -428,10 +427,9 @@ void DataContainer3D<DataT>::dumpInterpolation(std::string_view treename, std::s
 
   // define grid for interpolation
   using GridProp = GridProperties<DataT>;
-  const RegularGrid3D<DataT> mGrid3D(GridProp::ZMIN, GridProp::RMIN, GridProp::PHIMIN, GridProp::getGridSpacingZ(nz), GridProp::getGridSpacingR(nr), o2::tpc::GridProperties<float>::getGridSpacingPhi(nphi) / (MGParameters::normalizeGridToOneSector ? SECTORSPERSIDE : 1), ParamSpaceCharge{nr, nz, nphi});
+  const RegularGrid3D<DataT> mGrid3D(GridProp::ZMIN, GridProp::RMIN, GridProp::PHIMIN, GridProp::getGridSpacingZ(nz), GridProp::getGridSpacingR(nr), o2::tpc::GridProperties<float>::getGridSpacingPhi(nphi) * (MGParameters::normalizeGridToNSector / double(SECTORSPERSIDE)), ParamSpaceCharge{nr, nz, nphi});
 
   auto interpolate = [&mGrid3D = std::as_const(mGrid3D), &data = std::as_const(data), rangeR, rangeZ, rangePhi, nR, nZ, nPhi](unsigned int, ULong64_t iPhi) {
-    const bool simOneSectorOnly = MGParameters::normalizeGridToOneSector;
     std::vector<size_t> ir;
     std::vector<size_t> iphi;
     std::vector<size_t> iz;
@@ -473,7 +471,7 @@ void DataContainer3D<DataT>::dumpInterpolation(std::string_view treename, std::s
         const float x = rPos * std::cos(phiPos);
         const float y = rPos * std::sin(phiPos);
         const LocalPosition3D pos(x, y, zPos);
-        unsigned char secNum = simOneSectorOnly ? 0 : std::floor(phiPos / SECPHIWIDTH);
+        unsigned char secNum = std::floor(phiPos / SECPHIWIDTH); // TODO CHECK THIS
         Sector sector(secNum + (pos.Z() < 0) * SECTORSPERSIDE);
         LocalPosition3D lPosTmp = Mapper::GlobalToLocal(pos, sector);
         lPos.emplace_back(lPosTmp);
@@ -512,6 +510,27 @@ bool DataContainer3D<DataT>::getVertices(std::string_view treename, std::string_
   return true;
 }
 
+template <typename DataT>
+DataContainer3D<DataT> DataContainer3D<DataT>::convert(const o2::tpc::RegularGrid3D<DataT>& gridNew, const o2::tpc::RegularGrid3D<DataT>& gridRef, const int threads) const
+{
+  const int nZNew = gridNew.getNZ();
+  const int nRNew = gridNew.getNR();
+  const int nPhiNew = gridNew.getNPhi();
+  DataContainer3D<DataT> contCont(nZNew, nRNew, nPhiNew);
+#pragma omp parallel for num_threads(threads)
+  for (size_t iPhi = 0; iPhi < nPhiNew; ++iPhi) {
+    const DataT phi = gridNew.getPhiVertex(iPhi);
+    for (size_t iR = 0; iR < nRNew; ++iR) {
+      const DataT radius = gridNew.getRVertex(iR);
+      for (size_t iZ = 0; iZ < nZNew; ++iZ) {
+        const DataT z = gridNew.getZVertex(iZ);
+        contCont(iZ, iR, iPhi) = interpolate(z, radius, phi, gridRef);
+      }
+    }
+  }
+  return contCont;
+}
+
 template class o2::tpc::DataContainer3D<float>;
 template class o2::tpc::DataContainer3D<double>;
 
diff --git a/Detectors/TPC/spacecharge/src/PoissonSolver.cxx b/Detectors/TPC/spacecharge/src/PoissonSolver.cxx
index 952f4b29111ce..d00e268f64125 100644
--- a/Detectors/TPC/spacecharge/src/PoissonSolver.cxx
+++ b/Detectors/TPC/spacecharge/src/PoissonSolver.cxx
@@ -940,7 +940,7 @@ void PoissonSolver<DataT>::residue2D(Vector& residue, const Vector& matricesCurr
     for (int j = 1; j < tnZColumn - 1; ++j) {
       residue(i, j, iPhi) = ih2 * (coefficient1[i] * matricesCurrentV(i + 1, j, iPhi) + coefficient2[i] * matricesCurrentV(i - 1, j, iPhi) + tempRatio * (matricesCurrentV(i, j + 1, iPhi) + matricesCurrentV(i, j - 1, iPhi)) - inverseTempFourth * matricesCurrentV(i, j, iPhi)) + matricesCurrentCharge(i, j, iPhi);
     } // end cols
-  }   // end nRRow
+  } // end nRRow
 
   // Boundary points.
   for (int i = 0; i < tnRRow; ++i) {
@@ -997,7 +997,7 @@ void PoissonSolver<DataT>::residue3D(Vector& residue, const Vector& matricesCurr
                                   coefficient3[i] * (signPlus * matricesCurrentV(i, j, mp1) + signMinus * matricesCurrentV(i, j, mm1)) - inverseCoefficient4[i] * matricesCurrentV(i, j, m)) +
                            matricesCurrentCharge(i, j, m);
       } // end cols
-    }   // end mParamGrid.NRVertices
+    } // end mParamGrid.NRVertices
   }
 }
 
@@ -1263,9 +1263,9 @@ void PoissonSolver<DataT>::relax3D(Vector& matricesCurrentV, const Vector& matri
           for (int i = isw; i < tnRRow - 1; i += 2) {
             (matricesCurrentV)(i, j, m) = (coefficient2[i] * (matricesCurrentV)(i - 1, j, m) + tempRatioZ * ((matricesCurrentV)(i, j - 1, m) + (matricesCurrentV)(i, j + 1, m)) + coefficient1[i] * (matricesCurrentV)(i + 1, j, m) + coefficient3[i] * (signPlus * (matricesCurrentV)(i, j, mp1) + signMinus * (matricesCurrentV)(i, j, mm1)) + (h2 * (matricesCurrentCharge)(i, j, m))) * coefficient4[i];
           } // end cols
-        }   // end mParamGrid.NRVertices
-      }     // end phi
-    }       // end sweep
+        } // end mParamGrid.NRVertices
+      } // end phi
+    } // end sweep
   } else if (MGParameters::relaxType == RelaxType::Jacobi) {
     // for each slice
     for (int m = 0; m < iPhi; ++m) {
@@ -1306,8 +1306,8 @@ void PoissonSolver<DataT>::relax3D(Vector& matricesCurrentV, const Vector& matri
         for (int i = 1; i < tnRRow - 1; ++i) {
           (matricesCurrentV)(i, j, m) = (coefficient2[i] * (matricesCurrentV)(i - 1, j, m) + tempRatioZ * ((matricesCurrentV)(i, j - 1, m) + (matricesCurrentV)(i, j + 1, m)) + coefficient1[i] * (matricesCurrentV)(i + 1, j, m) + coefficient3[i] * (signPlus * (matricesCurrentV)(i, j, mp1) + signMinus * (matricesCurrentV)(i, j, mm1)) + (h2 * (matricesCurrentCharge)(i, j, m))) * coefficient4[i];
         } // end cols
-      }   // end mParamGrid.NRVertices
-    }     // end phi
+      } // end mParamGrid.NRVertices
+    } // end phi
   } else {
     // Case weighted Jacobi
     // TODO
@@ -1329,15 +1329,15 @@ void PoissonSolver<DataT>::relax2D(Vector& matricesCurrentV, const Vector& matri
           matricesCurrentV(i, j, iPhi) = tempFourth * (coefficient1[i] * matricesCurrentV(i + 1, j, iPhi) + coefficient2[i] * matricesCurrentV(i - 1, j, iPhi) +
                                                        tempRatio * (matricesCurrentV(i, j + 1, iPhi) + matricesCurrentV(i, j - 1, iPhi)) + (h2 * matricesCurrentCharge(i, j, iPhi)));
         } // end cols
-      }   // end mParamGrid.NRVertices
-    }     // end pass red-black
+      } // end mParamGrid.NRVertices
+    } // end pass red-black
   } else if (MGParameters::relaxType == RelaxType::Jacobi) {
     for (int j = 1; j < tnZColumn - 1; ++j) {
       for (int i = 1; i < tnRRow - 1; ++i) {
         matricesCurrentV(i, j, iPhi) = tempFourth * (coefficient1[i] * matricesCurrentV(i + 1, j, iPhi) + coefficient2[i] * matricesCurrentV(i - 1, j, iPhi) +
                                                      tempRatio * (matricesCurrentV(i, j + 1, iPhi) + matricesCurrentV(i, j - 1, iPhi)) + (h2 * matricesCurrentCharge(i, j, iPhi)));
       } // end cols
-    }   // end mParamGrid.NRVertices
+    } // end mParamGrid.NRVertices
   } else if (MGParameters::relaxType == RelaxType::WeightedJacobi) {
     // Weighted Jacobi
     // TODO
@@ -1421,7 +1421,7 @@ void PoissonSolver<DataT>::restrict3D(Vector& matricesCurrentCharge, const Vecto
 
           matricesCurrentCharge(i, j, m) = residue(ii, jj, mm) / 8 + s1 / 16 + s2 / 32 + s3 / 64;
         } // end cols
-      }   // end mParamGrid.NRVertices
+      } // end mParamGrid.NRVertices
 
       // for boundary
       for (int j = 0, jj = 0; j < tnZColumn; ++j, jj += 2) {
@@ -1460,7 +1460,7 @@ void PoissonSolver<DataT>::restrict2D(Vector& matricesCurrentCharge, const Vecto
                                             (residue(iip1, jjp1, iphi) + residue(iim1, jjp1, iphi) + residue(iip1, jjm1, iphi) + residue(iim1, jjm1, iphi)) / 16;
       }
     } // end cols
-  }   // end mParamGrid.NRVertices
+  } // end mParamGrid.NRVertices
   // boundary
   // for boundary
   for (int j = 0, jj = 0; j < tnZColumn; ++j, jj += 2) {
@@ -1520,7 +1520,7 @@ void PoissonSolver<DataT>::calcCoefficients2D(unsigned int from, unsigned int to
 template <typename DataT>
 DataT PoissonSolver<DataT>::getGridSizePhiInv()
 {
-  return MGParameters::normalizeGridToOneSector ? (INVTWOPI * SECTORSPERSIDE) : INVTWOPI;
+  return INVTWOPI * SECTORSPERSIDE / MGParameters::normalizeGridToNSector;
 }
 
 template class o2::tpc::PoissonSolver<double>;
diff --git a/Detectors/TPC/spacecharge/src/SpaceCharge.cxx b/Detectors/TPC/spacecharge/src/SpaceCharge.cxx
index 9b6a572b46406..b80d2a7606ee7 100644
--- a/Detectors/TPC/spacecharge/src/SpaceCharge.cxx
+++ b/Detectors/TPC/spacecharge/src/SpaceCharge.cxx
@@ -43,6 +43,7 @@
 #include "TStopwatch.h"
 #include "ROOT/RDataFrame.hxx"
 #include "THnSparse.h"
+#include "TRandom.h"
 
 #include <random>
 
@@ -246,6 +247,10 @@ void SpaceCharge<DataT>::setDefaultStaticDistortionsGEMFrameChargeUp(const Side
 template <typename DataT>
 size_t SpaceCharge<DataT>::getPhiBinsGapFrame(const Side side) const
 {
+  if (MGParameters::normalizeGridToNSector == 1) {
+    return 0;
+  }
+
   const auto& regInf = Mapper::instance().getPadRegionInfo(0);
   const float localYEdgeIROC = regInf.getPadsInRowRegion(0) / 2 * regInf.getPadWidth();
   const auto globalPosGap = Mapper::LocalToGlobal(LocalPosition2D(regInf.getRadiusFirstRow(), -(localYEdgeIROC + GEMFrameParameters<DataT>::WIDTHFRAME)), Sector(0));
@@ -268,16 +273,15 @@ void SpaceCharge<DataT>::setPotentialBoundaryGEMFrameAlongR(const std::function<
 }
 
 template <typename DataT>
-std::vector<size_t> SpaceCharge<DataT>::getPotentialBoundaryGEMFrameAlongRIndices(const Side side) const
+std::vector<std::pair<size_t, float>> SpaceCharge<DataT>::getPotentialBoundaryGEMFrameAlongRIndices(const Side side) const
 {
-  const bool simOneSectorOnly = MGParameters::normalizeGridToOneSector;
   const auto radiusStart = std::sqrt(std::pow(GEMFrameParameters<DataT>::LENGTHFRAMEIROCBOTTOM / 2, 2) + std::pow(GEMFrameParameters<DataT>::POSBOTTOM[0], 2));
   const auto rStart = getNearestRVertex(radiusStart, side);
 
   const auto radiusEnd = std::sqrt(std::pow(GEMFrameParameters<DataT>::LENGTHFRAMEOROC3TOP / 2, 2) + std::pow(GEMFrameParameters<DataT>::POSTOP[3], 2));
   const auto rEnd = getNearestRVertex(radiusEnd, side); // mParamGrid.NRVertices - 1
 
-  const int verticesPerSector = simOneSectorOnly ? mParamGrid.NPhiVertices : mParamGrid.NPhiVertices / SECTORSPERSIDE;
+  const int verticesPerSector = mParamGrid.NPhiVertices / MGParameters::normalizeGridToNSector;
 
   const auto& regInf = Mapper::instance().getPadRegionInfo(0);
   const float localYEdgeIROC = regInf.getPadsInRowRegion(0) / 2 * regInf.getPadWidth();
@@ -300,7 +304,8 @@ std::vector<size_t> SpaceCharge<DataT>::getPotentialBoundaryGEMFrameAlongRIndice
     radii.emplace_back(std::sqrt(std::pow(GEMFrameParameters<DataT>::POSTOP[stack], 2) + std::pow(localYEdge, 2)));
   }
 
-  std::vector<size_t> potentialInd;
+  std::vector<std::pair<size_t, float>> potentialInd;
+  const float weight = 1;
   for (size_t iR = rStart; iR < rEnd; ++iR) {
     const DataT radius = getRVertex(iR, side);
     auto const it = std::lower_bound(radii.begin(), radii.end(), radius);
@@ -315,13 +320,13 @@ std::vector<size_t> SpaceCharge<DataT>::getPotentialBoundaryGEMFrameAlongRIndice
         break;
       }
 
-      for (int sector = 0; sector < (simOneSectorOnly ? 1 : SECTORSPERSIDE); ++sector) {
+      for (int sector = 0; sector < MGParameters::normalizeGridToNSector; ++sector) {
         const size_t iPhiLeft = sector * verticesPerSector + iPhiTmp;
         const size_t iZ = mParamGrid.NZVertices - 1;
-        potentialInd.emplace_back(mPotential[side].getDataIndex(iZ, iR, iPhiLeft));
+        potentialInd.emplace_back(mPotential[side].getDataIndex(iZ, iR, iPhiLeft), weight);
         if (iPhiTmp > 0) {
           const size_t iPhiRight = (sector + 1) * verticesPerSector - iPhiTmp;
-          potentialInd.emplace_back(mPotential[side].getDataIndex(iZ, iR, iPhiRight));
+          potentialInd.emplace_back(mPotential[side].getDataIndex(iZ, iR, iPhiRight), weight);
         }
       }
     }
@@ -339,37 +344,35 @@ void SpaceCharge<DataT>::setPotentialBoundaryGEMFrameAlongPhi(const std::functio
 }
 
 template <typename DataT>
-void SpaceCharge<DataT>::setBoundaryFromIndices(const std::function<DataT(DataT)>& potentialFunc, const std::vector<size_t>& indices, const Side side)
+void SpaceCharge<DataT>::setBoundaryFromIndices(const std::function<DataT(DataT)>& potentialFunc, const std::vector<std::pair<size_t, float>>& indices, const Side side)
 {
-  for (const auto& index : indices) {
+  /*
+    make check for the weights
+    Loop over bins in the radial direction
+    Check for duplicates and use the one with larger weight
+  */
+
+  for (const auto& indexw : indices) {
+    const int index = indexw.first;
     const int iZ = mPotential[side].getIndexZ(index);
     const int iR = mPotential[side].getIndexR(index);
     const int iPhi = mPotential[side].getIndexPhi(index);
     const DataT radius = getRVertex(iR, side);
-    mPotential[side](iZ, iR, iPhi) = potentialFunc(radius);
+    const float weight = indexw.second;
+    const float pot = mPotential[side](iZ, iR, iPhi);
+    const float potNew = weight * potentialFunc(radius);
+    if (std::abs(potNew) > std::abs(pot)) {
+      mPotential[side](iZ, iR, iPhi) = potNew;
+    }
   }
 }
 
 template <typename DataT>
-std::vector<size_t> SpaceCharge<DataT>::getPotentialBoundaryGEMFrameAlongPhiIndices(const GEMstack stack, const bool bottom, const Side side, const bool outerFrame, const bool noGap) const
+std::vector<std::pair<size_t, float>> SpaceCharge<DataT>::getPotentialBoundaryGEMFrameAlongPhiIndices(const GEMstack stack, const bool bottom, const Side side, const bool outerFrame, const bool noGap) const
 {
-  const bool simOneSectorOnly = MGParameters::normalizeGridToOneSector;
-
   // to avoid double counting
   auto indices = getPotentialBoundaryGEMFrameAlongRIndices(side);
 
-  if (!bottom && outerFrame) {
-    // if OROC3 to OFC check outer GEM frame from OROC3!
-    const auto indicesOROC3 = getPotentialBoundaryGEMFrameAlongPhiIndices(GEMstack::OROC3gem, false, side, false);
-    indices.insert(indices.end(), indicesOROC3.begin(), indicesOROC3.end());
-    std::sort(indices.begin(), indices.end());
-  } else if (bottom && outerFrame) {
-    // if IROC to IFC check inner GEM frame from IROC
-    const auto indicesIROC = getPotentialBoundaryGEMFrameAlongPhiIndices(GEMstack::IROCgem, true, side, false);
-    indices.insert(indices.end(), indicesIROC.begin(), indicesIROC.end());
-    std::sort(indices.begin(), indices.end());
-  }
-
   int region = 0;
   float offsStart = 0;
   float offsEnd = 0;
@@ -415,10 +418,10 @@ std::vector<size_t> SpaceCharge<DataT>::getPotentialBoundaryGEMFrameAlongPhiIndi
     nVerticesR = 1;
   }
 
-  std::vector<size_t> potentialInd;
-  const int verticesPerSector = simOneSectorOnly ? mParamGrid.NPhiVertices : mParamGrid.NPhiVertices / SECTORSPERSIDE;
-  const auto nBinsPhi = (outerFrame || noGap) ? 0 : (simOneSectorOnly ? 0 : getPhiBinsGapFrame(side));
-  for (int sector = 0; sector < (simOneSectorOnly ? 1 : SECTORSPERSIDE); ++sector) {
+  std::vector<std::pair<size_t, float>> potentialInd; // index, weight
+  const int verticesPerSector = mParamGrid.NPhiVertices / MGParameters::normalizeGridToNSector;
+  const auto nBinsPhi = (outerFrame || noGap) ? 0 : getPhiBinsGapFrame(side);
+  for (int sector = 0; sector < MGParameters::normalizeGridToNSector; ++sector) {
     const auto offsetPhi = sector * verticesPerSector + verticesPerSector / 2;
     for (size_t iPhiLocal = 0; iPhiLocal <= (verticesPerSector / 2 - nBinsPhi); ++iPhiLocal) {
       const auto iPhiLeft = offsetPhi + iPhiLocal;
@@ -432,31 +435,62 @@ std::vector<size_t> SpaceCharge<DataT>::getPotentialBoundaryGEMFrameAlongPhiIndi
 
       // end at gem frame
       if ((outerFrame && (stack == GEMstack::IROCgem))) {
-        nREnd = (radiusBottom - getRVertex(1, side)) / getGridSpacingR(side) + 2; // 2 safety margin
+        // TODO: remove this?
+        const float marginCM = 0; // 0.4;
+        const int nMargingBins = marginCM / getGridSpacingR(side) + 0.5;
+        nREnd = (radiusBottom - getRVertex(1, side) + 0.5) / getGridSpacingR(side) + nMargingBins; // 2 safety margin
+        radiusMax = 3 + getRVertex(getNearestRVertex(radiusBottom + getGridSpacingR(side) * nMargingBins, side), side);
       }
 
-      if (rStart == 0) {
+      rStart -= 1;
+      nREnd += 1;
+      if (rStart <= 0) {
         rStart = 1;
       }
 
+      if (nREnd >= mParamGrid.NRVertices) {
+        nREnd = mParamGrid.NRVertices - 1;
+      }
+
+      float lxMin = radiusStart;
+      if ((outerFrame && (stack == GEMstack::IROCgem))) {
+        lxMin = 0;
+      }
+      const float lxMax = (nREnd == mParamGrid.NRVertices - 1) ? 9999 : radiusMax;
       for (size_t iR = rStart; iR < nREnd; ++iR) {
         const size_t iZ = mParamGrid.NZVertices - 1;
+        float weight = 1;
         if (iPhiLeft < getNPhiVertices()) {
-          if (noGap || !std::binary_search(indices.begin(), indices.end(), mPotential[side].getDataIndex(iZ, iR, iPhiLeft))) {
-            potentialInd.emplace_back(mPotential[side].getDataIndex(iZ, iR, iPhiLeft));
+          if (noGap || !std::binary_search(indices.begin(), indices.end(), std::make_pair(mPotential[side].getDataIndex(iZ, iR, iPhiLeft), 0.0f), [](const auto& a, const auto& b) { return (a.first < b.first); })) {
+
+            // check how much of the bin is in the lx range and assign weigth
+            const int nIterPoints = 1000;
+            int nPointsGood = 0;
+            for (int i = 0; i < nIterPoints; ++i) {
+              const float radius = getRVertex(iR, side) + getGridSpacingR(side) * gRandom->Uniform(-0.5, 0.5);
+              const float phi = getGridSpacingPhi(side) * gRandom->Uniform(-0.5, 0.5);
+              const DataT lx = radius * std::cos(phi + localphi);
+              if ((lx >= lxMin) && (lx <= lxMax)) {
+                ++nPointsGood;
+              }
+            }
+            weight = nPointsGood / double(nIterPoints);
+            potentialInd.emplace_back(mPotential[side].getDataIndex(iZ, iR, iPhiLeft), weight);
           }
         }
 
-        if (iPhiLocal && (noGap || !std::binary_search(indices.begin(), indices.end(), mPotential[side].getDataIndex(iZ, iR, iPhiRight)))) {
-          potentialInd.emplace_back(mPotential[side].getDataIndex(iZ, iR, iPhiRight));
+        if (iPhiLocal && (noGap || !std::binary_search(indices.begin(), indices.end(), std::make_pair(mPotential[side].getDataIndex(iZ, iR, iPhiRight), 0.0f), [](const auto& a, const auto& b) { return (a.first < b.first); }))) {
+          potentialInd.emplace_back(mPotential[side].getDataIndex(iZ, iR, iPhiRight), weight);
         }
       }
     }
   }
   // remove duplicate entries
-  std::unordered_set<size_t> set(potentialInd.begin(), potentialInd.end());
-  potentialInd.assign(set.begin(), set.end());
   std::sort(potentialInd.begin(), potentialInd.end());
+
+  // Remove duplicates
+  potentialInd.erase(std::unique(potentialInd.begin(), potentialInd.end()), potentialInd.end());
+
   return potentialInd;
 }
 
@@ -1809,6 +1843,18 @@ DataT SpaceCharge<DataT>::getDensityCyl(const DataT z, const DataT r, const Data
   return mInterpolatorDensity[side](z, r, phi);
 }
 
+template <typename DataT>
+std::vector<float> SpaceCharge<DataT>::getDensityCyl(const std::vector<DataT>& z, const std::vector<DataT>& r, const std::vector<DataT>& phi, const Side side) const
+{
+  const auto nPoints = z.size();
+  std::vector<float> density(nPoints);
+#pragma omp parallel for num_threads(sNThreads)
+  for (size_t i = 0; i < nPoints; ++i) {
+    density[i] = getDensityCyl(z[i], r[i], phi[i], side);
+  }
+  return density;
+}
+
 template <typename DataT>
 DataT SpaceCharge<DataT>::getPotentialCyl(const DataT z, const DataT r, const DataT phi, const Side side) const
 {
@@ -1885,7 +1931,8 @@ void SpaceCharge<DataT>::getCorrections(const DataT x, const DataT y, const Data
   } else {
     // convert cartesian to polar
     const DataT radius = getRadiusFromCartesian(x, y);
-    const DataT phi = getPhiFromCartesian(x, y);
+    DataT phi = getPhiFromCartesian(x, y);
+    o2::math_utils::detail::bringTo02PiGen(phi);
 
     DataT corrR{};
     DataT corrRPhi{};
@@ -2421,7 +2468,7 @@ void SpaceCharge<DataT>::makeElectronDriftPathGif(const char* inpFile, TH2F& hDu
 template <typename DataT>
 void SpaceCharge<DataT>::dumpToTree(const char* outFileName, const Side side, const int nZPoints, const int nRPoints, const int nPhiPoints, const bool randomize) const
 {
-  const DataT phiSpacing = GridProp::getGridSpacingPhi(nPhiPoints) / (MGParameters::normalizeGridToOneSector ? SECTORSPERSIDE : 1);
+  const DataT phiSpacing = GridProp::getGridSpacingPhi(nPhiPoints) * (MGParameters::normalizeGridToNSector / double(SECTORSPERSIDE));
   const DataT rSpacing = GridProp::getGridSpacingR(nRPoints);
   const DataT zSpacing = side == Side::A ? GridProp::getGridSpacingZ(nZPoints) : -GridProp::getGridSpacingZ(nZPoints);
 
@@ -2459,6 +2506,7 @@ void SpaceCharge<DataT>::dumpToTree(const char* outFileName, const Side side, co
   std::vector<std::vector<LocalPosition3D>> lPosOut(nPhiPoints);
   std::vector<std::vector<int>> sectorOut(nPhiPoints);
   std::vector<std::vector<size_t>> globalIdxOut(nPhiPoints);
+  std::vector<std::vector<bool>> isOnPadPlane(nPhiPoints);
 
 #pragma omp parallel for num_threads(sNThreads)
   for (int iPhi = 0; iPhi < nPhiPoints; ++iPhi) {
@@ -2494,6 +2542,7 @@ void SpaceCharge<DataT>::dumpToTree(const char* outFileName, const Side side, co
     lPosOut[iPhi].reserve(nPoints);
     sectorOut[iPhi].reserve(nPoints);
     globalIdxOut[iPhi].reserve(nPoints);
+    isOnPadPlane[iPhi].reserve(nPoints);
 
     std::mt19937 rng(std::random_device{}());
     DataT phiPos = iPhi * phiSpacing;
@@ -2603,6 +2652,12 @@ void SpaceCharge<DataT>::dumpToTree(const char* outFileName, const Side side, co
         sectorOut[iPhi].emplace_back(sector);
         const size_t idx = (iZ + nZPoints * (iR + iPhi * nRPoints));
         globalIdxOut[iPhi].emplace_back(idx);
+
+        const float xDist = getXFromPolar(radiusDistorted, phiDistorted);
+        const float yDist = getYFromPolar(radiusDistorted, phiDistorted);
+        GlobalPosition3D posTmp(xDist, yDist, zPos);
+        const DigitPos digiPadPos = o2::tpc::Mapper::instance().findDigitPosFromGlobalPosition(posTmp);
+        isOnPadPlane[iPhi].emplace_back(digiPadPos.isValid());
       }
     }
   }
@@ -2645,6 +2700,7 @@ void SpaceCharge<DataT>::dumpToTree(const char* outFileName, const Side side, co
   dfStore = dfStore.DefineSlotEntry("bZ", [&bZOut = bZOut](unsigned int, ULong64_t entry) { return bZOut[entry]; });
   dfStore = dfStore.DefineSlotEntry("bPhi", [&bPhiOut = bPhiOut](unsigned int, ULong64_t entry) { return bPhiOut[entry]; });
   dfStore = dfStore.DefineSlotEntry("globalIndex", [&globalIdxOut = globalIdxOut](unsigned int, ULong64_t entry) { return globalIdxOut[entry]; });
+  dfStore = dfStore.DefineSlotEntry("isOnPadPlane", [&isOnPadPlane = isOnPadPlane](unsigned int, ULong64_t entry) { return isOnPadPlane[entry]; });
   dfStore.Snapshot("tree", outFileName);
   timer.Print("u");
 }
@@ -3356,20 +3412,20 @@ void SpaceCharge<DataT>::readMetaData(std::string_view file)
 }
 
 template <typename DataT>
-void SpaceCharge<DataT>::setSimOneSector()
+void SpaceCharge<DataT>::setSimNSector(const int nSectors)
 {
   LOGP(warning, "Use this feature only if you know what you are doing!");
-  o2::tpc::MGParameters::normalizeGridToOneSector = true;
-  RegularGrid gridTmp[FNSIDES]{{GridProp::ZMIN, GridProp::RMIN, GridProp::PHIMIN, getSign(Side::A) * GridProp::getGridSpacingZ(mParamGrid.NZVertices), GridProp::getGridSpacingR(mParamGrid.NRVertices), GridProp::getGridSpacingPhi(mParamGrid.NPhiVertices) / SECTORSPERSIDE, mParamGrid},
-                               {GridProp::ZMIN, GridProp::RMIN, GridProp::PHIMIN, getSign(Side::C) * GridProp::getGridSpacingZ(mParamGrid.NZVertices), GridProp::getGridSpacingR(mParamGrid.NRVertices), GridProp::getGridSpacingPhi(mParamGrid.NPhiVertices) / SECTORSPERSIDE, mParamGrid}};
+  o2::tpc::MGParameters::normalizeGridToNSector = nSectors;
+  RegularGrid gridTmp[FNSIDES]{{GridProp::ZMIN, GridProp::RMIN, GridProp::PHIMIN, getSign(Side::A) * GridProp::getGridSpacingZ(mParamGrid.NZVertices), GridProp::getGridSpacingR(mParamGrid.NRVertices), GridProp::getGridSpacingPhi(mParamGrid.NPhiVertices) / SECTORSPERSIDE * nSectors, mParamGrid},
+                               {GridProp::ZMIN, GridProp::RMIN, GridProp::PHIMIN, getSign(Side::C) * GridProp::getGridSpacingZ(mParamGrid.NZVertices), GridProp::getGridSpacingR(mParamGrid.NRVertices), GridProp::getGridSpacingPhi(mParamGrid.NPhiVertices) / SECTORSPERSIDE * nSectors, mParamGrid}};
   mGrid3D[0] = gridTmp[0];
   mGrid3D[1] = gridTmp[1];
 }
 
 template <typename DataT>
-void SpaceCharge<DataT>::unsetSimOneSector()
+void SpaceCharge<DataT>::unsetSimNSector()
 {
-  o2::tpc::MGParameters::normalizeGridToOneSector = false;
+  o2::tpc::MGParameters::normalizeGridToNSector = SECTORSPERSIDE;
 }
 
 template <typename DataT>
@@ -3424,6 +3480,20 @@ void SpaceCharge<DataT>::addChargeDensity(const SpaceCharge<DataT>& otherSC)
   mDensity[Side::C] += otherSC.mDensity[Side::C];
 }
 
+template <typename DataT>
+void SpaceCharge<DataT>::addGlobalCorrections(const SpaceCharge<DataT>& otherSC, const Side side)
+{
+  const bool sameGrid = (getNPhiVertices() == otherSC.getNPhiVertices()) && (getNRVertices() == otherSC.getNRVertices()) && (getNZVertices() == otherSC.getNZVertices());
+  if (!sameGrid) {
+    LOGP(warning, "Space charge objects have different grid definition");
+    return;
+  }
+
+  mGlobalCorrdR[side] += otherSC.mGlobalCorrdR[side];
+  mGlobalCorrdZ[side] += otherSC.mGlobalCorrdZ[side];
+  mGlobalCorrdRPhi[side] += otherSC.mGlobalCorrdRPhi[side];
+}
+
 template <typename DataT>
 void SpaceCharge<DataT>::fillChargeDensityFromHisto(const char* file, const char* nameA, const char* nameC)
 {
@@ -3739,9 +3809,27 @@ void SpaceCharge<DataT>::setIFCChargeUpFallingPot(const float deltaPot, const fl
 template <typename DataT>
 void SpaceCharge<DataT>::setGlobalCorrections(const std::function<void(int sector, DataT gx, DataT gy, DataT gz, DataT& gCx, DataT& gCy, DataT& gCz)>& gCorr, const Side side)
 {
-  initContainer(mGlobalCorrdR[side], true);
-  initContainer(mGlobalCorrdZ[side], true);
-  initContainer(mGlobalCorrdRPhi[side], true);
+  setGlobalDistCorr(Type::Corrections, gCorr, side);
+}
+
+template <typename DataT>
+void SpaceCharge<DataT>::setGlobalDistortions(const std::function<void(int sector, DataT gx, DataT gy, DataT gz, DataT& gCx, DataT& gCy, DataT& gCz)>& gDist, const Side side)
+{
+  setGlobalDistCorr(Type::Distortions, gDist, side);
+}
+
+template <typename DataT>
+void SpaceCharge<DataT>::setGlobalDistCorr(const Type type, const std::function<void(int sector, DataT gx, DataT gy, DataT gz, DataT& gCx, DataT& gCy, DataT& gCz)>& gFunc, const Side side)
+{
+  if (type == Type::Distortions) {
+    initContainer(mGlobalDistdR[side], true);
+    initContainer(mGlobalDistdZ[side], true);
+    initContainer(mGlobalDistdRPhi[side], true);
+  } else {
+    initContainer(mGlobalCorrdR[side], true);
+    initContainer(mGlobalCorrdZ[side], true);
+    initContainer(mGlobalCorrdRPhi[side], true);
+  }
 
 #pragma omp parallel for num_threads(sNThreads)
   for (unsigned int iPhi = 0; iPhi < mParamGrid.NPhiVertices; ++iPhi) {
@@ -3761,7 +3849,7 @@ void SpaceCharge<DataT>::setGlobalCorrections(const std::function<void(int secto
         DataT gCx = 0;
         DataT gCy = 0;
         DataT gCz = 0;
-        gCorr(sector, x, y, z, gCx, gCy, gCz);
+        gFunc(sector, x, y, z, gCx, gCy, gCz);
         const DataT gCxCorr = x + gCx;
         const DataT gCyCorr = y + gCy;
 
@@ -3772,9 +3860,15 @@ void SpaceCharge<DataT>::setGlobalCorrections(const std::function<void(int secto
         const DataT corrRPhi = phiDiff * radius;
 
         // store corrections
-        mGlobalCorrdR[side](iZ, iR, iPhi) = corrR;
-        mGlobalCorrdZ[side](iZ, iR, iPhi) = gCz;
-        mGlobalCorrdRPhi[side](iZ, iR, iPhi) = corrRPhi;
+        if (type == Type::Distortions) {
+          mGlobalDistdR[side](iZ, iR, iPhi) = corrR;
+          mGlobalDistdZ[side](iZ, iR, iPhi) = gCz;
+          mGlobalDistdRPhi[side](iZ, iR, iPhi) = corrRPhi;
+        } else {
+          mGlobalCorrdR[side](iZ, iR, iPhi) = corrR;
+          mGlobalCorrdZ[side](iZ, iR, iPhi) = gCz;
+          mGlobalCorrdRPhi[side](iZ, iR, iPhi) = corrRPhi;
+        }
       }
     }
   }
@@ -3838,9 +3932,10 @@ void SpaceCharge<DataT>::setROCMisalignment(int stackType, int misalignmentType,
 }
 
 template <typename DataT>
-void SpaceCharge<DataT>::fillROCMisalignment(const std::vector<size_t>& indicesTop, const std::vector<size_t>& indicesBottom, int sector, int misalignmentType, const std::pair<float, float>& deltaPotPar)
+void SpaceCharge<DataT>::fillROCMisalignment(const std::vector<std::pair<size_t, float>>& indicesTop, const std::vector<std::pair<size_t, float>>& indicesBottom, int sector, int misalignmentType, const std::pair<float, float>& deltaPotPar)
 {
-  for (const auto& index : indicesTop) {
+  for (const auto& indexw : indicesTop) {
+    const int index = indexw.first;
     const int iZ = DataContainer3D<float>::getIndexZ(index, getNZVertices(), getNRVertices(), getNPhiVertices());
     const int iRStart = DataContainer3D<float>::getIndexR(index, getNZVertices(), getNRVertices(), getNPhiVertices());
     const int iPhi = DataContainer3D<float>::getIndexPhi(index, getNZVertices(), getNRVertices(), getNPhiVertices());
@@ -3853,7 +3948,8 @@ void SpaceCharge<DataT>::fillROCMisalignment(const std::vector<size_t>& indicesT
 
     for (size_t iR = iRStart; iR > 0; --iR) {
       const size_t currInd = (iZ + getNZVertices() * (iR + iPhi * getNRVertices()));
-      const bool foundVertexBottom = std::binary_search(indicesBottom.begin(), indicesBottom.end(), currInd);
+      const bool foundVertexBottom = std::binary_search(indicesBottom.begin(), indicesBottom.end(), std::make_pair(currInd, 0.0f), [](const auto& a, const auto& b) { return (a.first < b.first); });
+
       if (foundVertexBottom) {
         break;
       }
@@ -3982,7 +4078,7 @@ void SpaceCharge<DataT>::initAfterReadingFromFile()
 }
 
 template <typename DataT>
-float SpaceCharge<DataT>::getDCAr(float tgl, const int nPoints, const float phi, o2::utils::TreeStreamRedirector* pcstream) const
+float SpaceCharge<DataT>::getDCAr(float tgl, const int nPoints, const float phi, float rStart, o2::utils::TreeStreamRedirector* pcstream) const
 {
   const float rmin = getRMin(o2::tpc::Side::A);
   std::vector<float> dRphi;
@@ -3990,7 +4086,7 @@ float SpaceCharge<DataT>::getDCAr(float tgl, const int nPoints, const float phi,
   dRphi.reserve(nPoints);
   r.reserve(nPoints);
   for (int i = 0; i < nPoints; ++i) {
-    float radius = rmin + i;
+    float radius = (rStart > 0) ? (rStart + i) : (rmin + i);
     float z = tgl * radius;
     DataT distZ = 0;
     DataT distR = 0;
@@ -4030,6 +4126,7 @@ float SpaceCharge<DataT>::getDCAr(float tgl, const int nPoints, const float phi,
                 << "r=" << r
                 << "dRphi=" << dRphi
                 << "tgl=" << tgl
+                << "phi=" << phi
                 << "dca=" << dca
                 << "rInterpol=" << rInterpol
                 << "dRPhiInterpol=" << dRPhiInterpol
@@ -4047,6 +4144,26 @@ void SpaceCharge<DataT>::setPotential(int iz, int ir, int iphi, Side side, float
   mPotential[side](iz, ir, iphi) = val;
 }
 
+template <typename DataT>
+void SpaceCharge<DataT>::downSampleObject(const int nZNew, const int nRNew, const int nPhiNew)
+{
+  o2::tpc::SpaceCharge<DataT> scNew(getBField(), nZNew, nRNew, nPhiNew);
+  for (int iside = 0; iside < 2; ++iside) {
+    const o2::tpc::Side side = (iside == 0) ? o2::tpc::Side::A : o2::tpc::Side::C;
+    const std::vector<std::reference_wrapper<const DataContainer>> dataRef{mLocalDistdR[iside], mLocalDistdZ[iside], mLocalDistdRPhi[iside], mLocalVecDistdR[iside], mLocalVecDistdZ[iside], mLocalVecDistdRPhi[iside], mLocalCorrdR[iside], mLocalCorrdZ[iside], mLocalCorrdRPhi[iside], mGlobalDistdR[iside], mGlobalDistdZ[iside], mGlobalDistdRPhi[iside], mGlobalCorrdR[iside], mGlobalCorrdZ[iside], mGlobalCorrdRPhi[iside], mDensity[iside], mPotential[iside], mElectricFieldEr[iside], mElectricFieldEz[iside], mElectricFieldEphi[iside]};
+    const std::vector<std::reference_wrapper<DataContainer>> dataNew{scNew.mLocalDistdR[iside], scNew.mLocalDistdZ[iside], scNew.mLocalDistdRPhi[iside], scNew.mLocalVecDistdR[iside], scNew.mLocalVecDistdZ[iside], scNew.mLocalVecDistdRPhi[iside], scNew.mLocalCorrdR[iside], scNew.mLocalCorrdZ[iside], scNew.mLocalCorrdRPhi[iside], scNew.mGlobalDistdR[iside], scNew.mGlobalDistdZ[iside], scNew.mGlobalDistdRPhi[iside], scNew.mGlobalCorrdR[iside], scNew.mGlobalCorrdZ[iside], scNew.mGlobalCorrdRPhi[iside], scNew.mDensity[iside], scNew.mPotential[iside], scNew.mElectricFieldEr[iside], scNew.mElectricFieldEz[iside], scNew.mElectricFieldEphi[iside]};
+    for (int i = 0; i < dataRef.size(); ++i) {
+      const auto& objRef = dataRef[i].get();
+      if (objRef.getNDataPoints()) {
+        auto& objNew = dataNew[i].get();
+        scNew.initContainer(objNew, true);
+        objNew = objRef.convert(scNew.mGrid3D[iside], mGrid3D[iside], sNThreads);
+      }
+    }
+  }
+  *this = std::move(scNew);
+}
+
 using DataTD = double;
 template class o2::tpc::SpaceCharge<DataTD>;
 

From b20c426d6a7678fa1dbee6491344076d9de868b6 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 13 Jan 2026 13:28:50 +0100
Subject: [PATCH 1195/1764] use better criterion to add arrow support service

---
 Framework/Core/src/runDataProcessing.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 14bdb2d8c72d9..166f26878c363 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -3010,8 +3010,8 @@ int doMain(int argc, char** argv, o2::framework::WorkflowSpec const& workflow,
   ServiceSpecs driverServices = ServiceSpecHelpers::filterDisabled(CommonDriverServices::defaultServices(), driverServicesOverride);
   // We insert the hash for the internal devices.
   WorkflowHelpers::injectServiceDevices(physicalWorkflow, configContext);
-  auto reader = std::find_if(physicalWorkflow.begin(), physicalWorkflow.end(), [](DataProcessorSpec& spec) { return spec.name == "internal-dpl-aod-reader"; });
-  if (reader != physicalWorkflow.end()) {
+  auto& dec = configContext.services().get<DanglingEdgesContext>();
+  if (!(dec.requestedAODs.empty() && dec.requestedDYNs.empty() && dec.requestedIDXs.empty() && dec.requestedTIMs.empty())) {
     driverServices.push_back(ArrowSupport::arrowBackendSpec());
   }
   for (auto& service : driverServices) {

From 494f76c08b567f7660edccd151a76426fcac4f98 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 14 Jan 2026 16:45:15 +0100
Subject: [PATCH 1196/1764] Fix code checker report

---
 Detectors/EMCAL/calib/include/EMCALCalib/CellRecalibrator.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/EMCAL/calib/include/EMCALCalib/CellRecalibrator.h b/Detectors/EMCAL/calib/include/EMCALCalib/CellRecalibrator.h
index 571b43d05ef08..ea8a0445bbe5e 100644
--- a/Detectors/EMCAL/calib/include/EMCALCalib/CellRecalibrator.h
+++ b/Detectors/EMCAL/calib/include/EMCALCalib/CellRecalibrator.h
@@ -62,7 +62,7 @@ class CellRecalibrator
  public:
   /// \class CellTypeException
   /// \brief Handling of invalid cell types in calibration
-  class CellTypeException : public std::exception
+  class CellTypeException final : public std::exception
   {
    public:
     /// \brief Constructor
@@ -73,7 +73,7 @@ class CellRecalibrator
 
     /// \brief Get error message of the exception
     /// \return Error message
-    const char* what() const noexcept final
+    [[nodiscard]] char const* what() const noexcept final
     {
       return "Only possible to calibrate cells of type high gain or low gain";
     }
@@ -208,4 +208,4 @@ std::ostream& operator<<(std::ostream& in, const CellRecalibrator& calib);
 
 } // namespace o2
 
-#endif // !ALCEO2_EMCAL_CELLRECALIBRATOR_H
\ No newline at end of file
+#endif // !ALCEO2_EMCAL_CELLRECALIBRATOR_H

From 36176ca5c73048c3d34fb3261edd4298dd436178 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 14 Jan 2026 13:50:50 +0100
Subject: [PATCH 1197/1764] DPL: add test for routing messages

---
 Framework/Core/test/test_ForwardInputs.cxx | 74 ++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
index fe9f70d1daadb..7081d600080b1 100644
--- a/Framework/Core/test/test_ForwardInputs.cxx
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -616,6 +616,80 @@ TEST_CASE("ForwardInputsSplitPayload")
   CHECK(result[1].Size() == 3);
 }
 
+TEST_CASE("ForwardInputsSplitPayloadNoMessageSet")
+{
+  o2::header::DataHeader dh;
+  dh.dataOrigin = "TST";
+  dh.dataDescription = "A";
+  dh.subSpecification = 0;
+  dh.splitPayloadIndex = 2;
+  dh.splitPayloadParts = 2;
+
+  o2::header::DataHeader dh2;
+  dh2.dataOrigin = "TST";
+  dh2.dataDescription = "B";
+  dh2.subSpecification = 0;
+  dh2.splitPayloadIndex = 0;
+  dh2.splitPayloadParts = 1;
+
+  o2::framework::DataProcessingHeader dph{0, 1};
+
+  std::vector<fair::mq::Channel> channels{
+    fair::mq::Channel("from_A_to_B"),
+    fair::mq::Channel("from_A_to_C"),
+  };
+
+  bool consume = true;
+  bool copyByDefault = true;
+  FairMQDeviceProxy proxy;
+  std::vector<ForwardRoute> routes{
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "B", 0}},
+      .channel = "from_A_to_B",
+      .policy = nullptr,
+    },
+    ForwardRoute{
+      .timeslice = 0,
+      .maxTimeslices = 1,
+      .matcher = {"binding", ConcreteDataMatcher{"TST", "A", 0}},
+      .channel = "from_A_to_C",
+      .policy = nullptr,
+    }};
+
+  auto findChannelByName = [&channels](std::string const& channelName) -> fair::mq::Channel& {
+    for (auto& channel : channels) {
+      if (channel.GetName() == channelName) {
+        return channel;
+      }
+    }
+    throw std::runtime_error("Channel not found");
+  };
+
+  proxy.bind({}, {}, routes, findChannelByName, nullptr);
+
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload1(transport->CreateMessage());
+  fair::mq::MessagePtr payload2(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+  std::vector<std::unique_ptr<fair::mq::Message>> messages;
+  messages.push_back(std::move(header));
+  messages.push_back(std::move(payload1));
+  messages.push_back(std::move(payload2));
+  auto header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
+  messages.push_back(std::move(header2));
+  messages.push_back(transport->CreateMessage());
+
+  std::vector<fair::mq::Parts> result(2);
+  auto span = std::span(messages);
+  o2::framework::DataProcessingHelpers::routeForwardedMessages(proxy, span, result, copyByDefault, consume);
+  REQUIRE(result.size() == 2);  // Two routes
+  CHECK(result[0].Size() == 2); // No messages on this route
+  CHECK(result[1].Size() == 3);
+}
+
 TEST_CASE("ForwardInputEOSSingleRoute")
 {
   o2::framework::SourceInfoHeader sih{};

From 7b11923549de0c2ebcd4656d8f9f98eda2e7a412 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 14 Jan 2026 13:56:36 +0100
Subject: [PATCH 1198/1764] DPL: add callback when inserting in the slot

---
 Framework/Core/include/Framework/DataRelayer.h |  4 ++++
 Framework/Core/src/DataProcessingDevice.cxx    |  1 +
 Framework/Core/src/DataRelayer.cxx             | 10 ++++++++--
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/DataRelayer.h b/Framework/Core/include/Framework/DataRelayer.h
index 012b909096317..1e010fc12f3d4 100644
--- a/Framework/Core/include/Framework/DataRelayer.h
+++ b/Framework/Core/include/Framework/DataRelayer.h
@@ -114,6 +114,9 @@ class DataRelayer
 
   using OnDropCallback = std::function<void(TimesliceSlot, std::vector<MessageSet>&, TimesliceIndex::OldestOutputInfo info)>;
 
+  // Callback for when some messages are about to be owned by the the DataRelayer
+  using OnInsertionCallback = std::function<void(ServiceRegistryRef&, std::span<fair::mq::MessagePtr>&)>;
+
   /// Prune all the pending entries in the cache.
   void prunePending(OnDropCallback);
   /// Prune the cache for a given slot
@@ -135,6 +138,7 @@ class DataRelayer
                     InputInfo const& info,
                     size_t nMessages,
                     size_t nPayloads = 1,
+                    OnInsertionCallback onInsertion = nullptr,
                     OnDropCallback onDrop = nullptr);
 
   /// This is to set the oldest possible @a timeslice this relayer can
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 3925359b056b2..343b567d8b852 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1859,6 +1859,7 @@ void DataProcessingDevice::handleData(ServiceRegistryRef ref, InputChannelInfo&
                                        input,
                                        nMessages,
                                        nPayloadsPerHeader,
+                                       nullptr,
                                        onDrop);
           switch (relayed.type) {
             case DataRelayer::RelayChoice::Type::Backpressured:
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 01e7a2b29fd35..ea2c4c0b73316 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -436,7 +436,8 @@ DataRelayer::RelayChoice
                      InputInfo const& info,
                      size_t nMessages,
                      size_t nPayloads,
-                     std::function<void(TimesliceSlot, std::vector<MessageSet>&, TimesliceIndex::OldestOutputInfo)> onDrop)
+                     OnInsertionCallback onInsertion,
+                     OnDropCallback onDrop)
 {
   std::scoped_lock<O2_LOCKABLE(std::recursive_mutex)> lock(mMutex);
   DataProcessingHeader const* dph = o2::header::get<DataProcessingHeader*>(rawHeader);
@@ -482,6 +483,7 @@ DataRelayer::RelayChoice
                      &messages,
                      &nMessages,
                      &nPayloads,
+                     &onInsertion,
                      &cache = mCache,
                      &services = mContext,
                      numInputTypes = mDistinctRoutesIndex.size()](TimesliceId timeslice, int input, TimesliceSlot slot, InputInfo const& info) -> size_t {
@@ -512,7 +514,11 @@ DataRelayer::RelayChoice
         mi += nPayloads;
         continue;
       }
-      target.add([&messages, &mi](size_t i) -> fair::mq::MessagePtr& { return messages[mi + i]; }, nPayloads + 1);
+      auto span = std::span<fair::mq::MessagePtr>(messages + mi, messages + mi + nPayloads + 1);
+      if (onInsertion) {
+        onInsertion(services, span);
+      }
+      target.add([&span](size_t i) -> fair::mq::MessagePtr& { return span[i]; }, nPayloads + 1);
       mi += nPayloads;
       saved += nPayloads;
     }

From 1afdd6c49095ffa5a6df708c439e282b9d640abd Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 14 Jan 2026 13:56:37 +0100
Subject: [PATCH 1199/1764] DPL: fix how many forwarded parts are needed

In principle this is not fatal because the number of routes is always
larger / equal than the number of channels by construction.

Better safe than sorry.
---
 Framework/Core/src/DataProcessingHelpers.cxx | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index 2f7a1f65f3bd3..87e7c9bf8962f 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -343,9 +343,7 @@ auto DataProcessingHelpers::routeForwardedMessageSet(FairMQDeviceProxy& proxy,
                                                      const bool copyByDefault, bool consume) -> std::vector<fair::mq::Parts>
 {
   // we collect all messages per forward in a map and send them together
-  std::vector<fair::mq::Parts> forwardedParts;
-  forwardedParts.resize(proxy.getNumForwards());
-  std::vector<ChannelIndex> forwardingChoices{};
+  std::vector<fair::mq::Parts> forwardedParts(proxy.getNumForwardChannels());
 
   for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
     auto span = std::span<fair::mq::MessagePtr>(currentSetOfInputs[ii].messages);

From 056504e47cb31862baef654a4d847aede982f93a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 14 Jan 2026 22:15:06 +0100
Subject: [PATCH 1200/1764] Fix ITS/MFT clusterization for some complex shapes,
 O2-6424.

---
 .../include/ITSMFTReconstruction/Clusterer.h  |  14 ++-
 .../common/reconstruction/src/Clusterer.cxx   | 117 +++++++++++-------
 2 files changed, 80 insertions(+), 51 deletions(-)

diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
index 960ce2ca33d5b..c66468905d0aa 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
@@ -121,6 +121,10 @@ class Clusterer
   };
 
   struct ClustererThread {
+    struct PreCluster {
+      int head = 0; // index of precluster head in the pixels
+      int index = 0;
+    };
     int id = -1;
     Clusterer* parent = nullptr; // parent clusterer
     // buffers for entries in preClusterIndices in 2 columns, to avoid boundary checks, we reserve
@@ -132,12 +136,11 @@ class Clusterer
     // pixels[].first is the index of the next pixel of the same precluster in the pixels
     // pixels[].second is the index of the referred pixel in the ChipPixelData (element of mChips)
     std::vector<std::pair<int, uint32_t>> pixels;
-    std::vector<int> preClusterHeads; // index of precluster head in the pixels
-    std::vector<int> preClusterIndices;
     uint16_t currCol = 0xffff;               ///< Column being processed
     bool noLeftCol = true;                   ///< flag that there is no column on the left to check
     std::array<Label, MaxLabels> labelsBuff; //! temporary buffer for building cluster labels
     std::vector<PixelData> pixArrBuff;       //! temporary buffer for pattern calc.
+    std::vector<PreCluster> preClusters;     //! preclusters info
     //
     /// temporary storage for the thread output
     CompClusCont compClusters;
@@ -154,7 +157,7 @@ class Clusterer
     ///< add cluster at row (entry ip in the ChipPixeData) to the precluster with given index
     void expandPreCluster(uint32_t ip, uint16_t row, int preClusIndex)
     {
-      auto& firstIndex = preClusterHeads[preClusterIndices[preClusIndex]];
+      auto& firstIndex = preClusters[preClusters[preClusIndex].index].head;
       pixels.emplace_back(firstIndex, ip);
       firstIndex = pixels.size() - 1;
       curr[row] = preClusIndex;
@@ -163,11 +166,10 @@ class Clusterer
     ///< add new precluster at given row of current column for the fired pixel with index ip in the ChipPixelData
     void addNewPrecluster(uint32_t ip, uint16_t row)
     {
-      preClusterHeads.push_back(pixels.size());
+      int lastIndex = preClusters.size();
+      preClusters.emplace_back(pixels.size(), lastIndex);
       // new head does not point yet (-1) on other pixels, store just the entry of the pixel in the ChipPixelData
       pixels.emplace_back(-1, ip);
-      int lastIndex = preClusterIndices.size();
-      preClusterIndices.push_back(lastIndex);
       curr[row] = lastIndex; // store index of the new precluster in the current column buffer
     }
 
diff --git a/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx b/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
index 15dcc67a8967b..42e535e810a62 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
@@ -133,15 +133,17 @@ void Clusterer::process(int nThreads, PixelReader& reader, CompClusCont* compClu
           if (stat.firstChip == chid) {
             thrStatIdx[ith]++;
             chid += stat.nChips; // next chip to look
-            const auto clbeg = mThreads[ith]->compClusters.begin() + stat.firstClus;
-            auto szold = compClus->size();
-            compClus->insert(compClus->end(), clbeg, clbeg + stat.nClus);
-            if (patterns) {
-              const auto ptbeg = mThreads[ith]->patterns.begin() + stat.firstPatt;
-              patterns->insert(patterns->end(), ptbeg, ptbeg + stat.nPatt);
-            }
-            if (labelsCl) {
-              labelsCl->mergeAtBack(mThreads[ith]->labels, stat.firstClus, stat.nClus);
+            if (stat.nClus > 0) {
+              const auto clbeg = mThreads[ith]->compClusters.begin() + stat.firstClus;
+              auto szold = compClus->size();
+              compClus->insert(compClus->end(), clbeg, clbeg + stat.nClus);
+              if (patterns) {
+                const auto ptbeg = mThreads[ith]->patterns.begin() + stat.firstPatt;
+                patterns->insert(patterns->end(), ptbeg, ptbeg + stat.nPatt);
+              }
+              if (labelsCl) {
+                labelsCl->mergeAtBack(mThreads[ith]->labels, stat.firstClus, stat.nClus);
+              }
             }
           }
         }
@@ -214,14 +216,22 @@ void Clusterer::ClustererThread::finishChip(ChipPixelData* curChipData, CompClus
                                             PatternCont* patternsPtr, const ConstMCTruth* labelsDigPtr, MCTruth* labelsClusPtr)
 {
   const auto& pixData = curChipData->getData();
-  for (int i1 = 0; i1 < preClusterHeads.size(); ++i1) {
-    auto ci = preClusterIndices[i1];
+  int nPreclusters = preClusters.size();
+  // account for the eventual reindexing of preClusters: Id2 might have been reindexed to Id1, which later was reindexed to Id0
+  for (int i = 1; i < nPreclusters; i++) {
+    if (preClusters[i].index != i) { // reindexing is always done towards smallest index
+      preClusters[i].index = preClusters[preClusters[i].index].index;
+    }
+  }
+  for (int i1 = 0; i1 < nPreclusters; ++i1) {
+    auto& preCluster = preClusters[i1];
+    auto ci = preCluster.index;
     if (ci < 0) {
       continue;
     }
     BBox bbox(curChipData->getChipID());
     int nlab = 0;
-    int next = preClusterHeads[i1];
+    int next = preCluster.head;
     pixArrBuff.clear();
     while (next >= 0) {
       const auto& pixEntry = pixels[next];
@@ -237,12 +247,13 @@ void Clusterer::ClustererThread::finishChip(ChipPixelData* curChipData, CompClus
       }
       next = pixEntry.first;
     }
-    preClusterIndices[i1] = -1;
-    for (int i2 = i1 + 1; i2 < preClusterHeads.size(); ++i2) {
-      if (preClusterIndices[i2] != ci) {
+    preCluster.index = -1;
+    for (int i2 = i1 + 1; i2 < nPreclusters; ++i2) {
+      auto& preCluster2 = preClusters[i2];
+      if (preCluster2.index != ci) {
         continue;
       }
-      next = preClusterHeads[i2];
+      next = preCluster2.head;
       while (next >= 0) {
         const auto& pixEntry = pixels[next];
         const auto pix = pixData[pixEntry.second]; // PixelData
@@ -257,7 +268,7 @@ void Clusterer::ClustererThread::finishChip(ChipPixelData* curChipData, CompClus
         }
         next = pixEntry.first;
       }
-      preClusterIndices[i2] = -1;
+      preCluster2.index = -1;
     }
     if (bbox.isAcceptableSize()) {
       parent->streamCluster(pixArrBuff, &labelsBuff, bbox, parent->mPattIdConverter, compClusPtr, patternsPtr, labelsClusPtr, nlab);
@@ -344,18 +355,15 @@ void Clusterer::ClustererThread::initChip(const ChipPixelData* curChipData, uint
   prev = column1 + 1;
   curr = column2 + 1;
   resetColumn(curr);
-
   pixels.clear();
-  preClusterHeads.clear();
-  preClusterIndices.clear();
+  preClusters.clear();
   auto pix = curChipData->getData()[first];
   currCol = pix.getCol();
   curr[pix.getRowDirect()] = 0; // can use getRowDirect since the pixel is not masked
   // start the first pre-cluster
-  preClusterHeads.push_back(0);
-  preClusterIndices.push_back(0);
+  preClusters.emplace_back();
   pixels.emplace_back(-1, first); // id of current pixel
-  noLeftCol = true;               // flag that there is no column on the left to check yet
+  noLeftCol = true;
 }
 
 //__________________________________________________
@@ -378,39 +386,58 @@ void Clusterer::ClustererThread::updateChip(const ChipPixelData* curChipData, ui
     currCol = pix.getCol();
   }
 
-  Bool_t orphan = true;
-
   if (noLeftCol) { // check only the row above
     if (curr[row - 1] >= 0) {
       expandPreCluster(ip, row, curr[row - 1]); // attach to the precluster of the previous row
-      return;
+    } else {
+      addNewPrecluster(ip, row); // start new precluster
     }
   } else {
+    // row above should be always checked
+    int nnb = 0, lowestIndex = curr[row - 1], lowestNb = 0, *nbrCol[4], nbrRow[4];
+    if (lowestIndex >= 0) {
+      nbrCol[nnb] = curr;
+      nbrRow[nnb++] = row - 1;
+    } else {
+      lowestIndex = 0x7ffff;
+      lowestNb = -1;
+    }
 #ifdef _ALLOW_DIAGONAL_ALPIDE_CLUSTERS_
-    int neighbours[]{curr[row - 1], prev[row], prev[row + 1], prev[row - 1]};
-#else
-    int neighbours[]{curr[row - 1], prev[row]};
-#endif
-    for (auto pci : neighbours) {
-      if (pci < 0) {
-        continue;
+    for (int i : {-1, 0, 1}) {
+      auto v = prev[row + i];
+      if (v >= 0) {
+        nbrCol[nnb] = prev;
+        nbrRow[nnb] = row + i;
+        if (v < lowestIndex) {
+          lowestIndex = v;
+          lowestNb = nnb;
+        }
+        nnb++;
       }
-      if (orphan) {
-        expandPreCluster(ip, row, pci); // attach to the adjascent precluster
-        orphan = false;
-        continue;
+    }
+#else
+    if (prev[row] >= 0) {
+      nbrCol[nnb] = prev;
+      nbrRow[nnb] = row;
+      if (prev[row] < lowestIndex) {
+        lowestIndex = v;
+        lowestNb = nnb;
       }
-      // reassign precluster index to smallest one
-      if (preClusterIndices[pci] < preClusterIndices[curr[row]]) {
-        preClusterIndices[curr[row]] = preClusterIndices[pci];
-      } else {
-        preClusterIndices[pci] = preClusterIndices[curr[row]];
+      nnb++;
+    }
+#endif
+    if (!nnb) {                  // no neighbours, create new precluster
+      addNewPrecluster(ip, row); // start new precluster
+    } else {
+      expandPreCluster(ip, row, lowestIndex); // attach to the adjascent precluster with smallest index
+      if (nnb > 1) {
+        for (int inb = 0; inb < nnb; inb++) { // reassign precluster index to smallest one, replicating updated values to columns caches
+          auto& prevIndex = (nbrCol[inb])[nbrRow[inb]];
+          prevIndex = preClusters[prevIndex].index = lowestIndex;
+        }
       }
     }
   }
-  if (orphan) {
-    addNewPrecluster(ip, row); // start new precluster
-  }
 }
 
 //__________________________________________________

From eb3d49c31d23bd8d0c523ae7916c9ad5ba0d081c Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 14 Jan 2026 09:27:55 +0100
Subject: [PATCH 1201/1764] DPL Analysis: do not override error-handler reader
 for MC injected workflows

---
 Framework/Core/src/ArrowSupport.cxx | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index c0280b144e146..c403d983325dc 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -684,8 +684,10 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
           workflow.erase(reader);
         } else {
           // load reader algorithm before deployment
-          auto&& algo = PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx);
-          reader->algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(algo);
+          auto mctracks2aod = std::find_if(workflow.begin(), workflow.end(), [](auto const& x) { return x.name == "mctracks-to-aod"; });
+          if (mctracks2aod == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
+            reader->algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx));
+          } // otherwise the algorithm was set in injectServiceDevices
         }
       }
 

From 5cce90740c429898ff787e978e3f24573161ed9e Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Wed, 14 Jan 2026 13:21:42 +0100
Subject: [PATCH 1202/1764] Fix embedding test

---
 prodtests/full_system_test.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index a799afbbbfd3d..8ee8b5992b846 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -71,7 +71,7 @@ else
 fi
 FST_MC_ENGINE=${FST_MC_ENGINE:-TGeant4}
 FST_EMBEDDING_CONFIG=${FST_EMBEDDING_CONFIG:-GeneratorPythia8.config=$O2_ROOT/prodtests/full-system-test/pythia8.cfg}
-DO_EMBEDDING=${DO_EMBEDDING:-0}
+DO_EMBEDDING=${DO_EMBEDDING:-1}
 if [[ $DO_EMBEDDING == 0 ]]; then
   SIM_SOURCES="o2sim"
 else
@@ -139,7 +139,7 @@ fi
 
 taskwrapper sim.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} --seed $O2SIMSEED -n $NEvents --configKeyValues "\"$SIMOPTKEY\"" -g ${FST_GENERATOR} -e ${FST_MC_ENGINE} -j $NJOBS --run ${RUNNUMBER} -o o2sim
 if [[ $DO_EMBEDDING == 1 ]]; then
-  taskwrapper embed.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} -j $NJOBS --run ${RUNNUMBER} -n $NEvents -g pythia8pp -e ${FST_MC_ENGINE} -o sig --configKeyValues ${FST_EMBEDDING_CONFIG} --embedIntoFile o2sim_Kine.root
+  taskwrapper embed.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} -j $NJOBS --run ${RUNNUMBER} -n $NEvents -g pythia8pp -e ${FST_MC_ENGINE} -o sig --configKeyValues ${FST_EMBEDDING_CONFIG} --embedIntoFile o2sim_MCHeader.root
 fi
 taskwrapper digi.log o2-sim-digitizer-workflow -n $NEvents ${DIGIQED} ${NOMCLABELS} --sims ${SIM_SOURCES} --tpc-lanes $((NJOBS < 36 ? NJOBS : 36)) --shm-segment-size $SHMSIZE ${GLOBALDPLOPT} ${DIGITOPT} --configKeyValues "\"${DIGITOPTKEY}\"" --interactionRate $FST_COLRATE --early-forward-policy always
 [[ $SPLITTRDDIGI == "1" ]] && taskwrapper digiTRD.log o2-sim-digitizer-workflow -n $NEvents ${NOMCLABELS} --sims ${SIM_SOURCES} --onlyDet TRD --trd-digit-downscaling ${DIGITDOWNSCALINGTRD} --shm-segment-size $SHMSIZE ${GLOBALDPLOPT} --incontext collisioncontext.root --configKeyValues "\"${DIGITOPTKEYTRD}\"" --early-forward-policy always

From 8c0bd3ce631100e5ee0bdc61e5d430ef1110cc29 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Thu, 15 Jan 2026 13:27:17 +0100
Subject: [PATCH 1203/1764] Switch off default embedding

---
 prodtests/full_system_test.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 8ee8b5992b846..bf235a500cd8b 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -71,7 +71,7 @@ else
 fi
 FST_MC_ENGINE=${FST_MC_ENGINE:-TGeant4}
 FST_EMBEDDING_CONFIG=${FST_EMBEDDING_CONFIG:-GeneratorPythia8.config=$O2_ROOT/prodtests/full-system-test/pythia8.cfg}
-DO_EMBEDDING=${DO_EMBEDDING:-1}
+DO_EMBEDDING=${DO_EMBEDDING:-0}
 if [[ $DO_EMBEDDING == 0 ]]; then
   SIM_SOURCES="o2sim"
 else

From 34d96168b97ba4c073585eafdcd3c9c93b271f8d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 15 Jan 2026 14:43:39 +0100
Subject: [PATCH 1204/1764] DPL Analysis: fix for slice index builder resetting
 its caches in a wrong order

---
 Framework/Core/src/IndexBuilderHelpers.cxx | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/IndexBuilderHelpers.cxx b/Framework/Core/src/IndexBuilderHelpers.cxx
index d7231f72cbee8..0943dea42169c 100644
--- a/Framework/Core/src/IndexBuilderHelpers.cxx
+++ b/Framework/Core/src/IndexBuilderHelpers.cxx
@@ -161,14 +161,14 @@ SliceBuilder::SliceBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::M
 
 void SliceBuilder::reset(std::shared_ptr<arrow::ChunkedArray> source)
 {
+  mValues = nullptr;
+  mCounts = nullptr;
+  mListBuilder->Reset();
+  mValuePos = 0;
   static_cast<ChunkedArrayIterator*>(this)->reset(source);
   if (!preSlice().ok()) {
     throw framework::runtime_error("Cannot pre-slice the source for slice-index building");
   }
-  mListBuilder->Reset();
-  mValues = nullptr;
-  mCounts = nullptr;
-  mValuePos = 0;
 }
 
 bool SliceBuilder::find(int idx)

From 7245d49faf8a6e7cfd29d81a44f6cda5b52dfa2b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Wiktor=20Piero=C5=BCak?=
 <94726725+wpierozak@users.noreply.github.com>
Date: Thu, 15 Jan 2026 17:11:35 +0100
Subject: [PATCH 1205/1764] AFIT-1 FV0 digitzer dead channel map (#14908)

* FIT: added DeadChannelMap to FV0 Digitzier
* FIT: changed default value of disable-dead-channel-map option for FV0 digitizer to false
* FIT: included CCDBParamSpec.h in FV0DigitizerSpec.cxx
* FIT: Fixed typo in FV0DigitizerSpec.cxx
* FIT: change inputs to FV0 digitizer
---
 .../include/FV0Simulation/Digitizer.h         |  4 +++
 .../FIT/FV0/simulation/src/Digitizer.cxx      |  5 ++++
 .../src/FV0DigitizerSpec.cxx                  | 30 ++++++++++++++++---
 3 files changed, 35 insertions(+), 4 deletions(-)

diff --git a/Detectors/FIT/FV0/simulation/include/FV0Simulation/Digitizer.h b/Detectors/FIT/FV0/simulation/include/FV0Simulation/Digitizer.h
index 6956d8126ce53..b97893822c9d8 100644
--- a/Detectors/FIT/FV0/simulation/include/FV0Simulation/Digitizer.h
+++ b/Detectors/FIT/FV0/simulation/include/FV0Simulation/Digitizer.h
@@ -14,6 +14,7 @@
 
 #include "CommonDataFormat/InteractionRecord.h"
 #include "DataFormatsFV0/Digit.h"
+#include "DataFormatsFIT/DeadChannelMap.h"
 #include "DataFormatsFV0/ChannelData.h"
 #include "DataFormatsFV0/MCLabel.h"
 #include "FV0Simulation/Detector.h"
@@ -51,6 +52,7 @@ class Digitizer
   void setEventId(Int_t id) { mEventId = id; }
   void setSrcId(Int_t id) { mSrcId = id; }
   void setInteractionRecord(const InteractionTimeRecord& ir) { mIntRecord = ir; }
+  void setDeadChannelMap(o2::fit::DeadChannelMap const* deadChannelMap) { mDeadChannelMap = deadChannelMap; };
 
   void process(const std::vector<o2::fv0::Hit>& hits, std::vector<o2::fv0::Digit>& digitsBC,
                std::vector<o2::fv0::ChannelData>& digitsCh, std::vector<o2::fv0::DetTrigInput>& digitsTrig,
@@ -132,6 +134,8 @@ class Digitizer
   BCCache mLastBCCache;                                    // buffer for the last BC
   std::array<int, Constants::nFv0Channels> mCfdStartIndex; // start indices for the CFD detector
 
+  o2::fit::DeadChannelMap const* mDeadChannelMap = nullptr;
+
   /// Internal helper methods related to conversion of energy-deposition into el. signal
   Int_t SimulateLightYield(Int_t pmt, Int_t nPhot) const;
   Float_t SimulateTimeCfd(int& startIndex, const ChannelDigitF& pulseLast, const ChannelDigitF& pulse) const;
diff --git a/Detectors/FIT/FV0/simulation/src/Digitizer.cxx b/Detectors/FIT/FV0/simulation/src/Digitizer.cxx
index 1c94b14f029cf..8c1d2dc8824e2 100644
--- a/Detectors/FIT/FV0/simulation/src/Digitizer.cxx
+++ b/Detectors/FIT/FV0/simulation/src/Digitizer.cxx
@@ -98,6 +98,11 @@ void Digitizer::process(const std::vector<o2::fv0::Hit>& hits,
   for (auto ids : hitIdx) {
     const auto& hit = hits[ids];
     Int_t detId = hit.GetDetectorID();
+
+    if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(detId)) {
+      continue;
+    }
+
     Double_t hitEdep = hit.GetHitValue() * 1e3;  // convert to MeV
     Float_t const hitTime = hit.GetTime() * 1e9; // convert to ns
     // TODO: check how big is inaccuracy if more than 1 'below-threshold' particles hit the same detector cell
diff --git a/Steer/DigitizerWorkflow/src/FV0DigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/FV0DigitizerSpec.cxx
index 28f259c11162b..8197b1be1847b 100644
--- a/Steer/DigitizerWorkflow/src/FV0DigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/FV0DigitizerSpec.cxx
@@ -11,6 +11,7 @@
 
 #include "FV0DigitizerSpec.h"
 #include "DataFormatsFV0/ChannelData.h"
+#include "DataFormatsFIT/DeadChannelMap.h"
 #include "DataFormatsFV0/Digit.h"
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
@@ -30,6 +31,7 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "DetectorsBase/BaseDPLDigitizer.h"
 #include "DetectorsRaw/HBFUtils.h"
+#include "Framework/CCDBParamSpec.h"
 #include <TFile.h>
 
 using namespace o2::framework;
@@ -53,6 +55,16 @@ class FV0DPLDigitizerTask : public o2::base::BaseDPLDigitizer
     LOG(debug) << "FV0DPLDigitizerTask:init";
     mDigitizer.init();
     mDisableQED = ic.options().get<bool>("disable-qed"); //TODO: QED implementation to be tested
+    mUseDeadChannelMap = !ic.options().get<bool>("disable-dead-channel-map");
+    mUpdateDeadChannelMap = mUseDeadChannelMap;
+  }
+
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+  {
+    // Initialize the dead channel map only once
+    if (matcher == ConcreteDataMatcher("FV0", "DeadChannelMap", 0)) {
+      mUpdateDeadChannelMap = false;
+    }
   }
 
   void run(framework::ProcessingContext& pc)
@@ -67,6 +79,11 @@ class FV0DPLDigitizerTask : public o2::base::BaseDPLDigitizer
     context->initSimChains(o2::detectors::DetID::FV0, mSimChains);
     const bool withQED = context->isQEDProvided() && !mDisableQED; //TODO: QED implementation to be tested
 
+    if (mUseDeadChannelMap && mUpdateDeadChannelMap) {
+      auto deadChannelMap = pc.inputs().get<o2::fit::DeadChannelMap*>("fv0deadchannelmap");
+      mDigitizer.setDeadChannelMap(deadChannelMap.get());
+    }
+
     mDigitizer.setTimeStamp(context->getGRP().getTimeStart());
 
     auto& irecords = context->getEventRecords(withQED); //TODO: QED implementation to be tested
@@ -131,6 +148,8 @@ class FV0DPLDigitizerTask : public o2::base::BaseDPLDigitizer
 
  private:
   bool mFinished = false;
+  bool mUseDeadChannelMap = true;
+  bool mUpdateDeadChannelMap = true;
   Digitizer mDigitizer;
   std::vector<TChain*> mSimChains;
   std::vector<o2::fv0::ChannelData> mDigitsCh;
@@ -159,16 +178,19 @@ o2::framework::DataProcessorSpec getFV0DigitizerSpec(int channel, bool mctruth)
   }
   outputs.emplace_back("FV0", "ROMode", 0, Lifetime::Timeframe);
 
+  std::vector<InputSpec> inputs;
+  inputs.emplace_back("fv0deadchannelmap", "FV0", "DeadChannelMap", 0, Lifetime::Condition, ccdbParamSpec("FV0/Calib/DeadChannelMap"));
+  inputs.emplace_back("collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe);
   return DataProcessorSpec{
     "FV0Digitizer",
-    Inputs{InputSpec{"collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe}},
-
+    inputs,
     outputs,
 
     AlgorithmSpec{adaptFromTask<FV0DPLDigitizerTask>()},
     Options{{"pileup", VariantType::Int, 1, {"whether to run in continuous time mode"}},
-            {"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
-  //Options{{"pileup", VariantType::Int, 1, {"whether to run in continuous time mode"}}}};
+            {"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}},
+            {"disable-dead-channel-map", o2::framework::VariantType::Bool, false, {"Don't mask dead channels"}}}};
+  // Options{{"pileup", VariantType::Int, 1, {"whether to run in continuous time mode"}}}};
 }
 
 } // end namespace fv0

From 7aa1bbc3f97df804c61ce31f0aeed65d81e520b7 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 15 Jan 2026 19:45:39 +0100
Subject: [PATCH 1206/1764] DPL Analysis: Rework table input record extraction
 (#14944)

---
 .../src/AODJAlienReaderHelpers.cxx            | 23 -------
 .../AnalysisSupport/src/AODReaderHelpers.cxx  | 25 +++++---
 .../AnalysisSupport/src/AODWriterHelpers.cxx  |  7 +--
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   |  5 +-
 Framework/Core/include/Framework/ASoA.h       | 63 ++++++++++++++++---
 .../Core/include/Framework/AnalysisHelpers.h  |  7 ++-
 .../Core/include/Framework/AnalysisManagers.h |  8 +--
 .../Core/include/Framework/AnalysisTask.h     |  8 +--
 .../Framework/ArrowTableSlicingCache.h        | 13 +++-
 .../include/Framework/ConcreteDataMatcher.h   |  6 +-
 .../Core/include/Framework/DataSpecUtils.h    |  6 ++
 .../Core/include/Framework/DataSpecViews.h    |  7 +++
 .../Core/include/Framework/GroupSlicer.h      |  2 +-
 .../Core/include/Framework/InputRecord.h      | 22 +++++++
 Framework/Core/src/AnalysisHelpers.cxx        | 10 +--
 Framework/Core/src/ArrowSupport.cxx           |  4 +-
 Framework/Core/src/ArrowTableSlicingCache.cxx | 21 ++++---
 Framework/Core/src/DataSpecUtils.cxx          | 34 +++++++++-
 Framework/Core/src/IndexJSONHelpers.cxx       | 12 +++-
 Framework/Core/src/InputRecord.cxx            |  5 ++
 Framework/Core/test/benchmark_EventMixing.cxx |  6 +-
 Framework/Core/test/test_ASoA.cxx             |  5 +-
 Framework/Core/test/test_GroupSlicer.cxx      | 33 ++++++----
 Framework/TestWorkflows/CMakeLists.txt        |  4 ++
 .../TestWorkflows/src/o2TestHistograms.cxx    |  6 +-
 .../TestWorkflows/src/o2TestMultisource.cxx   | 47 ++++++++++++++
 26 files changed, 286 insertions(+), 103 deletions(-)
 create mode 100644 Framework/TestWorkflows/src/o2TestMultisource.cxx

diff --git a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
index b532c51b8d307..cde6c85f2c624 100644
--- a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
@@ -98,29 +98,6 @@ using o2::monitoring::tags::Value;
 
 namespace o2::framework::readers
 {
-auto setEOSCallback(InitContext& ic)
-{
-  ic.services().get<CallbackService>().set<CallbackService::Id::EndOfStream>(
-    [](EndOfStreamContext& eosc) {
-      auto& control = eosc.services().get<ControlService>();
-      control.endOfStream();
-      control.readyToQuit(QuitRequest::Me);
-    });
-}
-
-template <typename O>
-static inline auto extractTypedOriginal(ProcessingContext& pc)
-{
-  /// FIXME: this should be done in invokeProcess() as some of the originals may be compound tables
-  return O{pc.inputs().get<TableConsumer>(aod::MetadataTrait<O>::metadata::tableLabel())->asArrowTable()};
-}
-
-template <typename... Os>
-static inline auto extractOriginalsTuple(framework::pack<Os...>, ProcessingContext& pc)
-{
-  return std::make_tuple(extractTypedOriginal<Os>(pc)...);
-}
-
 AlgorithmSpec AODJAlienReaderHelpers::rootFileReaderCallback(ConfigContext const& ctx)
 {
   // aod-parent-base-path-replacement is now a workflow option, so it needs to be
diff --git a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
index 7f08dd0b36a64..485f3fa69edad 100644
--- a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
@@ -18,6 +18,7 @@
 #include "Framework/DataProcessingHelpers.h"
 #include "Framework/AlgorithmSpec.h"
 #include "Framework/DataSpecUtils.h"
+#include "Framework/DataSpecViews.h"
 #include "Framework/ConfigContext.h"
 #include "Framework/DanglingEdgesContext.h"
 
@@ -29,6 +30,7 @@ struct Buildable {
   bool exclusive = false;
   std::string binding;
   std::vector<std::string> labels;
+  std::vector<framework::ConcreteDataMatcher> matchers;
   header::DataOrigin origin;
   header::DataDescription description;
   header::DataHeader::SubSpecificationType version;
@@ -52,6 +54,7 @@ struct Buildable {
 
     for (auto const& r : records) {
       labels.emplace_back(r.label);
+      matchers.emplace_back(r.matcher);
     }
     outputSchema = std::make_shared<arrow::Schema>([](std::vector<o2::soa::IndexRecord> const& recs) {
                      std::vector<std::shared_ptr<arrow::Field>> fields;
@@ -68,6 +71,7 @@ struct Buildable {
     return {
       exclusive,
       labels,
+      matchers,
       records,
       outputSchema,
       origin,
@@ -105,6 +109,7 @@ namespace
 struct Spawnable {
   std::string binding;
   std::vector<std::string> labels;
+  std::vector<framework::ConcreteDataMatcher> matchers;
   std::vector<expressions::Projector> projectors;
   std::vector<std::shared_ptr<gandiva::Expression>> expressions;
   std::shared_ptr<arrow::Schema> outputSchema;
@@ -132,14 +137,17 @@ struct Spawnable {
     o2::framework::addLabelToSchema(outputSchema, binding.c_str());
 
     std::vector<std::shared_ptr<arrow::Schema>> schemas;
-    for (auto& i : spec.metadata) {
-      if (i.name.starts_with("input-schema:")) {
-        labels.emplace_back(i.name.substr(13));
-        iws.clear();
-        auto json = i.defaultValue.get<std::string>();
-        iws.str(json);
-        schemas.emplace_back(ArrowJSONHelpers::read(iws));
-      }
+    for (auto const& i : spec.metadata | views::filter_string_params_starts_with("input-schema:")) {
+      labels.emplace_back(i.name.substr(13));
+      iws.clear();
+      auto json = i.defaultValue.get<std::string>();
+      iws.str(json);
+      schemas.emplace_back(ArrowJSONHelpers::read(iws));
+    }
+    for (auto const& i : spec.metadata | views::filter_string_params_starts_with("input:") | std::ranges::views::transform([](auto const& param) {
+                           return DataSpecUtils::fromMetadataString(param.defaultValue.template get<std::string>());
+                         })) {
+      matchers.emplace_back(std::get<ConcreteDataMatcher>(i.matcher));
     }
 
     std::vector<std::shared_ptr<arrow::Field>> fields;
@@ -169,6 +177,7 @@ struct Spawnable {
     return {
       binding,
       labels,
+      matchers,
       expressions,
       makeProjector(),
       outputSchema,
diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index 5a43683afd364..d868b7498fb76 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -185,13 +185,12 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
         }
 
         // get the TableConsumer and corresponding arrow table
-        auto msg = pc.inputs().get(ref.spec->binding);
-        if (msg.header == nullptr) {
+        if (ref.header == nullptr) {
           LOGP(error, "No header for message {}:{}", ref.spec->binding, DataSpecUtils::describe(*ref.spec));
           continue;
         }
-        auto s = pc.inputs().get<TableConsumer>(ref.spec->binding);
-        auto table = s->asArrowTable();
+
+        auto table = pc.inputs().get<TableConsumer>(std::get<ConcreteDataMatcher>(ref.spec->matcher))->asArrowTable();
         if (!table->Validate().ok()) {
           LOGP(warning, "The table \"{}\" is not valid and will not be saved!", tableName);
           continue;
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index fcc856669cd92..9ec911518f754 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -83,6 +83,7 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
       if (m.name.starts_with("input:")) {
         auto name = m.name.substr(6);
         schemaMetadata->Append("sourceTable", name);
+        schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
         continue;
       }
       // Ignore the non ccdb: entries
@@ -109,13 +110,13 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
       for (auto& schema : schemas) {
         std::vector<CCDBFetcherHelper::FetchOp> ops;
         auto inputBinding = *schema->metadata()->Get("sourceTable");
+        auto inputMatcher = DataSpecUtils::fromString(*schema->metadata()->Get("sourceMatcher"));
         auto outRouteDesc = *schema->metadata()->Get("outputRoute");
         std::string outBinding = *schema->metadata()->Get("outputBinding");
         O2_SIGNPOST_EVENT_EMIT_INFO(ccdb, sid, "fetchFromAnalysisCCDB",
                                     "Fetching CCDB objects for %{public}s's columns with timestamps from %{public}s and putting them in route %{public}s",
                                     outBinding.c_str(), inputBinding.c_str(), outRouteDesc.c_str());
-        auto ref = inputs.get<TableConsumer>(inputBinding);
-        auto table = ref->asArrowTable();
+        auto table = inputs.get<TableConsumer>(inputMatcher)->asArrowTable();
         // FIXME: make the fTimestamp column configurable.
         auto timestampColumn = table->GetColumnByName("fTimestamp");
         O2_SIGNPOST_EVENT_EMIT_INFO(ccdb, sid, "fetchFromAnalysisCCDB",
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 43079a4634e97..ec02c7e47132b 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -12,6 +12,7 @@
 #ifndef O2_FRAMEWORK_ASOA_H_
 #define O2_FRAMEWORK_ASOA_H_
 
+#include "Framework/ConcreteDataMatcher.h"
 #include "Framework/Pack.h"                   // IWYU pragma: export
 #include "Framework/FunctionalHelpers.h"      // IWYU pragma: export
 #include "Headers/DataHeader.h"               // IWYU pragma: export
@@ -375,6 +376,12 @@ consteval const char* signature()
   return o2::aod::Hash<R.desc_hash>::str;
 }
 
+template <soa::TableRef R>
+constexpr framework::ConcreteDataMatcher matcher()
+{
+  return {origin<R>(), description(signature<R>()), R.version};
+}
+
 /// hash identification concepts
 template <typename T>
 concept is_aod_hash = requires(T t) { t.hash; t.str; };
@@ -1393,6 +1400,12 @@ static constexpr std::pair<bool, std::string> hasKey(std::string const& key)
   return {hasColumnForKey(typename aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::columns{}, key), aod::label<ref>()};
 }
 
+template <TableRef ref>
+static constexpr std::pair<bool, framework::ConcreteDataMatcher> hasKeyM(std::string const& key)
+{
+  return {hasColumnForKey(typename aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::columns{}, key), aod::matcher<ref>()};
+}
+
 template <typename... C>
 static constexpr auto haveKey(framework::pack<C...>, std::string const& key)
 {
@@ -1427,6 +1440,31 @@ static constexpr std::string getLabelFromTypeForKey(std::string const& key)
   O2_BUILTIN_UNREACHABLE();
 }
 
+template <with_originals T, bool OPT = false>
+static constexpr framework::ConcreteDataMatcher getMatcherFromTypeForKey(std::string const& key)
+{
+  if constexpr (T::originals.size() == 1) {
+    auto locate = hasKeyM<T::originals[0]>(key);
+    if (locate.first) {
+      return locate.second;
+    }
+  } else {
+    auto locate = [&]<size_t... Is>(std::index_sequence<Is...>) {
+      return std::vector{hasKeyM<T::originals[Is]>(key)...};
+    }(std::make_index_sequence<T::originals.size()>{});
+    auto it = std::find_if(locate.begin(), locate.end(), [](auto const& x) { return x.first; });
+    if (it != locate.end()) {
+      return it->second;
+    }
+  }
+  if constexpr (!OPT) {
+    notFoundColumn(getLabelFromType<std::decay_t<T>>().data(), key.data());
+  } else {
+    return framework::ConcreteDataMatcher{header::DataOrigin{"AOD"}, header::DataDescription{"[MISSING]"}, 0};
+  }
+  O2_BUILTIN_UNREACHABLE();
+}
+
 template <typename B, typename... C>
 consteval static bool hasIndexTo(framework::pack<C...>&&)
 {
@@ -1477,7 +1515,10 @@ struct PreslicePolicyGeneral : public PreslicePolicyBase {
   std::span<const int64_t> getSliceFor(int value) const;
 };
 
-template <typename T, typename Policy, bool OPT = false>
+template <typename T>
+concept is_preslice_policy = std::derived_from<T, PreslicePolicyBase>;
+
+template <typename T, is_preslice_policy Policy, bool OPT = false>
 struct PresliceBase : public Policy {
   constexpr static bool optional = OPT;
   using target_t = T;
@@ -1485,7 +1526,7 @@ struct PresliceBase : public Policy {
   const std::string binding;
 
   PresliceBase(expressions::BindingNode index_)
-    : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, Entry(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
+    : Policy{PreslicePolicyBase{{o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name})}, Entry(o2::soa::getLabelFromTypeForKey<T, OPT>(std::string{index_.name}), o2::soa::getMatcherFromTypeForKey<T, OPT>(std::string{index_.name}), std::string{index_.name})}, {}}
   {
   }
 
@@ -1520,7 +1561,11 @@ template <typename T>
 using PresliceOptional = PresliceBase<T, PreslicePolicySorted, true>;
 
 template <typename T>
-concept is_preslice = std::derived_from<T, PreslicePolicyBase>;
+concept is_preslice = std::derived_from<T, PreslicePolicyBase>&&
+  requires(T)
+{
+  T::optional;
+};
 
 /// Can be user to group together a number of Preslice declaration
 /// to avoid the limit of 100 data members per task
@@ -1667,10 +1712,10 @@ auto doFilteredSliceBy(T const* table, o2::framework::PresliceBase<C, framework:
   return prepareFilteredSlice(table, slice, offset);
 }
 
-template <typename T>
+template <soa::is_table T>
 auto doSliceByCached(T const* table, framework::expressions::BindingNode const& node, int value, o2::framework::SliceCache& cache)
 {
-  auto localCache = cache.ptr->getCacheFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
+  auto localCache = cache.ptr->getCacheFor({"", o2::soa::getMatcherFromTypeForKey<T>(node.name), node.name});
   auto [offset, count] = localCache.getSliceFor(value);
   auto t = typename T::self_t({table->asArrowTable()->Slice(static_cast<uint64_t>(offset), count)}, static_cast<uint64_t>(offset));
   if (t.tableSize() != 0) {
@@ -1679,19 +1724,19 @@ auto doSliceByCached(T const* table, framework::expressions::BindingNode const&
   return t;
 }
 
-template <typename T>
+template <soa::is_filtered_table T>
 auto doFilteredSliceByCached(T const* table, framework::expressions::BindingNode const& node, int value, o2::framework::SliceCache& cache)
 {
-  auto localCache = cache.ptr->getCacheFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
+  auto localCache = cache.ptr->getCacheFor({"", o2::soa::getMatcherFromTypeForKey<T>(node.name), node.name});
   auto [offset, count] = localCache.getSliceFor(value);
   auto slice = table->asArrowTable()->Slice(static_cast<uint64_t>(offset), count);
   return prepareFilteredSlice(table, slice, offset);
 }
 
-template <typename T>
+template <soa::is_table T>
 auto doSliceByCachedUnsorted(T const* table, framework::expressions::BindingNode const& node, int value, o2::framework::SliceCache& cache)
 {
-  auto localCache = cache.ptr->getCacheUnsortedFor({o2::soa::getLabelFromTypeForKey<T>(node.name), node.name});
+  auto localCache = cache.ptr->getCacheUnsortedFor({"", o2::soa::getMatcherFromTypeForKey<T>(node.name), node.name});
   if constexpr (soa::is_filtered_table<T>) {
     auto t = typename T::self_t({table->asArrowTable()}, localCache.getSliceFor(value));
     if (t.tableSize() != 0) {
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 3666fe1299489..a01d14b6632a9 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -30,6 +30,7 @@ namespace o2::soa
 {
 struct IndexRecord {
   std::string label;
+  framework::ConcreteDataMatcher matcher;
   std::string columnLabel;
   IndexKind kind;
   int pos;
@@ -142,6 +143,7 @@ std::vector<std::shared_ptr<arrow::Table>> extractSources(ProcessingContext& pc,
 struct Spawner {
   std::string binding;
   std::vector<std::string> labels;
+  std::vector<framework::ConcreteDataMatcher> matchers;
   std::vector<std::shared_ptr<gandiva::Expression>> expressions;
   std::shared_ptr<gandiva::Projector> projector = nullptr;
   std::shared_ptr<arrow::Schema> schema = nullptr;
@@ -157,6 +159,7 @@ struct Spawner {
 struct Builder {
   bool exclusive;
   std::vector<std::string> labels;
+  std::vector<framework::ConcreteDataMatcher> matchers;
   std::vector<o2::soa::IndexRecord> records;
   std::shared_ptr<arrow::Schema> outputSchema;
   header::DataOrigin origin;
@@ -258,9 +261,9 @@ inline constexpr auto getIndexMapping()
     ([&idx]<TableRef ref, typename C>() mutable {
       constexpr auto pos = o2::aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::template getIndexPosToKey<Key>();
       if constexpr (pos == -1) {
-        idx.emplace_back(o2::aod::label<ref>(), C::columnLabel(), IndexKind::IdxSelf, pos);
+        idx.emplace_back(o2::aod::label<ref>(), o2::aod::matcher<ref>(), C::columnLabel(), IndexKind::IdxSelf, pos);
       } else {
-        idx.emplace_back(o2::aod::label<ref>(), C::columnLabel(), getIndexKind<typename C::type>(), pos);
+        idx.emplace_back(o2::aod::label<ref>(), o2::aod::matcher<ref>(), C::columnLabel(), getIndexKind<typename C::type>(), pos);
       }
     }.template operator()<refs[Is], typename framework::pack_element_t<Is, indices>>(),
      ...);
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index fbb499940b9b9..5112e3659f4aa 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -38,7 +38,7 @@ template <size_t N, std::array<soa::TableRef, N> refs>
 static inline auto extractOriginals(ProcessingContext& pc)
 {
   return [&]<size_t... Is>(std::index_sequence<Is...>) -> std::vector<std::shared_ptr<arrow::Table>> {
-    return {pc.inputs().get<TableConsumer>(o2::aod::label<refs[Is]>())->asArrowTable()...};
+    return {pc.inputs().get<TableConsumer>(o2::aod::matcher<refs[Is]>())->asArrowTable()...};
   }(std::make_index_sequence<refs.size()>());
 }
 } // namespace
@@ -151,7 +151,7 @@ template <typename T>
 concept with_base_table = requires { T::base_specs(); };
 
 template <with_base_table T>
-bool requestInputs(std::vector<InputSpec>& inputs, T const& entity)
+bool requestInputs(std::vector<InputSpec>& inputs, T const& /*entity*/)
 {
   auto base_specs = T::base_specs();
   for (auto base_spec : base_specs) {
@@ -586,7 +586,7 @@ bool registerCache(T& preslice, Cache& bsks, Cache&)
       return true;
     }
   }
-  auto locate = std::find_if(bsks.begin(), bsks.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); });
+  auto locate = std::find(bsks.begin(), bsks.end(), preslice.getBindingKey());
   if (locate == bsks.end()) {
     bsks.emplace_back(preslice.getBindingKey());
   } else if (locate->enabled == false) {
@@ -604,7 +604,7 @@ bool registerCache(T& preslice, Cache&, Cache& bsksU)
       return true;
     }
   }
-  auto locate = std::find_if(bsksU.begin(), bsksU.end(), [&](auto const& entry) { return (entry.binding == preslice.bindingKey.binding) && (entry.key == preslice.bindingKey.key); });
+  auto locate = std::find(bsksU.begin(), bsksU.end(), preslice.getBindingKey());
   if (locate == bsksU.end()) {
     bsksU.emplace_back(preslice.getBindingKey());
   } else if (locate->enabled == false) {
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 53f6bc0f862d6..c50b5358990de 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -75,11 +75,11 @@ struct AnalysisDataProcessorBuilder {
       auto key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
       ([&bk, &bku, &key, enabled]() mutable {
         if constexpr (soa::relatedByIndex<std::decay_t<G>, std::decay_t<As>>()) {
-          auto binding = soa::getLabelFromTypeForKey<std::decay_t<As>>(key);
+          Entry e{soa::getLabelFromTypeForKey<std::decay_t<As>>(key), soa::getMatcherFromTypeForKey<std::decay_t<As>>(key), key, enabled};
           if constexpr (o2::soa::is_smallgroups<std::decay_t<As>>) {
-            framework::updatePairList(bku, binding, key, enabled);
+            framework::updatePairList(bku, e);
           } else {
-            framework::updatePairList(bk, binding, key, enabled);
+            framework::updatePairList(bk, e);
           }
         }
       }(),
@@ -214,7 +214,7 @@ struct AnalysisDataProcessorBuilder {
   template <soa::TableRef R>
   static auto extractTableFromRecord(InputRecord& record)
   {
-    auto table = record.get<TableConsumer>(o2::aod::label<R>())->asArrowTable();
+    auto table = record.get<TableConsumer>(o2::aod::matcher<R>())->asArrowTable();
     if (table->num_rows() == 0) {
       table = makeEmptyTable<R>();
     }
diff --git a/Framework/Core/include/Framework/ArrowTableSlicingCache.h b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
index a6117ec3e01bc..073eadc22d72c 100644
--- a/Framework/Core/include/Framework/ArrowTableSlicingCache.h
+++ b/Framework/Core/include/Framework/ArrowTableSlicingCache.h
@@ -12,6 +12,7 @@
 #ifndef ARROWTABLESLICINGCACHE_H
 #define ARROWTABLESLICINGCACHE_H
 
+#include "Framework/ConcreteDataMatcher.h"
 #include "Framework/ServiceHandle.h"
 #include <arrow/array.h>
 #include <gsl/span>
@@ -36,20 +37,28 @@ struct SliceInfoUnsortedPtr {
 
 struct Entry {
   std::string binding;
+  ConcreteDataMatcher matcher;
   std::string key;
   bool enabled;
 
-  Entry(std::string b, std::string k, bool e = true)
+  Entry(std::string b, ConcreteDataMatcher m, std::string k, bool e = true)
     : binding{b},
+      matcher{m},
       key{k},
       enabled{e}
   {
   }
+
+  friend bool operator==(Entry const& lhs, Entry const& rhs)
+  {
+    return (lhs.matcher == rhs.matcher) &&
+           (lhs.key == rhs.key);
+  }
 };
 
 using Cache = std::vector<Entry>;
 
-void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled);
+void updatePairList(Cache& list, Entry& entry);
 
 struct ArrowTableSlicingCacheDef {
   constexpr static ServiceKind service_kind = ServiceKind::Global;
diff --git a/Framework/Core/include/Framework/ConcreteDataMatcher.h b/Framework/Core/include/Framework/ConcreteDataMatcher.h
index 247e3cd6ed8b9..bfbd2a05a8709 100644
--- a/Framework/Core/include/Framework/ConcreteDataMatcher.h
+++ b/Framework/Core/include/Framework/ConcreteDataMatcher.h
@@ -56,9 +56,9 @@ struct ConcreteDataMatcher {
   header::DataDescription description;
   header::DataHeader::SubSpecificationType subSpec;
 
-  ConcreteDataMatcher(header::DataOrigin origin_,
-                      header::DataDescription description_,
-                      header::DataHeader::SubSpecificationType subSpec_)
+  constexpr ConcreteDataMatcher(header::DataOrigin origin_,
+                                header::DataDescription description_,
+                                header::DataHeader::SubSpecificationType subSpec_)
     : origin(origin_),
       description(description_),
       subSpec(subSpec_)
diff --git a/Framework/Core/include/Framework/DataSpecUtils.h b/Framework/Core/include/Framework/DataSpecUtils.h
index 588aa30da7e08..fe322334a8edb 100644
--- a/Framework/Core/include/Framework/DataSpecUtils.h
+++ b/Framework/Core/include/Framework/DataSpecUtils.h
@@ -127,6 +127,9 @@ struct DataSpecUtils {
   /// unique way a description should be done, so we keep this outside.
   static std::string describe(OutputSpec const& spec);
 
+  /// Describes a ConcreteDataMatcher
+  static std::string describe(ConcreteDataMatcher const& matcher);
+
   /// Provide a unique label for the input spec. Again this is outside because there
   /// is no standard way of doing it, so better not to pollute the API.
   static std::string label(InputSpec const& spec);
@@ -211,6 +214,9 @@ struct DataSpecUtils {
   /// Create an InputSpec from metadata string
   static InputSpec fromMetadataString(std::string s);
 
+  /// Create a concrete data matcher from serialized string
+  static ConcreteDataMatcher fromString(std::string s);
+
   /// Get the origin, if available
   static std::optional<header::DataOrigin> getOptionalOrigin(InputSpec const& spec);
 
diff --git a/Framework/Core/include/Framework/DataSpecViews.h b/Framework/Core/include/Framework/DataSpecViews.h
index 162a12419594e..b38866d8aa6fd 100644
--- a/Framework/Core/include/Framework/DataSpecViews.h
+++ b/Framework/Core/include/Framework/DataSpecViews.h
@@ -43,6 +43,13 @@ static auto filter_string_params_with(std::string match)
   });
 }
 
+static auto filter_string_params_starts_with(std::string match)
+{
+  return std::views::filter([match](auto const& param) {
+    return (param.type == VariantType::String) && (param.name.starts_with(match));
+  });
+}
+
 static auto input_to_output_specs()
 {
   return std::views::transform([](auto const& input) {
diff --git a/Framework/Core/include/Framework/GroupSlicer.h b/Framework/Core/include/Framework/GroupSlicer.h
index 4cfbb8c440fd3..596e68d8cdd4c 100644
--- a/Framework/Core/include/Framework/GroupSlicer.h
+++ b/Framework/Core/include/Framework/GroupSlicer.h
@@ -55,7 +55,7 @@ struct GroupSlicer {
     {
       constexpr auto index = framework::has_type_at_v<std::decay_t<T>>(associated_pack_t{});
       auto binding = o2::soa::getLabelFromTypeForKey<std::decay_t<T>>(mIndexColumnName);
-      auto bk = Entry(binding, mIndexColumnName);
+      auto bk = Entry(binding, o2::soa::getMatcherFromTypeForKey<std::decay_t<T>>(mIndexColumnName), mIndexColumnName);
       if constexpr (!o2::soa::is_smallgroups<std::decay_t<T>>) {
         if (table.size() == 0) {
           return;
diff --git a/Framework/Core/include/Framework/InputRecord.h b/Framework/Core/include/Framework/InputRecord.h
index 0c9f36d00c634..96963f88524be 100644
--- a/Framework/Core/include/Framework/InputRecord.h
+++ b/Framework/Core/include/Framework/InputRecord.h
@@ -189,6 +189,7 @@ class InputRecord
   };
 
   int getPos(const char* name) const;
+  int getPos(ConcreteDataMatcher matcher) const;
   [[nodiscard]] static InputPos getPos(std::vector<InputRoute> const& routes, ConcreteDataMatcher matcher);
   [[nodiscard]] static DataRef getByPos(std::vector<InputRoute> const& routes, InputSpan const& span, int pos, int part = 0);
 
@@ -511,6 +512,27 @@ class InputRecord
     return cache.idToMetadata[id];
   }
 
+  template <typename T>
+    requires(std::same_as<T, DataRef>)
+  decltype(auto) get(ConcreteDataMatcher matcher, int part = 0)
+  {
+    auto pos = getPos(matcher);
+    if (pos < 0) {
+      auto msg = describeAvailableInputs();
+      throw runtime_error_f("InputRecord::get: no input with binding %s found. %s", DataSpecUtils::describe(matcher).c_str(), msg.c_str());
+    }
+    return getByPos(pos, part);
+  }
+
+  template <typename T>
+    requires(std::same_as<T, TableConsumer>)
+  decltype(auto) get(ConcreteDataMatcher matcher, int part = 0)
+  {
+    auto ref = get<DataRef>(matcher, part);
+    auto data = reinterpret_cast<uint8_t const*>(ref.payload);
+    return std::make_unique<TableConsumer>(data, DataRefUtils::getPayloadSize(ref));
+  }
+
   /// Helper method to be used to check if a given part of the InputRecord is present.
   [[nodiscard]] bool isValid(std::string const& s) const
   {
diff --git a/Framework/Core/src/AnalysisHelpers.cxx b/Framework/Core/src/AnalysisHelpers.cxx
index b8e0348d5df9c..f2ecb2d68ce28 100644
--- a/Framework/Core/src/AnalysisHelpers.cxx
+++ b/Framework/Core/src/AnalysisHelpers.cxx
@@ -185,18 +185,18 @@ std::string serializeIndexRecords(std::vector<o2::soa::IndexRecord>& irs)
   return osm.str();
 }
 
-std::vector<std::shared_ptr<arrow::Table>> extractSources(ProcessingContext& pc, std::vector<std::string> const& labels)
+std::vector<std::shared_ptr<arrow::Table>> extractSources(ProcessingContext& pc, std::vector<ConcreteDataMatcher> const& matchers)
 {
   std::vector<std::shared_ptr<arrow::Table>> tables;
-  for (auto const& label : labels) {
-    tables.emplace_back(pc.inputs().get<TableConsumer>(label.c_str())->asArrowTable());
+  for (auto const& matcher : matchers) {
+    tables.emplace_back(pc.inputs().get<TableConsumer>(matcher)->asArrowTable());
   }
   return tables;
 }
 
 std::shared_ptr<arrow::Table> Spawner::materialize(ProcessingContext& pc) const
 {
-  auto tables = extractSources(pc, labels);
+  auto tables = extractSources(pc, matchers);
   auto fullTable = soa::ArrowHelpers::joinTables(std::move(tables), std::span{labels.begin(), labels.size()});
   if (fullTable->num_rows() == 0) {
     return arrow::Table::MakeEmpty(schema).ValueOrDie();
@@ -212,7 +212,7 @@ std::shared_ptr<arrow::Table> Builder::materialize(ProcessingContext& pc)
     builders->reserve(records.size());
   }
   std::shared_ptr<arrow::Table> result;
-  auto tables = extractSources(pc, labels);
+  auto tables = extractSources(pc, matchers);
   result = o2::soa::IndexBuilder::materialize(*builders.get(), std::move(tables), records, outputSchema, exclusive);
   return result;
 }
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index c403d983325dc..95e763343671a 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -753,7 +753,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowTableSlicingCacheSpec()
       auto& caches = service->bindingsKeys;
       for (auto i = 0u; i < caches.size(); ++i) {
         if (caches[i].enabled && pc.inputs().getPos(caches[i].binding.c_str()) >= 0) {
-          auto status = service->updateCacheEntry(i, pc.inputs().get<TableConsumer>(caches[i].binding.c_str())->asArrowTable());
+          auto status = service->updateCacheEntry(i, pc.inputs().get<TableConsumer>(caches[i].matcher)->asArrowTable());
           if (!status.ok()) {
             throw runtime_error_f("Failed to update slice cache for %s/%s", caches[i].binding.c_str(), caches[i].key.c_str());
           }
@@ -762,7 +762,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowTableSlicingCacheSpec()
       auto& unsortedCaches = service->bindingsKeysUnsorted;
       for (auto i = 0u; i < unsortedCaches.size(); ++i) {
         if (unsortedCaches[i].enabled && pc.inputs().getPos(unsortedCaches[i].binding.c_str()) >= 0) {
-          auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get<TableConsumer>(unsortedCaches[i].binding.c_str())->asArrowTable());
+          auto status = service->updateCacheEntryUnsorted(i, pc.inputs().get<TableConsumer>(unsortedCaches[i].matcher)->asArrowTable());
           if (!status.ok()) {
             throw runtime_error_f("failed to update slice cache (unsorted) for %s/%s", unsortedCaches[i].binding.c_str(), unsortedCaches[i].key.c_str());
           }
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 75b4bbfac701d..634c51f71f5a6 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -37,12 +37,12 @@ std::shared_ptr<arrow::ChunkedArray> GetColumnByNameCI(std::shared_ptr<arrow::Ta
 }
 } // namespace
 
-void updatePairList(Cache& list, std::string const& binding, std::string const& key, bool enabled = true)
+void updatePairList(Cache& list, Entry& entry)
 {
-  auto locate = std::find_if(list.begin(), list.end(), [&binding, &key](auto const& entry) { return (entry.binding == binding) && (entry.key == key); });
+  auto locate = std::find(list.begin(), list.end(), entry);
   if (locate == list.end()) {
-    list.emplace_back(binding, key, enabled);
-  } else if (!locate->enabled && enabled) {
+    list.emplace_back(entry);
+  } else if (!locate->enabled && entry.enabled) {
     locate->enabled = true;
   }
 }
@@ -110,7 +110,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
   if (table->num_rows() == 0) {
     return arrow::Status::OK();
   }
-  auto& [b, k, e] = bindingsKeys[pos];
+  auto& [b, m, k, e] = bindingsKeys[pos];
   if (!e) {
     throw runtime_error_f("Disabled cache %s/%s update requested", b.c_str(), k.c_str());
   }
@@ -169,7 +169,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntryUnsorted(int pos, const st
   if (table->num_rows() == 0) {
     return arrow::Status::OK();
   }
-  auto& [b, k, e] = bindingsKeysUnsorted[pos];
+  auto& [b, m, k, e] = bindingsKeysUnsorted[pos];
   if (!e) {
     throw runtime_error_f("Disabled unsorted cache %s/%s update requested", b.c_str(), k.c_str());
   }
@@ -210,7 +210,7 @@ std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const Entry& bindingKey
 
 int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const
 {
-  auto locate = std::find_if(bindingsKeys.begin(), bindingsKeys.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); });
+  auto locate = std::find(bindingsKeys.begin(), bindingsKeys.end(), bindingKey);
   if (locate != bindingsKeys.end()) {
     return std::distance(bindingsKeys.begin(), locate);
   }
@@ -219,7 +219,7 @@ int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const
 
 int ArrowTableSlicingCache::getCachePosUnsortedFor(Entry const& bindingKey) const
 {
-  auto locate_unsorted = std::find_if(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), [&](Entry const& bk) { return (bindingKey.binding == bk.binding) && (bindingKey.key == bk.key); });
+  auto locate_unsorted = std::find(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), bindingKey);
   if (locate_unsorted != bindingsKeysUnsorted.end()) {
     return std::distance(bindingsKeysUnsorted.begin(), locate_unsorted);
   }
@@ -269,7 +269,10 @@ SliceInfoUnsortedPtr ArrowTableSlicingCache::getCacheUnsortedForPos(int pos) con
 
 void ArrowTableSlicingCache::validateOrder(Entry const& bindingKey, const std::shared_ptr<arrow::Table>& input)
 {
-  auto const& [target, key, enabled] = bindingKey;
+  auto const& [target, matcher, key, enabled] = bindingKey;
+  if (!enabled) {
+    return;
+  }
   auto column = o2::framework::GetColumnByNameCI(input, key);
   auto array0 = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(0)->data());
   int32_t prev = 0;
diff --git a/Framework/Core/src/DataSpecUtils.cxx b/Framework/Core/src/DataSpecUtils.cxx
index 48f5e6abcad5b..bc1fcd180ed76 100644
--- a/Framework/Core/src/DataSpecUtils.cxx
+++ b/Framework/Core/src/DataSpecUtils.cxx
@@ -89,6 +89,11 @@ std::string DataSpecUtils::describe(OutputSpec const& spec)
                     spec.matcher);
 }
 
+std::string DataSpecUtils::describe(ConcreteDataMatcher const& matcher)
+{
+  return join(matcher, "/");
+}
+
 template <HasMatcher T>
 size_t DataSpecUtils::describe(char* buffer, size_t size, T const& spec)
 {
@@ -664,16 +669,39 @@ InputSpec DataSpecUtils::fromMetadataString(std::string s)
   if (std::distance(words, std::sregex_iterator()) != 4) {
     throw runtime_error_f("Malformed input spec metadata: %s", s.c_str());
   }
-  std::vector<std::string> data;
+  std::array<std::string, 4> data;
+  auto pos = 0;
   for (auto i = words; i != std::sregex_iterator(); ++i) {
-    data.emplace_back(i->str());
+    data[pos] = i->str();
+    ++pos;
   }
   char origin[4];
   char description[16];
   std::memcpy(&origin, data[1].c_str(), 4);
   std::memcpy(&description, data[2].c_str(), 16);
   auto version = static_cast<o2::header::DataHeader::SubSpecificationType>(std::atoi(data[3].c_str()));
-  return InputSpec{data[0], header::DataOrigin{origin}, header::DataDescription{description}, version, Lifetime::Timeframe};
+  return {data[0], header::DataOrigin{origin}, header::DataDescription{description}, version, Lifetime::Timeframe};
+}
+
+ConcreteDataMatcher DataSpecUtils::fromString(std::string s)
+{
+  std::regex word_regex("(\\w+)");
+  auto words = std::sregex_iterator(s.begin(), s.end(), word_regex);
+  if (std::distance(words, std::sregex_iterator()) != 3) {
+    throw runtime_error_f("Malformed serialized matcher: %s", s.c_str());
+  }
+  std::array<std::string, 3> data;
+  auto pos = 0;
+  for (auto i = words; i != std::sregex_iterator(); ++i) {
+    data[pos] = i->str();
+    ++pos;
+  }
+  char origin[4];
+  char description[16];
+  std::memcpy(&origin, data[0].c_str(), 4);
+  std::memcpy(&description, data[1].c_str(), 16);
+  auto version = static_cast<o2::header::DataHeader::SubSpecificationType>(std::atoi(data[2].c_str()));
+  return {header::DataOrigin{origin}, header::DataDescription{description}, version};
 }
 
 std::optional<header::DataOrigin> DataSpecUtils::getOptionalOrigin(InputSpec const& spec)
diff --git a/Framework/Core/src/IndexJSONHelpers.cxx b/Framework/Core/src/IndexJSONHelpers.cxx
index 19ae94a4bcd4c..a5c6c70579599 100644
--- a/Framework/Core/src/IndexJSONHelpers.cxx
+++ b/Framework/Core/src/IndexJSONHelpers.cxx
@@ -41,6 +41,7 @@ struct IndexRecordsReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<
   std::string currentKey;
   std::string label;
   std::string columnLabel;
+  std::string matcherStr;
   o2::soa::IndexKind kind;
   int pos;
 
@@ -87,6 +88,9 @@ struct IndexRecordsReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<
       if (currentKey.compare("label") == 0) {
         return true;
       }
+      if (currentKey.compare("matcher") == 0) {
+        return true;
+      }
       if (currentKey.compare("column") == 0) {
         return true;
       }
@@ -127,7 +131,7 @@ struct IndexRecordsReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<
     if (states.top() == State::IN_RECORD) {
       states.pop();
       // add a record
-      records.emplace_back(label, columnLabel, kind, pos);
+      records.emplace_back(label, DataSpecUtils::fromString(matcherStr), columnLabel, kind, pos);
       return true;
     }
 
@@ -175,6 +179,10 @@ struct IndexRecordsReader : public rapidjson::BaseReaderHandler<rapidjson::UTF8<
         columnLabel = str;
         return true;
       }
+      if (currentKey.compare("matcher") == 0) {
+        matcherStr = str;
+        return true;
+      }
     }
 
     states.push(State::IN_ERROR);
@@ -205,6 +213,8 @@ void writeRecords(rapidjson::Writer<rapidjson::OStreamWrapper>& w, std::vector<o
     w.StartObject();
     w.Key("label");
     w.String(r.label.c_str());
+    w.Key("matcher");
+    w.String(DataSpecUtils::describe(r.matcher).c_str());
     w.Key("column");
     w.String(r.columnLabel.c_str());
     w.Key("kind");
diff --git a/Framework/Core/src/InputRecord.cxx b/Framework/Core/src/InputRecord.cxx
index c4c6852a6a3c7..18b341704ffcb 100644
--- a/Framework/Core/src/InputRecord.cxx
+++ b/Framework/Core/src/InputRecord.cxx
@@ -58,6 +58,11 @@ int InputRecord::getPos(const char* binding) const
   return -1;
 }
 
+int InputRecord::getPos(ConcreteDataMatcher matcher) const
+{
+  return getPos(mInputsSchema, matcher).index;
+}
+
 InputRecord::InputPos InputRecord::getPos(std::vector<InputRoute> const& schema, ConcreteDataMatcher concrete)
 {
   size_t inputIndex = 0;
diff --git a/Framework/Core/test/benchmark_EventMixing.cxx b/Framework/Core/test/benchmark_EventMixing.cxx
index 99a7d0d4b1cb9..0e7e6839ee35e 100644
--- a/Framework/Core/test/benchmark_EventMixing.cxx
+++ b/Framework/Core/test/benchmark_EventMixing.cxx
@@ -78,7 +78,8 @@ static void BM_EventMixingTraditional(benchmark::State& state)
   auto tableTrack = trackBuilder.finalize();
   o2::aod::StoredTracks tracks{tableTrack};
 
-  ArrowTableSlicingCache atscache({{getLabelFromType<o2::aod::StoredTracks>(), "fIndex" + cutString(getLabelFromType<o2::aod::Collisions>())}});
+  std::string key = "fIndex" + cutString(getLabelFromType<o2::aod::Collisions>());
+  ArrowTableSlicingCache atscache({{getLabelFromType<o2::aod::StoredTracks>(), getMatcherFromTypeForKey<o2::aod::StoredTracks>(key), key}});
   auto s = atscache.updateCacheEntry(0, tableTrack);
   SliceCache cache{&atscache};
 
@@ -171,7 +172,8 @@ static void BM_EventMixingCombinations(benchmark::State& state)
 
   int64_t count = 0;
   int64_t colCount = 0;
-  ArrowTableSlicingCache atscache{{{getLabelFromType<o2::aod::StoredTracks>(), "fIndex" + getLabelFromType<o2::aod::Collisions>()}}};
+  std::string key = "fIndex" + getLabelFromType<o2::aod::Collisions>();
+  ArrowTableSlicingCache atscache{{{getLabelFromType<o2::aod::StoredTracks>(), getMatcherFromTypeForKey<o2::aod::StoredTracks>(key), key}}};
   auto s = atscache.updateCacheEntry(0, tableTrack);
   SliceCache cache{&atscache};
 
diff --git a/Framework/Core/test/test_ASoA.cxx b/Framework/Core/test/test_ASoA.cxx
index 80519aebc9ee7..117dddff4c548 100644
--- a/Framework/Core/test/test_ASoA.cxx
+++ b/Framework/Core/test/test_ASoA.cxx
@@ -1187,7 +1187,8 @@ TEST_CASE("TestSliceByCached")
   auto refs = w.finalize();
   o2::aod::References r{refs};
 
-  ArrowTableSlicingCache atscache({{o2::soa::getLabelFromType<o2::aod::References>(), "fIndex" + o2::framework::cutString(o2::soa::getLabelFromType<o2::aod::Origints>())}});
+  std::string key = "fIndex" + o2::framework::cutString(o2::soa::getLabelFromType<o2::aod::Origints>());
+  ArrowTableSlicingCache atscache({{o2::soa::getLabelFromType<o2::aod::References>(), o2::soa::getMatcherFromTypeForKey<o2::aod::References>(key), key}});
   auto s = atscache.updateCacheEntry(0, refs);
   SliceCache cache{&atscache};
 
@@ -1238,7 +1239,7 @@ TEST_CASE("TestSliceByCachedMismatched")
   J rr{{refs, refs2}};
 
   auto key = "fIndex" + o2::framework::cutString(o2::soa::getLabelFromType<o2::aod::Origints>()) + "_alt";
-  ArrowTableSlicingCache atscache({{o2::soa::getLabelFromTypeForKey<J>(key), key}});
+  ArrowTableSlicingCache atscache({{o2::soa::getLabelFromTypeForKey<J>(key), o2::soa::getMatcherFromTypeForKey<J>(key), key}});
   auto s = atscache.updateCacheEntry(0, refs2);
   SliceCache cache{&atscache};
 
diff --git a/Framework/Core/test/test_GroupSlicer.cxx b/Framework/Core/test/test_GroupSlicer.cxx
index 2f21d7dd17975..71360f736c3fb 100644
--- a/Framework/Core/test/test_GroupSlicer.cxx
+++ b/Framework/Core/test/test_GroupSlicer.cxx
@@ -117,7 +117,8 @@ TEST_CASE("GroupSlicerOneAssociated")
   REQUIRE(t.size() == 10 * 20);
 
   auto tt = std::make_tuple(t);
-  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>())}});
+  std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
+  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
   o2::framework::GroupSlicer g(e, tt, slices);
 
@@ -191,9 +192,9 @@ TEST_CASE("GroupSlicerSeveralAssociated")
 
   auto tt = std::make_tuple(tx, ty, tz, tu);
   auto key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
-  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), key},
-                                 {soa::getLabelFromType<aod::TrksY>(), key},
-                                 {soa::getLabelFromType<aod::TrksZ>(), key}});
+  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key},
+                                 {soa::getLabelFromType<aod::TrksY>(), soa::getMatcherFromTypeForKey<aod::TrksY>(key), key},
+                                 {soa::getLabelFromType<aod::TrksZ>(), soa::getMatcherFromTypeForKey<aod::TrksZ>(key), key}});
   auto s = slices.updateCacheEntry(0, {trkTableX});
   s = slices.updateCacheEntry(1, {trkTableY});
   s = slices.updateCacheEntry(2, {trkTableZ});
@@ -256,7 +257,8 @@ TEST_CASE("GroupSlicerMismatchedGroups")
   REQUIRE(t.size() == 10 * (20 - 5));
 
   auto tt = std::make_tuple(t);
-  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>())}});
+  std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
+  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
   o2::framework::GroupSlicer g(e, tt, slices);
 
@@ -312,7 +314,8 @@ TEST_CASE("GroupSlicerMismatchedUnassignedGroups")
   REQUIRE(t.size() == (30 + 10 * (20 - 5)));
 
   auto tt = std::make_tuple(t);
-  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>())}});
+  std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
+  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
   o2::framework::GroupSlicer g(e, tt, slices);
 
@@ -362,7 +365,8 @@ TEST_CASE("GroupSlicerMismatchedFilteredGroups")
   REQUIRE(t.size() == 10 * (20 - 4));
 
   auto tt = std::make_tuple(t);
-  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>())}});
+  std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
+  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
   o2::framework::GroupSlicer g(e, tt, slices);
 
@@ -423,7 +427,8 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroups")
   REQUIRE(t.size() == 10 * (20 - 4));
 
   auto tt = std::make_tuple(t);
-  ArrowTableSlicingCache slices({}, {{soa::getLabelFromType<aod::TrksXU>(), "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>())}});
+  std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
+  ArrowTableSlicingCache slices({}, {{soa::getLabelFromType<aod::TrksXU>(), soa::getMatcherFromTypeForKey<aod::TrksXU>(key), key}});
   auto s = slices.updateCacheEntryUnsorted(0, trkTable);
   o2::framework::GroupSlicer g(e, tt, slices);
 
@@ -547,8 +552,9 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
   }
   FilteredParts fp{{partsTable}, rows};
   auto associatedTuple = std::make_tuple(fp, t);
-  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::Parts>(), "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>())},
-                                 {soa::getLabelFromType<aod::Things>(), "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>())}});
+  std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
+  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::Parts>(), soa::getMatcherFromTypeForKey<aod::Parts>(key), key},
+                                 {soa::getLabelFromType<aod::Things>(), soa::getMatcherFromTypeForKey<aod::Things>(key), key}});
   auto s0 = slices.updateCacheEntry(0, partsTable);
   auto s1 = slices.updateCacheEntry(1, thingsTable);
   o2::framework::GroupSlicer g(e, associatedTuple, slices);
@@ -607,7 +613,8 @@ TEST_CASE("EmptySliceables")
   REQUIRE(t.size() == 0);
 
   auto tt = std::make_tuple(t);
-  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>())}});
+  std::string key = "fIndex" + o2::framework::cutString(soa::getLabelFromType<aod::Events>());
+  ArrowTableSlicingCache slices({{soa::getLabelFromType<aod::TrksX>(), soa::getMatcherFromTypeForKey<aod::TrksX>(key), key}});
   auto s = slices.updateCacheEntry(0, trkTable);
   o2::framework::GroupSlicer g(e, tt, slices);
 
@@ -679,7 +686,7 @@ TEST_CASE("ArrowDirectSlicing")
 
   std::vector<arrow::Datum> slices;
   std::vector<uint64_t> offsts;
-  auto bk = Entry(soa::getLabelFromType<aod::Events>(), "fID");
+  auto bk = Entry(soa::getLabelFromType<aod::Events>(), soa::getMatcherFromTypeForKey<aod::Events>("fID"), "fID");
   ArrowTableSlicingCache cache({bk});
   auto s = cache.updateCacheEntry(0, {evtTable});
   auto lcache = cache.getCacheFor(bk);
@@ -737,7 +744,7 @@ TEST_CASE("TestSlicingException")
   }
   auto evtTable = builderE.finalize();
 
-  auto bk = Entry(soa::getLabelFromType<aod::Events>(), "fID");
+  auto bk = Entry(soa::getLabelFromType<aod::Events>(), soa::getMatcherFromTypeForKey<aod::Events>("fID"), "fID");
   ArrowTableSlicingCache cache({bk});
 
   try {
diff --git a/Framework/TestWorkflows/CMakeLists.txt b/Framework/TestWorkflows/CMakeLists.txt
index f5d18183c3705..d2b98419043bf 100644
--- a/Framework/TestWorkflows/CMakeLists.txt
+++ b/Framework/TestWorkflows/CMakeLists.txt
@@ -46,6 +46,10 @@ o2_add_dpl_workflow(analysis-ccdb
                     PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
                     COMPONENT_NAME TestWorkflows)
 
+o2_add_dpl_workflow(analysis-emb
+                    SOURCES src/o2TestMultisource.cxx
+                    COMPONENT_NAME TestWorkflows)
+
 o2_add_dpl_workflow(two-timers
                   SOURCES src/o2TwoTimers.cxx
                   COMPONENT_NAME TestWorkflows)
diff --git a/Framework/TestWorkflows/src/o2TestHistograms.cxx b/Framework/TestWorkflows/src/o2TestHistograms.cxx
index 640a165fb91ff..9c2cba35b9156 100644
--- a/Framework/TestWorkflows/src/o2TestHistograms.cxx
+++ b/Framework/TestWorkflows/src/o2TestHistograms.cxx
@@ -16,8 +16,6 @@
 #include "Framework/runDataProcessing.h"
 #include "Framework/AnalysisTask.h"
 #include <TH2F.h>
-#include <cmath>
-#include <iostream>
 
 using namespace o2;
 using namespace o2::framework;
@@ -72,7 +70,7 @@ struct EtaAndClsHistogramsSimple {
     }
   }
 
-  void process(soa::Filtered<aod::Tracks> const& tracks, aod::FT0s const&, aod::StoredTracksFrom<o2::aod::Hash<"EMB"_h>> const& ortherTracks)
+  void process(soa::Filtered<aod::Tracks> const& tracks, aod::FT0s const&)
   {
     LOGP(info, "Invoking the simple one");
     for (auto& track : tracks) {
@@ -110,7 +108,7 @@ struct EtaAndClsHistogramsIUSimple {
     }
   }
 
-  void process(soa::Filtered<aod::TracksIU> const& tracks, aod::FT0s const&, aod::TracksIUFrom<o2::aod::Hash<"EMB"_h>> const& otherTracks)
+  void process(soa::Filtered<aod::TracksIU> const& tracks, aod::FT0s const&)
   {
     LOGP(info, "Invoking the simple one IU");
     for (auto& track : tracks) {
diff --git a/Framework/TestWorkflows/src/o2TestMultisource.cxx b/Framework/TestWorkflows/src/o2TestMultisource.cxx
new file mode 100644
index 0000000000000..00bd9ba5093bd
--- /dev/null
+++ b/Framework/TestWorkflows/src/o2TestMultisource.cxx
@@ -0,0 +1,47 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \brief Tests that the same tables from different origins are routed correctly.
+///        Requires two input files, <name>.root and <name>_EMB.root, that contain
+///        same number of DFs with the same names.
+/// \author
+/// \since
+
+#include "Framework/runDataProcessing.h"
+#include "Framework/AnalysisTask.h"
+
+using namespace o2;
+using namespace o2::framework;
+using namespace o2::framework::expressions;
+
+namespace o2::aod
+{
+O2ORIGIN("EMB");
+template <is_aod_hash T>
+using BCsFrom = BCs_001From<T>;
+using TracksPlus = soa::Join<StoredTracksIU, StoredTracksExtra>;
+template <is_aod_hash T>
+using TracksPlusFrom = soa::Join<StoredTracksIUFrom<T>, StoredTracksExtra_002From<T>>;
+} // namespace o2::aod
+
+struct TestEmbeddingSubscription {
+  void process(aod::BCs const& bcs, aod::BCsFrom<aod::Hash<"EMB"_h>> const& bcse,
+               aod::TracksPlus const& tracks, aod::TracksPlusFrom<aod::Hash<"EMB"_h>> const& trackse)
+  {
+    LOGP(info, "BCs from run {} and {}", bcs.begin().runNumber(), bcse.begin().runNumber());
+    LOGP(info, "Joined tracks: {} and {}", tracks.size(), trackse.size());
+  }
+};
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
+{
+  return {adaptAnalysisTask<TestEmbeddingSubscription>(cfgc)};
+}

From b5dfe5011ab8a7399ee9c41dba66175feee68033 Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Thu, 15 Jan 2026 19:50:34 +0100
Subject: [PATCH 1207/1764] start_tmux.sh: create ED directory to avoid
 filesystem errors during o2-eve-export-workflow (#14961)

---
 prodtests/full-system-test/start_tmux.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/prodtests/full-system-test/start_tmux.sh b/prodtests/full-system-test/start_tmux.sh
index 22b658856803a..fb69cc1e6baec 100755
--- a/prodtests/full-system-test/start_tmux.sh
+++ b/prodtests/full-system-test/start_tmux.sh
@@ -91,6 +91,7 @@ export DATADIST_NEW_DPL_CHAN=1
 
 [[ -z $GEN_TOPO_MYDIR ]] && GEN_TOPO_MYDIR="$(dirname $(realpath $0))"
 source $GEN_TOPO_MYDIR/setenv.sh || { echo "setenv.sh failed" 1>&2 && exit 1; }
+mkdir -p $EDJSONS_DIR  # create event display directory to avoid filesystem error messages
 
 workflow_has_parameter QC && export QC_REDIRECT_MERGER_TO_LOCALHOST=1
 

From 0a8627db853ed9bf9537a2792e2e2c5afa4e3c94 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 16 Jan 2026 15:00:07 +0100
Subject: [PATCH 1208/1764] Switch option from external to hybrid (#14951)

---
 .../include/Generators/GeneratorHybridParam.h |  7 +--
 Generators/src/GeneratorFactory.cxx           |  6 +++
 .../GeneratorHyperloopHybrid.ini              |  3 ++
 .../GeneratorHyperloopHybridCocktail.ini      |  3 ++
 run/SimExamples/ExternalToHybrid/README.md    | 45 ++++++++++++++++
 .../ExternalToHybrid/cocktail.json            | 49 +++++++++++++++++
 run/SimExamples/ExternalToHybrid/rundpl.sh    | 54 +++++++++++++++++++
 .../ExternalToHybrid/sequential.json          | 35 ++++++++++++
 8 files changed, 199 insertions(+), 3 deletions(-)
 create mode 100644 run/SimExamples/ExternalToHybrid/GeneratorHyperloopHybrid.ini
 create mode 100644 run/SimExamples/ExternalToHybrid/GeneratorHyperloopHybridCocktail.ini
 create mode 100644 run/SimExamples/ExternalToHybrid/README.md
 create mode 100644 run/SimExamples/ExternalToHybrid/cocktail.json
 create mode 100755 run/SimExamples/ExternalToHybrid/rundpl.sh
 create mode 100644 run/SimExamples/ExternalToHybrid/sequential.json

diff --git a/Generators/include/Generators/GeneratorHybridParam.h b/Generators/include/Generators/GeneratorHybridParam.h
index c05b70dcb40ba..acdf87bba2d0a 100644
--- a/Generators/include/Generators/GeneratorHybridParam.h
+++ b/Generators/include/Generators/GeneratorHybridParam.h
@@ -29,9 +29,10 @@ namespace eventgen
  **/
 
 struct GeneratorHybridParam : public o2::conf::ConfigurableParamHelper<GeneratorHybridParam> {
-  std::string configFile = ""; // JSON configuration file for the generators
-  bool randomize = false;      // randomize the order of the generators, if not generator using fractions
-  int num_workers = 1;         // number of threads available for asyn/parallel event generation
+  std::string configFile = "";    // JSON configuration file for the generators
+  bool randomize = false;         // randomize the order of the generators, if not generator using fractions
+  int num_workers = 1;            // number of threads available for asyn/parallel event generation
+  bool switchExtToHybrid = false; // force external generator to be executed as hybrid mode, useful for Hyperloop MCGEN
   O2ParamDef(GeneratorHybridParam, "GeneratorHybrid");
 };
 
diff --git a/Generators/src/GeneratorFactory.cxx b/Generators/src/GeneratorFactory.cxx
index d04e785402915..1cc2659460a4b 100644
--- a/Generators/src/GeneratorFactory.cxx
+++ b/Generators/src/GeneratorFactory.cxx
@@ -93,6 +93,12 @@ void GeneratorFactory::setPrimaryGenerator(o2::conf::SimConfig const& conf, Fair
 
   o2::O2DatabasePDG::addALICEParticles(TDatabasePDG::Instance());
   auto genconfig = conf.getGenerator();
+#if defined(GENERATORS_WITH_PYTHIA8) && defined(GENERATORS_WITH_HEPMC3)
+  if (GeneratorHybridParam::Instance().switchExtToHybrid && (genconfig.compare("external") == 0 || genconfig.compare("extgen") == 0)) {
+    LOG(info) << "Switching external generator to hybrid mode";
+    genconfig = "hybrid";
+  }
+#endif
   LOG(info) << "** Generator to use: '" << genconfig << "'";
   if (genconfig.compare("boxgen") == 0) {
     // a simple "box" generator configurable via BoxGunparam
diff --git a/run/SimExamples/ExternalToHybrid/GeneratorHyperloopHybrid.ini b/run/SimExamples/ExternalToHybrid/GeneratorHyperloopHybrid.ini
new file mode 100644
index 0000000000000..0105349ea4d42
--- /dev/null
+++ b/run/SimExamples/ExternalToHybrid/GeneratorHyperloopHybrid.ini
@@ -0,0 +1,3 @@
+[GeneratorHybrid]
+configFile = ${O2_ROOT}/examples/ExternalToHybrid/sequential.json
+switchExtToHybrid = true
\ No newline at end of file
diff --git a/run/SimExamples/ExternalToHybrid/GeneratorHyperloopHybridCocktail.ini b/run/SimExamples/ExternalToHybrid/GeneratorHyperloopHybridCocktail.ini
new file mode 100644
index 0000000000000..11728f970d688
--- /dev/null
+++ b/run/SimExamples/ExternalToHybrid/GeneratorHyperloopHybridCocktail.ini
@@ -0,0 +1,3 @@
+[GeneratorHybrid]
+configFile = ${O2_ROOT}/examples/ExternalToHybrid/cocktail.json
+switchExtToHybrid = true
diff --git a/run/SimExamples/ExternalToHybrid/README.md b/run/SimExamples/ExternalToHybrid/README.md
new file mode 100644
index 0000000000000..28292cdf9277a
--- /dev/null
+++ b/run/SimExamples/ExternalToHybrid/README.md
@@ -0,0 +1,45 @@
+<!-- doxy
+\page refrunSimExamplesExternalToHybrid Example ExternalToHybrid
+/doxy -->
+
+This example demonstrates how to bypass the Hyperloop limitations when using external generators by switching the configuration to hybrid mode, using the new `GeneratorHybrid.switchExtToHybrid` parameter (set to false by default).
+
+This solution works only with updated O2sim versions containing the `switchExtToHybrid` option.
+
+# Configuration Files
+
+Two example configuration files are provided, each pointing to different hybrid JSON files:
+
+- **GeneratorHyperloopHybridCocktail.ini** → Creates a cocktail mixing two Pythia8 based generators and a boxgen instance
+- **GeneratorHyperloopHybrid.ini** → Defines sequential generation of boxgen and EPOS4 events called with an external generator
+
+# Script Description
+
+## rundpl.sh
+
+This script demonstrates event generation using the DPL framework, launching it with the external generator in hybrid mode.
+
+### Available Flags
+
+- **-i, --ini CONFIG** → Specifies the configuration ini file (default: `GeneratorHyperloopHybridCocktail.ini`)
+- **-n, --nevents EVENTS** → Sets the number of events to generate (default: 5)
+- **-h, --help** → Prints usage instructions and o2-sim-dpl-eventgen help
+- **--** → Passes remaining command line arguments to o2-sim-dpl-eventgen
+
+### Usage Examples
+
+Run with default settings (5 events using cocktail configuration):
+```bash
+./rundpl.sh
+```
+
+Generate 10 events using the sequential configuration:
+```bash
+./rundpl.sh -n 10 -i ${O2_ROOT}/examples/ExternalToHybrid/GeneratorHyperloopHybrid.ini
+```
+
+# Requirements
+
+- O2sim version with `switchExtToHybrid` support
+- O2_ROOT and O2DPG_MC_CONFIG_ROOT environment variable must be loaded (possibly via O2sim directly)
+- Appropriate external generator configurations (e.g., EPOS4) must be available
\ No newline at end of file
diff --git a/run/SimExamples/ExternalToHybrid/cocktail.json b/run/SimExamples/ExternalToHybrid/cocktail.json
new file mode 100644
index 0000000000000..2e8a4c964b1c6
--- /dev/null
+++ b/run/SimExamples/ExternalToHybrid/cocktail.json
@@ -0,0 +1,49 @@
+{
+  "generators": [
+    {
+      "cocktail": [
+        {
+          "name": "pythia8",
+          "config": {
+            "config": "${O2_ROOT}/share/Generators/egconfig/pythia8_inel.cfg",
+            "hooksFileName": "",
+            "hooksFuncName": "",
+            "includePartonEvent": false,
+            "particleFilter": "",
+            "verbose": 0
+          }
+        },
+        {
+          "name": "external",
+          "config": {
+            "fileName": "",
+            "funcName": "",
+            "iniFile": "${O2DPG_MC_CONFIG_ROOT}/MC/config/ALICE3/ini/pythia8_pp_13tev.ini"
+          }
+        },
+        {
+          "name": "boxgen",
+          "config": {
+            "pdg": 443,
+            "number": 10,
+            "eta": [
+              -0.8,
+              0.8
+            ],
+            "prange": [
+              0.1,
+              5
+            ],
+            "phirange": [
+              0,
+              360
+            ]
+          }
+        }
+      ]
+    }
+  ],
+  "fractions": [
+    1
+  ]
+}
\ No newline at end of file
diff --git a/run/SimExamples/ExternalToHybrid/rundpl.sh b/run/SimExamples/ExternalToHybrid/rundpl.sh
new file mode 100755
index 0000000000000..e9bd15b239862
--- /dev/null
+++ b/run/SimExamples/ExternalToHybrid/rundpl.sh
@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+#
+# This is a simple example script to bypass the Hyperloop limitations in using
+# external generators only, by switching the generator to the hybrid mode
+
+# This script works only with updated O2sim version containing the switchExtToHybrid option
+
+[ ! "${O2_ROOT}" ] && echo "Error: This needs O2 loaded" && exit 2
+[ ! "${O2DPG_MC_CONFIG_ROOT}" ] && echo "Error: This needs O2DPG loaded" && exit 2
+
+NEV=5
+# Two example ini configurations are provided pointing to different hybrid JSON files
+# One creates a cocktail based on Pythia8, while the other generates sequentially EPOS4 and boxgen events
+ini="${O2_ROOT}/examples/ExternalToHybrid/GeneratorHyperloopHybridCocktail.ini"
+
+usage()
+{
+    cat <<EOF
+Usage: $0 [OPTIONS]
+
+Options:
+
+  -i,--ini     INI         Configuration ini file ($ini)
+  -n,--nevents EVENTS      Number of events ($nev)
+  -h,--help                Print these instructions
+  --                       Rest of command line sent to o2-sim
+
+COMMAND must be quoted if it contains spaces or other special
+characters
+
+Below follows the help output of o2-sim-dpl-eventgen
+
+EOF
+}
+
+if [ "$#" -lt 2 ]; then
+    echo "Running with default values"
+fi
+
+while test $# -gt 0 ; do
+    case $1 in
+        -i|--ini)     ini="$2" ; shift ;;
+        -n|--nevents) NEV=$2 ; shift ;;
+        -h|--help) usage; o2-sim-dpl-eventgen --help full ; exit 0 ;;
+        --)           shift ; break ;;
+        *) echo "Unknown option '$1', did you forget '--'?" >/dev/stderr
+           exit 3
+           ;;
+    esac
+    shift
+done
+
+# Starting the dpl-eventgen simulation
+o2-sim-dpl-eventgen -b --generator external --nEvents $NEV --configFile $ini
\ No newline at end of file
diff --git a/run/SimExamples/ExternalToHybrid/sequential.json b/run/SimExamples/ExternalToHybrid/sequential.json
new file mode 100644
index 0000000000000..bfb810f745f6a
--- /dev/null
+++ b/run/SimExamples/ExternalToHybrid/sequential.json
@@ -0,0 +1,35 @@
+{
+  "generators": [
+    {
+      "name": "boxgen",
+      "config": {
+        "pdg": 443,
+        "number": 10,
+        "eta": [
+          -0.8,
+          0.8
+        ],
+        "prange": [
+          0.1,
+          5
+        ],
+        "phirange": [
+          0,
+          360
+        ]
+      }
+    },
+    {
+      "name": "external",
+      "config": {
+        "fileName": "",
+        "funcName": "",
+        "iniFile": "${O2DPG_MC_CONFIG_ROOT}/MC/config/examples/ini/GeneratorEPOS4_pp13TeV.ini"
+      }
+    }
+  ],
+  "fractions": [
+    1,
+    1
+  ]
+}
\ No newline at end of file

From c5c328283cc56fb8fe2d3d17912bf5e738cd02fe Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Fri, 16 Jan 2026 16:23:38 +0100
Subject: [PATCH 1209/1764] ALICE3-TRK: partial fix to issue #14959 (#14965)

* ALICE3-TRK: fix matrix path for cylindrical ML and OT geometries

* ALICE3-TRK: setting turboStaves and staggered layouts as default for ML and OT, respectively
---
 .../TRK/base/include/TRKBase/GeometryTGeo.h      |  4 ++++
 .../TRK/base/include/TRKBase/TRKBaseParam.h      |  7 +++++--
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx         | 16 ++++++++++++++++
 3 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index ee6f5f33fc9fe..deec53950cd5f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -15,6 +15,7 @@
 #include <memory>
 #include <DetectorsCommonDataFormats/DetMatrixCache.h>
 #include "DetectorsCommonDataFormats/DetID.h"
+#include "TRKBase/TRKBaseParam.h"
 
 namespace o2
 {
@@ -221,6 +222,9 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   std::vector<float> mCacheRefXMLOT;     /// cache for X of ML and OT
   std::vector<float> mCacheRefAlphaMLOT; /// cache for sensor ref alpha ML and OT
 
+  eLayout mLayoutML; // Type of segmentation for the middle layers
+  eLayout mLayoutOL; // Type of segmentation for the outer layers
+
  private:
   static std::unique_ptr<o2::trk::GeometryTGeo> sInstance;
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index 3f3f656c4b417..7f2f7f32b79d9 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -38,8 +38,11 @@ struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
 
   eOverallGeom overallGeom = kDefaultRadii; // Overall geometry option, to be used in Detector::buildTRKMiddleOuterLayers
 
-  eLayout layoutML = kCylinder; // Type of segmentation for the middle layers
-  eLayout layoutOL = kCylinder; // Type of segmentation for the outer layers
+  eLayout layoutML = kTurboStaves; // Type of segmentation for the middle layers
+  eLayout layoutOL = kStaggered;   // Type of segmentation for the outer layers
+
+  eLayout getLayoutML() const { return layoutML; }
+  eLayout getLayoutOL() const { return layoutOL; }
 
   O2ParamDef(TRKBaseParam, "TRKBase");
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index bfa23fe57c01a..b32c89164f18a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -76,6 +76,11 @@ void GeometryTGeo::Build(int loadTrans)
     LOGP(fatal, "Geometry is not loaded");
   }
 
+  mLayoutML = o2::trk::TRKBaseParam::Instance().getLayoutML();
+  mLayoutOL = o2::trk::TRKBaseParam::Instance().getLayoutOL();
+
+  LOG(debug) << "Layout ML: " << mLayoutML << ", Layout OL: " << mLayoutOL;
+
   mNumberOfLayersMLOT = extractNumberOfLayersMLOT();
   mNumberOfPetalsVD = extractNumberOfPetalsVD();
   mNumberOfActivePartsVD = extractNumberOfActivePartsVD();
@@ -398,6 +403,17 @@ TString GeometryTGeo::getMatrixPath(int index) const
   // TString path = "/cave_1/barrel_1/TRKV_2/TRKLayer0_1/TRKStave0_1/TRKChip0_1/TRKSensor0_1/"; /// dummy path, to be used for tests
   TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
 
+  // handling cylindrical configuration for ML and/or OT
+  // needed bercause of the different numbering scheme in the geometry for the cylindrical case wrt the staggered and turbo ones
+  if (subDetID == 1) {
+    if ((layer < 4 && mLayoutML == eLayout::kCylinder) || (layer > 3 && mLayoutOL == eLayout::kCylinder)) {
+      stave = 1;
+      mod = 1;
+      chip = 1;
+    }
+  }
+
+  // build the path
   if (subDetID == 0) { // VD
     if (disk >= 0) {
       path += Form("%s_%d_%d/", getTRKPetalAssemblyPattern(), petalcase, petalcase + 1);             // PETAL_n

From 8ead4583abb166786d6e76c6ca9f8fd90e595e76 Mon Sep 17 00:00:00 2001
From: tubagundem <tuba.gundem@cern.ch>
Date: Mon, 8 Dec 2025 15:58:08 +0100
Subject: [PATCH 1210/1764] TPC_MC_anchoring_simple: Added per region relative
 gas gain to simulate the change in the voltage settings of GEMs

---
 Detectors/TPC/base/include/TPCBase/ParameterGEM.h             | 1 +
 .../TPC/simulation/include/TPCSimulation/GEMAmplification.h   | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/Detectors/TPC/base/include/TPCBase/ParameterGEM.h b/Detectors/TPC/base/include/TPCBase/ParameterGEM.h
index 2d55a550764ac..cb458fbb5dafa 100644
--- a/Detectors/TPC/base/include/TPCBase/ParameterGEM.h
+++ b/Detectors/TPC/base/include/TPCBase/ParameterGEM.h
@@ -54,6 +54,7 @@ struct ParameterGEM : public o2::conf::ConfigurableParamHelper<ParameterGEM> {
   float AbsoluteGain[4] = {14.f, 8.f, 53.f, 240.f};              ///< Absolute gain
   float CollectionEfficiency[4] = {1.f, 0.2f, 0.25f, 1.f};       ///< Collection efficiency
   float ExtractionEfficiency[4] = {0.65f, 0.55f, 0.12f, 0.6f};   ///< Extraction efficiency
+  float RelativeGainStack[4] = {1.f, 1.f, 1.f, 1.f};             ///< Relative gain of the stack per region (IROC, OROC1, OROC2, OROC3) for the EffectiveMode
   float TotalGainStack = 2000.f;                                 ///< Total gain of the stack for the EffectiveMode
   float KappaStack = 1.205f;                                     ///< Variable steering the energy resolution of the full stack for the EffectiveMode
   float EfficiencyStack = 0.528f;                                ///< Variable steering the single electron efficiency of the full stack for the EffectiveMode
diff --git a/Detectors/TPC/simulation/include/TPCSimulation/GEMAmplification.h b/Detectors/TPC/simulation/include/TPCSimulation/GEMAmplification.h
index f5c40569fee43..8dbfa21febc69 100644
--- a/Detectors/TPC/simulation/include/TPCSimulation/GEMAmplification.h
+++ b/Detectors/TPC/simulation/include/TPCSimulation/GEMAmplification.h
@@ -118,8 +118,10 @@ inline int GEMAmplification::getStackAmplification(const CRU& cru, const PadPos&
       break;
     }
     case AmplificationMode::EffectiveMode: {
+      const int region = static_cast<int>(cru.gemStack());
+      const float relativeGain = mGEMParam->RelativeGainStack[region];
       return static_cast<int>(static_cast<float>(getEffectiveStackAmplification(nElectrons)) *
-                              mGainMap->getValue(cru, pos.getRow(), pos.getPad()));
+                              mGainMap->getValue(cru, pos.getRow(), pos.getPad()) * relativeGain);
       break;
     }
   }

From 7cd4b7f29f7daf912f5773149f9d96d7d707a21f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 17 Jan 2026 00:00:15 +0100
Subject: [PATCH 1211/1764] DPL: keep code checker happy (#14966)

The code checker complains about the unique_ptr going out of scope.

However this is a false positive because such unique_ptr has a custom
deletion policy to mimick the behavior of an observer_ptr.

In order to keep the code checker happy, we use release, so that the bare
pointer is returned without any complain. Given the custom deleter, the semantic
is actually the same.
---
 Framework/Core/include/Framework/AnalysisManagers.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 5112e3659f4aa..fd41a079c6570 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -170,7 +170,7 @@ bool newDataframeCondition(InputRecord&, C&)
 template <is_condition C>
 bool newDataframeCondition(InputRecord& record, C& condition)
 {
-  condition.instance = (typename C::type*)record.get<typename C::type*>(condition.path).get();
+  condition.instance = (typename C::type*)record.get<typename C::type*>(condition.path).release();
   return true;
 }
 

From db7170bd9cd8ba0fd5622a617af7d4f78b584cb3 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Sat, 17 Jan 2026 01:14:20 +0100
Subject: [PATCH 1212/1764] ALICE3-TRK: fix the length of the layers for the
 kCylinder layout for ML and OT (#14967)

---
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx         | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index a24a8eea0be27..c4683f28918d0 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -50,7 +50,7 @@ TGeoVolume* TRKLayer::createSensor(std::string type)
   TGeoShape* sensor;
 
   if (type == "cylinder") {
-    sensor = new TGeoTube(mInnerRadius, mInnerRadius + mSensorThickness, mChipLength / 2); // TO BE CHECKED !!!
+    sensor = new TGeoTube(mInnerRadius, mInnerRadius + mSensorThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2); // TO BE CHECKED !!!
   } else if (type == "flat") {
     sensor = new TGeoBBox((mChipWidth - mDeadzoneWidth) / 2, mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
   } else {
@@ -71,7 +71,7 @@ TGeoVolume* TRKLayer::createDeadzone(std::string type)
   TGeoShape* deadzone;
 
   if (type == "cylinder") {
-    deadzone = new TGeoTube(mInnerRadius, mInnerRadius + mSensorThickness, mChipLength / 2); // TO BE CHECKED !!!
+    deadzone = new TGeoTube(mInnerRadius, mInnerRadius + mSensorThickness, 0); // TO BE CHECKED !!!
   } else if (type == "flat") {
     deadzone = new TGeoBBox(mDeadzoneWidth / 2, mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
   } else {
@@ -92,7 +92,7 @@ TGeoVolume* TRKLayer::createMetalStack(std::string type)
   TGeoShape* metalStack;
 
   if (type == "cylinder") {
-    metalStack = new TGeoTube(mInnerRadius + mSensorThickness, mInnerRadius + mChipThickness, mChipLength / 2); // TO BE CHECKED !!!
+    metalStack = new TGeoTube(mInnerRadius + mSensorThickness, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2); // TO BE CHECKED !!!
   } else if (type == "flat") {
     metalStack = new TGeoBBox(mChipWidth / 2, (mChipThickness - mSensorThickness) / 2, mChipLength / 2); // TO BE CHECKED !!!
   } else {
@@ -118,7 +118,7 @@ TGeoVolume* TRKLayer::createChip(std::string type)
   TGeoVolume* metalVol;
 
   if (type == "cylinder") {
-    chip = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
+    chip = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
     chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
 
     sensVol = createSensor("cylinder");
@@ -175,7 +175,7 @@ TGeoVolume* TRKLayer::createModule(std::string type)
   TGeoVolume* moduleVol;
 
   if (type == "cylinder") {
-    module = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
+    module = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
     moduleVol = new TGeoVolume(moduleName.c_str(), module, medAir);
 
     TGeoVolume* chipVol = createChip("cylinder");
@@ -269,7 +269,7 @@ TGeoVolume* TRKLayer::createStave(std::string type)
   TGeoVolume* staveVol;
 
   if (type == "cylinder") {
-    stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
+    stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
 
     TGeoVolume* moduleVol = createModule("cylinder");
@@ -341,7 +341,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
   TGeoVolume* layerVol;
 
   if (mLayout == eLayout::kCylinder) {
-    layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, mChipLength / 2);
+    layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
     layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
 
     TGeoVolume* staveVol = createStave("cylinder");

From c5f00f245e4f185f7fb761b13bdd07d7ec659df2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Mon, 19 Jan 2026 08:37:02 +0100
Subject: [PATCH 1213/1764] A3: Fix geometry building of FT3 (#14968)

Added logging for material initialization and layout creation.
---
 .../ALICE3/FT3/simulation/src/FT3Module.cxx   | 53 +++++++++++--------
 1 file changed, 30 insertions(+), 23 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
index 87f5f27da6a38..efcad74bc2cb9 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -18,6 +18,7 @@
 #include <TGeoMedium.h>
 #include <TGeoBBox.h>
 #include <TGeoMatrix.h>
+#include <Framework/Logger.h>
 #include <cmath>
 #include <iostream>
 #include <vector>
@@ -41,12 +42,12 @@ TGeoMedium* FT3Module::AluminumMed = nullptr;
 
 void FT3Module::initialize_materials()
 {
-
+  LOG(debug) << "FT3Module: initialize_materials";
   if (siliconMat) {
     return;
   }
 
-  TGeoManager* gGeoManager = gGeoManager;
+  TGeoManager* geoManager = gGeoManager;
 
   auto* itsH = new TGeoElement("FT3_H", "Hydrogen", 1, 1.00794);
   auto* itsC = new TGeoElement("FT3_C", "Carbon", 6, 12.0107);
@@ -73,6 +74,7 @@ void FT3Module::initialize_materials()
 
   AluminumMat = new TGeoMaterial("Aluminum", 26.98, 13, 2.7);
   AluminumMed = new TGeoMedium("Aluminum", 5, AluminumMat);
+  LOG(debug) << "FT3Module: done initialize_materials";
 }
 
 double calculate_y_circle(double x, double radius)
@@ -83,7 +85,8 @@ double calculate_y_circle(double x, double radius)
 void FT3Module::create_layout(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume)
 {
 
-  TGeoManager* gGeoManager = gGeoManager;
+  LOG(debug) << "FT3Module: create_layout - Layer " << layerNumber << ", Direction " << direction << ", Face " << face;
+  TGeoManager* geoManager = gGeoManager;
 
   FT3Module::initialize_materials();
 
@@ -479,13 +482,13 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
               if (sensor_width == 2.5) {
                 // silicon
                 std::string sensor_name = "FT3sensor_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, active_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, active_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(SiColor);
                 sensor->SetFillColorAlpha(SiColor, 0.4);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift_sensor + x_offset, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
 
                 std::string inactive_name = "FT3inactive_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(inactive_name.c_str(), siliconMed, (sensor_width - active_width) / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(inactive_name.c_str(), siliconMed, (sensor_width - active_width) / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(kRed);
                 sensor->SetFillColorAlpha(kRed, 1.0);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
@@ -493,19 +496,19 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
               } else {
 
                 std::string sensor_name = "FT3sensor_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(SiColor);
                 sensor->SetFillColorAlpha(SiColor, 0.4);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + x + inactive_width / 2, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
 
                 std::string inactive_name_left = "FT3inactive_left_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(inactive_name_left.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(inactive_name_left.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(kRed);
                 sensor->SetFillColorAlpha(kRed, 1.0);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift_left, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
 
                 std::string inactive_name_right = "FT3inactive_right_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(inactive_name_right.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(inactive_name_right.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(kRed);
                 sensor->SetFillColorAlpha(kRed, 1.0);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift_right, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness - silicon_thickness / 2));
@@ -513,21 +516,21 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
               // silicon-to-FPC epoxy glue
               std::string glue_up_name = "FT3glue_up_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-              sensor = gGeoManager->MakeBox(glue_up_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
+              sensor = geoManager->MakeBox(glue_up_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
               sensor->SetLineColor(kBlue);
               sensor->SetFillColorAlpha(kBlue, 1.0);
               motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + active_x_shift, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness - epoxy_thickness / 2));
 
               if (r_squared < R_material_threshold * R_material_threshold) {
                 std::string alu_name = "FT3aluminum_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(alu_name.c_str(), AluminumMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
+                sensor = geoManager->MakeBox(alu_name.c_str(), AluminumMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
                 sensor->SetLineColor(kBlack);
                 sensor->SetFillColorAlpha(kBlack, 0.4);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness / 2));
 
               } else {
                 std::string copper_name = "FT3copper_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(copper_name.c_str(), copperMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
+                sensor = geoManager->MakeBox(copper_name.c_str(), copperMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
                 sensor->SetLineColor(kBlack);
                 sensor->SetFillColorAlpha(kBlack, 0.4);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness - copper_thickness / 2));
@@ -535,14 +538,14 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
               // kapton
               std::string fpc_name = "FT3fpc_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-              sensor = gGeoManager->MakeBox(fpc_name.c_str(), kaptonMed, sensor_width / 2, sensor_height / 2, kapton_thickness / 2);
+              sensor = geoManager->MakeBox(fpc_name.c_str(), kaptonMed, sensor_width / 2, sensor_height / 2, kapton_thickness / 2);
               sensor->SetLineColor(kGreen);
               sensor->SetFillColorAlpha(kGreen, 0.4);
               motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset - epoxy_thickness - kapton_thickness / 2));
 
               // FPC-to-support epoxy glue
               std::string glue_down_name = "FT3glue_down_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-              sensor = gGeoManager->MakeBox(glue_down_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
+              sensor = geoManager->MakeBox(glue_down_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
               sensor->SetLineColor(kBlue);
               sensor->SetFillColorAlpha(kBlue, 1.0);
               motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + active_x_shift, y + y_offset, mZ + z_offset - epoxy_thickness / 2));
@@ -612,14 +615,14 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
               // FPC-to-support epoxy glue
               std::string glue_down_name = "FT3glue_down_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-              sensor = gGeoManager->MakeBox(glue_down_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
+              sensor = geoManager->MakeBox(glue_down_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
               sensor->SetLineColor(kBlue);
               sensor->SetFillColorAlpha(kBlue, 1.0);
               motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + active_x_shift, y + y_offset, mZ + z_offset + epoxy_thickness / 2));
 
               // Kapton
               std::string fpc_name = "FT3fpc_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-              sensor = gGeoManager->MakeBox(fpc_name.c_str(), kaptonMed, sensor_width / 2, sensor_height / 2, kapton_thickness / 2);
+              sensor = geoManager->MakeBox(fpc_name.c_str(), kaptonMed, sensor_width / 2, sensor_height / 2, kapton_thickness / 2);
               sensor->SetLineColor(kGreen);
               sensor->SetFillColorAlpha(kGreen, 0.4);
               motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness / 2));
@@ -627,14 +630,14 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
               if (r_squared < R_material_threshold * R_material_threshold) {
                 // replace copper with alu
                 std::string alu_name = "FT3aluminum_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(alu_name.c_str(), AluminumMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
+                sensor = geoManager->MakeBox(alu_name.c_str(), AluminumMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
                 sensor->SetLineColor(kBlack);
                 sensor->SetFillColorAlpha(kBlack, 0.4);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness / 2));
 
               } else {
                 std::string copper_name = "FT3copper_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(copper_name.c_str(), copperMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
+                sensor = geoManager->MakeBox(copper_name.c_str(), copperMed, sensor_width / 2, sensor_height / 2, copper_thickness / 2);
                 sensor->SetLineColor(kBlack);
                 sensor->SetFillColorAlpha(kBlack, 0.4);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift + x_offset, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness / 2));
@@ -642,7 +645,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
               // silicon-to-FPC epoxy glue
               std::string glue_up_name = "FT3glue_up_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-              sensor = gGeoManager->MakeBox(glue_up_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
+              sensor = geoManager->MakeBox(glue_up_name.c_str(), epoxyMed, sensor_width / 2, sensor_height / 2, epoxy_thickness / 2);
               sensor->SetLineColor(kBlue);
               sensor->SetFillColorAlpha(kBlue, 1.0);
               motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + active_x_shift, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness / 2));
@@ -650,13 +653,13 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
               if (sensor_width == 2.5) {
 
                 std::string sensor_name = "FT3sensor_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, active_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, active_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(SiColor);
                 sensor->SetFillColorAlpha(SiColor, 0.4);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(active_x_shift_sensor + x_offset, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
 
                 std::string inactive_name = "FT3inactive_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(inactive_name.c_str(), siliconMed, (sensor_width - active_width) / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(inactive_name.c_str(), siliconMed, (sensor_width - active_width) / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(kRed);
                 sensor->SetFillColorAlpha(kRed, 1.0);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
@@ -664,21 +667,21 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
               } else {
                 // active (4.6 cm centered)
                 std::string sensor_name = "FT3sensor_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(SiColor);
                 sensor->SetFillColorAlpha(SiColor, 0.4);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + x_shifted + inactive_width / 2, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
 
                 // left inactive strip
                 std::string inactive_name_left = "FT3inactive_left_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(inactive_name_left.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(inactive_name_left.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(kRed);
                 sensor->SetFillColorAlpha(kRed, 1.0);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift_left, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
 
                 // right inactive strip
                 std::string inactive_name_right = "FT3inactive_right_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-                sensor = gGeoManager->MakeBox(inactive_name_right.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
+                sensor = geoManager->MakeBox(inactive_name_right.c_str(), siliconMed, inactive_width / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(kRed);
                 sensor->SetFillColorAlpha(kRed, 1.0);
                 motherVolume->AddNode(sensor, sensor_count++, new TGeoTranslation(x_offset + inactive_x_shift_right, y + y_offset, mZ + z_offset + epoxy_thickness + kapton_thickness + copper_thickness + epoxy_thickness + silicon_thickness / 2));
@@ -691,9 +694,13 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
       rowCounter++;
     }
   }
+  LOG(debug) << "FT3Module: done create_layout";
 }
 
 void FT3Module::createModule(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume)
 {
+
+  LOG(debug) << "FT3Module: createModule - Layer " << layerNumber << ", Direction " << direction << ", Face " << face;
   create_layout(mZ, layerNumber, direction, Rin, Rout, overlap, face, layout_type, motherVolume);
+  LOG(debug) << "FT3Module: done createModule";
 }

From 705c73cda6dded60f2fe39c724842959b76134b6 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 16 Jan 2026 10:08:08 +0100
Subject: [PATCH 1214/1764] GPU CUDA: Do not link against nvrtc library, which
 is not used

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index e7a579bec794d..05ed091eb83ea 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -148,7 +148,7 @@ if (onnxruntime_FOUND)
 endif()
 
 # Setting target architecture and adding GPU libraries
-target_link_libraries(${targetName} PRIVATE cuda cudart nvrtc)
+target_link_libraries(${targetName} PRIVATE cuda cudart)
 set_target_cuda_arch(${targetName})
 #target_link_options(${targetName} PRIVATE "LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/version_script.ld")
 #set_target_properties(${targetName} PROPERTIES LINK_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/version_script.ld)

From 36b13b4dde9cce37ed414ea310d8a6a635d4ce31 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 16 Jan 2026 10:36:46 +0100
Subject: [PATCH 1215/1764] GPU: Fix direct memory allocation debug message

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index ef336526080b9..fbbe815f63c33 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -764,7 +764,7 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
   }
   UpdateMaxMemoryUsed();
   if (GetProcessingSettings().allocDebugLevel >= 2) {
-    std::cout << "Allocated (unmanaged " << (type == GPUMemoryResource::MEMORY_GPU ? "gpu" : "host") << "): " << size << " - available: " << ptrDiff(poolend, pool) << "\n";
+    std::cout << "Allocated (unmanaged " << ((type & GPUMemoryResource::MEMORY_GPU) ? "gpu" : "host") << "): " << size << " - available: " << ptrDiff(poolend, pool) << "\n";
   }
   return retVal;
 }

From 9ca7f3a7219d04b10219c6a653b9bf91cd2bf94c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 16 Jan 2026 10:49:17 +0100
Subject: [PATCH 1216/1764] GPU: Fix crash with --noEvents option, and improve
 some debug messages

---
 .../Standalone/Benchmark/standalone.cxx       | 36 ++++++++++---------
 1 file changed, 20 insertions(+), 16 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index b9825bc6da481..5fa9da23d7423 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -173,7 +173,7 @@ int32_t ReadConfiguration(int argc, char** argv)
     return 1;
   }
   if (configStandalone.proc.doublePipeline && (configStandalone.runs < 4 || !configStandalone.outputcontrolmem)) {
-    printf("Double pipeline mode needs at least 3 runs per event and external output. To cycle though multiple events, use --preloadEvents and --runs n for n iterations round-robin\n");
+    printf("Double pipeline mode needs at least 4 runs per event and external output. To cycle though multiple events, use --preloadEvents and --runs n for n iterations round-robin\n");
     return 1;
   }
   if (configStandalone.TF.bunchSim && configStandalone.TF.nMerge) {
@@ -297,7 +297,8 @@ int32_t SetupReconstruction()
       printf("Error reading event config file\n");
       return 1;
     }
-    printf("Read event settings from dir %s (solenoidBz: %f, constBz %d, maxTimeBin %d)\n", eventsDir.c_str(), rec->GetGRPSettings().solenoidBzNominalGPU, (int32_t)rec->GetGRPSettings().constBz, rec->GetGRPSettings().grpContinuousMaxTimeBin);
+    const char* tmptext = configStandalone.noEvents ? "Using default event settings, no event dir loaded" : "Read event settings from dir ";
+    printf("%s%s (solenoidBz: %f, constBz %d, maxTimeBin %d)\n", tmptext, configStandalone.noEvents ? "" : eventsDir.c_str(), rec->GetGRPSettings().solenoidBzNominalGPU, (int32_t)rec->GetGRPSettings().constBz, rec->GetGRPSettings().grpContinuousMaxTimeBin);
     if (configStandalone.testSyncAsync) {
       recAsync->ReadSettings(eventsDir.c_str());
     }
@@ -781,13 +782,17 @@ int32_t main(int argc, char** argv)
 
   srand(configStandalone.seed);
 
-  for (nEventsInDirectory = 0; true; nEventsInDirectory++) {
-    std::ifstream in;
-    in.open((eventsDir + GPUCA_EVDUMP_FILE "." + std::to_string(nEventsInDirectory) + ".dump").c_str(), std::ifstream::binary);
-    if (in.fail()) {
-      break;
+  nEventsInDirectory = 0;
+  if (!configStandalone.noEvents) {
+    while (true) {
+      std::ifstream in;
+      in.open((eventsDir + GPUCA_EVDUMP_FILE "." + std::to_string(nEventsInDirectory) + ".dump").c_str(), std::ifstream::binary);
+      if (in.fail()) {
+        break;
+      }
+      in.close();
+      nEventsInDirectory++;
     }
-    in.close();
   }
 
   if (configStandalone.TF.bunchSim || configStandalone.TF.nMerge) {
@@ -824,11 +829,7 @@ int32_t main(int argc, char** argv)
     fflush(stdout);
     for (int32_t i = 0; i < nEvents - configStandalone.StartEvent; i++) {
       LoadEvent(configStandalone.StartEvent + i, i);
-      if (configStandalone.proc.debugLevel >= 2) {
-        printf("Loading event %d\n", i);
-      } else {
-        printf(" %d", i);
-      }
+      printf(configStandalone.proc.debugLevel >= 2 ? "Loading event %d\n" : " %d", i + configStandalone.StartEvent);
       fflush(stdout);
     }
     printf("\n");
@@ -856,7 +857,7 @@ int32_t main(int argc, char** argv)
       if (iEvent != configStandalone.StartEvent) {
         printf("\n");
       }
-      if (configStandalone.noEvents == false && !configStandalone.preloadEvents) {
+      if (!configStandalone.noEvents && !configStandalone.preloadEvents) {
         HighResTimer timerLoad;
         timerLoad.Start();
         if (LoadEvent(iEvent, 0)) {
@@ -889,12 +890,14 @@ int32_t main(int argc, char** argv)
         }
         printf("Loading time: %'d us\n", (int32_t)(1000000 * timerLoad.GetCurrentElapsedTime()));
       }
-      printf("Processing Event %d\n", iEvent);
 
       nIteration.store(0);
       nIterationEnd.store(0);
       double pipelineWalltime = 1.;
-      if (configStandalone.proc.doublePipeline) {
+      if (configStandalone.noEvents) {
+        printf("No processing, no events loaded\n");
+      } else if (configStandalone.proc.doublePipeline) {
+        printf(configStandalone.preloadEvents ? "Processing Events %d to %d in Pipeline\n" : "Processing Event %d in Pipeline %d times\n", iEvent, configStandalone.preloadEvents ? std::min(iEvent + configStandalone.runs - 1, nEvents - 1) : configStandalone.runs);
         HighResTimer timerPipeline;
         if (configStandalone.proc.debugLevel < 2 && (RunBenchmark(rec, chainTracking, 1, iEvent, &nTracksTotal, &nClustersTotal) || RunBenchmark(recPipeline, chainTrackingPipeline, 2, iEvent, &nTracksTotal, &nClustersTotal))) {
           goto breakrun;
@@ -907,6 +910,7 @@ int32_t main(int argc, char** argv)
         pipelineWalltime = timerPipeline.GetElapsedTime() / (configStandalone.runs - 2);
         printf("Pipeline wall time: %f, %d iterations, %f per event\n", timerPipeline.GetElapsedTime(), configStandalone.runs - 2, pipelineWalltime);
       } else {
+        printf("Processing Event %d\n", iEvent);
         if (RunBenchmark(rec, chainTracking, configStandalone.runs, iEvent, &nTracksTotal, &nClustersTotal)) {
           goto breakrun;
         }

From fbe64c88c1e007d21024fbfd7f799a6fe4b1918a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 15 Jan 2026 22:35:14 +0100
Subject: [PATCH 1217/1764] Optionally refit ITS outward seeding with inward
 refit result

By default set to false as no effect of repeating this fit was seen so far.
---
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  1 +
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  1 +
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 32 +++++++++++++++++++
 .../include/ITStracking/Configuration.h       |  1 +
 .../include/ITStracking/TrackingConfigParam.h |  1 +
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |  1 +
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 16 ++++++++++
 7 files changed, 53 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index a4e4328b3aa22..6e0427f5413ba 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -219,6 +219,7 @@ void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const float maxChi2ClusterAttachment,
                       const float maxChi2NDF,
                       const int reseedIfShorter,
+                      const bool repeatRefitOut,
                       const bool shiftRefToCluster,
                       const o2::base::Propagator* propagator,
                       const o2::base::PropagatorF::MatCorrType matCorrType,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index f94147747a475..c4a5cfb4e26b3 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -336,6 +336,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                      startLevel,                                       // const int startLevel,
                      this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
                      this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
+                     this->mTrkParams[0].RepeatRefitOut,
                      this->mTrkParams[0].ReseedIfShorter,
                      this->mTrkParams[0].ShiftRefToCluster,
                      mTimeFrameGPU->getDevicePropagator(), // const o2::base::Propagator* propagator
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index d9136cb96d00e..85689488f5f6e 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -291,6 +291,7 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   const float maxChi2ClusterAttachment,
   const float maxChi2NDF,
   const int reseedIfShorter,
+  const bool repeatRefitOut,
   const bool shifRefToCluster,
   const o2::base::Propagator* propagator,
   const o2::base::PropagatorF::MatCorrType matCorrType)
@@ -337,6 +338,34 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
     if (!fitSuccess || temporaryTrack.getPt() < minPts[nLayers - temporaryTrack.getNClusters()]) {
       continue;
     }
+    if (repeatRefitOut) { // repeat outward refit seeding and linearizing with the stable inward fit result
+      o2::track::TrackParCov saveInw{temporaryTrack};
+      linRef = saveInw; // use refitted track as lin.reference
+      float saveChi2 = temporaryTrack.getChi2();
+      temporaryTrack.resetCovariance();
+      temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
+      temporaryTrack.setChi2(0);
+      fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
+                            0,                            // int lastLayer,
+                            nLayers,                      // int firstLayer,
+                            1,                            // int firstCluster,
+                            maxChi2ClusterAttachment,     // float maxChi2ClusterAttachment,
+                            maxChi2NDF,                   // float maxChi2NDF,
+                            o2::constants::math::VeryBig, // float maxQoverPt,
+                            0,                            // nCl,
+                            bz,                           // float bz,
+                            foundTrackingFrameInfo,       // TrackingFrameInfo** trackingFrameInfo,
+                            propagator,                   // const o2::base::Propagator* propagator,
+                            matCorrType,                  // o2::base::PropagatorF::MatCorrType matCorrType
+                            &linRef,
+                            shifRefToCluster);
+      if (!fitSuccess) {
+        continue;
+      }
+      temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+      temporaryTrack.getParamIn() = saveInw;
+      temporaryTrack.setChi2(saveChi2);
+    }
     tracks[iCurrentTrackSeedIndex] = temporaryTrack;
   }
 }
@@ -1174,6 +1203,7 @@ void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
                       const float maxChi2ClusterAttachment,
                       const float maxChi2NDF,
                       const int reseedIfShorter,
+                      const bool repeatRefitOut,
                       const bool shiftRefToCluster,
                       const o2::base::Propagator* propagator,
                       const o2::base::PropagatorF::MatCorrType matCorrType,
@@ -1195,6 +1225,7 @@ void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
     maxChi2ClusterAttachment,                 // float
     maxChi2NDF,                               // float
     reseedIfShorter,                          // int
+    repeatRefitOut,                           // bool
     shiftRefToCluster,                        // bool
     propagator,                               // const o2::base::Propagator*
     matCorrType);                             // o2::base::PropagatorF::MatCorrType
@@ -1375,6 +1406,7 @@ template void trackSeedHandler(CellSeed<7>* trackSeeds,
                                const float maxChi2ClusterAttachment,
                                const float maxChi2NDF,
                                const int reseedIfShorter,
+                               const bool repeatRefitOut,
                                const bool shiftRefToCluster,
                                const o2::base::Propagator* propagator,
                                const o2::base::PropagatorF::MatCorrType matCorrType,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 000c8fe822498..1019a3e3d45a9 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -69,6 +69,7 @@ struct TrackingParameters {
   int ReseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
   unsigned char StartLayerMask = 0x7F;
+  bool RepeatRefitOut = true;    // repeat outward refit using inward refit as a seed
   bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool FindShortTracks = false;
   bool PerPrimaryVertexProcessing = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 2a3506f17fa2f..0529bd53f2073 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -98,6 +98,7 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   int nIterations = MaxIter;               // overwrite the number of iterations
   int reseedIfShorter = 6;                 // for the final refit reseed the track with circle if they are shorter than this value
   bool shiftRefToCluster{true};            // TrackFit: after update shift the linearization reference to cluster
+  bool repeatRefitOut{false};              // repeat outward refit using inward refit as a seed
   bool createArtefactLabels{false}; // create on-the-fly labels for the artefacts
 
   int nThreads = 1;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 87787eeee03a9..202dc87f04237 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -187,6 +187,7 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       p.MinPt[lslot] *= bFactor;
     }
     p.ReseedIfShorter = tc.reseedIfShorter;
+    p.RepeatRefitOut = tc.repeatRefitOut;
     p.ShiftRefToCluster = tc.shiftRefToCluster;
     p.createArtefactLabels = tc.createArtefactLabels;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 6b237ad0a63e8..fe67eadaf6f72 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -778,6 +778,22 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
           return 0;
         }
+        if (mTrkParams[0].RepeatRefitOut) { // repeat outward refit seeding and linearizing with the stable inward fit result
+          o2::track::TrackParCov saveInw{temporaryTrack};
+          linRef = saveInw; // use refitted track as lin.reference
+          float saveChi2 = temporaryTrack.getChi2();
+          temporaryTrack.resetCovariance();
+          temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
+          temporaryTrack.setChi2(0);
+          fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, o2::constants::math::VeryBig, 0, &linRef);
+          if (!fitSuccess) {
+            return 0;
+          }
+          temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+          temporaryTrack.getParamIn() = saveInw;
+          temporaryTrack.setChi2(saveChi2);
+        }
+
         if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
           tracks.push_back(temporaryTrack);
         } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {

From dd6691384326f1f46bd7e186d1550c116152ea97 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Mon, 19 Jan 2026 10:52:57 +0100
Subject: [PATCH 1218/1764] dpl-workflow.sh: increase
 pvertexer.timeMarginVertexTime to 5 for sync raw pp

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index db491da5ebec5..f55605d1da485 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -133,7 +133,7 @@ if [[ $SYNCMODE == 1 ]]; then
 
   PVERTEXING_CONFIG_KEY+="pvertexer.meanVertexExtraErrConstraint=0.3;" # for calibration relax the constraint
   if [[ $SYNCRAWMODE == 1 ]]; then # add extra tolerance in sync mode to account for eventual time misalignment
-    PVERTEXING_CONFIG_KEY+="pvertexer.timeMarginVertexTime=2.5;"
+    [[ $BEAMTYPE == "pp" ]] && PVERTEXING_CONFIG_KEY+="pvertexer.timeMarginVertexTime=5;" || PVERTEXING_CONFIG_KEY+="pvertexer.timeMarginVertexTime=2.5;"
     if [[ -z $ITSEXTRAERR ]]; then # in sync mode account for ITS residual misalignment
       ERRIB="100e-8"
       ERROB="100e-8"

From c990996954857d60b683fadc3bc037f055276c5d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 19 Jan 2026 20:51:36 +0100
Subject: [PATCH 1219/1764] DPL Analysis: Use dangling edges context in more
 places (#14953)

---
 .../AnalysisSupport/src/AODWriterHelpers.cxx  | 21 ++++---
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   | 59 ++++++++++---------
 .../CCDBSupport/src/AnalysisCCDBHelpers.h     |  2 +-
 .../Core/include/Framework/AnalysisTask.h     |  4 +-
 Framework/Core/src/AnalysisSupportHelpers.cxx |  4 +-
 5 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index d868b7498fb76..b76ffca13977e 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -62,13 +62,13 @@ const static std::unordered_map<OutputObjHandlingPolicy, std::string> ROOTfileNa
 
 AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
 {
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
   auto dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
   int compressionLevel = 505;
   if (ctx.options().hasOption("aod-writer-compression")) {
     compressionLevel = ctx.options().get<int>("aod-writer-compression");
   }
-  return AlgorithmSpec{[dod, outputInputs = ac.outputsInputsAOD, compressionLevel](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+  return AlgorithmSpec{[dod, compressionLevel](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+    auto outputInputs = ic.services().get<DanglingEdgesContext>().outputsInputsAOD;
     LOGP(debug, "======== getGlobalAODSink::Init ==========");
 
     // find out if any table needs to be saved
@@ -241,14 +241,13 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
   };
 }
 
-AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
+AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& /*ctx*/)
 {
-  using namespace monitoring;
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
-  auto tskmap = ac.outTskMap;
-  auto objmap = ac.outObjHistMap;
-
-  return AlgorithmSpec{[objmap, tskmap](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+  return AlgorithmSpec{[](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+    using namespace monitoring;
+    auto& dec = ic.services().get<DanglingEdgesContext>();
+    auto tskmap = dec.outTskMap;
+    auto objmap = dec.outObjHistMap;
     auto& callbacks = ic.services().get<CallbackService>();
     auto inputObjects = std::make_shared<std::vector<std::pair<InputObjectRoute, InputObject>>>();
 
@@ -278,7 +277,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 
     callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
     return [inputObjects, objmap, tskmap](ProcessingContext& pc) mutable -> void {
-      auto mergePart = [&inputObjects, &objmap, &tskmap, &pc](DataRef const& ref) {
+      auto mergePart = [&inputObjects, &objmap, &tskmap](DataRef const& ref) {
         O2_SIGNPOST_ID_GENERATE(hid, histogram_registry);
         O2_SIGNPOST_START(histogram_registry, hid, "mergePart", "Merging histogram");
         if (!ref.header) {
@@ -474,7 +473,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
       };
       O2_SIGNPOST_ID_GENERATE(rid, histogram_registry);
       O2_SIGNPOST_START(histogram_registry, rid, "processParts", "Start merging %zu parts received together.", pc.inputs().getNofParts(0));
-      for (int pi = 0; pi < pc.inputs().getNofParts(0); ++pi) {
+      for (auto pi = 0U; pi < pc.inputs().getNofParts(0); ++pi) {
         mergePart(pc.inputs().get("x", pi));
       }
       O2_SIGNPOST_END(histogram_registry, rid, "processParts", "Done histograms in multipart message.");
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index 9ec911518f754..413adfddecf04 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -67,38 +67,39 @@ void fillValidRoutes(CCDBFetcherHelper& helper, std::vector<o2::framework::Outpu
 }
 } // namespace
 
-AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
+AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
 {
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
-  std::vector<std::shared_ptr<arrow::Schema>> schemas;
-  auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
+  return adaptStateful([](ConfigParamRegistry const& options, DeviceSpec const& spec, InitContext& ic) {
+    auto& dec = ic.services().get<DanglingEdgesContext>();
+    std::vector<std::shared_ptr<arrow::Schema>> schemas;
+    auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
 
-  for (auto& input : ac.analysisCCDBInputs) {
-    std::vector<std::shared_ptr<arrow::Field>> fields;
-    schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
-    schemaMetadata->Append("outputBinding", input.binding);
+    for (auto& input : dec.analysisCCDBInputs) {
+      std::vector<std::shared_ptr<arrow::Field>> fields;
+      schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
+      schemaMetadata->Append("outputBinding", input.binding);
 
-    for (auto& m : input.metadata) {
-      // Save the list of input tables
-      if (m.name.starts_with("input:")) {
-        auto name = m.name.substr(6);
-        schemaMetadata->Append("sourceTable", name);
-        schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
-        continue;
-      }
-      // Ignore the non ccdb: entries
-      if (!m.name.starts_with("ccdb:")) {
-        continue;
+      for (auto& m : input.metadata) {
+        // Save the list of input tables
+        if (m.name.starts_with("input:")) {
+          auto name = m.name.substr(6);
+          schemaMetadata->Append("sourceTable", name);
+          schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
+          continue;
+        }
+        // Ignore the non ccdb: entries
+        if (!m.name.starts_with("ccdb:")) {
+          continue;
+        }
+        // Create the schema of the output
+        auto metadata = std::make_shared<arrow::KeyValueMetadata>();
+        metadata->Append("url", m.defaultValue.asString());
+        auto columnName = m.name.substr(strlen("ccdb:"));
+        fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
       }
-      // Create the schema of the output
-      auto metadata = std::make_shared<arrow::KeyValueMetadata>();
-      metadata->Append("url", m.defaultValue.asString());
-      auto columnName = m.name.substr(strlen("ccdb:"));
-      fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
+      schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
     }
-    schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
-  }
-  return adaptStateful([schemas](CallbackService& callbacks, ConfigParamRegistry const& options, DeviceSpec const& spec) {
+
     std::shared_ptr<CCDBFetcherHelper> helper = std::make_shared<CCDBFetcherHelper>();
     CCDBFetcherHelper::initialiseHelper(*helper, options);
     std::unordered_map<std::string, int> bindings;
@@ -129,11 +130,11 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
         int outputRouteIndex = bindings.at(outRouteDesc);
         auto& spec = helper->routes[outputRouteIndex].matcher;
         std::vector<std::shared_ptr<arrow::BinaryViewBuilder>> builders;
-        for (auto& _ : schema->fields()) {
+        for (auto const& _ : schema->fields()) {
           builders.emplace_back(std::make_shared<arrow::BinaryViewBuilder>());
         }
 
-        for (size_t ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
+        for (auto ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
           std::shared_ptr<arrow::Array> chunk = timestampColumn->chunk(ci);
           auto const* timestamps = chunk->data()->GetValuesSafe<size_t>(1);
 
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
index f8175034da0ba..3be2138bd2b5c 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
@@ -17,7 +17,7 @@ namespace o2::framework
 {
 
 struct AnalysisCCDBHelpers {
-  static AlgorithmSpec fetchFromCCDB(ConfigContext const& ctx);
+  static AlgorithmSpec fetchFromCCDB(ConfigContext const&);
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index c50b5358990de..4f8a9e719e4b9 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -521,7 +521,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<ExpressionInfo> expressionInfos;
 
   /// make sure options and configurables are set before expression infos are created
-  homogeneous_apply_refs([&options, &hash](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
+  homogeneous_apply_refs([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
   /// extract conditions and append them as inputs
   homogeneous_apply_refs([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
 
@@ -620,7 +620,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
       }
       // reset pre-slice for the next dataframe
       auto slices = pc.services().get<ArrowTableSlicingCache>();
-      homogeneous_apply_refs([&pc, &slices](auto& element) {
+      homogeneous_apply_refs([&slices](auto& element) {
         return analysis_task_parsers::updateSliceInfo(element, slices);
       },
                              *(task.get()));
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index 15b56f9afbff5..7edf9a2d8d27f 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -98,7 +98,7 @@ std::shared_ptr<DataOutputDirector> AnalysisSupportHelpers::getDataOutputDirecto
     if (!keepString.empty()) {
       dod->reset();
       std::string d("dangling");
-      if (d.find(keepString) == 0) {
+      if (d.starts_with(keepString) == 0) {
         // use the dangling outputs
         std::vector<InputSpec> danglingOutputs;
         for (auto ii = 0u; ii < OutputsInputs.size(); ii++) {
@@ -144,7 +144,7 @@ void AnalysisSupportHelpers::addMissingOutputsToSpawner(std::vector<OutputSpec>
     sinks::append_to{publisher.outputs}; // append them to the publisher outputs
 
   std::vector<InputSpec> additionalInputs;
-  for (auto& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
+  for (auto const& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
     input.metadata |
       views::filter_string_params_with("input:") |
       views::params_to_input_specs() |

From a6471db3246688e5ad4302754449cc9b6f756a81 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 19 Jan 2026 13:59:07 +0100
Subject: [PATCH 1220/1764] DPL: more preparation for earlier forwarding

Separate code in a different commit to minimize the critical changes.
---
 Framework/Core/src/DataProcessingDevice.cxx | 60 +++++++++++++++++++++
 Framework/Core/src/DataRelayer.cxx          |  9 ++--
 2 files changed, 66 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 343b567d8b852..91f5fd0c2d547 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -617,6 +617,20 @@ static auto forwardInputs = [](ServiceRegistryRef registry, TimesliceSlot slot,
   O2_SIGNPOST_END(forwarding, sid, "forwardInputs", "Forwarding done");
 };
 
+static auto cleanEarlyForward = [](ServiceRegistryRef registry, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
+                                   TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume = true) {
+  auto& proxy = registry.get<FairMQDeviceProxy>();
+
+  O2_SIGNPOST_ID_GENERATE(sid, forwarding);
+  O2_SIGNPOST_START(forwarding, sid, "forwardInputs", "Cleaning up slot %zu with oldestTimeslice %zu %{public}s%{public}s%{public}s",
+                    slot.index, oldestTimeslice.timeslice.value, copy ? "with copy" : "", copy && consume ? " and " : "", consume ? "with consume" : "");
+  // Always copy them, because we do not want to actually send them.
+  // We merely need the side effect of the consume, if applicable.
+  auto forwardedParts = DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, true, consume);
+
+  O2_SIGNPOST_END(forwarding, sid, "forwardInputs", "Forwarding done");
+};
+
 extern volatile int region_read_global_dummy_variable;
 volatile int region_read_global_dummy_variable;
 
@@ -1680,6 +1694,51 @@ struct WaitBackpressurePolicy {
   }
 };
 
+auto forwardOnInsertion(ServiceRegistryRef& ref, std::span<fair::mq::MessagePtr>& messages) -> void
+{
+  O2_SIGNPOST_ID_GENERATE(sid, forwarding);
+
+  auto& spec = ref.get<DeviceSpec const>();
+  auto& context = ref.get<DataProcessorContext>();
+  if (!context.canForwardEarly || spec.forwards.empty()) {
+    O2_SIGNPOST_EVENT_EMIT(device, sid, "device", "Early forwardinding not enabled / needed.");
+    return;
+  }
+
+  O2_SIGNPOST_EVENT_EMIT(device, sid, "device", "Early forwardinding before injecting data into relayer.");
+  auto& timesliceIndex = ref.get<TimesliceIndex>();
+  auto oldestTimeslice = timesliceIndex.getOldestPossibleOutput();
+
+  auto& proxy = ref.get<FairMQDeviceProxy>();
+
+  O2_SIGNPOST_START(forwarding, sid, "forwardInputs",
+                    "Starting forwarding for incoming messages with oldestTimeslice %zu with copy",
+                    oldestTimeslice.timeslice.value);
+  std::vector<fair::mq::Parts> forwardedParts(proxy.getNumForwardChannels());
+  DataProcessingHelpers::routeForwardedMessages(proxy, messages, forwardedParts, true, false);
+
+  for (int fi = 0; fi < proxy.getNumForwardChannels(); fi++) {
+    if (forwardedParts[fi].Size() == 0) {
+      continue;
+    }
+    ForwardChannelInfo info = proxy.getForwardChannelInfo(ChannelIndex{fi});
+    auto& parts = forwardedParts[fi];
+    if (info.policy == nullptr) {
+      O2_SIGNPOST_EVENT_EMIT_ERROR(forwarding, sid, "forwardInputs", "Forwarding to %{public}s %d has no policy.", info.name.c_str(), fi);
+      continue;
+    }
+    O2_SIGNPOST_EVENT_EMIT(forwarding, sid, "forwardInputs", "Forwarding to %{public}s %d", info.name.c_str(), fi);
+    info.policy->forward(parts, ChannelIndex{fi}, ref);
+  }
+  auto& asyncQueue = ref.get<AsyncQueue>();
+  auto& decongestion = ref.get<DecongestionService>();
+  O2_SIGNPOST_ID_GENERATE(aid, async_queue);
+  O2_SIGNPOST_EVENT_EMIT(async_queue, aid, "forwardInputs", "Queuing forwarding oldestPossible %zu", oldestTimeslice.timeslice.value);
+  AsyncQueueHelpers::post(asyncQueue, AsyncTask{.timeslice = oldestTimeslice.timeslice, .id = decongestion.oldestPossibleTimesliceTask, .debounce = -1, .callback = decongestionCallbackLate}
+                                        .user<DecongestionContext>({.ref = ref, .oldestTimeslice = oldestTimeslice}));
+  O2_SIGNPOST_END(forwarding, sid, "forwardInputs", "Forwarding done");
+};
+
 /// This is the inner loop of our framework. The actual implementation
 /// is divided in two parts. In the first one we define a set of lambdas
 /// which describe what is actually going to happen, hiding all the state
@@ -1854,6 +1913,7 @@ void DataProcessingDevice::handleData(ServiceRegistryRef ref, InputChannelInfo&
             VariableContextHelpers::getTimeslice(variables);
             forwardInputs(ref, slot, dropped, oldestOutputInfo, false, true);
           };
+
           auto relayed = relayer.relay(parts.At(headerIndex)->GetData(),
                                        &parts.At(headerIndex),
                                        input,
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index ea2c4c0b73316..d9c340cd9c225 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -499,6 +499,12 @@ DataRelayer::RelayChoice
     // DataRelayer::relay
     assert(nPayloads > 0);
     size_t saved = 0;
+    // It's guaranteed we will see all these messages only once, so we can
+    // do the forwarding here.
+    auto allMessages = std::span<fair::mq::MessagePtr>(messages, messages + nMessages);
+    if (onInsertion) {
+      onInsertion(services, allMessages);
+    }
     for (size_t mi = 0; mi < nMessages; ++mi) {
       assert(mi + nPayloads < nMessages);
       // We are in calibration mode and the data does not have the calibration bit set.
@@ -515,9 +521,6 @@ DataRelayer::RelayChoice
         continue;
       }
       auto span = std::span<fair::mq::MessagePtr>(messages + mi, messages + mi + nPayloads + 1);
-      if (onInsertion) {
-        onInsertion(services, span);
-      }
       target.add([&span](size_t i) -> fair::mq::MessagePtr& { return span[i]; }, nPayloads + 1);
       mi += nPayloads;
       saved += nPayloads;

From ed8276cbddc8b3928c59fd6ee2b68dd60bb6afe1 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 19 Jan 2026 13:59:07 +0100
Subject: [PATCH 1221/1764] DPL: earlier forwarding

This anticipates the forwarding to the earliest possible moment, i.e. when
we are about to insert the messages in a slot. This is the earliest moment
we can guarantee messages will be seen only once.
---
 .../include/Framework/DataProcessingContext.h |  8 ++-
 Framework/Core/src/DataProcessingDevice.cxx   | 53 ++++++++++++++-----
 Framework/Core/src/DataRelayer.cxx            |  2 +
 3 files changed, 49 insertions(+), 14 deletions(-)

diff --git a/Framework/Core/include/Framework/DataProcessingContext.h b/Framework/Core/include/Framework/DataProcessingContext.h
index 9b7cbc238c942..221f7b099dc07 100644
--- a/Framework/Core/include/Framework/DataProcessingContext.h
+++ b/Framework/Core/include/Framework/DataProcessingContext.h
@@ -23,6 +23,12 @@ struct ServiceRegistry;
 struct DataAllocator;
 struct DataProcessorSpec;
 
+enum struct ForwardPolicy {
+  AtInjection,
+  AtCompletionPolicySatisified,
+  AfterProcessing
+};
+
 struct DataProcessorContext {
   DataProcessorContext(DataProcessorContext const&) = delete;
   DataProcessorContext() = default;
@@ -122,7 +128,7 @@ struct DataProcessorContext {
   mutable std::vector<ServicePreLoopHandle> preLoopHandles;
 
   /// Wether or not the associated DataProcessor can forward things early
-  bool canForwardEarly = true;
+  ForwardPolicy forwardPolicy = ForwardPolicy::AtInjection;
   bool isSink = false;
   bool balancingInputs = true;
 
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 91f5fd0c2d547..f65477c573772 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1050,10 +1050,25 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
     };
   }
 
-  auto decideEarlyForward = [&context, &deviceContext, &spec, this]() -> bool {
+  auto decideEarlyForward = [&context, &deviceContext, &spec, this]() -> ForwardPolicy {
+    ForwardPolicy defaultEarlyForwardPolicy = getenv("DPL_OLD_EARLY_FORWARD") ? ForwardPolicy::AtCompletionPolicySatisified : ForwardPolicy::AtInjection;
+
     /// We must make sure there is no optional
     /// if we want to optimize the forwarding
-    bool canForwardEarly = (spec.forwards.empty() == false) && deviceContext.processingPolicies.earlyForward != EarlyForwardPolicy::NEVER;
+    ForwardPolicy forwardPolicy = defaultEarlyForwardPolicy;
+    if (spec.forwards.empty() == false) {
+      switch (deviceContext.processingPolicies.earlyForward) {
+        case o2::framework::EarlyForwardPolicy::NEVER:
+          forwardPolicy = ForwardPolicy::AfterProcessing;
+          break;
+        case o2::framework::EarlyForwardPolicy::ALWAYS:
+          forwardPolicy = defaultEarlyForwardPolicy;
+          break;
+        case o2::framework::EarlyForwardPolicy::NORAW:
+          forwardPolicy = defaultEarlyForwardPolicy;
+          break;
+      }
+    }
     bool onlyConditions = true;
     bool overriddenEarlyForward = false;
     for (auto& forwarded : spec.forwards) {
@@ -1061,25 +1076,25 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
         onlyConditions = false;
       }
       if (DataSpecUtils::partialMatch(forwarded.matcher, o2::header::DataDescription{"RAWDATA"}) && deviceContext.processingPolicies.earlyForward == EarlyForwardPolicy::NORAW) {
-        context.canForwardEarly = false;
+        forwardPolicy = ForwardPolicy::AfterProcessing;
         overriddenEarlyForward = true;
         LOG(detail) << "Cannot forward early because of RAWDATA input: " << DataSpecUtils::describe(forwarded.matcher);
         break;
       }
       if (forwarded.matcher.lifetime == Lifetime::Optional) {
-        context.canForwardEarly = false;
+        forwardPolicy = ForwardPolicy::AfterProcessing;
         overriddenEarlyForward = true;
         LOG(detail) << "Cannot forward early because of Optional input: " << DataSpecUtils::describe(forwarded.matcher);
         break;
       }
     }
     if (!overriddenEarlyForward && onlyConditions) {
-      context.canForwardEarly = true;
+      forwardPolicy = defaultEarlyForwardPolicy;
       LOG(detail) << "Enabling early forwarding because only conditions to be forwarded";
     }
-    return canForwardEarly;
+    return forwardPolicy;
   };
-  context.canForwardEarly = decideEarlyForward();
+  context.forwardPolicy = decideEarlyForward();
 }
 
 void DataProcessingDevice::PreRun()
@@ -1700,7 +1715,7 @@ auto forwardOnInsertion(ServiceRegistryRef& ref, std::span<fair::mq::MessagePtr>
 
   auto& spec = ref.get<DeviceSpec const>();
   auto& context = ref.get<DataProcessorContext>();
-  if (!context.canForwardEarly || spec.forwards.empty()) {
+  if (context.forwardPolicy == ForwardPolicy::AfterProcessing || spec.forwards.empty()) {
     O2_SIGNPOST_EVENT_EMIT(device, sid, "device", "Early forwardinding not enabled / needed.");
     return;
   }
@@ -1858,7 +1873,7 @@ void DataProcessingDevice::handleData(ServiceRegistryRef ref, InputChannelInfo&
     stats.updateStats({(int)ProcessingStatsId::ERROR_COUNT, DataProcessingStats::Op::Add, 1});
   };
 
-  auto handleValidMessages = [&info, ref, &reportError](std::vector<InputInfo> const& inputInfos) {
+  auto handleValidMessages = [&info, ref, &reportError, &context](std::vector<InputInfo> const& inputInfos) {
     auto& relayer = ref.get<DataRelayer>();
     auto& state = ref.get<DeviceState>();
     static WaitBackpressurePolicy policy;
@@ -1919,7 +1934,7 @@ void DataProcessingDevice::handleData(ServiceRegistryRef ref, InputChannelInfo&
                                        input,
                                        nMessages,
                                        nPayloadsPerHeader,
-                                       nullptr,
+                                       context.forwardPolicy == ForwardPolicy::AtInjection ? forwardOnInsertion : nullptr,
                                        onDrop);
           switch (relayed.type) {
             case DataRelayer::RelayChoice::Type::Backpressured:
@@ -2333,11 +2348,23 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     bool hasForwards = spec.forwards.empty() == false;
     bool consumeSomething = action.op == CompletionPolicy::CompletionOp::Consume || action.op == CompletionPolicy::CompletionOp::ConsumeExisting;
 
-    if (context.canForwardEarly && hasForwards && consumeSomething) {
-      O2_SIGNPOST_EVENT_EMIT(device, aid, "device", "Early forwainding: %{public}s.", fmt::format("{}", action.op).c_str());
+    if (context.forwardPolicy == ForwardPolicy::AtCompletionPolicySatisified && hasForwards && consumeSomething) {
+      O2_SIGNPOST_EVENT_EMIT(device, aid, "device", "Early forwarding: %{public}s.", fmt::format("{}", action.op).c_str());
       auto& timesliceIndex = ref.get<TimesliceIndex>();
       forwardInputs(ref, action.slot, currentSetOfInputs, timesliceIndex.getOldestPossibleOutput(), true, action.op == CompletionPolicy::CompletionOp::Consume);
+    } else if (context.forwardPolicy == ForwardPolicy::AtInjection && hasForwards && consumeSomething) {
+      // We used to do fowarding here, however we now do it much earlier.
+      // We still need to clean the inputs which were already consumed
+      // via ConsumeExisting and which still have an header to hold the slot.
+      // FIXME: do we? This should really happen when we do the forwarding on
+      // insertion, because otherwise we lose the relevant information on how to
+      // navigate the set of headers. We could actually rely on the messageset index,
+      // is that the right thing to do though?
+      O2_SIGNPOST_EVENT_EMIT(device, aid, "device", "cleaning early forwarding: %{public}s.", fmt::format("{}", action.op).c_str());
+      auto& timesliceIndex = ref.get<TimesliceIndex>();
+      cleanEarlyForward(ref, action.slot, currentSetOfInputs, timesliceIndex.getOldestPossibleOutput(), true, action.op == CompletionPolicy::CompletionOp::Consume);
     }
+
     markInputsAsDone(action.slot);
 
     uint64_t tStart = uv_hrtime();
@@ -2456,7 +2483,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
       context.postDispatchingCallbacks(processContext);
       ref.get<CallbackService>().call<CallbackService::Id::DataConsumed>(o2::framework::ServiceRegistryRef{ref});
     }
-    if ((context.canForwardEarly == false) && hasForwards && consumeSomething) {
+    if ((context.forwardPolicy == ForwardPolicy::AfterProcessing) && hasForwards && consumeSomething) {
       O2_SIGNPOST_EVENT_EMIT(device, aid, "device", "Late forwarding");
       auto& timesliceIndex = ref.get<TimesliceIndex>();
       forwardInputs(ref, action.slot, currentSetOfInputs, timesliceIndex.getOldestPossibleOutput(), false, action.op == CompletionPolicy::CompletionOp::Consume);
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index d9c340cd9c225..05b64b6ed1dad 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -521,6 +521,8 @@ DataRelayer::RelayChoice
         continue;
       }
       auto span = std::span<fair::mq::MessagePtr>(messages + mi, messages + mi + nPayloads + 1);
+      // Notice this will split [(header, payload), (header, payload)] multiparts
+      // in N different subParts for the message spec.
       target.add([&span](size_t i) -> fair::mq::MessagePtr& { return span[i]; }, nPayloads + 1);
       mi += nPayloads;
       saved += nPayloads;

From 9634a2ee3fd8481f9f222c27eee03d1c459a1b13 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Tue, 20 Jan 2026 15:05:24 +0100
Subject: [PATCH 1222/1764] GPU: Don't override --recoSteps flags in
 standalone.

---
 .../Standalone/Benchmark/standalone.cxx       | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 5fa9da23d7423..a2e74c45fcb86 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -413,6 +413,18 @@ int32_t SetupReconstruction()
     steps.steps.setBits(gpudatatypes::RecoStep::TPCClusterFinding, false);
   }
 
+  // Set settings for synchronous
+  GPUChainTracking::ApplySyncSettings(procSet, recSet, steps.steps, configStandalone.testSyncAsync || configStandalone.testSync, configStandalone.rundEdx);
+  int32_t runAsyncQA = procSet.runQA && !configStandalone.testSyncAsyncQcInSync ? procSet.runQA : 0;
+  if (configStandalone.testSyncAsync) {
+    procSet.eventDisplay = nullptr;
+    if (!configStandalone.testSyncAsyncQcInSync) {
+      procSet.runQA = false;
+    }
+  }
+
+  // Apply --recoSteps flag last so it takes precedence
+  // E.g. ApplySyncSettings might enable TPCdEdx, but might not be needed if only clusterizer was requested
   if (configStandalone.recoSteps >= 0) {
     steps.steps &= configStandalone.recoSteps;
   }
@@ -432,16 +444,6 @@ int32_t SetupReconstruction()
     }
   }
 
-  // Set settings for synchronous
-  GPUChainTracking::ApplySyncSettings(procSet, recSet, steps.steps, configStandalone.testSyncAsync || configStandalone.testSync, configStandalone.rundEdx);
-  int32_t runAsyncQA = procSet.runQA && !configStandalone.testSyncAsyncQcInSync ? procSet.runQA : 0;
-  if (configStandalone.testSyncAsync) {
-    procSet.eventDisplay = nullptr;
-    if (!configStandalone.testSyncAsyncQcInSync) {
-      procSet.runQA = false;
-    }
-  }
-
   rec->SetSettings(&grp, &recSet, &procSet, &steps);
   if (configStandalone.proc.doublePipeline) {
     recPipeline->SetSettings(&grp, &recSet, &procSet, &steps);

From 96a6a753d2e56ec9db66ad200d693589a188f30a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 21 Jan 2026 11:07:47 +0100
Subject: [PATCH 1223/1764] GPU QA: Improvements for some plots

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  5 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  | 62 ++++++++++---------
 GPU/GPUTracking/qa/GPUQA.h                    |  8 +--
 3 files changed, 39 insertions(+), 36 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index d70fac115eab7..9bfe6feb14d8d 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -527,9 +527,10 @@ AddOption(histMaxNClusters, uint32_t, 500000000, "", 0, "Maximum number of clust
 AddOption(minNClFindable, uint32_t, 70, "", 0, "Minimum number of (weighted) MC clusters for a track to count as findable")
 AddOption(minNClEff, uint32_t, 10, "", 0, "Minimum number of (weighted) MC clusters for a track to contribute to all-tracks efficiency histogramm")
 AddOption(minNClRes, uint32_t, 40, "", 0, "Minimum number of (weighted) MC clusters for a track to contribute to resolution histogram")
-AddOption(perfFigure, int32_t, 0, "", 0, "Show as performance figure, positive value for MC, negative value for data")
+AddOption(perfFigure, std::string, "", "", 0, "Show as performance figure, provide mc/MC or data as asgument, or a custom string", def("MC"))
 AddOption(plotsDir, std::string, "plots", "", 0, "Directory to write plots to")
-AddShortcut("compare", 0, "--QAinput", "Compare QA histograms", "--qa", "--QAinputHistogramsOnly")
+AddOption(plotsNoTitle, bool, false, "", 0, "Do not print titles on figures")
+AddShortcut("compare", 0, "--QAinput", "Compare QA histograms", "-c", "--qa", "--QAinputHistogramsOnly")
 AddHelp("help", 'h')
 EndConfig()
 
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 852ac5c1feefb..b58209efff744 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -413,20 +413,21 @@ void GPUQA::DrawHisto(TH1* histo, char* filename, char* options)
 
 void GPUQA::doPerfFigure(float x, float y, float size)
 {
-  const char* str_perf_figure_1 = "ALICE Performance";
-  const char* str_perf_figure_2_mc = "MC, Pb#minusPb, #sqrt{s_{NN}} = 5.36 TeV";
-  const char* str_perf_figure_2_data = "Pb#minusPb, #sqrt{s_{NN}} = 5.36 TeV";
-
-  if (mConfig.perfFigure == 0) {
+  if (mConfig.perfFigure == "") {
     return;
   }
+  static constexpr const char* str_perf_figure_1 = "ALICE Performance";
+  static constexpr const char* str_perf_figure_2_mc = "MC, Pb#minusPb, #sqrt{s_{NN}} = 5.36 TeV";
+  static constexpr const char* str_perf_figure_2_data = "Pb#minusPb, #sqrt{s_{NN}} = 5.36 TeV";
+  const char* str_perf_figure_2 = (mConfig.perfFigure == "mc" || mConfig.perfFigure == "MC") ? str_perf_figure_2_mc : (mConfig.perfFigure == "data" ? str_perf_figure_2_data : mConfig.perfFigure.c_str());
+
   TLatex* t = createGarbageCollected<TLatex>(); // TODO: We could perhaps put everything in a legend, to get a white background if there is a grid
   t->SetNDC(kTRUE);
   t->SetTextColor(1);
   t->SetTextSize(size);
   t->DrawLatex(x, y, str_perf_figure_1);
   t->SetTextSize(size * 0.8);
-  t->DrawLatex(x, y - 0.01 - size, mConfig.perfFigure > 0 ? str_perf_figure_2_mc : str_perf_figure_2_data);
+  t->DrawLatex(x, y - 0.01 - size, str_perf_figure_2);
 }
 
 void GPUQA::SetMCTrackRange(int32_t min, int32_t max)
@@ -539,7 +540,7 @@ int32_t GPUQA::InitQACreateHistograms()
       createHist(mNCl[i], name, name, 160, 0, 159);
     }
     std::unique_ptr<double[]> binsPt{CreateLogAxis(AXIS_BINS[4], PT_MIN_CLUST, PT_MAX)};
-    createHist(mTracks, "tracks_pt", "tracks_pt", AXIS_BINS[4], binsPt.get());
+    createHist(mTrackPt, "tracks_pt", "tracks_pt", AXIS_BINS[4], binsPt.get());
     const uint32_t maxTime = (mTracking && mTracking->GetParam().continuousMaxTimeBin > 0) ? mTracking->GetParam().continuousMaxTimeBin : TPC_MAX_TIME_BIN_TRIGGERED;
     createHist(mT0[0], "tracks_t0", "tracks_t0", (maxTime + 1) / 10, 0, maxTime);
     createHist(mT0[1], "tracks_t0_res", "tracks_t0_res", 1000, -100, 100);
@@ -1738,7 +1739,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       if (!track.OK()) {
         continue;
       }
-      mTracks->Fill(1.f / fabsf(track.GetParam().GetQPt()));
+      mTrackPt->Fill(1.f / fabsf(track.GetParam().GetQPt()));
       mNCl[0]->Fill(track.NClustersFitted());
       uint32_t nClCorrected = 0;
       const auto& trackClusters = mTracking->mIOPtrs.mergedTrackHits;
@@ -2247,12 +2248,12 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
 
     // Create Canvas for track statistic histos
     if (mQATasks & taskTrackStatistics) {
-      mCTracks = createGarbageCollected<TCanvas>("ctrackspt", "ctrackspt", 0, 0, 700, 700. * 2. / 3.);
-      mCTracks->cd();
-      mPTracks = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
-      mPTracks->Draw();
-      mLTracks = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.5, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
-      SetLegend(mLTracks, true);
+      mCTrackPt = createGarbageCollected<TCanvas>("ctrackspt", "ctrackspt", 0, 0, 700, 700. * 2. / 3.);
+      mCTrackPt->cd();
+      mPTrackPt = createGarbageCollected<TPad>("p0", "", 0.0, 0.0, 1.0, 1.0);
+      mPTrackPt->Draw();
+      mLTrackPt = createGarbageCollected<TLegend>(0.9 - legendSpacingString * 1.5, 0.93 - (0.93 - 0.86) / 2. * (float)ConfigNumInputs, 0.98, 0.949);
+      SetLegend(mLTrackPt, true);
 
       for (int32_t i = 0; i < 2; i++) {
         snprintf(name, 2048, "ctrackst0%d", i);
@@ -2800,7 +2801,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
             continue;
           }
 
-          e->SetTitle(CLUSTER_TITLES[i]);
+          e->SetTitle(mConfig.plotsNoTitle ? "" : CLUSTER_TITLES[i]);
           e->GetYaxis()->SetTitle(i == 0 ? "Number of TPC clusters" : i == 1 ? "Fraction of TPC clusters" : CLUST_HIST_INT_SUM ? "Total TPC clusters (integrated)" : "Fraction of TPC clusters (integrated)");
           e->GetXaxis()->SetTitle("#it{p}_{Tmc} (GeV/#it{c})");
           e->GetXaxis()->SetTitleOffset(1.1);
@@ -2878,7 +2879,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       }
       title += ")";
 
-      e->SetTitle(title.c_str());
+      e->SetTitle(mConfig.plotsNoTitle ? "" : title.c_str());
       e->GetXaxis()->SetTitle(i == 3 ? "Local Occupancy" : (i ? "#Phi_{Cl} (sector)" : "First MC Pad Row"));
       e->GetYaxis()->SetTitle("First Pad Row");
       e->Draw();
@@ -2910,7 +2911,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
     // Process track statistic histograms
     float tmpMax = 0.;
     for (int32_t k = 0; k < ConfigNumInputs; k++) { // TODO: Simplify this drawing, avoid copy&paste
-      TH1F* e = mTracks;
+      TH1F* e = mTrackPt;
       if (GetHist(e, tin, k, nNewInput) == nullptr) {
         continue;
       }
@@ -2919,10 +2920,10 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         tmpMax = e->GetMaximum();
       }
     }
-    mPTracks->cd();
-    mPTracks->SetLogx();
+    mPTrackPt->cd();
+    mPTrackPt->SetLogx();
     for (int32_t k = 0; k < ConfigNumInputs; k++) {
-      TH1F* e = mTracks;
+      TH1F* e = mTrackPt;
       if (GetHist(e, tin, k, nNewInput) == nullptr) {
         continue;
       }
@@ -2933,9 +2934,10 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       e->SetMinimum(tmpMax * -0.02);
       e->SetStats(kFALSE);
       e->SetLineWidth(1);
-      e->SetTitle("Number of Tracks vs #it{p}_{T}");
+      e->SetTitle(mConfig.plotsNoTitle ? "" : "Number of Tracks vs #it{p}_{T}");
       e->GetYaxis()->SetTitle("Number of Tracks");
       e->GetXaxis()->SetTitle("#it{p}_{T} (GeV/#it{c})");
+      e->GetXaxis()->SetTitleOffset(1.2);
       if (qcout) {
         qcout->Add(e);
       }
@@ -2943,14 +2945,14 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       e->SetLineColor(colorNums[k % COLORCOUNT]);
       e->Draw(k == 0 ? "" : "same");
       GetName(fname, k, mConfig.inputHistogramsOnly);
-      mLTracks->AddEntry(e, Form(mConfig.inputHistogramsOnly ? "%s" : "%sTrack #it{p}_{T}", fname), "l");
+      mLTrackPt->AddEntry(e, Form(mConfig.inputHistogramsOnly ? "%s" : "%sTrack #it{p}_{T}", fname), "l");
     }
-    mLTracks->Draw();
+    mLTrackPt->Draw();
     doPerfFigure(0.63, 0.7, 0.030);
-    mCTracks->cd();
-    mCTracks->Print(Form("%s/tracks.pdf", mConfig.plotsDir.c_str()));
+    mCTrackPt->cd();
+    mCTrackPt->Print(Form("%s/tracks.pdf", mConfig.plotsDir.c_str()));
     if (mConfig.writeFileExt != "") {
-      mCTracks->Print(Form("%s/tracks.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
+      mCTrackPt->Print(Form("%s/tracks.%s", mConfig.plotsDir.c_str(), mConfig.writeFileExt.c_str()));
     }
 
     for (int32_t i = 0; i < 2; i++) {
@@ -2978,7 +2980,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         e->SetMinimum(tmpMax * -0.02);
         e->SetStats(kFALSE);
         e->SetLineWidth(1);
-        e->SetTitle(i ? "Track t_{0} resolution" : "Track t_{0} distribution");
+        e->SetTitle(mConfig.plotsNoTitle ? "" : (i ? "Track t_{0} resolution" : "Track t_{0} distribution"));
         e->GetYaxis()->SetTitle("a.u.");
         e->GetXaxis()->SetTitle(i ? "t_{0} - t_{0, mc}" : "t_{0}");
         if (qcout) {
@@ -3022,7 +3024,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         e->SetMinimum(tmpMax * -0.02);
         e->SetStats(kFALSE);
         e->SetLineWidth(1);
-        e->SetTitle(i ? "Number of Rows with attached Cluster" : "Number of Clusters");
+        e->SetTitle(mConfig.plotsNoTitle ? "" : (i ? "Number of Rows with attached Cluster" : "Number of Clusters"));
         e->GetYaxis()->SetTitle("a.u.");
         e->GetXaxis()->SetTitle(i ? "N_{Rows with Clusters}" : "N_{Clusters}");
         if (qcout) {
@@ -3061,7 +3063,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
         mClRej[i]->Write();
       }
       mPClRej[i]->cd();
-      mClRej[i]->SetTitle(REJECTED_NAMES[i]);
+      mClRej[i]->SetTitle(mConfig.plotsNoTitle ? "" : REJECTED_NAMES[i]);
       mClRej[i]->SetOption("colz");
       mClRej[i]->Draw();
       mCClRej[i]->cd();
@@ -3098,7 +3100,7 @@ int32_t GPUQA::DrawQAHistograms(TObjArray* qcout)
       delete proj2;
       e->SetMinimum(-0.02);
       e->SetMaximum(0.22);
-      e->SetTitle("Rejected Clusters");
+      e->SetTitle(mConfig.plotsNoTitle ? "" : "Rejected Clusters");
       e->GetXaxis()->SetTitle("Pad Row");
       e->GetYaxis()->SetTitle("Rejected Clusters (fraction)");
       e->Draw(k == 0 ? "" : "same");
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 346c56a898806..bd3c9be3a9aa5 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -290,10 +290,10 @@ class GPUQA
     double nUnaccessible = 0;
   } mClusterCounts;
 
-  TH1F* mTracks;
-  TCanvas* mCTracks;
-  TPad* mPTracks;
-  TLegend* mLTracks;
+  TH1F* mTrackPt;
+  TCanvas* mCTrackPt;
+  TPad* mPTrackPt;
+  TLegend* mLTrackPt;
 
   TH1F* mNCl[2];
   TCanvas* mCNCl[2];

From a4989384162de86181f18515a2431fab19182ed8 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 20 Jan 2026 10:32:03 +0100
Subject: [PATCH 1224/1764] DPL: avoid needless copy of messages when cleaning
 up early forwarding

---
 .../include/Framework/DataProcessingHelpers.h |  2 +
 Framework/Core/src/DataProcessingDevice.cxx   |  7 ++-
 Framework/Core/src/DataProcessingHelpers.cxx  | 54 +++++++++++++++++++
 3 files changed, 61 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/DataProcessingHelpers.h b/Framework/Core/include/Framework/DataProcessingHelpers.h
index a9bd95b69f4c7..87aeeb8922da3 100644
--- a/Framework/Core/include/Framework/DataProcessingHelpers.h
+++ b/Framework/Core/include/Framework/DataProcessingHelpers.h
@@ -59,6 +59,8 @@ struct DataProcessingHelpers {
   /// Helper to route messages for forwarding
   static void routeForwardedMessages(FairMQDeviceProxy& proxy, std::span<fair::mq::MessagePtr>& currentSetOfInputs, std::vector<fair::mq::Parts>& forwardedParts,
                                      bool copy, bool consume);
+
+  static void cleanForwardedMessages(std::span<fair::mq::MessagePtr>& currentSetOfInputs, bool consume);
 };
 } // namespace o2::framework
 #endif // O2_FRAMEWORK_DATAPROCESSINGHELPERS_H_
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index f65477c573772..38c57c66c8a01 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -626,9 +626,12 @@ static auto cleanEarlyForward = [](ServiceRegistryRef registry, TimesliceSlot sl
                     slot.index, oldestTimeslice.timeslice.value, copy ? "with copy" : "", copy && consume ? " and " : "", consume ? "with consume" : "");
   // Always copy them, because we do not want to actually send them.
   // We merely need the side effect of the consume, if applicable.
-  auto forwardedParts = DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, true, consume);
+  for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
+    auto span = std::span<fair::mq::MessagePtr>(currentSetOfInputs[ii].messages);
+    DataProcessingHelpers::cleanForwardedMessages(span, consume);
+  }
 
-  O2_SIGNPOST_END(forwarding, sid, "forwardInputs", "Forwarding done");
+  O2_SIGNPOST_END(forwarding, sid, "forwardInputs", "Cleaning done");
 };
 
 extern volatile int region_read_global_dummy_variable;
diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index 87e7c9bf8962f..334a0fc6045f6 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -338,6 +338,60 @@ void DataProcessingHelpers::routeForwardedMessages(FairMQDeviceProxy& proxy, std
   }
 }
 
+void DataProcessingHelpers::cleanForwardedMessages(std::span<fair::mq::MessagePtr>& messages, bool consume)
+{
+  size_t pi = 0;
+  while (pi < messages.size()) {
+    auto& header = messages[pi];
+
+    // If is now possible that the record is not complete when
+    // we forward it, because of a custom completion policy.
+    // this means that we need to skip the empty entries in the
+    // record for being forwarded.
+    if (header->GetData() == nullptr ||
+        o2::header::get<DomainInfoHeader*>(header->GetData()) ||
+        o2::header::get<SourceInfoHeader*>(header->GetData())) {
+      pi += 2;
+      continue;
+    }
+
+    auto dph = o2::header::get<DataProcessingHeader*>(header->GetData());
+    auto dh = o2::header::get<o2::header::DataHeader*>(header->GetData());
+
+    if (dph == nullptr || dh == nullptr) {
+      // Complain only if this is not an out-of-band message
+      LOGP(error, "Data is missing {}{}{}",
+           dph ? "DataProcessingHeader" : "", dph || dh ? "and" : "", dh ? "DataHeader" : "");
+      pi += 2;
+      continue;
+    }
+
+    // At least one payload.
+    auto& payload = messages[pi + 1];
+    // Calculate the number of messages which should be handled together
+    // all in one go.
+    size_t numberOfMessages = 0;
+    if (dh->splitPayloadParts > 0 && dh->splitPayloadParts == dh->splitPayloadIndex) {
+      // Sequence of (header, payload[0], ... , payload[splitPayloadParts - 1]) pairs belonging together.
+      numberOfMessages = dh->splitPayloadParts + 1; // one is for the header
+    } else {
+      // Sequence of splitPayloadParts (header, payload) pairs belonging together.
+      // In case splitPayloadParts = 0, we consider this as a single message pair
+      numberOfMessages = (dh->splitPayloadParts > 0 ? dh->splitPayloadParts : 1) * 2;
+    }
+
+    if (payload.get() == nullptr && consume == true) {
+      // If the payload is not there, it means we already
+      // processed it with ConsumeExisiting. Therefore we
+      // need to do something only if this is the last consume.
+      header.reset(nullptr);
+    }
+
+    // Nothing to forward go to the next messageset
+    pi += numberOfMessages;
+  }
+}
+
 auto DataProcessingHelpers::routeForwardedMessageSet(FairMQDeviceProxy& proxy,
                                                      std::vector<MessageSet>& currentSetOfInputs,
                                                      const bool copyByDefault, bool consume) -> std::vector<fair::mq::Parts>

From 8562189e36996069bd0de7a79c57454ebb3fb8fe Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 21 Jan 2026 16:55:11 +0100
Subject: [PATCH 1225/1764] DPL: make new early forward optional

The new behavior breaks the TPC custom policy.
---
 Framework/Core/src/DataProcessingDevice.cxx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 38c57c66c8a01..fb54af9402079 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1054,7 +1054,11 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
   }
 
   auto decideEarlyForward = [&context, &deviceContext, &spec, this]() -> ForwardPolicy {
-    ForwardPolicy defaultEarlyForwardPolicy = getenv("DPL_OLD_EARLY_FORWARD") ? ForwardPolicy::AtCompletionPolicySatisified : ForwardPolicy::AtInjection;
+    //ForwardPolicy defaultEarlyForwardPolicy = getenv("DPL_OLD_EARLY_FORWARD") ? ForwardPolicy::AtCompletionPolicySatisified : ForwardPolicy::AtInjection;
+    // Make the new policy optional until we handle some of the corner cases
+    // with custom policies which expect the early forward to happen only when
+    // all the data is available, like in the TPC case.
+    ForwardPolicy defaultEarlyForwardPolicy = getenv("DPL_NEW_EARLY_FORWARD") ? ForwardPolicy::AtInjection : ForwardPolicy::AtCompletionPolicySatisified;
 
     /// We must make sure there is no optional
     /// if we want to optimize the forwarding

From be1d553177b4c8edc9ad47863369f5390f1fefaa Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 21 Jan 2026 18:06:42 +0100
Subject: [PATCH 1226/1764] Store missing GlobalTrackID in the CheckResid
 output

---
 Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
index 691d731503b88..d665af5747c60 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
@@ -252,6 +252,7 @@ void CheckResidSpec::process()
         auto& accum = slots[0];
 #endif
         auto& resTrack = accum.emplace_back();
+        resTrack.gid = vid;
         if (!processITSTrack(itsTrack, pve, resTrack)) {
           accum.pop_back();
           continue;

From 587eb9487ae816790b3c4f7fe7db3fd22e9a8d85 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 21 Jan 2026 09:48:37 +0100
Subject: [PATCH 1227/1764] TRD: add missing OutputSpec in trd-pulseheight
 device

---
 Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h
index 3cfbb16644e54..be00e478608ec 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDPulseHeightSpec.h
@@ -69,6 +69,7 @@ class PuseHeightDevice : public o2::framework::Task
     mPulseHeight->reset();
     mPulseHeight->process();
     pc.outputs().snapshot(Output{"TRD", "PULSEHEIGHT", 0}, mPulseHeight->getPHData());
+    pc.outputs().snapshot(Output{"TRD", "PULSEHEIGHTHD", 0}, mPulseHeight->getPHDataHD());
     if (pc.transitionState() == TransitionHandlingState::Requested) {
       LOG(info) << "Run stop requested, finalizing";
       mRunStopRequested = true;
@@ -103,6 +104,7 @@ DataProcessorSpec getTRDPulseHeightSpec(GID::mask_t src, bool digitsFromReader)
 
   std::vector<OutputSpec> outputs;
   outputs.emplace_back(o2::header::gDataOriginTRD, "PULSEHEIGHT", 0, Lifetime::Timeframe);
+  outputs.emplace_back(o2::header::gDataOriginTRD, "PULSEHEIGHTHD", 0, Lifetime::Timeframe);
 
   bool isTPCavailable = false;
   if (GID::includesSource(GID::Source::ITSTPC, src)) {

From 397e0194d0ab4d02f61c75ca40eb024703208478 Mon Sep 17 00:00:00 2001
From: Barthelemy <barthelemy.von.haller@cern.ch>
Date: Wed, 21 Jan 2026 16:55:50 +0100
Subject: [PATCH 1228/1764] [O2-6625] Fix the missing filename in the CCDb

---
 CCDB/src/CcdbApi.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index f083d97b533df..42bc13904bf61 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -416,7 +416,7 @@ int CcdbApi::storeAsBinaryFile(const char* buffer, size_t size, const std::strin
     auto mime = curl_mime_init(curl);
     auto field = curl_mime_addpart(mime);
     curl_mime_name(field, "send");
-    if (filename.empty()) {
+    if (!filename.empty()) {
       curl_mime_filedata(field, filename.c_str());
     }
     if (buffer != nullptr && size > 0) {

From 078eb5d8b2ed24527f7488e5b8fbae866820a46d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 22 Jan 2026 15:58:36 +0100
Subject: [PATCH 1229/1764] Revert "DPL Analysis: Use dangling edges context in
 more places (#14953)"

This reverts commit c990996954857d60b683fadc3bc037f055276c5d.
---
 .../AnalysisSupport/src/AODWriterHelpers.cxx  | 21 +++----
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   | 59 +++++++++----------
 .../CCDBSupport/src/AnalysisCCDBHelpers.h     |  2 +-
 .../Core/include/Framework/AnalysisTask.h     |  4 +-
 Framework/Core/src/AnalysisSupportHelpers.cxx |  4 +-
 5 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index b76ffca13977e..d868b7498fb76 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -62,13 +62,13 @@ const static std::unordered_map<OutputObjHandlingPolicy, std::string> ROOTfileNa
 
 AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
 {
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
   auto dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
   int compressionLevel = 505;
   if (ctx.options().hasOption("aod-writer-compression")) {
     compressionLevel = ctx.options().get<int>("aod-writer-compression");
   }
-  return AlgorithmSpec{[dod, compressionLevel](InitContext& ic) -> std::function<void(ProcessingContext&)> {
-    auto outputInputs = ic.services().get<DanglingEdgesContext>().outputsInputsAOD;
+  return AlgorithmSpec{[dod, outputInputs = ac.outputsInputsAOD, compressionLevel](InitContext& ic) -> std::function<void(ProcessingContext&)> {
     LOGP(debug, "======== getGlobalAODSink::Init ==========");
 
     // find out if any table needs to be saved
@@ -241,13 +241,14 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
   };
 }
 
-AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& /*ctx*/)
+AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 {
-  return AlgorithmSpec{[](InitContext& ic) -> std::function<void(ProcessingContext&)> {
-    using namespace monitoring;
-    auto& dec = ic.services().get<DanglingEdgesContext>();
-    auto tskmap = dec.outTskMap;
-    auto objmap = dec.outObjHistMap;
+  using namespace monitoring;
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
+  auto tskmap = ac.outTskMap;
+  auto objmap = ac.outObjHistMap;
+
+  return AlgorithmSpec{[objmap, tskmap](InitContext& ic) -> std::function<void(ProcessingContext&)> {
     auto& callbacks = ic.services().get<CallbackService>();
     auto inputObjects = std::make_shared<std::vector<std::pair<InputObjectRoute, InputObject>>>();
 
@@ -277,7 +278,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& /*ct
 
     callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
     return [inputObjects, objmap, tskmap](ProcessingContext& pc) mutable -> void {
-      auto mergePart = [&inputObjects, &objmap, &tskmap](DataRef const& ref) {
+      auto mergePart = [&inputObjects, &objmap, &tskmap, &pc](DataRef const& ref) {
         O2_SIGNPOST_ID_GENERATE(hid, histogram_registry);
         O2_SIGNPOST_START(histogram_registry, hid, "mergePart", "Merging histogram");
         if (!ref.header) {
@@ -473,7 +474,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& /*ct
       };
       O2_SIGNPOST_ID_GENERATE(rid, histogram_registry);
       O2_SIGNPOST_START(histogram_registry, rid, "processParts", "Start merging %zu parts received together.", pc.inputs().getNofParts(0));
-      for (auto pi = 0U; pi < pc.inputs().getNofParts(0); ++pi) {
+      for (int pi = 0; pi < pc.inputs().getNofParts(0); ++pi) {
         mergePart(pc.inputs().get("x", pi));
       }
       O2_SIGNPOST_END(histogram_registry, rid, "processParts", "Done histograms in multipart message.");
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index 413adfddecf04..9ec911518f754 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -67,39 +67,38 @@ void fillValidRoutes(CCDBFetcherHelper& helper, std::vector<o2::framework::Outpu
 }
 } // namespace
 
-AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
+AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
 {
-  return adaptStateful([](ConfigParamRegistry const& options, DeviceSpec const& spec, InitContext& ic) {
-    auto& dec = ic.services().get<DanglingEdgesContext>();
-    std::vector<std::shared_ptr<arrow::Schema>> schemas;
-    auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
+  auto& ac = ctx.services().get<DanglingEdgesContext>();
+  std::vector<std::shared_ptr<arrow::Schema>> schemas;
+  auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
 
-    for (auto& input : dec.analysisCCDBInputs) {
-      std::vector<std::shared_ptr<arrow::Field>> fields;
-      schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
-      schemaMetadata->Append("outputBinding", input.binding);
+  for (auto& input : ac.analysisCCDBInputs) {
+    std::vector<std::shared_ptr<arrow::Field>> fields;
+    schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
+    schemaMetadata->Append("outputBinding", input.binding);
 
-      for (auto& m : input.metadata) {
-        // Save the list of input tables
-        if (m.name.starts_with("input:")) {
-          auto name = m.name.substr(6);
-          schemaMetadata->Append("sourceTable", name);
-          schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
-          continue;
-        }
-        // Ignore the non ccdb: entries
-        if (!m.name.starts_with("ccdb:")) {
-          continue;
-        }
-        // Create the schema of the output
-        auto metadata = std::make_shared<arrow::KeyValueMetadata>();
-        metadata->Append("url", m.defaultValue.asString());
-        auto columnName = m.name.substr(strlen("ccdb:"));
-        fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
+    for (auto& m : input.metadata) {
+      // Save the list of input tables
+      if (m.name.starts_with("input:")) {
+        auto name = m.name.substr(6);
+        schemaMetadata->Append("sourceTable", name);
+        schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
+        continue;
+      }
+      // Ignore the non ccdb: entries
+      if (!m.name.starts_with("ccdb:")) {
+        continue;
       }
-      schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
+      // Create the schema of the output
+      auto metadata = std::make_shared<arrow::KeyValueMetadata>();
+      metadata->Append("url", m.defaultValue.asString());
+      auto columnName = m.name.substr(strlen("ccdb:"));
+      fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
     }
-
+    schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
+  }
+  return adaptStateful([schemas](CallbackService& callbacks, ConfigParamRegistry const& options, DeviceSpec const& spec) {
     std::shared_ptr<CCDBFetcherHelper> helper = std::make_shared<CCDBFetcherHelper>();
     CCDBFetcherHelper::initialiseHelper(*helper, options);
     std::unordered_map<std::string, int> bindings;
@@ -130,11 +129,11 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
         int outputRouteIndex = bindings.at(outRouteDesc);
         auto& spec = helper->routes[outputRouteIndex].matcher;
         std::vector<std::shared_ptr<arrow::BinaryViewBuilder>> builders;
-        for (auto const& _ : schema->fields()) {
+        for (auto& _ : schema->fields()) {
           builders.emplace_back(std::make_shared<arrow::BinaryViewBuilder>());
         }
 
-        for (auto ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
+        for (size_t ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
           std::shared_ptr<arrow::Array> chunk = timestampColumn->chunk(ci);
           auto const* timestamps = chunk->data()->GetValuesSafe<size_t>(1);
 
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
index 3be2138bd2b5c..f8175034da0ba 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
@@ -17,7 +17,7 @@ namespace o2::framework
 {
 
 struct AnalysisCCDBHelpers {
-  static AlgorithmSpec fetchFromCCDB(ConfigContext const&);
+  static AlgorithmSpec fetchFromCCDB(ConfigContext const& ctx);
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 4f8a9e719e4b9..c50b5358990de 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -521,7 +521,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<ExpressionInfo> expressionInfos;
 
   /// make sure options and configurables are set before expression infos are created
-  homogeneous_apply_refs([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
+  homogeneous_apply_refs([&options, &hash](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
   /// extract conditions and append them as inputs
   homogeneous_apply_refs([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
 
@@ -620,7 +620,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
       }
       // reset pre-slice for the next dataframe
       auto slices = pc.services().get<ArrowTableSlicingCache>();
-      homogeneous_apply_refs([&slices](auto& element) {
+      homogeneous_apply_refs([&pc, &slices](auto& element) {
         return analysis_task_parsers::updateSliceInfo(element, slices);
       },
                              *(task.get()));
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index 7edf9a2d8d27f..15b56f9afbff5 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -98,7 +98,7 @@ std::shared_ptr<DataOutputDirector> AnalysisSupportHelpers::getDataOutputDirecto
     if (!keepString.empty()) {
       dod->reset();
       std::string d("dangling");
-      if (d.starts_with(keepString) == 0) {
+      if (d.find(keepString) == 0) {
         // use the dangling outputs
         std::vector<InputSpec> danglingOutputs;
         for (auto ii = 0u; ii < OutputsInputs.size(); ii++) {
@@ -144,7 +144,7 @@ void AnalysisSupportHelpers::addMissingOutputsToSpawner(std::vector<OutputSpec>
     sinks::append_to{publisher.outputs}; // append them to the publisher outputs
 
   std::vector<InputSpec> additionalInputs;
-  for (auto const& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
+  for (auto& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
     input.metadata |
       views::filter_string_params_with("input:") |
       views::params_to_input_specs() |

From 538f355832f7b5e353704b09c123dd603521e7df Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 22 Jan 2026 10:09:02 +0100
Subject: [PATCH 1230/1764] DPL: do not do the new early forwarding for some of
 the data

---
 Framework/Core/src/DataProcessingDevice.cxx | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index fb54af9402079..3eaab36fb7908 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1054,11 +1054,22 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
   }
 
   auto decideEarlyForward = [&context, &deviceContext, &spec, this]() -> ForwardPolicy {
-    //ForwardPolicy defaultEarlyForwardPolicy = getenv("DPL_OLD_EARLY_FORWARD") ? ForwardPolicy::AtCompletionPolicySatisified : ForwardPolicy::AtInjection;
-    // Make the new policy optional until we handle some of the corner cases
-    // with custom policies which expect the early forward to happen only when
-    // all the data is available, like in the TPC case.
-    ForwardPolicy defaultEarlyForwardPolicy = getenv("DPL_NEW_EARLY_FORWARD") ? ForwardPolicy::AtInjection : ForwardPolicy::AtCompletionPolicySatisified;
+    ForwardPolicy defaultEarlyForwardPolicy = getenv("DPL_OLD_EARLY_FORWARD") ? ForwardPolicy::AtCompletionPolicySatisified : ForwardPolicy::AtInjection;
+    //  FIXME: try again with the new policy by default.
+    //
+    //  Make the new policy optional until we handle some of the corner cases
+    //  with custom policies which expect the early forward to happen only when
+    //  all the data is available, like in the TPC case.
+    //  ForwardPolicy defaultEarlyForwardPolicy = getenv("DPL_NEW_EARLY_FORWARD") ? ForwardPolicy::AtInjection : ForwardPolicy::AtCompletionPolicySatisified;
+    for (auto& forward : spec.forwards) {
+      if (DataSpecUtils::match(forward.matcher, ConcreteDataTypeMatcher{"TPC", "DIGITSMCTR"}) ||
+          DataSpecUtils::match(forward.matcher, ConcreteDataTypeMatcher{"TPC", "CLNATIVEMCLBL"}) ||
+          DataSpecUtils::match(forward.matcher, ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, "DIGITS"}) ||
+          DataSpecUtils::match(forward.matcher, ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, "CLUSTERNATIVE"})) {
+        defaultEarlyForwardPolicy = ForwardPolicy::AtCompletionPolicySatisified;
+        break;
+      }
+    }
 
     /// We must make sure there is no optional
     /// if we want to optimize the forwarding

From 5376bb861a3a935a2a8211917d6d2e52e51c535e Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 23 Jan 2026 17:01:44 +0100
Subject: [PATCH 1231/1764] PVertexer::refitVertexFull for refitting with
 different geom.

In in case the residuals monitoring is running with geometry different from the one used for initial reconstruction
pass a --configKeyValues option for the vertex refit as:
;pvertexer.useMeanVertexConstraint=false;pvertexer.iniScale2=100;pvertexer.acceptableScale2=10.;

It will be used by the PVertexer::refitVertexFull.
---
 .../GlobalTrackingStudy/CheckResidConfig.h    |  5 ++-
 .../study/src/CheckResid.cxx                  | 40 ++++++++++++-------
 .../include/DetectorsVertexing/PVertexer.h    |  4 +-
 Detectors/Vertexing/src/PVertexer.cxx         | 31 ++++++++++++++
 4 files changed, 62 insertions(+), 18 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
index 53dffeed7ad69..2a07eaf87930f 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
@@ -26,11 +26,14 @@ struct CheckResidConfig : o2::conf::ConfigurableParamHelper<CheckResidConfig> {
 
   bool pvcontribOnly = true;
   bool addPVAsCluster = true;
-  bool refitPV = true;
   bool useStableRef = true;
   bool doIBOB = true;
   bool doResid = true;
 
+  bool refitPV = true;
+  float refitPVMV = false;
+  float refitPVIniScale = 100.f;
+
   O2ParamDef(CheckResidConfig, "checkresid");
 };
 } // namespace o2::checkresid
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
index d665af5747c60..e6584a7055446 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
@@ -38,14 +38,17 @@
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "ReconstructionDataFormats/VtxTrackRef.h"
 #include "DetectorsVertexing/PVertexer.h"
-
 #ifdef WITH_OPENMP
 #include <omp.h>
 #endif
 
+// Attention: in case the residuals are checked with geometry different from the one used for initial reconstruction,
+// pass a --configKeyValues option for vertex refit as:
+// ;pvertexer.useMeanVertexConstraint=false;pvertexer.iniScale2=100;pvertexer.acceptableScale2=10.;
+// In any case, it is better to pass ;pvertexer.useMeanVertexConstraint=false;
+
 namespace o2::checkresid
 {
-
 using namespace o2::framework;
 using DetID = o2::detectors::DetID;
 using DataRequest = o2::globaltracking::DataRequest;
@@ -83,6 +86,7 @@ class CheckResidSpec : public Task
 
   o2::globaltracking::RecoContainer* mRecoData = nullptr;
   int mNThreads = 1;
+  bool mMeanVertexUpdated = false;
   float mITSROFrameLengthMUS = 0.f;
   o2::dataformats::MeanVertexObject mMeanVtx{};
   std::vector<o2::BaseCluster<float>> mITSClustersArray;    ///< ITS clusters created in run() method from compact clusters
@@ -131,6 +135,7 @@ void CheckResidSpec::updateTimeDependentParams(ProcessingContext& pc)
   // mTPCCorrMapsLoader.extractCCDBInputs(pc);
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
+    const auto& params = o2::checkresid::CheckResidConfig::Instance();
     initOnceDone = true;
     // Note: reading of the ITS AlpideParam needed for ITS timing is done by the RecoContainer
     auto grp = o2::base::GRPGeomHelper::instance().getGRPECS();
@@ -142,9 +147,13 @@ void CheckResidSpec::updateTimeDependentParams(ProcessingContext& pc)
     }
     auto geom = o2::its::GeometryTGeo::Instance();
     geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2G));
-    o2::conf::ConfigurableParam::updateFromString("pvertexer.useMeanVertexConstraint=false");
+    o2::conf::ConfigurableParam::updateFromString("pvertexer.useTimeInChi2=false;");
     mVertexer.init();
   }
+  if (mMeanVertexUpdated) {
+    mMeanVertexUpdated = false;
+    mVertexer.initMeanVertexConstraint();
+  }
   bool updateMaps = false;
   /*
   if (mTPCCorrMapsLoader.isUpdated()) {
@@ -200,6 +209,7 @@ void CheckResidSpec::process()
     }
     nvGood++;
     if (params.refitPV) {
+      LOGP(debug, "Refitting PV#{} of {} tracks", iv, pve.getNContributors());
       auto tStartPVF = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
       bool res = refitPV(pve, iv);
       pvFitDuration += std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count() - tStartPVF;
@@ -315,6 +325,7 @@ bool CheckResidSpec::processITSTrack(const o2::its::TrackITS& iTrack, const o2::
 
   resTrack.points.clear();
   if (!prop->propagateToDCA(pv, trFitOut, bz)) {
+    LOGP(debug, "Failed to propagateToDCA, {}", trFitOut.asString());
     return false;
   }
   float cosAlp, sinAlp;
@@ -418,7 +429,7 @@ bool CheckResidSpec::refitPV(o2::dataformats::PrimaryVertex& pv, int vid)
   std::vector<o2::track::TrackParCov> tracks;
   std::vector<bool> useTrack;
   std::vector<GTrackID> gidsITS;
-  int ntr = pv.getNContributors();
+  int ntr = pv.getNContributors(), ntrIni = ntr;
   tracks.reserve(ntr);
   useTrack.reserve(ntr);
   gidsITS.reserve(ntr);
@@ -447,20 +458,18 @@ bool CheckResidSpec::refitPV(o2::dataformats::PrimaryVertex& pv, int vid)
     ntr++;
   }
   if (ntr < params.minPVContributors || !mVertexer.prepareVertexRefit(tracks, pv)) {
+    LOGP(warn, "Abandon vertex refit: NcontribNew = {} vs NcontribOld = {}", ntr, ntrIni);
     return false;
   }
-  // readjust vertexZ
-  const auto& pool = mVertexer.getTracksPool();
-  float zUpd = 0;
-  for (const auto& t : pool) {
-    zUpd += t.z;
-  }
-  if (pool.size()) {
-    pv.setZ(zUpd / pool.size());
-    mVertexer.prepareVertexRefit(tracks, pv);
+  LOGP(debug, "Original vtx: Nc:{} {}, chi2={}", pv.getNContributors(), pv.asString(), pv.getChi2());
+  auto pvSave = pv;
+  pv = mVertexer.refitVertexFull(useTrack, pv);
+  LOGP(debug, "Refitted vtx: Nc:{} {}, chi2={}", ntr, pv.asString(), pv.getChi2());
+  if (pv.getChi2() < 0.f) {
+    LOGP(warn, "Failed to refit PV {}", pvSave.asString());
+    return false;
   }
-  pv = mVertexer.refitVertex(useTrack, pv);
-  return pv.getChi2() > 0.f;
+  return true;
 }
 
 bool CheckResidSpec::refitITStrack(o2::track::TrackParCov& track, GTrackID gid)
@@ -515,6 +524,7 @@ void CheckResidSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
     LOG(info) << "Imposing new MeanVertex: " << ((const o2::dataformats::MeanVertexObject*)obj)->asString();
     mMeanVtx = *(const o2::dataformats::MeanVertexObject*)obj;
+    mMeanVertexUpdated = true;
     return;
   }
   if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
diff --git a/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h b/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
index 9967cbfcd5642..c06c2119b0cd1 100644
--- a/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
+++ b/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
@@ -113,7 +113,7 @@ class PVertexer
   bool prepareVertexRefit(const TR& tracks, const o2d::VertexBase& vtxSeed);
 
   PVertex refitVertex(const std::vector<bool> useTrack, const o2d::VertexBase& vtxSeed);
-
+  PVertex refitVertexFull(const std::vector<bool> useTrack, const o2d::VertexBase& vtxSeed);
   auto getNTZClusters() const { return mNTZClustersIni; }
   auto getTotTrials() const { return mTotTrials; }
   auto getMaxTrialsPerCluster() const { return mMaxTrialPerCluster; }
@@ -135,6 +135,7 @@ class PVertexer
   void setPoolDumpDirectory(const std::string& d) { mPoolDumpDirectory = d; }
 
   void printInpuTracksStatus(const VertexingInput& input) const;
+  void initMeanVertexConstraint();
 
  private:
   static constexpr int DBS_UNDEF = -2, DBS_NOISE = -1, DBS_INCHECK = -10;
@@ -152,7 +153,6 @@ class PVertexer
   FitStatus evalIterations(VertexSeed& vtxSeed, PVertex& vtx) const;
   TimeEst timeEstimate(const VertexingInput& input) const;
   float findZSeedHistoPeak() const;
-  void initMeanVertexConstraint();
   void applyConstraint(VertexSeed& vtxSeed) const;
   bool upscaleSigma(VertexSeed& vtxSeed) const;
   bool relateTrackToMeanVertex(o2::track::TrackParCov& trc, float vtxErr2);
diff --git a/Detectors/Vertexing/src/PVertexer.cxx b/Detectors/Vertexing/src/PVertexer.cxx
index 5fea1943ac762..10e504bba0772 100644
--- a/Detectors/Vertexing/src/PVertexer.cxx
+++ b/Detectors/Vertexing/src/PVertexer.cxx
@@ -1333,6 +1333,37 @@ PVertex PVertexer::refitVertex(const std::vector<bool> useTrack, const o2d::Vert
   return vtxRes;
 }
 
+//______________________________________________
+PVertex PVertexer::refitVertexFull(const std::vector<bool> useTrack, const o2d::VertexBase& vtxSeed)
+{
+  // Use this method if because of e.g. different alingnment the new vertex is supposed to be shifted from the original one.
+  // Refit the tracks prepared by the successful prepareVertexRefit, possible skipping those tracks wich have useTrack value false
+  // (useTrack is ignored if empty).
+  // The vtxSeed is the originally found vertex, assumed to be the same original PV used for the prepareVertexRefit.
+  // Refitted PrimaryVertex is returned, negative chi2 means failure of the refit.
+  // ATTENTION: only the position is refitted, the vertex time and IRMin/IRMax info is dummy.
+
+  if (vtxSeed != mVtxRefitOrig) {
+    throw std::runtime_error("refitVertex must be preceded by successful prepareVertexRefit");
+  }
+  VertexingInput inp;
+  inp.scaleSigma2 = mPVParams->iniScale2;
+  inp.idRange = gsl::span<int>(mRefitTrackIDs);
+  if (useTrack.size()) {
+    for (uint32_t i = 0; i < mTracksPool.size(); i++) {
+      mTracksPool[i].vtxID = useTrack[mTracksPool[i].entry] ? TrackVF::kNoVtx : TrackVF::kDiscarded;
+    }
+  }
+  PVertex vtxRes{};
+  vtxRes.VertexBase::operator=(vtxSeed);
+  if (findVertex(inp, vtxRes)) {
+    vtxRes.setTimeStamp({0.f, -1.}); // time is not refitter
+  } else {
+    vtxRes.setChi2(-1.);
+  }
+  return vtxRes;
+}
+
 //______________________________________________
 void PVertexer::printInpuTracksStatus(const VertexingInput& input) const
 {

From 5b572ed12a5b3ca085a18d9ece546a84a98c3c30 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 11 Jul 2025 14:01:38 +0200
Subject: [PATCH 1232/1764] ITSMFT: staggered digitization

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../Detectors/ITSMFT/common/src/ROFRecord.cxx |  14 +-
 .../ITS/base/include/ITSBase/GeometryTGeo.h   |   8 +-
 .../MFT/base/include/MFTBase/GeometryTGeo.h   |   6 +-
 .../base/include/ITSMFTBase/DPLAlpideParam.h  |  41 +-
 .../base/include/ITSMFTBase/GeometryTGeo.h    |   5 +-
 .../include/ITSMFTSimulation/DigiParams.h     |  45 +-
 .../include/ITSMFTSimulation/Digitizer.h      |  24 +-
 .../common/simulation/src/DigiParams.cxx      |  44 +-
 .../common/simulation/src/Digitizer.cxx       |  98 ++---
 .../include/ITSMFTWorkflow/DigitReaderSpec.h  |  54 +--
 .../common/workflow/src/DigitReaderSpec.cxx   | 223 +++++-----
 .../common/workflow/src/DigitWriterSpec.cxx   |  84 +++-
 .../src/ITSMFTDigitizerSpec.cxx               | 413 ++++++++++--------
 13 files changed, 614 insertions(+), 445 deletions(-)

diff --git a/DataFormats/Detectors/ITSMFT/common/src/ROFRecord.cxx b/DataFormats/Detectors/ITSMFT/common/src/ROFRecord.cxx
index 83b46f8798fc9..8dbde0d580efc 100644
--- a/DataFormats/Detectors/ITSMFT/common/src/ROFRecord.cxx
+++ b/DataFormats/Detectors/ITSMFT/common/src/ROFRecord.cxx
@@ -9,20 +9,22 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "DataFormatsITSMFT/ROFRecord.h"
 #include <iostream>
-#include "fmt/format.h"
+#include <format>
+
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "Framework/Logger.h"
 
 using namespace o2::itsmft;
 
 std::string ROFRecord::asString() const
 {
-  return fmt::format("ROF: {} | {} entries starting from {}", mROFrame, getNEntries(), getFirstEntry());
+  return std::format("ROF: {} | {} entries starting from {} | IR: {}", mROFrame, getNEntries(), getFirstEntry(), mBCData.asString());
 }
 
 void ROFRecord::print() const
 {
-  std::cout << this << "\n\t" << mBCData << std::endl;
+  LOG(info) << asString();
 }
 
 std::ostream& operator<<(std::ostream& stream, ROFRecord const& rec)
@@ -33,12 +35,12 @@ std::ostream& operator<<(std::ostream& stream, ROFRecord const& rec)
 
 std::string MC2ROFRecord::asString() const
 {
-  return fmt::format("MCEventID: {} ROFs: {}-{} Entry in ROFRecords: {}", eventRecordID, minROF, maxROF, rofRecordID);
+  return std::format("MCEventID: {} ROFs: {}-{} Entry in ROFRecords: {}", eventRecordID, minROF, maxROF, rofRecordID);
 }
 
 void MC2ROFRecord::print() const
 {
-  std::cout << this << std::endl;
+  LOG(info) << asString();
 }
 
 std::ostream& operator<<(std::ostream& stream, MC2ROFRecord const& rec)
diff --git a/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h b/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
index 934c927ac3059..e236c898851f5 100644
--- a/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
+++ b/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
@@ -176,7 +176,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   bool getChipId(int index, int& lay, int& hba, int& sta, int& ssta, int& mod, int& chip) const;
 
   /// Get chip layer, from 0
-  int getLayer(int index) const;
+  int getLayer(int index) const final;
 
   /// Get chip half barrel, from 0
   int getHalfBarrel(int index) const;
@@ -216,7 +216,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
     return getSymbolicName(getChipIndex(lay, hba, sta, det));
   }
 
-  /// Get the transformation matrix for a given chip (NOT A SENSOR!!!) 'index' by quering the TGeoManager
+  /// Get the transformation matrix for a given chip (NOT A SENSOR!!!) 'index' by querying the TGeoManager
   TGeoHMatrix* getMatrix(int index) const { return o2::base::GeometryManager::getMatrix(getDetID(), index); }
   TGeoHMatrix* getMatrix(int lay, int hba, int sta, int sens) const { return getMatrix(getChipIndex(lay, hba, sta, sens)); }
   bool getOriginalMatrix(int index, TGeoHMatrix& m) const
@@ -336,7 +336,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   TString getMatrixPath(int index) const;
 
   /// Get the transformation matrix of the SENSOR (not necessary the same as the chip)
-  /// for a given chip 'index' by quering the TGeoManager
+  /// for a given chip 'index' by querying the TGeoManager
   TGeoHMatrix* extractMatrixSensor(int index) const;
 
   // create matrix for transformation from sensor local frame to global one
@@ -407,7 +407,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   std::vector<int> mNumberOfChipsPerStave;      ///< number of chips per stave
   std::vector<int> mNumberOfChipsPerHalfBarrel; ///< number of chips per halfbarrel
   std::vector<int> mNumberOfChipsPerLayer;      ///< number of chips per stave
-  std::vector<int> mLastChipIndex;              ///< max ID of the detctor in the layer
+  std::vector<int> mLastChipIndex;              ///< max ID of the detector in the layer
   std::array<bool, MAXLAYERS> mIsLayerITS3;     ///< flag with the information of the ITS version (ITS2 or ITS3)
   std::array<char, MAXLAYERS> mLayerToWrapper;  ///< Layer to wrapper correspondence
 
diff --git a/Detectors/ITSMFT/MFT/base/include/MFTBase/GeometryTGeo.h b/Detectors/ITSMFT/MFT/base/include/MFTBase/GeometryTGeo.h
index 503e8332c4cf5..20b5407d614c5 100644
--- a/Detectors/ITSMFT/MFT/base/include/MFTBase/GeometryTGeo.h
+++ b/Detectors/ITSMFT/MFT/base/include/MFTBase/GeometryTGeo.h
@@ -95,7 +95,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   Int_t getSensorIndex(Int_t half, Int_t disk, Int_t ladder, Int_t sensor) const;
 
   /// get layer index (0:9) from the chip index
-  Int_t getLayer(Int_t index) const;
+  Int_t getLayer(Int_t index) const final;
 
   /// This routine computes the half, disk, ladder and sensor number
   /// given the sensor index number
@@ -122,7 +122,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   {
     return extractNumberOfDisks(half);
   }
-  /// Returns the number of halfs MFT
+  /// Returns the number of halves MFT
   Int_t getNumberOfHalfs()
   {
     return extractNumberOfHalves();
@@ -181,7 +181,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   Int_t extractVolumeCopy(const Char_t* name, const Char_t* prefix) const;
 
   /// Get the transformation matrix of the sensor [...]
-  /// for a given sensor 'index' by quering the TGeoManager
+  /// for a given sensor 'index' by querying the TGeoManager
   TGeoHMatrix* extractMatrixSensor(Int_t index) const;
 
   // Create matrix for transformation from sensor local frame to global one
diff --git a/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h b/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h
index bc3b3dbde53b0..de39bed299634 100644
--- a/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h
+++ b/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h
@@ -26,17 +26,44 @@ constexpr float DEFStrobeDelay = o2::constants::lhc::LHCBunchSpacingNS * 4; // ~
 
 template <int N>
 struct DPLAlpideParam : public o2::conf::ConfigurableParamHelper<DPLAlpideParam<N>> {
+  static constexpr int getNLayers()
+  {
+    return N == o2::detectors::DetID::ITS ? 7 : 10;
+  }
 
   static constexpr std::string_view getParamName()
   {
     return N == o2::detectors::DetID::ITS ? ParamName[0] : ParamName[1];
   }
-  int roFrameLengthInBC = DEFROFLengthBC();           ///< ROF length in BC for continuos mode
-  float roFrameLengthTrig = DEFROFLengthTrig();       ///< length of RO frame in ns for triggered mode
-  float strobeDelay = DEFStrobeDelay;                 ///< strobe start (in ns) wrt ROF start
-  float strobeLengthCont = -1.;                       ///< if < 0, full ROF length - delay
-  float strobeLengthTrig = 100.;                      ///< length of the strobe in ns (sig. over threshold checked in this window only)
-  int roFrameBiasInBC = DEFROFBiasInBC();             ///< bias of the start of ROF wrt orbit start: t_irof = (irof*roFrameLengthInBC + roFrameBiasInBC)*BClengthMUS
+
+  int roFrameLengthInBC = DEFROFLengthBC();      ///< ROF length in BC for continuous mode
+  float roFrameLengthTrig = DEFROFLengthTrig();  ///< length of RO frame in ns for triggered mode
+  float strobeDelay = DEFStrobeDelay;            ///< strobe start (in ns) wrt ROF start
+  float strobeLengthCont = -1.;                  ///< if < 0, full ROF length - delay
+  float strobeLengthTrig = 100.;                 ///< length of the strobe in ns (sig. over threshold checked in this window only)
+  int roFrameBiasInBC = DEFROFBiasInBC();        ///< bias of the start of ROF wrt orbit start: t_irof = (irof*roFrameLengthInBC + roFrameBiasInBC)*BClengthMUS
+  int roFrameLayerLengthInBC[getNLayers()] = {}; ///< staggering ROF length in BC for continuous mode per layer
+  int roFrameLayerBiasInBC[getNLayers()] = {};   ///< staggering ROF bias in BC for continuous mode per layer
+  int roFrameLayerDelayInBC[getNLayers()] = {};  ///< staggering ROF delay in BC for continuous mode per layer
+
+  static constexpr bool supportsStaggering() noexcept { return (N == o2::detectors::DetID::ITS) ? false : false; }
+  // test if staggering is on
+  bool withStaggering() const noexcept
+  {
+    if constexpr (!supportsStaggering()) {
+      return false;
+    }
+    for (int i{0}; i < getNLayers(); ++i) {
+      if (roFrameLayerLengthInBC[i] != 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // get ROF length for any layer
+  int getROFLengthInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerLengthInBC[layer] : roFrameLengthInBC; }
+  int getROFBiasInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerBiasInBC[layer] : roFrameBiasInBC; }
+  int getROFDelayInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerDelayInBC[layer] : 0; }
 
   // boilerplate stuff + make principal key
   O2ParamDef(DPLAlpideParam, getParamName().data());
@@ -46,7 +73,7 @@ struct DPLAlpideParam : public o2::conf::ConfigurableParamHelper<DPLAlpideParam<
 
   static constexpr int DEFROFLengthBC()
   {
-    // default ROF length in BC for continuos mode
+    // default ROF length in BC for continuous mode
     // allowed values: 1,2,3,4,6,9,11,12,18,22,27,33,36
     return N == o2::detectors::DetID::ITS ? o2::constants::lhc::LHCMaxBunches / 4 : o2::constants::lhc::LHCMaxBunches / 18;
   }
diff --git a/Detectors/ITSMFT/common/base/include/ITSMFTBase/GeometryTGeo.h b/Detectors/ITSMFT/common/base/include/ITSMFTBase/GeometryTGeo.h
index fda38b21812ee..3051176fb23c6 100644
--- a/Detectors/ITSMFT/common/base/include/ITSMFTBase/GeometryTGeo.h
+++ b/Detectors/ITSMFT/common/base/include/ITSMFTBase/GeometryTGeo.h
@@ -11,7 +11,7 @@
 
 /// \file GeometryTGeo.h
 /// \brief Definition of the GeometryTGeo class : common part for ITS and MFT
-/// \brief collects ITS and MFT common methods to acces matrices
+/// \brief collects ITS and MFT common methods to access matrices
 
 /// \author ruben.shahoyan@cern.ch
 #ifndef ALICEO2_ITSMFT_GEOMETRYTGEO_H_
@@ -37,7 +37,8 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   ~GeometryTGeo() override = default;
 
   Int_t getNumberOfChips() const { return mSize; }
-  /// build detector layout data, must be overriden by detector
+  virtual Int_t getLayer(Int_t index) const { return -1; };
+  /// build detector layout data, must be overridden by detector
   virtual void Build(int loadTrans) = 0;
 
   bool isOwner() const { return mOwner; }
diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
index b27739c26bc4d..fa75a65728675 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
@@ -15,8 +15,10 @@
 #ifndef ALICEO2_ITSMFT_DIGIPARAMS_H
 #define ALICEO2_ITSMFT_DIGIPARAMS_H
 
+#include <vector>
+#include <algorithm>
 #include <Rtypes.h>
-#include <ITSMFTSimulation/AlpideSignalTrapezoid.h>
+#include "ITSMFTSimulation/AlpideSignalTrapezoid.h"
 #include "ITSMFTBase/DPLAlpideParam.h"
 
 ////////////////////////////////////////////////////////////
@@ -51,24 +53,24 @@ class DigiParams
   void setContinuous(bool v) { mIsContinuous = v; }
   bool isContinuous() const { return mIsContinuous; }
 
-  int getROFrameLengthInBC() const { return mROFrameLengthInBC; }
-  void setROFrameLengthInBC(int n) { mROFrameLengthInBC = n; }
+  int getROFrameLengthInBC(int layer = -1) const { return layer < 0 ? mROFrameLengthInBC : mROFrameLayerLengthInBC[layer]; }
+  void setROFrameLengthInBC(int n, int layer = -1) { layer < 0 ? mROFrameLengthInBC = n : mROFrameLayerLengthInBC[layer] = n; }
 
-  void setROFrameLength(float ns);
-  float getROFrameLength() const { return mROFrameLength; }
-  float getROFrameLengthInv() const { return mROFrameLengthInv; }
+  void setROFrameLength(float ns, int layer = -1);
+  float getROFrameLength(int layer = -1) const { return layer < 0 ? mROFrameLength : mROFrameLayerLength[layer]; }
+  float getROFrameLengthInv(int layer = -1) const { return layer < 0 ? mROFrameLengthInv : mROFrameLayerLengthInv[layer]; }
 
   void setStrobeDelay(float ns) { mStrobeDelay = ns; }
-  float getStrobeDelay() const { return mStrobeDelay; }
+  float getStrobeDelay(int layer = -1) const { return layer < 0 ? mStrobeDelay : mStrobeLayerDelay[layer]; }
 
   void setStrobeLength(float ns) { mStrobeLength = ns; }
-  float getStrobeLength() const { return mStrobeLength; }
+  float getStrobeLength(int layer = -1) const { return layer < 0 ? mStrobeLength : mStrobeLayerLength[layer]; }
 
   void setTimeOffset(double sec) { mTimeOffset = sec; }
   double getTimeOffset() const { return mTimeOffset; }
 
-  void setROFrameBiasInBC(int n) { mROFrameBiasInBC = n; }
-  int getROFrameBiasInBC() const { return mROFrameBiasInBC; }
+  void setROFrameBiasInBC(int n, int layer = -1) { layer < 0 ? mROFrameBiasInBC = n : mROFrameLayerBiasInBC[layer] = n; }
+  int getROFrameBiasInBC(int layer = -1) const { return layer < 0 ? mROFrameBiasInBC : mROFrameLayerBiasInBC[layer]; }
 
   void setChargeThreshold(int v, float frac2Account = 0.1);
   void setNSimSteps(int v);
@@ -96,13 +98,19 @@ class DigiParams
   const SignalShape& getSignalShape() const { return mSignalShape; }
   SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
 
+  bool withStaggering() const noexcept { return !mROFrameLayerLength.empty(); }
+  void addROFrameLayerLengthInBC(int len) { mROFrameLayerLengthInBC.push_back(len); }
+  void addROFrameLayerBiasInBC(int len) { mROFrameLayerBiasInBC.push_back(len); }
+  void addStrobeLength(float ns) { mStrobeLayerLength.push_back(ns); }
+  void addStrobeDelay(float ns) { mStrobeLayerDelay.push_back(ns); }
+
   virtual void print() const;
 
  private:
   static constexpr double infTime = 1e99;
   bool mIsContinuous = false;              ///< flag for continuous simulation
   float mNoisePerPixel = 1.e-8;            ///< ALPIDE Noise per chip
-  int mROFrameLengthInBC = 0;              ///< ROF length in BC for continuos mode
+  int mROFrameLengthInBC = 0;              ///< ROF length in BC for continuous mode
   float mROFrameLength = 0;                ///< length of RO frame in ns
   float mStrobeDelay = 0.;                 ///< strobe start (in ns) wrt ROF start
   float mStrobeLength = 0;                 ///< length of the strobe in ns (sig. over threshold checked in this window only)
@@ -115,17 +123,24 @@ class DigiParams
 
   float mVbb = 0.0;   ///< back bias absolute value for MFT (in Volt)
   float mIBVbb = 0.0; ///< back bias absolute value for ITS Inner Barrel (in Volt)
-  float mOBVbb = 0.0; ///< back bias absolute value for ITS Outter Barrel (in Volt)
+  float mOBVbb = 0.0; ///< back bias absolute value for ITS Outer Barrel (in Volt)
+
+  std::vector<int> mROFrameLayerLengthInBC; ///< staggering ROF length in BC for continuous mode per layer
+  std::vector<int> mROFrameLayerBiasInBC;   ///< staggering ROF bias in BC for continuous mode per layer
+  std::vector<float> mROFrameLayerLength;   ///< staggering ROF length in ns for continuous mode per layer
+  std::vector<float> mStrobeLayerLength;    ///< staggering length of the strobe in ns (sig. over threshold checked in this window only)
+  std::vector<float> mStrobeLayerDelay;     ///< staggering delay of the strobe in ns
 
   o2::itsmft::AlpideSignalTrapezoid mSignalShape; ///< signal timeshape parameterization
 
   const o2::itsmft::AlpideSimResponse* mAlpSimResponse = nullptr; //!< pointer on external response
 
   // auxiliary precalculated parameters
-  float mROFrameLengthInv = 0; ///< inverse length of RO frame in ns
-  float mNSimStepsInv = 0;     ///< its inverse
+  float mROFrameLengthInv = 0;               ///< inverse length of RO frame in ns
+  std::vector<float> mROFrameLayerLengthInv; // inverse length of RO frame in ns per layer
+  float mNSimStepsInv = 0;                   ///< its inverse
 
-  ClassDef(DigiParams, 2);
+  ClassDef(DigiParams, 3);
 };
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
index 670dd32bf9f46..c81e2d9476644 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/Digitizer.h
@@ -49,6 +49,8 @@ class Digitizer : public TObject
 
  public:
   Digitizer() = default;
+  Digitizer(Digitizer&&) = delete;
+  Digitizer& operator=(Digitizer&&) = delete;
   ~Digitizer() override = default;
   Digitizer(const Digitizer&) = delete;
   Digitizer& operator=(const Digitizer&) = delete;
@@ -56,7 +58,7 @@ class Digitizer : public TObject
   void setDigits(std::vector<o2::itsmft::Digit>* dig) { mDigits = dig; }
   void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
   void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
-  o2::itsmft::DigiParams& getParams() { return (o2::itsmft::DigiParams&)mParams; }
+  o2::itsmft::DigiParams& getParams() { return mParams; }
   const o2::itsmft::DigiParams& getParams() const { return mParams; }
   void setNoiseMap(const o2::itsmft::NoiseMap* mp) { mNoiseMap = mp; }
   void setDeadChannelsMap(const o2::itsmft::NoiseMap* mp) { mDeadChanMap = mp; }
@@ -67,17 +69,17 @@ class Digitizer : public TObject
   auto getChipResponse(int chipID);
 
   /// Steer conversion of hits to digits
-  void process(const std::vector<Hit>* hits, int evID, int srcID);
-  void setEventTime(const o2::InteractionTimeRecord& irt);
+  void process(const std::vector<Hit>* hits, int evID, int srcID, int layer = -1);
+  void setEventTime(const o2::InteractionTimeRecord& irt, int layer = -1);
   double getEndTimeOfROFMax() const
   {
     ///< return the time corresponding to end of the last reserved ROFrame : mROFrameMax
-    return mParams.getROFrameLength() * (mROFrameMax + 1) + mParams.getTimeOffset();
+    return (mParams.getROFrameLength() * (double)(mROFrameMax + 1)) + mParams.getTimeOffset();
   }
 
   void setContinuous(bool v) { mParams.setContinuous(v); }
   bool isContinuous() const { return mParams.isContinuous(); }
-  void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
+  void fillOutputContainer(uint32_t maxFrame = 0xffffffff, int layer = -1);
 
   void setDigiParams(const o2::itsmft::DigiParams& par) { mParams = par; }
   const o2::itsmft::DigiParams& getDigitParams() const { return mParams; }
@@ -92,11 +94,17 @@ class Digitizer : public TObject
     mEventROFrameMin = 0xffffffff;
     mEventROFrameMax = 0;
   }
+  void resetROFrameBounds()
+  {
+    mROFrameMin = 0;
+    mROFrameMax = 0;
+    mNewROFrame = 0;
+  }
 
  private:
-  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID);
+  void processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID, int lay);
   void registerDigits(ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
-                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
+                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl, int lay);
 
   ExtraDig* getExtraDigBuffer(uint32_t roFrame)
   {
@@ -115,7 +123,7 @@ class Digitizer : public TObject
   o2::itsmft::DigiParams mParams;          ///< digitization parameters
   o2::InteractionTimeRecord mEventTime;    ///< global event time and interaction record
   o2::InteractionRecord mIRFirstSampledTF; ///< IR of the 1st sampled IR, noise-only ROFs will be inserted till this IR only
-  double mCollisionTimeWrtROF;
+  double mCollisionTimeWrtROF{};
   uint32_t mROFrameMin = 0; ///< lowest RO frame of current digits
   uint32_t mROFrameMax = 0; ///< highest RO frame of current digits
   uint32_t mNewROFrame = 0; ///< ROFrame corresponding to provided time
diff --git a/Detectors/ITSMFT/common/simulation/src/DigiParams.cxx b/Detectors/ITSMFT/common/simulation/src/DigiParams.cxx
index ffba627265cc7..a7c5c32b6351d 100644
--- a/Detectors/ITSMFT/common/simulation/src/DigiParams.cxx
+++ b/Detectors/ITSMFT/common/simulation/src/DigiParams.cxx
@@ -26,12 +26,17 @@ DigiParams::DigiParams()
   setNSimSteps(mNSimSteps);
 }
 
-void DigiParams::setROFrameLength(float lNS)
+void DigiParams::setROFrameLength(float lNS, int layer)
 {
   // set ROFrame length in nanosecongs
-  mROFrameLength = lNS;
-  assert(mROFrameLength > 1.);
-  mROFrameLengthInv = 1. / mROFrameLength;
+  assert(lNS > 1.f);
+  if (layer < 0) {
+    mROFrameLength = lNS;
+    mROFrameLengthInv = 1.f / mROFrameLength;
+  } else {
+    mROFrameLayerLength.push_back(lNS);
+    mROFrameLayerLengthInv.push_back(1.f / lNS);
+  }
 }
 
 void DigiParams::setNSimSteps(int v)
@@ -58,17 +63,24 @@ void DigiParams::setChargeThreshold(int v, float frac2Account)
 //______________________________________________
 void DigiParams::print() const
 {
-  // print settings
-  printf("Alpide digitization params:\n");
-  printf("Continuous readout             : %s\n", mIsContinuous ? "ON" : "OFF");
-  printf("Readout Frame Length(ns)       : %f\n", mROFrameLength);
-  printf("Strobe delay (ns)              : %f\n", mStrobeDelay);
-  printf("Strobe length (ns)             : %f\n", mStrobeLength);
-  printf("Threshold (N electrons)        : %d\n", mChargeThreshold);
-  printf("Min N electrons to account     : %d\n", mMinChargeToAccount);
-  printf("Number of charge sharing steps : %d\n", mNSimSteps);
-  printf("ELoss to N electrons factor    : %e\n", mEnergyToNElectrons);
-  printf("Noise level per pixel          : %e\n", mNoisePerPixel);
-  printf("Charge time-response:\n");
+  LOGF(info, "Alpide digitization params:");
+  LOGF(info, "Continuous readout               : %s", mIsContinuous ? "ON" : "OFF");
+  if (withStaggering()) {
+    for (int i{0}; i < (int)mROFrameLayerLengthInBC.size(); ++i) {
+      LOGF(info, " Readout Frame Layer:%d Length(ns)[BC]      : %f [%d]", i, mROFrameLayerLength[i], mROFrameLayerLengthInBC[i]);
+      LOGF(info, "Strobe delay Layer %d (ns)                : %f", i, mStrobeDelay);
+      LOGF(info, "Strobe length Layer %d (ns)               : %f", i, mStrobeLength);
+    }
+  } else {
+    LOGF(info, "Readout Frame Length(ns)         : %f", mROFrameLength);
+    LOGF(info, "Strobe delay (ns)                : %f", mStrobeDelay);
+    LOGF(info, "Strobe length (ns)               : %f", mStrobeLength);
+  }
+  LOGF(info, "Threshold (N electrons)          : %d", mChargeThreshold);
+  LOGF(info, "Min N electrons to account       : %d", mMinChargeToAccount);
+  LOGF(info, "Number of charge sharing steps   : %d", mNSimSteps);
+  LOGF(info, "ELoss to N electrons factor      : %e", mEnergyToNElectrons);
+  LOGF(info, "Noise level per pixel            : %e", mNoisePerPixel);
+  LOGF(info, "Charge time-response:");
   mSignalShape.print();
 }
diff --git a/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx b/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
index 4a8af0cbe9737..b1a92e988968b 100644
--- a/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
+++ b/Detectors/ITSMFT/common/simulation/src/Digitizer.cxx
@@ -13,6 +13,7 @@
 /// \brief Implementation of the ITS/MFT digitizer
 
 #include "DataFormatsITSMFT/Digit.h"
+#include "Framework/Logger.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "ITSMFTSimulation/DPLDigitizerParam.h"
 #include "ITSMFTSimulation/Digitizer.h"
@@ -21,10 +22,11 @@
 #include "DetectorsRaw/HBFUtils.h"
 
 #include <TRandom.h>
+#include <algorithm>
 #include <climits>
 #include <vector>
+#include <ranges>
 #include <numeric>
-#include <fairlogger/Logger.h> // for LOG
 
 using o2::itsmft::Digit;
 using o2::itsmft::Hit;
@@ -73,14 +75,14 @@ void Digitizer::init()
   } else {
     LOG(fatal) << "Invalid ITS Inner Barrel back-bias value";
   }
-  if (doptITS.OBVbb == 0.0) { // for ITS Outter Barrel
+  if (doptITS.OBVbb == 0.0) { // for ITS Outer Barrel
     mAlpSimRespOB = mAlpSimResp[0];
     LOG(info) << "Choosing Vbb=0V for ITS OB";
   } else if (doptITS.OBVbb == 3.0) {
     mAlpSimRespOB = mAlpSimResp[1];
     LOG(info) << "Choosing Vbb=-3V for ITS OB";
   } else {
-    LOG(fatal) << "Invalid ITS Outter Barrel back-bias value";
+    LOG(fatal) << "Invalid ITS Outer Barrel back-bias value";
   }
   mParams.print();
   mIRFirstSampledTF = o2::raw::HBFUtils::Instance().getFirstSampledTFIR();
@@ -98,47 +100,53 @@ auto Digitizer::getChipResponse(int chipID)
 
   if (chipID < 432) { // in ITS Inner Barrel
     return mAlpSimRespIB;
-  } else { // in ITS Outter Barrel
+  } else { // in ITS Outer Barrel
     return mAlpSimRespOB;
   }
 }
 
 //_______________________________________________________________________
-void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
+void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID, int layer)
 {
   // digitize single event, the time must have been set beforehand
+  // opt. apply a filter on the layer of the processed hits
 
-  LOG(debug) << "Digitizing " << mGeometry->getName() << " hits of entry " << evID << " from source "
+  LOG(debug) << "Digitizing " << mGeometry->getName() << ":" << layer << " hits of entry " << evID << " from source "
              << srcID << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
              << " cont.mode: " << isContinuous()
              << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
 
   // is there something to flush ?
   if (mNewROFrame > mROFrameMin) {
-    fillOutputContainer(mNewROFrame - 1); // flush out all frame preceding the new one
+    fillOutputContainer(mNewROFrame - 1, layer); // flush out all frame preceding the new one
   }
 
   int nHits = hits->size();
   std::vector<int> hitIdx(nHits);
   std::iota(std::begin(hitIdx), std::end(hitIdx), 0);
   // sort hits to improve memory access
-  std::sort(hitIdx.begin(), hitIdx.end(),
-            [hits](auto lhs, auto rhs) {
-              return (*hits)[lhs].GetDetectorID() < (*hits)[rhs].GetDetectorID();
-            });
-  for (int i : hitIdx) {
-    processHit((*hits)[i], mROFrameMax, evID, srcID);
+  std::sort(hitIdx.begin(), hitIdx.end(), [hits](auto lhs, auto rhs) {
+    return (*hits)[lhs].GetDetectorID() < (*hits)[rhs].GetDetectorID();
+  });
+  for (int i : hitIdx | std::views::filter([&](int idx) {
+                 if (layer < 0) {
+                   return true;
+                 }
+                 return mGeometry->getLayer((*hits)[idx].GetDetectorID()) == layer;
+               })) {
+    processHit((*hits)[i], mROFrameMax, evID, srcID, layer);
   }
+
   // in the triggered mode store digits after every MC event
   // TODO: in the real triggered mode this will not be needed, this is actually for the
   // single event processing only
   if (!mParams.isContinuous()) {
-    fillOutputContainer(mROFrameMax);
+    fillOutputContainer(mROFrameMax, layer);
   }
 }
 
 //_______________________________________________________________________
-void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
+void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt, int layer)
 {
   // assign event time in ns
   mEventTime = irt;
@@ -161,13 +169,13 @@ void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
       // this event is before the first RO
       mIsBeforeFirstRO = true;
     } else {
-      mNewROFrame = nbc / mParams.getROFrameLengthInBC();
+      mNewROFrame = nbc / mParams.getROFrameLengthInBC(layer);
       mIsBeforeFirstRO = false;
     }
     LOG(debug) << " NewROFrame " << mNewROFrame << " nbc " << nbc;
 
     // in continuous mode depends on starts of periodic readout frame
-    mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC()) * o2::constants::lhc::LHCBunchSpacingNS;
+    mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC(layer)) * o2::constants::lhc::LHCBunchSpacingNS;
   } else {
     mNewROFrame = 0;
   }
@@ -183,16 +191,14 @@ void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
 }
 
 //_______________________________________________________________________
-void Digitizer::fillOutputContainer(uint32_t frameLast)
+void Digitizer::fillOutputContainer(uint32_t frameLast, int layer)
 {
   // fill output with digits from min.cached up to requested frame, generating the noise beforehand
-  if (frameLast > mROFrameMax) {
-    frameLast = mROFrameMax;
-  }
+  frameLast = std::min(frameLast, mROFrameMax);
   // make sure all buffers for extra digits are created up to the maxFrame
   getExtraDigBuffer(mROFrameMax);
 
-  LOG(info) << "Filling " << mGeometry->getName() << " digits output for RO frames " << mROFrameMin << ":"
+  LOG(info) << "Filling " << mGeometry->getName() << " digits:" << layer << " output for RO frames " << mROFrameMin << ":"
             << frameLast;
 
   o2::itsmft::ROFRecord rcROF;
@@ -204,7 +210,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
 
     auto& extra = *(mExtraBuff.front().get());
     for (auto& chip : mChips) {
-      if (chip.isDisabled()) {
+      if (chip.isDisabled() || (layer >= 0 && mGeometry->getLayer(chip.getChipIndex()) != layer)) {
         continue;
       }
       chip.addNoise(mROFrameMin, mROFrameMin, &mParams);
@@ -236,7 +242,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
     // finalize ROF record
     rcROF.setNEntries(mDigits->size() - rcROF.getFirstEntry()); // number of digits
     if (isContinuous()) {
-      rcROF.getBCData().setFromLong(mIRFirstSampledTF.toLong() + mROFrameMin * mParams.getROFrameLengthInBC());
+      rcROF.getBCData().setFromLong(mIRFirstSampledTF.toLong() + mROFrameMin * mParams.getROFrameLengthInBC(layer));
     } else {
       rcROF.getBCData() = mEventTime; // RSTODO do we need to add trigger delay?
     }
@@ -251,7 +257,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
 }
 
 //_______________________________________________________________________
-void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID)
+void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID, int srcID, int lay)
 {
   // convert single hit to digits
   auto chipID = hit.GetDetectorID();
@@ -284,14 +290,12 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   }
   float tTot = mParams.getSignalShape().getMaxDuration();
   // frame of the hit signal start wrt event ROFrame
-  int roFrameRel = int(timeInROF * mParams.getROFrameLengthInv());
+  int roFrameRel = int(timeInROF * mParams.getROFrameLengthInv(lay));
   // frame of the hit signal end  wrt event ROFrame: in the triggered mode we read just 1 frame
-  uint32_t roFrameRelMax = mParams.isContinuous() ? (timeInROF + tTot) * mParams.getROFrameLengthInv() : roFrameRel;
+  uint32_t roFrameRelMax = mParams.isContinuous() ? (timeInROF + tTot) * mParams.getROFrameLengthInv(lay) : roFrameRel;
   int nFrames = roFrameRelMax + 1 - roFrameRel;
   uint32_t roFrameMax = mNewROFrame + roFrameRelMax;
-  if (roFrameMax > maxFr) {
-    maxFr = roFrameMax; // if signal extends beyond current maxFrame, increase the latter
-  }
+  maxFr = std::max(roFrameMax, maxFr); // if signal extends beyond current maxFrame, increase the latter
 
   // here we start stepping in the depth of the sensor to generate charge diffusion
   float nStepsInv = mParams.getNSimStepsInv();
@@ -332,17 +336,13 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
   }
   rowS -= AlpideRespSimMat::NPix / 2;
   rowE += AlpideRespSimMat::NPix / 2;
-  if (rowS < 0) {
-    rowS = 0;
-  }
+  rowS = std::max(rowS, 0);
   if (rowE >= Segmentation::NRows) {
     rowE = Segmentation::NRows - 1;
   }
   colS -= AlpideRespSimMat::NPix / 2;
   colE += AlpideRespSimMat::NPix / 2;
-  if (colS < 0) {
-    colS = 0;
-  }
+  colS = std::max(colS, 0);
   if (colE >= Segmentation::NCols) {
     colE = Segmentation::NCols - 1;
   }
@@ -362,7 +362,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
 
   const o2::itsmft::AlpideSimResponse* resp = getChipResponse(chipID);
 
-  // take into account that the AlpideSimResponse depth defintion has different min/max boundaries
+  // take into account that the AlpideSimResponse depth definition has different min/max boundaries
   // although the max should coincide with the surface of the epitaxial layer, which in the chip
   // local coordinates has Y = +SensorLayerThickness/2
 
@@ -379,7 +379,7 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
       rowPrev = row;
       colPrev = col;
     }
-    bool flipCol, flipRow;
+    bool flipCol = false, flipRow = false;
     // note that response needs coordinates along column row (locX) (locZ) then depth (locY)
     auto rspmat = resp->getResponse(xyzLocS.X() - cRowPix, xyzLocS.Z() - cColPix, xyzLocS.Y(), flipRow, flipCol);
 
@@ -389,12 +389,12 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
     }
 
     for (int irow = AlpideRespSimMat::NPix; irow--;) {
-      int rowDest = row + irow - AlpideRespSimMat::NPix / 2 - rowS; // destination row in the respMatrix
+      int rowDest = row + irow - (AlpideRespSimMat::NPix / 2) - rowS; // destination row in the respMatrix
       if (rowDest < 0 || rowDest >= rowSpan) {
         continue;
       }
       for (int icol = AlpideRespSimMat::NPix; icol--;) {
-        int colDest = col + icol - AlpideRespSimMat::NPix / 2 - colS; // destination column in the respMatrix
+        int colDest = col + icol - (AlpideRespSimMat::NPix / 2) - colS; // destination column in the respMatrix
         if (colDest < 0 || colDest >= colSpan) {
           continue;
         }
@@ -426,35 +426,31 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, uint32_t& maxFr, int evID
         continue;
       }
       //
-      registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl);
+      registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl, lay);
     }
   }
 }
 
 //________________________________________________________________________________
 void Digitizer::registerDigits(ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
-                               uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl)
+                               uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl, int lay)
 {
   // Register digits for given pixel, accounting for the possible signal contribution to
   // multiple ROFrame. The signal starts at time tInROF wrt the start of provided roFrame
   // In every ROFrame we check the collected signal during strobe
 
-  float tStrobe = mParams.getStrobeDelay() - tInROF; // strobe start wrt signal start
+  float tStrobe = mParams.getStrobeDelay(lay) - tInROF; // strobe start wrt signal start
   for (int i = 0; i < nROF; i++) {
     uint32_t roFr = roFrame + i;
-    int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength());
-    tStrobe += mParams.getROFrameLength(); // for the next ROF
+    int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength(lay));
+    tStrobe += mParams.getROFrameLength(lay); // for the next ROF
 
     // discard too small contributions, they have no chance to produce a digit
     if (nEleROF < mParams.getMinChargeToAccount()) {
       continue;
     }
-    if (roFr > mEventROFrameMax) {
-      mEventROFrameMax = roFr;
-    }
-    if (roFr < mEventROFrameMin) {
-      mEventROFrameMin = roFr;
-    }
+    mEventROFrameMax = std::max(roFr, mEventROFrameMax);
+    mEventROFrameMin = std::min(roFr, mEventROFrameMin);
     auto key = chip.getOrderingKey(roFr, row, col);
     PreDigit* pd = chip.findDigit(key);
     if (!pd) {
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitReaderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitReaderSpec.h
index e655e05842d71..348ba76468144 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitReaderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitReaderSpec.h
@@ -16,6 +16,7 @@
 
 #include "TFile.h"
 #include "TTree.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/GBTCalibData.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
@@ -34,64 +35,67 @@ namespace o2
 namespace itsmft
 {
 
+template <int N>
 class DigitReader : public Task
 {
  public:
+  static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+  static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  static constexpr int NLayers{o2::itsmft::DPLAlpideParam<N>::getNLayers()};
+  static constexpr int RLayers = o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? NLayers : 1;
+
   DigitReader() = delete;
-  DigitReader(o2::detectors::DetID id, bool useMC, bool useCalib, bool triggerOut);
+  DigitReader(bool useMC, bool useCalib, bool triggerOut);
   ~DigitReader() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
 
  protected:
   void connectTree(const std::string& filename);
+  template <typename Ptr>
+  void setBranchAddress(const std::string& base, Ptr& addr, int layer = -1);
+  std::string getBranchName(const std::string& base, int index);
 
-  std::vector<o2::itsmft::Digit> mDigits, *mDigitsPtr = &mDigits;
+  std::array<std::vector<o2::itsmft::Digit>*, NLayers> mDigits;
   std::vector<o2::itsmft::GBTCalibData> mCalib, *mCalibPtr = &mCalib;
-  std::vector<o2::itsmft::ROFRecord> mDigROFRec, *mDigROFRecPtr = &mDigROFRec;
-  std::vector<o2::itsmft::MC2ROFRecord> mDigMC2ROFs, *mDigMC2ROFsPtr = &mDigMC2ROFs;
-  o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel> mConstLabels;
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginInvalid;
+  std::array<std::vector<o2::itsmft::ROFRecord>*, NLayers> mDigROFRec;
+  std::array<std::vector<o2::itsmft::MC2ROFRecord>*, NLayers> mDigMC2ROFs;
+  std::array<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>, NLayers> mConstLabels;
+  std::array<o2::dataformats::IOMCTruthContainerView*, NLayers> mPLabels;
 
   std::unique_ptr<TFile> mFile;
   std::unique_ptr<TTree> mTree;
-  bool mUseMC = true;    // use MC truth
-  bool mUseCalib = true; // send calib data
-  bool mTriggerOut = true; // send dummy triggers vector
+  bool mUseMC = true;        // use MC truth
+  bool mUseCalib = true;     // send calib data
+  bool mTriggerOut = true;   // send dummy triggers vector
   bool mUseIRFrames = false; // selected IRFrames modes
   int mROFBiasInBC = 0;
   int mROFLengthInBC = 0;
   int mNRUs = 0;
-  std::string mDetName = "";
-  std::string mDetNameLC = "";
-  std::string mFileName = "";
+  std::string mDetName;
+  std::string mDetNameLC;
+  std::string mFileName;
   std::string mDigTreeName = "o2sim";
   std::string mDigitBranchName = "Digit";
-  std::string mDigROFBranchName = "DigitROF";
+  std::string mDigitROFBranchName = "DigitROF";
   std::string mCalibBranchName = "Calib";
 
-  std::string mDigtMCTruthBranchName = "DigitMCTruth";
-  std::string mDigtMC2ROFBranchName = "DigitMC2ROF";
+  std::string mDigitMCTruthBranchName = "DigitMCTruth";
+  std::string mDigitMC2ROFBranchName = "DigitMC2ROF";
 };
 
-class ITSDigitReader : public DigitReader
+class ITSDigitReader : public DigitReader<o2::detectors::DetID::ITS>
 {
  public:
   ITSDigitReader(bool useMC = true, bool useCalib = false, bool useTriggers = true)
-    : DigitReader(o2::detectors::DetID::ITS, useMC, useCalib, useTriggers)
-  {
-    mOrigin = o2::header::gDataOriginITS;
-  }
+    : DigitReader<o2::detectors::DetID::ITS>(useMC, useCalib, useTriggers) {}
 };
 
-class MFTDigitReader : public DigitReader
+class MFTDigitReader : public DigitReader<o2::detectors::DetID::MFT>
 {
  public:
   MFTDigitReader(bool useMC = true, bool useCalib = false, bool useTriggers = true)
-    : DigitReader(o2::detectors::DetID::MFT, useMC, useCalib, useTriggers)
-  {
-    mOrigin = o2::header::gDataOriginMFT;
-  }
+    : DigitReader<o2::detectors::DetID::MFT>(useMC, useCalib, useTriggers) {}
 };
 
 /// create a processor spec
diff --git a/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
index 3c7a86fe173d6..ec86da4833a0d 100644
--- a/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
@@ -11,6 +11,7 @@
 
 /// @file   DigitReaderSpec.cxx
 
+#include <string>
 #include <vector>
 
 #include "TTree.h"
@@ -39,25 +40,28 @@ namespace o2
 namespace itsmft
 {
 
-DigitReader::DigitReader(o2::detectors::DetID id, bool useMC, bool useCalib, bool triggerOut)
+template <int N>
+DigitReader<N>::DigitReader(bool useMC, bool useCalib, bool triggerOut) : mUseMC(useMC), mUseCalib(useCalib), mTriggerOut(triggerOut), mDetNameLC(mDetName = ID.getName()), mDigTreeName("o2sim")
 {
-  assert(id == o2::detectors::DetID::ITS || id == o2::detectors::DetID::MFT);
-  mDetNameLC = mDetName = id.getName();
-  mDigTreeName = "o2sim";
-
   mDigitBranchName = mDetName + mDigitBranchName;
-  mDigROFBranchName = mDetName + mDigROFBranchName;
+  mDigitROFBranchName = mDetName + mDigitROFBranchName;
   mCalibBranchName = mDetName + mCalibBranchName;
 
-  mDigtMCTruthBranchName = mDetName + mDigtMCTruthBranchName;
-  mDigtMC2ROFBranchName = mDetName + mDigtMC2ROFBranchName;
-  mTriggerOut = triggerOut;
-  mUseMC = useMC;
-  mUseCalib = useCalib;
+  mDigitMCTruthBranchName = mDetName + mDigitMCTruthBranchName;
+  mDigitMC2ROFBranchName = mDetName + mDigitMC2ROFBranchName;
+
   std::transform(mDetNameLC.begin(), mDetNameLC.end(), mDetNameLC.begin(), ::tolower);
+
+  for (uint32_t i = 0; i < NLayers; ++i) {
+    mDigits[i] = nullptr;
+    mDigROFRec[i] = nullptr;
+    mDigMC2ROFs[i] = nullptr;
+    mPLabels[i] = nullptr;
+  }
 }
 
-void DigitReader::init(InitContext& ic)
+template <int N>
+void DigitReader<N>::init(InitContext& ic)
 {
   mFileName = o2::utils::Str::concat_string(o2::utils::Str::rectifyDirectory(ic.options().get<std::string>("input-dir")),
                                             ic.options().get<std::string>((mDetNameLC + "-digit-infile").c_str()));
@@ -67,23 +71,23 @@ void DigitReader::init(InitContext& ic)
   connectTree(mFileName);
 }
 
-void DigitReader::run(ProcessingContext& pc)
+template <int N>
+void DigitReader<N>::run(ProcessingContext& pc)
 {
   const auto& tinfo = pc.services().get<o2::framework::TimingInfo>();
+  const auto& alpideParam = o2::itsmft::DPLAlpideParam<N>::Instance();
   if (tinfo.globalRunNumberChanged && mUseIRFrames) { // new run is starting: 1st call
     // TODO: we have to find a way define CCDBInput for IRFrames mode only using DPL fetcher
     auto& ccdb = o2::ccdb::BasicCCDBManager::instance();
     auto rlim = ccdb.getRunDuration(tinfo.runNumber);
     long ts = (rlim.first + rlim.second) / 2;
-    if (mOrigin == o2::header::gDataOriginITS) {
+    if constexpr (N == o2::detectors::DetID::ITS) {
       ccdb.getForTimeStamp<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>>("ITS/Config/AlpideParam", ts);
-      const auto& alpideParam = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
       mROFBiasInBC = alpideParam.roFrameBiasInBC;
       mROFLengthInBC = alpideParam.roFrameLengthInBC;
       mNRUs = o2::itsmft::ChipMappingITS::getNRUs();
     } else {
       ccdb.getForTimeStamp<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>>("MFT/Config/AlpideParam", ts);
-      const auto& alpideParam = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>::Instance();
       mROFBiasInBC = alpideParam.roFrameBiasInBC;
       mROFLengthInBC = alpideParam.roFrameLengthInBC;
       mNRUs = o2::itsmft::ChipMappingMFT::getNRUs();
@@ -93,38 +97,37 @@ void DigitReader::run(ProcessingContext& pc)
   if (mUseIRFrames) {
     irFrames = pc.inputs().get<gsl::span<o2::dataformats::IRFrame>>("driverInfo");
   }
-  static o2::dataformats::IOMCTruthContainerView* plabels = nullptr;
-  if (mUseMC && !plabels) {
-    mTree->SetBranchAddress(mDigtMCTruthBranchName.c_str(), &plabels);
-  }
-  auto ent = mTree->GetReadEntry();
 
+  auto ent = mTree->GetReadEntry();
   if (!mUseIRFrames) {
     ent++;
     assert(ent < mTree->GetEntries()); // this should not happen
     mTree->GetEntry(ent);
-    LOG(info) << mDetName << "DigitReader pushes " << mDigROFRec.size() << " ROFRecords, " << mDigits.size() << " digits at entry " << ent;
-    pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, mDigROFRec);
-    pc.outputs().snapshot(Output{mOrigin, "DIGITS", 0}, mDigits);
+    for (uint32_t iLayer = 0; iLayer < RLayers; ++iLayer) {
+      LOG(info) << mDetName << "DigitReader:" << iLayer << " pushes " << mDigROFRec[iLayer]->size() << " ROFRecords, " << mDigits[iLayer]->size() << " digits at entry " << ent;
+      pc.outputs().snapshot(Output{Origin, "DIGITSROF", iLayer}, *mDigROFRec[iLayer]);
+      pc.outputs().snapshot(Output{Origin, "DIGITS", iLayer}, *mDigits[iLayer]);
+      if (mUseMC) {
+        auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{Origin, "DIGITSMCTR", iLayer});
+        mPLabels[iLayer]->copyandflatten(sharedlabels);
+        delete mPLabels[iLayer];
+        mPLabels[iLayer] = nullptr;
+        pc.outputs().snapshot(Output{Origin, "DIGITSMC2ROF", iLayer}, *mDigMC2ROFs[iLayer]);
+      }
+    }
     if (mUseCalib) {
-      pc.outputs().snapshot(Output{mOrigin, "GBTCALIB", 0}, mCalib);
+      pc.outputs().snapshot(Output{Origin, "GBTCALIB", 0}, mCalib);
     }
     if (mTriggerOut) {
       std::vector<o2::itsmft::PhysTrigger> dummyTrig;
-      pc.outputs().snapshot(Output{mOrigin, "PHYSTRIG", 0}, dummyTrig);
-    }
-    if (mUseMC) {
-      auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", 0});
-      plabels->copyandflatten(sharedlabels);
-      delete plabels;
-      plabels = nullptr;
-      pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, mDigMC2ROFs);
+      pc.outputs().snapshot(Output{Origin, "PHYSTRIG", 0}, dummyTrig);
     }
     if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
       pc.services().get<ControlService>().endOfStream();
       pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     }
   } else { // need to select particulars IRs range, presumably from the same tree entry
+           // TODO implement for staggering
     std::vector<o2::itsmft::Digit> digitsSel;
     std::vector<o2::itsmft::GBTCalibData> calibSel;
     std::vector<o2::itsmft::ROFRecord> digROFRecSel;
@@ -144,33 +147,33 @@ void DigitReader::run(ProcessingContext& pc)
         // do we need to read a new entry?
         if (ent > mTree->GetReadEntry()) {
           if (mUseMC) {
-            delete plabels;
-            plabels = nullptr;
-            mConstLabels.clear();
-            mTree->SetBranchAddress(mDigtMCTruthBranchName.c_str(), &plabels);
+            delete mPLabels[0];
+            mPLabels[0] = nullptr;
+            mConstLabels[0].clear();
+            mTree->SetBranchAddress(mDigitMCTruthBranchName.c_str(), &mPLabels[0]);
           }
           mTree->GetEntry(ent);
           if (mUseMC) {
-            plabels->copyandflatten(mConstLabels);
-            delete plabels;
-            plabels = nullptr;
+            mPLabels[0]->copyandflatten(mConstLabels[0]);
+            delete mPLabels[0];
+            mPLabels[0] = nullptr;
           }
         }
         std::vector<int> rofOld2New;
-        rofOld2New.resize(mDigROFRec.size(), -1);
+        rofOld2New.resize(mDigROFRec[0]->size(), -1);
 
-        if (mDigROFRec.front().getBCData() <= irMax && (mDigROFRec.back().getBCData() + mROFLengthInBC - 1) >= irMin) { // there is an overlap
-          for (int irof = 0; irof < (int)mDigROFRec.size(); irof++) {
-            const auto& rof = mDigROFRec[irof];
+        if (mDigROFRec[0]->front().getBCData() <= irMax && (mDigROFRec[0]->back().getBCData() + mROFLengthInBC - 1) >= irMin) { // there is an overlap
+          for (int irof = 0; irof < (int)mDigROFRec[0]->size(); irof++) {
+            const auto& rof = mDigROFRec[0]->at(irof);
             if (irfSel.check({rof.getBCData(), rof.getBCData() + mROFLengthInBC - 1}) != -1) {
               rofOld2New[irof] = (int)digROFRecSel.size();
               LOGP(debug, "Adding selected ROF {}", rof.getBCData().asString());
               digROFRecSel.push_back(rof);
               int offs = digitsSel.size();
               digROFRecSel.back().setFirstEntry(offs);
-              std::copy(mDigits.begin() + rof.getFirstEntry(), mDigits.begin() + rof.getFirstEntry() + rof.getNEntries(), std::back_inserter(digitsSel));
+              std::copy(mDigits[0]->begin() + rof.getFirstEntry(), mDigits[0]->begin() + rof.getFirstEntry() + rof.getNEntries(), std::back_inserter(digitsSel));
               for (int id = 0; id < rof.getNEntries(); id++) { // copy MC info
-                digitLabelsSel.addElements(id + offs, mConstLabels.getLabels(id + rof.getFirstEntry()));
+                digitLabelsSel.addElements(id + offs, mConstLabels[0].getLabels(id + rof.getFirstEntry()));
               }
               if (mCalib.size() >= size_t((irof + 1) * mNRUs)) {
                 std::copy(mCalib.begin() + irof * mNRUs, mCalib.begin() + (irof + 1) * mNRUs, std::back_inserter(calibSel));
@@ -179,7 +182,7 @@ void DigitReader::run(ProcessingContext& pc)
           }
         }
         if (mUseMC) {
-          digMC2ROFsSel = mDigMC2ROFs;
+          digMC2ROFsSel = *mDigMC2ROFs[0];
           for (auto& mc2rof : digMC2ROFsSel) {
             if (mc2rof.rofRecordID < 0) {
               continue; // did not contribute even to the original data
@@ -198,26 +201,26 @@ void DigitReader::run(ProcessingContext& pc)
             mc2rof.maxROF = mx;
           }
         }
-        if (mDigROFRec.back().getBCData() + mROFLengthInBC - 1 < irMax) { // need to check the next entry
+        if (mDigROFRec[0]->back().getBCData() + mROFLengthInBC - 1 < irMax) { // need to check the next entry
           ent++;
           continue;
         }
         break; // push collected data
       }
     }
-    pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, digROFRecSel);
-    pc.outputs().snapshot(Output{mOrigin, "DIGITS", 0}, digitsSel);
+    pc.outputs().snapshot(Output{Origin, "DIGITSROF", 0}, digROFRecSel);
+    pc.outputs().snapshot(Output{Origin, "DIGITS", 0}, digitsSel);
     if (mUseCalib) {
-      pc.outputs().snapshot(Output{mOrigin, "GBTCALIB", 0}, calibSel);
+      pc.outputs().snapshot(Output{Origin, "GBTCALIB", 0}, calibSel);
     }
     if (mTriggerOut) {
       std::vector<o2::itsmft::PhysTrigger> dummyTrig;
-      pc.outputs().snapshot(Output{mOrigin, "PHYSTRIG", 0}, dummyTrig);
+      pc.outputs().snapshot(Output{Origin, "PHYSTRIG", 0}, dummyTrig);
     }
     if (mUseMC) {
-      auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", 0});
+      auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{Origin, "DIGITSMCTR", 0});
       digitLabelsSel.flatten_to(sharedlabels);
-      pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, digMC2ROFsSel);
+      pc.outputs().snapshot(Output{Origin, "DIGITSMC2ROF", 0}, digMC2ROFsSel);
     }
 
     if (!irFrames.size() || irFrames.back().isLast()) {
@@ -227,77 +230,99 @@ void DigitReader::run(ProcessingContext& pc)
   }
 }
 
-void DigitReader::connectTree(const std::string& filename)
+template <int N>
+void DigitReader<N>::connectTree(const std::string& filename)
 {
   mTree.reset(nullptr); // in case it was already loaded
   mFile.reset(TFile::Open(filename.c_str()));
   assert(mFile && !mFile->IsZombie());
   mTree.reset((TTree*)mFile->Get(mDigTreeName.c_str()));
   assert(mTree);
-
-  mTree->SetBranchAddress(mDigROFBranchName.c_str(), &mDigROFRecPtr);
-  mTree->SetBranchAddress(mDigitBranchName.c_str(), &mDigitsPtr);
+  for (uint32_t iLayer = 0; iLayer < RLayers; ++iLayer) {
+    setBranchAddress(mDigitROFBranchName, mDigROFRec[iLayer], iLayer);
+    setBranchAddress(mDigitBranchName, mDigits[iLayer], iLayer);
+    if (mUseMC) {
+      if (!mTree->GetBranch(getBranchName(mDigitMC2ROFBranchName, iLayer).c_str()) || !mTree->GetBranch(getBranchName(mDigitMCTruthBranchName, iLayer).c_str())) {
+        throw std::runtime_error("MC data requested but not found in the tree");
+      }
+      setBranchAddress(mDigitMC2ROFBranchName, mDigMC2ROFs[iLayer], iLayer);
+      if (!mPLabels[iLayer]) {
+        setBranchAddress(mDigitMCTruthBranchName, mPLabels[iLayer], iLayer);
+      }
+    }
+  }
   if (mUseCalib) {
     if (!mTree->GetBranch(mCalibBranchName.c_str())) {
       throw std::runtime_error("GBT calibration data requested but not found in the tree");
     }
-    mTree->SetBranchAddress(mCalibBranchName.c_str(), &mCalibPtr);
-  }
-  if (mUseMC) {
-    if (!mTree->GetBranch(mDigtMC2ROFBranchName.c_str()) || !mTree->GetBranch(mDigtMCTruthBranchName.c_str())) {
-      throw std::runtime_error("MC data requested but not found in the tree");
-    }
-    mTree->SetBranchAddress(mDigtMC2ROFBranchName.c_str(), &mDigMC2ROFsPtr);
+    setBranchAddress(mCalibBranchName, mCalibPtr);
   }
   LOG(info) << "Loaded tree from " << filename << " with " << mTree->GetEntries() << " entries";
 }
 
-DataProcessorSpec getITSDigitReaderSpec(bool useMC, bool useCalib, bool useTriggers, std::string defname)
+template <int N>
+std::string DigitReader<N>::getBranchName(const std::string& base, int index)
 {
-  std::vector<OutputSpec> outputSpec;
-  outputSpec.emplace_back("ITS", "DIGITS", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("ITS", "DIGITSROF", 0, Lifetime::Timeframe);
-  if (useCalib) {
-    outputSpec.emplace_back("ITS", "GBTCALIB", 0, Lifetime::Timeframe);
+  if constexpr (!o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) {
+    return base;
   }
-  if (useMC) {
-    outputSpec.emplace_back("ITS", "DIGITSMCTR", 0, Lifetime::Timeframe);
-    outputSpec.emplace_back("ITS", "DIGITSMC2ROF", 0, Lifetime::Timeframe);
+  return base + "_" + std::to_string(index);
+}
+
+template <int N>
+template <typename Ptr>
+void DigitReader<N>::setBranchAddress(const std::string& base, Ptr& addr, int layer)
+{
+  const auto name = getBranchName(base, layer);
+  if (Int_t ret = mTree->SetBranchAddress(name.c_str(), &addr); ret != 0) {
+    LOGP(fatal, "failed to set branch address for {} ret={}", name, ret);
   }
-  if (useTriggers) {
-    outputSpec.emplace_back("ITS", "PHYSTRIG", 0, Lifetime::Timeframe);
+}
+
+namespace
+{
+template <int N>
+std::vector<OutputSpec> makeOutChannels(bool mctruth, bool useCalib)
+{
+  constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  std::vector<OutputSpec> outputs;
+  static constexpr int RLayers = o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1;
+  for (int iLayer = 0; iLayer < RLayers; ++iLayer) {
+    outputs.emplace_back(Origin, "DIGITS", iLayer, Lifetime::Timeframe);
+    outputs.emplace_back(Origin, "DIGITSROF", iLayer, Lifetime::Timeframe);
+    if (mctruth) {
+      outputs.emplace_back(Origin, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(Origin, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
+    }
   }
+  if (useCalib) {
+    outputs.emplace_back(Origin, "GBTCALIB", 0, Lifetime::Timeframe);
+  }
+  outputs.emplace_back(Origin, "PHYSTRIG", 0, Lifetime::Timeframe);
+  return outputs;
+}
+} // namespace
+
+DataProcessorSpec getITSDigitReaderSpec(bool useMC, bool useCalib, bool useTriggers, std::string defname)
+{
   return DataProcessorSpec{
-    "its-digit-reader",
-    Inputs{},
-    outputSpec,
-    AlgorithmSpec{adaptFromTask<ITSDigitReader>(useMC, useCalib)},
-    Options{
+    .name = "its-digit-reader",
+    .inputs = Inputs{},
+    .outputs = makeOutChannels<o2::detectors::DetID::ITS>(useMC, useCalib),
+    .algorithm = AlgorithmSpec{adaptFromTask<ITSDigitReader>(useMC, useCalib)},
+    .options = Options{
       {"its-digit-infile", VariantType::String, defname, {"Name of the input digit file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
 }
 
 DataProcessorSpec getMFTDigitReaderSpec(bool useMC, bool useCalib, bool useTriggers, std::string defname)
 {
-  std::vector<OutputSpec> outputSpec;
-  outputSpec.emplace_back("MFT", "DIGITS", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("MFT", "DIGITSROF", 0, Lifetime::Timeframe);
-  if (useCalib) {
-    outputSpec.emplace_back("MFT", "GBTCALIB", 0, Lifetime::Timeframe);
-  }
-  if (useMC) {
-    outputSpec.emplace_back("MFT", "DIGITSMCTR", 0, Lifetime::Timeframe);
-    outputSpec.emplace_back("MFT", "DIGITSMC2ROF", 0, Lifetime::Timeframe);
-  }
-  if (useTriggers) {
-    outputSpec.emplace_back("MFT", "PHYSTRIG", 0, Lifetime::Timeframe);
-  }
   return DataProcessorSpec{
-    "mft-digit-reader",
-    Inputs{},
-    outputSpec,
-    AlgorithmSpec{adaptFromTask<MFTDigitReader>(useMC, useCalib)},
-    Options{
+    .name = "mft-digit-reader",
+    .inputs = Inputs{},
+    .outputs = makeOutChannels<o2::detectors::DetID::MFT>(useMC, useCalib),
+    .algorithm = AlgorithmSpec{adaptFromTask<MFTDigitReader>(useMC, useCalib)},
+    .options = Options{
       {"mft-digit-infile", VariantType::String, defname, {"Name of the input digit file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
 }
diff --git a/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx b/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
index 3a06d106ceb1f..c4f1e336180c7 100644
--- a/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
@@ -12,6 +12,9 @@
 /// @brief  Processor spec for a ROOT file writer for ITSMFT digits
 
 #include "ITSMFTWorkflow/DigitWriterSpec.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/DataRef.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
 #include "DPLUtils/MakeRootTreeWriterSpec.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/GBTCalibData.h"
@@ -39,14 +42,24 @@ using MCCont = o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>;
 
 /// create the processor spec
 /// describing a processor receiving digits for ITS/MFT and writing them to file
-DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib, o2::header::DataOrigin detOrig, o2::detectors::DetID detId)
+template <int N>
+DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib)
 {
-  std::string detStr = o2::detectors::DetID::getName(detId);
+  static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  constexpr int NLayers = o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1;
+  std::string detStr = o2::detectors::DetID::getName(N);
   std::string detStrL = dec ? "o2_" : ""; // for decoded digits prepend by o2
   detStrL += detStr;
   std::transform(detStrL.begin(), detStrL.end(), detStrL.begin(), ::tolower);
-  auto logger = [](std::vector<o2::itsmft::Digit> const& inDigits) {
-    LOG(info) << "RECEIVED DIGITS SIZE " << inDigits.size();
+  auto digitSizes = std::make_shared<std::array<size_t, NLayers>>();
+  auto digitSizeGetter = [digitSizes](std::vector<o2::itsmft::Digit> const& inDigits, DataRef const& ref) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    (*digitSizes)[dh->subSpecification] = inDigits.size();
+  };
+  auto rofSizes = std::make_shared<std::array<size_t, NLayers>>();
+  auto rofSizeGetter = [rofSizes](std::vector<o2::itsmft::ROFRecord> const& inROFs, DataRef const& ref) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    (*rofSizes)[dh->subSpecification] = inROFs.size();
   };
 
   // the callback to be set as hook for custom action when the writer is closed
@@ -71,9 +84,11 @@ DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib, o2::hea
   // handler for labels
   // This is necessary since we can't store the original label buffer in a ROOT entry -- as is -- if it exceeds a certain size.
   // We therefore convert it to a special split class.
-  auto fillLabels = [](TBranch& branch, std::vector<char> const& labelbuffer, DataRef const& /*ref*/) {
+  auto fillLabels = [digitSizes, rofSizes](TBranch& branch, std::vector<char> const& labelbuffer, DataRef const& ref) {
     o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
-    LOG(info) << "WRITING " << labels.getNElements() << " LABELS ";
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    auto layer = static_cast<size_t>(dh->subSpecification);
+    LOG(info) << "WRITING " << labels.getNElements() << " LABELS FOR " << layer << " WITH " << (*digitSizes)[layer] << " DIGITS IN " << (*rofSizes)[layer] << " ROFS";
 
     o2::dataformats::IOMCTruthContainerView outputcontainer;
     auto ptr = &outputcontainer;
@@ -83,35 +98,56 @@ DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib, o2::hea
     br->ResetAddress();
   };
 
+  auto getIndex = [](DataRef const& ref) -> size_t {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    return static_cast<size_t>(dh->subSpecification);
+  };
+  auto getName = [](std::string base, size_t index) -> std::string {
+    if constexpr (o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) {
+      return base += "_" + std::to_string(index);
+    }
+    return base;
+  };
   return MakeRootTreeWriterSpec((detStr + "DigitWriter" + (dec ? "_dec" : "")).c_str(),
                                 (detStrL + "digits.root").c_str(),
-                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Digits tree"},
+                                MakeRootTreeWriterSpec::TreeAttributes{.name = "o2sim", .title = detStr + " Digits tree"},
                                 MakeRootTreeWriterSpec::CustomClose(finishWriting),
-                                // in case of labels we first read them as std::vector<char> and process them correctly in the fillLabels hook
-                                BranchDefinition<std::vector<char>>{InputSpec{(detStr + "_digitsMCTR").c_str(), detOrig, "DIGITSMCTR", 0},
-                                                                    (detStr + "DigitMCTruth").c_str(),
-                                                                    (mctruth ? 1 : 0), fillLabels},
-                                BranchDefinition<std::vector<itsmft::MC2ROFRecord>>{InputSpec{(detStr + "_digitsMC2ROF").c_str(), detOrig, "DIGITSMC2ROF", 0},
-                                                                                    (detStr + "DigitMC2ROF").c_str(),
-                                                                                    (mctruth ? 1 : 0)},
-                                BranchDefinition<std::vector<itsmft::Digit>>{InputSpec{(detStr + "digits").c_str(), detOrig, "DIGITS", 0},
-                                                                             (detStr + "Digit").c_str(),
-                                                                             logger},
-                                BranchDefinition<std::vector<itsmft::GBTCalibData>>{InputSpec{(detStr + "calib").c_str(), detOrig, "GBTCALIB", 0},
-                                                                                    (detStr + "Calib").c_str(),
-                                                                                    (calib ? 1 : 0)},
-                                BranchDefinition<std::vector<itsmft::ROFRecord>>{InputSpec{(detStr + "digitsROF").c_str(), detOrig, "DIGITSROF", 0},
-                                                                                 (detStr + "DigitROF").c_str()})();
+                                BranchDefinition<std::vector<itsmft::Digit>>{InputSpec{detStr + "digits", ConcreteDataTypeMatcher{Origin, "DIGITS"}},
+                                                                             detStr + "Digit", "digit-branch",
+                                                                             NLayers,
+                                                                             digitSizeGetter,
+                                                                             getIndex,
+                                                                             getName},
+                                BranchDefinition<std::vector<itsmft::ROFRecord>>{InputSpec{detStr + "digitsROF", ConcreteDataTypeMatcher{Origin, "DIGITSROF"}},
+                                                                                 detStr + "DigitROF", "digit-rof-branch",
+                                                                                 NLayers,
+                                                                                 rofSizeGetter,
+                                                                                 getIndex,
+                                                                                 getName},
+                                BranchDefinition<std::vector<char>>{InputSpec{detStr + "_digitsMCTR", ConcreteDataTypeMatcher{Origin, "DIGITSMCTR"}},
+                                                                    detStr + "DigitMCTruth", "digit-mctruth-branch",
+                                                                    (mctruth ? NLayers : 0),
+                                                                    fillLabels,
+                                                                    getIndex,
+                                                                    getName},
+                                BranchDefinition<std::vector<itsmft::MC2ROFRecord>>{InputSpec{detStr + "_digitsMC2ROF", ConcreteDataTypeMatcher{Origin, "DIGITSMC2ROF"}},
+                                                                                    detStr + "DigitMC2ROF", "digit-mc2rof-branch",
+                                                                                    (mctruth ? NLayers : 0),
+                                                                                    getIndex,
+                                                                                    getName},
+                                BranchDefinition<std::vector<itsmft::GBTCalibData>>{InputSpec{detStr + "calib", ConcreteDataTypeMatcher{Origin, "GBTCALIB"}},
+                                                                                    detStr + "Calib", "digit-calib-branch",
+                                                                                    (calib ? 1 : 0)})();
 }
 
 DataProcessorSpec getITSDigitWriterSpec(bool mctruth, bool dec, bool calib)
 {
-  return getDigitWriterSpec(mctruth, dec, calib, o2::header::gDataOriginITS, o2::detectors::DetID::ITS);
+  return getDigitWriterSpec<o2::detectors::DetID::ITS>(mctruth, dec, calib);
 }
 
 DataProcessorSpec getMFTDigitWriterSpec(bool mctruth, bool dec, bool calib)
 {
-  return getDigitWriterSpec(mctruth, dec, calib, o2::header::gDataOriginMFT, o2::detectors::DetID::MFT);
+  return getDigitWriterSpec<o2::detectors::DetID::MFT>(mctruth, dec, calib);
 }
 
 } // end namespace itsmft
diff --git a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
index b40e377d58ca2..6809c8dee3f19 100644
--- a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
@@ -17,12 +17,13 @@
 #include "Framework/Lifetime.h"
 #include "Framework/Task.h"
 #include "Framework/CCDBParamSpec.h"
-#include "Steer/HitProcessingManager.h" // for DigitizationContext
+#include "SimulationDataFormat/DigitizationContext.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/NoiseMap.h"
 #include "DataFormatsITSMFT/TimeDeadMap.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "DetectorsBase/BaseDPLDigitizer.h"
+#include "DetectorsRaw/HBFUtils.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsCommonDataFormats/SimTraits.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
@@ -36,20 +37,25 @@
 #include <TChain.h>
 #include <TStopwatch.h>
 #include <string>
+#include <format>
 
 using namespace o2::framework;
 using SubSpecificationType = o2::framework::DataAllocator::SubSpecificationType;
 
-namespace o2
-{
-namespace itsmft
+namespace o2::itsmft
 {
 
 using namespace o2::base;
+template <int N>
 class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
 {
  public:
+  static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+  static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  static constexpr int NLayers{o2::itsmft::DPLAlpideParam<N>::getNLayers()};
+
   using BaseDPLDigitizer::init;
+
   void initDigitizerTask(framework::InitContext& ic) override
   {
     mDisableQED = ic.options().get<bool>("disable-qed");
@@ -60,121 +66,174 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
     if (mFinished) {
       return;
     }
+
     mFirstOrbitTF = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
-    mID == o2::detectors::DetID::ITS ? updateTimeDependentParams<o2::detectors::DetID::ITS>(pc) : updateTimeDependentParams<o2::detectors::DetID::MFT>(pc);
-    std::string detStr = mID.getName();
+    const o2::InteractionRecord firstIR(0, mFirstOrbitTF);
+    updateTimeDependentParams(pc);
+
+    TStopwatch timer;
+    timer.Start();
+    LOG(info) << " CALLING ITS DIGITIZATION ";
+
     // read collision context from input
     auto context = pc.inputs().get<o2::steer::DigitizationContext*>("collisioncontext");
-    context->initSimChains(mID, mSimChains);
+    context->initSimChains(ID, mSimChains);
     const bool withQED = context->isQEDProvided() && !mDisableQED;
     auto& timesview = context->getEventRecords(withQED);
     LOG(info) << "GOT " << timesview.size() << " COLLISSION TIMES";
-    LOG(info) << "SIMCHAINS " << mSimChains.size();
+    LOG(info) << "SIMCHAINS: " << mSimChains.size();
 
     // if there is nothing to do ... return
     if (timesview.size() == 0) {
       return;
     }
-    TStopwatch timer;
-    timer.Start();
-    LOG(info) << " CALLING ITS DIGITIZATION ";
 
-    mDigitizer.setDigits(&mDigits);
-    mDigitizer.setROFRecords(&mROFRecords);
-    mDigitizer.setMCLabels(&mLabels);
+    uint64_t nDigits{0};
+    constexpr uint32_t nLayers = (DPLAlpideParam<N>::supportsStaggering()) ? NLayers : 1;
+    for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
+      const int layer = (DPLAlpideParam<N>::supportsStaggering()) ? iLayer : -1;
+      mDigitizer.setDigits(&mDigits[iLayer]);
+      mDigitizer.setROFRecords(&mROFRecords[iLayer]);
+      mDigitizer.setMCLabels(&mLabels[iLayer]);
+      mDigitizer.resetROFrameBounds();
+
+      // digits are directly put into DPL owned resource
+      auto& digitsAccum = pc.outputs().make<std::vector<itsmft::Digit>>(Output{Origin, "DIGITS", iLayer});
+
+      // rofs are accumulated first and the copied
+      const int nROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer);
+      const int nROFsTF = nROFsPerOrbit * raw::HBFUtils::Instance().getNOrbitsPerTF();
+      mROFRecordsAccum[iLayer].reserve(nROFsTF);
+
+      auto accumulate = [this, &digitsAccum, &iLayer]() {
+        // accumulate result of single event processing on a specific layer, called after processing every event supplied
+        // AND after the final flushing via digitizer::fillOutputContainer
+        if (!mDigits[iLayer].size()) {
+          return; // no digits were flushed, nothing to accumulate
+        }
+        auto ndigAcc = digitsAccum.size();
+        std::copy(mDigits[iLayer].begin(), mDigits[iLayer].end(), std::back_inserter(digitsAccum));
+
+        // fix ROFrecords references on ROF entries
+        auto nROFRecsOld = mROFRecordsAccum[iLayer].size();
+
+        for (int i = 0; i < mROFRecords[iLayer].size(); i++) {
+          auto& rof = mROFRecords[iLayer][i];
+          rof.setFirstEntry(ndigAcc + rof.getFirstEntry());
+          rof.print();
+
+          if (mFixMC2ROF[iLayer] < mMC2ROFRecordsAccum[iLayer].size()) { // fix ROFRecord entry in MC2ROF records
+            for (int m2rid = mFixMC2ROF[iLayer]; m2rid < mMC2ROFRecordsAccum[iLayer].size(); m2rid++) {
+              // need to register the ROFRecors entry for MC event starting from this entry
+              auto& mc2rof = mMC2ROFRecordsAccum[iLayer][m2rid];
+              if (rof.getROFrame() == mc2rof.minROF) {
+                mFixMC2ROF[iLayer]++;
+                mc2rof.rofRecordID = nROFRecsOld + i;
+                mc2rof.print();
+              }
+            }
+          }
+        }
+
+        std::copy(mROFRecords[iLayer].begin(), mROFRecords[iLayer].end(), std::back_inserter(mROFRecordsAccum[iLayer]));
+        if (mWithMCTruth) {
+          mLabelsAccum[iLayer].mergeAtBack(mLabels[iLayer]);
+        }
+        LOG(info) << "Added " << mDigits[iLayer].size() << " digits:" << iLayer;
+        // clean containers from already accumulated stuff
+        mLabels[iLayer].clear();
+        mDigits[iLayer].clear();
+        mROFRecords[iLayer].clear();
+      }; // and accumulate lambda
+
+      const auto& eventParts = context->getEventParts(withQED);
+      const int64_t bcShift = mDigitizer.getParams().getROFrameBiasInBC(layer); // this accounts the misalignment and the opt. imposed rof delay
+      // loop over all composite collisions given from context (aka loop over all the interaction records)
+      for (int collID = 0; collID < timesview.size(); ++collID) {
+        auto irt = timesview[collID];
+        if (irt.toLong() < bcShift) { // due to the ROF misalignment (+opt. delay) the collision would go to negative ROF ID, discard
+          continue;
+        }
+        irt -= bcShift; // account for the ROF start shift
+
+        mDigitizer.setEventTime(irt, layer);
+        mDigitizer.resetEventROFrames(); // to estimate min/max ROF for this collID
+        // for each collision, loop over the constituents event and source IDs
+        // (background signal merging is basically taking place here)
+        for (const auto& part : eventParts[collID]) {
 
-    // digits are directly put into DPL owned resource
-    auto& digitsAccum = pc.outputs().make<std::vector<itsmft::Digit>>(Output{mOrigin, "DIGITS", 0});
+          // get the hits for this event and this source
+          mHits.clear();
+          context->retrieveHits(mSimChains, o2::detectors::SimTraits::DETECTORBRANCHNAMES[ID][0].c_str(), part.sourceID, part.entryID, &mHits);
 
-    auto accumulate = [this, &digitsAccum]() {
-      // accumulate result of single event processing, called after processing every event supplied
-      // AND after the final flushing via digitizer::fillOutputContainer
-      if (!mDigits.size()) {
-        return; // no digits were flushed, nothing to accumulate
+          if (mHits.size() > 0) {
+            LOG(debug) << "For collision " << collID << " eventID " << part.entryID << " found " << mHits.size() << " hits ";
+            mDigitizer.process(&mHits, part.entryID, part.sourceID, layer); // call actual digitization procedure
+          }
+        }
+        mMC2ROFRecordsAccum[iLayer].emplace_back(collID, -1, mDigitizer.getEventROFrameMin(), mDigitizer.getEventROFrameMax());
+        accumulate();
       }
-      auto ndigAcc = digitsAccum.size();
-      std::copy(mDigits.begin(), mDigits.end(), std::back_inserter(digitsAccum));
-
-      // fix ROFrecords references on ROF entries
-      auto nROFRecsOld = mROFRecordsAccum.size();
-
-      for (int i = 0; i < mROFRecords.size(); i++) {
-        auto& rof = mROFRecords[i];
-        rof.setFirstEntry(ndigAcc + rof.getFirstEntry());
-        rof.print();
-
-        if (mFixMC2ROF < mMC2ROFRecordsAccum.size()) { // fix ROFRecord entry in MC2ROF records
-          for (int m2rid = mFixMC2ROF; m2rid < mMC2ROFRecordsAccum.size(); m2rid++) {
-            // need to register the ROFRecors entry for MC event starting from this entry
-            auto& mc2rof = mMC2ROFRecordsAccum[m2rid];
-            if (rof.getROFrame() == mc2rof.minROF) {
-              mFixMC2ROF++;
-              mc2rof.rofRecordID = nROFRecsOld + i;
-              mc2rof.print();
-            }
+      mDigitizer.fillOutputContainer(0xffffffff, layer);
+      accumulate();
+      nDigits += digitsAccum.size();
+
+      // here we have all digits and labels and we can send them to consumer (aka snapshot it onto output)
+      // ensure that the rof output is continuous
+      if (nROFsTF != mROFRecordsAccum[iLayer].size()) {
+        // it can happen that in the digitization rofs without contributing hits are skipped
+        // however downstream consumers of the clusters cannot know apriori the time structure
+        // the cluster rofs do not account for the bias so it will start always at BC=0
+        std::vector<o2::itsmft::ROFRecord> expDigitRofVec(nROFsTF);
+        for (int iROF{0}; iROF < nROFsTF; ++iROF) {
+          auto& rof = expDigitRofVec[iROF];
+          int orb = iROF * DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer) / o2::constants::lhc::LHCMaxBunches + mFirstOrbitTF;
+          int bc = iROF * DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches;
+          o2::InteractionRecord ir(bc, orb);
+          rof.setBCData(ir);
+          rof.setROFrame(iROF);
+          rof.setNEntries(0);
+          rof.setFirstEntry(-1);
+        }
+        uint32_t prevEntry{0};
+        for (const auto& rof : mROFRecordsAccum[iLayer]) {
+          const auto& ir = rof.getBCData();
+          const auto irToFirst = ir - firstIR;
+          const int irROF = irToFirst.toLong() / DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer);
+          auto& expROF = expDigitRofVec[irROF];
+          expROF.setFirstEntry(rof.getFirstEntry());
+          expROF.setNEntries(rof.getNEntries());
+          if (expROF.getBCData() != rof.getBCData()) {
+            LOGP(fatal, "detected mismatch between expected ROF:{} and received ROF:{}", expROF.asString(), rof.asString());
+          }
+        }
+        int prevFirst{0};
+        for (auto& rof : expDigitRofVec) {
+          if (rof.getFirstEntry() < 0) {
+            rof.setFirstEntry(prevFirst);
           }
+          prevFirst = rof.getFirstEntry();
         }
+        pc.outputs().snapshot(Output{Origin, "DIGITSROF", iLayer}, expDigitRofVec);
+      } else {
+        pc.outputs().snapshot(Output{Origin, "DIGITSROF", iLayer}, mROFRecordsAccum[iLayer]);
       }
-
-      std::copy(mROFRecords.begin(), mROFRecords.end(), std::back_inserter(mROFRecordsAccum));
       if (mWithMCTruth) {
-        mLabelsAccum.mergeAtBack(mLabels);
-      }
-      LOG(info) << "Added " << mDigits.size() << " digits ";
-      // clean containers from already accumulated stuff
-      mLabels.clear();
-      mDigits.clear();
-      mROFRecords.clear();
-    }; // and accumulate lambda
-
-    auto& eventParts = context->getEventParts(withQED);
-    int bcShift = mDigitizer.getParams().getROFrameBiasInBC();
-    // loop over all composite collisions given from context (aka loop over all the interaction records)
-    for (int collID = 0; collID < timesview.size(); ++collID) {
-      auto irt = timesview[collID];
-      if (irt.toLong() < bcShift) { // due to the ROF misalignment the collision would go to negative ROF ID, discard
-        continue;
+        pc.outputs().snapshot(Output{Origin, "DIGITSMC2ROF", iLayer}, mMC2ROFRecordsAccum[iLayer]);
+        auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{Origin, "DIGITSMCTR", iLayer});
+        mLabelsAccum[iLayer].flatten_to(sharedlabels);
+        // free space of existing label containers
+        mLabels[iLayer].clear_andfreememory();
+        mLabelsAccum[iLayer].clear_andfreememory();
       }
-      irt -= bcShift; // account for the ROF start shift
-
-      mDigitizer.setEventTime(irt);
-      mDigitizer.resetEventROFrames(); // to estimate min/max ROF for this collID
-      // for each collision, loop over the constituents event and source IDs
-      // (background signal merging is basically taking place here)
-      for (auto& part : eventParts[collID]) {
-
-        // get the hits for this event and this source
-        mHits.clear();
-        context->retrieveHits(mSimChains, o2::detectors::SimTraits::DETECTORBRANCHNAMES[mID][0].c_str(), part.sourceID, part.entryID, &mHits);
-
-        if (mHits.size() > 0) {
-          LOG(debug) << "For collision " << collID << " eventID " << part.entryID
-                     << " found " << mHits.size() << " hits ";
-          mDigitizer.process(&mHits, part.entryID, part.sourceID); // call actual digitization procedure
-        }
-      }
-      mMC2ROFRecordsAccum.emplace_back(collID, -1, mDigitizer.getEventROFrameMin(), mDigitizer.getEventROFrameMax());
-      accumulate();
     }
-    mDigitizer.fillOutputContainer();
-    accumulate();
-
-    // here we have all digits and labels and we can send them to consumer (aka snapshot it onto output)
-
-    pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, mROFRecordsAccum);
-    if (mWithMCTruth) {
-      pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, mMC2ROFRecordsAccum);
-      auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", 0});
-      mLabelsAccum.flatten_to(sharedlabels);
-      // free space of existing label containers
-      mLabels.clear_andfreememory();
-      mLabelsAccum.clear_andfreememory();
-    }
-    LOG(info) << mID.getName() << ": Sending ROMode= " << mROMode << " to GRPUpdater";
-    pc.outputs().snapshot(Output{mOrigin, "ROMode", 0}, mROMode);
+
+    LOG(info) << ID.getName() << ": Sending ROMode= " << mROMode << " to GRPUpdater";
+    pc.outputs().snapshot(Output{Origin, "ROMode", 0}, mROMode);
 
     timer.Stop();
     LOG(info) << "Digitization took " << timer.CpuTime() << "s";
+    LOG(info) << "Produced " << nDigits << " digits";
 
     // we should be only called once; tell DPL that this process is ready to exit
     pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
@@ -184,18 +243,18 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
 
   void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   {
-    if (matcher == ConcreteDataMatcher(mOrigin, "NOISEMAP", 0)) {
-      LOG(info) << mID.getName() << " noise map updated";
+    if (matcher == ConcreteDataMatcher(Origin, "NOISEMAP", 0)) {
+      LOG(info) << ID.getName() << " noise map updated";
       mDigitizer.setNoiseMap((const o2::itsmft::NoiseMap*)obj);
       return;
     }
-    if (matcher == ConcreteDataMatcher(mOrigin, "DEADMAP", 0)) {
-      LOG(info) << mID.getName() << " static dead map updated";
+    if (matcher == ConcreteDataMatcher(Origin, "DEADMAP", 0)) {
+      LOG(info) << ID.getName() << " static dead map updated";
       mDeadMap = (o2::itsmft::NoiseMap*)obj;
       mDigitizer.setDeadChannelsMap(mDeadMap);
       return;
     }
-    if (matcher == ConcreteDataMatcher(mOrigin, "TimeDeadMap", 0)) {
+    if (matcher == ConcreteDataMatcher(Origin, "TimeDeadMap", 0)) {
       o2::itsmft::TimeDeadMap* timedeadmap = (o2::itsmft::TimeDeadMap*)obj;
       if (!timedeadmap->isDefault()) {
         timedeadmap->decodeMap(mFirstOrbitTF, *mDeadMap, true);
@@ -204,30 +263,25 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
         }
         mTimeDeadMapUpdated = true;
         mDigitizer.setDeadChannelsMap(mDeadMap);
-        LOG(info) << mID.getName() << " time-dependent dead map updated";
+        LOG(info) << ID.getName() << " time-dependent dead map updated";
       } else {
-        LOG(info) << mID.getName() << " time-dependent dead map is default/empty";
+        LOG(info) << ID.getName() << " time-dependent dead map is default/empty";
       }
 
       return;
     }
-    if (matcher == ConcreteDataMatcher(mOrigin, "ALPIDEPARAM", 0)) {
-      LOG(info) << mID.getName() << " Alpide param updated";
-      if (mID == o2::detectors::DetID::ITS) {
-        const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-        par.printKeyValues();
-      } else {
-        const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>::Instance();
-        par.printKeyValues();
-      }
+    if (matcher == ConcreteDataMatcher(Origin, "ALPIDEPARAM", 0)) {
+      LOG(info) << ID.getName() << " Alpide param updated";
+      const auto& par = o2::itsmft::DPLAlpideParam<N>::Instance();
+      par.printKeyValues();
       return;
     }
-    if (matcher == ConcreteDataMatcher(mOrigin, "ALPIDERESPVbb0", 0)) {
-      LOG(info) << mID.getName() << " loaded AlpideResponseData for Vbb=0V";
+    if (matcher == ConcreteDataMatcher(Origin, "ALPIDERESPVbb0", 0)) {
+      LOG(info) << ID.getName() << " loaded AlpideResponseData for Vbb=0V";
       mDigitizer.setAlpideResponse((o2::itsmft::AlpideSimResponse*)obj, 0);
     }
-    if (matcher == ConcreteDataMatcher(mOrigin, "ALPIDERESPVbbM3", 0)) {
-      LOG(info) << mID.getName() << " loaded AlpideResponseData for Vbb=-3V";
+    if (matcher == ConcreteDataMatcher(Origin, "ALPIDERESPVbbM3", 0)) {
+      LOG(info) << ID.getName() << " loaded AlpideResponseData for Vbb=-3V";
       mDigitizer.setAlpideResponse((o2::itsmft::AlpideSimResponse*)obj, 1);
     }
   }
@@ -235,20 +289,19 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
  protected:
   ITSMFTDPLDigitizerTask(bool mctruth = true) : BaseDPLDigitizer(InitServices::FIELD | InitServices::GEOM), mWithMCTruth(mctruth) {}
 
-  template <int DETID>
   void updateTimeDependentParams(ProcessingContext& pc)
   {
-    std::string detstr(o2::detectors::DetID::getName(DETID));
+    std::string detstr(o2::detectors::DetID::getName(ID));
     pc.inputs().get<o2::itsmft::NoiseMap*>(detstr + "_noise");
     pc.inputs().get<o2::itsmft::NoiseMap*>(detstr + "_dead");
     // TODO: the code should run even if this object does not exist. Or: create default object
     pc.inputs().get<o2::itsmft::TimeDeadMap*>(detstr + "_time_dead");
-    pc.inputs().get<o2::itsmft::DPLAlpideParam<DETID>*>(detstr + "_alppar");
+    pc.inputs().get<o2::itsmft::DPLAlpideParam<N>*>(detstr + "_alppar");
     pc.inputs().get<o2::itsmft::AlpideSimResponse*>(detstr + "_alpiderespvbb0");
     pc.inputs().get<o2::itsmft::AlpideSimResponse*>(detstr + "_alpiderespvbbm3");
 
-    auto& dopt = o2::itsmft::DPLDigitizerParam<DETID>::Instance();
-    auto& aopt = o2::itsmft::DPLAlpideParam<DETID>::Instance();
+    auto& dopt = o2::itsmft::DPLDigitizerParam<N>::Instance();
+    auto& aopt = o2::itsmft::DPLAlpideParam<N>::Instance();
     auto& digipar = mDigitizer.getParams();
     digipar.setContinuous(dopt.continuous);
     digipar.setROFrameBiasInBC(aopt.roFrameBiasInBC);
@@ -272,15 +325,29 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
     digipar.setIBVbb(dopt.IBVbb);
     digipar.setOBVbb(dopt.OBVbb);
     digipar.setVbb(dopt.Vbb);
+    // staggering parameters
+    if constexpr (o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) {
+      const bool withStag = aopt.withStaggering();
+      for (int iLayer{0}; iLayer < o2::itsmft::DPLAlpideParam<N>::getNLayers(); ++iLayer) {
+        const int nLayer = (withStag) ? iLayer : -1;
+        auto frameNS = aopt.getROFLengthInBC(nLayer) * o2::constants::lhc::LHCBunchSpacingNS;
+        digipar.addROFrameLayerLengthInBC(aopt.getROFLengthInBC(nLayer));
+        // NOTE: the rof delay looks from the digitizer like an additional bias
+        digipar.addROFrameLayerBiasInBC(aopt.getROFBiasInBC(nLayer) + aopt.getROFDelayInBC(nLayer));
+        digipar.addStrobeDelay(aopt.strobeDelay);
+        digipar.addStrobeLength(aopt.strobeLengthCont > 0 ? aopt.strobeLengthCont : frameNS - aopt.strobeDelay);
+        digipar.setROFrameLength(aopt.getROFLengthInBC(nLayer) * o2::constants::lhc::LHCBunchSpacingNS, iLayer);
+      }
+    }
 
     mROMode = digipar.isContinuous() ? o2::parameters::GRPObject::CONTINUOUS : o2::parameters::GRPObject::PRESENT;
-    LOG(info) << mID.getName() << " simulated in "
+    LOG(info) << detstr << " simulated in "
               << ((mROMode == o2::parameters::GRPObject::CONTINUOUS) ? "CONTINUOUS" : "TRIGGERED")
               << " RO mode";
 
     // configure digitizer
     o2::itsmft::GeometryTGeo* geom = nullptr;
-    if (mID == o2::detectors::DetID::ITS) {
+    if constexpr (N == o2::detectors::DetID::ITS) {
       geom = o2::its::GeometryTGeo::Instance();
     } else {
       geom = o2::mft::GeometryTGeo::Instance();
@@ -294,81 +361,61 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
   bool mFinished = false;
   bool mDisableQED = false;
   unsigned long mFirstOrbitTF = 0x0;
-  o2::detectors::DetID mID;
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginInvalid;
   o2::itsmft::Digitizer mDigitizer;
-  std::vector<o2::itsmft::Digit> mDigits;
-  std::vector<o2::itsmft::ROFRecord> mROFRecords;
-  std::vector<o2::itsmft::ROFRecord> mROFRecordsAccum;
+  std::array<std::vector<o2::itsmft::Digit>, NLayers> mDigits;
+  std::array<std::vector<o2::itsmft::ROFRecord>, NLayers> mROFRecords;
+  std::array<std::vector<o2::itsmft::ROFRecord>, NLayers> mROFRecordsAccum;
   std::vector<o2::itsmft::Hit> mHits;
   std::vector<o2::itsmft::Hit>* mHitsP = &mHits;
-  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabels;
-  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabelsAccum;
-  std::vector<o2::itsmft::MC2ROFRecord> mMC2ROFRecordsAccum;
+  std::array<o2::dataformats::MCTruthContainer<o2::MCCompLabel>, NLayers> mLabels;
+  std::array<o2::dataformats::MCTruthContainer<o2::MCCompLabel>, NLayers> mLabelsAccum;
+  std::array<std::vector<o2::itsmft::MC2ROFRecord>, NLayers> mMC2ROFRecordsAccum;
   std::vector<TChain*> mSimChains;
   o2::itsmft::NoiseMap* mDeadMap = nullptr;
 
-  int mFixMC2ROF = 0;                                                             // 1st entry in mc2rofRecordsAccum to be fixed for ROFRecordID
+  std::array<int, NLayers> mFixMC2ROF{}; // 1st entry in mc2rofRecordsAccum to be fixed for ROFRecordID
   bool mTimeDeadMapUpdated = false;
   o2::parameters::GRPObject::ROMode mROMode = o2::parameters::GRPObject::PRESENT; // readout mode
 };
 
 //_______________________________________________
-class ITSDPLDigitizerTask : public ITSMFTDPLDigitizerTask
+class ITSDPLDigitizerTask : public ITSMFTDPLDigitizerTask<o2::detectors::DetID::ITS>
 {
  public:
-  // FIXME: origin should be extractable from the DetID, the problem is 3d party header dependencies
-  static constexpr o2::detectors::DetID::ID DETID = o2::detectors::DetID::ITS;
-  static constexpr o2::header::DataOrigin DETOR = o2::header::gDataOriginITS;
-  ITSDPLDigitizerTask(bool mctruth = true) : ITSMFTDPLDigitizerTask(mctruth)
-  {
-    mID = DETID;
-    mOrigin = DETOR;
-  }
+  ITSDPLDigitizerTask(bool mctruth = true) : ITSMFTDPLDigitizerTask<o2::detectors::DetID::ITS>(mctruth) {}
 };
 
-constexpr o2::detectors::DetID::ID ITSDPLDigitizerTask::DETID;
-constexpr o2::header::DataOrigin ITSDPLDigitizerTask::DETOR;
-
 //_______________________________________________
-class MFTDPLDigitizerTask : public ITSMFTDPLDigitizerTask
+class MFTDPLDigitizerTask : public ITSMFTDPLDigitizerTask<o2::detectors::DetID::MFT>
 {
  public:
-  // FIXME: origina should be extractable from the DetID, the problem is 3d party header dependencies
-  static constexpr o2::detectors::DetID::ID DETID = o2::detectors::DetID::MFT;
-  static constexpr o2::header::DataOrigin DETOR = o2::header::gDataOriginMFT;
-  MFTDPLDigitizerTask(bool mctruth) : ITSMFTDPLDigitizerTask(mctruth)
-  {
-    mID = DETID;
-    mOrigin = DETOR;
-  }
+  MFTDPLDigitizerTask(bool mctruth = true) : ITSMFTDPLDigitizerTask<o2::detectors::DetID::MFT>(mctruth) {}
 };
 
-constexpr o2::detectors::DetID::ID MFTDPLDigitizerTask::DETID;
-constexpr o2::header::DataOrigin MFTDPLDigitizerTask::DETOR;
-
+namespace
+{
+template <int N>
 std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mctruth)
 {
   std::vector<OutputSpec> outputs;
-  outputs.emplace_back(detOrig, "DIGITS", 0, Lifetime::Timeframe);
-  outputs.emplace_back(detOrig, "DIGITSROF", 0, Lifetime::Timeframe);
-  if (mctruth) {
-    outputs.emplace_back(detOrig, "DIGITSMC2ROF", 0, Lifetime::Timeframe);
-    outputs.emplace_back(detOrig, "DIGITSMCTR", 0, Lifetime::Timeframe);
+  constexpr uint32_t nLayers = (DPLAlpideParam<N>::supportsStaggering()) ? DPLAlpideParam<N>::getNLayers() : 1;
+  for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
+    outputs.emplace_back(detOrig, "DIGITS", iLayer, Lifetime::Timeframe);
+    outputs.emplace_back(detOrig, "DIGITSROF", iLayer, Lifetime::Timeframe);
+    if (mctruth) {
+      outputs.emplace_back(detOrig, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(detOrig, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
+    }
   }
   outputs.emplace_back(detOrig, "ROMode", 0, Lifetime::Timeframe);
   return outputs;
 }
+} // namespace
 
 DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth)
 {
-  std::string detStr = o2::detectors::DetID::getName(ITSDPLDigitizerTask::DETID);
-  auto detOrig = ITSDPLDigitizerTask::DETOR;
-  std::stringstream parHelper;
-  parHelper << "Params as " << o2::itsmft::DPLDigitizerParam<ITSDPLDigitizerTask::DETID>::getParamName().data() << ".<param>=value;... with"
-            << o2::itsmft::DPLDigitizerParam<ITSDPLDigitizerTask::DETID>::Instance()
-            << "\n or " << o2::itsmft::DPLAlpideParam<ITSDPLDigitizerTask::DETID>::getParamName().data() << ".<param>=value;... with"
-            << o2::itsmft::DPLAlpideParam<ITSDPLDigitizerTask::DETID>::Instance();
+  std::string detStr = o2::detectors::DetID::getName(ITSDPLDigitizerTask::ID);
+  auto detOrig = ITSDPLDigitizerTask::Origin;
   std::vector<InputSpec> inputs;
   inputs.emplace_back("collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe);
   inputs.emplace_back("ITS_noise", "ITS", "NOISEMAP", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/NoiseMap"));
@@ -377,19 +424,18 @@ DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth)
   inputs.emplace_back("ITS_alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
   inputs.emplace_back("ITS_alpiderespvbb0", "ITS", "ALPIDERESPVbb0", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbb0"));
   inputs.emplace_back("ITS_alpiderespvbbm3", "ITS", "ALPIDERESPVbbM3", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbbM3"));
-
-  return DataProcessorSpec{(detStr + "Digitizer").c_str(),
-                           inputs, makeOutChannels(detOrig, mctruth),
-                           AlgorithmSpec{adaptFromTask<ITSDPLDigitizerTask>(mctruth)},
-                           Options{
+  return DataProcessorSpec{.name = detStr + "Digitizer",
+                           .inputs = inputs,
+                           .outputs = makeOutChannels<o2::detectors::DetID::ITS>(detOrig, mctruth),
+                           .algorithm = AlgorithmSpec{adaptFromTask<ITSDPLDigitizerTask>(mctruth)},
+                           .options = Options{
                              {"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
 }
 
 DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth)
 {
-  std::string detStr = o2::detectors::DetID::getName(MFTDPLDigitizerTask::DETID);
-  auto detOrig = MFTDPLDigitizerTask::DETOR;
-  std::stringstream parHelper;
+  std::string detStr = o2::detectors::DetID::getName(MFTDPLDigitizerTask::ID);
+  auto detOrig = MFTDPLDigitizerTask::Origin;
   std::vector<InputSpec> inputs;
   inputs.emplace_back("collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe);
   inputs.emplace_back("MFT_noise", "MFT", "NOISEMAP", 0, Lifetime::Condition, ccdbParamSpec("MFT/Calib/NoiseMap"));
@@ -398,15 +444,12 @@ DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth)
   inputs.emplace_back("MFT_alppar", "MFT", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("MFT/Config/AlpideParam"));
   inputs.emplace_back("MFT_alpiderespvbb0", "MFT", "ALPIDERESPVbb0", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbb0"));
   inputs.emplace_back("MFT_alpiderespvbbm3", "MFT", "ALPIDERESPVbbM3", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbbM3"));
-  parHelper << "Params as " << o2::itsmft::DPLDigitizerParam<ITSDPLDigitizerTask::DETID>::getParamName().data() << ".<param>=value;... with"
-            << o2::itsmft::DPLDigitizerParam<ITSDPLDigitizerTask::DETID>::Instance()
-            << " or " << o2::itsmft::DPLAlpideParam<ITSDPLDigitizerTask::DETID>::getParamName().data() << ".<param>=value;... with"
-            << o2::itsmft::DPLAlpideParam<ITSDPLDigitizerTask::DETID>::Instance();
-  return DataProcessorSpec{(detStr + "Digitizer").c_str(),
-                           inputs, makeOutChannels(detOrig, mctruth),
-                           AlgorithmSpec{adaptFromTask<MFTDPLDigitizerTask>(mctruth)},
-                           Options{{"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
+  return DataProcessorSpec{.name = detStr + "Digitizer",
+                           .inputs = inputs,
+                           .outputs = makeOutChannels<o2::detectors::DetID::MFT>(detOrig, mctruth),
+                           .algorithm = AlgorithmSpec{adaptFromTask<MFTDPLDigitizerTask>(mctruth)},
+                           .options = Options{{"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
 }
 
-} // end namespace itsmft
-} // end namespace o2
+} // namespace o2::itsmft
+  // end namespace o2

From b18b96ab60f829b2cb853b6a4553a47167948165 Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Sun, 25 Jan 2026 10:38:46 +0100
Subject: [PATCH 1233/1764] Ctpdev: task for populating BK with ctp
 config/scalers (#14993)

* dev: code for repopulating BK with old configs/scalers

* clang

* fixes

* fixes

* clang

* fix
---
 Detectors/CTP/workflowScalers/CMakeLists.txt  |   8 +
 .../CTPWorkflowScalers/ctpCCDBManager.h       |   5 +-
 .../CTP/workflowScalers/src/ctp-bk-write.cxx  | 170 ++++++++++++++++++
 .../workflowScalers/src/ctpCCDBManager.cxx    |  27 +++
 4 files changed, 208 insertions(+), 2 deletions(-)
 create mode 100644 Detectors/CTP/workflowScalers/src/ctp-bk-write.cxx

diff --git a/Detectors/CTP/workflowScalers/CMakeLists.txt b/Detectors/CTP/workflowScalers/CMakeLists.txt
index a31774ac66d69..f02a7f33e2abd 100644
--- a/Detectors/CTP/workflowScalers/CMakeLists.txt
+++ b/Detectors/CTP/workflowScalers/CMakeLists.txt
@@ -34,3 +34,11 @@ o2_add_executable(
                   SOURCES src/ctp-ccdb-orbit.cxx
                   PUBLIC_LINK_LIBRARIES O2::DataFormatsCTP
                   Boost::program_options)
+o2_add_executable(
+                  bk-write
+                  COMPONENT_NAME ctp
+                  SOURCES src/ctp-bk-write.cxx
+                  PUBLIC_LINK_LIBRARIES O2::DataFormatsCTP
+                  O2::CTPWorkflowScalers
+                  AliceO2::BookkeepingApi
+                  Boost::program_options)
diff --git a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
index 4237ad4501fcc..df2aa79d18697 100644
--- a/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
+++ b/Detectors/CTP/workflowScalers/include/CTPWorkflowScalers/ctpCCDBManager.h
@@ -31,8 +31,9 @@ class ctpCCDBManager
   int saveOrbitReset(long timeStamp);
   int saveCtpCfg(uint32_t runNumber, long timeStamp);
   static CTPConfiguration getConfigFromCCDB(long timestamp, std::string run, bool& ok);
-  static CTPConfiguration getConfigFromCCDB(long timestamp, std::string run);
-  CTPRunScalers getScalersFromCCDB(long timestamp, std::string, bool& ok);
+  CTPConfiguration getConfigFromCCDB(long timestamp, std::string run);
+  CTPRunScalers getScalersFromCCDB(long timestamp, std::string run, bool& ok);
+  static CTPRunScalers getScalersFromCCDB(long timestamp, std::string, std::string path, bool& ok);
   static void setCCDBHost(std::string host) { mCCDBHost = host; };
   static void setQCDBHost(std::string host) { mQCDBHost = host; };
   void setCtpCfgDir(std::string& ctpcfgdir) { mCtpCfgDir = ctpcfgdir; };
diff --git a/Detectors/CTP/workflowScalers/src/ctp-bk-write.cxx b/Detectors/CTP/workflowScalers/src/ctp-bk-write.cxx
new file mode 100644
index 0000000000000..8460c07dcc896
--- /dev/null
+++ b/Detectors/CTP/workflowScalers/src/ctp-bk-write.cxx
@@ -0,0 +1,170 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// example to run:
+//
+#include <boost/program_options.hpp>
+#include <filesystem>
+#include <TFile.h>
+#include <TStopwatch.h>
+#include "CommonUtils/StringUtils.h"
+#include <CCDB/BasicCCDBManager.h>
+#include "CTPWorkflowScalers/ctpCCDBManager.h"
+#include "BookkeepingApi/BkpClientFactory.h"
+#include "BookkeepingApi/BkpClient.h"
+#include <iostream>
+#include <fstream>
+#include <vector>
+#include <string>
+namespace bpo = boost::program_options;
+//
+// Test in the lab
+// o2-ctp-bk-write -r 37 -s 1 -c 1 --ccdb='http://acsl-ccdb.cern.ch:8083' -b 'acsl-aliecs.cern.ch:4001' -t 1753185071753
+//
+int main(int argc, char** argv)
+{
+  const std::string testCCDB = "http://ccdb-test.cern.ch:8080";
+  // std::string prodCCDB = "http://o2-ccdb.internal";
+  const std::string aliceCCDB = "http://alice-ccdb.cern.ch";
+  bpo::variables_map vm;
+  bpo::options_description opt_general("Usage:\n  " + std::string(argv[0]) +
+                                       " Write ctp config or scalers to BK\n");
+  bpo::options_description opt_hidden("");
+  bpo::options_description opt_all;
+  bpo::positional_options_description opt_pos;
+  try {
+    auto add_option = opt_general.add_options();
+    add_option("help,h", "Print this help message");
+    add_option("input-file,f", bpo::value<std::string>()->default_value("none"), "input file name, none - do not read file");
+    add_option("bkhost,b", bpo::value<std::string>()->default_value("none"), "bk web address");
+    add_option("ccdb", bpo::value<std::string>()->default_value("alice"), "choose databse: test- test ccdb; prod - production ccdb; alice - alice ccdb; else ccdb parameter");
+    add_option("run-number,r", bpo::value<uint32_t>()->default_value(0), "run number");
+    add_option("timestamp,t", bpo::value<uint64_t>()->default_value(0), "timestamp; if 0 timestamp is calulated inside this code");
+    add_option("cfg,c", bpo::value<bool>()->default_value(0), "Do cfg");
+    add_option("scalers,s", bpo::value<bool>()->default_value(0), "Do scalers");
+    //
+    opt_all.add(opt_general).add(opt_hidden);
+    bpo::store(bpo::command_line_parser(argc, argv).options(opt_all).positional(opt_pos).run(), vm);
+    if (vm.count("help")) {
+      std::cout << opt_general << std::endl;
+      exit(0);
+    }
+    bpo::notify(vm);
+  } catch (bpo::error& e) {
+    std::cerr << "ERROR: " << e.what() << std::endl
+              << std::endl;
+    std::cerr << opt_general << std::endl;
+    exit(1);
+  } catch (std::exception& e) {
+    std::cerr << e.what() << ", application will now exit" << std::endl;
+    exit(2);
+  }
+  uint64_t timestamp = vm["timestamp"].as<uint64_t>();
+  //
+  int ret = 0;
+  std::vector<std::string> runs;
+  int32_t run = vm["run-number"].as<uint32_t>();
+  std::cout << "run:" << run << std::endl;
+  if (run) {
+    std::cout << "pushing" << std::endl;
+    runs.push_back(std::to_string(run));
+  }
+  // read input file
+  std::string filename = vm["input-file"].as<std::string>();
+  if (filename != "none") {
+    std::ifstream file(filename);
+    if (!file.is_open()) {
+      LOG(fatal) << "Cannot open file:" << filename << std::endl;
+    } else {
+      std::string line;
+      while (std::getline(file, line)) {
+        std::cout << line << "\n";
+        std::vector<std::string> tokens = o2::utils::Str::tokenize(line, ' ');
+        // int run = std::stoi(tokens[0]);
+        runs.push_back(tokens[0]);
+      }
+    }
+  }
+  bool cfg = vm["cfg"].as<bool>();
+  bool scalers = vm["scalers"].as<bool>();
+  std::cout << "Doing: cfg:" << cfg << " scal:" << scalers << std::endl;
+  if (cfg || scalers) {
+    std::string bkhost = vm["bkhost"].as<std::string>();
+    std::unique_ptr<o2::bkp::api::BkpClient> mBKClient = o2::bkp::api::BkpClientFactory::create(bkhost);
+    // get from ccdb
+    std::string ccdbAddress;
+    if (vm["ccdb"].as<std::string>() == "prod") {
+      // ccdbAddress = prodCCDB;
+    } else if (vm["ccdb"].as<std::string>() == "test") {
+      ccdbAddress = testCCDB;
+    } else if (vm["ccdb"].as<std::string>() == "alice") {
+      ccdbAddress = aliceCCDB;
+    } else {
+      ccdbAddress = vm["ccdb"].as<std::string>();
+    }
+    o2::ctp::ctpCCDBManager::setCCDBHost(ccdbAddress);
+    std::cout << "CCDB: " << vm["ccdb"].as<std::string>() << " " << ccdbAddress << std::endl;
+    std::map<std::string, std::string> metadata;
+    for (auto const& run : runs) {
+      metadata["runNumber"] = run;
+      bool ok;
+      int runNumber = std::stoi(run);
+      auto ctpcfg = o2::ctp::ctpCCDBManager::getConfigFromCCDB(timestamp, run, ok);
+
+      if (cfg) {
+        std::string ctpcfgstr = ctpcfg.getConfigString();
+        try {
+          mBKClient->run()->setRawCtpTriggerConfiguration(runNumber, ctpcfgstr);
+        } catch (std::runtime_error& error) {
+          std::cerr << "An error occurred: " << error.what() << std::endl;
+          // return 1;
+        }
+        LOG(info) << "Run BK:" << run << " CFG:" << cfg;
+      }
+      if (scalers) {
+        auto ctpcnts = o2::ctp::ctpCCDBManager::getScalersFromCCDB(timestamp, run, "CTP/Calib/Scalers", ok);
+        ctpcnts.convertRawToO2();
+        std::vector<uint32_t> clsinds = ctpcnts.getClassIndexes();
+        long ts = ctpcnts.getTimeLimit().second;
+        int i = 0;
+        for (auto const& ind : clsinds) {
+          std::array<uint64_t, 7> cntsbk = ctpcnts.getIntegralForClass(i);
+          std::string clsname = ctpcfg.getClassNameFromHWIndex(cntsbk[0]);
+          try {
+            mBKClient->ctpTriggerCounters()->createOrUpdateForRun(runNumber, clsname, ts, cntsbk[1], cntsbk[2], cntsbk[3], cntsbk[4], cntsbk[5], cntsbk[6]);
+            std::cout << runNumber << " clsname: " << cntsbk[0] << " " << clsname << " t:" << ts << " cnts:" << cntsbk[1] << " " << cntsbk[2] << " " << cntsbk[3] << " " << cntsbk[4] << " " << cntsbk[5] << " " << cntsbk[6] << std::endl;
+            ;
+
+          } catch (std::runtime_error& error) {
+            std::cerr << "An error occurred: " << error.what() << std::endl;
+            // return 1;
+          }
+          LOG(debug) << "Run BK scalers ok";
+          i++;
+        }
+      }
+    }
+    // add to bk
+  }
+  std::cout << "o2-ctp-bk-write done" << std::endl;
+  return ret;
+}
diff --git a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
index df75b21c2effd..74d4a905c93e2 100644
--- a/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
+++ b/Detectors/CTP/workflowScalers/src/ctpCCDBManager.cxx
@@ -204,10 +204,16 @@ int ctpCCDBManager::saveCtpCfg(uint32_t runNumber, long timeStart)
 }
 CTPConfiguration ctpCCDBManager::getConfigFromCCDB(long timestamp, std::string run, bool& ok)
 {
+
   auto& mgr = o2::ccdb::BasicCCDBManager::instance();
   mgr.setURL(mCCDBHost);
   std::map<std::string, std::string> metadata; // can be empty
   metadata["runNumber"] = run;
+  if (timestamp == 0) {
+    // Timestamp
+    auto soreor = mgr.getRunDuration(std::stoi(run));
+    timestamp = (soreor.second - soreor.first) / 2 + soreor.first;
+  }
   auto ctpconfigdb = mgr.getSpecific<CTPConfiguration>(CCDBPathCTPConfig, timestamp, metadata);
   if (ctpconfigdb == nullptr) {
     LOG(info) << "CTP config not in database, timestamp:" << timestamp;
@@ -245,3 +251,24 @@ CTPRunScalers ctpCCDBManager::getScalersFromCCDB(long timestamp, std::string run
   }
   return *ctpscalers;
 }
+CTPRunScalers ctpCCDBManager::getScalersFromCCDB(long timestamp, std::string run, std::string path, bool& ok)
+{
+  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
+  mgr.setURL(mCCDBHost);
+  std::map<std::string, std::string> metadata; // can be empty
+  metadata["runNumber"] = run;
+  if (timestamp == 0) {
+    // Timestamp
+    auto soreor = mgr.getRunDuration(std::stoi(run));
+    timestamp = (soreor.second - soreor.first) / 2 + soreor.first;
+  }
+  auto ctpscalers = mgr.getSpecific<CTPRunScalers>(path, timestamp, metadata);
+  if (ctpscalers == nullptr) {
+    LOG(info) << "CTPRunScalers not in database, timestamp:" << timestamp;
+    ok = 0;
+  } else {
+    // ctpscalers->printStream(std::cout);
+    ok = 1;
+  }
+  return *ctpscalers;
+}
\ No newline at end of file

From b33261326dc4203ba6e537df64e04b4bdb3716d5 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 23 Jan 2026 14:55:22 +0100
Subject: [PATCH 1234/1764] Implement AO2D file checks for full_system_test

Performed during ASYNC stage, where the AO2D is created
---
 prodtests/full_system_test.sh | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index bf235a500cd8b..6408588d46e68 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -295,6 +295,25 @@ for STAGE in $STAGES; do
   # boolean flag indicating if workflow completed successfully at all
   RC=$?
   SUCCESS=0
+   # Check AOD production for ASYNC stage
+  if [[ "$STAGE" = "ASYNC" ]]; then
+    if [[ -f "AO2D.root" ]]; then
+      aod_size=`stat -c%s AO2D.root`
+      if [[ $aod_size -gt 0 ]]; then
+        echo "AO2D file produced: AO2D.root (size: ${aod_size} bytes)"
+        echo "aod_size_${STAGE},${TAG} value=${aod_size}" >> ${METRICFILE}
+      else
+        echo "ERROR: AO2D file (AO2D.root) exists but is empty"
+        echo "aod_size_${STAGE},${TAG} value=0" >> ${METRICFILE}
+        exit 1
+      fi
+    else
+      echo "ERROR: AO2D file (AO2D.root) was not produced in ASYNC stage"
+      echo "aod_size_${STAGE},${TAG} value=0" >> ${METRICFILE}
+      exit 1
+    fi
+  fi
+
   [[ -f "${logfile}_done" ]] && [[ "$RC" = 0 ]] && SUCCESS=1
   echo "success_${STAGE},${TAG} value=${SUCCESS}" >> ${METRICFILE}
 

From 1fba29618f1f469fb918c725234f1d9f45dfc183 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 26 Jan 2026 10:23:20 +0100
Subject: [PATCH 1235/1764] DPL Analysis: modernize and cleanup some code
 (#14975)

---
 .../AnalysisSupport/src/AODReaderHelpers.cxx  | 55 ++++-------
 Framework/Core/include/Framework/ASoA.h       |  1 +
 .../Core/include/Framework/Expressions.h      |  2 +-
 Framework/Core/src/ASoA.cxx                   | 96 +++++++++----------
 Framework/Core/src/AnalysisHelpers.cxx        | 37 +++----
 Framework/Core/src/ArrowSupport.cxx           | 26 ++---
 Framework/Core/src/ArrowTableSlicingCache.cxx |  6 +-
 Framework/Core/src/Expressions.cxx            |  4 +-
 Framework/Core/src/WorkflowHelpers.cxx        | 74 +++++++-------
 9 files changed, 129 insertions(+), 172 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
index 485f3fa69edad..4c1c065000186 100644
--- a/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODReaderHelpers.cxx
@@ -37,7 +37,7 @@ struct Buildable {
   std::vector<o2::soa::IndexRecord> records;
   std::shared_ptr<arrow::Schema> outputSchema;
 
-  Buildable(InputSpec const& spec)
+  explicit Buildable(InputSpec const& spec)
     : binding{spec.binding}
   {
     auto&& [origin_, description_, version_] = DataSpecUtils::asConcreteDataMatcher(spec);
@@ -58,9 +58,8 @@ struct Buildable {
     }
     outputSchema = std::make_shared<arrow::Schema>([](std::vector<o2::soa::IndexRecord> const& recs) {
                      std::vector<std::shared_ptr<arrow::Field>> fields;
-                     for (auto& r : recs) {
-                       fields.push_back(r.field());
-                     }
+                     fields.reserve(recs.size());
+                     std::ranges::transform(recs, std::back_inserter(fields), [](auto& r) { return r.field(); });
                      return fields;
                    }(records))
                      ->WithMetadata(std::make_shared<arrow::KeyValueMetadata>(std::vector{std::string{"label"}}, std::vector{std::string{binding}}));
@@ -87,19 +86,12 @@ AlgorithmSpec AODReaderHelpers::indexBuilderCallback(ConfigContext const& /*ctx*
 {
   return AlgorithmSpec::InitCallback{[](InitContext& ic) {
     auto const& requested = ic.services().get<DanglingEdgesContext>().requestedIDXs;
-    std::vector<Buildable> buildables;
-    for (auto const& i : requested) {
-      buildables.emplace_back(i);
-    }
     std::vector<Builder> builders;
-    for (auto& b : buildables) {
-      builders.push_back(b.createBuilder());
-    }
+    builders.reserve(requested.size());
+    std::ranges::transform(requested, std::back_inserter(builders), [](auto const& i) { return Buildable{i}.createBuilder(); });
     return [builders](ProcessingContext& pc) mutable {
       auto outputs = pc.outputs();
-      for (auto& builder : builders) {
-        outputs.adopt(Output{builder.origin, builder.description, builder.version}, builder.materialize(pc));
-      }
+      std::ranges::for_each(builders, [&pc, &outputs](auto& builder) { outputs.adopt(Output{builder.origin, builder.description, builder.version}, builder.materialize(pc)); });
     };
   }};
 }
@@ -119,7 +111,7 @@ struct Spawnable {
   header::DataDescription description;
   header::DataHeader::SubSpecificationType version;
 
-  Spawnable(InputSpec const& spec)
+  explicit Spawnable(InputSpec const& spec)
     : binding{spec.binding}
   {
     auto&& [origin_, description_, version_] = DataSpecUtils::asConcreteDataMatcher(spec);
@@ -144,16 +136,19 @@ struct Spawnable {
       iws.str(json);
       schemas.emplace_back(ArrowJSONHelpers::read(iws));
     }
-    for (auto const& i : spec.metadata | views::filter_string_params_starts_with("input:") | std::ranges::views::transform([](auto const& param) {
-                           return DataSpecUtils::fromMetadataString(param.defaultValue.template get<std::string>());
-                         })) {
-      matchers.emplace_back(std::get<ConcreteDataMatcher>(i.matcher));
-    }
+    std::ranges::transform(spec.metadata |
+                             views::filter_string_params_starts_with("input:") |
+                             std::ranges::views::transform(
+                               [](auto const& param) {
+                                 return DataSpecUtils::fromMetadataString(param.defaultValue.template get<std::string>());
+                               }),
+                           std::back_inserter(matchers), [](auto const& i) { return std::get<ConcreteDataMatcher>(i.matcher); });
 
     std::vector<std::shared_ptr<arrow::Field>> fields;
-    for (auto& s : schemas) {
-      std::copy(s->fields().begin(), s->fields().end(), std::back_inserter(fields));
-    }
+    std::ranges::for_each(schemas,
+                          [&fields](auto const& s) {
+                            std::ranges::copy(s->fields(), std::back_inserter(fields));
+                          });
 
     inputSchema = std::make_shared<arrow::Schema>(fields);
     expressions = expressions::materializeProjectors(projectors, inputSchema, outputSchema->fields());
@@ -194,20 +189,12 @@ AlgorithmSpec AODReaderHelpers::aodSpawnerCallback(ConfigContext const& /*ctx*/)
 {
   return AlgorithmSpec::InitCallback{[](InitContext& ic) {
     auto const& requested = ic.services().get<DanglingEdgesContext>().spawnerInputs;
-    std::vector<Spawnable> spawnables;
-    for (auto const& i : requested) {
-      spawnables.emplace_back(i);
-    }
     std::vector<Spawner> spawners;
-    for (auto& s : spawnables) {
-      spawners.push_back(s.createMaker());
-    }
-
+    spawners.reserve(requested.size());
+    std::ranges::transform(requested, std::back_inserter(spawners), [](auto const& i) { return Spawnable{i}.createMaker(); });
     return [spawners](ProcessingContext& pc) mutable {
       auto outputs = pc.outputs();
-      for (auto& spawner : spawners) {
-        outputs.adopt(Output{spawner.origin, spawner.description, spawner.version}, spawner.materialize(pc));
-      }
+      std::ranges::for_each(spawners, [&pc, &outputs](auto& spawner) { outputs.adopt(Output{spawner.origin, spawner.description, spawner.version}, spawner.materialize(pc)); });
     };
   }};
 }
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index ec02c7e47132b..4fd35e0dc5065 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1283,6 +1283,7 @@ struct TableIterator : IP, C... {
 };
 
 struct ArrowHelpers {
+  static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
   static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const char* const> labels);
   static std::shared_ptr<arrow::Table> joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const std::string> labels);
   static std::shared_ptr<arrow::Table> concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables);
diff --git a/Framework/Core/include/Framework/Expressions.h b/Framework/Core/include/Framework/Expressions.h
index 0be19954f1faa..c5f50311a7d19 100644
--- a/Framework/Core/include/Framework/Expressions.h
+++ b/Framework/Core/include/Framework/Expressions.h
@@ -712,7 +712,7 @@ std::shared_ptr<gandiva::Projector> createProjectorHelper(size_t nColumns, expre
                                                           std::shared_ptr<arrow::Schema> schema,
                                                           std::vector<std::shared_ptr<arrow::Field>> const& fields);
 
-std::vector<std::shared_ptr<gandiva::Expression>> materializeProjectors(std::vector<expressions::Projector> const& projectors, std::shared_ptr<arrow::Schema> const& inputSchema, std::vector<std::shared_ptr<arrow::Field>> outputFields);
+std::vector<std::shared_ptr<gandiva::Expression>> materializeProjectors(std::vector<expressions::Projector> const& projectors, std::shared_ptr<arrow::Schema> const& inputSchema, std::vector<std::shared_ptr<arrow::Field>> const& outputFields);
 
 template <typename... C>
 std::shared_ptr<gandiva::Projector> createProjectors(framework::pack<C...>, std::vector<std::shared_ptr<arrow::Field>> const& fields, gandiva::SchemaPtr schema)
diff --git a/Framework/Core/src/ASoA.cxx b/Framework/Core/src/ASoA.cxx
index 6a846c3d45b6c..1c73b257f81e4 100644
--- a/Framework/Core/src/ASoA.cxx
+++ b/Framework/Core/src/ASoA.cxx
@@ -62,71 +62,71 @@ SelectionVector sliceSelection(std::span<int64_t const> const& mSelectedRows, in
   auto start_iterator = std::lower_bound(mSelectedRows.begin(), mSelectedRows.end(), start);
   auto stop_iterator = std::lower_bound(start_iterator, mSelectedRows.end(), end);
   SelectionVector slicedSelection{start_iterator, stop_iterator};
-  std::transform(slicedSelection.begin(), slicedSelection.end(), slicedSelection.begin(),
-                 [&start](int64_t idx) {
-                   return idx - static_cast<int64_t>(start);
-                 });
+  std::ranges::transform(slicedSelection.begin(), slicedSelection.end(), slicedSelection.begin(),
+                         [&start](int64_t idx) {
+                           return idx - static_cast<int64_t>(start);
+                         });
   return slicedSelection;
 }
 
-std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const char* const> labels)
+std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables)
 {
-  if (tables.size() == 1) {
-    return tables[0];
-  }
-  for (auto i = 0U; i < tables.size() - 1; ++i) {
-    if (tables[i]->num_rows() != tables[i + 1]->num_rows()) {
-      throw o2::framework::runtime_error_f("Tables %s and %s have different sizes (%d vs %d) and cannot be joined!",
-                                           labels[i], labels[i + 1], tables[i]->num_rows(), tables[i + 1]->num_rows());
-    }
-  }
   std::vector<std::shared_ptr<arrow::Field>> fields;
   std::vector<std::shared_ptr<arrow::ChunkedArray>> columns;
-
-  for (auto& t : tables) {
-    auto tf = t->fields();
-    std::copy(tf.begin(), tf.end(), std::back_inserter(fields));
-  }
-
-  auto schema = std::make_shared<arrow::Schema>(fields);
-
-  if (tables[0]->num_rows() != 0) {
-    for (auto& t : tables) {
-      auto tc = t->columns();
-      std::copy(tc.begin(), tc.end(), std::back_inserter(columns));
+  bool notEmpty = (tables[0]->num_rows() != 0);
+  std::ranges::for_each(tables, [&fields, &columns, notEmpty](auto const& t) {
+    std::ranges::copy(t->fields(), std::back_inserter(fields));
+    if (notEmpty) {
+      std::ranges::copy(t->columns(), std::back_inserter(columns));
     }
-  }
+  });
+  auto schema = std::make_shared<arrow::Schema>(fields);
   return arrow::Table::Make(schema, columns);
 }
 
-std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const std::string> labels)
+namespace
+{
+template <typename T>
+  requires(std::same_as<T, std::string>)
+auto makeString(T const& str)
+{
+  return str.c_str();
+}
+template <typename T>
+  requires(std::same_as<T, const char*>)
+auto makeString(T const& str)
+{
+  return str;
+}
+
+template <typename T>
+void canNotJoin(std::vector<std::shared_ptr<arrow::Table>> const& tables, std::span<T> labels)
 {
-  if (tables.size() == 1) {
-    return tables[0];
-  }
   for (auto i = 0U; i < tables.size() - 1; ++i) {
     if (tables[i]->num_rows() != tables[i + 1]->num_rows()) {
       throw o2::framework::runtime_error_f("Tables %s and %s have different sizes (%d vs %d) and cannot be joined!",
-                                           labels[i].c_str(), labels[i + 1].c_str(), tables[i]->num_rows(), tables[i + 1]->num_rows());
+                                           makeString(labels[i]), makeString(labels[i + 1]), tables[i]->num_rows(), tables[i + 1]->num_rows());
     }
   }
-  std::vector<std::shared_ptr<arrow::Field>> fields;
-  std::vector<std::shared_ptr<arrow::ChunkedArray>> columns;
+}
+} // namespace
 
-  for (auto& t : tables) {
-    auto tf = t->fields();
-    std::copy(tf.begin(), tf.end(), std::back_inserter(fields));
+std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const char* const> labels)
+{
+  if (tables.size() == 1) {
+    return tables[0];
   }
+  canNotJoin(tables, labels);
+  return joinTables(std::forward<std::vector<std::shared_ptr<arrow::Table>>>(tables));
+}
 
-  auto schema = std::make_shared<arrow::Schema>(fields);
-
-  if (tables[0]->num_rows() != 0) {
-    for (auto& t : tables) {
-      auto tc = t->columns();
-      std::copy(tc.begin(), tc.end(), std::back_inserter(columns));
-    }
+std::shared_ptr<arrow::Table> ArrowHelpers::joinTables(std::vector<std::shared_ptr<arrow::Table>>&& tables, std::span<const std::string> labels)
+{
+  if (tables.size() == 1) {
+    return tables[0];
   }
-  return arrow::Table::Make(schema, columns);
+  canNotJoin(tables, labels);
+  return joinTables(std::forward<std::vector<std::shared_ptr<arrow::Table>>>(tables));
 }
 
 std::shared_ptr<arrow::Table> ArrowHelpers::concatTables(std::vector<std::shared_ptr<arrow::Table>>&& tables)
@@ -135,7 +135,6 @@ std::shared_ptr<arrow::Table> ArrowHelpers::concatTables(std::vector<std::shared
     return tables[0];
   }
   std::vector<std::shared_ptr<arrow::ChunkedArray>> columns;
-  assert(tables.size() > 1);
   std::vector<std::shared_ptr<arrow::Field>> resultFields = tables[0]->schema()->fields();
   auto compareFields = [](std::shared_ptr<arrow::Field> const& f1, std::shared_ptr<arrow::Field> const& f2) {
     // Let's do this with stable sorting.
@@ -165,13 +164,12 @@ std::shared_ptr<arrow::Table> ArrowHelpers::concatTables(std::vector<std::shared
     columns.push_back(std::make_shared<arrow::ChunkedArray>(chunks));
   }
 
-  auto result = arrow::Table::Make(std::make_shared<arrow::Schema>(resultFields), columns);
-  return result;
+  return arrow::Table::Make(std::make_shared<arrow::Schema>(resultFields), columns);
 }
 
 arrow::ChunkedArray* getIndexFromLabel(arrow::Table* table, std::string_view label)
 {
-  auto field = std::find_if(table->schema()->fields().begin(), table->schema()->fields().end(), [&](std::shared_ptr<arrow::Field> const& f) {
+  auto field = std::ranges::find_if(table->schema()->fields(), [&](std::shared_ptr<arrow::Field> const& f) {
     auto caseInsensitiveCompare = [](const std::string_view& str1, const std::string& str2) {
       return std::ranges::equal(
         str1, str2,
diff --git a/Framework/Core/src/AnalysisHelpers.cxx b/Framework/Core/src/AnalysisHelpers.cxx
index f2ecb2d68ce28..b7eac692d3859 100644
--- a/Framework/Core/src/AnalysisHelpers.cxx
+++ b/Framework/Core/src/AnalysisHelpers.cxx
@@ -46,14 +46,12 @@ void IndexBuilder::resetBuilders(std::vector<framework::IndexColumnBuilder>& bui
 std::shared_ptr<arrow::Table> IndexBuilder::materialize(std::vector<framework::IndexColumnBuilder>& builders, std::vector<std::shared_ptr<arrow::Table>>&& tables, std::vector<soa::IndexRecord> const& records, std::shared_ptr<arrow::Schema> const& schema, bool exclusive)
 {
   auto size = tables[0]->num_rows();
-  if (builders.empty()) {
+  if (O2_BUILTIN_UNLIKELY(builders.empty())) {
     builders = makeBuilders(std::move(tables), records);
   } else {
     resetBuilders(builders, std::move(tables));
   }
 
-  std::vector<bool> finds;
-  finds.resize(builders.size());
   for (int64_t counter = 0; counter < size; ++counter) {
     int64_t idx = -1;
     if (std::get<framework::SelfBuilder>(builders[0].builder).keyIndex == nullptr) {
@@ -61,29 +59,19 @@ std::shared_ptr<arrow::Table> IndexBuilder::materialize(std::vector<framework::I
     } else {
       idx = std::get<framework::SelfBuilder>(builders[0].builder).keyIndex->valueAt(counter);
     }
-    for (auto i = 0U; i < builders.size(); ++i) {
-      finds[i] = builders[i].find(idx);
-    }
-    if (exclusive) {
-      if (std::none_of(finds.begin(), finds.end(), [](bool const x) { return x == false; })) {
-        builders[0].fill(counter);
-        for (auto i = 1U; i < builders.size(); ++i) {
-          builders[i].fill(idx);
-        }
-      }
-    } else {
+
+    bool found = true;
+    std::ranges::for_each(builders, [&idx, &found](auto& builder) { found &= builder.find(idx); });
+
+    if (!exclusive || found) {
       builders[0].fill(counter);
-      for (auto i = 1U; i < builders.size(); ++i) {
-        builders[i].fill(idx);
-      }
+      std::ranges::for_each(builders.begin() + 1, builders.end(), [&idx](auto& builder) { builder.fill(idx); });
     }
   }
 
   std::vector<std::shared_ptr<arrow::ChunkedArray>> arrays;
   arrays.reserve(builders.size());
-  for (auto& builder : builders) {
-    arrays.push_back(builder.result());
-  }
+  std::ranges::transform(builders, std::back_inserter(arrays), [](auto& builder) { return builder.result(); });
 
   return arrow::Table::Make(schema, arrays);
 }
@@ -142,9 +130,7 @@ std::shared_ptr<arrow::Table> spawnerHelper(std::shared_ptr<arrow::Table> const&
   }
 
   arrays.reserve(nColumns);
-  for (auto i = 0U; i < nColumns; ++i) {
-    arrays.push_back(std::make_shared<arrow::ChunkedArray>(chunks[i]));
-  }
+  std::ranges::transform(chunks, std::back_inserter(arrays), [](auto&& chunk) { return std::make_shared<arrow::ChunkedArray>(chunk); });
 
   return arrow::Table::Make(newSchema, arrays);
 }
@@ -188,9 +174,8 @@ std::string serializeIndexRecords(std::vector<o2::soa::IndexRecord>& irs)
 std::vector<std::shared_ptr<arrow::Table>> extractSources(ProcessingContext& pc, std::vector<ConcreteDataMatcher> const& matchers)
 {
   std::vector<std::shared_ptr<arrow::Table>> tables;
-  for (auto const& matcher : matchers) {
-    tables.emplace_back(pc.inputs().get<TableConsumer>(matcher)->asArrowTable());
-  }
+  tables.reserve(matchers.size());
+  std::ranges::transform(matchers, std::back_inserter(tables), [&pc](auto const& matcher) { return pc.inputs().get<TableConsumer>(matcher)->asArrowTable(); });
   return tables;
 }
 
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 95e763343671a..60277dfc38a74 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -531,13 +531,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                                                   dh->dataOrigin.str, dh->dataDescription.str);
                            continue;
                          }
-                         bool forwarded = false;
-                         for (auto const& forward : ctx.services().get<DeviceSpec const>().forwards) {
-                           if (DataSpecUtils::match(forward.matcher, *dh)) {
-                             forwarded = true;
-                             break;
-                           }
-                         }
+                         bool forwarded = std::ranges::any_of(ctx.services().get<DeviceSpec const>().forwards, [&dh](auto const& forward) { return DataSpecUtils::match(forward.matcher, *dh); });
                          if (forwarded) {
                            O2_SIGNPOST_EVENT_EMIT(rate_limiting, sid, "offer",
                                                   "Message %{public}.4s/%{public}.16s is forwarded so we are not returning its memory.",
@@ -584,11 +578,11 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        } },
     .adjustTopology = [](WorkflowSpecNode& node, ConfigContext const& ctx) {
       auto& workflow = node.specs;
-      auto spawner = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-spawner"; });
-      auto analysisCCDB = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-ccdb"; });
-      auto builder = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-index-builder"; });
-      auto reader = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-reader"; });
-      auto writer = std::find_if(workflow.begin(), workflow.end(), [](DataProcessorSpec const& spec) { return spec.name == "internal-dpl-aod-writer"; });
+      auto spawner = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-spawner"); });
+      auto analysisCCDB = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-ccdb"); });
+      auto builder = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-index-builder"); });
+      auto reader = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-reader"); });
+      auto writer = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-writer"); });
       auto& dec = ctx.services().get<DanglingEdgesContext>();
       dec.requestedAODs.clear();
       dec.requestedDYNs.clear();
@@ -626,8 +620,8 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
             views::partial_match_filter(header::DataOrigin{"DYN"}) |
             sinks::append_to{dec.providedDYNs};
         }
-        std::sort(dec.requestedDYNs.begin(), dec.requestedDYNs.end(), inputSpecLessThan);
-        std::sort(dec.providedDYNs.begin(), dec.providedDYNs.end(), outputSpecLessThan);
+        std::ranges::sort(dec.requestedDYNs, inputSpecLessThan);
+        std::ranges::sort(dec.providedDYNs, outputSpecLessThan);
         dec.spawnerInputs.clear();
         dec.requestedDYNs |
           views::filter_not_matching(dec.providedDYNs) |
@@ -646,8 +640,8 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
           d.inputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::update_input_list{dec.requestedTIMs};
           d.outputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::append_to{dec.providedTIMs};
         }
-        std::sort(dec.requestedTIMs.begin(), dec.requestedTIMs.end(), inputSpecLessThan);
-        std::sort(dec.providedTIMs.begin(), dec.providedTIMs.end(), outputSpecLessThan);
+        std::ranges::sort(dec.requestedTIMs, inputSpecLessThan);
+        std::ranges::sort(dec.providedTIMs, outputSpecLessThan);
         // Use ranges::to<std::vector<>> in C++23...
         dec.analysisCCDBInputs.clear();
         dec.requestedTIMs | views::filter_not_matching(dec.providedTIMs) | sinks::append_to{dec.analysisCCDBInputs};
diff --git a/Framework/Core/src/ArrowTableSlicingCache.cxx b/Framework/Core/src/ArrowTableSlicingCache.cxx
index 634c51f71f5a6..5162c698a1d66 100644
--- a/Framework/Core/src/ArrowTableSlicingCache.cxx
+++ b/Framework/Core/src/ArrowTableSlicingCache.cxx
@@ -210,7 +210,7 @@ std::pair<int, bool> ArrowTableSlicingCache::getCachePos(const Entry& bindingKey
 
 int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const
 {
-  auto locate = std::find(bindingsKeys.begin(), bindingsKeys.end(), bindingKey);
+  auto locate = std::ranges::find(bindingsKeys, bindingKey);
   if (locate != bindingsKeys.end()) {
     return std::distance(bindingsKeys.begin(), locate);
   }
@@ -219,7 +219,7 @@ int ArrowTableSlicingCache::getCachePosSortedFor(Entry const& bindingKey) const
 
 int ArrowTableSlicingCache::getCachePosUnsortedFor(Entry const& bindingKey) const
 {
-  auto locate_unsorted = std::find(bindingsKeysUnsorted.begin(), bindingsKeysUnsorted.end(), bindingKey);
+  auto locate_unsorted = std::ranges::find(bindingsKeysUnsorted, bindingKey);
   if (locate_unsorted != bindingsKeysUnsorted.end()) {
     return std::distance(bindingsKeysUnsorted.begin(), locate_unsorted);
   }
@@ -275,7 +275,7 @@ void ArrowTableSlicingCache::validateOrder(Entry const& bindingKey, const std::s
   }
   auto column = o2::framework::GetColumnByNameCI(input, key);
   auto array0 = static_cast<arrow::NumericArray<arrow::Int32Type>>(column->chunk(0)->data());
-  int32_t prev = 0;
+  int32_t prev;
   int32_t cur = array0.Value(0);
   int32_t lastNeg = cur < 0 ? cur : 0;
   int32_t lastPos = cur < 0 ? -1 : cur;
diff --git a/Framework/Core/src/Expressions.cxx b/Framework/Core/src/Expressions.cxx
index 43143f781ddf4..02a862d30032b 100644
--- a/Framework/Core/src/Expressions.cxx
+++ b/Framework/Core/src/Expressions.cxx
@@ -1348,11 +1348,11 @@ OpNode Parser::opFromToken(std::string const& token)
   return OpNode{static_cast<BasicOp>(std::distance(mapping.begin(), locate))};
 }
 
-std::vector<std::shared_ptr<gandiva::Expression>> materializeProjectors(std::vector<expressions::Projector> const& projectors, std::shared_ptr<arrow::Schema> const& inputSchema, std::vector<std::shared_ptr<arrow::Field>> outputFields)
+std::vector<std::shared_ptr<gandiva::Expression>> materializeProjectors(std::vector<expressions::Projector> const& projectors, std::shared_ptr<arrow::Schema> const& inputSchema, std::vector<std::shared_ptr<arrow::Field>> const& outputFields)
 {
   std::vector<std::shared_ptr<gandiva::Expression>> expressions;
   int i = 0;
-  for (auto& p : projectors) {
+  for (auto const& p : projectors) {
     expressions.push_back(
       expressions::makeExpression(
         expressions::createExpressionTree(
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index fd9099e1aa24e..ff1ff1f4cf13d 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -100,7 +100,7 @@ std::vector<TopoIndexInfo>
     // which have the current node as incoming.
     // nextEdges will contain all the edges which are not related
     // to the current node.
-    for (auto& ei : remainingEdgesIndex) {
+    for (auto const& ei : remainingEdgesIndex) {
       if (*(edgeIn + ei * stride) == node.index) {
         nextVertex.insert({*(edgeOut + ei * stride), node.layer + 1});
       } else {
@@ -112,7 +112,7 @@ std::vector<TopoIndexInfo>
     // Of all the vertices which have node as incoming,
     // check if there is any other incoming node.
     std::set<TopoIndexInfo> hasPredecessors;
-    for (auto& ei : remainingEdgesIndex) {
+    for (auto const& ei : remainingEdgesIndex) {
       for (auto& m : nextVertex) {
         if (m.index == *(edgeOut + ei * stride)) {
           hasPredecessors.insert({m.index, m.layer});
@@ -240,7 +240,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   for (size_t wi = 0; wi < workflow.size(); ++wi) {
     auto& processor = workflow[wi];
     auto name = processor.name;
-    auto hash = runtime_hash(name.c_str());
+    uint32_t hash = runtime_hash(name.c_str());
     dec.outTskMap.push_back({hash, name});
 
     std::string prefix = "internal-dpl-";
@@ -252,8 +252,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       processor.options.push_back(ConfigParamSpec{"end-value-enumeration", VariantType::Int64, -1ll, {"final value for the enumeration"}});
       processor.options.push_back(ConfigParamSpec{"step-value-enumeration", VariantType::Int64, 1ll, {"step between one value and the other"}});
     }
-    bool hasTimeframeInputs = std::any_of(processor.inputs.begin(), processor.inputs.end(), [](auto const& input) { return input.lifetime == Lifetime::Timeframe; });
-    bool hasTimeframeOutputs = std::any_of(processor.outputs.begin(), processor.outputs.end(), [](auto const& output) { return output.lifetime == Lifetime::Timeframe; });
+    bool hasTimeframeInputs = std::ranges::any_of(processor.inputs, [](auto const& input) { return input.lifetime == Lifetime::Timeframe; });
+    bool hasTimeframeOutputs = std::ranges::any_of(processor.outputs, [](auto const& output) { return output.lifetime == Lifetime::Timeframe; });
 
     // A timeframeSink consumes timeframes without creating new
     // timeframe data.
@@ -261,10 +261,9 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     if (rateLimitingIPCID != -1) {
       if (timeframeSink && processor.name.find("internal-dpl-injected-dummy-sink") == std::string::npos) {
         O2_SIGNPOST_ID_GENERATE(sid, workflow_helpers);
-        uint32_t hash = runtime_hash(processor.name.c_str());
         bool hasMatch = false;
         ConcreteDataMatcher summaryMatcher = ConcreteDataMatcher{"DPL", "SUMMARY", static_cast<DataAllocator::SubSpecificationType>(hash)};
-        auto summaryOutput = std::find_if(processor.outputs.begin(), processor.outputs.end(), [&summaryMatcher](auto const& output) { return DataSpecUtils::match(output, summaryMatcher); });
+        auto summaryOutput = std::ranges::find_if(processor.outputs, [&summaryMatcher](auto const& output) { return DataSpecUtils::match(output, summaryMatcher); });
         if (summaryOutput != processor.outputs.end()) {
           O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "output enumeration", "%{public}s already there in %{public}s",
                                  DataSpecUtils::describe(*summaryOutput).c_str(), processor.name.c_str());
@@ -283,7 +282,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       switch (input.lifetime) {
         case Lifetime::Timer: {
           auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
-          auto hasOption = std::any_of(processor.options.begin(), processor.options.end(), [&input](auto const& option) { return (option.name == "period-" + input.binding); });
+          auto hasOption = std::ranges::any_of(processor.options, [&input](auto const& option) { return (option.name == "period-" + input.binding); });
           if (hasOption == false) {
             processor.options.push_back(ConfigParamSpec{"period-" + input.binding, VariantType::Int, 1000, {"period of the timer in milliseconds"}});
           }
@@ -299,7 +298,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
         } break;
         case Lifetime::Condition: {
           requestedCCDBs.emplace_back(input);
-          if ((hasConditionOption == false) && std::none_of(processor.options.begin(), processor.options.end(), [](auto const& option) { return (option.name.compare("condition-backend") == 0); })) {
+          if ((hasConditionOption == false) && std::ranges::none_of(processor.options, [](auto const& option) { return (option.name.compare("condition-backend") == 0); })) {
             processor.options.emplace_back(ConfigParamSpec{"condition-backend", VariantType::String, defaultConditionBackend(), {"URL for CCDB"}});
             processor.options.emplace_back(ConfigParamSpec{"condition-timestamp", VariantType::Int64, 0ll, {"Force timestamp for CCDB lookup"}});
             hasConditionOption = true;
@@ -307,7 +306,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
         } break;
         case Lifetime::OutOfBand: {
           auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
-          auto hasOption = std::any_of(processor.options.begin(), processor.options.end(), [&input](auto const& option) { return (option.name == "out-of-band-channel-name-" + input.binding); });
+          auto hasOption = std::ranges::any_of(processor.options, [&input](auto const& option) { return (option.name == "out-of-band-channel-name-" + input.binding); });
           if (hasOption == false) {
             processor.options.push_back(ConfigParamSpec{"out-of-band-channel-name-" + input.binding, VariantType::String, "out-of-band", {"channel to listen for out of band data"}});
           }
@@ -333,7 +332,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       }
     }
 
-    std::stable_sort(timer.outputs.begin(), timer.outputs.end(), [](OutputSpec const& a, OutputSpec const& b) { return *DataSpecUtils::getOptionalSubSpec(a) < *DataSpecUtils::getOptionalSubSpec(b); });
+    std::ranges::stable_sort(timer.outputs, [](OutputSpec const& a, OutputSpec const& b) { return *DataSpecUtils::getOptionalSubSpec(a) < *DataSpecUtils::getOptionalSubSpec(b); });
 
     for (auto& output : processor.outputs) {
       if (DataSpecUtils::partialMatch(output, AODOrigins)) {
@@ -344,7 +343,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
         dec.providedTIMs.emplace_back(output);
       } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"ATSK"})) {
         dec.providedOutputObjHist.emplace_back(output);
-        auto it = std::find_if(dec.outObjHistMap.begin(), dec.outObjHistMap.end(), [&](auto&& x) { return x.id == hash; });
+        auto it = std::ranges::find_if(dec.outObjHistMap, [&](auto&& x) { return x.id == hash; });
         if (it == dec.outObjHistMap.end()) {
           dec.outObjHistMap.push_back({hash, {output.binding.value}});
         } else {
@@ -359,10 +358,10 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   auto inputSpecLessThan = [](InputSpec const& lhs, InputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
   auto outputSpecLessThan = [](OutputSpec const& lhs, OutputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
-  std::sort(dec.requestedDYNs.begin(), dec.requestedDYNs.end(), inputSpecLessThan);
-  std::sort(dec.requestedTIMs.begin(), dec.requestedTIMs.end(), inputSpecLessThan);
-  std::sort(dec.providedDYNs.begin(), dec.providedDYNs.end(), outputSpecLessThan);
-  std::sort(dec.providedTIMs.begin(), dec.providedTIMs.end(), outputSpecLessThan);
+  std::ranges::sort(dec.requestedDYNs, inputSpecLessThan);
+  std::ranges::sort(dec.requestedTIMs, inputSpecLessThan);
+  std::ranges::sort(dec.providedDYNs, outputSpecLessThan);
+  std::ranges::sort(dec.providedTIMs, outputSpecLessThan);
 
   DataProcessorSpec indexBuilder{
     "internal-dpl-aod-index-builder",
@@ -389,8 +388,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   AnalysisSupportHelpers::addMissingOutputsToSpawner({}, dec.spawnerInputs, dec.requestedAODs, aodSpawner);
   AnalysisSupportHelpers::addMissingOutputsToReader(dec.providedAODs, dec.requestedAODs, aodReader);
 
-  std::sort(requestedCCDBs.begin(), requestedCCDBs.end(), inputSpecLessThan);
-  std::sort(providedCCDBs.begin(), providedCCDBs.end(), outputSpecLessThan);
+  std::ranges::sort(requestedCCDBs, inputSpecLessThan);
+  std::ranges::sort(providedCCDBs, outputSpecLessThan);
   AnalysisSupportHelpers::addMissingOutputsToReader(providedCCDBs, requestedCCDBs, ccdbBackend);
 
   std::vector<DataProcessorSpec> extraSpecs;
@@ -412,7 +411,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   // add the reader
   if (aodReader.outputs.empty() == false) {
-    auto mctracks2aod = std::find_if(workflow.begin(), workflow.end(), [](auto const& x) { return x.name == "mctracks-to-aod"; });
+    auto mctracks2aod = std::ranges::find_if(workflow, [](auto const& x) { return x.name == "mctracks-to-aod"; });
     if (mctracks2aod == workflow.end()) {
       // add normal reader
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
@@ -440,22 +439,22 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   auto& dstf = std::get<ConcreteDataMatcher>(matcher.matcher);
   // Check if any of the provided outputs is a DISTSTF
   // Check if any of the requested inputs is for a 0xccdb message
-  bool providesDISTSTF = std::any_of(workflow.begin(), workflow.end(),
-                                     [&matcher](auto const& dp) {
-                                       return std::any_of(dp.outputs.begin(), dp.outputs.end(), [&matcher](auto const& output) {
-                                         return DataSpecUtils::match(matcher, output);
-                                       });
-                                     });
+  bool providesDISTSTF = std::ranges::any_of(workflow,
+                                             [&matcher](auto const& dp) {
+                                               return std::any_of(dp.outputs.begin(), dp.outputs.end(), [&matcher](auto const& output) {
+                                                 return DataSpecUtils::match(matcher, output);
+                                               });
+                                             });
 
   // If there is no CCDB requested, but we still ask for a FLP/DISTSUBTIMEFRAME/0xccdb
   // we add to the first data processor which has no inputs (apart from
   // enumerations / timers) the responsibility to provide the DISTSUBTIMEFRAME
-  bool requiresDISTSUBTIMEFRAME = std::any_of(workflow.begin(), workflow.end(),
-                                              [&dstf](auto const& dp) {
-                                                return std::any_of(dp.inputs.begin(), dp.inputs.end(), [&dstf](auto const& input) {
-                                                  return DataSpecUtils::match(input, dstf);
-                                                });
-                                              });
+  bool requiresDISTSUBTIMEFRAME = std::ranges::any_of(workflow,
+                                                      [&dstf](auto const& dp) {
+                                                        return std::any_of(dp.inputs.begin(), dp.inputs.end(), [&dstf](auto const& input) {
+                                                          return DataSpecUtils::match(input, dstf);
+                                                        });
+                                                      });
 
   // We find the first device which has either just enumerations or
   // just timers, and we will add the DISTSUBTIMEFRAME to it.
@@ -560,7 +559,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     auto fileSink = AnalysisSupportHelpers::getGlobalAODSink(ctx);
     extraSpecs.push_back(fileSink);
 
-    auto it = std::find_if(dec.outputsInputs.begin(), dec.outputsInputs.end(), [](InputSpec& spec) -> bool {
+    auto it = std::ranges::find_if(dec.outputsInputs, [](InputSpec& spec) -> bool {
       return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
     });
     size_t ii = std::distance(dec.outputsInputs.begin(), it);
@@ -694,15 +693,8 @@ void WorkflowHelpers::adjustTopology(WorkflowSpec& workflow, ConfigContext const
   }
 
   if (distSTFCount > 0) {
-    bool found = false;
     for (auto& spec : workflow) {
-      for (auto& output : spec.outputs) {
-        if (DataSpecUtils::match(output, ConcreteDataMatcher{"FLP", "DISTSUBTIMEFRAME", 0})) {
-          found = true;
-          break;
-        }
-      }
-      if (found) {
+      if (std::ranges::any_of(spec.outputs, [](auto const& output) { return DataSpecUtils::match(output, ConcreteDataMatcher{"FLP", "DISTSUBTIMEFRAME", 0}); })) {
         for (unsigned int i = 1; i < distSTFCount; ++i) {
           spec.outputs.emplace_back(OutputSpec{ConcreteDataMatcher{"FLP", "DISTSUBTIMEFRAME", i}, Lifetime::Timeframe});
         }
@@ -1005,7 +997,7 @@ std::tuple<std::vector<InputSpec>, std::vector<bool>> WorkflowHelpers::analyzeOu
     input.binding = (snprintf(buf, 63, "output_%zu_%zu", output.workflowId, output.id), buf);
 
     // make sure that entries are unique
-    if (std::find(results.begin(), results.end(), input) == results.end()) {
+    if (std::ranges::find(results, input) == results.end()) {
       results.emplace_back(input);
       isDangling.emplace_back(matched == false);
     }

From 7cc3f1c550e70f8c6b919c7168f505ee13f75dc5 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 26 Jan 2026 11:22:10 +0100
Subject: [PATCH 1236/1764] DPL: move snapshot code to use concepts

Should be faster to compile and have better debug information.

It will also work seamlessly for gsl::span (assuming you have ms_gsl 4.2.1) and std::span.
---
 .../Core/include/Framework/DataAllocator.h    | 243 ++++++++++--------
 .../include/Framework/SerializationMethods.h  |  13 +-
 2 files changed, 143 insertions(+), 113 deletions(-)

diff --git a/Framework/Core/include/Framework/DataAllocator.h b/Framework/Core/include/Framework/DataAllocator.h
index 287513ec85845..ed9a31ca2857c 100644
--- a/Framework/Core/include/Framework/DataAllocator.h
+++ b/Framework/Core/include/Framework/DataAllocator.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -29,9 +29,9 @@
 
 #include "Headers/DataHeader.h"
 #include <TClass.h>
-#include <gsl/span>
 
 #include <memory>
+#include <ranges>
 #include <vector>
 #include <map>
 #include <string>
@@ -127,6 +127,10 @@ template <typename T>
 concept VectorOfMessageableTypes = is_specialization_v<T, std::vector> &&
                                    is_messageable<typename T::value_type>::value;
 
+template <typename T>
+concept ContiguousMessageablesRange = std::ranges::contiguous_range<T> &&
+                                      is_messageable<typename T::value_type>::value;
+
 /// This allocator is responsible to make sure that the messages created match
 /// the provided spec and that depending on how many pipelined reader we
 /// have, messages get created on the channel for the reader of the current
@@ -296,8 +300,9 @@ class DataAllocator
   ///
   /// Supported types:
   /// - messageable types (trivially copyable, non-polymorphic
-  /// - std::vector of messageable types
-  /// - std::vector of pointers of messageable type
+  /// - contiguous_range of messageable types
+  /// - random_access_ranges of pointers of messageable type
+  /// - sized range of messageable type
   /// - types with ROOT dictionary and implementing the ROOT ClassDef interface
   ///
   /// Note: for many use cases, especially for the messageable types, the `make` interface
@@ -308,116 +313,140 @@ class DataAllocator
   /// Use @a ROOTSerialized type wrapper to force ROOT serialization. Same applies to
   /// types which do not implement the ClassDef interface but have a dictionary.
   template <typename T>
+    requires(!std::ranges::contiguous_range<T> && is_messageable<T>::value)
+  void snapshot(const Output& spec, T const& object)
+  {
+    return snapshot(spec, std::span<T const>(&object, &object + 1));
+  }
+
+  void snapshot(const Output& spec, std::string_view const& object)
+  {
+    return snapshot(spec, std::span<char const>(object.data(), object.size()));
+  }
+
+  // This is for snapshotting a range of contiguous messageable types
+  template <typename T>
+    requires(ContiguousMessageablesRange<T> && !std::is_pointer_v<typename T::value_type>)
   void snapshot(const Output& spec, T const& object)
   {
     auto& proxy = mRegistry.get<MessageContext>().proxy();
-    fair::mq::MessagePtr payloadMessage;
-    auto serializationType = o2::header::gSerializationMethodNone;
     RouteIndex routeIndex = matchDataHeader(spec, mRegistry.get<TimingInfo>().timeslice);
-    if constexpr (is_messageable<T>::value == true) {
-      // Serialize a snapshot of a trivially copyable, non-polymorphic object,
-      payloadMessage = proxy.createOutputMessage(routeIndex, sizeof(T));
-      memcpy(payloadMessage->GetData(), &object, sizeof(T));
-
-      serializationType = o2::header::gSerializationMethodNone;
-    } else if constexpr (is_specialization_v<T, std::vector> == true ||
-                         (gsl::details::is_span<T>::value && has_messageable_value_type<T>::value)) {
-      using ElementType = typename std::remove_pointer<typename T::value_type>::type;
-      if constexpr (is_messageable<ElementType>::value) {
-        // Serialize a snapshot of a std::vector of trivially copyable, non-polymorphic elements
-        // Note: in most cases it is better to use the `make` function und work with the provided
-        // reference object
-        constexpr auto elementSizeInBytes = sizeof(ElementType);
-        auto sizeInBytes = elementSizeInBytes * object.size();
-        payloadMessage = proxy.createOutputMessage(routeIndex, sizeInBytes);
-
-        if constexpr (std::is_pointer<typename T::value_type>::value == false) {
-          // vector of elements
-          if (object.data() && sizeInBytes) {
-            memcpy(payloadMessage->GetData(), object.data(), sizeInBytes);
-          }
-        } else {
-          // serialize vector of pointers to elements
-          auto target = reinterpret_cast<unsigned char*>(payloadMessage->GetData());
-          for (auto const& pointer : object) {
-            memcpy(target, pointer, elementSizeInBytes);
-            target += elementSizeInBytes;
-          }
-        }
-
-        serializationType = o2::header::gSerializationMethodNone;
-      } else if constexpr (has_root_dictionary<ElementType>::value) {
-        return snapshot(spec, ROOTSerialized<T const>(object));
-      } else {
-        static_assert(always_static_assert_v<T>,
-                      "value type of std::vector not supported by API, supported types:"
-                      "\n - messageable tyeps (trivially copyable, non-polymorphic structures)"
-                      "\n - pointers to those"
-                      "\n - types with ROOT dictionary and implementing ROOT ClassDef interface");
-      }
-    } else if constexpr (is_container<T>::value == true && has_messageable_value_type<T>::value == true) {
-      // Serialize a snapshot of a std::container of trivially copyable, non-polymorphic elements
-      // Note: in most cases it is better to use the `make` function und work with the provided
-      // reference object
-      constexpr auto elementSizeInBytes = sizeof(typename T::value_type);
-      auto sizeInBytes = elementSizeInBytes * object.size();
-      payloadMessage = proxy.createOutputMessage(routeIndex, sizeInBytes);
-
-      // serialize vector of pointers to elements
-      auto target = reinterpret_cast<unsigned char*>(payloadMessage->GetData());
-      for (auto const& entry : object) {
-        memcpy(target, (void*)&entry, elementSizeInBytes);
-        target += elementSizeInBytes;
-      }
-      serializationType = o2::header::gSerializationMethodNone;
-    } else if constexpr (has_root_dictionary<T>::value == true || is_specialization_v<T, ROOTSerialized> == true) {
-      // Serialize a snapshot of an object with root dictionary
-      payloadMessage = proxy.createOutputMessage(routeIndex);
-      payloadMessage->Rebuild(4096, {64});
-      if constexpr (is_specialization_v<T, ROOTSerialized> == true) {
-        // Explicitely ROOT serialize a snapshot of object.
-        // An object wrapped into type `ROOTSerialized` is explicitely marked to be ROOT serialized
-        // and is expected to have a ROOT dictionary. Availability can not be checked at compile time
-        // for all cases.
-        using WrappedType = typename T::wrapped_type;
-        static_assert(std::is_same<typename T::hint_type, const char>::value ||
-                        std::is_same<typename T::hint_type, TClass>::value ||
-                        std::is_void<typename T::hint_type>::value,
-                      "class hint must be of type TClass or const char");
-
-        const TClass* cl = nullptr;
-        if (object.getHint() == nullptr) {
-          // get TClass info by wrapped type
-          cl = TClass::GetClass(typeid(WrappedType));
-        } else if (std::is_same<typename T::hint_type, TClass>::value) {
-          // the class info has been passed directly
-          cl = reinterpret_cast<const TClass*>(object.getHint());
-        } else if (std::is_same<typename T::hint_type, const char>::value) {
-          // get TClass info by optional name
-          cl = TClass::GetClass(reinterpret_cast<const char*>(object.getHint()));
-        }
-        if (has_root_dictionary<WrappedType>::value == false && cl == nullptr) {
-          if (std::is_same<typename T::hint_type, const char>::value) {
-            throw runtime_error_f("ROOT serialization not supported, dictionary not found for type %s",
-                                  reinterpret_cast<const char*>(object.getHint()));
-          } else {
-            throw runtime_error_f("ROOT serialization not supported, dictionary not found for type %s",
-                                  typeid(WrappedType).name());
-          }
-        }
-        typename root_serializer<T>::serializer().Serialize(*payloadMessage, &object(), cl);
+    using ElementType = typename std::remove_pointer<typename T::value_type>::type;
+    // Serialize a snapshot of a std::vector of trivially copyable, non-polymorphic elements
+    // Note: in most cases it is better to use the `make` function und work with the provided
+    // reference object
+    constexpr auto elementSizeInBytes = sizeof(ElementType);
+    auto sizeInBytes = elementSizeInBytes * object.size();
+    fair::mq::MessagePtr payloadMessage = proxy.createOutputMessage(routeIndex, sizeInBytes);
+
+    // vector of elements
+    if (object.data() && sizeInBytes) {
+      memcpy(payloadMessage->GetData(), object.data(), sizeInBytes);
+    }
+
+    addPartToContext(routeIndex, std::move(payloadMessage), spec, o2::header::gSerializationMethodNone);
+  }
+
+  // A random access range of pointers we can serialise by storing the contens one after the other.
+  // On the receiving side you will have to retrieve it via a span
+  template <typename T>
+    requires(std::ranges::random_access_range<T> && is_messageable<typename std::remove_pointer_t<typename T::value_type>>::value && std::is_pointer_v<typename T::value_type>)
+  void snapshot(const Output& spec, T const& object)
+  {
+    auto& proxy = mRegistry.get<MessageContext>().proxy();
+    RouteIndex routeIndex = matchDataHeader(spec, mRegistry.get<TimingInfo>().timeslice);
+    using ElementType = typename std::remove_pointer_t<typename T::value_type>;
+    // Serialize a snapshot of a std::vector of trivially copyable, non-polymorphic elements
+    // Note: in most cases it is better to use the `make` function und work with the provided
+    // reference object
+    constexpr auto elementSizeInBytes = sizeof(ElementType);
+    auto sizeInBytes = elementSizeInBytes * object.size();
+    fair::mq::MessagePtr payloadMessage = proxy.createOutputMessage(routeIndex, sizeInBytes);
+
+    // serialize vector of pointers to elements
+    auto target = reinterpret_cast<unsigned char*>(payloadMessage->GetData());
+    for (auto const& pointer : object) {
+      memcpy(target, pointer, elementSizeInBytes);
+      target += elementSizeInBytes;
+    }
+
+    addPartToContext(routeIndex, std::move(payloadMessage), spec, o2::header::gSerializationMethodNone);
+  }
+
+  // This is for a range where we can know upfront how many elements there are,
+  // so that we can preallocate the final size by simply multipling sizeof(T) x N elements
+  template <typename T>
+    requires(!std::ranges::contiguous_range<T> && std::ranges::sized_range<T> && has_messageable_value_type<T>::value)
+  void snapshot(const Output& spec, T const& object)
+  {
+    auto& proxy = mRegistry.get<MessageContext>().proxy();
+    RouteIndex routeIndex = matchDataHeader(spec, mRegistry.get<TimingInfo>().timeslice);
+    // Serialize a snapshot of a std::container of trivially copyable, non-polymorphic elements
+    // Note: in most cases it is better to use the `make` function und work with the provided
+    // reference object
+    constexpr auto elementSizeInBytes = sizeof(typename T::value_type);
+    auto sizeInBytes = elementSizeInBytes * object.size();
+    fair::mq::MessagePtr payloadMessage = proxy.createOutputMessage(routeIndex, sizeInBytes);
+
+    // serialize vector of pointers to elements
+    auto target = reinterpret_cast<unsigned char*>(payloadMessage->GetData());
+    for (auto const& entry : object) {
+      memcpy(target, (void*)&entry, elementSizeInBytes);
+      target += elementSizeInBytes;
+    }
+    addPartToContext(routeIndex, std::move(payloadMessage), spec, o2::header::gSerializationMethodNone);
+  }
+
+  template <typename T>
+    requires(is_specialization_v<T, ROOTSerialized>)
+  void snapshot(const Output& spec, T const& object)
+  {
+    auto& proxy = mRegistry.get<MessageContext>().proxy();
+    RouteIndex routeIndex = matchDataHeader(spec, mRegistry.get<TimingInfo>().timeslice);
+    // Serialize a snapshot of an object with root dictionary
+    fair::mq::MessagePtr payloadMessage = proxy.createOutputMessage(routeIndex);
+    payloadMessage->Rebuild(4096, {64});
+    const TClass* cl = nullptr;
+    // Explicitely ROOT serialize a snapshot of object.
+    // An object wrapped into type `ROOTSerialized` is explicitely marked to be ROOT serialized
+    // and is expected to have a ROOT dictionary. Availability can not be checked at compile time
+    // for all cases.
+    using WrappedType = typename T::wrapped_type;
+
+    if (object.getHint() == nullptr) {
+      // get TClass info by wrapped type
+      cl = TClass::GetClass(typeid(WrappedType));
+    } else if (std::is_same<typename T::hint_type, TClass>::value) {
+      // the class info has been passed directly
+      cl = reinterpret_cast<const TClass*>(object.getHint());
+    } else if (std::is_same<typename T::hint_type, const char>::value) {
+      // get TClass info by optional name
+      cl = TClass::GetClass(reinterpret_cast<const char*>(object.getHint()));
+    }
+    if (has_root_dictionary<WrappedType>::value == false && cl == nullptr) {
+      if (std::is_same<typename T::hint_type, const char>::value) {
+        throw runtime_error_f("ROOT serialization not supported, dictionary not found for type %s",
+                              reinterpret_cast<const char*>(object.getHint()));
       } else {
-        typename root_serializer<T>::serializer().Serialize(*payloadMessage, &object, TClass::GetClass(typeid(T)));
+        throw runtime_error_f("ROOT serialization not supported, dictionary not found for type %s",
+                              typeid(WrappedType).name());
       }
-      serializationType = o2::header::gSerializationMethodROOT;
-    } else {
-      static_assert(always_static_assert_v<T>,
-                    "data type T not supported by API, \n specializations available for"
-                    "\n - trivially copyable, non-polymorphic structures"
-                    "\n - std::vector of messageable structures or pointers to those"
-                    "\n - types with ROOT dictionary and implementing ROOT ClassDef interface");
     }
-    addPartToContext(routeIndex, std::move(payloadMessage), spec, serializationType);
+    typename root_serializer<T>::serializer().Serialize(*payloadMessage, &object(), cl);
+    addPartToContext(routeIndex, std::move(payloadMessage), spec, o2::header::gSerializationMethodROOT);
+  }
+
+  template <typename T>
+    requires(!is_messageable<T>::value && !ContiguousMessageablesRange<T> && has_root_dictionary<T>::value && !is_specialization_v<T, ROOTSerialized>)
+  void snapshot(const Output& spec, T const& object)
+  {
+    auto& proxy = mRegistry.get<MessageContext>().proxy();
+    RouteIndex routeIndex = matchDataHeader(spec, mRegistry.get<TimingInfo>().timeslice);
+    // Serialize a snapshot of an object with root dictionary
+    fair::mq::MessagePtr payloadMessage = proxy.createOutputMessage(routeIndex);
+    payloadMessage->Rebuild(4096, {64});
+    typename root_serializer<T>::serializer().Serialize(*payloadMessage, &object, TClass::GetClass(typeid(T)));
+    addPartToContext(routeIndex, std::move(payloadMessage), spec, o2::header::gSerializationMethodROOT);
   }
 
   /// Take a snapshot of a raw data array which can be either POD or may contain a serialized
diff --git a/Framework/Core/include/Framework/SerializationMethods.h b/Framework/Core/include/Framework/SerializationMethods.h
index 31b9d24013ab4..68c509d36905f 100644
--- a/Framework/Core/include/Framework/SerializationMethods.h
+++ b/Framework/Core/include/Framework/SerializationMethods.h
@@ -15,6 +15,7 @@
 /// @brief Type wrappers for enfording a specific serialization method
 
 #include "Framework/TypeTraits.h"
+#include <TClass.h>
 
 namespace o2::framework
 {
@@ -43,6 +44,9 @@ namespace o2::framework
 ///     - or -
 ///   ROOTSerialized<decltype(object), const char>(object, "classname"));
 template <typename T, typename HintType = void>
+  requires(!std::is_pointer_v<T> && (std::same_as<HintType, const char> ||
+                                     std::same_as<HintType, TClass> ||
+                                     std::is_void_v<HintType>))
 class ROOTSerialized
 {
  public:
@@ -50,9 +54,6 @@ class ROOTSerialized
   using wrapped_type = T;
   using hint_type = HintType;
 
-  static_assert(std::is_pointer<T>::value == false, "wrapped type can not be a pointer");
-  static_assert(std::is_pointer<HintType>::value == false, "hint type can not be a pointer");
-
   ROOTSerialized() = delete;
   ROOTSerialized(wrapped_type& ref, hint_type* hint = nullptr) : mRef(ref), mHint(hint) {}
 
@@ -67,6 +68,9 @@ class ROOTSerialized
 };
 
 template <typename T, typename HintType = void>
+  requires(!std::is_pointer_v<T> && (std::same_as<HintType, const char> ||
+                                     std::same_as<HintType, TClass> ||
+                                     std::is_void_v<HintType>))
 class CCDBSerialized
 {
  public:
@@ -74,9 +78,6 @@ class CCDBSerialized
   using wrapped_type = T;
   using hint_type = HintType;
 
-  static_assert(std::is_pointer<T>::value == false, "wrapped type can not be a pointer");
-  static_assert(std::is_pointer<HintType>::value == false, "hint type can not be a pointer");
-
   CCDBSerialized() = delete;
   CCDBSerialized(wrapped_type& ref, hint_type* hint = nullptr) : mRef(ref), mHint(hint) {}
 

From c6b7d8bf9c997a631449da7a98ad7e37d67bc151 Mon Sep 17 00:00:00 2001
From: atriolo <andrea.sofia.triolo@cern.ch>
Date: Mon, 19 Jan 2026 16:33:45 +0100
Subject: [PATCH 1237/1764] ALICE3-TRK: added possibility to use a local
 response file during digitization

---
 .../ALICE3/TRK/base/include/TRKBase/Specs.h   |  8 ++++++
 .../include/TRKSimulation/Digitizer.h         |  5 ++++
 .../ALICE3/TRK/simulation/src/DigiParams.cxx  |  3 +++
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   | 25 +++++++++++++-----
 .../src/TRKDigitizerSpec.cxx                  | 26 +++++++++++++++++--
 5 files changed, 59 insertions(+), 8 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index a5a60422f77eb..95f9f9b00d7f3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -131,6 +131,14 @@ constexpr double responseYShift{15.5 * mu};
 constexpr double thickness{45 * mu};
 } // namespace apts
 
+namespace alice3resp /// parameters for the alice3 chip response
+{
+constexpr double pitchX{10.0 * mu};
+constexpr double pitchZ{10.0 * mu};
+constexpr double responseYShift{5 * mu}; /// center of the epitaxial layer
+constexpr double thickness{20 * mu};
+} // namespace alice3resp
+
 } // namespace o2::trk::constants
 
 #endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
index 221d7b342bf59..362de63fb8cb6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
@@ -45,6 +45,7 @@ class Digitizer
   void setDigits(std::vector<o2::itsmft::Digit>* dig) { mDigits = dig; }
   void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
   void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
+  void setResponseName(const std::string& name) { mRespName = name; }
 
   o2::trk::DigiParams& getParams() { return (o2::trk::DigiParams&)mParams; }
   const o2::trk::DigiParams& getParams() const { return mParams; }
@@ -136,6 +137,8 @@ class Digitizer
   uint32_t mROFrameMax = 0; ///< highest RO frame of current digits
   uint32_t mNewROFrame = 0; ///< ROFrame corresponding to provided time
 
+  bool mIsBeforeFirstRO = false;
+
   uint32_t mEventROFrameMin = 0xffffffff; ///< lowest RO frame for processed events (w/o automatic noise ROFs)
   uint32_t mEventROFrameMax = 0;          ///< highest RO frame forfor processed events (w/o automatic noise ROFs)
 
@@ -145,6 +148,8 @@ class Digitizer
   const o2::trk::ChipSimResponse* mChipSimRespVD = nullptr;   // simulated response for VD chips
   const o2::trk::ChipSimResponse* mChipSimRespMLOT = nullptr; // simulated response for ML/OT chips
 
+  std::string mRespName; /// APTS or ALICE3, depending on the response to be used
+
   bool mSimRespOrientation{false};   // wether the orientation in the response function is flipped
   float mSimRespVDShift{0.f};        // adjusting the Y-shift in the APTS response function to match sensor local coord.
   float mSimRespVDScaleX{1.f};       // scale x-local coordinate to response function x-coordinate
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
index ca4685d53de2a..e2a78702204e5 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
@@ -74,6 +74,9 @@ void DigiParams::print() const
 
 void DigiParams::setAlpSimResponse(const o2::itsmft::AlpideSimResponse* resp)
 {
+  LOG(debug) << "Response function data path: " << resp->getDataPath();
+  LOG(debug) << "Response function info: ";
+  // resp->print();
   if (!resp) {
     LOGP(fatal, "cannot set response function from null");
   }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 7c988faebf2df..0fd8c7820ce28 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -49,7 +49,7 @@ void Digitizer::init()
     }
   }
 
-  // setting the correct response function (for the moment, for both VD and MLOT the APTS response function is udes)
+  // setting the correct response function (for the moment, for both VD and MLOT the same response function is used)
   mChipSimResp = mParams.getAlpSimResponse();
   mChipSimRespVD = mChipSimResp;   /// for the moment considering the same response
   mChipSimRespMLOT = mChipSimResp; /// for the moment considering the same response
@@ -65,11 +65,24 @@ void Digitizer::init()
   float thicknessVD = 0.0095;                                            // cm --- hardcoded based on geometry currently present
   float thicknessMLOT = o2::trk::SegmentationChip::SiliconThicknessMLOT; // 0.01 cm = 100 um --- based on geometry currently present
 
-  mSimRespVDScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowVD;
-  mSimRespVDScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColVD;
-  mSimRespVDShift = mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -45. Must add 10 um (= max depth) to match the APTS response.
-  mSimRespMLOTScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowMLOT;
-  mSimRespMLOTScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColMLOT;
+  LOG(info) << "Using response name: " << mRespName;
+
+  if (mRespName == "APTS") { // default
+    mSimRespVDScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowVD;
+    mSimRespVDScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColVD;
+    mSimRespVDShift = mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -45. Must add ~10 um (= max depth) to match the APTS response.
+    mSimRespMLOTScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowMLOT;
+    mSimRespMLOTScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColMLOT;
+  } else if (mRespName == "ALICE3") {
+    mSimRespVDScaleX = o2::trk::constants::alice3resp::pitchX / o2::trk::SegmentationChip::PitchRowVD;
+    mSimRespVDScaleZ = o2::trk::constants::alice3resp::pitchZ / o2::trk::SegmentationChip::PitchColVD;
+    mSimRespVDShift = mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -95 um. Must align the start of epi layer with the response function.
+    mSimRespMLOTScaleX = o2::trk::constants::alice3resp::pitchX / o2::trk::SegmentationChip::PitchRowMLOT;
+    mSimRespMLOTScaleZ = o2::trk::constants::alice3resp::pitchZ / o2::trk::SegmentationChip::PitchColMLOT;
+  } else {
+    LOG(fatal) << "Unknown response name: " << mRespName;
+  }
+
   mSimRespMLOTShift = mChipSimRespMLOT->getDepthMax() - thicknessMLOT / 2.f; // the shift should be done considering the rescaling done to adapt to the wrong silicon thickness. TODO: remove the scaling factor for the depth when the silicon thickness match the simulated response
   mSimRespOrientation = false;
 
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
index a3d4d1f245fc5..30f9d33983712 100644
--- a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
@@ -34,6 +34,7 @@
 #include <TChain.h>
 #include <TStopwatch.h>
 
+#include <memory>
 #include <string>
 
 using namespace o2::framework;
@@ -68,6 +69,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
   void initDigitizerTask(framework::InitContext& ic) override
   {
     mDisableQED = ic.options().get<bool>("disable-qed");
+    mLocalRespFile = ic.options().get<std::string>("local-response-file");
   }
 
   void run(framework::ProcessingContext& pc)
@@ -200,6 +202,15 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     mFinished = true;
   }
 
+  void setLocalResponseFunction()
+  {
+    std::unique_ptr<TFile> file(TFile::Open(mLocalRespFile.data(), "READ"));
+    if (!file) {
+      LOG(fatal) << "Cannot open response file " << mLocalRespFile;
+    }
+    mDigitizer.getParams().setAlpSimResponse((const o2::itsmft::AlpideSimResponse*)file->Get("response1"));
+  }
+
   void updateTimeDependentParams(ProcessingContext& pc)
   {
     static bool initOnce{false};
@@ -267,7 +278,15 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     // }
     if (matcher == ConcreteDataMatcher(mOrigin, "APTSRESP", 0)) {
       LOG(info) << mID.getName() << " loaded APTSResponseData";
-      mDigitizer.getParams().setAlpSimResponse((const o2::itsmft::AlpideSimResponse*)obj);
+      if (mLocalRespFile.empty()) {
+        LOG(info) << "Using CCDB/APTS response file";
+        mDigitizer.getParams().setAlpSimResponse((const o2::itsmft::AlpideSimResponse*)obj);
+        mDigitizer.setResponseName("APTS");
+      } else {
+        LOG(info) << "Response function will be loaded from local file: " << mLocalRespFile;
+        setLocalResponseFunction();
+        mDigitizer.setResponseName("ALICE3");
+      }
     }
   }
 
@@ -275,6 +294,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
   bool mWithMCTruth{true};
   bool mFinished{false};
   bool mDisableQED{false};
+  std::string mLocalRespFile{""};
   const o2::detectors::DetID mID{o2::detectors::DetID::TRK};
   const o2::header::DataOrigin mOrigin{o2::header::gDataOriginTRK};
   o2::trk::Digitizer mDigitizer{};
@@ -307,7 +327,9 @@ DataProcessorSpec getTRKDigitizerSpec(int channel, bool mctruth)
   return DataProcessorSpec{detStr + "Digitizer",
                            inputs, makeOutChannels(detOrig, mctruth),
                            AlgorithmSpec{adaptFromTask<TRKDPLDigitizerTask>(mctruth)},
-                           Options{{"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
+                           Options{
+                             {"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}},
+                             {"local-response-file", o2::framework::VariantType::String, "", {"use response file saved locally at this path/filename"}}}};
 }
 
 } // namespace o2::trk

From a09a567d02caea8d4d10219dd82243f72144c4a5 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 27 Jan 2026 14:50:19 +0100
Subject: [PATCH 1238/1764] DPL Analysis: Use dangling edges context in more
 places (#14988)

---
 .../AnalysisSupport/src/AODWriterHelpers.cxx  | 21 +++--
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   | 58 +++++++-------
 .../CCDBSupport/src/AnalysisCCDBHelpers.h     |  2 +-
 .../Core/include/Framework/AnalysisTask.h     |  4 +-
 Framework/Core/src/AnalysisSupportHelpers.cxx |  4 +-
 Framework/Core/src/ArrowSupport.cxx           | 27 +------
 Framework/Core/src/WorkflowHelpers.cxx        | 79 +++++++++----------
 Framework/Core/src/WorkflowHelpers.h          |  3 +
 8 files changed, 87 insertions(+), 111 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index d868b7498fb76..b76ffca13977e 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -62,13 +62,13 @@ const static std::unordered_map<OutputObjHandlingPolicy, std::string> ROOTfileNa
 
 AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
 {
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
   auto dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
   int compressionLevel = 505;
   if (ctx.options().hasOption("aod-writer-compression")) {
     compressionLevel = ctx.options().get<int>("aod-writer-compression");
   }
-  return AlgorithmSpec{[dod, outputInputs = ac.outputsInputsAOD, compressionLevel](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+  return AlgorithmSpec{[dod, compressionLevel](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+    auto outputInputs = ic.services().get<DanglingEdgesContext>().outputsInputsAOD;
     LOGP(debug, "======== getGlobalAODSink::Init ==========");
 
     // find out if any table needs to be saved
@@ -241,14 +241,13 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
   };
 }
 
-AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
+AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& /*ctx*/)
 {
-  using namespace monitoring;
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
-  auto tskmap = ac.outTskMap;
-  auto objmap = ac.outObjHistMap;
-
-  return AlgorithmSpec{[objmap, tskmap](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+  return AlgorithmSpec{[](InitContext& ic) -> std::function<void(ProcessingContext&)> {
+    using namespace monitoring;
+    auto& dec = ic.services().get<DanglingEdgesContext>();
+    auto tskmap = dec.outTskMap;
+    auto objmap = dec.outObjHistMap;
     auto& callbacks = ic.services().get<CallbackService>();
     auto inputObjects = std::make_shared<std::vector<std::pair<InputObjectRoute, InputObject>>>();
 
@@ -278,7 +277,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
 
     callbacks.set<CallbackService::Id::EndOfStream>(endofdatacb);
     return [inputObjects, objmap, tskmap](ProcessingContext& pc) mutable -> void {
-      auto mergePart = [&inputObjects, &objmap, &tskmap, &pc](DataRef const& ref) {
+      auto mergePart = [&inputObjects, &objmap, &tskmap](DataRef const& ref) {
         O2_SIGNPOST_ID_GENERATE(hid, histogram_registry);
         O2_SIGNPOST_START(histogram_registry, hid, "mergePart", "Merging histogram");
         if (!ref.header) {
@@ -474,7 +473,7 @@ AlgorithmSpec AODWriterHelpers::getOutputObjHistWriter(ConfigContext const& ctx)
       };
       O2_SIGNPOST_ID_GENERATE(rid, histogram_registry);
       O2_SIGNPOST_START(histogram_registry, rid, "processParts", "Start merging %zu parts received together.", pc.inputs().getNofParts(0));
-      for (int pi = 0; pi < pc.inputs().getNofParts(0); ++pi) {
+      for (auto pi = 0U; pi < pc.inputs().getNofParts(0); ++pi) {
         mergePart(pc.inputs().get("x", pi));
       }
       O2_SIGNPOST_END(histogram_registry, rid, "processParts", "Done histograms in multipart message.");
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index 9ec911518f754..ea13d412cd0b8 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -67,38 +67,38 @@ void fillValidRoutes(CCDBFetcherHelper& helper, std::vector<o2::framework::Outpu
 }
 } // namespace
 
-AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
+AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
 {
-  auto& ac = ctx.services().get<DanglingEdgesContext>();
-  std::vector<std::shared_ptr<arrow::Schema>> schemas;
-  auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
+  return adaptStateful([](ConfigParamRegistry const& options, DeviceSpec const& spec, InitContext& ic) {
+    auto& dec = ic.services().get<DanglingEdgesContext>();
+    std::vector<std::shared_ptr<arrow::Schema>> schemas;
+    auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
 
-  for (auto& input : ac.analysisCCDBInputs) {
-    std::vector<std::shared_ptr<arrow::Field>> fields;
-    schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
-    schemaMetadata->Append("outputBinding", input.binding);
+    for (auto& input : dec.analysisCCDBInputs) {
+      std::vector<std::shared_ptr<arrow::Field>> fields;
+      schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
+      schemaMetadata->Append("outputBinding", input.binding);
 
-    for (auto& m : input.metadata) {
-      // Save the list of input tables
-      if (m.name.starts_with("input:")) {
-        auto name = m.name.substr(6);
-        schemaMetadata->Append("sourceTable", name);
-        schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
-        continue;
-      }
-      // Ignore the non ccdb: entries
-      if (!m.name.starts_with("ccdb:")) {
-        continue;
+      for (auto& m : input.metadata) {
+        // Save the list of input tables
+        if (m.name.starts_with("input:")) {
+          auto name = m.name.substr(6);
+          schemaMetadata->Append("sourceTable", name);
+          continue;
+        }
+        // Ignore the non ccdb: entries
+        if (!m.name.starts_with("ccdb:")) {
+          continue;
+        }
+        // Create the schema of the output
+        auto metadata = std::make_shared<arrow::KeyValueMetadata>();
+        metadata->Append("url", m.defaultValue.asString());
+        auto columnName = m.name.substr(strlen("ccdb:"));
+        fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
       }
-      // Create the schema of the output
-      auto metadata = std::make_shared<arrow::KeyValueMetadata>();
-      metadata->Append("url", m.defaultValue.asString());
-      auto columnName = m.name.substr(strlen("ccdb:"));
-      fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
+      schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
     }
-    schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
-  }
-  return adaptStateful([schemas](CallbackService& callbacks, ConfigParamRegistry const& options, DeviceSpec const& spec) {
+
     std::shared_ptr<CCDBFetcherHelper> helper = std::make_shared<CCDBFetcherHelper>();
     CCDBFetcherHelper::initialiseHelper(*helper, options);
     std::unordered_map<std::string, int> bindings;
@@ -129,11 +129,11 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& ctx)
         int outputRouteIndex = bindings.at(outRouteDesc);
         auto& spec = helper->routes[outputRouteIndex].matcher;
         std::vector<std::shared_ptr<arrow::BinaryViewBuilder>> builders;
-        for (auto& _ : schema->fields()) {
+        for (auto const& _ : schema->fields()) {
           builders.emplace_back(std::make_shared<arrow::BinaryViewBuilder>());
         }
 
-        for (size_t ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
+        for (auto ci = 0; ci < timestampColumn->num_chunks(); ++ci) {
           std::shared_ptr<arrow::Array> chunk = timestampColumn->chunk(ci);
           auto const* timestamps = chunk->data()->GetValuesSafe<size_t>(1);
 
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
index f8175034da0ba..3be2138bd2b5c 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.h
@@ -17,7 +17,7 @@ namespace o2::framework
 {
 
 struct AnalysisCCDBHelpers {
-  static AlgorithmSpec fetchFromCCDB(ConfigContext const& ctx);
+  static AlgorithmSpec fetchFromCCDB(ConfigContext const&);
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index c50b5358990de..4f8a9e719e4b9 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -521,7 +521,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<ExpressionInfo> expressionInfos;
 
   /// make sure options and configurables are set before expression infos are created
-  homogeneous_apply_refs([&options, &hash](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
+  homogeneous_apply_refs([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
   /// extract conditions and append them as inputs
   homogeneous_apply_refs([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
 
@@ -620,7 +620,7 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
       }
       // reset pre-slice for the next dataframe
       auto slices = pc.services().get<ArrowTableSlicingCache>();
-      homogeneous_apply_refs([&pc, &slices](auto& element) {
+      homogeneous_apply_refs([&slices](auto& element) {
         return analysis_task_parsers::updateSliceInfo(element, slices);
       },
                              *(task.get()));
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index 15b56f9afbff5..7453751315626 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -98,7 +98,7 @@ std::shared_ptr<DataOutputDirector> AnalysisSupportHelpers::getDataOutputDirecto
     if (!keepString.empty()) {
       dod->reset();
       std::string d("dangling");
-      if (d.find(keepString) == 0) {
+      if (keepString.starts_with(d)) {
         // use the dangling outputs
         std::vector<InputSpec> danglingOutputs;
         for (auto ii = 0u; ii < OutputsInputs.size(); ii++) {
@@ -144,7 +144,7 @@ void AnalysisSupportHelpers::addMissingOutputsToSpawner(std::vector<OutputSpec>
     sinks::append_to{publisher.outputs}; // append them to the publisher outputs
 
   std::vector<InputSpec> additionalInputs;
-  for (auto& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
+  for (auto const& input : requestedSpecials | views::filter_not_matching(providedSpecials)) {
     input.metadata |
       views::filter_string_params_with("input:") |
       views::params_to_input_specs() |
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 60277dfc38a74..31cddc9803d69 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -685,33 +685,8 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         }
       }
 
-      // replace writer as some outputs may have become dangling and some are now consumed
-      auto [outputsInputs, isDangling] = WorkflowHelpers::analyzeOutputs(workflow);
-
-      // create DataOutputDescriptor
-      std::shared_ptr<DataOutputDirector> dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
-
-      // select outputs of type AOD which need to be saved
-      // ATTENTION: if there are dangling outputs the getGlobalAODSink
-      // has to be created in any case!
-      dec.outputsInputsAOD.clear();
-
-      for (auto ii = 0u; ii < outputsInputs.size(); ii++) {
-        if (DataSpecUtils::partialMatch(outputsInputs[ii], extendedAODOrigins)) {
-          auto ds = dod->getDataOutputDescriptors(outputsInputs[ii]);
-          if (!ds.empty() || isDangling[ii]) {
-            dec.outputsInputsAOD.emplace_back(outputsInputs[ii]);
-          }
-        }
-      }
+      WorkflowHelpers::injectAODWriter(workflow, ctx);
 
-      // file sink for any AOD output
-      if (!dec.outputsInputsAOD.empty()) {
-        // add TFNumber and TFFilename as input to the writer
-        dec.outputsInputsAOD.emplace_back("tfn", "TFN", "TFNumber");
-        dec.outputsInputsAOD.emplace_back("tff", "TFF", "TFFilename");
-        workflow.push_back(AnalysisSupportHelpers::getGlobalAODSink(ctx));
-      }
       // Move the dummy sink at the end, if needed
       for (size_t i = 0; i < workflow.size(); ++i) {
         if (workflow[i].name == "internal-dpl-injected-dummy-sink") {
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index ff1ff1f4cf13d..714706952d26c 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -420,10 +420,10 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       // AODs are being injected on-the-fly, add error-handler reader
       aodReader.algorithm = AlgorithmSpec{
         adaptStateful(
-          [outputs = aodReader.outputs](DeviceSpec const&) {
+          [](DeviceSpec const& spec) {
             LOGP(warn, "Workflow with injected AODs has unsatisfied inputs:");
-            for (auto const& output : outputs) {
-              LOGP(warn, "  {}", DataSpecUtils::describe(output));
+            for (auto const& output : spec.outputs) {
+              LOGP(warn, "  {}", DataSpecUtils::describe(output.matcher));
             }
             LOGP(fatal, "Stopping.");
             // to ensure the output type for adaptStateful
@@ -531,43 +531,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   workflow.insert(workflow.end(), extraSpecs.begin(), extraSpecs.end());
   extraSpecs.clear();
 
-  /// Analyze all ouputs
-  auto [outputsInputsTmp, isDanglingTmp] = analyzeOutputs(workflow);
-  dec.isDangling = isDanglingTmp;
-  dec.outputsInputs = outputsInputsTmp;
-
-  // create DataOutputDescriptor
-  std::shared_ptr<DataOutputDirector> dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
-
-  // select outputs of type AOD which need to be saved
-  // ATTENTION: if there are dangling outputs the getGlobalAODSink
-  // has to be created in any case!
-  for (auto ii = 0u; ii < dec.outputsInputs.size(); ii++) {
-    if (DataSpecUtils::partialMatch(dec.outputsInputs[ii], extendedAODOrigins)) {
-      auto ds = dod->getDataOutputDescriptors(dec.outputsInputs[ii]);
-      if (ds.size() > 0 || dec.isDangling[ii]) {
-        dec.outputsInputsAOD.emplace_back(dec.outputsInputs[ii]);
-      }
-    }
-  }
-
-  // file sink for any AOD output
-  if (dec.outputsInputsAOD.size() > 0) {
-    // add TFNumber and TFFilename as input to the writer
-    dec.outputsInputsAOD.emplace_back(InputSpec{"tfn", "TFN", "TFNumber"});
-    dec.outputsInputsAOD.emplace_back(InputSpec{"tff", "TFF", "TFFilename"});
-    auto fileSink = AnalysisSupportHelpers::getGlobalAODSink(ctx);
-    extraSpecs.push_back(fileSink);
-
-    auto it = std::ranges::find_if(dec.outputsInputs, [](InputSpec& spec) -> bool {
-      return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
-    });
-    size_t ii = std::distance(dec.outputsInputs.begin(), it);
-    dec.isDangling[ii] = false;
-  }
-
-  workflow.insert(workflow.end(), extraSpecs.begin(), extraSpecs.end());
-  extraSpecs.clear();
+  injectAODWriter(workflow, ctx);
 
   // Select dangling outputs which are not of type AOD
   std::vector<InputSpec> redirectedOutputsInputs;
@@ -704,6 +668,41 @@ void WorkflowHelpers::adjustTopology(WorkflowSpec& workflow, ConfigContext const
   }
 }
 
+void WorkflowHelpers::injectAODWriter(WorkflowSpec& workflow, ConfigContext const& ctx)
+{
+  auto& dec = ctx.services().get<DanglingEdgesContext>();
+  /// Analyze all ouputs
+  std::tie(dec.outputsInputs, dec.isDangling) = analyzeOutputs(workflow);
+
+  // create DataOutputDescriptor
+  std::shared_ptr<DataOutputDirector> dod = AnalysisSupportHelpers::getDataOutputDirector(ctx);
+
+  // select outputs of type AOD which need to be saved
+  dec.outputsInputsAOD.clear();
+  for (auto ii = 0u; ii < dec.outputsInputs.size(); ii++) {
+    if (DataSpecUtils::partialMatch(dec.outputsInputs[ii], extendedAODOrigins)) {
+      auto ds = dod->getDataOutputDescriptors(dec.outputsInputs[ii]);
+      if (ds.size() > 0 || dec.isDangling[ii]) {
+        dec.outputsInputsAOD.emplace_back(dec.outputsInputs[ii]);
+      }
+    }
+  }
+
+  // file sink for any AOD output
+  if (dec.outputsInputsAOD.size() > 0) {
+    // add TFNumber and TFFilename as input to the writer
+    DataSpecUtils::updateInputList(dec.outputsInputsAOD, InputSpec{"tfn", "TFN", "TFNumber"});
+    DataSpecUtils::updateInputList(dec.outputsInputsAOD, InputSpec{"tff", "TFF", "TFFilename"});
+    auto fileSink = AnalysisSupportHelpers::getGlobalAODSink(ctx);
+    workflow.push_back(fileSink);
+
+    auto it = std::find_if(dec.outputsInputs.begin(), dec.outputsInputs.end(), [](InputSpec const& spec) -> bool {
+      return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
+    });
+    dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
+  }
+}
+
 void WorkflowHelpers::constructGraph(const WorkflowSpec& workflow,
                                      std::vector<DeviceConnectionEdge>& logicalEdges,
                                      std::vector<OutputSpec>& outputs,
diff --git a/Framework/Core/src/WorkflowHelpers.h b/Framework/Core/src/WorkflowHelpers.h
index b2a4d4cab55df..5c0aa363c6d67 100644
--- a/Framework/Core/src/WorkflowHelpers.h
+++ b/Framework/Core/src/WorkflowHelpers.h
@@ -182,6 +182,9 @@ struct WorkflowHelpers {
   // @a ctx the context for the configuration phase
   static void injectServiceDevices(WorkflowSpec& workflow, ConfigContext& ctx);
 
+  // Function to correctly add AOD writer
+  static void injectAODWriter(WorkflowSpec& workflow, ConfigContext const& ctx);
+
   // Final adjustments to @a workflow after service devices have been injected.
   static void adjustTopology(WorkflowSpec& workflow, ConfigContext const& ctx);
 

From efad2290e1efb36f28e1c84c7e062525a919eb76 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 27 Jan 2026 13:39:03 +0100
Subject: [PATCH 1239/1764] ITSMFT: fix number of rofs per TF

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
index 6809c8dee3f19..eafb72c675a58 100644
--- a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
@@ -184,8 +184,10 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
         // it can happen that in the digitization rofs without contributing hits are skipped
         // however downstream consumers of the clusters cannot know apriori the time structure
         // the cluster rofs do not account for the bias so it will start always at BC=0
-        std::vector<o2::itsmft::ROFRecord> expDigitRofVec(nROFsTF);
-        for (int iROF{0}; iROF < nROFsTF; ++iROF) {
+        // also have to account for spillage into next TF
+        const size_t nROFsLayer = std::max((size_t)nROFsTF, mROFRecordsAccum[iLayer].size());
+        std::vector<o2::itsmft::ROFRecord> expDigitRofVec(nROFsLayer);
+        for (int iROF{0}; iROF < nROFsLayer; ++iROF) {
           auto& rof = expDigitRofVec[iROF];
           int orb = iROF * DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer) / o2::constants::lhc::LHCMaxBunches + mFirstOrbitTF;
           int bc = iROF * DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches;
@@ -204,7 +206,7 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
           expROF.setFirstEntry(rof.getFirstEntry());
           expROF.setNEntries(rof.getNEntries());
           if (expROF.getBCData() != rof.getBCData()) {
-            LOGP(fatal, "detected mismatch between expected ROF:{} and received ROF:{}", expROF.asString(), rof.asString());
+            LOGP(fatal, "detected mismatch between expected {} and received {}", expROF.asString(), rof.asString());
           }
         }
         int prevFirst{0};
@@ -214,6 +216,9 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
           }
           prevFirst = rof.getFirstEntry();
         }
+        // if more rofs where accumulated than ROFs possible in the TF, cut them away
+        // by construction expDigitRofVec is at least nROFsTF long
+        expDigitRofVec.resize(nROFsTF);
         pc.outputs().snapshot(Output{Origin, "DIGITSROF", iLayer}, expDigitRofVec);
       } else {
         pc.outputs().snapshot(Output{Origin, "DIGITSROF", iLayer}, mROFRecordsAccum[iLayer]);

From 0cf7ec22173e7817599b997d189328ba65ecabc4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 27 Jan 2026 21:10:07 +0100
Subject: [PATCH 1240/1764] GPU CMake: Improve architecture auto-detection

---
 dependencies/FindO2GPU.cmake | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 6ca311905e01c..21e2d7cad239a 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,12 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 8
+# FindO2GPU.cmake Version 9
+
+set(CUDA_COMPUTETARGET_DEFAULT_FULL 80-real 86-real 89-real 120-real 75-virtual)
+set(HIP_AMDGPUTARGET_DEFAULT_FULL gfx906;gfx908)
+set(CUDA_COMPUTETARGET_DEFAULT_MINIMAL 75-virtual)
+set(HIP_AMDGPUTARGET_DEFAULT_MINIMAL gfx906)
 
 if(NOT DEFINED ENABLE_CUDA)
   set(ENABLE_CUDA "AUTO")
@@ -32,11 +37,11 @@ if(CMAKE_BUILD_TYPE_UPPER STREQUAL "DEBUG")
 endif()
 
 if(CUDA_COMPUTETARGET AND CUDA_COMPUTETARGET STREQUAL "default")
-  set(CUDA_COMPUTETARGET 80-real 86-real 89-real 120-real 75-virtual)
+  set(CUDA_COMPUTETARGET ${CUDA_COMPUTETARGET_DEFAULT_FULL})
 endif()
 
 if(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET STREQUAL "default")
-  set(HIP_AMDGPUTARGET gfx906;gfx908)
+  set(HIP_AMDGPUTARGET ${HIP_AMDGPUTARGET_DEFAULT_FULL})
 endif()
 
 function(set_target_cuda_arch target)
@@ -112,7 +117,7 @@ if(ENABLE_CUDA)
   if(CUDA_COMPUTETARGET)
     set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET})
   else()
-    set(CMAKE_CUDA_ARCHITECTURES 75-virtual)
+    set(O2_GPU_CUDA_UPDATE_NATIVE_ARCHITECTURE 1)
   endif()
   set(CMAKE_CUDA_STANDARD ${CMAKE_CXX_STANDARD})
   set(CMAKE_CUDA_STANDARD_REQUIRED TRUE)
@@ -156,6 +161,13 @@ if(ENABLE_CUDA)
       set(CMAKE_CUDA_COMPILER OFF)
     endif()
   endif()
+  if(NOT CMAKE_CUDA_ARCHITECTURES OR O2_GPU_CUDA_UPDATE_NATIVE_ARCHITECTURE)
+    if(NOT CMAKE_CUDA_ARCHITECTURES_NATIVE STREQUAL "")
+      set(CMAKE_CUDA_ARCHITECTURES ${CMAKE_CUDA_ARCHITECTURES_NATIVE})
+    else()
+      set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET_DEFAULT_MINIMAL})
+    endif()
+  endif()
   if(CMAKE_CUDA_COMPILER)
     set(CMAKE_CUDA_FLAGS "-Xcompiler \"${O2_GPU_CMAKE_CXX_FLAGS_NOSTD}\" ${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr --extended-lambda -Xcompiler -Wno-attributes -Wno-deprecated-gpu-targets ${GPUCA_CUDA_DENORMALS_FLAGS}")
     set(CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "-Xcompiler \"${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}\" ${CMAKE_CUDA_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
@@ -184,7 +196,7 @@ if(ENABLE_CUDA)
     endif()
 
     set(CUDA_ENABLED ON)
-    message(STATUS "CUDA found (Version ${CMAKE_CUDA_COMPILER_VERSION})")
+    message(STATUS "CUDA found (Version ${CMAKE_CUDA_COMPILER_VERSION}, Architectures ${CMAKE_CUDA_ARCHITECTURES})")
   elseif(NOT ENABLE_CUDA STREQUAL "AUTO")
     message(FATAL_ERROR "CUDA not found (Compiler: ${CMAKE_CUDA_COMPILER})")
   else()
@@ -305,7 +317,6 @@ if(ENABLE_HIP)
   if(hip_FOUND AND hipcub_FOUND AND rocthrust_FOUND AND rocprim_FOUND AND hip_HIPCC_EXECUTABLE AND hip_HIPIFY_PERL_EXECUTABLE)
     set(HIP_ENABLED ON)
     set_target_properties(roc::rocthrust PROPERTIES IMPORTED_GLOBAL TRUE)
-    message(STATUS "HIP Found (${hip_HIPCC_EXECUTABLE} version ${hip_VERSION})")
     set(CMAKE_HIP_FLAGS "${O2_GPU_CMAKE_CXX_FLAGS_NOSTD} ${CMAKE_HIP_FLAGS} ${GPUCA_HIP_DENORMALS_FLAGS}")
     set(CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER} "${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}} ${CMAKE_HIP_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}")
     string(APPEND CMAKE_HIP_FLAGS " -fgpu-defer-diag -mllvm -amdgpu-enable-lower-module-lds=false -mllvm -amdgpu-function-calls=true -Wno-invalid-command-line-argument -Wno-unused-command-line-argument -Wno-invalid-constexpr -Wno-ignored-optimization-argument -Wno-unused-private-field -Wno-pass-failed ")
@@ -321,6 +332,7 @@ if(ENABLE_HIP)
     if(HIP_AMDGPUTARGET)
       set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}")
     endif()
+    message(STATUS "HIP Found (${hip_HIPCC_EXECUTABLE} version ${hip_VERSION}, Architectures ${CMAKE_HIP_ARCHITECTURES})")
   else()
     set(HIP_ENABLED OFF)
   endif()

From cb66b5edfc8322bc792b255368e52a897066c76a Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Wed, 28 Jan 2026 09:53:51 +0100
Subject: [PATCH 1241/1764] Add extra info with charge and timing and occupancy
 to unbinned residuals (#14969)

* Add extra info with charge and timing to unbinned residuals

* Store TOF time wrt t0 in DetInfoRes, diff to expectation in trackData.deltaTOF

* Add per-stack TPC mult info to TrackData
---
 .../tpcinterpolationworkflow/CMakeLists.txt   |   2 +
 .../TPCResidualAggregatorSpec.h               |   6 +-
 .../TPCUnbinnedResidualReaderSpec.h           |   1 +
 .../src/TPCInterpolationSpec.cxx              |  15 +-
 .../src/TPCResidualWriterSpec.cxx             |   1 +
 .../src/TPCUnbinnedResidualReaderSpec.cxx     |   7 +
 .../calibration/SpacePoints/CMakeLists.txt    |   3 +-
 .../include/SpacePoints/ResidualAggregator.h  |   3 +-
 .../include/SpacePoints/TrackInterpolation.h  |  95 ++++++++++-
 .../SpacePoints/src/ResidualAggregator.cxx    |  10 +-
 .../SpacePoints/src/SpacePointCalibLinkDef.h  |   2 +
 .../SpacePoints/src/TrackInterpolation.cxx    | 154 ++++++++++++++++--
 12 files changed, 269 insertions(+), 30 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/CMakeLists.txt b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/CMakeLists.txt
index c8db0209d4471..09ec6081b06b8 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/CMakeLists.txt
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/CMakeLists.txt
@@ -9,6 +9,8 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
+# add_compile_options(-O0 -g -fPIC -fno-omit-frame-pointer)
+
 o2_add_library(TPCInterpolationWorkflow
                SOURCES src/TPCInterpolationSpec.cxx
                        src/TPCResidualWriterSpec.cxx
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h
index b9c99f9e65676..99f20e390a09a 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCResidualAggregatorSpec.h
@@ -128,8 +128,9 @@ class ResidualAggregatorDevice : public o2::framework::Task
     updateTimeDependentParams(pc);
     std::chrono::duration<double, std::milli> ccdbUpdateTime = std::chrono::high_resolution_clock::now() - runStartTime;
 
-    // we always require the unbinned residuals and the associated track references
+    // we always require the unbinned residuals and the associated detector info and track references
     auto residualsData = pc.inputs().get<gsl::span<o2::tpc::UnbinnedResid>>("unbinnedRes");
+    auto residualsDataDet = pc.inputs().get<gsl::span<o2::tpc::DetInfoResid>>("detinfoRes");
     auto trackRefs = pc.inputs().get<gsl::span<o2::tpc::TrackDataCompact>>("trackRefs");
 
     // track data input is optional
@@ -151,7 +152,7 @@ class ResidualAggregatorDevice : public o2::framework::Task
 
     o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mAggregator->getCurrentTFInfo());
     LOG(detail) << "Processing TF " << mAggregator->getCurrentTFInfo().tfCounter << " with " << trkData->size() << " tracks and " << residualsData.size() << " unbinned residuals associated to them";
-    mAggregator->process(residualsData, trackRefs, trkDataPtr, lumi);
+    mAggregator->process(residualsData, residualsDataDet, trackRefs, trkDataPtr, lumi);
     std::chrono::duration<double, std::milli> runDuration = std::chrono::high_resolution_clock::now() - runStartTime;
     LOGP(debug, "Duration for run method: {} ms. From this taken for time dependent param update: {} ms",
          std::chrono::duration_cast<std::chrono::milliseconds>(runDuration).count(),
@@ -222,6 +223,7 @@ DataProcessorSpec getTPCResidualAggregatorSpec(bool trackInput, bool ctpInput, b
   auto& inputs = dataRequest->inputs;
   o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
   inputs.emplace_back("unbinnedRes", "GLO", "UNBINNEDRES");
+  inputs.emplace_back("detinfoRes", "GLO", "DETINFORES");
   inputs.emplace_back("trackRefs", "GLO", "TRKREFS");
   if (trackInput) {
     inputs.emplace_back("trkData", "GLO", "TRKDATA");
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCUnbinnedResidualReaderSpec.h b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCUnbinnedResidualReaderSpec.h
index 6c40bb355eb21..724151c90576f 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCUnbinnedResidualReaderSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/include/TPCInterpolationWorkflow/TPCUnbinnedResidualReaderSpec.h
@@ -43,6 +43,7 @@ class TPCUnbinnedResidualReader : public o2::framework::Task
   std::string mInFileName;
   std::string mInTreeName;
   std::vector<UnbinnedResid> mUnbinnedResid, *mUnbinnedResidPtr = &mUnbinnedResid;
+  std::vector<DetInfoResid> mDetInfoUnbRes, *mDetInfoUnbResPtr = &mDetInfoUnbRes;
   std::vector<TrackData> mTrackData, *mTrackDataPtr = &mTrackData;
   std::vector<TrackDataCompact> mTrackDataCompact, *mTrackDataCompactPtr = &mTrackDataCompact;
 };
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
index da2fcaab913d7..4912a1df36a33 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
@@ -66,11 +66,12 @@ void TPCInterpolationDPL::updateTimeDependentParams(ProcessingContext& pc)
     initOnceDone = true;
     // other init-once stuff
     const auto& param = SpacePointsCalibConfParam::Instance();
+    mInterpolation.setSqrtS(o2::base::GRPGeomHelper::instance().getGRPLHCIF()->getSqrtS());
+    mInterpolation.setNHBPerTF(o2::base::GRPGeomHelper::getNHBFPerTF());
     mInterpolation.init(mSources, mSourcesMap);
     if (mProcessITSTPConly) {
       mInterpolation.setProcessITSTPConly();
     }
-    mInterpolation.setSqrtS(o2::base::GRPGeomHelper::instance().getGRPLHCIF()->getSqrtS());
     int nTfs = mSlotLength / (o2::base::GRPGeomHelper::getNHBFPerTF() * o2::constants::lhc::LHCOrbitMUS * 1e-6);
     bool limitTracks = (param.maxTracksPerCalibSlot < 0) ? false : true;
     int nTracksPerTfMax = (nTfs > 0 && limitTracks) ? param.maxTracksPerCalibSlot / nTfs : -1;
@@ -93,6 +94,11 @@ void TPCInterpolationDPL::updateTimeDependentParams(ProcessingContext& pc)
       mInterpolation.setProcessSeeds();
     }
     o2::its::GeometryTGeo::Instance()->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2GRot) | o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L));
+    mInterpolation.setExtDetResid(mExtDetResid);
+    mInterpolation.setITSClusterDictionary(mITSDict);
+    if (mDebugOutput) {
+      mInterpolation.setDumpTrackPoints();
+    }
   }
   // we may have other params which need to be queried regularly
   if (mTPCVDriftHelper.isUpdated()) {
@@ -103,11 +109,6 @@ void TPCInterpolationDPL::updateTimeDependentParams(ProcessingContext& pc)
     mInterpolation.setTPCVDrift(mTPCVDriftHelper.getVDriftObject());
     mTPCVDriftHelper.acknowledgeUpdate();
   }
-  if (mDebugOutput) {
-    mInterpolation.setDumpTrackPoints();
-  }
-  mInterpolation.setExtDetResid(mExtDetResid);
-  mInterpolation.setITSClusterDictionary(mITSDict);
 }
 
 void TPCInterpolationDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
@@ -143,6 +144,7 @@ void TPCInterpolationDPL::run(ProcessingContext& pc)
     }
   }
   pc.outputs().snapshot(Output{"GLO", "UNBINNEDRES", 0}, mInterpolation.getClusterResiduals());
+  pc.outputs().snapshot(Output{"GLO", "DETINFORES", 0}, mInterpolation.getClusterResidualsDetInfo());
   pc.outputs().snapshot(Output{"GLO", "TRKREFS", 0}, mInterpolation.getTrackDataCompact());
   if (mSendTrackData) {
     pc.outputs().snapshot(Output{"GLO", "TRKDATA", 0}, mInterpolation.getReferenceTracks());
@@ -188,6 +190,7 @@ DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t srcCls, GTrackID::mas
     }
   }
   outputs.emplace_back("GLO", "UNBINNEDRES", 0, Lifetime::Timeframe);
+  outputs.emplace_back("GLO", "DETINFORES", 0, Lifetime::Timeframe);
   outputs.emplace_back("GLO", "TRKREFS", 0, Lifetime::Timeframe);
   if (sendTrackData) {
     outputs.emplace_back("GLO", "TRKDATA", 0, Lifetime::Timeframe);
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCResidualWriterSpec.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCResidualWriterSpec.cxx
index 5f6d7ad7b361c..8b06444bdb9b3 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCResidualWriterSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCResidualWriterSpec.cxx
@@ -38,6 +38,7 @@ DataProcessorSpec getTPCResidualWriterSpec(bool writeTrackData, bool debugOutput
                                 BranchDefinition<std::vector<TrackData>>{InputSpec{"tracksUnfiltered", "GLO", "TPCINT_TRK", 0}, "tracksUnfiltered", ((writeUnfiltered && writeTrackData) ? 1 : 0)},
                                 BranchDefinition<std::vector<TPCClusterResiduals>>{InputSpec{"residualsUnfiltered", "GLO", "TPCINT_RES", 0}, "residualsUnfiltered", (writeUnfiltered ? 1 : 0)},
                                 BranchDefinition<std::vector<UnbinnedResid>>{InputSpec{"residuals", "GLO", "UNBINNEDRES"}, "residuals"},
+                                BranchDefinition<std::vector<DetInfoResid>>{InputSpec{"detInfo", "GLO", "DETINFORES"}, "detInfo"},
                                 BranchDefinition<std::vector<TrackDataCompact>>{InputSpec{"trackRefs", "GLO", "TRKREFS"}, "trackRefs"},
                                 BranchDefinition<std::vector<TrackData>>{InputSpec{"tracks", "GLO", "TRKDATA"}, "tracks", (writeTrackData ? 1 : 0)},
                                 BranchDefinition<std::vector<TrackDataExtended>>{InputSpec{"trackExt", "GLO", "TRKDATAEXT"}, "trackExt", (debugOutput ? 1 : 0)})();
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCUnbinnedResidualReaderSpec.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCUnbinnedResidualReaderSpec.cxx
index 55da5a5e71e44..c2dae375731a4 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCUnbinnedResidualReaderSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCUnbinnedResidualReaderSpec.cxx
@@ -44,6 +44,11 @@ void TPCUnbinnedResidualReader::connectTree()
   assert(mTreeIn);
   mTreeIn->SetBranchAddress("residuals", &mUnbinnedResidPtr);
   mTreeIn->SetBranchAddress("trackRefs", &mTrackDataCompactPtr);
+  if (mTreeIn->GetBranch("detInfo")) {
+    mTreeIn->SetBranchAddress("detInfo", &mDetInfoUnbResPtr);
+  } else {
+    LOGP(warn, "No detInfo branch found in the unbinned residuals tree, empty vector will be sent");
+  }
   if (mTrackInput) {
     mTreeIn->SetBranchAddress("tracks", &mTrackDataPtr);
   }
@@ -58,6 +63,7 @@ void TPCUnbinnedResidualReader::run(ProcessingContext& pc)
   LOG(info) << "Pushing " << mUnbinnedResid.size() << " unbinned residuals at entry " << currEntry;
   pc.outputs().snapshot(Output{"GLO", "UNBINNEDRES", 0}, mUnbinnedResid);
   pc.outputs().snapshot(Output{"GLO", "TRKREFS", 0}, mTrackDataCompact);
+  pc.outputs().snapshot(Output{"GLO", "DETINFORES", 0}, mDetInfoUnbRes);
   if (mTrackInput) {
     LOG(info) << "Pushing " << mTrackData.size() << " reference tracks for these residuals";
     pc.outputs().snapshot(Output{"GLO", "TRKDATA", 0}, mTrackData);
@@ -73,6 +79,7 @@ DataProcessorSpec getUnbinnedTPCResidualsReaderSpec(bool trkInput)
 {
   std::vector<OutputSpec> outputs;
   outputs.emplace_back("GLO", "UNBINNEDRES", 0, Lifetime::Timeframe);
+  outputs.emplace_back("GLO", "DETINFORES", 0, Lifetime::Timeframe);
   outputs.emplace_back("GLO", "TRKREFS", 0, Lifetime::Timeframe);
   if (trkInput) {
     outputs.emplace_back("GLO", "TRKDATA", 0, Lifetime::Timeframe);
diff --git a/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt b/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
index 510cff4f7760c..47bb9c09a9951 100644
--- a/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
+++ b/Detectors/TPC/calibration/SpacePoints/CMakeLists.txt
@@ -29,7 +29,8 @@ o2_add_library(SpacePoints
                                      O2::DataFormatsITSMFT
                                      O2::DataFormatsTRD
                                      O2::DataFormatsTOF
-                                     O2::DataFormatsGlobalTracking)
+                                     O2::DataFormatsGlobalTracking
+                                     O2::GPUTracking)
 
 o2_target_root_dictionary(SpacePoints
                           HEADERS include/SpacePoints/TrackResiduals.h
diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/ResidualAggregator.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/ResidualAggregator.h
index a02d830cfe45d..00af697da3a9b 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/ResidualAggregator.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/ResidualAggregator.h
@@ -49,7 +49,7 @@ struct ResidualsContainer {
   void fillStatisticsBranches();
   uint64_t getNEntries() const { return nResidualsTotal; }
 
-  void fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const UnbinnedResid> resid, const gsl::span<const o2::tpc::TrackDataCompact> trkRefsIn, const gsl::span<const o2::tpc::TrackData>* trkDataIn, const o2::ctp::LumiInfo* lumiInput);
+  void fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const UnbinnedResid> resid, const gsl::span<const DetInfoResid> detInfoRes, const gsl::span<const o2::tpc::TrackDataCompact> trkRefsIn, const gsl::span<const o2::tpc::TrackData>* trkDataIn, const o2::ctp::LumiInfo* lumiInput);
   void merge(ResidualsContainer* prev);
   void print();
   void writeToFile(bool closeFileAfterwards);
@@ -64,6 +64,7 @@ struct ResidualsContainer {
   std::vector<uint32_t> sumUnbinnedResid, *sumUnbinnedResidPtr{&sumUnbinnedResid}; ///< sum of unbinned residuals for each TF
   std::vector<o2::ctp::LumiInfo> lumi, *lumiPtr{&lumi};                      ///< luminosity information from CTP per TF
   std::vector<UnbinnedResid> unbinnedRes, *unbinnedResPtr{&unbinnedRes};     ///< unbinned residuals which are sent to the aggregator
+  std::vector<DetInfoResid> detInfoUnbRes, *detInfoUnbResPtr{&detInfoUnbRes}; ///< detector info associated to unbinned residuals which are sent to the aggregator
   std::vector<TrackData> trkData, *trkDataPtr{&trkData};                     ///< track data and cluster ranges
   std::vector<TrackDataCompact> trackInfo, *trackInfoPtr{&trackInfo};        ///< allows to obtain track type for each unbinned residual downstream
   o2::ctp::LumiInfo lumiTF;                                                  ///< for each processed TF we store the lumi information in the tree of unbinned residuals
diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
index 992925179ffce..e7d0fb197ea42 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
@@ -47,6 +47,11 @@ class TTree;
 namespace o2
 {
 
+namespace gpu
+{
+class GPUParam;
+}
+
 namespace tpc
 {
 class VDriftCorrFact;
@@ -101,15 +106,72 @@ struct UnbinnedResid {
   ClassDefNV(UnbinnedResid, 2);
 };
 
+struct DetInfoResid { // detector info associated with residual
+  uint32_t word = 0;  // container interpreted in a different way depending on the detector type
+  //
+  // TPC view: qTot and qMax of the cluster
+  uint16_t qTotTPC() const { return static_cast<uint16_t>(word & 0xFFFFu); }
+  uint16_t qMaxTPC() const { return static_cast<uint16_t>((word >> 16) & 0xFFFFu); }
+  void setTPC(uint16_t qTot, uint16_t qMax) { word = (static_cast<uint32_t>(qMax) << 16) | static_cast<uint32_t>(qTot); }
+  //
+  // TRD view: q0, q1, q2 + calibrated slope (truncated to in +-3.5 range)
+  static constexpr uint32_t TRDQ0NB = 7, TRDQ1NB = 7, TRDQ2NB = 6, TRDSlpNB = 12;
+  static constexpr uint32_t TRDQ0Msk = (1 << TRDQ0NB) - 1, TRDQ1Msk = (1 << TRDQ1NB) - 1, TRDQ2Msk = ((1 << TRDQ2NB) - 1), TRDSlpMsk = (1 << TRDSlpNB) - 1;
+  static constexpr float TRDMaxSlope = 3.5, TRDSlope2Int = ((1 << TRDSlpNB) - 1) / (2 * TRDMaxSlope), TRDInt2Slope = 1.f / TRDSlope2Int;
+  uint16_t q0TRD() const { return static_cast<uint16_t>(word & TRDQ0Msk); }
+  uint16_t q1TRD() const { return static_cast<uint16_t>((word >> TRDQ0NB) & TRDQ1Msk); }
+  uint16_t q2TRD() const { return static_cast<uint16_t>((word >> (TRDQ0NB + TRDQ1NB)) & TRDQ2Msk); }
+  float slopeTRD() const { return ((word >> (TRDQ0NB + TRDQ1NB + TRDQ2NB)) & TRDSlpMsk) * TRDInt2Slope - TRDMaxSlope; }
+  void setTRD(uint8_t q0, uint8_t q1, uint8_t q2, float slope)
+  {
+    float rslope = (slope + TRDMaxSlope) * TRDSlope2Int;
+    if (rslope < 0.f) {
+      rslope = 0;
+    } else if (rslope > TRDSlpMsk) {
+      rslope = TRDSlpMsk;
+    }
+    uint32_t slpI = std::round(rslope);
+    word = (static_cast<uint32_t>(slpI << (TRDQ0NB + TRDQ1NB + TRDQ2NB)) |
+            static_cast<uint32_t>((q2 & TRDQ2Msk) << (TRDQ0NB + TRDQ1NB)) |
+            static_cast<uint32_t>((q1 & TRDQ1Msk) << TRDQ0NB) |
+            static_cast<uint32_t>(q0 & TRDQ0Msk));
+  }
+  //
+  // TOF view (time difference in \mus wrt seeding ITS-TPC track)
+  float timeTOF() const { return std::bit_cast<float>(word); }
+  void setTOF(float t) { word = std::bit_cast<uint32_t>(t); }
+  //
+  // No info for ITS is stored
+  //
+  // PV view (time difference in \mus wrt contributing ITS-TPC track)
+  float timePV() const { return std::bit_cast<float>(word); }
+  void setPV(float t) { word = std::bit_cast<uint32_t>(t); }
+
+  ClassDefNV(DetInfoResid, 1);
+};
+
 /// Structure for the information required to associate each residual with a given track type (ITS-TPC-TRD-TOF, etc)
 struct TrackDataCompact {
   TrackDataCompact() = default;
-  TrackDataCompact(uint32_t idx, uint8_t nRes, uint8_t source, uint8_t nextraRes = 0) : idxFirstResidual(idx), nResiduals(nRes), sourceId(source), nExtDetResid(nextraRes) {}
+  TrackDataCompact(uint32_t idx, std::array<uint8_t, 4> mlt, uint8_t nRes, uint8_t source, uint8_t nextraRes = 0) : idxFirstResidual(idx), multStack{mlt}, nResiduals(nRes), sourceId(source), nExtDetResid(nextraRes) {}
   uint32_t idxFirstResidual; ///< the index of the first residual from this track
+  std::array<uint8_t, 4> multStack{}; // multiplicity in the stack packed as asinh(x*0.05)/0.05
   uint8_t nResiduals;        ///< total number of TPC residuals associated to this track
   uint8_t nExtDetResid = 0;  ///< number of external detectors (wrt TPC) residuals stored, on top of clIdx.getEntries
   uint8_t sourceId;          ///< source ID obtained from the global track ID
-  ClassDefNV(TrackDataCompact, 2);
+
+  void setMultStack(float v, int stack)
+  {
+    uint32_t mltPacked = std::round(std::asinh(v * 0.05) / 0.05);
+    multStack[stack] = mltPacked < 0xff ? mltPacked : 0xff;
+  }
+  float getMultStack(int stack) const
+  {
+    return std::sinh(multStack[stack] * 0.05) / 0.05;
+  }
+  float getMultStackPacked(int stack) const { return multStack[stack]; }
+
+  ClassDefNV(TrackDataCompact, 3);
 };
 
 // TODO add to UnbinnedResid::sec flag if cluster was used or not
@@ -149,11 +211,22 @@ struct TrackData {
   short TRDTrkltSlope[6] = {};               ///< TRD tracklet slope 0x7fff / param::MaxTRDSlope
   uint8_t nExtDetResid = 0;                  ///< number of external detectors (to TPC) residuals stored, on top of clIdx.getEntries
   o2::dataformats::RangeReference<> clIdx{}; ///< index of first cluster residual and total number of TPC cluster residuals of this track
-
+  std::array<uint8_t, 4> multStack{};        // multiplicity in the stack packed as asinh(x*0.05)/0.05
   float getT0Error() const { return float(clAvailTOF); }
   bool isTOFAvail() const { return clAvailTOF != 0; }
 
-  ClassDefNV(TrackData, 9);
+  void setMultStack(float v, int stack)
+  {
+    uint32_t mltPacked = std::round(std::asinh(v * 0.05) / 0.05);
+    multStack[stack] = mltPacked < 0xff ? mltPacked : 0xff;
+  }
+  float getMultStack(int stack) const
+  {
+    return std::sinh(multStack[stack] * 0.05) / 0.05;
+  }
+  float getMultStackPacked(int stack) const { return multStack[stack]; }
+
+  ClassDefNV(TrackData, 10);
 };
 
 /// \class TrackInterpolation
@@ -268,6 +341,8 @@ class TrackInterpolation
   void diffToMA(const int np, const std::array<float, param::NPadRows>& y, std::array<float, param::NPadRows>& diffMA) const;
 
   // -------------------------------------- settings --------------------------------------------------
+  void setNHBPerTF(int n) { mNHBPerTF = n; }
+
   void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
 
   /// Sets the flag if material correction should be applied when extrapolating the tracks
@@ -296,10 +371,13 @@ class TrackInterpolation
 
   void setExtDetResid(bool v) { mExtDetResid = v; }
 
-  int processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork, std::array<float, 2>* trkltTRDYZ = nullptr, std::array<float, 3>* trkltTRDCov = nullptr, TrackData* trkData = nullptr);
+  int processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork, std::array<float, 2>* trkltTRDYZ = nullptr,
+                      std::array<float, 3>* trkltTRDCov = nullptr, TrackData* trkData = nullptr,
+                      o2::trd::Tracklet64* trk64 = nullptr, o2::trd::CalibratedTracklet* trkCalib = nullptr);
 
   // --------------------------------- output ---------------------------------------------
   std::vector<UnbinnedResid>& getClusterResiduals() { return mClRes; }
+  std::vector<DetInfoResid>& getClusterResidualsDetInfo() { return mDetInfoRes; }
   std::vector<TrackDataCompact>& getTrackDataCompact() { return mTrackDataCompact; }
   std::vector<TrackDataExtended>& getTrackDataExtended() { return mTrackDataExtended; }
   std::vector<TrackData>& getReferenceTracks() { return mTrackData; }
@@ -308,8 +386,14 @@ class TrackInterpolation
 
  private:
   static constexpr float sFloatEps{1.e-7f}; ///< float epsilon for robust linear fitting
+  static constexpr int NSTACKS = 4;
+  static constexpr std::array<int, NSTACKS + 1> STACKROWS{0, 63, 97, 127, 152};
   // parameters + settings
   const SpacePointsCalibConfParam* mParams = nullptr;
+  std::shared_ptr<o2::gpu::GPUParam> mTPCParam = nullptr;
+  int mNHBPerTF = 32;
+  int mNTPCOccBinLength = 16;                                   ///< TPC occupancy bin length in TB
+  float mNTPCOccBinLengthInv = 1.f / 16;                        ///< its inverse
   float mTPCTimeBinMUS{.2f};                                    ///< TPC time bin duration in us
   float mTPCVDriftRef = -1.;                                    ///< TPC nominal drift speed in cm/microseconds
   float mTPCDriftTimeOffsetRef = 0.;                            ///< TPC nominal (e.g. at the start of run) drift time bias in cm/mus
@@ -348,6 +432,7 @@ class TrackInterpolation
   std::vector<TrackDataCompact> mTrackDataCompact{};   ///< required to connect each residual to a global track
   std::vector<TrackDataExtended> mTrackDataExtended{}; ///< full tracking information for debugging
   std::vector<UnbinnedResid> mClRes{};                 ///< residuals for each available TPC cluster of all tracks
+  std::vector<DetInfoResid> mDetInfoRes{};             ///< packed detector info associated with each residual
   std::vector<TrackData> mTrackDataUnfiltered{};       ///< same as mTrackData, but for all tracks before outlier filtering
   std::vector<TPCClusterResiduals> mClResUnfiltered{}; ///< same as mClRes, but for all residuals before outlier filtering
 
diff --git a/Detectors/TPC/calibration/SpacePoints/src/ResidualAggregator.cxx b/Detectors/TPC/calibration/SpacePoints/src/ResidualAggregator.cxx
index a120c0e4ae782..b916e14dbf741 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/ResidualAggregator.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/ResidualAggregator.cxx
@@ -124,6 +124,7 @@ void ResidualsContainer::init(const TrackResiduals* residualsEngine, std::string
     treeOutResidualsUnbinned->Branch("trackInfo", &trackInfoPtr);
     treeOutResidualsUnbinned->Branch("CTPLumi", &lumiTF);
     treeOutResidualsUnbinned->Branch("timeMS", &timeMS);
+    treeOutResidualsUnbinned->Branch("detInfo", &detInfoUnbResPtr);
   }
   if (writeTrackData) {
     treeOutTrackData = std::make_unique<TTree>("trackData", "Track information incl cluster range ref");
@@ -170,7 +171,7 @@ void ResidualsContainer::fillStatisticsBranches()
   }
 }
 
-void ResidualsContainer::fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const UnbinnedResid> resid, const gsl::span<const o2::tpc::TrackDataCompact> trkRefsIn, const gsl::span<const o2::tpc::TrackData>* trkDataIn, const o2::ctp::LumiInfo* lumiInput)
+void ResidualsContainer::fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const UnbinnedResid> resid, const gsl::span<const DetInfoResid> detInfoRes, const gsl::span<const o2::tpc::TrackDataCompact> trkRefsIn, const gsl::span<const o2::tpc::TrackData>* trkDataIn, const o2::ctp::LumiInfo* lumiInput)
 {
   // receives large vector of unbinned residuals and fills the sector-wise vectors
   // with binned residuals and statistics
@@ -185,13 +186,14 @@ void ResidualsContainer::fill(const o2::dataformats::TFIDInfo& ti, const gsl::sp
     firstSeenTF = ti.tfCounter;
   }
   for (const auto& residIn : resid) {
-    ++nUnbinnedResidualsInTF;
     bool counterIncremented = false;
     if (writeUnbinnedResiduals) {
       unbinnedRes.push_back(residIn);
+      detInfoUnbRes.push_back(detInfoRes.size() ? detInfoRes[nUnbinnedResidualsInTF] : DetInfoResid{});
       ++nResidualsTotal;
       counterIncremented = true;
     }
+    ++nUnbinnedResidualsInTF;
     if (!writeBinnedResid) {
       continue;
     }
@@ -247,6 +249,7 @@ void ResidualsContainer::fill(const o2::dataformats::TFIDInfo& ti, const gsl::sp
     timeMS = orbitReset + ti.tfCounter * o2::constants::lhc::LHCOrbitMUS * 1.e-3;
     treeOutResidualsUnbinned->Fill();
     unbinnedRes.clear();
+    detInfoUnbRes.clear();
     trackInfo.clear();
   }
   tfOrbits.push_back(ti.firstTForbit);
@@ -338,6 +341,9 @@ void ResidualsContainer::merge(ResidualsContainer* prev)
   if (writeUnbinnedResiduals) {
     prev->treeOutResidualsUnbinned->SetBranchAddress("res", &unbinnedResPtr);
     prev->treeOutResidualsUnbinned->SetBranchAddress("trackInfo", &trackInfoPtr);
+    prev->treeOutResidualsUnbinned->SetBranchAddress("CTPLumi", &lumiTF);
+    prev->treeOutResidualsUnbinned->SetBranchAddress("timeMS", &timeMS);
+    prev->treeOutResidualsUnbinned->SetBranchAddress("detInfo", &detInfoUnbResPtr);
     for (int i = 0; i < treeOutResidualsUnbinned->GetEntries(); ++i) {
       treeOutResidualsUnbinned->GetEntry(i);
       prev->treeOutResidualsUnbinned->Fill();
diff --git a/Detectors/TPC/calibration/SpacePoints/src/SpacePointCalibLinkDef.h b/Detectors/TPC/calibration/SpacePoints/src/SpacePointCalibLinkDef.h
index b109a610f60b5..a3f9f3fe2267c 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/SpacePointCalibLinkDef.h
+++ b/Detectors/TPC/calibration/SpacePoints/src/SpacePointCalibLinkDef.h
@@ -29,7 +29,9 @@
 #pragma link C++ class o2::tpc::TrackResiduals::VoxRes + ;
 #pragma link C++ class o2::tpc::TrackResiduals::VoxStats + ;
 #pragma link C++ class o2::tpc::UnbinnedResid + ;
+#pragma link C++ class o2::tpc::DetInfoResid + ;
 #pragma link C++ class std::vector < o2::tpc::UnbinnedResid> + ;
+#pragma link C++ class std::vector < o2::tpc::DetInfoResid> + ;
 #pragma link C++ class std::vector < o2::tpc::TrackResiduals::LocalResid> + ;
 #pragma link C++ class std::vector < o2::tpc::TrackResiduals::VoxStats> + ;
 #pragma link C++ class o2::tpc::ResidualAggregator + ;
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index 7db5b7455f1a7..6c37be9ddc1b1 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -33,6 +33,11 @@
 #include "DataFormatsTPC/VDriftCorrFact.h"
 #include "Framework/Logger.h"
 #include "CCDB/BasicCCDBManager.h"
+#include "GPUO2InterfaceUtils.h"
+#include "GPUO2InterfaceConfiguration.h"
+#include "GPUO2InterfaceRefit.h"
+#include "GPUParam.h"
+#include "GPUParam.inc"
 #include <set>
 #include <algorithm>
 #include <random>
@@ -135,7 +140,7 @@ void TrackInterpolation::init(o2::dataformats::GlobalTrackID::mask_t src, o2::da
 
   auto geom = o2::its::GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
-
+  mTPCParam = o2::gpu::GPUO2InterfaceUtils::getFullParamShared(0.f, mNHBPerTF);
   mInitDone = true;
   LOGP(info, "Done initializing TrackInterpolation. Configured track input: {}. Track input specifically for map: {}",
        GTrackID::getSourcesNames(mSourcesConfigured), mSingleSourcesConfigured ? "identical" : GTrackID::getSourcesNames(mSourcesConfiguredMap));
@@ -316,6 +321,10 @@ void TrackInterpolation::process()
   // set the input containers
   mTPCTracksClusIdx = mRecoCont->getTPCTracksClusterRefs();
   mTPCClusterIdxStruct = &mRecoCont->getTPCClusters();
+  int nbOccTOT = o2::gpu::GPUO2InterfaceRefit::fillOccupancyMapGetSize(mNHBPerTF, mTPCParam.get());
+  o2::gpu::GPUO2InterfaceUtils::paramUseExternalOccupancyMap(mTPCParam.get(), mNHBPerTF, mRecoCont->occupancyMapTPC.data(), nbOccTOT);
+  mNTPCOccBinLength = mTPCParam->rec.tpc.occupancyMapTimeBins;
+  mNTPCOccBinLengthInv = 1.f / mNTPCOccBinLength;
   {
     if (!mITSDict) {
       LOG(error) << "No ITS dictionary available";
@@ -354,6 +363,7 @@ void TrackInterpolation::process()
   int maxOutputTracks = (mMaxTracksPerTF >= 0) ? mMaxTracksPerTF + mAddTracksForMapPerTF : nSeeds;
   mTrackData.reserve(maxOutputTracks);
   mClRes.reserve(maxOutputTracks * param::NPadRows);
+  mDetInfoRes.reserve(maxOutputTracks * param::NPadRows);
   bool maxTracksReached = false;
   for (int iSeed = 0; iSeed < nSeeds; ++iSeed) {
     if (mMaxTracksPerTF >= 0 && mTrackDataCompact.size() >= mMaxTracksPerTF + mAddTracksForMapPerTF) {
@@ -435,6 +445,8 @@ void TrackInterpolation::interpolateTrack(int iSeed)
 {
   LOGP(debug, "Starting track interpolation for GID {}", mGIDs[iSeed].asString());
   TrackData trackData;
+  o2::trd::Tracklet64 trkl64;
+  o2::trd::CalibratedTracklet trklCalib;
   std::unique_ptr<TrackDataExtended> trackDataExtended;
   std::vector<TPCClusterResiduals> clusterResiduals;
   auto propagator = o2::base::Propagator::Instance();
@@ -468,7 +480,9 @@ void TrackInterpolation::interpolateTrack(int iSeed)
   trackData.clIdx.setFirstEntry(mClRes.size()); // reference the first cluster residual belonging to this track
   float clusterTimeBinOffset = mTrackTimes[iSeed] / mTPCTimeBinMUS;
 
-  // store the TPC cluster positions in the cache
+  // store the TPC cluster positions in the cache, as well as dedx info
+  std::array<std::pair<uint16_t, uint16_t>, constants::MAXGLOBALPADROW> mCacheDEDX{};
+  std::array<short, constants::MAXGLOBALPADROW> multBins{};
   for (int iCl = trkTPC.getNClusterReferences(); iCl--;) {
     uint8_t sector, row;
     uint32_t clusterIndexInRow;
@@ -481,6 +495,12 @@ void TrackInterpolation::interpolateTrack(int iSeed)
     mCache[row].clY = clTPCYZ[0];
     mCache[row].clZ = clTPCYZ[1];
     mCache[row].clAngle = o2::math_utils::sector2Angle(sector);
+    mCacheDEDX[row].first = clTPC.getQtot();
+    mCacheDEDX[row].second = clTPC.getQmax();
+    int imb = int(clTPC.getTime() * mNTPCOccBinLengthInv);
+    if (imb < mTPCParam->occupancyMapSize) {
+      multBins[row] = 1 + std::max(0, imb);
+    }
   }
 
   // extrapolate seed through TPC and store track position at each pad row
@@ -627,10 +647,19 @@ void TrackInterpolation::interpolateTrack(int iSeed)
   trackData.nClsTPC = trkTPC.getNClusterReferences();
   trackData.nClsITS = trkITS.getNumberOfClusters();
   trackData.nTrkltsTRD = gidTable[GTrackID::TRD].isIndexSet() ? mRecoCont->getITSTPCTRDTrack<o2::trd::TrackTRD>(gidTable[GTrackID::ITSTPCTRD]).getNtracklets() : 0;
+
+  double t0forTOF = 0.; // to be set if TOF is matched
+  float t0forTOFwithinBC = 0.f;
+  float t0forTOFres = 9999.f;
+
   if (gidTable[GTrackID::TOF].isIndexSet()) {
     const auto& tofMatch = mRecoCont->getTOFMatch(mGIDs[iSeed]);
-    trackData.deltaTOF = tofMatch.getSignal() - tofMatch.getFT0Best() - tofMatch.getLTIntegralOut().getTOF(trkTPC.getPID().getID());
-    trackData.clAvailTOF = uint16_t(tofMatch.getFT0BestRes());
+    ULong64_t bclongtof = (tofMatch.getSignal() - 10000) * o2::tof::Geo::BC_TIME_INPS_INV;
+    t0forTOF = tofMatch.getFT0Best(); // setting t0 for TOF
+    t0forTOFwithinBC = t0forTOF - bclongtof * o2::tof::Geo::BC_TIME_INPS;
+    t0forTOFres = tofMatch.getFT0BestRes();
+    trackData.deltaTOF = tofMatch.getSignal() - t0forTOF - tofMatch.getLTIntegralOut().getTOF(trkTPC.getPID().getID());
+    trackData.clAvailTOF = uint16_t(t0forTOFres);
   } else {
     trackData.clAvailTOF = 0;
   }
@@ -655,6 +684,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
       const auto sec = clusterResiduals[iCl].sec;
       if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(y) < param::MaxY) && (std::abs(z) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
         mClRes.emplace_back(dy, dz, tgPhi, y, z, iRow, sec);
+        mDetInfoRes.emplace_back().setTPC(mCacheDEDX[iRow].first, mCacheDEDX[iRow].second); // qtot, qmax
         ++nClValidated;
       } else {
         ++mRejectedResiduals;
@@ -662,6 +692,30 @@ void TrackInterpolation::interpolateTrack(int iSeed)
     }
     trackData.clIdx.setEntries(nClValidated);
 
+    // store multiplicity info
+    for (int ist = 0; ist < NSTACKS; ist++) {
+      int mltBinMin = 0x7ffff, mltBinMax = -1, prevBin = -1;
+      for (int ir = STACKROWS[ist]; ir < STACKROWS[ist + 1]; ir++) {
+        if (multBins[ir] != prevBin && multBins[ir] > 0) { // there is a cluster different from previous one
+          prevBin = multBins[ir];
+          if (multBins[ir] > mltBinMax) {
+            mltBinMax = multBins[ir];
+          }
+          if (multBins[ir] < mltBinMin) {
+            mltBinMin = multBins[ir];
+          }
+        }
+      }
+      if (--mltBinMin >= 0) { // we were offsetting bin IDs by 1!
+        float avMlt = 0;
+        for (int ib = mltBinMin; ib < mltBinMax; ib++) {
+          avMlt += mTPCParam->occupancyMap[ib];
+        }
+        avMlt /= (mltBinMax - mltBinMin);
+        trackData.setMultStack(avMlt, ist);
+      }
+    }
+
     bool stopPropagation = !mExtDetResid;
     if (!stopPropagation) {
       // do we have TRD residuals to add?
@@ -670,7 +724,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
         const auto& trkTRD = mRecoCont->getITSTPCTRDTrack<o2::trd::TrackTRD>(gidTable[GTrackID::ITSTPCTRD]);
         for (int iLayer = 0; iLayer < o2::trd::constants::NLAYER; iLayer++) {
           std::array<float, 2> trkltTRDYZ{};
-          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ, nullptr, &trackData);
+          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ, nullptr, &trackData, &trkl64, &trklCalib);
           if (res == -1) { // no traklet on this layer
             continue;
           }
@@ -684,6 +738,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
           auto dz = trkltTRDYZ[1] - trkWork.getZ();
           if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
             mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 160 + iLayer, o2::math_utils::angle2Sector(trkWork.getAlpha()), (short)res);
+            mDetInfoRes.emplace_back().setTRD(trkl64.getQ0(), trkl64.getQ1(), trkl64.getQ2(), trklCalib.getDy()); // q0,q1,q2,slope
             trackData.nExtDetResid++;
           }
         }
@@ -710,8 +765,16 @@ void TrackInterpolation::interpolateTrack(int iSeed)
         float tgPhi = trkWork.getSnp() / std::sqrt((1.f - trkWork.getSnp()) * (1.f + trkWork.getSnp()));
         auto dy = clTOFxyz[1] - trkWork.getY();
         auto dz = clTOFxyz[2] - trkWork.getZ();
+        // get seeding track time
+
         if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
           mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 170, clTOF.getCount(), clTOF.getPadInSector());
+          // get seeding track time
+          if (!gidTable[GTrackID::ITSTPC].isIndexSet()) {
+            LOGP(fatal, "ITS-TPC seed index is not set for TOF track");
+          }
+          float tdif = static_cast<float>(clTOF.getTime() - t0forTOF); // time in \mus wrt interaction time0
+          mDetInfoRes.emplace_back().setTOF(tdif * 1e-6);
           trackData.nExtDetResid++;
         }
         break;
@@ -738,6 +801,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
           auto dz = cls.getZ() - trkWorkITS.getZ();
           if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
             mClRes.emplace_back(dy, dz, tgPhi, trkWorkITS.getY(), trkWorkITS.getZ(), 180 + geom->getLayer(cls.getSensorID()), -1, cls.getSensorID());
+            mDetInfoRes.emplace_back(); // empty placeholder
             trackData.nExtDetResid++;
           }
         }
@@ -759,6 +823,11 @@ void TrackInterpolation::interpolateTrack(int iSeed)
           if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && abs(xv) < param::MaxVtxX) {
             short compXV = static_cast<short>(xv * 0x7fff / param::MaxVtxX);
             mClRes.emplace_back(dy, dz, alpha / TMath::Pi(), trkWorkITS.getY(), trkWorkITS.getZ(), 190, -1, compXV);
+            if (!gidTable[GTrackID::ITSTPC].isIndexSet()) {
+              LOGP(fatal, "ITS-TPC seed index is not set for TOF track");
+            }
+            float tdif = pv.getTimeStamp().getTimeStamp() - mRecoCont->getTPCITSTrack(gidTable[GTrackID::ITSTPC]).getTimeMUS().getTimeStamp();
+            mDetInfoRes.emplace_back().setPV(tdif); // time in \mus wrt seeding ITS-TPC track
             trackData.nExtDetResid++;
           }
         }
@@ -767,7 +836,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
     }
 
     mGIDsSuccess.push_back(mGIDs[iSeed]);
-    mTrackDataCompact.emplace_back(trackData.clIdx.getFirstEntry(), nClValidated, mGIDs[iSeed].getSource(), trackData.nExtDetResid);
+    mTrackDataCompact.emplace_back(trackData.clIdx.getFirstEntry(), trackData.multStack, nClValidated, mGIDs[iSeed].getSource(), trackData.nExtDetResid);
     mTrackData.push_back(std::move(trackData));
     if (mDumpTrackPoints) {
       (*trackDataExtended).clIdx.setEntries(nClValidated);
@@ -785,7 +854,8 @@ void TrackInterpolation::interpolateTrack(int iSeed)
 }
 
 int TrackInterpolation::processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLayer, o2::track::TrackParCov& trkWork,
-                                        std::array<float, 2>* trkltTRDYZ, std::array<float, 3>* trkltTRDCov, TrackData* trkData)
+                                        std::array<float, 2>* trkltTRDYZ, std::array<float, 3>* trkltTRDCov, TrackData* trkData,
+                                        o2::trd::Tracklet64* trk64, o2::trd::CalibratedTracklet* trkCalib)
 {
   // return chamber ID (0:539) in case of successful processing, -1 if there is no TRD tracklet at given layer, -2 if processing failed
   int trkltIdx = trkTRD.getTrackletIndex(iLayer);
@@ -827,6 +897,12 @@ int TrackInterpolation::processTRDLayer(const o2::trd::TrackTRD& trkTRD, int iLa
       trkData->TRDTrkltSlope[iLayer] = slope * 0x7fff / param::MaxTRDSlope;
     }
   }
+  if (trk64) {
+    *trk64 = trdTrklt;
+  }
+  if (trkCalib) {
+    *trkCalib = trdSP;
+  }
   return trkltDet;
 }
 
@@ -836,6 +912,8 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
   LOGP(debug, "Starting track extrapolation for GID {}", mGIDs[iSeed].asString());
   const auto& gidTable = mGIDtables[iSeed];
   TrackData trackData;
+  o2::trd::Tracklet64 trkl64;
+  o2::trd::CalibratedTracklet trklCalib;
   std::unique_ptr<TrackDataExtended> trackDataExtended;
   std::vector<TPCClusterResiduals> clusterResiduals;
   trackData.clIdx.setFirstEntry(mClRes.size());
@@ -866,6 +944,8 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
   unsigned short rowPrev = 0; // used to calculate dRow of two consecutive cluster residuals
   unsigned short nMeasurements = 0;
   uint8_t clRowPrev = constants::MAXGLOBALPADROW; // used to identify and skip split clusters on the same pad row
+  std::array<std::pair<uint16_t, uint16_t>, constants::MAXGLOBALPADROW> mCacheDEDX{};
+  std::array<short, constants::MAXGLOBALPADROW> multBins{};
   for (int iCl = trkTPC.getNClusterReferences(); iCl--;) {
     uint8_t sector, row;
     uint32_t clusterIndexInRow;
@@ -897,10 +977,14 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
     const auto tz = trkWork.getZ();
     const auto snp = trkWork.getSnp();
     const auto sec = sector;
-
     clusterResiduals.emplace_back(dY, dZ, ty, tz, snp, sec, row - rowPrev);
-
+    mCacheDEDX[row].first = cl.getQtot();
+    mCacheDEDX[row].second = cl.getQmax();
     rowPrev = row;
+    int imb = int(cl.getTime() * mNTPCOccBinLengthInv);
+    if (imb < mTPCParam->occupancyMapSize) {
+      multBins[row] = 1 + std::max(0, imb);
+    }
     ++nMeasurements;
   }
 
@@ -937,6 +1021,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
       const auto z = clusterResiduals[iCl].z;
       if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(y) < param::MaxY) && (std::abs(z) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
         mClRes.emplace_back(dy, dz, tgPhi, y, z, iRow, clusterResiduals[iCl].sec);
+        mDetInfoRes.emplace_back().setTPC(mCacheDEDX[iRow].first, mCacheDEDX[iRow].second); // qtot, qmax
         ++nClValidated;
       } else {
         ++mRejectedResiduals;
@@ -944,6 +1029,30 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
     }
     trackData.clIdx.setEntries(nClValidated);
 
+    // store multiplicity info
+    for (int ist = 0; ist < NSTACKS; ist++) {
+      int mltBinMin = 0x7ffff, mltBinMax = -1, prevBin = -1;
+      for (int ir = STACKROWS[ist]; ir < STACKROWS[ist + 1]; ir++) {
+        if (multBins[ir] != prevBin && multBins[ir] > 0) { // there is a cluster
+          prevBin = multBins[ir];
+          if (multBins[ir] > mltBinMax) {
+            mltBinMax = multBins[ir];
+          }
+          if (multBins[ir] < mltBinMin) {
+            mltBinMin = multBins[ir];
+          }
+        }
+      }
+      if (--mltBinMin >= 0) { // we were offsetting bin IDs by 1!
+        float avMlt = 0;
+        for (int ib = mltBinMin; ib < mltBinMax; ib++) {
+          avMlt += mTPCParam->occupancyMap[ib];
+        }
+        avMlt /= (mltBinMax - mltBinMin);
+        trackData.setMultStack(avMlt, ist);
+      }
+    }
+
     bool stopPropagation = !mExtDetResid;
     if (!stopPropagation) {
       // do we have TRD residuals to add?
@@ -955,7 +1064,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
         trackData.nTrkltsTRD = trkTRD.getNtracklets();
         for (int iLayer = 0; iLayer < o2::trd::constants::NLAYER; iLayer++) {
           std::array<float, 2> trkltTRDYZ{};
-          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ, nullptr, &trackData);
+          int res = processTRDLayer(trkTRD, iLayer, trkWork, &trkltTRDYZ, nullptr, &trackData, &trkl64, &trklCalib);
           if (res == -1) { // no traklet on this layer
             continue;
           }
@@ -970,6 +1079,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
           const auto sec = clusterResiduals[iCl].sec;
           if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
             mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 160 + iLayer, o2::math_utils::angle2Sector(trkWork.getAlpha()), (short)res);
+            mDetInfoRes.emplace_back().setTRD(trkl64.getQ0(), trkl64.getQ1(), trkl64.getQ2(), trklCalib.getDy()); // q0,q1,q2,slope
             trackData.nExtDetResid++;
           }
         }
@@ -979,8 +1089,12 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
       trackData.clAvailTOF = 0;
       while (gidTableFull[GTrackID::TOF].isIndexSet() && !stopPropagation) {
         const auto& tofMatch = mRecoCont->getTOFMatch(gidFull);
-        trackData.deltaTOF = tofMatch.getSignal() - tofMatch.getFT0Best() - tofMatch.getLTIntegralOut().getTOF(trkTPC.getPID().getID());
-        trackData.clAvailTOF = uint16_t(tofMatch.getFT0BestRes());
+        ULong64_t bclongtof = (tofMatch.getSignal() - 10000) * o2::tof::Geo::BC_TIME_INPS_INV;
+        double t0forTOF = tofMatch.getFT0Best(); // setting t0 for TOF
+        float t0forTOFwithinBC = t0forTOF - bclongtof * o2::tof::Geo::BC_TIME_INPS;
+        float t0forTOFres = tofMatch.getFT0BestRes();
+        trackData.deltaTOF = tofMatch.getSignal() - t0forTOF - tofMatch.getLTIntegralOut().getTOF(trkTPC.getPID().getID());
+        trackData.clAvailTOF = uint16_t(t0forTOFres);
         const auto& clTOF = mRecoCont->getTOFClusters()[gidTableFull[GTrackID::TOF]];
         const float clTOFAlpha = o2::math_utils::sector2Angle(clTOF.getCount());
         float clTOFxyz[3] = {clTOF.getX(), clTOF.getY(), clTOF.getZ()};
@@ -1002,6 +1116,13 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
         auto dz = clTOFxyz[2] - trkWork.getZ();
         if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWork.getY()) < param::MaxY) && (std::abs(trkWork.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
           mClRes.emplace_back(dy, dz, tgPhi, trkWork.getY(), trkWork.getZ(), 170, clTOF.getCount(), clTOF.getPadInSector());
+          // get seeding track time
+          if (!gidTableFull[GTrackID::ITSTPC].isIndexSet()) {
+            LOGP(fatal, "ITS-TPC seed index is not set for TOF track");
+          }
+
+          float tdif = static_cast<float>(clTOF.getTime() - t0forTOF); // time in \mus wrt interaction time0
+          mDetInfoRes.emplace_back().setTOF(tdif * 1e-6);              // time in \mus wrt seeding ITS-TPC track
           trackData.nExtDetResid++;
         }
         break;
@@ -1028,6 +1149,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
           auto dz = cls.getZ() - trkWorkITS.getZ();
           if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && (std::abs(tgPhi) < param::MaxTgSlp)) {
             mClRes.emplace_back(dy, dz, tgPhi, trkWorkITS.getY(), trkWorkITS.getZ(), 180 + geom->getLayer(cls.getSensorID()), -1, cls.getSensorID());
+            mDetInfoRes.emplace_back(); // empty placeholder
             trackData.nExtDetResid++;
           }
         }
@@ -1049,6 +1171,11 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
           if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && abs(xv) < param::MaxVtxX) {
             short compXV = static_cast<short>(xv * 0x7fff / param::MaxVtxX);
             mClRes.emplace_back(dy, dz, alpha / TMath::Pi(), trkWorkITS.getY(), trkWorkITS.getZ(), 190, -1, compXV);
+            if (!gidTableFull[GTrackID::ITSTPC].isIndexSet()) {
+              LOGP(fatal, "ITS-TPC seed index is not set for TOF track");
+            }
+            float tdif = pv.getTimeStamp().getTimeStamp() - mRecoCont->getTPCITSTrack(gidTableFull[GTrackID::ITSTPC]).getTimeMUS().getTimeStamp();
+            mDetInfoRes.emplace_back().setPV(tdif); // time in \mus wrt seeding ITS-TPC track
             trackData.nExtDetResid++;
           }
         }
@@ -1057,7 +1184,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
     }
     mTrackData.push_back(std::move(trackData));
     mGIDsSuccess.push_back(mGIDs[iSeed]);
-    mTrackDataCompact.emplace_back(trackData.clIdx.getFirstEntry(), nClValidated, mGIDs[iSeed].getSource(), trackData.nExtDetResid);
+    mTrackDataCompact.emplace_back(trackData.clIdx.getFirstEntry(), trackData.multStack, nClValidated, mGIDs[iSeed].getSource(), trackData.nExtDetResid);
     if (mDumpTrackPoints) {
       (*trackDataExtended).clIdx.setEntries(nClValidated);
       (*trackDataExtended).nExtDetResid = trackData.nExtDetResid;
@@ -1445,6 +1572,7 @@ void TrackInterpolation::reset()
   mTrackDataCompact.clear();
   mTrackDataExtended.clear();
   mClRes.clear();
+  mDetInfoRes.clear();
   mTrackDataUnfiltered.clear();
   mClResUnfiltered.clear();
   mGIDsSuccess.clear();

From 0df45c42929034ad639a89a0618896090012270a Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Thu, 25 Sep 2025 15:57:50 +0200
Subject: [PATCH 1242/1764] Implementation of TPC loopers in O2

---
 Generators/CMakeLists.txt                     |  10 +
 Generators/include/Generators/Generator.h     |  13 +
 Generators/include/Generators/TPCLoopers.h    | 148 ++++++
 .../include/Generators/TPCLoopersParam.h      |  54 ++
 Generators/share/TPCLoopers/README.md         |  79 +++
 .../share/TPCLoopers/ScalerComptonParams.json |  28 +
 .../share/TPCLoopers/ScalerPairParams.json    |  34 ++
 .../share/TPCLoopers/gaussian_params.csv      |   4 +
 .../share/TPCLoopers/poisson_params.csv       |   3 +
 Generators/src/Generator.cxx                  | 184 +++++++
 Generators/src/GeneratorsLinkDef.h            |   4 +
 Generators/src/TPCLoopers.cxx                 | 486 ++++++++++++++++++
 Generators/src/TPCLoopersParam.cxx            |  15 +
 prodtests/full_system_test.sh                 |  37 +-
 14 files changed, 1095 insertions(+), 4 deletions(-)
 create mode 100644 Generators/include/Generators/TPCLoopers.h
 create mode 100644 Generators/include/Generators/TPCLoopersParam.h
 create mode 100644 Generators/share/TPCLoopers/README.md
 create mode 100644 Generators/share/TPCLoopers/ScalerComptonParams.json
 create mode 100644 Generators/share/TPCLoopers/ScalerPairParams.json
 create mode 100644 Generators/share/TPCLoopers/gaussian_params.csv
 create mode 100644 Generators/share/TPCLoopers/poisson_params.csv
 create mode 100644 Generators/src/TPCLoopers.cxx
 create mode 100644 Generators/src/TPCLoopersParam.cxx

diff --git a/Generators/CMakeLists.txt b/Generators/CMakeLists.txt
index 02caa63df0d43..287536ff118f7 100644
--- a/Generators/CMakeLists.txt
+++ b/Generators/CMakeLists.txt
@@ -41,6 +41,8 @@ o2_add_library(Generators
                        src/GeneratorTParticleParam.cxx
                        src/GeneratorService.cxx
                        src/FlowMapper.cxx
+                       src/TPCLoopers.cxx
+                       src/TPCLoopersParam.cxx
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/DecayerPythia8.cxx>
                        $<$<BOOL:${pythia_FOUND}>:src/GeneratorPythia8Param.cxx>
@@ -53,6 +55,7 @@ o2_add_library(Generators
                PUBLIC_LINK_LIBRARIES FairRoot::Base O2::SimConfig O2::CommonUtils O2::DetectorsBase O2::ZDCBase
                                      O2::SimulationDataFormat ${pythiaTarget} ${hepmcTarget}
                                      FairRoot::Gen
+                                     onnxruntime::onnxruntime
                TARGETVARNAME targetName)
 
 if(pythia_FOUND)
@@ -63,6 +66,8 @@ if(HepMC3_FOUND)
   target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_HEPMC3)
 endif()
 
+target_compile_definitions(${targetName} PUBLIC GENERATORS_WITH_TPCLOOPERS)
+
 set(headers
     include/Generators/Generator.h
     include/Generators/Trigger.h
@@ -88,6 +93,10 @@ set(headers
     include/Generators/FlowMapper.h
     )
 
+list(APPEND headers
+            include/Generators/TPCLoopers.h
+            include/Generators/TPCLoopersParam.h)
+
 if(pythia_FOUND)
   list(APPEND headers
               include/Generators/GeneratorPythia8.h
@@ -158,4 +167,5 @@ endif()
 
 o2_data_file(COPY share/external DESTINATION Generators)
 o2_data_file(COPY share/egconfig DESTINATION Generators)
+o2_data_file(COPY share/TPCLoopers DESTINATION Generators)
 o2_data_file(COPY share/pythia8 DESTINATION Generators)
diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index bd35a00793e2d..3484601aa42bb 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -17,6 +17,10 @@
 #include "FairGenerator.h"
 #include "TParticle.h"
 #include "Generators/Trigger.h"
+#ifdef GENERATORS_WITH_TPCLOOPERS
+#include "Generators/TPCLoopers.h"
+#include "Generators/TPCLoopersParam.h"
+#endif
 #include <functional>
 #include <vector>
 #include <unordered_map>
@@ -73,6 +77,7 @@ class Generator : public FairGenerator
   /** methods to override **/
   virtual Bool_t generateEvent() = 0;   // generates event (in structure internal to generator)
   virtual Bool_t importParticles() = 0; // fills the mParticles vector (transfer from generator state)
+  Bool_t finalizeEvent();               // final part of event generation that can be customised using external macros
   virtual void updateHeader(o2::dataformats::MCEventHeader* eventHeader) {};
   Bool_t triggerEvent();
 
@@ -154,6 +159,8 @@ class Generator : public FairGenerator
  private:
   void updateSubGeneratorInformation(o2::dataformats::MCEventHeader* header) const;
 
+  // loopers flag
+  Bool_t mAddTPCLoopers = kFALSE; // Flag is automatically set to true if TPC is in readout detectors, loopers are not vetoed and transport is enabled
   // collect an ID and a short description of sub-generator entities
   std::unordered_map<int, std::string> mSubGeneratorsIdToDesc;
   // the current ID of the sub-generator used in the current event (if applicable)
@@ -162,6 +169,12 @@ class Generator : public FairGenerator
   // global static information about (upper limit of) number of events to be generated
   static unsigned int gTotalNEvents;
 
+#ifdef GENERATORS_WITH_TPCLOOPERS
+  // Loopers generator instance
+  std::unique_ptr<o2::eventgen::GenTPCLoopers> mTPCLoopersGen = nullptr;
+  bool initTPCLoopersGen();
+#endif
+
   ClassDefOverride(Generator, 2);
 
 }; /** class Generator **/
diff --git a/Generators/include/Generators/TPCLoopers.h b/Generators/include/Generators/TPCLoopers.h
new file mode 100644
index 0000000000000..6a1d3ef262e22
--- /dev/null
+++ b/Generators/include/Generators/TPCLoopers.h
@@ -0,0 +1,148 @@
+// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \author M+Giacalone - September 2025
+
+#ifndef ALICEO2_EVENTGEN_TPCLOOPERS_H_
+#define ALICEO2_EVENTGEN_TPCLOOPERS_H_
+
+#ifdef GENERATORS_WITH_TPCLOOPERS
+#include <onnxruntime_cxx_api.h>
+#endif
+#include <vector>
+#include <rapidjson/document.h>
+#include "TRandom3.h"
+#include <SimulationDataFormat/DigitizationContext.h>
+#include "TParticle.h"
+
+#ifdef GENERATORS_WITH_TPCLOOPERS
+// Static Ort::Env instance for multiple onnx model loading
+extern Ort::Env global_env;
+
+// This class is responsible for loading the scaler parameters from a JSON file
+// and applying the inverse transformation to the generated data.
+// Inferenced output is scaled (min-max normalization or robust scaling for outlier features) during training,
+// so we need to revert this transformation to get physical values.
+struct Scaler {
+  std::vector<double> normal_min;
+  std::vector<double> normal_max;
+  std::vector<double> outlier_center;
+  std::vector<double> outlier_scale;
+
+  void load(const std::string& filename);
+
+  std::vector<double> inverse_transform(const std::vector<double>& input);
+
+ private:
+  std::vector<double> jsonArrayToVector(const rapidjson::Value& jsonArray);
+};
+
+// This class loads the ONNX model and generates samples using it.
+class ONNXGenerator
+{
+ public:
+  ONNXGenerator(Ort::Env& shared_env, const std::string& model_path);
+
+  std::vector<double> generate_sample();
+
+ private:
+  Ort::Env& env;
+  Ort::Session session;
+  TRandom3 rand_gen;
+};
+#endif // GENERATORS_WITH_TPCLOOPERS
+
+namespace o2
+{
+namespace eventgen
+{
+
+#ifdef GENERATORS_WITH_TPCLOOPERS
+/**
+ * Generator for TPC Loopers based on pre-trained ONNX models.
+ * Currently it generates loopers as electron-positron pairs and Compton electrons
+ * according to specified distributions and parameters.
+ * This can be extended to other types of background processes in the future (e.g. slow neutron spallation products, saturation tail).
+ * Multiple configuration options are available:
+ * - Flat gas: loopers are generated uniformly per event taking a reference value which can be either the LHC orbit time or the average interaction time record interval from the collision context.
+ *   ==> Current automatic setup (default) sets the interaction rate automatically from the collision context and the reference value per orbit is calculated from an external file.
+ *   ==> Number of loopers per orbit can be adjusted via a specific parameter.
+ * - Poisson + Gaussian sampling: number of loopers are sampled from Poissonian (for pairs) and Gaussian (for Compton electrons) distributions based on provided parameters.
+ *   ==> flat gas must be disabled to use this option.
+ * - Fixed number of loopers per event
+ *   ==> flat gas must be disabled to use this option and Poissonian/Gaussian parameters file should be set to None
+ */
+class GenTPCLoopers
+{
+ public:
+  GenTPCLoopers(std::string model_pairs = "tpcloopmodel.onnx", std::string model_compton = "tpcloopmodelcompton.onnx",
+                std::string poisson = "poisson.csv", std::string gauss = "gauss.csv", std::string scaler_pair = "scaler_pair.json",
+                std::string scaler_compton = "scaler_compton.json");
+
+  Bool_t generateEvent();
+
+  Bool_t generateEvent(double time_limit);
+
+  std::vector<TParticle> importParticles();
+
+  unsigned int PoissonPairs();
+
+  unsigned int GaussianElectrons();
+
+  void SetNLoopers(unsigned int nsig_pair, unsigned int nsig_compton);
+
+  void SetMultiplier(const std::array<float, 2>& mult);
+
+  void setFlatGas(Bool_t flat, Int_t number = -1, Int_t nloopers_orbit = -1);
+
+  void setFractionPairs(float fractionPairs);
+
+  void SetRate(const std::string& rateFile, bool isPbPb, int intRate = 50000);
+
+  void SetAdjust(float adjust = 0.f);
+
+  unsigned int getNLoopers() const { return (mNLoopersPairs + mNLoopersCompton); }
+
+ private:
+  std::unique_ptr<ONNXGenerator> mONNX_pair = nullptr;
+  std::unique_ptr<ONNXGenerator> mONNX_compton = nullptr;
+  std::unique_ptr<Scaler> mScaler_pair = nullptr;
+  std::unique_ptr<Scaler> mScaler_compton = nullptr;
+  double mPoisson[3] = {0.0, 0.0, 0.0};    // Mu, Min and Max of Poissonian
+  double mGauss[4] = {0.0, 0.0, 0.0, 0.0}; // Mean, Std, Min, Max
+  std::vector<std::vector<double>> mGenPairs;
+  std::vector<std::vector<double>> mGenElectrons;
+  unsigned int mNLoopersPairs = -1;
+  unsigned int mNLoopersCompton = -1;
+  std::array<float, 2> mMultiplier = {1., 1.};
+  bool mPoissonSet = false;
+  bool mGaussSet = false;
+  // Random number generator
+  TRandom3 mRandGen;
+  int mCurrentEvent = 0;                                          // Current event number, used for adaptive loopers
+  TFile* mContextFile = nullptr;                                  // Input collision context file
+  o2::steer::DigitizationContext* mCollisionContext = nullptr;    // Pointer to the digitization context
+  std::vector<o2::InteractionTimeRecord> mInteractionTimeRecords; // Interaction time records from collision context
+  Bool_t mFlatGas = false;                                        // Flag to indicate if flat gas loopers are used
+  Bool_t mFlatGasOrbit = false;                                   // Flag to indicate if flat gas loopers are per orbit
+  Int_t mFlatGasNumber = -1;                                      // Number of flat gas loopers per event
+  double mIntTimeRecMean = 1.0;                                   // Average interaction time record used for the reference
+  double mTimeLimit = 0.0;                                        // Time limit for the current event
+  double mTimeEnd = 0.0;                                          // Time limit for the last event
+  float mLoopsFractionPairs = 0.08;                               // Fraction of loopers from Pairs
+  int mInteractionRate = 50000;                                   // Interaction rate in Hz
+};
+#endif // GENERATORS_WITH_TPCLOOPERS
+
+} // namespace eventgen
+} // namespace o2
+
+#endif // ALICEO2_EVENTGEN_TPCLOOPERS_H_
\ No newline at end of file
diff --git a/Generators/include/Generators/TPCLoopersParam.h b/Generators/include/Generators/TPCLoopersParam.h
new file mode 100644
index 0000000000000..87e4510d6e617
--- /dev/null
+++ b/Generators/include/Generators/TPCLoopersParam.h
@@ -0,0 +1,54 @@
+// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \author M+Giacalone - September 2025
+
+#ifndef ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
+#define ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2
+{
+namespace eventgen
+{
+
+/**
+ ** a parameter class/struct to keep the settings of
+ ** the TPC loopers event-generator and
+ ** allow the user to modify them
+ **/
+struct GenTPCLoopersParam : public o2::conf::ConfigurableParamHelper<GenTPCLoopersParam> {
+  bool loopersVeto = false; // if true, no loopers are generated
+  // Current files are set to custom user CCDB paths, TO BE CHANGED
+  std::string model_pairs = "ccdb://Users/m/mgiacalo/WGAN_ExtGenPair";                            // ONNX model for e+e- pair production
+  std::string model_compton = "ccdb://Users/m/mgiacalo/WGAN_ExtGenCompton";                       // ONNX model for Compton scattering
+  std::string poisson = "${O2_ROOT}/share/Generators/TPCLoopers/poisson_params.csv";              // file with Poissonian parameters
+  std::string gauss = "${O2_ROOT}/share/Generators/TPCLoopers/gaussian_params.csv";               // file with Gaussian parameters
+  std::string scaler_pair = "${O2_ROOT}/share/Generators/TPCLoopers/ScalerPairParams.json";       // file with scaler parameters for e+e- pair production
+  std::string scaler_compton = "${O2_ROOT}/share/Generators/TPCLoopers/ScalerComptonParams.json"; // file with scaler parameters for Compton scattering
+  std::string nclxrate = "ccdb://Users/m/mgiacalo/ClustersTrackRatio";                            // file with clusters/rate information per orbit
+  std::string colsys = "PbPb";                                                                    // collision system  (PbPb or pp)
+  int intrate = -1;                                                                               // Automatic IR from collision context if -1, else user-defined interaction rate in Hz
+  bool flat_gas = true;                                                                           // if true, the gas density is considered flat in the TPC volume
+  unsigned int nFlatGasLoopers = 500;                                                             // number of loopers to be generated per event in case of flat gas [currently unused, kept for possible future debug developments]
+  float fraction_pairs = 0.08;                                                                    // fraction of loopers [currently unused, kept for possible future debug developments]
+  float multiplier[2] = {1., 1.};                                                                 // multiplier for pairs and compton loopers for Poissonian and Gaussian sampling
+  unsigned int fixedNLoopers[2] = {1, 1};                                                         // fixed number of loopers coming from pairs and compton electrons - valid if flat gas is false and both Poisson and Gaussian params files are empty
+  float adjust_flatgas = 0.f;                                                                     // adjustment for the number of flat gas loopers per orbit (in percentage, e.g. -0.1 = -10%) [-1, inf)]
+  O2ParamDef(GenTPCLoopersParam, "GenTPCLoopers");
+};
+
+} // end namespace eventgen
+} // end namespace o2
+
+#endif // ALICEO2_EVENTGEN_TPCLOOPERSPARAM_H_
diff --git a/Generators/share/TPCLoopers/README.md b/Generators/share/TPCLoopers/README.md
new file mode 100644
index 0000000000000..0e0ac858b8809
--- /dev/null
+++ b/Generators/share/TPCLoopers/README.md
@@ -0,0 +1,79 @@
+# TPC Loopers Generator - Parameter Files
+
+This directory contains parameter files used by the TPC Loopers event generator in ALICE O2.
+
+## Overview
+
+The TPC Loopers generator uses pre-trained ONNX models to generate realistic looper particles based on machine learning models trained on full GEANT4 slow neutron transport simulations. The parameter files in this directory provide:
+- Example statistical distribution parameters for sampling the number of loopers per event
+- **Mandatory** scaling parameters for transforming the ONNX model outputs to physical values
+
+## Files Description
+
+### Statistical Sampling Parameters
+
+The files provided in the folder are examples based on the training dataset.
+
+#### `gaussian_params.csv`
+Parameters for Gaussian distribution used to sample the number of Compton electrons per event.
+
+**Format:** Four values (one per line)
+1. Mean (μ)
+2. Standard deviation (σ)
+3. Minimum value
+4. Maximum value
+
+#### `poisson_params.csv`
+Parameters for Poisson distribution used to sample the number of electron-positron pairs per event.
+
+**Format:** Three values (one per line)
+1. Lambda (λ) parameter
+2. Minimum value
+3. Maximum value
+
+### Scaler Parameters
+
+These JSON files contain the parameters for inverse transformation of the ONNX models output. They should be kept as they are
+unless a new version of the models is released.
+
+#### `ScalerComptonParams.json`
+Scaler parameters for Compton electron generation model.
+
+**Structure:**
+```json
+{
+  "normal": {
+    "min": [array of 5 min values for min-max normalization],
+    "max": [array of 5 max values for min-max normalization]
+  },
+  "outlier": {
+    "center": [array of 2 center values for robust scaling],
+    "scale": [array of 2 scale values for robust scaling]
+  }
+}
+```
+
+- **normal**: Min-max normalization parameters for standard features (`Px`, `Py`, `Pz`, `VertexCoordinatesX`, `VertexCoordinatesY`)
+- **outlier**: Robust scaler parameters (center and scale) for outlier features (`VertexCoordinatesZ`,`time`)
+
+#### `ScalerPairParams.json`
+Scaler parameters for electron-positron pair generation model.
+
+**Structure:**
+```json
+{
+  "normal": {
+    "min": [array of 8 min values for min-max normalization],
+    "max": [array of 8 max values for min-max normalization]
+  },
+  "outlier": {
+    "center": [array of 2 center values for robust scaling],
+    "scale": [array of 2 scale values for robust scaling]
+  }
+}
+```
+
+- **normal**: Min-max normalization parameters for standard features (`Px_e`, `Py_e`, `Pz_e`,`Px_p`, `Py_p`, `Pz_p`, `VertexCoordinatesX`, `VertexCoordinatesY`)
+- **outlier**: Robust scaler parameters (center and scale) for outlier features (`VertexCoordinatesZ`,`time`)
+---
+*Author: M. Giacalone - September 2025*
diff --git a/Generators/share/TPCLoopers/ScalerComptonParams.json b/Generators/share/TPCLoopers/ScalerComptonParams.json
new file mode 100644
index 0000000000000..157647fee2db7
--- /dev/null
+++ b/Generators/share/TPCLoopers/ScalerComptonParams.json
@@ -0,0 +1,28 @@
+{
+  "normal": {
+    "min": [
+      -0.0108811147511005,
+      -0.0098758740350604,
+      -0.0103233363479375,
+      -260.0542297363281,
+      -259.80059814453125
+    ],
+    "max": [
+      0.0108060473576188,
+      0.0103057539090514,
+      0.0106524610891938,
+      260.0343933105469,
+      259.62890625
+    ]
+  },
+  "outlier": {
+    "center": [
+      -71.39387130737305,
+      96791.23828125
+    ],
+    "scale": [
+      265.9389114379883,
+      230762.30981445312
+    ]
+  }
+}
\ No newline at end of file
diff --git a/Generators/share/TPCLoopers/ScalerPairParams.json b/Generators/share/TPCLoopers/ScalerPairParams.json
new file mode 100644
index 0000000000000..57cdac421d3f6
--- /dev/null
+++ b/Generators/share/TPCLoopers/ScalerPairParams.json
@@ -0,0 +1,34 @@
+{
+  "normal": {
+    "min": [
+      -0.0073022879660129,
+      -0.0077305701561272,
+      -0.0076750442385673,
+      -0.0082916170358657,
+      -0.0079681202769279,
+      -0.0077468422241508,
+      -255.6164093017578,
+      -252.9441680908203
+    ],
+    "max": [
+      0.007688719779253,
+      0.0077241472899913,
+      0.0075828479602932,
+      0.00813714787364,
+      0.0083825681358575,
+      0.0073839174583554,
+      256.2904968261719,
+      253.4925842285156
+    ]
+  },
+  "outlier": {
+    "center": [
+      -79.66580963134766,
+      141535.640625
+    ],
+    "scale": [
+      250.8921127319336,
+      222363.16015625
+    ]
+  }
+}
\ No newline at end of file
diff --git a/Generators/share/TPCLoopers/gaussian_params.csv b/Generators/share/TPCLoopers/gaussian_params.csv
new file mode 100644
index 0000000000000..8e07c22dd30bf
--- /dev/null
+++ b/Generators/share/TPCLoopers/gaussian_params.csv
@@ -0,0 +1,4 @@
+9.611554230339172022e+01
+1.963570744941765867e+01
+4.300000000000000000e+01
+1.690000000000000000e+02
diff --git a/Generators/share/TPCLoopers/poisson_params.csv b/Generators/share/TPCLoopers/poisson_params.csv
new file mode 100644
index 0000000000000..ef26bd973d34c
--- /dev/null
+++ b/Generators/share/TPCLoopers/poisson_params.csv
@@ -0,0 +1,3 @@
+3.165383056343737511e+00
+1.000000000000000000e+00
+1.200000000000000000e+01
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 9204ede98215e..465a8ffb7ee22 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -17,11 +17,16 @@
 #include "SimulationDataFormat/MCEventHeader.h"
 #include "SimulationDataFormat/ParticleStatus.h"
 #include "SimulationDataFormat/MCGenProperties.h"
+#include <SimConfig/SimConfig.h>
 #include "FairPrimaryGenerator.h"
 #include <fairlogger/Logger.h>
 #include <cmath>
 #include "TClonesArray.h"
 #include "TParticle.h"
+#include "TSystem.h"
+#include "TGrid.h"
+#include "CCDB/BasicCCDBManager.h"
+#include <filesystem>
 
 namespace o2
 {
@@ -39,6 +44,25 @@ Generator::Generator() : FairGenerator("ALICEo2", "ALICEo2 Generator"),
   /** default constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
+#ifdef GENERATORS_WITH_TPCLOOPERS
+  const auto& simConfig = o2::conf::SimConfig::Instance();
+  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
+  if (!loopersParam.loopersVeto) {
+    bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
+    if (transport) {
+      bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
+      if (tpcActive) {
+        if (initTPCLoopersGen()) {
+          mAddTPCLoopers = kTRUE;
+        }
+      } else {
+        LOG(info) << "TPC not active in readout detectors: loopers fast generator disabled.";
+      }
+    }
+  } else {
+    LOG(info) << "Loopers fast generator turned OFF with veto flag.";
+  }
+#endif
 }
 
 /*****************************************************************/
@@ -49,7 +73,126 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
   /** constructor **/
   mThisInstanceID = Generator::InstanceCounter;
   Generator::InstanceCounter++;
+#ifdef GENERATORS_WITH_TPCLOOPERS
+  const auto& simConfig = o2::conf::SimConfig::Instance();
+  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
+  if (!loopersParam.loopersVeto) {
+    bool transport = (simConfig.getMCEngine() != "O2TrivialMCEngine");
+    if (transport) {
+      bool tpcActive = (std::find(simConfig.getReadoutDetectors().begin(), simConfig.getReadoutDetectors().end(), "TPC") != simConfig.getReadoutDetectors().end());
+      if (tpcActive) {
+        if (initTPCLoopersGen()) {
+          mAddTPCLoopers = kTRUE;
+        }
+      } else {
+        LOG(info) << "TPC not active in readout detectors: loopers fast generator disabled.";
+      }
+    }
+  } else {
+    LOG(info) << "Loopers fast generator turned OFF with veto flag.";
+  }
+#endif
+}
+
+/*****************************************************************/
+#ifdef GENERATORS_WITH_TPCLOOPERS
+bool Generator::initTPCLoopersGen()
+{
+  // Expand all environment paths
+  const auto& loopersParam = o2::eventgen::GenTPCLoopersParam::Instance();
+  std::string model_pairs = gSystem->ExpandPathName(loopersParam.model_pairs.c_str());
+  std::string model_compton = gSystem->ExpandPathName(loopersParam.model_compton.c_str());
+  std::string nclxrate = gSystem->ExpandPathName(loopersParam.nclxrate.c_str());
+  const auto& scaler_pair = gSystem->ExpandPathName(loopersParam.scaler_pair.c_str());
+  const auto& scaler_compton = gSystem->ExpandPathName(loopersParam.scaler_compton.c_str());
+  const auto& poisson = gSystem->ExpandPathName(loopersParam.poisson.c_str());
+  const auto& gauss = gSystem->ExpandPathName(loopersParam.gauss.c_str());
+  const auto& flat_gas = loopersParam.flat_gas;
+  const auto& colsys = loopersParam.colsys;
+  if (flat_gas) {
+    if (colsys != "PbPb" && colsys != "pp") {
+      LOG(warning) << "Automatic background loopers configuration supports only 'pp' and 'PbPb' systems.";
+      LOG(warning) << "Fast loopers generator will remain OFF.";
+      return kFALSE;
+    }
+    bool isContext = std::filesystem::exists("collisioncontext.root");
+    if (!isContext) {
+      LOG(warning) << "Warning: No collisioncontext.root file found!";
+      LOG(warning) << "Loopers will be kept OFF.";
+      return kFALSE;
+    }
+  }
+  std::array<float, 2> multiplier = {loopersParam.multiplier[0], loopersParam.multiplier[1]};
+  unsigned int nLoopersPairs = loopersParam.fixedNLoopers[0];
+  unsigned int nLoopersCompton = loopersParam.fixedNLoopers[1];
+  const std::array<std::string, 3> models = {model_pairs, model_compton, nclxrate};
+  const std::array<std::string, 3> local_names = {"WGANpair.onnx", "WGANcompton.onnx", "nclxrate.root"};
+  const std::array<bool, 3> isAlien = {models[0].starts_with("alien://"), models[1].starts_with("alien://"), models[2].starts_with("alien://")};
+  const std::array<bool, 3> isCCDB = {models[0].starts_with("ccdb://"), models[1].starts_with("ccdb://"), models[2].starts_with("ccdb://")};
+  if (std::any_of(isAlien.begin(), isAlien.end(), [](bool v) { return v; })) {
+    if (!gGrid) {
+      TGrid::Connect("alien://");
+      if (!gGrid) {
+        LOG(fatal) << "AliEn connection failed, check token.";
+        exit(1);
+      }
+    }
+    for (size_t i = 0; i < models.size(); ++i) {
+      if (isAlien[i] && !TFile::Cp(models[i].c_str(), local_names[i].c_str())) {
+        LOG(fatal) << "Error: Model file " << models[i] << " does not exist!";
+        exit(1);
+      }
+    }
+  }
+  if (std::any_of(isCCDB.begin(), isCCDB.end(), [](bool v) { return v; })) {
+    auto& ccdb = o2::ccdb::BasicCCDBManager::instance();
+    ccdb.setURL("http://alice-ccdb.cern.ch");
+    // Get underlying CCDB API from BasicCCDBManager
+    auto& ccdb_api = ccdb.getCCDBAccessor();
+    for (size_t i = 0; i < models.size(); ++i) {
+      if (isCCDB[i]) {
+        auto model_path = models[i].substr(7); // Remove "ccdb://"
+        // Treat filename if provided in the CCDB path
+        auto extension = model_path.find(".onnx");
+        if (extension != std::string::npos) {
+          auto last_slash = model_path.find_last_of('/');
+          model_path = model_path.substr(0, last_slash);
+        }
+        std::map<std::string, std::string> filter;
+        if (!ccdb_api.retrieveBlob(model_path, "./", filter, o2::ccdb::getCurrentTimestamp(), false, local_names[i].c_str())) {
+          LOG(fatal) << "Error: issues in retrieving " << model_path << " from CCDB!";
+          exit(1);
+        }
+      }
+    }
+  }
+  model_pairs = isAlien[0] || isCCDB[0] ? local_names[0] : model_pairs;
+  model_compton = isAlien[1] || isCCDB[1] ? local_names[1] : model_compton;
+  nclxrate = isAlien[2] || isCCDB[2] ? local_names[2] : nclxrate;
+  try {
+    // Create the TPC loopers generator with the provided parameters
+    mTPCLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
+    const auto& intrate = loopersParam.intrate;
+    // Configure the generator with flat gas loopers defined per orbit with clusters/track info
+    // If intrate is negative (default), automatic IR from collisioncontext.root will be used
+    if (flat_gas) {
+      mTPCLoopersGen->SetRate(nclxrate, (colsys == "PbPb") ? true : false, intrate);
+      mTPCLoopersGen->SetAdjust(loopersParam.adjust_flatgas);
+    } else {
+      // Otherwise, Poisson+Gauss sampling or fixed number of loopers per event will be used
+      // Multiplier is applied only with distribution sampling
+      // This configuration can be used for testing purposes, in all other cases flat gas is recommended
+      mTPCLoopersGen->SetNLoopers(nLoopersPairs, nLoopersCompton);
+      mTPCLoopersGen->SetMultiplier(multiplier);
+    }
+    LOG(info) << "TPC Loopers generator initialized successfully";
+  } catch (const std::exception& e) {
+    LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
+    mTPCLoopersGen.reset();
+  }
+  return kTRUE;
 }
+#endif
 
 /*****************************************************************/
 
@@ -64,6 +207,41 @@ Bool_t
 
 /*****************************************************************/
 
+Bool_t
+  Generator::finalizeEvent()
+{
+#ifdef GENERATORS_WITH_TPCLOOPERS
+  if (mAddTPCLoopers) {
+    if (!mTPCLoopersGen) {
+      LOG(error) << "Loopers generator not initialized";
+      return kFALSE;
+    }
+
+    // Generate loopers using the initialized TPC loopers generator
+    if (!mTPCLoopersGen->generateEvent()) {
+      LOG(error) << "Failed to generate loopers event";
+      return kFALSE;
+    }
+    if (mTPCLoopersGen->getNLoopers() == 0) {
+      LOG(warning) << "No loopers generated for this event";
+      return kTRUE;
+    }
+    const auto& looperParticles = mTPCLoopersGen->importParticles();
+    if (looperParticles.empty()) {
+      LOG(error) << "Failed to import loopers particles";
+      return kFALSE;
+    }
+    // Append the generated looper particles to the main particle list
+    mParticles.insert(mParticles.end(), looperParticles.begin(), looperParticles.end());
+
+    LOG(debug) << "Added " << looperParticles.size() << " looper particles";
+  }
+#endif
+  return kTRUE;
+}
+
+/*****************************************************************/
+
 Bool_t
   Generator::ReadEvent(FairPrimaryGenerator* primGen)
 {
@@ -91,6 +269,12 @@ Bool_t
       return kFALSE;
     }
 
+    /** Event finalization**/
+    if (!finalizeEvent()) {
+      LOG(error) << "ReadEvent failed in finalizeEvent";
+      return kFALSE;
+    }
+
     if (mSubGeneratorsIdToDesc.empty() && mSubGeneratorId > -1) {
       LOG(fatal) << "ReadEvent failed because no SubGenerator description given";
     }
diff --git a/Generators/src/GeneratorsLinkDef.h b/Generators/src/GeneratorsLinkDef.h
index 2b8d42f86bf9b..24b3f2e452498 100644
--- a/Generators/src/GeneratorsLinkDef.h
+++ b/Generators/src/GeneratorsLinkDef.h
@@ -35,6 +35,10 @@
 #pragma link C++ class o2::eventgen::GeneratorFromEventPool + ;
 #pragma link C++ class o2::eventgen::GeneratorEventPoolParam + ;
 #pragma link C++ class o2::eventgen::EventPoolGenConfig + ;
+#ifdef GENERATORS_WITH_TPCLOOPERS
+#pragma link C++ class o2::eventgen::GenTPCLoopers + ;
+#pragma link C++ class o2::eventgen::GenTPCLoopersParam + ;
+#endif
 #pragma link C++ class o2::conf::ConfigurableParamPromoter < o2::eventgen::GeneratorEventPoolParam, o2::eventgen::EventPoolGenConfig> + ;
 #ifdef GENERATORS_WITH_HEPMC3
 #pragma link C++ class o2::eventgen::GeneratorHepMC + ;
diff --git a/Generators/src/TPCLoopers.cxx b/Generators/src/TPCLoopers.cxx
new file mode 100644
index 0000000000000..6e5af7c0c84d8
--- /dev/null
+++ b/Generators/src/TPCLoopers.cxx
@@ -0,0 +1,486 @@
+// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \author M+Giacalone - September 2025
+
+#include "Generators/TPCLoopers.h"
+#include "CCDB/CCDBTimeStampUtils.h"
+#include "CCDB/CcdbApi.h"
+#include "DetectorsRaw/HBFUtils.h"
+#include "TF1.h"
+#include <filesystem>
+#include <SimulationDataFormat/ParticleStatus.h>
+#include "SimulationDataFormat/MCGenProperties.h"
+#include <iostream>
+#include <fstream>
+#include "TDatabasePDG.h"
+
+// Static Ort::Env instance for multiple onnx model loading
+Ort::Env global_env(ORT_LOGGING_LEVEL_WARNING, "GlobalEnv");
+
+// This class is responsible for loading the scaler parameters from a JSON file
+// and applying the inverse transformation to the generated data.
+
+void Scaler::load(const std::string& filename)
+{
+  std::ifstream file(filename);
+  if (!file.is_open()) {
+    throw std::runtime_error("Error: Could not open scaler file!");
+  }
+
+  std::string json_str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+  file.close();
+
+  rapidjson::Document doc;
+  doc.Parse(json_str.c_str());
+
+  if (doc.HasParseError()) {
+    throw std::runtime_error("Error: JSON parsing failed!");
+  }
+
+  normal_min = jsonArrayToVector(doc["normal"]["min"]);
+  normal_max = jsonArrayToVector(doc["normal"]["max"]);
+  outlier_center = jsonArrayToVector(doc["outlier"]["center"]);
+  outlier_scale = jsonArrayToVector(doc["outlier"]["scale"]);
+}
+
+std::vector<double> Scaler::inverse_transform(const std::vector<double>& input)
+{
+  std::vector<double> output;
+  for (int i = 0; i < input.size(); ++i) {
+    if (i < input.size() - 2) {
+      output.push_back(input[i] * (normal_max[i] - normal_min[i]) + normal_min[i]);
+    } else {
+      output.push_back(input[i] * outlier_scale[i - (input.size() - 2)] + outlier_center[i - (input.size() - 2)]);
+    }
+  }
+
+  return output;
+}
+
+std::vector<double> Scaler::jsonArrayToVector(const rapidjson::Value& jsonArray)
+{
+  std::vector<double> vec;
+  for (int i = 0; i < jsonArray.Size(); ++i) {
+    vec.push_back(jsonArray[i].GetDouble());
+  }
+  return vec;
+}
+
+// This class loads the ONNX model and generates samples using it.
+
+ONNXGenerator::ONNXGenerator(Ort::Env& shared_env, const std::string& model_path)
+  : env(shared_env), session(env, model_path.c_str(), Ort::SessionOptions{})
+{
+  // Create session options
+  Ort::SessionOptions session_options;
+  session = Ort::Session(env, model_path.c_str(), session_options);
+}
+
+std::vector<double> ONNXGenerator::generate_sample()
+{
+  Ort::AllocatorWithDefaultOptions allocator;
+
+  // Generate a latent vector (z)
+  std::vector<float> z(100);
+  for (auto& v : z) {
+    v = rand_gen.Gaus(0.0, 1.0);
+  }
+
+  // Prepare input tensor
+  std::vector<int64_t> input_shape = {1, 100};
+  // Get memory information
+  Ort::MemoryInfo memory_info = Ort::MemoryInfo::CreateCpu(OrtArenaAllocator, OrtMemTypeDefault);
+
+  // Create input tensor correctly
+  Ort::Value input_tensor = Ort::Value::CreateTensor<float>(
+    memory_info, z.data(), z.size(), input_shape.data(), input_shape.size());
+  // Run inference
+  const char* input_names[] = {"z"};
+  const char* output_names[] = {"output"};
+  auto output_tensors = session.Run(Ort::RunOptions{nullptr}, input_names, &input_tensor, 1, output_names, 1);
+
+  // Extract output
+  float* output_data = output_tensors.front().GetTensorMutableData<float>();
+  // Get the size of the output tensor
+  auto output_tensor_info = output_tensors.front().GetTensorTypeAndShapeInfo();
+  size_t output_data_size = output_tensor_info.GetElementCount(); // Total number of elements in the tensor
+  std::vector<double> output;
+  for (int i = 0; i < output_data_size; ++i) {
+    output.push_back(output_data[i]);
+  }
+
+  return output;
+}
+
+namespace o2
+{
+namespace eventgen
+{
+
+GenTPCLoopers::GenTPCLoopers(std::string model_pairs, std::string model_compton,
+                             std::string poisson, std::string gauss, std::string scaler_pair,
+                             std::string scaler_compton)
+{
+  // Checking if the model files exist and are not empty
+  std::ifstream model_file[2];
+  model_file[0].open(model_pairs);
+  model_file[1].open(model_compton);
+  if (!model_file[0].is_open() || model_file[0].peek() == std::ifstream::traits_type::eof()) {
+    LOG(fatal) << "Error: Pairs model file is empty or does not exist!";
+    exit(1);
+  }
+  if (!model_file[1].is_open() || model_file[1].peek() == std::ifstream::traits_type::eof()) {
+    LOG(fatal) << "Error: Compton model file is empty or does not exist!";
+    exit(1);
+  }
+  model_file[0].close();
+  model_file[1].close();
+  // Checking if the scaler files exist and are not empty
+  std::ifstream scaler_file[2];
+  scaler_file[0].open(scaler_pair);
+  scaler_file[1].open(scaler_compton);
+  if (!scaler_file[0].is_open() || scaler_file[0].peek() == std::ifstream::traits_type::eof()) {
+    LOG(fatal) << "Error: Pairs scaler file is empty or does not exist!";
+    exit(1);
+  }
+  if (!scaler_file[1].is_open() || scaler_file[1].peek() == std::ifstream::traits_type::eof()) {
+    LOG(fatal) << "Error: Compton scaler file is empty or does not exist!";
+    exit(1);
+  }
+  scaler_file[0].close();
+  scaler_file[1].close();
+  // Checking if the poisson file exists and it's not empty
+  if (poisson != "" && poisson != "None" && poisson != "none") {
+    std::ifstream poisson_file(poisson);
+    if (!poisson_file.is_open() || poisson_file.peek() == std::ifstream::traits_type::eof()) {
+      LOG(fatal) << "Error: Poisson file is empty or does not exist!";
+      exit(1);
+    } else {
+      poisson_file >> mPoisson[0] >> mPoisson[1] >> mPoisson[2];
+      poisson_file.close();
+      mPoissonSet = true;
+    }
+  }
+  // Checking if the gauss file exists and it's not empty
+  if (gauss != "" && gauss != "None" && gauss != "none") {
+    std::ifstream gauss_file(gauss);
+    if (!gauss_file.is_open() || gauss_file.peek() == std::ifstream::traits_type::eof()) {
+      LOG(fatal) << "Error: Gauss file is empty or does not exist!";
+      exit(1);
+    } else {
+      gauss_file >> mGauss[0] >> mGauss[1] >> mGauss[2] >> mGauss[3];
+      gauss_file.close();
+      mGaussSet = true;
+    }
+  }
+  mONNX_pair = std::make_unique<ONNXGenerator>(global_env, model_pairs);
+  mScaler_pair = std::make_unique<Scaler>();
+  mScaler_pair->load(scaler_pair);
+  mONNX_compton = std::make_unique<ONNXGenerator>(global_env, model_compton);
+  mScaler_compton = std::make_unique<Scaler>();
+  mScaler_compton->load(scaler_compton);
+}
+
+Bool_t GenTPCLoopers::generateEvent()
+{
+  // Clear the vector of pairs
+  mGenPairs.clear();
+  // Clear the vector of compton electrons
+  mGenElectrons.clear();
+  if (mFlatGas) {
+    unsigned int nLoopers, nLoopersPairs, nLoopersCompton;
+    LOG(debug) << "mCurrentEvent is " << mCurrentEvent;
+    LOG(debug) << "Current event time: " << ((mCurrentEvent < mInteractionTimeRecords.size() - 1) ? std::to_string(mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns()) : std::to_string(mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns())) << " ns";
+    LOG(debug) << "Current time offset wrt BC: " << mInteractionTimeRecords[mCurrentEvent].getTimeOffsetWrtBC() << " ns";
+    mTimeLimit = (mCurrentEvent < mInteractionTimeRecords.size() - 1) ? mInteractionTimeRecords[mCurrentEvent + 1].bc2ns() - mInteractionTimeRecords[mCurrentEvent].bc2ns() : mTimeEnd - mInteractionTimeRecords[mCurrentEvent].bc2ns();
+    // With flat gas the number of loopers are adapted based on time interval widths
+    // The denominator is either the LHC orbit (if mFlatGasOrbit is true) or the mean interaction time record interval
+    nLoopers = mFlatGasOrbit ? (mFlatGasNumber * (mTimeLimit / o2::constants::lhc::LHCOrbitNS)) : (mFlatGasNumber * (mTimeLimit / mIntTimeRecMean));
+    nLoopersPairs = static_cast<unsigned int>(std::round(nLoopers * mLoopsFractionPairs));
+    nLoopersCompton = nLoopers - nLoopersPairs;
+    SetNLoopers(nLoopersPairs, nLoopersCompton);
+    LOG(info) << "Flat gas loopers: " << nLoopers << " (pairs: " << nLoopersPairs << ", compton: " << nLoopersCompton << ")";
+    generateEvent(mTimeLimit);
+    mCurrentEvent++;
+  } else {
+    // Set number of loopers if poissonian params are available
+    if (mPoissonSet) {
+      mNLoopersPairs = static_cast<unsigned int>(std::round(mMultiplier[0] * PoissonPairs()));
+      LOG(debug) << "Generated loopers pairs (Poisson): " << mNLoopersPairs;
+    }
+    if (mGaussSet) {
+      mNLoopersCompton = static_cast<unsigned int>(std::round(mMultiplier[1] * GaussianElectrons()));
+      LOG(debug) << "Generated compton electrons (Gauss): " << mNLoopersCompton;
+    }
+    // Generate pairs
+    for (int i = 0; i < mNLoopersPairs; ++i) {
+      std::vector<double> pair = mONNX_pair->generate_sample();
+      // Apply the inverse transformation using the scaler
+      std::vector<double> transformed_pair = mScaler_pair->inverse_transform(pair);
+      mGenPairs.push_back(transformed_pair);
+    }
+    // Generate compton electrons
+    for (int i = 0; i < mNLoopersCompton; ++i) {
+      std::vector<double> electron = mONNX_compton->generate_sample();
+      // Apply the inverse transformation using the scaler
+      std::vector<double> transformed_electron = mScaler_compton->inverse_transform(electron);
+      mGenElectrons.push_back(transformed_electron);
+    }
+  }
+  return true;
+}
+
+Bool_t GenTPCLoopers::generateEvent(double time_limit)
+{
+  LOG(info) << "Time constraint for loopers: " << time_limit << " ns";
+  // Generate pairs
+  for (int i = 0; i < mNLoopersPairs; ++i) {
+    std::vector<double> pair = mONNX_pair->generate_sample();
+    // Apply the inverse transformation using the scaler
+    std::vector<double> transformed_pair = mScaler_pair->inverse_transform(pair);
+    transformed_pair[9] = gRandom->Uniform(0., time_limit); // Regenerate time, scaling is not needed because time_limit is already in nanoseconds
+    mGenPairs.push_back(transformed_pair);
+  }
+  // Generate compton electrons
+  for (int i = 0; i < mNLoopersCompton; ++i) {
+    std::vector<double> electron = mONNX_compton->generate_sample();
+    // Apply the inverse transformation using the scaler
+    std::vector<double> transformed_electron = mScaler_compton->inverse_transform(electron);
+    transformed_electron[6] = gRandom->Uniform(0., time_limit); // Regenerate time, scaling is not needed because time_limit is already in nanoseconds
+    mGenElectrons.push_back(transformed_electron);
+  }
+  LOG(info) << "Generated Particles with time limit";
+  return true;
+}
+
+std::vector<TParticle> GenTPCLoopers::importParticles()
+{
+  std::vector<TParticle> particles;
+  const double mass_e = TDatabasePDG::Instance()->GetParticle(11)->Mass();
+  const double mass_p = TDatabasePDG::Instance()->GetParticle(-11)->Mass();
+  // Get looper pairs from the event
+  for (auto& pair : mGenPairs) {
+    double px_e, py_e, pz_e, px_p, py_p, pz_p;
+    double vx, vy, vz, time;
+    double e_etot, p_etot;
+    px_e = pair[0];
+    py_e = pair[1];
+    pz_e = pair[2];
+    px_p = pair[3];
+    py_p = pair[4];
+    pz_p = pair[5];
+    vx = pair[6];
+    vy = pair[7];
+    vz = pair[8];
+    time = pair[9];
+    e_etot = TMath::Sqrt(px_e * px_e + py_e * py_e + pz_e * pz_e + mass_e * mass_e);
+    p_etot = TMath::Sqrt(px_p * px_p + py_p * py_p + pz_p * pz_p + mass_p * mass_p);
+    // Push the electron
+    TParticle electron(11, 1, -1, -1, -1, -1, px_e, py_e, pz_e, e_etot, vx, vy, vz, time / 1e9);
+    electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
+    electron.SetBit(ParticleStatus::kToBeDone, //
+                    o2::mcgenstatus::getHepMCStatusCode(electron.GetStatusCode()) == 1);
+    particles.push_back(electron);
+    // Push the positron
+    TParticle positron(-11, 1, -1, -1, -1, -1, px_p, py_p, pz_p, p_etot, vx, vy, vz, time / 1e9);
+    positron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(positron.GetStatusCode(), 0).fullEncoding);
+    positron.SetBit(ParticleStatus::kToBeDone, //
+                    o2::mcgenstatus::getHepMCStatusCode(positron.GetStatusCode()) == 1);
+    particles.push_back(positron);
+  }
+  // Get compton electrons from the event
+  for (auto& compton : mGenElectrons) {
+    double px, py, pz;
+    double vx, vy, vz, time;
+    double etot;
+    px = compton[0];
+    py = compton[1];
+    pz = compton[2];
+    vx = compton[3];
+    vy = compton[4];
+    vz = compton[5];
+    time = compton[6];
+    etot = TMath::Sqrt(px * px + py * py + pz * pz + mass_e * mass_e);
+    // Push the electron
+    TParticle electron(11, 1, -1, -1, -1, -1, px, py, pz, etot, vx, vy, vz, time / 1e9);
+    electron.SetStatusCode(o2::mcgenstatus::MCGenStatusEncoding(electron.GetStatusCode(), 0).fullEncoding);
+    electron.SetBit(ParticleStatus::kToBeDone, //
+                    o2::mcgenstatus::getHepMCStatusCode(electron.GetStatusCode()) == 1);
+    particles.push_back(electron);
+  }
+
+  return particles;
+}
+
+unsigned int GenTPCLoopers::PoissonPairs()
+{
+  unsigned int poissonValue;
+  do {
+    // Generate a Poisson-distributed random number with mean mPoisson[0]
+    poissonValue = mRandGen.Poisson(mPoisson[0]);
+  } while (poissonValue < mPoisson[1] || poissonValue > mPoisson[2]); // Regenerate if out of range
+
+  return poissonValue;
+}
+
+unsigned int GenTPCLoopers::GaussianElectrons()
+{
+  unsigned int gaussValue;
+  do {
+    // Generate a Normal-distributed random number with mean mGass[0] and stddev mGauss[1]
+    gaussValue = mRandGen.Gaus(mGauss[0], mGauss[1]);
+  } while (gaussValue < mGauss[2] || gaussValue > mGauss[3]); // Regenerate if out of range
+
+  return gaussValue;
+}
+
+void GenTPCLoopers::SetNLoopers(unsigned int nsig_pair, unsigned int nsig_compton)
+{
+  if (mFlatGas) {
+    mNLoopersPairs = nsig_pair;
+    mNLoopersCompton = nsig_compton;
+  } else {
+    if (mPoissonSet) {
+      LOG(info) << "Poissonian parameters correctly loaded.";
+    } else {
+      mNLoopersPairs = nsig_pair;
+    }
+    if (mGaussSet) {
+      LOG(info) << "Gaussian parameters correctly loaded.";
+    } else {
+      mNLoopersCompton = nsig_compton;
+    }
+  }
+}
+
+void GenTPCLoopers::SetMultiplier(const std::array<float, 2>& mult)
+{
+  // Multipliers will work only if the poissonian and gaussian parameters are set
+  // otherwise they will be ignored
+  if (mult[0] < 0 || mult[1] < 0) {
+    LOG(fatal) << "Error: Multiplier values must be non-negative!";
+    exit(1);
+  } else {
+    LOG(info) << "Multiplier values set to: Pair = " << mult[0] << ", Compton = " << mult[1];
+    mMultiplier[0] = mult[0];
+    mMultiplier[1] = mult[1];
+  }
+}
+
+void GenTPCLoopers::setFlatGas(Bool_t flat, Int_t number, Int_t nloopers_orbit)
+{
+  mFlatGas = flat;
+  if (mFlatGas) {
+    if (nloopers_orbit > 0) {
+      mFlatGasOrbit = true;
+      mFlatGasNumber = nloopers_orbit;
+      LOG(info) << "Flat gas loopers will be generated using orbit reference.";
+    } else {
+      mFlatGasOrbit = false;
+      if (number < 0) {
+        LOG(warn) << "Warning: Number of loopers per event must be non-negative! Switching option off.";
+        mFlatGas = false;
+        mFlatGasNumber = -1;
+      } else {
+        mFlatGasNumber = number;
+      }
+    }
+    if (mFlatGas) {
+      mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
+      mCollisionContext = mContextFile ? (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext") : nullptr;
+      mInteractionTimeRecords = mCollisionContext ? mCollisionContext->getEventRecords() : std::vector<o2::InteractionTimeRecord>{};
+      if (mInteractionTimeRecords.empty()) {
+        LOG(error) << "Error: No interaction time records found in the collision context!";
+        exit(1);
+      } else {
+        LOG(info) << "Interaction Time records has " << mInteractionTimeRecords.size() << " entries.";
+        mCollisionContext->printCollisionSummary();
+      }
+      for (int c = 0; c < mInteractionTimeRecords.size() - 1; c++) {
+        mIntTimeRecMean += mInteractionTimeRecords[c + 1].bc2ns() - mInteractionTimeRecords[c].bc2ns();
+      }
+      mIntTimeRecMean /= (mInteractionTimeRecords.size() - 1); // Average interaction time record used as reference
+      const auto& hbfUtils = o2::raw::HBFUtils::Instance();
+      // Get the start time of the second orbit after the last interaction record
+      const auto& lastIR = mInteractionTimeRecords.back();
+      o2::InteractionRecord finalOrbitIR(0, lastIR.orbit + 2); // Final orbit, BC = 0
+      mTimeEnd = finalOrbitIR.bc2ns();
+      LOG(debug) << "Final orbit start time: " << mTimeEnd << " ns while last interaction record time is " << mInteractionTimeRecords.back().bc2ns() << " ns";
+    }
+  } else {
+    mFlatGasNumber = -1;
+  }
+  LOG(info) << "Flat gas loopers: " << (mFlatGas ? "ON" : "OFF") << ", Reference loopers number per " << (mFlatGasOrbit ? "orbit " : "event ") << mFlatGasNumber;
+}
+
+void GenTPCLoopers::setFractionPairs(float fractionPairs)
+{
+  if (fractionPairs < 0 || fractionPairs > 1) {
+    LOG(fatal) << "Error: Loops fraction for pairs must be in the range [0, 1].";
+    exit(1);
+  }
+  mLoopsFractionPairs = fractionPairs;
+  LOG(info) << "Pairs fraction set to: " << mLoopsFractionPairs;
+}
+
+void GenTPCLoopers::SetRate(const std::string& rateFile, bool isPbPb = true, int intRate)
+{
+  // Checking if the rate file exists and is not empty
+  TFile rate_file(rateFile.c_str(), "READ");
+  if (!rate_file.IsOpen() || rate_file.IsZombie()) {
+    LOG(fatal) << "Error: Rate file is empty or does not exist!";
+    exit(1);
+  }
+  const char* fitName = isPbPb ? "fitPbPb" : "fitpp";
+  auto fit = (TF1*)rate_file.Get(fitName);
+  if (!fit) {
+    LOG(fatal) << "Error: Could not find fit function '" << fitName << "' in rate file!";
+    exit(1);
+  }
+  mInteractionRate = intRate;
+  if (mInteractionRate < 0) {
+    mContextFile = std::filesystem::exists("collisioncontext.root") ? TFile::Open("collisioncontext.root") : nullptr;
+    if (!mContextFile || mContextFile->IsZombie()) {
+      LOG(fatal) << "Error: Interaction rate not provided and collision context file not found!";
+      exit(1);
+    }
+    mCollisionContext = (o2::steer::DigitizationContext*)mContextFile->Get("DigitizationContext");
+    mInteractionRate = std::floor(mCollisionContext->getDigitizerInteractionRate());
+    LOG(info) << "Interaction rate retrieved from collision context: " << mInteractionRate << " Hz";
+    if (mInteractionRate < 0) {
+      LOG(fatal) << "Error: Invalid interaction rate retrieved from collision context!";
+      exit(1);
+    }
+  }
+  auto ref = static_cast<int>(std::floor(fit->Eval(mInteractionRate / 1000.))); // fit expects rate in kHz
+  rate_file.Close();
+  if (ref <= 0) {
+    LOG(fatal) << "Computed flat gas number reference per orbit is <=0";
+    exit(1);
+  } else {
+    LOG(info) << "Set flat gas number to " << ref << " loopers per orbit using " << fitName << " from " << mInteractionRate << " Hz interaction rate.";
+    auto flat = true;
+    setFlatGas(flat, -1, ref);
+  }
+}
+
+void GenTPCLoopers::SetAdjust(float adjust)
+{
+  if (mFlatGas && mFlatGasOrbit && adjust >= -1.f && adjust != 0.f) {
+    LOG(info) << "Adjusting flat gas number per orbit by " << adjust * 100.f << "%";
+    mFlatGasNumber = static_cast<int>(std::round(mFlatGasNumber * (1.f + adjust)));
+    LOG(info) << "New flat gas number per orbit: " << mFlatGasNumber;
+  }
+}
+
+} // namespace eventgen
+} // namespace o2
\ No newline at end of file
diff --git a/Generators/src/TPCLoopersParam.cxx b/Generators/src/TPCLoopersParam.cxx
new file mode 100644
index 0000000000000..0202a8ced0535
--- /dev/null
+++ b/Generators/src/TPCLoopersParam.cxx
@@ -0,0 +1,15 @@
+// Copyright 2024-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \author M+Giacalone - September 2025
+
+#include "Generators/TPCLoopersParam.h"
+O2ParamImpl(o2::eventgen::GenTPCLoopersParam);
diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 6408588d46e68..e2ecca590140f 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -54,8 +54,8 @@ O2SIMSEED=${O2SIMSEED:-0}
 SPLITTRDDIGI=${SPLITTRDDIGI:-1}
 DIGITDOWNSCALINGTRD=${DIGITDOWNSCALINGTRD:-1000}
 NHBPERTF=${NHBPERTF:-128}
-RUNFIRSTORBIT=${RUNFIRSTORBIT:-0}
-FIRSTSAMPLEDORBIT=${FIRSTSAMPLEDORBIT:-0}
+RUNFIRSTORBIT=${RUNFIRSTORBIT:-256}
+FIRSTSAMPLEDORBIT=${FIRSTSAMPLEDORBIT:-256}
 OBLIGATORYSOR=${OBLIGATORYSOR:-false}
 FST_TPC_ZSVERSION=${FST_TPC_ZSVERSION:-4}
 TPC_SLOW_REALISITC_FULL_SIM=${TPC_SLOW_REALISITC_FULL_SIM:-0}
@@ -137,11 +137,40 @@ if [[ $TPC_SLOW_REALISITC_FULL_SIM == 1 ]]; then
   DIGITOPTKEY+="TPCEleParam.doCommonModePerPad=0;TPCEleParam.doIonTailPerPad=1;TPCEleParam.commonModeCoupling=0;TPCEleParam.doNoiseEmptyPads=1;TPCEleParam.doSaturationTail=0;TPCDetParam.TPCRecoWindowSim=10;"
 fi
 
-taskwrapper sim.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} --seed $O2SIMSEED -n $NEvents --configKeyValues "\"$SIMOPTKEY\"" -g ${FST_GENERATOR} -e ${FST_MC_ENGINE} -j $NJOBS --run ${RUNNUMBER} -o o2sim
+# Create collision context
+SIGNALSPEC="o2sim,${FST_COLRATE},1000000:1000000"
+QEDSPEC=""
+if [[ $FST_QED == 1 ]]; then
+  PbPbXSec="8."
+  QEDXSECRATIO=$(awk "BEGIN {printf \"%.2f\",`grep xSectionQED qed/qedgenparam.ini | cut -d'=' -f 2`/$PbPbXSec}")
+  QEDRATE=$(awk "BEGIN {printf \"%.2f\",${FST_COLRATE}*${QEDXSECRATIO}}")
+  QEDSPEC="--QEDinteraction qed,${QEDRATE},10000000:${NEventsQED}"
+fi
+
+taskwrapper collcontext.log o2-steer-colcontexttool \
+  -i ${SIGNALSPEC} \
+  --show-context \
+  --timeframeID 0 \
+  --orbitsPerTF ${NHBPERTF} \
+  --orbits $(( ${NTIMEFRAMES} * ${NHBPERTF} )) \
+  --seed ${O2SIMSEED} \
+  --noEmptyTF \
+  --first-orbit ${RUNFIRSTORBIT} \
+  --extract-per-timeframe tf:o2sim \
+  --with-vertices kCCDB \
+  --maxCollsPerTF ${NEvents} \
+  --orbitsEarly 1 \
+  --bcPatternFile ccdb \
+  ${QEDSPEC}
+
+# Include collision system for TPC loopers generation
+SIMOPTKEY+="GenTPCLoopers.colsys=${BEAMTYPE};"
+
+taskwrapper sim.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} --vertexMode kCollContext --seed $O2SIMSEED -n $NEvents --configKeyValues "\"$SIMOPTKEY\"" -g ${FST_GENERATOR} -e ${FST_MC_ENGINE} -j $NJOBS --run ${RUNNUMBER} -o o2sim --fromCollContext collisioncontext.root:o2sim
 if [[ $DO_EMBEDDING == 1 ]]; then
   taskwrapper embed.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} -j $NJOBS --run ${RUNNUMBER} -n $NEvents -g pythia8pp -e ${FST_MC_ENGINE} -o sig --configKeyValues ${FST_EMBEDDING_CONFIG} --embedIntoFile o2sim_MCHeader.root
 fi
-taskwrapper digi.log o2-sim-digitizer-workflow -n $NEvents ${DIGIQED} ${NOMCLABELS} --sims ${SIM_SOURCES} --tpc-lanes $((NJOBS < 36 ? NJOBS : 36)) --shm-segment-size $SHMSIZE ${GLOBALDPLOPT} ${DIGITOPT} --configKeyValues "\"${DIGITOPTKEY}\"" --interactionRate $FST_COLRATE --early-forward-policy always
+taskwrapper digi.log o2-sim-digitizer-workflow -n $NEvents ${DIGIQED} ${NOMCLABELS} --sims ${SIM_SOURCES} --tpc-lanes $((NJOBS < 36 ? NJOBS : 36)) --shm-segment-size $SHMSIZE ${GLOBALDPLOPT} ${DIGITOPT} --configKeyValues "\"${DIGITOPTKEY}\"" --interactionRate $FST_COLRATE --early-forward-policy always --incontext collisioncontext.root
 [[ $SPLITTRDDIGI == "1" ]] && taskwrapper digiTRD.log o2-sim-digitizer-workflow -n $NEvents ${NOMCLABELS} --sims ${SIM_SOURCES} --onlyDet TRD --trd-digit-downscaling ${DIGITDOWNSCALINGTRD} --shm-segment-size $SHMSIZE ${GLOBALDPLOPT} --incontext collisioncontext.root --configKeyValues "\"${DIGITOPTKEYTRD}\"" --early-forward-policy always
 touch digiTRD.log_done
 

From 52b0e23ac5a60f3953749a91a29285b67d7d1558 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 28 Jan 2026 15:32:46 +0100
Subject: [PATCH 1243/1764] DPL: disable early forwarding for output proxies

---
 Framework/Core/src/DataProcessingDevice.cxx      | 9 +++++++++
 Framework/Core/src/ExternalFairMQDeviceProxy.cxx | 2 ++
 2 files changed, 11 insertions(+)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 3eaab36fb7908..fd03b7725d847 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1070,6 +1070,15 @@ void DataProcessingDevice::fillContext(DataProcessorContext& context, DeviceCont
         break;
       }
     }
+    // Output proxies should wait for the completion policy before forwarding.
+    // Because they actually do not do anything, that's equivalent to
+    // forwarding after the processing.
+    for (auto& label : spec.labels) {
+      if (label.value == "output-proxy") {
+        defaultEarlyForwardPolicy = ForwardPolicy::AfterProcessing;
+        break;
+      }
+    }
 
     /// We must make sure there is no optional
     /// if we want to optimize the forwarding
diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index b4bfc991db9ae..3b0275879a158 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -1045,6 +1045,7 @@ DataProcessorSpec specifyFairMQDeviceOutputProxy(char const* name,
   spec.options = {
     ConfigParamSpec{"channel-config", VariantType::String, d, {"Out-of-band channel config"}},
   };
+  spec.labels.push_back(DataProcessorLabel{"output-proxy"});
 
   return spec;
 }
@@ -1180,6 +1181,7 @@ DataProcessorSpec specifyFairMQDeviceMultiOutputProxy(char const* name,
   spec.options = {
     ConfigParamSpec{"channel-config", VariantType::String, d, {"Out-of-band channel config"}},
   };
+  spec.labels.push_back(DataProcessorLabel{"output-proxy"});
 
   return spec;
 }

From 3669ad3516f3d4a7ced7685735c35d60a15277f7 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Thu, 22 Jan 2026 16:36:03 +0100
Subject: [PATCH 1244/1764] GPU: Parallelize TPC pad filter over pad rows
 instead of cachelines.

---
 GPU/GPUTracking/DataTypes/GPUTPCGeometry.h    |   2 +
 .../Definitions/GPUDefParametersDefaults.h    |   8 +-
 .../Global/GPUChainTrackingClusterizer.cxx    |   2 +-
 .../GPUTPCCFCheckPadBaseline.cxx              | 101 +++++++++++++-----
 .../GPUTPCCFCheckPadBaseline.h                |  40 ++++++-
 5 files changed, 118 insertions(+), 35 deletions(-)

diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
index 9ad83bff363ac..13cec6c752fbe 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
@@ -96,6 +96,7 @@ class GPUTPCGeometry // TODO: Make values constexpr
   GPUd() static constexpr int32_t EndIROC() { return 63; }
   GPUd() static constexpr int32_t EndOROC1() { return 97; }
   GPUd() static constexpr int32_t EndOROC2() { return 127; }
+  GPUd() static constexpr int32_t MaxNPadsPerRow() { return 138; }
 #else
   GPUd() static constexpr int32_t GetRegion(int32_t row) { return (row < 63 ? 0 : row < 63 + 64 ? 1 : 2); }
   GPUd() static constexpr int32_t GetRegionRows(int32_t region) { return 0; }  // dummy
@@ -104,6 +105,7 @@ class GPUTPCGeometry // TODO: Make values constexpr
   GPUd() static constexpr int32_t EndIROC() { return 63; }
   GPUd() static constexpr int32_t EndOROC1() { return 63 + 64; }
   GPUd() static constexpr int32_t EndOROC2() { return GPUCA_ROW_COUNT; }
+  GPUd() static constexpr int32_t MaxNPadsPerRow() { return 140; }
 #endif
 
   GPUd() static constexpr float TPCLength() { return 250.f - 0.275f; }
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
index 01ae33dc3b4d8..1be881ee6323e 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
@@ -68,7 +68,7 @@
     #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
     #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
     #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64, 10
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 576, 2
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
@@ -133,7 +133,7 @@
     #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
     #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
     #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64, 2
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 576, 2
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
@@ -197,7 +197,7 @@
     #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 3
     #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
     #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64,8
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 576,2
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 448
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 448
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 448
@@ -447,7 +447,7 @@
     #define GPUCA_LB_GPUTPCStartHitsSorter 256
   #endif
   #ifndef GPUCA_LB_GPUTPCCFCheckPadBaseline
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 64
+    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 576
   #endif
   #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap
     #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 7629086272ed6..bf6577cfd929e 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -962,7 +962,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         checkForNoisyPads &= !GetProcessingSettings().disableTPCNoisyPadFilter;
 
         if (checkForNoisyPads) {
-          int32_t nBlocks = TPC_PADS_IN_SECTOR / GPUTPCCFCheckPadBaseline::PadsPerCacheline;
+          const int32_t nBlocks = GPUTPCCFCheckPadBaseline::GetNBlocks(doGPU);
 
           runKernel<GPUTPCCFCheckPadBaseline>({GetGridBlk(nBlocks, lane), {iSector}});
           getKernelTimer<GPUTPCCFCheckPadBaseline>(RecoStep::TPCClusterFinding, iSector, TPC_PADS_IN_SECTOR * fragment.lengthWithoutOverlap() * sizeof(PackedCharge), false);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
index 3248e517ff465..33ed089890bc4 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
@@ -9,13 +9,12 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file GPUTPCCFCheckPadBaseline.h
+/// \file GPUTPCCFCheckPadBaseline.cxx
 /// \author Felix Weiglhofer
 
 #include "GPUTPCCFCheckPadBaseline.h"
 #include "CfArray2D.h"
 #include "PackedCharge.h"
-#include "GPUTPCGeometry.h"
 #include "clusterFinderDefs.h"
 
 #ifndef GPUCA_GPUCODE
@@ -28,51 +27,88 @@ using namespace o2::gpu::tpccf;
 template <>
 GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
-  const CfFragment& fragment = clusterer.mPmemory->fragment;
-  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
-
-  int32_t basePad = iBlock * PadsPerCacheline;
-  CfChargePos basePos = padToCfChargePos(basePad, clusterer);
+#ifdef GPUCA_GPUCODE
+  CheckBaselineGPU(nBlocks, nThreads, iBlock, iThread, smem, clusterer);
+#else
+  CheckBaselineCPU(nBlocks, nThreads, iBlock, iThread, smem, clusterer);
+#endif
+}
 
-  if (not basePos.valid()) {
+// Charges are stored in a 2D array (pad and time) using a tiling layout.
+// Tiles are 8 pads x 4 timebins large stored in time-major layout and make up a single cacheline.
+//
+// This kernel processes one row per block. Threads cooperatively load chunks
+// of 4 consecutive time bins for all pads into shared memory. Thread `i` then processes charges for pad `i` in shared memory.
+// Blocks require `nextMultipleOf<64>(138 * 4) = 576` threads to process the largest TPC rows with 138 pads correctly.
+GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineGPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
+{
+#ifdef GPUCA_GPUCODE
+  if (iBlock >= GPUCA_ROW_COUNT) {
     return;
   }
 
-#ifdef GPUCA_GPUCODE
-  static_assert(TPC_MAX_FRAGMENT_LEN_GPU % NumOfCachedTimebins == 0);
+  const CfFragment& fragment = clusterer.mPmemory->fragment;
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+
+  const auto iRow = iBlock;
+  const auto rowinfo = GetRowInfo(iRow);
+  const CfChargePos basePos{(Row)iRow, 0, 0};
 
   int32_t totalCharges = 0;
   int32_t consecCharges = 0;
   int32_t maxConsecCharges = 0;
   Charge maxCharge = 0;
 
-  int16_t localPadId = iThread / NumOfCachedTimebins;
-  int16_t localTimeBin = iThread % NumOfCachedTimebins;
-  bool handlePad = localTimeBin == 0;
+  const int16_t iPadOffset = iThread % MaxNPadsPerRow;
+  const int16_t iTimeOffset = iThread / MaxNPadsPerRow;
+  const int16_t iPadHandle = iThread;
+  const bool handlePad = iPadHandle < rowinfo.nPads;
+
+  const auto firstTB = fragment.firstNonOverlapTimeBin();
+  const auto lastTB = fragment.lastNonOverlapTimeBin();
+
+  for (auto t = firstTB; t < lastTB; t += NumOfCachedTBs) {
+
+    const TPCFragmentTime iTime = t + iTimeOffset;
+
+    const CfChargePos pos = basePos.delta({iPadOffset, iTime});
+
+    smem.charges[iTimeOffset][iPadOffset] = iTime < lastTB && iPadOffset < rowinfo.nPads ? chargeMap[pos].unpack() : 0;
 
-  for (tpccf::TPCFragmentTime t = fragment.firstNonOverlapTimeBin(); t < fragment.lastNonOverlapTimeBin(); t += NumOfCachedTimebins) {
-    const CfChargePos pos = basePos.delta({localPadId, int16_t(t + localTimeBin)});
-    smem.charges[localPadId][localTimeBin] = (pos.valid()) ? chargeMap[pos].unpack() : 0;
     GPUbarrier();
+
     if (handlePad) {
-      for (int32_t i = 0; i < NumOfCachedTimebins; i++) {
-        const Charge q = smem.charges[localPadId][i];
+      for (int32_t i = 0; i < NumOfCachedTBs; i++) {
+        const Charge q = smem.charges[i][iPadHandle];
         totalCharges += (q > 0);
         consecCharges = (q > 0) ? consecCharges + 1 : 0;
         maxConsecCharges = CAMath::Max(consecCharges, maxConsecCharges);
         maxCharge = CAMath::Max<Charge>(q, maxCharge);
       }
     }
+
     GPUbarrier();
   }
 
-  GPUbarrier();
-
   if (handlePad) {
-    updatePadBaseline(basePad + localPadId, clusterer, totalCharges, maxConsecCharges, maxCharge);
+    updatePadBaseline(rowinfo.globalPadOffset + iPadOffset, clusterer, totalCharges, maxConsecCharges, maxCharge);
   }
+#endif
+}
 
-#else // CPU CODE
+GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineCPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
+{
+#ifndef GPUCA_GPUCODE
+  const CfFragment& fragment = clusterer.mPmemory->fragment;
+  CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
+
+  int32_t basePad = iBlock * PadsPerCacheline;
+  int32_t padsPerRow;
+  CfChargePos basePos = padToCfChargePos<PadsPerCacheline>(basePad, clusterer, padsPerRow);
+
+  if (not basePos.valid()) {
+    return;
+  }
 
   constexpr size_t ElemsInTileRow = (size_t)TilingLayout<GridSize<2>>::WidthInTiles * TimebinsPerCacheline * PadsPerCacheline;
 
@@ -122,7 +158,8 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
 #endif
 }
 
-GPUd() CfChargePos GPUTPCCFCheckPadBaseline::padToCfChargePos(int32_t& pad, const GPUTPCClusterFinder& clusterer)
+template <int32_t PadsPerBlock>
+GPUd() CfChargePos GPUTPCCFCheckPadBaseline::padToCfChargePos(int32_t& pad, const GPUTPCClusterFinder& clusterer, int32_t& padsPerRow)
 {
   constexpr GPUTPCGeometry geo;
 
@@ -130,17 +167,31 @@ GPUd() CfChargePos GPUTPCCFCheckPadBaseline::padToCfChargePos(int32_t& pad, cons
   for (Row r = 0; r < GPUCA_ROW_COUNT; r++) {
     int32_t npads = geo.NPads(r);
     int32_t padInRow = pad - padOffset;
-    if (0 <= padInRow && padInRow < CAMath::nextMultipleOf<PadsPerCacheline, int32_t>(npads)) {
-      int32_t cachelineOffset = padInRow % PadsPerCacheline;
+    if (0 <= padInRow && padInRow < npads) {
+      int32_t cachelineOffset = padInRow % PadsPerBlock;
       pad -= cachelineOffset;
+      padsPerRow = npads;
       return CfChargePos{r, Pad(padInRow - cachelineOffset), 0};
     }
     padOffset += npads;
   }
 
+  padsPerRow = 0;
   return CfChargePos{0, 0, INVALID_TIME_BIN};
 }
 
+GPUd() GPUTPCCFCheckPadBaseline::RowInfo GPUTPCCFCheckPadBaseline::GetRowInfo(int16_t row)
+{
+  constexpr GPUTPCGeometry geo;
+
+  int16_t padOffset = 0;
+  for (int16_t r = 0; r < row; r++) {
+    padOffset += geo.NPads(r);
+  }
+
+  return RowInfo{padOffset, geo.NPads(row)};
+}
+
 GPUd() void GPUTPCCFCheckPadBaseline::updatePadBaseline(int32_t pad, const GPUTPCClusterFinder& clusterer, int32_t totalCharges, int32_t consecCharges, Charge maxCharge)
 {
   const CfFragment& fragment = clusterer.mPmemory->fragment;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
index 25c93a4649662..a71f1358a73a6 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
@@ -11,14 +11,20 @@
 
 /// \file GPUTPCCFCheckPadBaseline.h
 /// \author Felix Weiglhofer
+///
+/// Kernel identifies noisy TPC pads by analyzing charge patterns over time.
+/// A pad is marked noisy if it exceeds thresholds for total or consecutive
+/// time bins with charge, unless the charge exceeds a saturation threshold.
 
 #ifndef O2_GPU_GPU_TPC_CF_CHECK_PAD_BASELINE_H
 #define O2_GPU_GPU_TPC_CF_CHECK_PAD_BASELINE_H
 
 #include "GPUGeneralKernels.h"
 #include "GPUConstantMem.h"
+#include "GPUTPCGeometry.h"
 
 #include "clusterFinderDefs.h"
+#include "CfArray2D.h"
 
 namespace o2::gpu
 {
@@ -28,13 +34,20 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
 
  public:
   enum {
-    PadsPerCacheline = 8,
-    TimebinsPerCacheline = 4,
-    NumOfCachedTimebins = GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFCheckPadBaseline) / PadsPerCacheline,
+    PadsPerCacheline = TPCMapMemoryLayout<uint16_t>::Width,
+    TimebinsPerCacheline = TPCMapMemoryLayout<uint16_t>::Height,
+    EntriesPerCacheline = PadsPerCacheline * TimebinsPerCacheline,
+    NumOfCachedPads = GPUCA_WARP_SIZE / TimebinsPerCacheline,
+    NumCLsPerWarp = GPUCA_WARP_SIZE / EntriesPerCacheline,
+    NumOfCachedTBs = TimebinsPerCacheline,
+    // Threads index shared memory as [iThread / MaxNPadsPerRow][iThread % MaxNPadsPerRow].
+    // Rounding up to a multiple of PadsPerCacheline ensures iThread / MaxNPadsPerRow < NumOfCachedTBs
+    // for all threads, avoiding out-of-bounds access.
+    MaxNPadsPerRow = CAMath::nextMultipleOf<PadsPerCacheline>(GPUTPCGeometry::MaxNPadsPerRow()),
   };
 
   struct GPUSharedMemory {
-    tpccf::Charge charges[PadsPerCacheline][NumOfCachedTimebins];
+    tpccf::Charge charges[NumOfCachedTBs][MaxNPadsPerRow];
   };
 
   typedef GPUTPCClusterFinder processorType;
@@ -48,11 +61,28 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
     return gpudatatypes::RecoStep::TPCClusterFinding;
   }
 
+  static int32_t GetNBlocks(bool isGPU)
+  {
+    const int32_t nBlocks = TPC_PADS_IN_SECTOR / PadsPerCacheline;
+    return isGPU ? GPUCA_ROW_COUNT : nBlocks;
+  }
+
   template <int32_t iKernel = defaultKernel>
   GPUd() static void Thread(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer);
 
  private:
-  GPUd() static CfChargePos padToCfChargePos(int32_t& pad, const GPUTPCClusterFinder&);
+  GPUd() static void CheckBaselineGPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer);
+  GPUd() static void CheckBaselineCPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer);
+
+  template <int32_t PadsPerBlock>
+  GPUd() static CfChargePos padToCfChargePos(int32_t& pad, const GPUTPCClusterFinder&, int32_t& padsPerRow);
+
+  struct RowInfo {
+    int16_t globalPadOffset;
+    int16_t nPads;
+  };
+  GPUd() static RowInfo GetRowInfo(int16_t row);
+
   GPUd() static void updatePadBaseline(int32_t pad, const GPUTPCClusterFinder&, int32_t totalCharges, int32_t consecCharges, tpccf::Charge maxCharge);
 };
 

From f86363afb697abe64b9bf593a6cd92dd45b49aae Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 26 Jan 2026 13:16:00 +0100
Subject: [PATCH 1245/1764] ITS: instaniate TRK classes

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx     |  4 ++++
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx       | 13 +++++++++++--
 Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  4 ++++
 3 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 0d8b461181741..70f4e3d1d3fc7 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -667,5 +667,9 @@ void TimeFrame<nLayers>::wipe()
 }
 
 template class TimeFrame<7>;
+// ALICE3 upgrade
+#ifdef ENABLE_UPGRADES
+template class TimeFrame<11>;
+#endif
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 59459dcab17e8..658a90b37613f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -145,8 +145,13 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
   } catch (const std::bad_alloc& err) {
     handleException(err);
     return;
-  } catch (...) {
-    error("Uncaught exception, all bets are off...");
+  } catch (const std::exception& err) {
+    error(std::format("Uncaught exception, all bets are off... {}", err.what()));
+    // clear tracks explicitly since if not fatalising on exception this may contain partial output
+    for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
+      mTimeFrame->getTracks(iROF).clear();
+    }
+    return;
   }
 
   if (mTimeFrame->hasMCinformation()) {
@@ -357,5 +362,9 @@ void Tracker<nLayers>::printSummary() const
 }
 
 template class Tracker<7>;
+// ALICE3 upgrade
+#ifdef ENABLE_UPGRADES
+template class Tracker<11>;
+#endif
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index fe67eadaf6f72..15459576a1031 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -1327,5 +1327,9 @@ void TrackerTraits<nLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>
 }
 
 template class TrackerTraits<7>;
+// ALICE3 upgrade
+#ifdef ENABLE_UPGRADES
+template class TrackerTraits<11>;
+#endif
 
 } // namespace o2::its

From 2d37a89a8539690def207cc7fd55dbf8b7514b03 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 26 Jan 2026 13:53:46 +0100
Subject: [PATCH 1246/1764] ITS: enlarge StartLayerMask for TRK

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/include/ITStracking/Configuration.h     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 1019a3e3d45a9..1c4d604a629ed 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -68,7 +68,7 @@ struct TrackingParameters {
   float MaxChi2NDF = 30.f;
   int ReseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
-  unsigned char StartLayerMask = 0x7F;
+  uint16_t StartLayerMask = 0x7F;
   bool RepeatRefitOut = true;    // repeat outward refit using inward refit as a seed
   bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool FindShortTracks = false;

From 8eebfb5e616c670e42b7a41742b64c123a9e7b54 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 26 Jan 2026 17:30:26 +0100
Subject: [PATCH 1247/1764] ITS: GPU: reduce TrackITS allocation

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |   8 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  61 +++++--
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     |  23 +--
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  65 ++++---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 169 +++++++++++++-----
 5 files changed, 234 insertions(+), 92 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 8095d690bbcc8..d6d87eb8c1143 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -80,8 +80,8 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   void createNeighboursIndexTablesDevice(const int);
   void createNeighboursDevice(const unsigned int layer);
   void createNeighboursLUTDevice(const int, const unsigned int);
-  void createTrackITSExtDevice(bounded_vector<CellSeedN>&);
-  void downloadTrackITSExtDevice(bounded_vector<CellSeedN>&);
+  void createTrackITSExtDevice(const size_t);
+  void downloadTrackITSExtDevice();
   void downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>&, const int);
   void downloadNeighboursLUTDevice(bounded_vector<int>&, const int);
   void downloadCellsDevice();
@@ -140,6 +140,8 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   int** getDeviceArrayNeighboursCellLUT() const { return mNeighboursCellLUTDeviceArray; }
   CellSeedN** getDeviceArrayCells() { return mCellsDeviceArray; }
   CellSeedN* getDeviceTrackSeeds() { return mTrackSeedsDevice; }
+  int* getDeviceTrackSeedsLUT() { return mTrackSeedsLUTDevice; }
+  auto getNTrackSeeds() const { return mNTracks; }
   o2::track::TrackParCovF** getDeviceArrayTrackSeeds() { return mCellSeedsDeviceArray; }
   float** getDeviceArrayTrackSeedsChi2() { return mCellSeedsChi2DeviceArray; }
   int* getDeviceNeighboursIndexTables(const int layer) { return mNeighboursIndexTablesDevice[layer]; }
@@ -219,6 +221,8 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   CellSeedN** mCellsDeviceArray;
   std::array<int*, nLayers - 3> mNeighboursIndexTablesDevice;
   CellSeedN* mTrackSeedsDevice{nullptr};
+  int* mTrackSeedsLUTDevice{nullptr};
+  unsigned int mNTracks{0};
   std::array<o2::track::TrackParCovF*, nLayers - 2> mCellSeedsDevice;
   o2::track::TrackParCovF** mCellSeedsDeviceArray;
   std::array<float*, nLayers - 2> mCellSeedsChi2Device;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 6e0427f5413ba..53992ccf3eb85 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -207,23 +207,48 @@ void processNeighboursHandler(const int startLayer,
                               const int nThreads);
 
 template <int nLayers = 7>
-void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
-                      const TrackingFrameInfo** foundTrackingFrameInfo,
-                      const Cluster** unsortedClusters,
-                      o2::its::TrackITSExt* tracks,
-                      const std::vector<float>& layerRadiiHost,
-                      const std::vector<float>& minPtsHost,
-                      const unsigned int nSeeds,
-                      const float Bz,
-                      const int startLevel,
-                      const float maxChi2ClusterAttachment,
-                      const float maxChi2NDF,
-                      const int reseedIfShorter,
-                      const bool repeatRefitOut,
-                      const bool shiftRefToCluster,
-                      const o2::base::Propagator* propagator,
-                      const o2::base::PropagatorF::MatCorrType matCorrType,
-                      const int nBlocks,
-                      const int nThreads);
+void countTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
+                           const TrackingFrameInfo** foundTrackingFrameInfo,
+                           const Cluster** unsortedClusters,
+                           int* seedLUT,
+                           const std::vector<float>& layerRadiiHost,
+                           const std::vector<float>& minPtsHost,
+                           const unsigned int nSeeds,
+                           const float Bz,
+                           const int startLevel,
+                           const float maxChi2ClusterAttachment,
+                           const float maxChi2NDF,
+                           const int reseedIfShorter,
+                           const bool repeatRefitOut,
+                           const bool shiftRefToCluster,
+                           const o2::base::Propagator* propagator,
+                           const o2::base::PropagatorF::MatCorrType matCorrType,
+                           o2::its::ExternalAllocator* alloc,
+                           const int nBlocks,
+                           const int nThreads);
+
+template <int nLayers = 7>
+void computeTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
+                             const TrackingFrameInfo** foundTrackingFrameInfo,
+                             const Cluster** unsortedClusters,
+                             o2::its::TrackITSExt* tracks,
+                             const int* seedLUT,
+                             const std::vector<float>& layerRadiiHost,
+                             const std::vector<float>& minPtsHost,
+                             const unsigned int nSeeds,
+                             const unsigned int nTracks,
+                             const float Bz,
+                             const int startLevel,
+                             const float maxChi2ClusterAttachment,
+                             const float maxChi2NDF,
+                             const int reseedIfShorter,
+                             const bool repeatRefitOut,
+                             const bool shiftRefToCluster,
+                             const o2::base::Propagator* propagator,
+                             const o2::base::PropagatorF::MatCorrType matCorrType,
+                             o2::its::ExternalAllocator* alloc,
+                             const int nBlocks,
+                             const int nThreads);
+
 } // namespace o2::its
 #endif // ITSTRACKINGGPU_TRACKINGKERNELS_H_
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 6532165d9628a..c7d6e31ec771a 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -439,8 +439,10 @@ void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeedN>& seed
   GPUTimer timer("loading track seeds");
   GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeedN) / constants::MB);
   allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeedN), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
-  GPUChkErrS(cudaHostRegister(seeds.data(), seeds.size() * sizeof(CellSeedN), cudaHostRegisterPortable));
   GPUChkErrS(cudaMemcpy(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeedN), cudaMemcpyHostToDevice));
+  GPULog("gpu-transfer: creating {} track seeds LUT, for {:.2f} MB.", seeds.size() + 1, (seeds.size() + 1) * sizeof(int) / constants::MB);
+  allocMem(reinterpret_cast<void**>(&mTrackSeedsLUTDevice), (seeds.size() + 1) * sizeof(int), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  GPUChkErrS(cudaMemset(mTrackSeedsLUTDevice, 0, (seeds.size() + 1) * sizeof(int)));
 }
 
 template <int nLayers>
@@ -458,14 +460,15 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer)
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackITSExtDevice(bounded_vector<CellSeedN>& seeds)
+void TimeFrameGPU<nLayers>::createTrackITSExtDevice(const size_t nSeeds)
 {
   GPUTimer timer("reserving tracks");
-  mTrackITSExt = bounded_vector<TrackITSExt>(seeds.size(), {}, this->getMemoryPool().get());
-  GPULog("gpu-allocation: reserving {} tracks, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mTrackITSExtDevice), seeds.size() * sizeof(o2::its::TrackITSExt), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
-  GPUChkErrS(cudaMemset(mTrackITSExtDevice, 0, seeds.size() * sizeof(o2::its::TrackITSExt)));
-  GPUChkErrS(cudaHostRegister(mTrackITSExt.data(), seeds.size() * sizeof(o2::its::TrackITSExt), cudaHostRegisterPortable));
+  mNTracks = 0;
+  GPUChkErrS(cudaMemcpy(&mNTracks, mTrackSeedsLUTDevice + nSeeds, sizeof(int), cudaMemcpyDeviceToHost));
+  GPULog("gpu-allocation: reserving {} tracks, for {:.2f} MB.", mNTracks, mNTracks * sizeof(o2::its::TrackITSExt) / constants::MB);
+  mTrackITSExt = bounded_vector<TrackITSExt>(mNTracks, {}, this->getMemoryPool().get());
+  allocMem(reinterpret_cast<void**>(&mTrackITSExtDevice), mNTracks * sizeof(o2::its::TrackITSExt), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  GPUChkErrS(cudaMemset(mTrackITSExtDevice, 0, mNTracks * sizeof(o2::its::TrackITSExt)));
 }
 
 template <int nLayers>
@@ -588,13 +591,11 @@ void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut
 }
 
 template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice(bounded_vector<CellSeedN>& seeds)
+void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice()
 {
   GPUTimer timer("downloading tracks");
   GPULog("gpu-transfer: downloading {} tracks, for {:.2f} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
-  GPUChkErrS(cudaMemcpy(mTrackITSExt.data(), mTrackITSExtDevice, seeds.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost));
-  GPUChkErrS(cudaHostUnregister(mTrackITSExt.data()));
-  GPUChkErrS(cudaHostUnregister(seeds.data()));
+  GPUChkErrS(cudaMemcpy(mTrackITSExt.data(), mTrackITSExtDevice, mTrackITSExt.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost));
 }
 
 template <int nLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index c4a5cfb4e26b3..60774e3313d7f 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -322,29 +322,52 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
       LOGP(debug, "No track seeds found, skipping track finding");
       continue;
     }
-    mTimeFrameGPU->createTrackITSExtDevice(trackSeeds);
     mTimeFrameGPU->loadTrackSeedsDevice(trackSeeds);
 
-    trackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),             // CellSeed*
-                     mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(), // TrackingFrameInfo**
-                     mTimeFrameGPU->getDeviceArrayUnsortedClusters(),  // Cluster**
-                     mTimeFrameGPU->getDeviceTrackITSExt(),            // o2::its::TrackITSExt*
-                     this->mTrkParams[iteration].LayerRadii,           // const std::vector<float>&
-                     this->mTrkParams[iteration].MinPt,                // const std::vector<float>&
-                     trackSeeds.size(),                                // const size_t nSeeds
-                     this->mBz,                                        // const float Bz
-                     startLevel,                                       // const int startLevel,
-                     this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
-                     this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
-                     this->mTrkParams[0].RepeatRefitOut,
-                     this->mTrkParams[0].ReseedIfShorter,
-                     this->mTrkParams[0].ShiftRefToCluster,
-                     mTimeFrameGPU->getDevicePropagator(), // const o2::base::Propagator* propagator
-                     this->mTrkParams[0].CorrType,         // o2::base::PropagatorImpl<float>::MatCorrType
-                     conf.nBlocksTracksSeeds[iteration],
-                     conf.nThreadsTracksSeeds[iteration]);
-
-    mTimeFrameGPU->downloadTrackITSExtDevice(trackSeeds);
+    // Since TrackITSExt is an enourmous class it is better to first count how many
+    // successfull fits we do and only then allocate
+    countTrackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),
+                          mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
+                          mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
+                          mTimeFrameGPU->getDeviceTrackSeedsLUT(),
+                          this->mTrkParams[iteration].LayerRadii,
+                          this->mTrkParams[iteration].MinPt,
+                          trackSeeds.size(),
+                          this->mBz,
+                          startLevel,
+                          this->mTrkParams[0].MaxChi2ClusterAttachment,
+                          this->mTrkParams[0].MaxChi2NDF,
+                          this->mTrkParams[0].RepeatRefitOut,
+                          this->mTrkParams[0].ReseedIfShorter,
+                          this->mTrkParams[0].ShiftRefToCluster,
+                          mTimeFrameGPU->getDevicePropagator(),
+                          this->mTrkParams[0].CorrType,
+                          mTimeFrameGPU->getFrameworkAllocator(),
+                          conf.nBlocksTracksSeeds[iteration],
+                          conf.nThreadsTracksSeeds[iteration]);
+    mTimeFrameGPU->createTrackITSExtDevice(trackSeeds.size());
+    computeTrackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),
+                            mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
+                            mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
+                            mTimeFrameGPU->getDeviceTrackITSExt(),
+                            mTimeFrameGPU->getDeviceTrackSeedsLUT(),
+                            this->mTrkParams[iteration].LayerRadii,
+                            this->mTrkParams[iteration].MinPt,
+                            trackSeeds.size(),
+                            mTimeFrameGPU->getNTrackSeeds(),
+                            this->mBz,
+                            startLevel,
+                            this->mTrkParams[0].MaxChi2ClusterAttachment,
+                            this->mTrkParams[0].MaxChi2NDF,
+                            this->mTrkParams[0].RepeatRefitOut,
+                            this->mTrkParams[0].ReseedIfShorter,
+                            this->mTrkParams[0].ShiftRefToCluster,
+                            mTimeFrameGPU->getDevicePropagator(),
+                            this->mTrkParams[0].CorrType,
+                            mTimeFrameGPU->getFrameworkAllocator(),
+                            conf.nBlocksTracksSeeds[iteration],
+                            conf.nThreadsTracksSeeds[iteration]);
+    mTimeFrameGPU->downloadTrackITSExtDevice();
 
     auto& tracks = mTimeFrameGPU->getTrackITSExt();
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 85689488f5f6e..e5427c07cb52b 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -277,12 +277,13 @@ struct compare_track_chi2 {
   }
 };
 
-template <int nLayers>
+template <bool initRun, int nLayers>
 GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   CellSeed<nLayers>* trackSeeds,
   const TrackingFrameInfo** foundTrackingFrameInfo,
   const Cluster** unsortedClusters,
   o2::its::TrackITSExt* tracks,
+  maybe_const<!initRun, int>* seedLUT,
   const float* layerRadii,
   const float* minPts,
   const unsigned int nSeeds,
@@ -297,6 +298,13 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   const o2::base::PropagatorF::MatCorrType matCorrType)
 {
   for (int iCurrentTrackSeedIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentTrackSeedIndex < nSeeds; iCurrentTrackSeedIndex += blockDim.x * gridDim.x) {
+
+    if constexpr (!initRun) {
+      if (seedLUT[iCurrentTrackSeedIndex] == seedLUT[iCurrentTrackSeedIndex + 1]) {
+        continue;
+      }
+    }
+
     TrackITSExt temporaryTrack = seedTrackForRefit<nLayers>(trackSeeds[iCurrentTrackSeedIndex], foundTrackingFrameInfo, unsortedClusters, layerRadii, bz, reseedIfShorter);
     o2::track::TrackPar linRef{temporaryTrack};
     bool fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
@@ -366,7 +374,12 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
       temporaryTrack.getParamIn() = saveInw;
       temporaryTrack.setChi2(saveChi2);
     }
-    tracks[iCurrentTrackSeedIndex] = temporaryTrack;
+
+    if constexpr (initRun) {
+      seedLUT[iCurrentTrackSeedIndex] = 1;
+    } else {
+      tracks[seedLUT[iCurrentTrackSeedIndex]] = temporaryTrack;
+    }
   }
 }
 
@@ -1191,32 +1204,84 @@ void processNeighboursHandler(const int startLayer,
 }
 
 template <int nLayers>
-void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
-                      const TrackingFrameInfo** foundTrackingFrameInfo,
-                      const Cluster** unsortedClusters,
-                      o2::its::TrackITSExt* tracks,
-                      const std::vector<float>& layerRadiiHost,
-                      const std::vector<float>& minPtsHost,
-                      const unsigned int nSeeds,
-                      const float bz,
-                      const int startLevel,
-                      const float maxChi2ClusterAttachment,
-                      const float maxChi2NDF,
-                      const int reseedIfShorter,
-                      const bool repeatRefitOut,
-                      const bool shiftRefToCluster,
-                      const o2::base::Propagator* propagator,
-                      const o2::base::PropagatorF::MatCorrType matCorrType,
-                      const int nBlocks,
-                      const int nThreads)
+void countTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
+                           const TrackingFrameInfo** foundTrackingFrameInfo,
+                           const Cluster** unsortedClusters,
+                           int* seedLUT,
+                           const std::vector<float>& layerRadiiHost,
+                           const std::vector<float>& minPtsHost,
+                           const unsigned int nSeeds,
+                           const float bz,
+                           const int startLevel,
+                           const float maxChi2ClusterAttachment,
+                           const float maxChi2NDF,
+                           const int reseedIfShorter,
+                           const bool repeatRefitOut,
+                           const bool shiftRefToCluster,
+                           const o2::base::Propagator* propagator,
+                           const o2::base::PropagatorF::MatCorrType matCorrType,
+                           o2::its::ExternalAllocator* alloc,
+                           const int nBlocks,
+                           const int nThreads)
+{
+  // TODO: the minPts&layerRadii is transfered twice
+  // we should allocate this in constant memory and stop these
+  // small transferes!
+  thrust::device_vector<float> minPts(minPtsHost);
+  thrust::device_vector<float> layerRadii(layerRadiiHost);
+  gpu::fitTrackSeedsKernel<true, nLayers><<<nBlocks, nThreads>>>(
+    trackSeeds,                               // CellSeed*
+    foundTrackingFrameInfo,                   // TrackingFrameInfo**
+    unsortedClusters,                         // Cluster**
+    nullptr,                                  // TrackITSExt*
+    seedLUT,                                  // int*
+    thrust::raw_pointer_cast(&layerRadii[0]), // const float*
+    thrust::raw_pointer_cast(&minPts[0]),     // const float*
+    nSeeds,                                   // const unsigned int
+    bz,                                       // const float
+    startLevel,                               // const int
+    maxChi2ClusterAttachment,                 // float
+    maxChi2NDF,                               // float
+    reseedIfShorter,                          // int
+    repeatRefitOut,                           // bool
+    shiftRefToCluster,                        // bool
+    propagator,                               // const o2::base::Propagator*
+    matCorrType);                             // o2::base::PropagatorF::MatCorrType
+  auto sync_policy = THRUST_NAMESPACE::par(gpu::TypedAllocator<char>(alloc));
+  thrust::exclusive_scan(sync_policy, seedLUT, seedLUT + nSeeds + 1, seedLUT);
+}
+
+template <int nLayers>
+void computeTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
+                             const TrackingFrameInfo** foundTrackingFrameInfo,
+                             const Cluster** unsortedClusters,
+                             o2::its::TrackITSExt* tracks,
+                             const int* seedLUT,
+                             const std::vector<float>& layerRadiiHost,
+                             const std::vector<float>& minPtsHost,
+                             const unsigned int nSeeds,
+                             const unsigned int nTracks,
+                             const float bz,
+                             const int startLevel,
+                             const float maxChi2ClusterAttachment,
+                             const float maxChi2NDF,
+                             const int reseedIfShorter,
+                             const bool repeatRefitOut,
+                             const bool shiftRefToCluster,
+                             const o2::base::Propagator* propagator,
+                             const o2::base::PropagatorF::MatCorrType matCorrType,
+                             o2::its::ExternalAllocator* alloc,
+                             const int nBlocks,
+                             const int nThreads)
 {
   thrust::device_vector<float> minPts(minPtsHost);
   thrust::device_vector<float> layerRadii(layerRadiiHost);
-  gpu::fitTrackSeedsKernel<<<nBlocks, nThreads>>>(
+  gpu::fitTrackSeedsKernel<false, nLayers><<<nBlocks, nThreads>>>(
     trackSeeds,                               // CellSeed*
     foundTrackingFrameInfo,                   // TrackingFrameInfo**
     unsortedClusters,                         // Cluster**
     tracks,                                   // TrackITSExt*
+    seedLUT,                                  // const int*
     thrust::raw_pointer_cast(&layerRadii[0]), // const float*
     thrust::raw_pointer_cast(&minPts[0]),     // const float*
     nSeeds,                                   // const unsigned int
@@ -1229,8 +1294,9 @@ void trackSeedHandler(CellSeed<nLayers>* trackSeeds,
     shiftRefToCluster,                        // bool
     propagator,                               // const o2::base::Propagator*
     matCorrType);                             // o2::base::PropagatorF::MatCorrType
+  auto sync_policy = THRUST_NAMESPACE::par(gpu::TypedAllocator<char>(alloc));
   thrust::device_ptr<o2::its::TrackITSExt> tr_ptr(tracks);
-  thrust::sort(tr_ptr, tr_ptr + nSeeds, gpu::compare_track_chi2());
+  thrust::sort(sync_policy, tr_ptr, tr_ptr + nTracks, gpu::compare_track_chi2());
 }
 
 /// Explicit instantiation of ITS2 handlers
@@ -1394,23 +1460,46 @@ template void processNeighboursHandler<7>(const int startLayer,
                                           const int nBlocks,
                                           const int nThreads);
 
-template void trackSeedHandler(CellSeed<7>* trackSeeds,
-                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                               const Cluster** unsortedClusters,
-                               o2::its::TrackITSExt* tracks,
-                               const std::vector<float>& layerRadiiHost,
-                               const std::vector<float>& minPtsHost,
-                               const unsigned int nSeeds,
-                               const float bz,
-                               const int startLevel,
-                               const float maxChi2ClusterAttachment,
-                               const float maxChi2NDF,
-                               const int reseedIfShorter,
-                               const bool repeatRefitOut,
-                               const bool shiftRefToCluster,
-                               const o2::base::Propagator* propagator,
-                               const o2::base::PropagatorF::MatCorrType matCorrType,
-                               const int nBlocks,
-                               const int nThreads);
+template void countTrackSeedHandler(CellSeed<7>* trackSeeds,
+                                    const TrackingFrameInfo** foundTrackingFrameInfo,
+                                    const Cluster** unsortedClusters,
+                                    int* seedLUT,
+                                    const std::vector<float>& layerRadiiHost,
+                                    const std::vector<float>& minPtsHost,
+                                    const unsigned int nSeeds,
+                                    const float bz,
+                                    const int startLevel,
+                                    const float maxChi2ClusterAttachment,
+                                    const float maxChi2NDF,
+                                    const int reseedIfShorter,
+                                    const bool repeatRefitOut,
+                                    const bool shiftRefToCluster,
+                                    const o2::base::Propagator* propagator,
+                                    const o2::base::PropagatorF::MatCorrType matCorrType,
+                                    o2::its::ExternalAllocator* alloc,
+                                    const int nBlocks,
+                                    const int nThreads);
+
+template void computeTrackSeedHandler(CellSeed<7>* trackSeeds,
+                                      const TrackingFrameInfo** foundTrackingFrameInfo,
+                                      const Cluster** unsortedClusters,
+                                      o2::its::TrackITSExt* tracks,
+                                      const int* seedLUT,
+                                      const std::vector<float>& layerRadiiHost,
+                                      const std::vector<float>& minPtsHost,
+                                      const unsigned int nSeeds,
+                                      const unsigned int nTracks,
+                                      const float bz,
+                                      const int startLevel,
+                                      const float maxChi2ClusterAttachment,
+                                      const float maxChi2NDF,
+                                      const int reseedIfShorter,
+                                      const bool repeatRefitOut,
+                                      const bool shiftRefToCluster,
+                                      const o2::base::Propagator* propagator,
+                                      const o2::base::PropagatorF::MatCorrType matCorrType,
+                                      o2::its::ExternalAllocator* alloc,
+                                      const int nBlocks,
+                                      const int nThreads);
 
 } // namespace o2::its

From c3f85c1d7cbbd4c9e16819f1f0d23b47d7004796 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 26 Jan 2026 17:31:50 +0100
Subject: [PATCH 1248/1764] ITS: fix correctForMaterial arg for actual layer

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu | 2 +-
 Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index e5427c07cb52b..7c257bc1d0ba1 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -505,7 +505,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
             break;
           }
 
-          if (!track.correctForMaterial(layerxX0[layer + iC], layerxX0[layer] * constants::Radl * constants::Rho, true)) {
+          if (!track.correctForMaterial(layerxX0[layer + iC], layerxX0[layer + iC] * constants::Radl * constants::Rho, true)) {
             break;
           }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 15459576a1031..b4ac847863d51 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -357,7 +357,7 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
               break;
             }
 
-            if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
+            if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer + iC] * constants::Radl * constants::Rho, true)) {
               break;
             }
 

From b62d3d6084dc219ffe1e99c8d42042d043c73773 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 28 Jan 2026 11:10:20 +0100
Subject: [PATCH 1249/1764] ITS: GPU: create compile time stack tags

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 25 +++++++++++++++----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index c7d6e31ec771a..da0cd51478945 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -11,7 +11,6 @@
 ///
 
 #include <cuda_runtime.h>
-#include <fmt/format.h>
 
 #include <unistd.h>
 #include <vector>
@@ -633,21 +632,37 @@ void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
   checkedUnregisterArray(mPinnedROFramesClusters, mROFramesClustersDevice);
 }
 
+namespace detail
+{
+template <std::size_t I>
+constexpr uint64_t makeIterTag()
+{
+  static_assert(I < 10);
+  constexpr char tag[] = {'I', 'T', 'S', 'I', 'T', 'E', 'R', char('0' + I), '\0'};
+  return qStr2Tag(tag);
+}
+template <std::size_t... I>
+constexpr auto makeIterTags(std::index_sequence<I...>)
+{
+  return std::array<uint64_t, sizeof...(I)>{makeIterTag<I>()...};
+}
+// FIXME: we have to be careful that the MaxIter does not diverge from the 4 here!
+constexpr auto kIterTags = makeIterTags(std::make_index_sequence<4>{});
+} // namespace detail
+
 template <int nLayers>
 void TimeFrameGPU<nLayers>::pushMemoryStack(const int iteration)
 {
   // mark the beginning of memory marked with MEMORY_STACK that can be discarded
   // after doing one iteration
-  const auto name = fmt::format("ITSITER{}", iteration);
-  (this->mExternalAllocator)->pushTagOnStack(qStr2Tag(name.c_str()));
+  (this->mExternalAllocator)->pushTagOnStack(detail::kIterTags[iteration]);
 }
 
 template <int nLayers>
 void TimeFrameGPU<nLayers>::popMemoryStack(const int iteration)
 {
   // pop all memory on the stack from this iteration
-  const auto name = fmt::format("ITSITER{}", iteration);
-  (this->mExternalAllocator)->popTagOffStack(qStr2Tag(name.c_str()));
+  (this->mExternalAllocator)->popTagOffStack(detail::kIterTags[iteration]);
 }
 
 template <int nLayers>

From 5f4f95a4797a1f5082d3c388fbc05aff8438ba95 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 27 Jan 2026 19:25:24 +0100
Subject: [PATCH 1250/1764] GPU: add constexpr version of qStr2Tag

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 GPU/GPUTracking/utils/strtag.h | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/GPU/GPUTracking/utils/strtag.h b/GPU/GPUTracking/utils/strtag.h
index 24c527ca11a8c..a822083da8980 100644
--- a/GPU/GPUTracking/utils/strtag.h
+++ b/GPU/GPUTracking/utils/strtag.h
@@ -15,20 +15,21 @@
 #ifndef STRTAG_H
 #define STRTAG_H
 
-#include <stdexcept>
+#include <cstring>
+#include <cstdint>
 #include <string>
+#include <type_traits>
 
-template <class T = uint64_t>
-constexpr T qStr2Tag(const char* str)
+template <class T = uint64_t, std::size_t N>
+constexpr T qStr2Tag(const char (&str)[N])
 {
-  if (strlen(str) != sizeof(T)) {
-    throw std::runtime_error("Invalid tag length");
+  static_assert(std::is_trivially_copyable_v<T>);
+  static_assert(N - 1 == sizeof(T), "Invalid tag length");
+  T value{};
+  for (std::size_t i = 0; i < sizeof(T); ++i) {
+    value |= T(static_cast<unsigned char>(str[i])) << (i * 8);
   }
-  T tmp;
-  for (uint32_t i = 0; i < sizeof(T); i++) {
-    ((char*)&tmp)[i] = str[i];
-  }
-  return tmp;
+  return value;
 }
 
 template <class T>

From e4a4f1a0029b3370a50410ee061b6acfa1a83ec1 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 27 Jan 2026 20:13:38 +0100
Subject: [PATCH 1251/1764] ITS: GPU: add skipping of parts where nothing was
 found

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 25 +++++++++++++++----
 .../ITS/tracking/GPU/hip/CMakeLists.txt       |  2 ++
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 7c257bc1d0ba1..a12237358c8bd 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -399,6 +399,11 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellNeighboursKernel(
   const int maxCellNeighbours = 1e2)
 {
   for (int iCurrentCellIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentCellIndex < nCells; iCurrentCellIndex += blockDim.x * gridDim.x) {
+    if constexpr (!initRun) {
+      if (neighboursIndexTable[iCurrentCellIndex] == neighboursIndexTable[iCurrentCellIndex + 1]) {
+        continue;
+      }
+    }
     const auto& currentCellSeed{cellSeedArray[layerIndex][iCurrentCellIndex]};
     const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
     const int nextLayerFirstCellIndex{cellsLUTs[layerIndex + 1][nextLayerTrackletIndex]};
@@ -464,8 +469,13 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut)
 {
-  constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // Hardcoded here for the moment.
+  constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // FIXME: Hardcoded here for the moment.
   for (int iCurrentTrackletIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentTrackletIndex < nTrackletsCurrent; iCurrentTrackletIndex += blockDim.x * gridDim.x) {
+    if constexpr (!initRun) {
+      if (cellsLUTs[layer][iCurrentTrackletIndex] == cellsLUTs[layer][iCurrentTrackletIndex + 1]) {
+        continue;
+      }
+    }
     const Tracklet& currentTracklet = tracklets[layer][iCurrentTrackletIndex];
     const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
     const int nextLayerFirstTrackletIndex{trackletsLUT[layer + 1][nextLayerClusterIndex]};
@@ -526,11 +536,11 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
           new (cells + cellsLUTs[layer][iCurrentTrackletIndex] + foundCells) CellSeed<nLayers>{layer, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2};
         }
         ++foundCells;
-        if constexpr (initRun) {
-          cellsLUTs[layer][iCurrentTrackletIndex] = foundCells;
-        }
       }
     }
+    if constexpr (initRun) {
+      cellsLUTs[layer][iCurrentTrackletIndex] = foundCells;
+    }
   }
 }
 
@@ -692,8 +702,13 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
   const o2::base::Propagator* propagator,
   const o2::base::PropagatorF::MatCorrType matCorrType)
 {
-  constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // Hardcoded here for the moment.
+  constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // FIXME: Hardcoded here for the moment.
   for (unsigned int iCurrentCell = blockIdx.x * blockDim.x + threadIdx.x; iCurrentCell < nCurrentCells; iCurrentCell += blockDim.x * gridDim.x) {
+    if constexpr (!dryRun) {
+      if (foundSeedsTable[iCurrentCell] == foundSeedsTable[iCurrentCell + 1]) {
+        continue;
+      }
+    }
     int foundSeeds{0};
     const auto& currentCell{currentCellSeeds[iCurrentCell]};
     if (currentCell.getLevel() != level) {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
index e8e475f2232c8..a40aac491a386 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
@@ -13,6 +13,8 @@ if(HIP_ENABLED)
   message(STATUS "Building ITS HIP tracker")
   set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} -fgpu-rdc")
   # set(CMAKE_HIP_FLAGS "${CMAKE_HIP_FLAGS} -O0 -g -ggdb -fno-inline -fno-omit-frame-pointer -D__HIP_ENABLE_DEVICE_ASSERT__")
+  # add_compile_definitions(ITS_MEASURE_GPU_TIME)
+  # add_compile_definitions(ITS_GPU_LOG)
   o2_add_hipified_library(ITStrackingHIP
                  SOURCES ../cuda/ClusterLinesGPU.cu
                          ../cuda/TimeFrameGPU.cu

From aa3ef3751f282ee477e0636d6bd5697c43103381 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 27 Jan 2026 20:14:15 +0100
Subject: [PATCH 1252/1764] ITS: GPU: more memory clearing in processNeighbours

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 84 +++++++++++++------
 1 file changed, 58 insertions(+), 26 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index a12237358c8bd..50888c676df77 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -39,6 +39,7 @@
 // O2 track model
 #include "ReconstructionDataFormats/Track.h"
 #include "DetectorsBase/Propagator.h"
+#include "utils/strtag.h"
 using namespace o2::track;
 
 namespace o2::its
@@ -1106,11 +1107,19 @@ void processNeighboursHandler(const int startLayer,
                               const int nBlocks,
                               const int nThreads)
 {
+  constexpr uint64_t Tag = qStr2Tag("ITS_PNH1");
+
+  // allocators used
   auto allocInt = gpu::TypedAllocator<int>(alloc);
   auto allocCellSeed = gpu::TypedAllocator<CellSeed<nLayers>>(alloc);
-  thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
-  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(gpu::Stream::DefaultStream);
+  // use sync_policy, this part cannot be run async but tell thrust to use the allocator
+  auto sync_policy = THRUST_NAMESPACE::par(gpu::TypedAllocator<char>(alloc));
+
+  // put initial computation on Tag1
+  alloc->pushTagOnStack(Tag);
 
+  // start processing of cells
+  thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
   gpu::processNeighboursKernel<true, nLayers><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
@@ -1129,10 +1138,10 @@ void processNeighboursHandler(const int startLayer,
     maxChi2ClusterAttachment,
     propagator,
     matCorrType);
-  thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
-
-  thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
-  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
+  thrust::exclusive_scan(sync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
+  auto foundSeeds{foundSeedsTable.back()};
+  thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeeds, 0, allocInt);
+  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> updatedCellSeed(foundSeeds, allocCellSeed);
   gpu::processNeighboursKernel<false, nLayers><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
@@ -1151,20 +1160,41 @@ void processNeighboursHandler(const int startLayer,
     maxChi2ClusterAttachment,
     propagator,
     matCorrType);
-  GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
 
+  // now do inward steps until stop is reached
   int level = startLevel;
-  thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
-  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> lastCellSeed(allocCellSeed);
+
+  // Host buffers to break dependency
+  // FIXME: these should be on our memory resource!
+  std::vector<int> hostCellId;
+  std::vector<CellSeed<nLayers>> hostCellSeed;
+
+  // inward loop
   for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
-    lastCellSeed.swap(updatedCellSeed);
-    lastCellId.swap(updatedCellId);
+    // copy current results to host
+    hostCellId.resize(updatedCellId.size());
+    hostCellSeed.resize(updatedCellSeed.size());
+    thrust::copy(updatedCellId.begin(), updatedCellId.end(), hostCellId.begin());
+    thrust::copy(updatedCellSeed.begin(), updatedCellSeed.end(), hostCellSeed.begin());
+
+    auto lastCellSeedSize{hostCellSeed.size()};
+    // but before we clear the memory, and immediately start a new block
+    alloc->popTagOffStack(Tag);
+    alloc->pushTagOnStack(Tag);
+
+    // based on the previous step's result create new LUT and zero it
+    thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(foundSeedsTable);
+    foundSeedsTable.resize(lastCellSeedSize + 1);
+    thrust::fill(sync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
+
+    // recreate lastCell vectors from host
+    thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(hostCellId.begin(), hostCellId.end(), allocInt);
+    thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> lastCellSeed(hostCellSeed.begin(), hostCellSeed.end(), allocCellSeed);
+    // also create new vectors on new block
     thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>>(allocCellSeed).swap(updatedCellSeed);
     thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellId);
-    auto lastCellSeedSize{lastCellSeed.size()};
-    foundSeedsTable.resize(lastCellSeedSize + 1);
-    thrust::fill(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
+    // start step
     gpu::processNeighboursKernel<true, nLayers><<<nBlocks, nThreads>>>(
       iLayer,
       --level,
@@ -1183,14 +1213,13 @@ void processNeighboursHandler(const int startLayer,
       maxChi2ClusterAttachment,
       propagator,
       matCorrType);
-    thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
-
-    auto foundSeeds{foundSeedsTable.back()};
+    // how many new seeds where found
+    thrust::exclusive_scan(sync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
+    foundSeeds = foundSeedsTable.back();
+    // do a resize, we don't need to set the memory now since we know that all of these are written to
+    // Note though this does not clear the memory...
     updatedCellId.resize(foundSeeds);
-    thrust::fill(nosync_policy, updatedCellId.begin(), updatedCellId.end(), 0);
     updatedCellSeed.resize(foundSeeds);
-    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed<nLayers>());
-
     gpu::processNeighboursKernel<false, nLayers><<<nBlocks, nThreads>>>(
       iLayer,
       level,
@@ -1210,12 +1239,15 @@ void processNeighboursHandler(const int startLayer,
       propagator,
       matCorrType);
   }
-  GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
-  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> outSeeds(updatedCellSeed.size(), allocCellSeed);
-  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector<nLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
-  auto s{end - outSeeds.begin()};
-  seedsHost.reserve(seedsHost.size() + s);
-  thrust::copy(outSeeds.begin(), outSeeds.begin() + s, std::back_inserter(seedsHost));
+
+  // final copy of result
+  const auto selector = gpu::seed_selector<nLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5));
+  const auto count = thrust::count_if(sync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), selector);
+  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> outSeeds(count, allocCellSeed);
+  thrust::copy_if(sync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), selector);
+  seedsHost.reserve(seedsHost.size() + count);
+  thrust::copy(outSeeds.begin(), outSeeds.end(), std::back_inserter(seedsHost));
+  alloc->popTagOffStack(Tag);
 }
 
 template <int nLayers>

From 0bb564d94f58153218e6cb421a5c666239c44428 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 28 Jan 2026 12:35:23 +0100
Subject: [PATCH 1253/1764] ITS: GPU: fix wrong argument parsing for outward
 refit

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx   | 4 ++--
 .../ITSMFT/ITS/tracking/include/ITStracking/Configuration.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 60774e3313d7f..42d2227de60f8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -337,8 +337,8 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                           startLevel,
                           this->mTrkParams[0].MaxChi2ClusterAttachment,
                           this->mTrkParams[0].MaxChi2NDF,
-                          this->mTrkParams[0].RepeatRefitOut,
                           this->mTrkParams[0].ReseedIfShorter,
+                          this->mTrkParams[0].RepeatRefitOut,
                           this->mTrkParams[0].ShiftRefToCluster,
                           mTimeFrameGPU->getDevicePropagator(),
                           this->mTrkParams[0].CorrType,
@@ -359,8 +359,8 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                             startLevel,
                             this->mTrkParams[0].MaxChi2ClusterAttachment,
                             this->mTrkParams[0].MaxChi2NDF,
-                            this->mTrkParams[0].RepeatRefitOut,
                             this->mTrkParams[0].ReseedIfShorter,
+                            this->mTrkParams[0].RepeatRefitOut,
                             this->mTrkParams[0].ShiftRefToCluster,
                             mTimeFrameGPU->getDevicePropagator(),
                             this->mTrkParams[0].CorrType,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 1c4d604a629ed..10e1681c73e8d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -69,7 +69,7 @@ struct TrackingParameters {
   int ReseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
   uint16_t StartLayerMask = 0x7F;
-  bool RepeatRefitOut = true;    // repeat outward refit using inward refit as a seed
+  bool RepeatRefitOut = false;   // repeat outward refit using inward refit as a seed
   bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool FindShortTracks = false;
   bool PerPrimaryVertexProcessing = false;

From 63e5c6136f9eb261968541ae80cc589d2c1b0a7f Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 29 Jan 2026 13:44:05 +0100
Subject: [PATCH 1254/1764] DPL Analysis: cleanup AnalysisTask.h and ASoA.h
 (#14996)

* remove unnecessary include; unnecessary mutability; too specific requires; unused function
* use non-capturing lambdas; restrict template
* we only expect void process functions
* improve getIterators
* improve homogeneous_apply_ref

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Framework/Core/include/Framework/ASoA.h       |  62 +++----
 .../Core/include/Framework/AnalysisManagers.h |   6 -
 .../Core/include/Framework/AnalysisTask.h     | 163 +++++++++---------
 .../include/Framework/StructToTuple.h         |  46 ++---
 4 files changed, 128 insertions(+), 149 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 4fd35e0dc5065..7586d6a6d3c63 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -405,15 +405,15 @@ class Table;
 /// Type-checking index column binding
 struct Binding {
   void const* ptr = nullptr;
-  size_t hash = 0;
-  std::span<TableRef const> refs;
+  uint32_t hash = 0;
+  // std::span<TableRef const> refs;
 
   template <typename T>
   void bind(T const* table)
   {
     ptr = table;
     hash = o2::framework::TypeIdHelpers::uniqueId<T>();
-    refs = std::span{T::originals};
+    // refs = std::span{T::originals};
   }
 
   template <typename T>
@@ -1293,6 +1293,9 @@ struct ArrowHelpers {
 template <typename T>
 concept is_iterator = framework::base_of_template<TableIterator, T> || framework::specialization_of_template<TableIterator, T>;
 
+template <typename T>
+concept is_table_or_iterator = is_table<T> || is_iterator<T>;
+
 template <typename T>
 concept with_originals = requires {
   T::originals.size();
@@ -2724,7 +2727,7 @@ consteval auto getIndexTargets()
       return !(*mColumnIterator).empty();                                                                \
     }                                                                                                    \
                                                                                                          \
-    template <typename T>                                                                                \
+    template <soa::is_table T>                                                                           \
     auto _Getter_##_as() const                                                                           \
     {                                                                                                    \
       if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                \
@@ -2734,10 +2737,15 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                          \
       }                                                                                                  \
-      return getIterators<T>();                                                                          \
+      auto result = std::vector<typename T::unfiltered_iterator>();                                      \
+      result.reserve((*mColumnIterator).size());                                                         \
+      for (auto& i : *mColumnIterator) {                                                                 \
+        result.emplace_back(t->rawIteratorAt(i));                                                        \
+      }                                                                                                  \
+      return result;                                                                                     \
     }                                                                                                    \
                                                                                                          \
-    template <typename T>                                                                                \
+    template <soa::is_filtered_table T>                                                                  \
     auto filtered_##_Getter_##_as() const                                                                \
     {                                                                                                    \
       if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                \
@@ -2747,35 +2755,15 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                          \
       }                                                                                                  \
-      return getFilteredIterators<T>();                                                                  \
-    }                                                                                                    \
-                                                                                                         \
-    template <typename T>                                                                                \
-    auto getIterators() const                                                                            \
-    {                                                                                                    \
-      auto result = std::vector<typename T::unfiltered_iterator>();                                      \
-      for (auto& i : *mColumnIterator) {                                                                 \
-        result.push_back(mBinding.get<T>()->rawIteratorAt(i));                                           \
-      }                                                                                                  \
-      return result;                                                                                     \
-    }                                                                                                    \
-                                                                                                         \
-    template <typename T>                                                                                \
-    std::vector<typename T::iterator> getFilteredIterators() const                                       \
-    {                                                                                                    \
-      if constexpr (o2::soa::is_filtered_table<T>) {                                                     \
-        auto result = std::vector<typename T::iterator>();                                               \
-        for (auto const& i : *mColumnIterator) {                                                         \
-          auto pos = mBinding.get<T>()->isInSelectedRows(i);                                             \
-          if (pos > 0) {                                                                                 \
-            result.emplace_back(mBinding.get<T>()->iteratorAt(pos));                                     \
-          }                                                                                              \
+      auto result = std::vector<typename T::iterator>();                                                 \
+      result.reserve((*mColumnIterator).size());                                                         \
+      for (auto const& i : *mColumnIterator) {                                                           \
+        auto pos = t->isInSelectedRows(i);                                                               \
+        if (pos > 0) {                                                                                   \
+          result.emplace_back(t->iteratorAt(pos));                                                       \
         }                                                                                                \
-        return result;                                                                                   \
-      } else {                                                                                           \
-        static_assert(o2::framework::always_static_assert_v<T>, "T is not a Filtered type");             \
       }                                                                                                  \
-      return {};                                                                                         \
+      return result;                                                                                     \
     }                                                                                                    \
                                                                                                          \
     auto _Getter_() const                                                                                \
@@ -3090,15 +3078,9 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, "self");                                            \
       }                                                                                                  \
-      return getIterators<T>();                                                                          \
-    }                                                                                                    \
-                                                                                                         \
-    template <typename T>                                                                                \
-    auto getIterators() const                                                                            \
-    {                                                                                                    \
       auto result = std::vector<typename T::unfiltered_iterator>();                                      \
       for (auto& i : *mColumnIterator) {                                                                 \
-        result.push_back(mBinding.get<T>()->rawIteratorAt(i));                                           \
+        result.push_back(t->rawIteratorAt(i));                                                           \
       }                                                                                                  \
       return result;                                                                                     \
     }                                                                                                    \
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index fd41a079c6570..121ce7f4b4a77 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -534,12 +534,6 @@ void bindExternalIndicesPartition(P& partition, T*... tables)
 }
 
 /// Cache handling
-template <typename T>
-bool preInitializeCache(InitContext&, T&)
-{
-  return false;
-}
-
 template <typename T>
 bool initializeCache(ProcessingContext&, T&)
 {
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 4f8a9e719e4b9..365c6b1d41692 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -22,7 +22,6 @@
 #include "Framework/EndOfStreamContext.h"
 #include "Framework/GroupSlicer.h"
 #include "Framework/StructToTuple.h"
-#include "Framework/Traits.h"
 #include "Framework/TypeIdHelpers.h"
 #include "Framework/ArrowTableSlicingCache.h"
 #include "Framework/AnalysisDataModel.h"
@@ -63,17 +62,20 @@ static constexpr bool is_enumeration_v<Enumeration<BEGIN, END, STEP>> = true;
 template <typename T>
 concept is_enumeration = is_enumeration_v<std::decay_t<T>>;
 
+template <typename T>
+concept is_table_iterator_or_enumeration = soa::is_table_or_iterator<T> || is_enumeration<T>;
+
 // Helper struct which builds a DataProcessorSpec from
 // the contents of an AnalysisTask...
 namespace
 {
 struct AnalysisDataProcessorBuilder {
-  template <soa::is_iterator G, typename... Args>
+  template <soa::is_iterator G, soa::is_table... Args>
   static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled)
   {
-    [&bk, &bku, enabled]<typename... As>(framework::pack<As...>) mutable {
+    []<soa::is_table... As>(framework::pack<As...>, Cache& bk, Cache& bku, bool enabled) {
       auto key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
-      ([&bk, &bku, &key, enabled]() mutable {
+      ([](Cache& bk, Cache& bku, bool enabled, std::string const& key) {
         if constexpr (soa::relatedByIndex<std::decay_t<G>, std::decay_t<As>>()) {
           Entry e{soa::getLabelFromTypeForKey<std::decay_t<As>>(key), soa::getMatcherFromTypeForKey<std::decay_t<As>>(key), key, enabled};
           if constexpr (o2::soa::is_smallgroups<std::decay_t<As>>) {
@@ -82,9 +84,9 @@ struct AnalysisDataProcessorBuilder {
             framework::updatePairList(bk, e);
           }
         }
-      }(),
+      }(bk, bku, enabled, key),
        ...);
-    }(framework::pack<Args...>{});
+    }(framework::pack<Args...>{}, bk, bku, enabled);
   }
 
   template <soa::TableRef R>
@@ -168,8 +170,8 @@ struct AnalysisDataProcessorBuilder {
     return true;
   }
   /// 1. enumeration (must be the only argument)
-  template <typename R, typename C, is_enumeration A>
-  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&) //, Cache&, Cache&)
+  template <typename C, is_enumeration A>
+  static void inputsFromArgs(void (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&) //, Cache&, Cache&)
   {
     std::vector<ConfigParamSpec> inputMetadata;
     // FIXME: for the moment we do not support begin, end and step.
@@ -177,37 +179,37 @@ struct AnalysisDataProcessorBuilder {
   }
 
   /// 2. 1st argument is an iterator
-  template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache& bk, Cache& bku)
+  template <typename C, soa::is_iterator A, soa::is_table... Args>
+  static void inputsFromArgs(void (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache& bk, Cache& bku)
     requires(std::is_lvalue_reference_v<A> && (std::is_lvalue_reference_v<Args> && ...))
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(A, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(A, Args...)>();
     addInputsAndExpressions<typename std::decay_t<A>::parent_t, Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 3. generic case
-  template <typename R, typename C, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache&, Cache&)
+  template <typename C, soa::is_table... Args>
+  static void inputsFromArgs(void (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache&, Cache&)
     requires(std::is_lvalue_reference_v<Args> && ...)
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Args...)>();
     addInputsAndExpressions<Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 1. enumeration (no grouping)
-  template <typename R, typename C, is_enumeration A>
-  static void cacheFromArgs(R (C::*)(A), bool, Cache&, Cache&)
+  template <typename C, is_enumeration A>
+  static void cacheFromArgs(void (C::*)(A), bool, Cache&, Cache&)
   {
   }
   /// 2. iterator (the only grouping case)
-  template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
-  static void cacheFromArgs(R (C::*)(A, Args...), bool value, Cache& bk, Cache& bku)
+  template <typename C, soa::is_iterator A, soa::is_table... Args>
+  static void cacheFromArgs(void (C::*)(A, Args...), bool value, Cache& bk, Cache& bku)
   {
     addGroupingCandidates<A, Args...>(bk, bku, value);
   }
   /// 3. generic case (no grouping)
-  template <typename R, typename C, soa::is_table A, soa::is_table... Args>
-  static void cacheFromArgs(R (C::*)(A, Args...), bool, Cache&, Cache&)
+  template <typename C, soa::is_table A, soa::is_table... Args>
+  static void cacheFromArgs(void (C::*)(A, Args...), bool, Cache&, Cache&)
   {
   }
 
@@ -282,51 +284,53 @@ struct AnalysisDataProcessorBuilder {
     }
   }
 
-  template <typename R, typename C, typename Grouping, typename... Args>
-  static auto bindGroupingTable(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
+  template <typename C, is_table_iterator_or_enumeration Grouping, soa::is_table... Args>
+  static auto bindGroupingTable(InputRecord& record, void (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
     requires(!std::same_as<Grouping, void>)
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Grouping, Args...)>();
     return extract<std::decay_t<Grouping>, 0>(record, infos, hash);
   }
 
-  template <typename R, typename C, typename Grouping, typename... Args>
-  static auto bindAssociatedTables(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
+  template <typename C, is_table_iterator_or_enumeration Grouping, soa::is_table... Args>
+  static auto bindAssociatedTables(InputRecord& record, void (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
     requires(!std::same_as<Grouping, void> && sizeof...(Args) > 0)
   {
     constexpr auto p = pack<Args...>{};
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Grouping, Args...)>();
     return std::make_tuple(extract<std::decay_t<Args>, has_type_at_v<Args>(p) + 1>(record, infos, hash)...);
   }
 
-  template <typename... As>
+  template <soa::is_table... As>
   static void overwriteInternalIndices(std::tuple<As...>& dest, std::tuple<As...> const& src)
   {
     (std::get<As>(dest).bindInternalIndicesTo(&std::get<As>(src)), ...);
   }
 
-  template <typename Task, typename R, typename C, typename Grouping, typename... Associated>
-  static void invokeProcess(Task& task, InputRecord& inputs, R (C::*processingFunction)(Grouping, Associated...), std::vector<ExpressionInfo>& infos, ArrowTableSlicingCache& slices)
+  template <typename Task, is_table_iterator_or_enumeration Grouping, soa::is_table... Associated>
+  static void invokeProcess(Task& task, InputRecord& inputs, void (Task::*processingFunction)(Grouping, Associated...), std::vector<ExpressionInfo>& infos, ArrowTableSlicingCache& slices)
   {
     using G = std::decay_t<Grouping>;
     auto groupingTable = AnalysisDataProcessorBuilder::bindGroupingTable(inputs, processingFunction, infos);
 
+    constexpr const int numElements = nested_brace_constructible_size<false, std::decay_t<Task>>() / 10;
+
     // set filtered tables for partitions with grouping
-    homogeneous_apply_refs([&groupingTable](auto& element) {
+    homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& element) {
       analysis_task_parsers::setPartition(element, groupingTable);
       analysis_task_parsers::bindInternalIndicesPartition(element, &groupingTable);
       return true;
     },
-                           task);
+                                              task);
 
     if constexpr (sizeof...(Associated) == 0) {
       // single argument to process
-      homogeneous_apply_refs([&groupingTable](auto& element) {
+      homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& element) {
         analysis_task_parsers::bindExternalIndicesPartition(element, &groupingTable);
         analysis_task_parsers::setGroupedCombination(element, groupingTable);
         return true;
       },
-                             task);
+                                                task);
       if constexpr (soa::is_iterator<G>) {
         for (auto& element : groupingTable) {
           std::invoke(processingFunction, task, *element);
@@ -344,7 +348,7 @@ struct AnalysisDataProcessorBuilder {
       // pre-bind self indices
       std::apply(
         [&task](auto&... t) mutable {
-          (homogeneous_apply_refs(
+          (homogeneous_apply_refs_sized<numElements>(
              [&t](auto& p) {
                analysis_task_parsers::bindInternalIndicesPartition(p, &t);
                return true;
@@ -356,12 +360,12 @@ struct AnalysisDataProcessorBuilder {
 
       auto binder = [&task, &groupingTable, &associatedTables](auto& x) mutable {
         x.bindExternalIndices(&groupingTable, &std::get<std::decay_t<Associated>>(associatedTables)...);
-        homogeneous_apply_refs([&x](auto& t) mutable {
+        homogeneous_apply_refs_sized<numElements>([&x](auto& t) mutable {
           analysis_task_parsers::setPartition(t, x);
           analysis_task_parsers::bindExternalIndicesPartition(t, &x);
           return true;
         },
-                               task);
+                                                  task);
       };
       groupingTable.bindExternalIndices(&std::get<std::decay_t<Associated>>(associatedTables)...);
 
@@ -373,11 +377,11 @@ struct AnalysisDataProcessorBuilder {
         associatedTables);
 
       // GroupedCombinations bound separately, as they should be set once for all associated tables
-      homogeneous_apply_refs([&groupingTable, &associatedTables](auto& t) {
+      homogeneous_apply_refs_sized<numElements>([&groupingTable, &associatedTables](auto& t) {
         analysis_task_parsers::setGroupedCombination(t, groupingTable, associatedTables);
         return true;
       },
-                             task);
+                                                task);
       overwriteInternalIndices(associatedTables, associatedTables);
       if constexpr (soa::is_iterator<std::decay_t<G>>) {
         auto slicer = GroupSlicer(groupingTable, associatedTables, slices);
@@ -391,28 +395,28 @@ struct AnalysisDataProcessorBuilder {
             associatedSlices);
 
           // bind partitions and grouping table
-          homogeneous_apply_refs([&groupingTable](auto& x) {
+          homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& x) {
             analysis_task_parsers::bindExternalIndicesPartition(x, &groupingTable);
             return true;
           },
-                                 task);
+                                                    task);
 
           invokeProcessWithArgs(task, processingFunction, slice.groupingElement(), associatedSlices);
         }
       } else {
         // bind partitions and grouping table
-        homogeneous_apply_refs([&groupingTable](auto& x) {
+        homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& x) {
           analysis_task_parsers::bindExternalIndicesPartition(x, &groupingTable);
           return true;
         },
-                               task);
+                                                  task);
 
         invokeProcessWithArgs(task, processingFunction, groupingTable, associatedTables);
       }
     }
   }
 
-  template <typename C, typename T, typename G, typename... A>
+  template <typename C, typename T, is_table_iterator_or_enumeration G, soa::is_table... A>
   static void invokeProcessWithArgs(C& task, T processingFunction, G g, std::tuple<A...>& at)
   {
     std::invoke(processingFunction, task, g, std::get<A>(at)...);
@@ -520,16 +524,18 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<ConfigParamSpec> options;
   std::vector<ExpressionInfo> expressionInfos;
 
+  constexpr const int numElements = nested_brace_constructible_size<false, std::decay_t<T>>() / 10;
+
   /// make sure options and configurables are set before expression infos are created
-  homogeneous_apply_refs([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
+  homogeneous_apply_refs_sized<numElements>([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
   /// extract conditions and append them as inputs
-  homogeneous_apply_refs([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
+  homogeneous_apply_refs_sized<numElements>([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
 
   /// parse process functions defined by corresponding configurables
   if constexpr (requires { &T::process; }) {
     AnalysisDataProcessorBuilder::inputsFromArgs(&T::process, "default", true, inputs, expressionInfos);
   }
-  homogeneous_apply_refs(
+  homogeneous_apply_refs_sized<numElements>(
     [name = name_str, &expressionInfos, &inputs](auto& x) mutable {
       // this pushes (argumentIndex, processHash, schemaPtr, nullptr) into expressionInfos for arguments that are Filtered/filtered_iterators
       return AnalysisDataProcessorBuilder::requestInputsFromArgs(x, name, inputs, expressionInfos);
@@ -538,39 +544,39 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
 
   // request base tables for spawnable extended tables and indices to be built
   // this checks for duplications
-  homogeneous_apply_refs([&inputs](auto& element) {
+  homogeneous_apply_refs_sized<numElements>([&inputs](auto& element) {
     return analysis_task_parsers::requestInputs(inputs, element);
   },
-                         *task.get());
+                                            *task.get());
 
   // no static way to check if the task defines any processing, we can only make sure it subscribes to at least something
   if (inputs.empty() == true) {
     LOG(warn) << "Task " << name_str << " has no inputs";
   }
 
-  homogeneous_apply_refs([&outputs, &hash](auto& element) { return analysis_task_parsers::appendOutput(outputs, element, hash); }, *task.get());
+  homogeneous_apply_refs_sized<numElements>([&outputs, &hash](auto& element) { return analysis_task_parsers::appendOutput(outputs, element, hash); }, *task.get());
 
   auto requiredServices = CommonServices::defaultServices();
   auto arrowServices = CommonServices::arrowServices();
   requiredServices.insert(requiredServices.end(), arrowServices.begin(), arrowServices.end());
-  homogeneous_apply_refs([&requiredServices](auto& element) { return analysis_task_parsers::addService(requiredServices, element); }, *task.get());
+  homogeneous_apply_refs_sized<numElements>([&requiredServices](auto& element) { return analysis_task_parsers::addService(requiredServices, element); }, *task.get());
 
   auto algo = AlgorithmSpec::InitCallback{[task = task, expressionInfos](InitContext& ic) mutable {
     Cache bindingsKeys;
     Cache bindingsKeysUnsorted;
     // add preslice declarations to slicing cache definition
-    homogeneous_apply_refs([&bindingsKeys, &bindingsKeysUnsorted](auto& element) { return analysis_task_parsers::registerCache(element, bindingsKeys, bindingsKeysUnsorted); }, *task.get());
+    homogeneous_apply_refs_sized<numElements>([&bindingsKeys, &bindingsKeysUnsorted](auto& element) { return analysis_task_parsers::registerCache(element, bindingsKeys, bindingsKeysUnsorted); }, *task.get());
 
-    homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareOption(ic, element); }, *task.get());
-    homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareService(ic, element); }, *task.get());
+    homogeneous_apply_refs_sized<numElements>([&ic](auto&& element) { return analysis_task_parsers::prepareOption(ic, element); }, *task.get());
+    homogeneous_apply_refs_sized<numElements>([&ic](auto&& element) { return analysis_task_parsers::prepareService(ic, element); }, *task.get());
 
     auto& callbacks = ic.services().get<CallbackService>();
     auto eoscb = [task](EndOfStreamContext& eosContext) {
-      homogeneous_apply_refs([&eosContext](auto& element) {
+      homogeneous_apply_refs_sized<numElements>([&eosContext](auto& element) {
           analysis_task_parsers::postRunService(eosContext, element);
           analysis_task_parsers::postRunOutput(eosContext, element);
           return true; },
-                             *task.get());
+                                                *task.get());
       eosContext.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     };
 
@@ -582,84 +588,75 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
     }
 
     /// update configurables in filters and partitions
-    homogeneous_apply_refs(
+    homogeneous_apply_refs_sized<numElements>(
       [&ic](auto& element) -> bool { return analysis_task_parsers::updatePlaceholders(ic, element); },
       *task.get());
     /// create expression trees for filters gandiva trees matched to schemas and store the pointers into expressionInfos
-    homogeneous_apply_refs([&expressionInfos](auto& element) {
+    homogeneous_apply_refs_sized<numElements>([&expressionInfos](auto& element) {
       return analysis_task_parsers::createExpressionTrees(expressionInfos, element);
     },
-                           *task.get());
+                                              *task.get());
 
     /// parse process functions to enable requested grouping caches - note that at this state process configurables have their final values
     if constexpr (requires { &T::process; }) {
       AnalysisDataProcessorBuilder::cacheFromArgs(&T::process, true, bindingsKeys, bindingsKeysUnsorted);
     }
-    homogeneous_apply_refs(
-      [&bindingsKeys, &bindingsKeysUnsorted](auto& x) mutable {
+    homogeneous_apply_refs_sized<numElements>(
+      [&bindingsKeys, &bindingsKeysUnsorted](auto& x) {
         return AnalysisDataProcessorBuilder::requestCacheFromArgs(x, bindingsKeys, bindingsKeysUnsorted);
       },
       *task.get());
 
     ic.services().get<ArrowTableSlicingCacheDef>().setCaches(std::move(bindingsKeys));
     ic.services().get<ArrowTableSlicingCacheDef>().setCachesUnsorted(std::move(bindingsKeysUnsorted));
-    // initialize global caches
-    homogeneous_apply_refs([&ic](auto& element) {
-      return analysis_task_parsers::preInitializeCache(ic, element);
-    },
-                           *(task.get()));
 
     return [task, expressionInfos](ProcessingContext& pc) mutable {
       // load the ccdb object from their cache
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::newDataframeCondition(pc.inputs(), element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::newDataframeCondition(pc.inputs(), element); }, *task.get());
       // reset partitions once per dataframe
-      homogeneous_apply_refs([](auto& element) { return analysis_task_parsers::newDataframePartition(element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([](auto& element) { return analysis_task_parsers::newDataframePartition(element); }, *task.get());
       // reset selections for the next dataframe
-      for (auto& info : expressionInfos) {
-        info.resetSelection = true;
-      }
+      std::ranges::for_each(expressionInfos, [](auto& info) { info.resetSelection = true; });
       // reset pre-slice for the next dataframe
       auto slices = pc.services().get<ArrowTableSlicingCache>();
-      homogeneous_apply_refs([&slices](auto& element) {
+      homogeneous_apply_refs_sized<numElements>([&slices](auto& element) {
         return analysis_task_parsers::updateSliceInfo(element, slices);
       },
-                             *(task.get()));
+                                                *(task.get()));
       // initialize local caches
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::initializeCache(pc, element); }, *(task.get()));
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::initializeCache(pc, element); }, *(task.get()));
       // prepare outputs
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::prepareOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::prepareOutput(pc, element); }, *task.get());
       // execute run()
       if constexpr (requires { task->run(pc); }) {
         task->run(pc);
       }
       // execute process()
-      if constexpr (requires { AnalysisDataProcessorBuilder::invokeProcess(*(task.get()), pc.inputs(), &T::process, expressionInfos, slices); }) {
+      if constexpr (requires { &T::process; }) {
         AnalysisDataProcessorBuilder::invokeProcess(*(task.get()), pc.inputs(), &T::process, expressionInfos, slices);
       }
       // execute optional process()
-      homogeneous_apply_refs(
-        [&pc, &expressionInfos, &task, &slices](auto& x) mutable {
-          if constexpr (base_of_template<ProcessConfigurable, std::decay_t<decltype(x)>>) {
+      homogeneous_apply_refs_sized<numElements>(
+        [&pc, &expressionInfos, &task, &slices](auto& x) {
+          if constexpr (is_process_configurable<decltype(x)>) {
             if (x.value == true) {
               AnalysisDataProcessorBuilder::invokeProcess(*task.get(), pc.inputs(), x.process, expressionInfos, slices);
               return true;
             }
+            return false;
           }
           return false;
         },
         *task.get());
       // prepare delayed outputs
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::prepareDelayedOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::prepareDelayedOutput(pc, element); }, *task.get());
       // finalize outputs
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::finalizeOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::finalizeOutput(pc, element); }, *task.get());
     };
   }};
 
   return {
     name,
-    // FIXME: For the moment we hardcode this. We could build
-    // this list from the list of methods actually implemented in the
-    // task itself.
     inputs,
     outputs,
     algo,
diff --git a/Framework/Foundation/include/Framework/StructToTuple.h b/Framework/Foundation/include/Framework/StructToTuple.h
index 5748329f6a50d..1c7aa62260bd3 100644
--- a/Framework/Foundation/include/Framework/StructToTuple.h
+++ b/Framework/Foundation/include/Framework/StructToTuple.h
@@ -174,9 +174,9 @@ consteval int nested_brace_constructible_size()
   return brace_constructible_size<type>() - nesting;
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 9)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -194,9 +194,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 8)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -214,9 +214,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 7)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -234,9 +234,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 6)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -254,9 +254,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 5)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -274,9 +274,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 4)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -294,9 +294,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 3)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -314,9 +314,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 2)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -334,9 +334,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 1)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -354,9 +354,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 0)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -373,6 +373,12 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
+template <int D, typename T, typename L>
+constexpr auto homogeneous_apply_refs_sized(L l, T&& object)
+{
+  return homogeneous_apply_refs<false, T, D, L>(l, object);
+}
+
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_STRUCTTOTUPLE_H_

From a979c459f80ce84473fcc430700f82e5f352f433 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Fri, 16 Jan 2026 14:05:07 +0100
Subject: [PATCH 1255/1764] dpl-workflow.sh: enable ALPIDE_ERR_DUMPS by default
 in online physics runs

---
 prodtests/full-system-test/dpl-workflow.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index f55605d1da485..f559fcdf91cf5 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -106,7 +106,8 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 : ${ITSTPC_CONFIG_KEY:=}
 : ${AOD_SOURCES:=$TRACK_SOURCES}
 : ${AODPROD_OPT:=}
-: ${ALPIDE_ERR_DUMPS:=0}
+: ${ALPIDE_ERR_DUMPS:=}
+[[ -z $ALPIDE_ERR_DUMPS ]] && [[ $EPNSYNCMODE == 1 && $RUNTYPE == "PHYSICS" ]] && ALPIDE_ERR_DUMPS=1 || ALPIDE_ERR_DUMPS=0
 
 [[ "0$DISABLE_ROOT_OUTPUT" == "00" ]] && DISABLE_ROOT_OUTPUT=
 

From fd54f4a12076c934e1359a0da6dffed4a0649578 Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Fri, 30 Jan 2026 11:03:46 +0100
Subject: [PATCH 1256/1764] DPL: fix device signpost segfaults for
 o2-dpl-raw-proxy (#15003)

---
 Framework/Core/src/DataProcessingDevice.cxx | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index fd03b7725d847..8a306c7b96001 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1509,9 +1509,8 @@ void DataProcessingDevice::doPrepare(ServiceRegistryRef ref)
 
   for (auto sci : pollOrder) {
     auto& info = state.inputChannelInfos[sci];
-    auto& channelSpec = spec.inputChannels[sci];
     O2_SIGNPOST_ID_FROM_POINTER(cid, device, &info);
-    O2_SIGNPOST_START(device, cid, "channels", "Processing channel %s", channelSpec.name.c_str());
+    O2_SIGNPOST_START(device, cid, "channels", "Processing channel %s", info.channel->GetName().c_str());
 
     if (info.state != InputChannelState::Completed && info.state != InputChannelState::Pull) {
       context.allDone = false;
@@ -1523,18 +1522,18 @@ void DataProcessingDevice::doPrepare(ServiceRegistryRef ref)
         DataProcessingDevice::handleData(ref, info);
       }
       O2_SIGNPOST_END(device, cid, "channels", "Flushing channel %s which is in state %d and has %zu parts still pending.",
-                      channelSpec.name.c_str(), (int)info.state, info.parts.Size());
+                      info.channel->GetName().c_str(), (int)info.state, info.parts.Size());
       continue;
     }
     if (info.channel == nullptr) {
       O2_SIGNPOST_END(device, cid, "channels", "Channel %s which is in state %d is nullptr and has %zu parts still pending.",
-                      channelSpec.name.c_str(), (int)info.state, info.parts.Size());
+                      info.channel->GetName().c_str(), (int)info.state, info.parts.Size());
       continue;
     }
     // Only poll DPL channels for now.
     if (info.channelType != ChannelAccountingType::DPL) {
       O2_SIGNPOST_END(device, cid, "channels", "Channel %s which is in state %d is not a DPL channel and has %zu parts still pending.",
-                      channelSpec.name.c_str(), (int)info.state, info.parts.Size());
+                      info.channel->GetName().c_str(), (int)info.state, info.parts.Size());
       continue;
     }
     auto& socket = info.channel->GetSocket();
@@ -1546,7 +1545,7 @@ void DataProcessingDevice::doPrepare(ServiceRegistryRef ref)
       socket.Events(&info.hasPendingEvents);
       // If we do not read, we can continue.
       if ((info.hasPendingEvents & 1) == 0 && (info.parts.Size() == 0)) {
-        O2_SIGNPOST_END(device, cid, "channels", "No pending events and no remaining parts to process for channel %{public}s", channelSpec.name.c_str());
+        O2_SIGNPOST_END(device, cid, "channels", "No pending events and no remaining parts to process for channel %{public}s", info.channel->GetName().c_str());
         continue;
       }
     }
@@ -1564,12 +1563,12 @@ void DataProcessingDevice::doPrepare(ServiceRegistryRef ref)
     bool newMessages = false;
     while (true) {
       O2_SIGNPOST_EVENT_EMIT(device, cid, "channels", "Receiving loop called for channel %{public}s (%d) with oldest possible timeslice %zu",
-                             channelSpec.name.c_str(), info.id.value, info.oldestForChannel.value);
+                             info.channel->GetName().c_str(), info.id.value, info.oldestForChannel.value);
       if (info.parts.Size() < 64) {
         fair::mq::Parts parts;
         info.channel->Receive(parts, 0);
         if (parts.Size()) {
-          O2_SIGNPOST_EVENT_EMIT(device, cid, "channels", "Received %zu parts from channel %{public}s (%d).", parts.Size(), channelSpec.name.c_str(), info.id.value);
+          O2_SIGNPOST_EVENT_EMIT(device, cid, "channels", "Received %zu parts from channel %{public}s (%d).", parts.Size(), info.channel->GetName().c_str(), info.id.value);
         }
         for (auto&& part : parts) {
           info.parts.fParts.emplace_back(std::move(part));
@@ -1598,7 +1597,7 @@ void DataProcessingDevice::doPrepare(ServiceRegistryRef ref)
       }
     }
     O2_SIGNPOST_END(device, cid, "channels", "Done processing channel %{public}s (%d).",
-                    channelSpec.name.c_str(), info.id.value);
+                    info.channel->GetName().c_str(), info.id.value);
   }
 }
 

From 515ba3a699331dbd7a6c772ce8405ef49a492a99 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 30 Jan 2026 12:05:55 +0100
Subject: [PATCH 1257/1764] Revert "DPL Analysis: cleanup AnalysisTask.h and
 ASoA.h (#14996)" (#15005)

This reverts commit 63e5c6136f9eb261968541ae80cc589d2c1b0a7f.
---
 Framework/Core/include/Framework/ASoA.h       |  62 ++++---
 .../Core/include/Framework/AnalysisManagers.h |   6 +
 .../Core/include/Framework/AnalysisTask.h     | 163 +++++++++---------
 .../include/Framework/StructToTuple.h         |  46 +++--
 4 files changed, 149 insertions(+), 128 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 7586d6a6d3c63..4fd35e0dc5065 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -405,15 +405,15 @@ class Table;
 /// Type-checking index column binding
 struct Binding {
   void const* ptr = nullptr;
-  uint32_t hash = 0;
-  // std::span<TableRef const> refs;
+  size_t hash = 0;
+  std::span<TableRef const> refs;
 
   template <typename T>
   void bind(T const* table)
   {
     ptr = table;
     hash = o2::framework::TypeIdHelpers::uniqueId<T>();
-    // refs = std::span{T::originals};
+    refs = std::span{T::originals};
   }
 
   template <typename T>
@@ -1293,9 +1293,6 @@ struct ArrowHelpers {
 template <typename T>
 concept is_iterator = framework::base_of_template<TableIterator, T> || framework::specialization_of_template<TableIterator, T>;
 
-template <typename T>
-concept is_table_or_iterator = is_table<T> || is_iterator<T>;
-
 template <typename T>
 concept with_originals = requires {
   T::originals.size();
@@ -2727,7 +2724,7 @@ consteval auto getIndexTargets()
       return !(*mColumnIterator).empty();                                                                \
     }                                                                                                    \
                                                                                                          \
-    template <soa::is_table T>                                                                           \
+    template <typename T>                                                                                \
     auto _Getter_##_as() const                                                                           \
     {                                                                                                    \
       if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                \
@@ -2737,15 +2734,10 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                          \
       }                                                                                                  \
-      auto result = std::vector<typename T::unfiltered_iterator>();                                      \
-      result.reserve((*mColumnIterator).size());                                                         \
-      for (auto& i : *mColumnIterator) {                                                                 \
-        result.emplace_back(t->rawIteratorAt(i));                                                        \
-      }                                                                                                  \
-      return result;                                                                                     \
+      return getIterators<T>();                                                                          \
     }                                                                                                    \
                                                                                                          \
-    template <soa::is_filtered_table T>                                                                  \
+    template <typename T>                                                                                \
     auto filtered_##_Getter_##_as() const                                                                \
     {                                                                                                    \
       if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                \
@@ -2755,17 +2747,37 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                          \
       }                                                                                                  \
-      auto result = std::vector<typename T::iterator>();                                                 \
-      result.reserve((*mColumnIterator).size());                                                         \
-      for (auto const& i : *mColumnIterator) {                                                           \
-        auto pos = t->isInSelectedRows(i);                                                               \
-        if (pos > 0) {                                                                                   \
-          result.emplace_back(t->iteratorAt(pos));                                                       \
-        }                                                                                                \
+      return getFilteredIterators<T>();                                                                  \
+    }                                                                                                    \
+                                                                                                         \
+    template <typename T>                                                                                \
+    auto getIterators() const                                                                            \
+    {                                                                                                    \
+      auto result = std::vector<typename T::unfiltered_iterator>();                                      \
+      for (auto& i : *mColumnIterator) {                                                                 \
+        result.push_back(mBinding.get<T>()->rawIteratorAt(i));                                           \
       }                                                                                                  \
       return result;                                                                                     \
     }                                                                                                    \
                                                                                                          \
+    template <typename T>                                                                                \
+    std::vector<typename T::iterator> getFilteredIterators() const                                       \
+    {                                                                                                    \
+      if constexpr (o2::soa::is_filtered_table<T>) {                                                     \
+        auto result = std::vector<typename T::iterator>();                                               \
+        for (auto const& i : *mColumnIterator) {                                                         \
+          auto pos = mBinding.get<T>()->isInSelectedRows(i);                                             \
+          if (pos > 0) {                                                                                 \
+            result.emplace_back(mBinding.get<T>()->iteratorAt(pos));                                     \
+          }                                                                                              \
+        }                                                                                                \
+        return result;                                                                                   \
+      } else {                                                                                           \
+        static_assert(o2::framework::always_static_assert_v<T>, "T is not a Filtered type");             \
+      }                                                                                                  \
+      return {};                                                                                         \
+    }                                                                                                    \
+                                                                                                         \
     auto _Getter_() const                                                                                \
     {                                                                                                    \
       return _Getter_##_as<binding_t>();                                                                 \
@@ -3078,9 +3090,15 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, "self");                                            \
       }                                                                                                  \
+      return getIterators<T>();                                                                          \
+    }                                                                                                    \
+                                                                                                         \
+    template <typename T>                                                                                \
+    auto getIterators() const                                                                            \
+    {                                                                                                    \
       auto result = std::vector<typename T::unfiltered_iterator>();                                      \
       for (auto& i : *mColumnIterator) {                                                                 \
-        result.push_back(t->rawIteratorAt(i));                                                           \
+        result.push_back(mBinding.get<T>()->rawIteratorAt(i));                                           \
       }                                                                                                  \
       return result;                                                                                     \
     }                                                                                                    \
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 121ce7f4b4a77..fd41a079c6570 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -534,6 +534,12 @@ void bindExternalIndicesPartition(P& partition, T*... tables)
 }
 
 /// Cache handling
+template <typename T>
+bool preInitializeCache(InitContext&, T&)
+{
+  return false;
+}
+
 template <typename T>
 bool initializeCache(ProcessingContext&, T&)
 {
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 365c6b1d41692..4f8a9e719e4b9 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -22,6 +22,7 @@
 #include "Framework/EndOfStreamContext.h"
 #include "Framework/GroupSlicer.h"
 #include "Framework/StructToTuple.h"
+#include "Framework/Traits.h"
 #include "Framework/TypeIdHelpers.h"
 #include "Framework/ArrowTableSlicingCache.h"
 #include "Framework/AnalysisDataModel.h"
@@ -62,20 +63,17 @@ static constexpr bool is_enumeration_v<Enumeration<BEGIN, END, STEP>> = true;
 template <typename T>
 concept is_enumeration = is_enumeration_v<std::decay_t<T>>;
 
-template <typename T>
-concept is_table_iterator_or_enumeration = soa::is_table_or_iterator<T> || is_enumeration<T>;
-
 // Helper struct which builds a DataProcessorSpec from
 // the contents of an AnalysisTask...
 namespace
 {
 struct AnalysisDataProcessorBuilder {
-  template <soa::is_iterator G, soa::is_table... Args>
+  template <soa::is_iterator G, typename... Args>
   static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled)
   {
-    []<soa::is_table... As>(framework::pack<As...>, Cache& bk, Cache& bku, bool enabled) {
+    [&bk, &bku, enabled]<typename... As>(framework::pack<As...>) mutable {
       auto key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
-      ([](Cache& bk, Cache& bku, bool enabled, std::string const& key) {
+      ([&bk, &bku, &key, enabled]() mutable {
         if constexpr (soa::relatedByIndex<std::decay_t<G>, std::decay_t<As>>()) {
           Entry e{soa::getLabelFromTypeForKey<std::decay_t<As>>(key), soa::getMatcherFromTypeForKey<std::decay_t<As>>(key), key, enabled};
           if constexpr (o2::soa::is_smallgroups<std::decay_t<As>>) {
@@ -84,9 +82,9 @@ struct AnalysisDataProcessorBuilder {
             framework::updatePairList(bk, e);
           }
         }
-      }(bk, bku, enabled, key),
+      }(),
        ...);
-    }(framework::pack<Args...>{}, bk, bku, enabled);
+    }(framework::pack<Args...>{});
   }
 
   template <soa::TableRef R>
@@ -170,8 +168,8 @@ struct AnalysisDataProcessorBuilder {
     return true;
   }
   /// 1. enumeration (must be the only argument)
-  template <typename C, is_enumeration A>
-  static void inputsFromArgs(void (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&) //, Cache&, Cache&)
+  template <typename R, typename C, is_enumeration A>
+  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&) //, Cache&, Cache&)
   {
     std::vector<ConfigParamSpec> inputMetadata;
     // FIXME: for the moment we do not support begin, end and step.
@@ -179,37 +177,37 @@ struct AnalysisDataProcessorBuilder {
   }
 
   /// 2. 1st argument is an iterator
-  template <typename C, soa::is_iterator A, soa::is_table... Args>
-  static void inputsFromArgs(void (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache& bk, Cache& bku)
+  template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
+  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache& bk, Cache& bku)
     requires(std::is_lvalue_reference_v<A> && (std::is_lvalue_reference_v<Args> && ...))
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(A, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(A, Args...)>();
     addInputsAndExpressions<typename std::decay_t<A>::parent_t, Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 3. generic case
-  template <typename C, soa::is_table... Args>
-  static void inputsFromArgs(void (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache&, Cache&)
+  template <typename R, typename C, soa::is_table... Args>
+  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache&, Cache&)
     requires(std::is_lvalue_reference_v<Args> && ...)
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Args...)>();
     addInputsAndExpressions<Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 1. enumeration (no grouping)
-  template <typename C, is_enumeration A>
-  static void cacheFromArgs(void (C::*)(A), bool, Cache&, Cache&)
+  template <typename R, typename C, is_enumeration A>
+  static void cacheFromArgs(R (C::*)(A), bool, Cache&, Cache&)
   {
   }
   /// 2. iterator (the only grouping case)
-  template <typename C, soa::is_iterator A, soa::is_table... Args>
-  static void cacheFromArgs(void (C::*)(A, Args...), bool value, Cache& bk, Cache& bku)
+  template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
+  static void cacheFromArgs(R (C::*)(A, Args...), bool value, Cache& bk, Cache& bku)
   {
     addGroupingCandidates<A, Args...>(bk, bku, value);
   }
   /// 3. generic case (no grouping)
-  template <typename C, soa::is_table A, soa::is_table... Args>
-  static void cacheFromArgs(void (C::*)(A, Args...), bool, Cache&, Cache&)
+  template <typename R, typename C, soa::is_table A, soa::is_table... Args>
+  static void cacheFromArgs(R (C::*)(A, Args...), bool, Cache&, Cache&)
   {
   }
 
@@ -284,53 +282,51 @@ struct AnalysisDataProcessorBuilder {
     }
   }
 
-  template <typename C, is_table_iterator_or_enumeration Grouping, soa::is_table... Args>
-  static auto bindGroupingTable(InputRecord& record, void (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
+  template <typename R, typename C, typename Grouping, typename... Args>
+  static auto bindGroupingTable(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
     requires(!std::same_as<Grouping, void>)
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Grouping, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
     return extract<std::decay_t<Grouping>, 0>(record, infos, hash);
   }
 
-  template <typename C, is_table_iterator_or_enumeration Grouping, soa::is_table... Args>
-  static auto bindAssociatedTables(InputRecord& record, void (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
+  template <typename R, typename C, typename Grouping, typename... Args>
+  static auto bindAssociatedTables(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
     requires(!std::same_as<Grouping, void> && sizeof...(Args) > 0)
   {
     constexpr auto p = pack<Args...>{};
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Grouping, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
     return std::make_tuple(extract<std::decay_t<Args>, has_type_at_v<Args>(p) + 1>(record, infos, hash)...);
   }
 
-  template <soa::is_table... As>
+  template <typename... As>
   static void overwriteInternalIndices(std::tuple<As...>& dest, std::tuple<As...> const& src)
   {
     (std::get<As>(dest).bindInternalIndicesTo(&std::get<As>(src)), ...);
   }
 
-  template <typename Task, is_table_iterator_or_enumeration Grouping, soa::is_table... Associated>
-  static void invokeProcess(Task& task, InputRecord& inputs, void (Task::*processingFunction)(Grouping, Associated...), std::vector<ExpressionInfo>& infos, ArrowTableSlicingCache& slices)
+  template <typename Task, typename R, typename C, typename Grouping, typename... Associated>
+  static void invokeProcess(Task& task, InputRecord& inputs, R (C::*processingFunction)(Grouping, Associated...), std::vector<ExpressionInfo>& infos, ArrowTableSlicingCache& slices)
   {
     using G = std::decay_t<Grouping>;
     auto groupingTable = AnalysisDataProcessorBuilder::bindGroupingTable(inputs, processingFunction, infos);
 
-    constexpr const int numElements = nested_brace_constructible_size<false, std::decay_t<Task>>() / 10;
-
     // set filtered tables for partitions with grouping
-    homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& element) {
+    homogeneous_apply_refs([&groupingTable](auto& element) {
       analysis_task_parsers::setPartition(element, groupingTable);
       analysis_task_parsers::bindInternalIndicesPartition(element, &groupingTable);
       return true;
     },
-                                              task);
+                           task);
 
     if constexpr (sizeof...(Associated) == 0) {
       // single argument to process
-      homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& element) {
+      homogeneous_apply_refs([&groupingTable](auto& element) {
         analysis_task_parsers::bindExternalIndicesPartition(element, &groupingTable);
         analysis_task_parsers::setGroupedCombination(element, groupingTable);
         return true;
       },
-                                                task);
+                             task);
       if constexpr (soa::is_iterator<G>) {
         for (auto& element : groupingTable) {
           std::invoke(processingFunction, task, *element);
@@ -348,7 +344,7 @@ struct AnalysisDataProcessorBuilder {
       // pre-bind self indices
       std::apply(
         [&task](auto&... t) mutable {
-          (homogeneous_apply_refs_sized<numElements>(
+          (homogeneous_apply_refs(
              [&t](auto& p) {
                analysis_task_parsers::bindInternalIndicesPartition(p, &t);
                return true;
@@ -360,12 +356,12 @@ struct AnalysisDataProcessorBuilder {
 
       auto binder = [&task, &groupingTable, &associatedTables](auto& x) mutable {
         x.bindExternalIndices(&groupingTable, &std::get<std::decay_t<Associated>>(associatedTables)...);
-        homogeneous_apply_refs_sized<numElements>([&x](auto& t) mutable {
+        homogeneous_apply_refs([&x](auto& t) mutable {
           analysis_task_parsers::setPartition(t, x);
           analysis_task_parsers::bindExternalIndicesPartition(t, &x);
           return true;
         },
-                                                  task);
+                               task);
       };
       groupingTable.bindExternalIndices(&std::get<std::decay_t<Associated>>(associatedTables)...);
 
@@ -377,11 +373,11 @@ struct AnalysisDataProcessorBuilder {
         associatedTables);
 
       // GroupedCombinations bound separately, as they should be set once for all associated tables
-      homogeneous_apply_refs_sized<numElements>([&groupingTable, &associatedTables](auto& t) {
+      homogeneous_apply_refs([&groupingTable, &associatedTables](auto& t) {
         analysis_task_parsers::setGroupedCombination(t, groupingTable, associatedTables);
         return true;
       },
-                                                task);
+                             task);
       overwriteInternalIndices(associatedTables, associatedTables);
       if constexpr (soa::is_iterator<std::decay_t<G>>) {
         auto slicer = GroupSlicer(groupingTable, associatedTables, slices);
@@ -395,28 +391,28 @@ struct AnalysisDataProcessorBuilder {
             associatedSlices);
 
           // bind partitions and grouping table
-          homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& x) {
+          homogeneous_apply_refs([&groupingTable](auto& x) {
             analysis_task_parsers::bindExternalIndicesPartition(x, &groupingTable);
             return true;
           },
-                                                    task);
+                                 task);
 
           invokeProcessWithArgs(task, processingFunction, slice.groupingElement(), associatedSlices);
         }
       } else {
         // bind partitions and grouping table
-        homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& x) {
+        homogeneous_apply_refs([&groupingTable](auto& x) {
           analysis_task_parsers::bindExternalIndicesPartition(x, &groupingTable);
           return true;
         },
-                                                  task);
+                               task);
 
         invokeProcessWithArgs(task, processingFunction, groupingTable, associatedTables);
       }
     }
   }
 
-  template <typename C, typename T, is_table_iterator_or_enumeration G, soa::is_table... A>
+  template <typename C, typename T, typename G, typename... A>
   static void invokeProcessWithArgs(C& task, T processingFunction, G g, std::tuple<A...>& at)
   {
     std::invoke(processingFunction, task, g, std::get<A>(at)...);
@@ -524,18 +520,16 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<ConfigParamSpec> options;
   std::vector<ExpressionInfo> expressionInfos;
 
-  constexpr const int numElements = nested_brace_constructible_size<false, std::decay_t<T>>() / 10;
-
   /// make sure options and configurables are set before expression infos are created
-  homogeneous_apply_refs_sized<numElements>([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
+  homogeneous_apply_refs([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
   /// extract conditions and append them as inputs
-  homogeneous_apply_refs_sized<numElements>([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
+  homogeneous_apply_refs([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
 
   /// parse process functions defined by corresponding configurables
   if constexpr (requires { &T::process; }) {
     AnalysisDataProcessorBuilder::inputsFromArgs(&T::process, "default", true, inputs, expressionInfos);
   }
-  homogeneous_apply_refs_sized<numElements>(
+  homogeneous_apply_refs(
     [name = name_str, &expressionInfos, &inputs](auto& x) mutable {
       // this pushes (argumentIndex, processHash, schemaPtr, nullptr) into expressionInfos for arguments that are Filtered/filtered_iterators
       return AnalysisDataProcessorBuilder::requestInputsFromArgs(x, name, inputs, expressionInfos);
@@ -544,39 +538,39 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
 
   // request base tables for spawnable extended tables and indices to be built
   // this checks for duplications
-  homogeneous_apply_refs_sized<numElements>([&inputs](auto& element) {
+  homogeneous_apply_refs([&inputs](auto& element) {
     return analysis_task_parsers::requestInputs(inputs, element);
   },
-                                            *task.get());
+                         *task.get());
 
   // no static way to check if the task defines any processing, we can only make sure it subscribes to at least something
   if (inputs.empty() == true) {
     LOG(warn) << "Task " << name_str << " has no inputs";
   }
 
-  homogeneous_apply_refs_sized<numElements>([&outputs, &hash](auto& element) { return analysis_task_parsers::appendOutput(outputs, element, hash); }, *task.get());
+  homogeneous_apply_refs([&outputs, &hash](auto& element) { return analysis_task_parsers::appendOutput(outputs, element, hash); }, *task.get());
 
   auto requiredServices = CommonServices::defaultServices();
   auto arrowServices = CommonServices::arrowServices();
   requiredServices.insert(requiredServices.end(), arrowServices.begin(), arrowServices.end());
-  homogeneous_apply_refs_sized<numElements>([&requiredServices](auto& element) { return analysis_task_parsers::addService(requiredServices, element); }, *task.get());
+  homogeneous_apply_refs([&requiredServices](auto& element) { return analysis_task_parsers::addService(requiredServices, element); }, *task.get());
 
   auto algo = AlgorithmSpec::InitCallback{[task = task, expressionInfos](InitContext& ic) mutable {
     Cache bindingsKeys;
     Cache bindingsKeysUnsorted;
     // add preslice declarations to slicing cache definition
-    homogeneous_apply_refs_sized<numElements>([&bindingsKeys, &bindingsKeysUnsorted](auto& element) { return analysis_task_parsers::registerCache(element, bindingsKeys, bindingsKeysUnsorted); }, *task.get());
+    homogeneous_apply_refs([&bindingsKeys, &bindingsKeysUnsorted](auto& element) { return analysis_task_parsers::registerCache(element, bindingsKeys, bindingsKeysUnsorted); }, *task.get());
 
-    homogeneous_apply_refs_sized<numElements>([&ic](auto&& element) { return analysis_task_parsers::prepareOption(ic, element); }, *task.get());
-    homogeneous_apply_refs_sized<numElements>([&ic](auto&& element) { return analysis_task_parsers::prepareService(ic, element); }, *task.get());
+    homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareOption(ic, element); }, *task.get());
+    homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareService(ic, element); }, *task.get());
 
     auto& callbacks = ic.services().get<CallbackService>();
     auto eoscb = [task](EndOfStreamContext& eosContext) {
-      homogeneous_apply_refs_sized<numElements>([&eosContext](auto& element) {
+      homogeneous_apply_refs([&eosContext](auto& element) {
           analysis_task_parsers::postRunService(eosContext, element);
           analysis_task_parsers::postRunOutput(eosContext, element);
           return true; },
-                                                *task.get());
+                             *task.get());
       eosContext.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     };
 
@@ -588,75 +582,84 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
     }
 
     /// update configurables in filters and partitions
-    homogeneous_apply_refs_sized<numElements>(
+    homogeneous_apply_refs(
       [&ic](auto& element) -> bool { return analysis_task_parsers::updatePlaceholders(ic, element); },
       *task.get());
     /// create expression trees for filters gandiva trees matched to schemas and store the pointers into expressionInfos
-    homogeneous_apply_refs_sized<numElements>([&expressionInfos](auto& element) {
+    homogeneous_apply_refs([&expressionInfos](auto& element) {
       return analysis_task_parsers::createExpressionTrees(expressionInfos, element);
     },
-                                              *task.get());
+                           *task.get());
 
     /// parse process functions to enable requested grouping caches - note that at this state process configurables have their final values
     if constexpr (requires { &T::process; }) {
       AnalysisDataProcessorBuilder::cacheFromArgs(&T::process, true, bindingsKeys, bindingsKeysUnsorted);
     }
-    homogeneous_apply_refs_sized<numElements>(
-      [&bindingsKeys, &bindingsKeysUnsorted](auto& x) {
+    homogeneous_apply_refs(
+      [&bindingsKeys, &bindingsKeysUnsorted](auto& x) mutable {
         return AnalysisDataProcessorBuilder::requestCacheFromArgs(x, bindingsKeys, bindingsKeysUnsorted);
       },
       *task.get());
 
     ic.services().get<ArrowTableSlicingCacheDef>().setCaches(std::move(bindingsKeys));
     ic.services().get<ArrowTableSlicingCacheDef>().setCachesUnsorted(std::move(bindingsKeysUnsorted));
+    // initialize global caches
+    homogeneous_apply_refs([&ic](auto& element) {
+      return analysis_task_parsers::preInitializeCache(ic, element);
+    },
+                           *(task.get()));
 
     return [task, expressionInfos](ProcessingContext& pc) mutable {
       // load the ccdb object from their cache
-      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::newDataframeCondition(pc.inputs(), element); }, *task.get());
+      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::newDataframeCondition(pc.inputs(), element); }, *task.get());
       // reset partitions once per dataframe
-      homogeneous_apply_refs_sized<numElements>([](auto& element) { return analysis_task_parsers::newDataframePartition(element); }, *task.get());
+      homogeneous_apply_refs([](auto& element) { return analysis_task_parsers::newDataframePartition(element); }, *task.get());
       // reset selections for the next dataframe
-      std::ranges::for_each(expressionInfos, [](auto& info) { info.resetSelection = true; });
+      for (auto& info : expressionInfos) {
+        info.resetSelection = true;
+      }
       // reset pre-slice for the next dataframe
       auto slices = pc.services().get<ArrowTableSlicingCache>();
-      homogeneous_apply_refs_sized<numElements>([&slices](auto& element) {
+      homogeneous_apply_refs([&slices](auto& element) {
         return analysis_task_parsers::updateSliceInfo(element, slices);
       },
-                                                *(task.get()));
+                             *(task.get()));
       // initialize local caches
-      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::initializeCache(pc, element); }, *(task.get()));
+      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::initializeCache(pc, element); }, *(task.get()));
       // prepare outputs
-      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::prepareOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::prepareOutput(pc, element); }, *task.get());
       // execute run()
       if constexpr (requires { task->run(pc); }) {
         task->run(pc);
       }
       // execute process()
-      if constexpr (requires { &T::process; }) {
+      if constexpr (requires { AnalysisDataProcessorBuilder::invokeProcess(*(task.get()), pc.inputs(), &T::process, expressionInfos, slices); }) {
         AnalysisDataProcessorBuilder::invokeProcess(*(task.get()), pc.inputs(), &T::process, expressionInfos, slices);
       }
       // execute optional process()
-      homogeneous_apply_refs_sized<numElements>(
-        [&pc, &expressionInfos, &task, &slices](auto& x) {
-          if constexpr (is_process_configurable<decltype(x)>) {
+      homogeneous_apply_refs(
+        [&pc, &expressionInfos, &task, &slices](auto& x) mutable {
+          if constexpr (base_of_template<ProcessConfigurable, std::decay_t<decltype(x)>>) {
             if (x.value == true) {
               AnalysisDataProcessorBuilder::invokeProcess(*task.get(), pc.inputs(), x.process, expressionInfos, slices);
               return true;
             }
-            return false;
           }
           return false;
         },
         *task.get());
       // prepare delayed outputs
-      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::prepareDelayedOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::prepareDelayedOutput(pc, element); }, *task.get());
       // finalize outputs
-      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::finalizeOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::finalizeOutput(pc, element); }, *task.get());
     };
   }};
 
   return {
     name,
+    // FIXME: For the moment we hardcode this. We could build
+    // this list from the list of methods actually implemented in the
+    // task itself.
     inputs,
     outputs,
     algo,
diff --git a/Framework/Foundation/include/Framework/StructToTuple.h b/Framework/Foundation/include/Framework/StructToTuple.h
index 1c7aa62260bd3..5748329f6a50d 100644
--- a/Framework/Foundation/include/Framework/StructToTuple.h
+++ b/Framework/Foundation/include/Framework/StructToTuple.h
@@ -174,9 +174,9 @@ consteval int nested_brace_constructible_size()
   return brace_constructible_size<type>() - nesting;
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 9)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -194,9 +194,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 8)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -214,9 +214,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 7)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -234,9 +234,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 6)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -254,9 +254,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 5)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -274,9 +274,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 4)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -294,9 +294,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 3)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -314,9 +314,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 2)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -334,9 +334,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 1)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -354,9 +354,9 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
+template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
   requires(D == 0)
-constexpr auto homogeneous_apply_refs(L l, T&& object)
+auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -373,12 +373,6 @@ constexpr auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <int D, typename T, typename L>
-constexpr auto homogeneous_apply_refs_sized(L l, T&& object)
-{
-  return homogeneous_apply_refs<false, T, D, L>(l, object);
-}
-
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_STRUCTTOTUPLE_H_

From dd70bca748eca6084e14c34d048c7ad4b79c120b Mon Sep 17 00:00:00 2001
From: Pavel Larionov <pavel.larionov@cern.ch>
Date: Fri, 30 Jan 2026 17:02:29 +0100
Subject: [PATCH 1258/1764] ALICE 3: add fully cylindrical IRIS, correct Si
 thickness, add v3 building (#14979)

* VD layer sensitive silicon 20 um, 80 um non-sens

* Add an option for pure cylindrical IRIS

* add v3 building option for FT3

* build pure cyl IRIS v3 by default
---
 .../include/FT3Simulation/Detector.h          |   1 +
 .../ALICE3/FT3/simulation/src/Detector.cxx    |  61 +++-
 .../ALICE3/TRK/base/include/TRKBase/Specs.h   |   4 +-
 .../include/TRKSimulation/VDGeometryBuilder.h |   8 +-
 .../include/TRKSimulation/VDLayer.h           |  13 +-
 .../ALICE3/TRK/simulation/src/Detector.cxx    |   2 +-
 .../TRK/simulation/src/VDGeometryBuilder.cxx  | 307 ++++++++++++++----
 .../ALICE3/TRK/simulation/src/VDLayer.cxx     | 280 ++++++++++++++--
 8 files changed, 585 insertions(+), 91 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
index a88ea5a351ad2..a68f8cf7788b6 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
@@ -116,6 +116,7 @@ class Detector : public o2::base::DetImpl<Detector>
   void buildFT3V3b();
   void buildFT3Scoping();
   void buildFT3NewVacuumVessel();
+  void buildFT3ScopingV3();
   void buildFT3FromFile(std::string);
 
   GeometryTGeo* mGeometryTGeo; //! access to geometry details
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index aab8ae070d936..9303979ada930 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -346,6 +346,65 @@ void Detector::buildFT3NewVacuumVessel()
   }
 }
 
+void Detector::buildFT3ScopingV3()
+{
+  // Build the FT3 detector according to v3 layout
+  // https://indico.cern.ch/event/1596309/contributions/6728167/attachments/3190117/5677220/2025-12-10-AW-ALICE3planning.pdf
+  // Middle disks inner radius 10 cm
+  // Outer  disks inner radius 20 cm
+
+  LOG(info) << "Building FT3 Detector: v3 scoping version";
+
+  mNumberOfLayers = 6;
+  float sensorThickness = 30.e-4;
+  float layersx2X0 = 1.e-2;
+  std::vector<std::array<float, 5>> layersConfigCSide{
+    {77., 10.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
+    {100., 10.0, 35., layersx2X0},
+    {122., 10.0, 35., layersx2X0},
+    {150., 20.0, 68.f, layersx2X0},
+    {180., 20.0, 68.f, layersx2X0},
+    {220., 20.0, 68.f, layersx2X0}};
+
+  std::vector<std::array<float, 5>> layersConfigASide{
+    {77., 10.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
+    {100., 10.0, 35., layersx2X0},
+    {122., 10.0, 35., layersx2X0},
+    {150., 20.0, 68.f, layersx2X0},
+    {180., 20.0, 68.f, layersx2X0},
+    {220., 20.0, 68.f, layersx2X0}};
+
+  mLayerName.resize(2);
+  mLayerName[0].resize(mNumberOfLayers);
+  mLayerName[1].resize(mNumberOfLayers);
+  mLayerID.clear();
+  mLayers.resize(2);
+
+  for (auto direction : {0, 1}) {
+    for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) {
+      std::string directionName = std::to_string(direction);
+      std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber);
+      mLayerName[direction][layerNumber] = layerName;
+      float z, rIn, rOut, x0;
+      if (direction == 0) { // C-Side
+        z = layersConfigCSide[layerNumber][0];
+        rIn = layersConfigCSide[layerNumber][1];
+        rOut = layersConfigCSide[layerNumber][2];
+        x0 = layersConfigCSide[layerNumber][3];
+      } else if (direction == 1) { // A-Side
+        z = layersConfigASide[layerNumber][0];
+        rIn = layersConfigASide[layerNumber][1];
+        rOut = layersConfigASide[layerNumber][2];
+        x0 = layersConfigASide[layerNumber][3];
+      }
+
+      LOG(info) << "Adding Layer " << layerName << " at z = " << z;
+      // Add layers
+      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0);
+    }
+  }
+}
+
 //_________________________________________________________________________________________________
 void Detector::buildFT3Scoping()
 {
@@ -411,7 +470,7 @@ Detector::Detector(bool active)
   } else {
     switch (ft3BaseParam.geoModel) {
       case Default:
-        buildFT3NewVacuumVessel(); // FT3 after Upgrade days March 2024
+        buildFT3ScopingV3(); // v3 Dec 25
         break;
       case Telescope:
         buildBasicFT3(ft3BaseParam); // BasicFT3 = Parametrized telescopic detector (equidistant layers)
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index 95f9f9b00d7f3..c3c7de9dbe910 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -34,11 +34,11 @@ namespace VD // TODO: add a primitive segmentation with more granularity wrt 1/4
 {
 namespace silicon
 {
-constexpr double thickness{30 * mu}; // thickness of the silicon (should be 10 um epitaxial layer + 20 um substrate)?
+constexpr double thickness{20 * mu}; // thickness of the silicon (should be 10 um epitaxial layer + 20 um substrate)?
 } // namespace silicon
 namespace metalstack
 {
-constexpr double thickness{0 * mu}; // thickness of the copper metal stack - for the moment it is not implemented
+constexpr double thickness{80 * mu}; // thickness of the copper metal stack - for the moment it is not implemented. PL: set to 80 um considering silicon as material
 } // namespace metalstack
 namespace petal
 {
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
index 0a2cb68f2233a..c337ddb102147 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
@@ -24,9 +24,11 @@ namespace o2::trk
 // Each function builds one local petal assembly (walls + layers + disks)
 // and then places/rotates the petal once into the mother volume.
 
-void createIRIS4Geometry(TGeoVolume* motherVolume);  // 4 petals, cylindrical L0
-void createIRIS4aGeometry(TGeoVolume* motherVolume); // 3 petals, cylindrical L0
-void createIRIS5Geometry(TGeoVolume* motherVolume);  // 4 petals, rectangular L0
+void createIRISGeometryFullCyl(TGeoVolume* motherVolume);          // Full-cylinder IRIS geometry (no petals, no gaps, no side walls)
+void createIRISGeometryFullCylwithDisks(TGeoVolume* motherVolume); // Full-cylinder IRIS geometry (no petals, no gaps, no side walls) incl. disks
+void createIRIS4Geometry(TGeoVolume* motherVolume);                // 4 petals, cylindrical L0
+void createIRIS4aGeometry(TGeoVolume* motherVolume);               // 3 petals, cylindrical L0
+void createIRIS5Geometry(TGeoVolume* motherVolume);                // 4 petals, rectangular L0
 
 void createSinglePetalDebug(TGeoVolume* motherVolume, int petalID = 0, int nPetals = 4, bool rectangularL0 = false);
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDLayer.h
index 9e9ca2971bc3b..acf9b19342e4b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDLayer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDLayer.h
@@ -39,9 +39,10 @@ class VDLayer
  protected:
   int mLayerNumber{0};
   std::string mLayerName;
-  double mX2X0{0.f};          // Radiation length in units of X0
-  double mChipThickness{0.f}; // thickness derived from X/X0
-  double mModuleWidth{4.54f}; // cm
+  double mX2X0{0.f};            // Radiation length in units of X0
+  double mChipThickness{0.f};   // thickness derived from X/X0
+  double mSensorThickness{0.f}; //
+  double mModuleWidth{4.54f};   // cm
 
   // ClassDef(VDLayer, 1)
 };
@@ -54,6 +55,8 @@ class VDCylindricalLayer : public VDLayer
                      double radius, double phiSpanDeg, double lengthZ, double lengthSensZ);
 
   TGeoVolume* createSensor() const; // builds the sensor volume
+  TGeoVolume* createChip() const;
+  TGeoVolume* createMetalStack() const;
   void createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans = nullptr) const override;
 
  private:
@@ -73,6 +76,8 @@ class VDRectangularLayer : public VDLayer
                      double width, double lengthZ, double lengthSensZ);
 
   TGeoVolume* createSensor() const;
+  TGeoVolume* createChip() const;
+  TGeoVolume* createMetalStack() const;
   void createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans = nullptr) const override;
 
  private:
@@ -91,6 +96,8 @@ class VDDiskLayer : public VDLayer
               double rMin, double rMax, double phiSpanDeg, double zPos);
 
   TGeoVolume* createSensor() const;
+  TGeoVolume* createChip() const;
+  TGeoVolume* createMetalStack() const;
   void createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans = nullptr) const override;
 
   double getZPosition() const { return mZPos; }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 0924be5fb6764..e0fc6ef1ed35b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -266,7 +266,7 @@ void Detector::createGeometry()
   // Alternatives: createIRIS5Geometry(vTRK); createIRIS4aGeometry(vTRK);
 
   o2::trk::clearVDSensorRegistry();
-  o2::trk::createIRIS4Geometry(vTRK);
+  o2::trk::createIRISGeometryFullCyl(vTRK);
 
   // Fill sensor names from registry right after geometry creation
   const auto& regs = o2::trk::vdSensorRegistry();
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
index 5df875713262c..6ce04bb8443ef 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
@@ -67,6 +67,12 @@ inline bool isSolidToCut(const TGeoVolume* v)
   if (TString(nm).BeginsWith("VD_SideWall")) {
     return true;
   }
+  if (TString(nm).BeginsWith("VD_InnerWallCyl")) {
+    return true;
+  }
+  if (TString(nm).BeginsWith("VD_OuterWallCyl")) {
+    return true;
+  }
   if (TString(nm).Contains("_Coldplate")) {
     return true;
   }
@@ -166,7 +172,34 @@ inline void buildPetalSolidsComposite(TGeoVolume* petalAsm)
 // Build the global cutout by rotating the petal-local composite n times with (p+0.5) phase
 inline void buildIrisCutoutFromPetalSolid(int nPetals)
 {
-  // Create n rotation transforms
+  auto* shps = gGeoManager->GetListOfShapes();
+  auto* base = shps ? dynamic_cast<TGeoShape*>(shps->FindObject("IRIS_PETAL_SOLIDSsh")) : nullptr;
+  if (!base) {
+    LOGP(error, "IRIS cutout: shape 'IRIS_PETAL_SOLIDSsh' not found.");
+    return;
+  }
+
+  // IMPORTANT: for nPetals==1, a composite expression like "A:tr" is invalid.
+  // Just clone the petal solids shape as the global cutout.
+  if (nPetals == 1) {
+    // Remove any previous shape with same name if it exists (optional but keeps things clean)
+    if (shps->FindObject("IRIS_CUTOUTsh")) {
+      // ROOT shape lists are owned by gGeoManager; removing is not always necessary.
+      // Keeping it simple: just create a unique name if it already exists.
+      LOGP(warning, "IRIS cutout: 'IRIS_CUTOUTsh' already exists; overwriting by clone name reuse may be unsafe.");
+    }
+
+    auto* cut = dynamic_cast<TGeoShape*>(base->Clone("IRIS_CUTOUTsh"));
+    if (!cut) {
+      LOGP(error, "IRIS cutout: failed to clone 'IRIS_PETAL_SOLIDSsh' to 'IRIS_CUTOUTsh'.");
+      return;
+    }
+
+    LOGP(info, "IRIS_CUTOUTsh created as clone of IRIS_PETAL_SOLIDSsh (nPetals=1).");
+    return;
+  }
+
+  // nPetals > 1: build union of rotated copies
   TString cutFormula;
   for (int p = 0; p < nPetals; ++p) {
     const double phi = (360.0 / nPetals) * (p + 0.5);
@@ -175,47 +208,23 @@ inline void buildIrisCutoutFromPetalSolid(int nPetals)
     auto* RT = new TGeoCombiTrans(0, 0, 0, R);
     RT->SetName(Form("IRIS_PETAL_ROT_%d", p));
     RT->RegisterYourself();
+
     if (p) {
       cutFormula += "+";
     }
     cutFormula += Form("IRIS_PETAL_SOLIDSsh:%s", RT->GetName());
   }
-  LOGP(info, "IRIS_CUTOUTsh formula: {}", cutFormula.Data());
-  new TGeoCompositeShape("IRIS_CUTOUTsh", cutFormula.Data());
 
-  // --- Sanity check: required matrices & shapes exist
-  auto* mats = gGeoManager ? gGeoManager->GetListOfMatrices() : nullptr;
-  auto* shps = gGeoManager ? gGeoManager->GetListOfShapes() : nullptr;
+  LOGP(info, "IRIS_CUTOUTsh formula: {}", cutFormula.Data());
+  auto* cut = new TGeoCompositeShape("IRIS_CUTOUTsh", cutFormula.Data());
+  (void)cut;
 
-  if (!mats || !shps) {
-    LOGP(error, "IRIS cutout sanity: gGeoManager not initialized properly (mats/shapes missing).");
+  // Stronger sanity: ensure it parsed into a boolean node
+  auto* cutCheck = dynamic_cast<TGeoCompositeShape*>(shps->FindObject("IRIS_CUTOUTsh"));
+  if (!cutCheck || !cutCheck->GetBoolNode()) {
+    LOGP(error, "IRIS cutout sanity: IRIS_CUTOUTsh exists but parsing failed (no BoolNode).");
   } else {
-    bool ok = true;
-
-    // Check the petal rotations were registered and referenced
-    for (int p = 0; p < nPetals; ++p) {
-      const TString name = Form("IRIS_PETAL_ROT_%d", p);
-      if (!mats->FindObject(name)) {
-        LOGP(error, "IRIS cutout sanity: missing matrix {}", name.Data());
-        ok = false;
-      }
-    }
-
-    // Check that the local petal composite exists
-    if (!shps->FindObject("IRIS_PETAL_SOLIDSsh")) {
-      LOGP(error, "IRIS cutout sanity: shape 'IRIS_PETAL_SOLIDSsh' not found.");
-      ok = false;
-    }
-
-    // Check that the global cutout shape was created
-    if (!shps->FindObject("IRIS_CUTOUTsh")) {
-      LOGP(error, "IRIS cutout sanity: shape 'IRIS_CUTOUTsh' not found.");
-      ok = false;
-    }
-
-    if (ok) {
-      LOGP(info, "IRIS cutout sanity: OK ({} petals).", nPetals);
-    }
+    LOGP(info, "IRIS cutout sanity: OK ({} petals).", nPetals);
   }
 }
 
@@ -299,7 +308,11 @@ inline TGeoCombiTrans rotZ(double phiDeg)
 // ============ Petal sub-builders (LOCAL coords only, no rotation) =========
 
 // Walls: inner cylindrical arc at r=4.8 mm (always), outer arc wall, and two side plates.
-static void addPetalWalls(TGeoVolume* petalAsm, int nPetals, double outerRadius_cm = kOuterWallRadius_cm)
+static void addPetalWalls(TGeoVolume* petalAsm,
+                          int nPetals,
+                          double outerRadius_cm = kOuterWallRadius_cm,
+                          bool withSideWalls = true,
+                          bool fullCylindricalRadialWalls = false)
 {
   if (!petalAsm) {
     LOGP(error, "addPetalWalls: petalAsm is null");
@@ -314,11 +327,21 @@ static void addPetalWalls(TGeoVolume* petalAsm, int nPetals, double outerRadius_
     return;
   }
 
-  const double halfPhi = 0.5f * (360.f / static_cast<double>(nPetals));
-  const double halfZ = 0.5f * kPetalZ_cm;
+  const double halfZ = 0.5 * kPetalZ_cm;
 
-  // ---- Inner cylindrical wall (always at r=4.8 mm) ----
-  {
+  // In full-cylinder radial-wall mode we ignore nPetals for the radial walls.
+  const double halfPhi = fullCylindricalRadialWalls ? 180.0 : 0.5 * (360.0 / static_cast<double>(nPetals));
+
+  // ---- Inner radial wall ----
+  if (fullCylindricalRadialWalls) {
+    auto* s = new TGeoTube(static_cast<Double_t>(kInnerWallRadius_cm),
+                           static_cast<Double_t>(kInnerWallRadius_cm + kWallThick_cm),
+                           static_cast<Double_t>(halfZ));
+    auto* v = new TGeoVolume("VD_InnerWallCyl", s, med);
+    v->SetLineColor(kGray + 2);
+    v->SetTransparency(70);
+    petalAsm->AddNode(v, 1);
+  } else {
     auto* s = new TGeoTubeSeg(static_cast<Double_t>(kInnerWallRadius_cm),
                               static_cast<Double_t>(kInnerWallRadius_cm + kWallThick_cm),
                               static_cast<Double_t>(halfZ),
@@ -330,8 +353,16 @@ static void addPetalWalls(TGeoVolume* petalAsm, int nPetals, double outerRadius_
     petalAsm->AddNode(v, 1);
   }
 
-  // ---- Outer arc wall ----
-  {
+  // ---- Outer radial wall ----
+  if (fullCylindricalRadialWalls) {
+    auto* s = new TGeoTube(static_cast<Double_t>(outerRadius_cm),
+                           static_cast<Double_t>(outerRadius_cm + kWallThick_cm),
+                           static_cast<Double_t>(halfZ));
+    auto* v = new TGeoVolume("VD_OuterWallCyl", s, med);
+    v->SetLineColor(kGray + 2);
+    v->SetTransparency(70);
+    petalAsm->AddNode(v, 1);
+  } else {
     auto* s = new TGeoTubeSeg(static_cast<Double_t>(outerRadius_cm),
                               static_cast<Double_t>(outerRadius_cm + kWallThick_cm),
                               static_cast<Double_t>(halfZ),
@@ -343,6 +374,11 @@ static void addPetalWalls(TGeoVolume* petalAsm, int nPetals, double outerRadius_
     petalAsm->AddNode(v, 1);
   }
 
+  // ---- Side plates (skip in "single petal full cylinders" mode) ----
+  if (!withSideWalls) {
+    return;
+  }
+
   // ---- Side walls (boxes) at ±halfPhi ----
   const double radialLen = (outerRadius_cm - (kInnerWallRadius_cm + kWallThick_cm));
   auto* sideS = new TGeoBBox(static_cast<Double_t>(0.5f * radialLen),
@@ -369,7 +405,7 @@ static void addPetalWalls(TGeoVolume* petalAsm, int nPetals, double outerRadius_
 
 // Build inner layers (L0..L2). L0 may be rectangular (IRIS5) or cylindrical.
 // φ-spans derive from spec gaps/arc; all local placement (no rotation).
-static void addBarrelLayers(TGeoVolume* petalAsm, int nPetals, int petalID, bool rectangularL0)
+static void addBarrelLayers(TGeoVolume* petalAsm, int nPetals, int petalID, bool rectangularL0, bool fullCylinders)
 {
   if (!petalAsm) {
     LOGP(error, "addBarrelLayers: petalAsm is null");
@@ -382,15 +418,15 @@ static void addBarrelLayers(TGeoVolume* petalAsm, int nPetals, int petalID, bool
   constexpr double arcL0_cm = 0.6247f; // 6.247 mm
 
   // φ spans
-  const double phiL0_deg = phiSpanFromGap(nPetals, gapL0_cm, rL0_cm);   // L0 gap-defined
-  const double phiL1_deg = phiSpanFromGap(nPetals, gapL1L2_cm, rL1_cm); // L1 gap-defined
-  const double phiL2_deg = phiSpanFromGap(nPetals, gapL1L2_cm, rL2_cm); // L2 gap-defined
+  const double phiL0_deg = fullCylinders ? 360.0 : phiSpanFromGap(nPetals, gapL0_cm, rL0_cm);
+  const double phiL1_deg = fullCylinders ? 360.0 : phiSpanFromGap(nPetals, gapL1L2_cm, rL1_cm);
+  const double phiL2_deg = fullCylinders ? 360.0 : phiSpanFromGap(nPetals, gapL1L2_cm, rL2_cm);
 
   const std::string nameL0 =
     std::string(o2::trk::GeometryTGeo::getTRKPetalPattern()) + std::to_string(petalID) + "_" +
     std::string(o2::trk::GeometryTGeo::getTRKPetalLayerPattern()) + "0";
 
-  if (rectangularL0) {
+  if (!fullCylinders && rectangularL0) {
     VDRectangularLayer L0(0,
                           nameL0,
                           kX2X0, kL0RectWidth_cm, kLenZ_cm, kLenZ_cm);
@@ -438,7 +474,7 @@ static void addBarrelLayers(TGeoVolume* petalAsm, int nPetals, int petalID, bool
 }
 
 // Build cold plate (cylindrical) in local coordinates, and add it to the petal assembly.
-static void addColdPlate(TGeoVolume* petalAsm, int nPetals, int petalId)
+static void addColdPlate(TGeoVolume* petalAsm, int nPetals, int petalId, bool fullCylinders = false)
 {
   if (!petalAsm) {
     LOGP(error, "addColdPlate: petalAsm is null");
@@ -455,8 +491,9 @@ static void addColdPlate(TGeoVolume* petalAsm, int nPetals, int petalId)
   constexpr double gapL1L2_cm = 0.12f; // 1.2 mm
 
   // φ spans
-  const double phiSpanColdplate_deg = phiSpanFromGap(nPetals, gapL1L2_cm, rL2_cm); // L2 gap-defined
-  const double halfPhiDeg = 0.5f * phiSpanColdplate_deg;
+  const double phiSpanColdplate_deg =
+    fullCylinders ? 360.0 : phiSpanFromGap(nPetals, gapL1L2_cm, rL2_cm); // L2 gap-defined in normal mode
+  const double halfPhiDeg = 0.5 * phiSpanColdplate_deg;
   const double startPhi = -halfPhiDeg;
   const double endPhi = +halfPhiDeg;
 
@@ -625,7 +662,7 @@ static void addIRISServiceModulesSegmented(TGeoVolume* petalAsm, int nPetals)
 
 // Build disks in local coords: each disk gets only a local Z translation.
 // φ span from gap at rOut.
-static void addDisks(TGeoVolume* petalAsm, int nPetals, int petalID)
+static void addDisks(TGeoVolume* petalAsm, int nPetals, int petalID, bool fullCylinders)
 {
 
   if (!petalAsm) {
@@ -633,7 +670,7 @@ static void addDisks(TGeoVolume* petalAsm, int nPetals, int petalID)
     return;
   }
 
-  const double phiDisk_deg = phiSpanFromGap(nPetals, 2 * kWallThick_cm, diskRin_cm);
+  const double phiDisk_deg = fullCylinders ? 360.0 : phiSpanFromGap(nPetals, 2 * kWallThick_cm, diskRin_cm);
 
   for (int i = 0; i < 6; ++i) {
     const std::string nameD =
@@ -651,21 +688,124 @@ static void addDisks(TGeoVolume* petalAsm, int nPetals, int petalID)
   }
 }
 
+// Add Z end-cap walls to "close" the petal/cylinder volume at zMin and zMax.
+// Implemented as thin rings (TGeoTube) with thickness 'capThick_cm' in Z,
+// spanning radii [rIn_cm, rOut_cm].
+static void addPetalEndCaps(TGeoVolume* petalAsm,
+                            int petalId,
+                            double rIn_cm,
+                            double rOut_cm,
+                            double zMin_cm,
+                            double zMax_cm,
+                            double capThick_cm)
+{
+  if (!petalAsm) {
+    LOGP(error, "addPetalEndCaps: petalAsm is null");
+    return;
+  }
+
+  auto& matmgr = o2::base::MaterialManager::Instance();
+  const TGeoMedium* med =
+    matmgr.getTGeoMedium("ALICE3_TRKSERVICES_ALUMINIUM5083");
+
+  if (!med) {
+    LOGP(warning,
+         "addPetalEndCaps: ALICE3_TRKSERVICES_ALUMINIUM5083 not found, caps not created.");
+    return;
+  }
+
+  const double halfT = 0.5 * capThick_cm;
+
+  auto* sh = new TGeoTube(static_cast<Double_t>(rIn_cm),
+                          static_cast<Double_t>(rOut_cm),
+                          static_cast<Double_t>(halfT));
+
+  TString vname = Form("Petal%d_ZCap", petalId);
+  auto* v = new TGeoVolume(vname, sh, med);
+  v->SetLineColor(kGray + 2);
+  v->SetTransparency(70);
+
+  auto* trMin = new TGeoTranslation(0.0, 0.0,
+                                    static_cast<Double_t>(zMin_cm + halfT));
+  auto* trMax = new TGeoTranslation(0.0, 0.0,
+                                    static_cast<Double_t>(zMax_cm - halfT));
+
+  petalAsm->AddNode(v, 1, trMin);
+  petalAsm->AddNode(v, 2, trMax);
+}
+
 // Build one complete petal assembly (walls + L0..L2 + disks) in LOCAL coords.
-static TGeoVolume* buildPetalAssembly(int nPetals, int petalID, bool rectangularL0)
+static TGeoVolume* buildPetalAssembly(int nPetals,
+                                      int petalID,
+                                      bool rectangularL0,
+                                      bool fullCylinders,
+                                      bool withSideWalls)
 {
   auto* petalAsm = new TGeoVolumeAssembly(Form("PETAL_%d", petalID));
-  addPetalWalls(petalAsm, nPetals, kOuterWallRadius_cm);
 
-  // Pass petalID to layers/disks for naming
-  addBarrelLayers(petalAsm, nPetals, petalID, rectangularL0);
-  addColdPlate(petalAsm, nPetals, petalID);
-  addDisks(petalAsm, nPetals, petalID);
+  // In the special mode: no side walls, but keep radial walls as FULL cylinders.
+  addPetalWalls(petalAsm, nPetals, kOuterWallRadius_cm,
+                /*withSideWalls=*/withSideWalls,
+                /*fullCylindricalRadialWalls=*/fullCylinders);
+
+  addBarrelLayers(petalAsm, nPetals, petalID, rectangularL0, fullCylinders);
+  addDisks(petalAsm, nPetals, petalID, fullCylinders);
+
+  addColdPlate(petalAsm, nPetals, petalID, /*fullCylinders=*/false);
   addIRISServiceModulesSegmented(petalAsm, nPetals);
 
   return petalAsm;
 }
 
+static TGeoVolume* buildFullCylAssembly(int petalID, bool withDisks)
+{
+  // IMPORTANT: keep naming consistent with createIRIS4/5 (PETAL_%d)
+  auto* petalAsm = new TGeoVolumeAssembly(Form("PETAL_%d", petalID));
+
+  // Radial walls only: full 360° cylinders, no side plates
+  addPetalWalls(petalAsm,
+                /*nPetals=*/1,
+                /*outerRadius_cm=*/kOuterWallRadius_cm,
+                /*withSideWalls=*/false,
+                /*fullCylindricalRadialWalls=*/true);
+
+  // --- Z end-cap walls to close the petal in Z ---
+  {
+    const double zMin = -0.5 * kLenZ_cm;
+    const double zMax = +0.5 * kLenZ_cm;
+    const double rIn = kInnerWallRadius_cm;
+    const double rOut = kOuterWallRadius_cm + kWallThick_cm;
+
+    addPetalEndCaps(petalAsm,
+                    petalID,
+                    rIn,
+                    rOut,
+                    zMin,
+                    zMax,
+                    kWallThick_cm);
+  }
+
+  // Full 360° barrel cylinders
+  addBarrelLayers(petalAsm,
+                  /*nPetals=*/1,
+                  /*petalID=*/petalID,
+                  /*rectangularL0=*/false,
+                  /*fullCylinders=*/true);
+
+  addColdPlate(petalAsm, 1, petalID, /*fullCylinders=*/true);
+  addIRISServiceModulesSegmented(petalAsm, /*nPetals=*/1);
+
+  // Optionally add full 360° disks
+  if (withDisks) {
+    addDisks(petalAsm,
+             /*nPetals=*/1,
+             /*petalID=*/petalID,
+             /*fullCylinders=*/true);
+  }
+
+  return petalAsm;
+}
+
 // =================== Public entry points ===================
 
 void createIRIS4Geometry(TGeoVolume* motherVolume)
@@ -679,7 +819,9 @@ void createIRIS4Geometry(TGeoVolume* motherVolume)
 
   constexpr int nPetals = 4;
   for (int p = 0; p < nPetals; ++p) {
-    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ false);
+    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ false,
+                                     /*fullCylinders=*/false,
+                                     /*withSideWalls=*/true);
     // Build the petal-local solids composite once from the FIRST petal
     if (p == 0) {
       buildPetalSolidsComposite(petal); // <-- captures only SOLIDS in local coords
@@ -704,7 +846,9 @@ void createIRIS5Geometry(TGeoVolume* motherVolume)
 
   constexpr int nPetals = 4;
   for (int p = 0; p < nPetals; ++p) {
-    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ true);
+    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ true,
+                                     /*fullCylinders=*/false,
+                                     /*withSideWalls=*/true);
     // Build the petal-local solids composite once from the FIRST petal
     if (p == 0) {
       buildPetalSolidsComposite(petal); // <-- captures only SOLIDS in local coords
@@ -729,7 +873,9 @@ void createIRIS4aGeometry(TGeoVolume* motherVolume)
 
   constexpr int nPetals = 3;
   for (int p = 0; p < nPetals; ++p) {
-    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ false);
+    auto* petal = buildPetalAssembly(nPetals, p, /*rectangularL0*/ false,
+                                     /*fullCylinders=*/false,
+                                     /*withSideWalls=*/true);
     // Build the petal-local solids composite once from the FIRST petal
     if (p == 0) {
       buildPetalSolidsComposite(petal); // <-- captures only SOLIDS in local coords
@@ -743,9 +889,48 @@ void createIRIS4aGeometry(TGeoVolume* motherVolume)
   buildIrisCutoutFromPetalSolid(nPetals);
 }
 
+void createIRISGeometryFullCyl(TGeoVolume* motherVolume)
+{
+  if (!motherVolume) {
+    LOGP(error, "createIRISGeometryFullCyl: motherVolume is null");
+    return;
+  }
+
+  clearVDSensorRegistry();
+
+  constexpr int nPetals = 1;
+  constexpr int petalID = 0;
+
+  auto* petal = buildFullCylAssembly(petalID, /*withDisks=*/false);
+  motherVolume->AddNode(petal, 1, nullptr);
+
+  buildPetalSolidsComposite(petal);
+  buildIrisCutoutFromPetalSolid(nPetals);
+}
+
+void createIRISGeometryFullCylwithDisks(TGeoVolume* motherVolume)
+{
+  if (!motherVolume) {
+    LOGP(error, "createIRISGeometryFullCylDisks: motherVolume is null");
+    return;
+  }
+
+  clearVDSensorRegistry();
+
+  constexpr int nPetals = 1;
+  constexpr int petalID = 0;
+
+  auto* petal = buildFullCylAssembly(petalID, /*withDisks=*/true);
+  motherVolume->AddNode(petal, 1, nullptr);
+
+  // Same cutout pipeline as createIRIS4/5:
+  buildPetalSolidsComposite(petal);
+  buildIrisCutoutFromPetalSolid(nPetals);
+}
+
 void createSinglePetalDebug(TGeoVolume* motherVolume, int petalID, int nPetals, bool rectangularL0)
 {
-  auto* petal = buildPetalAssembly(nPetals, petalID, rectangularL0);
+  auto* petal = buildPetalAssembly(nPetals, petalID, rectangularL0, false, true);
 
   // Optionally rotate the petal for display
   const double phiDeg = (360.f / static_cast<double>(nPetals)) * (static_cast<double>(petalID) + 0.5f);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
index 20f36f1f6f4e7..411dd485684b9 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
@@ -11,6 +11,7 @@
 
 #include "TRKSimulation/VDLayer.h"
 #include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/Specs.h"
 
 #include "Framework/Logger.h"
 
@@ -32,6 +33,8 @@ VDLayer::VDLayer(int layerNumber, const std::string& layerName, double layerX2X0
 {
   constexpr double kSiX0_cm = 9.5; // Radiation length of Silicon in cm
   mChipThickness = mX2X0 * kSiX0_cm;
+
+  mSensorThickness = o2::trk::constants::VD::silicon::thickness; // cm
 }
 
 // VDCylindricalLayer constructor
@@ -83,7 +86,7 @@ TGeoVolume* VDCylindricalLayer::createSensor() const
   }
   std::string sensName = Form("%s_%s%d", this->mLayerName.c_str(), GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
   const double rIn = mRadius;
-  const double rOut = mRadius + mChipThickness;
+  const double rOut = mRadius + mSensorThickness;
   const double halfZ = 0.5 * mLengthSensZ;
   const double halfPhi = 0.5 * mPhiSpanDeg; // degrees
   auto* shape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
@@ -106,8 +109,8 @@ TGeoVolume* VDRectangularLayer::createSensor() const
   }
   std::string sensName = Form("%s_%s%d", this->mLayerName.c_str(), GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
   const double hx = 0.5 * mWidth;
-  const double hy = 0.5 * mChipThickness; // thickness in Y
-  const double hz = 0.5 * mLengthSensZ;   // <-- use sensor Z length, not full layer
+  const double hy = 0.5 * mSensorThickness;
+  const double hz = 0.5 * mLengthSensZ; // <-- use sensor Z length, not full layer
 
   auto* shape = new TGeoBBox(hx, hy, hz);
   auto* vol = new TGeoVolume(sensName.c_str(), shape, medSi);
@@ -134,8 +137,8 @@ TGeoVolume* VDDiskLayer::createSensor() const
     return nullptr;
   }
   std::string sensName = Form("%s_%s%d", this->mLayerName.c_str(), GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
-  const double halfThickness = 0.5 * mChipThickness; // disk thickness is along Z
-  const double halfPhi = 0.5 * mPhiSpanDeg;          // degrees
+  const double halfThickness = 0.5 * mSensorThickness; // active sensor thickness along Z
+  const double halfPhi = 0.5 * mPhiSpanDeg;            // degrees
 
   // Same geometry as the layer (identical radii + phi span + thickness)
   auto* shape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
@@ -147,6 +150,243 @@ TGeoVolume* VDDiskLayer::createSensor() const
   return sensVol;
 }
 
+/*
+** Create metal stack
+*/
+
+TGeoVolume* VDCylindricalLayer::createMetalStack() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  auto* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+
+  const double metalT = mChipThickness - mSensorThickness;
+  if (metalT <= 0) {
+    return nullptr; // nothing to add
+  }
+
+  std::string name = Form("%s_%s%d", mLayerName.c_str(),
+                          GeometryTGeo::getTRKMetalStackPattern(), mLayerNumber);
+
+  const double rIn = mRadius + mSensorThickness;
+  const double rOut = mRadius + mChipThickness;
+  const double halfZ = 0.5 * mLengthSensZ;
+  const double halfPhi = 0.5 * mPhiSpanDeg;
+
+  auto* shape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  auto* vol = new TGeoVolume(name.c_str(), shape, medSi);
+  vol->SetLineColor(kGray);
+  vol->SetTransparency(30);
+  return vol;
+}
+
+TGeoVolume* VDRectangularLayer::createMetalStack() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  auto* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+
+  const double metalT = mChipThickness - mSensorThickness;
+  if (metalT <= 0) {
+    return nullptr;
+  }
+
+  std::string name = Form("%s_%s%d", mLayerName.c_str(),
+                          GeometryTGeo::getTRKMetalStackPattern(), mLayerNumber);
+
+  const double hx = 0.5 * mWidth;
+  const double hy = 0.5 * metalT;
+  const double hz = 0.5 * mLengthSensZ;
+
+  auto* shape = new TGeoBBox(hx, hy, hz);
+  auto* vol = new TGeoVolume(name.c_str(), shape, medSi);
+  vol->SetLineColor(kGray);
+  vol->SetTransparency(30);
+  return vol;
+}
+
+TGeoVolume* VDDiskLayer::createMetalStack() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+
+  const double metalT = mChipThickness - mSensorThickness;
+  if (metalT <= 0) {
+    return nullptr;
+  }
+
+  if (mRMin < 0 || mRMax <= mRMin || mPhiSpanDeg <= 0 || mPhiSpanDeg > 360.0) {
+    LOGP(error, "Invalid disk metal dims: rMin={}, rMax={}, metalT={}, phiSpanDeg={}",
+         mRMin, mRMax, metalT, mPhiSpanDeg);
+    return nullptr;
+  }
+
+  std::string name = Form("%s_%s%d", mLayerName.c_str(),
+                          GeometryTGeo::getTRKMetalStackPattern(), mLayerNumber);
+
+  const double halfThickness = 0.5 * metalT;
+  const double halfPhi = 0.5 * mPhiSpanDeg;
+
+  auto* shape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  auto* vol = new TGeoVolume(name.c_str(), shape, medSi);
+  vol->SetLineColor(kGray);
+  vol->SetTransparency(30);
+  return vol;
+}
+
+/*
+** Create chip
+*/
+
+TGeoVolume* VDCylindricalLayer::createChip() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  auto* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+
+  std::string chipName = Form("%s_%s%d", mLayerName.c_str(),
+                              GeometryTGeo::getTRKChipPattern(), mLayerNumber);
+
+  const double rIn = mRadius;
+  const double rOut = mRadius + mChipThickness;
+  const double halfZ = 0.5 * mLengthSensZ;
+  const double halfPhi = 0.5 * mPhiSpanDeg;
+
+  auto* chipShape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  auto* chipVol = new TGeoVolume(chipName.c_str(), chipShape, medSi);
+
+  // sensor
+  if (auto* sensVol = createSensor()) {
+    LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(sensVol, 1, nullptr);
+  }
+
+  // metal stack
+  if (auto* metalVol = createMetalStack()) {
+    LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(metalVol, 1, nullptr); // concentric, no translation needed
+  }
+
+  chipVol->SetLineColor(kYellow);
+  chipVol->SetTransparency(30);
+  return chipVol;
+}
+
+TGeoVolume* VDRectangularLayer::createChip() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  auto* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+
+  std::string chipName = Form("%s_%s%d", mLayerName.c_str(),
+                              GeometryTGeo::getTRKChipPattern(), mLayerNumber);
+
+  const double hx = 0.5 * mWidth;
+  const double hy = 0.5 * mChipThickness;
+  const double hz = 0.5 * mLengthSensZ;
+
+  auto* chipShape = new TGeoBBox(hx, hy, hz);
+  auto* chipVol = new TGeoVolume(chipName.c_str(), chipShape, medSi);
+
+  // sensor (place it on the "bottom" side, like TRK)
+  if (auto* sensVol = createSensor()) {
+    auto* transSens = new TGeoTranslation(0.0, -(mChipThickness - mSensorThickness) / 2, 0.0);
+    LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(sensVol, 1, transSens);
+  }
+
+  // metal stack (remaining thickness on top)
+  if (auto* metalVol = createMetalStack()) {
+    auto* transMetal = new TGeoTranslation(0.0, +mSensorThickness / 2, 0.0);
+    LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(metalVol, 1, transMetal);
+  }
+
+  chipVol->SetLineColor(kYellow);
+  chipVol->SetTransparency(30);
+  return chipVol;
+}
+
+TGeoVolume* VDDiskLayer::createChip() const
+{
+  if (!gGeoManager) {
+    LOGP(error, "gGeoManager is null");
+    return nullptr;
+  }
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  if (!medSi) {
+    LOGP(error, "Missing medium TRK_SILICON$");
+    return nullptr;
+  }
+
+  if (mRMin < 0 || mRMax <= mRMin || mChipThickness <= 0 ||
+      mPhiSpanDeg <= 0 || mPhiSpanDeg > 360.0) {
+    LOGP(error, "Invalid disk chip dims: rMin={}, rMax={}, t={}, phi={}",
+         mRMin, mRMax, mChipThickness, mPhiSpanDeg);
+    return nullptr;
+  }
+
+  std::string chipName = Form("%s_%s%d", mLayerName.c_str(),
+                              GeometryTGeo::getTRKChipPattern(), mLayerNumber);
+
+  const double halfThickness = 0.5 * mChipThickness;
+  const double halfPhi = 0.5 * mPhiSpanDeg;
+
+  auto* chipShape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  auto* chipVol = new TGeoVolume(chipName.c_str(), chipShape, medSi);
+  chipVol->SetLineColor(kYellow);
+  chipVol->SetTransparency(30);
+
+  // Sensor slab (sensitive) placed on one side in Z (TRK-like stacking convention)
+  if (auto* sensVol = createSensor()) {
+    const double zSens = -(mChipThickness - mSensorThickness) / 2.0;
+    auto* tSens = new TGeoTranslation(0.0, 0.0, zSens);
+    LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(sensVol, 1, tSens);
+  }
+
+  // Metal stack slab (non-sensitive), remaining thickness, also silicon
+  if (auto* metalVol = createMetalStack()) {
+    const double zMetal = +mSensorThickness / 2.0;
+    auto* tMetal = new TGeoTranslation(0.0, 0.0, zMetal);
+    LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
+    chipVol->AddNode(metalVol, 1, tMetal);
+  }
+
+  return chipVol;
+}
+
 /*
 ** Create layer
 */
@@ -184,14 +424,14 @@ void VDCylindricalLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combi
   layerVol->SetLineColor(kYellow);
   layerVol->SetTransparency(30);
 
-  // Sensor volume (must use mLengthSensZ internally)
-  TGeoVolume* sensorVol = VDCylindricalLayer::createSensor();
-  if (!sensorVol) {
-    LOGP(error, "VDCylindricalLayer::createSensor() returned null");
+  // Chip volume (must use mLengthSensZ internally)
+  TGeoVolume* chipVol = VDCylindricalLayer::createChip();
+  if (!chipVol) {
+    LOGP(error, "VDCylindricalLayer::createChip() returned null");
     return;
   }
-  LOGP(debug, "Inserting {} in {} ", sensorVol->GetName(), layerVol->GetName());
-  layerVol->AddNode(sensorVol, 1, nullptr);
+  LOGP(debug, "Inserting {} in {} ", chipVol->GetName(), layerVol->GetName());
+  layerVol->AddNode(chipVol, 1, nullptr);
 
   // Tiling: edge-to-edge if sensor shorter than layer; else single centered
   // const auto zCenters = (mLengthSensZ < mLengthZ)
@@ -238,14 +478,14 @@ void VDRectangularLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combi
   layerVol->SetTransparency(30);
 
   // Sensor volume (uses mLengthSensZ internally)
-  TGeoVolume* sensorVol = VDRectangularLayer::createSensor();
-  if (!sensorVol) {
-    LOGP(error, "VDRectangularLayer::createSensor() returned null");
+  TGeoVolume* chipVol = VDRectangularLayer::createChip();
+  if (!chipVol) {
+    LOGP(error, "VDRectangularLayer::chipVol() returned null");
     return;
   }
 
-  LOGP(debug, "Inserting {} in {} ", sensorVol->GetName(), layerVol->GetName());
-  layerVol->AddNode(sensorVol, 1, nullptr);
+  LOGP(debug, "Inserting {} in {} ", chipVol->GetName(), layerVol->GetName());
+  layerVol->AddNode(chipVol, 1, nullptr);
 
   // Tiling along Z, edge - to - edge if needed
   // const auto zCenters = (mLengthSensZ < mLengthZ)
@@ -292,14 +532,14 @@ void VDDiskLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans)
   layerVol->SetTransparency(30);
 
   // Sensor (same size & shape as the layer for disks)
-  TGeoVolume* sensorVol = VDDiskLayer::createSensor();
-  if (!sensorVol) {
-    LOGP(error, "VDDiskLayer::createSensor() returned null");
+  TGeoVolume* chipVol = VDDiskLayer::createChip();
+  if (!chipVol) {
+    LOGP(error, "VDDiskLayer::createChip() returned null");
     return;
   }
 
   // Insert single sensor (no Z-segmentation for disks)
-  layerVol->AddNode(sensorVol, 1, nullptr);
+  layerVol->AddNode(chipVol, 1, nullptr);
 
   TGeoTranslation tz(0.0, 0.0, mZPos);
   motherVolume->AddNode(layerVol, 1, combiTrans ? combiTrans : &tz);

From 02a0aebb5718b3faba48c0aad82916e45e93621d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 31 Jan 2026 18:59:49 +0100
Subject: [PATCH 1259/1764] DPL: improve type_to_task_name function (#15006)

- Out of line and avoid usage of stringstream.
- Remove non-sense abbreviations
---
 Framework/Core/CMakeLists.txt                 |  2 +
 .../Core/include/Framework/AnalysisTask.h     |  3 +
 Framework/Core/src/AnalysisTask.cxx           | 77 +++++++++++++++++++
 Framework/Core/test/test_TypeToTaskName.cxx   | 65 ++++++++++++++++
 .../include/Framework/TypeIdHelpers.h         | 17 ----
 5 files changed, 147 insertions(+), 17 deletions(-)
 create mode 100644 Framework/Core/src/AnalysisTask.cxx
 create mode 100644 Framework/Core/test/test_TypeToTaskName.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 1daba5dbc9798..7357167a3fcd8 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -16,6 +16,7 @@ o2_add_library(Framework
                        src/ArrowTableSlicingCache.cxx
                        src/AnalysisDataModel.cxx
                        src/AnalysisSupportHelpers.cxx
+                       src/AnalysisTask.cxx
                        src/ASoA.cxx
                        src/ASoAHelpers.cxx
                        src/AsyncQueue.cxx
@@ -254,6 +255,7 @@ add_executable(o2-test-framework-core
               test/test_TimeParallelPipelining.cxx
               test/test_TimesliceIndex.cxx
               test/test_TypeTraits.cxx
+              test/test_TypeToTaskName.cxx
               test/test_TopologyPolicies.cxx
               test/test_Variants.cxx
               test/test_WorkflowHelpers.cxx
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index 4f8a9e719e4b9..eb98d55cc24b2 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -37,6 +37,9 @@
 
 namespace o2::framework
 {
+/// Convert a CamelCase task struct name to snake-case task name
+std::string type_to_task_name(std::string_view const& camelCase);
+
 /// A more familiar task API for the DPL analysis framework.
 /// This allows you to define your own tasks as subclasses
 /// of o2::framework::AnalysisTask and to pass them in the specification
diff --git a/Framework/Core/src/AnalysisTask.cxx b/Framework/Core/src/AnalysisTask.cxx
new file mode 100644
index 0000000000000..e88e6fbc6f041
--- /dev/null
+++ b/Framework/Core/src/AnalysisTask.cxx
@@ -0,0 +1,77 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#include <string>
+
+namespace o2::framework
+{
+/// Convert a CamelCase task struct name to snake-case task name
+std::string type_to_task_name(std::string_view const& camelCase)
+{
+  std::string result;
+  result.reserve(camelCase.size() * 2 + 2);
+
+  // The first character is always -.
+  result += "-";
+  result += static_cast<char>(std::tolower(camelCase[0]));
+
+  for (auto it = camelCase.begin() + 1; it != camelCase.end(); ++it) {
+    if (std::isupper(*it) && *(it - 1) != '-') {
+      result += '-';
+    }
+    result += static_cast<char>(std::tolower(*it));
+  }
+  // Post-process to consolidate common ALICE abbreviations
+  // Process backwards to handle patterns correctly
+  static const struct {
+    std::string_view pattern;
+    std::string_view replacement;
+  } abbreviations[] = {
+    {"-h-m-p-i-d", "-hmpid"},
+    {"-e-m-c-a-l", "-emcal"},
+    {"-e-m-c", "-emc"},
+    {"-i-t-s", "-its"},
+    {"-t-p-c", "-tpc"},
+    {"-q-c-d", "-qcd"},
+    {"-t-o-f", "-tof"},
+    {"-t-r-d", "-trd"},
+    {"-f-v0", "-fv0"},
+    {"-q-a", "-qa"},
+    {"-b-c", "-bc"},
+    {"-q-c", "-qc"}};
+
+  std::string consolidated;
+  consolidated.reserve(result.size());
+
+  for (int i = result.size() - 1; i >= 0;) {
+    bool matched = false;
+
+    for (const auto& abbr : abbreviations) {
+      int startPos = i - abbr.pattern.size() + 1;
+      if (startPos >= 0 && result.compare(startPos, abbr.pattern.size(), abbr.pattern.data()) == 0) {
+        consolidated.insert(0, abbr.replacement);
+        i = startPos - 1;
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched) {
+      consolidated.insert(0, 1, result[i]);
+      --i;
+    }
+  }
+  if (consolidated[0] == '-') {
+    return std::string(consolidated.data() + 1);
+  }
+
+  return consolidated;
+}
+} // namespace o2::framework
diff --git a/Framework/Core/test/test_TypeToTaskName.cxx b/Framework/Core/test/test_TypeToTaskName.cxx
new file mode 100644
index 0000000000000..b7b440b13ecfd
--- /dev/null
+++ b/Framework/Core/test/test_TypeToTaskName.cxx
@@ -0,0 +1,65 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <catch_amalgamated.hpp>
+#include "Framework/AnalysisTask.h"
+#include <string_view>
+
+using namespace o2::framework;
+
+TEST_CASE("TypeIdHelpers_BasicConversion")
+{
+  // Basic CamelCase to snake-case conversion
+  REQUIRE((type_to_task_name(std::string_view("SimpleTask")) == "simple-task"));
+  REQUIRE((type_to_task_name(std::string_view("MyTask")) == "my-task"));
+  REQUIRE((type_to_task_name(std::string_view("Task")) == "task"));
+}
+
+TEST_CASE("TypeIdHelpers_AbbreviationConsolidation")
+{
+  // Test ALICE detector abbreviations
+  REQUIRE(type_to_task_name(std::string_view("ITSQA")) == "its-qa");
+  REQUIRE(type_to_task_name(std::string_view("TPCQCTask")) == "tpc-qc-task");
+  REQUIRE(type_to_task_name(std::string_view("EMCALQATask")) == "emcal-qa-task");
+  REQUIRE(type_to_task_name(std::string_view("HMPIDTask")) == "hmpid-task");
+  REQUIRE(type_to_task_name(std::string_view("ITSTPCTask")) == "its-tpc-task");
+  REQUIRE(type_to_task_name(std::string_view("QCFV0Task")) == "qc-fv0-task");
+}
+
+TEST_CASE("TypeIdHelpers_QualityControlAbbreviations")
+{
+  // Test quality control abbreviations
+  REQUIRE(type_to_task_name(std::string_view("QATask")) == "qa-task");
+  REQUIRE(type_to_task_name(std::string_view("QCTask")) == "qc-task");
+  REQUIRE(type_to_task_name(std::string_view("QCDAnalysis")) == "qcd-analysis");
+}
+
+TEST_CASE("TypeIdHelpers_ComplexNames")
+{
+  // Test complex combinations
+  REQUIRE(type_to_task_name(std::string_view("ITSQAAnalysisTask")) == "its-qa-analysis-task");
+  REQUIRE(type_to_task_name(std::string_view("TPCEMCQCTask")) == "tpc-emc-qc-task");
+  REQUIRE(type_to_task_name(std::string_view("MyITSTask")) == "my-its-task");
+}
+
+TEST_CASE("TypeIdHelpers_EdgeCases")
+{
+  // Single character
+  REQUIRE(type_to_task_name(std::string_view("A")) == "a");
+
+  // All uppercase. BC is Bunch Crossing!
+  //
+  REQUIRE(type_to_task_name(std::string_view("ABC")) == "a-bc");
+  REQUIRE(type_to_task_name(std::string_view("BC")) == "bc");
+
+  // Mixed with numbers (numbers are not uppercase, so no hyphens before them)
+  REQUIRE(type_to_task_name(std::string_view("Task123")) == "task123");
+}
diff --git a/Framework/Foundation/include/Framework/TypeIdHelpers.h b/Framework/Foundation/include/Framework/TypeIdHelpers.h
index 5eaac2151b909..1dc2464b40ec8 100644
--- a/Framework/Foundation/include/Framework/TypeIdHelpers.h
+++ b/Framework/Foundation/include/Framework/TypeIdHelpers.h
@@ -13,7 +13,6 @@
 #define O2_FRAMEWORK_TYPEIDHELPERS_H_
 
 #include <string_view>
-#include <sstream>
 #if __cplusplus >= 202002L
 #include <source_location>
 #endif
@@ -82,22 +81,6 @@ struct TypeIdHelpers {
   }
 };
 
-/// Convert a CamelCase task struct name to snake-case task name
-inline static std::string type_to_task_name(std::string_view& camelCase)
-{
-  std::ostringstream str;
-  str << static_cast<char>(std::tolower(camelCase[0]));
-
-  for (auto it = camelCase.begin() + 1; it != camelCase.end(); ++it) {
-    if (std::isupper(*it) && *(it - 1) != '-') {
-      str << "-";
-    }
-    str << static_cast<char>(std::tolower(*it));
-  }
-
-  return str.str();
-}
-
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_TYPEIDHELPERS_H_

From dee4e246302c2a78b02fe2d4b7a29d0f48d2b05f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 2 Feb 2026 13:16:21 +0100
Subject: [PATCH 1260/1764] Revert abbreviations until we get green light from
 the affected people (#15009)

---
 Framework/Core/src/AnalysisTask.cxx | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/Framework/Core/src/AnalysisTask.cxx b/Framework/Core/src/AnalysisTask.cxx
index e88e6fbc6f041..993c597a95f49 100644
--- a/Framework/Core/src/AnalysisTask.cxx
+++ b/Framework/Core/src/AnalysisTask.cxx
@@ -34,18 +34,9 @@ std::string type_to_task_name(std::string_view const& camelCase)
     std::string_view pattern;
     std::string_view replacement;
   } abbreviations[] = {
-    {"-h-m-p-i-d", "-hmpid"},
     {"-e-m-c-a-l", "-emcal"},
-    {"-e-m-c", "-emc"},
-    {"-i-t-s", "-its"},
-    {"-t-p-c", "-tpc"},
-    {"-q-c-d", "-qcd"},
-    {"-t-o-f", "-tof"},
-    {"-t-r-d", "-trd"},
-    {"-f-v0", "-fv0"},
-    {"-q-a", "-qa"},
-    {"-b-c", "-bc"},
-    {"-q-c", "-qc"}};
+    {"-e-m-c", "-emc"}
+  };
 
   std::string consolidated;
   consolidated.reserve(result.size());

From 597fc9ee8673ea2bb916c6caf5bbbec8f631a224 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 28 Jan 2026 20:42:39 +0100
Subject: [PATCH 1261/1764] Leave single implementation of TRD RecoParam, init
 from GPUSettingsRecTRD

---
 .../include/Align/AlignableDetectorTRD.h      |   4 +-
 Detectors/Align/src/AlignableDetectorTRD.cxx  |  11 +-
 .../include/SpacePoints/TrackInterpolation.h  |   4 +-
 .../SpacePoints/src/TrackInterpolation.cxx    |   4 +-
 Detectors/TRD/base/CMakeLists.txt             |   2 -
 .../TRD/base/include/TRDBase/RecoParam.h      |  64 -----------
 Detectors/TRD/base/src/RecoParam.cxx          |  64 -----------
 Detectors/TRD/base/src/TRDBaseLinkDef.h       |   1 -
 Detectors/TRD/calibration/CMakeLists.txt      |   1 +
 .../include/TRDCalibration/TrackBasedCalib.h  |   4 +-
 .../TRD/calibration/src/TrackBasedCalib.cxx   |   5 +-
 Detectors/TRD/qc/CMakeLists.txt               |   1 +
 Detectors/TRD/qc/include/TRDQC/Tracking.h     |   4 +-
 Detectors/TRD/qc/src/Tracking.cxx             |   5 +-
 .../TRDWorkflow/TRDGlobalTrackingSpec.h       |   4 +-
 .../workflow/src/TRDGlobalTrackingSpec.cxx    |   6 +-
 GPU/GPUTracking/Base/GPUConstantMem.h         |   1 -
 GPU/GPUTracking/CMakeLists.txt                |   3 +-
 GPU/GPUTracking/DataTypes/GPUDataTypesIO.h    |   3 +-
 GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx | 100 ++++++++++++++++++
 GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h   |  84 +++++++++++++++
 GPU/GPUTracking/GPUTrackingLinkDef_O2.h       |   1 +
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  13 +++
 GPU/GPUTracking/Global/GPUChainTracking.h     |   5 +
 .../Global/GPUChainTrackingGetters.inc        |   2 +
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  10 ++
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx |  48 ++-------
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.h   |  15 +--
 .../TRDTracking/macros/run_trd_tracker.C      |   4 +-
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |   3 +
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |  27 +++--
 31 files changed, 286 insertions(+), 217 deletions(-)
 delete mode 100644 Detectors/TRD/base/include/TRDBase/RecoParam.h
 delete mode 100644 Detectors/TRD/base/src/RecoParam.cxx
 create mode 100644 GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
 create mode 100644 GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h

diff --git a/Detectors/Align/include/Align/AlignableDetectorTRD.h b/Detectors/Align/include/Align/AlignableDetectorTRD.h
index a73b0f76902d2..4e7577b11055c 100644
--- a/Detectors/Align/include/Align/AlignableDetectorTRD.h
+++ b/Detectors/Align/include/Align/AlignableDetectorTRD.h
@@ -18,7 +18,7 @@
 #define ALIGNABLEDETECTORTRD_H
 
 #include "Align/AlignableDetector.h"
-#include "TRDBase/RecoParam.h"
+#include "GPUTRDRecoParam.h"
 
 namespace o2
 {
@@ -64,7 +64,7 @@ class AlignableDetectorTRD final : public AlignableDetector
   int processPoints(GIndex gid, int npntCut, bool inv) final;
 
  protected:
-  o2::trd::RecoParam mRecoParam;    // parameters required for TRD reconstruction
+  o2::gpu::GPUTRDRecoParam mRecoParam; // parameters required for TRD reconstruction
   double mNonRCCorrDzDtgl = 0.;     // correction in Z for non-crossing tracklets
   double mCorrDVT = 0.;             // correction to Vdrift*t
   double mExtraErrRC[2] = {0., 0.}; // extra errors for RC tracklets
diff --git a/Detectors/Align/src/AlignableDetectorTRD.cxx b/Detectors/Align/src/AlignableDetectorTRD.cxx
index d752553bf6ead..080d0f72b2516 100644
--- a/Detectors/Align/src/AlignableDetectorTRD.cxx
+++ b/Detectors/Align/src/AlignableDetectorTRD.cxx
@@ -26,6 +26,7 @@
 #include "DataFormatsTRD/TrackTRD.h"
 #include "DataFormatsTRD/Tracklet64.h"
 #include "DataFormatsTRD/CalibratedTracklet.h"
+#include "GPUO2InterfaceConfiguration.h"
 #include <TMath.h>
 #include <TGeoManager.h>
 
@@ -175,10 +176,12 @@ int AlignableDetectorTRD::processPoints(GIndex gid, int npntCut, bool inv)
     return -1;
   }
   auto propagator = o2::base::Propagator::Instance(); // float version!
-  static float prevBz = -99999.;
-  if (prevBz != propagator->getNominalBz()) {
-    prevBz = propagator->getNominalBz();
-    mRecoParam.setBfield(prevBz);
+  static bool firstCall = true;
+  if (firstCall) {
+    o2::gpu::GPUO2InterfaceConfiguration config;
+    config.ReadConfigurableParam(config);
+    mRecoParam.init(propagator->getNominalBz(), &config.configReconstruction);
+    firstCall = false;
   }
   const auto* transformer = mController->getTRDTransformer();
   auto algTrack = mController->getAlgTrack();
diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
index e7d0fb197ea42..58627250d815e 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackInterpolation.h
@@ -39,7 +39,7 @@
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "DetectorsBase/Propagator.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
-#include "TRDBase/RecoParam.h"
+#include "GPUTRDRecoParam.h"
 #include "TRDBase/Geometry.h"
 
 class TTree;
@@ -441,7 +441,7 @@ class TrackInterpolation
   std::vector<o2::dataformats::GlobalTrackID> mGIDsSuccess;       ///< keep track of the GIDs which could be processed successfully
 
   // helpers
-  o2::trd::RecoParam mRecoParam;                      ///< parameters required for TRD refit
+  o2::gpu::GPUTRDRecoParam mRecoParam;                ///< parameters required for TRD refit
   o2::trd::Geometry* mGeoTRD;                         ///< TRD geometry instance (needed for tilted pad correction)
   std::unique_ptr<TPCFastTransform> mFastTransform{}; ///< TPC cluster transformation
   float mBz;                                          ///< required for helix approximation
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index 6c37be9ddc1b1..cd5e3960160a6 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -126,7 +126,9 @@ void TrackInterpolation::init(o2::dataformats::GlobalTrackID::mask_t src, o2::da
   mFastTransform = std::move(TPCFastTransformHelperO2::instance()->create(0));
 
   mBz = o2::base::Propagator::Instance()->getNominalBz();
-  mRecoParam.setBfield(mBz);
+  o2::gpu::GPUO2InterfaceConfiguration config;
+  config.ReadConfigurableParam(config);
+  mRecoParam.init(mBz, &config.configReconstruction);
   mGeoTRD = o2::trd::Geometry::instance();
   mParams = &SpacePointsCalibConfParam::Instance();
 
diff --git a/Detectors/TRD/base/CMakeLists.txt b/Detectors/TRD/base/CMakeLists.txt
index 030fb6cea1e50..e0563a85a3f42 100644
--- a/Detectors/TRD/base/CMakeLists.txt
+++ b/Detectors/TRD/base/CMakeLists.txt
@@ -16,7 +16,6 @@ o2_add_library(TRDBase
                        src/GeometryFlat.cxx
                        src/PadResponse.cxx
                        src/FeeParam.cxx
-                       src/RecoParam.cxx
                        src/ChamberStatus.cxx
                        src/Calibrations.cxx
                        src/CalOnlineGainTables.cxx
@@ -38,7 +37,6 @@ o2_target_root_dictionary(TRDBase
                                   include/TRDBase/GeometryFlat.h
                                   include/TRDBase/PadResponse.h
                                   include/TRDBase/FeeParam.h
-                                  include/TRDBase/RecoParam.h
                                   include/TRDBase/Calibrations.h
                                   include/TRDBase/PadParameters.h
                                   include/TRDBase/PadCalibrations.h
diff --git a/Detectors/TRD/base/include/TRDBase/RecoParam.h b/Detectors/TRD/base/include/TRDBase/RecoParam.h
deleted file mode 100644
index 1828a0b1724e9..0000000000000
--- a/Detectors/TRD/base/include/TRDBase/RecoParam.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file RecoParam.h
-/// \brief Error parameterizations and helper functions for TRD reconstruction
-/// \author Ole Schmidt
-
-#ifndef O2_TRD_RECOPARAM_H
-#define O2_TRD_RECOPARAM_H
-
-#include <array>
-#include "Rtypes.h"
-
-namespace o2
-{
-namespace trd
-{
-
-class RecoParam
-{
- public:
-  RecoParam() = default;
-  RecoParam(const RecoParam&) = default;
-  ~RecoParam() = default;
-
-  /// Load parameterization for given magnetic field
-  void setBfield(float bz);
-
-  /// Recalculate tracklet covariance based on phi angle of related track
-  void recalcTrkltCov(const float tilt, const float snp, const float rowSize, std::array<float, 3>& cov) const;
-
-  /// Get tracklet r-phi resolution for given phi angle
-  /// Resolution depends on the track angle sin(phi) = snp and is approximated by the formula
-  /// sigma_y(snp) = sqrt(a^2 + c^2 * (snp - b^2)^2)
-  /// more details are given in http://cds.cern.ch/record/2724259 in section 5.3.3
-  /// \param phi angle of related track
-  /// \return sigma_y^2 of tracklet
-  float getRPhiRes(float snp) const { return (mA2 + mC2 * (snp - mB) * (snp - mB)); }
-
-  /// Get tracklet z correction coefficient for track-eta based corraction
-  float getZCorrCoeffNRC() const { return mZCorrCoefNRC; }
-
- private:
-  // tracklet error parameterization depends on the magnetic field
-  float mA2{1.f};            ///< parameterization for tracklet position resolution
-  float mB{0.f};             ///< parameterization for tracklet position resolution
-  float mC2{0.f};            ///< parameterization for tracklet position resolution
-  float mZCorrCoefNRC{1.4f}; ///< tracklet z-position depends linearly on track dip angle
-
-  ClassDefNV(RecoParam, 1);
-};
-
-} // namespace trd
-} // namespace o2
-
-#endif // O2_TRD_RECOPARAM_H
diff --git a/Detectors/TRD/base/src/RecoParam.cxx b/Detectors/TRD/base/src/RecoParam.cxx
deleted file mode 100644
index 34921777bdb72..0000000000000
--- a/Detectors/TRD/base/src/RecoParam.cxx
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file RecoParam.cxx
-/// \brief Error parameterizations and helper functions for TRD reconstruction
-/// \author Ole Schmidt
-
-#include "TRDBase/RecoParam.h"
-#include <fairlogger/Logger.h>
-#include <cmath>
-
-using namespace o2::trd;
-
-// error parameterizations taken from http://cds.cern.ch/record/2724259 Appendix A
-void RecoParam::setBfield(float bz)
-{
-  if (std::fabs(std::fabs(bz) - 2) < 0.1) {
-    if (bz > 0) {
-      // magnetic field +0.2 T
-      mA2 = 1.6e-3f;
-      mB = -1.43e-2f;
-      mC2 = 4.55e-2f;
-    } else {
-      // magnetic field -0.2 T
-      mA2 = 1.6e-3f;
-      mB = 1.43e-2f;
-      mC2 = 4.55e-2f;
-    }
-  } else if (std::fabs(std::fabs(bz) - 5) < 0.1) {
-    if (bz > 0) {
-      // magnetic field +0.5 T
-      mA2 = 1.6e-3f;
-      mB = 0.125f;
-      mC2 = 0.0961f;
-    } else {
-      // magnetic field -0.5 T
-      mA2 = 1.6e-3f;
-      mB = -0.14f;
-      mC2 = 0.1156f;
-    }
-  } else {
-    LOG(warning) << "No error parameterization available for Bz= " << bz << ". Keeping default value (sigma_y = const. = 1cm)";
-  }
-  LOG(info) << "Loaded error parameterization for Bz = " << bz;
-}
-
-void RecoParam::recalcTrkltCov(const float tilt, const float snp, const float rowSize, std::array<float, 3>& cov) const
-{
-  float t2 = tilt * tilt;      // tan^2 (tilt)
-  float c2 = 1.f / (1.f + t2); // cos^2 (tilt)
-  float sy2 = getRPhiRes(snp);
-  float sz2 = rowSize * rowSize / 12.f;
-  cov[0] = c2 * (sy2 + t2 * sz2);
-  cov[1] = c2 * tilt * (sz2 - sy2);
-  cov[2] = c2 * (t2 * sy2 + sz2);
-}
diff --git a/Detectors/TRD/base/src/TRDBaseLinkDef.h b/Detectors/TRD/base/src/TRDBaseLinkDef.h
index 2d3de311a1dc0..a835def5628b2 100644
--- a/Detectors/TRD/base/src/TRDBaseLinkDef.h
+++ b/Detectors/TRD/base/src/TRDBaseLinkDef.h
@@ -19,7 +19,6 @@
 #pragma link C++ class o2::trd::Geometry + ;
 #pragma link C++ class o2::trd::GeometryBase + ;
 #pragma link C++ class o2::trd::FeeParam + ;
-#pragma link C++ class o2::trd::RecoParam + ;
 #pragma link C++ class o2::trd::PadResponse + ;
 #pragma link C++ class o2::trd::PadParameters < float > +;
 #pragma link C++ class o2::trd::PadParameters < char> + ;
diff --git a/Detectors/TRD/calibration/CMakeLists.txt b/Detectors/TRD/calibration/CMakeLists.txt
index 36d00e92bbc16..52444d2855b1f 100644
--- a/Detectors/TRD/calibration/CMakeLists.txt
+++ b/Detectors/TRD/calibration/CMakeLists.txt
@@ -28,6 +28,7 @@ o2_add_library(TRDCalibration
                                      O2::DetectorsBase
                                      O2::DetectorsCalibration
                                      O2::MathUtils
+                                     O2::GPUTracking
                                      O2::DetectorsDCS)
 
  o2_target_root_dictionary(TRDCalibration
diff --git a/Detectors/TRD/calibration/include/TRDCalibration/TrackBasedCalib.h b/Detectors/TRD/calibration/include/TRDCalibration/TrackBasedCalib.h
index 49ba9fdf3d161..7249016d9675e 100644
--- a/Detectors/TRD/calibration/include/TRDCalibration/TrackBasedCalib.h
+++ b/Detectors/TRD/calibration/include/TRDCalibration/TrackBasedCalib.h
@@ -24,7 +24,7 @@
 #include "DataFormatsTRD/NoiseCalibration.h"
 #include "TRDBase/PadCalibrationsAliases.h"
 #include "DetectorsBase/Propagator.h"
-#include "TRDBase/RecoParam.h"
+#include "GPUTRDRecoParam.h"
 
 #include "Rtypes.h"
 
@@ -90,7 +90,7 @@ class TrackBasedCalib
   float mMaxSnp{o2::base::Propagator::MAX_SIN_PHI};  ///< max snp when propagating tracks
   float mMaxStep{o2::base::Propagator::MAX_STEP};    ///< maximum step for propagation
   MatCorrType mMatCorr{MatCorrType::USEMatCorrNONE}; ///< if material correction should be done
-  RecoParam mRecoParam;                              ///< parameters required for TRD reconstruction
+  o2::gpu::GPUTRDRecoParam mRecoParam;               ///< parameters required for TRD reconstruction
   AngularResidHistos mAngResHistos;                  ///< aggregated data for the track based calibration
   std::vector<int> mGainCalibHistos;                 ///< aggregated input data for gain calibration
   float bz;                                          ///< magnetic field
diff --git a/Detectors/TRD/calibration/src/TrackBasedCalib.cxx b/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
index 011a888a47618..8fe195f861389 100644
--- a/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
+++ b/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
@@ -13,6 +13,7 @@
 /// \brief Provides information required for TRD calibration which is based on the global tracking
 /// \author Ole Schmidt
 
+#include "GPUO2InterfaceConfiguration.h"
 #include "TRDCalibration/TrackBasedCalib.h"
 #include "TRDCalibration/CalibrationParams.h"
 #include "DataFormatsTRD/Constants.h"
@@ -35,7 +36,9 @@ void TrackBasedCalib::reset()
 void TrackBasedCalib::init()
 {
   bz = o2::base::Propagator::Instance()->getNominalBz();
-  mRecoParam.setBfield(bz);
+  o2::gpu::GPUO2InterfaceConfiguration config;
+  config.ReadConfigurableParam(config);
+  mRecoParam.init(bz, &config.configReconstruction);
 }
 
 void TrackBasedCalib::setInput(const o2::globaltracking::RecoContainer& input)
diff --git a/Detectors/TRD/qc/CMakeLists.txt b/Detectors/TRD/qc/CMakeLists.txt
index d631de1f54246..daba4928957f9 100644
--- a/Detectors/TRD/qc/CMakeLists.txt
+++ b/Detectors/TRD/qc/CMakeLists.txt
@@ -21,6 +21,7 @@ o2_add_library(TRDQC
                                      O2::DataFormatsTRD
                                      O2::DataFormatsGlobalTracking
                                      O2::DetectorsBase
+                                     O2::GPUTracking
                                      O2::MathUtils)
 
  o2_target_root_dictionary(TRDQC
diff --git a/Detectors/TRD/qc/include/TRDQC/Tracking.h b/Detectors/TRD/qc/include/TRDQC/Tracking.h
index 880b1727ab367..f39c64286d0cc 100644
--- a/Detectors/TRD/qc/include/TRDQC/Tracking.h
+++ b/Detectors/TRD/qc/include/TRDQC/Tracking.h
@@ -25,7 +25,7 @@
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DetectorsBase/Propagator.h"
-#include "TRDBase/RecoParam.h"
+#include "GPUTRDRecoParam.h"
 
 #include "Rtypes.h"
 #include "TH1.h"
@@ -107,7 +107,7 @@ class Tracking
   float mMaxSnp{o2::base::Propagator::MAX_SIN_PHI};  ///< max snp when propagating tracks
   float mMaxStep{o2::base::Propagator::MAX_STEP};    ///< maximum step for propagation
   MatCorrType mMatCorr{MatCorrType::USEMatCorrNONE}; ///< if material correction should be done
-  RecoParam mRecoParam;                              ///< parameters required for TRD reconstruction
+  o2::gpu::GPUTRDRecoParam mRecoParam;               ///< parameters required for TRD reconstruction
   bool mPID{true};                                   ///< if TPC only tracks are not available we don't fill PID info
   bool mApplyShift{true};
 
diff --git a/Detectors/TRD/qc/src/Tracking.cxx b/Detectors/TRD/qc/src/Tracking.cxx
index 278ebe5391ff9..9a0df7efa323b 100644
--- a/Detectors/TRD/qc/src/Tracking.cxx
+++ b/Detectors/TRD/qc/src/Tracking.cxx
@@ -13,6 +13,7 @@
 /// \brief Check the performance of the TRD in global tracking
 /// \author Ole Schmidt
 
+#include "GPUO2InterfaceConfiguration.h"
 #include "TRDQC/Tracking.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
 #include "DetectorsBase/GeometryManager.h"
@@ -25,7 +26,9 @@ using namespace o2::trd::constants;
 
 void Tracking::init()
 {
-  mRecoParam.setBfield(o2::base::Propagator::Instance()->getNominalBz());
+  o2::gpu::GPUO2InterfaceConfiguration config;
+  config.ReadConfigurableParam(config);
+  mRecoParam.init(o2::base::Propagator::Instance()->getNominalBz(), &config.configReconstruction);
 }
 
 void Tracking::setInput(const o2::globaltracking::RecoContainer& input)
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
index 9f3b9b27d37b5..93f07dd58445e 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
@@ -20,6 +20,7 @@
 #include "TRDBase/GeometryFlat.h"
 #include "GPUO2ExternalUser.h"
 #include "GPUTRDTracker.h"
+#include "GPUTRDRecoParam.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
 #include "DataFormatsTRD/TrackTRD.h"
@@ -34,7 +35,6 @@
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "GPUO2InterfaceRefit.h"
 #include "TPCFastTransform.h"
-#include "TRDBase/RecoParam.h"
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsITS/TrackITS.h"
 #include "DataFormatsITSMFT/TrkClusRef.h"
@@ -94,7 +94,7 @@ class TRDGlobalTracking : public o2::framework::Task
   // temporary members -> should go into processor (GPUTRDTracker or additional refit processor?)
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter;         ///< TPC refitter used for TPC tracks refit during the reconstruction
   const o2::tpc::ClusterNativeAccess* mTPCClusterIdxStruct = nullptr; ///< struct holding the TPC cluster indices
-  RecoParam mRecoParam;                                               ///< parameters required for TRD reconstruction
+  o2::gpu::GPUTRDRecoParam mRecoParam;                                ///< parameters required for TRD reconstruction
   gsl::span<const Tracklet64> mTrackletsRaw;                          ///< array of raw tracklets needed for TRD refit
   gsl::span<const CalibratedTracklet> mTrackletsCalib;                ///< array of calibrated tracklets needed for TRD refit
   gsl::span<const o2::tpc::TrackTPC> mTPCTracksArray;                 ///< input TPC tracks used for refit
diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index 9588888df5fc6..f2d4aad829fe5 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -43,6 +43,7 @@
 // GPU header
 #include "GPUReconstruction.h"
 #include "GPUChainTracking.h"
+#include "GPUChainTrackingGetters.inc"
 #include "GPUO2InterfaceConfiguration.h"
 #include "GPUO2InterfaceUtils.h"
 #include "GPUSettings.h"
@@ -112,6 +113,8 @@ void TRDGlobalTracking::updateTimeDependentParams(ProcessingContext& pc)
     config.ReadConfigurableParam(config);
     config.configGRP.solenoidBzNominalGPU = GPUO2InterfaceUtils::getNominalGPUBz(*o2::base::GRPGeomHelper::instance().getGRPMagField());
     config.configProcessing.o2PropagatorUseGPUField = false;
+    mRecoParam.init(o2::base::Propagator::Instance()->getNominalBz(), &config.configReconstruction);
+
     mRec->SetSettings(&config.configGRP, &config.configReconstruction, &config.configProcessing, &cfgRecoStep);
 
     mChainTracking = mRec->AddChain<GPUChainTracking>();
@@ -127,12 +130,11 @@ void TRDGlobalTracking::updateTimeDependentParams(ProcessingContext& pc)
 
     mRec->RegisterGPUProcessor(mTracker, false);
     mChainTracking->SetTRDGeometry(std::move(mFlatGeo));
+    mChainTracking->SetTRDRecoParam(&mRecoParam);
     if (mRec->Init()) {
       LOG(fatal) << "GPUReconstruction could not be initialized";
     }
 
-    mRecoParam.setBfield(o2::base::Propagator::Instance()->getNominalBz());
-
     mTracker->PrintSettings();
     LOG(info) << "Strict matching mode is " << ((mStrict) ? "ON" : "OFF");
     LOGF(info, "The search road in time for ITS-TPC tracks is set to %.1f sigma and %.2f us are added to it on top",
diff --git a/GPU/GPUTracking/Base/GPUConstantMem.h b/GPU/GPUTracking/Base/GPUConstantMem.h
index efb83a7e874c8..94ccfa7fa6db9 100644
--- a/GPU/GPUTracking/Base/GPUConstantMem.h
+++ b/GPU/GPUTracking/Base/GPUConstantMem.h
@@ -57,7 +57,6 @@ struct GPUConstantMem {
 #ifdef GPUCA_HAS_ONNX
   GPUTPCNNClusterizer tpcNNClusterer[GPUCA_NSECTORS];
 #endif
-
   template <int32_t I>
   GPUd() auto& getTRDTracker();
 };
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 6a60eb9edd6d0..9e9344108ccfb 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -59,6 +59,7 @@ set(SRCS
     Merger/GPUTPCGMPhysicalTrackModel.cxx
     Merger/GPUTPCGMPolynomialFieldManager.cxx
     DataTypes/GPUTRDTrack.cxx
+    DataTypes/GPUTRDRecoParam.cxx
     TRDTracking/GPUTRDTracker.cxx
     TRDTracking/GPUTRDTrackletWord.cxx
     TRDTracking/GPUTRDTrackerKernels.cxx
@@ -68,7 +69,7 @@ set(SRCS_DATATYPES DataTypes/GPUDataTypesConfig.cxx DataTypes/GPUConfigDump.cxx
 
 set(HDRS_CINT_O2 Merger/GPUTPCGMTrackParam.h Merger/GPUTPCGMMergedTrack.h Merger/GPUTPCGMSectorTrack.h Merger/GPUTPCGMBorderTrack.h TRDTracking/GPUTRDInterfaces.h)
 set(HDRS_CINT_DATATYPES DataTypes/GPUTPCGMMergedTrackHit.h)
-set(HDRS_CINT_O2_ADDITIONAL DataTypes/GPUSettings.h Definitions/GPUSettingsList.h DataTypes/GPUDataTypesIO.h DataTypes/GPUDataTypesConfig.h DataTypes/GPUDataTypesQA.h DataTypes/GPUTRDTrack.h DataTypes/CalibdEdxTrackTopologyPol.h DataTypes/CalibdEdxTrackTopologySpline.h) # Manual dependencies for ROOT dictionary generation
+set(HDRS_CINT_O2_ADDITIONAL DataTypes/GPUSettings.h Definitions/GPUSettingsList.h DataTypes/GPUDataTypesIO.h DataTypes/GPUDataTypesConfig.h DataTypes/GPUDataTypesQA.h DataTypes/GPUTRDTrack.h DataTypes/GPUTRDRecoParam.h DataTypes/CalibdEdxTrackTopologyPol.h DataTypes/CalibdEdxTrackTopologySpline.h) # Manual dependencies for ROOT dictionary generation
 
 set(SRCS_NO_CINT
     DataTypes/GPUMemorySizeScalers.cxx
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
index fd98cba1dadaa..76fa569a16824 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
@@ -95,6 +95,7 @@ class TPCFastTransform;
 struct TPCPadGainCalib;
 struct TPCZSLinkMapping;
 
+class GPUTRDRecoParam;
 class GPUTPCTrack;
 class GPUTPCHitId;
 class GPUTPCGMMergedTrack;
@@ -135,7 +136,7 @@ struct GPUCalibObjectsTemplate { // use only pointers on PODs or flat objects he
   typename S<o2::tpc::CalibdEdxContainer>::type* dEdxCalibContainer = nullptr;
   typename S<o2::base::PropagatorImpl<float>>::type* o2Propagator = nullptr;
   typename S<o2::itsmft::TopologyDictionary>::type* itsPatternDict = nullptr;
-
+  typename S<GPUTRDRecoParam>::type* trdRecoParam = nullptr;
   // NN clusterizer objects
   typename S<o2::tpc::ORTRootSerializer>::type* nnClusterizerNetworks[3] = {nullptr, nullptr, nullptr};
 };
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
new file mode 100644
index 0000000000000..70b445f7befc0
--- /dev/null
+++ b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
@@ -0,0 +1,100 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUTRDRecoParam.cxx
+/// \brief Error parameterizations and helper functions for TRD reconstruction
+/// \author Ole Schmidt
+
+#include "GPUSettings.h"
+#include "GPUTRDRecoParam.h"
+#include "GPUCommonLogger.h"
+#include "GPUCommonMath.h"
+
+using namespace o2::gpu;
+
+// error parameterizations taken from http://cds.cern.ch/record/2724259 Appendix A
+void GPUTRDRecoParam::init(float bz, const GPUSettingsRec* rec)
+{
+  float resRPhiIdeal2 = rec ? rec->trd.trkltResRPhiIdeal * rec->trd.trkltResRPhiIdeal : 1.6e-3f;
+
+  if (CAMath::Abs(CAMath::Abs(bz) - 2) < 0.1) {
+    if (bz > 0) {
+      // magnetic field +0.2 T
+      mRPhiA2 = resRPhiIdeal2;
+      mRPhiB = -1.43e-2f;
+      mRPhiC2 = 4.55e-2f;
+
+      mDyA2 = 1.225e-3f;
+      mDyB = -9.8e-3f;
+      mDyC2 = 3.88e-2f;
+
+      mAngleToDyA = -0.1f;
+      mAngleToDyB = 1.89f;
+      mAngleToDyC = -0.4f;
+    } else {
+      // magnetic field -0.2 T
+      mRPhiA2 = resRPhiIdeal2;
+      mRPhiB = 1.43e-2f;
+      mRPhiC2 = 4.55e-2f;
+
+      mDyA2 = 1.225e-3f;
+      mDyB = 9.8e-3f;
+      mDyC2 = 3.88e-2f;
+
+      mAngleToDyA = 0.1f;
+      mAngleToDyB = 1.89f;
+      mAngleToDyC = 0.4f;
+    }
+  } else if (CAMath::Abs(CAMath::Abs(bz) - 5) < 0.1) {
+    if (bz > 0) {
+      // magnetic field +0.5 T
+      mRPhiA2 = resRPhiIdeal2;
+      mRPhiB = 0.125f;
+      mRPhiC2 = 0.0961f;
+
+      mDyA2 = 1.681e-3f;
+      mDyB = 0.15f;
+      mDyC2 = 0.1849f;
+
+      mAngleToDyA = 0.13f;
+      mAngleToDyB = 2.43f;
+      mAngleToDyC = -0.58f;
+    } else {
+      // magnetic field -0.5 T
+      mRPhiA2 = resRPhiIdeal2;
+      mRPhiB = -0.14f;
+      mRPhiC2 = 0.1156f;
+
+      mDyA2 = 2.209e-3f;
+      mDyB = -0.15f;
+      mDyC2 = 0.2025f;
+
+      mAngleToDyA = -0.15f;
+      mAngleToDyB = 2.34f;
+      mAngleToDyC = 0.56f;
+    }
+  } else {
+    LOGP(warning, "No error parameterization available for Bz= {}. Keeping default value (sigma_y = const. = 1cm)", bz);
+  }
+  LOGP(info, "Loaded parameterizations for Bz={}: PhiRes:[{},{},{}] DyRes:[{},{},{}] Angle2Dy:[{},{},{}]",
+       bz, mRPhiA2, mRPhiB, mRPhiC2, mDyA2, mDyB, mDyC2, mAngleToDyA, mAngleToDyB, mAngleToDyC);
+}
+
+void GPUTRDRecoParam::recalcTrkltCov(const float tilt, const float snp, const float rowSize, float* cov) const
+{
+  float t2 = tilt * tilt;      // tan^2 (tilt)
+  float c2 = 1.f / (1.f + t2); // cos^2 (tilt)
+  float sy2 = getRPhiRes(snp);
+  float sz2 = rowSize * rowSize / 12.f;
+  cov[0] = c2 * (sy2 + t2 * sz2);
+  cov[1] = c2 * tilt * (sz2 - sy2);
+  cov[2] = c2 * (t2 * sy2 + sz2);
+}
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h
new file mode 100644
index 0000000000000..ad0285487d3c3
--- /dev/null
+++ b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h
@@ -0,0 +1,84 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file RecoParam.h
+/// \brief Error parameterizations and helper functions for TRD reconstruction
+/// \author Ole Schmidt
+
+#ifndef O2_GPU_TRD_RECOPARAM_H
+#define O2_GPU_TRD_RECOPARAM_H
+
+#include "GPUCommonDef.h"
+#include "GPUCommonRtypes.h"
+#include "GPUCommonArray.h"
+
+namespace o2
+{
+namespace gpu
+{
+struct GPUSettingsRec;
+
+class GPUTRDRecoParam
+{
+ public:
+  GPUTRDRecoParam() = default;
+  GPUTRDRecoParam(const GPUTRDRecoParam&) = default;
+  ~GPUTRDRecoParam() = default;
+
+  /// Load parameterization for given magnetic field
+  void init(float bz, const GPUSettingsRec* rec = nullptr);
+
+#if !defined(GPUCA_GPUCODE_DEVICE)
+  /// Recalculate tracklet covariance based on phi angle of related track
+  GPUd() void recalcTrkltCov(const float tilt, const float snp, const float rowSize, std::array<float, 3>& cov) const
+  {
+    recalcTrkltCov(tilt, snp, rowSize, cov.data());
+  }
+#endif
+  GPUd() void recalcTrkltCov(const float tilt, const float snp, const float rowSize, float* cov) const;
+
+  /// Get tracklet r-phi resolution for given phi angle
+  /// Resolution depends on the track angle sin(phi) = snp and is approximated by the formula
+  /// sigma_y(snp) = sqrt(a^2 + c^2 * (snp - b)^2)
+  /// more details are given in http://cds.cern.ch/record/2724259 in section 5.3.3
+  /// \param phi angle of related track
+  /// \return sigma_y^2 of tracklet
+  GPUd() float getRPhiRes(float snp) const { return (mRPhiA2 + mRPhiC2 * (snp - mRPhiB) * (snp - mRPhiB)); }
+  GPUd() float getDyRes(float snp) const { return mDyA2 + mDyC2 * (snp - mDyB) * (snp - mDyB); }                       // // a^2 + c^2 * (snp - b)^2
+  GPUd() float convertAngleToDy(float snp) const { return mAngleToDyA + mAngleToDyB * snp + mAngleToDyC * snp * snp; } // a + b*snp + c*snp^2 is more accurate than sin(phi) = (dy / xDrift) / sqrt(1+(dy/xDrift)^2)
+
+  /// Get tracklet z correction coefficient for track-eta based corraction
+  GPUd() float getZCorrCoeffNRC() const { return mZCorrCoefNRC; }
+
+ private:
+  // tracklet error parameterization depends on the magnetic field
+  // rphi
+  float mRPhiA2{1.f}; ///< parameterization for tracklet position resolution
+  float mRPhiB{0.f};  ///< parameterization for tracklet position resolution
+  float mRPhiC2{0.f}; ///< parameterization for tracklet position resolution
+  // angle
+  float mDyA2{1.225e-3f}; ///< parameterization for tracklet angular resolution
+  float mDyB{0.f};        ///< parameterization for tracklet angular resolution
+  float mDyC2{0.f};       ///< parameterization for tracklet angular resolution
+  // angle to Dy
+  float mAngleToDyA; // parameterization for conversion track angle -> tracklet deflection
+  float mAngleToDyB; // parameterization for conversion track angle -> tracklet deflection
+  float mAngleToDyC; // parameterization for conversion track angle -> tracklet deflection
+
+  float mZCorrCoefNRC{1.4f}; ///< tracklet z-position depends linearly on track dip angle
+
+  ClassDefNV(GPUTRDRecoParam, 2);
+};
+
+} // namespace gpu
+} // namespace o2
+
+#endif // O2_GPU_TRD_RECOPARAM_H
diff --git a/GPU/GPUTracking/GPUTrackingLinkDef_O2.h b/GPU/GPUTracking/GPUTrackingLinkDef_O2.h
index 8e99514a817c5..46ced1e0481f9 100644
--- a/GPU/GPUTracking/GPUTrackingLinkDef_O2.h
+++ b/GPU/GPUTracking/GPUTrackingLinkDef_O2.h
@@ -27,6 +27,7 @@
 #pragma link C++ struct o2::gpu::GPUTPCGMSectorTrack::sectorTrackParam + ;
 #pragma link C++ class o2::gpu::trackInterface < o2::gpu::GPUTPCGMTrackParam> + ;
 #pragma link C++ class o2::gpu::GPUTRDTrack_t < o2::gpu::trackInterface < o2::gpu::GPUTPCGMTrackParam>> + ;
+#pragma link C++ class o2::gpu::GPUTRDRecoParam + ;
 #pragma link C++ class o2::gpu::gputpcgmmergertypes::GPUTPCOuterParam + ;
 #pragma link C++ class o2::gpu::gputpcgmmergertypes::InterpolationErrorHit + ;
 
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 5c951053e155b..7216de0535329 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -34,6 +34,7 @@
 #include "GPUTRDTracker.h"
 #include "AliHLTTPCRawCluster.h"
 #include "GPUTRDTrackletLabels.h"
+#include "GPUTRDRecoParam.h"
 #include "display/GPUDisplayInterface.h"
 #include "GPUQA.h"
 #include "GPULogging.h"
@@ -435,6 +436,9 @@ void GPUChainTracking::UpdateGPUCalibObjects(int32_t stream, const GPUCalibObjec
     memcpy((void*)mFlatObjectsShadow.mCalibObjects.trdGeometry, (const void*)processors()->calibObjects.trdGeometry, sizeof(*processors()->calibObjects.trdGeometry));
     mFlatObjectsShadow.mCalibObjects.trdGeometry->clearInternalBufferPtr();
   }
+  if (processors()->calibObjects.trdRecoParam && (ptrMask == nullptr || ptrMask->trdRecoParam)) {
+    memcpy((void*)mFlatObjectsShadow.mCalibObjects.trdRecoParam, (const void*)processors()->calibObjects.trdRecoParam, sizeof(*processors()->calibObjects.trdRecoParam));
+  }
   if (processors()->calibObjects.tpcPadGain && (ptrMask == nullptr || ptrMask->tpcPadGain)) {
     memcpy((void*)mFlatObjectsShadow.mCalibObjects.tpcPadGain, (const void*)processors()->calibObjects.tpcPadGain, sizeof(*processors()->calibObjects.tpcPadGain));
   }
@@ -536,6 +540,9 @@ void* GPUChainTracking::GPUTrackingFlatObjects::SetPointersFlatObjects(void* mem
   if (mChainTracking->processors()->calibObjects.trdGeometry) {
     computePointerWithAlignment(mem, mCalibObjects.trdGeometry, 1);
   }
+  if (mChainTracking->processors()->calibObjects.trdRecoParam) {
+    computePointerWithAlignment(mem, mCalibObjects.trdRecoParam, 1);
+  }
   computePointerWithAlignment(mem, mCalibObjects.o2Propagator, 1);
   if (!mChainTracking->processors()->calibObjects.o2Propagator) {
     mCalibObjects.o2Propagator = nullptr; // Always reserve memory for o2::Propagator, since it may be propagatred only during run() not during init().
@@ -602,6 +609,12 @@ void GPUChainTracking::SetTRDGeometry(std::unique_ptr<o2::trd::GeometryFlat>&& g
   processors()->calibObjects.trdGeometry = mTRDGeometryU.get();
 }
 
+void GPUChainTracking::SetTRDRecoParam(std::unique_ptr<GPUTRDRecoParam>&& par)
+{
+  mTRDRecoParamU = std::move(par);
+  processors()->calibObjects.trdRecoParam = mTRDRecoParamU.get();
+}
+
 int32_t GPUChainTracking::DoQueuedUpdates(int32_t stream, bool updateSlave)
 {
   int32_t retVal = 0;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 2dd1ece856ecf..fd75136f51d76 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -59,6 +59,7 @@ class GPUDisplayInterface;
 class GPUQA;
 class GPUTPCClusterStatistics;
 class GPUTRDGeometry;
+class GPUTRDRecoParam;
 class TPCFastTransform;
 class GPUTrackingInputProvider;
 struct GPUChainTrackingFinalContext;
@@ -178,13 +179,16 @@ class GPUChainTracking : public GPUChain
   const o2::tpc::CalibdEdxContainer* GetdEdxCalibContainer() const;
   const o2::base::MatLayerCylSet* GetMatLUT() const;
   const GPUTRDGeometry* GetTRDGeometry() const;
+  const GPUTRDRecoParam* GetTRDRecoParam() const;
   const o2::base::Propagator* GetO2Propagator() const;
   const o2::base::Propagator* GetDeviceO2Propagator();
   void SetTPCFastTransform(std::unique_ptr<TPCFastTransform>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper);
   void SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut);
   void SetTRDGeometry(std::unique_ptr<o2::trd::GeometryFlat>&& geo);
+  void SetTRDRecoParam(std::unique_ptr<GPUTRDRecoParam>&& par);
   void SetMatLUT(const o2::base::MatLayerCylSet* lut);
   void SetTRDGeometry(const o2::trd::GeometryFlat* geo);
+  void SetTRDRecoParam(const GPUTRDRecoParam* par);
   void SetO2Propagator(const o2::base::Propagator* prop);
   void SetCalibObjects(const GPUCalibObjectsConst& obj);
   void SetCalibObjects(const GPUCalibObjects& obj);
@@ -267,6 +271,7 @@ class GPUChainTracking : public GPUChain
   std::unique_ptr<o2::tpc::CalibdEdxContainer> mdEdxCalibContainerU; // TPC dEdx calibration container
   std::unique_ptr<o2::base::MatLayerCylSet> mMatLUTU;                // Material Lookup Table
   std::unique_ptr<o2::trd::GeometryFlat> mTRDGeometryU;              // TRD Geometry
+  std::unique_ptr<GPUTRDRecoParam> mTRDRecoParamU;                   // TRD RecoParam
 
   // Ptrs to internal buffers
   std::unique_ptr<o2::tpc::ClusterNativeAccess> mClusterNativeAccess, mClusterNativeAccessReduced;
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc b/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
index 5b72a8f23c242..b3b1773ec664e 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
+++ b/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
@@ -26,9 +26,11 @@ inline const TPCZSLinkMapping* GPUChainTracking::GetTPCZSLinkMapping() const { r
 inline const o2::tpc::CalibdEdxContainer* GPUChainTracking::GetdEdxCalibContainer() const { return processors()->calibObjects.dEdxCalibContainer; }
 inline const o2::base::MatLayerCylSet* GPUChainTracking::GetMatLUT() const { return processors()->calibObjects.matLUT; }
 inline const GPUTRDGeometry* GPUChainTracking::GetTRDGeometry() const { return (GPUTRDGeometry*)processors()->calibObjects.trdGeometry; }
+inline const GPUTRDRecoParam* GPUChainTracking::GetTRDRecoParam() const { return processors()->calibObjects.trdRecoParam; }
 inline const o2::base::Propagator* GPUChainTracking::GetO2Propagator() const { return processors()->calibObjects.o2Propagator; }
 inline void GPUChainTracking::SetMatLUT(const o2::base::MatLayerCylSet* lut) { processors()->calibObjects.matLUT = lut; }
 inline void GPUChainTracking::SetTRDGeometry(const o2::trd::GeometryFlat* geo) { processors()->calibObjects.trdGeometry = geo; }
+inline void GPUChainTracking::SetTRDRecoParam(const GPUTRDRecoParam* par) { processors()->calibObjects.trdRecoParam = par; }
 inline void GPUChainTracking::SetCalibObjects(const GPUCalibObjectsConst& obj) { processors()->calibObjects = obj; }
 inline void GPUChainTracking::SetCalibObjects(const GPUCalibObjects& obj) { memcpy((void*)&processors()->calibObjects, (const void*)&obj, sizeof(obj)); }
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index dd11e9989f684..6f24415564a8c 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -20,6 +20,7 @@
 #include "GPUTPCTrack.h"
 #include "GPUTPCHitId.h"
 #include "GPUTRDTrackletWord.h"
+#include "GPUTRDRecoParam.h"
 #include "AliHLTTPCClusterMCData.h"
 #include "GPUTPCMCInfo.h"
 #include "GPUTRDTrack.h"
@@ -337,6 +338,11 @@ void GPUChainTracking::DumpSettings(const char* dir)
     f += "trdgeometry.dump";
     DumpStructToFile(processors()->calibObjects.trdGeometry, f.c_str());
   }
+  if (processors()->calibObjects.trdRecoParam != nullptr) {
+    f = dir;
+    f += "trdrecoparam.dump";
+    DumpStructToFile(processors()->calibObjects.trdRecoParam, f.c_str());
+  }
 }
 
 void GPUChainTracking::ReadSettings(const char* dir)
@@ -382,4 +388,8 @@ void GPUChainTracking::ReadSettings(const char* dir)
   f += "trdgeometry.dump";
   mTRDGeometryU = ReadStructFromFile<o2::trd::GeometryFlat>(f.c_str());
   processors()->calibObjects.trdGeometry = mTRDGeometryU.get();
+  f = dir;
+  f += "trdrecoparam.dump";
+  mTRDRecoParamU = ReadStructFromFile<GPUTRDRecoParam>(f.c_str());
+  processors()->calibObjects.trdRecoParam = mTRDRecoParamU.get();
 }
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
index 2f754d2416bc1..d5d400e30df53 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
@@ -23,6 +23,7 @@
 #include "GPUCommonMath.h"
 #include "GPUCommonAlgorithm.h"
 #include "GPUConstantMem.h"
+#include "GPUTRDRecoParam.h"
 
 using namespace o2::gpu;
 
@@ -92,7 +93,7 @@ void* GPUTRDTracker_t<TRDTRK, PROP>::SetPointersTracks(void* base)
 }
 
 template <class TRDTRK, class PROP>
-GPUTRDTracker_t<TRDTRK, PROP>::GPUTRDTracker_t() : mR(nullptr), mIsInitialized(false), mGenerateSpacePoints(false), mProcessPerTimeFrame(false), mNAngleHistogramBins(25), mAngleHistogramRange(50), mMemoryPermanent(-1), mMemoryTracklets(-1), mMemoryTracks(-1), mNMaxCollisions(0), mNMaxTracks(0), mNMaxSpacePoints(0), mTracks(nullptr), mTrackAttribs(nullptr), mNCandidates(1), mNTracks(0), mNEvents(0), mMaxBackendThreads(100), mTrackletIndexArray(nullptr), mHypothesis(nullptr), mCandidates(nullptr), mSpacePoints(nullptr), mGeo(nullptr), mRPhiA2(0), mRPhiB(0), mRPhiC2(0), mDyA2(0), mDyB(0), mDyC2(0), mAngleToDyA(0), mAngleToDyB(0), mAngleToDyC(0), mDebugOutput(false), mMaxEta(0.84f), mRoadZ(18.f), mZCorrCoefNRC(1.4f), mTPCVdrift(2.58f), mTPCTDriftOffset(0.f), mDebug(new GPUTRDTrackerDebug<TRDTRK>())
+GPUTRDTracker_t<TRDTRK, PROP>::GPUTRDTracker_t() : mR(nullptr), mIsInitialized(false), mGenerateSpacePoints(false), mProcessPerTimeFrame(false), mNAngleHistogramBins(25), mAngleHistogramRange(50), mMemoryPermanent(-1), mMemoryTracklets(-1), mMemoryTracks(-1), mNMaxCollisions(0), mNMaxTracks(0), mNMaxSpacePoints(0), mTracks(nullptr), mTrackAttribs(nullptr), mNCandidates(1), mNTracks(0), mNEvents(0), mMaxBackendThreads(100), mTrackletIndexArray(nullptr), mHypothesis(nullptr), mCandidates(nullptr), mSpacePoints(nullptr), mGeo(nullptr), mRecoParam(nullptr), mDebugOutput(false), mMaxEta(0.84f), mRoadZ(18.f), mZCorrCoefNRC(1.4f), mTPCVdrift(2.58f), mTPCTDriftOffset(0.f), mDebug(new GPUTRDTrackerDebug<TRDTRK>())
 {
   //--------------------------------------------------------------------
   // Default constructor
@@ -114,9 +115,8 @@ void GPUTRDTracker_t<TRDTRK, PROP>::InitializeProcessor()
   //--------------------------------------------------------------------
   // Initialise tracker
   //--------------------------------------------------------------------
-
+  mRecoParam = GetConstantMem()->calibObjects.trdRecoParam;
   UpdateGeometry();
-
   mDebug->ExpandVectors();
   mIsInitialized = true;
 }
@@ -131,42 +131,6 @@ void GPUTRDTracker_t<TRDTRK, PROP>::UpdateGeometry()
   if (!mGeo) {
     GPUFatal("TRD geometry must be provided externally");
   }
-  float Bz = Param().bzkG;
-  float resRPhiIdeal2 = Param().rec.trd.trkltResRPhiIdeal * Param().rec.trd.trkltResRPhiIdeal;
-  GPUInfo("Initializing with B-field: %f kG", Bz);
-  if (CAMath::Abs(CAMath::Abs(Bz) - 2) < 0.1f) {
-    // magnetic field +-0.2 T
-    if (Bz > 0) {
-      GPUInfo("Loading error parameterization for Bz = +2 kG");
-      mRPhiA2 = resRPhiIdeal2, mRPhiB = -1.43e-2f, mRPhiC2 = 4.55e-2f;
-      mDyA2 = 1.225e-3f, mDyB = -9.8e-3f, mDyC2 = 3.88e-2f;
-      mAngleToDyA = -0.1f, mAngleToDyB = 1.89f, mAngleToDyC = -0.4f;
-    } else {
-      GPUInfo("Loading error parameterization for Bz = -2 kG");
-      mRPhiA2 = resRPhiIdeal2, mRPhiB = 1.43e-2f, mRPhiC2 = 4.55e-2f;
-      mDyA2 = 1.225e-3f, mDyB = 9.8e-3f, mDyC2 = 3.88e-2f;
-      mAngleToDyA = 0.1f, mAngleToDyB = 1.89f, mAngleToDyC = 0.4f;
-    }
-  } else if (CAMath::Abs(CAMath::Abs(Bz) - 5) < 0.1f) {
-    // magnetic field +-0.5 T
-    if (Bz > 0) {
-      GPUInfo("Loading error parameterization for Bz = +5 kG");
-      mRPhiA2 = resRPhiIdeal2, mRPhiB = 0.125f, mRPhiC2 = 0.0961f;
-      mDyA2 = 1.681e-3f, mDyB = 0.15f, mDyC2 = 0.1849f;
-      mAngleToDyA = 0.13f, mAngleToDyB = 2.43f, mAngleToDyC = -0.58f;
-    } else {
-      GPUInfo("Loading error parameterization for Bz = -5 kG");
-      mRPhiA2 = resRPhiIdeal2, mRPhiB = -0.14f, mRPhiC2 = 0.1156f;
-      mDyA2 = 2.209e-3f, mDyB = -0.15f, mDyC2 = 0.2025f;
-      mAngleToDyA = -0.15f, mAngleToDyB = 2.34f, mAngleToDyC = 0.56f;
-    }
-  } else {
-    // magnetic field 0 T or another value which is not covered by the error parameterizations
-    // using default values instead
-    GPUWarning("No error parameterization available for Bz = %.2f kG. Keeping default value (sigma_y = const. = 1cm)", Bz);
-    mRPhiA2 = 1.f;
-  }
-
   // obtain average radius of TRD chambers
   float x0[kNLayers] = {300.2f, 312.8f, 325.4f, 338.0f, 350.6f, 363.2f}; // used as default value in case no transformation matrix can be obtained
   auto* matrix = mGeo->GetClusterMatrix(0);
@@ -967,7 +931,7 @@ GPUd() void GPUTRDTracker_t<TRDTRK, PROP>::RecalcTrkltCov(const float tilt, cons
   //--------------------------------------------------------------------
   float t2 = tilt * tilt;      // tan^2 (tilt)
   float c2 = 1.f / (1.f + t2); // cos^2 (tilt)
-  float sy2 = GetRPhiRes(snp);
+  float sy2 = mRecoParam->getRPhiRes(snp);
   float sz2 = rowSize * rowSize / 12.f;
   cov[0] = c2 * (sy2 + t2 * sz2);
   cov[1] = c2 * tilt * (sz2 - sy2);
@@ -977,8 +941,8 @@ GPUd() void GPUTRDTracker_t<TRDTRK, PROP>::RecalcTrkltCov(const float tilt, cons
 template <class TRDTRK, class PROP>
 GPUd() float GPUTRDTracker_t<TRDTRK, PROP>::GetAngularPull(float dYtracklet, float snp) const
 {
-  float dYtrack = ConvertAngleToDy(snp);
-  float dYresolution = GetAngularResolution(snp);
+  float dYtrack = mRecoParam->convertAngleToDy(snp);
+  float dYresolution = mRecoParam->getDyRes(snp);
   if (dYresolution < 1e-6f) {
     return 999.f;
   }
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
index f8fa0342ee62d..5d7530ccecc11 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
@@ -38,6 +38,7 @@ class GPUTRDGeometry;
 class GPUChainTracking;
 template <class T>
 class GPUTRDTrackerDebug;
+class GPUTRDRecoParam;
 
 //-------------------------------------------------------------------------
 template <class TRDTRK, class PROP>
@@ -114,9 +115,6 @@ class GPUTRDTracker_t : public GPUProcessor
   GPUd() bool AdjustSector(PROP* prop, TRDTRK* t) const;
   GPUd() int32_t GetSector(float alpha) const;
   GPUd() float GetAlphaOfSector(const int32_t sec) const;
-  GPUd() float GetRPhiRes(float snp) const { return (mRPhiA2 + mRPhiC2 * (snp - mRPhiB) * (snp - mRPhiB)); }           // parametrization obtained from track-tracklet residuals:
-  GPUd() float GetAngularResolution(float snp) const { return mDyA2 + mDyC2 * (snp - mDyB) * (snp - mDyB); }           // a^2 + c^2 * (snp - b)^2
-  GPUd() float ConvertAngleToDy(float snp) const { return mAngleToDyA + mAngleToDyB * snp + mAngleToDyC * snp * snp; } // a + b*snp + c*snp^2 is more accurate than sin(phi) = (dy / xDrift) / sqrt(1+(dy/xDrift)^2)
   GPUd() float GetAngularPull(float dYtracklet, float snp) const;
   GPUd() void RecalcTrkltCov(const float tilt, const float snp, const float rowSize, float (&cov)[3]);
   GPUd() void FindChambersInRoad(const TRDTRK* t, const float roadY, const float roadZ, const int32_t iLayer, int32_t* det, const float zMax, const float alpha, const float zShiftTrk) const;
@@ -174,16 +172,7 @@ class GPUTRDTracker_t : public GPUProcessor
   TRDTRK* mCandidates;            // array of tracks for multiple hypothesis tracking
   GPUTRDSpacePoint* mSpacePoints; // array with tracklet coordinates in global tracking frame
   const GPUTRDGeometry* mGeo;     // TRD geometry
-  /// ---- error parametrization depending on magnetic field ----
-  float mRPhiA2;     // parameterization for tracklet position resolution
-  float mRPhiB;      // parameterization for tracklet position resolution
-  float mRPhiC2;     // parameterization for tracklet position resolution
-  float mDyA2;       // parameterization for tracklet angular resolution
-  float mDyB;        // parameterization for tracklet angular resolution
-  float mDyC2;       // parameterization for tracklet angular resolution
-  float mAngleToDyA; // parameterization for conversion track angle -> tracklet deflection
-  float mAngleToDyB; // parameterization for conversion track angle -> tracklet deflection
-  float mAngleToDyC; // parameterization for conversion track angle -> tracklet deflection
+  const GPUTRDRecoParam* mRecoParam; // TRD RecoParam
   /// ---- end error parametrization ----
   bool mDebugOutput;                                  // store debug output
   static constexpr const float sRadialOffset = -0.1f; // due to (possible) mis-calibration of t0 -> will become obsolete when tracklet conversion is done outside of the tracker
diff --git a/GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C b/GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C
index acfcf92370b00..e4b37500e1a60 100644
--- a/GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C
+++ b/GPU/GPUTracking/TRDTracking/macros/run_trd_tracker.C
@@ -24,6 +24,7 @@
 #include "GPUTRDTrackletWord.h"
 #include "GPUTRDInterfaces.h"
 #include "GPUTRDGeometry.h"
+#include "GPUTRDRecoParam.h"
 
 // O2 header
 #include "CommonUtils/NameConf.h"
@@ -58,7 +59,7 @@ void run_trd_tracker(std::string path = "./",
   geo->createPadPlaneArray();
   geo->createClusterMatrixArray();
   const o2::trd::GeometryFlat geoFlat(*geo);
-
+  o2::gpu::GPUTRDRecoParam trdRecoParam;
   //-------- init GPU reconstruction --------//
   // different settings are defined in GPUSettingsList.h
   GPUSettingsGRP cfgGRP;                     // defaults should be ok
@@ -85,6 +86,7 @@ void run_trd_tracker(std::string path = "./",
 
   rec->RegisterGPUProcessor(tracker, false);
   chainTracking->SetTRDGeometry(&geoFlat);
+  chainTracking->SetTRDRecoParam(&trdRecoParam);
   if (rec->Init()) {
     printf("ERROR: GPUReconstruction not initialized\n");
   }
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index d610269abca81..8dfbdaff7272f 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -85,6 +85,7 @@ struct TPCPadGainCalib;
 struct TPCZSLinkMapping;
 struct GPUSettingsO2;
 struct GPUSettingsProcessingNNclusterizer;
+class GPUTRDRecoParam;
 class GPUO2InterfaceQA;
 struct GPUTrackingInOutPointers;
 struct GPUTrackingInOutZS;
@@ -212,6 +213,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   std::unique_ptr<TPCZSLinkMapping> mTPCZSLinkMapping;
   std::unique_ptr<o2::tpc::VDriftHelper> mTPCVDriftHelper;
   std::unique_ptr<o2::trd::GeometryFlat> mTRDGeometry;
+  std::unique_ptr<GPUTRDRecoParam> mTRDRecoParam;
   std::unique_ptr<GPUO2InterfaceConfiguration> mConfig;
   std::unique_ptr<GPUSettingsO2> mConfParam;
   std::unique_ptr<TStopwatch> mTimer;
@@ -245,6 +247,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
   bool mMatLUTCreated = false;
   bool mITSGeometryCreated = false;
   bool mTRDGeometryCreated = false;
+  bool mTRDRecoParamCreated = false;
   bool mPropagatorInstanceCreated = false;
   int32_t mTPCCutAtTimeBin = -1;
 };
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 7b1db436dbf7e..a8f95841a4dc9 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -73,6 +73,7 @@
 #include "DataFormatsTRD/RecoInputContainer.h"
 #include "TRDBase/Geometry.h"
 #include "TRDBase/GeometryFlat.h"
+#include "GPUTRDRecoParam.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "CommonUtils/DebugStreamer.h"
 #include "GPUReconstructionConvert.h"
@@ -273,6 +274,9 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     if (mSpecConfig.readTRDtracklets) {
       mTRDGeometry = std::make_unique<o2::trd::GeometryFlat>();
       mConfig->configCalib.trdGeometry = mTRDGeometry.get();
+
+      mTRDRecoParam = std::make_unique<GPUTRDRecoParam>();
+      mConfig->configCalib.trdRecoParam = mTRDRecoParam.get();
     }
 
     mConfig->configProcessing.willProvideO2PropagatorLate = true;
@@ -1059,14 +1063,21 @@ void GPURecoWorkflowSpec::doCalibUpdates(o2::framework::ProcessingContext& pc, c
       }
       mMatLUTCreated = true;
     }
-    if (mSpecConfig.readTRDtracklets && !mTRDGeometryCreated) {
-      auto gm = o2::trd::Geometry::instance();
-      gm->createPadPlaneArray();
-      gm->createClusterMatrixArray();
-      mTRDGeometry = std::make_unique<o2::trd::GeometryFlat>(*gm);
-      newCalibObjects.trdGeometry = mConfig->configCalib.trdGeometry = mTRDGeometry.get();
-      LOG(info) << "Loaded TRD geometry";
-      mTRDGeometryCreated = true;
+    if (mSpecConfig.readTRDtracklets) {
+      if (!mTRDGeometryCreated) {
+        auto gm = o2::trd::Geometry::instance();
+        gm->createPadPlaneArray();
+        gm->createClusterMatrixArray();
+        mTRDGeometry = std::make_unique<o2::trd::GeometryFlat>(*gm);
+        newCalibObjects.trdGeometry = mConfig->configCalib.trdGeometry = mTRDGeometry.get();
+        LOG(info) << "Loaded TRD geometry";
+        mTRDGeometryCreated = true;
+      }
+      if (!mTRDRecoParamCreated) {
+        mTRDRecoParam = std::make_unique<GPUTRDRecoParam>();
+        newCalibObjects.trdRecoParam = mConfig->configCalib.trdRecoParam = mTRDRecoParam.get();
+        mTRDRecoParamCreated = true;
+      }
     }
   }
   needCalibUpdate = fetchCalibsCCDBTPC(pc, newCalibObjects, oldCalibObjects) || needCalibUpdate;

From 8e1f22798d5e2ccfd03ace4ea07c45a18845e3e2 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 3 Feb 2026 10:48:58 +0100
Subject: [PATCH 1262/1764] Disable tests for reverted exceptions (#15011)

---
 Framework/Core/test/test_TypeToTaskName.cxx | 60 ++++++++++-----------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/Framework/Core/test/test_TypeToTaskName.cxx b/Framework/Core/test/test_TypeToTaskName.cxx
index b7b440b13ecfd..af51bc04613f5 100644
--- a/Framework/Core/test/test_TypeToTaskName.cxx
+++ b/Framework/Core/test/test_TypeToTaskName.cxx
@@ -18,48 +18,48 @@ using namespace o2::framework;
 TEST_CASE("TypeIdHelpers_BasicConversion")
 {
   // Basic CamelCase to snake-case conversion
-  REQUIRE((type_to_task_name(std::string_view("SimpleTask")) == "simple-task"));
-  REQUIRE((type_to_task_name(std::string_view("MyTask")) == "my-task"));
-  REQUIRE((type_to_task_name(std::string_view("Task")) == "task"));
+//  REQUIRE((type_to_task_name(std::string_view("SimpleTask")) == "simple-task"));
+//  REQUIRE((type_to_task_name(std::string_view("MyTask")) == "my-task"));
+//  REQUIRE((type_to_task_name(std::string_view("Task")) == "task"));
 }
 
 TEST_CASE("TypeIdHelpers_AbbreviationConsolidation")
 {
   // Test ALICE detector abbreviations
-  REQUIRE(type_to_task_name(std::string_view("ITSQA")) == "its-qa");
-  REQUIRE(type_to_task_name(std::string_view("TPCQCTask")) == "tpc-qc-task");
+//  REQUIRE(type_to_task_name(std::string_view("ITSQA")) == "its-qa");
+//  REQUIRE(type_to_task_name(std::string_view("TPCQCTask")) == "tpc-qc-task");
   REQUIRE(type_to_task_name(std::string_view("EMCALQATask")) == "emcal-qa-task");
-  REQUIRE(type_to_task_name(std::string_view("HMPIDTask")) == "hmpid-task");
-  REQUIRE(type_to_task_name(std::string_view("ITSTPCTask")) == "its-tpc-task");
-  REQUIRE(type_to_task_name(std::string_view("QCFV0Task")) == "qc-fv0-task");
+//  REQUIRE(type_to_task_name(std::string_view("HMPIDTask")) == "hmpid-task");
+// REQUIRE(type_to_task_name(std::string_view("ITSTPCTask")) == "its-tpc-task");
+// REQUIRE(type_to_task_name(std::string_view("QCFV0Task")) == "qc-fv0-task");
 }
 
-TEST_CASE("TypeIdHelpers_QualityControlAbbreviations")
-{
-  // Test quality control abbreviations
-  REQUIRE(type_to_task_name(std::string_view("QATask")) == "qa-task");
-  REQUIRE(type_to_task_name(std::string_view("QCTask")) == "qc-task");
-  REQUIRE(type_to_task_name(std::string_view("QCDAnalysis")) == "qcd-analysis");
-}
+//TEST_CASE("TypeIdHelpers_QualityControlAbbreviations")
+//{
+//  // Test quality control abbreviations
+//  REQUIRE(type_to_task_name(std::string_view("QATask")) == "qa-task");
+//  REQUIRE(type_to_task_name(std::string_view("QCTask")) == "qc-task");
+//  REQUIRE(type_to_task_name(std::string_view("QCDAnalysis")) == "qcd-analysis");
+//}
 
 TEST_CASE("TypeIdHelpers_ComplexNames")
 {
   // Test complex combinations
-  REQUIRE(type_to_task_name(std::string_view("ITSQAAnalysisTask")) == "its-qa-analysis-task");
+//  REQUIRE(type_to_task_name(std::string_view("ITSQAAnalysisTask")) == "its-qa-analysis-task");
   REQUIRE(type_to_task_name(std::string_view("TPCEMCQCTask")) == "tpc-emc-qc-task");
-  REQUIRE(type_to_task_name(std::string_view("MyITSTask")) == "my-its-task");
+//  REQUIRE(type_to_task_name(std::string_view("MyITSTask")) == "my-its-task");
 }
 
-TEST_CASE("TypeIdHelpers_EdgeCases")
-{
-  // Single character
-  REQUIRE(type_to_task_name(std::string_view("A")) == "a");
-
-  // All uppercase. BC is Bunch Crossing!
-  //
-  REQUIRE(type_to_task_name(std::string_view("ABC")) == "a-bc");
-  REQUIRE(type_to_task_name(std::string_view("BC")) == "bc");
-
-  // Mixed with numbers (numbers are not uppercase, so no hyphens before them)
-  REQUIRE(type_to_task_name(std::string_view("Task123")) == "task123");
-}
+//TEST_CASE("TypeIdHelpers_EdgeCases")
+//{
+//  // Single character
+//  REQUIRE(type_to_task_name(std::string_view("A")) == "a");
+//
+//  // All uppercase. BC is Bunch Crossing!
+//  //
+//  REQUIRE(type_to_task_name(std::string_view("ABC")) == "a-bc");
+//  REQUIRE(type_to_task_name(std::string_view("BC")) == "bc");
+//
+//  // Mixed with numbers (numbers are not uppercase, so no hyphens before them)
+//  REQUIRE(type_to_task_name(std::string_view("Task123")) == "task123");
+//}

From ee2b995e2450fb5b6a5314b5eca18969e5d260c6 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 3 Feb 2026 14:01:01 +0100
Subject: [PATCH 1263/1764] Brown paperbag issue with reverted feature.
 (#15012)

---
 Framework/Core/test/test_TypeToTaskName.cxx | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Framework/Core/test/test_TypeToTaskName.cxx b/Framework/Core/test/test_TypeToTaskName.cxx
index af51bc04613f5..cd5a359db0446 100644
--- a/Framework/Core/test/test_TypeToTaskName.cxx
+++ b/Framework/Core/test/test_TypeToTaskName.cxx
@@ -25,10 +25,10 @@ TEST_CASE("TypeIdHelpers_BasicConversion")
 
 TEST_CASE("TypeIdHelpers_AbbreviationConsolidation")
 {
-  // Test ALICE detector abbreviations
+// Test ALICE detector abbreviations
 //  REQUIRE(type_to_task_name(std::string_view("ITSQA")) == "its-qa");
 //  REQUIRE(type_to_task_name(std::string_view("TPCQCTask")) == "tpc-qc-task");
-  REQUIRE(type_to_task_name(std::string_view("EMCALQATask")) == "emcal-qa-task");
+//  REQUIRE(type_to_task_name(std::string_view("EMCALQATask")) == "emcal-qa-task");
 //  REQUIRE(type_to_task_name(std::string_view("HMPIDTask")) == "hmpid-task");
 // REQUIRE(type_to_task_name(std::string_view("ITSTPCTask")) == "its-tpc-task");
 // REQUIRE(type_to_task_name(std::string_view("QCFV0Task")) == "qc-fv0-task");
@@ -42,13 +42,13 @@ TEST_CASE("TypeIdHelpers_AbbreviationConsolidation")
 //  REQUIRE(type_to_task_name(std::string_view("QCDAnalysis")) == "qcd-analysis");
 //}
 
-TEST_CASE("TypeIdHelpers_ComplexNames")
-{
-  // Test complex combinations
+//TEST_CASE("TypeIdHelpers_ComplexNames")
+//{
+// Test complex combinations
 //  REQUIRE(type_to_task_name(std::string_view("ITSQAAnalysisTask")) == "its-qa-analysis-task");
-  REQUIRE(type_to_task_name(std::string_view("TPCEMCQCTask")) == "tpc-emc-qc-task");
+//  REQUIRE(type_to_task_name(std::string_view("TPCEMCQCTask")) == "tpc-emc-qc-task");
 //  REQUIRE(type_to_task_name(std::string_view("MyITSTask")) == "my-its-task");
-}
+//}
 
 //TEST_CASE("TypeIdHelpers_EdgeCases")
 //{

From ff39f95db1067234eac4ab9dd3681ecba15949bd Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Tue, 3 Feb 2026 15:33:50 +0100
Subject: [PATCH 1264/1764] Fix and improve TPC Loopers implementation

---
 Generators/include/Generators/Generator.h  | 12 +++++------
 Generators/include/Generators/TPCLoopers.h |  2 --
 Generators/src/Generator.cxx               | 23 ++++++++++++++++++++--
 3 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/Generators/include/Generators/Generator.h b/Generators/include/Generators/Generator.h
index 3484601aa42bb..f413aeccfa3ab 100644
--- a/Generators/include/Generators/Generator.h
+++ b/Generators/include/Generators/Generator.h
@@ -17,10 +17,6 @@
 #include "FairGenerator.h"
 #include "TParticle.h"
 #include "Generators/Trigger.h"
-#ifdef GENERATORS_WITH_TPCLOOPERS
-#include "Generators/TPCLoopers.h"
-#include "Generators/TPCLoopersParam.h"
-#endif
 #include <functional>
 #include <vector>
 #include <unordered_map>
@@ -38,6 +34,8 @@ namespace o2
 namespace eventgen
 {
 
+class GenTPCLoopers; // Forward declaration
+
 /*****************************************************************/
 /*****************************************************************/
 
@@ -60,7 +58,7 @@ class Generator : public FairGenerator
   /** constructor **/
   Generator(const Char_t* name, const Char_t* title = "ALICEo2 Generator");
   /** destructor **/
-  ~Generator() override = default;
+  ~Generator() override;
 
   /** Initialize the generator if needed **/
   Bool_t Init() override;
@@ -169,9 +167,9 @@ class Generator : public FairGenerator
   // global static information about (upper limit of) number of events to be generated
   static unsigned int gTotalNEvents;
 
-#ifdef GENERATORS_WITH_TPCLOOPERS
   // Loopers generator instance
-  std::unique_ptr<o2::eventgen::GenTPCLoopers> mTPCLoopersGen = nullptr;
+  o2::eventgen::GenTPCLoopers* mTPCLoopersGen = nullptr;
+#ifdef GENERATORS_WITH_TPCLOOPERS
   bool initTPCLoopersGen();
 #endif
 
diff --git a/Generators/include/Generators/TPCLoopers.h b/Generators/include/Generators/TPCLoopers.h
index 6a1d3ef262e22..a144a947fc11b 100644
--- a/Generators/include/Generators/TPCLoopers.h
+++ b/Generators/include/Generators/TPCLoopers.h
@@ -16,14 +16,12 @@
 
 #ifdef GENERATORS_WITH_TPCLOOPERS
 #include <onnxruntime_cxx_api.h>
-#endif
 #include <vector>
 #include <rapidjson/document.h>
 #include "TRandom3.h"
 #include <SimulationDataFormat/DigitizationContext.h>
 #include "TParticle.h"
 
-#ifdef GENERATORS_WITH_TPCLOOPERS
 // Static Ort::Env instance for multiple onnx model loading
 extern Ort::Env global_env;
 
diff --git a/Generators/src/Generator.cxx b/Generators/src/Generator.cxx
index 465a8ffb7ee22..ecea311c94de7 100644
--- a/Generators/src/Generator.cxx
+++ b/Generators/src/Generator.cxx
@@ -27,6 +27,10 @@
 #include "TGrid.h"
 #include "CCDB/BasicCCDBManager.h"
 #include <filesystem>
+#ifdef GENERATORS_WITH_TPCLOOPERS
+#include "Generators/TPCLoopers.h"
+#include "Generators/TPCLoopersParam.h"
+#endif
 
 namespace o2
 {
@@ -94,6 +98,19 @@ Generator::Generator(const Char_t* name, const Char_t* title) : FairGenerator(na
 #endif
 }
 
+/*****************************************************************/
+
+Generator::~Generator()
+{
+  /** destructor **/
+#ifdef GENERATORS_WITH_TPCLOOPERS
+  if (mTPCLoopersGen) {
+    delete mTPCLoopersGen;
+    mTPCLoopersGen = nullptr;
+  }
+#endif
+}
+
 /*****************************************************************/
 #ifdef GENERATORS_WITH_TPCLOOPERS
 bool Generator::initTPCLoopersGen()
@@ -171,7 +188,7 @@ bool Generator::initTPCLoopersGen()
   nclxrate = isAlien[2] || isCCDB[2] ? local_names[2] : nclxrate;
   try {
     // Create the TPC loopers generator with the provided parameters
-    mTPCLoopersGen = std::make_unique<o2::eventgen::GenTPCLoopers>(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
+    mTPCLoopersGen = new o2::eventgen::GenTPCLoopers(model_pairs, model_compton, poisson, gauss, scaler_pair, scaler_compton);
     const auto& intrate = loopersParam.intrate;
     // Configure the generator with flat gas loopers defined per orbit with clusters/track info
     // If intrate is negative (default), automatic IR from collisioncontext.root will be used
@@ -188,7 +205,9 @@ bool Generator::initTPCLoopersGen()
     LOG(info) << "TPC Loopers generator initialized successfully";
   } catch (const std::exception& e) {
     LOG(error) << "Failed to initialize TPC Loopers generator: " << e.what();
-    mTPCLoopersGen.reset();
+    delete mTPCLoopersGen;
+    mTPCLoopersGen = nullptr;
+    return kFALSE;
   }
   return kTRUE;
 }

From 71634e3b6983e1e54596784828b6fcb145261c9f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 5 Feb 2026 09:20:34 +0100
Subject: [PATCH 1265/1764] DPL: Improve message when we do not have enough
 resources to process. (#15016)

---
 Framework/Core/src/DataProcessingDevice.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 8a306c7b96001..ccfb58db7559a 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1399,12 +1399,12 @@ void DataProcessingDevice::Run()
         if (schedulingStats.numberOfUnscheduledSinceLastScheduled > 100 ||
             (uv_now(state.loop) - schedulingStats.lastScheduled) > 30000) {
           O2_SIGNPOST_EVENT_EMIT_WARN(scheduling, sid, "Run",
-                                      "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu.",
+                                      "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu. Data is not lost and it will be scheduled again.",
                                       schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
                                       schedulingStats.lastScheduled.load());
         } else {
           O2_SIGNPOST_EVENT_EMIT(scheduling, sid, "Run",
-                                 "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu.",
+                                 "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu. Data is not lost and it will be scheduled again.",
                                  schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
                                  schedulingStats.lastScheduled.load());
         }

From bfa44ca0e7a6b8d42cca3ac93f0b7a423869c5a0 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <gab.cima22@gmail.com>
Date: Fri, 19 Dec 2025 10:59:27 +0100
Subject: [PATCH 1266/1764] GPU Framework: remove GPUDefParametersDefaults.h
 and automatically generate GPU parameters using json file and CMake

---
 .../ITS/tracking/GPU/cuda/CMakeLists.txt      |   2 +-
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |   4 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |   4 +-
 GPU/GPUTracking/CMakeLists.txt                |  21 +-
 .../Definitions/.clang-format-ignore          |   1 +
 .../Definitions/GPUDefParametersDefaults.h    | 589 ------------------
 .../Definitions/GPUParameters.json            | 582 +++++++++++++++++
 GPU/GPUTracking/Definitions/GPUSettingsList.h |   2 +-
 .../cmake/generateGPUParamHeader.cmake        |  37 ++
 .../cmake/gpu_param_header_generator.cmake    | 105 ++++
 GPU/documentation/build-O2.md                 |   2 +-
 dependencies/FindO2GPU.cmake                  |  43 +-
 log.txt                                       |   0
 13 files changed, 777 insertions(+), 615 deletions(-)
 create mode 100644 GPU/GPUTracking/Definitions/.clang-format-ignore
 delete mode 100644 GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
 create mode 100644 GPU/GPUTracking/Definitions/GPUParameters.json
 create mode 100644 GPU/GPUTracking/cmake/generateGPUParamHeader.cmake
 create mode 100644 GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
 create mode 100644 log.txt

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index 1f6a046a81350..e38dbb1ef20e8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -35,5 +35,5 @@ if(CUDA_ENABLED)
 
     set_property(TARGET ${targetName} PROPERTY CUDA_SEPARABLE_COMPILATION ON)
     target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::ITStracking,COMPILE_DEFINITIONS>)
-    set_target_cuda_arch(${targetName})
+    set_target_gpu_arch("CUDA" ${targetName})
 endif()
diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 05ed091eb83ea..226bacbf88157 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -74,7 +74,7 @@ add_custom_command(
     COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -Wno-deprecated-gpu-targets -D__CUDACC__ -x c++ -M -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d ${GPU_RTC_SRC}
     COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -Wno-deprecated-gpu-targets -D__CUDACC__ -x c++ -E -Xcompiler "-nostdinc -P" ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
-    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h
+    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h GPU_PARAM_HEADER_AUTO_ALL
     DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
     COMMENT "Preparing CUDA RTC source file ${GPU_RTC_BIN}.src"
@@ -149,7 +149,7 @@ endif()
 
 # Setting target architecture and adding GPU libraries
 target_link_libraries(${targetName} PRIVATE cuda cudart)
-set_target_cuda_arch(${targetName})
+set_target_gpu_arch("CUDA" ${targetName})
 #target_link_options(${targetName} PRIVATE "LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/version_script.ld")
 #set_target_properties(${targetName} PROPERTIES LINK_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/version_script.ld)
 
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index 501509d8dfcf6..d148e376abca9 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -125,7 +125,7 @@ add_custom_command(
     COMMAND cat ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h | grep -v GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND ${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d >> ${GPU_RTC_BIN}.src
-    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h ${MODULE}_HIPIFIED
+    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h ${MODULE}_HIPIFIED GPU_PARAM_HEADER_AUTO_ALL
     DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
     COMMENT "Preparing HIP RTC source file ${GPU_RTC_BIN}.src"
@@ -219,7 +219,7 @@ endif()
 
 # Setting target architecture and adding GPU libraries
 target_link_libraries(${targetName} PRIVATE hip::host hip::device hip::hipcub roc::rocthrust)
-set_target_hip_arch(${targetName})
+set_target_gpu_arch("HIP" ${targetName})
 
 target_link_libraries(${MODULE}_CXX PRIVATE TBB::tbb)
 
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 9e9344108ccfb..a2d91b6ed4c5e 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -107,6 +107,12 @@ set(SRCS_NO_H SectorTracker/GPUTPCTrackerDump.cxx
               Global/GPUChainTrackingDebugAndProfiling.cxx
               Global/GPUChainTrackingIO.cxx)
 
+set(ON_THE_FLY_DIR ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
+file(MAKE_DIRECTORY ${ON_THE_FLY_DIR})
+include(cmake/generateGPUParamHeader.cmake)
+set(GPU_DEFAULT_PARAMS_HEADER ${ON_THE_FLY_DIR}/GPUDefParametersDefaults.h)
+generate_gpu_param_header("AUTO" ${GPU_DEFAULT_PARAMS_HEADER}) # generate header with default GPU parameters, arch selected by CMake variables
+
 set(HDRS_INSTALL
     ${HDRS_CINT_O2}
     ${HDRS_CINT_DATATYPES}
@@ -135,9 +141,9 @@ set(HDRS_INSTALL
     DataTypes/GPUO2ExternalUser.h
     Debug/GPUROOTDump.h
     Definitions/GPUDefConstantsAndSettings.h
+    ${GPU_DEFAULT_PARAMS_HEADER}
     Definitions/GPUDefParametersWrapper.h
     Definitions/GPUDefParametersConstants.h
-    Definitions/GPUDefParametersDefaults.h
     Definitions/GPUDef.h
     Definitions/GPUDefMacros.h
     Definitions/GPULogging.h
@@ -239,8 +245,6 @@ set(TEMPLATE_HEADER_LIST Base/GPUReconstructionKernelList.template.h
                          Definitions/GPUDefParametersLoad.template.inc)
 set(GENERATED_HEADERS_LIST "")
 
-set(ON_THE_FLY_DIR ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
-file(MAKE_DIRECTORY ${ON_THE_FLY_DIR})
 foreach(TEMPLATE_FILE ${TEMPLATE_HEADER_LIST})
   get_filename_component(OUTPUT_FILE_NAME ${TEMPLATE_FILE} NAME)
   string(REPLACE ".template" "" OUTPUT_FILE_NAME ${OUTPUT_FILE_NAME})
@@ -286,6 +290,7 @@ set(HDRS_CINT_DATATYPES ${HDRS_CINT_DATATYPES} ${HDRS_TMP})
 unset(HDRS_TMP)
 
 set(INCDIRS
+    ${ON_THE_FLY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/Definitions
     ${CMAKE_CURRENT_SOURCE_DIR}/DataTypes
@@ -302,14 +307,14 @@ set(INCDIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/Refit
     ${CMAKE_CURRENT_SOURCE_DIR}/Debug
     ${CMAKE_CURRENT_SOURCE_DIR}/DataCompression
-    ${CMAKE_CURRENT_SOURCE_DIR}/TPCClusterFinder
-    ${ON_THE_FLY_DIR})
+    ${CMAKE_CURRENT_SOURCE_DIR}/TPCClusterFinder)
 
 # Main CMake part for O2
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   o2_add_library(GPUDataTypes
                  TARGETVARNAME targetName
                  PUBLIC_INCLUDE_DIRECTORIES .
+                                            ${ON_THE_FLY_DIR}
                                             Definitions
                                             DataTypes
                  PUBLIC_LINK_LIBRARIES O2::GPUUtils
@@ -409,15 +414,17 @@ set(GPU_CONST_PARAM_ARCHITECTUES AMPERE TURING VEGA MI100)
 set(GPU_CONST_PARAM_FILES "")
 foreach(GPU_ARCH ${GPU_CONST_PARAM_ARCHITECTUES})
   set(PARAMFILE ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/gpu_const_param_${GPU_ARCH}.par)
+  set(GPU_ARCH_PARAMS_HEADER ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/GPUDefParametersDefaults_${GPU_ARCH}.h)
+  generate_gpu_param_header(${GPU_ARCH} ${GPU_ARCH_PARAMS_HEADER})
   add_custom_command(
     OUTPUT ${PARAMFILE}
     COMMAND bash -c
-            "echo -e '#define GPUCA_GPUTYPE_${GPU_ARCH}\\n#define PARAMETER_FILE \"GPUDefParametersDefaults.h\"\\ngInterpreter->AddIncludePath(\"${CMAKE_CURRENT_SOURCE_DIR}/Definitions\");\\ngInterpreter->AddIncludePath(\"${ON_THE_FLY_DIR}\");\\n.x ${CMAKE_CURRENT_SOURCE_DIR}/Standalone/tools/dumpGPUDefParam.C(\"${PARAMFILE}\")\\n.q\\n'"
+            "echo -e '#define GPUCA_GPUTYPE_${GPU_ARCH}\\n#define PARAMETER_FILE \"${GPU_ARCH_PARAMS_HEADER}\"\\ngInterpreter->AddIncludePath(\"${CMAKE_CURRENT_SOURCE_DIR}/Definitions\");\\ngInterpreter->AddIncludePath(\"${ON_THE_FLY_DIR}\");\\n.x ${CMAKE_CURRENT_SOURCE_DIR}/Standalone/tools/dumpGPUDefParam.C(\"${PARAMFILE}\")\\n.q\\n'"
             | root -l -b > /dev/null
     VERBATIM
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch
     MAIN_DEPENDENCY Standalone/tools/dumpGPUDefParam.C
-    DEPENDS Definitions/GPUDefParametersDefaults.h
+    DEPENDS ${GPU_ARCH_PARAMS_HEADER}
             ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h
             ${ON_THE_FLY_DIR}/GPUDefParametersLoad.inc
     COMMENT "Generating GPU parameter set for architecture ${GPU_ARCH}")
diff --git a/GPU/GPUTracking/Definitions/.clang-format-ignore b/GPU/GPUTracking/Definitions/.clang-format-ignore
new file mode 100644
index 0000000000000..5ffee2498bd7e
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/.clang-format-ignore
@@ -0,0 +1 @@
+GPUParameters.json
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h b/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
deleted file mode 100644
index 1be881ee6323e..0000000000000
--- a/GPU/GPUTracking/Definitions/GPUDefParametersDefaults.h
+++ /dev/null
@@ -1,589 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUDefParametersDefaults.h
-/// \author David Rohr
-
-// This file contains compile-time constants affecting the GPU performance.
-
-#if !defined(GPUDEFPARAMETERSDEFAULTS_H)
-#define GPUDEFPARAMETERSDEFAULTS_H
-// clang-format off
-
-// Launch bound definition, 3 optional parameters: maxThreads per block, minBlocks per multiprocessor, force number of blocks (not passed to compiler as launch bounds)
-
-// GPU Run Configuration
-#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.
-  // GPU-architecture-dependent default settings
-  #if defined(GPUCA_GPUTYPE_MI100)
-    #define GPUCA_WARP_SIZE 64
-    #define GPUCA_PAR_AMD_EUS_PER_CU 4
-    #define GPUCA_THREAD_COUNT_DEFAULT 256
-    #define GPUCA_LB_GPUTPCCreateTrackingData 256, 7
-    #define GPUCA_LB_GPUTPCStartHitsSorter 1024, 5
-    #define GPUCA_LB_GPUTPCStartHitsFinder 1024, 2
-    #define GPUCA_LB_GPUTPCTrackletConstructor 768, 8
-    #define GPUCA_LB_GPUTPCTrackletSelector 384, 5
-    #define GPUCA_LB_GPUTPCNeighboursFinder 192, 8
-    #define GPUCA_LB_GPUTPCNeighboursCleaner 128, 5
-    #define GPUCA_LB_GPUTPCExtrapolationTracking 256, 7
-    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 4
-    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE, 4
-    #define GPUCA_LB_GPUTPCCFGather 1024, 5
-    #define GPUCA_LB_GPUTPCGMMergerTrackFit 192, 2
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 5
-    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 64, 4
-    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 512
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 512
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 512
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 512
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 512
-    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 512
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 512
-    #define GPUCA_LB_GPUTPCGMMergerMergeCE 512
-    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-    #define GPUCA_LB_GPUTPCGMMergerCollect 768, 1
-    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 128, 1
-    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 576, 2
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
-    #define GPUCA_LB_GPUTPCCFPeakFinder 512, 9
-    #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
-    #define GPUCA_LB_GPUTPCCFDeconvolution 512, 5
-    #define GPUCA_LB_GPUTPCCFClusterizer 448, 3
-    #define GPUCA_LB_COMPRESSION_GATHER 1024
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 10
-    #define PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL 4
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED 0
-    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 9
-    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
-    #define GPUCA_PAR_SORT_BEFORE_FIT 1
-    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
-    #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
-    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
-    #define GPUCA_PAR_COMP_GATHER_KERNEL 4
-    #define GPUCA_PAR_COMP_GATHER_MODE 3
-  #elif defined(GPUCA_GPUTYPE_VEGA)
-    #define GPUCA_WARP_SIZE 64
-    #define GPUCA_PAR_AMD_EUS_PER_CU 4
-    #define GPUCA_THREAD_COUNT_DEFAULT 256
-    #define GPUCA_LB_GPUTPCCreateTrackingData 192, 2
-    #define GPUCA_LB_GPUTPCStartHitsSorter 512, 7
-    #define GPUCA_LB_GPUTPCStartHitsFinder 1024, 7
-    #define GPUCA_LB_GPUTPCTrackletConstructor 512, 10
-    #define GPUCA_LB_GPUTPCTrackletSelector 192, 10
-    #define GPUCA_LB_GPUTPCNeighboursFinder 960, 8
-    #define GPUCA_LB_GPUTPCNeighboursCleaner 384, 9
-    #define GPUCA_LB_GPUTPCExtrapolationTracking 256, 2
-    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 1
-    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE, 14
-    #define GPUCA_LB_GPUTPCCFGather 1024, 1
-    #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 7
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256, 4
-    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256, 2
-    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256
-    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
-    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-    #define GPUCA_LB_GPUTPCGMMergerCollect 1024, 1
-    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 64, 2
-    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 128, 2
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 64, 2
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 576, 2
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
-    #define GPUCA_LB_GPUTPCCFPeakFinder 512, 4
-    #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
-    #define GPUCA_LB_GPUTPCCFDeconvolution 512, 5
-    #define GPUCA_LB_GPUTPCCFClusterizer 512, 2
-    #define GPUCA_LB_COMPRESSION_GATHER 1024
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL 2
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED 0
-    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 27
-    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
-    #define GPUCA_PAR_SORT_BEFORE_FIT 1
-    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
-    #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
-    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
-    #define GPUCA_PAR_COMP_GATHER_KERNEL 4
-    #define GPUCA_PAR_COMP_GATHER_MODE 3
-  #elif defined(GPUCA_GPUTYPE_AMPERE)
-    #define GPUCA_WARP_SIZE 32
-    #define GPUCA_THREAD_COUNT_DEFAULT 512
-    #define GPUCA_LB_GPUTPCCreateTrackingData 384
-    #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
-    #define GPUCA_LB_GPUTPCStartHitsFinder 512
-    #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2 // best single-kernel: 128, 4
-    #define GPUCA_LB_GPUTPCTrackletSelector 192, 3    // best single-kernel: 128, 4
-    #define GPUCA_LB_GPUTPCNeighboursFinder 640, 1    // best single-kernel: 768, 1
-    #define GPUCA_LB_GPUTPCNeighboursCleaner 512
-    #define GPUCA_LB_GPUTPCExtrapolationTracking 128, 4
-    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 10
-    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFGather 1024, 1
-    #define GPUCA_LB_GPUTPCGMMergerTrackFit 64, 4
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 64, 12
-    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 32, 6
-    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256, 4
-    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256, 2
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 192
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 64, 2
-    #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
-    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-    #define GPUCA_LB_GPUTPCGMMergerCollect 256, 2
-    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 64, 2
-    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 3
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 576,2
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 448
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 448
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 448
-    #define GPUCA_LB_GPUTPCCFPeakFinder 128
-    #define GPUCA_LB_GPUTPCCFNoiseSuppression 448
-    #define GPUCA_LB_GPUTPCCFDeconvolution 384
-    #define GPUCA_LB_GPUTPCCFClusterizer 448
-    #define GPUCA_LB_COMPRESSION_GATHER 1024
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
-    #define GPUCA_PAR_SORT_BEFORE_FIT 1
-    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
-    #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
-    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
-    #define GPUCA_PAR_COMP_GATHER_KERNEL 4
-    #define GPUCA_PAR_COMP_GATHER_MODE 3
-  #elif defined(GPUCA_GPUTYPE_TURING)
-    #define GPUCA_WARP_SIZE 32
-    #define GPUCA_THREAD_COUNT_DEFAULT 512
-    #define GPUCA_LB_GPUTPCCreateTrackingData 256
-    #define GPUCA_LB_GPUTPCStartHitsSorter 512, 1
-    #define GPUCA_LB_GPUTPCStartHitsFinder 512
-    #define GPUCA_LB_GPUTPCTrackletConstructor 256, 2
-    #define GPUCA_LB_GPUTPCTrackletSelector 192, 3
-    #define GPUCA_LB_GPUTPCNeighboursFinder 640, 1
-    #define GPUCA_LB_GPUTPCNeighboursCleaner 512
-    #define GPUCA_LB_GPUTPCExtrapolationTracking 192, 2
-    #define GPUCA_LB_GPUTPCCFDecodeZS 64, 8
-    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
-    #define GPUCA_LB_GPUTPCCFGather 1024, 1
-    #define GPUCA_LB_GPUTPCGMMergerTrackFit 32, 8
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 128, 4
-    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 64, 5
-    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256, 4
-    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256, 2
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 192
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
-    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-    #define GPUCA_LB_GPUTPCGMMergerCollect 128, 2
-    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_0 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_1 256
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_2 256
-    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 128
-    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 512, 2
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 32, 1
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 32, 1
-    #define GPUCA_LB_COMPRESSION_GATHER 1024
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 4
-    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 20
-    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 1
-    #define GPUCA_PAR_SORT_BEFORE_FIT 1
-    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 1
-    #define GPUCA_PAR_COMP_GATHER_KERNEL 4
-    #define GPUCA_PAR_COMP_GATHER_MODE 3
-    #define GPUCA_PAR_DEDX_STORAGE_TYPE uint16_t
-    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE half
-  #elif defined(GPUCA_GPUTYPE_OPENCL)
-  #else
-    #error GPU TYPE NOT SET
-  #endif
-
-  // Default settings for GPU, if not already set for selected GPU type
-  #ifndef GPUCA_WARP_SIZE
-    #define GPUCA_WARP_SIZE 32
-  #endif
-  #ifndef GPUCA_PAR_AMD_EUS_PER_CU
-    #define GPUCA_PAR_AMD_EUS_PER_CU 0
-  #endif
-  #ifndef GPUCA_THREAD_COUNT_DEFAULT
-    #define GPUCA_THREAD_COUNT_DEFAULT 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCreateTrackingData
-    #define GPUCA_LB_GPUTPCCreateTrackingData 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCTrackletConstructor
-    #define GPUCA_LB_GPUTPCTrackletConstructor 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCTrackletSelector
-    #define GPUCA_LB_GPUTPCTrackletSelector 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCNeighboursFinder
-    #define GPUCA_LB_GPUTPCNeighboursFinder 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCNeighboursCleaner
-    #define GPUCA_LB_GPUTPCNeighboursCleaner 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCExtrapolationTracking
-    #define GPUCA_LB_GPUTPCExtrapolationTracking 256
-  #endif
-  #ifndef GPUCA_LB_GPUTRDTrackerKernels_gpuVersion
-    #define GPUCA_LB_GPUTRDTrackerKernels_gpuVersion 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCreateOccupancyMap_fill
-    #define GPUCA_LB_GPUTPCCreateOccupancyMap_fill 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCreateOccupancyMap_fold
-    #define GPUCA_LB_GPUTPCCreateOccupancyMap_fold 256
-  #endif
-  #ifndef GPUCA_LB_GPUTRDTrackerKernels_o2Version
-    #define GPUCA_LB_GPUTRDTrackerKernels_o2Version 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCompressionKernels_step0attached
-    #define GPUCA_LB_GPUTPCCompressionKernels_step0attached 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCompressionKernels_step1unattached
-    #define GPUCA_LB_GPUTPCCompressionKernels_step1unattached 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionKernels_step0attached
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step0attached 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionKernels_step1unattached
-    #define GPUCA_LB_GPUTPCDecompressionKernels_step1unattached 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_sortPerSectorRow
-    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_sortPerSectorRow 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters
-    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_countFilteredClusters 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters
-    #define GPUCA_LB_GPUTPCDecompressionUtilKernels_storeFilteredClusters 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFDecodeZS
-    #define GPUCA_LB_GPUTPCCFDecodeZS 128, 4
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFDecodeZSLink
-    #define GPUCA_LB_GPUTPCCFDecodeZSLink GPUCA_WARP_SIZE
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFDecodeZSDenseLink
-    #define GPUCA_LB_GPUTPCCFDecodeZSDenseLink GPUCA_WARP_SIZE
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFGather
-    #define GPUCA_LB_GPUTPCCFGather 1024, 1
-  #endif
-  #ifndef GPUCA_LB_COMPRESSION_GATHER
-    #define GPUCA_LB_COMPRESSION_GATHER 1024
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerTrackFit
-    #define GPUCA_LB_GPUTPCGMMergerTrackFit 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerFollowLoopers
-    #define GPUCA_LB_GPUTPCGMMergerFollowLoopers 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerSectorRefit
-    #define GPUCA_LB_GPUTPCGMMergerSectorRefit 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerUnpackResetIds
-    #define GPUCA_LB_GPUTPCGMMergerUnpackResetIds 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerUnpackGlobal
-    #define GPUCA_LB_GPUTPCGMMergerUnpackGlobal 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step0
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step0 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step1
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step1 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step2
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step2 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step3
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step3 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerResolve_step4
-    #define GPUCA_LB_GPUTPCGMMergerResolve_step4 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerClearLinks
-    #define GPUCA_LB_GPUTPCGMMergerClearLinks 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare
-    #define GPUCA_LB_GPUTPCGMMergerMergeWithinPrepare 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare
-    #define GPUCA_LB_GPUTPCGMMergerMergeSectorsPrepare 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_step0
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step0 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeBorders_step2
-    #define GPUCA_LB_GPUTPCGMMergerMergeBorders_step2 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeCE
-    #define GPUCA_LB_GPUTPCGMMergerMergeCE 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks
-    #define GPUCA_LB_GPUTPCGMMergerLinkExtrapolatedTracks 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerCollect
-    #define GPUCA_LB_GPUTPCGMMergerCollect 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerSortTracksPrepare
-    #define GPUCA_LB_GPUTPCGMMergerSortTracksPrepare 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step0 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step1 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2
-    #define GPUCA_LB_GPUTPCGMMergerPrepareForFit_step2 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step0
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_step0 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step1
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_step1 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerFinalize_step2
-    #define GPUCA_LB_GPUTPCGMMergerFinalize_step2 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step0
-    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step0 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step1
-    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step1 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMMergerMergeLoopers_step2
-    #define GPUCA_LB_GPUTPCGMMergerMergeLoopers_step2 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMO2Output_prepare
-    #define GPUCA_LB_GPUTPCGMO2Output_prepare 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCGMO2Output_output
-    #define GPUCA_LB_GPUTPCGMO2Output_output 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCStartHitsFinder
-    #define GPUCA_LB_GPUTPCStartHitsFinder 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCStartHitsSorter
-    #define GPUCA_LB_GPUTPCStartHitsSorter 256
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFCheckPadBaseline
-    #define GPUCA_LB_GPUTPCCFCheckPadBaseline 576
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillIndexMap 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_fillFromDigits 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart
-    #define GPUCA_LB_GPUTPCCFChargeMapFiller_findFragmentStart 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFPeakFinder
-    #define GPUCA_LB_GPUTPCCFPeakFinder 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFNoiseSuppression
-    #define GPUCA_LB_GPUTPCCFNoiseSuppression 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFDeconvolution
-    #define GPUCA_LB_GPUTPCCFDeconvolution 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCCFClusterizer
-    #define GPUCA_LB_GPUTPCCFClusterizer 512
-  #endif
-  #ifndef GPUCA_LB_GPUTPCNNClusterizerKernels
-    #define GPUCA_LB_GPUTPCNNClusterizerKernels 512
-  #endif
-  #ifndef GPUCA_LB_GPUTrackingRefitKernel_mode0asGPU
-    #define GPUCA_LB_GPUTrackingRefitKernel_mode0asGPU 256
-  #endif
-  #ifndef GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov
-    #define GPUCA_LB_GPUTrackingRefitKernel_mode1asTrackParCov 256
-  #endif
-  #ifndef GPUCA_LB_GPUMemClean16
-    #define GPUCA_LB_GPUMemClean16 GPUCA_THREAD_COUNT_DEFAULT, 1
-  #endif
-  #ifndef GPUCA_LB_GPUitoa
-    #define GPUCA_LB_GPUitoa GPUCA_THREAD_COUNT_DEFAULT, 1
-  #endif
-  // These kernel launch-bounds are derrived from one of the constants set above
-  #define GPUCA_LB_GPUTPCCFNoiseSuppression_noiseSuppression GPUCA_LB_GPUTPCCFNoiseSuppression
-  #define GPUCA_LB_GPUTPCCFNoiseSuppression_updatePeaks GPUCA_LB_GPUTPCCFNoiseSuppression
-
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_runCfClusterizer GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNCPU GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_fillInputNNGPU 1024
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass1Labels GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_determineClass2Labels GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass1Regression GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishClass2Regression GPUCA_LB_GPUTPCNNClusterizerKernels
-  #define GPUCA_LB_GPUTPCNNClusterizerKernels_publishDeconvolutionFlags GPUCA_LB_GPUTPCNNClusterizerKernels
-
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanStart GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanUp GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanTop GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_scanDown GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
-  #define GPUCA_LB_GPUTPCCFStreamCompaction_compactDigits GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
-  #define GPUCA_LB_GPUTPCCompressionGatherKernels_unbuffered GPUCA_LB_COMPRESSION_GATHER
-  #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered32 GPUCA_LB_COMPRESSION_GATHER
-  #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered64 GPUCA_LB_COMPRESSION_GATHER
-  #define GPUCA_LB_GPUTPCCompressionGatherKernels_buffered128 GPUCA_LB_COMPRESSION_GATHER
-  #define GPUCA_LB_GPUTPCCompressionGatherKernels_multiBlock GPUCA_LB_COMPRESSION_GATHER
-
-  // Defaults for non-LB parameters
-  #ifndef GPUCA_PAR_SORT_STARTHITS
-    #define GPUCA_PAR_SORT_STARTHITS 1
-  #endif
-  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 6
-  #endif
-  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL 4
-  #endif
-  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED 1
-  #endif
-  #ifndef GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE
-    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 12
-  #endif
-  #ifndef GPUCA_PAR_ALTERNATE_BORDER_SORT
-    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 0
-  #endif
-  #ifndef GPUCA_PAR_SORT_BEFORE_FIT
-    #define GPUCA_PAR_SORT_BEFORE_FIT 0
-  #endif
-  #ifndef GPUCA_PAR_COMP_GATHER_KERNEL
-    #define GPUCA_PAR_COMP_GATHER_KERNEL 0
-  #endif
-  #ifndef GPUCA_PAR_COMP_GATHER_MODE
-    #define GPUCA_PAR_COMP_GATHER_MODE 2
-  #endif
-  #ifndef GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
-    #define GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE 512
-  #endif
-#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)
-
-#ifndef GPUCA_GPUCODE_GENRTC
-  // Defaults (also for CPU) for non-LB parameters
-  #ifndef GPUCA_PAR_SORT_STARTHITS
-    #define GPUCA_PAR_SORT_STARTHITS 0
-  #endif
-  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP 0
-  #endif
-  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL 0
-  #endif
-  #ifndef GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED
-    #define GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_SHARED 0
-  #endif
-  #ifndef GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE
-    #define GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE 0
-  #endif
-  #ifndef GPUCA_PAR_ALTERNATE_BORDER_SORT
-    #define GPUCA_PAR_ALTERNATE_BORDER_SORT 0
-  #endif
-  #ifndef GPUCA_PAR_SORT_BEFORE_FIT
-    #define GPUCA_PAR_SORT_BEFORE_FIT 0
-  #endif
-  #ifndef GPUCA_PAR_COMP_GATHER_KERNEL
-    #define GPUCA_PAR_COMP_GATHER_KERNEL 0
-  #endif
-  #ifndef GPUCA_PAR_COMP_GATHER_MODE
-    #define GPUCA_PAR_COMP_GATHER_MODE 0
-  #endif
-  #ifndef GPUCA_PAR_NO_ATOMIC_PRECHECK
-    #define GPUCA_PAR_NO_ATOMIC_PRECHECK 0
-  #endif
-  #ifndef GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE
-    #define GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE 0
-  #endif
-  #ifndef GPUCA_PAR_DEDX_STORAGE_TYPE
-    #define GPUCA_PAR_DEDX_STORAGE_TYPE float
-  #endif
-  #ifndef GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE
-    #define GPUCA_PAR_MERGER_INTERPOLATION_ERROR_TYPE float
-  #endif
-#endif // GPUCA_GPUCODE_GENRTC
-
-// clang-format on
-#endif // GPUDEFPARAMETERSDEFAULTS_H
diff --git a/GPU/GPUTracking/Definitions/GPUParameters.json b/GPU/GPUTracking/Definitions/GPUParameters.json
new file mode 100644
index 0000000000000..e8f1c24520813
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/GPUParameters.json
@@ -0,0 +1,582 @@
+{
+  "CORE": {
+    "WARP_SIZE": {
+      "default":  32,
+      "MI100":    64,
+      "VEGA":     64,
+      "AMPERE":   32,
+      "TURING":   32
+    },
+    "THREAD_COUNT_DEFAULT": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   512,
+      "TURING":   512
+    }
+  },
+  "LB": {
+    "GPUTPCCreateTrackingData": {
+      "default":  256,
+      "MI100":    [256, 7],
+      "VEGA":     [192, 2],
+      "AMPERE":   384,
+      "TURING":   256
+    },
+    "GPUTPCTrackletConstructor": {
+      "default":  256,
+      "MI100":    [768, 8],
+      "VEGA":     [512, 10],
+      "AMPERE":   [256, 2],
+      "TURING":   [256, 2]
+    },
+    "GPUTPCTrackletSelector": {
+      "default":  256,
+      "MI100":    [384, 5],
+      "VEGA":     [192, 10],
+      "AMPERE":   [192, 3],
+      "TURING":   [192, 3]
+    },
+    "GPUTPCNeighboursFinder": {
+      "default":  256,
+      "MI100":    [192, 8],
+      "VEGA":     [960, 8],
+      "AMPERE":   [640, 1],
+      "TURING":   [640, 1]
+    },
+    "GPUTPCNeighboursCleaner": {
+      "default":  256,
+      "MI100":    [128, 5],
+      "VEGA":     [384, 9],
+      "AMPERE":   512,
+      "TURING":   512
+    },
+    "GPUTPCExtrapolationTracking": {
+      "default":  256,
+      "MI100":    [256, 7],
+      "VEGA":     [256, 2],
+      "AMPERE":   [128, 4],
+      "TURING":   [192, 2]
+    },
+    "GPUTRDTrackerKernels_gpuVersion": {
+      "default": 512
+    },
+    "GPUTPCCreateOccupancyMap_fill": {
+      "default": 256
+    },
+    "GPUTPCCreateOccupancyMap_fold": {
+      "default": 256
+    },
+    "GPUTRDTrackerKernels_o2Version": {
+      "default": 512
+    },
+    "GPUTPCCompressionKernels_step0attached": {
+      "default":  256,
+      "MI100":    [128, 1],
+      "VEGA":     [64, 2],
+      "AMPERE":   [64, 2],
+      "TURING":   128
+    },
+    "GPUTPCCompressionKernels_step1unattached": {
+      "default":  256,
+      "MI100":    [512, 2],
+      "VEGA":     [512, 2],
+      "AMPERE":   [512, 3],
+      "TURING":   [512, 2]
+    },
+    "GPUTPCDecompressionKernels_step0attached": {
+      "default":  256,
+      "MI100":    [128, 2],
+      "VEGA":     [128, 2],
+      "AMPERE":   [32, 1],
+      "TURING":   [32, 1]
+    },
+    "GPUTPCDecompressionKernels_step1unattached": {
+      "default":  256,
+      "MI100":    [64, 2],
+      "VEGA":     [64, 2],
+      "AMPERE":   [32, 1],
+      "TURING":   [32, 1]
+    },
+    "GPUTPCDecompressionUtilKernels_sortPerSectorRow": {
+      "default": 256
+    },
+    "GPUTPCDecompressionUtilKernels_countFilteredClusters": {
+      "default": 256
+    },
+    "GPUTPCDecompressionUtilKernels_storeFilteredClusters": {
+      "default": 256
+    },
+    "GPUTPCCFDecodeZS": {
+      "default":  [128, 4],
+      "MI100":    [64, 4],
+      "VEGA":     [64, 1],
+      "AMPERE":   [64, 10],
+      "TURING":   [64, 8]
+    },
+    "GPUTPCCFDecodeZSLink": {
+      "default":  "GPUCA_WARP_SIZE",
+      "MI100":    "GPUCA_WARP_SIZE",
+      "VEGA":     "GPUCA_WARP_SIZE",
+      "AMPERE":   "GPUCA_WARP_SIZE",
+      "TURING":   "GPUCA_WARP_SIZE"
+    },
+    "GPUTPCCFDecodeZSDenseLink": {
+      "default":  "GPUCA_WARP_SIZE",
+      "MI100":    ["GPUCA_WARP_SIZE", 4],
+      "VEGA":     ["GPUCA_WARP_SIZE", 14],
+      "AMPERE":   "GPUCA_WARP_SIZE",
+      "TURING":   "GPUCA_WARP_SIZE"
+    },
+    "GPUTPCCFGather": {
+      "default":  [1024, 1],
+      "MI100":    [1024, 5],
+      "VEGA":     [1024, 1],
+      "AMPERE":   [1024, 1],
+      "TURING":   [1024, 1]
+    },
+    "COMPRESSION_GATHER": {
+      "default":  1024,
+      "MI100":    1024,
+      "VEGA":     1024,
+      "AMPERE":   1024,
+      "TURING":   1024
+    },
+    "GPUTPCGMMergerTrackFit": {
+      "default":  256,
+      "MI100":    [192, 2],
+      "VEGA":     [64, 7],
+      "AMPERE":   [64, 4],
+      "TURING":   [32, 8]
+    },
+    "GPUTPCGMMergerFollowLoopers": {
+      "default":  256,
+      "MI100":    [256, 5],
+      "VEGA":     [256, 4],
+      "AMPERE":   [64, 12],
+      "TURING":   [128, 4]
+    },
+    "GPUTPCGMMergerSectorRefit": {
+      "default":  256,
+      "MI100":    [64, 4],
+      "VEGA":     [256, 2],
+      "AMPERE":   [32, 6],
+      "TURING":   [64, 5]
+    },
+    "GPUTPCGMMergerUnpackResetIds": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerUnpackGlobal": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerResolve_step0": {
+      "default":  256,
+      "MI100":    512,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerResolve_step1": {
+      "default":  256,
+      "MI100":    512,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerResolve_step2": {
+      "default":  256,
+      "MI100":    512,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerResolve_step3": {
+      "default":  256,
+      "MI100":    512,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerResolve_step4": {
+      "default":  256,
+      "MI100":    512,
+      "VEGA":     256,
+      "AMPERE":   [256, 4],
+      "TURING":   [256, 4]
+    },
+    "GPUTPCGMMergerClearLinks": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerMergeWithinPrepare": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerMergeSectorsPrepare": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   [256, 2],
+      "TURING":   [256, 2]
+    },
+    "GPUTPCGMMergerMergeBorders_step0": {
+      "default":  256,
+      "MI100":    512,
+      "VEGA":     256,
+      "AMPERE":   192,
+      "TURING":   192
+    },
+    "GPUTPCGMMergerMergeBorders_step2": {
+      "default":  256,
+      "MI100":    512,
+      "VEGA":     256,
+      "AMPERE":   [64, 2],
+      "TURING":   256
+    },
+    "GPUTPCGMMergerMergeCE": {
+      "default":  256,
+      "MI100":    512,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerLinkExtrapolatedTracks": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerCollect": {
+      "default":  256,
+      "MI100":    [768, 1],
+      "VEGA":     [1024, 1],
+      "AMPERE":   [256, 2],
+      "TURING":   [128, 2]
+    },
+    "GPUTPCGMMergerSortTracksPrepare": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerPrepareForFit_step0": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerPrepareForFit_step1": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerPrepareForFit_step2": {
+      "default":  256,
+      "MI100":    256,
+      "VEGA":     256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerFinalize_step0": {
+      "default":  256,
+      "VEGA":     256
+    },
+    "GPUTPCGMMergerFinalize_step1": {
+      "default":  256,
+      "VEGA":     256
+    },
+    "GPUTPCGMMergerFinalize_step2": {
+      "default":  256,
+      "VEGA":     256
+    },
+    "GPUTPCGMMergerMergeLoopers_step0": {
+      "default": 256
+    },
+    "GPUTPCGMMergerMergeLoopers_step1": {
+      "default": 256
+    },
+    "GPUTPCGMMergerMergeLoopers_step2": {
+      "default": 256
+    },
+    "GPUTPCGMO2Output_prepare": {
+      "default": 256
+    },
+    "GPUTPCGMO2Output_output": {
+      "default": 256
+    },
+    "GPUTPCStartHitsFinder": {
+      "default":  256,
+      "MI100":    [1024, 2],
+      "VEGA":     [1024, 7],
+      "AMPERE":   512,
+      "TURING":   512
+    },
+    "GPUTPCStartHitsSorter": {
+      "default":  256,
+      "MI100":    [1024, 5],
+      "VEGA":     [512, 7],
+      "AMPERE":   [512, 1],
+      "TURING":   [512, 1]
+    },
+    "GPUTPCCFCheckPadBaseline": {
+      "default":  64,
+      "MI100":    [64, 10],
+      "VEGA":     [64, 2],
+      "AMPERE":   [64, 8]
+    },
+    "GPUTPCCFChargeMapFiller_fillIndexMap": {
+      "default":  512,
+      "MI100":    512,
+      "VEGA":     512,
+      "AMPERE":   448
+    },
+    "GPUTPCCFChargeMapFiller_fillFromDigits": {
+      "default":  512,
+      "MI100":    512,
+      "VEGA":     512,
+      "AMPERE":   448
+    },
+    "GPUTPCCFChargeMapFiller_findFragmentStart": {
+      "default":  512,
+      "MI100":    512,
+      "VEGA":     512,
+      "AMPERE":   448
+    },
+    "GPUTPCCFPeakFinder": {
+      "default":  512,
+      "MI100":    [512, 9],
+      "VEGA":     [512, 4],
+      "AMPERE":   128
+    },
+    "GPUTPCCFNoiseSuppression": {
+      "default":  512,
+      "MI100":    512,
+      "VEGA":     512,
+      "AMPERE":   448
+    },
+    "GPUTPCCFDeconvolution": {
+      "default":  512,
+      "MI100":    [512, 5],
+      "VEGA":     [512, 5],
+      "AMPERE":   384
+    },
+    "GPUTPCCFClusterizer": {
+      "default":  512,
+      "MI100":    [448, 3],
+      "VEGA":     [512, 2],
+      "AMPERE":   448
+    },
+    "GPUTPCNNClusterizerKernels": {
+      "default": 512
+    },
+    "GPUTrackingRefitKernel_mode0asGPU": {
+      "default": 256
+    },
+    "GPUTrackingRefitKernel_mode1asTrackParCov": {
+      "default": 256
+    },
+    "GPUMemClean16": {
+      "default": ["GPUCA_THREAD_COUNT_DEFAULT", 1]
+    },
+    "GPUitoa": {
+      "default": ["GPUCA_THREAD_COUNT_DEFAULT", 1]
+    },
+    "GPUTPCCFNoiseSuppression_noiseSuppression": {
+      "default": "GPUCA_LB_GPUTPCCFNoiseSuppression"
+    },
+    "GPUTPCCFNoiseSuppression_updatePeaks": {
+      "default": "GPUCA_LB_GPUTPCCFNoiseSuppression"
+    },
+    "GPUTPCNNClusterizerKernels_runCfClusterizer": {
+      "default": "GPUCA_LB_GPUTPCNNClusterizerKernels"
+    },
+    "GPUTPCNNClusterizerKernels_fillInputNNCPU": {
+      "default": "GPUCA_LB_GPUTPCNNClusterizerKernels"
+    },
+    "GPUTPCNNClusterizerKernels_fillInputNNGPU": {
+      "default": 1024
+    },
+    "GPUTPCNNClusterizerKernels_determineClass1Labels": {
+      "default": "GPUCA_LB_GPUTPCNNClusterizerKernels"
+    },
+    "GPUTPCNNClusterizerKernels_determineClass2Labels": {
+      "default": "GPUCA_LB_GPUTPCNNClusterizerKernels"
+    },
+    "GPUTPCNNClusterizerKernels_publishClass1Regression": {
+      "default": "GPUCA_LB_GPUTPCNNClusterizerKernels"
+    },
+    "GPUTPCNNClusterizerKernels_publishClass2Regression": {
+      "default": "GPUCA_LB_GPUTPCNNClusterizerKernels"
+    },
+    "GPUTPCNNClusterizerKernels_publishDeconvolutionFlags": {
+      "default": "GPUCA_LB_GPUTPCNNClusterizerKernels"
+    },
+    "GPUTPCCFStreamCompaction_scanStart": {
+      "default": "GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"
+    },
+    "GPUTPCCFStreamCompaction_scanUp": {
+      "default": "GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"
+    },
+    "GPUTPCCFStreamCompaction_scanTop": {
+      "default": "GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"
+    },
+    "GPUTPCCFStreamCompaction_scanDown": {
+      "default": "GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"
+    },
+    "GPUTPCCFStreamCompaction_compactDigits": {
+      "default": "GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"
+    },
+    "GPUTPCCompressionGatherKernels_unbuffered": {
+      "default": "GPUCA_LB_COMPRESSION_GATHER"
+    },
+    "GPUTPCCompressionGatherKernels_buffered32": {
+      "default": "GPUCA_LB_COMPRESSION_GATHER"
+    },
+    "GPUTPCCompressionGatherKernels_buffered64": {
+      "default": "GPUCA_LB_COMPRESSION_GATHER"
+    },
+    "GPUTPCCompressionGatherKernels_buffered128": {
+      "default": "GPUCA_LB_COMPRESSION_GATHER"
+    },
+    "GPUTPCCompressionGatherKernels_multiBlock": {
+      "default": "GPUCA_LB_COMPRESSION_GATHER"
+    },
+    "GPUTPCGMMergerFinalize_0": {
+      "default":  256,
+      "MI100":    256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerFinalize_1": {
+      "default":  256,
+      "MI100":    256,
+      "AMPERE":   256,
+      "TURING":   256
+    },
+    "GPUTPCGMMergerFinalize_2": {
+      "default":  256,
+      "MI100":    256,
+      "AMPERE":   256,
+      "TURING":   256
+    }
+  },
+  "PAR": {
+    "AMD_EUS_PER_CU": {
+      "default":      0,
+      "default_cpu":  0,
+      "MI100":        4,
+      "VEGA":         4
+    },
+    "SORT_STARTHITS": {
+      "default":      1,
+      "default_cpu":  0
+    },
+    "NEIGHBOURS_FINDER_MAX_NNEIGHUP": {
+      "default":      6,
+      "default_cpu":  0,
+      "MI100":        10,
+      "VEGA":         4,
+      "AMPERE":       4,
+      "TURING":       4
+    },
+    "NEIGHBOURS_FINDER_UNROLL_GLOBAL": {
+      "default":      4,
+      "default_cpu":  0,
+      "MI100":        4,
+      "VEGA":         2
+    },
+    "NEIGHBOURS_FINDER_UNROLL_SHARED": {
+      "default":      1,
+      "default_cpu":  0,
+      "MI100":        0,
+      "VEGA":         0
+    },
+    "TRACKLET_SELECTOR_HITS_REG_SIZE": {
+      "default":      12,
+      "default_cpu":  0,
+      "MI100":        9,
+      "VEGA":         27,
+      "AMPERE":       20,
+      "TURING":       20
+    },
+    "ALTERNATE_BORDER_SORT": {
+      "default":      0,
+      "default_cpu":  0,
+      "MI100":        1,
+      "VEGA":         1,
+      "AMPERE":       1,
+      "TURING":       1
+    },
+    "SORT_BEFORE_FIT": {
+      "default":      0,
+      "default_cpu":  0,
+      "MI100":        1,
+      "VEGA":         1,
+      "AMPERE":       1,
+      "TURING":       1
+    },
+    "NO_ATOMIC_PRECHECK": {
+      "default":      0,
+      "default_cpu":  0,
+      "MI100":        1,
+      "VEGA":         1,
+      "AMPERE":       1,
+      "TURING":       1
+    },
+    "DEDX_STORAGE_TYPE": {
+      "default":      "float",
+      "default_cpu":  "float",
+      "MI100":        "uint16_t",
+      "VEGA":         "uint16_t",
+      "AMPERE":       "uint16_t",
+      "TURING":       "uint16_t"
+    },
+    "MERGER_INTERPOLATION_ERROR_TYPE": {
+      "default":      "float",
+      "default_cpu":  "float",
+      "MI100":        "half",
+      "VEGA":         "half",
+      "AMPERE":       "half",
+      "TURING":       "half"
+    },
+    "COMP_GATHER_KERNEL": {
+      "default":      0,
+      "default_cpu":  0,
+      "MI100":        4,
+      "VEGA":         4,
+      "AMPERE":       4,
+      "TURING":       4
+    },
+    "COMP_GATHER_MODE": {
+      "default":      2,
+      "default_cpu":  0,
+      "MI100":        3,
+      "VEGA":         3,
+      "AMPERE":       3,
+      "TURING":       3
+    },
+    "CF_SCAN_WORKGROUP_SIZE": {
+      "default":      512,
+      "default_cpu":  0
+    }
+  }
+}
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 9bfe6feb14d8d..c61056466929e 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -624,7 +624,7 @@ AddSubConfig(GPUSettingsEG, EG)
 EndConfig()
 #endif // BeginConfig
 
-//Settings for the O2 workfllow
+//Settings for the O2 workflow
 #if !defined(QCONFIG_PARSER_CXX) && (defined(GPUCA_O2_LIB) || defined(GPUCA_O2_INTERFACE))
 BeginSubConfig(GPUSettingsO2, global, configStandalone, "O2", 0, "O2 workflow settings", global)
 AddOption(solenoidBzNominalGPU, float, -1e6f, "", 0, "Field strength of solenoid Bz in kGaus")
diff --git a/GPU/GPUTracking/cmake/generateGPUParamHeader.cmake b/GPU/GPUTracking/cmake/generateGPUParamHeader.cmake
new file mode 100644
index 0000000000000..712bf4641b825
--- /dev/null
+++ b/GPU/GPUTracking/cmake/generateGPUParamHeader.cmake
@@ -0,0 +1,37 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# file generateGPUParamHeader.cmake
+# author Gabriele Cimador
+
+function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
+  set(GPU_PARAM_JSON ${CMAKE_SOURCE_DIR}/GPU/GPUTracking/Definitions/GPUParameters.json)
+  set(TARGET_ARCH "UNKNOWN")
+  if(GPU_ARCH STREQUAL "AUTO")
+      detect_gpu_arch("AUTO")
+  else()
+    set(TARGET_ARCH ${GPU_ARCH})
+  endif()
+  add_custom_command(
+    OUTPUT ${OUT_HEADER}
+    COMMAND ${CMAKE_COMMAND}
+            -DOUT_HEADER=${OUT_HEADER}
+            -DGPU_PARAM_JSON=${GPU_PARAM_JSON}
+            -DTARGET_ARCH_SHORT=${TARGET_ARCH}
+            -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/gpu_param_header_generator.cmake
+    DEPENDS
+            ${CMAKE_CURRENT_SOURCE_DIR}/cmake/gpu_param_header_generator.cmake
+            ${GPU_PARAM_JSON}
+    COMMENT "Generating GPU parameter header for ${TARGET_ARCH}"
+    VERBATIM
+  )
+  add_custom_target(GPU_PARAM_HEADER_${GPU_ARCH}_ALL ALL DEPENDS ${OUT_HEADER})
+endfunction()
\ No newline at end of file
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
new file mode 100644
index 0000000000000..3949322b5abfa
--- /dev/null
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -0,0 +1,105 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+# file gpu_param_header_generator.cmake
+# author Gabriele Cimador
+
+file(READ "${GPU_PARAM_JSON}" JSON_CONTENT)
+set(TMP_HEADER "${OUT_HEADER}.tmp")
+file(WRITE "${TMP_HEADER}" "#ifndef GPUDEFPARAMETERSDEFAULTS_H\n#define GPUDEFPARAMETERSDEFAULTS_H\n\n")
+file(APPEND "${TMP_HEADER}" "// This file is auto-generated from gpu_params.json. Do not edit directly.\n")
+string(REPLACE "," ";" ARCH_LIST "${TARGET_ARCH_SHORT}")
+file(APPEND "${TMP_HEADER}" "// Architectures: ${TARGET_ARCH_SHORT}\n\n")
+file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.\n\n")
+
+# Types
+set(TYPES CORE LB PAR)
+foreach(ARCH IN LISTS ARCH_LIST)
+    file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUTYPE_${ARCH})\n\n")
+    foreach(TYPE IN LISTS TYPES)
+        # Get all keys of this TYPE as a semicolon-separated list
+        string(JSON n_params LENGTH "${JSON_CONTENT}" "${TYPE}")
+        math(EXPR last "${n_params} - 1")
+        foreach(i RANGE 0 ${last})
+            string(JSON param_name MEMBER "${JSON_CONTENT}" "${TYPE}" "${i}")
+            string(JSON n_archs LENGTH "${JSON_CONTENT}" "${TYPE}" "${param_name}")
+            math(EXPR last_arch "${n_archs} - 1")
+
+            foreach(iArch RANGE 0 ${last_arch})
+                string(JSON arch MEMBER "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${iArch}")
+                if(arch STREQUAL "${ARCH}")
+                    string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${ARCH}")
+                    if(TYPE STREQUAL "LB")
+                        set(MACRO_NAME "GPUCA_LB_${param_name}")
+                    elseif(TYPE STREQUAL "PAR")
+                        set(MACRO_NAME "GPUCA_PAR_${param_name}")
+                    else()
+                        set(MACRO_NAME "GPUCA_${param_name}")
+                    endif()
+                    set(vals "${param_values}")
+                    string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
+                    string(REGEX REPLACE " *\\]$" "" vals "${vals}")
+                    string(REGEX REPLACE "\"" "" vals "${vals}")
+                    set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
+                    file(APPEND "${TMP_HEADER}" "${MACRO_DEFINITION}\n")
+                endif()
+            endforeach()
+        endforeach()
+    endforeach()
+    file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUTYPE_${ARCH}\n\n")
+endforeach()
+
+file(APPEND "${TMP_HEADER}" "\n// Default parameters if not defined for the target architecture\n\n")
+#Default parameters
+foreach(TYPE IN LISTS TYPES)
+    # Get all keys of this TYPE as a semicolon-separated list
+    string(JSON n_params LENGTH "${JSON_CONTENT}" "${TYPE}")
+    math(EXPR last "${n_params} - 1")
+    foreach(i RANGE 0 ${last})
+        string(JSON param_name MEMBER "${JSON_CONTENT}" "${TYPE}" "${i}")
+        string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "default")
+        if(TYPE STREQUAL "LB")
+            set(MACRO_NAME "GPUCA_LB_${param_name}")
+        elseif(TYPE STREQUAL "PAR")
+            set(MACRO_NAME "GPUCA_PAR_${param_name}")
+        else()
+            set(MACRO_NAME "GPUCA_${param_name}")
+        endif()
+        set(vals "${param_values}")
+        string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
+        string(REGEX REPLACE " *\\]$" "" vals "${vals}")
+        string(REGEX REPLACE "\"" "" vals "${vals}")
+        set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
+        file(APPEND "${TMP_HEADER}" "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+    endforeach()
+endforeach()
+file(APPEND "${TMP_HEADER}" "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
+
+#Defaults for non-LB parameters also for CPU fallback
+file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC //Defaults for non-LB parameters also for CPU fallback\n\n")    # Get all keys of this TYPE as a semicolon-separated list
+string(JSON n_params LENGTH "${JSON_CONTENT}" "PAR")
+math(EXPR last "${n_params} - 1")
+foreach(i RANGE 0 ${last})
+    string(JSON param_name MEMBER "${JSON_CONTENT}" "PAR" "${i}")
+    string(JSON param_values GET "${JSON_CONTENT}" "PAR" "${param_name}" "default_cpu")
+    set(MACRO_NAME "GPUCA_PAR_${param_name}")
+    set(vals "${param_values}")
+    string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
+    string(REGEX REPLACE " *\\]$" "" vals "${vals}")
+    string(REGEX REPLACE "\"" "" vals "${vals}")
+    set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
+    file(APPEND "${TMP_HEADER}" "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+endforeach()
+file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUCODE_GENRTC\n")
+
+file(APPEND "${TMP_HEADER}" "\n#endif // GPUDEFPARAMETERSDEFAULTS_H\n")
+file(RENAME "${TMP_HEADER}" "${OUT_HEADER}")
+message(STATUS "Generated ${OUT_HEADER}")
diff --git a/GPU/documentation/build-O2.md b/GPU/documentation/build-O2.md
index dd21f7e154a63..b04fe562b8c2f 100644
--- a/GPU/documentation/build-O2.md
+++ b/GPU/documentation/build-O2.md
@@ -37,7 +37,7 @@ Advantages:
 - One can see enabled GPU features / versions / architectures in the version string of `gpu-system`.
 
 Disadvantages:
-- Need system `CMake` >= `3.26` for the detsction at aliBuild level.
+- Need system `CMake` >= `3.26` for the detection at aliBuild level.
 - `FindO2GPU.cmake` is duplicated in O2 and alidist and must be kept in sync. But at least this is checked and gives an error otherwise.
 - Running cmake during the system check takes around 5 sec for every aliBuild command involving O2 or ONNX.
 
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 21e2d7cad239a..3cfcaef82fcca 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 9
+# FindO2GPU.cmake Version 10
 
 set(CUDA_COMPUTETARGET_DEFAULT_FULL 80-real 86-real 89-real 120-real 75-virtual)
 set(HIP_AMDGPUTARGET_DEFAULT_FULL gfx906;gfx908)
@@ -44,34 +44,53 @@ if(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET STREQUAL "default")
   set(HIP_AMDGPUTARGET ${HIP_AMDGPUTARGET_DEFAULT_FULL})
 endif()
 
-function(set_target_cuda_arch target)
-  if(CUDA_COMPUTETARGET AND (CUDA_COMPUTETARGET MATCHES "86" OR CUDA_COMPUTETARGET MATCHES "89"))
+function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterring by backend
+  set(TARGET_ARCH "")
+  set(CUDA_TARGET "")
+  set(HIP_TARGET "")
+
+  if(CUDA_COMPUTETARGET AND CUDA_COMPUTETARGET MATCHES "86|89")
+    set(CUDA_TARGET AMPERE)
     message(STATUS "Using optimized CUDA settings for Ampere GPU")
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_AMPERE)
   elseif(CUDA_COMPUTETARGET AND CUDA_COMPUTETARGET MATCHES "75")
+    set(CUDA_TARGET TURING)
     message(STATUS "Using optimized CUDA settings for Turing GPU")
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_TURING)
   else()
+    set(CUDA_TARGET AMPERE)
     message(STATUS "Defaulting optimized CUDA settings for Ampere GPU")
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_AMPERE)
   endif()
-endfunction()
 
-function(set_target_hip_arch target)
   if(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET MATCHES "gfx906")
+    set(HIP_TARGET VEGA)
     message(STATUS "Using optimized HIP settings for MI50 GPU")
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_VEGA)
   elseif(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET MATCHES "gfx908")
+    set(HIP_TARGET MI100)
     message(STATUS "Using optimized HIP settings for MI100 GPU")
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_MI100)
   elseif(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET MATCHES "gfx90a")
+    set(HIP_TARGET MI100)
     message(STATUS "Using optimized HIP settings for MI210 GPU")
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_MI100)
   else()
-    target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_VEGA)
+    set(HIP_TARGET VEGA)
+    message(STATUS "Defaulting optimized HIP settings for VEGA GPU")
+  endif()
+
+  if(backend STREQUAL "CUDA") # CUDA filter
+    set(TARGET_ARCH "${CUDA_TARGET}" PARENT_SCOPE)
+    return()
+  elseif(backend STREQUAL "HIP") # HIP filter
+    set(TARGET_ARCH "${HIP_TARGET}" PARENT_SCOPE)
+    return()
+  else() # Return both
+    set(TARGET_ARCH "${CUDA_TARGET},${HIP_TARGET}" PARENT_SCOPE)
   endif()
 endfunction()
 
+function(set_target_gpu_arch backend target)
+  detect_gpu_arch("${backend}")
+  message(STATUS "Compiling for ${TARGET_ARCH}")
+  target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_${TARGET_ARCH})
+endfunction()
+
 # Need to strip c++17 imposed by alidist defaults
 STRING(REGEX REPLACE "\-std=[^ ]*" "" O2_GPU_CMAKE_CXX_FLAGS_NOSTD "${CMAKE_CXX_FLAGS}")
 
diff --git a/log.txt b/log.txt
new file mode 100644
index 0000000000000..e69de29bb2d1d

From f683cac8423902087d678de4181d4a2089376296 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <gab.cima22@gmail.com>
Date: Wed, 28 Jan 2026 17:53:20 +0100
Subject: [PATCH 1267/1764] GPU Framework: refactor generation of default GPU
 parameters

---
 GPU/GPUTracking/CMakeLists.txt                |   2 +-
 .../Definitions/Parameters/.clang-format      |   1 +
 .../{ => Parameters}/.clang-format-ignore     |   0
 .../{ => Parameters}/GPUParameters.json       |   0
 .../cmake/generateGPUParamHeader.cmake        |  37 ------
 .../cmake/gpu_param_header_generator.cmake    | 117 ++++++++----------
 dependencies/FindO2GPU.cmake                  |   8 +-
 7 files changed, 58 insertions(+), 107 deletions(-)
 create mode 100644 GPU/GPUTracking/Definitions/Parameters/.clang-format
 rename GPU/GPUTracking/Definitions/{ => Parameters}/.clang-format-ignore (100%)
 rename GPU/GPUTracking/Definitions/{ => Parameters}/GPUParameters.json (100%)
 delete mode 100644 GPU/GPUTracking/cmake/generateGPUParamHeader.cmake

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index a2d91b6ed4c5e..816d578fb31a3 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -109,7 +109,7 @@ set(SRCS_NO_H SectorTracker/GPUTPCTrackerDump.cxx
 
 set(ON_THE_FLY_DIR ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
 file(MAKE_DIRECTORY ${ON_THE_FLY_DIR})
-include(cmake/generateGPUParamHeader.cmake)
+include(cmake/gpu_param_header_generator.cmake)
 set(GPU_DEFAULT_PARAMS_HEADER ${ON_THE_FLY_DIR}/GPUDefParametersDefaults.h)
 generate_gpu_param_header("AUTO" ${GPU_DEFAULT_PARAMS_HEADER}) # generate header with default GPU parameters, arch selected by CMake variables
 
diff --git a/GPU/GPUTracking/Definitions/Parameters/.clang-format b/GPU/GPUTracking/Definitions/Parameters/.clang-format
new file mode 100644
index 0000000000000..e3845288a2aec
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/Parameters/.clang-format
@@ -0,0 +1 @@
+DisableFormat: true
diff --git a/GPU/GPUTracking/Definitions/.clang-format-ignore b/GPU/GPUTracking/Definitions/Parameters/.clang-format-ignore
similarity index 100%
rename from GPU/GPUTracking/Definitions/.clang-format-ignore
rename to GPU/GPUTracking/Definitions/Parameters/.clang-format-ignore
diff --git a/GPU/GPUTracking/Definitions/GPUParameters.json b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
similarity index 100%
rename from GPU/GPUTracking/Definitions/GPUParameters.json
rename to GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
diff --git a/GPU/GPUTracking/cmake/generateGPUParamHeader.cmake b/GPU/GPUTracking/cmake/generateGPUParamHeader.cmake
deleted file mode 100644
index 712bf4641b825..0000000000000
--- a/GPU/GPUTracking/cmake/generateGPUParamHeader.cmake
+++ /dev/null
@@ -1,37 +0,0 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-# All rights not expressly granted are reserved.
-#
-# This software is distributed under the terms of the GNU General Public
-# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-#
-# In applying this license CERN does not waive the privileges and immunities
-# granted to it by virtue of its status as an Intergovernmental Organization
-# or submit itself to any jurisdiction.
-
-# file generateGPUParamHeader.cmake
-# author Gabriele Cimador
-
-function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
-  set(GPU_PARAM_JSON ${CMAKE_SOURCE_DIR}/GPU/GPUTracking/Definitions/GPUParameters.json)
-  set(TARGET_ARCH "UNKNOWN")
-  if(GPU_ARCH STREQUAL "AUTO")
-      detect_gpu_arch("AUTO")
-  else()
-    set(TARGET_ARCH ${GPU_ARCH})
-  endif()
-  add_custom_command(
-    OUTPUT ${OUT_HEADER}
-    COMMAND ${CMAKE_COMMAND}
-            -DOUT_HEADER=${OUT_HEADER}
-            -DGPU_PARAM_JSON=${GPU_PARAM_JSON}
-            -DTARGET_ARCH_SHORT=${TARGET_ARCH}
-            -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/gpu_param_header_generator.cmake
-    DEPENDS
-            ${CMAKE_CURRENT_SOURCE_DIR}/cmake/gpu_param_header_generator.cmake
-            ${GPU_PARAM_JSON}
-    COMMENT "Generating GPU parameter header for ${TARGET_ARCH}"
-    VERBATIM
-  )
-  add_custom_target(GPU_PARAM_HEADER_${GPU_ARCH}_ALL ALL DEPENDS ${OUT_HEADER})
-endfunction()
\ No newline at end of file
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index 3949322b5abfa..38b92421616f2 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -12,31 +12,18 @@
 # file gpu_param_header_generator.cmake
 # author Gabriele Cimador
 
-file(READ "${GPU_PARAM_JSON}" JSON_CONTENT)
-set(TMP_HEADER "${OUT_HEADER}.tmp")
-file(WRITE "${TMP_HEADER}" "#ifndef GPUDEFPARAMETERSDEFAULTS_H\n#define GPUDEFPARAMETERSDEFAULTS_H\n\n")
-file(APPEND "${TMP_HEADER}" "// This file is auto-generated from gpu_params.json. Do not edit directly.\n")
-string(REPLACE "," ";" ARCH_LIST "${TARGET_ARCH_SHORT}")
-file(APPEND "${TMP_HEADER}" "// Architectures: ${TARGET_ARCH_SHORT}\n\n")
-file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.\n\n")
-
-# Types
-set(TYPES CORE LB PAR)
-foreach(ARCH IN LISTS ARCH_LIST)
-    file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUTYPE_${ARCH})\n\n")
-    foreach(TYPE IN LISTS TYPES)
-        # Get all keys of this TYPE as a semicolon-separated list
-        string(JSON n_params LENGTH "${JSON_CONTENT}" "${TYPE}")
+function(generate_macros json_content header types arch_key use_ifndef_guard)
+    foreach(TYPE IN LISTS types)
+        string(JSON n_params LENGTH "${json_content}" "${TYPE}")
         math(EXPR last "${n_params} - 1")
         foreach(i RANGE 0 ${last})
-            string(JSON param_name MEMBER "${JSON_CONTENT}" "${TYPE}" "${i}")
+            string(JSON param_name MEMBER "${json_content}" "${TYPE}" "${i}")
             string(JSON n_archs LENGTH "${JSON_CONTENT}" "${TYPE}" "${param_name}")
             math(EXPR last_arch "${n_archs} - 1")
-
             foreach(iArch RANGE 0 ${last_arch})
                 string(JSON arch MEMBER "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${iArch}")
-                if(arch STREQUAL "${ARCH}")
-                    string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${ARCH}")
+                if(arch STREQUAL "${arch_key}")
+                    string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch_key}")
                     if(TYPE STREQUAL "LB")
                         set(MACRO_NAME "GPUCA_LB_${param_name}")
                     elseif(TYPE STREQUAL "PAR")
@@ -49,57 +36,57 @@ foreach(ARCH IN LISTS ARCH_LIST)
                     string(REGEX REPLACE " *\\]$" "" vals "${vals}")
                     string(REGEX REPLACE "\"" "" vals "${vals}")
                     set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
-                    file(APPEND "${TMP_HEADER}" "${MACRO_DEFINITION}\n")
+                    if(use_ifndef_guard)
+                        # fallback defaults are wrapped in #ifndef
+                        file(APPEND "${header}" "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+                    else()
+                        file(APPEND "${header}" "${MACRO_DEFINITION}\n")
+                    endif()
                 endif()
             endforeach()
         endforeach()
     endforeach()
-    file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUTYPE_${ARCH}\n\n")
-endforeach()
+endfunction()
+
+function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
+    set(GPU_PARAM_JSON ${CMAKE_SOURCE_DIR}/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json)
+    set(TARGET_ARCH "UNKNOWN")
+    if(GPU_ARCH STREQUAL "AUTO")
+        detect_gpu_arch("ALL")
+    else()
+        set(TARGET_ARCH ${GPU_ARCH})
+    endif()
+    file(READ "${GPU_PARAM_JSON}" JSON_CONTENT)
+    set(TMP_HEADER "${OUT_HEADER}.tmp")
+    message(STATUS "OUT_HEADER = '${OUT_HEADER}'")
+    message(STATUS "TMP_HEADER = '${TMP_HEADER}'")
+    file(WRITE "${TMP_HEADER}" "#ifndef GPUDEFPARAMETERSDEFAULTS_H\n#define GPUDEFPARAMETERSDEFAULTS_H\n\n")
+    file(APPEND "${TMP_HEADER}" "// This file is auto-generated from gpu_params.json. Do not edit directly.\n")
+    string(REPLACE "," ";" ARCH_LIST "${TARGET_ARCH}")
+    file(APPEND "${TMP_HEADER}" "// Architectures: ${TARGET_ARCH}\n\n")
+    file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.\n\n")
 
-file(APPEND "${TMP_HEADER}" "\n// Default parameters if not defined for the target architecture\n\n")
-#Default parameters
-foreach(TYPE IN LISTS TYPES)
-    # Get all keys of this TYPE as a semicolon-separated list
-    string(JSON n_params LENGTH "${JSON_CONTENT}" "${TYPE}")
-    math(EXPR last "${n_params} - 1")
-    foreach(i RANGE 0 ${last})
-        string(JSON param_name MEMBER "${JSON_CONTENT}" "${TYPE}" "${i}")
-        string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "default")
-        if(TYPE STREQUAL "LB")
-            set(MACRO_NAME "GPUCA_LB_${param_name}")
-        elseif(TYPE STREQUAL "PAR")
-            set(MACRO_NAME "GPUCA_PAR_${param_name}")
-        else()
-            set(MACRO_NAME "GPUCA_${param_name}")
-        endif()
-        set(vals "${param_values}")
-        string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
-        string(REGEX REPLACE " *\\]$" "" vals "${vals}")
-        string(REGEX REPLACE "\"" "" vals "${vals}")
-        set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
-        file(APPEND "${TMP_HEADER}" "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+    # Types
+    set(TYPES CORE LB PAR)
+    # Per architecture definitions
+    foreach(ARCH IN LISTS ARCH_LIST)
+    file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUTYPE_${ARCH})\n\n")
+    generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "${TYPES}" "${ARCH}" "")
+    file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUTYPE_${ARCH}\n\n")
     endforeach()
-endforeach()
-file(APPEND "${TMP_HEADER}" "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
 
-#Defaults for non-LB parameters also for CPU fallback
-file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC //Defaults for non-LB parameters also for CPU fallback\n\n")    # Get all keys of this TYPE as a semicolon-separated list
-string(JSON n_params LENGTH "${JSON_CONTENT}" "PAR")
-math(EXPR last "${n_params} - 1")
-foreach(i RANGE 0 ${last})
-    string(JSON param_name MEMBER "${JSON_CONTENT}" "PAR" "${i}")
-    string(JSON param_values GET "${JSON_CONTENT}" "PAR" "${param_name}" "default_cpu")
-    set(MACRO_NAME "GPUCA_PAR_${param_name}")
-    set(vals "${param_values}")
-    string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
-    string(REGEX REPLACE " *\\]$" "" vals "${vals}")
-    string(REGEX REPLACE "\"" "" vals "${vals}")
-    set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
-    file(APPEND "${TMP_HEADER}" "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
-endforeach()
-file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUCODE_GENRTC\n")
+    # Default parameters
+    file(APPEND "${TMP_HEADER}" "\n// Default parameters if not defined for the target architecture\n\n")
+    generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "${TYPES}" "default" "use_ifndef_guard")
+    file(APPEND "${TMP_HEADER}" "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
+
+    # CPU fallback
+    file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC //Defaults for non-LB parameters also for CPU fallback\n\n")    # Get all keys of this TYPE as a semicolon-separated list
+    generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "PAR" "default_cpu" "use_ifndef_guard")
+    file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUCODE_GENRTC\n")
 
-file(APPEND "${TMP_HEADER}" "\n#endif // GPUDEFPARAMETERSDEFAULTS_H\n")
-file(RENAME "${TMP_HEADER}" "${OUT_HEADER}")
-message(STATUS "Generated ${OUT_HEADER}")
+    file(APPEND "${TMP_HEADER}" "\n#endif // GPUDEFPARAMETERSDEFAULTS_H\n")
+    file(RENAME "${TMP_HEADER}" "${OUT_HEADER}")
+    message(STATUS "Generated ${OUT_HEADER}")
+    add_custom_target(GPU_PARAM_HEADER_${GPU_ARCH}_ALL ALL DEPENDS ${OUT_HEADER} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/gpu_param_header_generator.cmake ${GPU_PARAM_JSON})
+endfunction()
\ No newline at end of file
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 3cfcaef82fcca..4ed29ec61f3e1 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -45,9 +45,6 @@ if(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET STREQUAL "default")
 endif()
 
 function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterring by backend
-  set(TARGET_ARCH "")
-  set(CUDA_TARGET "")
-  set(HIP_TARGET "")
 
   if(CUDA_COMPUTETARGET AND CUDA_COMPUTETARGET MATCHES "86|89")
     set(CUDA_TARGET AMPERE)
@@ -80,8 +77,11 @@ function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterri
   elseif(backend STREQUAL "HIP") # HIP filter
     set(TARGET_ARCH "${HIP_TARGET}" PARENT_SCOPE)
     return()
-  else() # Return both
+  elseif(backend STREQUAL "ALL") # Return both
     set(TARGET_ARCH "${CUDA_TARGET},${HIP_TARGET}" PARENT_SCOPE)
+    return()
+  else()
+    message(FATAL_ERROR "Unknown backend provided: ${backend}")
   endif()
 endfunction()
 

From fe431a1ae55bf5a05e617210f7fab1f4f35aa378 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <gab.cima22@gmail.com>
Date: Thu, 29 Jan 2026 13:16:58 +0100
Subject: [PATCH 1268/1764] GPU Framework: Add OpenCL support to GPU param
 header generation + update CFCheckPadBaseline parameters

---
 .../Definitions/Parameters/GPUParameters.json |  8 ++++----
 .../cmake/gpu_param_header_generator.cmake    | 20 ++++++++++++-------
 dependencies/FindO2GPU.cmake                  | 19 ++++++++++++------
 3 files changed, 30 insertions(+), 17 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
index e8f1c24520813..674efc9ea0912 100644
--- a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
+++ b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
@@ -338,10 +338,10 @@
       "TURING":   [512, 1]
     },
     "GPUTPCCFCheckPadBaseline": {
-      "default":  64,
-      "MI100":    [64, 10],
-      "VEGA":     [64, 2],
-      "AMPERE":   [64, 8]
+      "default":  576,
+      "MI100":    [576, 2],
+      "VEGA":     [576, 2],
+      "AMPERE":   [576, 2]
     },
     "GPUTPCCFChargeMapFiller_fillIndexMap": {
       "default":  512,
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index 38b92421616f2..3770e30f2583c 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -49,7 +49,7 @@ function(generate_macros json_content header types arch_key use_ifndef_guard)
 endfunction()
 
 function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
-    set(GPU_PARAM_JSON ${CMAKE_SOURCE_DIR}/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json)
+    set(GPU_PARAM_JSON ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/GPUParameters.json)
     set(TARGET_ARCH "UNKNOWN")
     if(GPU_ARCH STREQUAL "AUTO")
         detect_gpu_arch("ALL")
@@ -58,8 +58,6 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
     endif()
     file(READ "${GPU_PARAM_JSON}" JSON_CONTENT)
     set(TMP_HEADER "${OUT_HEADER}.tmp")
-    message(STATUS "OUT_HEADER = '${OUT_HEADER}'")
-    message(STATUS "TMP_HEADER = '${TMP_HEADER}'")
     file(WRITE "${TMP_HEADER}" "#ifndef GPUDEFPARAMETERSDEFAULTS_H\n#define GPUDEFPARAMETERSDEFAULTS_H\n\n")
     file(APPEND "${TMP_HEADER}" "// This file is auto-generated from gpu_params.json. Do not edit directly.\n")
     string(REPLACE "," ";" ARCH_LIST "${TARGET_ARCH}")
@@ -69,11 +67,19 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
     # Types
     set(TYPES CORE LB PAR)
     # Per architecture definitions
+    set(_first TRUE)
     foreach(ARCH IN LISTS ARCH_LIST)
-    file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUTYPE_${ARCH})\n\n")
-    generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "${TYPES}" "${ARCH}" "")
-    file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUTYPE_${ARCH}\n\n")
+        if(_first)
+            file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUTYPE_${ARCH})\n\n")
+            set(_first FALSE)
+        else()
+            file(APPEND "${TMP_HEADER}" "#elif defined(GPUCA_GPUTYPE_${ARCH})\n\n")
+        endif()
+        generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "${TYPES}" "${ARCH}" "")
     endforeach()
+    if(NOT _first)
+        file(APPEND "${TMP_HEADER}" "#else\n#error GPU TYPE NOT SET\n#endif\n")
+    endif()
 
     # Default parameters
     file(APPEND "${TMP_HEADER}" "\n// Default parameters if not defined for the target architecture\n\n")
@@ -81,7 +87,7 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
     file(APPEND "${TMP_HEADER}" "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
 
     # CPU fallback
-    file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC //Defaults for non-LB parameters also for CPU fallback\n\n")    # Get all keys of this TYPE as a semicolon-separated list
+    file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC //Defaults for non-LB parameters also for CPU fallback\n\n")
     generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "PAR" "default_cpu" "use_ifndef_guard")
     file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUCODE_GENRTC\n")
 
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 4ed29ec61f3e1..e02bf932ab784 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -73,13 +73,21 @@ function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterri
 
   if(backend STREQUAL "CUDA") # CUDA filter
     set(TARGET_ARCH "${CUDA_TARGET}" PARENT_SCOPE)
-    return()
   elseif(backend STREQUAL "HIP") # HIP filter
     set(TARGET_ARCH "${HIP_TARGET}" PARENT_SCOPE)
-    return()
-  elseif(backend STREQUAL "ALL") # Return both
-    set(TARGET_ARCH "${CUDA_TARGET},${HIP_TARGET}" PARENT_SCOPE)
-    return()
+  elseif(backend STREQUAL "ALL") # Return enabled backends
+    set(_archs "")
+    if(CUDA_ENABLED)
+      list(APPEND _archs "${CUDA_TARGET}")
+    endif()
+    if(HIP_ENABLED)
+      list(APPEND _archs "${HIP_TARGET}")
+    endif()
+    if(OPENCL_ENABLED)
+      list(APPEND _archs "OPENCL")
+    endif()
+    list(JOIN _archs "," TARGET_ARCH)
+    set(TARGET_ARCH "${TARGET_ARCH}" PARENT_SCOPE)
   else()
     message(FATAL_ERROR "Unknown backend provided: ${backend}")
   endif()
@@ -87,7 +95,6 @@ endfunction()
 
 function(set_target_gpu_arch backend target)
   detect_gpu_arch("${backend}")
-  message(STATUS "Compiling for ${TARGET_ARCH}")
   target_compile_definitions(${target} PUBLIC GPUCA_GPUTYPE_${TARGET_ARCH})
 endfunction()
 

From 5a15ab5c1b12b1010a439bcd16751e375059795f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 5 Feb 2026 11:47:27 +0100
Subject: [PATCH 1269/1764] GPU: Delete unused files (#15015)

* GPU: Remove unused files

* Add missing suffix

* Revert "Add missing suffix"

This reverts commit 81879979abeac8839164d57d33d65a392c4b3aea.

* Remove cxx suffix
---
 ...tGPUsortHIP.hip.cxx => testGPUsortHIP.hip} |   0
 .../SectorTracker/GPUTPCDefinitions.h         |  25 --
 .../utils/makefile_opencl_compiler.cxx        | 258 ------------------
 .../utils/opencl_compiler_structs.h           |  28 --
 GPU/GPUTracking/utils/opencl_obtain_program.h |  91 ------
 5 files changed, 402 deletions(-)
 rename GPU/GPUTracking/Base/hip/test/{testGPUsortHIP.hip.cxx => testGPUsortHIP.hip} (100%)
 delete mode 100644 GPU/GPUTracking/SectorTracker/GPUTPCDefinitions.h
 delete mode 100644 GPU/GPUTracking/utils/makefile_opencl_compiler.cxx
 delete mode 100644 GPU/GPUTracking/utils/opencl_compiler_structs.h
 delete mode 100644 GPU/GPUTracking/utils/opencl_obtain_program.h

diff --git a/GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip.cxx b/GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip
similarity index 100%
rename from GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip.cxx
rename to GPU/GPUTracking/Base/hip/test/testGPUsortHIP.hip
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCDefinitions.h b/GPU/GPUTracking/SectorTracker/GPUTPCDefinitions.h
deleted file mode 100644
index 7d9d607b9b88d..0000000000000
--- a/GPU/GPUTracking/SectorTracker/GPUTPCDefinitions.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file GPUTPCDefinitions.h
-/// \author Sergey Gorbunov, David Rohr
-
-#ifndef GPUTPCDEFINITIONS_H
-#define GPUTPCDEFINITIONS_H
-
-#include "AliHLTDataTypes.h"
-
-namespace GPUTPCDefinitions
-{
-extern const AliHLTComponentDataType fgkTrackletsDataType;
-}
-
-#endif // GPUTPCDEFINITIONS_H
diff --git a/GPU/GPUTracking/utils/makefile_opencl_compiler.cxx b/GPU/GPUTracking/utils/makefile_opencl_compiler.cxx
deleted file mode 100644
index f6400cc3369e0..0000000000000
--- a/GPU/GPUTracking/utils/makefile_opencl_compiler.cxx
+++ /dev/null
@@ -1,258 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file makefile_opencl_compiler.cxx
-/// \author David Rohr
-
-#define CL_TARGET_OPENCL_VERSION 220
-#define _CRT_SECURE_NO_WARNINGS
-#include "CL/opencl.h"
-#include <cstdlib>
-#include <cstdio>
-#include <cstring>
-#include <string>
-#include <vector>
-
-#include "opencl_compiler_structs.h"
-
-#define quit(arg)              \
-  {                            \
-    fprintf(stderr, arg "\n"); \
-    return (1);                \
-  }
-#define DEFAULT_OPENCL_COMPILER_OPTIONS ""
-#define DEFAULT_OUTPUT_FILE "opencl.out"
-
-int32_t main(int argc, char** argv)
-{
-  const char* output_file = DEFAULT_OUTPUT_FILE;
-  std::string compiler_options = DEFAULT_OPENCL_COMPILER_OPTIONS;
-  std::vector<char*> files;
-
-  printf("Passing command line options:\n");
-  bool add_option = false;
-  for (int32_t i = 1; i < argc; i++) {
-    if (add_option) {
-      compiler_options += " ";
-      compiler_options += argv[i];
-    } else if (strcmp(argv[i], "--") == 0) {
-      add_option = true;
-    } else if (strcmp(argv[i], "-output-file") == 0) {
-      if (++i >= argc) {
-        quit("Output file name missing");
-      }
-      output_file = argv[i];
-    } else {
-      fprintf(stderr, "%s\n", argv[i]);
-      files.push_back(argv[i]);
-    }
-  }
-
-  cl_int ocl_error;
-  cl_uint num_platforms;
-  if (clGetPlatformIDs(0, nullptr, &num_platforms) != CL_SUCCESS) {
-    quit("Error getting OpenCL Platform Count");
-  }
-  if (num_platforms == 0) {
-    quit("No OpenCL Platform found");
-  }
-  printf("%d OpenCL Platforms found\n", num_platforms);
-
-  // Query platforms
-  cl_platform_id* platforms = new cl_platform_id[num_platforms];
-  if (platforms == nullptr) {
-    quit("Memory allocation error");
-  }
-  if (clGetPlatformIDs(num_platforms, platforms, nullptr) != CL_SUCCESS) {
-    quit("Error getting OpenCL Platforms");
-  }
-
-  cl_platform_id platform;
-  bool found = false;
-
-  _makefiles_opencl_platform_info pinfo;
-  for (uint32_t i_platform = 0; i_platform < num_platforms; i_platform++) {
-    clGetPlatformInfo(platforms[i_platform], CL_PLATFORM_PROFILE, 64, pinfo.platform_profile, nullptr);
-    clGetPlatformInfo(platforms[i_platform], CL_PLATFORM_VERSION, 64, pinfo.platform_version, nullptr);
-    clGetPlatformInfo(platforms[i_platform], CL_PLATFORM_NAME, 64, pinfo.platform_name, nullptr);
-    clGetPlatformInfo(platforms[i_platform], CL_PLATFORM_VENDOR, 64, pinfo.platform_vendor, nullptr);
-    printf("Available Platform %u: (%s %s) %s %s\n", i_platform, pinfo.platform_profile, pinfo.platform_version, pinfo.platform_vendor, pinfo.platform_name);
-    if (strcmp(pinfo.platform_vendor, "Advanced Micro Devices, Inc.") == 0 && strcmp(pinfo.platform_version, "OpenCL 2.0 AMD-APP (1800.8)") == 0) {
-      found = true;
-      printf("AMD OpenCL Platform found (%u)\n", i_platform);
-      platform = platforms[i_platform];
-      break;
-    }
-  }
-  if (found == false) {
-    quit("Did not find AMD OpenCL Platform");
-  }
-
-  if (clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, 0, nullptr, &pinfo.count) != CL_SUCCESS) {
-    quit("Error getting OPENCL Device Count");
-  }
-
-  // Query devices
-  cl_device_id* devices = new cl_device_id[pinfo.count];
-  if (devices == nullptr) {
-    quit("Memory allocation error");
-  }
-  if (clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, pinfo.count, devices, nullptr) != CL_SUCCESS) {
-    quit("Error getting OpenCL devices");
-  }
-
-  _makefiles_opencl_device_info dinfo;
-  cl_device_type device_type;
-  cl_uint freq, shaders;
-
-  printf("Available OPENCL devices:\n");
-  for (uint32_t i = 0; i < pinfo.count; i++) {
-    printf("Examining device %u\n", i);
-
-    clGetDeviceInfo(devices[i], CL_DEVICE_NAME, 64, dinfo.device_name, nullptr);
-    clGetDeviceInfo(devices[i], CL_DEVICE_VENDOR, 64, dinfo.device_vendor, nullptr);
-    clGetDeviceInfo(devices[i], CL_DEVICE_TYPE, sizeof(cl_device_type), &device_type, nullptr);
-    clGetDeviceInfo(devices[i], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(freq), &freq, nullptr);
-    clGetDeviceInfo(devices[i], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(shaders), &shaders, nullptr);
-    clGetDeviceInfo(devices[i], CL_DEVICE_ADDRESS_BITS, sizeof(dinfo.nbits), &dinfo.nbits, nullptr);
-    printf("Found Device %u : %s %s (Frequency %d, Shaders %d, %d bit)\n", i, dinfo.device_vendor, dinfo.device_name, (int32_t)freq, (int32_t)shaders, (int32_t)dinfo.nbits);
-  }
-
-  if (files.size() == 0) {
-    quit("Syntax: opencl [-output-file OUTPUT_FILE] FILE1 [FILE2] ... [FILEn] [-- COMPILER_OPTION_1] [COMPILER_OPTION_2] ... [COMPILER_OPTION_N]");
-  }
-
-  char** buffers = (char**)malloc(files.size() * sizeof(char*));
-  if (buffers == nullptr) {
-    quit("Memory allocation error\n");
-  }
-  for (uint32_t i = 0; i < files.size(); i++) {
-    printf("Reading source file %s\n", files[i]);
-    FILE* fp = fopen(files[i], "rb");
-    if (fp == nullptr) {
-      printf("Cannot open %s\n", files[i]);
-      free(buffers);
-      return (1);
-    }
-    fseek(fp, 0, SEEK_END);
-    size_t file_size = ftell(fp);
-    fseek(fp, 0, SEEK_SET);
-
-    buffers[i] = (char*)malloc(file_size + 1);
-    if (buffers[i] == nullptr) {
-      quit("Memory allocation error");
-    }
-    if (fread(buffers[i], 1, file_size, fp) != file_size) {
-      quit("Error reading file");
-    }
-    buffers[i][file_size] = 0;
-    fclose(fp);
-  }
-
-  printf("Creating OpenCL Context\n");
-  // Create OpenCL context
-  cl_context context = clCreateContext(nullptr, pinfo.count, devices, nullptr, nullptr, &ocl_error);
-  if (ocl_error != CL_SUCCESS) {
-    quit("Error creating OpenCL context");
-  }
-
-  printf("Creating OpenCL Program Object\n");
-  // Create OpenCL program object
-  cl_program program = clCreateProgramWithSource(context, (cl_uint)files.size(), (const char**)buffers, nullptr, &ocl_error);
-  if (ocl_error != CL_SUCCESS) {
-    quit("Error creating program object");
-  }
-
-  printf("Compiling OpenCL Program\n");
-  // Compile program
-  ocl_error = clBuildProgram(program, pinfo.count, devices, compiler_options.c_str(), nullptr, nullptr);
-  if (ocl_error != CL_SUCCESS) {
-    fprintf(stderr, "OpenCL Error while building program: %d (Compiler options: %s)\n", ocl_error, compiler_options.c_str());
-    fprintf(stderr, "OpenCL Kernel:\n\n");
-    for (uint32_t i = 0; i < files.size(); i++) {
-      printf("%s\n\n", buffers[i]);
-    }
-
-    for (uint32_t i = 0; i < pinfo.count; i++) {
-      cl_build_status status;
-      clGetProgramBuildInfo(program, devices[i], CL_PROGRAM_BUILD_STATUS, sizeof(status), &status, nullptr);
-      if (status == CL_BUILD_ERROR) {
-        size_t log_size;
-        clGetProgramBuildInfo(program, devices[i], CL_PROGRAM_BUILD_LOG, 0, nullptr, &log_size);
-        char* build_log = (char*)malloc(log_size + 1);
-        if (build_log == nullptr) {
-          quit("Memory allocation error");
-        }
-        clGetProgramBuildInfo(program, devices[i], CL_PROGRAM_BUILD_LOG, log_size, build_log, nullptr);
-        fprintf(stderr, "Build Log (device %d):\n\n%s\n\n", i, build_log);
-        free(build_log);
-      }
-    }
-  }
-  for (uint32_t i = 0; i < files.size(); i++) {
-    free(buffers[i]);
-  }
-  free(buffers);
-  if (ocl_error != CL_SUCCESS) {
-    return (1);
-  }
-
-  printf("Obtaining program binaries\n");
-  size_t* binary_sizes = (size_t*)malloc(pinfo.count * sizeof(size_t));
-  if (binary_sizes == nullptr) {
-    quit("Memory allocation error");
-  }
-  clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES, pinfo.count * sizeof(size_t), binary_sizes, nullptr);
-  char** binary_buffers = (char**)malloc(pinfo.count * sizeof(char*));
-  if (binary_buffers == nullptr) {
-    quit("Memory allocation error");
-  }
-  for (uint32_t i = 0; i < pinfo.count; i++) {
-    printf("Binary size for device %d: %d\n", i, (int32_t)binary_sizes[i]);
-    binary_buffers[i] = (char*)malloc(binary_sizes[i]);
-    memset(binary_buffers[i], 0, binary_sizes[i]);
-    if (binary_buffers[i] == nullptr) {
-      quit("Memory allocation error");
-    }
-  }
-  clGetProgramInfo(program, CL_PROGRAM_BINARIES, pinfo.count * sizeof(char*), binary_buffers, nullptr);
-
-  printf("Programs obtained successfully, cleaning up opencl\n");
-  clReleaseProgram(program);
-  clReleaseContext(context);
-
-  printf("Writing binaries to file (%s)\n", output_file);
-  FILE* fp;
-  fp = fopen(output_file, "w+b");
-  if (fp == nullptr) {
-    quit("Error opening output file\n");
-  }
-  const char* magic_bytes = "QOCLPB";
-  fwrite(magic_bytes, 1, strlen(magic_bytes) + 1, fp);
-  fwrite(&pinfo, 1, sizeof(pinfo), fp);
-  for (uint32_t i = 0; i < pinfo.count; i++) {
-    clGetDeviceInfo(devices[i], CL_DEVICE_NAME, 64, dinfo.device_name, nullptr);
-    clGetDeviceInfo(devices[i], CL_DEVICE_VENDOR, 64, dinfo.device_vendor, nullptr);
-    dinfo.binary_size = binary_sizes[i];
-    fwrite(&dinfo, 1, sizeof(dinfo), fp);
-    fwrite(binary_buffers[i], 1, binary_sizes[i], fp);
-  }
-  fclose(fp);
-
-  printf("All done, cleaning up remaining buffers\n");
-  for (uint32_t i = 0; i < pinfo.count; i++) {
-    free(binary_buffers[i]);
-  }
-  free(binary_sizes);
-  free(binary_buffers);
-
-  return (0);
-}
diff --git a/GPU/GPUTracking/utils/opencl_compiler_structs.h b/GPU/GPUTracking/utils/opencl_compiler_structs.h
deleted file mode 100644
index 68e0a4f184480..0000000000000
--- a/GPU/GPUTracking/utils/opencl_compiler_structs.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file opencl_compiler_structs.h
-/// \author David Rohr
-
-struct _makefiles_opencl_platform_info {
-  char platform_profile[64];
-  char platform_version[64];
-  char platform_name[64];
-  char platform_vendor[64];
-  cl_uint count;
-};
-
-struct _makefiles_opencl_device_info {
-  char device_name[64];
-  char device_vendor[64];
-  cl_uint nbits;
-  size_t binary_size;
-};
diff --git a/GPU/GPUTracking/utils/opencl_obtain_program.h b/GPU/GPUTracking/utils/opencl_obtain_program.h
deleted file mode 100644
index 6c10ca9d47de1..0000000000000
--- a/GPU/GPUTracking/utils/opencl_obtain_program.h
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file opencl_obtain_program.h
-/// \author David Rohr
-
-#ifndef MAKEFILES_OPENCL_OBTAIN_PROGRAMH
-#define MAKEFILES_OPENCL_OBTAIN_PROGRAMH
-
-#include <CL/opencl.h>
-#include <vector>
-#include "opencl_compiler_structs.h"
-
-static int32_t _makefiles_opencl_obtain_program_helper(cl_context context, cl_uint num_devices, cl_device_id* devices, cl_program* program, char* binaries)
-{
-  const char* magic_bytes = "QOCLPB";
-  if (strncmp(magic_bytes, binaries, strlen(magic_bytes)) != 0) {
-    printf("Internal error accessing opencl program\n");
-    return (1);
-  }
-  char* current_ptr = binaries + strlen(magic_bytes) + 1;
-  _makefiles_opencl_platform_info* pinfo = (_makefiles_opencl_platform_info*)current_ptr;
-  current_ptr += sizeof(_makefiles_opencl_platform_info);
-
-  if (num_devices != pinfo->count) {
-    printf("Number of devices differs from number of devices in opencl program\n");
-    return (1);
-  }
-  // printf("Obtaining program for OpenCL Platform: (%s %s) %s %s\n", pinfo->platform_profile, pinfo->platform_version, pinfo->platform_vendor, pinfo->platform_name);
-
-  std::vector<size_t> program_sizes(pinfo->count);
-  std::vector<char*> program_binaries(pinfo->count);
-
-  for (uint32_t i = 0; i < pinfo->count; i++) {
-    char device_name[64], device_vendor[64];
-    cl_uint nbits;
-    clGetDeviceInfo(devices[i], CL_DEVICE_NAME, 64, device_name, nullptr);
-    clGetDeviceInfo(devices[i], CL_DEVICE_VENDOR, 64, device_vendor, nullptr);
-    clGetDeviceInfo(devices[i], CL_DEVICE_ADDRESS_BITS, sizeof(nbits), &nbits, nullptr);
-    _makefiles_opencl_device_info* dinfo = (_makefiles_opencl_device_info*)current_ptr;
-    if (strcmp(device_name, dinfo->device_name) != 0 || strcmp(device_vendor, dinfo->device_vendor) != 0) {
-      printf("Device list is different to device list from opencl program (Device %d: '%s - %s' != '%s - %s')\n", i, device_vendor, device_name, dinfo->device_vendor, dinfo->device_name);
-      return (1);
-    }
-    if (nbits != dinfo->nbits) {
-      printf("Pointer size of device and stored device binary differs\n");
-      return (1);
-    }
-    current_ptr += sizeof(_makefiles_opencl_device_info);
-    // printf("Device %d: %s %s (size %ld)\n", i, dinfo->device_vendor, dinfo->device_name, (int64_t) dinfo->binary_size);
-    program_sizes[i] = dinfo->binary_size;
-    program_binaries[i] = current_ptr;
-    current_ptr += dinfo->binary_size;
-  }
-
-  cl_int return_status[pinfo->count];
-  cl_int ocl_error;
-  *program = clCreateProgramWithBinary(context, num_devices, devices, program_sizes.data(), (const uint8_t**)program_binaries.data(), return_status, &ocl_error);
-
-  if (ocl_error != CL_SUCCESS) {
-    printf("Error loading program\n");
-    return (1);
-  }
-
-  for (uint32_t i = 0; i < pinfo->count; i++) {
-    if (return_status[i] != CL_SUCCESS) {
-      printf("Error loading program for device %d\n", i);
-      clReleaseProgram(*program);
-      return (1);
-    }
-  }
-
-  ocl_error = clBuildProgram(*program, num_devices, devices, "", nullptr, nullptr);
-  if (ocl_error != CL_SUCCESS) {
-    printf("Error building program\n");
-    clReleaseProgram(*program);
-    return (1);
-  }
-
-  return (0);
-}
-
-#endif

From d64bc8603cc75d8de8e6523d75ac49f83f265364 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 5 Feb 2026 12:07:23 +0100
Subject: [PATCH 1270/1764] Add the .clang-format-ignore (#15019)

---
 .clang-format-ignore | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .clang-format-ignore

diff --git a/.clang-format-ignore b/.clang-format-ignore
new file mode 100644
index 0000000000000..a6c57f5fb2ffb
--- /dev/null
+++ b/.clang-format-ignore
@@ -0,0 +1 @@
+*.json

From 414ba09ac65b6bfe4202cab6327246817dee2646 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Feb 2026 10:24:37 +0100
Subject: [PATCH 1271/1764] Add back tuned parameters for old architectures
 TAHITI TESLA FERMI PASCAL KEPLER

---
 .../Definitions/Parameters/.clang-format      |  1 -
 .../Parameters/.clang-format-ignore           |  1 -
 .../Definitions/Parameters/GPUParameters.json | 46 +++++++++++++++++--
 3 files changed, 41 insertions(+), 7 deletions(-)
 delete mode 100644 GPU/GPUTracking/Definitions/Parameters/.clang-format
 delete mode 100644 GPU/GPUTracking/Definitions/Parameters/.clang-format-ignore

diff --git a/GPU/GPUTracking/Definitions/Parameters/.clang-format b/GPU/GPUTracking/Definitions/Parameters/.clang-format
deleted file mode 100644
index e3845288a2aec..0000000000000
--- a/GPU/GPUTracking/Definitions/Parameters/.clang-format
+++ /dev/null
@@ -1 +0,0 @@
-DisableFormat: true
diff --git a/GPU/GPUTracking/Definitions/Parameters/.clang-format-ignore b/GPU/GPUTracking/Definitions/Parameters/.clang-format-ignore
deleted file mode 100644
index 5ffee2498bd7e..0000000000000
--- a/GPU/GPUTracking/Definitions/Parameters/.clang-format-ignore
+++ /dev/null
@@ -1 +0,0 @@
-GPUParameters.json
diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
index 674efc9ea0912..285919559c04c 100644
--- a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
+++ b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
@@ -1,11 +1,17 @@
 {
   "CORE": {
     "WARP_SIZE": {
-      "default":  32,
-      "MI100":    64,
-      "VEGA":     64,
-      "AMPERE":   32,
-      "TURING":   32
+      "default":      32,
+      "default_cpu":  1,
+      "MI100":        64,
+      "VEGA":         64,
+      "TAHITI":       32,
+      "TESLA":        32,
+      "FERMI":        32,
+      "PASCAL":       32,
+      "KEPLER":       32,
+      "AMPERE":       32,
+      "TURING":       32
     },
     "THREAD_COUNT_DEFAULT": {
       "default":  256,
@@ -27,6 +33,11 @@
       "default":  256,
       "MI100":    [768, 8],
       "VEGA":     [512, 10],
+      "TAHITI":   [256, 2],
+      "TESLA":    [256, 1],
+      "FERMI":    [256, 2],
+      "PASCAL":   [1024, 2],
+      "KEPLER":   [512, 4],
       "AMPERE":   [256, 2],
       "TURING":   [256, 2]
     },
@@ -34,6 +45,11 @@
       "default":  256,
       "MI100":    [384, 5],
       "VEGA":     [192, 10],
+      "TAHITI":   [256, 3],
+      "TESLA":    [256, 1],
+      "FERMI":    [256, 3],
+      "PASCAL":   [512, 4],
+      "KEPLER":   [256, 3],
       "AMPERE":   [192, 3],
       "TURING":   [192, 3]
     },
@@ -41,6 +57,11 @@
       "default":  256,
       "MI100":    [192, 8],
       "VEGA":     [960, 8],
+      "TAHITI":   256,
+      "TESLA":    256,
+      "FERMI":    256,
+      "PASCAL":   512,
+      "KEPLER":   256,
       "AMPERE":   [640, 1],
       "TURING":   [640, 1]
     },
@@ -48,6 +69,11 @@
       "default":  256,
       "MI100":    [128, 5],
       "VEGA":     [384, 9],
+      "TAHITI":   256,
+      "TESLA":    256,
+      "FERMI":    256,
+      "PASCAL":   256,
+      "KEPLER":   256,
       "AMPERE":   512,
       "TURING":   512
     },
@@ -327,6 +353,11 @@
       "default":  256,
       "MI100":    [1024, 2],
       "VEGA":     [1024, 7],
+      "TAHITI":   256,
+      "TESLA":    256,
+      "PASCAL":   256,
+      "FERMI":    256,
+      "KEPLER":   256,
       "AMPERE":   512,
       "TURING":   512
     },
@@ -334,6 +365,11 @@
       "default":  256,
       "MI100":    [1024, 5],
       "VEGA":     [512, 7],
+      "TAHITI":   256,
+      "TESLA":    256,
+      "PASCAL":   256,
+      "FERMI":    256,
+      "KEPLER":   256,
       "AMPERE":   [512, 1],
       "TURING":   [512, 1]
     },

From 024cbcab8238cc0a7c4a6259d518fabbfc498b91 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Feb 2026 10:29:50 +0100
Subject: [PATCH 1272/1764] Don't use 'No CUDA devices found' as CUDA
 architecture

---
 dependencies/FindO2GPU.cmake | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index e02bf932ab784..ec6b7323ad5d1 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 10
+# FindO2GPU.cmake Version 11
 
 set(CUDA_COMPUTETARGET_DEFAULT_FULL 80-real 86-real 89-real 120-real 75-virtual)
 set(HIP_AMDGPUTARGET_DEFAULT_FULL gfx906;gfx908)
@@ -173,9 +173,7 @@ if(ENABLE_CUDA)
       message(${FAILURE_SEVERITY} "CUDA was found but cannot be enabled")
       set(CMAKE_CUDA_COMPILER OFF)
     endif()
-    find_path(THRUST_INCLUDE_DIR thrust/version.h PATHS ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}
-	    PATH_SUFFIXES "" cccl
-	    NO_DEFAULT_PATH)
+    find_path(THRUST_INCLUDE_DIR thrust/version.h PATHS ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES} PATH_SUFFIXES "" cccl NO_DEFAULT_PATH)
     if(THRUST_INCLUDE_DIR STREQUAL "THRUST_INCLUDE_DIR-NOTFOUND")
       message(${FAILURE_SEVERITY} "CUDA found but thrust not available, looked under: ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}")
       set(CMAKE_CUDA_COMPILER OFF)
@@ -188,7 +186,7 @@ if(ENABLE_CUDA)
     endif()
   endif()
   if(NOT CMAKE_CUDA_ARCHITECTURES OR O2_GPU_CUDA_UPDATE_NATIVE_ARCHITECTURE)
-    if(NOT CMAKE_CUDA_ARCHITECTURES_NATIVE STREQUAL "")
+    if(NOT CMAKE_CUDA_ARCHITECTURES_NATIVE STREQUAL "" AND NOT CMAKE_CUDA_ARCHITECTURES_NATIVE MATCHES "No CUDA devices found")
       set(CMAKE_CUDA_ARCHITECTURES ${CMAKE_CUDA_ARCHITECTURES_NATIVE})
     else()
       set(CMAKE_CUDA_ARCHITECTURES ${CUDA_COMPUTETARGET_DEFAULT_MINIMAL})

From 9e910d691cb379f93c7c1dc7a09ee9193cddaa06 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Feb 2026 15:59:08 +0100
Subject: [PATCH 1273/1764] GPU: Add converter scripts for CSV parameter file
 to JSON and vice versa

---
 .../Base/cuda/GPUReconstructionCUDA.cu        |  2 +-
 .../Definitions/Parameters/csv_to_json.sh     | 46 +++++++++++++++++
 .../Definitions/Parameters/json_to_csv.python | 50 +++++++++++++++++++
 3 files changed, 97 insertions(+), 1 deletion(-)
 create mode 100755 GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
 create mode 100755 GPU/GPUTracking/Definitions/Parameters/json_to_csv.python

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index 8e896ca513f53..c919581eefdde 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -189,7 +189,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
         bestDeviceSpeed = deviceSpeed;
       } else {
         if (GetProcessingSettings().debugLevel >= 2 && GetProcessingSettings().deviceNum < 0) {
-          GPUInfo("Skipping: Speed %f < %f\n", deviceSpeed, bestDeviceSpeed);
+          GPUInfo("Skipping: Speed %f <= %f\n", deviceSpeed, bestDeviceSpeed);
         }
       }
     }
diff --git a/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh b/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
new file mode 100755
index 0000000000000..ae9d3b7704284
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+
+[[ -z $1 ]] && { echo "Usage: csv_to_json.sh CSV_FILE"; exit 1; }
+
+awk -vFPAT='([^,]*)|(\"([^\"]|\"\")*\")' \
+  'BEGIN {
+     print "{"
+   } {
+     if (count == 0) {
+       for (i = 1; i <= NF; i++) {
+         names[i] = $i
+       }
+     } else if ($1 == "CORE:" || $1 == "LB:" || $1 == "PAR:") {
+       if (paramprinted) print "\n    }"
+       else if (lineprinted) print ""
+       if (catprinted) print "  },"
+       lineprinted = 0
+       paramprinted = 0
+       catprinted = 1
+       gsub(/:$/, "", $1)
+       print "  \""$1"\": {";
+     } else if ($1 != "") {
+       if (lineprinted) print ""
+       if (paramprinted) print "    },"
+       lineprinted = 0
+       paramprinted = 1
+       print "    \""$1"\": {";
+       lineprinted = 0
+       for (i=2; i<=NF; i++) {
+         if ($i != "") {
+           gsub(/^"/, "", $i)
+           gsub(/"$/, "", $i)
+           gsub(/""/, "\"", $i)
+           if (lineprinted) print ","
+           lineprinted = 1
+           printf("      \"%s\": %s", names[i], $i)
+         }
+       }
+     }
+     count++;
+   } END {
+     if (paramprinted) print "\n    }"
+     if (catprinted) print "  }"
+     print "}"
+   }' \
+   $1
diff --git a/GPU/GPUTracking/Definitions/Parameters/json_to_csv.python b/GPU/GPUTracking/Definitions/Parameters/json_to_csv.python
new file mode 100755
index 0000000000000..a6640239604e0
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/Parameters/json_to_csv.python
@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+import sys, json, csv, string
+
+if len(sys.argv) != 3:
+    sys.exit("usage: json2csv.py input.json output.csv")
+
+try:
+    data = json.load(open(sys.argv[1]))
+except Exception:
+    sys.exit("invalid json")
+
+if set(data) != {"CORE", "LB", "PAR"}:
+    sys.exit("invalid categories")
+
+arches = []
+seen = set()
+for cat in data.values():
+    if not isinstance(cat, dict):
+        sys.exit("data not 2-dimensional")
+    for param in cat.values():
+        if not isinstance(param, dict):
+            sys.exit("data not 2-dimensional")
+        for a in param.keys():
+            if a not in seen:
+                seen.add(a)
+                arches.append(a)
+
+cols = 1 + len(arches)
+empty = [""] * cols
+
+with open(sys.argv[2], "w", newline="") as f:
+    w = csv.writer(f, lineterminator="\n")
+    w.writerow(["Architecture", *arches])
+    w.writerow(empty)
+    cats = list(data.items())
+    for ci, (cname, cat) in enumerate(cats):
+        w.writerow([f"{cname}:"] + [""] * (cols - 1))
+        for pname, param in cat.items():
+            row = [pname]
+            for a in arches:
+                v = param.get(a, "")
+                if isinstance(v, list):
+                  row.append(json.dumps(v))
+                elif isinstance(v, str) and not v == "":
+                   row.append('"' + v + '"')
+                else:
+                   row.append(v)
+            w.writerow(row)
+        if ci != len(cats) - 1:
+            w.writerow(empty)

From c8834dee0b39f86f394dfb07f5a42ab09659dffa Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 5 Feb 2026 11:27:52 +0100
Subject: [PATCH 1274/1764] Promote --ctf-dict from process to workflow level
 option

---
 .../Base/include/DetectorsBase/CTFCoderBase.h | 14 ++++----
 .../include/CPVReconstruction/CTFCoder.h      |  2 +-
 .../include/CPVWorkflow/EntropyDecoderSpec.h  |  4 +--
 .../include/CPVWorkflow/EntropyEncoderSpec.h  |  4 +--
 .../CPV/workflow/src/EntropyDecoderSpec.cxx   | 13 +++----
 .../CPV/workflow/src/EntropyEncoderSpec.cxx   | 13 +++----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/CTFWorkflow/CTFReaderSpec.h       |  1 +
 Detectors/CTF/workflow/src/CTFReaderSpec.cxx  |  1 -
 .../CTF/workflow/src/ctf-reader-workflow.cxx  | 34 ++++++++++---------
 .../include/CTPReconstruction/CTFCoder.h      |  2 +-
 .../include/CTPWorkflow/EntropyDecoderSpec.h  |  4 +--
 .../include/CTPWorkflow/EntropyEncoderSpec.h  |  4 +--
 .../CTP/workflow/src/EntropyDecoderSpec.cxx   | 16 ++++-----
 .../CTP/workflow/src/EntropyEncoderSpec.cxx   | 16 ++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/EMCALReconstruction/CTFCoder.h    |  2 +-
 .../EMCALWorkflow/EntropyDecoderSpec.h        |  4 +--
 .../EMCALWorkflow/EntropyEncoderSpec.h        |  4 +--
 .../EMCAL/workflow/src/EntropyDecoderSpec.cxx | 16 ++++-----
 .../EMCAL/workflow/src/EntropyEncoderSpec.cxx | 23 ++++++-------
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/FDDReconstruction/CTFCoder.h      |  2 +-
 .../include/FDDWorkflow/EntropyDecoderSpec.h  |  4 +--
 .../include/FDDWorkflow/EntropyEncoderSpec.h  |  4 +--
 .../FDD/workflow/src/EntropyDecoderSpec.cxx   | 16 ++++-----
 .../FDD/workflow/src/EntropyEncoderSpec.cxx   | 16 ++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/FT0Reconstruction/CTFCoder.h      |  2 +-
 .../include/FT0Workflow/EntropyDecoderSpec.h  |  4 +--
 .../include/FT0Workflow/EntropyEncoderSpec.h  |  4 +--
 .../FT0/workflow/src/EntropyDecoderSpec.cxx   | 15 ++++----
 .../FT0/workflow/src/EntropyEncoderSpec.cxx   | 16 ++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/FV0Reconstruction/CTFCoder.h      |  2 +-
 .../include/FV0Workflow/EntropyDecoderSpec.h  |  4 +--
 .../include/FV0Workflow/EntropyEncoderSpec.h  |  4 +--
 .../FV0/workflow/src/EntropyDecoderSpec.cxx   | 16 ++++-----
 .../FV0/workflow/src/EntropyEncoderSpec.cxx   | 16 ++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/HMPIDReconstruction/CTFCoder.h    |  2 +-
 .../HMPIDWorkflow/EntropyDecoderSpec.h        |  2 +-
 .../HMPIDWorkflow/EntropyEncoderSpec.h        |  2 +-
 .../HMPID/workflow/src/EntropyDecoderSpec.cxx | 18 +++++-----
 .../HMPID/workflow/src/EntropyEncoderSpec.cxx | 18 +++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/ITSMFTReconstruction/CTFCoder.h   |  2 +-
 .../ITSMFTWorkflow/EntropyDecoderSpec.h       |  4 +--
 .../ITSMFTWorkflow/EntropyEncoderSpec.h       |  4 +--
 .../workflow/src/EntropyDecoderSpec.cxx       | 22 ++++++------
 .../workflow/src/EntropyEncoderSpec.cxx       | 18 +++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../MUON/MCH/CTF/include/MCHCTF/CTFCoder.h    |  2 +-
 .../CTF/include/MCHCTF/EntropyDecoderSpec.h   |  2 +-
 .../MUON/MCH/CTF/src/EntropyDecoderSpec.cxx   | 18 +++++-----
 .../Workflow/src/entropy-encoder-workflow.cxx | 21 ++++++------
 .../MUON/MID/CTF/include/MIDCTF/CTFCoder.h    |  2 +-
 .../include/MIDWorkflow/EntropyDecoderSpec.h  |  4 +--
 .../include/MIDWorkflow/EntropyEncoderSpec.h  |  4 +--
 .../MID/Workflow/src/EntropyDecoderSpec.cxx   | 16 ++++-----
 .../MID/Workflow/src/EntropyEncoderSpec.cxx   | 16 ++++-----
 .../Workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/PHOSReconstruction/CTFCoder.h     |  2 +-
 .../include/PHOSWorkflow/EntropyDecoderSpec.h |  4 +--
 .../include/PHOSWorkflow/EntropyEncoderSpec.h |  4 +--
 .../PHOS/workflow/src/EntropyDecoderSpec.cxx  | 16 ++++-----
 .../PHOS/workflow/src/EntropyEncoderSpec.cxx  | 16 ++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/TOFReconstruction/CTFCoder.h      |  2 +-
 .../TOFWorkflowUtils/EntropyDecoderSpec.h     |  4 +--
 .../TOFWorkflowUtils/EntropyEncoderSpec.h     |  4 +--
 .../TOF/workflow/src/EntropyDecoderSpec.cxx   | 16 ++++-----
 .../TOF/workflow/src/EntropyEncoderSpec.cxx   | 16 ++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/TPCReconstruction/CTFCoder.h      |  2 +-
 .../include/TPCWorkflow/EntropyDecoderSpec.h  |  4 +--
 .../include/TPCWorkflow/EntropyEncoderSpec.h  |  4 +--
 .../include/TPCWorkflow/RecoWorkflow.h        |  1 +
 .../TPC/workflow/src/EntropyDecoderSpec.cxx   | 14 ++++----
 .../TPC/workflow/src/EntropyEncoderSpec.cxx   | 16 ++++-----
 Detectors/TPC/workflow/src/RecoWorkflow.cxx   |  4 +--
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../TPC/workflow/src/tpc-reco-workflow.cxx    |  2 ++
 .../include/TRDReconstruction/CTFCoder.h      |  2 +-
 .../include/TRDWorkflow/EntropyDecoderSpec.h  |  2 +-
 .../include/TRDWorkflow/EntropyEncoderSpec.h  |  2 +-
 .../TRD/workflow/src/EntropyDecoderSpec.cxx   | 18 +++++-----
 .../TRD/workflow/src/EntropyEncoderSpec.cxx   | 18 +++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 .../include/ZDCReconstruction/CTFCoder.h      |  2 +-
 .../include/ZDCWorkflow/EntropyDecoderSpec.h  |  4 +--
 .../include/ZDCWorkflow/EntropyEncoderSpec.h  |  4 +--
 .../ZDC/workflow/src/EntropyDecoderSpec.cxx   | 16 ++++-----
 .../ZDC/workflow/src/EntropyEncoderSpec.cxx   | 16 ++++-----
 .../workflow/src/entropy-encoder-workflow.cxx |  3 +-
 95 files changed, 378 insertions(+), 358 deletions(-)

diff --git a/Detectors/Base/include/DetectorsBase/CTFCoderBase.h b/Detectors/Base/include/DetectorsBase/CTFCoderBase.h
index bf4f37ecbeff5..593bf37df5879 100644
--- a/Detectors/Base/include/DetectorsBase/CTFCoderBase.h
+++ b/Detectors/Base/include/DetectorsBase/CTFCoderBase.h
@@ -58,8 +58,8 @@ class CTFCoderBase
                             Decoder };
 
   CTFCoderBase() = delete;
-  CTFCoderBase(int n, DetID det, float memFactor = 1.f) : mCoders(n), mDet(det), mMemMarginFactor(memFactor > 1.f ? memFactor : 1.f) {}
-  CTFCoderBase(OpType op, int n, DetID det, float memFactor = 1.f) : mOpType(op), mCoders(n), mDet(det), mMemMarginFactor(memFactor > 1.f ? memFactor : 1.f) {}
+  CTFCoderBase(int n, DetID det, float memFactor = 1.f, const std::string& ctfdictOpt = "none") : mCoders(n), mDet(det), mMemMarginFactor(memFactor > 1.f ? memFactor : 1.f), mDictOpt{ctfdictOpt} {}
+  CTFCoderBase(OpType op, int n, DetID det, float memFactor = 1.f, const std::string& ctfdictOpt = "none") : mOpType(op), mCoders(n), mDet(det), mMemMarginFactor(memFactor > 1.f ? memFactor : 1.f), mDictOpt{ctfdictOpt} {}
   virtual ~CTFCoderBase() = default;
 
   virtual void createCoders(const std::vector<char>& bufVec, o2::ctf::CTFCoderBase::OpType op) = 0;
@@ -189,6 +189,7 @@ class CTFCoderBase
   std::vector<char> loadDictionaryFromTree(TTree* tree);
   std::vector<std::any> mCoders; // encoders/decoders
   DetID mDet;
+  std::string mDictOpt{};
   std::string mDictBinding{"ctfdict"};
   std::string mTrigOffsBinding{"trigoffset"};
   CTFDictHeader mExtHeader;                    // external dictionary header
@@ -325,13 +326,12 @@ void CTFCoderBase::init(o2::framework::InitContext& ic)
       }
     }
   }
-  auto dict = ic.options().get<std::string>("ctf-dict");
-  if (dict.empty() || dict == "ccdb") { // load from CCDB
+  if (mDictOpt.empty() || mDictOpt == "ccdb") { // load from CCDB
     mLoadDictFromCCDB = true;
   } else {
-    if (dict != "none") { // none means per-CTF dictionary will created on the fly
-      createCodersFromFile<CTF>(dict, mOpType);
-      LOGP(info, "Loaded {} from {}", mExtHeader.asString(), dict);
+    if (mDictOpt != "none") { // none means per-CTF dictionary will created on the fly
+      createCodersFromFile<CTF>(mDictOpt, mOpType);
+      LOGP(info, "Loaded {} from {}", mExtHeader.asString(), mDictOpt);
     } else {
       LOGP(info, "Internal per-TF CTF Dict will be created");
     }
diff --git a/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h b/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
index ab5082b5c748c..a5f9d0eac90e8 100644
--- a/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
+++ b/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace cpv
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::CPV) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::CPV, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/CPV/workflow/include/CPVWorkflow/EntropyDecoderSpec.h b/Detectors/CPV/workflow/include/CPVWorkflow/EntropyDecoderSpec.h
index 09de778360d74..7192b1b2f6353 100644
--- a/Detectors/CPV/workflow/include/CPVWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/CPV/workflow/include/CPVWorkflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace cpv
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -41,7 +41,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace cpv
 } // namespace o2
diff --git a/Detectors/CPV/workflow/include/CPVWorkflow/EntropyEncoderSpec.h b/Detectors/CPV/workflow/include/CPVWorkflow/EntropyEncoderSpec.h
index 24c229179fe1d..a1851ebb97377 100644
--- a/Detectors/CPV/workflow/include/CPVWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/CPV/workflow/include/CPVWorkflow/EntropyEncoderSpec.h
@@ -28,7 +28,7 @@ namespace cpv
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR = false);
+  EntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +42,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace cpv
 } // namespace o2
diff --git a/Detectors/CPV/workflow/src/EntropyDecoderSpec.cxx b/Detectors/CPV/workflow/src/EntropyDecoderSpec.cxx
index 7c14dc70dd430..518a646e23cb9 100644
--- a/Detectors/CPV/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/CPV/workflow/src/EntropyDecoderSpec.cxx
@@ -25,7 +25,7 @@ namespace o2
 namespace cpv
 {
 
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -74,7 +74,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"triggers"}, "CPV", "CLUSTERTRIGRECS", 0, Lifetime::Timeframe},
@@ -83,16 +83,17 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_CPV", "CPV", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_CPV", "CPV", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("CPV/Calib/CTFDictionaryTree"));
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_CPV", "CPV", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("CPV/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "cpv-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
 
 } // namespace cpv
diff --git a/Detectors/CPV/workflow/src/EntropyEncoderSpec.cxx b/Detectors/CPV/workflow/src/EntropyEncoderSpec.cxx
index 31ed720e66335..54fb1354ad60c 100644
--- a/Detectors/CPV/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/CPV/workflow/src/EntropyEncoderSpec.cxx
@@ -26,7 +26,7 @@ namespace o2
 namespace cpv
 {
 
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -70,12 +70,14 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("triggers", "CPV", "CLUSTERTRIGRECS", 0, Lifetime::Timeframe);
   inputs.emplace_back("clusters", "CPV", "CLUSTERS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "CPV", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("CPV/Calib/CTFDictionaryTree"));
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "CPV", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("CPV/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -84,9 +86,8 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{"CPV", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "CPV", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
diff --git a/Detectors/CPV/workflow/src/entropy-encoder-workflow.cxx b/Detectors/CPV/workflow/src/entropy-encoder-workflow.cxx
index d7e79c4cea430..6f9445d9ddd16 100644
--- a/Detectors/CPV/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/CPV/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::cpv::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::cpv::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h b/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
index ab03649c0646b..081e6cf4d968a 100644
--- a/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
+++ b/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
@@ -32,6 +32,7 @@ struct CTFReaderInp {
   std::string metricChannel{};
   std::string fileIRFrames{};
   std::string fileRunTimeSpans{};
+  std::string dictOpt{};
   std::vector<int> ctfIDs{};
   bool reverseCTFIDs{false};
   bool skipSkimmedOutTF = false;
diff --git a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
index 3810230637e5f..4100ebb37c61d 100644
--- a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
+++ b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
@@ -645,7 +645,6 @@ DataProcessorSpec getCTFReaderSpec(const CTFReaderInp& inp)
   if (!inp.sup0xccdb) {
     outputs.emplace_back(OutputSpec{{"TFDist"}, o2::header::gDataOriginFLP, o2::header::gDataDescriptionDISTSTF, 0xccdb});
   }
-
   options.emplace_back(ConfigParamSpec{"select-ctf-ids", VariantType::String, "", {"comma-separated list CTF IDs to inject (from cumulative counter of CTFs seen)"}});
   options.emplace_back(ConfigParamSpec{"reverse-select-ctf-ids", VariantType::Bool, false, {"reverse order of to inject CTF IDs"}});
   options.emplace_back(ConfigParamSpec{"impose-run-start-timstamp", VariantType::Int64, 0L, {"impose run start time stamp (ms), ignored if 0"}});
diff --git a/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx b/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
index cddf694251a01..fc50c971c5d20 100644
--- a/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
+++ b/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
@@ -52,6 +52,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<o2::framework::ConfigParamSpec> options;
   options.push_back(ConfigParamSpec{"ctf-input", VariantType::String, "none", {"comma-separated list CTF input files"}});
+  options.push_back(ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}});
   options.push_back(ConfigParamSpec{"onlyDet", VariantType::String, std::string{DetID::ALL}, {"comma-separated list of detectors to accept. Overrides skipDet"}});
   options.push_back(ConfigParamSpec{"skipDet", VariantType::String, std::string{DetID::NONE}, {"comma-separate list of detectors to skip"}});
   options.push_back(ConfigParamSpec{"loop", VariantType::Int, 0, {"loop N times (infinite for N<0)"}});
@@ -132,6 +133,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   ctfInput.fileRunTimeSpans = configcontext.options().get<std::string>("run-time-span-file");
   ctfInput.skipSkimmedOutTF = configcontext.options().get<bool>("skip-skimmed-out-tf");
   ctfInput.invertIRFramesSelection = configcontext.options().get<bool>("invert-irframe-selection");
+  ctfInput.dictOpt = configcontext.options().get<std::string>("ctf-dict");
   int verbosity = configcontext.options().get<int>("ctf-reader-verbosity");
 
   int rateLimitingIPCID = std::stoi(configcontext.options().get<std::string>("timeframes-rate-limit-ipcid"));
@@ -181,52 +183,52 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   // add decoders for all allowed detectors.
   if (ctfInput.detMask[DetID::ITS]) {
-    addSpecs(o2::itsmft::getEntropyDecoderSpec(DetID::getDataOrigin(DetID::ITS), verbosity, configcontext.options().get<bool>("its-digits"), ctfInput.subspec));
+    addSpecs(o2::itsmft::getEntropyDecoderSpec(DetID::getDataOrigin(DetID::ITS), verbosity, configcontext.options().get<bool>("its-digits"), ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::MFT]) {
-    addSpecs(o2::itsmft::getEntropyDecoderSpec(DetID::getDataOrigin(DetID::MFT), verbosity, configcontext.options().get<bool>("mft-digits"), ctfInput.subspec));
+    addSpecs(o2::itsmft::getEntropyDecoderSpec(DetID::getDataOrigin(DetID::MFT), verbosity, configcontext.options().get<bool>("mft-digits"), ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::TPC]) {
-    addSpecs(o2::tpc::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::tpc::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::TRD]) {
-    addSpecs(o2::trd::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::trd::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::TOF]) {
-    addSpecs(o2::tof::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::tof::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::FT0]) {
-    addSpecs(o2::ft0::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::ft0::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::FV0]) {
-    addSpecs(o2::fv0::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::fv0::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::FDD]) {
-    addSpecs(o2::fdd::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::fdd::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::MID]) {
-    addSpecs(o2::mid::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::mid::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::MCH]) {
-    addSpecs(o2::mch::getEntropyDecoderSpec(verbosity, "mch-entropy-decoder", ctfInput.subspec));
+    addSpecs(o2::mch::getEntropyDecoderSpec(verbosity, "mch-entropy-decoder", ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::EMC]) {
-    addSpecs(o2::emcal::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.decSSpecEMC));
+    addSpecs(o2::emcal::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.decSSpecEMC, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::PHS]) {
-    addSpecs(o2::phos::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::phos::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::CPV]) {
-    addSpecs(o2::cpv::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::cpv::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::ZDC]) {
-    addSpecs(o2::zdc::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::zdc::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::HMP]) {
-    addSpecs(o2::hmpid::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::hmpid::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::CTP]) {
-    addSpecs(o2::ctp::getEntropyDecoderSpec(verbosity, ctfInput.subspec));
+    addSpecs(o2::ctp::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
   }
 
   bool combine = configcontext.options().get<bool>("combine-devices");
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
index 87657f6a6f8c6..b17db0e77be28 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
@@ -37,7 +37,7 @@ namespace ctp
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::CTP) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::CTP, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/CTP/workflow/include/CTPWorkflow/EntropyDecoderSpec.h b/Detectors/CTP/workflow/include/CTPWorkflow/EntropyDecoderSpec.h
index eee7abb08d16c..dda45c9f11a34 100644
--- a/Detectors/CTP/workflow/include/CTPWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/CTP/workflow/include/CTPWorkflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace ctp
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +42,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace ctp
 } // namespace o2
diff --git a/Detectors/CTP/workflow/include/CTPWorkflow/EntropyEncoderSpec.h b/Detectors/CTP/workflow/include/CTPWorkflow/EntropyEncoderSpec.h
index 3a023ce2022dc..a63119264e071 100644
--- a/Detectors/CTP/workflow/include/CTPWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/CTP/workflow/include/CTPWorkflow/EntropyEncoderSpec.h
@@ -28,7 +28,7 @@ namespace ctp
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR, bool noLumi);
+  EntropyEncoderSpec(bool selIR, bool noLumi, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -43,7 +43,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, bool noLumiInput = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, bool noLumiInput = false, const std::string& ctfdictOpt = "none");
 
 } // namespace ctp
 } // namespace o2
diff --git a/Detectors/CTP/workflow/src/EntropyDecoderSpec.cxx b/Detectors/CTP/workflow/src/EntropyDecoderSpec.cxx
index 8c2f5d05aa031..0fa8fb0004e4c 100644
--- a/Detectors/CTP/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/CTP/workflow/src/EntropyDecoderSpec.cxx
@@ -24,8 +24,7 @@ namespace o2
 {
 namespace ctp
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -90,7 +89,7 @@ void EntropyDecoderSpec::updateTimeDependentParams(framework::ProcessingContext&
   }
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"digits"}, "CTP", "DIGITS", 0, Lifetime::Timeframe},
@@ -99,18 +98,19 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_CTP", "CTP", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_CTP", "CTP", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("CTP/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_CTP", "CTP", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("CTP/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
   inputs.emplace_back("ctpconfig", "CTP", "CTPCONFIG", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/Config", 1));
   return DataProcessorSpec{
     "ctp-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ignore-ctpinputs-decoding-ctf", VariantType::Bool, false, {"Inputs alignment: false - CTF decoder - has to be compatible with reco: allowed options: 10,01,00"}},
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ignore-ctpinputs-decoding-ctf", VariantType::Bool, false, {"Inputs alignment: false - CTF decoder - has to be compatible with reco: allowed options: 10,01,00"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace ctp
 } // namespace o2
diff --git a/Detectors/CTP/workflow/src/EntropyEncoderSpec.cxx b/Detectors/CTP/workflow/src/EntropyEncoderSpec.cxx
index 44e64d7505977..902fe22dadcc9 100644
--- a/Detectors/CTP/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/CTP/workflow/src/EntropyEncoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace ctp
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, bool nolumi) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR), mNoLumi(nolumi)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, bool nolumi, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR), mNoLumi(nolumi)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -77,14 +76,17 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR, bool nolumi)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, bool nolumi, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("digits", "CTP", "DIGITS", 0, Lifetime::Timeframe);
   if (!nolumi) {
     inputs.emplace_back("CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe);
   }
-  inputs.emplace_back("ctfdict", "CTP", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("CTP/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "CTP", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("CTP/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -92,13 +94,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR, bool nolumi)
     "ctp-entropy-encoder",
     inputs,
     Outputs{{"CTP", "CTFDATA", 0, Lifetime::Timeframe}, {{"ctfrep"}, "CTP", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, nolumi)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, nolumi, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace ctp
 } // namespace o2
diff --git a/Detectors/CTP/workflow/src/entropy-encoder-workflow.cxx b/Detectors/CTP/workflow/src/entropy-encoder-workflow.cxx
index 1fcaa89be9888..9057d16df4384 100644
--- a/Detectors/CTP/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/CTP/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"no-lumi-input", VariantType::Bool, false, {"Lumi info not available"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
@@ -38,6 +39,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::ctp::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<bool>("no-lumi-input")));
+  wf.emplace_back(o2::ctp::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<bool>("no-lumi-input"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
index 23deb75ffb049..6584775057d9f 100644
--- a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
+++ b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace emcal
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::EMC) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::EMC, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/EMCAL/workflow/include/EMCALWorkflow/EntropyDecoderSpec.h b/Detectors/EMCAL/workflow/include/EMCALWorkflow/EntropyDecoderSpec.h
index 0215e0ae65e43..9cc5ba7887473 100644
--- a/Detectors/EMCAL/workflow/include/EMCALWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/EMCAL/workflow/include/EMCALWorkflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace emcal
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity, unsigned int sspecOut);
+  EntropyDecoderSpec(int verbosity, unsigned int sspecOut, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +42,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspecInp, unsigned int sspecOut = 0);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspecInp, unsigned int sspecOut = 0, const std::string& ctfdictOpt = "none");
 
 } // namespace emcal
 } // namespace o2
diff --git a/Detectors/EMCAL/workflow/include/EMCALWorkflow/EntropyEncoderSpec.h b/Detectors/EMCAL/workflow/include/EMCALWorkflow/EntropyEncoderSpec.h
index cdfb342e7ff11..df502beef30df 100644
--- a/Detectors/EMCAL/workflow/include/EMCALWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/EMCAL/workflow/include/EMCALWorkflow/EntropyEncoderSpec.h
@@ -28,7 +28,7 @@ namespace emcal
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +42,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace emcal
 } // namespace o2
diff --git a/Detectors/EMCAL/workflow/src/EntropyDecoderSpec.cxx b/Detectors/EMCAL/workflow/src/EntropyDecoderSpec.cxx
index 700f468e9e73d..ecc0e45492bea 100644
--- a/Detectors/EMCAL/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/EMCAL/workflow/src/EntropyDecoderSpec.cxx
@@ -24,8 +24,7 @@ namespace o2
 {
 namespace emcal
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, unsigned int sspecOut) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder), mSSpecOut(sspecOut)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, unsigned int sspecOut, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt), mSSpecOut(sspecOut)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -74,7 +73,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspecInp, unsigned int sspecOut)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspecInp, unsigned int sspecOut, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"triggers"}, "EMC", "CELLSTRGR", sspecOut, Lifetime::Timeframe},
@@ -83,17 +82,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspecInp, un
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_EMC", "EMC", "CTFDATA", sspecInp, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_EMC", "EMC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("EMC/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_EMC", "EMC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("EMC/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "emcal-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, sspecOut)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, sspecOut, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace emcal
 } // namespace o2
diff --git a/Detectors/EMCAL/workflow/src/EntropyEncoderSpec.cxx b/Detectors/EMCAL/workflow/src/EntropyEncoderSpec.cxx
index 773c4c65fc9fe..2928a71a167bc 100644
--- a/Detectors/EMCAL/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/EMCAL/workflow/src/EntropyEncoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace emcal
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -71,12 +70,15 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("triggers", "EMC", "CELLSTRGR", 0, Lifetime::Timeframe);
   inputs.emplace_back("cells", "EMC", "CELLS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "EMC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("EMC/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "EMC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("EMC/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -85,14 +87,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{"EMC", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "EMC", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{
-      {"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-      {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
-      {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
-      {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
-      {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+            {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
+            {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
+            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace emcal
 } // namespace o2
diff --git a/Detectors/EMCAL/workflow/src/entropy-encoder-workflow.cxx b/Detectors/EMCAL/workflow/src/entropy-encoder-workflow.cxx
index e6af02fa10d49..953b726fcb971 100644
--- a/Detectors/EMCAL/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/EMCAL/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::emcal::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::emcal::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
index 94a0c6f64659d..cb3b13aa9b8e4 100644
--- a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
+++ b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
@@ -36,7 +36,7 @@ namespace fdd
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FDD) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::FDD, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode digits to buffer with CTF
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/EntropyDecoderSpec.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/EntropyDecoderSpec.h
index a6ee132ee0c34..1fd3cd7835cd9 100644
--- a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace fdd
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -41,7 +41,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace fdd
 } // namespace o2
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/EntropyEncoderSpec.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/EntropyEncoderSpec.h
index 87dcca02e869f..37d43f477e836 100644
--- a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/EntropyEncoderSpec.h
@@ -28,7 +28,7 @@ namespace fdd
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +42,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace fdd
 } // namespace o2
diff --git a/Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx b/Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx
index fb5b173fb7a94..33c140b5bc198 100644
--- a/Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx
@@ -24,8 +24,7 @@ namespace o2
 {
 namespace fdd
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -73,7 +72,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"digits"}, "FDD", "DIGITSBC", 0, Lifetime::Timeframe},
@@ -82,17 +81,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_FDD", "FDD", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_FDD", "FDD", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FDD/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_FDD", "FDD", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FDD/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "fdd-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace fdd
 } // namespace o2
diff --git a/Detectors/FIT/FDD/workflow/src/EntropyEncoderSpec.cxx b/Detectors/FIT/FDD/workflow/src/EntropyEncoderSpec.cxx
index abb2518e5ae0b..be81f7ca7d3d4 100644
--- a/Detectors/FIT/FDD/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/FIT/FDD/workflow/src/EntropyEncoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace fdd
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -69,12 +68,15 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("digits", "FDD", "DIGITSBC", 0, Lifetime::Timeframe);
   inputs.emplace_back("channels", "FDD", "DIGITSCH", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "FDD", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FDD/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "FDD", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FDD/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -82,13 +84,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     "fdd-entropy-encoder",
     inputs,
     Outputs{{"FDD", "CTFDATA", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace fdd
 } // namespace o2
diff --git a/Detectors/FIT/FDD/workflow/src/entropy-encoder-workflow.cxx b/Detectors/FIT/FDD/workflow/src/entropy-encoder-workflow.cxx
index bcc42ebc2e086..0e43c6e3c4ba0 100644
--- a/Detectors/FIT/FDD/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/FIT/FDD/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::fdd::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::fdd::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
index 65646c161dde5..5c2e0f0627ef1 100644
--- a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
+++ b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
@@ -37,7 +37,7 @@ namespace ft0
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FT0) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::FT0, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode digits to buffer with CTF
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/EntropyDecoderSpec.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/EntropyDecoderSpec.h
index 4f8e8b5e9be63..d6009accfa45b 100644
--- a/Detectors/FIT/FT0/workflow/include/FT0Workflow/EntropyDecoderSpec.h
+++ b/Detectors/FIT/FT0/workflow/include/FT0Workflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace ft0
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -41,7 +41,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace ft0
 } // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/EntropyEncoderSpec.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/EntropyEncoderSpec.h
index 8fd597af8629d..a1b3714fdbb26 100644
--- a/Detectors/FIT/FT0/workflow/include/FT0Workflow/EntropyEncoderSpec.h
+++ b/Detectors/FIT/FT0/workflow/include/FT0Workflow/EntropyEncoderSpec.h
@@ -28,7 +28,7 @@ namespace ft0
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +42,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace ft0
 } // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx b/Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx
index 65d3585350888..066c5cc547c2e 100644
--- a/Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx
@@ -24,8 +24,7 @@ namespace o2
 {
 namespace ft0
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -73,7 +72,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"digits"}, "FT0", "DIGITSBC", 0, Lifetime::Timeframe},
@@ -82,16 +81,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_FT0", "FT0", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_FT0", "FT0", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FT0/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_FT0", "FT0", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FT0/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "ft0-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}}, {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace ft0
 } // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/src/EntropyEncoderSpec.cxx b/Detectors/FIT/FT0/workflow/src/EntropyEncoderSpec.cxx
index 81bdc2e729bb4..7be6618a61103 100644
--- a/Detectors/FIT/FT0/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/FIT/FT0/workflow/src/EntropyEncoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace ft0
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -70,12 +69,15 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("digits", "FT0", "DIGITSBC", 0, Lifetime::Timeframe);
   inputs.emplace_back("channels", "FT0", "DIGITSCH", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "FT0", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FT0/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "FT0", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FT0/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -83,13 +85,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     "ft0-entropy-encoder",
     inputs,
     Outputs{{"FT0", "CTFDATA", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace ft0
 } // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/src/entropy-encoder-workflow.cxx b/Detectors/FIT/FT0/workflow/src/entropy-encoder-workflow.cxx
index 6a98bbdafd53b..2b4a86df0a614 100644
--- a/Detectors/FIT/FT0/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/FIT/FT0/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::ft0::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::ft0::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
index 4398e19c0a5ed..fdff035b934ef 100644
--- a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
+++ b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
@@ -33,7 +33,7 @@ namespace fv0
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FV0) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::FV0, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode digits to buffer with CTF
diff --git a/Detectors/FIT/FV0/workflow/include/FV0Workflow/EntropyDecoderSpec.h b/Detectors/FIT/FV0/workflow/include/FV0Workflow/EntropyDecoderSpec.h
index 67b74f45e42bf..76f1aae5e728d 100644
--- a/Detectors/FIT/FV0/workflow/include/FV0Workflow/EntropyDecoderSpec.h
+++ b/Detectors/FIT/FV0/workflow/include/FV0Workflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace fv0
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -41,7 +41,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace fv0
 } // namespace o2
diff --git a/Detectors/FIT/FV0/workflow/include/FV0Workflow/EntropyEncoderSpec.h b/Detectors/FIT/FV0/workflow/include/FV0Workflow/EntropyEncoderSpec.h
index db4f154a302c7..0df9403a88a12 100644
--- a/Detectors/FIT/FV0/workflow/include/FV0Workflow/EntropyEncoderSpec.h
+++ b/Detectors/FIT/FV0/workflow/include/FV0Workflow/EntropyEncoderSpec.h
@@ -28,7 +28,7 @@ namespace fv0
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +42,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace fv0
 } // namespace o2
diff --git a/Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx b/Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx
index 9310905ad41b9..7babe9fdea6ed 100644
--- a/Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx
@@ -24,8 +24,7 @@ namespace o2
 {
 namespace fv0
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -73,7 +72,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"digits"}, "FV0", "DIGITSBC", 0, Lifetime::Timeframe},
@@ -82,17 +81,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_FV0", "FV0", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_FV0", "FV0", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FV0/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_FV0", "FV0", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FV0/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "fv0-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace fv0
 } // namespace o2
diff --git a/Detectors/FIT/FV0/workflow/src/EntropyEncoderSpec.cxx b/Detectors/FIT/FV0/workflow/src/EntropyEncoderSpec.cxx
index a25c16a5d697c..2448af09fac4e 100644
--- a/Detectors/FIT/FV0/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/FIT/FV0/workflow/src/EntropyEncoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace fv0
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -71,12 +70,15 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("digits", "FV0", "DIGITSBC", 0, Lifetime::Timeframe);
   inputs.emplace_back("channels", "FV0", "DIGITSCH", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "FV0", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FV0/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "FV0", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("FV0/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -85,13 +87,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{"FV0", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "FV0", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace fv0
 } // namespace o2
diff --git a/Detectors/FIT/FV0/workflow/src/entropy-encoder-workflow.cxx b/Detectors/FIT/FV0/workflow/src/entropy-encoder-workflow.cxx
index 90f37996b55b7..f1b1bfa456316 100644
--- a/Detectors/FIT/FV0/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/FIT/FV0/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::fv0::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::fv0::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h b/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
index 39242355a3de9..0e6694d2353ac 100644
--- a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
+++ b/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace hmpid
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::HMP) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::HMP, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/HMPID/workflow/include/HMPIDWorkflow/EntropyDecoderSpec.h b/Detectors/HMPID/workflow/include/HMPIDWorkflow/EntropyDecoderSpec.h
index 8c64f326a6878..d03a30ab905e5 100644
--- a/Detectors/HMPID/workflow/include/HMPIDWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/HMPID/workflow/include/HMPIDWorkflow/EntropyDecoderSpec.h
@@ -24,7 +24,7 @@ namespace hmpid
 {
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt = "none");
 
 } // namespace hmpid
 } // namespace o2
diff --git a/Detectors/HMPID/workflow/include/HMPIDWorkflow/EntropyEncoderSpec.h b/Detectors/HMPID/workflow/include/HMPIDWorkflow/EntropyEncoderSpec.h
index 2fb9fd301f13b..9c2c4eb5b4fb0 100644
--- a/Detectors/HMPID/workflow/include/HMPIDWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/HMPID/workflow/include/HMPIDWorkflow/EntropyEncoderSpec.h
@@ -24,7 +24,7 @@ namespace hmpid
 {
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace hmpid
 } // namespace o2
diff --git a/Detectors/HMPID/workflow/src/EntropyDecoderSpec.cxx b/Detectors/HMPID/workflow/src/EntropyDecoderSpec.cxx
index aa22979bc305f..9ec05efc846fb 100644
--- a/Detectors/HMPID/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/HMPID/workflow/src/EntropyDecoderSpec.cxx
@@ -26,11 +26,10 @@ namespace o2
 {
 namespace hmpid
 {
-
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +41,7 @@ class EntropyDecoderSpec : public o2::framework::Task
   TStopwatch mTimer;
 };
 
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -91,7 +90,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"triggers"}, "HMP", "INTRECORDS", 0, Lifetime::Timeframe},
@@ -100,17 +99,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_HMP", "HMP", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_HMP", "HMP", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("HMP/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_HMP", "HMP", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("HMP/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "hmpid-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace hmpid
 } // namespace o2
diff --git a/Detectors/HMPID/workflow/src/EntropyEncoderSpec.cxx b/Detectors/HMPID/workflow/src/EntropyEncoderSpec.cxx
index 95723f42d0fd6..c29c1cee459bc 100644
--- a/Detectors/HMPID/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/HMPID/workflow/src/EntropyEncoderSpec.cxx
@@ -27,11 +27,10 @@ namespace o2
 {
 namespace hmpid
 {
-
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR = false);
+  EntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -44,7 +43,7 @@ class EntropyEncoderSpec : public o2::framework::Task
   TStopwatch mTimer;
 };
 
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -89,12 +88,15 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("triggers", "HMP", "INTRECORDS", 0, Lifetime::Timeframe);
   inputs.emplace_back("digits", "HMP", "DIGITS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "HMP", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("HMP/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "HMP", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("HMP/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -103,13 +105,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{"HMP", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "HMP", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace hmpid
 } // namespace o2
diff --git a/Detectors/HMPID/workflow/src/entropy-encoder-workflow.cxx b/Detectors/HMPID/workflow/src/entropy-encoder-workflow.cxx
index fde5e0183abd6..76e7eae10508e 100644
--- a/Detectors/HMPID/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/HMPID/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::hmpid::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::hmpid::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
index 94c14424f6ce3..57d989038342a 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
@@ -45,7 +45,7 @@ class CTFCoder final : public o2::ctf::CTFCoderBase
   using PMatrix = std::array<std::array<bool, ClusterPattern::MaxRowSpan + 2>, ClusterPattern::MaxColSpan + 2>;
   using RowColBuff = std::vector<PixelData>;
 
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, o2::detectors::DetID det) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), det) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, o2::detectors::DetID det, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, det, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode clusters to buffer with CTF
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyDecoderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyDecoderSpec.h
index 4ed4e99f4b6f8..a64f2bf8c063c 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyDecoderSpec.h
@@ -32,7 +32,7 @@ namespace itsmft
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits = false);
+  EntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits = false, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void init(o2::framework::InitContext& ic) final;
   void run(o2::framework::ProcessingContext& pc) final;
@@ -60,7 +60,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyEncoderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyEncoderSpec.h
index c10ae16c95a3e..588cae6339489 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyEncoderSpec.h
@@ -30,7 +30,7 @@ namespace itsmft
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR);
+  EntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -48,7 +48,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/src/EntropyDecoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/EntropyDecoderSpec.cxx
index 4edbc10d5bfbd..f90b708af1996 100644
--- a/Detectors/ITSMFT/common/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/EntropyDecoderSpec.cxx
@@ -28,9 +28,8 @@ namespace o2
 {
 namespace itsmft
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits)
-  : mOrigin(orig), mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, orig == o2::header::gDataOriginITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT), mGetDigits(getDigits)
+EntropyDecoderSpec::EntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits, const std::string& ctfdictOpt)
+  : mOrigin(orig), mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, orig == o2::header::gDataOriginITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT, ctfdictOpt), mGetDigits(getDigits)
 {
   assert(orig == o2::header::gDataOriginITS || orig == o2::header::gDataOriginMFT);
   mDetPrefix = orig == o2::header::gDataOriginITS ? "_ITS" : "_MFT";
@@ -119,7 +118,7 @@ void EntropyDecoderSpec::finaliseCCDB(o2::framework::ConcreteDataMatcher& matche
   }
 }
 
-DataProcessorSpec getEntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs;
   // this is a special dummy input which makes sense only in sync workflows
@@ -141,20 +140,19 @@ DataProcessorSpec getEntropyDecoderSpec(o2::header::DataOrigin orig, int verbosi
   inputs.emplace_back(std::string("ctf") + nm, orig, "CTFDATA", sspec, Lifetime::Timeframe);
   inputs.emplace_back(std::string("noise") + nm, orig, "NOISEMAP", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/NoiseMap", orig.as<std::string>())));
   inputs.emplace_back(std::string("cldict") + nm, orig, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/ClusterDictionary", orig.as<std::string>())));
-  inputs.emplace_back(std::string("ctfdict") + nm, orig, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/CTFDictionaryTree", orig.as<std::string>())));
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back(std::string("ctfdict") + nm, orig, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/CTFDictionaryTree", orig.as<std::string>())));
+  }
   inputs.emplace_back(std::string("trigoffset"), "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     EntropyDecoderSpec::getName(orig),
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(orig, verbosity, getDigits)},
-    Options{
-      {"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-      {"mask-noise", VariantType::Bool, false, {"apply noise mask to digits or clusters (involves reclusterization)"}},
-      {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}},
-      {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(orig, verbosity, getDigits, ctfdictOpt)},
+    Options{{"mask-noise", VariantType::Bool, false, {"apply noise mask to digits or clusters (involves reclusterization)"}},
+            {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}},
+            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/src/EntropyEncoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/EntropyEncoderSpec.cxx
index 4b35f6cc44e39..a824184330547 100644
--- a/Detectors/ITSMFT/common/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/EntropyEncoderSpec.cxx
@@ -27,9 +27,8 @@ namespace o2
 {
 namespace itsmft
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR)
-  : mOrigin(orig), mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, orig == o2::header::gDataOriginITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR, const std::string& ctfdictOpt)
+  : mOrigin(orig), mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, orig == o2::header::gDataOriginITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT, ctfdictOpt), mSelIR(selIR)
 {
   assert(orig == o2::header::gDataOriginITS || orig == o2::header::gDataOriginMFT);
   mTimer.Stop();
@@ -112,7 +111,7 @@ void EntropyEncoderSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   }
 }
 
-DataProcessorSpec getEntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("compClusters", orig, "COMPCLUSTERS", 0, Lifetime::Timeframe);
@@ -123,19 +122,20 @@ DataProcessorSpec getEntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR)
     inputs.emplace_back("cldict", orig, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/ClusterDictionary", orig.as<std::string>())));
     inputs.emplace_back("alppar", orig, "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Config/AlpideParam", orig.as<std::string>())));
   }
-  inputs.emplace_back("ctfdict", orig, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/CTFDictionaryTree", orig.as<std::string>())));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", orig, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/CTFDictionaryTree", orig.as<std::string>())));
+  }
   return DataProcessorSpec{
     orig == o2::header::gDataOriginITS ? "its-entropy-encoder" : "mft-entropy-encoder",
     inputs,
     Outputs{{orig, "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, orig, "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(orig, selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(orig, selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx b/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
index 6b0585e293db6..5f09fd6c69a97 100644
--- a/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
@@ -24,6 +24,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"runmft", VariantType::Bool, false, {"source detector is MFT (default ITS)"}},
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -40,7 +41,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
   bool selIR = cfgc.options().get<bool>("select-ir-frames");
   if (cfgc.options().get<bool>("runmft")) {
-    wf.emplace_back(o2::itsmft::getEntropyEncoderSpec("MFT", selIR));
+    wf.emplace_back(o2::itsmft::getEntropyEncoderSpec("MFT", selIR, cfgc.options().get<std::string>("ctf-dict")));
   } else {
     wf.emplace_back(o2::itsmft::getEntropyEncoderSpec("ITS", selIR));
   }
diff --git a/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h b/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
index 2d65cbbaea614..5c9da95a98354 100644
--- a/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
+++ b/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
@@ -37,7 +37,7 @@ namespace mch
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::MCH) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::MCH, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/MUON/MCH/CTF/include/MCHCTF/EntropyDecoderSpec.h b/Detectors/MUON/MCH/CTF/include/MCHCTF/EntropyDecoderSpec.h
index f28ca90e9a339..0c3534ff5cdd1 100644
--- a/Detectors/MUON/MCH/CTF/include/MCHCTF/EntropyDecoderSpec.h
+++ b/Detectors/MUON/MCH/CTF/include/MCHCTF/EntropyDecoderSpec.h
@@ -22,7 +22,7 @@ namespace o2
 namespace mch
 {
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, const char* specName, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, const char* specName, unsigned int sspec, const std::string& ctfdictOpt = "none");
 
 } // namespace mch
 } // namespace o2
diff --git a/Detectors/MUON/MCH/CTF/src/EntropyDecoderSpec.cxx b/Detectors/MUON/MCH/CTF/src/EntropyDecoderSpec.cxx
index 9ec13fed85690..653120bd9b630 100644
--- a/Detectors/MUON/MCH/CTF/src/EntropyDecoderSpec.cxx
+++ b/Detectors/MUON/MCH/CTF/src/EntropyDecoderSpec.cxx
@@ -27,11 +27,10 @@ namespace o2
 {
 namespace mch
 {
-
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -43,7 +42,7 @@ class EntropyDecoderSpec : public o2::framework::Task
   TStopwatch mTimer;
 };
 
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -91,7 +90,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, const char* specName, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, const char* specName, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"rofs"}, "MCH", "DIGITROFS", 0, Lifetime::Timeframe},
@@ -101,17 +100,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, const char* specName, uns
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_MCH", "MCH", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_MCH", "MCH", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MCH/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_MCH", "MCH", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MCH/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     specName,
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace mch
 } // namespace o2
diff --git a/Detectors/MUON/MCH/Workflow/src/entropy-encoder-workflow.cxx b/Detectors/MUON/MCH/Workflow/src/entropy-encoder-workflow.cxx
index 058202dfb802b..b5f371edfc759 100644
--- a/Detectors/MUON/MCH/Workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/MUON/MCH/Workflow/src/entropy-encoder-workflow.cxx
@@ -27,11 +27,10 @@ namespace o2
 {
 namespace mch
 {
-
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -44,7 +43,7 @@ class EntropyEncoderSpec : public o2::framework::Task
   TStopwatch mTimer;
 };
 
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -85,12 +84,15 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(const char* specName, bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(const char* specName, bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("rofs", "MCH", "DIGITROFS", 0, Lifetime::Timeframe);
   inputs.emplace_back("digits", "MCH", "DIGITS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "MCH", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MCH/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "MCH", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MCH/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -99,14 +101,12 @@ DataProcessorSpec getEntropyEncoderSpec(const char* specName, bool selIR)
     inputs,
     Outputs{{"MCH", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "MCH", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace mch
 } // namespace o2
 
@@ -118,6 +118,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -133,6 +134,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
   bool selIR = cfgc.options().get<bool>("select-ir-frames");
-  wf.emplace_back(o2::mch::getEntropyEncoderSpec("mch-entropy-encoder", selIR));
+  wf.emplace_back(o2::mch::getEntropyEncoderSpec("mch-entropy-encoder", selIR, cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h b/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
index 5afc42550ae3e..defec7207f808 100644
--- a/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
+++ b/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
@@ -37,7 +37,7 @@ namespace mid
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::MID) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::MID, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/EntropyDecoderSpec.h b/Detectors/MUON/MID/Workflow/include/MIDWorkflow/EntropyDecoderSpec.h
index 301db519b9a5f..8f466ac8b7a54 100644
--- a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/MUON/MID/Workflow/include/MIDWorkflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace mid
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -41,7 +41,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace mid
 } // namespace o2
diff --git a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/EntropyEncoderSpec.h b/Detectors/MUON/MID/Workflow/include/MIDWorkflow/EntropyEncoderSpec.h
index e90c96e6ac8fe..20858ca6dfc07 100644
--- a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/MUON/MID/Workflow/include/MIDWorkflow/EntropyEncoderSpec.h
@@ -29,7 +29,7 @@ namespace mid
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -43,7 +43,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace mid
 } // namespace o2
diff --git a/Detectors/MUON/MID/Workflow/src/EntropyDecoderSpec.cxx b/Detectors/MUON/MID/Workflow/src/EntropyDecoderSpec.cxx
index 5a8df6f8e81cb..0f6dc8bbaa995 100644
--- a/Detectors/MUON/MID/Workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/EntropyDecoderSpec.cxx
@@ -26,8 +26,7 @@ namespace o2
 {
 namespace mid
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -84,7 +83,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs;
   for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < NEvTypes; ++subSpec) {
@@ -94,17 +93,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
   outputs.emplace_back(OutputSpec{{"ctfrep"}, "MID", "CTFDECREP", 0, Lifetime::Timeframe});
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_MID", "MID", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_MID", "MID", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MID/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_MID", "MID", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MID/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "mid-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace mid
 } // namespace o2
diff --git a/Detectors/MUON/MID/Workflow/src/EntropyEncoderSpec.cxx b/Detectors/MUON/MID/Workflow/src/EntropyEncoderSpec.cxx
index a472d6e28ff16..d75fe3fa6fbf2 100644
--- a/Detectors/MUON/MID/Workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/EntropyEncoderSpec.cxx
@@ -32,8 +32,7 @@ namespace o2
 {
 namespace mid
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -100,12 +99,15 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("rofs", ConcreteDataTypeMatcher(header::gDataOriginMID, "DATAROF"), Lifetime::Timeframe);
   inputs.emplace_back("cols", ConcreteDataTypeMatcher(header::gDataOriginMID, "DATA"), Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", header::gDataOriginMID, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MID/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", header::gDataOriginMID, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MID/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -114,13 +116,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{header::gDataOriginMID, "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, header::gDataOriginMID, "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace mid
 } // namespace o2
diff --git a/Detectors/MUON/MID/Workflow/src/entropy-encoder-workflow.cxx b/Detectors/MUON/MID/Workflow/src/entropy-encoder-workflow.cxx
index 56c482c514e38..25b038190281a 100644
--- a/Detectors/MUON/MID/Workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/MUON/MID/Workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::mid::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::mid::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h b/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
index 8a7172f634a33..e222328a351c0 100644
--- a/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
+++ b/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace phos
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::PHS) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::PHS, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/PHOS/workflow/include/PHOSWorkflow/EntropyDecoderSpec.h b/Detectors/PHOS/workflow/include/PHOSWorkflow/EntropyDecoderSpec.h
index 1890864af77ea..a6045cf36f7b2 100644
--- a/Detectors/PHOS/workflow/include/PHOSWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/PHOS/workflow/include/PHOSWorkflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace phos
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -41,7 +41,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace phos
 } // namespace o2
diff --git a/Detectors/PHOS/workflow/include/PHOSWorkflow/EntropyEncoderSpec.h b/Detectors/PHOS/workflow/include/PHOSWorkflow/EntropyEncoderSpec.h
index 4ac8240f4c234..c88bddedc7e20 100644
--- a/Detectors/PHOS/workflow/include/PHOSWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/PHOS/workflow/include/PHOSWorkflow/EntropyEncoderSpec.h
@@ -28,7 +28,7 @@ namespace phos
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -42,7 +42,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace phos
 } // namespace o2
diff --git a/Detectors/PHOS/workflow/src/EntropyDecoderSpec.cxx b/Detectors/PHOS/workflow/src/EntropyDecoderSpec.cxx
index a3d15862a2057..20b161b2d2325 100644
--- a/Detectors/PHOS/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/PHOS/workflow/src/EntropyDecoderSpec.cxx
@@ -24,8 +24,7 @@ namespace o2
 {
 namespace phos
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -74,7 +73,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"triggers"}, "PHS", "CELLTRIGREC", 0, Lifetime::Timeframe},
@@ -83,17 +82,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_PHS", "PHS", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_PHS", "PHS", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("PHS/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_PHS", "PHS", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("PHS/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "phos-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace phos
 } // namespace o2
diff --git a/Detectors/PHOS/workflow/src/EntropyEncoderSpec.cxx b/Detectors/PHOS/workflow/src/EntropyEncoderSpec.cxx
index a932a45f1bb53..66a0e04ed3895 100644
--- a/Detectors/PHOS/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/PHOS/workflow/src/EntropyEncoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace phos
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -70,12 +69,15 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("triggers", "PHS", "CELLTRIGREC", 0, Lifetime::Timeframe);
   inputs.emplace_back("cells", "PHS", "CELLS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "PHS", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("PHS/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "PHS", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("PHS/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -84,13 +86,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{"PHS", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "PHS", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace phos
 } // namespace o2
diff --git a/Detectors/PHOS/workflow/src/entropy-encoder-workflow.cxx b/Detectors/PHOS/workflow/src/entropy-encoder-workflow.cxx
index c7266925060c2..41642cd026089 100644
--- a/Detectors/PHOS/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/PHOS/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::phos::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::phos::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h b/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
index e7a203cfcb25e..53cdf59d08572 100644
--- a/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
+++ b/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
@@ -34,7 +34,7 @@ namespace tof
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TOF) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::TOF, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode clusters to buffer with CTF
diff --git a/Detectors/TOF/workflow/include/TOFWorkflowUtils/EntropyDecoderSpec.h b/Detectors/TOF/workflow/include/TOFWorkflowUtils/EntropyDecoderSpec.h
index c09aa6abc9f7b..714b23d955a78 100644
--- a/Detectors/TOF/workflow/include/TOFWorkflowUtils/EntropyDecoderSpec.h
+++ b/Detectors/TOF/workflow/include/TOFWorkflowUtils/EntropyDecoderSpec.h
@@ -29,7 +29,7 @@ namespace tof
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -43,7 +43,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace tof
 } // namespace o2
diff --git a/Detectors/TOF/workflow/include/TOFWorkflowUtils/EntropyEncoderSpec.h b/Detectors/TOF/workflow/include/TOFWorkflowUtils/EntropyEncoderSpec.h
index ee0739c076597..27377b6447d1c 100644
--- a/Detectors/TOF/workflow/include/TOFWorkflowUtils/EntropyEncoderSpec.h
+++ b/Detectors/TOF/workflow/include/TOFWorkflowUtils/EntropyEncoderSpec.h
@@ -29,7 +29,7 @@ namespace tof
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -43,7 +43,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace tof
 } // namespace o2
diff --git a/Detectors/TOF/workflow/src/EntropyDecoderSpec.cxx b/Detectors/TOF/workflow/src/EntropyDecoderSpec.cxx
index 400914c64021f..8c0445e3ee3cb 100644
--- a/Detectors/TOF/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/TOF/workflow/src/EntropyDecoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace tof
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -93,7 +92,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"digitheader"}, o2::header::gDataOriginTOF, "DIGITHEADER", 0, Lifetime::Timeframe},
@@ -105,17 +104,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_TOF", "TOF", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_TOF", "TOF", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_TOF", "TOF", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "tof-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace tof
 } // namespace o2
diff --git a/Detectors/TOF/workflow/src/EntropyEncoderSpec.cxx b/Detectors/TOF/workflow/src/EntropyEncoderSpec.cxx
index 3fc47955f53c0..27d7c162cf670 100644
--- a/Detectors/TOF/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/TOF/workflow/src/EntropyEncoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace tof
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -71,13 +70,16 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("compDigits", o2::header::gDataOriginTOF, "DIGITS", 0, Lifetime::Timeframe);
   inputs.emplace_back("patterns", o2::header::gDataOriginTOF, "PATTERNS", 0, Lifetime::Timeframe);
   inputs.emplace_back("ROframes", o2::header::gDataOriginTOF, "READOUTWINDOW", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "TOF", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "TOF", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -86,14 +88,12 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{o2::header::gDataOriginTOF, "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "TOF", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"irframe-shift", VariantType::Int, o2::tof::Geo::LATENCYWINDOW_IN_BC, {"IRFrame shift to account for latency"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace tof
 } // namespace o2
diff --git a/Detectors/TOF/workflow/src/entropy-encoder-workflow.cxx b/Detectors/TOF/workflow/src/entropy-encoder-workflow.cxx
index 1969672ad3fa3..5cf882e2723d6 100644
--- a/Detectors/TOF/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/TOF/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::tof::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::tof::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h b/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
index 12d66ef6a6e7c..2c6fac7dcde2a 100644
--- a/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
+++ b/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
@@ -122,7 +122,7 @@ struct MergedColumnsDecoder {
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TPC) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::TPC, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode compressed clusters to flat buffer
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/EntropyDecoderSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/EntropyDecoderSpec.h
index d36391adfab51..767b68644d698 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace tpc
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none") : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
   {
     mTimer.Stop();
     mTimer.Reset();
@@ -47,7 +47,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt = "none");
 
 } // namespace tpc
 } // namespace o2
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/EntropyEncoderSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/EntropyEncoderSpec.h
index ac6fafec0a554..1b8483953a8ab 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/EntropyEncoderSpec.h
@@ -45,7 +45,7 @@ class VDriftHelper;
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool fromFile, bool selIR = false, std::shared_ptr<o2::base::GRPGeomRequest> pgg = std::shared_ptr<o2::base::GRPGeomRequest>());
+  EntropyEncoderSpec(bool fromFile, bool selIR = false, std::shared_ptr<o2::base::GRPGeomRequest> pgg = std::shared_ptr<o2::base::GRPGeomRequest>(), const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -71,7 +71,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool inputFromFile, bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool inputFromFile, bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // end namespace tpc
 } // end namespace o2
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h b/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
index a5368f451a820..8e8a6a96eed63 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
@@ -85,6 +85,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData,
                                     int caClusterer = 0,                                 //
                                     int zsOnTheFly = 0,
                                     bool askDISTSTF = true,
+                                    const std::string& ctfdictOpt = "none",
                                     bool selIR = false,
                                     bool filteredInp = false,
                                     int deadMapSources = -1,
diff --git a/Detectors/TPC/workflow/src/EntropyDecoderSpec.cxx b/Detectors/TPC/workflow/src/EntropyDecoderSpec.cxx
index 4ff3573918722..dd73d582553e6 100644
--- a/Detectors/TPC/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/TPC/workflow/src/EntropyDecoderSpec.cxx
@@ -26,7 +26,6 @@ namespace o2
 {
 namespace tpc
 {
-
 void EntropyDecoderSpec::finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
 {
   if (mCTFCoder.finaliseCCDB<CTF>(matcher, obj)) {
@@ -66,11 +65,14 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_TPC", "TPC", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_TPC", "TPC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TPC/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_TPC", "TPC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TPC/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
@@ -79,10 +81,8 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
     Outputs{OutputSpec{{"output"}, "TPC", "COMPCLUSTERSFLAT", 0, Lifetime::Timeframe},
             OutputSpec{{"trigger"}, "TPC", "TRIGGERWORDS", 0, Lifetime::Timeframe},
             OutputSpec{{"ctfrep"}, "TPC", "CTFDECREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace tpc
 } // namespace o2
diff --git a/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx b/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
index 2efa7077be125..73bdfa1905f3b 100644
--- a/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
@@ -38,10 +38,9 @@ namespace o2
 {
 namespace tpc
 {
-
 EntropyEncoderSpec::~EntropyEncoderSpec() = default;
 
-EntropyEncoderSpec::EntropyEncoderSpec(bool fromFile, bool selIR, std::shared_ptr<o2::base::GRPGeomRequest> pgg) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mFromFile(fromFile), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool fromFile, bool selIR, std::shared_ptr<o2::base::GRPGeomRequest> pgg, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mFromFile(fromFile), mSelIR(selIR)
 {
   if (mSelIR) {
     mGRPRequest = pgg;
@@ -305,13 +304,16 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool inputFromFile, bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool inputFromFile, bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   header::DataDescription inputType = inputFromFile ? header::DataDescription("COMPCLUSTERS") : header::DataDescription("COMPCLUSTERSFLAT");
   inputs.emplace_back("input", "TPC", inputType, 0, Lifetime::Timeframe);
   inputs.emplace_back("trigger", "TPC", "TRIGGERWORDS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "TPC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TPC/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "TPC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TPC/Calib/CTFDictionaryTree"));
+  }
 
   std::shared_ptr<o2::base::GRPGeomRequest> ggreq;
   if (selIR) {
@@ -324,9 +326,8 @@ DataProcessorSpec getEntropyEncoderSpec(bool inputFromFile, bool selIR)
     inputs,
     Outputs{{"TPC", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "TPC", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(inputFromFile, selIR, ggreq)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"no-ctf-columns-combining", VariantType::Bool, false, {"Do not combine correlated columns in CTF"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(inputFromFile, selIR, ggreq, ctfdictOpt)},
+    Options{{"no-ctf-columns-combining", VariantType::Bool, false, {"Do not combine correlated columns in CTF"}},
             {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"irframe-clusters-maxeta", VariantType::Float, 1.5f, {"Max eta for non-assigned clusters"}},
@@ -335,6 +336,5 @@ DataProcessorSpec getEntropyEncoderSpec(bool inputFromFile, bool selIR)
             {"nThreads-tpc-encoder", VariantType::UInt32, 1u, {"number of threads to use for decoding"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace tpc
 } // namespace o2
diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index 98a9841fac8b2..3054dd5d61519 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -101,7 +101,7 @@ const std::unordered_map<std::string, OutputType> OutputMap{
 
 framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vector<int> const& tpcSectors, unsigned long tpcSectorMask, std::vector<int> const& laneConfiguration,
                                     const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool propagateMC, unsigned nLanes, std::string const& cfgInput, std::string const& cfgOutput, bool disableRootInput,
-                                    int caClusterer, int zsOnTheFly, bool askDISTSTF, bool selIR, bool filteredInp, int deadMapSources, bool useMCTimeGain)
+                                    int caClusterer, int zsOnTheFly, bool askDISTSTF, const std::string& ctfdictOpt, bool selIR, bool filteredInp, int deadMapSources, bool useMCTimeGain)
 {
   InputType inputType;
   try {
@@ -507,7 +507,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   //
   // selected by output type 'encoded-clusters'
   if (runClusterEncoder) {
-    specs.emplace_back(o2::tpc::getEntropyEncoderSpec(!runGPUReco && inputType != InputType::CompClustersFlatForEncode, selIR));
+    specs.emplace_back(o2::tpc::getEntropyEncoderSpec(!runGPUReco && inputType != InputType::CompClustersFlatForEncode, selIR, ctfdictOpt));
   }
 
   //////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/Detectors/TPC/workflow/src/entropy-encoder-workflow.cxx b/Detectors/TPC/workflow/src/entropy-encoder-workflow.cxx
index 3f9029cf384a9..c09eb193e0fbf 100644
--- a/Detectors/TPC/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/TPC/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}},
     ConfigParamSpec{"inputFromFile", VariantType::Bool, false, {"Expect COMPCLUSTERS from file"}}};
 
@@ -38,6 +39,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::tpc::getEntropyEncoderSpec(cfgc.options().get<bool>("inputFromFile"), cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::tpc::getEntropyEncoderSpec(cfgc.options().get<bool>("inputFromFile"), cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index 3c8804de8b536..07b1c293bff98 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -71,6 +71,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"configFile", VariantType::String, "", {"configuration file for configurable parameters"}},
     {"filtered-input", VariantType::Bool, false, {"Filtered tracks, clusters input, prefix dataDescriptors with F"}},
     {"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}},
+    {"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     {"tpc-deadMap-sources", VariantType::Int, -1, {"Sources to consider for TPC dead channel map creation; -1=all, 0=deactivated"}},
     {"tpc-mc-time-gain", VariantType::Bool, false, {"use time gain calibration for MC (true) or for data (false)"}},
   };
@@ -182,6 +183,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
                                                 !cfgc.options().get<bool>("no-ca-clusterer"),      //
                                                 !cfgc.options().get<bool>("no-tpc-zs-on-the-fly"), //
                                                 !cfgc.options().get<bool>("ignore-dist-stf"),      //
+                                                cfgc.options().get<std::string>("ctf-dict"),
                                                 cfgc.options().get<bool>("select-ir-frames"),
                                                 cfgc.options().get<bool>("filtered-input"),
                                                 cfgc.options().get<int>("tpc-deadMap-sources"),
diff --git a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
index 9eeaf19db5025..adb584ef15ec4 100644
--- a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
+++ b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
@@ -36,7 +36,7 @@ namespace trd
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TRD) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::TRD, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/EntropyDecoderSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/EntropyDecoderSpec.h
index 53c591e343134..9521d6262afbf 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/EntropyDecoderSpec.h
@@ -24,7 +24,7 @@ namespace trd
 {
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt = "none");
 
 } // namespace trd
 } // namespace o2
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/EntropyEncoderSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/EntropyEncoderSpec.h
index 673b600bee051..e31a629225f2c 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/EntropyEncoderSpec.h
@@ -24,7 +24,7 @@ namespace trd
 {
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace trd
 } // namespace o2
diff --git a/Detectors/TRD/workflow/src/EntropyDecoderSpec.cxx b/Detectors/TRD/workflow/src/EntropyDecoderSpec.cxx
index b30732927c182..2caa4c370a021 100644
--- a/Detectors/TRD/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/TRD/workflow/src/EntropyDecoderSpec.cxx
@@ -27,11 +27,10 @@ namespace o2
 {
 namespace trd
 {
-
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -44,7 +43,7 @@ class EntropyDecoderSpec : public o2::framework::Task
   TStopwatch mTimer;
 };
 
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -109,7 +108,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"triggers"}, "TRD", "TRKTRGRD", 0, Lifetime::Timeframe},
@@ -119,19 +118,20 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_TRD", "TRD", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_TRD", "TRD", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TRD/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_TRD", "TRD", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TRD/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "trd-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"correct-trd-trigger-offset", VariantType::Bool, false, {"Correct decoded IR by TriggerOffsetsParam::LM_L0"}},
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"correct-trd-trigger-offset", VariantType::Bool, false, {"Correct decoded IR by TriggerOffsetsParam::LM_L0"}},
             {"bogus-trigger-rejection", VariantType::Int, 10, {">0 : discard, warn N times, <0 : warn only, =0: no check for triggers with no tracklets or bogus IR"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace trd
 } // namespace o2
diff --git a/Detectors/TRD/workflow/src/EntropyEncoderSpec.cxx b/Detectors/TRD/workflow/src/EntropyEncoderSpec.cxx
index d345dd74141ed..18b9a012db2f1 100644
--- a/Detectors/TRD/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/TRD/workflow/src/EntropyEncoderSpec.cxx
@@ -27,11 +27,10 @@ namespace o2
 {
 namespace trd
 {
-
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -44,7 +43,7 @@ class EntropyEncoderSpec : public o2::framework::Task
   TStopwatch mTimer;
 };
 
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -92,13 +91,16 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("triggers", "TRD", "TRKTRGRD", 0, Lifetime::Timeframe);
   inputs.emplace_back("tracklets", "TRD", "TRACKLETS", 0, Lifetime::Timeframe);
   inputs.emplace_back("digits", "TRD", "DIGITS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "TRD", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TRD/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "TRD", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("TRD/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -107,14 +109,12 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{"TRD", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "TRD", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"bogus-trigger-check", VariantType::Int, 10, {"max bogus triggers to report, all if < 0"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace trd
 } // namespace o2
diff --git a/Detectors/TRD/workflow/src/entropy-encoder-workflow.cxx b/Detectors/TRD/workflow/src/entropy-encoder-workflow.cxx
index 83fff5bceedef..177f6e4913a26 100644
--- a/Detectors/TRD/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/TRD/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -37,6 +38,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   WorkflowSpec wf;
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::trd::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames")));
+  wf.emplace_back(o2::trd::getEntropyEncoderSpec(cfgc.options().get<bool>("select-ir-frames"), cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }
diff --git a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
index f8823e4fc66a5..a299431ef17fc 100644
--- a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
+++ b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace zdc
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op) : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::ZDC) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::ZDC, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/ZDC/workflow/include/ZDCWorkflow/EntropyDecoderSpec.h b/Detectors/ZDC/workflow/include/ZDCWorkflow/EntropyDecoderSpec.h
index ae53ca8bdd0fb..6226b4dc99fe3 100644
--- a/Detectors/ZDC/workflow/include/ZDCWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/ZDC/workflow/include/ZDCWorkflow/EntropyDecoderSpec.h
@@ -28,7 +28,7 @@ namespace zdc
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(int verbosity);
+  EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -41,7 +41,7 @@ class EntropyDecoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec);
+framework::DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace zdc
 } // namespace o2
diff --git a/Detectors/ZDC/workflow/include/ZDCWorkflow/EntropyEncoderSpec.h b/Detectors/ZDC/workflow/include/ZDCWorkflow/EntropyEncoderSpec.h
index 4979de5a30332..44c4585bf0c3f 100644
--- a/Detectors/ZDC/workflow/include/ZDCWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/ZDC/workflow/include/ZDCWorkflow/EntropyEncoderSpec.h
@@ -29,7 +29,7 @@ namespace zdc
 class EntropyEncoderSpec : public o2::framework::Task
 {
  public:
-  EntropyEncoderSpec(bool selIR);
+  EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -43,7 +43,7 @@ class EntropyEncoderSpec : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false);
+framework::DataProcessorSpec getEntropyEncoderSpec(bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace zdc
 } // namespace o2
diff --git a/Detectors/ZDC/workflow/src/EntropyDecoderSpec.cxx b/Detectors/ZDC/workflow/src/EntropyDecoderSpec.cxx
index bf870324ce442..59c774662525a 100644
--- a/Detectors/ZDC/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/ZDC/workflow/src/EntropyDecoderSpec.cxx
@@ -25,8 +25,7 @@ namespace o2
 {
 namespace zdc
 {
-
-EntropyDecoderSpec::EntropyDecoderSpec(int verbosity) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder)
+EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, ctfdictOpt)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -81,7 +80,7 @@ void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec, const std::string& ctfdictOpt)
 {
   std::vector<OutputSpec> outputs{
     OutputSpec{{"trig"}, "ZDC", "DIGITSBC", 0, Lifetime::Timeframe},
@@ -91,17 +90,18 @@ DataProcessorSpec getEntropyDecoderSpec(int verbosity, unsigned int sspec)
 
   std::vector<InputSpec> inputs;
   inputs.emplace_back("ctf_ZDC", "ZDC", "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict_ZDC", "ZDC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("ZDC/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict_ZDC", "ZDC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("ZDC/Calib/CTFDictionaryTree"));
+  }
   inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
     "zdc-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(verbosity, ctfdictOpt)},
+    Options{{"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace zdc
 } // namespace o2
diff --git a/Detectors/ZDC/workflow/src/EntropyEncoderSpec.cxx b/Detectors/ZDC/workflow/src/EntropyEncoderSpec.cxx
index abbd821fcb749..1a12360645ab2 100644
--- a/Detectors/ZDC/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/ZDC/workflow/src/EntropyEncoderSpec.cxx
@@ -27,8 +27,7 @@ namespace o2
 {
 namespace zdc
 {
-
-EntropyEncoderSpec::EntropyEncoderSpec(bool selIR) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder), mSelIR(selIR)
+EntropyEncoderSpec::EntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt) : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, ctfdictOpt), mSelIR(selIR)
 {
   mTimer.Stop();
   mTimer.Reset();
@@ -74,13 +73,16 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getEntropyEncoderSpec(bool selIR)
+DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
   inputs.emplace_back("trig", "ZDC", "DIGITSBC", 0, Lifetime::Timeframe);
   inputs.emplace_back("chan", "ZDC", "DIGITSCH", 0, Lifetime::Timeframe);
   inputs.emplace_back("peds", "ZDC", "DIGITSPD", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ctfdict", "ZDC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("ZDC/Calib/CTFDictionaryTree"));
+
+  if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
+    inputs.emplace_back("ctfdict", "ZDC", "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("ZDC/Calib/CTFDictionaryTree"));
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
   }
@@ -89,13 +91,11 @@ DataProcessorSpec getEntropyEncoderSpec(bool selIR)
     inputs,
     Outputs{{"ZDC", "CTFDATA", 0, Lifetime::Timeframe},
             {{"ctfrep"}, "ZDC", "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR)},
-    Options{{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
-            {"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(selIR, ctfdictOpt)},
+    Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
-
 } // namespace zdc
 } // namespace o2
diff --git a/Detectors/ZDC/workflow/src/entropy-encoder-workflow.cxx b/Detectors/ZDC/workflow/src/entropy-encoder-workflow.cxx
index 070c65ac9196a..9ab0e10098f43 100644
--- a/Detectors/ZDC/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/ZDC/workflow/src/entropy-encoder-workflow.cxx
@@ -23,6 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
@@ -38,6 +39,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
   bool selIR = cfgc.options().get<bool>("select-ir-frames");
-  wf.emplace_back(o2::zdc::getEntropyEncoderSpec(selIR));
+  wf.emplace_back(o2::zdc::getEntropyEncoderSpec(selIR, cfgc.options().get<std::string>("ctf-dict")));
   return wf;
 }

From d00ca87143fa6617948d44aff6ea98e75b7ba7a9 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 4 Feb 2026 08:06:11 +0100
Subject: [PATCH 1275/1764] Revert "ITS: GPU: more memory clearing in
 processNeighbours"

This reverts commit aa3ef3751f282ee477e0636d6bd5697c43103381.

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 84 ++++++-------------
 1 file changed, 26 insertions(+), 58 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 50888c676df77..a12237358c8bd 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -39,7 +39,6 @@
 // O2 track model
 #include "ReconstructionDataFormats/Track.h"
 #include "DetectorsBase/Propagator.h"
-#include "utils/strtag.h"
 using namespace o2::track;
 
 namespace o2::its
@@ -1107,19 +1106,11 @@ void processNeighboursHandler(const int startLayer,
                               const int nBlocks,
                               const int nThreads)
 {
-  constexpr uint64_t Tag = qStr2Tag("ITS_PNH1");
-
-  // allocators used
   auto allocInt = gpu::TypedAllocator<int>(alloc);
   auto allocCellSeed = gpu::TypedAllocator<CellSeed<nLayers>>(alloc);
-  // use sync_policy, this part cannot be run async but tell thrust to use the allocator
-  auto sync_policy = THRUST_NAMESPACE::par(gpu::TypedAllocator<char>(alloc));
-
-  // put initial computation on Tag1
-  alloc->pushTagOnStack(Tag);
-
-  // start processing of cells
   thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(gpu::Stream::DefaultStream);
+
   gpu::processNeighboursKernel<true, nLayers><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
@@ -1138,10 +1129,10 @@ void processNeighboursHandler(const int startLayer,
     maxChi2ClusterAttachment,
     propagator,
     matCorrType);
-  thrust::exclusive_scan(sync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
-  auto foundSeeds{foundSeedsTable.back()};
-  thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeeds, 0, allocInt);
-  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> updatedCellSeed(foundSeeds, allocCellSeed);
+  thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
+
+  thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
+  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
   gpu::processNeighboursKernel<false, nLayers><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
@@ -1160,41 +1151,20 @@ void processNeighboursHandler(const int startLayer,
     maxChi2ClusterAttachment,
     propagator,
     matCorrType);
+  GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
 
-  // now do inward steps until stop is reached
   int level = startLevel;
-
-  // Host buffers to break dependency
-  // FIXME: these should be on our memory resource!
-  std::vector<int> hostCellId;
-  std::vector<CellSeed<nLayers>> hostCellSeed;
-
-  // inward loop
+  thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
+  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> lastCellSeed(allocCellSeed);
   for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
-    // copy current results to host
-    hostCellId.resize(updatedCellId.size());
-    hostCellSeed.resize(updatedCellSeed.size());
-    thrust::copy(updatedCellId.begin(), updatedCellId.end(), hostCellId.begin());
-    thrust::copy(updatedCellSeed.begin(), updatedCellSeed.end(), hostCellSeed.begin());
-
-    auto lastCellSeedSize{hostCellSeed.size()};
-    // but before we clear the memory, and immediately start a new block
-    alloc->popTagOffStack(Tag);
-    alloc->pushTagOnStack(Tag);
-
-    // based on the previous step's result create new LUT and zero it
-    thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(foundSeedsTable);
-    foundSeedsTable.resize(lastCellSeedSize + 1);
-    thrust::fill(sync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
-
-    // recreate lastCell vectors from host
-    thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(hostCellId.begin(), hostCellId.end(), allocInt);
-    thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> lastCellSeed(hostCellSeed.begin(), hostCellSeed.end(), allocCellSeed);
-    // also create new vectors on new block
+    lastCellSeed.swap(updatedCellSeed);
+    lastCellId.swap(updatedCellId);
     thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>>(allocCellSeed).swap(updatedCellSeed);
     thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellId);
+    auto lastCellSeedSize{lastCellSeed.size()};
+    foundSeedsTable.resize(lastCellSeedSize + 1);
+    thrust::fill(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
-    // start step
     gpu::processNeighboursKernel<true, nLayers><<<nBlocks, nThreads>>>(
       iLayer,
       --level,
@@ -1213,13 +1183,14 @@ void processNeighboursHandler(const int startLayer,
       maxChi2ClusterAttachment,
       propagator,
       matCorrType);
-    // how many new seeds where found
-    thrust::exclusive_scan(sync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
-    foundSeeds = foundSeedsTable.back();
-    // do a resize, we don't need to set the memory now since we know that all of these are written to
-    // Note though this does not clear the memory...
+    thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
+
+    auto foundSeeds{foundSeedsTable.back()};
     updatedCellId.resize(foundSeeds);
+    thrust::fill(nosync_policy, updatedCellId.begin(), updatedCellId.end(), 0);
     updatedCellSeed.resize(foundSeeds);
+    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed<nLayers>());
+
     gpu::processNeighboursKernel<false, nLayers><<<nBlocks, nThreads>>>(
       iLayer,
       level,
@@ -1239,15 +1210,12 @@ void processNeighboursHandler(const int startLayer,
       propagator,
       matCorrType);
   }
-
-  // final copy of result
-  const auto selector = gpu::seed_selector<nLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5));
-  const auto count = thrust::count_if(sync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), selector);
-  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> outSeeds(count, allocCellSeed);
-  thrust::copy_if(sync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), selector);
-  seedsHost.reserve(seedsHost.size() + count);
-  thrust::copy(outSeeds.begin(), outSeeds.end(), std::back_inserter(seedsHost));
-  alloc->popTagOffStack(Tag);
+  GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
+  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> outSeeds(updatedCellSeed.size(), allocCellSeed);
+  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector<nLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
+  auto s{end - outSeeds.begin()};
+  seedsHost.reserve(seedsHost.size() + s);
+  thrust::copy(outSeeds.begin(), outSeeds.begin() + s, std::back_inserter(seedsHost));
 }
 
 template <int nLayers>

From 19803f64dccc492a0bfd8d528ea481dcc972faf8 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 5 Feb 2026 17:44:10 +0100
Subject: [PATCH 1276/1764] ITS: GPU: add minimal version of clearing

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index a12237358c8bd..eacf514c7a91d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -32,9 +32,9 @@
 #include "ITStracking/Cluster.h"
 #include "ITStracking/Cell.h"
 #include "DataFormatsITS/TrackITS.h"
-
 #include "ITStrackingGPU/TrackingKernels.h"
 #include "ITStrackingGPU/Utils.h"
+#include "utils/strtag.h"
 
 // O2 track model
 #include "ReconstructionDataFormats/Track.h"
@@ -1106,6 +1106,8 @@ void processNeighboursHandler(const int startLayer,
                               const int nBlocks,
                               const int nThreads)
 {
+  constexpr uint64_t Tag = qStr2Tag("ITS_PNH1");
+  alloc->pushTagOnStack(Tag);
   auto allocInt = gpu::TypedAllocator<int>(alloc);
   auto allocCellSeed = gpu::TypedAllocator<CellSeed<nLayers>>(alloc);
   thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
@@ -1216,6 +1218,7 @@ void processNeighboursHandler(const int startLayer,
   auto s{end - outSeeds.begin()};
   seedsHost.reserve(seedsHost.size() + s);
   thrust::copy(outSeeds.begin(), outSeeds.begin() + s, std::back_inserter(seedsHost));
+  alloc->popTagOffStack(Tag);
 }
 
 template <int nLayers>

From 5639312fdb8f49ef5365f32985bf9a53187add07 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Feb 2026 21:27:14 +0100
Subject: [PATCH 1277/1764] GPU CMake: Avoid repetitive JSON parsing

---
 GPU/GPUTracking/CMakeLists.txt                |  6 ++--
 .../Definitions/Parameters/GPUParameters.json |  1 -
 .../cmake/gpu_param_header_generator.cmake    | 31 +++++++++++++------
 3 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 816d578fb31a3..adfb79a78b994 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -410,12 +410,12 @@ target_sources(${targetName}
                BASE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
 
 make_directory(${CMAKE_CURRENT_BINARY_DIR}/genGPUArch)
-set(GPU_CONST_PARAM_ARCHITECTUES AMPERE TURING VEGA MI100)
+set(GPU_CONST_PARAM_ARCHITECTUES "AMPERE;TURING;VEGA;MI100")
 set(GPU_CONST_PARAM_FILES "")
+set(GPU_ARCH_PARAMS_HEADER ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/GPUDefParametersDefaults_OnTheFly.h)
+generate_gpu_param_header("${GPU_CONST_PARAM_ARCHITECTUES}" ${GPU_ARCH_PARAMS_HEADER})
 foreach(GPU_ARCH ${GPU_CONST_PARAM_ARCHITECTUES})
   set(PARAMFILE ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/gpu_const_param_${GPU_ARCH}.par)
-  set(GPU_ARCH_PARAMS_HEADER ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/GPUDefParametersDefaults_${GPU_ARCH}.h)
-  generate_gpu_param_header(${GPU_ARCH} ${GPU_ARCH_PARAMS_HEADER})
   add_custom_command(
     OUTPUT ${PARAMFILE}
     COMMAND bash -c
diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
index 285919559c04c..3c6f1af1aab2f 100644
--- a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
+++ b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
@@ -2,7 +2,6 @@
   "CORE": {
     "WARP_SIZE": {
       "default":      32,
-      "default_cpu":  1,
       "MI100":        64,
       "VEGA":         64,
       "TAHITI":       32,
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index 3770e30f2583c..526303a353106 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -12,7 +12,10 @@
 # file gpu_param_header_generator.cmake
 # author Gabriele Cimador
 
-function(generate_macros json_content header types arch_key use_ifndef_guard)
+function(generate_macros json_content output types arch_list)
+    foreach(arch IN LISTS arch_list)
+        set(${output}_${arch} "")
+    endforeach()
     foreach(TYPE IN LISTS types)
         string(JSON n_params LENGTH "${json_content}" "${TYPE}")
         math(EXPR last "${n_params} - 1")
@@ -22,8 +25,12 @@ function(generate_macros json_content header types arch_key use_ifndef_guard)
             math(EXPR last_arch "${n_archs} - 1")
             foreach(iArch RANGE 0 ${last_arch})
                 string(JSON arch MEMBER "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${iArch}")
-                if(arch STREQUAL "${arch_key}")
-                    string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch_key}")
+                if(arch STREQUAL "default_cpu" AND NOT TYPE STREQUAL "PAR")
+                  message(FATAL_ERROR "Bogus entry ${param_name} for ${arch}")
+                endif()
+                list(FIND arch_list "${arch}" list_idx)
+                if(list_idx GREATER -1)
+                    string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch}")
                     if(TYPE STREQUAL "LB")
                         set(MACRO_NAME "GPUCA_LB_${param_name}")
                     elseif(TYPE STREQUAL "PAR")
@@ -36,16 +43,19 @@ function(generate_macros json_content header types arch_key use_ifndef_guard)
                     string(REGEX REPLACE " *\\]$" "" vals "${vals}")
                     string(REGEX REPLACE "\"" "" vals "${vals}")
                     set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
-                    if(use_ifndef_guard)
+                    if(arch MATCHES ^default)
                         # fallback defaults are wrapped in #ifndef
-                        file(APPEND "${header}" "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+                        string(APPEND ${output}_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
                     else()
-                        file(APPEND "${header}" "${MACRO_DEFINITION}\n")
+                        string(APPEND ${output}_${arch} "${MACRO_DEFINITION}\n")
                     endif()
                 endif()
             endforeach()
         endforeach()
     endforeach()
+    foreach(arch IN LISTS arch_list)
+        set(${output}_${arch} "${${output}_${arch}}" PARENT_SCOPE)
+    endforeach()
 endfunction()
 
 function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
@@ -68,6 +78,7 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
     set(TYPES CORE LB PAR)
     # Per architecture definitions
     set(_first TRUE)
+    generate_macros("${JSON_CONTENT}" TMP_OUTPUT "${TYPES}" "${ARCH_LIST};default;default_cpu")
     foreach(ARCH IN LISTS ARCH_LIST)
         if(_first)
             file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUTYPE_${ARCH})\n\n")
@@ -75,7 +86,7 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
         else()
             file(APPEND "${TMP_HEADER}" "#elif defined(GPUCA_GPUTYPE_${ARCH})\n\n")
         endif()
-        generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "${TYPES}" "${ARCH}" "")
+        file(APPEND "${TMP_HEADER}" ${TMP_OUTPUT_${ARCH}})
     endforeach()
     if(NOT _first)
         file(APPEND "${TMP_HEADER}" "#else\n#error GPU TYPE NOT SET\n#endif\n")
@@ -83,16 +94,16 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
 
     # Default parameters
     file(APPEND "${TMP_HEADER}" "\n// Default parameters if not defined for the target architecture\n\n")
-    generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "${TYPES}" "default" "use_ifndef_guard")
+    file(APPEND "${TMP_HEADER}" ${TMP_OUTPUT_default})
     file(APPEND "${TMP_HEADER}" "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
 
     # CPU fallback
     file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC //Defaults for non-LB parameters also for CPU fallback\n\n")
-    generate_macros("${JSON_CONTENT}" "${TMP_HEADER}" "PAR" "default_cpu" "use_ifndef_guard")
+    file(APPEND "${TMP_HEADER}" ${TMP_OUTPUT_default_cpu})
     file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUCODE_GENRTC\n")
 
     file(APPEND "${TMP_HEADER}" "\n#endif // GPUDEFPARAMETERSDEFAULTS_H\n")
     file(RENAME "${TMP_HEADER}" "${OUT_HEADER}")
     message(STATUS "Generated ${OUT_HEADER}")
     add_custom_target(GPU_PARAM_HEADER_${GPU_ARCH}_ALL ALL DEPENDS ${OUT_HEADER} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/gpu_param_header_generator.cmake ${GPU_PARAM_JSON})
-endfunction()
\ No newline at end of file
+endfunction()

From e7b5a26d2ad81644dc692c3b740d3124f49d71b0 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Feb 2026 22:06:35 +0100
Subject: [PATCH 1278/1764] GPU CMake: Generate optimized parameter files for
 all available architectures, not only for hardcoded list

---
 GPU/GPUTracking/CMakeLists.txt                |  3 +-
 .../cmake/gpu_param_header_generator.cmake    | 37 +++++++++++++++----
 2 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index adfb79a78b994..9f349d0e21f4f 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -410,10 +410,9 @@ target_sources(${targetName}
                BASE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
 
 make_directory(${CMAKE_CURRENT_BINARY_DIR}/genGPUArch)
-set(GPU_CONST_PARAM_ARCHITECTUES "AMPERE;TURING;VEGA;MI100")
 set(GPU_CONST_PARAM_FILES "")
 set(GPU_ARCH_PARAMS_HEADER ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/GPUDefParametersDefaults_OnTheFly.h)
-generate_gpu_param_header("${GPU_CONST_PARAM_ARCHITECTUES}" ${GPU_ARCH_PARAMS_HEADER})
+generate_gpu_param_header("ALL" ${GPU_ARCH_PARAMS_HEADER} "GPU_CONST_PARAM_ARCHITECTUES")
 foreach(GPU_ARCH ${GPU_CONST_PARAM_ARCHITECTUES})
   set(PARAMFILE ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/gpu_const_param_${GPU_ARCH}.par)
   add_custom_command(
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index 526303a353106..0c3e905a697c0 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -12,10 +12,12 @@
 # file gpu_param_header_generator.cmake
 # author Gabriele Cimador
 
-function(generate_macros json_content output types arch_list)
+function(generate_macros json_content output types arch_list arch_list_output)
     foreach(arch IN LISTS arch_list)
-        set(${output}_${arch} "")
+        set(OUTPUT_TMP_${arch} "")
     endforeach()
+    set(arch_list_output_tmp)
+    list(FIND arch_list "ALL" do_all_architectures)
     foreach(TYPE IN LISTS types)
         string(JSON n_params LENGTH "${json_content}" "${TYPE}")
         math(EXPR last "${n_params} - 1")
@@ -28,7 +30,14 @@ function(generate_macros json_content output types arch_list)
                 if(arch STREQUAL "default_cpu" AND NOT TYPE STREQUAL "PAR")
                   message(FATAL_ERROR "Bogus entry ${param_name} for ${arch}")
                 endif()
-                list(FIND arch_list "${arch}" list_idx)
+                if(do_all_architectures GREATER -1)
+                    if(arch_list_output AND NOT arch MATCHES ^default)
+                        list(APPEND arch_list_output_tmp "${arch}")
+                    endif()
+                    set(list_idx 0)
+                else()
+                    list(FIND arch_list "${arch}" list_idx)
+                endif()
                 if(list_idx GREATER -1)
                     string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch}")
                     if(TYPE STREQUAL "LB")
@@ -45,17 +54,22 @@ function(generate_macros json_content output types arch_list)
                     set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
                     if(arch MATCHES ^default)
                         # fallback defaults are wrapped in #ifndef
-                        string(APPEND ${output}_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+                        string(APPEND OUTPUT_TMP_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
                     else()
-                        string(APPEND ${output}_${arch} "${MACRO_DEFINITION}\n")
+                        string(APPEND OUTPUT_TMP_${arch} "${MACRO_DEFINITION}\n")
                     endif()
                 endif()
             endforeach()
         endforeach()
     endforeach()
     foreach(arch IN LISTS arch_list)
-        set(${output}_${arch} "${${output}_${arch}}" PARENT_SCOPE)
+        set(${output}_${arch} "${OUTPUT_TMP_${arch}}" PARENT_SCOPE)
     endforeach()
+    if(arch_list_output)
+        list(REMOVE_DUPLICATES arch_list_output_tmp)
+        list(SORT arch_list_output_tmp)
+        set(${arch_list_output} "${arch_list_output_tmp}" PARENT_SCOPE)
+    endif()
 endfunction()
 
 function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
@@ -78,7 +92,14 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
     set(TYPES CORE LB PAR)
     # Per architecture definitions
     set(_first TRUE)
-    generate_macros("${JSON_CONTENT}" TMP_OUTPUT "${TYPES}" "${ARCH_LIST};default;default_cpu")
+    generate_macros("${JSON_CONTENT}" TMP_OUTPUT "${TYPES}" "${ARCH_LIST};default;default_cpu" "JSON_ARCHITECTURES")
+    list(FIND ARCH_LIST "ALL" do_all_architectures)
+    if(ARGC GREATER 2)
+        set(${ARGV2} "${JSON_ARCHITECTURES}" PARENT_SCOPE)
+    endif()
+    if(do_all_architectures GREATER -1)
+        set(ARCH_LIST ${JSON_ARCHITECTURES})
+    endif()
     foreach(ARCH IN LISTS ARCH_LIST)
         if(_first)
             file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUTYPE_${ARCH})\n\n")
@@ -98,7 +119,7 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
     file(APPEND "${TMP_HEADER}" "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
 
     # CPU fallback
-    file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC //Defaults for non-LB parameters also for CPU fallback\n\n")
+    file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC // Defaults for non-LB parameters also for CPU fallback\n\n")
     file(APPEND "${TMP_HEADER}" ${TMP_OUTPUT_default_cpu})
     file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUCODE_GENRTC\n")
 

From 0f4e3152fb0fe97fd29acffbc7954937cf82e381 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Feb 2026 22:36:28 +0100
Subject: [PATCH 1279/1764] GPU CMake: Make source for GPU parameters
 configurable, auto-convert CSV to JSON if necessary

---
 GPU/GPUTracking/CMakeLists.txt                |  17 +++
 .../Definitions/Parameters/GPUParameters.csv  | 113 ++++++++++++++++++
 ...meters.json => GPUParameters.json.example} |   0
 GPU/GPUTracking/Standalone/cmake/config.cmake |   1 +
 .../cmake/gpu_param_header_generator.cmake    |   1 -
 5 files changed, 131 insertions(+), 1 deletion(-)
 create mode 100644 GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
 rename GPU/GPUTracking/Definitions/Parameters/{GPUParameters.json => GPUParameters.json.example} (100%)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 9f349d0e21f4f..cd17d8f284b13 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -107,6 +107,23 @@ set(SRCS_NO_H SectorTracker/GPUTPCTrackerDump.cxx
               Global/GPUChainTrackingDebugAndProfiling.cxx
               Global/GPUChainTrackingIO.cxx)
 
+if(GPUCA_OVERRIDE_PARAMETER_FILE)
+    set(GPU_PARAM_JSON ${GPUCA_OVERRIDE_PARAMETER_FILE})
+else()
+    set(GPU_PARAM_JSON ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/GPUParameters.csv)
+endif()
+get_filename_component(GPU_PARAM_JSON_EXT ${GPU_PARAM_JSON} EXT)
+string(TOLOWER "${GPU_PARAM_JSON_EXT}" GPU_PARAM_JSON_EXT)
+if(GPU_PARAM_JSON_EXT STREQUAL .csv)
+    execute_process(
+        COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/csv_to_json.sh "${GPU_PARAM_JSON}"
+        OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    )
+    message(STATUS "Converted ${GPU_PARAM_JSON} to ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json")
+    set(GPU_PARAM_JSON ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json)
+endif()
+
 set(ON_THE_FLY_DIR ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
 file(MAKE_DIRECTORY ${ON_THE_FLY_DIR})
 include(cmake/gpu_param_header_generator.cmake)
diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
new file mode 100644
index 0000000000000..5afa99554f5d0
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
@@ -0,0 +1,113 @@
+Architecture,default,MI100,VEGA,TAHITI,TESLA,FERMI,PASCAL,KEPLER,AMPERE,TURING,default_cpu
+,,,,,,,,,,,
+CORE:,,,,,,,,,,,
+WARP_SIZE,32,64,64,32,32,32,32,32,32,32,
+THREAD_COUNT_DEFAULT,256,256,256,,,,,,512,512,
+,,,,,,,,,,,
+LB:,,,,,,,,,,,
+GPUTPCCreateTrackingData,256,"[256, 7]","[192, 2]",,,,,,384,256,
+GPUTPCTrackletConstructor,256,"[768, 8]","[512, 10]","[256, 2]","[256, 1]","[256, 2]","[1024, 2]","[512, 4]","[256, 2]","[256, 2]",
+GPUTPCTrackletSelector,256,"[384, 5]","[192, 10]","[256, 3]","[256, 1]","[256, 3]","[512, 4]","[256, 3]","[192, 3]","[192, 3]",
+GPUTPCNeighboursFinder,256,"[192, 8]","[960, 8]",256,256,256,512,256,"[640, 1]","[640, 1]",
+GPUTPCNeighboursCleaner,256,"[128, 5]","[384, 9]",256,256,256,256,256,512,512,
+GPUTPCExtrapolationTracking,256,"[256, 7]","[256, 2]",,,,,,"[128, 4]","[192, 2]",
+GPUTRDTrackerKernels_gpuVersion,512,,,,,,,,,,
+GPUTPCCreateOccupancyMap_fill,256,,,,,,,,,,
+GPUTPCCreateOccupancyMap_fold,256,,,,,,,,,,
+GPUTRDTrackerKernels_o2Version,512,,,,,,,,,,
+GPUTPCCompressionKernels_step0attached,256,"[128, 1]","[64, 2]",,,,,,"[64, 2]",128,
+GPUTPCCompressionKernels_step1unattached,256,"[512, 2]","[512, 2]",,,,,,"[512, 3]","[512, 2]",
+GPUTPCDecompressionKernels_step0attached,256,"[128, 2]","[128, 2]",,,,,,"[32, 1]","[32, 1]",
+GPUTPCDecompressionKernels_step1unattached,256,"[64, 2]","[64, 2]",,,,,,"[32, 1]","[32, 1]",
+GPUTPCDecompressionUtilKernels_sortPerSectorRow,256,,,,,,,,,,
+GPUTPCDecompressionUtilKernels_countFilteredClusters,256,,,,,,,,,,
+GPUTPCDecompressionUtilKernels_storeFilteredClusters,256,,,,,,,,,,
+GPUTPCCFDecodeZS,"[128, 4]","[64, 4]","[64, 1]",,,,,,"[64, 10]","[64, 8]",
+GPUTPCCFDecodeZSLink,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",
+GPUTPCCFDecodeZSDenseLink,"""GPUCA_WARP_SIZE""","[""GPUCA_WARP_SIZE"", 4]","[""GPUCA_WARP_SIZE"", 14]",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",
+GPUTPCCFGather,"[1024, 1]","[1024, 5]","[1024, 1]",,,,,,"[1024, 1]","[1024, 1]",
+COMPRESSION_GATHER,1024,1024,1024,,,,,,1024,1024,
+GPUTPCGMMergerTrackFit,256,"[192, 2]","[64, 7]",,,,,,"[64, 4]","[32, 8]",
+GPUTPCGMMergerFollowLoopers,256,"[256, 5]","[256, 4]",,,,,,"[64, 12]","[128, 4]",
+GPUTPCGMMergerSectorRefit,256,"[64, 4]","[256, 2]",,,,,,"[32, 6]","[64, 5]",
+GPUTPCGMMergerUnpackResetIds,256,256,256,,,,,,256,256,
+GPUTPCGMMergerUnpackGlobal,256,256,256,,,,,,256,256,
+GPUTPCGMMergerResolve_step0,256,512,256,,,,,,256,256,
+GPUTPCGMMergerResolve_step1,256,512,256,,,,,,256,256,
+GPUTPCGMMergerResolve_step2,256,512,256,,,,,,256,256,
+GPUTPCGMMergerResolve_step3,256,512,256,,,,,,256,256,
+GPUTPCGMMergerResolve_step4,256,512,256,,,,,,"[256, 4]","[256, 4]",
+GPUTPCGMMergerClearLinks,256,256,256,,,,,,256,256,
+GPUTPCGMMergerMergeWithinPrepare,256,256,256,,,,,,256,256,
+GPUTPCGMMergerMergeSectorsPrepare,256,256,256,,,,,,"[256, 2]","[256, 2]",
+GPUTPCGMMergerMergeBorders_step0,256,512,256,,,,,,192,192,
+GPUTPCGMMergerMergeBorders_step2,256,512,256,,,,,,"[64, 2]",256,
+GPUTPCGMMergerMergeCE,256,512,256,,,,,,256,256,
+GPUTPCGMMergerLinkExtrapolatedTracks,256,256,256,,,,,,256,256,
+GPUTPCGMMergerCollect,256,"[768, 1]","[1024, 1]",,,,,,"[256, 2]","[128, 2]",
+GPUTPCGMMergerSortTracksPrepare,256,256,256,,,,,,256,256,
+GPUTPCGMMergerPrepareForFit_step0,256,256,256,,,,,,256,256,
+GPUTPCGMMergerPrepareForFit_step1,256,256,256,,,,,,256,256,
+GPUTPCGMMergerPrepareForFit_step2,256,256,256,,,,,,256,256,
+GPUTPCGMMergerFinalize_step0,256,,256,,,,,,,,
+GPUTPCGMMergerFinalize_step1,256,,256,,,,,,,,
+GPUTPCGMMergerFinalize_step2,256,,256,,,,,,,,
+GPUTPCGMMergerMergeLoopers_step0,256,,,,,,,,,,
+GPUTPCGMMergerMergeLoopers_step1,256,,,,,,,,,,
+GPUTPCGMMergerMergeLoopers_step2,256,,,,,,,,,,
+GPUTPCGMO2Output_prepare,256,,,,,,,,,,
+GPUTPCGMO2Output_output,256,,,,,,,,,,
+GPUTPCStartHitsFinder,256,"[1024, 2]","[1024, 7]",256,256,256,256,256,512,512,
+GPUTPCStartHitsSorter,256,"[1024, 5]","[512, 7]",256,256,256,256,256,"[512, 1]","[512, 1]",
+GPUTPCCFCheckPadBaseline,576,"[576, 2]","[576, 2]",,,,,,"[576, 2]",,
+GPUTPCCFChargeMapFiller_fillIndexMap,512,512,512,,,,,,448,,
+GPUTPCCFChargeMapFiller_fillFromDigits,512,512,512,,,,,,448,,
+GPUTPCCFChargeMapFiller_findFragmentStart,512,512,512,,,,,,448,,
+GPUTPCCFPeakFinder,512,"[512, 9]","[512, 4]",,,,,,128,,
+GPUTPCCFNoiseSuppression,512,512,512,,,,,,448,,
+GPUTPCCFDeconvolution,512,"[512, 5]","[512, 5]",,,,,,384,,
+GPUTPCCFClusterizer,512,"[448, 3]","[512, 2]",,,,,,448,,
+GPUTPCNNClusterizerKernels,512,,,,,,,,,,
+GPUTrackingRefitKernel_mode0asGPU,256,,,,,,,,,,
+GPUTrackingRefitKernel_mode1asTrackParCov,256,,,,,,,,,,
+GPUMemClean16,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,
+GPUitoa,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,
+GPUTPCCFNoiseSuppression_noiseSuppression,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,
+GPUTPCCFNoiseSuppression_updatePeaks,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,
+GPUTPCNNClusterizerKernels_runCfClusterizer,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
+GPUTPCNNClusterizerKernels_fillInputNNCPU,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
+GPUTPCNNClusterizerKernels_fillInputNNGPU,1024,,,,,,,,,,
+GPUTPCNNClusterizerKernels_determineClass1Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
+GPUTPCNNClusterizerKernels_determineClass2Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishClass1Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishClass2Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishDeconvolutionFlags,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
+GPUTPCCFStreamCompaction_scanStart,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
+GPUTPCCFStreamCompaction_scanUp,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
+GPUTPCCFStreamCompaction_scanTop,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
+GPUTPCCFStreamCompaction_scanDown,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
+GPUTPCCFStreamCompaction_compactDigits,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
+GPUTPCCompressionGatherKernels_unbuffered,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered32,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered64,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered128,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
+GPUTPCCompressionGatherKernels_multiBlock,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
+GPUTPCGMMergerFinalize_0,256,256,,,,,,,256,256,
+GPUTPCGMMergerFinalize_1,256,256,,,,,,,256,256,
+GPUTPCGMMergerFinalize_2,256,256,,,,,,,256,256,
+,,,,,,,,,,,
+PAR:,,,,,,,,,,,
+AMD_EUS_PER_CU,0,4,4,,,,,,,,0
+SORT_STARTHITS,1,,,,,,,,,,0
+NEIGHBOURS_FINDER_MAX_NNEIGHUP,6,10,4,,,,,,4,4,0
+NEIGHBOURS_FINDER_UNROLL_GLOBAL,4,4,2,,,,,,,,0
+NEIGHBOURS_FINDER_UNROLL_SHARED,1,0,0,,,,,,,,0
+TRACKLET_SELECTOR_HITS_REG_SIZE,12,9,27,,,,,,20,20,0
+ALTERNATE_BORDER_SORT,0,1,1,,,,,,1,1,0
+SORT_BEFORE_FIT,0,1,1,,,,,,1,1,0
+NO_ATOMIC_PRECHECK,0,1,1,,,,,,1,1,0
+DEDX_STORAGE_TYPE,"""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t""","""float"""
+MERGER_INTERPOLATION_ERROR_TYPE,"""float""","""half""","""half""",,,,,,"""half""","""half""","""float"""
+COMP_GATHER_KERNEL,0,4,4,,,,,,4,4,0
+COMP_GATHER_MODE,2,3,3,,,,,,3,3,0
+CF_SCAN_WORKGROUP_SIZE,512,,,,,,,,,,0
diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.json.example
similarity index 100%
rename from GPU/GPUTracking/Definitions/Parameters/GPUParameters.json
rename to GPU/GPUTracking/Definitions/Parameters/GPUParameters.json.example
diff --git a/GPU/GPUTracking/Standalone/cmake/config.cmake b/GPU/GPUTracking/Standalone/cmake/config.cmake
index ca723063b6d3b..9355311db617c 100644
--- a/GPU/GPUTracking/Standalone/cmake/config.cmake
+++ b/GPU/GPUTracking/Standalone/cmake/config.cmake
@@ -41,3 +41,4 @@ set(CUDA_COMPUTETARGET "default")           # 86 89
 #set(GPUCA_CONFIG_COMPILER gcc)             # gcc / clang
 #set(GPUCA_CONFIG_WERROR 1)
 #add_definitions(-DGPUCA_GPU_DEBUG_PRINT)
+#set(GPUCA_OVERRIDE_PARAMETER_FILE "foo.csv")
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index 0c3e905a697c0..5bf1454cb31d8 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -73,7 +73,6 @@ function(generate_macros json_content output types arch_list arch_list_output)
 endfunction()
 
 function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
-    set(GPU_PARAM_JSON ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/GPUParameters.json)
     set(TARGET_ARCH "UNKNOWN")
     if(GPU_ARCH STREQUAL "AUTO")
         detect_gpu_arch("ALL")

From fe395fea62618db410e4703f00e9f233e5a6ac44 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Feb 2026 22:54:07 +0100
Subject: [PATCH 1280/1764] GPU CMake: Use FILE GENERATE to generate Default
 Parameter Headers to track changes and rerun if necessary

---
 GPU/GPUTracking/CMakeLists.txt                |  2 +
 .../cmake/gpu_param_header_generator.cmake    | 40 ++++++++-----------
 2 files changed, 18 insertions(+), 24 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index cd17d8f284b13..14118d9b71e9c 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -112,6 +112,8 @@ if(GPUCA_OVERRIDE_PARAMETER_FILE)
 else()
     set(GPU_PARAM_JSON ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/GPUParameters.csv)
 endif()
+set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${GPU_PARAM_JSON}")
+
 get_filename_component(GPU_PARAM_JSON_EXT ${GPU_PARAM_JSON} EXT)
 string(TOLOWER "${GPU_PARAM_JSON_EXT}" GPU_PARAM_JSON_EXT)
 if(GPU_PARAM_JSON_EXT STREQUAL .csv)
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index 5bf1454cb31d8..e79a96034103d 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -80,17 +80,15 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
         set(TARGET_ARCH ${GPU_ARCH})
     endif()
     file(READ "${GPU_PARAM_JSON}" JSON_CONTENT)
-    set(TMP_HEADER "${OUT_HEADER}.tmp")
-    file(WRITE "${TMP_HEADER}" "#ifndef GPUDEFPARAMETERSDEFAULTS_H\n#define GPUDEFPARAMETERSDEFAULTS_H\n\n")
-    file(APPEND "${TMP_HEADER}" "// This file is auto-generated from gpu_params.json. Do not edit directly.\n")
+    set(TMP_HEADER "#ifndef GPUDEFPARAMETERSDEFAULTS_H\n#define GPUDEFPARAMETERSDEFAULTS_H\n\n")
+    string(APPEND TMP_HEADER "// This file is auto-generated from gpu_params.json. Do not edit directly.\n")
     string(REPLACE "," ";" ARCH_LIST "${TARGET_ARCH}")
-    file(APPEND "${TMP_HEADER}" "// Architectures: ${TARGET_ARCH}\n\n")
-    file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.\n\n")
+    string(APPEND TMP_HEADER "// Architectures: ${TARGET_ARCH}\n\n")
+    string(APPEND TMP_HEADER "#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.\n\n")
 
     # Types
     set(TYPES CORE LB PAR)
     # Per architecture definitions
-    set(_first TRUE)
     generate_macros("${JSON_CONTENT}" TMP_OUTPUT "${TYPES}" "${ARCH_LIST};default;default_cpu" "JSON_ARCHITECTURES")
     list(FIND ARCH_LIST "ALL" do_all_architectures)
     if(ARGC GREATER 2)
@@ -99,31 +97,25 @@ function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
     if(do_all_architectures GREATER -1)
         set(ARCH_LIST ${JSON_ARCHITECTURES})
     endif()
+    string(APPEND TMP_HEADER "#if 0\n")
     foreach(ARCH IN LISTS ARCH_LIST)
-        if(_first)
-            file(APPEND "${TMP_HEADER}" "#if defined(GPUCA_GPUTYPE_${ARCH})\n\n")
-            set(_first FALSE)
-        else()
-            file(APPEND "${TMP_HEADER}" "#elif defined(GPUCA_GPUTYPE_${ARCH})\n\n")
-        endif()
-        file(APPEND "${TMP_HEADER}" ${TMP_OUTPUT_${ARCH}})
+        string(APPEND TMP_HEADER "\n#elif defined(GPUCA_GPUTYPE_${ARCH})\n")
+        string(APPEND TMP_HEADER ${TMP_OUTPUT_${ARCH}})
     endforeach()
-    if(NOT _first)
-        file(APPEND "${TMP_HEADER}" "#else\n#error GPU TYPE NOT SET\n#endif\n")
-    endif()
+    string(APPEND TMP_HEADER "#else\n#error GPU TYPE NOT SET\n#endif\n")
 
     # Default parameters
-    file(APPEND "${TMP_HEADER}" "\n// Default parameters if not defined for the target architecture\n\n")
-    file(APPEND "${TMP_HEADER}" ${TMP_OUTPUT_default})
-    file(APPEND "${TMP_HEADER}" "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
+    string(APPEND TMP_HEADER "\n// Default parameters if not defined for the target architecture\n\n")
+    string(APPEND TMP_HEADER ${TMP_OUTPUT_default})
+    string(APPEND TMP_HEADER "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
 
     # CPU fallback
-    file(APPEND "${TMP_HEADER}" "#ifndef GPUCA_GPUCODE_GENRTC // Defaults for non-LB parameters also for CPU fallback\n\n")
-    file(APPEND "${TMP_HEADER}" ${TMP_OUTPUT_default_cpu})
-    file(APPEND "${TMP_HEADER}" "\n#endif // GPUCA_GPUCODE_GENRTC\n")
+    string(APPEND TMP_HEADER "#ifndef GPUCA_GPUCODE_GENRTC // Defaults for non-LB parameters also for CPU fallback\n\n")
+    string(APPEND TMP_HEADER ${TMP_OUTPUT_default_cpu})
+    string(APPEND TMP_HEADER "\n#endif // GPUCA_GPUCODE_GENRTC\n")
 
-    file(APPEND "${TMP_HEADER}" "\n#endif // GPUDEFPARAMETERSDEFAULTS_H\n")
-    file(RENAME "${TMP_HEADER}" "${OUT_HEADER}")
+    string(APPEND TMP_HEADER "\n#endif // GPUDEFPARAMETERSDEFAULTS_H\n")
+    file(GENERATE OUTPUT "${OUT_HEADER}" CONTENT "${TMP_HEADER}")
     message(STATUS "Generated ${OUT_HEADER}")
     add_custom_target(GPU_PARAM_HEADER_${GPU_ARCH}_ALL ALL DEPENDS ${OUT_HEADER} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/gpu_param_header_generator.cmake ${GPU_PARAM_JSON})
 endfunction()

From 6c63d01ba5c76408a9000db3a5c45cab39ea4611 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 6 Feb 2026 09:46:34 +0100
Subject: [PATCH 1281/1764] GPU CSV to JSON converter: Workaround to be
 compatible to MacOS

---
 GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh b/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
index ae9d3b7704284..373bd18ba7cd4 100755
--- a/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
+++ b/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
@@ -2,7 +2,13 @@
 
 [[ -z $1 ]] && { echo "Usage: csv_to_json.sh CSV_FILE"; exit 1; }
 
-awk -vFPAT='([^,]*)|(\"([^\"]|\"\")*\")' \
+DELIM=$'\xFF'
+sed -E \
+  ':loop
+   s/^(([^"]*"[^"]*")*[^"]*),/\1'$DELIM'/;
+   t loop' \
+  $1 | \
+awk -F$DELIM \
   'BEGIN {
      print "{"
    } {
@@ -42,5 +48,4 @@ awk -vFPAT='([^,]*)|(\"([^\"]|\"\")*\")' \
      if (paramprinted) print "\n    }"
      if (catprinted) print "  }"
      print "}"
-   }' \
-   $1
+   }'

From c2cae5e77332edc5f876e2ff8de9d78f494fd795 Mon Sep 17 00:00:00 2001
From: ddobrigk <david.dobrigkeit.chinellato@cern.ch>
Date: Sat, 7 Feb 2026 13:01:30 +0100
Subject: [PATCH 1282/1764] Add ability to retain TrackQA for all global tracks
 (#15010)

* Add ability to retain TrackQA for all global tracks

* Do check in one go for writeQAData

* Change default to false

* Change actual defaults to false
---
 .../AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h | 1 +
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx                 | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 615a7f96de13e..2d16f343dc1eb 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -237,6 +237,7 @@ class AODProducerWorkflowDPL : public Task
   bool mThinTracks{false};
   bool mPropTracks{false};
   bool mPropMuons{false};
+  float mTrackQCKeepGlobalTracks{false};
   float mTrackQCFraction{0.00};
   int64_t mTrackQCNTrCut{4};
   float mTrackQCDCAxy{3.};
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index b18514949114d..6dcb702791b43 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -499,7 +499,7 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
 
           float weight = 0;
           static std::uniform_real_distribution<> distr(0., 1.);
-          bool writeQAData = o2::math_utils::Tsallis::downsampleTsallisCharged(data.getTrackParam(trackIndex).getPt(), mTrackQCFraction, mSqrtS, weight, distr(mGenerator));
+          bool writeQAData = o2::math_utils::Tsallis::downsampleTsallisCharged(data.getTrackParam(trackIndex).getPt(), mTrackQCFraction, mSqrtS, weight, distr(mGenerator)) || (src != GIndex::TPC && mTrackQCKeepGlobalTracks);
           auto extraInfoHolder = processBarrelTrack(collisionID, collisionBC, trackIndex, data, bcsMap);
 
           if (writeQAData) {
@@ -1719,6 +1719,7 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
       LOGP(warn, "Specified non-default empty streamer mask!");
     }
   }
+  mTrackQCKeepGlobalTracks = ic.options().get<bool>("trackqc-keepglobaltracks");
   mTrackQCFraction = ic.options().get<float>("trackqc-fraction");
   mTrackQCNTrCut = ic.options().get<int64_t>("trackqc-NTrCut");
   mTrackQCDCAxy = ic.options().get<float>("trackqc-tpc-dca");
@@ -3348,6 +3349,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"hepmc-update", VariantType::String, "always", {"When to update HepMC Aux tables: always - force update, never - never update, all - if all keys are present, any - when any key is present (not valid yet)"}},
       ConfigParamSpec{"propagate-muons", VariantType::Bool, false, {"Propagate muons to IP"}},
       ConfigParamSpec{"thin-tracks", VariantType::Bool, false, {"Produce thinned track tables"}},
+      ConfigParamSpec{"trackqc-keepglobaltracks", VariantType::Bool, false, {"Always keep TrackQA for global tracks"}},
       ConfigParamSpec{"trackqc-fraction", VariantType::Float, float(0.1), {"Fraction of tracks to QC"}},
       ConfigParamSpec{"trackqc-NTrCut", VariantType::Int64, 4L, {"Minimal length of the track - in amount of tracklets"}},
       ConfigParamSpec{"trackqc-tpc-dca", VariantType::Float, 3.f, {"Keep TPC standalone track with this DCAxy to the PV"}},

From 1dedc84cef1cc35cc858e31d47da7da51d361ecd Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Sat, 7 Feb 2026 13:02:06 +0100
Subject: [PATCH 1283/1764] Store TPC track A/C side info in the AO2D
 TrackExtra.fFlags unused bits (#15014)

* Store TPC track A/C side info in TrackExtra.fFlags unused bits

* Add dynamic columns hasTPCSideA/C, hasTPCSideAOnly/COnly, hasTPCBothSides
---
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx        |  6 ++++++
 Framework/Core/include/Framework/AnalysisDataModel.h | 10 ++++++++++
 Framework/Core/include/Framework/DataTypes.h         |  2 ++
 3 files changed, 18 insertions(+)

diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 6dcb702791b43..be169ad4be19d 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -2646,6 +2646,12 @@ AODProducerWorkflowDPL::TrackExtraInfo AODProducerWorkflowDPL::processBarrelTrac
     if (tpcOrig.getdEdx().dEdxTotTPC == 0) {
       extraInfoHolder.flags |= o2::aod::track::TPCdEdxAlt;
     }
+    if (tpcOrig.hasASideClusters()) {
+      extraInfoHolder.flags |= o2::aod::track::TPCSideA;
+    }
+    if (tpcOrig.hasCSideClusters()) {
+      extraInfoHolder.flags |= o2::aod::track::TPCSideC;
+    }
     extraInfoHolder.tpcInnerParam = tpcOrig.getP() / tpcOrig.getAbsCharge();
     extraInfoHolder.tpcChi2NCl = tpcOrig.getNClusters() ? tpcOrig.getChi2() / tpcOrig.getNClusters() : 0;
     extraInfoHolder.tpcSignal = dEdx.dEdxTotTPC;
diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index b174f3858e165..e3032830beaac 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -404,6 +404,16 @@ DECLARE_SOA_DYNAMIC_COLUMN(HasTOF, hasTOF, //! Flag to check if track has a TOF
                            [](uint8_t detectorMap) -> bool { return detectorMap & o2::aod::track::TOF; });
 DECLARE_SOA_DYNAMIC_COLUMN(IsPVContributor, isPVContributor, //! Run 3: Has this track contributed to the collision vertex fit
                            [](uint8_t flags) -> bool { return (flags & o2::aod::track::PVContributor) == o2::aod::track::PVContributor; });
+DECLARE_SOA_DYNAMIC_COLUMN(HasTPCSideA, hasTPCSideA, //! Run 3: Has this track TPC clusters from side A?
+                           [](uint8_t flags) -> bool { return (flags & o2::aod::track::TPCSideA) == o2::aod::track::TPCSideA; });
+DECLARE_SOA_DYNAMIC_COLUMN(HasTPCSideAOnly, hasTPCSideAOnly, //! Run 3: Has this track TPC clusters from side A only?
+                           [](uint8_t flags) -> bool { return (flags & (o2::aod::track::TPCSideA | o2::aod::track::TPCSideC)) == o2::aod::track::TPCSideA; });
+DECLARE_SOA_DYNAMIC_COLUMN(HasTPCSideC, hasTPCSideC, //! Run 3: Has this track TPC clusters from side C?
+                           [](uint8_t flags) -> bool { return (flags & o2::aod::track::TPCSideC) == o2::aod::track::TPCSideC; });
+DECLARE_SOA_DYNAMIC_COLUMN(HasTPCSideCOnly, hasTPCSideCOnly, //! Run 3: Has this track TPC clusters from side C only?
+                           [](uint8_t flags) -> bool { return (flags & (o2::aod::track::TPCSideA | o2::aod::track::TPCSideC)) == o2::aod::track::TPCSideC; });
+DECLARE_SOA_DYNAMIC_COLUMN(HasTPCBothSides, hasTPCBothSides, //! Run 3: Has this track TPC clusters from both side A and C?
+                           [](uint8_t flags) -> bool { return (flags & (o2::aod::track::TPCSideA | o2::aod::track::TPCSideC)) == (o2::aod::track::TPCSideA || o2::aod::track::TPCSideC); });
 DECLARE_SOA_DYNAMIC_COLUMN(PIDForTracking, pidForTracking, //! PID hypothesis used during tracking. See the constants in the class PID in PID.h
                            [](uint32_t flags) -> uint32_t { return flags >> 28; });
 DECLARE_SOA_DYNAMIC_COLUMN(TPCNClsFound, tpcNClsFound, //! Number of found TPC clusters
diff --git a/Framework/Core/include/Framework/DataTypes.h b/Framework/Core/include/Framework/DataTypes.h
index e273a78f8d0a2..3d49d6d3c03d0 100644
--- a/Framework/Core/include/Framework/DataTypes.h
+++ b/Framework/Core/include/Framework/DataTypes.h
@@ -51,6 +51,8 @@ enum TrackFlags : uint32_t {
   OrphanTrack = 0x4,         // Track has no association with any collision vertex
   TrackTimeAsym = 0x8,       // track with an asymmetric time range
   TPCdEdxAlt = 0x10,         // TPCSignal and tpcNClsFindableMinusPID correspond for alternative dEdx since the nominal was 0
+  TPCSideA = 0x20,           // TPC track has A-side clusters (if any)
+  TPCSideC = 0x40,           // TPC track has C-side clusters (if any)
   // NOTE Highest 4 (29..32) bits reserved for PID hypothesis
 };
 enum TrackFlagsRun2Enum {

From a9e312faaff4b436fdf839ea5bc45ed4c0049a4a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 6 Feb 2026 10:37:15 +0100
Subject: [PATCH 1284/1764] GPU: Generate GPU parameter files only if GPU build
 is actually enabled

---
 GPU/GPUTracking/CMakeLists.txt                | 48 +++++++++----------
 .../Standalone/tools/dumpGPUDefParam.C        |  2 +-
 2 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 14118d9b71e9c..4ff1355672d7c 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -428,31 +428,6 @@ target_sources(${targetName}
                FILES ${GENERATED_HEADERS_LIST}
                BASE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
 
-make_directory(${CMAKE_CURRENT_BINARY_DIR}/genGPUArch)
-set(GPU_CONST_PARAM_FILES "")
-set(GPU_ARCH_PARAMS_HEADER ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/GPUDefParametersDefaults_OnTheFly.h)
-generate_gpu_param_header("ALL" ${GPU_ARCH_PARAMS_HEADER} "GPU_CONST_PARAM_ARCHITECTUES")
-foreach(GPU_ARCH ${GPU_CONST_PARAM_ARCHITECTUES})
-  set(PARAMFILE ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/gpu_const_param_${GPU_ARCH}.par)
-  add_custom_command(
-    OUTPUT ${PARAMFILE}
-    COMMAND bash -c
-            "echo -e '#define GPUCA_GPUTYPE_${GPU_ARCH}\\n#define PARAMETER_FILE \"${GPU_ARCH_PARAMS_HEADER}\"\\ngInterpreter->AddIncludePath(\"${CMAKE_CURRENT_SOURCE_DIR}/Definitions\");\\ngInterpreter->AddIncludePath(\"${ON_THE_FLY_DIR}\");\\n.x ${CMAKE_CURRENT_SOURCE_DIR}/Standalone/tools/dumpGPUDefParam.C(\"${PARAMFILE}\")\\n.q\\n'"
-            | root -l -b > /dev/null
-    VERBATIM
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch
-    MAIN_DEPENDENCY Standalone/tools/dumpGPUDefParam.C
-    DEPENDS ${GPU_ARCH_PARAMS_HEADER}
-            ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h
-            ${ON_THE_FLY_DIR}/GPUDefParametersLoad.inc
-    COMMENT "Generating GPU parameter set for architecture ${GPU_ARCH}")
-  LIST(APPEND GPU_CONST_PARAM_FILES ${PARAMFILE})
-endforeach()
-
-add_custom_target(${MODULE}_GPU_CONST_PARAM_ARCHS ALL DEPENDS ${GPU_CONST_PARAM_FILES})
-install(FILES ${GPU_CONST_PARAM_FILES} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/arch_param)
-
-
 # Add compile definitions and libraries depending on available optional dependencies
 if(GPUCA_QA)
   message(STATUS "Building GPU QA")
@@ -473,6 +448,29 @@ if(CUDA_ENABLED OR OPENCL_ENABLED OR HIP_ENABLED)
   if(CMAKE_SYSTEM_NAME MATCHES Darwin)
     message(WARNING "GPU Tracking disabled on MacOS")
   else()
+    make_directory(${CMAKE_CURRENT_BINARY_DIR}/genGPUArch)
+    set(GPU_CONST_PARAM_FILES "")
+    set(GPU_ARCH_PARAMS_HEADER ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/GPUDefParametersDefaults_OnTheFly.h)
+    generate_gpu_param_header("ALL" ${GPU_ARCH_PARAMS_HEADER} "GPU_CONST_PARAM_ARCHITECTUES")
+    foreach(GPU_ARCH ${GPU_CONST_PARAM_ARCHITECTUES})
+      set(PARAMFILE ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/gpu_const_param_${GPU_ARCH}.par)
+      add_custom_command(
+        OUTPUT ${PARAMFILE}
+        COMMAND bash -c
+                "echo -e '#define GPUCA_GPUTYPE_${GPU_ARCH}\\n#define PARAMETER_FILE \"${GPU_ARCH_PARAMS_HEADER}\"\\ngInterpreter->AddIncludePath(\"${CMAKE_CURRENT_SOURCE_DIR}/Definitions\");\\ngInterpreter->AddIncludePath(\"${ON_THE_FLY_DIR}\");\\n.x ${CMAKE_CURRENT_SOURCE_DIR}/Standalone/tools/dumpGPUDefParam.C(\"${PARAMFILE}\")\\n.q\\n'"
+                | root -l -b > /dev/null
+        VERBATIM
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch
+        MAIN_DEPENDENCY Standalone/tools/dumpGPUDefParam.C
+        DEPENDS ${GPU_ARCH_PARAMS_HEADER}
+                ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h
+                ${ON_THE_FLY_DIR}/GPUDefParametersLoad.inc
+        COMMENT "Generating GPU parameter set for architecture ${GPU_ARCH}")
+      LIST(APPEND GPU_CONST_PARAM_FILES ${PARAMFILE})
+    endforeach()
+    add_custom_target(${MODULE}_GPU_CONST_PARAM_ARCHS ALL DEPENDS ${GPU_CONST_PARAM_FILES})
+    install(FILES ${GPU_CONST_PARAM_FILES} DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/arch_param)
+
     if(CUDA_ENABLED)
       add_subdirectory(Base/cuda)
     endif()
diff --git a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
index f6866bb80da05..30d10bcdd2a8e 100644
--- a/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
+++ b/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C
@@ -18,7 +18,7 @@
 // echo -e '#define GPUCA_GPUTYPE_AMPERE\n#define PARAMETER_FILE "GPUDefParametersDefaults.h"\ngInterpreter->AddIncludePath("'`pwd`'/include/GPU");\n.x share/GPU/tools/dumpGPUDefParam.C("default_AMPERE.par")\n.q\n' | root -l -b
 
 #ifndef PARAMETER_FILE
-#error Must provide the PARAMETER_FILE as preprocessor define, e.g. -DHEADER_TO_INCLUDE='"GPUDefParametersDefaults.h"'
+#error Must provide the PARAMETER_FILE as preprocessor define, e.g. -DPARAMETER_FILE='"GPUDefParametersDefaults.h"'
 #endif
 
 #define GPUCA_GPUCODE

From acd7f3bcd98bb944f2e0ff44b855c342161cfe2c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 6 Feb 2026 12:24:28 +0100
Subject: [PATCH 1285/1764] GPU Parameter CSV: sort such that defaults are
 first

---
 .../Definitions/Parameters/GPUParameters.csv  | 140 +++++++++---------
 .../Definitions/Parameters/json_to_csv.python |   1 +
 2 files changed, 71 insertions(+), 70 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
index 5afa99554f5d0..fc27de72ea2f1 100644
--- a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
+++ b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
@@ -1,72 +1,72 @@
-Architecture,default,MI100,VEGA,TAHITI,TESLA,FERMI,PASCAL,KEPLER,AMPERE,TURING,default_cpu
+Architecture,default,default_cpu,MI100,VEGA,TAHITI,TESLA,FERMI,PASCAL,KEPLER,AMPERE,TURING
 ,,,,,,,,,,,
 CORE:,,,,,,,,,,,
-WARP_SIZE,32,64,64,32,32,32,32,32,32,32,
-THREAD_COUNT_DEFAULT,256,256,256,,,,,,512,512,
+WARP_SIZE,32,,64,64,32,32,32,32,32,32,32
+THREAD_COUNT_DEFAULT,256,,256,256,,,,,,512,512
 ,,,,,,,,,,,
 LB:,,,,,,,,,,,
-GPUTPCCreateTrackingData,256,"[256, 7]","[192, 2]",,,,,,384,256,
-GPUTPCTrackletConstructor,256,"[768, 8]","[512, 10]","[256, 2]","[256, 1]","[256, 2]","[1024, 2]","[512, 4]","[256, 2]","[256, 2]",
-GPUTPCTrackletSelector,256,"[384, 5]","[192, 10]","[256, 3]","[256, 1]","[256, 3]","[512, 4]","[256, 3]","[192, 3]","[192, 3]",
-GPUTPCNeighboursFinder,256,"[192, 8]","[960, 8]",256,256,256,512,256,"[640, 1]","[640, 1]",
-GPUTPCNeighboursCleaner,256,"[128, 5]","[384, 9]",256,256,256,256,256,512,512,
-GPUTPCExtrapolationTracking,256,"[256, 7]","[256, 2]",,,,,,"[128, 4]","[192, 2]",
+GPUTPCCreateTrackingData,256,,"[256, 7]","[192, 2]",,,,,,384,256
+GPUTPCTrackletConstructor,256,,"[768, 8]","[512, 10]","[256, 2]","[256, 1]","[256, 2]","[1024, 2]","[512, 4]","[256, 2]","[256, 2]"
+GPUTPCTrackletSelector,256,,"[384, 5]","[192, 10]","[256, 3]","[256, 1]","[256, 3]","[512, 4]","[256, 3]","[192, 3]","[192, 3]"
+GPUTPCNeighboursFinder,256,,"[192, 8]","[960, 8]",256,256,256,512,256,"[640, 1]","[640, 1]"
+GPUTPCNeighboursCleaner,256,,"[128, 5]","[384, 9]",256,256,256,256,256,512,512
+GPUTPCExtrapolationTracking,256,,"[256, 7]","[256, 2]",,,,,,"[128, 4]","[192, 2]"
 GPUTRDTrackerKernels_gpuVersion,512,,,,,,,,,,
 GPUTPCCreateOccupancyMap_fill,256,,,,,,,,,,
 GPUTPCCreateOccupancyMap_fold,256,,,,,,,,,,
 GPUTRDTrackerKernels_o2Version,512,,,,,,,,,,
-GPUTPCCompressionKernels_step0attached,256,"[128, 1]","[64, 2]",,,,,,"[64, 2]",128,
-GPUTPCCompressionKernels_step1unattached,256,"[512, 2]","[512, 2]",,,,,,"[512, 3]","[512, 2]",
-GPUTPCDecompressionKernels_step0attached,256,"[128, 2]","[128, 2]",,,,,,"[32, 1]","[32, 1]",
-GPUTPCDecompressionKernels_step1unattached,256,"[64, 2]","[64, 2]",,,,,,"[32, 1]","[32, 1]",
+GPUTPCCompressionKernels_step0attached,256,,"[128, 1]","[64, 2]",,,,,,"[64, 2]",128
+GPUTPCCompressionKernels_step1unattached,256,,"[512, 2]","[512, 2]",,,,,,"[512, 3]","[512, 2]"
+GPUTPCDecompressionKernels_step0attached,256,,"[128, 2]","[128, 2]",,,,,,"[32, 1]","[32, 1]"
+GPUTPCDecompressionKernels_step1unattached,256,,"[64, 2]","[64, 2]",,,,,,"[32, 1]","[32, 1]"
 GPUTPCDecompressionUtilKernels_sortPerSectorRow,256,,,,,,,,,,
 GPUTPCDecompressionUtilKernels_countFilteredClusters,256,,,,,,,,,,
 GPUTPCDecompressionUtilKernels_storeFilteredClusters,256,,,,,,,,,,
-GPUTPCCFDecodeZS,"[128, 4]","[64, 4]","[64, 1]",,,,,,"[64, 10]","[64, 8]",
-GPUTPCCFDecodeZSLink,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",
-GPUTPCCFDecodeZSDenseLink,"""GPUCA_WARP_SIZE""","[""GPUCA_WARP_SIZE"", 4]","[""GPUCA_WARP_SIZE"", 14]",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",
-GPUTPCCFGather,"[1024, 1]","[1024, 5]","[1024, 1]",,,,,,"[1024, 1]","[1024, 1]",
-COMPRESSION_GATHER,1024,1024,1024,,,,,,1024,1024,
-GPUTPCGMMergerTrackFit,256,"[192, 2]","[64, 7]",,,,,,"[64, 4]","[32, 8]",
-GPUTPCGMMergerFollowLoopers,256,"[256, 5]","[256, 4]",,,,,,"[64, 12]","[128, 4]",
-GPUTPCGMMergerSectorRefit,256,"[64, 4]","[256, 2]",,,,,,"[32, 6]","[64, 5]",
-GPUTPCGMMergerUnpackResetIds,256,256,256,,,,,,256,256,
-GPUTPCGMMergerUnpackGlobal,256,256,256,,,,,,256,256,
-GPUTPCGMMergerResolve_step0,256,512,256,,,,,,256,256,
-GPUTPCGMMergerResolve_step1,256,512,256,,,,,,256,256,
-GPUTPCGMMergerResolve_step2,256,512,256,,,,,,256,256,
-GPUTPCGMMergerResolve_step3,256,512,256,,,,,,256,256,
-GPUTPCGMMergerResolve_step4,256,512,256,,,,,,"[256, 4]","[256, 4]",
-GPUTPCGMMergerClearLinks,256,256,256,,,,,,256,256,
-GPUTPCGMMergerMergeWithinPrepare,256,256,256,,,,,,256,256,
-GPUTPCGMMergerMergeSectorsPrepare,256,256,256,,,,,,"[256, 2]","[256, 2]",
-GPUTPCGMMergerMergeBorders_step0,256,512,256,,,,,,192,192,
-GPUTPCGMMergerMergeBorders_step2,256,512,256,,,,,,"[64, 2]",256,
-GPUTPCGMMergerMergeCE,256,512,256,,,,,,256,256,
-GPUTPCGMMergerLinkExtrapolatedTracks,256,256,256,,,,,,256,256,
-GPUTPCGMMergerCollect,256,"[768, 1]","[1024, 1]",,,,,,"[256, 2]","[128, 2]",
-GPUTPCGMMergerSortTracksPrepare,256,256,256,,,,,,256,256,
-GPUTPCGMMergerPrepareForFit_step0,256,256,256,,,,,,256,256,
-GPUTPCGMMergerPrepareForFit_step1,256,256,256,,,,,,256,256,
-GPUTPCGMMergerPrepareForFit_step2,256,256,256,,,,,,256,256,
-GPUTPCGMMergerFinalize_step0,256,,256,,,,,,,,
-GPUTPCGMMergerFinalize_step1,256,,256,,,,,,,,
-GPUTPCGMMergerFinalize_step2,256,,256,,,,,,,,
+GPUTPCCFDecodeZS,"[128, 4]",,"[64, 4]","[64, 1]",,,,,,"[64, 10]","[64, 8]"
+GPUTPCCFDecodeZSLink,"""GPUCA_WARP_SIZE""",,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE"""
+GPUTPCCFDecodeZSDenseLink,"""GPUCA_WARP_SIZE""",,"[""GPUCA_WARP_SIZE"", 4]","[""GPUCA_WARP_SIZE"", 14]",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE"""
+GPUTPCCFGather,"[1024, 1]",,"[1024, 5]","[1024, 1]",,,,,,"[1024, 1]","[1024, 1]"
+COMPRESSION_GATHER,1024,,1024,1024,,,,,,1024,1024
+GPUTPCGMMergerTrackFit,256,,"[192, 2]","[64, 7]",,,,,,"[64, 4]","[32, 8]"
+GPUTPCGMMergerFollowLoopers,256,,"[256, 5]","[256, 4]",,,,,,"[64, 12]","[128, 4]"
+GPUTPCGMMergerSectorRefit,256,,"[64, 4]","[256, 2]",,,,,,"[32, 6]","[64, 5]"
+GPUTPCGMMergerUnpackResetIds,256,,256,256,,,,,,256,256
+GPUTPCGMMergerUnpackGlobal,256,,256,256,,,,,,256,256
+GPUTPCGMMergerResolve_step0,256,,512,256,,,,,,256,256
+GPUTPCGMMergerResolve_step1,256,,512,256,,,,,,256,256
+GPUTPCGMMergerResolve_step2,256,,512,256,,,,,,256,256
+GPUTPCGMMergerResolve_step3,256,,512,256,,,,,,256,256
+GPUTPCGMMergerResolve_step4,256,,512,256,,,,,,"[256, 4]","[256, 4]"
+GPUTPCGMMergerClearLinks,256,,256,256,,,,,,256,256
+GPUTPCGMMergerMergeWithinPrepare,256,,256,256,,,,,,256,256
+GPUTPCGMMergerMergeSectorsPrepare,256,,256,256,,,,,,"[256, 2]","[256, 2]"
+GPUTPCGMMergerMergeBorders_step0,256,,512,256,,,,,,192,192
+GPUTPCGMMergerMergeBorders_step2,256,,512,256,,,,,,"[64, 2]",256
+GPUTPCGMMergerMergeCE,256,,512,256,,,,,,256,256
+GPUTPCGMMergerLinkExtrapolatedTracks,256,,256,256,,,,,,256,256
+GPUTPCGMMergerCollect,256,,"[768, 1]","[1024, 1]",,,,,,"[256, 2]","[128, 2]"
+GPUTPCGMMergerSortTracksPrepare,256,,256,256,,,,,,256,256
+GPUTPCGMMergerPrepareForFit_step0,256,,256,256,,,,,,256,256
+GPUTPCGMMergerPrepareForFit_step1,256,,256,256,,,,,,256,256
+GPUTPCGMMergerPrepareForFit_step2,256,,256,256,,,,,,256,256
+GPUTPCGMMergerFinalize_step0,256,,,256,,,,,,,
+GPUTPCGMMergerFinalize_step1,256,,,256,,,,,,,
+GPUTPCGMMergerFinalize_step2,256,,,256,,,,,,,
 GPUTPCGMMergerMergeLoopers_step0,256,,,,,,,,,,
 GPUTPCGMMergerMergeLoopers_step1,256,,,,,,,,,,
 GPUTPCGMMergerMergeLoopers_step2,256,,,,,,,,,,
 GPUTPCGMO2Output_prepare,256,,,,,,,,,,
 GPUTPCGMO2Output_output,256,,,,,,,,,,
-GPUTPCStartHitsFinder,256,"[1024, 2]","[1024, 7]",256,256,256,256,256,512,512,
-GPUTPCStartHitsSorter,256,"[1024, 5]","[512, 7]",256,256,256,256,256,"[512, 1]","[512, 1]",
-GPUTPCCFCheckPadBaseline,576,"[576, 2]","[576, 2]",,,,,,"[576, 2]",,
-GPUTPCCFChargeMapFiller_fillIndexMap,512,512,512,,,,,,448,,
-GPUTPCCFChargeMapFiller_fillFromDigits,512,512,512,,,,,,448,,
-GPUTPCCFChargeMapFiller_findFragmentStart,512,512,512,,,,,,448,,
-GPUTPCCFPeakFinder,512,"[512, 9]","[512, 4]",,,,,,128,,
-GPUTPCCFNoiseSuppression,512,512,512,,,,,,448,,
-GPUTPCCFDeconvolution,512,"[512, 5]","[512, 5]",,,,,,384,,
-GPUTPCCFClusterizer,512,"[448, 3]","[512, 2]",,,,,,448,,
+GPUTPCStartHitsFinder,256,,"[1024, 2]","[1024, 7]",256,256,256,256,256,512,512
+GPUTPCStartHitsSorter,256,,"[1024, 5]","[512, 7]",256,256,256,256,256,"[512, 1]","[512, 1]"
+GPUTPCCFCheckPadBaseline,576,,"[576, 2]","[576, 2]",,,,,,"[576, 2]",
+GPUTPCCFChargeMapFiller_fillIndexMap,512,,512,512,,,,,,448,
+GPUTPCCFChargeMapFiller_fillFromDigits,512,,512,512,,,,,,448,
+GPUTPCCFChargeMapFiller_findFragmentStart,512,,512,512,,,,,,448,
+GPUTPCCFPeakFinder,512,,"[512, 9]","[512, 4]",,,,,,128,
+GPUTPCCFNoiseSuppression,512,,512,512,,,,,,448,
+GPUTPCCFDeconvolution,512,,"[512, 5]","[512, 5]",,,,,,384,
+GPUTPCCFClusterizer,512,,"[448, 3]","[512, 2]",,,,,,448,
 GPUTPCNNClusterizerKernels,512,,,,,,,,,,
 GPUTrackingRefitKernel_mode0asGPU,256,,,,,,,,,,
 GPUTrackingRefitKernel_mode1asTrackParCov,256,,,,,,,,,,
@@ -92,22 +92,22 @@ GPUTPCCompressionGatherKernels_buffered32,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,
 GPUTPCCompressionGatherKernels_buffered64,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
 GPUTPCCompressionGatherKernels_buffered128,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
 GPUTPCCompressionGatherKernels_multiBlock,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
-GPUTPCGMMergerFinalize_0,256,256,,,,,,,256,256,
-GPUTPCGMMergerFinalize_1,256,256,,,,,,,256,256,
-GPUTPCGMMergerFinalize_2,256,256,,,,,,,256,256,
+GPUTPCGMMergerFinalize_0,256,,256,,,,,,,256,256
+GPUTPCGMMergerFinalize_1,256,,256,,,,,,,256,256
+GPUTPCGMMergerFinalize_2,256,,256,,,,,,,256,256
 ,,,,,,,,,,,
 PAR:,,,,,,,,,,,
-AMD_EUS_PER_CU,0,4,4,,,,,,,,0
-SORT_STARTHITS,1,,,,,,,,,,0
-NEIGHBOURS_FINDER_MAX_NNEIGHUP,6,10,4,,,,,,4,4,0
-NEIGHBOURS_FINDER_UNROLL_GLOBAL,4,4,2,,,,,,,,0
-NEIGHBOURS_FINDER_UNROLL_SHARED,1,0,0,,,,,,,,0
-TRACKLET_SELECTOR_HITS_REG_SIZE,12,9,27,,,,,,20,20,0
-ALTERNATE_BORDER_SORT,0,1,1,,,,,,1,1,0
-SORT_BEFORE_FIT,0,1,1,,,,,,1,1,0
-NO_ATOMIC_PRECHECK,0,1,1,,,,,,1,1,0
-DEDX_STORAGE_TYPE,"""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t""","""float"""
-MERGER_INTERPOLATION_ERROR_TYPE,"""float""","""half""","""half""",,,,,,"""half""","""half""","""float"""
-COMP_GATHER_KERNEL,0,4,4,,,,,,4,4,0
-COMP_GATHER_MODE,2,3,3,,,,,,3,3,0
-CF_SCAN_WORKGROUP_SIZE,512,,,,,,,,,,0
+AMD_EUS_PER_CU,0,0,4,4,,,,,,,
+SORT_STARTHITS,1,0,,,,,,,,,
+NEIGHBOURS_FINDER_MAX_NNEIGHUP,6,0,10,4,,,,,,4,4
+NEIGHBOURS_FINDER_UNROLL_GLOBAL,4,0,4,2,,,,,,,
+NEIGHBOURS_FINDER_UNROLL_SHARED,1,0,0,0,,,,,,,
+TRACKLET_SELECTOR_HITS_REG_SIZE,12,0,9,27,,,,,,20,20
+ALTERNATE_BORDER_SORT,0,0,1,1,,,,,,1,1
+SORT_BEFORE_FIT,0,0,1,1,,,,,,1,1
+NO_ATOMIC_PRECHECK,0,0,1,1,,,,,,1,1
+DEDX_STORAGE_TYPE,"""float""","""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t"""
+MERGER_INTERPOLATION_ERROR_TYPE,"""float""","""float""","""half""","""half""",,,,,,"""half""","""half"""
+COMP_GATHER_KERNEL,0,0,4,4,,,,,,4,4
+COMP_GATHER_MODE,2,0,3,3,,,,,,3,3
+CF_SCAN_WORKGROUP_SIZE,512,0,,,,,,,,,
diff --git a/GPU/GPUTracking/Definitions/Parameters/json_to_csv.python b/GPU/GPUTracking/Definitions/Parameters/json_to_csv.python
index a6640239604e0..1ae15662021a3 100755
--- a/GPU/GPUTracking/Definitions/Parameters/json_to_csv.python
+++ b/GPU/GPUTracking/Definitions/Parameters/json_to_csv.python
@@ -27,6 +27,7 @@ for cat in data.values():
 
 cols = 1 + len(arches)
 empty = [""] * cols
+arches = sorted(arches, key=lambda x: 0 if x.startswith("default") else 1)
 
 with open(sys.argv[2], "w", newline="") as f:
     w = csv.writer(f, lineterminator="\n")

From f182c291126a2875decfa42eb1bcad743c18f618 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 7 Feb 2026 14:03:20 +0100
Subject: [PATCH 1286/1764] GPU CMake: Better detection of GPU optimization
 setting from architecture string

---
 dependencies/FindO2GPU.cmake | 48 +++++++++++++++++++++++++-----------
 1 file changed, 33 insertions(+), 15 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index ec6b7323ad5d1..928454f93b4f8 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -46,30 +46,48 @@ endif()
 
 function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterring by backend
 
-  if(CUDA_COMPUTETARGET AND CUDA_COMPUTETARGET MATCHES "86|89")
+  string(REGEX MATCH "^[ \t\r\n]*[0-9]+" CUDA_FIRST_TARGET "${CUDA_COMPUTETARGET}")
+  string(STRIP "${CUDA_FIRST_TARGET}" CUDA_FIRST_TARGET)
+  if(NOT CUDA_FIRST_TARGET)
+    set(CUDA_FIRST_TARGET 86)
+    message(STATUS "CUDA_COMPUTETARGET not set, defaulting CUDA optimization for architecture ${CUDA_FIRST_TARGET}")
+  endif()
+  if(CUDA_FIRST_TARGET GREATER_EQUAL 86)
     set(CUDA_TARGET AMPERE)
-    message(STATUS "Using optimized CUDA settings for Ampere GPU")
-  elseif(CUDA_COMPUTETARGET AND CUDA_COMPUTETARGET MATCHES "75")
+  elseif(CUDA_FIRST_TARGET GREATER_EQUAL 75)
     set(CUDA_TARGET TURING)
-    message(STATUS "Using optimized CUDA settings for Turing GPU")
+  elseif(CUDA_FIRST_TARGET GREATER_EQUAL 60)
+    set(CUDA_TARGET PASCAL)
+  elseif(CUDA_FIRST_TARGET GREATER_EQUAL 30)
+    set(CUDA_TARGET KEPLER)
+  elseif(CUDA_FIRST_TARGET GREATER_EQUAL 20)
+    set(CUDA_TARGET FERMI)
   else()
-    set(CUDA_TARGET AMPERE)
-    message(STATUS "Defaulting optimized CUDA settings for Ampere GPU")
+    set(CUDA_TARGET TESLA)
   endif()
+  message(STATUS "Using optimized CUDA settings for ${CUDA_TARGET} GPU (sm_${CUDA_FIRST_TARGET})")
 
-  if(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET MATCHES "gfx906")
-    set(HIP_TARGET VEGA)
-    message(STATUS "Using optimized HIP settings for MI50 GPU")
-  elseif(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET MATCHES "gfx908")
-    set(HIP_TARGET MI100)
-    message(STATUS "Using optimized HIP settings for MI100 GPU")
-  elseif(HIP_AMDGPUTARGET AND HIP_AMDGPUTARGET MATCHES "gfx90a")
+  string(REGEX MATCH "^[ \t\r\n]*gfx[0-9]+" HIP_FIRST_TARGET "${HIP_AMDGPUTARGET}")
+  string(STRIP "${HIP_FIRST_TARGET}" HIP_FIRST_TARGET)
+  string(REGEX REPLACE "^gfx" "" HIP_FIRST_TARGET "${HIP_FIRST_TARGET}")
+  if(NOT HIP_FIRST_TARGET)
+    set(HIP_FIRST_TARGET 906)
+    message(STATUS "HIP_AMDGPUTARGET not set, defaulting HIP optimization for architecture ${HIP_FIRST_TARGET}")
+  endif()
+  string(TOLOWER "${HIP_FIRST_TARGET}" HIP_FIRST_TARGET)
+  string(REGEX MATCH "....$" HIP_FIRST_TARGET_PADDED "0000${HIP_FIRST_TARGET}")
+  if(HIP_FIRST_TARGET_PADDED STRGREATER_EQUAL "1000")
+    set(HIP_TARGET RDNA)
+  elseif(HIP_FIRST_TARGET_PADDED STRGREATER_EQUAL "090a")
+    set(HIP_TARGET MI210)
+  elseif(HIP_FIRST_TARGET_PADDED STRGREATER_EQUAL "0908")
     set(HIP_TARGET MI100)
-    message(STATUS "Using optimized HIP settings for MI210 GPU")
+  elseif(HIP_FIRST_TARGET_PADDED STRGREATER_EQUAL "0906")
+    set(HIP_TARGET VEGA)
   else()
     set(HIP_TARGET VEGA)
-    message(STATUS "Defaulting optimized HIP settings for VEGA GPU")
   endif()
+  message(STATUS "Using optimized HIP settings for ${HIP_TARGET} GPU (gfx${HIP_FIRST_TARGET})")
 
   if(backend STREQUAL "CUDA") # CUDA filter
     set(TARGET_ARCH "${CUDA_TARGET}" PARENT_SCOPE)

From 6a9fd1e145c46fbe21c5a62999e59c8bc288a4b1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 8 Feb 2026 00:05:43 +0100
Subject: [PATCH 1287/1764] GPU CMake: Write separate headers for GPU device
 and non-device parameters, use same headers for compilation and for parameter
 file generation

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |   2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |   2 +-
 GPU/GPUTracking/CMakeLists.txt                |  13 ++-
 .../cmake/gpu_param_header_generator.cmake    | 106 +++++++++---------
 dependencies/FindO2GPU.cmake                  |  17 ++-
 5 files changed, 72 insertions(+), 68 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 226bacbf88157..27c3d24cd079f 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -74,7 +74,7 @@ add_custom_command(
     COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -Wno-deprecated-gpu-targets -D__CUDACC__ -x c++ -M -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d ${GPU_RTC_SRC}
     COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -Wno-deprecated-gpu-targets -D__CUDACC__ -x c++ -E -Xcompiler "-nostdinc -P" ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
-    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h GPU_PARAM_HEADER_AUTO_ALL
+    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h GPU_PARAM_HEADER_TARGET
     DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
     COMMENT "Preparing CUDA RTC source file ${GPU_RTC_BIN}.src"
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index d148e376abca9..b459a78b5789e 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -125,7 +125,7 @@ add_custom_command(
     COMMAND cat ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h | grep -v GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND ${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d >> ${GPU_RTC_BIN}.src
-    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h ${MODULE}_HIPIFIED GPU_PARAM_HEADER_AUTO_ALL
+    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h ${MODULE}_HIPIFIED GPU_PARAM_HEADER_TARGET
     DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
     COMMENT "Preparing HIP RTC source file ${GPU_RTC_BIN}.src"
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 4ff1355672d7c..786774c16971b 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -130,7 +130,8 @@ set(ON_THE_FLY_DIR ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
 file(MAKE_DIRECTORY ${ON_THE_FLY_DIR})
 include(cmake/gpu_param_header_generator.cmake)
 set(GPU_DEFAULT_PARAMS_HEADER ${ON_THE_FLY_DIR}/GPUDefParametersDefaults.h)
-generate_gpu_param_header("AUTO" ${GPU_DEFAULT_PARAMS_HEADER}) # generate header with default GPU parameters, arch selected by CMake variables
+set(GPU_DEFAULT_PARAMS_HEADER_DEVICE ${ON_THE_FLY_DIR}/GPUDefParametersDefaultsDevice.h)
+generate_gpu_param_header("ALL" ${GPU_DEFAULT_PARAMS_HEADER} ${GPU_DEFAULT_PARAMS_HEADER_DEVICE} GPU_CONST_PARAM_ARCHITECTUES) # generate header with default GPU parameters, arch selected by CMake variables
 
 set(HDRS_INSTALL
     ${HDRS_CINT_O2}
@@ -161,6 +162,7 @@ set(HDRS_INSTALL
     Debug/GPUROOTDump.h
     Definitions/GPUDefConstantsAndSettings.h
     ${GPU_DEFAULT_PARAMS_HEADER}
+    ${GPU_DEFAULT_PARAMS_HEADER_DEVICE}
     Definitions/GPUDefParametersWrapper.h
     Definitions/GPUDefParametersConstants.h
     Definitions/GPUDef.h
@@ -449,20 +451,19 @@ if(CUDA_ENABLED OR OPENCL_ENABLED OR HIP_ENABLED)
     message(WARNING "GPU Tracking disabled on MacOS")
   else()
     make_directory(${CMAKE_CURRENT_BINARY_DIR}/genGPUArch)
-    set(GPU_CONST_PARAM_FILES "")
-    set(GPU_ARCH_PARAMS_HEADER ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/GPUDefParametersDefaults_OnTheFly.h)
-    generate_gpu_param_header("ALL" ${GPU_ARCH_PARAMS_HEADER} "GPU_CONST_PARAM_ARCHITECTUES")
+    set(GPU_CONST_PARAM_FILES)
     foreach(GPU_ARCH ${GPU_CONST_PARAM_ARCHITECTUES})
       set(PARAMFILE ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch/gpu_const_param_${GPU_ARCH}.par)
       add_custom_command(
         OUTPUT ${PARAMFILE}
         COMMAND bash -c
-                "echo -e '#define GPUCA_GPUTYPE_${GPU_ARCH}\\n#define PARAMETER_FILE \"${GPU_ARCH_PARAMS_HEADER}\"\\ngInterpreter->AddIncludePath(\"${CMAKE_CURRENT_SOURCE_DIR}/Definitions\");\\ngInterpreter->AddIncludePath(\"${ON_THE_FLY_DIR}\");\\n.x ${CMAKE_CURRENT_SOURCE_DIR}/Standalone/tools/dumpGPUDefParam.C(\"${PARAMFILE}\")\\n.q\\n'"
+                "echo -e '#define GPUCA_GPUTYPE_${GPU_ARCH}\\n#define PARAMETER_FILE \"GPUDefParametersDefaults.h\"\\ngInterpreter->AddIncludePath(\"${CMAKE_CURRENT_SOURCE_DIR}/Definitions\");\\ngInterpreter->AddIncludePath(\"${ON_THE_FLY_DIR}\");\\n.x ${CMAKE_CURRENT_SOURCE_DIR}/Standalone/tools/dumpGPUDefParam.C(\"${PARAMFILE}\")\\n.q\\n'"
                 | root -l -b > /dev/null
         VERBATIM
         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/genGPUArch
         MAIN_DEPENDENCY Standalone/tools/dumpGPUDefParam.C
-        DEPENDS ${GPU_ARCH_PARAMS_HEADER}
+        DEPENDS ${GPU_DEFAULT_PARAMS_HEADER}
+                ${GPU_DEFAULT_PARAMS_HEADER_DEVICE}
                 ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h
                 ${ON_THE_FLY_DIR}/GPUDefParametersLoad.inc
         COMMENT "Generating GPU parameter set for architecture ${GPU_ARCH}")
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index e79a96034103d..31d395615a5ed 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -12,17 +12,31 @@
 # file gpu_param_header_generator.cmake
 # author Gabriele Cimador
 
-function(generate_macros json_content output types arch_list arch_list_output)
-    foreach(arch IN LISTS arch_list)
-        set(OUTPUT_TMP_${arch} "")
-    endforeach()
-    set(arch_list_output_tmp)
-    list(FIND arch_list "ALL" do_all_architectures)
-    foreach(TYPE IN LISTS types)
-        string(JSON n_params LENGTH "${json_content}" "${TYPE}")
+function(generate_gpu_param_header ARCH_LIST OUT_HEADER OUT_HEADER_DEVICE)
+    list(FIND ARCH_LIST "ALL" do_all_architectures)
+    list(FIND ARCH_LIST "AUTO" do_auto_architectures)
+    if(do_all_architectures GREATER -1 OR do_auto_architectures GREATER -1)
+        if(do_auto_architectures GREATER -1)
+            detect_gpu_arch("AUTO")
+            list(REMOVE_ITEM ARCH_LIST "AUTO")
+        else()
+            detect_gpu_arch("ALL")
+        endif()
+        list(APPEND ARCH_LIST ${TARGET_ARCH})
+    endif()
+    file(READ "${GPU_PARAM_JSON}" JSON_CONTENT)
+
+    # Types
+    set(TYPES CORE LB PAR)
+    set(ARCH_LIST_EXT "${ARCH_LIST};default;default_cpu")
+    # Per architecture definitions
+    set(JSON_ARCHITECTURES)
+
+    foreach(TYPE IN LISTS TYPES)
+        string(JSON n_params LENGTH "${JSON_CONTENT}" "${TYPE}")
         math(EXPR last "${n_params} - 1")
         foreach(i RANGE 0 ${last})
-            string(JSON param_name MEMBER "${json_content}" "${TYPE}" "${i}")
+            string(JSON param_name MEMBER "${JSON_CONTENT}" "${TYPE}" "${i}")
             string(JSON n_archs LENGTH "${JSON_CONTENT}" "${TYPE}" "${param_name}")
             math(EXPR last_arch "${n_archs} - 1")
             foreach(iArch RANGE 0 ${last_arch})
@@ -31,12 +45,12 @@ function(generate_macros json_content output types arch_list arch_list_output)
                   message(FATAL_ERROR "Bogus entry ${param_name} for ${arch}")
                 endif()
                 if(do_all_architectures GREATER -1)
-                    if(arch_list_output AND NOT arch MATCHES ^default)
-                        list(APPEND arch_list_output_tmp "${arch}")
+                    if(NOT arch MATCHES ^default)
+                        list(APPEND JSON_ARCHITECTURES "${arch}")
                     endif()
                     set(list_idx 0)
                 else()
-                    list(FIND arch_list "${arch}" list_idx)
+                    list(FIND ARCH_LIST_EXT "${arch}" list_idx)
                 endif()
                 if(list_idx GREATER -1)
                     string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch}")
@@ -54,68 +68,58 @@ function(generate_macros json_content output types arch_list arch_list_output)
                     set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
                     if(arch MATCHES ^default)
                         # fallback defaults are wrapped in #ifndef
-                        string(APPEND OUTPUT_TMP_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+                        string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
                     else()
-                        string(APPEND OUTPUT_TMP_${arch} "${MACRO_DEFINITION}\n")
+                        string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "${MACRO_DEFINITION}\n")
                     endif()
                 endif()
             endforeach()
         endforeach()
     endforeach()
-    foreach(arch IN LISTS arch_list)
-        set(${output}_${arch} "${OUTPUT_TMP_${arch}}" PARENT_SCOPE)
-    endforeach()
-    if(arch_list_output)
-        list(REMOVE_DUPLICATES arch_list_output_tmp)
-        list(SORT arch_list_output_tmp)
-        set(${arch_list_output} "${arch_list_output_tmp}" PARENT_SCOPE)
-    endif()
-endfunction()
 
-function(generate_gpu_param_header GPU_ARCH OUT_HEADER)
-    set(TARGET_ARCH "UNKNOWN")
-    if(GPU_ARCH STREQUAL "AUTO")
-        detect_gpu_arch("ALL")
-    else()
-        set(TARGET_ARCH ${GPU_ARCH})
+    list(REMOVE_DUPLICATES JSON_ARCHITECTURES)
+    list(SORT JSON_ARCHITECTURES)
+    if(ARGC GREATER 3)
+        set(${ARGV3} "${JSON_ARCHITECTURES}" PARENT_SCOPE)
     endif()
-    file(READ "${GPU_PARAM_JSON}" JSON_CONTENT)
+    if(do_all_architectures GREATER -1)
+        list(REMOVE_ITEM ARCH_LIST "ALL")
+        list(APPEND ARCH_LIST ${JSON_ARCHITECTURES})
+    endif()
+    list(REMOVE_DUPLICATES ARCH_LIST)
+    list(SORT ARCH_LIST)
+
+    get_filename_component(DEVICE_HEADER_FILE "${OUT_HEADER_DEVICE}" NAME)
+
     set(TMP_HEADER "#ifndef GPUDEFPARAMETERSDEFAULTS_H\n#define GPUDEFPARAMETERSDEFAULTS_H\n\n")
+    set(TMP_HEADER_DEVICE "#ifndef GPUDEFPARAMETERSDEFAULTSDEVICE_H\n#define GPUDEFPARAMETERSDEFAULTSDEVICE_H\n\n")
     string(APPEND TMP_HEADER "// This file is auto-generated from gpu_params.json. Do not edit directly.\n")
-    string(REPLACE "," ";" ARCH_LIST "${TARGET_ARCH}")
-    string(APPEND TMP_HEADER "// Architectures: ${TARGET_ARCH}\n\n")
+    string(APPEND TMP_HEADER_DEVICE "// This file is auto-generated from gpu_params.json. Do not edit directly.\n")
+    string(APPEND TMP_HEADER_DEVICE "// Architectures: ${TARGET_ARCH}\n\n")
     string(APPEND TMP_HEADER "#if defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS) // Avoid including for RTC generation besides normal include protection.\n\n")
+    string(APPEND TMP_HEADER "#include \"${DEVICE_HEADER_FILE}\"\n")
 
-    # Types
-    set(TYPES CORE LB PAR)
-    # Per architecture definitions
-    generate_macros("${JSON_CONTENT}" TMP_OUTPUT "${TYPES}" "${ARCH_LIST};default;default_cpu" "JSON_ARCHITECTURES")
-    list(FIND ARCH_LIST "ALL" do_all_architectures)
-    if(ARGC GREATER 2)
-        set(${ARGV2} "${JSON_ARCHITECTURES}" PARENT_SCOPE)
-    endif()
-    if(do_all_architectures GREATER -1)
-        set(ARCH_LIST ${JSON_ARCHITECTURES})
-    endif()
-    string(APPEND TMP_HEADER "#if 0\n")
+    string(APPEND TMP_HEADER_DEVICE "#if 0\n")
     foreach(ARCH IN LISTS ARCH_LIST)
-        string(APPEND TMP_HEADER "\n#elif defined(GPUCA_GPUTYPE_${ARCH})\n")
-        string(APPEND TMP_HEADER ${TMP_OUTPUT_${ARCH}})
+        string(APPEND TMP_HEADER_DEVICE "\n#elif defined(GPUCA_GPUTYPE_${ARCH})\n")
+        string(APPEND TMP_HEADER_DEVICE ${generate_gpu_param_header_OUTPUT_TMP_${ARCH}})
     endforeach()
-    string(APPEND TMP_HEADER "#else\n#error GPU TYPE NOT SET\n#endif\n")
+    string(APPEND TMP_HEADER_DEVICE "#else\n#error GPU TYPE NOT SET\n#endif\n")
 
     # Default parameters
     string(APPEND TMP_HEADER "\n// Default parameters if not defined for the target architecture\n\n")
-    string(APPEND TMP_HEADER ${TMP_OUTPUT_default})
+    string(APPEND TMP_HEADER ${generate_gpu_param_header_OUTPUT_TMP_default})
     string(APPEND TMP_HEADER "#endif // defined(GPUCA_GPUCODE) && !defined(GPUCA_GPUCODE_GENRTC) && !defined(GPUCA_GPUCODE_NO_LAUNCH_BOUNDS)\n\n")
 
     # CPU fallback
     string(APPEND TMP_HEADER "#ifndef GPUCA_GPUCODE_GENRTC // Defaults for non-LB parameters also for CPU fallback\n\n")
-    string(APPEND TMP_HEADER ${TMP_OUTPUT_default_cpu})
+    string(APPEND TMP_HEADER ${generate_gpu_param_header_OUTPUT_TMP_default_cpu})
     string(APPEND TMP_HEADER "\n#endif // GPUCA_GPUCODE_GENRTC\n")
 
     string(APPEND TMP_HEADER "\n#endif // GPUDEFPARAMETERSDEFAULTS_H\n")
+    string(APPEND TMP_HEADER_DEVICE "\n#endif // GPUDEFPARAMETERSDEFAULTSDEVICE_H\n")
     file(GENERATE OUTPUT "${OUT_HEADER}" CONTENT "${TMP_HEADER}")
-    message(STATUS "Generated ${OUT_HEADER}")
-    add_custom_target(GPU_PARAM_HEADER_${GPU_ARCH}_ALL ALL DEPENDS ${OUT_HEADER} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/gpu_param_header_generator.cmake ${GPU_PARAM_JSON})
+    file(GENERATE OUTPUT "${OUT_HEADER_DEVICE}" CONTENT "${TMP_HEADER_DEVICE}")
+    message(STATUS "Generated ${OUT_HEADER} and ${OUT_HEADER_DEVICE}")
+    add_custom_target(GPU_PARAM_HEADER_TARGET ALL DEPENDS ${OUT_HEADER} ${OUT_HEADER_DEVICE} ${GPU_PARAM_JSON})
 endfunction()
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 928454f93b4f8..42d0162691c37 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -93,18 +93,17 @@ function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterri
     set(TARGET_ARCH "${CUDA_TARGET}" PARENT_SCOPE)
   elseif(backend STREQUAL "HIP") # HIP filter
     set(TARGET_ARCH "${HIP_TARGET}" PARENT_SCOPE)
-  elseif(backend STREQUAL "ALL") # Return enabled backends
-    set(_archs "")
-    if(CUDA_ENABLED)
-      list(APPEND _archs "${CUDA_TARGET}")
+  elseif(backend STREQUAL "ALL" OR backend STREQUAL "AUTO") # Return all / enabled backends
+    set(TARGET_ARCH)
+    if(CUDA_ENABLED OR backend STREQUAL "ALL")
+      list(APPEND TARGET_ARCH "${CUDA_TARGET}")
     endif()
-    if(HIP_ENABLED)
-      list(APPEND _archs "${HIP_TARGET}")
+    if(HIP_ENABLED OR backend STREQUAL "ALL")
+      list(APPEND TARGET_ARCH "${HIP_TARGET}")
     endif()
-    if(OPENCL_ENABLED)
-      list(APPEND _archs "OPENCL")
+    if(OPENCL_ENABLED OR backend STREQUAL "ALL")
+      list(APPEND TARGET_ARCH "OPENCL")
     endif()
-    list(JOIN _archs "," TARGET_ARCH)
     set(TARGET_ARCH "${TARGET_ARCH}" PARENT_SCOPE)
   else()
     message(FATAL_ERROR "Unknown backend provided: ${backend}")

From f4becde9083aa6bb2dda8837a2a254eec4c55bb9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 8 Feb 2026 23:25:16 +0100
Subject: [PATCH 1288/1764] GPU CMake: Clean up some targets, fix if JSON
 contains 0 architectures

---
 GPU/GPUTracking/Base/cuda/CMakeLists.txt      |  2 +-
 GPU/GPUTracking/Base/hip/CMakeLists.txt       |  2 +-
 GPU/GPUTracking/CMakeLists.txt                | 55 ++++++++--------
 .../cmake/gpu_param_header_generator.cmake    | 65 ++++++++++---------
 4 files changed, 62 insertions(+), 62 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/CMakeLists.txt b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
index 27c3d24cd079f..6e54187332c9b 100644
--- a/GPU/GPUTracking/Base/cuda/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/cuda/CMakeLists.txt
@@ -74,7 +74,7 @@ add_custom_command(
     COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -Wno-deprecated-gpu-targets -D__CUDACC__ -x c++ -M -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d ${GPU_RTC_SRC}
     COMMAND ${CMAKE_CUDA_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_CUDA_STANDARD} -D__CUDA_ARCH__=${RTC_CUDA_ARCH} -Wno-deprecated-gpu-targets -D__CUDACC__ -x c++ -E -Xcompiler "-nostdinc -P" ${GPU_RTC_SRC} >> ${GPU_RTC_BIN}.src
-    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h GPU_PARAM_HEADER_TARGET
+    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/cuda/GPUReconstructionCUDAIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h
     DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
     COMMENT "Preparing CUDA RTC source file ${GPU_RTC_BIN}.src"
diff --git a/GPU/GPUTracking/Base/hip/CMakeLists.txt b/GPU/GPUTracking/Base/hip/CMakeLists.txt
index b459a78b5789e..50d710fd9d557 100644
--- a/GPU/GPUTracking/Base/hip/CMakeLists.txt
+++ b/GPU/GPUTracking/Base/hip/CMakeLists.txt
@@ -125,7 +125,7 @@ add_custom_command(
     COMMAND cat ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h | grep -v GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND cat ${GPUDIR}/Base/GPUStdSystemHeaders.h >> ${GPU_RTC_BIN}.src
     COMMAND ${CMAKE_HIP_COMPILER} ${GPU_RTC_DEFINES} ${GPU_RTC_INCLUDES} -std=c++${CMAKE_HIP_STANDARD} -D__HIPCC__ -D__HIP_DEVICE_COMPILE__ -x c++ -nostdinc -E -P ${GPU_RTC_SRC} -MD -MT ${GPU_RTC_BIN}.src -MF ${GPU_RTC_BIN}.src.d >> ${GPU_RTC_BIN}.src
-    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h ${MODULE}_HIPIFIED GPU_PARAM_HEADER_TARGET
+    DEPENDS ${GPU_RTC_SRC} ${GPUDIR}/Base/GPUStdSystemHeaders.h ${GPUDIR}/Base/hip/GPUReconstructionHIPIncludesSystem.h ${GPUDIR}/Base/GPUStdSystemHeaders.h ${MODULE}_HIPIFIED
     DEPFILE ${GPU_RTC_BIN}.src.d
     COMMAND_EXPAND_LISTS
     COMMENT "Preparing HIP RTC source file ${GPU_RTC_BIN}.src"
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 786774c16971b..e52fb80113c00 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -107,32 +107,6 @@ set(SRCS_NO_H SectorTracker/GPUTPCTrackerDump.cxx
               Global/GPUChainTrackingDebugAndProfiling.cxx
               Global/GPUChainTrackingIO.cxx)
 
-if(GPUCA_OVERRIDE_PARAMETER_FILE)
-    set(GPU_PARAM_JSON ${GPUCA_OVERRIDE_PARAMETER_FILE})
-else()
-    set(GPU_PARAM_JSON ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/GPUParameters.csv)
-endif()
-set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${GPU_PARAM_JSON}")
-
-get_filename_component(GPU_PARAM_JSON_EXT ${GPU_PARAM_JSON} EXT)
-string(TOLOWER "${GPU_PARAM_JSON_EXT}" GPU_PARAM_JSON_EXT)
-if(GPU_PARAM_JSON_EXT STREQUAL .csv)
-    execute_process(
-        COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/csv_to_json.sh "${GPU_PARAM_JSON}"
-        OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-    )
-    message(STATUS "Converted ${GPU_PARAM_JSON} to ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json")
-    set(GPU_PARAM_JSON ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json)
-endif()
-
-set(ON_THE_FLY_DIR ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
-file(MAKE_DIRECTORY ${ON_THE_FLY_DIR})
-include(cmake/gpu_param_header_generator.cmake)
-set(GPU_DEFAULT_PARAMS_HEADER ${ON_THE_FLY_DIR}/GPUDefParametersDefaults.h)
-set(GPU_DEFAULT_PARAMS_HEADER_DEVICE ${ON_THE_FLY_DIR}/GPUDefParametersDefaultsDevice.h)
-generate_gpu_param_header("ALL" ${GPU_DEFAULT_PARAMS_HEADER} ${GPU_DEFAULT_PARAMS_HEADER_DEVICE} GPU_CONST_PARAM_ARCHITECTUES) # generate header with default GPU parameters, arch selected by CMake variables
-
 set(HDRS_INSTALL
     ${HDRS_CINT_O2}
     ${HDRS_CINT_DATATYPES}
@@ -161,8 +135,6 @@ set(HDRS_INSTALL
     DataTypes/GPUO2ExternalUser.h
     Debug/GPUROOTDump.h
     Definitions/GPUDefConstantsAndSettings.h
-    ${GPU_DEFAULT_PARAMS_HEADER}
-    ${GPU_DEFAULT_PARAMS_HEADER_DEVICE}
     Definitions/GPUDefParametersWrapper.h
     Definitions/GPUDefParametersConstants.h
     Definitions/GPUDef.h
@@ -258,6 +230,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
       DataTypes/GPUO2ConfigurableParam.cxx)
 endif()
 
+set(ON_THE_FLY_DIR ${CMAKE_CURRENT_BINARY_DIR}/include_gpu_onthefly)
+file(MAKE_DIRECTORY ${ON_THE_FLY_DIR})
 set(TEMPLATE_HEADER_LIST Base/GPUReconstructionKernelList.template.h
                          Base/GPUReconstructionKernelIncludes.template.h
                          Base/GPUReconstructionIncludesDeviceAll.template.h
@@ -288,6 +262,31 @@ add_custom_command(
 )
 list(APPEND GENERATED_HEADERS_LIST ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h)
 
+if(GPUCA_OVERRIDE_PARAMETER_FILE)
+    set(GPU_PARAM_JSON ${GPUCA_OVERRIDE_PARAMETER_FILE})
+else()
+    set(GPU_PARAM_JSON ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/GPUParameters.csv)
+endif()
+set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${GPU_PARAM_JSON}")
+
+get_filename_component(GPU_PARAM_JSON_EXT ${GPU_PARAM_JSON} EXT)
+string(TOLOWER "${GPU_PARAM_JSON_EXT}" GPU_PARAM_JSON_EXT)
+if(GPU_PARAM_JSON_EXT STREQUAL .csv)
+    execute_process(
+        COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/csv_to_json.sh "${GPU_PARAM_JSON}"
+        OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json
+        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+    )
+    message(STATUS "Converted ${GPU_PARAM_JSON} to ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json")
+    set(GPU_PARAM_JSON ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json)
+endif()
+
+include(cmake/gpu_param_header_generator.cmake)
+set(GPU_DEFAULT_PARAMS_HEADER ${ON_THE_FLY_DIR}/GPUDefParametersDefaults.h)
+set(GPU_DEFAULT_PARAMS_HEADER_DEVICE ${ON_THE_FLY_DIR}/GPUDefParametersDefaultsDevice.h)
+generate_gpu_param_header("ALL" ${GPU_DEFAULT_PARAMS_HEADER} ${GPU_DEFAULT_PARAMS_HEADER_DEVICE} GPU_CONST_PARAM_ARCHITECTUES) # generate header with default GPU parameters, arch selected by CMake variables
+list(APPEND GENERATED_HEADERS_LIST ${GPU_DEFAULT_PARAMS_HEADER} ${GPU_DEFAULT_PARAMS_HEADER_DEVICE})
+
 set(HDRS_INSTALL ${HDRS_INSTALL} ${GENERATED_HEADERS_LIST})
 include(kernels.cmake)
 
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index 31d395615a5ed..0a7b234aa6a18 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -38,42 +38,44 @@ function(generate_gpu_param_header ARCH_LIST OUT_HEADER OUT_HEADER_DEVICE)
         foreach(i RANGE 0 ${last})
             string(JSON param_name MEMBER "${JSON_CONTENT}" "${TYPE}" "${i}")
             string(JSON n_archs LENGTH "${JSON_CONTENT}" "${TYPE}" "${param_name}")
+            if(n_archs GREATER 0)
             math(EXPR last_arch "${n_archs} - 1")
-            foreach(iArch RANGE 0 ${last_arch})
-                string(JSON arch MEMBER "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${iArch}")
-                if(arch STREQUAL "default_cpu" AND NOT TYPE STREQUAL "PAR")
-                  message(FATAL_ERROR "Bogus entry ${param_name} for ${arch}")
-                endif()
-                if(do_all_architectures GREATER -1)
-                    if(NOT arch MATCHES ^default)
-                        list(APPEND JSON_ARCHITECTURES "${arch}")
+                foreach(iArch RANGE 0 ${last_arch})
+                    string(JSON arch MEMBER "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${iArch}")
+                    if(arch STREQUAL "default_cpu" AND NOT TYPE STREQUAL "PAR")
+                    message(FATAL_ERROR "Bogus entry ${param_name} for ${arch}")
                     endif()
-                    set(list_idx 0)
-                else()
-                    list(FIND ARCH_LIST_EXT "${arch}" list_idx)
-                endif()
-                if(list_idx GREATER -1)
-                    string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch}")
-                    if(TYPE STREQUAL "LB")
-                        set(MACRO_NAME "GPUCA_LB_${param_name}")
-                    elseif(TYPE STREQUAL "PAR")
-                        set(MACRO_NAME "GPUCA_PAR_${param_name}")
+                    if(do_all_architectures GREATER -1)
+                        if(NOT arch MATCHES ^default)
+                            list(APPEND JSON_ARCHITECTURES "${arch}")
+                        endif()
+                        set(list_idx 0)
                     else()
-                        set(MACRO_NAME "GPUCA_${param_name}")
+                        list(FIND ARCH_LIST_EXT "${arch}" list_idx)
                     endif()
-                    set(vals "${param_values}")
-                    string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
-                    string(REGEX REPLACE " *\\]$" "" vals "${vals}")
-                    string(REGEX REPLACE "\"" "" vals "${vals}")
-                    set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
-                    if(arch MATCHES ^default)
-                        # fallback defaults are wrapped in #ifndef
-                        string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
-                    else()
-                        string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "${MACRO_DEFINITION}\n")
+                    if(list_idx GREATER -1)
+                        string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch}")
+                        if(TYPE STREQUAL "LB")
+                            set(MACRO_NAME "GPUCA_LB_${param_name}")
+                        elseif(TYPE STREQUAL "PAR")
+                            set(MACRO_NAME "GPUCA_PAR_${param_name}")
+                        else()
+                            set(MACRO_NAME "GPUCA_${param_name}")
+                        endif()
+                        set(vals "${param_values}")
+                        string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
+                        string(REGEX REPLACE " *\\]$" "" vals "${vals}")
+                        string(REGEX REPLACE "\"" "" vals "${vals}")
+                        set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
+                        if(arch MATCHES ^default)
+                            # fallback defaults are wrapped in #ifndef
+                            string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+                        else()
+                            string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "${MACRO_DEFINITION}\n")
+                        endif()
                     endif()
-                endif()
-            endforeach()
+                endforeach()
+            endif()
         endforeach()
     endforeach()
 
@@ -121,5 +123,4 @@ function(generate_gpu_param_header ARCH_LIST OUT_HEADER OUT_HEADER_DEVICE)
     file(GENERATE OUTPUT "${OUT_HEADER}" CONTENT "${TMP_HEADER}")
     file(GENERATE OUTPUT "${OUT_HEADER_DEVICE}" CONTENT "${TMP_HEADER_DEVICE}")
     message(STATUS "Generated ${OUT_HEADER} and ${OUT_HEADER_DEVICE}")
-    add_custom_target(GPU_PARAM_HEADER_TARGET ALL DEPENDS ${OUT_HEADER} ${OUT_HEADER_DEVICE} ${GPU_PARAM_JSON})
 endfunction()

From f1175e1181e24441768ca3f97655786fcadee539 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 9 Feb 2026 00:03:02 +0100
Subject: [PATCH 1289/1764] GPU Parameters: Support multiple csv/json files,
 and merge the parameters into the header on the fly

---
 GPU/GPUTracking/CMakeLists.txt                | 37 +++++---
 .../cmake/gpu_param_header_generator.cmake    | 95 ++++++++++---------
 2 files changed, 75 insertions(+), 57 deletions(-)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index e52fb80113c00..082dc1f10b1d6 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -263,28 +263,39 @@ add_custom_command(
 list(APPEND GENERATED_HEADERS_LIST ${ON_THE_FLY_DIR}/GPUDefParametersLoadPrepare.h)
 
 if(GPUCA_OVERRIDE_PARAMETER_FILE)
-    set(GPU_PARAM_JSON ${GPUCA_OVERRIDE_PARAMETER_FILE})
+  set(GPU_PARAM_JSON ${GPUCA_OVERRIDE_PARAMETER_FILE})
 else()
-    set(GPU_PARAM_JSON ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/GPUParameters.csv)
+  set(GPU_PARAM_JSON ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/GPUParameters.csv)
 endif()
 set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS "${GPU_PARAM_JSON}")
 
-get_filename_component(GPU_PARAM_JSON_EXT ${GPU_PARAM_JSON} EXT)
-string(TOLOWER "${GPU_PARAM_JSON_EXT}" GPU_PARAM_JSON_EXT)
-if(GPU_PARAM_JSON_EXT STREQUAL .csv)
-    execute_process(
-        COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/csv_to_json.sh "${GPU_PARAM_JSON}"
-        OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json
-        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+set(GPU_PARAM_JSON_FILES)
+set(GPU_PARAM_JSON_N_FILES 0)
+foreach(GPU_PARAM_JSON_FILE IN LISTS GPU_PARAM_JSON)
+  if(NOT EXISTS "${GPU_PARAM_JSON_FILE}")
+    message(FATAL_ERROR "Parameter file ${GPU_PARAM_JSON_FILE} does not exist")
+  endif()
+  get_filename_component(GPU_PARAM_JSON_EXT ${GPU_PARAM_JSON_FILE} EXT)
+  string(TOLOWER "${GPU_PARAM_JSON_EXT}" GPU_PARAM_JSON_EXT)
+  if(GPU_PARAM_JSON_EXT STREQUAL .csv)
+    get_filename_component(GPU_PARAM_JSON_NAME ${GPU_PARAM_JSON_FILE} NAME_WE)
+    set(CONVOUTFILE "GPUParameters_${GPU_PARAM_JSON_NAME}_${GPU_PARAM_JSON_N_FILES}.json")
+    execute_process(COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/csv_to_json.sh "${GPU_PARAM_JSON_FILE}"
+                    OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/${CONVOUTFILE}
+                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
     )
-    message(STATUS "Converted ${GPU_PARAM_JSON} to ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json")
-    set(GPU_PARAM_JSON ${CMAKE_CURRENT_BINARY_DIR}/gpu_parameters.json)
-endif()
+    message(STATUS "Converted ${GPU_PARAM_JSON_FILE} to ${CONVOUTFILE}")
+    list(APPEND GPU_PARAM_JSON_FILES ${CMAKE_CURRENT_BINARY_DIR}/${CONVOUTFILE})
+  else()
+    list(APPEND GPU_PARAM_JSON_FILES ${GPU_PARAM_JSON_FILE})
+  endif()
+  math(EXPR GPU_PARAM_JSON_N_FILES "${GPU_PARAM_JSON_N_FILES} + 1")
+endforeach()
 
 include(cmake/gpu_param_header_generator.cmake)
 set(GPU_DEFAULT_PARAMS_HEADER ${ON_THE_FLY_DIR}/GPUDefParametersDefaults.h)
 set(GPU_DEFAULT_PARAMS_HEADER_DEVICE ${ON_THE_FLY_DIR}/GPUDefParametersDefaultsDevice.h)
-generate_gpu_param_header("ALL" ${GPU_DEFAULT_PARAMS_HEADER} ${GPU_DEFAULT_PARAMS_HEADER_DEVICE} GPU_CONST_PARAM_ARCHITECTUES) # generate header with default GPU parameters, arch selected by CMake variables
+generate_gpu_param_header("${GPU_PARAM_JSON_FILES}" "ALL" "${GPU_DEFAULT_PARAMS_HEADER}" "${GPU_DEFAULT_PARAMS_HEADER_DEVICE}" GPU_CONST_PARAM_ARCHITECTUES) # generate header with default GPU parameters, arch selected by CMake variables
 list(APPEND GENERATED_HEADERS_LIST ${GPU_DEFAULT_PARAMS_HEADER} ${GPU_DEFAULT_PARAMS_HEADER_DEVICE})
 
 set(HDRS_INSTALL ${HDRS_INSTALL} ${GENERATED_HEADERS_LIST})
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
index 0a7b234aa6a18..383d194aaa717 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
@@ -12,7 +12,7 @@
 # file gpu_param_header_generator.cmake
 # author Gabriele Cimador
 
-function(generate_gpu_param_header ARCH_LIST OUT_HEADER OUT_HEADER_DEVICE)
+function(generate_gpu_param_header GPU_PARAM_JSON_FILES ARCH_LIST OUT_HEADER OUT_HEADER_DEVICE)
     list(FIND ARCH_LIST "ALL" do_all_architectures)
     list(FIND ARCH_LIST "AUTO" do_auto_architectures)
     if(do_all_architectures GREATER -1 OR do_auto_architectures GREATER -1)
@@ -24,7 +24,6 @@ function(generate_gpu_param_header ARCH_LIST OUT_HEADER OUT_HEADER_DEVICE)
         endif()
         list(APPEND ARCH_LIST ${TARGET_ARCH})
     endif()
-    file(READ "${GPU_PARAM_JSON}" JSON_CONTENT)
 
     # Types
     set(TYPES CORE LB PAR)
@@ -32,57 +31,65 @@ function(generate_gpu_param_header ARCH_LIST OUT_HEADER OUT_HEADER_DEVICE)
     # Per architecture definitions
     set(JSON_ARCHITECTURES)
 
-    foreach(TYPE IN LISTS TYPES)
-        string(JSON n_params LENGTH "${JSON_CONTENT}" "${TYPE}")
-        math(EXPR last "${n_params} - 1")
-        foreach(i RANGE 0 ${last})
-            string(JSON param_name MEMBER "${JSON_CONTENT}" "${TYPE}" "${i}")
-            string(JSON n_archs LENGTH "${JSON_CONTENT}" "${TYPE}" "${param_name}")
-            if(n_archs GREATER 0)
-            math(EXPR last_arch "${n_archs} - 1")
-                foreach(iArch RANGE 0 ${last_arch})
-                    string(JSON arch MEMBER "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${iArch}")
-                    if(arch STREQUAL "default_cpu" AND NOT TYPE STREQUAL "PAR")
-                    message(FATAL_ERROR "Bogus entry ${param_name} for ${arch}")
-                    endif()
-                    if(do_all_architectures GREATER -1)
-                        if(NOT arch MATCHES ^default)
-                            list(APPEND JSON_ARCHITECTURES "${arch}")
+    set(GPU_PARAM_JSON_N_FILES 0)
+    foreach(GPU_PARAM_JSON_FILE IN LISTS GPU_PARAM_JSON_FILES)
+        file(READ "${GPU_PARAM_JSON_FILE}" JSON_CONTENT)
+        foreach(TYPE IN LISTS TYPES)
+            string(JSON n_params LENGTH "${JSON_CONTENT}" "${TYPE}")
+            math(EXPR last "${n_params} - 1")
+            foreach(i RANGE 0 ${last})
+                string(JSON param_name MEMBER "${JSON_CONTENT}" "${TYPE}" "${i}")
+                string(JSON n_archs LENGTH "${JSON_CONTENT}" "${TYPE}" "${param_name}")
+                if(n_archs GREATER 0)
+                math(EXPR last_arch "${n_archs} - 1")
+                    foreach(iArch RANGE 0 ${last_arch})
+                        string(JSON arch MEMBER "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${iArch}")
+                        if(arch STREQUAL "default_cpu" AND NOT TYPE STREQUAL "PAR")
+                            message(FATAL_ERROR "Bogus entry ${param_name} for ${arch}")
                         endif()
-                        set(list_idx 0)
-                    else()
-                        list(FIND ARCH_LIST_EXT "${arch}" list_idx)
-                    endif()
-                    if(list_idx GREATER -1)
-                        string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch}")
-                        if(TYPE STREQUAL "LB")
-                            set(MACRO_NAME "GPUCA_LB_${param_name}")
-                        elseif(TYPE STREQUAL "PAR")
-                            set(MACRO_NAME "GPUCA_PAR_${param_name}")
-                        else()
-                            set(MACRO_NAME "GPUCA_${param_name}")
+                        if(arch MATCHES ^default AND GPU_PARAM_JSON_N_FILES GREATER 0)
+                            message(FATAL_ERROR "Defaults must be provided in first parameter file")
                         endif()
-                        set(vals "${param_values}")
-                        string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
-                        string(REGEX REPLACE " *\\]$" "" vals "${vals}")
-                        string(REGEX REPLACE "\"" "" vals "${vals}")
-                        set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
-                        if(arch MATCHES ^default)
-                            # fallback defaults are wrapped in #ifndef
-                            string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+                        if(do_all_architectures GREATER -1)
+                            if(NOT arch MATCHES ^default)
+                                list(APPEND JSON_ARCHITECTURES "${arch}")
+                            endif()
+                            set(list_idx 0)
                         else()
-                            string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "${MACRO_DEFINITION}\n")
+                            list(FIND ARCH_LIST_EXT "${arch}" list_idx)
+                        endif()
+                        if(list_idx GREATER -1)
+                            string(JSON param_values GET "${JSON_CONTENT}" "${TYPE}" "${param_name}" "${arch}")
+                            if(TYPE STREQUAL "LB")
+                                set(MACRO_NAME "GPUCA_LB_${param_name}")
+                            elseif(TYPE STREQUAL "PAR")
+                                set(MACRO_NAME "GPUCA_PAR_${param_name}")
+                            else()
+                                set(MACRO_NAME "GPUCA_${param_name}")
+                            endif()
+                            set(vals "${param_values}")
+                            string(REGEX REPLACE "^\\[ *" "" vals "${vals}")
+                            string(REGEX REPLACE " *\\]$" "" vals "${vals}")
+                            string(REGEX REPLACE "\"" "" vals "${vals}")
+                            set(MACRO_DEFINITION "#define ${MACRO_NAME} ${vals}")
+                            if(arch MATCHES ^default)
+                                # fallback defaults are wrapped in #ifndef
+                                string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "#ifndef ${MACRO_NAME}\n  ${MACRO_DEFINITION}\n#endif\n\n")
+                            else()
+                                string(APPEND generate_gpu_param_header_OUTPUT_TMP_${arch} "${MACRO_DEFINITION}\n")
+                            endif()
                         endif()
-                    endif()
-                endforeach()
-            endif()
+                    endforeach()
+                endif()
+            endforeach()
         endforeach()
+        math(EXPR GPU_PARAM_JSON_N_FILES "${GPU_PARAM_JSON_N_FILES} + 1")
     endforeach()
 
     list(REMOVE_DUPLICATES JSON_ARCHITECTURES)
     list(SORT JSON_ARCHITECTURES)
-    if(ARGC GREATER 3)
-        set(${ARGV3} "${JSON_ARCHITECTURES}" PARENT_SCOPE)
+    if(ARGC GREATER 4)
+        set(${ARGV4} "${JSON_ARCHITECTURES}" PARENT_SCOPE)
     endif()
     if(do_all_architectures GREATER -1)
         list(REMOVE_ITEM ARCH_LIST "ALL")

From b77438bbd5aa8d07b4458b5eb80bf519ba9f6ec4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Mon, 9 Feb 2026 09:25:15 +0100
Subject: [PATCH 1290/1764] Utilities: Delete unused files (#15039)

---
 .../DataCompression/CodingModelDispatcher.h   | 380 ------------
 .../DataCompression/runtime_container.h       | 583 ------------------
 .../tpccluster_parameter_model.h              | 101 ---
 .../internal/containers/HistogramInterface.h  |  88 ---
 4 files changed, 1152 deletions(-)
 delete mode 100644 Utilities/DataCompression/include/DataCompression/CodingModelDispatcher.h
 delete mode 100644 Utilities/DataCompression/include/DataCompression/runtime_container.h
 delete mode 100644 Utilities/DataCompression/tpccluster_parameter_model.h
 delete mode 100644 Utilities/rANS/include/rANS/internal/containers/HistogramInterface.h

diff --git a/Utilities/DataCompression/include/DataCompression/CodingModelDispatcher.h b/Utilities/DataCompression/include/DataCompression/CodingModelDispatcher.h
deleted file mode 100644
index 68fcc8360df2b..0000000000000
--- a/Utilities/DataCompression/include/DataCompression/CodingModelDispatcher.h
+++ /dev/null
@@ -1,380 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/* Local Variables:  */
-/* mode: c++         */
-/* End:              */
-
-#ifndef CODINGMODELDISPATCHER_H
-#define CODINGMODELDISPATCHER_H
-
-/// @file   CodingModelDispatcher.h
-/// @author Matthias Richter
-/// @since  2016-09-11
-/// @brief  Runtime dispatcher interface for probability model definitions
-
-#include "mpl_tools.h"
-#include "runtime_container.h"
-#include <iostream>
-#include <fstream>
-#include <boost/type.hpp>
-#include <boost/mpl/for_each.hpp>
-
-using namespace gNeric;
-
-namespace o2
-{
-namespace data_compression
-{
-
-/**
- * @class CodingModelDispatcher Runtime dispatcher interface
- * @brief Runtime dispatcher interface for probability model definitions
- *
- * ModelDefinition single coding model or mpl sequence of models
- *
- * TODO:
- * - consistency check for coding direction, all model definitions have to obey
- *   same direction
- * - probably one should also require the same code type for all definitions, at
- *   least in the codec. Multiple code types do not make much sense in the codec
- */
-template <typename ModelDefinition>
-class CodingModelDispatcher
-{
- public:
-  CodingModelDispatcher() : mPosition(0), mContainer() {}
-  ~CodingModelDispatcher() = default;
-
-  using self_type = CodingModelDispatcher<ModelDefinition>;
-
-  // make_mpl_vector traits makes sure that an mpl sequence is used further on
-  // if the original type is not a sequence it is wrapped into an mpl vector with
-  // the original type as the only element
-  using definition_type = typename mpl::make_mpl_vector<ModelDefinition>::type;
-
-  // the runtime container type is the heart of the dispatcher to runtime objects
-  // of the sequence of data types which define the probability model
-  using container_type = typename create_rtc<definition_type, RuntimeContainer<>>::type;
-
-  using code_type = typename container_type::wrapped_type::code_type;
-
-  /// get the number of models in the definition
-  static int getNumberOfModels() { return boost::mpl::size<definition_type>::value; }
-
-  /// return highest stage of runtime container
-  container_type& operator*() { return mContainer; }
-
-  /// functor to add weight to probability model at runtime container level
-  template <typename ValueType, typename WeightType>
-  class addWeightFctr
-  {
-   public:
-    addWeightFctr(ValueType _v, WeightType _w) : value(_v), weight(_w) {}
-    ~addWeightFctr() {}
-
-    using return_type = bool;
-
-    template <typename T>
-    return_type operator()(T& stage)
-    {
-      // the addWeight function belongs to the probability model as base
-      // of the specific model; funcions of the base can be accessed by
-      // static casting. This avoids an extra level of function calls.
-      return static_cast<typename T::wrapped_type::base_type&>(*stage).addWeight(value, weight);
-    }
-
-   private:
-    ValueType value;
-    WeightType weight;
-  };
-
-  /**
-   * add weight to current model
-   *
-   * Dispatcher increments to the next model definition after decoding if
-   * parameter switchToNextModel is true.
-   */
-  template <typename ValueType, typename WeightType>
-  bool addWeight(ValueType v, WeightType w, bool switchToNextModel = true)
-  {
-    bool result = mContainer.apply(mPosition, addWeightFctr<ValueType, WeightType>(v, w));
-    if (switchToNextModel && ++mPosition >= getNumberOfModels()) {
-      mPosition = 0;
-    }
-    return result;
-  }
-
-  /**
-   * init model
-   */
-  class initFctr
-  {
-   public:
-    initFctr(container_type& container) : mContainer(container) {}
-    ~initFctr() {}
-
-    using return_type = int;
-
-    template <typename T>
-    return_type operator()(boost::type<T>)
-    {
-      T& stage = static_cast<T&>(mContainer);
-      return (*stage).init();
-    }
-
-   private:
-    container_type& mContainer;
-  };
-
-  /**
-   * init dispatcher and models
-   */
-  int init()
-  {
-    mPosition = 0;
-    boost::mpl::for_each<typename container_type::types, boost::type<boost::mpl::_>>(initFctr(mContainer));
-    return 0;
-  }
-
-  /**
-   * TODO: this is tailored to HuffmanCodec for the moment, some generic interface
-   * has to come
-   */
-  class generateFctr
-  {
-   public:
-    generateFctr(container_type& container) : mContainer(container) {}
-    ~generateFctr() {}
-
-    using return_type = int;
-
-    template <typename T>
-    return_type operator()(boost::type<T>)
-    {
-      T& stage = static_cast<T&>(mContainer);
-      return (*stage).GenerateHuffmanTree();
-    }
-
-   private:
-    container_type& mContainer;
-  };
-
-  /**
-   * TODO: maybe 'generate' is not the appropriate name
-   */
-  int generate()
-  {
-    boost::mpl::for_each<typename container_type::types, boost::type<boost::mpl::_>>(generateFctr(mContainer));
-    return 0;
-  }
-
-  /// functor to execute encoding on runtime container level
-  template <typename CodeType, typename ValueType>
-  class encodeFctr
-  {
-   public:
-    encodeFctr(ValueType _v, CodeType& _code, uint16_t& _codeLength) : code(_code), value(_v), codeLength(_codeLength)
-    {
-    }
-    ~encodeFctr() {}
-
-    using return_type = bool;
-
-    template <typename T>
-    return_type operator()(T& stage)
-    {
-      code = (*stage).Encode(value, codeLength);
-      return true;
-    }
-
-   private:
-    CodeType& code;
-    ValueType value;
-    uint16_t& codeLength;
-  };
-
-  /**
-   * Encode a value
-   *
-   * Dispatcher increments to the next model definition after decoding if
-   * parameter switchToNextModel is true.
-   */
-  template <typename CodeType, typename ValueType>
-  bool encode(ValueType v, CodeType& code, uint16_t& codeLength, bool switchToNextModel = true)
-  {
-    bool result = mContainer.apply(mPosition, encodeFctr<CodeType, ValueType>(v, code, codeLength));
-    if (switchToNextModel && ++mPosition >= getNumberOfModels()) {
-      mPosition = 0;
-    }
-    return result;
-  }
-
-  /// Functor to execute decoding on runtime container level
-  template <typename CodeType, typename ValueType>
-  class decodeFctr
-  {
-   public:
-    decodeFctr(ValueType& _v, CodeType _code, uint16_t& _codeLength) : code(_code), value(_v), codeLength(_codeLength)
-    {
-    }
-    ~decodeFctr() {}
-
-    using return_type = bool;
-
-    template <typename T>
-    return_type operator()(T& stage)
-    {
-      value = (*stage).Decode(code, codeLength);
-      return true;
-    }
-
-   private:
-    CodeType code;
-    ValueType& value;
-    uint16_t& codeLength;
-  };
-
-  /**
-   * Decode a code sequence
-   * Code direction can be either from MSB to LSB or LSB to MSB, controlled
-   * by template parameter orderMSB of the probability model.
-   *
-   * Dispatcher increments to the next model definition after decoding if
-   * parameter switchToNextModel is true.
-   */
-  template <typename ValueType, typename CodeType>
-  bool decode(ValueType& v, CodeType code, uint16_t& codeLength, bool switchToNextModel = true)
-  {
-    bool result = mContainer.apply(mPosition, decodeFctr<CodeType, ValueType>(v, code, codeLength));
-    if (switchToNextModel && ++mPosition >= getNumberOfModels()) {
-      mPosition = 0;
-    }
-    return result;
-  }
-
-  class getCodingDirectionFctr
-  {
-   public:
-    using return_type = bool;
-    template <typename T>
-    return_type operator()(T& stage)
-    {
-      return T::wrapped_type::orderMSB;
-    }
-  };
-
-  /**
-   * Get coding direction for model at current position
-   */
-  bool getCodingDirection() { return mContainer.apply(mPosition, getCodingDirectionFctr()); }
-
-  /// write functor
-  class writeFctr
-  {
-   public:
-    writeFctr(std::ostream& out, container_type& container) : mOut(out), mContainer(container) {}
-    ~writeFctr() {}
-
-    using return_type = std::ostream&;
-
-    template <typename T>
-    return_type operator()(boost::type<T>)
-    {
-      T& stage = static_cast<T&>(mContainer);
-      if (T::level::value > 0) {
-        mOut << std::endl; // blank line between dumps
-      }
-      mOut << T::level::value << " " << (*stage).getName() << std::endl;
-      (*stage).write(mOut);
-      return mOut;
-    }
-
-   private:
-    std::ostream& mOut;
-    container_type& mContainer;
-  };
-
-  /**
-   * Write configuration
-   *
-   * TODO: introduce a general storage policy, a text file is used for now
-   */
-  int write(const char* filename = nullptr)
-  {
-    std::ofstream ofile(filename);
-    boost::mpl::for_each<typename container_type::types, boost::type<boost::mpl::_>>(
-      writeFctr(ofile.good() ? ofile : std::cout, mContainer));
-    ofile.close();
-    return 0;
-  }
-
-  /// read functor
-  class readFctr
-  {
-   public:
-    readFctr(std::istream& in, container_type& container) : mIn(in), mContainer(container) {}
-    ~readFctr() {}
-
-    using return_type = bool;
-
-    template <typename T>
-    return_type operator()(boost::type<T>)
-    {
-      T& stage = static_cast<T&>(mContainer);
-      std::string level, name, remaining;
-      mIn >> level;
-      mIn >> name;
-      if (!mIn) {
-        return false;
-      }
-      if (std::stoi(level) != T::level::value || name.compare((*stage).getName())) {
-        std::cerr << "Format error: expecting level '" << T::level::value << "' and name '" << (*stage).getName()
-                  << "', got: " << level << " " << name << std::endl;
-      }
-      std::cout << "reading configuration for model " << name << std::endl;
-      std::getline(mIn, remaining); // flush the current line
-      (*stage).read(mIn);
-      return true;
-    }
-
-   private:
-    std::istream& mIn;
-    container_type& mContainer;
-  };
-
-  /**
-   * Read configuration
-   *
-   * TODO: introduce a general storage policy, a text file is used for now
-   */
-  int read(const char* filename)
-  {
-    std::ifstream input(filename);
-    if (!input.good()) {
-      return -1;
-    }
-    // TODO: probably need mpl fold here to propagate the return value
-    boost::mpl::for_each<typename container_type::types, boost::type<boost::mpl::_>>(readFctr(input, mContainer));
-    return 0;
-  }
-
- private:
-  /// position for cyclic dispatch
-  int mPosition;
-  /// the runtime container
-  container_type mContainer;
-};
-
-} // namespace data_compression
-} // namespace o2
-
-#endif
diff --git a/Utilities/DataCompression/include/DataCompression/runtime_container.h b/Utilities/DataCompression/include/DataCompression/runtime_container.h
deleted file mode 100644
index 363f4220e73f6..0000000000000
--- a/Utilities/DataCompression/include/DataCompression/runtime_container.h
+++ /dev/null
@@ -1,583 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-//-*- Mode: C++ -*-
-
-#ifndef RUNTIME_CONTAINER_H
-#define RUNTIME_CONTAINER_H
-//****************************************************************************
-//* This file is free software: you can redistribute it and/or modify        *
-//* it under the terms of the GNU General Public License as published by     *
-//* the Free Software Foundation, either version 3 of the License, or        *
-//* (at your option) any later version.                                      *
-//*                                                                          *
-//* Primary Author(s): Matthias Richter <mail@matthias-richter.com>          *
-//*                                                                          *
-//* The authors make no claims about the suitability of this software for    *
-//* any purpose. It is provided "as is" without express or implied warranty. *
-//****************************************************************************
-
-/// @file   runtime_container.h
-/// @author Matthias Richter
-/// @since  2016-09-11
-/// @brief  A general runtime container for a compile time sequence
-/// This file is part of https://github.com/matthiasrichter/gNeric
-
-// clang-format off
-
-// A general runtime container for a compile time sequence
-// of types. A mixin class is used to represent a member of each data
-// type. Every data type in the sequence describes a mixin on top of
-// the previous one. The runtime container accumulates the type
-// properties.
-
-#include <iostream>
-#include <iomanip>
-#include <boost/mpl/equal.hpp>
-#include <boost/mpl/minus.hpp>
-#include <boost/mpl/less.hpp>
-#include <boost/mpl/fold.hpp>
-#include <boost/mpl/lambda.hpp>
-#include <boost/mpl/vector.hpp>
-#include <boost/mpl/push_back.hpp>
-#include <boost/mpl/protect.hpp>
-#include <boost/mpl/begin.hpp>
-#include <boost/mpl/end.hpp>
-#include <boost/mpl/next.hpp>
-#include <boost/mpl/deref.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/range_c.hpp>
-#include <boost/mpl/size.hpp>
-
-using namespace boost::mpl::placeholders;
-
-namespace gNeric {
-
-/**
- * @class DefaultInterface
- * @brief The default interface for the RuntimeContainer
- *
- * The common interface for the mixin class. In order to allow entry
- * points to the different levels of the mixin, none of the interface
- * functions has to be declared virtual. The function implementation of
- * the top most mixin would be called otherwise.
- *
- * The mixin technique requires a base class, but it mostly makes sense in
- * the picture of runtime polymorphism and virtual interfaces. The runtime
- * container application is purely using static polymorphism which makes the
- * base interface just to a technical aspect.
- */
-class DefaultInterface
-{
-public:
-  DefaultInterface() {}
-  ~DefaultInterface() {}
-
-  void print() const {}
-};
-
-/**
- * @brief Default initializer does nothing
- */
-struct default_initializer
-{
-  template<typename T>
-  void operator()(T&) {}
-};
-
-/**
- * @brief An initializer for simple types
- * The initializer makes use of truncation for non-float types, and
- * over- and underflow to produce different values in the member
- * of the individual stages in the container.
- * - float types keep the fraction
- * - integral types truncate the fraction
- * - unsigned types undergo an underflow and produce big numbers
- * - 8 bit char produces the '*' character
- *
- * Mainly for testing and illustration purposes.
- */
-struct funny_initializer
-{
-  template<typename T>
-  void operator()(T& v) {v=0; v-=214.5;}
-};
-
-/**
- * @brief Default printer prints nothing
- */
-struct default_printer
-{
-  template<typename T>
-  bool operator()(const T& v, int level = -1) {return false;}
-};
-
-/**
- * @brief Verbose printer prints level and content
- */
-template<bool recursive = true>
-struct verbose_printer_base
-{
-  template<typename T>
-  bool operator()(const T& v, int level = -1) {
-    std::cout << "RC mixin level "
-              << std::setw(2)
-              << level << ": " << v << std::endl;
-    return recursive;
-  }
-};
-
-/**
- * @brief Verbose printer to print levels recursively
- */
-struct recursive_printer : verbose_printer_base<true> {};
-
-// preserve backward compatibility
-typedef recursive_printer verbose_printer;
-
-/**
- * @brief Verbose printer to print a single level
- */
-struct single_printer : verbose_printer_base<false> {};
-
-/**
- * @brief Setter functor, forwards to the container mixin's set function
- */
-template<typename U>
-class set_value {
-public:
-  typedef void return_type;
-  typedef U value_type;
-
-  set_value(U u) : mValue(u) {}
-  template<typename T>
-  return_type operator()(T& t) {
-    *t = mValue;
-  }
-
-private:
-  set_value(); // forbidden
-  U mValue;
-};
-
-/**
- * @brief Adder functor
- */
-template<typename U>
-class add_value {
-public:
-  typedef void return_type;
-  typedef U value_type;
-
-  add_value(U u) : mValue(u) {}
-  template<typename T>
-  return_type operator()(T& t) {
-    *t += mValue;
-  }
-
-private:
-  add_value(); // forbidden
-  U mValue;
-};
-
-/**
- * @brief Getter functor, forwards to the container mixin's get function
- *
- * TODO: make a type trait to either return t.get() if its a container
- * instance or t directly if it is the member object
- */
-template<typename U>
-class get_value {
-public:
-  typedef U return_type;
-  typedef U value_type;
-  class NullType {};
-private:
-  /* could not solve the problem that one has to instantiate Traits
-     with a fixed number of template arguments where wrapped_type
-     would need to be provided already to go into the specialization
-  template<typename InstanceType, typename Dummy = InstanceType>
-  struct Traits {
-    typedef NullType container_type;
-    typedef InstanceType type;
-    static return_type apply(InstanceType& c) {
-      std::cout << "Traits";
-      return c;
-    }
-  };
-  // specialization for container instances
-  template<typename InstanceType>
-  struct Traits<InstanceType, typename InstanceType::wrapped_type> {
-    typedef InstanceType container_type;
-    typedef typename InstanceType::wrapped_type type;
-    static return_type apply(InstanceType& c) {
-      std::cout << "specialized Traits";
-      return c.get();
-    }
-  };
-  */
-
-public:
-  template<typename T>
-  return_type operator()(T& t) {
-    return t.get();
-    //return (typename Traits<T>::type)(t);
-  }
-};
-
-
-/******************************************************************************
- * @brief apply functor to the wrapped member object in the runtime container
- * This meta function recurses through the list while incrementing the index
- * and calls the functor at the required position
- *
- * @note internal meta function for the RuntimeContainers' apply function
- */
-template <
-  typename _ContainerT  // container type
-  , typename _IndexT    // data type of position index
-  , typename _Iterator  // current iterator position
-  , typename _End       // end iterator position
-  , _IndexT  _Index     // current index
-  , typename F          // functor
-  >
-struct rc_apply_at
-{
-  static typename F::return_type apply( _ContainerT& c, _IndexT position, F& f )
-  {
-    if ( position == _Index ) {
-      // this is the queried position, make the type cast to the current
-      // stage of the runtime container and execute function for it.
-      // Terminate loop by forwarding _End as _Iterator and thus
-      // calling the specialization
-      typedef typename boost::mpl::deref< _Iterator >::type stagetype;
-      stagetype& stage = static_cast<stagetype&>(c);
-      return f(stage);
-    } else {
-      // go to next element
-      return rc_apply_at<
-        _ContainerT
-        , _IndexT
-        , typename boost::mpl::next< _Iterator >::type
-        , _End
-        , _Index + 1
-        , F
-        >::apply( c, position, f );
-    }
-  }
-};
-// specialization: end of recursive loop, kicks in if _Iterator matches
-// _End.
-// here we end up if the position parameter is out of bounds
-template <
-  typename _ContainerT  // container type
-  , typename _IndexT    // data type of position index
-  , typename _End       // end iterator position
-  , _IndexT  _Index     // current index
-  , typename F          // functor
-  >
-struct rc_apply_at<_ContainerT
-                   , _IndexT
-                   , _End
-                   , _End
-                   , _Index
-                   , F
-                   >
-{
-  static typename F::return_type apply( _ContainerT& c, _IndexT position, F& f )
-  {
-    // TODO: this is probably the place to throw an exeption because
-    // we are out of bound
-    return typename F::return_type(0);
-  }
-};
-
-/**
- * Apply functor to the specified container level
- *
- * Ignores parameter '_IndexT'
- */
-template<typename _ContainerT
-         , typename _StageT
-         , typename _IndexT
-         , typename F>
-struct rc_apply {
-  typedef typename _ContainerT::types types;
-  static typename F::return_type apply(_ContainerT& c, _IndexT /*ignored*/, F& f)
-  {
-    return f(static_cast<_StageT&>(c));
-  }
-};
-
-/**
- * Generalized dispatcher with the ability for code unrolling
- *
- * The optional template parameter 'Position' can be used to cast directly to
- * the specified level in the runtime container and apply the functor without
- * the recursive loop. The template call with default parameters forwards to
- * the recursive call because 'Position' is set to out of list range.
- */
-template<typename _ContainerT
-         , typename F
-         , typename Position = boost::mpl::size<typename _ContainerT::types>
-         , typename _IndexT = int
-         >
-struct rc_dispatcher {
-  typedef typename _ContainerT::types types;
-  typedef typename boost::mpl::if_<
-    boost::mpl::less<Position,  boost::mpl::size<types> >
-    , rc_apply<_ContainerT, typename boost::mpl::at<types, Position>::type, _IndexT, F>
-    , rc_apply_at<
-      _ContainerT
-      , _IndexT
-      , typename boost::mpl::begin<types>::type
-      , typename boost::mpl::end<types>::type
-      , 0
-      , F
-      >
-    >::type type;
-
-  static typename F::return_type apply(_ContainerT& c, _IndexT position, F& f) {
-    return type::apply(c, position, f);
-  }
-};
-
-/**
- * @class RuntimeContainer The base for the mixin class
- * @brief the technical base of the mixin class
- *
- * The class is necessary to provide the innermost functionality of the
- * mixin.
- *
- * The level of the mixin is encoded in the type 'level' which is
- * incremented in each mixin stage.
- */
-template<typename InterfacePolicy = DefaultInterface
-  , typename InitializerPolicy = default_initializer
-  , typename PrinterPolicy = default_printer>
-struct RuntimeContainer : public InterfacePolicy
-{
-  InitializerPolicy _initializer;
-  PrinterPolicy     _printer;
-  typedef boost::mpl::int_<-1> level;
-  typedef boost::mpl::vector<>::type  types;
-
-  /// get size which is 0 at this level
-  constexpr std::size_t size() const {return 0;}
-
-  void print() {
-    const char* string = "base";
-    _printer(string, level::value);
-  }
-
-  // not yet clear if we need the setter and getter in the base class
-  // at least wrapped_type is not defined in the base
-  //void set(wrapped_type) {mMember = v;}
-  //wrapped_type get() const {return mMember;}
-
-};
-
-/**
- * @class rc_mixin Components for the mixin class
- * @brief Mixin component is used with different data types
- *
- * Each mixin component has a member of the specified type. The container
- * level exports the following data types to the outside:
- * - wrapped_type    the data type at this level
- * - mixin_type      composed type at this level
- * - types           mpl sequence containing all level types
- * - level           a data type containing the level
- */
-template <typename BASE, typename T>
-class rc_mixin : public BASE
-{
-public:
-  rc_mixin() : mMember() {BASE::_initializer(mMember);}
-
-  /// each stage of the mixin class wraps one type
-  typedef T wrapped_type;
-  /// this is the self type
-  typedef rc_mixin<BASE, wrapped_type> mixin_type;
-  /// a vector of all mixin stage types so far
-  typedef typename boost::mpl::push_back<typename BASE::types, mixin_type>::type types;
-  /// increment the level counter
-  typedef typename boost::mpl::plus< typename BASE::level, boost::mpl::int_<1> >::type level;
-  void print() {
-    // use the printer policy of this level, the policy returns
-    // a bool determining whether to call the underlying level
-    if (BASE::_printer(mMember, level::value)) {
-      BASE::print();
-    }
-  }
-
-  /// get size at this stage
-  constexpr std::size_t size() const {return level::value + 1;}
-  /// set member wrapped object
-  void set(wrapped_type v) {mMember = v;}
-  /// get wrapped object
-  wrapped_type get() const {return mMember;}
-  /// get wrapped object reference
-  wrapped_type& operator*() {return mMember;}
-  /// assignment operator to wrapped type
-  wrapped_type& operator=(const wrapped_type& v) {mMember = v; return mMember;}
-  /// type conversion to wrapped type
-  operator wrapped_type() const {return mMember;}
-  /// operator
-  wrapped_type& operator+=(const wrapped_type& v) {mMember += v; return mMember;}
-  /// operator
-  wrapped_type operator+(const wrapped_type& v) {return mMember + v;}
-
-  /// a functor wrapper dereferencing the RC container instance
-  /// the idea is to use this extra wrapper to apply the functor directly to
-  /// the wrapped type, see the comment below
-  template<typename F>
-  class member_apply_at {
-  public:
-    member_apply_at(F& f) : mFunctor(f) {}
-    typedef typename F::return_type return_type;
-    template<typename _T>
-    typename F::return_type operator()(_T& me) {
-      return mFunctor(*me);
-    }
-  private:
-    member_apply_at(); //forbidden
-    F& mFunctor;
-  };
-
-  /// apply functor to the runtime object at index
-  /// TODO: there is a performance issue with this solution, introducing another
-  /// level of functors makes the access much slower compared with applying to
-  /// container instance and using container member functions, tested with the
-  /// add_value functor and bench_runtime_container, also the actual operation
-  /// needs to be checked, the result is not correct for the last check of
-  /// 100000000 iterations
-  /*
-  template<typename F>
-  typename F::return_type applyToMember(int index, F f) {
-    return apply(index, member_apply_at<F>(f));
-  }
-  */
-
-  /*
-   * Apply a functor to the runtime container at index
-   *
-   * For performance tests there is a template option to do an explicite loop
-   * unrolling for the first n (=10) elements. This is however only effective
-   * if the compiler optimization is switched of. This is  in the end a nice
-   * demonstrator for the potential of compiler optimization. Unrolling is
-   * switched on with the compile time switch RC_UNROLL.
-   */
-  template<typename F
-#ifdef RC_UNROLL
-           , bool unroll = true
-#else
-           , bool unroll = false
-#endif
-           >
-  typename F::return_type apply(int index, F f) {
-    if (unroll) {// this is a compile time switch
-      // do unrolling for the first n elements and forward to generic
-      // recursive function for the rest.
-      switch (index) {
-      case 0: return rc_dispatcher<mixin_type, F, boost::mpl::int_<0>, int>::apply(*this, 0, f);
-      case 1: return rc_dispatcher<mixin_type, F, boost::mpl::int_<1>, int>::apply(*this, 1, f);
-      case 2: return rc_dispatcher<mixin_type, F, boost::mpl::int_<2>, int>::apply(*this, 2, f);
-      case 3: return rc_dispatcher<mixin_type, F, boost::mpl::int_<3>, int>::apply(*this, 3, f);
-      case 4: return rc_dispatcher<mixin_type, F, boost::mpl::int_<4>, int>::apply(*this, 4, f);
-      case 5: return rc_dispatcher<mixin_type, F, boost::mpl::int_<5>, int>::apply(*this, 5, f);
-      case 6: return rc_dispatcher<mixin_type, F, boost::mpl::int_<6>, int>::apply(*this, 6, f);
-      case 7: return rc_dispatcher<mixin_type, F, boost::mpl::int_<7>, int>::apply(*this, 7, f);
-      case 8: return rc_dispatcher<mixin_type, F, boost::mpl::int_<8>, int>::apply(*this, 8, f);
-      case 9: return rc_dispatcher<mixin_type, F, boost::mpl::int_<9>, int>::apply(*this, 9, f);
-      }
-    }
-    return rc_dispatcher<mixin_type, F>::apply(*this, index, f);
-  }
-
-private:
-  T mMember;
-};
-
-/**
- * @brief Applying rc_mixin with the template parameters as placeholders
- * The wrapping into an mpl lambda is necessary to separate placeholder scopes
- * in the mpl fold operation.
- */
-typedef typename boost::mpl::lambda< rc_mixin<_1, _2> >::type apply_rc_mixin;
-
-/**
- * @brief check the mixin level to be below specified level
- *
- * @note: the number is specified as a type, e.g. boost::mpl:int_<3>
- */
-template< typename T, typename N > struct rtc_less
-: boost::mpl::bool_<(T::level::value < boost::mpl::minus<N, boost::mpl::int_<1>>::value) > {};
-
-template< typename T, typename N > struct rtc_equal
-: boost::mpl::bool_<boost::mpl::equal<typename T::wrapped_type, N>::type> {};
-
-/**
- * @brief create the runtime container type
- * The runtime container type is build from a list of data types, the recursive
- * build can be optionally stopped at the level of argument N.
- *
- * Usage: typedef create_rtc<types, base>::type container_type;
- */
-template<typename Types, typename Base, typename N = boost::mpl::size<Types>>
-struct  create_rtc
-{
-  typedef typename boost::mpl::lambda<
-    // mpl fold loops over all elements in the list of the first template
-    // parameter and provides this as placeholder _2; for every element the
-    // operation of the third template parameter is applied to the result of
-    // the previous stage which is provided as placeholder _1 to the operation
-    // and initialized to the second template argument for the very first
-    // operation
-    typename boost::mpl::fold<
-      // list of types, each element provided as placeholder _1
-      Types
-      // initializer for the _1 placeholder
-      , Base
-      // recursively applied operation, depending on the outcome of rtc_less
-      // either the next mixin level is applied or the current state is used
-      , boost::mpl::if_<
-          rtc_less<_1, N >
-          // apply mixin level
-          , boost::mpl::apply2< boost::mpl::protect<apply_rc_mixin>::type, _1, _2 >
-          // keep current state by identity
-          , boost::mpl::identity<_1>
-          >
-      >::type
-    >::type type;
-};
-
-/**
- * @brief create an mpl vector of mixin types
- * Every stage in the runtime container contains all the previous ones.
- * The resulting mpl vector of this meta function contains all individual
- * stages.
- *
- * Usage: typedef create_rtc_types<types, base>::type container_types;
- */
-template<typename Types, typename Base, typename N = boost::mpl::size<Types>>
-struct create_rtc_types
-{
-  typedef typename boost::mpl::fold<
-    boost::mpl::range_c<int, 0, N::value>
-    , boost::mpl::vector< >
-    , boost::mpl::push_back<_1, create_rtc<Types , Base , boost::mpl::plus<_2, boost::mpl::int_<1>>>>
-    >::type type;
-};
-
-};// namespace gNeric
-// clang-format on
-
-#endif
diff --git a/Utilities/DataCompression/tpccluster_parameter_model.h b/Utilities/DataCompression/tpccluster_parameter_model.h
deleted file mode 100644
index e8455399f17c1..0000000000000
--- a/Utilities/DataCompression/tpccluster_parameter_model.h
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "DataCompression/dc_primitives.h"
-#include "DataCompression/HuffmanCodec.h"
-#include <bitset>
-#include <boost/mpl/vector.hpp>
-#include <boost/mpl/string.hpp>
-
-/**
- * Parameter model definitions
- * - boost mpl vector of alphabets
- */
-using tpccluster_parameter =
-  boost::mpl::vector<BitRangeContiguousAlphabet<uint16_t, 6, boost::mpl::string<'p', 'a', 'd', 'r', 'o', 'w'>>,
-                     BitRangeContiguousAlphabet<uint16_t, 14, boost::mpl::string<'p', 'a', 'd'>>,
-                     BitRangeContiguousAlphabet<uint16_t, 15, boost::mpl::string<'t', 'i', 'm', 'e'>>,
-                     BitRangeContiguousAlphabet<uint16_t, 8, boost::mpl::string<'s', 'i', 'g', 'm', 'a', 'Y', '2'>>,
-                     BitRangeContiguousAlphabet<uint16_t, 8, boost::mpl::string<'s', 'i', 'g', 'm', 'a', 'Z', '2'>>,
-                     BitRangeContiguousAlphabet<uint16_t, 16, boost::mpl::string<'c', 'h', 'a', 'r', 'g', 'e'>>,
-                     BitRangeContiguousAlphabet<uint16_t, 10, boost::mpl::string<'q', 'm', 'a', 'x'>>>;
-/**
- * Definition of Huffman probability models for the above defined alphabets
- *
- * This is a temporary definition, the mpl sequence can be created automatically
- * from the list of alphabet types, but did not manage so far (see below)
- */
-template <typename RepT, int Length, typename Description>
-using Model = o2::HuffmanModel<ProbabilityModel<BitRangeContiguousAlphabet<RepT, Length, Description>>,
-                               o2::HuffmanNode<std::bitset<64>>, true>;
-
-using tpccluster_parameter_models =
-  boost::mpl::vector<Model<uint16_t, /* */ 6, boost::mpl::string<'p', 'a', 'd', 'r', 'o', 'w'>>,
-                     Model<uint16_t, /**/ 14, boost::mpl::string<'p', 'a', 'd'>>,
-                     Model<uint16_t, /**/ 15, boost::mpl::string<'t', 'i', 'm', 'e'>>,
-                     Model<uint16_t, /* */ 8, boost::mpl::string<'s', 'i', 'g', 'm', 'a', 'Y', '2'>>,
-                     Model<uint16_t, /* */ 8, boost::mpl::string<'s', 'i', 'g', 'm', 'a', 'Z', '2'>>,
-                     Model<uint16_t, /**/ 16, boost::mpl::string<'c', 'h', 'a', 'r', 'g', 'e'>>,
-                     Model<uint16_t, /**/ 10, boost::mpl::string<'q', 'm', 'a', 'x'>>>;
-
-/** new approach
-  using basemodels = foldtype
-    < tpccluster_parameter,
-      mpl::lambda<ProbabilityModel<_>>::type
-      >::type;
-
-  using tpcmodels = foldtype
-    < basemodels,
-      mpl::lambda<_, o2::HuffmanNode<std::bitset<64>>>::type
-      >::type;
-*/
-
-/**
- * this was an attemp to create the vector of Huffman models directly
- * from the vector of alphabets
- *
- * For the moment, the placeholders of mpl fold are not expanded, so there are
- * unknown types in the end
- */
-/// very first attemp
-//using namespace boost::mpl::placeholders;
-//
-//typedef boost::mpl::fold<
-//  tpccluster_parameter,
-//  boost::mpl::vector<>,
-//  boost::mpl::push_back<
-//    _1
-//    , AliceO2::HuffmanModel< ProbabilityModel< _2 >, AliceO2::HuffmanNode<std::bitset<64>>, true>
-//    >
-//  >::type models_t;
-
-/// trying with additional lambda levels
-//typedef boost::mpl::string<'T','e','s','t'>::type TestAlphabetName;
-//typedef ContiguousAlphabet<int16_t, -1, 10, TestAlphabetName> TestAlphabet;
-//
-//typedef typename boost::mpl::lambda< ProbabilityModel< _1 > > apply_alphabet;
-//typedef boost::mpl::apply1<apply_alphabet, TestAlphabet>::type TestAlphabetModel;
-//typedef typename boost::mpl::lambda< AliceO2::HuffmanModel< _1, AliceO2::HuffmanNode<std::bitset<64>>, true> > apply_probabilitymodel;
-//typedef typename boost::mpl::apply1<boost::mpl::protect<apply_probabilitymodel>::type, TestAlphabetModel>::type TestHuffmanModel;
-//
-//TestAlphabetModel object;
-//typedef TestAlphabetModel::value_type vtype;
-//
-//std::cout << object.getName() << std::endl;
-
-//typedef boost::mpl::fold<
-//  tpccluster_parameter,
-//  boost::mpl::vector<>,
-//  boost::mpl::push_back<
-//    _1
-//    , boost::mpl::apply1< boost::mpl::protect<apply_huffmanmodel>::type, _2 >
-//    >
-//  >::type models_t;
diff --git a/Utilities/rANS/include/rANS/internal/containers/HistogramInterface.h b/Utilities/rANS/include/rANS/internal/containers/HistogramInterface.h
deleted file mode 100644
index 2c703ede64493..0000000000000
--- a/Utilities/rANS/include/rANS/internal/containers/HistogramInterface.h
+++ /dev/null
@@ -1,88 +0,0 @@
-// Copyright 2019-2023 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   HistogramInterface.h
-/// @author Michael Lettrich
-/// @brief  Operations that will be performed on a histogram
-
-#ifndef RANS_INTERNAL_CONTAINERS_HISTOGRAMINTERFACE_H_
-#define RANS_INTERNAL_CONTAINERS_HISTOGRAMINTERFACE_H_
-
-#include <gsl/span>
-
-#include "rANS/internal/common/utils.h"
-
-namespace o2::rans::internal
-{
-
-template <class source_T, class value_T, class difference_T, class derived_T>
-class HistogramInterface
-{
-
- public:
-  using source_type = source_T;
-  using value_type = value_T;
-  using difference_type = difference_T;
-
-  // operations
-  template <typename source_IT>
-  inline derived_T& addSamples(source_IT begin, source_IT end)
-  {
-    static_assert(utils::isCompatibleIter_v<source_type, source_IT>);
-
-    if (begin == end) {
-      return static_cast<derived_T&>(*this);
-    } else {
-      return static_cast<derived_T*>(this)->addSamples(begin, end);
-    }
-  };
-
-  inline derived_T& addSamples(gsl::span<const source_type> samples)
-  {
-    return addSamples(samples.data(), samples.data() + samples.size());
-  };
-
-  template <typename freq_IT>
-  inline derived_T& addFrequencies(freq_IT begin, freq_IT end, difference_type offset)
-  {
-    static_assert(utils::isCompatibleIter_v<value_type, freq_IT>);
-
-    if (begin == end) {
-      return static_cast<derived_T&>(*this);
-    } else {
-      return static_cast<derived_T*>(this)->addFrequencies(begin, end, offset);
-    }
-  };
-
-  inline derived_T& addFrequencies(gsl::span<const value_type> frequencies, difference_type offset)
-  {
-    return addFrequencies(frequencies.data(), frequencies.data() + frequencies.size(), offset);
-  };
-
-  derived_T& operator+(derived_T& other)
-  {
-    return addFrequencies(other.cbegin(), other.cbegin(), other.getOffset());
-  };
-
- protected:
-  HistogramInterface() = default;
-
-  template <typename freq_IT>
-  HistogramInterface(freq_IT begin, freq_IT end, difference_type offset)
-  {
-    static_assert(utils::isIntegralIter_v<freq_IT>);
-    addFrequencies(begin, end, offset);
-  };
-};
-
-} // namespace o2::rans::internal
-
-#endif /* RANS_INTERNAL_CONTAINERS_HISTOGRAMINTERFACE_H_ */

From c5ead8881e60c064d0c804889da12e1c55edaba4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Mon, 9 Feb 2026 09:46:24 +0100
Subject: [PATCH 1291/1764] Algorithm: Delete unused files (#15025)

---
 Algorithm/include/Algorithm/BitstreamReader.h | 290 ------------------
 Algorithm/test/test_BitstreamReader.cxx       | 121 --------
 2 files changed, 411 deletions(-)
 delete mode 100644 Algorithm/include/Algorithm/BitstreamReader.h
 delete mode 100644 Algorithm/test/test_BitstreamReader.cxx

diff --git a/Algorithm/include/Algorithm/BitstreamReader.h b/Algorithm/include/Algorithm/BitstreamReader.h
deleted file mode 100644
index 0a112183ab5ef..0000000000000
--- a/Algorithm/include/Algorithm/BitstreamReader.h
+++ /dev/null
@@ -1,290 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef BITSTREAMREADER_H
-#define BITSTREAMREADER_H
-
-/// @file   BitstreamReader.h
-/// @author Matthias Richter
-/// @since  2019-06-05
-/// @brief  Utility class to provide bitstream access to an underlying resource
-
-#include <type_traits>
-#include <bitset>
-
-namespace o2
-{
-namespace algorithm
-{
-
-/// @class BitStreamReader
-/// @brief Utility class to provide bitstream access to an underlying resource
-///
-/// Allows to access bits of variable length, supports integral types and also
-/// bitsets as target type. At the moment, the access is in direction MSB -> LSB.
-///
-///     BitstreamReader<uint8_t> reader(start, end);
-///     while (reader.good() && not reader.eof()) {
-///       // get an 8 bit value from the stream, moves the position
-///       uint8_t ivalue;
-///       reader.get(ivalue);
-///
-///       // get a 13 bit bitset without moving the position
-///       std::bitset<13> value;
-///       reader.peek(value, value.size());
-///       // e.g. use 7 bits of the data
-///       value >>= value.size() - 7;
-///       // move position by the specific number of bits
-///       reader.seek(7);
-///     }
-template <typename BufferType>
-class BitstreamReader
-{
- public:
-  using self_type = BitstreamReader<BufferType>;
-  // for the moment we simply use pointers, but with some traits this can be extended to
-  // containers
-  using value_type = BufferType;
-  using iterator = const value_type*;
-  static constexpr size_t value_size = sizeof(value_type) * 8;
-  BitstreamReader() = delete;
-  BitstreamReader(iterator start, iterator end)
-    : mStart(start), mEnd(end), mCurrent(mStart), mBitPosition(value_size)
-  {
-  }
-  ~BitstreamReader() = default;
-
-  /// Check reader's state
-  /// @return true if not in error state
-  bool good() const
-  {
-    return mBitPosition > 0;
-  }
-
-  /// Indicates end of data
-  /// @return true if end of resource is reached
-  bool eof() const
-  {
-    return mCurrent == mEnd && mBitPosition > 0;
-  }
-
-  /// Reset the reader, start over at beginning
-  void reset()
-  {
-    mCurrent = mStart;
-    mBitPosition = value_size;
-  }
-
-  /// Get the next N bits without moving the read position
-  /// if bitlength is smaller than the size of data type, result is aligned to LSB
-  /// TODO: this also works nicely for bitsets, but then the bitlength has to be specified
-  /// as template parameter, want to do a specific overload, but needs more work to catch
-  /// all cases.
-  /// @param v  target variable passed by reference
-  /// @return number of poked bits
-  template <typename T, size_t N = sizeof(T) * 8>
-  size_t peek(T& v)
-  {
-    static_assert(N <= sizeof(T) * 8);
-    return peek<T, false>(v, N);
-  }
-
-  /// Get the next n bits without moving the read position
-  /// if bitlength is smaller than the size of data type, result is aligned to LSB
-  /// @param v          target variable passed by reference
-  /// @param bitlength  number of bits to read
-  /// @return number of poked bits
-  template <typename T>
-  size_t peek(T& v, size_t bitlength)
-  {
-    return peek<T, true>(v, bitlength);
-  }
-
-  /// Move read position
-  /// @param bitlength  move count in number of bits
-  void seek(size_t bitlength)
-  {
-    while (good() && bitlength > 0 && mCurrent != mEnd) {
-      if (bitlength >= mBitPosition) {
-        bitlength -= mBitPosition;
-        mBitPosition = 0;
-      } else {
-        mBitPosition -= bitlength;
-        bitlength = 0;
-      }
-      if (mBitPosition == 0) {
-        mCurrent++;
-        mBitPosition = value_size;
-      }
-    }
-
-    if (bitlength > 0) {
-      mBitPosition = 0;
-    }
-  }
-
-  /// Get the next n bits and move the read position
-  template <typename T, size_t N = sizeof(T) * 8>
-  T get()
-  {
-    T result;
-    peek<T, N>(result);
-    seek(N);
-    return result;
-  }
-
-  /// Get the next n and move the read position
-  template <typename T>
-  T get(size_t bitlength = sizeof(T) * 8)
-  {
-    T result;
-    peek<T>(result, bitlength);
-    seek(bitlength);
-    return result;
-  }
-
-  /// @class Bits
-  /// @brief Helper class to get value of specified type which holds the number used bits
-  ///
-  /// The class holds both the extracted value access via peek method and the number of used
-  /// bits. The reader will be incremented when the object is destroyed.
-  /// The number of bits can be adjusted by using markUsed method
-  template <typename FieldType, size_t N = sizeof(FieldType) * 8, typename ParentType = self_type>
-  class Bits
-  {
-   public:
-    using field_type = FieldType;
-    static_assert(N <= sizeof(FieldType) * 8);
-    Bits()
-      : mParent(nullptr), mData(0), mLength(0)
-    {
-    }
-    Bits(ParentType* parent, FieldType&& data)
-      : mParent(parent), mData(std::move(data)), mLength(N)
-    {
-    }
-    Bits(Bits&& other)
-      : mParent(other.mParent), mData(std::move(other.mData)), mLength(other.mLength)
-    {
-      other.mParent = nullptr;
-      other.mLength = 0;
-    }
-
-    ~Bits()
-    {
-      if (mParent) {
-        mParent->seek(mLength);
-      }
-    }
-
-    auto& operator=(Bits<FieldType, N, ParentType>&& other)
-    {
-      mParent = other.mParent;
-      mData = std::move(other.mData);
-      mLength = other.mLength;
-      other.mParent = nullptr;
-      other.mLength = 0;
-
-      return *this;
-    }
-
-    FieldType& operator*()
-    {
-      return mData;
-    }
-
-    void markUsed(size_t length)
-    {
-      mLength = length;
-    }
-
-   private:
-    ParentType* mParent;
-    FieldType mData;
-    size_t mLength;
-  };
-
-  /// Read an integral value from the stream
-  template <typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0>
-  self_type& operator>>(T& target)
-  {
-    target = get<T>();
-    return *this;
-  }
-
-  /// Read a bitstream value from the stream
-  template <size_t N>
-  self_type& operator>>(std::bitset<N>& target)
-  {
-    target = get<std::bitset<N>, N>();
-    return *this;
-  }
-
-  /// Read a Bits object from the stream
-  template <typename T>
-  self_type& operator>>(Bits<T>& target)
-  {
-    T bitfield;
-    peek<T>(bitfield);
-    target = std::move(Bits<T>(this, std::move(bitfield)));
-    return *this;
-  }
-
- private:
-  /// The internal peek method
-  template <typename T, bool RuntimeCheck>
-  size_t peek(T& result, size_t bitlength)
-  {
-    if constexpr (RuntimeCheck) {
-      // the runtime check is disabled if bitlength is derived at compile time
-      if (bitlength > sizeof(T) * 8) {
-        throw std::length_error(std::string("requested bit length ") + std::to_string(bitlength) + " does not fit size of result data type " + std::to_string(sizeof(T) * 8));
-      }
-    }
-    result = 0;
-    size_t bitsToWrite = bitlength;
-    auto current = mCurrent;
-    auto bitsAvailable = mBitPosition;
-    while (bitsToWrite > 0 && current != mEnd) {
-      // extract available bits
-      value_type mask = ~value_type(0) >> (value_size - bitsAvailable);
-      if (bitsToWrite >= bitsAvailable) {
-        T value = (*current & mask) << (bitsToWrite - bitsAvailable);
-        result |= value;
-        bitsToWrite -= bitsAvailable;
-        bitsAvailable = 0;
-      } else {
-        value_type value = (*current & mask) >> (bitsAvailable - bitsToWrite);
-        result |= value;
-        bitsAvailable -= bitsToWrite;
-        bitsToWrite = 0;
-      }
-      if (bitsAvailable == 0) {
-        current++;
-        bitsAvailable = value_size;
-      }
-    }
-
-    return bitlength - bitsToWrite;
-  }
-
-  /// start of resource
-  iterator mStart;
-  /// end of resource
-  iterator mEnd;
-  /// current position in resource
-  iterator mCurrent;
-  /// bit position in current element
-  size_t mBitPosition;
-};
-} // namespace algorithm
-} // namespace o2
-#endif
diff --git a/Algorithm/test/test_BitstreamReader.cxx b/Algorithm/test/test_BitstreamReader.cxx
deleted file mode 100644
index 41e3b47f5f276..0000000000000
--- a/Algorithm/test/test_BitstreamReader.cxx
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   test_BitstreamReader.cxx
-/// @author Matthias Richter
-/// @since  2019-06-05
-/// @brief  Test program for BitstreamReader utility
-
-#define BOOST_TEST_MODULE Algorithm BitstreamReader unit test
-#define BOOST_TEST_MAIN
-#define BOOST_TEST_DYN_LINK
-#include <boost/test/unit_test.hpp>
-#include <iostream>
-#include <iomanip>
-#include <array>
-#include <vector>
-#include <bitset>
-#include "../include/Algorithm/BitstreamReader.h"
-
-namespace o2
-{
-namespace algorithm
-{
-
-BOOST_AUTO_TEST_CASE(test_BitstreamReader_basic)
-{
-  std::array<uint8_t, 8> data = {'d', 'e', 'a', 'd', 'b', 'e', 'e', 'f'};
-  std::array<uint8_t, 10> expected7bit = {0x32, 0x19, 0x2c, 0x16, 0x23, 0x09, 0x4a, 0x65, 0x33, 0x0};
-  auto reference = expected7bit.begin();
-  constexpr size_t totalBits = data.size() * sizeof(decltype(data)::value_type) * 8;
-  size_t bitsRead = 0;
-
-  BitstreamReader<uint8_t> reader(data.data(), data.data() + data.size());
-  while (bitsRead < totalBits) {
-    BOOST_REQUIRE(reference != expected7bit.end());
-    BOOST_CHECK(reader.eof() == false);
-    uint8_t value;
-    reader.peek(value);
-    // we use 7 bits of the data
-    value >>= 1;
-    reader.seek(7);
-    bitsRead += 7;
-    // in the last call should there is not enough data
-    BOOST_CHECK(reader.good() == (bitsRead <= totalBits));
-    BOOST_REQUIRE(reference != expected7bit.end());
-    //std::cout << "value " << (int)value << "  expected " << (int)*reference << std::endl;
-    BOOST_CHECK(value == *reference);
-    ++reference;
-  }
-}
-
-BOOST_AUTO_TEST_CASE(test_BitstreamReader_operator)
-{
-  std::array<uint8_t, 8> data = {'d', 'e', 'a', 'd', 'b', 'e', 'e', 'f'};
-  std::array<uint8_t, 10> expected7bit = {0x32, 0x19, 0x2c, 0x16, 0x23, 0x09, 0x4a, 0x65, 0x33, 0x0};
-  auto reference = expected7bit.begin();
-  constexpr size_t totalBits = data.size() * sizeof(decltype(data)::value_type) * 8;
-  size_t bitsRead = 0;
-
-  BitstreamReader<uint8_t> reader(data.data(), data.data() + data.size());
-  while (bitsRead < totalBits) {
-    BOOST_REQUIRE(reference != expected7bit.end());
-    BOOST_CHECK(reader.eof() == false);
-    {
-      decltype(reader)::Bits<uint8_t> value;
-      reader >> value;
-      // we use 7 bits of the data
-      *value >>= 1;
-      value.markUsed(7);
-      //std::cout << "value " << (int)*value << "  expected " << (int)*reference << std::endl;
-      BOOST_CHECK(*value == *reference);
-    }
-    bitsRead += 7;
-    // in the last call should there is not enough data
-    BOOST_CHECK(reader.good() == (bitsRead <= totalBits));
-    BOOST_REQUIRE(reference != expected7bit.end());
-    ++reference;
-  }
-}
-
-BOOST_AUTO_TEST_CASE(test_BitstreamReader_bitset)
-{
-  std::array<uint8_t, 8> data = {'d', 'e', 'a', 'd', 'b', 'e', 'e', 'f'};
-  std::array<uint8_t, 10> expected7bit = {0x32, 0x19, 0x2c, 0x16, 0x23, 0x09, 0x4a, 0x65, 0x33, 0x0};
-  auto reference = expected7bit.begin();
-  constexpr size_t totalBits = data.size() * sizeof(decltype(data)::value_type) * 8;
-  size_t bitsRead = 0;
-
-  BitstreamReader<uint8_t> reader(data.data(), data.data() + data.size());
-  while (bitsRead < totalBits) {
-    BOOST_REQUIRE(reference != expected7bit.end());
-    BOOST_CHECK(reader.eof() == false);
-    std::bitset<13> value;
-    reader.peek(value, value.size());
-    // we use 7 bits of the data
-    value >>= value.size() - 7;
-    reader.seek(7);
-    bitsRead += 7;
-    // in the last call should there is not enough data
-    BOOST_CHECK(reader.good() == (bitsRead <= totalBits));
-    BOOST_REQUIRE(reference != expected7bit.end());
-    BOOST_CHECK_MESSAGE(value.to_ulong() == *reference, std::string("mismatch: value ") << value.to_ulong() << ",  expected " << (int)*reference);
-    ++reference;
-  }
-
-  reader.reset();
-  std::bitset<16> aBitset;
-  reader >> aBitset;
-  BOOST_CHECK_MESSAGE(aBitset.to_ulong() == 0x6465, std::string("mismatch: value 0x") << std::hex << aBitset.to_ulong() << ",  expected 0x6465");
-}
-
-} // namespace algorithm
-} // namespace o2

From 7830e9c54db7ef479c0c8710c4b934c27312e2d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Mon, 9 Feb 2026 10:10:31 +0100
Subject: [PATCH 1292/1764] DataFormats: Delete unused files (#15029)

---
 .../include/Headers/SubframeMetadata.h        |  68 -----
 .../HLT/include/AliceHLT/TPCRawCluster.h      | 232 ------------------
 2 files changed, 300 deletions(-)
 delete mode 100644 DataFormats/Headers/include/Headers/SubframeMetadata.h
 delete mode 100644 DataFormats/Legacy/HLT/include/AliceHLT/TPCRawCluster.h

diff --git a/DataFormats/Headers/include/Headers/SubframeMetadata.h b/DataFormats/Headers/include/Headers/SubframeMetadata.h
deleted file mode 100644
index 255fa0ceb8db6..0000000000000
--- a/DataFormats/Headers/include/Headers/SubframeMetadata.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef SUBFRAMEMETADATA_H
-#define SUBFRAMEMETADATA_H
-
-#include <vector>
-
-namespace o2
-{
-namespace data_flow
-{
-
-struct SubframeMetadata {
-  // TODO: replace with timestamp struct
-  // IDEA: not timeframeID because can be calculcated with helper function
-  // QUESTION: isn't the duration set to ~22ms?
-  uint64_t startTime = ~(uint64_t)0;
-  uint64_t duration = ~(uint64_t)0;
-
-  //further meta data to be added
-
-  // putting data specific to FLP origin
-  int flpIndex;
-};
-
-// Helper function to derive the timeframe id from the actual timestamp.
-// Timestamp is in nanoseconds. Each Timeframe is ~22ms i.e. 2^17 nanoseconds,
-// so we can get a unique id by dividing by the timeframe period and masking
-// the lower 16 bits. Overlaps will only happen every ~ 22 minutes.
-constexpr uint16_t
-  timeframeIdFromTimestamp(uint64_t timestamp, uint64_t timeFrameDuration)
-{
-  return (timestamp / timeFrameDuration) & 0xffff;
-}
-
-// A Mockup class to describe some TPC-like payload
-struct TPCTestCluster {
-  float x = 0.f;
-  float y = 0.f;
-  float z = 1.5f;
-  float q = 0.;
-  uint64_t timeStamp; // the time this thing was digitized/recorded
-};
-
-struct TPCTestPayload {
-  std::vector<TPCTestCluster> clusters;
-};
-
-// a mockup class to describe some "ITS" payload
-struct ITSRawData {
-  float x = -1.;
-  float y = 1.;
-  uint64_t timeStamp;
-};
-
-} // namespace data_flow
-} // namespace o2
-
-#endif
diff --git a/DataFormats/Legacy/HLT/include/AliceHLT/TPCRawCluster.h b/DataFormats/Legacy/HLT/include/AliceHLT/TPCRawCluster.h
deleted file mode 100644
index 59be2a86c3c2b..0000000000000
--- a/DataFormats/Legacy/HLT/include/AliceHLT/TPCRawCluster.h
+++ /dev/null
@@ -1,232 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-//-*- Mode: C++ -*-
-
-#ifndef TPCRAWCLUSTER_H
-#define TPCRAWCLUSTER_H
-//****************************************************************************
-//* This file is free software: you can redistribute it and/or modify        *
-//* it under the terms of the GNU General Public License as published by     *
-//* the Free Software Foundation, either version 3 of the License, or        *
-//* (at your option) any later version.                                      *
-//*                                                                          *
-//* Primary Authors: Matthias Richter <richterm@scieq.net>                   *
-//*                                                                          *
-//* The authors make no claims about the suitability of this software for    *
-//* any purpose. It is provided "as is" without express or implied warranty. *
-//****************************************************************************
-
-//  @file   TPCRawCluster.h
-//  @author Matthias Richter
-//  @since  2015-09-27
-//  @brief  ALICE HLT TPC raw cluster structure and tools
-
-#include <iostream>
-#include <fstream> // ifstream
-#include <cstring> // memcpy
-
-namespace o2
-{
-namespace AliceHLT
-{
-
-/**
- * @struct RawCluster
- * This is a redefinition from AliRoot/HLT/TPCLib/AliHLTTPCRawCluster.h for the
- * sake of reading HLT TPC raw cluster files into O2.
- *
- * TODO: there is no dependence on AliRoot, however, a test needs to be added
- * to check consistency if AliRoot is available in the build.
- */
-struct RawCluster {
-
-  int16_t GetPadRow() const { return fPadRow; }
-  float GetPad() const { return fPad; }
-  float GetTime() const { return fTime; }
-  float GetSigmaPad2() const { return fSigmaPad2; }
-  float GetSigmaTime2() const { return fSigmaTime2; }
-  int32_t GetCharge() const { return fCharge; }
-  int32_t GetQMax() const { return fQMax; }
-  bool GetFlagSplitPad() const { return (fFlags & (1 << 0)); }
-  bool GetFlagSplitTime() const { return (fFlags & (1 << 1)); }
-  bool GetFlagSplitAny() const { return (fFlags & 3); }
-  uint16_t GetFlags() const { return (fFlags); }
-
-  int16_t fPadRow;
-  uint16_t fFlags; //Flags: (1 << 0): Split in pad direction
-                   //       (1 << 1): Split in time direction
-                   //During cluster merging, flags are or'd
-  float fPad;
-  float fTime;
-  float fSigmaPad2;
-  float fSigmaTime2;
-  uint16_t fCharge;
-  uint16_t fQMax;
-};
-
-/**
- * @struct RawClusterData
- * Header data struct for a raw cluster block
- */
-struct RawClusterData {
-  uint32_t fVersion;       // version number
-  uint32_t fCount;         // number of clusters
-  RawCluster fClusters[0]; // array of clusters
-};
-
-std::ostream& operator<<(std::ostream& stream, const RawCluster& cluster)
-{
-  stream << "TPCRawCluster:"
-         << " " << cluster.GetPadRow()
-         << " " << cluster.GetPad()
-         << " " << cluster.GetTime()
-         << " " << cluster.GetSigmaPad2()
-         << " " << cluster.GetSigmaTime2()
-         << " " << cluster.GetCharge()
-         << " " << cluster.GetQMax();
-  return stream;
-}
-
-/**
- * @class RawClusterArray Wrapper to binary data block of HLT TPC raw clusters
- * Container class which provides access to the content of a binary block of
- * HLT TPC raw clusters.
- */
-class RawClusterArray
-{
- public:
-  RawClusterArray() : mBuffer(nullptr), mBufferSize(0), mNClusters(0), mClusters(NULL), mClustersEnd(NULL) {}
-  RawClusterArray(const char* filename) : mBuffer(nullptr), mBufferSize(0), mNClusters(0), mClusters(NULL), mClustersEnd(NULL)
-  {
-    init(filename);
-  }
-  RawClusterArray(unsigned char* buffer, int size) : mBuffer(nullptr), mBufferSize(0), mNClusters(0), mClusters(NULL), mClustersEnd(NULL)
-  {
-    init(buffer, size);
-  }
-  ~RawClusterArray() {}
-
-  typedef uint8_t Buffer_t;
-
-  int init(const char* filename)
-  {
-    std::ifstream input(filename, std::ifstream::binary);
-    clear(0);
-    if (input) {
-      // get length of file:
-      input.seekg(0, input.end);
-      int length = input.tellg();
-      input.seekg(0, input.beg);
-
-      // allocate memory:
-      mBuffer = new Buffer_t[length];
-      mBufferSize = length;
-
-      // read data as a block:
-      input.read(reinterpret_cast<char*>(mBuffer), length);
-      if (!input.good()) {
-        clear(-1);
-        std::cerr << "failed to read " << length << " byte(s) from file " << filename << std::endl;
-      }
-
-      input.close();
-      return init();
-    }
-    std::cerr << "failed to open file " << filename << std::endl;
-    return -1;
-  }
-
-  int init(unsigned char* buffer, int size)
-  {
-    if (!buffer || size <= 0)
-      return -1;
-    clear(0);
-    mBuffer = new Buffer_t[size];
-    mBufferSize = size;
-    memcpy(mBuffer, buffer, size);
-    return init();
-  }
-
-  int GetNClusters() const { return mNClusters; }
-
-  RawCluster* begin() { return mClusters; }
-
-  RawCluster* end() { return mClustersEnd; }
-
-  RawCluster& operator[](int i)
-  {
-    if (i + 1 > mNClusters) {
-      // runtime exeption?
-      static RawCluster dummy;
-      return dummy;
-    }
-    return *(mClusters + i);
-  }
-
-  void print() { print(std::cout); }
-
-  template <typename StreamT>
-  StreamT& print(StreamT& stream)
-  {
-    std::cout << "RawClusterArray: " << mNClusters << " cluster(s)" << std::endl;
-    for (RawCluster* cluster = mClusters; cluster != mClustersEnd; cluster++) {
-      std::cout << "  " << *cluster << std::endl;
-    }
-    return stream;
-  }
-
- private:
-  int init()
-  {
-    if (mBuffer == nullptr || mBufferSize == 0)
-      return 0;
-    if (mBufferSize < sizeof(RawClusterData))
-      return -1;
-    RawClusterData& clusterData = *reinterpret_cast<RawClusterData*>(mBuffer);
-
-    if (clusterData.fCount * sizeof(RawCluster) + sizeof(RawClusterData) > mBufferSize) {
-      std::cerr << "Format error, " << clusterData.fCount << " cluster(s) "
-                << "would require "
-                << (clusterData.fCount * sizeof(RawCluster) + sizeof(RawClusterData))
-                << " byte(s), but only " << mBufferSize << " available" << std::endl;
-      return clear(-1);
-    }
-
-    mNClusters = clusterData.fCount;
-    mClusters = clusterData.fClusters;
-    mClustersEnd = mClusters + mNClusters;
-
-    return mNClusters;
-  }
-
-  int clear(int returnValue)
-  {
-    mNClusters = 0;
-    mClusters = NULL;
-    mClustersEnd = NULL;
-    delete[] mBuffer;
-    mBuffer = nullptr;
-    mBufferSize = 0;
-
-    return returnValue;
-  }
-
-  Buffer_t* mBuffer;
-  int mBufferSize;
-  int mNClusters;
-  RawCluster* mClusters;
-  RawCluster* mClustersEnd;
-};
-
-}; // namespace AliceHLT
-}; // namespace o2
-#endif

From 99d03b950769c309102f0a7d2cb7805e329f15ee Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Fri, 9 Jan 2026 15:15:52 +0000
Subject: [PATCH 1293/1764] Event Display: remove return statements from
 handled filesystem exceptions

---
 EventVisualisation/Base/src/DirectoryLoader.cxx | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/EventVisualisation/Base/src/DirectoryLoader.cxx b/EventVisualisation/Base/src/DirectoryLoader.cxx
index f2f5a421c0ef9..50b3de61295a3 100644
--- a/EventVisualisation/Base/src/DirectoryLoader.cxx
+++ b/EventVisualisation/Base/src/DirectoryLoader.cxx
@@ -37,7 +37,6 @@ deque<string> DirectoryLoader::load(const std::string& path, const std::string&
     }
   } catch (std::filesystem::filesystem_error const& ex) {
     LOGF(error, "filesystem problem during DirectoryLoader::load: %s", ex.what());
-    return result;
   }
   // comparison with safety if marker not in the filename (-1+1 gives 0)
   std::sort(result.begin(), result.end(),
@@ -62,7 +61,6 @@ bool DirectoryLoader::canCreateNextFile(const std::vector<std::string>& paths, c
       }
     } catch (std::filesystem::filesystem_error const& ex) {
       LOGF(error, "filesystem problem during DirectoryLoader::canCreateNextFile: %s", ex.what());
-      return false;
     }
   }
 
@@ -103,7 +101,6 @@ deque<string> DirectoryLoader::load(const std::vector<std::string>& paths, const
     }
   } catch (std::filesystem::filesystem_error const& ex) {
     LOGF(error, "filesystem problem during DirectoryLoader::load: %s", ex.what());
-    return result;
   }
   // comparison with safety if marker not in the filename (-1+1 gives 0)
   std::sort(result.begin(), result.end(),

From 28dcfc4269c76c97a71081f8f4835d0e9ce7e196 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 15 Jan 2026 15:17:28 +0100
Subject: [PATCH 1294/1764] Event Display: add OnlineMode and safety checks

---
 .../Base/src/DirectoryLoader.cxx              | 25 +++++++++++++------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/EventVisualisation/Base/src/DirectoryLoader.cxx b/EventVisualisation/Base/src/DirectoryLoader.cxx
index 50b3de61295a3..e106eaf7ebb47 100644
--- a/EventVisualisation/Base/src/DirectoryLoader.cxx
+++ b/EventVisualisation/Base/src/DirectoryLoader.cxx
@@ -14,6 +14,8 @@
 /// \author julian.myrcha@cern.ch
 
 #include "EventVisualisationBase/DirectoryLoader.h"
+#include "Framework/DefaultsHelpers.h"
+#include "Framework/DataTakingContext.h"
 #include <filesystem>
 #include <algorithm>
 #include <climits>
@@ -65,10 +67,13 @@ bool DirectoryLoader::canCreateNextFile(const std::vector<std::string>& paths, c
   }
 
   // comparison with safety if marker not in the filename (-1+1 gives 0)
-  std::ranges::sort(result.begin(), result.end(),
-                    [marker](const std::string& a, const std::string& b) {
-                      return a.substr(a.find_first_of(marker) + 1) > b.substr(b.find_first_of(marker) + 1);
-                    });
+  if (result.size() > 1) {
+    std::ranges::sort(result.begin(), result.end(),
+                      [marker](const std::string& a, const std::string& b) {
+                        return a.substr(a.find_first_of(marker) + 1) > b.substr(b.find_first_of(marker) + 1);
+                      });
+  }
+
   unsigned long accumulatedSize = 0L;
   const std::regex delimiter{"_"};
   for (auto const& file : result) {
@@ -113,11 +118,15 @@ deque<string> DirectoryLoader::load(const std::vector<std::string>& paths, const
 
 std::vector<std::string> DirectoryLoader::allFolders(const std::string& location)
 {
-  auto const pos = location.find_last_of('_');
   std::vector<std::string> folders;
-  folders.push_back(location.substr(0, pos) + "_PHYSICS");
-  folders.push_back(location.substr(0, pos) + "_COSMICS");
-  folders.push_back(location.substr(0, pos) + "_SYNTHETIC");
+  if (o2::framework::DefaultsHelpers::deploymentMode() == o2::framework::DeploymentMode::OnlineDDS) {
+    auto const pos = location.find_last_of('_');
+    folders.push_back(location.substr(0, pos) + "_PHYSICS");
+    folders.push_back(location.substr(0, pos) + "_COSMICS");
+    folders.push_back(location.substr(0, pos) + "_SYNTHETIC");
+  } else {
+    folders.push_back(location);
+  }
   return folders;
 }
 

From 1452f31b25e3ec1633e02e1a8f6151210b6bb70c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Mon, 9 Feb 2026 23:46:22 +0100
Subject: [PATCH 1295/1764] Framework: Delete unused files (#15038)

---
 .../Framework/DataProcessingStateManager.h    |  35 ----
 Framework/Foundation/src/Traits.cxx           |  10 --
 Framework/TestWorkflows/src/dummy.cxx         |  10 --
 Framework/TestWorkflows/src/o2_sim_its_ALP3.h |  25 ---
 Framework/TestWorkflows/src/o2_sim_tpc.cxx    | 157 ------------------
 Framework/TestWorkflows/src/o2_sim_tpc.h      |  25 ---
 .../src/test_o2ITSCluserizer.cxx              |  32 ----
 .../src/test_o2TPCSimulation.cxx              |  31 ----
 Framework/Utils/test/DPLBroadcasterMerger.cxx | 147 ----------------
 Framework/Utils/test/DPLBroadcasterMerger.h   |  28 ----
 Framework/Utils/test/DPLOutputTest.h          |  28 ----
 .../Utils/test/test_DPLBroadcasterMerger.cxx  |  31 ----
 Framework/Utils/test/test_DPLOutputTest.cxx   |  31 ----
 13 files changed, 590 deletions(-)
 delete mode 100644 Framework/Core/include/Framework/DataProcessingStateManager.h
 delete mode 100644 Framework/Foundation/src/Traits.cxx
 delete mode 100644 Framework/TestWorkflows/src/dummy.cxx
 delete mode 100644 Framework/TestWorkflows/src/o2_sim_its_ALP3.h
 delete mode 100644 Framework/TestWorkflows/src/o2_sim_tpc.cxx
 delete mode 100644 Framework/TestWorkflows/src/o2_sim_tpc.h
 delete mode 100644 Framework/TestWorkflows/src/test_o2ITSCluserizer.cxx
 delete mode 100644 Framework/TestWorkflows/src/test_o2TPCSimulation.cxx
 delete mode 100644 Framework/Utils/test/DPLBroadcasterMerger.cxx
 delete mode 100644 Framework/Utils/test/DPLBroadcasterMerger.h
 delete mode 100644 Framework/Utils/test/DPLOutputTest.h
 delete mode 100644 Framework/Utils/test/test_DPLBroadcasterMerger.cxx
 delete mode 100644 Framework/Utils/test/test_DPLOutputTest.cxx

diff --git a/Framework/Core/include/Framework/DataProcessingStateManager.h b/Framework/Core/include/Framework/DataProcessingStateManager.h
deleted file mode 100644
index eaa1c8e4e5501..0000000000000
--- a/Framework/Core/include/Framework/DataProcessingStateManager.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef O2_DATAPROCESSINGSTATEMANAGER_H_
-#define O2_DATAPROCESSINGSTATEMANAGER_H_
-
-#include <array>
-#include <vector>
-#include <string>
-
-struct DataProcessingStateManager {
-  struct StateIndex {
-    short id = -1;
-    short index = -1;
-  };
-  struct StateInfo {
-    std::string name;
-    int64_t lastUpdate = 0;
-    int index = -1;
-  };
-
-  static constexpr int MAX_STATES = 1024;
-  std::vector<std::array<char, 1024>> states = {};
-  std::vector<StateInfo> infos = {};
-};
-
-#endif
diff --git a/Framework/Foundation/src/Traits.cxx b/Framework/Foundation/src/Traits.cxx
deleted file mode 100644
index faff430964e73..0000000000000
--- a/Framework/Foundation/src/Traits.cxx
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
diff --git a/Framework/TestWorkflows/src/dummy.cxx b/Framework/TestWorkflows/src/dummy.cxx
deleted file mode 100644
index faff430964e73..0000000000000
--- a/Framework/TestWorkflows/src/dummy.cxx
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
diff --git a/Framework/TestWorkflows/src/o2_sim_its_ALP3.h b/Framework/TestWorkflows/src/o2_sim_its_ALP3.h
deleted file mode 100644
index f9c465fcf5717..0000000000000
--- a/Framework/TestWorkflows/src/o2_sim_its_ALP3.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef WORKFLOWS_O2_SIM_ITS_ALP3
-#define WORKFLOWS_O2_SIM_ITS_ALP3
-
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace workflows
-{
-o2::framework::DataProcessorSpec sim_its_ALP3();
-}
-} // namespace o2
-
-#endif // WORKFLOWS_O2_SIM_ITS_ALP3
diff --git a/Framework/TestWorkflows/src/o2_sim_tpc.cxx b/Framework/TestWorkflows/src/o2_sim_tpc.cxx
deleted file mode 100644
index 4587c0fcb831f..0000000000000
--- a/Framework/TestWorkflows/src/o2_sim_tpc.cxx
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-#include "Framework/DataRefUtils.h"
-#include "Framework/WorkflowSpec.h"
-#include <Monitoring/Monitoring.h>
-#include "Framework/RootFileService.h"
-#include "Framework/AlgorithmSpec.h"
-#include "Framework/ConfigParamRegistry.h"
-
-#include "Framework/Logger.h"
-
-#include "FairRunSim.h"
-#include <FairRootFileSink.h>
-#include "FairRuntimeDb.h"
-#include "FairPrimaryGenerator.h"
-#include "FairBoxGenerator.h"
-#include "FairParRootFileIo.h"
-
-#include "DetectorsPassive/Cave.h"
-#include "Field/MagneticField.h"
-
-#include "DetectorsPassive/Cave.h"
-#include "Generators/GeneratorFromFile.h"
-#include "TPCSimulation/Detector.h"
-#include "Framework/OutputSpec.h"
-#include <vector>
-
-using namespace o2::framework;
-
-#define BOX_GENERATOR 1
-
-namespace o2
-{
-namespace workflows
-{
-
-DataProcessorSpec sim_tpc()
-{
-  return {
-    "sim_tpc",
-    Inputs{},
-    Outputs{OutputSpec{"TPC", "GEN"}},
-    AlgorithmSpec{
-      [](InitContext& setup) {
-        int nEvents = setup.options().get<int>("nEvents");
-        auto mcEngine = setup.options().get<std::string>("mcEngine");
-
-        // FIXME: this should probably be part of some generic
-        //        FairRunInitSpec
-        TString dir = getenv("VMCWORKDIR");
-        TString geom_dir = dir + "/Detectors/Geometry/";
-        gSystem->Setenv("GEOMPATH", geom_dir.Data());
-
-        TString tut_configdir = dir + "/Detectors/gconfig";
-        gSystem->Setenv("CONFIG_DIR", tut_configdir.Data());
-
-        // Requiring a file is something which requires IO, and it's therefore
-        // delegated to the framework
-        auto& rfm = setup.services().get<RootFileService>();
-        // FIXME: We should propably have a service for FairRunSim, rather than
-        //        for the root files themselves...
-        // Output file name
-        auto outFile = rfm.format("AliceO2_%s.tpc.mc_%i_event.root", mcEngine.c_str(), nEvents);
-
-        // Parameter file name
-        auto parFile = rfm.format("AliceO2_%s.tpc.mc_%i_event.root", mcEngine.c_str(), nEvents);
-
-        // Create simulation run
-        FairRunSim* run = new FairRunSim();
-
-        run->SetName(mcEngine.c_str());
-        run->SetSink(new FairRootFileSink(outFile.c_str())); // Output file
-        FairRuntimeDb* rtdb = run->GetRuntimeDb();
-
-        // Create media
-        run->SetMaterials("media.geo"); // Materials
-
-        // Create geometry
-        o2::passive::Cave* cave = new o2::passive::Cave("CAVE");
-        cave->SetGeometryFileName("cave.geo");
-        run->AddModule(cave);
-
-        o2::field::MagneticField* magField = new o2::field::MagneticField("Maps", "Maps", -1., -1., o2::field::MagFieldParam::k5kG);
-        run->SetField(magField);
-
-        // ===| Add TPC |============================================================
-        o2::tpc::Detector* tpc = new o2::tpc::Detector(kTRUE);
-        tpc->SetGeoFileName("TPCGeometry.root");
-        run->AddModule(tpc);
-
-        // Create PrimaryGenerator
-        FairPrimaryGenerator* primGen = new FairPrimaryGenerator();
-#ifdef BOX_GENERATOR
-        FairBoxGenerator* boxGen = new FairBoxGenerator(211, 10); /*protons*/
-
-        //boxGen->SetThetaRange(0.0, 90.0);
-        boxGen->SetEtaRange(-0.9, 0.9);
-        boxGen->SetPRange(0.1, 5);
-        boxGen->SetPhiRange(0., 360.);
-        boxGen->SetDebug(kTRUE);
-
-        primGen->AddGenerator(boxGen);
-#else
-        // reading the events from a kinematics file (produced by AliRoot)
-        auto extGen = new o2::eventgen::GeneratorFromFile(params.get<std::string>("extKinFile"));
-        extGen->SetStartEvent(params.get<int>("startEvent"));
-        primGen->AddGenerator(extGen);
-#endif
-
-        run->SetGenerator(primGen);
-
-        // store track trajectories
-        // run->SetStoreTraj(kTRUE);
-
-        // Initialize simulation run
-        run->Init();
-
-        // Runtime database
-        Bool_t kParameterMerged = kTRUE;
-        FairParRootFileIo* parOut = new FairParRootFileIo(kParameterMerged);
-        parOut->open(parFile.c_str());
-        rtdb->setOutput(parOut);
-        rtdb->saveOutput();
-        rtdb->print();
-        run->Run(nEvents);
-
-        static bool once = true;
-
-        // This is the actual inner loop for the device
-        return [run, nEvents](ProcessingContext& ctx) {
-          if (!once) {
-            run->Run(nEvents);
-            once = true;
-          } else {
-            std::this_thread::sleep_for(std::chrono::seconds(1));
-          }
-          // FIXME: After we run we should readback events
-          // and push them as messages, for the next stage of
-          // processing.
-        };
-      }},
-    Options{
-      {"mcEngine", VariantType::String, "TGeant3", {"Engine to use"}},
-      {"nEvents", VariantType::Int, 10, {"Events to process"}},
-      {"extKinFile", VariantType::String, "Kinematics.root", {"name of kinematics file for event generator from file (when applicable)"}},
-      {"startEvent", VariantType::Int, 2, {"Events to skip"}}}};
-};
-} // namespace workflows
-} // namespace o2
diff --git a/Framework/TestWorkflows/src/o2_sim_tpc.h b/Framework/TestWorkflows/src/o2_sim_tpc.h
deleted file mode 100644
index e567fe89e0b38..0000000000000
--- a/Framework/TestWorkflows/src/o2_sim_tpc.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef WORKFLOWS_O2_SIM_TPC
-#define WORKFLOWS_O2_SIM_TPC
-
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace workflows
-{
-o2::framework::DataProcessorSpec sim_tpc();
-}
-} // namespace o2
-
-#endif // WORKFLOWS_O2_SIM_TPC
diff --git a/Framework/TestWorkflows/src/test_o2ITSCluserizer.cxx b/Framework/TestWorkflows/src/test_o2ITSCluserizer.cxx
deleted file mode 100644
index d6d3cb1242f7c..0000000000000
--- a/Framework/TestWorkflows/src/test_o2ITSCluserizer.cxx
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-#include "Framework/DataRefUtils.h"
-#include "Framework/ServiceRegistry.h"
-#include "Framework/runDataProcessing.h"
-#include <Monitoring/Monitoring.h>
-// FIXME: this should not be needed as the framework should be able to
-//        decode TClonesArray by itself.
-#include "Framework/TMessageSerializer.h"
-#include "o2_sim_its_ALP3.h"
-#include "Framework/Logger.h"
-#include <TClonesArray.h>
-#include <TH1F.h>
-
-using namespace o2::framework;
-using namespace o2::workflows;
-
-// This is how you can define your processing in a declarative way
-WorkflowSpec defineDataProcessing(ConfigContext const&)
-{
-  return WorkflowSpec{
-    sim_its_ALP3(),
-  };
-}
diff --git a/Framework/TestWorkflows/src/test_o2TPCSimulation.cxx b/Framework/TestWorkflows/src/test_o2TPCSimulation.cxx
deleted file mode 100644
index 403ad8bc7127b..0000000000000
--- a/Framework/TestWorkflows/src/test_o2TPCSimulation.cxx
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-#include "Framework/DataRefUtils.h"
-#include "Framework/ServiceRegistry.h"
-#include "Framework/runDataProcessing.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/DataRef.h"
-// FIXME: this should not be needed as the framework should be able to
-//        decode TClonesArray by itself.
-#include "Framework/TMessageSerializer.h"
-#include "o2_sim_tpc.h"
-#include "Framework/Logger.h"
-
-using namespace o2::framework;
-using namespace o2::workflows;
-
-// This is how you can define your processing in a declarative way
-WorkflowSpec defineDataProcessing(ConfigContext const& specs)
-{
-  return WorkflowSpec{
-    sim_tpc(),
-  };
-}
diff --git a/Framework/Utils/test/DPLBroadcasterMerger.cxx b/Framework/Utils/test/DPLBroadcasterMerger.cxx
deleted file mode 100644
index bf793275d2f3f..0000000000000
--- a/Framework/Utils/test/DPLBroadcasterMerger.cxx
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author Gabriele Gaetano Fronzé, gfronze@cern.ch
-
-#include <fstream>
-#include "DPLBroadcasterMerger.h"
-#include "DPLUtils/Utils.h"
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/ControlService.h"
-#include "Framework/DataRefUtils.h"
-#include "random"
-#include "Framework/Logger.h"
-#include <thread>
-
-namespace o2f = o2::framework;
-
-namespace o2::workflows
-{
-
-o2f::Inputs noInputs{};
-o2f::Outputs noOutputs{};
-
-o2f::DataProcessorSpec defineGenerator(o2f::OutputSpec usrOutput)
-{
-  return {"Generator",             // Device name
-          noInputs,                // No inputs for a generator
-          o2f::Outputs{usrOutput}, // One simple output
-
-          o2f::AlgorithmSpec{[usrOutput](o2f::InitContext&) {
-            int msgCounter = 0;
-            auto msgCounter_shptr = std::make_shared<int>(msgCounter);
-            auto usrOutput_shptr = std::make_shared<o2f::Output>(getOutput(usrOutput));
-
-            LOG(info) << ">>>>>>>>>>>>>> Generator initialised";
-
-            // Processing context in captured from return on InitCallback
-            return [usrOutput_shptr, msgCounter_shptr](o2f::ProcessingContext& ctx) {
-              int msgIndex = (*msgCounter_shptr)++;
-              if (msgIndex > 10) {
-                ctx.services().get<framework::ControlService>().endOfStream();
-              }
-              LOG(info) << ">>> MSG:" << msgIndex;
-              std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-
-              LOG(info) << ">>> Preparing MSG:" << msgIndex;
-
-              auto& outputMsg =
-                ctx.outputs().newChunk(*usrOutput_shptr, (msgIndex + 1) * sizeof(uint32_t) / sizeof(char));
-
-              LOG(info) << ">>> Preparing1 MSG:" << msgIndex;
-
-              auto payload = reinterpret_cast<uint32_t*>(outputMsg.data());
-
-              payload[0] = msgIndex;
-
-              LOG(info) << ">>> Preparing2 MSG:" << msgIndex;
-
-              for (int k = 0; k < msgIndex; ++k) {
-                payload[k + 1] = (uint32_t)32;
-                LOG(info) << ">>>>\t" << payload[k + 1];
-              }
-
-              return;
-            };
-          }}};
-}
-
-o2f::DataProcessorSpec definePipeline(std::string devName, o2f::InputSpec usrInput, o2f::OutputSpec usrOutput)
-{
-  return {devName,               // Device name
-          o2f::Inputs{usrInput}, // No inputs, for the moment
-          o2f::Outputs{usrOutput}, o2f::AlgorithmSpec{[usrOutput](o2f::InitContext&) {
-            auto output_sharedptr = std::make_shared<o2f::Output>(getOutput(usrOutput));
-
-            // Processing context in captured from return on InitCallback
-            return [output_sharedptr](o2f::ProcessingContext& ctx) {
-              auto inputMsg = ctx.inputs().getByPos(0);
-              auto msgSize = o2::framework::DataRefUtils::getPayloadSize(inputMsg);
-
-              auto& fwdMsg = ctx.outputs().newChunk((*output_sharedptr), msgSize);
-              std::memcpy(fwdMsg.data(), inputMsg.payload, msgSize);
-            };
-          }}};
-}
-
-o2f::DataProcessorSpec defineSink(o2f::InputSpec usrInput)
-{
-  return {"Sink",                // Device name
-          o2f::Inputs{usrInput}, // No inputs, for the moment
-          noOutputs,
-
-          o2f::AlgorithmSpec{[](o2f::InitContext&) {
-            // Processing context in captured from return on InitCallback
-            return [](o2f::ProcessingContext& ctx) {
-              LOG(info) << "Received message ";
-
-              auto inputMsg = ctx.inputs().getByPos(0);
-              auto payload = reinterpret_cast<const uint32_t*>(inputMsg.payload);
-
-              LOG(info) << "Received message containing" << payload[0] << "elements";
-
-              for (int j = 0; j < payload[0]; ++j) {
-                LOG(info) << payload[j + 1] << "\t";
-              }
-              LOG(info);
-            };
-          }}};
-}
-
-o2::framework::WorkflowSpec DPLBroadcasterMergerWorkflow()
-{
-  auto lspec = o2f::WorkflowSpec();
-
-  // A generator of data
-  lspec.emplace_back(defineGenerator(o2f::OutputSpec{"TST", "ToBC", 0, o2f::Lifetime::Timeframe}));
-
-  // A two-way broadcaster
-  lspec.emplace_back(defineBroadcaster("Broadcaster",
-                                       o2f::InputSpec{"input", "TST", "ToBC", 0, o2f::Lifetime::Timeframe},
-                                       o2f::Outputs{{"TST", "BCAST0", 0, o2f::Lifetime::Timeframe},
-                                                    {"TST", "BCAST1", 0, o2f::Lifetime::Timeframe}}));
-
-  // Two pipeline devices
-  lspec.emplace_back(definePipeline("pip0", o2f::InputSpec{"bc", "TST", "BCAST0", 0, o2f::Lifetime::Timeframe},
-                                    o2f::OutputSpec{"TST", "PIP0", 0, o2f::Lifetime::Timeframe}));
-  lspec.emplace_back(definePipeline("pip1", o2f::InputSpec{"bc", "TST", "BCAST1", 0, o2f::Lifetime::Timeframe},
-                                    o2f::OutputSpec{"TST", "PIP1", 0, o2f::Lifetime::Timeframe}));
-
-  // A gatherer
-  lspec.emplace_back(defineMerger("Merger", o2f::Inputs{{"input1", "TST", "PIP0", 0, o2f::Lifetime::Timeframe}, {"input2", "TST", "PIP1", 0, o2f::Lifetime::Timeframe}},
-                                  o2f::OutputSpec{"TST", "ToSink", 0, o2f::Lifetime::Timeframe}));
-
-  // A sink which dumps messages
-  lspec.emplace_back(defineSink(o2f::InputSpec{"input", "TST", "ToSink", 0, o2f::Lifetime::Timeframe}));
-  return std::move(lspec);
-}
-
-} // namespace o2::workflows
diff --git a/Framework/Utils/test/DPLBroadcasterMerger.h b/Framework/Utils/test/DPLBroadcasterMerger.h
deleted file mode 100644
index 4607d72a702b7..0000000000000
--- a/Framework/Utils/test/DPLBroadcasterMerger.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author Gabriele Gaetano Fronzé, gfronze@cern.ch
-
-#ifndef DPLBROADCASTERMERGER_H
-#define DPLBROADCASTERMERGER_H
-
-#include "Framework/WorkflowSpec.h"
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace workflows
-{
-o2::framework::WorkflowSpec DPLBroadcasterMergerWorkflow();
-}
-} // namespace o2
-
-#endif // DPLBROADCASTERMERGER_H
diff --git a/Framework/Utils/test/DPLOutputTest.h b/Framework/Utils/test/DPLOutputTest.h
deleted file mode 100644
index ce776ffff1113..0000000000000
--- a/Framework/Utils/test/DPLOutputTest.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author Gabriele Gaetano Fronzé, gfronze@cern.ch
-
-#ifndef DPLOUTPUTTEST_H
-#define DPLOUTPUTTEST_H
-
-#include "Framework/WorkflowSpec.h"
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace workflows
-{
-o2::framework::WorkflowSpec DPLOutputTest();
-}
-} // namespace o2
-
-#endif // DPLOUTPUTTEST_H
diff --git a/Framework/Utils/test/test_DPLBroadcasterMerger.cxx b/Framework/Utils/test/test_DPLBroadcasterMerger.cxx
deleted file mode 100644
index 6ff554e75f462..0000000000000
--- a/Framework/Utils/test/test_DPLBroadcasterMerger.cxx
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author Gabriele Gaetano Fronzé, gfronze@cern.ch
-
-#include "Framework/DataRefUtils.h"
-#include "Framework/ServiceRegistry.h"
-#include "Framework/runDataProcessing.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/DataRef.h"
-// FIXME: this should not be needed as the framework should be able to
-//        decode TClonesArray by itself.
-#include "Framework/TMessageSerializer.h"
-#include "DPLBroadcasterMerger.h"
-#include "Framework/Logger.h"
-
-using namespace o2::framework;
-
-// This is how you can define your processing in a declarative way
-WorkflowSpec defineDataProcessing(ConfigContext const&)
-{
-  return o2::workflows::DPLBroadcasterMergerWorkflow();
-}
diff --git a/Framework/Utils/test/test_DPLOutputTest.cxx b/Framework/Utils/test/test_DPLOutputTest.cxx
deleted file mode 100644
index e49bea3074dd1..0000000000000
--- a/Framework/Utils/test/test_DPLOutputTest.cxx
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \author Gabriele Gaetano Fronzé, gfronze@cern.ch
-
-#include "Framework/DataRefUtils.h"
-#include "Framework/ServiceRegistry.h"
-#include "Framework/runDataProcessing.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/DataRef.h"
-// FIXME: this should not be needed as the framework should be able to
-//        decode TClonesArray by itself.
-#include "Framework/TMessageSerializer.h"
-#include "DPLOutputTest.h"
-#include "Framework/Logger.h"
-
-using namespace o2::framework;
-
-// This is how you can define your processing in a declarative way
-WorkflowSpec defineDataProcessing(ConfigContext const&)
-{
-  return o2::workflows::DPLOutputTest();
-}

From 1fd232899d168aab1eaa344aab5562589f7195a2 Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Tue, 10 Feb 2026 01:50:33 +0100
Subject: [PATCH 1296/1764] ALICE3 Sensor orientation fix + first try to close
 in-stave gaps (#15043)

---
 .../ALICE3/TRK/simulation/src/Detector.cxx    |  2 +-
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx    | 35 +++++++++++--------
 2 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index e0fc6ef1ed35b..06fd2d9670b67 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -128,7 +128,7 @@ void Detector::buildTRKMiddleOuterLayers()
       LOGP(info, "TRKLayer created. Name: {}", GeometryTGeo::getTRKLayerPattern() + std::to_string(0));
       mLayers.emplace_back(1, GeometryTGeo::getTRKLayerPattern() + std::to_string(1), 11.f, 10, 100.e-3);
       mLayers.emplace_back(2, GeometryTGeo::getTRKLayerPattern() + std::to_string(2), 15.f, 10, 100.e-3);
-      mLayers.emplace_back(3, GeometryTGeo::getTRKLayerPattern() + std::to_string(3), 19.f, 10, 100.e-3);
+      mLayers.emplace_back(3, GeometryTGeo::getTRKLayerPattern() + std::to_string(3), 20.f, 10, 100.e-3);
       mLayers.emplace_back(4, GeometryTGeo::getTRKLayerPattern() + std::to_string(4), 30.f, 10, 100.e-3);
       mLayers.emplace_back(5, GeometryTGeo::getTRKLayerPattern() + std::to_string(5), 45.f, 20, 100.e-3);
       mLayers.emplace_back(6, GeometryTGeo::getTRKLayerPattern() + std::to_string(6), 60.f, 20, 100.e-3);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index c4683f28918d0..8d30cf9759e40 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -168,7 +168,7 @@ TGeoVolume* TRKLayer::createChip(std::string type)
 
 TGeoVolume* TRKLayer::createModule(std::string type)
 {
-  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string moduleName = GeometryTGeo::getTRKModulePattern() + std::to_string(mLayerNumber);
 
   TGeoShape* module;
@@ -176,7 +176,7 @@ TGeoVolume* TRKLayer::createModule(std::string type)
 
   if (type == "cylinder") {
     module = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
-    moduleVol = new TGeoVolume(moduleName.c_str(), module, medAir);
+    moduleVol = new TGeoVolume(moduleName.c_str(), module, medSi);
 
     TGeoVolume* chipVol = createChip("cylinder");
     LOGP(debug, "Inserting {} in {} ", chipVol->GetName(), moduleVol->GetName());
@@ -186,7 +186,7 @@ TGeoVolume* TRKLayer::createModule(std::string type)
     double moduleLength = constants::moduleMLOT::length;
 
     module = new TGeoBBox(moduleWidth / 2, mChipThickness / 2, moduleLength / 2); // TO BE CHECKED !!!
-    moduleVol = new TGeoVolume(moduleName.c_str(), module, medAir);
+    moduleVol = new TGeoVolume(moduleName.c_str(), module, medSi);
 
     for (int iChip = 0; iChip < mHalfNumberOfChips; iChip++) {
       TGeoVolume* chipVolLeft = createChip("flat");
@@ -223,7 +223,7 @@ TGeoVolume* TRKLayer::createModule(std::string type)
 
 TGeoVolume* TRKLayer::createHalfStave(std::string type)
 {
-  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string halfStaveName = GeometryTGeo::getTRKHalfStavePattern() + std::to_string(mLayerNumber);
 
   TGeoShape* halfStave;
@@ -231,7 +231,7 @@ TGeoVolume* TRKLayer::createHalfStave(std::string type)
 
   if (type == "cylinder") {
     halfStave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
-    halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medAir);
+    halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medSi);
 
     TGeoVolume* moduleVol = createModule("cylinder");
     LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
@@ -242,7 +242,7 @@ TGeoVolume* TRKLayer::createHalfStave(std::string type)
     double halfStaveLength = constants::moduleMLOT::length * mNumberOfModules;
 
     halfStave = new TGeoBBox(halfStaveWidth / 2, mChipThickness / 2, halfStaveLength / 2);
-    halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medAir);
+    halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medSi);
 
     for (int iModule = 0; iModule < mNumberOfModules; iModule++) {
       TGeoVolume* moduleVol = createModule("flat");
@@ -257,6 +257,9 @@ TGeoVolume* TRKLayer::createHalfStave(std::string type)
       halfStaveVol->AddNode(moduleVol, iModule, trans);
     }
   }
+
+  halfStaveVol->SetLineColor(kYellow);
+
   return halfStaveVol;
 }
 
@@ -296,11 +299,11 @@ TGeoVolume* TRKLayer::createStave(std::string type)
       staveVol->AddNode(moduleVol, iModule, trans);
     }
   } else if (type == "staggered") {
-    /*double moduleWidth = constants::moduleMLOT::width;
-    double moduleLength = constants::moduleMLOT::length;*/
+    double overlap = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true)overlap
+    double shift = overlap / 2;
 
-    double halfstaveWidth = constants::ML::width;
-    double staveWidth = constants::OT::width; // Each stave has two modules (based on the LOI design)
+    double halfstaveWidth = constants::OT::halfstave::width;
+    double staveWidth = constants::OT::width - overlap;
     double staveLength = constants::moduleMLOT::length * mNumberOfModules;
 
     stave = new TGeoBBox(staveWidth / 2, mLogicalVolumeThickness / 2, staveLength / 2);
@@ -311,12 +314,12 @@ TGeoVolume* TRKLayer::createStave(std::string type)
     TGeoVolume* halfStaveVolRight = createHalfStave("flat");
 
     TGeoCombiTrans* transLeft = new TGeoCombiTrans();
-    transLeft->SetTranslation(-halfstaveWidth / 2 + 0.05, 0, 0); // TO BE CHECKED !!! 1mm overlap between the modules
+    transLeft->SetTranslation(-halfstaveWidth / 2 + shift, 0, 0); // TO BE CHECKED !!! 1mm overlap between the modules
     LOGP(debug, "Inserting {} in {} ", halfStaveVolLeft->GetName(), staveVol->GetName());
     staveVol->AddNode(halfStaveVolLeft, 0, transLeft);
 
     TGeoCombiTrans* transRight = new TGeoCombiTrans();
-    transRight->SetTranslation(halfstaveWidth / 2 - 0.05, 0.2, 0); // TO BE CHECKED !!! 1mm overlap between the modules
+    transRight->SetTranslation(halfstaveWidth / 2 - shift, 0.2, 0); // TO BE CHECKED !!! 1mm overlap between the modules
     LOGP(debug, "Inserting {} in {} ", halfStaveVolRight->GetName(), staveVol->GetName());
     staveVol->AddNode(halfStaveVolRight, 1, transRight);
   } else {
@@ -377,7 +380,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       // Put the staves in the correct position and orientation
       TGeoCombiTrans* trans = new TGeoCombiTrans();
       double theta = 360. * iStave / nStaves;
-      TGeoRotation* rot = new TGeoRotation("rot", theta + 90 + 3, 0, 0);
+      TGeoRotation* rot = new TGeoRotation("rot", theta - 90 + 3, 0, 0);
       trans->SetRotation(rot);
       trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
 
@@ -385,13 +388,15 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       layerVol->AddNode(staveVol, iStave, trans);
     }
   } else if (mLayout == kStaggered) {
+    double overlapInStave = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true)overlap
+
     double layerLength = constants::moduleMLOT::length * mNumberOfModules;
+    double staveWidth = constants::OT::width - overlapInStave;
 
     layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, layerLength / 2);
     layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
 
     // Compute the number of staves
-    double staveWidth = constants::OT::width; // Each stave has two modules (based on the LOI design)
     int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / staveWidth);
     nStaves += nStaves % 2; // Require an even number of staves
 
@@ -410,7 +415,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       // Put the staves in the correct position and orientation
       TGeoCombiTrans* trans = new TGeoCombiTrans();
       double theta = 360. * iStave / nStaves;
-      TGeoRotation* rot = new TGeoRotation("rot", theta + 90, 0, 0);
+      TGeoRotation* rot = new TGeoRotation("rot", theta - 90 + 3, 0, 0);
       trans->SetRotation(rot);
       trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
 

From d43ba29f8b05b6cb5e0914686830dd0740c87f80 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 5 Feb 2026 22:38:04 +0100
Subject: [PATCH 1297/1764] SimulationDataFormat: Delete unused files

---
 .../ProcessingEventInfo.h                     | 36 -------------------
 1 file changed, 36 deletions(-)
 delete mode 100644 DataFormats/simulation/include/SimulationDataFormat/ProcessingEventInfo.h

diff --git a/DataFormats/simulation/include/SimulationDataFormat/ProcessingEventInfo.h b/DataFormats/simulation/include/SimulationDataFormat/ProcessingEventInfo.h
deleted file mode 100644
index 150a8272c7714..0000000000000
--- a/DataFormats/simulation/include/SimulationDataFormat/ProcessingEventInfo.h
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file ProcessingEventInfo.h
-/// \brief Encapsulated meta information about current event being processed by FairRoot (analysis) tasks
-/// \author Sandro Wenzel
-
-#ifndef ALICEO2_DATA_EVENTINFO_H_
-#define ALICEO2_DATA_EVENTINFO_H_
-
-namespace o2
-{
-
-// A class encapsulating meta information about events being process
-// and the data being sent by run classes such as FairRunAna.
-// Can be send to processing tasks for usage so that they do no longer
-// need to access the FairRootManager directly.
-struct ProcessingEventInfo {
-  double eventTime;   //! time of the current event
-  int eventNumber;    //! the current entry
-  int sourceNumber;   //! the current source number
-  bool numberSources; //! number of sources
-  // can be extended further
-};
-
-} // namespace o2
-
-#endif

From 1f4624047d09e5bcf08c1e67c665593e4f178ef8 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 10 Feb 2026 10:50:56 +0100
Subject: [PATCH 1298/1764] Update OpenMP detection for macOS (#15040)

Updated OpenMP detection for macOS with hints to brew library paths and set required compile flags.
---
 dependencies/FindOpenMPMacOS.cmake | 47 +++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 11 deletions(-)

diff --git a/dependencies/FindOpenMPMacOS.cmake b/dependencies/FindOpenMPMacOS.cmake
index 264ce5398a331..9bdeb35ecd46d 100644
--- a/dependencies/FindOpenMPMacOS.cmake
+++ b/dependencies/FindOpenMPMacOS.cmake
@@ -1,28 +1,53 @@
+# Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
 find_library(OpenMP_LIBRARY
-    NAMES omp
+    NAMES omp libomp
+    HINTS
+        /opt/homebrew/opt/libomp/lib
+        /usr/local/opt/libomp/lib
 )
 
 find_path(OpenMP_INCLUDE_DIR
-    omp.h
+    NAMES omp.h
+    HINTS
+        /opt/homebrew/opt/libomp/include
+        /usr/local/opt/libomp/include
 )
 
 mark_as_advanced(OpenMP_LIBRARY OpenMP_INCLUDE_DIR)
 
 include(FindPackageHandleStandardArgs)
-find_package_handle_standard_args(OpenMP DEFAULT_MSG
-    OpenMP_LIBRARY OpenMP_INCLUDE_DIR)
+find_package_handle_standard_args(
+    OpenMPMacOS
+    DEFAULT_MSG
+    OpenMP_LIBRARY OpenMP_INCLUDE_DIR
+)
 
-if (OpenMP_FOUND)
+if (OpenMPMacOS_FOUND)
     set(OpenMP_LIBRARIES ${OpenMP_LIBRARY})
     set(OpenMP_INCLUDE_DIRS ${OpenMP_INCLUDE_DIR})
-    set(OpenMP_COMPILE_OPTIONS -Xpreprocessor -fopenmp)
 
-    set(OpenMP_CXX_FOUND True)
-    set(OpenMPMacOS_FOUND True)
-    add_library(OpenMP::OpenMP_CXX SHARED IMPORTED)
+    set(OpenMP_CXX_FOUND TRUE)
+    set(OpenMP_FOUND TRUE)
+
+    add_library(OpenMP::OpenMP_CXX INTERFACE IMPORTED)
     set_target_properties(OpenMP::OpenMP_CXX PROPERTIES
-        IMPORTED_LOCATION ${OpenMP_LIBRARIES}
         INTERFACE_INCLUDE_DIRECTORIES "${OpenMP_INCLUDE_DIRS}"
-        INTERFACE_COMPILE_OPTIONS "${OpenMP_COMPILE_OPTIONS}"
+        INTERFACE_COMPILE_OPTIONS "-Xclang;-fopenmp"
+        INTERFACE_LINK_LIBRARIES "${OpenMP_LIBRARIES}"
+    )
+    message(STATUS
+        "Found OpenMP (macOS workaround): "
+        "library=${OpenMP_LIBRARY}, "
+        "include=${OpenMP_INCLUDE_DIR}"
     )
 endif()

From a63c9c11727258f79489f5dc8801a55a6483d7ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 5 Feb 2026 22:53:21 +0100
Subject: [PATCH 1299/1764] TRD: Delete unused files

---
 .../TRD/base/src/CalSingleChamberStatus.cxx   | 154 ------------------
 1 file changed, 154 deletions(-)
 delete mode 100644 Detectors/TRD/base/src/CalSingleChamberStatus.cxx

diff --git a/Detectors/TRD/base/src/CalSingleChamberStatus.cxx b/Detectors/TRD/base/src/CalSingleChamberStatus.cxx
deleted file mode 100644
index f054d49766461..0000000000000
--- a/Detectors/TRD/base/src/CalSingleChamberStatus.cxx
+++ /dev/null
@@ -1,154 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-///////////////////////////////////////////////////////////////////////////////
-//                                                                           //
-//  Calibration base class for a single ROC                                  //
-//  Contains one char value per pad                                          //
-//                                                                           //
-///////////////////////////////////////////////////////////////////////////////
-
-#include "TRDBase/CalSingleChamberStatus.h"
-
-using namespace o2::trd;
-
-//_____________________________________________________________________________
-CalSingleChamberStatus::CalSingleChamberStatus() = default;
-
-//_____________________________________________________________________________
-CalSingleChamberStatus::CalSingleChamberStatus(Int_t p, Int_t c, Int_t cols)
-  : mPla(p), mCha(c), mNcols(cols)
-{
-  //
-  // Constructor that initializes a given pad plane type
-  //
-
-  //
-  // The pad plane parameter
-  //
-  switch (p) {
-    case 0:
-      if (c == 2) {
-        // L0C0 type
-        mNrows = 12;
-      } else {
-        // L0C1 type
-        mNrows = 16;
-      }
-      break;
-    case 1:
-      if (c == 2) {
-        // L1C0 type
-        mNrows = 12;
-      } else {
-        // L1C1 type
-        mNrows = 16;
-      }
-      break;
-    case 2:
-      if (c == 2) {
-        // L2C0 type
-        mNrows = 12;
-      } else {
-        // L2C1 type
-        mNrows = 16;
-      }
-      break;
-    case 3:
-      if (c == 2) {
-        // L3C0 type
-        mNrows = 12;
-      } else {
-        // L3C1 type
-        mNrows = 16;
-      }
-      break;
-    case 4:
-      if (c == 2) {
-        // L4C0 type
-        mNrows = 12;
-      } else {
-        // L4C1 type
-        mNrows = 16;
-      }
-      break;
-    case 5:
-      if (c == 2) {
-        // L5C0 type
-        mNrows = 12;
-      } else {
-        // L5C1 type
-        mNrows = 16;
-      }
-      break;
-  };
-
-  mNchannels = mNrows * mNcols;
-  if (mNchannels != 0) {
-    mData.resize(mNchannels);
-  }
-  memset(&mData[0], 0, sizeof(mData[0]) * mData.size());
-}
-
-//_____________________________________________________________________________
-CalSingleChamberStatus::CalSingleChamberStatus(const CalSingleChamberStatus& c)
-  : mPla(c.mPla), mCha(c.mCha), mNrows(c.mNrows), mNcols(c.mNcols), mNchannels(c.mNchannels)
-{
-  //
-  // CalSingleChamberStatus copy constructor
-  //
-
-  mData = c.mData;
-}
-
-//_____________________________________________________________________________
-CalSingleChamberStatus::~CalSingleChamberStatus() = default;
-
-//_____________________________________________________________________________
-CalSingleChamberStatus& CalSingleChamberStatus::operator=(const CalSingleChamberStatus& c)
-{
-  //
-  // Assignment operator
-  //
-
-  if (this == &c) {
-    return *this;
-  }
-
-  mPla = c.mPla;
-  mCha = c.mCha;
-  mNrows = c.mNrows;
-  mNcols = c.mNcols;
-  mNchannels = c.mNchannels;
-  mData = c.mData;
-
-  return *this;
-}
-
-//_____________________________________________________________________________
-void CalSingleChamberStatus::Copy(CalSingleChamberStatus& c) const
-{
-  //
-  // Copy function
-  //
-
-  Int_t iBin = 0;
-
-  c.mPla = mPla;
-  c.mCha = mCha;
-
-  c.mNrows = mNrows;
-  c.mNcols = mNcols;
-
-  c.mNchannels = mNchannels;
-
-  c.mData = mData;
-}

From d9bbbfccdc95fd9779cb9b08b7df78a8271e2565 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 5 Feb 2026 22:42:28 +0100
Subject: [PATCH 1300/1764] GlobalTrackingWorkflow: Delete unused files

---
 .../tofworkflow/src/RecoWorkflowSpec.cxx      | 189 ------------------
 1 file changed, 189 deletions(-)
 delete mode 100644 Detectors/GlobalTrackingWorkflow/tofworkflow/src/RecoWorkflowSpec.cxx

diff --git a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/RecoWorkflowSpec.cxx b/Detectors/GlobalTrackingWorkflow/tofworkflow/src/RecoWorkflowSpec.cxx
deleted file mode 100644
index ab4f90464b31b..0000000000000
--- a/Detectors/GlobalTrackingWorkflow/tofworkflow/src/RecoWorkflowSpec.cxx
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "TOFWorkflow/RecoWorkflowSpec.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/ControlService.h"
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/DataRefUtils.h"
-#include "Framework/Lifetime.h"
-#include "Framework/Task.h"
-#include "Framework/SerializationMethods.h"
-#include "Headers/DataHeader.h"
-#include "DataFormatsTOF/Cluster.h"
-#include "GlobalTracking/MatchTOF.h"
-#include "ReconstructionDataFormats/TrackTPCITS.h"
-#include "DetectorsBase/GeometryManager.h"
-#include "DetectorsBase/Propagator.h"
-#include "DetectorsBase/GRPGeomHelper.h"
-#include "CommonUtils/NameConf.h"
-#include <gsl/span>
-#include "TStopwatch.h"
-#include "TPCCalibration/VDriftHelper.h"
-
-// from FIT
-#include "DataFormatsFT0/RecPoints.h"
-
-#include <memory> // for make_shared, make_unique, unique_ptr
-#include <vector>
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace tof
-{
-
-// use the tasking system of DPL
-// just need to implement 2 special methods init + run (there is no need to inherit from anything)
-class TOFDPLRecoWorkflowTask
-{
-  using evIdx = o2::dataformats::EvIndex<int, int>;
-  using MatchOutputType = std::vector<o2::dataformats::MatchInfoTOF>;
-
-  bool mUseMC = true;
-  bool mUseFIT = false;
-
- public:
-  explicit TOFDPLRecoWorkflowTask(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool useFIT) : mGGCCDBRequest(gr), mUseMC(useMC), mUseFIT(useFIT) {}
-
-  void init(framework::InitContext& ic)
-  {
-    o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
-    mTimer.Stop();
-    mTimer.Reset();
-  }
-
-  void run(framework::ProcessingContext& pc)
-  {
-    mTimer.Start(false);
-    updateTimeDependentParams(pc);
-    //>>>---------- attach input data --------------->>>
-    const auto clustersRO = pc.inputs().get<gsl::span<o2::tof::Cluster>>("tofcluster");
-    const auto tracksRO = pc.inputs().get<gsl::span<o2::dataformats::TrackTPCITS>>("globaltrack");
-
-    if (mUseFIT) {
-      // Note: the particular variable will go out of scope, but the span is passed by copy to the
-      // worker and the underlying memory is valid throughout the whole computation
-      auto recPoints = std::move(pc.inputs().get<gsl::span<o2::ft0::RecPoints>>("fitrecpoints"));
-      mMatcher.setFITRecPoints(recPoints);
-      LOG(info) << "TOF Reco Workflow pulled " << recPoints.size() << " FIT RecPoints";
-    }
-
-    // we do a copy of the input but we are looking for a way to avoid it (current problem in conversion form unique_ptr to *)
-
-    gsl::span<const o2::MCCompLabel> itstpclab;
-    o2::dataformats::MCTruthContainer<o2::MCCompLabel> toflab;
-    if (mUseMC) {
-      const auto toflabel = pc.inputs().get<o2::dataformats::MCTruthContainer<o2::MCCompLabel>*>("tofclusterlabel");
-      itstpclab = pc.inputs().get<gsl::span<o2::MCCompLabel>>("itstpclabel");
-      toflab = std::move(*toflabel);
-    }
-
-    mMatcher.run(tracksRO, clustersRO, toflab, itstpclab);
-
-    // in run_match_tof aggiugnere esplicitamente la chiamata a fill del tree (nella classe MatchTOF) e il metodo per leggere i vettori di output
-
-    //...
-    // LOG(info) << "TOF CLUSTERER : TRANSFORMED " << digits->size()
-    //           << " DIGITS TO " << mClustersArray.size() << " CLUSTERS";
-
-    // send matching-info
-    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MTC_ITSTPC", 0}, mMatcher.getMatchedTrackVector());
-    if (mUseMC) {
-      pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MCMATCHTOF", 0}, mMatcher.getMatchedTOFLabelsVector());
-    }
-    pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "CALIBDATA", 0}, mMatcher.getCalibVector());
-    mTimer.Stop();
-  }
-
-  void endOfStream(EndOfStreamContext& ec)
-  {
-    LOGF(info, "TOF Matching total timing: Cpu: %.3e Real: %.3e s in %d slots",
-         mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
-  }
-
-  void updateTimeDependentParams(ProcessingContext& pc)
-  {
-    o2::base::GRPGeomHelper::instance().checkUpdates(pc);
-    mTPCVDriftHelper.extractCCDBInputs(pc);
-    static bool initOnceDone = false;
-    if (!initOnceDone) { // this params need to be queried only once
-      initOnceDone = true;
-      // put here init-once stuff
-    }
-    // we may have other params which need to be queried regularly
-    if (mTPCVDriftHelper.isUpdated()) {
-      LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} from source {}",
-           mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getSourceName());
-      mMatcher.setTPCVDrift(mTPCVDriftHelper.getVDriftObject());
-      mTPCVDriftHelper.acknowledgeUpdate();
-    }
-  }
-
-  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
-  {
-    if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
-      return;
-    }
-    if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
-      return;
-    }
-  }
-
- private:
-  o2::globaltracking::MatchTOF mMatcher; ///< Cluster finder
-  std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
-  o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  TStopwatch mTimer;
-};
-
-o2::framework::DataProcessorSpec getTOFRecoWorkflowSpec(bool useMC, bool useFIT)
-{
-  std::vector<InputSpec> inputs;
-  std::vector<OutputSpec> outputs;
-  inputs.emplace_back("tofcluster", o2::header::gDataOriginTOF, "CLUSTERS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("globaltrack", "GLO", "TPCITS", 0, Lifetime::Timeframe);
-  if (useMC) {
-    inputs.emplace_back("tofclusterlabel", o2::header::gDataOriginTOF, "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    inputs.emplace_back("itstpclabel", "GLO", "TPCITS_MC", 0, Lifetime::Timeframe);
-  }
-
-  if (useFIT) {
-    inputs.emplace_back("fitrecpoints", o2::header::gDataOriginFT0, "RECPOINTS", 0, Lifetime::Timeframe);
-  }
-  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
-                                                              true,                              // GRPECS=true
-                                                              false,                             // GRPLHCIF
-                                                              true,                              // GRPMagField
-                                                              true,                              // askMatLUT
-                                                              o2::base::GRPGeomRequest::Aligned, // geometry
-                                                              inputs,
-                                                              true);
-  o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
-
-  outputs.emplace_back(o2::header::gDataOriginTOF, "MTC_ITSTPC", 0, Lifetime::Timeframe);
-  if (useMC) {
-    outputs.emplace_back(o2::header::gDataOriginTOF, "MCMATCHTOF", 0, Lifetime::Timeframe);
-  }
-  outputs.emplace_back(o2::header::gDataOriginTOF, "CALIBDATA", 0, Lifetime::Timeframe);
-
-  return DataProcessorSpec{
-    "TOFRecoWorkflow",
-    inputs,
-    outputs,
-    AlgorithmSpec{adaptFromTask<TOFDPLRecoWorkflowTask>(ggRequest, useMC, useFIT)},
-    Options{
-      {"material-lut-path", VariantType::String, "", {"Path of the material LUT file"}}}};
-}
-
-} // end namespace tof
-} // end namespace o2

From aa7e258b79b263eff919e23579e9455ffe1c9c0b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 9 Feb 2026 09:48:53 +0100
Subject: [PATCH 1301/1764] FindO2GPU.cmake: be less verbose

---
 dependencies/FindO2GPU.cmake | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 42d0162691c37..3e8f012fea4b5 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 11
+# FindO2GPU.cmake Version 13
 
 set(CUDA_COMPUTETARGET_DEFAULT_FULL 80-real 86-real 89-real 120-real 75-virtual)
 set(HIP_AMDGPUTARGET_DEFAULT_FULL gfx906;gfx908)
@@ -65,7 +65,6 @@ function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterri
   else()
     set(CUDA_TARGET TESLA)
   endif()
-  message(STATUS "Using optimized CUDA settings for ${CUDA_TARGET} GPU (sm_${CUDA_FIRST_TARGET})")
 
   string(REGEX MATCH "^[ \t\r\n]*gfx[0-9]+" HIP_FIRST_TARGET "${HIP_AMDGPUTARGET}")
   string(STRIP "${HIP_FIRST_TARGET}" HIP_FIRST_TARGET)
@@ -87,12 +86,13 @@ function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterri
   else()
     set(HIP_TARGET VEGA)
   endif()
-  message(STATUS "Using optimized HIP settings for ${HIP_TARGET} GPU (gfx${HIP_FIRST_TARGET})")
 
   if(backend STREQUAL "CUDA") # CUDA filter
+    message(STATUS "Using optimized CUDA settings for ${CUDA_TARGET} GPU (sm_${CUDA_FIRST_TARGET})")
     set(TARGET_ARCH "${CUDA_TARGET}" PARENT_SCOPE)
   elseif(backend STREQUAL "HIP") # HIP filter
     set(TARGET_ARCH "${HIP_TARGET}" PARENT_SCOPE)
+    message(STATUS "Using optimized HIP settings for ${HIP_TARGET} GPU (gfx${HIP_FIRST_TARGET})")
   elseif(backend STREQUAL "ALL" OR backend STREQUAL "AUTO") # Return all / enabled backends
     set(TARGET_ARCH)
     if(CUDA_ENABLED OR backend STREQUAL "ALL")
@@ -194,8 +194,6 @@ if(ENABLE_CUDA)
     if(THRUST_INCLUDE_DIR STREQUAL "THRUST_INCLUDE_DIR-NOTFOUND")
       message(${FAILURE_SEVERITY} "CUDA found but thrust not available, looked under: ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES}")
       set(CMAKE_CUDA_COMPILER OFF)
-    else()
-      message(STATUS "Thrust found in the path: ${THRUST_INCLUDE_DIR}")
     endif()
     if (NOT CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL "12.8")
       message(${FAILURE_SEVERITY} "CUDA Version too old: ${CMAKE_CUDA_COMPILER_VERSION}, 12.8 required")
@@ -278,15 +276,14 @@ if(ENABLE_OPENCL)
      AND NOT LLVM_SPIRV STREQUAL "LLVM_SPIRV-NOTFOUND"
      AND OPENCL_COMPATIBLE_CLANG_FOUND)
     set(OPENCL_ENABLED_SPIRV ON)
-    message(STATUS "Using CLANG ${LLVM_CLANG} and ${LLVM_SPIRV} for SPIR-V compilation")
   endif ()
   if(OPENCL_COMPATIBLE_CLANG_FOUND AND
      (OpenCL_VERSION_STRING VERSION_GREATER_EQUAL 2.2
      OR OPENCL_ENABLED_SPIRV))
     set(OPENCL_ENABLED ON)
-    message(STATUS "Found OpenCL 2 (${OpenCL_VERSION_STRING} SPIR-V ${OPENCL_ENABLED_SPIRV} with CLANG ${LLVM_PACKAGE_VERSION})")
+    message(STATUS "Found OpenCL ${OpenCL_VERSION_STRING} (SPIR-V ${OPENCL_ENABLED_SPIRV} ${LLVM_CLANG} ${LLVM_PACKAGE_VERSION} ${LLVM_SPIRV})")
   elseif(NOT ENABLE_OPENCL STREQUAL "AUTO")
-    message(FATAL_ERROR "OpenCL 2.x not available")
+    message(FATAL_ERROR "OpenCL >= 2.x not available")
   else()
     set(OPENCL_ENABLED OFF)
   endif()
@@ -347,7 +344,6 @@ if(ENABLE_HIP)
         set(CMAKE_HIP_HOST_COMPILER "$ENV{GCC_TOOLCHAIN_ROOT}/bin/gcc")
       endif()
       enable_language(HIP)
-      message(STATUS "HIP language enabled: ${CMAKE_HIP_COMPILER}")
     endif()
   elseif(NOT ENABLE_HIP STREQUAL "AUTO")
     message(FATAL_ERROR "HIP requested, but CMAKE_PREFIX_PATH env variable does not contain rocm folder!")
@@ -373,7 +369,7 @@ if(ENABLE_HIP)
     if(HIP_AMDGPUTARGET)
       set(CMAKE_HIP_ARCHITECTURES "${HIP_AMDGPUTARGET}")
     endif()
-    message(STATUS "HIP Found (${hip_HIPCC_EXECUTABLE} version ${hip_VERSION}, Architectures ${CMAKE_HIP_ARCHITECTURES})")
+    message(STATUS "HIP Found (${hip_HIPCC_EXECUTABLE} version ${hip_VERSION}, ${CMAKE_HIP_COMPILER}, Architectures ${CMAKE_HIP_ARCHITECTURES})")
   else()
     set(HIP_ENABLED OFF)
   endif()

From 2d96089c502e6c582a108e4a0f0ed1cbb7a21e69 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 9 Feb 2026 09:49:15 +0100
Subject: [PATCH 1302/1764] GPU Parameters: Add script to generate parameter
 file from parameter list csv/json and architecture

---
 GPU/GPUTracking/CMakeLists.txt                |  4 +-
 .../gpu_param_header_generator.cmake          |  4 +-
 .../Standalone/Benchmark/CMakeLists.txt       |  2 +
 GPU/GPUTracking/Standalone/CMakeLists.txt     |  1 -
 .../Standalone/tools/dumpGPUParamByArch.sh    | 60 +++++++++++++++++++
 GPU/GPUTracking/display/CMakeLists.txt        |  9 ++-
 .../display/filterMacros/setinclude.sh.in     |  2 +-
 7 files changed, 72 insertions(+), 10 deletions(-)
 rename GPU/GPUTracking/{cmake => Definitions/Parameters}/gpu_param_header_generator.cmake (96%)
 create mode 100755 GPU/GPUTracking/Standalone/tools/dumpGPUParamByArch.sh

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 082dc1f10b1d6..dfee81b398a79 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -292,10 +292,10 @@ foreach(GPU_PARAM_JSON_FILE IN LISTS GPU_PARAM_JSON)
   math(EXPR GPU_PARAM_JSON_N_FILES "${GPU_PARAM_JSON_N_FILES} + 1")
 endforeach()
 
-include(cmake/gpu_param_header_generator.cmake)
+include(Definitions/Parameters/gpu_param_header_generator.cmake)
 set(GPU_DEFAULT_PARAMS_HEADER ${ON_THE_FLY_DIR}/GPUDefParametersDefaults.h)
 set(GPU_DEFAULT_PARAMS_HEADER_DEVICE ${ON_THE_FLY_DIR}/GPUDefParametersDefaultsDevice.h)
-generate_gpu_param_header("${GPU_PARAM_JSON_FILES}" "ALL" "${GPU_DEFAULT_PARAMS_HEADER}" "${GPU_DEFAULT_PARAMS_HEADER_DEVICE}" GPU_CONST_PARAM_ARCHITECTUES) # generate header with default GPU parameters, arch selected by CMake variables
+generate_gpu_param_header("${GPU_PARAM_JSON_FILES}" "ALL" "${GPU_DEFAULT_PARAMS_HEADER}" "${GPU_DEFAULT_PARAMS_HEADER_DEVICE}" GPU_CONST_PARAM_ARCHITECTUES) # generate header with default GPU parameters for all architectures
 list(APPEND GENERATED_HEADERS_LIST ${GPU_DEFAULT_PARAMS_HEADER} ${GPU_DEFAULT_PARAMS_HEADER_DEVICE})
 
 set(HDRS_INSTALL ${HDRS_INSTALL} ${GENERATED_HEADERS_LIST})
diff --git a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake b/GPU/GPUTracking/Definitions/Parameters/gpu_param_header_generator.cmake
similarity index 96%
rename from GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
rename to GPU/GPUTracking/Definitions/Parameters/gpu_param_header_generator.cmake
index 383d194aaa717..d0e36e7f15026 100644
--- a/GPU/GPUTracking/cmake/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/Definitions/Parameters/gpu_param_header_generator.cmake
@@ -110,6 +110,9 @@ function(generate_gpu_param_header GPU_PARAM_JSON_FILES ARCH_LIST OUT_HEADER OUT
 
     string(APPEND TMP_HEADER_DEVICE "#if 0\n")
     foreach(ARCH IN LISTS ARCH_LIST)
+        if(do_all_architectures EQUAL -1 AND do_auto_architectures EQUAL -1 AND NOT generate_gpu_param_header_OUTPUT_TMP_${ARCH})
+            message(FATAL_ERROR "No parameters defined for architecture ${ARCH}")
+        endif()
         string(APPEND TMP_HEADER_DEVICE "\n#elif defined(GPUCA_GPUTYPE_${ARCH})\n")
         string(APPEND TMP_HEADER_DEVICE ${generate_gpu_param_header_OUTPUT_TMP_${ARCH}})
     endforeach()
@@ -129,5 +132,4 @@ function(generate_gpu_param_header GPU_PARAM_JSON_FILES ARCH_LIST OUT_HEADER OUT
     string(APPEND TMP_HEADER_DEVICE "\n#endif // GPUDEFPARAMETERSDEFAULTSDEVICE_H\n")
     file(GENERATE OUTPUT "${OUT_HEADER}" CONTENT "${TMP_HEADER}")
     file(GENERATE OUTPUT "${OUT_HEADER_DEVICE}" CONTENT "${TMP_HEADER_DEVICE}")
-    message(STATUS "Generated ${OUT_HEADER} and ${OUT_HEADER_DEVICE}")
 endfunction()
diff --git a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
index eeafcfc44142d..9f28fd8cc6fe9 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
@@ -30,6 +30,8 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
     target_link_libraries(${targetName} PUBLIC GPUTracking)
 endif()
 
+install(DIRECTORY ../tools DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU)
+install(DIRECTORY ../../Definitions/Parameters/ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/tools FILES_MATCHING REGEX "\\.(python|sh|cmake)")
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
 if(ROOT_FOUND)
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 48fbd77c62786..0cf72fd2b4c3e 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -246,4 +246,3 @@ install(TARGETS ca TPCFastTransformation standalone_support)
 install(FILES "cmake/makefile" DESTINATION "${CMAKE_INSTALL_PREFIX}")
 install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${O2_DIR} ${CMAKE_INSTALL_PREFIX}/src)")
 install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_BINARY_DIR}/config.cmake ${CMAKE_INSTALL_PREFIX}/config.cmake)")
-install(DIRECTORY tools DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU)
diff --git a/GPU/GPUTracking/Standalone/tools/dumpGPUParamByArch.sh b/GPU/GPUTracking/Standalone/tools/dumpGPUParamByArch.sh
new file mode 100755
index 0000000000000..0a4f5f5c1656f
--- /dev/null
+++ b/GPU/GPUTracking/Standalone/tools/dumpGPUParamByArch.sh
@@ -0,0 +1,60 @@
+#!/bin/bash
+
+if [[ -z $3 ]]; then
+    echo "Usage: dumpGPUParamByArch.sh [JSON or CSV parameter file] [Architecture] [Output File]"
+    exit 1
+fi
+
+if ! command -v root &> /dev/null; then
+    echo "Cannot run root, please make sure ROOT is available and in the parh"
+    exit 1
+fi
+
+if [[ ! -f $1 ]]; then
+    echo "Input file $1 does not exist"
+    exit 1
+fi
+
+if [[ -f "include/GPU/GPUDefParametersLoad.inc" ]]; then
+    LOADDIR=$(realpath "include/GPU")
+elif [[ -f "$O2_ROOT/include/GPU/GPUDefParametersLoad.inc" ]]; then
+    LOADDIR=$(realpath "$O2_ROOT/include/GPU/")
+else
+    echo "Cannot find GPUDefParametersLoad.inc, please run from standalone benchmark folder or set \$O2_ROOT to the standalone or O2 installation"
+    exit 1
+fi
+
+set -e
+
+TMPDIR=$(mktemp -d)
+if [[ $? != 0 ]]; then
+    echo "Failed to create a temporary directory"
+    exit 1
+fi
+
+BASE_DIR=$(dirname $(realpath ${BASH_SOURCE[0]}))
+
+if [[ $1 =~ \.csv$ ]]; then
+    "${BASE_DIR}"/../../Definitions/Parameters/csv_to_json.sh $1 > "$TMPDIR"/temp.json
+    JSON_FILE="$TMPDIR"/temp.json
+else
+    JSON_FILE=$(realpath $1)
+fi
+
+cat <<EOT > "${TMPDIR}"/CMakeLists.txt
+cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
+project(DumpGPUParam NONE)
+include($BASE_DIR/../../Definitions/Parameters/gpu_param_header_generator.cmake)
+generate_gpu_param_header("${JSON_FILE}" "$2" "${TMPDIR}/GPUDefParametersDefaultsOnTheFly.h" "${TMPDIR}/GPUDefParametersDefaultsDeviceOnTheFly.h")
+EOT
+
+cmake -B "${TMPDIR}" -S"${TMPDIR}"
+
+echo -e "#define GPUCA_GPUTYPE_$2\n" \
+        "#define PARAMETER_FILE \"${TMPDIR}/GPUDefParametersDefaultsOnTheFly.h\"\n" \
+        "gInterpreter->AddIncludePath(\"${TMPDIR}\");gInterpreter->AddIncludePath(\"${LOADDIR}\");\n" \
+        ".x $BASE_DIR/dumpGPUDefParam.C(\"$3\")\n.q\n" | root -l -b
+
+echo -e "\nCreated $3 with parameters for $2 architecture from $1"
+
+rm -Rf "${TMPDIR}"
diff --git a/GPU/GPUTracking/display/CMakeLists.txt b/GPU/GPUTracking/display/CMakeLists.txt
index 32d25ee08b729..82ce0d4a9b190 100644
--- a/GPU/GPUTracking/display/CMakeLists.txt
+++ b/GPU/GPUTracking/display/CMakeLists.txt
@@ -151,14 +151,13 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   add_library(O2::${MODULE} ALIAS ${MODULE})
   target_link_libraries(${targetName} PUBLIC O2::GPUTracking)
   install(TARGETS ${MODULE})
-
-  install(DIRECTORY filterMacros/ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/displayTrackFilter FILES_MATCHING PATTERN "*.C")
-  get_property(GPU_DISPLAY_INCLUDE_PATH DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
-  configure_file(filterMacros/setinclude.sh.in setinclude.sh @ONLY)
-  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/setinclude.sh PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/displayTrackFilter)
 endif()
 
 install(FILES ${HDRS} ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+install(DIRECTORY filterMacros/ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/displayTrackFilter FILES_MATCHING PATTERN "*.C")
+get_property(GPU_DISPLAY_INCLUDE_PATH DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY INCLUDE_DIRECTORIES)
+configure_file(filterMacros/setinclude.sh.in setinclude.sh @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/setinclude.sh PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/displayTrackFilter)
 
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
diff --git a/GPU/GPUTracking/display/filterMacros/setinclude.sh.in b/GPU/GPUTracking/display/filterMacros/setinclude.sh.in
index c588923db4b43..0a301537bba0e 100755
--- a/GPU/GPUTracking/display/filterMacros/setinclude.sh.in
+++ b/GPU/GPUTracking/display/filterMacros/setinclude.sh.in
@@ -1,2 +1,2 @@
 #!/bin/bash
-export ROOC_INCLUDE_PATH="@GPU_DISPLAY_INCLUDE_PATH@"
+export ROOT_INCLUDE_PATH="@GPU_DISPLAY_INCLUDE_PATH@"

From bf8a4027b3eb50ce57d54dc0b796afa1cb6a2fcf Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 10 Feb 2026 14:21:16 +0100
Subject: [PATCH 1303/1764] Fix codechecker violation

---
 Detectors/EMCAL/base/src/ClusterFactory.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Detectors/EMCAL/base/src/ClusterFactory.cxx b/Detectors/EMCAL/base/src/ClusterFactory.cxx
index 970f7979ef86d..1752e5c0e98ee 100644
--- a/Detectors/EMCAL/base/src/ClusterFactory.cxx
+++ b/Detectors/EMCAL/base/src/ClusterFactory.cxx
@@ -528,8 +528,9 @@ void ClusterFactory<InputType>::evalNExMax(gsl::span<const int> inputsIndices, A
 
     // loop over all other cells in cluster
     for (size_t j = 0; j < n; j++) {
-      if (i == j)
+      if (i == j) {
         continue;
+      }
 
       // adjacent cell is any cell with adjacent phi or eta index
       if (std::abs(rows[i] - rows[j]) <= 1 &&

From f10bf6ecd0328e6a96700cc6de8d1afd57e66875 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 11 Feb 2026 10:02:55 +0100
Subject: [PATCH 1304/1764] DPL: oldest possible timeframe triggered
 CompletionPolicy (#15046)

This will trigger the processing whenever a given slot will not receive data
anymore in virtue of its timeslice being past the oldest possible timeframe.
---
 .../Framework/CompletionPolicyHelpers.h       |  8 ++++-
 .../Core/src/CompletionPolicyHelpers.cxx      | 29 ++++++++++++++++++-
 2 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/CompletionPolicyHelpers.h b/Framework/Core/include/Framework/CompletionPolicyHelpers.h
index 7f77e4a96f76f..9fce626854e5b 100644
--- a/Framework/Core/include/Framework/CompletionPolicyHelpers.h
+++ b/Framework/Core/include/Framework/CompletionPolicyHelpers.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -54,6 +54,12 @@ struct CompletionPolicyHelpers {
   }
   static CompletionPolicy consumeWhenAny(std::string matchName);
 
+  // Consume all the data captured until the oldest possible timeframe
+  // in input indicates that nothing else can be added to this timeslice.
+  // Useful in case of wildcards which multiplex multiple subspecs on the
+  // same input.
+  static CompletionPolicy consumeWhenPastOldestPossibleTimeframe(const char* name, CompletionPolicy::Matcher matcher);
+
   /// When any of the parts of the record have been received, consume them.
   static CompletionPolicy consumeWhenAnyWithAllConditions(const char* name, CompletionPolicy::Matcher matcher);
   /// Default matcher applies for all devices
diff --git a/Framework/Core/src/CompletionPolicyHelpers.cxx b/Framework/Core/src/CompletionPolicyHelpers.cxx
index 67c726b7f4368..2b49b8dfa9acd 100644
--- a/Framework/Core/src/CompletionPolicyHelpers.cxx
+++ b/Framework/Core/src/CompletionPolicyHelpers.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -11,6 +11,7 @@
 
 #include "Framework/CompletionPolicyHelpers.h"
 #include "Framework/CompletionPolicy.h"
+#include "Framework/DataProcessingHeader.h"
 #include "Framework/InputSpan.h"
 #include "Framework/DeviceSpec.h"
 #include "Framework/CompilerBuiltins.h"
@@ -263,6 +264,32 @@ CompletionPolicy CompletionPolicyHelpers::consumeWhenAnyZeroCount(const char* na
   return CompletionPolicy{name, matcher, callback, false};
 }
 
+CompletionPolicy CompletionPolicyHelpers::consumeWhenPastOldestPossibleTimeframe(const char* name, CompletionPolicy::Matcher matcher)
+{
+  auto callback = [](InputSpan const& inputs, std::vector<InputSpec> const&, ServiceRegistryRef& ref) -> CompletionPolicy::CompletionOp {
+    size_t currentTimeslice = -1;
+    for (auto& input : inputs) {
+      if (input.header == nullptr) {
+        continue;
+      }
+      o2::framework::DataProcessingHeader const* dph = o2::header::get<o2::framework::DataProcessingHeader*>(input.header);
+      if (dph && !TimingInfo::timesliceIsTimer(dph->startTime)) {
+        currentTimeslice = dph->startTime;
+        break;
+      }
+    }
+
+    auto& timesliceIndex = ref.get<TimesliceIndex>();
+    auto oldestPossibleTimeslice = timesliceIndex.getOldestPossibleInput().timeslice.value;
+
+    if (currentTimeslice >= oldestPossibleTimeslice) {
+      return CompletionPolicy::CompletionOp::Retry;
+    }
+    return CompletionPolicy::CompletionOp::Consume;
+  };
+  return CompletionPolicy{name, matcher, callback, false};
+}
+
 CompletionPolicy CompletionPolicyHelpers::consumeWhenAny(const char* name, CompletionPolicy::Matcher matcher)
 {
   auto callback = [](InputSpan const& inputs, std::vector<InputSpec> const&, ServiceRegistryRef& ref) -> CompletionPolicy::CompletionOp {

From 331f2cc815bd213df04c40ecb9359422f11edd8d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Wed, 11 Feb 2026 11:18:17 +0100
Subject: [PATCH 1305/1764] fix topology adjust corner case (#15053)

---
 Framework/Core/src/ArrowSupport.cxx | 4 +++-
 run/o2sim_kine_publisher.cxx        | 3 +--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 31cddc9803d69..450f31f4ba7d3 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -581,7 +581,6 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
       auto spawner = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-spawner"); });
       auto analysisCCDB = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-ccdb"); });
       auto builder = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-index-builder"); });
-      auto reader = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-reader"); });
       auto writer = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-writer"); });
       auto& dec = ctx.services().get<DanglingEdgesContext>();
       dec.requestedAODs.clear();
@@ -659,6 +658,9 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         workflow.erase(writer);
       }
 
+      // removing writer would invalidate the reader iterator if it was created before
+      auto reader = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-reader"); });
+
       if (reader != workflow.end()) {
         // If reader and/or builder were adjusted, remove unneeded outputs
         // update currently requested AODs
diff --git a/run/o2sim_kine_publisher.cxx b/run/o2sim_kine_publisher.cxx
index f72dd6eebaaf0..cfbea6ae02a5f 100644
--- a/run/o2sim_kine_publisher.cxx
+++ b/run/o2sim_kine_publisher.cxx
@@ -13,7 +13,6 @@
 #include "Framework/AnalysisTask.h"
 #include "Monitoring/Monitoring.h"
 #include "Framework/CommonDataProcessors.h"
-#include "SimulationDataFormat/MCTrack.h"
 #include "Steer/MCKinematicsReader.h"
 
 #include "Framework/runDataProcessing.h"
@@ -64,6 +63,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   spec.outputs.emplace_back("MC", "MCHEADER", 0, Lifetime::Timeframe);
   spec.outputs.emplace_back("MC", "MCTRACKS", 0, Lifetime::Timeframe);
   spec.requiredServices.push_back(o2::framework::ArrowSupport::arrowBackendSpec());
-  spec.algorithm = CommonDataProcessors::wrapWithRateLimiting(spec.algorithm);
+  spec.algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(spec.algorithm);
   return {spec};
 }

From 970ed8ea7328d3828694ba4770429ea680ff2524 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Wiktor=20Piero=C5=BCak?=
 <94726725+wpierozak@users.noreply.github.com>
Date: Wed, 11 Feb 2026 14:41:38 +0100
Subject: [PATCH 1306/1764] EventsPerBC calibration task for FT0 (O2-6563)
 (#14986)

Implements the EventsPerBC calibration task for FT0, which generates a histogram of VTX events above a defined amplitude threshold plotted against the BC.

* FT0: created first sketch of implementation of generation of TVX per Event calibration object

* FT0: Updated CMakeLists for calibration

* FT0: Added missing entry in FT0CalibrationLinkDef.h

* FT0 calibration: fixed ROOT directory compilation, fixed CCDB output

* FT0: refined logs in EventsPerBc calibration, fixed setting TF info in run method

* FT0: Added readme to calibrations

* FT0: Changed calibration object name, implemented missing OrbitReset fetching

* FT0 EventsPerBc calibration: storing histograms in float format, updated readme

* Changed type of EventsPerBc calibration object to std::array

* FT0: corrected macro FT0readEventsPerBc, corrected typo in calibration README

* Created CCDB object class for EvetnsPerBC calibration

* FT0: formatted EvensPerBc.h

* FT0: removed amplitudes thresholds from EventsPerBc

* FT0: Removed from EventsPerBc calibarion option to define slot lenght in TFs; Small code cleaning

* Changed default value of min number of entries in EventsPerBcProcessor from 5000 to 5000u
---
 DataFormats/Detectors/FIT/FT0/CMakeLists.txt  |   1 +
 .../FT0/include/DataFormatsFT0/EventsPerBc.h  |  25 ++++
 .../FIT/FT0/src/DataFormatsFT0LinkDef.h       |   2 +
 Detectors/FIT/FT0/calibration/CMakeLists.txt  |  70 ++++++----
 Detectors/FIT/FT0/calibration/README.md       |  62 +++++++++
 .../FT0Calibration/EventsPerBcCalibrator.h    |  81 ++++++++++++
 .../calibration/src/EventsPerBcCalibrator.cxx |  81 ++++++++++++
 .../calibration/src/FT0CalibrationLinkDef.h   |   4 +-
 .../FT0EventsPerBcProcessor-Workflow.cxx      |  47 +++++++
 .../calibration/workflow/FT0EventsPerBcSpec.h | 124 ++++++++++++++++++
 Detectors/FIT/FT0/macros/CMakeLists.txt       |  19 ++-
 Detectors/FIT/FT0/macros/FT0readEventsPerBc.C |  52 ++++++++
 12 files changed, 538 insertions(+), 30 deletions(-)
 create mode 100644 DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/EventsPerBc.h
 create mode 100644 Detectors/FIT/FT0/calibration/README.md
 create mode 100644 Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
 create mode 100644 Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
 create mode 100644 Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
 create mode 100644 Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
 create mode 100644 Detectors/FIT/FT0/macros/FT0readEventsPerBc.C

diff --git a/DataFormats/Detectors/FIT/FT0/CMakeLists.txt b/DataFormats/Detectors/FIT/FT0/CMakeLists.txt
index e5331b7b739b2..f7d6a111f4348 100644
--- a/DataFormats/Detectors/FIT/FT0/CMakeLists.txt
+++ b/DataFormats/Detectors/FIT/FT0/CMakeLists.txt
@@ -47,4 +47,5 @@ o2_target_root_dictionary(DataFormatsFT0
           include/DataFormatsFT0/GlobalOffsetsCalibrationObject.h
           include/DataFormatsFT0/SpectraInfoObject.h
           include/DataFormatsFT0/SlewingCoef.h
+          include/DataFormatsFT0/EventsPerBc.h
 )
diff --git a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/EventsPerBc.h b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/EventsPerBc.h
new file mode 100644
index 0000000000000..9fcd1318914bd
--- /dev/null
+++ b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/EventsPerBc.h
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef _FT0_EVENTS_PER_BC_CALIB_OBJECT
+#define _FT0_EVENTS_PER_BC_CALIB_OBJECT
+
+#include "CommonConstants/LHCConstants.h"
+#include <Rtypes.h>
+
+namespace o2::ft0
+{
+struct EventsPerBc {
+  std::array<double, o2::constants::lhc::LHCMaxBunches> histogram;
+  ClassDefNV(EventsPerBc, 1);
+};
+} // namespace o2::ft0
+#endif
\ No newline at end of file
diff --git a/DataFormats/Detectors/FIT/FT0/src/DataFormatsFT0LinkDef.h b/DataFormats/Detectors/FIT/FT0/src/DataFormatsFT0LinkDef.h
index 0d3491224180c..7f8c17a0cd191 100644
--- a/DataFormats/Detectors/FIT/FT0/src/DataFormatsFT0LinkDef.h
+++ b/DataFormats/Detectors/FIT/FT0/src/DataFormatsFT0LinkDef.h
@@ -56,4 +56,6 @@
 #pragma link C++ class std::pair < std::vector < double>, std::vector < double>> + ;
 #pragma link C++ class o2::ft0::SlewingCoef + ;
 
+#pragma link C++ class o2::ft0::EventsPerBc + ;
+
 #endif
diff --git a/Detectors/FIT/FT0/calibration/CMakeLists.txt b/Detectors/FIT/FT0/calibration/CMakeLists.txt
index d103b4a9a18b6..bee0493d300c1 100644
--- a/Detectors/FIT/FT0/calibration/CMakeLists.txt
+++ b/Detectors/FIT/FT0/calibration/CMakeLists.txt
@@ -10,26 +10,50 @@
 # or submit itself to any jurisdiction.
 
 o2_add_library(FT0Calibration
-        SOURCES
-        src/FT0TimeOffsetSlotContainer.cxx
-        PUBLIC_LINK_LIBRARIES
-         O2::DataFormatsFT0
-         O2::CommonDataFormat
-         O2::DetectorsCalibration
-           )
-       o2_target_root_dictionary(FT0Calibration
-        HEADERS
-        include/FT0Calibration/FT0TimeOffsetSlotContainer.h
-        )
-      o2_add_executable(ft0-time-offset-calib
-        COMPONENT_NAME calibration
-        SOURCES workflow/FT0TimeOffsetCalibration-Workflow.cxx
-        PUBLIC_LINK_LIBRARIES
-        O2::FT0Calibration O2::FITCalibration
-        )
-      o2_add_executable(ft0-time-spectra-processor
-        COMPONENT_NAME calibration
-        SOURCES workflow/FT0TimeSpectraProcessor-Workflow.cxx
-        PUBLIC_LINK_LIBRARIES
-        O2::FT0Calibration
-        )
+  SOURCES
+    src/FT0TimeOffsetSlotContainer.cxx
+    src/EventsPerBcCalibrator.cxx
+  PUBLIC_LINK_LIBRARIES
+    O2::DetectorsCalibration
+    O2::Framework
+    O2::CommonUtils
+    Microsoft.GSL::GSL
+    O2::DataFormatsFT0
+    O2::CommonDataFormat
+    O2::Steer
+    O2::CCDB
+    ROOT::Minuit
+    ROOT::Hist
+  )
+
+o2_target_root_dictionary(FT0Calibration
+  HEADERS
+    include/FT0Calibration/FT0TimeOffsetSlotContainer.h
+    include/FT0Calibration/EventsPerBcCalibrator.h
+  )
+
+o2_add_executable(ft0-time-offset-calib
+  COMPONENT_NAME calibration
+  SOURCES
+    workflow/FT0TimeOffsetCalibration-Workflow.cxx
+  PUBLIC_LINK_LIBRARIES
+    O2::FT0Calibration O2::FITCalibration
+  )
+
+o2_add_executable(ft0-time-spectra-processor
+  COMPONENT_NAME calibration
+  SOURCES
+    workflow/FT0TimeSpectraProcessor-Workflow.cxx
+  PUBLIC_LINK_LIBRARIES
+    O2::FT0Calibration
+  )
+
+o2_add_executable(ft0-events-per-bc-processor
+  COMPONENT_NAME calibration
+  SOURCES
+    workflow/FT0EventsPerBcProcessor-Workflow.cxx
+  PUBLIC_LINK_LIBRARIES
+    O2::FT0Calibration
+    O2::Framework
+    O2::CCDB
+)
\ No newline at end of file
diff --git a/Detectors/FIT/FT0/calibration/README.md b/Detectors/FIT/FT0/calibration/README.md
new file mode 100644
index 0000000000000..78b0f980400d2
--- /dev/null
+++ b/Detectors/FIT/FT0/calibration/README.md
@@ -0,0 +1,62 @@
+# Calibrations
+
+## Events per BC Calibration
+### Description
+Generates histograms of **Events per Bunch Crossing (BC)**. Events can be filtered by applying amplitude thresholds to the **A-side** and **C-side**.
+
+### Command-Line Options
+| Option | Default | Description |
+| :--- | :--- | :--- |
+| `--slot-len-sec` | `3600` | Duration of each slot in seconds. |
+| `--slot-len-tf` | `0` | Slot length in Time Frames (TFs). |
+| `--one-object-per-run` | — | If set, the workflow creates only one calibration object per run. |
+| `--min-entries-number` | `0` | Minimum number of entries required for a slot to be valid. |
+| `--min-ampl-side-a` | `-2147483648` | Amplitude threshold for Side A events. |
+| `--min-ampl-side-c` | `-2147483648` | Amplitude threshold for Side C events. |
+
+---
+
+## How to Run
+
+### Simulation Data
+First, it is important to digitize data with a non-zero run number, orbit, and timestamp. To set these parameters, one can use the `--configKeyValues` option, as shown in the example below.
+```
+o2-sim-digitizer-workflow \
+--onlyDet FT0 \
+--configKeyValues="HBFUtils.nHBFPerTF=128;HBFUtils.orbitFirst=128;HBFUtils.orbitFirstSampled=256;HBFUtils.runNumber=560560;HBFUtils.startTime=1768464099000"
+```
+
+To process simulation data, digits must first be converted to RAW format. The `o2-ft0-digi2raw` tool performs this conversion and generates the required configuration file.
+
+Once converted, you can run the calibration either as a single integrated workflow or by spawning as the sender and receiver components separately.
+
+#### Single Workflow Example
+Execute the following command within the simulation directory:
+```
+o2-raw-file-reader-workflow --input-conf FT0raw.cfg --loop -1 \
+| o2-ft0-flp-dpl-workflow --condition-backend=http://localhost:8080 \
+| o2-calibration-ft0-events-per-bc-processor --FT0EventsPerBcProcessor "--slot-len-sec=10" \
+| o2-calibration-ccdb-populator-workflow --ccdb-path=http://localhost:8080
+```
+
+Sender example (in simulation directory):
+```
+o2-raw-file-reader-workflow --input-conf FT0raw.cfg --loop -1 \
+| o2-ft0-flp-dpl-workflow --condition-backend=http://localhost:8080 \
+| o2-dpl-output-proxy --channel-config "name=downstream,method=connect,address=tcp://localhost:30453,type=push,transport=zeromq" --dataspec "downstream:FT0/DIGITSBC"
+```
+
+Receiver example:
+```
+o2-dpl-raw-proxy --channel-config "name=readout-proxy,type=pull,method=bind,address=tcp://localhost:30453,rateLogging=1,transport=zeromq" --dataspec "A:FT0/DIGITSBC/0" \
+| o2-calibration-ft0-events-per-bc-processor --FT0EventsPerBcProcessor "--slot-len-sec=10 --min-ampl-side-a=0" \
+| o2-calibration-ccdb-populator-workflow --ccdb-path=http://localhost:8080/
+```
+
+### CTF Data
+Example:
+```
+o2-ctf-reader-workflow --ctf-input ctf.root --onlyDet FT0 \
+| o2-calibration-ft0-events-per-bc-processor --FT0EventsPerBcProcessor "--slot-len-sec=10" \
+| o2-calibration-ccdb-populator-workflow --ccdb-path=http://localhost:8080/
+```
\ No newline at end of file
diff --git a/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h b/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
new file mode 100644
index 0000000000000..f44824517f258
--- /dev/null
+++ b/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
@@ -0,0 +1,81 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_FT0TVXPERBCID
+#define O2_FT0TVXPERBCID
+
+#include <bitset>
+#include <array>
+#include <limits>
+#include <TH1F.h>
+
+#include "CommonDataFormat/FlatHisto2D.h"
+#include "CommonConstants/LHCConstants.h"
+#include "DataFormatsFT0/SpectraInfoObject.h"
+#include "DataFormatsFT0/Digit.h"
+#include "DataFormatsFT0/EventsPerBc.h"
+#include "DetectorsCalibration/TimeSlotCalibration.h"
+#include "DetectorsCalibration/TimeSlot.h"
+#include "CommonDataFormat/TFIDInfo.h"
+#include "TH1F.h"
+#include "Rtypes.h"
+
+namespace o2::ft0
+{
+struct EventsPerBcContainer {
+  EventsPerBcContainer(int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC) {}
+
+  size_t getEntries() const { return entries; }
+  void print() const;
+  void fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const o2::ft0::Digit> data);
+  void merge(const EventsPerBcContainer* prev);
+
+  const int32_t mMinAmplitudeSideA;
+  const int32_t mMinAmplitudeSideC;
+
+  std::array<double, o2::constants::lhc::LHCMaxBunches> mTvx{0.0};
+  size_t entries{0};
+  long startTimeStamp{0};
+  long stopTimeStamp{0};
+
+  ClassDefNV(EventsPerBcContainer, 1);
+};
+
+class EventsPerBcCalibrator final : public o2::calibration::TimeSlotCalibration<o2::ft0::EventsPerBcContainer>
+{
+  using Slot = o2::calibration::TimeSlot<o2::ft0::EventsPerBcContainer>;
+  using TFType = o2::calibration::TFType;
+  using EventsHistogram = std::array<double, o2::constants::lhc::LHCMaxBunches>;
+
+ public:
+  EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC);
+
+  bool hasEnoughData(const Slot& slot) const override;
+  void initOutput() override;
+  void finalizeSlot(Slot& slot) override;
+  Slot& emplaceNewSlot(bool front, TFType tstart, TFType tend) override;
+
+  const std::vector<EventsPerBc>& getTvxPerBc() { return mTvxPerBcs; }
+  std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>>& getTvxPerBcCcdbInfo() { return mTvxPerBcInfos; }
+
+ private:
+  const uint32_t mMinNumberOfEntries;
+  const int32_t mMinAmplitudeSideA;
+  const int32_t mMinAmplitudeSideC;
+
+  std::vector<EventsPerBc> mTvxPerBcs;
+  std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>> mTvxPerBcInfos;
+
+  ClassDefOverride(EventsPerBcCalibrator, 1);
+};
+} // namespace o2::ft0
+
+#endif
diff --git a/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx b/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
new file mode 100644
index 0000000000000..a2230f51dc4ea
--- /dev/null
+++ b/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
@@ -0,0 +1,81 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "FT0Calibration/EventsPerBcCalibrator.h"
+#include "CommonUtils/MemFileHelper.h"
+
+namespace o2::ft0
+{
+void EventsPerBcContainer::print() const
+{
+  LOG(info) << entries << " entries";
+}
+
+void EventsPerBcContainer::fill(const o2::dataformats::TFIDInfo& ti, const gsl::span<const o2::ft0::Digit> data)
+{
+  size_t oldEntries = entries;
+  for (const auto& digit : data) {
+    if (digit.mTriggers.getVertex() && digit.mTriggers.getAmplA() >= mMinAmplitudeSideA && digit.mTriggers.getAmplC() >= mMinAmplitudeSideC) {
+      mTvx[digit.mIntRecord.bc]++;
+      entries++;
+    }
+  }
+  LOG(debug) << "Container is filled with " << entries - oldEntries << " new events";
+}
+
+void EventsPerBcContainer::merge(const EventsPerBcContainer* prev)
+{
+  for (int bc = 0; bc < o2::constants::lhc::LHCMaxBunches; bc++) {
+    mTvx[bc] += prev->mTvx[bc];
+  }
+  entries += prev->entries;
+}
+
+void EventsPerBcCalibrator::initOutput()
+{
+  mTvxPerBcs.clear();
+  mTvxPerBcInfos.clear();
+}
+
+EventsPerBcCalibrator::EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinNumberOfEntries(minNumberOfEntries), mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC)
+{
+  LOG(info) << "Defined threshold for number of entires per slot: " << mMinNumberOfEntries;
+  LOG(info) << "Defined threshold for side A amplitude for event: " << mMinAmplitudeSideA;
+  LOG(info) << "Defined threshold for side C amplitude for event: " << mMinAmplitudeSideC;
+}
+
+bool EventsPerBcCalibrator::hasEnoughData(const EventsPerBcCalibrator::Slot& slot) const
+{
+  return slot.getContainer()->entries > mMinNumberOfEntries;
+}
+
+void EventsPerBcCalibrator::finalizeSlot(EventsPerBcCalibrator::Slot& slot)
+{
+  LOG(info) << "Finalizing slot from " << slot.getStartTimeMS() << " to " << slot.getEndTimeMS();
+  o2::ft0::EventsPerBcContainer* data = slot.getContainer();
+  mTvxPerBcs.emplace_back(data->mTvx);
+
+  auto clName = o2::utils::MemFileHelper::getClassName(mTvxPerBcs.back());
+  auto flName = o2::ccdb::CcdbApi::generateFileName(clName);
+
+  std::map<std::string, std::string> metaData;
+  mTvxPerBcInfos.emplace_back(std::make_unique<o2::ccdb::CcdbObjectInfo>("FT0/Calib/EventsPerBc", clName, flName, metaData, slot.getStartTimeMS(), slot.getEndTimeMS()));
+  LOG(info) << "Created object valid from " << mTvxPerBcInfos.back()->getStartValidityTimestamp() << " to " << mTvxPerBcInfos.back()->getEndValidityTimestamp();
+}
+
+EventsPerBcCalibrator::Slot& EventsPerBcCalibrator::emplaceNewSlot(bool front, TFType tstart, TFType tend)
+{
+  auto& cont = getSlots();
+  auto& slot = front ? cont.emplace_front(tstart, tend) : cont.emplace_back(tstart, tend);
+  slot.setContainer(std::make_unique<EventsPerBcContainer>(mMinAmplitudeSideA, mMinAmplitudeSideC));
+  return slot;
+}
+} // namespace o2::ft0
\ No newline at end of file
diff --git a/Detectors/FIT/FT0/calibration/src/FT0CalibrationLinkDef.h b/Detectors/FIT/FT0/calibration/src/FT0CalibrationLinkDef.h
index 49f72e8cbdfff..11b1ce25e9353 100644
--- a/Detectors/FIT/FT0/calibration/src/FT0CalibrationLinkDef.h
+++ b/Detectors/FIT/FT0/calibration/src/FT0CalibrationLinkDef.h
@@ -16,7 +16,9 @@
 #pragma link off all functions;
 
 #pragma link C++ class o2::ft0::FT0TimeOffsetSlotContainer + ;
+#pragma link C++ class o2::ft0::EventsPerBcCalibrator + ;
 #pragma link C++ class o2::calibration::TimeSlot < o2::ft0::FT0TimeOffsetSlotContainer>;
 #pragma link C++ class o2::calibration::TimeSlotCalibration < o2::ft0::FT0TimeOffsetSlotContainer>;
-
+#pragma link C++ class o2::calibration::TimeSlot < o2::ft0::EventsPerBcContainer> + ;
+#pragma link C++ class o2::calibration::TimeSlotCalibration < o2::ft0::EventsPerBcContainer> + ;
 #endif
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
new file mode 100644
index 0000000000000..ac7a8e52f53b1
--- /dev/null
+++ b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
@@ -0,0 +1,47 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "FT0EventsPerBcSpec.h"
+#include "Framework/Lifetime.h"
+#include <limits>
+
+o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& cfgc)
+{
+  using namespace o2::framework;
+  using o2::calibration::FT0EventsPerBcProcessor;
+  std::vector<InputSpec> inputs;
+  inputs.emplace_back("digits", "FT0", "DIGITSBC", Lifetime::Timeframe);
+  auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true,                           // orbitResetTime
+                                                                false,                          // GRPECS=true
+                                                                false,                          // GRPLHCIF
+                                                                false,                          // GRPMagField
+                                                                false,                          // askMatLUT
+                                                                o2::base::GRPGeomRequest::None, // geometry
+                                                                inputs);
+  std::vector<OutputSpec> outputs;
+  outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, "EventsPerBc"}, Lifetime::Timeframe);
+  outputs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, "EventsPerBc"}, Lifetime::Timeframe);
+  DataProcessorSpec dataProcessorSpec{
+    "FT0EventsPerBcProcessor",
+    inputs,
+    outputs,
+    AlgorithmSpec(adaptFromTask<FT0EventsPerBcProcessor>(ccdbRequest)),
+    Options{
+      {"slot-len-sec", VariantType::UInt32, 3600u, {"Duration of each slot in seconds"}},
+      {"one-object-per-run", VariantType::Bool, false, {"If set, workflow creates only one calibration object per run"}},
+      {"min-entries-number", VariantType::UInt32, 5000u, {"Minimum number of entries required for a slot to be valid"}},
+      {"min-ampl-side-a", VariantType::Int, 0, {"Amplitude threshold for Side A events"}},
+      {"min-ampl-side-c", VariantType::Int, 0, {"Amplitude threshold for Side C events"}}}};
+
+  WorkflowSpec workflow;
+  workflow.emplace_back(dataProcessorSpec);
+  return workflow;
+}
\ No newline at end of file
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
new file mode 100644
index 0000000000000..c587ab58fcd90
--- /dev/null
+++ b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
@@ -0,0 +1,124 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_CALIBRATION_FT0_EVENTS_PER_BC_CALIBRATOR_H
+#define O2_CALIBRATION_FT0_EVENTS_PER_BC_CALIBRATOR_H
+
+#include "Framework/runDataProcessing.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/ConfigParamSpec.h"
+#include <Framework/ConfigContext.h>
+#include "Framework/DeviceSpec.h"
+#include "Framework/WorkflowSpec.h"
+#include "Framework/Task.h"
+#include "DetectorsCalibration/Utils.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+
+#include "DataFormatsFT0/Digit.h"
+#include "FT0Calibration/EventsPerBcCalibrator.h"
+
+namespace o2::calibration
+{
+class FT0EventsPerBcProcessor final : public o2::framework::Task
+{
+ public:
+  FT0EventsPerBcProcessor(std::shared_ptr<o2::base::GRPGeomRequest> request) : mCCDBRequest(request) {}
+
+  void init(o2::framework::InitContext& ic) final
+  {
+    o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
+    if (ic.options().hasOption("slot-len-sec")) {
+      mSlotLenSec = ic.options().get<uint32_t>("slot-len-sec");
+    }
+    if (ic.options().hasOption("one-object-per-run")) {
+      mOneObjectPerRun = ic.options().get<bool>("one-object-per-run");
+    }
+    if (ic.options().hasOption("min-entries-number")) {
+      mMinNumberOfEntries = ic.options().get<uint32_t>("min-entries-number");
+    }
+    if (ic.options().hasOption("min-ampl-side-a")) {
+      mMinAmplitudeSideA = ic.options().get<int32_t>("min-ampl-side-a");
+    }
+    if (ic.options().hasOption("min-ampl-side-c")) {
+      mMinAmplitudeSideC = ic.options().get<int32_t>("min-ampl-side-c");
+    }
+
+    mCalibrator = std::make_unique<o2::ft0::EventsPerBcCalibrator>(mMinNumberOfEntries, mMinAmplitudeSideA, mMinAmplitudeSideC);
+
+    if (mOneObjectPerRun) {
+      LOG(info) << "Only one object will be created at the end of run";
+      mCalibrator->setUpdateAtTheEndOfRunOnly();
+    }
+    if (mOneObjectPerRun == false) {
+      LOG(info) << "Defined slot interval to " << mSlotLenSec << " seconds";
+      mCalibrator->setSlotLengthInSeconds(mSlotLenSec);
+    }
+  }
+
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
+  {
+    o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+    auto digits = pc.inputs().get<gsl::span<o2::ft0::Digit>>("digits");
+    o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
+    if (digits.size() == 0) {
+      return;
+    }
+    mCalibrator->process(digits);
+    if (mOneObjectPerRun == false) {
+      sendOutput(pc.outputs());
+    }
+  }
+
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final
+  {
+    LOG(info) << "Received end-of-stream, checking for slot to finalize...";
+    mCalibrator->checkSlotsToFinalize();
+    sendOutput(ec.outputs());
+    mCalibrator->initOutput();
+  }
+
+  void sendOutput(o2::framework::DataAllocator& output)
+  {
+    using o2::framework::Output;
+    const auto& tvxHists = mCalibrator->getTvxPerBc();
+    auto& infos = mCalibrator->getTvxPerBcCcdbInfo();
+    for (unsigned int idx = 0; idx < tvxHists.size(); idx++) {
+      auto& info = infos[idx];
+      const auto& payload = tvxHists[idx];
+
+      auto image = o2::ccdb::CcdbApi::createObjectImage(&payload, info.get());
+      LOG(info) << "Sending object " << info->getPath() << "/" << info->getFileName() << " of size " << image->size()
+                << " bytes, valid for " << info->getStartValidityTimestamp() << " : " << info->getEndValidityTimestamp();
+      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "EventsPerBc", idx}, *image.get());
+      output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "EventsPerBc", idx}, *info.get());
+    }
+
+    if (tvxHists.size()) {
+      mCalibrator->initOutput();
+    }
+  }
+
+ private:
+  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
+  std::unique_ptr<o2::ft0::EventsPerBcCalibrator> mCalibrator;
+  bool mOneObjectPerRun;
+  uint32_t mSlotLenSec;
+  uint32_t mMinNumberOfEntries;
+  int32_t mMinAmplitudeSideA;
+  int32_t mMinAmplitudeSideC;
+};
+} // namespace o2::calibration
+#endif
\ No newline at end of file
diff --git a/Detectors/FIT/FT0/macros/CMakeLists.txt b/Detectors/FIT/FT0/macros/CMakeLists.txt
index c4ed27d2513ba..17491ca4962c1 100644
--- a/Detectors/FIT/FT0/macros/CMakeLists.txt
+++ b/Detectors/FIT/FT0/macros/CMakeLists.txt
@@ -1,14 +1,21 @@
-# Copyright CERN and copyright holders of ALICE O2. This software is distributed
-# under the terms of the GNU General Public License v3 (GPL Version 3), copied
-# verbatim in the file "COPYING".
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
 #
-# See http://alice-o2.web.cern.ch/license for full licensing information.
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
 #
 # In applying this license CERN does not waive the privileges and immunities
-# granted to it by virtue of its status as an Intergovernmental Organization or
-# submit itself to any jurisdiction.
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
 
 o2_add_test_root_macro(FT0Misaligner.C
                        PUBLIC_LINK_LIBRARIES O2::CCDB
                        O2::FT0Simulation
                        LABELS ft0)
+
+o2_add_test_root_macro(FT0readEventsPerBc.C
+                       PUBLIC_LINK_LIBRARIES
+                       O2::CCDB
+                       O2::DataFormatsFT0
+                       LABELS ft0)
diff --git a/Detectors/FIT/FT0/macros/FT0readEventsPerBc.C b/Detectors/FIT/FT0/macros/FT0readEventsPerBc.C
new file mode 100644
index 0000000000000..c6afc86389b9b
--- /dev/null
+++ b/Detectors/FIT/FT0/macros/FT0readEventsPerBc.C
@@ -0,0 +1,52 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <iostream>
+#include <array>
+#endif
+
+#include "CCDB/CcdbApi.h"
+#include "CCDB/CCDBTimeStampUtils.h"
+#include "TH1F.h"
+#include "DataFormatsFT0/EventsPerBc.h"
+#include "Framework/Logger.h"
+#include "CommonConstants/LHCConstants.h"
+
+std::unique_ptr<TH1F> hist;
+std::unique_ptr<TCanvas> canvas;
+
+void FT0readEventsPerBc(std::string ccdbUrl, long timestamp)
+{
+  o2::ccdb::CcdbApi ccdbApi;
+  ccdbApi.init(ccdbUrl);
+  const std::string ccdbPath = "FT0/Calib/EventsPerBc";
+  std::map<std::string, std::string> metadata;
+
+  if (timestamp < 0) {
+    timestamp = o2::ccdb::getCurrentTimestamp();
+  }
+
+  std::unique_ptr<o2::ft0::EventsPerBc> events(ccdbApi.retrieveFromTFileAny<o2::ft0::EventsPerBc>(ccdbPath, metadata, timestamp));
+
+  if (!events) {
+    LOGP(fatal, "EventsPerBc object not found in {}/{} for timestamp {}.", ccdbUrl, ccdbPath, timestamp);
+    return;
+  }
+
+  hist = std::make_unique<TH1F>("eventsPerBcHist", "Events per BC", o2::constants::lhc::LHCMaxBunches, 0, o2::constants::lhc::LHCMaxBunches - 1);
+  for (int idx = 0; idx < o2::constants::lhc::LHCMaxBunches; idx++) {
+    hist->Fill(idx, events->histogram[idx]);
+  }
+  canvas = std::make_unique<TCanvas>();
+  hist->Draw();
+  canvas->Draw();
+}
\ No newline at end of file

From 8d3541adfc2ff3fb78615f86cc2a234eb8bd60a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 5 Feb 2026 23:27:12 +0100
Subject: [PATCH 1307/1764] Vertexing: Delete unused files

---
 .../DetectorsVertexing/FwdDCAFitterN.h        | 1297 -----------------
 Detectors/Vertexing/src/FwdDCAFitterN.cxx     |   33 -
 2 files changed, 1330 deletions(-)
 delete mode 100644 Detectors/Vertexing/include/DetectorsVertexing/FwdDCAFitterN.h
 delete mode 100644 Detectors/Vertexing/src/FwdDCAFitterN.cxx

diff --git a/Detectors/Vertexing/include/DetectorsVertexing/FwdDCAFitterN.h b/Detectors/Vertexing/include/DetectorsVertexing/FwdDCAFitterN.h
deleted file mode 100644
index d5bc6631575af..0000000000000
--- a/Detectors/Vertexing/include/DetectorsVertexing/FwdDCAFitterN.h
+++ /dev/null
@@ -1,1297 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file FwdDCAFitterN.h
-/// \brief Defintions for N-prongs secondary vertex fit
-/// \author ruben.shahoyan@cern.ch, adapted from central barrel to fwd rapidities by Rita Sadek, rita.sadek@cern.ch
-/// For the formulae derivation see /afs/cern.ch/user/s/shahoian/public/O2/DCAFitter/DCAFitterN.pdf
-
-#ifndef _ALICEO2_DCA_FWDFITTERN_
-#define _ALICEO2_DCA_FWDFITTERN_
-#include <TMath.h>
-#include "MathUtils/Cartesian.h"
-#include "ReconstructionDataFormats/TrackFwd.h"
-#include "ReconstructionDataFormats/Track.h"
-#include "ReconstructionDataFormats/HelixHelper.h"
-#include <TRandom.h>
-#include "DetectorsBase/Propagator.h"
-#include "DetectorsBase/GeometryManager.h"
-
-namespace o2
-{
-namespace vertexing
-{
-
-///__________________________________________________________________________________
-///< Fwd Inverse cov matrix (augmented by a dummy Z error) of the point defined by the track
-struct FwdTrackCovI {
-  float sxx, syy, sxy, szz;
-
-  FwdTrackCovI(const o2::track::TrackParCovFwd& trc, float zerrFactor = 1.) { set(trc, zerrFactor); }
-  FwdTrackCovI() = default;
-  void set(const o2::track::TrackParCovFwd& trc, float zerrFactor = 1)
-  {
-    float cxx = trc.getSigma2X(), cyy = trc.getSigma2Y(), cxy = trc.getSigmaXY(), czz = cyy * zerrFactor;
-    float detXY = cxx * cyy - cxy * cxy;
-    if (detXY > 0.) {
-      auto detXYI = 1. / detXY;
-      sxx = cyy * detXYI;
-      syy = cxx * detXYI;
-      sxy = -cxy * detXYI;
-      szz = 1. / czz;
-    } else {
-      throw std::runtime_error("invalid track covariance");
-    }
-  }
-};
-
-///__________________________________________________________________________
-///< Fwd derivative (up to 2) of the TrackParam position over its running param Z
-struct FwdTrackDeriv {
-  float dxdz, dydz, d2xdz2, d2ydz2;
-  FwdTrackDeriv() = default;
-  FwdTrackDeriv(const o2::track::TrackParFwd& trc, float bz) { set(trc, bz); }
-  void set(const o2::track::TrackParFwd& trc, float bz)
-  {
-    float snp = trc.getSnp(), csp = std::sqrt((1. - snp) * (1. + snp)), cspI = 1. / csp, crv2c = trc.getCurvature(bz), tgl = trc.getTanl(), tglI = 1. / tgl;
-    if (crv2c == 0.) {
-      crv2c = (trc.getCharge()) * 0.3 * bz * (-1e-3);
-    }
-
-    dxdz = csp * tglI;
-    dydz = snp * tglI;
-    d2xdz2 = crv2c * snp * tglI * tglI;
-    d2ydz2 = -crv2c * csp * tglI * tglI;
-  }
-};
-
-template <int N, typename... Args>
-class FwdDCAFitterN
-{
-  static constexpr double NMin = 2;
-  static constexpr double NMax = 4;
-  static constexpr double NInv = 1. / N;
-  static constexpr int MAXHYP = 2;
-  static constexpr float ZerrFactor = 5.; // factor for conversion of track covXX to dummy covZZ
-  using Track = o2::track::TrackParCovFwd;
-  using TrackAuxPar = o2::track::TrackAuxPar;
-  using CrossInfo = o2::track::CrossInfo;
-  using Vec3D = ROOT::Math::SVector<double, 3>;
-  using VecND = ROOT::Math::SVector<double, N>;
-  using MatSym3D = ROOT::Math::SMatrix<double, 3, 3, ROOT::Math::MatRepSym<double, 3>>;
-  using MatStd3D = ROOT::Math::SMatrix<double, 3, 3, ROOT::Math::MatRepStd<double, 3>>;
-  using MatSymND = ROOT::Math::SMatrix<double, N, N, ROOT::Math::MatRepSym<double, N>>;
-  using MatStdND = ROOT::Math::SMatrix<double, N, N, ROOT::Math::MatRepStd<double, N>>;
-  using SMatrix55 = ROOT::Math::SMatrix<double, 5, 5, ROOT::Math::MatRepSym<double, 5>>;
-  using TrackCoefVtx = MatStd3D;
-  using ArrTrack = std::array<Track, N>;            // container for prongs (tracks) at single vertex cand.
-  using ArrTrackCovI = std::array<FwdTrackCovI, N>; // container for inv.cov.matrices at single vertex cand.
-  using ArrTrCoef = std::array<TrackCoefVtx, N>;    // container of TrackCoefVtx coefficients at single vertex cand.
-  using ArrTrDer = std::array<FwdTrackDeriv, N>;    // container of Track 1st and 2nd derivative over their Z param
-  using ArrTrPos = std::array<Vec3D, N>;            // container of Track positions
-
- public:
-  static constexpr int getNProngs() { return N; }
-
-  FwdDCAFitterN() = default;
-  FwdDCAFitterN(float bz, bool useAbsDCA, bool prop2DCA) : mBz(bz), mUseAbsDCA(useAbsDCA), mPropagateToPCA(prop2DCA)
-  {
-    static_assert(N >= NMin && N <= NMax, "N prongs outside of allowed range");
-  }
-
-  //=========================================================================
-  ///< return PCA candidate, by default best on is provided (no check for the index validity)
-  const Vec3D& getPCACandidate(int cand = 0) const { return mPCA[mOrder[cand]]; }
-  const auto getPCACandidatePos(int cand = 0) const
-  {
-    const auto& vd = mPCA[mOrder[cand]];
-    return std::array<float, 3>{float(vd[0]), float(vd[1]), float(vd[2])};
-  }
-
-  ///< return Chi2 at PCA candidate (no check for its validity)
-  float getChi2AtPCACandidate(int cand = 0) const { return mChi2[mOrder[cand]]; }
-
-  ///< prepare copies of tracks at the V0 candidate (no check for the candidate validity)
-  ///  must be called before getTrack(i,cand) query
-  bool FwdpropagateTracksToVertex(int cand = 0);
-
-  ///< check if propagation of tracks to candidate vertex was done
-  bool isPropagateTracksToVertexDone(int cand = 0) const { return mTrPropDone[mOrder[cand]]; }
-
-  ///< track param propagated to V0 candidate (no check for the candidate validity)
-  ///  propagateTracksToVertex must be called in advance
-  Track& getTrack(int i, int cand = 0)
-  {
-    if (!mTrPropDone[mOrder[cand]]) {
-      throw std::runtime_error("propagateTracksToVertex was not called yet");
-    }
-    return mCandTr[mOrder[cand]][i];
-  }
-
-  ///< calculate on the fly track param (no cov mat) at candidate
-  o2::track::TrackParFwd FwdgetTrackParamAtPCA(int i, int cand = 0) const;
-
-  MatSym3D calcPCACovMatrix(int cand = 0) const;
-
-  std::array<float, 6> calcPCACovMatrixFlat(int cand = 0) const
-  {
-    auto m = calcPCACovMatrix(cand);
-    return {float(m(0, 0)), float(m(1, 0)), float(m(1, 1)), float(m(2, 0)), float(m(2, 1)), float(m(2, 2))};
-  }
-
-  const Track* getOrigTrackPtr(int i) const { return mOrigTrPtr[i]; }
-
-  ///< return number of iterations during minimization (no check for its validity)
-  int getNIterations(int cand = 0) const { return mNIters[mOrder[cand]]; }
-  void setPropagateToPCA(bool v = true) { mPropagateToPCA = v; }
-  void setMaxIter(int n = 60) { mMaxIter = n > 2 ? n : 2; }
-  void setMaxR(float r = 200.) { mMaxR2 = r * r; }
-  void setMaxDXIni(float d = 4.) { mMaxDXIni = d; }
-  void setMaxChi2(float chi2 = 999.) { mMaxChi2 = chi2; }
-  void setBz(float bz) { mBz = std::abs(bz) > o2::constants::math::Almost0 ? bz : 0.f; }
-  void setMinParamChange(float x = 1e-3) { mMinParamChange = x > 1e-4 ? x : 1.e-4; }
-  void setMinRelChi2Change(float r = 0.9) { mMinRelChi2Change = r > 0.1 ? r : 999.; }
-  void setUseAbsDCA(bool v) { mUseAbsDCA = v; }
-  void setMatLUT(const o2::base::MatLayerCylSet* m)
-  {
-    mMatLUT = m;
-    mUseMatBudget = true;
-  }
-  void setTGeoMat(bool v = true) { mTGeoFallBackAllowed = v; }
-  void setMaxDistance2ToMerge(float v) { mMaxDist2ToMergeSeeds = v; }
-
-  int getNCandidates() const { return mCurHyp; }
-  int getMaxIter() const { return mMaxIter; }
-  float getMaxR() const { return std::sqrt(mMaxR2); }
-  float getMaxDXIni() const { return mMaxDXIni; }
-  float getMaxChi2() const { return mMaxChi2; }
-  float getMinParamChange() const { return mMinParamChange; }
-  float getBz() const { return mBz; }
-  double getK(double b) const { return std::abs(o2::constants::math::B2C * b); }
-  double getHz(double b) const { return std::copysign(1, b); }
-
-  float getMaxDistance2ToMerge() const { return mMaxDist2ToMergeSeeds; }
-  bool getUseAbsDCA() const { return mUseAbsDCA; }
-  bool getPropagateToPCA() const { return mPropagateToPCA; }
-
-  template <class... Tr>
-  int process(const Tr&... args);
-  void print() const;
-
- protected:
-  bool FwdcalcPCACoefs();
-  bool FwdcalcInverseWeight();
-  void FwdcalcResidDerivatives();
-  void FwdcalcResidDerivativesNoErr();
-  void FwdcalcChi2Derivatives();
-  void FwdcalcChi2DerivativesNoErr();
-  void FwdcalcPCA();
-  void FwdcalcPCANoErr();
-  void FwdcalcTrackResiduals();
-  void calcTrackDerivatives();
-  float findZatXY(int cand = 0);
-  void findZatXY_mid(int cand = 0);
-  void findZatXY_lineApprox(int cand = 0);
-  void findZatXY_quad(int cand = 0);
-  void findZatXY_linear(int cand = 0);
-  double FwdcalcChi2() const;
-  double FwdcalcChi2NoErr() const;
-  bool FwdcorrectTracks(const VecND& corrZ);
-  bool minimizeChi2();
-  bool minimizeChi2NoErr();
-  bool roughDXCut() const;
-  bool closerToAlternative() const;
-  static double getAbsMax(const VecND& v);
-  bool propagateToVtx(o2::track::TrackParCovFwd& t, const std::array<float, 3>& p, const std::array<float, 2>& cov) const;
-
-  ///< track param positions at V0 candidate (no check for the candidate validity)
-  const Vec3D& getTrackPos(int i, int cand = 0) const { return mTrPos[mOrder[cand]][i]; }
-
-  ///< track Z-param at V0 candidate (no check for the candidate validity)
-  float getTrackZ(int i, int cand = 0) const { return getTrackPos(i, cand)[2]; }
-
-  MatStd3D getTrackRotMatrix(int i) const // generate 3D matrix for track rotation to global frame
-  // no rotation for fwd: mat=I
-  {
-    MatStd3D mat;
-    mat(0, 0) = 1;
-    mat(1, 1) = 1;
-    mat(2, 2) = 1;
-    return mat;
-  }
-
-  MatSym3D getTrackCovMatrix(int i, int cand = 0) const // generate covariance matrix of track position, adding fake Z error
-  {
-    const auto& trc = mCandTr[mOrder[cand]][i];
-    MatSym3D mat;
-    mat(0, 0) = trc.getSigma2X();
-    mat(1, 1) = trc.getSigma2Y();
-    mat(1, 0) = trc.getSigmaXY();
-    mat(2, 2) = trc.getSigma2Y() * ZerrFactor;
-    return mat;
-  }
-
-  void assign(int) {}
-  template <class T, class... Tr>
-  void assign(int i, const T& t, const Tr&... args)
-  {
-    static_assert(std::is_convertible<T, Track>(), "Wrong track type");
-    mOrigTrPtr[i] = &t;
-    assign(i + 1, args...);
-  }
-
-  void clear()
-  {
-    mCurHyp = 0;
-    mAllowAltPreference = true;
-  }
-
-  static void setTrackPos(Vec3D& pnt, const Track& tr)
-  {
-    pnt[0] = tr.getX();
-    pnt[1] = tr.getY();
-    pnt[2] = tr.getZ();
-  }
-
- private:
-  // vectors of 1st derivatives of track local residuals over Z parameters
-  std::array<std::array<Vec3D, N>, N> mDResidDz;
-  // vectors of 1nd derivatives of track local residuals over Z parameters
-  std::array<std::array<Vec3D, N>, N> mD2ResidDz2;
-  VecND mDChi2Dz;      // 1st derivatives of chi2 over tracks Z params
-  MatSymND mD2Chi2Dz2; // 2nd derivatives of chi2 over tracks Z params (symmetric matrix)
-
-  std::array<const Track*, N> mOrigTrPtr;
-  std::array<TrackAuxPar, N> mTrAux; // Aux track info for each track at each cand. vertex
-  CrossInfo mCrossings;              // info on track crossing
-
-  std::array<ArrTrackCovI, MAXHYP> mTrcEInv; // errors for each track at each cand. vertex
-  std::array<ArrTrack, MAXHYP> mCandTr;      // tracks at each cond. vertex (Note: Errors are at seed XY point)
-  std::array<ArrTrCoef, MAXHYP> mTrCFVT;     // TrackCoefVtx for each track at each cand. vertex
-  std::array<ArrTrDer, MAXHYP> mTrDer;       // Track derivativse
-  std::array<ArrTrPos, MAXHYP> mTrPos;       // Track positions
-  std::array<ArrTrPos, MAXHYP> mTrRes;       // Track residuals
-  std::array<Vec3D, MAXHYP> mPCA;            // PCA for each vertex candidate
-  std::array<float, MAXHYP> mChi2 = {0};     // Chi2 at PCA candidate
-  std::array<int, MAXHYP> mNIters;           // number of iterations for each seed
-  std::array<bool, MAXHYP> mTrPropDone;      // Flag that the tracks are fully propagated to PCA
-  MatSym3D mWeightInv;                       // inverse weight of single track, [sum{M^T E M}]^-1 in EQ.T
-  std::array<int, MAXHYP> mOrder{0};
-  int mCurHyp = 0;
-  int mCrossIDCur = 0;
-  int mCrossIDAlt = -1;
-  bool mAllowAltPreference = true;  // if the fit converges to alternative PCA seed, abandon the current one
-  bool mUseAbsDCA = false;          // use abs. distance minimization rather than chi2
-  bool mPropagateToPCA = true;      // create tracks version propagated to PCA
-  bool mUseMatBudget = false;       // include MCS effects in track propagation
-  bool mTGeoFallBackAllowed = true; // use TGeo for precise estimate of mat. budget
-  int mMaxIter = 60;                // max number of iterations
-  float mBz = 0;                    // bz field, to be set by user
-  float mMaxR2 = 200. * 200.;       // reject PCA's above this radius
-  float mMaxDXIni = 4.;             // reject (if>0) PCA candidate if tracks DZ exceeds threshold
-  float mMinParamChange = 1e-5;     // stop iterations if largest change of any X is smaller than this
-  float mMinRelChi2Change = 0.98;   // stop iterations is chi2/chi2old > this
-  float mMaxChi2 = 100;             // abs cut on chi2 or abs distance
-  float mMaxDist2ToMergeSeeds = 1.; // merge 2 seeds to their average if their distance^2 is below the threshold
-  const o2::base::MatLayerCylSet* mMatLUT = nullptr; // use to compute material budget to include MCS effects
-
-  ClassDefNV(FwdDCAFitterN, 1);
-};
-
-///_________________________________________________________________________
-template <int N, typename... Args>
-template <class... Tr>
-int FwdDCAFitterN<N, Args...>::process(const Tr&... args)
-{
-
-  static_assert(sizeof...(args) == N, "incorrect number of input tracks");
-  assign(0, args...);
-  clear();
-
-  for (int i = 0; i < N; i++) {
-    mTrAux[i].set(*mOrigTrPtr[i], mBz);
-  }
-
-  if (!mCrossings.set(mTrAux[0], *mOrigTrPtr[0], mTrAux[1], *mOrigTrPtr[1])) { // even for N>2 it should be enough to test just 1 loop
-    return 0;                                                                  // no crossing
-  }
-
-  if (mCrossings.nDCA == MAXHYP) { // if there are 2 candidates
-    auto dst2 = (mCrossings.xDCA[0] - mCrossings.xDCA[1]) * (mCrossings.xDCA[0] - mCrossings.xDCA[1]) +
-                (mCrossings.yDCA[0] - mCrossings.yDCA[1]) * (mCrossings.yDCA[0] - mCrossings.yDCA[1]);
-
-    if (dst2 < mMaxDist2ToMergeSeeds) {
-      mCrossings.nDCA = 1;
-      mCrossings.xDCA[0] = 0.5 * (mCrossings.xDCA[0] + mCrossings.xDCA[1]);
-      mCrossings.yDCA[0] = 0.5 * (mCrossings.yDCA[0] + mCrossings.yDCA[1]);
-    }
-  }
-
-  // check all crossings
-  for (int ic = 0; ic < mCrossings.nDCA; ic++) {
-    // check if radius is acceptable
-    if (mCrossings.xDCA[ic] * mCrossings.xDCA[ic] + mCrossings.yDCA[ic] * mCrossings.yDCA[ic] > mMaxR2) {
-      continue;
-    }
-
-    mCrossIDCur = ic;
-    mCrossIDAlt = (mCrossings.nDCA == 2 && mAllowAltPreference) ? 1 - ic : -1; // works for max 2 crossings
-    mNIters[mCurHyp] = 0;
-    mTrPropDone[mCurHyp] = false;
-    mChi2[mCurHyp] = -1.;
-
-    findZatXY_mid(mCurHyp);
-
-    if (mUseAbsDCA ? minimizeChi2NoErr() : minimizeChi2()) {
-      mOrder[mCurHyp] = mCurHyp;
-      if (mPropagateToPCA && !FwdpropagateTracksToVertex(mCurHyp)) {
-        continue;
-      }
-      mCurHyp++;
-    }
-  }
-
-  for (int i = mCurHyp; i--;) { // order in quality
-    for (int j = i; j--;) {
-      if (mChi2[mOrder[i]] < mChi2[mOrder[j]]) {
-        std::swap(mOrder[i], mOrder[j]);
-      }
-    }
-  }
-
-  return mCurHyp;
-}
-
-//__________________________________________________________________________
-template <int N, typename... Args>
-bool FwdDCAFitterN<N, Args...>::FwdcalcPCACoefs()
-{
-  //< calculate Ti matrices for global vertex decomposition to V = sum_{0<i<N} Ti pi, see EQ.T in the ref
-  if (!FwdcalcInverseWeight()) {
-    return false;
-  }
-  for (int i = N; i--;) { // build Mi*Ei matrix, with Mi = I
-    const auto& tcov = mTrcEInv[mCurHyp][i];
-    MatStd3D miei;
-
-    miei[0][0] = tcov.sxx;
-    miei[0][1] = tcov.sxy;
-    miei[1][0] = tcov.sxy;
-    miei[1][1] = tcov.syy;
-    miei[2][2] = tcov.szz;
-
-    mTrCFVT[mCurHyp][i] = mWeightInv * miei;
-  }
-  return true;
-}
-
-//__________________________________________________________________________
-template <int N, typename... Args>
-bool FwdDCAFitterN<N, Args...>::FwdcalcInverseWeight()
-{
-  //< calculate [sum_{0<j<N} M_j*E_j*M_j^T]^-1 used for Ti matrices, see EQ.T, with M_i = I
-  auto* arrmat = mWeightInv.Array();
-  memset(arrmat, 0, sizeof(mWeightInv));
-  enum { XX,
-         XY,
-         YY,
-         XZ,
-         YZ,
-         ZZ };
-  for (int i = N; i--;) {
-    const auto& tcov = mTrcEInv[mCurHyp][i];
-    arrmat[XX] += tcov.sxx;
-    arrmat[XY] += tcov.sxy;
-    arrmat[XZ] += 0;
-    arrmat[YY] += tcov.syy;
-    arrmat[YZ] += 0;
-    arrmat[ZZ] += tcov.szz;
-  }
-
-  // invert 3x3 symmetrix matrix
-  return mWeightInv.Invert();
-}
-
-//__________________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::FwdcalcResidDerivatives()
-{
-  //< calculate matrix of derivatives for weighted chi2: residual i vs parameter Z of track j
-  MatStd3D matMT;
-  for (int i = N; i--;) { // residual being differentiated
-    // const auto& taux = mTrAux[i];
-    for (int j = N; j--;) {                   // track over which we differentiate
-      const auto& matT = mTrCFVT[mCurHyp][j]; // coefficient matrix for track J
-      const auto& trDz = mTrDer[mCurHyp][j];  // track point derivs over track Z param
-      auto& dr1 = mDResidDz[i][j];
-      auto& dr2 = mD2ResidDz2[i][j];
-      // calculate M_i^transverse * T_j , M_i^transverse=I -> MT=T
-      matMT[0][0] = matT[0][0];
-      matMT[0][1] = matT[0][1];
-      matMT[0][2] = matT[0][2];
-      matMT[1][0] = matT[1][0];
-      matMT[1][1] = matT[1][1];
-      matMT[1][2] = matT[1][2];
-      matMT[2][0] = matT[2][0];
-      matMT[2][1] = matT[2][1];
-      matMT[2][2] = matT[2][2];
-
-      // calculate DResid_i/Dz_j = (delta_ij - M_i^tr * T_j) * DTrack_k/Dz_k
-      dr1[0] = -(matMT[0][0] * trDz.dxdz + matMT[0][1] * trDz.dydz + matMT[0][2]);
-      dr1[1] = -(matMT[1][0] * trDz.dxdz + matMT[1][1] * trDz.dydz + matMT[1][2]);
-      dr1[2] = -(matMT[2][0] * trDz.dxdz + matMT[2][1] * trDz.dydz + matMT[2][2]);
-
-      // calculate D2Resid_I/(Dz_J Dz_K) = (delta_ijk - M_i^tr * T_j * delta_jk) * D2Track_k/dz_k^2
-      dr2[0] = -(matMT[0][1] * trDz.d2ydz2 + matMT[0][0] * trDz.d2xdz2);
-      dr2[1] = -(matMT[1][1] * trDz.d2ydz2 + matMT[1][0] * trDz.d2xdz2);
-      dr2[2] = -(matMT[2][1] * trDz.d2ydz2 + matMT[2][0] * trDz.d2xdz2);
-
-      if (i == j) {
-        dr1[0] += trDz.dxdz;
-        dr1[1] += trDz.dydz;
-        dr1[2] += 1.;
-
-        dr2[0] += trDz.d2xdz2;
-        dr2[1] += trDz.d2ydz2;
-      }
-    } // track over which we differentiate
-  }   // residual being differentiated
-}
-
-//__________________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::FwdcalcResidDerivativesNoErr()
-{
-  //< calculate matrix of derivatives for absolute distance chi2: residual i vs parameter Z of track j
-  constexpr double NInv1 = 1. - NInv;       // profit from Rii = I/Ninv
-  for (int i = N; i--;) {                   // residual being differentiated
-    const auto& trDzi = mTrDer[mCurHyp][i]; // track point derivs over track Z param
-    auto& dr1ii = mDResidDz[i][i];
-    auto& dr2ii = mD2ResidDz2[i][i];
-
-    dr1ii[0] = NInv1 * trDzi.dxdz;
-    dr1ii[1] = NInv1 * trDzi.dydz;
-    dr1ii[2] = NInv1;
-
-    dr2ii[0] = NInv1 * trDzi.d2xdz2;
-    dr2ii[1] = NInv1 * trDzi.d2ydz2;
-    dr2ii[2] = 0;
-
-    for (int j = i; j--;) { // track over which we differentiate
-      auto& dr1ij = mDResidDz[i][j];
-      auto& dr1ji = mDResidDz[j][i];
-      const auto& trDzj = mTrDer[mCurHyp][j]; // track point derivs over track Z param
-
-      // calculate DResid_i/Dz_j = (delta_ij - R_ij) * DTrack_j/Dz_j  for j<i
-      dr1ij[0] = -trDzj.dxdz * NInv;
-      dr1ij[1] = -trDzj.dydz * NInv;
-      dr1ij[2] = -1 * NInv;
-
-      // calculate DResid_j/Dz_i = (delta_ij - R_ji) * DTrack_i/Dz_i  for j<i
-      dr1ji[0] = -trDzi.dxdz * NInv;
-      dr1ji[1] = -trDzi.dydz * NInv;
-      dr1ji[2] = -1 * NInv;
-
-      auto& dr2ij = mD2ResidDz2[i][j];
-      auto& dr2ji = mD2ResidDz2[j][i];
-
-      // calculate D2Resid_I/(Dz_J Dz_K) = (delta_ij - Rij) * D2Track_j/dz_j^2 * delta_jk for j<i
-      dr2ij[0] = -trDzj.d2xdz2 * NInv;
-      dr2ij[1] = -trDzj.d2ydz2 * NInv;
-      dr2ij[2] = 0;
-
-      // calculate D2Resid_j/(Dz_i Dz_k) = (delta_ij - Rji) * D2Track_i/dz_i^2 * delta_ik for j<i
-      dr2ji[0] = -trDzi.d2xdz2 * NInv;
-      dr2ji[1] = -trDzi.d2ydz2 * NInv;
-      dr2ji[2] = 0;
-
-    } // track over which we differentiate
-  }   // residual being differentiated
-}
-
-//__________________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::FwdcalcChi2Derivatives()
-{
-  //< calculate 1st and 2nd derivatives of wighted DCA (chi2) over track parameters Z
-  std::array<std::array<Vec3D, N>, N> covIDrDz; // tempory vectors of covI_j * dres_j/dz_i
-
-  // chi2 1st derivative
-  for (int i = N; i--;) {
-    auto& dchi1 = mDChi2Dz[i]; // DChi2/Dz_i = sum_j { res_j * covI_j * Dres_j/Dz_i }
-    dchi1 = 0;
-    for (int j = N; j--;) {
-      const auto& res = mTrRes[mCurHyp][j];    // vector of residuals of track j
-      const auto& covI = mTrcEInv[mCurHyp][j]; // inverse cov matrix of track j
-      const auto& dr1 = mDResidDz[j][i];       // vector of j-th residuals 1st derivative over Z param of track i
-      auto& cidr = covIDrDz[i][j];             // vector covI_j * dres_j/dz_i, save for 2nd derivative calculation
-      cidr[0] = covI.sxx * dr1[0] + covI.sxy * dr1[1];
-      cidr[1] = covI.sxy * dr1[0] + covI.syy * dr1[1];
-      cidr[2] = covI.szz * dr1[2];
-
-      dchi1 += ROOT::Math::Dot(res, cidr);
-    }
-  }
-
-  // chi2 2nd derivative
-  for (int i = N; i--;) {
-    for (int j = i + 1; j--;) {       // symmetric matrix
-      auto& dchi2 = mD2Chi2Dz2[i][j]; // D2Chi2/Dz_i/Dz_j = sum_k { Dres_k/Dz_j * covI_k * Dres_k/Dz_i + res_k * covI_k * D2res_k/Dz_i/Dz_j }
-      dchi2 = 0;
-      for (int k = N; k--;) {
-        const auto& dr1j = mDResidDz[k][j];  // vector of k-th residuals 1st derivative over Z param of track j
-        const auto& cidrkj = covIDrDz[i][k]; // vector covI_k * dres_k/dz_i
-        dchi2 += ROOT::Math::Dot(dr1j, cidrkj);
-        if (k == j) {
-          const auto& res = mTrRes[mCurHyp][k];    // vector of residuals of track k
-          const auto& covI = mTrcEInv[mCurHyp][k]; // inverse cov matrix of track k
-          const auto& dr2ij = mD2ResidDz2[k][j];   // vector of k-th residuals 2nd derivative over Z params of track j
-          dchi2 += res[0] * (covI.sxx * dr2ij[0] + covI.sxy * dr2ij[1]) + res[1] * (covI.sxy * dr2ij[0] + covI.syy * dr2ij[1]) + res[2] * covI.szz * dr2ij[2];
-        }
-      }
-    }
-  }
-}
-
-//__________________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::FwdcalcChi2DerivativesNoErr()
-{
-  //< calculate 1st and 2nd derivatives of abs DCA (chi2) over track parameters Z
-  for (int i = N; i--;) {
-    auto& dchi1 = mDChi2Dz[i]; // DChi2/Dz_i = sum_j { res_j * Dres_j/Dz_i }
-    dchi1 = 0;                 // chi2 1st derivative
-    for (int j = N; j--;) {
-      const auto& res = mTrRes[mCurHyp][j]; // vector of residuals of track j
-      const auto& dr1 = mDResidDz[j][i];    // vector of j-th residuals 1st derivative over Z param of track i
-      dchi1 += ROOT::Math::Dot(res, dr1);
-      if (i >= j) { // symmetrix matrix
-        // chi2 2nd derivative
-        auto& dchi2 = mD2Chi2Dz2[i][j]; // D2Chi2/Dz_i/Dz_j = sum_k { Dres_k/Dz_j * covI_k * Dres_k/Dz_i + res_k * covI_k * D2res_k/Dz_i/Dz_j }
-        dchi2 = ROOT::Math::Dot(mTrRes[mCurHyp][i], mD2ResidDz2[i][j]);
-        for (int k = N; k--;) {
-          dchi2 += ROOT::Math::Dot(mDResidDz[k][i], mDResidDz[k][j]);
-        }
-      }
-    }
-  }
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::FwdcalcPCA()
-{
-  // calculate point of closest approach for N prongs
-  // calculating V = sum (Ti*Pi)
-  mPCA[mCurHyp] = mTrCFVT[mCurHyp][N - 1] * mTrPos[mCurHyp][N - 1];
-  for (int i = N - 1; i--;) {
-    mPCA[mCurHyp] += mTrCFVT[mCurHyp][i] * mTrPos[mCurHyp][i];
-  }
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::FwdcalcPCANoErr()
-{
-  // calculate point of closest approach for N prongs w/o errors
-  auto& pca = mPCA[mCurHyp];
-
-  pca[0] = mTrPos[mCurHyp][N - 1][0];
-  pca[1] = mTrPos[mCurHyp][N - 1][1];
-  pca[2] = mTrPos[mCurHyp][N - 1][2];
-
-  for (int i = N - 1; i--;) {
-    pca[0] += mTrPos[mCurHyp][i][0];
-    pca[1] += mTrPos[mCurHyp][i][1];
-    pca[2] += mTrPos[mCurHyp][i][2];
-  }
-  pca[0] *= NInv;
-  pca[1] *= NInv;
-  pca[2] *= NInv;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-ROOT::Math::SMatrix<double, 3, 3, ROOT::Math::MatRepSym<double, 3>> FwdDCAFitterN<N, Args...>::calcPCACovMatrix(int cand) const
-{
-  // calculate covariance matrix for the point of closest approach
-  MatSym3D covm;
-  for (int i = N; i--;) {
-    covm += ROOT::Math::Similarity(mUseAbsDCA ? getTrackRotMatrix(i) : mTrCFVT[mOrder[cand]][i], getTrackCovMatrix(i, cand));
-  }
-  return covm;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::FwdcalcTrackResiduals()
-{
-  // calculate residuals, res = Pi - V
-  Vec3D vtxLoc;
-  for (int i = N; i--;) {
-    mTrRes[mCurHyp][i] = mTrPos[mCurHyp][i];
-    vtxLoc = mPCA[mCurHyp];
-    mTrRes[mCurHyp][i] -= vtxLoc;
-  }
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-inline void FwdDCAFitterN<N, Args...>::calcTrackDerivatives()
-{
-  // calculate track derivatives over Z param
-  for (int i = N; i--;) {
-    mTrDer[mCurHyp][i].set(mCandTr[mCurHyp][i], mBz);
-  }
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-inline double FwdDCAFitterN<N, Args...>::FwdcalcChi2() const
-{
-  // calculate current chi2
-  double chi2 = 0;
-  for (int i = N; i--;) {
-    const auto& res = mTrRes[mCurHyp][i];
-    const auto& covI = mTrcEInv[mCurHyp][i];
-    chi2 += res[0] * res[0] * covI.sxx + res[1] * res[1] * covI.syy + res[2] * res[2] * covI.szz + 2. * res[0] * res[1] * covI.sxy;
-  }
-  return chi2;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-inline double FwdDCAFitterN<N, Args...>::FwdcalcChi2NoErr() const
-{
-  // calculate current chi2 of abs. distance minimization
-  double chi2 = 0;
-  for (int i = N; i--;) {
-    const auto& res = mTrRes[mCurHyp][i];
-    chi2 += res[0] * res[0] + res[1] * res[1] + res[2] * res[2];
-  }
-  return chi2;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-bool FwdDCAFitterN<N, Args...>::FwdcorrectTracks(const VecND& corrZ)
-{
-  // propagate tracks to updated Z
-  for (int i = N; i--;) {
-    const auto& trDer = mTrDer[mCurHyp][i];
-    auto dz2h = 0.5 * corrZ[i] * corrZ[i];
-    mTrPos[mCurHyp][i][0] -= trDer.dxdz * corrZ[i] - dz2h * trDer.d2xdz2;
-    mTrPos[mCurHyp][i][1] -= trDer.dydz * corrZ[i] - dz2h * trDer.d2ydz2;
-    mTrPos[mCurHyp][i][2] -= corrZ[i];
-  }
-
-  return true;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-bool FwdDCAFitterN<N, Args...>::FwdpropagateTracksToVertex(int icand)
-{
-  // propagate on z axis to vertex
-  int ord = mOrder[icand];
-  if (mTrPropDone[ord]) {
-    return true;
-  }
-  const Vec3D& pca = mPCA[ord];
-  std::array<float, 6> covMatrixPCA = calcPCACovMatrixFlat(ord);
-  std::array<float, 2> cov = {covMatrixPCA[0], covMatrixPCA[2]};
-  for (int i = N; i--;) {
-    mCandTr[ord][i] = *mOrigTrPtr[i]; // fetch the track again, as mCandTr might have been propagated w/o errors
-    auto& trc = mCandTr[ord][i];
-    const std::array<float, 3> p = {(float)pca[0], (float)pca[1], (float)pca[2]};
-    if (!propagateToVtx(trc, p, cov)) {
-      return false;
-    }
-  }
-
-  mTrPropDone[ord] = true;
-  return true;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-float FwdDCAFitterN<N, Args...>::findZatXY(int mCurHyp) // Between 2 tracks
-{
-
-  double step = 0.001;     // initial step
-  double startPoint = 20.; // first MFT disk
-
-  double z[2] = {startPoint, startPoint};
-  double newX[2], newY[2];
-
-  double X = mPCA[mCurHyp][0]; // X seed
-  double Y = mPCA[mCurHyp][1]; // Y seed
-
-  mCandTr[mCurHyp][0] = *mOrigTrPtr[0];
-  mCandTr[mCurHyp][1] = *mOrigTrPtr[1];
-
-  double dstXY[2][3] = {{999., 999., 999.}, {999., 999., 999.}};
-
-  double Z[2];
-  double finalZ[2];
-
-  double newDstXY;
-
-  for (int i = 0; i < 2; i++) {
-
-    while (z[i] > -10) {
-
-      mCandTr[mCurHyp][i].propagateParamToZquadratic(z[i], mBz);
-      newX[i] = mCandTr[mCurHyp][i].getX();
-      newY[i] = mCandTr[mCurHyp][i].getY();
-
-      newDstXY = std::sqrt((newX[i] - X) * (newX[i] - X) +
-                           (newY[i] - Y) * (newY[i] - Y));
-
-      // Update points
-      dstXY[i][0] = dstXY[i][1];
-      dstXY[i][1] = dstXY[i][2];
-      dstXY[i][2] = newDstXY;
-
-      if (dstXY[i][2] > dstXY[i][1] && dstXY[i][1] < dstXY[i][0]) {
-        finalZ[i] = z[i] + step;
-        break;
-      }
-
-      z[i] -= step;
-    }
-  }
-
-  float rez = 0.5 * (finalZ[0] + finalZ[1]);
-  return rez;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::findZatXY_mid(int mCurHyp)
-{
-  // look into dXY of T0 - T1 between 2 points(0,40cm); the one with the highest dXY is moved to mid
-
-  double startPoint = -40.;
-  double endPoint = 50.;
-  double midPoint = 0.5 * (startPoint + endPoint);
-
-  double z[2][2] = {{startPoint, endPoint}, {startPoint, endPoint}}; // z for tracks 0/1 on starting poing and endpoint
-
-  double DeltaZ = std::abs(endPoint - startPoint);
-
-  double newX[2][2];
-  double newY[2][2];
-
-  double epsilon = 0.0001;
-
-  double X = mPCA[mCurHyp][0]; // X seed
-  double Y = mPCA[mCurHyp][1]; // Y seed
-
-  mCandTr[mCurHyp][0] = *mOrigTrPtr[0];
-  mCandTr[mCurHyp][1] = *mOrigTrPtr[1];
-
-  double finalZ;
-
-  double dstXY[2]; // 0 -> distance btwn both tracks at startPoint
-
-  while (DeltaZ > epsilon) {
-
-    midPoint = 0.5 * (startPoint + endPoint);
-
-    for (int i = 0; i < 2; i++) {
-      mCandTr[mCurHyp][i].propagateParamToZquadratic(startPoint, mBz);
-      newX[i][0] = mCandTr[mCurHyp][i].getX();
-      newY[i][0] = mCandTr[mCurHyp][i].getY();
-
-      mCandTr[mCurHyp][i].propagateParamToZquadratic(endPoint, mBz);
-      newX[i][1] = mCandTr[mCurHyp][i].getX();
-      newY[i][1] = mCandTr[mCurHyp][i].getY();
-    }
-
-    dstXY[0] = (newX[0][0] - newX[1][0]) * (newX[0][0] - newX[1][0]) +
-               (newY[0][0] - newY[1][0]) * (newY[0][0] - newY[1][0]);
-
-    dstXY[1] = (newX[0][1] - newX[1][1]) * (newX[0][1] - newX[1][1]) +
-               (newY[0][1] - newY[1][1]) * (newY[0][1] - newY[1][1]);
-
-    DeltaZ = std::abs(endPoint - startPoint);
-
-    if (DeltaZ < epsilon) {
-      finalZ = 0.5 * (startPoint + endPoint);
-      break;
-    }
-
-    // chose new start and end Point according to the smallest D_XY
-    if (dstXY[1] > dstXY[0]) {
-      endPoint = midPoint;
-    } else {
-      startPoint = midPoint;
-    }
-  }
-
-  mPCA[mCurHyp][2] = finalZ;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::findZatXY_lineApprox(int mCurHyp)
-{
-  // approx method: z=(b-b')/(a'-a) -> tracks to lines with y0,1=az0,1+b for each track (in YZ and XZ plane)
-
-  double startPoint = 1.;
-  double endPoint = 50.; // first disk
-
-  double X = mPCA[mCurHyp][0]; // X seed
-  double Y = mPCA[mCurHyp][1]; // Y seed
-
-  mCandTr[mCurHyp][0] = *mOrigTrPtr[0];
-  mCandTr[mCurHyp][1] = *mOrigTrPtr[1];
-
-  double y[2][2]; // Y00: y track 0 at point 0; Y01: y track 0 at point 1
-  double z[2][2];
-  double x[2][2];
-
-  double aYZ[2];
-  double bYZ[2];
-
-  double aXZ[2];
-  double bXZ[2];
-
-  double finalZ;
-
-  // find points of the tracks = 2 straight lines
-  for (int i = 0; i < 2; i++) {
-
-    mCandTr[mCurHyp][i].propagateToZquadratic(startPoint, mBz);
-    //  mCandTr[mCurHyp][i].propagateToZlinear(startPoint);
-    z[i][0] = startPoint;
-    y[i][0] = mCandTr[mCurHyp][i].getY();
-    x[i][0] = mCandTr[mCurHyp][i].getX();
-
-    mCandTr[mCurHyp][i].propagateToZquadratic(endPoint, mBz);
-    //  mCandTr[mCurHyp][i].propagateToZlinear(endPoint);
-    z[i][1] = endPoint;
-    y[i][1] = mCandTr[mCurHyp][i].getY();
-    x[i][1] = mCandTr[mCurHyp][i].getX();
-
-    bYZ[i] = (y[i][1] - y[i][0] * z[i][1] / z[i][0]) / (1 - z[i][1] / z[i][0]);
-    aYZ[i] = (y[i][0] - bYZ[i]) / z[i][0];
-
-    bXZ[i] = (x[i][1] - x[i][0] * z[i][1] / z[i][0]) / (1 - z[i][1] / z[i][0]);
-    aXZ[i] = (x[i][0] - bXZ[i]) / z[i][0];
-  }
-
-  // z seed: equ. for intersection of these lines
-  finalZ = 0.5 * ((bYZ[0] - bYZ[1]) / (aYZ[1] - aYZ[0]) + (bXZ[0] - bXZ[1]) / (aXZ[1] - aXZ[0]));
-
-  mPCA[mCurHyp][2] = finalZ;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::findZatXY_quad(int mCurHyp)
-{
-  double startPoint = 0.;
-  double endPoint = 40.; // first disk
-
-  double X = mPCA[mCurHyp][0]; // X seed
-  double Y = mPCA[mCurHyp][1]; // Y seed
-
-  mCandTr[mCurHyp][0] = *mOrigTrPtr[0];
-  mCandTr[mCurHyp][1] = *mOrigTrPtr[1];
-
-  double x[2];
-  double y[2];
-  double sinPhi0[2];
-  double cosPhi0[2];
-  double tanL0[2];
-  double qpt0[2];
-
-  double k[2];  // B2C *abs(mBz)
-  double Hz[2]; // mBz/abs(mBz)
-
-  double Ax[2], Bx[2], Cx[2];
-  double Ay[2], By[2], Cy[2];
-
-  double deltaX[2], deltaY[2];
-
-  bool posX[2], nulX[2], negX[2];
-  double z1X[2], z2X[2], z12X[2];
-
-  bool posY[2], nulY[2], negY[2];
-  double z1Y[2], z2Y[2], z12Y[2];
-
-  double finalZ[2];
-
-  // find all variables for 2 tracks at z0 = startPoint
-  // set A, B, C variables for x/y equation for 2 tracks
-  // calculate Deltax/y for both and roots
-
-  for (int i = 0; i < 2; i++) {
-    mCandTr[mCurHyp][i].propagateToZquadratic(startPoint, mBz);
-    x[i] = mCandTr[mCurHyp][i].getX();
-    y[i] = mCandTr[mCurHyp][i].getY();
-    sinPhi0[i] = mCandTr[mCurHyp][i].getSnp();
-    cosPhi0[i] = std::sqrt((1. - sinPhi0[i]) * (1. + sinPhi0[i]));
-    tanL0[i] = mCandTr[mCurHyp][i].getTanl();
-    qpt0[i] = mCandTr[mCurHyp][i].getInvQPt();
-    k[i] = getK(mBz);
-    Hz[i] = getHz(mBz);
-
-    Ax[i] = qpt0[i] * Hz[i] * k[i] * sinPhi0[i] / (2 * tanL0[i] * tanL0[i]);
-    Bx[i] = cosPhi0[i] / tanL0[i];
-    Cx[i] = x[i] - X;
-
-    Ay[i] = -qpt0[i] * Hz[i] * k[i] * cosPhi0[i] / (2 * tanL0[i] * tanL0[i]);
-    By[i] = sinPhi0[i] / tanL0[i];
-    Cy[i] = y[i] - Y; //
-
-    deltaX[i] = Bx[i] * Bx[i] - 4 * Ax[i] * Cx[i];
-    deltaY[i] = By[i] * By[i] - 4 * Ay[i] * Cy[i];
-
-    if (deltaX[i] > 0) {
-      posX[i] = true;
-      z1X[i] = (-Bx[i] - std::sqrt(deltaX[i])) / (2 * Ax[i]);
-      z2X[i] = (-Bx[i] + std::sqrt(deltaX[i])) / (2 * Ax[i]);
-    } else if (deltaX[i] == 0) {
-      nulX[i] = true;
-      z12X[i] = -Bx[i] / (2 * Ax[i]);
-    } else {
-      negX[i] = true;
-      z12X[i] = 0;
-    } // discard
-
-    if (deltaY[i] > 0) {
-      posY[i] = true;
-      z1Y[i] = (-By[i] - std::sqrt(deltaY[i])) / (2 * Ay[i]);
-      z2Y[i] = (-By[i] + std::sqrt(deltaY[i])) / (2 * Ay[i]);
-    } else if (deltaX[i] == 0) {
-      nulY[i] = true;
-      z12Y[i] = -By[i] / (2 * Ay[i]);
-    } else {
-      negY[i] = true;
-      z12Y[i] = 0;
-    }
-
-    // find the z located in an acceptable interval
-    if (posX[i]) {
-      if (z1X[i] < endPoint && z1X[i] > startPoint) {
-        z12X[i] = z1X[i];
-      } else {
-        z12X[i] = z2X[i];
-      }
-    }
-
-    if (posY[i]) {
-      if (z1Y[i] < endPoint && z1Y[i] > startPoint) {
-        z12Y[i] = z1Y[i];
-      } else {
-        z12Y[i] = z2Y[i];
-      }
-    }
-
-    finalZ[i] = 0.5 * (z12X[i] + z12Y[i]);
-  }
-
-  mPCA[mCurHyp][2] = 0.5 * (finalZ[0] + finalZ[1]);
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::findZatXY_linear(int mCurHyp)
-{
-
-  double startPoint = 0.;
-
-  double X = mPCA[mCurHyp][0]; // X seed
-  double Y = mPCA[mCurHyp][1]; // Y seed
-
-  mCandTr[mCurHyp][0] = *mOrigTrPtr[0];
-  mCandTr[mCurHyp][1] = *mOrigTrPtr[1];
-
-  double x[2];
-  double y[2];
-  double sinPhi0[2];
-  double cosPhi0[2];
-  double tanL0[2];
-
-  double Ax[2], Bx[2];
-  double Ay[2], By[2];
-
-  double z12X[2];
-  double z12Y[2];
-
-  double finalZ[2];
-
-  // find all variables for 2 tracks at z0 = startPoint
-  // set A, B variables for x/y equation for 2 tracks
-  // calculate root
-
-  for (int i = 0; i < 2; i++) {
-    mCandTr[mCurHyp][i].propagateToZlinear(startPoint);
-    x[i] = mCandTr[mCurHyp][i].getX();
-    y[i] = mCandTr[mCurHyp][i].getY();
-    sinPhi0[i] = mCandTr[mCurHyp][i].getSnp();
-    cosPhi0[i] = std::sqrt((1. - sinPhi0[i]) * (1. + sinPhi0[i]));
-    tanL0[i] = mCandTr[mCurHyp][i].getTanl();
-
-    Ax[i] = cosPhi0[i] / tanL0[i];
-    Bx[i] = x[i] - X;
-
-    Ay[i] = sinPhi0[i] / tanL0[i];
-    By[i] = y[i] - Y;
-
-    z12X[i] = -Bx[i] / Ax[i];
-    z12Y[i] = -By[i] / Ay[i];
-
-    finalZ[i] = 0.5 * (z12X[i] + z12Y[i]);
-  }
-
-  mPCA[mCurHyp][2] = 0.5 * (finalZ[0] + finalZ[1]);
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-inline o2::track::TrackParFwd FwdDCAFitterN<N, Args...>::FwdgetTrackParamAtPCA(int i, int icand) const
-{
-  // propagate tracks param only to current vertex (if not already done)
-  int ord = mOrder[icand];
-  o2::track::TrackParFwd trc(mCandTr[ord][i]);
-  if (!mTrPropDone[ord]) {
-    auto z = mPCA[ord][2];
-    trc.propagateParamToZquadratic(z, mBz);
-  }
-
-  return {trc};
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-inline double FwdDCAFitterN<N, Args...>::getAbsMax(const VecND& v)
-{
-  double mx = -1;
-  for (int i = N; i--;) {
-    auto vai = std::abs(v[i]);
-    if (mx < vai) {
-      mx = vai;
-    }
-  }
-  return mx;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-bool FwdDCAFitterN<N, Args...>::minimizeChi2()
-{
-  // find best chi2 (weighted DCA) of N tracks in the vicinity of the seed PCA
-  double x[2], y[2];
-  double sumX = 0.;
-  double sumY = 0.;
-
-  for (int i = N; i--;) {
-    mCandTr[mCurHyp][i] = *mOrigTrPtr[i];
-    auto z = mPCA[mCurHyp][2];
-
-    mCandTr[mCurHyp][i].propagateToZquadratic(z, mBz);
-
-    x[i] = mCandTr[mCurHyp][i].getX();
-    y[i] = mCandTr[mCurHyp][i].getY();
-
-    setTrackPos(mTrPos[mCurHyp][i], mCandTr[mCurHyp][i]);      // prepare positions
-    mTrcEInv[mCurHyp][i].set(mCandTr[mCurHyp][i], ZerrFactor); // prepare inverse cov.matrices at starting point
-
-    sumX = sumX + x[i];
-    sumY = sumY + y[i];
-  }
-
-  mPCA[mCurHyp][0] = sumX / N;
-  mPCA[mCurHyp][1] = sumY / N;
-
-  if (mMaxDXIni > 0 && !roughDXCut()) { // apply rough cut on tracks X difference
-    return false;
-  }
-
-  if (!FwdcalcPCACoefs()) { // prepare tracks contribution matrices to the global PCA
-    return false;
-  }
-  FwdcalcPCA();            // current PCA
-  FwdcalcTrackResiduals(); // current track residuals
-  float chi2Upd, chi2 = FwdcalcChi2();
-  do {
-    calcTrackDerivatives();    // current track derivatives (1st and 2nd)
-    FwdcalcResidDerivatives(); // current residals derivatives (1st and 2nd)
-    FwdcalcChi2Derivatives();  // current chi2 derivatives (1st and 2nd) to proceed for dz calculation
-
-    // do Newton-Rapson iteration with corrections = - dchi2/d{x0..xN} * [ d^2chi2/d{x0..xN}^2 ]^-1
-    if (!mD2Chi2Dz2.Invert()) {
-      return false;
-    }
-
-    VecND dz = mD2Chi2Dz2 * mDChi2Dz;
-
-    if (!FwdcorrectTracks(dz)) { // calculate new Pi (mTrPos) following Newton-Rapson iteration
-      return false;
-    }
-
-    FwdcalcPCA(); // updated mPCA (new V coordinates with new mTrPos (Pi))
-    if (mCrossIDAlt >= 0 && closerToAlternative()) {
-      mAllowAltPreference = false;
-      return false;
-    }
-
-    FwdcalcTrackResiduals(); // updated residuals
-    chi2Upd = FwdcalcChi2(); // updated chi2
-
-    if (getAbsMax(dz) < mMinParamChange || chi2Upd > chi2 * mMinRelChi2Change) {
-      chi2 = chi2Upd;
-      break; // converged
-    }
-
-    chi2 = chi2Upd;
-  } while (++mNIters[mCurHyp] < mMaxIter);
-
-  mChi2[mCurHyp] = chi2 * NInv;
-  return mChi2[mCurHyp] < mMaxChi2;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-bool FwdDCAFitterN<N, Args...>::minimizeChi2NoErr()
-{
-  // find best chi2 (absolute DCA) of N tracks in the vicinity of the PCA seed
-  double x[2], y[2];
-  double sumX = 0.;
-  double sumY = 0.;
-
-  for (int i = N; i--;) {
-
-    mCandTr[mCurHyp][i] = *mOrigTrPtr[i];
-
-    auto z = mPCA[mCurHyp][2];
-    mCandTr[mCurHyp][i].propagateParamToZquadratic(z, mBz);
-
-    x[i] = mCandTr[mCurHyp][i].getX();
-    y[i] = mCandTr[mCurHyp][i].getY();
-
-    mPCA[mCurHyp][2] = z;
-
-    setTrackPos(mTrPos[mCurHyp][i], mCandTr[mCurHyp][i]); // prepare positions
-
-    sumX = sumX + x[i];
-    sumY = sumY + y[i];
-  }
-
-  mPCA[mCurHyp][0] = sumX / N;
-  mPCA[mCurHyp][1] = sumY / N;
-
-  if (mMaxDXIni > 0 && !roughDXCut()) { // apply rough cut on tracks Z difference
-    return false;
-  }
-
-  FwdcalcPCANoErr();       // current PCA
-  FwdcalcTrackResiduals(); // current track residuals
-  float chi2Upd, chi2 = FwdcalcChi2NoErr();
-  do {
-    calcTrackDerivatives();         // current track derivatives (1st and 2nd)
-    FwdcalcResidDerivativesNoErr(); // current residals derivatives (1st and 2nd)
-    FwdcalcChi2DerivativesNoErr();  // current chi2 derivatives (1st and 2nd)
-
-    // do Newton-Rapson iteration with corrections = - dchi2/d{x0..xN} * [ d^2chi2/d{x0..xN}^2 ]^-1
-    if (!mD2Chi2Dz2.Invert()) {
-      return false;
-    }
-    VecND dz = mD2Chi2Dz2 * mDChi2Dz;
-
-    if (!FwdcorrectTracks(dz)) {
-      return false;
-    }
-    FwdcalcPCANoErr(); // updated PCA
-    if (mCrossIDAlt >= 0 && closerToAlternative()) {
-      mAllowAltPreference = false;
-      return false;
-    }
-    FwdcalcTrackResiduals();      // updated residuals
-    chi2Upd = FwdcalcChi2NoErr(); // updated chi2
-    if (getAbsMax(dz) < mMinParamChange || chi2Upd > chi2 * mMinRelChi2Change) {
-      chi2 = chi2Upd;
-      break; // converged
-    }
-    chi2 = chi2Upd;
-  } while (++mNIters[mCurHyp] < mMaxIter);
-  //
-  mChi2[mCurHyp] = chi2 * NInv;
-  return mChi2[mCurHyp] < mMaxChi2;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-bool FwdDCAFitterN<N, Args...>::roughDXCut() const
-{
-  // apply rough cut on DX between the tracks in the seed point
-
-  bool accept = true;
-  for (int i = N; accept && i--;) {
-    for (int j = i; j--;) {
-      if (std::abs(mCandTr[mCurHyp][i].getX() - mCandTr[mCurHyp][j].getX()) > mMaxDXIni) {
-        accept = false;
-        break;
-      }
-    }
-  }
-  return accept;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-bool FwdDCAFitterN<N, Args...>::closerToAlternative() const
-{
-  // check if the point current PCA point is closer to the seeding XY point being tested or to alternative see (if any)
-  auto dxCur = mPCA[mCurHyp][0] - mCrossings.xDCA[mCrossIDCur], dyCur = mPCA[mCurHyp][1] - mCrossings.yDCA[mCrossIDCur];
-  auto dxAlt = mPCA[mCurHyp][0] - mCrossings.xDCA[mCrossIDAlt], dyAlt = mPCA[mCurHyp][1] - mCrossings.yDCA[mCrossIDAlt];
-  return dxCur * dxCur + dyCur * dyCur > dxAlt * dxAlt + dyAlt * dyAlt;
-}
-
-//___________________________________________________________________
-template <int N, typename... Args>
-void FwdDCAFitterN<N, Args...>::print() const
-{
-  LOG(info) << N << "-prong vertex fitter in " << (mUseAbsDCA ? "abs." : "weighted") << " distance minimization mode";
-  LOG(info) << "Bz: " << mBz << " MaxIter: " << mMaxIter << " MaxChi2: " << mMaxChi2;
-  LOG(info) << "Stopping condition: Max.param change < " << mMinParamChange << " Rel.Chi2 change > " << mMinRelChi2Change;
-  LOG(info) << "Discard candidates for : Rvtx > " << getMaxR() << " DZ between tracks > " << mMaxDXIni;
-}
-//___________________________________________________________________
-template <int N, typename... Args>
-inline bool FwdDCAFitterN<N, Args...>::propagateToVtx(o2::track::TrackParCovFwd& t, const std::array<float, 3>& p, const std::array<float, 2>& cov) const
-{
-  // propagate track to vertex including MCS effects if material budget included, simple propagation to Z otherwise
-  float x2x0 = 0;
-  if (mUseMatBudget) {
-    auto mb = mMatLUT->getMatBudget(t.getX(), t.getY(), t.getZ(), p[0], p[1], p[2]);
-    x2x0 = (float)mb.meanX2X0;
-    return t.propagateToVtxhelixWithMCS(p[2], {p[0], p[1]}, cov, mBz, x2x0);
-  } else if (mTGeoFallBackAllowed) {
-    auto geoMan = o2::base::GeometryManager::meanMaterialBudget(t.getX(), t.getY(), t.getZ(), p[0], p[1], p[2]);
-    x2x0 = (float)geoMan.meanX2X0;
-    return t.propagateToVtxhelixWithMCS(p[2], {p[0], p[1]}, cov, mBz, x2x0);
-  } else {
-    t.propagateToZhelix(p[2], mBz);
-    return true;
-  }
-}
-
-using FwdDCAFitter2 = FwdDCAFitterN<2, o2::track::TrackParCovFwd>;
-using FwdDCAFitter3 = FwdDCAFitterN<3, o2::track::TrackParCovFwd>;
-
-} // namespace vertexing
-} // namespace o2
-#endif // _ALICEO2_DCA_FWDFITTERN_
diff --git a/Detectors/Vertexing/src/FwdDCAFitterN.cxx b/Detectors/Vertexing/src/FwdDCAFitterN.cxx
deleted file mode 100644
index f7176aa5039fd..0000000000000
--- a/Detectors/Vertexing/src/FwdDCAFitterN.cxx
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file DCAFitterN.cxx
-/// \brief Defintions for N-prongs secondary vertex fit
-/// \author ruben.shahoyan@cern.ch, adapted from central barrel to fwd rapidities by Rita Sadek, rita.sadek@cern.ch
-
-#include "DetectorsVertexing/FwdDCAFitterN.h"
-
-namespace o2
-{
-namespace vertexing
-{
-
-void __test_instance__()
-{
-  FwdDCAFitter2 ft2;
-  FwdDCAFitter3 ft3;
-  o2::track::TrackParCovFwd tr;
-  ft2.process(tr, tr);
-  ft3.process(tr, tr, tr);
-}
-
-} // namespace vertexing
-} // namespace o2

From 35c99fbf9c4a2c42e6cc220c119441ad22dfd059 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Wed, 11 Feb 2026 18:05:45 +0100
Subject: [PATCH 1308/1764] ITSMFT: Delete unused files (#15034)

---
 .../MFTCalibration/NoiseSlotCalibrator.h      |  101 -
 .../MFT/calibration/src/MchAlignment.cxx      | 1660 -----------------
 .../calibration/src/NoiseSlotCalibrator.cxx   |  145 --
 3 files changed, 1906 deletions(-)
 delete mode 100644 Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseSlotCalibrator.h
 delete mode 100644 Detectors/ITSMFT/MFT/calibration/src/MchAlignment.cxx
 delete mode 100644 Detectors/ITSMFT/MFT/calibration/src/NoiseSlotCalibrator.cxx

diff --git a/Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseSlotCalibrator.h b/Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseSlotCalibrator.h
deleted file mode 100644
index a8280467b14c9..0000000000000
--- a/Detectors/ITSMFT/MFT/calibration/include/MFTCalibration/NoiseSlotCalibrator.h
+++ /dev/null
@@ -1,101 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   NoiseSlotCalibrator.h
-
-#ifndef O2_MFT_NOISESLOTCALIBRATOR
-#define O2_MFT_NOISESLOTCALIBRATOR
-
-#include <string>
-
-#include "DetectorsCalibration/TimeSlotCalibration.h"
-#include "DetectorsCalibration/TimeSlot.h"
-
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "DataFormatsITSMFT/Digit.h"
-#include "DataFormatsITSMFT/NoiseMap.h"
-#include "gsl/span"
-
-namespace o2
-{
-
-namespace itsmft
-{
-class ROFRecord;
-} // namespace itsmft
-
-namespace mft
-{
-
-class NoiseSlotCalibrator : public o2::calibration::TimeSlotCalibration<o2::itsmft::NoiseMap>
-{
-  using Slot = calibration::TimeSlot<o2::itsmft::NoiseMap>;
-
- public:
-  NoiseSlotCalibrator() { setUpdateAtTheEndOfRunOnly(); }
-  NoiseSlotCalibrator(float prob, float relErr) : mProbabilityThreshold(prob), mProbRelErr(relErr)
-  {
-    setUpdateAtTheEndOfRunOnly();
-    setSlotLength(INFINITE_TF);
-    mMinROFs = 1.1 * o2::itsmft::NoiseMap::getMinROFs(prob, relErr);
-    LOGP(info, "At least {} ROFs needed to apply threshold {} with relative error {}", mMinROFs, mProbabilityThreshold, mProbRelErr);
-  }
-  ~NoiseSlotCalibrator() final = default;
-
-  void setThreshold(unsigned int t) { mThreshold = t; }
-
-  bool processTimeFrame(calibration::TFType tf,
-                        gsl::span<const o2::itsmft::Digit> const& digits,
-                        gsl::span<const o2::itsmft::ROFRecord> const& rofs);
-
-  bool processTimeFrame(calibration::TFType tf,
-                        gsl::span<const o2::itsmft::CompClusterExt> const& clusters,
-                        gsl::span<const unsigned char> const& patterns,
-                        gsl::span<const o2::itsmft::ROFRecord> const& rofs);
-
-  void setMinROFs(long n) { mMinROFs = n; }
-
-  void finalize()
-  {
-    LOG(info) << "Number of processed strobes is " << mNumberOfStrobes;
-    auto& slot = getSlots().back();
-    slot.getContainer()->applyProbThreshold(mProbabilityThreshold, mNumberOfStrobes);
-  }
-
-  const o2::itsmft::NoiseMap& getNoiseMap(long& start, long& end)
-  {
-    const auto& slot = getSlots().back();
-    start = slot.getTFStart();
-    end = slot.getTFEnd();
-    return *(slot.getContainer());
-  }
-
-  // Functions overloaded from the calibration framework
-  bool process(calibration::TFType tf, const gsl::span<const o2::itsmft::CompClusterExt> data) final;
-
-  // Functions required by the calibration framework
-  void initOutput() final {}
-  Slot& emplaceNewSlot(bool, calibration::TFType, calibration::TFType) final;
-  void finalizeSlot(Slot& slot) final;
-  bool hasEnoughData(const Slot& slot) const final;
-
- private:
-  float mProbabilityThreshold = 1e-6f;
-  float mProbRelErr = 0.2; // relative error on channel noise to apply the threshold
-  long mMinROFs = 0;
-  unsigned int mThreshold = 100;
-  unsigned int mNumberOfStrobes = 0;
-};
-
-} // namespace mft
-} // namespace o2
-
-#endif /* O2_MFT_NOISESLOTCALIBRATOR */
diff --git a/Detectors/ITSMFT/MFT/calibration/src/MchAlignment.cxx b/Detectors/ITSMFT/MFT/calibration/src/MchAlignment.cxx
deleted file mode 100644
index b9e590cca0b63..0000000000000
--- a/Detectors/ITSMFT/MFT/calibration/src/MchAlignment.cxx
+++ /dev/null
@@ -1,1660 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-//-----------------------------------------------------------------------------
-/// \file Alignment
-/// Alignment class for the ALICE DiMuon spectrometer
-///
-/// MUON specific alignment class which interface to AliMillepede.
-/// For each track ProcessTrack calculates the local and global derivatives
-/// at each cluster and fill the corresponding local equations. Provide methods
-/// for fixing or constraining detection elements for best results.
-///
-/// \author Javier Castillo Castellanos
-//-----------------------------------------------------------------------------
-
-#include "MCHAlign/Alignment.h"
-#include "MCHAlign/MillePede2.h"
-#include "MCHAlign/MillePedeRecord.h"
-#include <iostream>
-
-#include "MCHTracking/Track.h"
-#include "MCHTracking/TrackParam.h"
-#include "MCHTracking/Cluster.h"
-#include "TGeoManager.h"
-
-// #include "DataFormatsMCH/ROFRecord.h"
-// #include "DataFormatsMCH/TrackMCH.h"
-// #include "DataFormatsMCH/Cluster.h"
-// #include "DataFormatsMCH/Digit.h"
-
-// #include "AliMUONGeometryTransformer.h"
-// #include "AliMUONGeometryModuleTransformer.h"
-// #include "MCHAlign/AliMUONGeometryDetElement.h"
-// #include "AliMUONGeometryBuilder.h"
-#include "MCHGeometryCreator/Geometry.h"
-#include "MCHGeometryTest/Helpers.h"
-#include "MCHGeometryTransformer/Transformations.h"
-#include "TGeoManager.h"
-
-// #include "Align/Millepede2Record.h" //to be replaced
-// #include "AliMpExMap.h"
-// #include "AliMpExMapIterator.h"
-
-#include "DetectorsCommonDataFormats/AlignParam.h"
-#include "Framework/Logger.h"
-
-#include <TMath.h>
-#include <TMatrixDSym.h>
-#include <TMatrixD.h>
-#include <TClonesArray.h>
-#include <TGraphErrors.h>
-#include <TObject.h>
-
-namespace o2
-{
-namespace mch
-{
-
-using namespace std;
-
-//_____________________________________________________________________
-// static variables
-const Int_t Alignment::fgNDetElemCh[Alignment::fgNCh] = {4, 4, 4, 4, 18, 18, 26, 26, 26, 26};
-const Int_t Alignment::fgSNDetElemCh[Alignment::fgNCh + 1] = {0, 4, 8, 12, 16, 34, 52, 78, 104, 130, 156};
-
-// number of detector elements in each half-chamber
-const Int_t Alignment::fgNDetElemHalfCh[Alignment::fgNHalfCh] = {2, 2, 2, 2, 2, 2, 2, 2, 9, 9, 9, 9, 13, 13, 13, 13, 13, 13, 13, 13};
-
-// list of detector elements for each half chamber
-const Int_t Alignment::fgDetElemHalfCh[Alignment::fgNHalfCh][Alignment::fgNDetHalfChMax] =
-  {
-    {100, 103, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {101, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-
-    {200, 203, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {201, 202, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-
-    {300, 303, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {301, 302, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-
-    {400, 403, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-    {401, 402, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
-
-    {500, 501, 502, 503, 504, 514, 515, 516, 517, 0, 0, 0, 0},
-    {505, 506, 507, 508, 509, 510, 511, 512, 513, 0, 0, 0, 0},
-
-    {600, 601, 602, 603, 604, 614, 615, 616, 617, 0, 0, 0, 0},
-    {605, 606, 607, 608, 609, 610, 611, 612, 613, 0, 0, 0, 0},
-
-    {700, 701, 702, 703, 704, 705, 706, 720, 721, 722, 723, 724, 725},
-    {707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719},
-
-    {800, 801, 802, 803, 804, 805, 806, 820, 821, 822, 823, 824, 825},
-    {807, 808, 809, 810, 811, 812, 813, 814, 815, 816, 817, 818, 819},
-
-    {900, 901, 902, 903, 904, 905, 906, 920, 921, 922, 923, 924, 925},
-    {907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919},
-
-    {1000, 1001, 1002, 1003, 1004, 1005, 1006, 1020, 1021, 1022, 1023, 1024, 1025},
-    {1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019}
-
-};
-
-//_____________________________________________________________________
-/// self initialized array, used for adding constraints
-class Array
-{
-
- public:
-  /// contructor
-  Array(void)
-  {
-    for (Int_t i = 0; i < Alignment::fNGlobal; ++i) {
-      values[i] = 0;
-    }
-  }
-
-  /// array
-  Double_t values[Alignment::fNGlobal];
-
- private:
-  /// Not implemented
-  Array(const Array&);
-
-  /// Not implemented
-  Array& operator=(const Array&);
-};
-
-//________________________________________________________________________
-Double_t Square(Double_t x) { return x * x; }
-
-//_____________________________________________________________________
-Alignment::Alignment()
-  : TObject(),
-    fInitialized(kFALSE),
-    fRunNumber(0),
-    fBFieldOn(kFALSE),
-    fRefitStraightTracks(kFALSE),
-    fStartFac(256),
-    fResCutInitial(100),
-    fResCut(100),
-    fMillepede(0L), // to be modified
-    fCluster(0L),
-    fNStdDev(3),
-    fDetElemNumber(0),
-    fTrackRecord(),
-    fTransformCreator(),
-    fGeoCombiTransInverse(),
-    fDoEvaluation(kFALSE),
-    fTrackParamOrig(0),
-    fTrackParamNew(0),
-    fTFile(0),
-    fTTree(0)
-{
-  /// constructor
-  fSigma[0] = 1.5e-1;
-  fSigma[1] = 1.0e-2;
-
-  // default allowed variations
-  fAllowVar[0] = 0.5;  // x
-  fAllowVar[1] = 0.5;  // y
-  fAllowVar[2] = 0.01; // phi_z
-  fAllowVar[3] = 5;    // z
-
-  // initialize millepede
-  fMillepede = new MillePede2();
-  // fMillepede = new o2::align::Mille("theMilleFile.txt"); // To be replaced by MillePede2
-
-  // initialize degrees of freedom
-  // by default all parameters are free
-  for (Int_t iPar = 0; iPar < fNGlobal; ++iPar) {
-    fGlobalParameterStatus[iPar] = kFreeParId;
-  }
-
-  // initialize local equations
-  for (int i = 0; i < fNLocal; ++i) {
-    fLocalDerivatives[i] = 0.0;
-  }
-
-  for (int i = 0; i < fNGlobal; ++i) {
-    fGlobalDerivatives[i] = 0.0;
-  }
-}
-
-//_____________________________________________________________________
-// Alignment::~Alignment()
-//{
-//  /// destructor
-//}
-// Alignment::~Alignment() = default;
-//_____________________________________________________________________
-void Alignment::init(void)
-{
-
-  /// initialize
-  /**
-  initialize millipede
-  must be called after necessary detectors have been fixed,
-  but before constrains are added and before global parameters initial value are set
-  */
-  if (fInitialized) {
-    LOG(fatal) << "Millepede already initialized";
-  }
-
-  // assign proper groupID to free parameters
-  Int_t nGlobal = 0;
-  for (Int_t iPar = 0; iPar < fNGlobal; ++iPar) {
-
-    if (fGlobalParameterStatus[iPar] == kFixedParId) {
-      // fixed parameters are left unchanged
-      continue;
-
-    } else if (fGlobalParameterStatus[iPar] == kFreeParId || fGlobalParameterStatus[iPar] == kGroupBaseId) {
-
-      // free parameters or first element of group are assigned a new group id
-      fGlobalParameterStatus[iPar] = nGlobal++;
-      continue;
-
-    } else if (fGlobalParameterStatus[iPar] < kGroupBaseId) {
-
-      // get detector element id from status, get chamber parameter id
-      const Int_t iDeBase(kGroupBaseId - 1 - fGlobalParameterStatus[iPar]);
-      const Int_t iParBase = iPar % fgNParCh;
-
-      // check
-      if (iDeBase < 0 || iDeBase >= iPar / fgNParCh) {
-        LOG(fatal) << "Group for parameter index " << iPar << " has wrong base detector element: " << iDeBase;
-      }
-
-      // assign identical group id to current
-      fGlobalParameterStatus[iPar] = fGlobalParameterStatus[iDeBase * fgNParCh + iParBase];
-      LOG(info) << "Parameter " << iPar << " grouped to detector " << iDeBase << " (" << GetParameterMaskString(1 << iParBase).Data() << ")";
-
-    } else
-      LOG(fatal) << "Unrecognized parameter status for index " << iPar << ": " << fGlobalParameterStatus[iPar];
-  }
-
-  LOG(info) << "Free Parameters: " << nGlobal << " out of " << fNGlobal;
-
-  // initialize millepede
-  // fMillepede->InitMille(fNGlobal, fNLocal, fNStdDev, fResCut, fResCutInitial, fGlobalParameterStatus);
-  fMillepede->InitMille(fNGlobal, fNLocal, fNStdDev, fResCut, fResCutInitial); // MillePede2 implementation
-
-  fInitialized = kTRUE;
-
-  // some debug output
-  for (Int_t iPar = 0; iPar < fgNParCh; ++iPar) {
-    LOG(info) << "fAllowVar[" << iPar << "]= " << fAllowVar[iPar];
-  }
-
-  // set allowed variations for all parameters
-  for (Int_t iDet = 0; iDet < fgNDetElem; ++iDet) {
-    for (Int_t iPar = 0; iPar < fgNParCh; ++iPar) {
-      fMillepede->SetParSigma(iDet * fgNParCh + iPar, fAllowVar[iPar]);
-    }
-  }
-
-  // Set iterations
-  if (fStartFac > 1) {
-    fMillepede->SetIterations(fStartFac);
-  }
-  // setup monitoring TFile
-  if (fDoEvaluation && fRefitStraightTracks) {
-    fTFile = new TFile("Alignment.root", "RECREATE");
-    fTTree = new TTree("TreeE", "Evaluation");
-
-    const Int_t kSplitlevel = 98;
-    const Int_t kBufsize = 32000;
-
-    fTrackParamOrig = new LocalTrackParam();
-    fTTree->Branch("fTrackParamOrig", "LocalTrackParam", &fTrackParamOrig, kBufsize, kSplitlevel);
-
-    fTrackParamNew = new LocalTrackParam();
-    fTTree->Branch("fTrackParamNew", "LocalTrackParam", &fTrackParamNew, kBufsize, kSplitlevel);
-  }
-}
-
-//_____________________________________________________
-void Alignment::terminate(void)
-{
-  LOG(info) << "Closing Evaluation TFile";
-  if (fTFile && fTTree) {
-    fTFile->cd();
-    fTTree->Write();
-    fTFile->Close();
-  }
-}
-
-//_____________________________________________________
-MillePedeRecord* Alignment::ProcessTrack(Track& track, Bool_t doAlignment, Double_t weight)
-{
-  /// process track for alignment minimization
-  /**
-  returns the alignment records for this track.
-  They can be stored in some output for later reprocessing.
-  */
-
-  // reset track records
-  fTrackRecord.Reset();
-  if (fMillepede->GetRecord()) {
-    fMillepede->GetRecord()->Reset();
-  }
-
-  // loop over clusters to get starting values
-  Bool_t first(kTRUE);
-  // if (!trackParam)
-  // continue;
-  for (auto itTrackParam(track.begin()); itTrackParam != track.end(); ++itTrackParam) {
-
-    // get cluster
-    const Cluster* Cluster = itTrackParam->getClusterPtr();
-    if (!cluster)
-      continue;
-
-    // for first valid cluster, save track position as "starting" values
-    if (first) {
-
-      first = kFALSE;
-      FillTrackParamData(&*itTrackParam);
-      fTrackPos0[0] = fTrackPos[0];
-      fTrackPos0[1] = fTrackPos[1];
-      fTrackPos0[2] = fTrackPos[2];
-      fTrackSlope0[0] = fTrackSlope[0];
-      fTrackSlope0[1] = fTrackSlope[1];
-
-      break;
-    }
-  }
-
-  // redo straight track fit
-  if (fRefitStraightTracks) {
-
-    // refit straight track
-    const LocalTrackParam trackParam(RefitStraightTrack(track, fTrackPos0[2]));
-
-    // fill evaluation tree
-    if (fTrackParamOrig) {
-      fTrackParamOrig->fTrackX = fTrackPos0[0];
-      fTrackParamOrig->fTrackY = fTrackPos0[1];
-      fTrackParamOrig->fTrackZ = fTrackPos0[2];
-      fTrackParamOrig->fTrackSlopeX = fTrackSlope[0];
-      fTrackParamOrig->fTrackSlopeY = fTrackSlope[1];
-    }
-
-    // new ones
-    if (fTrackParamNew) {
-      fTrackParamNew->fTrackX = trackParam.fTrackX;
-      fTrackParamNew->fTrackY = trackParam.fTrackY;
-      fTrackParamNew->fTrackZ = trackParam.fTrackZ;
-      fTrackParamNew->fTrackSlopeX = trackParam.fTrackSlopeX;
-      fTrackParamNew->fTrackSlopeY = trackParam.fTrackSlopeY;
-    }
-
-    if (fTTree)
-      fTTree->Fill();
-
-    /*
-    copy new parameters to stored ones for derivatives calculation
-    this is done only if BFieldOn is false, for which these parameters are used
-    */
-    if (!fBFieldOn) {
-      fTrackPos0[0] = trackParam.fTrackX;
-      fTrackPos0[1] = trackParam.fTrackY;
-      fTrackPos0[2] = trackParam.fTrackZ;
-      fTrackSlope[0] = trackParam.fTrackSlopeX;
-      fTrackSlope[1] = trackParam.fTrackSlopeY;
-    }
-  }
-
-  // second loop to perform alignment
-  for (auto itTrackParam(track.begin()); itTrackParam != track.end(); ++itTrackParam) {
-
-    // get track parameters
-    if (!&*itTrackParam)
-      continue;
-
-    // get cluster
-    const Cluster* cluster = itTrackParam->getClusterPtr();
-    if (!cluster)
-      continue;
-
-    // fill local variables for this position --> one measurement
-    FillDetElemData(cluster);
-    FillRecPointData(cluster);
-    FillTrackParamData(&*itTrackParam);
-
-    // 'inverse' (GlobalToLocal) rotation matrix
-    const Double_t* r(fGeoCombiTransInverse.GetRotationMatrix());
-
-    // calculate measurements
-    if (fBFieldOn) {
-
-      // use residuals (cluster - track) for measurement
-      fMeas[0] = r[0] * (fClustPos[0] - fTrackPos[0]) + r[1] * (fClustPos[1] - fTrackPos[1]);
-      fMeas[1] = r[3] * (fClustPos[0] - fTrackPos[0]) + r[4] * (fClustPos[1] - fTrackPos[1]);
-
-    } else {
-
-      // use cluster position for measurement
-      fMeas[0] = (r[0] * fClustPos[0] + r[1] * fClustPos[1]);
-      fMeas[1] = (r[3] * fClustPos[0] + r[4] * fClustPos[1]);
-    }
-
-    // Set local equations
-    LocalEquationX();
-    LocalEquationY();
-  }
-
-  // copy track record
-  fMillepede->SetRecordRun(fRunNumber);
-  fMillepede->SetRecordWeight(weight);
-  fTrackRecord = *fMillepede->GetRecord();
-
-  // save record data
-  if (doAlignment) {
-    fMillepede->SaveRecordData();
-    fMillepede->CloseDataRecStorage();
-  }
-
-  // return record
-  return &fTrackRecord;
-}
-
-//______________________________________________________________________________
-void Alignment::ProcessTrack(MillePedeRecord* trackRecord)
-{
-  LOG(fatal) << __PRETTY_FUNCTION__ << " is disabled";
-
-  /// process track record
-  if (!trackRecord)
-    return;
-
-  // // make sure record storage is initialized
-  if (!fMillepede->GetRecord()) {
-    fMillepede->InitDataRecStorage(kFalse);
-  }
-  // // copy content
-  *fMillepede->GetRecord() = *trackRecord;
-
-  // save record
-  fMillepede->SaveRecordData();
-  // write to local file
-  fMillepede->CloseDataRecStorage();
-
-  return;
-}
-
-//_____________________________________________________________________
-void Alignment::FixAll(UInt_t mask)
-{
-  /// fix parameters matching mask, for all chambers
-  LOG(info) << "Fixing " << GetParameterMaskString(mask).Data() << " for all detector elements";
-
-  // fix all stations
-  for (Int_t i = 0; i < fgNDetElem; ++i) {
-    if (mask & ParX)
-      FixParameter(i, 0);
-    if (mask & ParY)
-      FixParameter(i, 1);
-    if (mask & ParTZ)
-      FixParameter(i, 2);
-    if (mask & ParZ)
-      FixParameter(i, 3);
-  }
-}
-
-//_____________________________________________________________________
-void Alignment::FixChamber(Int_t iCh, UInt_t mask)
-{
-  /// fix parameters matching mask, for all detector elements in a given chamber, counting from 1
-
-  // check boundaries
-  if (iCh < 1 || iCh > 10) {
-    LOG(fatal) << "Invalid chamber index " << iCh;
-  }
-
-  // get first and last element
-  const Int_t iDetElemFirst = fgSNDetElemCh[iCh - 1];
-  const Int_t iDetElemLast = fgSNDetElemCh[iCh];
-  for (Int_t i = iDetElemFirst; i < iDetElemLast; ++i) {
-
-    LOG(info) << "Fixing " << GetParameterMaskString(mask).Data() << " for detector element " << i;
-
-    if (mask & ParX)
-      FixParameter(i, 0);
-    if (mask & ParY)
-      FixParameter(i, 1);
-    if (mask & ParTZ)
-      FixParameter(i, 2);
-    if (mask & ParZ)
-      FixParameter(i, 3);
-  }
-}
-
-//_____________________________________________________________________
-void Alignment::FixDetElem(Int_t iDetElemId, UInt_t mask)
-{
-  /// fix parameters matching mask, for a given detector element, counting from 0
-  const Int_t iDet(GetDetElemNumber(iDetElemId));
-  if (mask & ParX)
-    FixParameter(iDet, 0);
-  if (mask & ParY)
-    FixParameter(iDet, 1);
-  if (mask & ParTZ)
-    FixParameter(iDet, 2);
-  if (mask & ParZ)
-    FixParameter(iDet, 3);
-}
-
-//_____________________________________________________________________
-void Alignment::FixHalfSpectrometer(const Bool_t* lChOnOff, UInt_t sidesMask, UInt_t mask)
-{
-
-  /// Fix parameters matching mask for all detectors in selected chambers and selected sides of the spectrometer
-  for (Int_t i = 0; i < fgNDetElem; ++i) {
-
-    // get chamber matching detector
-    const Int_t iCh(GetChamberId(i));
-    if (!lChOnOff[iCh - 1])
-      continue;
-
-    // get detector element in chamber
-    Int_t lDetElemNumber = i - fgSNDetElemCh[iCh - 1];
-
-    // skip detector if its side is off
-    // stations 1 and 2
-    if (iCh >= 1 && iCh <= 4) {
-      if (lDetElemNumber == 0 && !(sidesMask & SideTopRight))
-        continue;
-      if (lDetElemNumber == 1 && !(sidesMask & SideTopLeft))
-        continue;
-      if (lDetElemNumber == 2 && !(sidesMask & SideBottomLeft))
-        continue;
-      if (lDetElemNumber == 3 && !(sidesMask & SideBottomRight))
-        continue;
-    }
-
-    // station 3
-    if (iCh >= 5 && iCh <= 6) {
-      if (lDetElemNumber >= 0 && lDetElemNumber <= 4 && !(sidesMask & SideTopRight))
-        continue;
-      if (lDetElemNumber >= 5 && lDetElemNumber <= 10 && !(sidesMask & SideTopLeft))
-        continue;
-      if (lDetElemNumber >= 11 && lDetElemNumber <= 13 && !(sidesMask & SideBottomLeft))
-        continue;
-      if (lDetElemNumber >= 14 && lDetElemNumber <= 17 && !(sidesMask & SideBottomRight))
-        continue;
-    }
-
-    // stations 4 and 5
-    if (iCh >= 7 && iCh <= 10) {
-      if (lDetElemNumber >= 0 && lDetElemNumber <= 6 && !(sidesMask & SideTopRight))
-        continue;
-      if (lDetElemNumber >= 7 && lDetElemNumber <= 13 && !(sidesMask & SideTopLeft))
-        continue;
-      if (lDetElemNumber >= 14 && lDetElemNumber <= 19 && !(sidesMask & SideBottomLeft))
-        continue;
-      if (lDetElemNumber >= 20 && lDetElemNumber <= 25 && !(sidesMask & SideBottomRight))
-        continue;
-    }
-
-    // detector is accepted, fix it
-    FixDetElem(i, mask);
-  }
-}
-
-//______________________________________________________________________
-void Alignment::FixParameter(Int_t iPar)
-{
-
-  /// fix a given parameter, counting from 0
-  if (fInitialized) {
-    LOG(fatal) << "Millepede already initialized";
-  }
-
-  fGlobalParameterStatus[iPar] = kFixedParId;
-}
-
-//_____________________________________________________________________
-void Alignment::ReleaseChamber(Int_t iCh, UInt_t mask)
-{
-  /// release parameters matching mask, for all detector elements in a given chamber, counting from 1
-
-  // check boundaries
-  if (iCh < 1 || iCh > 10) {
-    LOG(fatal) << "Invalid chamber index " << iCh;
-  }
-
-  // get first and last element
-  const Int_t iDetElemFirst = fgSNDetElemCh[iCh - 1];
-  const Int_t iDetElemLast = fgSNDetElemCh[iCh];
-  for (Int_t i = iDetElemFirst; i < iDetElemLast; ++i) {
-
-    LOG(info) << "Releasing " << GetParameterMaskString(mask).Data() << " for detector element " << i;
-
-    if (mask & ParX)
-      ReleaseParameter(i, 0);
-    if (mask & ParY)
-      ReleaseParameter(i, 1);
-    if (mask & ParTZ)
-      ReleaseParameter(i, 2);
-    if (mask & ParZ)
-      ReleaseParameter(i, 3);
-  }
-}
-
-//_____________________________________________________________________
-void Alignment::ReleaseDetElem(Int_t iDetElemId, UInt_t mask)
-{
-  /// release parameters matching mask, for a given detector element, counting from 0
-  const Int_t iDet(GetDetElemNumber(iDetElemId));
-  if (mask & ParX)
-    ReleaseParameter(iDet, 0);
-  if (mask & ParY)
-    ReleaseParameter(iDet, 1);
-  if (mask & ParTZ)
-    ReleaseParameter(iDet, 2);
-  if (mask & ParZ)
-    ReleaseParameter(iDet, 3);
-}
-
-//______________________________________________________________________
-void Alignment::ReleaseParameter(Int_t iPar)
-{
-
-  /// release a given parameter, counting from 0
-  if (fInitialized) {
-    LOG(fatal) << "Millepede already initialized";
-  }
-
-  fGlobalParameterStatus[iPar] = kFreeParId;
-}
-
-//_____________________________________________________________________
-void Alignment::GroupChamber(Int_t iCh, UInt_t mask)
-{
-  /// group parameters matching mask for all detector elements in a given chamber, counting from 1
-  if (iCh < 1 || iCh > fgNCh) {
-    LOG(fatal) << "Invalid chamber index " << iCh;
-  }
-
-  const Int_t detElemMin = 100 * iCh;
-  const Int_t detElemMax = 100 * iCh + fgNDetElemCh[iCh] - 1;
-  GroupDetElems(detElemMin, detElemMax, mask);
-}
-
-//_____________________________________________________________________
-void Alignment::GroupHalfChamber(Int_t iCh, Int_t iHalf, UInt_t mask)
-{
-  /// group parameters matching mask for all detector elements in a given tracking module (= half chamber), counting from 0
-  if (iCh < 1 || iCh > fgNCh) {
-    LOG(fatal) << "Invalid chamber index " << iCh;
-  }
-
-  if (iHalf < 0 || iHalf > 1) {
-    LOG(fatal) << "Invalid half chamber index " << iHalf;
-  }
-
-  const Int_t iHalfCh = 2 * (iCh - 1) + iHalf;
-  GroupDetElems(&fgDetElemHalfCh[iHalfCh][0], fgNDetElemHalfCh[iHalfCh], mask);
-}
-
-//_____________________________________________________________________
-void Alignment::GroupDetElems(Int_t detElemMin, Int_t detElemMax, UInt_t mask)
-{
-  /// group parameters matching mask for all detector elements between min and max
-  // check number of detector elements
-  const Int_t nDetElem = detElemMax - detElemMin + 1;
-  if (nDetElem < 2) {
-    LOG(fatal) << "Requested group of DEs " << detElemMin << "-" << detElemMax << " contains less than 2 DE's";
-  }
-
-  // create list
-  Int_t* detElemList = new int[nDetElem];
-  for (Int_t i = 0; i < nDetElem; ++i) {
-    detElemList[i] = detElemMin + i;
-  }
-
-  // group
-  GroupDetElems(detElemList, nDetElem, mask);
-  delete[] detElemList;
-}
-
-//_____________________________________________________________________
-void Alignment::GroupDetElems(const Int_t* detElemList, Int_t nDetElem, UInt_t mask)
-{
-  /// group parameters matching mask for all detector elements in list
-  if (fInitialized) {
-    LOG(fatal) << "Millepede already initialized";
-  }
-
-  const Int_t iDeBase(GetDetElemNumber(detElemList[0]));
-  for (Int_t i = 0; i < nDetElem; ++i) {
-    const Int_t iDeCurrent(GetDetElemNumber(detElemList[i]));
-    if (mask & ParX)
-      fGlobalParameterStatus[iDeCurrent * fgNParCh + 0] = (i == 0) ? kGroupBaseId : (kGroupBaseId - iDeBase - 1);
-    if (mask & ParY)
-      fGlobalParameterStatus[iDeCurrent * fgNParCh + 1] = (i == 0) ? kGroupBaseId : (kGroupBaseId - iDeBase - 1);
-    if (mask & ParTZ)
-      fGlobalParameterStatus[iDeCurrent * fgNParCh + 2] = (i == 0) ? kGroupBaseId : (kGroupBaseId - iDeBase - 1);
-    if (mask & ParZ)
-      fGlobalParameterStatus[iDeCurrent * fgNParCh + 3] = (i == 0) ? kGroupBaseId : (kGroupBaseId - iDeBase - 1);
-
-    if (i == 0)
-      LOG(info) << "Creating new group for detector " << detElemList[i] << " and variable " << GetParameterMaskString(mask).Data();
-    else
-      LOG(info) << "Adding detector element " << detElemList[i] << " to current group";
-  }
-}
-
-//______________________________________________________________________
-void Alignment::SetChamberNonLinear(Int_t iCh, UInt_t mask)
-{
-  /// Set parameters matching mask as non linear, for all detector elements in a given chamber, counting from 1
-  const Int_t iDetElemFirst = fgSNDetElemCh[iCh - 1];
-  const Int_t iDetElemLast = fgSNDetElemCh[iCh];
-  for (Int_t i = iDetElemFirst; i < iDetElemLast; ++i) {
-
-    if (mask & ParX)
-      SetParameterNonLinear(i, 0);
-    if (mask & ParY)
-      SetParameterNonLinear(i, 1);
-    if (mask & ParTZ)
-      SetParameterNonLinear(i, 2);
-    if (mask & ParZ)
-      SetParameterNonLinear(i, 3);
-  }
-}
-
-//_____________________________________________________________________
-void Alignment::SetDetElemNonLinear(Int_t iDetElemId, UInt_t mask)
-{
-  /// Set parameters matching mask as non linear, for a given detector element, counting from 0
-  const Int_t iDet(GetDetElemNumber(iDetElemId));
-  if (mask & ParX)
-    SetParameterNonLinear(iDet, 0);
-  if (mask & ParY)
-    SetParameterNonLinear(iDet, 1);
-  if (mask & ParTZ)
-    SetParameterNonLinear(iDet, 2);
-  if (mask & ParZ)
-    SetParameterNonLinear(iDet, 3);
-}
-
-//______________________________________________________________________
-void Alignment::SetParameterNonLinear(Int_t iPar)
-{
-  /// Set nonlinear flag for parameter iPar
-  if (!fInitialized) {
-    LOG(fatal) << "Millepede not initialized";
-  }
-
-  fMillepede->SetNonLinear(iPar);
-  LOG(info) << "Parameter " << iPar << " set to non linear ";
-}
-
-//______________________________________________________________________
-void Alignment::AddConstraints(const Bool_t* lChOnOff, UInt_t mask)
-{
-  /// Add constraint equations for selected chambers and degrees of freedom
-
-  Array fConstraintX;
-  Array fConstraintY;
-  Array fConstraintTZ;
-  Array fConstraintZ;
-
-  for (Int_t i = 0; i < fgNDetElem; ++i) {
-
-    // get chamber matching detector
-    const Int_t iCh(GetChamberId(i));
-    if (lChOnOff[iCh - 1]) {
-
-      if (mask & ParX)
-        fConstraintX.values[i * fgNParCh + 0] = 1.0;
-      if (mask & ParY)
-        fConstraintY.values[i * fgNParCh + 1] = 1.0;
-      if (mask & ParTZ)
-        fConstraintTZ.values[i * fgNParCh + 2] = 1.0;
-      if (mask & ParZ)
-        fConstraintTZ.values[i * fgNParCh + 3] = 1.0;
-    }
-  }
-
-  if (mask & ParX)
-    AddConstraint(fConstraintX.values, 0.0);
-  if (mask & ParY)
-    AddConstraint(fConstraintY.values, 0.0);
-  if (mask & ParTZ)
-    AddConstraint(fConstraintTZ.values, 0.0);
-  if (mask & ParZ)
-    AddConstraint(fConstraintZ.values, 0.0);
-}
-
-//______________________________________________________________________
-void Alignment::AddConstraints(const Bool_t* lChOnOff, const Bool_t* lVarXYT, UInt_t sidesMask)
-{
-  /*
-  questions:
-  - is there not redundancy/inconsistency between lDetTLBR and lSpecLROnOff ? shouldn't we use only lDetTLBR ?
-  - why is weight ignored for ConstrainT and ConstrainB
-  - why is there no constrain on z
-  */
-
-  /// Add constraint equations for selected chambers, degrees of freedom and detector half
-  Double_t lMeanY = 0.;
-  Double_t lSigmaY = 0.;
-  Double_t lMeanZ = 0.;
-  Double_t lSigmaZ = 0.;
-  Int_t lNDetElem = 0;
-
-  for (Int_t i = 0; i < fgNDetElem; ++i) {
-
-    // get chamber matching detector
-    const Int_t iCh(GetChamberId(i));
-
-    // skip detector if chamber is off
-    if (lChOnOff[iCh - 1])
-      continue;
-
-    // get detector element id from detector element number
-    const Int_t lDetElemNumber = i - fgSNDetElemCh[iCh - 1];
-    const Int_t lDetElemId = iCh * 100 + lDetElemNumber;
-
-    // skip detector if its side is off
-    // stations 1 and 2
-    if (iCh >= 1 && iCh <= 4) {
-      if (lDetElemNumber == 0 && !(sidesMask & SideTopRight))
-        continue;
-      if (lDetElemNumber == 1 && !(sidesMask & SideTopLeft))
-        continue;
-      if (lDetElemNumber == 2 && !(sidesMask & SideBottomLeft))
-        continue;
-      if (lDetElemNumber == 3 && !(sidesMask & SideBottomRight))
-        continue;
-    }
-
-    // station 3
-    if (iCh >= 5 && iCh <= 6) {
-      if (lDetElemNumber >= 0 && lDetElemNumber <= 4 && !(sidesMask & SideTopRight))
-        continue;
-      if (lDetElemNumber >= 5 && lDetElemNumber <= 10 && !(sidesMask & SideTopLeft))
-        continue;
-      if (lDetElemNumber >= 11 && lDetElemNumber <= 13 && !(sidesMask & SideBottomLeft))
-        continue;
-      if (lDetElemNumber >= 14 && lDetElemNumber <= 17 && !(sidesMask & SideBottomRight))
-        continue;
-    }
-
-    // stations 4 and 5
-    if (iCh >= 7 && iCh <= 10) {
-      if (lDetElemNumber >= 0 && lDetElemNumber <= 6 && !(sidesMask & SideTopRight))
-        continue;
-      if (lDetElemNumber >= 7 && lDetElemNumber <= 13 && !(sidesMask & SideTopLeft))
-        continue;
-      if (lDetElemNumber >= 14 && lDetElemNumber <= 19 && !(sidesMask & SideBottomLeft))
-        continue;
-      if (lDetElemNumber >= 20 && lDetElemNumber <= 25 && !(sidesMask & SideBottomRight))
-        continue;
-    }
-
-    // get global x, y and z position
-    Double_t lDetElemGloX = 0.;
-    Double_t lDetElemGloY = 0.;
-    Double_t lDetElemGloZ = 0.;
-
-    auto fTransform = fTransformCreator(lDetElemId);
-    o2::math_utils::Point3D<double> SlatPos{0.0, 0.0, 0.0};
-    o2::math_utils::Point3D<double> GlobalPos;
-
-    fTransform.LocalToMaster(SlatPos, GlobalPos);
-    lDetElemGloX = GlobalPos.x();
-    lDetElemGloY = GlobalPos.y();
-    lDetElemGloZ = GlobalPos.z();
-    // fTransform->Local2Global(lDetElemId, 0, 0, 0, lDetElemGloX, lDetElemGloY, lDetElemGloZ);
-
-    // increment mean Y, mean Z, sigmas and number of accepted detectors
-    lMeanY += lDetElemGloY;
-    lSigmaY += lDetElemGloY * lDetElemGloY;
-    lMeanZ += lDetElemGloZ;
-    lSigmaZ += lDetElemGloZ * lDetElemGloZ;
-    lNDetElem++;
-  }
-
-  // calculate mean values
-  lMeanY /= lNDetElem;
-  lSigmaY /= lNDetElem;
-  lSigmaY = TMath::Sqrt(lSigmaY - lMeanY * lMeanY);
-  lMeanZ /= lNDetElem;
-  lSigmaZ /= lNDetElem;
-  lSigmaZ = TMath::Sqrt(lSigmaZ - lMeanZ * lMeanZ);
-  LOG(info) << "Used " << lNDetElem << " DetElem, MeanZ= " << lMeanZ << ", SigmaZ= " << lSigmaZ;
-
-  // create all possible arrays
-  Array fConstraintX[4];  // Array for constraint equation X
-  Array fConstraintY[4];  // Array for constraint equation Y
-  Array fConstraintP[4];  // Array for constraint equation P
-  Array fConstraintXZ[4]; // Array for constraint equation X vs Z
-  Array fConstraintYZ[4]; // Array for constraint equation Y vs Z
-  Array fConstraintPZ[4]; // Array for constraint equation P vs Z
-
-  // do we really need these ?
-  Array fConstraintXY[4]; // Array for constraint equation X vs Y
-  Array fConstraintYY[4]; // Array for constraint equation Y vs Y
-  Array fConstraintPY[4]; // Array for constraint equation P vs Y
-
-  // fill Bool_t sides array based on masks, for convenience
-  Bool_t lDetTLBR[4];
-  lDetTLBR[0] = sidesMask & SideTop;
-  lDetTLBR[1] = sidesMask & SideLeft;
-  lDetTLBR[2] = sidesMask & SideBottom;
-  lDetTLBR[3] = sidesMask & SideRight;
-
-  for (Int_t i = 0; i < fgNDetElem; ++i) {
-
-    // get chamber matching detector
-    const Int_t iCh(GetChamberId(i));
-
-    // skip detector if chamber is off
-    if (!lChOnOff[iCh - 1])
-      continue;
-
-    // get detector element id from detector element number
-    const Int_t lDetElemNumber = i - fgSNDetElemCh[iCh - 1];
-    const Int_t lDetElemId = iCh * 100 + lDetElemNumber;
-
-    // get global x, y and z position
-    Double_t lDetElemGloX = 0.;
-    Double_t lDetElemGloY = 0.;
-    Double_t lDetElemGloZ = 0.;
-
-    auto fTransform = fTransformCreator(lDetElemId);
-    o2::math_utils::Point3D<double> SlatPos{0.0, 0.0, 0.0};
-    o2::math_utils::Point3D<double> GlobalPos;
-
-    fTransform.LocalToMaster(SlatPos, GlobalPos);
-    lDetElemGloX = GlobalPos.x();
-    lDetElemGloY = GlobalPos.y();
-    lDetElemGloZ = GlobalPos.z();
-    // fTransform->Local2Global(lDetElemId, 0, 0, 0, lDetElemGloX, lDetElemGloY, lDetElemGloZ);
-
-    // loop over sides
-    for (Int_t iSide = 0; iSide < 4; iSide++) {
-
-      // skip if side is not selected
-      if (!lDetTLBR[iSide])
-        continue;
-
-      // skip detector if it is not in the selected side
-      // stations 1 and 2
-      if (iCh >= 1 && iCh <= 4) {
-        if (lDetElemNumber == 0 && !(iSide == 0 || iSide == 3))
-          continue; // top-right
-        if (lDetElemNumber == 1 && !(iSide == 0 || iSide == 1))
-          continue; // top-left
-        if (lDetElemNumber == 2 && !(iSide == 2 || iSide == 1))
-          continue; // bottom-left
-        if (lDetElemNumber == 3 && !(iSide == 2 || iSide == 3))
-          continue; // bottom-right
-      }
-
-      // station 3
-      if (iCh >= 5 && iCh <= 6) {
-        if (lDetElemNumber >= 0 && lDetElemNumber <= 4 && !(iSide == 0 || iSide == 3))
-          continue; // top-right
-        if (lDetElemNumber >= 5 && lDetElemNumber <= 9 && !(iSide == 0 || iSide == 1))
-          continue; // top-left
-        if (lDetElemNumber >= 10 && lDetElemNumber <= 13 && !(iSide == 2 || iSide == 1))
-          continue; // bottom-left
-        if (lDetElemNumber >= 14 && lDetElemNumber <= 17 && !(iSide == 2 || iSide == 3))
-          continue; // bottom-right
-      }
-
-      // stations 4 and 5
-      if (iCh >= 7 && iCh <= 10) {
-        if (lDetElemNumber >= 0 && lDetElemNumber <= 6 && !(iSide == 0 || iSide == 3))
-          continue; // top-right
-        if (lDetElemNumber >= 7 && lDetElemNumber <= 13 && !(iSide == 0 || iSide == 1))
-          continue; // top-left
-        if (lDetElemNumber >= 14 && lDetElemNumber <= 19 && !(iSide == 2 || iSide == 1))
-          continue; // bottom-left
-        if (lDetElemNumber >= 20 && lDetElemNumber <= 25 && !(iSide == 2 || iSide == 3))
-          continue; // bottom-right
-      }
-
-      // constrain x
-      if (lVarXYT[0])
-        fConstraintX[iSide].values[i * fgNParCh + 0] = 1;
-
-      // constrain y
-      if (lVarXYT[1])
-        fConstraintY[iSide].values[i * fgNParCh + 1] = 1;
-
-      // constrain phi (rotation around z)
-      if (lVarXYT[2])
-        fConstraintP[iSide].values[i * fgNParCh + 2] = 1;
-
-      // x-z shearing
-      if (lVarXYT[3])
-        fConstraintXZ[iSide].values[i * fgNParCh + 0] = (lDetElemGloZ - lMeanZ) / lSigmaZ;
-
-      // y-z shearing
-      if (lVarXYT[4])
-        fConstraintYZ[iSide].values[i * fgNParCh + 1] = (lDetElemGloZ - lMeanZ) / lSigmaZ;
-
-      // phi-z shearing
-      if (lVarXYT[5])
-        fConstraintPZ[iSide].values[i * fgNParCh + 2] = (lDetElemGloZ - lMeanZ) / lSigmaZ;
-
-      // x-y shearing
-      if (lVarXYT[6])
-        fConstraintXY[iSide].values[i * fgNParCh + 0] = (lDetElemGloY - lMeanY) / lSigmaY;
-
-      // y-y shearing
-      if (lVarXYT[7])
-        fConstraintYY[iSide].values[i * fgNParCh + 1] = (lDetElemGloY - lMeanY) / lSigmaY;
-
-      // phi-y shearing
-      if (lVarXYT[8])
-        fConstraintPY[iSide].values[i * fgNParCh + 2] = (lDetElemGloY - lMeanY) / lSigmaY;
-    }
-  }
-
-  // pass constraints to millepede
-  for (Int_t iSide = 0; iSide < 4; iSide++) {
-    // skip if side is not selected
-    if (!lDetTLBR[iSide])
-      continue;
-
-    if (lVarXYT[0])
-      AddConstraint(fConstraintX[iSide].values, 0.0);
-    if (lVarXYT[1])
-      AddConstraint(fConstraintY[iSide].values, 0.0);
-    if (lVarXYT[2])
-      AddConstraint(fConstraintP[iSide].values, 0.0);
-    if (lVarXYT[3])
-      AddConstraint(fConstraintXZ[iSide].values, 0.0);
-    if (lVarXYT[4])
-      AddConstraint(fConstraintYZ[iSide].values, 0.0);
-    if (lVarXYT[5])
-      AddConstraint(fConstraintPZ[iSide].values, 0.0);
-    if (lVarXYT[6])
-      AddConstraint(fConstraintXY[iSide].values, 0.0);
-    if (lVarXYT[7])
-      AddConstraint(fConstraintYY[iSide].values, 0.0);
-    if (lVarXYT[8])
-      AddConstraint(fConstraintPY[iSide].values, 0.0);
-  }
-}
-
-//______________________________________________________________________
-void Alignment::InitGlobalParameters(Double_t* par)
-{
-  /// Initialize global parameters with par array
-  if (!fInitialized) {
-    LOG(fatal) << "Millepede is not initialized";
-  }
-
-  fMillepede->SetGlobalParameters(par);
-}
-
-//______________________________________________________________________
-void Alignment::SetAllowedVariation(Int_t iPar, Double_t value)
-{
-  /// "Encouraged" variation for degrees of freedom
-  // check initialization
-  if (fInitialized) {
-    LOG(fatal) << "Millepede already initialized";
-  }
-
-  // check initialization
-  if (!(iPar >= 0 && iPar < fgNParCh)) {
-    LOG(fatal) << "Invalid index: " << iPar;
-  }
-
-  fAllowVar[iPar] = value;
-}
-
-//______________________________________________________________________
-void Alignment::SetSigmaXY(Double_t sigmaX, Double_t sigmaY)
-{
-
-  /// Set expected measurement resolution
-  fSigma[0] = sigmaX;
-  fSigma[1] = sigmaY;
-
-  // print
-  for (Int_t i = 0; i < 2; ++i) {
-    LOG(info) << "fSigma[" << i << "] =" << fSigma[i];
-  }
-}
-
-//_____________________________________________________
-void Alignment::GlobalFit(Double_t* parameters, Double_t* errors, Double_t* pulls)
-{
-
-  /// Call global fit; Global parameters are stored in parameters
-  fMillepede->GlobalFit(parameters, errors, pulls);
-
-  LOG(info) << "Done fitting global parameters";
-  for (int iDet = 0; iDet < fgNDetElem; ++iDet) {
-    LOG(info) << iDet << " " << parameters[iDet * fgNParCh + 0] << " " << parameters[iDet * fgNParCh + 1] << " " << parameters[iDet * fgNParCh + 3] << " " << parameters[iDet * fgNParCh + 2];
-  }
-}
-
-//_____________________________________________________
-void Alignment::PrintGlobalParameters() const
-{
-  fMillepede->PrintGlobalParameters();
-}
-
-//_____________________________________________________
-Double_t Alignment::GetParError(Int_t iPar) const
-{
-  return fMillepede->GetParError(iPar);
-}
-
-// //______________________________________________________________________
-// AliMUONGeometryTransformer* Alignment::ReAlign(
-//   const AliMUONGeometryTransformer* transformer,
-//   const double* misAlignments, Bool_t)
-// {
-
-//   /// Returns a new AliMUONGeometryTransformer with the found misalignments
-//   /// applied.
-
-//   // Takes the internal geometry module transformers, copies them
-//   // and gets the Detection Elements from them.
-//   // Takes misalignment parameters and applies these
-//   // to the local transform of the Detection Element
-//   // Obtains the global transform by multiplying the module transformer
-//   // transformation with the local transformation
-//   // Applies the global transform to a new detection element
-//   // Adds the new detection element to a new module transformer
-//   // Adds the new module transformer to a new geometry transformer
-//   // Returns the new geometry transformer
-
-//   Double_t lModuleMisAlignment[fgNParCh] = {0};
-//   Double_t lDetElemMisAlignment[fgNParCh] = {0};
-//   const TClonesArray* oldMisAlignArray(transformer->GetMisAlignmentData());
-
-//   AliMUONGeometryTransformer* newGeometryTransformer = new AliMUONGeometryTransformer();
-//   for (Int_t iMt = 0; iMt < transformer->GetNofModuleTransformers(); ++iMt) {
-
-//     // module transformers
-//     const AliMUONGeometryModuleTransformer* kModuleTransformer = transformer->GetModuleTransformer(iMt, kTRUE);
-
-//     AliMUONGeometryModuleTransformer* newModuleTransformer = new AliMUONGeometryModuleTransformer(iMt);
-//     newGeometryTransformer->AddModuleTransformer(newModuleTransformer);
-
-//     // get transformation
-//     TGeoHMatrix deltaModuleTransform(DeltaTransform(lModuleMisAlignment));
-
-//     // update module
-//     TGeoHMatrix moduleTransform(*kModuleTransformer->GetTransformation());
-//     TGeoHMatrix newModuleTransform(AliMUONGeometryBuilder::Multiply(deltaModuleTransform, moduleTransform));
-//     newModuleTransformer->SetTransformation(newModuleTransform);
-
-//     // Get matching old alignment and update current matrix accordingly
-//     if (oldMisAlignArray) {
-
-//       const AliAlignObjMatrix* oldAlignObj(0);
-//       const Int_t moduleId(kModuleTransformer->GetModuleId());
-//       const Int_t volId = AliGeomManager::LayerToVolUID(AliGeomManager::kMUON, moduleId);
-//       for (Int_t pos = 0; pos < oldMisAlignArray->GetEntriesFast(); ++pos) {
-
-//         const AliAlignObjMatrix* localAlignObj(dynamic_cast<const AliAlignObjMatrix*>(oldMisAlignArray->At(pos)));
-//         if (localAlignObj && localAlignObj->GetVolUID() == volId) {
-//           oldAlignObj = localAlignObj;
-//           break;
-//         }
-//       }
-
-//       // multiply
-//       if (oldAlignObj) {
-
-//         TGeoHMatrix oldMatrix;
-//         oldAlignObj->GetMatrix(oldMatrix);
-//         deltaModuleTransform.Multiply(&oldMatrix);
-//       }
-//     }
-
-//     // Create module mis alignment matrix
-//     newGeometryTransformer->AddMisAlignModule(kModuleTransformer->GetModuleId(), deltaModuleTransform);
-
-//     AliMpExMap* detElements = kModuleTransformer->GetDetElementStore();
-
-//     TIter next(detElements->CreateIterator());
-//     AliMUONGeometryDetElement* detElement;
-//     Int_t iDe(-1);
-//     while ((detElement = static_cast<AliMUONGeometryDetElement*>(next()))) {
-//       ++iDe;
-//       // make a new detection element
-//       AliMUONGeometryDetElement* newDetElement = new AliMUONGeometryDetElement(detElement->GetId(), detElement->GetVolumePath());
-//       TString lDetElemName(detElement->GetDEName());
-//       lDetElemName.ReplaceAll("DE", "");
-
-//       // store detector element id and number
-//       const Int_t iDetElemId = lDetElemName.Atoi();
-//       if (DetElemIsValid(iDetElemId)) {
-
-//         const Int_t iDetElemNumber(GetDetElemNumber(iDetElemId));
-
-//         for (int i = 0; i < fgNParCh; ++i) {
-//           lDetElemMisAlignment[i] = 0.0;
-//           if (iMt < fgNTrkMod) {
-//             lDetElemMisAlignment[i] = misAlignments[iDetElemNumber * fgNParCh + i];
-//           }
-//         }
-
-//         // get transformation
-//         TGeoHMatrix deltaGlobalTransform(DeltaTransform(lDetElemMisAlignment));
-
-//         // update module
-//         TGeoHMatrix globalTransform(*detElement->GetGlobalTransformation());
-//         TGeoHMatrix newGlobalTransform(AliMUONGeometryBuilder::Multiply(deltaGlobalTransform, globalTransform));
-//         newDetElement->SetGlobalTransformation(newGlobalTransform);
-//         newModuleTransformer->GetDetElementStore()->Add(newDetElement->GetId(), newDetElement);
-
-//         // Get matching old alignment and update current matrix accordingly
-//         if (oldMisAlignArray) {
-
-//           const AliAlignObjMatrix* oldAlignObj(0);
-//           const int detElemId(detElement->GetId());
-//           const Int_t volId = AliGeomManager::LayerToVolUID(AliGeomManager::kMUON, detElemId);
-//           for (Int_t pos = 0; pos < oldMisAlignArray->GetEntriesFast(); ++pos) {
-
-//             const AliAlignObjMatrix* localAlignObj(dynamic_cast<const AliAlignObjMatrix*>(oldMisAlignArray->At(pos)));
-//             if (localAlignObj && localAlignObj->GetVolUID() == volId) {
-//               oldAlignObj = localAlignObj;
-//               break;
-//             }
-//           }
-
-//           // multiply
-//           if (oldAlignObj) {
-
-//             TGeoHMatrix oldMatrix;
-//             oldAlignObj->GetMatrix(oldMatrix);
-//             deltaGlobalTransform.Multiply(&oldMatrix);
-//           }
-//         }
-
-//         // Create misalignment matrix
-//         newGeometryTransformer->AddMisAlignDetElement(detElement->GetId(), deltaGlobalTransform);
-
-//       } else {
-
-//         // "invalid" detector elements come from MTR and are left unchanged
-//         Aliinfo(Form("Keeping detElement %i unchanged", iDetElemId));
-
-//         // update module
-//         TGeoHMatrix globalTransform(*detElement->GetGlobalTransformation());
-//         newDetElement->SetGlobalTransformation(globalTransform);
-//         newModuleTransformer->GetDetElementStore()->Add(newDetElement->GetId(), newDetElement);
-
-//         // Get matching old alignment and update current matrix accordingly
-//         if (oldMisAlignArray) {
-
-//           const AliAlignObjMatrix* oldAlignObj(0);
-//           const int detElemId(detElement->GetId());
-//           const Int_t volId = AliGeomManager::LayerToVolUID(AliGeomManager::kMUON, detElemId);
-//           for (Int_t pos = 0; pos < oldMisAlignArray->GetEntriesFast(); ++pos) {
-
-//             const AliAlignObjMatrix* localAlignObj(dynamic_cast<const AliAlignObjMatrix*>(oldMisAlignArray->At(pos)));
-//             if (localAlignObj && localAlignObj->GetVolUID() == volId) {
-//               oldAlignObj = localAlignObj;
-//               break;
-//             }
-//           }
-
-//           // multiply
-//           if (oldAlignObj) {
-
-//             TGeoHMatrix oldMatrix;
-//             oldAlignObj->GetMatrix(oldMatrix);
-//             newGeometryTransformer->AddMisAlignDetElement(detElement->GetId(), oldMatrix);
-//           }
-//         }
-//       }
-//     }
-
-//     newGeometryTransformer->AddModuleTransformer(newModuleTransformer);
-//   }
-
-//   return newGeometryTransformer;
-// }
-
-//______________________________________________________________________
-void Alignment::SetAlignmentResolution(const TClonesArray* misAlignArray, Int_t rChId, Double_t chResX, Double_t chResY, Double_t deResX, Double_t deResY)
-{
-
-  /// Set alignment resolution to misalign objects to be stored in CDB
-  /// if rChId is > 0 set parameters for this chamber only, counting from 1
-  TMatrixDSym mChCorrMatrix(6);
-  mChCorrMatrix[0][0] = chResX * chResX;
-  mChCorrMatrix[1][1] = chResY * chResY;
-
-  TMatrixDSym mDECorrMatrix(6);
-  mDECorrMatrix[0][0] = deResX * deResX;
-  mDECorrMatrix[1][1] = deResY * deResY;
-
-  o2::detectors::AlignParam* alignMat = 0x0;
-
-  for (Int_t chId = 0; chId <= 9; ++chId) {
-
-    // skip chamber if selection is valid, and does not match
-    if (rChId > 0 && chId + 1 != rChId)
-      continue;
-
-    TString chName1;
-    TString chName2;
-    if (chId < 4) {
-
-      chName1 = Form("GM%d", chId);
-      chName2 = Form("GM%d", chId);
-
-    } else {
-
-      chName1 = Form("GM%d", 4 + (chId - 4) * 2);
-      chName2 = Form("GM%d", 4 + (chId - 4) * 2 + 1);
-    }
-
-    for (int i = 0; i < misAlignArray->GetEntries(); ++i) {
-
-      alignMat = (o2::detectors::AlignParam*)misAlignArray->At(i);
-      TString volName(alignMat->getSymName());
-      if ((volName.Contains(chName1) &&
-           ((volName.Last('/') == volName.Index(chName1) + chName1.Length()) ||
-            (volName.Length() == volName.Index(chName1) + chName1.Length()))) ||
-          (volName.Contains(chName2) &&
-           ((volName.Last('/') == volName.Index(chName2) + chName2.Length()) ||
-            (volName.Length() == volName.Index(chName2) + chName2.Length())))) {
-
-        volName.Remove(0, volName.Last('/') + 1);
-        // if (volName.Contains("GM")){
-        //   alignMat->SetCorrMatrix(mChCorrMatrix);
-        // }else if (volName.Contains("DE")){
-        //   alignMat->SetCorrMatrix(mDECorrMatrix);
-        // }
-      }
-    }
-  }
-}
-
-//_____________________________________________________
-LocalTrackParam Alignment::RefitStraightTrack(Track& track, Double_t z0) const
-{
-
-  // initialize matrices
-  TMatrixD AtGASum(4, 4);
-  AtGASum.Zero();
-
-  TMatrixD AtGMSum(4, 1);
-  AtGMSum.Zero();
-
-  // loop over clusters
-  for (auto itTrackParam(track.begin()); itTrackParam != track.end(); ++itTrackParam) {
-
-    // get track parameters
-    if (!&*itTrackParam)
-      continue;
-
-    // get cluster
-    const Cluster* cluster = itTrackParam->getClusterPtr();
-    if (!cluster)
-      continue;
-
-    // projection matrix
-    TMatrixD A(2, 4);
-    A.Zero();
-    A(0, 0) = 1;
-    A(0, 2) = (cluster->getZ() - z0);
-    A(1, 1) = 1;
-    A(1, 3) = (cluster->getZ() - z0);
-
-    TMatrixD At(TMatrixD::kTransposed, A);
-
-    // gain matrix
-    TMatrixD G(2, 2);
-    G.Zero();
-    G(0, 0) = 1.0 / Square(cluster->getEx());
-    G(1, 1) = 1.0 / Square(cluster->getEy());
-
-    const TMatrixD AtG(At, TMatrixD::kMult, G);
-    const TMatrixD AtGA(AtG, TMatrixD::kMult, A);
-    AtGASum += AtGA;
-
-    // measurement
-    TMatrixD M(2, 1);
-    M(0, 0) = cluster->getX();
-    M(1, 0) = cluster->getY();
-    const TMatrixD AtGM(AtG, TMatrixD::kMult, M);
-    AtGMSum += AtGM;
-  }
-
-  // perform inversion
-  TMatrixD AtGASumInv(TMatrixD::kInverted, AtGASum);
-  TMatrixD X(AtGASumInv, TMatrixD::kMult, AtGMSum);
-
-  //   // TODO: compare with initial track parameters
-  //   Aliinfo( Form( "x: %.3f vs %.3f", fTrackPos0[0], X(0,0) ) );
-  //   Aliinfo( Form( "y: %.3f vs %.3f", fTrackPos0[1], X(1,0) ) );
-  //   Aliinfo( Form( "dxdz: %.6g vs %.6g", fTrackSlope0[0], X(2,0) ) );
-  //   Aliinfo( Form( "dydz: %.6g vs %.6g\n", fTrackSlope0[1], X(3,0) ) );
-
-  // fill output parameters
-  LocalTrackParam out;
-  out.fTrackX = X(0, 0);
-  out.fTrackY = X(1, 0);
-  out.fTrackZ = z0;
-  out.fTrackSlopeX = X(2, 0);
-  out.fTrackSlopeY = X(3, 0);
-
-  return out;
-}
-
-//_____________________________________________________
-void Alignment::FillDetElemData(const Cluster* cluster)
-{
-  // LOG(fatal) << __PRETTY_FUNCTION__ << " is disabled";
-  LOG(info) << __PRETTY_FUNCTION__ << " is enabled";
-
-  /// Get information of current detection element
-  // get detector element number from Alice ID
-  const Int_t detElemId = cluster->getDEId();
-  fDetElemNumber = GetDetElemNumber(detElemId);
-
-  // get detector element
-  // const AliMUONGeometryDetElement detElement(detElemId);
-  auto fTransform = fTransformCreator(detElemId);
-  /*
-  get the global transformation matrix and store its inverse, in order to manually perform
-  the global to Local transformations needed to calculate the derivatives
-  */
-  // fTransform = fTransform.Inverse();
-  // fTransform.GetTransformMatrix(fGeoCombiTransInverse);
-}
-
-//______________________________________________________________________
-void Alignment::FillRecPointData(const Cluster* cluster)
-{
-
-  /// Get information of current cluster
-  fClustPos[0] = cluster->getX();
-  fClustPos[1] = cluster->getY();
-  fClustPos[2] = cluster->getZ();
-}
-
-//______________________________________________________________________
-void Alignment::FillTrackParamData(const TrackParam* trackParam)
-{
-
-  /// Get information of current track at current cluster
-  fTrackPos[0] = trackParam->getNonBendingCoor();
-  fTrackPos[1] = trackParam->getBendingCoor();
-  fTrackPos[2] = trackParam->getZ();
-  fTrackSlope[0] = trackParam->getNonBendingSlope();
-  fTrackSlope[1] = trackParam->getBendingSlope();
-}
-
-//______________________________________________________________________
-void Alignment::LocalEquationX(void)
-{
-  /// local equation along X
-
-  // 'inverse' (GlobalToLocal) rotation matrix
-  const Double_t* r(fGeoCombiTransInverse.GetRotationMatrix());
-
-  // local derivatives
-  SetLocalDerivative(0, r[0]);
-  SetLocalDerivative(1, r[0] * (fTrackPos[2] - fTrackPos0[2]));
-  SetLocalDerivative(2, r[1]);
-  SetLocalDerivative(3, r[1] * (fTrackPos[2] - fTrackPos0[2]));
-
-  // global derivatives
-  /*
-  alignment parameters are
-  0: delta_x
-  1: delta_y
-  2: delta_phiz
-  3: delta_z
-  */
-
-  SetGlobalDerivative(fDetElemNumber * fgNParCh + 0, -r[0]);
-  SetGlobalDerivative(fDetElemNumber * fgNParCh + 1, -r[1]);
-
-  if (fBFieldOn) {
-
-    // use local position for derivatives vs 'delta_phi_z'
-    SetGlobalDerivative(fDetElemNumber * fgNParCh + 2, -r[1] * fTrackPos[0] + r[0] * fTrackPos[1]);
-
-    // use local slopes for derivatives vs 'delta_z'
-    SetGlobalDerivative(fDetElemNumber * fgNParCh + 3, r[0] * fTrackSlope[0] + r[1] * fTrackSlope[1]);
-
-  } else {
-
-    // local copy of extrapolated track positions
-    const Double_t trackPosX = fTrackPos0[0] + fTrackSlope0[0] * (fTrackPos[2] - fTrackPos0[2]);
-    const Double_t trackPosY = fTrackPos0[1] + fTrackSlope0[1] * (fTrackPos[2] - fTrackPos0[2]);
-
-    // use properly extrapolated position for derivatives vs 'delta_phi_z'
-    SetGlobalDerivative(fDetElemNumber * fgNParCh + 2, -r[1] * trackPosX + r[0] * trackPosY);
-
-    // use slopes at origin for derivatives vs 'delta_z'
-    SetGlobalDerivative(fDetElemNumber * fgNParCh + 3, r[0] * fTrackSlope0[0] + r[1] * fTrackSlope0[1]);
-  }
-
-  // store local equation
-  fMillepede->SetLocalEquation(fGlobalDerivatives, fLocalDerivatives, fMeas[0], fSigma[0]);
-}
-
-//______________________________________________________________________
-void Alignment::LocalEquationY(void)
-{
-  /// local equation along Y
-
-  // 'inverse' (GlobalToLocal) rotation matrix
-  const Double_t* r(fGeoCombiTransInverse.GetRotationMatrix());
-
-  // store local derivatives
-  SetLocalDerivative(0, r[3]);
-  SetLocalDerivative(1, r[3] * (fTrackPos[2] - fTrackPos0[2]));
-  SetLocalDerivative(2, r[4]);
-  SetLocalDerivative(3, r[4] * (fTrackPos[2] - fTrackPos0[2]));
-
-  // set global derivatives
-  SetGlobalDerivative(fDetElemNumber * fgNParCh + 0, -r[3]);
-  SetGlobalDerivative(fDetElemNumber * fgNParCh + 1, -r[4]);
-
-  if (fBFieldOn) {
-
-    // use local position for derivatives vs 'delta_phi'
-    SetGlobalDerivative(fDetElemNumber * fgNParCh + 2, -r[4] * fTrackPos[0] + r[3] * fTrackPos[1]);
-
-    // use local slopes for derivatives vs 'delta_z'
-    SetGlobalDerivative(fDetElemNumber * fgNParCh + 3, r[3] * fTrackSlope[0] + r[4] * fTrackSlope[1]);
-
-  } else {
-
-    // local copy of extrapolated track positions
-    const Double_t trackPosX = fTrackPos0[0] + fTrackSlope0[0] * (fTrackPos[2] - fTrackPos0[2]);
-    const Double_t trackPosY = fTrackPos0[1] + fTrackSlope0[1] * (fTrackPos[2] - fTrackPos0[2]);
-
-    // use properly extrapolated position for derivatives vs 'delta_phi'
-    SetGlobalDerivative(fDetElemNumber * fgNParCh + 2, -r[4] * trackPosX + r[3] * trackPosY);
-
-    // use slopes at origin for derivatives vs 'delta_z'
-    SetGlobalDerivative(fDetElemNumber * fgNParCh + 3, r[3] * fTrackSlope0[0] + r[4] * fTrackSlope0[1]);
-  }
-
-  // store local equation
-  fMillepede->SetLocalEquation(fGlobalDerivatives, fLocalDerivatives, fMeas[1], fSigma[1]);
-}
-
-//_________________________________________________________________________
-TGeoCombiTrans Alignment::DeltaTransform(const double* lMisAlignment) const
-{
-  /// Get Delta Transformation, based on alignment parameters
-
-  // translation
-  const TGeoTranslation deltaTrans(lMisAlignment[0], lMisAlignment[1], lMisAlignment[3]);
-
-  // rotation
-  TGeoRotation deltaRot;
-  deltaRot.RotateZ(lMisAlignment[2] * 180. / TMath::Pi());
-
-  // combined rotation and translation.
-  return TGeoCombiTrans(deltaTrans, deltaRot);
-}
-
-//______________________________________________________________________
-void Alignment::AddConstraint(Double_t* par, Double_t value)
-{
-  /// Constrain equation defined by par to value
-  if (!fInitialized) {
-    LOG(fatal) << "Millepede is not initialized";
-  }
-
-  fMillepede->SetGlobalConstraint(par, value);
-}
-
-//______________________________________________________________________
-Bool_t Alignment::DetElemIsValid(Int_t iDetElemId) const
-{
-  /// return true if given detector element is valid (and belongs to muon tracker)
-  const Int_t iCh = iDetElemId / 100;
-  const Int_t iDet = iDetElemId % 100;
-  return (iCh > 0 && iCh <= fgNCh && iDet < fgNDetElemCh[iCh - 1]);
-}
-
-//______________________________________________________________________
-Int_t Alignment::GetDetElemNumber(Int_t iDetElemId) const
-{
-  /// get det element number from ID
-  // get chamber and element number in chamber
-  const Int_t iCh = iDetElemId / 100;
-  const Int_t iDet = iDetElemId % 100;
-
-  // make sure detector index is valid
-  if (!(iCh > 0 && iCh <= fgNCh && iDet < fgNDetElemCh[iCh - 1])) {
-    LOG(fatal) << "Invalid detector element id: " << iDetElemId;
-  }
-
-  // add number of detectors up to this chamber
-  return iDet + fgSNDetElemCh[iCh - 1];
-}
-
-//______________________________________________________________________
-Int_t Alignment::GetChamberId(Int_t iDetElemNumber) const
-{
-  /// get chamber (counting from 1) matching a given detector element id
-  Int_t iCh(0);
-  for (iCh = 0; iCh < fgNCh; iCh++) {
-    if (iDetElemNumber < fgSNDetElemCh[iCh])
-      break;
-  }
-
-  return iCh;
-}
-
-//______________________________________________________________________
-TString Alignment::GetParameterMaskString(UInt_t mask) const
-{
-  TString out;
-  if (mask & ParX)
-    out += "X";
-  if (mask & ParY)
-    out += "Y";
-  if (mask & ParZ)
-    out += "Z";
-  if (mask & ParTZ)
-    out += "T";
-  return out;
-}
-
-//______________________________________________________________________
-TString Alignment::GetSidesMaskString(UInt_t mask) const
-{
-  TString out;
-  if (mask & SideTop)
-    out += "T";
-  if (mask & SideLeft)
-    out += "L";
-  if (mask & SideBottom)
-    out += "B";
-  if (mask & SideRight)
-    out += "R";
-  return out;
-}
-
-} // namespace mch
-} // namespace o2
\ No newline at end of file
diff --git a/Detectors/ITSMFT/MFT/calibration/src/NoiseSlotCalibrator.cxx b/Detectors/ITSMFT/MFT/calibration/src/NoiseSlotCalibrator.cxx
deleted file mode 100644
index 13d6f3b3f567b..0000000000000
--- a/Detectors/ITSMFT/MFT/calibration/src/NoiseSlotCalibrator.cxx
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   NoiseSlotCalibrator.cxx
-
-#include "MFTCalibration/NoiseSlotCalibrator.h"
-
-#include <fairlogger/Logger.h>
-#include "TFile.h"
-#include "DataFormatsITSMFT/Digit.h"
-#include "DataFormatsITSMFT/ClusterPattern.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-
-namespace o2
-{
-using Slot = calibration::TimeSlot<o2::itsmft::NoiseMap>;
-
-namespace mft
-{
-bool NoiseSlotCalibrator::processTimeFrame(calibration::TFType nTF,
-                                           gsl::span<const o2::itsmft::Digit> const& digits,
-                                           gsl::span<const o2::itsmft::ROFRecord> const& rofs)
-{
-  LOG(detail) << "Processing TF# " << nTF;
-
-  auto& slotTF = getSlotForTF(nTF);
-  auto& noiseMap = *(slotTF.getContainer());
-
-  for (const auto& rof : rofs) {
-    auto digitsInFrame = rof.getROFData(digits);
-    for (const auto& d : digitsInFrame) {
-      auto id = d.getChipIndex();
-      auto row = d.getRow();
-      auto col = d.getColumn();
-
-      noiseMap.increaseNoiseCount(id, row, col);
-    }
-  }
-  noiseMap.addStrobes(rofs.size());
-  mNumberOfStrobes += rofs.size();
-  return hasEnoughData(slotTF);
-}
-
-bool NoiseSlotCalibrator::processTimeFrame(calibration::TFType nTF,
-                                           gsl::span<const o2::itsmft::CompClusterExt> const& clusters,
-                                           gsl::span<const unsigned char> const& patterns,
-                                           gsl::span<const o2::itsmft::ROFRecord> const& rofs)
-{
-  LOG(detail) << "Processing TF# " << nTF;
-
-  auto& slotTF = getSlotForTF(nTF);
-  auto& noiseMap = *(slotTF.getContainer());
-
-  auto pattIt = patterns.begin();
-  for (const auto& rof : rofs) {
-    auto clustersInFrame = rof.getROFData(clusters);
-    for (const auto& c : clustersInFrame) {
-      if (c.getPatternID() != o2::itsmft::CompCluster::InvalidPatternID) {
-        // For the noise calibration, we use "pass1" clusters...
-        continue;
-      }
-      o2::itsmft::ClusterPattern patt(pattIt);
-
-      auto id = c.getSensorID();
-      auto row = c.getRow();
-      auto col = c.getCol();
-      auto colSpan = patt.getColumnSpan();
-      auto rowSpan = patt.getRowSpan();
-
-      // Fast 1-pixel calibration
-      if ((rowSpan == 1) && (colSpan == 1)) {
-        noiseMap.increaseNoiseCount(id, row, col);
-        continue;
-      }
-
-      // All-pixel calibration
-      auto nBits = rowSpan * colSpan;
-      int ic = 0, ir = 0;
-      for (unsigned int i = 2; i < patt.getUsedBytes() + 2; i++) {
-        unsigned char tempChar = patt.getByte(i);
-        int s = 128; // 0b10000000
-        while (s > 0) {
-          if ((tempChar & s) != 0) {
-            noiseMap.increaseNoiseCount(id, row + ir, col + ic);
-          }
-          ic++;
-          s >>= 1;
-          if ((ir + 1) * ic == nBits) {
-            break;
-          }
-          if (ic == colSpan) {
-            ic = 0;
-            ir++;
-          }
-        }
-        if ((ir + 1) * ic == nBits) {
-          break;
-        }
-      }
-    }
-  }
-  noiseMap.addStrobes(rofs.size());
-  mNumberOfStrobes += rofs.size();
-  return hasEnoughData(slotTF);
-}
-
-// Functions overloaded from the calibration framework
-bool NoiseSlotCalibrator::process(calibration::TFType tf, const gsl::span<const o2::itsmft::CompClusterExt> data)
-{
-  LOG(warning) << "Only 1-pix noise calibraton is possible !";
-  return calibration::TimeSlotCalibration<o2::itsmft::CompClusterExt, o2::itsmft::NoiseMap>::process(tf, data);
-}
-
-// Functions required by the calibration framework
-
-Slot& NoiseSlotCalibrator::emplaceNewSlot(bool front, calibration::TFType tstart, calibration::TFType tend)
-{
-  auto& cont = getSlots();
-  auto& slot = front ? cont.emplace_front(tstart, tend) : cont.emplace_back(tstart, tend);
-  slot.setContainer(std::make_unique<o2::itsmft::NoiseMap>(936));
-  return slot;
-}
-
-bool NoiseSlotCalibrator::hasEnoughData(const Slot& slot) const
-{
-  return slot.getContainer()->getNumberOfStrobes() > mMinROFs ? true : false;
-}
-
-void NoiseSlotCalibrator::finalizeSlot(Slot& slot)
-{
-  o2::itsmft::NoiseMap* map = slot.getContainer();
-  LOG(info) << "Number of processed strobes is " << map->getNumberOfStrobes();
-  map->applyProbThreshold(mProbabilityThreshold, map->getNumberOfStrobes(), mProbRelErr);
-}
-
-} // namespace mft
-} // namespace o2

From 6d11591da421e8c200b3368a41727752882e4db1 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 11 Feb 2026 10:09:52 +0100
Subject: [PATCH 1309/1764] ITS: GPU: use mean vertex constraint for gpu
 processing

I noticed that in the Pb-Pb production we did not add the mean vertex constraint to be used.
---
 prodtests/full-system-test/dpl-workflow.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index f559fcdf91cf5..a8f01a3ef1822 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -572,6 +572,9 @@ if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
 fi
 
 has_detector_gpu ITS && GPU_INPUT+=",its-clusters"
+if [[ $BEAMTYPE != "cosmic" && $SYNCMODE != 1 ]]; then
+  has_detector_gpu ITS && GPU_INPUT+=",its-mean-vertex"
+fi
 has_detector_gpu ITS && GPU_OUTPUT+=",its-tracks"
 
 # ---------------------------------------------------------------------------------------------------------------------

From 7c79e17a0c694491c65c3033f976084f85cca8d7 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Wed, 11 Feb 2026 09:44:56 +0100
Subject: [PATCH 1310/1764] TPC: time gain calibration optimizations

- bug fix: using bin centre of the dE/dx instead of lower bin edge
- add option to not perform per sector scaling (needed for MC)
---
 .../DataFormatsTPC/CalibdEdxCorrection.h        |  3 +++
 .../Detectors/TPC/src/CalibdEdxCorrection.cxx   | 13 +++++++++++++
 .../include/TPCCalibration/CalibdEdx.h          |  4 +++-
 Detectors/TPC/calibration/src/CalibdEdx.cxx     | 17 +++++++++++------
 4 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/CalibdEdxCorrection.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/CalibdEdxCorrection.h
index 1d7b10dc965f7..024d6189593e9 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/CalibdEdxCorrection.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/CalibdEdxCorrection.h
@@ -115,6 +115,9 @@ class CalibdEdxCorrection
   /// Single fit parameters averaged over all sectors for a stack type
   float getMeanEntries(const GEMstack stack, ChargeType charge) const;
 
+  /// set all corrections to 1, used for default initialization and to reset corrections
+  void setUnity();
+
 #endif
 
  private:
diff --git a/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx b/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx
index 0991c8693d8e8..152feacb41937 100644
--- a/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx
+++ b/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx
@@ -168,3 +168,16 @@ float CalibdEdxCorrection::getMeanEntries(const GEMstack stack, ChargeType charg
 
   return mean / (SECTORSPERSIDE * SIDES);
 }
+
+void CalibdEdxCorrection::setUnity()
+{
+  for (int i = 0; i < FitSize; ++i) {
+    for (int j = 0; j < ParamSize; ++j) {
+      mParams[i][j] = 0.f;
+    }
+    mParams[i][0] = 1.f; // constant term = 1
+    mChi2[i] = 0.f;
+    mEntries[i] = 0;
+  }
+  mDims = 0;
+}
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CalibdEdx.h b/Detectors/TPC/calibration/include/TPCCalibration/CalibdEdx.h
index 20e470702a89a..ff7c763efcd2b 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CalibdEdx.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CalibdEdx.h
@@ -129,7 +129,9 @@ class CalibdEdx
   /// Compute MIP position from dEdx histograms and save result in the correction container.
   /// To retrieve the correction call `CalibdEdx::getCalib()`
   /// \param useGausFits make gaussian fits of dEdx vs tgl instead of fitting the mean dEdx
-  void finalize(const bool useGausFits = true);
+  /// \param averageSectors If true, the correction is averaged over all sectors.
+  /// In this case, no mean-sector scaling is applied when statistics are low.
+  void finalize(const bool useGausFits = true, const bool averageSectors = false);
 
   /// Return calib data histogram
   const Hist& getHist() const { return mHist; }
diff --git a/Detectors/TPC/calibration/src/CalibdEdx.cxx b/Detectors/TPC/calibration/src/CalibdEdx.cxx
index 4eb29c8833565..938ab8ae91065 100644
--- a/Detectors/TPC/calibration/src/CalibdEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalibdEdx.cxx
@@ -351,7 +351,7 @@ auto ProjectBoostHistoXFastAllSectors(const Hist& hist, std::vector<int>& bin_in
 
       // access the bin content specified by bin_indices
       const float counts = hist.at(bin_indices);
-      float dEdx = hist.axis(ax::dEdx).value(i);
+      float dEdx = hist.axis(ax::dEdx).bin(i).center();
 
       // scale the dedx to the mean
       if (stackMean != nullptr) {
@@ -532,7 +532,7 @@ void CalibdEdx::fitHistGaus(TLinearFitter& fitter, CalibdEdxCorrection& corr, co
   LOGP(info, "Calibration fits took: {}", time.count());
 }
 
-void CalibdEdx::finalize(const bool useGausFits)
+void CalibdEdx::finalize(const bool useGausFits, const bool averageSectors)
 {
   const float entries = minStackEntries();
   mCalib.clear();
@@ -565,10 +565,15 @@ void CalibdEdx::finalize(const bool useGausFits)
     // get mean of each GEM stack
     CalibdEdxCorrection meanCorr{};
     meanCorr.setDims(0);
-    TLinearFitter meanFitter(0);
-    meanFitter.SetFormula("1");
-    // get the mean dEdx for each stack
-    fitHist(mHist, meanCorr, meanFitter, mFitCut, mFitLowCutFactor, mFitPasses);
+    if (averageSectors) {
+      // set mean dEdx per stack to unity
+      meanCorr.setUnity();
+    } else {
+      // get the mean dEdx for each stack
+      TLinearFitter meanFitter(0);
+      meanFitter.SetFormula("1");
+      fitHist(mHist, meanCorr, meanFitter, mFitCut, mFitLowCutFactor, mFitPasses, nullptr, mDebugOutputStreamer.get());
+    }
     if (!useGausFits) {
       // get higher dimension corrections with projected sectors
       fitHist(mHist, mCalib, fitter, mFitCut, mFitLowCutFactor, mFitPasses, &meanCorr, mDebugOutputStreamer.get());

From a1b356bc9af763d7c8bd7893f04b17d7202f8457 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 12 Feb 2026 00:11:38 +0100
Subject: [PATCH 1311/1764] GPU Vulkan Display: fix DEPFILE path

---
 GPU/GPUTracking/cmake/vulkan_display.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/cmake/vulkan_display.cmake b/GPU/GPUTracking/cmake/vulkan_display.cmake
index 7cbfd0328c323..7859742363755 100644
--- a/GPU/GPUTracking/cmake/vulkan_display.cmake
+++ b/GPU/GPUTracking/cmake/vulkan_display.cmake
@@ -27,7 +27,7 @@ function(add_glslc_shader TARGET SHADER)
         OUTPUT ${spirv-file}
         COMMAND ${Vulkan_GLSLC_EXECUTABLE} -o ${spirv-file} ${input-file-abs} -MD -MT ${spirv-file} -MF ${spirv-file}.d
         DEPENDS ${input-file-abs}
-        DEPFILE ${input-file-abs}.d
+        DEPFILE ${spirv-file}.d
         COMMENT "Compiling GLSL to SPIRV: ${SHADER}"
         VERBATIM
     )

From bf2a3feb26a00127d99b08b9185b3a7a1fc30e15 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 11 Feb 2026 15:52:03 +0100
Subject: [PATCH 1312/1764] DCS: Fix undefined behavior and invalid pointer
 access

---
 Detectors/DCS/src/DataPointCreator.cxx | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/Detectors/DCS/src/DataPointCreator.cxx b/Detectors/DCS/src/DataPointCreator.cxx
index 06b0321ad2c94..0bfb5bcd7d387 100644
--- a/Detectors/DCS/src/DataPointCreator.cxx
+++ b/Detectors/DCS/src/DataPointCreator.cxx
@@ -37,10 +37,9 @@ DataPointCompositeObject createDataPointCompositeObject(const std::string& alias
 template <>
 DataPointCompositeObject createDataPointCompositeObject(const std::string& alias, float val, uint32_t seconds, uint16_t msec, uint16_t flags)
 {
-  float tmp[2];
-  tmp[0] = val;
-  tmp[1] = 0;
-  return createDPCOM(alias, reinterpret_cast<const uint64_t*>(&tmp[0]), seconds, msec, flags, DeliveryType::DPVAL_FLOAT);
+  uint64_t tmp = 0;
+  memcpy(&tmp, &val, sizeof(val));
+  return createDPCOM(alias, &tmp, seconds, msec, flags, DeliveryType::DPVAL_FLOAT);
 }
 
 template <>
@@ -54,36 +53,38 @@ template <>
 DataPointCompositeObject createDataPointCompositeObject(const std::string& alias, uint32_t val, uint32_t seconds, uint16_t msec, uint16_t flags)
 {
   uint64_t tmp{val};
-  return createDPCOM(alias, reinterpret_cast<const uint64_t*>(&tmp), seconds, msec, flags, DeliveryType::DPVAL_UINT);
+  return createDPCOM(alias, &tmp, seconds, msec, flags, DeliveryType::DPVAL_UINT);
 }
 
 template <>
 DataPointCompositeObject createDataPointCompositeObject(const std::string& alias, long long val, uint32_t seconds, uint16_t msec, uint16_t flags)
 {
   uint64_t tmp{static_cast<uint64_t>(val)};
-  return createDPCOM(alias, reinterpret_cast<const uint64_t*>(&tmp), seconds, msec, flags, DeliveryType::DPVAL_UINT);
+  return createDPCOM(alias, &tmp, seconds, msec, flags, DeliveryType::DPVAL_UINT);
 }
 
 template <>
 DataPointCompositeObject createDataPointCompositeObject(const std::string& alias, char val, uint32_t seconds, uint16_t msec, uint16_t flags)
 {
-  return createDPCOM(alias, reinterpret_cast<const uint64_t*>(&val), seconds, msec, flags, DeliveryType::DPVAL_CHAR);
+  uint64_t tmp = 0;
+  memcpy(&tmp, &val, 1);
+  return createDPCOM(alias, &tmp, seconds, msec, flags, DeliveryType::DPVAL_CHAR);
 }
 
 template <>
 DataPointCompositeObject createDataPointCompositeObject(const std::string& alias, bool val, uint32_t seconds, uint16_t msec, uint16_t flags)
 {
   uint64_t tmp{val};
-  return createDPCOM(alias, reinterpret_cast<const uint64_t*>(&tmp), seconds, msec, flags, DeliveryType::DPVAL_BOOL);
+  return createDPCOM(alias, &tmp, seconds, msec, flags, DeliveryType::DPVAL_BOOL);
 }
 
 template <>
 DataPointCompositeObject createDataPointCompositeObject(const std::string& alias, std::string val, uint32_t seconds, uint16_t msec, uint16_t flags)
 {
   constexpr int N{56};
-  char str[N];
-  strncpy(str, val.c_str(), N);
-  return createDPCOM(alias, reinterpret_cast<const uint64_t*>(&str[0]), seconds, msec, flags, DeliveryType::DPVAL_STRING);
+  uint64_t tmp[N / sizeof(uint64_t)];
+  strncpy((char*)tmp, val.c_str(), N);
+  return createDPCOM(alias, tmp, seconds, msec, flags, DeliveryType::DPVAL_STRING);
 }
 
 } // namespace o2::dcs

From 6ef43cf21196279d3c6e7cb507e51e4274b015ac Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 12 Feb 2026 09:01:29 +0100
Subject: [PATCH 1313/1764] ITS3: load chip response functions from ccdb
 (#15051)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS3/macros/test/CheckChipResponseFile.C  | 23 ++++++++-----------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C b/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
index 32d5bad87ce21..5bc053c516079 100644
--- a/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
+++ b/Detectors/Upgrades/ITS3/macros/test/CheckChipResponseFile.C
@@ -22,6 +22,7 @@
 #include <vector>
 #include <string>
 
+#include "CCDB/BasicCCDBManager.h"
 #define ENABLE_UPGRADES
 #include "ITSMFTSimulation/AlpideSimResponse.h"
 #include "ITS3Simulation/ChipSimResponse.h"
@@ -37,16 +38,12 @@ double cm2um(double cm) { return cm * 1e+4; }
 
 std::unique_ptr<o2::its3::ChipSimResponse> mAlpSimResp0, mAlpSimResp1, mAptSimResp1;
 
-std::unique_ptr<o2::its3::ChipSimResponse> loadResponse(const std::string& fileName, const std::string& respName)
+std::unique_ptr<o2::its3::ChipSimResponse> loadResponse(const std::string& path)
 {
-  TFile* f = TFile::Open(fileName.data());
-  if (!f) {
-    std::cerr << fileName << " not found" << std::endl;
-    return nullptr;
-  }
-  auto base = f->Get<o2::itsmft::AlpideSimResponse>(respName.c_str());
+  auto& cdb = o2::ccdb::BasicCCDBManager::instance();
+  o2::itsmft::AlpideSimResponse* base = cdb.get<o2::itsmft::AlpideSimResponse>(path);
   if (!base) {
-    std::cerr << respName << " not found in " << fileName << std::endl;
+    std::cerr << path << " not found in " << '\n';
     return nullptr;
   }
   return std::make_unique<o2::its3::ChipSimResponse>(base);
@@ -54,24 +51,24 @@ std::unique_ptr<o2::its3::ChipSimResponse> loadResponse(const std::string& fileN
 
 void LoadRespFunc()
 {
-  std::string AptsFile = "$(O2_ROOT)/share/Detectors/Upgrades/ITS3/data/ITS3ChipResponseData/APTSResponseData.root";
-  std::string AlpideFile = "$(O2_ROOT)/share/Detectors/ITSMFT/data/AlpideResponseData/AlpideResponseData.root";
+  auto& cdb = o2::ccdb::BasicCCDBManager::instance();
+  cdb.setURL("https://alice-ccdb.cern.ch/");
 
   std::cout << "=====================\n";
   LOGP(info, "ALPIDE Vbb=0V response");
-  mAlpSimResp0 = loadResponse(AlpideFile, "response0"); // Vbb=0V
+  mAlpSimResp0 = loadResponse("ITSMFT/Calib/ALPIDEResponseVbb0"); // Vbb=0V
   mAlpSimResp0->computeCentreFromData();
   mAlpSimResp0->print();
   LOGP(info, "Response Centre {}", mAlpSimResp0->getRespCentreDep());
   std::cout << "=====================\n";
   LOGP(info, "ALPIDE Vbb=-3V response");
-  mAlpSimResp1 = loadResponse(AlpideFile, "response1"); // Vbb=-3V
+  mAlpSimResp1 = loadResponse("ITSMFT/Calib/ALPIDEResponseVbbM3"); // Vbb=-3V
   mAlpSimResp1->computeCentreFromData();
   mAlpSimResp1->print();
   LOGP(info, "Response Centre {}", mAlpSimResp1->getRespCentreDep());
   std::cout << "=====================\n";
   LOGP(info, "APTS response");
-  mAptSimResp1 = loadResponse(AptsFile, "response1"); // APTS
+  mAptSimResp1 = loadResponse("IT3/Calib/APTSResponse"); // APTS
   mAptSimResp1->computeCentreFromData();
   mAptSimResp1->print();
   LOGP(info, "Response Centre {}", mAptSimResp1->getRespCentreDep());

From 93cae7b66005fa79f1ecb5bd58e49d52e7cb33e8 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 12 Feb 2026 09:01:54 +0100
Subject: [PATCH 1314/1764] ITS3: split longerons, improving stepping speed
 (#15052)

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS3/base/include/ITS3Base/SpecsV2.h      |  2 +-
 .../include/ITS3Simulation/ITS3Layer.h        |  5 +-
 .../ITS3/simulation/src/ITS3Layer.cxx         | 68 +++++++++----------
 3 files changed, 37 insertions(+), 38 deletions(-)

diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
index a7422c55e72b8..937fa8d2e982c 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
@@ -104,7 +104,7 @@ namespace carbonfoam
 // TODO: Waiting for the further information from WP5(Corrado)
 constexpr double HringLength{6.0 * mm};                                    // from blueprint
 constexpr double longeronsWidth{2.0 * mm};                                 // what is the height of the longerons?
-constexpr double longeronsLength{segment::length - 2 * HringLength};       // 263mm from blueprint; overrriden to be consitent
+constexpr double longeronsLength{segment::length - (2 * HringLength)};     // 263mm from blueprint; overrriden to be consitent
 constexpr double edgeBetwChipAndFoam{1.0 * mm};                            // from blueprint but not used cause forms are already overlapping
 constexpr double gapBetwHringsLongerons{0.05 * mm};                        // from blueprint
 constexpr std::array<int, 3> nHoles{11, 11, 11};                           // how many holes for each layer?
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h
index fd9195f9ee228..f45a4469ae2b8 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/ITS3Layer.h
@@ -26,7 +26,7 @@ namespace o2::its3
 {
 
 /// This class defines the geometry for the ITS3 IB layers.
-class ITS3Layer
+class ITS3Layer final
 {
   // The hierarchy will be the following:
   // ITS2          ->       ITS3
@@ -76,7 +76,6 @@ class ITS3Layer
   void buildPartial(TGeoVolume* motherVolume, TGeoMatrix* mat = nullptr, BuildLevel level = BuildLevel::kAll, bool createMaterials = false);
 
  private:
-  bool mBuilt{false};
   TGeoMedium* mSilicon{nullptr};
   TGeoMedium* mAir{nullptr};
   TGeoMedium* mCarbon{nullptr};
@@ -91,7 +90,7 @@ class ITS3Layer
   void createSegment();
   void createChip();
   void createCarbonForm();
-  TGeoCompositeShape* getHringShape(TGeoTubeSeg* Hring);
+  TGeoCompositeShape* getHringShape(TGeoTubeSeg* Hring) const;
   void createLayerImpl();
 
   uint8_t mNLayer{0}; // Layer number
diff --git a/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx b/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
index e0be011096450..c0f8fdc19d03b 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/ITS3Layer.cxx
@@ -67,11 +67,11 @@ void ITS3Layer::createLayer(TGeoVolume* motherVolume)
   // Create one layer of ITS3 and attach it to the motherVolume.
   getMaterials();
   createLayerImpl();
-  mBuilt = true;
 
   if (motherVolume == nullptr) {
     return;
   }
+
   // Add it to motherVolume
   auto* trans = new TGeoTranslation(0, 0, -constants::segment::lengthSensitive / 2.);
   motherVolume->AddNode(mLayer, 0, trans);
@@ -122,8 +122,8 @@ void ITS3Layer::createTile()
   mTile->AddNode(mPixelArray, 0, phiRotPixelArray);
 
   // Biasing
-  double biasPhi1 = constants::pixelarray::width / mR * o2m::Rad2Deg + readoutPhi2;
-  double biasPhi2 = biasing::width / mR * o2m::Rad2Deg + biasPhi1;
+  double biasPhi1 = (constants::pixelarray::width / mR * o2m::Rad2Deg) + readoutPhi2;
+  double biasPhi2 = (biasing::width / mR * o2m::Rad2Deg) + biasPhi1;
   auto biasing = new TGeoTubeSeg(mRmin, mRmax, biasing::length / 2, biasPhi1, biasPhi2);
   auto biasingVol = new TGeoVolume(Form("biasing%d", mNLayer), biasing, mSilicon);
   biasingVol->SetLineColor(biasing::color);
@@ -131,9 +131,9 @@ void ITS3Layer::createTile()
   mTile->AddNode(biasingVol, 0);
 
   // Power Switches are on the side right side of the pixel array and biasing.
-  auto zMovePowerSwitches = new TGeoTranslation(0, 0, +powerswitches::length / 2. + constants::pixelarray::length / 2.);
+  auto zMovePowerSwitches = new TGeoTranslation(0, 0, (+powerswitches::length / 2.) + (constants::pixelarray::length / 2.));
   double powerPhi1 = readoutPhi2;
-  double powerPhi2 = powerswitches::width / mR * o2m::Rad2Deg + powerPhi1;
+  double powerPhi2 = (powerswitches::width / mR * o2m::Rad2Deg) + powerPhi1;
   auto powerSwitches = new TGeoTubeSeg(mRmin, mRmax, powerswitches::length / 2, powerPhi1, powerPhi2);
   auto powerSwitchesVol = new TGeoVolume(Form("powerswitches%d", mNLayer), powerSwitches, mSilicon);
   powerSwitchesVol->SetLineColor(powerswitches::color);
@@ -166,7 +166,7 @@ void ITS3Layer::createRSU()
   // Lower Left
   auto zMoveLL1 = new TGeoTranslation(0, 0, constants::tile::length);
   auto zMoveLL2 = new TGeoTranslation(0, 0, constants::tile::length * 2.);
-  auto zMoveLLDB = new TGeoTranslation(0, 0, -databackbone::length / 2. - constants::pixelarray::length / 2.);
+  auto zMoveLLDB = new TGeoTranslation(0, 0, (-databackbone::length / 2.) - (constants::pixelarray::length / 2.));
   // Lets attach the tiles to the QS.
   mRSU->AddNode(mTile, nCopyRSU++, nullptr);
   mRSU->AddNode(mTile, nCopyRSU++, zMoveLL1);
@@ -175,9 +175,9 @@ void ITS3Layer::createRSU()
 
   // Lower Right
   auto zMoveLR0 = new TGeoTranslation(0, 0, +length / 2.);
-  auto zMoveLR1 = new TGeoTranslation(0, 0, constants::tile::length + length / 2.);
-  auto zMoveLR2 = new TGeoTranslation(0, 0, constants::tile::length * 2. + length / 2.);
-  auto zMoveLRDB = new TGeoTranslation(0, 0, -databackbone::length / 2. + length / 2. - constants::pixelarray::length / 2.);
+  auto zMoveLR1 = new TGeoTranslation(0, 0, constants::tile::length + (length / 2.));
+  auto zMoveLR2 = new TGeoTranslation(0, 0, (constants::tile::length * 2.) + (length / 2.));
+  auto zMoveLRDB = new TGeoTranslation(0, 0, (-databackbone::length / 2.) + (length / 2.) - (constants::pixelarray::length / 2.));
   // Lets attach the tiles to the QS.
   mRSU->AddNode(mTile, nCopyRSU++, zMoveLR0);
   mRSU->AddNode(mTile, nCopyRSU++, zMoveLR1);
@@ -192,7 +192,7 @@ void ITS3Layer::createRSU()
   // Upper Left
   auto zMoveUL1 = new TGeoCombiTrans(0, 0, constants::tile::length, rot);
   auto zMoveUL2 = new TGeoCombiTrans(0, 0, constants::tile::length * 2., rot);
-  auto zMoveULDB = new TGeoCombiTrans(0, 0, -databackbone::length / 2. - constants::pixelarray::length / 2., rot);
+  auto zMoveULDB = new TGeoCombiTrans(0, 0, (-databackbone::length / 2.) - (constants::pixelarray::length / 2.), rot);
   // Lets attach the tiles to the QS.
   mRSU->AddNode(mTile, nCopyRSU++, rot);
   mRSU->AddNode(mTile, nCopyRSU++, zMoveUL1);
@@ -201,9 +201,9 @@ void ITS3Layer::createRSU()
 
   // Upper Right
   auto zMoveUR0 = new TGeoCombiTrans(0, 0, +length / 2., rot);
-  auto zMoveUR1 = new TGeoCombiTrans(0, 0, constants::tile::length + length / 2., rot);
-  auto zMoveUR2 = new TGeoCombiTrans(0, 0, constants::tile::length * 2. + length / 2., rot);
-  auto zMoveURDB = new TGeoCombiTrans(0, 0, -databackbone::length / 2. + length / 2. - constants::pixelarray::length / 2., rot);
+  auto zMoveUR1 = new TGeoCombiTrans(0, 0, constants::tile::length + (length / 2.), rot);
+  auto zMoveUR2 = new TGeoCombiTrans(0, 0, (constants::tile::length * 2.) + (length / 2.), rot);
+  auto zMoveURDB = new TGeoCombiTrans(0, 0, (-databackbone::length / 2.) + (length / 2.) - (constants::pixelarray::length / 2.), rot);
   // Lets attach the tiles to the QS.
   mRSU->AddNode(mTile, nCopyRSU++, zMoveUR0);
   mRSU->AddNode(mTile, nCopyRSU++, zMoveUR1);
@@ -225,9 +225,9 @@ void ITS3Layer::createSegment()
   mSegment = new TGeoVolumeAssembly(its3TGeo::getITS3SegmentPattern(mNLayer));
   mSegment->VisibleDaughters();
 
-  for (size_t i{0}; i < nRSUs; ++i) {
-    auto zMove = new TGeoTranslation(0, 0, +i * constants::rsu::length + constants::rsu::databackbone::length + constants::pixelarray::length / 2.);
-    mSegment->AddNode(mRSU, i, zMove);
+  for (unsigned int i{0}; i < nRSUs; ++i) {
+    auto zMove = new TGeoTranslation(0, 0, (i * constants::rsu::length) + constants::rsu::databackbone::length + (constants::pixelarray::length / 2.));
+    mSegment->AddNode(mRSU, (int)i, zMove);
   }
 
   // LEC
@@ -242,7 +242,7 @@ void ITS3Layer::createSegment()
   mSegment->AddNode(lecVol, 0, zMoveLEC);
 
   // REC; reuses lecPhi1,2
-  auto zMoveREC = new TGeoTranslation(0, 0, nRSUs * constants::rsu::length + rec::length / 2.);
+  auto zMoveREC = new TGeoTranslation(0, 0, (nRSUs * constants::rsu::length) + (rec::length / 2.));
   auto rec =
     new TGeoTubeSeg(mRmin, mRmax, rec::length / 2., lecPhi1, lecPhi2);
   auto recVol = new TGeoVolume(Form("rec%d", mNLayer), rec, mSilicon);
@@ -266,11 +266,11 @@ void ITS3Layer::createChip()
   auto phiOffset = constants::segment::width / mR * o2m::Rad2Deg;
   for (unsigned int i{0}; i < constants::nSegments[mNLayer]; ++i) {
     auto rot = new TGeoRotation(Form("its3PhiSegmentOffset_%d_%d", mNLayer, i), 0, 0, phiOffset * i);
-    mChip->AddNode(mSegment, i, rot);
+    mChip->AddNode(mSegment, (int)i, rot);
   }
 
   // Add metal stack positioned radially outward
-  auto zMoveMetal = new TGeoTranslation(0, 0, constants::metalstack::length / 2. - constants::segment::lec::length);
+  auto zMoveMetal = new TGeoTranslation(0, 0, (constants::metalstack::length / 2.) - constants::segment::lec::length);
   auto metal = new TGeoTubeSeg(mRmax, mRmax + constants::metalstack::thickness, constants::metalstack::length / 2., 0, constants::nSegments[mNLayer] * phiOffset);
   auto metalVol = new TGeoVolume(Form("metal%d", mNLayer), metal, mCopper);
   metalVol->SetLineColor(constants::metalstack::color);
@@ -296,7 +296,7 @@ void ITS3Layer::createCarbonForm()
     dRadius = constants::carbonfoam::thicknessOuterFoam; // TODO: lack of carbon foam radius for layer 2, use 0.7 cm as a temporary value
   }
   double phiSta = edgeBetwChipAndFoam / (0.5 * constants::radii[mNLayer + 1] + constants::radii[mNLayer]) * o2m::Rad2Deg;
-  double phiEnd = (constants::nSegments[mNLayer] * constants::segment::width) / constants::radii[mNLayer] * o2m::Rad2Deg - phiSta;
+  double phiEnd = ((constants::nSegments[mNLayer] * constants::segment::width) / constants::radii[mNLayer] * o2m::Rad2Deg) - phiSta;
   double phiLongeronsCover = longeronsWidth / (0.5 * constants::radii[mNLayer + 1] + constants::radii[mNLayer]) * o2m::Rad2Deg;
 
   // H-rings foam
@@ -308,35 +308,37 @@ void ITS3Layer::createCarbonForm()
   HringCVol->SetLineColor(color);
   auto HringAVol = new TGeoVolume(Form("hringA%d", mNLayer), HringAWithHoles, mCarbon);
   HringAVol->SetLineColor(color);
-  auto zMoveHringC = new TGeoTranslation(0, 0, -constants::segment::lec::length + HringLength / 2.);
-  auto zMoveHringA = new TGeoTranslation(0, 0, -constants::segment::lec::length + HringLength / 2. + constants::segment::length - HringLength);
+  auto zMoveHringC = new TGeoTranslation(0, 0, -constants::segment::lec::length + (HringLength / 2.));
+  auto zMoveHringA = new TGeoTranslation(0, 0, -constants::segment::lec::length + (HringLength / 2.) + constants::segment::length - HringLength);
 
   // Longerons are made by same material
+  // added separately to make navigation faster
   [[maybe_unused]] auto longeronR = new TGeoTubeSeg(Form("longeronR%d", mNLayer), mRmax, mRmax + dRadius, longeronsLength / 2., phiSta, phiSta + phiLongeronsCover);
   [[maybe_unused]] auto longeronL = new TGeoTubeSeg(Form("longeronL%d", mNLayer), mRmax, mRmax + dRadius, longeronsLength / 2., phiEnd - phiLongeronsCover, phiEnd);
-  TString nameLongerons = Form("longeronR%d + longeronL%d", mNLayer, mNLayer);
-  auto longerons = new TGeoCompositeShape(nameLongerons);
-  auto longeronsVol = new TGeoVolume(Form("longerons%d", mNLayer), longerons, mCarbon);
-  longeronsVol->SetLineColor(color);
-  auto zMoveLongerons = new TGeoTranslation(0, 0, -constants::segment::lec::length + constants::segment::length / 2.);
+  auto longeronRVol = new TGeoVolume(Form("longeronR%d", mNLayer), longeronR, mCarbon);
+  longeronRVol->SetLineColor(color);
+  auto longeronLVol = new TGeoVolume(Form("longeronL%d", mNLayer), longeronL, mCarbon);
+  longeronLVol->SetLineColor(color);
+  auto zMoveLongerons = new TGeoTranslation(0, 0, -constants::segment::lec::length + (constants::segment::length / 2.));
 
   mCarbonForm->AddNode(HringCVol, 0, zMoveHringC);
   mCarbonForm->AddNode(HringAVol, 0, zMoveHringA);
-  mCarbonForm->AddNode(longeronsVol, 0, zMoveLongerons);
+  mCarbonForm->AddNode(longeronRVol, 0, zMoveLongerons);
+  mCarbonForm->AddNode(longeronLVol, 0, zMoveLongerons);
   mCarbonForm->AddNode(mChip, 0);
 }
 
-TGeoCompositeShape* ITS3Layer::getHringShape(TGeoTubeSeg* Hring)
+TGeoCompositeShape* ITS3Layer::getHringShape(TGeoTubeSeg* Hring) const
 {
   // Function to dig holes in H-rings
   using namespace constants::carbonfoam;
   double stepPhiHoles = (Hring->GetPhi2() - Hring->GetPhi1()) / (nHoles[mNLayer]);
-  double phiHolesSta = Hring->GetPhi1() + stepPhiHoles / 2.;
+  double phiHolesSta = Hring->GetPhi1() + (stepPhiHoles / 2.);
   double radiusHring = 0.5 * (Hring->GetRmin() + Hring->GetRmax());
   TGeoCompositeShape* HringWithHoles = nullptr;
   TString nameAllHoles = "";
   for (int iHoles = 0; iHoles < nHoles[mNLayer]; iHoles++) {
-    double phiHole = phiHolesSta + stepPhiHoles * iHoles;
+    double phiHole = phiHolesSta + (stepPhiHoles * iHoles);
     TString nameHole = Form("hole_%d_%d", iHoles, mNLayer);
     [[maybe_unused]] auto hole = new TGeoTube(nameHole, 0, radiusHoles[mNLayer], 3 * Hring->GetDz());
     // move hole to the hring radius
@@ -376,9 +378,7 @@ void ITS3Layer::createLayerImpl()
 
 void ITS3Layer::buildPartial(TGeoVolume* motherVolume, TGeoMatrix* mat, BuildLevel level, bool createMaterials)
 {
-  if (!mBuilt) {
-    getMaterials(createMaterials);
-  }
+  getMaterials(createMaterials);
   switch (level) {
     case BuildLevel::kPixelArray:
       createPixelArray();

From f926fb83e768fb8b60656bc8e9ed668f8debb7c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 12 Feb 2026 10:34:03 +0100
Subject: [PATCH 1315/1764] MUON: Delete unused files (#15027)

---
 .../Detectors/MUON/MCH/src/DsChannelGroup.cxx |  16 -
 .../SegContour/src/SegmentationSVGWriter.cxx  | 117 ---
 .../Raw/Encoder/Payload/RefBufferCRUBare.cxx  | 938 ------------------
 .../Encoder/Payload/RefBufferCRUUserLogic.cxx |  67 --
 .../Raw/Encoder/Payload/RefBufferGBTBare.cxx  | 239 -----
 .../Encoder/Payload/RefBufferGBTUserLogic.cxx |  34 -
 .../MUON/MID/Filtering/test/bench_Filter.cxx  |  98 --
 .../include/MIDWorkflow/DecodedDataDumpSpec.h |  30 -
 .../include/MIDWorkflow/RawAggregatorSpec.h   |  30 -
 .../MID/Workflow/src/DecodedDataDumpSpec.cxx  |  84 --
 .../src/decoded-data-dump-workflow.cxx        |  65 --
 11 files changed, 1718 deletions(-)
 delete mode 100644 DataFormats/Detectors/MUON/MCH/src/DsChannelGroup.cxx
 delete mode 100644 Detectors/MUON/MCH/Mapping/SegContour/src/SegmentationSVGWriter.cxx
 delete mode 100644 Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferCRUBare.cxx
 delete mode 100644 Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferCRUUserLogic.cxx
 delete mode 100644 Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferGBTBare.cxx
 delete mode 100644 Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferGBTUserLogic.cxx
 delete mode 100644 Detectors/MUON/MID/Filtering/test/bench_Filter.cxx
 delete mode 100644 Detectors/MUON/MID/Workflow/include/MIDWorkflow/DecodedDataDumpSpec.h
 delete mode 100644 Detectors/MUON/MID/Workflow/include/MIDWorkflow/RawAggregatorSpec.h
 delete mode 100644 Detectors/MUON/MID/Workflow/src/DecodedDataDumpSpec.cxx
 delete mode 100644 Detectors/MUON/MID/Workflow/src/decoded-data-dump-workflow.cxx

diff --git a/DataFormats/Detectors/MUON/MCH/src/DsChannelGroup.cxx b/DataFormats/Detectors/MUON/MCH/src/DsChannelGroup.cxx
deleted file mode 100644
index bcf10d74c95ff..0000000000000
--- a/DataFormats/Detectors/MUON/MCH/src/DsChannelGroup.cxx
+++ /dev/null
@@ -1,16 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "DataFormatsMCH/DsChannelGroup.h"
-
-std::string o2::mch::DsChannelId() const
-{
-}
diff --git a/Detectors/MUON/MCH/Mapping/SegContour/src/SegmentationSVGWriter.cxx b/Detectors/MUON/MCH/Mapping/SegContour/src/SegmentationSVGWriter.cxx
deleted file mode 100644
index b614346f1a42a..0000000000000
--- a/Detectors/MUON/MCH/Mapping/SegContour/src/SegmentationSVGWriter.cxx
+++ /dev/null
@@ -1,117 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-///
-/// @author  Laurent Aphecetche
-
-#include "MCHMappingSegContour/CathodeSegmentationSVGWriter.h"
-#include "MCHMappingInterface/CathodeSegmentation.h"
-#include "MCHMappingSegContour/CathodeSegmentationContours.h"
-#include "MCHContour/SVGWriter.h"
-#include <ostream>
-
-using namespace o2::mch::contour;
-
-namespace o2
-{
-namespace mch
-{
-namespace mapping
-{
-
-std::string svgCathodeSegmentationDefaultStyle()
-{
-  return R"(
-.pads {
-  fill: #EEEEEE;
-  stroke-width: 0.025px;
-  stroke: #AAAAAA;
-}
-.padchannels {
-  font-size: 0.4px;
-  font-family: arial;
-  fill: blue;
-  text-anchor: middle;
-}
-.dualsampas {
-  fill:none;
-  stroke-width: 0.025px;
-  stroke: #333333;
-}
-.detectionelements {
-  fill:none;
-  stroke-width:0.025px;
-  stroke: #000000;
-}
-.testpoints {
-  fill:red;
-  stroke-width:0.025px;
-  stroke: black;
-  opacity: 0.5;
-}
-)";
-}
-
-void svgCathodeSegmentation(const CathodeSegmentation& seg, SVGWriter& w, bool showdes, bool showdualsampas, bool showpads,
-                            bool showpadchannels)
-{
-  std::vector<Contour<double>> dualSampaContours = getDualSampaContours(seg);
-  std::vector<std::vector<Polygon<double>>> dualSampaPads = getPadPolygons(seg);
-  std::vector<std::vector<int>> dualSampaPadChannels = getPadChannels(seg);
-
-  if (dualSampaPadChannels.size() != dualSampaPads.size()) {
-    throw std::runtime_error("gouze");
-  }
-
-  auto deContour = getEnvelop(seg);
-  auto box = getBBox(seg);
-
-  if (showpads) {
-    w.svgGroupStart("pads");
-    for (auto& dsp : dualSampaPads) {
-      for (auto& p : dsp) {
-        w.polygon(p);
-      }
-    }
-    w.svgGroupEnd();
-  }
-
-  if (showpadchannels) {
-    w.svgGroupStart("padchannels");
-    for (auto i = 0; i < dualSampaPads.size(); ++i) {
-      auto& dsp = dualSampaPads[i];
-      auto& dspch = dualSampaPadChannels[i];
-      for (auto j = 0; j < dsp.size(); j++) {
-        auto bbox = getBBox(dsp[j]);
-        w.text(std::to_string(dspch[j]), bbox.xcenter(),
-               bbox.ymax() - 0.05 * bbox.height()); // SVG text y position is the bottom of the text
-      }
-    }
-    w.svgGroupEnd();
-  }
-
-  if (showdualsampas) {
-    w.svgGroupStart("dualsampas");
-    for (auto& dsp : dualSampaContours) {
-      w.contour(dsp);
-    }
-    w.svgGroupEnd();
-  }
-
-  if (showdes) {
-    w.svgGroupStart("detectionelements");
-    w.contour(deContour);
-  }
-}
-
-} // namespace mapping
-} // namespace mch
-} // namespace o2
diff --git a/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferCRUBare.cxx b/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferCRUBare.cxx
deleted file mode 100644
index 52e4581da1a71..0000000000000
--- a/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferCRUBare.cxx
+++ /dev/null
@@ -1,938 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "RefBuffers.h"
-#include <array>
-#include "MCHRawCommon/DataFormats.h"
-
-extern std::array<const uint8_t, 10944> REF_BUFFER_CRU_BARE_CHARGESUM;
-template <>
-gsl::span<const std::byte> REF_BUFFER_CRU<o2::mch::raw::BareFormat, o2::mch::raw::ChargeSumMode>()
-{
-  return gsl::span<const std::byte>(reinterpret_cast<const std::byte*>(&REF_BUFFER_CRU_BARE_CHARGESUM[0]), REF_BUFFER_CRU_BARE_CHARGESUM.size());
-}
-std::array<const uint8_t, 10944> REF_BUFFER_CRU_BARE_CHARGESUM = {
-  // clang-format off
-0x04, 0x40, 0x00, 0x00, 0x1B, 0x01, 0x00, 0x00, 0xB0, 0x12, 0xB0, 0x12, 
-0x00, 0x00, 0x0D, 0x10, 0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 
-0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFE, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAB, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA9, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFE, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAB, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA9, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFC, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xA8, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xA8, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x00, 0x00, 
-0x1B, 0x01, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x00, 0x01, 0x0D, 0x10, 
-0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 0x03, 0x08, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x04, 0x40, 0x00, 0x00, 0x1E, 0x01, 0x00, 0x00, 0x40, 0x0A, 0x40, 0x0A, 
-0x00, 0x00, 0x0F, 0x00, 0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 
-0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA6, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAE, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA6, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA6, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA6, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xF3, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA6, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAE, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAE, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xF3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xF3, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA6, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA2, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA6, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA2, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x00, 0x00, 
-0x1E, 0x01, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x00, 0x01, 0x0F, 0x00, 
-0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 0x03, 0x08, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x04, 0x40, 0x00, 0x00, 0x1B, 0x01, 0x00, 0x00, 0x10, 0x0D, 0x10, 0x0D, 
-0x07, 0x00, 0x0D, 0x10, 0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 
-0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFD, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAB, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFD, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFC, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA9, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA9, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFC, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFE, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAB, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA9, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xA9, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x40, 0x00, 0x00, 
-0x1B, 0x01, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x07, 0x01, 0x0D, 0x10, 
-0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 0x03, 0x08, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
-
-  // clang-format on
-};
diff --git a/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferCRUUserLogic.cxx b/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferCRUUserLogic.cxx
deleted file mode 100644
index 3c3781460f4d1..0000000000000
--- a/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferCRUUserLogic.cxx
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "RefBuffers.h"
-#include <array>
-#include "MCHRawCommon/DataFormats.h"
-
-extern std::array<const uint8_t, 496> REF_BUFFER_CRU_USERLOGIC_CHARGESUM;
-template <>
-gsl::span<const std::byte> REF_BUFFER_CRU<o2::mch::raw::UserLogicFormat, o2::mch::raw::ChargeSumMode>()
-{
-  return gsl::span<const std::byte>(reinterpret_cast<const std::byte*>(&REF_BUFFER_CRU_USERLOGIC_CHARGESUM[0]), REF_BUFFER_CRU_USERLOGIC_CHARGESUM.size());
-}
-std::array<const uint8_t, 496> REF_BUFFER_CRU_USERLOGIC_CHARGESUM = {
-  // clang-format off
-0x04, 0x40, 0x00, 0x00, 0x1E, 0x01, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 
-0x0F, 0x00, 0x0F, 0x00, 0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 
-0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x13, 0x01, 0xF0, 0x40, 0x55, 0x55, 0xA1, 0x00, 
-0x03, 0x12, 0x00, 0xE3, 0x46, 0x00, 0xA0, 0x00, 0x01, 0x60, 0xD0, 0x00, 
-0x00, 0x58, 0xA2, 0x00, 0x04, 0x40, 0xBB, 0x11, 0x00, 0x01, 0xA0, 0x00, 
-0x18, 0x14, 0x02, 0x40, 0x90, 0x04, 0xA0, 0x00, 0x70, 0x6F, 0x04, 0x40, 
-0x00, 0x18, 0xA0, 0x00, 0xA3, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA0, 0x00, 
-0xED, 0xDE, 0xED, 0xFE, 0xED, 0xDE, 0xED, 0xFE, 0x04, 0x40, 0x00, 0x00, 
-0x1E, 0x01, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x0F, 0x01, 0x0F, 0x00, 
-0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 0x03, 0x08, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x04, 0x40, 0x00, 0x00, 0x1B, 0x01, 0x00, 0x00, 0xF0, 0x00, 0xF0, 0x00, 
-0x0F, 0x00, 0x0D, 0x10, 0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 
-0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x13, 0x01, 0xF0, 0x40, 0x55, 0x55, 0x81, 0x38, 
-0x1A, 0x12, 0x80, 0xE0, 0x46, 0x00, 0x80, 0x38, 0x01, 0x60, 0xA0, 0x00, 
-0x00, 0x4D, 0x82, 0x38, 0x04, 0x60, 0xB8, 0x11, 0x00, 0x01, 0x80, 0x38, 
-0x18, 0x50, 0x00, 0x80, 0x90, 0x04, 0x80, 0x38, 0x28, 0x6E, 0x04, 0x40, 
-0x00, 0x18, 0x80, 0x38, 0x1E, 0x00, 0x50, 0x21, 0x01, 0x38, 0x82, 0x38, 
-0x1B, 0x01, 0x10, 0x00, 0x06, 0x28, 0x80, 0x38, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x80, 0x38, 0xED, 0xDE, 0xED, 0xFE, 0xED, 0xDE, 0xED, 0xFE, 
-0x13, 0x01, 0xF0, 0x40, 0x55, 0x55, 0x01, 0x04, 0x03, 0x12, 0x40, 0xF6, 
-0x46, 0x00, 0x00, 0x04, 0x01, 0x60, 0x40, 0x1A, 0x00, 0x54, 0x02, 0x04, 
-0x04, 0xD0, 0xBD, 0x11, 0x00, 0x01, 0x00, 0x04, 0x18, 0xB8, 0x06, 0x00, 
-0x96, 0x04, 0x00, 0x04, 0x84, 0x6F, 0x04, 0x40, 0x00, 0x18, 0x00, 0x04, 
-0xB8, 0x01, 0xF0, 0x20, 0x01, 0x94, 0x03, 0x04, 0x1B, 0x01, 0x10, 0x00, 
-0x06, 0xC2, 0x01, 0x04, 0x00, 0x00, 0x48, 0x00, 0xE9, 0x1B, 0x01, 0x04, 
-0x00, 0x04, 0x80, 0x01, 0x73, 0x00, 0x00, 0x04, 0x48, 0x12, 0x50, 0xEA, 
-0x46, 0x00, 0x00, 0x04, 0x01, 0x60, 0x40, 0x1A, 0x00, 0x00, 0x00, 0x04, 
-0x04, 0x40, 0x00, 0x00, 0x1B, 0x01, 0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 
-0x0F, 0x01, 0x0D, 0x10, 0x39, 0x30, 0x00, 0x00, 0x39, 0x30, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xA6, 0x02, 0xA6, 0x02, 
-0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00
-  // clang-format on
-};
diff --git a/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferGBTBare.cxx b/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferGBTBare.cxx
deleted file mode 100644
index 89b1602cb0489..0000000000000
--- a/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferGBTBare.cxx
+++ /dev/null
@@ -1,239 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "RefBuffers.h"
-#include <array>
-#include "MCHRawCommon/DataFormats.h"
-
-extern std::array<const uint8_t, 2560> REF_BUFFER_GBT_BARE_CHARGESUM;
-template <>
-gsl::span<const std::byte> REF_BUFFER_GBT<o2::mch::raw::BareFormat, o2::mch::raw::ChargeSumMode>()
-{
-  return gsl::span<const std::byte>(reinterpret_cast<const std::byte*>(&REF_BUFFER_GBT_BARE_CHARGESUM[0]), REF_BUFFER_GBT_BARE_CHARGESUM.size());
-}
-std::array<const uint8_t, 2560> REF_BUFFER_GBT_BARE_CHARGESUM = {
-  // clang-format off
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x69, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xEB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xBE, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x3C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x7D, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xEB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x3C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC3, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x3C, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xAB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6A, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xA8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0xE8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xE8, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x3E, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 
-0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xAB, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x2A, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE8, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x68, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x28, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 
-0xAA, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
-0x00, 0x00, 0x00, 0x00
-  // clang-format on
-};
diff --git a/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferGBTUserLogic.cxx b/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferGBTUserLogic.cxx
deleted file mode 100644
index 9487037328ad2..0000000000000
--- a/Detectors/MUON/MCH/Raw/Encoder/Payload/RefBufferGBTUserLogic.cxx
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "RefBuffers.h"
-#include <array>
-#include "MCHRawCommon/DataFormats.h"
-
-extern std::array<const uint8_t, 96> REF_BUFFER_GBT_USERLOGIC_CHARGESUM;
-template <>
-gsl::span<const std::byte> REF_BUFFER_GBT<o2::mch::raw::UserLogicFormat, o2::mch::raw::ChargeSumMode>()
-{
-  return gsl::span<const std::byte>(reinterpret_cast<const std::byte*>(&REF_BUFFER_GBT_USERLOGIC_CHARGESUM[0]), REF_BUFFER_GBT_USERLOGIC_CHARGESUM.size());
-}
-std::array<const uint8_t, 96> REF_BUFFER_GBT_USERLOGIC_CHARGESUM = {
-  // clang-format off
-0x13, 0x01, 0xF0, 0x40, 0x55, 0x55, 0x01, 0x58, 0x0C, 0x12, 0x00, 0xA0, 
-0x50, 0x03, 0x00, 0x58, 0x01, 0x30, 0xA0, 0x00, 0x00, 0x5B, 0x02, 0x58, 
-0x04, 0xC0, 0x2F, 0xD4, 0x00, 0x01, 0x00, 0x58, 0x0C, 0x80, 0x02, 0x00, 
-0x00, 0x00, 0x00, 0x58, 0x13, 0x01, 0xF0, 0x40, 0x55, 0x55, 0x61, 0x58, 
-0x19, 0x12, 0x60, 0xAD, 0x50, 0x03, 0x60, 0x58, 0x01, 0x30, 0xD0, 0x00, 
-0x00, 0x09, 0x62, 0x58, 0x04, 0x5C, 0x28, 0xD4, 0x00, 0x01, 0x60, 0x58, 
-0x0C, 0x14, 0x02, 0x40, 0x82, 0x04, 0x60, 0x58, 0xF7, 0x0B, 0x35, 0x40, 
-0x00, 0x0C, 0x60, 0x58, 0xA3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x58
-
-  // clang-format on
-};
diff --git a/Detectors/MUON/MID/Filtering/test/bench_Filter.cxx b/Detectors/MUON/MID/Filtering/test/bench_Filter.cxx
deleted file mode 100644
index a54ea9c1733a8..0000000000000
--- a/Detectors/MUON/MID/Filtering/test/bench_Filter.cxx
+++ /dev/null
@@ -1,98 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file   MID/Tracking/test/bench_Tracker.cxx
-/// \brief  Benchmark tracker device for MID
-/// \author Diego Stocco <Diego.Stocco at cern.ch>
-/// \date   17 March 2018
-
-#include "benchmark/benchmark.h"
-#include <random>
-#include "DataFormatsMID/Cluster.h"
-#include "DataFormatsMID/Track.h"
-#include "MIDBase/HitFinder.h"
-#include "MIDBase/Mapping.h"
-#include "MIDBase/MpArea.h"
-#include "MIDTestingSimTools/TrackGenerator.h"
-#include "MIDTracking/Tracker.h"
-
-std::vector<o2::mid::Cluster> generateTestData(int nTracks, o2::mid::TrackGenerator& trackGen,
-                                               const o2::mid::HitFinder& hitFinder, const o2::mid::Mapping& mapping)
-{
-  o2::mid::Mapping::MpStripIndex stripIndex;
-  o2::mid::MpArea area;
-  std::vector<o2::mid::Cluster> clusters;
-  o2::mid::Cluster cl;
-  std::vector<o2::mid::Track> tracks = trackGen.generate(nTracks);
-  for (auto& track : tracks) {
-    for (int ich = 0; ich < 4; ++ich) {
-      auto hits = hitFinder.getLocalPositions(track, ich);
-      bool isFired = false;
-      for (auto& hit : hits) {
-        int deId = hit.deId;
-        float xPos = hit.xCoor;
-        float yPos = hit.yCoor;
-        stripIndex = mapping.stripByPosition(xPos, yPos, 0, deId, false);
-        if (!stripIndex.isValid()) {
-          continue;
-        }
-        cl.deId = deId;
-        area = mapping.stripByLocation(stripIndex.strip, 0, stripIndex.line, stripIndex.column, deId);
-        cl.yCoor = area.getCenterY();
-        cl.yErr = area.getHalfSizeY() / std::sqrt(3.);
-        stripIndex = mapping.stripByPosition(xPos, yPos, 1, deId, false);
-        area = mapping.stripByLocation(stripIndex.strip, 1, stripIndex.line, stripIndex.column, deId);
-        cl.xCoor = area.getCenterX();
-        cl.xErr = area.getHalfSizeX() / std::sqrt(3.);
-        clusters.push_back(cl);
-      } // loop on fired pos
-    }   // loop on chambers
-  }     // loop on tracks
-  return clusters;
-}
-
-static void BM_TRACKER(benchmark::State& state)
-{
-  o2::mid::GeometryTransformer geoTrans = o2::mid::createDefaultTransformer();
-  o2::mid::TrackGenerator trackGen;
-  o2::mid::HitFinder hitFinder(geoTrans);
-  o2::mid::Mapping mapping;
-  o2::mid::Tracker tracker(geoTrans);
-
-  int nTracksPerEvent = state.range(0);
-  tracker.init((state.range(1) == 1));
-  double num{0};
-
-  std::vector<o2::mid::Cluster> inputData;
-
-  for (auto _ : state) {
-    state.PauseTiming();
-    inputData = generateTestData(nTracksPerEvent, trackGen, hitFinder, mapping);
-    state.ResumeTiming();
-    tracker.process(inputData);
-    ++num;
-  }
-
-  state.counters["num"] = benchmark::Counter(num, benchmark::Counter::kIsRate);
-}
-
-static void CustomArguments(benchmark::internal::Benchmark* bench)
-{
-  for (int itrack = 1; itrack <= 8; ++itrack) {
-    for (int imethod = 0; imethod < 2; ++imethod) {
-      bench->Args({itrack, imethod});
-    }
-  }
-}
-
-BENCHMARK(BM_TRACKER)->Apply(CustomArguments)->Unit(benchmark::kNanosecond);
-
-BENCHMARK_MAIN();
diff --git a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/DecodedDataDumpSpec.h b/Detectors/MUON/MID/Workflow/include/MIDWorkflow/DecodedDataDumpSpec.h
deleted file mode 100644
index 4d104aacac15c..0000000000000
--- a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/DecodedDataDumpSpec.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file   MIDWorkflow/RawDumpSpec.h
-/// \brief  Device to dump decoded raw data
-/// \author Diego Stocco <Diego.Stocco at cern.ch>
-/// \date   17 February 2022
-
-#ifndef O2_MID_RAWDUMPSPEC_H
-#define O2_MID_RAWDUMPSPEC_H
-
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace mid
-{
-framework::DataProcessorSpec getRawDumpSpec();
-} // namespace mid
-} // namespace o2
-
-#endif // O2_MID_RAWDUMPSPEC_H
diff --git a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/RawAggregatorSpec.h b/Detectors/MUON/MID/Workflow/include/MIDWorkflow/RawAggregatorSpec.h
deleted file mode 100644
index b5a6b33530c8f..0000000000000
--- a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/RawAggregatorSpec.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file   MIDWorkflow/RawAggregatorSpec.h
-/// \brief  Data processor spec for MID raw data aggregator devices
-/// \author Diego Stocco <Diego.Stocco at cern.ch>
-/// \date   26 February 2020
-
-#ifndef O2_MID_RAWAGGREGATORSPEC_H
-#define O2_MID_RAWAGGREGATORSPEC_H
-
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace mid
-{
-framework::DataProcessorSpec getRawAggregatorSpec();
-} // namespace mid
-} // namespace o2
-
-#endif //O2_MID_RAWAGGREGATORSPEC_H
diff --git a/Detectors/MUON/MID/Workflow/src/DecodedDataDumpSpec.cxx b/Detectors/MUON/MID/Workflow/src/DecodedDataDumpSpec.cxx
deleted file mode 100644
index 77d05a8b3374f..0000000000000
--- a/Detectors/MUON/MID/Workflow/src/DecodedDataDumpSpec.cxx
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file   MID/Workflow/src/RawDumpSpec.cxx
-/// \brief  Device to dump decoded raw data
-/// \author Diego Stocco <Diego.Stocco at cern.ch>
-/// \date   17 February 2022
-
-#include "MIDWorkflow/RawDumpSpec.h"
-
-#include <fstream>
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/ControlService.h"
-#include "Framework/Logger.h"
-#include "Framework/Task.h"
-#include "fmt/format.h"
-#include "DataFormatsMID/ROBoard.h"
-#include "DataFormatsMID/ROFRecord.h"
-
-namespace o2
-{
-namespace mid
-{
-
-class RawDumpDeviceDPL
-{
- public:
-  void init(o2::framework::InitContext& ic)
-  {
-    auto outFilename = ic.options().get<std::string>("mid-dump-outfile");
-
-    if (!outFilename.empty()) {
-      mOutFile.open(outFilename.c_str());
-    }
-  }
-
-  void
-    run(o2::framework::ProcessingContext& pc)
-  {
-
-    auto data = pc.inputs().get<gsl::span<ROBoard>>("mid_decoded");
-    auto dataROFs = pc.inputs().get<gsl::span<ROFRecord>>("mid_decoded_rof");
-    std::stringstream ss;
-    for (auto& rof : dataROFs) {
-      ss << fmt::format("BCid: 0x{:x} Orbit: 0x{:x}  EvtType: {:d}", rof.interactionRecord.bc, rof.interactionRecord.orbit, static_cast<int>(rof.eventType)) << std::endl;
-      for (auto colIt = data.begin() + rof.firstEntry, end = data.begin() + rof.getEndIndex(); colIt != end; ++colIt) {
-        ss << *colIt << std::endl;
-      }
-    }
-    if (mOutFile.is_open()) {
-      mOutFile << ss.str();
-    } else {
-      LOG(info) << ss.str();
-    }
-  }
-
- private:
-  std::ofstream mOutFile; /// Output file
-};
-
-framework::DataProcessorSpec getRawDumpSpec()
-{
-  std::vector<o2::framework::InputSpec> inputSpecs{
-    o2::framework::InputSpec{"mid_decoded", header::gDataOriginMID, "DECODED", 0, o2::framework::Lifetime::Timeframe},
-    o2::framework::InputSpec{"mid_decoded_rof", header::gDataOriginMID, "DECODEDROF", 0, o2::framework::Lifetime::Timeframe}};
-
-  return o2::framework::DataProcessorSpec{
-    "MIDRawDataDumper",
-    {inputSpecs},
-    {},
-    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<RawDumpDeviceDPL>()},
-    o2::framework::Options{{"mid-dump-outfile", o2::framework::VariantType::String, "", {"Dump output to file"}}}};
-}
-
-} // namespace mid
-} // namespace o2
diff --git a/Detectors/MUON/MID/Workflow/src/decoded-data-dump-workflow.cxx b/Detectors/MUON/MID/Workflow/src/decoded-data-dump-workflow.cxx
deleted file mode 100644
index 036b63bc75338..0000000000000
--- a/Detectors/MUON/MID/Workflow/src/decoded-data-dump-workflow.cxx
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file   MID/Workflow/src/raw-dump-workflow.cxx
-/// \brief  MID raw dump workflow
-/// \author Diego Stocco <Diego.Stocco at cern.ch>
-/// \date   17 February 2022
-
-#include <string>
-#include <vector>
-#include "Framework/Variant.h"
-#include "Framework/ConfigParamSpec.h"
-#include "MIDRaw/CrateMasks.h"
-#include "MIDRaw/ElectronicsDelay.h"
-#include "MIDRaw/FEEIdConfig.h"
-#include "MIDWorkflow/RawDumpSpec.h"
-#include "MIDWorkflow/RawDecoderSpec.h"
-
-using namespace o2::framework;
-
-// add workflow options, note that customization needs to be declared before
-// including Framework/runDataProcessing
-void customize(std::vector<ConfigParamSpec>& workflowOptions)
-{
-  std::vector<ConfigParamSpec>
-    options{
-      {"feeId-config-file", VariantType::String, "", {"Filename with crate FEE ID correspondence"}},
-      {"crate-masks-file", VariantType::String, "", {"Filename with crate masks"}},
-      {"electronics-delay-file", VariantType::String, "", {"Filename with electronics delay"}}};
-  workflowOptions.insert(workflowOptions.end(), options.begin(), options.end());
-}
-
-#include "Framework/runDataProcessing.h"
-
-WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
-{
-  auto feeIdConfigFilename = cfgc.options().get<std::string>("feeId-config-file");
-  o2::mid::FEEIdConfig feeIdConfig;
-  if (!feeIdConfigFilename.empty()) {
-    feeIdConfig = o2::mid::FEEIdConfig(feeIdConfigFilename.c_str());
-  }
-  auto crateMasksFilename = cfgc.options().get<std::string>("crate-masks-file");
-  o2::mid::CrateMasks crateMasks;
-  if (!crateMasksFilename.empty()) {
-    crateMasks = o2::mid::CrateMasks(crateMasksFilename.c_str());
-  }
-  auto electronicsDelayFilename = cfgc.options().get<std::string>("electronics-delay-file");
-  o2::mid::ElectronicsDelay electronicsDelay;
-  if (!electronicsDelayFilename.empty()) {
-    electronicsDelay = o2::mid::readElectronicsDelay(electronicsDelayFilename.c_str());
-  }
-
-  WorkflowSpec specs;
-  specs.emplace_back(o2::mid::getRawDecoderSpec(true, feeIdConfig, crateMasks, electronicsDelay, false));
-  specs.emplace_back(o2::mid::getRawDumpSpec());
-  return specs;
-}

From 87fa1f6c3befc55da9d538d04dab3b2811793c91 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 12 Feb 2026 11:08:37 +0100
Subject: [PATCH 1316/1764] ITSMFT: scaffolding for staggered clusterization
 (#15004)

* ITS staggered clusterization

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Simplify getMaxBCDiffToSquashBias function

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../src/StrangenessTrackingSpec.cxx           |   2 -
 Detectors/ITSMFT/ITS/workflow/CMakeLists.txt  |   2 -
 .../include/ITSWorkflow/ClustererSpec.h       |  65 ----
 .../ITS/workflow/src/ClusterWriterSpec.cxx    |  72 ----
 .../workflow/src/ClusterWriterWorkflow.cxx    |   4 +-
 .../ITSMFT/ITS/workflow/src/ClustererSpec.cxx | 218 ------------
 .../ITSMFT/ITS/workflow/src/RecoWorkflow.cxx  |   8 +-
 Detectors/ITSMFT/MFT/workflow/CMakeLists.txt  |   2 -
 .../include/MFTWorkflow/ClusterWriterSpec.h   |  31 --
 .../MFT/workflow/src/ClusterWriterSpec.cxx    |  72 ----
 .../ITSMFT/MFT/workflow/src/ClustererSpec.cxx | 212 ------------
 .../ITSMFT/MFT/workflow/src/RecoWorkflow.cxx  |   8 +-
 .../src/mft-cluster-writer-workflow.cxx       |   4 +-
 .../include/ITSMFTReconstruction/Clusterer.h  |  14 +-
 .../ITSMFTReconstruction/ClustererParam.h     |  22 +-
 .../ITSMFTReconstruction/DigitPixelReader.h   |   3 +-
 .../common/reconstruction/src/Clusterer.cxx   |  36 +-
 .../reconstruction/src/DigitPixelReader.cxx   |  11 +
 .../ITSMFT/common/workflow/CMakeLists.txt     |   2 +
 .../ITSMFTWorkflow/ClusterReaderSpec.h        |  52 ++-
 .../ITSMFTWorkflow}/ClusterWriterSpec.h       |  16 +-
 .../include/ITSMFTWorkflow}/ClustererSpec.h   |  28 +-
 .../common/workflow/src/ClusterReaderSpec.cxx | 166 +++++----
 .../common/workflow/src/ClusterWriterSpec.cxx | 107 ++++++
 .../common/workflow/src/ClustererSpec.cxx     | 325 ++++++++++++++++++
 .../ITS3/workflow/src/RecoWorkflow.cxx        |   4 +-
 26 files changed, 648 insertions(+), 838 deletions(-)
 delete mode 100644 Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClustererSpec.h
 delete mode 100644 Detectors/ITSMFT/ITS/workflow/src/ClusterWriterSpec.cxx
 delete mode 100644 Detectors/ITSMFT/ITS/workflow/src/ClustererSpec.cxx
 delete mode 100644 Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/ClusterWriterSpec.h
 delete mode 100644 Detectors/ITSMFT/MFT/workflow/src/ClusterWriterSpec.cxx
 delete mode 100644 Detectors/ITSMFT/MFT/workflow/src/ClustererSpec.cxx
 rename Detectors/ITSMFT/{ITS/workflow/include/ITSWorkflow => common/workflow/include/ITSMFTWorkflow}/ClusterWriterSpec.h (73%)
 rename Detectors/ITSMFT/{MFT/workflow/include/MFTWorkflow => common/workflow/include/ITSMFTWorkflow}/ClustererSpec.h (64%)
 create mode 100644 Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
 create mode 100644 Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx

diff --git a/Detectors/GlobalTrackingWorkflow/src/StrangenessTrackingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/StrangenessTrackingSpec.cxx
index 849964aeaf871..e313940b0a91e 100644
--- a/Detectors/GlobalTrackingWorkflow/src/StrangenessTrackingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/StrangenessTrackingSpec.cxx
@@ -17,10 +17,8 @@
 #include "DataFormatsGlobalTracking/RecoContainer.h"
 #include "StrangenessTracking/StrangenessTrackingConfigParam.h"
 #include "GlobalTrackingWorkflow/StrangenessTrackingSpec.h"
-#include "ITSWorkflow/ClusterWriterSpec.h"
 #include "ITSWorkflow/TrackerSpec.h"
 #include "ITSWorkflow/TrackReaderSpec.h"
-#include "ITSMFTWorkflow/ClusterReaderSpec.h"
 #include "Framework/CCDBParamSpec.h"
 #include "DataFormatsParameters/GRPObject.h"
 
diff --git a/Detectors/ITSMFT/ITS/workflow/CMakeLists.txt b/Detectors/ITSMFT/ITS/workflow/CMakeLists.txt
index f0d50e59493d4..10e16e49d92b5 100644
--- a/Detectors/ITSMFT/ITS/workflow/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/workflow/CMakeLists.txt
@@ -13,8 +13,6 @@ o2_add_library(ITSWorkflow
                TARGETVARNAME targetName
                SOURCES src/RecoWorkflow.cxx
                        src/ClusterWriterWorkflow.cxx
-                       src/ClustererSpec.cxx
-                       src/ClusterWriterSpec.cxx
                        src/TrackerSpec.cxx
                        src/TrackWriterSpec.cxx
                        src/TrackReaderSpec.cxx
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClustererSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClustererSpec.h
deleted file mode 100644
index c5038c87fa467..0000000000000
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClustererSpec.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClustererSpec.h
-
-#ifndef O2_ITS_CLUSTERERDPL
-#define O2_ITS_CLUSTERERDPL
-
-#include <fstream>
-#include "DetectorsBase/GRPGeomHelper.h"
-#include "ITSMFTReconstruction/Clusterer.h"
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-
-namespace itsmft
-{
-class Clusterer;
-}
-
-namespace its
-{
-
-class ClustererDPL : public Task
-{
- public:
-  ClustererDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC) : mGGCCDBRequest(gr), mUseMC(useMC) {}
-  ~ClustererDPL() override = default;
-  void init(InitContext& ic) final;
-  void run(ProcessingContext& pc) final;
-  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
-  void endOfStream(o2::framework::EndOfStreamContext& ec) final;
-
- private:
-  void updateTimeDependentParams(ProcessingContext& pc);
-
-  int mState = 0;
-  bool mUseMC = true;
-  bool mUseClusterDictionary = true;
-  int mNThreads = 1;
-  std::unique_ptr<std::ifstream> mFile = nullptr;
-  std::unique_ptr<o2::itsmft::Clusterer> mClusterer = nullptr;
-  std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
-};
-
-/// create a processor spec
-/// run ITS cluster finder
-framework::DataProcessorSpec getClustererSpec(bool useMC);
-
-} // namespace its
-} // namespace o2
-
-#endif /* O2_ITS_CLUSTERERDPL */
diff --git a/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterSpec.cxx
deleted file mode 100644
index 4dffbaf88893c..0000000000000
--- a/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterSpec.cxx
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClusterWriterSpec.cxx
-
-#include <vector>
-
-#include "ITSWorkflow/ClusterWriterSpec.h"
-#include "DPLUtils/MakeRootTreeWriterSpec.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace its
-{
-
-template <typename T>
-using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
-using CompClusType = std::vector<o2::itsmft::CompClusterExt>;
-using PatternsType = std::vector<unsigned char>;
-using ROFrameRType = std::vector<o2::itsmft::ROFRecord>;
-using LabelsType = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
-using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
-using namespace o2::header;
-
-DataProcessorSpec getClusterWriterSpec(bool useMC)
-{
-  // Spectators for logging
-  // this is only to restore the original behavior
-  auto compClustersSize = std::make_shared<int>(0);
-  auto compClustersSizeGetter = [compClustersSize](CompClusType const& compClusters) {
-    *compClustersSize = compClusters.size();
-  };
-  auto logger = [compClustersSize](std::vector<o2::itsmft::ROFRecord> const& rofs) {
-    LOG(info) << "ITSClusterWriter pulled " << *compClustersSize << " clusters, in " << rofs.size() << " RO frames";
-  };
-  return MakeRootTreeWriterSpec("its-cluster-writer",
-                                "o2clus_its.root",
-                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Tree with ITS clusters"},
-                                BranchDefinition<CompClusType>{InputSpec{"compclus", "ITS", "COMPCLUSTERS", 0},
-                                                               "ITSClusterComp",
-                                                               compClustersSizeGetter},
-                                BranchDefinition<PatternsType>{InputSpec{"patterns", "ITS", "PATTERNS", 0},
-                                                               "ITSClusterPatt"},
-                                BranchDefinition<ROFrameRType>{InputSpec{"ROframes", "ITS", "CLUSTERSROF", 0},
-                                                               "ITSClustersROF",
-                                                               logger},
-                                BranchDefinition<LabelsType>{InputSpec{"labels", "ITS", "CLUSTERSMCTR", 0},
-                                                             "ITSClusterMCTruth",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""},
-                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", "ITS", "CLUSTERSMC2ROF", 0},
-                                                             "ITSClustersMC2ROF",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""})();
-}
-
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
index ca5db7acd63e1..aba468b3e9460 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
@@ -12,7 +12,7 @@
 /// @file   ClusterWriterWorkflow.cxx
 
 #include "ITSWorkflow/ClusterWriterWorkflow.h"
-#include "ITSWorkflow/ClusterWriterSpec.h"
+#include "ITSMFTWorkflow/ClusterWriterSpec.h"
 
 namespace o2
 {
@@ -26,7 +26,7 @@ framework::WorkflowSpec getWorkflow(bool useMC)
 {
   framework::WorkflowSpec specs;
 
-  specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
+  specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC));
 
   return specs;
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/src/ClustererSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/ClustererSpec.cxx
deleted file mode 100644
index d58e4f5d915c1..0000000000000
--- a/Detectors/ITSMFT/ITS/workflow/src/ClustererSpec.cxx
+++ /dev/null
@@ -1,218 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClustererSpec.cxx
-
-#include <vector>
-
-#include "Framework/ControlService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/CCDBParamSpec.h"
-#include "ITSWorkflow/ClustererSpec.h"
-#include "DataFormatsITSMFT/Digit.h"
-#include "ITSMFTReconstruction/ChipMappingITS.h"
-#include "ITSMFTReconstruction/ClustererParam.h"
-#include "DataFormatsITSMFT/TopologyDictionary.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/ConstMCTruthContainer.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "DataFormatsParameters/GRPObject.h"
-#include "ITSMFTReconstruction/DigitPixelReader.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
-#include "CommonConstants/LHCConstants.h"
-#include "DetectorsCommonDataFormats/DetectorNameConf.h"
-
-using namespace o2::framework;
-using namespace o2::itsmft;
-
-namespace o2
-{
-namespace its
-{
-
-void ClustererDPL::init(InitContext& ic)
-{
-  mClusterer = std::make_unique<o2::itsmft::Clusterer>();
-  mClusterer->setNChips(o2::itsmft::ChipMappingITS::getNChips());
-  mUseClusterDictionary = !ic.options().get<bool>("ignore-cluster-dictionary");
-  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
-  mNThreads = std::max(1, ic.options().get<int>("nthreads"));
-  LOGP(info, "Initialising ITSClusterer with {} threads", mNThreads);
-  mState = 1;
-}
-
-void ClustererDPL::run(ProcessingContext& pc)
-{
-  updateTimeDependentParams(pc);
-  auto digits = pc.inputs().get<gsl::span<o2::itsmft::Digit>>("digits");
-  auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
-
-  gsl::span<const o2::itsmft::MC2ROFRecord> mc2rofs;
-  gsl::span<const char> labelbuffer;
-  if (mUseMC) {
-    labelbuffer = pc.inputs().get<gsl::span<char>>("labels");
-    mc2rofs = pc.inputs().get<gsl::span<o2::itsmft::MC2ROFRecord>>("MC2ROframes");
-  }
-  o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
-
-  LOG(info) << "ITSClusterer pulled " << digits.size() << " digits, in "
-            << rofs.size() << " RO frames";
-  LOG(info) << "ITSClusterer pulled " << labels.getNElements() << " labels ";
-
-  o2::itsmft::DigitPixelReader reader;
-  reader.setSquashingDepth(mClusterer->getMaxROFDepthToSquash());
-  reader.setSquashingDist(mClusterer->getMaxRowColDiffToMask()); // Sharing same parameter/logic with masking
-  reader.setMaxBCSeparationToSquash(mClusterer->getMaxBCSeparationToSquash());
-  reader.setDigits(digits);
-  reader.setROFRecords(rofs);
-  if (mUseMC) {
-    reader.setMC2ROFRecords(mc2rofs);
-    reader.setDigitsMCTruth(labels.getIndexedSize() > 0 ? &labels : nullptr);
-  }
-  reader.init();
-  auto orig = o2::header::gDataOriginITS;
-  std::vector<o2::itsmft::CompClusterExt> clusCompVec;
-  std::vector<o2::itsmft::ROFRecord> clusROFVec;
-  std::vector<unsigned char> clusPattVec;
-
-  std::unique_ptr<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> clusterLabels;
-  if (mUseMC) {
-    clusterLabels = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
-  }
-  mClusterer->process(mNThreads, reader, &clusCompVec, &clusPattVec, &clusROFVec, clusterLabels.get());
-  pc.outputs().snapshot(Output{orig, "COMPCLUSTERS", 0}, clusCompVec);
-  pc.outputs().snapshot(Output{orig, "CLUSTERSROF", 0}, clusROFVec);
-  pc.outputs().snapshot(Output{orig, "PATTERNS", 0}, clusPattVec);
-
-  if (mUseMC) {
-    pc.outputs().snapshot(Output{orig, "CLUSTERSMCTR", 0}, *clusterLabels.get()); // at the moment requires snapshot
-    std::vector<o2::itsmft::MC2ROFRecord> clusterMC2ROframes(mc2rofs.size());
-    for (int i = mc2rofs.size(); i--;) {
-      clusterMC2ROframes[i] = mc2rofs[i]; // Simply, replicate it from digits ?
-    }
-    pc.outputs().snapshot(Output{orig, "CLUSTERSMC2ROF", 0}, clusterMC2ROframes);
-  }
-
-  // TODO: in principle, after masking "overflow" pixels the MC2ROFRecord maxROF supposed to change, nominally to minROF
-  // -> consider recalculationg maxROF
-  LOG(info) << "ITSClusterer pushed " << clusCompVec.size() << " clusters, in " << clusROFVec.size() << " RO frames";
-}
-
-///_______________________________________
-void ClustererDPL::updateTimeDependentParams(ProcessingContext& pc)
-{
-  static bool initOnceDone = false;
-  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
-  if (!initOnceDone) { // this params need to be queried only once
-    initOnceDone = true;
-    pc.inputs().get<TopologyDictionary*>("cldict"); // just to trigger the finaliseCCDB
-    pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("alppar");
-    pc.inputs().get<o2::itsmft::ClustererParam<o2::detectors::DetID::ITS>*>("cluspar");
-    mClusterer->setContinuousReadOut(o2::base::GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::ITS));
-    // settings for the fired pixel overflow masking
-    const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-    const auto& clParams = o2::itsmft::ClustererParam<o2::detectors::DetID::ITS>::Instance();
-    mClusterer->setDropHugeClusters(clParams.dropHugeClusters);
-    if (clParams.maxBCDiffToMaskBias > 0 && clParams.maxBCDiffToSquashBias > 0) {
-      LOGP(fatal, "maxBCDiffToMaskBias = {} and maxBCDiffToSquashBias = {} cannot be set at the same time. Either set masking or squashing with a BCDiff > 0", clParams.maxBCDiffToMaskBias, clParams.maxBCDiffToSquashBias);
-    }
-    auto nbc = clParams.maxBCDiffToMaskBias;
-    nbc += mClusterer->isContinuousReadOut() ? alpParams.roFrameLengthInBC : (alpParams.roFrameLengthTrig / o2::constants::lhc::LHCBunchSpacingNS);
-    mClusterer->setMaxBCSeparationToMask(nbc);
-    mClusterer->setMaxRowColDiffToMask(clParams.maxRowColDiffToMask);
-    // Squasher
-    int rofBC = mClusterer->isContinuousReadOut() ? alpParams.roFrameLengthInBC : (alpParams.roFrameLengthTrig / o2::constants::lhc::LHCBunchSpacingNS); // ROF length in BC
-    mClusterer->setMaxBCSeparationToSquash(rofBC + clParams.maxBCDiffToSquashBias);
-    int nROFsToSquash = 0; // squashing disabled if no reset due to maxSOTMUS>0.
-    if (clParams.maxSOTMUS > 0 && rofBC > 0) {
-      nROFsToSquash = 2 + int(clParams.maxSOTMUS / (rofBC * o2::constants::lhc::LHCBunchSpacingMUS)); // use squashing
-    }
-    mClusterer->setMaxROFDepthToSquash(clParams.maxBCDiffToSquashBias > 0 ? nROFsToSquash : 0);
-    mClusterer->print();
-  }
-  // we may have other params which need to be queried regularly
-}
-
-///_______________________________________
-void ClustererDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
-{
-  if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
-    return;
-  }
-  if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
-    LOG(info) << "cluster dictionary updated" << (!mUseClusterDictionary ? " but its using is disabled" : "");
-    if (mUseClusterDictionary) {
-      mClusterer->setDictionary((const o2::itsmft::TopologyDictionary*)obj);
-    }
-    return;
-  }
-  // Note: strictly speaking, for Configurable params we don't need finaliseCCDB check, the singletons are updated at the CCDB fetcher level
-  if (matcher == ConcreteDataMatcher("ITS", "ALPIDEPARAM", 0)) {
-    LOG(info) << "Alpide param updated";
-    const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-    par.printKeyValues();
-    return;
-  }
-  if (matcher == ConcreteDataMatcher("ITS", "CLUSPARAM", 0)) {
-    LOG(info) << "Cluster param updated";
-    const auto& par = o2::itsmft::ClustererParam<o2::detectors::DetID::ITS>::Instance();
-    par.printKeyValues();
-    return;
-  }
-}
-
-DataProcessorSpec getClustererSpec(bool useMC)
-{
-  std::vector<InputSpec> inputs;
-  inputs.emplace_back("digits", "ITS", "DIGITS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ROframes", "ITS", "DIGITSROF", 0, Lifetime::Timeframe);
-  inputs.emplace_back("cldict", "ITS", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
-  inputs.emplace_back("cluspar", "ITS", "CLUSPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/ClustererParam"));
-  inputs.emplace_back("alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
-  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
-                                                              true,                           // GRPECS=true
-                                                              false,                          // GRPLHCIF
-                                                              false,                          // GRPMagField
-                                                              false,                          // askMatLUT
-                                                              o2::base::GRPGeomRequest::None, // geometry
-                                                              inputs,
-                                                              true);
-  std::vector<OutputSpec> outputs;
-  outputs.emplace_back("ITS", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  outputs.emplace_back("ITS", "PATTERNS", 0, Lifetime::Timeframe);
-  outputs.emplace_back("ITS", "CLUSTERSROF", 0, Lifetime::Timeframe);
-
-  if (useMC) {
-    inputs.emplace_back("labels", "ITS", "DIGITSMCTR", 0, Lifetime::Timeframe);
-    inputs.emplace_back("MC2ROframes", "ITS", "DIGITSMC2ROF", 0, Lifetime::Timeframe);
-    outputs.emplace_back("ITS", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    outputs.emplace_back("ITS", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
-  }
-
-  return DataProcessorSpec{
-    "its-clusterer",
-    inputs,
-    outputs,
-    AlgorithmSpec{adaptFromTask<ClustererDPL>(ggRequest, useMC)},
-    Options{
-      {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}},
-      {"nthreads", VariantType::Int, 1, {"Number of clustering threads"}}}};
-}
-
-///_______________________________________
-void ClustererDPL::endOfStream(o2::framework::EndOfStreamContext& ec)
-{
-  mClusterer->print();
-}
-
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index 60e28556716f2..9f8cb6c83ef99 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -12,8 +12,8 @@
 /// @file   RecoWorkflow.cxx
 
 #include "ITSWorkflow/RecoWorkflow.h"
-#include "ITSWorkflow/ClustererSpec.h"
-#include "ITSWorkflow/ClusterWriterSpec.h"
+#include "ITSMFTWorkflow/ClustererSpec.h"
+#include "ITSMFTWorkflow/ClusterWriterSpec.h"
 #include "ITSWorkflow/TrackerSpec.h"
 #include "ITSWorkflow/TrackWriterSpec.h"
 #include "ITStracking/TrackingConfigParam.h"
@@ -43,10 +43,10 @@ framework::WorkflowSpec getWorkflow(bool useMC,
     specs.emplace_back(o2::itsmft::getITSDigitReaderSpec(useMC, false, true, "itsdigits.root"));
   }
   if (!upstreamClusters) {
-    specs.emplace_back(o2::its::getClustererSpec(useMC));
+    specs.emplace_back(o2::itsmft::getITSClustererSpec(useMC));
   }
   if (!disableRootOutput) {
-    specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
+    specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC));
   }
   if ((trmode != TrackingMode::Off) && (TrackerParamConfig::Instance().trackingMode != TrackingMode::Off)) {
     if (useGPUWF) {
diff --git a/Detectors/ITSMFT/MFT/workflow/CMakeLists.txt b/Detectors/ITSMFT/MFT/workflow/CMakeLists.txt
index acb3d0b3e835f..b83699498a6b8 100644
--- a/Detectors/ITSMFT/MFT/workflow/CMakeLists.txt
+++ b/Detectors/ITSMFT/MFT/workflow/CMakeLists.txt
@@ -12,8 +12,6 @@
 o2_add_library(MFTWorkflow
                TARGETVARNAME targetName
                SOURCES src/RecoWorkflow.cxx
-                       src/ClustererSpec.cxx
-                       src/ClusterWriterSpec.cxx
                        src/TrackerSpec.cxx
                        src/TrackReaderSpec.cxx
                        src/TrackWriterSpec.cxx
diff --git a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/ClusterWriterSpec.h b/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/ClusterWriterSpec.h
deleted file mode 100644
index 51dc5a6481eb5..0000000000000
--- a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/ClusterWriterSpec.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClusterWriterSpec.h
-
-#ifndef O2_MFT_CLUSTERWRITER_H_
-#define O2_MFT_CLUSTERWRITER_H_
-
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace mft
-{
-
-/// create a processor spec
-/// write MFT clusters a root file
-framework::DataProcessorSpec getClusterWriterSpec(bool useMC);
-
-} // namespace mft
-} // namespace o2
-
-#endif /* O2_MFT_CLUSTERWRITER_H */
diff --git a/Detectors/ITSMFT/MFT/workflow/src/ClusterWriterSpec.cxx b/Detectors/ITSMFT/MFT/workflow/src/ClusterWriterSpec.cxx
deleted file mode 100644
index c8061310e34f6..0000000000000
--- a/Detectors/ITSMFT/MFT/workflow/src/ClusterWriterSpec.cxx
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClusterWriterSpec.cxx
-
-#include <vector>
-
-#include "MFTWorkflow/ClusterWriterSpec.h"
-#include "DPLUtils/MakeRootTreeWriterSpec.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace mft
-{
-
-template <typename T>
-using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
-using CompClusType = std::vector<o2::itsmft::CompClusterExt>;
-using PatternsType = std::vector<unsigned char>;
-using ROFrameRType = std::vector<o2::itsmft::ROFRecord>;
-using LabelsType = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
-using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
-using namespace o2::header;
-
-DataProcessorSpec getClusterWriterSpec(bool useMC)
-{
-  // Spectators for logging
-  // this is only to restore the original behavior
-  auto compClustersSize = std::make_shared<int>(0);
-  auto compClustersSizeGetter = [compClustersSize](CompClusType const& compClusters) {
-    *compClustersSize = compClusters.size();
-  };
-  auto logger = [compClustersSize](std::vector<o2::itsmft::ROFRecord> const& rofs) {
-    LOG(info) << "MFTClusterWriter pulled " << *compClustersSize << " clusters, in " << rofs.size() << " RO frames";
-  };
-  return MakeRootTreeWriterSpec("mft-cluster-writer",
-                                "mftclusters.root",
-                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Tree with MFT clusters"},
-                                BranchDefinition<CompClusType>{InputSpec{"compclus", "MFT", "COMPCLUSTERS", 0},
-                                                               "MFTClusterComp",
-                                                               compClustersSizeGetter},
-                                BranchDefinition<PatternsType>{InputSpec{"patterns", "MFT", "PATTERNS", 0},
-                                                               "MFTClusterPatt"},
-                                BranchDefinition<ROFrameRType>{InputSpec{"ROframes", "MFT", "CLUSTERSROF", 0},
-                                                               "MFTClustersROF",
-                                                               logger},
-                                BranchDefinition<LabelsType>{InputSpec{"labels", "MFT", "CLUSTERSMCTR", 0},
-                                                             "MFTClusterMCTruth",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""},
-                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", "MFT", "CLUSTERSMC2ROF", 0},
-                                                             "MFTClustersMC2ROF",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""})();
-}
-
-} // namespace mft
-} // namespace o2
diff --git a/Detectors/ITSMFT/MFT/workflow/src/ClustererSpec.cxx b/Detectors/ITSMFT/MFT/workflow/src/ClustererSpec.cxx
deleted file mode 100644
index 766d7c1a0729e..0000000000000
--- a/Detectors/ITSMFT/MFT/workflow/src/ClustererSpec.cxx
+++ /dev/null
@@ -1,212 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   ClustererSpec.cxx
-
-#include <vector>
-
-#include "Framework/ControlService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/CCDBParamSpec.h"
-#include "MFTWorkflow/ClustererSpec.h"
-#include "DataFormatsITSMFT/Digit.h"
-#include "ITSMFTReconstruction/ChipMappingMFT.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "DataFormatsITSMFT/TopologyDictionary.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/ConstMCTruthContainer.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "DataFormatsParameters/GRPObject.h"
-#include "ITSMFTReconstruction/DigitPixelReader.h"
-#include "DetectorsBase/GeometryManager.h"
-#include "MFTBase/GeometryTGeo.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
-#include "CommonConstants/LHCConstants.h"
-#include "DetectorsCommonDataFormats/DetectorNameConf.h"
-#include "ITSMFTReconstruction/ClustererParam.h"
-
-using namespace o2::framework;
-using namespace o2::itsmft;
-
-namespace o2
-{
-namespace mft
-{
-
-void ClustererDPL::init(InitContext& ic)
-{
-  mClusterer = std::make_unique<o2::itsmft::Clusterer>();
-  mClusterer->setNChips(o2::itsmft::ChipMappingMFT::getNChips());
-  mUseClusterDictionary = !ic.options().get<bool>("ignore-cluster-dictionary");
-  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
-  mNThreads = std::max(1, ic.options().get<int>("nthreads"));
-  mState = 1;
-}
-
-void ClustererDPL::run(ProcessingContext& pc)
-{
-  updateTimeDependentParams(pc);
-  auto digits = pc.inputs().get<gsl::span<o2::itsmft::Digit>>("digits");
-  auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
-
-  gsl::span<const o2::itsmft::MC2ROFRecord> mc2rofs;
-  gsl::span<const char> labelbuffer;
-  if (mUseMC) {
-    labelbuffer = pc.inputs().get<gsl::span<char>>("labels");
-    mc2rofs = pc.inputs().get<gsl::span<o2::itsmft::MC2ROFRecord>>("MC2ROframes");
-  }
-  const o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
-
-  LOG(debug) << "MFTClusterer pulled " << digits.size() << " digits, in "
-             << rofs.size() << " RO frames";
-
-  o2::itsmft::DigitPixelReader reader;
-  reader.setSquashingDepth(mClusterer->getMaxROFDepthToSquash());
-  reader.setSquashingDist(mClusterer->getMaxRowColDiffToMask()); // Sharing same parameter/logic with masking
-  reader.setMaxBCSeparationToSquash(mClusterer->getMaxBCSeparationToSquash());
-  reader.setDigits(digits);
-  reader.setROFRecords(rofs);
-  if (mUseMC) {
-    reader.setMC2ROFRecords(mc2rofs);
-    reader.setDigitsMCTruth(labels.getIndexedSize() > 0 ? &labels : nullptr);
-  }
-  reader.init();
-  auto orig = o2::header::gDataOriginMFT;
-  std::vector<o2::itsmft::CompClusterExt> clusCompVec;
-  std::vector<o2::itsmft::ROFRecord> clusROFVec;
-  std::vector<unsigned char> clusPattVec;
-
-  std::unique_ptr<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> clusterLabels;
-  if (mUseMC) {
-    clusterLabels = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
-  }
-  mClusterer->process(mNThreads, reader, &clusCompVec, &clusPattVec, &clusROFVec, clusterLabels.get());
-  pc.outputs().snapshot(Output{orig, "COMPCLUSTERS", 0}, clusCompVec);
-  pc.outputs().snapshot(Output{orig, "CLUSTERSROF", 0}, clusROFVec);
-  pc.outputs().snapshot(Output{orig, "PATTERNS", 0}, clusPattVec);
-
-  if (mUseMC) {
-    pc.outputs().snapshot(Output{orig, "CLUSTERSMCTR", 0}, *clusterLabels.get()); // at the moment requires snapshot
-    std::vector<o2::itsmft::MC2ROFRecord> clusterMC2ROframes(mc2rofs.size());
-    for (int i = mc2rofs.size(); i--;) {
-      clusterMC2ROframes[i] = mc2rofs[i]; // Simply, replicate it from digits ?
-    }
-    pc.outputs().snapshot(Output{orig, "CLUSTERSMC2ROF", 0}, clusterMC2ROframes);
-  }
-
-  // TODO: in principle, after masking "overflow" pixels the MC2ROFRecord maxROF supposed to change, nominally to minROF
-  // -> consider recalculationg maxROF
-  LOG(debug) << "MFTClusterer pushed " << clusCompVec.size() << " compressed clusters, in " << clusROFVec.size() << " RO frames";
-}
-
-///_______________________________________
-void ClustererDPL::updateTimeDependentParams(ProcessingContext& pc)
-{
-  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
-  static bool initOnceDone = false;
-  if (!initOnceDone) { // this params need to be queried only once
-    initOnceDone = true;
-    pc.inputs().get<TopologyDictionary*>("cldict"); // just to trigger the finaliseCCDB
-    pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>*>("alppar");
-    pc.inputs().get<o2::itsmft::ClustererParam<o2::detectors::DetID::MFT>*>("cluspar");
-    mClusterer->setContinuousReadOut(o2::base::GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::MFT));
-    // settings for the fired pixel overflow masking
-    const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>::Instance();
-    const auto& clParams = o2::itsmft::ClustererParam<o2::detectors::DetID::MFT>::Instance();
-    if (clParams.maxBCDiffToMaskBias > 0 && clParams.maxBCDiffToSquashBias > 0) {
-      LOGP(fatal, "maxBCDiffToMaskBias = {} and maxBCDiffToSquashBias = {} cannot be set at the same time. Either set masking or squashing with a BCDiff > 0", clParams.maxBCDiffToMaskBias, clParams.maxBCDiffToSquashBias);
-    }
-    mClusterer->setDropHugeClusters(clParams.dropHugeClusters);
-    auto nbc = clParams.maxBCDiffToMaskBias;
-    nbc += mClusterer->isContinuousReadOut() ? alpParams.roFrameLengthInBC : (alpParams.roFrameLengthTrig / o2::constants::lhc::LHCBunchSpacingNS);
-    mClusterer->setMaxBCSeparationToMask(nbc);
-    mClusterer->setMaxRowColDiffToMask(clParams.maxRowColDiffToMask);
-    // Squasher
-    int rofBC = mClusterer->isContinuousReadOut() ? alpParams.roFrameLengthInBC : (alpParams.roFrameLengthTrig / o2::constants::lhc::LHCBunchSpacingNS); // ROF length in BC
-    mClusterer->setMaxBCSeparationToSquash(rofBC + clParams.maxBCDiffToSquashBias);
-    int nROFsToSquash = 0; // squashing disabled if no reset due to maxSOTMUS>0.
-    if (clParams.maxSOTMUS > 0 && rofBC > 0) {
-      nROFsToSquash = 2 + int(clParams.maxSOTMUS / (rofBC * o2::constants::lhc::LHCBunchSpacingMUS)); // use squashing
-    }
-    mClusterer->setMaxROFDepthToSquash(nROFsToSquash);
-    mClusterer->print();
-  }
-  // we may have other params which need to be queried regularly
-}
-
-///_______________________________________
-void ClustererDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
-{
-  if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
-    return;
-  }
-  if (matcher == ConcreteDataMatcher("MFT", "CLUSDICT", 0)) {
-    LOG(info) << "cluster dictionary updated" << (!mUseClusterDictionary ? " but its using is disabled" : "");
-    if (mUseClusterDictionary) {
-      mClusterer->setDictionary((const TopologyDictionary*)obj);
-    }
-    return;
-  }
-  // Note: strictly speaking, for Configurable params we don't need finaliseCCDB check, the singletons are updated at the CCDB fetcher level
-  if (matcher == ConcreteDataMatcher("MFT", "ALPIDEPARAM", 0)) {
-    LOG(info) << "Alpide param updated";
-    const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>::Instance();
-    par.printKeyValues();
-    return;
-  }
-  if (matcher == ConcreteDataMatcher("MFT", "CLUSPARAM", 0)) {
-    LOG(info) << "Cluster param updated";
-    const auto& par = o2::itsmft::ClustererParam<o2::detectors::DetID::MFT>::Instance();
-    par.printKeyValues();
-    return;
-  }
-}
-
-DataProcessorSpec getClustererSpec(bool useMC)
-{
-  std::vector<InputSpec> inputs;
-  inputs.emplace_back("digits", "MFT", "DIGITS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ROframes", "MFT", "DIGITSROF", 0, Lifetime::Timeframe);
-  inputs.emplace_back("cldict", "MFT", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("MFT/Calib/ClusterDictionary"));
-  inputs.emplace_back("cluspar", "MFT", "CLUSPARAM", 0, Lifetime::Condition, ccdbParamSpec("MFT/Config/ClustererParam"));
-  inputs.emplace_back("alppar", "MFT", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("MFT/Config/AlpideParam"));
-  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
-                                                              true,                           // GRPECS=true
-                                                              false,                          // GRPLHCIF
-                                                              false,                          // GRPMagField
-                                                              false,                          // askMatLUT
-                                                              o2::base::GRPGeomRequest::None, // geometry
-                                                              inputs,
-                                                              true);
-  std::vector<OutputSpec> outputs;
-  outputs.emplace_back("MFT", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  outputs.emplace_back("MFT", "PATTERNS", 0, Lifetime::Timeframe);
-  outputs.emplace_back("MFT", "CLUSTERSROF", 0, Lifetime::Timeframe);
-
-  if (useMC) {
-    inputs.emplace_back("labels", "MFT", "DIGITSMCTR", 0, Lifetime::Timeframe);
-    inputs.emplace_back("MC2ROframes", "MFT", "DIGITSMC2ROF", 0, Lifetime::Timeframe);
-    outputs.emplace_back("MFT", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    outputs.emplace_back("MFT", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
-  }
-
-  return DataProcessorSpec{
-    "mft-clusterer",
-    inputs,
-    outputs,
-    AlgorithmSpec{adaptFromTask<ClustererDPL>(ggRequest, useMC)},
-    Options{
-      {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}},
-      {"nthreads", VariantType::Int, 1, {"Number of clustering threads"}}}};
-}
-
-} // namespace mft
-} // namespace o2
diff --git a/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
index 615c9c1b275d4..5d85c0ef81670 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
@@ -12,9 +12,9 @@
 /// @file   RecoWorkflow.cxx
 
 #include <TTree.h>
+#include "ITSMFTWorkflow/ClustererSpec.h"
+#include "ITSMFTWorkflow/ClusterWriterSpec.h"
 #include "MFTWorkflow/RecoWorkflow.h"
-#include "MFTWorkflow/ClustererSpec.h"
-#include "MFTWorkflow/ClusterWriterSpec.h"
 #include "MFTWorkflow/TrackerSpec.h"
 #include "MFTWorkflow/TrackWriterSpec.h"
 #include "ITSMFTWorkflow/DigitReaderSpec.h"
@@ -52,10 +52,10 @@ framework::WorkflowSpec getWorkflow(
     }
   }
   if (!upstreamClusters) {
-    specs.emplace_back(o2::mft::getClustererSpec(useMC));
+    specs.emplace_back(o2::itsmft::getMFTClustererSpec(useMC));
   }
   if (!disableRootOutput) {
-    specs.emplace_back(o2::mft::getClusterWriterSpec(useMC));
+    specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC));
   }
 
   if (runTracking) {
diff --git a/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
index f42b2e0c92a4a..b656970693808 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "MFTWorkflow/ClusterWriterSpec.h"
+#include "ITSMFTWorkflow/ClusterWriterSpec.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/CompletionPolicyHelpers.h"
 
@@ -34,6 +34,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   WorkflowSpec specs;
-  specs.emplace_back(o2::mft::getClusterWriterSpec(useMC));
+  specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC));
   return specs;
 }
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
index c66468905d0aa..0bdbb701a9356 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
@@ -215,13 +215,15 @@ class Clusterer
   int getMaxRowColDiffToMask() const { return mMaxRowColDiffToMask; }
   void setMaxRowColDiffToMask(int v) { mMaxRowColDiffToMask = v; }
 
-  int getMaxROFDepthToSquash() const { return mSquashingDepth; }
+  int getMaxROFDepthToSquash(int layer = -1) const { return (layer < 0) ? mSquashingDepth : mSquashingLayerDepth[layer]; }
   void setMaxROFDepthToSquash(int v) { mSquashingDepth = v; }
+  void addMaxROFDepthToSquash(int v) { mSquashingLayerDepth.push_back(v); }
 
-  int getMaxBCSeparationToSquash() const { return mMaxBCSeparationToSquash; }
+  int getMaxBCSeparationToSquash(int layer = -1) const { return (layer < 0) ? mMaxBCSeparationToSquash : mMaxBCSeparationToSquashLayer[layer]; }
   void setMaxBCSeparationToSquash(int n) { mMaxBCSeparationToSquash = n; }
+  void addMaxBCSeparationToSquash(int n) { mMaxBCSeparationToSquashLayer.push_back(n); }
 
-  void print() const;
+  void print(bool showTiming = true) const;
   void clear();
   void reset();
 
@@ -245,7 +247,7 @@ class Clusterer
   bool mContinuousReadout = true; ///< flag continuous readout
   bool mDropHugeClusters = false; ///< don't include clusters that would be split in more than one
 
-  ///< mask continuosly fired pixels in frames separated by less than this amount of BCs (fired from hit in prev. ROF)
+  ///< mask continuously fired pixels in frames separated by less than this amount of BCs (fired from hit in prev. ROF)
   int mMaxBCSeparationToMask = 6000. / o2::constants::lhc::LHCBunchSpacingNS + 10;
   int mMaxRowColDiffToMask = 0; ///< provide their difference in col/row is <= than this
   int mNHugeClus = 0;           ///< number of encountered huge clusters
@@ -253,6 +255,8 @@ class Clusterer
   ///< Squashing options
   int mSquashingDepth = 0; ///< squashing is applied to next N rofs
   int mMaxBCSeparationToSquash = 6000. / o2::constants::lhc::LHCBunchSpacingNS + 10;
+  std::vector<int> mSquashingLayerDepth;
+  std::vector<int> mMaxBCSeparationToSquashLayer;
 
   std::vector<std::unique_ptr<ClustererThread>> mThreads; // buffers for threads
   std::vector<ChipPixelData> mChips;                      // currently processed ROF's chips data
@@ -288,7 +292,7 @@ void Clusterer::streamCluster(const std::vector<PixelData>& pixbuf, const std::a
   uint16_t row = bbox.rowMin, col = bbox.colMin;
   if (pattID == CompCluster::InvalidPatternID || pattIdConverter.isGroup(pattID)) {
     if (pattID != CompCluster::InvalidPatternID) {
-      // For groupped topologies, the reference pixel is the COG pixel
+      // For grouped topologies, the reference pixel is the COG pixel
       float xCOG = 0., zCOG = 0.;
       ClusterPattern::getCOG(rowSpanW, colSpanW, patt.data(), xCOG, zCOG);
       row += round(xCOG);
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ClustererParam.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ClustererParam.h
index a71e5f3095b06..3188a4f3b0010 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ClustererParam.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ClustererParam.h
@@ -29,16 +29,26 @@ template <int N>
 struct ClustererParam : public o2::conf::ConfigurableParamHelper<ClustererParam<N>> {
   static_assert(N == o2::detectors::DetID::ITS || N == o2::detectors::DetID::MFT, "only DetID::ITS or DetID:: MFT are allowed");
 
+  static constexpr int getNLayers()
+  {
+    return N == o2::detectors::DetID::ITS ? 7 : 10;
+  }
+
   static constexpr std::string_view getParamName()
   {
     return N == o2::detectors::DetID::ITS ? ParamName[0] : ParamName[1];
   }
 
-  int maxRowColDiffToMask = DEFRowColDiffToMask(); ///< pixel may be masked as overflow if such a neighbour in prev frame was fired
-  int maxBCDiffToMaskBias = 10;                    ///< mask if 2 ROFs differ by <= StrobeLength + Bias BCs, use value <0 to disable masking
-  int maxBCDiffToSquashBias = -10;                 ///< squash if 2 ROFs differ by <= StrobeLength + Bias BCs, use value <0 to disable squashing
-  float maxSOTMUS = 8.;                            ///< max expected signal over threshold in \mus
-  bool dropHugeClusters = false;                   ///< option to drop huge clusters (mitigate beam background)
+  int maxRowColDiffToMask = DEFRowColDiffToMask();   ///< pixel may be masked as overflow if such a neighbour in prev frame was fired
+  int maxBCDiffToMaskBias = 10;                      ///< mask if 2 ROFs differ by <= StrobeLength + Bias BCs, use value <0 to disable masking
+  int maxBCDiffToSquashBias = -10;                   ///< squash if 2 ROFs differ by <= StrobeLength + Bias BCs, use value <0 to disable squashing
+  float maxSOTMUS = 8.;                              ///< max expected signal over threshold in \mus
+  bool dropHugeClusters = false;                     ///< option to drop huge clusters (mitigate beam background)
+  int maxBCDiffToSquashBiasLayer[getNLayers()] = {}; ///< squash mask per layer
+  int getMaxBCDiffToSquashBias(int layer) const noexcept
+  {
+    return maxBCDiffToSquashBiasLayer[layer] ? maxBCDiffToSquashBiasLayer[layer] : maxBCDiffToSquashBias;
+  }
 
   O2ParamDef(ClustererParam, getParamName().data());
 
@@ -46,7 +56,7 @@ struct ClustererParam : public o2::conf::ConfigurableParamHelper<ClustererParam<
   static constexpr int DEFRowColDiffToMask()
   {
     // default neighbourhood definition
-    return N == o2::detectors::DetID::ITS ? 1 : 1; // ITS and MFT will suppress also closest neigbours
+    return N == o2::detectors::DetID::ITS ? 1 : 1; // ITS and MFT will suppress also closest neighbours
   }
 
   static constexpr std::string_view ParamName[2] = {"ITSClustererParam", "MFTClustererParam"};
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/DigitPixelReader.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/DigitPixelReader.h
index 2a6d44ec0d0ab..60dad3d98f410 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/DigitPixelReader.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/DigitPixelReader.h
@@ -93,6 +93,7 @@ class DigitPixelReader : public PixelReader
   bool readNextEntry();
 
   void clear();
+  void reset();
 
   uint16_t getSquashingDepth() { return mSquashOverflowsDepth; }
   void setSquashingDepth(const int16_t v)
@@ -152,4 +153,4 @@ class DigitPixelReader : public PixelReader
 } // namespace itsmft
 } // namespace o2
 
-#endif /* ALICEO2_ITS_DIGITPIXELREADER_H */
\ No newline at end of file
+#endif /* ALICEO2_ITS_DIGITPIXELREADER_H */
diff --git a/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx b/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
index 42e535e810a62..3c741321e7780 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
@@ -30,11 +30,8 @@ void Clusterer::process(int nThreads, PixelReader& reader, CompClusCont* compClu
 #ifdef _PERFORM_TIMING_
   mTimer.Start(kFALSE);
 #endif
-  if (nThreads < 1) {
-    nThreads = 1;
-  }
+  nThreads = std::max(nThreads, 1);
   auto autoDecode = reader.getDecodeNextAuto();
-  int rofcount{0};
   o2::InteractionRecord lastIR{};
   do {
     if (autoDecode) {
@@ -73,9 +70,7 @@ void Clusterer::process(int nThreads, PixelReader& reader, CompClusCont* compClu
       }
       break; // just 1 ROF was asked to be processed
     }
-    if (nFired < nThreads) {
-      nThreads = nFired;
-    }
+    nThreads = std::min<int>(nFired, nThreads);
 #ifndef WITH_OPENMP
     nThreads = 1;
 #endif
@@ -173,7 +168,7 @@ void Clusterer::ClustererThread::process(uint16_t chip, uint16_t nChips, CompClu
                                          const ConstMCTruth* labelsDigPtr, MCTruth* labelsClPtr, const ROFRecord& rofPtr)
 {
   if (stats.empty() || stats.back().firstChip + stats.back().nChips != chip) { // there is a jump, register new block
-    stats.emplace_back(ThreadStat{chip, 0, uint32_t(compClusPtr->size()), patternsPtr ? uint32_t(patternsPtr->size()) : 0, 0, 0});
+    stats.emplace_back(ThreadStat{.firstChip = chip, .nChips = 0, .firstClus = uint32_t(compClusPtr->size()), .firstPatt = patternsPtr ? uint32_t(patternsPtr->size()) : 0, .nClus = 0, .nPatt = 0});
   }
   for (int ic = 0; ic < nChips; ic++) {
     auto* curChipData = parent->mFiredChipsPtr[chip + ic];
@@ -476,22 +471,31 @@ void Clusterer::clear()
 }
 
 //__________________________________________________
-void Clusterer::print() const
+void Clusterer::print(bool showsTiming) const
 {
   // print settings
-  LOGP(info, "Clusterizer squashes overflow pixels separated by {} BC and <= {} in row/col seeking down to {} neighbour ROFs", mMaxBCSeparationToSquash, mMaxRowColDiffToMask, mSquashingDepth);
+  if (mSquashingLayerDepth.empty()) {
+    LOGP(info, "Clusterizer squashes overflow pixels separated by {} BC and <= {} in row/col seeking down to {} neighbour ROFs", mMaxBCSeparationToSquash, mMaxRowColDiffToMask, mSquashingDepth);
+  } else {
+    LOGP(info, "Clusterizer squashes overflow pixels <= {} in row/col", mMaxRowColDiffToMask);
+    for (size_t i{0}; i < mSquashingLayerDepth.size(); ++i) {
+      LOGP(info, "\tlay:{} separated by {} BC seeking down to {} neighbour ROFs", i, mMaxBCSeparationToSquashLayer[i], mSquashingLayerDepth[i]);
+    }
+  }
   LOGP(info, "Clusterizer masks overflow pixels separated by < {} BC and <= {} in row/col", mMaxBCSeparationToMask, mMaxRowColDiffToMask);
   LOGP(info, "Clusterizer does {} drop huge clusters", mDropHugeClusters ? "" : "not");
 
+  if (showsTiming) {
 #ifdef _PERFORM_TIMING_
-  auto& tmr = const_cast<TStopwatch&>(mTimer); // ugly but this is what root does internally
-  auto& tmrm = const_cast<TStopwatch&>(mTimerMerge);
-  LOG(info) << "Inclusive clusterization timing (w/o disk IO): Cpu: " << tmr.CpuTime()
-            << " Real: " << tmr.RealTime() << " s in " << tmr.Counter() << " slots";
-  LOG(info) << "Threads output merging timing                : Cpu: " << tmrm.CpuTime()
-            << " Real: " << tmrm.RealTime() << " s in " << tmrm.Counter() << " slots";
+    auto& tmr = const_cast<TStopwatch&>(mTimer); // ugly but this is what root does internally
+    auto& tmrm = const_cast<TStopwatch&>(mTimerMerge);
+    LOG(info) << "Inclusive clusterization timing (w/o disk IO): Cpu: " << tmr.CpuTime()
+              << " Real: " << tmr.RealTime() << " s in " << tmr.Counter() << " slots";
+    LOG(info) << "Threads output merging timing                : Cpu: " << tmrm.CpuTime()
+              << " Real: " << tmrm.RealTime() << " s in " << tmrm.Counter() << " slots";
 
 #endif
+  }
 }
 
 //__________________________________________________
diff --git a/Detectors/ITSMFT/common/reconstruction/src/DigitPixelReader.cxx b/Detectors/ITSMFT/common/reconstruction/src/DigitPixelReader.cxx
index b8d88a6fc4223..5c1dbde074649 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/DigitPixelReader.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/DigitPixelReader.cxx
@@ -330,3 +330,14 @@ void DigitPixelReader::clear()
   mROFRecVec = gsl::span<const o2::itsmft::ROFRecord>();
   mMC2ROFRecVec = gsl::span<const o2::itsmft::MC2ROFRecord>();
 }
+
+//______________________________________________________________________________
+void DigitPixelReader::reset()
+{
+  clear();
+  mSquashedDigitsMask.clear();
+  mBookmarkNextROFs.clear();
+  mIdDig = 0;
+  mIdROF = 0;
+  mIdROFLast = 0;
+}
diff --git a/Detectors/ITSMFT/common/workflow/CMakeLists.txt b/Detectors/ITSMFT/common/workflow/CMakeLists.txt
index 63cd8d6c0bcee..ead08c4422260 100644
--- a/Detectors/ITSMFT/common/workflow/CMakeLists.txt
+++ b/Detectors/ITSMFT/common/workflow/CMakeLists.txt
@@ -11,6 +11,8 @@
 
 o2_add_library(ITSMFTWorkflow
                SOURCES src/ClusterReaderSpec.cxx
+                       src/ClusterWriterSpec.cxx
+                       src/ClustererSpec.cxx
                        src/DigitWriterSpec.cxx
                        src/DigitReaderSpec.cxx
                        src/STFDecoderSpec.cxx
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterReaderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterReaderSpec.h
index 99318df1cd9d9..82e3890de7475 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterReaderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterReaderSpec.h
@@ -23,46 +23,51 @@
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 
 using namespace o2::framework;
 
-namespace o2
-{
-namespace itsmft
+namespace o2::itsmft
 {
 
+template <int N>
 class ClusterReader : public Task
 {
  public:
+  static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+  static constexpr o2::header::DataOrigin Origin{(N == o2::detectors::DetID::ITS) ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  static constexpr int NLayers{o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1};
+
   ClusterReader() = delete;
-  ClusterReader(o2::detectors::DetID id, bool useMC, bool usePatterns = true, bool triggers = true);
+  ClusterReader(bool useMC, bool usePatterns = true, bool triggers = true);
   ~ClusterReader() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
 
  protected:
   void connectTree(const std::string& filename);
+  template <typename Ptr>
+  void setBranchAddress(const std::string& base, Ptr& addr, int layer);
+  std::string getBranchName(const std::string& base, int index) const;
 
-  std::vector<o2::itsmft::ROFRecord> mClusROFRec, *mClusROFRecPtr = &mClusROFRec;
-  std::vector<o2::itsmft::CompClusterExt> mClusterCompArray, *mClusterCompArrayPtr = &mClusterCompArray;
-  std::vector<unsigned char> mPatternsArray, *mPatternsArrayPtr = &mPatternsArray;
-  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mClusterMCTruth, *mClusterMCTruthPtr = &mClusterMCTruth;
-  std::vector<o2::itsmft::MC2ROFRecord> mClusMC2ROFs, *mClusMC2ROFsPtr = &mClusMC2ROFs;
-
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginInvalid;
+  std::array<std::vector<o2::itsmft::ROFRecord>*, NLayers> mClusROFRec;
+  std::array<std::vector<o2::itsmft::CompClusterExt>*, NLayers> mClusterCompArray;
+  std::array<std::vector<unsigned char>*, NLayers> mPatternsArray;
+  std::array<o2::dataformats::MCTruthContainer<o2::MCCompLabel>*, NLayers> mClusterMCTruth;
+  std::array<std::vector<o2::itsmft::MC2ROFRecord>*, NLayers> mClusMC2ROFs;
 
   std::unique_ptr<TFile> mFile;
   std::unique_ptr<TTree> mTree;
 
-  bool mUseMC = true;     // use MC truth
+  bool mUseMC = true;       // use MC truth
   bool mUsePatterns = true; // send patterns
   bool mTriggerOut = true;  // send dummy triggers vector
 
-  std::string mDetName = "";
-  std::string mDetNameLC = "";
-  std::string mFileName = "";
+  std::string mDetName;
+  std::string mDetNameLC;
+  std::string mFileName;
   std::string mClusTreeName = "o2sim";
   std::string mClusROFBranchName = "ClustersROF";
   std::string mClusterPattBranchName = "ClusterPatt";
@@ -71,24 +76,18 @@ class ClusterReader : public Task
   std::string mClustMC2ROFBranchName = "ClustersMC2ROF";
 };
 
-class ITSClusterReader : public ClusterReader
+class ITSClusterReader : public ClusterReader<o2::detectors::DetID::ITS>
 {
  public:
   ITSClusterReader(bool useMC = true, bool usePatterns = true, bool triggerOut = true)
-    : ClusterReader(o2::detectors::DetID::ITS, useMC, usePatterns, triggerOut)
-  {
-    mOrigin = o2::header::gDataOriginITS;
-  }
+    : ClusterReader(useMC, usePatterns, triggerOut) {}
 };
 
-class MFTClusterReader : public ClusterReader
+class MFTClusterReader : public ClusterReader<o2::detectors::DetID::MFT>
 {
  public:
   MFTClusterReader(bool useMC = true, bool usePatterns = true, bool triggerOut = true)
-    : ClusterReader(o2::detectors::DetID::MFT, useMC, usePatterns, triggerOut)
-  {
-    mOrigin = o2::header::gDataOriginMFT;
-  }
+    : ClusterReader(useMC, usePatterns, triggerOut) {}
 };
 
 /// create a processor spec
@@ -96,7 +95,6 @@ class MFTClusterReader : public ClusterReader
 framework::DataProcessorSpec getITSClusterReaderSpec(bool useMC = true, bool usePatterns = true, bool useTriggers = true);
 framework::DataProcessorSpec getMFTClusterReaderSpec(bool useMC = true, bool usePatterns = true, bool useTriggers = true);
 
-} // namespace itsmft
-} // namespace o2
+} // namespace o2::itsmft
 
 #endif /* O2_ITSMFT_CLUSTERREADER */
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
similarity index 73%
rename from Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterSpec.h
rename to Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
index 42b96786af27a..5ae371e7e09c4 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
@@ -11,21 +11,19 @@
 
 /// @file   ClusterWriterSpec.h
 
-#ifndef O2_ITS_CLUSTERWRITER
-#define O2_ITS_CLUSTERWRITER
+#ifndef O2_ITSMFT_CLUSTERWRITER
+#define O2_ITSMFT_CLUSTERWRITER
 
 #include "Framework/DataProcessorSpec.h"
 
-namespace o2
-{
-namespace its
+namespace o2::itsmft
 {
 
-/// create a processor spec
-/// write ITS clusters to ROOT file
+template <int N>
 framework::DataProcessorSpec getClusterWriterSpec(bool useMC);
+framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC);
+framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC);
 
-} // namespace its
-} // namespace o2
+} // namespace o2::itsmft
 
 #endif /* O2_ITS_CLUSTERWRITER */
diff --git a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/ClustererSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClustererSpec.h
similarity index 64%
rename from Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/ClustererSpec.h
rename to Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClustererSpec.h
index f0a763597ff74..b6ebc282c2a27 100644
--- a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/ClustererSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClustererSpec.h
@@ -11,24 +11,27 @@
 
 /// @file   ClustererSpec.h
 
-#ifndef O2_MFT_CLUSTERERDPL_H_
-#define O2_MFT_CLUSTERERDPL_H_
+#ifndef O2_ITSMFT_CLUSTERERDPL_H_
+#define O2_ITSMFT_CLUSTERERDPL_H_
 
-#include <fstream>
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "ITSMFTReconstruction/Clusterer.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
 
 using namespace o2::framework;
 
-namespace o2
-{
-namespace mft
+namespace o2::itsmft
 {
 
+template <int N>
 class ClustererDPL : public Task
 {
+  static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+  static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  static constexpr int NLayers{o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1};
+
  public:
   ClustererDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC) : mGGCCDBRequest(gr), mUseMC(useMC) {}
   ~ClustererDPL() override = default;
@@ -39,20 +42,19 @@ class ClustererDPL : public Task
  private:
   void updateTimeDependentParams(ProcessingContext& pc);
 
-  int mState = 0;
+  std::string mDetName;
   bool mUseMC = true;
   bool mUseClusterDictionary = true;
   int mNThreads = 1;
-  std::unique_ptr<std::ifstream> mFile = nullptr;
   std::unique_ptr<o2::itsmft::Clusterer> mClusterer = nullptr;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
+  int mLayers{NLayers};
+  std::vector<InputSpec> mFilter;
 };
 
-/// create a processor spec
-/// run MFT cluster finder
-framework::DataProcessorSpec getClustererSpec(bool useMC);
+framework::DataProcessorSpec getITSClustererSpec(bool useMC);
+framework::DataProcessorSpec getMFTClustererSpec(bool useMC);
 
-} // namespace mft
-} // namespace o2
+} // namespace o2::itsmft
 
 #endif /* O2_MFT_CLUSTERERDPL */
diff --git a/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
index ea906056c7898..bc6418a077810 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
@@ -12,15 +12,16 @@
 /// @file   ClusterReaderSpec.cxx
 
 #include <vector>
+#include <cassert>
 
-#include "TTree.h"
+#include <TTree.h>
 
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/Logger.h"
 #include "ITSMFTWorkflow/ClusterReaderSpec.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/PhysTrigger.h"
-#include <cassert>
 #include "CommonUtils/NameConf.h"
 
 using namespace o2::framework;
@@ -31,45 +32,48 @@ namespace o2
 namespace itsmft
 {
 
-ClusterReader::ClusterReader(o2::detectors::DetID id, bool useMC, bool usePatterns, bool triggerOut)
+template <int N>
+ClusterReader<N>::ClusterReader(bool useMC, bool usePatterns, bool triggerOut) : mUseMC(useMC), mUsePatterns(usePatterns), mTriggerOut(triggerOut), mDetName(Origin.as<std::string>()), mDetNameLC(mDetName)
 {
-  assert(id == o2::detectors::DetID::ITS || id == o2::detectors::DetID::MFT);
-  mDetNameLC = mDetName = id.getName();
-  mUseMC = useMC;
-  mUsePatterns = usePatterns;
-  mTriggerOut = triggerOut;
   std::transform(mDetNameLC.begin(), mDetNameLC.end(), mDetNameLC.begin(), ::tolower);
+
+  mClusROFRec.fill(nullptr);
+  mClusterCompArray.fill(nullptr);
+  mPatternsArray.fill(nullptr);
+  mClusterMCTruth.fill(nullptr);
+  mClusMC2ROFs.fill(nullptr);
 }
 
-void ClusterReader::init(InitContext& ic)
+template <int N>
+void ClusterReader<N>::init(InitContext& ic)
 {
   mFileName = o2::utils::Str::concat_string(o2::utils::Str::rectifyDirectory(ic.options().get<std::string>("input-dir")),
                                             ic.options().get<std::string>((mDetNameLC + "-cluster-infile").c_str()));
   connectTree(mFileName);
 }
 
-void ClusterReader::run(ProcessingContext& pc)
+template <int N>
+void ClusterReader<N>::run(ProcessingContext& pc)
 {
   auto ent = mTree->GetReadEntry() + 1;
   assert(ent < mTree->GetEntries()); // this should not happen
   mTree->GetEntry(ent);
-  LOG(info) << mDetName << "ClusterReader pushes " << mClusROFRec.size() << " ROFRecords,"
-            << mClusterCompArray.size() << " compact clusters at entry " << ent;
-
-  // This is a very ugly way of providing DataDescription, which anyway does not need to contain detector name.
-  // To be fixed once the names-definition class is ready
-  pc.outputs().snapshot(Output{mOrigin, "CLUSTERSROF", 0}, mClusROFRec);
-  pc.outputs().snapshot(Output{mOrigin, "COMPCLUSTERS", 0}, mClusterCompArray);
-  if (mUsePatterns) {
-    pc.outputs().snapshot(Output{mOrigin, "PATTERNS", 0}, mPatternsArray);
-  }
-  if (mUseMC) {
-    pc.outputs().snapshot(Output{mOrigin, "CLUSTERSMCTR", 0}, mClusterMCTruth);
-    pc.outputs().snapshot(Output{mOrigin, "CLUSTERSMC2ROF", 0}, mClusMC2ROFs);
+
+  for (uint32_t iLayer = 0; iLayer < NLayers; ++iLayer) {
+    LOG(info) << mDetName << "ClusterReader:" << iLayer << " pushes " << mClusROFRec[iLayer]->size() << " ROFRecords, " << mClusterCompArray[iLayer]->size() << " compact clusters at entry " << ent;
+    pc.outputs().snapshot(Output{Origin, "CLUSTERSROF", iLayer}, *mClusROFRec[iLayer]);
+    pc.outputs().snapshot(Output{Origin, "COMPCLUSTERS", iLayer}, *mClusterCompArray[iLayer]);
+    if (mUsePatterns) {
+      pc.outputs().snapshot(Output{Origin, "PATTERNS", iLayer}, *mPatternsArray[iLayer]);
+    }
+    if (mUseMC) {
+      pc.outputs().snapshot(Output{Origin, "CLUSTERSMCTR", iLayer}, *mClusterMCTruth[iLayer]);
+      pc.outputs().snapshot(Output{Origin, "CLUSTERSMC2ROF", iLayer}, *mClusMC2ROFs[iLayer]);
+    }
   }
   if (mTriggerOut) {
     std::vector<o2::itsmft::PhysTrigger> dummyTrig;
-    pc.outputs().snapshot(Output{mOrigin, "PHYSTRIG", 0}, dummyTrig);
+    pc.outputs().snapshot(Output{Origin, "PHYSTRIG", 0}, dummyTrig);
   }
   if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
     pc.services().get<ControlService>().endOfStream();
@@ -77,7 +81,8 @@ void ClusterReader::run(ProcessingContext& pc)
   }
 }
 
-void ClusterReader::connectTree(const std::string& filename)
+template <int N>
+void ClusterReader<N>::connectTree(const std::string& filename)
 {
   mTree.reset(nullptr); // in case it was already loaded
   mFile.reset(TFile::Open(filename.c_str()));
@@ -85,70 +90,89 @@ void ClusterReader::connectTree(const std::string& filename)
   mTree.reset((TTree*)mFile->Get(mClusTreeName.c_str()));
   assert(mTree);
 
-  mTree->SetBranchAddress((mDetName + mClusROFBranchName).c_str(), &mClusROFRecPtr);
-  mTree->SetBranchAddress((mDetName + mClusterCompBranchName).c_str(), &mClusterCompArrayPtr);
-  if (mUsePatterns) {
-    mTree->SetBranchAddress((mDetName + mClusterPattBranchName).c_str(), &mPatternsArrayPtr);
-  }
-  if (mUseMC) {
-    if (mTree->GetBranch((mDetName + mClustMCTruthBranchName).c_str()) &&
-        mTree->GetBranch((mDetName + mClustMC2ROFBranchName).c_str())) {
-      mTree->SetBranchAddress((mDetName + mClustMCTruthBranchName).c_str(), &mClusterMCTruthPtr);
-      mTree->SetBranchAddress((mDetName + mClustMC2ROFBranchName).c_str(), &mClusMC2ROFsPtr);
-    } else {
-      LOG(info) << "MC-truth is missing";
-      mUseMC = false;
+  for (uint32_t iLayer = 0; iLayer < NLayers; ++iLayer) {
+    setBranchAddress(mClusROFBranchName, mClusROFRec[iLayer], iLayer);
+    setBranchAddress(mClusterCompBranchName, mClusterCompArray[iLayer], iLayer);
+    if (mUsePatterns) {
+      setBranchAddress(mClusterPattBranchName, mPatternsArray[iLayer], iLayer);
+    }
+    if (mUseMC) {
+      if (mTree->GetBranch(getBranchName(mClustMCTruthBranchName, iLayer).c_str()) &&
+          mTree->GetBranch(getBranchName(mClustMC2ROFBranchName, iLayer).c_str())) {
+        setBranchAddress(mClustMCTruthBranchName, mClusterMCTruth[iLayer], iLayer);
+        setBranchAddress(mClustMC2ROFBranchName, mClusMC2ROFs[iLayer], iLayer);
+      } else {
+        LOG(info) << "MC-truth is missing";
+        mUseMC = false;
+      }
     }
   }
   LOG(info) << "Loaded tree from " << filename << " with " << mTree->GetEntries() << " entries";
 }
 
-DataProcessorSpec getITSClusterReaderSpec(bool useMC, bool usePatterns, bool triggerOut)
+template <int N>
+std::string ClusterReader<N>::getBranchName(const std::string& base, int index) const
+{
+  if constexpr (o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) {
+    return mDetName + base + "_" + std::to_string(index);
+  }
+  return mDetName + base;
+}
+
+template <int N>
+template <typename Ptr>
+void ClusterReader<N>::setBranchAddress(const std::string& base, Ptr& addr, int layer)
 {
-  std::vector<OutputSpec> outputSpec;
-  outputSpec.emplace_back("ITS", "CLUSTERSROF", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("ITS", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  if (usePatterns) {
-    outputSpec.emplace_back("ITS", "PATTERNS", 0, Lifetime::Timeframe);
+  const auto name = getBranchName(base, layer);
+  if (Int_t ret = mTree->SetBranchAddress(name.c_str(), &addr); ret != 0) {
+    LOGP(fatal, "failed to set branch address for {} ret={}", name, ret);
   }
-  if (useMC) {
-    outputSpec.emplace_back("ITS", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    outputSpec.emplace_back("ITS", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
+}
+
+namespace
+{
+template <int N>
+std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mctruth, bool usePatterns, bool triggerOut)
+{
+  std::vector<OutputSpec> outputs;
+  for (uint32_t iLayer = 0; iLayer < ((o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1); ++iLayer) {
+    outputs.emplace_back(detOrig, "CLUSTERSROF", iLayer, Lifetime::Timeframe);
+    outputs.emplace_back(detOrig, "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
+    if (usePatterns) {
+      outputs.emplace_back(detOrig, "PATTERNS", iLayer, Lifetime::Timeframe);
+    }
+    if (mctruth) {
+      outputs.emplace_back(detOrig, "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(detOrig, "CLUSTERSMC2ROF", iLayer, Lifetime::Timeframe);
+    }
   }
   if (triggerOut) {
-    outputSpec.emplace_back("ITS", "PHYSTRIG", 0, Lifetime::Timeframe);
+    outputs.emplace_back(detOrig, "PHYSTRIG", 0, Lifetime::Timeframe);
   }
+  return outputs;
+}
+} // namespace
+
+DataProcessorSpec getITSClusterReaderSpec(bool useMC, bool usePatterns, bool triggerOut)
+{
   return DataProcessorSpec{
-    "its-cluster-reader",
-    Inputs{},
-    outputSpec,
-    AlgorithmSpec{adaptFromTask<ITSClusterReader>(useMC, usePatterns, triggerOut)},
-    Options{
+    .name = "its-cluster-reader",
+    .inputs = Inputs{},
+    .outputs = makeOutChannels<o2::detectors::DetID::ITS>("ITS", useMC, usePatterns, triggerOut),
+    .algorithm = AlgorithmSpec{adaptFromTask<ITSClusterReader>(useMC, usePatterns, triggerOut)},
+    .options = Options{
       {"its-cluster-infile", VariantType::String, "o2clus_its.root", {"Name of the input cluster file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
 }
 
 DataProcessorSpec getMFTClusterReaderSpec(bool useMC, bool usePatterns, bool triggerOut)
 {
-  std::vector<OutputSpec> outputSpec;
-  outputSpec.emplace_back("MFT", "CLUSTERSROF", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("MFT", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  if (usePatterns) {
-    outputSpec.emplace_back("MFT", "PATTERNS", 0, Lifetime::Timeframe);
-  }
-  if (useMC) {
-    outputSpec.emplace_back("MFT", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    outputSpec.emplace_back("MFT", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
-  }
-  if (triggerOut) {
-    outputSpec.emplace_back("MFT", "PHYSTRIG", 0, Lifetime::Timeframe);
-  }
   return DataProcessorSpec{
-    "mft-cluster-reader",
-    Inputs{},
-    outputSpec,
-    AlgorithmSpec{adaptFromTask<MFTClusterReader>(useMC, usePatterns, triggerOut)},
-    Options{
+    .name = "mft-cluster-reader",
+    .inputs = Inputs{},
+    .outputs = makeOutChannels<o2::detectors::DetID::MFT>("MFT", useMC, usePatterns, triggerOut),
+    .algorithm = AlgorithmSpec{adaptFromTask<MFTClusterReader>(useMC, usePatterns, triggerOut)},
+    .options = Options{
       {"mft-cluster-infile", VariantType::String, "mftclusters.root", {"Name of the input cluster file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
 }
diff --git a/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
new file mode 100644
index 0000000000000..c1900c346133b
--- /dev/null
+++ b/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
@@ -0,0 +1,107 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   ClusterWriterSpec.cxx
+
+#include <algorithm>
+#include <cctype>
+#include <memory>
+#include <vector>
+#include <format>
+
+#include "Framework/ConcreteDataMatcher.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
+#include "ITSMFTWorkflow/ClusterWriterSpec.h"
+#include "DPLUtils/MakeRootTreeWriterSpec.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+
+using namespace o2::framework;
+
+namespace o2::itsmft
+{
+
+template <typename T>
+using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
+using CompClusType = std::vector<o2::itsmft::CompClusterExt>;
+using PatternsType = std::vector<unsigned char>;
+using ROFrameRType = std::vector<o2::itsmft::ROFRecord>;
+using LabelsType = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
+using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
+using namespace o2::header;
+
+template <int N>
+DataProcessorSpec getClusterWriterSpec(bool useMC)
+{
+  static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  constexpr int NLayers = (DPLAlpideParam<N>::supportsStaggering()) ? DPLAlpideParam<N>::getNLayers() : 1;
+  const auto detName = Origin.as<std::string>();
+  // Spectators for logging
+  auto compClusterSizes = std::make_shared<std::array<size_t, NLayers>>();
+  auto compClustersSizeGetter = [compClusterSizes](CompClusType const& compClusters, DataRef const& ref) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    (*compClusterSizes)[dh->subSpecification] = compClusters.size();
+  };
+  auto logger = [detName, compClusterSizes](std::vector<o2::itsmft::ROFRecord> const& rofs, DataRef const& ref) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    const auto i = dh->subSpecification;
+    LOG(info) << detName << "ClusterWriter:" << i << " pulled " << (*compClusterSizes)[i] << " clusters, in " << rofs.size() << " RO frames";
+  };
+  auto getIndex = [](DataRef const& ref) -> size_t {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    return static_cast<size_t>(dh->subSpecification);
+  };
+  auto getName = [](std::string base, size_t index) -> std::string {
+    if constexpr (DPLAlpideParam<N>::supportsStaggering()) {
+      return base += "_" + std::to_string(index);
+    }
+    return base;
+  };
+  auto detNameLC = detName;
+  std::transform(detNameLC.begin(), detNameLC.end(), detNameLC.begin(), [](unsigned char c) { return std::tolower(c); });
+  return MakeRootTreeWriterSpec(std::format("{}-cluster-writer", detNameLC).c_str(),
+                                (o2::detectors::DetID::ITS == N) ? "o2clus_its.root" : "mftclusters.root",
+                                MakeRootTreeWriterSpec::TreeAttributes{.name = "o2sim", .title = std::format("Tree with {} clusters", detName)},
+                                BranchDefinition<CompClusType>{InputSpec{"compclus", ConcreteDataTypeMatcher{Origin, "COMPCLUSTERS"}},
+                                                               (detName + "ClusterComp").c_str(), "compact-cluster-branch",
+                                                               NLayers,
+                                                               compClustersSizeGetter,
+                                                               getIndex,
+                                                               getName},
+                                BranchDefinition<PatternsType>{InputSpec{"patterns", ConcreteDataTypeMatcher{Origin, "PATTERNS"}},
+                                                               (detName + "ClusterPatt").c_str(), "cluster-pattern-branch",
+                                                               NLayers,
+                                                               getIndex,
+                                                               getName},
+                                BranchDefinition<ROFrameRType>{InputSpec{"ROframes", ConcreteDataTypeMatcher{Origin, "CLUSTERSROF"}},
+                                                               (detName + "ClustersROF").c_str(), "cluster-rof-branch",
+                                                               NLayers,
+                                                               logger,
+                                                               getIndex,
+                                                               getName},
+                                BranchDefinition<LabelsType>{InputSpec{"labels", ConcreteDataTypeMatcher{Origin, "CLUSTERSMCTR"}},
+                                                             (detName + "ClusterMCTruth").c_str(), "cluster-label-branch",
+                                                             (useMC ? NLayers : 0),
+                                                             getIndex,
+                                                             getName},
+                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", ConcreteDataTypeMatcher{Origin, "CLUSTERSMC2ROF"}},
+                                                             (detName + "ClustersMC2ROF").c_str(), "cluster-mc2rof-branch",
+                                                             (useMC ? NLayers : 0),
+                                                             getIndex,
+                                                             getName})();
+}
+
+framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC) { return getClusterWriterSpec<o2::detectors::DetID::ITS>(useMC); }
+framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC) { return getClusterWriterSpec<o2::detectors::DetID::MFT>(useMC); }
+
+} // namespace o2::itsmft
diff --git a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
new file mode 100644
index 0000000000000..0b6bb44ee78c8
--- /dev/null
+++ b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
@@ -0,0 +1,325 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   ClustererSpec.cxx
+
+#include <vector>
+
+#include "ITSMFTWorkflow/ClustererSpec.h"
+#include "Framework/ControlService.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/CCDBParamSpec.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "Framework/InputRecordWalker.h"
+#include "ITSMFTReconstruction/ChipMappingMFT.h"
+#include "ITSMFTReconstruction/ChipMappingITS.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsParameters/GRPObject.h"
+#include "ITSMFTReconstruction/DigitPixelReader.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "ITSMFTBase/DPLAlpideParam.h"
+#include "CommonConstants/LHCConstants.h"
+#include "DetectorsCommonDataFormats/DetectorNameConf.h"
+#include "ITSMFTReconstruction/ClustererParam.h"
+
+namespace o2::itsmft
+{
+
+template <int N>
+void ClustererDPL<N>::init(InitContext& ic)
+{
+  mClusterer = std::make_unique<o2::itsmft::Clusterer>();
+  mClusterer->setNChips((N == o2::detectors::DetID::ITS) ? o2::itsmft::ChipMappingITS::getNChips() : o2::itsmft::ChipMappingMFT::getNChips());
+  mUseClusterDictionary = !ic.options().get<bool>("ignore-cluster-dictionary");
+  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
+  mNThreads = std::max(1, ic.options().get<int>("nthreads"));
+  mDetName = Origin.as<std::string>();
+
+  // prepare data filter
+  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
+    mFilter.emplace_back("digits", Origin, "DIGITS", iLayer, Lifetime::Timeframe);
+    mFilter.emplace_back("ROframe", Origin, "DIGITSROF", iLayer, Lifetime::Timeframe);
+    if (mUseMC) {
+      mFilter.emplace_back("labels", Origin, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
+      mFilter.emplace_back("MC2ROframes", Origin, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
+    }
+  }
+}
+
+template <int N>
+void ClustererDPL<N>::run(ProcessingContext& pc)
+{
+  updateTimeDependentParams(pc);
+
+  // filter input and compose
+  std::array<gsl::span<const o2::itsmft::Digit>, NLayers> digits;
+  std::array<gsl::span<const o2::itsmft::ROFRecord>, NLayers> rofs;
+  std::array<gsl::span<const char>, NLayers> labelsbuffer;
+  std::array<gsl::span<const o2::itsmft::MC2ROFRecord>, NLayers> mc2rofs;
+  for (const DataRef& ref : InputRecordWalker{pc.inputs(), mFilter}) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    if (DataRefUtils::match(ref, {"digits", ConcreteDataTypeMatcher{Origin, "DIGITS"}})) {
+      digits[dh->subSpecification] = pc.inputs().get<gsl::span<o2::itsmft::Digit>>(ref);
+    }
+    if (DataRefUtils::match(ref, {"ROframe", ConcreteDataTypeMatcher{Origin, "DIGITSROF"}})) {
+      rofs[dh->subSpecification] = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>(ref);
+    }
+    if (DataRefUtils::match(ref, {"labels", ConcreteDataTypeMatcher{Origin, "DIGITSMCTR"}})) {
+      labelsbuffer[dh->subSpecification] = pc.inputs().get<gsl::span<char>>(ref);
+    }
+    if (DataRefUtils::match(ref, {"MC2ROframes", ConcreteDataTypeMatcher{Origin, "DIGITSMC2ROF"}})) {
+      mc2rofs[dh->subSpecification] = pc.inputs().get<gsl::span<o2::itsmft::MC2ROFRecord>>(ref);
+    }
+  }
+
+  // query the first orbit in this TF
+  const auto firstTForbit = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
+  const o2::InteractionRecord firstIR(0, firstTForbit);
+  const auto& par = DPLAlpideParam<N>::Instance();
+
+  // process received inputs
+  uint64_t nClusters{0};
+  TStopwatch sw;
+  o2::itsmft::DigitPixelReader reader;
+  for (uint32_t iLayer{0}; iLayer < NLayers; ++iLayer) {
+    int layer = (DPLAlpideParam<N>::supportsStaggering()) ? iLayer : -1;
+    sw.Start();
+    LOG(info) << mDetName << "Clusterer:" << layer << " pulled " << digits[iLayer].size() << " digits, in " << rofs[iLayer].size() << " RO frames";
+
+    mClusterer->setMaxROFDepthToSquash(mClusterer->getMaxROFDepthToSquash(layer));
+    o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelsbuffer[iLayer]);
+    reader.setSquashingDepth(mClusterer->getMaxROFDepthToSquash(layer));
+    reader.setSquashingDist(mClusterer->getMaxRowColDiffToMask()); // Sharing same parameter/logic with masking
+    reader.setMaxBCSeparationToSquash(mClusterer->getMaxBCSeparationToSquash(layer));
+    reader.setDigits(digits[iLayer]);
+    reader.setROFRecords(rofs[iLayer]);
+    if (mUseMC) {
+      reader.setMC2ROFRecords(mc2rofs[iLayer]);
+      LOG(info) << mDetName << "Clusterer:" << layer << " pulled " << labels.getNElements() << " labels ";
+      reader.setDigitsMCTruth(labels.getIndexedSize() > 0 ? &labels : nullptr);
+    }
+    reader.init();
+    std::vector<o2::itsmft::CompClusterExt> clusCompVec;
+    std::vector<o2::itsmft::ROFRecord> clusROFVec;
+    std::vector<unsigned char> clusPattVec;
+
+    std::unique_ptr<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> clusterLabels;
+    if (mUseMC) {
+      clusterLabels = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
+    }
+    mClusterer->process(mNThreads, reader, &clusCompVec, &clusPattVec, &clusROFVec, clusterLabels.get());
+
+    // ensure that the rof output is continuous
+    size_t nROFs = clusROFVec.size();
+    const int nROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / par.getROFLengthInBC(iLayer);
+    const int nROFsTF = nROFsPerOrbit * o2::base::GRPGeomHelper::getNHBFPerTF();
+    if (nROFsTF != clusROFVec.size()) {
+      // it can happen that in the digitization rofs without contributing hits are skipped
+      // however downstream consumers of the clusters cannot know apriori the time structure
+      // the cluster rofs do not account for the bias so it will start always at BC=0
+      // if we receive more cluster rofs then there supposed to be, do not throw away this data
+      // the clusterer should be blind to this!
+      const size_t nROFsLayer = std::max((size_t)nROFsTF, clusROFVec.size());
+      std::vector<o2::itsmft::ROFRecord> expClusRofVec(nROFsLayer);
+      for (int iROF{0}; iROF < nROFsLayer; ++iROF) {
+        auto& rof = expClusRofVec[iROF];
+        int orb = iROF * par.getROFLengthInBC(iLayer) / o2::constants::lhc::LHCMaxBunches + firstTForbit;
+        int bc = iROF * par.getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches;
+        o2::InteractionRecord ir(bc, orb);
+        rof.setBCData(ir);
+        rof.setROFrame(iROF);
+        rof.setNEntries(0);
+        rof.setFirstEntry(-1);
+      }
+      uint32_t prevEntry{0};
+      for (const auto& rof : clusROFVec) {
+        const auto& ir = rof.getBCData();
+        const auto irToFirst = ir - firstIR;
+        const int irROF = irToFirst.toLong() / par.getROFLengthInBC(iLayer);
+        auto& expROF = expClusRofVec[irROF];
+        expROF.setFirstEntry(rof.getFirstEntry());
+        expROF.setNEntries(rof.getNEntries());
+        if (expROF.getBCData() != rof.getBCData()) {
+          LOGP(fatal, "detected mismatch between expected ROF:{} and received ROF:{}", expROF.asString(), rof.asString());
+        }
+      }
+      int prevFirst{0};
+      for (auto& rof : expClusRofVec) {
+        if (rof.getFirstEntry() < 0) {
+          rof.setFirstEntry(prevFirst);
+        }
+        prevFirst = rof.getFirstEntry();
+      }
+      nROFs = expClusRofVec.size();
+      pc.outputs().snapshot(Output{Origin, "CLUSTERSROF", iLayer}, expClusRofVec);
+    } else {
+      pc.outputs().snapshot(Output{Origin, "CLUSTERSROF", iLayer}, clusROFVec);
+    }
+    pc.outputs().snapshot(Output{Origin, "COMPCLUSTERS", iLayer}, clusCompVec);
+    pc.outputs().snapshot(Output{Origin, "PATTERNS", iLayer}, clusPattVec);
+
+    nClusters += clusCompVec.size();
+
+    if (mUseMC) {
+      pc.outputs().snapshot(Output{Origin, "CLUSTERSMCTR", iLayer}, *clusterLabels); // at the moment requires snapshot
+      std::vector<o2::itsmft::MC2ROFRecord> clusterMC2ROframes(mc2rofs[iLayer].size());
+      for (int i = mc2rofs[iLayer].size(); i--;) {
+        clusterMC2ROframes[i] = mc2rofs[iLayer][i]; // Simply, replicate it from digits ?
+      }
+      pc.outputs().snapshot(Output{Origin, "CLUSTERSMC2ROF", iLayer}, clusterMC2ROframes);
+    }
+    reader.reset();
+
+    // TODO: in principle, after masking "overflow" pixels the MC2ROFRecord maxROF supposed to change, nominally to minROF
+    // -> consider recalculationg maxROF
+    sw.Stop();
+    LOG(info) << mDetName << "Clusterer:" << layer << " pushed " << clusCompVec.size() << " clusters, in " << nROFs << " RO frames in " << sw.RealTime() << " s";
+  }
+
+  LOG(info) << mDetName << "Clusterer produced " << nClusters << " clusters";
+}
+
+///_______________________________________
+template <int N>
+void ClustererDPL<N>::updateTimeDependentParams(ProcessingContext& pc)
+{
+  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+  static bool initOnceDone = false;
+  if (!initOnceDone) { // this params need to be queried only once
+    initOnceDone = true;
+    pc.inputs().get<TopologyDictionary*>("cldict"); // just to trigger the finaliseCCDB
+    pc.inputs().get<o2::itsmft::DPLAlpideParam<N>*>("alppar");
+    pc.inputs().get<o2::itsmft::ClustererParam<N>*>("cluspar");
+    mClusterer->setContinuousReadOut(o2::base::GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(N));
+    // settings for the fired pixel overflow masking
+    const auto& alpParams = o2::itsmft::DPLAlpideParam<N>::Instance();
+    const auto& clParams = o2::itsmft::ClustererParam<N>::Instance();
+    if (clParams.maxBCDiffToMaskBias > 0 && clParams.maxBCDiffToSquashBias > 0) {
+      LOGP(fatal, "maxBCDiffToMaskBias = {} and maxBCDiffToSquashBias = {} cannot be set at the same time. Either set masking or squashing with a BCDiff > 0", clParams.maxBCDiffToMaskBias, clParams.maxBCDiffToSquashBias);
+    }
+    mClusterer->setDropHugeClusters(clParams.dropHugeClusters);
+    auto nbc = clParams.maxBCDiffToMaskBias;
+    nbc += mClusterer->isContinuousReadOut() ? alpParams.roFrameLengthInBC : (alpParams.roFrameLengthTrig / o2::constants::lhc::LHCBunchSpacingNS);
+    mClusterer->setMaxBCSeparationToMask(nbc);
+    mClusterer->setMaxRowColDiffToMask(clParams.maxRowColDiffToMask);
+    // Squasher
+    int rofBC = mClusterer->isContinuousReadOut() ? alpParams.roFrameLengthInBC : (alpParams.roFrameLengthTrig / o2::constants::lhc::LHCBunchSpacingNS); // ROF length in BC
+    mClusterer->setMaxBCSeparationToSquash(rofBC + clParams.maxBCDiffToSquashBias);
+    int nROFsToSquash = 0; // squashing disabled if no reset due to maxSOTMUS>0.
+    if (clParams.maxSOTMUS > 0 && rofBC > 0) {
+      nROFsToSquash = 2 + int(clParams.maxSOTMUS / (rofBC * o2::constants::lhc::LHCBunchSpacingMUS)); // use squashing
+    }
+    mClusterer->setMaxROFDepthToSquash(nROFsToSquash);
+    if constexpr (DPLAlpideParam<N>::supportsStaggering()) {
+      if (mClusterer->isContinuousReadOut()) {
+        for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
+          mClusterer->addMaxBCSeparationToSquash(alpParams.getROFLengthInBC(iLayer) + clParams.getMaxBCDiffToSquashBias(iLayer));
+          mClusterer->addMaxROFDepthToSquash((clParams.getMaxBCDiffToSquashBias(iLayer) > 0) ? 2 + int(clParams.maxSOTMUS / (alpParams.getROFLengthInBC(iLayer) * o2::constants::lhc::LHCBunchSpacingMUS)) : 0);
+        }
+      }
+    }
+    mClusterer->print(false);
+  }
+  // we may have other params which need to be queried regularly
+}
+
+///_______________________________________
+template <int N>
+void ClustererDPL<N>::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+{
+  if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
+    return;
+  }
+  if (matcher == ConcreteDataMatcher(Origin, "CLUSDICT", 0)) {
+    LOG(info) << "cluster dictionary updated" << (!mUseClusterDictionary ? " but its using is disabled" : "");
+    if (mUseClusterDictionary) {
+      mClusterer->setDictionary((const TopologyDictionary*)obj);
+    }
+    return;
+  }
+  // Note: strictly speaking, for Configurable params we don't need finaliseCCDB check, the singletons are updated at the CCDB fetcher level
+  if (matcher == ConcreteDataMatcher(Origin, "ALPIDEPARAM", 0)) {
+    LOG(info) << "Alpide param updated";
+    const auto& par = o2::itsmft::DPLAlpideParam<N>::Instance();
+    par.printKeyValues();
+    return;
+  }
+  if (matcher == ConcreteDataMatcher(Origin, "CLUSPARAM", 0)) {
+    LOG(info) << "Cluster param updated";
+    const auto& par = o2::itsmft::ClustererParam<N>::Instance();
+    par.printKeyValues();
+    return;
+  }
+}
+
+namespace
+{
+template <int N>
+DataProcessorSpec getClustererSpec(bool useMC)
+{
+  constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  std::vector<InputSpec> inputs;
+  constexpr uint32_t nLayers = (DPLAlpideParam<N>::supportsStaggering()) ? DPLAlpideParam<N>::getNLayers() : 1;
+  for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
+    inputs.emplace_back("digits", Origin, "DIGITS", iLayer, Lifetime::Timeframe);
+    inputs.emplace_back("ROframes", Origin, "DIGITSROF", iLayer, Lifetime::Timeframe);
+    if (useMC) {
+      inputs.emplace_back("labels", Origin, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
+      inputs.emplace_back("MC2ROframes", Origin, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
+    }
+  }
+  inputs.emplace_back("cldict", Origin, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(Origin.as<std::string>() + "/Calib/ClusterDictionary"));
+  inputs.emplace_back("cluspar", Origin, "CLUSPARAM", 0, Lifetime::Condition, ccdbParamSpec(Origin.as<std::string>() + "/Config/ClustererParam"));
+  inputs.emplace_back("alppar", Origin, "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec(Origin.as<std::string>() + "/Config/AlpideParam"));
+  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
+                                                              true,                           // GRPECS=true
+                                                              false,                          // GRPLHCIF
+                                                              false,                          // GRPMagField
+                                                              false,                          // askMatLUT
+                                                              o2::base::GRPGeomRequest::None, // geometry
+                                                              inputs,
+                                                              true);
+  std::vector<OutputSpec> outputs;
+  for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
+    outputs.emplace_back(Origin, "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
+    outputs.emplace_back(Origin, "PATTERNS", iLayer, Lifetime::Timeframe);
+    outputs.emplace_back(Origin, "CLUSTERSROF", iLayer, Lifetime::Timeframe);
+    if (useMC) {
+      outputs.emplace_back(Origin, "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(Origin, "CLUSTERSMC2ROF", iLayer, Lifetime::Timeframe);
+    }
+  }
+  return DataProcessorSpec{
+    .name = (N == o2::detectors::DetID::ITS) ? "its-clusterer" : "mft-clusterer",
+    .inputs = inputs,
+    .outputs = outputs,
+    .algorithm = AlgorithmSpec{adaptFromTask<ClustererDPL<N>>(ggRequest, useMC)},
+    .options = Options{
+      {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}},
+      {"nthreads", VariantType::Int, 1, {"Number of clustering threads"}}}};
+}
+} // namespace
+
+framework::DataProcessorSpec getITSClustererSpec(bool useMC)
+{
+  return getClustererSpec<o2::detectors::DetID::ITS>(useMC);
+}
+
+framework::DataProcessorSpec getMFTClustererSpec(bool useMC)
+{
+  return getClustererSpec<o2::detectors::DetID::MFT>(useMC);
+}
+
+} // namespace o2::itsmft
diff --git a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
index 004c3f6097167..60fe4fabfe481 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
@@ -12,7 +12,7 @@
 #include "ITS3Workflow/RecoWorkflow.h"
 #include "ITS3Workflow/ClustererSpec.h"
 #include "ITS3Workflow/TrackerSpec.h"
-#include "ITSWorkflow/ClusterWriterSpec.h"
+#include "ITSMFTWorkflow/ClusterWriterSpec.h"
 #include "ITSWorkflow/TrackWriterSpec.h"
 #include "ITS3Workflow/DigitReaderSpec.h"
 #include "GPUWorkflow/GPUWorkflowSpec.h"
@@ -40,7 +40,7 @@ framework::WorkflowSpec getWorkflow(bool useMC, its::TrackingMode::Type trmode,
   }
 
   if (!disableRootOutput) {
-    specs.emplace_back(o2::its::getClusterWriterSpec(useMC));
+    specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC));
   }
 
   if (trmode != its::TrackingMode::Off) {

From 4ec73c1134146fdf5648327c62d112625240f3c3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 12 Feb 2026 13:32:13 +0100
Subject: [PATCH 1317/1764] DPL: introduce range based views to navigate data
 model (#15061)

---
 .../Core/include/Framework/DataModelViews.h   | 239 ++++++++++++++++++
 1 file changed, 239 insertions(+)
 create mode 100644 Framework/Core/include/Framework/DataModelViews.h

diff --git a/Framework/Core/include/Framework/DataModelViews.h b/Framework/Core/include/Framework/DataModelViews.h
new file mode 100644
index 0000000000000..b7a334454bb6e
--- /dev/null
+++ b/Framework/Core/include/Framework/DataModelViews.h
@@ -0,0 +1,239 @@
+// Copyright 2019-2025 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef O2_FRAMEWORK_DATASPECVIEWS_H_
+#define O2_FRAMEWORK_DATASPECVIEWS_H_
+
+#include <fairmq/FwdDecls.h>
+#include <fairmq/Message.h>
+#include "DomainInfoHeader.h"
+#include "SourceInfoHeader.h"
+#include "Headers/DataHeader.h"
+#include <ranges>
+
+namespace o2::framework
+{
+
+struct count_payloads {
+  // ends the pipeline, returns the container
+  template <typename R>
+    requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
+  friend size_t operator|(R&& r, count_payloads self)
+  {
+    size_t count = 0;
+    size_t mi = 0;
+    while (mi < r.size()) {
+      auto* header = o2::header::get<o2::header::DataHeader*>(r[mi]->GetData());
+      if (!header) {
+        throw std::runtime_error("Not a DataHeader");
+      }
+      if (header->splitPayloadParts > 1 && header->splitPayloadIndex == header->splitPayloadParts) {
+        count += header->splitPayloadParts;
+        mi += header->splitPayloadParts + 1;
+      } else {
+        count += header->splitPayloadParts ? header->splitPayloadParts : 1;
+        mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
+      }
+    }
+    return count;
+  }
+};
+
+struct count_parts {
+  // ends the pipeline, returns the number of parts
+  template <typename R>
+    requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
+  friend size_t operator|(R&& r, count_parts self)
+  {
+    size_t count = 0;
+    size_t mi = 0;
+    while (mi < r.size()) {
+      auto* header = o2::header::get<o2::header::DataHeader*>(r[mi]->GetData());
+      auto* sih = o2::header::get<o2::framework::SourceInfoHeader*>(r[mi]->GetData());
+      auto* dih = o2::header::get<o2::framework::DomainInfoHeader*>(r[mi]->GetData());
+      if (!header && !sih && !dih) {
+        throw std::runtime_error("Header information not found");
+      }
+      // We skip oldest possible timeframe / end of stream and not consider it
+      // as actual parts.
+      if (dih || sih) {
+        count += 1;
+        mi += 2;
+      } else if (header->splitPayloadParts > 1 && header->splitPayloadIndex == header->splitPayloadParts) {
+        count += 1;
+        mi += header->splitPayloadParts + 1;
+      } else {
+        count += header->splitPayloadParts;
+        mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
+      }
+    }
+    return count;
+  }
+};
+
+struct DataRefIndices {
+  size_t headerIdx;
+  size_t payloadIdx;
+};
+
+struct get_pair {
+  size_t pairId;
+  template <typename R>
+    requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
+  friend DataRefIndices operator|(R&& r, get_pair self)
+  {
+    size_t count = 0;
+    size_t mi = 0;
+    while (mi < r.size()) {
+      auto* header = o2::header::get<o2::header::DataHeader*>(r[mi]->GetData());
+      if (!header) {
+        throw std::runtime_error("Not a DataHeader");
+      }
+      size_t diff = self.pairId - count;
+      if (header->splitPayloadParts > 1 && header->splitPayloadIndex == header->splitPayloadParts) {
+        count += header->splitPayloadParts;
+        if (self.pairId < count) {
+          return {mi, mi + 1 + diff};
+        }
+        mi += header->splitPayloadParts + 1;
+      } else {
+        count += header->splitPayloadParts ? header->splitPayloadParts : 1;
+        if (self.pairId < count) {
+          return {mi, mi + 2 * diff + 1};
+        }
+        mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
+      }
+    }
+    throw std::runtime_error("Payload not found");
+  }
+};
+
+struct get_dataref_indices {
+  size_t part;
+  size_t subPart;
+  // ends the pipeline, returns the number of parts
+  template <typename R>
+    requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
+  friend DataRefIndices operator|(R&& r, get_dataref_indices self)
+  {
+    size_t count = 0;
+    size_t mi = 0;
+    while (mi < r.size()) {
+      auto* header = o2::header::get<o2::header::DataHeader*>(r[mi]->GetData());
+      if (!header) {
+        throw std::runtime_error("Not a DataHeader");
+      }
+      if (header->splitPayloadParts > 1 && header->splitPayloadIndex == header->splitPayloadParts) {
+        if (self.part == count) {
+          return {mi, mi + 1 + self.subPart};
+        }
+        count += 1;
+        mi += header->splitPayloadParts + 1;
+      } else {
+        if (self.part == count) {
+          return {mi, mi + 2 * self.subPart + 1};
+        }
+        count += 1;
+        mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
+      }
+    }
+    throw std::runtime_error("Payload not found");
+  }
+};
+
+struct get_header {
+  size_t id;
+  // ends the pipeline, returns the number of parts
+  template <typename R>
+    requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
+  friend fair::mq::MessagePtr& operator|(R&& r, get_header self)
+  {
+    return r[(r | get_dataref_indices{self.id, 0}).headerIdx];
+  }
+};
+
+struct get_payload {
+  size_t part;
+  size_t subPart;
+  // ends the pipeline, returns the number of parts
+  template <typename R>
+    requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
+  friend fair::mq::MessagePtr& operator|(R&& r, get_payload self)
+  {
+    return r[(r | get_dataref_indices{self.part, self.subPart}).payloadIdx];
+  }
+};
+
+struct get_num_payloads {
+  size_t id;
+  // ends the pipeline, returns the number of parts
+  template <typename R>
+    requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
+  friend size_t operator|(R&& r, get_num_payloads self)
+  {
+    size_t count = 0;
+    size_t mi = 0;
+    while (mi < r.size()) {
+      auto* header = o2::header::get<o2::header::DataHeader*>(r[mi]->GetData());
+      if (!header) {
+        throw std::runtime_error("Not a DataHeader");
+      }
+      if (self.id == count) {
+        if (header->splitPayloadParts > 1 && (header->splitPayloadIndex == header->splitPayloadParts)) {
+          return header->splitPayloadParts;
+        } else {
+          return 1;
+        }
+      }
+      if (header->splitPayloadParts > 1 && (header->splitPayloadIndex == header->splitPayloadParts)) {
+        count += 1;
+        mi += header->splitPayloadParts + 1;
+      } else {
+        count += 1;
+        mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
+      }
+    }
+    return 0;
+  }
+};
+
+struct MessageSet;
+
+struct MessageStore {
+  std::span<MessageSet> sets;
+  size_t inputsPerSlot = 0;
+};
+
+struct inputs_for_slot {
+  TimesliceSlot slot;
+  template <typename R>
+    requires requires(R r) { std::ranges::random_access_range<decltype(r.sets)>; }
+  friend std::span<o2::framework::MessageSet> operator|(R&& r, inputs_for_slot self)
+  {
+    return std::span(r.sets[self.slot.index * r.inputsPerSlot]);
+  }
+};
+
+struct messages_for_input {
+  size_t inputIdx;
+  template <typename R>
+    requires std::ranges::random_access_range<R>
+  friend std::span<fair::mq::MessagePtr> operator|(R&& r, messages_for_input self)
+  {
+    return r[self.inputIdx].messages;
+  }
+};
+
+// FIXME: we should use special index classes in place of size_t
+// FIXME: we need something to substitute a range in the store with another
+
+} // namespace o2::framework
+
+#endif // O2_FRAMEWORK_DATASPECVIEWS_H_

From 834cbc5b6f9e0f73b4bdedbb96df73538571571f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 12 Feb 2026 14:39:27 +0100
Subject: [PATCH 1318/1764] FST: Make previousOrbit configurable

---
 prodtests/full_system_test.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index e2ecca590140f..82021d6c65e63 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -40,6 +40,7 @@ export LC_ALL=C
 BEAMTYPE=${BEAMTYPE:-PbPb}
 NEvents=${NEvents:-10} #550 for full TF (the number of PbPb events)
 NEventsQED=${NEventsQED:-1000} #35000 for full TF
+OrbitsBeforeTf=${OrbitsBeforeTf:-1}
 NCPUS=$(getNumberOfPhysicalCPUCores)
 echo "Found ${NCPUS} physical CPU cores"
 NJOBS=${NJOBS:-"${NCPUS}"}
@@ -159,7 +160,7 @@ taskwrapper collcontext.log o2-steer-colcontexttool \
   --extract-per-timeframe tf:o2sim \
   --with-vertices kCCDB \
   --maxCollsPerTF ${NEvents} \
-  --orbitsEarly 1 \
+  --orbitsEarly ${OrbitsBeforeTf} \
   --bcPatternFile ccdb \
   ${QEDSPEC}
 

From 23765b5bdef76fb5a3151d01df8f908936aacf94 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 13 Feb 2026 09:03:17 +0100
Subject: [PATCH 1319/1764] DPL: Enforce that dpl pipeline length is at least
 as long as number of TFs in flight (#15048)

---
 .../Core/include/Framework/DataRelayer.h      |  3 ++-
 .../Core/include/Framework/DefaultsHelpers.h  | 10 +++++++-
 Framework/Core/src/ArrowSupport.cxx           |  2 +-
 Framework/Core/src/CommonServices.cxx         |  4 +++-
 Framework/Core/src/DataProcessingDevice.cxx   | 12 ++++++----
 Framework/Core/src/DataRelayer.cxx            | 17 ++++++++++++--
 Framework/Core/src/DefaultsHelpers.cxx        | 23 +++++++++++++++----
 Framework/Core/src/runDataProcessing.cxx      |  5 ++--
 Framework/Core/test/benchmark_DataRelayer.cxx | 10 ++++----
 Framework/Core/test/test_DataRelayer.cxx      | 22 +++++++++---------
 10 files changed, 75 insertions(+), 33 deletions(-)

diff --git a/Framework/Core/include/Framework/DataRelayer.h b/Framework/Core/include/Framework/DataRelayer.h
index 1e010fc12f3d4..e5a2aecea1de4 100644
--- a/Framework/Core/include/Framework/DataRelayer.h
+++ b/Framework/Core/include/Framework/DataRelayer.h
@@ -102,7 +102,8 @@ class DataRelayer
   DataRelayer(CompletionPolicy const&,
               std::vector<InputRoute> const& routes,
               TimesliceIndex&,
-              ServiceRegistryRef);
+              ServiceRegistryRef,
+              int);
 
   /// This invokes the appropriate `InputRoute::danglingChecker` on every
   /// entry in the cache and if it returns true, it creates a new
diff --git a/Framework/Core/include/Framework/DefaultsHelpers.h b/Framework/Core/include/Framework/DefaultsHelpers.h
index 16d41d03baa7f..68e64cc42a90e 100644
--- a/Framework/Core/include/Framework/DefaultsHelpers.h
+++ b/Framework/Core/include/Framework/DefaultsHelpers.h
@@ -12,16 +12,24 @@
 #ifndef O2_FRAMEWORK_DEFAULTHELPERS_H_
 #define O2_FRAMEWORK_DEFAULTHELPERS_H_
 
+namespace fair::mq
+{
+class ProgOptions;
+}
+
 namespace o2::framework
 {
 enum struct DeploymentMode;
+struct DeviceConfig;
 
 struct DefaultsHelpers {
   static DeploymentMode deploymentMode();
   /// @true if running online
   static bool onlineDeploymentMode();
   /// get max number of timeslices in the queue
-  static unsigned int pipelineLength();
+  static unsigned int pipelineLength(unsigned int minLength);
+  static unsigned int pipelineLength(const fair::mq::ProgOptions& options);
+  static unsigned int pipelineLength(const DeviceConfig& dc);
 };
 } // namespace o2::framework
 
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 450f31f4ba7d3..c5cc021a53478 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -564,7 +564,7 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        if (dc.options.count("timeframes-rate-limit") && dc.options["timeframes-rate-limit"].defaulted() == false) {
                          config->maxTimeframes = std::stoll(dc.options["timeframes-rate-limit"].as<std::string>());
                        } else {
-                         config->maxTimeframes = readers * DefaultsHelpers::pipelineLength();
+                         config->maxTimeframes = readers * DefaultsHelpers::pipelineLength(dc);
                        }
                        static bool once = false;
                        // Until we guarantee this is called only once...
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index f786d99fd2c0d..6486406a06dca 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -414,11 +414,13 @@ o2::framework::ServiceSpec CommonServices::dataRelayer()
     .name = "datarelayer",
     .init = [](ServiceRegistryRef services, DeviceState&, fair::mq::ProgOptions& options) -> ServiceHandle {
       auto& spec = services.get<DeviceSpec const>();
+      int pipelineLength = DefaultsHelpers::pipelineLength(options);
       return ServiceHandle{TypeIdHelpers::uniqueId<DataRelayer>(),
                            new DataRelayer(spec.completionPolicy,
                                            spec.inputs,
                                            services.get<TimesliceIndex>(),
-                                           services)};
+                                           services,
+                                           pipelineLength)};
     },
     .configure = noConfiguration(),
     .kind = ServiceKind::Serial};
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index ccfb58db7559a..da04a23e81c0c 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1483,7 +1483,7 @@ void DataProcessingDevice::doPrepare(ServiceRegistryRef ref)
   auto& infos = state.inputChannelInfos;
 
   if (context.balancingInputs) {
-    static int pipelineLength = DefaultsHelpers::pipelineLength();
+    static int pipelineLength = DefaultsHelpers::pipelineLength(*ref.get<RawDeviceService>().device()->fConfig);
     static uint64_t ahead = getenv("DPL_MAX_CHANNEL_AHEAD") ? std::atoll(getenv("DPL_MAX_CHANNEL_AHEAD")) : std::max(8, std::min(pipelineLength - 48, pipelineLength / 2));
     auto newEnd = std::remove_if(pollOrder.begin(), pollOrder.end(), [&infos, limitNew = currentOldest.value + ahead](int a) -> bool {
       return infos[a].oldestForChannel.value > limitNew;
@@ -2259,12 +2259,14 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     return false;
   }
 
-  auto postUpdateStats = [ref](DataRelayer::RecordAction const& action, InputRecord const& record, uint64_t tStart, uint64_t tStartMilli) {
+  int pipelineLength = DefaultsHelpers::pipelineLength(*ref.get<RawDeviceService>().device()->fConfig);
+
+  auto postUpdateStats = [ref, pipelineLength](DataRelayer::RecordAction const& action, InputRecord const& record, uint64_t tStart, uint64_t tStartMilli) {
     auto& stats = ref.get<DataProcessingStats>();
     auto& states = ref.get<DataProcessingStates>();
     std::atomic_thread_fence(std::memory_order_release);
     char relayerSlotState[1024];
-    int written = snprintf(relayerSlotState, 1024, "%d ", DefaultsHelpers::pipelineLength());
+    int written = snprintf(relayerSlotState, 1024, "%d ", pipelineLength);
     char* buffer = relayerSlotState + written;
     for (size_t ai = 0; ai != record.size(); ai++) {
       buffer[ai] = record.isValid(ai) ? '3' : '0';
@@ -2291,11 +2293,11 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     count++;
   };
 
-  auto preUpdateStats = [ref](DataRelayer::RecordAction const& action, InputRecord const& record, uint64_t) {
+  auto preUpdateStats = [ref, pipelineLength](DataRelayer::RecordAction const& action, InputRecord const& record, uint64_t) {
     auto& states = ref.get<DataProcessingStates>();
     std::atomic_thread_fence(std::memory_order_release);
     char relayerSlotState[1024];
-    snprintf(relayerSlotState, 1024, "%d ", DefaultsHelpers::pipelineLength());
+    snprintf(relayerSlotState, 1024, "%d ", pipelineLength);
     char* buffer = strchr(relayerSlotState, ' ') + 1;
     for (size_t ai = 0; ai != record.size(); ai++) {
       buffer[ai] = record.isValid(ai) ? '2' : '0';
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 05b64b6ed1dad..cece5b343659f 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -37,6 +37,7 @@
 #include "Framework/DataProcessingStates.h"
 #include "Framework/DataTakingContext.h"
 #include "Framework/DefaultsHelpers.h"
+#include "Framework/RawDeviceService.h"
 
 #include "Headers/DataHeaderHelpers.h"
 #include "Framework/Formatters.h"
@@ -48,6 +49,7 @@
 #include <fairmq/Channel.h>
 #include <functional>
 #include <fairmq/shmem/Message.h>
+#include <fairmq/Device.h>
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 #include <span>
@@ -70,7 +72,8 @@ constexpr int INVALID_INPUT = -1;
 DataRelayer::DataRelayer(const CompletionPolicy& policy,
                          std::vector<InputRoute> const& routes,
                          TimesliceIndex& index,
-                         ServiceRegistryRef services)
+                         ServiceRegistryRef services,
+                         int pipelineLength)
   : mContext{services},
     mTimesliceIndex{index},
     mCompletionPolicy{policy},
@@ -81,7 +84,17 @@ DataRelayer::DataRelayer(const CompletionPolicy& policy,
   std::scoped_lock<O2_LOCKABLE(std::recursive_mutex)> lock(mMutex);
 
   if (policy.configureRelayer == nullptr) {
-    static int pipelineLength = DefaultsHelpers::pipelineLength();
+    if (pipelineLength == -1) {
+      auto getPipelineLengthHelper = [&services]() {
+        try {
+          return DefaultsHelpers::pipelineLength(*services.get<RawDeviceService>().device()->fConfig);
+        } catch (...) {
+          return DefaultsHelpers::pipelineLength(0);
+        }
+      };
+      static int detectedPipelineLength = getPipelineLengthHelper();
+      pipelineLength = detectedPipelineLength;
+    }
     setPipelineLength(pipelineLength);
   } else {
     policy.configureRelayer(*this);
diff --git a/Framework/Core/src/DefaultsHelpers.cxx b/Framework/Core/src/DefaultsHelpers.cxx
index 4dcc734216f0c..5fd1ed29e7af6 100644
--- a/Framework/Core/src/DefaultsHelpers.cxx
+++ b/Framework/Core/src/DefaultsHelpers.cxx
@@ -11,6 +11,9 @@
 
 #include "Framework/DefaultsHelpers.h"
 #include "Framework/DataTakingContext.h"
+#include "Framework/DeviceConfig.h"
+#include <fairmq/ProgOptions.h>
+
 #include <cstdlib>
 #include <cstring>
 #include <stdexcept>
@@ -18,23 +21,35 @@
 namespace o2::framework
 {
 
-unsigned int DefaultsHelpers::pipelineLength()
+unsigned int DefaultsHelpers::pipelineLength(unsigned int minLength)
 {
   static bool override = getenv("DPL_DEFAULT_PIPELINE_LENGTH");
   if (override) {
     static unsigned int retval = atoi(getenv("DPL_DEFAULT_PIPELINE_LENGTH"));
-    return retval;
+    return std::max(minLength, retval);
   }
   DeploymentMode deploymentMode = DefaultsHelpers::deploymentMode();
   // just some reasonable numers
   // The number should really be tuned at runtime for each processor.
   if (deploymentMode == DeploymentMode::OnlineDDS || deploymentMode == DeploymentMode::OnlineECS || deploymentMode == DeploymentMode::FST) {
-    return 512;
+    return std::max(minLength, 512u);
   } else {
-    return 64;
+    return std::max(minLength, 64u);
   }
 }
 
+unsigned int DefaultsHelpers::pipelineLength(const DeviceConfig& dc)
+{
+  static unsigned int minLength = dc.options.count("timeframes-rate-limit") ? std::max(0, atoi(dc.options["timeframes-rate-limit"].as<std::string>().c_str())) : 0;
+  return pipelineLength(minLength);
+}
+
+unsigned int DefaultsHelpers::pipelineLength(const fair::mq::ProgOptions& options)
+{
+  static unsigned int minLength = options.Count("timeframes-rate-limit") ? std::max(0, atoi(options.GetValue<std::string>("timeframes-rate-limit").c_str())) : 0;
+  return pipelineLength(minLength);
+}
+
 static DeploymentMode getDeploymentMode_internal()
 {
   char* explicitMode = getenv("O2_DPL_DEPLOYMENT_MODE");
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 166f26878c363..ced884ebaa1ed 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -817,7 +817,8 @@ void spawnDevice(uv_loop_t* loop,
     .sendInitialValue = true,
   });
 
-  for (size_t i = 0; i < DefaultsHelpers::pipelineLength(); ++i) {
+  unsigned int pipelineLength = DefaultsHelpers::pipelineLength(DeviceConfig{varmap});
+  for (size_t i = 0; i < pipelineLength; ++i) {
     allStates.back().registerState(DataProcessingStates::StateSpec{
       .name = fmt::format("matcher_variables/{}", i),
       .stateId = static_cast<short>((short)(ProcessingStateId::CONTEXT_VARIABLES_BASE) + i),
@@ -826,7 +827,7 @@ void spawnDevice(uv_loop_t* loop,
     });
   }
 
-  for (size_t i = 0; i < DefaultsHelpers::pipelineLength(); ++i) {
+  for (size_t i = 0; i < pipelineLength; ++i) {
     allStates.back().registerState(DataProcessingStates::StateSpec{
       .name = fmt::format("data_relayer/{}", i),
       .stateId = static_cast<short>((short)(ProcessingStateId::DATA_RELAYER_BASE) + i),
diff --git a/Framework/Core/test/benchmark_DataRelayer.cxx b/Framework/Core/test/benchmark_DataRelayer.cxx
index dcff3930dbaad..3c3d2294fdd7e 100644
--- a/Framework/Core/test/benchmark_DataRelayer.cxx
+++ b/Framework/Core/test/benchmark_DataRelayer.cxx
@@ -65,7 +65,7 @@ static void BM_RelaySingleSlot(benchmark::State& state)
   TimesliceIndex index{1, infos};
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
   ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry});
+  DataRelayer relayer(policy, inputs, index, {registry}, -1);
   relayer.setPipelineLength(4);
 
   // Let's create a dummy O2 Message with two headers in the stack:
@@ -118,7 +118,7 @@ static void BM_RelayMultipleSlots(benchmark::State& state)
 
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
   ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry});
+  DataRelayer relayer(policy, inputs, index, {registry}, -1);
   relayer.setPipelineLength(4);
 
   // Let's create a dummy O2 Message with two headers in the stack:
@@ -177,7 +177,7 @@ static void BM_RelayMultipleRoutes(benchmark::State& state)
 
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
   ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry});
+  DataRelayer relayer(policy, inputs, index, {registry}, -1);
   relayer.setPipelineLength(4);
 
   // Let's create a dummy O2 Message with two headers in the stack:
@@ -254,7 +254,7 @@ static void BM_RelaySplitParts(benchmark::State& state)
 
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
   ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry});
+  DataRelayer relayer(policy, inputs, index, {registry}, -1);
   relayer.setPipelineLength(4);
 
   // Let's create a dummy O2 Message with two headers in the stack:
@@ -314,7 +314,7 @@ static void BM_RelayMultiplePayloads(benchmark::State& state)
 
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
   ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry});
+  DataRelayer relayer(policy, inputs, index, {registry}, -1);
   relayer.setPipelineLength(4);
 
   // DataHeader matching the one provided in the input
diff --git a/Framework/Core/test/test_DataRelayer.cxx b/Framework/Core/test/test_DataRelayer.cxx
index 7d5a3ded88e16..8957e361cb8a2 100644
--- a/Framework/Core/test/test_DataRelayer.cxx
+++ b/Framework/Core/test/test_DataRelayer.cxx
@@ -83,7 +83,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::consumeWhenAny();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     relayer.setPipelineLength(4);
 
     // Let's create a dummy O2 Message with two headers in the stack:
@@ -133,7 +133,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::consumeWhenAny();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     relayer.setPipelineLength(4);
 
     // Let's create a dummy O2 Message with two headers in the stack:
@@ -195,7 +195,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::consumeWhenAll();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     relayer.setPipelineLength(4);
 
     auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
@@ -276,7 +276,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::consumeWhenAll();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     relayer.setPipelineLength(3);
 
     auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
@@ -359,7 +359,7 @@ TEST_CASE("DataRelayer")
     std::vector<InputChannelInfo> infos{1};
     TimesliceIndex index{1, infos};
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     // Only two messages to fill the cache.
     relayer.setPipelineLength(2);
 
@@ -437,7 +437,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::processWhenAny();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     // Only two messages to fill the cache.
     relayer.setPipelineLength(2);
 
@@ -509,7 +509,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::processWhenAny();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     // Only two messages to fill the cache.
     relayer.setPipelineLength(3);
 
@@ -568,7 +568,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::processWhenAny();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     // Only two messages to fill the cache.
     relayer.setPipelineLength(1);
 
@@ -629,7 +629,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::processWhenAny();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     // Only two messages to fill the cache.
     relayer.setPipelineLength(1);
 
@@ -698,7 +698,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::consumeWhenAny();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     relayer.setPipelineLength(4);
 
     DataHeader dh{"CLUSTERS", "TPC", 0};
@@ -752,7 +752,7 @@ TEST_CASE("DataRelayer")
     ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
 
     auto policy = CompletionPolicyHelpers::consumeWhenAny();
-    DataRelayer relayer(policy, inputs, index, {registry});
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
     relayer.setPipelineLength(4);
 
     auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");

From ab29595c9106a6f5c28bc1a12cb0402cb7f446b8 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 13 Feb 2026 10:47:40 +0100
Subject: [PATCH 1320/1764] Update examples on AO2D creation from MCTracks
 (#15056)

---
 run/SimExamples/HepMC_STARlight/run_HepMCToAOD.sh | 2 +-
 run/SimExamples/McTracksToAOD/run_O2Kine.sh       | 5 +++--
 run/SimExamples/McTracksToAOD/run_Pythia8.sh      | 2 +-
 run/SimExamples/McTracksToAOD/run_trigger.sh      | 6 +++---
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/run/SimExamples/HepMC_STARlight/run_HepMCToAOD.sh b/run/SimExamples/HepMC_STARlight/run_HepMCToAOD.sh
index f08de81b92d8c..7671d03b97b8f 100755
--- a/run/SimExamples/HepMC_STARlight/run_HepMCToAOD.sh
+++ b/run/SimExamples/HepMC_STARlight/run_HepMCToAOD.sh
@@ -18,7 +18,7 @@ set -x
 # PART b) ... apply vertex smearing on top of HepMC events and perform simple analysis
 NEV=$(grep EVENT slight.out | wc -l)
 
-o2-sim-dpl-eventgen -b --nevents ${NEV} --generator hepmc --confKeyValues \
+o2-sim-dpl-eventgen -b --nEvents ${NEV} --generator hepmc --configKeyValues \
                     "GeneratorFileOrCmd.fileNames=starlight.hepmc;Diamond.position[2]=0.1;Diamond.width[2]=0.05" |\
                     o2-sim-mctracks-to-aod -b | o2-analysis-mctracks-to-aod-simple-task -b
 
diff --git a/run/SimExamples/McTracksToAOD/run_O2Kine.sh b/run/SimExamples/McTracksToAOD/run_O2Kine.sh
index 7506f00834fcf..9afac20cd1a0b 100755
--- a/run/SimExamples/McTracksToAOD/run_O2Kine.sh
+++ b/run/SimExamples/McTracksToAOD/run_O2Kine.sh
@@ -10,6 +10,7 @@ NEVENTS=1000
 # launch generator process (for 10000 min bias Pythia8 events; no Geant; no geometry)
 # o2-sim -j 1 -g pythia8pp -n ${NEVENTS} --noGeant --vertexMode kNoVertex &> sim.log
 
+## Add --aod-writer-keep dangling to o2-sim-mctracks-to-aod to write the AO2D file to disc (as AnalysisResults_trees.root)
 # Option 1) -- use o2-mckine-publisher
 [ -f AnalysisResults.root ] && rm AnalysisResults.root
 o2-sim-kine-publisher -b --kineFileName o2sim --aggregate-timeframe 10 |\
@@ -19,8 +20,8 @@ mv AnalysisResults.root AnalysisResult_1.root
 
 # Option 2) -- use o2-sim-dpl-eventgen + extkinO2 generator (this should be equivalent to Option 1)
 [ -f AnalysisResults.root ] && rm AnalysisResults.root
-o2-sim-dpl-eventgen -b --nevents ${NEVENTS} --aggregate-timeframe 10 --generator extkinO2 \
-                    --confKeyValues "GeneratorFromO2Kine.fileName=o2sim_Kine.root" --vertexMode kNoVertex |\
+o2-sim-dpl-eventgen -b --nEvents ${NEVENTS} --aggregate-timeframe 10 --generator extkinO2 \
+                    --configKeyValues "GeneratorFromO2Kine.fileName=o2sim_Kine.root" --vertexMode kNoVertex |\
 o2-sim-mctracks-to-aod -b |\
 o2-analysis-mctracks-to-aod-simple-task -b &> log2
 mv AnalysisResults.root AnalysisResult_2.root
diff --git a/run/SimExamples/McTracksToAOD/run_Pythia8.sh b/run/SimExamples/McTracksToAOD/run_Pythia8.sh
index 8bac774c5892b..93d2024b05d37 100755
--- a/run/SimExamples/McTracksToAOD/run_Pythia8.sh
+++ b/run/SimExamples/McTracksToAOD/run_Pythia8.sh
@@ -8,7 +8,7 @@ NEVENTS=1000
 
 # --aggregate-timeframe 10 is used to combine 10 generated events into a timeframe that is then converted to AOD tables
 # note that if you need special configuration for the analysis tasks, it needs to be passed to proxy and converter as well
-
+## Add --aod-writer-keep dangling to o2-sim-mctracks-to-aod to write the AO2D file to disc (as AnalysisResults_trees.root)
 o2-sim-dpl-eventgen -b --nEvents ${NEVENTS} --aggregate-timeframe 10 --generator pythia8pp --vertexMode kNoVertex |\
 o2-sim-mctracks-to-aod -b | o2-analysis-mctracks-to-aod-simple-task -b &> pythia8.log
 
diff --git a/run/SimExamples/McTracksToAOD/run_trigger.sh b/run/SimExamples/McTracksToAOD/run_trigger.sh
index ca720191cbad2..5b278c0b666e5 100755
--- a/run/SimExamples/McTracksToAOD/run_trigger.sh
+++ b/run/SimExamples/McTracksToAOD/run_trigger.sh
@@ -5,9 +5,9 @@
 
 set -x
 NEVENTS=1000
-
+## Add --aod-writer-keep dangling to o2-sim-mctracks-to-aod to write the AO2D file to disc (as AnalysisResults_trees.root)
 CONFKEY="TriggerExternal.fileName=trigger.macro;TriggerExternal.funcName=trigger()"
-o2-sim-dpl-eventgen -b --nevents ${NEVENTS} --aggregate-timeframe 10 --generator pythia8pp --trigger external \
-                    --vertexMode kDiamondParam --confKeyValues "${CONFKEY}" |\
+o2-sim-dpl-eventgen -b --nEvents ${NEVENTS} --aggregate-timeframe 10 --generator pythia8pp --trigger external \
+                    --vertexMode kDiamondParam --configKeyValues "${CONFKEY}" |\
 o2-sim-mctracks-to-aod -b | o2-analysis-mctracks-to-aod-simple-task -b
 

From 7c503090305ab42c607db29f49917e32dfd28023 Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Fri, 13 Feb 2026 17:44:23 +0100
Subject: [PATCH 1321/1764] [A3 TRK] Fix kCylinder option + services crossing
 (#15067)

* Fix for kCylinder

* Fix services crossing
---
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx    | 32 +++++++++----------
 .../ALICE3/TRK/simulation/src/TRKServices.cxx |  4 +--
 2 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index 8d30cf9759e40..82b6fbd40af59 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -122,17 +122,12 @@ TGeoVolume* TRKLayer::createChip(std::string type)
     chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
 
     sensVol = createSensor("cylinder");
-    metalVol = createMetalStack("cylinder");
-
-    TGeoCombiTrans* transSens = new TGeoCombiTrans();
-    transSens->SetTranslation(0, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
     LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-    chipVol->AddNode(sensVol, 1, transSens);
+    chipVol->AddNode(sensVol, 1, nullptr);
 
-    TGeoCombiTrans* transMetal = new TGeoCombiTrans();
-    transMetal->SetTranslation(0, mSensorThickness / 2, 0); // TO BE CHECKED !!!
+    metalVol = createMetalStack("cylinder");
     LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
-    chipVol->AddNode(metalVol, 1, transMetal);
+    chipVol->AddNode(metalVol, 1, nullptr);
 
     // deadVol = createDeadzone("cylinder");
   } else if (type == "flat") {
@@ -175,7 +170,9 @@ TGeoVolume* TRKLayer::createModule(std::string type)
   TGeoVolume* moduleVol;
 
   if (type == "cylinder") {
-    module = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
+    double moduleLength = constants::moduleMLOT::length * mNumberOfModules;
+
+    module = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, moduleLength / 2);
     moduleVol = new TGeoVolume(moduleName.c_str(), module, medSi);
 
     TGeoVolume* chipVol = createChip("cylinder");
@@ -229,8 +226,10 @@ TGeoVolume* TRKLayer::createHalfStave(std::string type)
   TGeoShape* halfStave;
   TGeoVolume* halfStaveVol;
 
+  double halfStaveLength = constants::moduleMLOT::length * mNumberOfModules;
+
   if (type == "cylinder") {
-    halfStave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mChipLength / 2);
+    halfStave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, halfStaveLength / 2);
     halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medSi);
 
     TGeoVolume* moduleVol = createModule("cylinder");
@@ -239,7 +238,6 @@ TGeoVolume* TRKLayer::createHalfStave(std::string type)
   } else if (type == "flat") {
     double moduleLength = constants::moduleMLOT::length;
     double halfStaveWidth = constants::OT::halfstave::width;
-    double halfStaveLength = constants::moduleMLOT::length * mNumberOfModules;
 
     halfStave = new TGeoBBox(halfStaveWidth / 2, mChipThickness / 2, halfStaveLength / 2);
     halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medSi);
@@ -271,8 +269,10 @@ TGeoVolume* TRKLayer::createStave(std::string type)
   TGeoShape* stave;
   TGeoVolume* staveVol;
 
+  double staveLength = constants::moduleMLOT::length * mNumberOfModules;
+
   if (type == "cylinder") {
-    stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
+    stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, staveLength / 2);
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
 
     TGeoVolume* moduleVol = createModule("cylinder");
@@ -281,7 +281,6 @@ TGeoVolume* TRKLayer::createStave(std::string type)
   } else if (type == "flat") {
     double moduleLength = constants::moduleMLOT::length;
     double staveWidth = constants::ML::width;
-    double staveLength = constants::moduleMLOT::length * mNumberOfModules;
 
     stave = new TGeoBBox(staveWidth / 2, mChipThickness / 2, staveLength / 2);
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
@@ -304,7 +303,6 @@ TGeoVolume* TRKLayer::createStave(std::string type)
 
     double halfstaveWidth = constants::OT::halfstave::width;
     double staveWidth = constants::OT::width - overlap;
-    double staveLength = constants::moduleMLOT::length * mNumberOfModules;
 
     stave = new TGeoBBox(staveWidth / 2, mLogicalVolumeThickness / 2, staveLength / 2);
     staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
@@ -343,15 +341,16 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
   TGeoTube* layer;
   TGeoVolume* layerVol;
 
+  double layerLength = constants::moduleMLOT::length * mNumberOfModules;
+
   if (mLayout == eLayout::kCylinder) {
-    layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
+    layer = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, layerLength / 2);
     layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
 
     TGeoVolume* staveVol = createStave("cylinder");
     LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
     layerVol->AddNode(staveVol, 1, nullptr);
   } else if (mLayout == eLayout::kTurboStaves) {
-    double layerLength = constants::moduleMLOT::length * mNumberOfModules;
     double staveWidth = constants::ML::width; // Each stave has two modules (based on the LOI design)
 
     if (mInnerRadius > 25) {
@@ -390,7 +389,6 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
   } else if (mLayout == kStaggered) {
     double overlapInStave = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true)overlap
 
-    double layerLength = constants::moduleMLOT::length * mNumberOfModules;
     double staveWidth = constants::OT::width - overlapInStave;
 
     layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, layerLength / 2);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 51eea905c436a..cbe00e8fc9e89 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -264,7 +264,7 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
   // Carbon Fiber Cylinder support for the middle tracker
   float rMinMiddleCarbonSupport = 34.8f; // Arbitrary value
   float rMaxMiddleCarbonSupport = 35.f;  // 2 mm of carbon fiber
-  const float zLengthMiddleCarbon = 62.f;
+  const float zLengthMiddleCarbon = 64.2f;
   TGeoTube* middleBarrelCarbonSupport = new TGeoTube("TRK_MID_CARBONSUPPORTsh", rMinMiddleCarbonSupport, rMaxMiddleCarbonSupport, zLengthMiddleCarbon);
   TGeoVolume* middleBarrelCarbonSupportVolume = new TGeoVolume("TRK_MID_CARBONSUPPORT", middleBarrelCarbonSupport, medCFiber);
   middleBarrelCarbonSupportVolume->SetLineColor(kGray);
@@ -318,7 +318,7 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
   // Middle barrel connection disks
   const float rMinMiddleBarrelDisk = 5.68f;
   const float rMaxMiddleBarrelDisk = 35.f;
-  const float zLengthMiddleBarrel = 62.f;
+  const float zLengthMiddleBarrel = 64.2f;
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
     TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube(Form("TRK_MIDBARCONN_DISK_SIO2sh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, siO2FiberThick);
     TGeoTube* middleBarrelConnDiskPE = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, peFiberThick);

From 48c0b5433f9d4f7af17e8ad34ea6e3363fce5963 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Sun, 8 Feb 2026 19:17:34 +0100
Subject: [PATCH 1322/1764] Support to plug-and-play external (CAD) geometry

This commit adds support for

- conversion from CAD geometries (STEP) file to (meshed) TGeo geometry
  via the tool O2_CADtoTGeo.py

- ability to setup and include simulations modules from external geometries
  via the ExternalModule mechanism

- ability to navigate complex TGeoTessellated solids efficiently
  (will stay here until fully integrated in the official ROOT repo)

It includes all the (basic) functionality to pick a detector layout from
a CAD design and actually simulate it with o2-sim.

Instructions are provided in a dedicated documentation markdown.

The commit is related to epic https://its.cern.ch/jira/browse/O2-6616
---
 Detectors/Base/CMakeLists.txt                 |    7 +-
 .../include/DetectorsBase/O2Tessellated.h     |  142 ++
 .../include/DetectorsBase/TGeoGeometryUtils.h |   38 +
 Detectors/Base/src/DetectorsBaseLinkDef.h     |    2 +
 Detectors/Base/src/O2Tessellated.cxx          | 1509 +++++++++++++++++
 Detectors/Base/src/TGeoGeometryUtils.cxx      |  144 ++
 Detectors/Base/src/bvh2_extra_kernels.h       |   79 +
 Detectors/Base/src/bvh2_third_party.h         |   49 +
 Detectors/Passive/CMakeLists.txt              |    2 +
 .../include/DetectorsPassive/ExternalModule.h |   64 +
 Detectors/Passive/src/ExternalModule.cxx      |  175 ++
 Steer/include/Steer/O2MCApplicationBase.h     |    2 +
 Steer/src/O2MCApplication.cxx                 |   60 +
 macro/build_geometry.C                        |   14 +
 scripts/geometry/O2_CADtoTGeo.py              |  602 +++++++
 scripts/geometry/README.md                    |   27 +
 scripts/geometry/simulating_CAD_modules.md    |   72 +
 17 files changed, 2987 insertions(+), 1 deletion(-)
 create mode 100644 Detectors/Base/include/DetectorsBase/O2Tessellated.h
 create mode 100644 Detectors/Base/include/DetectorsBase/TGeoGeometryUtils.h
 create mode 100644 Detectors/Base/src/O2Tessellated.cxx
 create mode 100644 Detectors/Base/src/TGeoGeometryUtils.cxx
 create mode 100644 Detectors/Base/src/bvh2_extra_kernels.h
 create mode 100644 Detectors/Base/src/bvh2_third_party.h
 create mode 100644 Detectors/Passive/include/DetectorsPassive/ExternalModule.h
 create mode 100644 Detectors/Passive/src/ExternalModule.cxx
 create mode 100644 scripts/geometry/O2_CADtoTGeo.py
 create mode 100644 scripts/geometry/README.md
 create mode 100644 scripts/geometry/simulating_CAD_modules.md

diff --git a/Detectors/Base/CMakeLists.txt b/Detectors/Base/CMakeLists.txt
index 30ab4c4fe8a40..83a9193274e4f 100644
--- a/Detectors/Base/CMakeLists.txt
+++ b/Detectors/Base/CMakeLists.txt
@@ -29,6 +29,8 @@ o2_add_library(DetectorsBase
                        src/Stack.cxx
                        src/VMCSeederService.cxx
                        src/GlobalParams.cxx
+                       src/O2Tessellated.cxx
+                       src/TGeoGeometryUtils.cxx
                PUBLIC_LINK_LIBRARIES FairRoot::Base
                                      O2::CommonUtils
                                      O2::DetectorsCommonDataFormats
@@ -46,6 +48,7 @@ o2_add_library(DetectorsBase
                                      O2::GPUDataTypes
                                      MC::VMC
                                      TBB::tbb
+                                     ROOT::Gdml
                              )
 
 o2_target_root_dictionary(DetectorsBase
@@ -62,7 +65,9 @@ o2_target_root_dictionary(DetectorsBase
                                   include/DetectorsBase/Aligner.h
                                   include/DetectorsBase/Stack.h
                                   include/DetectorsBase/SimFieldUtils.h
-                                  include/DetectorsBase/GlobalParams.h)
+                                  include/DetectorsBase/GlobalParams.h
+                                  include/DetectorsBase/O2Tessellated.h
+                                  )
 
 if(BUILD_SIMULATION)
   if (NOT APPLE)
diff --git a/Detectors/Base/include/DetectorsBase/O2Tessellated.h b/Detectors/Base/include/DetectorsBase/O2Tessellated.h
new file mode 100644
index 0000000000000..0a1cee8b3e01f
--- /dev/null
+++ b/Detectors/Base/include/DetectorsBase/O2Tessellated.h
@@ -0,0 +1,142 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_BASE_O2TESSELLATED_
+#define ALICEO2_BASE_O2TESSELLATED_
+
+#include "TGeoShape.h"
+#include "TGeoBBox.h"
+#include "TGeoVector3.h"
+#include "TGeoTypedefs.h"
+#include "TGeoTessellated.h"
+
+namespace o2
+{
+namespace base
+{
+
+class O2Tessellated : public TGeoBBox
+{
+
+ public:
+  using Vertex_t = Tessellated::Vertex_t;
+
+ private:
+  int fNfacets = 0;         // Number of facets
+  int fNvert = 0;           // Number of vertices
+  int fNseg = 0;            // Number of segments
+  bool fDefined = false;    //! Shape fully defined
+  bool fClosedBody = false; // The faces are making a closed body
+
+  // for now separate vectors but might be better to group per face
+  std::vector<Vertex_t> fVertices;       // List of vertices
+  std::vector<TGeoFacet> fFacets;        // List of facets
+  std::vector<Vertex_t> fOutwardNormals; // Vector of outward-facing normals (to be streamed !)
+
+  std::multimap<long, int> fVerticesMap; //! Temporary map used to deduplicate vertices
+  bool fIsClosed = false;                //! to know if shape still needs closure/initialization
+  void* fBVH = nullptr;                  //! BVH acceleration structure for safety and navigation
+
+  O2Tessellated(const O2Tessellated&) = delete;
+  O2Tessellated& operator=(const O2Tessellated&) = delete;
+
+  // bvh helper functions
+  void BuildBVH();
+  void CalculateNormals();
+
+ public:
+  // constructors
+  O2Tessellated() {}
+  O2Tessellated(const char* name, int nfacets = 0);
+  O2Tessellated(const char* name, const std::vector<Vertex_t>& vertices);
+  // from a TGeoTessellated
+  O2Tessellated(TGeoTessellated const&, bool check = false);
+
+  // destructor
+  ~O2Tessellated() override {}
+
+  void ComputeBBox() override;
+  void CloseShape(bool check = true, bool fixFlipped = true, bool verbose = true);
+
+  bool AddFacet(const Vertex_t& pt0, const Vertex_t& pt1, const Vertex_t& pt2);
+  bool AddFacet(const Vertex_t& pt0, const Vertex_t& pt1, const Vertex_t& pt2, const Vertex_t& pt3);
+  bool AddFacet(int i1, int i2, int i3);
+  bool AddFacet(int i1, int i2, int i3, int i4);
+  int AddVertex(const Vertex_t& vert);
+
+  bool FacetCheck(int ifacet) const;
+  Vertex_t FacetComputeNormal(int ifacet, bool& degenerated) const;
+
+  int GetNfacets() const { return fFacets.size(); }
+  int GetNsegments() const { return fNseg; }
+  int GetNvertices() const { return fNvert; }
+  bool IsClosedBody() const { return fClosedBody; }
+  bool IsDefined() const { return fDefined; }
+
+  const TGeoFacet& GetFacet(int i) const { return fFacets[i]; }
+  const Vertex_t& GetVertex(int i) const { return fVertices[i]; }
+
+  int DistancetoPrimitive(int, int) override { return 99999; }
+  const TBuffer3D& GetBuffer3D(int reqSections, Bool_t localFrame) const override;
+  void GetMeshNumbers(int& nvert, int& nsegs, int& npols) const override;
+  int GetNmeshVertices() const override { return fNvert; }
+  void InspectShape() const override {}
+  TBuffer3D* MakeBuffer3D() const override;
+  void Print(Option_t* option = "") const override;
+  void SavePrimitive(std::ostream&, Option_t*) override {}
+  void SetPoints(double* points) const override;
+  void SetPoints(Float_t* points) const override;
+  void SetSegsAndPols(TBuffer3D& buff) const override;
+  void Sizeof3D() const override {}
+
+  /// Resize and center the shape in a box of size maxsize
+  void ResizeCenter(double maxsize);
+
+  /// Flip all facets
+  void FlipFacets()
+  {
+    for (auto facet : fFacets)
+      facet.Flip();
+  }
+
+  bool CheckClosure(bool fixFlipped = true, bool verbose = true);
+
+  /// Reader from .obj format
+  static O2Tessellated* ImportFromObjFormat(const char* objfile, bool check = false, bool verbose = false);
+
+  // navigation functions used by TGeoNavigator (attention: only the iact == 3 cases implemented for now)
+  Double_t DistFromOutside(const Double_t* point, const Double_t* dir, Int_t iact = 1,
+                           Double_t step = TGeoShape::Big(), Double_t* safe = nullptr) const override;
+  Double_t DistFromInside(const Double_t* point, const Double_t* dir, Int_t iact = 1, Double_t step = TGeoShape::Big(),
+                          Double_t* safe = nullptr) const override;
+  bool Contains(const Double_t* point) const override;
+  Double_t Safety(const Double_t* point, Bool_t in = kTRUE) const override;
+  void ComputeNormal(const Double_t* point, const Double_t* dir, Double_t* norm) const override;
+
+  // these are trivial implementations, just for debugging
+  Double_t DistFromInside_Loop(const Double_t* point, const Double_t* dir) const;
+  Double_t DistFromOutside_Loop(const Double_t* point, const Double_t* dir) const;
+  bool Contains_Loop(const Double_t* point) const;
+
+  Double_t Capacity() const override;
+
+ private:
+  // a safety kernel used in multiple implementations
+  template <bool closest_facet = false>
+  Double_t SafetyKernel(const Double_t* point, bool in, int* closest_facet_id = nullptr) const;
+
+  ClassDefOverride(O2Tessellated, 1) // tessellated shape class
+};
+
+} // namespace base
+} // namespace o2
+
+#endif
diff --git a/Detectors/Base/include/DetectorsBase/TGeoGeometryUtils.h b/Detectors/Base/include/DetectorsBase/TGeoGeometryUtils.h
new file mode 100644
index 0000000000000..5ec85f1c14702
--- /dev/null
+++ b/Detectors/Base/include/DetectorsBase/TGeoGeometryUtils.h
@@ -0,0 +1,38 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TGeoGeometryUtils.h
+/// \author Sandro Wenzel (CERN)
+/// \brief Collection of utility functions for TGeo
+
+#ifndef ALICEO2_BASE_TGEOGEOMETRYUTILS_H_
+#define ALICEO2_BASE_TGEOGEOMETRYUTILS_H_
+
+class TGeoShape;
+class TGeoTessellated;
+
+namespace o2
+{
+namespace base
+{
+
+/// A few utility functions to operate on TGeo geometries (transformations, printing, ...)
+class TGeoGeometryUtils
+{
+ public:
+  ///< Transform any (primitive) TGeoShape to a tessellated representation
+  static TGeoTessellated* TGeoShapeToTGeoTessellated(TGeoShape const*);
+};
+
+} // namespace base
+} // namespace o2
+
+#endif
diff --git a/Detectors/Base/src/DetectorsBaseLinkDef.h b/Detectors/Base/src/DetectorsBaseLinkDef.h
index bd76e9bfbe2e4..8255c143ebb4a 100644
--- a/Detectors/Base/src/DetectorsBaseLinkDef.h
+++ b/Detectors/Base/src/DetectorsBaseLinkDef.h
@@ -42,4 +42,6 @@
 
 #pragma link C++ class o2::data::Stack + ;
 
+#pragma link C++ class o2::base::O2Tessellated - ;
+
 #endif
diff --git a/Detectors/Base/src/O2Tessellated.cxx b/Detectors/Base/src/O2Tessellated.cxx
new file mode 100644
index 0000000000000..256a70e5a697a
--- /dev/null
+++ b/Detectors/Base/src/O2Tessellated.cxx
@@ -0,0 +1,1509 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// Sandro Wenzel 2026
+
+// An implementation of TGeoTessellated augmented with efficient navigation functions.
+// Asked for integration into ROOT here https://github.com/root-project/root/pull/21045
+// Will be deleted once we get this from ROOT.
+
+#include <iostream>
+#include <sstream>
+
+#include "TGeoManager.h"
+#include "TGeoMatrix.h"
+#include "TGeoVolume.h"
+#include "TVirtualGeoPainter.h"
+#include "DetectorsBase/O2Tessellated.h"
+#include "TBuffer3D.h"
+#include "TBuffer3DTypes.h"
+#include "TMath.h"
+#include "TBuffer.h"
+
+#include <array>
+#include <vector>
+
+// THIS IS THIRD PARTY CODE (TO BE PUT IN ROOT) WHICH DOES NOT NEED TO ADHERE TO OUR LINTING
+// NOLINTBEGIN
+
+// include the Third-party BVH headers
+#include "bvh2_third_party.h"
+// some kernels on top of BVH
+#include "bvh2_extra_kernels.h"
+
+#include <cmath>
+#include <limits>
+
+using namespace o2::base;
+ClassImp(O2Tessellated);
+
+using Vertex_t = Tessellated::Vertex_t;
+
+////////////////////////////////////////////////////////////////////////////////
+/// Compact consecutive equal vertices
+
+int TGeoFacet::CompactFacet(Vertex_t* vert, int nvertices)
+{
+  // Compact the common vertices and return new facet
+  if (nvertices < 2)
+    return nvertices;
+  int nvert = nvertices;
+  int i = 0;
+  while (i < nvert) {
+    if (vert[(i + 1) % nvert] == vert[i]) {
+      // shift last vertices left by one element
+      for (int j = i + 2; j < nvert; ++j)
+        vert[j - 1] = vert[j];
+      nvert--;
+    }
+    i++;
+  }
+  return nvert;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Check if a connected neighbour facet has compatible normal
+
+bool TGeoFacet::IsNeighbour(const TGeoFacet& other, bool& flip) const
+{
+
+  // Find a connecting segment
+  bool neighbour = false;
+  int line1[2], line2[2];
+  int npoints = 0;
+  for (int i = 0; i < fNvert; ++i) {
+    auto ivert = fIvert[i];
+    // Check if the other facet has the same vertex
+    for (int j = 0; j < other.GetNvert(); ++j) {
+      if (ivert == other[j]) {
+        line1[npoints] = i;
+        line2[npoints] = j;
+        if (++npoints == 2) {
+          neighbour = true;
+          bool order1 = line1[1] == line1[0] + 1;
+          bool order2 = line2[1] == (line2[0] + 1) % other.GetNvert();
+          flip = (order1 == order2);
+          return neighbour;
+        }
+      }
+    }
+  }
+  return neighbour;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Constructor. In case nfacets is zero, it is user's responsibility to
+/// call CloseShape once all faces are defined.
+
+O2Tessellated::O2Tessellated(const char* name, int nfacets) : TGeoBBox(name, 0, 0, 0)
+{
+  fNfacets = nfacets;
+  if (nfacets)
+    fFacets.reserve(nfacets);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Constructor providing directly the array of vertices. Facets have to be added
+/// providing vertex indices rather than coordinates.
+
+O2Tessellated::O2Tessellated(const char* name, const std::vector<Vertex_t>& vertices) : TGeoBBox(name, 0, 0, 0)
+{
+  fVertices = vertices;
+  fNvert = fVertices.size();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Construct from TGeoTessellated
+
+O2Tessellated::O2Tessellated(TGeoTessellated const& tsl, bool check) : TGeoBBox(tsl.GetName(), 0, 0, 0)
+{
+  fNfacets = tsl.GetNfacets();
+  fNvert = tsl.GetNvertices();
+  fNseg = tsl.GetNsegments();
+
+  // copy facet and vertex done
+  fVertices.reserve(fNvert);
+  fFacets.reserve(fNfacets);
+  for (int i = 0; i < fNfacets; ++i) {
+    fFacets.push_back(tsl.GetFacet(i));
+  }
+  for (int i = 0; i < fNvert; ++i) {
+    fVertices.push_back(tsl.GetVertex(i));
+  }
+  // finish remaining structures
+  CloseShape(check);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Add a vertex checking for duplicates, returning the vertex index
+
+int O2Tessellated::AddVertex(Vertex_t const& vert)
+{
+  constexpr double tolerance = 1.e-10;
+  auto vertexHash = [&](Vertex_t const& vertex) {
+    // Compute hash for the vertex
+    long hash = 0;
+    // helper function to generate hash from integer numbers
+    auto hash_combine = [](long seed, const long value) {
+      return seed ^ (std::hash<long>{}(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2));
+    };
+    for (int i = 0; i < 3; i++) {
+      // use tolerance to generate int with the desired precision from a real number for hashing
+      hash = hash_combine(hash, std::roundl(vertex[i] / tolerance));
+    }
+    return hash;
+  };
+
+  auto hash = vertexHash(vert);
+  bool isAdded = false;
+  int ivert = -1;
+  // Get the compatible vertices
+  auto range = fVerticesMap.equal_range(hash);
+  for (auto it = range.first; it != range.second; ++it) {
+    ivert = it->second;
+    if (fVertices[ivert] == vert) {
+      isAdded = true;
+      break;
+    }
+  }
+  if (!isAdded) {
+    ivert = fVertices.size();
+    fVertices.push_back(vert);
+    fVerticesMap.insert(std::make_pair(hash, ivert));
+  }
+  return ivert;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Adding a triangular facet from vertex positions in absolute coordinates
+
+bool O2Tessellated::AddFacet(const Vertex_t& pt0, const Vertex_t& pt1, const Vertex_t& pt2)
+{
+  if (fDefined) {
+    Error("AddFacet", "Shape %s already fully defined. Not adding", GetName());
+    return false;
+  }
+
+  Vertex_t vert[3];
+  vert[0] = pt0;
+  vert[1] = pt1;
+  vert[2] = pt2;
+  int nvert = TGeoFacet::CompactFacet(vert, 3);
+  if (nvert < 3) {
+    Error("AddFacet", "Triangular facet at index %d degenerated. Not adding.", GetNfacets());
+    return false;
+  }
+  int ind[3];
+  for (auto i = 0; i < 3; ++i)
+    ind[i] = AddVertex(vert[i]);
+  fNseg += 3;
+  fFacets.emplace_back(ind[0], ind[1], ind[2]);
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Adding a triangular facet from indices of vertices
+
+bool O2Tessellated::AddFacet(int i0, int i1, int i2)
+{
+  if (fDefined) {
+    Error("AddFacet", "Shape %s already fully defined. Not adding", GetName());
+    return false;
+  }
+  if (fVertices.empty()) {
+    Error("AddFacet", "Shape %s Cannot add facets by indices without vertices. Not adding", GetName());
+    return false;
+  }
+
+  fNseg += 3;
+  fFacets.emplace_back(i0, i1, i2);
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Adding a quadrilateral facet from vertex positions in absolute coordinates
+
+bool O2Tessellated::AddFacet(const Vertex_t& pt0, const Vertex_t& pt1, const Vertex_t& pt2, const Vertex_t& pt3)
+{
+  if (fDefined) {
+    Error("AddFacet", "Shape %s already fully defined. Not adding", GetName());
+    return false;
+  }
+  Vertex_t vert[4];
+  vert[0] = pt0;
+  vert[1] = pt1;
+  vert[2] = pt2;
+  vert[3] = pt3;
+  int nvert = TGeoFacet::CompactFacet(vert, 4);
+  if (nvert < 3) {
+    Error("AddFacet", "Quadrilateral facet at index %d degenerated. Not adding.", GetNfacets());
+    return false;
+  }
+
+  int ind[4];
+  for (auto i = 0; i < nvert; ++i)
+    ind[i] = AddVertex(vert[i]);
+  fNseg += nvert;
+  if (nvert == 3)
+    fFacets.emplace_back(ind[0], ind[1], ind[2]);
+  else
+    fFacets.emplace_back(ind[0], ind[1], ind[2], ind[3]);
+
+  if (fNfacets > 0 && GetNfacets() == fNfacets)
+    CloseShape(false);
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Adding a quadrilateral facet from indices of vertices
+
+bool O2Tessellated::AddFacet(int i0, int i1, int i2, int i3)
+{
+  if (fDefined) {
+    Error("AddFacet", "Shape %s already fully defined. Not adding", GetName());
+    return false;
+  }
+  if (fVertices.empty()) {
+    Error("AddFacet", "Shape %s Cannot add facets by indices without vertices. Not adding", GetName());
+    return false;
+  }
+
+  fNseg += 4;
+  fFacets.emplace_back(i0, i1, i2, i3);
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Compute normal for a given facet
+
+Vertex_t O2Tessellated::FacetComputeNormal(int ifacet, bool& degenerated) const
+{
+  // Compute normal using non-zero segments
+  constexpr double kTolerance = 1.e-20;
+  auto const& facet = fFacets[ifacet];
+  int nvert = facet.GetNvert();
+  degenerated = true;
+  Vertex_t normal;
+  for (int i = 0; i < nvert - 1; ++i) {
+    Vertex_t e1 = fVertices[facet[i + 1]] - fVertices[facet[i]];
+    if (e1.Mag2() < kTolerance)
+      continue;
+    for (int j = i + 1; j < nvert; ++j) {
+      Vertex_t e2 = fVertices[facet[(j + 1) % nvert]] - fVertices[facet[j]];
+      if (e2.Mag2() < kTolerance)
+        continue;
+      normal = Vertex_t::Cross(e1, e2);
+      // e1 and e2 may be colinear
+      if (normal.Mag2() < kTolerance)
+        continue;
+      normal.Normalize();
+      degenerated = false;
+      break;
+    }
+    if (!degenerated)
+      break;
+  }
+  return normal;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Check validity of facet
+
+bool O2Tessellated::FacetCheck(int ifacet) const
+{
+  constexpr double kTolerance = 1.e-10;
+  auto const& facet = fFacets[ifacet];
+  int nvert = facet.GetNvert();
+  bool degenerated = true;
+  FacetComputeNormal(ifacet, degenerated);
+  if (degenerated) {
+    std::cout << "Facet: " << ifacet << " is degenerated\n";
+    return false;
+  }
+
+  // Compute surface area
+  double surfaceArea = 0.;
+  for (int i = 1; i < nvert - 1; ++i) {
+    Vertex_t e1 = fVertices[facet[i]] - fVertices[facet[0]];
+    Vertex_t e2 = fVertices[facet[i + 1]] - fVertices[facet[0]];
+    surfaceArea += 0.5 * Vertex_t::Cross(e1, e2).Mag();
+  }
+  if (surfaceArea < kTolerance) {
+    std::cout << "Facet: " << ifacet << " has zero surface area\n";
+    return false;
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Close the shape: calculate bounding box and compact vertices
+
+void O2Tessellated::CloseShape(bool check, bool fixFlipped, bool verbose)
+{
+  if (fIsClosed && fBVH) {
+    return;
+  }
+  // Compute bounding box
+  fDefined = true;
+  fNvert = fVertices.size();
+  fNfacets = fFacets.size();
+  ComputeBBox();
+
+  BuildBVH();
+  if (fOutwardNormals.size() == 0) {
+    CalculateNormals();
+  } else {
+    // short check if the normal container is of correct size
+    if (fOutwardNormals.size() != fFacets.size()) {
+      std::cerr << "Inconsistency in normal container";
+    }
+  }
+  fIsClosed = true;
+
+  // Cleanup the vertex map
+  std::multimap<long, int>().swap(fVerticesMap);
+
+  if (fVertices.size() > 0) {
+    if (!check)
+      return;
+
+    // Check facets
+    for (auto i = 0; i < fNfacets; ++i)
+      FacetCheck(i);
+
+    fClosedBody = CheckClosure(fixFlipped, verbose);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Check closure of the solid and check/fix flipped normals
+
+bool O2Tessellated::CheckClosure(bool fixFlipped, bool verbose)
+{
+  int* nn = new int[fNfacets];
+  bool* flipped = new bool[fNfacets];
+  bool hasorphans = false;
+  bool hasflipped = false;
+  for (int i = 0; i < fNfacets; ++i) {
+    nn[i] = 0;
+    flipped[i] = false;
+  }
+
+  for (int icrt = 0; icrt < fNfacets; ++icrt) {
+    // all neighbours checked?
+    if (nn[icrt] >= fFacets[icrt].GetNvert())
+      continue;
+    for (int i = icrt + 1; i < fNfacets; ++i) {
+      bool isneighbour = fFacets[icrt].IsNeighbour(fFacets[i], flipped[i]);
+      if (isneighbour) {
+        if (flipped[icrt])
+          flipped[i] = !flipped[i];
+        if (flipped[i])
+          hasflipped = true;
+        nn[icrt]++;
+        nn[i]++;
+        if (nn[icrt] == fFacets[icrt].GetNvert())
+          break;
+      }
+    }
+    if (nn[icrt] < fFacets[icrt].GetNvert())
+      hasorphans = true;
+  }
+
+  if (hasorphans && verbose) {
+    Error("Check", "Tessellated solid %s has following not fully connected facets:", GetName());
+    for (int icrt = 0; icrt < fNfacets; ++icrt) {
+      if (nn[icrt] < fFacets[icrt].GetNvert())
+        std::cout << icrt << " (" << fFacets[icrt].GetNvert() << " edges, " << nn[icrt] << " neighbours)\n";
+    }
+  }
+  fClosedBody = !hasorphans;
+  int nfixed = 0;
+  if (hasflipped) {
+    if (verbose)
+      Warning("Check", "Tessellated solid %s has following facets with flipped normals:", GetName());
+    for (int icrt = 0; icrt < fNfacets; ++icrt) {
+      if (flipped[icrt]) {
+        if (verbose)
+          std::cout << icrt << "\n";
+        if (fixFlipped) {
+          fFacets[icrt].Flip();
+          nfixed++;
+        }
+      }
+    }
+    if (nfixed && verbose)
+      Info("Check", "Automatically flipped %d facets to match first defined facet", nfixed);
+  }
+  delete[] nn;
+  delete[] flipped;
+
+  return !hasorphans;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Compute bounding box
+
+void O2Tessellated::ComputeBBox()
+{
+  const double kBig = TGeoShape::Big();
+  double vmin[3] = {kBig, kBig, kBig};
+  double vmax[3] = {-kBig, -kBig, -kBig};
+  for (const auto& facet : fFacets) {
+    for (int i = 0; i < facet.GetNvert(); ++i) {
+      for (int j = 0; j < 3; ++j) {
+        vmin[j] = TMath::Min(vmin[j], fVertices[facet[i]].operator[](j));
+        vmax[j] = TMath::Max(vmax[j], fVertices[facet[i]].operator[](j));
+      }
+    }
+  }
+  fDX = 0.5 * (vmax[0] - vmin[0]);
+  fDY = 0.5 * (vmax[1] - vmin[1]);
+  fDZ = 0.5 * (vmax[2] - vmin[2]);
+  for (int i = 0; i < 3; ++i)
+    fOrigin[i] = 0.5 * (vmax[i] + vmin[i]);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Returns numbers of vertices, segments and polygons composing the shape mesh.
+
+void O2Tessellated::GetMeshNumbers(int& nvert, int& nsegs, int& npols) const
+{
+  nvert = fNvert;
+  nsegs = fNseg;
+  npols = GetNfacets();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Creates a TBuffer3D describing *this* shape.
+/// Coordinates are in local reference frame.
+
+TBuffer3D* O2Tessellated::MakeBuffer3D() const
+{
+  const int nvert = fNvert;
+  const int nsegs = fNseg;
+  const int npols = GetNfacets();
+  auto buff = new TBuffer3D(TBuffer3DTypes::kGeneric, nvert, 3 * nvert, nsegs, 3 * nsegs, npols, 6 * npols);
+  if (buff) {
+    SetPoints(buff->fPnts);
+    SetSegsAndPols(*buff);
+  }
+  return buff;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Prints basic info
+
+void O2Tessellated::Print(Option_t*) const
+{
+  std::cout << "=== Tessellated shape " << GetName() << " having " << GetNvertices() << " vertices and "
+            << GetNfacets() << " facets\n";
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Fills TBuffer3D structure for segments and polygons.
+
+void O2Tessellated::SetSegsAndPols(TBuffer3D& buff) const
+{
+  const int c = GetBasicColor();
+  int* segs = buff.fSegs;
+  int* pols = buff.fPols;
+
+  int indseg = 0; // segment internal data index
+  int indpol = 0; // polygon internal data index
+  int sind = 0;   // segment index
+  for (const auto& facet : fFacets) {
+    auto nvert = facet.GetNvert();
+    pols[indpol++] = c;
+    pols[indpol++] = nvert;
+    for (auto j = 0; j < nvert; ++j) {
+      int k = (j + 1) % nvert;
+      // segment made by next consecutive points
+      segs[indseg++] = c;
+      segs[indseg++] = facet[j];
+      segs[indseg++] = facet[k];
+      // add segment to current polygon and increment segment index
+      pols[indpol + nvert - j - 1] = sind++;
+    }
+    indpol += nvert;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Fill tessellated points to an array.
+
+void O2Tessellated::SetPoints(double* points) const
+{
+  int ind = 0;
+  for (const auto& vertex : fVertices) {
+    vertex.CopyTo(&points[ind]);
+    ind += 3;
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Fill tessellated points in float.
+
+void O2Tessellated::SetPoints(Float_t* points) const
+{
+  int ind = 0;
+  for (const auto& vertex : fVertices) {
+    points[ind++] = vertex.x();
+    points[ind++] = vertex.y();
+    points[ind++] = vertex.z();
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Resize the shape by scaling vertices within maxsize and center to origin
+
+void O2Tessellated::ResizeCenter(double maxsize)
+{
+  using Vector3_t = Vertex_t;
+
+  if (!fDefined) {
+    Error("ResizeCenter", "Not all faces are defined");
+    return;
+  }
+  Vector3_t origin(fOrigin[0], fOrigin[1], fOrigin[2]);
+  double maxedge = TMath::Max(TMath::Max(fDX, fDY), fDZ);
+  double scale = maxsize / maxedge;
+  for (size_t i = 0; i < fVertices.size(); ++i) {
+    fVertices[i] = scale * (fVertices[i] - origin);
+  }
+  fOrigin[0] = fOrigin[1] = fOrigin[2] = 0;
+  fDX *= scale;
+  fDY *= scale;
+  fDZ *= scale;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Fills a static 3D buffer and returns a reference.
+
+const TBuffer3D& O2Tessellated::GetBuffer3D(int reqSections, Bool_t localFrame) const
+{
+  static TBuffer3D buffer(TBuffer3DTypes::kGeneric);
+
+  FillBuffer3D(buffer, reqSections, localFrame);
+
+  const int nvert = fNvert;
+  const int nsegs = fNseg;
+  const int npols = GetNfacets();
+
+  if (reqSections & TBuffer3D::kRawSizes) {
+    if (buffer.SetRawSizes(nvert, 3 * nvert, nsegs, 3 * nsegs, npols, 6 * npols)) {
+      buffer.SetSectionsValid(TBuffer3D::kRawSizes);
+    }
+  }
+  if ((reqSections & TBuffer3D::kRaw) && buffer.SectionsValid(TBuffer3D::kRawSizes)) {
+    SetPoints(buffer.fPnts);
+    if (!buffer.fLocalFrame) {
+      TransformPoints(buffer.fPnts, buffer.NbPnts());
+    }
+
+    SetSegsAndPols(buffer);
+    buffer.SetSectionsValid(TBuffer3D::kRaw);
+  }
+
+  return buffer;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Reads a single tessellated solid from an .obj file.
+
+O2Tessellated* O2Tessellated::ImportFromObjFormat(const char* objfile, bool check, bool verbose)
+{
+  using std::vector, std::string, std::ifstream, std::stringstream, std::endl;
+
+  vector<Vertex_t> vertices;
+  vector<string> sfacets;
+
+  struct FacetInd_t {
+    int i0 = -1;
+    int i1 = -1;
+    int i2 = -1;
+    int i3 = -1;
+    int nvert = 0;
+    FacetInd_t(int a, int b, int c)
+    {
+      i0 = a;
+      i1 = b;
+      i2 = c;
+      nvert = 3;
+    };
+    FacetInd_t(int a, int b, int c, int d)
+    {
+      i0 = a;
+      i1 = b;
+      i2 = c;
+      i3 = d;
+      nvert = 4;
+    };
+  };
+
+  vector<FacetInd_t> facets;
+  // List of geometric vertices, with (x, y, z [,w]) coordinates, w is optional and defaults to 1.0.
+  // struct vtx_t { double x = 0; double y = 0; double z = 0; double w = 1; };
+
+  // Texture coordinates in u, [,v ,w]) coordinates, these will vary between 0 and 1. v, w are optional and default to
+  // 0.
+  // struct tex_t { double u; double v; double w; };
+
+  // List of vertex normals in (x,y,z) form; normals might not be unit vectors.
+  // struct vn_t { double x; double y; double z; };
+
+  // Parameter space vertices in ( u [,v] [,w] ) form; free form geometry statement
+  // struct vp_t { double u; double v; double w; };
+
+  // Faces are defined using lists of vertex, texture and normal indices which start at 1.
+  // Polygons such as quadrilaterals can be defined by using more than three vertex/texture/normal indices.
+  //     f v1//vn1 v2//vn2 v3//vn3 ...
+
+  // Records starting with the letter "l" specify the order of the vertices which build a polyline.
+  //     l v1 v2 v3 v4 v5 v6 ...
+
+  string line;
+  int ind[4] = {0};
+  ifstream file(objfile);
+  if (!file.is_open()) {
+    ::Error("O2Tessellated::ImportFromObjFormat", "Unable to open %s", objfile);
+    return nullptr;
+  }
+
+  while (getline(file, line)) {
+    stringstream ss(line);
+    string tag;
+
+    // We ignore everything which is not a vertex or a face
+    if (line.rfind('v', 0) == 0 && line.rfind("vt", 0) != 0 && line.rfind("vn", 0) != 0 && line.rfind("vn", 0) != 0) {
+      // Decode the vertex
+      double pos[4] = {0, 0, 0, 1};
+      ss >> tag >> pos[0] >> pos[1] >> pos[2] >> pos[3];
+      vertices.emplace_back(pos[0] * pos[3], pos[1] * pos[3], pos[2] * pos[3]);
+    }
+
+    else if (line.rfind('f', 0) == 0) {
+      // Decode the face
+      ss >> tag;
+      string word;
+      sfacets.clear();
+      while (ss >> word)
+        sfacets.push_back(word);
+      if (sfacets.size() > 4 || sfacets.size() < 3) {
+        ::Error("O2Tessellated::ImportFromObjFormat", "Detected face having unsupported %zu vertices",
+                sfacets.size());
+        return nullptr;
+      }
+      int nvert = 0;
+      for (auto& sword : sfacets) {
+        stringstream ssword(sword);
+        string token;
+        getline(ssword, token, '/'); // just need the vertex index, which is the first token
+        // Convert string token to integer
+
+        ind[nvert++] = stoi(token) - 1;
+        if (ind[nvert - 1] < 0) {
+          ::Error("O2Tessellated::ImportFromObjFormat", "Unsupported relative vertex index definition in %s",
+                  objfile);
+          return nullptr;
+        }
+      }
+      if (nvert == 3)
+        facets.emplace_back(ind[0], ind[1], ind[2]);
+      else
+        facets.emplace_back(ind[0], ind[1], ind[2], ind[3]);
+    }
+  }
+
+  int nvertices = (int)vertices.size();
+  int nfacets = (int)facets.size();
+  if (nfacets < 3) {
+    ::Error("O2Tessellated::ImportFromObjFormat", "Not enough faces detected in %s", objfile);
+    return nullptr;
+  }
+
+  string sobjfile(objfile);
+  if (verbose)
+    std::cout << "Read " << nvertices << " vertices and " << nfacets << " facets from " << sobjfile << endl;
+
+  auto tsl = new O2Tessellated(sobjfile.erase(sobjfile.find_last_of('.')).c_str(), vertices);
+
+  for (int i = 0; i < nfacets; ++i) {
+    auto facet = facets[i];
+    if (facet.nvert == 3)
+      tsl->AddFacet(facet.i0, facet.i1, facet.i2);
+    else
+      tsl->AddFacet(facet.i0, facet.i1, facet.i2, facet.i3);
+  }
+  tsl->CloseShape(check, true, verbose);
+  tsl->Print();
+  return tsl;
+}
+
+// implementation of some geometry helper functions in anonymous namespace
+namespace
+{
+
+using Vertex_t = Tessellated::Vertex_t;
+// The classic Moeller-Trumbore ray triangle-intersection kernel:
+// - Compute triangle edges e1, e2
+// - Compute determinant det
+// - Reject parallel rays
+// - Compute barycentric coordinates u, v
+// - Compute ray parameter t
+double rayTriangle(const Vertex_t& orig, const Vertex_t& dir, const Vertex_t& v0, const Vertex_t& v1,
+                   const Vertex_t& v2, double rayEPS = 1e-8)
+{
+  constexpr double EPS = 1e-8;
+  const double INF = std::numeric_limits<double>::infinity();
+  Vertex_t e1{v1[0] - v0[0], v1[1] - v0[1], v1[2] - v0[2]};
+  Vertex_t e2{v2[0] - v0[0], v2[1] - v0[1], v2[2] - v0[2]};
+  auto p = Vertex_t::Cross(dir, e2);
+  auto det = e1.Dot(p);
+  if (std::abs(det) <= EPS) {
+    return INF;
+  }
+
+  Vertex_t tvec{orig[0] - v0[0], orig[1] - v0[1], orig[2] - v0[2]};
+  auto invDet = 1.0 / det;
+  auto u = tvec.Dot(p) * invDet;
+  if (u < 0.0 || u > 1.0) {
+    return INF;
+  }
+  auto q = Vertex_t::Cross(tvec, e1);
+  auto v = dir.Dot(q) * invDet;
+  if (v < 0.0 || u + v > 1.0) {
+    return INF;
+  }
+  auto t = e2.Dot(q) * invDet;
+  return (t > rayEPS) ? t : INF;
+}
+
+template <typename T = float>
+struct Vec3f {
+  T x, y, z;
+};
+
+template <typename T>
+inline Vec3f<T> operator-(const Vec3f<T>& a, const Vec3f<T>& b)
+{
+  return {a.x - b.x, a.y - b.y, a.z - b.z};
+}
+
+template <typename T>
+inline Vec3f<T> cross(const Vec3f<T>& a, const Vec3f<T>& b)
+{
+  return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
+}
+
+template <typename T>
+inline T dot(const Vec3f<T>& a, const Vec3f<T>& b)
+{
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+
+// Kernel to get closest/shortest distance between a point and a triangl (a,b,c).
+// Performed by default in float since Safety can be approximate.
+// Project point onto triangle plane
+// If projection lies inside → distance to plane
+// Otherwise compute min distance to the three edges
+// Return squared distance
+template <typename T = float>
+T pointTriangleDistSq(const Vec3f<T>& p, const Vec3f<T>& a, const Vec3f<T>& b, const Vec3f<T>& c)
+{
+  // Edges
+  Vec3f<T> ab = b - a;
+  Vec3f<T> ac = c - a;
+  Vec3f<T> ap = p - a;
+
+  auto d1 = dot(ab, ap);
+  auto d2 = dot(ac, ap);
+  if (d1 <= T(0.0) && d2 <= T(0.0)) {
+    return dot(ap, ap); // barycentric (1,0,0)
+  }
+
+  Vec3f<T> bp = p - b;
+  auto d3 = dot(ab, bp);
+  auto d4 = dot(ac, bp);
+  if (d3 >= T(0.0) && d4 <= d3) {
+    return dot(bp, bp); // (0,1,0)
+  }
+
+  T vc = d1 * d4 - d3 * d2;
+  if (vc <= 0.0f && d1 >= 0.0f && d3 <= 0.0f) {
+    T v = d1 / (d1 - d3);
+    Vec3f<T> proj = {a.x + v * ab.x, a.y + v * ab.y, a.z + v * ab.z};
+    Vec3f<T> d = p - proj;
+    return dot(d, d); // edge AB
+  }
+
+  Vec3f<T> cp = p - c;
+  T d5 = dot(ab, cp);
+  T d6 = dot(ac, cp);
+  if (d6 >= T(0.0f) && d5 <= d6) {
+    return dot(cp, cp); // (0,0,1)
+  }
+
+  T vb = d5 * d2 - d1 * d6;
+  if (vb <= 0.0f && d2 >= 0.0f && d6 <= 0.0f) {
+    T w = d2 / (d2 - d6);
+    Vec3f<T> proj = {a.x + w * ac.x, a.y + w * ac.y, a.z + w * ac.z};
+    Vec3f<T> d = p - proj;
+    return dot(d, d); // edge AC
+  }
+
+  T va = d3 * d6 - d5 * d4;
+  if (va <= 0.0f && (d4 - d3) >= 0.0f && (d5 - d6) >= 0.0f) {
+    T w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
+    Vec3f<T> proj = {b.x + w * (c.x - b.x), b.y + w * (c.y - b.y), b.z + w * (c.z - b.z)};
+    Vec3f<T> d = p - proj;
+    return dot(d, d); // edge BC
+  }
+
+  // Inside face region
+  T denom = T(1.0f) / (va + vb + vc);
+  T v = vb * denom;
+  T w = vc * denom;
+
+  Vec3f<T> proj = {a.x + ab.x * v + ac.x * w, a.y + ab.y * v + ac.y * w, a.z + ab.z * v + ac.z * w};
+
+  Vec3f<T> d = p - proj;
+  return dot(d, d);
+}
+
+template <typename T>
+inline Vec3f<T> normalize(const Vec3f<T>& v)
+{
+  T len2 = dot(v, v);
+  if (len2 == T(0.0f)) {
+    std::cerr << "Degnerate triangle. Cannot determine normal";
+    return {0, 0, 0};
+  }
+  T invLen = T(1.0f) / std::sqrt(len2);
+  return {v.x * invLen, v.y * invLen, v.z * invLen};
+}
+
+template <typename T>
+inline Vec3f<T> triangleNormal(const Vec3f<T>& a, const Vec3f<T>& b, const Vec3f<T>& c)
+{
+  const Vec3f<T> e1 = b - a;
+  const Vec3f<T> e2 = c - a;
+  return normalize(cross(e1, e2));
+}
+
+} // end anonymous namespace
+
+////////////////////////////////////////////////////////////////////////////////
+/// DistFromOutside
+
+Double_t O2Tessellated::DistFromOutside(const Double_t* point, const Double_t* dir, Int_t /*iact*/, Double_t stepmax,
+                                        Double_t* /*safe*/) const
+{
+  // use the BVH intersector in combination with leaf ray-triangle testing
+  double local_step = Big(); // we need this otherwise the lambda get's confused
+
+  using Scalar = float;
+  using Vec3 = bvh::v2::Vec<Scalar, 3>;
+  using Node = bvh::v2::Node<Scalar, 3>;
+  using Bvh = bvh::v2::Bvh<Node>;
+  using Ray = bvh::v2::Ray<Scalar, 3>;
+
+  // let's fetch the bvh
+  auto mybvh = (Bvh*)fBVH;
+  if (!mybvh) {
+    assert(false);
+    return -1.;
+  }
+
+  auto truncate_roundup = [](double orig) {
+    float epsilon = std::numeric_limits<float>::epsilon() * std::fabs(orig);
+    // Add the bias to x before assigning it to y
+    return static_cast<float>(orig + epsilon);
+  };
+
+  // let's do very quick checks against the top node
+  const auto topnode_bbox = mybvh->get_root().get_bbox();
+  if ((-point[0] + topnode_bbox.min[0]) > stepmax) {
+    return Big();
+  }
+  if ((-point[1] + topnode_bbox.min[1]) > stepmax) {
+    return Big();
+  }
+  if ((-point[2] + topnode_bbox.min[2]) > stepmax) {
+    return Big();
+  }
+  if ((point[0] - topnode_bbox.max[0]) > stepmax) {
+    return Big();
+  }
+  if ((point[1] - topnode_bbox.max[1]) > stepmax) {
+    return Big();
+  }
+  if ((point[2] - topnode_bbox.max[2]) > stepmax) {
+    return Big();
+  }
+
+  // the ray used for bvh interaction
+  Ray ray(Vec3(point[0], point[1], point[2]), // origin
+          Vec3(dir[0], dir[1], dir[2]),       // direction
+          0.0f,                               // minimum distance (could give stepmax ?)
+          truncate_roundup(local_step));
+
+  static constexpr bool use_robust_traversal = true;
+
+  Vertex_t dir_v{dir[0], dir[1], dir[2]};
+  // Traverse the BVH and apply concrete object intersection in BVH leafs
+  bvh::v2::GrowingStack<Bvh::Index> stack;
+  mybvh->intersect<false, use_robust_traversal>(ray, mybvh->get_root().index, stack, [&](size_t begin, size_t end) {
+    for (size_t prim_id = begin; prim_id < end; ++prim_id) {
+      auto objectid = mybvh->prim_ids[prim_id];
+      const auto& facet = fFacets[objectid];
+      const auto& n = fOutwardNormals[objectid];
+
+      // quick normal test. Coming from outside, the dot product must be negative
+      if (n.Dot(dir_v) > 0.) {
+        continue;
+      }
+
+      auto thisdist = rayTriangle(Vertex_t(point[0], point[1], point[2]), dir_v,
+                                  fVertices[facet[0]], fVertices[facet[1]], fVertices[facet[2]], 0.);
+
+      if (thisdist < local_step) {
+        local_step = thisdist;
+      }
+    }
+    return false; // go on after this
+  });
+
+  return local_step;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// DistFromOutside
+
+Double_t O2Tessellated::DistFromInside(const Double_t* point, const Double_t* dir, Int_t /*iact*/, Double_t /*stepmax*/,
+                                       Double_t* /*safe*/) const
+{
+  // use the BVH intersector in combination with leaf ray-triangle testing
+  double local_step = Big(); // we need this otherwise the lambda get's confused
+
+  using Scalar = float;
+  using Vec3 = bvh::v2::Vec<Scalar, 3>;
+  using Node = bvh::v2::Node<Scalar, 3>;
+  using Bvh = bvh::v2::Bvh<Node>;
+  using Ray = bvh::v2::Ray<Scalar, 3>;
+
+  // let's fetch the bvh
+  auto mybvh = (Bvh*)fBVH;
+  if (!mybvh) {
+    assert(false);
+    return -1.;
+  }
+
+  auto truncate_roundup = [](double orig) {
+    float epsilon = std::numeric_limits<float>::epsilon() * std::fabs(orig);
+    // Add the bias to x before assigning it to y
+    return static_cast<float>(orig + epsilon);
+  };
+
+  // the ray used for bvh interaction
+  Ray ray(Vec3(point[0], point[1], point[2]), // origin
+          Vec3(dir[0], dir[1], dir[2]),       // direction
+          0.,                                 // minimum distance (could give stepmax ?)
+          truncate_roundup(local_step));
+
+  static constexpr bool use_robust_traversal = true;
+
+  Vertex_t dir_v{dir[0], dir[1], dir[2]};
+  // Traverse the BVH and apply concrete object intersection in BVH leafs
+  bvh::v2::GrowingStack<Bvh::Index> stack;
+  mybvh->intersect<false, use_robust_traversal>(ray, mybvh->get_root().index, stack, [&](size_t begin, size_t end) {
+    for (size_t prim_id = begin; prim_id < end; ++prim_id) {
+      auto objectid = mybvh->prim_ids[prim_id];
+      auto facet = fFacets[objectid];
+      const auto& n = fOutwardNormals[objectid];
+
+      // Only exiting surfaces are relevant (from inside--> dot product must be positive)
+      if (n.Dot(dir_v) <= 0.) {
+        continue;
+      }
+
+      const auto& v0 = fVertices[facet[0]];
+      const auto& v1 = fVertices[facet[1]];
+      const auto& v2 = fVertices[facet[2]];
+
+      const double t =
+        rayTriangle(Vertex_t{point[0], point[1], point[2]}, dir_v, v0, v1, v2, 0.);
+      if (t < local_step) {
+        local_step = t;
+      }
+    }
+    return false; // go on after this
+  });
+
+  return local_step;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Capacity
+
+Double_t O2Tessellated::Capacity() const
+{
+  // For explanation of the following algorithm see:
+  // https://en.wikipedia.org/wiki/Polyhedron#Volume
+  // http://wwwf.imperial.ac.uk/~rn/centroid.pdf
+
+  double vol = 0.0;
+  for (size_t i = 0; i < fFacets.size(); ++i) {
+    auto& facet = fFacets[i];
+    auto a = fVertices[facet[0]];
+    auto b = fVertices[facet[1]];
+    auto c = fVertices[facet[2]];
+    vol +=
+      a[0] * (b[1] * c[2] - b[2] * c[1]) + b[0] * (c[1] * a[2] - c[2] * a[1]) + c[0] * (a[1] * b[2] - a[2] * b[1]);
+  }
+  return vol / 6.0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// BuildBVH
+
+void O2Tessellated::BuildBVH()
+{
+  using Scalar = float;
+  using BBox = bvh::v2::BBox<Scalar, 3>;
+  using Vec3 = bvh::v2::Vec<Scalar, 3>;
+  using Node = bvh::v2::Node<Scalar, 3>;
+  using Bvh = bvh::v2::Bvh<Node>;
+
+  // helper determining axis aligned bounding box from a facet;
+  auto GetBoundingBox = [this](TGeoFacet const& facet) {
+#ifndef NDEBUG
+    const auto nvertices = facet.GetNvert();
+    assert(nvertices == 3); // for now only triangles
+#endif
+    const auto& v1 = fVertices[facet[0]];
+    const auto& v2 = fVertices[facet[1]];
+    const auto& v3 = fVertices[facet[2]];
+    BBox bbox;
+    bbox.min[0] = std::min(std::min(v1[0], v2[0]), v3[0]) - 0.001f;
+    bbox.min[1] = std::min(std::min(v1[1], v2[1]), v3[1]) - 0.001f;
+    bbox.min[2] = std::min(std::min(v1[2], v2[2]), v3[2]) - 0.001f;
+    bbox.max[0] = std::max(std::max(v1[0], v2[0]), v3[0]) + 0.001f;
+    bbox.max[1] = std::max(std::max(v1[1], v2[1]), v3[1]) + 0.001f;
+    bbox.max[2] = std::max(std::max(v1[2], v2[2]), v3[2]) + 0.001f;
+    return bbox;
+  };
+
+  // we need bounding boxes enclosing the primitives and centers of primitives
+  // (replaced here by centers of bounding boxes) to build the bvh
+  std::vector<BBox> bboxes;
+  std::vector<Vec3> centers;
+
+  // loop over all the triangles/Facets;
+  int nd = fFacets.size();
+  for (int i = 0; i < nd; ++i) {
+    auto& facet = fFacets[i];
+
+    // fetch the bounding box of this node and add to the vector of bounding boxes
+    (bboxes).push_back(GetBoundingBox(facet));
+    centers.emplace_back((bboxes).back().get_center());
+  }
+
+  // check if some previous object is registered and delete if necessary
+  if (fBVH) {
+    delete (Bvh*)fBVH;
+    fBVH = nullptr;
+  }
+
+  // create the bvh
+  typename bvh::v2::DefaultBuilder<Node>::Config config;
+  config.quality = bvh::v2::DefaultBuilder<Node>::Quality::High;
+  auto bvh = bvh::v2::DefaultBuilder<Node>::build(bboxes, centers, config);
+  auto bvhptr = new Bvh;
+  *bvhptr = std::move(bvh); // copy structure
+  fBVH = (void*)(bvhptr);
+
+  return;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Contains
+
+bool O2Tessellated::Contains(Double_t const* point) const
+{
+  // we do the parity test
+  using Scalar = float;
+  using Vec3 = bvh::v2::Vec<Scalar, 3>;
+  using Node = bvh::v2::Node<Scalar, 3>;
+  using Bvh = bvh::v2::Bvh<Node>;
+  using Ray = bvh::v2::Ray<Scalar, 3>;
+
+  // let's fetch the bvh
+  auto mybvh = (Bvh*)fBVH;
+  if (!mybvh) {
+    assert(false);
+    return false;
+  }
+
+  auto truncate_roundup = [](double orig) {
+    float epsilon = std::numeric_limits<float>::epsilon() * std::fabs(orig);
+    // Add the bias to x before assigning it to y
+    return static_cast<float>(orig + epsilon);
+  };
+
+  // let's do very quick checks against the top node
+  if (!TGeoBBox::Contains(point)) {
+    return false;
+  }
+
+  // An arbitrary test direction.
+  // Doesn't need to be normalized and probes all normals. Also ensuring to be skewed somewhat
+  // without evident symmetries.
+  Vertex_t test_dir{1.0, 1.41421356237, 1.73205080757};
+
+  double local_step = Big();
+  // the ray used for bvh interaction
+  Ray ray(Vec3(point[0], point[1], point[2]),          // origin
+          Vec3(test_dir[0], test_dir[1], test_dir[2]), // direction
+          0.0f,                                        // minimum distance (could give stepmax ?)
+          truncate_roundup(local_step));
+
+  static constexpr bool use_robust_traversal = true;
+
+  // Traverse the BVH and apply concrete object intersection in BVH leafs
+  bvh::v2::GrowingStack<Bvh::Index> stack;
+  size_t crossings = 0;
+  mybvh->intersect<false, use_robust_traversal>(ray, mybvh->get_root().index, stack, [&](size_t begin, size_t end) {
+    for (size_t prim_id = begin; prim_id < end; ++prim_id) {
+      auto objectid = mybvh->prim_ids[prim_id];
+      auto& facet = fFacets[objectid];
+
+      // for the parity test, we probe all crossing surfaces
+      const auto& v0 = fVertices[facet[0]];
+      const auto& v1 = fVertices[facet[1]];
+      const auto& v2 = fVertices[facet[2]];
+
+      const double t = rayTriangle(Vertex_t(point[0], point[1], point[2]),
+                                   test_dir, v0, v1, v2, 0.);
+
+      if (t != std::numeric_limits<double>::infinity()) {
+        ++crossings;
+      }
+    }
+    return false;
+  });
+
+  return crossings & 1;
+}
+
+namespace
+{
+
+// Helper classes/structs used for priority queue - BVH traversal
+// structure keeping cost (value) for a BVH index
+struct BVHPrioElement {
+  size_t bvh_node_id;
+  float value;
+};
+
+// A priority queue for BVHPrioElement with an additional clear method
+// for quick reset. We intentionally derive from std::priority_queue here to expose a
+// clear() convenience method via access to the protected container `c`.
+// This is internal, non-polymorphic code and relies on standard-library
+// implementation details that are stable across supported platforms.
+template <typename Comparator>
+class BVHPrioQueue : public std::priority_queue<BVHPrioElement, std::vector<BVHPrioElement>, Comparator>
+{
+ public:
+  using std::priority_queue<BVHPrioElement, std::vector<BVHPrioElement>,
+                            Comparator>::priority_queue; // constructor inclusion
+
+  // convenience method to quickly clear/reset the queue (instead of having to pop one by one)
+  void clear() { this->c.clear(); }
+};
+
+} // namespace
+
+/// a reusable safety kernel, which optionally returns the closest face
+template <bool returnFace>
+inline Double_t O2Tessellated::SafetyKernel(const Double_t* point, bool in, int* closest_facet_id) const
+{
+  // This is the classic traversal/pruning of a BVH based on priority queue search
+
+  float smallest_safety_sq = TGeoShape::Big();
+
+  using Scalar = float;
+  using Vec3 = bvh::v2::Vec<Scalar, 3>;
+  using Node = bvh::v2::Node<Scalar, 3>;
+  using Bvh = bvh::v2::Bvh<Node>;
+
+  // let's fetch the bvh
+  auto mybvh = (Bvh*)fBVH;
+
+  // testpoint object in float for quick BVH interaction
+  Vec3 testpoint(point[0], point[1], point[2]);
+
+  auto currnode = mybvh->nodes[0]; // we start from the top BVH node
+  // we do a quick check on the top node (in case we are outside shape)
+  bool outside_top = false;
+  if (!in) {
+    outside_top = !bvh::v2::extra::contains(currnode.get_bbox(), testpoint);
+    if (outside_top) {
+      const auto safety_sq_to_top = bvh::v2::extra::SafetySqToNode(currnode.get_bbox(), testpoint);
+      // we simply return safety to the outer bounding box as an estimate
+      return std::sqrt(safety_sq_to_top);
+    }
+  }
+
+  // comparator bringing out "smallest" value on top
+  auto cmp = [](BVHPrioElement a, BVHPrioElement b) { return a.value > b.value; };
+  static thread_local BVHPrioQueue<decltype(cmp)> queue(cmp);
+  queue.clear();
+
+  // algorithm is based on standard iterative tree traversal with priority queues
+  float current_safety_to_node_sq = 0.f;
+
+  if (returnFace) {
+    *closest_facet_id = -1;
+  }
+
+  do {
+    if (currnode.is_leaf()) {
+      // we are in a leaf node and actually talk to a face/triangular primitive
+      const auto begin_prim_id = currnode.index.first_id();
+      const auto end_prim_id = begin_prim_id + currnode.index.prim_count();
+
+      for (auto p_id = begin_prim_id; p_id < end_prim_id; p_id++) {
+        const auto object_id = mybvh->prim_ids[p_id];
+
+        const auto& facet = fFacets[object_id];
+        const auto& v1 = fVertices[facet[0]];
+        const auto& v2 = fVertices[facet[1]];
+        const auto& v3 = fVertices[facet[2]];
+
+        auto thissafetySQ = pointTriangleDistSq(Vec3f{point[0], point[1], point[2]}, Vec3f{v1[0], v1[1], v1[2]},
+                                                Vec3f{v2[0], v2[1], v2[2]}, Vec3f{v3[0], v3[1], v3[2]});
+
+        if (thissafetySQ < smallest_safety_sq) {
+          smallest_safety_sq = thissafetySQ;
+          if (returnFace) {
+            *closest_facet_id = object_id;
+          }
+        }
+      }
+    } else {
+      // not a leave node ... for further traversal,
+      // we inject the children into priority queue based on distance to it's bounding box
+      const auto leftchild_id = currnode.index.first_id();
+      const auto rightchild_id = leftchild_id + 1;
+
+      for (size_t childid : {leftchild_id, rightchild_id}) {
+        if (childid >= mybvh->nodes.size()) {
+          continue;
+        }
+
+        const auto& node = mybvh->nodes[childid];
+        const auto inside = bvh::v2::extra::contains(node.get_bbox(), testpoint);
+
+        if (inside) {
+          // this must be further considered because we are inside the bounding box
+          queue.push(BVHPrioElement{childid, -1.});
+        } else {
+          auto safety_to_node_square = bvh::v2::extra::SafetySqToNode(node.get_bbox(), testpoint);
+          if (safety_to_node_square <= smallest_safety_sq) {
+            // this should be further considered
+            queue.push(BVHPrioElement{childid, safety_to_node_square});
+          }
+        }
+      }
+    }
+
+    if (queue.size() > 0) {
+      auto currElement = queue.top();
+      currnode = mybvh->nodes[currElement.bvh_node_id];
+      current_safety_to_node_sq = currElement.value;
+      queue.pop();
+    } else {
+      break;
+    }
+  } while (current_safety_to_node_sq <= smallest_safety_sq);
+
+  return std::nextafter(std::sqrt(smallest_safety_sq), 0.0f);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Safety
+
+Double_t O2Tessellated::Safety(const Double_t* point, Bool_t in) const
+{
+  // we could use some caching here (in future) since queries to the solid will likely
+  // be made with some locality
+
+  // fall-back to precise safety kernel
+  return SafetyKernel<false>(point, in);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// ComputeNormal interface
+
+void O2Tessellated::ComputeNormal(const Double_t* point, const Double_t* dir, Double_t* norm) const
+{
+  // We take the approach to identify closest facet to the point via safety
+  // and returning the normal from this face.
+
+  // TODO: Before doing that we could check for cached points from other queries
+
+  // use safety kernel
+  int closest_face_id = -1;
+  SafetyKernel<true>(point, true, &closest_face_id);
+
+  if (closest_face_id < 0) {
+    norm[0] = 1.;
+    norm[1] = 0.;
+    norm[2] = 0.;
+    return;
+  }
+
+  const auto& n = fOutwardNormals[closest_face_id];
+  norm[0] = n[0];
+  norm[1] = n[1];
+  norm[2] = n[2];
+
+  // change sign depending on dir
+  if (norm[0] * dir[0] + norm[1] * dir[1] + norm[2] * dir[2] < 0) {
+    norm[0] = -norm[0];
+    norm[1] = -norm[1];
+    norm[2] = -norm[2];
+  }
+  return;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// trivial (non-BVH) DistFromInside function
+
+Double_t O2Tessellated::DistFromInside_Loop(const Double_t* point, const Double_t* dir) const
+{
+  Vertex_t p(point[0], point[1], point[2]);
+  Vertex_t d(dir[0], dir[1], dir[2]);
+
+  double dist = Big();
+  for (size_t i = 0; i < fFacets.size(); ++i) {
+    const auto& facet = fFacets[i];
+    const auto& n = fOutwardNormals[i];
+
+    // Only exiting surfaces are relevant (from inside--> dot product must be positive)
+    if (n.Dot(d) <= 0.0) {
+      continue;
+    }
+
+    const auto& v0 = fVertices[facet[0]];
+    const auto& v1 = fVertices[facet[1]];
+    const auto& v2 = fVertices[facet[2]];
+
+    const double t = rayTriangle(p, d, v0, v1, v2, 0.);
+
+    if (t < dist) {
+      dist = t;
+    }
+  }
+  return dist;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// trivial (non-BVH) DistFromOutside function
+
+Double_t O2Tessellated::DistFromOutside_Loop(const Double_t* point, const Double_t* dir) const
+{
+  Vertex_t p(point[0], point[1], point[2]);
+  Vertex_t d(dir[0], dir[1], dir[2]);
+
+  double dist = Big();
+  for (size_t i = 0; i < fFacets.size(); ++i) {
+    const auto& facet = fFacets[i];
+    const auto& n = fOutwardNormals[i];
+
+    // Only exiting surfaces are relevant (from outside, the dot product must be negative)
+    if (n.Dot(d) > 0.0) {
+      continue;
+    }
+
+    const auto& v0 = fVertices[facet[0]];
+    const auto& v1 = fVertices[facet[1]];
+    const auto& v2 = fVertices[facet[2]];
+
+    const double t = rayTriangle(p, d, v0, v1, v2, 0.);
+
+    if (t < dist) {
+      dist = t;
+    }
+  }
+  return dist;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// trivial (non-BVH) Contains
+
+bool O2Tessellated::Contains_Loop(const Double_t* point) const
+{
+  // Fixed ray direction
+  const Vertex_t test_dir{1.0, 1.41421356237, 1.73205080757};
+
+  Vertex_t p(point[0], point[1], point[2]);
+
+  int crossings = 0;
+  for (size_t i = 0; i < fFacets.size(); ++i) {
+    const auto& facet = fFacets[i];
+
+    const auto& v0 = fVertices[facet[0]];
+    const auto& v1 = fVertices[facet[1]];
+    const auto& v2 = fVertices[facet[2]];
+
+    const double t = rayTriangle(p, test_dir, v0, v1, v2, 0.);
+    if (t != std::numeric_limits<double>::infinity()) {
+      ++crossings;
+    }
+  }
+  return (crossings & 1);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Custom streamer which performs Closing on read.
+/// Recalculation of BVH and normals is fast
+
+void O2Tessellated::Streamer(TBuffer& b)
+{
+  if (b.IsReading()) {
+    b.ReadClassBuffer(O2Tessellated::Class(), this);
+    CloseShape(false); // close shape but do not re-perform checks
+  } else {
+    b.WriteClassBuffer(O2Tessellated::Class(), this);
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Calculate the normals
+
+void O2Tessellated::CalculateNormals()
+{
+  fOutwardNormals.clear();
+  for (auto& facet : fFacets) {
+    auto& v1 = fVertices[facet[0]];
+    auto& v2 = fVertices[facet[1]];
+    auto& v3 = fVertices[facet[2]];
+    using Vec3d = Vec3f<double>;
+    auto norm = triangleNormal(Vec3d{v1[0], v1[1], v1[2]}, Vec3d{v2[0], v2[1], v2[2]}, Vec3d{v3[0], v3[1], v3[2]});
+    fOutwardNormals.emplace_back(Vertex_t{norm.x, norm.y, norm.z});
+  }
+}
+
+// NOLINTEND
\ No newline at end of file
diff --git a/Detectors/Base/src/TGeoGeometryUtils.cxx b/Detectors/Base/src/TGeoGeometryUtils.cxx
new file mode 100644
index 0000000000000..6f06eff17a6d7
--- /dev/null
+++ b/Detectors/Base/src/TGeoGeometryUtils.cxx
@@ -0,0 +1,144 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file TGeoGeometryUtils.cxx
+/// \author Sandro Wenzel (CERN)
+/// \brief Collection of utility functions for TGeo
+
+#include <DetectorsBase/TGeoGeometryUtils.h>
+#include <TGeoShape.h>
+#include <TGeoTessellated.h>
+#include <TBuffer3D.h>
+#include <vector>
+
+namespace o2
+{
+namespace base
+{
+
+namespace
+{
+// some helpers to interpret TGeo TBuffer3D output
+// and convert it to surface triangles (reengineered from TGeo code)
+
+std::vector<int> BuildVertexLoop(const TBuffer3D& buf,
+                                 const std::vector<int>& segs)
+{
+  // adjacency list
+  std::unordered_map<int, std::vector<int>> adj;
+
+  for (int s : segs) {
+    int a = buf.fSegs[3 * s + 1];
+    int b = buf.fSegs[3 * s + 2];
+    adj[a].push_back(b);
+    adj[b].push_back(a);
+  }
+
+  // start from any vertex
+  int start = adj.begin()->first;
+  int prev = -1;
+  int curr = start;
+
+  std::vector<int> loop;
+
+  while (true) {
+    loop.push_back(curr);
+
+    const auto& nbrs = adj[curr];
+    int next = -1;
+
+    for (int n : nbrs) {
+      if (n != prev) {
+        next = n;
+        break;
+      }
+    }
+
+    if (next == -1 || next == start) {
+      break;
+    }
+
+    prev = curr;
+    curr = next;
+  }
+  return loop;
+}
+
+std::vector<std::vector<int>> ExtractPolygons(const TBuffer3D& buf)
+{
+  std::vector<std::vector<int>> polys;
+  Int_t idx = 0;
+
+  for (Int_t ip = 0; ip < buf.NbPols(); ++ip) {
+
+    idx++; // color
+    Int_t nseg = buf.fPols[idx++];
+
+    std::vector<int> segs(nseg);
+    for (Int_t i = 0; i < nseg; ++i) {
+      segs[i] = buf.fPols[idx++];
+    }
+
+    auto verts = BuildVertexLoop(buf, segs);
+    if (verts.size() >= 3) {
+      polys.push_back(std::move(verts));
+    }
+  }
+
+  return polys;
+}
+
+std::vector<std::array<int, 3>>
+  Triangulate(const std::vector<std::vector<int>>& polys)
+{
+  std::vector<std::array<int, 3>> tris;
+  for (const auto& poly : polys) {
+    int nv = poly.size();
+    if (nv < 3) {
+      continue;
+    }
+
+    int v0 = poly[0];
+    for (int i = 1; i < nv - 1; ++i) {
+      tris.push_back({{v0, poly[i], poly[i + 1]}});
+    }
+  }
+  return tris;
+}
+
+TGeoTessellated* MakeTessellated(const TBuffer3D& buf)
+{
+  auto polys = ExtractPolygons(buf);
+  auto tris = Triangulate(polys);
+  int i = 0;
+  auto* tess = new TGeoTessellated("tess");
+  const Double_t* p = buf.fPnts;
+  for (auto& t : tris) {
+    tess->AddFacet(
+      TGeoTessellated::Vertex_t{p[3 * t[0]], p[3 * t[0] + 1], p[3 * t[0] + 2]},
+      TGeoTessellated::Vertex_t{p[3 * t[1]], p[3 * t[1] + 1], p[3 * t[1] + 2]},
+      TGeoTessellated::Vertex_t{p[3 * t[2]], p[3 * t[2] + 1], p[3 * t[2] + 2]});
+  }
+  tess->CloseShape();
+  return tess;
+}
+} // end anonymous namespace
+
+///< Transform any (primitive) TGeoShape to a TGeoTessellated
+TGeoTessellated* TGeoGeometryUtils::TGeoShapeToTGeoTessellated(TGeoShape const* shape)
+{
+  auto& buf = shape->GetBuffer3D(TBuffer3D::kRawSizes | TBuffer3D::kRaw | TBuffer3D::kCore, false);
+  auto tes = MakeTessellated(buf);
+  return tes;
+}
+
+} // namespace base
+} // namespace o2
diff --git a/Detectors/Base/src/bvh2_extra_kernels.h b/Detectors/Base/src/bvh2_extra_kernels.h
new file mode 100644
index 0000000000000..70e43202a53c4
--- /dev/null
+++ b/Detectors/Base/src/bvh2_extra_kernels.h
@@ -0,0 +1,79 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// Sandro Wenzel 2026
+
+#ifndef ROOT_GEOM_BVH2_EXTRA
+
+namespace bvh::v2::extra
+{
+
+// reusable geometry kernels used in multiple places
+// for interaction with BVH2 structures
+
+// determines if a point is inside the bounding box
+template <typename T>
+bool contains(bvh::v2::BBox<T, 3> const& box, bvh::v2::Vec<T, 3> const& p)
+{
+  auto min = box.min;
+  auto max = box.max;
+  return (p[0] >= min[0] && p[0] <= max[0]) && (p[1] >= min[1] && p[1] <= max[1]) &&
+         (p[2] >= min[2] && p[2] <= max[2]);
+}
+
+// determines the largest squared distance of point to any of the bounding box corners
+template <typename T>
+auto RmaxSqToNode(bvh::v2::BBox<T, 3> const& box, bvh::v2::Vec<T, 3> const& p)
+{
+  // construct the 8 corners to get the maximal distance
+  const auto minCorner = box.min;
+  const auto maxCorner = box.max;
+  using Vec3 = bvh::v2::Vec<T, 3>;
+  // these are the corners of the bounding box
+  const std::array<bvh::v2::Vec<T, 3>, 8> corners{
+    Vec3{minCorner[0], minCorner[1], minCorner[2]}, Vec3{minCorner[0], minCorner[1], maxCorner[2]},
+    Vec3{minCorner[0], maxCorner[1], minCorner[2]}, Vec3{minCorner[0], maxCorner[1], maxCorner[2]},
+    Vec3{maxCorner[0], minCorner[1], minCorner[2]}, Vec3{maxCorner[0], minCorner[1], maxCorner[2]},
+    Vec3{maxCorner[0], maxCorner[1], minCorner[2]}, Vec3{maxCorner[0], maxCorner[1], maxCorner[2]}};
+
+  T Rmax_sq{0};
+  for (const auto& corner : corners) {
+    float R_sq = 0.;
+    const auto dx = corner[0] - p[0];
+    R_sq += dx * dx;
+    const auto dy = corner[1] - p[1];
+    R_sq += dy * dy;
+    const auto dz = corner[2] - p[2];
+    R_sq += dz * dz;
+    Rmax_sq = std::max(Rmax_sq, R_sq);
+  }
+  return Rmax_sq;
+};
+
+// determines the minimum squared distance of point to a bounding box ("safey square")
+template <typename T>
+auto SafetySqToNode(bvh::v2::BBox<T, 3> const& box, bvh::v2::Vec<T, 3> const& p)
+{
+  T sqDist{0.0};
+  for (int i = 0; i < 3; i++) {
+    T v = p[i];
+    if (v < box.min[i]) {
+      sqDist += (box.min[i] - v) * (box.min[i] - v);
+    } else if (v > box.max[i]) {
+      sqDist += (v - box.max[i]) * (v - box.max[i]);
+    }
+  }
+  return sqDist;
+};
+
+} // namespace bvh::v2::extra
+
+#endif
\ No newline at end of file
diff --git a/Detectors/Base/src/bvh2_third_party.h b/Detectors/Base/src/bvh2_third_party.h
new file mode 100644
index 0000000000000..5cf7772269642
--- /dev/null
+++ b/Detectors/Base/src/bvh2_third_party.h
@@ -0,0 +1,49 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// Sandro Wenzel 2026
+
+#ifndef ROOT_GEOM_BVH2_THIRD_PARTY
+
+// A single entry header into third-party BVH2 installed in ROOT
+// Good place to manage compiler warnings etc.
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshadow"
+#pragma clang diagnostic ignored "-Wpsabi"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wpsabi"
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wunknown-pragmas"
+#pragma GCC diagnostic ignored "-Wattributes"
+#elif defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 5051)
+#endif
+
+#include <bvh/v2/bvh.h>
+#include <bvh/v2/vec.h>
+#include <bvh/v2/ray.h>
+#include <bvh/v2/node.h>
+#include <bvh/v2/stack.h>
+#include <bvh/v2/default_builder.h>
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
+
+#endif
\ No newline at end of file
diff --git a/Detectors/Passive/CMakeLists.txt b/Detectors/Passive/CMakeLists.txt
index 0976530bc6571..a24954ad10539 100644
--- a/Detectors/Passive/CMakeLists.txt
+++ b/Detectors/Passive/CMakeLists.txt
@@ -23,6 +23,7 @@ o2_add_library(DetectorsPassive
                        src/Hall.cxx
                        src/HallSimParam.cxx
                        src/PassiveBase.cxx
+                       src/ExternalModule.cxx
                PUBLIC_LINK_LIBRARIES O2::Field O2::DetectorsBase O2::SimConfig)
 
 o2_target_root_dictionary(DetectorsPassive
@@ -39,6 +40,7 @@ o2_target_root_dictionary(DetectorsPassive
                                   include/DetectorsPassive/Hall.h
                                   include/DetectorsPassive/HallSimParam.h
                                   include/DetectorsPassive/PassiveBase.h
+                                  include/DetectorsPassive/ExternalModule.h
                           LINKDEF src/PassiveLinkDef.h)
 
 # FIXME: if PutFrameInTop really depends on TRD, then the following can not work
diff --git a/Detectors/Passive/include/DetectorsPassive/ExternalModule.h b/Detectors/Passive/include/DetectorsPassive/ExternalModule.h
new file mode 100644
index 0000000000000..155870ae42a6d
--- /dev/null
+++ b/Detectors/Passive/include/DetectorsPassive/ExternalModule.h
@@ -0,0 +1,64 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_PASSIVE_EXTERNALMODULE_H
+#define ALICEO2_PASSIVE_EXTERNALMODULE_H
+
+#include "DetectorsPassive/PassiveBase.h" // base class of passive modules
+#include "Rtypes.h"                       // for Pipe::Class, ClassDef, Pipe::Streamer
+
+class TGeoVolume;
+class TGeoTransformation;
+
+namespace o2
+{
+namespace passive
+{
+
+// options used to configure a generic plug and play external module
+struct ExternalModuleOptions {
+  std::string root_macro_file;           // the file where to lookup the ROOT geometry building macro
+  std::string top_volume;                // the volume to be added
+  std::string anchor_volume;             // the volume into which the detector will be hooked
+  TGeoMatrix const* placement = nullptr; // how to place the module inside anchor_volume
+};
+
+// a module (passive material) defined externally (ROOT macro / GDML / TGeo geometry)
+class ExternalModule : public PassiveBase
+{
+ public:
+  ExternalModule(const char* name, const char* long_title, ExternalModuleOptions options);
+  ExternalModule() = default; // default constructor
+
+  ~ExternalModule() override = default;
+  void ConstructGeometry() override;
+
+  /// Clone this object (used in MT mode only)
+  FairModule* CloneModule() const override { return nullptr; }
+
+  typedef std::function<TGeoVolume const*()> GeomBuilderFcn; // function hook for external geometry builder
+
+ private:
+  // void createMaterials();
+  ExternalModule(const ExternalModule& orig);
+  ExternalModule& operator=(const ExternalModule&);
+
+  GeomBuilderFcn mGeomHook;
+  ExternalModuleOptions mOptions;
+
+  bool initGeomBuilderHook();       // function to load/JIT Geometry builder hook
+  void remapMedia(TGeoVolume* vol); // performs a remapping of materials/media IDs after registration with VMC
+
+  // ClassDefOverride(ExternalModule, 0);
+};
+} // namespace passive
+} // namespace o2
+#endif
diff --git a/Detectors/Passive/src/ExternalModule.cxx b/Detectors/Passive/src/ExternalModule.cxx
new file mode 100644
index 0000000000000..fc6bd6953b82d
--- /dev/null
+++ b/Detectors/Passive/src/ExternalModule.cxx
@@ -0,0 +1,175 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+// Sandro Wenzel (CERN), 2026
+
+#include <DetectorsPassive/ExternalModule.h>
+#include <CommonUtils/ConfigurationMacroHelper.h>
+#include <filesystem>
+#include <CommonUtils/FileSystemUtils.h>
+#include <TGeoManager.h>
+#include <TGeoVolume.h>
+#include <unordered_map>
+#include <unordered_set>
+#include <TGeoMaterial.h>
+#include <TGeoMedium.h>
+#include <DetectorsBase/MaterialManager.h>
+
+// ClassImp(o2::passive::ExternalModule)
+
+namespace o2::passive
+{
+
+ExternalModule::ExternalModule(const char* name, const char* long_title, ExternalModuleOptions options) : PassiveBase(name, long_title), mOptions(options)
+{
+}
+
+void ExternalModule::remapMedia(TGeoVolume* top_volume)
+{
+  std::unordered_map<TGeoMedium*, TGeoMedium*> medium_ptr_mapping;
+  std::unordered_set<TGeoVolume*> volumes_already_treated;
+  int counter = 1;
+
+  auto modulename = GetName();
+
+  // The transformer function
+  auto transform_media = [&](TGeoVolume* vol_) {
+    if (volumes_already_treated.find(vol_) != volumes_already_treated.end()) {
+      // this volume was already transformed
+      return;
+    }
+    volumes_already_treated.insert(vol_);
+
+    if (dynamic_cast<TGeoVolumeAssembly*>(vol_)) {
+      // do nothing for assemblies (they don't have a medium)
+      return;
+    }
+
+    auto medium = vol_->GetMedium();
+    if (!medium) {
+      return;
+    }
+
+    auto iter = medium_ptr_mapping.find(medium);
+    if (iter != medium_ptr_mapping.end()) {
+      // This medium has already been transformed, so
+      // we just update the volume
+      vol_->SetMedium(iter->second);
+      return;
+    } else {
+      std::cout << "Transforming media with name " << medium->GetName() << " for volume " << vol_->GetName() << "\n";
+
+      // we found a medium, not yet treated
+      auto curr_mat = medium->GetMaterial();
+      auto& matmgr = o2::base::MaterialManager::Instance();
+
+      matmgr.Material(modulename, counter, curr_mat->GetName(), curr_mat->GetA(), curr_mat->GetZ(), curr_mat->GetDensity(), curr_mat->GetRadLen(), curr_mat->GetIntLen());
+      // TGeo medium params are stored in a flat array with the following convention
+      // fParams[0] = isvol;
+      // fParams[1] = ifield;
+      // fParams[2] = fieldm;
+      // fParams[3] = tmaxfd;
+      // fParams[4] = stemax;
+      // fParams[5] = deemax;
+      // fParams[6] = epsil;
+      // fParams[7] = stmin;
+      const auto isvol = medium->GetParam(0);
+      const auto isxfld = medium->GetParam(1);
+      const auto sxmgmx = medium->GetParam(2);
+      const auto tmaxfd = medium->GetParam(3);
+      const auto stemax = medium->GetParam(4);
+      const auto deemax = medium->GetParam(5);
+      const auto epsil = medium->GetParam(6);
+      const auto stmin = medium->GetParam(7);
+
+      matmgr.Medium(modulename, counter, medium->GetName(), counter, isvol, isxfld, sxmgmx, tmaxfd, stemax, deemax, epsil, stmin);
+
+      // there will be new Material and Medium objects; fetch them
+      auto new_med = matmgr.getTGeoMedium(modulename, counter);
+
+      // insert into cache
+      medium_ptr_mapping[medium] = new_med;
+      vol_->SetMedium(new_med);
+      counter++;
+    }
+  }; // end transformer lambda
+
+  // a generic volume walker
+  std::function<void(TGeoVolume*)> visit_volume;
+  visit_volume = [&](TGeoVolume* vol) -> void {
+    if (!vol) {
+      return;
+    }
+
+    // call the transformer
+    transform_media(vol);
+
+    // Recurse into daughters
+    const int nd = vol->GetNdaughters();
+    for (int i = 0; i < nd; ++i) {
+      TGeoNode* node = vol->GetNode(i);
+      if (!node) {
+        continue;
+      }
+      TGeoVolume* child = node->GetVolume();
+      if (!child) {
+        continue;
+      }
+
+      visit_volume(child);
+    }
+  };
+
+  visit_volume(top_volume);
+}
+
+void ExternalModule::ConstructGeometry()
+{
+  // JIT the geom builder hook
+  if (!initGeomBuilderHook()) {
+    LOG(error) << " Could not load geometry builder hook";
+    return;
+  }
+
+  // otherwise execute it and obtain pointer to top most module volume
+  auto module_top = mGeomHook();
+  if (!module_top) {
+    LOG(error) << "No module found\n";
+    return;
+  }
+
+  remapMedia(const_cast<TGeoVolume*>(module_top));
+
+  // place it into the provided anchor volume (needs to exist)
+  auto anchor = gGeoManager->FindVolumeFast(mOptions.anchor_volume.c_str());
+  if (!anchor) {
+    LOG(error) << "Anchor volume " << mOptions.anchor_volume << " not found. Aborting";
+    return;
+  }
+  anchor->AddNode(const_cast<TGeoVolume*>(module_top), 1, const_cast<TGeoMatrix*>(mOptions.placement));
+}
+
+bool ExternalModule::initGeomBuilderHook()
+{
+  if (mOptions.root_macro_file.size() > 0) {
+    LOG(info) << "Initializing the hook for geometry module building";
+    auto expandedHookFileName = o2::utils::expandShellVarsInFileName(mOptions.root_macro_file);
+    if (std::filesystem::exists(expandedHookFileName)) {
+      // if this file exists we will compile the hook on the fly (the last one is an identifier --> maybe make it dependent on this class)
+      mGeomHook = o2::conf::GetFromMacro<GeomBuilderFcn>(mOptions.root_macro_file, "get_builder_hook_unchecked()", "function<TGeoVolume*()>", "o2_passive_extmodule_builder");
+      LOG(info) << "Hook initialized from file " << expandedHookFileName;
+      return true;
+    }
+  }
+  return false;
+}
+
+} // namespace o2::passive
\ No newline at end of file
diff --git a/Steer/include/Steer/O2MCApplicationBase.h b/Steer/include/Steer/O2MCApplicationBase.h
index 36966be9bde62..d61199baba0ae 100644
--- a/Steer/include/Steer/O2MCApplicationBase.h
+++ b/Steer/include/Steer/O2MCApplicationBase.h
@@ -58,6 +58,8 @@ class O2MCApplicationBase : public FairMCApplication
 
   typedef std::function<void(TVirtualMC const*)> TrackRefFcn;
 
+  void fixTGeoRuntimeShapes();
+
  protected:
   o2::conf::SimCutParams const& mCutParams; // reference to parameter system
   unsigned long long mStepCounter{0};
diff --git a/Steer/src/O2MCApplication.cxx b/Steer/src/O2MCApplication.cxx
index 584598d350581..f832ab70ab121 100644
--- a/Steer/src/O2MCApplication.cxx
+++ b/Steer/src/O2MCApplication.cxx
@@ -37,6 +37,11 @@
 #include "SimConfig/GlobalProcessCutSimParam.h"
 #include "DetectorsBase/GeometryManagerParam.h"
 #include <TGeoParallelWorld.h>
+#include <TGeoVolume.h>
+#include <TBuffer3D.h>
+#include <TGeoTessellated.h>
+#include <DetectorsBase/O2Tessellated.h>
+#include <unordered_set>
 
 namespace o2
 {
@@ -209,10 +214,65 @@ bool O2MCApplicationBase::MisalignGeometry()
     gGeoManager->SetUseParallelWorldNav(true);
   }
 
+  // performs possible optimizations (shape replacements on the runtime geometry)
+  fixTGeoRuntimeShapes();
+
   // return original return value of misalignment procedure
   return true;
 }
 
+void O2MCApplicationBase::fixTGeoRuntimeShapes()
+{
+  // Replace TGeo shapes by other ones for performance or other reasons.
+  // Should only affect runtime of simulation.
+
+  // TODO: make this configurable via external JSON rules/macro
+
+  // Also delete original shapes for memory reasons
+
+  // We follow a visitor pattern on a geom hierarchy
+  // for now replace a TGeoTessellate by our own implementation
+  std::unordered_set<TGeoVolume*> volumes_visited;
+  std::unordered_set<TGeoShape*> old_shape_pointers;
+
+  std::function<void(TGeoNode*)> visit;
+  visit = [&](TGeoNode* node) -> void {
+    if (!node) {
+      return;
+    }
+    auto vol = node->GetVolume();
+    if (volumes_visited.find(vol) != volumes_visited.end()) {
+      return;
+    }
+    volumes_visited.insert(vol);
+
+    // transform the shape of this volume
+    auto shape = vol->GetShape();
+    if (shape->IsA() == TGeoTessellated::Class()) {
+      auto tsl = static_cast<TGeoTessellated*>(shape);
+
+      // make a new O2Tessellated until ROOT has proper support for navigation in TGeoTessellated
+      std::cout << "Converting to O2Tessellated for vol " << vol->GetName() << "\n";
+      auto replacement_shape = new o2::base::O2Tessellated(*tsl, false);
+      vol->SetShape(replacement_shape);
+      old_shape_pointers.insert(shape);
+    }
+    // other cases could come here
+
+    for (int i = 0; i < vol->GetNdaughters(); ++i) {
+      auto child_node = vol->GetNode(i);
+      visit(child_node);
+    }
+  };
+
+  visit(gGeoManager->GetTopNode());
+
+  for (auto ptr : old_shape_pointers) {
+    delete ptr;
+    ptr = nullptr;
+  }
+}
+
 void O2MCApplicationBase::finishEventCommon()
 {
   LOG(info) << "This event/chunk did " << mStepCounter << " steps";
diff --git a/macro/build_geometry.C b/macro/build_geometry.C
index 6b13f2eac2766..ccc3b13fe728d 100644
--- a/macro/build_geometry.C
+++ b/macro/build_geometry.C
@@ -63,6 +63,8 @@
 #include <Alice3DetectorsPassive/Magnet.h>
 #endif
 
+#include <DetectorsPassive/ExternalModule.h>
+
 using Return = o2::base::Detector*;
 
 void finalize_geometry(FairRunSim* run);
@@ -182,6 +184,18 @@ void build_geometry(FairRunSim* run = nullptr)
   }
 #endif
 
+  if (isActivated("EXT")) {
+    // EXAMPLE!! how to pick geometry generated from external (CAD) module via `O2_CADtoTGeo.py`
+    o2::passive::ExternalModuleOptions options;
+    options.root_macro_file = "PATH_TO_EXTERNAL_GEOM_MODULE/geom.C";
+    options.anchor_volume = "barrel"; // hook this into barrel
+    auto rot = new TGeoCombiTrans();
+    rot->RotateX(90);
+    rot->SetDy(30); // we need to compensate for a shift of barrel with respect to zero
+    options.placement = rot;
+    run->AddModule(new o2::passive::ExternalModule("FOO", "BAR", options));
+  }
+
   // the absorber
   if (isActivated("ABSO")) {
     // the frame structure to support other detectors
diff --git a/scripts/geometry/O2_CADtoTGeo.py b/scripts/geometry/O2_CADtoTGeo.py
new file mode 100644
index 0000000000000..d564cdc6124a8
--- /dev/null
+++ b/scripts/geometry/O2_CADtoTGeo.py
@@ -0,0 +1,602 @@
+#!/usr/bin/env python3
+"""
+A Python script, doing a deep STEP/XCAF -> ROOT TGeo conversion.
+For now, all CAD solids are simply meshed. The ROOT geometry is build as a C++ ROOT macro
+and facet data is stored in binary form to keep disc space minimal.
+
+Generates (into --output-folder):
+  - geom.C (small ROOT macro)
+  - facets_<VOLNAME>_<LID>.bin for each leaf logical volume (float32 triangles)
+
+Facet file format (little-endian):
+  uint32 nTriangles
+  then nTriangles * 9 * float32:
+    ax ay az bx by bz cx cy cz
+
+VOLNAME is a filename-safe version of the XCAF label name when available (e.g. "nut"),
+and LID is the XCAF label entry (e.g. "0:1:1:7" -> "0_1_1_7") to keep filenames unique.
+
+Naming:
+  - C++ variable names stay based on XCAF label entry (e.g. 0:1:1:7) for uniqueness.
+  - ROOT object names (TGeoVolume / TGeoTessellated / TGeoVolumeAssembly) use the label's
+    human name when available (e.g. "nut", "rod-assembly"), falling back to the entry.
+
+Units:
+  - By default, the script tries to detect the STEP LENGTH unit by scanning the STEP file
+    header/contents (common patterns like .MILLI. / .CENTI. / .METRE. / INCH / FOOT).
+  - You can override with --step-unit {auto,mm,cm,m,in,ft}. TGeo expects cm.
+
+Author:
+  - Sandro Wenzel, CERN (02/2026)
+"""
+
+import warnings
+warnings.filterwarnings("ignore", message=".*all to deprecated function.*", category=DeprecationWarning)
+
+import argparse
+import re
+import struct
+from pathlib import Path as _Path
+
+from OCC.Core.Bnd import Bnd_Box
+from OCC.Core.BRepBndLib import brepbndlib
+from OCC.Core.BRepMesh import BRepMesh_IncrementalMesh
+from OCC.Core.BRep import BRep_Tool
+from OCC.Core.TopLoc import TopLoc_Location
+from OCC.Core.TopAbs import TopAbs_REVERSED
+from OCC.Extend.TopologyUtils import TopologyExplorer
+
+from OCC.Core.STEPCAFControl import STEPCAFControl_Reader
+from OCC.Core.TDocStd import TDocStd_Document
+from OCC.Core.XCAFDoc import XCAFDoc_DocumentTool
+from OCC.Core.IFSelect import IFSelect_RetDone
+
+from OCC.Core.TDF import TDF_Label, TDF_LabelSequence, TDF_Tool
+from OCC.Core.TCollection import TCollection_AsciiString
+from OCC.Core.gp import gp_Trsf
+
+
+# -------------------------------
+# STEP/XCAF loading
+# -------------------------------
+
+def load_step_with_xcaf(path: str):
+    doc = TDocStd_Document("pythonocc-doc")
+    reader = STEPCAFControl_Reader()
+    reader.SetColorMode(True)
+    reader.SetNameMode(True)
+    reader.SetLayerMode(True)
+
+    status = reader.ReadFile(path)
+    if status != IFSelect_RetDone:
+        raise RuntimeError(f"STEP read failed for: {path}")
+
+    reader.Transfer(doc)
+    shape_tool = XCAFDoc_DocumentTool.ShapeTool(doc.Main())
+    return doc, shape_tool
+
+
+def label_id(label: TDF_Label) -> str:
+    s = TCollection_AsciiString()
+    TDF_Tool.Entry(label, s)
+    return s.ToCString()
+
+
+def label_name(label: TDF_Label) -> str:
+    # Uses the XCAF/STEP name when present; can be empty.
+    try:
+        n = label.GetLabelName()
+        if n:
+            return str(n)
+    except Exception:
+        pass
+    return ""
+
+
+# -------------------------------
+# Units
+# -------------------------------
+
+def step_unit_scale_to_cm(step_unit: str) -> float:
+    step_unit = (step_unit or "auto").lower()
+    if step_unit == "mm":
+        return 0.1
+    if step_unit == "cm":
+        return 1.0
+    if step_unit == "m":
+        return 100.0
+    if step_unit == "in":
+        return 2.54
+    if step_unit == "ft":
+        return 30.48
+    raise ValueError(f"Unknown --step-unit {step_unit} (use auto, mm, cm, m, in, ft)")
+
+
+def detect_step_length_unit(step_path: str) -> str:
+    """
+    Heuristic unit detection by scanning STEP file text for common unit tokens.
+    This avoids relying on OCCT APIs that can vary across pythonOCC builds.
+
+    Returns one of: mm, cm, m, in, ft. Defaults to mm if uncertain.
+    """
+    p = _Path(step_path)
+    # STEP can be huge: read only the first few MB; units are near the header.
+    max_bytes = 4 * 1024 * 1024
+    data = p.open("rb").read(max_bytes).decode("latin-1", errors="ignore").upper()
+
+    if ".MILLI." in data:
+        return "mm"
+    if ".CENTI." in data:
+        return "cm"
+    if ".METRE." in data or ".METER." in data:
+        return "m"
+    if "INCH" in data:
+        return "in"
+    if "FOOT" in data or "FEET" in data:
+        return "ft"
+
+    # Conservative default for mechanical CAD STEP is mm
+    return "mm"
+
+
+# -------------------------------
+# Triangulation helpers
+# -------------------------------
+
+def _scale_triangles(triangles, s: float):
+    if s == 1.0:
+        return triangles
+    out = []
+    for (a, b, c) in triangles:
+        out.append((
+            (a[0] * s, a[1] * s, a[2] * s),
+            (b[0] * s, b[1] * s, b[2] * s),
+            (c[0] * s, c[1] * s, c[2] * s),
+        ))
+    return out
+
+
+def triangulate_asbbox(shape, scale_to_cm: float = 1.0):
+    box = Bnd_Box()
+    brepbndlib.Add(shape, box)
+    xmin, ymin, zmin, xmax, ymax, zmax = box.Get()
+
+    p000 = (xmin, ymin, zmin)
+    p001 = (xmin, ymin, zmax)
+    p010 = (xmin, ymax, zmin)
+    p011 = (xmin, ymax, zmax)
+    p100 = (xmax, ymin, zmin)
+    p101 = (xmax, ymin, zmax)
+    p110 = (xmax, ymax, zmin)
+    p111 = (xmax, ymax, zmax)
+
+    triangles = [
+        (p000, p100, p110), (p000, p110, p010),
+        (p001, p111, p101), (p001, p011, p111),
+        (p000, p101, p100), (p000, p001, p101),
+        (p010, p110, p111), (p010, p111, p011),
+        (p000, p010, p011), (p000, p011, p001),
+        (p100, p101, p111), (p100, p111, p110),
+    ]
+    return _scale_triangles(triangles, scale_to_cm)
+
+
+def triangulate_CAD_solid(my_solid, meshparam, scale_to_cm: float = 1.0):
+    lin_defl = float(meshparam.get("lin_defl", 0.1))
+    ang_defl = float(meshparam.get("ang_defl", 0.1))
+
+    parallel = True
+    try:
+        BRepMesh_IncrementalMesh(my_solid, lin_defl, False, ang_defl, bool(parallel))
+    except TypeError:
+        BRepMesh_IncrementalMesh(my_solid, lin_defl, False, ang_defl)
+
+    triangles = []
+    for face in TopologyExplorer(my_solid).faces():
+        loc = TopLoc_Location()
+        triangulation = BRep_Tool.Triangulation(face, loc)
+        if triangulation is None:
+            continue
+
+        trsf = loc.Transformation()
+        reverse = (face.Orientation() == TopAbs_REVERSED)
+
+        for i in range(1, triangulation.NbTriangles() + 1):
+            tri = triangulation.Triangle(i)
+            n1, n2, n3 = tri.Get()
+
+            p1 = triangulation.Node(n1).Transformed(trsf)
+            p2 = triangulation.Node(n2).Transformed(trsf)
+            p3 = triangulation.Node(n3).Transformed(trsf)
+
+            if reverse:
+                p2, p3 = p3, p2
+
+            triangles.append((
+                (p1.X(), p1.Y(), p1.Z()),
+                (p2.X(), p2.Y(), p2.Z()),
+                (p3.X(), p3.Y(), p3.Z()),
+            ))
+
+    return _scale_triangles(triangles, scale_to_cm)
+
+
+# -------------------------------
+# Naming helpers
+# -------------------------------
+
+def sanitize_cpp_name(s: str) -> str:
+    safe = re.sub(r"[^0-9a-zA-Z]", "_", s)
+    if not safe:
+        safe = "x"
+    if not (safe[0].isalpha() or safe[0] == "_"):
+        safe = "_" + safe
+    return safe
+
+
+def sanitize_filename(s: str) -> str:
+    safe = re.sub(r"[^0-9a-zA-Z]", "_", s)
+    return safe or "x"
+
+
+# -------------------------------
+# Binary facet IO
+# -------------------------------
+
+def write_facets_bin(path: _Path, triangles):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "wb") as f:
+        f.write(struct.pack("<I", len(triangles)))
+        for (a, b, c) in triangles:
+            f.write(struct.pack(
+                "<9f",
+                float(a[0]), float(a[1]), float(a[2]),
+                float(b[0]), float(b[1]), float(b[2]),
+                float(c[0]), float(c[1]), float(c[2]),
+            ))
+
+
+# -------------------------------
+# C++ emission helpers
+# -------------------------------
+
+def trsf_to_tgeo(trsf: gp_Trsf, name: str, scale_to_cm: float) -> str:
+    m = trsf.GetRotation().GetMatrix()
+    t = trsf.TranslationPart()
+    return f"""
+  Double_t {name}_m[9] = {{
+    {m.Value(1,1)}, {m.Value(1,2)}, {m.Value(1,3)},
+    {m.Value(2,1)}, {m.Value(2,2)}, {m.Value(2,3)},
+    {m.Value(3,1)}, {m.Value(3,2)}, {m.Value(3,3)}
+  }};
+  TGeoRotation *{name}_rot = new TGeoRotation();
+  {name}_rot->SetMatrix({name}_m);
+  TGeoCombiTrans *{name} = new TGeoCombiTrans({t.X()*scale_to_cm}, {t.Y()*scale_to_cm}, {t.Z()*scale_to_cm}, {name}_rot);
+"""
+
+
+def emit_cpp_prelude() -> str:
+    return """#include <TGeoManager.h>
+#include <TFile.h>
+#include <fstream>
+#include <functional>
+#include <stdexcept>
+#include <string>
+
+static void LoadFacets(const std::string& file, TGeoTessellated* solid, bool check=false)
+{
+  std::ifstream in(file, std::ios::binary);
+  if (!in) throw std::runtime_error("Cannot open facet file: " + file);
+
+  uint32_t nTri = 0;
+  in.read(reinterpret_cast<char*>(&nTri), sizeof(nTri));
+  if (!in) throw std::runtime_error("Bad facet header in: " + file);
+
+  for (uint32_t i=0;i<nTri;i++) {
+    float v[9];
+    in.read(reinterpret_cast<char*>(v), sizeof(v));
+    if (!in) throw std::runtime_error("Unexpected EOF in: " + file);
+
+    solid->AddFacet(TGeoTessellated::Vertex_t(v[0],v[1],v[2]),
+                    TGeoTessellated::Vertex_t(v[3],v[4],v[5]),
+                    TGeoTessellated::Vertex_t(v[6],v[7],v[8]));
+  }
+  solid->CloseShape(check, true);
+}
+"""
+
+
+def emit_materials_cpp() -> str:
+    return """  // Default material/medium (placeholder; can be replaced later)
+  TGeoMaterial *mat_Default = new TGeoMaterial("Default", 0., 0., 0.);
+  TGeoMedium   *med_Default = new TGeoMedium("Default", 1, mat_Default);
+"""
+
+
+def emit_tessellated_cpp(lid: str, vol_display_name: str, facet_abspath: str, ntriangles: int) -> str:
+    safe = sanitize_cpp_name(lid)
+    shape_name = vol_display_name if vol_display_name else lid
+
+    if ntriangles <= 0:
+        out = []
+        out.append(f'  TGeoBBox *solid_{safe} = new TGeoBBox("{shape_name}", 0.001, 0.001, 0.001);')
+        out.append(f'  TGeoVolume *vol_{safe} = new TGeoVolume("{shape_name}", solid_{safe}, med_Default);')
+        return "\n".join(out)
+
+    out = []
+    out.append(f'  TGeoTessellated *solid_{safe} = new TGeoTessellated("{shape_name}", {ntriangles});')
+    out.append(f'  LoadFacets("{facet_abspath}", solid_{safe}, check);')
+    out.append(f'  TGeoVolume *vol_{safe} = new TGeoVolume("{shape_name}", solid_{safe}, med_Default);')
+    return "\n".join(out)
+
+
+def emit_assembly_cpp(lid: str, asm_display_name: str) -> str:
+    safe = sanitize_cpp_name(lid)
+    name = asm_display_name if asm_display_name else lid
+    return f'  TGeoVolumeAssembly *asm_{safe} = new TGeoVolumeAssembly("{name}");'
+
+
+# -------------------------------
+# Definition graph extraction
+# -------------------------------
+
+logical_volumes = {}     # def_lid -> triangles
+def_names = {}           # def_lid -> human display name (may be "")
+assemblies = set()       # def_lid
+placements = []          # (parent_def_lid, child_def_lid, gp_Trsf local)
+top_defs = set()         # top definition lids
+visited_defs = set()     # expanded defs
+
+
+def cpp_var_for_def(lid: str) -> str:
+    safe = sanitize_cpp_name(lid)
+    return f"asm_{safe}" if lid in assemblies else f"vol_{safe}"
+
+
+def expand_definition(def_label: TDF_Label, shape_tool, meshparam=None, scale_to_cm: float = 1.0):
+    def_lid = label_id(def_label)
+    if def_lid in visited_defs:
+        return
+    visited_defs.add(def_lid)
+
+    nm = label_name(def_label)
+    if nm and def_lid not in def_names:
+        def_names[def_lid] = nm
+    elif def_lid not in def_names:
+        def_names[def_lid] = ""
+
+    children = TDF_LabelSequence()
+    shape_tool.GetComponents(def_label, children)
+    has_children = children.Length() > 0
+
+    if has_children or shape_tool.IsAssembly(def_label):
+        assemblies.add(def_lid)
+
+        for i in range(children.Length()):
+            child = children.Value(i + 1)
+            if shape_tool.IsReference(child):
+                referred = TDF_Label()
+                shape_tool.GetReferredShape(child, referred)
+                child_def_lid = label_id(referred)
+
+                loc = shape_tool.GetLocation(child)
+                trsf = loc.Transformation()
+                placements.append((def_lid, child_def_lid, trsf))
+
+                expand_definition(referred, shape_tool, meshparam=meshparam, scale_to_cm=scale_to_cm)
+            else:
+                child_def_lid = label_id(child)
+                placements.append((def_lid, child_def_lid, gp_Trsf()))
+                expand_definition(child, shape_tool, meshparam=meshparam, scale_to_cm=scale_to_cm)
+        return
+
+    if shape_tool.IsSimpleShape(def_label):
+        if def_lid not in logical_volumes:
+            shape = shape_tool.GetShape(def_label)
+            do_meshing = (meshparam is not None) and meshparam.get("do_meshing", None) is True
+            logical_volumes[def_lid] = triangulate_CAD_solid(shape, meshparam=meshparam, scale_to_cm=scale_to_cm) if do_meshing else triangulate_asbbox(shape, scale_to_cm=scale_to_cm)
+        return
+
+    assemblies.add(def_lid)
+
+
+def extract_graph(step_path: str, meshparam=None, scale_to_cm: float = 1.0):
+    global logical_volumes, def_names, assemblies, placements, top_defs, visited_defs
+    logical_volumes = {}
+    def_names = {}
+    assemblies = set()
+    placements = []
+    top_defs = set()
+    visited_defs = set()
+
+    doc, shape_tool = load_step_with_xcaf(step_path)
+
+    roots = TDF_LabelSequence()
+    shape_tool.GetFreeShapes(roots)
+
+    for i in range(roots.Length()):
+        root = roots.Value(i + 1)
+        if shape_tool.IsReference(root):
+            ref = TDF_Label()
+            shape_tool.GetReferredShape(root, ref)
+            top_defs.add(label_id(ref))
+            expand_definition(ref, shape_tool, meshparam=meshparam, scale_to_cm=scale_to_cm)
+        else:
+            top_defs.add(label_id(root))
+            expand_definition(root, shape_tool, meshparam=meshparam, scale_to_cm=scale_to_cm)
+
+    return doc, shape_tool
+
+
+# -------------------------------
+# ROOT macro emission
+# -------------------------------
+
+def emit_placement_cpp(parent_def: str, child_def: str, trsf: gp_Trsf, copy_no: int, scale_to_cm: float) -> str:
+    parent_cpp = cpp_var_for_def(parent_def)
+    child_cpp = cpp_var_for_def(child_def)
+    tr_name = f"tr_{sanitize_cpp_name(parent_def)}_{sanitize_cpp_name(child_def)}_{copy_no}"
+    return trsf_to_tgeo(trsf, tr_name, scale_to_cm) + f"  {parent_cpp}->AddNode({child_cpp}, {copy_no}, {tr_name});\n"
+
+
+def emit_root_macro(step_path: str, out_folder: _Path, meshparam=None, step_unit: str = "auto"):
+    if (step_unit or "auto").lower() == "auto":
+        detected = detect_step_length_unit(step_path)
+        scale_to_cm = step_unit_scale_to_cm(detected)
+        print(f"Detected STEP length unit: {detected} (scale to cm = {scale_to_cm})")
+    else:
+        scale_to_cm = step_unit_scale_to_cm(step_unit)
+        print(f"Using overridden STEP length unit: {step_unit} (scale to cm = {scale_to_cm})")
+
+    extract_graph(step_path, meshparam=meshparam, scale_to_cm=scale_to_cm)
+
+    out_folder = out_folder.expanduser().resolve()
+    out_folder.mkdir(parents=True, exist_ok=True)
+
+    facet_files = {}  # def_lid -> absolute path string
+    for lid, tris in logical_volumes.items():
+        disp = def_names.get(lid, "")
+        volname = sanitize_filename(disp) if disp else "vol"
+        lidname = sanitize_filename(lid)
+        fname = f"facets_{volname}_{lidname}.bin"
+        fpath = (out_folder / fname).resolve()
+        write_facets_bin(fpath, tris)
+        facet_files[lid] = str(fpath).replace("\\", "\\\\")  # C++ string literal safety
+
+    cpp = []
+    cpp.append(emit_cpp_prelude())
+
+    cpp.append("TGeoVolume* build(bool check=true) {")
+    cpp.append('  if (!gGeoManager) { throw std::runtime_error("gGeoManager is null. Call build_and_export() or create a TGeoManager first."); }')
+    cpp.append(emit_materials_cpp())
+
+    for lid in logical_volumes.keys():
+        ntriangles = len(logical_volumes[lid])
+        cpp.append(emit_tessellated_cpp(lid, def_names.get(lid, ""), facet_files[lid], ntriangles))
+
+    for lid in sorted(assemblies):
+        cpp.append(emit_assembly_cpp(lid, def_names.get(lid, "")))
+
+    for idx, (parent, child, trsf) in enumerate(placements, start=1):
+        cpp.append(emit_placement_cpp(parent, child, trsf, idx, scale_to_cm))
+
+    if len(top_defs) == 1:
+        top = next(iter(top_defs))
+        cpp.append(f"  return {cpp_var_for_def(top)};")
+    else:
+        cpp.append('  TGeoVolumeAssembly *asm_WORLD = new TGeoVolumeAssembly("WORLD");')
+        for i, node in enumerate(sorted(top_defs), start=1):
+            cpp.append(f"  asm_WORLD->AddNode({cpp_var_for_def(node)}, {i});")
+        cpp.append("  return asm_WORLD;")
+
+    cpp.append("}")
+
+    # exports a function allowing to export the geometry to TGeo file
+    cpp.append('void build_and_export(const char* out_root = "geom.root", bool check=true) {')
+    cpp.append('  if (!gGeoManager) { new TGeoManager("geom","geom"); }')
+    cpp.append('  TGeoVolume* top = build(check);')
+    cpp.append('  gGeoManager->SetTopVolume(top);')
+    cpp.append('  gGeoManager->CloseGeometry();')
+    cpp.append('  gGeoManager->CheckOverlaps();')
+    cpp.append('  gGeoManager->Export(out_root);')
+    cpp.append('}')
+
+    # exports a function to get get hold of the builder function in ALICE O2
+    cpp.append('std::function<TGeoVolume*()> get_builder_hook_checked() {')
+    cpp.append('  return []() { return build(true); };')
+    cpp.append('}')
+    # exports a function to get get hold of the builder function in ALICE O2
+    cpp.append('std::function<TGeoVolume*()> get_builder_hook_unchecked() {')
+    cpp.append('  return []() { return build(false); };')
+    cpp.append('}')
+
+    return "\n".join(cpp)
+
+
+# -------------------------------
+# Geometry Tree printing (debug)
+# -------------------------------
+
+def label_entry(label):
+    s = TCollection_AsciiString()
+    TDF_Tool.Entry(label, s)
+    return s.ToCString()
+
+
+def traverse_print(label, shape_tool, depth=0):
+    indent = "  " * depth
+    name = label.GetLabelName()
+    entry = label_entry(label)
+    print(f"{indent}- {name}  =>[{entry}]")
+
+    if shape_tool.IsReference(label):
+        ref_label = TDF_Label()
+        shape_tool.GetReferredShape(label, ref_label)
+        traverse_print(ref_label, shape_tool, depth + 1)
+        return
+
+    children = TDF_LabelSequence()
+    shape_tool.GetComponents(label, children)
+    if children.Length() > 0 or shape_tool.IsAssembly(label):
+        for i in range(children.Length()):
+            traverse_print(children.Value(i + 1), shape_tool, depth + 1)
+        return
+
+    if shape_tool.IsSimpleShape(label):
+        shape = shape_tool.GetShape(label)
+        print(f"{indent}  [LogicalShape id={id(shape)}]")
+
+
+def print_geom(step_file):
+    print(f"Printing GEOM hierarchy for {step_file}")
+    doc, shape_tool = load_step_with_xcaf(step_file)
+    roots = TDF_LabelSequence()
+    shape_tool.GetFreeShapes(roots)
+    for i in range(roots.Length()):
+        traverse_print(roots.Value(i + 1), shape_tool)
+
+
+# -------------------------------
+# CLI
+# -------------------------------
+
+def main():
+    ap = argparse.ArgumentParser(description="Convert STEP/XCAF to ROOT TGeo macro, facets in per-volume binary files.")
+    ap.add_argument("step", help="Input STEP file")
+    ap.add_argument("-o", "--out", default="geom.C", help="Output ROOT macro file name (default: geom.C)")
+    ap.add_argument("--output-folder", default="./", help="Output folder for macro + facet files")
+    ap.add_argument("--out-path", default=None, help="(deprecated) Alias for --output-folder")
+    ap.add_argument("--mesh", action="store_true", help="Use full BRepMesh triangulation instead of bounding boxes")
+    ap.add_argument("--print-tree", action="store_true", help="Just prints the geometry tree")
+    ap.add_argument("--mesh-prec", default=0.1, help="meshing precision. lower --> slower")
+    ap.add_argument("--step-unit", default="auto", choices=["auto", "mm", "cm", "m", "in", "ft"], help="STEP length unit override (default: auto-detect)")
+
+    args = ap.parse_args()
+
+    step_path = str(_Path(args.step).expanduser().resolve())
+    if args.print_tree:
+        print_geom(step_path)
+        return
+
+    out_folder = _Path(args.output_folder)
+    if args.out_path is not None:
+        out_folder = _Path(args.out_path)
+
+    meshparam = {"do_meshing": args.mesh, "lin_defl": args.mesh_prec, "ang_defl": args.mesh_prec}
+
+    out_folder = out_folder.expanduser().resolve()
+    out_folder.mkdir(parents=True, exist_ok=True)
+
+    out_macro = (out_folder / _Path(args.out).name).resolve()
+    code = emit_root_macro(step_path, out_folder, meshparam=meshparam, step_unit=args.step_unit)
+    out_macro.write_text(code)
+
+    print(f"Wrote ROOT macro: {out_macro}")
+    print(f"Wrote facet files into: {out_folder}")
+    print("In ROOT you can do:")
+    print(f"  root -l {out_macro}")
+    print('  build_and_export("geom.root");')
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/geometry/README.md b/scripts/geometry/README.md
new file mode 100644
index 0000000000000..4fb2d1ec610d4
--- /dev/null
+++ b/scripts/geometry/README.md
@@ -0,0 +1,27 @@
+This is the tool O2_CADtoTGeo.py which translates from geometries in STEP format (CAD export) to
+TGeo.
+
+To use the tool, setup a conda environment with python-occ core installed.
+The following should work on standard linux x86:
+
+```
+# -) download miniconda into $HOME/miniconda (if not already done)
+if [ ! -d $HOME/miniconda ]; then
+  curl -fsSL https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh -o miniconda.sh
+  bash miniconda.sh -b -p $HOME/miniconda
+fi
+
+# -) source conda into the environment (in every shell you want to use this)
+source $HOME/miniconda/etc/profile.d/conda.sh
+
+# -) Create an OCC environment (for OpenCacade)
+conda create -n occ python=3.10 -y
+conda activate occ
+
+# 3) Install OpenCascade Python bindings
+conda install -c conda-forge pythonocc-core -y
+
+# 4) Run the tool, e.g.
+conda activate occ
+python PATH_TO_ALICEO2_SOURCES/scripts/geometry/O2_CADtoTGeo.py --help
+```
\ No newline at end of file
diff --git a/scripts/geometry/simulating_CAD_modules.md b/scripts/geometry/simulating_CAD_modules.md
new file mode 100644
index 0000000000000..ccd59a3523781
--- /dev/null
+++ b/scripts/geometry/simulating_CAD_modules.md
@@ -0,0 +1,72 @@
+# ALICE-O2 GEANT Simulation of CAD Geometries
+
+These are a few notes related to the inclusion of external (CAD-described) detector modules into the O2 simulation framework.
+
+## Description of the Workflow
+
+In principle, such integration is now possible and requires the following steps:
+
+1. The CAD geometry needs to be exported to STEP format and must contain only the final geometry (no artificial eta-cut elements). Ideally, the geometry should be fully hierarchical with proper solid reuse. The solids should retain their proper surface representation for detailed analysis.
+
+2. A tool `O2-CADtoTGeo.py` is provided to convert the STEP geometry into TGeo format. The tool is part of AliceO2 and is based on Python bindings (OCC) for OpenCascade. The tool can be used as follows:
+
+    ```bash
+    python O2-CADtoTGeo.py STEP_FILE --output-folder my_detector -o geom.C --mesh \
+                           --mesh-prec 0.2
+    ```
+
+    This will create a ROOT macro file `geom.C` containing the geometry description in ROOT format, as well as several binary files describing the TGeo solids. The `geom.C` file can either be used directly in ROOT to inspect the geometry or be provided to ALICE-O2 for inclusion in the geometry.
+
+3. Introduction of materials/media in the file `geom.C`. Currently, the file `geom.C` needs to be patched or edited to properly include `TGeoMaterial`/`TGeoMedium` definitions and connect them to the relevant `TGeoVolume` objects. At present, every solid has the same dummy material attached, which is not realistic. It may be a good idea to create a new file `geom_withMaterials.C`, which differs from `geom.C` by the addition of these material definitions.
+
+4. Once the conversion is complete, the module can be inserted into the O2 geometry via the `ExternalModule` class. To do so, follow this pattern in `build_geometry.C`:
+
+    ```cpp
+    if (isActivated("EXT")) {
+      o2::passive::ExternalModuleOptions options;
+      options.root_macro_file = "PATH_TO_MY_DETECTOR/my_detector/geom_withMaterials.C";
+      options.anchor_volume = "barrel"; // hook this into barrel
+      auto rot = new TGeoCombiTrans();
+      rot->RotateX(90);
+      rot->SetDy(30); // compensate for a shift of the barrel with respect to zero
+      options.placement = rot;
+      run->AddModule(new o2::passive::ExternalModule("A3VTX", "ALICE3 beam pipe", options));
+    }
+    ```
+
+5. Create a custom detector geometry list file `my_det.json` in JSON format that includes the external detector (and any other required components, such as the L3 magnet in this example):
+
+    ```json
+    {
+      "MY_DET": [
+        "EXT",
+        "MAG"
+      ]
+    }
+    ```
+
+6. Run the Geant simulation with:
+
+   ```bash
+   o2-sim --detectorList MY_DET:my_det.json -g pythia8pp ....
+   ```
+
+## Known Limitations
+
+- The `O2-CADtoTGeo.py` tool currently converts geometries only into TGeoTessellated solids. This may be suboptimal for primitive shapes or only an approximation for shapes with exact second-order surfaces (e.g., tubes). The precision (and therefore the number of surface triangles) can be controlled with the `--mesh-prec` parameter. The smaller the value, the more precise the mesh.
+
+- Meshed solids created by the tool may have issues, such as topological errors or non-watertight surfaces. It is planned to include "healing" steps via additional processing with well-known geometry kernels (e.g., CGAL).
+
+- The tool does not currently export materials or TGeoMedia. These must be inserted or edited manually. It is planned to make this process more automatic and user-friendly.
+
+- The Python tool requires the OCC Python module, which is currently not part of our software distribution. We have found it most practical to run the tool in a separate conda environment (fully decoupled from the ALICE software stack).
+
+- The tool currently generates a `geom.C` macro file. In the future, it may be possible to directly create an in-memory TGeo representation for deeper integration.
+
+- Currently, only passive modules can be integrated. Treatment of sensitive volumes or parts will be addressed in a future step.
+
+## Software Installation
+
+- The simulation must be run in the standard O2 environment built with alibuild.
+
+- The CAD conversion tool must currently be run in a dedicated conda environment, as described in scripts/geometry/README.md in the AliceO2 source code.
\ No newline at end of file

From 17d865e646a90d7e19ae43424d2404dd163885ec Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Fri, 13 Feb 2026 16:34:50 +0100
Subject: [PATCH 1323/1764] Fix Header info forwarding

---
 Generators/src/GeneratorHybrid.cxx | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/Generators/src/GeneratorHybrid.cxx b/Generators/src/GeneratorHybrid.cxx
index 2a13f9876e717..f853b772e3cd3 100644
--- a/Generators/src/GeneratorHybrid.cxx
+++ b/Generators/src/GeneratorHybrid.cxx
@@ -420,6 +420,7 @@ bool GeneratorHybrid::importParticles()
   mMCEventHeader.clearInfo();
   if (mCocktailMode) {
     // in cocktail mode we need to merge the particles from the different generators
+    bool baseGen = true; // first generator of the cocktail is used as reference to update the event header information
     for (auto subIndex : subGenIndex) {
       LOG(info) << "Importing particles for task " << subIndex;
       auto subParticles = gens[subIndex]->getParticles();
@@ -441,8 +442,10 @@ bool GeneratorHybrid::importParticles()
       }
 
       mParticles.insert(mParticles.end(), subParticles.begin(), subParticles.end());
-      // fetch the event Header information from the underlying generator
-      gens[subIndex]->updateHeader(&mMCEventHeader);
+      if (baseGen) {
+        gens[subIndex]->updateHeader(&mMCEventHeader);
+        baseGen = false;
+      }
       mInputTaskQueue.push(subIndex);
       mTasksStarted++;
     }
@@ -481,7 +484,9 @@ bool GeneratorHybrid::importParticles()
 void GeneratorHybrid::updateHeader(o2::dataformats::MCEventHeader* eventHeader)
 {
   if (eventHeader) {
-    // we forward the original header information if any
+    // Forward the base class fields from FairMCEventHeader
+    static_cast<FairMCEventHeader&>(*eventHeader) = static_cast<FairMCEventHeader&>(mMCEventHeader);
+    // Copy the key-value store info
     eventHeader->copyInfoFrom(mMCEventHeader);
 
     // put additional information about

From 8361c429fd87b9d0cb215b1ac83f5ee1fd162269 Mon Sep 17 00:00:00 2001
From: ddobrigk <david.dobrigkeit.chinellato@cern.ch>
Date: Sat, 14 Feb 2026 09:47:17 +0100
Subject: [PATCH 1324/1764] Add option to compress out non-dEdx info in TrackQA
 table (#15045)

* Add compress-out option for non-dEdx info in TrackQA

* Add compress-out option for non-dEdx info in TrackQA

* Retain also TPC-only tracks used by svtx, strangeness tracking

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../AODProducerWorkflowSpec.h                 |  1 +
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 34 ++++++++++---------
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 2d16f343dc1eb..2c58db42ed856 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -238,6 +238,7 @@ class AODProducerWorkflowDPL : public Task
   bool mPropTracks{false};
   bool mPropMuons{false};
   float mTrackQCKeepGlobalTracks{false};
+  float mTrackQCRetainOnlydEdx{false};
   float mTrackQCFraction{0.00};
   int64_t mTrackQCNTrCut{4};
   float mTrackQCDCAxy{3.};
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index be169ad4be19d..852419a9895eb 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -363,10 +363,10 @@ void AODProducerWorkflowDPL::addToTracksQATable(TracksQACursorType& tracksQACurs
 {
   tracksQACursor(
     trackQAInfoHolder.trackID,
-    truncateFloatFraction(trackQAInfoHolder.tpcTime0, mTPCTime0),
+    mTrackQCRetainOnlydEdx ? 0.0f : truncateFloatFraction(trackQAInfoHolder.tpcTime0, mTPCTime0),
     truncateFloatFraction(trackQAInfoHolder.tpcdEdxNorm, mTrackSignal),
-    trackQAInfoHolder.tpcdcaR,
-    trackQAInfoHolder.tpcdcaZ,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int16_t>::min() : trackQAInfoHolder.tpcdcaR,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int16_t>::min() : trackQAInfoHolder.tpcdcaZ,
     trackQAInfoHolder.tpcClusterByteMask,
     trackQAInfoHolder.tpcdEdxMax0R,
     trackQAInfoHolder.tpcdEdxMax1R,
@@ -376,18 +376,18 @@ void AODProducerWorkflowDPL::addToTracksQATable(TracksQACursorType& tracksQACurs
     trackQAInfoHolder.tpcdEdxTot1R,
     trackQAInfoHolder.tpcdEdxTot2R,
     trackQAInfoHolder.tpcdEdxTot3R,
-    trackQAInfoHolder.dRefContY,
-    trackQAInfoHolder.dRefContZ,
-    trackQAInfoHolder.dRefContSnp,
-    trackQAInfoHolder.dRefContTgl,
-    trackQAInfoHolder.dRefContQ2Pt,
-    trackQAInfoHolder.dRefGloY,
-    trackQAInfoHolder.dRefGloZ,
-    trackQAInfoHolder.dRefGloSnp,
-    trackQAInfoHolder.dRefGloTgl,
-    trackQAInfoHolder.dRefGloQ2Pt,
-    trackQAInfoHolder.dTofdX,
-    trackQAInfoHolder.dTofdZ);
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefContY,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefContZ,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefContSnp,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefContTgl,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefContQ2Pt,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefGloY,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefGloZ,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefGloSnp,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefGloTgl,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dRefGloQ2Pt,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dTofdX,
+    mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dTofdZ);
 }
 
 template <typename mftTracksCursorType, typename AmbigMFTTracksCursorType>
@@ -499,7 +499,7 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
 
           float weight = 0;
           static std::uniform_real_distribution<> distr(0., 1.);
-          bool writeQAData = o2::math_utils::Tsallis::downsampleTsallisCharged(data.getTrackParam(trackIndex).getPt(), mTrackQCFraction, mSqrtS, weight, distr(mGenerator)) || (src != GIndex::TPC && mTrackQCKeepGlobalTracks);
+          bool writeQAData = o2::math_utils::Tsallis::downsampleTsallisCharged(data.getTrackParam(trackIndex).getPt(), mTrackQCFraction, mSqrtS, weight, distr(mGenerator)) || ((src != GIndex::TPC || mGIDUsedBySVtx.find(trackIndex) != mGIDUsedBySVtx.end() || mGIDUsedByStr.find(trackIndex) != mGIDUsedByStr.end()) && mTrackQCKeepGlobalTracks);
           auto extraInfoHolder = processBarrelTrack(collisionID, collisionBC, trackIndex, data, bcsMap);
 
           if (writeQAData) {
@@ -1720,6 +1720,7 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
     }
   }
   mTrackQCKeepGlobalTracks = ic.options().get<bool>("trackqc-keepglobaltracks");
+  mTrackQCRetainOnlydEdx = ic.options().get<bool>("trackqc-retainonlydedx");
   mTrackQCFraction = ic.options().get<float>("trackqc-fraction");
   mTrackQCNTrCut = ic.options().get<int64_t>("trackqc-NTrCut");
   mTrackQCDCAxy = ic.options().get<float>("trackqc-tpc-dca");
@@ -3356,6 +3357,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"propagate-muons", VariantType::Bool, false, {"Propagate muons to IP"}},
       ConfigParamSpec{"thin-tracks", VariantType::Bool, false, {"Produce thinned track tables"}},
       ConfigParamSpec{"trackqc-keepglobaltracks", VariantType::Bool, false, {"Always keep TrackQA for global tracks"}},
+      ConfigParamSpec{"trackqc-retainonlydedx", VariantType::Bool, false, {"Keep only dEdx information, zero out everything else"}},
       ConfigParamSpec{"trackqc-fraction", VariantType::Float, float(0.1), {"Fraction of tracks to QC"}},
       ConfigParamSpec{"trackqc-NTrCut", VariantType::Int64, 4L, {"Minimal length of the track - in amount of tracklets"}},
       ConfigParamSpec{"trackqc-tpc-dca", VariantType::Float, 3.f, {"Keep TPC standalone track with this DCAxy to the PV"}},

From b87ed891b1f785c042f7cc9f2d490d3f5a6dd3f1 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 15 Feb 2026 14:29:48 +0100
Subject: [PATCH 1325/1764] DPL Examples: use the new completion policy for
 parallel processing (#15059)

This demonstrates how the new policy can be used in conjunction
with wildcards in order to simplify parallelism based on the
subSpecification.
---
 .../Framework/CompletionPolicyHelpers.h       |  1 -
 .../TestWorkflows/src/o2ParallelWorkflow.cxx  | 77 ++++++++++++-------
 2 files changed, 48 insertions(+), 30 deletions(-)

diff --git a/Framework/Core/include/Framework/CompletionPolicyHelpers.h b/Framework/Core/include/Framework/CompletionPolicyHelpers.h
index 9fce626854e5b..09ea8b7ea6b61 100644
--- a/Framework/Core/include/Framework/CompletionPolicyHelpers.h
+++ b/Framework/Core/include/Framework/CompletionPolicyHelpers.h
@@ -11,7 +11,6 @@
 #ifndef O2_FRAMEWORK_COMPLETIONPOLICYHELPERS_H_
 #define O2_FRAMEWORK_COMPLETIONPOLICYHELPERS_H_
 
-#include "Framework/ChannelSpec.h"
 #include "Framework/CompletionPolicy.h"
 #include "Headers/DataHeader.h"
 
diff --git a/Framework/TestWorkflows/src/o2ParallelWorkflow.cxx b/Framework/TestWorkflows/src/o2ParallelWorkflow.cxx
index 841f4a8f2b9bd..bdc08ad45ea24 100644
--- a/Framework/TestWorkflows/src/o2ParallelWorkflow.cxx
+++ b/Framework/TestWorkflows/src/o2ParallelWorkflow.cxx
@@ -9,7 +9,12 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include "Framework/ConcreteDataMatcher.h"
 #include "Framework/ConfigParamSpec.h"
+#include "Framework/CompletionPolicy.h"
+#include "Framework/CompletionPolicyHelpers.h"
+#include "Framework/InputRecordWalker.h"
+#include "Framework/Logger.h"
 
 #include <chrono>
 #include <thread>
@@ -29,13 +34,16 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     ConfigParamSpec{"3-layer-pipelining", VariantType::Int, 1, {timeHelp}});
 }
 
+void customize(std::vector<CompletionPolicy>& policies)
+{
+  policies = {
+    CompletionPolicyHelpers::consumeWhenPastOldestPossibleTimeframe("merger-policy", [](auto const&) -> bool { return true; })};
+}
+
 #include "Framework/runDataProcessing.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/DataSpecUtils.h"
 #include "Framework/ParallelContext.h"
-#include "Framework/ControlService.h"
-
-#include "Framework/Logger.h"
 
 #include <vector>
 
@@ -43,22 +51,24 @@ using DataHeader = o2::header::DataHeader;
 
 DataProcessorSpec templateProcessor()
 {
-  return DataProcessorSpec{"some-processor", {
-                                               InputSpec{"x", "TST", "A", 0, Lifetime::Timeframe},
-                                             },
-                           {
+  return DataProcessorSpec{.name = "some-processor",
+                           .inputs = {
+                             InputSpec{"x", "TST", "A", 0, Lifetime::Timeframe},
+                           },
+                           .outputs = {
                              OutputSpec{"TST", "P", 0, Lifetime::Timeframe},
                            },
                            // The producer is stateful, we use a static for the state in this
                            // particular case, but a Singleton or a captured new object would
                            // work as well.
-                           AlgorithmSpec{[](InitContext& setup) {
+                           .algorithm = AlgorithmSpec{[](InitContext& setup) {
                              srand(setup.services().get<ParallelContext>().index1D());
                              return [](ProcessingContext& ctx) {
                                // Create a single output.
                                size_t index = ctx.services().get<ParallelContext>().index1D();
-                               auto& aData = ctx.outputs().make<int>(
+                               auto& i = ctx.outputs().make<int>(
                                  Output{"TST", "P", static_cast<o2::header::DataHeader::SubSpecificationType>(index)}, 1);
+                               i[0] = index;
                                std::this_thread::sleep_for(std::chrono::seconds(rand() % 5));
                              };
                            }}};
@@ -86,34 +96,43 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
     outputSpecs.emplace_back("TST", "A", ssi);
   }
 
-  workflow.push_back(DataProcessorSpec{"reader", {}, outputSpecs, AlgorithmSpec{[jobs](InitContext& initCtx) {
-                                         return [jobs](ProcessingContext& ctx) {
-                                           for (size_t ji = 0; ji < jobs; ++ji) {
-                                             ctx.outputs().make<int>(Output{"TST", "A", static_cast<o2::header::DataHeader::SubSpecificationType>(ji)},
-                                                                     1);
-                                           }
-                                         };
-                                       }}});
+  workflow.push_back(DataProcessorSpec{
+    .name = "reader",
+    .outputs = outputSpecs,
+    .algorithm = AlgorithmSpec{[jobs](InitContext& initCtx) {
+      return [jobs](ProcessingContext& ctx) {
+        static int count = 0;
+        for (size_t ji = 0; ji < jobs; ++ji) {
+          int& i = ctx.outputs().make<int>(Output{"TST", "A", static_cast<o2::header::DataHeader::SubSpecificationType>(ji)});
+          i = count * 100 + ji;
+        }
+        count++;
+      };
+    }}});
   workflow.push_back(timePipeline(DataProcessorSpec{
-                                    "merger",
-                                    mergeInputs(InputSpec{"x", "TST", "P"},
-                                                jobs,
-                                                [](InputSpec& input, size_t index) {
-                                                  DataSpecUtils::updateMatchingSubspec(input, index);
-                                                }),
-                                    {OutputSpec{{"out"}, "TST", "M"}},
-                                    AlgorithmSpec{[](InitContext& setup) {
+                                    .name = "merger",
+                                    .inputs = {InputSpec{"all", ConcreteDataTypeMatcher{"TST", "P"}}},
+                                    .outputs = {OutputSpec{{"out"}, "TST", "M"}},
+                                    .algorithm = AlgorithmSpec{[](InitContext& setup) {
                                       return [](ProcessingContext& ctx) {
+                                        LOGP(info, "Run");
+                                        for (const auto& input : o2::framework::InputRecordWalker(ctx.inputs())) {
+                                          if (input.header == nullptr) {
+                                            LOGP(error, "Missing header");
+                                            continue;
+                                          }
+                                          int record = *(int*)input.payload;
+                                          LOGP(info, "Record {}", record);
+                                        }
                                         ctx.outputs().make<int>(OutputRef("out", 0), 1);
                                       };
                                     }}},
                                   stages));
 
   workflow.push_back(DataProcessorSpec{
-    "writer",
-    {InputSpec{"x", "TST", "M"}},
-    {},
-    AlgorithmSpec{[](InitContext& setup) {
+    .name = "writer",
+    .inputs = {InputSpec{"x", "TST", "M"}},
+    .algorithm = AlgorithmSpec{[](InitContext& setup) {
       return [](ProcessingContext& ctx) {
       };
     }}});

From cbace3965ebdcb915f78a5535d447571ae056a68 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 15 Feb 2026 21:48:06 +0100
Subject: [PATCH 1326/1764] GPU TPC: Assume more sector track hits for low
 field data

---
 GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h | 6 ++++--
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx  | 5 +++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
index ff8abdc1a491e..067a11817d7ac 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
@@ -43,7 +43,9 @@ struct GPUMemorySizeScalers {
   double tpcClustersPerPeak = 0.9;
   double tpcStartHitsPerHit = 0.08;
   double tpcTrackletsPerStartHit = 0.8;
+  double tpcTrackletsPerStartHitLowField = 0.85;
   double tpcTrackletHitsPerHit = 5;
+  double tpcTrackletHitsPerHitLowField = 7;
   double tpcSectorTracksPerHit = 0.02;
   double tpcSectorTrackHitsPerHit = 0.8;
   double tpcSectorTrackHitsPerHitWithRejection = 1.0;
@@ -80,8 +82,8 @@ struct GPUMemorySizeScalers {
   inline size_t NTPCClusters(size_t tpcDigits, bool perSector = false) { return getValue(perSector ? tpcMaxSectorClusters : tpcMaxClusters, (conservative ? 1.0 : tpcClustersPerPeak) * NTPCPeaks(tpcDigits, perSector)); }
   inline size_t NTPCStartHits(size_t tpcHits) { return getValue(tpcMaxStartHits, tpcHits * tpcStartHitsPerHit); }
   inline size_t NTPCRowStartHits(size_t tpcHits) { return getValue(tpcMaxRowStartHits, std::max<size_t>(NTPCStartHits(tpcHits) * (tpcHits < 30000000 ? 20 : 12) / GPUCA_ROW_COUNT, tpcMinRowStartHits)); }
-  inline size_t NTPCTracklets(size_t tpcHits) { return getValue(tpcMaxTracklets, NTPCStartHits(tpcHits) * tpcTrackletsPerStartHit); }
-  inline size_t NTPCTrackletHits(size_t tpcHits) { return getValue(tpcMaxTrackletHits, hitOffset + tpcHits * tpcTrackletHitsPerHit); }
+  inline size_t NTPCTracklets(size_t tpcHits, bool lowField) { return getValue(tpcMaxTracklets, NTPCStartHits(tpcHits) * (lowField ? tpcTrackletsPerStartHitLowField : tpcTrackletsPerStartHit)); }
+  inline size_t NTPCTrackletHits(size_t tpcHits, bool lowField) { return getValue(tpcMaxTrackletHits, hitOffset + tpcHits * (lowField ? tpcTrackletHitsPerHitLowField : tpcTrackletHitsPerHit)); }
   inline size_t NTPCSectorTracks(size_t tpcHits) { return getValue(tpcMaxSectorTracks, tpcHits * tpcSectorTracksPerHit); }
   inline size_t NTPCSectorTrackHits(size_t tpcHits, uint8_t withRejection = 0) { return getValue(tpcMaxSectorTrackHits, tpcHits * (withRejection ? tpcSectorTrackHitsPerHitWithRejection : tpcSectorTrackHitsPerHit)); }
   inline size_t NTPCMergedTracks(size_t tpcSectorTracks) { return getValue(tpcMaxMergedTracks, tpcSectorTracks * (conservative ? 1.0 : tpcMergedTrackPerSectorTrack)); }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index 03931f73a4a12..506f90c55abf3 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -144,8 +144,9 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   } else {
     mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(mData.NumberOfHits());
   }
-  mNMaxTracklets = mRec->MemoryScalers()->NTPCTracklets(mData.NumberOfHits());
-  mNMaxRowHits = mRec->MemoryScalers()->NTPCTrackletHits(mData.NumberOfHits());
+  bool lowField = CAMath::Abs(Param().bzkG) < 4;
+  mNMaxTracklets = mRec->MemoryScalers()->NTPCTracklets(mData.NumberOfHits(), lowField);
+  mNMaxRowHits = mRec->MemoryScalers()->NTPCTrackletHits(mData.NumberOfHits(), lowField);
   mNMaxTracks = mRec->MemoryScalers()->NTPCSectorTracks(mData.NumberOfHits());
   if (io.clustersNative) {
     uint32_t sectorOffset = mISector >= GPUCA_NSECTORS / 2 ? GPUCA_NSECTORS / 2 : 0;

From 23a36dfe2517df697788634b9a64088e86c0822b Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Mon, 16 Feb 2026 14:10:23 +0100
Subject: [PATCH 1327/1764] Add Kine publisher test (#15058)

---
 prodtests/full_system_test.sh | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 82021d6c65e63..07ccdf01d4566 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -168,6 +168,13 @@ taskwrapper collcontext.log o2-steer-colcontexttool \
 SIMOPTKEY+="GenTPCLoopers.colsys=${BEAMTYPE};"
 
 taskwrapper sim.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} --vertexMode kCollContext --seed $O2SIMSEED -n $NEvents --configKeyValues "\"$SIMOPTKEY\"" -g ${FST_GENERATOR} -e ${FST_MC_ENGINE} -j $NJOBS --run ${RUNNUMBER} -o o2sim --fromCollContext collisioncontext.root:o2sim
+# Test MCTracks to AO2D conversion tool
+taskwrapper kine2aod.log "o2-sim-kine-publisher -b --kineFileName o2sim --aggregate-timeframe $NEvents | o2-sim-mctracks-to-aod -b --aod-writer-keep dangling | o2-analysis-mctracks-to-aod-simple-task -b"
+if [[ ! -s AnalysisResults_trees.root ]] || [[ ! -s AnalysisResults.root ]]; then
+  echo "Error: AnalysisResults_trees.root (AO2D from Kine file) or AnalysisResults.root (simple analysis task output) missing or empty"
+  exit 1
+fi
+
 if [[ $DO_EMBEDDING == 1 ]]; then
   taskwrapper embed.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} -j $NJOBS --run ${RUNNUMBER} -n $NEvents -g pythia8pp -e ${FST_MC_ENGINE} -o sig --configKeyValues ${FST_EMBEDDING_CONFIG} --embedIntoFile o2sim_MCHeader.root
 fi

From 75a357d3e2fcb58cadca886055691d53eac62004 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Wiktor=20Piero=C5=BCak?=
 <94726725+wpierozak@users.noreply.github.com>
Date: Mon, 16 Feb 2026 14:14:28 +0100
Subject: [PATCH 1328/1764] Afit 124 (#14985)

* FV0: included dead channel map in reconstruction

* FV0: fixed fetch of dead channel map in reco

* FV0:Added debug log when data from dead channel is discard

* FV0: changed handling of dead channel in reco

* Implementation DeadChannelMap in FDD/FT0

* Updaed FDD reco

* FIT:Fixed application of DeadChannelMap in FV0 and FDD reconstruction task

* Fixed missing constructor arguments for FDD RecoSepc

* Please consider the following formatting changes

---------

Co-authored-by: wpierozak <wpierozak@Laptop-Wiktor.play.pl>
Co-authored-by: wpierozak <wpierozak@localhost.localdomain>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../include/FDDReconstruction/Reconstructor.h |  9 ++++++-
 .../FDD/reconstruction/src/Reconstructor.cxx  |  5 ++++
 .../include/FDDWorkflow/RecoWorkflow.h        |  2 +-
 .../include/FDDWorkflow/ReconstructorSpec.h   | 10 +++++--
 .../FIT/FDD/workflow/src/RecoWorkflow.cxx     |  4 +--
 .../FDD/workflow/src/ReconstructorSpec.cxx    | 23 ++++++++++++++--
 .../FDD/workflow/src/fdd-reco-workflow.cxx    |  4 ++-
 .../FT0Reconstruction/CollisionTimeRecoTask.h |  7 +++++
 .../src/CollisionTimeRecoTask.cxx             |  4 +++
 .../include/FT0Workflow/RecoWorkflow.h        |  2 +-
 .../include/FT0Workflow/ReconstructionSpec.h  |  6 +++--
 .../FIT/FT0/workflow/src/RecoWorkflow.cxx     |  4 +--
 .../FT0/workflow/src/ReconstructionSpec.cxx   | 22 +++++++++++++--
 .../FT0/workflow/src/ft0-reco-workflow.cxx    |  6 +++--
 .../include/FV0Reconstruction/BaseRecoTask.h  |  6 +++--
 .../FV0/reconstruction/src/BaseRecoTask.cxx   | 27 +++++++++++--------
 .../include/FV0Workflow/RecoWorkflow.h        |  2 +-
 .../include/FV0Workflow/ReconstructionSpec.h  |  6 +++--
 .../FIT/FV0/workflow/src/RecoWorkflow.cxx     |  5 ++--
 .../FV0/workflow/src/ReconstructionSpec.cxx   | 21 ++++++++++-----
 .../FV0/workflow/src/fv0-reco-workflow.cxx    |  4 ++-
 21 files changed, 135 insertions(+), 44 deletions(-)

diff --git a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/Reconstructor.h b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/Reconstructor.h
index 161b800a2c3ca..8881605b652ac 100644
--- a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/Reconstructor.h
+++ b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/Reconstructor.h
@@ -17,6 +17,7 @@
 #include <vector>
 #include "DataFormatsFDD/Digit.h"
 #include "DataFormatsFDD/RecPoint.h"
+#include "DataFormatsFIT/DeadChannelMap.h"
 namespace o2
 {
 namespace fdd
@@ -30,10 +31,16 @@ class Reconstructor
                gsl::span<const o2::fdd::ChannelData> inChData,
                std::vector<o2::fdd::RecPoint>& RecPoints,
                std::vector<o2::fdd::ChannelDataFloat>& outChData);
-
   void finish();
 
+  void setDeadChannelMap(o2::fit::DeadChannelMap const* deadChannelMap)
+  {
+    LOG(info) << "Updated dead channel map";
+    mDeadChannelMap = deadChannelMap;
+  }
+
  private:
+  o2::fit::DeadChannelMap const* mDeadChannelMap = nullptr;
   ClassDefNV(Reconstructor, 3);
 };
 } // namespace fdd
diff --git a/Detectors/FIT/FDD/reconstruction/src/Reconstructor.cxx b/Detectors/FIT/FDD/reconstruction/src/Reconstructor.cxx
index 3a87a11046a77..7d133e30df08e 100644
--- a/Detectors/FIT/FDD/reconstruction/src/Reconstructor.cxx
+++ b/Detectors/FIT/FDD/reconstruction/src/Reconstructor.cxx
@@ -33,7 +33,12 @@ void Reconstructor::process(o2::fdd::Digit const& digitBC, gsl::span<const o2::f
   int firstEntry = outChData.size();
   int nStored = 0;
   int nch = inChData.size();
+
   for (int ich = 0; ich < nch; ich++) {
+    if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(inChData[ich].mPMNumber)) {
+      LOG(debug) << "Channel " << ich << " is dead - discarding data";
+      continue;
+    }
     bool inTime = inChData[ich].getFlag(ChannelData::EEventDataBit::kIsEventInTVDC);
     bool inAdcGate = inChData[ich].getFlag(ChannelData::EEventDataBit::kIsCFDinADCgate);
     if (inAdcGate) {
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RecoWorkflow.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RecoWorkflow.h
index 2dbd854e34eee..0d5d308216bb0 100644
--- a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RecoWorkflow.h
+++ b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RecoWorkflow.h
@@ -20,7 +20,7 @@ namespace o2
 {
 namespace fdd
 {
-framework::WorkflowSpec getRecoWorkflow(bool useMC, bool disableRootInp, bool disableRootOut);
+framework::WorkflowSpec getRecoWorkflow(bool useMC, bool disableRootInp, bool disableRootOut, bool useDeadChannelMap);
 } // namespace fdd
 } // namespace o2
 #endif
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/ReconstructorSpec.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/ReconstructorSpec.h
index 7dcb5d9aaba40..8f20ff1513ab4 100644
--- a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/ReconstructorSpec.h
+++ b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/ReconstructorSpec.h
@@ -18,6 +18,8 @@
 #include "Framework/Task.h"
 #include "FDDReconstruction/Reconstructor.h"
 #include "DataFormatsFDD/RecPoint.h"
+#include "DataFormatsFIT/DeadChannelMap.h"
+#include "Framework/ConcreteDataMatcher.h"
 
 using namespace o2::framework;
 
@@ -29,21 +31,25 @@ namespace fdd
 class FDDReconstructorDPL : public Task
 {
  public:
-  FDDReconstructorDPL(bool useMC) : mUseMC(useMC) {}
+  FDDReconstructorDPL(bool useMC, bool useDeadChannelMap) : mUseMC(useMC), mUseDeadChannelMap(useDeadChannelMap) {}
   ~FDDReconstructorDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
 
  private:
   bool mUseMC = true;
+  bool mUseDeadChannelMap = true;
+  bool mUpdateDeadChannelMap = true;
   std::vector<o2::fdd::RecPoint> mRecPoints;
   std::vector<o2::fdd::ChannelDataFloat> mRecChData;
+  o2::fit::DeadChannelMap const* mDeadChannelMap;
   o2::fdd::Reconstructor mReco;
   o2::header::DataOrigin mOrigin = o2::header::gDataOriginFDD;
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getFDDReconstructorSpec(bool useMC = true);
+framework::DataProcessorSpec getFDDReconstructorSpec(bool useMC = true, bool useDeadChannelMap = true);
 
 } // namespace fdd
 } // namespace o2
diff --git a/Detectors/FIT/FDD/workflow/src/RecoWorkflow.cxx b/Detectors/FIT/FDD/workflow/src/RecoWorkflow.cxx
index a7d4c15af81bb..b464e689f7a75 100644
--- a/Detectors/FIT/FDD/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/FIT/FDD/workflow/src/RecoWorkflow.cxx
@@ -22,14 +22,14 @@ namespace o2
 namespace fdd
 {
 
-framework::WorkflowSpec getRecoWorkflow(bool useMC, bool disableRootInp, bool disableRootOut)
+framework::WorkflowSpec getRecoWorkflow(bool useMC, bool disableRootInp, bool disableRootOut, bool useDeadChannelMap)
 {
   framework::WorkflowSpec specs;
 
   if (!disableRootInp) {
     specs.emplace_back(o2::fdd::getFDDDigitReaderSpec(useMC));
   }
-  specs.emplace_back(o2::fdd::getFDDReconstructorSpec(useMC));
+  specs.emplace_back(o2::fdd::getFDDReconstructorSpec(useMC, useDeadChannelMap));
   if (!disableRootOut) {
     specs.emplace_back(o2::fdd::getFDDRecPointWriterSpec(useMC));
   }
diff --git a/Detectors/FIT/FDD/workflow/src/ReconstructorSpec.cxx b/Detectors/FIT/FDD/workflow/src/ReconstructorSpec.cxx
index b7a0b9876a2ee..1d5d599b5ee31 100644
--- a/Detectors/FIT/FDD/workflow/src/ReconstructorSpec.cxx
+++ b/Detectors/FIT/FDD/workflow/src/ReconstructorSpec.cxx
@@ -18,6 +18,7 @@
 #include "FDDWorkflow/ReconstructorSpec.h"
 #include "DataFormatsFDD/Digit.h"
 #include "DataFormatsFDD/MCLabel.h"
+#include "Framework/CCDBParamSpec.h"
 
 using namespace o2::framework;
 
@@ -44,6 +45,11 @@ void FDDReconstructorDPL::run(ProcessingContext& pc)
     // lblPtr = labels.get();
     LOG(info) << "Ignoring MC info";
   }
+  if (mUseDeadChannelMap && mUpdateDeadChannelMap) {
+    LOG(info) << "Populating reconsturctor object with Dead Channel Map object";
+    auto deadChannelMap = pc.inputs().get<o2::fit::DeadChannelMap*>("deadChannelMap");
+    mReco.setDeadChannelMap(deadChannelMap.get());
+  }
   int nDig = digitsBC.size();
   mRecPoints.reserve(nDig);
   mRecChData.reserve(digitsCh.size());
@@ -58,16 +64,29 @@ void FDDReconstructorDPL::run(ProcessingContext& pc)
   pc.outputs().snapshot(Output{mOrigin, "RECCHDATA", 0}, mRecChData);
 }
 
-DataProcessorSpec getFDDReconstructorSpec(bool useMC)
+void FDDReconstructorDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+{
+  if (matcher == ConcreteDataMatcher("FDD", "DeadChannelMap", 0)) {
+    mUpdateDeadChannelMap = false;
+    return;
+  }
+}
+
+DataProcessorSpec getFDDReconstructorSpec(bool useMC, bool useDeadChannelMap)
 {
   std::vector<InputSpec> inputSpec;
   std::vector<OutputSpec> outputSpec;
   inputSpec.emplace_back("digitsBC", o2::header::gDataOriginFDD, "DIGITSBC", 0, Lifetime::Timeframe);
   inputSpec.emplace_back("digitsCh", o2::header::gDataOriginFDD, "DIGITSCH", 0, Lifetime::Timeframe);
+
   if (useMC) {
     LOG(info) << "Currently FDDReconstructor does not consume and provide MC truth";
     // inputSpec.emplace_back("labels", o2::header::gDataOriginFDD, "DIGITSMCTR", 0, Lifetime::Timeframe);
   }
+  if (useDeadChannelMap) {
+    LOG(info) << "Dead channel map will be applied during reconstruction";
+    inputSpec.emplace_back("deadChannelMap", o2::header::gDataOriginFDD, "DeadChannelMap", 0, Lifetime::Condition, ccdbParamSpec("FDD/Calib/DeadChannelMap"));
+  }
   outputSpec.emplace_back(o2::header::gDataOriginFDD, "RECPOINTS", 0, Lifetime::Timeframe);
   outputSpec.emplace_back(o2::header::gDataOriginFDD, "RECCHDATA", 0, Lifetime::Timeframe);
 
@@ -75,7 +94,7 @@ DataProcessorSpec getFDDReconstructorSpec(bool useMC)
     "fdd-reconstructor",
     inputSpec,
     outputSpec,
-    AlgorithmSpec{adaptFromTask<FDDReconstructorDPL>(useMC)},
+    AlgorithmSpec{adaptFromTask<FDDReconstructorDPL>(useMC, useDeadChannelMap)},
     Options{}};
 }
 
diff --git a/Detectors/FIT/FDD/workflow/src/fdd-reco-workflow.cxx b/Detectors/FIT/FDD/workflow/src/fdd-reco-workflow.cxx
index 652ddb8bd2a29..888792425909b 100644
--- a/Detectors/FIT/FDD/workflow/src/fdd-reco-workflow.cxx
+++ b/Detectors/FIT/FDD/workflow/src/fdd-reco-workflow.cxx
@@ -38,6 +38,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}},
     {"disable-root-input", o2::framework::VariantType::Bool, false, {"disable root-files input readers"}},
     {"disable-root-output", o2::framework::VariantType::Bool, false, {"disable root-files output writers"}},
+    {"disable-dead-channel-map", o2::framework::VariantType::Bool, false, {"disable dead channel map"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
@@ -57,8 +58,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   auto disableRootInp = configcontext.options().get<bool>("disable-root-input");
   auto disableRootOut = configcontext.options().get<bool>("disable-root-output");
+  bool useDeadChannelMap = !configcontext.options().get<bool>("disable-dead-channel-map");
 
-  auto wf = o2::fdd::getRecoWorkflow(useMC, disableRootInp, disableRootOut);
+  auto wf = o2::fdd::getRecoWorkflow(useMC, disableRootInp, disableRootOut, useDeadChannelMap);
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, wf);
diff --git a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CollisionTimeRecoTask.h b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CollisionTimeRecoTask.h
index ff3f8384f488d..9f6cd500b9e74 100644
--- a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CollisionTimeRecoTask.h
+++ b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CollisionTimeRecoTask.h
@@ -21,6 +21,7 @@
 #include "DataFormatsFT0/FT0ChannelTimeCalibrationObject.h"
 #include "DataFormatsFT0/SpectraInfoObject.h"
 #include "DataFormatsFT0/SlewingCoef.h"
+#include "DataFormatsFIT/DeadChannelMap.h"
 #include <gsl/span>
 #include <array>
 #include <vector>
@@ -57,10 +58,16 @@ class CollisionTimeRecoTask
     LOG(info) << "Init for slewing calib object";
     mCalibSlew = calibSlew->makeSlewingPlots();
   };
+  void SetDeadChannelMap(const o2::fit::DeadChannelMap* deadChannelMap)
+  {
+    LOG(info) << "Updated dead channel map for CollisionTimeRecoTask";
+    mDeadChannelMap = deadChannelMap;
+  }
   float getTimeInPS(const o2::ft0::ChannelData& channelData);
 
  private:
   o2::ft0::TimeSpectraInfoObject const* mTimeCalibObject = nullptr;
+  const o2::fit::DeadChannelMap* mDeadChannelMap = nullptr;
   typename o2::ft0::SlewingCoef::SlewingPlots_t mCalibSlew{};
 };
 } // namespace ft0
diff --git a/Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx b/Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx
index 7363cef57cf31..3e3ffe52671e9 100644
--- a/Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx
+++ b/Detectors/FIT/FT0/reconstruction/src/CollisionTimeRecoTask.cxx
@@ -67,6 +67,10 @@ RP CollisionTimeRecoTask::processDigit(const o2::ft0::Digit& digit,
       // Reference channels shouldn't participate in reco at all!
       continue;
     }
+    if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(channelData.ChId)) {
+      LOG(debug) << "Channel " << channelData.ChId << " is dead - discarding data";
+      continue;
+    }
     const float timeInPS = getTimeInPS(channelData);
     if (ChannelFilterParam::Instance().checkAll(channelData)) {
       outChData.emplace_back(channelData.ChId, timeInPS, (float)channelData.QTCAmpl, channelData.ChainQTC);
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/RecoWorkflow.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/RecoWorkflow.h
index 3c6e4599a250c..6de23a1c66bfd 100644
--- a/Detectors/FIT/FT0/workflow/include/FT0Workflow/RecoWorkflow.h
+++ b/Detectors/FIT/FT0/workflow/include/FT0Workflow/RecoWorkflow.h
@@ -20,7 +20,7 @@ namespace o2
 {
 namespace ft0
 {
-framework::WorkflowSpec getRecoWorkflow(bool useMC, std::string ccdbpath, bool useTimeOffsetCalib, bool useSlewingCalib, bool disableRootInp, bool disableRootOut);
+framework::WorkflowSpec getRecoWorkflow(bool useMC, std::string ccdbpath, bool useTimeOffsetCalib, bool useSlewingCalib, bool disableRootInp, bool disableRootOut, bool useDeadChannelMap = true);
 } // namespace ft0
 } // namespace o2
 #endif
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/ReconstructionSpec.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/ReconstructionSpec.h
index 1c671352e6ba7..307b2109fe35f 100644
--- a/Detectors/FIT/FT0/workflow/include/FT0Workflow/ReconstructionSpec.h
+++ b/Detectors/FIT/FT0/workflow/include/FT0Workflow/ReconstructionSpec.h
@@ -34,7 +34,7 @@ class ReconstructionDPL : public Task
   static constexpr int NCHANNELS = o2::ft0::Geometry::Nchannels;
 
  public:
-  ReconstructionDPL(bool useMC, const std::string& ccdbpath, bool useTimeOffsetCalib, bool useSlewingCalib) : mUseMC(useMC), mCCDBpath(ccdbpath), mUseTimeOffsetCalib(useTimeOffsetCalib), mUseSlewingCalib(useSlewingCalib) {}
+  ReconstructionDPL(bool useMC, const std::string& ccdbpath, bool useTimeOffsetCalib, bool useSlewingCalib, bool useDeadChannelMap) : mUseMC(useMC), mCCDBpath(ccdbpath), mUseTimeOffsetCalib(useTimeOffsetCalib), mUseSlewingCalib(useSlewingCalib), mUseDeadChannelMap(useDeadChannelMap) {}
   ~ReconstructionDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -46,6 +46,8 @@ class ReconstructionDPL : public Task
   bool mUpdateCCDB = true;
   bool mUseTimeOffsetCalib = true;
   bool mUseSlewingCalib = true;
+  bool mUseDeadChannelMap = true;
+  bool mUpdateDeadChannelMap = true;
   const std::string mCCDBpath = o2::base::NameConf::getCCDBServer();
   std::vector<o2::ft0::RecPoints> mRecPoints;
   std::vector<o2::ft0::ChannelDataFloat> mRecChData;
@@ -55,7 +57,7 @@ class ReconstructionDPL : public Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getReconstructionSpec(bool useMC = false, const std::string ccdbpath = "http://alice-ccdb.cern.ch", bool useTimeOffsetCalib = true, bool useSlewingCalib = true);
+framework::DataProcessorSpec getReconstructionSpec(bool useMC = false, const std::string ccdbpath = "http://alice-ccdb.cern.ch", bool useTimeOffsetCalib = true, bool useSlewingCalib = true, bool useDeadChannelMap = true);
 
 } // namespace ft0
 } // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/src/RecoWorkflow.cxx b/Detectors/FIT/FT0/workflow/src/RecoWorkflow.cxx
index 247158164ac3b..2231011febd7f 100644
--- a/Detectors/FIT/FT0/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/FIT/FT0/workflow/src/RecoWorkflow.cxx
@@ -22,13 +22,13 @@ namespace o2
 namespace ft0
 {
 
-framework::WorkflowSpec getRecoWorkflow(bool useMC, std::string ccdbpath, bool useTimeOffsetCalib, bool useSlewingCalib, bool disableRootInp, bool disableRootOut)
+framework::WorkflowSpec getRecoWorkflow(bool useMC, std::string ccdbpath, bool useTimeOffsetCalib, bool useSlewingCalib, bool disableRootInp, bool disableRootOut, bool useDeadChannelMap)
 {
   framework::WorkflowSpec specs;
   if (!disableRootInp) {
     specs.emplace_back(o2::ft0::getDigitReaderSpec(useMC));
   }
-  specs.emplace_back(o2::ft0::getReconstructionSpec(useMC, ccdbpath, useTimeOffsetCalib, useSlewingCalib));
+  specs.emplace_back(o2::ft0::getReconstructionSpec(useMC, ccdbpath, useTimeOffsetCalib, useSlewingCalib, useDeadChannelMap));
   if (!disableRootOut) {
     specs.emplace_back(o2::ft0::getRecPointWriterSpec(useMC));
   }
diff --git a/Detectors/FIT/FT0/workflow/src/ReconstructionSpec.cxx b/Detectors/FIT/FT0/workflow/src/ReconstructionSpec.cxx
index 40bc96ebca58e..bc5217c8d7471 100644
--- a/Detectors/FIT/FT0/workflow/src/ReconstructionSpec.cxx
+++ b/Detectors/FIT/FT0/workflow/src/ReconstructionSpec.cxx
@@ -44,6 +44,7 @@ void ReconstructionDPL::init(InitContext& ic)
   LOG(info) << "FT0 param mMinRMS: " << CalibParam::Instance().mMinRMS;
   LOG(info) << "FT0 param mMaxSigma: " << CalibParam::Instance().mMaxSigma;
   LOG(info) << "FT0 param mMaxDiffMean: " << CalibParam::Instance().mMaxDiffMean;
+  LOG(info) << "FT0 dead channel map will be applied " << mUseDeadChannelMap;
 }
 
 void ReconstructionDPL::run(ProcessingContext& pc)
@@ -69,6 +70,12 @@ void ReconstructionDPL::run(ProcessingContext& pc)
     mReco.SetSlewingCalibObject(slewingCalibObject.get());
   }
 
+  if (mUseDeadChannelMap && mUpdateDeadChannelMap) {
+    LOG(debug) << "Applying dead channel map";
+    auto deadChannelMap = pc.inputs().get<o2::fit::DeadChannelMap*>("deadChannelMap");
+    mReco.SetDeadChannelMap(deadChannelMap.get());
+  }
+
   mRecPoints.reserve(digits.size());
   mRecChData.reserve(channels.size());
   mReco.processTF(digits, channels, mRecPoints, mRecChData);
@@ -91,6 +98,11 @@ void ReconstructionDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
     mUseSlewingCalib = false; // upload only once, slewing should be stable during the run
     return;
   }
+  if (matcher == ConcreteDataMatcher("FT0", "DeadChannelMap", 0)) {
+    LOG(debug) << "New DeadChannelMap is uploaded";
+    mUpdateDeadChannelMap = false;
+    return;
+  }
 }
 
 void ReconstructionDPL::endOfStream(EndOfStreamContext& ec)
@@ -99,12 +111,13 @@ void ReconstructionDPL::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getReconstructionSpec(bool useMC, const std::string ccdbpath, bool useTimeOffsetCalib, bool useSlewingCalib)
+DataProcessorSpec getReconstructionSpec(bool useMC, const std::string ccdbpath, bool useTimeOffsetCalib, bool useSlewingCalib, bool useDeadChannelMap)
 {
   std::vector<InputSpec> inputSpec;
   std::vector<OutputSpec> outputSpec;
   inputSpec.emplace_back("digits", o2::header::gDataOriginFT0, "DIGITSBC", 0, Lifetime::Timeframe);
   inputSpec.emplace_back("digch", o2::header::gDataOriginFT0, "DIGITSCH", 0, Lifetime::Timeframe);
+
   if (useMC) {
     LOG(info) << "Currently Reconstruction does not consume and provide MC truth";
     inputSpec.emplace_back("labels", o2::header::gDataOriginFT0, "DIGITSMCTR", 0, Lifetime::Timeframe);
@@ -121,6 +134,11 @@ DataProcessorSpec getReconstructionSpec(bool useMC, const std::string ccdbpath,
                            ccdbParamSpec("FT0/Calib/SlewingCoef"));
   }
 
+  if (useDeadChannelMap) {
+    LOG(info) << "Dead channel map will be applied during reconstruction";
+    inputSpec.emplace_back("deadChannelMap", o2::header::gDataOriginFT0, "DeadChannelMap", 0, Lifetime::Condition, ccdbParamSpec("FT0/Calib/DeadChannelMap"));
+  }
+
   outputSpec.emplace_back(o2::header::gDataOriginFT0, "RECPOINTS", 0, Lifetime::Timeframe);
   outputSpec.emplace_back(o2::header::gDataOriginFT0, "RECCHDATA", 0, Lifetime::Timeframe);
 
@@ -128,7 +146,7 @@ DataProcessorSpec getReconstructionSpec(bool useMC, const std::string ccdbpath,
     "ft0-reconstructor",
     inputSpec,
     outputSpec,
-    AlgorithmSpec{adaptFromTask<ReconstructionDPL>(useMC, ccdbpath, useTimeOffsetCalib, useSlewingCalib)},
+    AlgorithmSpec{adaptFromTask<ReconstructionDPL>(useMC, ccdbpath, useTimeOffsetCalib, useSlewingCalib, useDeadChannelMap)},
     Options{}};
 }
 
diff --git a/Detectors/FIT/FT0/workflow/src/ft0-reco-workflow.cxx b/Detectors/FIT/FT0/workflow/src/ft0-reco-workflow.cxx
index 3e6a6bf5da090..ab39068aedb38 100644
--- a/Detectors/FIT/FT0/workflow/src/ft0-reco-workflow.cxx
+++ b/Detectors/FIT/FT0/workflow/src/ft0-reco-workflow.cxx
@@ -41,7 +41,8 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-root-output", o2::framework::VariantType::Bool, false, {"disable root-files output writers"}},
     {"disable-time-offset-calib", o2::framework::VariantType::Bool, false, {"disable timeoffset calibration"}},
     {"disable-slewing-calib", o2::framework::VariantType::Bool, false, {"disable slewing calibration"}},
-    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    {"disable-dead-channel-map", VariantType::Bool, false, {"disable dead channel map"}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -64,9 +65,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto disableRootOut = configcontext.options().get<bool>("disable-root-output");
   const auto useTimeOffsetCalib = !configcontext.options().get<bool>("disable-time-offset-calib");
   const auto useSlewingCalib = !configcontext.options().get<bool>("disable-slewing-calib");
+  const auto useDeadChannelMap = !configcontext.options().get<bool>("disable-dead-channel-map");
 
   LOG(info) << "WorkflowSpec getRecoWorkflow useMC " << useMC << " CCDB  " << ccdbpath;
-  auto wf = o2::ft0::getRecoWorkflow(useMC, ccdbpath, useTimeOffsetCalib, useSlewingCalib, disableRootInp, disableRootOut);
+  auto wf = o2::ft0::getRecoWorkflow(useMC, ccdbpath, useTimeOffsetCalib, useSlewingCalib, disableRootInp, disableRootOut, useDeadChannelMap);
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, wf);
diff --git a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/BaseRecoTask.h b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/BaseRecoTask.h
index 12d89b82a13cc..c5cb5b0da6d05 100644
--- a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/BaseRecoTask.h
+++ b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/BaseRecoTask.h
@@ -18,6 +18,7 @@
 #include "DataFormatsFV0/ChannelData.h"
 #include "DataFormatsFV0/RecPoints.h"
 #include "DataFormatsFV0/FV0ChannelTimeCalibrationObject.h"
+#include "DataFormatsFIT/DeadChannelMap.h"
 #include <gsl/span>
 
 namespace o2
@@ -33,14 +34,15 @@ class BaseRecoTask
   ~BaseRecoTask() = default;
   o2::fv0::RecPoints process(o2::fv0::Digit const& bcd,
                              gsl::span<const o2::fv0::ChannelData> inChData,
-                             gsl::span<o2::fv0::ChannelDataFloat> outChData);
+                             std::vector<o2::fv0::ChannelDataFloat>& outChData);
   void FinishTask();
   void SetChannelOffset(o2::fv0::FV0ChannelTimeCalibrationObject const* caliboffsets) { mCalibOffset = caliboffsets; };
+  void SetDeadChannelMap(o2::fit::DeadChannelMap const* deadChannelMap) { mDeadChannelMap = deadChannelMap; }
   int getOffset(int channel);
 
  private:
   o2::fv0::FV0ChannelTimeCalibrationObject const* mCalibOffset = nullptr;
-
+  o2::fit::DeadChannelMap const* mDeadChannelMap = nullptr;
   ClassDefNV(BaseRecoTask, 3);
 };
 } // namespace fv0
diff --git a/Detectors/FIT/FV0/reconstruction/src/BaseRecoTask.cxx b/Detectors/FIT/FV0/reconstruction/src/BaseRecoTask.cxx
index 8a217232592df..8032220f8996d 100644
--- a/Detectors/FIT/FV0/reconstruction/src/BaseRecoTask.cxx
+++ b/Detectors/FIT/FV0/reconstruction/src/BaseRecoTask.cxx
@@ -27,7 +27,7 @@ using RP = o2::fv0::RecPoints;
 
 RP BaseRecoTask::process(o2::fv0::Digit const& bcd,
                          gsl::span<const o2::fv0::ChannelData> inChData,
-                         gsl::span<o2::fv0::ChannelDataFloat> outChData)
+                         std::vector<o2::fv0::ChannelDataFloat>& outChData)
 {
   LOG(debug) << "Running reconstruction on new event";
 
@@ -44,22 +44,27 @@ RP BaseRecoTask::process(o2::fv0::Digit const& bcd,
   int nch = inChData.size();
   for (int ich = 0; ich < nch; ich++) {
     LOG(debug) << "  channel " << ich << " / " << nch;
+    if (mDeadChannelMap && !mDeadChannelMap->isChannelAlive(inChData[ich].ChId)) {
+      LOG(debug) << "Channel " << ich << " is dead - discarding data";
+      continue;
+    }
     int offsetChannel = getOffset(int(inChData[ich].ChId));
-    outChData[ich] = o2::fv0::ChannelDataFloat{inChData[ich].ChId,
-                                               (inChData[ich].CFDTime - offsetChannel) * DigitizationConstant::TIME_PER_TDCCHANNEL,
-                                               (float)inChData[ich].QTCAmpl,
-                                               inChData[ich].ChainQTC};
+    outChData.emplace_back(o2::fv0::ChannelDataFloat{inChData[ich].ChId,
+                                                     (inChData[ich].CFDTime - offsetChannel) * DigitizationConstant::TIME_PER_TDCCHANNEL,
+                                                     (float)inChData[ich].QTCAmpl,
+                                                     inChData[ich].ChainQTC});
+    const auto& currentOutCh = outChData.back();
 
     // Conditions for reconstructing collision time (3 variants: first, average-relaxed and average-tight)
-    if (outChData[ich].charge > FV0DigParam::Instance().chargeThrForMeanTime) {
-      sideAtimeFirst = std::min(static_cast<Double_t>(sideAtimeFirst), outChData[ich].time);
+    if (currentOutCh.charge > FV0DigParam::Instance().chargeThrForMeanTime) {
+      sideAtimeFirst = std::min(static_cast<Double_t>(sideAtimeFirst), currentOutCh.time);
       if (inChData[ich].areAllFlagsGood()) {
-        if (std::abs(outChData[ich].time) < FV0DigParam::Instance().mTimeThresholdForReco) {
-          sideAtimeAvg += outChData[ich].time;
+        if (std::abs(currentOutCh.time) < FV0DigParam::Instance().mTimeThresholdForReco) {
+          sideAtimeAvg += currentOutCh.time;
           ndigitsA++;
         }
-        if (outChData[ich].charge > FV0DigParam::Instance().mAmpThresholdForReco && std::abs(outChData[ich].time) < FV0DigParam::Instance().mTimeThresholdForReco) {
-          sideAtimeAvgSelected += outChData[ich].time;
+        if (currentOutCh.charge > FV0DigParam::Instance().mAmpThresholdForReco && std::abs(currentOutCh.time) < FV0DigParam::Instance().mTimeThresholdForReco) {
+          sideAtimeAvgSelected += currentOutCh.time;
           ndigitsASelected++;
         }
       }
diff --git a/Detectors/FIT/FV0/workflow/include/FV0Workflow/RecoWorkflow.h b/Detectors/FIT/FV0/workflow/include/FV0Workflow/RecoWorkflow.h
index 015870d9178e2..f035b2406e5ba 100644
--- a/Detectors/FIT/FV0/workflow/include/FV0Workflow/RecoWorkflow.h
+++ b/Detectors/FIT/FV0/workflow/include/FV0Workflow/RecoWorkflow.h
@@ -20,7 +20,7 @@ namespace o2
 {
 namespace fv0
 {
-framework::WorkflowSpec getRecoWorkflow(bool useMC, bool disableRootInp, bool disableRootOut);
+framework::WorkflowSpec getRecoWorkflow(bool useMC, bool disableRootInp, bool disableRootOut, bool useDeadChannelMap);
 } // namespace fv0
 } // namespace o2
 #endif
diff --git a/Detectors/FIT/FV0/workflow/include/FV0Workflow/ReconstructionSpec.h b/Detectors/FIT/FV0/workflow/include/FV0Workflow/ReconstructionSpec.h
index d71e154280e3d..934ce4d2c4a66 100644
--- a/Detectors/FIT/FV0/workflow/include/FV0Workflow/ReconstructionSpec.h
+++ b/Detectors/FIT/FV0/workflow/include/FV0Workflow/ReconstructionSpec.h
@@ -34,7 +34,7 @@ class ReconstructionDPL : public Task
   static constexpr int NCHANNELS = o2::fv0::Constants::nFv0Channels;
 
  public:
-  ReconstructionDPL(bool useMC, const std::string ccdbpath) : mUseMC(useMC), mCCDBpath(ccdbpath) {}
+  ReconstructionDPL(bool useMC, bool useDeadChannelMap, const std::string ccdbpath) : mUseMC(useMC), mUseDeadChannelMap(useDeadChannelMap), mCCDBpath(ccdbpath) {}
   ~ReconstructionDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -44,6 +44,8 @@ class ReconstructionDPL : public Task
  private:
   bool mUseMC = false;
   bool mUpdateCCDB = true;
+  bool mUseDeadChannelMap = true;
+  bool mUpdateDeadChannelMap = true;
   const std::string mCCDBpath = o2::base::NameConf::getCCDBServer();
   std::vector<o2::fv0::RecPoints> mRecPoints;
   std::vector<o2::fv0::ChannelDataFloat> mRecChData;
@@ -53,7 +55,7 @@ class ReconstructionDPL : public Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getReconstructionSpec(bool useMC = false, const std::string ccdbpath = "http://alice-ccdb.cern.ch");
+framework::DataProcessorSpec getReconstructionSpec(bool useMC = false, bool useDeadChannelMap = true, const std::string ccdbpath = "http://alice-ccdb.cern.ch");
 
 } // namespace fv0
 } // namespace o2
diff --git a/Detectors/FIT/FV0/workflow/src/RecoWorkflow.cxx b/Detectors/FIT/FV0/workflow/src/RecoWorkflow.cxx
index 6bfc5479303d1..a0ef71b75765a 100644
--- a/Detectors/FIT/FV0/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/FIT/FV0/workflow/src/RecoWorkflow.cxx
@@ -22,14 +22,13 @@ namespace o2
 namespace fv0
 {
 
-framework::WorkflowSpec getRecoWorkflow(bool useMC, bool disableRootInp, bool disableRootOut)
+framework::WorkflowSpec getRecoWorkflow(bool useMC, bool disableRootInp, bool disableRootOut, bool useDeadChannelMap)
 {
   framework::WorkflowSpec specs;
   if (!disableRootInp) {
     specs.emplace_back(o2::fv0::getDigitReaderSpec(useMC));
   }
-
-  specs.emplace_back(o2::fv0::getReconstructionSpec(useMC));
+  specs.emplace_back(o2::fv0::getReconstructionSpec(useMC, useDeadChannelMap));
   if (!disableRootOut) {
     specs.emplace_back(o2::fv0::getRecPointWriterSpec(useMC));
   }
diff --git a/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx b/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx
index 520ac4dbaa563..b97186bbf81a8 100644
--- a/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx
+++ b/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx
@@ -21,6 +21,7 @@
 #include "DataFormatsFV0/ChannelData.h"
 #include "DataFormatsFV0/MCLabel.h"
 #include "DataFormatsFV0/FV0ChannelTimeCalibrationObject.h"
+#include "DataFormatsFIT/DeadChannelMap.h"
 #include "Framework/CCDBParamSpec.h"
 
 using namespace o2::framework;
@@ -53,18 +54,19 @@ void ReconstructionDPL::run(ProcessingContext& pc)
     auto caliboffsets = pc.inputs().get<o2::fv0::FV0ChannelTimeCalibrationObject*>("fv0offsets");
     mReco.SetChannelOffset(caliboffsets.get());
   }
+  if (mUseDeadChannelMap && mUpdateDeadChannelMap) {
+    auto deadChannelMap = pc.inputs().get<o2::fit::DeadChannelMap*>("deadChannelMap");
+    mReco.SetDeadChannelMap(deadChannelMap.get());
+  }
 
   int nDig = digits.size();
   LOG(debug) << " nDig " << nDig << " | ndigch " << digch.size();
   mRecPoints.reserve(nDig);
-  mRecChData.resize(digch.size());
   for (int id = 0; id < nDig; id++) {
     const auto& digit = digits[id];
     LOG(debug) << " ndig " << id << " bc " << digit.getBC() << " orbit " << digit.getOrbit();
     auto channels = digit.getBunchChannelData(digch);
-    gsl::span<o2::fv0::ChannelDataFloat> out_ch(mRecChData);
-    out_ch = out_ch.subspan(digit.ref.getFirstEntry(), digit.ref.getEntries());
-    mRecPoints.emplace_back(mReco.process(digit, channels, out_ch));
+    mRecPoints.emplace_back(mReco.process(digit, channels, mRecChData));
   }
 
   LOG(debug) << "FV0 reconstruction pushes " << mRecPoints.size() << " RecPoints";
@@ -80,6 +82,9 @@ void ReconstructionDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
     mUpdateCCDB = false;
     return;
   }
+  if (matcher == ConcreteDataMatcher(o2::header::gDataOriginFV0, "DeadChannelMap", 0)) {
+    mUpdateDeadChannelMap = false;
+  }
 }
 
 void ReconstructionDPL::endOfStream(EndOfStreamContext& ec)
@@ -88,7 +93,7 @@ void ReconstructionDPL::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getReconstructionSpec(bool useMC, const std::string ccdbpath)
+DataProcessorSpec getReconstructionSpec(bool useMC, bool useDeadChannelMap, const std::string ccdbpath)
 {
   std::vector<InputSpec> inputSpec;
   std::vector<OutputSpec> outputSpec;
@@ -98,6 +103,10 @@ DataProcessorSpec getReconstructionSpec(bool useMC, const std::string ccdbpath)
     LOG(info) << "Currently Reconstruction does not consume and provide MC truth";
     inputSpec.emplace_back("labels", o2::header::gDataOriginFV0, "DIGITSMCTR", 0, Lifetime::Timeframe);
   }
+  if (useDeadChannelMap) {
+    LOG(info) << "Dead channel map will be applied during reconstruction";
+    inputSpec.emplace_back("deadChannelMap", o2::header::gDataOriginFV0, "DeadChannelMap", 0, Lifetime::Condition, ccdbParamSpec("FV0/Calib/DeadChannelMap"));
+  }
   inputSpec.emplace_back("fv0offsets", "FV0", "TimeOffset", 0,
                          Lifetime::Condition,
                          ccdbParamSpec("FV0/Calib/ChannelTimeOffset"));
@@ -109,7 +118,7 @@ DataProcessorSpec getReconstructionSpec(bool useMC, const std::string ccdbpath)
     "fv0-reconstructor",
     inputSpec,
     outputSpec,
-    AlgorithmSpec{adaptFromTask<ReconstructionDPL>(useMC, ccdbpath)},
+    AlgorithmSpec{adaptFromTask<ReconstructionDPL>(useMC, useDeadChannelMap, ccdbpath)},
     Options{}};
 }
 
diff --git a/Detectors/FIT/FV0/workflow/src/fv0-reco-workflow.cxx b/Detectors/FIT/FV0/workflow/src/fv0-reco-workflow.cxx
index 16d1383c7e8c4..309560e2d6b36 100644
--- a/Detectors/FIT/FV0/workflow/src/fv0-reco-workflow.cxx
+++ b/Detectors/FIT/FV0/workflow/src/fv0-reco-workflow.cxx
@@ -39,6 +39,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}},
     {"disable-root-input", o2::framework::VariantType::Bool, false, {"disable root-files input readers"}},
     {"disable-root-output", o2::framework::VariantType::Bool, false, {"disable root-files output writers"}},
+    {"disable-dead-channel-map", o2::framework::VariantType::Bool, false, {"disable dead channel map"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
@@ -59,9 +60,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   auto disableRootInp = configcontext.options().get<bool>("disable-root-input");
   auto disableRootOut = configcontext.options().get<bool>("disable-root-output");
+  bool useDeadChannelMap = !configcontext.options().get<bool>("disable-dead-channel-map");
 
   LOG(info) << "WorkflowSpec getRecoWorkflow useMC " << useMC;
-  auto wf = o2::fv0::getRecoWorkflow(useMC, disableRootInp, disableRootOut);
+  auto wf = o2::fv0::getRecoWorkflow(useMC, disableRootInp, disableRootOut, useDeadChannelMap);
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, wf);

From 3e6876861dffa4a73c9c7fd8c858d6f7cb3f9554 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Mon, 16 Feb 2026 16:03:27 +0100
Subject: [PATCH 1329/1764] First version of the hit based CA tracker for
 ALICE3 IT/OT (#15066)

* ITSTracking: change visibility of methods

Change TimeFrame prepareClusters method visibility to protected
Add computeTracksMClabels method to Tracker class

* Hit based CA for ALICE3 tracker
---
 .../tracking/include/ITStracking/TimeFrame.h  |   2 +-
 .../tracking/include/ITStracking/Tracker.h    |   2 +-
 Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt  |   3 +-
 .../ALICE3/TRK/macros/test/CMakeLists.txt     |  10 +
 .../ALICE3/TRK/macros/test/CheckTracksCA.C    | 345 ++++++++++++++++++
 .../ALICE3/TRK/reconstruction/CMakeLists.txt  |  34 ++
 .../include/TRKReconstruction/TimeFrame.h     |  73 ++++
 .../src/TRKReconstructionLinkDef.h            |  20 +
 .../TRK/reconstruction/src/TimeFrame.cxx      | 189 ++++++++++
 .../ALICE3/TRK/workflow/CMakeLists.txt        |  10 +-
 .../Upgrades/ALICE3/TRK/workflow/README.md    | 130 +++++++
 .../include/TRKWorkflow/RecoWorkflow.h        |   2 +
 .../include/TRKWorkflow/TrackWriterSpec.h     |  31 ++
 .../include/TRKWorkflow/TrackerSpec.h         |  12 +-
 .../ALICE3/TRK/workflow/src/RecoWorkflow.cxx  |  11 +-
 .../TRK/workflow/src/TrackWriterSpec.cxx      |  57 +++
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   | 336 ++++++++++++++++-
 .../TRK/workflow/src/trk-reco-workflow.cxx    |   4 +-
 18 files changed, 1251 insertions(+), 20 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/macros/test/CheckTracksCA.C
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/README.md
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackWriterSpec.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackWriterSpec.cxx

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 4dbb9f09f6192..acc884ea68b8b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -299,7 +299,7 @@ struct TimeFrame {
   virtual bool isGPU() const noexcept { return false; }
   virtual const char* getName() const noexcept { return "CPU"; }
 
- private:
+ protected:
   void prepareClusters(const TrackingParameters& trkParam, const int maxLayers = nLayers);
   float mBz = 5.;
   unsigned int mNTotalLowPtVertices = 0;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 4c903ed1f3ca1..3ea382c626fed 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -72,6 +72,7 @@ class Tracker
   bool isMatLUT() const { return mTraits->isMatLUT(); }
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena) { mTraits->setNThreads(n, arena); }
   void printSummary() const;
+  void computeTracksMClabels();
 
  private:
   void initialiseTimeFrame(int iteration) { mTraits->initialiseTimeFrame(iteration); }
@@ -84,7 +85,6 @@ class Tracker
 
   // MC interaction
   void computeRoadsMClabels();
-  void computeTracksMClabels();
   void rectifyClusterIndices();
 
   template <typename... T, typename... F>
diff --git a/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
index e623239122658..6e3437c9d841b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
@@ -12,4 +12,5 @@
 add_subdirectory(base)
 add_subdirectory(macros)
 add_subdirectory(simulation)
-add_subdirectory(workflow)
\ No newline at end of file
+add_subdirectory(reconstruction)
+add_subdirectory(workflow)
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
index 379207eb07481..d9908bbfeb1e5 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
@@ -18,4 +18,14 @@ o2_add_test_root_macro(CheckDigits.C
                                              O2::SimulationDataFormat
                                              O2::DetectorsBase
                                              O2::Steer
+                       LABELS trk COMPILE_ONLY)
+
+o2_add_test_root_macro(CheckTracksCA.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsITS
+                                             O2::ITStracking
+                                             O2::SimulationDataFormat
+                                             O2::DetectorsBase
+                                             O2::TRKBase
+                                             O2::TRKSimulation
+                                             O2::Steer
                        LABELS trk COMPILE_ONLY)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckTracksCA.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckTracksCA.C
new file mode 100644
index 0000000000000..ae75616b7719c
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckTracksCA.C
@@ -0,0 +1,345 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CheckTracksCA.C
+/// \brief Quality assurance macro for TRK tracking
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <array>
+#include <cmath>
+#include <iostream>
+#include <unordered_map>
+#include <vector>
+
+#include <TFile.h>
+#include <TTree.h>
+#include <TH1D.h>
+#include <TCanvas.h>
+#include <THStack.h>
+#include <TLegend.h>
+#include <TLatex.h>
+#include <TStyle.h>
+
+#include "DataFormatsITS/TrackITS.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTrack.h"
+#include "Steer/MCKinematicsReader.h"
+#include "TRKSimulation/Hit.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "DetectorsBase/GeometryManager.h"
+
+#endif
+
+using namespace std;
+using namespace o2;
+
+/// Structure to track particle hit information
+struct ParticleHitInfo {
+  std::bitset<11> layerHits; ///< Which layers have hits (11 layers for TRK)
+  int nHits = 0;             ///< Total number of hits
+  float pt = 0.0f;           ///< Particle pT
+
+  void addHit(int layer)
+  {
+    if (!layerHits[layer]) {
+      layerHits[layer] = true;
+      nHits++;
+    }
+  }
+
+  bool hasConsecutiveLayers(int nConsecutive) const
+  {
+    for (int startLayer = 0; startLayer <= 11 - nConsecutive; ++startLayer) {
+      bool allSet = true;
+      for (int i = 0; i < nConsecutive; ++i) {
+        if (!layerHits[startLayer + i]) {
+          allSet = false;
+          break;
+        }
+      }
+      if (allSet) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+void CheckTracksCA(std::string tracfile = "o2trac_trk.root",
+                   std::string kinefile = "o2sim_Kine.root",
+                   std::string hitsfile = "o2sim_HitsTRK.root",
+                   std::string outputfile = "trk_qa_output.root")
+{
+  gStyle->SetOptStat(0);
+
+  std::cout << "=== Starting TRK Track Quality Assurance ===" << std::endl;
+  std::cout << "Input files:" << std::endl;
+  std::cout << "  Tracks:      " << tracfile << std::endl;
+  std::cout << "  Kinematics:  " << kinefile << std::endl;
+  std::cout << "  Hits:        " << hitsfile << std::endl;
+  std::cout << "  Output:      " << outputfile << std::endl;
+  std::cout << std::endl;
+
+  // MC kinematics reader
+  o2::steer::MCKinematicsReader kineReader("o2sim", o2::steer::MCKinematicsReader::Mode::kMCKine);
+  const int nEvents = kineReader.getNEvents(0);
+  std::cout << "Number of MC events: " << nEvents << std::endl;
+
+  // Open hits file to count hits per particle per layer
+  TFile* hitsFile = TFile::Open(hitsfile.c_str(), "READ");
+  if (!hitsFile || hitsFile->IsZombie()) {
+    std::cerr << "ERROR: Cannot open hits file: " << hitsfile << std::endl;
+    return;
+  }
+  TTree* hitsTree = hitsFile->Get<TTree>("o2sim");
+  if (!hitsTree) {
+    std::cerr << "ERROR: Cannot find o2sim tree in hits file" << std::endl;
+    return;
+  }
+
+  // Open reconstructed tracks file
+  TFile* tracFile = TFile::Open(tracfile.c_str(), "READ");
+  if (!tracFile || tracFile->IsZombie()) {
+    std::cerr << "ERROR: Cannot open tracks file: " << tracfile << std::endl;
+    return;
+  }
+  TTree* recTree = tracFile->Get<TTree>("o2sim");
+  if (!recTree) {
+    std::cerr << "ERROR: Cannot find o2sim tree in tracks file" << std::endl;
+    return;
+  }
+
+  // Reconstructed tracks and labels
+  std::vector<o2::its::TrackITS>* recTracks = nullptr;
+  std::vector<o2::MCCompLabel>* trkLabels = nullptr;
+  recTree->SetBranchAddress("TRKTrack", &recTracks);
+  recTree->SetBranchAddress("TRKTrackMCTruth", &trkLabels);
+
+  std::cout << "Reading tracks from tree..." << std::endl;
+
+  // Analyze hits tree to count hits per particle per layer
+  std::cout << "Analyzing hits from tree..." << std::endl;
+  std::unordered_map<o2::MCCompLabel, ParticleHitInfo> particleHitMap;
+
+  // Load geometry for layer determination
+  o2::base::GeometryManager::loadGeometry();
+  auto* gman = o2::trk::GeometryTGeo::Instance();
+
+  // Array to map detector to starting layer
+  constexpr std::array<int, 2> startLayer{0, 3};
+
+  std::vector<o2::trk::Hit>* trkHit = nullptr;
+  hitsTree->SetBranchAddress("TRKHit", &trkHit);
+
+  Long64_t nHitsEntries = hitsTree->GetEntries();
+  std::cout << "Processing " << nHitsEntries << " hit entries..." << std::endl;
+
+  for (Long64_t iEntry = 0; iEntry < nHitsEntries; ++iEntry) {
+    hitsTree->GetEntry(iEntry);
+
+    for (const auto& hit : *trkHit) {
+      // Skip disk hits (only barrel)
+      if (gman->getDisk(hit.GetDetectorID()) != -1) {
+        continue;
+      }
+
+      // Determine layer
+      int subDetID = gman->getSubDetID(hit.GetDetectorID());
+      const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
+
+      // Create label for this particle
+      o2::MCCompLabel label(hit.GetTrackID(), static_cast<int>(iEntry), 0);
+
+      // Add hit to particle's hit map
+      particleHitMap[label].addHit(layer);
+    }
+  }
+
+  std::cout << "Found " << particleHitMap.size() << " unique particles with hits" << std::endl;
+
+  // Store particle info and fill generated histograms
+  std::unordered_map<o2::MCCompLabel, float> particlePtMap;
+
+  // Create histograms
+  constexpr int nLayers = 11;
+  constexpr int nb = 100;
+  double xbins[nb + 1], ptcutl = 0.05, ptcuth = 10.;
+  double a = std::log(ptcuth / ptcutl) / nb;
+  for (int i = 0; i <= nb; i++)
+    xbins[i] = ptcutl * std::exp(i * a);
+
+  TH1D genParticlePtHist("genParticlePt", "Generated Particle p_{T} (All Layers); #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+  TH1D genParticlePt7LayersHist("genParticlePt7Layers", "Generated Particle p_{T} with hits in at least 7 consecutive layers; #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+  TH1D goodTracks("goodTracks", "Good Tracks; p_{T} (GeV/c); Counts", nb, xbins);
+  TH1D fakeTracks("fakeTracks", "Fake Tracks; p_{T} (GeV/c); Counts", nb, xbins);
+
+  std::array<TH1D, 5> goodTracksMatching, fakeTracksMatching;
+  for (int i = 0; i < 5; ++i) {
+    goodTracksMatching[i] = TH1D(Form("goodTracksMatching_%dLayers", i + 7),
+                                 Form("Good Tracks with %d layer hits; p_{T} (GeV/c); Counts", i + 7),
+                                 nb, xbins);
+    fakeTracksMatching[i] = TH1D(Form("fakeTracksMatching_%dLayers", i + 7),
+                                 Form("Fake Tracks with %d layer hits; p_{T} (GeV/c); Counts", i + 7),
+                                 nb, xbins);
+  }
+
+  TH1D numberOfClustersPerTrack("numberOfClustersPerTrack",
+                                "Number of clusters per track; N_{clusters}; Counts",
+                                12, -0.5, 11.5);
+
+  // First pass: identify particles with full hit coverage from kinematics
+  std::cout << "Analyzing MC particles..." << std::endl;
+  for (int iEvent = 0; iEvent < nEvents; ++iEvent) {
+    const auto& mcTracks = kineReader.getTracks(iEvent);
+    for (size_t iTrack = 0; iTrack < mcTracks.size(); ++iTrack) {
+      const auto& mcTrack = mcTracks[iTrack];
+      if (!mcTrack.isPrimary()) {
+        continue;
+      }
+
+      // Create label for this particle
+      o2::MCCompLabel label(iTrack, iEvent, 0);
+      float pt = mcTrack.GetPt();
+
+      // Store particle info
+      particlePtMap[label] = pt;
+
+      // Check if this particle has hits
+      auto hitIt = particleHitMap.find(label);
+      if (hitIt != particleHitMap.end()) {
+        // Store pT in hit info
+        hitIt->second.pt = pt;
+
+        // Fill histogram for particles with hits in all 11 layers
+        if (hitIt->second.nHits == 11) {
+          genParticlePtHist.Fill(pt);
+        }
+
+        // Fill histogram for particles with at least 7 consecutive layer hits
+        if (hitIt->second.hasConsecutiveLayers(7)) {
+          genParticlePt7LayersHist.Fill(pt);
+        }
+      }
+    }
+  }
+
+  std::cout << "Generated particles with 11 hits: " << genParticlePtHist.GetEntries() << std::endl;
+  std::cout << "Generated particles with 7+ consecutive hits: " << genParticlePt7LayersHist.GetEntries() << std::endl;
+
+  // Second pass: analyze reconstructed tracks
+  std::cout << "Analyzing reconstructed tracks..." << std::endl;
+  int nROFs = recTree->GetEntries();
+  int totalTracks = 0;
+  int goodTracksCount = 0;
+  int fakeTracksCount = 0;
+
+  for (int iROF = 0; iROF < nROFs; ++iROF) {
+    recTree->GetEntry(iROF);
+
+    if (!recTracks || !trkLabels) {
+      continue;
+    }
+
+    totalTracks += recTracks->size();
+
+    for (size_t iTrack = 0; iTrack < recTracks->size(); ++iTrack) {
+      const auto& track = recTracks->at(iTrack);
+      const auto& label = trkLabels->at(iTrack);
+
+      if (!label.isSet() || !label.isValid()) {
+        continue;
+      }
+
+      int eventID = label.getEventID();
+      int trackID = label.getTrackID();
+      int nClusters = track.getNumberOfClusters();
+
+      // Get MC track info
+      if (eventID < 0 || eventID >= nEvents) {
+        continue;
+      }
+
+      const auto& mcTracks = kineReader.getTracks(eventID);
+      if (trackID < 0 || trackID >= (int)mcTracks.size()) {
+        continue;
+      }
+
+      float pt = mcTracks[trackID].GetPt();
+
+      // Fill histograms
+      numberOfClustersPerTrack.Fill(nClusters);
+
+      auto key = o2::MCCompLabel(trackID, eventID, 0);
+      if (particleHitMap.find(key) != particleHitMap.end() && particleHitMap[key].hasConsecutiveLayers(11)) {
+        if (label.isFake()) {
+          fakeTracks.Fill(pt);
+          fakeTracksCount++;
+          if (nClusters >= 7 && nClusters <= 11) {
+            fakeTracksMatching[nClusters - 7].Fill(pt);
+          }
+        } else {
+          goodTracks.Fill(pt);
+          goodTracksCount++;
+          if (nClusters >= 7 && nClusters <= 11) {
+            goodTracksMatching[nClusters - 7].Fill(pt);
+          }
+        }
+      }
+    }
+  }
+
+  // Create efficiency histograms
+  std::cout << "Computing efficiencies..." << std::endl;
+
+  std::array<TH1D, 5> efficiencyHistograms;
+  THStack* efficiencyStack = new THStack("efficiencyStack",
+                                         "Tracking Efficiency; #it{p}_{T} (GeV/#it{c}); Efficiency");
+
+  int colors[5] = {kRed, kBlue, kGreen + 2, kMagenta, kOrange};
+  for (int i = 0; i < 5; ++i) {
+    int nClusters = i + 7;
+    efficiencyHistograms[i] = TH1D(Form("efficiency_%dClusters", nClusters),
+                                   Form("Efficiency for %d cluster tracks; #it{p}_{T} (GeV/#it{c}); Efficiency", nClusters),
+                                   nb, xbins);
+
+    efficiencyHistograms[i].Divide(&goodTracksMatching[i], &genParticlePtHist, 1, 1, "B");
+
+    efficiencyHistograms[i].SetLineColor(colors[i]);
+    efficiencyHistograms[i].SetFillColor(colors[i]);
+    efficiencyHistograms[i].SetLineWidth(2);
+    efficiencyHistograms[i].SetMarkerColor(colors[i]);
+    efficiencyHistograms[i].SetMarkerStyle(20 + i);
+    efficiencyStack->Add(&efficiencyHistograms[i]);
+  }
+
+  // Write output
+  std::cout << "Writing output to " << outputfile << std::endl;
+  TFile outFile(outputfile.c_str(), "RECREATE");
+  genParticlePtHist.Write();
+  goodTracks.Write();
+  fakeTracks.Write();
+  for (int i = 0; i < 5; ++i) {
+    goodTracksMatching[i].Write();
+    fakeTracksMatching[i].Write();
+    efficiencyHistograms[i].Write();
+  }
+  efficiencyStack->Write();
+  genParticlePt7LayersHist.Write();
+  numberOfClustersPerTrack.Write();
+  outFile.Close();
+
+  // Clean up
+  hitsFile->Close();
+  tracFile->Close();
+  delete efficiencyStack;
+  delete hitsFile;
+  delete tracFile;
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
new file mode 100644
index 0000000000000..01ddc783d192b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
@@ -0,0 +1,34 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(TRKReconstruction
+               TARGETVARNAME targetName
+               SOURCES src/TimeFrame.cxx
+               PUBLIC_LINK_LIBRARIES
+                       O2::ITStracking
+                       O2::GPUCommon
+                       Microsoft.GSL::GSL
+                       O2::CommonConstants
+                       O2::DataFormatsITSMFT
+                       O2::SimulationDataFormat
+                       O2::ITSBase
+                       O2::ITSReconstruction
+                       O2::ITSMFTReconstruction
+                       O2::DataFormatsITS
+                       O2::TRKSimulation
+                       nlohmann_json::nlohmann_json
+               PRIVATE_LINK_LIBRARIES
+                       O2::Steer
+                       TBB::tbb)
+
+o2_target_root_dictionary(TRKReconstruction
+                          HEADERS include/TRKReconstruction/TimeFrame.h
+                          LINKDEF src/TRKReconstructionLinkDef.h)
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
new file mode 100644
index 0000000000000..d2ca6fba132e1
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
@@ -0,0 +1,73 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file TimeFrame.h
+/// \brief TRK TimeFrame class derived from ITS TimeFrame
+///
+
+#ifndef ALICEO2_TRK_TIMEFRAME_H
+#define ALICEO2_TRK_TIMEFRAME_H
+
+#include "ITStracking/TimeFrame.h"
+#include "ITStracking/Constants.h"
+#include "ITStracking/Configuration.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include <vector>
+#include <unordered_map>
+#include <bitset>
+#include <cstdint>
+
+#include <nlohmann/json.hpp>
+
+class TTree;
+
+namespace o2
+{
+namespace trk
+{
+class Hit;
+class GeometryTGeo;
+
+/// TRK TimeFrame class that extends ITS TimeFrame functionality
+/// This allows for customization of tracking algorithms specific to the TRK detector
+template <int nLayers = 11>
+class TimeFrame : public o2::its::TimeFrame<nLayers>
+{
+ public:
+  TimeFrame() = default;
+  ~TimeFrame() override = default;
+
+  /// Override methods if needed for TRK-specific behavior
+  /// For now, we inherit all functionality from ITS TimeFrame
+
+  /// Process hits from TTree to initialize ROFs
+  /// \param hitsTree Tree containing TRK hits
+  /// \param mcHeaderTree Tree containing MC event headers
+  /// \param nEvents Number of events to process
+  /// \param gman TRK geometry manager instance
+  /// \param config Configuration parameters for hit reconstruction
+  int loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config);
+
+  /// Add primary vertices from MC headers for each ROF
+  /// \param mcHeaderTree Tree containing MC event headers
+  /// \param nRofs Number of ROFs (Read-Out Frames)
+  /// \param nEvents Number of events to process
+  /// \param inROFpileup Number of events per ROF
+  void getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup);
+
+ private:
+  ClassDefNV(TimeFrame, 1);
+};
+
+} // namespace trk
+} // namespace o2
+
+#endif // ALICEO2_TRK_TIMEFRAME_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
new file mode 100644
index 0000000000000..09ab598ec626c
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
@@ -0,0 +1,20 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::trk::TimeFrame < 11> + ;
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
new file mode 100644
index 0000000000000..686270826049b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
@@ -0,0 +1,189 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file TimeFrame.cxx
+/// \brief TRK TimeFrame implementation
+///
+
+#include "TRKReconstruction/TimeFrame.h"
+#include "TRKSimulation/Hit.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "Framework/Logger.h"
+#include "SimulationDataFormat/MCEventHeader.h"
+#include <TTree.h>
+#include <TRandom3.h>
+#include <vector>
+#include <array>
+
+namespace o2::trk
+{
+
+template <int nLayers>
+int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config)
+{
+  constexpr std::array<int, 2> startLayer{0, 3};
+  const Long64_t nEvents = hitsTree->GetEntries();
+
+  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L) | o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+
+  std::vector<o2::trk::Hit>* trkHit = nullptr;
+  hitsTree->SetBranchAddress("TRKHit", &trkHit);
+
+  const int inROFpileup{config.contains("inROFpileup") ? config["inROFpileup"].get<int>() : 1};
+
+  // Calculate number of ROFs and initialize data structures
+  this->mNrof = (nEvents + inROFpileup - 1) / inROFpileup;
+
+  // Reset and prepare ROF data structures
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    this->mMinR[iLayer] = std::numeric_limits<float>::max();
+    this->mMaxR[iLayer] = std::numeric_limits<float>::lowest();
+    this->mROFramesClusters[iLayer].clear();
+    this->mROFramesClusters[iLayer].resize(this->mNrof + 1, 0);
+    this->mUnsortedClusters[iLayer].clear();
+    this->mTrackingFrameInfo[iLayer].clear();
+    this->mClusterExternalIndices[iLayer].clear();
+  }
+
+  // Pre-count hits to reserve memory efficiently
+  int totalNHits{0};
+  std::array<int, nLayers> clusterCountPerLayer{};
+  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
+    hitsTree->GetEntry(iEvent);
+    for (const auto& hit : *trkHit) {
+      if (gman->getDisk(hit.GetDetectorID()) != -1) {
+        continue; // skip non-barrel hits
+      }
+      int subDetID = gman->getSubDetID(hit.GetDetectorID());
+      const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
+      ++clusterCountPerLayer[layer];
+      totalNHits++;
+    }
+    trkHit->clear();
+  }
+
+  // Reserve memory for all layers
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    this->mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    this->mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    this->mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
+  }
+  clearResizeBoundedVector(this->mClusterSize, totalNHits, this->mMemoryPool.get());
+
+  std::array<float, 11> resolution{0.001, 0.001, 0.001, 0.001, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004};
+  if (config["geometry"]["pitch"].size() == nLayers) {
+    for (int iLayer{0}; iLayer < config["geometry"]["pitch"].size(); ++iLayer) {
+      LOGP(info, "Setting resolution for layer {} from config", iLayer);
+      LOGP(info, "Layer {} pitch {} cm", iLayer, config["geometry"]["pitch"][iLayer].get<float>());
+      resolution[iLayer] = config["geometry"]["pitch"][iLayer].get<float>() / std::sqrt(12.f);
+    }
+  }
+  LOGP(info, "Number of active parts in VD: {}", gman->getNumberOfActivePartsVD());
+
+  int hitCounter{0};
+  auto labels = new dataformats::MCTruthContainer<MCCompLabel>();
+
+  int iRof{0}; // Current ROF index
+  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
+    hitsTree->GetEntry(iEvent);
+
+    for (auto& hit : *trkHit) {
+      if (gman->getDisk(hit.GetDetectorID()) != -1) {
+        continue; // skip non-barrel hits for this test
+      }
+      int subDetID = gman->getSubDetID(hit.GetDetectorID());
+      const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
+
+      float alpha{0.f};
+      o2::math_utils::Point3D<float> gloXYZ;
+      o2::math_utils::Point3D<float> trkXYZ;
+      float r{0.f};
+      if (layer >= 3) {
+        int chipID = hit.GetDetectorID();
+        alpha = gman->getSensorRefAlphaMLOT(chipID);
+        const o2::math_utils::Transform3D& l2g = gman->getMatrixL2G(chipID);
+        auto locXYZ = l2g ^ (hit.GetPos());
+        locXYZ.SetX(locXYZ.X() + gRandom->Gaus(0.0, resolution[layer]));
+        locXYZ.SetZ(locXYZ.Z() + gRandom->Gaus(0.0, resolution[layer]));
+        gloXYZ = gman->getMatrixL2G(chipID) * locXYZ;
+        trkXYZ = gman->getMatrixT2L(chipID - gman->getNumberOfActivePartsVD()) ^ locXYZ;
+        r = std::hypot(gloXYZ.X(), gloXYZ.Y());
+      } else {
+        const auto& hitPos = hit.GetPos();
+        r = std::hypot(hitPos.X(), hitPos.Y());
+        alpha = std::atan2(hitPos.Y(), hitPos.X()) + gRandom->Gaus(0.0, resolution[layer] / r);
+        o2::math_utils::bringTo02Pi(alpha);
+        gloXYZ.SetX(r * std::cos(alpha));
+        gloXYZ.SetY(r * std::sin(alpha));
+        gloXYZ.SetZ(hitPos.Z() + gRandom->Gaus(0.0, resolution[layer]));
+        trkXYZ.SetX(r);
+        trkXYZ.SetY(0.f);
+        trkXYZ.SetZ(gloXYZ.Z());
+      }
+      this->mMinR[layer] = std::min(this->mMinR[layer], r);
+      this->mMaxR[layer] = std::max(this->mMaxR[layer], r);
+      this->addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), alpha,
+                                        std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
+                                        std::array<float, 3>{resolution[layer] * resolution[layer], 0., resolution[layer] * resolution[layer]});
+      /// Rotate to the global frame
+      this->addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), this->mUnsortedClusters[layer].size());
+      this->addClusterExternalIndexToLayer(layer, hitCounter);
+      MCCompLabel label{hit.GetTrackID(), static_cast<int>(iEvent), 0};
+      labels->addElement(hitCounter, label);
+      this->mClusterSize[hitCounter] = 1; // For compatibility with cluster-based tracking, set cluster size to 1 for hits
+      hitCounter++;
+    }
+    trkHit->clear();
+
+    // Update ROF structure when we complete an ROF or reach the last event
+    if ((iEvent + 1) % inROFpileup == 0 || iEvent == nEvents - 1) {
+      iRof++;
+      for (unsigned int iLayer{0}; iLayer < this->mUnsortedClusters.size(); ++iLayer) {
+        this->mROFramesClusters[iLayer][iRof] = this->mUnsortedClusters[iLayer].size(); // effectively calculating an exclusive sum
+      }
+      // Update primary vertices ROF structure
+    }
+    this->mClusterLabels = labels;
+  }
+  return this->mNrof;
+}
+
+template <int nLayers>
+void TimeFrame<nLayers>::getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup)
+{
+  auto mcheader = new o2::dataformats::MCEventHeader;
+  mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
+
+  this->mROFramesPV.clear();
+  this->mROFramesPV.resize(nRofs + 1, 0);
+  this->mPrimaryVertices.clear();
+
+  int iRof{0};
+  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
+    mcHeaderTree->GetEntry(iEvent);
+    o2::its::Vertex vertex;
+    vertex.setXYZ(mcheader->GetX(), mcheader->GetY(), mcheader->GetZ());
+    vertex.setNContributors(30);
+    vertex.setChi2(0.f);
+    LOGP(debug, "ROF {}: Added primary vertex at ({}, {}, {})", iRof, mcheader->GetX(), mcheader->GetY(), mcheader->GetZ());
+    this->mPrimaryVertices.push_back(vertex);
+    if ((iEvent + 1) % inROFpileup == 0 || iEvent == nEvents - 1) {
+      iRof++;
+      this->mROFramesPV[iRof] = this->mPrimaryVertices.size(); // effectively calculating an exclusive sum
+    }
+  }
+  this->mMultiplicityCutMask.resize(nRofs, true); /// all ROFs are valid with MC primary vertices.
+}
+
+// Explicit template instantiation for TRK with 11 layers
+template class TimeFrame<11>;
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
index e86ed7982c85b..d6c8ea85c2bbd 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
@@ -14,17 +14,23 @@ o2_add_library(TRKWorkflow
                SOURCES src/DigitReaderSpec.cxx
                        src/DigitWriterSpec.cxx
                        src/TrackerSpec.cxx
+                       src/TrackWriterSpec.cxx
                        src/RecoWorkflow.cxx
                PUBLIC_LINK_LIBRARIES O2::Framework
                                      O2::GPUWorkflow
                                      O2::SimConfig
                                      O2::DataFormatsITSMFT
                                      O2::SimulationDataFormat
-                                     O2::DPLUtils)
+                                     O2::DPLUtils
+                                     O2::TRKBase
+                                     O2::TRKSimulation
+                                     O2::TRKReconstruction
+                                     nlohmann_json::nlohmann_json)
 
 o2_add_executable(reco-workflow
                   SOURCES src/trk-reco-workflow.cxx
                   COMPONENT_NAME alice3-trk
                   PUBLIC_LINK_LIBRARIES O2::TRKWorkflow
                                         O2::TRKSimulation
-                                        O2::ITStracking)
\ No newline at end of file
+                                        O2::TRKReconstruction
+                                        O2::ITStracking)
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/README.md b/Detectors/Upgrades/ALICE3/TRK/workflow/README.md
new file mode 100644
index 0000000000000..afb30ed6dbdd3
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/README.md
@@ -0,0 +1,130 @@
+# TRK Reconstruction Workflow
+
+This document describes how to run the TRK (ALICE 3 Tracker) reconstruction workflow and provides examples of configuration files.
+
+## Overview
+
+The TRK reconstruction workflow performs track reconstruction from simulated hits, producing reconstructed tracks with MC truth labels. The workflow currently supports the track reconstruction from hits using the Cellular Automaton (CA) algorithm. The ouput is stored to a ROOT file for offline analysis (example of QA macro provided in `macros/test/CheckTracksCA.C`).
+
+## Quick Start
+
+### Basic Command
+
+```bash
+o2-alice3-trk-reco-workflow --tracking-from-hits-config config_tracker.json -b
+```
+
+### Command Line Options
+
+- `--tracking-from-hits-config <file>`: Path to tracking configuration JSON file (required)
+- `-b`: Batch mode (no GUI)
+- `--disable-root-output`: Skip writing tracks to ROOT file
+- `--help`: Show all available options
+
+## Configuration File
+
+The tracking configuration is provided via a JSON file that specifies:
+1. Input file paths
+2. Geometry parameters (magnetic field, detector pitch)
+3. Tracking algorithm parameters (can specify multiple iterations)
+
+### Example Configuration (`config_tracker.json`)
+
+```json
+{
+  "inputfiles": {
+    "hits": "o2sim_HitsTRK.root",
+    "geometry": "o2sim_geometry.root",
+    "mcHeader": "o2sim_MCHeader.root",
+    "kinematics": "o2sim_Kine.root"
+  },
+  "geometry": {
+    "bz": 5.0,
+    "pitch": [0.001, 0.001, 0.001, 0.001, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004]
+  },
+  "trackingparams": [{
+    "NLayers": 11,
+    "DeltaROF": 0,
+    "LayerZ": [25.1, 25.1, 25.1, 64.2, 64.2, 64.2, 64.2, 64.2, 128.5, 128.5, 128.5],
+    "LayerRadii": [0.5, 1.2, 2.5, 7.05, 9.05, 12.05, 20.05, 30.05, 45.05, 60.5, 80.05],
+    "LayerxX0": [0.001, 0.001, 0.001, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+    "LayerResolution": [0.0003, 0.0003, 0.0003, 0.0003, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012],
+    "SystErrorY2": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+    "SystErrorZ2": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+    "ZBins": 256,
+    "PhiBins": 128,
+    "nROFsPerIterations": -1,
+    "UseDiamond": false,
+    "Diamond": [0.0, 0.0, 0.0],
+    "AllowSharingFirstCluster": false,
+    "ClusterSharing": 0,
+    "MinTrackLength": 7,
+    "NSigmaCut": 10,
+    "PVres": 0.01,
+    "TrackletMinPt": 0.1,
+    "TrackletsPerClusterLimit": 2.0,
+    "CellDeltaTanLambdaSigma": 0.007,
+    "CellsPerClusterLimit": 2.0,
+    "MaxChi2ClusterAttachment": 60.0,
+    "MaxChi2NDF": 30.0,
+    "ReseedIfShorter": 6,
+    "MinPt": [0.0, 0.0, 0.0, 0.0],
+    "StartLayerMask": 4095,
+    "RepeatRefitOut": false,
+    "ShiftRefToCluster": true,
+    "FindShortTracks": false,
+    "PerPrimaryVertexProcessing": false,
+    "SaveTimeBenchmarks": false,
+    "DoUPCIteration": false,
+    "FataliseUponFailure": true,
+    "UseTrackFollower": true,
+    "UseTrackFollowerTop": false,
+    "UseTrackFollowerBot": false,
+    "UseTrackFollowerMix": true,
+    "TrackFollowerNSigmaCutZ": 1.0,
+    "TrackFollowerNSigmaCutPhi": 1.0,
+    "createArtefactLabels": false,
+    "PrintMemory": false,
+    "DropTFUponFailure": false
+  }]
+}
+```
+Note that the `trackingparams` field can contain multiple sets of parameters for different iterations of the tracking algorithm. The example above shows a single iteration with 11 layers and it is **not** optimized.
+
+## Complete Workflow Example
+
+### 1. Run Simulation
+
+First, generate simulation data:
+
+```bash
+o2-sim-serial-run5 -n 200 -g pythia8hi -m TRK --configKeyValues "Diamond.width[0]=0.01;Diamond.width[1]=0.01;Diamond.width[2]=5;TRKBase.layoutML=kTurboStaves;TRKBase.layoutOL=kStaggered;"
+```
+
+This produces, among other files:
+- `o2sim_HitsTRK.root`
+- `o2sim_geometry.root`
+- `o2sim_MCHeader.root`
+- `o2sim_Kine.root`
+That will be used by the reconstruction as currently we do not have clusters.
+
+### 2. Run Reconstruction
+
+Execute the tracking workflow:
+
+```bash
+o2-alice3-trk-reco-workflow --tracking-from-hits-config config_tracker.json -b
+```
+
+This produces:
+- `o2trac_trk.root`: Reconstructed tracks with MC labels
+
+### 3. Run Quality Assurance
+
+Analyze the tracking performance:
+
+```bash
+root -l
+.L CheckTracksCA.C+
+CheckTracksCA("o2trac_trk.root", "o2sim_Kine.root", "o2sim_HitsTRK.root", "trk_qa_output.root")
+```
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
index 98d4154f11dd8..7046955a20c2e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
@@ -14,6 +14,7 @@
 
 #include "Framework/WorkflowSpec.h"
 #include "GPUDataTypesConfig.h"
+#include <string>
 
 namespace o2::trk
 {
@@ -21,6 +22,7 @@ namespace reco_workflow
 {
 
 o2::framework::WorkflowSpec getWorkflow(bool useMC,
+                                        const std::string& hitRecoConfig,
                                         bool upstreamDigits = false,
                                         bool upstreamClusters = false,
                                         bool disableRootOutput = false,
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackWriterSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackWriterSpec.h
new file mode 100644
index 0000000000000..105504e7c9fe6
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackWriterSpec.h
@@ -0,0 +1,31 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   TrackWriterSpec.h
+
+#ifndef O2_TRK_TRACKWRITER
+#define O2_TRK_TRACKWRITER
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2
+{
+namespace trk
+{
+
+/// create a processor spec
+/// write TRK tracks to ROOT file
+o2::framework::DataProcessorSpec getTrackWriterSpec(bool useMC);
+
+} // namespace trk
+} // namespace o2
+
+#endif /* O2_TRK_TRACKWRITER */
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
index dac1826e21cf6..33b25737bbc29 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
@@ -19,6 +19,9 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 
+#include <oneapi/tbb/task_arena.h>
+
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/TrackingInterface.h"
 #include "GPUDataTypesConfig.h"
 
@@ -26,6 +29,8 @@
 
 #include "TStopwatch.h"
 
+#include <nlohmann/json.hpp>
+
 namespace o2::trk
 {
 class TrackerDPL : public framework::Task
@@ -33,6 +38,7 @@ class TrackerDPL : public framework::Task
  public:
   TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
              bool isMC,
+             const std::string& hitRecoConfig,
              gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
   void init(framework::InitContext& ic) final;
@@ -43,14 +49,18 @@ class TrackerDPL : public framework::Task
 
  private:
   void updateTimeDependentParams(framework::ProcessingContext& pc);
+  std::vector<o2::its::TrackingParameters> createTrackingParamsFromConfig();
   //   std::unique_ptr<o2::gpu::GPUReconstruction> mRecChain = nullptr;
   //   std::unique_ptr<o2::gpu::GPUChainITS> mChainITS = nullptr;
   //   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   //   ITSTrackingInterface mITSTrackingInterface;
+  std::shared_ptr<its::BoundedMemoryResource> mMemoryPool;
+  std::shared_ptr<tbb::task_arena> mTaskArena;
+  nlohmann::json mHitRecoConfig;
   TStopwatch mTimer;
 };
 
-framework::DataProcessorSpec getTrackerSpec(bool useMC, gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
 
 } // namespace o2::trk
 #endif /* O2_TRK_TRACKERDPL */
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
index 09d447a576e48..5f6cbe2f96b04 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
@@ -11,12 +11,16 @@
 
 #include "TRKWorkflow/RecoWorkflow.h"
 #include "TRKWorkflow/TrackerSpec.h"
+#include "TRKWorkflow/TrackWriterSpec.h"
 #include "Framework/CCDBParamSpec.h"
 
+#include <string>
+
 namespace o2::trk::reco_workflow
 {
 
 framework::WorkflowSpec getWorkflow(bool useMC,
+                                    const std::string& hitRecoConfig,
                                     bool upstreamDigits,
                                     bool upstreamClusters,
                                     bool disableRootOutput,
@@ -24,7 +28,12 @@ framework::WorkflowSpec getWorkflow(bool useMC,
                                     o2::gpu::gpudatatypes::DeviceType dtype)
 {
   framework::WorkflowSpec specs;
-  specs.emplace_back(o2::trk::getTrackerSpec(useMC, dtype));
+  specs.emplace_back(o2::trk::getTrackerSpec(useMC, hitRecoConfig, dtype));
+
+  if (!disableRootOutput) {
+    specs.emplace_back(o2::trk::getTrackWriterSpec(useMC));
+  }
+
   return specs;
 }
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackWriterSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackWriterSpec.cxx
new file mode 100644
index 0000000000000..1606c32a0ea78
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackWriterSpec.cxx
@@ -0,0 +1,57 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   TrackWriterSpec.cxx
+
+#include <vector>
+
+#include "TRKWorkflow/TrackWriterSpec.h"
+#include "DPLUtils/MakeRootTreeWriterSpec.h"
+#include "DataFormatsITS/TrackITS.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+
+using namespace o2::framework;
+
+namespace o2
+{
+namespace trk
+{
+
+template <typename T>
+using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
+using LabelsType = std::vector<o2::MCCompLabel>;
+using namespace o2::header;
+
+DataProcessorSpec getTrackWriterSpec(bool useMC)
+{
+  // Spectators for logging
+  auto tracksSize = std::make_shared<int>(0);
+  auto tracksSizeGetter = [tracksSize](std::vector<o2::its::TrackITS> const& tracks) {
+    *tracksSize = tracks.size();
+  };
+  auto logger = [tracksSize]() {
+    LOG(info) << "TRKTrackWriter pulled " << *tracksSize << " tracks";
+  };
+
+  return MakeRootTreeWriterSpec("trk-track-writer",
+                                "o2trac_trk.root",
+                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Tree with TRK tracks"},
+                                BranchDefinition<std::vector<o2::its::TrackITS>>{InputSpec{"tracks", "TRK", "TRACKS", 0},
+                                                                                 "TRKTrack",
+                                                                                 tracksSizeGetter},
+                                BranchDefinition<LabelsType>{InputSpec{"labels", "TRK", "TRACKSMCTR", 0},
+                                                             "TRKTrackMCTruth",
+                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
+                                                             ""})();
+}
+
+} // namespace trk
+} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
index 868a8acc0fc6e..8f26478f4496e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -11,10 +11,24 @@
 
 #include <vector>
 
+#include "DetectorsBase/GeometryManager.h"
+#include "ITStracking/TimeFrame.h"
+#include "ITStracking/Configuration.h"
+#include "Field/MagneticField.h"
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
+#include "SimulationDataFormat/MCEventHeader.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/SegmentationChip.h"
+#include "TRKSimulation/Hit.h"
+#include "TRKReconstruction/TimeFrame.h"
 #include "TRKWorkflow/TrackerSpec.h"
+#include <TGeoGlobalMagField.h>
+
+#include <TFile.h>
+#include <TTree.h>
 
 namespace o2
 {
@@ -25,8 +39,14 @@ using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        bool isMC,
+                       const std::string& hitRecoConfigFileName,
                        o2::gpu::gpudatatypes::DeviceType dType)
 {
+  if (!hitRecoConfigFileName.empty()) {
+    std::ifstream configFile(hitRecoConfigFileName);
+    mHitRecoConfig = nlohmann::json::parse(configFile);
+  }
+
   // mITSTrackingInterface.setTrackingMode(trMode);
 }
 
@@ -46,13 +66,288 @@ void TrackerDPL::stop()
   LOGF(info, "CPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
+std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromConfig()
+{
+  std::vector<o2::its::TrackingParameters> trackingParams;
+
+  if (!mHitRecoConfig.contains("trackingparams") || !mHitRecoConfig["trackingparams"].is_array()) {
+    LOGP(fatal, "No trackingparams field found in configuration or it is not an array. Returning empty vector.");
+    return trackingParams;
+  }
+
+  for (const auto& paramConfig : mHitRecoConfig["trackingparams"]) {
+    o2::its::TrackingParameters params;
+
+    // Parse integer parameters
+    if (paramConfig.contains("NLayers")) {
+      params.NLayers = paramConfig["NLayers"].get<int>();
+    }
+    if (paramConfig.contains("DeltaROF")) {
+      params.DeltaROF = paramConfig["DeltaROF"].get<int>();
+    }
+    if (paramConfig.contains("ZBins")) {
+      params.ZBins = paramConfig["ZBins"].get<int>();
+    }
+    if (paramConfig.contains("PhiBins")) {
+      params.PhiBins = paramConfig["PhiBins"].get<int>();
+    }
+    if (paramConfig.contains("nROFsPerIterations")) {
+      params.nROFsPerIterations = paramConfig["nROFsPerIterations"].get<int>();
+    }
+    if (paramConfig.contains("ClusterSharing")) {
+      params.ClusterSharing = paramConfig["ClusterSharing"].get<int>();
+    }
+    if (paramConfig.contains("MinTrackLength")) {
+      params.MinTrackLength = paramConfig["MinTrackLength"].get<int>();
+    }
+    if (paramConfig.contains("ReseedIfShorter")) {
+      params.ReseedIfShorter = paramConfig["ReseedIfShorter"].get<int>();
+    }
+    if (paramConfig.contains("StartLayerMask")) {
+      params.StartLayerMask = paramConfig["StartLayerMask"].get<uint16_t>();
+    }
+
+    // Parse float parameters
+    if (paramConfig.contains("NSigmaCut")) {
+      params.NSigmaCut = paramConfig["NSigmaCut"].get<float>();
+    }
+    if (paramConfig.contains("PVres")) {
+      params.PVres = paramConfig["PVres"].get<float>();
+    }
+    if (paramConfig.contains("TrackletMinPt")) {
+      params.TrackletMinPt = paramConfig["TrackletMinPt"].get<float>();
+    }
+    if (paramConfig.contains("TrackletsPerClusterLimit")) {
+      params.TrackletsPerClusterLimit = paramConfig["TrackletsPerClusterLimit"].get<float>();
+    }
+    if (paramConfig.contains("CellDeltaTanLambdaSigma")) {
+      params.CellDeltaTanLambdaSigma = paramConfig["CellDeltaTanLambdaSigma"].get<float>();
+    }
+    if (paramConfig.contains("CellsPerClusterLimit")) {
+      params.CellsPerClusterLimit = paramConfig["CellsPerClusterLimit"].get<float>();
+    }
+    if (paramConfig.contains("MaxChi2ClusterAttachment")) {
+      params.MaxChi2ClusterAttachment = paramConfig["MaxChi2ClusterAttachment"].get<float>();
+    }
+    if (paramConfig.contains("MaxChi2NDF")) {
+      params.MaxChi2NDF = paramConfig["MaxChi2NDF"].get<float>();
+    }
+    if (paramConfig.contains("TrackFollowerNSigmaCutZ")) {
+      params.TrackFollowerNSigmaCutZ = paramConfig["TrackFollowerNSigmaCutZ"].get<float>();
+    }
+    if (paramConfig.contains("TrackFollowerNSigmaCutPhi")) {
+      params.TrackFollowerNSigmaCutPhi = paramConfig["TrackFollowerNSigmaCutPhi"].get<float>();
+    }
+
+    // Parse boolean parameters
+    if (paramConfig.contains("UseDiamond")) {
+      params.UseDiamond = paramConfig["UseDiamond"].get<bool>();
+    }
+    if (paramConfig.contains("AllowSharingFirstCluster")) {
+      params.AllowSharingFirstCluster = paramConfig["AllowSharingFirstCluster"].get<bool>();
+    }
+    if (paramConfig.contains("RepeatRefitOut")) {
+      params.RepeatRefitOut = paramConfig["RepeatRefitOut"].get<bool>();
+    }
+    if (paramConfig.contains("ShiftRefToCluster")) {
+      params.ShiftRefToCluster = paramConfig["ShiftRefToCluster"].get<bool>();
+    }
+    if (paramConfig.contains("FindShortTracks")) {
+      params.FindShortTracks = paramConfig["FindShortTracks"].get<bool>();
+    }
+    if (paramConfig.contains("PerPrimaryVertexProcessing")) {
+      params.PerPrimaryVertexProcessing = paramConfig["PerPrimaryVertexProcessing"].get<bool>();
+    }
+    if (paramConfig.contains("SaveTimeBenchmarks")) {
+      params.SaveTimeBenchmarks = paramConfig["SaveTimeBenchmarks"].get<bool>();
+    }
+    if (paramConfig.contains("DoUPCIteration")) {
+      params.DoUPCIteration = paramConfig["DoUPCIteration"].get<bool>();
+    }
+    if (paramConfig.contains("FataliseUponFailure")) {
+      params.FataliseUponFailure = paramConfig["FataliseUponFailure"].get<bool>();
+    }
+    if (paramConfig.contains("UseTrackFollower")) {
+      params.UseTrackFollower = paramConfig["UseTrackFollower"].get<bool>();
+    }
+    if (paramConfig.contains("UseTrackFollowerTop")) {
+      params.UseTrackFollowerTop = paramConfig["UseTrackFollowerTop"].get<bool>();
+    }
+    if (paramConfig.contains("UseTrackFollowerBot")) {
+      params.UseTrackFollowerBot = paramConfig["UseTrackFollowerBot"].get<bool>();
+    }
+    if (paramConfig.contains("UseTrackFollowerMix")) {
+      params.UseTrackFollowerMix = paramConfig["UseTrackFollowerMix"].get<bool>();
+    }
+    if (paramConfig.contains("createArtefactLabels")) {
+      params.createArtefactLabels = paramConfig["createArtefactLabels"].get<bool>();
+    }
+    if (paramConfig.contains("PrintMemory")) {
+      params.PrintMemory = paramConfig["PrintMemory"].get<bool>();
+    }
+    if (paramConfig.contains("DropTFUponFailure")) {
+      params.DropTFUponFailure = paramConfig["DropTFUponFailure"].get<bool>();
+    }
+
+    // Parse vector parameters
+    if (paramConfig.contains("LayerZ")) {
+      params.LayerZ = paramConfig["LayerZ"].get<std::vector<float>>();
+    }
+    if (paramConfig.contains("LayerRadii")) {
+      params.LayerRadii = paramConfig["LayerRadii"].get<std::vector<float>>();
+    }
+    if (paramConfig.contains("LayerxX0")) {
+      params.LayerxX0 = paramConfig["LayerxX0"].get<std::vector<float>>();
+    }
+    if (paramConfig.contains("LayerResolution")) {
+      params.LayerResolution = paramConfig["LayerResolution"].get<std::vector<float>>();
+    }
+    if (paramConfig.contains("SystErrorY2")) {
+      params.SystErrorY2 = paramConfig["SystErrorY2"].get<std::vector<float>>();
+    }
+    if (paramConfig.contains("SystErrorZ2")) {
+      params.SystErrorZ2 = paramConfig["SystErrorZ2"].get<std::vector<float>>();
+    }
+    if (paramConfig.contains("MinPt")) {
+      params.MinPt = paramConfig["MinPt"].get<std::vector<float>>();
+    }
+
+    // Parse Diamond array
+    if (paramConfig.contains("Diamond") && paramConfig["Diamond"].is_array() && paramConfig["Diamond"].size() == 3) {
+      params.Diamond[0] = paramConfig["Diamond"][0].get<float>();
+      params.Diamond[1] = paramConfig["Diamond"][1].get<float>();
+      params.Diamond[2] = paramConfig["Diamond"][2].get<float>();
+    }
+
+    // Parse size_t parameter
+    if (paramConfig.contains("MaxMemory")) {
+      params.MaxMemory = paramConfig["MaxMemory"].get<size_t>();
+    }
+
+    // Parse CorrType enum
+    if (paramConfig.contains("CorrType")) {
+      int corrTypeInt = paramConfig["CorrType"].get<int>();
+      params.CorrType = static_cast<o2::base::PropagatorImpl<float>::MatCorrType>(corrTypeInt);
+    }
+
+    trackingParams.push_back(params);
+  }
+
+  LOGP(info, "Loaded {} tracking parameter sets from configuration", trackingParams.size());
+  return trackingParams;
+}
+
 void TrackerDPL::run(ProcessingContext& pc)
 {
   auto cput = mTimer.CpuTime();
   auto realt = mTimer.RealTime();
   mTimer.Start(false);
-  // mITSTrackingInterface.updateTimeDependentParams(pc);
-  // mITSTrackingInterface.run(pc);
+
+  if (!mHitRecoConfig.empty()) {
+    TFile hitsFile(mHitRecoConfig["inputfiles"]["hits"].get<std::string>().c_str(), "READ");
+    TFile mcHeaderFile(mHitRecoConfig["inputfiles"]["mcHeader"].get<std::string>().c_str(), "READ");
+    TTree* hitsTree = hitsFile.Get<TTree>("o2sim");
+    std::vector<o2::trk::Hit>* trkHit = nullptr;
+    hitsTree->SetBranchAddress("TRKHit", &trkHit);
+
+    TTree* mcHeaderTree = mcHeaderFile.Get<TTree>("o2sim");
+    auto mcheader = new o2::dataformats::MCEventHeader;
+    mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
+
+    o2::base::GeometryManager::loadGeometry(mHitRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
+    auto* gman = o2::trk::GeometryTGeo::Instance();
+
+    const Long64_t nEvents{hitsTree->GetEntries()};
+    LOGP(info, "Starting reconstruction from hits for {} events", nEvents);
+
+    if (mMemoryPool.get() == nullptr) {
+      mMemoryPool = std::make_shared<its::BoundedMemoryResource>();
+    }
+    if (mTaskArena.get() == nullptr) {
+      mTaskArena = std::make_shared<tbb::task_arena>(1); /// TODO: make it configurable
+    }
+
+    o2::trk::TimeFrame<11> timeFrame;
+    o2::its::TrackerTraits<11> itsTrackerTraits;
+    o2::its::Tracker<11> itsTracker(&itsTrackerTraits);
+    timeFrame.setMemoryPool(mMemoryPool);
+    itsTrackerTraits.setMemoryPool(mMemoryPool);
+    itsTrackerTraits.setNThreads(mTaskArena->max_concurrency(), mTaskArena);
+    itsTrackerTraits.adoptTimeFrame(static_cast<o2::its::TimeFrame<11>*>(&timeFrame));
+    itsTracker.adoptTimeFrame(timeFrame);
+    itsTrackerTraits.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
+    auto field = o2::field::MagneticField::createNominalField(std::round(mHitRecoConfig["geometry"]["bz"].get<float>()), true);
+    TGeoGlobalMagField::Instance()->SetField(field);
+    TGeoGlobalMagField::Instance()->Lock();
+
+    int nRofs = timeFrame.loadROFsFromHitTree(hitsTree, gman, mHitRecoConfig);
+
+    const int inROFpileup{mHitRecoConfig.contains("inROFpileup") ? mHitRecoConfig["inROFpileup"].get<int>() : 1};
+
+    // Add primary vertices from MC headers for each ROF
+    timeFrame.getPrimaryVerticesFromMC(mcHeaderTree, nRofs, nEvents, inROFpileup);
+    // Create tracking parameters from config and set them in the time frame
+    auto trackingParams = createTrackingParamsFromConfig();
+
+    itsTrackerTraits.updateTrackingParameters(trackingParams);
+
+    for (size_t iter{0}; iter < trackingParams.size(); ++iter) {
+      LOGP(info, "{}", trackingParams[iter].asString());
+      timeFrame.initialise(iter, trackingParams[iter], 11, false);
+      itsTrackerTraits.computeLayerTracklets(iter, -1, -1);
+      LOGP(info, "Number of tracklets in iteration {}: {}", iter, timeFrame.getNumberOfTracklets());
+      itsTrackerTraits.computeLayerCells(iter);
+      LOGP(info, "Number of cells in iteration {}: {}", iter, timeFrame.getNumberOfCells());
+      itsTrackerTraits.findCellsNeighbours(iter);
+      LOGP(info, "Number of cell neighbours in iteration {}: {}", iter, timeFrame.getNumberOfNeighbours());
+      itsTrackerTraits.findRoads(iter);
+      LOGP(info, "Number of roads in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
+      itsTrackerTraits.extendTracks(iter);
+    }
+
+    itsTracker.computeTracksMClabels();
+
+    // Stream tracks and their MC labels to the output
+    // Collect all tracks and labels from all ROFs
+    std::vector<o2::its::TrackITS> allTracks;
+    std::vector<o2::MCCompLabel> allLabels;
+
+    int totalTracks = 0;
+    int goodTracks = 0;
+    int fakeTracks = 0;
+
+    for (int iRof = 0; iRof < nRofs; ++iRof) {
+      const auto& rofTracks = timeFrame.getTracks(iRof);
+      const auto& rofLabels = timeFrame.getTracksLabel(iRof);
+
+      allTracks.insert(allTracks.end(), rofTracks.begin(), rofTracks.end());
+      allLabels.insert(allLabels.end(), rofLabels.begin(), rofLabels.end());
+
+      totalTracks += rofTracks.size();
+      for (const auto& label : rofLabels) {
+        if (label.isFake()) {
+          fakeTracks++;
+        } else {
+          goodTracks++;
+        }
+      }
+    }
+
+    LOGP(info, "=== Tracking Summary ===");
+    LOGP(info, "Total tracks reconstructed: {}", totalTracks);
+    LOGP(info, "Good tracks: {} ({:.1f}%)", goodTracks, totalTracks > 0 ? 100.0 * goodTracks / totalTracks : 0);
+    LOGP(info, "Fake tracks: {} ({:.1f}%)", fakeTracks, totalTracks > 0 ? 100.0 * fakeTracks / totalTracks : 0);
+
+    // Stream tracks and labels to DPL output
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKS", 0}, allTracks);
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSMCTR", 0}, allLabels);
+
+    LOGP(info, "Tracks and MC labels streamed to output");
+
+    pc.services().get<o2::framework::ControlService>().endOfStream();
+    pc.services().get<o2::framework::ControlService>().readyToQuit(framework::QuitRequest::Me);
+  }
+
   mTimer.Stop();
   LOGP(info, "CPU Reconstruction time for this TF {} s (cpu), {} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
 }
@@ -67,16 +362,11 @@ void TrackerDPL::endOfStream(EndOfStreamContext& ec)
   LOGF(info, "TRK CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTrackerSpec(bool useMC, o2::gpu::gpudatatypes::DeviceType dType)
+DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, o2::gpu::gpudatatypes::DeviceType dType)
 {
   std::vector<InputSpec> inputs;
-
-  // inputs.emplace_back("compClusters", "TRK", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  // inputs.emplace_back("patterns", "TRK", "PATTERNS", 0, Lifetime::Timeframe);
-  // inputs.emplace_back("ROframes", "TRK", "CLUSTERSROF", 0, Lifetime::Timeframe);
-
-  // inputs.emplace_back("itscldict", "TRK", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
-  // inputs.emplace_back("itsalppar", "TRK", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+  std::vector<OutputSpec> outputs;
+  outputs.emplace_back("TRK", "TRACKS", 0, Lifetime::Timeframe);
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
                                                               false,                          // GRPECS=true
                                                               false,                          // GRPLHCIF
@@ -85,8 +375,29 @@ DataProcessorSpec getTrackerSpec(bool useMC, o2::gpu::gpudatatypes::DeviceType d
                                                               o2::base::GRPGeomRequest::None, // geometry, but ignored until it will be put in the CCDB
                                                               inputs,
                                                               true);
-  std::vector<OutputSpec> outputs;
-  outputs.emplace_back("TRK", "TRACKS", 0, Lifetime::Timeframe);
+
+  if (!hitRecoConfig.empty()) {
+    outputs.emplace_back("TRK", "TRACKSMCTR", 0, Lifetime::Timeframe);
+    return DataProcessorSpec{
+      "trk-hits-tracker",
+      {},
+      outputs,
+      AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
+                                              useMC,
+                                              hitRecoConfig,
+                                              dType)},
+      Options{ConfigParamSpec{"max-loops", VariantType::Int, 1, {"max number of loops"}}}};
+  }
+
+  inputs.emplace_back("dummy", "TRK", "DUMMY", 0, Lifetime::Timeframe);
+
+  // inputs.emplace_back("compClusters", "TRK", "COMPCLUSTERS", 0, Lifetime::Timeframe);
+  // inputs.emplace_back("patterns", "TRK", "PATTERNS", 0, Lifetime::Timeframe);
+  // inputs.emplace_back("ROframes", "TRK", "CLUSTERSROF", 0, Lifetime::Timeframe);
+
+  // inputs.emplace_back("itscldict", "TRK", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
+  // inputs.emplace_back("itsalppar", "TRK", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+
   // outputs.emplace_back("TRK", "TRACKCLSID", 0, Lifetime::Timeframe);
   // outputs.emplace_back("TRK", "TRKTrackROF", 0, Lifetime::Timeframe);
   // outputs.emplace_back("TRK", "VERTICES", 0, Lifetime::Timeframe);
@@ -108,6 +419,7 @@ DataProcessorSpec getTrackerSpec(bool useMC, o2::gpu::gpudatatypes::DeviceType d
     outputs,
     AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
                                             useMC,
+                                            hitRecoConfig,
                                             dType)},
     Options{}};
 }
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
index 8f44b01da1c9c..166e6f65b4b2b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
@@ -52,6 +52,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"clusters-from-upstream", VariantType::Bool, false, {"clusters will be provided from upstream, skip clusterizer"}},
     {"disable-root-output", VariantType::Bool, false, {"do not write output root files"}},
     {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"tracking-from-hits-config", VariantType::String, "", {"JSON file with tracking from hits configuration"}},
     {"disable-tracking", VariantType::Bool, false, {"disable tracking step"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"use-gpu-workflow", VariantType::Bool, false, {"use GPU workflow (default: false)"}},
@@ -66,6 +67,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   // Update the (declared) parameters if changed from the command line
   auto useMC = !configcontext.options().get<bool>("disable-mc");
+  auto hitRecoConfig = configcontext.options().get<std::string>("tracking-from-hits-config");
   auto useGpuWF = configcontext.options().get<bool>("use-gpu-workflow");
   auto gpuDevice = static_cast<o2::gpu::gpudatatypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
   auto extDigits = configcontext.options().get<bool>("digits-from-upstream");
@@ -76,5 +78,5 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // write the configuration used for the reco workflow
   o2::conf::ConfigurableParam::writeINI("o2itsrecoflow_configuration.ini");
 
-  return o2::trk::reco_workflow::getWorkflow(useMC, extDigits, extClusters, disableRootOutput, useGpuWF, gpuDevice);
+  return o2::trk::reco_workflow::getWorkflow(useMC, hitRecoConfig, extDigits, extClusters, disableRootOutput, useGpuWF, gpuDevice);
 }

From 712170392332bf82ef808d71c26d6a805b8e675f Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 17 Feb 2026 14:47:47 +0100
Subject: [PATCH 1330/1764] DPL Analysis: cleanup AnalysisTask.h and ASoA.h
 (#15008)

---
 Framework/Core/include/Framework/ASoA.h       |  62 +++----
 .../Core/include/Framework/AnalysisManagers.h |   6 -
 .../Core/include/Framework/AnalysisTask.h     | 163 +++++++++---------
 .../Core/include/Framework/Configurable.h     |  15 +-
 Framework/Core/test/test_Concepts.cxx         |   1 +
 .../include/Framework/StructToTuple.h         |  46 ++---
 6 files changed, 136 insertions(+), 157 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 4fd35e0dc5065..7586d6a6d3c63 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -405,15 +405,15 @@ class Table;
 /// Type-checking index column binding
 struct Binding {
   void const* ptr = nullptr;
-  size_t hash = 0;
-  std::span<TableRef const> refs;
+  uint32_t hash = 0;
+  // std::span<TableRef const> refs;
 
   template <typename T>
   void bind(T const* table)
   {
     ptr = table;
     hash = o2::framework::TypeIdHelpers::uniqueId<T>();
-    refs = std::span{T::originals};
+    // refs = std::span{T::originals};
   }
 
   template <typename T>
@@ -1293,6 +1293,9 @@ struct ArrowHelpers {
 template <typename T>
 concept is_iterator = framework::base_of_template<TableIterator, T> || framework::specialization_of_template<TableIterator, T>;
 
+template <typename T>
+concept is_table_or_iterator = is_table<T> || is_iterator<T>;
+
 template <typename T>
 concept with_originals = requires {
   T::originals.size();
@@ -2724,7 +2727,7 @@ consteval auto getIndexTargets()
       return !(*mColumnIterator).empty();                                                                \
     }                                                                                                    \
                                                                                                          \
-    template <typename T>                                                                                \
+    template <soa::is_table T>                                                                           \
     auto _Getter_##_as() const                                                                           \
     {                                                                                                    \
       if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                \
@@ -2734,10 +2737,15 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                          \
       }                                                                                                  \
-      return getIterators<T>();                                                                          \
+      auto result = std::vector<typename T::unfiltered_iterator>();                                      \
+      result.reserve((*mColumnIterator).size());                                                         \
+      for (auto& i : *mColumnIterator) {                                                                 \
+        result.emplace_back(t->rawIteratorAt(i));                                                        \
+      }                                                                                                  \
+      return result;                                                                                     \
     }                                                                                                    \
                                                                                                          \
-    template <typename T>                                                                                \
+    template <soa::is_filtered_table T>                                                                  \
     auto filtered_##_Getter_##_as() const                                                                \
     {                                                                                                    \
       if (O2_BUILTIN_UNLIKELY(mBinding.ptr == nullptr)) {                                                \
@@ -2747,35 +2755,15 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, #_Table_);                                          \
       }                                                                                                  \
-      return getFilteredIterators<T>();                                                                  \
-    }                                                                                                    \
-                                                                                                         \
-    template <typename T>                                                                                \
-    auto getIterators() const                                                                            \
-    {                                                                                                    \
-      auto result = std::vector<typename T::unfiltered_iterator>();                                      \
-      for (auto& i : *mColumnIterator) {                                                                 \
-        result.push_back(mBinding.get<T>()->rawIteratorAt(i));                                           \
-      }                                                                                                  \
-      return result;                                                                                     \
-    }                                                                                                    \
-                                                                                                         \
-    template <typename T>                                                                                \
-    std::vector<typename T::iterator> getFilteredIterators() const                                       \
-    {                                                                                                    \
-      if constexpr (o2::soa::is_filtered_table<T>) {                                                     \
-        auto result = std::vector<typename T::iterator>();                                               \
-        for (auto const& i : *mColumnIterator) {                                                         \
-          auto pos = mBinding.get<T>()->isInSelectedRows(i);                                             \
-          if (pos > 0) {                                                                                 \
-            result.emplace_back(mBinding.get<T>()->iteratorAt(pos));                                     \
-          }                                                                                              \
+      auto result = std::vector<typename T::iterator>();                                                 \
+      result.reserve((*mColumnIterator).size());                                                         \
+      for (auto const& i : *mColumnIterator) {                                                           \
+        auto pos = t->isInSelectedRows(i);                                                               \
+        if (pos > 0) {                                                                                   \
+          result.emplace_back(t->iteratorAt(pos));                                                       \
         }                                                                                                \
-        return result;                                                                                   \
-      } else {                                                                                           \
-        static_assert(o2::framework::always_static_assert_v<T>, "T is not a Filtered type");             \
       }                                                                                                  \
-      return {};                                                                                         \
+      return result;                                                                                     \
     }                                                                                                    \
                                                                                                          \
     auto _Getter_() const                                                                                \
@@ -3090,15 +3078,9 @@ consteval auto getIndexTargets()
       if (O2_BUILTIN_UNLIKELY(t == nullptr)) {                                                           \
         o2::soa::dereferenceWithWrongType(#_Getter_, "self");                                            \
       }                                                                                                  \
-      return getIterators<T>();                                                                          \
-    }                                                                                                    \
-                                                                                                         \
-    template <typename T>                                                                                \
-    auto getIterators() const                                                                            \
-    {                                                                                                    \
       auto result = std::vector<typename T::unfiltered_iterator>();                                      \
       for (auto& i : *mColumnIterator) {                                                                 \
-        result.push_back(mBinding.get<T>()->rawIteratorAt(i));                                           \
+        result.push_back(t->rawIteratorAt(i));                                                           \
       }                                                                                                  \
       return result;                                                                                     \
     }                                                                                                    \
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index fd41a079c6570..121ce7f4b4a77 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -534,12 +534,6 @@ void bindExternalIndicesPartition(P& partition, T*... tables)
 }
 
 /// Cache handling
-template <typename T>
-bool preInitializeCache(InitContext&, T&)
-{
-  return false;
-}
-
 template <typename T>
 bool initializeCache(ProcessingContext&, T&)
 {
diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index eb98d55cc24b2..fbd523c7b0c37 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -22,7 +22,6 @@
 #include "Framework/EndOfStreamContext.h"
 #include "Framework/GroupSlicer.h"
 #include "Framework/StructToTuple.h"
-#include "Framework/Traits.h"
 #include "Framework/TypeIdHelpers.h"
 #include "Framework/ArrowTableSlicingCache.h"
 #include "Framework/AnalysisDataModel.h"
@@ -66,17 +65,20 @@ static constexpr bool is_enumeration_v<Enumeration<BEGIN, END, STEP>> = true;
 template <typename T>
 concept is_enumeration = is_enumeration_v<std::decay_t<T>>;
 
+template <typename T>
+concept is_table_iterator_or_enumeration = soa::is_table_or_iterator<T> || is_enumeration<T>;
+
 // Helper struct which builds a DataProcessorSpec from
 // the contents of an AnalysisTask...
 namespace
 {
 struct AnalysisDataProcessorBuilder {
-  template <soa::is_iterator G, typename... Args>
+  template <soa::is_iterator G, soa::is_table... Args>
   static void addGroupingCandidates(Cache& bk, Cache& bku, bool enabled)
   {
-    [&bk, &bku, enabled]<typename... As>(framework::pack<As...>) mutable {
+    []<soa::is_table... As>(framework::pack<As...>, Cache& bk, Cache& bku, bool enabled) {
       auto key = std::string{"fIndex"} + o2::framework::cutString(soa::getLabelFromType<std::decay_t<G>>());
-      ([&bk, &bku, &key, enabled]() mutable {
+      ([](Cache& bk, Cache& bku, bool enabled, std::string const& key) {
         if constexpr (soa::relatedByIndex<std::decay_t<G>, std::decay_t<As>>()) {
           Entry e{soa::getLabelFromTypeForKey<std::decay_t<As>>(key), soa::getMatcherFromTypeForKey<std::decay_t<As>>(key), key, enabled};
           if constexpr (o2::soa::is_smallgroups<std::decay_t<As>>) {
@@ -85,9 +87,9 @@ struct AnalysisDataProcessorBuilder {
             framework::updatePairList(bk, e);
           }
         }
-      }(),
+      }(bk, bku, enabled, key),
        ...);
-    }(framework::pack<Args...>{});
+    }(framework::pack<Args...>{}, bk, bku, enabled);
   }
 
   template <soa::TableRef R>
@@ -171,8 +173,8 @@ struct AnalysisDataProcessorBuilder {
     return true;
   }
   /// 1. enumeration (must be the only argument)
-  template <typename R, typename C, is_enumeration A>
-  static void inputsFromArgs(R (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&) //, Cache&, Cache&)
+  template <typename C, is_enumeration A>
+  static void inputsFromArgs(void (C::*)(A), const char* /*name*/, bool /*value*/, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>&) //, Cache&, Cache&)
   {
     std::vector<ConfigParamSpec> inputMetadata;
     // FIXME: for the moment we do not support begin, end and step.
@@ -180,37 +182,37 @@ struct AnalysisDataProcessorBuilder {
   }
 
   /// 2. 1st argument is an iterator
-  template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache& bk, Cache& bku)
+  template <typename C, soa::is_iterator A, soa::is_table... Args>
+  static void inputsFromArgs(void (C::*)(A, Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache& bk, Cache& bku)
     requires(std::is_lvalue_reference_v<A> && (std::is_lvalue_reference_v<Args> && ...))
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(A, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(A, Args...)>();
     addInputsAndExpressions<typename std::decay_t<A>::parent_t, Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 3. generic case
-  template <typename R, typename C, soa::is_table... Args>
-  static void inputsFromArgs(R (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache&, Cache&)
+  template <typename C, soa::is_table... Args>
+  static void inputsFromArgs(void (C::*)(Args...), const char* name, bool value, std::vector<InputSpec>& inputs, std::vector<ExpressionInfo>& eInfos) //, Cache&, Cache&)
     requires(std::is_lvalue_reference_v<Args> && ...)
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Args...)>();
     addInputsAndExpressions<Args...>(hash, name, value, inputs, eInfos);
   }
 
   /// 1. enumeration (no grouping)
-  template <typename R, typename C, is_enumeration A>
-  static void cacheFromArgs(R (C::*)(A), bool, Cache&, Cache&)
+  template <typename C, is_enumeration A>
+  static void cacheFromArgs(void (C::*)(A), bool, Cache&, Cache&)
   {
   }
   /// 2. iterator (the only grouping case)
-  template <typename R, typename C, soa::is_iterator A, soa::is_table... Args>
-  static void cacheFromArgs(R (C::*)(A, Args...), bool value, Cache& bk, Cache& bku)
+  template <typename C, soa::is_iterator A, soa::is_table... Args>
+  static void cacheFromArgs(void (C::*)(A, Args...), bool value, Cache& bk, Cache& bku)
   {
     addGroupingCandidates<A, Args...>(bk, bku, value);
   }
   /// 3. generic case (no grouping)
-  template <typename R, typename C, soa::is_table A, soa::is_table... Args>
-  static void cacheFromArgs(R (C::*)(A, Args...), bool, Cache&, Cache&)
+  template <typename C, soa::is_table A, soa::is_table... Args>
+  static void cacheFromArgs(void (C::*)(A, Args...), bool, Cache&, Cache&)
   {
   }
 
@@ -285,51 +287,53 @@ struct AnalysisDataProcessorBuilder {
     }
   }
 
-  template <typename R, typename C, typename Grouping, typename... Args>
-  static auto bindGroupingTable(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
+  template <typename C, is_table_iterator_or_enumeration Grouping, soa::is_table... Args>
+  static auto bindGroupingTable(InputRecord& record, void (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
     requires(!std::same_as<Grouping, void>)
   {
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Grouping, Args...)>();
     return extract<std::decay_t<Grouping>, 0>(record, infos, hash);
   }
 
-  template <typename R, typename C, typename Grouping, typename... Args>
-  static auto bindAssociatedTables(InputRecord& record, R (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
+  template <typename C, is_table_iterator_or_enumeration Grouping, soa::is_table... Args>
+  static auto bindAssociatedTables(InputRecord& record, void (C::*)(Grouping, Args...), std::vector<ExpressionInfo>& infos)
     requires(!std::same_as<Grouping, void> && sizeof...(Args) > 0)
   {
     constexpr auto p = pack<Args...>{};
-    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<R (C::*)(Grouping, Args...)>();
+    constexpr auto hash = o2::framework::TypeIdHelpers::uniqueId<void (C::*)(Grouping, Args...)>();
     return std::make_tuple(extract<std::decay_t<Args>, has_type_at_v<Args>(p) + 1>(record, infos, hash)...);
   }
 
-  template <typename... As>
+  template <soa::is_table... As>
   static void overwriteInternalIndices(std::tuple<As...>& dest, std::tuple<As...> const& src)
   {
     (std::get<As>(dest).bindInternalIndicesTo(&std::get<As>(src)), ...);
   }
 
-  template <typename Task, typename R, typename C, typename Grouping, typename... Associated>
-  static void invokeProcess(Task& task, InputRecord& inputs, R (C::*processingFunction)(Grouping, Associated...), std::vector<ExpressionInfo>& infos, ArrowTableSlicingCache& slices)
+  template <typename Task, is_table_iterator_or_enumeration Grouping, soa::is_table... Associated>
+  static void invokeProcess(Task& task, InputRecord& inputs, void (Task::*processingFunction)(Grouping, Associated...), std::vector<ExpressionInfo>& infos, ArrowTableSlicingCache& slices)
   {
     using G = std::decay_t<Grouping>;
     auto groupingTable = AnalysisDataProcessorBuilder::bindGroupingTable(inputs, processingFunction, infos);
 
+    constexpr const int numElements = nested_brace_constructible_size<false, std::decay_t<Task>>() / 10;
+
     // set filtered tables for partitions with grouping
-    homogeneous_apply_refs([&groupingTable](auto& element) {
+    homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& element) {
       analysis_task_parsers::setPartition(element, groupingTable);
       analysis_task_parsers::bindInternalIndicesPartition(element, &groupingTable);
       return true;
     },
-                           task);
+                                              task);
 
     if constexpr (sizeof...(Associated) == 0) {
       // single argument to process
-      homogeneous_apply_refs([&groupingTable](auto& element) {
+      homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& element) {
         analysis_task_parsers::bindExternalIndicesPartition(element, &groupingTable);
         analysis_task_parsers::setGroupedCombination(element, groupingTable);
         return true;
       },
-                             task);
+                                                task);
       if constexpr (soa::is_iterator<G>) {
         for (auto& element : groupingTable) {
           std::invoke(processingFunction, task, *element);
@@ -347,7 +351,7 @@ struct AnalysisDataProcessorBuilder {
       // pre-bind self indices
       std::apply(
         [&task](auto&... t) mutable {
-          (homogeneous_apply_refs(
+          (homogeneous_apply_refs_sized<numElements>(
              [&t](auto& p) {
                analysis_task_parsers::bindInternalIndicesPartition(p, &t);
                return true;
@@ -359,12 +363,12 @@ struct AnalysisDataProcessorBuilder {
 
       auto binder = [&task, &groupingTable, &associatedTables](auto& x) mutable {
         x.bindExternalIndices(&groupingTable, &std::get<std::decay_t<Associated>>(associatedTables)...);
-        homogeneous_apply_refs([&x](auto& t) mutable {
+        homogeneous_apply_refs_sized<numElements>([&x](auto& t) mutable {
           analysis_task_parsers::setPartition(t, x);
           analysis_task_parsers::bindExternalIndicesPartition(t, &x);
           return true;
         },
-                               task);
+                                                  task);
       };
       groupingTable.bindExternalIndices(&std::get<std::decay_t<Associated>>(associatedTables)...);
 
@@ -376,11 +380,11 @@ struct AnalysisDataProcessorBuilder {
         associatedTables);
 
       // GroupedCombinations bound separately, as they should be set once for all associated tables
-      homogeneous_apply_refs([&groupingTable, &associatedTables](auto& t) {
+      homogeneous_apply_refs_sized<numElements>([&groupingTable, &associatedTables](auto& t) {
         analysis_task_parsers::setGroupedCombination(t, groupingTable, associatedTables);
         return true;
       },
-                             task);
+                                                task);
       overwriteInternalIndices(associatedTables, associatedTables);
       if constexpr (soa::is_iterator<std::decay_t<G>>) {
         auto slicer = GroupSlicer(groupingTable, associatedTables, slices);
@@ -394,28 +398,28 @@ struct AnalysisDataProcessorBuilder {
             associatedSlices);
 
           // bind partitions and grouping table
-          homogeneous_apply_refs([&groupingTable](auto& x) {
+          homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& x) {
             analysis_task_parsers::bindExternalIndicesPartition(x, &groupingTable);
             return true;
           },
-                                 task);
+                                                    task);
 
           invokeProcessWithArgs(task, processingFunction, slice.groupingElement(), associatedSlices);
         }
       } else {
         // bind partitions and grouping table
-        homogeneous_apply_refs([&groupingTable](auto& x) {
+        homogeneous_apply_refs_sized<numElements>([&groupingTable](auto& x) {
           analysis_task_parsers::bindExternalIndicesPartition(x, &groupingTable);
           return true;
         },
-                               task);
+                                                  task);
 
         invokeProcessWithArgs(task, processingFunction, groupingTable, associatedTables);
       }
     }
   }
 
-  template <typename C, typename T, typename G, typename... A>
+  template <typename C, typename T, is_table_iterator_or_enumeration G, soa::is_table... A>
   static void invokeProcessWithArgs(C& task, T processingFunction, G g, std::tuple<A...>& at)
   {
     std::invoke(processingFunction, task, g, std::get<A>(at)...);
@@ -523,16 +527,18 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
   std::vector<ConfigParamSpec> options;
   std::vector<ExpressionInfo> expressionInfos;
 
+  constexpr const int numElements = nested_brace_constructible_size<false, std::decay_t<T>>() / 10;
+
   /// make sure options and configurables are set before expression infos are created
-  homogeneous_apply_refs([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
+  homogeneous_apply_refs_sized<numElements>([&options](auto& element) { return analysis_task_parsers::appendOption(options, element); }, *task.get());
   /// extract conditions and append them as inputs
-  homogeneous_apply_refs([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
+  homogeneous_apply_refs_sized<numElements>([&inputs](auto& element) { return analysis_task_parsers::appendCondition(inputs, element); }, *task.get());
 
   /// parse process functions defined by corresponding configurables
   if constexpr (requires { &T::process; }) {
     AnalysisDataProcessorBuilder::inputsFromArgs(&T::process, "default", true, inputs, expressionInfos);
   }
-  homogeneous_apply_refs(
+  homogeneous_apply_refs_sized<numElements>(
     [name = name_str, &expressionInfos, &inputs](auto& x) mutable {
       // this pushes (argumentIndex, processHash, schemaPtr, nullptr) into expressionInfos for arguments that are Filtered/filtered_iterators
       return AnalysisDataProcessorBuilder::requestInputsFromArgs(x, name, inputs, expressionInfos);
@@ -541,39 +547,39 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
 
   // request base tables for spawnable extended tables and indices to be built
   // this checks for duplications
-  homogeneous_apply_refs([&inputs](auto& element) {
+  homogeneous_apply_refs_sized<numElements>([&inputs](auto& element) {
     return analysis_task_parsers::requestInputs(inputs, element);
   },
-                         *task.get());
+                                            *task.get());
 
   // no static way to check if the task defines any processing, we can only make sure it subscribes to at least something
   if (inputs.empty() == true) {
     LOG(warn) << "Task " << name_str << " has no inputs";
   }
 
-  homogeneous_apply_refs([&outputs, &hash](auto& element) { return analysis_task_parsers::appendOutput(outputs, element, hash); }, *task.get());
+  homogeneous_apply_refs_sized<numElements>([&outputs, &hash](auto& element) { return analysis_task_parsers::appendOutput(outputs, element, hash); }, *task.get());
 
   auto requiredServices = CommonServices::defaultServices();
   auto arrowServices = CommonServices::arrowServices();
   requiredServices.insert(requiredServices.end(), arrowServices.begin(), arrowServices.end());
-  homogeneous_apply_refs([&requiredServices](auto& element) { return analysis_task_parsers::addService(requiredServices, element); }, *task.get());
+  homogeneous_apply_refs_sized<numElements>([&requiredServices](auto& element) { return analysis_task_parsers::addService(requiredServices, element); }, *task.get());
 
   auto algo = AlgorithmSpec::InitCallback{[task = task, expressionInfos](InitContext& ic) mutable {
     Cache bindingsKeys;
     Cache bindingsKeysUnsorted;
     // add preslice declarations to slicing cache definition
-    homogeneous_apply_refs([&bindingsKeys, &bindingsKeysUnsorted](auto& element) { return analysis_task_parsers::registerCache(element, bindingsKeys, bindingsKeysUnsorted); }, *task.get());
+    homogeneous_apply_refs_sized<numElements>([&bindingsKeys, &bindingsKeysUnsorted](auto& element) { return analysis_task_parsers::registerCache(element, bindingsKeys, bindingsKeysUnsorted); }, *task.get());
 
-    homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareOption(ic, element); }, *task.get());
-    homogeneous_apply_refs([&ic](auto&& element) { return analysis_task_parsers::prepareService(ic, element); }, *task.get());
+    homogeneous_apply_refs_sized<numElements>([&ic](auto&& element) { return analysis_task_parsers::prepareOption(ic, element); }, *task.get());
+    homogeneous_apply_refs_sized<numElements>([&ic](auto&& element) { return analysis_task_parsers::prepareService(ic, element); }, *task.get());
 
     auto& callbacks = ic.services().get<CallbackService>();
     auto eoscb = [task](EndOfStreamContext& eosContext) {
-      homogeneous_apply_refs([&eosContext](auto& element) {
+      homogeneous_apply_refs_sized<numElements>([&eosContext](auto& element) {
           analysis_task_parsers::postRunService(eosContext, element);
           analysis_task_parsers::postRunOutput(eosContext, element);
           return true; },
-                             *task.get());
+                                                *task.get());
       eosContext.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     };
 
@@ -585,84 +591,75 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
     }
 
     /// update configurables in filters and partitions
-    homogeneous_apply_refs(
+    homogeneous_apply_refs_sized<numElements>(
       [&ic](auto& element) -> bool { return analysis_task_parsers::updatePlaceholders(ic, element); },
       *task.get());
     /// create expression trees for filters gandiva trees matched to schemas and store the pointers into expressionInfos
-    homogeneous_apply_refs([&expressionInfos](auto& element) {
+    homogeneous_apply_refs_sized<numElements>([&expressionInfos](auto& element) {
       return analysis_task_parsers::createExpressionTrees(expressionInfos, element);
     },
-                           *task.get());
+                                              *task.get());
 
     /// parse process functions to enable requested grouping caches - note that at this state process configurables have their final values
     if constexpr (requires { &T::process; }) {
       AnalysisDataProcessorBuilder::cacheFromArgs(&T::process, true, bindingsKeys, bindingsKeysUnsorted);
     }
-    homogeneous_apply_refs(
-      [&bindingsKeys, &bindingsKeysUnsorted](auto& x) mutable {
+    homogeneous_apply_refs_sized<numElements>(
+      [&bindingsKeys, &bindingsKeysUnsorted](auto& x) {
         return AnalysisDataProcessorBuilder::requestCacheFromArgs(x, bindingsKeys, bindingsKeysUnsorted);
       },
       *task.get());
 
     ic.services().get<ArrowTableSlicingCacheDef>().setCaches(std::move(bindingsKeys));
     ic.services().get<ArrowTableSlicingCacheDef>().setCachesUnsorted(std::move(bindingsKeysUnsorted));
-    // initialize global caches
-    homogeneous_apply_refs([&ic](auto& element) {
-      return analysis_task_parsers::preInitializeCache(ic, element);
-    },
-                           *(task.get()));
 
     return [task, expressionInfos](ProcessingContext& pc) mutable {
       // load the ccdb object from their cache
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::newDataframeCondition(pc.inputs(), element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::newDataframeCondition(pc.inputs(), element); }, *task.get());
       // reset partitions once per dataframe
-      homogeneous_apply_refs([](auto& element) { return analysis_task_parsers::newDataframePartition(element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([](auto& element) { return analysis_task_parsers::newDataframePartition(element); }, *task.get());
       // reset selections for the next dataframe
-      for (auto& info : expressionInfos) {
-        info.resetSelection = true;
-      }
+      std::ranges::for_each(expressionInfos, [](auto& info) { info.resetSelection = true; });
       // reset pre-slice for the next dataframe
       auto slices = pc.services().get<ArrowTableSlicingCache>();
-      homogeneous_apply_refs([&slices](auto& element) {
+      homogeneous_apply_refs_sized<numElements>([&slices](auto& element) {
         return analysis_task_parsers::updateSliceInfo(element, slices);
       },
-                             *(task.get()));
+                                                *(task.get()));
       // initialize local caches
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::initializeCache(pc, element); }, *(task.get()));
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::initializeCache(pc, element); }, *(task.get()));
       // prepare outputs
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::prepareOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::prepareOutput(pc, element); }, *task.get());
       // execute run()
       if constexpr (requires { task->run(pc); }) {
         task->run(pc);
       }
       // execute process()
-      if constexpr (requires { AnalysisDataProcessorBuilder::invokeProcess(*(task.get()), pc.inputs(), &T::process, expressionInfos, slices); }) {
+      if constexpr (requires { &T::process; }) {
         AnalysisDataProcessorBuilder::invokeProcess(*(task.get()), pc.inputs(), &T::process, expressionInfos, slices);
       }
       // execute optional process()
-      homogeneous_apply_refs(
-        [&pc, &expressionInfos, &task, &slices](auto& x) mutable {
-          if constexpr (base_of_template<ProcessConfigurable, std::decay_t<decltype(x)>>) {
+      homogeneous_apply_refs_sized<numElements>(
+        [&pc, &expressionInfos, &task, &slices](auto& x) {
+          if constexpr (is_process_configurable<decltype(x)>) {
             if (x.value == true) {
               AnalysisDataProcessorBuilder::invokeProcess(*task.get(), pc.inputs(), x.process, expressionInfos, slices);
               return true;
             }
+            return false;
           }
           return false;
         },
         *task.get());
       // prepare delayed outputs
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::prepareDelayedOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::prepareDelayedOutput(pc, element); }, *task.get());
       // finalize outputs
-      homogeneous_apply_refs([&pc](auto& element) { return analysis_task_parsers::finalizeOutput(pc, element); }, *task.get());
+      homogeneous_apply_refs_sized<numElements>([&pc](auto& element) { return analysis_task_parsers::finalizeOutput(pc, element); }, *task.get());
     };
   }};
 
   return {
     name,
-    // FIXME: For the moment we hardcode this. We could build
-    // this list from the list of methods actually implemented in the
-    // task itself.
     inputs,
     outputs,
     algo,
diff --git a/Framework/Core/include/Framework/Configurable.h b/Framework/Core/include/Framework/Configurable.h
index 3ef90a0eee166..0931884da1ff7 100644
--- a/Framework/Core/include/Framework/Configurable.h
+++ b/Framework/Core/include/Framework/Configurable.h
@@ -84,10 +84,10 @@ template <typename T, ConfigParamKind K = ConfigParamKind::kGeneric>
 using MutableConfigurable = Configurable<T, K, ConfigurablePolicyMutable<T, K>>;
 
 template <typename T>
-concept is_configurable = requires(T& t) {
-  typename T::type;
+concept is_configurable = requires(T t) {
   requires std::same_as<std::string, decltype(t.name)>;
-  &T::operator typename T::type;
+  requires std::same_as<std::string, decltype(t.help)>;
+  requires std::same_as<typename std::decay_t<T>::type, decltype(t.value)>;
 };
 
 using ConfigurableAxis = Configurable<std::vector<double>, ConfigParamKind::kAxisSpec, ConfigurablePolicyConst<std::vector<double>, ConfigParamKind::kAxisSpec>>;
@@ -99,19 +99,18 @@ concept is_configurable_axis = is_configurable<T>&&
   T::kind == ConfigParamKind::kAxisSpec;
 };
 
-template <typename R, typename T, typename... As>
+template <typename T, typename... As>
 struct ProcessConfigurable : Configurable<bool, ConfigParamKind::kProcessFlag> {
-  ProcessConfigurable(R (T::*process_)(As...), std::string const& name_, bool&& value_, std::string const& help_)
+  ProcessConfigurable(void (T::*process_)(As...), std::string const& name_, bool&& value_, std::string const& help_)
     : process{process_},
       Configurable<bool, ConfigParamKind::kProcessFlag>(name_, std::forward<bool>(value_), help_)
   {
   }
-  R(T::*process)
-  (As...);
+  void (T::*process)(As...);
 };
 
 template <typename T>
-concept is_process_configurable = is_configurable<T> && requires(T& t) { t.process; };
+concept is_process_configurable = is_configurable<T> && requires(T t) { t.process; };
 
 #define PROCESS_SWITCH(_Class_, _Name_, _Help_, _Default_) \
   decltype(o2::framework::ProcessConfigurable{&_Class_ ::_Name_, #_Name_, _Default_, _Help_}) do##_Name_ = o2::framework::ProcessConfigurable{&_Class_ ::_Name_, #_Name_, _Default_, _Help_};
diff --git a/Framework/Core/test/test_Concepts.cxx b/Framework/Core/test/test_Concepts.cxx
index ea94c4dfffe5a..982c748e701e4 100644
--- a/Framework/Core/test/test_Concepts.cxx
+++ b/Framework/Core/test/test_Concepts.cxx
@@ -174,6 +174,7 @@ TEST_CASE("IdentificationConcepts")
   REQUIRE(is_configurable_axis<decltype(ca)>);
 
   REQUIRE(is_process_configurable<decltype(P::doprocess1)>);
+  REQUIRE(is_process_configurable<decltype((P::doprocess1))>);
 
   struct : ConfigurableGroup {
     Configurable<int> c{"", 1, ""};
diff --git a/Framework/Foundation/include/Framework/StructToTuple.h b/Framework/Foundation/include/Framework/StructToTuple.h
index 5748329f6a50d..1c7aa62260bd3 100644
--- a/Framework/Foundation/include/Framework/StructToTuple.h
+++ b/Framework/Foundation/include/Framework/StructToTuple.h
@@ -174,9 +174,9 @@ consteval int nested_brace_constructible_size()
   return brace_constructible_size<type>() - nesting;
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 9)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -194,9 +194,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 8)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -214,9 +214,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 7)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -234,9 +234,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 6)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -254,9 +254,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 5)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -274,9 +274,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 4)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -294,9 +294,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 3)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -314,9 +314,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 2)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -334,9 +334,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 1)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -354,9 +354,9 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
-template <bool B = false, typename L, class T, int D = nested_brace_constructible_size<B, T>() / 10>
+template <bool B = false, class T, int D = nested_brace_constructible_size<B, T>() / 10, typename L>
   requires(D == 0)
-auto homogeneous_apply_refs(L l, T&& object)
+constexpr auto homogeneous_apply_refs(L l, T&& object)
 {
   constexpr int numElements = nested_brace_constructible_size<B, T>();
   // clang-format off
@@ -373,6 +373,12 @@ auto homogeneous_apply_refs(L l, T&& object)
   // clang-format on
 }
 
+template <int D, typename T, typename L>
+constexpr auto homogeneous_apply_refs_sized(L l, T&& object)
+{
+  return homogeneous_apply_refs<false, T, D, L>(l, object);
+}
+
 } // namespace o2::framework
 
 #endif // O2_FRAMEWORK_STRUCTTOTUPLE_H_

From 0355d19f2aad1726cdd020029b5eef7b9bb4625b Mon Sep 17 00:00:00 2001
From: Marco van Leeuwen <marco.van.leeuwen@cern.ch>
Date: Tue, 17 Feb 2026 19:12:33 +0100
Subject: [PATCH 1331/1764] [ALICE3] Fix geometry overlaps in tracker (ML/OT)
 (#15072)

---
 .../ALICE3/FT3/simulation/src/FT3Module.cxx   |  2 +-
 .../ALICE3/TRK/simulation/src/TRKServices.cxx | 42 +++++++++----------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
index efcad74bc2cb9..9e24247958c06 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -108,7 +108,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
   double carbonFiberThickness = 0.01;
 
-  double foamSpacingThickness = 0.5;
+  double foamSpacingThickness = 1.0;
 
   int dist_offset = 0;
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index cbe00e8fc9e89..25c59b3c8fd4a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -320,26 +320,26 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
   const float rMaxMiddleBarrelDisk = 35.f;
   const float zLengthMiddleBarrel = 64.2f;
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
-    TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube(Form("TRK_MIDBARCONN_DISK_SIO2sh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, siO2FiberThick);
-    TGeoTube* middleBarrelConnDiskPE = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, peFiberThick);
+    TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube(Form("TRK_MIDBARCONN_DISK_SIO2sh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, siO2FiberThick / 2.);
+    TGeoTube* middleBarrelConnDiskPE = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, peFiberThick / 2.);
     TGeoVolume* middleBarrelConnDiskSIO2Volume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_SIO2_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskSIO2, medSiO2);
     TGeoVolume* middleBarrelConnDiskPEVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_PE_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskPE, medPE);
     middleBarrelConnDiskSIO2Volume->SetLineColor(kGray);
     middleBarrelConnDiskPEVolume->SetLineColor(kGray);
     auto* rot = new TGeoRotation("", 0, 0, 180);
-    auto* combiTransSIO2 = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick / 2 + zLengthMiddleBarrel), rot);
-    auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick / 2 + zLengthMiddleBarrel), rot);
+    auto* combiTransSIO2 = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick / 2. + zLengthMiddleBarrel), rot);
+    auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick / 2. + zLengthMiddleBarrel), rot);
     motherVolume->AddNode(middleBarrelConnDiskSIO2Volume, 1, combiTransSIO2);
     motherVolume->AddNode(middleBarrelConnDiskPEVolume, 1, combiTransPE);
 
-    TGeoTube* middleBarrelConnDiskCu = new TGeoTube(Form("TRK_MIDBARCONN_DISK_CUsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, cuPowerThick);
-    TGeoTube* middleBarrelConnDiskPEPower = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, pePowerThick);
+    TGeoTube* middleBarrelConnDiskCu = new TGeoTube(Form("TRK_MIDBARCONN_DISK_CUsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, cuPowerThick / 2.);
+    TGeoTube* middleBarrelConnDiskPEPower = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, pePowerThick / 2.);
     TGeoVolume* middleBarrelConnDiskCuVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_CU_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskCu, medCu);
     TGeoVolume* middleBarrelConnDiskPEPowerVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_PE_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskPEPower, medPE);
     middleBarrelConnDiskCuVolume->SetLineColor(kGray);
     middleBarrelConnDiskPEPowerVolume->SetLineColor(kGray);
-    auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick / 2 + zLengthMiddleBarrel), rot);
-    auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick / 2 + zLengthMiddleBarrel), rot);
+    auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick / 2. + zLengthMiddleBarrel), rot);
+    auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick / 2. + zLengthMiddleBarrel), rot);
     motherVolume->AddNode(middleBarrelConnDiskCuVolume, 1, combiTransCu);
     motherVolume->AddNode(middleBarrelConnDiskPEPowerVolume, 1, combiTransPEPower);
 
@@ -357,39 +357,39 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
   float rMaxMiddleServicesBarFwd = 74.5f + siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick + puCoolingThick + h2oCoolingThick;
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
     // Create fibers: 3.07mm, 50% SiO2, 50% PE
-    TGeoTube* middleBarFwdFiberSIO2 = new TGeoTube("TRK_MIDBARFWD_FIBER_SIO2sh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, siO2FiberThick);
-    TGeoTube* middleBarFwdFiberPE = new TGeoTube("TRK_MIDBARFWD_FIBER_PEsh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, peFiberThick);
+    TGeoTube* middleBarFwdFiberSIO2 = new TGeoTube("TRK_MIDBARFWD_FIBER_SIO2sh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, siO2FiberThick / 2.);
+    TGeoTube* middleBarFwdFiberPE = new TGeoTube("TRK_MIDBARFWD_FIBER_PEsh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, peFiberThick / 2.);
     TGeoVolume* middleBarFwdFiberSIO2Volume = new TGeoVolume("TRK_MIDBARFWD_FIBER_SIO2", middleBarFwdFiberSIO2, medSiO2);
     TGeoVolume* middleBarFwdFiberPEVolume = new TGeoVolume("TRK_MIDBARFWD_FIBER_PE", middleBarFwdFiberPE, medPE);
     middleBarFwdFiberSIO2Volume->SetLineColor(kGray);
     middleBarFwdFiberPEVolume->SetLineColor(kGray);
     auto* rot = new TGeoRotation("", 0, 0, 180);
-    auto* combiTransSIO2 = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick / 2 + zLengthMiddleServices), rot);
-    auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick / 2 + zLengthMiddleServices), rot);
+    auto* combiTransSIO2 = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick / 2. + zLengthMiddleServices), rot);
+    auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick / 2. + zLengthMiddleServices), rot);
     motherVolume->AddNode(middleBarFwdFiberSIO2Volume, 1, combiTransSIO2);
     motherVolume->AddNode(middleBarFwdFiberPEVolume, 1, combiTransPE);
 
     // Create powerlines: 10.9mm, 9% Cu, 91% PE
-    TGeoTube* middleBarFwdPowerCu = new TGeoTube("TRK_MIDBARFWD_POWER_CUsh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, cuPowerThick);
-    TGeoTube* middleBarFwdPowerPE = new TGeoTube("TRK_MIDBARFWD_POWER_PEsh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, pePowerThick);
+    TGeoTube* middleBarFwdPowerCu = new TGeoTube("TRK_MIDBARFWD_POWER_CUsh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, cuPowerThick / 2.);
+    TGeoTube* middleBarFwdPowerPE = new TGeoTube("TRK_MIDBARFWD_POWER_PEsh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, pePowerThick / 2.);
     TGeoVolume* middleBarFwdPowerCuVolume = new TGeoVolume("TRK_MIDBARFWD_POWER_CU", middleBarFwdPowerCu, medCu);
     TGeoVolume* middleBarFwdPowerPEVolume = new TGeoVolume("TRK_MIDBARFWD_POWER_PE", middleBarFwdPowerPE, medPE);
     middleBarFwdPowerCuVolume->SetLineColor(kGray);
     middleBarFwdPowerPEVolume->SetLineColor(kGray);
-    auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick / 2 + zLengthMiddleServices), rot);
-    auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick / 2 + zLengthMiddleServices), rot);
+    auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick / 2. + zLengthMiddleServices), rot);
+    auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick / 2. + zLengthMiddleServices), rot);
     motherVolume->AddNode(middleBarFwdPowerCuVolume, 1, combiTransCu);
     motherVolume->AddNode(middleBarFwdPowerPEVolume, 1, combiTransPEPower);
 
     // Create cooling pipes: 4.74mm, 56% PU, 44% H2O
-    TGeoTube* middleBarFwdCoolingPU = new TGeoTube("TRK_MIDBARFWD_COOLING_PUsh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, puCoolingThick);
-    TGeoTube* middleBarFwdCoolingH2O = new TGeoTube("TRK_MIDBARFWD_COOLING_H2Osh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, h2oCoolingThick);
+    TGeoTube* middleBarFwdCoolingPU = new TGeoTube("TRK_MIDBARFWD_COOLING_PUsh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, puCoolingThick / 2.);
+    TGeoTube* middleBarFwdCoolingH2O = new TGeoTube("TRK_MIDBARFWD_COOLING_H2Osh", rMinMiddleBarrel, rMaxMiddleServicesBarFwd, h2oCoolingThick / 2.);
     TGeoVolume* middleBarFwdCoolingPUVolume = new TGeoVolume("TRK_MIDBARFWD_COOLING_PU", middleBarFwdCoolingPU, medPU);
     TGeoVolume* middleBarFwdCoolingH2OVolume = new TGeoVolume("TRK_MIDBARFWD_COOLING_H2O", middleBarFwdCoolingH2O, medH2O);
     middleBarFwdCoolingPUVolume->SetLineColor(kGray);
     middleBarFwdCoolingH2OVolume->SetLineColor(kGray);
-    auto* combiTransCoolingPU = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick + puCoolingThick / 2 + zLengthMiddleServices), rot);
-    auto* combiTransCoolingH2O = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick + puCoolingThick + h2oCoolingThick / 2 + zLengthMiddleServices), rot);
+    auto* combiTransCoolingPU = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick + puCoolingThick / 2. + zLengthMiddleServices), rot);
+    auto* combiTransCoolingH2O = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick + puCoolingThick + h2oCoolingThick / 2. + zLengthMiddleServices), rot);
     motherVolume->AddNode(middleBarFwdCoolingPUVolume, 1, combiTransCoolingPU);
     motherVolume->AddNode(middleBarFwdCoolingH2OVolume, 1, combiTransCoolingH2O);
   }
@@ -501,4 +501,4 @@ void TRKServices::createOuterBarrelServices(TGeoVolume* motherVolume)
   motherVolume->AddNode(outerBarrelCoolingH2OVolume, 1, nullptr);
 }
 } // namespace trk
-} // namespace o2
\ No newline at end of file
+} // namespace o2

From e57a6edf96c71b344ede9fe78b4b0e3c69335069 Mon Sep 17 00:00:00 2001
From: Pavel Larionov <pavel.larionov@cern.ch>
Date: Tue, 17 Feb 2026 19:15:56 +0100
Subject: [PATCH 1332/1764] Configurable VD design, set def to IRIS 4, remove
 IRIS disks (#15055)

---
 .../TRK/base/include/TRKBase/TRKBaseParam.h   |  9 ++++++
 .../ALICE3/TRK/simulation/src/Detector.cxx    | 28 ++++++++++++++++---
 .../TRK/simulation/src/VDGeometryBuilder.cxx  |  2 +-
 3 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index 7f2f7f32b79d9..d5e11313c0f0c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -31,6 +31,13 @@ enum eLayout {
   kStaggered,
 };
 
+enum eVDLayout {
+  kIRIS4 = 0,
+  kIRISFullCyl,
+  kIRIS5,
+  kIRIS4a,
+};
+
 struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   std::string configFile = "";
   float serviceTubeX0 = 0.02f; // X0 Al2O3
@@ -40,9 +47,11 @@ struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
 
   eLayout layoutML = kTurboStaves; // Type of segmentation for the middle layers
   eLayout layoutOL = kStaggered;   // Type of segmentation for the outer layers
+  eVDLayout layoutVD = kIRIS4;     // VD detector layout design
 
   eLayout getLayoutML() const { return layoutML; }
   eLayout getLayoutOL() const { return layoutOL; }
+  eVDLayout getLayoutVD() const { return layoutVD; }
 
   O2ParamDef(TRKBaseParam, "TRKBase");
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 06fd2d9670b67..556b016f22553 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -261,12 +261,32 @@ void Detector::createGeometry()
   mServices.createServices(vTRK);
 
   // Build the VD using the petal builder
-  // Choose the VD design (here: IRIS4 by default).
-  // You can wire this to a parameter in TRKBaseParam if desired.
-  // Alternatives: createIRIS5Geometry(vTRK); createIRIS4aGeometry(vTRK);
+  // Choose the VD design based on TRKBaseParam.layoutVD
+  auto& trkPars = TRKBaseParam::Instance();
 
   o2::trk::clearVDSensorRegistry();
-  o2::trk::createIRISGeometryFullCyl(vTRK);
+
+  switch (trkPars.layoutVD) {
+    case kIRIS4:
+      LOG(info) << "Building VD with IRIS4 layout";
+      o2::trk::createIRIS4Geometry(vTRK);
+      break;
+    case kIRISFullCyl:
+      LOG(info) << "Building VD with IRIS fully cylindrical layout";
+      o2::trk::createIRISGeometryFullCyl(vTRK);
+      break;
+    case kIRIS5:
+      LOG(info) << "Building VD with IRIS5 layout";
+      o2::trk::createIRIS5Geometry(vTRK);
+      break;
+    case kIRIS4a:
+      LOG(info) << "Building VD with IRIS4a layout";
+      o2::trk::createIRIS4aGeometry(vTRK);
+      break;
+    default:
+      LOG(fatal) << "Unknown VD layout option: " << static_cast<int>(trkPars.layoutVD);
+      break;
+  }
 
   // Fill sensor names from registry right after geometry creation
   const auto& regs = o2::trk::vdSensorRegistry();
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
index 6ce04bb8443ef..b06faa38211bb 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
@@ -749,7 +749,7 @@ static TGeoVolume* buildPetalAssembly(int nPetals,
                 /*fullCylindricalRadialWalls=*/fullCylinders);
 
   addBarrelLayers(petalAsm, nPetals, petalID, rectangularL0, fullCylinders);
-  addDisks(petalAsm, nPetals, petalID, fullCylinders);
+  // addDisks(petalAsm, nPetals, petalID, fullCylinders); // disks removed according to the v3b layout
 
   addColdPlate(petalAsm, nPetals, petalID, /*fullCylinders=*/false);
   addIRISServiceModulesSegmented(petalAsm, nPetals);

From e5768cde630297876b47f1c24b5da3489f56228a Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Tue, 17 Feb 2026 19:16:53 +0100
Subject: [PATCH 1333/1764] ALICE3-TRK: adapt ordering key for digits to the
 large number of columns in the VD (#15070)

---
 .../simulation/include/TRKSimulation/ChipDigitsContainer.h  | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
index 658fb823bb596..73c95b04c45e3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
@@ -29,6 +29,12 @@ class ChipDigitsContainer : public o2::itsmft::ChipDigitsContainer
 
   using Segmentation = SegmentationChip;
 
+  /// Get global ordering key made of readout frame, column and row
+  static ULong64_t getOrderingKey(UInt_t roframe, UShort_t row, UShort_t col)
+  {
+    return (static_cast<ULong64_t>(roframe) << (8 * sizeof(UInt_t))) + (static_cast<ULong64_t>(col) << (8 * sizeof(Short_t))) + row;
+  }
+
   ClassDefNV(ChipDigitsContainer, 1);
 };
 

From 06150434b8a30967fb5449016758b0441748f0b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Tue, 17 Feb 2026 21:54:34 +0100
Subject: [PATCH 1334/1764] A3: Add geometries for IOTOF (#15073)

- fix enabling and disabling of backward TOF
- add v3b versions of IOTOF
---
 .../base/include/IOTOFBase/IOTOFBaseParam.h   |  1 +
 .../include/IOTOFSimulation/Detector.h        |  2 +-
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  | 73 ++++++++++++++-----
 3 files changed, 56 insertions(+), 20 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
index 10d8c5ced94dd..bf605797cbfe5 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
@@ -25,6 +25,7 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
   bool enableOuterTOF = true;
   bool enableForwardTOF = true;
   bool enableBackwardTOF = true;
+  std::string detectorPattern = "";
 
   O2ParamDef(IOTOFBaseParam, "IOTOFBase");
 };
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
index 1f3b2f4fe9fac..f39a43733ccab 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
@@ -60,7 +60,7 @@ class Detector : public o2::base::DetImpl<Detector>
     return nullptr;
   }
 
-  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true);
+  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "");
 
   void configServices();
   void createMaterials();
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index a2bba7cc5fe35..3a971e81a610d 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -20,8 +20,6 @@
 #include "IOTOFSimulation/Detector.h"
 #include "IOTOFBase/IOTOFBaseParam.h"
 
-using o2::itsmft::Hit;
-
 namespace o2
 {
 namespace iotof
@@ -40,7 +38,9 @@ Detector::Detector(bool active)
     mHits(o2::utils::createSimVector<o2::itsmft::Hit>())
 {
   auto& iotofPars = IOTOFBaseParam::Instance();
-  configLayers(iotofPars.enableInnerTOF, iotofPars.enableOuterTOF, iotofPars.enableForwardTOF);
+  configLayers(iotofPars.enableInnerTOF, iotofPars.enableOuterTOF,
+               iotofPars.enableForwardTOF, iotofPars.enableBackwardTOF,
+               iotofPars.detectorPattern);
 }
 
 Detector::~Detector()
@@ -56,19 +56,54 @@ void Detector::ConstructGeometry()
   createGeometry();
 }
 
-void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof)
+void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::string pattern)
 {
+
+  float radiusInnerTof = 19.f;
+  float radiusOuterTof = 85.f;
+  float lengthInnerTof = 124.f;
+  float lengthOuterTof = 680.f;
+  std::pair<float, float> radiusRangeDiskTof = {15.f, 100.f};
+  float zForwardTof = 370.f;
+  if (pattern == "") {
+  } else if (pattern == "v3b") {
+    LOG(info) << "Configuring IOTOF layers with v3b pattern";
+    ftof = false;
+    btof = false;
+  } else if (pattern == "v3b1a") {
+    lengthOuterTof = 500.f;
+    zForwardTof = 270.f;
+    radiusRangeDiskTof = {30.f, 100.f};
+  } else if (pattern == "v3b1b") {
+    lengthOuterTof = 500.f;
+    zForwardTof = 200.f;
+    radiusRangeDiskTof = {20.f, 68.f};
+  } else if (pattern == "v3b2a") {
+    lengthOuterTof = 440.f;
+    zForwardTof = 270.f;
+    radiusRangeDiskTof = {30.f, 120.f};
+  } else if (pattern == "v3b2b") {
+    lengthOuterTof = 440.f;
+    zForwardTof = 200.f;
+    radiusRangeDiskTof = {20.f, 68.f};
+  } else if (pattern == "v3b3") {
+    lengthOuterTof = 580.f;
+    zForwardTof = 200.f;
+    radiusRangeDiskTof = {20.f, 68.f};
+  } else {
+    LOG(fatal) << "IOTOF layer pattern " << pattern << " not recognized, exiting";
+  }
   if (itof) {
-    mITOFLayer = ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()}, 19.f, 0.f, 124.f, 0.f, 0.02f, true); // iTOF
+    mITOFLayer = ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()}, radiusInnerTof, 0.f, lengthInnerTof, 0.f, 0.02f, true); // iTOF
   }
   if (otof) {
-    mOTOFLayer = OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()}, 85.f, 0.f, 680.f, 0.f, 0.02f, true); // oTOF
+    mOTOFLayer = OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()}, radiusOuterTof, 0.f, lengthOuterTof, 0.f, 0.02f, true); // oTOF
   }
   if (ftof) {
-    mFTOFLayer = FTOFLayer(std::string{GeometryTGeo::getFTOFLayerPattern()}, 15.f, 100.f, 0.f, 370.f, 0.02f, false); // fTOF
+    mFTOFLayer = FTOFLayer(std::string{GeometryTGeo::getFTOFLayerPattern()}, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, zForwardTof, 0.02f, false); // fTOF
   }
   if (btof) {
-    mBTOFLayer = BTOFLayer(std::string{GeometryTGeo::getBTOFLayerPattern()}, 15.f, 100.f, 0.f, -370.f, 0.02f, false); // bTOF
+    mBTOFLayer = BTOFLayer(std::string{GeometryTGeo::getBTOFLayerPattern()}, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, -zForwardTof, 0.02f, false); // bTOF
   }
 }
 
@@ -214,28 +249,28 @@ bool Detector::ProcessHits(FairVolume* vol)
   bool startHit = false, stopHit = false;
   unsigned char status = 0;
   if (fMC->IsTrackEntering()) {
-    status |= Hit::kTrackEntering;
+    status |= o2::itsmft::Hit::kTrackEntering;
   }
   if (fMC->IsTrackInside()) {
-    status |= Hit::kTrackInside;
+    status |= o2::itsmft::Hit::kTrackInside;
   }
   if (fMC->IsTrackExiting()) {
-    status |= Hit::kTrackExiting;
+    status |= o2::itsmft::Hit::kTrackExiting;
   }
   if (fMC->IsTrackOut()) {
-    status |= Hit::kTrackOut;
+    status |= o2::itsmft::Hit::kTrackOut;
   }
   if (fMC->IsTrackStop()) {
-    status |= Hit::kTrackStopped;
+    status |= o2::itsmft::Hit::kTrackStopped;
   }
   if (fMC->IsTrackAlive()) {
-    status |= Hit::kTrackAlive;
+    status |= o2::itsmft::Hit::kTrackAlive;
   }
 
   // track is entering or created in the volume
-  if ((status & Hit::kTrackEntering) || (status & Hit::kTrackInside && !mTrackData.mHitStarted)) {
+  if ((status & o2::itsmft::Hit::kTrackEntering) || (status & o2::itsmft::Hit::kTrackInside && !mTrackData.mHitStarted)) {
     startHit = true;
-  } else if ((status & (Hit::kTrackExiting | Hit::kTrackOut | Hit::kTrackStopped))) {
+  } else if ((status & (o2::itsmft::Hit::kTrackExiting | o2::itsmft::Hit::kTrackOut | o2::itsmft::Hit::kTrackStopped))) {
     stopHit = true;
   }
 
@@ -264,9 +299,9 @@ bool Detector::ProcessHits(FairVolume* vol)
     fMC->CurrentVolOffID(3, halfstave);
     fMC->CurrentVolOffID(4, stave);
 
-    Hit* p = addHit(stack->GetCurrentTrackNumber(), lay, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
-                    mTrackData.mMomentumStart.Vect(), mTrackData.mMomentumStart.E(), positionStop.T(),
-                    mTrackData.mEnergyLoss, mTrackData.mTrkStatusStart, status);
+    o2::itsmft::Hit* p = addHit(stack->GetCurrentTrackNumber(), lay, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
+                                mTrackData.mMomentumStart.Vect(), mTrackData.mMomentumStart.E(), positionStop.T(),
+                                mTrackData.mEnergyLoss, mTrackData.mTrkStatusStart, status);
 
     // RS: not sure this is needed
     // Increment number of Detector det points in TParticle

From 41d9be4b011d3c9cc04742b271e814661002379d Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Tue, 17 Feb 2026 22:08:43 +0100
Subject: [PATCH 1335/1764] [ALICE3] Adapt CA for 2T simulations (#15075)

---
 .../reconstruction/include/TRKReconstruction/TimeFrame.h   | 3 ---
 .../Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx   | 7 ++++++-
 Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx | 7 ++++++-
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
index d2ca6fba132e1..f42a1c897efb6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
@@ -62,9 +62,6 @@ class TimeFrame : public o2::its::TimeFrame<nLayers>
   /// \param nEvents Number of events to process
   /// \param inROFpileup Number of events per ROF
   void getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup);
-
- private:
-  ClassDefNV(TimeFrame, 1);
 };
 
 } // namespace trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
index 686270826049b..610a08450d5ee 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
@@ -64,10 +64,12 @@ int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman,
       }
       int subDetID = gman->getSubDetID(hit.GetDetectorID());
       const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
+      if (layer >= nLayers) {
+        continue;
+      }
       ++clusterCountPerLayer[layer];
       totalNHits++;
     }
-    trkHit->clear();
   }
 
   // Reserve memory for all layers
@@ -106,6 +108,9 @@ int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman,
       o2::math_utils::Point3D<float> gloXYZ;
       o2::math_utils::Point3D<float> trkXYZ;
       float r{0.f};
+      if (layer >= nLayers) {
+        continue;
+      }
       if (layer >= 3) {
         int chipID = hit.GetDetectorID();
         alpha = gman->getSensorRefAlphaMLOT(chipID);
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
index 8f26478f4496e..8fc67f0fa5567 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -10,11 +10,13 @@
 // or submit itself to any jurisdiction.
 
 #include <vector>
+#include <chrono>
 
 #include "DetectorsBase/GeometryManager.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Configuration.h"
 #include "Field/MagneticField.h"
+#include "Field/MagFieldParam.h"
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
@@ -276,7 +278,7 @@ void TrackerDPL::run(ProcessingContext& pc)
     itsTrackerTraits.adoptTimeFrame(static_cast<o2::its::TimeFrame<11>*>(&timeFrame));
     itsTracker.adoptTimeFrame(timeFrame);
     itsTrackerTraits.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
-    auto field = o2::field::MagneticField::createNominalField(std::round(mHitRecoConfig["geometry"]["bz"].get<float>()), true);
+    auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mHitRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
     TGeoGlobalMagField::Instance()->SetField(field);
     TGeoGlobalMagField::Instance()->Lock();
 
@@ -291,6 +293,7 @@ void TrackerDPL::run(ProcessingContext& pc)
 
     itsTrackerTraits.updateTrackingParameters(trackingParams);
 
+    const auto trackingLoopStart = std::chrono::steady_clock::now();
     for (size_t iter{0}; iter < trackingParams.size(); ++iter) {
       LOGP(info, "{}", trackingParams[iter].asString());
       timeFrame.initialise(iter, trackingParams[iter], 11, false);
@@ -304,6 +307,8 @@ void TrackerDPL::run(ProcessingContext& pc)
       LOGP(info, "Number of roads in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
       itsTrackerTraits.extendTracks(iter);
     }
+    const auto trackingLoopElapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - trackingLoopStart).count();
+    LOGP(info, "Tracking iterations block took {} ms", trackingLoopElapsedMs);
 
     itsTracker.computeTracksMClabels();
 

From d95be4db7b5fe479e7adbe8b45094f628d6d97ea Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Tue, 17 Feb 2026 19:47:42 +0100
Subject: [PATCH 1336/1764] o2-sim: Possibility to switch between TGeo and
 Geant4 navigation

---
 Common/SimConfig/include/SimConfig/G4Params.h |  9 +++++++++
 Common/SimConfig/src/SimConfigLinkDef.h       |  1 +
 Detectors/gconfig/g4Config.C                  | 11 ++++++++++-
 Steer/src/O2MCApplication.cxx                 |  6 ++++++
 4 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/Common/SimConfig/include/SimConfig/G4Params.h b/Common/SimConfig/include/SimConfig/G4Params.h
index fd36ae046d520..aa8aa05263c0a 100644
--- a/Common/SimConfig/include/SimConfig/G4Params.h
+++ b/Common/SimConfig/include/SimConfig/G4Params.h
@@ -33,6 +33,13 @@ enum class EG4Physics {
   kUSER = 8                           /* allows to give own string combination */
 };
 
+// enumerating possible geometry navigation modes
+// (understanding that geometry description is always done with TGeo)
+enum class EG4Nav {
+  kTGeo = 0, /* navigate with TGeo */
+  kG4 = 1    /* navigate with G4 native geometry */
+};
+
 // parameters to influence the G4 engine
 struct G4Params : public o2::conf::ConfigurableParamHelper<G4Params> {
   EG4Physics physicsmode = EG4Physics::kFTFP_BERT_EMV_optical; // default physics mode with which to configure G4
@@ -40,6 +47,8 @@ struct G4Params : public o2::conf::ConfigurableParamHelper<G4Params> {
   std::string configMacroFile = ""; // a user provided g4Config.in file (otherwise standard one fill be taken)
   std::string userPhysicsList = ""; // possibility to directly give physics list as string
 
+  EG4Nav navmode = EG4Nav::kTGeo; // geometry navigation mode (default TGeo)
+
   std::string const& getPhysicsConfigString() const;
 
   O2ParamDef(G4Params, "G4");
diff --git a/Common/SimConfig/src/SimConfigLinkDef.h b/Common/SimConfig/src/SimConfigLinkDef.h
index 9c27536be5eb8..a1315e24ffedd 100644
--- a/Common/SimConfig/src/SimConfigLinkDef.h
+++ b/Common/SimConfig/src/SimConfigLinkDef.h
@@ -29,6 +29,7 @@
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::conf::DigiParams> + ;
 
 #pragma link C++ enum o2::conf::EG4Physics;
+#pragma link C++ enum o2::conf::EG4Nav;
 #pragma link C++ enum o2::conf::SimFieldMode;
 #pragma link C++ struct o2::conf::G4Params + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::conf::G4Params> + ;
diff --git a/Detectors/gconfig/g4Config.C b/Detectors/gconfig/g4Config.C
index 8f74c0105dbf5..c2b1fbd433e4b 100644
--- a/Detectors/gconfig/g4Config.C
+++ b/Detectors/gconfig/g4Config.C
@@ -100,7 +100,16 @@ void Config()
   auto& g4Params = ::o2::conf::G4Params::Instance();
   auto& physicsSetup = g4Params.getPhysicsConfigString();
   std::cout << "PhysicsSetup wanted " << physicsSetup << "\n";
-  auto runConfiguration = new TG4RunConfiguration("geomRoot", physicsSetup, "stepLimiter+specialCuts",
+  std::string geomNavStr;
+  if (g4Params.navmode == o2::conf::EG4Nav::kTGeo) {
+    geomNavStr = "geomRoot";
+  } else if (g4Params.navmode == o2::conf::EG4Nav::kG4) {
+    geomNavStr = "geomVMC+RootToGeant4";
+  } else {
+    LOG(fatal) << "Unsupported geometry navigation mode";
+  }
+
+  auto runConfiguration = new TG4RunConfiguration(geomNavStr, physicsSetup, "stepLimiter+specialCuts",
                                                   specialStacking, mtMode);
   /// avoid the use of G4BACKTRACE (it seems to inferfere with process logic in o2-sim)
   setenv("G4BACKTRACE", "none", 1);
diff --git a/Steer/src/O2MCApplication.cxx b/Steer/src/O2MCApplication.cxx
index f832ab70ab121..1e3f925042d01 100644
--- a/Steer/src/O2MCApplication.cxx
+++ b/Steer/src/O2MCApplication.cxx
@@ -42,6 +42,7 @@
 #include <TGeoTessellated.h>
 #include <DetectorsBase/O2Tessellated.h>
 #include <unordered_set>
+#include "SimConfig/G4Params.h"
 
 namespace o2
 {
@@ -223,6 +224,11 @@ bool O2MCApplicationBase::MisalignGeometry()
 
 void O2MCApplicationBase::fixTGeoRuntimeShapes()
 {
+  auto& g4Params = o2::conf::G4Params::Instance();
+  if (g4Params.navmode != o2::conf::EG4Nav::kTGeo) {
+    return;
+  }
+
   // Replace TGeo shapes by other ones for performance or other reasons.
   // Should only affect runtime of simulation.
 

From d384645a99a311b75d221ca280d924a6bdfbb787 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Wed, 18 Feb 2026 15:11:43 +0100
Subject: [PATCH 1337/1764] ALICE3-TRK: fix detector ID assignment to hits
 (#15074)

---
 .../Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx    | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index b32c89164f18a..059a35520c1a0 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -416,15 +416,15 @@ TString GeometryTGeo::getMatrixPath(int index) const
   // build the path
   if (subDetID == 0) { // VD
     if (disk >= 0) {
-      path += Form("%s_%d_%d/", getTRKPetalAssemblyPattern(), petalcase, petalcase + 1);             // PETAL_n
-      path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk); // PETALCASEx_DISKy_1
-      // path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk, getTRKChipPattern(), disk);   // PETALCASEx_DISKy_TRKChipy_1
+      path += Form("%s_%d_%d/", getTRKPetalAssemblyPattern(), petalcase, petalcase + 1);                                               // PETAL_n
+      path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk);                                   // PETALCASEx_DISKy_1
+      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk, getTRKChipPattern(), disk);   // PETALCASEx_DISKy_TRKChipy_1
       path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalDiskPattern(), disk, getTRKSensorPattern(), disk); // PETALCASEx_DISKy_TRKSensory_1
     } else if (layer >= 0) {
       path += Form("%s_%d_%d/", getTRKPetalAssemblyPattern(), petalcase, petalcase + 1);               // PETAL_n
       path += Form("%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer); // PETALCASEx_LAYERy_1
       // path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKStavePattern(), layer);  // PETALCASEx_LAYERy_TRKStavey_1
-      // path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKChipPattern(), layer);   // PETALCASEx_LAYERy_TRKChipy_1
+      path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKChipPattern(), layer);   // PETALCASEx_LAYERy_TRKChipy_1
       path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKSensorPattern(), layer); // PETALCASEx_LAYERy_TRKSensory_1
     }
   } else if (subDetID == 1) {                                               // MLOT
@@ -962,9 +962,9 @@ int GeometryTGeo::extractNumberOfChipsPerPetalVD() const
 
       for (int i = 0; i < subNodes->GetEntriesFast(); i++) {
         auto* subNode = dynamic_cast<TGeoNode*>(subNodes->At(i));
-        if (strstr(subNode->GetName(), getTRKSensorPattern()) != nullptr) {
+        if (strstr(subNode->GetName(), getTRKChipPattern()) != nullptr) {
           numberOfChips++;
-          LOGP(debug, "Found sensor in {}: {}", nodeName, subNode->GetName());
+          LOGP(debug, "Found chip in {}: {}", nodeName, subNode->GetName());
         }
       }
     }

From 0b483951ab025a97601f15d861ba4df8de3c396e Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Thu, 19 Feb 2026 07:54:50 +0100
Subject: [PATCH 1338/1764] [ALICE3] Change to upper-case 'S' in "FT3sensor_*"
 strings  (#15078)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Change to upper-case 'S' in "FT3sensor_*"

* Change to upper-case 'S' in "FT3sensor_*" in FT3Module.cxx

* Update comments in exportLayout method

Clarified comments in exportLayout function.

---------

Co-authored-by: Nicolò Jacazio <njacazio@users.noreply.github.com>
---
 Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx | 7 ++++---
 .../Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx      | 8 ++++----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index 9303979ada930..4b139272834f1 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -129,7 +129,8 @@ void Detector::buildFT3FromFile(std::string configFileName)
 //_________________________________________________________________________________________________
 void Detector::exportLayout()
 {
-  // Export FT3 Layout description to file. One line per disk
+  // Export FT3 Layout description to file.
+  // One line per disk:
   // z_layer r_in r_out Layerx2X0
 
   std::string configFileName = "FT3_layout.cfg";
@@ -795,8 +796,8 @@ void Detector::defineSensitiveVolumes()
           AddSensitiveVolume(v);
         } else { // OT disks
           for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) {
-            std::string sensor_name_front = "FT3sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-            std::string sensor_name_back = "FT3sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+            std::string sensor_name_front = "FT3Sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+            std::string sensor_name_back = "FT3Sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
             v = geoManager->GetVolume(sensor_name_front.c_str());
             if (v) {
               AddSensitiveVolume(v);
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
index 9e24247958c06..9318554837706 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -481,7 +481,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
               if (sensor_width == 2.5) {
                 // silicon
-                std::string sensor_name = "FT3sensor_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                std::string sensor_name = "FT3Sensor_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
                 sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, active_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(SiColor);
                 sensor->SetFillColorAlpha(SiColor, 0.4);
@@ -495,7 +495,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
               } else {
 
-                std::string sensor_name = "FT3sensor_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                std::string sensor_name = "FT3Sensor_front_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
                 sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(SiColor);
                 sensor->SetFillColorAlpha(SiColor, 0.4);
@@ -652,7 +652,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
               if (sensor_width == 2.5) {
 
-                std::string sensor_name = "FT3sensor_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                std::string sensor_name = "FT3Sensor_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
                 sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, active_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(SiColor);
                 sensor->SetFillColorAlpha(SiColor, 0.4);
@@ -666,7 +666,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
 
               } else {
                 // active (4.6 cm centered)
-                std::string sensor_name = "FT3sensor_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+                std::string sensor_name = "FT3Sensor_back_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
                 sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, active_width / 2, sensor_height / 2, silicon_thickness / 2);
                 sensor->SetLineColor(SiColor);
                 sensor->SetFillColorAlpha(SiColor, 0.4);

From db8db2f046de80b4b70c4de41d0b05e07568aefd Mon Sep 17 00:00:00 2001
From: Roman Lietava <roman.lietava@cern.ch>
Date: Thu, 19 Feb 2026 10:17:05 +0100
Subject: [PATCH 1339/1764] Ctpdev: getting list of unmasked inputs (#15082)

* dev:CTpCfg list of used inputs

* clang
---
 .../include/DataFormatsCTP/Configuration.h    |  3 ++-
 .../Detectors/CTP/src/Configuration.cxx       | 19 +++++++++++++++++--
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h b/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
index e9464089d71fc..ff1462084d53d 100644
--- a/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
+++ b/DataFormats/Detectors/CTP/include/DataFormatsCTP/Configuration.h
@@ -214,7 +214,8 @@ struct CtpCfg {
   uint32_t orbitShift = 0;
   uint32_t irInputs_1_24 = 0;
   uint32_t irInputs_25_48 = 0;
-  ClassDefNV(CtpCfg, 1)
+  std::vector<int> listOfUsedInputs();
+  ClassDefNV(CtpCfg, 2)
 };
 } // namespace ctp
 } // namespace o2
diff --git a/DataFormats/Detectors/CTP/src/Configuration.cxx b/DataFormats/Detectors/CTP/src/Configuration.cxx
index 61e51bcb20d91..98458ef06d1d3 100644
--- a/DataFormats/Detectors/CTP/src/Configuration.cxx
+++ b/DataFormats/Detectors/CTP/src/Configuration.cxx
@@ -1227,9 +1227,24 @@ int CtpCfg::readAndSave(std::string& path)
   }
   return 0;
 }
-
+std::vector<int> CtpCfg::listOfUsedInputs()
+{
+  std::cout << std::hex << "0x" << irInputs_1_24 << " " << irInputs_25_48 << std::dec << std::endl;
+  std::vector<int> inputList;
+  for (int i = 0; i < 24; i++) {
+    if ((1ul << i) & irInputs_1_24) {
+      inputList.push_back(i);
+    }
+  }
+  for (int i = 0; i < 24; i++) {
+    if ((1ul << i) & irInputs_25_48) {
+      inputList.push_back(i + 24);
+    }
+  }
+  return inputList;
+}
 std::ostream& o2::ctp::operator<<(std::ostream& in, const o2::ctp::CTPConfiguration& conf)
 {
   conf.printStream(in);
   return in;
-}
+}
\ No newline at end of file

From efa08980b26cf9ee523abf6d427b7e41dee1ed0d Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Thu, 19 Feb 2026 10:18:54 +0100
Subject: [PATCH 1340/1764] [ITS] Protect ultra low pt selections at the
 tracklet level (#15079)

Checked on Pb-Pb simulation that this does not change the number of
reconstructed tracks
---
 Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 70f4e3d1d3fc7..29fb4ac4c69b5 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -344,7 +344,6 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
 
   mMSangles.resize(trkParam.NLayers);
   mPhiCuts.resize(mClusters.size() - 1, 0.f);
-
   float oneOverR{0.001f * 0.3f * std::abs(mBz) / trkParam.TrackletMinPt};
   for (unsigned int iLayer{0}; iLayer < nLayers; ++iLayer) {
     mMSangles[iLayer] = math_utils::MSangle(0.14f, trkParam.TrackletMinPt, trkParam.LayerxX0[iLayer]);
@@ -352,12 +351,14 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     if (iLayer < mClusters.size() - 1) {
       const float& r1 = trkParam.LayerRadii[iLayer];
       const float& r2 = trkParam.LayerRadii[iLayer + 1];
+      oneOverR = (0.5 * oneOverR >= 1.f / r2) ? 2.f / r2 - o2::constants::math::Almost0 : oneOverR;
       const float res1 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[iLayer]);
       const float res2 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[iLayer + 1]);
       const float cosTheta1half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r1 * oneOverR));
       const float cosTheta2half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r2 * oneOverR));
       float x = r2 * cosTheta1half - r1 * cosTheta2half;
       float delta = o2::gpu::CAMath::Sqrt(1.f / (1.f - 0.25f * math_utils::Sq(x * oneOverR)) * (math_utils::Sq(0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta2half + cosTheta1half) * math_utils::Sq(res1) + math_utils::Sq(0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta1half + cosTheta2half) * math_utils::Sq(res2)));
+      /// the expression std::asin(0.5f * x * oneOverR) is equivalent to std::aCos(0.5f * r1 * oneOverR) - std::acos(0.5 * r2 * oneOverR)
       mPhiCuts[iLayer] = std::min(o2::gpu::CAMath::ASin(0.5f * x * oneOverR) + 2.f * mMSangles[iLayer] + delta, o2::constants::math::PI * 0.5f);
     }
   }

From 98820e9b681677c61f1acac3e5f768cb806eb319 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 19 Feb 2026 11:53:32 +0100
Subject: [PATCH 1341/1764] EMCAL: Delete unused files (#15026)

---
 .../DataFormatsEMCAL/EMCALChannelData.h       |  55 ------
 .../Detectors/EMCAL/src/EMCALChannelData.cxx  |  19 --
 .../reconstruction/run/rawReaderTRUDigits.cxx | 171 ------------------
 3 files changed, 245 deletions(-)
 delete mode 100644 DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/EMCALChannelData.h
 delete mode 100644 DataFormats/Detectors/EMCAL/src/EMCALChannelData.cxx
 delete mode 100644 Detectors/EMCAL/reconstruction/run/rawReaderTRUDigits.cxx

diff --git a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/EMCALChannelData.h b/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/EMCALChannelData.h
deleted file mode 100644
index 3c014d37e6f9e..0000000000000
--- a/DataFormats/Detectors/EMCAL/include/DataFormatsEMCAL/EMCALChannelData.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file EMCALChannelData.h
-/// \brief
-
-/// \class EMCALChannelCalibrator
-/// \brief Class to store the data format for calibraton of the EMCal
-/// \author Hannah Bossi, Yale University
-/// \ingroup DetectorEMCAL
-/// \since Feb 11, 2021
-
-#ifndef ALICEO2_EMCALCHANNELDATA_H
-#define ALICEO2_EMCALCHANNELDATA_H
-
-#include "Rtypes.h"
-
-namespace o2
-{
-namespace dataformats
-{
-class EMCALChannelData
-{
- public:
-  EMCALChannelData(int cellID, int timestamp, int flags = 0, int events) : mEMCALCellID(cellID), mTimestamp(timestamp), mFlags(flags){};
-  EMCALChannelData() = default;
-  ~EMCALChannelData() = default;
-
-  void setEMCALCellID(int index) { mEMCALCellID = index; }
-  int getEMCALCellID() const { return mEMCALCellID; }
-
-  void setTimestamp(int ts) { mTimestamp = ts; }
-  int getTimestamp() const { return mTimestamp; }
-
-  void setFlags(int flags) { mFlags = flags; }
-  float getFlags() const { return mFlags; }
-
- private:
-  int mEMCALCellID;     ///< EMCal Cell ID
-  int mTimestamp;       ///< timestamp in seconds
-  unsigned char mFlags; ///< bit mask with quality flags (to be defined)
-
-  ClassDefNV(EMCALChannelData, 1);
-};
-} // namespace dataformats
-} // namespace o2
-#endif
diff --git a/DataFormats/Detectors/EMCAL/src/EMCALChannelData.cxx b/DataFormats/Detectors/EMCAL/src/EMCALChannelData.cxx
deleted file mode 100644
index 8affa29259f7a..0000000000000
--- a/DataFormats/Detectors/EMCAL/src/EMCALChannelData.cxx
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file EMCALChannelData.cxx
-/// \brief Class to store the data format for calibraton of the EMCal
-
-#include "DataFormatsEMCAL/EMCALChannelData.h"
-
-using namespace o2::dataformats;
-
-ClassImp(o2::dataformats::EMCALChannelData;
diff --git a/Detectors/EMCAL/reconstruction/run/rawReaderTRUDigits.cxx b/Detectors/EMCAL/reconstruction/run/rawReaderTRUDigits.cxx
deleted file mode 100644
index 6fc119dc69521..0000000000000
--- a/Detectors/EMCAL/reconstruction/run/rawReaderTRUDigits.cxx
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file rawReaderFileNew.cxx
-/// \author Markus Fasel <markus.fasel@cern.ch>, Oak Ridge National Laboratory
-
-#include <iostream>
-#include <boost/program_options.hpp>
-
-#include <TTree.h>
-
-#include "DetectorsRaw/RawFileReader.h"
-#include "DetectorsRaw/RDHUtils.h"
-#include "EMCALBase/Mapper.h"
-#include "EMCALBase/TriggerMappingV2.h"
-#include "EMCALReconstruction/AltroDecoder.h"
-#include "EMCALReconstruction/RawReaderMemory.h"
-#include <fairlogger/Logger.h>
-
-namespace bpo = boost::program_options;
-// using namespace o2::emcal;
-
-int main(int argc, char** argv)
-{
-  bpo::variables_map vm;
-  bpo::options_description opt_general("Usage:\n  " + std::string(argv[0]) +
-                                       " <cmds/options>\n"
-                                       "  Tool will decode the DDLx data for EMCAL 0\n"
-                                       "Commands / Options");
-  bpo::options_description opt_hidden("");
-  bpo::options_description opt_all;
-  bpo::positional_options_description opt_pos;
-
-  try {
-    auto add_option = opt_general.add_options();
-    add_option("help,h", "Print this help message");
-    add_option("verbose,v", bpo::value<uint32_t>()->default_value(0), "Select verbosity level [0 = no output]");
-    add_option("version", "Print version information");
-    add_option("input-file,i", bpo::value<std::string>()->required(), "Specifies input file.");
-    add_option("debug,d", bpo::value<uint32_t>()->default_value(0), "Select debug output level [0 = no debug output]");
-
-    opt_all.add(opt_general).add(opt_hidden);
-    bpo::store(bpo::command_line_parser(argc, argv).options(opt_all).positional(opt_pos).run(), vm);
-
-    if (vm.count("help") || argc == 1) {
-      std::cout << opt_general << std::endl;
-      exit(0);
-    }
-
-    if (vm.count("version")) {
-      // std::cout << GitInfo();
-      exit(0);
-    }
-
-    bpo::notify(vm);
-  } catch (bpo::error& e) {
-    std::cerr << "ERROR: " << e.what() << std::endl
-              << std::endl;
-    std::cerr << opt_general << std::endl;
-    exit(1);
-  } catch (std::exception& e) {
-    std::cerr << e.what() << ", application will now exit" << std::endl;
-    exit(2);
-  }
-
-  auto rawfilename = vm["input-file"].as<std::string>();
-
-  o2::raw::RawFileReader reader;
-  reader.setDefaultDataOrigin(o2::header::gDataOriginEMC);
-  reader.setDefaultDataDescription(o2::header::gDataDescriptionRawData);
-  reader.setDefaultReadoutCardType(o2::raw::RawFileReader::RORC);
-  reader.addFile(rawfilename);
-  reader.init();
-
-  o2::emcal::MappingHandler mapper;
-  o2::emcal::TriggerMappingV2 triggermapping;
-
-  std::unique_ptr<TFile> treefile(TFile::Open("trudata.root", "RECREATE"));
-  TTree trudata("trudata", "Tree with TRU data");
-  // branches in tree
-  struct collisiontrigger {
-    unsigned long bc;
-    unsigned long orbit;
-  } mycollision;
-  int absFastOR;
-  int starttime;
-  std::vector<int> timesamples;
-  tree->Branch(&mycollision, "collisiontrigger", "bc,orbit/l");
-  tree->Branch(&starttime, "starttime", "starttime/i");
-  tree->Branch(&timesamples, "timesamples", ""); // @todo check how to write std::vector to tree;
-
-  while (1) {
-    int tfID = reader.getNextTFToRead();
-    if (tfID >= reader.getNTimeFrames()) {
-      LOG(info) << "nothing left to read after " << tfID << " TFs read";
-      break;
-    }
-    std::vector<char> dataBuffer; // where to put extracted data
-    for (int il = 0; il < reader.getNLinks(); il++) {
-      auto& link = reader.getLink(il);
-      std::cout << "Decoding link " << il << std::endl;
-
-      auto sz = link.getNextTFSize(); // size in bytes needed for the next TF of this link
-      dataBuffer.resize(sz);
-      link.readNextTF(dataBuffer.data());
-
-      // Parse
-      o2::emcal::RawReaderMemory parser(dataBuffer);
-      while (parser.hasNext()) {
-        parser.next();
-        auto rdh = parser.getRawHeader();
-        auto ddl = o2::raw::RDHUtils::getFEEID(parser.getRawHeader());
-        // Exclude STU DDLs
-        if (ddl >= 40) {
-          continue;
-        }
-
-        mycollision.bc = o2::raw::RDHUtils::getTriggerBC(rdh);
-        mycollision.orbit = o2::raw::RDHUtils::getTriggerOrbit(rdh);
-
-        o2::emcal::AltroDecoder decoder(parser);
-        decoder.decode();
-        auto& ddlmapping = mapper.getMappingForDDL(ddl);
-
-        std::cout << decoder.getRCUTrailer() << std::endl;
-        for (auto& chan : decoder.getChannels()) {
-          if (ddlmapping.getChannelType(chan.getHardwareAddress) != o2::emcal::ChannelType_t::TRU) {
-            continue;
-          }
-          std::cout << "Hw address: " << chan.getHardwareAddress() << std::endl;
-          // Get absolute FastOR index - this will tell us where on the EMCAL surface the FastOR is
-          // TRU index is encoded in column, needs to be converted to an absoluted FastOR ID via the
-          // trigger mapping. The absoluted FastOR ID can be connected via the geometry to tower IDs
-          // from the FEC data.
-          // we are only interested in the FastORs for now, skip patches starting from 96
-          auto fastorInTRU = ddlmapping.getColumn(chan.getHardwareAddress());
-          if (fastorInTRU >= 96) {
-            // indices starting from 96 encode patches, not FastORs
-            continue;
-          }
-          auto truindex = triggermapping.getTRUIndexFromOnlineHardareAddree(chan.getHardwareAddress(), ddl, ddl / 2);
-          auto absFastOrID = triggermapping.getAbsFastORIndexFromIndexInTRU(truindex, fastorInTRU);
-
-          for (auto& bunch : chan.getBunches()) {
-            std::cout << "BunchLength: " << int(bunch.getBunchLength()) << std::endl;
-            auto adcs = bunch.getADC();
-            int time = bunch.getStartTime();
-            starttime = time;
-            timesamples.clear();
-            timesamples.resize(adcs.size());
-            std::copy(adcs.begin(), adcs.end(), timesamples.begin());
-            trudata.Fill();
-            for (int i = adcs.size() - 1; i >= 0; i--) {
-              std::cout << "Timebin " << time << ", ADC " << adcs[i] << std::endl;
-              time--;
-            }
-          }
-        }
-      }
-    }
-    reader.setNextTFToRead(++tfID);
-  }
-}
\ No newline at end of file

From 7b4f8f168ca7051f84d73b9ade285882c048348e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 19 Feb 2026 10:14:24 +0100
Subject: [PATCH 1342/1764] TPC: Delete unused files

---
 .../TPCReconstruction/ClusterContainer.h      | 65 -------------------
 .../src/time-series-merge-integrator.cxx      | 34 ----------
 .../TPC/workflow/src/time-series-reader.cxx   | 25 -------
 3 files changed, 124 deletions(-)
 delete mode 100644 Detectors/TPC/reconstruction/include/TPCReconstruction/ClusterContainer.h
 delete mode 100644 Detectors/TPC/workflow/src/time-series-merge-integrator.cxx
 delete mode 100644 Detectors/TPC/workflow/src/time-series-reader.cxx

diff --git a/Detectors/TPC/reconstruction/include/TPCReconstruction/ClusterContainer.h b/Detectors/TPC/reconstruction/include/TPCReconstruction/ClusterContainer.h
deleted file mode 100644
index d86a845b0fe4c..0000000000000
--- a/Detectors/TPC/reconstruction/include/TPCReconstruction/ClusterContainer.h
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file ClusterContainer.h
-/// \brief Container class for TPC clusters
-#ifndef _ALICEO2_TPC_ClusterContainer_
-#define _ALICEO2_TPC_ClusterContainer_
-
-#include <vector>
-#include <cassert>
-#include <Rtypes.h> // for Float_t etc
-
-namespace o2
-{
-namespace tpc
-{
-
-/// \class ClusterContainer
-/// \brief Container class for TPC clusters
-class ClusterContainer
-{
- public:
-  // Initialize the clones array
-  // @param clusterType Possibility to store different types of clusters
-  // void InitArray(const Char_t* clusterType="o2::tpc::Cluster");
-
-  /// Add cluster to array
-  /// @param output, the vector to append to
-  /// @param cru CRU (sector)
-  /// @param row Row
-  /// @param q Total charge of cluster
-  /// @param qmax Maximum charge in a single cell (pad, time)
-  /// @param padmean Mean position of cluster in pad direction
-  /// @param padsigma Sigma of cluster in pad direction
-  /// @param timemean Mean position of cluster in time direction
-  /// @param timesigma Sigma of cluster in time direction
-  template <typename ClusterType>
-  static ClusterType* addCluster(std::vector<ClusterType>* output,
-                                 Int_t cru, Int_t row, Float_t qTot, Float_t qMax,
-                                 Float_t meanpad, Float_t meantime, Float_t sigmapad,
-                                 Float_t sigmatime)
-  {
-    assert(output);
-    output->emplace_back(); // emplace_back a defaut constructed cluster of type ClusterType
-    auto& cluster = output->back();
-    // set its concrete parameters:
-    // ATTENTION: the order of parameters in setParameters is different than in AddCluster!
-    cluster.setParameters(cru, row, qTot, qMax,
-                          meanpad, sigmapad,
-                          meantime, sigmatime);
-    return &cluster;
-  }
-};
-} // namespace tpc
-} // namespace o2
-
-#endif
diff --git a/Detectors/TPC/workflow/src/time-series-merge-integrator.cxx b/Detectors/TPC/workflow/src/time-series-merge-integrator.cxx
deleted file mode 100644
index c17b68e307328..0000000000000
--- a/Detectors/TPC/workflow/src/time-series-merge-integrator.cxx
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "TPCWorkflow/TPCMergeTimeSeriesSpec.h"
-#include "CommonUtils/ConfigurableParam.h"
-#include "Framework/ConfigParamSpec.h"
-
-using namespace o2::framework;
-
-void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
-{
-  std::vector<ConfigParamSpec> options{
-    ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-  };
-  std::swap(workflowOptions, options);
-}
-
-#include "Framework/runDataProcessing.h"
-
-WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
-{
-  WorkflowSpec wf;
-  o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
-  wf.emplace_back(o2::tpc::getTPCMergeTimeSeriesSpec());
-  return wf;
-}
diff --git a/Detectors/TPC/workflow/src/time-series-reader.cxx b/Detectors/TPC/workflow/src/time-series-reader.cxx
deleted file mode 100644
index ccedbdf4f9599..0000000000000
--- a/Detectors/TPC/workflow/src/time-series-reader.cxx
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "TPCWorkflow/TPCTimeSeriesReaderSpec.h"
-#include "CommonUtils/ConfigurableParam.h"
-#include "Framework/ConfigParamSpec.h"
-
-using namespace o2::framework;
-
-#include "Framework/runDataProcessing.h"
-
-WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
-{
-  WorkflowSpec wf;
-  wf.emplace_back(o2::tpc::getTPCTimeSeriesReaderSpec());
-  return wf;
-}

From 1d4b3ef48aef20e6866379301de6e9d94ff234c2 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 17 Feb 2026 22:15:26 +0100
Subject: [PATCH 1343/1764] DPL: add ability to get the toplevel service
 registry

This will allows non DPL code to still exploit some of the
DPL services, like monitoring.
---
 Framework/Core/CMakeLists.txt                 |  1 +
 .../include/Framework/ServiceRegistryRef.h    |  2 ++
 Framework/Core/src/ServiceRegistryRef.cxx     | 25 +++++++++++++++++++
 Framework/Core/src/runDataProcessing.cxx      |  1 +
 4 files changed, 29 insertions(+)
 create mode 100644 Framework/Core/src/ServiceRegistryRef.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 7357167a3fcd8..e6a8db1077136 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -125,6 +125,7 @@ o2_add_library(Framework
                        src/RootArrowFilesystem.cxx
                        src/SendingPolicy.cxx
                        src/ServiceRegistry.cxx
+                       src/ServiceRegistryRef.cxx
                        src/ServiceSpec.cxx
                        src/SimpleResourceManager.cxx
                        src/SimpleRawDeviceService.cxx
diff --git a/Framework/Core/include/Framework/ServiceRegistryRef.h b/Framework/Core/include/Framework/ServiceRegistryRef.h
index 910d4e726c080..85aad6d70e93b 100644
--- a/Framework/Core/include/Framework/ServiceRegistryRef.h
+++ b/Framework/Core/include/Framework/ServiceRegistryRef.h
@@ -112,6 +112,8 @@ class ServiceRegistryRef
     mRegistry.unlock(mSalt);
   }
 
+  static ServiceRegistryRef *globalDeviceRef(ServiceRegistryRef *ref = nullptr);
+
  private:
   ServiceRegistry& mRegistry;
   ServiceRegistry::Salt mSalt;
diff --git a/Framework/Core/src/ServiceRegistryRef.cxx b/Framework/Core/src/ServiceRegistryRef.cxx
new file mode 100644
index 0000000000000..70728ad37eda7
--- /dev/null
+++ b/Framework/Core/src/ServiceRegistryRef.cxx
@@ -0,0 +1,25 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+
+#include "Framework/ServiceRegistryRef.h"
+namespace o2::framework {
+
+ServiceRegistryRef *ServiceRegistryRef::globalDeviceRef(ServiceRegistryRef *ref) {
+  static ServiceRegistryRef *globalRef = nullptr;
+  if (!globalRef) {
+    globalRef = ref;
+  }
+  // We return a copy, so that it can be cache
+  return globalRef;
+}
+
+}
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index ced884ebaa1ed..b99b5119e3ce9 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1429,6 +1429,7 @@ int runStateMachine(DataProcessorSpecs const& workflow,
   // We initialise this in the driver, because different drivers might have
   // different versions of the service
   ServiceRegistry serviceRegistry;
+  ServiceRegistryRef::globalDeviceRef(new ServiceRegistryRef{serviceRegistry, ServiceRegistry::globalDeviceSalt()});
 
   if ((driverConfig.batch == false || getenv("DPL_DRIVER_REMOTE_GUI") != nullptr) && frameworkId.empty()) {
     debugGUI = initDebugGUI();

From 813e416361a029fa023fd3fa6116cbb54a700bba Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 17 Feb 2026 22:15:26 +0100
Subject: [PATCH 1344/1764] CCDB: report stats about CCDB fetches / misses to
 DPL

---
 CCDB/include/CCDB/BasicCCDBManager.h          | 11 ++++++++-
 CCDB/src/BasicCCDBManager.cxx                 |  2 ++
 .../include/Framework/DataProcessingStats.h   |  3 +++
 Framework/Core/src/CommonServices.cxx         | 24 +++++++++++++++++++
 Framework/Core/src/runDataProcessing.cxx      |  1 +
 5 files changed, 40 insertions(+), 1 deletion(-)

diff --git a/CCDB/include/CCDB/BasicCCDBManager.h b/CCDB/include/CCDB/BasicCCDBManager.h
index 71287c2f07d76..fd0fe7aa6d05b 100644
--- a/CCDB/include/CCDB/BasicCCDBManager.h
+++ b/CCDB/include/CCDB/BasicCCDBManager.h
@@ -20,6 +20,8 @@
 #include "CommonUtils/NameConf.h"
 #include "Framework/DataTakingContext.h"
 #include "Framework/DefaultsHelpers.h"
+#include "Framework/ServiceRegistryRef.h"
+#include "Framework/DataProcessingStats.h"
 #include <string>
 #include <chrono>
 #include <map>
@@ -340,6 +342,13 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp,
   }
   auto end = std::chrono::system_clock::now();
   mTimerMS += std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+  auto *ref = o2::framework::ServiceRegistryRef::globalDeviceRef();
+  if (ref && ref->active<framework::DataProcessingStats>()) {
+    auto& stats = ref->get<o2::framework::DataProcessingStats>();
+    stats.updateStats({(int)o2::framework::ProcessingStatsId::CCDB_CACHE_HIT, o2::framework::DataProcessingStats::Op::Set, (int64_t)mQueries - mFailures - mFetches});
+    stats.updateStats({(int)o2::framework::ProcessingStatsId::CCDB_CACHE_MISS, o2::framework::DataProcessingStats::Op::Set, (int64_t)mFetches});
+    stats.updateStats({(int)o2::framework::ProcessingStatsId::CCDB_CACHE_FAILURE, o2::framework::DataProcessingStats::Op::Set, (int64_t)mFailures});
+  }
   return ptr;
 }
 
@@ -391,4 +400,4 @@ class BasicCCDBManager : public CCDBManagerInstance
 
 } // namespace o2::ccdb
 
-#endif //O2_BASICCCDBMANAGER_H
+#endif // O2_BASICCCDBMANAGER_H
diff --git a/CCDB/src/BasicCCDBManager.cxx b/CCDB/src/BasicCCDBManager.cxx
index bcf88554578c1..d55fdad960d3a 100644
--- a/CCDB/src/BasicCCDBManager.cxx
+++ b/CCDB/src/BasicCCDBManager.cxx
@@ -13,6 +13,8 @@
 // Created by Sandro Wenzel on 2019-08-14.
 //
 #include "CCDB/BasicCCDBManager.h"
+#include "Framework/ServiceRegistryRef.h"
+#include "Framework/DataProcessingStats.h"
 #include <boost/lexical_cast.hpp>
 #include <fairlogger/Logger.h>
 #include <string>
diff --git a/Framework/Core/include/Framework/DataProcessingStats.h b/Framework/Core/include/Framework/DataProcessingStats.h
index e32523c9abb08..a1f5c0eec5568 100644
--- a/Framework/Core/include/Framework/DataProcessingStats.h
+++ b/Framework/Core/include/Framework/DataProcessingStats.h
@@ -69,6 +69,9 @@ enum struct ProcessingStatsId : short {
   RESOURCES_MISSING,
   RESOURCES_INSUFFICIENT,
   RESOURCES_SATISFACTORY,
+  CCDB_CACHE_HIT,
+  CCDB_CACHE_MISS,
+  CCDB_CACHE_FAILURE,
   AVAILABLE_MANAGED_SHM_BASE = 512,
 };
 
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 6486406a06dca..06bc7969ebf1e 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -1152,6 +1152,30 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
                    .scope = Scope::DPL,
                    .minPublishInterval = 0,
                    .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
+        MetricSpec{.name = "ccdb-cache-hit",
+                   .enabled = true,
+                   .metricId = static_cast<short>(ProcessingStatsId::CCDB_CACHE_HIT),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 1000,
+                   .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
+        MetricSpec{.name = "ccdb-cache-miss",
+                   .enabled = true,
+                   .metricId = static_cast<short>(ProcessingStatsId::CCDB_CACHE_MISS),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 1000,
+                   .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
+        MetricSpec{.name = "ccdb-cache-failure",
+                   .enabled = true,
+                   .metricId = static_cast<short>(ProcessingStatsId::CCDB_CACHE_FAILURE),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 1000,
+                   .maxRefreshLatency = 10000,
                    .sendInitialValue = true}};
 
       for (auto& metric : metrics) {
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index b99b5119e3ce9..815fce47544d0 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1248,6 +1248,7 @@ std::vector<std::regex> getDumpableMetrics()
   dumpableMetrics.emplace_back("^total-timeframes.*");
   dumpableMetrics.emplace_back("^device_state.*");
   dumpableMetrics.emplace_back("^total_wall_time_ms$");
+  dumpableMetrics.emplace_back("^ccdb-.*$");
   return dumpableMetrics;
 }
 

From d569998f2457c1eb4f35596b38cf9a4c4bea23a5 Mon Sep 17 00:00:00 2001
From: Francesco Noferini <noferini@bo.infn.it>
Date: Wed, 18 Feb 2026 17:20:27 +0100
Subject: [PATCH 1345/1764] path for LHCphase ccdb configurable

---
 .../calibration/include/TOFCalibration/LHCClockCalibrator.h   | 3 +++
 Detectors/TOF/calibration/src/LHCClockCalibrator.cxx          | 2 +-
 .../TOF/calibration/testWorkflow/LHCClockCalibratorSpec.h     | 4 ++++
 3 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/Detectors/TOF/calibration/include/TOFCalibration/LHCClockCalibrator.h b/Detectors/TOF/calibration/include/TOFCalibration/LHCClockCalibrator.h
index aaab8a06e5e86..4c8f5cdae8654 100644
--- a/Detectors/TOF/calibration/include/TOFCalibration/LHCClockCalibrator.h
+++ b/Detectors/TOF/calibration/include/TOFCalibration/LHCClockCalibrator.h
@@ -99,6 +99,8 @@ class LHCClockCalibrator final : public o2::calibration::TimeSlotCalibration<o2:
 
   void setCalibTOFapi(CalibTOFapi* api) { mCalibTOFapi = api; }
   CalibTOFapi* getCalibTOFapi() const { return mCalibTOFapi; }
+  const char* getPath() const { return mPath.Data(); }
+  void setPath(const char* path) { mPath = path; }
 
  private:
   int mMinEntries = 0;
@@ -107,6 +109,7 @@ class LHCClockCalibrator final : public o2::calibration::TimeSlotCalibration<o2:
   CalibTOFapi* mCalibTOFapi = nullptr;
   CcdbObjectInfoVector mInfoVector; // vector of CCDB Infos , each element is filled with the CCDB description of the accompanying LHCPhase
   LHCphaseVector mLHCphaseVector;   // vector of LhcPhase, each element is filled in "process" when we finalize one slot (multiple can be finalized during the same "process", which is why we have a vector. Each element is to be considered the output of the device, and will go to the CCDB
+  TString mPath = "TOF/Calib/LHCphaseSync";
 
 #ifdef DEBUGGING
   int mNslot = 0;
diff --git a/Detectors/TOF/calibration/src/LHCClockCalibrator.cxx b/Detectors/TOF/calibration/src/LHCClockCalibrator.cxx
index c4fdc25e98849..5a9dd727cda8e 100644
--- a/Detectors/TOF/calibration/src/LHCClockCalibrator.cxx
+++ b/Detectors/TOF/calibration/src/LHCClockCalibrator.cxx
@@ -158,7 +158,7 @@ void LHCClockCalibrator::finalizeSlot(Slot& slot)
   l.setStartValidity(starting);
   l.setEndValidity(stopping);
 
-  mInfoVector.emplace_back("TOF/Calib/LHCphase", clName, flName, md, starting, stopping);
+  mInfoVector.emplace_back(mPath.Data(), clName, flName, md, starting, stopping);
   mLHCphaseVector.emplace_back(l);
 
   slot.print();
diff --git a/Detectors/TOF/calibration/testWorkflow/LHCClockCalibratorSpec.h b/Detectors/TOF/calibration/testWorkflow/LHCClockCalibratorSpec.h
index f2d3df9218249..1e3a6602939bf 100644
--- a/Detectors/TOF/calibration/testWorkflow/LHCClockCalibratorSpec.h
+++ b/Detectors/TOF/calibration/testWorkflow/LHCClockCalibratorSpec.h
@@ -53,7 +53,10 @@ class LHCClockCalibDevice : public o2::framework::Task
     int nb = std::max(500, ic.options().get<int>("nbins"));
     auto slotL = ic.options().get<uint32_t>("tf-per-slot");
     auto delay = ic.options().get<uint32_t>("max-delay");
+    std::string path = ic.options().get<std::string>("output-path");
+
     mCalibrator = std::make_unique<o2::tof::LHCClockCalibrator>(minEnt, nb);
+    mCalibrator->setPath(path.data());
     mCalibrator->setSlotLength(slotL);
     mCalibrator->setMaxSlotsDelay(delay);
 
@@ -216,6 +219,7 @@ DataProcessorSpec getLHCClockCalibDeviceSpec(bool useCCDB)
     AlgorithmSpec{adaptFromTask<device>(ccdbRequest, useCCDB)},
     Options{
       {"tf-per-slot", VariantType::UInt32, 5u, {"number of TFs per calibration time slot"}},
+      {"output-path", VariantType::String, "TOF/Calib/LHCphaseSync", {"path to ccdb output"}},
       {"max-delay", VariantType::UInt32, 3u, {"number of slots in past to consider"}},
       {"min-entries", VariantType::Int, 500, {"minimum number of entries to fit single time slot"}},
       {"nbins", VariantType::Int, 4000, {"number of bins for "}}}};

From 67ab6d5a3922f27ce27376993bf5523b8c5d9e5f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Thu, 5 Feb 2026 22:44:32 +0100
Subject: [PATCH 1346/1764] HMPID: Delete unused files

---
 .../HMPIDReconstruction/HmpidDecodeRawFile.h  |   63 -
 .../HMPIDReconstruction/HmpidDecodeRawMem.h   |   73 --
 .../reconstruction/src/HmpidDecodeRawFile.cxx |  158 ---
 .../reconstruction/src/HmpidDecodeRawMem.cxx  |  184 ---
 .../HMPID/reconstruction/src/HmpidDecoder.cxx | 1134 -----------------
 .../HMPIDWorkflow/ClusterizerSpec.h_notused.h |   27 -
 .../HMPIDWorkflow/DigitReaderSpec.h_notused.h |   53 -
 7 files changed, 1692 deletions(-)
 delete mode 100644 Detectors/HMPID/reconstruction/include/HMPIDReconstruction/HmpidDecodeRawFile.h
 delete mode 100644 Detectors/HMPID/reconstruction/include/HMPIDReconstruction/HmpidDecodeRawMem.h
 delete mode 100644 Detectors/HMPID/reconstruction/src/HmpidDecodeRawFile.cxx
 delete mode 100644 Detectors/HMPID/reconstruction/src/HmpidDecodeRawMem.cxx
 delete mode 100644 Detectors/HMPID/reconstruction/src/HmpidDecoder.cxx
 delete mode 100644 Detectors/HMPID/workflow/include/HMPIDWorkflow/ClusterizerSpec.h_notused.h
 delete mode 100644 Detectors/HMPID/workflow/include/HMPIDWorkflow/DigitReaderSpec.h_notused.h

diff --git a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/HmpidDecodeRawFile.h b/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/HmpidDecodeRawFile.h
deleted file mode 100644
index e92e8375ad0d0..0000000000000
--- a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/HmpidDecodeRawFile.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-///
-/// \file   HmpidDecodeRawFile.h
-/// \author Antonio Franco - INFN Bari
-/// \brief Derived Class for decoding Raw Data File stream
-/// \version 1.0
-/// \date 24 set 2020
-
-#ifndef COMMON_HMPIDDECODERAWFILE_H_
-#define COMMON_HMPIDDECODERAWFILE_H_
-
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <unistd.h>
-
-#include "HMPIDReconstruction/HmpidDecoder.h"
-
-#define MAXFILENAMEBUFFER 512
-#define MAXRAWFILEBUFFER RAWBLOCKDIMENSION_W * 4 + 8
-
-namespace o2
-{
-namespace hmpid
-{
-
-class HmpidDecodeRawFile : public HmpidDecoder
-{
- public:
-  HmpidDecodeRawFile(int* EqIds, int* CruIds, int* LinkIds, int numOfEquipments);
-  HmpidDecodeRawFile(int numOfEquipments);
-  ~HmpidDecodeRawFile();
-
-  bool setUpStream(void* InpuFileName, long Size);
-
- private:
-  bool getBlockFromStream(uint32_t** streamPtr, uint32_t Size);
-  bool getHeaderFromStream(uint32_t** streamPtr);
-  bool getWordFromStream(uint32_t* word);
-  int fileExists(char* filewithpath);
-  void setPad(HmpidEquipment* eq, int col, int dil, int ch, uint16_t charge);
-
- private:
-  FILE* fh;
-  char mInputFile[MAXFILENAMEBUFFER];
-  uint32_t mFileBuffer[MAXRAWFILEBUFFER];
-};
-
-} // namespace hmpid
-} // namespace o2
-#endif /* COMMON_HMPIDDECODERAWFILE_H_ */
diff --git a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/HmpidDecodeRawMem.h b/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/HmpidDecodeRawMem.h
deleted file mode 100644
index d5d82d0f238e9..0000000000000
--- a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/HmpidDecodeRawMem.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-///
-/// \file   HmpidDecodeRawMem.h
-/// \author Antonio Franco - INFN Bari
-/// \brief Derived Class for decoding Raw Data Memory stream
-/// \version 1.0
-/// \date 24 set 2020
-
-#ifndef COMMON_HMPIDDECODERAWMEM_H_
-#define COMMON_HMPIDDECODERAWMEM_H_
-
-#include <cctype>
-#include <cstdio>
-#include <cstdlib>
-#include <unistd.h>
-#include <cstring>
-#include <vector>
-
-#include "DataFormatsHMP/Digit.h"
-#include "HMPIDBase/Geo.h"
-#include "HMPIDReconstruction/HmpidDecoder.h"
-
-using namespace o2;
-
-namespace o2
-{
-namespace hmpid
-{
-
-class HmpidDecodeRawMem : public HmpidDecoder
-{
- public:
-  HmpidDecodeRawMem(int* EqIds, int* CruIds, int* LinkIds, int numOfEquipments);
-  HmpidDecodeRawMem(int numOfEquipments);
-  ~HmpidDecodeRawMem();
-
-  bool setUpStream(void* Buffer, long BufferLen) override;
-
- private:
-  bool getBlockFromStream(uint32_t** streamPtr, uint32_t Size) override;
-  bool getHeaderFromStream(uint32_t** streamPtr) override;
-  bool getWordFromStream(uint32_t* word) override;
-  void setPad(HmpidEquipment* eq, int col, int dil, int ch, uint16_t charge) override;
-
- private:
-};
-
-class HmpidDecodeRawDigit : public HmpidDecodeRawMem
-{
- public:
-  HmpidDecodeRawDigit(int* EqIds, int* CruIds, int* LinkIds, int numOfEquipments);
-  HmpidDecodeRawDigit(int numOfEquipments);
-  ~HmpidDecodeRawDigit();
-
-  std::vector<o2::hmpid::Digit> mDigits;
-
- private:
-  void setPad(HmpidEquipment* eq, int col, int dil, int ch, uint16_t charge) override;
-};
-
-} // namespace hmpid
-} // namespace o2
-#endif /* COMMON_HMPIDDECODERAWFILE_H_ */
diff --git a/Detectors/HMPID/reconstruction/src/HmpidDecodeRawFile.cxx b/Detectors/HMPID/reconstruction/src/HmpidDecodeRawFile.cxx
deleted file mode 100644
index df97a4d2101e0..0000000000000
--- a/Detectors/HMPID/reconstruction/src/HmpidDecodeRawFile.cxx
+++ /dev/null
@@ -1,158 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-///
-/// \file   HmpidDecodeRawFile.cxx
-/// \author Antonio Franco - INFN Bari
-/// \brief Derived Class for decoding Raw Data File stream
-/// \version 1.0
-/// \date 24 set 2020
-
-/* ------ HISTORY ---------
-*/
-#include <fairlogger/Logger.h> // for LOG
-#include "Framework/Logger.h"
-
-#include "HMPIDReconstruction/HmpidDecodeRawFile.h"
-
-using namespace o2::hmpid;
-
-/// Constructor with the default HMPID equipments map at P2
-/// @param[in] numOfEquipments : number of defined equipments [0..13]
-HmpidDecodeRawFile::HmpidDecodeRawFile(int numOfEquipments)
-  : HmpidDecoder(numOfEquipments)
-{
-  fh = 0;
-}
-
-/// Constructor with the HMPID address map
-/// @param[in] numOfEquipments : the number of equipments to define [1..14]
-/// @param[in] *EqIds : the pointer to the Equipments ID array
-/// @param[in] *CruIds : the pointer to the CRU ID array
-/// @param[in] *LinkIds : the pointer to the Link ID array
-HmpidDecodeRawFile::HmpidDecodeRawFile(int* EqIds, int* CruIds, int* LinkIds, int numOfEquipments)
-  : HmpidDecoder(EqIds, CruIds, LinkIds, numOfEquipments)
-{
-  fh = 0;
-}
-
-/// Destructor
-HmpidDecodeRawFile::~HmpidDecodeRawFile()
-{
-}
-
-/// Setup the Input Stream with a File Handle
-/// verify the existence and try to open it
-/// @param[in] *FileName : the string that contains the File Name
-/// @param[in] Size : not used
-/// @returns True if the file is opened
-/// @throws TH_FILENOTEXISTS Thrown if the file doesn't exists
-/// @throws TH_OPENFILE Thrown if Fails to open the file
-bool HmpidDecodeRawFile::setUpStream(void* FileName, long Size)
-{
-  strcpy(mInputFile, (const char*)FileName);
-  // files section ----
-  if (!fileExists(mInputFile)) {
-    LOG(error) << "The input file " << mInputFile << " does not exist at this time.";
-    throw TH_FILENOTEXISTS;
-  }
-  // open the file
-  fh = fopen(mInputFile, "rb");
-  if (fh == 0) {
-    LOG(error) << "ERROR to open Input file ! [" << mInputFile << "]";
-    throw TH_OPENFILE;
-  }
-
-  mActualStreamPtr = 0; // sets the pointer to the Buffer
-  mEndStreamPtr = 0;    //sets the End of buffer
-  mStartStreamPtr = 0;
-
-  return (true);
-}
-
-/// Gets a sized chunk from the stream. Read from the file and update the pointers
-/// ATTENTION : in order to optimize the disk accesses the block read pre-load a
-/// complete Header+Payload block, the Size parameter is recalculated with the
-/// dimension of the pack extract from the header field 'Offeset'
-///
-/// verify the existence and try to open it
-/// @param[in] **streamPtr : the pointer to the memory buffer
-/// @param[in] Size : not used
-/// @returns True if the file is opened
-/// @throws TH_WRONGFILELEN Thrown if the file doesn't contains enough words
-bool HmpidDecodeRawFile::getBlockFromStream(uint32_t** streamPtr, uint32_t Size)
-{
-  if (Size > MAXRAWFILEBUFFER)
-    return (false);
-  int nr = fread(mFileBuffer, sizeof(int32_t), HEADERDIMENSION_W, fh);
-  if (nr != HEADERDIMENSION_W) {
-    throw TH_WRONGFILELEN;
-  }
-  Size = ((mFileBuffer[2] & 0x0000FFFF) / sizeof(int32_t)) - HEADERDIMENSION_W;
-  nr = fread(mFileBuffer + HEADERDIMENSION_W, sizeof(int32_t), Size, fh);
-  LOG(debug) << " getBlockFromStream read " << nr << " of " << Size + HEADERDIMENSION_W << " words !";
-  if (nr != Size) {
-    throw TH_WRONGFILELEN;
-  }
-  *streamPtr = mFileBuffer;
-  mStartStreamPtr = mFileBuffer;
-  mActualStreamPtr = mFileBuffer;
-  mEndStreamPtr = mFileBuffer + Size;
-  return (true);
-}
-
-/// Reads the Header from the file
-/// @param[in] **streamPtr : the pointer to the memory buffer
-/// @returns True if the header is read
-bool HmpidDecodeRawFile::getHeaderFromStream(uint32_t** streamPtr)
-{
-  bool flag = getBlockFromStream(streamPtr, RAWBLOCKDIMENSION_W); // reads the 8k block
-  mActualStreamPtr += HEADERDIMENSION_W;                          // Move forward for the first word
-  return (flag);
-}
-
-/// Read one word from the pre-load buffer
-/// @param[in] *word : the buffer for the read word
-/// @returns True every time
-bool HmpidDecodeRawFile::getWordFromStream(uint32_t* word)
-{
-  *word = *mActualStreamPtr;
-  mActualStreamPtr++;
-  return (true);
-}
-
-/// -----   Sets the Pad ! ------
-/// this is an overloaded method. In this version the value of the charge
-/// is used to update the statistical matrix of the base class
-///
-/// @param[in] *eq : the pointer to the Equipment object
-/// @param[in] col : the column [0..23]
-/// @param[in] dil : the dilogic [0..9]
-/// @param[in] ch : the channel [0..47]
-/// @param[in] charge : the value of the charge
-void HmpidDecodeRawFile::setPad(HmpidEquipment* eq, int col, int dil, int ch, uint16_t charge)
-{
-  eq->setPad(col, dil, ch, charge);
-  return;
-}
-
-/// Checks if the file exists !
-/// @param[in] *filewithpath : the File Name to check
-/// @returns True if the file exists
-int HmpidDecodeRawFile::fileExists(char* filewithpath)
-{
-  if (access(filewithpath, F_OK) != -1) {
-    return (true);
-  } else {
-    return (false);
-  }
-}
-o2::hmpid::Digit
diff --git a/Detectors/HMPID/reconstruction/src/HmpidDecodeRawMem.cxx b/Detectors/HMPID/reconstruction/src/HmpidDecodeRawMem.cxx
deleted file mode 100644
index 5a4f2acbfd97b..0000000000000
--- a/Detectors/HMPID/reconstruction/src/HmpidDecodeRawMem.cxx
+++ /dev/null
@@ -1,184 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-///
-/// \file   HmpidDecodeRawMem.cxx
-/// \author Antonio Franco - INFN Bari
-/// \brief Derived Class for decoding Raw Data Memory stream
-/// \version 1.0
-/// \date 24 set 2020
-
-/* ------ HISTORY ---------
-*/
-#include <fairlogger/Logger.h> // for LOG
-#include "Framework/Logger.h"
-
-#include "DataFormatsHMP/Digit.h"
-#include "HMPIDBase/Geo.h"
-#include "HMPIDReconstruction/HmpidDecodeRawMem.h"
-
-using namespace o2::hmpid;
-
-/// Constructor : accepts the number of equipments to define
-///               The mapping is the default at P2
-///               Allocates instances for all defined equipments
-///               normally it is equal to 14
-/// @param[in] numOfEquipments : the number of equipments to define [1..14]
-HmpidDecodeRawMem::HmpidDecodeRawMem(int numOfEquipments)
-  : HmpidDecoder(numOfEquipments)
-{
-}
-
-/// Constructor : accepts the number of equipments to define
-///               and their complete address map
-///               Allocates instances for all defined equipments
-///
-///  The Address map is build from three array
-/// @param[in] numOfEquipments : the number of equipments to define [1..14]
-/// @param[in] *EqIds : the pointer to the Equipments ID array
-/// @param[in] *CruIds : the pointer to the CRU ID array
-/// @param[in] *LinkIds : the pointer to the Link ID array
-HmpidDecodeRawMem::HmpidDecodeRawMem(int* EqIds, int* CruIds, int* LinkIds, int numOfEquipments)
-  : HmpidDecoder(EqIds, CruIds, LinkIds, numOfEquipments)
-{
-}
-
-/// Destructor
-HmpidDecodeRawMem::~HmpidDecodeRawMem() = default;
-
-/// Setup the Input Stream with a Memory Pointer
-/// the buffer length is in byte, some controls are done
-///
-/// @param[in] *Buffer : the pointer to Memory buffer
-/// @param[in] BufferLen : the length of the buffer (bytes)
-/// @returns True if the stream is set
-/// @throws TH_NULLBUFFERPOINTER Thrown if the pointer to the buffer is NULL
-/// @throws TH_BUFFEREMPTY Thrown if the buffer is empty
-/// @throws TH_WRONGBUFFERDIM Thrown if the buffer len is less then one header
-bool HmpidDecodeRawMem::setUpStream(void* Buffer, long BufferLen)
-{
-  long wordsBufferLen = BufferLen / (sizeof(int32_t) / sizeof(char)); // Converts the len in words
-  if (Buffer == nullptr) {
-    LOG(error) << "Raw data buffer null Pointer ! ";
-    throw TH_NULLBUFFERPOINTER;
-  }
-  if (wordsBufferLen == 0) {
-    LOG(error) << "Raw data buffer Empty ! ";
-    throw TH_BUFFEREMPTY;
-  }
-  if (wordsBufferLen < 16) {
-    LOG(error) << "Raw data buffer less then the Header Dimension = " << wordsBufferLen;
-    throw TH_WRONGBUFFERDIM;
-  }
-
-  mActualStreamPtr = (uint32_t*)Buffer;                 // sets the pointer to the Buffer
-  mEndStreamPtr = ((uint32_t*)Buffer) + wordsBufferLen; //sets the End of buffer
-  mStartStreamPtr = ((uint32_t*)Buffer);
-  //  std::cout << " setUpStrem : StPtr=" << mStartStreamPtr << " EndPtr=" << mEndStreamPtr << " Len=" << wordsBufferLen << std::endl;
-  return (true);
-}
-
-/// Gets a sized chunk from the stream. The stream pointers members are updated
-/// @param[in] **streamPtr : the pointer to the memory buffer
-/// @param[in] Size : the dimension of the chunk (words)
-/// @returns True every time
-/// @throw TH_WRONGBUFFERDIM Buffer length shorter then the requested
-bool HmpidDecodeRawMem::getBlockFromStream(uint32_t** streamPtr, uint32_t Size)
-{
-  *streamPtr = mActualStreamPtr;
-  mActualStreamPtr += Size;
-  if (mActualStreamPtr > mEndStreamPtr) {
-    //    std::cout << " getBlockFromStream : StPtr=" << mActualStreamPtr << " EndPtr=" << mEndStreamPtr << " Len=" << Size << std::endl;
-    //    std::cout << "Beccato " << std::endl;
-    //    throw TH_WRONGBUFFERDIM;
-    return (false);
-  }
-  return (true);
-}
-
-/// Gets the Header Block from the stream.
-/// @param[in] **streamPtr : the pointer to the memory buffer
-/// @returns True if the header is read
-bool HmpidDecodeRawMem::getHeaderFromStream(uint32_t** streamPtr)
-{
-  return (getBlockFromStream(streamPtr, mRDHSize));
-}
-
-/// Gets a Word from the stream.
-/// @param[in] *word : the buffer for the read word
-/// @returns True if the operation end well
-bool HmpidDecodeRawMem::getWordFromStream(uint32_t* word)
-{
-  uint32_t* appo;
-  *word = *mActualStreamPtr;
-  return (getBlockFromStream(&appo, 1));
-}
-
-/// -----   Sets the Pad ! ------
-/// this is an overloaded method. In this version the value of the charge
-/// is used to update the statistical matrix of the base class
-///
-/// @param[in] *eq : the pointer to the Equipment object
-/// @param[in] col : the column [0..23]
-/// @param[in] dil : the dilogic [0..9]
-/// @param[in] ch : the channel [0..47]
-/// @param[in] charge : the value of the charge
-void HmpidDecodeRawMem::setPad(HmpidEquipment* eq, int col, int dil, int ch, uint16_t charge)
-{
-  eq->setPad(col, dil, ch, charge);
-  return;
-}
-
-// ========================================================================================
-
-/// Constructor : accepts the number of equipments to define
-///               The mapping is the default at P2
-///               Allocates instances for all defined equipments
-///               normally it is equal to 14
-/// @param[in] numOfEquipments : the number of equipments to define [1..14]
-HmpidDecodeRawDigit::HmpidDecodeRawDigit(int numOfEquipments)
-  : HmpidDecodeRawMem(numOfEquipments)
-{
-}
-
-/// Constructor : accepts the number of equipments to define
-///               and their complete address map
-///               Allocates instances for all defined equipments
-///
-///  The Address map is build from three array
-/// @param[in] numOfEquipments : the number of equipments to define [1..14]
-/// @param[in] *EqIds : the pointer to the Equipments ID array
-/// @param[in] *CruIds : the pointer to the CRU ID array
-/// @param[in] *LinkIds : the pointer to the Link ID array
-HmpidDecodeRawDigit::HmpidDecodeRawDigit(int* EqIds, int* CruIds, int* LinkIds, int numOfEquipments)
-  : HmpidDecodeRawMem(EqIds, CruIds, LinkIds, numOfEquipments)
-{
-}
-
-/// Destructor
-HmpidDecodeRawDigit::~HmpidDecodeRawDigit() = default;
-
-/// -----   Sets the Pad ! ------
-/// this is an overloaded method. In this version the value of the charge
-/// is used to update the statistical matrix of the base class
-///
-/// @param[in] *eq : the pointer to the Equipment object
-/// @param[in] col : the column [0..23]
-/// @param[in] dil : the dilogic [0..9]
-/// @param[in] ch : the channel [0..47]
-/// @param[in] charge : the value of the charge
-void HmpidDecodeRawDigit::setPad(HmpidEquipment* eq, int col, int dil, int ch, uint16_t charge)
-{
-  eq->setPad(col, dil, ch, charge);
-  mDigits.push_back(o2::hmpid::Digit(charge, eq->getEquipmentId(), col, dil, ch));
-  //std::cout << "DI " << mDigits.back() << " "<<col<<","<< dil<<","<< ch<<"="<< charge<<std::endl;
-  return;
-}
diff --git a/Detectors/HMPID/reconstruction/src/HmpidDecoder.cxx b/Detectors/HMPID/reconstruction/src/HmpidDecoder.cxx
deleted file mode 100644
index 6397d707d1b48..0000000000000
--- a/Detectors/HMPID/reconstruction/src/HmpidDecoder.cxx
+++ /dev/null
@@ -1,1134 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-///
-/// \file   HmpidDecoder.cxx
-/// \author Antonio Franco - INFN Bari
-/// \brief Base Class to decode HMPID Raw Data stream
-/// \version 1.1
-/// \date 17/11/2020
-
-/* ------ HISTORY ---------
-*/
-
-#include <fairlogger/Logger.h> // for LOG
-#include "Framework/Logger.h"
-#include "Headers/RAWDataHeader.h"
-#include "HMPIDReconstruction/HmpidDecoder.h"
-#include "DataFormatsHMP/Digit.h"
-
-using namespace o2::hmpid;
-
-// ============= HmpidDecoder Class implementation =======
-
-/// Decoding Error Messages Definitions
-char HmpidDecoder::sErrorDescription[MAXERRORS][MAXDESCRIPTIONLENGHT] = {"Word that I don't known !",
-                                                                         "Row Marker Word with 0 words", "Duplicated Pad Word !", "Row Marker Wrong/Lost -> to EoE",
-                                                                         "Row Marker Wrong/Lost -> to EoE", "Row Marker reports an ERROR !", "Lost EoE Marker !", "Double EoE marker",
-                                                                         "Wrong size definition in EoE Marker", "Double Mark Word", "Wrong Size in Segment Marker", "Lost EoS Marker !",
-                                                                         "HMPID Header Errors"};
-
-/// HMPID Firmware Error Messages Definitions
-char HmpidDecoder::sHmpidErrorDescription[MAXHMPIDERRORS][MAXDESCRIPTIONLENGHT] = {
-  "L0 Missing,"
-  "L1 is received without L0",
-  "L1A signal arrived before the L1 Latency", "L1A signal arrived after the L1 Latency",
-  "L1A is missing or L1 timeout", "L1A Message is missing or L1 Message"};
-
-/// Constructor : accepts the number of equipments to define
-///               The mapping is the default at P2
-///               Allocates instances for all defined equipments
-///               normally it is equal to 14
-/// @param[in] numOfEquipments : the number of equipments to define [1..14]
-HmpidDecoder::HmpidDecoder(int numOfEquipments)
-{
-  // The standard definition of HMPID equipments at P2
-  int EqIds[] = {0, 1, 2, 3, 4, 5, 8, 9, 6, 7, 10, 11, 12, 13};
-  int CruIds[] = {0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3, 3};
-  int LinkIds[] = {0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 0, 1, 2};
-
-  mNumberOfEquipments = numOfEquipments;
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    mTheEquipments[i] = new HmpidEquipment(EqIds[i], CruIds[i], LinkIds[i]);
-  }
-}
-
-/// Constructor : accepts the number of equipments to define
-///               and their complete address map
-///               Allocates instances for all defined equipments
-///
-///  The Address map is build from three array
-/// @param[in] numOfEquipments : the number of equipments to define [1..14]
-/// @param[in] *EqIds : the pointer to the Equipments ID array
-/// @param[in] *CruIds : the pointer to the CRU ID array
-/// @param[in] *LinkIds : the pointer to the Link ID array
-HmpidDecoder::HmpidDecoder(int* EqIds, int* CruIds, int* LinkIds, int numOfEquipments)
-{
-  mNumberOfEquipments = numOfEquipments;
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    mTheEquipments[i] = new HmpidEquipment(EqIds[i], CruIds[i], LinkIds[i]);
-  }
-}
-
-/// Destructor : remove the Equipments instances
-HmpidDecoder::~HmpidDecoder()
-{
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    delete mTheEquipments[i];
-  }
-}
-
-/// Init all the members variables.
-void HmpidDecoder::init()
-{
-  mRDHSize = sizeof(o2::header::RAWDataHeader) / sizeof(uint32_t);
-
-  mVerbose = 0;
-  mHeEvent = 0;
-  mHeBusy = 0;
-  mNumberWordToRead = 0;
-  mPayloadTail = 0;
-
-  mHeFEEID = 0;
-  mHeSize = 0;
-  mHeVer = 0;
-  mHePrior = 0;
-  mHeStop = 0;
-  mHePages = 0;
-  mEquipment = 0;
-
-  mHeOffsetNewPack = 0;
-  mHeMemorySize = 0;
-
-  mHeDetectorID = 0;
-  mHeDW = 0;
-  mHeCruID = 0;
-  mHePackNum = 0;
-  mHePAR = 0;
-  mHePageNum = 0;
-  mHeLinkNum = 0;
-  mHeFirmwareVersion = 0;
-  mHeHmpidError = 0;
-  mHeBCDI = 0;
-  mHeORBIT = 0;
-  mHeTType = 0;
-
-  mActualStreamPtr = nullptr;
-  mEndStreamPtr = nullptr;
-  mStartStreamPtr = nullptr;
-
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    mTheEquipments[i]->init();
-  }
-}
-
-/// Returns the Equipment Index (Pointer of the array) converting
-/// the FLP hardware coords (CRU_Id and Link_Id)
-/// @param[in] CruId : the CRU ID [0..3] -> FLP 160 = [0,1]  FLP 161 = [2,3]
-/// @param[in] LinkId : the Link ID [0..3]
-/// @returns EquipmentIndex : the index in the Equipment array [0..13] (-1 := error)
-int HmpidDecoder::getEquipmentIndex(int CruId, int LinkId)
-{
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    if (mTheEquipments[i]->getEquipmentId(CruId, LinkId) != -1) {
-      return (i);
-    }
-  }
-  return (-1);
-}
-
-/// Returns the Equipment Index (Pointer of the array) converting
-/// the Equipment_ID (Firmaware defined Id AKA FFEID)
-/// @param[in] EquipmentId : the Equipment ID [0..13]
-/// @returns EquipmentIndex : the index in the Equipment array [0..13] (-1 := error)
-int HmpidDecoder::getEquipmentIndex(int EquipmentId)
-{
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    if (mTheEquipments[i]->getEquipmentId() == EquipmentId) {
-      return (i);
-    }
-  }
-  return (-1);
-}
-
-/// Returns the Equipment_ID converting the FLP hardware coords
-/// @param[in] CruId : the CRU ID [0..3] -> FLP 160 = [0,1]  FLP 161 = [2,3]
-/// @param[in] LinkId : the Link ID [0..3]
-/// @returns EquipmentID : the ID of the Equipment [0..13] (-1 := error)
-int HmpidDecoder::getEquipmentID(int CruId, int LinkId)
-{
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    if (mTheEquipments[i]->getEquipmentId(CruId, LinkId) != -1) {
-      return (mTheEquipments[i]->getEquipmentId());
-    }
-  }
-  return (-1);
-}
-
-/// Scans the BitMap of Raw Data File word and detect the type
-/// and the parameters
-/// @param[in] wp : the word to analyze
-/// @param[out] *p1 : first parameter extract (if it exists)
-/// @param[out] *p2 : second parameter extract (if it exists)
-/// @param[out] *p3 : third parameter extract (if it exists)
-/// @param[out] *p4 : fourth parameter extract (if it exists)
-/// @returns Type of Word : the type of word [0..4] (0 := undetect)
-int HmpidDecoder::checkType(uint32_t wp, int* p1, int* p2, int* p3, int* p4)
-{
-  if ((wp & 0x0000ffff) == 0x000036A8 || (wp & 0x0000ffff) == 0x000032A8 || (wp & 0x0000ffff) == 0x000030A0 || (wp & 0x0800ffff) == 0x080010A0) {
-    *p2 = (wp & 0x03ff0000) >> 16; // Number of words of row
-    *p1 = wp & 0x0000ffff;
-    return (WTYPE_ROW);
-  }
-  if ((wp & 0xfff00000) >> 20 == 0xAB0) {
-    *p2 = (wp & 0x000fff00) >> 8; // Number of words of Segment
-    *p1 = (wp & 0xfff00000) >> 20;
-    *p3 = wp & 0x0000000F;
-    if (*p3 < 4 && *p3 > 0) {
-      return (WTYPE_EOS);
-    }
-  }
-  // #EX MASK Raul 0x3803FF80  # ex mask 0xF803FF80 - this is EoE marker 0586800B0
-  if ((wp & 0x0803FF80) == 0x08000080) {
-    *p1 = (wp & 0x07c00000) >> 22;
-    *p2 = (wp & 0x003C0000) >> 18;
-    *p3 = (wp & 0x0000007F);
-    if (*p1 < 25 && *p2 < 11) {
-      return (WTYPE_EOE);
-    }
-  }
-  if ((wp & 0x08000000) == 0) { //  # this is a pad
-    // PAD:0000.0ccc.ccdd.ddnn.nnnn.vvvv.vvvv.vvvv :: c=col,d=dilo,n=chan,v=value
-    *p1 = (wp & 0x07c00000) >> 22;
-    *p2 = (wp & 0x003C0000) >> 18;
-    *p3 = (wp & 0x0003F000) >> 12;
-    *p4 = (wp & 0x00000FFF);
-    if (*p1 > 0 && *p1 < 25 && *p2 > 0 && *p2 < 11 && *p3 < 48) {
-      return (WTYPE_PAD);
-    }
-  } else {
-    return (WTYPE_NONE);
-  }
-  return (WTYPE_NONE);
-}
-
-/// Checks if is a Raw Marker and extract the Row Size
-/// @param[in] wp : the word to check
-/// @param[out] *Err : true if an error is detected
-/// @param[out] *rowSize : the number of words of the row
-/// @param[out] *mark : the row marker
-/// @returns True if Row Marker is detected
-bool HmpidDecoder::isRowMarker(uint32_t wp, int* Err, int* rowSize, int* mark)
-{
-  if ((wp & 0x0000ffff) == 0x36A8 || (wp & 0x0000ffff) == 0x32A8 || (wp & 0x0000ffff) == 0x30A0 || (wp & 0x0800ffff) == 0x080010A0) {
-    *rowSize = (wp & 0x03ff0000) >> 16; // # Number of words of row
-    *mark = wp & 0x0000ffff;
-    *Err = false;
-    return (true);
-  } else {
-    *Err = true;
-    return (false);
-  }
-}
-
-/// Checks if is a Segment Marker and extracts the Segment number and the size
-/// @param[in] wp : the word to check
-/// @param[out] *Err : true if an error is detected
-/// @param[out] *segSize : the number of words of the segment
-/// @param[out] *Seg : the Segment number [1..3]
-/// @param[out] *mark : the Segment Marker
-/// @returns True if Segment Marker is detected
-bool HmpidDecoder::isSegmentMarker(uint32_t wp, int* Err, int* segSize, int* Seg, int* mark)
-{
-  *Err = false;
-  if ((wp & 0xfff00000) >> 20 == 0xAB0) {
-    *segSize = (wp & 0x000fff00) >> 8; // # Number of words of Segment
-    *mark = (wp & 0xfff00000) >> 20;
-    *Seg = wp & 0x0000000F;
-    if (*Seg > 3 || *Seg < 1) {
-      LOG(info) << " Wrong segment Marker Word, bad Number of segment" << *Seg << "!";
-      *Err = true;
-    }
-    return (true);
-  } else {
-    return (false);
-  }
-}
-
-/// Checks if is a PAD Word and extracts all the parameters
-/// PAD map : 0000.0ccc.ccdd.ddnn.nnnn.vvvv.vvvv.vvvv :: c=col,d=dilo,n=chan,v=value
-/// @param[in] wp : the word to check
-/// @param[out] *Err : true if an error is detected
-/// @param[out] *Col : the column number [1..24]
-/// @param[out] *Dilogic : the dilogic number [1..10]
-/// @param[out] *Channel : the channel number [0..47]
-/// @param[out] *Charge : the value of Charge [0..4095]
-/// @returns True if PAD Word is detected
-bool HmpidDecoder::isPadWord(uint32_t wp, int* Err, int* Col, int* Dilogic, int* Channel, int* Charge)
-{
-  *Err = false;
-  //  if ((wp & 0x08000000) != 0) {
-  if ((wp & 0x08000000) != 0) {
-    return (false);
-  }
-  *Col = (wp & 0x07c00000) >> 22;
-  *Dilogic = (wp & 0x003C0000) >> 18;
-  *Channel = (wp & 0x0003F000) >> 12;
-  *Charge = (wp & 0x00000FFF);
-
-  if ((wp & 0x0ffff) == 0x036A8 || (wp & 0x0ffff) == 0x032A8 || (wp & 0x0ffff) == 0x030A0 || (wp & 0x0ffff) == 0x010A0) { //  # ! this is a pad
-    if (*Dilogic > 10 || *Channel > 47 || *Dilogic < 1 || *Col > 24 || *Col < 1) {
-      return (false);
-    }
-  } else {
-    if (*Dilogic > 10 || *Channel > 47 || *Dilogic < 1 || *Col > 24 || *Col < 1) {
-      //    LOG(warning) << " Wrong Pad values Col=" << *Col << " Dilogic=" << *Dilogic << " Channel=" << *Channel << " Charge=" << *Charge << " wp:0x" << std::hex << wp << std::dec;
-      *Err = true;
-      return (false);
-    }
-  }
-  return (true);
-}
-
-/// Checks if is a EoE Marker and extracts the Column, Dilogic and the size
-/// @param[in] wp : the word to check
-/// @param[out] *Err : true if an error is detected
-/// @param[out] *Col : the column number [1..24]
-/// @param[out] *Dilogic : the dilogic number [1..10]
-/// @param[out] *Eoesize : the number of words for dilogic
-/// @returns True if EoE marker is detected
-bool HmpidDecoder::isEoEmarker(uint32_t wp, int* Err, int* Col, int* Dilogic, int* Eoesize)
-{
-  *Err = false;
-  // #EX MASK Raul 0x3803FF80  # ex mask 0xF803FF80 - this is EoE marker 0586800B0
-  if ((wp & 0x0803FF80) == 0x08000080) {
-    *Col = (wp & 0x07c00000) >> 22;
-    *Dilogic = (wp & 0x003C0000) >> 18;
-    *Eoesize = (wp & 0x0000007F);
-    if (*Col > 24 || *Dilogic > 10) {
-      LOG(info) << " EoE size wrong definition. Col=" << *Col << " Dilogic=" << *Dilogic;
-      *Err = true;
-    }
-    return (true);
-  } else {
-    return (false);
-  }
-}
-
-/// Decode the HMPID error BitMap field (5 bits) and returns true if there are
-/// errors and in addition the concat string that contains the error messages
-/// ATTENTION : the char * outbuf MUST point to a 250 bytes buffer
-/// @param[in] ErrorField : the HMPID Error field
-/// @param[out] *outbuf : the output buffer that contains the error description
-/// @returns True if EoE marker is detected
-bool HmpidDecoder::decodeHmpidError(int ErrorField, char* outbuf)
-{
-  int res = false;
-  outbuf[0] = '\0';
-  for (int i = 0; i < MAXHMPIDERRORS; i++) {
-    if ((ErrorField & (0x01 << i)) != 0) {
-      res = true;
-      strcat(outbuf, sHmpidErrorDescription[i]);
-    }
-  }
-  return (res);
-}
-
-/// This Decode the Raw Data Header, returns the EquipmentIndex
-/// that is obtained with the FLP hardware coords
-///
-/// ATTENTION : the 'EquipIndex' parameter and the mEquipment member
-/// are different data: the first is the pointer in the Equipments instances
-/// array, the second is the FEE_ID number
-///
-/// The EVENT_NUMBER : actually is calculated from the ORBIT number
-///
-/// @param[in] *streamPtrAdr : the pointer to the Header buffer
-/// @param[out] *EquipIndex : the Index to the Equipment Object Array [0..13]
-/// @returns True every time
-/// @throws TH_WRONGEQUIPINDEX Thrown if the Equipment Index is out of boundary (Equipment not recognized)
-int HmpidDecoder::decodeHeader(uint32_t* streamPtrAdr, int* EquipIndex)
-{
-  uint32_t* buffer = streamPtrAdr; // Sets the pointer to buffer
-  o2::header::RAWDataHeader* hpt = (o2::header::RAWDataHeader*)buffer;
-
-  /*
-  mHeFEEID = (buffer[0] & 0x000f0000) >> 16;
-  mHeSize = (buffer[0] & 0x0000ff00) >> 8;
-  mHeVer = (buffer[0] & 0x000000ff);
-  mHePrior = (buffer[1] & 0x000000FF);
-  mHeDetectorID = (buffer[1] & 0x0000FF00) >> 8;
-  mHeOffsetNewPack = (buffer[2] & 0x0000FFFF);
-  mHeMemorySize = (buffer[2] & 0xffff0000) >> 16;
-  mHeDW = (buffer[3] & 0xF0000000) >> 24;
-  mHeCruID = (buffer[3] & 0x0FF0000) >> 16;
-  mHePackNum = (buffer[3] & 0x0000FF00) >> 8;
-  mHeLinkNum = (buffer[3] & 0x000000FF);
-  mHeBCDI = (buffer[4] & 0x00000FFF);
-  mHeORBIT = buffer[5];
-  mHeTType = buffer[8];
-  mHePageNum = (buffer[9] & 0x0000FFFF);
-  mHeStop = (buffer[9] & 0x00ff0000) >> 16;
-  mHeBusy = (buffer[12] & 0xfffffe00) >> 9;
-  mHeFirmwareVersion = buffer[12] & 0x0000000f;
-  mHeHmpidError = (buffer[12] & 0x000001F0) >> 4;
-  mHePAR = buffer[13] & 0x0000FFFF;
-  */
-  mHeFEEID = hpt->feeId;
-  mHeSize = hpt->headerSize;
-  mHeVer = hpt->version;
-  mHePrior = hpt->priority;
-  mHeDetectorID = hpt->sourceID;
-  mHeOffsetNewPack = hpt->offsetToNext;
-  mHeMemorySize = hpt->memorySize;
-  mHeDW = hpt->endPointID;
-  mHeCruID = hpt->cruID;
-  mHePackNum = hpt->packetCounter;
-  mHeLinkNum = hpt->linkID;
-  mHeBCDI = hpt->bunchCrossing;
-  mHeORBIT = hpt->orbit;
-  mHeTType = hpt->triggerType;
-  mHePageNum = hpt->pageCnt;
-  mHeStop = hpt->stop;
-  mHeBusy = (hpt->detectorField & 0xfffffe00) >> 9;
-  mHeFirmwareVersion = hpt->detectorField & 0x0000000f;
-  mHeHmpidError = (hpt->detectorField & 0x000001F0) >> 4;
-  mHePAR = hpt->detectorPAR;
-
-  *EquipIndex = getEquipmentIndex(mHeCruID, mHeLinkNum);
-  //  mEquipment = (*EquipIndex != -1) ? mTheEquipments[*EquipIndex]->getEquipmentId() : -1;
-  mEquipment = mHeFEEID & 0x000F;
-  mNumberWordToRead = ((mHeMemorySize - mHeSize) / sizeof(uint32_t));
-  mPayloadTail = ((mHeOffsetNewPack - mHeMemorySize) / sizeof(uint32_t));
-
-  // ---- Event ID  : Actualy based on ORBIT NUMBER and BC
-  mHeEvent = (mHeORBIT << 12) | mHeBCDI;
-
-  LOG(debug) << "FEE-ID=" << mHeFEEID << " HeSize=" << mHeSize << " HePrior=" << mHePrior << " Det.Id=" << mHeDetectorID << " HeMemorySize=" << mHeMemorySize << " HeOffsetNewPack=" << mHeOffsetNewPack;
-  LOG(debug) << "      Equipment=" << mEquipment << " PakCounter=" << mHePackNum << " Link=" << mHeLinkNum << " CruID=" << mHeCruID << " DW=" << mHeDW << " BC=" << mHeBCDI << " ORBIT=" << mHeORBIT;
-  LOG(debug) << "      TType=" << mHeTType << " HeStop=" << mHeStop << " PagesCounter=" << mHePageNum << " FirmVersion=" << mHeFirmwareVersion << " BusyTime=" << mHeBusy << " Error=" << mHeHmpidError << " PAR=" << mHePAR;
-  LOG(debug) << "      EquIdx = " << *EquipIndex << " Event = " << mHeEvent << " Payload :  Words to read=" << mNumberWordToRead << " PailoadTail=" << mPayloadTail;
-
-  if (*EquipIndex == -1) {
-    LOG(error) << "ERROR ! Bad equipment Number: " << mEquipment;
-    throw TH_WRONGEQUIPINDEX;
-  }
-  // std::cout << "HMPID ! Exit decode header" << std::endl;
-  return (true);
-}
-
-/// Updates some information related to the Event
-/// this function is called at the end of the event
-/// @param[in] *eq : the pointer to the Equipment Object
-void HmpidDecoder::updateStatistics(HmpidEquipment* eq)
-{
-  eq->mPadsPerEventAverage = ((eq->mPadsPerEventAverage * (eq->mNumberOfEvents - 1)) + eq->mSampleNumber) / (eq->mNumberOfEvents);
-  eq->mEventSizeAverage = ((eq->mEventSizeAverage * (eq->mNumberOfEvents - 1)) + eq->mEventSize) / (eq->mNumberOfEvents);
-  eq->mBusyTimeAverage = ((eq->mBusyTimeAverage * eq->mBusyTimeSamples) + eq->mBusyTimeValue) / (++(eq->mBusyTimeSamples));
-  if (eq->mSampleNumber == 0) {
-    eq->mNumberOfEmptyEvents += 1;
-  }
-  if (eq->mErrorsCounter > 0) {
-    eq->mNumberOfWrongEvents += 1;
-  }
-  eq->mTotalPads += eq->mSampleNumber;
-  eq->mTotalErrors += eq->mErrorsCounter;
-
-  //std::cout << ">>>updateStatistics() >>> "<< eq->getEquipmentId() << "="<< eq->mNumberOfEvents<<" :" << eq->mEventSize <<","<< eq->mTotalPads << ", " << eq->mSampleNumber << std::endl;
-
-  return;
-}
-
-/// Evaluates the content of the header and detect the change of the event
-/// with the relevant updates...
-/// @param[in] EquipmentIndex : the pointer to the Array of Equipments Array
-/// @returns the Pointer to the modified Equipment object
-HmpidEquipment* HmpidDecoder::evaluateHeaderContents(int EquipmentIndex)
-{
-  //std::cout << "Enter evaluateHeaderContents..";
-  HmpidEquipment* eq = mTheEquipments[EquipmentIndex];
-  if (mHeEvent != eq->mEventNumber) {              // Is a new event
-    if (eq->mEventNumber != OUTRANGEEVENTNUMBER) { // skip the first
-      updateStatistics(eq);                        // update previous statistics
-    }
-    eq->mNumberOfEvents++;
-    eq->mEventNumber = mHeEvent;
-    eq->mBusyTimeValue = mHeBusy * 0.00000005;
-    eq->mEventSize = 0; // reset the event
-    eq->mSampleNumber = 0;
-    eq->mErrorsCounter = 0;
-    mIntReco = {(uint16_t)mHeBCDI, (uint32_t)mHeORBIT};
-  }
-  eq->mEventSize += mNumberWordToRead * sizeof(uint32_t); // Calculate the size in bytes
-  if (mHeHmpidError != 0) {
-    LOG(info) << "HMPID Header reports an error : " << mHeHmpidError;
-    dumpHmpidError(mHeHmpidError);
-    eq->setError(ERR_HMPID);
-  }
-  // std::cout << ".. end evaluateHeaderContents = " << eq->mEventNumber << std::endl;
-  return (eq);
-}
-
-/// --------------- Decode One Page from Data Buffer ---------------
-/// Read the stream, decode the contents and store resuls.
-/// ATTENTION : Assumes that the input stream was set
-/// @throws TH_WRONGHEADER Thrown if the Fails to decode the Header
-/// @param[in] streamBuf : the pointer to the Pointer of the Stream Buffer
-void HmpidDecoder::decodePage(uint32_t** streamBuf)
-{
-  int equipmentIndex;
-  try {
-    getHeaderFromStream(streamBuf);
-  } catch (int e) {
-    // The stream end !
-    LOG(debug) << "End main decoding loop !";
-    throw TH_BUFFEREMPTY;
-  }
-  try {
-    decodeHeader(*streamBuf, &equipmentIndex);
-  } catch (int e) {
-    LOG(error) << "Failed to decode the Header !";
-    throw TH_WRONGHEADER;
-  }
-
-  HmpidEquipment* eq = evaluateHeaderContents(equipmentIndex);
-
-  uint32_t wpprev = 0;
-  uint32_t wp = 0;
-  int newOne = true;
-  int p1, p2, p3, p4;
-  int error;
-  int type;
-  bool isIt;
-
-  int payIndex = 0;
-  while (payIndex < mNumberWordToRead) { //start the payload loop word by word
-    if (newOne == true) {
-      wpprev = wp;
-      if (!getWordFromStream(&wp)) { // end the stream
-        break;
-      }
-      type = checkType(wp, &p1, &p2, &p3, &p4);
-      if (type == WTYPE_NONE) {
-        if (eq->mWillBePad == true) { // try to recover the first pad !
-          type = checkType((wp & 0xF7FFFFFF), &p1, &p2, &p3, &p4);
-          if (type == WTYPE_PAD && p3 == 0 && eq->mWordsPerDilogicCounter == 0) {
-            newOne = false; // # reprocess as pad
-            continue;
-          }
-        }
-        eq->setError(ERR_NOTKNOWN);
-        LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_NOTKNOWN] << " [" << wp << "]";
-        eq->mWordsPerRowCounter++;
-        eq->mWordsPerSegCounter++;
-        payIndex++;
-        continue;
-      }
-    }
-    if (mEquipment == 8) {
-      LOG(info) << "Event" << eq->mEventNumber << " >" << std::hex << wp << std::dec << "<" << type;
-    }
-    if (eq->mWillBeRowMarker == true) { // #shoud be a Row Marker
-      if (type == WTYPE_ROW) {
-        eq->mColumnCounter++;
-        eq->mWordsPerSegCounter++;
-        eq->mRowSize = p2;
-        switch (p2) {
-          case 0: // Empty column
-            eq->setError(ERR_ROWMARKEMPTY);
-            LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_ROWMARKEMPTY] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-            eq->mWillBeRowMarker = true;
-            break;
-          case 0x3FF: // Error in column
-            eq->setError(ERR_ROWMARKERROR);
-            LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_ROWMARKERROR] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-            eq->mWillBeRowMarker = true;
-            break;
-          case 0x3FE: // Masked column
-            LOG(info) << "Equip=" << mEquipment << "The column=" << (eq->mSegment) * 8 + eq->mColumnCounter << " is Masked !";
-            eq->mWillBeRowMarker = true;
-            break;
-          default:
-            eq->mWillBeRowMarker = false;
-            eq->mWillBePad = true;
-            break;
-        }
-        newOne = true;
-      } else {
-        if (wp == wpprev) {
-          eq->setError(ERR_DUPLICATEPAD);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_DUPLICATEPAD] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-          newOne = true;
-        } else if (type == WTYPE_EOE) { // # Could be a EoE
-          eq->mColumnCounter++;
-          eq->setError(ERR_ROWMARKWRONG);
-          eq->mWillBeRowMarker = false;
-          eq->mWillBePad = true;
-          newOne = true;
-        } else if (type == WTYPE_PAD) { //# Could be a PAD
-          eq->mColumnCounter++;
-          eq->setError(ERR_ROWMARKLOST);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_ROWMARKLOST] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-          eq->mWillBeRowMarker = false;
-          eq->mWillBePad = true;
-          newOne = true;
-        } else if (type == WTYPE_EOS) { // # Could be a EoS
-          eq->mWillBeRowMarker = false;
-          eq->mWillBeSegmentMarker = true;
-          newOne = false;
-        } else {
-          eq->mColumnCounter++;
-          eq->setError(ERR_ROWMARKLOST);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_ROWMARKLOST] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-          eq->mWillBeRowMarker = false;
-          eq->mWillBePad = true;
-          newOne = true;
-        }
-      }
-    } else if (eq->mWillBePad == true) { // # We expect a pad
-      //# PAD:0000.0ccc.ccdd.ddnn.nnnn.vvvv.vvvv.vvvv :: c=col,d=dilo,n=chan,v=value
-      //   c = 1..24   d = 1..10  n = 0..47
-      if (type == WTYPE_PAD) {
-        newOne = true;
-        if (wp == wpprev) {
-          eq->setError(ERR_DUPLICATEPAD);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_DUPLICATEPAD] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-        } else if (p1 != (eq->mSegment * 8 + eq->mColumnCounter)) { // # Manage
-          // We try to recover the RowMarker misunderstanding
-          isIt = isRowMarker(wp, &error, &p2, &p1);
-          if (isIt == true && error == false) {
-            type = WTYPE_ROW;
-            newOne = false;
-            eq->mWillBeEoE = true;
-            eq->mWillBePad = false;
-          } else {
-            LOG(debug) << "Equip=" << mEquipment << " Mismatch in column"
-                       << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-            eq->mColumnCounter = p1 % 8;
-          }
-        } else {
-          setPad(eq, p1 - 1, p2 - 1, p3, p4);
-          if (mEquipment == 8) {
-            LOG(info) << "Event" << eq->mEventNumber << " >" << p1 - 1 << "," << p2 - 1 << "," << p3 << "," << p4;
-          }
-          eq->mWordsPerDilogicCounter++;
-          eq->mSampleNumber++;
-          if (p3 == 47) {
-            eq->mWillBeEoE = true;
-            eq->mWillBePad = false;
-          }
-        }
-        eq->mWordsPerRowCounter++;
-        eq->mWordsPerSegCounter++;
-      } else if (type == WTYPE_EOE) { //# the pads are end ok
-        eq->mWillBeEoE = true;
-        eq->mWillBePad = false;
-        newOne = false;
-      } else if (type == WTYPE_ROW) { // # We Lost the EoE !
-        // We try to recover the PAD misunderstanding
-        isIt = isPadWord(wp, &error, &p1, &p2, &p3, &p4);
-        if (isIt == true && error == false) {
-          type = WTYPE_PAD;
-          newOne = false; // # reprocess as pad
-        } else {
-          eq->setError(ERR_LOSTEOEMARK);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_LOSTEOEMARK] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-          eq->mWillBeRowMarker = true;
-          eq->mWillBePad = false;
-          newOne = false;
-        }
-      } else if (type == WTYPE_EOS) { // # We Lost the EoE !
-        eq->setError(ERR_LOSTEOEMARK);
-        LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_LOSTEOEMARK] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-        eq->mWillBeSegmentMarker = true;
-        eq->mWillBePad = false;
-        newOne = false;
-      }
-    } else if (eq->mWillBeEoE == true) { // # We expect a EoE
-      if (type == WTYPE_EOE) {
-        eq->mWordsPerRowCounter++;
-        eq->mWordsPerSegCounter++;
-        if (wpprev == wp) {
-          eq->setError(ERR_DOUBLEEOEMARK);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_DOUBLEEOEMARK] << " col=" << p1;
-        } else if (p3 != eq->mWordsPerDilogicCounter) {
-          eq->setError(ERR_WRONGSIZEINEOE);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_WRONGSIZEINEOE] << " col=" << p1;
-        }
-        eq->mWordsPerDilogicCounter = 0;
-        if (p2 == 10) {
-          if (p1 % 8 != 0) { // # we expect the Row Marker
-            eq->mWillBeRowMarker = true;
-          } else {
-            eq->mWillBeSegmentMarker = true;
-          }
-        } else {
-          eq->mWillBePad = true;
-        }
-        eq->mWillBeEoE = false;
-        newOne = true;
-      } else if (type == WTYPE_EOS) { // We Lost the EoE !
-        eq->setError(ERR_LOSTEOEMARK);
-        LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_LOSTEOEMARK] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-        eq->mWillBeSegmentMarker = true;
-        eq->mWillBeEoE = false;
-        newOne = false;
-      } else if (type == WTYPE_ROW) { //# We Lost the EoE !
-        eq->setError(ERR_LOSTEOEMARK);
-        LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_LOSTEOEMARK] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-        eq->mWillBeRowMarker = true;
-        eq->mWillBeEoE = false;
-        newOne = false;
-      } else if (type == WTYPE_PAD) { // # We Lost the EoE !
-        int typb, p1b, p2b, p3b, p4b;
-        typb = checkType((wp | 0x08000000), &p1b, &p2b, &p3b, &p4b);
-        if (typb == WTYPE_EOE && p3b == 48) {
-          type = typb;
-          p1 = p1b;
-          p2 = p2b;
-          p3 = p3b;
-          p4 = p4b;
-          newOne = false; // # reprocess as EoE
-        } else {
-          eq->setError(ERR_LOSTEOEMARK);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_LOSTEOEMARK] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-          eq->mWillBePad = true;
-          eq->mWillBeEoE = false;
-          newOne = false;
-        }
-      }
-    } else if (eq->mWillBeSegmentMarker == true) { // # We expect a EoSegment
-      if (wpprev == wp) {
-        eq->setError(ERR_DOUBLEMARKWORD);
-        LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_DOUBLEMARKWORD] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-        newOne = true;
-      } else if (type == 2) {
-        if (abs(eq->mWordsPerSegCounter - p2) > 5) {
-          eq->setError(ERR_WRONGSIZESEGMENTMARK);
-          LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_WRONGSIZESEGMENTMARK] << " Seg=" << p2;
-        }
-        eq->mWordsPerSegCounter = 0;
-        eq->mWordsPerRowCounter = 0;
-        eq->mColumnCounter = 0;
-        eq->mSegment = p3 % 3;
-        eq->mWillBeRowMarker = true;
-        eq->mWillBeSegmentMarker = false;
-        newOne = true;
-      } else {
-        eq->setError(ERR_LOSTEOSMARK);
-        LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_LOSTEOSMARK] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << p1 << "]";
-        eq->mWillBeSegmentMarker = false;
-        eq->mWillBeRowMarker = true;
-        newOne = false;
-      }
-    }
-    if (newOne) {
-      payIndex += 1;
-    }
-  }
-  for (int i = 0; i < mPayloadTail; i++) { // move the pointer to skip the Payload Tail
-    getWordFromStream(&wp);
-  }
-}
-
-/// --------------- Read Raw Data Buffer ---------------
-/// Read the stream, decode the contents and store resuls.
-/// ATTENTION : Assumes that the input stream was set
-/// @throws TH_WRONGHEADER Thrown if the Fails to decode the Header
-bool HmpidDecoder::decodeBuffer()
-{
-  // ---------resets the PAdMap-----------
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    mTheEquipments[i]->init();
-    mTheEquipments[i]->resetPadMap();
-    mTheEquipments[i]->resetErrors();
-  }
-
-  int type;
-  int equipmentIndex = -1;
-  int isIt;
-  HmpidEquipment* eq;
-  uint32_t* streamBuf;
-  LOG(debug) << "Enter decoding !";
-
-  // Input Stream Main Loop
-  while (true) {
-    try {
-      decodePage(&streamBuf);
-    } catch (int e) {
-      LOG(debug) << "End main buffer decoding loop !";
-      break;
-    }
-  } // this is the end of stream
-
-  // cycle in order to update info for the last event
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    if (mTheEquipments[i]->mNumberOfEvents > 0) {
-      updateStatistics(mTheEquipments[i]);
-    }
-  }
-  return (true);
-}
-
-/// --------- Decode One Page from Data Buffer with Fast Decoding --------
-/// Read the stream, decode the contents and store resuls.
-/// ATTENTION : Assumes that the input stream was set
-/// @throws TH_WRONGHEADER Thrown if the Fails to decode the Header
-/// @param[in] streamBuf : the pointer to the Pointer of the Stream Buffer
-void HmpidDecoder::decodePageFast(uint32_t** streamBuf)
-{
-  int equipmentIndex;
-  try {
-    getHeaderFromStream(streamBuf);
-  } catch (int e) {
-    // The stream end !
-    LOG(info) << "End Fast Page decoding loop !";
-    throw TH_BUFFEREMPTY;
-  }
-  try {
-    decodeHeader(*streamBuf, &equipmentIndex);
-  } catch (int e) {
-    LOG(info) << "Failed to decode the Header !";
-    throw TH_WRONGHEADER;
-  }
-  HmpidEquipment* eq = evaluateHeaderContents(equipmentIndex);
-  uint32_t wpprev = 0;
-  uint32_t wp = 0;
-  int newOne = true;
-  int Column, Dilogic, Channel, Charge;
-  int pwer;
-  int payIndex = 0;
-  while (payIndex < mNumberWordToRead) { //start the payload loop word by word
-    wpprev = wp;
-    if (!getWordFromStream(&wp)) { // end the stream
-      break;
-    }
-    if (wp == wpprev) {
-      LOG(debug) << "Equip=" << mEquipment << sErrorDescription[ERR_DUPLICATEPAD] << " col=" << (eq->mSegment) * 8 + eq->mColumnCounter << "[" << Column << "]";
-    } else {
-      if (isPadWord(wp, &pwer, &Column, &Dilogic, &Channel, &Charge) == true) {
-        if (pwer != true) {
-          setPad(eq, Column - 1, Dilogic - 1, Channel, Charge);
-          eq->mSampleNumber++;
-        }
-      }
-    }
-    payIndex += 1;
-  }
-  for (int i = 0; i < mPayloadTail; i++) { // move the pointer to skip the Payload Tail
-    getWordFromStream(&wp);
-  }
-  return;
-}
-/// ---------- Read Raw Data Buffer with Fast Decoding ----------
-/// Read the stream, decode the contents and store resuls.
-/// Fast alghoritm : no parsing of control words !
-/// ATTENTION : Assumes that the input stream was set
-/// @throws TH_WRONGHEADER Thrown if the Fails to decode the Header
-bool HmpidDecoder::decodeBufferFast()
-{
-  // ---------resets the PAdMap-----------
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    mTheEquipments[i]->init();
-    mTheEquipments[i]->resetPadMap();
-  }
-
-  uint32_t* streamBuf;
-  LOG(info) << "Enter FAST decoding !";
-
-  // Input Stream Main Loop
-  while (true) {
-    try {
-      decodePageFast(&streamBuf);
-    } catch (int e) {
-      LOG(info) << " End Buffer Fast Decoding !";
-      break;
-    }
-  } // this is the end of stream
-
-  // cycle in order to update info for the last event
-  for (int i = 0; i < mNumberOfEquipments; i++) {
-    if (mTheEquipments[i]->mNumberOfEvents > 0) {
-      updateStatistics(mTheEquipments[i]);
-    }
-  }
-  return (true);
-}
-
-// =========================================================
-
-/// Getter method to extract Statistic Data in Digit Coords
-/// @param[in] Module : the HMPID Module number [0..6]
-/// @param[in] Column : the HMPID Module Column number [0..143]
-/// @param[in] Row : the HMPID Module Row number [0..159]
-/// @returns The Number of entries for specified pad
-uint16_t HmpidDecoder::getPadSamples(int Module, int Row, int Column)
-{
-  int e, c, d, h;
-  o2::hmpid::Digit::absolute2Equipment(Module, Row, Column, &e, &c, &d, &h);
-  int EqInd = getEquipmentIndex(e);
-  if (EqInd < 0) {
-    return (0);
-  }
-  return (mTheEquipments[EqInd]->mPadSamples[c][d][h]);
-}
-
-/// Getter method to extract Statistic Data in Digit Coords
-/// @param[in] Module : the HMPID Module number [0..6]
-/// @param[in] Column : the HMPID Module Column number [0..143]
-/// @param[in] Row : the HMPID Module Row number [0..159]
-/// @returns The Sum of Charges for specified pad
-double HmpidDecoder::getPadSum(int Module, int Row, int Column)
-{
-  int e, c, d, h;
-  o2::hmpid::Digit::absolute2Equipment(Module, Row, Column, &e, &c, &d, &h);
-  int EqInd = getEquipmentIndex(e);
-  if (EqInd < 0) {
-    return (0);
-  }
-  return (mTheEquipments[EqInd]->mPadSum[c][d][h]);
-}
-
-/// Getter method to extract Statistic Data in Digit Coords
-/// @param[in] Module : the HMPID Module number [0..6]
-/// @param[in] Column : the HMPID Module Column number [0..143]
-/// @param[in] Row : the HMPID Module Row number [0..159]
-/// @returns The Sum of Square Charges for specified pad
-double HmpidDecoder::getPadSquares(int Module, int Row, int Column)
-{
-  int e, c, d, h;
-  o2::hmpid::Digit::absolute2Equipment(Module, Row, Column, &e, &c, &d, &h);
-  int EqInd = getEquipmentIndex(e);
-  if (EqInd < 0) {
-    return (0);
-  }
-  return (mTheEquipments[EqInd]->mPadSquares[c][d][h]);
-}
-
-/// Getter method to extract Statistic Data in Hardware Coords
-/// @param[in] EquipmId : the HMPID EquipmentId [0..13]
-/// @param[in] Column : the HMPID Module Column number [0..23]
-/// @param[in] Dilogic : the HMPID Module Row number [0..9]
-/// @param[in] Channel : the HMPID Module Row number [0..47]
-/// @returns The Number of Entries for specified pad
-uint16_t HmpidDecoder::getChannelSamples(int EquipmId, int Column, int Dilogic, int Channel)
-{
-  int EqInd = getEquipmentIndex(EquipmId);
-  if (EqInd < 0) {
-    return (0);
-  }
-  return (mTheEquipments[EqInd]->mPadSamples[Column][Dilogic][Channel]);
-}
-
-/// Getter method to extract Statistic Data in Hardware Coords
-/// @param[in] EquipmId : the HMPID EquipmentId [0..13]
-/// @param[in] Column : the HMPID Module Column number [0..23]
-/// @param[in] Dilogic : the HMPID Module Row number [0..9]
-/// @param[in] Channel : the HMPID Module Row number [0..47]
-/// @returns The Sum of Charges for specified pad
-double HmpidDecoder::getChannelSum(int EquipmId, int Column, int Dilogic, int Channel)
-{
-  int EqInd = getEquipmentIndex(EquipmId);
-  if (EqInd < 0) {
-    return (0);
-  }
-  return (mTheEquipments[EqInd]->mPadSum[Column][Dilogic][Channel]);
-}
-
-/// Getter method to extract Statistic Data in Hardware Coords
-/// @param[in] EquipmId : the HMPID EquipmentId [0..13]
-/// @param[in] Column : the HMPID Module Column number [0..23]
-/// @param[in] Dilogic : the HMPID Module Row number [0..9]
-/// @param[in] Channel : the HMPID Module Row number [0..47]
-/// @returns The Sum of Square Charges for specified pad
-double HmpidDecoder::getChannelSquare(int EquipmId, int Column, int Dilogic, int Channel)
-{
-  int EqInd = getEquipmentIndex(EquipmId);
-  if (EqInd < 0) {
-    return (0);
-  }
-  return (mTheEquipments[EqInd]->mPadSquares[Column][Dilogic][Channel]);
-}
-
-/// Gets the Average Event Size value
-/// @param[in] EquipmId : the HMPID EquipmentId [0..13]
-/// @returns The Average Event Size value ( 0 for wrong Equipment Id)
-float HmpidDecoder::getAverageEventSize(int EquipmId)
-{
-  int EqInd = getEquipmentIndex(EquipmId);
-  if (EqInd < 0) {
-    return (0.0);
-  }
-  return (mTheEquipments[EqInd]->mEventSizeAverage);
-}
-
-/// Gets the Average Busy Time value
-/// @param[in] EquipmId : the HMPID EquipmentId [0..13]
-/// @returns The Average Busy Time value ( 0 for wrong Equipment Id)
-float HmpidDecoder::getAverageBusyTime(int EquipmId)
-{
-  int EqInd = getEquipmentIndex(EquipmId);
-  if (EqInd < 0) {
-    return (0.0);
-  }
-  return (mTheEquipments[EqInd]->mBusyTimeAverage);
-}
-
-// ===================================================
-// Methods to dump info
-
-/// Prints on the standard output the table of decoding
-/// errors for one equipment
-/// @param[in] EquipmId : the HMPID EquipmentId [0..13]
-void HmpidDecoder::dumpErrors(int EquipmId)
-{
-  int EqInd = getEquipmentIndex(EquipmId);
-  if (EqInd < 0) {
-    return;
-  }
-  std::cout << "Dump Errors for the Equipment = " << EquipmId << std::endl;
-  for (int i = 0; i < MAXERRORS; i++) {
-    std::cout << sErrorDescription[i] << "  = " << mTheEquipments[EqInd]->mErrors[i] << std::endl;
-  }
-  std::cout << " -------- " << std::endl;
-  return;
-}
-
-/// Prints on the standard output a Table of statistical
-/// decoding information for one equipment
-/// @param[in] EquipmId : the HMPID EquipmentId [0..13]
-/// @type[in] The type of info.  0 = Entries, 1 = Sum, 2 = Sum of squares
-void HmpidDecoder::dumpPads(int EquipmId, int type)
-{
-  int EqInd = getEquipmentIndex(EquipmId);
-  if (EqInd < 0) {
-    return;
-  }
-  int Module = EquipmId / 2;
-  int StartRow = (EquipmId % 2 == 1) ? 80 : 0;
-  int EndRow = (EquipmId % 2 == 1) ? 160 : 80;
-  std::cout << "Dump Pads for the Equipment = " << EquipmId << std::endl;
-  for (int c = 0; c < 144; c++) {
-    for (int r = StartRow; r < EndRow; r++) {
-      switch (type) {
-        case 0:
-          std::cout << getPadSamples(Module, r, c) << ",";
-          break;
-        case 1:
-          std::cout << getPadSum(Module, r, c) << ",";
-          break;
-        case 2:
-          std::cout << getPadSquares(Module, r, c) << ",";
-          break;
-      }
-    }
-    std::cout << std::endl;
-  }
-  std::cout << " -------- " << std::endl;
-  return;
-}
-
-/// Prints on the standard output the decoded HMPID error field
-/// @param[in] ErrorField : the HMPID readout error field
-void HmpidDecoder::dumpHmpidError(int ErrorField)
-{
-  char printbuf[MAXHMPIDERRORS * MAXDESCRIPTIONLENGHT];
-  if (decodeHmpidError(ErrorField, printbuf) == true) {
-    LOG(error) << "HMPID Error field = " << ErrorField << " : " << printbuf;
-  }
-  return;
-}
-
-/// Writes in a ASCCI File the complete report of the decoding
-/// procedure
-/// @param[in] *summaryFileName : the name of the output file
-/// @throws TH_CREATEFILE Thrown if was not able to create the file
-void HmpidDecoder::writeSummaryFile(char* summaryFileName)
-{
-  FILE* fs = fopen(summaryFileName, "w");
-  if (fs == nullptr) {
-    printf("Error opening the file %s !\n", summaryFileName);
-    throw TH_CREATEFILE;
-  }
-
-  fprintf(fs, "HMPID Readout Raw Data Decoding Summary File\n");
-  fprintf(fs, "Equipment Id\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%d\t", mTheEquipments[i]->getEquipmentId());
-  }
-  fprintf(fs, "\n");
-
-  fprintf(fs, "Number of events\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%d\t", mTheEquipments[i]->mNumberOfEvents);
-  }
-  fprintf(fs, "\n");
-
-  fprintf(fs, "Average Event Size\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%f\t", mTheEquipments[i]->mEventSizeAverage);
-  }
-  fprintf(fs, "\n");
-
-  fprintf(fs, "Total pads\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%d\t", mTheEquipments[i]->mTotalPads);
-  }
-  fprintf(fs, "\n");
-
-  fprintf(fs, "Average pads per event\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%f\t", mTheEquipments[i]->mPadsPerEventAverage);
-  }
-  fprintf(fs, "\n");
-
-  fprintf(fs, "Busy Time average\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%e\t", mTheEquipments[i]->mBusyTimeAverage);
-  }
-  fprintf(fs, "\n");
-
-  fprintf(fs, "Event rate\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%e\t", 1 / mTheEquipments[i]->mBusyTimeAverage);
-  }
-  fprintf(fs, "\n");
-
-  fprintf(fs, "Number of Empty Events\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%d\t", mTheEquipments[i]->mNumberOfEmptyEvents);
-  }
-  fprintf(fs, "\n");
-
-  fprintf(fs, "-------------Errors--------------------\n");
-  fprintf(fs, "Wrong events\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%d\t", mTheEquipments[i]->mNumberOfWrongEvents);
-  }
-  fprintf(fs, "\n");
-
-  for (int j = 0; j < MAXERRORS; j++) {
-    fprintf(fs, "%s\t", sErrorDescription[j]);
-    for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-      fprintf(fs, "%d\t", mTheEquipments[i]->mErrors[j]);
-    }
-    fprintf(fs, "\n");
-  }
-
-  fprintf(fs, "Total errors\t");
-  for (int i = 0; i < Geo::MAXEQUIPMENTS; i++) {
-    fprintf(fs, "%d\t", mTheEquipments[i]->mTotalErrors);
-  }
-  fprintf(fs, "\n");
-
-  fclose(fs);
-  return;
-}
diff --git a/Detectors/HMPID/workflow/include/HMPIDWorkflow/ClusterizerSpec.h_notused.h b/Detectors/HMPID/workflow/include/HMPIDWorkflow/ClusterizerSpec.h_notused.h
deleted file mode 100644
index 6102ec481c97c..0000000000000
--- a/Detectors/HMPID/workflow/include/HMPIDWorkflow/ClusterizerSpec.h_notused.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef STEER_DIGITIZERWORKFLOW_HMPIDCLUSTERIZER_H_
-#define STEER_DIGITIZERWORKFLOW_HMPIDCLUSTERIZER_H_
-
-#include "Framework/DataProcessorSpec.h"
-
-namespace o2
-{
-namespace hmpid
-{
-
-o2::framework::DataProcessorSpec getHMPIDClusterizerSpec(bool useMC);
-
-} // end namespace hmpid
-} // end namespace o2
-
-#endif /* STEER_DIGITIZERWORKFLOW_HMPIDCLUSTERIZERSPEC_H_ */
diff --git a/Detectors/HMPID/workflow/include/HMPIDWorkflow/DigitReaderSpec.h_notused.h b/Detectors/HMPID/workflow/include/HMPIDWorkflow/DigitReaderSpec.h_notused.h
deleted file mode 100644
index eea9b134bd911..0000000000000
--- a/Detectors/HMPID/workflow/include/HMPIDWorkflow/DigitReaderSpec.h_notused.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   DigitReader.h
-
-#ifndef O2_HMPID_DIGITREADER
-#define O2_HMPID_DIGITREADER
-
-#include "TFile.h"
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-#include "DataFormatsHMP/Digit.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-
-namespace o2
-{
-namespace hmpid
-{
-
-class DigitReader : public o2::framework::Task
-{
- public:
-  DigitReader(bool useMC) : mUseMC(useMC) {}
-  ~DigitReader() override = default;
-  void init(o2::framework::InitContext& ic) final;
-  void run(o2::framework::ProcessingContext& pc) final;
-
- private:
-  int mState = 0;
-  bool mUseMC = true;
-  std::unique_ptr<TFile> mFile = nullptr;
-
-  std::vector<o2::hmpid::Digit> mDigits, *mPdigits = &mDigits;
-
-  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabels, *mPlabels = &mLabels;
-};
-
-/// read simulated HMPID digits from a root file
-framework::DataProcessorSpec getDigitReaderSpec(bool useMC);
-
-} // namespace hmpid
-} // namespace o2
-
-#endif /* O2_HMPID_DIGITREADER */

From cb599998aa3f2425b7556f9b97075633065966a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Fri, 20 Feb 2026 13:16:53 +0100
Subject: [PATCH 1347/1764] FIT: Delete unused files (#15031)

---
 .../include/FDDReconstruction/ReadRaw.h       |  68 --------
 .../include/FDDSimulation/Digits2Raw.h        |  74 ---------
 .../include/FDDWorkflow/RawDataProcessSpec.h  |  61 -------
 .../include/FDDWorkflow/RawDataReaderSpec.h   |  84 ----------
 .../include/FDDWorkflow/RawWorkflow.h         |  28 ----
 .../FDD/workflow/src/RawDataProcessSpec.cxx   |  52 ------
 .../FDD/workflow/src/RawDataReaderSpec.cxx    |  24 ---
 .../FIT/FDD/workflow/src/RawWorkflow.cxx      |  42 -----
 .../FT0Workflow/FT0DataProcessDPLSpec.h       |  61 -------
 .../FT0Workflow/FT0DataReaderDPLSpec.h        | 110 ------------
 .../include/FT0Workflow/FT0Workflow.h         |  28 ----
 .../include/FT0Workflow/RawReaderFT0.h        | 156 ------------------
 .../workflow/src/FT0DataProcessDPLSpec.cxx    |  52 ------
 .../FT0/workflow/src/FT0DataReaderDPLSpec.cxx |  24 ---
 .../FIT/FT0/workflow/src/FT0Workflow.cxx      |  45 -----
 .../FIT/FT0/workflow/src/RawReaderFT0.cxx     |  13 --
 16 files changed, 922 deletions(-)
 delete mode 100644 Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/ReadRaw.h
 delete mode 100644 Detectors/FIT/FDD/simulation/include/FDDSimulation/Digits2Raw.h
 delete mode 100644 Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawDataProcessSpec.h
 delete mode 100644 Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawDataReaderSpec.h
 delete mode 100644 Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawWorkflow.h
 delete mode 100644 Detectors/FIT/FDD/workflow/src/RawDataProcessSpec.cxx
 delete mode 100644 Detectors/FIT/FDD/workflow/src/RawDataReaderSpec.cxx
 delete mode 100644 Detectors/FIT/FDD/workflow/src/RawWorkflow.cxx
 delete mode 100644 Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataProcessDPLSpec.h
 delete mode 100644 Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataReaderDPLSpec.h
 delete mode 100644 Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0Workflow.h
 delete mode 100644 Detectors/FIT/FT0/workflow/include/FT0Workflow/RawReaderFT0.h
 delete mode 100644 Detectors/FIT/FT0/workflow/src/FT0DataProcessDPLSpec.cxx
 delete mode 100644 Detectors/FIT/FT0/workflow/src/FT0DataReaderDPLSpec.cxx
 delete mode 100644 Detectors/FIT/FT0/workflow/src/FT0Workflow.cxx
 delete mode 100644 Detectors/FIT/FT0/workflow/src/RawReaderFT0.cxx

diff --git a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/ReadRaw.h b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/ReadRaw.h
deleted file mode 100644
index 54c8b7b203edb..0000000000000
--- a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/ReadRaw.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file ReadRaw.h
-/// \brief Reads raw data and converts to digits
-/// \author Maciej.Slupecki@cern.ch, arvind.khuntia@cern.ch, based on the FT0 code
-// RAW data format description: DataFormat/Detectors/FIT/FDD/RawEventData
-
-#ifndef ALICEO2_FDD_READRAW_H_
-#define ALICEO2_FDD_READRAW_H_
-
-#include <fstream>
-#include <iostream>
-#include <iomanip>
-#include <map>
-#include <string>
-#include <sstream>
-#include <vector>
-#include "TBranch.h"
-#include "TTree.h"
-#include "CommonDataFormat/InteractionRecord.h"
-#include "DataFormatsFDD/Digit.h"
-#include "DataFormatsFDD/ChannelData.h"
-#include "DataFormatsFDD/LookUpTable.h"
-#include "DataFormatsFDD/RawEventData.h"
-
-namespace o2
-{
-namespace fdd
-{
-class ReadRaw
-{
- public:
-  ReadRaw() = default;
-  ReadRaw(bool doConversionToDigits, const std::string inputRawFilePath = "fdd.raw", const std::string outputRawFilePath = "fdddigitsFromRaw.root");
-  void readRawData(const LookUpTable& lut);
-  void writeDigits(const std::string& outputDigitsFilePath);
-  void close();
-
- private:
-  std::ifstream mRawFileIn;
-  std::map<o2::InteractionRecord, std::vector<ChannelData>> mDigitAccum; // digit accumulator
-
-  template <typename T>
-  TBranch* getOrMakeBranch(TTree& tree, std::string brname, T* ptr)
-  {
-    if (auto br = tree.GetBranch(brname.c_str())) {
-      br->SetAddress(static_cast<void*>(ptr));
-      return br;
-    }
-    // otherwise make it
-    return tree.Branch(brname.c_str(), ptr);
-  }
-
-  ClassDefNV(ReadRaw, 1);
-};
-
-} // namespace fdd
-} // namespace o2
-#endif
diff --git a/Detectors/FIT/FDD/simulation/include/FDDSimulation/Digits2Raw.h b/Detectors/FIT/FDD/simulation/include/FDDSimulation/Digits2Raw.h
deleted file mode 100644
index 4afcf5da37ae8..0000000000000
--- a/Detectors/FIT/FDD/simulation/include/FDDSimulation/Digits2Raw.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file Digits2Raw.h
-/// \brief converts digits to raw format
-/// \author Maciej.Slupecki@cern.ch
-// based on FV0
-
-#ifndef ALICEO2_FDD_DIGITS2RAW_H_
-#define ALICEO2_FDD_DIGITS2RAW_H_
-
-#include "Headers/RAWDataHeader.h"
-#include "CommonDataFormat/InteractionRecord.h"
-#include "DataFormatsFDD/RawEventData.h"
-#include "DataFormatsFDD/LookUpTable.h"
-#include "DataFormatsFDD/ChannelData.h"
-#include "DataFormatsFDD/Digit.h"
-#include "DetectorsRaw/HBFUtils.h"
-#include "DetectorsRaw/RawFileWriter.h"
-#include <fairlogger/Logger.h>
-#include <TStopwatch.h>
-#include <iostream>
-#include <string>
-#include <vector>
-#include <gsl/span>
-
-namespace o2
-{
-namespace fdd
-{
-class Digits2Raw
-{
- public:
-  Digits2Raw() = default;
-  void readDigits(const std::string& outDir, const std::string& fileDigitsName);
-  void convertDigits(o2::fdd::Digit bcdigits,
-                     gsl::span<const ChannelData> pmchannels,
-                     const o2::fdd::LookUpTable& lut);
-
-  o2::raw::RawFileWriter& getWriter() { return mWriter; }
-  void setFilePerLink(bool v) { mOutputPerLink = v; }
-  bool getFilePerLink() const { return mOutputPerLink; }
-
-  int carryOverMethod(const header::RDHAny* rdh, const gsl::span<char> data,
-                      const char* ptr, int maxSize, int splitID,
-                      std::vector<char>& trailer, std::vector<char>& header) const;
-
- private:
-  static constexpr uint32_t sTcmLink = 2;
-  static constexpr uint16_t sCruId = 0;
-  static constexpr uint32_t sEndPointId = sCruId;
-
-  void makeGBTHeader(EventHeader& eventHeader, int link, o2::InteractionRecord const& mIntRecord);
-  void fillSecondHalfWordAndAddData(int iChannelPerLink, int prevPmLink, const o2::InteractionRecord& ir);
-  RawEventData mRawEventData;
-  o2::fdd::Triggers mTriggers;
-  o2::raw::RawFileWriter mWriter{"FDD"};
-  bool mOutputPerLink = false;
-  /////////////////////////////////////////////////
-
-  ClassDefNV(Digits2Raw, 1);
-};
-
-} // namespace fdd
-} // namespace o2
-#endif
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawDataProcessSpec.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawDataProcessSpec.h
deleted file mode 100644
index 6ed465b6181dd..0000000000000
--- a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawDataProcessSpec.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   RawDataProcessSpec.h
-
-#ifndef O2_FDD_RAWDATAPROCESSSPEC_H
-#define O2_FDD_RAWDATAPROCESSSPEC_H
-
-#include "Framework/CallbackService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/ControlService.h"
-#include "Framework/Lifetime.h"
-#include "Framework/Output.h"
-#include "Framework/WorkflowSpec.h"
-#include "Framework/SerializationMethods.h"
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-
-#include "FDDRaw/DigitBlockFDD.h"
-#include "DataFormatsFDD/Digit.h"
-#include "DataFormatsFDD/ChannelData.h"
-
-#include <iostream>
-#include <vector>
-#include <gsl/span>
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace fdd
-{
-
-class RawDataProcessSpec : public Task
-{
- public:
-  RawDataProcessSpec(bool dumpEventBlocks) : mDumpEventBlocks(dumpEventBlocks) {}
-  ~RawDataProcessSpec() override = default;
-  void init(InitContext& ic) final;
-  void run(ProcessingContext& pc) final;
-
- private:
-  bool mDumpEventBlocks;
-
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginFDD;
-};
-
-framework::DataProcessorSpec getFDDRawDataProcessSpec(bool dumpProcessor);
-
-} // namespace fdd
-} // namespace o2
-
-#endif /* O2_FDDDATAPROCESSDPL_H */
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawDataReaderSpec.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawDataReaderSpec.h
deleted file mode 100644
index c3b0349826e98..0000000000000
--- a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawDataReaderSpec.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   RawDataReaderSpec.h
-
-#ifndef O2_FDD_RAWDATAREADERSPEC_H
-#define O2_FDD_RAWDATAREADERSPEC_H
-
-#include "DataFormatsFDD/LookUpTable.h"
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-#include "Framework/CallbackService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/ControlService.h"
-#include "Framework/Lifetime.h"
-#include "Framework/Output.h"
-#include "Framework/WorkflowSpec.h"
-#include "Framework/SerializationMethods.h"
-#include "DPLUtils/DPLRawParser.h"
-#include "DetectorsRaw/RDHUtils.h"
-
-#include <iostream>
-#include <vector>
-#include <gsl/span>
-using namespace o2::framework;
-
-namespace o2
-{
-namespace fdd
-{
-template <typename RawReader>
-class RawDataReaderSpec : public Task
-{
- public:
-  RawDataReaderSpec(const RawReader& rawReader) : mRawReader(rawReader) {}
-  RawDataReaderSpec() = default;
-  ~RawDataReaderSpec() override = default;
-  void init(InitContext& ic) final { o2::fdd::SingleLUT::Instance().printFullMap(); }
-  void run(ProcessingContext& pc) final
-  {
-    DPLRawParser parser(pc.inputs());
-    mRawReader.clear();
-    LOG(info) << "FDD RawDataReaderSpec";
-    uint64_t count = 0;
-    for (auto it = parser.begin(), end = parser.end(); it != end; ++it) {
-      //Proccessing each page
-      count++;
-      auto rdhPtr = reinterpret_cast<const o2::header::RDHAny*>(it.raw());
-      gsl::span<const uint8_t> payload(it.data(), it.size());
-      mRawReader.process(payload, o2::raw::RDHUtils::getLinkID(rdhPtr), int(0));
-    }
-    LOG(info) << "Pages: " << count;
-    mRawReader.accumulateDigits();
-    mRawReader.makeSnapshot(pc);
-  }
-  RawReader mRawReader;
-};
-
-template <typename RawReader>
-framework::DataProcessorSpec getFDDRawDataReaderSpec(const RawReader& rawReader)
-{
-  LOG(info) << "DataProcessorSpec initDataProcSpec() for RawReaderFDD";
-  std::vector<OutputSpec> outputSpec;
-  RawReader::prepareOutputSpec(outputSpec);
-  return DataProcessorSpec{
-    "fdd-datareader-dpl",
-    o2::framework::select("TF:FDD/RAWDATA"),
-    outputSpec,
-    adaptFromTask<RawDataReaderSpec<RawReader>>(rawReader),
-    Options{}};
-}
-
-} // namespace fdd
-} // namespace o2
-
-#endif /* O2_FDDDATAREADERDPL_H */
diff --git a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawWorkflow.h b/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawWorkflow.h
deleted file mode 100644
index 3bbab66d16497..0000000000000
--- a/Detectors/FIT/FDD/workflow/include/FDDWorkflow/RawWorkflow.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef O2_FDD_RAWWORKFLOW_H
-#define O2_FDD_RAWWORKFLOW_H
-
-/// @file   RawWorkflow.h
-
-#include "Framework/WorkflowSpec.h"
-
-namespace o2
-{
-namespace fdd
-{
-framework::WorkflowSpec getFDDRawWorkflow(bool useProcess,
-                                          bool dumpProcessor, bool dumpReader,
-                                          bool disableRootOut);
-} // namespace fdd
-} // namespace o2
-#endif
diff --git a/Detectors/FIT/FDD/workflow/src/RawDataProcessSpec.cxx b/Detectors/FIT/FDD/workflow/src/RawDataProcessSpec.cxx
deleted file mode 100644
index bf18db67672c2..0000000000000
--- a/Detectors/FIT/FDD/workflow/src/RawDataProcessSpec.cxx
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   RawDataProcessSpec.cxx
-
-#include "FDDWorkflow/RawDataProcessSpec.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace fdd
-{
-using namespace std;
-void RawDataProcessSpec::init(InitContext& ic)
-{
-}
-
-void RawDataProcessSpec::run(ProcessingContext& pc)
-{
-  LOG(info) << "RawDataProcessSpec running...";
-  auto vecDigits = pc.inputs().get<std::vector<Digit>>("digits");
-  auto vecChannelData = pc.inputs().get<std::vector<ChannelData>>("digch");
-  if (mDumpEventBlocks) {
-    DigitBlockFDD::print(vecDigits, vecChannelData);
-  }
-}
-
-DataProcessorSpec getFDDRawDataProcessSpec(bool dumpProcessor)
-{
-  std::vector<InputSpec> inputSpec;
-  inputSpec.emplace_back("digits", o2::header::gDataOriginFDD, "DIGITSBC", 0, Lifetime::Timeframe);
-  inputSpec.emplace_back("digch", o2::header::gDataOriginFDD, "DIGITSCH", 0, Lifetime::Timeframe);
-  LOG(info) << "DataProcessorSpec getRawDataProcessSpec";
-  return DataProcessorSpec{
-    "fdd-dataprocess-dpl-flp",
-    inputSpec,
-    Outputs{},
-    AlgorithmSpec{adaptFromTask<RawDataProcessSpec>(dumpProcessor)},
-    Options{}};
-}
-
-} // namespace fdd
-} // namespace o2
diff --git a/Detectors/FIT/FDD/workflow/src/RawDataReaderSpec.cxx b/Detectors/FIT/FDD/workflow/src/RawDataReaderSpec.cxx
deleted file mode 100644
index 631655d3038ec..0000000000000
--- a/Detectors/FIT/FDD/workflow/src/RawDataReaderSpec.cxx
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   RawDataReaderSpec.cxx
-
-#include "FDDWorkflow/RawDataReaderSpec.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace fdd
-{
-
-} // namespace fdd
-} // namespace o2
diff --git a/Detectors/FIT/FDD/workflow/src/RawWorkflow.cxx b/Detectors/FIT/FDD/workflow/src/RawWorkflow.cxx
deleted file mode 100644
index c9e5c5be0c81d..0000000000000
--- a/Detectors/FIT/FDD/workflow/src/RawWorkflow.cxx
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   RawWorkflow.cxx
-
-#include "FDDWorkflow/RawWorkflow.h"
-#include "FDDWorkflow/RawDataProcessSpec.h"
-#include "FDDWorkflow/RawDataReaderSpec.h"
-#include "FDDWorkflow/DigitWriterSpec.h"
-#include "FDDWorkflow/RawReaderFDD.h"
-namespace o2
-{
-namespace fdd
-{
-
-framework::WorkflowSpec getFDDRawWorkflow(bool useProcess,
-                                          bool dumpProcessor, bool dumpReader,
-                                          bool disableRootOut)
-{
-  LOG(info) << "framework::WorkflowSpec getFDDWorkflow";
-  framework::WorkflowSpec specs;
-  specs.emplace_back(o2::fdd::getFDDRawDataReaderSpec(RawReaderFDD{dumpReader}));
-
-  if (useProcess) {
-    specs.emplace_back(o2::fdd::getFDDRawDataProcessSpec(dumpProcessor));
-  }
-  if (!disableRootOut) {
-    specs.emplace_back(o2::fdd::getFDDDigitWriterSpec(false, false));
-  }
-  return specs;
-}
-
-} // namespace fdd
-} // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataProcessDPLSpec.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataProcessDPLSpec.h
deleted file mode 100644
index 7b7e98d50368e..0000000000000
--- a/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataProcessDPLSpec.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   FT0DataProcessDPLSpec.h
-
-#ifndef O2_FT0DATAPROCESSDPLSPEC_H
-#define O2_FT0DATAPROCESSDPLSPEC_H
-
-#include "Framework/CallbackService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/ControlService.h"
-#include "Framework/Lifetime.h"
-#include "Framework/Output.h"
-#include "Framework/WorkflowSpec.h"
-#include "Framework/SerializationMethods.h"
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-
-#include "FT0Raw/DigitBlockFT0.h"
-#include "DataFormatsFT0/Digit.h"
-#include "DataFormatsFT0/ChannelData.h"
-
-#include <iostream>
-#include <vector>
-#include <gsl/span>
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace ft0
-{
-
-class FT0DataProcessDPLSpec : public Task
-{
- public:
-  FT0DataProcessDPLSpec(bool dumpEventBlocks) : mDumpEventBlocks(dumpEventBlocks) {}
-  ~FT0DataProcessDPLSpec() override = default;
-  void init(InitContext& ic) final;
-  void run(ProcessingContext& pc) final;
-
- private:
-  bool mDumpEventBlocks;
-
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginFT0;
-};
-
-framework::DataProcessorSpec getFT0DataProcessDPLSpec(bool dumpProcessor);
-
-} // namespace ft0
-} // namespace o2
-
-#endif /* O2_FT0DATAPROCESSDPL_H */
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataReaderDPLSpec.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataReaderDPLSpec.h
deleted file mode 100644
index 9074f4f7f0f34..0000000000000
--- a/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0DataReaderDPLSpec.h
+++ /dev/null
@@ -1,110 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   FT0DataReaderDPLSpec.h
-
-#ifndef O2_FT0DATAREADERDPLSPEC_H
-#define O2_FT0DATAREADERDPLSPEC_H
-#include "DataFormatsFT0/LookUpTable.h"
-#include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
-#include "Framework/CallbackService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/ControlService.h"
-#include "Framework/Lifetime.h"
-#include "Framework/Output.h"
-#include "Framework/WorkflowSpec.h"
-#include "Framework/SerializationMethods.h"
-#include "DPLUtils/DPLRawParser.h"
-#include "Framework/InputRecordWalker.h"
-#include <iostream>
-#include <vector>
-#include <gsl/span>
-#include "CommonUtils/VerbosityConfig.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace ft0
-{
-template <typename RawReader>
-class FT0DataReaderDPLSpec : public Task
-{
- public:
-  FT0DataReaderDPLSpec(const RawReader& rawReader) : mRawReader(rawReader) {}
-  FT0DataReaderDPLSpec() = default;
-  ~FT0DataReaderDPLSpec() override = default;
-  typedef RawReader RawReader_t;
-  void init(InitContext& ic) final { o2::ft0::SingleLUT::Instance().printFullMap(); }
-  void run(ProcessingContext& pc) final
-  {
-    // if we see requested data type input with 0xDEADBEEF subspec and 0 payload this means that the "delayed message"
-    // mechanism created it in absence of real data from upstream. Processor should send empty output to not block the workflow
-    {
-      static size_t contDeadBeef = 0; // number of times 0xDEADBEEF was seen continuously
-      std::vector<InputSpec> dummy{InputSpec{"dummy", ConcreteDataMatcher{o2::header::gDataOriginFT0, o2::header::gDataDescriptionRawData, 0xDEADBEEF}}};
-      for (const auto& ref : InputRecordWalker(pc.inputs(), dummy)) {
-        const auto dh = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
-        auto payloadSize = DataRefUtils::getPayloadSize(ref);
-        if (payloadSize == 0) {
-          auto maxWarn = o2::conf::VerbosityConfig::Instance().maxWarnDeadBeef;
-          if (++contDeadBeef <= maxWarn) {
-            LOGP(alarm, "Found input [{}/{}/{:#x}] TF#{} 1st_orbit:{} Payload {} : assuming no payload for all links in this TF{}",
-                 dh->dataOrigin.str, dh->dataDescription.str, dh->subSpecification, dh->tfCounter, dh->firstTForbit, payloadSize,
-                 contDeadBeef == maxWarn ? fmt::format(". {} such inputs in row received, stopping reporting", contDeadBeef) : "");
-          }
-          mRawReader.makeSnapshot(pc); // send empty output
-          return;
-        }
-      }
-      contDeadBeef = 0; // if good data, reset the counter
-    }
-    std::vector<InputSpec> filter{InputSpec{"filter", ConcreteDataTypeMatcher{o2::header::gDataOriginFT0, o2::header::gDataDescriptionRawData}, Lifetime::Timeframe}};
-    DPLRawParser parser(pc.inputs(), filter);
-    std::size_t count = 0;
-    for (auto it = parser.begin(), end = parser.end(); it != end; ++it) {
-      //Proccessing each page
-      count++;
-      auto rdhPtr = reinterpret_cast<const o2::header::RDHAny*>(it.raw());
-      gsl::span<const uint8_t> payload(it.data(), it.size());
-      mRawReader.process(payload, o2::raw::RDHUtils::getLinkID(rdhPtr), o2::raw::RDHUtils::getEndPointID(rdhPtr));
-    }
-    LOG(info) << "Pages: " << count;
-    mRawReader.accumulateDigits();
-    mRawReader.makeSnapshot(pc);
-    mRawReader.clear();
-  }
-  RawReader_t mRawReader;
-};
-
-template <typename RawReader>
-framework::DataProcessorSpec getFT0DataReaderDPLSpec(const RawReader& rawReader, bool askSTFDist)
-{
-  LOG(info) << "DataProcessorSpec initDataProcSpec() for RawReaderFT0";
-  std::vector<OutputSpec> outputSpec;
-  RawReader::prepareOutputSpec(outputSpec);
-  std::vector<InputSpec> inputSpec{{"STF", ConcreteDataTypeMatcher{o2::header::gDataOriginFT0, "RAWDATA"}, Lifetime::Timeframe}};
-  if (askSTFDist) {
-    inputSpec.emplace_back("STFDist", "FLP", "DISTSUBTIMEFRAME", 0, Lifetime::Timeframe);
-  }
-  return DataProcessorSpec{
-    "ft0-datareader-dpl",
-    inputSpec,
-    outputSpec,
-    adaptFromTask<FT0DataReaderDPLSpec<RawReader>>(rawReader),
-    Options{}};
-}
-
-} // namespace ft0
-} // namespace o2
-
-#endif /* O2_FT0DATAREADERDPL_H */
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0Workflow.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0Workflow.h
deleted file mode 100644
index a4988b2c18fc7..0000000000000
--- a/Detectors/FIT/FT0/workflow/include/FT0Workflow/FT0Workflow.h
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef O2_FIT_FT0WORKFLOW_H
-#define O2_FIT_FT0WORKFLOW_H
-
-/// @file   FT0Workflow.h
-
-#include "Framework/WorkflowSpec.h"
-
-namespace o2
-{
-namespace ft0
-{
-framework::WorkflowSpec getFT0Workflow(bool isExtendedMode, bool useProcess,
-                                       bool dumpProcessor, bool dumpReader,
-                                       bool disableRootOut, bool askSTFDist);
-} // namespace ft0
-} // namespace o2
-#endif
diff --git a/Detectors/FIT/FT0/workflow/include/FT0Workflow/RawReaderFT0.h b/Detectors/FIT/FT0/workflow/include/FT0Workflow/RawReaderFT0.h
deleted file mode 100644
index f7729394db652..0000000000000
--- a/Detectors/FIT/FT0/workflow/include/FT0Workflow/RawReaderFT0.h
+++ /dev/null
@@ -1,156 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-//
-//file RawReaderFT0.h class  for RAW data reading
-//
-// Artur.Furs
-// afurs@cern.ch
-//
-//Main purpuse is to decode FT0 data blocks and push them to DigitBlockFT0 for proccess
-//TODO: prepare wrappers for containers with digits and combine classes below into one template class?
-#ifndef ALICEO2_FIT_RAWREADERFT0_H_
-#define ALICEO2_FIT_RAWREADERFT0_H_
-#include <iostream>
-#include <vector>
-#include <Rtypes.h>
-#include "FT0Raw/RawReaderFT0Base.h"
-
-#include "DataFormatsFT0/Digit.h"
-#include "DataFormatsFT0/ChannelData.h"
-
-#include "Framework/ProcessingContext.h"
-#include "Framework/DataAllocator.h"
-#include "Framework/OutputSpec.h"
-#include <gsl/span>
-
-namespace o2
-{
-namespace ft0
-{
-//Normal TCM mode
-template <bool useTrgInput = false>
-class RawReaderFT0 : public RawReaderFT0BaseNorm
-{
- public:
-  RawReaderFT0(bool dumpData) : mDumpData(dumpData) {}
-  RawReaderFT0(const RawReaderFT0&) = default;
-
-  RawReaderFT0() = default;
-  ~RawReaderFT0() = default;
-  static constexpr bool sUseTrgInput = useTrgInput;
-  void clear()
-  {
-    mVecDigits.clear();
-    if constexpr (sUseTrgInput) {
-      mVecTriggerInput.clear();
-    }
-    mVecChannelData.clear();
-  }
-  void accumulateDigits()
-  {
-    if constexpr (sUseTrgInput) {
-      getDigits(mVecDigits, mVecChannelData, mVecTriggerInput);
-    } else {
-      getDigits(mVecDigits, mVecChannelData);
-    }
-    LOG(info) << "Number of Digits: " << mVecDigits.size();
-    LOG(info) << "Number of ChannelData: " << mVecChannelData.size();
-    if constexpr (sUseTrgInput) {
-      LOG(info) << "Number of TriggerInput: " << mVecTriggerInput.size();
-    }
-    if (mDumpData) {
-      DigitBlockFT0::print(mVecDigits, mVecChannelData);
-    }
-  }
-  static void prepareOutputSpec(std::vector<o2::framework::OutputSpec>& outputSpec)
-  {
-    outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSBC", 0, o2::framework::Lifetime::Timeframe);
-    outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSCH", 0, o2::framework::Lifetime::Timeframe);
-    if constexpr (sUseTrgInput) {
-      outputSpec.emplace_back(o2::header::gDataOriginFT0, "TRIGGERINPUT", 0, o2::framework::Lifetime::Timeframe);
-    }
-  }
-  void makeSnapshot(o2::framework::ProcessingContext& pc)
-  {
-    pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginFT0, "DIGITSBC", 0}, mVecDigits);
-    pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginFT0, "DIGITSCH", 0}, mVecChannelData);
-    if constexpr (sUseTrgInput) {
-      pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginFT0, "TRIGGERINPUT", 0}, mVecTriggerInput);
-    }
-  }
-  bool mDumpData;
-  std::vector<Digit> mVecDigits;
-  std::vector<DetTrigInput> mVecTriggerInput;
-  std::vector<ChannelData> mVecChannelData;
-};
-
-//Extended TCM mode (additional raw data struct)
-template <bool useTrgInput = false>
-class RawReaderFT0ext : public RawReaderFT0BaseExt
-{
- public:
-  RawReaderFT0ext(bool dumpData) : mDumpData(dumpData) {}
-  RawReaderFT0ext(const RawReaderFT0ext&) = default;
-  static constexpr bool sUseTrgInput = useTrgInput;
-  RawReaderFT0ext() = default;
-  ~RawReaderFT0ext() = default;
-  void clear()
-  {
-    mVecDigits.clear();
-    mVecChannelData.clear();
-    mVecTrgExt.clear();
-    if constexpr (sUseTrgInput) {
-      mVecTriggerInput.clear();
-    }
-  }
-  void accumulateDigits()
-  {
-    if constexpr (sUseTrgInput) {
-      getDigits(mVecDigits, mVecChannelData, mVecTrgExt, mVecTriggerInput);
-    } else {
-      getDigits(mVecDigits, mVecChannelData, mVecTrgExt);
-    }
-    LOG(info) << "Number of Digits: " << mVecDigits.size();
-    LOG(info) << "Number of ChannelData: " << mVecChannelData.size();
-    LOG(info) << "Number of TriggerExt: " << mVecTrgExt.size();
-    if (mDumpData) {
-      DigitBlockFT0ext::print(mVecDigits, mVecChannelData, mVecTrgExt);
-    }
-  }
-  static void prepareOutputSpec(std::vector<o2::framework::OutputSpec>& outputSpec)
-  {
-    outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSBC", 0, o2::framework::Lifetime::Timeframe);
-    outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSCH", 0, o2::framework::Lifetime::Timeframe);
-    outputSpec.emplace_back(o2::header::gDataOriginFT0, "DIGITSTRGEXT", 0, o2::framework::Lifetime::Timeframe);
-    if constexpr (sUseTrgInput) {
-      outputSpec.emplace_back(o2::header::gDataOriginFT0, "TRIGGERINPUT", 0, o2::framework::Lifetime::Timeframe);
-    }
-  }
-  void makeSnapshot(o2::framework::ProcessingContext& pc)
-  {
-    pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginFT0, "DIGITSBC", 0}, mVecDigits);
-    pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginFT0, "DIGITSCH", 0}, mVecChannelData);
-    pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginFT0, "DIGITSTRGEXT", 0}, mVecTrgExt);
-    if constexpr (sUseTrgInput) {
-      pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginFT0, "TRIGGERINPUT", 0}, mVecTriggerInput);
-    }
-  }
-  bool mDumpData;
-  std::vector<Digit> mVecDigits;
-  std::vector<ChannelData> mVecChannelData;
-  std::vector<TriggersExt> mVecTrgExt;
-  std::vector<DetTrigInput> mVecTriggerInput;
-};
-
-} // namespace ft0
-} // namespace o2
-
-#endif
diff --git a/Detectors/FIT/FT0/workflow/src/FT0DataProcessDPLSpec.cxx b/Detectors/FIT/FT0/workflow/src/FT0DataProcessDPLSpec.cxx
deleted file mode 100644
index d7a7a689d402f..0000000000000
--- a/Detectors/FIT/FT0/workflow/src/FT0DataProcessDPLSpec.cxx
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   FT0DataProcessDPLSpec.cxx
-
-#include "FT0Workflow/FT0DataProcessDPLSpec.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace ft0
-{
-using namespace std;
-void FT0DataProcessDPLSpec::init(InitContext& ic)
-{
-}
-
-void FT0DataProcessDPLSpec::run(ProcessingContext& pc)
-{
-  LOG(info) << "FT0DataProcessDPLSpec running...";
-  auto vecDigits = pc.inputs().get<std::vector<Digit>>("digits");
-  auto vecChannelData = pc.inputs().get<std::vector<ChannelData>>("digch");
-  if (mDumpEventBlocks) {
-    DigitBlockFT0::print(vecDigits, vecChannelData);
-  }
-}
-
-DataProcessorSpec getFT0DataProcessDPLSpec(bool dumpProcessor)
-{
-  std::vector<InputSpec> inputSpec;
-  inputSpec.emplace_back("digits", o2::header::gDataOriginFT0, "DIGITSBC", 0, Lifetime::Timeframe);
-  inputSpec.emplace_back("digch", o2::header::gDataOriginFT0, "DIGITSCH", 0, Lifetime::Timeframe);
-  LOG(info) << "DataProcessorSpec getFT0DataProcessDPLSpec";
-  return DataProcessorSpec{
-    "ft0-dataprocess-dpl-flp",
-    inputSpec,
-    Outputs{},
-    AlgorithmSpec{adaptFromTask<FT0DataProcessDPLSpec>(dumpProcessor)},
-    Options{}};
-}
-
-} // namespace ft0
-} // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/src/FT0DataReaderDPLSpec.cxx b/Detectors/FIT/FT0/workflow/src/FT0DataReaderDPLSpec.cxx
deleted file mode 100644
index caa642794b561..0000000000000
--- a/Detectors/FIT/FT0/workflow/src/FT0DataReaderDPLSpec.cxx
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   FT0DataReaderDPLSpec.cxx
-
-#include "FT0Workflow/FT0DataReaderDPLSpec.h"
-
-using namespace o2::framework;
-
-namespace o2
-{
-namespace ft0
-{
-
-} // namespace ft0
-} // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/src/FT0Workflow.cxx b/Detectors/FIT/FT0/workflow/src/FT0Workflow.cxx
deleted file mode 100644
index 156feb7dd3e2f..0000000000000
--- a/Detectors/FIT/FT0/workflow/src/FT0Workflow.cxx
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// @file   FT0Workflow.cxx
-
-#include "FT0Workflow/FT0Workflow.h"
-#include "FT0Workflow/FT0DataProcessDPLSpec.h"
-#include "FT0Workflow/FT0DataReaderDPLSpec.h"
-#include "FT0Workflow/FT0DigitWriterSpec.h"
-#include "FT0Workflow/RawReaderFT0.h"
-namespace o2
-{
-namespace ft0
-{
-
-framework::WorkflowSpec getFT0Workflow(bool isExtendedMode, bool useProcess,
-                                       bool dumpProcessor, bool dumpReader,
-                                       bool disableRootOut, bool askSTFDist)
-{
-  LOG(info) << "framework::WorkflowSpec getFT0Workflow";
-  framework::WorkflowSpec specs;
-  if (isExtendedMode) {
-    specs.emplace_back(o2::ft0::getFT0DataReaderDPLSpec(RawReaderFT0ext{dumpReader}, askSTFDist));
-  } else {
-    specs.emplace_back(o2::ft0::getFT0DataReaderDPLSpec(RawReaderFT0<false>{dumpReader}, askSTFDist));
-  }
-  if (useProcess) {
-    specs.emplace_back(o2::ft0::getFT0DataProcessDPLSpec(dumpProcessor));
-  }
-  if (!disableRootOut) {
-    specs.emplace_back(o2::ft0::getFT0DigitWriterSpec(false, false));
-  }
-  return specs;
-}
-
-} // namespace ft0
-} // namespace o2
diff --git a/Detectors/FIT/FT0/workflow/src/RawReaderFT0.cxx b/Detectors/FIT/FT0/workflow/src/RawReaderFT0.cxx
deleted file mode 100644
index b2ef17e540112..0000000000000
--- a/Detectors/FIT/FT0/workflow/src/RawReaderFT0.cxx
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "FT0Workflow/RawReaderFT0.h"
-using namespace o2::ft0;

From ca1c2128b44820ff63518d0d298664c716cd4cb5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Wiktor=20Piero=C5=BCak?=
 <94726725+wpierozak@users.noreply.github.com>
Date: Fri, 20 Feb 2026 17:47:38 +0100
Subject: [PATCH 1348/1764] FT0: Implemented condition on sum of amplitudes in
 EventsPerBc calibration (#15084)

Co-authored-by: wpierozak <wpierozak@wpieroza-1.dyndns.cern.ch>
---
 .../include/FT0Calibration/EventsPerBcCalibrator.h          | 6 ++++--
 Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx | 6 +++---
 .../workflow/FT0EventsPerBcProcessor-Workflow.cxx           | 3 ++-
 Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h | 6 +++++-
 4 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h b/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
index f44824517f258..d831cc36201ab 100644
--- a/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
+++ b/Detectors/FIT/FT0/calibration/include/FT0Calibration/EventsPerBcCalibrator.h
@@ -31,7 +31,7 @@
 namespace o2::ft0
 {
 struct EventsPerBcContainer {
-  EventsPerBcContainer(int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC) {}
+  EventsPerBcContainer(int32_t minAmplitudeSideA, int32_t minAmplitudeSideC, int32_t minSumOfAmplitude) : mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC), mMinSumOfAmplitude(minSumOfAmplitude) {}
 
   size_t getEntries() const { return entries; }
   void print() const;
@@ -40,6 +40,7 @@ struct EventsPerBcContainer {
 
   const int32_t mMinAmplitudeSideA;
   const int32_t mMinAmplitudeSideC;
+  const int32_t mMinSumOfAmplitude;
 
   std::array<double, o2::constants::lhc::LHCMaxBunches> mTvx{0.0};
   size_t entries{0};
@@ -56,7 +57,7 @@ class EventsPerBcCalibrator final : public o2::calibration::TimeSlotCalibration<
   using EventsHistogram = std::array<double, o2::constants::lhc::LHCMaxBunches>;
 
  public:
-  EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC);
+  EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC, int32_t minSumOfAmplitude);
 
   bool hasEnoughData(const Slot& slot) const override;
   void initOutput() override;
@@ -70,6 +71,7 @@ class EventsPerBcCalibrator final : public o2::calibration::TimeSlotCalibration<
   const uint32_t mMinNumberOfEntries;
   const int32_t mMinAmplitudeSideA;
   const int32_t mMinAmplitudeSideC;
+  const int32_t mMinSumOfAmplitude;
 
   std::vector<EventsPerBc> mTvxPerBcs;
   std::vector<std::unique_ptr<o2::ccdb::CcdbObjectInfo>> mTvxPerBcInfos;
diff --git a/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx b/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
index a2230f51dc4ea..b17c81213cd08 100644
--- a/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
+++ b/Detectors/FIT/FT0/calibration/src/EventsPerBcCalibrator.cxx
@@ -23,7 +23,7 @@ void EventsPerBcContainer::fill(const o2::dataformats::TFIDInfo& ti, const gsl::
 {
   size_t oldEntries = entries;
   for (const auto& digit : data) {
-    if (digit.mTriggers.getVertex() && digit.mTriggers.getAmplA() >= mMinAmplitudeSideA && digit.mTriggers.getAmplC() >= mMinAmplitudeSideC) {
+    if (digit.mTriggers.getVertex() && digit.mTriggers.getAmplA() >= mMinAmplitudeSideA && digit.mTriggers.getAmplC() >= mMinAmplitudeSideC && (digit.mTriggers.getAmplA() + digit.mTriggers.getAmplC()) >= mMinSumOfAmplitude) {
       mTvx[digit.mIntRecord.bc]++;
       entries++;
     }
@@ -45,7 +45,7 @@ void EventsPerBcCalibrator::initOutput()
   mTvxPerBcInfos.clear();
 }
 
-EventsPerBcCalibrator::EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC) : mMinNumberOfEntries(minNumberOfEntries), mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC)
+EventsPerBcCalibrator::EventsPerBcCalibrator(uint32_t minNumberOfEntries, int32_t minAmplitudeSideA, int32_t minAmplitudeSideC, int32_t minSumOfAmplitude) : mMinNumberOfEntries(minNumberOfEntries), mMinAmplitudeSideA(minAmplitudeSideA), mMinAmplitudeSideC(minAmplitudeSideC), mMinSumOfAmplitude(minSumOfAmplitude)
 {
   LOG(info) << "Defined threshold for number of entires per slot: " << mMinNumberOfEntries;
   LOG(info) << "Defined threshold for side A amplitude for event: " << mMinAmplitudeSideA;
@@ -75,7 +75,7 @@ EventsPerBcCalibrator::Slot& EventsPerBcCalibrator::emplaceNewSlot(bool front, T
 {
   auto& cont = getSlots();
   auto& slot = front ? cont.emplace_front(tstart, tend) : cont.emplace_back(tstart, tend);
-  slot.setContainer(std::make_unique<EventsPerBcContainer>(mMinAmplitudeSideA, mMinAmplitudeSideC));
+  slot.setContainer(std::make_unique<EventsPerBcContainer>(mMinAmplitudeSideA, mMinAmplitudeSideC, mMinSumOfAmplitude));
   return slot;
 }
 } // namespace o2::ft0
\ No newline at end of file
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
index ac7a8e52f53b1..5cef707da2cca 100644
--- a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
+++ b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
@@ -39,7 +39,8 @@ o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext co
       {"one-object-per-run", VariantType::Bool, false, {"If set, workflow creates only one calibration object per run"}},
       {"min-entries-number", VariantType::UInt32, 5000u, {"Minimum number of entries required for a slot to be valid"}},
       {"min-ampl-side-a", VariantType::Int, 0, {"Amplitude threshold for Side A events"}},
-      {"min-ampl-side-c", VariantType::Int, 0, {"Amplitude threshold for Side C events"}}}};
+      {"min-ampl-side-c", VariantType::Int, 0, {"Amplitude threshold for Side C events"}},
+      {"min-sum-of-ampl", VariantType::Int, 0, {"Amplitude threshold for sum of A-side and C-side amplitudes"}}}};
 
   WorkflowSpec workflow;
   workflow.emplace_back(dataProcessorSpec);
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
index c587ab58fcd90..d493e2a606613 100644
--- a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
+++ b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
@@ -50,8 +50,11 @@ class FT0EventsPerBcProcessor final : public o2::framework::Task
     if (ic.options().hasOption("min-ampl-side-c")) {
       mMinAmplitudeSideC = ic.options().get<int32_t>("min-ampl-side-c");
     }
+    if (ic.options().hasOption("min-sum-of-ampl")) {
+      mMinSumOfAmplitude = ic.options().get<int32_t>("min-sum-of-ampl");
+    }
 
-    mCalibrator = std::make_unique<o2::ft0::EventsPerBcCalibrator>(mMinNumberOfEntries, mMinAmplitudeSideA, mMinAmplitudeSideC);
+    mCalibrator = std::make_unique<o2::ft0::EventsPerBcCalibrator>(mMinNumberOfEntries, mMinAmplitudeSideA, mMinAmplitudeSideC, mMinSumOfAmplitude);
 
     if (mOneObjectPerRun) {
       LOG(info) << "Only one object will be created at the end of run";
@@ -119,6 +122,7 @@ class FT0EventsPerBcProcessor final : public o2::framework::Task
   uint32_t mMinNumberOfEntries;
   int32_t mMinAmplitudeSideA;
   int32_t mMinAmplitudeSideC;
+  int32_t mMinSumOfAmplitude;
 };
 } // namespace o2::calibration
 #endif
\ No newline at end of file

From 4728518ad3cee9c3bb9ab424733e7c79d46fc934 Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Fri, 20 Feb 2026 18:13:21 +0100
Subject: [PATCH 1349/1764] [ALICE] Fix TRK services crossing (#15085)

---
 .../Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 25c59b3c8fd4a..bd27a5bc30f62 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -264,8 +264,8 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
   // Carbon Fiber Cylinder support for the middle tracker
   float rMinMiddleCarbonSupport = 34.8f; // Arbitrary value
   float rMaxMiddleCarbonSupport = 35.f;  // 2 mm of carbon fiber
-  const float zLengthMiddleCarbon = 64.2f;
-  TGeoTube* middleBarrelCarbonSupport = new TGeoTube("TRK_MID_CARBONSUPPORTsh", rMinMiddleCarbonSupport, rMaxMiddleCarbonSupport, zLengthMiddleCarbon);
+  const float zLengthMiddleCarbon = 129.f;
+  TGeoTube* middleBarrelCarbonSupport = new TGeoTube("TRK_MID_CARBONSUPPORTsh", rMinMiddleCarbonSupport, rMaxMiddleCarbonSupport, zLengthMiddleCarbon / 2.);
   TGeoVolume* middleBarrelCarbonSupportVolume = new TGeoVolume("TRK_MID_CARBONSUPPORT", middleBarrelCarbonSupport, medCFiber);
   middleBarrelCarbonSupportVolume->SetLineColor(kGray);
   LOGP(info, "Creating carbon fiber support for Middle Tracker");
@@ -318,7 +318,7 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
   // Middle barrel connection disks
   const float rMinMiddleBarrelDisk = 5.68f;
   const float rMaxMiddleBarrelDisk = 35.f;
-  const float zLengthMiddleBarrel = 64.2f;
+  const float zLengthMiddleBarrel = 64.5f;
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
     TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube(Form("TRK_MIDBARCONN_DISK_SIO2sh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, siO2FiberThick / 2.);
     TGeoTube* middleBarrelConnDiskPE = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, peFiberThick / 2.);

From 16ee3b839f933da6185705bc9476023d84fc8391 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Fri, 20 Feb 2026 21:00:56 +0100
Subject: [PATCH 1350/1764] [ALICE3] Add proto segmentation of TF3 (#15081)

* Use TF3 CAD specifications
---
 .../base/include/IOTOFBase/IOTOFBaseParam.h   |   2 +
 .../include/IOTOFSimulation/Detector.h        |   2 +-
 .../include/IOTOFSimulation/Layer.h           |  22 +-
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  |  44 ++--
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     | 237 ++++++++++++++----
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      |   1 -
 6 files changed, 239 insertions(+), 69 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
index bf605797cbfe5..b74fc6d6869dd 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
@@ -26,6 +26,8 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
   bool enableForwardTOF = true;
   bool enableBackwardTOF = true;
   std::string detectorPattern = "";
+  bool segmentedInnerTOF = false; // If the inner TOF layer is segmented
+  bool segmentedOuterTOF = false; // If the outer TOF layer is segmented
 
   O2ParamDef(IOTOFBaseParam, "IOTOFBase");
 };
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
index f39a43733ccab..f3c4e3ddd6276 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
@@ -60,7 +60,7 @@ class Detector : public o2::base::DetImpl<Detector>
     return nullptr;
   }
 
-  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "");
+  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "", bool itofSegmented = false, bool otofSegmented = false);
 
   void configServices();
   void createMaterials();
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
index b7cc0a05c1c2e..df3687b2b2ea4 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
@@ -14,6 +14,8 @@
 
 #include <TGeoManager.h>
 #include <Rtypes.h>
+#include <string>
+#include <vector>
 
 namespace o2
 {
@@ -23,7 +25,8 @@ class Layer
 {
  public:
   Layer() = default;
-  Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0, bool isBarrel = true);
+  Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0,
+        int layout = kBarrel, int nSegments = 0, float segmentSize = 0.0, int nSensorsPerSegment = 0, double tiltAngle = 0.0);
   ~Layer() = default;
 
   auto getInnerRadius() const { return mInnerRadius; }
@@ -33,9 +36,14 @@ class Layer
   auto getx2X0() const { return mX2X0; }
   auto getChipThickness() const { return mChipThickness; }
   auto getName() const { return mLayerName; }
-  auto getIsBarrel() const { return mIsBarrel; }
+  auto getLayout() const { return mLayout; }
+  auto getSegments() const { return mSegments; }
+  static constexpr int kBarrel = 0;
+  static constexpr int kDisk = 1;
+  static constexpr int kBarrelSegmented = 2;
+  static constexpr int kDiskSegmented = 3;
 
-  virtual void createLayer(TGeoVolume* motherVolume){};
+  virtual void createLayer(TGeoVolume* motherVolume) {};
 
  protected:
   std::string mLayerName;
@@ -45,7 +53,11 @@ class Layer
   float mZOffset{0.f}; // Of use when fwd layers
   float mX2X0;
   float mChipThickness;
-  bool mIsBarrel{true};
+  int mLayout{kBarrel}; // Identifier of the type of layer layout (barrel, disk, barrel segmented, disk segmented)
+  // To be used only in case of the segmented layout, to define the number of segments in phi (for barrel) or in r (for disk)
+  std::pair<int, float> mSegments{0, 0.0f}; // Number  and size of segments in phi (for barrel) or in r (for disk) in case of segmented layout
+  int mSensorsPerSegment{0};                // Number of sensors along a segment
+  double mTiltAngle{0.0};                   // Tilt angle in degrees to be applied as a rotation around the local center of the segment
 };
 
 class ITOFLayer : public Layer
@@ -53,6 +65,7 @@ class ITOFLayer : public Layer
  public:
   using Layer::Layer;
   virtual void createLayer(TGeoVolume* motherVolume) override;
+  static std::vector<std::string> mRegister;
 };
 
 class OTOFLayer : public Layer
@@ -60,6 +73,7 @@ class OTOFLayer : public Layer
  public:
   using Layer::Layer;
   virtual void createLayer(TGeoVolume* motherVolume) override;
+  static std::vector<std::string> mRegister;
 };
 
 class FTOFLayer : public Layer
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index 3a971e81a610d..0742af3a1340a 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -40,7 +40,8 @@ Detector::Detector(bool active)
   auto& iotofPars = IOTOFBaseParam::Instance();
   configLayers(iotofPars.enableInnerTOF, iotofPars.enableOuterTOF,
                iotofPars.enableForwardTOF, iotofPars.enableBackwardTOF,
-               iotofPars.detectorPattern);
+               iotofPars.detectorPattern,
+               iotofPars.segmentedInnerTOF, iotofPars.segmentedOuterTOF);
 }
 
 Detector::~Detector()
@@ -56,7 +57,7 @@ void Detector::ConstructGeometry()
   createGeometry();
 }
 
-void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::string pattern)
+void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::string pattern, bool itofSegmented, bool otofSegmented)
 {
 
   float radiusInnerTof = 19.f;
@@ -65,9 +66,10 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
   float lengthOuterTof = 680.f;
   std::pair<float, float> radiusRangeDiskTof = {15.f, 100.f};
   float zForwardTof = 370.f;
+  LOG(info) << "Configuring IOTOF layers with '" << pattern << "' pattern";
   if (pattern == "") {
+    LOG(info) << "Default pattern";
   } else if (pattern == "v3b") {
-    LOG(info) << "Configuring IOTOF layers with v3b pattern";
     ftof = false;
     btof = false;
   } else if (pattern == "v3b1a") {
@@ -93,17 +95,25 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
   } else {
     LOG(fatal) << "IOTOF layer pattern " << pattern << " not recognized, exiting";
   }
-  if (itof) {
-    mITOFLayer = ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()}, radiusInnerTof, 0.f, lengthInnerTof, 0.f, 0.02f, true); // iTOF
+  if (itof) { // iTOF
+    mITOFLayer = itofSegmented ? ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()},
+                                           radiusInnerTof, 0.f, lengthInnerTof, 0.f, 0.02f, ITOFLayer::kBarrelSegmented,
+                                           24, 5.42, 80, 10)
+                               : ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()},
+                                           radiusInnerTof, 0.f, lengthInnerTof, 0.f, 0.02f, ITOFLayer::kBarrel);
   }
-  if (otof) {
-    mOTOFLayer = OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()}, radiusOuterTof, 0.f, lengthOuterTof, 0.f, 0.02f, true); // oTOF
+  if (otof) { // oTOF
+    mOTOFLayer = otofSegmented ? OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()},
+                                           radiusOuterTof, 0.f, lengthOuterTof, 0.f, 0.02f, OTOFLayer::kBarrelSegmented,
+                                           62, 9.74, 432, 5)
+                               : OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()},
+                                           radiusOuterTof, 0.f, lengthOuterTof, 0.f, 0.02f, OTOFLayer::kBarrel);
   }
   if (ftof) {
-    mFTOFLayer = FTOFLayer(std::string{GeometryTGeo::getFTOFLayerPattern()}, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, zForwardTof, 0.02f, false); // fTOF
+    mFTOFLayer = FTOFLayer(std::string{GeometryTGeo::getFTOFLayerPattern()}, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, zForwardTof, 0.02f, FTOFLayer::kDisk); // fTOF
   }
   if (btof) {
-    mBTOFLayer = BTOFLayer(std::string{GeometryTGeo::getBTOFLayerPattern()}, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, -zForwardTof, 0.02f, false); // bTOF
+    mBTOFLayer = BTOFLayer(std::string{GeometryTGeo::getBTOFLayerPattern()}, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, -zForwardTof, 0.02f, BTOFLayer::kDisk); // bTOF
   }
 }
 
@@ -186,14 +196,18 @@ void Detector::defineSensitiveVolumes()
   // The names of the IOTOF sensitive volumes have the format: IOTOFLayer(0...mLayers.size()-1)
   auto& iotofPars = IOTOFBaseParam::Instance();
   if (iotofPars.enableInnerTOF) {
-    v = geoManager->GetVolume(GeometryTGeo::getITOFSensorPattern());
-    LOGP(info, "Adding IOTOF Sensitive Volume {}", v->GetName());
-    AddSensitiveVolume(v);
+    for (const std::string& itofSensor : ITOFLayer::mRegister) {
+      v = geoManager->GetVolume(itofSensor.c_str());
+      LOGP(info, "Adding IOTOF Sensitive Volume {}", v->GetName());
+      AddSensitiveVolume(v);
+    }
   }
   if (iotofPars.enableOuterTOF) {
-    v = geoManager->GetVolume(GeometryTGeo::getOTOFSensorPattern());
-    LOGP(info, "Adding IOTOF Sensitive Volume {}", v->GetName());
-    AddSensitiveVolume(v);
+    for (const std::string& otofSensor : OTOFLayer::mRegister) {
+      v = geoManager->GetVolume(otofSensor.c_str());
+      LOGP(info, "Adding IOTOF Sensitive Volume {}", v->GetName());
+      AddSensitiveVolume(v);
+    }
   }
   if (iotofPars.enableForwardTOF) {
     v = geoManager->GetVolume(GeometryTGeo::getFTOFSensorPattern());
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 53c07d1fa4978..169a1271da47e 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -14,84 +14,225 @@
 
 #include "Framework/Logger.h"
 
+#include <TGeoBBox.h>
+#include <TGeoMatrix.h>
 #include <TGeoTube.h>
 #include <TGeoVolume.h>
+#include <TMath.h>
+
+#include <algorithm>
+#include <cmath>
 
 namespace o2
 {
 namespace iotof
 {
-Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0, bool isBarrel)
-  : mLayerName(layerName), mInnerRadius(rInn), mOuterRadius(rOut), mZLength(zLength), mZOffset(zOffset), mX2X0(layerX2X0), mIsBarrel(isBarrel)
+Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0, int layout, int nSegments, float segmentSize, int nSensorsPerSegment, double tiltAngle)
+  : mLayerName(layerName),
+    mInnerRadius(rInn),
+    mOuterRadius(rOut),
+    mZLength(zLength),
+    mZOffset(zOffset),
+    mX2X0(layerX2X0),
+    mLayout(layout),
+    mSegments(nSegments, segmentSize),
+    mSensorsPerSegment(nSensorsPerSegment),
+    mTiltAngle(tiltAngle)
 {
   float Si_X0 = 9.5f;
   mChipThickness = mX2X0 * Si_X0;
-  if (isBarrel) {
-    mOuterRadius = mInnerRadius + mChipThickness;
-  } else {
-    mZLength = mChipThickness;
+  std::string name = "";
+  switch (layout) {
+    case kBarrel:
+    case kBarrelSegmented:
+      name = "barrel";
+      mOuterRadius = mInnerRadius + mChipThickness;
+      break;
+    case kDisk:
+    case kDiskSegmented:
+      name = "forward";
+      mZLength = mChipThickness;
+      break;
+    default:
+      LOG(fatal) << "Invalid layout " << layout;
+  }
+  if (1) { // Sanity checks
+    if (mInnerRadius > mOuterRadius) {
+      LOG(fatal) << "Invalid layer dimensions: rInner " << mInnerRadius << " cm is larger than rOuter " << mOuterRadius << " cm";
+    }
+    if ((mSegments.first != 0 || mSegments.second != 0.0f) && (layout != kBarrelSegmented && layout != kDiskSegmented)) {
+      LOG(fatal) << "Invalid configuration: number of segments " << mSegments.first << " is set for non-segmented layout " << layout;
+    }
+    if ((mSegments.first <= 1 || mSegments.second <= 0.0f) && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
+      LOG(fatal) << "Invalid configuration: number of segments " << mSegments.first << " must be positive for segmented layout " << layout;
+    }
+    if (mSensorsPerSegment <= 0 && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
+      LOG(fatal) << "Invalid configuration: number of sensors per segment " << mSensorsPerSegment << " must be positive for segmented layout " << layout;
+    }
+    if (std::abs(mTiltAngle) > 0.1 && (layout != kBarrelSegmented && layout != kDiskSegmented)) {
+      LOG(fatal) << "Invalid configuration: tilt angle " << mTiltAngle << " is set for non-segmented layout " << layout;
+    }
   }
-  LOGP(info, "TOF: Creating {} layer: rInner: {} (cm) rOuter: {} (cm) zLength: {} (cm) zOffset: {} x2X0: {}", isBarrel ? std::string("barrel") : std::string("forward"), mInnerRadius, mOuterRadius, mZLength, mZOffset, mX2X0);
+
+  LOGP(info, "TOF: Creating {} layer: rInner: {} (cm) rOuter: {} (cm) zLength: {} (cm) zOffset: {} x2X0: {}", name.c_str(), mInnerRadius, mOuterRadius, mZLength, mZOffset, mX2X0);
 }
 
+std::vector<std::string> ITOFLayer::mRegister;
 void ITOFLayer::createLayer(TGeoVolume* motherVolume)
 {
-  std::string chipName = o2::iotof::GeometryTGeo::getITOFChipPattern(),
-              sensName = o2::iotof::GeometryTGeo::getITOFSensorPattern();
-
-  TGeoTube* sensor = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
-  TGeoTube* chip = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
-  TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+  const std::string chipName = o2::iotof::GeometryTGeo::getITOFChipPattern();
+  const std::string sensName = o2::iotof::GeometryTGeo::getITOFSensorPattern();
 
   TGeoMedium* medSi = gGeoManager->GetMedium("TF3_SILICON$");
   TGeoMedium* medAir = gGeoManager->GetMedium("TF3_AIR$");
-
   LOGP(info, "Media: {} {}", (void*)medSi, (void*)medAir);
 
-  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
-  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
-  TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-  sensVol->SetLineColor(kRed + 3);
-  chipVol->SetLineColor(kRed + 3);
-  layerVol->SetLineColor(kRed + 3);
-
-  LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-  chipVol->AddNode(sensVol, 1, nullptr);
-
-  LOGP(info, "Inserting {} in {} ", chipVol->GetName(), layerVol->GetName());
-  layerVol->AddNode(chipVol, 1, nullptr);
-
-  LOGP(info, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
-  motherVolume->AddNode(layerVol, 1, nullptr);
+  switch (mLayout) {
+    case kBarrel: {
+      TGeoTube* sensor = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+      TGeoTube* chip = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+      TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+
+      TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
+      TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+      TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+      sensVol->SetLineColor(kRed + 3);
+      chipVol->SetLineColor(kRed + 3);
+      layerVol->SetLineColor(kRed + 3);
+
+      LOGP(info, "Inserting Barrel {} in {} ", sensVol->GetName(), chipVol->GetName());
+      ITOFLayer::mRegister.push_back(sensVol->GetName());
+      chipVol->AddNode(sensVol, 1, nullptr);
+
+      LOGP(info, "Inserting Barrel {} in {} ", chipVol->GetName(), layerVol->GetName());
+      layerVol->AddNode(chipVol, 1, nullptr);
+
+      LOGP(info, "Inserting Barrel {} in {} ", layerVol->GetName(), motherVolume->GetName());
+      motherVolume->AddNode(layerVol, 1, nullptr);
+      return;
+    }
+    case kBarrelSegmented: {
+      const double circumference = TMath::TwoPi() * 0.5 * (mInnerRadius + mOuterRadius);
+      const double segmentSize = mSegments.second; // cm circumference / mSegments;
+      const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
+      TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+      TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+      layerVol->SetLineColor(kRed + 3);
+
+      for (int i = 0; i < mSegments.first; ++i) {
+        LOGP(info, "iTOF: Creating segment {}/{} with size {} and thickness {}cm", i + 1, mSegments.first, segmentSize, (mOuterRadius - mInnerRadius));
+        const double hx = 0.5 * segmentSize;
+        const double hy = 0.5 * (mOuterRadius - mInnerRadius);
+        const double hz = 0.5 * mZLength;
+        TGeoBBox* sensor = new TGeoBBox(hy, hx, hz);
+        TGeoBBox* chip = new TGeoBBox(hy, hx, hz);
+        const std::string segmentTag = Form("segment%d", i + 1);
+        TGeoVolume* sensVol = new TGeoVolume(Form("%s_%s", sensName.c_str(), segmentTag.c_str()), sensor, medSi);
+        TGeoVolume* chipVol = new TGeoVolume(Form("%s_%s", chipName.c_str(), segmentTag.c_str()), chip, medSi);
+        sensVol->SetLineColor(kRed + 3);
+        chipVol->SetLineColor(kRed + 3);
+
+        LOGP(info, "  Inserting Barrel {} in {} ", sensVol->GetName(), chipVol->GetName());
+        ITOFLayer::mRegister.push_back(sensVol->GetName());
+        chipVol->AddNode(sensVol, 1, nullptr);
+
+        const double phi = TMath::TwoPi() * i / mSegments.first;
+
+        LOG(info) << "  Tilting angle for segment " << i + 1 << ": " << phi * TMath::RadToDeg() << " degrees";
+        const double x = avgRadius * TMath::Cos(phi);
+        const double y = avgRadius * TMath::Sin(phi);
+        auto* rotation = new TGeoRotation(Form("segmentRot%d", i + 1), phi * TMath::RadToDeg() + mTiltAngle, 0, 0);
+        auto* transformation = new TGeoCombiTrans(x, y, 0, rotation);
+
+        LOGP(info, "Inserting Barrel {} in {} ", chipVol->GetName(), layerVol->GetName());
+        layerVol->AddNode(chipVol, 1 + i, transformation);
+      }
+      LOGP(info, "Inserting Barrel {} in {} at r={} cm", layerVol->GetName(), motherVolume->GetName(), avgRadius);
+      motherVolume->AddNode(layerVol, 1, nullptr);
+      return;
+    }
+    default:
+      LOG(fatal) << "Invalid layout " << mLayout;
+  }
 }
 
+std::vector<std::string> OTOFLayer::mRegister;
 void OTOFLayer::createLayer(TGeoVolume* motherVolume)
 {
   std::string chipName = o2::iotof::GeometryTGeo::getOTOFChipPattern(),
               sensName = o2::iotof::GeometryTGeo::getOTOFSensorPattern();
 
-  TGeoTube* sensor = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
-  TGeoTube* chip = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
-  TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
-
   TGeoMedium* medSi = gGeoManager->GetMedium("TF3_SILICON$");
   TGeoMedium* medAir = gGeoManager->GetMedium("TF3_AIR$");
+  LOGP(info, "Media: {} {}", (void*)medSi, (void*)medAir);
 
-  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
-  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
-  TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-  sensVol->SetLineColor(kRed + 3);
-  chipVol->SetLineColor(kRed + 3);
-  layerVol->SetLineColor(kRed + 3);
-
-  LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-  chipVol->AddNode(sensVol, 1, nullptr);
-
-  LOGP(info, "Inserting {} in {} ", chipVol->GetName(), layerVol->GetName());
-  layerVol->AddNode(chipVol, 1, nullptr);
-
-  LOGP(info, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
-  motherVolume->AddNode(layerVol, 1, nullptr);
+  switch (mLayout) {
+    case kBarrel: {
+      TGeoTube* sensor = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+      TGeoTube* chip = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+      TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+
+      TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
+      TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+      TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+      sensVol->SetLineColor(kRed + 3);
+      chipVol->SetLineColor(kRed + 3);
+      layerVol->SetLineColor(kRed + 3);
+
+      LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+      OTOFLayer::mRegister.push_back(sensVol->GetName());
+      chipVol->AddNode(sensVol, 1, nullptr);
+
+      LOGP(info, "Inserting {} in {} ", chipVol->GetName(), layerVol->GetName());
+      layerVol->AddNode(chipVol, 1, nullptr);
+
+      LOGP(info, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
+      motherVolume->AddNode(layerVol, 1, nullptr);
+      return;
+    }
+    case kBarrelSegmented: {
+      const double circumference = TMath::TwoPi() * 0.5 * (mInnerRadius + mOuterRadius);
+      const double segmentSize = mSegments.second; // cm circumference / mSegments;
+      const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
+      TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+      TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+      layerVol->SetLineColor(kRed + 3);
+
+      for (int i = 0; i < mSegments.first; ++i) {
+        LOGP(info, "oTOF: Creating segment {}/{} with size {} and thickness {}cm", i + 1, mSegments.first, segmentSize, (mOuterRadius - mInnerRadius));
+        const double hx = 0.5 * segmentSize;
+        const double hy = 0.5 * (mOuterRadius - mInnerRadius);
+        const double hz = 0.5 * mZLength;
+        TGeoBBox* sensor = new TGeoBBox(hy, hx, hz);
+        TGeoBBox* chip = new TGeoBBox(hy, hx, hz);
+        const std::string segmentTag = Form("segment%d", i + 1);
+        TGeoVolume* sensVol = new TGeoVolume(Form("%s_%s", sensName.c_str(), segmentTag.c_str()), sensor, medSi);
+        TGeoVolume* chipVol = new TGeoVolume(Form("%s_%s", chipName.c_str(), segmentTag.c_str()), chip, medSi);
+        sensVol->SetLineColor(kRed + 3);
+        chipVol->SetLineColor(kRed + 3);
+
+        LOGP(info, "  Inserting Barrel {} in {} ", sensVol->GetName(), chipVol->GetName());
+        OTOFLayer::mRegister.push_back(sensVol->GetName());
+        chipVol->AddNode(sensVol, 1, nullptr);
+
+        const double phi = TMath::TwoPi() * i / mSegments.first;
+
+        LOG(info) << "  Tilting angle for segment " << i + 1 << ": " << phi * TMath::RadToDeg() << " degrees";
+        const double x = avgRadius * TMath::Cos(phi);
+        const double y = avgRadius * TMath::Sin(phi);
+        auto* rotation = new TGeoRotation(Form("segmentRot%d", i + 1), phi * TMath::RadToDeg() + mTiltAngle, 0, 0);
+        auto* transformation = new TGeoCombiTrans(x, y, 0, rotation);
+
+        LOGP(info, "Inserting Barrel {} in {} ", chipVol->GetName(), layerVol->GetName());
+        layerVol->AddNode(chipVol, 1 + i, transformation);
+      }
+      LOGP(info, "Inserting Barrel {} in {} at r={} cm", layerVol->GetName(), motherVolume->GetName(), avgRadius);
+      motherVolume->AddNode(layerVol, 1, nullptr);
+      return;
+    }
+    default:
+      LOG(fatal) << "Invalid layout " << mLayout;
+  }
 }
 
 void FTOFLayer::createLayer(TGeoVolume* motherVolume)
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 059a35520c1a0..d5d37ec00acef 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -102,7 +102,6 @@ void GeometryTGeo::Build(int loadTrans)
   mLastChipIndexMLOT.resize(mNumberOfLayersMLOT); /// ML and OT are part of TRK as the same detector, without disks
 
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
-    std::cout << "Layer MLOT: " << i << std::endl;
     mNumberOfStaves[i] = extractNumberOfStavesMLOT(i);
     mNumberOfHalfStaves[i] = extractNumberOfHalfStavesMLOT(i);
     mNumberOfModules[i] = extractNumberOfModulesMLOT(i);

From f23aa72dfdb3779502c9510526dab12715756c40 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sat, 21 Feb 2026 16:25:38 +0100
Subject: [PATCH 1351/1764] Add missing reset for FV0 channels vector at TF
 start

---
 Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx b/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx
index b97186bbf81a8..cdf297b334588 100644
--- a/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx
+++ b/Detectors/FIT/FV0/workflow/src/ReconstructionSpec.cxx
@@ -42,6 +42,7 @@ void ReconstructionDPL::run(ProcessingContext& pc)
 {
   mTimer.Start(false);
   mRecPoints.clear();
+  mRecChData.clear();
   auto digits = pc.inputs().get<gsl::span<o2::fv0::Digit>>("digits");
   auto digch = pc.inputs().get<gsl::span<o2::fv0::ChannelData>>("digch");
   // RS: if we need to process MC truth, uncomment lines below

From 354b12edc5d97890ef6ae952be530323b7c41075 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 19 Feb 2026 19:42:12 +0100
Subject: [PATCH 1352/1764] GPU: Improve some error messages

---
 GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx | 4 ++--
 GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx     | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
index cd1717faf178d..51a896c2baf6a 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
@@ -43,10 +43,10 @@ int32_t TPCClusterDecompressor::decompress(const CompressedClustersFlat* cluster
 int32_t TPCClusterDecompressor::decompress(const CompressedClusters* clustersCompressed, o2::tpc::ClusterNativeAccess& clustersNative, std::function<o2::tpc::ClusterNative*(size_t)> allocator, const GPUParam& param, bool deterministicRec)
 {
   if (clustersCompressed->nTracks && clustersCompressed->solenoidBz != -1e6f && clustersCompressed->solenoidBz != param.bzkG) {
-    throw std::runtime_error("Configured solenoid Bz does not match value used for track model encoding");
+    throw std::runtime_error("Configured solenoid Bz " + std::to_string(param.bzkG) + " does not match value used for track model encoding " + std::to_string(clustersCompressed->solenoidBz));
   }
   if (clustersCompressed->nTracks && clustersCompressed->maxTimeBin != -1e6 && clustersCompressed->maxTimeBin != param.continuousMaxTimeBin) {
-    throw std::runtime_error("Configured max time bin does not match value used for track model encoding");
+    throw std::runtime_error("Configured max time bin " + std::to_string(param.continuousMaxTimeBin) + " does not match value used for track model encoding " + std::to_string(clustersCompressed->maxTimeBin));
   }
   std::vector<ClusterNative> clusters[NSECTORS][GPUCA_ROW_COUNT];
   std::atomic_flag locks[NSECTORS][GPUCA_ROW_COUNT];
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index ca1352b3bda1b..89d47d0e1b86c 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -273,10 +273,10 @@ int32_t GPUChainTracking::RunTPCDecompression()
     CompressedClusters& inputGPUShadow = DecompressorShadow.mInputGPU;
 
     if (cmprClsHost.nTracks && cmprClsHost.solenoidBz != -1e6f && cmprClsHost.solenoidBz != param().bzkG) {
-      throw std::runtime_error("Configured solenoid Bz does not match value used for track model encoding");
+      throw std::runtime_error("Configured solenoid Bz " + std::to_string(param().bzkG) + " does not match value used for track model encoding " + std::to_string(cmprClsHost.solenoidBz));
     }
     if (cmprClsHost.nTracks && cmprClsHost.maxTimeBin != -1e6 && cmprClsHost.maxTimeBin != param().continuousMaxTimeBin) {
-      throw std::runtime_error("Configured max time bin does not match value used for track model encoding");
+      throw std::runtime_error("Configured max time bin " + std::to_string(param().continuousMaxTimeBin) + " does not match value used for track model encoding " + std::to_string(cmprClsHost.maxTimeBin));
     }
 
     int32_t inputStream = 0;

From 480167460a22dfe0a23f8c2285901c739f719c6c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Oct 2025 09:44:10 +0200
Subject: [PATCH 1353/1764] GPU: Improve existing debug dumps

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  2 +
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx | 74 ++++++++++---------
 2 files changed, 40 insertions(+), 36 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 14974bdec2303..813e3df29e82e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -199,6 +199,8 @@ class GPUTPCGMMerger : public GPUProcessor
   void DumpRefit(std::ostream& out) const;
   void DumpFinal(std::ostream& out) const;
   void DumpLoopers(std::ostream& out) const;
+  void DumpTrackParam(std::ostream& out) const;
+  void DumpTrackClusters(std::ostream& out, bool non0StateOnly = false, bool noNDF0 = false) const;
 
   template <int32_t mergeType>
   void MergedTrackStreamerInternal(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, int32_t mergeMode, float weight, float frac) const;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 0a83bf47f5725..f6afc46609a11 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -43,10 +43,10 @@ using namespace gputpcgmmergertypes;
 void GPUTPCGMMerger::DumpSectorTracks(std::ostream& out) const
 {
   std::streamsize ss = out.precision();
-  out << std::setprecision(2);
+  out << std::setprecision(10);
   out << "\nTPC Merger Sector Tracks\n";
   for (int32_t iSector = 0; iSector < NSECTORS; iSector++) {
-    out << "Sector Track Info Index " << (mSectorTrackInfoIndex[iSector + 1] - mSectorTrackInfoIndex[iSector]) << " / " << (mSectorTrackInfoIndex[NSECTORS + iSector + 1] - mSectorTrackInfoIndex[NSECTORS + iSector]) << "\n";
+    out << "Sector Track Info Sector " << iSector << " Index " << (mSectorTrackInfoIndex[iSector + 1] - mSectorTrackInfoIndex[iSector]) << " / " << (mSectorTrackInfoIndex[NSECTORS + iSector + 1] - mSectorTrackInfoIndex[NSECTORS + iSector]) << "\n";
     for (int32_t iGlobal = 0; iGlobal < 2; iGlobal++) {
       out << "  Track type " << iGlobal << "\n";
       for (int32_t j = mSectorTrackInfoIndex[iSector + NSECTORS * iGlobal]; j < mSectorTrackInfoIndex[iSector + NSECTORS * iGlobal + 1]; j++) {
@@ -134,9 +134,14 @@ void GPUTPCGMMerger::DumpMergedBetweenSectors(std::ostream& out) const
 
 void GPUTPCGMMerger::DumpCollected(std::ostream& out) const
 {
-  std::streamsize ss = out.precision();
-  out << std::setprecision(6);
   out << "\nTPC Merger Collected Tracks\n";
+  DumpTrackParam(out);
+}
+
+void GPUTPCGMMerger::DumpTrackParam(std::ostream& out) const
+{
+  std::streamsize ss = out.precision();
+  out << std::setprecision(10);
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mMergedTracks[i];
     const auto& p = trk.GetParam();
@@ -157,33 +162,42 @@ void GPUTPCGMMerger::DumpMergeCE(std::ostream& out) const
   }
 }
 
-void GPUTPCGMMerger::DumpFitPrepare(std::ostream& out) const
+void GPUTPCGMMerger::DumpTrackClusters(std::ostream& out, bool non0StateOnly, bool noNDF0) const
 {
-  out << "\nTPC Merger Refit Prepare\n";
-  out << "  Sort\n";
-  for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
-    out << "    " << i << ": " << mTrackOrderAttach[i] << "\n";
-  }
-  out << "  Clusters\n";
   for (uint32_t j = 0; j < mMemory->nMergedTracks; j++) {
     const auto& trk = mMergedTracks[j];
-    out << "  Track " << j << ": ";
+    if (trk.NClusters() == 0) {
+      continue;
+    }
+    if (noNDF0 && (!trk.OK() || trk.GetParam().GetNDF() < 0)) {
+      continue;
+    }
+    out << "  Track " << j << ": (" << trk.NClusters() << "): ";
     for (uint32_t i = trk.FirstClusterRef(); i < trk.FirstClusterRef() + trk.NClusters(); i++) {
-      out << j << "/" << (i - trk.FirstClusterRef()) << ": " << mClusters[i].num << "/" << (int32_t)mClusters[i].state << ", ";
+      if (!non0StateOnly || mClusters[i].state != 0) {
+        out << j << "/" << (i - trk.FirstClusterRef()) << ": " << (int32_t)mClusters[i].row << "/" << mClusters[i].num << "/" << (int32_t)mClusters[i].state << ", ";
+      }
     }
     out << "\n";
   }
-  uint32_t maxId = mNMaxClusters;
+}
+
+void GPUTPCGMMerger::DumpFitPrepare(std::ostream& out) const
+{
+  out << "\nTPC Merger Refit Prepare\n";
+  out << "  Sort\n";
+  for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
+    out << "    " << i << ": " << mTrackOrderAttach[i] << "\n";
+  }
+  out << "  Track Clusters";
+  DumpTrackClusters(out);
   uint32_t j = 0;
-  for (uint32_t i = 0; i < maxId; i++) {
+  for (uint32_t i = 0; i < mNMaxClusters; i++) {
     if ((mClusterAttachment[i] & attachFlagMask) != 0) {
-      if (++j % 10 == 0) {
-        out << "    Cluster attachment ";
+      if (j++ % 10 == 0) {
+        out << "\n    Cluster attachment ";
       }
       out << i << ": " << (mClusterAttachment[i] & attachTrackMask) << " / " << (mClusterAttachment[i] & attachFlagMask) << " - ";
-      if (j % 10 == 0) {
-        out << "\n";
-      }
     }
   }
   out << "\n";
@@ -192,7 +206,7 @@ void GPUTPCGMMerger::DumpFitPrepare(std::ostream& out) const
 void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
 {
   std::streamsize ss = out.precision();
-  out << std::setprecision(2);
+  out << std::setprecision(10);
   out << "\nTPC Merger Refit\n";
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mMergedTracks[i];
@@ -224,22 +238,10 @@ void GPUTPCGMMerger::DumpLoopers(std::ostream& out) const
 void GPUTPCGMMerger::DumpFinal(std::ostream& out) const
 {
   out << "\nTPC Merger Finalized\n";
-  for (uint32_t j = 0; j < mMemory->nMergedTracks; j++) {
-    const auto& trk = mMergedTracks[j];
-    if (trk.NClusters() == 0) {
-      continue;
-    }
-    out << "  Track " << j << ": ";
-    for (uint32_t i = trk.FirstClusterRef(); i < trk.FirstClusterRef() + trk.NClusters(); i++) {
-      if (mClusters[i].state != 0) {
-        out << j << "/" << (i - trk.FirstClusterRef()) << ": " << mClusters[i].num << "/" << (int32_t)mClusters[i].state << ", ";
-      }
-    }
-    out << "\n";
-  }
-  uint32_t maxId = mNMaxClusters;
+  out << "Track Clusters\n";
+  DumpTrackClusters(out, true);
   uint32_t j = 0;
-  for (uint32_t i = 0; i < maxId; i++) {
+  for (uint32_t i = 0; i < mNMaxClusters; i++) {
     if ((mClusterAttachment[i] & attachFlagMask) != 0) {
       if (++j % 10 == 0) {
         out << "    Cluster attachment ";

From a839182762a089481cece2ef7e58a3c7136ac93d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 19 Feb 2026 22:27:38 +0100
Subject: [PATCH 1354/1764] GPU TPC: Fix deterministic mode with new cluster
 removal protection

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 260781c17406b..eaf181b741918 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -1852,7 +1852,7 @@ GPUd() void GPUTPCGMMerger::PrepareForFit1(int32_t nBlocks, int32_t nThreads, in
         if (CAMath::Abs(trk.GetParam().GetQPt() * Param().qptB5Scaler) <= Param().rec.tpc.rejectQPtB5 && !trk.MergedLooper() && trk.Leg() == 0) {
           weight |= attachProtect;
         }
-        mClusterAttachment[mClusters[trk.FirstClusterRef() + j].num] = weight;
+        CAMath::AtomicMax(&mClusterAttachment[mClusters[trk.FirstClusterRef() + j].num], weight);
         CAMath::AtomicAdd(&mSharedCount[mClusters[trk.FirstClusterRef() + j].num], 1u);
       }
       if (!trk.CCE() && !trk.MergedLooper()) {

From 84a89e877a04d98c1969997a3789449ec26887bb Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 20 Feb 2026 00:03:17 +0100
Subject: [PATCH 1355/1764] GPU TPC: Do not use fitWithoutProjection for now,
 sometimes broken

---
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx    | 21 +++++++++-----------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h      |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h |  3 ++-
 3 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index eaf181b741918..3622e51bd663f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -555,7 +555,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
   prop.SetMaterialTPC();
   prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
   prop.SetSeedingErrors(true); // Larger errors for seeds, better since we don't start with good hypothesis
-  prop.SetFitInProjections(false);
+  prop.SetFitInProjections(true); // TODO: Was false, consider reenabling after fitInProjection is fixed
   prop.SetPolynomialField(&Param().polynomialField);
   GPUTPCGMTrackParam trk;
   trk.X() = inTrack->Param().GetX();
@@ -718,9 +718,6 @@ GPUd() void GPUTPCGMMerger::MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nT
   } else if (iBorder == 3) { // transport to the middle of the sector and rotate vertically to the border on the right
     dAlpha = -dAlpha;
     x0 = GPUTPCGeometry::Row2X(63);
-  } else if (iBorder == 4) { // transport to the middle of the sßector, w/o rotation
-    dAlpha = 0;
-    x0 = GPUTPCGeometry::Row2X(63);
   }
 
   const float maxSin = CAMath::Sin(60.f / 180.f * CAMath::Pi());
@@ -783,14 +780,14 @@ GPUd() void GPUTPCGMMerger::MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nT
 }
 
 template <>
-GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
+GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
 {
   CADEBUG(GPUInfo("\nMERGING Sectors %d %d NTracks %d %d CROSS %d", iSector1, iSector2, N1, N2, mergeMode));
   GPUTPCGMBorderRange* range1 = mBorderRange[iSector1];
   GPUTPCGMBorderRange* range2 = mBorderRange[iSector2] + *GetConstantMem()->tpcTrackers[iSector2].NTracks();
   bool sameSector = (iSector1 == iSector2);
   for (int32_t itr = iBlock * nThreads + iThread; itr < N1; itr += nThreads * nBlocks) {
-    GPUTPCGMBorderTrack& b = B1[itr];
+    const GPUTPCGMBorderTrack& b = B1[itr];
     float d = CAMath::Max(0.5f, 3.5f * CAMath::Sqrt(b.Cov()[1]));
     if (CAMath::Abs(b.Par()[4]) * Param().qptB5Scaler >= 20) {
       d *= 2;
@@ -809,7 +806,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThrea
   }
   if (!sameSector) {
     for (int32_t itr = iBlock * nThreads + iThread; itr < N2; itr += nThreads * nBlocks) {
-      GPUTPCGMBorderTrack& b = B2[itr];
+      const GPUTPCGMBorderTrack& b = B2[itr];
       float d = CAMath::Max(0.5f, 3.5f * CAMath::Sqrt(b.Cov()[1]));
       if (CAMath::Abs(b.Par()[4]) * Param().qptB5Scaler >= 20) {
         d *= 2;
@@ -827,7 +824,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThrea
 }
 
 template <>
-GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
+GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
 {
 #if !defined(GPUCA_GPUCODE_COMPILEKERNELS)
   GPUTPCGMBorderRange* range1 = mBorderRange[iSector1];
@@ -860,7 +857,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<3>(int32_t nBlocks, int32_t nThrea
 }
 
 template <>
-GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
+GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
 {
   // int32_t statAll = 0, statMerged = 0;
   float factor2ys = Param().rec.tpc.trackMergerFactor2YS;
@@ -887,7 +884,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThrea
       i2++;
     }
 
-    GPUTPCGMBorderTrack& b1 = B1[r1.fId];
+    const GPUTPCGMBorderTrack& b1 = B1[r1.fId];
     if (b1.NClusters() < minNPartHits) {
       continue;
     }
@@ -904,7 +901,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThrea
       }
       // do check
 
-      GPUTPCGMBorderTrack& b2 = B2[r2.fId];
+      const GPUTPCGMBorderTrack& b2 = B2[r2.fId];
 #if defined(GPUCA_MERGER_BY_MC_LABEL) && !defined(GPUCA_GPUCODE)
       int64_t label1 = GetTrackLabel(b1);
       int64_t label2 = GetTrackLabel(b2);
@@ -1019,7 +1016,7 @@ GPUd() void GPUTPCGMMerger::MergeWithinSectorsPrepare(int32_t nBlocks, int32_t n
   const float maxSin = CAMath::Sin(60.f / 180.f * CAMath::Pi());
 
   for (int32_t itr = iBlock * nThreads + iThread; itr < SectorTrackInfoLocalTotal(); itr += nThreads * nBlocks) {
-    GPUTPCGMSectorTrack& track = mSectorTrackInfos[itr];
+    const GPUTPCGMSectorTrack& track = mSectorTrackInfos[itr];
     int32_t iSector = track.Sector();
     GPUTPCGMBorderTrack b;
     if (track.TransportToX(this, x0, Param().bzCLight, b, maxSin)) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 813e3df29e82e..8f554c24c1d8c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -226,7 +226,7 @@ class GPUTPCGMMerger : public GPUProcessor
  private:
   GPUd() void MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iBorder, GPUTPCGMBorderTrack** B, GPUAtomic(uint32_t) * nB, bool useOrigTrackParam = false);
   template <int32_t I>
-  GPUd() void MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode = 0);
+  GPUd() void MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode = 0);
 
   GPUd() void MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, int32_t itr);
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
index 60febbb4428f6..84102cd14ce5c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
@@ -54,6 +54,7 @@ class GPUTPCGMSectorTrack
   GPUd() float SecPhi() const { return mParam.mSecPhi; }
   GPUd() float DzDs() const { return mParam.mDzDs; }
   GPUd() float QPt() const { return mParam.mQPt; }
+  GPUd() const auto& Param() const { return mParam; }
   GPUd() float TOffset() const { return mTOffset; }
 
   GPUd() int32_t LocalTrackId() const { return mLocalTrackId; }
@@ -75,7 +76,7 @@ class GPUTPCGMSectorTrack
   GPUd() void Set(const GPUTPCGMTrackParam& trk, const GPUTPCTrack* sectorTr, float alpha, int32_t sector);
   GPUd() void SetParam2(const GPUTPCGMTrackParam& trk);
   GPUd() void Set(const GPUTPCGMMerger* merger, const GPUTPCTrack* sectorTr, float alpha, int32_t sector);
-  GPUd() void UseParam2() { mParam = mParam2; }
+  GPUd() void UseParam2() { mParam = mParam2; } // TODO: Clean this up!
   GPUd() void SetX2(float v) { mParam2.mX = v; }
   GPUd() float X2() const { return mParam2.mX; }
 

From ab73e40320a9d6512588c642d576a80ada959981 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 23 Feb 2026 10:40:26 +0100
Subject: [PATCH 1356/1764] ITS3: define alignable volumes (#15050)

* ITS3: define alignable volumes

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Add support for ITS3 in Detector class

* Please consider the following formatting changes

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../ITS/base/include/ITSBase/GeometryTGeo.h   |  2 +-
 .../ITSMFT/ITS/base/src/GeometryTGeo.cxx      |  8 +---
 .../ITSMFT/ITS/simulation/src/Detector.cxx    | 21 ++++-----
 .../DescriptorInnerBarrelITS3.h               |  8 ++--
 .../src/DescriptorInnerBarrelITS3.cxx         | 44 +++++++++++++++++++
 5 files changed, 59 insertions(+), 24 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h b/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
index e236c898851f5..c8ef445e273d3 100644
--- a/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
+++ b/Detectors/ITSMFT/ITS/base/include/ITSBase/GeometryTGeo.h
@@ -314,7 +314,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   static const char* getITS3PixelArrayPattern(int layer) { return Form("%s%d", getITS3PixelArrayPatternRaw(), layer); };
 
   /// sym name of the layer
-  static const char* composeSymNameITS(bool isITS3 = false);
+  static const char* composeSymNameITS();
   /// sym name of the layer
   static const char* composeSymNameLayer(int lr, bool isITS3 = false);
 
diff --git a/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx b/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
index 60570b2f204c5..5dc499d05037e 100644
--- a/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
+++ b/Detectors/ITSMFT/ITS/base/src/GeometryTGeo.cxx
@@ -290,14 +290,8 @@ bool GeometryTGeo::getChipId(int index, int& lay, int& hba, int& sta, int& hsta,
 }
 
 //__________________________________________________________________________
-const char* GeometryTGeo::composeSymNameITS(bool isITS3)
+const char* GeometryTGeo::composeSymNameITS()
 {
-  if (isITS3) {
-#ifdef ENABLE_UPGRADES
-    return o2::detectors::DetID(o2::detectors::DetID::IT3).getName();
-#endif
-  }
-
   return o2::detectors::DetID(o2::detectors::DetID::ITS).getName();
 }
 
diff --git a/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx b/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
index 8cfe13097d581..63d7a8ad8dfa2 100644
--- a/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
+++ b/Detectors/ITSMFT/ITS/simulation/src/Detector.cxx
@@ -61,6 +61,7 @@ using Segmentation = o2::itsmft::SegmentationAlpide;
 using namespace o2::its;
 
 #ifdef ENABLE_UPGRADES
+#include "ITS3Simulation/DescriptorInnerBarrelITS3.h"
 using namespace o2::its3;
 #endif
 
@@ -1106,7 +1107,7 @@ void Detector::addAlignableVolumes() const
 
   TString detName = GetName();
   TString path = Form("/cave_1/barrel_1/%s_2", GeometryTGeo::getITSVolPattern());
-  TString sname = GeometryTGeo::composeSymNameITS((detName == "IT3"));
+  TString sname = GeometryTGeo::composeSymNameITS();
 
   LOG(debug) << sname << " <-> " << path;
 
@@ -1117,15 +1118,19 @@ void Detector::addAlignableVolumes() const
   Int_t lastUID = 0;
   for (Int_t lr = 0; lr < mNumberLayers; lr++) {
     if (lr < mNumberInnerLayers) {
+#ifdef ENABLE_UPGRADES
       if (detName == "ITS") {
         ((DescriptorInnerBarrelITS2*)mDescriptorIB.get())->addAlignableVolumesLayer(lr, mWrapperLayerId[lr], path, lastUID);
+      } else {
+        ((DescriptorInnerBarrelITS3*)mDescriptorIB.get())->addAlignableVolumesLayer(lr, mWrapperLayerId[lr], path, lastUID);
       }
+#else
+      ((DescriptorInnerBarrelITS2*)mDescriptorIB.get())->addAlignableVolumesLayer(lr, mWrapperLayerId[lr], path, lastUID);
+#endif
     } else {
       addAlignableVolumesLayer(lr, path, lastUID);
     }
   }
-
-  return;
 }
 
 void Detector::addAlignableVolumesLayer(int lr, TString& parent, Int_t& lastUID) const
@@ -1148,8 +1153,6 @@ void Detector::addAlignableVolumesLayer(int lr, TString& parent, Int_t& lastUID)
   for (Int_t hb = start; hb < nhbarrel; hb++) {
     addAlignableVolumesHalfBarrel(lr, hb, path, lastUID);
   }
-
-  return;
 }
 
 void Detector::addAlignableVolumesHalfBarrel(Int_t lr, Int_t hb, TString& parent, Int_t& lastUID) const
@@ -1177,8 +1180,6 @@ void Detector::addAlignableVolumesHalfBarrel(Int_t lr, Int_t hb, TString& parent
   for (int st = 0; st < nstaves; st++) {
     addAlignableVolumesStave(lr, hb, st, path, lastUID);
   }
-
-  return;
 }
 
 void Detector::addAlignableVolumesStave(Int_t lr, Int_t hb, Int_t st, TString& parent, Int_t& lastUID) const
@@ -1205,8 +1206,6 @@ void Detector::addAlignableVolumesStave(Int_t lr, Int_t hb, Int_t st, TString& p
   for (Int_t sst = start; sst < nhstave; sst++) {
     addAlignableVolumesHalfStave(lr, hb, st, sst, path, lastUID);
   }
-
-  return;
 }
 
 void Detector::addAlignableVolumesHalfStave(Int_t lr, Int_t hb, Int_t st, Int_t hst, TString& parent, Int_t& lastUID) const
@@ -1236,8 +1235,6 @@ void Detector::addAlignableVolumesHalfStave(Int_t lr, Int_t hb, Int_t st, Int_t
   for (Int_t md = start; md < nmodules; md++) {
     addAlignableVolumesModule(lr, hb, st, hst, md, path, lastUID);
   }
-
-  return;
 }
 
 void Detector::addAlignableVolumesModule(Int_t lr, Int_t hb, Int_t st, Int_t hst, Int_t md, TString& parent, Int_t& lastUID) const
@@ -1266,8 +1263,6 @@ void Detector::addAlignableVolumesModule(Int_t lr, Int_t hb, Int_t st, Int_t hst
   for (Int_t ic = 0; ic < nchips; ic++) {
     addAlignableVolumesChip(lr, hb, st, hst, md, ic, path, lastUID);
   }
-
-  return;
 }
 
 void Detector::addAlignableVolumesChip(Int_t lr, Int_t hb, Int_t st, Int_t hst, Int_t md, Int_t ch, TString& parent,
diff --git a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
index 80565df55d154..3e230cee474bd 100644
--- a/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
+++ b/Detectors/Upgrades/ITS3/simulation/include/ITS3Simulation/DescriptorInnerBarrelITS3.h
@@ -40,17 +40,19 @@ class DescriptorInnerBarrelITS3 : public o2::its::DescriptorInnerBarrel
   void createLayer(int idLayer, TGeoVolume* dest);
   void createServices(TGeoVolume* dest);
   void configure() {}
+  void addAlignableVolumesLayer(int idLayer, int wrapperLayerId, TString& parentPath, int& lastUID) const;
 
  protected:
-  int mNumLayers{constants::nLayers};
-
   // wrapper volume properties
   static constexpr double mTolerance{1e-3};
   static constexpr double mWrapperMinRadiusITS3{constants::radiiInner[0] - mTolerance};
   static constexpr double mWrapperMaxRadiusITS3{constants::services::radiusOuter + mTolerance};
-  static constexpr double mWrapperZSpanITS3{constants::services::length * 2 + mTolerance}; // z length is divided in half
+  static constexpr double mWrapperZSpanITS3{(constants::services::length * 2) + mTolerance}; // z length is divided in half
 
  private:
+  void addAlignableVolumesHalfBarrel(int idLayer, int iHB, TString& parentPath, int& lastUID) const;
+  void addAlignableVolumesChips(int idLayer, int iHalfBarrel, TString& parentPath, int& lastUID) const;
+
   std::array<std::unique_ptr<ITS3Layer>, constants::nLayers> mIBLayers;
   std::unique_ptr<ITS3Services> mServices;
 
diff --git a/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx b/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
index 04f244284d5b6..42644fbfe0c38 100644
--- a/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
+++ b/Detectors/Upgrades/ITS3/simulation/src/DescriptorInnerBarrelITS3.cxx
@@ -10,6 +10,8 @@
 // or submit itself to any jurisdiction.
 
 #include "ITS3Simulation/DescriptorInnerBarrelITS3.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "Framework/Logger.h"
 
 using namespace o2::its3;
 
@@ -26,3 +28,45 @@ void DescriptorInnerBarrelITS3::createServices(TGeoVolume* dest)
   mServices = std::make_unique<ITS3Services>();
   mServices->createCYSSAssembly(dest);
 }
+
+void DescriptorInnerBarrelITS3::addAlignableVolumesLayer(int idLayer, int wrapperLayerId, TString& parentPath, int& lastUID) const
+{
+  TString wrpV = wrapperLayerId != -1 ? Form("%s%d_1", its::GeometryTGeo::getITSWrapVolPattern(), wrapperLayerId) : "";
+  TString path = Form("%s/%s/%s%d_0", parentPath.Data(), wrpV.Data(), its::GeometryTGeo::getITS3LayerPattern(), idLayer);
+  TString sname = its::GeometryTGeo::composeSymNameLayer(idLayer, true);
+
+  for (int iHalfBarrel{0}; iHalfBarrel < 2; ++iHalfBarrel) {
+    addAlignableVolumesHalfBarrel(idLayer, iHalfBarrel, path, lastUID);
+  }
+}
+
+void DescriptorInnerBarrelITS3::addAlignableVolumesHalfBarrel(int idLayer, int iHB, TString& parentPath, int& lastUID) const
+{
+  // for ITS3 smallest alignable volume is the half-barrel (e.g., the carbon-form composite structure with the sensors)
+  TString path = Form("%s/%s%d_%d", parentPath.Data(), its::GeometryTGeo::getITS3HalfBarrelPattern(), idLayer, iHB);
+  TString sname = its::GeometryTGeo::composeSymNameHalfBarrel(idLayer, iHB, true);
+  if (!gGeoManager->SetAlignableEntry(sname.Data(), path.Data())) {
+    LOG(fatal) << "Unable to set alignable entry ! " << sname << " : " << path;
+  }
+  addAlignableVolumesChips(idLayer, iHB, path, lastUID);
+}
+
+void DescriptorInnerBarrelITS3::addAlignableVolumesChips(int idLayer, int iHB, TString& parentPath, int& lastUID) const
+{
+  for (int seg{0}; seg < constants::nSegments[idLayer]; ++seg) {
+    for (int rsu{0}; rsu < constants::segment::nRSUs; ++rsu) {
+      for (int tile{0}; tile < constants::rsu::nTiles; ++tile) {
+        TString path = parentPath;
+        path += Form("/%s_0/", its::GeometryTGeo::getITS3ChipPattern(idLayer));
+        path += Form("%s_%d/", its::GeometryTGeo::getITS3SegmentPattern(idLayer), seg);
+        path += Form("%s_%d/", its::GeometryTGeo::getITS3RSUPattern(idLayer), rsu);
+        path += Form("%s_%d/", its::GeometryTGeo::getITS3TilePattern(idLayer), tile);
+        TString sname = its::GeometryTGeo::composeSymNameChip(idLayer, iHB, 0, seg, rsu, tile, true);
+        if (!gGeoManager->SetAlignableEntry(sname.Data(), path.Data())) {
+          LOG(fatal) << "Unable to set alignable entry ! " << sname << " : " << path;
+        }
+        ++lastUID;
+      }
+    }
+  }
+}

From e75007c89783956185afd405ba03c2f0f47eea51 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 22 Feb 2026 22:36:50 +0100
Subject: [PATCH 1357/1764] GPU HIP RTC: Check that AMD_EUS_PER_CU is set

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx | 7 +++++++
 GPU/GPUTracking/Definitions/GPUSettingsList.h             | 1 +
 2 files changed, 8 insertions(+)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index dba7e680d0b2c..c4e1775e445c3 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -74,6 +74,13 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
     }
     fclose(fp);
   }
+  if constexpr (std::string_view("CUDA") == "HIP") { // Check if we are RTC-compiling for HIP
+    if (GetProcessingSettings().hipOverrideAMDEUSperCU > 0) {
+      mParDevice->par_AMD_EUS_PER_CU = GetProcessingSettings().hipOverrideAMDEUSperCU;
+    } else if (mParDevice->par_AMD_EUS_PER_CU <= 0) {
+      GPUFatal("AMD_EUS_PER_CU not set in the parameters provided for the AMD GPU, you can override this via --PROChipOverrideAMDEUSperCU [n]");
+    }
+  }
   const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true, mParDevice->par_AMD_EUS_PER_CU ? (mParDevice->par_AMD_EUS_PER_CU * mWarpSize) : 0) +
                                    "#define GPUCA_WARP_SIZE " + std::to_string(mWarpSize) + "\n";
   if (GetProcessingSettings().rtctech.printLaunchBounds || GetProcessingSettings().debugLevel >= 3) {
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index c61056466929e..ea15ecde78c21 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -372,6 +372,7 @@ AddOption(tpcWriteClustersAfterRejection, bool, false, "", 0, "Apply TPC rejecti
 AddOption(oclPlatformNum, int32_t, -1, "", 0, "Platform to use, in case the backend provides multiple platforms (OpenCL only, -1 = auto-select, -2 query all platforms (also incompatible))")
 AddOption(oclCompileFromSources, bool, false, "", 0, "Compile OpenCL binary from included source code instead of using included spirv code")
 AddOption(oclOverrideSourceBuildFlags, std::string, "", "", 0, "Override OCL build flags for compilation from source, put a space for empty options")
+AddOption(hipOverrideAMDEUSperCU, int32_t, -1, "", 0, "Override AMD_EUS_PER_CU setting")
 AddOption(printSettings, bool, false, "", 0, "Print all settings when initializing")
 AddOption(tpcFreeAllocatedMemoryAfterProcessing, bool, false, "", 0, "Clean all memory allocated by TPC when TPC processing done, only data written to external output resources will remain")
 AddOption(debugOnFailure, int32_t, 0, "", 0, "Dump raw data in case an error occured, bit 1 enables all dumps, otherwise bitmask for: 2 = signal, 3 = GPUErrorCode", def(1))

From 9a75a460b6a2d6c4c004abc6af64b07d7abf2e1e Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 23 Feb 2026 23:51:53 +0100
Subject: [PATCH 1358/1764] o2sim: fix time aggregation in dpl-eventgen
 (#15091)

* Fix timeframe aggregation in dpl-eventgen

* precalculate batch size so it does not depend on the event counter
  updated in the generator loop

* use DataAllocator::make instead of snapshot to reduce memory churn
---
 .../include/Generators/GeneratorService.h     |  2 ++
 Generators/src/GeneratorService.cxx           | 12 +++++++
 run/dpl_eventgen.cxx                          | 36 ++++++++++++-------
 run/o2sim_mctracks_to_aod.cxx                 |  3 +-
 4 files changed, 38 insertions(+), 15 deletions(-)

diff --git a/Generators/include/Generators/GeneratorService.h b/Generators/include/Generators/GeneratorService.h
index a0037707bcdd6..13ebe054f2940 100644
--- a/Generators/include/Generators/GeneratorService.h
+++ b/Generators/include/Generators/GeneratorService.h
@@ -20,6 +20,7 @@
 #include <SimulationDataFormat/MCTrack.h>
 #include <Generators/PrimaryGenerator.h> // could be forward declaration
 #include <DetectorsBase/Stack.h>
+#include <MemoryResources/MemoryResources.h>
 
 namespace o2
 {
@@ -66,6 +67,7 @@ class GeneratorService
   std::pair<std::vector<MCTrack>, o2::dataformats::MCEventHeader> generateEvent();
 
   void generateEvent_MCTracks(std::vector<MCTrack>& tracks, o2::dataformats::MCEventHeader& header);
+  void generateEvent_MCTracks(o2::pmr::vector<MCTrack>& tracks, o2::dataformats::MCEventHeader& header);
   void generateEvent_TParticles(std::vector<TParticle>& tparts, o2::dataformats::MCEventHeader& header);
 
  private:
diff --git a/Generators/src/GeneratorService.cxx b/Generators/src/GeneratorService.cxx
index 902b482dc839b..ae0de385a1b23 100644
--- a/Generators/src/GeneratorService.cxx
+++ b/Generators/src/GeneratorService.cxx
@@ -61,6 +61,18 @@ void GeneratorService::generateEvent_MCTracks(std::vector<MCTrack>& tracks, o2::
   }
 }
 
+void GeneratorService::generateEvent_MCTracks(o2::pmr::vector<MCTrack>& tracks, o2::dataformats::MCEventHeader& header)
+{
+  mPrimGen.SetEvent(&header);
+  mStack.Reset();
+  mPrimGen.GenerateEvent(&mStack); // this is the usual FairROOT interface going via stack
+
+  tracks.reserve(mStack.getPrimaries().size());
+  for (auto& tparticle : mStack.getPrimaries()) {
+    tracks.emplace_back(tparticle);
+  }
+}
+
 std::pair<std::vector<o2::MCTrack>, o2::dataformats::MCEventHeader> GeneratorService::generateEvent()
 {
   std::vector<o2::MCTrack> tracks;
diff --git a/run/dpl_eventgen.cxx b/run/dpl_eventgen.cxx
index 6202e965f3e8a..3df16ee3e5ebb 100644
--- a/run/dpl_eventgen.cxx
+++ b/run/dpl_eventgen.cxx
@@ -50,6 +50,9 @@ struct GeneratorTask {
   std::unique_ptr<o2::eventgen::GeneratorService> genservice;
   TStopwatch timer;
 
+  std::vector<o2::pmr::vector<o2::MCTrack>*> mctracks_vector;
+  std::vector<o2::dataformats::MCEventHeader*> mcheader_vector;
+
   void init(o2::framework::InitContext& /*ic*/)
   {
     genservice.reset(new o2::eventgen::GeneratorService);
@@ -85,25 +88,31 @@ struct GeneratorTask {
       outfile.reset(new TFile(kineoutfilename.c_str(), "RECREATE"));
       outtree.reset(new TTree("o2sim", "o2sim"));
     }
+
+    mctracks_vector.reserve(aggregate);
+    mcheader_vector.reserve(aggregate);
   }
 
   void run(o2::framework::ProcessingContext& pc)
   {
-    std::vector<o2::MCTrack> mctracks;
-    o2::dataformats::MCEventHeader mcheader;
-    auto mctrack_ptr = &mctracks;
-    if (outfile.get()) {
-      auto br = o2::base::getOrMakeBranch(*outtree, "MCTrack", &mctrack_ptr);
-      br->SetAddress(&mctrack_ptr);
-    }
+    mctracks_vector.clear();
+    mcheader_vector.clear();
 
-    for (auto i = 0; i < std::min((GenCount)aggregate, nEvents - eventCounter); ++i) {
-      mctracks.clear();
-      genservice->generateEvent_MCTracks(mctracks, mcheader);
-      pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcheader);
-      pc.outputs().snapshot(Output{"MC", "MCTRACKS", 0}, mctracks);
+    auto batch = std::min((GenCount)aggregate, nEvents - eventCounter);
+    for (auto i = 0U; i < batch; ++i) {
+      mctracks_vector.push_back(&pc.outputs().make<o2::pmr::vector<o2::MCTrack>>(Output{"MC", "MCTRACKS", 0}));
+      auto& mctracks = mctracks_vector.back();
+      mcheader_vector.push_back(&pc.outputs().make<o2::dataformats::MCEventHeader>(Output{"MC", "MCHEADER", 0}));
+      auto& mcheader = mcheader_vector.back();
+      genservice->generateEvent_MCTracks(*mctracks, *mcheader);
       ++eventCounter;
 
+      auto mctrack_ptr = mctracks;
+      if (outfile.get()) {
+        auto br = o2::base::getOrMakeBranch(*outtree, "MCTrack", &mctrack_ptr);
+        br->SetAddress(&mctrack_ptr);
+      }
+
       if (outfile.get() && outtree.get()) {
         outtree->Fill();
       }
@@ -112,6 +121,7 @@ struct GeneratorTask {
     // report number of TFs injected for the rate limiter to work
     ++tfCounter;
     pc.services().get<o2::monitoring::Monitoring>().send(o2::monitoring::Metric{(uint64_t)tfCounter, "df-sent"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
+
     bool time_expired = false;
     if (ttl > 0) {
       timer.Stop();
@@ -125,7 +135,7 @@ struct GeneratorTask {
       pc.services().get<ControlService>().endOfStream();
       pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
 
-      // write out data to disc if asked
+      // write out data to disk if asked
       if (outfile.get()) {
         outtree->SetEntries(eventCounter);
         outtree->Write();
diff --git a/run/o2sim_mctracks_to_aod.cxx b/run/o2sim_mctracks_to_aod.cxx
index f7a85e62a3f9b..124e8aa7b3e42 100644
--- a/run/o2sim_mctracks_to_aod.cxx
+++ b/run/o2sim_mctracks_to_aod.cxx
@@ -94,9 +94,8 @@ struct MctracksToAod {
     // TODO: include BC simulation
     auto bcCounter = 0UL;
     size_t offset = 0;
+    LOG(debug) << "--- Loop over " << nParts << " parts ---";
     for (auto i = 0U; i < nParts; ++i) {
-      LOG(debug) << "--- Loop over " << nParts << " parts ---";
-
       auto record = mSampler.generateCollisionTime();
       auto header = pc.inputs().get<McHeader*>("mcheader", i);
       auto tracks = pc.inputs().get<McTracks>("mctracks", i);

From 03279d0607888602f7157dee8a2d05b4ac5af1b8 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 24 Feb 2026 08:39:51 +0100
Subject: [PATCH 1359/1764] Fix missing accumulate of covmatrix in fall-back
 case

---
 Common/DCAFitter/include/DCAFitter/DCAFitterN.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
index 1adf7a9ae7329..2641dec84aed9 100644
--- a/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
+++ b/Common/DCAFitter/include/DCAFitter/DCAFitterN.h
@@ -818,6 +818,7 @@ GPUd() o2::math_utils::SMatrix<double, 3, 3, o2::math_utils::MatRepSym<double, 3
   MatSym3D covmSum;
   for (int i = N; i--;) {
     MatSym3D covTr = o2::math_utils::Similarity(getTrackRotMatrix(i), getTrackCovMatrix(i, cand));
+    covmSum += covTr;
   }
   return covmSum;
 }

From 47fced53c0a25984601944d92b0193690985d839 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Mon, 23 Feb 2026 17:37:07 +0100
Subject: [PATCH 1360/1764] Workaround for HepMC3 bug

---
 Generators/src/GeneratorHepMC.cxx | 42 +++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 7 deletions(-)

diff --git a/Generators/src/GeneratorHepMC.cxx b/Generators/src/GeneratorHepMC.cxx
index 371e0cf1acce1..180a088c02a92 100644
--- a/Generators/src/GeneratorHepMC.cxx
+++ b/Generators/src/GeneratorHepMC.cxx
@@ -27,6 +27,7 @@
 #include <fairlogger/Logger.h>
 #include "FairPrimaryGenerator.h"
 #include <cmath>
+#include <sstream>
 
 namespace o2
 {
@@ -420,6 +421,34 @@ void GeneratorHepMC::updateHeader(o2::dataformats::MCEventHeader* eventHeader)
   auto pdfInfo = mEvent->pdf_info();
   auto hiInfo = mEvent->heavy_ion();
 
+  // Workaround for a bug in HepMC3 (3.3.1 on 23/02/2026): GenHeavyIon::from_string() for the "v0"
+  // format skips reading user_cent_estimate, but to_string() always writes it.
+  // This shifts all subsequent fields by one, causing a istringstream failure and and heavy_ion()
+  // to return null even when the attribute is present and well-formed.
+  // For now we use this manual parser in case the infos are available
+  if (!hiInfo) {
+    auto attStr = mEvent->attribute_as_string("GenHeavyIon");
+    if (!attStr.empty() && attStr[0] == 'v') {
+      std::istringstream is(attStr);
+      std::string version;
+      is >> version;
+      if (version == "v0") {
+        auto hi = std::make_shared<HepMC3::GenHeavyIon>();
+        double spectNeutrons, spectProtons, eccentricity, userCentEst;
+        is >> hi->Ncoll_hard >> hi->Npart_proj >> hi->Npart_targ >> hi->Ncoll >> spectNeutrons >> spectProtons                                                           // deprecated v0 fields
+          >> hi->N_Nwounded_collisions >> hi->Nwounded_N_collisions >> hi->Nwounded_Nwounded_collisions >> hi->impact_parameter >> hi->event_plane_angle >> eccentricity // deprecated v0 field
+          >> hi->sigma_inel_NN >> hi->centrality >> userCentEst                                                                                                          // GenHeavyIon::to_string always writes this, but GenHeavyIon::from_string skips it for v0 (HepMC3 bug to fix)
+          >> hi->Nspec_proj_n >> hi->Nspec_targ_n >> hi->Nspec_proj_p >> hi->Nspec_targ_p;
+        if (!is.fail()) {
+          LOG(debug) << "GenHeavyIon: using manual v0 parser (workaround for HepMC3 from_string bug)";
+          hiInfo = hi;
+        } else {
+          LOG(warn) << "GenHeavyIon: manual v0 parser also failed on: [" << attStr << "]";
+        }
+      }
+    }
+  }
+
   // Set default cross-section
   if (xSection) {
     eventHeader->putInfo<float>(Key::xSection, xSection->xsec());
@@ -457,8 +486,9 @@ void GeneratorHepMC::updateHeader(o2::dataformats::MCEventHeader* eventHeader)
 
   // Set heavy-ion information
   if (hiInfo) {
-    eventHeader->putInfo<int>(Key::impactParameter,
-                              hiInfo->impact_parameter);
+    eventHeader->SetB(hiInfo->impact_parameter); // sets the impact parameter to the FairMCEventHeader field for quick access in the AO2D
+    eventHeader->putInfo<float>(Key::impactParameter,
+                                hiInfo->impact_parameter);
     eventHeader->putInfo<int>(Key::nPart,
                               hiInfo->Npart_proj + hiInfo->Npart_targ);
     eventHeader->putInfo<int>(Key::nPartProjectile, hiInfo->Npart_proj);
@@ -471,11 +501,9 @@ void GeneratorHepMC::updateHeader(o2::dataformats::MCEventHeader* eventHeader)
                               hiInfo->Nwounded_N_collisions);
     eventHeader->putInfo<int>(Key::nCollNWoundedNwounded,
                               hiInfo->Nwounded_Nwounded_collisions);
-    eventHeader->putInfo<int>(Key::planeAngle,
-                              hiInfo->event_plane_angle);
-    eventHeader->putInfo<int>(Key::sigmaInelNN,
-                              hiInfo->sigma_inel_NN);
-    eventHeader->putInfo<int>(Key::centrality, hiInfo->centrality);
+    eventHeader->putInfo<float>(Key::planeAngle, hiInfo->event_plane_angle);
+    eventHeader->putInfo<float>(Key::sigmaInelNN, hiInfo->sigma_inel_NN);
+    eventHeader->putInfo<float>(Key::centrality, hiInfo->centrality);
     eventHeader->putInfo<int>(Key::nSpecProjectileProton, hiInfo->Nspec_proj_p);
     eventHeader->putInfo<int>(Key::nSpecProjectileNeutron, hiInfo->Nspec_proj_n);
     eventHeader->putInfo<int>(Key::nSpecTargetProton, hiInfo->Nspec_targ_p);

From 96fafb9e89326b76b1ab86eef6301d59c1e62dba Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Mon, 23 Feb 2026 17:34:44 +0100
Subject: [PATCH 1361/1764] Update MC header when using event pool generator

---
 Generators/include/Generators/GeneratorFromFile.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/Generators/include/Generators/GeneratorFromFile.h b/Generators/include/Generators/GeneratorFromFile.h
index 3b469751a4d47..706557ea2484b 100644
--- a/Generators/include/Generators/GeneratorFromFile.h
+++ b/Generators/include/Generators/GeneratorFromFile.h
@@ -87,11 +87,10 @@ class GeneratorFromO2Kine : public o2::eventgen::Generator
   void SetStartEvent(int start);
 
   void setContinueMode(bool val) { mContinueMode = val; };
-
- private:
   /** methods that can be overridden **/
   void updateHeader(o2::dataformats::MCEventHeader* eventHeader) override;
 
+ private:
   TFile* mEventFile = nullptr;     //! the file containing the persistent events
   TBranch* mEventBranch = nullptr; //! the branch containing the persistent events
   TBranch* mMCHeaderBranch = nullptr; //! branch containing MC event headers
@@ -143,6 +142,11 @@ class GeneratorFromEventPool : public o2::eventgen::Generator
     return import_good;
   }
 
+  void updateHeader(o2::dataformats::MCEventHeader* eventHeader) override
+  {
+    mO2KineGenerator->updateHeader(eventHeader);
+  }
+
   // determine the collection of available files
   std::vector<std::string> setupFileUniverse(std::string const& path) const;
 

From 60cea723ef5288c10973f41f4d5fc59e51a7a874 Mon Sep 17 00:00:00 2001
From: glegras <71757105+glegras@users.noreply.github.com>
Date: Tue, 24 Feb 2026 19:05:04 +0100
Subject: [PATCH 1362/1764] TRD: updates in vdrift and ExB calibration +
 possibility to use slope in chi2 matching (#14989)

* updates vd exb calib

* TRD: updates in vdrift and ExB calibration + possibility to use slope in chi2 matching

* small fix

* use lorentz angle to define better fit range

* merge with with new error parametrization

* clang format

* simplify error parametrization

* clang format

* calculate average only once

* clang format
---
 .../TRD/include/DataFormatsTRD/CalGain.h      | 44 ++++++++-
 .../TRD/include/DataFormatsTRD/CalVdriftExB.h | 94 ++++++++++++++++++-
 .../TRD/include/DataFormatsTRD/Constants.h    |  4 +
 .../TRD/base/src/TrackletTransformer.cxx      |  3 +-
 Detectors/TRD/calibration/README.md           |  6 +-
 .../TRDCalibration/CalibrationParams.h        |  7 +-
 .../include/TRDCalibration/CalibratorVdExB.h  |  4 +-
 .../TRD/calibration/macros/manualCalibFit.C   | 67 +++++++++++--
 .../TRD/calibration/src/CalibratorVdExB.cxx   | 48 ++++++++--
 .../TRD/calibration/src/TrackBasedCalib.cxx   | 20 +++-
 .../include/TRDWorkflow/VdAndExBCalibSpec.h   |  2 +-
 GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx | 53 +++--------
 GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h   | 20 ++--
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 .../TRDTracking/GPUTRDInterfaces.h            |  1 +
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx | 87 ++++++++++++++++-
 GPU/GPUTracking/TRDTracking/GPUTRDTracker.h   |  6 +-
 17 files changed, 376 insertions(+), 91 deletions(-)

diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalGain.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalGain.h
index f90101e7a4f21..b4e64db094a5c 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalGain.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalGain.h
@@ -33,12 +33,52 @@ class CalGain
 
   void setMPVdEdx(int iDet, float mpv) { mMPVdEdx[iDet] = mpv; }
 
-  float getMPVdEdx(int iDet) const { return mMPVdEdx[iDet]; }
+  float getMPVdEdx(int iDet, bool defaultAvg = true) const
+  {
+    // if defaultAvg = false, we take the value stored whatever it is
+    // if defaultAvg = true and we have default value or bad value stored, we take the average on all chambers instead
+    if (!defaultAvg || isGoodGain(iDet))
+      return mMPVdEdx[iDet];
+    else {
+      if (TMath::Abs(mMeanGain + 999.) < 1e-6)
+        mMeanGain = getAverageGain();
+      return mMeanGain;
+    }
+  }
+
+  float getAverageGain() const
+  {
+    float averageGain = 0.;
+    int ngood = 0;
+
+    for (int iDet = 0; iDet < constants::MAXCHAMBER; iDet++) {
+      if (isGoodGain(iDet)) {
+        // The chamber has correct calibration
+        ngood++;
+        averageGain += mMPVdEdx[iDet];
+      }
+    }
+    if (ngood == 0) {
+      // we should make sure it never happens
+      return constants::MPVDEDXDEFAULT;
+    }
+    averageGain /= ngood;
+    return averageGain;
+  }
+
+  bool isGoodGain(int iDet) const
+  {
+    if (TMath::Abs(mMPVdEdx[iDet] - constants::MPVDEDXDEFAULT) > 1e-6)
+      return true;
+    else
+      return false;
+  }
 
  private:
   std::array<float, constants::MAXCHAMBER> mMPVdEdx{}; ///< Most probable value of dEdx distribution per TRD chamber
+  mutable float mMeanGain{-999.};                      ///! average gain, calculated only once
 
-  ClassDefNV(CalGain, 1);
+  ClassDefNV(CalGain, 2);
 };
 
 } // namespace trd
diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalVdriftExB.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalVdriftExB.h
index bad9dcfef4e37..65981e928fb39 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalVdriftExB.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalVdriftExB.h
@@ -34,14 +34,102 @@ class CalVdriftExB
   void setVdrift(int iDet, float vd) { mVdrift[iDet] = vd; }
   void setExB(int iDet, float exb) { mExB[iDet] = exb; }
 
-  float getVdrift(int iDet) const { return mVdrift[iDet]; }
-  float getExB(int iDet) const { return mExB[iDet]; }
+  float getVdrift(int iDet, bool defaultAvg = true) const
+  {
+    // if defaultAvg = false, we take the value stored whatever it is
+    // if defaultAvg = true and we have default value or bad value stored, we take the average on all chambers instead
+    if (!defaultAvg || (isGoodExB(iDet) && isGoodVdrift(iDet)))
+      return mVdrift[iDet];
+    else {
+      if (TMath::Abs(mMeanVdrift + 999.) < 1e-6)
+        mMeanVdrift = getAverageVdrift();
+      return mMeanVdrift;
+    }
+  }
+  float getExB(int iDet, bool defaultAvg = true) const
+  {
+    if (!defaultAvg || (isGoodExB(iDet) && isGoodVdrift(iDet)))
+      return mExB[iDet];
+    else {
+      if (TMath::Abs(mMeanExB + 999.) < 1e-6)
+        mMeanExB = getAverageExB();
+      return mMeanExB;
+    }
+  }
+
+  float getAverageVdrift() const
+  {
+    float averageVdrift = 0.;
+    int ngood = 0;
+
+    for (int iDet = 0; iDet < constants::MAXCHAMBER; iDet++) {
+      if (isGoodExB(iDet) && isGoodVdrift(iDet)) {
+        // Both values need to be correct to declare a chamber as well calibrated
+        ngood++;
+        averageVdrift += mVdrift[iDet];
+      }
+    }
+    if (ngood == 0) {
+      // we should make sure it never happens
+      return constants::VDRIFTDEFAULT;
+    }
+    averageVdrift /= ngood;
+    return averageVdrift;
+  }
+
+  float getAverageExB() const
+  {
+    float averageExB = 0.;
+    int ngood = 0;
+
+    for (int iDet = 0; iDet < constants::MAXCHAMBER; iDet++) {
+      if (isGoodExB(iDet) && isGoodVdrift(iDet)) {
+        // Both values need to be correct to declare a chamber as well calibrated
+        ngood++;
+        averageExB += mExB[iDet];
+      }
+    }
+    if (ngood == 0) {
+      // we should make sure it never happens
+      return constants::EXBDEFAULT;
+    }
+    averageExB /= ngood;
+    return averageExB;
+  }
+
+  bool isGoodExB(int iDet) const
+  {
+    // check if value is well calibrated or not
+    // default calibration if not enough entries
+    // close to boundaries indicate a failed fit
+    if (TMath::Abs(mExB[iDet] - constants::EXBDEFAULT) > 1e-6 &&
+        TMath::Abs(mExB[iDet] - constants::EXBMIN) > 0.01 &&
+        TMath::Abs(mExB[iDet] - constants::EXBMAX) > 0.01)
+      return true;
+    else
+      return false;
+  }
+
+  bool isGoodVdrift(int iDet) const
+  {
+    // check if value is well calibrated or not
+    // default calibration if not enough entries
+    // close to boundaries indicate a failed fit
+    if (TMath::Abs(mVdrift[iDet] - constants::VDRIFTDEFAULT) > 1e-6 &&
+        TMath::Abs(mVdrift[iDet] - constants::VDRIFTMIN) > 0.1 &&
+        TMath::Abs(mVdrift[iDet] - constants::VDRIFTMAX) > 0.1)
+      return true;
+    else
+      return false;
+  }
 
  private:
   std::array<float, constants::MAXCHAMBER> mVdrift{}; ///< calibrated drift velocity per TRD chamber
   std::array<float, constants::MAXCHAMBER> mExB{};    ///< calibrated Lorentz angle per TRD chamber
+  mutable float mMeanVdrift{-999.};                   ///! average drift velocity, calculated only once
+  mutable float mMeanExB{-999.};                      ///! average lorentz angle, calculated only once
 
-  ClassDefNV(CalVdriftExB, 1);
+  ClassDefNV(CalVdriftExB, 2);
 };
 
 } // namespace trd
diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/Constants.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/Constants.h
index 7a650cf3699cf..9a4da1024e251 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/Constants.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/Constants.h
@@ -75,7 +75,11 @@ constexpr int TIMEBINS = 30;            ///< the number of time bins
 constexpr float MAXIMPACTANGLE = 25.f;  ///< the maximum impact angle for tracks relative to the TRD detector plane to be considered for vDrift and ExB calibration
 constexpr int NBINSANGLEDIFF = 25;      ///< the number of bins for the track angle used for the vDrift and ExB calibration based on the tracking
 constexpr double VDRIFTDEFAULT = 1.546; ///< default value for vDrift
+constexpr double VDRIFTMIN = 0.4;       ///< min value for vDrift
+constexpr double VDRIFTMAX = 2.0;       ///< max value for vDrift
 constexpr double EXBDEFAULT = 0.0;      ///< default value for LorentzAngle
+constexpr double EXBMIN = -0.4;         ///< min value for LorentzAngle
+constexpr double EXBMAX = 0.4;          ///< max value for LorentzAngle
 constexpr int NBINSGAINCALIB = 320;     ///< number of bins in the charge (Q0+Q1+Q2) histogram for gain calibration
 constexpr float MPVDEDXDEFAULT = 42.;   ///< default Most Probable Value of TRD dEdx
 constexpr float T0DEFAULT = 1.2;        ///< default value for t0
diff --git a/Detectors/TRD/base/src/TrackletTransformer.cxx b/Detectors/TRD/base/src/TrackletTransformer.cxx
index 58938cfd99161..7f9976b8ce714 100644
--- a/Detectors/TRD/base/src/TrackletTransformer.cxx
+++ b/Detectors/TRD/base/src/TrackletTransformer.cxx
@@ -50,7 +50,8 @@ float TrackletTransformer::calculateDy(int detector, int slope, const PadPlane*
   // NOTE: check what drift height is used in calibration code to ensure consistency
   // NOTE: check sign convention of Lorentz angle
   // NOTE: confirm the direction in which vDrift is measured/determined. Is it in x or in direction of drift?
-  double lorentzCorrection = TMath::Tan(exb) * mXAnode;
+  // The Lorentz correction have to be applied both at the point of entrance and at the end of the drift region
+  double lorentzCorrection = TMath::Tan(exb) * mGeo->cdrHght();
 
   // assuming angle in Bailhache, fig. 4.17 would be positive in our calibration code
   double calibratedDy = rawDy - lorentzCorrection;
diff --git a/Detectors/TRD/calibration/README.md b/Detectors/TRD/calibration/README.md
index bdbfc9e709800..f769fa99b5778 100644
--- a/Detectors/TRD/calibration/README.md
+++ b/Detectors/TRD/calibration/README.md
@@ -27,15 +27,15 @@ For 'o2-calibration-trd-workflow --vDriftAndExB' there are also the following ke
 
 *Hint: You can get information on the meaning of the parameters by running `o2-calibration-trd-workflow --vDriftAndExB -b --help full`*
 
-If you want to run the calibration from a local file with residuals, trdangreshistos.root, you can run:
+If you want to run the calibration from a local file with residuals, trdcaliboutput.root, you can run:
 
-    o2-calibration-trd-workflow --vDriftAndExB -b --enable-root-input --calib-vdexb-calibration '--tf-per-slot 1' --configKeyValues "TRDCalibParams.minEntriesChamber=100;TRDCalibParams.minEntriesTotal=50000"
+    o2-calibration-trd-workflow --vDriftAndExB -b --enable-root-input --calib-vdexb-calibration '--tf-per-slot 1' --configKeyValues "TRDCalibParams.minEntriesChamber=100;TRDCalibParams.minEntriesTotal=50000" --trd-calib-infile trdcaliboutput.root
 
 Additionally it is possible to perform the calibrations fit manually per chamber if you have TPC-TRD or ITS-TPC-TRD tracks, you can run:
 
     o2-trd-global-tracking -b --enable-trackbased-calib
 
-This produces `trdangreshistos.root` which holds the residuals of the angles and differences.
+This produces `trdcaliboutput.root` which holds the residuals of the angles and differences.
 Then run the macro `Detectors/TRD/calibration/macros/manualCalibFit.C`.
 This produces a file of similar name with the fitted data and prints out the fit results.
 This is equivalent to running:
diff --git a/Detectors/TRD/calibration/include/TRDCalibration/CalibrationParams.h b/Detectors/TRD/calibration/include/TRDCalibration/CalibrationParams.h
index 677673a7f85f3..cadd21af2a55d 100644
--- a/Detectors/TRD/calibration/include/TRDCalibration/CalibrationParams.h
+++ b/Detectors/TRD/calibration/include/TRDCalibration/CalibrationParams.h
@@ -25,12 +25,13 @@ namespace trd
 /// VDrift and ExB calibration parameters.
 struct TRDCalibParams : public o2::conf::ConfigurableParamHelper<TRDCalibParams> {
   unsigned int nTrackletsMin = 5;  ///< minimum amount of tracklets
+  unsigned int nTrackletsMinLoose = 4; ///< minimum amount of tracklets if two layers with a large lever arm both have a hit
   unsigned int chi2RedMax = 6;     ///< maximum reduced chi2 acceptable for track quality
-  size_t minEntriesChamber = 75;   ///< minimum number of entries per chamber to fit single time slot
-  size_t minEntriesTotal = 40'500; ///< minimum total required for meaningful fits
+  size_t minEntriesChamber = 200;  ///< minimum number of entries per chamber to fit single time slot
+  size_t minEntriesTotal = 400'000; ///< minimum total required for meaningful fits
 
   // For gain calibration
-  unsigned int nTrackletsMinGainCalib = 5;
+  unsigned int nTrackletsMinGainCalib = 3;
   size_t minEntriesChamberGainCalib = 500;     ///< minimum number of entries per chamber to fit single time slot
   size_t minEntriesTotalGainCalib = 1'000'000; ///< minimum total required for meaningful fits
   // Cuts for selecting clean pion candidates for gain calibration
diff --git a/Detectors/TRD/calibration/include/TRDCalibration/CalibratorVdExB.h b/Detectors/TRD/calibration/include/TRDCalibration/CalibratorVdExB.h
index 7d55850af9fd4..16223f3e78112 100644
--- a/Detectors/TRD/calibration/include/TRDCalibration/CalibratorVdExB.h
+++ b/Detectors/TRD/calibration/include/TRDCalibration/CalibratorVdExB.h
@@ -88,8 +88,8 @@ class CalibratorVdExB final : public o2::calibration::TimeSlotCalibration<o2::tr
  private:
   bool mInitDone{false};                                     ///< flag to avoid creating the TProfiles multiple times
   const TRDCalibParams& mParams{TRDCalibParams::Instance()}; ///< reference to calibration parameters
-  size_t mMinEntriesTotal{mParams.minEntriesChamber};        ///< minimum total number of angular deviations (on average ~3 entries per bin for each TRD chamber)
-  size_t mMinEntriesChamber{mParams.minEntriesTotal};        ///< minimum number of angular deviations per chamber for accepting refitted value (~3 per bin)
+  size_t mMinEntriesTotal{mParams.minEntriesTotal};          ///< minimum total number of angular deviations (on average ~3 entries per bin for each TRD chamber)
+  size_t mMinEntriesChamber{mParams.minEntriesChamber};      ///< minimum number of angular deviations per chamber for accepting refitted value (~3 per bin)
   bool mEnableOutput{false};                                 ///< enable output of calibration fits and tprofiles in a root file instead of the ccdb
   std::unique_ptr<TFile> mOutFile{nullptr};                  ///< output file
   std::unique_ptr<TTree> mOutTree{nullptr};                  ///< output tree
diff --git a/Detectors/TRD/calibration/macros/manualCalibFit.C b/Detectors/TRD/calibration/macros/manualCalibFit.C
index d31744a2e727c..877202d4e211e 100644
--- a/Detectors/TRD/calibration/macros/manualCalibFit.C
+++ b/Detectors/TRD/calibration/macros/manualCalibFit.C
@@ -30,18 +30,19 @@
 
 // O2 header
 #include <TRDCalibration/CalibratorVdExB.h>
+#include "DetectorsBase/Propagator.h"
 
 #endif
 
 // This root macro reads in 'trdangreshistos.root' and
 // performs the calibration fits manually as in CalibratorVdExB.cxx
 // This can be used for checking if the calibration fits make sense.
-void manualCalibFit()
+void manualCalibFit(int runNumber = 563335, bool usePreCorrFromCCDB = false)
 {
   //----------------------------------------------------
   // TTree and File
   //----------------------------------------------------
-  std::unique_ptr<TFile> inFilePtr(TFile::Open("trdangreshistos.root"));
+  std::unique_ptr<TFile> inFilePtr(TFile::Open("trdcaliboutput.root"));
   if (inFilePtr == nullptr) {
     printf("Input File could not be read!\n'");
     return;
@@ -60,18 +61,46 @@ void manualCalibFit()
   tree->SetBranchAddress("mHistogramEntries[13500]", &mHistogramEntries);
   tree->SetBranchAddress("mNEntriesPerBin[13500]", &mNEntriesPerBin);
 
+  // use precorr values from ccdb
+  // necessary when the angular residuals were calculated already using ccdb calibration (e.g. in a local run)
+
+  o2::trd::CalVdriftExB* calObject;
+  if (usePreCorrFromCCDB) {
+    auto& ccdbmgr = o2::ccdb::BasicCCDBManager::instance();
+
+    o2::ccdb::CcdbApi ccdb;
+    ccdb.init("http://alice-ccdb.cern.ch");
+    auto runDuration = ccdbmgr.getRunDuration(runNumber);
+
+    std::map<std::string, std::string> metadata;
+    std::map<std::string, std::string> headers;
+
+    calObject = ccdb.retrieveFromTFileAny<o2::trd::CalVdriftExB>("TRD/Calib/CalVdriftExB", metadata, runDuration.first + 60000, &headers, "", "", "1689478811721");
+  }
+
   //----------------------------------------------------
   // Configure Fitter
   //----------------------------------------------------
   o2::trd::FitFunctor mFitFunctor;
   std::array<std::unique_ptr<TProfile>, 540> profiles; ///< profile histograms for each TRD chamber
+  int counter = 0;
   for (int iDet = 0; iDet < 540; ++iDet) {
     mFitFunctor.profiles[iDet] = std::make_unique<TProfile>(Form("profAngleDiff_%i", iDet), Form("profAngleDiff_%i", iDet), 25, -25.f, 25.f);
+    if (usePreCorrFromCCDB) {
+      if (calObject->isGoodExB(iDet))
+        counter++;
+      mFitFunctor.vdPreCorr[iDet] = calObject->getVdrift(iDet, true);
+      mFitFunctor.laPreCorr[iDet] = calObject->getExB(iDet, true);
+    }
   }
+  std::cout << counter << " good entries in the CCDB " << std::endl;
+  mFitFunctor.mAnodePlane = 3.35; // don't really care as long as it's not zero, this parameter could  be removed
   mFitFunctor.lowerBoundAngleFit = 80 * TMath::DegToRad();
   mFitFunctor.upperBoundAngleFit = 100 * TMath::DegToRad();
-  mFitFunctor.vdPreCorr.fill(1.546);
-  mFitFunctor.laPreCorr.fill(0.0);
+  if (!usePreCorrFromCCDB) {
+    mFitFunctor.vdPreCorr.fill(1.546);
+    mFitFunctor.laPreCorr.fill(0.0);
+  }
 
   //----------------------------------------------------
   // Loop
@@ -88,15 +117,18 @@ void manualCalibFit()
   //----------------------------------------------------
   // Fill profiles
   //----------------------------------------------------
+  int nEntriesDetTotal[540] = {};
   for (int iDet = 0; iDet < 540; ++iDet) {
     for (int iBin = 0; iBin < 25; ++iBin) {
       auto angleDiffSum = mHistogramEntriesSum[iDet * 25 + iBin];
       auto nEntries = mNEntriesPerBinSum[iDet * 25 + iBin];
+      nEntriesDetTotal[iDet] += nEntries;
       if (nEntries > 0) { // skip entries which have no entries; ?
         // add to the respective profile for fitting later on
         mFitFunctor.profiles[iDet]->Fill(2 * iBin - 25.f, angleDiffSum / nEntries, nEntries);
       }
     }
+    printf("Det %d: nEntries=%d \n", iDet, nEntriesDetTotal[iDet]);
   }
 
   //----------------------------------------------------
@@ -105,16 +137,23 @@ void manualCalibFit()
   printf("-------- Started fits\n");
   std::array<float, 540> laFitResults{};
   std::array<float, 540> vdFitResults{};
+
+  TH1F* hVd = new TH1F("hVd", "v drift", 150, 0.5, 2.);
+  TH1F* hLa = new TH1F("hLa", "lorentz angle", 200, -25., 25.);
+  o2::trd::CalVdriftExB* calObjectOut = new o2::trd::CalVdriftExB();
+
   for (int iDet = 0; iDet < 540; ++iDet) {
+    if (nEntriesDetTotal[iDet] < 75)
+      continue;
     mFitFunctor.currDet = iDet;
     ROOT::Fit::Fitter fitter;
     double paramsStart[2];
-    paramsStart[0] = 0. * TMath::DegToRad();
+    paramsStart[0] = 0.;
     paramsStart[1] = 1.;
     fitter.SetFCN<o2::trd::FitFunctor>(2, mFitFunctor, paramsStart);
     fitter.Config().ParSettings(0).SetLimits(-0.7, 0.7);
     fitter.Config().ParSettings(0).SetStepSize(.01);
-    fitter.Config().ParSettings(1).SetLimits(0., 3.);
+    fitter.Config().ParSettings(1).SetLimits(0.01, 3.);
     fitter.Config().ParSettings(1).SetStepSize(.01);
     ROOT::Math::MinimizerOptions opt;
     opt.SetMinimizerType("Minuit2");
@@ -127,14 +166,28 @@ void manualCalibFit()
     auto fitResult = fitter.Result();
     laFitResults[iDet] = fitResult.Parameter(0);
     vdFitResults[iDet] = fitResult.Parameter(1);
-    printf("Det %d: la=%f\tvd=%f\n", iDet, laFitResults[iDet] * TMath::RadToDeg(), vdFitResults[iDet]);
+    if (fitResult.MinFcnValue() > 0.03)
+      continue;
+    printf("Det %d: la=%.3f \tvd=%.3f \t100*minValue=%f \tentries=%d\n", iDet, laFitResults[iDet] * TMath::RadToDeg(), vdFitResults[iDet], 100 * fitResult.MinFcnValue(), nEntriesDetTotal[iDet]);
+    hVd->Fill(vdFitResults[iDet]);
+    hLa->Fill(laFitResults[iDet] * TMath::RadToDeg());
+    calObjectOut->setVdrift(iDet, vdFitResults[iDet]);
+    calObjectOut->setExB(iDet, laFitResults[iDet]);
   }
   printf("-------- Finished fits\n");
 
+  std::cout << "number of chambers with enough entries: " << hVd->GetEntries() << std::endl;
+  ;
+  std::cout << "vdrift mean: " << hVd->GetMean() << " sigma: " << hVd->GetStdDev() << std::endl;
+  std::cout << "lorentz angle mean: " << hLa->GetMean() << " sigma: " << hLa->GetStdDev() << std::endl;
+
   //----------------------------------------------------
   // Write
   //----------------------------------------------------
   std::unique_ptr<TFile> outFilePtr(TFile::Open("manualCalibFit.root", "RECREATE"));
+  hVd->Write();
+  hLa->Write();
+  outFilePtr->WriteObjectAny(calObjectOut, "o2::trd::CalVdriftExB", "calObject");
   for (auto& p : mFitFunctor.profiles)
     p->Write();
 }
diff --git a/Detectors/TRD/calibration/src/CalibratorVdExB.cxx b/Detectors/TRD/calibration/src/CalibratorVdExB.cxx
index 64a8664640e41..fef7bdecef38c 100644
--- a/Detectors/TRD/calibration/src/CalibratorVdExB.cxx
+++ b/Detectors/TRD/calibration/src/CalibratorVdExB.cxx
@@ -24,6 +24,7 @@
 #include "CCDB/BasicCCDBManager.h"
 #include "CommonUtils/NameConf.h"
 #include "CommonUtils/MemFileHelper.h"
+#include "DetectorsBase/Propagator.h"
 #include <TFile.h>
 #include <TTree.h>
 
@@ -105,17 +106,37 @@ void CalibratorVdExB::initProcessing()
     return;
   }
 
-  mFitFunctor.lowerBoundAngleFit = 80 * TMath::DegToRad();
-  mFitFunctor.upperBoundAngleFit = 100 * TMath::DegToRad();
+  // fit is done in region where ion tails are small, close to lorentz angle
+  // we want an approximate value of the lorentz angle in order to define better fit boundaries, coinciding with profile bin edges
+  float bz = o2::base::Propagator::Instance()->getNominalBz();
+  // default angle with zero field is slightly shifted
+  float lorentzAngleAvg = -1.f;
+  if (TMath::Abs(bz - 2) < 0.1f) {
+    lorentzAngleAvg = 3.f;
+  }
+  if (TMath::Abs(bz + 2) < 0.1f) {
+    lorentzAngleAvg = -5.f;
+  }
+  if (TMath::Abs(bz - 5) < 0.1f) {
+    lorentzAngleAvg = 7.f;
+  }
+  if (TMath::Abs(bz + 5) < 0.1f) {
+    lorentzAngleAvg = -9.f;
+  }
+
+  LOGP(info, "b field: {}  lorentz angle start: {}", bz, lorentzAngleAvg);
+
+  mFitFunctor.lowerBoundAngleFit = (80 + lorentzAngleAvg) * TMath::DegToRad();
+  mFitFunctor.upperBoundAngleFit = (100 + lorentzAngleAvg) * TMath::DegToRad();
   mFitFunctor.mAnodePlane = GeometryBase::camHght() / (2.f * 100.f);
   for (int iDet = 0; iDet < MAXCHAMBER; ++iDet) {
     mFitFunctor.profiles[iDet] = std::make_unique<TProfile>(Form("profAngleDiff_%i", iDet), Form("profAngleDiff_%i", iDet), NBINSANGLEDIFF, -MAXIMPACTANGLE, MAXIMPACTANGLE);
   }
 
   mFitter.SetFCN<FitFunctor>(2, mFitFunctor, mParamsStart);
-  mFitter.Config().ParSettings(ParamIndex::LA).SetLimits(-0.7, 0.7);
+  mFitter.Config().ParSettings(ParamIndex::LA).SetLimits(constants::EXBMIN, constants::EXBMAX);
   mFitter.Config().ParSettings(ParamIndex::LA).SetStepSize(.01);
-  mFitter.Config().ParSettings(ParamIndex::VD).SetLimits(0.01, 3.);
+  mFitter.Config().ParSettings(ParamIndex::VD).SetLimits(constants::VDRIFTMIN, constants::VDRIFTMAX);
   mFitter.Config().ParSettings(ParamIndex::VD).SetStepSize(.01);
   ROOT::Math::MinimizerOptions opt;
   opt.SetMinimizerType("Minuit2");
@@ -184,17 +205,30 @@ void CalibratorVdExB::finalizeSlot(Slot& slot)
     }
     // Check if we have the minimum amount of entries
     if (sumEntries < mMinEntriesChamber) {
-      LOGF(debug, "Chamber %d did not reach minimum amount of entries for refit", iDet);
+      LOGF(debug, "Chamber %d did not reach minimum amount of entries for refit: %d", iDet, sumEntries);
       continue;
     }
+    float laPreCorrTemp = mFitFunctor.laPreCorr[iDet];
+    float vdPreCorrTemp = mFitFunctor.vdPreCorr[iDet];
+    // Here we start from uncalibrated values, otherwise online calibration does not work properly
+    mFitFunctor.laPreCorr[iDet] = EXBDEFAULT;
+    mFitFunctor.vdPreCorr[iDet] = VDRIFTDEFAULT;
+
     // Reset Start Parameter
     mParamsStart[ParamIndex::LA] = 0.0;
     mParamsStart[ParamIndex::VD] = 1.0;
     mFitter.FitFCN();
     auto fitResult = mFitter.Result();
+    if (fitResult.MinFcnValue() > 0.03) {
+      LOGF(debug, "Chamber %d fit did not converge properly, minimization value too high: %f", iDet, fitResult.MinFcnValue());
+      // The fit did not work properly, so we keep previous values
+      mFitFunctor.laPreCorr[iDet] = laPreCorrTemp;
+      mFitFunctor.vdPreCorr[iDet] = vdPreCorrTemp;
+      continue;
+    }
     laFitResults[iDet] = fitResult.Parameter(ParamIndex::LA);
     vdFitResults[iDet] = fitResult.Parameter(ParamIndex::VD);
-    LOGF(debug, "Fit result for chamber %i: vd=%f, la=%f", iDet, vdFitResults[iDet], laFitResults[iDet] * TMath::RadToDeg());
+    LOGF(debug, "Fit result for chamber %i: vd=%f, la=%f, minimizer value=%f", iDet, vdFitResults[iDet], laFitResults[iDet] * TMath::RadToDeg(), fitResult.MinFcnValue());
     // Update fit values for next fit
     mFitFunctor.laPreCorr[iDet] = laFitResults[iDet];
     mFitFunctor.vdPreCorr[iDet] = vdFitResults[iDet];
@@ -222,7 +256,7 @@ void CalibratorVdExB::finalizeSlot(Slot& slot)
   auto flName = o2::ccdb::CcdbApi::generateFileName(clName);
   std::map<std::string, std::string> metadata; // TODO: do we want to store any meta data?
   long startValidity = slot.getStartTimeMS() - 10 * o2::ccdb::CcdbObjectInfo::SECOND;
-  mInfoVector.emplace_back("TRD/Calib/CalVdriftExB", clName, flName, metadata, startValidity, startValidity + o2::ccdb::CcdbObjectInfo::HOUR);
+  mInfoVector.emplace_back("TRD/Calib/CalVdriftExB", clName, flName, metadata, startValidity, startValidity + 1 * o2::ccdb::CcdbObjectInfo::HOUR);
   mObjectVector.push_back(calObject);
 }
 
diff --git a/Detectors/TRD/calibration/src/TrackBasedCalib.cxx b/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
index 8fe195f861389..ae1f7b33c6bba 100644
--- a/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
+++ b/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
@@ -190,7 +190,10 @@ int TrackBasedCalib::doTrdOnlyTrackFits(gsl::span<const TrackTRD>& tracks)
   for (const auto& trkIn : tracks) {
     if (trkIn.getNtracklets() < params.nTrackletsMin) {
       // with less than 3 tracklets the TRD-only refit not meaningful
-      continue;
+      if (trkIn.getNtracklets() < params.nTrackletsMinLoose || !((trkIn.getTrackletIndex(0) >= 0 && (trkIn.getTrackletIndex(NLAYER - 1) >= 0 || trkIn.getTrackletIndex(NLAYER - 2) >= 0))) || (trkIn.getTrackletIndex(1) >= 0 && trkIn.getTrackletIndex(NLAYER - 1) >= 0)) {
+        // we check if we have enough lever arm, i.e. (first and last) or (second and last) or (first and before last) are present
+        continue;
+      }
     }
     auto trkWork = trkIn; // input is const, so we need to create a copy
     bool trackFailed = false;
@@ -262,9 +265,20 @@ int TrackBasedCalib::doTrdOnlyTrackFits(gsl::span<const TrackTRD>& tracks)
       }
 
       float trkAngle = o2::math_utils::asin(trkWork.getSnp()) * TMath::RadToDeg();
-      float trkltAngle = o2::math_utils::atan(mTrackletsCalib[trkWork.getTrackletIndex(iLayer)].getDy() / Geometry::cdrHght()) * TMath::RadToDeg();
+      int trkltId = trkWork.getTrackletIndex(iLayer);
+      // tracklet angle, corrected for pad tilt
+      const PadPlane* pad = Geometry::instance()->getPadPlane(mTrackletsRaw[trkltId].getDetector());
+      float tilt = tan(TMath::DegToRad() * pad->getTiltingAngle()); // tilt is signed! and returned in degrees
+      float tiltCorrUp = tilt * trkWork.getTgl() * Geometry::cdrHght();
+      float padLength = pad->getRowSize(mTrackletsRaw[trkltId].getPadRow());
+      if (!((trkWork.getSigmaZ2() < (padLength * padLength / 12.f)) && (std::fabs(mTrackletsCalib[trkltId].getZ() - trkWork.getZ()) < padLength))) {
+        tiltCorrUp = 0.f;
+      }
+      // use uncalibrated dy because online calibration does not work otherwise
+      float trkltDy = mTrackletsRaw[trkltId].getUncalibratedDy(30.f / o2::trd::constants::VDRIFTDEFAULT) + tiltCorrUp;
+      float trkltAngle = o2::math_utils::atan(trkltDy / Geometry::cdrHght()) * TMath::RadToDeg();
       float angleDeviation = trkltAngle - trkAngle;
-      if (mAngResHistos.addEntry(angleDeviation, trkAngle, mTrackletsRaw[trkWork.getTrackletIndex(iLayer)].getDetector())) {
+      if (mAngResHistos.addEntry(angleDeviation, trkAngle, mTrackletsRaw[trkltId].getDetector())) {
         // track impact angle out of histogram range
         continue;
       }
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h
index f45b7a1808287..e4d6a1641ed50 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/VdAndExBCalibSpec.h
@@ -147,7 +147,7 @@ DataProcessorSpec getTRDVdAndExBCalibSpec()
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(true,                           // orbitResetTime
                                                                 true,                           // GRPECS=true
                                                                 false,                          // GRPLHCIF
-                                                                false,                          // GRPMagField
+                                                                true,                           // GRPMagField
                                                                 false,                          // askMatLUT
                                                                 o2::base::GRPGeomRequest::None, // geometry
                                                                 inputs);
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
index 70b445f7befc0..674b7a317b477 100644
--- a/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
@@ -28,64 +28,33 @@ void GPUTRDRecoParam::init(float bz, const GPUSettingsRec* rec)
   if (CAMath::Abs(CAMath::Abs(bz) - 2) < 0.1) {
     if (bz > 0) {
       // magnetic field +0.2 T
-      mRPhiA2 = resRPhiIdeal2;
-      mRPhiB = -1.43e-2f;
       mRPhiC2 = 4.55e-2f;
-
-      mDyA2 = 1.225e-3f;
-      mDyB = -9.8e-3f;
-      mDyC2 = 3.88e-2f;
-
-      mAngleToDyA = -0.1f;
-      mAngleToDyB = 1.89f;
-      mAngleToDyC = -0.4f;
     } else {
       // magnetic field -0.2 T
-      mRPhiA2 = resRPhiIdeal2;
-      mRPhiB = 1.43e-2f;
       mRPhiC2 = 4.55e-2f;
-
-      mDyA2 = 1.225e-3f;
-      mDyB = 9.8e-3f;
-      mDyC2 = 3.88e-2f;
-
-      mAngleToDyA = 0.1f;
-      mAngleToDyB = 1.89f;
-      mAngleToDyC = 0.4f;
     }
   } else if (CAMath::Abs(CAMath::Abs(bz) - 5) < 0.1) {
     if (bz > 0) {
       // magnetic field +0.5 T
-      mRPhiA2 = resRPhiIdeal2;
-      mRPhiB = 0.125f;
       mRPhiC2 = 0.0961f;
-
-      mDyA2 = 1.681e-3f;
-      mDyB = 0.15f;
-      mDyC2 = 0.1849f;
-
-      mAngleToDyA = 0.13f;
-      mAngleToDyB = 2.43f;
-      mAngleToDyC = -0.58f;
     } else {
       // magnetic field -0.5 T
-      mRPhiA2 = resRPhiIdeal2;
-      mRPhiB = -0.14f;
       mRPhiC2 = 0.1156f;
-
-      mDyA2 = 2.209e-3f;
-      mDyB = -0.15f;
-      mDyC2 = 0.2025f;
-
-      mAngleToDyA = -0.15f;
-      mAngleToDyB = 2.34f;
-      mAngleToDyC = 0.56f;
     }
   } else {
     LOGP(warning, "No error parameterization available for Bz= {}. Keeping default value (sigma_y = const. = 1cm)", bz);
   }
-  LOGP(info, "Loaded parameterizations for Bz={}: PhiRes:[{},{},{}] DyRes:[{},{},{}] Angle2Dy:[{},{},{}]",
-       bz, mRPhiA2, mRPhiB, mRPhiC2, mDyA2, mDyB, mDyC2, mAngleToDyA, mAngleToDyB, mAngleToDyC);
+
+  mRPhiA2 = resRPhiIdeal2;
+  mLorentzAngle = -0.02f + 0.13f * bz / 5.f;
+
+  mDyA2 = 6e-3f;
+  mDyC2 = 0.3f;
+  mCorrYDyA = 0.27f;
+  mCorrYDyC = -0.44f;
+
+  LOGP(info, "Loaded parameterizations for Bz={}: PhiRes:[{},{},{}] DyRes:[{},{},{}] CorrYDy:[{},{},{}]",
+       bz, mRPhiA2, mLorentzAngle, mRPhiC2, mDyA2, mLorentzAngle, mDyC2, mCorrYDyA, mLorentzAngle, mCorrYDyC);
 }
 
 void GPUTRDRecoParam::recalcTrkltCov(const float tilt, const float snp, const float rowSize, float* cov) const
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h
index ad0285487d3c3..a0a8e71143d94 100644
--- a/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h
+++ b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.h
@@ -19,6 +19,7 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonRtypes.h"
 #include "GPUCommonArray.h"
+#include "GPUCommonMath.h"
 
 namespace o2
 {
@@ -51,31 +52,30 @@ class GPUTRDRecoParam
   /// more details are given in http://cds.cern.ch/record/2724259 in section 5.3.3
   /// \param phi angle of related track
   /// \return sigma_y^2 of tracklet
-  GPUd() float getRPhiRes(float snp) const { return (mRPhiA2 + mRPhiC2 * (snp - mRPhiB) * (snp - mRPhiB)); }
-  GPUd() float getDyRes(float snp) const { return mDyA2 + mDyC2 * (snp - mDyB) * (snp - mDyB); }                       // // a^2 + c^2 * (snp - b)^2
-  GPUd() float convertAngleToDy(float snp) const { return mAngleToDyA + mAngleToDyB * snp + mAngleToDyC * snp * snp; } // a + b*snp + c*snp^2 is more accurate than sin(phi) = (dy / xDrift) / sqrt(1+(dy/xDrift)^2)
+  GPUd() float getRPhiRes(float snp) const { return (mRPhiA2 + mRPhiC2 * (snp - mLorentzAngle) * (snp - mLorentzAngle)); }
+  GPUd() float getDyRes(float snp) const { return mDyA2 + mDyC2 * (snp - mLorentzAngle) * (snp - mLorentzAngle); }           // a^2 + c^2 * (snp - b)^2
+  GPUd() float convertAngleToDy(float snp) const { return 3.f * snp / CAMath::Sqrt(1 - snp * snp); }                         // when calibrated, sin(phi) = (dy / xDrift) / sqrt(1+(dy/xDrift)^2) works well
+  GPUd() float getCorrYDy(float snp) const { return mCorrYDyA + mCorrYDyC * (snp - mLorentzAngle) * (snp - mLorentzAngle); } // a + c * (snp - b)^2
 
   /// Get tracklet z correction coefficient for track-eta based corraction
   GPUd() float getZCorrCoeffNRC() const { return mZCorrCoefNRC; }
 
  private:
   // tracklet error parameterization depends on the magnetic field
+  float mLorentzAngle{0.f};
   // rphi
   float mRPhiA2{1.f}; ///< parameterization for tracklet position resolution
-  float mRPhiB{0.f};  ///< parameterization for tracklet position resolution
   float mRPhiC2{0.f}; ///< parameterization for tracklet position resolution
   // angle
   float mDyA2{1.225e-3f}; ///< parameterization for tracklet angular resolution
-  float mDyB{0.f};        ///< parameterization for tracklet angular resolution
   float mDyC2{0.f};       ///< parameterization for tracklet angular resolution
-  // angle to Dy
-  float mAngleToDyA; // parameterization for conversion track angle -> tracklet deflection
-  float mAngleToDyB; // parameterization for conversion track angle -> tracklet deflection
-  float mAngleToDyC; // parameterization for conversion track angle -> tracklet deflection
+  // correlation coefficient between y residual and dy residual
+  float mCorrYDyA{0.f};
+  float mCorrYDyC{0.f};
 
   float mZCorrCoefNRC{1.4f}; ///< tracklet z-position depends linearly on track dip angle
 
-  ClassDefNV(GPUTRDRecoParam, 2);
+  ClassDefNV(GPUTRDRecoParam, 3);
 };
 
 } // namespace gpu
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index ea15ecde78c21..cf6b913551ab5 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -184,6 +184,7 @@ AddOptionRTC(extraRoadZ, float, 10.f, "", 0, "Addition to search road around tra
 AddOptionRTC(trkltResRPhiIdeal, float, 1.f, "", 0, "Optimal tracklet rphi resolution in cm (in case phi of track = lorentz angle)")
 AddOptionRTC(maxChi2Red, float, 99.f, "", 0, "maximum chi2 per attached tracklet for TRD tracks TODO: currently effectively disabled, requires tuning")
 AddOptionRTC(applyDeflectionCut, uint8_t, 0, "", 0, "Set to 1 to enable tracklet selection based on deflection")
+AddOptionRTC(addDeflectionInChi2, uint8_t, 0, "", 0, "Set to 1 to add the deflection in the chi2 calculation for matching")
 AddOptionRTC(stopTrkAfterNMissLy, uint8_t, 6, "", 0, "Abandon track following after N layers without a TRD match")
 AddOptionRTC(nTrackletsMin, uint8_t, 3, "", 0, "Tracks with less attached tracklets are discarded after the tracking")
 AddOptionRTC(matCorrType, uint8_t, 2, "", 0, "Material correction to use: 0 - none, 1 - TGeo, 2 - matLUT")
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
index d45959f99b056..a7b0166122c1b 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
@@ -151,6 +151,7 @@ class trackInterface<GPUTPCGMTrackParam> : public GPUTPCGMTrackParam
   GPUd() float getPt() const { return CAMath::Abs(getQ2Pt()) > 0 ? CAMath::Abs(1.f / getQ2Pt()) : 99999.f; }
   GPUd() float getSigmaY2() const { return GetErr2Y(); }
   GPUd() float getSigmaZ2() const { return GetErr2Z(); }
+  GPUd() float getSigmaZY() const { return GetCov(1); }
 
   GPUd() const float* getPar() const { return GetPar(); }
   GPUd() const float* getCov() const { return GetCov(); }
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
index d5d400e30df53..80098ff151ebe 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.cxx
@@ -93,7 +93,7 @@ void* GPUTRDTracker_t<TRDTRK, PROP>::SetPointersTracks(void* base)
 }
 
 template <class TRDTRK, class PROP>
-GPUTRDTracker_t<TRDTRK, PROP>::GPUTRDTracker_t() : mR(nullptr), mIsInitialized(false), mGenerateSpacePoints(false), mProcessPerTimeFrame(false), mNAngleHistogramBins(25), mAngleHistogramRange(50), mMemoryPermanent(-1), mMemoryTracklets(-1), mMemoryTracks(-1), mNMaxCollisions(0), mNMaxTracks(0), mNMaxSpacePoints(0), mTracks(nullptr), mTrackAttribs(nullptr), mNCandidates(1), mNTracks(0), mNEvents(0), mMaxBackendThreads(100), mTrackletIndexArray(nullptr), mHypothesis(nullptr), mCandidates(nullptr), mSpacePoints(nullptr), mGeo(nullptr), mRecoParam(nullptr), mDebugOutput(false), mMaxEta(0.84f), mRoadZ(18.f), mZCorrCoefNRC(1.4f), mTPCVdrift(2.58f), mTPCTDriftOffset(0.f), mDebug(new GPUTRDTrackerDebug<TRDTRK>())
+GPUTRDTracker_t<TRDTRK, PROP>::GPUTRDTracker_t() : mR(nullptr), mIsInitialized(false), mGenerateSpacePoints(false), mProcessPerTimeFrame(false), mNAngleHistogramBins(25), mAngleHistogramRange(50), mMemoryPermanent(-1), mMemoryTracklets(-1), mMemoryTracks(-1), mNMaxCollisions(0), mNMaxTracks(0), mNMaxSpacePoints(0), mTracks(nullptr), mTrackAttribs(nullptr), mNCandidates(1), mNTracks(0), mNEvents(0), mMaxBackendThreads(100), mTrackletIndexArray(nullptr), mHypothesis(nullptr), mCandidates(nullptr), mSpacePoints(nullptr), mGeo(nullptr), mRecoParam(nullptr), mDebugOutput(false), mMaxEta(0.84f), mRoadZ(18.f), mTPCVdrift(2.58f), mTPCTDriftOffset(0.f), mDebug(new GPUTRDTrackerDebug<TRDTRK>())
 {
   //--------------------------------------------------------------------
   // Default constructor
@@ -579,12 +579,14 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::FollowProlongation(PROP* prop, TRDTRK
           prop->getPropagatedYZ(spacePoints[trkltIdx].getX(), projY, projZ);
           // correction for tilted pads (only applied if deltaZ < lPad && track z err << lPad)
           float tiltCorr = tilt * (spacePoints[trkltIdx].getZ() - projZ);
+          float dyTiltCorr = tilt * trkWork->getTgl() * mGeo->GetCdrHght();
           float lPad = pad->GetRowSize(tracklets[trkltIdx].GetZbin());
           if (!((CAMath::Abs(spacePoints[trkltIdx].getZ() - projZ) < lPad) && (trkWork->getSigmaZ2() < (lPad * lPad / 12.f)))) {
             tiltCorr = 0.f; // will be zero also for TPC tracks which are shifted in z
+            dyTiltCorr = 0.f;
           }
           // correction for mean z position of tracklet (is not the center of the pad if track eta != 0)
-          float zPosCorr = spacePoints[trkltIdx].getZ() + mZCorrCoefNRC * trkWork->getTgl();
+          float zPosCorr = spacePoints[trkltIdx].getZ() + mRecoParam->getZCorrCoeffNRC() * trkWork->getTgl();
           float yPosCorr = spacePoints[trkltIdx].getY() - tiltCorr;
           zPosCorr -= zShiftTrk; // shift tracklet instead of track in order to avoid having to do a re-fit for each collision
           float deltaY = yPosCorr - projY;
@@ -595,8 +597,22 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::FollowProlongation(PROP* prop, TRDTRK
             // tracklet is in windwow: get predicted chi2 for update and store tracklet index if best guess
             RecalcTrkltCov(tilt, trkWork->getSnp(), pad->GetRowSize(tracklets[trkltIdx].GetZbin()), trkltCovTmp);
             float chi2 = prop->getPredictedChi2(trkltPosTmpYZ, trkltCovTmp);
+            if (Param().rec.trd.addDeflectionInChi2 && (trkWork->getSnp() < 1.f - 1e-6f) && (trkWork->getSnp() > -1.f + 1e-6f)) {
+              // we add the slope in the chi2 calculation
+              float trkltCovTmpWithDy[6] = {trkltCovTmp[0], trkltCovTmp[1], trkltCovTmp[2], 0.f, 0.f, 0.f};
+              RecalcTrkltCovDy(tilt, trkWork->getSnp(), trkltCovTmpWithDy);
+              trkltCovTmpWithDy[0] += trkWork->getSigmaY2();
+              trkltCovTmpWithDy[1] += trkWork->getSigmaZY();
+              trkltCovTmpWithDy[2] += trkWork->getSigmaZ2();
+
+              // For now, dy uncertainty parametrization also includes track uncertainty, so no need to add additional uncertainty
+              if (InvertCov(trkltCovTmpWithDy)) {
+                float deltaDy = spacePoints[trkltIdx].getDy() + dyTiltCorr - mRecoParam->convertAngleToDy(trkWork->getSnp());
+                chi2 = deltaY * trkltCovTmpWithDy[0] * deltaY + 2 * deltaY * trkltCovTmpWithDy[1] * deltaZ + 2 * deltaY * trkltCovTmpWithDy[3] * deltaDy + deltaZ * trkltCovTmpWithDy[2] * deltaZ + 2 * deltaZ * trkltCovTmpWithDy[4] * deltaDy + deltaDy * trkltCovTmpWithDy[5] * deltaDy;
+              }
+            }
             // TODO cut on angular pull should be made stricter when proper v-drift calibration for the TRD tracklets is implemented
-            if ((chi2 > Param().rec.trd.maxChi2) || (Param().rec.trd.applyDeflectionCut && CAMath::Abs(GetAngularPull(spacePoints[trkltIdx].getDy(), trkWork->getSnp())) > 4)) {
+            if ((chi2 > Param().rec.trd.maxChi2) || (Param().rec.trd.applyDeflectionCut && CAMath::Abs(GetAngularPull(spacePoints[trkltIdx].getDy() + dyTiltCorr, trkWork->getSnp())) > 4)) {
               continue;
             }
             Hypothesis hypo(trkWork->getNlayersFindable(), iCandidate, trkltIdx, trkWork->getChi2() + chi2);
@@ -674,7 +690,7 @@ GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::FollowProlongation(PROP* prop, TRDTRK
 
       pad = mGeo->GetPadPlane(tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetDetector());
       float tiltCorrUp = tilt * (spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getZ() - trkWork->getZ());
-      float zPosCorrUp = spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getZ() + mZCorrCoefNRC * trkWork->getTgl();
+      float zPosCorrUp = spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getZ() + mRecoParam->getZCorrCoeffNRC() * trkWork->getTgl();
       zPosCorrUp -= zShiftTrk;
       float padLength = pad->GetRowSize(tracklets[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].GetZbin());
       if (!((trkWork->getSigmaZ2() < (padLength * padLength / 12.f)) && (CAMath::Abs(spacePoints[mHypothesis[iUpdate + hypothesisIdxOffset].mTrackletId].getZ() - trkWork->getZ()) < padLength))) {
@@ -938,6 +954,69 @@ GPUd() void GPUTRDTracker_t<TRDTRK, PROP>::RecalcTrkltCov(const float tilt, cons
   cov[2] = c2 * (t2 * sy2 + sz2);
 }
 
+template <class TRDTRK, class PROP>
+GPUd() void GPUTRDTracker_t<TRDTRK, PROP>::RecalcTrkltCovDy(const float tilt, const float snp, float (&cov)[6])
+{
+  float t2 = tilt * tilt;      // tan^2 (tilt)
+  float c2 = 1.f / (1.f + t2); // cos^2 (tilt)
+  float sy2 = mRecoParam->getRPhiRes(snp);
+  float sdy2 = mRecoParam->getDyRes(snp);
+  cov[3] = mRecoParam->getCorrYDy(snp) * CAMath::Sqrt(sdy2 * c2 * sy2);
+  cov[4] = -tilt * mRecoParam->getCorrYDy(snp) * CAMath::Sqrt(sdy2 * c2 * sy2);
+  cov[5] = sdy2;
+}
+
+template <class TRDTRK, class PROP>
+GPUd() bool GPUTRDTracker_t<TRDTRK, PROP>::InvertCov(float (&cov)[6])
+{
+  // invert a 3*3 symmetric matrix. Adapted from https://root.cern.ch/doc/master/TMatrixTSymCramerInv_8cxx_source.html
+
+  float c00 = cov[2] * cov[5] - cov[4] * cov[4];
+  float c01 = cov[4] * cov[3] - cov[1] * cov[5];
+  float c02 = cov[1] * cov[4] - cov[2] * cov[3];
+  float c11 = cov[5] * cov[0] - cov[3] * cov[3];
+  float c12 = cov[3] * cov[1] - cov[4] * cov[0];
+  float c22 = cov[0] * cov[2] - cov[1] * cov[1];
+
+  float t0 = CAMath::Abs(cov[0]);
+  float t1 = CAMath::Abs(cov[1]);
+  float t2 = CAMath::Abs(cov[3]);
+
+  float det;
+  float tmp;
+
+  if (t0 >= t1) {
+    if (t2 >= t0) {
+      tmp = cov[3];
+      det = c12 * c01 - c11 * c02;
+    } else {
+      tmp = cov[0];
+      det = c11 * c22 - c12 * c12;
+    }
+  } else if (t2 >= t1) {
+    tmp = cov[3];
+    det = c12 * c01 - c11 * c02;
+  } else {
+    tmp = cov[1];
+    det = c02 * c12 - c01 * c22;
+  }
+
+  if (det == 0 || tmp == 0) {
+    return false;
+  }
+
+  float s = tmp / det;
+
+  cov[0] = s * c00;
+  cov[1] = s * c01;
+  cov[3] = s * c02;
+  cov[2] = s * c11;
+  cov[4] = s * c12;
+  cov[5] = s * c22;
+
+  return true;
+}
+
 template <class TRDTRK, class PROP>
 GPUd() float GPUTRDTracker_t<TRDTRK, PROP>::GetAngularPull(float dYtracklet, float snp) const
 {
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
index 5d7530ccecc11..f698e570d2158 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTracker.h
@@ -117,6 +117,8 @@ class GPUTRDTracker_t : public GPUProcessor
   GPUd() float GetAlphaOfSector(const int32_t sec) const;
   GPUd() float GetAngularPull(float dYtracklet, float snp) const;
   GPUd() void RecalcTrkltCov(const float tilt, const float snp, const float rowSize, float (&cov)[3]);
+  GPUd() void RecalcTrkltCovDy(const float tilt, const float snp, float (&cov)[6]);
+  GPUd() bool InvertCov(float (&cov)[6]);
   GPUd() void FindChambersInRoad(const TRDTRK* t, const float roadY, const float roadZ, const int32_t iLayer, int32_t* det, const float zMax, const float alpha, const float zShiftTrk) const;
   GPUd() bool IsGeoFindable(const TRDTRK* t, const int32_t layer, const float alpha, const float zShiftTrk) const;
   GPUd() void InsertHypothesis(Hypothesis hypo, int32_t& nCurrHypothesis, int32_t idxOffset);
@@ -172,13 +174,11 @@ class GPUTRDTracker_t : public GPUProcessor
   TRDTRK* mCandidates;            // array of tracks for multiple hypothesis tracking
   GPUTRDSpacePoint* mSpacePoints; // array with tracklet coordinates in global tracking frame
   const GPUTRDGeometry* mGeo;     // TRD geometry
-  const GPUTRDRecoParam* mRecoParam; // TRD RecoParam
-  /// ---- end error parametrization ----
+  const GPUTRDRecoParam* mRecoParam;                  // TRD RecoParam
   bool mDebugOutput;                                  // store debug output
   static constexpr const float sRadialOffset = -0.1f; // due to (possible) mis-calibration of t0 -> will become obsolete when tracklet conversion is done outside of the tracker
   float mMaxEta;                                      // TPC tracks with higher eta are ignored
   float mRoadZ;                                       // in z, a constant search road is used
-  float mZCorrCoefNRC;                                // tracklet z-position depends linearly on track dip angle
   float mTPCVdrift;                                   // TPC drift velocity used for shifting TPC tracks along Z
   float mTPCTDriftOffset;                             // TPC drift time additive offset
   GPUTRDTrackerDebug<TRDTRK>* mDebug;                 // debug output

From 657d53aefcd3d49808f21540ed1d0a371f914fec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Tue, 24 Feb 2026 22:14:52 +0200
Subject: [PATCH 1363/1764] [ALICE3] update TOF geometry (#15096)

- add segmentation into modules, fix overlaps
---
 .../base/include/IOTOFBase/GeometryTGeo.h     |   8 +
 .../ALICE3/IOTOF/base/src/GeometryTGeo.cxx    |   4 +
 .../include/IOTOFSimulation/Layer.h           |  12 +-
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  |   4 +-
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     | 330 +++++++++++++-----
 5 files changed, 257 insertions(+), 101 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/GeometryTGeo.h
index 177426e8dba09..577bd1bcabaf1 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/GeometryTGeo.h
@@ -32,11 +32,15 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   // Inner TOF
   static const char* getITOFLayerPattern() { return sITOFLayerName.c_str(); }
+  static const char* getITOFStavePattern() { return sITOFStaveName.c_str(); }
+  static const char* getITOFModulePattern() { return sITOFModuleName.c_str(); }
   static const char* getITOFChipPattern() { return sITOFChipName.c_str(); }
   static const char* getITOFSensorPattern() { return sITOFSensorName.c_str(); }
 
   // Outer TOF
   static const char* getOTOFLayerPattern() { return sOTOFLayerName.c_str(); }
+  static const char* getOTOFStavePattern() { return sOTOFStaveName.c_str(); }
+  static const char* getOTOFModulePattern() { return sOTOFModuleName.c_str(); }
   static const char* getOTOFChipPattern() { return sOTOFChipName.c_str(); }
   static const char* getOTOFSensorPattern() { return sOTOFSensorName.c_str(); }
 
@@ -81,11 +85,15 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   // Inner TOF
   static std::string sITOFLayerName;
+  static std::string sITOFStaveName;
+  static std::string sITOFModuleName;
   static std::string sITOFChipName;
   static std::string sITOFSensorName;
 
   // Outer TOF
   static std::string sOTOFLayerName;
+  static std::string sOTOFStaveName;
+  static std::string sOTOFModuleName;
   static std::string sOTOFChipName;
   static std::string sOTOFSensorName;
 
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/IOTOF/base/src/GeometryTGeo.cxx
index 8c29127a5e7d6..f7d0eb135a27a 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/src/GeometryTGeo.cxx
@@ -23,11 +23,15 @@ std::string GeometryTGeo::sIOTOFVolumeName = "IOTOFV";
 
 // Inner TOF
 std::string GeometryTGeo::sITOFLayerName = "ITOFLayer";
+std::string GeometryTGeo::sITOFStaveName = "ITOFStave";
+std::string GeometryTGeo::sITOFModuleName = "ITOFModule";
 std::string GeometryTGeo::sITOFChipName = "ITOFChip";
 std::string GeometryTGeo::sITOFSensorName = "ITOFSensor";
 
 // Outer TOF
 std::string GeometryTGeo::sOTOFLayerName = "OTOFLayer";
+std::string GeometryTGeo::sOTOFStaveName = "OTOFStave";
+std::string GeometryTGeo::sOTOFModuleName = "OTOFModule";
 std::string GeometryTGeo::sOTOFChipName = "OTOFChip";
 std::string GeometryTGeo::sOTOFSensorName = "OTOFSensor";
 
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
index df3687b2b2ea4..29542810b8021 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
@@ -26,7 +26,7 @@ class Layer
  public:
   Layer() = default;
   Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0,
-        int layout = kBarrel, int nSegments = 0, float segmentSize = 0.0, int nSensorsPerSegment = 0, double tiltAngle = 0.0);
+        int layout = kBarrel, int nStaves = 0, float staveSize = 0.0, double staveTiltAngle = 0.0, int modulesPerStave = 0);
   ~Layer() = default;
 
   auto getInnerRadius() const { return mInnerRadius; }
@@ -37,7 +37,7 @@ class Layer
   auto getChipThickness() const { return mChipThickness; }
   auto getName() const { return mLayerName; }
   auto getLayout() const { return mLayout; }
-  auto getSegments() const { return mSegments; }
+  auto getSegments() const { return mStaves; }
   static constexpr int kBarrel = 0;
   static constexpr int kDisk = 1;
   static constexpr int kBarrelSegmented = 2;
@@ -54,10 +54,10 @@ class Layer
   float mX2X0;
   float mChipThickness;
   int mLayout{kBarrel}; // Identifier of the type of layer layout (barrel, disk, barrel segmented, disk segmented)
-  // To be used only in case of the segmented layout, to define the number of segments in phi (for barrel) or in r (for disk)
-  std::pair<int, float> mSegments{0, 0.0f}; // Number  and size of segments in phi (for barrel) or in r (for disk) in case of segmented layout
-  int mSensorsPerSegment{0};                // Number of sensors along a segment
-  double mTiltAngle{0.0};                   // Tilt angle in degrees to be applied as a rotation around the local center of the segment
+  // To be used only in case of the segmented layout, to define the number of staves in phi (for barrel) or in r (for disk)
+  std::pair<int, float> mStaves{0, 0.0f}; // Number and size of staves in phi (for barrel) or in r (for disk) in case of segmented layout
+  int mModulesPerStave{0};                // Number of modules along a stave
+  double mTiltAngle{0.0};                 // Tilt angle in degrees to be applied as a rotation around the local center of the stave
 };
 
 class ITOFLayer : public Layer
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index 0742af3a1340a..c056df5fd34ca 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -98,14 +98,14 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
   if (itof) { // iTOF
     mITOFLayer = itofSegmented ? ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()},
                                            radiusInnerTof, 0.f, lengthInnerTof, 0.f, 0.02f, ITOFLayer::kBarrelSegmented,
-                                           24, 5.42, 80, 10)
+                                           24, 5.42, 10.0, 10)
                                : ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()},
                                            radiusInnerTof, 0.f, lengthInnerTof, 0.f, 0.02f, ITOFLayer::kBarrel);
   }
   if (otof) { // oTOF
     mOTOFLayer = otofSegmented ? OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()},
                                            radiusOuterTof, 0.f, lengthOuterTof, 0.f, 0.02f, OTOFLayer::kBarrelSegmented,
-                                           62, 9.74, 432, 5)
+                                           62, 9.74, 5.0, 54)
                                : OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()},
                                            radiusOuterTof, 0.f, lengthOuterTof, 0.f, 0.02f, OTOFLayer::kBarrel);
   }
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 169a1271da47e..32a24fc46f94c 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -27,7 +27,8 @@ namespace o2
 {
 namespace iotof
 {
-Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0, int layout, int nSegments, float segmentSize, int nSensorsPerSegment, double tiltAngle)
+Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0,
+             int layout, int nStaves, float staveSize, double staveTiltAngle, int modulesPerStave)
   : mLayerName(layerName),
     mInnerRadius(rInn),
     mOuterRadius(rOut),
@@ -35,9 +36,9 @@ Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float
     mZOffset(zOffset),
     mX2X0(layerX2X0),
     mLayout(layout),
-    mSegments(nSegments, segmentSize),
-    mSensorsPerSegment(nSensorsPerSegment),
-    mTiltAngle(tiltAngle)
+    mStaves(nStaves, staveSize),
+    mModulesPerStave(modulesPerStave),
+    mTiltAngle(staveTiltAngle)
 {
   float Si_X0 = 9.5f;
   mChipThickness = mX2X0 * Si_X0;
@@ -56,32 +57,72 @@ Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float
     default:
       LOG(fatal) << "Invalid layout " << layout;
   }
-  if (1) { // Sanity checks
-    if (mInnerRadius > mOuterRadius) {
-      LOG(fatal) << "Invalid layer dimensions: rInner " << mInnerRadius << " cm is larger than rOuter " << mOuterRadius << " cm";
-    }
-    if ((mSegments.first != 0 || mSegments.second != 0.0f) && (layout != kBarrelSegmented && layout != kDiskSegmented)) {
-      LOG(fatal) << "Invalid configuration: number of segments " << mSegments.first << " is set for non-segmented layout " << layout;
-    }
-    if ((mSegments.first <= 1 || mSegments.second <= 0.0f) && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
-      LOG(fatal) << "Invalid configuration: number of segments " << mSegments.first << " must be positive for segmented layout " << layout;
-    }
-    if (mSensorsPerSegment <= 0 && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
-      LOG(fatal) << "Invalid configuration: number of sensors per segment " << mSensorsPerSegment << " must be positive for segmented layout " << layout;
-    }
-    if (std::abs(mTiltAngle) > 0.1 && (layout != kBarrelSegmented && layout != kDiskSegmented)) {
-      LOG(fatal) << "Invalid configuration: tilt angle " << mTiltAngle << " is set for non-segmented layout " << layout;
-    }
+  // Sanity checks
+  if (mInnerRadius > mOuterRadius) {
+    LOG(fatal) << "Invalid layer dimensions: rInner " << mInnerRadius << " cm is larger than rOuter " << mOuterRadius << " cm";
+  }
+  if ((mStaves.first != 0 || mStaves.second != 0.0f) && (layout != kBarrelSegmented && layout != kDiskSegmented)) {
+    LOG(fatal) << "Invalid configuration: number of segments " << mStaves.first << " is set for non-segmented layout " << layout;
+  }
+  if ((mStaves.first <= 1 || mStaves.second <= 0.0f) && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
+    LOG(fatal) << "Invalid configuration: number of segments " << mStaves.first << " must be positive for segmented layout " << layout;
+  }
+  if (mModulesPerStave <= 0 && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
+    LOG(fatal) << "Invalid configuration: number of sensors per segment " << mModulesPerStave << " must be positive for segmented layout " << layout;
+  }
+  if (std::abs(mTiltAngle) > 0.1 && (layout != kBarrelSegmented && layout != kDiskSegmented)) {
+    LOG(fatal) << "Invalid configuration: tilt angle " << mTiltAngle << " is set for non-segmented layout " << layout;
+  }
+  if ((mTiltAngle < 0.0 || mTiltAngle > 90.0) && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
+    LOG(fatal) << "Invalid configuration: tilt angle " << mTiltAngle << " is too large, it must be between 0 and 90 degrees";
   }
 
   LOGP(info, "TOF: Creating {} layer: rInner: {} (cm) rOuter: {} (cm) zLength: {} (cm) zOffset: {} x2X0: {}", name.c_str(), mInnerRadius, mOuterRadius, mZLength, mZOffset, mX2X0);
 }
 
+void setLayerStyle(TGeoVolume* obj)
+{
+  obj->SetLineColor(kRed - 7);
+  obj->SetFillColor(kRed - 7);
+  obj->SetLineWidth(1);
+  obj->SetTransparency(70);
+}
+void setStaveStyle(TGeoVolume* obj)
+{
+  obj->SetLineColor(kRed - 5);
+  obj->SetFillColor(kRed - 9);
+  obj->SetLineWidth(2);
+  obj->SetTransparency(45);
+}
+void setModuleStyle(TGeoVolume* obj)
+{
+  obj->SetLineColor(kRed - 3);
+  obj->SetFillColor(kRed - 8);
+  obj->SetLineWidth(2);
+  obj->SetTransparency(35);
+}
+void setChipStyle(TGeoVolume* obj)
+{
+  obj->SetLineColor(kOrange);
+  obj->SetFillColor(kOrange - 9);
+  obj->SetLineWidth(3);
+  obj->SetTransparency(15);
+}
+void setSensorStyle(TGeoVolume* obj)
+{
+  obj->SetLineColor(kRed);
+  obj->SetFillColor(kRed - 9);
+  obj->SetLineWidth(3);
+  obj->SetTransparency(5);
+}
+
 std::vector<std::string> ITOFLayer::mRegister;
 void ITOFLayer::createLayer(TGeoVolume* motherVolume)
 {
-  const std::string chipName = o2::iotof::GeometryTGeo::getITOFChipPattern();
-  const std::string sensName = o2::iotof::GeometryTGeo::getITOFSensorPattern();
+  const char* chipName = o2::iotof::GeometryTGeo::getITOFChipPattern();
+  const char* sensName = o2::iotof::GeometryTGeo::getITOFSensorPattern();
+  const char* moduleName = o2::iotof::GeometryTGeo::getITOFModulePattern();
+  const char* staveName = o2::iotof::GeometryTGeo::getITOFStavePattern();
 
   TGeoMedium* medSi = gGeoManager->GetMedium("TF3_SILICON$");
   TGeoMedium* medAir = gGeoManager->GetMedium("TF3_AIR$");
@@ -93,12 +134,12 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       TGeoTube* chip = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
       TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
 
-      TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
-      TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+      TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);
+      TGeoVolume* chipVol = new TGeoVolume(chipName, chip, medSi);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-      sensVol->SetLineColor(kRed + 3);
-      chipVol->SetLineColor(kRed + 3);
-      layerVol->SetLineColor(kRed + 3);
+      setSensorStyle(sensVol);
+      setChipStyle(chipVol);
+      setLayerStyle(layerVol);
 
       LOGP(info, "Inserting Barrel {} in {} ", sensVol->GetName(), chipVol->GetName());
       ITOFLayer::mRegister.push_back(sensVol->GetName());
@@ -112,40 +153,91 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       return;
     }
     case kBarrelSegmented: {
-      const double circumference = TMath::TwoPi() * 0.5 * (mInnerRadius + mOuterRadius);
-      const double segmentSize = mSegments.second; // cm circumference / mSegments;
+      // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
-      TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+      const double staveSizeX = mStaves.second;                                                                                                          // cm
+      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                             // cm
+      const double staveSizeZ = mZLength;                                                                                                                // cm
+      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY); // we increase the size of the layer to account for the tilt of the staves
+      TGeoTube* layer = new TGeoTube(mInnerRadius - deltaForTilt, mOuterRadius + deltaForTilt, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-      layerVol->SetLineColor(kRed + 3);
-
-      for (int i = 0; i < mSegments.first; ++i) {
-        LOGP(info, "iTOF: Creating segment {}/{} with size {} and thickness {}cm", i + 1, mSegments.first, segmentSize, (mOuterRadius - mInnerRadius));
-        const double hx = 0.5 * segmentSize;
-        const double hy = 0.5 * (mOuterRadius - mInnerRadius);
-        const double hz = 0.5 * mZLength;
-        TGeoBBox* sensor = new TGeoBBox(hy, hx, hz);
-        TGeoBBox* chip = new TGeoBBox(hy, hx, hz);
-        const std::string segmentTag = Form("segment%d", i + 1);
-        TGeoVolume* sensVol = new TGeoVolume(Form("%s_%s", sensName.c_str(), segmentTag.c_str()), sensor, medSi);
-        TGeoVolume* chipVol = new TGeoVolume(Form("%s_%s", chipName.c_str(), segmentTag.c_str()), chip, medSi);
-        sensVol->SetLineColor(kRed + 3);
-        chipVol->SetLineColor(kRed + 3);
-
-        LOGP(info, "  Inserting Barrel {} in {} ", sensVol->GetName(), chipVol->GetName());
-        ITOFLayer::mRegister.push_back(sensVol->GetName());
-        chipVol->AddNode(sensVol, 1, nullptr);
-
-        const double phi = TMath::TwoPi() * i / mSegments.first;
-
-        LOG(info) << "  Tilting angle for segment " << i + 1 << ": " << phi * TMath::RadToDeg() << " degrees";
+      setLayerStyle(layerVol);
+
+      // Now we create the volume for a single stave
+      TGeoBBox* stave = new TGeoBBox(staveSizeX * 0.5, staveSizeY * 0.5, staveSizeZ * 0.5);
+      TGeoVolume* staveVol = new TGeoVolume(staveName, stave, medAir);
+      setStaveStyle(staveVol);
+
+      // Now we create the volume for a single module (sensor + chip)
+      const int modulesPerStaveX = 1;                           // we assume that each stave is divided in 2 modules along the x direction
+      const double moduleSizeX = staveSizeX / modulesPerStaveX; // cm
+      const double moduleSizeY = staveSizeY;                    // cm
+      const double moduleSizeZ = staveSizeZ / mModulesPerStave; // cm
+      TGeoBBox* module = new TGeoBBox(moduleSizeX * 0.5, moduleSizeY * 0.5, moduleSizeZ * 0.5);
+      TGeoVolume* moduleVol = new TGeoVolume(moduleName, module, medAir);
+      setModuleStyle(moduleVol);
+
+      // Now we create the volume of the chip, which is the same for all modules
+      const int chipsPerModuleX = 2;                          // we assume that each module is divided in 2 chips along the x direction
+      const int chipsPerModuleZ = 2;                          // we assume that each module is divided in 2 chips along the z direction
+      const double chipSizeX = moduleSizeX / chipsPerModuleX; // cm
+      const double chipSizeY = moduleSizeY;                   // cm
+      const double chipSizeZ = moduleSizeZ / chipsPerModuleZ; // cm
+      TGeoBBox* chip = new TGeoBBox(chipSizeX * 0.5, chipSizeY * 0.5, chipSizeZ * 0.5);
+      TGeoVolume* chipVol = new TGeoVolume(chipName, chip, medSi);
+      setChipStyle(chipVol);
+
+      // Finally we create the volume of the sensor, which is the same for all chips
+      const int sensorsPerChipX = 2;                          // we assume that each chip is divided in 2 sensors along the x direction
+      const int sensorsPerChipZ = 2;                          // we assume that each chip is divided in 2 sensors along the z direction
+      const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
+      const double sensorSizeY = chipSizeY;                   // cm
+      const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
+      TGeoBBox* sensor = new TGeoBBox(sensorSizeX * 0.5, sensorSizeY * 0.5, sensorSizeZ * 0.5);
+      TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);
+      setSensorStyle(sensVol);
+      ITOFLayer::mRegister.push_back(sensVol->GetName());
+
+      // Now we build a chip from sensors
+      for (int i = 0; i < sensorsPerChipX; ++i) {
+        for (int j = 0; j < sensorsPerChipZ; ++j) {
+          LOGP(info, "iTOF: Creating sensor {}/{} for chip {}/{}", i + 1, sensorsPerChipX, j + 1, sensorsPerChipZ);
+          auto* translation = new TGeoTranslation((i + 0.5) * sensorSizeX - 0.5 * chipSizeX,
+                                                  0,
+                                                  (j + 0.5) * sensorSizeZ - 0.5 * chipSizeZ);
+          chipVol->AddNode(sensVol, 1 + i * sensorsPerChipZ + j, translation);
+        }
+      }
+
+      // Now we build a module from chips
+      for (int i = 0; i < chipsPerModuleX; ++i) {
+        for (int j = 0; j < chipsPerModuleZ; ++j) {
+          LOGP(info, "iTOF: Creating chip {}/{} for module {}/{}", i + 1, chipsPerModuleX, j + 1, chipsPerModuleZ);
+          auto* translation = new TGeoTranslation((i + 0.5) * chipSizeX - 0.5 * moduleSizeX, 0, (j + 0.5) * chipSizeZ - 0.5 * moduleSizeZ);
+          moduleVol->AddNode(chipVol, 1 + i * chipsPerModuleZ + j, translation);
+        }
+      }
+
+      // Now we build a stave from modules
+      for (int i = 0; i < modulesPerStaveX; ++i) {
+        for (int j = 0; j < mModulesPerStave; ++j) {
+          LOGP(info, "iTOF: Creating module {}/{} for stave {}/{}", i + 1, modulesPerStaveX, j + 1, mModulesPerStave);
+          auto* translation = new TGeoTranslation((i + 0.5) * moduleSizeX - 0.5 * staveSizeX, 0, (j + 0.5) * moduleSizeZ - 0.5 * staveSizeZ);
+          staveVol->AddNode(moduleVol, 1 + i * mModulesPerStave + j, translation);
+        }
+      }
+
+      // We finally put all the staves in the layer
+      for (int i = 0; i < mStaves.first; ++i) {
+        LOGP(info, "iTOF: Creating stave {}/{} for layer {}", i + 1, mStaves.first, layerVol->GetName());
+        const double phi = TMath::TwoPi() * i / mStaves.first;
         const double x = avgRadius * TMath::Cos(phi);
         const double y = avgRadius * TMath::Sin(phi);
-        auto* rotation = new TGeoRotation(Form("segmentRot%d", i + 1), phi * TMath::RadToDeg() + mTiltAngle, 0, 0);
+        auto* rotation = new TGeoRotation(Form("segmentRot%d", i + 1), phi * TMath::RadToDeg() + 90 + mTiltAngle, 0, 0);
         auto* transformation = new TGeoCombiTrans(x, y, 0, rotation);
 
         LOGP(info, "Inserting Barrel {} in {} ", chipVol->GetName(), layerVol->GetName());
-        layerVol->AddNode(chipVol, 1 + i, transformation);
+        layerVol->AddNode(staveVol, 1 + i, transformation);
       }
       LOGP(info, "Inserting Barrel {} in {} at r={} cm", layerVol->GetName(), motherVolume->GetName(), avgRadius);
       motherVolume->AddNode(layerVol, 1, nullptr);
@@ -159,8 +251,10 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
 std::vector<std::string> OTOFLayer::mRegister;
 void OTOFLayer::createLayer(TGeoVolume* motherVolume)
 {
-  std::string chipName = o2::iotof::GeometryTGeo::getOTOFChipPattern(),
-              sensName = o2::iotof::GeometryTGeo::getOTOFSensorPattern();
+  const char* chipName = o2::iotof::GeometryTGeo::getOTOFChipPattern();
+  const char* sensName = o2::iotof::GeometryTGeo::getOTOFSensorPattern();
+  const char* moduleName = o2::iotof::GeometryTGeo::getOTOFModulePattern();
+  const char* staveName = o2::iotof::GeometryTGeo::getOTOFStavePattern();
 
   TGeoMedium* medSi = gGeoManager->GetMedium("TF3_SILICON$");
   TGeoMedium* medAir = gGeoManager->GetMedium("TF3_AIR$");
@@ -172,12 +266,12 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
       TGeoTube* chip = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
       TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
 
-      TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
-      TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
+      TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);
+      TGeoVolume* chipVol = new TGeoVolume(chipName, chip, medSi);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-      sensVol->SetLineColor(kRed + 3);
-      chipVol->SetLineColor(kRed + 3);
-      layerVol->SetLineColor(kRed + 3);
+      setSensorStyle(sensVol);
+      setChipStyle(chipVol);
+      setLayerStyle(layerVol);
 
       LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
       OTOFLayer::mRegister.push_back(sensVol->GetName());
@@ -191,40 +285,90 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
       return;
     }
     case kBarrelSegmented: {
-      const double circumference = TMath::TwoPi() * 0.5 * (mInnerRadius + mOuterRadius);
-      const double segmentSize = mSegments.second; // cm circumference / mSegments;
+      // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
       TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-      layerVol->SetLineColor(kRed + 3);
-
-      for (int i = 0; i < mSegments.first; ++i) {
-        LOGP(info, "oTOF: Creating segment {}/{} with size {} and thickness {}cm", i + 1, mSegments.first, segmentSize, (mOuterRadius - mInnerRadius));
-        const double hx = 0.5 * segmentSize;
-        const double hy = 0.5 * (mOuterRadius - mInnerRadius);
-        const double hz = 0.5 * mZLength;
-        TGeoBBox* sensor = new TGeoBBox(hy, hx, hz);
-        TGeoBBox* chip = new TGeoBBox(hy, hx, hz);
-        const std::string segmentTag = Form("segment%d", i + 1);
-        TGeoVolume* sensVol = new TGeoVolume(Form("%s_%s", sensName.c_str(), segmentTag.c_str()), sensor, medSi);
-        TGeoVolume* chipVol = new TGeoVolume(Form("%s_%s", chipName.c_str(), segmentTag.c_str()), chip, medSi);
-        sensVol->SetLineColor(kRed + 3);
-        chipVol->SetLineColor(kRed + 3);
-
-        LOGP(info, "  Inserting Barrel {} in {} ", sensVol->GetName(), chipVol->GetName());
-        OTOFLayer::mRegister.push_back(sensVol->GetName());
-        chipVol->AddNode(sensVol, 1, nullptr);
-
-        const double phi = TMath::TwoPi() * i / mSegments.first;
-
-        LOG(info) << "  Tilting angle for segment " << i + 1 << ": " << phi * TMath::RadToDeg() << " degrees";
+      setLayerStyle(layerVol);
+
+      // Now we create the volume for a single stave
+      const double staveSizeX = mStaves.second;              // cm
+      const double staveSizeY = mOuterRadius - mInnerRadius; // cm
+      const double staveSizeZ = mZLength;                    // cm
+      TGeoBBox* stave = new TGeoBBox(staveSizeX * 0.5, staveSizeY * 0.5, staveSizeZ * 0.5);
+      TGeoVolume* staveVol = new TGeoVolume(staveName, stave, medAir);
+      setStaveStyle(staveVol);
+
+      // Now we create the volume for a single module (sensor + chip)
+      const int modulesPerStaveX = 1;                           // we assume that each stave is divided in 2 modules along the x direction
+      const double moduleSizeX = staveSizeX / modulesPerStaveX; // cm
+      const double moduleSizeY = staveSizeY;                    // cm
+      const double moduleSizeZ = staveSizeZ / mModulesPerStave; // cm
+      TGeoBBox* module = new TGeoBBox(moduleSizeX * 0.5, moduleSizeY * 0.5, moduleSizeZ * 0.5);
+      TGeoVolume* moduleVol = new TGeoVolume(moduleName, module, medAir);
+      setModuleStyle(moduleVol);
+
+      // Now we create the volume of the chip, which is the same for all modules
+      const int chipsPerModuleX = 2;                          // we assume that each module is divided in 2 chips along the x direction
+      const int chipsPerModuleZ = 2;                          // we assume that each module is divided in 2 chips along the z direction
+      const double chipSizeX = moduleSizeX / chipsPerModuleX; // cm
+      const double chipSizeY = moduleSizeY;                   // cm
+      const double chipSizeZ = moduleSizeZ / chipsPerModuleZ; // cm
+      TGeoBBox* chip = new TGeoBBox(chipSizeX * 0.5, chipSizeY * 0.5, chipSizeZ * 0.5);
+      TGeoVolume* chipVol = new TGeoVolume(chipName, chip, medSi);
+      setChipStyle(chipVol);
+
+      // Finally we create the volume of the sensor, which is the same for all chips
+      const int sensorsPerChipX = 2;                          // we assume that each chip is divided in 2 sensors along the x direction
+      const int sensorsPerChipZ = 2;                          // we assume that each chip is divided in 2 sensors along the z direction
+      const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
+      const double sensorSizeY = chipSizeY;                   // cm
+      const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
+      TGeoBBox* sensor = new TGeoBBox(sensorSizeX * 0.5, sensorSizeY * 0.5, sensorSizeZ * 0.5);
+      TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);
+      setSensorStyle(sensVol);
+      OTOFLayer::mRegister.push_back(sensVol->GetName());
+
+      // Now we build a chip from sensors
+      for (int i = 0; i < sensorsPerChipX; ++i) {
+        for (int j = 0; j < sensorsPerChipZ; ++j) {
+          LOGP(info, "oTOF: Creating sensor {}/{} for chip {}/{}", i + 1, sensorsPerChipX, j + 1, sensorsPerChipZ);
+          auto* translation = new TGeoTranslation((i + 0.5) * sensorSizeX - 0.5 * chipSizeX,
+                                                  0,
+                                                  (j + 0.5) * sensorSizeZ - 0.5 * chipSizeZ);
+          chipVol->AddNode(sensVol, 1 + i * sensorsPerChipZ + j, translation);
+        }
+      }
+
+      // Now we build a module from chips
+      for (int i = 0; i < chipsPerModuleX; ++i) {
+        for (int j = 0; j < chipsPerModuleZ; ++j) {
+          LOGP(info, "oTOF: Creating chip {}/{} for module {}/{}", i + 1, chipsPerModuleX, j + 1, chipsPerModuleZ);
+          auto* translation = new TGeoTranslation((i + 0.5) * chipSizeX - 0.5 * moduleSizeX, 0, (j + 0.5) * chipSizeZ - 0.5 * moduleSizeZ);
+          moduleVol->AddNode(chipVol, 1 + i * chipsPerModuleZ + j, translation);
+        }
+      }
+
+      // Now we build a stave from modules
+      for (int i = 0; i < modulesPerStaveX; ++i) {
+        for (int j = 0; j < mModulesPerStave; ++j) {
+          LOGP(info, "oTOF: Creating module {}/{} for stave {}/{}", i + 1, modulesPerStaveX, j + 1, mModulesPerStave);
+          auto* translation = new TGeoTranslation((i + 0.5) * moduleSizeX - 0.5 * staveSizeX, 0, (j + 0.5) * moduleSizeZ - 0.5 * staveSizeZ);
+          staveVol->AddNode(moduleVol, 1 + i * mModulesPerStave + j, translation);
+        }
+      }
+
+      // We finally put all the staves in the layer
+      for (int i = 0; i < mStaves.first; ++i) {
+        LOGP(info, "oTOF: Creating stave {}/{} for layer {}", i + 1, mStaves.first, layerVol->GetName());
+        const double phi = TMath::TwoPi() * i / mStaves.first;
         const double x = avgRadius * TMath::Cos(phi);
         const double y = avgRadius * TMath::Sin(phi);
-        auto* rotation = new TGeoRotation(Form("segmentRot%d", i + 1), phi * TMath::RadToDeg() + mTiltAngle, 0, 0);
+        auto* rotation = new TGeoRotation(Form("segmentRot%d", i + 1), phi * TMath::RadToDeg() + 90 + mTiltAngle, 0, 0);
         auto* transformation = new TGeoCombiTrans(x, y, 0, rotation);
 
         LOGP(info, "Inserting Barrel {} in {} ", chipVol->GetName(), layerVol->GetName());
-        layerVol->AddNode(chipVol, 1 + i, transformation);
+        layerVol->AddNode(staveVol, 1 + i, transformation);
       }
       LOGP(info, "Inserting Barrel {} in {} at r={} cm", layerVol->GetName(), motherVolume->GetName(), avgRadius);
       motherVolume->AddNode(layerVol, 1, nullptr);
@@ -250,9 +394,9 @@ void FTOFLayer::createLayer(TGeoVolume* motherVolume)
   TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
   TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
   TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-  sensVol->SetLineColor(kRed + 3);
-  chipVol->SetLineColor(kRed + 3);
-  layerVol->SetLineColor(kRed + 3);
+  setSensorStyle(sensVol);
+  setChipStyle(chipVol);
+  setLayerStyle(layerVol);
 
   LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
   chipVol->AddNode(sensVol, 1, nullptr);
@@ -282,9 +426,9 @@ void BTOFLayer::createLayer(TGeoVolume* motherVolume)
   TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
   TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
   TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-  sensVol->SetLineColor(kRed + 3);
-  chipVol->SetLineColor(kRed + 3);
-  layerVol->SetLineColor(kRed + 3);
+  setSensorStyle(sensVol);
+  setChipStyle(chipVol);
+  setLayerStyle(layerVol);
 
   LOGP(info, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
   chipVol->AddNode(sensVol, 1, nullptr);

From f65da9abe52beb8fa8368c041bf45ef0e730fdfc Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 24 Feb 2026 12:27:51 +0100
Subject: [PATCH 1364/1764] Fix order of args passed to CTFCoderBase

Due to this typo the dictionary, if it was requested, was not propagated to the coder
---
 .../CPV/reconstruction/include/CPVReconstruction/CTFCoder.h     | 2 +-
 .../CTP/reconstruction/include/CTPReconstruction/CTFCoder.h     | 2 +-
 .../EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h | 2 +-
 .../FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h | 2 +-
 .../FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h | 2 +-
 .../FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h | 2 +-
 .../HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h | 2 +-
 .../reconstruction/include/ITSMFTReconstruction/CTFCoder.h      | 2 +-
 Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h                | 2 +-
 Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h                | 2 +-
 .../PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h   | 2 +-
 .../TOF/reconstruction/include/TOFReconstruction/CTFCoder.h     | 2 +-
 .../TPC/reconstruction/include/TPCReconstruction/CTFCoder.h     | 2 +-
 .../TRD/reconstruction/include/TRDReconstruction/CTFCoder.h     | 2 +-
 .../ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h     | 2 +-
 15 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h b/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
index a5f9d0eac90e8..4e259c24f44a6 100644
--- a/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
+++ b/Detectors/CPV/reconstruction/include/CPVReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace cpv
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::CPV, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::CPV, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
index b17db0e77be28..8dbc5adadbfc5 100644
--- a/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
+++ b/Detectors/CTP/reconstruction/include/CTPReconstruction/CTFCoder.h
@@ -37,7 +37,7 @@ namespace ctp
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::CTP, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::CTP, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
index 6584775057d9f..706b9bf8138a6 100644
--- a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
+++ b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace emcal
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::EMC, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::EMC, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
index cb3b13aa9b8e4..c62e013447416 100644
--- a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
+++ b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
@@ -36,7 +36,7 @@ namespace fdd
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::FDD, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FDD, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode digits to buffer with CTF
diff --git a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
index 5c2e0f0627ef1..5dc367204e1a3 100644
--- a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
+++ b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
@@ -37,7 +37,7 @@ namespace ft0
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::FT0, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FT0, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode digits to buffer with CTF
diff --git a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
index fdff035b934ef..80dcd6060455b 100644
--- a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
+++ b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
@@ -33,7 +33,7 @@ namespace fv0
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::FV0, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::FV0, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode digits to buffer with CTF
diff --git a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h b/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
index 0e6694d2353ac..894c11864f061 100644
--- a/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
+++ b/Detectors/HMPID/reconstruction/include/HMPIDReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace hmpid
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::HMP, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::HMP, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
index 57d989038342a..7e266052efb3c 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
@@ -45,7 +45,7 @@ class CTFCoder final : public o2::ctf::CTFCoderBase
   using PMatrix = std::array<std::array<bool, ClusterPattern::MaxRowSpan + 2>, ClusterPattern::MaxColSpan + 2>;
   using RowColBuff = std::vector<PixelData>;
 
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, o2::detectors::DetID det, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, det, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, o2::detectors::DetID det, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), det, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode clusters to buffer with CTF
diff --git a/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h b/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
index 5c9da95a98354..a5f2af646c778 100644
--- a/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
+++ b/Detectors/MUON/MCH/CTF/include/MCHCTF/CTFCoder.h
@@ -37,7 +37,7 @@ namespace mch
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::MCH, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::MCH, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h b/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
index defec7207f808..0a6ee12316921 100644
--- a/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
+++ b/Detectors/MUON/MID/CTF/include/MIDCTF/CTFCoder.h
@@ -37,7 +37,7 @@ namespace mid
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::MID, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::MID, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h b/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
index e222328a351c0..8c73114bc53bb 100644
--- a/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
+++ b/Detectors/PHOS/reconstruction/include/PHOSReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace phos
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::PHS, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::PHS, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h b/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
index 53cdf59d08572..4ae99bae86eba 100644
--- a/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
+++ b/Detectors/TOF/reconstruction/include/TOFReconstruction/CTFCoder.h
@@ -34,7 +34,7 @@ namespace tof
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::TOF, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TOF, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode clusters to buffer with CTF
diff --git a/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h b/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
index 2c6fac7dcde2a..0d2d37a73d7db 100644
--- a/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
+++ b/Detectors/TPC/reconstruction/include/TPCReconstruction/CTFCoder.h
@@ -122,7 +122,7 @@ struct MergedColumnsDecoder {
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::TPC, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TPC, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode compressed clusters to flat buffer
diff --git a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
index adb584ef15ec4..b34c2da395c5e 100644
--- a/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
+++ b/Detectors/TRD/reconstruction/include/TRDReconstruction/CTFCoder.h
@@ -36,7 +36,7 @@ namespace trd
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::TRD, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::TRD, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF
diff --git a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
index a299431ef17fc..ec80c16af329e 100644
--- a/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
+++ b/Detectors/ZDC/reconstruction/include/ZDCReconstruction/CTFCoder.h
@@ -35,7 +35,7 @@ namespace zdc
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), 1.f, o2::detectors::DetID::ZDC, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), o2::detectors::DetID::ZDC, 1.f, ctfdictOpt) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode data to buffer with CTF

From c590fd7f2f7dbfed03abe1c3b584d0a2cb2d927f Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 24 Feb 2026 13:17:20 +0100
Subject: [PATCH 1365/1764] Change default ctf-dict of encoders to "none"
 (per-tf dictionary)

---
 Detectors/Base/include/DetectorsBase/CTFCoderBase.h   | 11 ++++++++---
 .../CPV/workflow/src/entropy-encoder-workflow.cxx     |  2 +-
 .../CTP/workflow/src/entropy-encoder-workflow.cxx     |  2 +-
 .../EMCAL/workflow/src/entropy-encoder-workflow.cxx   |  2 +-
 .../FIT/FDD/workflow/src/entropy-encoder-workflow.cxx |  2 +-
 .../FIT/FT0/workflow/src/entropy-encoder-workflow.cxx |  2 +-
 .../FIT/FV0/workflow/src/entropy-encoder-workflow.cxx |  2 +-
 .../HMPID/workflow/src/entropy-encoder-workflow.cxx   |  2 +-
 .../common/workflow/src/entropy-encoder-workflow.cxx  |  2 +-
 .../MCH/Workflow/src/entropy-encoder-workflow.cxx     |  2 +-
 .../MID/Workflow/src/entropy-encoder-workflow.cxx     |  2 +-
 .../PHOS/workflow/src/entropy-encoder-workflow.cxx    |  2 +-
 .../TOF/workflow/src/entropy-encoder-workflow.cxx     |  2 +-
 .../TPC/workflow/src/entropy-encoder-workflow.cxx     |  2 +-
 Detectors/TPC/workflow/src/tpc-reco-workflow.cxx      |  2 +-
 .../TRD/workflow/src/entropy-encoder-workflow.cxx     |  2 +-
 .../ZDC/workflow/src/entropy-encoder-workflow.cxx     |  2 +-
 17 files changed, 24 insertions(+), 19 deletions(-)

diff --git a/Detectors/Base/include/DetectorsBase/CTFCoderBase.h b/Detectors/Base/include/DetectorsBase/CTFCoderBase.h
index 593bf37df5879..e94123bb2b7ff 100644
--- a/Detectors/Base/include/DetectorsBase/CTFCoderBase.h
+++ b/Detectors/Base/include/DetectorsBase/CTFCoderBase.h
@@ -314,6 +314,7 @@ void CTFCoderBase::init(o2::framework::InitContext& ic)
   if (ic.options().hasOption("irframe-shift")) {
     mIRFrameSelShift = (long)ic.options().get<int32_t>("irframe-shift");
   }
+  bool ansVersionProvided = false;
   if (ic.options().hasOption("ans-version")) {
     if (ic.options().isSet("ans-version")) {
       const std::string ansVersionString = ic.options().get<std::string>("ans-version");
@@ -323,6 +324,7 @@ void CTFCoderBase::init(o2::framework::InitContext& ic)
         if (mANSVersion == ANSVersionUnspecified) {
           throw std::invalid_argument(fmt::format("Invalid ANS Version {}", ansVersionString));
         }
+        ansVersionProvided = true;
       }
     }
   }
@@ -331,9 +333,12 @@ void CTFCoderBase::init(o2::framework::InitContext& ic)
   } else {
     if (mDictOpt != "none") { // none means per-CTF dictionary will created on the fly
       createCodersFromFile<CTF>(mDictOpt, mOpType);
-      LOGP(info, "Loaded {} from {}", mExtHeader.asString(), mDictOpt);
+      LOGP(info, "Loaded {} from {}, ANS Version {}", mExtHeader.asString(), mDictOpt, std::string(mANSVersion));
     } else {
-      LOGP(info, "Internal per-TF CTF Dict will be created");
+      if (!ansVersionProvided) {
+        mANSVersion = ANSVersion1;
+      }
+      LOGP(info, "Internal per-TF CTF Dict will be created, ANS Version {}", std::string(mANSVersion));
     }
     mLoadDictFromCCDB = false; // don't try to load from CCDB
   }
@@ -368,7 +373,7 @@ bool CTFCoderBase::finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, voi
       }
       createCoders(*dict, mOpType);
       mExtHeader = static_cast<const CTFDictHeader&>(CTF::get(dict->data())->getHeader());
-      LOGP(info, "Loaded {} from CCDB", mExtHeader.asString());
+      LOGP(info, "Loaded {} from CCDB, ANS Version {}", mExtHeader.asString(), std::string(mANSVersion));
     }
     mLoadDictFromCCDB = false; // we read the dictionary at most once!
   } else if ((match = (matcher == o2::framework::ConcreteDataMatcher("CTP", "Trig_Offset", 0)))) {
diff --git a/Detectors/CPV/workflow/src/entropy-encoder-workflow.cxx b/Detectors/CPV/workflow/src/entropy-encoder-workflow.cxx
index 6f9445d9ddd16..90fedb1d5eb83 100644
--- a/Detectors/CPV/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/CPV/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/CTP/workflow/src/entropy-encoder-workflow.cxx b/Detectors/CTP/workflow/src/entropy-encoder-workflow.cxx
index 9057d16df4384..c2b324a4b3bfa 100644
--- a/Detectors/CTP/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/CTP/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"no-lumi-input", VariantType::Bool, false, {"Lumi info not available"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
diff --git a/Detectors/EMCAL/workflow/src/entropy-encoder-workflow.cxx b/Detectors/EMCAL/workflow/src/entropy-encoder-workflow.cxx
index 953b726fcb971..d5264aabc0566 100644
--- a/Detectors/EMCAL/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/EMCAL/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/FIT/FDD/workflow/src/entropy-encoder-workflow.cxx b/Detectors/FIT/FDD/workflow/src/entropy-encoder-workflow.cxx
index 0e43c6e3c4ba0..b83e25557e760 100644
--- a/Detectors/FIT/FDD/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/FIT/FDD/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/FIT/FT0/workflow/src/entropy-encoder-workflow.cxx b/Detectors/FIT/FT0/workflow/src/entropy-encoder-workflow.cxx
index 2b4a86df0a614..144d27abeda9c 100644
--- a/Detectors/FIT/FT0/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/FIT/FT0/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/FIT/FV0/workflow/src/entropy-encoder-workflow.cxx b/Detectors/FIT/FV0/workflow/src/entropy-encoder-workflow.cxx
index f1b1bfa456316..932e0a37ee376 100644
--- a/Detectors/FIT/FV0/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/FIT/FV0/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/HMPID/workflow/src/entropy-encoder-workflow.cxx b/Detectors/HMPID/workflow/src/entropy-encoder-workflow.cxx
index 76e7eae10508e..4a1883233b605 100644
--- a/Detectors/HMPID/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/HMPID/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx b/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
index 5f09fd6c69a97..b2a1b6ce75591 100644
--- a/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
@@ -24,7 +24,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"runmft", VariantType::Bool, false, {"source detector is MFT (default ITS)"}},
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/MUON/MCH/Workflow/src/entropy-encoder-workflow.cxx b/Detectors/MUON/MCH/Workflow/src/entropy-encoder-workflow.cxx
index b5f371edfc759..c66365922233e 100644
--- a/Detectors/MUON/MCH/Workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/MUON/MCH/Workflow/src/entropy-encoder-workflow.cxx
@@ -118,7 +118,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/MUON/MID/Workflow/src/entropy-encoder-workflow.cxx b/Detectors/MUON/MID/Workflow/src/entropy-encoder-workflow.cxx
index 25b038190281a..a109250894ce9 100644
--- a/Detectors/MUON/MID/Workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/MUON/MID/Workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/PHOS/workflow/src/entropy-encoder-workflow.cxx b/Detectors/PHOS/workflow/src/entropy-encoder-workflow.cxx
index 41642cd026089..1fc827a5a7525 100644
--- a/Detectors/PHOS/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/PHOS/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/TOF/workflow/src/entropy-encoder-workflow.cxx b/Detectors/TOF/workflow/src/entropy-encoder-workflow.cxx
index 5cf882e2723d6..547b3235ca684 100644
--- a/Detectors/TOF/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/TOF/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/TPC/workflow/src/entropy-encoder-workflow.cxx b/Detectors/TPC/workflow/src/entropy-encoder-workflow.cxx
index c09eb193e0fbf..3256b875447a8 100644
--- a/Detectors/TPC/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/TPC/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}},
     ConfigParamSpec{"inputFromFile", VariantType::Bool, false, {"Expect COMPCLUSTERS from file"}}};
 
diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index 07b1c293bff98..f3d4d639ddfd2 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -71,7 +71,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"configFile", VariantType::String, "", {"configuration file for configurable parameters"}},
     {"filtered-input", VariantType::Bool, false, {"Filtered tracks, clusters input, prefix dataDescriptors with F"}},
     {"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}},
-    {"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    {"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     {"tpc-deadMap-sources", VariantType::Int, -1, {"Sources to consider for TPC dead channel map creation; -1=all, 0=deactivated"}},
     {"tpc-mc-time-gain", VariantType::Bool, false, {"use time gain calibration for MC (true) or for data (false)"}},
   };
diff --git a/Detectors/TRD/workflow/src/entropy-encoder-workflow.cxx b/Detectors/TRD/workflow/src/entropy-encoder-workflow.cxx
index 177f6e4913a26..dff3831cd78a5 100644
--- a/Detectors/TRD/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/TRD/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);
diff --git a/Detectors/ZDC/workflow/src/entropy-encoder-workflow.cxx b/Detectors/ZDC/workflow/src/entropy-encoder-workflow.cxx
index 9ab0e10098f43..6f73fa121244f 100644
--- a/Detectors/ZDC/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/ZDC/workflow/src/entropy-encoder-workflow.cxx
@@ -23,7 +23,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<ConfigParamSpec> options{
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    ConfigParamSpec{"ctf-dict", VariantType::String, "ccdb", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
+    ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
 
   std::swap(workflowOptions, options);

From d19919cf22ca9fb08dfd71502aa7f4b5e0c96705 Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Thu, 26 Feb 2026 12:28:48 +0100
Subject: [PATCH 1366/1764] [ALICE3] Change 'layoutOL' to 'layoutOT', update
 ALICE3/README with a config table (#15101)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* change 'layoutOL' to 'layoutOT' for consistency

* small updates of readme

* Update README.md

* Document specific detector setup for TRK

Added specific detector setup details and configurables for TRK detector.

---------

Co-authored-by: Igor Altsybeev <Igor.Altsybeev@cern.ch>
Co-authored-by: Nicolò Jacazio <nicolo.jacazio@cern.ch>
---
 Detectors/Upgrades/ALICE3/README.md           | 17 +++++++++++-----
 Detectors/Upgrades/ALICE3/TRK/README.md       | 20 ++++++++++++++++++-
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |  2 +-
 .../TRK/base/include/TRKBase/TRKBaseParam.h   |  4 ++--
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      |  6 +++---
 .../ALICE3/TRK/macros/test/run_test.sh        |  2 +-
 .../ALICE3/TRK/simulation/src/Detector.cxx    |  8 ++++----
 .../Upgrades/ALICE3/TRK/workflow/README.md    |  2 +-
 8 files changed, 43 insertions(+), 18 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/README.md b/Detectors/Upgrades/ALICE3/README.md
index 7e1e1c03718d8..23d45232b71c9 100644
--- a/Detectors/Upgrades/ALICE3/README.md
+++ b/Detectors/Upgrades/ALICE3/README.md
@@ -21,7 +21,7 @@ The specific modules for Run 5 are enabled by passing their their IDs to the `-m
 A list of the available DetIDs is reproted in the table below:
 
 | Detector ID | Detector description             |
-|-------------|----------------------------------|
+| ----------- | -------------------------------- |
 | `A3IP`      | Beam pipe                        |
 | `TRK`       | Barrel Tracker                   |
 | `TF3`       | Time Of Flight detectors         |
@@ -49,7 +49,7 @@ export ALICE3_MAGFIELD_MACRO=../ALICE3Field.C
 
 An exampling macro for a custom magnetic field is stored in `Detectors/Upgrades/macros/ALICE3Field.C`.
 
-### Run a simple simulation for run 5
+### Run a simple simulation for ALICE 3
 The simplest command to be run to test the simulation is working is:
 
 ```bash
@@ -61,13 +61,20 @@ To enable a specific set of modules, e.g. the beampipe and the TOFs one can spec
 ```bash
 o2-sim-run5 -n 10 -m A3IP TF3
 ```
+
+#### Specific detector setups
+
+Configurables for various sub-detectors are presented in the following Table:
+
+| Available options | Link to options                                                |
+| ----------------- | -------------------------------------------------------------- |
+| TKR               | [Link to TRK options](./TRK/README.md#specific-detector-setup) |
+
 ### Output of the simulation
 The simulation will produce a `o2sim_Hits<DetID>.root` file with a tree with the hits related to that detector.
-Currently, hits are produced for: `TRK`, `FT3`, and `TF3`.
-More detectors will be included.
 
 ## Reconstruction
 WIP
 
 ## Analysis
-WIP
\ No newline at end of file
+WIP
diff --git a/Detectors/Upgrades/ALICE3/TRK/README.md b/Detectors/Upgrades/ALICE3/TRK/README.md
index 44937fb3663a6..8b3a7984bb233 100644
--- a/Detectors/Upgrades/ALICE3/TRK/README.md
+++ b/Detectors/Upgrades/ALICE3/TRK/README.md
@@ -6,5 +6,23 @@
 
 This is top page for the TRK detector documentation.
 
+
+## Specific detector setup
+
+
+Configurables for various sub-detectors are presented in the following Table:
+
+| Subsystem          | Available options                                       | Comments                                                         |
+| ------------------ | ------------------------------------------------------- | ---------------------------------------------------------------- |
+| `TRKBase.layoutVD` | `kIRIS4` (default), `kIRISFullCyl`, `kIRIS5`, `kIRIS4a` | [link to definitions](./base/include/TRKBase/TRKBaseParam.h) |
+| `TRKBase.layoutML` | `kCylinder`, `kTurboStaves` (default), `kStaggered`     |                                                                  |
+| `TRKBase.layoutOT` | `kCylinder`, `kTurboStaves`, `kStaggered` (default)     |                                                                  |
+
+For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by
+```bash
+o2-sim-serial-run5 -n 1 -g pythia8hi -m A3IP TRK FT3 TF3 \
+  --configKeyValues "TRKBase.layoutVD=kIRISFullCyl;TRKBase.layoutML=kCylinder;TRKBase.layoutOL=kCylinder"
+```
+
 <!-- doxy
-/doxy -->
\ No newline at end of file
+/doxy -->
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index deec53950cd5f..bb1597f2967e4 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -223,7 +223,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   std::vector<float> mCacheRefAlphaMLOT; /// cache for sensor ref alpha ML and OT
 
   eLayout mLayoutML; // Type of segmentation for the middle layers
-  eLayout mLayoutOL; // Type of segmentation for the outer layers
+  eLayout mLayoutOT; // Type of segmentation for the outer layers
 
  private:
   static std::unique_ptr<o2::trk::GeometryTGeo> sInstance;
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index d5e11313c0f0c..f919839b7ed0a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -46,11 +46,11 @@ struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   eOverallGeom overallGeom = kDefaultRadii; // Overall geometry option, to be used in Detector::buildTRKMiddleOuterLayers
 
   eLayout layoutML = kTurboStaves; // Type of segmentation for the middle layers
-  eLayout layoutOL = kStaggered;   // Type of segmentation for the outer layers
+  eLayout layoutOT = kStaggered;   // Type of segmentation for the outer layers
   eVDLayout layoutVD = kIRIS4;     // VD detector layout design
 
   eLayout getLayoutML() const { return layoutML; }
-  eLayout getLayoutOL() const { return layoutOL; }
+  eLayout getLayoutOT() const { return layoutOT; }
   eVDLayout getLayoutVD() const { return layoutVD; }
 
   O2ParamDef(TRKBaseParam, "TRKBase");
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index d5d37ec00acef..b5535af781910 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -77,9 +77,9 @@ void GeometryTGeo::Build(int loadTrans)
   }
 
   mLayoutML = o2::trk::TRKBaseParam::Instance().getLayoutML();
-  mLayoutOL = o2::trk::TRKBaseParam::Instance().getLayoutOL();
+  mLayoutOT = o2::trk::TRKBaseParam::Instance().getLayoutOT();
 
-  LOG(debug) << "Layout ML: " << mLayoutML << ", Layout OL: " << mLayoutOL;
+  LOG(debug) << "Layout ML: " << mLayoutML << ", Layout OL: " << mLayoutOT;
 
   mNumberOfLayersMLOT = extractNumberOfLayersMLOT();
   mNumberOfPetalsVD = extractNumberOfPetalsVD();
@@ -405,7 +405,7 @@ TString GeometryTGeo::getMatrixPath(int index) const
   // handling cylindrical configuration for ML and/or OT
   // needed bercause of the different numbering scheme in the geometry for the cylindrical case wrt the staggered and turbo ones
   if (subDetID == 1) {
-    if ((layer < 4 && mLayoutML == eLayout::kCylinder) || (layer > 3 && mLayoutOL == eLayout::kCylinder)) {
+    if ((layer < 4 && mLayoutML == eLayout::kCylinder) || (layer > 3 && mLayoutOT == eLayout::kCylinder)) {
       stave = 1;
       mod = 1;
       chip = 1;
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/run_test.sh b/Detectors/Upgrades/ALICE3/TRK/macros/test/run_test.sh
index 797d1d12af4ab..d0953a342af04 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/run_test.sh
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/run_test.sh
@@ -2,7 +2,7 @@
 nEvents=10
 
 # Simulating
-o2-sim-serial-run5 -n $nEvents -g pythia8hi -m TRK --configKeyValues "TRKBase.layoutML=kTurboStaves;TRKBase.layoutOL=kStaggered;">& sim_TRK.log
+o2-sim-serial-run5 -n $nEvents -g pythia8hi -m TRK --configKeyValues "TRKBase.layoutML=kTurboStaves;TRKBase.layoutOT=kStaggered;">& sim_TRK.log
 
 # Digitizing
 o2-sim-digitizer-workflow -b >& digiTRK.log
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 556b016f22553..a2629a101d2d0 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -146,10 +146,10 @@ void Detector::buildTRKMiddleOuterLayers()
   mLayers[3].setLayout(trkPars.layoutML);
 
   // Outer tracker
-  mLayers[4].setLayout(trkPars.layoutOL);
-  mLayers[5].setLayout(trkPars.layoutOL);
-  mLayers[6].setLayout(trkPars.layoutOL);
-  mLayers[7].setLayout(trkPars.layoutOL);
+  mLayers[4].setLayout(trkPars.layoutOT);
+  mLayers[5].setLayout(trkPars.layoutOT);
+  mLayers[6].setLayout(trkPars.layoutOT);
+  mLayers[7].setLayout(trkPars.layoutOT);
 }
 
 void Detector::configFromFile(std::string fileName)
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/README.md b/Detectors/Upgrades/ALICE3/TRK/workflow/README.md
index afb30ed6dbdd3..1cdce15b72726 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/README.md
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/README.md
@@ -98,7 +98,7 @@ Note that the `trackingparams` field can contain multiple sets of parameters for
 First, generate simulation data:
 
 ```bash
-o2-sim-serial-run5 -n 200 -g pythia8hi -m TRK --configKeyValues "Diamond.width[0]=0.01;Diamond.width[1]=0.01;Diamond.width[2]=5;TRKBase.layoutML=kTurboStaves;TRKBase.layoutOL=kStaggered;"
+o2-sim-serial-run5 -n 200 -g pythia8hi -m TRK --configKeyValues "Diamond.width[0]=0.01;Diamond.width[1]=0.01;Diamond.width[2]=5;TRKBase.layoutML=kTurboStaves;TRKBase.layoutOT=kStaggered;"
 ```
 
 This produces, among other files:

From e59f5cb62c966c99b230eb37d6077f66b72b815c Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Fri, 27 Feb 2026 00:00:16 +0100
Subject: [PATCH 1367/1764] [ALICE3] TRK: fix extrusions and overlaps b/n
 staves (#15105)

---
 .../include/TRKSimulation/TRKLayer.h          | 19 ++++++++++++-------
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx    | 15 +++++----------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
index 0a7a45e87bfd8..39dd7752cc010 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
@@ -51,21 +51,26 @@ class TRKLayer
 
  private:
   // TGeo objects outside logical volumes can cause errors. Only used in case of kStaggered and kTurboStaves layouts
-  static constexpr float mLogicalVolumeThickness = 1;
+  static constexpr float mLogicalVolumeThickness = 1.3;
 
+  // User defined parameters for the layer, to be set in the constructor
   int mLayerNumber;
-  eLayout mLayout;
   std::string mLayerName;
   float mInnerRadius;
   float mOuterRadius;
   int mNumberOfModules;
   float mX2X0;
-  float mChipWidth;
-  float mChipLength;
   float mChipThickness;
-  float mDeadzoneWidth;
-  float mSensorThickness;
-  int mHalfNumberOfChips;
+
+  // Fixed parameters for the layer, to be set based on the specifications of the chip and module
+  eLayout mLayout = kCylinder;
+  float mChipWidth = constants::moduleMLOT::chip::width;
+  float mChipLength = constants::moduleMLOT::chip::length;
+  float mDeadzoneWidth = constants::moduleMLOT::chip::passiveEdgeReadOut;
+  float mSensorThickness = constants::moduleMLOT::silicon::thickness;
+  int mHalfNumberOfChips = 4;
+
+  static constexpr float Si_X0 = 9.5f;
 
   ClassDef(TRKLayer, 2);
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index 82b6fbd40af59..53cc6ab11850d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -26,17 +26,15 @@ namespace o2
 namespace trk
 {
 TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float rOut, int numberOfModules, float layerX2X0)
-  : mLayerNumber(layerNumber), mLayout(kCylinder), mLayerName(layerName), mInnerRadius(rInn), mOuterRadius(rOut), mNumberOfModules(numberOfModules), mX2X0(layerX2X0), mChipWidth(constants::moduleMLOT::chip::width), mChipLength(constants::moduleMLOT::chip::length), mDeadzoneWidth(constants::moduleMLOT::chip::passiveEdgeReadOut), mSensorThickness(constants::moduleMLOT::silicon::thickness), mHalfNumberOfChips(4)
+  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mOuterRadius(rOut), mNumberOfModules(numberOfModules), mX2X0(layerX2X0)
 {
-  float Si_X0 = 9.5f;
   mChipThickness = mX2X0 * Si_X0;
   LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, getZ(), mX2X0);
 }
 
 TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thick)
-  : mLayerNumber(layerNumber), mLayout(kCylinder), mLayerName(layerName), mInnerRadius(rInn), mNumberOfModules(numberOfModules), mChipThickness(thick), mChipWidth(constants::moduleMLOT::chip::width), mChipLength(constants::moduleMLOT::chip::length), mDeadzoneWidth(constants::moduleMLOT::chip::passiveEdgeReadOut), mSensorThickness(constants::moduleMLOT::silicon::thickness), mHalfNumberOfChips(4)
+  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mNumberOfModules(numberOfModules), mChipThickness(thick)
 {
-  float Si_X0 = 9.5f;
   mOuterRadius = rInn + thick;
   mX2X0 = mChipThickness / Si_X0;
   LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, getZ(), mX2X0);
@@ -300,12 +298,9 @@ TGeoVolume* TRKLayer::createStave(std::string type)
   } else if (type == "staggered") {
     double overlap = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true)overlap
     double shift = overlap / 2;
-
     double halfstaveWidth = constants::OT::halfstave::width;
-    double staveWidth = constants::OT::width - overlap;
 
-    stave = new TGeoBBox(staveWidth / 2, mLogicalVolumeThickness / 2, staveLength / 2);
-    staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
+    staveVol = new TGeoVolumeAssembly(staveName.c_str());
 
     // Put the half staves in the correct position
     TGeoVolume* halfStaveVolLeft = createHalfStave("flat");
@@ -379,7 +374,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       // Put the staves in the correct position and orientation
       TGeoCombiTrans* trans = new TGeoCombiTrans();
       double theta = 360. * iStave / nStaves;
-      TGeoRotation* rot = new TGeoRotation("rot", theta - 90 + 3, 0, 0);
+      TGeoRotation* rot = new TGeoRotation("rot", theta - 90 + 4, 0, 0);
       trans->SetRotation(rot);
       trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
 
@@ -413,7 +408,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       // Put the staves in the correct position and orientation
       TGeoCombiTrans* trans = new TGeoCombiTrans();
       double theta = 360. * iStave / nStaves;
-      TGeoRotation* rot = new TGeoRotation("rot", theta - 90 + 3, 0, 0);
+      TGeoRotation* rot = new TGeoRotation("rot", theta - 90, 0, 0);
       trans->SetRotation(rot);
       trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
 

From eedf394f1e426515d02297fe43afdf85d1425b3d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Fri, 27 Feb 2026 16:22:28 +0200
Subject: [PATCH 1368/1764] [ALICE3] Update README.md with additional detector
 options (#15106)

* Update README.md with additional detector options

* Add files via upload
---
 Detectors/Upgrades/ALICE3/IOTOF/README.md | 36 +++++++++++++++++++++++
 Detectors/Upgrades/ALICE3/README.md       |  7 +++--
 2 files changed, 40 insertions(+), 3 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/README.md

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/README.md b/Detectors/Upgrades/ALICE3/IOTOF/README.md
new file mode 100644
index 0000000000000..044798076b485
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/README.md
@@ -0,0 +1,36 @@
+<!-- doxy
+\page refDetectorsUpgradesALICE3IOTOF TOF
+/doxy -->
+
+# ALICE 3 TOF system
+
+This is top page for the TOF detector documentation.
+
+
+## Specific detector setup
+
+
+Configurables for various sub-detectors are presented in the following Table:
+
+[link to definitions](./base/include/IOTOFBase/IOTOFBaseParam.h)
+
+| Options                       | Choices                                                          | Comments                                    |
+| ----------------------------- | ---------------------------------------------------------------- | ------------------------------------------- |
+| `IOTOFBase.enableInnerTOF`    | `true` (default), `false`                                        | Enable inner TOF barrel layer               |
+| `IOTOFBase.enableOuterTOF`    | `true` (default), `false`                                        | Enable outer TOF barrel layer               |
+| `IOTOFBase.enableForwardTOF`  | `true` (default), `false`                                        | Enable forward TOF endcap                   |
+| `IOTOFBase.enableBackwardTOF` | `true` (default), `false`                                        | Enable backward TOF endcap                  |
+| `IOTOFBase.segmentedInnerTOF` | `false` (default), `true`                                        | Use segmented geometry for inner TOF        |
+| `IOTOFBase.segmentedOuterTOF` | `false` (default), `true`                                        | Use segmented geometry for outer TOF        |
+| `IOTOFBase.detectorPattern`   | ` ` (default), `v3b`, `v3b1a`, `v3b1b`, `v3b2a`, `v3b2b`, `v3b3` | Optional layout pattern                     |
+| ----------------------------- | -------------------------                                        | ------------------------------------------- |
+
+
+For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by
+```bash
+o2-sim-serial-run5 -n 1 -g pythia8hi -m A3IP  TF3 \
+  --configKeyValues "IOTOFBase.detectorPattern=v3b1a;IOTOFBase.segmentedInnerTOF=true;IOTOFBase.segmentedOuterTOF=true;FT3Base.geoModel=1;FT3Base.nLayers=1;IOTOFBase.enableOuterTOF=false;IOTOFBase.enableBackwardTOF=false;IOTOFBase.enableForwardTOF=false;"
+```
+
+<!-- doxy
+/doxy -->
diff --git a/Detectors/Upgrades/ALICE3/README.md b/Detectors/Upgrades/ALICE3/README.md
index 23d45232b71c9..44a478b592882 100644
--- a/Detectors/Upgrades/ALICE3/README.md
+++ b/Detectors/Upgrades/ALICE3/README.md
@@ -66,9 +66,10 @@ o2-sim-run5 -n 10 -m A3IP TF3
 
 Configurables for various sub-detectors are presented in the following Table:
 
-| Available options | Link to options                                                |
-| ----------------- | -------------------------------------------------------------- |
-| TKR               | [Link to TRK options](./TRK/README.md#specific-detector-setup) |
+| Available options | Link to options                                                  |
+| ----------------- | ---------------------------------------------------------------- |
+| TRK               | [Link to TRK options](./TRK/README.md#specific-detector-setup)   |
+| TOF               | [Link to TOF options](./IOTOF/README.md#specific-detector-setup) |
 
 ### Output of the simulation
 The simulation will produce a `o2sim_Hits<DetID>.root` file with a tree with the hits related to that detector.

From f4f4d35ae108b8b1bf7e1d82e9f004bb69700a3b Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 26 Feb 2026 12:29:33 +0100
Subject: [PATCH 1369/1764] DPL: clean up leftovers from input stream after
 parsing a workflow

---
 .../Core/src/WorkflowSerializationHelpers.cxx      | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/WorkflowSerializationHelpers.cxx b/Framework/Core/src/WorkflowSerializationHelpers.cxx
index e20e23f98c90b..9624a2dfd0d3e 100644
--- a/Framework/Core/src/WorkflowSerializationHelpers.cxx
+++ b/Framework/Core/src/WorkflowSerializationHelpers.cxx
@@ -29,6 +29,7 @@
 #include <memory>
 
 O2_DECLARE_DYNAMIC_LOG(workflow_importer);
+O2_DECLARE_DYNAMIC_LOG(post_workflow_importer);
 
 namespace o2::framework
 {
@@ -969,7 +970,18 @@ bool WorkflowSerializationHelpers::import(std::istream& s,
   WorkflowImporter importer{workflow, metadata, command};
   bool ok = reader.Parse(isw, importer);
   if (ok == false) {
-    throw std::runtime_error("Error while parsing serialised workflow");
+    if (s.eof()) {
+      throw std::runtime_error("Error while parsing serialised workflow");
+    }
+    // clean up possible leftovers at the end of the input stream, e.g. [DEBUG] message from destructors
+    O2_SIGNPOST_ID_GENERATE(sid, post_workflow_importer);
+    while (true) {
+      s.getline(buf, 1024, '\n');
+      if (s.eof()) {
+        break;
+      }
+      O2_SIGNPOST_EVENT_EMIT(post_workflow_importer, sid, "post import", "Following leftover line found in input stream after parsing workflow: %{public}s", buf);
+    }
   }
   return true;
 }

From 497abe03821aad1de722f6c5889fe9e0bc338441 Mon Sep 17 00:00:00 2001
From: Kangkan Goswami <kangkan.goswami@cern.ch>
Date: Sat, 28 Feb 2026 20:21:39 +0530
Subject: [PATCH 1370/1764] Integrate TRD extra data support in AOD production
 workflow (#15108)

* Add TRD support and local gain/noise handling in AODProducerWorkflowSpec

This commit enables the workflow to process TRD-specific calibration and noise information, allowing for more accurate reconstruction and analysis of TRD signals in AOD production.

* Implement TRD extra data processing in AODProducerWorkflowSpec.cxx

This commit enables the workflow to generate TRD-specific extra tables in the AOD, applying calibration and noise corrections to improve reconstruction fidelity for TRD tracks.

* Add TRD extra configuration option to AOD producer workflow

This change allows users to enable or disable TRD extra output at runtime via workflow configuration, integrating TRD processing into the AOD production workflow.

* Refactor TRD dynamic columns and define TRDsExtra SOA table in AnalysisDataModel.h

This update to AnalysisDataModel.h standardizes TRD-related naming and introduces a dedicated SOA table for TRD extra data, allowing calibrated and corrected TRD quantities to be stored within the AOD framework.

* fix TRD extra information

* clang format

* Adjust TRD logic after rebase

* Please consider the following formatting changes

---------

Co-authored-by: Gauthier Legras <gauthier.legras@orange.fr>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../AODProducerWorkflowSpec.h                 |  20 ++-
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 155 +++++++++++++++++-
 Detectors/AOD/src/aod-producer-workflow.cxx   |   4 +-
 .../include/Framework/AnalysisDataModel.h     |  29 +++-
 4 files changed, 193 insertions(+), 15 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 2c58db42ed856..588cd575ee7f5 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -19,6 +19,10 @@
 #include "DataFormatsGlobalTracking/RecoContainer.h"
 #include "DataFormatsPHOS/Cell.h"
 #include "DataFormatsTRD/TrackTRD.h"
+#include "TRDBase/PadCalibrationsAliases.h"
+#include "DataFormatsTRD/NoiseCalibration.h"
+#include "DataFormatsTRD/CalGain.h"
+#include "DataFormatsTRD/Constants.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "DetectorsBase/Propagator.h"
 #include "Framework/DataProcessorSpec.h"
@@ -215,7 +219,7 @@ enum struct AODProducerStreamerFlags : uint8_t {
 class AODProducerWorkflowDPL : public Task
 {
  public:
-  AODProducerWorkflowDPL(GID::mask_t src, std::shared_ptr<DataRequest> dataRequest, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool enableSV, bool useMC = true, bool enableFITextra = false) : mUseMC(useMC), mEnableSV(enableSV), mEnableFITextra(enableFITextra), mInputSources(src), mDataRequest(dataRequest), mGGCCDBRequest(gr) {}
+  AODProducerWorkflowDPL(GID::mask_t src, std::shared_ptr<DataRequest> dataRequest, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool enableSV, bool useMC = true, bool enableFITextra = false, bool enableTRDextra = false) : mUseMC(useMC), mEnableSV(enableSV), mEnableFITextra(enableFITextra), mEnableTRDextra(enableTRDextra), mInputSources(src), mDataRequest(dataRequest), mGGCCDBRequest(gr) {}
   ~AODProducerWorkflowDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -250,6 +254,10 @@ class AODProducerWorkflowDPL : public Task
   o2::dataformats::MeanVertexObject mVtx;
   float mMaxPropXiu{5.0f}; // max X_IU for which track is to be propagated if mPropTracks is true. (other option: o2::constants::geom::XTPCInnerRef + 0.1f)
 
+  const o2::trd::LocalGainFactor* mTRDLocalGain; // TRD local gain factors from krypton calibration
+  const o2::trd::CalGain* mTRDGainCalib;         // TRD time-dependent gain calib at chamber level
+  const o2::trd::NoiseStatusMCM* mTRDNoiseMap;   // TRD noise map
+
   std::unordered_set<GIndex> mGIDUsedBySVtx;
   std::unordered_set<GIndex> mGIDUsedByStr;
 
@@ -261,6 +269,7 @@ class AODProducerWorkflowDPL : public Task
   bool mUseSigFiltMC = false; // enable signal filtering for MC with embedding
   bool mEnableSV = true; // enable secondary vertices
   bool mEnableFITextra = false;
+  bool mEnableTRDextra = false;
   bool mFieldON = false;
   const float cSpeed = 0.029979246f; // speed of light in TOF units
 
@@ -278,6 +287,7 @@ class AODProducerWorkflowDPL : public Task
   TStopwatch mTimer;
   bool mEMCselectLeading{false};
   uint64_t mEMCALTrgClassMask = 0;
+  size_t mCurrentTRDTrigID = 0; // current index of the TRD trigger record, to speed up search
 
   // unordered map connects global indices and table indices of barrel tracks
   std::unordered_map<GIndex, int> mGIDToTableID;
@@ -525,6 +535,9 @@ class AODProducerWorkflowDPL : public Task
   template <typename TracksQACursorType>
   void addToTracksQATable(TracksQACursorType& tracksQACursor, TrackQA& trackQAInfoHolder);
 
+  template <typename TRDsExtraCursorType>
+  void addToTRDsExtra(const o2::globaltracking::RecoContainer& recoData, TRDsExtraCursorType& trdExtraCursor, const GIndex& trkIdx, int trkTableIdx);
+
   template <typename mftTracksCursorType, typename AmbigMFTTracksCursorType>
   void addToMFTTracksTable(mftTracksCursorType& mftTracksCursor, AmbigMFTTracksCursorType& ambigMFTTracksCursor,
                            GIndex trackID, const o2::globaltracking::RecoContainer& data, int collisionID,
@@ -544,7 +557,7 @@ class AODProducerWorkflowDPL : public Task
   // helper for track tables
   // * fills tables collision by collision
   // * interaction time is for TOF information
-  template <typename TracksCursorType, typename TracksCovCursorType, typename TracksExtraCursorType, typename TracksQACursorType, typename AmbigTracksCursorType,
+  template <typename TracksCursorType, typename TracksCovCursorType, typename TracksExtraCursorType, typename TracksQACursorType, typename TRDsExtraCursorType, typename AmbigTracksCursorType,
             typename MFTTracksCursorType, typename MFTTracksCovCursorType, typename AmbigMFTTracksCursorType,
             typename FwdTracksCursorType, typename FwdTracksCovCursorType, typename AmbigFwdTracksCursorType, typename FwdTrkClsCursorType>
   void fillTrackTablesPerCollision(int collisionID,
@@ -556,6 +569,7 @@ class AODProducerWorkflowDPL : public Task
                                    TracksCovCursorType& tracksCovCursor,
                                    TracksExtraCursorType& tracksExtraCursor,
                                    TracksQACursorType& tracksQACursor,
+                                   TRDsExtraCursorType& trdsExtraCursor,
                                    AmbigTracksCursorType& ambigTracksCursor,
                                    MFTTracksCursorType& mftTracksCursor,
                                    MFTTracksCovCursorType& mftTracksCovCursor,
@@ -680,7 +694,7 @@ class AODProducerWorkflowDPL : public Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, bool enableST, bool useMC, bool CTPConfigPerRun, bool enableFITextra);
+framework::DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, bool enableST, bool useMC, bool CTPConfigPerRun, bool enableFITextra, bool enableTRDextra);
 
 // helper interface for calo cells to "befriend" emcal and phos cells
 class CellHelper
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 852419a9895eb..fcb419d6c441b 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -33,7 +33,6 @@
 #include "DataFormatsPHOS/TriggerRecord.h"
 #include "DataFormatsPHOS/EventHandler.h"
 #include "DataFormatsTPC/TrackTPC.h"
-#include "DataFormatsTRD/TriggerRecord.h"
 #include "DataFormatsZDC/BCRecData.h"
 #include "DataFormatsZDC/ZDCEnergy.h"
 #include "DataFormatsZDC/ZDCTDCData.h"
@@ -45,6 +44,9 @@
 #include "CommonDataFormat/InteractionRecord.h"
 #include "DataFormatsTRD/TrackTRD.h"
 #include "DataFormatsTRD/TrackTriggerRecord.h"
+#include "DataFormatsTRD/CalibratedTracklet.h"
+#include "DataFormatsTRD/TriggerRecord.h"
+#include "DataFormatsTRD/Tracklet64.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
 #include "Framework/AnalysisDataModel.h"
 #include "Framework/ConfigParamRegistry.h"
@@ -390,6 +392,121 @@ void AODProducerWorkflowDPL::addToTracksQATable(TracksQACursorType& tracksQACurs
     mTrackQCRetainOnlydEdx ? std::numeric_limits<int8_t>::min() : trackQAInfoHolder.dTofdZ);
 }
 
+template <typename TRDsExtraCursorType>
+void AODProducerWorkflowDPL::addToTRDsExtra(const o2::globaltracking::RecoContainer& recoData, TRDsExtraCursorType& trdExtraCursor, const GIndex& trkIdx, int trkTableIdx)
+{
+  int q0s[6] = {-1}, q1s[6] = {-1}, q2s[6] = {-1};
+  float q0sCor[6] = {-1}, q1sCor[6] = {-1}, q2sCor[6] = {-1};
+  float ttgls[6] = {-999}, tphis[6] = {-999};
+
+  auto contributorsGID = recoData.getSingleDetectorRefs(trkIdx);
+  if (!contributorsGID[GIndex::Source::TRD].isIndexSet()) { // should be redunant
+    return;
+  }
+  const auto& trk = recoData.getTrack<o2::trd::TrackTRD>(contributorsGID[GIndex::Source::TRD]);
+  o2::track::TrackPar trkC{contributorsGID[GIndex::Source::ITSTPC].isIndexSet() ? recoData.getTPCITSTrack(contributorsGID[GIndex::Source::ITSTPC]).getParamOut() : recoData.getTPCTrack(contributorsGID[GIndex::Source::TPC]).getParamOut()};
+  const auto& trklets = recoData.getTRDTracklets();
+  const auto& ctrklets = recoData.getTRDCalibratedTracklets();
+  for (int iLay{0}; iLay < 6; ++iLay) {
+    q0s[iLay] = q1s[iLay] = q2s[iLay] = -1;
+    q0sCor[iLay] = q1sCor[iLay] = q2sCor[iLay] = -1;
+    tphis[iLay] = ttgls[iLay] = -999;
+    auto trkltId = trk.getTrackletIndex(iLay);
+    if (trkltId < 0) {
+      continue;
+    }
+    const auto& tracklet = trklets[trkltId];
+    if (mTRDNoiseMap->isTrackletFromNoisyMCM(tracklet)) {
+      continue;
+    }
+    // we need to propagate into TRD local system
+    int trkltDet = tracklet.getDetector();
+    int trkltSec = trkltDet / 30;
+    if (trkltSec != o2::math_utils::angle2Sector(trkC.getAlpha())) {
+      if (!trkC.rotate(o2::math_utils::sector2Angle(trkltSec))) {
+        break;
+      }
+    }
+    if (!o2::base::Propagator::Instance()->PropagateToXBxByBz(trkC, ctrklets[trkltId].getX(), o2::base::Propagator::MAX_SIN_PHI, o2::base::Propagator::MAX_STEP, mMatCorr)) {
+      break;
+    }
+
+    auto tphi = trkC.getSnp() / std::sqrt((1.f - trkC.getSnp()) * (1.f + trkC.getSnp()));
+    auto trackletLength = std::sqrt(1.f + tphi * tphi + trkC.getTgl() * trkC.getTgl());
+    float cor = mTRDLocalGain->getValue(tracklet.getHCID() / 2, tracklet.getPadCol(), tracklet.getPadRow()) * mTRDGainCalib->getMPVdEdx(tracklet.getDetector()) / o2::trd::constants::MPVDEDXDEFAULT * trackletLength;
+    q0s[iLay] = tracklet.getQ0();
+    q1s[iLay] = tracklet.getQ1();
+    q2s[iLay] = tracklet.getQ2();
+    q0sCor[iLay] = (float)tracklet.getQ0() / cor;
+    q1sCor[iLay] = (float)tracklet.getQ1() / cor;
+    q2sCor[iLay] = (float)tracklet.getQ2() / cor;
+    ttgls[iLay] = trkC.getTgl();
+    tphis[iLay] = tphi;
+
+    // z-row merging, we want to merge only with tracklets from the same trigger record
+    if (trk.getIsCrossingNeighbor(iLay) && trk.getHasNeighbor()) {
+      // find the trigger the tracklet belongs to
+      auto trigsTRD = recoData.getTRDTriggerRecords();
+      size_t trdSelID = -1;
+
+      const auto& trig = trigsTRD[mCurrentTRDTrigID];
+      bool foundTRDTrigger = false;
+      // first check current trigger
+      if (trkltId >= trig.getFirstTracklet() && trkltId < trig.getFirstTracklet() + trig.getNumberOfTracklets()) {
+        trdSelID = mCurrentTRDTrigID;
+        foundTRDTrigger = true;
+      } else {
+        // then check next trigger
+        if (mCurrentTRDTrigID < trigsTRD.size() - 1) {
+          const auto& trig = trigsTRD[mCurrentTRDTrigID + 1];
+          if (trkltId >= trig.getFirstTracklet() && trkltId < trig.getFirstTracklet() + trig.getNumberOfTracklets()) {
+            trdSelID = mCurrentTRDTrigID + 1;
+            foundTRDTrigger = true;
+          }
+        }
+      }
+
+      size_t low = 0, up = trigsTRD.size() - 1;
+
+      // otherwise binary search
+      while (low <= up && !foundTRDTrigger) {
+        trdSelID = low + std::floor((up - low) / 2);
+        const auto& trig = trigsTRD[trdSelID];
+        if (trig.getFirstTracklet() > trkltId) {
+          up = trdSelID - 1;
+        } else {
+          if (trig.getFirstTracklet() + trig.getNumberOfTracklets() <= trkltId) {
+            low = trdSelID + 1;
+          } else {
+            foundTRDTrigger = true;
+          }
+        }
+      }
+      //-------------------
+      mCurrentTRDTrigID = trdSelID;
+      const auto& trigSel = trigsTRD[trdSelID];
+
+      // loop on other tracklets from the same trigger record
+      for (const auto& trklt : trklets.subspan(trigSel.getFirstTracklet(), trigSel.getNumberOfTracklets())) {
+        if (tracklet.getTrackletWord() == trklt.getTrackletWord() || tracklet.getDetector() != trklt.getDetector()) {
+          continue;
+        }
+        if (std::abs(tracklet.getPadCol() - trklt.getPadCol()) <= 1 && std::abs(tracklet.getPadRow() - trklt.getPadRow()) == 1) {
+          cor = mTRDLocalGain->getValue(trklt.getHCID() / 2, trklt.getPadCol(), trklt.getPadRow()) * mTRDGainCalib->getMPVdEdx(tracklet.getDetector()) / o2::trd::constants::MPVDEDXDEFAULT * trackletLength;
+          q0s[iLay] += trklt.getQ0();
+          q1s[iLay] += trklt.getQ1();
+          q2s[iLay] += trklt.getQ2();
+          q0sCor[iLay] += (float)trklt.getQ0() / cor;
+          q1sCor[iLay] += (float)trklt.getQ1() / cor;
+          q2sCor[iLay] += (float)trklt.getQ2() / cor;
+        }
+      }
+    }
+  }
+
+  trdExtraCursor(trkTableIdx, q0s, q1s, q2s, q0sCor, q1sCor, q2sCor, ttgls, tphis);
+}
+
 template <typename mftTracksCursorType, typename AmbigMFTTracksCursorType>
 void AODProducerWorkflowDPL::addToMFTTracksTable(mftTracksCursorType& mftTracksCursor, AmbigMFTTracksCursorType& ambigMFTTracksCursor,
                                                  GIndex trackID, const o2::globaltracking::RecoContainer& data, int collisionID,
@@ -430,8 +547,7 @@ void AODProducerWorkflowDPL::addToMFTTracksTable(mftTracksCursorType& mftTracksC
     ambigMFTTracksCursor(mTableTrMFTID, bcSlice);
   }
 }
-
-template <typename TracksCursorType, typename TracksCovCursorType, typename TracksExtraCursorType, typename TracksQACursorType, typename AmbigTracksCursorType,
+template <typename TracksCursorType, typename TracksCovCursorType, typename TracksExtraCursorType, typename TracksQACursorType, typename TRDsExtraCursor, typename AmbigTracksCursorType,
           typename MFTTracksCursorType, typename MFTTracksCovCursorType, typename AmbigMFTTracksCursorType,
           typename FwdTracksCursorType, typename FwdTracksCovCursorType, typename AmbigFwdTracksCursorType, typename FwdTrkClsCursorType>
 void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
@@ -443,6 +559,7 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
                                                          TracksCovCursorType& tracksCovCursor,
                                                          TracksExtraCursorType& tracksExtraCursor,
                                                          TracksQACursorType& tracksQACursor,
+                                                         TRDsExtraCursor& trdsExtraCursor,
                                                          AmbigTracksCursorType& ambigTracksCursor,
                                                          MFTTracksCursorType& mftTracksCursor,
                                                          MFTTracksCovCursorType& mftTracksCovCursor,
@@ -553,7 +670,9 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
             addToTracksTable(tracksCursor, tracksCovCursor, trOrig, collisionID, aod::track::TrackIU);
           }
           addToTracksExtraTable(tracksExtraCursor, extraInfoHolder);
-
+          if (mEnableTRDextra && trackIndex.includesDet(GIndex::Source::TRD)) {
+            addToTRDsExtra(data, trdsExtraCursor, trackIndex, mTableTrID);
+          }
           //  collecting table indices of barrel tracks for V0s table
           if (extraInfoHolder.bcSlice[0] >= 0 && collisionID < 0) {
             ambigTracksCursor(mTableTrID, extraInfoHolder.bcSlice);
@@ -1934,6 +2053,12 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
   auto cpvClustersCursor = createTableCursor<o2::aod::CPVClusters>(pc);
   auto originCursor = createTableCursor<o2::aod::Origins>(pc);
 
+  /// Extra tables
+  o2::framework::Produces<o2::aod::TRDsExtra> trdExtraCursor;
+  if (mEnableTRDextra) {
+    trdExtraCursor = createTableCursor<o2::aod::TRDsExtra>(pc);
+  }
+
   // Declare MC cursors type without adding the output for a table
   o2::framework::Produces<o2::aod::McCollisionLabels> mcColLabelsCursor;
   o2::framework::Produces<o2::aod::McCollisions> mcCollisionsCursor;
@@ -2294,14 +2419,16 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
     }
   }
 
+  mCurrentTRDTrigID = 0; // reinitialize index for TRD trigger record search
   // filling unassigned tracks first
   // so that all unassigned tracks are stored in the beginning of the table together
   auto& trackRef = primVer2TRefs.back(); // references to unassigned tracks are at the end
   // fixme: interaction time is undefined for unassigned tracks (?)
-  fillTrackTablesPerCollision(-1, std::uint64_t(-1), trackRef, primVerGIs, recoData, tracksCursor, tracksCovCursor, tracksExtraCursor, tracksQACursor,
+  fillTrackTablesPerCollision(-1, std::uint64_t(-1), trackRef, primVerGIs, recoData, tracksCursor, tracksCovCursor, tracksExtraCursor, tracksQACursor, trdExtraCursor,
                               ambigTracksCursor, mftTracksCursor, mftTracksCovCursor, ambigMFTTracksCursor,
                               fwdTracksCursor, fwdTracksCovCursor, ambigFwdTracksCursor, fwdTrkClsCursor, bcsMap);
 
+  mCurrentTRDTrigID = 0; // reinitialize index for TRD trigger record search
   // filling collisions and tracks into tables
   collisionID = 0;
   collisionsCursor.reserve(primVertices.size());
@@ -2340,7 +2467,7 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
 
     auto& trackRef = primVer2TRefs[collisionID];
     // passing interaction time in [ps]
-    fillTrackTablesPerCollision(collisionID, globalBC, trackRef, primVerGIs, recoData, tracksCursor, tracksCovCursor, tracksExtraCursor, tracksQACursor, ambigTracksCursor,
+    fillTrackTablesPerCollision(collisionID, globalBC, trackRef, primVerGIs, recoData, tracksCursor, tracksCovCursor, tracksExtraCursor, tracksQACursor, trdExtraCursor, ambigTracksCursor,
                                 mftTracksCursor, mftTracksCovCursor, ambigMFTTracksCursor,
                                 fwdTracksCursor, fwdTracksCovCursor, ambigFwdTracksCursor, fwdTrkClsCursor, bcsMap);
     collisionID++;
@@ -3011,6 +3138,11 @@ void AODProducerWorkflowDPL::updateTimeDependentParams(ProcessingContext& pc)
     mFieldON = std::abs(o2::base::Propagator::Instance()->getNominalBz()) > 0.01;
 
     pc.inputs().get<o2::ctp::CTPConfiguration*>("ctpconfig");
+    if (mEnableTRDextra) {
+      mTRDLocalGain = pc.inputs().get<o2::trd::LocalGainFactor*>("trdlocalgainfactors").get();
+      mTRDNoiseMap = pc.inputs().get<o2::trd::NoiseStatusMCM*>("trdnoisemap").get();
+      mTRDGainCalib = pc.inputs().get<o2::trd::CalGain*>("trdgaincalib").get(); // time dependent gain
+    }
   }
   if (mPropTracks) {
     pc.inputs().get<o2::dataformats::MeanVertexObject*>("meanvtx");
@@ -3222,7 +3354,7 @@ void AODProducerWorkflowDPL::endOfStream(EndOfStreamContext& /*ec*/)
   mStreamer.reset();
 }
 
-DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, bool enableStrangenessTracking, bool useMC, bool CTPConfigPerRun, bool enableFITextra)
+DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, bool enableStrangenessTracking, bool useMC, bool CTPConfigPerRun, bool enableFITextra, bool enableTRDextra)
 {
   auto dataRequest = std::make_shared<DataRequest>();
   dataRequest->inputs.emplace_back("ctpconfig", "CTP", "CTPCONFIG", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/Config", CTPConfigPerRun));
@@ -3313,6 +3445,13 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
     OutputSpec{"TFF", "TFFilename"},
     OutputSpec{"AMD", "AODMetadataKeys"},
     OutputSpec{"AMD", "AODMetadataVals"}};
+  /// Extra tables
+  if (enableTRDextra) {
+    outputs.push_back(OutputForTable<TRDsExtra>::spec());
+    dataRequest->inputs.emplace_back("trdlocalgainfactors", "TRD", "LOCALGAINFACTORS", 0, Lifetime::Condition, ccdbParamSpec("TRD/Calib/LocalGainFactor"));
+    dataRequest->inputs.emplace_back("trdnoisemap", "TRD", "NOISEMAP", 0, Lifetime::Condition, ccdbParamSpec("TRD/Calib/NoiseMapMCM"));
+    dataRequest->inputs.emplace_back("trdgaincalib", "TRD", "CALGAIN", 0, Lifetime::Condition, ccdbParamSpec("TRD/Calib/CalGain"));
+  }
 
   if (useMC) {
     outputs.insert(outputs.end(),
@@ -3336,7 +3475,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
     "aod-producer-workflow",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<AODProducerWorkflowDPL>(src, dataRequest, ggRequest, enableSV, useMC, enableFITextra)},
+    AlgorithmSpec{adaptFromTask<AODProducerWorkflowDPL>(src, dataRequest, ggRequest, enableSV, useMC, enableFITextra, enableTRDextra)},
     Options{
       ConfigParamSpec{"run-number", VariantType::Int64, -1L, {"The run-number. If left default we try to get it from DPL header."}},
       ConfigParamSpec{"aod-timeframe-id", VariantType::Int64, -1L, {"Set timeframe number"}},
diff --git a/Detectors/AOD/src/aod-producer-workflow.cxx b/Detectors/AOD/src/aod-producer-workflow.cxx
index 81e178642e403..f6bfaae170bbd 100644
--- a/Detectors/AOD/src/aod-producer-workflow.cxx
+++ b/Detectors/AOD/src/aod-producer-workflow.cxx
@@ -38,6 +38,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"disable-secondary-vertices", o2::framework::VariantType::Bool, false, {"disable filling secondary vertices"}},
     {"disable-strangeness-tracker", o2::framework::VariantType::Bool, false, {"disable filling strangeness tracking"}},
     {"enable-FIT-extra", o2::framework::VariantType::Bool, false, {"enable FIT extra output"}},
+    {"enable-TRD-extra", o2::framework::VariantType::Bool, false, {"enable TRD extra output"}},
     {"info-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of sources to use"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}},
     {"combine-source-devices", o2::framework::VariantType::Bool, false, {"merge DPL source devices"}},
@@ -56,6 +57,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   bool enableST = !configcontext.options().get<bool>("disable-strangeness-tracker");
   bool ctpcfgperrun = !configcontext.options().get<bool>("ctpconfig-run-independent");
   bool enableFITextra = configcontext.options().get<bool>("enable-FIT-extra");
+  bool enableTRDextra = configcontext.options().get<bool>("enable-TRD-extra");
 
   GID::mask_t allowedSrc = GID::getSourcesMask("ITS,MFT,MCH,MID,MCH-MID,TPC,TRD,ITS-TPC,TPC-TOF,TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD,TPC-TRD-TOF,ITS-TPC-TRD-TOF,MFT-MCH,FT0,FV0,FDD,ZDC,EMC,CTP,PHS,CPV,HMP");
   GID::mask_t src = allowedSrc & GID::getSourcesMask(configcontext.options().get<std::string>("info-sources"));
@@ -66,7 +68,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   }
 
   WorkflowSpec specs;
-  specs.emplace_back(o2::aodproducer::getAODProducerWorkflowSpec(src, enableSV, enableST, useMC, ctpcfgperrun, enableFITextra));
+  specs.emplace_back(o2::aodproducer::getAODProducerWorkflowSpec(src, enableSV, enableST, useMC, ctpcfgperrun, enableFITextra, enableTRDextra));
 
   auto srcCls = src & ~(GID::getSourceMask(GID::MCH) | GID::getSourceMask(GID::MID)); // Don't read global MID and MCH clusters (those attached to tracks are always read)
   auto srcMtc = src;
diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index e3032830beaac..9f48685820634 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -470,13 +470,13 @@ DECLARE_SOA_DYNAMIC_COLUMN(TPCFractionSharedCls, tpcFractionSharedCls, //! Fract
                              return (float)tpcNClsShared / (float)tpcNClsFound;
                            });
 
-DECLARE_SOA_DYNAMIC_COLUMN(TRDHasNeighbor, trdPattern, //! Flag to check if at least one tracklet of a TRD Track has a neighboring tracklet
+DECLARE_SOA_DYNAMIC_COLUMN(TRDHasNeighbor, trdHasNeighbor, //! Flag to check if at least one tracklet of a TRD Track has a neighboring tracklet
                            [](uint8_t trdPattern) -> bool { return trdPattern & o2::aod::track::HasNeighbor; });
 
-DECLARE_SOA_DYNAMIC_COLUMN(TRDHasCrossing, trdPattern, //! Flag to check if at least one tracklet of a TRD Track crossed a padrow
+DECLARE_SOA_DYNAMIC_COLUMN(TRDHasCrossing, trdHasCrossing, //! Flag to check if at least one tracklet of a TRD Track crossed a padrow
                            [](uint8_t trdPattern) -> bool { return trdPattern & o2::aod::track::HasCrossing; });
 
-DECLARE_SOA_DYNAMIC_COLUMN(TRDNLayers, trdPattern, //! Number of TRD tracklets in a Track
+DECLARE_SOA_DYNAMIC_COLUMN(TRDNTracklets, trdNTracklets, //! Number of TRD tracklets in a Track
                            [](uint8_t trdPattern) -> std::size_t { return std::bitset<6>(trdPattern).count(); });
 } // namespace track
 
@@ -589,6 +589,7 @@ DECLARE_SOA_TABLE_FULL(StoredTracksExtra_000, "TracksExtra", "AOD", "TRACKEXTRA"
                        track::TPCCrossedRowsOverFindableCls<track::TPCNClsFindable, track::TPCNClsFindableMinusCrossedRows>,
                        track::TPCFoundOverFindableCls<track::TPCNClsFindable, track::TPCNClsFindableMinusFound>,
                        track::TPCFractionSharedCls<track::TPCNClsShared, track::TPCNClsFindable, track::TPCNClsFindableMinusFound>,
+                       track::TRDHasCrossing<track::TRDPattern>, track::TRDHasNeighbor<track::TRDPattern>, track::TRDNTracklets<track::TRDPattern>,
                        track::TrackEtaEMCAL, track::TrackPhiEMCAL, track::TrackTime, track::TrackTimeRes);
 
 DECLARE_SOA_TABLE_FULL_VERSIONED(StoredTracksExtra_001, "TracksExtra", "AOD", "TRACKEXTRA", 1, // On disk version of TracksExtra, version 1
@@ -618,6 +619,7 @@ DECLARE_SOA_TABLE_FULL_VERSIONED(StoredTracksExtra_001, "TracksExtra", "AOD", "T
                                  track::TPCCrossedRowsOverFindableCls<track::TPCNClsFindable, track::TPCNClsFindableMinusCrossedRows>,
                                  track::TPCFoundOverFindableCls<track::TPCNClsFindable, track::TPCNClsFindableMinusFound>,
                                  track::TPCFractionSharedCls<track::TPCNClsShared, track::TPCNClsFindable, track::TPCNClsFindableMinusFound>,
+                                 track::TRDHasCrossing<track::TRDPattern>, track::TRDHasNeighbor<track::TRDPattern>, track::TRDNTracklets<track::TRDPattern>,
                                  track::TrackEtaEMCAL, track::TrackPhiEMCAL, track::TrackTime, track::TrackTimeRes);
 
 DECLARE_SOA_TABLE_FULL_VERSIONED(StoredTracksExtra_002, "TracksExtra", "AOD", "TRACKEXTRA", 2, // On disk version of TracksExtra, version 2
@@ -648,6 +650,7 @@ DECLARE_SOA_TABLE_FULL_VERSIONED(StoredTracksExtra_002, "TracksExtra", "AOD", "T
                                  track::TPCCrossedRowsOverFindableCls<track::TPCNClsFindable, track::TPCNClsFindableMinusCrossedRows>,
                                  track::TPCFoundOverFindableCls<track::TPCNClsFindable, track::TPCNClsFindableMinusFound>,
                                  track::TPCFractionSharedCls<track::TPCNClsShared, track::TPCNClsFindable, track::TPCNClsFindableMinusFound>,
+                                 track::TRDHasCrossing<track::TRDPattern>, track::TRDHasNeighbor<track::TRDPattern>, track::TRDNTracklets<track::TRDPattern>,
                                  track::TrackEtaEMCAL, track::TrackPhiEMCAL, track::TrackTime, track::TrackTimeRes);
 
 DECLARE_SOA_EXTENDED_TABLE(TracksExtra_000, StoredTracksExtra_000, "EXTRACKEXTRA", 0, //! Additional track information (clusters, PID, etc.)
@@ -1610,6 +1613,26 @@ DECLARE_SOA_TABLE(FDDsExtra, "AOD", "FDDEXTRA", //! FDDsExtra table
                   fdd::TimeFDDA, fdd::TimeFDDC);
 using FDDExtra = FDDsExtra::iterator;
 
+namespace trd
+{
+DECLARE_SOA_INDEX_COLUMN(Track, track);                         //! Track index
+DECLARE_SOA_COLUMN(TRDQ0s, trdQ0s, int[6]);                     //! Q0 charge (un-corrected)
+DECLARE_SOA_COLUMN(TRDQ1s, trdQ1s, int[6]);                     //! Q1 charge (un-corrected)
+DECLARE_SOA_COLUMN(TRDQ2s, trdQ2s, int[6]);                     //! Q2 charge (un-corrected)
+DECLARE_SOA_COLUMN(TRDQ0sCorrected, trdQ0sCorrected, float[6]); //! Q0 charge (corrected)
+DECLARE_SOA_COLUMN(TRDQ1sCorrected, trdQ1sCorrected, float[6]); //! Q1 charge (corrected)
+DECLARE_SOA_COLUMN(TRDQ2sCorrected, trdQ2sCorrected, float[6]); //! Q2 charge (corrected)
+DECLARE_SOA_COLUMN(TRDTgls, trdTgls, float[6]);                 //! Local tracklet TgL
+DECLARE_SOA_COLUMN(TRDPhis, trdPhis, float[6]);                 //! Local tracklet phi
+} // namespace trd
+
+DECLARE_SOA_TABLE(TRDsExtra, "AOD", "TRDEXTRA", //! TRDExtra table
+                  o2::soa::Index<>, trd::TrackId,
+                  trd::TRDQ0s, trd::TRDQ1s, trd::TRDQ2s,
+                  trd::TRDQ0sCorrected, trd::TRDQ1sCorrected, trd::TRDQ2sCorrected,
+                  trd::TRDTgls, trd::TRDPhis);
+using TRDExtra = TRDsExtra::iterator;
+
 namespace v0
 {
 DECLARE_SOA_INDEX_COLUMN_FULL(PosTrack, posTrack, int, Tracks, "_Pos"); //! Positive track

From 075c01aa42703316f5fc1ba990e3840305666097 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sat, 28 Feb 2026 17:54:43 +0100
Subject: [PATCH 1371/1764] Fix in the 3D field propagation final step

---
 .../Reconstruction/src/TrackParametrization.cxx      | 10 +++++-----
 .../src/TrackParametrizationWithError.cxx            | 12 ++++++------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/DataFormats/Reconstruction/src/TrackParametrization.cxx b/DataFormats/Reconstruction/src/TrackParametrization.cxx
index 7fe677a6e1c7a..4b850fe14086b 100644
--- a/DataFormats/Reconstruction/src/TrackParametrization.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrization.cxx
@@ -314,14 +314,14 @@ GPUd() bool TrackParametrization<value_T>::propagateParamTo(value_t xk, const di
 
   // Do the final correcting step to the target plane (linear approximation)
   value_t x = vecLab[0], y = vecLab[1], z = vecLab[2];
-  if (gpu::CAMath::Abs(dx) > constants::math::Almost0) {
+  if (gpu::CAMath::Abs(x - xk) > constants::math::Almost0) {
     if (gpu::CAMath::Abs(vecLab[3]) < constants::math::Almost0) {
       return false;
     }
-    dx = xk - vecLab[0];
-    x += dx;
-    y += vecLab[4] / vecLab[3] * dx;
-    z += vecLab[5] / vecLab[3] * dx;
+    auto dxFin = xk - vecLab[0];
+    x += dxFin;
+    y += vecLab[4] / vecLab[3] * dxFin;
+    z += vecLab[5] / vecLab[3] * dxFin;
   }
 
   // Calculate the track parameters
diff --git a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
index 2f8f15f783c60..93ff7e1a2eb82 100644
--- a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
@@ -776,14 +776,14 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, cons
 
   // Do the final correcting step to the target plane (linear approximation)
   value_t x = vecLab[0], y = vecLab[1], z = vecLab[2];
-  if (gpu::CAMath::Abs(dx) > constants::math::Almost0) {
+  if (gpu::CAMath::Abs(x - xk) > constants::math::Almost0) {
     if (gpu::CAMath::Abs(vecLab[3]) < constants::math::Almost0) {
       return false;
     }
-    dx = xk - vecLab[0];
-    x += dx;
-    y += vecLab[4] / vecLab[3] * dx;
-    z += vecLab[5] / vecLab[3] * dx;
+    auto dxFin = xk - vecLab[0];
+    x += dxFin;
+    y += vecLab[4] / vecLab[3] * dxFin;
+    z += vecLab[5] / vecLab[3] * dxFin;
   }
 
   // Calculate the track parameters
@@ -896,7 +896,7 @@ GPUd() bool TrackParametrizationWithError<value_T>::propagateTo(value_t xk, Trac
 
   // Do the final correcting step to the target plane (linear approximation)
   value_t x = vecLab[0], y = vecLab[1], z = vecLab[2];
-  if (gpu::CAMath::Abs(dx) > constants::math::Almost0) {
+  if (gpu::CAMath::Abs(x - xk) > constants::math::Almost0) {
     if (gpu::CAMath::Abs(vecLab[3]) < constants::math::Almost0) {
       return false;
     }

From 8c4238634e2ce6d1766cd747962c361337d46f94 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 26 Feb 2026 17:41:35 +0100
Subject: [PATCH 1372/1764] Extra support for dumping ConfigurableParam to
 ini/json files

---
 .../include/CommonUtils/ConfigurableParam.h   |  3 ++
 Common/Utils/include/CommonUtils/NameConf.h   |  3 ++
 .../Utils/include/CommonUtils/StringUtils.h   |  3 ++
 Common/Utils/src/ConfigurableParam.cxx        | 23 +++++++++++++--
 Common/Utils/src/NameConf.cxx                 |  9 ++++++
 Common/Utils/src/StringUtils.cxx              | 29 +++++++++++++++++++
 6 files changed, 68 insertions(+), 2 deletions(-)

diff --git a/Common/Utils/include/CommonUtils/ConfigurableParam.h b/Common/Utils/include/CommonUtils/ConfigurableParam.h
index 39b24bbbbd57c..b9234926b7c40 100644
--- a/Common/Utils/include/CommonUtils/ConfigurableParam.h
+++ b/Common/Utils/include/CommonUtils/ConfigurableParam.h
@@ -187,6 +187,9 @@ class ConfigurableParam
   // writes a human readable INI file of all parameters
   static void writeINI(std::string const& filename, std::string const& keyOnly = "");
 
+  // writes a human readable INI or JSON file depending on the extension
+  static void write(std::string const& filename, std::string const& keyOnly = "");
+
   // can be used instead of using API on concrete child classes
   template <typename T>
   static T getValueAs(std::string key)
diff --git a/Common/Utils/include/CommonUtils/NameConf.h b/Common/Utils/include/CommonUtils/NameConf.h
index 8a09a903bf32f..fb10f929c9782 100644
--- a/Common/Utils/include/CommonUtils/NameConf.h
+++ b/Common/Utils/include/CommonUtils/NameConf.h
@@ -103,6 +103,9 @@ class NameConf : public o2::conf::ConfigurableParamHelper<NameConf>
   // Default CCDB server
   static std::string getCCDBServer();
 
+  // create name to dump config file
+  static std::string getConfigOutputFileName(const std::string& procName, const std::string& confName = "", bool json = true);
+
  protected:
   // helper method to build filenames
   static std::string buildFileName(const std::string_view prefix, const std::string_view delimiter, const std::string_view defPrefix, const std::string_view defName,
diff --git a/Common/Utils/include/CommonUtils/StringUtils.h b/Common/Utils/include/CommonUtils/StringUtils.h
index 710632fc7dbfe..cfe29e065a78e 100644
--- a/Common/Utils/include/CommonUtils/StringUtils.h
+++ b/Common/Utils/include/CommonUtils/StringUtils.h
@@ -136,6 +136,9 @@ struct Str {
   // return vector of tokens from the string with provided delimiter. If requested, trim the spaces from tokens
   static std::vector<std::string> tokenize(const std::string& src, char delim, bool trimToken = true, bool skipEmpty = true);
 
+  // return vector of tokens from the string with provided delimiters. If requested, trim the spaces from tokens
+  static std::vector<std::string> tokenize(const std::string& src, const std::string& delim, bool trimToken = true, bool skipEmpty = true);
+
   // concatenate arbitrary number of strings
   template <typename... Ts>
   static std::string concat_string(Ts const&... ts)
diff --git a/Common/Utils/src/ConfigurableParam.cxx b/Common/Utils/src/ConfigurableParam.cxx
index 8497a485fca39..fd69f51402cd5 100644
--- a/Common/Utils/src/ConfigurableParam.cxx
+++ b/Common/Utils/src/ConfigurableParam.cxx
@@ -192,6 +192,19 @@ int EnumLegalValues::getIntValue(const std::string& value) const
 
 // -----------------------------------------------------------------
 
+void ConfigurableParam::write(std::string const& filename, std::string const& keyOnly)
+{
+  if (o2::utils::Str::endsWith(filename, ".ini")) {
+    writeINI(filename, keyOnly);
+  } else if (o2::utils::Str::endsWith(filename, ".json")) {
+    writeJSON(filename, keyOnly);
+  } else {
+    throw std::invalid_argument(fmt::format("ConfigurabeParam output file name {} extension is neither .json nor .ini", filename));
+  }
+}
+
+// -----------------------------------------------------------------
+
 void ConfigurableParam::writeINI(std::string const& filename, std::string const& keyOnly)
 {
   if (sOutputDir == "/dev/null") {
@@ -203,7 +216,10 @@ void ConfigurableParam::writeINI(std::string const& filename, std::string const&
   if (!keyOnly.empty()) { // write ini for selected key only
     try {
       boost::property_tree::ptree kTree;
-      kTree.add_child(keyOnly, sPtree->get_child(keyOnly));
+      auto keys = o2::utils::Str::tokenize(keyOnly, " ,;", true, true);
+      for (const auto& k : keys) {
+        kTree.add_child(k, sPtree->get_child(k));
+      }
       boost::property_tree::write_ini(outfilename, kTree);
     } catch (const boost::property_tree::ptree_bad_path& err) {
       LOG(fatal) << "non-existing key " << keyOnly << " provided to writeINI";
@@ -284,7 +300,10 @@ void ConfigurableParam::writeJSON(std::string const& filename, std::string const
   if (!keyOnly.empty()) { // write ini for selected key only
     try {
       boost::property_tree::ptree kTree;
-      kTree.add_child(keyOnly, sPtree->get_child(keyOnly));
+      auto keys = o2::utils::Str::tokenize(keyOnly, " ,;", true, true);
+      for (const auto& k : keys) {
+        kTree.add_child(k, sPtree->get_child(k));
+      }
       boost::property_tree::write_json(outfilename, kTree);
     } catch (const boost::property_tree::ptree_bad_path& err) {
       LOG(fatal) << "non-existing key " << keyOnly << " provided to writeJSON";
diff --git a/Common/Utils/src/NameConf.cxx b/Common/Utils/src/NameConf.cxx
index 5a5f644f2da39..45646284a878b 100644
--- a/Common/Utils/src/NameConf.cxx
+++ b/Common/Utils/src/NameConf.cxx
@@ -111,3 +111,12 @@ std::string NameConf::getCCDBServer()
 {
   return Instance().mCCDBServer;
 }
+
+std::string NameConf::getConfigOutputFileName(const std::string& procName, const std::string& confName, bool json)
+{
+  std::string nm = procName;
+  if (!confName.empty()) {
+    nm += '_' + confName;
+  }
+  return fmt::format("ConfigParam_{}.{}", nm, json ? "json" : "ini");
+}
diff --git a/Common/Utils/src/StringUtils.cxx b/Common/Utils/src/StringUtils.cxx
index 687225d069ed2..29c43ec18375b 100644
--- a/Common/Utils/src/StringUtils.cxx
+++ b/Common/Utils/src/StringUtils.cxx
@@ -37,6 +37,35 @@ std::vector<std::string> Str::tokenize(const std::string& src, char delim, bool
   return tokens;
 }
 
+std::vector<std::string> Str::tokenize(const std::string& src, const std::string& delim, bool trimToken, bool skipEmpty)
+{
+  std::string inptStr{src};
+  char* input = inptStr.data();
+  auto mystrtok = [&]() -> char* {
+    input += std::strspn(input, delim.c_str());
+    if (*input == '\0') {
+      return nullptr;
+    }
+    char* const token = input;
+    input += std::strcspn(input, delim.c_str());
+    if (*input != '\0') {
+      *input++ = '\0';
+    }
+    return token;
+  };
+  std::vector<std::string> tokens;
+  while (*input != '\0') {
+    std::string token = mystrtok();
+    if (trimToken) {
+      trim(token);
+    }
+    if (!token.empty() || !skipEmpty) {
+      tokens.push_back(std::move(token));
+    }
+  }
+  return tokens;
+}
+
 // replace all occurencies of from by to, return count
 int Str::replaceAll(std::string& s, const std::string& from, const std::string& to)
 {

From 18af67d8e54e2489801659be91444b2102bbb2c3 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 26 Feb 2026 17:45:32 +0100
Subject: [PATCH 1373/1764] Dump uniformly important reco ConfigParams to be
 collected in AO2D metadata

---
 .../src/PrimaryVertexingSpec.cxx                   |  8 ++++++++
 .../src/SecondaryVertexingSpec.cxx                 | 11 +++++++++++
 .../GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx  |  9 +++++++++
 .../src/TPCITSMatchingSpec.cxx                     |  8 ++++++++
 Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx  |  9 +++++++++
 Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx  |  9 +++++++++
 .../TRD/workflow/src/TRDGlobalTrackingSpec.cxx     |  9 +++++++++
 GPU/Workflow/src/GPUWorkflowITS.cxx                | 14 +++++++++++++-
 GPU/Workflow/src/GPUWorkflowSpec.cxx               |  7 +++++++
 9 files changed, 83 insertions(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx
index d71a4fad7ab78..dc1107bacb18a 100644
--- a/Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx
@@ -197,6 +197,14 @@ void PrimaryVertexingSpec::run(ProcessingContext& pc)
        mVertexer.getTimeReAttach().CpuTime(), mVertexer.getTotTrials(), mVertexer.getNTZClusters(), mVertexer.getMaxTrialsPerCluster(),
        mVertexer.getLongestClusterTimeMS(), mVertexer.getLongestClusterMult(), mVertexer.getNIniFound(),
        mVertexer.getNKilledBCValid(), mVertexer.getNKilledIntCand(), mVertexer.getNKilledDebris(), mVertexer.getNKilledQuality(), mVertexer.getNKilledITSOnly());
+
+  static bool first = true;
+  if (first) {
+    first = false;
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, PVertexerParams::Instance().getName()), PVertexerParams::Instance().getName());
+    }
+  }
 }
 
 void PrimaryVertexingSpec::endOfStream(EndOfStreamContext& ec)
diff --git a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
index ea566f15a0b59..1b55f9c763e7f 100644
--- a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
@@ -128,6 +128,17 @@ void SecondaryVertexingSpec::run(ProcessingContext& pc)
        mVertexer.getNV0s(), calls[0] - fitCalls[0], mVertexer.getNCascades(), calls[1] - fitCalls[1], mVertexer.getN3Bodies(), calls[2] - fitCalls[2], mVertexer.getNStrangeTracks(),
        mTimer.CpuTime() - timeCPU0, mTimer.RealTime() - timeReal0);
   fitCalls = calls;
+
+  static bool first = true;
+  if (first) {
+    first = false;
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, SVertexerParams::Instance().getName()), SVertexerParams::Instance().getName());
+      if (mEnableStrangenessTracking) {
+        o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::strangeness_tracking::StrangenessTrackingParamConfig::Instance().getName()), o2::strangeness_tracking::StrangenessTrackingParamConfig::Instance().getName());
+      }
+    }
+  }
 }
 
 void SecondaryVertexingSpec::endOfStream(EndOfStreamContext& ec)
diff --git a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
index 3f6e79e433635..8081c48e390d3 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
@@ -22,6 +22,7 @@
 #include "DataFormatsGlobalTracking/RecoContainer.h"
 #include "Framework/Task.h"
 #include "Framework/DataProcessorSpec.h"
+#include "Framework/DeviceSpec.h"
 #include "TPCCalibration/VDriftHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 
@@ -229,6 +230,14 @@ void TOFMatcherSpec::run(ProcessingContext& pc)
     pc.outputs().snapshot(Output{o2::header::gDataOriginTOF, "MATCHABLES_17", 0}, mMatcher.getMatchedTracksPair(17));
   }
 
+  static bool first = true;
+  if (first) {
+    first = false;
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, MatchTOFParams::Instance().getName()), MatchTOFParams::Instance().getName());
+    }
+  }
+
   mTimer.Stop();
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
index 14af8c12794cc..c333c37ff245b 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
@@ -130,6 +130,14 @@ void TPCITSMatchingDPL::run(ProcessingContext& pc)
 
   mMatching.run(recoData, matchedTracks, ABTrackletRefs, ABTrackletClusterIDs, matchLabels, ABTrackletLabels, calib);
 
+  static bool first = true;
+  if (first) {
+    first = false;
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, MatchTPCITSParams::Instance().getName()), MatchTPCITSParams::Instance().getName());
+    }
+  }
+
   mTimer.Stop();
 }
 
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index 12d84ca7ab6ad..3d07048aaf1e6 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -14,6 +14,7 @@
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
+#include "Framework/DeviceSpec.h"
 #include "ITSWorkflow/TrackerSpec.h"
 #include "ITStracking/Definitions.h"
 #include "ITStracking/TrackingConfigParam.h"
@@ -60,6 +61,14 @@ void TrackerDPL::run(ProcessingContext& pc)
   mITSTrackingInterface.run(pc);
   mTimer.Stop();
   LOGP(info, "CPU Reconstruction time for this TF {:.2f} s (cpu), {:.2f} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
+  static bool first = true;
+  if (first) {
+    first = false;
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::VertexerParamConfig::Instance().getName()), o2::its::VertexerParamConfig::Instance().getName());
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::TrackerParamConfig::Instance().getName()), o2::its::TrackerParamConfig::Instance().getName());
+    }
+  }
 }
 
 void TrackerDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
diff --git a/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
index d8e15590474ec..3e726fe37c38c 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
@@ -24,6 +24,7 @@
 
 #include "TGeoGlobalMagField.h"
 
+#include "Framework/DeviceSpec.h"
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
@@ -331,6 +332,14 @@ void TrackerDPL::run(ProcessingContext& pc)
     pc.outputs().snapshot(Output{"MFT", "TRACKSMC2ROF", 0}, mc2rofs);
   }
 
+  static bool first = true;
+  if (first) {
+    first = false;
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::mft::MFTTrackingParam::Instance().getName()), o2::mft::MFTTrackingParam::Instance().getName());
+    }
+  }
+
   mTimer[SWTot].Stop();
 }
 
diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index f2d4aad829fe5..9e7ef089faeef 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -28,6 +28,7 @@
 #include "GPUWorkflowHelper/GPUWorkflowHelper.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
+#include "Framework/DeviceSpec.h"
 #include "DataFormatsTPC/WorkflowHelper.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "CommonConstants/GeomConstants.h"
@@ -554,6 +555,14 @@ void TRDGlobalTracking::run(ProcessingContext& pc)
     }
   }
 
+  static bool first = true;
+  if (first) {
+    first = false;
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, "GPU_rec_trd"), "GPU_rec_trd");
+    }
+  }
+
   mTimer.Stop();
 }
 
diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index b1c8d619ec736..587b85df98952 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -18,8 +18,11 @@
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
-
+#include "Framework/DeviceSpec.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/NameConf.h"
 #include "ITStracking/TrackingInterface.h"
+#include "ITStracking/TrackingConfigParam.h"
 
 #ifdef ENABLE_UPGRADES
 #include "ITS3Reconstruction/TrackingInterface.h"
@@ -33,6 +36,15 @@ int32_t GPURecoWorkflowSpec::runITSTracking(o2::framework::ProcessingContext& pc
   mITSTimeFrame->setDevicePropagator(mGPUReco->GetDeviceO2Propagator());
   LOGP(debug, "GPUChainITS is giving me device propagator: {}", (void*)mGPUReco->GetDeviceO2Propagator());
   mITSTrackingInterface->run(pc);
+  static bool first = true;
+  if (first) {
+    first = false;
+    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::VertexerParamConfig::Instance().getName()), o2::its::VertexerParamConfig::Instance().getName());
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::TrackerParamConfig::Instance().getName()), o2::its::TrackerParamConfig::Instance().getName());
+      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::ITSGpuTrackingParamConfig::Instance().getName()), o2::its::ITSGpuTrackingParamConfig::Instance().getName());
+    }
+  }
   return 0;
 }
 
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index a8f95841a4dc9..48210c440d01e 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -514,6 +514,13 @@ int32_t GPURecoWorkflowSpec::runMain(o2::framework::ProcessingContext* pc, GPUTr
     if (retVal == 0 && mSpecConfig.runITSTracking) {
       retVal = runITSTracking(*pc);
     }
+    static bool first = true;
+    if (first) {
+      first = false;
+      if (pc->services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // TPC ConfigurableCarams are somewhat special, need to construct by hand
+        o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc->services().get<const o2::framework::DeviceSpec>().name, "rec_tpc"), "GPU_rec_tpc,GPU_rec,GPU_proc_param,GPU_proc,GPU_global,trackTuneParams");
+      }
+    }
   }
 
   if (!mSpecConfig.enableDoublePipeline) { // TODO: Why is this needed for double-pipeline?

From cbdea04a9a190c34a49f64c4a9f949178db39fe3 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 24 Feb 2026 10:03:21 +0100
Subject: [PATCH 1374/1764] Add Eigen3 and GBL dependencies

Following https://github.com/alisw/alidist/pull/6137, this adds GBL and Eigen3 as dependencies.
---
 dependencies/O2Dependencies.cmake | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/dependencies/O2Dependencies.cmake b/dependencies/O2Dependencies.cmake
index 26f381a4ef79f..8addb87a1a16f 100644
--- a/dependencies/O2Dependencies.cmake
+++ b/dependencies/O2Dependencies.cmake
@@ -243,4 +243,25 @@ set_package_properties(absl PROPERTIES TYPE REQUIRED)
 find_package(Vtune)
 set_package_properties(Vtune PROPERTIES TYPE OPTIONAL)
 
+find_package(Eigen3 QUIET)
+if(NOT TARGET Eigen3::Eigen)
+    # The Eigen3 install only provides the header files, so 'mock' the cmake target
+    add_library(Eigen3::Eigen INTERFACE IMPORTED)
+    set_target_properties(Eigen3::Eigen PROPERTIES
+        INTERFACE_INCLUDE_DIRECTORIES "${EIGEN3_ROOT}/include/eigen3"
+    )
+endif()
+
+find_package(GBL)
+set_package_properties(GBL PROPERTIES TYPE REQUIRED)
+if(GBL_FOUND AND NOT TARGET GBL::GBL)
+    # As of now, GBL does not provide a cmake target so create a compatibility wrapper
+    add_library(GBL::GBL INTERFACE IMPORTED)
+    target_include_directories(GBL::GBL INTERFACE ${GBL_INCLUDE_DIR})
+    target_link_libraries(GBL::GBL INTERFACE
+        ${GBL_LIBRARIES}
+        Eigen3::Eigen
+    )
+endif()
+
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)

From da3f131d129c3661803d439ac9ccf9e2f6bb163c Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 2 Mar 2026 15:45:26 +0100
Subject: [PATCH 1375/1764] Clusterer fix: suppress stray ROFs keeping their
 clusters unaddressed

---
 .../common/workflow/src/ClustererSpec.cxx     | 78 ++++++++++---------
 1 file changed, 43 insertions(+), 35 deletions(-)

diff --git a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
index 0b6bb44ee78c8..8de29c62335b6 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
@@ -125,48 +125,56 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
     size_t nROFs = clusROFVec.size();
     const int nROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / par.getROFLengthInBC(iLayer);
     const int nROFsTF = nROFsPerOrbit * o2::base::GRPGeomHelper::getNHBFPerTF();
-    if (nROFsTF != clusROFVec.size()) {
-      // it can happen that in the digitization rofs without contributing hits are skipped
-      // however downstream consumers of the clusters cannot know apriori the time structure
-      // the cluster rofs do not account for the bias so it will start always at BC=0
-      // if we receive more cluster rofs then there supposed to be, do not throw away this data
-      // the clusterer should be blind to this!
-      const size_t nROFsLayer = std::max((size_t)nROFsTF, clusROFVec.size());
-      std::vector<o2::itsmft::ROFRecord> expClusRofVec(nROFsLayer);
-      for (int iROF{0}; iROF < nROFsLayer; ++iROF) {
-        auto& rof = expClusRofVec[iROF];
-        int orb = iROF * par.getROFLengthInBC(iLayer) / o2::constants::lhc::LHCMaxBunches + firstTForbit;
-        int bc = iROF * par.getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches;
-        o2::InteractionRecord ir(bc, orb);
-        rof.setBCData(ir);
-        rof.setROFrame(iROF);
-        rof.setNEntries(0);
-        rof.setFirstEntry(-1);
+    // It can happen that in the digitization rofs without contributing hits are skipped or there are stray ROFs
+    // We will preserve the clusters as they are but the stray ROFs will be removed (leaving their clusters unaddressed).
+    std::vector<o2::itsmft::ROFRecord> expClusRofVec(nROFsTF);
+    for (int iROF{0}; iROF < nROFsTF; ++iROF) {
+      auto& rof = expClusRofVec[iROF];
+      int orb = iROF * par.getROFLengthInBC(iLayer) / o2::constants::lhc::LHCMaxBunches + firstTForbit;
+      int bc = iROF * par.getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches;
+      o2::InteractionRecord ir(bc, orb);
+      rof.setBCData(ir);
+      rof.setROFrame(iROF);
+      rof.setNEntries(0);
+      rof.setFirstEntry(-1);
+    }
+    uint32_t prevEntry{0};
+    for (const auto& rof : clusROFVec) {
+      const auto& ir = rof.getBCData();
+      if (ir < firstIR) {
+        LOGP(warn, "Discard ROF {} preceding TF 1st orbit {}, layer:{}", ir.asString(), firstTForbit, iLayer);
+        continue;
+      }
+      const auto irToFirst = ir - firstIR;
+      const long irROF = irToFirst.toLong() / par.getROFLengthInBC(iLayer);
+      if (irROF >= nROFsTF) {
+        LOGP(warn, "Discard ROF {} exceding TF orbit range, layer:{}", ir.asString(), iLayer);
+        continue;
       }
-      uint32_t prevEntry{0};
-      for (const auto& rof : clusROFVec) {
-        const auto& ir = rof.getBCData();
-        const auto irToFirst = ir - firstIR;
-        const int irROF = irToFirst.toLong() / par.getROFLengthInBC(iLayer);
-        auto& expROF = expClusRofVec[irROF];
+      auto& expROF = expClusRofVec[irROF];
+      if (expROF.getNEntries() == 0) {
         expROF.setFirstEntry(rof.getFirstEntry());
         expROF.setNEntries(rof.getNEntries());
-        if (expROF.getBCData() != rof.getBCData()) {
-          LOGP(fatal, "detected mismatch between expected ROF:{} and received ROF:{}", expROF.asString(), rof.asString());
+      } else {
+        if (expROF.getNEntries() < rof.getNEntries()) {
+          LOGP(warn, "Repeating ROF {} with {} clusters, prefer to already processed instance with {} clusters", rof.asString(), rof.getNEntries(), expROF.getNEntries());
+          expROF.setFirstEntry(rof.getFirstEntry());
+          expROF.setNEntries(rof.getNEntries());
+        } else {
+          LOGP(warn, "Repeating ROF {} with {} clusters, discard preferring already processed instance with {} clusters", rof.asString(), rof.getNEntries(), expROF.getNEntries());
         }
       }
-      int prevFirst{0};
-      for (auto& rof : expClusRofVec) {
-        if (rof.getFirstEntry() < 0) {
-          rof.setFirstEntry(prevFirst);
-        }
-        prevFirst = rof.getFirstEntry();
+    }
+    int prevFirst{0};
+    for (auto& rof : expClusRofVec) {
+      if (rof.getFirstEntry() < 0) {
+        rof.setFirstEntry(prevFirst);
       }
-      nROFs = expClusRofVec.size();
-      pc.outputs().snapshot(Output{Origin, "CLUSTERSROF", iLayer}, expClusRofVec);
-    } else {
-      pc.outputs().snapshot(Output{Origin, "CLUSTERSROF", iLayer}, clusROFVec);
+      prevFirst = rof.getFirstEntry();
     }
+    nROFs = expClusRofVec.size();
+    pc.outputs().snapshot(Output{Origin, "CLUSTERSROF", iLayer}, expClusRofVec);
+
     pc.outputs().snapshot(Output{Origin, "COMPCLUSTERS", iLayer}, clusCompVec);
     pc.outputs().snapshot(Output{Origin, "PATTERNS", iLayer}, clusPattVec);
 

From 9b34abbb94ab5792006a25845b042b4c7bec5dc6 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Thu, 26 Feb 2026 13:33:27 +0100
Subject: [PATCH 1376/1764] Add missing test

---
 Detectors/TPC/qc/CMakeLists.txt | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Detectors/TPC/qc/CMakeLists.txt b/Detectors/TPC/qc/CMakeLists.txt
index 60195ed6d451a..ce998eec6475c 100644
--- a/Detectors/TPC/qc/CMakeLists.txt
+++ b/Detectors/TPC/qc/CMakeLists.txt
@@ -77,6 +77,12 @@ o2_add_test(TrackClusters
             SOURCES test/test_TrackClusters.cxx
             LABELS tpc)
 
+o2_add_test(DCSPTemperature
+            COMPONENT_NAME tpc
+            PUBLIC_LINK_LIBRARIES O2::TPCQC
+            SOURCES test/test_DCSPTemperature.cxx
+            LABELS tpc)
+
 o2_add_test_root_macro(macro/runPID.C
                        PUBLIC_LINK_LIBRARIES O2::TPCQC
                                              O2::DataFormatsTPC

From 1ffca72c093b391400c44db610e822d23b3ba3b9 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Wed, 25 Feb 2026 15:28:57 +0100
Subject: [PATCH 1377/1764] Fix type mismatch

---
 Generators/src/GeneratorHepMC.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Generators/src/GeneratorHepMC.cxx b/Generators/src/GeneratorHepMC.cxx
index 180a088c02a92..faacde7317664 100644
--- a/Generators/src/GeneratorHepMC.cxx
+++ b/Generators/src/GeneratorHepMC.cxx
@@ -501,7 +501,7 @@ void GeneratorHepMC::updateHeader(o2::dataformats::MCEventHeader* eventHeader)
                               hiInfo->Nwounded_N_collisions);
     eventHeader->putInfo<int>(Key::nCollNWoundedNwounded,
                               hiInfo->Nwounded_Nwounded_collisions);
-    eventHeader->putInfo<float>(Key::planeAngle, hiInfo->event_plane_angle);
+    eventHeader->putInfo<double>(Key::planeAngle, hiInfo->event_plane_angle);
     eventHeader->putInfo<float>(Key::sigmaInelNN, hiInfo->sigma_inel_NN);
     eventHeader->putInfo<float>(Key::centrality, hiInfo->centrality);
     eventHeader->putInfo<int>(Key::nSpecProjectileProton, hiInfo->Nspec_proj_p);

From a1d999e775b3da8f2f6099d0fe43eaf6e20a5a81 Mon Sep 17 00:00:00 2001
From: Pavel Larionov <pavel.larionov@cern.ch>
Date: Mon, 2 Mar 2026 21:48:08 +0100
Subject: [PATCH 1378/1764] [ALICE 3] Add IRIS option with inclined walls
 material   (#15098)

* Fully cyl IRIS with inclined walls material

* Remove white space

* Please consider the following formatting changes

* Added 3rd segment up to R = 47.5 mm

* Petal outer radius 48 mm

* Set incl. material length to petal length

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../TRK/base/include/TRKBase/TRKBaseParam.h   |   1 +
 .../include/TRKSimulation/VDGeometryBuilder.h |   1 +
 .../ALICE3/TRK/simulation/src/Detector.cxx    |   4 +
 .../TRK/simulation/src/VDGeometryBuilder.cxx  | 199 +++++++++++++++++-
 4 files changed, 200 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index f919839b7ed0a..232e7e04b09cd 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -34,6 +34,7 @@ enum eLayout {
 enum eVDLayout {
   kIRIS4 = 0,
   kIRISFullCyl,
+  kIRISFullCyl3InclinedWalls,
   kIRIS5,
   kIRIS4a,
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
index c337ddb102147..77b45c97cba84 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/VDGeometryBuilder.h
@@ -25,6 +25,7 @@ namespace o2::trk
 // and then places/rotates the petal once into the mother volume.
 
 void createIRISGeometryFullCyl(TGeoVolume* motherVolume);          // Full-cylinder IRIS geometry (no petals, no gaps, no side walls)
+void createIRISGeometry3InclinedWalls(TGeoVolume* motherVolume);   // Full-cylinder IRIS geometry with 3 inclined walls
 void createIRISGeometryFullCylwithDisks(TGeoVolume* motherVolume); // Full-cylinder IRIS geometry (no petals, no gaps, no side walls) incl. disks
 void createIRIS4Geometry(TGeoVolume* motherVolume);                // 4 petals, cylindrical L0
 void createIRIS4aGeometry(TGeoVolume* motherVolume);               // 3 petals, cylindrical L0
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index a2629a101d2d0..2ad1d52ba73c4 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -275,6 +275,10 @@ void Detector::createGeometry()
       LOG(info) << "Building VD with IRIS fully cylindrical layout";
       o2::trk::createIRISGeometryFullCyl(vTRK);
       break;
+    case kIRISFullCyl3InclinedWalls:
+      LOG(info) << "Building VD with IRIS fully cylindrical layout with 3 inclined walls";
+      o2::trk::createIRISGeometry3InclinedWalls(vTRK);
+      break;
     case kIRIS5:
       LOG(info) << "Building VD with IRIS5 layout";
       o2::trk::createIRIS5Geometry(vTRK);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
index b06faa38211bb..f487d7602619f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 
 #include "TRKSimulation/VDGeometryBuilder.h"
-
 #include <TGeoVolume.h>
 #include <TGeoMatrix.h>
 #include <TGeoTube.h>
@@ -19,13 +18,13 @@
 #include <TGeoCompositeShape.h>
 #include <TString.h>
 #include <DetectorsBase/MaterialManager.h>
-
 #include "TGeoManager.h"
-
 #include "Framework/Logger.h"
 #include "TRKBase/GeometryTGeo.h"
 #include "TRKSimulation/VDLayer.h"
 #include "TRKSimulation/VDSensorRegistry.h"
+#include <algorithm>
+#include <cmath>
 
 namespace o2::trk
 {
@@ -82,6 +81,9 @@ inline bool isSolidToCut(const TGeoVolume* v)
   if (TString(nm).BeginsWith("IRIS_Service_Pos_InVac")) {
     return true;
   }
+  if (TString(nm).BeginsWith("VD_InclinedWall")) {
+    return true;
+  }
   return false;
 }
 
@@ -252,8 +254,18 @@ static const double diskZ_cm[6] = {-34.0f, -30.0f, -26.0f, 26.0f, 30.0f, 34.0f};
 static constexpr double kPetalZ_cm = 70.0f;          // full wall height
 static constexpr double kWallThick_cm = 0.015f;      // 0.15 mm
 static constexpr double kInnerWallRadius_cm = 0.48f; // 4.8 mm (ALWAYS cylindrical)
-static constexpr double kOuterWallRadius_cm = 3.0f;  // 30 mm (can be changed)
-static constexpr double kEps_cm = 1.e-4f;
+static constexpr double kOuterWallRadius_cm = 4.8f;  // 48 mm (can be changed)
+static constexpr double kEps_cm = 2.5e-4f;
+
+// 3 inclined walls ("walls") specs for the full-cylinder option
+// Thickness in-plane (cm). This is the short half-dimension of the TGeoBBox in XY.
+static constexpr double kInclinedWallThick_cm = 0.04f; // 0.4 mm
+// Layer-shell thickness used for the gap boundaries in the inclined-wall construction (cm)
+static constexpr double kSiLayerThick_cm = 0.01f; // 0.1 mm
+// Base tangency angle (deg) for the first wall; the other 2 are +120/+240.
+// This matches the angle used in the ROOT sketch from our chat.
+static constexpr double kInclinedWallPhi0_deg = 27.799f;
+static constexpr double kInclinedWallRmax_cm = 4.75f; // 47.5 mm outer extension
 
 // Coldplate specs (cm)
 static constexpr double kColdplateRadius_cm = 2.6f;     // 26 mm (outer radius)
@@ -806,6 +818,158 @@ static TGeoVolume* buildFullCylAssembly(int petalID, bool withDisks)
   return petalAsm;
 }
 
+// Add 3 inclined walls (straight walls) into a full-cylinder petal assembly.
+// The walls are implemented as TWO TGeoBBox segments per wall, living in the gaps:
+//   - segment 01: from tangency at Rtan to inner surface of L1
+//   - segment 12: from outer surface of L1 to inner surface of L2
+// The construction accounts for the finite wall thickness (kInclinedWallThick_cm).
+static void addInclinedWalls3FullCyl(TGeoVolume* petalAsm, double phi0_deg = kInclinedWallPhi0_deg)
+{
+  if (!petalAsm) {
+    LOGP(error, "addInclinedWalls3FullCyl: petalAsm is null");
+    return;
+  }
+
+  auto& matmgr = o2::base::MaterialManager::Instance();
+  const TGeoMedium* med = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_ALUMINIUM5083");
+  if (!med) {
+    LOGP(warning, "addInclinedWalls3FullCyl: ALICE3_TRKSERVICES_ALUMINIUM5083 not found, walls not created.");
+    return;
+  }
+
+  // Clearance margin from layer/coldplate surfaces (cm)
+  constexpr double clearanceMargin = 0.010; // 100 microns
+
+  // Geometry inputs (cm)
+  constexpr double R0 = rL0_cm;
+  constexpr double R1 = rL1_cm;
+  constexpr double R2 = rL2_cm;
+  constexpr double Rmax = kInclinedWallRmax_cm;
+
+  const double wallDy = 0.5 * kInclinedWallThick_cm;
+  const double shellTh = kSiLayerThick_cm; // 0.1 mm shell thickness for bounds
+  const double h = 0.5 * shellTh;
+  const double dz = 0.5 * kPetalZ_cm; // match barrel/coldplate length in full-cyl option
+
+  constexpr int nWalls = 3;
+  constexpr double dPhi = 360.0 / double(nWalls);
+
+  // Gap boundaries (shell surfaces)
+  const double R0_out = R0 + h;
+  const double R1_in = R1 - h;
+  const double R1_out = R1 + h;
+  const double R2_in = R2 - h;
+  const double R2_out = R2 + h;
+
+  // Coldplate outer radius (tube segment is [kColdplateRadius_cm, kColdplateRadius_cm + kColdplateThickness_cm])
+  const double Rcold_out = kColdplateRadius_cm + kColdplateThickness_cm;
+
+  // Tangency radius choice (thickness-safe at s=0): need Rtan - wallDy >= R0_out
+  const double Rtan = R0_out + wallDy + clearanceMargin;
+
+  // For finite-thickness box:
+  //   outermost edge uses Reff_plus, innermost edge uses Reff_minus
+  const double Reff_plus = Rtan + wallDy + clearanceMargin;
+  const double Reff_minus = std::max(0.0, Rtan - wallDy - clearanceMargin);
+
+  auto sAt = [](double R, double Reff) -> double {
+    const double v = R * R - Reff * Reff;
+    return (v > 0.0) ? std::sqrt(v) : 0.0;
+  };
+
+  // Segment bounds in 's' (thickness-safe):
+  // 01: from tangency to L1 inner surface (outer edge <= R1_in)
+  const double sa01 = 0.0;
+  const double sb01 = sAt(R1_in, Reff_plus);
+
+  // 12: from outside L1 to inside L2
+  const double sa12 = sAt(R1_out, Reff_minus); // inner edge >= R1_out
+  const double sb12 = sAt(R2_in, Reff_plus);   // outer edge <= R2_in
+
+  // 23: from outside coldplate (and outside L2) to Rmax
+  const double R23_start = std::max(R2_out, Rcold_out) + clearanceMargin;
+  const double sa23 = sAt(R23_start, Reff_minus); // inner edge >= start radius
+  const double sb23 = sAt(Rmax, Reff_plus);       // outer edge <= Rmax
+
+  if (!((sb01 > sa01) && (sb12 > sa12) && (sb23 > sa23))) {
+    LOGP(error,
+         "addInclinedWalls3FullCyl: invalid bounds. 01:[{},{}] 12:[{},{}] 23:[{},{}] "
+         "Rtan={} Reff-={} Reff+={} R23_start={}",
+         sa01, sb01, sa12, sb12, sa23, sb23,
+         Rtan, Reff_minus, Reff_plus, R23_start);
+    return;
+  }
+
+  // Half-lengths and center parameters (s-centers)
+  const double dx01 = 0.5 * (sb01 - sa01);
+  const double dx12 = 0.5 * (sb12 - sa12);
+  const double dx23 = 0.5 * (sb23 - sa23);
+
+  const double sc01 = 0.5 * (sa01 + sb01);
+  const double sc12 = 0.5 * (sa12 + sb12);
+  const double sc23 = 0.5 * (sa23 + sb23);
+
+  // Create shapes once, reuse for all walls
+  auto* sh01 = new TGeoBBox(dx01, wallDy, dz);
+  auto* sh12 = new TGeoBBox(dx12, wallDy, dz);
+  auto* sh23 = new TGeoBBox(dx23, wallDy, dz);
+  sh01->SetName("VD_InclinedWall01_sh");
+  sh12->SetName("VD_InclinedWall12_sh");
+  sh23->SetName("VD_InclinedWall23_sh");
+
+  const double phi0_rad = phi0_deg * TMath::DegToRad();
+
+  for (int i = 0; i < nWalls; ++i) {
+    const double phi = phi0_rad + i * (dPhi * TMath::DegToRad());
+    const double cosPhi = std::cos(phi);
+    const double sinPhi = std::sin(phi);
+
+    // Tangency point on Rtan
+    const double xT = Rtan * cosPhi;
+    const double yT = Rtan * sinPhi;
+
+    // Tangent direction u = (-sin, cos)
+    const double ux = -sinPhi;
+    const double uy = cosPhi;
+
+    // Centers (in XY)
+    const double cx01 = xT + sc01 * ux;
+    const double cy01 = yT + sc01 * uy;
+    const double cx12 = xT + sc12 * ux;
+    const double cy12 = yT + sc12 * uy;
+    const double cx23 = xT + sc23 * ux;
+    const double cy23 = yT + sc23 * uy;
+
+    // Rotation: local X along tangent => angle = phi + 90°
+    const double alpha_deg = phi0_deg + i * dPhi + 90.0;
+    auto* rot = new TGeoRotation();
+    rot->RotateZ(alpha_deg);
+
+    // Create volumes per wall (unique names)
+    auto* v01 = new TGeoVolume(Form("VD_InclinedWall01_%d", i), sh01, med);
+    auto* v12 = new TGeoVolume(Form("VD_InclinedWall12_%d", i), sh12, med);
+    auto* v23 = new TGeoVolume(Form("VD_InclinedWall23_%d", i), sh23, med);
+    v01->SetLineColor(kOrange + 7);
+    v12->SetLineColor(kOrange + 7);
+    v23->SetLineColor(kOrange + 7);
+    v01->SetTransparency(70);
+    v12->SetTransparency(70);
+    v23->SetTransparency(70);
+
+    auto* T01 = new TGeoCombiTrans(cx01, cy01, 0.0, rot);
+    auto* T12 = new TGeoCombiTrans(cx12, cy12, 0.0, new TGeoRotation(*rot));
+    auto* T23 = new TGeoCombiTrans(cx23, cy23, 0.0, new TGeoRotation(*rot));
+
+    petalAsm->AddNode(v01, 1, T01);
+    petalAsm->AddNode(v12, 1, T12);
+    petalAsm->AddNode(v23, 1, T23);
+
+    LOGP(debug,
+         "InclinedWall {}: 01({:.3f},{:.3f}) 12({:.3f},{:.3f}) 23({:.3f},{:.3f}) angle={:.2f}°",
+         i, cx01, cy01, cx12, cy12, cx23, cy23, alpha_deg);
+  }
+}
+
 // =================== Public entry points ===================
 
 void createIRIS4Geometry(TGeoVolume* motherVolume)
@@ -908,6 +1072,31 @@ void createIRISGeometryFullCyl(TGeoVolume* motherVolume)
   buildIrisCutoutFromPetalSolid(nPetals);
 }
 
+void createIRISGeometry3InclinedWalls(TGeoVolume* motherVolume)
+{
+  if (!motherVolume) {
+    LOGP(error, "createIRISGeometry3InclinedWalls: motherVolume is null");
+    return;
+  }
+
+  clearVDSensorRegistry();
+
+  constexpr int nPetals = 1;
+  constexpr int petalID = 0;
+
+  // Start from the same content as createIRISGeometryFullCyl
+  auto* petal = buildFullCylAssembly(petalID, /*withDisks=*/false);
+
+  // Add the 3 inclined walls into the same assembly
+  addInclinedWalls3FullCyl(petal, kInclinedWallPhi0_deg);
+
+  motherVolume->AddNode(petal, 1, nullptr);
+
+  // Same cutout pipeline as full-cyl
+  buildPetalSolidsComposite(petal);
+  buildIrisCutoutFromPetalSolid(nPetals);
+}
+
 void createIRISGeometryFullCylwithDisks(TGeoVolume* motherVolume)
 {
   if (!motherVolume) {

From 3626eeac1a4c8a21fbafeee349d1bc7576777f33 Mon Sep 17 00:00:00 2001
From: AizatDaribayeva <aizat.daribayeva@cern.ch>
Date: Tue, 3 Mar 2026 10:35:34 +0100
Subject: [PATCH 1379/1764] [ALICE3] TRK/Geometry: small bug fix (#15112)

---
 .../TRK/base/include/TRKBase/GeometryTGeo.h     | 17 +++++++++++++++--
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx        |  2 +-
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index bb1597f2967e4..d4402d66cff7e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -104,8 +104,21 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   bool isTrackingFrameCachedMLOT() const { return !mCacheRefXMLOT.empty(); }
   void fillTrackingFramesCacheMLOT();
 
-  float getSensorRefAlphaMLOT(int index) const { return mCacheRefAlphaMLOT[index]; }
-  float getSensorXMLOT(int index) const { return mCacheRefXMLOT[index]; }
+  float getSensorRefAlphaMLOT(int chipId) const
+  {
+    assert(getSubDetID(chipId) != 0 && "Called MLOT getter with VD chipId");
+    const int local = chipId - getNumberOfActivePartsVD();
+    assert(local >= 0 && local < (int)mCacheRefAlphaMLOT.size());
+    return mCacheRefAlphaMLOT[local];
+  }
+
+  float getSensorXMLOT(int chipId) const
+  {
+    assert(getSubDetID(chipId) != 0 && "Called MLOT getter with VD chipId");
+    const int local = chipId - getNumberOfActivePartsVD();
+    assert(local >= 0 && local < (int)mCacheRefXMLOT.size());
+    return mCacheRefXMLOT[local];
+  }
 
   // create matrix for tracking to local frame for MLOT
   TGeoHMatrix& createT2LMatrixMLOT(int);
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index b5535af781910..7b3d33ca1a75c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -127,9 +127,9 @@ void GeometryTGeo::Build(int loadTrans)
   }
 
   setSize(numberOfChipsTotal);
-  fillMatrixCache(loadTrans);
   defineMLOTSensors();
   fillTrackingFramesCacheMLOT();
+  fillMatrixCache(loadTrans);
 }
 
 //__________________________________________________________________________

From afcf287eb39a39188e3017eeda93772f00532aa7 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Tue, 3 Mar 2026 10:49:10 +0100
Subject: [PATCH 1380/1764] [ALICE3] Cluster finding of TRK (#15110)

---
 .../Detectors/Upgrades/ALICE3/CMakeLists.txt  |   1 +
 .../Upgrades/ALICE3/TRK/CMakeLists.txt        |  24 +
 .../TRK/include/DataFormatsTRK/Cluster.h      |  38 ++
 .../TRK/include/DataFormatsTRK/ROFRecord.h    |  75 ++++
 .../Upgrades/ALICE3/TRK/src/Cluster.cxx       |  28 ++
 .../ALICE3/TRK/src/DataFormatsTRKLinkDef.h    |  25 ++
 .../Upgrades/ALICE3/TRK/src/ROFRecord.cxx     |  29 ++
 .../ALICE3/TRK/macros/test/CMakeLists.txt     |  10 +-
 .../ALICE3/TRK/macros/test/CheckClusters.C    | 417 +++++++++++++++++
 .../ALICE3/TRK/reconstruction/CMakeLists.txt  |   3 +
 .../include/TRKReconstruction/Clusterer.h     | 182 ++++++++
 .../TRK/reconstruction/src/Clusterer.cxx      | 419 ++++++++++++++++++
 .../src/TRKReconstructionLinkDef.h            |   1 +
 .../ALICE3/TRK/workflow/CMakeLists.txt        |   3 +
 .../include/TRKWorkflow/ClusterWriterSpec.h   |  24 +
 .../include/TRKWorkflow/ClustererSpec.h       |  39 ++
 .../TRK/workflow/src/ClusterWriterSpec.cxx    |  65 +++
 .../ALICE3/TRK/workflow/src/ClustererSpec.cxx |  99 +++++
 .../ALICE3/TRK/workflow/src/RecoWorkflow.cxx  |  21 +-
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   |  10 +-
 20 files changed, 1507 insertions(+), 6 deletions(-)
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/TRK/include/DataFormatsTRK/Cluster.h
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/TRK/include/DataFormatsTRK/ROFRecord.h
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/TRK/src/Cluster.cxx
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/TRK/src/DataFormatsTRKLinkDef.h
 create mode 100644 DataFormats/Detectors/Upgrades/ALICE3/TRK/src/ROFRecord.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClusterWriterSpec.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/ClusterWriterSpec.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx

diff --git a/DataFormats/Detectors/Upgrades/ALICE3/CMakeLists.txt b/DataFormats/Detectors/Upgrades/ALICE3/CMakeLists.txt
index b3944c2e502d8..360b50d442d7d 100644
--- a/DataFormats/Detectors/Upgrades/ALICE3/CMakeLists.txt
+++ b/DataFormats/Detectors/Upgrades/ALICE3/CMakeLists.txt
@@ -10,3 +10,4 @@
 # or submit itself to any jurisdiction.
 
 add_subdirectory(FD3)
+add_subdirectory(TRK)
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt b/DataFormats/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
new file mode 100644
index 0000000000000..c239a2a36845d
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/TRK/CMakeLists.txt
@@ -0,0 +1,24 @@
+# Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(DataFormatsTRK
+  SOURCES src/Cluster.cxx
+          src/ROFRecord.cxx
+  PUBLIC_LINK_LIBRARIES O2::CommonDataFormat
+                        O2::DataFormatsITSMFT
+                        O2::SimulationDataFormat
+)
+
+o2_target_root_dictionary(DataFormatsTRK
+  HEADERS include/DataFormatsTRK/Cluster.h
+          include/DataFormatsTRK/ROFRecord.h
+  LINKDEF src/DataFormatsTRKLinkDef.h
+)
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/TRK/include/DataFormatsTRK/Cluster.h b/DataFormats/Detectors/Upgrades/ALICE3/TRK/include/DataFormatsTRK/Cluster.h
new file mode 100644
index 0000000000000..ec68191b3c43f
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/TRK/include/DataFormatsTRK/Cluster.h
@@ -0,0 +1,38 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_DATAFORMATSTRK_CLUSTER_H
+#define ALICEO2_DATAFORMATSTRK_CLUSTER_H
+
+#include <Rtypes.h>
+#include <cstdint>
+#include <string>
+
+namespace o2::trk
+{
+
+struct Cluster {
+  uint16_t chipID = 0;
+  uint16_t row = 0;
+  uint16_t col = 0;
+  uint16_t size = 1;
+  int16_t subDetID = -1;
+  int16_t layer = -1;
+  int16_t disk = -1;
+
+  std::string asString() const;
+
+  ClassDefNV(Cluster, 1);
+};
+
+} // namespace o2::trk
+
+#endif
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/TRK/include/DataFormatsTRK/ROFRecord.h b/DataFormats/Detectors/Upgrades/ALICE3/TRK/include/DataFormatsTRK/ROFRecord.h
new file mode 100644
index 0000000000000..86ee31389fd5f
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/TRK/include/DataFormatsTRK/ROFRecord.h
@@ -0,0 +1,75 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_DATAFORMATSTRK_ROFRECORD_H
+#define ALICEO2_DATAFORMATSTRK_ROFRECORD_H
+
+#include "CommonDataFormat/InteractionRecord.h"
+#include "CommonDataFormat/RangeReference.h"
+#include <Rtypes.h>
+#include <cstdint>
+#include <string>
+
+namespace o2::trk
+{
+
+class ROFRecord
+{
+ public:
+  using EvIdx = o2::dataformats::RangeReference<int, int>;
+  using BCData = o2::InteractionRecord;
+  using ROFtype = unsigned int;
+
+  ROFRecord() = default;
+  ROFRecord(const BCData& bc, ROFtype rof, int idx, int n)
+    : mBCData(bc), mROFEntry(idx, n), mROFrame(rof) {}
+
+  void setBCData(const BCData& bc) { mBCData = bc; }
+  void setROFrame(ROFtype rof) { mROFrame = rof; }
+  void setEntry(EvIdx entry) { mROFEntry = entry; }
+  void setFirstEntry(int idx) { mROFEntry.setFirstEntry(idx); }
+  void setNEntries(int n) { mROFEntry.setEntries(n); }
+
+  const BCData& getBCData() const { return mBCData; }
+  BCData& getBCData() { return mBCData; }
+  EvIdx getEntry() const { return mROFEntry; }
+  EvIdx& getEntry() { return mROFEntry; }
+  int getNEntries() const { return mROFEntry.getEntries(); }
+  int getFirstEntry() const { return mROFEntry.getFirstEntry(); }
+  ROFtype getROFrame() const { return mROFrame; }
+
+  std::string asString() const;
+
+ private:
+  o2::InteractionRecord mBCData;
+  EvIdx mROFEntry;
+  ROFtype mROFrame = 0;
+
+  ClassDefNV(ROFRecord, 1);
+};
+
+struct MC2ROFRecord {
+  using ROFtype = unsigned int;
+
+  int eventRecordID = -1;
+  int rofRecordID = 0;
+  ROFtype minROF = 0;
+  ROFtype maxROF = 0;
+
+  MC2ROFRecord() = default;
+  MC2ROFRecord(int evID, int rofRecID, ROFtype mnrof, ROFtype mxrof) : eventRecordID(evID), rofRecordID(rofRecID), minROF(mnrof), maxROF(mxrof) {}
+
+  ClassDefNV(MC2ROFRecord, 1);
+};
+
+} // namespace o2::trk
+
+#endif
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/Cluster.cxx b/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/Cluster.cxx
new file mode 100644
index 0000000000000..6c96692ea5a9e
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/Cluster.cxx
@@ -0,0 +1,28 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "DataFormatsTRK/Cluster.h"
+#include <sstream>
+
+ClassImp(o2::trk::Cluster);
+
+namespace o2::trk
+{
+
+std::string Cluster::asString() const
+{
+  std::ostringstream stream;
+  stream << "chip=" << chipID << " row=" << row << " col=" << col << " size=" << size
+         << " subDet=" << subDetID << " layer=" << layer << " disk=" << disk;
+  return stream.str();
+}
+
+} // namespace o2::trk
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/DataFormatsTRKLinkDef.h b/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/DataFormatsTRKLinkDef.h
new file mode 100644
index 0000000000000..36528d9dd2c46
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/DataFormatsTRKLinkDef.h
@@ -0,0 +1,25 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::trk::Cluster + ;
+#pragma link C++ class std::vector < o2::trk::Cluster> + ;
+#pragma link C++ class o2::trk::ROFRecord + ;
+#pragma link C++ class std::vector < o2::trk::ROFRecord> + ;
+#pragma link C++ class o2::trk::MC2ROFRecord + ;
+#pragma link C++ class std::vector < o2::trk::MC2ROFRecord> + ;
+
+#endif
diff --git a/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/ROFRecord.cxx b/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/ROFRecord.cxx
new file mode 100644
index 0000000000000..79745f9854eb7
--- /dev/null
+++ b/DataFormats/Detectors/Upgrades/ALICE3/TRK/src/ROFRecord.cxx
@@ -0,0 +1,29 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "DataFormatsTRK/ROFRecord.h"
+#include <sstream>
+
+ClassImp(o2::trk::ROFRecord);
+ClassImp(o2::trk::MC2ROFRecord);
+
+namespace o2::trk
+{
+
+std::string ROFRecord::asString() const
+{
+  std::ostringstream stream;
+  stream << "IR=" << mBCData.asString() << " ROFrame=" << mROFrame
+         << " first=" << mROFEntry.getFirstEntry() << " n=" << mROFEntry.getEntries();
+  return stream.str();
+}
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
index d9908bbfeb1e5..edd9c785d89ce 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
@@ -28,4 +28,12 @@ o2_add_test_root_macro(CheckTracksCA.C
                                              O2::TRKBase
                                              O2::TRKSimulation
                                              O2::Steer
-                       LABELS trk COMPILE_ONLY)
\ No newline at end of file
+                       LABELS trk COMPILE_ONLY)
+
+o2_add_test_root_macro(CheckClusters.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsTRK
+                                             O2::SimulationDataFormat
+                                             O2::Framework
+                                             O2::TRKBase
+                                             O2::TRKSimulation
+                       LABELS trk COMPILE_ONLY)
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
new file mode 100644
index 0000000000000..327577102d86e
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
@@ -0,0 +1,417 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CheckClusters.C
+/// \brief Macro to check TRK clusters and compare cluster positions to MC hit positions
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <TCanvas.h>
+#include <TFile.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TNtuple.h>
+#include <TString.h>
+#include <TTree.h>
+#include <TROOT.h>
+#include <TStyle.h>
+#include <unordered_map>
+
+#include "DataFormatsTRK/Cluster.h"
+#include "DataFormatsTRK/ROFRecord.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/SegmentationChip.h"
+#include "TRKSimulation/Hit.h"
+#include "ITSMFTSimulation/AlpideSimResponse.h"
+#include "CCDB/BasicCCDBManager.h"
+#include "MathUtils/Cartesian.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "Framework/Logger.h"
+#endif
+
+void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
+                   const std::string& hitfile = "o2sim_HitsTRK.root",
+                   const std::string& inputGeom = "o2sim_geometry.root",
+                   const std::string& ccdbUrl = "http://alice-ccdb.cern.ch",
+                   long ccdbTimestamp = -1,
+                   bool batch = false)
+{
+  gROOT->SetBatch(batch);
+
+  using o2::MCCompLabel;
+  using ROFRec = o2::trk::ROFRecord;
+  using MC2ROF = o2::trk::MC2ROFRecord;
+  using HitVec = std::vector<o2::trk::Hit>;
+  using MC2HITS_map = std::unordered_map<uint64_t, int>; // maps (trackID << 32) + chipID -> hit index
+
+  // ── Chip response (for hit-segment propagation to charge-collection plane) ──
+  // Fetches the same AlpideSimResponse from CCDB as the digitizer (IT3/Calib/APTSResponse)
+  // and computes Y-intersection planes with the same formulas from Digitizer::init()
+  auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance();
+  ccdbMgr.setURL(ccdbUrl);
+  if (ccdbTimestamp > 0) {
+    ccdbMgr.setTimestamp(ccdbTimestamp);
+  }
+  auto* alpResp = ccdbMgr.get<o2::itsmft::AlpideSimResponse>("IT3/Calib/APTSResponse");
+  if (!alpResp) {
+    LOGP(fatal, "Cannot retrieve AlpideSimResponse from CCDB at {}", ccdbUrl);
+    return;
+  }
+  const float depthMax = alpResp->getDepthMax();
+
+  // ── Y-plane shifts: why VD and ML/OT need different values ────────────────
+  //
+  // The APTS pixel response (AlpideSimResponse) uses an internal Y axis where:
+  //
+  //        y = depthMax  ──  beam-entry (top) surface
+  //        y = 0         ──  charge-collection plane   ← where clusters form
+  //        y < 0         ──  substrate (no response)
+  //
+  // The digitizer (Digitizer::init()) brings hit Y coordinates into this frame
+  // by adding a per-sub-detector shift before querying the response:
+  //
+  //     y_APTS = y_local + shift                  [Digitizer.cxx ::processHit]
+  //
+  // The collection plane (y_APTS = 0) is therefore at  y_local = −shift
+  // in the detector local frame.  That is the Y value used here when
+  // propagating the MC hit segment to a single representative point.
+  //
+  // ── VD (vertex detector – curved sensors) ─────────────────────────────────
+  // After SegmentationChip::curvedToFlat() (convention: yFlat = dist − R):
+  //   outer face (beam-entry): yFlat = +halfThickVD = +10 µm
+  //   inner face (exit):       yFlat = −halfThickVD = −10 µm
+  // The digitizer uses:
+  //
+  //     mSimRespVDShift = depthMax − halfThickVD
+  //
+  // so the collection plane (y_APTS = 0) corresponds to:
+  //
+  //     yPlaneVD = alice3resp::responseYShift = +5 µm
+  //
+  // i.e. 5 µm inside from the outer (entry) face. ✓
+  //
+  // ── ML/OT (middle/outer tracker – flat sensors) ────────────────────────────
+  // The local Y origin is at the GEOMETRIC CENTRE of the sensor volume.
+  // The outer (entry) surface is at y_local = +SiliconThicknessMLOT/2.
+  // The digitizer uses:
+  //
+  //     mSimRespMLOTShift = depthMax − SiliconThicknessMLOT / 2
+  //
+  // so the collection plane (y_APTS = 0) is at:
+  //
+  //     yPlaneMLOT = SiliconThicknessMLOT/2 − depthMax
+  //
+  // ──────────────────────────────────────────────────────────────────────────
+  const float halfThicknessMLOT = o2::trk::SegmentationChip::SiliconThicknessMLOT / 2.f;
+  const float yPlaneVD = (float)o2::trk::constants::alice3resp::responseYShift; // VD: collection plane 5 µm inside outer (entry) face in flat local frame
+  const float yPlaneMLOT = halfThicknessMLOT - depthMax;                        // MLOT: entry @ +halfThick, collection depthMax below entry
+  LOGP(info, "Response depthMax = {:.4f} cm  |  VD Y-plane = {:.4f} cm  |  ML/OT Y-plane = {:.4f} cm",
+       depthMax, yPlaneVD, yPlaneMLOT);
+
+  // ── Geometry ───────────────────────────────────────────────────────────────
+  o2::base::GeometryManager::loadGeometry(inputGeom);
+  auto gman = o2::trk::GeometryTGeo::Instance();
+  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+
+  // ── Hits ───────────────────────────────────────────────────────────────────
+  TFile fileH(hitfile.data());
+  auto* hitTree = dynamic_cast<TTree*>(fileH.Get("o2sim"));
+  if (!hitTree) {
+    LOGP(error, "Cannot find o2sim tree in {}", hitfile);
+    return;
+  }
+  std::vector<MC2HITS_map> mc2hitVec;
+  std::vector<HitVec*> hitVecPool;
+  mc2hitVec.resize(hitTree->GetEntries());
+  hitVecPool.resize(hitTree->GetEntries(), nullptr);
+
+  // ── Clusters ───────────────────────────────────────────────────────────────
+  TFile fileC(clusfile.data());
+  auto* clusTree = dynamic_cast<TTree*>(fileC.Get("o2sim"));
+  if (!clusTree) {
+    LOGP(error, "Cannot find o2sim tree in {}", clusfile);
+    return;
+  }
+
+  std::vector<o2::trk::Cluster>* clusArr = nullptr;
+  std::vector<o2::trk::ROFRecord>* rofRecVecP = nullptr;
+  std::vector<unsigned char>* patternsPtr = nullptr;
+  clusTree->SetBranchAddress("TRKClusterComp", &clusArr);
+  clusTree->SetBranchAddress("TRKClustersROF", &rofRecVecP);
+  if (clusTree->GetBranch("TRKClusterPatt") != nullptr) {
+    clusTree->SetBranchAddress("TRKClusterPatt", &patternsPtr);
+  }
+
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel>* clusLabArr = nullptr;
+  std::vector<MC2ROF> mc2rofVec, *mc2rofVecP = &mc2rofVec;
+  bool hasMC = (clusTree->GetBranch("TRKClusterMCTruth") != nullptr);
+  if (hasMC) {
+    clusTree->SetBranchAddress("TRKClusterMCTruth", &clusLabArr);
+    clusTree->SetBranchAddress("TRKClustersMC2ROF", &mc2rofVecP);
+  }
+
+  clusTree->GetEntry(0);
+  const unsigned int nROFRec = rofRecVecP ? (unsigned int)rofRecVecP->size() : 0u;
+  LOGP(info, "Number of ROF records: {}", nROFRec);
+  auto pattIt = patternsPtr ? patternsPtr->cbegin() : std::vector<unsigned char>::const_iterator{};
+
+  // ── Build per-ROF MC event range ───────────────────────────────────────────
+  std::vector<int> mcEvMin(nROFRec, (int)hitTree->GetEntries());
+  std::vector<int> mcEvMax(nROFRec, -1);
+  if (hasMC) {
+    for (int imc = (int)mc2rofVec.size(); imc--;) {
+      const auto& mc2rof = mc2rofVec[imc];
+      if (mc2rof.rofRecordID < 0) {
+        continue;
+      }
+      for (unsigned int irfd = mc2rof.maxROF - mc2rof.minROF + 1; irfd--;) {
+        unsigned int irof = mc2rof.rofRecordID + irfd;
+        if (irof >= nROFRec) {
+          continue;
+        }
+        if (mcEvMin[irof] > imc) {
+          mcEvMin[irof] = imc;
+        }
+        if (mcEvMax[irof] < imc) {
+          mcEvMax[irof] = imc;
+        }
+      }
+    }
+  }
+
+  // ── Output ─────────────────────────────────────────────────────────────────
+  TFile fout("CheckClusters.root", "recreate");
+  // columns: event, MC track label,
+  //   local hit x/z (flat frame), global hit x/y/z (midpoint),
+  //   global cluster x/y/z, local cluster x/z,
+  //   residuals dx/dz (local, cluster - hit),
+  //   ROF frame, cluster size, chipID, layer, disk, subDetID, row, col, pt
+  TNtuple nt("ntc", "TRK cluster ntuple",
+             "event:mcTrackID:hitLocX:hitLocZ:hitGlobX:hitGlobY:hitGlobZ:clusGlobX:clusGlobY:clusGlobZ:clusLocX:clusLocZ:rofFrame:clusSize:chipID:layer:disk:subdet:row:col:pt");
+
+  // ── Counters ───────────────────────────────────────────────────────────────
+  long nTot{0}, nInvalidLabel{0}, nNoMCHit{0}, nValid{0};
+
+  // ── Main loop ──────────────────────────────────────────────────────────────
+  for (unsigned int irof = 0; irof < nROFRec; irof++) {
+    const auto& rofRec = (*rofRecVecP)[irof];
+
+    // Cache MC hit events for this ROF
+    if (hasMC) {
+      for (int im = mcEvMin[irof]; im <= mcEvMax[irof]; im++) {
+        if (hitVecPool[im] == nullptr) {
+          hitTree->SetBranchAddress("TRKHit", &hitVecPool[im]);
+          hitTree->GetEntry(im);
+          auto& mc2hit = mc2hitVec[im];
+          const auto* hv = hitVecPool[im];
+          for (int ih = (int)hv->size(); ih--;) {
+            const auto& hit = (*hv)[ih];
+            uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
+            mc2hit.emplace(key, ih);
+          }
+        }
+      }
+    }
+
+    for (int icl = 0; icl < rofRec.getNEntries(); icl++) {
+      const int clEntry = rofRec.getFirstEntry() + icl;
+      const auto& cluster = (*clusArr)[clEntry];
+      nTot++;
+
+      // ── Parse pattern → center-of-gravity within bounding box ──────────
+      // The cluster stores the bounding-box top-left pixel (row, col).
+      // The pattern stream encodes [rowSpan, colSpan, bitmap...] for each cluster.
+      // We accumulate pixel row/col offsets to obtain a sub-pixel CoG correction.
+      float cogDr{0.f}, cogDc{0.f}; // mean offsets from bbox origin (pixels)
+      if (patternsPtr) {
+        const uint8_t rowSpan = *pattIt++;
+        const uint8_t colSpan = *pattIt++;
+        const int nBytes = (rowSpan * colSpan + 7) / 8;
+        int nPix{0}, pixIdx{0};
+        for (int ib = 0; ib < nBytes; ib++) {
+          const uint8_t byte = *pattIt++;
+          for (int bit = 7; bit >= 0 && pixIdx < rowSpan * colSpan; bit--, pixIdx++) {
+            if (byte & (1 << bit)) {
+              cogDr += pixIdx / colSpan;
+              cogDc += pixIdx % colSpan;
+              nPix++;
+            }
+          }
+        }
+        if (nPix > 1) {
+          cogDr /= nPix;
+          cogDc /= nPix;
+        }
+      }
+
+      // ── Cluster local → global (CoG position) ─────────────────────────────
+      // Get local coords of the bounding-box corner pixel, then apply the
+      // fractional CoG displacement using the pixel pitch.
+      // Formula from detectorToLocalUnchecked:
+      //   VD  : xRow = 0.5*(width[lay]-pitchRow) - row*pitchRow  → row↑ xRow↓
+      //         zCol = col*pitchCol + 0.5*(pitchCol-length)      → col↑ zCol↑
+      //   MLOT: same structure with MLOT pitches
+      float clLocX{0.f}, clLocZ{0.f};
+      o2::trk::SegmentationChip::detectorToLocalUnchecked(
+        cluster.row, cluster.col, clLocX, clLocZ,
+        cluster.subDetID, cluster.layer, cluster.disk);
+      const float pitchRow = (cluster.subDetID == 0)
+                               ? o2::trk::SegmentationChip::PitchRowVD
+                               : o2::trk::SegmentationChip::PitchRowMLOT;
+      const float pitchCol = (cluster.subDetID == 0)
+                               ? o2::trk::SegmentationChip::PitchColVD
+                               : o2::trk::SegmentationChip::PitchColMLOT;
+      clLocX -= cogDr * pitchRow; // increasing row → decreasing xRow
+      clLocZ += cogDc * pitchCol; // increasing col → increasing zCol
+      const float yResponse = (cluster.subDetID == 0) ? yPlaneVD : yPlaneMLOT;
+      // For VD the L2G matrix is built in the *curved* local frame (quasi-Cartesian,
+      // origin at the beam axis). Convert flat (clLocX, 0) → curved (xC, yC) first.
+      // For MLOT (flat sensors) the local frame is already Cartesian: pass directly.
+      // clLocX is already in the flat frame from detectorToLocalUnchecked + CoG and
+      // does NOT need any further transformation for the residual comparison.
+      o2::math_utils::Point3D<float> locC;
+      if (cluster.subDetID == 0) {
+        auto cv = o2::trk::SegmentationChip::flatToCurved(cluster.layer, clLocX, 0.f);
+        locC = {cv.X(), cv.Y(), clLocZ};
+      } else {
+        locC = {clLocX, yResponse, clLocZ};
+      }
+      auto gloC = gman->getMatrixL2G(cluster.chipID)(locC);
+
+      if (!hasMC || clusLabArr == nullptr) {
+        // No MC info: just fill geometry columns, leave residuals as 0
+        std::array<float, 21> data = {
+          -1.f, -1.f,
+          0.f, 0.f, 0.f, 0.f, 0.f,
+          (float)gloC.X(), (float)gloC.Y(), (float)gloC.Z(),
+          clLocX, clLocZ,
+          (float)rofRec.getROFrame(), (float)cluster.size, (float)cluster.chipID,
+          (float)cluster.layer, (float)cluster.disk, (float)cluster.subDetID,
+          (float)cluster.row, (float)cluster.col, -1.f};
+        nt.Fill(data.data());
+        continue;
+      }
+
+      // ── MC label ───────────────────────────────────────────────────────
+      const auto& labels = clusLabArr->getLabels(clEntry);
+      if (labels.empty() || !labels[0].isValid()) {
+        nInvalidLabel++;
+        continue;
+      }
+      const auto& lab = labels[0];
+      const int trID = lab.getTrackID();
+      const int evID = lab.getEventID();
+
+      // ── Find matching MC hit ────────────────────────────────────────────
+      const auto& mc2hit = mc2hitVec[evID];
+      uint64_t key = (uint64_t(trID) << 32) + cluster.chipID;
+      auto hitEntry = mc2hit.find(key);
+      if (hitEntry == mc2hit.end()) {
+        nNoMCHit++;
+        continue;
+      }
+      const auto& hit = (*hitVecPool[evID])[hitEntry->second];
+      const float pt = TMath::Hypot(hit.GetPx(), hit.GetPy());
+
+      // ── Hit global midpoint ────────────────────────────────────────────
+      const auto& gloHend = hit.GetPos();
+      const auto& gloHsta = hit.GetPosStart();
+      o2::math_utils::Point3D<float> gloHmid(
+        0.5f * (gloHend.X() + gloHsta.X()),
+        0.5f * (gloHend.Y() + gloHsta.Y()),
+        0.5f * (gloHend.Z() + gloHsta.Z()));
+
+      // ── Hit global → local ─────────────────────────────
+      o2::math_utils::Point3D<float> locHsta = gman->getMatrixL2G(cluster.chipID) ^ (gloHsta); // inverse L2G
+      o2::math_utils::Point3D<float> locHend = gman->getMatrixL2G(cluster.chipID) ^ (gloHend); // inverse L2G
+
+      // ── Propagate hit segment to the sensor response surface ───────────────
+      // Rather than the geometric midpoint, find where the track segment crosses
+      // the response plane (y = responseYShift in the flat local frame).
+      // For VD (curved): convert both endpoints to flat frame first.
+      // For ML/OT (flat): use local coordinates directly.
+      float hitLocX{0.f}, hitLocZ{0.f};
+      if (cluster.subDetID == 0) { // VD – curved sensor
+        auto flatSta = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHsta.X(), locHsta.Y());
+        auto flatEnd = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHend.X(), locHend.Y());
+        float x0 = flatSta.X(), y0 = flatSta.Y(), z0 = locHsta.Z();
+        float dltx = flatEnd.X() - x0, dlty = flatEnd.Y() - y0, dltz = locHend.Z() - z0;
+        float r = (std::abs(dlty) > 1e-9f) ? (yPlaneVD - y0) / dlty : 0.5f;
+        hitLocX = x0 + r * dltx;
+        hitLocZ = z0 + r * dltz;
+      } else { // ML/OT – flat sensor
+        float x0 = locHsta.X(), y0 = locHsta.Y(), z0 = locHsta.Z();
+        float dltx = locHend.X() - x0, dlty = locHend.Y() - y0, dltz = locHend.Z() - z0;
+        float r = (std::abs(dlty) > 1e-9f) ? (yPlaneMLOT - y0) / dlty : 0.5f;
+        hitLocX = x0 + r * dltx;
+        hitLocZ = z0 + r * dltz;
+      }
+
+      nValid++;
+      std::array<float, 21> data = {
+        (float)evID, (float)trID,
+        hitLocX, hitLocZ,
+        (float)gloHmid.X(), (float)gloHmid.Y(), (float)gloHmid.Z(),
+        (float)gloC.X(), (float)gloC.Y(), (float)gloC.Z(),
+        clLocX, clLocZ,
+        (float)rofRec.getROFrame(), (float)cluster.size, (float)cluster.chipID,
+        (float)cluster.layer, (float)cluster.disk, (float)cluster.subDetID,
+        (float)cluster.row, (float)cluster.col, pt};
+      nt.Fill(data.data());
+    }
+  }
+
+  // ── Summary ────────────────────────────────────────────────────────────────
+  LOGP(info, "=== TRK Cluster vs Hit Summary ===");
+  LOGP(info, "Total clusters:          {}", nTot);
+  LOGP(info, "Valid (hit matched):     {}", nValid);
+  LOGP(info, "Invalid/noise MC labels: {}", nInvalidLabel);
+  LOGP(info, "MC hit not found:        {}", nNoMCHit);
+  // ── Visualisation ──────────────────────────────────────────────────────────
+  auto canvGlobal = new TCanvas("canvGlobal", "Cluster global positions", 1600, 800);
+  canvGlobal->Divide(2, 1);
+  canvGlobal->cd(1);
+  nt.Draw("clusGlobY:clusGlobX>>h_yx(500,-50,50,500,-50,50)", "", "colz");
+  canvGlobal->cd(2);
+  nt.Draw("clusGlobY:clusGlobZ>>h_yz(500,-100,100,500,-50,50)", "", "colz");
+  canvGlobal->SaveAs("trk_clusters_global.png");
+
+  auto canvRes = new TCanvas("canvRes", "Residuals (cluster - hit) [cm]", 1600, 1200);
+  canvRes->Divide(2, 3);
+  canvRes->cd(1)->SetLogy();
+  nt.Draw("hitLocX-clusLocX>>h_dx_VD(200,-0.02,0.02)", "subdet==0&&event>=0");
+  canvRes->cd(2)->SetLogy();
+  nt.Draw("hitLocZ-clusLocZ>>h_dz_VD(200,-0.02,0.02)", "subdet==0&&event>=0");
+  canvRes->cd(3)->SetLogy();
+  nt.Draw("hitLocX-clusLocX>>h_dx_MLOT(200,-0.02,0.02)", "subdet==1&&event>=0");
+  canvRes->cd(4)->SetLogy();
+  nt.Draw("hitLocZ-clusLocZ>>h_dz_MLOT(200,-0.02,0.02)", "subdet==1&&event>=0");
+  canvRes->cd(5)->SetLogz();
+  nt.Draw("hitLocX-clusLocX:hitLocZ-clusLocZ>>h_dxdz_VD(200,-0.02,0.02,200,-0.02,0.02)", "subdet==0&&event>=0", "colz");
+  canvRes->cd(6);
+  nt.Draw("hitLocX-clusLocX:hitLocZ-clusLocZ>>h_dxdz_MLOT(200,-0.02,0.02,200,-0.02,0.02)", "subdet==1&&event>=0", "colz");
+  canvRes->SaveAs("trk_residuals.png");
+
+  auto canvResVsLayer = new TCanvas("canvResVsLayer", "Residuals vs layer", 1600, 600);
+  canvResVsLayer->Divide(2, 1);
+  canvResVsLayer->cd(1);
+  nt.Draw("hitLocX-clusLocX:layer>>h_dx_vs_lay(20,0,20,200,-0.02,0.02)", "event>=0", "prof");
+  canvResVsLayer->cd(2);
+  nt.Draw("hitLocZ-clusLocZ:layer>>h_dz_vs_lay(20,0,20,200,-0.02,0.02)", "event>=0", "prof");
+  canvResVsLayer->SaveAs("trk_residuals_vs_layer.png");
+
+  fout.cd();
+  nt.Write();
+  fout.Close();
+
+  LOGP(info, "Output saved to CheckClusters.root and PNG files");
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
index 01ddc783d192b..b9866c7d6aa4d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
@@ -12,12 +12,14 @@
 o2_add_library(TRKReconstruction
                TARGETVARNAME targetName
                SOURCES src/TimeFrame.cxx
+                       src/Clusterer.cxx
                PUBLIC_LINK_LIBRARIES
                        O2::ITStracking
                        O2::GPUCommon
                        Microsoft.GSL::GSL
                        O2::CommonConstants
                        O2::DataFormatsITSMFT
+                       O2::DataFormatsTRK
                        O2::SimulationDataFormat
                        O2::ITSBase
                        O2::ITSReconstruction
@@ -31,4 +33,5 @@ o2_add_library(TRKReconstruction
 
 o2_target_root_dictionary(TRKReconstruction
                           HEADERS include/TRKReconstruction/TimeFrame.h
+                                  include/TRKReconstruction/Clusterer.h
                           LINKDEF src/TRKReconstructionLinkDef.h)
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
new file mode 100644
index 0000000000000..abddafa312fb9
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
@@ -0,0 +1,182 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Clusterer.h
+/// \brief Definition of the TRK cluster finder
+
+#ifndef ALICEO2_TRK_CLUSTERER_H
+#define ALICEO2_TRK_CLUSTERER_H
+
+// uncomment to allow diagonal clusters, e.g. |* |
+//                                            | *|
+#define _ALLOW_DIAGONAL_TRK_CLUSTERS_
+
+#include "DataFormatsITSMFT/Digit.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsITSMFT/ClusterPattern.h"
+#include "DataFormatsTRK/Cluster.h"
+#include "DataFormatsTRK/ROFRecord.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "TRKBase/Specs.h"
+#include <gsl/span>
+#include <vector>
+#include <array>
+#include <memory>
+#include <cstring>
+#include <utility>
+
+namespace o2::trk
+{
+
+class GeometryTGeo;
+
+class Clusterer
+{
+ public:
+  static constexpr int MaxLabels = 10;
+  static constexpr int MaxHugeClusWarn = 5;
+
+  using Digit = o2::itsmft::Digit;
+  using DigROFRecord = o2::itsmft::ROFRecord;
+  using DigMC2ROFRecord = o2::itsmft::MC2ROFRecord;
+  using ClusterTruth = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
+  using ConstDigitTruth = o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>;
+  using Label = o2::MCCompLabel;
+
+  //----------------------------------------------
+  struct BBox {
+    uint16_t chipID = 0xffff;
+    uint16_t rowMin = 0xffff, colMin = 0xffff;
+    uint16_t rowMax = 0, colMax = 0;
+    explicit BBox(uint16_t c) : chipID(c) {}
+    bool isInside(uint16_t r, uint16_t c) const { return r >= rowMin && r <= rowMax && c >= colMin && c <= colMax; }
+    uint16_t rowSpan() const { return rowMax - rowMin + 1; }
+    uint16_t colSpan() const { return colMax - colMin + 1; }
+    bool isAcceptableSize() const
+    {
+      return rowSpan() <= o2::itsmft::ClusterPattern::MaxRowSpan &&
+             colSpan() <= o2::itsmft::ClusterPattern::MaxColSpan;
+    }
+    void adjust(uint16_t r, uint16_t c)
+    {
+      if (r < rowMin) {
+        rowMin = r;
+      }
+      if (r > rowMax) {
+        rowMax = r;
+      }
+      if (c < colMin) {
+        colMin = c;
+      }
+      if (c > colMax) {
+        colMax = c;
+      }
+    }
+  };
+
+  //----------------------------------------------
+  struct ClustererThread {
+    Clusterer* parent = nullptr;
+    // column buffers (pre-cluster state); extra sentinel entries at [0] and [size-1]
+    int* column1 = nullptr;
+    int* column2 = nullptr;
+    int* curr = nullptr;                               ///< current column pre-cluster indices
+    int* prev = nullptr;                               ///< previous column pre-cluster indices
+    int size = constants::moduleMLOT::chip::nRows + 2; ///< reallocated per chip in initChip
+
+    // pixels[i] = {next_in_chain, global_digit_index}
+    std::vector<std::pair<int, uint32_t>> pixels;
+    std::vector<int> preClusterHeads;
+    std::vector<int> preClusterIndices;
+    uint16_t currCol = 0xffff;
+    bool noLeftCol = true;
+
+    std::array<Label, MaxLabels> labelsBuff;               ///< MC label buffer for one cluster
+    std::vector<std::pair<uint16_t, uint16_t>> pixArrBuff; ///< (row,col) pixel buffer for pattern
+
+    // per-thread output (accumulated, then merged back by caller)
+    std::vector<Cluster> clusters;
+    std::vector<unsigned char> patterns;
+    ClusterTruth labels;
+
+    ///< reset column buffer
+    void resetColumn(int* buff) const { std::memset(buff, -1, sizeof(int) * (size - 2)); }
+    ///< swap current and previous column buffers
+    void swapColumnBuffers() { std::swap(prev, curr); }
+
+    ///< append pixel ip to the pre-cluster headed at preClusterIndex
+    void expandPreCluster(uint32_t ip, uint16_t row, int preClusterIndex)
+    {
+      auto& firstIndex = preClusterHeads[preClusterIndices[preClusterIndex]];
+      pixels.emplace_back(firstIndex, ip);
+      firstIndex = pixels.size() - 1;
+      curr[row] = preClusterIndex;
+    }
+
+    ///< start a new pre-cluster with pixel ip at given row
+    void addNewPreCluster(uint32_t ip, uint16_t row)
+    {
+      preClusterHeads.push_back(pixels.size());
+      pixels.emplace_back(-1, ip);
+      int lastIndex = preClusterIndices.size();
+      preClusterIndices.push_back(lastIndex);
+      curr[row] = lastIndex;
+    }
+
+    void fetchMCLabels(uint32_t digID, const ConstDigitTruth* labelsDig, int& nfilled);
+    void initChip(gsl::span<const Digit> digits, uint32_t first, GeometryTGeo* geom);
+    void updateChip(gsl::span<const Digit> digits, uint32_t ip);
+    void finishChip(gsl::span<const Digit> digits,
+                    const ConstDigitTruth* labelsDigPtr, ClusterTruth* labelsClusPtr,
+                    GeometryTGeo* geom);
+    void finishChipSingleHitFast(gsl::span<const Digit> digits, uint32_t hit,
+                                 const ConstDigitTruth* labelsDigPtr, ClusterTruth* labelsClusPtr,
+                                 GeometryTGeo* geom);
+    void processChip(gsl::span<const Digit> digits, int chipFirst, int chipN,
+                     std::vector<Cluster>* clustersOut, std::vector<unsigned char>* patternsOut,
+                     const ConstDigitTruth* labelsDigPtr, ClusterTruth* labelsClusPtr,
+                     GeometryTGeo* geom);
+    void streamCluster(const BBox& bbox, const std::vector<std::pair<uint16_t, uint16_t>>& pixbuf,
+                       uint32_t totalCharge, bool doLabels, int nlab,
+                       uint16_t chipID, int subDetID, int layer, int disk);
+
+    ~ClustererThread()
+    {
+      delete[] column1;
+      delete[] column2;
+    }
+    explicit ClustererThread(Clusterer* par = nullptr) : parent(par) {}
+    ClustererThread(const ClustererThread&) = delete;
+    ClustererThread& operator=(const ClustererThread&) = delete;
+  };
+  //----------------------------------------------
+
+  void process(gsl::span<const Digit> digits,
+               gsl::span<const DigROFRecord> digitROFs,
+               std::vector<o2::trk::Cluster>& clusters,
+               std::vector<unsigned char>& patterns,
+               std::vector<o2::trk::ROFRecord>& clusterROFs,
+               const ConstDigitTruth* digitLabels = nullptr,
+               ClusterTruth* clusterLabels = nullptr,
+               gsl::span<const DigMC2ROFRecord> digMC2ROFs = {},
+               std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs = nullptr);
+
+ private:
+  int mNHugeClus = 0;
+  std::unique_ptr<ClustererThread> mThread;
+  std::vector<int> mSortIdx; ///< reusable per-ROF sort buffer
+};
+
+} // namespace o2::trk
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
new file mode 100644
index 0000000000000..bdaa76319c1f2
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
@@ -0,0 +1,419 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Clusterer.cxx
+/// \brief Implementation of the TRK cluster finder
+
+#include "TRKReconstruction/Clusterer.h"
+#include "TRKBase/GeometryTGeo.h"
+
+#include <algorithm>
+#include <numeric>
+
+namespace o2::trk
+{
+
+//__________________________________________________
+void Clusterer::process(gsl::span<const Digit> digits,
+                        gsl::span<const DigROFRecord> digitROFs,
+                        std::vector<o2::trk::Cluster>& clusters,
+                        std::vector<unsigned char>& patterns,
+                        std::vector<o2::trk::ROFRecord>& clusterROFs,
+                        const ConstDigitTruth* digitLabels,
+                        ClusterTruth* clusterLabels,
+                        gsl::span<const DigMC2ROFRecord> digMC2ROFs,
+                        std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs)
+{
+  if (!mThread) {
+    mThread = std::make_unique<ClustererThread>(this);
+  }
+
+  auto* geom = o2::trk::GeometryTGeo::Instance();
+
+  for (size_t iROF = 0; iROF < digitROFs.size(); ++iROF) {
+    const auto& inROF = digitROFs[iROF];
+    const auto outFirst = static_cast<int>(clusters.size());
+    const int first = inROF.getFirstEntry();
+    const int nEntries = inROF.getNEntries();
+
+    if (nEntries == 0) {
+      clusterROFs.emplace_back(inROF.getBCData(), inROF.getROFrame(), outFirst, 0);
+      continue;
+    }
+
+    // Sort digit indices within this ROF by (chipID, col, row) so we can process
+    // chip by chip, column by column -- the same ordering the ALPIDE scanner expects.
+    mSortIdx.resize(nEntries);
+    std::iota(mSortIdx.begin(), mSortIdx.end(), first);
+    std::sort(mSortIdx.begin(), mSortIdx.end(), [&digits](int a, int b) {
+      const auto& da = digits[a];
+      const auto& db = digits[b];
+      if (da.getChipIndex() != db.getChipIndex()) {
+        return da.getChipIndex() < db.getChipIndex();
+      }
+      if (da.getColumn() != db.getColumn()) {
+        return da.getColumn() < db.getColumn();
+      }
+      return da.getRow() < db.getRow();
+    });
+
+    // Process one chip at a time
+    int sliceStart = 0;
+    while (sliceStart < nEntries) {
+      const int chipFirst = sliceStart;
+      const uint16_t chipID = digits[mSortIdx[sliceStart]].getChipIndex();
+      while (sliceStart < nEntries && digits[mSortIdx[sliceStart]].getChipIndex() == chipID) {
+        ++sliceStart;
+      }
+      const int chipN = sliceStart - chipFirst;
+
+      mThread->processChip(digits, chipFirst, chipN, &clusters, &patterns, digitLabels, clusterLabels, geom);
+    }
+
+    clusterROFs.emplace_back(inROF.getBCData(), inROF.getROFrame(),
+                             outFirst, static_cast<int>(clusters.size()) - outFirst);
+  }
+
+  if (clusterMC2ROFs && !digMC2ROFs.empty()) {
+    clusterMC2ROFs->reserve(clusterMC2ROFs->size() + digMC2ROFs.size());
+    for (const auto& in : digMC2ROFs) {
+      clusterMC2ROFs->emplace_back(in.eventRecordID, in.rofRecordID, in.minROF, in.maxROF);
+    }
+  }
+}
+
+//__________________________________________________
+void Clusterer::ClustererThread::processChip(gsl::span<const Digit> digits,
+                                             int chipFirst, int chipN,
+                                             std::vector<Cluster>* clustersOut,
+                                             std::vector<unsigned char>* patternsOut,
+                                             const ConstDigitTruth* labelsDigPtr,
+                                             ClusterTruth* labelsClusPtr,
+                                             GeometryTGeo* geom)
+{
+  // chipFirst and chipN are relative to mSortIdx (i.e. mSortIdx[chipFirst..chipFirst+chipN-1]
+  // are the global digit indices for this chip, already sorted by col then row).
+  // We use parent->mSortIdx to resolve the global index of each pixel.
+  const auto& sortIdx = parent->mSortIdx;
+
+  if (chipN == 1) {
+    finishChipSingleHitFast(digits, sortIdx[chipFirst], labelsDigPtr, labelsClusPtr, geom);
+  } else {
+    initChip(digits, sortIdx[chipFirst], geom);
+    for (int i = chipFirst + 1; i < chipFirst + chipN; ++i) {
+      updateChip(digits, sortIdx[i]);
+    }
+    finishChip(digits, labelsDigPtr, labelsClusPtr, geom);
+  }
+
+  // Flush per-thread output into the caller's containers
+  if (!clusters.empty()) {
+    clustersOut->insert(clustersOut->end(), clusters.begin(), clusters.end());
+    clusters.clear();
+  }
+  if (!patterns.empty()) {
+    patternsOut->insert(patternsOut->end(), patterns.begin(), patterns.end());
+    patterns.clear();
+  }
+  if (labelsClusPtr && labels.getNElements()) {
+    labelsClusPtr->mergeAtBack(labels);
+    labels.clear();
+  }
+}
+
+//__________________________________________________
+void Clusterer::ClustererThread::initChip(gsl::span<const Digit> digits, uint32_t first, GeometryTGeo* geom)
+{
+  const uint16_t chipID = digits[first].getChipIndex();
+
+  // Determine the number of rows for this chip's sensor type
+  size = constants::moduleMLOT::chip::nRows + 2; // default for ML/OT
+  if (geom) {
+    if (geom->getSubDetID(chipID) == 0) { // VD
+      const int layer = geom->getLayer(chipID);
+      size = constants::VD::petal::layer::nRows[layer] + 2;
+    }
+  }
+
+  delete[] column1;
+  delete[] column2;
+  column1 = new int[size];
+  column2 = new int[size];
+  column1[0] = column1[size - 1] = -1;
+  column2[0] = column2[size - 1] = -1;
+  prev = column1 + 1;
+  curr = column2 + 1;
+  resetColumn(curr);
+
+  pixels.clear();
+  preClusterHeads.clear();
+  preClusterIndices.clear();
+
+  const auto& pix = digits[first];
+  currCol = pix.getColumn();
+  curr[pix.getRow()] = 0;
+  preClusterHeads.push_back(0);
+  preClusterIndices.push_back(0);
+  pixels.emplace_back(-1, first);
+  noLeftCol = true;
+}
+
+//__________________________________________________
+void Clusterer::ClustererThread::updateChip(gsl::span<const Digit> digits, uint32_t ip)
+{
+  const auto& pix = digits[ip];
+  uint16_t row = pix.getRow();
+
+  if (currCol != pix.getColumn()) {
+    swapColumnBuffers();
+    resetColumn(curr);
+    noLeftCol = false;
+    if (pix.getColumn() > currCol + 1) {
+      // gap: no connection with previous column
+      currCol = pix.getColumn();
+      addNewPreCluster(ip, row);
+      noLeftCol = true;
+      return;
+    }
+    currCol = pix.getColumn();
+  }
+
+  bool orphan = true;
+
+  if (noLeftCol) {
+    if (curr[row - 1] >= 0) {
+      expandPreCluster(ip, row, curr[row - 1]);
+      return;
+    }
+  } else {
+#ifdef _ALLOW_DIAGONAL_TRK_CLUSTERS_
+    int neighbours[]{curr[row - 1], prev[row], prev[row + 1], prev[row - 1]};
+#else
+    int neighbours[]{curr[row - 1], prev[row]};
+#endif
+    for (auto pci : neighbours) {
+      if (pci < 0) {
+        continue;
+      }
+      if (orphan) {
+        expandPreCluster(ip, row, pci);
+        orphan = false;
+        continue;
+      }
+      // merge two pre-clusters: assign the smaller index to both
+      if (preClusterIndices[pci] < preClusterIndices[curr[row]]) {
+        preClusterIndices[curr[row]] = preClusterIndices[pci];
+      } else {
+        preClusterIndices[pci] = preClusterIndices[curr[row]];
+      }
+    }
+  }
+  if (orphan) {
+    addNewPreCluster(ip, row);
+  }
+}
+
+//__________________________________________________
+void Clusterer::ClustererThread::finishChip(gsl::span<const Digit> digits,
+                                            const ConstDigitTruth* labelsDigPtr,
+                                            ClusterTruth* labelsClusPtr,
+                                            GeometryTGeo* geom)
+{
+  const uint16_t chipID = digits[pixels[0].second].getChipIndex();
+
+  for (size_t i1 = 0; i1 < preClusterHeads.size(); ++i1) {
+    auto ci = preClusterIndices[i1];
+    if (ci < 0) {
+      continue;
+    }
+    BBox bbox(chipID);
+    int nlab = 0;
+    uint32_t totalCharge = 0;
+    pixArrBuff.clear();
+
+    // Walk the linked list for this pre-cluster head
+    auto collectPixels = [&](int head) {
+      int next = head;
+      while (next >= 0) {
+        const auto& pixEntry = pixels[next];
+        const auto& d = digits[pixEntry.second];
+        uint16_t r = d.getRow(), c = d.getColumn();
+        pixArrBuff.emplace_back(r, c);
+        bbox.adjust(r, c);
+        totalCharge += d.getCharge();
+        if (labelsClusPtr) {
+          fetchMCLabels(pixEntry.second, labelsDigPtr, nlab);
+        }
+        next = pixEntry.first;
+      }
+    };
+
+    collectPixels(preClusterHeads[i1]);
+    preClusterIndices[i1] = -1;
+
+    for (size_t i2 = i1 + 1; i2 < preClusterHeads.size(); ++i2) {
+      if (preClusterIndices[i2] != ci) {
+        continue;
+      }
+      collectPixels(preClusterHeads[i2]);
+      preClusterIndices[i2] = -1;
+    }
+
+    // Determine geometry info
+    int subDetID = -1, layer = -1, disk = -1;
+    if (geom) {
+      subDetID = geom->getSubDetID(chipID);
+      layer = geom->getLayer(chipID);
+      disk = geom->getDisk(chipID);
+    }
+
+    const bool doLabels = (labelsClusPtr != nullptr);
+    if (bbox.isAcceptableSize()) {
+      streamCluster(bbox, pixArrBuff, totalCharge, doLabels, nlab, chipID, subDetID, layer, disk);
+    } else {
+      // Huge cluster: split into MaxRowSpan x MaxColSpan tiles (same as ITS3)
+      auto warnLeft = MaxHugeClusWarn - parent->mNHugeClus;
+      if (warnLeft > 0) {
+        LOGP(warn, "Splitting huge TRK cluster: chipID {}, rows {}:{} cols {}:{}{}",
+             chipID, bbox.rowMin, bbox.rowMax, bbox.colMin, bbox.colMax,
+             warnLeft == 1 ? " (further warnings muted)" : "");
+        parent->mNHugeClus++;
+      }
+      BBox bboxT(chipID);
+      bboxT.colMin = bbox.colMin;
+      do {
+        bboxT.rowMin = bbox.rowMin;
+        bboxT.colMax = std::min(bbox.colMax, uint16_t(bboxT.colMin + o2::itsmft::ClusterPattern::MaxColSpan - 1));
+        do {
+          bboxT.rowMax = std::min(bbox.rowMax, uint16_t(bboxT.rowMin + o2::itsmft::ClusterPattern::MaxRowSpan - 1));
+          std::vector<std::pair<uint16_t, uint16_t>> subPix;
+          uint32_t subCharge = 0;
+          for (const auto& [r, c] : pixArrBuff) {
+            if (bboxT.isInside(r, c)) {
+              subPix.emplace_back(r, c);
+              subCharge += 1;
+            }
+          }
+          if (!subPix.empty()) {
+            streamCluster(bboxT, subPix, subCharge, doLabels, nlab, chipID, subDetID, layer, disk);
+          }
+          bboxT.rowMin = bboxT.rowMax + 1;
+        } while (bboxT.rowMin <= bbox.rowMax);
+        bboxT.colMin = bboxT.colMax + 1;
+      } while (bboxT.colMin <= bbox.colMax);
+    }
+  }
+  // flush per-thread output to the caller via processChip
+}
+
+//__________________________________________________
+void Clusterer::ClustererThread::finishChipSingleHitFast(gsl::span<const Digit> digits, uint32_t hit,
+                                                         const ConstDigitTruth* labelsDigPtr,
+                                                         ClusterTruth* labelsClusPtr,
+                                                         GeometryTGeo* geom)
+{
+  const auto& d = digits[hit];
+  const uint16_t chipID = d.getChipIndex();
+  const uint16_t row = d.getRow();
+  const uint16_t col = d.getColumn();
+
+  if (labelsClusPtr) {
+    int nlab = 0;
+    fetchMCLabels(hit, labelsDigPtr, nlab);
+    const auto cnt = static_cast<uint32_t>(clusters.size());
+    for (int i = nlab; i--;) {
+      labels.addElement(cnt, labelsBuff[i]);
+    }
+  }
+
+  // 1×1 pattern: rowSpan=1, colSpan=1, one byte = 0x80
+  patterns.emplace_back(1);
+  patterns.emplace_back(1);
+  patterns.emplace_back(0x80);
+
+  Cluster cluster;
+  cluster.chipID = chipID;
+  cluster.row = row;
+  cluster.col = col;
+  cluster.size = 1;
+  if (geom) {
+    cluster.subDetID = geom->getSubDetID(chipID);
+    cluster.layer = geom->getLayer(chipID);
+    cluster.disk = geom->getDisk(chipID);
+  }
+  clusters.emplace_back(cluster);
+}
+
+//__________________________________________________
+void Clusterer::ClustererThread::streamCluster(const BBox& bbox,
+                                               const std::vector<std::pair<uint16_t, uint16_t>>& pixbuf,
+                                               uint32_t totalCharge,
+                                               bool doLabels, int nlab,
+                                               uint16_t chipID, int subDetID, int layer, int disk)
+{
+  if (doLabels) {
+    const auto cnt = static_cast<uint32_t>(clusters.size());
+    for (int i = nlab; i--;) {
+      labels.addElement(cnt, labelsBuff[i]); // accumulate in thread-local buffer
+    }
+  }
+
+  const uint16_t rowSpanW = bbox.rowSpan();
+  const uint16_t colSpanW = bbox.colSpan();
+
+  // Encode the pixel pattern bitmap (rowSpan, colSpan, bytes...)
+  std::array<unsigned char, o2::itsmft::ClusterPattern::MaxPatternBytes> patt{};
+  for (const auto& [r, c] : pixbuf) {
+    uint32_t ir = r - bbox.rowMin, ic = c - bbox.colMin;
+    int nbit = ir * colSpanW + ic;
+    patt[nbit >> 3] |= (0x1 << (7 - (nbit % 8)));
+  }
+  patterns.emplace_back(static_cast<unsigned char>(rowSpanW));
+  patterns.emplace_back(static_cast<unsigned char>(colSpanW));
+  int nBytes = (rowSpanW * colSpanW + 7) / 8;
+  patterns.insert(patterns.end(), patt.begin(), patt.begin() + nBytes);
+
+  Cluster cluster;
+  cluster.chipID = chipID;
+  cluster.row = bbox.rowMin;
+  cluster.col = bbox.colMin;
+  cluster.size = static_cast<uint16_t>(pixbuf.size());
+  cluster.subDetID = static_cast<int16_t>(subDetID);
+  cluster.layer = static_cast<int16_t>(layer);
+  cluster.disk = static_cast<int16_t>(disk);
+  clusters.emplace_back(cluster);
+}
+
+//__________________________________________________
+void Clusterer::ClustererThread::fetchMCLabels(uint32_t digID, const ConstDigitTruth* labelsDig, int& nfilled)
+{
+  if (nfilled >= MaxLabels) {
+    return;
+  }
+  if (!labelsDig || digID >= labelsDig->getIndexedSize()) {
+    return;
+  }
+  const auto& lbls = labelsDig->getLabels(digID);
+  for (int i = lbls.size(); i--;) {
+    int ic = nfilled;
+    for (; ic--;) {
+      if (labelsBuff[ic] == lbls[i]) {
+        return; // already present
+      }
+    }
+    labelsBuff[nfilled++] = lbls[i];
+    if (nfilled >= MaxLabels) {
+      break;
+    }
+  }
+}
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
index 09ab598ec626c..4eda22e350852 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
@@ -16,5 +16,6 @@
 #pragma link off all functions;
 
 #pragma link C++ class o2::trk::TimeFrame < 11> + ;
+#pragma link C++ class o2::trk::Clusterer + ;
 
 #endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
index d6c8ea85c2bbd..42402fe6b62dc 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
@@ -13,6 +13,8 @@ o2_add_library(TRKWorkflow
                TARGETVARNAME targetName
                SOURCES src/DigitReaderSpec.cxx
                        src/DigitWriterSpec.cxx
+                       src/ClustererSpec.cxx
+                       src/ClusterWriterSpec.cxx
                        src/TrackerSpec.cxx
                        src/TrackWriterSpec.cxx
                        src/RecoWorkflow.cxx
@@ -20,6 +22,7 @@ o2_add_library(TRKWorkflow
                                      O2::GPUWorkflow
                                      O2::SimConfig
                                      O2::DataFormatsITSMFT
+                                     O2::DataFormatsTRK
                                      O2::SimulationDataFormat
                                      O2::DPLUtils
                                      O2::TRKBase
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClusterWriterSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClusterWriterSpec.h
new file mode 100644
index 0000000000000..50d823b497bb9
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClusterWriterSpec.h
@@ -0,0 +1,24 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRK_CLUSTERWRITER
+#define O2_TRK_CLUSTERWRITER
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2::trk
+{
+
+framework::DataProcessorSpec getClusterWriterSpec(bool useMC);
+
+} // namespace o2::trk
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
new file mode 100644
index 0000000000000..bacc1057c7b07
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
@@ -0,0 +1,39 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRK_CLUSTERERDPL
+#define O2_TRK_CLUSTERERDPL
+
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/Task.h"
+#include "TRKReconstruction/Clusterer.h"
+
+namespace o2::trk
+{
+
+class ClustererDPL : public o2::framework::Task
+{
+ public:
+  ClustererDPL(bool useMC) : mUseMC(useMC) {}
+  void init(o2::framework::InitContext& ic) final;
+  void run(o2::framework::ProcessingContext& pc) final;
+
+ private:
+  bool mUseMC = true;
+  int mNThreads = 1;
+  o2::trk::Clusterer mClusterer;
+};
+
+o2::framework::DataProcessorSpec getClustererSpec(bool useMC);
+
+} // namespace o2::trk
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClusterWriterSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClusterWriterSpec.cxx
new file mode 100644
index 0000000000000..bc3a75c646198
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClusterWriterSpec.cxx
@@ -0,0 +1,65 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   ClusterWriterSpec.cxx
+
+#include <vector>
+
+#include "TRKWorkflow/ClusterWriterSpec.h"
+#include "DPLUtils/MakeRootTreeWriterSpec.h"
+#include "DataFormatsTRK/Cluster.h"
+#include "DataFormatsTRK/ROFRecord.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+
+using namespace o2::framework;
+
+namespace o2::trk
+{
+
+template <typename T>
+using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
+using ClustersType = std::vector<o2::trk::Cluster>;
+using PatternsType = std::vector<unsigned char>;
+using ROFrameType = std::vector<o2::trk::ROFRecord>;
+using LabelsType = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
+using ROFRecLblType = std::vector<o2::trk::MC2ROFRecord>;
+
+DataProcessorSpec getClusterWriterSpec(bool useMC)
+{
+  auto clustersSize = std::make_shared<int>(0);
+  auto clustersSizeGetter = [clustersSize](ClustersType const& clusters) {
+    *clustersSize = clusters.size();
+  };
+  auto logger = [clustersSize](ROFrameType const& rofs) {
+    LOG(info) << "TRKClusterWriter pulled " << *clustersSize << " clusters, in " << rofs.size() << " RO frames";
+  };
+
+  return MakeRootTreeWriterSpec("trk-cluster-writer",
+                                "o2clus_trk.root",
+                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Tree with TRK clusters"},
+                                BranchDefinition<ClustersType>{InputSpec{"compclus", "TRK", "COMPCLUSTERS", 0},
+                                                               "TRKClusterComp",
+                                                               clustersSizeGetter},
+                                BranchDefinition<PatternsType>{InputSpec{"patterns", "TRK", "PATTERNS", 0},
+                                                               "TRKClusterPatt"},
+                                BranchDefinition<ROFrameType>{InputSpec{"ROframes", "TRK", "CLUSTERSROF", 0},
+                                                              "TRKClustersROF",
+                                                              logger},
+                                BranchDefinition<LabelsType>{InputSpec{"labels", "TRK", "CLUSTERSMCTR", 0},
+                                                             "TRKClusterMCTruth",
+                                                             (useMC ? 1 : 0)},
+                                BranchDefinition<ROFRecLblType>{InputSpec{"MC2ROframes", "TRK", "CLUSTERSMC2ROF", 0},
+                                                                "TRKClustersMC2ROF",
+                                                                (useMC ? 1 : 0)})();
+}
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx
new file mode 100644
index 0000000000000..8aec63d69206b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx
@@ -0,0 +1,99 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKWorkflow/ClustererSpec.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "DataFormatsTRK/Cluster.h"
+#include "DataFormatsTRK/ROFRecord.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/Logger.h"
+#include "SimulationDataFormat/ConstMCTruthContainer.h"
+
+namespace o2::trk
+{
+
+void ClustererDPL::init(o2::framework::InitContext& ic)
+{
+  mNThreads = std::max(1, ic.options().get<int>("nthreads"));
+}
+
+void ClustererDPL::run(o2::framework::ProcessingContext& pc)
+{
+  auto digits = pc.inputs().get<gsl::span<o2::itsmft::Digit>>("digits");
+  auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
+
+  gsl::span<const o2::itsmft::MC2ROFRecord> mc2rofs;
+  gsl::span<const char> labelbuffer;
+  if (mUseMC) {
+    labelbuffer = pc.inputs().get<gsl::span<char>>("labels");
+    mc2rofs = pc.inputs().get<gsl::span<o2::itsmft::MC2ROFRecord>>("MC2ROframes");
+  }
+  o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
+
+  std::vector<o2::trk::Cluster> clusters;
+  std::vector<unsigned char> patterns;
+  std::vector<o2::trk::ROFRecord> clusterROFs;
+  std::unique_ptr<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> clusterLabels;
+  std::vector<o2::trk::MC2ROFRecord> clusterMC2ROFs;
+  if (mUseMC) {
+    clusterLabels = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
+  }
+  o2::base::GeometryManager::loadGeometry("o2sim_geometry.root", false, true);
+
+  mClusterer.process(digits,
+                     rofs,
+                     clusters,
+                     patterns,
+                     clusterROFs,
+                     mUseMC ? &labels : nullptr,
+                     clusterLabels.get(),
+                     mc2rofs,
+                     mUseMC ? &clusterMC2ROFs : nullptr);
+
+  pc.outputs().snapshot(o2::framework::Output{"TRK", "COMPCLUSTERS", 0}, clusters);
+  pc.outputs().snapshot(o2::framework::Output{"TRK", "PATTERNS", 0}, patterns);
+  pc.outputs().snapshot(o2::framework::Output{"TRK", "CLUSTERSROF", 0}, clusterROFs);
+
+  if (mUseMC) {
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "CLUSTERSMCTR", 0}, *clusterLabels);
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "CLUSTERSMC2ROF", 0}, clusterMC2ROFs);
+  }
+
+  LOGP(info, "TRKClusterer pushed {} clusters in {} ROFs", clusters.size(), clusterROFs.size());
+}
+
+o2::framework::DataProcessorSpec getClustererSpec(bool useMC)
+{
+  std::vector<o2::framework::InputSpec> inputs;
+  inputs.emplace_back("digits", "TRK", "DIGITS", 0, o2::framework::Lifetime::Timeframe);
+  inputs.emplace_back("ROframes", "TRK", "DIGITSROF", 0, o2::framework::Lifetime::Timeframe);
+
+  std::vector<o2::framework::OutputSpec> outputs;
+  outputs.emplace_back("TRK", "COMPCLUSTERS", 0, o2::framework::Lifetime::Timeframe);
+  outputs.emplace_back("TRK", "PATTERNS", 0, o2::framework::Lifetime::Timeframe);
+  outputs.emplace_back("TRK", "CLUSTERSROF", 0, o2::framework::Lifetime::Timeframe);
+
+  if (useMC) {
+    inputs.emplace_back("labels", "TRK", "DIGITSMCTR", 0, o2::framework::Lifetime::Timeframe);
+    inputs.emplace_back("MC2ROframes", "TRK", "DIGITSMC2ROF", 0, o2::framework::Lifetime::Timeframe);
+    outputs.emplace_back("TRK", "CLUSTERSMCTR", 0, o2::framework::Lifetime::Timeframe);
+    outputs.emplace_back("TRK", "CLUSTERSMC2ROF", 0, o2::framework::Lifetime::Timeframe);
+  }
+
+  return o2::framework::DataProcessorSpec{
+    "trk-clusterer",
+    inputs,
+    outputs,
+    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<o2::trk::ClustererDPL>(useMC)},
+    o2::framework::Options{{"nthreads", o2::framework::VariantType::Int, 1, {"Number of clustering threads"}}}};
+}
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
index 5f6cbe2f96b04..d10feb4214f38 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
@@ -10,6 +10,9 @@
 // or submit itself to any jurisdiction.
 
 #include "TRKWorkflow/RecoWorkflow.h"
+#include "TRKWorkflow/ClustererSpec.h"
+#include "TRKWorkflow/ClusterWriterSpec.h"
+#include "TRKWorkflow/DigitReaderSpec.h"
 #include "TRKWorkflow/TrackerSpec.h"
 #include "TRKWorkflow/TrackWriterSpec.h"
 #include "Framework/CCDBParamSpec.h"
@@ -28,10 +31,24 @@ framework::WorkflowSpec getWorkflow(bool useMC,
                                     o2::gpu::gpudatatypes::DeviceType dtype)
 {
   framework::WorkflowSpec specs;
-  specs.emplace_back(o2::trk::getTrackerSpec(useMC, hitRecoConfig, dtype));
+
+  if (!(upstreamDigits || upstreamClusters)) {
+    specs.emplace_back(o2::trk::getTRKDigitReaderSpec(useMC, false, "trkdigits.root"));
+  }
+  if (!upstreamClusters) {
+    specs.emplace_back(o2::trk::getClustererSpec(useMC));
+  }
 
   if (!disableRootOutput) {
-    specs.emplace_back(o2::trk::getTrackWriterSpec(useMC));
+    specs.emplace_back(o2::trk::getClusterWriterSpec(useMC));
+  }
+
+  if (!hitRecoConfig.empty()) {
+    LOGP(info, "Using hit reco config from file {}", hitRecoConfig);
+    specs.emplace_back(o2::trk::getTrackerSpec(useMC, hitRecoConfig, dtype));
+    if (!disableRootOutput) {
+      specs.emplace_back(o2::trk::getTrackWriterSpec(useMC));
+    }
   }
 
   return specs;
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
index 8fc67f0fa5567..20bd45557dac5 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -396,9 +396,13 @@ DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, o
 
   inputs.emplace_back("dummy", "TRK", "DUMMY", 0, Lifetime::Timeframe);
 
-  // inputs.emplace_back("compClusters", "TRK", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  // inputs.emplace_back("patterns", "TRK", "PATTERNS", 0, Lifetime::Timeframe);
-  // inputs.emplace_back("ROframes", "TRK", "CLUSTERSROF", 0, Lifetime::Timeframe);
+  constexpr bool expectClusterInputs = false;
+  if (expectClusterInputs) {
+    inputs.pop_back();
+    inputs.emplace_back("compClusters", "TRK", "COMPCLUSTERS", 0, Lifetime::Timeframe);
+    inputs.emplace_back("patterns", "TRK", "PATTERNS", 0, Lifetime::Timeframe);
+    inputs.emplace_back("ROframes", "TRK", "CLUSTERSROF", 0, Lifetime::Timeframe);
+  }
 
   // inputs.emplace_back("itscldict", "TRK", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
   // inputs.emplace_back("itsalppar", "TRK", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));

From ebaff324a16d3d91da35e5c679cb823469442251 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 3 Mar 2026 11:08:29 +0100
Subject: [PATCH 1381/1764] Fix EMCAL workflows in case DISABLE_ROOT_OUTPUT=0

---
 prodtests/full-system-test/dpl-workflow.sh | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index a8f01a3ef1822..9c6c45c049576 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -363,7 +363,7 @@ if [[ ${O2_GPU_RTC:-$EPNSYNCMODE} == 1 ]] && [[ ( ${ALICE_O2_FST:-0} == 1 && ${F
   [[ ${EPN_NODE_MI100:-0} == 1 ]] && GPU_CONFIG_KEY+="GPU_proc_rtctech.overrideArchitecture=--offload-arch=gfx908;"
 fi
 
-( workflow_has_parameter AOD || [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-emcal-cell-writer-workflow ) && has_detector EMC && RAW_EMC_SUBSPEC=" --subspecification 1 "
+( workflow_has_parameter AOD || [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-emcal-cell-writer-workflow ) && has_detector EMC && RAW_EMC_SUBSPEC=" --subspecificationOut 1 "
 has_detector_reco MID && has_detector_matching MCHMID && MFTMCHConf="FwdMatching.useMIDMatch=true;" || MFTMCHConf="FwdMatching.useMIDMatch=false;"
 [[ -n ${MFTMCH_NCANDIDATES_OPT:-} ]] && MFTMCHConf+="${MFTMCH_NCANDIDATES_OPT}"
 
@@ -568,7 +568,7 @@ if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
   has_detector CTP && ! has_detector_from_global_reader CTP && add_W o2-ctp-reco-workflow "$DISABLE_ROOT_OUTPUT $CTP_CONFIG --ntf-to-average 1 --pipeline $(get_N ctp-raw-decoder CTP RAW 1)"
   has_detector PHS && ! has_detector_from_global_reader PHS && ! has_detector_flp_processing PHS && add_W o2-phos-reco-workflow "--input-type raw --output-type cells $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT --pipeline $(get_N PHOSRawToCellConverterSpec PHS REST 1) $DISABLE_MC"
   has_detector CPV && ! has_detector_from_global_reader CPV && add_W o2-cpv-reco-workflow "--input-type $CPV_INPUT --output-type clusters $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT --pipeline $(get_N CPVRawToDigitConverterSpec CPV REST 1),$(get_N CPVClusterizerSpec CPV REST 1) $DISABLE_MC"
-  has_detector EMC && ! has_detector_from_global_reader EMC && ! has_detector_flp_processing EMC && add_W o2-emcal-reco-workflow "--input-type raw --output-type cells ${RAW_EMC_SUBSPEC:-} $EMCRAW2C_CONFIG $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N EMCALRawToCellConverterSpec EMC REST 1 EMCREC)"
+  has_detector EMC && ! has_detector_from_global_reader EMC && ! has_detector_flp_processing EMC && add_W o2-emcal-reco-workflow "--input-type raw --output-type cells ${RAW_EMC_SUBSPEC:-} $EMCRAW2C_CONFIG --disable-root-output $DISABLE_MC --pipeline $(get_N EMCALRawToCellConverterSpec EMC REST 1 EMCREC)"
 fi
 
 has_detector_gpu ITS && GPU_INPUT+=",its-clusters"

From 6c245eef5377fb70818a2c4bbed9b4ab4807b56e Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 3 Mar 2026 13:49:55 +0100
Subject: [PATCH 1382/1764] Fix in filling empty ROFs 1st entry

---
 Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
index 8de29c62335b6..fc0dd5dbae7da 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
@@ -165,12 +165,12 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
         }
       }
     }
-    int prevFirst{0};
+    int prevLast{0};
     for (auto& rof : expClusRofVec) {
       if (rof.getFirstEntry() < 0) {
-        rof.setFirstEntry(prevFirst);
+        rof.setFirstEntry(prevLast);
       }
-      prevFirst = rof.getFirstEntry();
+      prevLast = rof.getFirstEntry() + rof.getNEntries();
     }
     nROFs = expClusRofVec.size();
     pc.outputs().snapshot(Output{Origin, "CLUSTERSROF", iLayer}, expClusRofVec);

From 63c7419346ce8da63c3c5c77fab1dbe83b086472 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 3 Mar 2026 16:04:09 +0100
Subject: [PATCH 1383/1764] Possibility to dump FT0 eventsPerBC to file

---
 .../FT0EventsPerBcProcessor-Workflow.cxx      |  3 ++-
 .../calibration/workflow/FT0EventsPerBcSpec.h | 22 ++++++++++++++++++-
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
index 5cef707da2cca..38d634c20c828 100644
--- a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
+++ b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcProcessor-Workflow.cxx
@@ -35,6 +35,7 @@ o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext co
     outputs,
     AlgorithmSpec(adaptFromTask<FT0EventsPerBcProcessor>(ccdbRequest)),
     Options{
+      {"save-to-file", VariantType::Bool, false, {"Save calibration object to local file"}},
       {"slot-len-sec", VariantType::UInt32, 3600u, {"Duration of each slot in seconds"}},
       {"one-object-per-run", VariantType::Bool, false, {"If set, workflow creates only one calibration object per run"}},
       {"min-entries-number", VariantType::UInt32, 5000u, {"Minimum number of entries required for a slot to be valid"}},
@@ -45,4 +46,4 @@ o2::framework::WorkflowSpec defineDataProcessing(o2::framework::ConfigContext co
   WorkflowSpec workflow;
   workflow.emplace_back(dataProcessorSpec);
   return workflow;
-}
\ No newline at end of file
+}
diff --git a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
index d493e2a606613..1d4d4a75842e8 100644
--- a/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
+++ b/Detectors/FIT/FT0/calibration/workflow/FT0EventsPerBcSpec.h
@@ -35,6 +35,8 @@ class FT0EventsPerBcProcessor final : public o2::framework::Task
   void init(o2::framework::InitContext& ic) final
   {
     o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
+    mSaveToFile = ic.options().get<bool>("save-to-file");
+
     if (ic.options().hasOption("slot-len-sec")) {
       mSlotLenSec = ic.options().get<uint32_t>("slot-len-sec");
     }
@@ -73,6 +75,10 @@ class FT0EventsPerBcProcessor final : public o2::framework::Task
 
   void run(o2::framework::ProcessingContext& pc) final
   {
+    const auto& tinfo = pc.services().get<o2::framework::TimingInfo>();
+    if (tinfo.globalRunNumberChanged || mRunNoFromDH < 1) { // new run is starting
+      mRunNoFromDH = tinfo.runNumber;
+    }
     o2::base::GRPGeomHelper::instance().checkUpdates(pc);
     auto digits = pc.inputs().get<gsl::span<o2::ft0::Digit>>("digits");
     o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
@@ -107,6 +113,18 @@ class FT0EventsPerBcProcessor final : public o2::framework::Task
                 << " bytes, valid for " << info->getStartValidityTimestamp() << " : " << info->getEndValidityTimestamp();
       output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, "EventsPerBc", idx}, *image.get());
       output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, "EventsPerBc", idx}, *info.get());
+      if (mSaveToFile) {
+        std::string fnout = fmt::format("ft0eventsPerBC_run_{}_{}_{}.root", mRunNoFromDH, info->getStartValidityTimestamp(), info->getEndValidityTimestamp());
+        try {
+          TFile flout(fnout.c_str(), "recreate");
+          flout.WriteObjectAny(&payload, "o2::ft0::EventsPerBc", o2::ccdb::CcdbApi::CCDBOBJECT_ENTRY);
+          LOGP(info, R"(Saved to file, can upload as: o2-ccdb-upload -f {} --starttimestamp {} --endtimestamp {} -k "ccdb_object" --path {} -m "runNumber={};AdjustableEOV=true;")",
+               fnout, info->getStartValidityTimestamp(), info->getEndValidityTimestamp(), info->getPath(), mRunNoFromDH);
+          flout.Close();
+        } catch (const std::exception& ex) {
+          LOGP(error, "failed to store object to file {}, error: {}", fnout, ex.what());
+        }
+      }
     }
 
     if (tvxHists.size()) {
@@ -118,6 +136,8 @@ class FT0EventsPerBcProcessor final : public o2::framework::Task
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
   std::unique_ptr<o2::ft0::EventsPerBcCalibrator> mCalibrator;
   bool mOneObjectPerRun;
+  bool mSaveToFile = false;
+  int mRunNoFromDH = 0;
   uint32_t mSlotLenSec;
   uint32_t mMinNumberOfEntries;
   int32_t mMinAmplitudeSideA;
@@ -125,4 +145,4 @@ class FT0EventsPerBcProcessor final : public o2::framework::Task
   int32_t mMinSumOfAmplitude;
 };
 } // namespace o2::calibration
-#endif
\ No newline at end of file
+#endif

From d142160152169ec9c2d8ed6ff09df7ea793cb2d4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 4 Mar 2026 08:12:10 +0100
Subject: [PATCH 1384/1764] Include sstream to avoid implicit instantion of
 forward-declared object (header anyway only used once

---
 Framework/Core/src/OptionsHelpers.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/OptionsHelpers.h b/Framework/Core/src/OptionsHelpers.h
index 578ccc4935e69..3ca2dc1df330e 100644
--- a/Framework/Core/src/OptionsHelpers.h
+++ b/Framework/Core/src/OptionsHelpers.h
@@ -13,7 +13,7 @@
 
 #define BOOST_BIND_GLOBAL_PLACEHOLDERS
 #include <boost/program_options/variables_map.hpp>
-#include <iosfwd>
+#include <sstream>
 
 namespace boost::program_options
 {

From b2575f95b53fbf19755aaba5c2d5c1319e228617 Mon Sep 17 00:00:00 2001
From: Pavel Larionov <pavel.larionov@cern.ch>
Date: Wed, 4 Mar 2026 10:56:13 +0100
Subject: [PATCH 1385/1764] [ALICE 3] Fix VD full cyl building for ACTS
 (#15116)

* Fix full cyl building for ACTS

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../ALICE3/TRK/simulation/src/VDLayer.cxx     | 79 +++++++++++++++----
 1 file changed, 63 insertions(+), 16 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
index 411dd485684b9..a92dcd24d6038 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDLayer.cxx
@@ -27,6 +27,13 @@ namespace o2
 {
 namespace trk
 {
+
+// Helper function for floating point comparison
+inline bool isFullCircle(double phiSpanDeg, double epsilon = 0.005)
+{
+  return (std::fabs(phiSpanDeg - 360.0) < epsilon);
+}
+
 // Base layer constructor
 VDLayer::VDLayer(int layerNumber, const std::string& layerName, double layerX2X0)
   : mLayerNumber(layerNumber), mLayerName(layerName), mX2X0(layerX2X0), mModuleWidth(4.54)
@@ -88,8 +95,13 @@ TGeoVolume* VDCylindricalLayer::createSensor() const
   const double rIn = mRadius;
   const double rOut = mRadius + mSensorThickness;
   const double halfZ = 0.5 * mLengthSensZ;
-  const double halfPhi = 0.5 * mPhiSpanDeg; // degrees
-  auto* shape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  TGeoShape* shape;
+  if (isFullCircle(mPhiSpanDeg)) {
+    shape = new TGeoTube(rIn, rOut, halfZ);
+  } else {
+    const double halfPhi = 0.5 * mPhiSpanDeg; // degrees
+    shape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  }
   auto* vol = new TGeoVolume(sensName.c_str(), shape, medSi);
   vol->SetLineColor(kYellow);
   vol->SetTransparency(30);
@@ -138,10 +150,15 @@ TGeoVolume* VDDiskLayer::createSensor() const
   }
   std::string sensName = Form("%s_%s%d", this->mLayerName.c_str(), GeometryTGeo::getTRKSensorPattern(), this->mLayerNumber);
   const double halfThickness = 0.5 * mSensorThickness; // active sensor thickness along Z
-  const double halfPhi = 0.5 * mPhiSpanDeg;            // degrees
 
   // Same geometry as the layer (identical radii + phi span + thickness)
-  auto* shape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  TGeoShape* shape;
+  if (isFullCircle(mPhiSpanDeg)) {
+    shape = new TGeoTube(mRMin, mRMax, halfThickness);
+  } else {
+    const double halfPhi = 0.5 * mPhiSpanDeg; // degrees
+    shape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  }
 
   auto* sensVol = new TGeoVolume(sensName.c_str(), shape, medSi);
   sensVol->SetLineColor(kYellow);
@@ -177,9 +194,14 @@ TGeoVolume* VDCylindricalLayer::createMetalStack() const
   const double rIn = mRadius + mSensorThickness;
   const double rOut = mRadius + mChipThickness;
   const double halfZ = 0.5 * mLengthSensZ;
-  const double halfPhi = 0.5 * mPhiSpanDeg;
 
-  auto* shape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  TGeoShape* shape;
+  if (isFullCircle(mPhiSpanDeg)) {
+    shape = new TGeoTube(rIn, rOut, halfZ);
+  } else {
+    const double halfPhi = 0.5 * mPhiSpanDeg;
+    shape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  }
   auto* vol = new TGeoVolume(name.c_str(), shape, medSi);
   vol->SetLineColor(kGray);
   vol->SetTransparency(30);
@@ -244,9 +266,14 @@ TGeoVolume* VDDiskLayer::createMetalStack() const
                           GeometryTGeo::getTRKMetalStackPattern(), mLayerNumber);
 
   const double halfThickness = 0.5 * metalT;
-  const double halfPhi = 0.5 * mPhiSpanDeg;
 
-  auto* shape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  TGeoShape* shape;
+  if (isFullCircle(mPhiSpanDeg)) {
+    shape = new TGeoTube(mRMin, mRMax, halfThickness);
+  } else {
+    const double halfPhi = 0.5 * mPhiSpanDeg;
+    shape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  }
   auto* vol = new TGeoVolume(name.c_str(), shape, medSi);
   vol->SetLineColor(kGray);
   vol->SetTransparency(30);
@@ -275,9 +302,14 @@ TGeoVolume* VDCylindricalLayer::createChip() const
   const double rIn = mRadius;
   const double rOut = mRadius + mChipThickness;
   const double halfZ = 0.5 * mLengthSensZ;
-  const double halfPhi = 0.5 * mPhiSpanDeg;
 
-  auto* chipShape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  TGeoShape* chipShape;
+  if (isFullCircle(mPhiSpanDeg)) {
+    chipShape = new TGeoTube(rIn, rOut, halfZ);
+  } else {
+    const double halfPhi = 0.5 * mPhiSpanDeg;
+    chipShape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  }
   auto* chipVol = new TGeoVolume(chipName.c_str(), chipShape, medSi);
 
   // sensor
@@ -361,9 +393,14 @@ TGeoVolume* VDDiskLayer::createChip() const
                               GeometryTGeo::getTRKChipPattern(), mLayerNumber);
 
   const double halfThickness = 0.5 * mChipThickness;
-  const double halfPhi = 0.5 * mPhiSpanDeg;
 
-  auto* chipShape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  TGeoShape* chipShape;
+  if (isFullCircle(mPhiSpanDeg)) {
+    chipShape = new TGeoTube(mRMin, mRMax, halfThickness);
+  } else {
+    const double halfPhi = 0.5 * mPhiSpanDeg;
+    chipShape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  }
   auto* chipVol = new TGeoVolume(chipName.c_str(), chipShape, medSi);
   chipVol->SetLineColor(kYellow);
   chipVol->SetTransparency(30);
@@ -417,9 +454,14 @@ void VDCylindricalLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combi
   const double rIn = mRadius;
   const double rOut = mRadius + mChipThickness;
   const double halfZ = 0.5 * mLengthZ;
-  const double halfPhi = 0.5 * mPhiSpanDeg; // degrees
 
-  auto* layerShape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  TGeoShape* layerShape;
+  if (isFullCircle(mPhiSpanDeg)) {
+    layerShape = new TGeoTube(rIn, rOut, halfZ);
+  } else {
+    const double halfPhi = 0.5 * mPhiSpanDeg; // degrees
+    layerShape = new TGeoTubeSeg(rIn, rOut, halfZ, -halfPhi, +halfPhi);
+  }
   auto* layerVol = new TGeoVolume(mLayerName.c_str(), layerShape, medAir);
   layerVol->SetLineColor(kYellow);
   layerVol->SetTransparency(30);
@@ -523,10 +565,15 @@ void VDDiskLayer::createLayer(TGeoVolume* motherVolume, TGeoMatrix* combiTrans)
 
   // For disks the thickness is along Z and equals mChipThickness
   const double halfThickness = 0.5 * mChipThickness;
-  const double halfPhi = 0.5 * mPhiSpanDeg;
 
   // AIR container (layer)
-  auto* layerShape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  TGeoShape* layerShape;
+  if (isFullCircle(mPhiSpanDeg)) {
+    layerShape = new TGeoTube(mRMin, mRMax, halfThickness);
+  } else {
+    const double halfPhi = 0.5 * mPhiSpanDeg;
+    layerShape = new TGeoTubeSeg(mRMin, mRMax, halfThickness, -halfPhi, +halfPhi);
+  }
   auto* layerVol = new TGeoVolume(mLayerName.c_str(), layerShape, medAir);
   layerVol->SetLineColor(kYellow);
   layerVol->SetTransparency(30);

From 1913a00141d0d4b2eb1dfb594bd02a05c4c1338c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 4 Mar 2026 16:20:01 +0100
Subject: [PATCH 1386/1764] [ALICE3] Add possibility to set the chip thickness
 (#15120)

---
 .../base/include/IOTOFBase/IOTOFBaseParam.h   | 15 +++++------
 .../include/IOTOFSimulation/Detector.h        |  2 +-
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  | 25 +++++++++++--------
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     |  2 +-
 4 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
index b74fc6d6869dd..91d005415891d 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
@@ -21,13 +21,14 @@ namespace iotof
 {
 
 struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam> {
-  bool enableInnerTOF = true;
-  bool enableOuterTOF = true;
-  bool enableForwardTOF = true;
-  bool enableBackwardTOF = true;
-  std::string detectorPattern = "";
-  bool segmentedInnerTOF = false; // If the inner TOF layer is segmented
-  bool segmentedOuterTOF = false; // If the outer TOF layer is segmented
+  bool enableInnerTOF = true;       // Enable Inner TOF layer
+  bool enableOuterTOF = true;       // Enable Outer TOF layer
+  bool enableForwardTOF = true;     // Enable Forward TOF layer
+  bool enableBackwardTOF = true;    // Enable Backward TOF layer
+  std::string detectorPattern = ""; // Layouts of the detector
+  bool segmentedInnerTOF = false;   // If the inner TOF layer is segmented
+  bool segmentedOuterTOF = false;   // If the outer TOF layer is segmented
+  float x2x0 = 0.02f;               // thickness expressed in radiation length, for all layers for the moment
 
   O2ParamDef(IOTOFBaseParam, "IOTOFBase");
 };
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
index f3c4e3ddd6276..acf754e1b1fa8 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
@@ -60,7 +60,7 @@ class Detector : public o2::base::DetImpl<Detector>
     return nullptr;
   }
 
-  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "", bool itofSegmented = false, bool otofSegmented = false);
+  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "", bool itofSegmented = false, bool otofSegmented = false, const float x2x0 = 0.02f);
 
   void configServices();
   void createMaterials();
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index c056df5fd34ca..d4e34c582bbed 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -41,7 +41,7 @@ Detector::Detector(bool active)
   configLayers(iotofPars.enableInnerTOF, iotofPars.enableOuterTOF,
                iotofPars.enableForwardTOF, iotofPars.enableBackwardTOF,
                iotofPars.detectorPattern,
-               iotofPars.segmentedInnerTOF, iotofPars.segmentedOuterTOF);
+               iotofPars.segmentedInnerTOF, iotofPars.segmentedOuterTOF, iotofPars.x2x0);
 }
 
 Detector::~Detector()
@@ -57,12 +57,13 @@ void Detector::ConstructGeometry()
   createGeometry();
 }
 
-void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::string pattern, bool itofSegmented, bool otofSegmented)
+void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::string pattern, bool itofSegmented, bool otofSegmented,
+                            const float x2x0)
 {
 
-  float radiusInnerTof = 19.f;
-  float radiusOuterTof = 85.f;
-  float lengthInnerTof = 124.f;
+  const float radiusInnerTof = 19.f;
+  const float radiusOuterTof = 85.f;
+  const float lengthInnerTof = 124.f;
   float lengthOuterTof = 680.f;
   std::pair<float, float> radiusRangeDiskTof = {15.f, 100.f};
   float zForwardTof = 370.f;
@@ -97,23 +98,25 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
   }
   if (itof) { // iTOF
     mITOFLayer = itofSegmented ? ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()},
-                                           radiusInnerTof, 0.f, lengthInnerTof, 0.f, 0.02f, ITOFLayer::kBarrelSegmented,
+                                           radiusInnerTof, 0.f, lengthInnerTof, 0.f, x2x0, ITOFLayer::kBarrelSegmented,
                                            24, 5.42, 10.0, 10)
                                : ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()},
-                                           radiusInnerTof, 0.f, lengthInnerTof, 0.f, 0.02f, ITOFLayer::kBarrel);
+                                           radiusInnerTof, 0.f, lengthInnerTof, 0.f, x2x0, ITOFLayer::kBarrel);
   }
   if (otof) { // oTOF
     mOTOFLayer = otofSegmented ? OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()},
-                                           radiusOuterTof, 0.f, lengthOuterTof, 0.f, 0.02f, OTOFLayer::kBarrelSegmented,
+                                           radiusOuterTof, 0.f, lengthOuterTof, 0.f, x2x0, OTOFLayer::kBarrelSegmented,
                                            62, 9.74, 5.0, 54)
                                : OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()},
-                                           radiusOuterTof, 0.f, lengthOuterTof, 0.f, 0.02f, OTOFLayer::kBarrel);
+                                           radiusOuterTof, 0.f, lengthOuterTof, 0.f, x2x0, OTOFLayer::kBarrel);
   }
   if (ftof) {
-    mFTOFLayer = FTOFLayer(std::string{GeometryTGeo::getFTOFLayerPattern()}, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, zForwardTof, 0.02f, FTOFLayer::kDisk); // fTOF
+    mFTOFLayer = FTOFLayer(std::string{GeometryTGeo::getFTOFLayerPattern()},
+                           radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, zForwardTof, x2x0, FTOFLayer::kDisk); // fTOF
   }
   if (btof) {
-    mBTOFLayer = BTOFLayer(std::string{GeometryTGeo::getBTOFLayerPattern()}, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, -zForwardTof, 0.02f, BTOFLayer::kDisk); // bTOF
+    mBTOFLayer = BTOFLayer(std::string{GeometryTGeo::getBTOFLayerPattern()},
+                           radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, -zForwardTof, x2x0, BTOFLayer::kDisk); // bTOF
   }
 }
 
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 32a24fc46f94c..1744e4c4510bb 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -40,7 +40,7 @@ Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float
     mModulesPerStave(modulesPerStave),
     mTiltAngle(staveTiltAngle)
 {
-  float Si_X0 = 9.5f;
+  const float Si_X0 = 9.5f;
   mChipThickness = mX2X0 * Si_X0;
   std::string name = "";
   switch (layout) {

From d890d412ba9987c024216320be1b444ab4e3210e Mon Sep 17 00:00:00 2001
From: Francesco Noferini <noferini@bo.infn.it>
Date: Mon, 23 Feb 2026 14:12:04 +0100
Subject: [PATCH 1387/1764] add treatment of TOF DRM Errors

---
 .../TOF/include/DataFormatsTOF/Diagnostic.h   |   7 +
 .../TOF/base/include/TOFBase/CalibTOFapi.h    |  63 +++++++--
 Detectors/TOF/base/include/TOFBase/Digit.h    |  14 +-
 Detectors/TOF/base/src/CalibTOFapi.cxx        | 131 +++++++++++++++++-
 Detectors/TOF/prototyping/CMakeLists.txt      |  15 ++
 Detectors/TOF/prototyping/checkDRMobj_tof.C   |  41 ++++++
 Detectors/TOF/prototyping/makeDRMobj_tof.C    |  45 ++++++
 .../TOF/reconstruction/src/Clusterer.cxx      |   4 +-
 .../include/TOFSimulation/Digitizer.h         |   5 +-
 Detectors/TOF/simulation/src/Detector.cxx     |   1 -
 Detectors/TOF/simulation/src/Digitizer.cxx    |  13 +-
 .../src/SimpleDigitizerWorkflow.cxx           |   5 +-
 .../src/TOFDigitizerSpec.cxx                  |  25 +++-
 .../DigitizerWorkflow/src/TOFDigitizerSpec.h  |   2 +-
 14 files changed, 339 insertions(+), 32 deletions(-)
 create mode 100644 Detectors/TOF/prototyping/checkDRMobj_tof.C
 create mode 100644 Detectors/TOF/prototyping/makeDRMobj_tof.C

diff --git a/DataFormats/Detectors/TOF/include/DataFormatsTOF/Diagnostic.h b/DataFormats/Detectors/TOF/include/DataFormatsTOF/Diagnostic.h
index 8adcdb63e9d21..028da04b3ef70 100644
--- a/DataFormats/Detectors/TOF/include/DataFormatsTOF/Diagnostic.h
+++ b/DataFormats/Detectors/TOF/include/DataFormatsTOF/Diagnostic.h
@@ -44,6 +44,13 @@ class Diagnostic
   uint32_t fillEmptyTOF(uint32_t frequency = 1) { return fill(1, frequency); }
   static ULong64_t getEmptyCrateKey(int crate);
   static ULong64_t getNoisyChannelKey(int channel);
+  static ULong64_t getDRMKey(int crate) { return 1000000 + crate * 1000; }
+  static ULong64_t getDRMerrorKey(int crate, int error) { return getDRMKey(crate) + error; }
+  uint32_t getFrequencyDRM(int crate) const { return getFrequency(getDRMKey(crate)); }
+  uint32_t getFrequencyDRMerror(int crate, int error) const { return getFrequency(getDRMerrorKey(crate, error)); }
+  uint32_t fillDRM(int crate, uint32_t frequency) { return fill(getDRMKey(crate), frequency); }
+  uint32_t fillDRMerror(int crate, int error, uint32_t frequency) { return fill(getDRMerrorKey(crate, error), frequency); }
+
   static ULong64_t getTRMKey(int crate, int trm);
   void print(bool longFormat = false) const;
   void clear() { mVector.clear(); }
diff --git a/Detectors/TOF/base/include/TOFBase/CalibTOFapi.h b/Detectors/TOF/base/include/TOFBase/CalibTOFapi.h
index c3d39d3e978e1..6fb87e72abf62 100644
--- a/Detectors/TOF/base/include/TOFBase/CalibTOFapi.h
+++ b/Detectors/TOF/base/include/TOFBase/CalibTOFapi.h
@@ -23,6 +23,9 @@
 #include "TOFBase/Geo.h"
 #include "DataFormatsTOF/Diagnostic.h"
 #include "DataFormatsTOF/TOFFEElightInfo.h"
+#include "DataFormatsTOF/CompressedDataFormat.h"
+
+class TH2F;
 
 namespace o2
 {
@@ -38,10 +41,12 @@ class CalibTOFapi
   using CcdbApi = o2::ccdb::CcdbApi;
 
  public:
+  static o2::tof::Diagnostic doDRMerrCalibFromQCHisto(const TH2F* histo, const char* file_output_name);
+
   void resetDia();
   CalibTOFapi() = default;
   CalibTOFapi(const std::string url);
-  CalibTOFapi(long timestamp, o2::dataformats::CalibLHCphaseTOF* phase, o2::dataformats::CalibTimeSlewingParamTOF* slew, Diagnostic* dia = nullptr) : mTimeStamp(timestamp), mLHCphase(phase), mSlewParam(slew), mDiaFreq(dia) {}
+  CalibTOFapi(long timestamp, o2::dataformats::CalibLHCphaseTOF* phase, o2::dataformats::CalibTimeSlewingParamTOF* slew, Diagnostic* dia = nullptr, Diagnostic* diaDRM = nullptr) : mTimeStamp(timestamp), mLHCphase(phase), mSlewParam(slew), mDiaFreq(dia), mDiaDRMFreq(diaDRM) {}
   ~CalibTOFapi()
   {
     if (mLHCphase) {
@@ -53,6 +58,9 @@ class CalibTOFapi
     if (mDiaFreq) {
       //      delete mDiaFreq;
     }
+    if (mDiaDRMFreq) {
+      //      delete mDiaDRMFreq;
+    }
   }
 
   void setTimeStamp(long t)
@@ -69,6 +77,8 @@ class CalibTOFapi
   void readTimeSlewingParamFromFile(const char* filename);
   void readDiagnosticFrequencies();
   void loadDiagnosticFrequencies();
+  void readDiagnosticDRMFrequencies();
+  void loadDiagnosticDRMFrequencies();
   void readActiveMap();
   void loadActiveMap(TOFFEElightInfo* fee);
   void writeLHCphase(LhcPhase* phase, std::map<std::string, std::string> metadataLHCphase, uint64_t minTimeSTamp, uint64_t maxTimeStamp);
@@ -89,6 +99,8 @@ class CalibTOFapi
   void setLhcPhase(LhcPhase* obj) { mLHCphase = obj; }
   Diagnostic* getDiagnostic() { return mDiaFreq; }
   void setDiagnostic(Diagnostic* obj) { mDiaFreq = obj; }
+  Diagnostic* getDiagnosticDRM() { return mDiaDRMFreq; }
+  void setDiagnosticDRM(Diagnostic* obj) { mDiaDRMFreq = obj; }
 
   int getNoisyThreshold() const { return mNoisyThreshold; }
   void setNoisyThreshold(int val) { mNoisyThreshold = val; }
@@ -102,12 +114,39 @@ class CalibTOFapi
   void processError(int crate, int trm, int mask);
   bool isChannelError(int channel) const;
   bool checkTRMPolicy(int mask) const;
+  void resetDRMErrors();
+  void processErrorDRM(int crate, int codeErr);
+  bool isChannelDRMError(int channel) const;
+  bool checkDRMPolicy(int mask) const;
+
+  void setDRMCriticalErrorMask(uint32_t val) { mDRMCriticalErrorMask = val; }
+  uint32_t getDRMCriticalErrorMask() const { return mDRMCriticalErrorMask; }
+  float getDRMprobError(int crate, int type) const { return mErrorInDRM[crate][type]; }
+
+  // DRM error codes inherited by EDRMDiagnostic_t in CompressedDataFormat.h (shifted by 4 bits)
+  static const int DRM_ERRINDEX_SHIFT = 4;
+  enum DRMcodes {
+    DRM_HEADER_MISSING = o2::tof::diagnostic::DRM_HEADER_MISSING >> DRM_ERRINDEX_SHIFT,
+    DRM_TRAILER_MISSING = o2::tof::diagnostic::DRM_TRAILER_MISSING >> DRM_ERRINDEX_SHIFT,
+    DRM_FEEID_MISMATCH = o2::tof::diagnostic::DRM_FEEID_MISMATCH >> DRM_ERRINDEX_SHIFT,
+    DRM_ORBIT_MISMATCH = o2::tof::diagnostic::DRM_ORBIT_MISMATCH >> DRM_ERRINDEX_SHIFT,
+    DRM_CRC_MISMATCH = o2::tof::diagnostic::DRM_CRC_MISMATCH >> DRM_ERRINDEX_SHIFT,
+    DRM_ENAPARTMASK_DIFFER = o2::tof::diagnostic::DRM_ENAPARTMASK_DIFFER >> DRM_ERRINDEX_SHIFT,
+    DRM_CLOCKSTATUS_WRONG = o2::tof::diagnostic::DRM_CLOCKSTATUS_WRONG >> DRM_ERRINDEX_SHIFT,
+    DRM_FAULTSLOTMASK_NOTZERO = o2::tof::diagnostic::DRM_FAULTSLOTMASK_NOTZERO >> DRM_ERRINDEX_SHIFT,
+    DRM_READOUTTIMEOUT_NOTZERO = o2::tof::diagnostic::DRM_READOUTTIMEOUT_NOTZERO >> DRM_ERRINDEX_SHIFT,
+    DRM_EVENTWORDS_MISMATCH = o2::tof::diagnostic::DRM_EVENTWORDS_MISMATCH >> DRM_ERRINDEX_SHIFT,
+    DRM_DIAGNOSTIC_SPARE1 = o2::tof::diagnostic::DRM_DIAGNOSTIC_SPARE1 >> DRM_ERRINDEX_SHIFT,
+    DRM_DECODE_ERROR = o2::tof::diagnostic::DRM_DECODE_ERROR >> DRM_ERRINDEX_SHIFT,
+    N_DRM_ERRORS = 12
+  };
 
  private:
-  long mTimeStamp;                 ///< timeStamp for queries
-  LhcPhase* mLHCphase = nullptr;   ///< object for LHC phase
-  SlewParam* mSlewParam = nullptr; ///< object for timeslewing (containing info also for offset and problematic)
-  Diagnostic* mDiaFreq = nullptr;  ///< object for Diagnostic Frequency
+  long mTimeStamp;                   ///< timeStamp for queries
+  LhcPhase* mLHCphase = nullptr;     ///< object for LHC phase
+  SlewParam* mSlewParam = nullptr;   ///< object for timeslewing (containing info also for offset and problematic)
+  Diagnostic* mDiaFreq = nullptr;    ///< object for Diagnostic Frequency
+  Diagnostic* mDiaDRMFreq = nullptr; ///< object for Diagnostic Frequency
 
   // info from diagnostic
   int mNoisyThreshold = 1;                          ///< threshold to be noisy
@@ -116,13 +155,17 @@ class CalibTOFapi
   std::vector<std::pair<int, float>> mNoisy;        ///< probTRMerror
   std::vector<std::pair<int, float>> mTRMerrorProb; ///< probTRMerror
   std::vector<int> mTRMmask;                        ///< mask error for TRM
+  float mErrorInDRM[Geo::kNCrate][N_DRM_ERRORS] = {}; ///< probability of DRM error
+  uint32_t mDRMCriticalErrorMask = 0;                 ///< bit mask for critical DRM errors (e.g. Orbit Mismatch -> 1 << 7, see DataFormats/Detectors/TOF/include/DataFormatsTOF/CompressedDataFormat.h)
 
-  bool mIsErrorCh[Geo::NCHANNELS] = {}; ///< channels in error (TRM)
-  std::vector<int> mFillErrChannel;     ///< last error channels filled
-  bool mIsOffCh[Geo::NCHANNELS] = {};   ///< channels in error (TRM)
-  bool mIsNoisy[Geo::NCHANNELS] = {};   ///< noisy channels
+  bool mIsErrorCh[Geo::NCHANNELS] = {};    ///< channels in error (TRM)
+  std::vector<int> mFillErrChannel;        ///< last error channels filled
+  bool mIsOffCh[Geo::NCHANNELS] = {};      ///< channels in error (TRM)
+  bool mIsNoisy[Geo::NCHANNELS] = {};      ///< noisy channels
+  bool mIsErrorDRMCh[Geo::NCHANNELS] = {}; ///< channels in error (DRM)
+  std::vector<int> mFillErrDRMChannel;     ///< last error channels filled
 
-  ClassDefNV(CalibTOFapi, 1);
+  ClassDefNV(CalibTOFapi, 2);
 };
 } // namespace tof
 } // namespace o2
diff --git a/Detectors/TOF/base/include/TOFBase/Digit.h b/Detectors/TOF/base/include/TOFBase/Digit.h
index eef03ef84b97c..afa5662044a3e 100644
--- a/Detectors/TOF/base/include/TOFBase/Digit.h
+++ b/Detectors/TOF/base/include/TOFBase/Digit.h
@@ -101,13 +101,13 @@ class Digit
  private:
   friend class boost::serialization::access;
 
-  Int_t mChannel;          ///< TOF channel index
-  uint16_t mTDC;           ///< TDC bin number
-  uint16_t mTOT;           ///< TOT bin number
-  InteractionRecord mIR{0, 0}; ///< InteractionRecord (orbit and bc) when digit occurs
-  Int_t mLabel;            ///< Index of the corresponding entry in the MC label array
-  Double_t mCalibratedTime; //!< time of the digits after calibration (not persistent; it will be filled during clusterization)
-  Int_t mElectronIndex;    //!/< index in electronic format
+  Int_t mChannel;                ///< TOF channel index
+  uint16_t mTDC;                 ///< TDC bin number
+  uint16_t mTOT;                 ///< TOT bin number
+  InteractionRecord mIR{0, 0};   ///< InteractionRecord (orbit and bc) when digit occurs
+  Int_t mLabel;                  ///< Index of the corresponding entry in the MC label array
+  Double_t mCalibratedTime;      //!< time of the digits after calibration (not persistent; it will be filled during clusterization)
+  Int_t mElectronIndex;          //!/< index in electronic format
   uint32_t mTriggerOrbit = 0;    //!< orbit id of trigger event // RS: orbit must be 32bits long
   uint16_t mTriggerBunch = 0;    //!< bunch id of trigger event
   Bool_t mIsUsedInCluster;       //!/< flag to declare that the digit was used to build a cluster
diff --git a/Detectors/TOF/base/src/CalibTOFapi.cxx b/Detectors/TOF/base/src/CalibTOFapi.cxx
index 281498990a9dd..fdc028bde536c 100644
--- a/Detectors/TOF/base/src/CalibTOFapi.cxx
+++ b/Detectors/TOF/base/src/CalibTOFapi.cxx
@@ -11,11 +11,40 @@
 
 #include "TOFBase/CalibTOFapi.h"
 #include <fairlogger/Logger.h> // for LOG
+#include <TH2F.h>
 
 using namespace o2::tof;
 
 ClassImp(o2::tof::CalibTOFapi);
 
+o2::tof::Diagnostic CalibTOFapi::doDRMerrCalibFromQCHisto(const TH2F* histo, const char* file_output_name)
+{
+  // this is a method which translate the QC output in qc/TOF/MO/TaskRaw/DRMCounter (TH2F) into a Diagnotic object for DRM (patter(crate, error), frequency)
+  // note that, differently from TRM errors, DRM ones are not stored in CTF by design (since very rare, as expected). Such an info is available only at the level of raw sync QC
+  o2::tof::Diagnostic drmDia;
+
+  for (int j = 1; j <= Geo::kNCrate; j++) {
+    drmDia.fillDRM(j - 1, histo->GetBinContent(1, j));
+    for (int i = 2; i <= histo->GetXaxis()->GetNbins(); i++) {
+      if (histo->GetBinContent(1, j)) {
+        if (histo->GetBinContent(i, j) > 0) {
+          drmDia.fillDRMerror(j - 1, i - 1, histo->GetBinContent(i, j));
+        }
+      }
+    }
+  }
+
+  TFile* fo = new TFile(file_output_name, "RECREATE");
+  fo->WriteObjectAny(&drmDia, drmDia.Class_Name(), "ccdb_object");
+  fo->Close();
+  LOG(debug) << "DRM error ccdb object created in " << file_output_name << " with this content";
+  drmDia.print(true);
+
+  return drmDia;
+}
+
+//______________________________________________________________________
+
 void CalibTOFapi::resetDia()
 {
   memset(mEmptyCrateProb, 0., Geo::kNCrate * 4);
@@ -38,7 +67,7 @@ void CalibTOFapi::readActiveMap()
 {
   auto& mgr = CcdbManager::instance();
   long timems = long(mTimeStamp) * 1000;
-  LOG(info) << "TOF get active map with timestamp (ms) = " << timems;
+  LOG(debug) << "TOF get active map with timestamp (ms) = " << timems;
   auto fee = mgr.getForTimeStamp<TOFFEElightInfo>("TOF/Calib/FEELIGHT", timems);
   loadActiveMap(fee);
 }
@@ -116,11 +145,23 @@ void CalibTOFapi::readDiagnosticFrequencies()
 {
   auto& mgr = CcdbManager::instance();
   long timems = long(mTimeStamp) * 1000;
-  LOG(info) << "TOF get Diagnostics with timestamp (ms) = " << timems;
+  LOG(info) << "TOF get TRM Diagnostics with timestamp (ms) = " << timems;
   mDiaFreq = mgr.getForTimeStamp<Diagnostic>("TOF/Calib/Diagnostic", timems);
 
   loadDiagnosticFrequencies();
 }
+
+//______________________________________________________________________
+
+void CalibTOFapi::readDiagnosticDRMFrequencies()
+{
+  auto& mgr = CcdbManager::instance();
+  long timems = long(mTimeStamp) * 1000;
+  LOG(info) << "TOF get DRM Diagnostics with timestamp (ms) = " << timems;
+  mDiaFreq = mgr.getForTimeStamp<Diagnostic>("TOF/Calib/TRMerrors", timems);
+
+  loadDiagnosticDRMFrequencies();
+}
 //______________________________________________________________________
 
 void CalibTOFapi::loadDiagnosticFrequencies()
@@ -210,6 +251,37 @@ void CalibTOFapi::loadDiagnosticFrequencies()
 
 //______________________________________________________________________
 
+void CalibTOFapi::loadDiagnosticDRMFrequencies()
+{
+  mDiaDRMFreq->print();
+
+  for (int ic = 0; ic < Geo::kNCrate; ic++) { // loop over crates
+    float DRMcounters = mDiaDRMFreq->getFrequencyDRM(ic);
+
+    if (DRMcounters < 1) {
+      for (int ie = 0; ie < N_DRM_ERRORS; ie++) {
+        mErrorInDRM[ic][ie] = 0.;
+      }
+      continue;
+    }
+
+    for (int ie = 0; ie < N_DRM_ERRORS; ie++) { // loop over error types
+      int ie_shifted = ie + DRM_ERRINDEX_SHIFT;
+
+      float frequency = mDiaDRMFreq->getFrequencyDRMerror(ic, ie_shifted) * 1. / DRMcounters; // error frequency
+      if (frequency > 1) {
+        frequency = 1.;
+      }
+      if (frequency > 1E-6) {
+        LOG(debug) << "DRMmap: Crate = " << ic << " - error = " << ie << " - frequency = " << frequency;
+      }
+      mErrorInDRM[ic][ie] = frequency;
+    }
+  }
+}
+
+//______________________________________________________________________
+
 void CalibTOFapi::writeLHCphase(LhcPhase* phase, std::map<std::string, std::string> metadataLHCphase, uint64_t minTimeStamp, uint64_t maxTimeStamp)
 {
 
@@ -330,6 +402,17 @@ void CalibTOFapi::resetTRMErrors()
 
 //______________________________________________________________________
 
+void CalibTOFapi::resetDRMErrors()
+{
+  for (auto index : mFillErrDRMChannel) {
+    mIsErrorDRMCh[index] = false;
+  }
+
+  mFillErrDRMChannel.clear();
+}
+
+//______________________________________________________________________
+
 void CalibTOFapi::processError(int crate, int trm, int mask)
 {
   if (checkTRMPolicy(mask)) { // check the policy of TRM -> true=good TRM
@@ -348,6 +431,32 @@ void CalibTOFapi::processError(int crate, int trm, int mask)
 
 //______________________________________________________________________
 
+void CalibTOFapi::processErrorDRM(int crate, int codeErr)
+{
+  int mask = 1 << codeErr;
+
+  if (checkDRMPolicy(mask)) {
+    return;
+  }
+
+  LOG(debug) << "DRMmask: crate = " << crate << " - mask = " << mask << " - critical mask = " << mDRMCriticalErrorMask;
+
+  for (int trm = 3; trm < 13; trm++) {
+    int ech = (crate << 12) + ((trm - 3) << 8);
+    for (int i = ech; i < ech + 256; i++) {
+      int channel = Geo::getCHFromECH(i);
+      if (channel == -1 || mIsErrorDRMCh[channel] == true) {
+        continue;
+      }
+
+      mIsErrorDRMCh[channel] = true;
+      mFillErrDRMChannel.push_back(channel);
+    }
+  }
+}
+
+//______________________________________________________________________
+
 bool CalibTOFapi::checkTRMPolicy(int mask) const
 {
   return false;
@@ -355,7 +464,25 @@ bool CalibTOFapi::checkTRMPolicy(int mask) const
 
 //______________________________________________________________________
 
+bool CalibTOFapi::checkDRMPolicy(int mask) const
+{
+  return !(mDRMCriticalErrorMask & mask);
+}
+
+//______________________________________________________________________
+
 bool CalibTOFapi::isChannelError(int channel) const
 {
   return mIsErrorCh[channel];
 }
+
+//______________________________________________________________________
+
+bool CalibTOFapi::isChannelDRMError(int channel) const
+{
+  if (mIsErrorDRMCh[channel]) {
+    int detId[5];
+    o2::tof::Geo::getVolumeIndices(channel, detId);
+  }
+  return mIsErrorDRMCh[channel];
+}
diff --git a/Detectors/TOF/prototyping/CMakeLists.txt b/Detectors/TOF/prototyping/CMakeLists.txt
index 1ce2268f1358a..7dfc9f8cb7361 100644
--- a/Detectors/TOF/prototyping/CMakeLists.txt
+++ b/Detectors/TOF/prototyping/CMakeLists.txt
@@ -32,6 +32,16 @@ o2_add_test_root_macro(findLabels.C
                                              O2::TOFBase
                        LABELS tof)
 
+o2_add_test_root_macro(makeDRMobj_tof.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
+                                             O2::TOFBase
+                       LABELS tof)
+
+o2_add_test_root_macro(checkDRMobj_tof.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
+                                             O2::TOFBase
+                       LABELS tof)
+
 o2_add_test_root_macro(findTOFclusterFromLabel.C
                        PUBLIC_LINK_LIBRARIES O2::DataFormatsTOF
                                              O2::SimulationDataFormat
@@ -59,3 +69,8 @@ o2_add_test_root_macro(macroEvTime.C
                        PUBLIC_LINK_LIBRARIES O2::TOFBase
                                              O2::TOFReconstruction
                        LABELS tof)
+
+install(
+  FILES makeDRMobj_tof.C
+  checkDRMobj_tof.C
+  DESTINATION share/macro/)
diff --git a/Detectors/TOF/prototyping/checkDRMobj_tof.C b/Detectors/TOF/prototyping/checkDRMobj_tof.C
new file mode 100644
index 0000000000000..9652a4fb9823e
--- /dev/null
+++ b/Detectors/TOF/prototyping/checkDRMobj_tof.C
@@ -0,0 +1,41 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include "TFile.h"
+#include "TH2F.h"
+#include "TOFBase/CalibTOFapi.h"
+#endif
+
+void checkDRMobj_tof(const char* fname = "ccdb.root")
+{
+  TFile* f = new TFile(fname);
+
+  TH2F* hErrors = new TH2F("hDRMerrors", ";error code; frequency", 30, 0, 30, 72, 0, 72);
+
+  o2::tof::Diagnostic* drmDia = (o2::tof::Diagnostic*)f->Get("ccdb_object");
+
+  for (int j = 1; j <= 72; j++) {
+    uint32_t patternRDH = o2::tof::Diagnostic::getDRMKey(j - 1);
+    for (int i = 1; i <= hErrors->GetXaxis()->GetNbins(); i++) {
+      uint32_t pattern = o2::tof::Diagnostic::getDRMerrorKey(j - 1, i - 1);
+      if (drmDia->getFrequency(patternRDH)) {
+        hErrors->SetBinContent(i, j, drmDia->getFrequency(pattern) * 1. / drmDia->getFrequency(patternRDH));
+      }
+    }
+  }
+
+  TCanvas* c = new TCanvas();
+  c->cd(1);
+  hErrors->Draw("colz");
+
+  drmDia->print(true);
+}
diff --git a/Detectors/TOF/prototyping/makeDRMobj_tof.C b/Detectors/TOF/prototyping/makeDRMobj_tof.C
new file mode 100644
index 0000000000000..2ae79d501b369
--- /dev/null
+++ b/Detectors/TOF/prototyping/makeDRMobj_tof.C
@@ -0,0 +1,45 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include "TFile.h"
+#include "TH2F.h"
+#include "TOFBase/CalibTOFapi.h"
+#endif
+
+void makeDRMobj_tof(const char* inputfile = "TObject_1764607157510.root", bool dummy = false)
+{
+  if (dummy) {
+    o2::tof::Diagnostic drmDia;
+    for (int j = 1; j <= 72; j++) {
+      drmDia.fill(o2::tof::Diagnostic::getDRMKey(j - 1));
+    }
+
+    TFile* fo = new TFile("ccdb.root", "RECREATE");
+    fo->WriteObjectAny(&drmDia, drmDia.Class_Name(), "ccdb_object");
+    fo->Close();
+
+    return;
+  }
+
+  TFile* f = new TFile(inputfile);
+  TH2F* h = (TH2F*)f->Get("ccdb_object");
+
+  float maxVal = h->GetBinContent(h->GetMaximumBin());
+
+  if (maxVal > 1E6) { // to avoid to pass value causing overflow
+    h->Scale(1E6 / maxVal);
+  }
+
+  o2::tof::Diagnostic drmDia;
+
+  drmDia = o2::tof::CalibTOFapi::doDRMerrCalibFromQCHisto(h, "ccdb.root");
+}
diff --git a/Detectors/TOF/reconstruction/src/Clusterer.cxx b/Detectors/TOF/reconstruction/src/Clusterer.cxx
index 0b393bfd45e78..dbfa472ce4112 100644
--- a/Detectors/TOF/reconstruction/src/Clusterer.cxx
+++ b/Detectors/TOF/reconstruction/src/Clusterer.cxx
@@ -54,11 +54,9 @@ void Clusterer::calibrateStrip()
     //    LOG(info) << "channel = " << dig->getChannel();
     dig->setBC(dig->getBC() - mBCOffset); // RS Don't use raw BC, always start from the beginning of the TF
     double calib = mCalibApi->getTimeCalibration(dig->getChannel(), dig->getTOT() * Geo::TOTBIN_NS);
-    //printf("channel %d) isProblematic = %d, fractionUnderPeak = %f\n",dig->getChannel(),mCalibApi->isProblematic(dig->getChannel()),mCalibApi->getFractionUnderPeak(dig->getChannel())); // toberem
     bool isProbOrError = mAreCalibStored ? mCalibApi->isChannelError(dig->getChannel()) || mCalibApi->isNoisy(dig->getChannel()) : mCalibApi->isChannelError(dig->getChannel()) || mCalibApi->isNoisy(dig->getChannel()) || mCalibApi->isProblematic(dig->getChannel());
     dig->setIsProblematic(isProbOrError);
-    dig->setCalibratedTime(dig->getTDC() * Geo::TDCBIN + dig->getBC() * o2::constants::lhc::LHCBunchSpacingNS * 1E3 - Geo::LATENCYWINDOW * 1E3 - calib); //TODO:  to be checked that "-" is correct, and we did not need "+" instead :-)
-    //printf("calibration correction = %f\n",calib); // toberem
+    dig->setCalibratedTime(dig->getTDC() * Geo::TDCBIN + dig->getBC() * o2::constants::lhc::LHCBunchSpacingNS * 1E3 - Geo::LATENCYWINDOW * 1E3 - calib); // TODO:  to be checked that "-" is correct, and we did not need "+" instead :-)
   }
 }
 
diff --git a/Detectors/TOF/simulation/include/TOFSimulation/Digitizer.h b/Detectors/TOF/simulation/include/TOFSimulation/Digitizer.h
index 5153f168f176f..4e369cecf6e26 100644
--- a/Detectors/TOF/simulation/include/TOFSimulation/Digitizer.h
+++ b/Detectors/TOF/simulation/include/TOFSimulation/Digitizer.h
@@ -148,7 +148,10 @@ class Digitizer : public WindowFiller
   float mTotLastHit[10];
   Int_t mXLastShift[10];
   Int_t mZLastShift[10];
-  ClassDefNV(Digitizer, 1);
+
+  float mIsCrateRDHerr[Geo::kNCrate];
+
+  ClassDefNV(Digitizer, 2);
 };
 } // namespace tof
 } // namespace o2
diff --git a/Detectors/TOF/simulation/src/Detector.cxx b/Detectors/TOF/simulation/src/Detector.cxx
index 2bfb76613dae5..97d5e03851291 100644
--- a/Detectors/TOF/simulation/src/Detector.cxx
+++ b/Detectors/TOF/simulation/src/Detector.cxx
@@ -637,7 +637,6 @@ void Detector::makeStripsInModules(Float_t ytof, Float_t zlenA) const
   // Define MRPC strip volume, called FSTR
   // Insert FSTR volume in FLTA/B/C volumes
   //
-  // ciao
   Float_t yFLT = ytof * 0.5 - Geo::MODULEWALLTHICKNESS;
 
   ///////////////// Detector itself //////////////////////
diff --git a/Detectors/TOF/simulation/src/Digitizer.cxx b/Detectors/TOF/simulation/src/Digitizer.cxx
index ec899bd35fbff..e2c4fdcca9abe 100644
--- a/Detectors/TOF/simulation/src/Digitizer.cxx
+++ b/Detectors/TOF/simulation/src/Digitizer.cxx
@@ -95,7 +95,7 @@ int Digitizer::process(const std::vector<HitType>* hits, std::vector<Digit>* dig
   const double max_hit_time = TOFSimParams::Instance().max_hit_time;
 
   // hits array of TOF hits for a given simulated event
-  // digits passed from external to be filled, in continuous readout mode we will push it on mDigitsPerTimeFrame vector of vectors of digits
+  // digits passed from external to be filled, in continuous readout mode we will push it on mDigitsPerTimeFrame, final vector of digits
 
   //  printf("process event time = %f with %ld hits\n",mEventTime.getTimeNS(),hits->size());
 
@@ -891,6 +891,7 @@ void Digitizer::fillOutputContainer(std::vector<Digit>& digits)
 
     // fill diagnostics
     mCalibApi->resetTRMErrors();
+    mCalibApi->resetDRMErrors();
     float p = gRandom->Rndm();
     if (mCalibApi->getEmptyTOFProb() > p) { // check empty TOF
       for (int i = 0; i < Geo::kNCrate; i++) {
@@ -906,6 +907,14 @@ void Digitizer::fillOutputContainer(std::vector<Digit>& digits)
           info.setEmptyCrate(i);
           isEmptyCrate[i] = true;
         } else { // check if filling diagnostic (noisy will be masked in clusterization, then skip here)
+          // Fill DRM RDH errors
+          for (int ie = 0; ie < mCalibApi->N_DRM_ERRORS; ie++) {
+            p = gRandom->Rndm();
+            if (mCalibApi->getDRMprobError(i, ie) > p) {
+              mCalibApi->processErrorDRM(i, ie);
+            }
+          }
+
           isEmptyCrate[i] = false;
           int slotreached = -1;
           const std::vector<std::pair<int, float>>& trmProg = mCalibApi->getTRMerrorProb();
@@ -955,7 +964,7 @@ void Digitizer::fillOutputContainer(std::vector<Digit>& digits)
         for (auto [key, dig] : dmap) {
           int crate = Geo::getCrateFromECH(Geo::getECHFromCH(dig.getChannel()));
 
-          if (isEmptyCrate[crate] || mCalibApi->isChannelError(dig.getChannel())) {
+          if (isEmptyCrate[crate] || mCalibApi->isChannelError(dig.getChannel()) || mCalibApi->isChannelDRMError(dig.getChannel())) {
             // flag digits to be removed
             keyToBeRemoved.push_back(key);
           }
diff --git a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
index c45c746064101..6f956efe79304 100644
--- a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
+++ b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
@@ -53,6 +53,7 @@
 // for TOF
 #include "TOFDigitizerSpec.h"
 #include "TOFWorkflowIO/TOFDigitWriterSpec.h"
+#include "TOFBase/CalibTOFapi.h"
 
 // for FT0
 #include "FT0DigitizerSpec.h"
@@ -202,6 +203,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   // option to use/not use CCDB for TOF
   workflowOptions.push_back(ConfigParamSpec{"use-ccdb-tof", o2::framework::VariantType::Bool, false, {"enable access to ccdb tof calibration objects"}});
   workflowOptions.push_back(ConfigParamSpec{"ccdb-tof-sa", o2::framework::VariantType::Bool, false, {"enable access to ccdb tof calibration objects via CCDBManager (obsolete remap to use-ccdb-tof)"}});
+  workflowOptions.push_back(ConfigParamSpec{"tof-drm-bitmask", o2::framework::VariantType::Int, (int)o2::tof::CalibTOFapi::DRM_ORBIT_MISMATCH, {"bit mask of DRM critical errors"}});
 
   // option to use/not use CCDB for FT0
   workflowOptions.push_back(ConfigParamSpec{"use-ccdb-ft0", o2::framework::VariantType::Bool, false, {"enable access to ccdb ft0 calibration objects"}});
@@ -677,10 +679,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     auto ccdb_url_tof = o2::base::NameConf::getCCDBServer();
     auto timestamp = o2::raw::HBFUtils::Instance().startTime / 1000;
     detList.emplace_back(o2::detectors::DetID::TOF);
+    auto maskDRM = (uint32_t)configcontext.options().get<int>("tof-drm-bitmask");
     // connect the TOF digitization
     // printf("TOF Setting: use-ccdb = %d ---- ccdb url=%s  ----   timestamp=%ld\n", useCCDB, ccdb_url_tof.c_str(), timestamp);
 
-    digitizerSpecs.emplace_back(o2::tof::getTOFDigitizerSpec(fanoutsize++, useCCDB, mctruth, ccdb_url_tof.c_str(), timestamp));
+    digitizerSpecs.emplace_back(o2::tof::getTOFDigitizerSpec(fanoutsize++, useCCDB, mctruth, ccdb_url_tof.c_str(), timestamp, maskDRM));
     // add TOF digit writer
     writerSpecs.emplace_back(o2::tof::getTOFDigitWriterSpec(mctruth));
   }
diff --git a/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.cxx
index e512659686c86..2a7800985fc1f 100644
--- a/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.cxx
@@ -48,7 +48,7 @@ namespace tof
 class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
 {
  public:
-  TOFDPLDigitizerTask(bool useCCDB, std::string ccdb_url, int timestamp) : mUseCCDB{useCCDB}, mCCDBurl(ccdb_url), mTimestamp(timestamp), o2::base::BaseDPLDigitizer(o2::base::InitServices::FIELD | o2::base::InitServices::GEOM), mPass(o2::conf::DigiParams::Instance().passName){};
+  TOFDPLDigitizerTask(bool useCCDB, std::string ccdb_url, int timestamp, uint32_t mask) : mUseCCDB{useCCDB}, mCCDBurl(ccdb_url), mTimestamp(timestamp), o2::base::BaseDPLDigitizer(o2::base::InitServices::FIELD | o2::base::InitServices::GEOM), mPass(o2::conf::DigiParams::Instance().passName), mMaskDRM(mask){};
 
   void initDigitizerTask(framework::InitContext& ic) override
   {
@@ -77,6 +77,10 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
       mUpdateCCDB = true;
       return;
     }
+    if (matcher == ConcreteDataMatcher("TOF", "DiagnosticDRM", 0)) {
+      mUpdateCCDB = true;
+      return;
+    }
     if (matcher == ConcreteDataMatcher("TOF", "LHCphaseCal", 0)) {
       mUpdateCCDB = true;
       return;
@@ -127,6 +131,7 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
       const auto lhcPhaseIn = pc.inputs().get<o2::dataformats::CalibLHCphaseTOF*>("tofccdbLHCphase");
       const auto channelCalibIn = pc.inputs().get<o2::dataformats::CalibTimeSlewingParamTOF*>("tofccdbChannelCalib");
       const auto diagnosticIn = pc.inputs().get<o2::tof::Diagnostic*>("tofccdbDia");
+      const auto diagnosticDRM = pc.inputs().get<o2::tof::Diagnostic*>("tofccdbDrm");
       const auto statusIn = pc.inputs().get<o2::tof::TOFFEElightInfo*>("tofccdbStatus");
       const auto tofParams = pc.inputs().get<o2::tof::ParameterCollection*>("tofccdbParams");
 
@@ -165,11 +170,15 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
         o2::dataformats::CalibLHCphaseTOF* lhcPhase = new o2::dataformats::CalibLHCphaseTOF(std::move(*lhcPhaseIn));
         o2::dataformats::CalibTimeSlewingParamTOF* channelCalib = new o2::dataformats::CalibTimeSlewingParamTOF(std::move(*channelCalibIn));
         o2::tof::Diagnostic* diagnostic = new o2::tof::Diagnostic(std::move(*diagnosticIn));
+        o2::tof::Diagnostic* diagnosticDRMerr = new o2::tof::Diagnostic(std::move(*diagnosticDRM));
         o2::tof::TOFFEElightInfo* status = new o2::tof::TOFFEElightInfo(std::move(*statusIn));
 
-        mCalibApi = new o2::tof::CalibTOFapi(long(0), lhcPhase, channelCalib, diagnostic);
+        mCalibApi = new o2::tof::CalibTOFapi(long(0), lhcPhase, channelCalib, diagnostic, diagnosticDRMerr);
+        mCalibApi->setDRMCriticalErrorMask(mMaskDRM);
         mCalibApi->loadDiagnosticFrequencies();
+        mCalibApi->loadDiagnosticDRMFrequencies();
         mCalibApi->loadActiveMap(status);
+
         mUpdateCCDB = false;
       } else { // update if necessary
         if (mUpdateCCDB) {
@@ -178,10 +187,14 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
           o2::dataformats::CalibLHCphaseTOF* lhcPhase = new o2::dataformats::CalibLHCphaseTOF(*lhcPhaseIn);
           o2::dataformats::CalibTimeSlewingParamTOF* channelCalib = new o2::dataformats::CalibTimeSlewingParamTOF(*channelCalibIn);
           o2::tof::Diagnostic* diagnostic = new o2::tof::Diagnostic(std::move(*diagnosticIn));
+          o2::tof::Diagnostic* diagnosticDRMerr = new o2::tof::Diagnostic(std::move(*diagnosticDRM));
           o2::tof::TOFFEElightInfo* status = new o2::tof::TOFFEElightInfo(std::move(*statusIn));
           mCalibApi = new o2::tof::CalibTOFapi(long(0), lhcPhase, channelCalib, diagnostic);
+          mCalibApi->setDRMCriticalErrorMask(mMaskDRM);
           mCalibApi->loadDiagnosticFrequencies();
+          mCalibApi->loadDiagnosticDRMFrequencies();
           mCalibApi->loadActiveMap(status);
+
           mUpdateCCDB = false;
         } else {
           // do nothing
@@ -201,10 +214,12 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
         channelCalibDummy->setFractionUnderPeak(sector, channelInSector, 1);
       }
       mCalibApi = new o2::tof::CalibTOFapi(long(mTimestamp), lhcPhaseDummy, channelCalibDummy);
+      mCalibApi->setDRMCriticalErrorMask(mMaskDRM);
 
       if (mUseCCDB) {
         mCalibApi->setURL(mCCDBurl);
         mCalibApi->readDiagnosticFrequencies();
+        mCalibApi->readDiagnosticDRMFrequencies();
         mCalibApi->readLHCphase();
         mCalibApi->readActiveMap();
         mCalibApi->readTimeSlewingParam();
@@ -300,9 +315,10 @@ class TOFDPLDigitizerTask : public o2::base::BaseDPLDigitizer
   bool mUpdateCCDB = false;
   o2::tof::CalibTOFapi* mCalibApi = nullptr;
   std::string mPass;
+  uint32_t mMaskDRM = 0;
 };
 
-DataProcessorSpec getTOFDigitizerSpec(int channel, bool useCCDB, bool mctruth, std::string ccdb_url, int timestamp)
+DataProcessorSpec getTOFDigitizerSpec(int channel, bool useCCDB, bool mctruth, std::string ccdb_url, int timestamp, uint32_t maskDRM)
 {
   // create the full data processor spec using
   //  a name identifier
@@ -319,6 +335,7 @@ DataProcessorSpec getTOFDigitizerSpec(int channel, bool useCCDB, bool mctruth, s
   if (useCCDB) {
     inputs.emplace_back("tofccdbStatus", "TOF", "StatusTOF", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/FEELIGHT"));
     inputs.emplace_back("tofccdbDia", "TOF", "DiagnosticCal", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/Diagnostic"));
+    inputs.emplace_back("tofccdbDrm", "TOF", "DiagnosticDRM", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/DRMerrors"));
     inputs.emplace_back("tofccdbLHCphase", "TOF", "LHCphaseCal", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/LHCphase"));
     inputs.emplace_back("tofccdbChannelCalib", "TOF", "ChannelCalibCal", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/ChannelCalib"));
     inputs.emplace_back("tofccdbParams", "TOF", "parameters", 0, Lifetime::Condition, ccdbParamSpec("TOF/Calib/Params"));
@@ -337,7 +354,7 @@ DataProcessorSpec getTOFDigitizerSpec(int channel, bool useCCDB, bool mctruth, s
     "TOFDigitizer",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TOFDPLDigitizerTask>(useCCDB, ccdb_url, timestamp)},
+    AlgorithmSpec{adaptFromTask<TOFDPLDigitizerTask>(useCCDB, ccdb_url, timestamp, maskDRM)},
     Options{{"pileup", VariantType::Int, 1, {"whether to run in continuous time mode"}}}
     // I can't use VariantType::Bool as it seems to have a problem
   };
diff --git a/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.h b/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.h
index f5841313c1cb0..7951b93eb1419 100644
--- a/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.h
+++ b/Steer/DigitizerWorkflow/src/TOFDigitizerSpec.h
@@ -19,7 +19,7 @@ namespace o2
 namespace tof
 {
 
-o2::framework::DataProcessorSpec getTOFDigitizerSpec(int channel, bool useCCDB, bool mctruth, std::string ccdb_url, int timestamp);
+o2::framework::DataProcessorSpec getTOFDigitizerSpec(int channel, bool useCCDB, bool mctruth, std::string ccdb_url, int timestamp, uint32_t maskDRM = 1 << 1);
 
 } // end namespace tof
 } // end namespace o2

From 94d365311d47fb9bca5d7fd8a027a7466d0e399f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Mar 2026 14:29:46 +0100
Subject: [PATCH 1388/1764] GPU Parameters: Make conversion more robust and
 compatible to UTF terminal encoding

---
 GPU/GPUTracking/CMakeLists.txt                        | 1 +
 GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh | 3 +++
 2 files changed, 4 insertions(+)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index dfee81b398a79..c276bf59af40b 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -283,6 +283,7 @@ foreach(GPU_PARAM_JSON_FILE IN LISTS GPU_PARAM_JSON)
     execute_process(COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/Definitions/Parameters/csv_to_json.sh "${GPU_PARAM_JSON_FILE}"
                     OUTPUT_FILE ${CMAKE_CURRENT_BINARY_DIR}/${CONVOUTFILE}
                     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+                    COMMAND_ERROR_IS_FATAL ANY
     )
     message(STATUS "Converted ${GPU_PARAM_JSON_FILE} to ${CONVOUTFILE}")
     list(APPEND GPU_PARAM_JSON_FILES ${CMAKE_CURRENT_BINARY_DIR}/${CONVOUTFILE})
diff --git a/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh b/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
index 373bd18ba7cd4..d064c4f6b58d9 100755
--- a/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
+++ b/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
@@ -2,7 +2,10 @@
 
 [[ -z $1 ]] && { echo "Usage: csv_to_json.sh CSV_FILE"; exit 1; }
 
+LANG=C
+LC_ALL=C
 DELIM=$'\xFF'
+set -o pipefail
 sed -E \
   ':loop
    s/^(([^"]*"[^"]*")*[^"]*),/\1'$DELIM'/;

From ca0d86d5cefc9e4b01bda1ea0f57f3f95e618fa4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 4 Mar 2026 11:15:14 +0100
Subject: [PATCH 1389/1764] Do not use random 1000 value for auto-setting of
 83cm for trackReferenceX as default, just disable as default

---
 Detectors/GlobalTracking/src/MatchCosmics.cxx                | 1 -
 Detectors/GlobalTracking/src/MatchTPCITS.cxx                 | 1 -
 Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx | 1 -
 Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx | 1 -
 Detectors/TPC/reconstruction/test/testGPUCATracking.cxx      | 2 +-
 Detectors/TPC/workflow/src/TPCRefitter.cxx                   | 1 -
 Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx         | 1 -
 Detectors/Vertexing/src/SVertexer.cxx                        | 1 -
 GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx         | 3 ---
 GPU/GPUTracking/Definitions/GPUSettingsList.h                | 2 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx                         | 3 +++
 11 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/Detectors/GlobalTracking/src/MatchCosmics.cxx b/Detectors/GlobalTracking/src/MatchCosmics.cxx
index 90964fb1c05fa..3c20ecad2f36c 100644
--- a/Detectors/GlobalTracking/src/MatchCosmics.cxx
+++ b/Detectors/GlobalTracking/src/MatchCosmics.cxx
@@ -96,7 +96,6 @@ void MatchCosmics::refitWinners(const o2::globaltracking::RecoContainer& data)
                                                                  mTPCCorrMapsHelper, mBz,
                                                                  tpcClusRefs.data(), 0, tpcClusShMap.data(),
                                                                  tpcClusOccMap.data(), tpcClusOccMap.size(), nullptr, o2::base::Propagator::Instance());
-    tpcRefitter->setTrackReferenceX(900); // disable propagation after refit by setting reference to value > 500
   }
 
   const auto& itsClusters = prepareITSClusters(data);
diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index 5f99ad2202073..73216c8ce1eac 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -505,7 +505,6 @@ bool MatchTPCITS::prepareTPCData()
   }
 
   mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMapsHelper, mBz, mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
-  mTPCRefitter->setTrackReferenceX(900); // disable propagation after refit by setting reference to value > 500
   mNTPCOccBinLength = mTPCRefitter->getParam()->rec.tpc.occupancyMapTimeBins;
   mTBinClOcc.clear();
   if (mNTPCOccBinLength > 1 && mTPCRefitterOccMap.size()) {
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
index 05e6a122adec9..ee475acbbcf70 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
@@ -188,7 +188,6 @@ void TPCTrackStudySpec::process(o2::globaltracking::RecoContainer& recoData)
   if (mTPCTracksArray.size()) {
     LOGP(info, "Found {} TPC tracks", mTPCTracksArray.size());
     mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, &mTPCCorrMapsLoader, prop->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
-    mTPCRefitter->setTrackReferenceX(900); // disable propagation after refit by setting reference to value > 500
   }
   float vdriftTB = mTPCVDriftHelper.getVDriftObject().getVDrift() * o2::tpc::ParameterElectronics::Instance().ZbinWidth; // VDrift expressed in cm/TimeBin
   float tpcTBBias = mTPCVDriftHelper.getVDriftObject().getTimeOffset() / (8 * o2::constants::lhc::LHCBunchSpacingMUS);
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index b8a8f97737b4d..c68e60059cd3f 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -163,7 +163,6 @@ void TrackingStudySpec::run(ProcessingContext& pc)
     mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(&recoData.inputsTPCclusters->clusterIndex, &mTPCCorrMapsLoader, o2::base::Propagator::Instance()->getNominalBz(),
                                                                   recoData.getTPCTracksClusterRefs().data(), 0, recoData.clusterShMapTPC.data(), recoData.occupancyMapTPC.data(),
                                                                   recoData.occupancyMapTPC.size(), nullptr, o2::base::Propagator::Instance());
-    mTPCRefitter->setTrackReferenceX(900); // disable propagation after refit by setting reference to value > 500
     mNTPCOccBinLength = mTPCRefitter->getParam()->rec.tpc.occupancyMapTimeBins;
     mTBinClOccBef.clear();
     mTBinClOccAft.clear();
diff --git a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
index 5c66e4635987f..0debfa72dd7fa 100644
--- a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
+++ b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
@@ -51,7 +51,7 @@ BOOST_AUTO_TEST_CASE(CATracking_test1)
   GPUO2Interface tracker;
 
   float solenoidBz = -5.00668; // B-field
-  float refX = 1000.;          // transport tracks to this x after tracking, >500 for disabling
+  float refX = 83.;            // transport tracks to this x after tracking, >500 for disabling
   bool continuous = false;     // time frame data v.s. triggered events
 
   GPUO2InterfaceConfiguration config;
diff --git a/Detectors/TPC/workflow/src/TPCRefitter.cxx b/Detectors/TPC/workflow/src/TPCRefitter.cxx
index 51ff2516524a9..43a55526246fe 100644
--- a/Detectors/TPC/workflow/src/TPCRefitter.cxx
+++ b/Detectors/TPC/workflow/src/TPCRefitter.cxx
@@ -336,7 +336,6 @@ void TPCRefitterSpec::process(o2::globaltracking::RecoContainer& recoData)
   }
 
   mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, &mTPCCorrMapsLoader, prop->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, prop);
-  mTPCRefitter->setTrackReferenceX(900); // disable propagation after refit by setting reference to value > 500
 
   mVdriftTB = mTPCVDriftHelper.getVDriftObject().getVDrift() * o2::tpc::ParameterElectronics::Instance().ZbinWidth; // VDrift expressed in cm/TimeBin
   mTPCTBBias = mTPCVDriftHelper.getVDriftObject().getTimeOffset() / (8 * o2::constants::lhc::LHCBunchSpacingMUS);
diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index 9e7ef089faeef..0f578efd3aa5b 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -294,7 +294,6 @@ void TRDGlobalTracking::run(ProcessingContext& pc)
 
   mTPCClusterIdxStruct = &inputTracks.inputsTPCclusters->clusterIndex;
   mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, &mTPCCorrMapsLoader, o2::base::Propagator::Instance()->getNominalBz(), inputTracks.getTPCTracksClusterRefs().data(), 0, inputTracks.clusterShMapTPC.data(), inputTracks.occupancyMapTPC.data(), inputTracks.occupancyMapTPC.size(), nullptr, o2::base::Propagator::Instance());
-  mTPCRefitter->setTrackReferenceX(900); // disable propagation after refit by setting reference to value > 500
   auto tmpInputContainer = getRecoInputContainer(pc, &mChainTracking->mIOPtrs, &inputTracks, mUseMC);
   auto tmpContainer = GPUWorkflowHelper::fillIOPtr(mChainTracking->mIOPtrs, inputTracks, mUseMC, nullptr, GTrackID::getSourcesMask("TRD"), mTrkMask, GTrackID::mask_t{GTrackID::MASK_NONE});
   mTrackletsRaw = inputTracks.getTRDTracklets();
diff --git a/Detectors/Vertexing/src/SVertexer.cxx b/Detectors/Vertexing/src/SVertexer.cxx
index d9206fe54e068..2c625c9cfaf0a 100644
--- a/Detectors/Vertexing/src/SVertexer.cxx
+++ b/Detectors/Vertexing/src/SVertexer.cxx
@@ -459,7 +459,6 @@ void SVertexer::buildT2V(const o2::globaltracking::RecoContainer& recoData) // a
     mTPCRefitterShMap = recoData.clusterShMapTPC;
     mTPCRefitterOccMap = mRecoCont->occupancyMapTPC;
     mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMapsHelper, o2::base::Propagator::Instance()->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
-    mTPCRefitter->setTrackReferenceX(900); // disable propagation after refit by setting reference to value > 500
   }
 
   std::unordered_map<GIndex, std::pair<int, int>> tmap;
diff --git a/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
index 60fdbe8042c2d..49cd25624b2c3 100644
--- a/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
@@ -119,9 +119,6 @@ GPUSettingsO2 GPUO2InterfaceConfiguration::ReadConfigurableParam(GPUO2InterfaceC
   if (global.gpuDisplayfilterMacro != "") {
     obj.configDisplay.filterMacros.emplace_back(global.gpuDisplayfilterMacro);
   }
-  if (obj.configReconstruction.tpc.trackReferenceX == 1000.f) {
-    obj.configReconstruction.tpc.trackReferenceX = 83.f;
-  }
   obj.configDeviceBackend.deviceType = gpudatatypes::GetDeviceType(global.deviceType.c_str());
   obj.configDeviceBackend.forceDeviceType = global.forceDeviceType;
   return global;
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index cf6b913551ab5..e34af48d7a85e 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -66,7 +66,7 @@ AddOptionRTC(sysClusErrorC12Box, float, 1.1e-05f, "", 0, "Systematic cluster for
 AddOptionRTC(minNClustersTrackSeed, int32_t, -1, "", 0, "required min number of clusters on the track after track following (before merging)")
 AddOptionRTC(minNClustersFinalTrack, int32_t, -1, "", 0, "required min number of clusters on the final track")
 AddOptionRTC(searchWindowDZDR, float, 2.5f, "", 0, "Use DZDR window for seeding instead of neighboursSearchArea")
-AddOptionRTC(trackReferenceX, float, 1000.f, "", 0, "Transport all tracks to this X after tracking (disabled if > 500, auto = 1000)")
+AddOptionRTC(trackReferenceX, float, 1000.f, "", 0, "Transport all tracks to this X after tracking (disabled if > 500)")
 AddOptionRTC(zsThreshold, float, 2.0f, "", 0, "Zero-Suppression threshold")
 AddOptionRTC(tubeProtectSigma2, float, 4.f * 4.f, "", 0, "Max sigma2 to mark adjacent cluster for protection")
 AddOptionRTC(tubeProtectMaxSize2, float, 2.f * 2.f, "", 0, "Square of max tube size (if smaller than tubeProtectChi2)")
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 48210c440d01e..7f69513dea1d5 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -281,6 +281,9 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
 
     mConfig->configProcessing.willProvideO2PropagatorLate = true;
     mConfig->configProcessing.o2PropagatorUseGPUField = true;
+    if (mConfig->configReconstruction.tpc.trackReferenceX == 1000.f) {
+      mConfig->configReconstruction.tpc.trackReferenceX = 83.f;
+    }
 
     if (mConfParam->printSettings && (mConfParam->printSettings > 1 || ic.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0)) {
       mConfig->configProcessing.printSettings = true;

From 396dc287d6f513a7f305f20a7b0706350c8f9900 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 4 Mar 2026 11:26:52 +0100
Subject: [PATCH 1390/1764] Add getter for individual GPU configKeyValues

---
 .../Interface/GPUO2InterfaceConfiguration.inc | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.inc

diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.inc b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.inc
new file mode 100644
index 0000000000000..a8ec49df2a281
--- /dev/null
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.inc
@@ -0,0 +1,37 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUO2InterfaceConfiguration.inc
+/// \author David Rohr
+
+// Note, this must potentionally be included first, before other GPU headers!
+// Do not include in .h files!
+
+#ifndef GPUO2INTERFACECONFIGURATIONINC_H
+#define GPUO2INTERFACECONFIGURATIONINC_H
+
+#ifdef GPUCA_STANDALONE
+#define GPU_GET_CONFIG(configName) static_assert(false, "GPU_GET_CONFIG not available in standalone benchmark")
+#else
+#include "GPUO2ExternalUser.h"
+#include "GPUCommonRtypes.h"
+#include "GPUDefMacros.h"
+#include "GPUO2InterfaceConfiguration.h"
+#include "GPUO2ConfigurableParam.h"
+#include <type_traits>
+
+#define GPU_GET_CONFIG(configName) []() -> decltype(auto) {                            \
+  static_assert(!std::is_same_v<o2::gpu::configName, o2::gpu::GPUSettingsProcessing>); \
+  return o2::gpu::GPUCA_M_CAT(GPUConfigurableParam, configName)::Instance();           \
+}()
+#endif
+
+#endif

From f4c528d0452e3e2b98807efce437ad8535aa6cd1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 4 Mar 2026 13:24:16 +0100
Subject: [PATCH 1391/1764] Fix missing header

---
 Common/Utils/src/StringUtils.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Common/Utils/src/StringUtils.cxx b/Common/Utils/src/StringUtils.cxx
index 29c43ec18375b..89f834d9a8f2e 100644
--- a/Common/Utils/src/StringUtils.cxx
+++ b/Common/Utils/src/StringUtils.cxx
@@ -17,6 +17,7 @@
 #include <fmt/format.h>
 #endif
 #include <unistd.h>
+#include <cstring>
 
 using namespace o2::utils;
 

From 8858408fe64b51a5ef214fd7cbf8b5a7a22b727e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 4 Mar 2026 19:54:12 +0100
Subject: [PATCH 1392/1764] Fetch only GPUSettingsRecTRD for TRD tasks not all
 GPU ConfigurableParams

---
 Detectors/Align/src/AlignableDetectorTRD.cxx         |  4 +---
 .../SpacePoints/src/TrackInterpolation.cxx           |  4 +---
 Detectors/TRD/calibration/src/TrackBasedCalib.cxx    |  4 +---
 Detectors/TRD/qc/src/Tracking.cxx                    |  4 +---
 GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx        | 12 +++++++++++-
 5 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/Detectors/Align/src/AlignableDetectorTRD.cxx b/Detectors/Align/src/AlignableDetectorTRD.cxx
index 080d0f72b2516..6fe8a60ef90f6 100644
--- a/Detectors/Align/src/AlignableDetectorTRD.cxx
+++ b/Detectors/Align/src/AlignableDetectorTRD.cxx
@@ -178,9 +178,7 @@ int AlignableDetectorTRD::processPoints(GIndex gid, int npntCut, bool inv)
   auto propagator = o2::base::Propagator::Instance(); // float version!
   static bool firstCall = true;
   if (firstCall) {
-    o2::gpu::GPUO2InterfaceConfiguration config;
-    config.ReadConfigurableParam(config);
-    mRecoParam.init(propagator->getNominalBz(), &config.configReconstruction);
+    mRecoParam.init(propagator->getNominalBz());
     firstCall = false;
   }
   const auto* transformer = mController->getTRDTransformer();
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index cd5e3960160a6..539ae25862865 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -126,9 +126,7 @@ void TrackInterpolation::init(o2::dataformats::GlobalTrackID::mask_t src, o2::da
   mFastTransform = std::move(TPCFastTransformHelperO2::instance()->create(0));
 
   mBz = o2::base::Propagator::Instance()->getNominalBz();
-  o2::gpu::GPUO2InterfaceConfiguration config;
-  config.ReadConfigurableParam(config);
-  mRecoParam.init(mBz, &config.configReconstruction);
+  mRecoParam.init(mBz);
   mGeoTRD = o2::trd::Geometry::instance();
   mParams = &SpacePointsCalibConfParam::Instance();
 
diff --git a/Detectors/TRD/calibration/src/TrackBasedCalib.cxx b/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
index ae1f7b33c6bba..0d551e7b5f33d 100644
--- a/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
+++ b/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
@@ -36,9 +36,7 @@ void TrackBasedCalib::reset()
 void TrackBasedCalib::init()
 {
   bz = o2::base::Propagator::Instance()->getNominalBz();
-  o2::gpu::GPUO2InterfaceConfiguration config;
-  config.ReadConfigurableParam(config);
-  mRecoParam.init(bz, &config.configReconstruction);
+  mRecoParam.init(bz);
 }
 
 void TrackBasedCalib::setInput(const o2::globaltracking::RecoContainer& input)
diff --git a/Detectors/TRD/qc/src/Tracking.cxx b/Detectors/TRD/qc/src/Tracking.cxx
index 9a0df7efa323b..da2d05794e2d8 100644
--- a/Detectors/TRD/qc/src/Tracking.cxx
+++ b/Detectors/TRD/qc/src/Tracking.cxx
@@ -26,9 +26,7 @@ using namespace o2::trd::constants;
 
 void Tracking::init()
 {
-  o2::gpu::GPUO2InterfaceConfiguration config;
-  config.ReadConfigurableParam(config);
-  mRecoParam.init(o2::base::Propagator::Instance()->getNominalBz(), &config.configReconstruction);
+  mRecoParam.init(o2::base::Propagator::Instance()->getNominalBz());
 }
 
 void Tracking::setInput(const o2::globaltracking::RecoContainer& input)
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
index 674b7a317b477..f7adc2401df79 100644
--- a/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUTRDRecoParam.cxx
@@ -13,6 +13,7 @@
 /// \brief Error parameterizations and helper functions for TRD reconstruction
 /// \author Ole Schmidt
 
+#include "GPUO2InterfaceConfiguration.inc"
 #include "GPUSettings.h"
 #include "GPUTRDRecoParam.h"
 #include "GPUCommonLogger.h"
@@ -23,7 +24,16 @@ using namespace o2::gpu;
 // error parameterizations taken from http://cds.cern.ch/record/2724259 Appendix A
 void GPUTRDRecoParam::init(float bz, const GPUSettingsRec* rec)
 {
-  float resRPhiIdeal2 = rec ? rec->trd.trkltResRPhiIdeal * rec->trd.trkltResRPhiIdeal : 1.6e-3f;
+  float resRPhiIdeal2 = 1.6e-3f;
+  if (rec) {
+    resRPhiIdeal2 = rec->trd.trkltResRPhiIdeal * rec->trd.trkltResRPhiIdeal;
+  }
+#ifndef GPUCA_STANDALONE
+  else {
+    const auto& rtrd = GPU_GET_CONFIG(GPUSettingsRecTRD);
+    resRPhiIdeal2 = rtrd.trkltResRPhiIdeal * rtrd.trkltResRPhiIdeal;
+  }
+#endif
 
   if (CAMath::Abs(CAMath::Abs(bz) - 2) < 0.1) {
     if (bz > 0) {

From 23fa9c3c76e73cd2cac18dca94817b29c8b424b9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 5 Mar 2026 10:27:26 +0100
Subject: [PATCH 1393/1764] Avoid unintended usage of GPUO2ConfigurableParam.h

---
 Detectors/TPC/workflow/src/CalibdEdxSpec.cxx  |  7 ++--
 .../TPC/workflow/src/CalibratordEdxSpec.cxx   |  7 ++--
 .../DataTypes/GPUO2ConfigurableParam.cxx      |  4 +--
 .../DataTypes/GPUO2ConfigurableParam.h        | 13 ++++++--
 .../GPUTrackingLinkDef_O2_DataTypes.h         | 32 +++++++++----------
 .../Interface/GPUO2InterfaceConfiguration.inc |  2 +-
 6 files changed, 37 insertions(+), 28 deletions(-)

diff --git a/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx b/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
index 7c2e2db8188e8..15ea241a7b350 100644
--- a/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalibdEdxSpec.cxx
@@ -13,6 +13,7 @@
 /// \brief Workflow for time based dE/dx calibration.
 /// \author Thiago Badaró <thiago.saramela@usp.br>
 
+#include "GPUO2InterfaceConfiguration.inc"
 #include "TPCWorkflow/CalibdEdxSpec.h"
 
 // o2 includes
@@ -26,7 +27,6 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
-#include "GPUO2ConfigurableParam.h"
 #include "TPCCalibration/CalibdEdx.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "TPCBaseRecSim/CDBTypes.h"
@@ -70,8 +70,9 @@ class CalibdEdxDevice : public Task
     mCalib->setElectronCut(fitThreshold, fitPasses, fitThresholdLowFactor);
     mCalib->setMaterialType(mMatType);
 
-    mCustomdEdxFileName = o2::gpu::GPUConfigurableParamGPUSettingsO2::Instance().dEdxCorrFile;
-    mDisableTimeGain = o2::gpu::GPUConfigurableParamGPUSettingsO2::Instance().dEdxDisableResidualGain;
+    const auto& gpuConfig = GPU_GET_CONFIG(GPUSettingsO2);
+    mCustomdEdxFileName = gpuConfig.dEdxCorrFile;
+    mDisableTimeGain = gpuConfig.dEdxDisableResidualGain;
 
     if (mDisableTimeGain) {
       LOGP(info, "TimeGain correction was disabled via GPU_global.dEdxDisableResidualGain=1");
diff --git a/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx b/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
index 87e339f0643f4..dea1d85899675 100644
--- a/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
+++ b/Detectors/TPC/workflow/src/CalibratordEdxSpec.cxx
@@ -13,6 +13,7 @@
 /// \brief Workflow for time based dE/dx calibration.
 /// \author Thiago Badaró <thiago.saramela@usp.br>
 
+#include "GPUO2InterfaceConfiguration.inc"
 #include "TPCWorkflow/CalibratordEdxSpec.h"
 
 #include <vector>
@@ -29,7 +30,6 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
-#include "GPUO2ConfigurableParam.h"
 #include "TPCCalibration/CalibratordEdx.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "DetectorsBase/GRPGeomHelper.h"
@@ -86,8 +86,9 @@ class CalibratordEdxDevice : public Task
     mCalibrator->setTrackDebug(trackDebug);
     mCalibrator->setMakeGaussianFits(makeGaussianFits);
 
-    mCustomdEdxFileName = o2::gpu::GPUConfigurableParamGPUSettingsO2::Instance().dEdxCorrFile;
-    mDisableTimeGain = o2::gpu::GPUConfigurableParamGPUSettingsO2::Instance().dEdxDisableResidualGain;
+    const auto& gpuConfig = GPU_GET_CONFIG(GPUSettingsO2);
+    mCustomdEdxFileName = gpuConfig.dEdxCorrFile;
+    mDisableTimeGain = gpuConfig.dEdxDisableResidualGain;
 
     if (mDisableTimeGain) {
       LOGP(info, "TimeGain correction was disabled via GPU_global.dEdxDisableResidualGain=1");
diff --git a/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
index 49cd25624b2c3..f3b7e07c4c43b 100644
--- a/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.cxx
@@ -29,7 +29,7 @@ using namespace o2::gpu;
 #define AddOptionArray(name, type, count, default, optname, optnameshort, help, ...)
 #define AddOptionArrayRTC(...) AddOptionArray(__VA_ARGS__)
 #define AddSubConfig(name, instance)
-#define BeginSubConfig(name, instance, parent, preoptname, preoptnameshort, descr, o2prefix) O2ParamImpl(GPUCA_M_CAT(GPUConfigurableParam, name))
+#define BeginSubConfig(name, instance, parent, preoptname, preoptnameshort, descr, o2prefix) O2ParamImpl(internal::GPUCA_M_CAT(GPUConfigurableParam, name))
 #define BeginHiddenConfig(...)
 #define EndConfig()
 #define AddCustomCPP(...)
@@ -73,7 +73,7 @@ GPUSettingsO2 GPUO2InterfaceConfiguration::ReadConfigurableParam(GPUO2InterfaceC
 #define BeginSubConfig(name, instance, parent, preoptname, preoptnameshort, descr, o2prefix) \
   name instance;                                                                             \
   {                                                                                          \
-    const auto& src = GPUCA_M_CAT(GPUConfigurableParam, name)::Instance();                   \
+    const auto& src = internal::GPUCA_M_CAT(GPUConfigurableParam, name)::Instance();         \
     name& dst = instance;
 #define BeginHiddenConfig(name, instance) {
 #define EndConfig() }
diff --git a/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.h b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.h
index 8bc0d98910f54..503ba3e0d51ae 100644
--- a/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.h
+++ b/GPU/GPUTracking/DataTypes/GPUO2ConfigurableParam.h
@@ -29,6 +29,7 @@
 #include "GPUDefMacros.h"
 #include <vector>
 
+// clang-format off
 #define BeginNamespace(name) \
   namespace name             \
   {
@@ -42,12 +43,17 @@
 #define AddOptionArray(name, type, count, default, optname, optnameshort, help, ...) type name[count] = {GPUCA_M_STRIP(default)};
 #define AddSubConfig(name, instance)
 #define BeginSubConfig(name, instance, parent, preoptname, preoptnameshort, descr, o2prefix)                                           \
+  namespace internal                                                                                                                   \
+  {                                                                                                                                    \
   struct GPUCA_M_CAT(GPUConfigurableParam, name) : public o2::conf::ConfigurableParamHelper<GPUCA_M_CAT(GPUConfigurableParam, name)> { \
     O2ParamDef(GPUCA_M_CAT(GPUConfigurableParam, name), GPUCA_M_STR(GPUCA_M_CAT(GPU_, o2prefix))) public:
-#define BeginHiddenConfig(name, instance) struct GPUCA_M_CAT(GPUConfigurableParam, name) {
+#define BeginHiddenConfig(name, instance) \
+  namespace internal                      \
+  {                                       \
+  struct GPUCA_M_CAT(GPUConfigurableParam, name) {
 #define EndConfig() \
-  }                 \
-  ;
+  };                \
+  } // namespace internal
 #define AddCustomCPP(...) __VA_ARGS__
 #define AddHelp(...)
 #define AddShortcut(...)
@@ -71,5 +77,6 @@
 #undef AddCustomCPP
 #undef AddHelp
 #undef AddShortcut
+// clang-format on
 
 #endif
diff --git a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
index 7bd2c689c5354..5318e23e7d10f 100644
--- a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
+++ b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
@@ -22,22 +22,22 @@
 #pragma link C++ class o2::gpu::GPUTRDTrack_t < o2::gpu::trackInterface < o2::track::TrackParCov>> + ;
 #pragma link C++ class std::vector < o2::gpu::GPUTRDTrack_t < o2::gpu::trackInterface < o2::track::TrackParCov>>> + ;
 #ifdef GPUCA_O2_LIB
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsO2 + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsRec + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsRecTPC + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsRecTRD + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsRecDynamic + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessing + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingParam + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingRTC + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingRTCtechnical + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsProcessingNNclusterizer + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplay + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplayLight + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplayHeavy + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplayRenderer + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsDisplayVulkan + ;
-#pragma link C++ class o2::gpu::GPUConfigurableParamGPUSettingsQA + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsO2 + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsRec + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsRecTPC + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsRecTRD + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsRecDynamic + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessing + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessingParam + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessingRTC + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessingRTCtechnical + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessingNNclusterizer + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsDisplay + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsDisplayLight + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsDisplayHeavy + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsDisplayRenderer + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsDisplayVulkan + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsQA + ;
 #endif
 #pragma link C++ class o2::gpu::GPUTPCGMMergedTrackHit + ;
 #pragma link C++ class o2::tpc::CalibdEdxTrackTopologyPol + ;
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.inc b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.inc
index a8ec49df2a281..30f6d56a17f1a 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.inc
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceConfiguration.inc
@@ -30,7 +30,7 @@
 
 #define GPU_GET_CONFIG(configName) []() -> decltype(auto) {                            \
   static_assert(!std::is_same_v<o2::gpu::configName, o2::gpu::GPUSettingsProcessing>); \
-  return o2::gpu::GPUCA_M_CAT(GPUConfigurableParam, configName)::Instance();           \
+  return o2::gpu::internal::GPUCA_M_CAT(GPUConfigurableParam, configName)::Instance(); \
 }()
 #endif
 

From 4d2d35ee7f495258fb06c105826a9e841ce00b35 Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Fri, 6 Mar 2026 09:50:40 +0100
Subject: [PATCH 1394/1764] Do not parse/init TPC correction options if TPC is
 absent (#15123)

* Do not parse TPC correction options if TPC is absent

* Do not init TPC corr.loader in SVFinder in absence of TPC
---
 .../GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx | 8 +++++---
 prodtests/full-system-test/dpl-workflow.sh                | 4 +++-
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
index 1b55f9c763e7f..6dfd1cb770d7f 100644
--- a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
@@ -60,9 +60,11 @@ class SecondaryVertexingSpec : public Task
  public:
   SecondaryVertexingSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, GTrackID::mask_t src, bool enabCasc, bool enable3body, bool enableStrangenessTracking, bool enableCCDBParams, bool useMC) : mDataRequest(dr), mGGCCDBRequest(gr), mSrc(src), mEnableCascades(enabCasc), mEnable3BodyVertices(enable3body), mEnableStrangenessTracking(enableStrangenessTracking), mEnableCCDBParams(enableCCDBParams), mUseMC(useMC)
   {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
+    if (mSrc[GTrackID::TPC]) {
+      mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
+      mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+      mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
+    }
   }
   ~SecondaryVertexingSpec() override = default;
   void init(InitContext& ic) final;
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 9c6c45c049576..a3048a494796e 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -332,7 +332,9 @@ done
 ! has_detector CTP && [[ ${CTPLUMY_DISABLED:-} != 1 ]] && TPC_CORR_OPT+=" --disable-ctp-lumi-request"
 }
 
-parse_TPC_CORR_SCALING $TPC_CORR_SCALING
+if has_detector TPC; then
+  parse_TPC_CORR_SCALING $TPC_CORR_SCALING
+fi
 
 if [[ $GPUTYPE != "CPU" && $(ulimit -e) -ge 25 && ${O2_GPU_WORKFLOW_NICE:-} == 1 ]]; then
   GPU_CONFIG_SELF+=" --child-driver 'nice -n -5'"

From 7ebcfb639db92c6d0a4a0426d9490ccbab7e1211 Mon Sep 17 00:00:00 2001
From: cortesep <57937610+cortesep@users.noreply.github.com>
Date: Fri, 6 Mar 2026 09:42:29 +0100
Subject: [PATCH 1395/1764] Update CODEOWNERS (#92)

---
 CODEOWNERS | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 26021d458ad76..369a7cf8a8463 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -43,7 +43,7 @@
 /DataFormats/Detectors/TRD                     @f3sch @bazinski @wille10
 /DataFormats/Detectors/Upgrades                @mconcas
 /DataFormats/Detectors/Upgrades/ITS3           @fgrosa @arossi81
-/DataFormats/Detectors/ZDC                     @coppedis
+/DataFormats/Detectors/ZDC                     @coppedis @cortesep
 
 #/DataFormats/Headers
 #/DataFormats/Legacy
@@ -75,7 +75,7 @@
 /Detectors/Upgrades                @mconcas
 /Detectors/Upgrades/ALICE3         @mconcas @njacazio
 /Detectors/Upgrades/ITS3           @fgrosa @arossi81 @mconcas @f3sch
-/Detectors/ZDC                     @coppedis
+/Detectors/ZDC                     @coppedis @cortesep
 /Detectors/CTF                     @shahor02
 /Detectors/Raw                     @shahor02
 /Detectors/StrangenessTracking     @mconcas @mpuccio @fmazzasc

From 538bd61b8df51e3265af5f0e84abb4b1cf1328a0 Mon Sep 17 00:00:00 2001
From: Francesco Noferini <noferini@bo.infn.it>
Date: Sat, 7 Mar 2026 10:20:16 +0100
Subject: [PATCH 1396/1764] fix include in one TOF macro

---
 Detectors/TOF/prototyping/checkDRMobj_tof.C | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Detectors/TOF/prototyping/checkDRMobj_tof.C b/Detectors/TOF/prototyping/checkDRMobj_tof.C
index 9652a4fb9823e..81381852b15df 100644
--- a/Detectors/TOF/prototyping/checkDRMobj_tof.C
+++ b/Detectors/TOF/prototyping/checkDRMobj_tof.C
@@ -12,6 +12,7 @@
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 #include "TFile.h"
 #include "TH2F.h"
+#include "TCanvas.h"
 #include "TOFBase/CalibTOFapi.h"
 #endif
 

From d40b3503fd10e4df52f61d100466d84f05ab5d1a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 8 Mar 2026 14:18:37 +0100
Subject: [PATCH 1397/1764] Protection against null proc.context in GPUWorkflow

---
 GPU/Workflow/src/GPUWorkflowSpec.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 7f69513dea1d5..f7fc760b99125 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -520,7 +520,7 @@ int32_t GPURecoWorkflowSpec::runMain(o2::framework::ProcessingContext* pc, GPUTr
     static bool first = true;
     if (first) {
       first = false;
-      if (pc->services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // TPC ConfigurableCarams are somewhat special, need to construct by hand
+      if (pc && pc->services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // TPC ConfigurableCarams are somewhat special, need to construct by hand
         o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc->services().get<const o2::framework::DeviceSpec>().name, "rec_tpc"), "GPU_rec_tpc,GPU_rec,GPU_proc_param,GPU_proc,GPU_global,trackTuneParams");
       }
     }

From 095ccb47ccf3c623ca2b8b962f3addf087203b9b Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 9 Mar 2026 11:17:52 +0100
Subject: [PATCH 1398/1764] DPL Analysis: fix missing sourceMatcher

---
 Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index ea13d412cd0b8..413adfddecf04 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -84,6 +84,7 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
         if (m.name.starts_with("input:")) {
           auto name = m.name.substr(6);
           schemaMetadata->Append("sourceTable", name);
+          schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
           continue;
         }
         // Ignore the non ccdb: entries

From 94799ffc659dfd699992a7f002fcdeb362248551 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Mon, 9 Mar 2026 21:13:40 +0100
Subject: [PATCH 1399/1764] [ALICE3] TRK: fix macro CheckDigits.C (#15136)

---
 .../ALICE3/TRK/macros/test/CheckDigits.C      | 112 +++++++++++++-----
 1 file changed, 82 insertions(+), 30 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
index 5d60592a96f41..618dbe929a943 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
@@ -19,11 +19,13 @@
 #include <TNtuple.h>
 #include <TString.h>
 #include <TTree.h>
+#include <TLine.h>
+#include <TStyle.h>
 
 #include "TRKBase/SegmentationChip.h"
 #include "TRKBase/GeometryTGeo.h"
 #include "DataFormatsITSMFT/Digit.h"
-#include "ITSMFTSimulation/Hit.h"
+#include "TRKSimulation/Hit.h"
 #include "MathUtils/Utils.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "SimulationDataFormat/IOMCTruthContainerView.h"
@@ -36,14 +38,50 @@
 
 #define ENABLE_UPGRADES
 
-void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile = "o2sim_HitsTRK.root", std::string inputGeom = "", std::string paramfile = "o2sim_par.root")
+void addTLines(float pitch)
 {
+  // Add grid lines at multiples of pitch on the current pad
+  if (!gPad)
+    return;
+
+  gPad->Update();
+
+  Double_t xmin = gPad->GetUxmin();
+  Double_t xmax = gPad->GetUxmax();
+  Double_t ymin = gPad->GetUymin();
+  Double_t ymax = gPad->GetUymax();
+
+  // Calculate the first vertical line position (multiple of pitch)
+  int nLinesX = 0;
+  for (float x = xmin; x <= xmax && nLinesX < 1000; x += pitch, nLinesX++) {
+    TLine* line = new TLine(x, ymin, x, ymax);
+    line->SetLineStyle(2);
+    line->SetLineColor(kGray);
+    line->Draw("same");
+  }
+
+  // Calculate the first horizontal line position (multiple of pitch)
+  int nLinesY = 0;
+  for (float y = ymin; y <= ymax && nLinesY < 1000; y += pitch, nLinesY++) {
+    TLine* line = new TLine(xmin, y, xmax, y);
+    line->SetLineStyle(2);
+    line->SetLineColor(kGray);
+    line->Draw("same");
+  }
+
+  gPad->Modified();
+  gPad->Update();
+}
+
+void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile = "o2sim_HitsTRK.root", std::string inputGeom = "o2sim_geometry.root", std::string paramfile = "o2sim_par.root")
+{
+  gStyle->SetPalette(55);
 
   using namespace o2::base;
   using namespace o2::trk;
 
   using o2::itsmft::Digit;
-  using o2::itsmft::Hit;
+  using o2::trk::Hit;
 
   using o2::trk::SegmentationChip;
 
@@ -64,7 +102,7 @@ void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile =
   TFile* hitFile = TFile::Open(hitfile.data());
   TTree* hitTree = (TTree*)hitFile->Get("o2sim");
   int nevH = hitTree->GetEntries(); // hits are stored as one event per entry
-  std::vector<std::vector<o2::itsmft::Hit>*> hitArray(nevH, nullptr);
+  std::vector<std::vector<o2::trk::Hit>*> hitArray(nevH, nullptr);
 
   std::vector<std::unordered_map<uint64_t, int>> mc2hitVec(nevH);
 
@@ -273,110 +311,124 @@ void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile =
   auto canvXY = new TCanvas("canvXY", "", 1600, 2400);
   canvXY->Divide(2, 3);
   canvXY->cd(1);
-  nt->Draw("y:x >>h_y_vs_x_VD(1000, -3, 3, 1000, -3, 3)", "id < 36 ", "colz");
+  nt->Draw("y:x >>h_y_vs_x_VD(1000, -3, 3, 1000, -3, 3)", "id < 12 ", "colz");
   canvXY->cd(2);
-  nt->Draw("y:z>>h_y_vs_z_VD(1000, -26, 26, 1000, -3, 3)", "id < 36 ", "colz");
+  nt->Draw("y:z>>h_y_vs_z_VD(1000, -26, 26, 1000, -3, 3)", "id < 12 ", "colz");
   canvXY->cd(3);
-  nt->Draw("y:x>>h_y_vs_x_ML(1000, -25, 25, 1000, -25, 25)", "id >= 36 && id < 106 ", "colz");
+  nt->Draw("y:x>>h_y_vs_x_ML(1000, -25, 25, 1000, -25, 25)", "id >= 12 && id < 5132 ", "colz");
   canvXY->cd(4);
-  nt->Draw("y:z>>h_y_vs_z_ML(1000, -70, 70, 1000, -25, 25)", "id >= 36 && id < 106 ", "colz");
+  nt->Draw("y:z>>h_y_vs_z_ML(1000, -70, 70, 1000, -25, 25)", "id >= 12 && id < 5132 ", "colz");
   canvXY->cd(5);
-  nt->Draw("y:x>>h_y_vs_x_OT(1000, -85, 85, 1000, -85, 85)", "id >= 106 ", "colz");
+  nt->Draw("y:x>>h_y_vs_x_OT(1000, -85, 85, 1000, -85, 85)", "id >= 5132 ", "colz");
   canvXY->cd(6);
-  nt->Draw("y:z>>h_y_vs_z_OT(1000, -85, 85, 1000, -130, 130)", "id >= 106 ", "colz");
+  nt->Draw("y:z>>h_y_vs_z_OT(1000, -85, 85, 1000, -130, 130)", "id >= 5132 ", "colz");
   canvXY->SaveAs("trkdigits_y_vs_x_vs_z.pdf");
 
   // z distributions
   auto canvZ = new TCanvas("canvZ", "", 800, 2400);
   canvZ->Divide(1, 3);
   canvZ->cd(1);
-  nt->Draw("z>>h_z_VD(500, -26, 26)", "id < 36 ");
+  nt->Draw("z>>h_z_VD(500, -26, 26)", "id < 12 ");
   canvZ->cd(2);
-  nt->Draw("z>>h_z_ML(500, -70, 70)", "id >= 36 && id < 106 ");
+  nt->Draw("z>>h_z_ML(500, -70, 70)", "id >= 12 && id < 5132 ");
   canvZ->cd(3);
-  nt->Draw("z>>h_z_OT(500, -85, 85)", "id >= 106 ");
+  nt->Draw("z>>h_z_OT(500, -85, 85)", "id >= 5132 ");
   canvZ->SaveAs("trkdigits_z.pdf");
 
   // dz distributions (difference between local position of digits and hits in x and z)
   auto canvdZ = new TCanvas("canvdZ", "", 800, 2400);
   canvdZ->Divide(1, 3);
   canvdZ->cd(1);
-  nt->Draw("dz>>h_dz_VD(500, -0.05, 0.05)", "id < 36 ");
+  nt->Draw("dz>>h_dz_VD(500, -0.05, 0.05)", "id < 12 ");
   canvdZ->cd(2);
-  nt->Draw("dz>>h_dz_ML(500, -0.05, 0.05)", "id >= 36 && id < 106 ");
+  nt->Draw("dz>>h_dz_ML(500, -0.05, 0.05)", "id >= 12 && id < 5132 ");
   canvdZ->cd(3);
-  nt->Draw("dz>>h_dz_OT(500, -0.05, 0.05)", "id >= 106 ");
+  nt->Draw("dz>>h_dz_OT(500, -0.05, 0.05)", "id >= 5132 ");
   canvdZ->SaveAs("trkdigits_dz.pdf");
+  canvdZ->SaveAs("trkdigits_dz.root");
 
   // distributions of differences between local positions of digits and hits in x and z
   auto canvdXdZ = new TCanvas("canvdXdZ", "", 1600, 2400);
   canvdXdZ->Divide(2, 3);
   canvdXdZ->cd(1);
-  nt->Draw("dx:dz>>h_dx_vs_dz_VD(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 36", "colz");
+  nt->Draw("dx:dz>>h_dx_vs_dz_VD(500, -0.005, 0.005, 500, -0.005, 0.005)", "id < 12", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowVD);
   auto h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_VD");
   LOG(info) << "dx, dz";
   Info("VD", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("VD", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZ->cd(2);
-  nt->Draw("dx:dz>>h_dx_vs_dz_VD_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 36 && abs(z)<2", "colz");
+  nt->Draw("dx:dz>>h_dx_vs_dz_VD_z(500, -0.005, 0.005, 500, -0.005, 0.005)", "id < 12 && abs(z)<0.5", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowVD);
   h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_VD_z");
-  Info("VD |z|<2", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
-  Info("VD |z|<2", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
+  Info("VD |z|<1", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
+  Info("VD |z|<1", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZ->cd(3);
-  nt->Draw("dx:dz>>h_dx_vs_dz_ML(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 36 && id < 106", "colz");
+  nt->Draw("dx:dz>>h_dx_vs_dz_ML(600, -0.03, 0.03, 600, -0.03, 0.03)", "id >= 12 && id < 5132", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowMLOT);
   h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_ML");
   Info("ML", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("ML", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZ->cd(4);
-  nt->Draw("dx:dz>>h_dx_vs_dz_ML_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 36 && id < 106 && abs(z)<2", "colz");
+  nt->Draw("dx:dz>>h_dx_vs_dz_ML_z(600, -0.03, 0.03, 600, -0.03, 0.03)", "id >= 12 && id < 5132 && abs(z)<2", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowMLOT);
   h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_ML_z");
   Info("ML |z|<2", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("ML |z|<2", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZ->SaveAs("trkdigits_dx_vs_dz.pdf");
   canvdXdZ->cd(5);
-  nt->Draw("dx:dz>>h_dx_vs_dz_OT(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 106", "colz");
+  nt->Draw("dx:dz>>h_dx_vs_dz_OT(600, -0.03, 0.03, 600, -0.03, 0.03)", "id >= 5132", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowMLOT);
   h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_OT");
   Info("OT", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("OT", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZ->cd(6);
-  nt->Draw("dx:dz>>h_dx_vs_dz_OT_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 106 && abs(z)<2", "colz");
+  nt->Draw("dx:dz>>h_dx_vs_dz_OT_z(600, -0.03, 0.03, 600, -0.03, 0.03)", "id >= 5132 && abs(z)<2", "colz");
   h = (TH2F*)gPad->GetPrimitive("h_dx_vs_dz_OT_z");
+  addTLines(o2::trk::SegmentationChip::PitchRowMLOT);
   Info("OT |z|<2", "RMS(dx)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("OT |z|<2", "RMS(dz)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZ->SaveAs("trkdigits_dx_vs_dz.pdf");
+  canvdXdZ->SaveAs("trkdigits_dx_vs_dz.root");
 
   // distribution of differences between hit start and hit end in local coordinates
   auto canvdXdZHit = new TCanvas("canvdXdZHit", "", 1600, 2400);
   canvdXdZHit->Divide(2, 3);
   canvdXdZHit->cd(1);
-  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_VD(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 36", "colz");
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_VD(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 12", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowVD);
   LOG(info) << "dxH, dzH";
   h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_VD");
   Info("VD", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("VD", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZHit->cd(2);
-  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_VD_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 36 && abs(z)<2", "colz");
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_VD_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id < 12 && abs(z)<2", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowVD);
   h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_VD_z");
   Info("VD |z|<2", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("VD |z|<2", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZHit->cd(3);
-  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_ML(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 36 && id < 106", "colz");
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_ML(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 12 && id < 5132", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowMLOT);
   h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_ML");
   Info("ML", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("ML", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZHit->cd(4);
-  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_ML_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 36 && id < 106 && abs(z)<2", "colz");
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_ML_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 12 && id < 5132 && abs(z)<2", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowMLOT);
   h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_ML_z");
   Info("ML |z|<2", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("ML |z|<2", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZHit->SaveAs("trkdigits_dxH_vs_dzH.pdf");
   canvdXdZHit->cd(5);
-  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_OT(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 106", "colz");
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_OT(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 5132", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowMLOT);
   h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_OT");
   Info("OT", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("OT", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);
   canvdXdZHit->cd(6);
-  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_OT_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 106 && abs(z)<2", "colz");
+  nt2->Draw("dxH:dzH>>h_dxH_vs_dzH_OT_z(300, -0.03, 0.03, 300, -0.03, 0.03)", "id >= 5132 && abs(z)<2", "colz");
+  addTLines(o2::trk::SegmentationChip::PitchRowMLOT);
   h = (TH2F*)gPad->GetPrimitive("h_dxH_vs_dzH_OT_z");
   Info("OT |z|<2", "RMS(dxH)=%.1f mu", h->GetRMS(2) * 1e4);
   Info("OT |z|<2", "RMS(dzH)=%.1f mu", h->GetRMS(1) * 1e4);

From b461fc2e20f45aa66adf0de69aaa6adf45adc3ed Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 9 Mar 2026 22:12:55 +0100
Subject: [PATCH 1400/1764] ITS: fix zero field seeding

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu | 5 +++--
 Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx       | 5 +++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index eacf514c7a91d..353464e10712d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -143,8 +143,9 @@ GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
 
   float snp, q2pt, q2pt2;
   if (o2::gpu::CAMath::Abs(bz) < 0.01f) {
-    const float tgp = o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
-    snp = sign * tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
+    const float dx = x3 - x1;
+    const float dy = y3 - y1;
+    snp = sign * dy / o2::gpu::CAMath::Hypot(dx, dy);
     q2pt = sign / track::kMostProbablePt;
     q2pt2 = 1.f;
   } else {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index b4ac847863d51..d46db96339495 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -1278,8 +1278,9 @@ track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster
 
   float snp, q2pt, q2pt2;
   if (mIsZeroField) {
-    const float tgp = o2::gpu::CAMath::ATan2(y3 - y1, x3 - x1);
-    snp = sign * tgp / o2::gpu::CAMath::Sqrt(1.f + tgp * tgp);
+    const float dx = x3 - x1;
+    const float dy = y3 - y1;
+    snp = sign * dy / o2::gpu::CAMath::Hypot(dx, dy);
     q2pt = sign / track::kMostProbablePt;
     q2pt2 = 1.f;
   } else {

From 0b3869219ddb9b0caa8d7ae6ec93586353439e9d Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Fri, 6 Mar 2026 08:08:39 +0100
Subject: [PATCH 1401/1764] CAD->TGeo: Add first support for material mapping

The present commit adds support to complement
the geometry created from CAD STEP files with materials.

For now the script can process materials in a CSV
file, where each line maps the CAD part name to a material string.

An example is this
```
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
CAD,Mechanical/Part,ST1782525_01,AA.04,FIRST PART,1.51881,St. Steel EN 1.4306 (304L)
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
CAD,Mechanical/Part,ST2487461_01,AA.04,SECOND PART,2.344,Alu EN AW-5083 (H116)
,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
CAD,Mechanical/Part,ST2487721_01,AA.02,THIRD PART,0.313133,Carbon Fiber
```
where `ST2487721_01` are the part names referenced in the STEP file.

The conversion script will read the material names (e.g., Alu EN AW-5083 (H116))
and attempt a mapping to known materials in the Geant4 NIST database of materials
based on string matching as well as material density.

The user should check the emitted materials in the resulting geometry
file (geom.C) and possibly edit/correct the code. Another possibility
would be to fix the CSV file from the start and only reference Geant4 NIST
names.

The commit also contains a small utility to extract a JSON G4 NIST database
from the Geant4 engine. The resulting JSON file `G4_NIST_DB.json` is also
part of the commit and can be extended by the user with further definitions.

A complete conversion example, including materials would like this:
```bash
python3 O2_CADtoTGeo.py STEPFILE.stp --mesh [--mesh-prec 1.2]    \
         --out-path tgeo_geometry_output_folder -o geom.C        \
	 --materials-csv MATERIALS.csv                           \
	 --g4-nist-json G4_NIST_DB.json
```

Code generated with help of a code assistent.
---
 scripts/geometry/O2_CADtoTGeo.py              |  785 +-
 .../geometry/g4_nist_database/G4_NIST_DB.json | 7160 +++++++++++++++++
 scripts/geometry/g4_nist_database/compile.sh  |   11 +
 .../g4_nist_database/nist_export_all.cxx      |  136 +
 scripts/geometry/simulating_CAD_modules.md    |   12 +-
 5 files changed, 8080 insertions(+), 24 deletions(-)
 create mode 100644 scripts/geometry/g4_nist_database/G4_NIST_DB.json
 create mode 100755 scripts/geometry/g4_nist_database/compile.sh
 create mode 100644 scripts/geometry/g4_nist_database/nist_export_all.cxx

diff --git a/scripts/geometry/O2_CADtoTGeo.py b/scripts/geometry/O2_CADtoTGeo.py
index d564cdc6124a8..3de2fd75973df 100644
--- a/scripts/geometry/O2_CADtoTGeo.py
+++ b/scripts/geometry/O2_CADtoTGeo.py
@@ -4,6 +4,14 @@
 For now, all CAD solids are simply meshed. The ROOT geometry is build as a C++ ROOT macro
 and facet data is stored in binary form to keep disc space minimal.
 
+NEW (03/2026):
+  - Optional material/medium emission from a BOM (bill of materials) CSV file.
+    The CSV is expected to contain lines like:
+      CAD, Mechanical/Part, <PartNumber>, <Rev>, <Name>, <Mass>, <Material>, ...
+  - If both a part mass and a CAD volume are available, an effective density is computed
+    and used in the emitted TGeoMaterial. Otherwise a reasonable default density is used
+    for a few common materials, or 1.0 g/cm^3 as fallback.
+
 Generates (into --output-folder):
   - geom.C (small ROOT macro)
   - facets_<VOLNAME>_<LID>.bin for each leaf logical volume (float32 triangles)
@@ -28,15 +36,21 @@
 
 Author:
   - Sandro Wenzel, CERN (02/2026)
+  - Material/BOM integration patch (03/2026)
 """
 
 import warnings
 warnings.filterwarnings("ignore", message=".*all to deprecated function.*", category=DeprecationWarning)
 
 import argparse
+import csv
+import json
+import math
 import re
 import struct
+from dataclasses import dataclass
 from pathlib import Path as _Path
+from typing import Dict, List, Optional, Tuple
 
 from OCC.Core.Bnd import Bnd_Box
 from OCC.Core.BRepBndLib import brepbndlib
@@ -55,6 +69,14 @@
 from OCC.Core.TCollection import TCollection_AsciiString
 from OCC.Core.gp import gp_Trsf
 
+# volume properties for density calcs (may not be present in older pythonOCC builds)
+try:
+    from OCC.Core.GProp import GProp_GProps
+    from OCC.Core.BRepGProp import brepgprop_VolumeProperties
+    _HAS_VOLPROPS = True
+except Exception:
+    _HAS_VOLPROPS = False
+
 
 # -------------------------------
 # STEP/XCAF loading
@@ -221,6 +243,30 @@ def triangulate_CAD_solid(my_solid, meshparam, scale_to_cm: float = 1.0):
     return _scale_triangles(triangles, scale_to_cm)
 
 
+# -------------------------------
+# Volume helpers (for density)
+# -------------------------------
+
+def volume_cm3_of_shape(shape, scale_to_cm: float) -> float:
+    """Compute CAD solid volume in cm^3 (using STEP->cm scale)."""
+    if _HAS_VOLPROPS:
+        try:
+            props = GProp_GProps()
+            brepgprop_VolumeProperties(shape, props)
+            # volume returned in STEP length units^3
+            v = float(props.Mass())
+            return v * (scale_to_cm ** 3)
+        except Exception:
+            pass
+
+    # Fallback: bounding-box volume (rough but always defined)
+    box = Bnd_Box()
+    brepbndlib.Add(shape, box)
+    xmin, ymin, zmin, xmax, ymax, zmax = box.Get()
+    dx, dy, dz = (xmax - xmin) * scale_to_cm, (ymax - ymin) * scale_to_cm, (zmax - zmin) * scale_to_cm
+    return max(dx, 0.0) * max(dy, 0.0) * max(dz, 0.0)
+
+
 # -------------------------------
 # Naming helpers
 # -------------------------------
@@ -256,6 +302,472 @@ def write_facets_bin(path: _Path, triangles):
             ))
 
 
+# -------------------------------
+# BOM / material mapping
+# -------------------------------
+
+@dataclass(frozen=True)
+class BomEntry:
+    part_number: str
+    revision: str
+    name: str
+    mass_value: float  # as in CSV
+    material: str
+
+    @property
+    def part_number_key(self) -> str:
+        return (self.part_number or "").strip()
+
+    @property
+    def name_key(self) -> str:
+        return (self.name or "").strip()
+
+
+def _to_float(s: str) -> Optional[float]:
+    try:
+        if s is None:
+            return None
+        s = str(s).strip()
+        if not s:
+            return None
+        return float(s)
+    except Exception:
+        return None
+
+
+def read_bom_csv(csv_path: str) -> List[BomEntry]:
+    """
+    Reads a BOM CSV in the format provided by design team.
+
+    We look for rows whose first column is 'CAD' and second is 'Mechanical/Part'.
+    Columns (0-based):
+      0 CAD
+      1 type
+      2 part number
+      3 revision
+      4 name/description
+      5 mass
+      6 material
+    """
+    entries: List[BomEntry] = []
+    with open(csv_path, newline="", encoding="utf-8", errors="ignore") as f:
+        reader = csv.reader(f)
+        for row in reader:
+            if not row:
+                continue
+            if len(row) < 7:
+                continue
+            if row[0].strip() != "CAD":
+                continue
+            if row[1].strip() != "Mechanical/Part":
+                continue
+
+            part_no = (row[2] or "").strip()
+            rev = (row[3] or "").strip()
+            name = (row[4] or "").strip()
+            mass = _to_float(row[5])
+            mat = (row[6] or "").strip()
+
+            if not (part_no or name):
+                continue
+            if mass is None:
+                mass = float("nan")
+            if not mat:
+                mat = "Default"
+
+            entries.append(BomEntry(part_no, rev, name, float(mass), mat))
+    return entries
+
+
+
+def normalize_material_name(mat: str) -> str:
+    """
+    Normalizes a BOM material string for matching / caching.
+
+    Note: We keep the *original* string for ROOT object names; this is only used
+    internally for robust matching and dictionary keys.
+    """
+    mat = (mat or "Default").strip()
+    mat = re.sub(r"\s+", " ", mat)
+    return mat
+
+
+def _norm_tokens(s: str) -> List[str]:
+    s = (s or "").lower()
+    # common grade/format noise
+    s = re.sub(r"\(.*?\)", " ", s)
+    s = s.replace("en aw", " ")
+    s = s.replace("en-aw", " ")
+    s = s.replace("en", " ")
+    s = s.replace("aw", " ")
+    s = s.replace("_", " ").replace("-", " ")
+    s = re.sub(r"[^a-z0-9]+", " ", s)
+    s = re.sub(r"\s+", " ", s).strip()
+    if not s:
+        return []
+    toks = s.split(" ")
+
+    # small synonym normalization
+    syn = {
+        "alu": "al",
+        "aluminium": "aluminum",
+        "silicium": "silicon",
+        "inox": "stainless",
+        "ss": "stainless",
+        "cu": "copper",
+        "fe": "iron",
+        "ptfe": "teflon",
+        "ti": "titanium",
+        "be": "beryllium",
+    }
+
+    # Expand common element symbols to names and vice-versa so that e.g. "G4_Si" can match "silicon".
+    elem_alias = {
+        "h": "hydrogen", "he": "helium", "c": "carbon", "n": "nitrogen", "o": "oxygen",
+        "al": "aluminum", "si": "silicon", "fe": "iron", "cu": "copper", "be": "beryllium",
+        "mg": "magnesium", "mn": "manganese", "cr": "chromium", "ni": "nickel", "zn": "zinc",
+        "ti": "titanium", "w": "tungsten", "pb": "lead", "sn": "tin",
+    }
+    name_to_sym = {v: k for k, v in elem_alias.items()}
+
+    out: List[str] = []
+    for t in toks:
+        t2 = syn.get(t, t)
+        out.append(t2)
+        if t2 in elem_alias:
+            out.append(elem_alias[t2])
+        if t2 in name_to_sym:
+            out.append(name_to_sym[t2])
+
+    # de-dup while preserving order
+    seen = set()
+    out2: List[str] = []
+    for t in out:
+        if t and t not in seen:
+            seen.add(t)
+            out2.append(t)
+    return out2
+
+
+def _density_score(rho_part: Optional[float], rho_ref: Optional[float]) -> float:
+    if rho_part is None or rho_ref is None or not (rho_part > 0.0) or not (rho_ref > 0.0):
+        return 0.0
+    # symmetric score in log-space; 1.0 is perfect match
+    d = abs(math.log(rho_ref / rho_part))
+    return 1.0 / (1.0 + d)
+
+
+def _token_score(tokens_a: List[str], tokens_b: List[str]) -> float:
+    if not tokens_a or not tokens_b:
+        return 0.0
+    sa = set(tokens_a)
+    sb = set(tokens_b)
+    inter = len(sa & sb)
+    union = len(sa | sb)
+    if union == 0:
+        return 0.0
+    return inter / union
+
+
+def load_g4_nist_db(json_path: str) -> Dict[str, dict]:
+    """
+    Loads a JSON dump created by the 'nist_export_all' tool.
+    Returns a dict: nist_name -> material record.
+    """
+    with open(json_path, "r", encoding="utf-8") as f:
+        data = json.load(f)
+    mats = data.get("materials", {})
+    if not isinstance(mats, dict) or not mats:
+        raise RuntimeError(f"G4 NIST DB JSON seems empty or malformed: {json_path}")
+    return mats
+
+# Minimal periodic table for parsing custom alloys not present in NIST.
+# Values: Z (atomic number), A (g/mol)
+_ELEMENT_TABLE = {
+    "H": (1, 1.00794),
+    "C": (6, 12.0107),
+    "N": (7, 14.0067),
+    "O": (8, 15.9994),
+    "Al": (13, 26.9815385),
+    "Si": (14, 28.0855),
+    "Fe": (26, 55.845),
+    "Cu": (29, 63.546),
+    "Be": (4, 9.0121831),
+    "Mg": (12, 24.305),
+    "Mn": (25, 54.938044),
+    "Cr": (24, 51.9961),
+    "Ni": (28, 58.6934),
+    "Zn": (30, 65.38),
+    "Ti": (22, 47.867),
+    "W": (74, 183.84),
+    "Pb": (82, 207.2),
+    "Sn": (50, 118.71),
+}
+
+
+@dataclass
+class ResolvedMaterial:
+    bom_name: str
+    nist_name: Optional[str]          # e.g. "G4_Al"
+    score: float
+    rho_used_g_cm3: Optional[float]   # density used in ROOT definition
+    radlen_cm: Optional[float]
+    intlen_cm: Optional[float]
+    elements: Optional[List[dict]]    # list of {symbol,Z,A_g_mol,mass_fraction}
+    note: str                         # for comments in geom.C (warnings/FIXME)
+
+@dataclass
+class MatMatchConfig:
+    # Minimum combined score to accept a match.
+    min_score: float = 0.35
+    # If (best - second_best) < ambiguity_delta, treat as ambiguous/unresolved.
+    ambiguity_delta: float = 0.05
+    # Weights for the combined score = w_token * token_score + w_density * density_score
+    w_token: float = 0.75
+    w_density: float = 0.25
+    # Optional hard filter on density proximity (in log-space). If <=0, disabled.
+    # Example: max_log_density_diff=0.8 means accept within exp(0.8)~2.2x in either direction.
+    max_log_density_diff: float = 0.0
+    # Penalize compound matches (oxide/dioxide/carbide/...) when BOM doesn't mention those tokens.
+    compound_penalty: float = 0.25
+
+
+def resolve_bom_material(
+    bom_material: str,
+    rho_part_g_cm3: Optional[float],
+    g4db: Optional[Dict[str, dict]],
+    cfg: MatMatchConfig,
+) -> ResolvedMaterial:
+    """
+    Resolves an arbitrary BOM material string to a Geant4 NIST material name using:
+      - exact key match (BOM already uses e.g. "G4_Al")
+      - token overlap scoring on names
+      - density proximity scoring (if rho_part_g_cm3 available)
+
+    If unresolved/ambiguous, tries to parse element symbols from the BOM string (e.g. "Cu Be")
+    and emits a placeholder mixture (equal mass fractions) annotated with FIXME.
+    """
+    raw_bom_material = (bom_material or "").strip()
+    bom_material = normalize_material_name(bom_material)
+
+    if not g4db:
+        return ResolvedMaterial(
+            bom_name=bom_material,
+            nist_name=None,
+            score=0.0,
+            rho_used_g_cm3=rho_part_g_cm3,
+            radlen_cm=None,
+            intlen_cm=None,
+            elements=None,
+            note="FIXME: No Geant4 NIST DB provided; using dummy material.",
+        )
+
+    # Trivial: BOM already provides an exact Geant4 material key
+    if bom_material in g4db:
+        rec = g4db[bom_material]
+        rho_ref = rec.get("density_g_cm3")
+        # Use NIST density for emission; CAD-derived density is used only for matching.
+        rho_used = rho_ref
+
+        rad = rec.get("radlen_cm")
+        itl = rec.get("intlen_cm")
+
+        return ResolvedMaterial(
+            bom_name=bom_material,
+            nist_name=bom_material,
+            score=1.0,
+            rho_used_g_cm3=rho_used,
+            radlen_cm=rad,
+            intlen_cm=itl,
+            elements=rec.get("elements", []),
+            note="Resolved by exact Geant4 NIST name from BOM.",
+        )
+
+    bom_toks = _norm_tokens(bom_material)
+    if not bom_toks:
+        return ResolvedMaterial(
+            bom_name=bom_material,
+            nist_name=None,
+            score=0.0,
+            rho_used_g_cm3=rho_part_g_cm3,
+            radlen_cm=None,
+            intlen_cm=None,
+            elements=None,
+            note="FIXME: Empty/unknown BOM material string; using dummy material.",
+        )
+
+    def _build_custom_from_elements(note_prefix: str) -> Optional[ResolvedMaterial]:
+        s = raw_bom_material
+        if not s:
+            return None
+
+        symbols = set(re.findall(r"\b([A-Z][a-z]?)\b", s))
+        name_to_symbol = {
+            "aluminum": "Al", "aluminium": "Al", "silicon": "Si", "iron": "Fe", "copper": "Cu",
+            "beryllium": "Be", "magnesium": "Mg", "manganese": "Mn", "chromium": "Cr", "nickel": "Ni",
+            "zinc": "Zn", "titanium": "Ti", "tungsten": "W", "lead": "Pb", "tin": "Sn",
+        }
+        for t in bom_toks:
+            if t in name_to_symbol:
+                symbols.add(name_to_symbol[t])
+
+        symbols = [sym for sym in sorted(symbols) if sym in _ELEMENT_TABLE]
+        if not symbols:
+            return None
+
+        frac = 1.0 / float(len(symbols))
+        elems: List[dict] = []
+        for sym in symbols:
+            Z, A = _ELEMENT_TABLE[sym]
+            elems.append({"symbol": sym, "Z": Z, "A_g_mol": A, "mass_fraction": frac})
+
+        return ResolvedMaterial(
+            bom_name=bom_material,
+            nist_name=None,
+            score=0.0,
+            rho_used_g_cm3=rho_part_g_cm3,
+            radlen_cm=None,
+            intlen_cm=None,
+            elements=elems,
+            note=f"FIXME: {note_prefix} No suitable Geant4 NIST material. Emitting placeholder mixture from parsed elements {symbols} with equal mass fractions; please adjust fractions/material.",
+        )
+
+    best = (None, -1.0, 0.0, 0.0)   # (nist_name, score, dens_score, token_score)
+    second = (None, -1.0, 0.0, 0.0)
+
+    bom_has_compound = any(t in bom_toks for t in (
+        "oxide", "dioxide", "carbide", "nitride", "fluoride", "chloride",
+        "sulfate", "phosphate", "glass", "dioxyde"
+    ))
+
+    for nist_name, rec in g4db.items():
+        nist_toks = _norm_tokens(nist_name)
+        ts = _token_score(bom_toks, nist_toks)
+        if ts <= 0.0:
+            continue
+
+        ds = _density_score(rho_part_g_cm3, rec.get("density_g_cm3"))
+
+        # Optional hard density filter
+        if cfg.max_log_density_diff and cfg.max_log_density_diff > 0.0 and rho_part_g_cm3 and rec.get("density_g_cm3"):
+            try:
+                if abs(math.log(float(rec.get("density_g_cm3")) / float(rho_part_g_cm3))) > cfg.max_log_density_diff:
+                    continue
+            except Exception:
+                pass
+
+        nist_has_compound = any(t in nist_toks for t in (
+            "oxide", "dioxide", "carbide", "nitride", "fluoride", "chloride",
+            "sulfate", "phosphate", "glass", "dioxyde"
+        ))
+        compound_pen = cfg.compound_penalty if (nist_has_compound and not bom_has_compound) else 0.0
+
+        score = cfg.w_token * ts + cfg.w_density * ds - compound_pen
+
+        if score > best[1]:
+            second = best
+            best = (nist_name, score, ds, ts)
+        elif score > second[1]:
+            second = (nist_name, score, ds, ts)
+
+    nist_best, score_best, ds_best, ts_best = best
+    nist_second, score_second, _, _ = second
+
+    if nist_best is None or score_best < cfg.min_score:
+        custom = _build_custom_from_elements("Could not resolve with enough confidence.")
+        if custom is not None:
+            return custom
+        return ResolvedMaterial(
+            bom_name=bom_material,
+            nist_name=None,
+            score=float(score_best if score_best > 0 else 0.0),
+            rho_used_g_cm3=rho_part_g_cm3,
+            radlen_cm=None,
+            intlen_cm=None,
+            elements=None,
+            note="FIXME: Could not resolve BOM material to a Geant4 NIST material with enough confidence; using dummy material.",
+        )
+
+    if score_second > 0 and (score_best - score_second) < cfg.ambiguity_delta:
+        custom = _build_custom_from_elements(
+            f"Ambiguous material match (best '{nist_best}' score={score_best:.3f}, second '{nist_second}' score={score_second:.3f})."
+        )
+        if custom is not None:
+            return custom
+        return ResolvedMaterial(
+            bom_name=bom_material,
+            nist_name=None,
+            score=float(score_best),
+            rho_used_g_cm3=rho_part_g_cm3,
+            radlen_cm=None,
+            intlen_cm=None,
+            elements=None,
+            note=f"FIXME: Ambiguous material match (best '{nist_best}' score={score_best:.3f}, second '{nist_second}' score={score_second:.3f}); using dummy material.",
+        )
+
+    rec = g4db[nist_best]
+    rho_ref = rec.get("density_g_cm3")
+    # Use NIST density for emission; CAD-derived density is used only for matching.
+    rho_used = rho_ref
+
+    rad = rec.get("radlen_cm")
+    itl = rec.get("intlen_cm")
+
+    return ResolvedMaterial(
+        bom_name=bom_material,
+        nist_name=nist_best,
+        score=float(score_best),
+        rho_used_g_cm3=rho_used,
+        radlen_cm=rad,
+        intlen_cm=itl,
+        elements=rec.get("elements", []),
+        note=f"Resolved to '{nist_best}' (token={ts_best:.3f}, density={ds_best:.3f}, score={score_best:.3f}).",
+    )
+
+
+def build_volume_to_material_map(
+    bom_entries: List[BomEntry],
+    def_names: Dict[str, str],
+) -> Dict[str, BomEntry]:
+    """
+    Builds a mapping def_lid -> BomEntry by matching the XCAF display name to:
+      - exact part_number match
+      - exact description/name match
+      - substring match on part_number within the XCAF name
+
+    This is heuristic; if nothing matches we keep no assignment for that volume.
+    """
+    # lookup tables
+    by_part: Dict[str, BomEntry] = {}
+    by_name: Dict[str, BomEntry] = {}
+    for e in bom_entries:
+        if e.part_number_key:
+            by_part[e.part_number_key] = e
+        if e.name_key and e.name_key not in by_name:
+            by_name[e.name_key] = e
+
+    out: Dict[str, BomEntry] = {}
+    for lid, disp in def_names.items():
+        key = (disp or "").strip()
+        if not key:
+            continue
+
+        # 1) exact part number
+        if key in by_part:
+            out[lid] = by_part[key]
+            continue
+        # 2) exact name/description
+        if key in by_name:
+            out[lid] = by_name[key]
+            continue
+        # 3) substring match on any part number
+        for pn, e in by_part.items():
+            if pn and pn in key:
+                out[lid] = e
+                break
+    return out
+
+
 # -------------------------------
 # C++ emission helpers
 # -------------------------------
@@ -306,27 +818,100 @@ def emit_cpp_prelude() -> str:
 """
 
 
-def emit_materials_cpp() -> str:
-    return """  // Default material/medium (placeholder; can be replaced later)
-  TGeoMaterial *mat_Default = new TGeoMaterial("Default", 0., 0., 0.);
-  TGeoMedium   *med_Default = new TGeoMedium("Default", 1, mat_Default);
-"""
+def emit_materials_cpp(
+    used_materials: Dict[str, ResolvedMaterial],
+    # key: BOM material string as used in CSV after normalization
+) -> Tuple[str, Dict[str, str]]:
+    """
+    Emits C++ code defining TGeoMaterial/TGeoMixture + TGeoMedium for all used materials.
+
+    - If a material resolved to a Geant4 NIST entry, emit a physically correct mixture
+      (element mass fractions) and set RadLen/IntLen (from Geant4) when available.
+    - If unresolved/ambiguous, emit a dummy material and annotate with FIXME comments.
+    """
+    cpp: List[str] = []
+    cpp.append("  // Default material/medium (placeholder; can be replaced later)")
+    cpp.append("  TGeoMaterial *mat_Default = new TGeoMaterial(\"Default\", 0., 0., 0.);")
+    cpp.append("  TGeoMedium   *med_Default = new TGeoMedium(\"Default\", 1, mat_Default);")
+    cpp.append("")
+
+    emitted_el: Dict[str, str] = {}
+
+    def _emit_element(el: dict) -> str:
+        sym = el.get("symbol", "X")
+        Z = int(el.get("Z", 0))
+        A = float(el.get("A_g_mol", 0.0))
+        if sym in emitted_el:
+            return emitted_el[sym]
+        safe = sanitize_cpp_name(sym)
+        var = f"el_{safe}"
+        cpp.append(f"  TGeoElement *{var} = new TGeoElement(\"{sym}\", \"{sym}\", {Z}, {A:.10g});")
+        emitted_el[sym] = var
+        return var
+
+    medium_var: Dict[str, str] = {"Default": "med_Default"}
+    next_id = 2
+
+    for bom_mat in sorted(used_materials.keys(), key=lambda s: s.lower()):
+        rm = used_materials[bom_mat]
+        safe = sanitize_cpp_name(bom_mat)
+        base = safe
+        k = 2
+        while f"med_{safe}" in medium_var.values():
+            safe = f"{base}_{k}"
+            k += 1
+
+        rho = rm.rho_used_g_cm3 if (rm.rho_used_g_cm3 and rm.rho_used_g_cm3 > 0.0) else 0.0
+
+        cpp.append(f"  // BOM material: {rm.bom_name}")
+        cpp.append(f"  // {rm.note}")
+
+        if rm.elements:
+            elems = rm.elements
+            if len(elems) == 1 and abs(float(elems[0].get('mass_fraction', 1.0)) - 1.0) < 1e-6:
+                el = elems[0]
+                A = float(el.get("A_g_mol", 0.0))
+                Z = float(el.get("Z", 0))
+                cpp.append(f"  TGeoMaterial *mat_{safe} = new TGeoMaterial(\"{bom_mat}\", {A:.10g}, {Z:.10g}, {rho:.10g});")
+            else:
+                cpp.append(f"  TGeoMixture  *mat_{safe} = new TGeoMixture(\"{bom_mat}\", {len(elems)}, {rho:.10g});")
+                for el in elems:
+                    elvar = _emit_element(el)
+                    w = float(el.get("mass_fraction", 0.0))
+                    cpp.append(f"  mat_{safe}->AddElement({elvar}, {w:.10g});")
+
+            if rm.radlen_cm is not None and rm.intlen_cm is not None:
+                cpp.append(f"  mat_{safe}->SetRadLen({float(rm.radlen_cm):.10g}, {float(rm.intlen_cm):.10g});")
+            elif rm.radlen_cm is not None:
+                cpp.append(f"  mat_{safe}->SetRadLen({float(rm.radlen_cm):.10g});")
+        else:
+            cpp.append("  // FIXME: Unresolved material. Replace with a proper TGeoMaterial/TGeoMixture.")
+            cpp.append(f"  TGeoMaterial *mat_{safe} = new TGeoMaterial(\"{bom_mat}\", 0., 0., {rho:.10g});")
+
+        cpp.append(f"  TGeoMedium   *med_{safe} = new TGeoMedium(\"{bom_mat}\", {next_id}, mat_{safe});")
+        cpp.append("")
+        medium_var[bom_mat] = f"med_{safe}"
+        next_id += 1
+
+    return "\n".join(cpp), medium_var
+
+
 
 
-def emit_tessellated_cpp(lid: str, vol_display_name: str, facet_abspath: str, ntriangles: int) -> str:
+def emit_tessellated_cpp(lid: str, vol_display_name: str, facet_abspath: str, ntriangles: int, medium_var: str) -> str:
     safe = sanitize_cpp_name(lid)
     shape_name = vol_display_name if vol_display_name else lid
 
     if ntriangles <= 0:
         out = []
         out.append(f'  TGeoBBox *solid_{safe} = new TGeoBBox("{shape_name}", 0.001, 0.001, 0.001);')
-        out.append(f'  TGeoVolume *vol_{safe} = new TGeoVolume("{shape_name}", solid_{safe}, med_Default);')
+        out.append(f'  TGeoVolume *vol_{safe} = new TGeoVolume("{shape_name}", solid_{safe}, {medium_var});')
         return "\n".join(out)
 
     out = []
     out.append(f'  TGeoTessellated *solid_{safe} = new TGeoTessellated("{shape_name}", {ntriangles});')
     out.append(f'  LoadFacets("{facet_abspath}", solid_{safe}, check);')
-    out.append(f'  TGeoVolume *vol_{safe} = new TGeoVolume("{shape_name}", solid_{safe}, med_Default);')
+    out.append(f'  TGeoVolume *vol_{safe} = new TGeoVolume("{shape_name}", solid_{safe}, {medium_var});')
     return "\n".join(out)
 
 
@@ -340,12 +925,13 @@ def emit_assembly_cpp(lid: str, asm_display_name: str) -> str:
 # Definition graph extraction
 # -------------------------------
 
-logical_volumes = {}     # def_lid -> triangles
-def_names = {}           # def_lid -> human display name (may be "")
-assemblies = set()       # def_lid
-placements = []          # (parent_def_lid, child_def_lid, gp_Trsf local)
-top_defs = set()         # top definition lids
-visited_defs = set()     # expanded defs
+logical_volumes: Dict[str, list] = {}     # def_lid -> triangles
+def_names: Dict[str, str] = {}           # def_lid -> human display name (may be "")
+def_volumes_cm3: Dict[str, float] = {}   # def_lid -> volume in cm^3 (leaf only)
+assemblies = set()                       # def_lid
+placements = []                          # (parent_def_lid, child_def_lid, gp_Trsf local)
+top_defs = set()                         # top definition lids
+visited_defs = set()                     # expanded defs
 
 
 def cpp_var_for_def(lid: str) -> str:
@@ -393,6 +979,13 @@ def expand_definition(def_label: TDF_Label, shape_tool, meshparam=None, scale_to
     if shape_tool.IsSimpleShape(def_label):
         if def_lid not in logical_volumes:
             shape = shape_tool.GetShape(def_label)
+
+            # store volume (for density estimation)
+            try:
+                def_volumes_cm3[def_lid] = volume_cm3_of_shape(shape, scale_to_cm=scale_to_cm)
+            except Exception:
+                def_volumes_cm3[def_lid] = 0.0
+
             do_meshing = (meshparam is not None) and meshparam.get("do_meshing", None) is True
             logical_volumes[def_lid] = triangulate_CAD_solid(shape, meshparam=meshparam, scale_to_cm=scale_to_cm) if do_meshing else triangulate_asbbox(shape, scale_to_cm=scale_to_cm)
         return
@@ -401,9 +994,10 @@ def expand_definition(def_label: TDF_Label, shape_tool, meshparam=None, scale_to
 
 
 def extract_graph(step_path: str, meshparam=None, scale_to_cm: float = 1.0):
-    global logical_volumes, def_names, assemblies, placements, top_defs, visited_defs
+    global logical_volumes, def_names, def_volumes_cm3, assemblies, placements, top_defs, visited_defs
     logical_volumes = {}
     def_names = {}
+    def_volumes_cm3 = {}
     assemblies = set()
     placements = []
     top_defs = set()
@@ -439,7 +1033,52 @@ def emit_placement_cpp(parent_def: str, child_def: str, trsf: gp_Trsf, copy_no:
     return trsf_to_tgeo(trsf, tr_name, scale_to_cm) + f"  {parent_cpp}->AddNode({child_cpp}, {copy_no}, {tr_name});\n"
 
 
-def emit_root_macro(step_path: str, out_folder: _Path, meshparam=None, step_unit: str = "auto"):
+
+def _compute_density_g_cm3(
+    volume_cm3: float,
+    mass_value: float,
+    mass_unit: str,
+) -> Tuple[Optional[float], str]:
+    """
+    Computes an effective part density from (mass, CAD volume).
+
+    Returns (rho_g_cm3 or None, comment). If rho is None, caller should fall back
+    to the Geant4 NIST density (if resolved) or to a dummy density.
+    """
+    if not volume_cm3 or volume_cm3 <= 0:
+        return None, "no CAD volume available for density"
+
+    if (mass_value is None) or (isinstance(mass_value, float) and math.isnan(mass_value)):
+        return None, "no BOM mass available for density"
+
+    mass_g = float(mass_value)
+    mu = (mass_unit or "kg").lower()
+    if mu == "kg":
+        mass_g *= 1000.0
+    elif mu == "g":
+        pass
+    else:
+        # unknown unit: assume kg
+        mass_g *= 1000.0
+
+    rho = mass_g / float(volume_cm3)
+    # Guard against obvious unit/volume issues
+    if not (0.01 < rho < 50.0):
+        return None, f"computed density {rho:.3g} g/cm3 rejected (unit mismatch?)"
+
+    return rho, "density from BOM mass and CAD volume"
+
+
+def emit_root_macro(
+    step_path: str,
+    out_folder: _Path,
+    meshparam=None,
+    step_unit: str = "auto",
+    materials_csv: Optional[str] = None,
+    bom_mass_unit: str = "kg",
+    g4_nist_json: Optional[str] = None,
+    mat_cfg: Optional[MatMatchConfig] = None,
+):
     if (step_unit or "auto").lower() == "auto":
         detected = detect_step_length_unit(step_path)
         scale_to_cm = step_unit_scale_to_cm(detected)
@@ -453,6 +1092,28 @@ def emit_root_macro(step_path: str, out_folder: _Path, meshparam=None, step_unit
     out_folder = out_folder.expanduser().resolve()
     out_folder.mkdir(parents=True, exist_ok=True)
 
+
+    # --- Geant4 NIST material DB (optional but recommended) ---
+    g4db: Optional[Dict[str, dict]] = None
+    if g4_nist_json:
+        g4db = load_g4_nist_db(g4_nist_json)
+        print(f"Loaded Geant4 NIST DB with {len(g4db)} materials from: {g4_nist_json}")
+    else:
+        print("No --g4-nist-json provided: unresolved materials will fall back to dummy ROOT materials.")
+    mat_cfg = mat_cfg or MatMatchConfig()
+
+
+    # --- BOM: map volumes to materials (heuristic) ---
+    lid_to_bom: Dict[str, BomEntry] = {}
+    if materials_csv:
+        bom_entries = read_bom_csv(materials_csv)
+        lid_to_bom = build_volume_to_material_map(bom_entries, def_names)
+        print(f"Loaded {len(bom_entries)} BOM entries from: {materials_csv}")
+        print(f"Matched {len(lid_to_bom)} CAD logical volumes to BOM entries (by name/part-number heuristics)")
+    else:
+        print("No --materials-csv provided: emitting Default medium for all logical volumes")
+
+    # --- facet files ---
     facet_files = {}  # def_lid -> absolute path string
     for lid, tris in logical_volumes.items():
         disp = def_names.get(lid, "")
@@ -463,16 +1124,63 @@ def emit_root_macro(step_path: str, out_folder: _Path, meshparam=None, step_unit
         write_facets_bin(fpath, tris)
         facet_files[lid] = str(fpath).replace("\\", "\\\\")  # C++ string literal safety
 
-    cpp = []
+    # --- which materials do we need to emit? ---
+    
+    # --- materials: collect unique BOM material strings actually used by leaf volumes ---
+    # We resolve each unique BOM string to a Geant4 NIST material using string + density scoring.
+    used_materials: Dict[str, ResolvedMaterial] = {}
+
+    # Precompute one representative part density per BOM material (first good value wins)
+    mat_to_rho: Dict[str, Optional[float]] = {}
+    mat_to_rho_note: Dict[str, str] = {}
+
+    for lid in logical_volumes.keys():
+        if lid not in lid_to_bom:
+            continue
+        bom = lid_to_bom[lid]
+        mat_name = normalize_material_name(bom.material)
+
+        if mat_name not in mat_to_rho:
+            rho_part, rho_note = _compute_density_g_cm3(
+                def_volumes_cm3.get(lid, 0.0),
+                bom.mass_value,
+                bom_mass_unit,
+            )
+            mat_to_rho[mat_name] = rho_part
+            mat_to_rho_note[mat_name] = rho_note
+
+    for mat_name in sorted(mat_to_rho.keys(), key=lambda s: s.lower()):
+        rho_part = mat_to_rho.get(mat_name)
+        rm = resolve_bom_material(mat_name, rho_part, g4db, mat_cfg)
+
+        # Fold density provenance into the note for geom.C comments
+        rm.note = f"{rm.note} (density: {mat_to_rho_note.get(mat_name, 'n/a')})"
+
+        if rm.nist_name is None:
+            print(f"WARNING: Unresolved/ambiguous material '{mat_name}'. See FIXME in generated geom.C.")
+
+        used_materials[mat_name] = rm
+
+    materials_cpp, medium_var_map = emit_materials_cpp(used_materials)
+
+    # --- emit C++ macro ---
+    cpp: List[str] = []
     cpp.append(emit_cpp_prelude())
 
     cpp.append("TGeoVolume* build(bool check=true) {")
     cpp.append('  if (!gGeoManager) { throw std::runtime_error("gGeoManager is null. Call build_and_export() or create a TGeoManager first."); }')
-    cpp.append(emit_materials_cpp())
+    cpp.append(materials_cpp)
 
     for lid in logical_volumes.keys():
         ntriangles = len(logical_volumes[lid])
-        cpp.append(emit_tessellated_cpp(lid, def_names.get(lid, ""), facet_files[lid], ntriangles))
+
+        # choose medium for this volume
+        med = "med_Default"
+        if lid in lid_to_bom:
+            mat_name = normalize_material_name(lid_to_bom[lid].material)
+            med = medium_var_map.get(mat_name, "med_Default")
+
+        cpp.append(emit_tessellated_cpp(lid, def_names.get(lid, ""), facet_files[lid], ntriangles, med))
 
     for lid in sorted(assemblies):
         cpp.append(emit_assembly_cpp(lid, def_names.get(lid, "")))
@@ -527,7 +1235,7 @@ def traverse_print(label, shape_tool, depth=0):
     indent = "  " * depth
     name = label.GetLabelName()
     entry = label_entry(label)
-    print(f"{indent}- {name}  =>[{entry}]")
+    print(f"{indent}- {name}  =>[{entry}]") 
 
     if shape_tool.IsReference(label):
         ref_label = TDF_Label()
@@ -569,7 +1277,21 @@ def main():
     ap.add_argument("--mesh", action="store_true", help="Use full BRepMesh triangulation instead of bounding boxes")
     ap.add_argument("--print-tree", action="store_true", help="Just prints the geometry tree")
     ap.add_argument("--mesh-prec", default=0.1, help="meshing precision. lower --> slower")
-    ap.add_argument("--step-unit", default="auto", choices=["auto", "mm", "cm", "m", "in", "ft"], help="STEP length unit override (default: auto-detect)")
+    ap.add_argument("--step-unit", default="auto", choices=["auto", "mm", "cm", "m", "in", "ft"], help="STEP length unit override (default: auto-detect); TGeo expects cm")
+
+    # NEW: BOM / material support
+    ap.add_argument("--materials-csv", default=None, help="BOM CSV file providing material + mass per part (optional)")
+    ap.add_argument("--bom-mass-unit", default="kg", choices=["kg", "g"], help="Unit of the BOM mass column (default: kg)")
+    ap.add_argument("--g4-nist-json", default=None, help="Path to Geant4 NIST DB JSON dump (from nist_export_all). Enables TGeoMixture emission + RadLen/IntLen.")
+
+
+    # Material matching scoring knobs (only used if --g4-nist-json is provided)
+    ap.add_argument("--mat-min-score", type=float, default=0.35, help="Minimum combined score to accept a G4 NIST material match (default: 0.35)")
+    ap.add_argument("--mat-ambiguity-delta", type=float, default=0.05, help="If best-second < delta, treat match as ambiguous/unresolved (default: 0.05)")
+    ap.add_argument("--mat-w-token", type=float, default=0.75, help="Weight for token/name similarity score (default: 0.75)")
+    ap.add_argument("--mat-w-density", type=float, default=0.25, help="Weight for density proximity score (default: 0.25)")
+    ap.add_argument("--mat-max-log-density-diff", type=float, default=0.0, help="Optional hard density filter in log-space (0 disables). Example 0.8 ~ within 2.2x (default: 0.0)")
+    ap.add_argument("--mat-compound-penalty", type=float, default=0.25, help="Penalty for matching to oxides/carbides/etc. when BOM doesn't mention them (default: 0.25)")
 
     args = ap.parse_args()
 
@@ -584,11 +1306,30 @@ def main():
 
     meshparam = {"do_meshing": args.mesh, "lin_defl": args.mesh_prec, "ang_defl": args.mesh_prec}
 
+
+    mat_cfg = MatMatchConfig(
+    min_score=args.mat_min_score,
+    ambiguity_delta=args.mat_ambiguity_delta,
+    w_token=args.mat_w_token,
+    w_density=args.mat_w_density,
+    max_log_density_diff=args.mat_max_log_density_diff,
+    compound_penalty=args.mat_compound_penalty,
+    )
+
     out_folder = out_folder.expanduser().resolve()
     out_folder.mkdir(parents=True, exist_ok=True)
 
     out_macro = (out_folder / _Path(args.out).name).resolve()
-    code = emit_root_macro(step_path, out_folder, meshparam=meshparam, step_unit=args.step_unit)
+    code = emit_root_macro(
+        step_path,
+        out_folder,
+        meshparam=meshparam,
+        step_unit=args.step_unit,
+        materials_csv=args.materials_csv,
+        bom_mass_unit=args.bom_mass_unit,
+        g4_nist_json=args.g4_nist_json,
+        mat_cfg=mat_cfg,
+    )
     out_macro.write_text(code)
 
     print(f"Wrote ROOT macro: {out_macro}")
diff --git a/scripts/geometry/g4_nist_database/G4_NIST_DB.json b/scripts/geometry/g4_nist_database/G4_NIST_DB.json
new file mode 100644
index 0000000000000..3489beb16bad3
--- /dev/null
+++ b/scripts/geometry/g4_nist_database/G4_NIST_DB.json
@@ -0,0 +1,7160 @@
+{
+  "schema": "g4_nist_export_v1",
+  "count_requested": 309,
+  "materials": {
+    "G4_1,2-DICHLOROBENZENE": {
+      "name": "G4_1,2-DICHLOROBENZENE",
+      "density_g_cm3": 1.3048000000,
+      "radlen_cm": 20.7489144362,
+      "intlen_cm": 69.0775200428,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4902297089
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0274267115
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.4823435796
+        }
+      ]
+    },
+    "G4_1,2-DICHLOROETHANE": {
+      "name": "G4_1,2-DICHLOROETHANE",
+      "density_g_cm3": 1.2351000000,
+      "radlen_cm": 18.6131823209,
+      "intlen_cm": 77.6700314494,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2427431829
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0407420059
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.7165148112
+        }
+      ]
+    },
+    "G4_A-150_TISSUE": {
+      "name": "G4_A-150_TISSUE",
+      "density_g_cm3": 1.1270000000,
+      "radlen_cm": 37.1439852154,
+      "intlen_cm": 63.7486912428,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1013268987
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7755002245
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0350569649
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0523159477
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.0174219826
+        },
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.0183779816
+        }
+      ]
+    },
+    "G4_ACETONE": {
+      "name": "G4_ACETONE",
+      "density_g_cm3": 0.7899000000,
+      "radlen_cm": 52.2534185395,
+      "intlen_cm": 91.4814595809,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6203973505
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1041274661
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2754751834
+        }
+      ]
+    },
+    "G4_ACETYLENE": {
+      "name": "G4_ACETYLENE",
+      "density_g_cm3": 0.0010967000,
+      "radlen_cm": 39930.0227629710,
+      "intlen_cm": 66449.2307704659,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9225773293
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0774226707
+        }
+      ]
+    },
+    "G4_ADENINE": {
+      "name": "G4_ADENINE",
+      "density_g_cm3": 1.3500000000,
+      "radlen_cm": 30.0581586935,
+      "intlen_cm": 58.0823779196,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4444232424
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0372959895
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.5182807681
+        }
+      ]
+    },
+    "G4_ADIPOSE_TISSUE_ICRP": {
+      "name": "G4_ADIPOSE_TISSUE_ICRP",
+      "density_g_cm3": 0.9500000000,
+      "radlen_cm": 43.3949297995,
+      "intlen_cm": 75.2919618730,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1140000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5980000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0070000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2780000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0010000000
+        }
+      ]
+    },
+    "G4_AIR": {
+      "name": "G4_AIR",
+      "density_g_cm3": 0.0012047900,
+      "radlen_cm": 30392.0700501740,
+      "intlen_cm": 71009.5012707064,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0001240001
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.7552677553
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2317812318
+        },
+        {
+          "symbol": "Ar",
+          "Z": 18,
+          "A_g_mol": 39.9476933511,
+          "mass_fraction": 0.0128270128
+        }
+      ]
+    },
+    "G4_ALANINE": {
+      "name": "G4_ALANINE",
+      "density_g_cm3": 1.4200000000,
+      "radlen_cm": 27.7725516260,
+      "intlen_cm": 53.1723594099,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4044321096
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0791931803
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1572145382
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3591601720
+        }
+      ]
+    },
+    "G4_ALUMINUM_OXIDE": {
+      "name": "G4_ALUMINUM_OXIDE",
+      "density_g_cm3": 3.9700000000,
+      "radlen_cm": 7.0377543639,
+      "intlen_cm": 24.2683456290,
+      "elements": [
+        {
+          "symbol": "Al",
+          "Z": 13,
+          "A_g_mol": 26.9815000000,
+          "mass_fraction": 0.5292504916
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4707495084
+        }
+      ]
+    },
+    "G4_AMBER": {
+      "name": "G4_AMBER",
+      "density_g_cm3": 1.1000000000,
+      "radlen_cm": 39.1372915409,
+      "intlen_cm": 64.6512140234,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1059301059
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7889737890
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1050961051
+        }
+      ]
+    },
+    "G4_AMMONIA": {
+      "name": "G4_AMMONIA",
+      "density_g_cm3": 0.0008260190,
+      "radlen_cm": 49481.0183957974,
+      "intlen_cm": 81682.0756970836,
+      "elements": [
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.8224476051
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1775523949
+        }
+      ]
+    },
+    "G4_ANILINE": {
+      "name": "G4_ANILINE",
+      "density_g_cm3": 1.0235000000,
+      "radlen_cm": 41.9603888047,
+      "intlen_cm": 71.8321544827,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7738313735
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0757632320
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1504053945
+        }
+      ]
+    },
+    "G4_ANTHRACENE": {
+      "name": "G4_ANTHRACENE",
+      "density_g_cm3": 1.2830000000,
+      "radlen_cm": 33.8977543296,
+      "intlen_cm": 58.2256880136,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9434470990
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0565529010
+        }
+      ]
+    },
+    "G4_Ac": {
+      "name": "G4_Ac",
+      "density_g_cm3": 10.0700000000,
+      "radlen_cm": 0.6015581907,
+      "intlen_cm": 21.2030538527,
+      "elements": [
+        {
+          "symbol": "Ac",
+          "Z": 89,
+          "A_g_mol": 227.0280000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ag": {
+      "name": "G4_Ag",
+      "density_g_cm3": 10.5000000000,
+      "radlen_cm": 0.8542919107,
+      "intlen_cm": 15.8675527542,
+      "elements": [
+        {
+          "symbol": "Ag",
+          "Z": 47,
+          "A_g_mol": 107.8682200000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Al": {
+      "name": "G4_Al",
+      "density_g_cm3": 2.6990000000,
+      "radlen_cm": 8.8963176127,
+      "intlen_cm": 38.8944132871,
+      "elements": [
+        {
+          "symbol": "Al",
+          "Z": 13,
+          "A_g_mol": 26.9815000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Am": {
+      "name": "G4_Am",
+      "density_g_cm3": 13.6700000000,
+      "radlen_cm": 0.4243095287,
+      "intlen_cm": 15.9785730103,
+      "elements": [
+        {
+          "symbol": "Am",
+          "Z": 95,
+          "A_g_mol": 243.0610000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ar": {
+      "name": "G4_Ar",
+      "density_g_cm3": 0.0016620100,
+      "radlen_cm": 11762.1436719519,
+      "intlen_cm": 71988.8135208583,
+      "elements": [
+        {
+          "symbol": "Ar",
+          "Z": 18,
+          "A_g_mol": 39.9476933511,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_As": {
+      "name": "G4_As",
+      "density_g_cm3": 5.7300000000,
+      "radlen_cm": 2.0837957777,
+      "intlen_cm": 25.7503105909,
+      "elements": [
+        {
+          "symbol": "As",
+          "Z": 33,
+          "A_g_mol": 74.9216000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_At": {
+      "name": "G4_At",
+      "density_g_cm3": 9.3200000000,
+      "radlen_cm": 0.6507992580,
+      "intlen_cm": 22.3211364933,
+      "elements": [
+        {
+          "symbol": "At",
+          "Z": 85,
+          "A_g_mol": 209.9870000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Au": {
+      "name": "G4_Au",
+      "density_g_cm3": 19.3200000000,
+      "radlen_cm": 0.3344364418,
+      "intlen_cm": 10.5404409730,
+      "elements": [
+        {
+          "symbol": "Au",
+          "Z": 79,
+          "A_g_mol": 196.9670000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_B": {
+      "name": "G4_B",
+      "density_g_cm3": 2.3700000000,
+      "radlen_cm": 22.2307454494,
+      "intlen_cm": 32.6544150557,
+      "elements": [
+        {
+          "symbol": "B",
+          "Z": 5,
+          "A_g_mol": 10.8110164000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_B-100_BONE": {
+      "name": "G4_B-100_BONE",
+      "density_g_cm3": 1.4500000000,
+      "radlen_cm": 22.1470650946,
+      "intlen_cm": 55.3715324980,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0654709345
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5369444631
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0214999785
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0320849679
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.1674108326
+        },
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.1765888234
+        }
+      ]
+    },
+    "G4_BAKELITE": {
+      "name": "G4_BAKELITE",
+      "density_g_cm3": 1.2500000000,
+      "radlen_cm": 33.3909731372,
+      "intlen_cm": 60.5624222030,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0574410000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7745910000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1679680000
+        }
+      ]
+    },
+    "G4_BARIUM_FLUORIDE": {
+      "name": "G4_BARIUM_FLUORIDE",
+      "density_g_cm3": 4.8900000000,
+      "radlen_cm": 2.0272211742,
+      "intlen_cm": 30.7133072542,
+      "elements": [
+        {
+          "symbol": "Ba",
+          "Z": 56,
+          "A_g_mol": 137.3267993000,
+          "mass_fraction": 0.7832761810
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.2167238190
+        }
+      ]
+    },
+    "G4_BARIUM_SULFATE": {
+      "name": "G4_BARIUM_SULFATE",
+      "density_g_cm3": 4.5000000000,
+      "radlen_cm": 2.5872675325,
+      "intlen_cm": 29.2271363557,
+      "elements": [
+        {
+          "symbol": "Ba",
+          "Z": 56,
+          "A_g_mol": 137.3267993000,
+          "mass_fraction": 0.5883993303
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.1373925574
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2742081123
+        }
+      ]
+    },
+    "G4_BENZENE": {
+      "name": "G4_BENZENE",
+      "density_g_cm3": 0.8786500000,
+      "radlen_cm": 49.8392488069,
+      "intlen_cm": 82.9395907198,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9225773293
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0774226707
+        }
+      ]
+    },
+    "G4_BERYLLIUM_OXIDE": {
+      "name": "G4_BERYLLIUM_OXIDE",
+      "density_g_cm3": 3.0100000000,
+      "radlen_cm": 13.7223989677,
+      "intlen_cm": 27.2312420821,
+      "elements": [
+        {
+          "symbol": "Be",
+          "Z": 4,
+          "A_g_mol": 9.0121800000,
+          "mass_fraction": 0.3603204378
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6396795622
+        }
+      ]
+    },
+    "G4_BGO": {
+      "name": "G4_BGO",
+      "density_g_cm3": 7.1300000000,
+      "radlen_cm": 1.1180299951,
+      "intlen_cm": 22.7101337225,
+      "elements": [
+        {
+          "symbol": "Bi",
+          "Z": 83,
+          "A_g_mol": 208.9800000000,
+          "mass_fraction": 0.6710168961
+        },
+        {
+          "symbol": "Ge",
+          "Z": 32,
+          "A_g_mol": 72.6127869100,
+          "mass_fraction": 0.1748650836
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1541180203
+        }
+      ]
+    },
+    "G4_BLOOD_ICRP": {
+      "name": "G4_BLOOD_ICRP",
+      "density_g_cm3": 1.0600000000,
+      "radlen_cm": 34.4916255606,
+      "intlen_cm": 71.4008796952,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1020000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1100000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0330000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7450000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0030000000
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "Fe",
+          "Z": 26,
+          "A_g_mol": 55.8451107980,
+          "mass_fraction": 0.0010000000
+        }
+      ]
+    },
+    "G4_BONE_COMPACT_ICRU": {
+      "name": "G4_BONE_COMPACT_ICRU",
+      "density_g_cm3": 1.8500000000,
+      "radlen_cm": 16.4792529255,
+      "intlen_cm": 44.4244163422,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0640000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2780000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0270000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4100000000
+        },
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0700000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.1470000000
+        }
+      ]
+    },
+    "G4_BONE_CORTICAL_ICRP": {
+      "name": "G4_BONE_CORTICAL_ICRP",
+      "density_g_cm3": 1.9200000000,
+      "radlen_cm": 14.0594998747,
+      "intlen_cm": 46.4710446539,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0340000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1550000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0420000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4350000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.1030000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0030000000
+        },
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.2250000000
+        }
+      ]
+    },
+    "G4_BORON_CARBIDE": {
+      "name": "G4_BORON_CARBIDE",
+      "density_g_cm3": 2.5200000000,
+      "radlen_cm": 19.8956330875,
+      "intlen_cm": 30.9425465737,
+      "elements": [
+        {
+          "symbol": "B",
+          "Z": 5,
+          "A_g_mol": 10.8110164000,
+          "mass_fraction": 0.7826299987
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2173700013
+        }
+      ]
+    },
+    "G4_BORON_OXIDE": {
+      "name": "G4_BORON_OXIDE",
+      "density_g_cm3": 1.8120000000,
+      "radlen_cm": 21.2007815469,
+      "intlen_cm": 46.6495645684,
+      "elements": [
+        {
+          "symbol": "B",
+          "Z": 5,
+          "A_g_mol": 10.8110164000,
+          "mass_fraction": 0.3105712358
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6894287642
+        }
+      ]
+    },
+    "G4_BRAIN_ICRP": {
+      "name": "G4_BRAIN_ICRP",
+      "density_g_cm3": 1.0400000000,
+      "radlen_cm": 35.4025933979,
+      "intlen_cm": 72.1555402096,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1070000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1450000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0220000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7120000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0040000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0030000000
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0030000000
+        }
+      ]
+    },
+    "G4_BRASS": {
+      "name": "G4_BRASS",
+      "density_g_cm3": 8.5200000000,
+      "radlen_cm": 1.3674058172,
+      "intlen_cm": 16.9476882148,
+      "elements": [
+        {
+          "symbol": "Cu",
+          "Z": 29,
+          "A_g_mol": 63.5456450600,
+          "mass_fraction": 0.5751304341
+        },
+        {
+          "symbol": "Zn",
+          "Z": 30,
+          "A_g_mol": 65.3955232900,
+          "mass_fraction": 0.3341218915
+        },
+        {
+          "symbol": "Pb",
+          "Z": 82,
+          "A_g_mol": 207.2170000000,
+          "mass_fraction": 0.0907476744
+        }
+      ]
+    },
+    "G4_BRONZE": {
+      "name": "G4_BRONZE",
+      "density_g_cm3": 8.8200000000,
+      "radlen_cm": 1.3674305230,
+      "intlen_cm": 16.1768594449,
+      "elements": [
+        {
+          "symbol": "Cu",
+          "Z": 29,
+          "A_g_mol": 63.5456450600,
+          "mass_fraction": 0.8493676870
+        },
+        {
+          "symbol": "Zn",
+          "Z": 30,
+          "A_g_mol": 65.3955232900,
+          "mass_fraction": 0.0883914919
+        },
+        {
+          "symbol": "Pb",
+          "Z": 82,
+          "A_g_mol": 207.2170000000,
+          "mass_fraction": 0.0622408211
+        }
+      ]
+    },
+    "G4_BUTANE": {
+      "name": "G4_BUTANE",
+      "density_g_cm3": 0.0024934300,
+      "radlen_cm": 18139.0227601157,
+      "intlen_cm": 26268.9556216470,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8265829410
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1734170590
+        }
+      ]
+    },
+    "G4_Ba": {
+      "name": "G4_Ba",
+      "density_g_cm3": 3.5000000000,
+      "radlen_cm": 2.3733248313,
+      "intlen_cm": 51.5923290927,
+      "elements": [
+        {
+          "symbol": "Ba",
+          "Z": 56,
+          "A_g_mol": 137.3267993000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Be": {
+      "name": "G4_Be",
+      "density_g_cm3": 1.8480000000,
+      "radlen_cm": 35.2759751356,
+      "intlen_cm": 39.4132938630,
+      "elements": [
+        {
+          "symbol": "Be",
+          "Z": 4,
+          "A_g_mol": 9.0121800000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Bi": {
+      "name": "G4_Bi",
+      "density_g_cm3": 9.7470000000,
+      "radlen_cm": 0.6453882442,
+      "intlen_cm": 21.3091121330,
+      "elements": [
+        {
+          "symbol": "Bi",
+          "Z": 83,
+          "A_g_mol": 208.9800000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Bk": {
+      "name": "G4_Bk",
+      "density_g_cm3": 14.0000000000,
+      "radlen_cm": 0.4064786913,
+      "intlen_cm": 15.6872462983,
+      "elements": [
+        {
+          "symbol": "Bk",
+          "Z": 97,
+          "A_g_mol": 247.0700000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Br": {
+      "name": "G4_Br",
+      "density_g_cm3": 0.0070721000,
+      "radlen_cm": 1615.1154699324,
+      "intlen_cm": 21316.1276450533,
+      "elements": [
+        {
+          "symbol": "Br",
+          "Z": 35,
+          "A_g_mol": 79.9035138000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_C": {
+      "name": "G4_C",
+      "density_g_cm3": 2.0000000000,
+      "radlen_cm": 21.3485184336,
+      "intlen_cm": 40.0769468390,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_C-552": {
+      "name": "G4_C-552",
+      "density_g_cm3": 1.7600000000,
+      "radlen_cm": 21.3755217174,
+      "intlen_cm": 47.2178616072,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0246800247
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5016105016
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0045270045
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.4652094652
+        },
+        {
+          "symbol": "Si",
+          "Z": 14,
+          "A_g_mol": 28.0853614555,
+          "mass_fraction": 0.0039730040
+        }
+      ]
+    },
+    "G4_CADMIUM_TELLURIDE": {
+      "name": "G4_CADMIUM_TELLURIDE",
+      "density_g_cm3": 6.2000000000,
+      "radlen_cm": 1.4363029675,
+      "intlen_cm": 27.8572965803,
+      "elements": [
+        {
+          "symbol": "Cd",
+          "Z": 48,
+          "A_g_mol": 112.4114464000,
+          "mass_fraction": 0.4683531856
+        },
+        {
+          "symbol": "Te",
+          "Z": 52,
+          "A_g_mol": 127.6028203000,
+          "mass_fraction": 0.5316468144
+        }
+      ]
+    },
+    "G4_CADMIUM_TUNGSTATE": {
+      "name": "G4_CADMIUM_TUNGSTATE",
+      "density_g_cm3": 7.9000000000,
+      "radlen_cm": 1.0975367504,
+      "intlen_cm": 19.6990488848,
+      "elements": [
+        {
+          "symbol": "Cd",
+          "Z": 48,
+          "A_g_mol": 112.4114464000,
+          "mass_fraction": 0.3120367899
+        },
+        {
+          "symbol": "W",
+          "Z": 74,
+          "A_g_mol": 183.8416100000,
+          "mass_fraction": 0.5103158768
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1776473334
+        }
+      ]
+    },
+    "G4_CALCIUM_CARBONATE": {
+      "name": "G4_CALCIUM_CARBONATE",
+      "density_g_cm3": 2.8000000000,
+      "radlen_cm": 8.5806303005,
+      "intlen_cm": 34.7483442364,
+      "elements": [
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.4004321837
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1200030341
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4795647823
+        }
+      ]
+    },
+    "G4_CALCIUM_FLUORIDE": {
+      "name": "G4_CALCIUM_FLUORIDE",
+      "density_g_cm3": 3.1800000000,
+      "radlen_cm": 6.7515445571,
+      "intlen_cm": 33.1126825134,
+      "elements": [
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.5133284414
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.4866715586
+        }
+      ]
+    },
+    "G4_CALCIUM_OXIDE": {
+      "name": "G4_CALCIUM_OXIDE",
+      "density_g_cm3": 3.3000000000,
+      "radlen_cm": 5.7605472772,
+      "intlen_cm": 32.9311668963,
+      "elements": [
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.7146910499
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2853089501
+        }
+      ]
+    },
+    "G4_CALCIUM_SULFATE": {
+      "name": "G4_CALCIUM_SULFATE",
+      "density_g_cm3": 2.9600000000,
+      "radlen_cm": 7.6700891493,
+      "intlen_cm": 34.1039310668,
+      "elements": [
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.2943846699
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.2355348323
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4700804977
+        }
+      ]
+    },
+    "G4_CALCIUM_TUNGSTATE": {
+      "name": "G4_CALCIUM_TUNGSTATE",
+      "density_g_cm3": 6.0620000000,
+      "radlen_cm": 1.5061183605,
+      "intlen_cm": 23.9389476671,
+      "elements": [
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.1391998505
+        },
+        {
+          "symbol": "W",
+          "Z": 74,
+          "A_g_mol": 183.8416100000,
+          "mass_fraction": 0.6385224915
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2222776580
+        }
+      ]
+    },
+    "G4_CARBON_DIOXIDE": {
+      "name": "G4_CARBON_DIOXIDE",
+      "density_g_cm3": 0.0018421200,
+      "radlen_cm": 19648.6261057218,
+      "intlen_cm": 46600.4101036886,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2729122504
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7270877496
+        }
+      ]
+    },
+    "G4_CARBON_TETRACHLORIDE": {
+      "name": "G4_CARBON_TETRACHLORIDE",
+      "density_g_cm3": 1.5940000000,
+      "radlen_cm": 12.6353035438,
+      "intlen_cm": 69.7653934353,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0780825377
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.9219174623
+        }
+      ]
+    },
+    "G4_CELLULOSE_BUTYRATE": {
+      "name": "G4_CELLULOSE_BUTYRATE",
+      "density_g_cm3": 1.2000000000,
+      "radlen_cm": 33.1272771295,
+      "intlen_cm": 63.5368792659,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0671250000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5454030000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3874720000
+        }
+      ]
+    },
+    "G4_CELLULOSE_CELLOPHANE": {
+      "name": "G4_CELLULOSE_CELLOPHANE",
+      "density_g_cm3": 1.4200000000,
+      "radlen_cm": 27.2894013482,
+      "intlen_cm": 54.5257863934,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4444558564
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0621645440
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4933795996
+        }
+      ]
+    },
+    "G4_CELLULOSE_NITRATE": {
+      "name": "G4_CELLULOSE_NITRATE",
+      "density_g_cm3": 1.4900000000,
+      "radlen_cm": 24.9514919127,
+      "intlen_cm": 54.9526743102,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0292160000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2712960000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1212760000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5782120000
+        }
+      ]
+    },
+    "G4_CERIC_SULFATE": {
+      "name": "G4_CERIC_SULFATE",
+      "density_g_cm3": 1.0300000000,
+      "radlen_cm": 34.3245544164,
+      "intlen_cm": 73.8457863342,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1075960000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0008000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.8749760000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0146270000
+        },
+        {
+          "symbol": "Ce",
+          "Z": 58,
+          "A_g_mol": 140.1153107700,
+          "mass_fraction": 0.0020010000
+        }
+      ]
+    },
+    "G4_CESIUM_FLUORIDE": {
+      "name": "G4_CESIUM_FLUORIDE",
+      "density_g_cm3": 4.1150000000,
+      "radlen_cm": 2.2265267957,
+      "intlen_cm": 38.9591822729,
+      "elements": [
+        {
+          "symbol": "Cs",
+          "Z": 55,
+          "A_g_mol": 132.9050000000,
+          "mass_fraction": 0.8749310417
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.1250689583
+        }
+      ]
+    },
+    "G4_CESIUM_IODIDE": {
+      "name": "G4_CESIUM_IODIDE",
+      "density_g_cm3": 4.5100000000,
+      "radlen_cm": 1.8602879809,
+      "intlen_cm": 39.3059850354,
+      "elements": [
+        {
+          "symbol": "Cs",
+          "Z": 55,
+          "A_g_mol": 132.9050000000,
+          "mass_fraction": 0.5115488686
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.4884511314
+        }
+      ]
+    },
+    "G4_CHLOROBENZENE": {
+      "name": "G4_CHLOROBENZENE",
+      "density_g_cm3": 1.1058000000,
+      "radlen_cm": 28.2213601504,
+      "intlen_cm": 75.3196655676,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6402499469
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0447748021
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.3149752510
+        }
+      ]
+    },
+    "G4_CHLOROFORM": {
+      "name": "G4_CHLOROFORM",
+      "density_g_cm3": 1.4832000000,
+      "radlen_cm": 13.8426852338,
+      "intlen_cm": 72.9258168862,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1006123208
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0084433839
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.8909442953
+        }
+      ]
+    },
+    "G4_CONCRETE": {
+      "name": "G4_CONCRETE",
+      "density_g_cm3": 2.3000000000,
+      "radlen_cm": 11.5527147841,
+      "intlen_cm": 41.2115550512,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0100000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5291070000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0160000000
+        },
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "Al",
+          "Z": 13,
+          "A_g_mol": 26.9815000000,
+          "mass_fraction": 0.0338720000
+        },
+        {
+          "symbol": "Si",
+          "Z": 14,
+          "A_g_mol": 28.0853614555,
+          "mass_fraction": 0.3370210000
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0130000000
+        },
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.0440000000
+        },
+        {
+          "symbol": "Fe",
+          "Z": 26,
+          "A_g_mol": 55.8451107980,
+          "mass_fraction": 0.0140000000
+        }
+      ]
+    },
+    "G4_CR39": {
+      "name": "G4_CR39",
+      "density_g_cm3": 1.3200000000,
+      "radlen_cm": 29.9630720578,
+      "intlen_cm": 57.9349397872,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0661505040
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5255046077
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4083448883
+        }
+      ]
+    },
+    "G4_CYCLOHEXANE": {
+      "name": "G4_CYCLOHEXANE",
+      "density_g_cm3": 0.7790000000,
+      "radlen_cm": 57.4759804747,
+      "intlen_cm": 86.7995841505,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8562817123
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1437182877
+        }
+      ]
+    },
+    "G4_CYTOSINE": {
+      "name": "G4_CYTOSINE",
+      "density_g_cm3": 1.3000000000,
+      "radlen_cm": 30.7578506265,
+      "intlen_cm": 60.0651401038,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0453609120
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4324206194
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.3782125956
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1440058730
+        }
+      ]
+    },
+    "G4_Ca": {
+      "name": "G4_Ca",
+      "density_g_cm3": 1.5500000000,
+      "radlen_cm": 10.4151095198,
+      "intlen_cm": 77.2749101845,
+      "elements": [
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Cd": {
+      "name": "G4_Cd",
+      "density_g_cm3": 8.6500000000,
+      "radlen_cm": 1.0399387577,
+      "intlen_cm": 19.5278973588,
+      "elements": [
+        {
+          "symbol": "Cd",
+          "Z": 48,
+          "A_g_mol": 112.4114464000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ce": {
+      "name": "G4_Ce",
+      "density_g_cm3": 6.6570000000,
+      "radlen_cm": 1.1950616986,
+      "intlen_cm": 27.3076746781,
+      "elements": [
+        {
+          "symbol": "Ce",
+          "Z": 58,
+          "A_g_mol": 140.1153107700,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Cf": {
+      "name": "G4_Cf",
+      "density_g_cm3": 10.0000000000,
+      "radlen_cm": 0.5683275438,
+      "intlen_cm": 22.0803245446,
+      "elements": [
+        {
+          "symbol": "Cf",
+          "Z": 98,
+          "A_g_mol": 251.0800000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Cl": {
+      "name": "G4_Cl",
+      "density_g_cm3": 0.0029947300,
+      "radlen_cm": 6437.3408608729,
+      "intlen_cm": 38393.6729355327,
+      "elements": [
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Cm": {
+      "name": "G4_Cm",
+      "density_g_cm3": 13.5100000000,
+      "radlen_cm": 0.4287060756,
+      "intlen_cm": 16.2562137806,
+      "elements": [
+        {
+          "symbol": "Cm",
+          "Z": 96,
+          "A_g_mol": 247.0700000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Co": {
+      "name": "G4_Co",
+      "density_g_cm3": 8.9000000000,
+      "radlen_cm": 1.5300516989,
+      "intlen_cm": 15.3037576765,
+      "elements": [
+        {
+          "symbol": "Co",
+          "Z": 27,
+          "A_g_mol": 58.9332000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Cr": {
+      "name": "G4_Cr",
+      "density_g_cm3": 7.1800000000,
+      "radlen_cm": 2.0814040144,
+      "intlen_cm": 18.1942423649,
+      "elements": [
+        {
+          "symbol": "Cr",
+          "Z": 24,
+          "A_g_mol": 51.9961301370,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Cs": {
+      "name": "G4_Cs",
+      "density_g_cm3": 1.8730000000,
+      "radlen_cm": 4.4342020259,
+      "intlen_cm": 95.3624518046,
+      "elements": [
+        {
+          "symbol": "Cs",
+          "Z": 55,
+          "A_g_mol": 132.9050000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Cu": {
+      "name": "G4_Cu",
+      "density_g_cm3": 8.9600000000,
+      "radlen_cm": 1.4355780238,
+      "intlen_cm": 15.5879379043,
+      "elements": [
+        {
+          "symbol": "Cu",
+          "Z": 29,
+          "A_g_mol": 63.5456450600,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_DACRON": {
+      "name": "G4_DACRON",
+      "density_g_cm3": 1.4000000000,
+      "radlen_cm": 28.5364043256,
+      "intlen_cm": 55.9231513594,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6250108323
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0419607171
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3330284506
+        }
+      ]
+    },
+    "G4_DEOXYRIBOSE": {
+      "name": "G4_DEOXYRIBOSE",
+      "density_g_cm3": 1.5000000000,
+      "radlen_cm": 26.0277793263,
+      "intlen_cm": 50.7245404788,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0751461910
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4477252695
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4771285395
+        }
+      ]
+    },
+    "G4_DICHLORODIETHYL_ETHER": {
+      "name": "G4_DICHLORODIETHYL_ETHER",
+      "density_g_cm3": 1.2199000000,
+      "radlen_cm": 21.7159252335,
+      "intlen_cm": 72.0157030853,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.3359387920
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0563839532
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1118752364
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.4958020185
+        }
+      ]
+    },
+    "G4_DIETHYL_ETHER": {
+      "name": "G4_DIETHYL_ETHER",
+      "density_g_cm3": 0.7137800000,
+      "radlen_cm": 59.2587073492,
+      "intlen_cm": 97.1612602951,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6481626481
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1359844906
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2158528613
+        }
+      ]
+    },
+    "G4_DIMETHYL_SULFOXIDE": {
+      "name": "G4_DIMETHYL_SULFOXIDE",
+      "density_g_cm3": 1.1014000000,
+      "radlen_cm": 25.6056153635,
+      "intlen_cm": 75.2873092978,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.3074369871
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0774003171
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2047669780
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.4103957178
+        }
+      ]
+    },
+    "G4_DNA_ADENINE": {
+      "name": "G4_DNA_ADENINE",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 40.4701354302,
+      "intlen_cm": 79.1489834113,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0300610227
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4477631967
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.5221757806
+        }
+      ]
+    },
+    "G4_DNA_CYTOSINE": {
+      "name": "G4_DNA_CYTOSINE",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 39.8517602235,
+      "intlen_cm": 78.9747286021,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0366209616
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4363795341
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.3816752229
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1453242814
+        }
+      ]
+    },
+    "G4_DNA_DEOXYRIBOSE": {
+      "name": "G4_DNA_DEOXYRIBOSE",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 41.8531490771,
+      "intlen_cm": 73.4025938940,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0848959119
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7225923706
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1925117175
+        }
+      ]
+    },
+    "G4_DNA_GUANINE": {
+      "name": "G4_DNA_GUANINE",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 39.6999832548,
+      "intlen_cm": 80.0236241154,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0268571707
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4000413663
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.4665231851
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1065782779
+        }
+      ]
+    },
+    "G4_DNA_PHOSPHATE": {
+      "name": "G4_DNA_PHOSPHATE",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 28.5212126943,
+      "intlen_cm": 94.2697781537,
+      "elements": [
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.3261383165
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6738616835
+        }
+      ]
+    },
+    "G4_DNA_THYMINE": {
+      "name": "G4_DNA_THYMINE",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 39.6095818095,
+      "intlen_cm": 78.7777563069,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0402835649
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4800235304
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.2239189496
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2557739551
+        }
+      ]
+    },
+    "G4_DNA_URACIL": {
+      "name": "G4_DNA_URACIL",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 39.0409633092,
+      "intlen_cm": 80.4546879807,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0272222464
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4325111686
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.2521945291
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2880720559
+        }
+      ]
+    },
+    "G4_Dy": {
+      "name": "G4_Dy",
+      "density_g_cm3": 8.5500000000,
+      "radlen_cm": 0.8561401252,
+      "intlen_cm": 22.3383201875,
+      "elements": [
+        {
+          "symbol": "Dy",
+          "Z": 66,
+          "A_g_mol": 162.4971100000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_ETHANE": {
+      "name": "G4_ETHANE",
+      "density_g_cm3": 0.0012532400,
+      "radlen_cm": 36434.2860647397,
+      "intlen_cm": 50781.0189376312,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7988752227
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.2011247773
+        }
+      ]
+    },
+    "G4_ETHYLENE": {
+      "name": "G4_ETHYLENE",
+      "density_g_cm3": 0.0011749700,
+      "radlen_cm": 38106.3250889615,
+      "intlen_cm": 57547.7467962794,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8562817123
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1437182877
+        }
+      ]
+    },
+    "G4_ETHYL_ALCOHOL": {
+      "name": "G4_ETHYL_ALCOHOL",
+      "density_g_cm3": 0.7893000000,
+      "radlen_cm": 51.8429704156,
+      "intlen_cm": 89.2594985493,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5214293661
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1312750254
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3472956085
+        }
+      ]
+    },
+    "G4_ETHYL_CELLULOSE": {
+      "name": "G4_ETHYL_CELLULOSE",
+      "density_g_cm3": 1.1300000000,
+      "radlen_cm": 35.9450301822,
+      "intlen_cm": 65.2831880981,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0900270000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5851820000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3247910000
+        }
+      ]
+    },
+    "G4_EYE_LENS_ICRP": {
+      "name": "G4_EYE_LENS_ICRP",
+      "density_g_cm3": 1.0700000000,
+      "radlen_cm": 34.9413412839,
+      "intlen_cm": 70.6360062417,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0960000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1950000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0570000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6460000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0030000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0010000000
+        }
+      ]
+    },
+    "G4_Er": {
+      "name": "G4_Er",
+      "density_g_cm3": 9.0660000000,
+      "radlen_cm": 0.7880939310,
+      "intlen_cm": 21.2705940900,
+      "elements": [
+        {
+          "symbol": "Er",
+          "Z": 68,
+          "A_g_mol": 167.2560232000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Eu": {
+      "name": "G4_Eu",
+      "density_g_cm3": 5.2430000000,
+      "radlen_cm": 1.4186770984,
+      "intlen_cm": 35.6234054321,
+      "elements": [
+        {
+          "symbol": "Eu",
+          "Z": 63,
+          "A_g_mol": 151.9643219000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_F": {
+      "name": "G4_F",
+      "density_g_cm3": 0.0015802900,
+      "radlen_cm": 20838.1744350084,
+      "intlen_cm": 59097.6615288435,
+      "elements": [
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_FERRIC_OXIDE": {
+      "name": "G4_FERRIC_OXIDE",
+      "density_g_cm3": 5.2000000000,
+      "radlen_cm": 3.2418173343,
+      "intlen_cm": 22.2675201920,
+      "elements": [
+        {
+          "symbol": "Fe",
+          "Z": 26,
+          "A_g_mol": 55.8451107980,
+          "mass_fraction": 0.6994260486
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3005739514
+        }
+      ]
+    },
+    "G4_FERROBORIDE": {
+      "name": "G4_FERROBORIDE",
+      "density_g_cm3": 7.1500000000,
+      "radlen_cm": 2.1983578257,
+      "intlen_cm": 16.7331909572,
+      "elements": [
+        {
+          "symbol": "Fe",
+          "Z": 26,
+          "A_g_mol": 55.8451107980,
+          "mass_fraction": 0.8378091129
+        },
+        {
+          "symbol": "B",
+          "Z": 5,
+          "A_g_mol": 10.8110164000,
+          "mass_fraction": 0.1621908871
+        }
+      ]
+    },
+    "G4_FERROUS_OXIDE": {
+      "name": "G4_FERROUS_OXIDE",
+      "density_g_cm3": 5.7000000000,
+      "radlen_cm": 2.7992227484,
+      "intlen_cm": 21.0475937407,
+      "elements": [
+        {
+          "symbol": "Fe",
+          "Z": 26,
+          "A_g_mol": 55.8451107980,
+          "mass_fraction": 0.7773052893
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2226947107
+        }
+      ]
+    },
+    "G4_FERROUS_SULFATE": {
+      "name": "G4_FERROUS_SULFATE",
+      "density_g_cm3": 1.0240000000,
+      "radlen_cm": 34.8125553802,
+      "intlen_cm": 74.1303341800,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1082590000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0000270000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.8786360000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0000220000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0129680000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0000340000
+        },
+        {
+          "symbol": "Fe",
+          "Z": 26,
+          "A_g_mol": 55.8451107980,
+          "mass_fraction": 0.0000540000
+        }
+      ]
+    },
+    "G4_FREON-12": {
+      "name": "G4_FREON-12",
+      "density_g_cm3": 1.1200000000,
+      "radlen_cm": 21.1136459442,
+      "intlen_cm": 92.0056500582,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0993350000
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.3142470000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.5864180000
+        }
+      ]
+    },
+    "G4_FREON-12B2": {
+      "name": "G4_FREON-12B2",
+      "density_g_cm3": 1.8000000000,
+      "radlen_cm": 7.5563082797,
+      "intlen_cm": 72.0960738549,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0572450000
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.1810960000
+        },
+        {
+          "symbol": "Br",
+          "Z": 35,
+          "A_g_mol": 79.9035138000,
+          "mass_fraction": 0.7616590000
+        }
+      ]
+    },
+    "G4_FREON-13": {
+      "name": "G4_FREON-13",
+      "density_g_cm3": 0.9500000000,
+      "radlen_cm": 28.5519879814,
+      "intlen_cm": 102.9101489011,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1149828850
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.5456214544
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.3393956606
+        }
+      ]
+    },
+    "G4_FREON-13B1": {
+      "name": "G4_FREON-13B1",
+      "density_g_cm3": 1.5000000000,
+      "radlen_cm": 11.0211416256,
+      "intlen_cm": 76.9456788799,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0806579862
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.3827507249
+        },
+        {
+          "symbol": "Br",
+          "Z": 35,
+          "A_g_mol": 79.9035138000,
+          "mass_fraction": 0.5365912889
+        }
+      ]
+    },
+    "G4_FREON-13I1": {
+      "name": "G4_FREON-13I1",
+      "density_g_cm3": 1.8000000000,
+      "radlen_cm": 6.4111664137,
+      "intlen_cm": 73.4578642805,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0613090000
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.2909240000
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.6477670000
+        }
+      ]
+    },
+    "G4_Fe": {
+      "name": "G4_Fe",
+      "density_g_cm3": 7.8740000000,
+      "radlen_cm": 1.7574934651,
+      "intlen_cm": 16.9903002759,
+      "elements": [
+        {
+          "symbol": "Fe",
+          "Z": 26,
+          "A_g_mol": 55.8451107980,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Fr": {
+      "name": "G4_Fr",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 6.1882573776,
+      "intlen_cm": 212.2508067736,
+      "elements": [
+        {
+          "symbol": "Fr",
+          "Z": 87,
+          "A_g_mol": 223.0200000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_GADOLINIUM_OXYSULFIDE": {
+      "name": "G4_GADOLINIUM_OXYSULFIDE",
+      "density_g_cm3": 7.4400000000,
+      "radlen_cm": 1.1407035079,
+      "intlen_cm": 21.9702398250,
+      "elements": [
+        {
+          "symbol": "Gd",
+          "Z": 64,
+          "A_g_mol": 157.2521250000,
+          "mass_fraction": 0.8307709545
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0845255913
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0847034542
+        }
+      ]
+    },
+    "G4_GALLIUM_ARSENIDE": {
+      "name": "G4_GALLIUM_ARSENIDE",
+      "density_g_cm3": 5.3100000000,
+      "radlen_cm": 2.2959768793,
+      "intlen_cm": 27.4658727793,
+      "elements": [
+        {
+          "symbol": "Ga",
+          "Z": 31,
+          "A_g_mol": 69.7230809720,
+          "mass_fraction": 0.4820300374
+        },
+        {
+          "symbol": "As",
+          "Z": 33,
+          "A_g_mol": 74.9216000000,
+          "mass_fraction": 0.5179699626
+        }
+      ]
+    },
+    "G4_GEL_PHOTO_EMULSION": {
+      "name": "G4_GEL_PHOTO_EMULSION",
+      "density_g_cm3": 1.2914000000,
+      "radlen_cm": 30.2058086009,
+      "intlen_cm": 58.4748172458,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0811800000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4160600000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1112400000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3806400000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0108800000
+        }
+      ]
+    },
+    "G4_GLASS_LEAD": {
+      "name": "G4_GLASS_LEAD",
+      "density_g_cm3": 6.2200000000,
+      "radlen_cm": 1.2655477423,
+      "intlen_cm": 25.7388388952,
+      "elements": [
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1564530000
+        },
+        {
+          "symbol": "Si",
+          "Z": 14,
+          "A_g_mol": 28.0853614555,
+          "mass_fraction": 0.0808660000
+        },
+        {
+          "symbol": "Ti",
+          "Z": 22,
+          "A_g_mol": 47.8667173300,
+          "mass_fraction": 0.0080920000
+        },
+        {
+          "symbol": "As",
+          "Z": 33,
+          "A_g_mol": 74.9216000000,
+          "mass_fraction": 0.0026510000
+        },
+        {
+          "symbol": "Pb",
+          "Z": 82,
+          "A_g_mol": 207.2170000000,
+          "mass_fraction": 0.7519380000
+        }
+      ]
+    },
+    "G4_GLASS_PLATE": {
+      "name": "G4_GLASS_PLATE",
+      "density_g_cm3": 2.4000000000,
+      "radlen_cm": 10.6921640656,
+      "intlen_cm": 40.6857797379,
+      "elements": [
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4598004598
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0964410964
+        },
+        {
+          "symbol": "Si",
+          "Z": 14,
+          "A_g_mol": 28.0853614555,
+          "mass_fraction": 0.3365533366
+        },
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.1072051072
+        }
+      ]
+    },
+    "G4_GLUTAMINE": {
+      "name": "G4_GLUTAMINE",
+      "density_g_cm3": 1.4600000000,
+      "radlen_cm": 27.0121584298,
+      "intlen_cm": 52.3124063449,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4109190507
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0689686368
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1916834413
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3284288712
+        }
+      ]
+    },
+    "G4_GLYCEROL": {
+      "name": "G4_GLYCEROL",
+      "density_g_cm3": 1.2613000000,
+      "radlen_cm": 30.7600170394,
+      "intlen_cm": 59.6449295333,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.3912550846
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0875576500
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5211872654
+        }
+      ]
+    },
+    "G4_GRAPHITE": {
+      "name": "G4_GRAPHITE",
+      "density_g_cm3": 2.2100000000,
+      "radlen_cm": 19.3199261842,
+      "intlen_cm": 36.2687301711,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_GRAPHITE_POROUS": {
+      "name": "G4_GRAPHITE_POROUS",
+      "density_g_cm3": 1.7000000000,
+      "radlen_cm": 25.1159040395,
+      "intlen_cm": 47.1493492224,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_GUANINE": {
+      "name": "G4_GUANINE",
+      "density_g_cm3": 1.5800000000,
+      "radlen_cm": 25.1887769514,
+      "intlen_cm": 50.2170220603,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.3973732857
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0333475581
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.4634117033
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1058674529
+        }
+      ]
+    },
+    "G4_GYPSUM": {
+      "name": "G4_GYPSUM",
+      "density_g_cm3": 2.3200000000,
+      "radlen_cm": 10.6092208180,
+      "intlen_cm": 40.6273547785,
+      "elements": [
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.2327786930
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.1862443803
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5575598954
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0234170314
+        }
+      ]
+    },
+    "G4_Ga": {
+      "name": "G4_Ga",
+      "density_g_cm3": 5.9040000000,
+      "radlen_cm": 2.1127975858,
+      "intlen_cm": 24.3994809094,
+      "elements": [
+        {
+          "symbol": "Ga",
+          "Z": 31,
+          "A_g_mol": 69.7230809720,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Galactic": {
+      "name": "G4_Galactic",
+      "density_g_cm3": 0.0000000000,
+      "radlen_cm": 630435090422683690204135424.0000000000,
+      "intlen_cm": 350000028082484913811488768.0000000000,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Gd": {
+      "name": "G4_Gd",
+      "density_g_cm3": 7.9004000000,
+      "radlen_cm": 0.9472083827,
+      "intlen_cm": 23.9121066950,
+      "elements": [
+        {
+          "symbol": "Gd",
+          "Z": 64,
+          "A_g_mol": 157.2521250000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ge": {
+      "name": "G4_Ge",
+      "density_g_cm3": 5.3230000000,
+      "radlen_cm": 2.3012998808,
+      "intlen_cm": 27.4314847558,
+      "elements": [
+        {
+          "symbol": "Ge",
+          "Z": 32,
+          "A_g_mol": 72.6127869100,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_H": {
+      "name": "G4_H",
+      "density_g_cm3": 0.0000837480,
+      "radlen_cm": 752776.2936699188,
+      "intlen_cm": 417920.4614826443,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_He": {
+      "name": "G4_He",
+      "density_g_cm3": 0.0001663220,
+      "radlen_cm": 567113.1420929121,
+      "intlen_cm": 334118.5985088379,
+      "elements": [
+        {
+          "symbol": "He",
+          "Z": 2,
+          "A_g_mol": 4.0026425851,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Hf": {
+      "name": "G4_Hf",
+      "density_g_cm3": 13.3100000000,
+      "radlen_cm": 0.5177172521,
+      "intlen_cm": 14.8055339056,
+      "elements": [
+        {
+          "symbol": "Hf",
+          "Z": 72,
+          "A_g_mol": 178.4851746000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Hg": {
+      "name": "G4_Hg",
+      "density_g_cm3": 13.5460000000,
+      "radlen_cm": 0.4752411427,
+      "intlen_cm": 15.1251608352,
+      "elements": [
+        {
+          "symbol": "Hg",
+          "Z": 80,
+          "A_g_mol": 200.5991002000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ho": {
+      "name": "G4_Ho",
+      "density_g_cm3": 8.7950000000,
+      "radlen_cm": 0.8224469594,
+      "intlen_cm": 21.8238878765,
+      "elements": [
+        {
+          "symbol": "Ho",
+          "Z": 67,
+          "A_g_mol": 164.9300000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_I": {
+      "name": "G4_I",
+      "density_g_cm3": 4.9300000000,
+      "radlen_cm": 1.7201640735,
+      "intlen_cm": 35.6762827299,
+      "elements": [
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_In": {
+      "name": "G4_In",
+      "density_g_cm3": 7.3100000000,
+      "radlen_cm": 1.2105450732,
+      "intlen_cm": 23.2713161873,
+      "elements": [
+        {
+          "symbol": "In",
+          "Z": 49,
+          "A_g_mol": 114.8182000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ir": {
+      "name": "G4_Ir",
+      "density_g_cm3": 22.4200000000,
+      "radlen_cm": 0.2941415950,
+      "intlen_cm": 9.0093994089,
+      "elements": [
+        {
+          "symbol": "Ir",
+          "Z": 77,
+          "A_g_mol": 192.2162540000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_K": {
+      "name": "G4_K",
+      "density_g_cm3": 0.8620000000,
+      "radlen_cm": 20.0870675609,
+      "intlen_cm": 137.8097927497,
+      "elements": [
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_KAPTON": {
+      "name": "G4_KAPTON",
+      "density_g_cm3": 1.4200000000,
+      "radlen_cm": 28.5747754063,
+      "intlen_cm": 55.8169092105,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6911278143
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0263633782
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0732713202
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2092374873
+        }
+      ]
+    },
+    "G4_KEVLAR": {
+      "name": "G4_KEVLAR",
+      "density_g_cm3": 1.4400000000,
+      "radlen_cm": 28.6728455313,
+      "intlen_cm": 53.7041703894,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7057961409
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0423074270
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1343120694
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1175843627
+        }
+      ]
+    },
+    "G4_Kr": {
+      "name": "G4_Kr",
+      "density_g_cm3": 0.0034783200,
+      "radlen_cm": 3269.4392743928,
+      "intlen_cm": 44033.0436533239,
+      "elements": [
+        {
+          "symbol": "Kr",
+          "Z": 36,
+          "A_g_mol": 83.7993175100,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_LANTHANUM_OXYBROMIDE": {
+      "name": "G4_LANTHANUM_OXYBROMIDE",
+      "density_g_cm3": 6.2800000000,
+      "radlen_cm": 1.5241532522,
+      "intlen_cm": 25.3014351184,
+      "elements": [
+        {
+          "symbol": "La",
+          "Z": 57,
+          "A_g_mol": 138.9051009000,
+          "mass_fraction": 0.5915688472
+        },
+        {
+          "symbol": "Br",
+          "Z": 35,
+          "A_g_mol": 79.9035138000,
+          "mass_fraction": 0.3402929715
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0681381812
+        }
+      ]
+    },
+    "G4_LANTHANUM_OXYSULFIDE": {
+      "name": "G4_LANTHANUM_OXYSULFIDE",
+      "density_g_cm3": 5.8600000000,
+      "radlen_cm": 1.5889258344,
+      "intlen_cm": 26.7145523078,
+      "elements": [
+        {
+          "symbol": "La",
+          "Z": 57,
+          "A_g_mol": 138.9051009000,
+          "mass_fraction": 0.8126073070
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0935978698
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0937948232
+        }
+      ]
+    },
+    "G4_LEAD_OXIDE": {
+      "name": "G4_LEAD_OXIDE",
+      "density_g_cm3": 9.5300000000,
+      "radlen_cm": 0.7098556946,
+      "intlen_cm": 19.8173808964,
+      "elements": [
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0716820000
+        },
+        {
+          "symbol": "Pb",
+          "Z": 82,
+          "A_g_mol": 207.2170000000,
+          "mass_fraction": 0.9283180000
+        }
+      ]
+    },
+    "G4_LITHIUM_AMIDE": {
+      "name": "G4_LITHIUM_AMIDE",
+      "density_g_cm3": 1.1780000000,
+      "radlen_cm": 40.2298585529,
+      "intlen_cm": 59.5078880837,
+      "elements": [
+        {
+          "symbol": "Li",
+          "Z": 3,
+          "A_g_mol": 6.9400332080,
+          "mass_fraction": 0.3022309285
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.6099796156
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0877894559
+        }
+      ]
+    },
+    "G4_LITHIUM_CARBONATE": {
+      "name": "G4_LITHIUM_CARBONATE",
+      "density_g_cm3": 2.1100000000,
+      "radlen_cm": 18.9197918579,
+      "intlen_cm": 38.8235211926,
+      "elements": [
+        {
+          "symbol": "Li",
+          "Z": 3,
+          "A_g_mol": 6.9400332080,
+          "mass_fraction": 0.1878503065
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1625511321
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6495985614
+        }
+      ]
+    },
+    "G4_LITHIUM_FLUORIDE": {
+      "name": "G4_LITHIUM_FLUORIDE",
+      "density_g_cm3": 2.6350000000,
+      "radlen_cm": 14.8973607769,
+      "intlen_cm": 32.0247499094,
+      "elements": [
+        {
+          "symbol": "Li",
+          "Z": 3,
+          "A_g_mol": 6.9400332080,
+          "mass_fraction": 0.2675579189
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.7324420811
+        }
+      ]
+    },
+    "G4_LITHIUM_HYDRIDE": {
+      "name": "G4_LITHIUM_HYDRIDE",
+      "density_g_cm3": 0.8200000000,
+      "radlen_cm": 97.0850620364,
+      "intlen_cm": 73.0132624194,
+      "elements": [
+        {
+          "symbol": "Li",
+          "Z": 3,
+          "A_g_mol": 6.9400332080,
+          "mass_fraction": 0.8731826806
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1268173194
+        }
+      ]
+    },
+    "G4_LITHIUM_IODIDE": {
+      "name": "G4_LITHIUM_IODIDE",
+      "density_g_cm3": 3.4940000000,
+      "radlen_cm": 2.5456045592,
+      "intlen_cm": 46.4058302608,
+      "elements": [
+        {
+          "symbol": "Li",
+          "Z": 3,
+          "A_g_mol": 6.9400332080,
+          "mass_fraction": 0.0518516443
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.9481483557
+        }
+      ]
+    },
+    "G4_LITHIUM_OXIDE": {
+      "name": "G4_LITHIUM_OXIDE",
+      "density_g_cm3": 2.0130000000,
+      "radlen_cm": 23.3753863602,
+      "intlen_cm": 38.1260963105,
+      "elements": [
+        {
+          "symbol": "Li",
+          "Z": 3,
+          "A_g_mol": 6.9400332080,
+          "mass_fraction": 0.4645354330
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5354645670
+        }
+      ]
+    },
+    "G4_LITHIUM_TETRABORATE": {
+      "name": "G4_LITHIUM_TETRABORATE",
+      "density_g_cm3": 2.4400000000,
+      "radlen_cm": 16.2719894171,
+      "intlen_cm": 34.0334121576,
+      "elements": [
+        {
+          "symbol": "Li",
+          "Z": 3,
+          "A_g_mol": 6.9400332080,
+          "mass_fraction": 0.0820723599
+        },
+        {
+          "symbol": "B",
+          "Z": 5,
+          "A_g_mol": 10.8110164000,
+          "mass_fraction": 0.2557006868
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6622269533
+        }
+      ]
+    },
+    "G4_LUCITE": {
+      "name": "G4_LUCITE",
+      "density_g_cm3": 1.1900000000,
+      "radlen_cm": 34.0748652335,
+      "intlen_cm": 62.6704780225,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0805380000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5998480000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3196140000
+        }
+      ]
+    },
+    "G4_LUNG_ICRP": {
+      "name": "G4_LUNG_ICRP",
+      "density_g_cm3": 1.0400000000,
+      "radlen_cm": 35.0156133645,
+      "intlen_cm": 72.6726342239,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1050000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0830000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0230000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7790000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0030000000
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0020000000
+        }
+      ]
+    },
+    "G4_La": {
+      "name": "G4_La",
+      "density_g_cm3": 6.1540000000,
+      "radlen_cm": 1.3223836276,
+      "intlen_cm": 29.4543867747,
+      "elements": [
+        {
+          "symbol": "La",
+          "Z": 57,
+          "A_g_mol": 138.9051009000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Li": {
+      "name": "G4_Li",
+      "density_g_cm3": 0.5340000000,
+      "radlen_cm": 154.9972904774,
+      "intlen_cm": 125.0203388568,
+      "elements": [
+        {
+          "symbol": "Li",
+          "Z": 3,
+          "A_g_mol": 6.9400332080,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Lu": {
+      "name": "G4_Lu",
+      "density_g_cm3": 9.8400000000,
+      "radlen_cm": 0.7036514007,
+      "intlen_cm": 19.8941317320,
+      "elements": [
+        {
+          "symbol": "Lu",
+          "Z": 71,
+          "A_g_mol": 174.9669518000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_M3_WAX": {
+      "name": "G4_M3_WAX",
+      "density_g_cm3": 1.0500000000,
+      "radlen_cm": 37.4523271935,
+      "intlen_cm": 68.7782440198,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1143181143
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6558236558
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0921830922
+        },
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.1347921348
+        },
+        {
+          "symbol": "Ca",
+          "Z": 20,
+          "A_g_mol": 40.0780316410,
+          "mass_fraction": 0.0028830029
+        }
+      ]
+    },
+    "G4_MAGNESIUM_CARBONATE": {
+      "name": "G4_MAGNESIUM_CARBONATE",
+      "density_g_cm3": 2.9580000000,
+      "radlen_cm": 10.7392076017,
+      "intlen_cm": 30.5238324080,
+      "elements": [
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.2882681150
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1424525855
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5692792995
+        }
+      ]
+    },
+    "G4_MAGNESIUM_FLUORIDE": {
+      "name": "G4_MAGNESIUM_FLUORIDE",
+      "density_g_cm3": 3.0000000000,
+      "radlen_cm": 9.7736131065,
+      "intlen_cm": 32.1181946756,
+      "elements": [
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.3901172937
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.6098827063
+        }
+      ]
+    },
+    "G4_MAGNESIUM_OXIDE": {
+      "name": "G4_MAGNESIUM_OXIDE",
+      "density_g_cm3": 3.5800000000,
+      "radlen_cm": 7.8275822876,
+      "intlen_cm": 26.7323051305,
+      "elements": [
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.6030361955
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3969638045
+        }
+      ]
+    },
+    "G4_MAGNESIUM_TETRABORATE": {
+      "name": "G4_MAGNESIUM_TETRABORATE",
+      "density_g_cm3": 2.5300000000,
+      "radlen_cm": 14.0171151884,
+      "intlen_cm": 34.3098315005,
+      "elements": [
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.1353701908
+        },
+        {
+          "symbol": "B",
+          "Z": 5,
+          "A_g_mol": 10.8110164000,
+          "mass_fraction": 0.2408538825
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6237759267
+        }
+      ]
+    },
+    "G4_MERCURIC_IODIDE": {
+      "name": "G4_MERCURIC_IODIDE",
+      "density_g_cm3": 6.3600000000,
+      "radlen_cm": 1.1695626925,
+      "intlen_cm": 29.4979745172,
+      "elements": [
+        {
+          "symbol": "Hg",
+          "Z": 80,
+          "A_g_mol": 200.5991002000,
+          "mass_fraction": 0.4414523895
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.5585476105
+        }
+      ]
+    },
+    "G4_METHANE": {
+      "name": "G4_METHANE",
+      "density_g_cm3": 0.0006671510,
+      "radlen_cm": 69648.1895684307,
+      "intlen_cm": 90727.2666787782,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7486823647
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.2513176353
+        }
+      ]
+    },
+    "G4_METHANOL": {
+      "name": "G4_METHANOL",
+      "density_g_cm3": 0.7914000000,
+      "radlen_cm": 49.8277776201,
+      "intlen_cm": 90.6875121309,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.3748448189
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1258278783
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4993273028
+        }
+      ]
+    },
+    "G4_MIX_D_WAX": {
+      "name": "G4_MIX_D_WAX",
+      "density_g_cm3": 0.9900000000,
+      "radlen_cm": 42.4388764028,
+      "intlen_cm": 70.0170389774,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1340400000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7779600000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0350200000
+        },
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.0385940000
+        },
+        {
+          "symbol": "Ti",
+          "Z": 22,
+          "A_g_mol": 47.8667173300,
+          "mass_fraction": 0.0143860000
+        }
+      ]
+    },
+    "G4_MS20_TISSUE": {
+      "name": "G4_MS20_TISSUE",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 38.2901787990,
+      "intlen_cm": 75.6659085615,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0811920000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5834420000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0177980000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1863810000
+        },
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 0.1302870000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0009000000
+        }
+      ]
+    },
+    "G4_MUSCLE_SKELETAL_ICRP": {
+      "name": "G4_MUSCLE_SKELETAL_ICRP",
+      "density_g_cm3": 1.0500000000,
+      "radlen_cm": 35.0573564270,
+      "intlen_cm": 71.8808850701,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1020000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1430000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0340000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7100000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0030000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0040000000
+        }
+      ]
+    },
+    "G4_MUSCLE_STRIATED_ICRU": {
+      "name": "G4_MUSCLE_STRIATED_ICRU",
+      "density_g_cm3": 1.0400000000,
+      "radlen_cm": 35.2882455673,
+      "intlen_cm": 72.6659485329,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1021021021
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1231231231
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0350350350
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7297297297
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0010010010
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0020020020
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0040040040
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0030030030
+        }
+      ]
+    },
+    "G4_MUSCLE_WITHOUT_SUCROSE": {
+      "name": "G4_MUSCLE_WITHOUT_SUCROSE",
+      "density_g_cm3": 1.0700000000,
+      "radlen_cm": 34.5507134115,
+      "intlen_cm": 70.5306459594,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1019690000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1200580000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0354510000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7425220000
+        }
+      ]
+    },
+    "G4_MUSCLE_WITH_SUCROSE": {
+      "name": "G4_MUSCLE_WITH_SUCROSE",
+      "density_g_cm3": 1.1100000000,
+      "radlen_cm": 33.5030358691,
+      "intlen_cm": 68.1084691034,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0982340982
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1562141562
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0354510355
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7101007101
+        }
+      ]
+    },
+    "G4_MYLAR": {
+      "name": "G4_MYLAR",
+      "density_g_cm3": 1.4000000000,
+      "radlen_cm": 28.5364043256,
+      "intlen_cm": 55.9231513594,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6250108323
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0419607171
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3330284506
+        }
+      ]
+    },
+    "G4_Mg": {
+      "name": "G4_Mg",
+      "density_g_cm3": 1.7400000000,
+      "radlen_cm": 14.3859171086,
+      "intlen_cm": 58.2663034870,
+      "elements": [
+        {
+          "symbol": "Mg",
+          "Z": 12,
+          "A_g_mol": 24.3050157600,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Mn": {
+      "name": "G4_Mn",
+      "density_g_cm3": 7.4400000000,
+      "radlen_cm": 1.9677221865,
+      "intlen_cm": 17.8835098670,
+      "elements": [
+        {
+          "symbol": "Mn",
+          "Z": 25,
+          "A_g_mol": 54.9380000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Mo": {
+      "name": "G4_Mo",
+      "density_g_cm3": 10.2200000000,
+      "radlen_cm": 0.9591074077,
+      "intlen_cm": 15.6772760730,
+      "elements": [
+        {
+          "symbol": "Mo",
+          "Z": 42,
+          "A_g_mol": 95.9312864600,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_N": {
+      "name": "G4_N",
+      "density_g_cm3": 0.0011652000,
+      "radlen_cm": 32602.2350168044,
+      "intlen_cm": 72406.9506998844,
+      "elements": [
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_N,N-DIMETHYL_FORMAMIDE": {
+      "name": "G4_N,N-DIMETHYL_FORMAMIDE",
+      "density_g_cm3": 0.9487000000,
+      "radlen_cm": 42.9986906208,
+      "intlen_cm": 77.1577428431,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4929574510
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0965276183
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1916269163
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2188880144
+        }
+      ]
+    },
+    "G4_N-BUTYL_ALCOHOL": {
+      "name": "G4_N-BUTYL_ALCOHOL",
+      "density_g_cm3": 0.8098000000,
+      "radlen_cm": 52.2322550404,
+      "intlen_cm": 85.6406080185,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6481626481
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1359844906
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2158528613
+        }
+      ]
+    },
+    "G4_N-HEPTANE": {
+      "name": "G4_N-HEPTANE",
+      "density_g_cm3": 0.6837600000,
+      "radlen_cm": 65.8657382833,
+      "intlen_cm": 97.0698845209,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8390549213
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1609450787
+        }
+      ]
+    },
+    "G4_N-HEXANE": {
+      "name": "G4_N-HEXANE",
+      "density_g_cm3": 0.6603000000,
+      "radlen_cm": 68.2710686267,
+      "intlen_cm": 100.2185093356,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8362509531
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1637490469
+        }
+      ]
+    },
+    "G4_N-PENTANE": {
+      "name": "G4_N-PENTANE",
+      "density_g_cm3": 0.6262000000,
+      "radlen_cm": 72.0844513772,
+      "intlen_cm": 105.2394466274,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8323567353
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1676432647
+        }
+      ]
+    },
+    "G4_N-PROPYL_ALCOHOL": {
+      "name": "G4_N-PROPYL_ALCOHOL",
+      "density_g_cm3": 0.8035000000,
+      "radlen_cm": 51.9709503464,
+      "intlen_cm": 86.8320985664,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5995862193
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1341793689
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2662344118
+        }
+      ]
+    },
+    "G4_NAPHTHALENE": {
+      "name": "G4_NAPHTHALENE",
+      "density_g_cm3": 1.1450000000,
+      "radlen_cm": 38.0628209006,
+      "intlen_cm": 64.7481877565,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9370876957
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0629123043
+        }
+      ]
+    },
+    "G4_NEOPRENE": {
+      "name": "G4_NEOPRENE",
+      "density_g_cm3": 1.2300000000,
+      "radlen_cm": 23.6452775257,
+      "intlen_cm": 68.4404103466,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5426421718
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0569231500
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.4004346781
+        }
+      ]
+    },
+    "G4_NITROBENZENE": {
+      "name": "G4_NITROBENZENE",
+      "density_g_cm3": 1.1986700000,
+      "radlen_cm": 33.4429484913,
+      "intlen_cm": 65.3377994376,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5853676418
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0409367005
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1137747242
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2599209335
+        }
+      ]
+    },
+    "G4_NITROUS_OXIDE": {
+      "name": "G4_NITROUS_OXIDE",
+      "density_g_cm3": 0.0018309400,
+      "radlen_cm": 19953.4404326249,
+      "intlen_cm": 46817.4565215888,
+      "elements": [
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.6364843009
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3635156991
+        }
+      ]
+    },
+    "G4_NYLON-11_RILSAN": {
+      "name": "G4_NYLON-11_RILSAN",
+      "density_g_cm3": 1.4250000000,
+      "radlen_cm": 30.1506780146,
+      "intlen_cm": 49.4620432566,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1154758845
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7208182792
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0764169236
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0872889127
+        }
+      ]
+    },
+    "G4_NYLON-6-10": {
+      "name": "G4_NYLON-6-10",
+      "density_g_cm3": 1.1400000000,
+      "radlen_cm": 37.2399939034,
+      "intlen_cm": 62.6184623928,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1070620000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6804490000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0991890000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1133000000
+        }
+      ]
+    },
+    "G4_NYLON-6-6": {
+      "name": "G4_NYLON-6-6",
+      "density_g_cm3": 1.1400000000,
+      "radlen_cm": 36.7677016597,
+      "intlen_cm": 63.4952151640,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6368481720
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0979811903
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1237807148
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1413899228
+        }
+      ]
+    },
+    "G4_NYLON-8062": {
+      "name": "G4_NYLON-8062",
+      "density_g_cm3": 1.0800000000,
+      "radlen_cm": 38.9258725316,
+      "intlen_cm": 66.5604267341,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1035091035
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6484156484
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0995360995
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1485391485
+        }
+      ]
+    },
+    "G4_Na": {
+      "name": "G4_Na",
+      "density_g_cm3": 0.9710000000,
+      "radlen_cm": 28.5646359402,
+      "intlen_cm": 102.4929311883,
+      "elements": [
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Nb": {
+      "name": "G4_Nb",
+      "density_g_cm3": 8.5700000000,
+      "radlen_cm": 1.1578315182,
+      "intlen_cm": 18.4970498911,
+      "elements": [
+        {
+          "symbol": "Nb",
+          "Z": 41,
+          "A_g_mol": 92.9064000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Nd": {
+      "name": "G4_Nd",
+      "density_g_cm3": 6.9000000000,
+      "radlen_cm": 1.1166740406,
+      "intlen_cm": 26.6017647572,
+      "elements": [
+        {
+          "symbol": "Nd",
+          "Z": 60,
+          "A_g_mol": 144.2362360000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ne": {
+      "name": "G4_Ne",
+      "density_g_cm3": 0.0008385050,
+      "radlen_cm": 34504.7957012515,
+      "intlen_cm": 113641.3080885588,
+      "elements": [
+        {
+          "symbol": "Ne",
+          "Z": 10,
+          "A_g_mol": 20.1800112800,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ni": {
+      "name": "G4_Ni",
+      "density_g_cm3": 8.9020000000,
+      "radlen_cm": 1.4242208745,
+      "intlen_cm": 15.2795322887,
+      "elements": [
+        {
+          "symbol": "Ni",
+          "Z": 28,
+          "A_g_mol": 58.6933251009,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Np": {
+      "name": "G4_Np",
+      "density_g_cm3": 20.2500000000,
+      "radlen_cm": 0.2896763497,
+      "intlen_cm": 10.6968313874,
+      "elements": [
+        {
+          "symbol": "Np",
+          "Z": 93,
+          "A_g_mol": 237.0480000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_O": {
+      "name": "G4_O",
+      "density_g_cm3": 0.0013315100,
+      "radlen_cm": 25713.7634595345,
+      "intlen_cm": 66235.5975584616,
+      "elements": [
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_OCTADECANOL": {
+      "name": "G4_OCTADECANOL",
+      "density_g_cm3": 0.8120000000,
+      "radlen_cm": 54.2695775063,
+      "intlen_cm": 83.8467764328,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1415990478
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7992522572
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0591486950
+        }
+      ]
+    },
+    "G4_OCTANE": {
+      "name": "G4_OCTANE",
+      "density_g_cm3": 0.7026000000,
+      "radlen_cm": 64.0534438285,
+      "intlen_cm": 94.6809469695,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8411702684
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1588297316
+        }
+      ]
+    },
+    "G4_Os": {
+      "name": "G4_Os",
+      "density_g_cm3": 22.5700000000,
+      "radlen_cm": 0.2958609866,
+      "intlen_cm": 8.9185046979,
+      "elements": [
+        {
+          "symbol": "Os",
+          "Z": 76,
+          "A_g_mol": 190.2245546000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_P": {
+      "name": "G4_P",
+      "density_g_cm3": 2.2000000000,
+      "radlen_cm": 9.6387902637,
+      "intlen_cm": 49.9624310154,
+      "elements": [
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_PARAFFIN": {
+      "name": "G4_PARAFFIN",
+      "density_g_cm3": 0.9300000000,
+      "radlen_cm": 48.2237383379,
+      "intlen_cm": 72.3210868975,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8513873152
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1486126848
+        }
+      ]
+    },
+    "G4_PHOSPHORIC_ACID": {
+      "name": "G4_PHOSPHORIC_ACID",
+      "density_g_cm3": 1.8700000000,
+      "radlen_cm": 15.5141283621,
+      "intlen_cm": 47.9082638597,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0308568456
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.3160747168
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6530684376
+        }
+      ]
+    },
+    "G4_PHOTO_EMULSION": {
+      "name": "G4_PHOTO_EMULSION",
+      "density_g_cm3": 3.8150000000,
+      "radlen_cm": 2.9706503474,
+      "intlen_cm": 35.0478714990,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0141000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0722610000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0193200000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.0661010000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0018900000
+        },
+        {
+          "symbol": "Br",
+          "Z": 35,
+          "A_g_mol": 79.9035138000,
+          "mass_fraction": 0.3491030000
+        },
+        {
+          "symbol": "Ag",
+          "Z": 47,
+          "A_g_mol": 107.8682200000,
+          "mass_fraction": 0.4741050000
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.0031200000
+        }
+      ]
+    },
+    "G4_PLASTIC_SC_VINYLTOLUENE": {
+      "name": "G4_PLASTIC_SC_VINYLTOLUENE",
+      "density_g_cm3": 1.0320000000,
+      "radlen_cm": 42.5441996486,
+      "intlen_cm": 69.9693874192,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9147085318
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0852914682
+        }
+      ]
+    },
+    "G4_PLEXIGLASS": {
+      "name": "G4_PLEXIGLASS",
+      "density_g_cm3": 1.1900000000,
+      "radlen_cm": 34.0748806544,
+      "intlen_cm": 62.6702055110,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5998410709
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0805418407
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3196170884
+        }
+      ]
+    },
+    "G4_PLUTONIUM_DIOXIDE": {
+      "name": "G4_PLUTONIUM_DIOXIDE",
+      "density_g_cm3": 11.4600000000,
+      "radlen_cm": 0.5723242927,
+      "intlen_cm": 16.2912350677,
+      "elements": [
+        {
+          "symbol": "Pu",
+          "Z": 94,
+          "A_g_mol": 244.0640000000,
+          "mass_fraction": 0.8840887543
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1159112457
+        }
+      ]
+    },
+    "G4_POLYACRYLONITRILE": {
+      "name": "G4_POLYACRYLONITRILE",
+      "density_g_cm3": 1.1700000000,
+      "radlen_cm": 35.9776646539,
+      "intlen_cm": 64.6096169435,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6790483898
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0569857271
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.2639658832
+        }
+      ]
+    },
+    "G4_POLYCARBONATE": {
+      "name": "G4_POLYCARBONATE",
+      "density_g_cm3": 1.2000000000,
+      "radlen_cm": 34.5873361608,
+      "intlen_cm": 63.3495193368,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7557453702
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0554943691
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1887602607
+        }
+      ]
+    },
+    "G4_POLYCHLOROSTYRENE": {
+      "name": "G4_POLYCHLOROSTYRENE",
+      "density_g_cm3": 1.3000000000,
+      "radlen_cm": 25.3754585368,
+      "intlen_cm": 62.3930757123,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6932901610
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0509082842
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.2558015548
+        }
+      ]
+    },
+    "G4_POLYETHYLENE": {
+      "name": "G4_POLYETHYLENE",
+      "density_g_cm3": 0.9400000000,
+      "radlen_cm": 47.6316902019,
+      "intlen_cm": 71.9328468651,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8562817123
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1437182877
+        }
+      ]
+    },
+    "G4_POLYOXYMETHYLENE": {
+      "name": "G4_POLYOXYMETHYLENE",
+      "density_g_cm3": 1.4250000000,
+      "radlen_cm": 26.9940588984,
+      "intlen_cm": 54.1869646318,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4000110924
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0671378455
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5328510621
+        }
+      ]
+    },
+    "G4_POLYPROPYLENE": {
+      "name": "G4_POLYPROPYLENE",
+      "density_g_cm3": 0.9000000000,
+      "radlen_cm": 49.7486542109,
+      "intlen_cm": 75.1298622814,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8562817123
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1437182877
+        }
+      ]
+    },
+    "G4_POLYSTYRENE": {
+      "name": "G4_POLYSTYRENE",
+      "density_g_cm3": 1.0600000000,
+      "radlen_cm": 41.3125056266,
+      "intlen_cm": 68.7498786660,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9225773293
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0774226707
+        }
+      ]
+    },
+    "G4_POLYTRIFLUOROCHLOROETHYLENE": {
+      "name": "G4_POLYTRIFLUOROCHLOROETHYLENE",
+      "density_g_cm3": 2.1000000000,
+      "radlen_cm": 13.4211774188,
+      "intlen_cm": 45.5231505449,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2062473447
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.4893583661
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.3043942892
+        }
+      ]
+    },
+    "G4_POLYVINYLIDENE_CHLORIDE": {
+      "name": "G4_POLYVINYLIDENE_CHLORIDE",
+      "density_g_cm3": 1.7000000000,
+      "radlen_cm": 13.3466912811,
+      "intlen_cm": 58.5490734291,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2477909327
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0207946100
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.7314144572
+        }
+      ]
+    },
+    "G4_POLYVINYLIDENE_FLUORIDE": {
+      "name": "G4_POLYVINYLIDENE_FLUORIDE",
+      "density_g_cm3": 1.7600000000,
+      "radlen_cm": 20.8089540539,
+      "intlen_cm": 47.6128231526,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.3751353170
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0314813482
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.5933833348
+        }
+      ]
+    },
+    "G4_POLYVINYL_ACETATE": {
+      "name": "G4_POLYVINYL_ACETATE",
+      "density_g_cm3": 1.1900000000,
+      "radlen_cm": 33.5589610921,
+      "intlen_cm": 63.7392761655,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5580589687
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0702484460
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3716925853
+        }
+      ]
+    },
+    "G4_POLYVINYL_ALCOHOL": {
+      "name": "G4_POLYVINYL_ALCOHOL",
+      "density_g_cm3": 1.3000000000,
+      "radlen_cm": 30.9791700346,
+      "intlen_cm": 56.8283796029,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5452903684
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0915215132
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3631881183
+        }
+      ]
+    },
+    "G4_POLYVINYL_BUTYRAL": {
+      "name": "G4_POLYVINYL_BUTYRAL",
+      "density_g_cm3": 1.1200000000,
+      "radlen_cm": 37.2445284119,
+      "intlen_cm": 64.6185702523,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6757292578
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0992375747
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2250331675
+        }
+      ]
+    },
+    "G4_POLYVINYL_CHLORIDE": {
+      "name": "G4_POLYVINYL_CHLORIDE",
+      "density_g_cm3": 1.3000000000,
+      "radlen_cm": 19.6259713893,
+      "intlen_cm": 69.2301257138,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.3843566728
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0483828062
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.5672605210
+        }
+      ]
+    },
+    "G4_POLYVINYL_PYRROLIDONE": {
+      "name": "G4_POLYVINYL_PYRROLIDONE",
+      "density_g_cm3": 1.2500000000,
+      "radlen_cm": 33.3295432994,
+      "intlen_cm": 59.0516806099,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.6483992503
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0816204778
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1260258351
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1439544368
+        }
+      ]
+    },
+    "G4_POTASSIUM_IODIDE": {
+      "name": "G4_POTASSIUM_IODIDE",
+      "density_g_cm3": 3.1300000000,
+      "radlen_cm": 3.0794662292,
+      "intlen_cm": 50.4789672731,
+      "elements": [
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.2355286329
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.7644713671
+        }
+      ]
+    },
+    "G4_POTASSIUM_OXIDE": {
+      "name": "G4_POTASSIUM_OXIDE",
+      "density_g_cm3": 2.3200000000,
+      "radlen_cm": 8.1473889734,
+      "intlen_cm": 48.3539578260,
+      "elements": [
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.8301478368
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1698521632
+        }
+      ]
+    },
+    "G4_PROPANE": {
+      "name": "G4_PROPANE",
+      "density_g_cm3": 0.0018793900,
+      "radlen_cm": 24143.4343892002,
+      "intlen_cm": 34507.9467355684,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8171359205
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1828640795
+        }
+      ]
+    },
+    "G4_PYRIDINE": {
+      "name": "G4_PYRIDINE",
+      "density_g_cm3": 0.9819000000,
+      "radlen_cm": 43.4238519327,
+      "intlen_cm": 76.0528817127,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.7592106765
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0637129445
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1770763790
+        }
+      ]
+    },
+    "G4_Pa": {
+      "name": "G4_Pa",
+      "density_g_cm3": 15.3700000000,
+      "radlen_cm": 0.3860695338,
+      "intlen_cm": 13.9729283036,
+      "elements": [
+        {
+          "symbol": "Pa",
+          "Z": 91,
+          "A_g_mol": 231.0360000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Pb": {
+      "name": "G4_Pb",
+      "density_g_cm3": 11.3500000000,
+      "radlen_cm": 0.5612532628,
+      "intlen_cm": 18.2479470310,
+      "elements": [
+        {
+          "symbol": "Pb",
+          "Z": 82,
+          "A_g_mol": 207.2170000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_PbWO4": {
+      "name": "G4_PbWO4",
+      "density_g_cm3": 8.2800000000,
+      "radlen_cm": 0.8924531919,
+      "intlen_cm": 20.7397427149,
+      "elements": [
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1406366195
+        },
+        {
+          "symbol": "Pb",
+          "Z": 82,
+          "A_g_mol": 207.2170000000,
+          "mass_fraction": 0.4553657612
+        },
+        {
+          "symbol": "W",
+          "Z": 74,
+          "A_g_mol": 183.8416100000,
+          "mass_fraction": 0.4039976193
+        }
+      ]
+    },
+    "G4_Pd": {
+      "name": "G4_Pd",
+      "density_g_cm3": 12.0200000000,
+      "radlen_cm": 0.7657167657,
+      "intlen_cm": 13.7984874589,
+      "elements": [
+        {
+          "symbol": "Pd",
+          "Z": 46,
+          "A_g_mol": 106.4151876000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Pm": {
+      "name": "G4_Pm",
+      "density_g_cm3": 7.2200000000,
+      "radlen_cm": 1.0408459865,
+      "intlen_cm": 25.4624387556,
+      "elements": [
+        {
+          "symbol": "Pm",
+          "Z": 61,
+          "A_g_mol": 144.9130000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Po": {
+      "name": "G4_Po",
+      "density_g_cm3": 9.3200000000,
+      "radlen_cm": 0.6610916001,
+      "intlen_cm": 22.2854698005,
+      "elements": [
+        {
+          "symbol": "Po",
+          "Z": 84,
+          "A_g_mol": 208.9820000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Pr": {
+      "name": "G4_Pr",
+      "density_g_cm3": 6.7100000000,
+      "radlen_cm": 1.1562026576,
+      "intlen_cm": 27.1429747446,
+      "elements": [
+        {
+          "symbol": "Pr",
+          "Z": 59,
+          "A_g_mol": 140.9080000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Pt": {
+      "name": "G4_Pt",
+      "density_g_cm3": 21.4500000000,
+      "radlen_cm": 0.3050532706,
+      "intlen_cm": 9.4633205278,
+      "elements": [
+        {
+          "symbol": "Pt",
+          "Z": 78,
+          "A_g_mol": 195.0780035700,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Pu": {
+      "name": "G4_Pu",
+      "density_g_cm3": 19.8400000000,
+      "radlen_cm": 0.2989048704,
+      "intlen_cm": 11.0245529144,
+      "elements": [
+        {
+          "symbol": "Pu",
+          "Z": 94,
+          "A_g_mol": 244.0640000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Pyrex_Glass": {
+      "name": "G4_Pyrex_Glass",
+      "density_g_cm3": 2.2300000000,
+      "radlen_cm": 12.6325375693,
+      "intlen_cm": 42.2910635276,
+      "elements": [
+        {
+          "symbol": "B",
+          "Z": 5,
+          "A_g_mol": 10.8110164000,
+          "mass_fraction": 0.0400639199
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5395609209
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0281909436
+        },
+        {
+          "symbol": "Al",
+          "Z": 13,
+          "A_g_mol": 26.9815000000,
+          "mass_fraction": 0.0116439767
+        },
+        {
+          "symbol": "Si",
+          "Z": 14,
+          "A_g_mol": 28.0853614555,
+          "mass_fraction": 0.3772192456
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0033209934
+        }
+      ]
+    },
+    "G4_RUBBER_BUTYL": {
+      "name": "G4_RUBBER_BUTYL",
+      "density_g_cm3": 0.9200000000,
+      "radlen_cm": 48.6670416944,
+      "intlen_cm": 73.4971873425,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1437110000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8562890000
+        }
+      ]
+    },
+    "G4_RUBBER_NATURAL": {
+      "name": "G4_RUBBER_NATURAL",
+      "density_g_cm3": 0.9200000000,
+      "radlen_cm": 48.2532262024,
+      "intlen_cm": 75.5816000621,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1183710000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8816290000
+        }
+      ]
+    },
+    "G4_RUBBER_NEOPRENE": {
+      "name": "G4_RUBBER_NEOPRENE",
+      "density_g_cm3": 1.2300000000,
+      "radlen_cm": 23.6452744201,
+      "intlen_cm": 68.4406876941,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0569200000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5426460000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.4004340000
+        }
+      ]
+    },
+    "G4_Ra": {
+      "name": "G4_Ra",
+      "density_g_cm3": 5.0000000000,
+      "radlen_cm": 1.2298658749,
+      "intlen_cm": 42.6399710179,
+      "elements": [
+        {
+          "symbol": "Ra",
+          "Z": 88,
+          "A_g_mol": 226.0250000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Rb": {
+      "name": "G4_Rb",
+      "density_g_cm3": 1.5320000000,
+      "radlen_cm": 7.1977407506,
+      "intlen_cm": 100.6336626726,
+      "elements": [
+        {
+          "symbol": "Rb",
+          "Z": 37,
+          "A_g_mol": 85.4676764200,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Re": {
+      "name": "G4_Re",
+      "density_g_cm3": 21.0200000000,
+      "radlen_cm": 0.3182831922,
+      "intlen_cm": 9.5082503276,
+      "elements": [
+        {
+          "symbol": "Re",
+          "Z": 75,
+          "A_g_mol": 186.2068780000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Rh": {
+      "name": "G4_Rh",
+      "density_g_cm3": 12.4100000000,
+      "radlen_cm": 0.7466192395,
+      "intlen_cm": 13.2162992461,
+      "elements": [
+        {
+          "symbol": "Rh",
+          "Z": 45,
+          "A_g_mol": 102.9060000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Rn": {
+      "name": "G4_Rn",
+      "density_g_cm3": 0.0090066200,
+      "radlen_cm": 697.7766671691,
+      "intlen_cm": 23530.7426900032,
+      "elements": [
+        {
+          "symbol": "Rn",
+          "Z": 86,
+          "A_g_mol": 222.0180000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ru": {
+      "name": "G4_Ru",
+      "density_g_cm3": 12.4100000000,
+      "radlen_cm": 0.7640666774,
+      "intlen_cm": 13.1370029745,
+      "elements": [
+        {
+          "symbol": "Ru",
+          "Z": 44,
+          "A_g_mol": 101.0648187900,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_S": {
+      "name": "G4_S",
+      "density_g_cm3": 2.0000000000,
+      "radlen_cm": 9.7482931365,
+      "intlen_cm": 55.5972779233,
+      "elements": [
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_SILICON_DIOXIDE": {
+      "name": "G4_SILICON_DIOXIDE",
+      "density_g_cm3": 2.3200000000,
+      "radlen_cm": 11.6577276645,
+      "intlen_cm": 41.3174239290,
+      "elements": [
+        {
+          "symbol": "Si",
+          "Z": 14,
+          "A_g_mol": 28.0853614555,
+          "mass_fraction": 0.4674338418
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5325661582
+        }
+      ]
+    },
+    "G4_SILVER_BROMIDE": {
+      "name": "G4_SILVER_BROMIDE",
+      "density_g_cm3": 6.4730000000,
+      "radlen_cm": 1.5250930816,
+      "intlen_cm": 24.6362003753,
+      "elements": [
+        {
+          "symbol": "Ag",
+          "Z": 47,
+          "A_g_mol": 107.8682200000,
+          "mass_fraction": 0.5744646322
+        },
+        {
+          "symbol": "Br",
+          "Z": 35,
+          "A_g_mol": 79.9035138000,
+          "mass_fraction": 0.4255353678
+        }
+      ]
+    },
+    "G4_SILVER_CHLORIDE": {
+      "name": "G4_SILVER_CHLORIDE",
+      "density_g_cm3": 5.5600000000,
+      "radlen_cm": 1.8592358479,
+      "intlen_cm": 26.9699324435,
+      "elements": [
+        {
+          "symbol": "Ag",
+          "Z": 47,
+          "A_g_mol": 107.8682200000,
+          "mass_fraction": 0.7526348232
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.2473651768
+        }
+      ]
+    },
+    "G4_SILVER_HALIDES": {
+      "name": "G4_SILVER_HALIDES",
+      "density_g_cm3": 6.4700000000,
+      "radlen_cm": 1.5245239630,
+      "intlen_cm": 24.6583577333,
+      "elements": [
+        {
+          "symbol": "Br",
+          "Z": 35,
+          "A_g_mol": 79.9035138000,
+          "mass_fraction": 0.4228950000
+        },
+        {
+          "symbol": "Ag",
+          "Z": 47,
+          "A_g_mol": 107.8682200000,
+          "mass_fraction": 0.5737480000
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.0033570000
+        }
+      ]
+    },
+    "G4_SILVER_IODIDE": {
+      "name": "G4_SILVER_IODIDE",
+      "density_g_cm3": 6.0100000000,
+      "radlen_cm": 1.4473505292,
+      "intlen_cm": 28.5353855145,
+      "elements": [
+        {
+          "symbol": "Ag",
+          "Z": 47,
+          "A_g_mol": 107.8682200000,
+          "mass_fraction": 0.4594590450
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.5405409550
+        }
+      ]
+    },
+    "G4_SKIN_ICRP": {
+      "name": "G4_SKIN_ICRP",
+      "density_g_cm3": 1.0900000000,
+      "radlen_cm": 34.3047957676,
+      "intlen_cm": 69.0045449724,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1000000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2040000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0420000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6450000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0030000000
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0010000000
+        }
+      ]
+    },
+    "G4_SODIUM_CARBONATE": {
+      "name": "G4_SODIUM_CARBONATE",
+      "density_g_cm3": 2.5320000000,
+      "radlen_cm": 12.5293001203,
+      "intlen_cm": 36.2077642513,
+      "elements": [
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.4338168452
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1133211199
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4528620349
+        }
+      ]
+    },
+    "G4_SODIUM_IODIDE": {
+      "name": "G4_SODIUM_IODIDE",
+      "density_g_cm3": 3.6670000000,
+      "radlen_cm": 2.5882212769,
+      "intlen_cm": 42.9136935370,
+      "elements": [
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.1533739221
+        },
+        {
+          "symbol": "I",
+          "Z": 53,
+          "A_g_mol": 126.9040000000,
+          "mass_fraction": 0.8466260779
+        }
+      ]
+    },
+    "G4_SODIUM_MONOXIDE": {
+      "name": "G4_SODIUM_MONOXIDE",
+      "density_g_cm3": 2.2700000000,
+      "radlen_cm": 12.8484696099,
+      "intlen_cm": 42.4347669192,
+      "elements": [
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.7418578408
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2581421592
+        }
+      ]
+    },
+    "G4_SODIUM_NITRATE": {
+      "name": "G4_SODIUM_NITRATE",
+      "density_g_cm3": 2.2610000000,
+      "radlen_cm": 14.4612324186,
+      "intlen_cm": 39.9375053268,
+      "elements": [
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.2704849729
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1647957147
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5647193123
+        }
+      ]
+    },
+    "G4_STAINLESS-STEEL": {
+      "name": "G4_STAINLESS-STEEL",
+      "density_g_cm3": 8.0000000000,
+      "radlen_cm": 1.7380670645,
+      "intlen_cm": 16.6780570974,
+      "elements": [
+        {
+          "symbol": "Fe",
+          "Z": 26,
+          "A_g_mol": 55.8451107980,
+          "mass_fraction": 0.7462128746
+        },
+        {
+          "symbol": "Cr",
+          "Z": 24,
+          "A_g_mol": 51.9961301370,
+          "mass_fraction": 0.1690010443
+        },
+        {
+          "symbol": "Ni",
+          "Z": 28,
+          "A_g_mol": 58.6933251009,
+          "mass_fraction": 0.0847860811
+        }
+      ]
+    },
+    "G4_STILBENE": {
+      "name": "G4_STILBENE",
+      "density_g_cm3": 0.9707000000,
+      "radlen_cm": 44.9595141781,
+      "intlen_cm": 75.9942943910,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9328955096
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0671044904
+        }
+      ]
+    },
+    "G4_SUCROSE": {
+      "name": "G4_SUCROSE",
+      "density_g_cm3": 1.5805000000,
+      "radlen_cm": 24.4231162245,
+      "intlen_cm": 48.9185997692,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4210638981
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0647820686
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.5141540333
+        }
+      ]
+    },
+    "G4_Sb": {
+      "name": "G4_Sb",
+      "density_g_cm3": 6.6910000000,
+      "radlen_cm": 1.3040127628,
+      "intlen_cm": 25.9265676022,
+      "elements": [
+        {
+          "symbol": "Sb",
+          "Z": 51,
+          "A_g_mol": 121.7598000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Sc": {
+      "name": "G4_Sc",
+      "density_g_cm3": 2.9890000000,
+      "radlen_cm": 5.5354470594,
+      "intlen_cm": 41.6361977932,
+      "elements": [
+        {
+          "symbol": "Sc",
+          "Z": 21,
+          "A_g_mol": 44.9559000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Se": {
+      "name": "G4_Se",
+      "density_g_cm3": 4.5000000000,
+      "radlen_cm": 2.6462517652,
+      "intlen_cm": 33.3674841789,
+      "elements": [
+        {
+          "symbol": "Se",
+          "Z": 34,
+          "A_g_mol": 78.9593734300,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Si": {
+      "name": "G4_Si",
+      "density_g_cm3": 2.3300000000,
+      "radlen_cm": 9.3660702922,
+      "intlen_cm": 45.6603073704,
+      "elements": [
+        {
+          "symbol": "Si",
+          "Z": 14,
+          "A_g_mol": 28.0853614555,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Sm": {
+      "name": "G4_Sm",
+      "density_g_cm3": 7.4600000000,
+      "radlen_cm": 1.0152448223,
+      "intlen_cm": 24.9485982224,
+      "elements": [
+        {
+          "symbol": "Sm",
+          "Z": 62,
+          "A_g_mol": 150.3663619000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Sn": {
+      "name": "G4_Sn",
+      "density_g_cm3": 7.3100000000,
+      "radlen_cm": 1.2063713058,
+      "intlen_cm": 23.5313378422,
+      "elements": [
+        {
+          "symbol": "Sn",
+          "Z": 50,
+          "A_g_mol": 118.7101218000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Sr": {
+      "name": "G4_Sr",
+      "density_g_cm3": 2.5400000000,
+      "radlen_cm": 4.2369989713,
+      "intlen_cm": 61.2016634807,
+      "elements": [
+        {
+          "symbol": "Sr",
+          "Z": 38,
+          "A_g_mol": 87.6166395000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_TEFLON": {
+      "name": "G4_TEFLON",
+      "density_g_cm3": 2.2000000000,
+      "radlen_cm": 15.8385014262,
+      "intlen_cm": 40.8310561331,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2401785261
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.7598214739
+        }
+      ]
+    },
+    "G4_TERPHENYL": {
+      "name": "G4_TERPHENYL",
+      "density_g_cm3": 1.2400000000,
+      "radlen_cm": 35.1277340003,
+      "intlen_cm": 59.9049067935,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9387281833
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0612718167
+        }
+      ]
+    },
+    "G4_TESTIS_ICRP": {
+      "name": "G4_TESTIS_ICRP",
+      "density_g_cm3": 1.0400000000,
+      "radlen_cm": 35.1692276422,
+      "intlen_cm": 72.4725513802,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1060000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0990000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0200000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7660000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0020000000
+        }
+      ]
+    },
+    "G4_TETRACHLOROETHYLENE": {
+      "name": "G4_TETRACHLOROETHYLENE",
+      "density_g_cm3": 1.6250000000,
+      "radlen_cm": 12.8873634663,
+      "intlen_cm": 66.5667035399,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1448544708
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.8551455292
+        }
+      ]
+    },
+    "G4_THALLIUM_CHLORIDE": {
+      "name": "G4_THALLIUM_CHLORIDE",
+      "density_g_cm3": 7.0040000000,
+      "radlen_cm": 1.0166713986,
+      "intlen_cm": 26.3467114309,
+      "elements": [
+        {
+          "symbol": "Tl",
+          "Z": 81,
+          "A_g_mol": 204.3829295200,
+          "mass_fraction": 0.8521796274
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.1478203726
+        }
+      ]
+    },
+    "G4_THYMINE": {
+      "name": "G4_THYMINE",
+      "density_g_cm3": 1.4800000000,
+      "radlen_cm": 26.8429768410,
+      "intlen_cm": 52.7013719035,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0479539269
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4761870282
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.2221293174
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2537297275
+        }
+      ]
+    },
+    "G4_TISSUE-METHANE": {
+      "name": "G4_TISSUE-METHANE",
+      "density_g_cm3": 0.0010640900,
+      "radlen_cm": 37431.0260905174,
+      "intlen_cm": 68943.1775981619,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1018690000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4561790000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0351720000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4067800000
+        }
+      ]
+    },
+    "G4_TISSUE-PROPANE": {
+      "name": "G4_TISSUE-PROPANE",
+      "density_g_cm3": 0.0018262800,
+      "radlen_cm": 22400.6777976263,
+      "intlen_cm": 39755.8870930692,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1026720000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5689400000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0350220000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2933660000
+        }
+      ]
+    },
+    "G4_TISSUE_SOFT_ICRP": {
+      "name": "G4_TISSUE_SOFT_ICRP",
+      "density_g_cm3": 1.0300000000,
+      "radlen_cm": 36.6945920182,
+      "intlen_cm": 72.2954858829,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1050000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2560000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0270000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.6020000000
+        },
+        {
+          "symbol": "Na",
+          "Z": 11,
+          "A_g_mol": 22.9898000000,
+          "mass_fraction": 0.0010000000
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "S",
+          "Z": 16,
+          "A_g_mol": 32.0661142600,
+          "mass_fraction": 0.0030000000
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.0020000000
+        },
+        {
+          "symbol": "K",
+          "Z": 19,
+          "A_g_mol": 39.0982931613,
+          "mass_fraction": 0.0020000000
+        }
+      ]
+    },
+    "G4_TISSUE_SOFT_ICRU-4": {
+      "name": "G4_TISSUE_SOFT_ICRU-4",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 36.8431452797,
+      "intlen_cm": 75.6496725291,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1010000000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1110000000
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.0260000000
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.7620000000
+        }
+      ]
+    },
+    "G4_TITANIUM_DIOXIDE": {
+      "name": "G4_TITANIUM_DIOXIDE",
+      "density_g_cm3": 4.2600000000,
+      "radlen_cm": 4.8120066363,
+      "intlen_cm": 25.3523138121,
+      "elements": [
+        {
+          "symbol": "Ti",
+          "Z": 22,
+          "A_g_mol": 47.8667173300,
+          "mass_fraction": 0.5993416236
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.4006583764
+        }
+      ]
+    },
+    "G4_TOLUENE": {
+      "name": "G4_TOLUENE",
+      "density_g_cm3": 0.8669000000,
+      "radlen_cm": 50.6840912009,
+      "intlen_cm": 83.0802585391,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9124848982
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0875151018
+        }
+      ]
+    },
+    "G4_TRICHLOROETHYLENE": {
+      "name": "G4_TRICHLOROETHYLENE",
+      "density_g_cm3": 1.4600000000,
+      "radlen_cm": 14.7632677276,
+      "intlen_cm": 71.7912794212,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1828297192
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0076715332
+        },
+        {
+          "symbol": "Cl",
+          "Z": 17,
+          "A_g_mol": 35.4525734000,
+          "mass_fraction": 0.8094987477
+        }
+      ]
+    },
+    "G4_TRIETHYL_PHOSPHATE": {
+      "name": "G4_TRIETHYL_PHOSPHATE",
+      "density_g_cm3": 1.0700000000,
+      "radlen_cm": 32.3802005558,
+      "intlen_cm": 72.7982710675,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.3956216481
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0830014017
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.3513359494
+        },
+        {
+          "symbol": "P",
+          "Z": 15,
+          "A_g_mol": 30.9738000000,
+          "mass_fraction": 0.1700410008
+        }
+      ]
+    },
+    "G4_TUNGSTEN_HEXAFLUORIDE": {
+      "name": "G4_TUNGSTEN_HEXAFLUORIDE",
+      "density_g_cm3": 2.4000000000,
+      "radlen_cm": 4.0495275513,
+      "intlen_cm": 57.8720027568,
+      "elements": [
+        {
+          "symbol": "W",
+          "Z": 74,
+          "A_g_mol": 183.8416100000,
+          "mass_fraction": 0.6172661226
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.3827338774
+        }
+      ]
+    },
+    "G4_Ta": {
+      "name": "G4_Ta",
+      "density_g_cm3": 16.6540000000,
+      "radlen_cm": 0.4093920370,
+      "intlen_cm": 11.8868655868,
+      "elements": [
+        {
+          "symbol": "Ta",
+          "Z": 73,
+          "A_g_mol": 180.9478798800,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Tb": {
+      "name": "G4_Tb",
+      "density_g_cm3": 8.2290000000,
+      "radlen_cm": 0.8939773235,
+      "intlen_cm": 23.0383704280,
+      "elements": [
+        {
+          "symbol": "Tb",
+          "Z": 65,
+          "A_g_mol": 158.9250000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Tc": {
+      "name": "G4_Tc",
+      "density_g_cm3": 11.5000000000,
+      "radlen_cm": 0.8331486453,
+      "intlen_cm": 14.0273332814,
+      "elements": [
+        {
+          "symbol": "Tc",
+          "Z": 43,
+          "A_g_mol": 97.9072000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Te": {
+      "name": "G4_Te",
+      "density_g_cm3": 6.2400000000,
+      "radlen_cm": 1.4145736790,
+      "intlen_cm": 28.2381937661,
+      "elements": [
+        {
+          "symbol": "Te",
+          "Z": 52,
+          "A_g_mol": 127.6028203000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Th": {
+      "name": "G4_Th",
+      "density_g_cm3": 11.7200000000,
+      "radlen_cm": 0.5182303174,
+      "intlen_cm": 18.3510184568,
+      "elements": [
+        {
+          "symbol": "Th",
+          "Z": 90,
+          "A_g_mol": 232.0380000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Ti": {
+      "name": "G4_Ti",
+      "density_g_cm3": 4.5400000000,
+      "radlen_cm": 3.5601976931,
+      "intlen_cm": 27.9913240031,
+      "elements": [
+        {
+          "symbol": "Ti",
+          "Z": 22,
+          "A_g_mol": 47.8667173300,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Tl": {
+      "name": "G4_Tl",
+      "density_g_cm3": 11.7200000000,
+      "radlen_cm": 0.5476649213,
+      "intlen_cm": 17.5909248845,
+      "elements": [
+        {
+          "symbol": "Tl",
+          "Z": 81,
+          "A_g_mol": 204.3829295200,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Tm": {
+      "name": "G4_Tm",
+      "density_g_cm3": 9.3210000000,
+      "radlen_cm": 0.7544283053,
+      "intlen_cm": 20.7576376405,
+      "elements": [
+        {
+          "symbol": "Tm",
+          "Z": 69,
+          "A_g_mol": 168.9340000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_U": {
+      "name": "G4_U",
+      "density_g_cm3": 18.9500000000,
+      "radlen_cm": 0.3166296193,
+      "intlen_cm": 11.4463995326,
+      "elements": [
+        {
+          "symbol": "U",
+          "Z": 92,
+          "A_g_mol": 238.0291290500,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_URACIL": {
+      "name": "G4_URACIL",
+      "density_g_cm3": 1.3200000000,
+      "radlen_cm": 29.6780964598,
+      "intlen_cm": 60.2469223893,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0359699343
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.4286218190
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.2499266740
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2854815727
+        }
+      ]
+    },
+    "G4_URANIUM_DICARBIDE": {
+      "name": "G4_URANIUM_DICARBIDE",
+      "density_g_cm3": 11.2800000000,
+      "radlen_cm": 0.5774187445,
+      "intlen_cm": 16.6288137602,
+      "elements": [
+        {
+          "symbol": "U",
+          "Z": 92,
+          "A_g_mol": 238.0291290500,
+          "mass_fraction": 0.9083326938
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0916673062
+        }
+      ]
+    },
+    "G4_URANIUM_MONOCARBIDE": {
+      "name": "G4_URANIUM_MONOCARBIDE",
+      "density_g_cm3": 13.6300000000,
+      "radlen_cm": 0.4591719671,
+      "intlen_cm": 14.7086462814,
+      "elements": [
+        {
+          "symbol": "U",
+          "Z": 92,
+          "A_g_mol": 238.0291290500,
+          "mass_fraction": 0.9519647143
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.0480352857
+        }
+      ]
+    },
+    "G4_URANIUM_OXIDE": {
+      "name": "G4_URANIUM_OXIDE",
+      "density_g_cm3": 10.9600000000,
+      "radlen_cm": 0.6067585859,
+      "intlen_cm": 16.8728319003,
+      "elements": [
+        {
+          "symbol": "U",
+          "Z": 92,
+          "A_g_mol": 238.0291290500,
+          "mass_fraction": 0.8814982465
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.1185017535
+        }
+      ]
+    },
+    "G4_UREA": {
+      "name": "G4_UREA",
+      "density_g_cm3": 1.3230000000,
+      "radlen_cm": 29.2864284039,
+      "intlen_cm": 58.3095550771,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.1999941860
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0671340321
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.4664613838
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2664103982
+        }
+      ]
+    },
+    "G4_V": {
+      "name": "G4_V",
+      "density_g_cm3": 6.1100000000,
+      "radlen_cm": 2.5928540732,
+      "intlen_cm": 21.2349284162,
+      "elements": [
+        {
+          "symbol": "V",
+          "Z": 23,
+          "A_g_mol": 50.9415080000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_VALINE": {
+      "name": "G4_VALINE",
+      "density_g_cm3": 1.2300000000,
+      "radlen_cm": 33.0046908252,
+      "intlen_cm": 59.7177245788,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.5126370904
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0946450872
+        },
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 0.1195661791
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.2731516433
+        }
+      ]
+    },
+    "G4_VITON": {
+      "name": "G4_VITON",
+      "density_g_cm3": 1.8000000000,
+      "radlen_cm": 19.6436366979,
+      "intlen_cm": 48.8530589173,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0094170000
+        },
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.2805550000
+        },
+        {
+          "symbol": "F",
+          "Z": 9,
+          "A_g_mol": 18.9984000000,
+          "mass_fraction": 0.7100280000
+        }
+      ]
+    },
+    "G4_W": {
+      "name": "G4_W",
+      "density_g_cm3": 19.3000000000,
+      "radlen_cm": 0.3504180177,
+      "intlen_cm": 10.3115837893,
+      "elements": [
+        {
+          "symbol": "W",
+          "Z": 74,
+          "A_g_mol": 183.8416100000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_WATER": {
+      "name": "G4_WATER",
+      "density_g_cm3": 1.0000000000,
+      "radlen_cm": 36.0829774640,
+      "intlen_cm": 75.3747894121,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1118984778
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.8881015222
+        }
+      ]
+    },
+    "G4_WATER_VAPOR": {
+      "name": "G4_WATER_VAPOR",
+      "density_g_cm3": 0.0007561820,
+      "radlen_cm": 47717.3186666997,
+      "intlen_cm": 99678.1058159553,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1118984778
+        },
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 0.8881015222
+        }
+      ]
+    },
+    "G4_XYLENE": {
+      "name": "G4_XYLENE",
+      "density_g_cm3": 0.8700000000,
+      "radlen_cm": 50.6283508279,
+      "intlen_cm": 82.0777032085,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.9050593022
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.0949406978
+        }
+      ]
+    },
+    "G4_Xe": {
+      "name": "G4_Xe",
+      "density_g_cm3": 0.0054853600,
+      "radlen_cm": 1546.2047849966,
+      "intlen_cm": 32429.6946749956,
+      "elements": [
+        {
+          "symbol": "Xe",
+          "Z": 54,
+          "A_g_mol": 131.2924485000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Y": {
+      "name": "G4_Y",
+      "density_g_cm3": 4.4690000000,
+      "radlen_cm": 2.3294263573,
+      "intlen_cm": 34.9543386305,
+      "elements": [
+        {
+          "symbol": "Y",
+          "Z": 39,
+          "A_g_mol": 88.9058000000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Yb": {
+      "name": "G4_Yb",
+      "density_g_cm3": 6.7300000000,
+      "radlen_cm": 1.0433231211,
+      "intlen_cm": 28.9800996269,
+      "elements": [
+        {
+          "symbol": "Yb",
+          "Z": 70,
+          "A_g_mol": 173.0376377000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Zn": {
+      "name": "G4_Zn",
+      "density_g_cm3": 7.1330000000,
+      "radlen_cm": 1.7428596191,
+      "intlen_cm": 19.7687190024,
+      "elements": [
+        {
+          "symbol": "Zn",
+          "Z": 30,
+          "A_g_mol": 65.3955232900,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_Zr": {
+      "name": "G4_Zr",
+      "density_g_cm3": 6.5060000000,
+      "radlen_cm": 1.5670742707,
+      "intlen_cm": 24.2171559753,
+      "elements": [
+        {
+          "symbol": "Zr",
+          "Z": 40,
+          "A_g_mol": 91.2236313100,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_lAr": {
+      "name": "G4_lAr",
+      "density_g_cm3": 1.3960000000,
+      "radlen_cm": 14.0034386850,
+      "intlen_cm": 85.7063953867,
+      "elements": [
+        {
+          "symbol": "Ar",
+          "Z": 18,
+          "A_g_mol": 39.9476933511,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_lBr": {
+      "name": "G4_lBr",
+      "density_g_cm3": 3.1028000000,
+      "radlen_cm": 3.6812743699,
+      "intlen_cm": 48.5850800305,
+      "elements": [
+        {
+          "symbol": "Br",
+          "Z": 35,
+          "A_g_mol": 79.9035138000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_lH2": {
+      "name": "G4_lH2",
+      "density_g_cm3": 0.0708000000,
+      "radlen_cm": 890.4450429699,
+      "intlen_cm": 494.3503221504,
+      "elements": [
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_lKr": {
+      "name": "G4_lKr",
+      "density_g_cm3": 2.4180000000,
+      "radlen_cm": 4.7031249036,
+      "intlen_cm": 63.3420249794,
+      "elements": [
+        {
+          "symbol": "Kr",
+          "Z": 36,
+          "A_g_mol": 83.7993175100,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_lN2": {
+      "name": "G4_lN2",
+      "density_g_cm3": 0.8070000000,
+      "radlen_cm": 47.0732642399,
+      "intlen_cm": 104.5459466611,
+      "elements": [
+        {
+          "symbol": "N",
+          "Z": 7,
+          "A_g_mol": 14.0067689600,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_lO2": {
+      "name": "G4_lO2",
+      "density_g_cm3": 1.1410000000,
+      "radlen_cm": 30.0071281192,
+      "intlen_cm": 77.2947944830,
+      "elements": [
+        {
+          "symbol": "O",
+          "Z": 8,
+          "A_g_mol": 15.9993904110,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    },
+    "G4_lPROPANE": {
+      "name": "G4_lPROPANE",
+      "density_g_cm3": 0.4300000000,
+      "radlen_cm": 105.5230910621,
+      "intlen_cm": 150.8230000357,
+      "elements": [
+        {
+          "symbol": "C",
+          "Z": 6,
+          "A_g_mol": 12.0107363800,
+          "mass_fraction": 0.8171359205
+        },
+        {
+          "symbol": "H",
+          "Z": 1,
+          "A_g_mol": 1.0079407527,
+          "mass_fraction": 0.1828640795
+        }
+      ]
+    },
+    "G4_lXe": {
+      "name": "G4_lXe",
+      "density_g_cm3": 2.9530000000,
+      "radlen_cm": 2.8721604739,
+      "intlen_cm": 60.2399424255,
+      "elements": [
+        {
+          "symbol": "Xe",
+          "Z": 54,
+          "A_g_mol": 131.2924485000,
+          "mass_fraction": 1.0000000000
+        }
+      ]
+    }
+  },
+  "count_built_ok": 309,
+  "count_built_fail": 0
+}
diff --git a/scripts/geometry/g4_nist_database/compile.sh b/scripts/geometry/g4_nist_database/compile.sh
new file mode 100755
index 0000000000000..27d9cb0d87450
--- /dev/null
+++ b/scripts/geometry/g4_nist_database/compile.sh
@@ -0,0 +1,11 @@
+echo "Compiling using geant4-config..."
+
+g++ -std=c++20 nist_export_all.cxx \
+    $(geant4-config --cflags) \
+    $(geant4-config --libs) \
+    -O2 -o nist_export_all
+
+echo ""
+echo "Build complete."
+echo "Run with:"
+echo "  ./nist_export_all nist_db_all.json"
\ No newline at end of file
diff --git a/scripts/geometry/g4_nist_database/nist_export_all.cxx b/scripts/geometry/g4_nist_database/nist_export_all.cxx
new file mode 100644
index 0000000000000..709b3da261fbf
--- /dev/null
+++ b/scripts/geometry/g4_nist_database/nist_export_all.cxx
@@ -0,0 +1,136 @@
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+#include <string>
+#include <vector>
+#include <algorithm>
+
+// Geant4
+#include "G4NistManager.hh"
+#include "G4Material.hh"
+#include "G4Element.hh"
+#include "G4SystemOfUnits.hh"
+
+static std::string json_escape(const std::string& s)
+{
+  std::string out;
+  out.reserve(s.size() + 8);
+  for (char c : s) {
+    switch (c) {
+      case '\\':
+        out += "\\\\";
+        break;
+      case '"':
+        out += "\\\"";
+        break;
+      case '\n':
+        out += "\\n";
+        break;
+      case '\r':
+        out += "\\r";
+        break;
+      case '\t':
+        out += "\\t";
+        break;
+      default:
+        out += c;
+        break;
+    }
+  }
+  return out;
+}
+
+int main(int argc, char** argv)
+{
+  if (argc < 2) {
+    std::cerr << "Usage:\n  " << argv[0] << " out.json\n";
+    return 2;
+  }
+
+  const std::string out_json = argv[1];
+
+  auto* nist = G4NistManager::Instance();
+
+  // This returns all known NIST material names.
+  std::vector<G4String> names = nist->GetNistMaterialNames();
+  std::sort(names.begin(), names.end());
+
+  std::ofstream out(out_json);
+  if (!out) {
+    std::cerr << "Cannot write: " << out_json << "\n";
+    return 2;
+  }
+
+  out << std::fixed << std::setprecision(10);
+  out << "{\n"
+      << "  \"schema\": \"g4_nist_export_v1\",\n"
+      << "  \"count_requested\": " << names.size() << ",\n"
+      << "  \"materials\": {\n";
+
+  bool first_mat = true;
+  size_t built_ok = 0;
+  size_t built_fail = 0;
+
+  for (const auto& g4name : names) {
+    // Build the material (some may fail depending on Geant4 build/config).
+    G4Material* mat = nist->FindOrBuildMaterial(g4name, /*warning=*/false, /*isotopes=*/false);
+    if (!mat) {
+      ++built_fail;
+      continue;
+    }
+    ++built_ok;
+
+    const std::string name = g4name; // convert G4String -> std::string
+
+    // Export in convenient units
+    const double density_g_cm3 = mat->GetDensity() / (g / cm3);
+    const double radlen_cm = mat->GetRadlen() / cm;
+    const double intlen_cm = mat->GetNuclearInterLength() / cm;
+
+    const size_t ne = mat->GetNumberOfElements();
+    const auto* elems = mat->GetElementVector();
+    const auto* fracs = mat->GetFractionVector(); // mass fractions (nullptr for some edge cases)
+
+    if (!first_mat)
+      out << ",\n";
+    first_mat = false;
+
+    out << "    \"" << json_escape(name) << "\": {\n";
+    out << "      \"name\": \"" << json_escape(name) << "\",\n";
+    out << "      \"density_g_cm3\": " << density_g_cm3 << ",\n";
+    out << "      \"radlen_cm\": " << radlen_cm << ",\n";
+    out << "      \"intlen_cm\": " << intlen_cm << ",\n";
+    out << "      \"elements\": [\n";
+
+    for (size_t i = 0; i < ne; ++i) {
+      const G4Element* el = (*elems)[i];
+      const int Z = static_cast<int>(el->GetZ());
+      const double A_g_mol = el->GetA() / (g / mole);
+      const double w = fracs ? fracs[i] : 0.0;
+
+      out << "        {"
+          << "\"symbol\": \"" << json_escape(el->GetSymbol()) << "\", "
+          << "\"Z\": " << Z << ", "
+          << "\"A_g_mol\": " << A_g_mol << ", "
+          << "\"mass_fraction\": " << w
+          << "}";
+
+      if (i + 1 != ne)
+        out << ",";
+      out << "\n";
+    }
+
+    out << "      ]\n";
+    out << "    }";
+  }
+
+  out << "\n  },\n"
+      << "  \"count_built_ok\": " << built_ok << ",\n"
+      << "  \"count_built_fail\": " << built_fail << "\n"
+      << "}\n";
+
+  std::cerr << "Wrote: " << out_json << "\n"
+            << "NIST names: " << names.size() << ", built ok: " << built_ok
+            << ", failed: " << built_fail << "\n";
+  return 0;
+}
\ No newline at end of file
diff --git a/scripts/geometry/simulating_CAD_modules.md b/scripts/geometry/simulating_CAD_modules.md
index ccd59a3523781..fe30456332ff6 100644
--- a/scripts/geometry/simulating_CAD_modules.md
+++ b/scripts/geometry/simulating_CAD_modules.md
@@ -6,7 +6,8 @@ These are a few notes related to the inclusion of external (CAD-described) detec
 
 In principle, such integration is now possible and requires the following steps:
 
-1. The CAD geometry needs to be exported to STEP format and must contain only the final geometry (no artificial eta-cut elements). Ideally, the geometry should be fully hierarchical with proper solid reuse. The solids should retain their proper surface representation for detailed analysis.
+1. The CAD geometry needs to be exported to STEP format and must contain only the final geometry (no artificial eta-cut elements). Ideally, the geometry should be fully hierarchical with proper solid reuse. The solids should retain their proper surface representation for detailed analysis. Materials can be treated by providing a CSV file that map STEP part names to a material name. The conversion code will do it's best to find a corresponding material definition from a G4 NIST database JSON file (which can be expanded by users with custom definitions).
+
 
 2. A tool `O2-CADtoTGeo.py` is provided to convert the STEP geometry into TGeo format. The tool is part of AliceO2 and is based on Python bindings (OCC) for OpenCascade. The tool can be used as follows:
 
@@ -17,7 +18,14 @@ In principle, such integration is now possible and requires the following steps:
 
     This will create a ROOT macro file `geom.C` containing the geometry description in ROOT format, as well as several binary files describing the TGeo solids. The `geom.C` file can either be used directly in ROOT to inspect the geometry or be provided to ALICE-O2 for inclusion in the geometry.
 
-3. Introduction of materials/media in the file `geom.C`. Currently, the file `geom.C` needs to be patched or edited to properly include `TGeoMaterial`/`TGeoMedium` definitions and connect them to the relevant `TGeoVolume` objects. At present, every solid has the same dummy material attached, which is not realistic. It may be a good idea to create a new file `geom_withMaterials.C`, which differs from `geom.C` by the addition of these material definitions.
+    When materials are included the conversion process looks like this
+    ```bash
+    python O2-CADtoTGeo.py STEP_FILE --output-folder my_detector -o geom.C --mesh \
+                           --mesh-prec 0.2                                        \
+                           --materials-csv MATERIALS.csv                          \ --g4-nist-json ../g4_nist_database/G4_NIST_DB.json 
+    ```
+
+3. Inspection of the created geom.C file and possible manual editing/fixing of the code, in particular materials and medium objects.
 
 4. Once the conversion is complete, the module can be inserted into the O2 geometry via the `ExternalModule` class. To do so, follow this pattern in `build_geometry.C`:
 

From dbdc1df7dbaf74cca5a2f1c755459d7991b57e8f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Tue, 10 Mar 2026 21:29:22 +0100
Subject: [PATCH 1402/1764] [ALICE3] Update FT3 geometry (#15126)

- simplify geometry building
- unify indices, variables
---
 .../FT3/base/include/FT3Base/FT3BaseParam.h   |   3 -
 .../FT3/base/include/FT3Base/GeometryTGeo.h   |   3 -
 .../include/FT3Simulation/Detector.h          |  45 +-
 .../include/FT3Simulation/FT3Layer.h          |  20 +-
 .../ALICE3/FT3/simulation/src/Detector.cxx    | 452 ++++++------------
 .../ALICE3/FT3/simulation/src/FT3Layer.cxx    |  65 ++-
 .../ALICE3/FT3/simulation/src/FT3Module.cxx   |   2 +-
 7 files changed, 221 insertions(+), 369 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
index b286aa068611c..7160067f075f7 100644
--- a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
+++ b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
@@ -42,9 +42,6 @@ struct FT3BaseParam : public o2::conf::ConfigurableParamHelper<FT3BaseParam> {
   Float_t etaOut = 1.5;
   Float_t Layerx2X0 = 0.01;
 
-  // FT3Geometry::External file
-  std::string configFile = ""; // Overrides geoModel parameter when provided
-
   O2ParamDef(FT3BaseParam, "FT3Base");
 };
 
diff --git a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h
index bb22af7ad7f9d..3c78850dffb55 100644
--- a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h
@@ -101,9 +101,6 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   static const char* composeSymNameSensor(Int_t d, Int_t lr);
 
  protected:
-  static constexpr int MAXLAYERS = 15; ///< max number of active layers
-
-  Int_t mNumberOfLayers;               ///< number of layers
   static std::string sInnerVolumeName; ///< Mother inner volume name
   static std::string sVolumeName;      ///< Mother volume name
   static std::string sLayerName;       ///< Layer name
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
index a68f8cf7788b6..8bc4b7f634d7c 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
@@ -25,7 +25,6 @@
 #include "TGeoManager.h"                      // for gGeoManager, TGeoManager (ptr only)
 #include "TLorentzVector.h"                   // for TLorentzVector
 #include "TVector3.h"                         // for TVector3
-#include "FT3Base/FT3BaseParam.h"
 
 class FairVolume;
 class TGeoVolume;
@@ -34,25 +33,10 @@ class TParticle;
 
 class TString;
 
-namespace o2
-{
-namespace ft3
+namespace o2::ft3
 {
 class GeometryTGeo;
-}
-} // namespace o2
-namespace o2
-{
-namespace ft3
-{
-class FT3Layer;
-}
-} // namespace o2
-
-namespace o2
-{
-namespace ft3
-{
+class FT3BaseParam;
 class FT3Layer;
 
 class Detector : public o2::base::DetImpl<Detector>
@@ -108,8 +92,16 @@ class Detector : public o2::base::DetImpl<Detector>
   void PostTrack() override { ; }
   void PreTrack() override { ; }
 
+  static constexpr int IdxForwardDisks = 0;
+  static constexpr int IdxBackwardDisks = 1;
   /// Returns the number of layers
-  Int_t getNumberOfLayers() const { return mNumberOfLayers; }
+  size_t getNumberOfLayers() const
+  {
+    if (mLayerName[IdxBackwardDisks].size() != mLayerName[IdxForwardDisks].size()) {
+      LOG(fatal) << "Number of layers in the two directions are different! Returning 0.";
+    }
+    return mLayerName[IdxBackwardDisks].size();
+  }
 
   void buildBasicFT3(const FT3BaseParam& param);
   void buildFT3V1();
@@ -117,16 +109,10 @@ class Detector : public o2::base::DetImpl<Detector>
   void buildFT3Scoping();
   void buildFT3NewVacuumVessel();
   void buildFT3ScopingV3();
-  void buildFT3FromFile(std::string);
-
-  GeometryTGeo* mGeometryTGeo; //! access to geometry details
-
-  void exportLayout();
 
  protected:
   std::vector<Int_t> mLayerID;
-  std::vector<std::vector<TString>> mLayerName;
-  Int_t mNumberOfLayers;
+  std::array<std::vector<TString>, 2> mLayerName; // Two sets of layer names, one per direction (forward/backward)
 
  private:
   /// this is transient data about track passing the sensor
@@ -154,16 +140,15 @@ class Detector : public o2::base::DetImpl<Detector>
 
   Detector& operator=(const Detector&);
 
-  std::vector<std::vector<FT3Layer>> mLayers;
-  bool mIsPipeActivated = true; //! If Alice 3 pipe is present append inner disks to vacuum volume to avoid overlaps
+  std::array<std::vector<FT3Layer>, 2> mLayers; // Two sets of layers, one per direction (forward/backward)
+  bool mIsPipeActivated = true;                 //! If Alice 3 pipe is present append inner disks to vacuum volume to avoid overlaps
 
   template <typename Det>
   friend class o2::base::DetImpl;
   ClassDefOverride(Detector, 1);
 };
 
-} // namespace ft3
-} // namespace o2
+} // namespace o2::ft3
 
 #ifdef USESHM
 namespace o2
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
index 44a0ef0f7d8bc..44fd8eb08e444 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
@@ -36,7 +36,7 @@ class FT3Layer : public TObject
   FT3Layer() = default;
 
   // Sample layer constructor
-  FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0);
+  FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0, bool partOfMiddleLayers);
 
   /// Copy constructor
   FT3Layer(const FT3Layer&) = default;
@@ -51,6 +51,7 @@ class FT3Layer : public TObject
   auto getInnerRadius() const { return mInnerRadius; }
   auto getOuterRadius() const { return mOuterRadius; }
   auto getDirection() const { return mDirection; }
+  bool getIsInMiddleLayer() const { return mIsMiddleLayer; }
   auto getZ() const { return mZ; }
   auto getx2X0() const { return mx2X0; }
 
@@ -77,14 +78,15 @@ class FT3Layer : public TObject
   static TGeoMedium* medFoam;
 
  private:
-  Int_t mLayerNumber = -1; ///< Current layer number
-  Int_t mDirection;        ///< Layer direction 0=Forward 1 = Backward
-  std::string mLayerName;  ///< Current layer name
-  Double_t mInnerRadius;   ///< Inner radius of this layer
-  Double_t mOuterRadius;   ///< Outer radius of this layer
-  Double_t mZ;             ///< Z position of the layer
-  Double_t mChipThickness; ///< Chip thickness
-  Double_t mx2X0;          ///< Layer material budget x/X0
+  Int_t mLayerNumber = -1;    ///< Current layer number
+  Int_t mDirection;           ///< Layer direction 0=Forward 1 = Backward
+  bool mIsMiddleLayer = true; ///< Wether this layer is part of the middle layers
+  std::string mLayerName;     ///< Current layer name
+  Double_t mInnerRadius;      ///< Inner radius of this layer
+  Double_t mOuterRadius;      ///< Outer radius of this layer
+  Double_t mZ;                ///< Z position of the layer
+  Double_t mChipThickness;    ///< Chip thickness
+  Double_t mx2X0;             ///< Layer material budget x/X0
 
   ClassDefOverride(FT3Layer, 0); // ALICE 3 EndCaps geometry
 };
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index 4b139272834f1..0a93a4061ae44 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -59,97 +59,6 @@ Detector::Detector()
 {
 }
 
-//_________________________________________________________________________________________________
-void Detector::buildFT3FromFile(std::string configFileName)
-{
-  // Geometry description from file. One line per disk
-  // z_layer r_in r_out Layerx2X0
-  // This simple file reader is not failproof. Do not add empty lines!
-
-  /*
-  # Sample FT3 configuration
-  # z_layer    r_in    r_out   Layerx2X0
-  -45.3       2.5     9.26    0.0042
-  -46.7       2.5     9.26    0.0042
-  -48.6       2.5     9.8     0.0042
-  -50.0       2.5     9.8     0.0042
-  -52.4       2.5     10.43   0.0042
-  -53.8       2.5     10.43   0.0042
-  -67.7       3.82    13.01   0.0042
-  -69.1       3.82    13.01   0.0042
-  -76.1       3.92    14.35   0.0042
-  -77.5       3.92    14.35   0.0042
-  */
-
-  mLayerName.clear();
-  mLayers.clear();
-  mLayerID.clear();
-  mLayerName.resize(1);
-  mLayers.resize(1);
-
-  LOG(info) << "Building FT3 Detector: From file";
-  LOG(info) << "   FT3 detector configuration: " << configFileName;
-  std::ifstream ifs(configFileName.c_str());
-  if (!ifs.good()) {
-    LOG(fatal) << " Invalid FT3Base.configFile!";
-  }
-  std::string tempstr;
-  float z_layer, r_in, r_out, Layerx2X0;
-  char delimiter;
-  int layerNumber = 0;
-  while (std::getline(ifs, tempstr)) {
-    if (tempstr[0] == '#') {
-      LOG(info) << " Comment: " << tempstr;
-      continue;
-    }
-    std::istringstream iss(tempstr);
-    iss >> z_layer;
-    iss >> r_in;
-    iss >> r_out;
-    iss >> Layerx2X0;
-
-    int direction = 1; // Forwards
-    if (z_layer < 0) {
-      // Backwards
-      direction = 0;
-    }
-
-    std::string directionName = std::to_string(direction);
-    std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber);
-    mLayerName[0].push_back(layerName);
-    LOG(info) << "Adding Layer " << layerName << " at z = " << z_layer << " ; direction = " << direction << " ; r_in = " << r_in << " ; r_out = " << r_out << " x/X0 = " << Layerx2X0;
-    auto& thisLayer = mLayers[0].emplace_back(direction, layerNumber, layerName, z_layer, r_in, r_out, Layerx2X0);
-    layerNumber++;
-  }
-
-  mNumberOfLayers = layerNumber;
-  LOG(info) << " Loaded FT3 Detector with  " << mNumberOfLayers << " layers";
-}
-
-//_________________________________________________________________________________________________
-void Detector::exportLayout()
-{
-  // Export FT3 Layout description to file.
-  // One line per disk:
-  // z_layer r_in r_out Layerx2X0
-
-  std::string configFileName = "FT3_layout.cfg";
-
-  LOG(info) << "Exporting FT3 Detector layout to " << configFileName;
-
-  std::ofstream fOut(configFileName.c_str(), std::ios::out);
-  if (!fOut) {
-    printf("Cannot open file\n");
-    return;
-  }
-  fOut << "#   z_layer   r_in   r_out   Layerx2X0" << std::endl;
-  for (auto layers_dir : mLayers) {
-    for (auto layer : layers_dir) {
-      fOut << layer.getZ() << "  " << layer.getInnerRadius() << "  " << layer.getOuterRadius() << "  " << layer.getx2X0() << std::endl;
-    }
-  }
-}
-
 //_________________________________________________________________________________________________
 void Detector::buildBasicFT3(const FT3BaseParam& param)
 {
@@ -158,28 +67,27 @@ void Detector::buildBasicFT3(const FT3BaseParam& param)
 
   LOG(info) << "Building FT3 Detector: Conical Telescope";
 
-  auto z_first = param.z0;
-  auto z_length = param.zLength;
-  auto etaIn = param.etaIn;
-  auto etaOut = param.etaOut;
-  auto Layerx2X0 = param.Layerx2X0;
-  mNumberOfLayers = param.nLayers;
-  mLayerName.resize(2);
-  mLayerName[0].resize(mNumberOfLayers);
-  mLayerName[1].resize(mNumberOfLayers);
+  const int numberOfLayers = param.nLayers;
+  const auto z_first = param.z0;
+  const auto z_length = param.zLength;
+  const auto etaIn = param.etaIn;
+  const auto etaOut = param.etaOut;
+  const auto Layerx2X0 = param.Layerx2X0;
+  mLayerName[IdxBackwardDisks].resize(numberOfLayers);
+  mLayerName[IdxForwardDisks].resize(numberOfLayers);
   mLayerID.clear();
-  mLayers.resize(2);
 
-  for (int direction : {0, 1}) {
-    for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) {
-      std::string layerName = GeometryTGeo::getFT3LayerPattern() + std::to_string(layerNumber + mNumberOfLayers * direction);
+  for (int direction : {IdxBackwardDisks, IdxForwardDisks}) {
+    for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
+      std::string layerName = GeometryTGeo::getFT3LayerPattern() + std::to_string(layerNumber + numberOfLayers * direction);
       mLayerName[direction][layerNumber] = layerName;
 
       // Adds evenly spaced layers
-      float layerZ = z_first + (layerNumber * z_length / (mNumberOfLayers - 1)) * std::copysign(1, z_first);
-      float rIn = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaIn))));
-      float rOut = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaOut))));
-      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, layerZ, rIn, rOut, Layerx2X0);
+      const float layerZ = z_first + (layerNumber * z_length / numberOfLayers) * std::copysign(1, z_first);
+      const float rIn = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaIn))));
+      const float rOut = std::abs(layerZ * std::tan(2.f * std::atan(std::exp(-etaOut))));
+      const bool isMiddleLayer = layerNumber < 3;
+      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, layerZ, rIn, rOut, Layerx2X0, isMiddleLayer);
     }
   }
 }
@@ -192,10 +100,10 @@ void Detector::buildFT3V1()
 
   LOG(info) << "Building FT3 Detector: V1";
 
-  mNumberOfLayers = 10;
-  float sensorThickness = 30.e-4;
-  float layersx2X0 = 1.e-2;
-  std::vector<std::array<float, 5>> layersConfig{
+  const int numberOfLayers = 10;
+  const float sensorThickness = 30.e-4;
+  const float layersx2X0 = 1.e-2;
+  const std::vector<std::array<float, 4>> layersConfig{
     {26., .5, 3., 0.1f * layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
     {30., .5, 3., 0.1f * layersx2X0},
     {34., .5, 3., 0.1f * layersx2X0},
@@ -207,14 +115,12 @@ void Detector::buildFT3V1()
     {220., 3.5, 80.f, layersx2X0},
     {279., 3.5, 80.f, layersx2X0}};
 
-  mLayerName.resize(2);
-  mLayerName[0].resize(mNumberOfLayers);
-  mLayerName[1].resize(mNumberOfLayers);
+  mLayerName[IdxBackwardDisks].resize(numberOfLayers);
+  mLayerName[IdxForwardDisks].resize(numberOfLayers);
   mLayerID.clear();
-  mLayers.resize(2);
 
-  for (auto direction : {0, 1}) {
-    for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) {
+  for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
+    for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
       std::string directionName = std::to_string(direction);
       std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber);
       mLayerName[direction][layerNumber] = layerName;
@@ -226,7 +132,8 @@ void Detector::buildFT3V1()
 
       LOG(info) << "Adding Layer " << layerName << " at z = " << z;
       // Add layers
-      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0);
+      const bool isMiddleLayer = layerNumber < 3;
+      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer);
     }
   }
 }
@@ -239,10 +146,10 @@ void Detector::buildFT3V3b()
 
   LOG(info) << "Building FT3 Detector: V3b";
 
-  mNumberOfLayers = 12;
+  const int numberOfLayers = 12;
   float sensorThickness = 30.e-4;
   float layersx2X0 = 1.e-2;
-  std::vector<std::array<float, 5>> layersConfig{
+  std::vector<std::array<float, 4>> layersConfig{
     {26., .5, 3., 0.1f * layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
     {30., .5, 3., 0.1f * layersx2X0},
     {34., .5, 3., 0.1f * layersx2X0},
@@ -256,14 +163,12 @@ void Detector::buildFT3V3b()
     {340., 12.5, 80.f, layersx2X0},
     {400., 14.7, 80.f, layersx2X0}};
 
-  mLayerName.resize(2);
-  mLayerName[0].resize(mNumberOfLayers);
-  mLayerName[1].resize(mNumberOfLayers);
+  mLayerName[IdxBackwardDisks].resize(numberOfLayers);
+  mLayerName[IdxForwardDisks].resize(numberOfLayers);
   mLayerID.clear();
-  mLayers.resize(2);
 
-  for (auto direction : {0, 1}) {
-    for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) {
+  for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
+    for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
       std::string directionName = std::to_string(direction);
       std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber);
       mLayerName[direction][layerNumber] = layerName;
@@ -275,7 +180,8 @@ void Detector::buildFT3V3b()
 
       LOG(info) << "Adding Layer " << layerName << " at z = " << z;
       // Add layers
-      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0);
+      const bool isMiddleLayer = layerNumber < 3;
+      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer);
     }
   }
 }
@@ -291,10 +197,10 @@ void Detector::buildFT3NewVacuumVessel()
 
   LOG(info) << "Building FT3 Detector: After Upgrade Days March 2024 version";
 
-  mNumberOfLayers = 9;
-  float sensorThickness = 30.e-4;
-  float layersx2X0 = 1.e-2;
-  std::vector<std::array<float, 5>> layersConfigCSide{
+  const int numberOfLayers = 9;
+  const float sensorThickness = 30.e-4;
+  const float layersx2X0 = 1.e-2;
+  const std::vector<std::array<float, 4>> layersConfigCSide{
     {77., 7.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
     {100., 7.0, 35., layersx2X0},
     {122., 7.0, 35., layersx2X0},
@@ -305,7 +211,7 @@ void Detector::buildFT3NewVacuumVessel()
     {300., 7.0, 68.f, layersx2X0},
     {350., 7.0, 68.f, layersx2X0}};
 
-  std::vector<std::array<float, 5>> layersConfigASide{
+  const std::vector<std::array<float, 4>> layersConfigASide{
     {77., 5.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
     {100., 5.0, 35., layersx2X0},
     {122., 5.0, 35., layersx2X0},
@@ -316,14 +222,12 @@ void Detector::buildFT3NewVacuumVessel()
     {300., 5.0, 68.f, layersx2X0},
     {350., 5.0, 68.f, layersx2X0}};
 
-  mLayerName.resize(2);
-  mLayerName[0].resize(mNumberOfLayers);
-  mLayerName[1].resize(mNumberOfLayers);
+  mLayerName[IdxBackwardDisks].resize(numberOfLayers);
+  mLayerName[IdxForwardDisks].resize(numberOfLayers);
   mLayerID.clear();
-  mLayers.resize(2);
 
-  for (auto direction : {0, 1}) {
-    for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) {
+  for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
+    for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
       std::string directionName = std::to_string(direction);
       std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber);
       mLayerName[direction][layerNumber] = layerName;
@@ -342,7 +246,8 @@ void Detector::buildFT3NewVacuumVessel()
 
       LOG(info) << "Adding Layer " << layerName << " at z = " << z;
       // Add layers
-      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0);
+      const bool isMiddleLayer = layerNumber < 3;
+      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer);
     }
   }
 }
@@ -356,52 +261,45 @@ void Detector::buildFT3ScopingV3()
 
   LOG(info) << "Building FT3 Detector: v3 scoping version";
 
-  mNumberOfLayers = 6;
-  float sensorThickness = 30.e-4;
-  float layersx2X0 = 1.e-2;
-  std::vector<std::array<float, 5>> layersConfigCSide{
-    {77., 10.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
-    {100., 10.0, 35., layersx2X0},
-    {122., 10.0, 35., layersx2X0},
-    {150., 20.0, 68.f, layersx2X0},
-    {180., 20.0, 68.f, layersx2X0},
-    {220., 20.0, 68.f, layersx2X0}};
-
-  std::vector<std::array<float, 5>> layersConfigASide{
-    {77., 10.0, 35., layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
-    {100., 10.0, 35., layersx2X0},
-    {122., 10.0, 35., layersx2X0},
-    {150., 20.0, 68.f, layersx2X0},
-    {180., 20.0, 68.f, layersx2X0},
-    {220., 20.0, 68.f, layersx2X0}};
-
-  mLayerName.resize(2);
-  mLayerName[0].resize(mNumberOfLayers);
-  mLayerName[1].resize(mNumberOfLayers);
+  const int numberOfLayers = 6;
+  const float sensorThickness = 30.e-4;
+  const float layersx2X0 = 1.e-2;
+  using LayerConfig = std::array<float, 4>; // {z_layer, r_in, r_out, Layerx2X0}
+  const std::array<LayerConfig, numberOfLayers> layersConfigCSide{LayerConfig{77., 10.0, 35., layersx2X0},
+                                                                  LayerConfig{100., 10.0, 35., layersx2X0},
+                                                                  LayerConfig{122., 10.0, 35., layersx2X0},
+                                                                  LayerConfig{150., 20.0, 68.f, layersx2X0},
+                                                                  LayerConfig{180., 20.0, 68.f, layersx2X0},
+                                                                  LayerConfig{220., 20.0, 68.f, layersx2X0}};
+
+  const std::array<LayerConfig, numberOfLayers> layersConfigASide{LayerConfig{77., 10.0, 35., layersx2X0},
+                                                                  LayerConfig{100., 10.0, 35., layersx2X0},
+                                                                  LayerConfig{122., 10.0, 35., layersx2X0},
+                                                                  LayerConfig{150., 20.0, 68.f, layersx2X0},
+                                                                  LayerConfig{180., 20.0, 68.f, layersx2X0},
+                                                                  LayerConfig{220., 20.0, 68.f, layersx2X0}};
+  const std::array<bool, numberOfLayers> enabled{true, true, true, true, true, true}; // To enable or disable layers for debug purpose
+
   mLayerID.clear();
-  mLayers.resize(2);
 
-  for (auto direction : {0, 1}) {
-    for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) {
-      std::string directionName = std::to_string(direction);
-      std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber);
-      mLayerName[direction][layerNumber] = layerName;
-      float z, rIn, rOut, x0;
-      if (direction == 0) { // C-Side
-        z = layersConfigCSide[layerNumber][0];
-        rIn = layersConfigCSide[layerNumber][1];
-        rOut = layersConfigCSide[layerNumber][2];
-        x0 = layersConfigCSide[layerNumber][3];
-      } else if (direction == 1) { // A-Side
-        z = layersConfigASide[layerNumber][0];
-        rIn = layersConfigASide[layerNumber][1];
-        rOut = layersConfigASide[layerNumber][2];
-        x0 = layersConfigASide[layerNumber][3];
+  for (int direction : {IdxBackwardDisks, IdxForwardDisks}) {
+    mLayerName[direction].clear();
+    const std::array<LayerConfig, numberOfLayers>& layerConfig = (direction == IdxBackwardDisks) ? layersConfigCSide : layersConfigASide;
+    for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
+      if (!enabled[layerNumber]) {
+        continue;
       }
-
-      LOG(info) << "Adding Layer " << layerName << " at z = " << z;
+      const std::string directionName = std::to_string(direction);
+      const std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber);
+      mLayerName[direction].push_back(layerName.c_str());
+      const float z = layerConfig[layerNumber][0];
+      const float rIn = layerConfig[layerNumber][1];
+      const float rOut = layerConfig[layerNumber][2];
+      const float x0 = layerConfig[layerNumber][3];
+      LOG(info) << "buildFT3ScopingV3 -> Adding Layer " << layerNumber << "/" << numberOfLayers << " " << layerName << " at z = " << z;
       // Add layers
-      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0);
+      const bool isMiddleLayer = layerNumber < 3;
+      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer);
     }
   }
 }
@@ -413,10 +311,10 @@ void Detector::buildFT3Scoping()
 
   LOG(info) << "Building FT3 Detector: Scoping document version";
 
-  mNumberOfLayers = 12;
-  float sensorThickness = 30.e-4;
-  float layersx2X0 = 1.e-2;
-  std::vector<std::array<float, 5>> layersConfig{
+  const int numberOfLayers = 12;
+  const float sensorThickness = 30.e-4;
+  const float layersx2X0 = 1.e-2;
+  const std::vector<std::array<float, 4>> layersConfig{
     {26., .5, 2.5, 0.1f * layersx2X0}, // {z_layer, r_in, r_out, Layerx2X0}
     {30., .5, 2.5, 0.1f * layersx2X0},
     {34., .5, 2.5, 0.1f * layersx2X0},
@@ -430,26 +328,24 @@ void Detector::buildFT3Scoping()
     {300., 5.0, 68.f, layersx2X0},
     {350., 5.0, 68.f, layersx2X0}};
 
-  mLayerName.resize(2);
-  mLayerName[0].resize(mNumberOfLayers);
-  mLayerName[1].resize(mNumberOfLayers);
+  mLayerName[IdxBackwardDisks].resize(numberOfLayers);
+  mLayerName[IdxForwardDisks].resize(numberOfLayers);
   mLayerID.clear();
-  mLayers.resize(2);
 
-  for (auto direction : {0, 1}) {
-    for (int layerNumber = 0; layerNumber < mNumberOfLayers; layerNumber++) {
+  for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
+    for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
       std::string directionName = std::to_string(direction);
       std::string layerName = GeometryTGeo::getFT3LayerPattern() + directionName + std::string("_") + std::to_string(layerNumber);
       mLayerName[direction][layerNumber] = layerName;
       auto& z = layersConfig[layerNumber][0];
-
       auto& rIn = layersConfig[layerNumber][1];
       auto& rOut = layersConfig[layerNumber][2];
       auto& x0 = layersConfig[layerNumber][3];
 
       LOG(info) << "Adding Layer " << layerName << " at z = " << z;
       // Add layers
-      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0);
+      const bool isMiddleLayer = layerNumber < 3;
+      auto& thisLayer = mLayers[direction].emplace_back(direction, layerNumber, layerName, z, rIn, rOut, x0, isMiddleLayer);
     }
   }
 }
@@ -464,24 +360,17 @@ Detector::Detector(bool active)
   // FT3 Base configuration parameters
   auto& ft3BaseParam = FT3BaseParam::Instance();
 
-  if (ft3BaseParam.configFile != "") {
-    LOG(info) << "FT3 Geometry configuration file provided. Overriding FT3Base.geoModel configuration.";
-    buildFT3FromFile(ft3BaseParam.configFile);
-
-  } else {
-    switch (ft3BaseParam.geoModel) {
-      case Default:
-        buildFT3ScopingV3(); // v3 Dec 25
-        break;
-      case Telescope:
-        buildBasicFT3(ft3BaseParam); // BasicFT3 = Parametrized telescopic detector (equidistant layers)
-        break;
-      default:
-        LOG(fatal) << "Invalid Geometry.\n";
-        break;
-    }
+  switch (ft3BaseParam.geoModel) {
+    case Default:
+      buildFT3ScopingV3(); // v3 Dec 25
+      break;
+    case Telescope:
+      buildBasicFT3(ft3BaseParam); // BasicFT3 = Parametrized telescopic detector (equidistant layers)
+      break;
+    default:
+      LOG(fatal) << "Invalid Geometry.\n";
+      break;
   }
-  exportLayout();
 }
 
 //_________________________________________________________________________________________________
@@ -494,7 +383,6 @@ Detector::Detector(const Detector& rhs)
 {
   mLayerID = rhs.mLayerID;
   mLayerName = rhs.mLayerName;
-  mNumberOfLayers = rhs.mNumberOfLayers;
 }
 
 //_________________________________________________________________________________________________
@@ -527,7 +415,6 @@ Detector& Detector::operator=(const Detector& rhs)
 
   mLayerID = rhs.mLayerID;
   mLayerName = rhs.mLayerName;
-  mNumberOfLayers = rhs.mNumberOfLayers;
   mLayers = rhs.mLayers;
   mTrackData = rhs.mTrackData;
 
@@ -543,8 +430,6 @@ void Detector::InitializeO2Detector()
   // Define the list of sensitive volumes
   LOG(info) << "Initialize FT3 O2Detector";
 
-  mGeometryTGeo = GeometryTGeo::Instance();
-
   defineSensitiveVolumes();
 }
 
@@ -693,12 +578,10 @@ void Detector::ConstructGeometry()
 void Detector::createGeometry()
 {
 
-  mGeometryTGeo = GeometryTGeo::Instance();
-
   TGeoVolume* volFT3 = new TGeoVolumeAssembly(GeometryTGeo::getFT3VolPattern());
   TGeoVolume* volIFT3 = new TGeoVolumeAssembly(GeometryTGeo::getFT3InnerVolPattern());
 
-  LOG(info) << "GeometryBuilder::buildGeometry volume name = " << GeometryTGeo::getFT3VolPattern();
+  LOG(info) << "FT3: createGeometry volume name = " << GeometryTGeo::getFT3VolPattern();
 
   TGeoVolume* vALIC = gGeoManager->GetVolume("barrel");
   if (!vALIC) {
@@ -710,69 +593,40 @@ void Detector::createGeometry()
     LOG(info) << "Running simulation with no beam pipe.";
   }
 
-  LOG(debug) << "FT3 createGeometry: "
-             << Form("gGeoManager name is %s title is %s", gGeoManager->GetName(), gGeoManager->GetTitle());
-
-  if (mLayers.size() == 2) { // V1 and telescope
-    if (!A3IPvac) {
-      for (int direction : {0, 1}) { // Backward layers at mLayers[0]; Forward layers at mLayers[1]
-        std::string directionString = direction ? "Forward" : "Backward";
-        LOG(info) << "Creating FT3 " << directionString << " layers:";
-        for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) {
-          mLayers[direction][iLayer].createLayer(volFT3);
-        }
-      }
-      vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.));
-    } else { // If beampipe is enabled append inner disks to beampipe filling volume, this should be temporary.
-      for (int direction : {0, 1}) {
-        std::string directionString = direction ? "Forward" : "Backward";
-        LOG(info) << "Creating FT3 " << directionString << " layers:";
-        for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) {
-          if (iLayer < 3) {
-            mLayers[direction][iLayer].createLayer(volIFT3);
-          } else {
-            mLayers[direction][iLayer].createLayer(volFT3);
-          }
-        }
-      }
-      A3IPvac->AddNode(volIFT3, 2, new TGeoTranslation(0., 0., 0.));
-      vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.));
-    }
-
-    for (auto direction : {0, 1}) {
-      std::string directionString = direction ? "Forward" : "Backward";
-      LOG(info) << "Registering FT3 " << directionString << " LayerIDs:";
+  // This will need to adapt to the new scheme
+  if (!A3IPvac) {
+    for (int direction : {IdxBackwardDisks, IdxForwardDisks}) { // Backward layers at mLayers[0]; Forward layers at mLayers[1]
+      const std::string directionString = direction ? "Forward" : "Backward";
+      LOG(info) << "  Creating FT3 without beampipe " << directionString << " layers:";
       for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) {
-        auto layerID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer)) : 0;
-        mLayerID.push_back(layerID);
-        LOG(info) << " " << directionString << " layer " << iLayer << " LayerID " << layerID;
+        mLayers[direction][iLayer].createLayer(volFT3);
       }
     }
-  }
-
-  if (mLayers.size() == 1) { // All layers registered at mLayers[0], used when building from file
-    LOG(info) << "Creating FT3 layers:";
-    if (A3IPvac) {
-      for (int iLayer = 0; iLayer < mLayers[0].size(); iLayer++) {
-        if (std::abs(mLayers[0][iLayer].getZ()) < 25) {
-          mLayers[0][iLayer].createLayer(volIFT3);
+    vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.));
+  } else { // If beampipe is enabled append inner disks to beampipe filling volume, this should be temporary.
+    for (int direction : {IdxBackwardDisks, IdxForwardDisks}) {
+      const std::string directionString = direction ? "Forward" : "Backward";
+      LOG(info) << "  Creating FT3 " << directionString << " layers:";
+      for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) {
+        LOG(info) << "  Creating " << directionString << " layer " << iLayer;
+        if (mLayers[direction][iLayer].getIsInMiddleLayer()) { // ML disks
+          mLayers[direction][iLayer].createLayer(volIFT3);
         } else {
-          mLayers[0][iLayer].createLayer(volFT3);
+          mLayers[direction][iLayer].createLayer(volFT3);
         }
       }
-      A3IPvac->AddNode(volIFT3, 2, new TGeoTranslation(0., 0., 0.));
-      vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.));
-    } else {
-      for (int iLayer = 0; iLayer < mLayers[0].size(); iLayer++) {
-        mLayers[0][iLayer].createLayer(volFT3);
-      }
-      vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.));
     }
-    LOG(info) << "Registering FT3 LayerIDs:";
-    for (int iLayer = 0; iLayer < mLayers[0].size(); iLayer++) {
-      auto layerID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), 0, iLayer)) : 0;
+    A3IPvac->AddNode(volIFT3, 2, new TGeoTranslation(0., 0., 0.));
+    vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.));
+  }
+
+  for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
+    std::string directionString = direction ? "Forward" : "Backward";
+    LOG(info) << "  Registering FT3 " << directionString << " LayerIDs for " << mLayers[direction].size() << " layers:";
+    for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) {
+      auto layerID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer)) : 0;
       mLayerID.push_back(layerID);
-      LOG(info) << "  mLayerID[" << iLayer << "] = " << layerID;
+      LOG(info) << " " << directionString << " layer " << iLayer << " LayerID " << layerID;
     }
   }
 }
@@ -786,40 +640,34 @@ void Detector::defineSensitiveVolumes()
   TString volumeName;
   LOG(info) << "Adding FT3 Sensitive Volumes";
 
-  // The names of the FT3 sensitive volumes have the format: FT3Sensor_(0,1)_(0...sNumberLayers-1)
-  if (mLayers.size() == 2) {
-    for (int direction : {0, 1}) {
-      for (int iLayer = 0; iLayer < mNumberOfLayers; iLayer++) {
-        volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer);
-        if (iLayer < 3) { // ML disks
-          v = geoManager->GetVolume(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer));
-          AddSensitiveVolume(v);
-        } else { // OT disks
-          for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) {
-            std::string sensor_name_front = "FT3Sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-            std::string sensor_name_back = "FT3Sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-            v = geoManager->GetVolume(sensor_name_front.c_str());
-            if (v) {
-              AddSensitiveVolume(v);
-            }
-            v = geoManager->GetVolume(sensor_name_back.c_str());
-            if (v) {
-              AddSensitiveVolume(v);
-            }
+  for (int direction : {IdxBackwardDisks, IdxForwardDisks}) {
+    for (int iLayer = 0; iLayer < getNumberOfLayers(); iLayer++) {
+      LOG(info) << "Adding FT3 Sensitive Volume for direction " << direction << " layer " << iLayer << "/" << getNumberOfLayers();
+      volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer);
+      if (mLayers[direction][iLayer].getIsInMiddleLayer()) { // ML disks
+        const std::string sensorName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer);
+        v = geoManager->GetVolume(sensorName.c_str());
+        if (!v) {
+          geoManager->GetListOfVolumes()->ls();
+          LOG(fatal) << "Could not find volume " << sensorName << " for direction " << direction << " layer " << iLayer;
+        }
+        AddSensitiveVolume(v);
+      } else { // OT disks
+        for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) {
+          std::string sensor_name_front = "FT3sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+          std::string sensor_name_back = "FT3sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+          v = geoManager->GetVolume(sensor_name_front.c_str());
+          if (v) {
+            AddSensitiveVolume(v);
+          }
+          v = geoManager->GetVolume(sensor_name_back.c_str());
+          if (v) {
+            AddSensitiveVolume(v);
           }
         }
       }
     }
   }
-
-  if (mLayers.size() == 1) {
-    for (int iLayer = 0; iLayer < mLayers[0].size(); iLayer++) {
-      volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer);
-      v = geoManager->GetVolume(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), mLayers[0][iLayer].getDirection(), iLayer));
-      LOG(info) << "Adding FT3 Sensitive Volume => " << v->GetName();
-      AddSensitiveVolume(v);
-    }
-  }
 }
 
 //_________________________________________________________________________________________________
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
index 97f42eca6143f..1ad4d1aad1eeb 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -16,7 +16,6 @@
 
 #include "FT3Simulation/FT3Layer.h"
 #include "FT3Base/GeometryTGeo.h"
-#include "FT3Simulation/Detector.h"
 
 #include <fairlogger/Logger.h> // for LOG
 
@@ -55,20 +54,29 @@ TGeoMedium* FT3Layer::waterMed = nullptr;
 TGeoMaterial* FT3Layer::foamMat = nullptr;
 TGeoMedium* FT3Layer::medFoam = nullptr;
 
-FT3Layer::FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0)
+FT3Layer::FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerName, Float_t z, Float_t rIn, Float_t rOut, Float_t Layerx2X0, bool partOfMiddleLayers)
 {
   // Creates a simple parametrized EndCap layer covering the given
   // pseudorapidity range at the z layer position
   mDirection = layerDirection;
   mLayerNumber = layerNumber;
+  mIsMiddleLayer = partOfMiddleLayers;
   mLayerName = layerName;
   mZ = layerDirection ? std::abs(z) : -std::abs(z);
   mx2X0 = Layerx2X0;
   mInnerRadius = rIn;
   mOuterRadius = rOut;
-  auto Si_X0 = 9.5;
+  const double Si_X0 = 9.5;
   mChipThickness = Layerx2X0 * Si_X0;
 
+  // Sanity checks
+  if (std::isnan(mZ)) {
+    LOG(fatal) << "FT3 Layer " << mLayerNumber << " has z = NaN, which is not a valid number.";
+  }
+  if (mZ < 0.001 && mZ > -0.001) {
+    LOG(fatal) << "FT3 Layer " << mLayerNumber << " has z = " << mZ << " cm, which is very close to 0.";
+  }
+
   LOG(info) << "Creating FT3 Layer " << mLayerNumber << " ; direction " << mDirection;
   LOG(info) << "   Using silicon X0 = " << Si_X0 << " to emulate layer radiation length.";
   LOG(info) << "   Layer z = " << mZ << " ; R_in = " << mInnerRadius << " ; R_out = " << mOuterRadius << " ; x2X0 = " << mx2X0 << " ; ChipThickness = " << mChipThickness;
@@ -110,8 +118,8 @@ void FT3Layer::createSeparationLayer_waterCooling(TGeoVolume* motherVolume, cons
 
   FT3Layer::initialize_mat();
 
-  double carbonFiberThickness = 0.01;
-  double foamSpacingThickness = 0.5;
+  const double carbonFiberThickness = 0.01; // cm
+  const double foamSpacingThickness = 0.5;  // cm
 
   TGeoTube* carbonFiberLayer = new TGeoTube(mInnerRadius, mOuterRadius, carbonFiberThickness / 2);
 
@@ -122,15 +130,15 @@ void FT3Layer::createSeparationLayer_waterCooling(TGeoVolume* motherVolume, cons
   carbonFiberLayerVol1->SetLineColor(kGray + 2);
   carbonFiberLayerVol2->SetLineColor(kGray + 2);
 
-  double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0;
+  const double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0;
 
   motherVolume->AddNode(carbonFiberLayerVol1, 1, new TGeoTranslation(0, 0, mZ - zSeparation));
   motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, mZ + zSeparation));
 
-  double pipeOuterRadius = 0.20;
-  double kaptonThickness = 0.0025;
-  double pipeInnerRadius = pipeOuterRadius - kaptonThickness;
-  double pipeMaxLength = mOuterRadius * 2.0;
+  const double pipeOuterRadius = 0.20;
+  const double kaptonThickness = 0.0025;
+  const double pipeInnerRadius = pipeOuterRadius - kaptonThickness;
+  const double pipeMaxLength = mOuterRadius * 2.0;
 
   int name_it = 0;
 
@@ -199,8 +207,8 @@ void FT3Layer::createSeparationLayer(TGeoVolume* motherVolume, const std::string
 
   FT3Layer::initialize_mat();
 
-  double carbonFiberThickness = 0.01;
-  double foamSpacingThickness = 1.0;
+  constexpr double carbonFiberThickness = 0.01; // cm
+  constexpr double foamSpacingThickness = 1.0;  // cm
 
   TGeoTube* carbonFiberLayer = new TGeoTube(mInnerRadius, mOuterRadius, carbonFiberThickness / 2);
   TGeoTube* foamLayer = new TGeoTube(mInnerRadius, mOuterRadius, foamSpacingThickness / 2);
@@ -215,16 +223,19 @@ void FT3Layer::createSeparationLayer(TGeoVolume* motherVolume, const std::string
   foamLayerVol->SetFillColorAlpha(kBlack, 1.0);
   carbonFiberLayerVol2->SetLineColor(kGray + 2);
 
-  double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0;
+  const double zSeparation = foamSpacingThickness / 2.0 + carbonFiberThickness / 2.0;
 
-  motherVolume->AddNode(carbonFiberLayerVol1, 1, new TGeoTranslation(0, 0, mZ - zSeparation));
-  motherVolume->AddNode(foamLayerVol, 1, new TGeoTranslation(0, 0, mZ));
-  motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, mZ + zSeparation));
+  motherVolume->AddNode(carbonFiberLayerVol1, 1, new TGeoTranslation(0, 0, 0 - zSeparation));
+  motherVolume->AddNode(foamLayerVol, 1, new TGeoTranslation(0, 0, 0));
+  motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, 0 + zSeparation));
 }
 
 void FT3Layer::createLayer(TGeoVolume* motherVolume)
 {
-  if (mLayerNumber >= 0 && mLayerNumber < 3) {
+  if (mLayerNumber < 0) {
+    LOG(fatal) << "Invalid layer number " << mLayerNumber << " for FT3 layer.";
+  }
+  if (mIsMiddleLayer) { // ML disks
 
     std::string chipName = o2::ft3::GeometryTGeo::getFT3ChipPattern() + std::to_string(mLayerNumber),
                 sensName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), mDirection, mLayerNumber);
@@ -255,7 +266,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
 
-  } else if (mLayerNumber >= 3) {
+  } else { // OT disks
 
     FT3Module module;
 
@@ -264,11 +275,23 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     std::string backLayerName = o2::ft3::GeometryTGeo::getFT3LayerPattern() + std::to_string(mDirection) + std::to_string(mLayerNumber) + "_Back";
     std::string separationLayerName = "FT3SeparationLayer" + std::to_string(mDirection) + std::to_string(mLayerNumber);
 
+    TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$");
+    TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, 10 * mChipThickness / 2);
+    TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+    layerVol->SetLineColor(kYellow + 2);
+
     // createSeparationLayer_waterCooling(motherVolume, separationLayerName);
-    createSeparationLayer(motherVolume, separationLayerName);
+    createSeparationLayer(layerVol, separationLayerName);
 
     // create disk faces
-    module.createModule(mZ, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "front", "rectangular", motherVolume);
-    module.createModule(mZ, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "back", "rectangular", motherVolume);
+    module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "front", "rectangular", layerVol);
+    module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "back", "rectangular", layerVol);
+
+    // Finally put everything in the mother volume
+    auto* FwdDiskRotation = new TGeoRotation("FwdDiskRotation", 0, 0, 180);
+    auto* FwdDiskCombiTrans = new TGeoCombiTrans(0, 0, mZ, FwdDiskRotation);
+
+    LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
+    motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
   }
 }
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
index 9318554837706..20a481cb36046 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -199,7 +199,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
     bottom_y_pos_value = 3.5;
     bottom_y_neg_value = -3.5;
   } else {
-    std::cout << "Different config - to determine offsets needed." << std::endl;
+    LOG(warning) << "Different config - to determine offsets needed for " << "Rin = " << Rin << " ; sensor_height = " << sensor_height << " ; sensor_width = " << sensor_width << " layer " << layerNumber;
     x_condition_min = -Rin;
     x_condition_max = Rin;
     adjust_bottom_y_pos = false;

From 49b0cb7c06128427a857252be17d7bc77eb227ed Mon Sep 17 00:00:00 2001
From: Pavel Larionov <pavel.larionov@cern.ch>
Date: Tue, 10 Mar 2026 22:12:41 +0100
Subject: [PATCH 1403/1764] [ALICE3] Remove petal Z caps from vacuum vol
 (#15119)

---
 .../TRK/simulation/src/VDGeometryBuilder.cxx       | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
index f487d7602619f..48cd0f37d2eb5 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
@@ -84,6 +84,9 @@ inline bool isSolidToCut(const TGeoVolume* v)
   if (TString(nm).BeginsWith("VD_InclinedWall")) {
     return true;
   }
+  if (TString(nm).Contains("_ZCap")) {
+    return true;
+  }
   return false;
 }
 
@@ -252,10 +255,11 @@ static const double diskZ_cm[6] = {-34.0f, -30.0f, -26.0f, 26.0f, 30.0f, 34.0f};
 
 // Petal walls specifications (cm)
 static constexpr double kPetalZ_cm = 70.0f;          // full wall height
-static constexpr double kWallThick_cm = 0.015f;      // 0.15 mm
+static constexpr double kWallThick_cm = 0.02f;       // 0.2 mm
 static constexpr double kInnerWallRadius_cm = 0.48f; // 4.8 mm (ALWAYS cylindrical)
 static constexpr double kOuterWallRadius_cm = 4.8f;  // 48 mm (can be changed)
 static constexpr double kEps_cm = 2.5e-4f;
+static constexpr double kEps_100um = 0.01f; // 100 microns in cm
 
 // 3 inclined walls ("walls") specs for the full-cylinder option
 // Thickness in-plane (cm). This is the short half-dimension of the TGeoBBox in XY.
@@ -604,8 +608,8 @@ static void addIRISServiceModulesSegmented(TGeoVolume* petalAsm, int nPetals)
 
   // --- Vacuum vessel window around z∈[-L/2, +L/2] with wall thickness on +Z side
   //     Keep these in sync with TRKServices::createVacuumCompositeShape()
-  constexpr double vacuumVesselLength = 76.0;             // cm
-  constexpr double vacuumVesselThickness = 0.08;          // cm (0.8 mm)
+  constexpr double vacuumVesselLength = kPetalZ_cm;       // cm
+  constexpr double vacuumVesselThickness = kWallThick_cm; // cm (0.2 mm)
   const double halfVess = 0.5 * vacuumVesselLength;       // 38.0 cm
   const double gapStart = halfVess;                       // 38.00
   const double gapEnd = halfVess + vacuumVesselThickness; // 38.08
@@ -783,8 +787,8 @@ static TGeoVolume* buildFullCylAssembly(int petalID, bool withDisks)
 
   // --- Z end-cap walls to close the petal in Z ---
   {
-    const double zMin = -0.5 * kLenZ_cm;
-    const double zMax = +0.5 * kLenZ_cm;
+    const double zMin = -0.5 * kPetalZ_cm - 2 * kWallThick_cm;
+    const double zMax = +0.5 * kPetalZ_cm + 2 * kWallThick_cm;
     const double rIn = kInnerWallRadius_cm;
     const double rOut = kOuterWallRadius_cm + kWallThick_cm;
 

From 79f51afc1674c855775048eaee2f1b794a004bf7 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Wed, 11 Mar 2026 03:40:28 +0100
Subject: [PATCH 1404/1764] ALICE3-TRK: fix y-axis orientation in the sensor
 local coordinate system, keeping the geometry unchanged (#15134)

---
 .../Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx    | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index 53cc6ab11850d..b5bde06d09484 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -137,17 +137,17 @@ TGeoVolume* TRKLayer::createChip(std::string type)
     metalVol = createMetalStack("flat");
 
     TGeoCombiTrans* transSens = new TGeoCombiTrans();
-    transSens->SetTranslation(-mDeadzoneWidth / 2, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
+    transSens->SetTranslation(-mDeadzoneWidth / 2, (mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
     LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
     chipVol->AddNode(sensVol, 1, transSens);
 
     TGeoCombiTrans* transDead = new TGeoCombiTrans();
-    transDead->SetTranslation((mChipWidth - mDeadzoneWidth) / 2, -(mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
+    transDead->SetTranslation((mChipWidth - mDeadzoneWidth) / 2, (mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
     LOGP(debug, "Inserting {} in {} ", deadVol->GetName(), chipVol->GetName());
     chipVol->AddNode(deadVol, 1, transDead);
 
     TGeoCombiTrans* transMetal = new TGeoCombiTrans();
-    transMetal->SetTranslation(0, mSensorThickness / 2, 0); // TO BE CHECKED !!!
+    transMetal->SetTranslation(0, -(mSensorThickness) / 2, 0); // TO BE CHECKED !!!
     LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
     chipVol->AddNode(metalVol, 1, transMetal);
   } else {
@@ -374,7 +374,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       // Put the staves in the correct position and orientation
       TGeoCombiTrans* trans = new TGeoCombiTrans();
       double theta = 360. * iStave / nStaves;
-      TGeoRotation* rot = new TGeoRotation("rot", theta - 90 + 4, 0, 0);
+      TGeoRotation* rot = new TGeoRotation("rot", theta + 90 + 4, 0, 0);
       trans->SetRotation(rot);
       trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
 
@@ -408,7 +408,7 @@ void TRKLayer::createLayer(TGeoVolume* motherVolume)
       // Put the staves in the correct position and orientation
       TGeoCombiTrans* trans = new TGeoCombiTrans();
       double theta = 360. * iStave / nStaves;
-      TGeoRotation* rot = new TGeoRotation("rot", theta - 90, 0, 0);
+      TGeoRotation* rot = new TGeoRotation("rot", theta + 90, 0, 0);
       trans->SetRotation(rot);
       trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
 

From 90fbe62a83d5564440ad96b604b38f284178d194 Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Wed, 11 Mar 2026 04:31:07 +0100
Subject: [PATCH 1405/1764] [ALICE3] TRK: fix orientation of response function
 both for APTS and ALICE3 response + set reasonable threshold (#15135)

* ALICE3-TRK: fix orientation of response function, handling both ALICE3 and APTS response + log messages modification

* ALICE3-TRK: set more reasonable threshold for the digitization process
---
 .../base/include/TRKBase/SegmentationChip.h   |  2 +-
 .../include/TRKSimulation/DPLDigitizerParam.h |  4 +--
 .../include/TRKSimulation/DigiParams.h        |  4 +--
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   | 27 ++++++++++---------
 4 files changed, 19 insertions(+), 18 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
index 8110191931e44..7ee569c9bd8e8 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/SegmentationChip.h
@@ -198,7 +198,7 @@ class SegmentationChip
       zCol = col * PitchColVD + 0.5 * (PitchColVD - constants::VD::petal::layer::length);
     } else if (subDetID == 1) { // ML/OT
       xRow = 0.5 * (constants::moduleMLOT::chip::width - constants::moduleMLOT::chip::passiveEdgeReadOut - PitchRowMLOT) - (row * PitchRowMLOT);
-      zCol = col * PitchRowMLOT + 0.5 * (PitchRowMLOT - constants::moduleMLOT::chip::length);
+      zCol = col * PitchColMLOT + 0.5 * (PitchColMLOT - constants::moduleMLOT::chip::length);
     }
   }
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
index bbafcf3f8f979..15ed63e46e21f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
@@ -37,8 +37,8 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
   float strobeQRiseTime0 = 450.;            ///< q @ which strobe rise time is 0
 
   double timeOffset = 0.;                 ///< time offset (in seconds!) to calculate ROFrame from hit time
-  int chargeThreshold = 1;                ///< charge threshold in Nelectrons
-  int minChargeToAccount = 1;             ///< minimum charge contribution to account
+  int chargeThreshold = 75;               ///< charge threshold in Nelectrons
+  int minChargeToAccount = 7;             ///< minimum charge contribution to account
   int nSimSteps = 475;                    ///< number of steps in response simulation
   float energyToNElectrons = 1. / 3.6e-9; // conversion of eloss to Nelectrons
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
index 0463a68a77c3e..23824eaefa13d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
@@ -110,8 +110,8 @@ class DigiParams
   float mStrobeLength = 0;               ///< length of the strobe in ns (sig. over threshold checked in this window only)
   double mTimeOffset = -2 * infTime;     ///< time offset (in seconds!) to calculate ROFrame from hit time
   int mROFrameBiasInBC = 0;              ///< misalignment of the ROF start in BC
-  int mChargeThreshold = 1;              ///< charge threshold in Nelectrons
-  int mMinChargeToAccount = 1;           ///< minimum charge contribution to account
+  int mChargeThreshold = 75;             ///< charge threshold in Nelectrons
+  int mMinChargeToAccount = 7;           ///< minimum charge contribution to account
   int mNSimSteps = 475;                  ///< number of steps in response simulation
   float mNSimStepsInv = 1. / mNSimSteps; ///< its inverse
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 0fd8c7820ce28..52eaccfe045f7 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -66,6 +66,7 @@ void Digitizer::init()
   float thicknessMLOT = o2::trk::SegmentationChip::SiliconThicknessMLOT; // 0.01 cm = 100 um --- based on geometry currently present
 
   LOG(info) << "Using response name: " << mRespName;
+  mSimRespOrientation = false;
 
   if (mRespName == "APTS") { // default
     mSimRespVDScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowVD;
@@ -73,6 +74,7 @@ void Digitizer::init()
     mSimRespVDShift = mChipSimRespVD->getDepthMax(); // the curved, rescaled, sensors have a width from 0 to -45. Must add ~10 um (= max depth) to match the APTS response.
     mSimRespMLOTScaleX = o2::trk::constants::apts::pitchX / o2::trk::SegmentationChip::PitchRowMLOT;
     mSimRespMLOTScaleZ = o2::trk::constants::apts::pitchZ / o2::trk::SegmentationChip::PitchColMLOT;
+    mSimRespOrientation = true; /// APTS response function is flipped along x wrt the ones of ALPIDE and ALICE3
   } else if (mRespName == "ALICE3") {
     mSimRespVDScaleX = o2::trk::constants::alice3resp::pitchX / o2::trk::SegmentationChip::PitchRowVD;
     mSimRespVDScaleZ = o2::trk::constants::alice3resp::pitchZ / o2::trk::SegmentationChip::PitchColVD;
@@ -84,7 +86,6 @@ void Digitizer::init()
   }
 
   mSimRespMLOTShift = mChipSimRespMLOT->getDepthMax() - thicknessMLOT / 2.f; // the shift should be done considering the rescaling done to adapt to the wrong silicon thickness. TODO: remove the scaling factor for the depth when the silicon thickness match the simulated response
-  mSimRespOrientation = false;
 
   // importing the parameters from DPLDigitizerParam.h
   auto& dOptTRK = DPLDigitizerParam<o2::detectors::DetID::TRK>::Instance();
@@ -116,11 +117,11 @@ void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
 {
   // digitize single event, the time must have been set beforehand
 
-  LOG(debug) << " Digitizing " << mGeometry->getName() << " (ID: " << mGeometry->getDetID()
-             << ") hits of entry " << evID << " from source " << srcID
-             << " at time " << mEventTime << " ROFrame= " << mNewROFrame << ")"
-             << " cont.mode: " << isContinuous()
-             << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
+  LOG(info) << " Digitizing " << mGeometry->getName() << " (ID: " << mGeometry->getDetID()
+            << ") hits of event " << evID << " from source " << srcID
+            << " at time " << mEventTime.getTimeNS() << " ROFrame = " << mNewROFrame
+            << " cont.mode: " << isContinuous()
+            << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
 
   std::cout << "Printing segmentation info: " << std::endl;
   SegmentationChip::Print();
@@ -154,7 +155,7 @@ void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
 //_______________________________________________________________________
 void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
 {
-  LOG(info) << "Setting event time ";
+  LOG(info) << "Setting event time to " << irt.getTimeNS() << " ns after orbit 0 bc 0";
   // assign event time in ns
   mEventTime = irt;
   if (!mParams.isContinuous()) {
@@ -279,7 +280,7 @@ void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, i
     return;
   }
   float timeInROF = hit.GetTime() * sec2ns;
-  LOG(debug) << "timeInROF: " << timeInROF;
+  LOG(debug) << "Hit time: " << timeInROF << " ns";
   if (timeInROF > 20e3) {
     const int maxWarn = 10;
     static int warnNo = 0;
@@ -292,7 +293,7 @@ void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, i
   if (isContinuous()) {
     timeInROF += mCollisionTimeWrtROF;
   }
-  if (timeInROF < 0) {
+  if (mIsBeforeFirstRO && timeInROF < 0) {
     // disregard this hit because it comes from an event byefore readout starts and it does not effect this RO
     LOG(debug) << "Ignoring hit with timeInROF = " << timeInROF;
     return;
@@ -468,7 +469,7 @@ void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, i
         if (colDest < 0 || colDest >= colSpan) {
           continue;
         }
-        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, mSimRespOrientation ? !flipRow : flipRow, !flipCol);
+        respMatrix[rowDest][colDest] += rspmat->getValue(irow, icol, mSimRespOrientation ? !flipRow : flipRow, flipCol);
       }
     }
   }
@@ -501,7 +502,6 @@ void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, i
       if (mDeadChanMap && mDeadChanMap->isNoisy(chipID, rowIS, colIS)) {
         continue;
       }
-
       registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl);
     }
   }
@@ -517,7 +517,7 @@ void Digitizer::registerDigits(o2::trk::ChipDigitsContainer& chip, uint32_t roFr
   LOG(debug) << "Registering digits for chip " << chip.getChipIndex() << " at ROFrame " << roFrame
              << " row " << row << " col " << col << " nEle " << nEle << " label " << lbl;
   float tStrobe = mParams.getStrobeDelay() - tInROF; // strobe start wrt signal start
-  for (int i = 0; i < nROF; i++) {
+  for (int i = 0; i < nROF; i++) {                   // loop on all the ROFs occupied by the same signal to calculate the charge accumulated in that ROF
     uint32_t roFr = roFrame + i;
     int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength());
     tStrobe += mParams.getROFrameLength(); // for the next ROF
@@ -536,8 +536,9 @@ void Digitizer::registerDigits(o2::trk::ChipDigitsContainer& chip, uint32_t roFr
     o2::itsmft::PreDigit* pd = chip.findDigit(key);
     if (!pd) {
       chip.addDigit(key, roFr, row, col, nEleROF, lbl);
-      LOG(debug) << "Added digit " << key << "  " << roFr << "  " << row << "  " << col << "  " << nEleROF;
+      LOG(debug) << "Added digit with key: " << key << "  ROF: " << roFr << "  row: " << row << "  col: " << col << "  charge: " << nEleROF;
     } else { // there is already a digit at this slot, account as PreDigitExtra contribution
+      LOG(debug) << "Added to pre-digit with key: " << key << "  ROF: " << roFr << "  row: " << row << "  col: " << col << "  charge: " << nEleROF;
       pd->charge += nEleROF;
       if (pd->labelRef.label == lbl) { // don't store the same label twice
         continue;

From 202d71be3c3089d47f3327e1dfde95782a77b044 Mon Sep 17 00:00:00 2001
From: Marco van Leeuwen <marco.van.leeuwen@cern.ch>
Date: Wed, 11 Mar 2026 07:36:59 +0100
Subject: [PATCH 1406/1764] [ALICE 3] Implementation of peacock layour for
 services (#15122)

* [ALICE 3] Implementation of peacock layour for services

* Please consider the following formatting changes

* [ALICE 3] Fixes for code checker

* [ALICE 3] More fixes for code checker

* [ALICE 3] Fix one more overlap in the tracker services in the LoI geometry; plus cosmetics

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Detectors/Upgrades/ALICE3/TRK/README.md       |   1 +
 .../TRK/base/include/TRKBase/TRKBaseParam.h   |   7 +
 .../include/TRKSimulation/TRKServices.h       |   8 +-
 .../ALICE3/TRK/simulation/src/TRKServices.cxx | 481 +++++++++++++++++-
 4 files changed, 480 insertions(+), 17 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/README.md b/Detectors/Upgrades/ALICE3/TRK/README.md
index 8b3a7984bb233..9730c6f6efff7 100644
--- a/Detectors/Upgrades/ALICE3/TRK/README.md
+++ b/Detectors/Upgrades/ALICE3/TRK/README.md
@@ -17,6 +17,7 @@ Configurables for various sub-detectors are presented in the following Table:
 | `TRKBase.layoutVD` | `kIRIS4` (default), `kIRISFullCyl`, `kIRIS5`, `kIRIS4a` | [link to definitions](./base/include/TRKBase/TRKBaseParam.h) |
 | `TRKBase.layoutML` | `kCylinder`, `kTurboStaves` (default), `kStaggered`     |                                                                  |
 | `TRKBase.layoutOT` | `kCylinder`, `kTurboStaves`, `kStaggered` (default)     |                                                                  |
+| `TRKBase.layoutSRV` | `kPeacockv1` (default), `kLOISymm` | `kLOISymm` produces radially symmetric service volumes, as used in the LoI |
 
 For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by
 ```bash
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index 232e7e04b09cd..fb67b90afa7ad 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -39,6 +39,11 @@ enum eVDLayout {
   kIRIS4a,
 };
 
+enum eSrvLayout {
+  kPeacockv1 = 0,
+  kLOISymm,
+};
+
 struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   std::string configFile = "";
   float serviceTubeX0 = 0.02f; // X0 Al2O3
@@ -49,10 +54,12 @@ struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   eLayout layoutML = kTurboStaves; // Type of segmentation for the middle layers
   eLayout layoutOT = kStaggered;   // Type of segmentation for the outer layers
   eVDLayout layoutVD = kIRIS4;     // VD detector layout design
+  eSrvLayout layoutSRV = kPeacockv1; // Layout of services
 
   eLayout getLayoutML() const { return layoutML; }
   eLayout getLayoutOT() const { return layoutOT; }
   eVDLayout getLayoutVD() const { return layoutVD; }
+  eSrvLayout getLayoutSRV() const { return layoutSRV; }
 
   O2ParamDef(TRKBaseParam, "TRKBase");
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
index 8dd3968743024..79033f48cb0b9 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
@@ -51,6 +51,8 @@ class TRKServices : public FairModule
   void createMiddleServices(TGeoVolume* motherVolume);
   void createOuterDisksServices(TGeoVolume* motherVolume);
   void createOuterBarrelServices(TGeoVolume* motherVolume);
+  void createMLServicesPeacock(TGeoVolume* motherVolume);
+  void createOTServicesPeacock(TGeoVolume* motherVolume);
   void createVacuumCompositeShape();
   void excavateFromVacuum(TString shapeToExcavate);
   void registerVacuum(TGeoVolume* motherVolume);
@@ -65,12 +67,14 @@ class TRKServices : public FairModule
   float mColdPlateX0;
 
   // Services
+  float mFiberArea = 7.1e-2;                             // cm^2
+  float mPowerBundleArea = 1.13;                         // cm^2
   float mFiberComposition[2] = {0.5, 0.5};               // SiO2, PE
-  float mPowerBundleComposition[2] = {0.09, 0.91};       // Cu, PE
+  float mPowerBundleComposition[2] = {0.08, 0.92};       // Cu, PE (with jacket)
   float mPowerBundleJacketComposition[2] = {0.06, 0.94}; // Cu, PE
   float mWaterBundleComposition[2] = {0.56, 0.44};       // PU, H2O
   float mWaterBundleDiskComposition[2] = {0.44, 0.56};   // PU, H2O
-  float mMiddleDiskThickness = 1.0;                      // cm
+  // float mMiddleDiskThickness = 1.0;                      // cm
   std::vector<float> mCableFanWeights = {0.5, 0.3, 0.2}; // relative weights of the fan layers
 
   ClassDefOverride(TRKServices, 1);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index bd27a5bc30f62..0394c59780141 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -12,6 +12,7 @@
 #include <TRKSimulation/TRKServices.h>
 #include <DetectorsBase/MaterialManager.h>
 #include <TRKBase/GeometryTGeo.h>
+#include <TRKBase/TRKBaseParam.h>
 #include <FT3Base/GeometryTGeo.h>
 #include <TGeoVolume.h>
 #include <TGeoNode.h>
@@ -23,6 +24,8 @@
 
 #include <Framework/Logger.h>
 
+using std::string;
+
 namespace o2
 {
 namespace trk
@@ -126,9 +129,17 @@ void TRKServices::createServices(TGeoVolume* motherVolume)
 {
   createMaterials();
   createVacuumCompositeShape();
-  createMiddleServices(motherVolume);
-  createOuterDisksServices(motherVolume);
-  createOuterBarrelServices(motherVolume);
+  auto& trkPars = TRKBaseParam::Instance();
+  if (trkPars.getLayoutSRV() == kLOISymm) {
+    LOGP(info, "TRK services: LoI version");
+    createMiddleServices(motherVolume);
+    createOuterDisksServices(motherVolume);
+    createOuterBarrelServices(motherVolume);
+  } else {
+    LOGP(info, "TRK services: Peacock layout");
+    createMLServicesPeacock(motherVolume);
+    createOTServicesPeacock(motherVolume);
+  }
 }
 
 void TRKServices::createVacuumCompositeShape()
@@ -320,10 +331,10 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
   const float rMaxMiddleBarrelDisk = 35.f;
   const float zLengthMiddleBarrel = 64.5f;
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
-    TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube(Form("TRK_MIDBARCONN_DISK_SIO2sh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, siO2FiberThick / 2.);
-    TGeoTube* middleBarrelConnDiskPE = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, peFiberThick / 2.);
-    TGeoVolume* middleBarrelConnDiskSIO2Volume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_SIO2_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskSIO2, medSiO2);
-    TGeoVolume* middleBarrelConnDiskPEVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_PE_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskPE, medPE);
+    TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube(Form("TRK_MIDBARCONN_DISK_FIBER_SIO2sh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, siO2FiberThick / 2.);
+    TGeoTube* middleBarrelConnDiskPE = new TGeoTube(Form("TRK_MIDBARCONN_DISK_FIBER_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, peFiberThick / 2.);
+    TGeoVolume* middleBarrelConnDiskSIO2Volume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_FIBER_SIO2_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskSIO2, medSiO2);
+    TGeoVolume* middleBarrelConnDiskPEVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_FIBER_PE_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskPE, medPE);
     middleBarrelConnDiskSIO2Volume->SetLineColor(kGray);
     middleBarrelConnDiskPEVolume->SetLineColor(kGray);
     auto* rot = new TGeoRotation("", 0, 0, 180);
@@ -332,10 +343,10 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
     motherVolume->AddNode(middleBarrelConnDiskSIO2Volume, 1, combiTransSIO2);
     motherVolume->AddNode(middleBarrelConnDiskPEVolume, 1, combiTransPE);
 
-    TGeoTube* middleBarrelConnDiskCu = new TGeoTube(Form("TRK_MIDBARCONN_DISK_CUsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, cuPowerThick / 2.);
-    TGeoTube* middleBarrelConnDiskPEPower = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, pePowerThick / 2.);
-    TGeoVolume* middleBarrelConnDiskCuVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_CU_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskCu, medCu);
-    TGeoVolume* middleBarrelConnDiskPEPowerVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_PE_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskPEPower, medPE);
+    TGeoTube* middleBarrelConnDiskCu = new TGeoTube(Form("TRK_MIDBARCONN_DISK_POWER_CUsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, cuPowerThick / 2.);
+    TGeoTube* middleBarrelConnDiskPEPower = new TGeoTube(Form("TRK_MIDBARCONN_DISK_POWER_PEsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, pePowerThick / 2.);
+    TGeoVolume* middleBarrelConnDiskCuVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_POWER_CU_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskCu, medCu);
+    TGeoVolume* middleBarrelConnDiskPEPowerVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_POWER_PE_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskPEPower, medPE);
     middleBarrelConnDiskCuVolume->SetLineColor(kGray);
     middleBarrelConnDiskPEPowerVolume->SetLineColor(kGray);
     auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick / 2. + zLengthMiddleBarrel), rot);
@@ -343,14 +354,16 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
     motherVolume->AddNode(middleBarrelConnDiskCuVolume, 1, combiTransCu);
     motherVolume->AddNode(middleBarrelConnDiskPEPowerVolume, 1, combiTransPEPower);
 
-    TGeoTube* middleBarrelConnDiskPU = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PUsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, puCoolingThick);
-    TGeoTube* middleBarrelConnDiskH2O = new TGeoTube(Form("TRK_MIDBARCONN_DISK_H2Osh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, h2oCoolingThick);
+    TGeoTube* middleBarrelConnDiskPU = new TGeoTube(Form("TRK_MIDBARCONN_DISK_PUsh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, puCoolingThick / 2.);
+    TGeoTube* middleBarrelConnDiskH2O = new TGeoTube(Form("TRK_MIDBARCONN_DISK_H2Osh_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, h2oCoolingThick / 2.);
     TGeoVolume* middleBarrelConnDiskPUVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_PU_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskPU, medPU);
     TGeoVolume* middleBarrelConnDiskH2OVolume = new TGeoVolume(Form("TRK_MIDBARCONN_DISK_H2O_%s", orientation == Orientation::kASide ? "bwd" : "fwd"), middleBarrelConnDiskH2O, medH2O);
     middleBarrelConnDiskPUVolume->SetLineColor(kGray);
     middleBarrelConnDiskH2OVolume->SetLineColor(kGray);
-    motherVolume->AddNode(middleBarrelConnDiskPUVolume, 1, combiTransCu);
-    motherVolume->AddNode(middleBarrelConnDiskH2OVolume, 1, combiTransPEPower);
+    auto* combiTransPU = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick + puCoolingThick / 2. + zLengthMiddleBarrel), rot);
+    auto* combiTransH2O = new TGeoCombiTrans(0, 0, (int)orientation * (siO2FiberThick + peFiberThick + cuPowerThick + pePowerThick + puCoolingThick + h2oCoolingThick / 2. + zLengthMiddleBarrel), rot);
+    motherVolume->AddNode(middleBarrelConnDiskPUVolume, 1, combiTransPU);
+    motherVolume->AddNode(middleBarrelConnDiskH2OVolume, 1, combiTransH2O);
   }
 
   // Barrel to forward connection disks
@@ -448,6 +461,10 @@ void TRKServices::createMiddleServices(TGeoVolume* motherVolume)
 
 void TRKServices::createOuterBarrelServices(TGeoVolume* motherVolume)
 {
+  // This implements a service barrel around the full outer tracker which is probably not needed:
+  // power, data and cooling should be implemented on the staves
+  // Used only for 'LOI' geometry
+
   auto& matmgr = o2::base::MaterialManager::Instance();
 
   TGeoMedium* medSiO2 = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_SILICONDIOXIDE");
@@ -500,5 +517,439 @@ void TRKServices::createOuterBarrelServices(TGeoVolume* motherVolume)
   motherVolume->AddNode(outerBarrelCoolingPUVolume, 1, nullptr);
   motherVolume->AddNode(outerBarrelCoolingH2OVolume, 1, nullptr);
 }
+
+void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
+{
+  // This method hardcoes the yellow shape for the middle services
+  auto& matmgr = o2::base::MaterialManager::Instance();
+
+  TGeoMedium* medSiO2 = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_SILICONDIOXIDE");
+  TGeoMedium* medPE = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_POLYETHYLENE");
+  TGeoMedium* medCu = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_COPPER");
+  TGeoMedium* medPU = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_POLYURETHANE");
+  TGeoMedium* medH2O = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_WATER");
+  TGeoMedium* medCFiber = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_CARBONFIBERM55J6K");
+
+  // Barrel service constants
+  const int ITBarrelnFiber = 70;
+  const int ITBarrelnPower = 70;
+  float siO2FiberAreaB = ITBarrelnFiber * mFiberArea * mFiberComposition[0];
+  float peFiberAreaB = ITBarrelnFiber * mFiberArea * mFiberComposition[1];
+
+  float puCoolingAreaB = 0;
+  float h2oCoolingAreaB = 0;
+  float cuPowerAreaB = ITBarrelnPower * mPowerBundleArea * mPowerBundleComposition[0];
+  float pePowerAreaB = ITBarrelnPower * mPowerBundleArea * mPowerBundleComposition[1];
+
+  // Disk service constants
+  const int ITDisknFiber = 3 * 24;
+  const int ITDisknPower = 3 * 16;
+  float siO2FiberAreaD = ITDisknFiber * mFiberArea * mFiberComposition[0];
+  float peFiberAreaD = ITDisknFiber * mFiberArea * mFiberComposition[1];
+
+  float puCoolingAreaD = 0;
+  float h2oCoolingAreaD = 0;
+  float cuPowerAreaD = ITDisknPower * mPowerBundleArea * mPowerBundleComposition[0];
+  float pePowerAreaD = ITDisknPower * mPowerBundleArea * mPowerBundleComposition[1];
+
+  // Carbon Fiber Cylinder support for the middle tracker
+  float rMinMiddleCarbonSupport = 34.8f; // Arbitrary value
+  float rMaxMiddleCarbonSupport = 35.f;  // 2 mm of carbon fiber
+  const float zLengthMiddleCarbon = 129.f;
+  TGeoTube* middleBarrelCarbonSupport = new TGeoTube("TRK_MID_CARBONSUPPORTsh", rMinMiddleCarbonSupport, rMaxMiddleCarbonSupport, zLengthMiddleCarbon / 2.);
+  TGeoVolume* middleBarrelCarbonSupportVolume = new TGeoVolume("TRK_MID_CARBONSUPPORT", middleBarrelCarbonSupport, medCFiber);
+  middleBarrelCarbonSupportVolume->SetLineColor(kGray);
+  LOGP(info, "Creating carbon fiber support for Middle Tracker");
+  motherVolume->AddNode(middleBarrelCarbonSupportVolume, 1, nullptr);
+
+  // Get geometry information from TRK which is already present
+  float rMinMiddleServices = 35.f;
+  float rMinMiddleBarrel = rMinMiddleServices;
+  const float zLengthCylinderMiddleServices = 40.5f;
+  const float zLengthMiddleServices = 143.f;
+
+  // Middle layer barrel services are only on A side
+  rMinMiddleServices = 35.f;
+  LOGP(info, "Building services for Middle Tracker rminMiddleServices");
+
+  // Middle barrel connection disks
+  const float rMinMiddleBarrelDisk = 5.68f;
+  const float rMaxMiddleBarrelDisk = 35.f;
+  const float zLengthMiddleBarrel = 64.5f;
+  auto orientation = Orientation::kASide;
+  float diskCircumference = rMaxMiddleBarrelDisk * 3.14; // Use only half circumference
+
+  double zCur = zLengthMiddleBarrel;
+  double dZ = siO2FiberAreaB / diskCircumference / 2.;
+  TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube("TRK_MIDBARCONN_DISK_FIBER_SIO2sh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
+  TGeoVolume* middleBarrelConnDiskSIO2Volume = new TGeoVolume("TRK_MIDBARCONN_DISK_FIBER_SIO2", middleBarrelConnDiskSIO2, medSiO2);
+  middleBarrelConnDiskSIO2Volume->SetLineColor(kGray);
+  auto* rot = new TGeoRotation("", 0, 0, 180); // Why this?
+  auto* combiTransSIO2 = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
+
+  zCur += 2. * dZ;
+  dZ = peFiberAreaB / diskCircumference / 2.;
+  TGeoTube* middleBarrelConnDiskPE = new TGeoTube("TRK_MIDBARCONN_DISK_FIBER_PEsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
+  TGeoVolume* middleBarrelConnDiskPEVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_FIBER_PE", middleBarrelConnDiskPE, medPE);
+  middleBarrelConnDiskPEVolume->SetLineColor(kGray);
+  auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
+
+  motherVolume->AddNode(middleBarrelConnDiskSIO2Volume, 1, combiTransSIO2);
+  motherVolume->AddNode(middleBarrelConnDiskPEVolume, 1, combiTransPE);
+
+  zCur += 2. * dZ;
+  dZ = cuPowerAreaB / diskCircumference / 2.;
+  TGeoTube* middleBarrelConnDiskCu = new TGeoTube("TRK_MIDBARCONN_DISK_POWER_CUsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
+  TGeoVolume* middleBarrelConnDiskCuVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_POWER_CU", middleBarrelConnDiskCu, medCu);
+  middleBarrelConnDiskCuVolume->SetLineColor(kGray);
+  auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
+
+  zCur += 2. * dZ;
+  dZ = pePowerAreaB / diskCircumference / 2.;
+  TGeoTube* middleBarrelConnDiskPEPower = new TGeoTube("TRK_MIDBARCONN_DISK_POWER_PEsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
+  TGeoVolume* middleBarrelConnDiskPEPowerVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_POWER_PE", middleBarrelConnDiskPEPower, medPE);
+  middleBarrelConnDiskPEPowerVolume->SetLineColor(kGray);
+  auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
+  motherVolume->AddNode(middleBarrelConnDiskCuVolume, 1, combiTransCu);
+  motherVolume->AddNode(middleBarrelConnDiskPEPowerVolume, 1, combiTransPEPower);
+
+  for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
+    for (int iSide = 0; iSide < 2; iSide++) { // left/right or top/bottom
+      float refAngle = 0;
+      string orLabel("A");
+      if (orientation == Orientation::kCSide) {
+        orLabel = "C";
+        refAngle = 90;
+      }
+      // Add ML Disk services
+      // create data fiber volumes
+      double rCur = rMinMiddleServices;
+      double dR = siO2FiberAreaD / (3.14 * rCur);
+      TGeoTubeSeg* middleDiskFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+      TGeoVolume* middleDiskFiberSIO2Volume = new TGeoVolume(Form("TRK_MLD_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), middleDiskFiberSIO2, medSiO2);
+      middleDiskFiberSIO2Volume->SetLineColor(kGray);
+
+      rCur += dR;
+      dR = peFiberAreaD / (3.14 * rCur);
+      TGeoTubeSeg* middleDiskFiberPE = new TGeoTubeSeg(Form("TRK_MLD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+      TGeoVolume* middleDiskFiberPEVolume = new TGeoVolume(Form("TRK_MLD_FIBER_PE_%s%d", orLabel.c_str(), iSide), middleDiskFiberPE, medPE);
+      middleDiskFiberPEVolume->SetLineColor(kGray);
+      auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices), new TGeoRotation("", refAngle + iSide * 180., 0, 0));
+      motherVolume->AddNode(middleDiskFiberSIO2Volume, 1, combiTrans);
+      motherVolume->AddNode(middleDiskFiberPEVolume, 1, combiTrans);
+
+      // Create powerlines
+      rCur += dR;
+      dR = cuPowerAreaD / (3.14 * rCur);
+      TGeoTubeSeg* middleDiskPowerCu = new TGeoTubeSeg(Form("TRK_MLD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+      TGeoVolume* middleDiskPowerCuVolume = new TGeoVolume(Form("TRK_MLD_POWER_CU_%s%d", orLabel.c_str(), iSide), middleDiskPowerCu, medCu);
+      middleDiskPowerCuVolume->SetLineColor(kGray);
+
+      rCur += dR;
+      dR = pePowerAreaD / (3.14 * rCur);
+      TGeoTubeSeg* middleDiskPowerPE = new TGeoTubeSeg(Form("TRK_MLD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+      TGeoVolume* middleDiskPowerPEVolume = new TGeoVolume(Form("TRK_MLD_POWER_PE_%s%d", orLabel.c_str(), iSide), middleDiskPowerPE, medPE);
+      middleDiskPowerPEVolume->SetLineColor(kGray);
+
+      motherVolume->AddNode(middleDiskPowerCuVolume, 1, combiTrans);
+      motherVolume->AddNode(middleDiskPowerPEVolume, 1, combiTrans);
+
+      if (orientation == Orientation::kASide) {
+        // Add Barrel services
+        // create data fiber volumes
+        rCur += dR;
+        dR = siO2FiberAreaB / (3.14 * rCur);
+        TGeoTubeSeg* middleBarrelFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLB_FIBER_SIO2sh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+        TGeoVolume* middleBarrelFiberSIO2Volume = new TGeoVolume(Form("TRK_MLB_FIBER_SIO2_A%d", iSide), middleBarrelFiberSIO2, medSiO2);
+        middleBarrelFiberSIO2Volume->SetLineColor(kGray);
+
+        rCur += dR;
+        dR = peFiberAreaB / (3.14 * rCur);
+        TGeoTubeSeg* middleBarrelFiberPE = new TGeoTubeSeg(Form("TRK_MLB_FIBER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+        TGeoVolume* middleBarrelFiberPEVolume = new TGeoVolume(Form("TRK_MLB_FIBER_PE_A%d", iSide), middleBarrelFiberPE, medPE);
+        middleBarrelFiberPEVolume->SetLineColor(kGray);
+        auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices), new TGeoRotation(nullptr, refAngle + iSide * 180., 0, 0));
+        motherVolume->AddNode(middleBarrelFiberSIO2Volume, 1, combiTrans);
+        motherVolume->AddNode(middleBarrelFiberPEVolume, 1, combiTrans);
+
+        // Create powerlines
+        rCur += dR;
+        dR = cuPowerAreaB / (3.14 * rCur);
+        TGeoTubeSeg* middleBarrelPowerCu = new TGeoTubeSeg(Form("TRK_MLB_POWER_CUsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+        TGeoVolume* middleBarrelPowerCuVolume = new TGeoVolume(Form("TRK_MLB_POWER_CU_A%d", iSide), middleBarrelPowerCu, medCu);
+        middleBarrelPowerCuVolume->SetLineColor(kGray);
+
+        rCur += dR;
+        dR = pePowerAreaB / (3.14 * rCur);
+        TGeoTubeSeg* middleBarrelPowerPE = new TGeoTubeSeg(Form("TRK_MLB_POWER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+        TGeoVolume* middleBarrelPowerPEVolume = new TGeoVolume(Form("TRK_MLB_POWER_PE_A%d", iSide), middleBarrelPowerPE, medPE);
+        middleBarrelPowerPEVolume->SetLineColor(kGray);
+
+        motherVolume->AddNode(middleBarrelPowerCuVolume, 1, combiTrans);
+        motherVolume->AddNode(middleBarrelPowerPEVolume, 1, combiTrans);
+
+        // TODO: add cooling ducts/pipes
+      }
+    }
+  }
+
+  // Barrel to forward connection disks
+  // A side: barrel + disk services
+  // C side: only disk services
+  float rMaxMiddleServicesBarFwd = 74.5f;              // TODO: add thickness of service barrels
+  diskCircumference = rMaxMiddleServicesBarFwd * 3.14; // Only half of the area is used
+  for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
+    float refAngle = 0;
+    string orLabel("A");
+    if (orientation == Orientation::kCSide) {
+      refAngle = 90;
+      orLabel = "C";
+    }
+    double totalThickness = 0;
+    for (int iSide = 0; iSide < 2; iSide++) {
+      // Create fibers
+      double zCur = zLengthMiddleServices; // Change to f
+      double dZ = siO2FiberAreaD / diskCircumference / 2.;
+      totalThickness += 2 * dZ;
+      if (orientation == Orientation::kASide) {
+        dZ += siO2FiberAreaB / diskCircumference / 2.;
+      }
+      TGeoTubeSeg* middleBarFwdFiberSIO2 = new TGeoTubeSeg(Form("TRK_MIDBARFWD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rMinMiddleBarrel, rMaxMiddleServicesBarFwd, dZ, -45, 45);
+      TGeoVolume* middleBarFwdFiberSIO2Volume = new TGeoVolume(Form("TRK_MIDBARFWD_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), middleBarFwdFiberSIO2, medSiO2);
+      auto* rot = new TGeoRotation("", refAngle + iSide * 180., 0, 180.);
+      auto* combiTransSIO2 = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
+
+      zCur += 2 * dZ;
+      dZ = peFiberAreaD / diskCircumference / 2.;
+      totalThickness += 2 * dZ;
+      if (orientation == Orientation::kASide) {
+        dZ += peFiberAreaB / diskCircumference / 2.;
+      }
+      TGeoTubeSeg* middleBarFwdFiberPE = new TGeoTubeSeg(Form("TRK_MIDBARFWD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rMinMiddleBarrel, rMaxMiddleServicesBarFwd, dZ, -45, 45);
+      TGeoVolume* middleBarFwdFiberPEVolume = new TGeoVolume(Form("TRK_MIDBARFWD_FIBER_PE_%s%d", orLabel.c_str(), iSide), middleBarFwdFiberPE, medPE);
+      middleBarFwdFiberSIO2Volume->SetLineColor(kGray);
+      middleBarFwdFiberPEVolume->SetLineColor(kGray);
+      auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
+      motherVolume->AddNode(middleBarFwdFiberSIO2Volume, 1, combiTransSIO2);
+      motherVolume->AddNode(middleBarFwdFiberPEVolume, 1, combiTransPE);
+
+      // Create powerlines
+      zCur += 2 * dZ;
+      dZ = cuPowerAreaD / diskCircumference / 2.;
+      totalThickness += 2 * dZ;
+      if (orientation == Orientation::kASide) {
+        dZ += cuPowerAreaB / diskCircumference / 2.;
+      }
+      TGeoTubeSeg* middleBarFwdPowerCu = new TGeoTubeSeg(Form("TRK_MIDBARFWD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rMinMiddleBarrel, rMaxMiddleServicesBarFwd, dZ, -45, 45);
+      TGeoVolume* middleBarFwdPowerCuVolume = new TGeoVolume(Form("TRK_MIDBARFWD_POWER_CU_%s%d", orLabel.c_str(), iSide), middleBarFwdPowerCu, medCu);
+      auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
+
+      zCur += 2 * dZ;
+      dZ = pePowerAreaD / diskCircumference / 2.;
+      totalThickness += 2 * dZ;
+      if (orientation == Orientation::kASide) {
+        dZ += pePowerAreaB / diskCircumference / 2.;
+      }
+      TGeoTubeSeg* middleBarFwdPowerPE = new TGeoTubeSeg(Form("TRK_MIDBARFWD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rMinMiddleBarrel, rMaxMiddleServicesBarFwd, dZ, -45, 45);
+      TGeoVolume* middleBarFwdPowerPEVolume = new TGeoVolume(Form("TRK_MIDBARFWD_POWER_PE_%s%d", orLabel.c_str(), iSide), middleBarFwdPowerPE, medPE);
+      middleBarFwdPowerCuVolume->SetLineColor(kGray);
+      middleBarFwdPowerPEVolume->SetLineColor(kGray);
+      auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
+      motherVolume->AddNode(middleBarFwdPowerCuVolume, 1, combiTransCu);
+      motherVolume->AddNode(middleBarFwdPowerPEVolume, 1, combiTransPEPower);
+
+      // TODO: add cooling ducts/pipes
+    }
+
+    // Forward part
+    float zLengthMiddleServicesFwd = 350.f - (143.f + totalThickness);
+
+    for (int iSide = 0; iSide < 2; iSide++) {
+      // Create fibers
+      float rMinMiddleServicesFwd = 74.5f; // 74.5cm
+
+      float translation = (int)orientation * (143.f + totalThickness + zLengthMiddleServicesFwd / 2);
+
+      double rCur = rMinMiddleServicesFwd;
+      double dR = siO2FiberAreaD / (3.14 * rCur);
+      if (orientation == Orientation::kASide) {
+        dR += siO2FiberAreaB / (3.14 * rCur);
+      }
+      TGeoTubeSeg* middleFwdFiberSIO2 = new TGeoTubeSeg(Form("TRK_MIDFWD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthMiddleServicesFwd / 2, -45, 45);
+      TGeoVolume* middleFwdFiberSIO2Volume = new TGeoVolume(Form("TRK_MIDFWD_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), middleFwdFiberSIO2, medSiO2);
+      middleFwdFiberSIO2Volume->SetLineColor(kGray);
+
+      rCur += dR;
+      dR = peFiberAreaD / (3.14 * rCur);
+      if (orientation == Orientation::kASide) {
+        dR += peFiberAreaB / (3.14 * rCur);
+      }
+      TGeoTubeSeg* middleFwdFiberPE = new TGeoTubeSeg(Form("TRK_MIDFWD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthMiddleServicesFwd / 2, -45, 45);
+      TGeoVolume* middleFwdFiberPEVolume = new TGeoVolume(Form("TRK_MIDFWD_FIBER_PE_%s%d", orLabel.c_str(), iSide), middleFwdFiberPE, medPE);
+      middleFwdFiberPEVolume->SetLineColor(kGray);
+
+      auto* rot = new TGeoRotation("", refAngle + iSide * 180., 0, 0.);
+      auto* combiTrans = new TGeoCombiTrans(0, 0, translation, rot);
+      motherVolume->AddNode(middleFwdFiberSIO2Volume, 1, combiTrans);
+      motherVolume->AddNode(middleFwdFiberPEVolume, 1, combiTrans);
+
+      // Create powerlines
+      rCur += dR;
+      dR = cuPowerAreaD / (3.14 * rCur);
+      if (orientation == Orientation::kASide) {
+        dR += cuPowerAreaB / (3.14 * rCur);
+      }
+      TGeoTubeSeg* middleFwdPowerCu = new TGeoTubeSeg(Form("TRK_MIDFWD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthMiddleServicesFwd / 2, -45, 45);
+      TGeoVolume* middleFwdPowerCuVolume = new TGeoVolume(Form("TRK_MIDFWD_POWER_CU_%s%d", orLabel.c_str(), iSide), middleFwdPowerCu, medCu);
+      middleFwdPowerCuVolume->SetLineColor(kGray);
+
+      rCur += dR;
+      dR = pePowerAreaD / (3.14 * rCur);
+      if (orientation == Orientation::kASide) {
+        dR += pePowerAreaB / (3.14 * rCur);
+      }
+      TGeoTubeSeg* middleFwdPowerPE = new TGeoTubeSeg(Form("TRK_MIDFWD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthMiddleServicesFwd / 2, -45, 45);
+      TGeoVolume* middleFwdPowerPEVolume = new TGeoVolume(Form("TRK_MIDFWD_POWER_PE_%s%d", orLabel.c_str(), iSide), middleFwdPowerPE, medPE);
+      middleFwdPowerPEVolume->SetLineColor(kGray);
+      motherVolume->AddNode(middleFwdPowerCuVolume, 1, combiTrans);
+      motherVolume->AddNode(middleFwdPowerPEVolume, 1, combiTrans);
+
+      // TODO: add cooling ducts/pipes
+    }
+  }
+}
+
+void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
+{
+  // This implments the service barrels for power + data for the OT barrels and disks
+  // TODO: add cooling
+
+  auto& matmgr = o2::base::MaterialManager::Instance();
+
+  TGeoMedium* medSiO2 = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_SILICONDIOXIDE");
+  TGeoMedium* medPE = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_POLYETHYLENE");
+  TGeoMedium* medCu = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_COPPER");
+  TGeoMedium* medPU = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_POLYURETHANE");
+  TGeoMedium* medH2O = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_WATER");
+  TGeoMedium* medCFiber = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_CARBONFIBERM55J6K");
+
+  // OT Disk service constants
+  const int OTDisknFiber = 3 * 51;
+  const int OTDisknPower = 3 * 34;
+  float siO2FiberAreaD = OTDisknFiber * mFiberArea * mFiberComposition[0];
+  float peFiberAreaD = OTDisknFiber * mFiberArea * mFiberComposition[1];
+
+  float puCoolingAreaD = 0;
+  float h2oCoolingAreaD = 0;
+  float cuPowerAreaD = OTDisknPower * mPowerBundleArea * mPowerBundleComposition[0];
+  float pePowerAreaD = OTDisknPower * mPowerBundleArea * mPowerBundleComposition[1];
+
+  // OT Barrel service constants
+  const int OTBarrelnFiber = 460;
+  const int OTBarrelnPower = 306;
+  float siO2FiberAreaB = OTBarrelnFiber * mFiberArea * mFiberComposition[0];
+  float peFiberAreaB = OTBarrelnFiber * mFiberArea * mFiberComposition[1];
+
+  float puCoolingAreaB = 0;
+  float h2oCoolingAreaB = 0;
+  float cuPowerAreaB = OTBarrelnPower * mPowerBundleArea * mPowerBundleComposition[0];
+  float pePowerAreaB = OTBarrelnPower * mPowerBundleArea * mPowerBundleComposition[1];
+
+  float rMinOuterServices = 68.5f;    // 68.5cm
+  float zLengthOuterServices = 201.f; // 201cm
+
+  // Carbon Fiber Cylinder support for the middle tracker
+  float rMinOuterCarbonSupport = 82.0f;    // TODO: get more precise location
+  float rMaxOuterCarbonSupport = 82.4f;    // 4 mm of carbon fiber
+  const float zLengthOuterCarbon = 280.0f; // Rough guess for now
+  TGeoTube* outerBarrelCarbonSupport = new TGeoTube("TRK_OT_CARBONSUPPORTsh", rMinOuterCarbonSupport, rMaxOuterCarbonSupport, zLengthOuterCarbon / 2.);
+  TGeoVolume* outerBarrelCarbonSupportVolume = new TGeoVolume("TRK_OT_CARBONSUPPORT", outerBarrelCarbonSupport, medCFiber);
+  outerBarrelCarbonSupportVolume->SetLineColor(kGray);
+  LOGP(info, "Creating carbon fiber support for Outer Tracker");
+  motherVolume->AddNode(outerBarrelCarbonSupportVolume, 1, nullptr);
+
+  for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
+    string orLabel = "A";
+    float refAngle = 0;
+    if (orientation == Orientation::kCSide) {
+      orLabel = "C";
+      refAngle = 90;
+    }
+    // TODO: add cables/connections at ends of OT barrels
+    // Set rMin, rMax and dZ
+
+    double rMin = 45.0;
+    double rMax = rMinOuterServices;
+    double zCur = 145.0;
+    double dZ = siO2FiberAreaB / (4 * 3.14 * rMax);
+    TGeoTube* outerBarrelFiberSIO2 = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_SIO2sh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    TGeoVolume* outerBarrelFiberSIO2Volume = new TGeoVolume(Form("TRK_OUTERBARREL_FIBER_SIO2_%s", orLabel.c_str()), outerBarrelFiberSIO2, medSiO2);
+    outerBarrelFiberSIO2Volume->SetLineColor(kGray);
+    auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
+    motherVolume->AddNode(outerBarrelFiberSIO2Volume, 1, combiTrans);
+
+    zCur += 2 * dZ;
+    dZ = peFiberAreaB / (4 * 3.14 * rMax);
+    TGeoTube* outerBarrelFiberPE = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_PEsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    TGeoVolume* outerBarrelFiberPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_FIBER_PE_%s", orLabel.c_str()), outerBarrelFiberPE, medPE);
+    outerBarrelFiberPEVolume->SetLineColor(kGray);
+    combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
+    motherVolume->AddNode(outerBarrelFiberPEVolume, 1, combiTrans);
+
+    zCur += 2 * dZ;
+    dZ = cuPowerAreaB / (4 * 3.14 * rMax);
+    TGeoTube* outerBarrelPowerCu = new TGeoTube(Form("TRK_OUTERBARREL_POWER_CUsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    TGeoVolume* outerBarrelPowerCuVolume = new TGeoVolume(Form("TRK_OUTERBARREL_POWER_CU_%s", orLabel.c_str()), outerBarrelPowerCu, medCu);
+    outerBarrelFiberSIO2Volume->SetLineColor(kGray);
+    combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
+    motherVolume->AddNode(outerBarrelPowerCuVolume, 1, combiTrans);
+
+    zCur += 2 * dZ;
+    dZ = pePowerAreaB / (4 * 3.14 * rMax);
+    TGeoTube* outerBarrelPowerPE = new TGeoTube(Form("TRK_OUTERBARREL_POWER_PEsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    TGeoVolume* outerBarrelPowerPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_POWER_PE_%s", orLabel.c_str()), outerBarrelPowerPE, medPE);
+    outerBarrelPowerPEVolume->SetLineColor(kGray);
+    combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
+    motherVolume->AddNode(outerBarrelPowerPEVolume, 1, combiTrans);
+
+    for (int iSide = 0; iSide < 2; iSide++) {
+      // Create fibers
+      double rCur = rMinOuterServices;
+      double dR = (siO2FiberAreaD + siO2FiberAreaB) / (3.14 * rCur);
+      TGeoTubeSeg* outerDisksFiberSIO2 = new TGeoTubeSeg(Form("TRK_OUTERDISKS_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterServices / 2, -45, 45);
+      TGeoVolume* outerDisksFiberSIO2Volume = new TGeoVolume(Form("TRK_OUTERDISKS_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), outerDisksFiberSIO2, medSiO2);
+      outerDisksFiberSIO2Volume->SetLineColor(kGray);
+
+      rCur += dR;
+      dR = (peFiberAreaD + peFiberAreaB) / (3.14 * rCur);
+      TGeoTubeSeg* outerDisksFiberPE = new TGeoTubeSeg(Form("TRK_OUTERDISKS_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterServices / 2, -45, 45);
+      TGeoVolume* outerDisksFiberPEVolume = new TGeoVolume(Form("TRK_OUTERDISKS_FIBER_PE_%s%d", orLabel.c_str(), iSide), outerDisksFiberPE, medPE);
+      outerDisksFiberPEVolume->SetLineColor(kGray);
+
+      float translation = (int)orientation * (149.f + zLengthOuterServices / 2); // ±149cm
+      auto* combiTrans = new TGeoCombiTrans(0, 0, translation, new TGeoRotation("", refAngle + iSide * 180., 0, 0));
+      motherVolume->AddNode(outerDisksFiberSIO2Volume, 1, combiTrans);
+      motherVolume->AddNode(outerDisksFiberPEVolume, 1, combiTrans);
+
+      // Create power lines
+      rCur += dR;
+      dR = (cuPowerAreaD + cuPowerAreaB) / (3.14 * rCur);
+      TGeoTubeSeg* outerDisksPowerCu = new TGeoTubeSeg(Form("TRK_OUTERDISKS_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterServices / 2, -45, 45);
+      TGeoVolume* outerDisksPowerCuVolume = new TGeoVolume(Form("TRK_OUTERDISKS_POWER_CU_%s%d", orLabel.c_str(), iSide), outerDisksPowerCu, medCu);
+      outerDisksPowerCuVolume->SetLineColor(kGray);
+
+      rCur += dR;
+      dR = (pePowerAreaD + pePowerAreaB) / (3.14 * rCur);
+      TGeoTubeSeg* outerDisksPowerPE = new TGeoTubeSeg(Form("TRK_OUTERDISKS_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterServices / 2, -45, 45);
+      TGeoVolume* outerDisksPowerPEVolume = new TGeoVolume(Form("TRK_OUTERDISKS_POWER_PE_%s%d", orLabel.c_str(), iSide), outerDisksPowerPE, medPE);
+      outerDisksPowerPEVolume->SetLineColor(kGray);
+      motherVolume->AddNode(outerDisksPowerCuVolume, 1, combiTrans);
+      motherVolume->AddNode(outerDisksPowerPEVolume, 1, combiTrans);
+
+      // TODO: add cooling ducts/pipes
+    }
+  }
+}
+
 } // namespace trk
 } // namespace o2

From d886b772dea2e4b92a43b1ca6b7d44b0ecf0cf20 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 10 Mar 2026 22:39:04 +0100
Subject: [PATCH 1407/1764] Add getR method to TrackPar

---
 .../TrackParametrization.h                       | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index 1d6c4d9f0e4ea..6389b037c3625 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -165,6 +165,8 @@ class TrackParametrization
   GPUd() value_t getTgl() const;
   GPUhd() value_t getQ2Pt() const;
   GPUd() value_t getCharge2Pt() const;
+  GPUd() value_t getR2() const;
+  GPUd() value_t getR() const;
   GPUd() int getAbsCharge() const;
   GPUd() PID getPID() const;
   GPUd() void setPID(const PID pid, bool passCharge = false);
@@ -378,6 +380,20 @@ GPUdi() auto TrackParametrization<value_T>::getCharge2Pt() const -> value_t
   return mAbsCharge ? mP[kQ2Pt] : 0.f;
 }
 
+//____________________________________________________________
+template <typename value_T>
+GPUdi() auto TrackParametrization<value_T>::getR2() const -> value_t
+{
+  return mX * mX + mP[kY] * mP[kY];
+}
+
+//____________________________________________________________
+template <typename value_T>
+GPUdi() auto TrackParametrization<value_T>::getR() const -> value_t
+{
+  return gpu::CAMath::Sqrt(getR2());
+}
+
 //____________________________________________________________
 template <typename value_T>
 GPUdi() int TrackParametrization<value_T>::getAbsCharge() const

From 70b4aaaeb6024370c18969187e1f7da7357f2fa4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 11 Mar 2026 17:18:40 +0100
Subject: [PATCH 1408/1764] [ALICE3] Update IOTOF README.md (#15146)

---
 Detectors/Upgrades/ALICE3/IOTOF/README.md | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/README.md b/Detectors/Upgrades/ALICE3/IOTOF/README.md
index 044798076b485..fba4d12252af6 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/README.md
+++ b/Detectors/Upgrades/ALICE3/IOTOF/README.md
@@ -14,16 +14,16 @@ Configurables for various sub-detectors are presented in the following Table:
 
 [link to definitions](./base/include/IOTOFBase/IOTOFBaseParam.h)
 
-| Options                       | Choices                                                          | Comments                                    |
-| ----------------------------- | ---------------------------------------------------------------- | ------------------------------------------- |
-| `IOTOFBase.enableInnerTOF`    | `true` (default), `false`                                        | Enable inner TOF barrel layer               |
-| `IOTOFBase.enableOuterTOF`    | `true` (default), `false`                                        | Enable outer TOF barrel layer               |
-| `IOTOFBase.enableForwardTOF`  | `true` (default), `false`                                        | Enable forward TOF endcap                   |
-| `IOTOFBase.enableBackwardTOF` | `true` (default), `false`                                        | Enable backward TOF endcap                  |
-| `IOTOFBase.segmentedInnerTOF` | `false` (default), `true`                                        | Use segmented geometry for inner TOF        |
-| `IOTOFBase.segmentedOuterTOF` | `false` (default), `true`                                        | Use segmented geometry for outer TOF        |
-| `IOTOFBase.detectorPattern`   | ` ` (default), `v3b`, `v3b1a`, `v3b1b`, `v3b2a`, `v3b2b`, `v3b3` | Optional layout pattern                     |
-| ----------------------------- | -------------------------                                        | ------------------------------------------- |
+| Options                       | Choices                                                          | Comments                                       |
+| ----------------------------- | ---------------------------------------------------------------- | ---------------------------------------------- |
+| `IOTOFBase.enableInnerTOF`    | `true` (default), `false`                                        | Enable inner TOF barrel layer                  |
+| `IOTOFBase.enableOuterTOF`    | `true` (default), `false`                                        | Enable outer TOF barrel layer                  |
+| `IOTOFBase.enableForwardTOF`  | `true` (default), `false`                                        | Enable forward TOF endcap                      |
+| `IOTOFBase.enableBackwardTOF` | `true` (default), `false`                                        | Enable backward TOF endcap                     |
+| `IOTOFBase.segmentedInnerTOF` | `false` (default), `true`                                        | Use segmented geometry for inner TOF           |
+| `IOTOFBase.segmentedOuterTOF` | `false` (default), `true`                                        | Use segmented geometry for outer TOF           |
+| `IOTOFBase.detectorPattern`   | ` ` (default), `v3b`, `v3b1a`, `v3b1b`, `v3b2a`, `v3b2b`, `v3b3` | Optional layout pattern                        |
+| `IOTOFBase.x2x0`              | `0.02` (default)                                                 | Chip thickness in fractions of the rad. lenght |
 
 
 For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by

From 2e80e74b8747160c8755b9fe4699e99a0b18aee7 Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Thu, 12 Mar 2026 04:33:31 +0100
Subject: [PATCH 1409/1764] [ALICE 3] TRKLayer refactoring (#15145)

* TRKLayer refactoring

* Naming

* Fix

* Fix constructors

* Andrea's modifications

* Naming

* Removed header
---
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |   3 +-
 .../TRK/base/include/TRKBase/TRKBaseParam.h   |  29 +-
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      |   9 +-
 .../include/TRKSimulation/Detector.h          |   8 +-
 .../include/TRKSimulation/TRKLayer.h          | 112 +++-
 .../ALICE3/TRK/simulation/src/Detector.cxx    | 128 ++---
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx    | 544 ++++++++----------
 .../TRK/simulation/src/TRKSimulationLinkDef.h |   5 +-
 8 files changed, 392 insertions(+), 446 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index d4402d66cff7e..21d86378f59ec 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -235,8 +235,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   std::vector<float> mCacheRefXMLOT;     /// cache for X of ML and OT
   std::vector<float> mCacheRefAlphaMLOT; /// cache for sensor ref alpha ML and OT
 
-  eLayout mLayoutML; // Type of segmentation for the middle layers
-  eLayout mLayoutOT; // Type of segmentation for the outer layers
+  eMLOTLayout mLayoutMLOT; // ML and OT detector layout design
 
  private:
   static std::unique_ptr<o2::trk::GeometryTGeo> sInstance;
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index fb67b90afa7ad..63e961db44505 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -19,18 +19,6 @@ namespace o2
 {
 namespace trk
 {
-
-enum eOverallGeom {
-  kDefaultRadii = 0, // After Upgrade Days March 2024
-  kModRadii,
-};
-
-enum eLayout {
-  kCylinder = 0,
-  kTurboStaves,
-  kStaggered,
-};
-
 enum eVDLayout {
   kIRIS4 = 0,
   kIRISFullCyl,
@@ -39,6 +27,11 @@ enum eVDLayout {
   kIRIS4a,
 };
 
+enum eMLOTLayout {
+  kCylindrical = 0,
+  kSegmented,
+};
+
 enum eSrvLayout {
   kPeacockv1 = 0,
   kLOISymm,
@@ -49,16 +42,12 @@ struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   float serviceTubeX0 = 0.02f; // X0 Al2O3
   Bool_t irisOpen = false;
 
-  eOverallGeom overallGeom = kDefaultRadii; // Overall geometry option, to be used in Detector::buildTRKMiddleOuterLayers
-
-  eLayout layoutML = kTurboStaves; // Type of segmentation for the middle layers
-  eLayout layoutOT = kStaggered;   // Type of segmentation for the outer layers
-  eVDLayout layoutVD = kIRIS4;     // VD detector layout design
-  eSrvLayout layoutSRV = kPeacockv1; // Layout of services
+  eVDLayout layoutVD = kIRIS4;         // VD detector layout design
+  eMLOTLayout layoutMLOT = kSegmented; // ML and OT detector layout design
+  eSrvLayout layoutSRV = kPeacockv1;   // Layout of services
 
-  eLayout getLayoutML() const { return layoutML; }
-  eLayout getLayoutOT() const { return layoutOT; }
   eVDLayout getLayoutVD() const { return layoutVD; }
+  eMLOTLayout getLayoutMLOT() const { return layoutMLOT; }
   eSrvLayout getLayoutSRV() const { return layoutSRV; }
 
   O2ParamDef(TRKBaseParam, "TRKBase");
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 7b3d33ca1a75c..1a81723a18f63 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -76,10 +76,9 @@ void GeometryTGeo::Build(int loadTrans)
     LOGP(fatal, "Geometry is not loaded");
   }
 
-  mLayoutML = o2::trk::TRKBaseParam::Instance().getLayoutML();
-  mLayoutOT = o2::trk::TRKBaseParam::Instance().getLayoutOT();
+  mLayoutMLOT = o2::trk::TRKBaseParam::Instance().getLayoutMLOT();
 
-  LOG(debug) << "Layout ML: " << mLayoutML << ", Layout OL: " << mLayoutOT;
+  LOG(debug) << "Overall layout ML and OT: " << mLayoutMLOT;
 
   mNumberOfLayersMLOT = extractNumberOfLayersMLOT();
   mNumberOfPetalsVD = extractNumberOfPetalsVD();
@@ -403,9 +402,9 @@ TString GeometryTGeo::getMatrixPath(int index) const
   TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
 
   // handling cylindrical configuration for ML and/or OT
-  // needed bercause of the different numbering scheme in the geometry for the cylindrical case wrt the staggered and turbo ones
+  // needed because of the different numbering scheme in the geometry for the cylindrical case wrt the staggered and turbo ones
   if (subDetID == 1) {
-    if ((layer < 4 && mLayoutML == eLayout::kCylinder) || (layer > 3 && mLayoutOT == eLayout::kCylinder)) {
+    if ((layer < 4 && mLayoutMLOT == eMLOTLayout::kCylindrical) || (layer > 3 && mLayoutMLOT == eMLOTLayout::kCylindrical)) {
       stave = 1;
       mod = 1;
       chip = 1;
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
index 32bdc89109269..9666916800185 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Detector.h
@@ -32,6 +32,7 @@ class Detector : public o2::base::DetImpl<Detector>
  public:
   Detector(bool active);
   Detector();
+  Detector(const Detector& other);
   ~Detector();
 
   // Factory method
@@ -66,8 +67,7 @@ class Detector : public o2::base::DetImpl<Detector>
     return nullptr;
   }
 
-  void configDefault();
-  void buildTRKMiddleOuterLayers();
+  void configMLOT();
   void configFromFile(std::string fileName = "alice3_TRK_layout.txt");
   void configToFile(std::string fileName = "alice3_TRK_layout.txt");
 
@@ -88,8 +88,8 @@ class Detector : public o2::base::DetImpl<Detector>
     double mEnergyLoss;             // energy loss
   } mTrackData;                     //! transient data
   GeometryTGeo* mGeometryTGeo;      //!
-  std::vector<o2::trk::Hit>* mHits; // ITSMFT ones for the moment
-  std::vector<TRKLayer> mLayers;
+  std::vector<o2::trk::Hit>* mHits; // Derived from ITSMFT
+  std::vector<std::unique_ptr<TRKCylindricalLayer>> mLayers;
   TRKServices mServices; // Houses the services of the TRK, but not the Iris tracker
 
   std::vector<std::string> mFirstOrLastLayers; // Names of the first or last layers
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
index 39dd7752cc010..6077d9e5f9839 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
@@ -22,57 +22,113 @@ namespace o2
 {
 namespace trk
 {
-class TRKLayer
+enum class MatBudgetParamMode {
+  Thickness,
+  X2X0
+};
+
+class TRKCylindricalLayer
 {
  public:
-  TRKLayer() = default;
-  TRKLayer(int layerNumber, std::string layerName, float rInn, float rOut, int numberOfModules, float layerX2X0);
-  TRKLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thick);
-  ~TRKLayer() = default;
-
-  void setLayout(eLayout layout) { mLayout = layout; };
+  TRKCylindricalLayer() = default;
+  TRKCylindricalLayer(int layerNumber, std::string layerName, float rInn, float length, float thickOrX2X0, MatBudgetParamMode mode);
+  virtual ~TRKCylindricalLayer() = default;
 
   auto getInnerRadius() const { return mInnerRadius; }
   auto getOuterRadius() const { return mOuterRadius; }
-  auto getZ() const { return constants::moduleMLOT::length * mNumberOfModules; }
+  auto getZ() const { return mLength; }
   auto getx2X0() const { return mX2X0; }
   auto getChipThickness() const { return mChipThickness; }
   auto getNumber() const { return mLayerNumber; }
   auto getName() const { return mLayerName; }
 
-  TGeoVolume* createSensor(std::string type);
-  TGeoVolume* createDeadzone(std::string type);
-  TGeoVolume* createMetalStack(std::string type);
-  TGeoVolume* createChip(std::string type);
-  TGeoVolume* createModule(std::string type);
-  TGeoVolume* createStave(std::string type);
-  TGeoVolume* createHalfStave(std::string type);
-  void createLayer(TGeoVolume* motherVolume);
-
- private:
-  // TGeo objects outside logical volumes can cause errors. Only used in case of kStaggered and kTurboStaves layouts
-  static constexpr float mLogicalVolumeThickness = 1.3;
+  virtual TGeoVolume* createSensor();
+  virtual TGeoVolume* createMetalStack();
+  virtual void createLayer(TGeoVolume* motherVolume);
 
+ protected:
   // User defined parameters for the layer, to be set in the constructor
   int mLayerNumber;
   std::string mLayerName;
   float mInnerRadius;
   float mOuterRadius;
-  int mNumberOfModules;
+  float mLength;
   float mX2X0;
   float mChipThickness;
 
   // Fixed parameters for the layer, to be set based on the specifications of the chip and module
-  eLayout mLayout = kCylinder;
-  float mChipWidth = constants::moduleMLOT::chip::width;
-  float mChipLength = constants::moduleMLOT::chip::length;
-  float mDeadzoneWidth = constants::moduleMLOT::chip::passiveEdgeReadOut;
-  float mSensorThickness = constants::moduleMLOT::silicon::thickness;
-  int mHalfNumberOfChips = 4;
+  static constexpr double sSensorThickness = constants::moduleMLOT::silicon::thickness;
 
   static constexpr float Si_X0 = 9.5f;
 
-  ClassDef(TRKLayer, 2);
+  ClassDef(TRKCylindricalLayer, 0);
+};
+
+class TRKSegmentedLayer : public TRKCylindricalLayer
+{
+ public:
+  TRKSegmentedLayer() = default;
+  TRKSegmentedLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
+  ~TRKSegmentedLayer() override = default;
+
+  TGeoVolume* createSensor() override;
+  TGeoVolume* createDeadzone();
+  TGeoVolume* createMetalStack() override;
+  TGeoVolume* createChip();
+  TGeoVolume* createModule();
+  virtual TGeoVolume* createStave() = 0;
+  void createLayer(TGeoVolume* motherVolume) override = 0;
+
+ protected:
+  int mNumberOfModules;
+
+  // Fixed parameters for the layer, to be set based on the specifications of the chip and module
+  static constexpr double sChipWidth = constants::moduleMLOT::chip::width;
+  static constexpr double sChipLength = constants::moduleMLOT::chip::length;
+  static constexpr double sDeadzoneWidth = constants::moduleMLOT::chip::passiveEdgeReadOut;
+  static constexpr double sModuleLength = constants::moduleMLOT::length;
+  static constexpr double sModuleWidth = constants::moduleMLOT::width;
+  static constexpr int sHalfNumberOfChips = 4;
+
+  // TGeo objects outside logical volumes can cause errors
+  static constexpr float sLogicalVolumeThickness = 1.3;
+
+  ClassDefOverride(TRKSegmentedLayer, 0);
+};
+
+class TRKMLLayer : public TRKSegmentedLayer
+{
+ public:
+  TRKMLLayer() = default;
+  TRKMLLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
+  ~TRKMLLayer() override = default;
+
+  TGeoVolume* createStave() override;
+  void createLayer(TGeoVolume* motherVolume) override;
+
+ private:
+  static constexpr double sStaveWidth = constants::ML::width;
+
+  ClassDefOverride(TRKMLLayer, 0);
+};
+
+class TRKOTLayer : public TRKSegmentedLayer
+{
+ public:
+  TRKOTLayer() = default;
+  TRKOTLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
+  ~TRKOTLayer() override = default;
+
+  TGeoVolume* createStave() override;
+  TGeoVolume* createHalfStave();
+  void createLayer(TGeoVolume* motherVolume) override;
+
+ private:
+  static constexpr double sHalfStaveWidth = constants::OT::halfstave::width;
+  static constexpr double sInStaveOverlap = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true) overlap
+  static constexpr double sStaveWidth = constants::OT::width - sInStaveOverlap;
+
+  ClassDefOverride(TRKOTLayer, 0)
 };
 
 } // namespace trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 2ad1d52ba73c4..8e13d31e7915c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -54,17 +54,24 @@ Detector::Detector(bool active)
   if (trkPars.configFile != "") {
     configFromFile(trkPars.configFile);
   } else {
-    buildTRKMiddleOuterLayers();
+    configMLOT();
     configToFile();
     configServices();
   }
 
   LOGP(info, "Summary of TRK configuration:");
   for (auto& layer : mLayers) {
-    LOGP(info, "Layer: {} name: {} r: {} cm | z: {} cm | thickness: {} cm", layer.getNumber(), layer.getName(), layer.getInnerRadius(), layer.getZ(), layer.getChipThickness());
+    LOGP(info, "Layer: {} name: {} r: {} cm | z: {} cm | thickness: {} cm", layer->getNumber(), layer->getName(), layer->getInnerRadius(), layer->getZ(), layer->getChipThickness());
   }
 }
 
+Detector::Detector(const Detector& other)
+  : o2::base::DetImpl<Detector>(other),
+    mTrackData(),
+    mHits(o2::utils::createSimVector<o2::trk::Hit>())
+{
+}
+
 Detector::~Detector()
 {
   if (mHits) {
@@ -78,78 +85,42 @@ void Detector::ConstructGeometry()
   createGeometry();
 }
 
-void Detector::configDefault()
-{
-
-  // Build TRK detector according to the scoping document
-
-  mLayers.clear();
-
-  LOGP(warning, "Loading Scoping Document configuration for ALICE3 TRK");
-  mLayers.emplace_back(0, GeometryTGeo::getTRKLayerPattern() + std::to_string(0), 3.78f, 10, 100.e-3);
-  mLayers.emplace_back(1, GeometryTGeo::getTRKLayerPattern() + std::to_string(1), 7.f, 10, 100.e-3);
-  mLayers.emplace_back(2, GeometryTGeo::getTRKLayerPattern() + std::to_string(2), 12.f, 10, 100.e-3);
-  mLayers.emplace_back(3, GeometryTGeo::getTRKLayerPattern() + std::to_string(3), 20.f, 10, 100.e-3);
-  mLayers.emplace_back(4, GeometryTGeo::getTRKLayerPattern() + std::to_string(4), 30.f, 10, 100.e-3);
-  mLayers.emplace_back(5, GeometryTGeo::getTRKLayerPattern() + std::to_string(5), 45.f, 20, 100.e-3);
-  mLayers.emplace_back(6, GeometryTGeo::getTRKLayerPattern() + std::to_string(6), 60.f, 20, 100.e-3);
-  mLayers.emplace_back(7, GeometryTGeo::getTRKLayerPattern() + std::to_string(7), 80.f, 20, 100.e-3);
-}
-
-void Detector::buildTRKMiddleOuterLayers()
+void Detector::configMLOT()
 {
   auto& trkPars = TRKBaseParam::Instance();
 
   mLayers.clear();
 
-  switch (trkPars.overallGeom) {
-    case kDefaultRadii:
-      // Build the TRK detector according to changes proposed during
-      // https://indico.cern.ch/event/1407704/
-      // to adhere to the changes that were presented at the ALICE 3 Upgrade days in March 2024
-      // L3 -> 7 cm, L4 -> 9 cm, L5 -> 12 cm, L6 -> 20 cm
-
-      LOGP(warning, "Loading \"After Upgrade Days March 2024\" configuration for ALICE3 TRK");
-      LOGP(warning, "Building TRK with new vacuum vessel and L3 at 7 cm, L4 at 9 cm, L5 at 12 cm, L6 at 20 cm");
-      mLayers.emplace_back(0, GeometryTGeo::getTRKLayerPattern() + std::to_string(0), 7.f, 10, 100.e-3);
-      LOGP(info, "TRKLayer created. Name: {}", GeometryTGeo::getTRKLayerPattern() + std::to_string(0));
-      mLayers.emplace_back(1, GeometryTGeo::getTRKLayerPattern() + std::to_string(1), 9.f, 10, 100.e-3);
-      mLayers.emplace_back(2, GeometryTGeo::getTRKLayerPattern() + std::to_string(2), 12.f, 10, 100.e-3);
-      mLayers.emplace_back(3, GeometryTGeo::getTRKLayerPattern() + std::to_string(3), 20.f, 10, 100.e-3);
-      mLayers.emplace_back(4, GeometryTGeo::getTRKLayerPattern() + std::to_string(4), 30.f, 10, 100.e-3);
-      mLayers.emplace_back(5, GeometryTGeo::getTRKLayerPattern() + std::to_string(5), 45.f, 20, 100.e-3);
-      mLayers.emplace_back(6, GeometryTGeo::getTRKLayerPattern() + std::to_string(6), 60.f, 20, 100.e-3);
-      mLayers.emplace_back(7, GeometryTGeo::getTRKLayerPattern() + std::to_string(7), 80.f, 20, 100.e-3);
+  const std::vector<float> rInn{7.f, 9.f, 12.f, 20.f, 30.f, 45.f, 60.f, 80.f};
+  const float thick = 100.e-3;
+
+  switch (trkPars.layoutMLOT) {
+    case kCylindrical: {
+      const std::vector<float> length{128.35f, 128.35f, 128.35f, 128.35f, 128.35f, 256.7f, 256.7f, 256.7f};
+      LOGP(warning, "Loading cylindrical configuration for ALICE3 TRK");
+      for (int i{0}; i < 8; ++i) {
+        std::string name = GeometryTGeo::getTRKLayerPattern() + std::to_string(i);
+        mLayers.push_back(std::make_unique<TRKCylindricalLayer>(i, name, rInn[i], length[i], thick, MatBudgetParamMode::Thickness));
+      }
       break;
-    case kModRadii:
-      LOGP(warning, "Loading \"Alternative\" configuration for ALICE3 TRK");
-      LOGP(warning, "Building TRK with new vacuum vessel and L3 at 7 cm, L4 at 11 cm, L5 at 15 cm, L6 at 19 cm");
-      mLayers.emplace_back(0, GeometryTGeo::getTRKLayerPattern() + std::to_string(0), 7.f, 10, 100.e-3);
-      LOGP(info, "TRKLayer created. Name: {}", GeometryTGeo::getTRKLayerPattern() + std::to_string(0));
-      mLayers.emplace_back(1, GeometryTGeo::getTRKLayerPattern() + std::to_string(1), 11.f, 10, 100.e-3);
-      mLayers.emplace_back(2, GeometryTGeo::getTRKLayerPattern() + std::to_string(2), 15.f, 10, 100.e-3);
-      mLayers.emplace_back(3, GeometryTGeo::getTRKLayerPattern() + std::to_string(3), 20.f, 10, 100.e-3);
-      mLayers.emplace_back(4, GeometryTGeo::getTRKLayerPattern() + std::to_string(4), 30.f, 10, 100.e-3);
-      mLayers.emplace_back(5, GeometryTGeo::getTRKLayerPattern() + std::to_string(5), 45.f, 20, 100.e-3);
-      mLayers.emplace_back(6, GeometryTGeo::getTRKLayerPattern() + std::to_string(6), 60.f, 20, 100.e-3);
-      mLayers.emplace_back(7, GeometryTGeo::getTRKLayerPattern() + std::to_string(7), 80.f, 20, 100.e-3);
+    }
+    case kSegmented: {
+      const std::vector<int> nMods{10, 10, 10, 10, 10, 20, 20, 20};
+      LOGP(warning, "Loading segmented configuration for ALICE3 TRK");
+      for (int i{0}; i < 8; ++i) {
+        std::string name = GeometryTGeo::getTRKLayerPattern() + std::to_string(i);
+        if (i < 4) {
+          mLayers.push_back(std::make_unique<TRKMLLayer>(i, name, rInn[i], nMods[i], thick, MatBudgetParamMode::Thickness));
+        } else {
+          mLayers.push_back(std::make_unique<TRKOTLayer>(i, name, rInn[i], nMods[i], thick, MatBudgetParamMode::Thickness));
+        }
+      }
       break;
+    }
     default:
-      LOGP(fatal, "Unknown option {} for buildTRKMiddleOuterLayers", static_cast<int>(trkPars.overallGeom));
+      LOGP(fatal, "Unknown option {} for configMLOT", static_cast<int>(trkPars.layoutMLOT));
       break;
   }
-
-  // Middle layers
-  mLayers[0].setLayout(trkPars.layoutML);
-  mLayers[1].setLayout(trkPars.layoutML);
-  mLayers[2].setLayout(trkPars.layoutML);
-  mLayers[3].setLayout(trkPars.layoutML);
-
-  // Outer tracker
-  mLayers[4].setLayout(trkPars.layoutOT);
-  mLayers[5].setLayout(trkPars.layoutOT);
-  mLayers[6].setLayout(trkPars.layoutOT);
-  mLayers[7].setLayout(trkPars.layoutOT);
 }
 
 void Detector::configFromFile(std::string fileName)
@@ -160,6 +131,8 @@ void Detector::configFromFile(std::string fileName)
     LOGP(fatal, "File {} not found, aborting.", fileName);
   }
 
+  auto& trkPars = TRKBaseParam::Instance();
+
   mLayers.clear();
 
   LOGP(info, "Overriding geometry of ALICE3 TRK using {} file.", fileName);
@@ -178,7 +151,26 @@ void Detector::configFromFile(std::string fileName)
     while (getline(ss, substr, '\t')) {
       tmpBuff.push_back(std::stof(substr));
     }
-    mLayers.emplace_back(layerCount, GeometryTGeo::getTRKLayerPattern() + std::to_string(layerCount), tmpBuff[0], tmpBuff[1], tmpBuff[2]);
+
+    std::string name = GeometryTGeo::getTRKLayerPattern() + std::to_string(layerCount);
+    switch (trkPars.layoutMLOT) {
+      case kCylindrical:
+        mLayers.push_back(std::make_unique<TRKCylindricalLayer>(layerCount, name, tmpBuff[0], tmpBuff[1], tmpBuff[2], MatBudgetParamMode::Thickness));
+        break;
+      case kSegmented: {
+        int nMods = static_cast<int>(tmpBuff[1]);
+        if (layerCount < 4) {
+          mLayers.push_back(std::make_unique<TRKMLLayer>(layerCount, name, tmpBuff[0], nMods, tmpBuff[2], MatBudgetParamMode::Thickness));
+        } else {
+          mLayers.push_back(std::make_unique<TRKOTLayer>(layerCount, name, tmpBuff[0], nMods, tmpBuff[2], MatBudgetParamMode::Thickness));
+        }
+        break;
+      }
+      default:
+        LOGP(fatal, "Unknown option {} for configMLOT", static_cast<int>(trkPars.layoutMLOT));
+        break;
+    }
+
     ++layerCount;
   }
 }
@@ -188,8 +180,8 @@ void Detector::configToFile(std::string fileName)
   LOGP(info, "Exporting TRK Detector layout to {}", fileName);
   std::ofstream conFile(fileName.c_str(), std::ios::out);
   conFile << "/// TRK configuration file: inn_radius  z_length  lay_thickness" << std::endl;
-  for (auto layer : mLayers) {
-    conFile << layer.getInnerRadius() << "\t" << layer.getZ() << "\t" << layer.getChipThickness() << std::endl;
+  for (const auto& layer : mLayers) {
+    conFile << layer->getInnerRadius() << "\t" << layer->getZ() << "\t" << layer->getChipThickness() << std::endl;
   }
 }
 
@@ -254,7 +246,7 @@ void Detector::createGeometry()
   vTRK->SetTitle(vstrng);
 
   for (auto& layer : mLayers) {
-    layer.createLayer(vTRK);
+    layer->createLayer(vTRK);
   }
 
   // Add service for inner tracker
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index b5bde06d09484..39c7b3598d19b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -25,400 +25,308 @@ namespace o2
 {
 namespace trk
 {
-TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, float rOut, int numberOfModules, float layerX2X0)
-  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mOuterRadius(rOut), mNumberOfModules(numberOfModules), mX2X0(layerX2X0)
+TRKCylindricalLayer::TRKCylindricalLayer(int layerNumber, std::string layerName, float rInn, float length, float thickOrX2X0, MatBudgetParamMode mode)
+  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mLength(length)
 {
-  mChipThickness = mX2X0 * Si_X0;
-  LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, getZ(), mX2X0);
-}
+  if (mode == MatBudgetParamMode::Thickness) {
+    mChipThickness = thickOrX2X0;
+    mX2X0 = thickOrX2X0 / Si_X0;
+    mOuterRadius = rInn + thickOrX2X0;
+  } else if (mode == MatBudgetParamMode::X2X0) {
+    mX2X0 = thickOrX2X0;
+    mChipThickness = thickOrX2X0 * Si_X0;
+    mOuterRadius = rInn + thickOrX2X0 * Si_X0;
+  }
 
-TRKLayer::TRKLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thick)
-  : mLayerNumber(layerNumber), mLayerName(layerName), mInnerRadius(rInn), mNumberOfModules(numberOfModules), mChipThickness(thick)
-{
-  mOuterRadius = rInn + thick;
-  mX2X0 = mChipThickness / Si_X0;
-  LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, getZ(), mX2X0);
+  LOGP(info, "Creating layer: id: {} rInner: {} rOuter: {} zLength: {} x2X0: {}", mLayerNumber, mInnerRadius, mOuterRadius, mLength, mX2X0);
 }
 
-TGeoVolume* TRKLayer::createSensor(std::string type)
+TGeoVolume* TRKCylindricalLayer::createSensor()
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string sensName = GeometryTGeo::getTRKSensorPattern() + std::to_string(mLayerNumber);
-
-  TGeoShape* sensor;
-
-  if (type == "cylinder") {
-    sensor = new TGeoTube(mInnerRadius, mInnerRadius + mSensorThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2); // TO BE CHECKED !!!
-  } else if (type == "flat") {
-    sensor = new TGeoBBox((mChipWidth - mDeadzoneWidth) / 2, mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
-  } else {
-    LOGP(fatal, "Sensor of type '{}' is not implemented", type);
-  }
-
+  TGeoShape* sensor = new TGeoTube(mInnerRadius, mInnerRadius + sSensorThickness, mLength / 2);
   TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
   sensVol->SetLineColor(kYellow);
 
   return sensVol;
 };
 
-TGeoVolume* TRKLayer::createDeadzone(std::string type)
+TGeoVolume* TRKCylindricalLayer::createMetalStack()
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
-  std::string deadName = GeometryTGeo::getTRKDeadzonePattern() + std::to_string(mLayerNumber);
+  std::string metalName = GeometryTGeo::getTRKMetalStackPattern() + std::to_string(mLayerNumber);
+  TGeoShape* metalStack = new TGeoTube(mInnerRadius + sSensorThickness, mInnerRadius + mChipThickness, mLength / 2);
+  TGeoVolume* metalVol = new TGeoVolume(metalName.c_str(), metalStack, medSi);
+  metalVol->SetLineColor(kGray);
 
-  TGeoShape* deadzone;
+  return metalVol;
+};
 
-  if (type == "cylinder") {
-    deadzone = new TGeoTube(mInnerRadius, mInnerRadius + mSensorThickness, 0); // TO BE CHECKED !!!
-  } else if (type == "flat") {
-    deadzone = new TGeoBBox(mDeadzoneWidth / 2, mSensorThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
-  } else {
-    LOGP(fatal, "Deadzone of type '{}' is not implemented", type);
-  }
+void TRKCylindricalLayer::createLayer(TGeoVolume* motherVolume)
+{
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  TGeoTube* layer = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, mLength / 2);
+  TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+  layerVol->SetLineColor(kYellow);
+
+  TGeoVolume* sensVol = createSensor();
+  LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), layerVol->GetName());
+  layerVol->AddNode(sensVol, 1, nullptr);
+
+  TGeoVolume* metalVol = createMetalStack();
+  LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), layerVol->GetName());
+  layerVol->AddNode(metalVol, 1, nullptr);
+
+  LOGP(debug, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
+  motherVolume->AddNode(layerVol, 1, nullptr);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+TRKSegmentedLayer::TRKSegmentedLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
+  : TRKCylindricalLayer(layerNumber, layerName, rInn, numberOfModules * sModuleLength, thickOrX2X0, mode), mNumberOfModules(numberOfModules)
+{
+}
+
+TGeoVolume* TRKSegmentedLayer::createSensor()
+{
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  std::string sensName = GeometryTGeo::getTRKSensorPattern() + std::to_string(mLayerNumber);
+  TGeoShape* sensor = new TGeoBBox((sChipWidth - sDeadzoneWidth) / 2, sSensorThickness / 2, sChipLength / 2);
+  TGeoVolume* sensVol = new TGeoVolume(sensName.c_str(), sensor, medSi);
+  sensVol->SetLineColor(kYellow);
+
+  return sensVol;
+}
 
+TGeoVolume* TRKSegmentedLayer::createDeadzone()
+{
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  std::string deadName = GeometryTGeo::getTRKDeadzonePattern() + std::to_string(mLayerNumber);
+  TGeoShape* deadzone = new TGeoBBox(sDeadzoneWidth / 2, sSensorThickness / 2, sChipLength / 2);
   TGeoVolume* deadVol = new TGeoVolume(deadName.c_str(), deadzone, medSi);
   deadVol->SetLineColor(kGray);
 
   return deadVol;
-};
+}
 
-TGeoVolume* TRKLayer::createMetalStack(std::string type)
+TGeoVolume* TRKSegmentedLayer::createMetalStack()
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string metalName = GeometryTGeo::getTRKMetalStackPattern() + std::to_string(mLayerNumber);
-
-  TGeoShape* metalStack;
-
-  if (type == "cylinder") {
-    metalStack = new TGeoTube(mInnerRadius + mSensorThickness, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2); // TO BE CHECKED !!!
-  } else if (type == "flat") {
-    metalStack = new TGeoBBox(mChipWidth / 2, (mChipThickness - mSensorThickness) / 2, mChipLength / 2); // TO BE CHECKED !!!
-  } else {
-    LOGP(fatal, "Metal stack of type '{}' is not implemented", type);
-  }
-
+  TGeoShape* metalStack = new TGeoBBox(sChipWidth / 2, (mChipThickness - sSensorThickness) / 2, sChipLength / 2);
   TGeoVolume* metalVol = new TGeoVolume(metalName.c_str(), metalStack, medSi);
   metalVol->SetLineColor(kGray);
 
   return metalVol;
-};
+}
 
-TGeoVolume* TRKLayer::createChip(std::string type)
+TGeoVolume* TRKSegmentedLayer::createChip()
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string chipName = GeometryTGeo::getTRKChipPattern() + std::to_string(mLayerNumber);
-
-  TGeoShape* chip;
-  TGeoVolume* chipVol;
-
-  TGeoVolume* sensVol;
-  TGeoVolume* deadVol;
-  TGeoVolume* metalVol;
-
-  if (type == "cylinder") {
-    chip = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, (constants::moduleMLOT::length * mNumberOfModules) / 2);
-    chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
-
-    sensVol = createSensor("cylinder");
-    LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-    chipVol->AddNode(sensVol, 1, nullptr);
-
-    metalVol = createMetalStack("cylinder");
-    LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
-    chipVol->AddNode(metalVol, 1, nullptr);
-
-    // deadVol = createDeadzone("cylinder");
-  } else if (type == "flat") {
-    chip = new TGeoBBox(mChipWidth / 2, mChipThickness / 2, mChipLength / 2); // TO BE CHECKED !!!
-    chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
-
-    sensVol = createSensor("flat");
-    deadVol = createDeadzone("flat");
-    metalVol = createMetalStack("flat");
-
-    TGeoCombiTrans* transSens = new TGeoCombiTrans();
-    transSens->SetTranslation(-mDeadzoneWidth / 2, (mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
-    LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-    chipVol->AddNode(sensVol, 1, transSens);
-
-    TGeoCombiTrans* transDead = new TGeoCombiTrans();
-    transDead->SetTranslation((mChipWidth - mDeadzoneWidth) / 2, (mChipThickness - mSensorThickness) / 2, 0); // TO BE CHECKED !!!
-    LOGP(debug, "Inserting {} in {} ", deadVol->GetName(), chipVol->GetName());
-    chipVol->AddNode(deadVol, 1, transDead);
-
-    TGeoCombiTrans* transMetal = new TGeoCombiTrans();
-    transMetal->SetTranslation(0, -(mSensorThickness) / 2, 0); // TO BE CHECKED !!!
-    LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
-    chipVol->AddNode(metalVol, 1, transMetal);
-  } else {
-    LOGP(fatal, "Sensor of type '{}' is not implemented", type);
-  }
-
+  TGeoShape* chip = new TGeoBBox(sChipWidth / 2, mChipThickness / 2, sChipLength / 2);
+  TGeoVolume* chipVol = new TGeoVolume(chipName.c_str(), chip, medSi);
   chipVol->SetLineColor(kYellow);
 
+  TGeoVolume* sensVol = createSensor();
+  TGeoCombiTrans* transSens = new TGeoCombiTrans();
+  // transSens->SetTranslation(-sDeadzoneWidth / 2, -(mChipThickness - sSensorThickness) / 2, 0);
+  transSens->SetTranslation(-sDeadzoneWidth / 2, (mChipThickness - sSensorThickness) / 2, 0);
+  LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+  chipVol->AddNode(sensVol, 1, transSens);
+
+  TGeoVolume* deadVol = createDeadzone();
+  TGeoCombiTrans* transDead = new TGeoCombiTrans();
+  // transDead->SetTranslation((sChipWidth - sDeadzoneWidth) / 2, -(mChipThickness - sSensorThickness) / 2, 0);
+  transDead->SetTranslation((sChipWidth - sDeadzoneWidth) / 2, (mChipThickness - sSensorThickness) / 2, 0);
+  LOGP(debug, "Inserting {} in {} ", deadVol->GetName(), chipVol->GetName());
+  chipVol->AddNode(deadVol, 1, transDead);
+
+  TGeoVolume* metalVol = createMetalStack();
+  TGeoCombiTrans* transMetal = new TGeoCombiTrans();
+  // transMetal->SetTranslation(0, sSensorThickness / 2, 0);
+  transMetal->SetTranslation(0, -sSensorThickness / 2, 0);
+  LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
+  chipVol->AddNode(metalVol, 1, transMetal);
+
   return chipVol;
 }
 
-TGeoVolume* TRKLayer::createModule(std::string type)
+TGeoVolume* TRKSegmentedLayer::createModule()
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string moduleName = GeometryTGeo::getTRKModulePattern() + std::to_string(mLayerNumber);
+  TGeoShape* module = new TGeoBBox(sModuleWidth / 2, mChipThickness / 2, sModuleLength / 2);
+  TGeoVolume* moduleVol = new TGeoVolume(moduleName.c_str(), module, medSi);
+  moduleVol->SetLineColor(kYellow);
 
-  TGeoShape* module;
-  TGeoVolume* moduleVol;
-
-  if (type == "cylinder") {
-    double moduleLength = constants::moduleMLOT::length * mNumberOfModules;
-
-    module = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, moduleLength / 2);
-    moduleVol = new TGeoVolume(moduleName.c_str(), module, medSi);
-
-    TGeoVolume* chipVol = createChip("cylinder");
-    LOGP(debug, "Inserting {} in {} ", chipVol->GetName(), moduleVol->GetName());
-    moduleVol->AddNode(chipVol, 1, nullptr);
-  } else if (type == "flat") {
-    double moduleWidth = constants::moduleMLOT::width;
-    double moduleLength = constants::moduleMLOT::length;
-
-    module = new TGeoBBox(moduleWidth / 2, mChipThickness / 2, moduleLength / 2); // TO BE CHECKED !!!
-    moduleVol = new TGeoVolume(moduleName.c_str(), module, medSi);
-
-    for (int iChip = 0; iChip < mHalfNumberOfChips; iChip++) {
-      TGeoVolume* chipVolLeft = createChip("flat");
-      TGeoVolume* chipVolRight = createChip("flat");
-
-      // Put the chips in the correct position
-      double xLeft = -moduleWidth / 2 + constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::width / 2;
-      double zLeft = -moduleLength / 2 + constants::moduleMLOT::gaps::outerEdgeShortSide + iChip * (constants::moduleMLOT::chip::length + constants::moduleMLOT::gaps::interChips) + constants::moduleMLOT::chip::length / 2;
-
-      TGeoCombiTrans* transLeft = new TGeoCombiTrans();
-      transLeft->SetTranslation(xLeft, 0, zLeft); // TO BE CHECKED !!!
-      TGeoRotation* rot = new TGeoRotation();
-      rot->RotateY(180);
-      transLeft->SetRotation(rot);
-      LOGP(debug, "Inserting {} in {} ", chipVolLeft->GetName(), moduleVol->GetName());
-      moduleVol->AddNode(chipVolLeft, iChip * 2, transLeft);
-
-      double xRight = +moduleWidth / 2 - constants::moduleMLOT::gaps::outerEdgeLongSide - constants::moduleMLOT::chip::width / 2;
-      double zRight = -moduleLength / 2 + constants::moduleMLOT::gaps::outerEdgeShortSide + iChip * (constants::moduleMLOT::chip::length + constants::moduleMLOT::gaps::interChips) + constants::moduleMLOT::chip::length / 2;
-
-      TGeoCombiTrans* transRight = new TGeoCombiTrans();
-      transRight->SetTranslation(xRight, 0, zRight); // TO BE CHECKED !!!
-      LOGP(debug, "Inserting {} in {} ", chipVolRight->GetName(), moduleVol->GetName());
-      moduleVol->AddNode(chipVolRight, iChip * 2 + 1, transRight);
-    }
-  } else {
-    LOGP(fatal, "Chip of type '{}' is not implemented", type);
+  for (int iChip = 0; iChip < sHalfNumberOfChips; iChip++) {
+    TGeoVolume* chipVolLeft = createChip();
+    double xLeft = -sModuleWidth / 2 + constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::width / 2;
+    double zLeft = -sModuleLength / 2 + constants::moduleMLOT::gaps::outerEdgeShortSide + iChip * (constants::moduleMLOT::chip::length + constants::moduleMLOT::gaps::interChips) + constants::moduleMLOT::chip::length / 2;
+    TGeoCombiTrans* transLeft = new TGeoCombiTrans();
+    transLeft->SetTranslation(xLeft, 0, zLeft);
+    TGeoRotation* rot = new TGeoRotation();
+    rot->RotateY(180);
+    transLeft->SetRotation(rot);
+    LOGP(debug, "Inserting {} in {} ", chipVolLeft->GetName(), moduleVol->GetName());
+    moduleVol->AddNode(chipVolLeft, iChip * 2, transLeft);
+
+    TGeoVolume* chipVolRight = createChip();
+    double xRight = +sModuleWidth / 2 - constants::moduleMLOT::gaps::outerEdgeLongSide - constants::moduleMLOT::chip::width / 2;
+    double zRight = -sModuleLength / 2 + constants::moduleMLOT::gaps::outerEdgeShortSide + iChip * (constants::moduleMLOT::chip::length + constants::moduleMLOT::gaps::interChips) + constants::moduleMLOT::chip::length / 2;
+    TGeoCombiTrans* transRight = new TGeoCombiTrans();
+    transRight->SetTranslation(xRight, 0, zRight);
+    LOGP(debug, "Inserting {} in {} ", chipVolRight->GetName(), moduleVol->GetName());
+    moduleVol->AddNode(chipVolRight, iChip * 2 + 1, transRight);
   }
 
-  moduleVol->SetLineColor(kYellow);
-
   return moduleVol;
 }
 
-TGeoVolume* TRKLayer::createHalfStave(std::string type)
-{
-  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
-  std::string halfStaveName = GeometryTGeo::getTRKHalfStavePattern() + std::to_string(mLayerNumber);
-
-  TGeoShape* halfStave;
-  TGeoVolume* halfStaveVol;
-
-  double halfStaveLength = constants::moduleMLOT::length * mNumberOfModules;
-
-  if (type == "cylinder") {
-    halfStave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, halfStaveLength / 2);
-    halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medSi);
-
-    TGeoVolume* moduleVol = createModule("cylinder");
-    LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
-    halfStaveVol->AddNode(moduleVol, 1, nullptr);
-  } else if (type == "flat") {
-    double moduleLength = constants::moduleMLOT::length;
-    double halfStaveWidth = constants::OT::halfstave::width;
-
-    halfStave = new TGeoBBox(halfStaveWidth / 2, mChipThickness / 2, halfStaveLength / 2);
-    halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medSi);
-
-    for (int iModule = 0; iModule < mNumberOfModules; iModule++) {
-      TGeoVolume* moduleVol = createModule("flat");
-
-      // Put the modules in the correct position
-      double zPos = -0.5 * mNumberOfModules * moduleLength + (iModule + 0.5) * moduleLength;
-
-      TGeoCombiTrans* trans = new TGeoCombiTrans();
-      trans->SetTranslation(0, 0, zPos); // TO BE CHECKED !!!
-
-      LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
-      halfStaveVol->AddNode(moduleVol, iModule, trans);
-    }
-  }
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-  halfStaveVol->SetLineColor(kYellow);
-
-  return halfStaveVol;
+TRKMLLayer::TRKMLLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
+  : TRKSegmentedLayer(layerNumber, layerName, rInn, numberOfModules, thickOrX2X0, mode)
+{
 }
 
-TGeoVolume* TRKLayer::createStave(std::string type)
+TGeoVolume* TRKMLLayer::createStave()
 {
   TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
   std::string staveName = GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber);
+  TGeoShape* stave = new TGeoBBox(sStaveWidth / 2, mChipThickness / 2, mLength / 2);
+  TGeoVolume* staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
+  staveVol->SetLineColor(kYellow);
 
-  TGeoShape* stave;
-  TGeoVolume* staveVol;
-
-  double staveLength = constants::moduleMLOT::length * mNumberOfModules;
-
-  if (type == "cylinder") {
-    stave = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, staveLength / 2);
-    staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
-
-    TGeoVolume* moduleVol = createModule("cylinder");
+  for (int iModule = 0; iModule < mNumberOfModules; iModule++) {
+    TGeoVolume* moduleVol = createModule();
+    double zPos = -0.5 * mNumberOfModules * sModuleLength + (iModule + 0.5) * sModuleLength;
+    TGeoCombiTrans* trans = new TGeoCombiTrans();
+    trans->SetTranslation(0, 0, zPos);
     LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), staveVol->GetName());
-    staveVol->AddNode(moduleVol, 1, nullptr);
-  } else if (type == "flat") {
-    double moduleLength = constants::moduleMLOT::length;
-    double staveWidth = constants::ML::width;
-
-    stave = new TGeoBBox(staveWidth / 2, mChipThickness / 2, staveLength / 2);
-    staveVol = new TGeoVolume(staveName.c_str(), stave, medAir);
+    staveVol->AddNode(moduleVol, iModule, trans);
+  }
 
-    for (int iModule = 0; iModule < mNumberOfModules; iModule++) {
-      TGeoVolume* moduleVol = createModule("flat");
+  return staveVol;
+}
 
-      // Put the modules in the correct position
-      double zPos = -0.5 * mNumberOfModules * moduleLength + (iModule + 0.5) * moduleLength;
+void TRKMLLayer::createLayer(TGeoVolume* motherVolume)
+{
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * sLogicalVolumeThickness, mInnerRadius + 0.667 * sLogicalVolumeThickness, mLength / 2);
+  TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+  layerVol->SetLineColor(kYellow);
 
-      TGeoCombiTrans* trans = new TGeoCombiTrans();
-      trans->SetTranslation(0, 0, zPos); // TO BE CHECKED !!!
+  // Compute the number of staves
+  int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / sStaveWidth);
+  nStaves += nStaves % 2; // Require an even number of staves
+
+  // Compute the size of the overlap region
+  double theta = 2 * TMath::Pi() / nStaves;
+  double theta1 = std::atan(sStaveWidth / 2 / mInnerRadius);
+  double st = std::sin(theta);
+  double ct = std::cos(theta);
+  double theta2 = std::atan((mInnerRadius * st - sStaveWidth / 2 * ct) / (mInnerRadius * ct + sStaveWidth / 2 * st));
+  double overlap = (theta1 - theta2) * mInnerRadius;
+  LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
+
+  for (int iStave = 0; iStave < nStaves; iStave++) {
+    TGeoVolume* staveVol = createStave();
+    TGeoCombiTrans* trans = new TGeoCombiTrans();
+    double theta = 360. * iStave / nStaves;
+    // TGeoRotation* rot = new TGeoRotation("rot", theta - 90 + 4, 0, 0);
+    TGeoRotation* rot = new TGeoRotation("rot", theta + 90 + 4, 0, 0);
+    trans->SetRotation(rot);
+    trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
+    LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
+    layerVol->AddNode(staveVol, iStave, trans);
+  }
 
-      LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), staveVol->GetName());
-      staveVol->AddNode(moduleVol, iModule, trans);
-    }
-  } else if (type == "staggered") {
-    double overlap = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true)overlap
-    double shift = overlap / 2;
-    double halfstaveWidth = constants::OT::halfstave::width;
+  LOGP(debug, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
+  motherVolume->AddNode(layerVol, 1, nullptr);
+}
 
-    staveVol = new TGeoVolumeAssembly(staveName.c_str());
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-    // Put the half staves in the correct position
-    TGeoVolume* halfStaveVolLeft = createHalfStave("flat");
-    TGeoVolume* halfStaveVolRight = createHalfStave("flat");
+TRKOTLayer::TRKOTLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
+  : TRKSegmentedLayer(layerNumber, layerName, rInn, numberOfModules, thickOrX2X0, mode)
+{
+}
 
-    TGeoCombiTrans* transLeft = new TGeoCombiTrans();
-    transLeft->SetTranslation(-halfstaveWidth / 2 + shift, 0, 0); // TO BE CHECKED !!! 1mm overlap between the modules
-    LOGP(debug, "Inserting {} in {} ", halfStaveVolLeft->GetName(), staveVol->GetName());
-    staveVol->AddNode(halfStaveVolLeft, 0, transLeft);
+TGeoVolume* TRKOTLayer::createHalfStave()
+{
+  TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
+  std::string halfStaveName = GeometryTGeo::getTRKHalfStavePattern() + std::to_string(mLayerNumber);
+  TGeoShape* halfStave = new TGeoBBox(sHalfStaveWidth / 2, mChipThickness / 2, mLength / 2);
+  TGeoVolume* halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medSi);
+  halfStaveVol->SetLineColor(kYellow);
 
-    TGeoCombiTrans* transRight = new TGeoCombiTrans();
-    transRight->SetTranslation(halfstaveWidth / 2 - shift, 0.2, 0); // TO BE CHECKED !!! 1mm overlap between the modules
-    LOGP(debug, "Inserting {} in {} ", halfStaveVolRight->GetName(), staveVol->GetName());
-    staveVol->AddNode(halfStaveVolRight, 1, transRight);
-  } else {
-    LOGP(fatal, "Chip of type '{}' is not implemented", type);
+  for (int iModule = 0; iModule < mNumberOfModules; iModule++) {
+    TGeoVolume* moduleVol = createModule();
+    double zPos = -0.5 * mNumberOfModules * sModuleLength + (iModule + 0.5) * sModuleLength;
+    TGeoCombiTrans* trans = new TGeoCombiTrans();
+    trans->SetTranslation(0, 0, zPos);
+    LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
+    halfStaveVol->AddNode(moduleVol, iModule, trans);
   }
 
-  staveVol->SetLineColor(kYellow);
-
-  return staveVol;
+  return halfStaveVol;
 }
 
-void TRKLayer::createLayer(TGeoVolume* motherVolume)
+TGeoVolume* TRKOTLayer::createStave()
 {
-  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  std::string staveName = GeometryTGeo::getTRKStavePattern() + std::to_string(mLayerNumber);
+  TGeoVolume* staveVol = new TGeoVolumeAssembly(staveName.c_str());
 
-  double layerThickness = mChipThickness;
-  if (mLayout != eLayout::kCylinder) {
-    layerThickness = mLogicalVolumeThickness;
-  }
+  TGeoVolume* halfStaveVolLeft = createHalfStave();
+  TGeoCombiTrans* transLeft = new TGeoCombiTrans();
+  transLeft->SetTranslation(-(sHalfStaveWidth - sInStaveOverlap) / 2, 0, 0);
+  LOGP(debug, "Inserting {} in {} ", halfStaveVolLeft->GetName(), staveVol->GetName());
+  staveVol->AddNode(halfStaveVolLeft, 0, transLeft);
 
-  TGeoTube* layer;
-  TGeoVolume* layerVol;
+  TGeoVolume* halfStaveVolRight = createHalfStave();
+  TGeoCombiTrans* transRight = new TGeoCombiTrans();
+  transRight->SetTranslation((sHalfStaveWidth - sInStaveOverlap) / 2, 0.2, 0);
+  LOGP(debug, "Inserting {} in {} ", halfStaveVolRight->GetName(), staveVol->GetName());
+  staveVol->AddNode(halfStaveVolRight, 1, transRight);
 
-  double layerLength = constants::moduleMLOT::length * mNumberOfModules;
+  return staveVol;
+}
 
-  if (mLayout == eLayout::kCylinder) {
-    layer = new TGeoTube(mInnerRadius, mInnerRadius + mChipThickness, layerLength / 2);
-    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+void TRKOTLayer::createLayer(TGeoVolume* motherVolume)
+{
+  TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
+  TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * sLogicalVolumeThickness, mInnerRadius + 0.667 * sLogicalVolumeThickness, mLength / 2);
+  TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+  layerVol->SetLineColor(kYellow);
 
-    TGeoVolume* staveVol = createStave("cylinder");
+  // Compute the number of staves
+  int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / sStaveWidth);
+  nStaves += nStaves % 2; // Require an even number of staves
+
+  // Compute the size of the overlap region
+  double theta = 2 * TMath::Pi() / nStaves;
+  double theta1 = std::atan(sStaveWidth / 2 / mInnerRadius);
+  double st = std::sin(theta);
+  double ct = std::cos(theta);
+  double theta2 = std::atan((mInnerRadius * st - sStaveWidth / 2 * ct) / (mInnerRadius * ct + sStaveWidth / 2 * st));
+  double overlap = (theta1 - theta2) * mInnerRadius;
+  LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
+
+  for (int iStave = 0; iStave < nStaves; iStave++) {
+    TGeoVolume* staveVol = createStave();
+    TGeoCombiTrans* trans = new TGeoCombiTrans();
+    double theta = 360. * iStave / nStaves;
+    // TGeoRotation* rot = new TGeoRotation("rot", theta - 90, 0, 0);
+    TGeoRotation* rot = new TGeoRotation("rot", theta + 90, 0, 0);
+    trans->SetRotation(rot);
+    trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
     LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
-    layerVol->AddNode(staveVol, 1, nullptr);
-  } else if (mLayout == eLayout::kTurboStaves) {
-    double staveWidth = constants::ML::width; // Each stave has two modules (based on the LOI design)
-
-    if (mInnerRadius > 25) {
-      staveWidth = constants::OT::width; // Outer layers have two modules per stave
-    }
-
-    layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, layerLength / 2);
-    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-
-    // Compute the number of staves
-    int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / staveWidth);
-    nStaves += nStaves % 2; // Require an even number of staves
-
-    // Compute the size of the overlap region
-    double theta = 2 * TMath::Pi() / nStaves;
-    double theta1 = std::atan(staveWidth / 2 / mInnerRadius);
-    double st = std::sin(theta);
-    double ct = std::cos(theta);
-    double theta2 = std::atan((mInnerRadius * st - staveWidth / 2 * ct) / (mInnerRadius * ct + staveWidth / 2 * st));
-    double overlap = (theta1 - theta2) * mInnerRadius;
-    LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
-
-    for (int iStave = 0; iStave < nStaves; iStave++) {
-      TGeoVolume* staveVol = createStave("flat");
-
-      // Put the staves in the correct position and orientation
-      TGeoCombiTrans* trans = new TGeoCombiTrans();
-      double theta = 360. * iStave / nStaves;
-      TGeoRotation* rot = new TGeoRotation("rot", theta + 90 + 4, 0, 0);
-      trans->SetRotation(rot);
-      trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
-
-      LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
-      layerVol->AddNode(staveVol, iStave, trans);
-    }
-  } else if (mLayout == kStaggered) {
-    double overlapInStave = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true)overlap
-
-    double staveWidth = constants::OT::width - overlapInStave;
-
-    layer = new TGeoTube(mInnerRadius - 0.333 * layerThickness, mInnerRadius + 0.667 * layerThickness, layerLength / 2);
-    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
-
-    // Compute the number of staves
-    int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / staveWidth);
-    nStaves += nStaves % 2; // Require an even number of staves
-
-    // Compute the size of the overlap region
-    double theta = 2 * TMath::Pi() / nStaves;
-    double theta1 = std::atan(staveWidth / 2 / mInnerRadius);
-    double st = std::sin(theta);
-    double ct = std::cos(theta);
-    double theta2 = std::atan((mInnerRadius * st - staveWidth / 2 * ct) / (mInnerRadius * ct + staveWidth / 2 * st));
-    double overlap = (theta1 - theta2) * mInnerRadius;
-    LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
-
-    for (int iStave = 0; iStave < nStaves; iStave++) {
-      TGeoVolume* staveVol = createStave("staggered");
-
-      // Put the staves in the correct position and orientation
-      TGeoCombiTrans* trans = new TGeoCombiTrans();
-      double theta = 360. * iStave / nStaves;
-      TGeoRotation* rot = new TGeoRotation("rot", theta + 90, 0, 0);
-      trans->SetRotation(rot);
-      trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
-
-      LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
-      layerVol->AddNode(staveVol, iStave, trans);
-    }
-  } else {
-    LOGP(fatal, "Layout not implemented");
+    layerVol->AddNode(staveVol, iStave, trans);
   }
-  layerVol->SetLineColor(kYellow);
 
   LOGP(debug, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
   motherVolume->AddNode(layerVol, 1, nullptr);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
index fec9cb6631a6f..282fc72becc52 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKSimulationLinkDef.h
@@ -18,7 +18,10 @@
 #pragma link C++ class o2::trk::Hit + ;
 #pragma link C++ class std::vector < o2::trk::Hit> + ;
 
-#pragma link C++ class o2::trk::TRKLayer + ;
+#pragma link C++ class o2::trk::TRKCylindricalLayer + ;
+#pragma link C++ class o2::trk::TRKSegmentedLayer + ;
+#pragma link C++ class o2::trk::TRKMLLayer + ;
+#pragma link C++ class o2::trk::TRKOTLayer + ;
 #pragma link C++ class o2::trk::VDLayer + ;
 #pragma link C++ class o2::trk::TRKServices + ;
 #pragma link C++ class o2::trk::Detector + ;

From b4da18e21dc4928048813bcd57c563bb8de7f165 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 11 Mar 2026 19:44:53 +0100
Subject: [PATCH 1410/1764] full_system_test.sh: add --shm-segment-size to
 MCTracks-to-AO2D conversion tool workflow

---
 prodtests/full_system_test.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 07ccdf01d4566..24215276fd463 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -169,7 +169,7 @@ SIMOPTKEY+="GenTPCLoopers.colsys=${BEAMTYPE};"
 
 taskwrapper sim.log o2-sim ${FST_BFIELD+--field=}${FST_BFIELD} --vertexMode kCollContext --seed $O2SIMSEED -n $NEvents --configKeyValues "\"$SIMOPTKEY\"" -g ${FST_GENERATOR} -e ${FST_MC_ENGINE} -j $NJOBS --run ${RUNNUMBER} -o o2sim --fromCollContext collisioncontext.root:o2sim
 # Test MCTracks to AO2D conversion tool
-taskwrapper kine2aod.log "o2-sim-kine-publisher -b --kineFileName o2sim --aggregate-timeframe $NEvents | o2-sim-mctracks-to-aod -b --aod-writer-keep dangling | o2-analysis-mctracks-to-aod-simple-task -b"
+taskwrapper kine2aod.log "o2-sim-kine-publisher --shm-segment-size $SHMSIZE -b --kineFileName o2sim --aggregate-timeframe $NEvents | o2-sim-mctracks-to-aod --shm-segment-size $SHMSIZE -b --aod-writer-keep dangling | o2-analysis-mctracks-to-aod-simple-task --shm-segment-size $SHMSIZE -b"
 if [[ ! -s AnalysisResults_trees.root ]] || [[ ! -s AnalysisResults.root ]]; then
   echo "Error: AnalysisResults_trees.root (AO2D from Kine file) or AnalysisResults.root (simple analysis task output) missing or empty"
   exit 1

From e17ce87255672c961b0a19abc9a40d4198f1b479 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 11 Mar 2026 17:09:30 +0100
Subject: [PATCH 1411/1764] Methods for Barrel <-> Forward tracks conversion

---
 .../ReconstructionDataFormats/TrackFwd.h      | 12 +++
 .../TrackParametrization.h                    |  4 +
 .../TrackParametrizationWithError.h           |  3 +
 DataFormats/Reconstruction/src/TrackFwd.cxx   | 78 ++++++++++++++++++-
 .../src/TrackParametrization.cxx              | 16 ++++
 .../src/TrackParametrizationWithError.cxx     | 59 ++++++++++++++
 6 files changed, 171 insertions(+), 1 deletion(-)

diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h
index 50ed36d466d25..fca117583027f 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackFwd.h
@@ -31,6 +31,12 @@ using SMatrix55Sym = ROOT::Math::SMatrix<double, 5, 5, ROOT::Math::MatRepSym<dou
 using SMatrix55Std = ROOT::Math::SMatrix<double, 5>;
 using SMatrix5 = ROOT::Math::SVector<Double_t, 5>;
 
+template <typename value_T>
+class TrackParametrization; // fwd declaration for conversion method
+
+template <typename value_T>
+class TrackParametrizationWithError; // fwd declaration for conversion method
+
 class TrackParFwd
 { // Forward track parameterization, kinematics only.
  public:
@@ -42,6 +48,9 @@ class TrackParFwd
   TrackParFwd(TrackParFwd&&) = delete;
   TrackParFwd& operator=(TrackParFwd&&) = delete;
 
+  template <typename T>
+  void toBarrelTrackPar(TrackParametrization<T>& t) const;
+
   /// return Z coordinate (cm)
   Double_t getZ() const { return mZ; }
   /// set Z coordinate (cm)
@@ -145,6 +154,9 @@ class TrackParCovFwd : public TrackParFwd
   TrackParCovFwd& operator=(const TrackParCovFwd& tpf) = default;
   TrackParCovFwd(const Double_t z, const SMatrix5& parameters, const SMatrix55Sym& covariances, const Double_t chi2);
 
+  template <typename T>
+  void toBarrelTrackParCov(TrackParametrizationWithError<T>& t) const;
+
   const SMatrix55Sym& getCovariances() const { return mCovariances; }
   void setCovariances(const SMatrix55Sym& covariances) { mCovariances = covariances; }
   void deleteCovariances() { mCovariances = SMatrix55Sym(); }
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
index 6389b037c3625..918633d914230 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h
@@ -66,6 +66,9 @@ class DCA;
 
 namespace track
 {
+
+class TrackParFwd; // fwd declaration for conversion method
+
 // aliases for track elements
 enum ParLabels : int { kY,
                        kZ,
@@ -252,6 +255,7 @@ class TrackParametrization
   GPUd() void printParam() const;
   GPUd() void printParamHexadecimal();
 #ifndef GPUCA_ALIGPUCODE
+  void toFwdTrackPar(TrackParFwd& t) const;
   std::string asString() const;
   std::string asStringHexadecimal();
   size_t hash() const { return hash(getX(), getAlpha(), getY(), getZ(), getSnp(), getTgl(), getQ2Pt()); }
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
index 0fc01e6db61a2..7f7e1e33144b1 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
@@ -25,6 +25,8 @@ namespace o2
 namespace track
 {
 
+class TrackParCovFwd; // fwd declaration for conversion method
+
 template <typename value_T = float>
 class TrackParametrizationWithError : public TrackParametrization<value_T>
 { // track+error parameterization
@@ -82,6 +84,7 @@ class TrackParametrizationWithError : public TrackParametrization<value_T>
   GPUd() void print() const;
   GPUd() void printHexadecimal();
 #ifndef GPUCA_ALIGPUCODE
+  bool toFwdTrackParCov(TrackParCovFwd& t) const;
   std::string asString() const;
   std::string asStringHexadecimal();
 #endif
diff --git a/DataFormats/Reconstruction/src/TrackFwd.cxx b/DataFormats/Reconstruction/src/TrackFwd.cxx
index dfe72c5b2ccc4..511ba122b2822 100644
--- a/DataFormats/Reconstruction/src/TrackFwd.cxx
+++ b/DataFormats/Reconstruction/src/TrackFwd.cxx
@@ -10,6 +10,8 @@
 // or submit itself to any jurisdiction.
 
 #include "ReconstructionDataFormats/TrackFwd.h"
+#include "ReconstructionDataFormats/TrackParametrization.h"
+#include "ReconstructionDataFormats/TrackParametrizationWithError.h"
 #include "Math/MatrixFunctions.h"
 #include <GPUCommonLogger.h>
 
@@ -41,7 +43,7 @@ void TrackParFwd::propagateParamToZlinear(double zEnd)
   auto dZ = (zEnd - getZ());
   auto phi0 = getPhi();
   auto [sinphi0, cosphi0] = o2::math_utils::sincosd(phi0);
-  auto invtanl0 = 1.0 / getTanl();
+  auto invtanl0 = 1.0 / getTgl();
   auto n = dZ * invtanl0;
   mParameters(0) += n * cosphi0;
   mParameters(1) += n * sinphi0;
@@ -572,5 +574,79 @@ void TrackParCovFwd::propagateToDCAhelix(double zField, const std::array<double,
   return;
 }
 
+template <typename T>
+void TrackParFwd::toBarrelTrackPar(TrackParametrization<T>& t) const
+{
+  // we select the barrel frame with alpha = phi, then by construction the snp is 0
+  auto alpha = getPhi();
+  auto csa = TMath::Cos(alpha), sna = TMath::Sin(alpha);
+  t.setAlpha(alpha);
+  t.setX(csa * getX() + sna * getY());
+  t.setY(-sna * getX() + csa * getY());
+  t.setZ(getZ());
+  t.setSnp(0);
+  t.setTgl(getTanl());
+  t.setQ2Pt(getInvQPt());
+}
+
+template <typename T>
+void TrackParCovFwd::toBarrelTrackParCov(TrackParametrizationWithError<T>& t) const
+{
+  // We select the barrel frame with alpha = phi, then by construction the snp is 0
+  auto alpha = getPhi();
+  auto csa = TMath::Cos(alpha), sna = TMath::Sin(alpha);
+  t.setAlpha(alpha);
+  t.setX(csa * getX() + sna * getY());
+  t.setY(-sna * getX() + csa * getY());
+  t.setZ(getZ());
+  t.setSnp(0);
+  t.setTgl(getTgl());
+  t.setQ2Pt(getInvQPt());
+  /*
+    The standard Jacobian d{barrel_param} / d{fwd_param} should be augmented by the "forward" uncertainty
+    in X_barrel translated to uncertainty in Z, i.e:
+    A fwd param variation delta_x, delta_y leads to barrel frame coordinate variaion
+    delta_xb =  csa delta_x + sna delta_y
+    delta_yb = -sna delta_x + csa delta_y
+    with dx_b/dz = csp/tgL = 1/tgL, dy_b/dz = snp/tgL = 0  (for phi 0 in the tracking frame) the variation of delta_xb would require
+    a shift in delta_zb = -tgL delta_xb to stat at the same X.
+    So, for alpha=phi (-> snp=0) choice the full Jacobian fwd->barrel is:
+    / -sna       csa      0 0 0  \
+    | -tgL*csa  -tgL*sna  0 0 0  |
+    |  0          0       1 0 0  |
+    |  0          0       0 1 0  |
+    \  0          0       0 0 1 /
+  */
+  const T a1 = -sna;
+  const T a2 = csa;
+  const T b1 = -getTgl() * csa;
+  const T b2 = -getTgl() * sna;
+  const T cphi = 1;
+  const auto& C = getCovariances();
+  typename TrackParametrizationWithError<T>::covMat_t covBarrel = {
+    T(a1 * a1 * C(0, 0) + 2 * a1 * a2 * C(0, 1) + a2 * a2 * C(1, 1)),         // kSigY2
+    T(a1 * b1 * C(0, 0) + (a1 * b2 + a2 * b1) * C(0, 1) + a2 * b2 * C(1, 1)), // kSigZY
+    T(b1 * b1 * C(0, 0) + 2 * b1 * b2 * C(0, 1) + b2 * b2 * C(1, 1)),         // kSigZ2
+    T(csa * (a1 * C(0, 2) + a2 * C(1, 2))),                                   // kSigSnpY
+    T(csa * (b1 * C(0, 2) + b2 * C(1, 2))),                                   // kSigSnpZ
+    T(csa * csa * C(2, 2)),                                                   // kSigSnp2
+    T(a1 * C(0, 3) + a2 * C(1, 3)),                                           // kSigTglY
+    T(b1 * C(0, 3) + b2 * C(1, 3)),                                           // kSigTglZ
+    T(csa * C(2, 3)),                                                         // kSigTglSnp
+    T(C(3, 3)),                                                               // kSigTgl2
+    T(a1 * C(0, 4) + a2 * C(1, 4)),                                           // kSigQ2PtY
+    T(b1 * C(0, 4) + b2 * C(1, 4)),                                           // kSigQ2PtZ
+    T(csa * C(2, 4)),                                                         // kSigQ2PtSnp
+    T(C(3, 4)),                                                               // kSigQ2PtTgl
+    T(C(4, 4))                                                                // kSigQ2Pt2
+  };
+  t.setCov(covBarrel);
+}
+
+template void TrackParFwd::toBarrelTrackPar<float>(TrackParametrization<float>&) const;
+template void TrackParFwd::toBarrelTrackPar<double>(TrackParametrization<double>&) const;
+template void TrackParCovFwd::toBarrelTrackParCov<float>(TrackParametrizationWithError<float>&) const;
+template void TrackParCovFwd::toBarrelTrackParCov<double>(TrackParametrizationWithError<double>&) const;
+
 } // namespace track
 } // namespace o2
diff --git a/DataFormats/Reconstruction/src/TrackParametrization.cxx b/DataFormats/Reconstruction/src/TrackParametrization.cxx
index 4b850fe14086b..c238b087d5086 100644
--- a/DataFormats/Reconstruction/src/TrackParametrization.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrization.cxx
@@ -26,6 +26,7 @@
 
 #ifndef GPUCA_ALIGPUCODE
 #include <fmt/printf.h>
+#include "ReconstructionDataFormats/TrackFwd.h"
 #endif
 
 using namespace o2::gpu;
@@ -985,6 +986,21 @@ GPUd() typename TrackParametrization<value_T>::value_t TrackParametrization<valu
   return ttmp.propagateParamToDCA({xmv, ymv, zmv}, b, &dca) ? dca[1] : -9999.;
 }
 
+#ifndef GPUCA_ALIGPUCODE
+//______________________________________________
+template <typename value_T>
+void TrackParametrization<value_T>::toFwdTrackPar(TrackParFwd& t) const
+{
+  auto p = getXYZGlo();
+  t.setZ(p.Z());
+  t.setX(p.X());
+  t.setY(p.Y());
+  t.setPhi(getPhi());
+  t.setTanl(getTgl());
+  t.setInvQPt(getQ2Pt());
+}
+#endif
+
 namespace o2::track
 {
 #if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.
diff --git a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
index 93ff7e1a2eb82..ee2e96736aa6d 100644
--- a/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
+++ b/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
@@ -21,6 +21,7 @@
 
 #ifndef GPUCA_ALIGPUCODE
 #include <fmt/printf.h>
+#include "ReconstructionDataFormats/TrackFwd.h"
 #endif
 
 using namespace o2::track;
@@ -1768,6 +1769,64 @@ GPUd() void TrackParametrizationWithError<value_T>::printHexadecimal()
 #endif
 }
 
+#ifndef GPUCA_ALIGPUCODE
+//______________________________________________________________
+template <typename value_T>
+bool TrackParametrizationWithError<value_T>::toFwdTrackParCov(TrackParCovFwd& t) const
+{
+  auto p = this->getXYZGlo();
+  t.setZ(p.Z());
+  t.setX(p.X());
+  t.setY(p.Y());
+  t.setPhi(this->getPhi());
+  t.setTanl(this->getTgl());
+  t.setInvQPt(this->getQ2Pt());
+  //
+  if (gpu::CAMath::Abs(this->getSnp()) >= o2::constants::math::Almost1 ||
+      gpu::CAMath::Abs(this->getTgl()) <= o2::constants::math::Almost0) {
+    return false;
+  }
+  value_T csa, sna, csP, snP, csp = gpu::CAMath::Sqrt((1. - this->getSnp()) * (1. + this->getSnp()));
+  math_utils::detail::sincos(value_T(this->getAlpha()), sna, csa);
+  math_utils::detail::sincos(value_T(t.getPhi()), snP, csP);
+  /*
+    Jacobian is
+    /-sna  -csP/tgL 0     0 0 \
+    | csa  -snP/tgL 0     0 0 |
+    | 0     0       1/csp 0 0 |
+    | 0     0       0     1 0 |
+    \ 0     0       0     0 1 /
+  */
+  auto tgLI = 1 / this->getTgl();
+  const value_T d1 = -sna;
+  const value_T d2 = -csP * tgLI;
+  const value_T e1 = csa;
+  const value_T e2 = -snP * tgLI;
+  const value_T f1 = 1 / csp;
+  SMatrix55Sym C;
+  C(0, 0) = d1 * d1 * getSigmaY2() + 2 * d1 * d2 * getSigmaZY() + d2 * d2 * getSigmaZ2();
+  C(0, 1) = d1 * e1 * getSigmaY2() + (d1 * e2 + d2 * e1) * getSigmaZY() + d2 * e2 * getSigmaZ2();
+  C(1, 1) = e1 * e1 * getSigmaY2() + 2 * e1 * e2 * getSigmaZY() + e2 * e2 * getSigmaZ2();
+
+  C(0, 2) = f1 * (d1 * getSigmaSnpY() + d2 * getSigmaSnpZ());
+  C(1, 2) = f1 * (e1 * getSigmaSnpY() + e2 * getSigmaSnpZ());
+  C(2, 2) = f1 * f1 * getSigmaSnp2();
+
+  C(0, 3) = d1 * getSigmaTglY() + d2 * getSigmaTglZ();
+  C(1, 3) = e1 * getSigmaTglY() + e2 * getSigmaTglZ();
+  C(2, 3) = f1 * getSigmaTglSnp();
+  C(3, 3) = getSigmaTgl2();
+
+  C(0, 4) = d1 * getSigma1PtY() + d2 * getSigma1PtZ();
+  C(1, 4) = e1 * getSigma1PtY() + e2 * getSigma1PtZ();
+  C(2, 4) = f1 * getSigma1PtSnp();
+  C(3, 4) = getSigma1PtTgl();
+  C(4, 4) = getSigma1Pt2();
+  t.setCovariances(C);
+  return true;
+}
+#endif
+
 namespace o2::track
 {
 #if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.

From 19ded7aa5f3ed75992e50f9b74a7801bac2229f8 Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Thu, 12 Mar 2026 21:25:37 +0100
Subject: [PATCH 1412/1764] [ALICE 3] Update TRK README (#15151)

* Update TRK README

* Update TRK README 2
---
 Detectors/Upgrades/ALICE3/TRK/README.md | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/README.md b/Detectors/Upgrades/ALICE3/TRK/README.md
index 9730c6f6efff7..a061a06be66f3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/README.md
+++ b/Detectors/Upgrades/ALICE3/TRK/README.md
@@ -15,14 +15,13 @@ Configurables for various sub-detectors are presented in the following Table:
 | Subsystem          | Available options                                       | Comments                                                         |
 | ------------------ | ------------------------------------------------------- | ---------------------------------------------------------------- |
 | `TRKBase.layoutVD` | `kIRIS4` (default), `kIRISFullCyl`, `kIRIS5`, `kIRIS4a` | [link to definitions](./base/include/TRKBase/TRKBaseParam.h) |
-| `TRKBase.layoutML` | `kCylinder`, `kTurboStaves` (default), `kStaggered`     |                                                                  |
-| `TRKBase.layoutOT` | `kCylinder`, `kTurboStaves`, `kStaggered` (default)     |                                                                  |
+| `TRKBase.layoutMLOT` | `kCylindrical`, `kSegmented` (default)     | `kSegmented` produced a Turbo layout for ML and a Staggered layout for OT                                                                 |
 | `TRKBase.layoutSRV` | `kPeacockv1` (default), `kLOISymm` | `kLOISymm` produces radially symmetric service volumes, as used in the LoI |
 
 For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by
 ```bash
 o2-sim-serial-run5 -n 1 -g pythia8hi -m A3IP TRK FT3 TF3 \
-  --configKeyValues "TRKBase.layoutVD=kIRISFullCyl;TRKBase.layoutML=kCylinder;TRKBase.layoutOL=kCylinder"
+  --configKeyValues "TRKBase.layoutVD=kIRISFullCyl;TRKBase.layoutMLOT=kCylindrical"
 ```
 
 <!-- doxy

From 2318d8f0ac377d720aa5b1afa631d8e440cd596a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 3 Mar 2026 00:54:45 +0100
Subject: [PATCH 1413/1764] Parse and pass SOR to o2-steer-colcontexttool in
 FST

The o2-steer-colcontexttool was using timestamp -1 (i.e. now) therefore the FST is
generating the context with the mean-vertex available at givin moment. If this happen
to be the default meanvertex with sigmaX,Y of 0.5 cm, the generated data is not reconstructable
in the ITS since the reconstruction will use the meanvertx with small sigma corresponding to the
selected run number.
---
 .../Calibration/testMacros/getRunParameters.cxx    | 14 ++++++++++++++
 prodtests/full_system_test.sh                      |  5 +++++
 2 files changed, 19 insertions(+)

diff --git a/Detectors/Calibration/testMacros/getRunParameters.cxx b/Detectors/Calibration/testMacros/getRunParameters.cxx
index c06926511c95d..d3f9b0a2ece69 100644
--- a/Detectors/Calibration/testMacros/getRunParameters.cxx
+++ b/Detectors/Calibration/testMacros/getRunParameters.cxx
@@ -53,6 +53,18 @@ void writeDurationToFile(long duration)
   fclose(fptr);
 }
 
+void writeSORToFile(long sor)
+{
+
+  FILE* fptr = fopen("SOR.txt", "w");
+  if (fptr == nullptr) {
+    LOGP(fatal, "ERROR: Could not open file to write SOR!");
+    return;
+  }
+  fprintf(fptr, "%ld", sor);
+  fclose(fptr);
+}
+
 void writeBFieldToFile(float b)
 {
 
@@ -165,6 +177,7 @@ int main(int argc, char* argv[])
       ir = -1.f;
       writeIRtoFile(ir);
       writeDurationToFile(run_O2duration);
+      writeSORToFile(tsSOR);
       return 0;
     }
   }
@@ -204,6 +217,7 @@ int main(int argc, char* argv[])
   }
   writeIRtoFile(ir);
   writeDurationToFile(duration);
+  writeSORToFile(tsSOR);
 
   return 0;
 }
diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 24215276fd463..8e252c5a8378f 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -81,6 +81,10 @@ fi
 
 [[ "$FIRSTSAMPLEDORBIT" -lt "$RUNFIRSTORBIT" ]] && FIRSTSAMPLEDORBIT=$RUNFIRSTORBIT
 
+# get run start time
+taskwrapper run_params.log o2-calibration-get-run-parameters -r $RUNNUMBER
+runStartTime=`cat SOR.txt`
+
 # allow skipping
 JOBUTILS_SKIPDONE=ON
 # potentially enable memory monitoring (independent on whether DPL or not)
@@ -162,6 +166,7 @@ taskwrapper collcontext.log o2-steer-colcontexttool \
   --maxCollsPerTF ${NEvents} \
   --orbitsEarly ${OrbitsBeforeTf} \
   --bcPatternFile ccdb \
+  --timestamp ${runStartTime} \
   ${QEDSPEC}
 
 # Include collision system for TPC loopers generation

From bd3c02cbf626d28b2154493934bbf6d209a1444e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 11 Mar 2026 09:48:20 +0100
Subject: [PATCH 1414/1764] GPU Workflow: Avoid duplicated variable

---
 GPU/Workflow/src/GPUWorkflowITS.cxx  | 11 ++++-------
 GPU/Workflow/src/GPUWorkflowSpec.cxx | 11 ++++-------
 2 files changed, 8 insertions(+), 14 deletions(-)

diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index 587b85df98952..46e1b1578285c 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -37,13 +37,10 @@ int32_t GPURecoWorkflowSpec::runITSTracking(o2::framework::ProcessingContext& pc
   LOGP(debug, "GPUChainITS is giving me device propagator: {}", (void*)mGPUReco->GetDeviceO2Propagator());
   mITSTrackingInterface->run(pc);
   static bool first = true;
-  if (first) {
-    first = false;
-    if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
-      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::VertexerParamConfig::Instance().getName()), o2::its::VertexerParamConfig::Instance().getName());
-      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::TrackerParamConfig::Instance().getName()), o2::its::TrackerParamConfig::Instance().getName());
-      o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::ITSGpuTrackingParamConfig::Instance().getName()), o2::its::ITSGpuTrackingParamConfig::Instance().getName());
-    }
+  if (mNTFs == 1 && pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
+    o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::VertexerParamConfig::Instance().getName()), o2::its::VertexerParamConfig::Instance().getName());
+    o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::TrackerParamConfig::Instance().getName()), o2::its::TrackerParamConfig::Instance().getName());
+    o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::ITSGpuTrackingParamConfig::Instance().getName()), o2::its::ITSGpuTrackingParamConfig::Instance().getName());
   }
   return 0;
 }
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index f7fc760b99125..dbb554a14cea4 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -517,13 +517,6 @@ int32_t GPURecoWorkflowSpec::runMain(o2::framework::ProcessingContext* pc, GPUTr
     if (retVal == 0 && mSpecConfig.runITSTracking) {
       retVal = runITSTracking(*pc);
     }
-    static bool first = true;
-    if (first) {
-      first = false;
-      if (pc && pc->services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // TPC ConfigurableCarams are somewhat special, need to construct by hand
-        o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc->services().get<const o2::framework::DeviceSpec>().name, "rec_tpc"), "GPU_rec_tpc,GPU_rec,GPU_proc_param,GPU_proc,GPU_global,trackTuneParams");
-      }
-    }
   }
 
   if (!mSpecConfig.enableDoublePipeline) { // TODO: Why is this needed for double-pipeline?
@@ -819,6 +812,10 @@ void GPURecoWorkflowSpec::run(ProcessingContext& pc)
       mNTFDumps++;
     }
   }
+  if (mNTFs == 1 && pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // TPC ConfigurableCarams are somewhat special, need to construct by hand
+    o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, "rec_tpc"), "GPU_rec_tpc,GPU_rec,GPU_proc_param,GPU_proc,GPU_global,trackTuneParams");
+  }
+
   std::unique_ptr<GPUTrackingInOutPointers> ptrsDump;
   if (mConfParam->dumpBadTFMode == 2) {
     ptrsDump.reset(new GPUTrackingInOutPointers);

From e608207349277272f181a43e9f8c099fa541c045 Mon Sep 17 00:00:00 2001
From: Piotr Konopka <piotr.jan.konopka@cern.ch>
Date: Fri, 13 Mar 2026 17:15:16 +0100
Subject: [PATCH 1415/1764] Mergers: Retry with gDebug if merging fails
 (#15153)

...to help understand the error in QC-1340.

I get the following with newly added test case:
```
Error in <TH1Merger::DifferentAxesMerge>: Cannot merge histograms - the histograms obj1 can extend the X axis or have different limits and underflows/overflows are present in the histogram obj2.
[ERROR] Failed to merge the input object 'obj2' of type 'TH1I and the target object 'obj1' of type 'TH1I'
Info in <TH1Merger::ExamineHistogram>: Examine histogram obj1 - labels 0 - same limits 1 - axis found 1
Info in <TH1Merger::ExamineHistogram>: Examine histogram obj2 - labels 0 - same limits 0 - axis found 1
Info in <Merge>: Histogram Merge type is 2 and new axis flag is 1
Info in <DefineNewAxis>: A new X axis has been defined Nbins=20 , [0.000000,20.000000]
Info in <TH1Merger::DifferentAxesMerge>: Merging histogram obj1 into obj1
Info in <TH1Merger::DifferentAxesMerge>: Merging histogram obj2 into obj1
Error in <TH1Merger::DifferentAxesMerge>: Cannot merge histograms - the histograms obj1 can extend the X axis or have different limits and underflows/overflows are present in the histogram obj2.
[ERROR] Merging 'obj2' and 'obj1' failed again after a retry for debugging purposes. See ROOT warnings for details.
```

What bothers me is that the ROOT error is actually printed there even before gDebug is enabled, while we see no ROOT error in the case of QC-1340, even though stderr output is redirected to infologger by o2-aliecs-executor.
Perhaps whathever is triggering the error does not have an error log associated with it in ROOT?
---
 Utilities/Mergers/src/MergerAlgorithm.cxx | 99 ++++++++++++++---------
 Utilities/Mergers/test/test_Algorithm.cxx | 16 ++++
 2 files changed, 76 insertions(+), 39 deletions(-)

diff --git a/Utilities/Mergers/src/MergerAlgorithm.cxx b/Utilities/Mergers/src/MergerAlgorithm.cxx
index a3be493d8e34e..9395dd0a2b3f7 100644
--- a/Utilities/Mergers/src/MergerAlgorithm.cxx
+++ b/Utilities/Mergers/src/MergerAlgorithm.cxx
@@ -95,6 +95,52 @@ auto matchCollectedToPairs(const std::vector<TObject*>& targetObjects, const std
   return matchedObjects;
 }
 
+// calls the default Merge methods of TObjects
+Long64_t mergeDefault(TObject* const target, TObject* const other)
+{
+  Long64_t errorCode = 0;
+
+  TObjArray otherCollection;
+  otherCollection.SetOwner(false);
+  otherCollection.Add(other);
+
+  if (target->InheritsFrom(TH1::Class())) {
+    // this includes TH1, TH2, TH3
+    auto targetTH1 = reinterpret_cast<TH1*>(target);
+    if (targetTH1->TestBit(TH1::kIsAverage)) {
+      // Merge() does not support averages, we have to use Add()
+      // this will break if collection.size != 1
+      if (auto otherTH1 = dynamic_cast<TH1*>(otherCollection.First())) {
+        errorCode = targetTH1->Add(otherTH1);
+      }
+    } else {
+      // Add() does not support histograms with labels, thus we resort to Merge() by default
+      errorCode = targetTH1->Merge(&otherCollection);
+    }
+  } else if (target->InheritsFrom(THnBase::Class())) {
+    // this includes THn and THnSparse
+    errorCode = reinterpret_cast<THnBase*>(target)->Merge(&otherCollection);
+  } else if (target->InheritsFrom(TTree::Class())) {
+    auto targetTree = reinterpret_cast<TTree*>(target);
+    auto otherTree = reinterpret_cast<TTree*>(other);
+    auto targetTreeSize = estimateTreeSize(targetTree);
+    auto otherTreeSize = estimateTreeSize(otherTree);
+    if (auto totalSize = targetTreeSize + otherTreeSize; totalSize > 100000000) {
+      LOG(warn) << "The tree '" << targetTree->GetName() << "' would be larger than 100MB (" << totalSize << "B) after merging, skipping to let the system survive";
+      errorCode = 0;
+    } else {
+      errorCode = targetTree->Merge(&otherCollection);
+    }
+  } else if (target->InheritsFrom(TGraph::Class())) {
+    errorCode = reinterpret_cast<TGraph*>(target)->Merge(&otherCollection);
+  } else if (target->InheritsFrom(TEfficiency::Class())) {
+    errorCode = reinterpret_cast<TEfficiency*>(target)->Merge(&otherCollection);
+  } else {
+    LOG(warn) << "Object '" + std::string(target->GetName()) + "' with type '" + std::string(target->ClassName()) + "' is not one of the mergeable types, skipping";
+  }
+  return errorCode;
+}
+
 void merge(TObject* const target, TObject* const other)
 {
   if (target == nullptr) {
@@ -158,48 +204,23 @@ void merge(TObject* const target, TObject* const other)
     }
 
   } else {
-    Long64_t errorCode = 0;
-    TObjArray otherCollection;
-    otherCollection.SetOwner(false);
-    otherCollection.Add(other);
-
-    if (target->InheritsFrom(TH1::Class())) {
-      // this includes TH1, TH2, TH3
-      auto targetTH1 = reinterpret_cast<TH1*>(target);
-      if (targetTH1->TestBit(TH1::kIsAverage)) {
-        // Merge() does not support averages, we have to use Add()
-        // this will break if collection.size != 1
-        if (auto otherTH1 = dynamic_cast<TH1*>(otherCollection.First())) {
-          errorCode = targetTH1->Add(otherTH1);
-        }
-      } else {
-        // Add() does not support histograms with labels, thus we resort to Merge() by default
-        errorCode = targetTH1->Merge(&otherCollection);
-      }
-    } else if (target->InheritsFrom(THnBase::Class())) {
-      // this includes THn and THnSparse
-      errorCode = reinterpret_cast<THnBase*>(target)->Merge(&otherCollection);
-    } else if (target->InheritsFrom(TTree::Class())) {
-      auto targetTree = reinterpret_cast<TTree*>(target);
-      auto otherTree = reinterpret_cast<TTree*>(other);
-      auto targetTreeSize = estimateTreeSize(targetTree);
-      auto otherTreeSize = estimateTreeSize(otherTree);
-      if (auto totalSize = targetTreeSize + otherTreeSize; totalSize > 100000000) {
-        LOG(warn) << "The tree '" << targetTree->GetName() << "' would be larger than 100MB (" << totalSize << "B) after merging, skipping to let the system survive";
-        errorCode = 0;
-      } else {
-        errorCode = targetTree->Merge(&otherCollection);
-      }
-    } else if (target->InheritsFrom(TGraph::Class())) {
-      errorCode = reinterpret_cast<TGraph*>(target)->Merge(&otherCollection);
-    } else if (target->InheritsFrom(TEfficiency::Class())) {
-      errorCode = reinterpret_cast<TEfficiency*>(target)->Merge(&otherCollection);
-    } else {
-      LOG(warn) << "Object '" + std::string(target->GetName()) + "' with type '" + std::string(target->ClassName()) + "' is not one of the mergeable types, skipping";
-    }
+    Long64_t errorCode = mergeDefault(target, other);
+
     if (errorCode == -1) {
       LOG(error) << "Failed to merge the input object '" + std::string(other->GetName()) + "' of type '" + std::string(other->ClassName()) //
                       + " and the target object '" + std::string(target->GetName()) + "' of type '" + std::string(target->ClassName()) + "'";
+
+      // we retry with debug options enabled in ROOT in hopes to get some logs explaining the issue
+      gDebug = true;
+      errorCode = mergeDefault(target, other);
+      gDebug = false;
+      if (errorCode == -1) {
+        LOG(error) << "Merging '" + std::string(other->GetName()) + "' and '" + std::string(target->GetName()) //
+                        + "' failed again after a retry for debugging purposes. See ROOT warnings for details.";
+      } else {
+        LOG(warn) << "Merging '" + std::string(other->GetName()) + "' and '" + std::string(target->GetName()) //
+                       + "' succeeded after retrying for debugging purposes.";
+      }
     }
   }
 }
diff --git a/Utilities/Mergers/test/test_Algorithm.cxx b/Utilities/Mergers/test/test_Algorithm.cxx
index f087254e00d05..4e9e538719655 100644
--- a/Utilities/Mergers/test/test_Algorithm.cxx
+++ b/Utilities/Mergers/test/test_Algorithm.cxx
@@ -97,6 +97,22 @@ BOOST_AUTO_TEST_CASE(MergerSingularObjects)
     delete other;
     delete target;
   }
+  {
+    // mismatching axes - merging should fail.
+    // we should run again merging with gDebug enabled to see more logs from ROOT (tested only manually by visual inspection of logs)
+    TH1I* target = new TH1I("obj1", "obj1", bins, min, max);
+    target->Fill(5);
+    TH1I* other = new TH1I("obj2", "obj2", bins, max, max + 10);
+    other->Fill(2);
+    other->Fill(2);
+
+    BOOST_CHECK_NO_THROW(algorithm::merge(target, other));
+    BOOST_CHECK_EQUAL(target->GetBinContent(target->FindBin(2)), 0);
+    BOOST_CHECK_EQUAL(target->GetBinContent(target->FindBin(5)), 1);
+
+    delete other;
+    delete target;
+  }
   {
     TH2I* target = new TH2I("obj1", "obj1", bins, min, max, bins, min, max);
     target->Fill(5, 5);

From fd78301558694324c800ba8adbe85f3fc8ec80c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Fri, 13 Mar 2026 19:48:40 +0100
Subject: [PATCH 1416/1764] [ALICE3] Update oTOF radius (#15140)

---
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  | 52 ++++++++++---------
 1 file changed, 28 insertions(+), 24 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index d4e34c582bbed..9b097a0243597 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -61,10 +61,8 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
                             const float x2x0)
 {
 
-  const float radiusInnerTof = 19.f;
-  const float radiusOuterTof = 85.f;
-  const float lengthInnerTof = 124.f;
-  float lengthOuterTof = 680.f;
+  const std::pair<float, float> dInnerTof = {21.f, 129.f}; // Radius and length
+  std::pair<float, float> dOuterTof = {92.f, 680.f};       // Radius and length
   std::pair<float, float> radiusRangeDiskTof = {15.f, 100.f};
   float zForwardTof = 370.f;
   LOG(info) << "Configuring IOTOF layers with '" << pattern << "' pattern";
@@ -74,49 +72,55 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     ftof = false;
     btof = false;
   } else if (pattern == "v3b1a") {
-    lengthOuterTof = 500.f;
+    dOuterTof.second = 500.f;
     zForwardTof = 270.f;
     radiusRangeDiskTof = {30.f, 100.f};
   } else if (pattern == "v3b1b") {
-    lengthOuterTof = 500.f;
+    dOuterTof.second = 500.f;
     zForwardTof = 200.f;
     radiusRangeDiskTof = {20.f, 68.f};
   } else if (pattern == "v3b2a") {
-    lengthOuterTof = 440.f;
+    dOuterTof.second = 440.f;
     zForwardTof = 270.f;
     radiusRangeDiskTof = {30.f, 120.f};
   } else if (pattern == "v3b2b") {
-    lengthOuterTof = 440.f;
+    dOuterTof.second = 440.f;
     zForwardTof = 200.f;
     radiusRangeDiskTof = {20.f, 68.f};
   } else if (pattern == "v3b3") {
-    lengthOuterTof = 580.f;
+    dOuterTof.second = 580.f;
     zForwardTof = 200.f;
     radiusRangeDiskTof = {20.f, 68.f};
   } else {
     LOG(fatal) << "IOTOF layer pattern " << pattern << " not recognized, exiting";
   }
   if (itof) { // iTOF
-    mITOFLayer = itofSegmented ? ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()},
-                                           radiusInnerTof, 0.f, lengthInnerTof, 0.f, x2x0, ITOFLayer::kBarrelSegmented,
-                                           24, 5.42, 10.0, 10)
-                               : ITOFLayer(std::string{GeometryTGeo::getITOFLayerPattern()},
-                                           radiusInnerTof, 0.f, lengthInnerTof, 0.f, x2x0, ITOFLayer::kBarrel);
+    const std::string name = GeometryTGeo::getITOFLayerPattern();
+    const int nStaves = itofSegmented ? 24 : 0;               // number of staves in segmented case
+    const double staveWidth = itofSegmented ? 5.42 : 0.0;     // cm
+    const double staveTiltAngle = itofSegmented ? 10.0 : 0.0; // degrees
+    const int modulesPerStave = itofSegmented ? 10 : 0;       // number of modules per stave in segmented case
+    mITOFLayer = ITOFLayer(name,
+                           dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, ITOFLayer::kBarrelSegmented,
+                           nStaves, staveWidth, staveTiltAngle, modulesPerStave);
   }
   if (otof) { // oTOF
-    mOTOFLayer = otofSegmented ? OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()},
-                                           radiusOuterTof, 0.f, lengthOuterTof, 0.f, x2x0, OTOFLayer::kBarrelSegmented,
-                                           62, 9.74, 5.0, 54)
-                               : OTOFLayer(std::string{GeometryTGeo::getOTOFLayerPattern()},
-                                           radiusOuterTof, 0.f, lengthOuterTof, 0.f, x2x0, OTOFLayer::kBarrel);
+    const std::string name = GeometryTGeo::getOTOFLayerPattern();
+    const int nStaves = otofSegmented ? 62 : 0;              // number of staves in segmented case
+    const double staveWidth = otofSegmented ? 9.74 : 0.0;    // cm
+    const double staveTiltAngle = otofSegmented ? 5.0 : 0.0; // degrees
+    const int modulesPerStave = otofSegmented ? 54 : 0;      // number of modules per stave in segmented case
+    mOTOFLayer = OTOFLayer(name,
+                           dOuterTof.first, 0.f, dOuterTof.second, 0.f, x2x0, OTOFLayer::kBarrelSegmented,
+                           nStaves, staveWidth, staveTiltAngle, modulesPerStave);
   }
   if (ftof) {
-    mFTOFLayer = FTOFLayer(std::string{GeometryTGeo::getFTOFLayerPattern()},
-                           radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, zForwardTof, x2x0, FTOFLayer::kDisk); // fTOF
+    const std::string name = GeometryTGeo::getFTOFLayerPattern();
+    mFTOFLayer = FTOFLayer(name, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, zForwardTof, x2x0, FTOFLayer::kDisk); // fTOF
   }
   if (btof) {
-    mBTOFLayer = BTOFLayer(std::string{GeometryTGeo::getBTOFLayerPattern()},
-                           radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, -zForwardTof, x2x0, BTOFLayer::kDisk); // bTOF
+    const std::string name = GeometryTGeo::getBTOFLayerPattern();
+    mBTOFLayer = BTOFLayer(name, radiusRangeDiskTof.first, radiusRangeDiskTof.second, 0.f, -zForwardTof, x2x0, BTOFLayer::kDisk); // bTOF
   }
 }
 
@@ -338,4 +342,4 @@ o2::itsmft::Hit* Detector::addHit(int trackID, int detID, const TVector3& startP
 } // namespace iotof
 } // namespace o2
 
-ClassImp(o2::iotof::Detector);
\ No newline at end of file
+ClassImp(o2::iotof::Detector);

From ddce6a52e8cb08f8c7f83933947d3f1f49bf7a02 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 13 Mar 2026 15:13:48 +0100
Subject: [PATCH 1417/1764] Fix ITS seeding for B=0

The convention is to assign to q/pT = 1/mostProbablePt(=0.6) in case of B=0
---
 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu | 2 +-
 Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 353464e10712d..525b37eb52891 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -146,7 +146,7 @@ GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
     const float dx = x3 - x1;
     const float dy = y3 - y1;
     snp = sign * dy / o2::gpu::CAMath::Hypot(dx, dy);
-    q2pt = sign / track::kMostProbablePt;
+    q2pt = 1.f / track::kMostProbablePt;
     q2pt2 = 1.f;
   } else {
     const float crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index d46db96339495..da7c9afdd3ed6 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -1281,7 +1281,7 @@ track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster
     const float dx = x3 - x1;
     const float dy = y3 - y1;
     snp = sign * dy / o2::gpu::CAMath::Hypot(dx, dy);
-    q2pt = sign / track::kMostProbablePt;
+    q2pt = 1.f / track::kMostProbablePt;
     q2pt2 = 1.f;
   } else {
     const float crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);

From c1af82da4d58f3a2b9c5b3744512b43c5799e2fd Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Sat, 14 Mar 2026 11:07:04 +0100
Subject: [PATCH 1418/1764] [ALICE3] adding trapezoidal disk option for FT3;
 fixing overlaps in FT3 and TOF (#15158)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* adding trapezoidal disk option for FT3; fixing overlaps in FT3 OT modules and TF3

* Please consider the following formatting changes

---------

Co-authored-by: Igor Altsybeev <Igor.Altsybeev@cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
Co-authored-by: Nicolò Jacazio <njacazio@users.noreply.github.com>
---
 .../FT3/base/include/FT3Base/FT3BaseParam.h   |  18 +--
 .../FT3/base/include/FT3Base/GeometryTGeo.h   |   3 +-
 .../ALICE3/FT3/base/src/GeometryTGeo.cxx      |   3 +-
 .../include/FT3Simulation/FT3Layer.h          |   1 +
 .../ALICE3/FT3/simulation/src/Detector.cxx    |  16 +-
 .../ALICE3/FT3/simulation/src/FT3Layer.cxx    | 140 ++++++++++++++++--
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  |  10 +-
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     |  16 +-
 8 files changed, 157 insertions(+), 50 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
index 7160067f075f7..67bf42458a88a 100644
--- a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
+++ b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
@@ -19,20 +19,16 @@ namespace o2
 {
 namespace ft3
 {
-
-// **
-// ** Parameters for FT3 base configuration
-// **
-
-enum FT3Geometry {
-  Default = 0,
-  Telescope = 1
+// Parameters for FT3 (ML and OT disks)
+enum eFT3Layout {
+  kCylindrical = 0,
+  kTrapezoidal,
+  kSegmented,
 };
-
 struct FT3BaseParam : public o2::conf::ConfigurableParamHelper<FT3BaseParam> {
   // Geometry Builder parameters
-
-  Int_t geoModel = FT3Geometry::Default;
+  eFT3Layout layoutFT3 = kSegmented;
+  int nTrapezoidalSegments = 32; // for the simple trapezoidal disks
 
   // FT3Geometry::Telescope parameters
   Int_t nLayers = 10;
diff --git a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h
index 3c78850dffb55..1941b543579db 100644
--- a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/GeometryTGeo.h
@@ -94,6 +94,7 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   static const char* getFT3LayerPattern() { return sLayerName.c_str(); }
   static const char* getFT3ChipPattern() { return sChipName.c_str(); }
   static const char* getFT3SensorPattern() { return sSensorName.c_str(); }
+  static const char* getFT3PassivePattern() { return sPassiveName.c_str(); }
 
   static const char* composeSymNameFT3(Int_t d) { return Form("%s_%d", o2::detectors::DetID(o2::detectors::DetID::FT3).getName(), d); }
   static const char* composeSymNameLayer(Int_t d, Int_t lr);
@@ -105,8 +106,8 @@ class GeometryTGeo : public o2::itsmft::GeometryTGeo
   static std::string sVolumeName;      ///< Mother volume name
   static std::string sLayerName;       ///< Layer name
   static std::string sChipName;        ///< Chip name
-
   static std::string sSensorName; ///< Sensor name
+  static std::string sPassiveName; ///< Passive material name
 
  private:
   static std::unique_ptr<o2::ft3::GeometryTGeo> sInstance; ///< singletone instance
diff --git a/Detectors/Upgrades/ALICE3/FT3/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/FT3/base/src/GeometryTGeo.cxx
index 6833c4c3d1b89..73b2bc9b94eb8 100644
--- a/Detectors/Upgrades/ALICE3/FT3/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/base/src/GeometryTGeo.cxx
@@ -52,8 +52,9 @@ std::unique_ptr<o2::ft3::GeometryTGeo> GeometryTGeo::sInstance;
 std::string GeometryTGeo::sVolumeName = "FT3V";          ///< Mother volume name
 std::string GeometryTGeo::sInnerVolumeName = "FT3Inner"; ///< Mother inner volume name
 std::string GeometryTGeo::sLayerName = "FT3Layer";       ///< Layer name
-std::string GeometryTGeo::sChipName = "FT3Chip";         ///< Sensor name
+std::string GeometryTGeo::sChipName = "FT3Chip";         ///< Chip name
 std::string GeometryTGeo::sSensorName = "FT3Sensor";     ///< Sensor name
+std::string GeometryTGeo::sPassiveName = "FT3Passive";   ///< Passive material name
 
 //__________________________________________________________________________
 GeometryTGeo::GeometryTGeo(bool build, int loadTrans) : o2::itsmft::GeometryTGeo(DetID::FT3)
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
index 44fd8eb08e444..f6acebe80ac33 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
@@ -86,6 +86,7 @@ class FT3Layer : public TObject
   Double_t mOuterRadius;      ///< Outer radius of this layer
   Double_t mZ;                ///< Z position of the layer
   Double_t mChipThickness;    ///< Chip thickness
+  Double_t mSensorThickness;  ///< Sensor thickness
   Double_t mx2X0;             ///< Layer material budget x/X0
 
   ClassDefOverride(FT3Layer, 0); // ALICE 3 EndCaps geometry
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index 0a93a4061ae44..02aae95daacfe 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -356,21 +356,7 @@ Detector::Detector(bool active)
     mTrackData(),
     mHits(o2::utils::createSimVector<o2::itsmft::Hit>())
 {
-
-  // FT3 Base configuration parameters
-  auto& ft3BaseParam = FT3BaseParam::Instance();
-
-  switch (ft3BaseParam.geoModel) {
-    case Default:
-      buildFT3ScopingV3(); // v3 Dec 25
-      break;
-    case Telescope:
-      buildBasicFT3(ft3BaseParam); // BasicFT3 = Parametrized telescopic detector (equidistant layers)
-      break;
-    default:
-      LOG(fatal) << "Invalid Geometry.\n";
-      break;
-  }
+  buildFT3ScopingV3(); // v3 Dec 25
 }
 
 //_________________________________________________________________________________________________
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
index 1ad4d1aad1eeb..453d90501802e 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -16,22 +16,17 @@
 
 #include "FT3Simulation/FT3Layer.h"
 #include "FT3Base/GeometryTGeo.h"
-
-#include <fairlogger/Logger.h> // for LOG
+#include "FT3Base/FT3BaseParam.h"
 
 #include <TGeoManager.h>        // for TGeoManager, gGeoManager
 #include <TGeoMatrix.h>         // for TGeoCombiTrans, TGeoRotation, etc
 #include <TGeoTube.h>           // for TGeoTube, TGeoTubeSeg
+#include <TGeoArb8.h>           // for TGeoTrap
 #include <TGeoVolume.h>         // for TGeoVolume, TGeoVolumeAssembly
 #include <TGeoCompositeShape.h> // for TGeoCompositeShape
 #include "TMathBase.h"          // for Abs
 #include <TMath.h>              // for Sin, RadToDeg, DegToRad, Cos, Tan, etc
 
-#include <TGeoBBox.h>
-#include <string>
-#include <cstdio> // for snprintf
-#include <cmath>
-
 class TGeoMedium;
 
 using namespace TMath;
@@ -68,6 +63,7 @@ FT3Layer::FT3Layer(Int_t layerDirection, Int_t layerNumber, std::string layerNam
   mOuterRadius = rOut;
   const double Si_X0 = 9.5;
   mChipThickness = Layerx2X0 * Si_X0;
+  mSensorThickness = 0.005; // assume 50 microns of active thickness (for sensor volumes for trapezoidal disks)
 
   // Sanity checks
   if (std::isnan(mZ)) {
@@ -232,10 +228,130 @@ void FT3Layer::createSeparationLayer(TGeoVolume* motherVolume, const std::string
 
 void FT3Layer::createLayer(TGeoVolume* motherVolume)
 {
+  auto& ft3Params = FT3BaseParam::Instance();
+
   if (mLayerNumber < 0) {
     LOG(fatal) << "Invalid layer number " << mLayerNumber << " for FT3 layer.";
   }
-  if (mIsMiddleLayer) { // ML disks
+
+  LOG(info) << "FT3: ft3Params.layoutFT3 = " << ft3Params.layoutFT3;
+
+  // ### options for ML and OT disk layout
+  if (ft3Params.layoutFT3 == kTrapezoidal || (mIsMiddleLayer && ft3Params.layoutFT3 == kSegmented)) {
+    // trapezoidal ML+OT disks
+    // (disks with TGeoTubes doesn'n work properly in ACTS, due to polar coordinates on TGeoTube sides)
+
+    // (!) Currently (March 12, 2026), only OT disks are segmented --> use Trapezoidal option for ML disks as a simplified segmentation
+    // To be changed to "true" paving with modules, as for the OT disks
+
+    std::string chipName = o2::ft3::GeometryTGeo::getFT3ChipPattern() + std::to_string(mLayerNumber);
+    std::string sensName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), mDirection, mLayerNumber);
+    std::string passiveName = o2::ft3::GeometryTGeo::getFT3PassivePattern() + std::to_string(mLayerNumber);
+
+    TGeoMedium* medSi = gGeoManager->GetMedium("FT3_SILICON$");
+    TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$");
+
+    TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mChipThickness / 2);
+    TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+    layerVol->SetLineColor(kGray);
+
+    const int NtrapezoidalSegments = ft3Params.nTrapezoidalSegments;
+
+    const double dz = mChipThickness / 2;
+    const double dzSensor = mSensorThickness / 2;
+
+    const double dphi = 2.0 * TMath::Pi() / NtrapezoidalSegments;
+    double innerRadiusTrapezoidCorner = mInnerRadius / sin((TMath::Pi() - dphi) / 2); // to ensure that the trapezoid segments do not extend beyond the volume
+
+    const double rc = 0.5 * (innerRadiusTrapezoidCorner + mOuterRadius) * TMath::Cos(0.5 * dphi); // radius of tile center
+    const double h = 0.5 * (mOuterRadius - innerRadiusTrapezoidCorner) * TMath::Cos(0.5 * dphi);  // half radial length
+
+    // chord lengths at inner/outer radii
+    const double bl = innerRadiusTrapezoidCorner * TMath::Sin(0.5 * dphi); // half lower base
+    const double tl = mOuterRadius * TMath::Sin(0.5 * dphi);               // half upper base
+
+    // create trapezoids
+    for (int iTr = 0; iTr < NtrapezoidalSegments; ++iTr) {
+      // chip volume
+      auto trdShapeChip = new TGeoTrap(dz,
+                                       0.0, 0.0, // theta, phi
+                                       h,        // h1
+                                       bl,       // bl1
+                                       tl,       // tl1
+                                       0.0,      // alpha1
+                                       h,        // h2
+                                       bl,       // bl2
+                                       tl,       // tl2
+                                       0.0);     // alpha2
+      TGeoVolume* trapezoidChipVolume = new TGeoVolume(chipName.c_str(), trdShapeChip, medSi);
+      trapezoidChipVolume->SetLineColor(kCyan);
+      trapezoidChipVolume->SetTransparency(50);
+
+      // sensor volume
+      auto trdShapeSensor = new TGeoTrap(dzSensor,
+                                         0.0, 0.0, // theta, phi
+                                         h,        // h1
+                                         bl,       // bl1
+                                         tl,       // tl1
+                                         0.0,      // alpha1
+                                         h,        // h2
+                                         bl,       // bl2
+                                         tl,       // tl2
+                                         0.0);     // alpha2
+      TGeoVolume* trapezoidSensorVolume = new TGeoVolume(sensName.c_str(), trdShapeSensor, medSi);
+      trapezoidSensorVolume->SetLineColor(kYellow);
+
+      // placing sensor in chip:
+      const double zSensorInChip = (dz - dzSensor) * (mZ < 0 ? 1 : -1); // place sensor at the outer face of the chip, towards the incoming particles
+      TGeoCombiTrans* transSens = new TGeoCombiTrans();
+      transSens->SetTranslation(0, 0, zSensorInChip);
+      trapezoidChipVolume->AddNode(trapezoidSensorVolume, iTr, transSens);
+
+      // passive volume
+      auto trdShapePassive = new TGeoTrap(dz - dzSensor,
+                                          0.0, 0.0, // theta, phi
+                                          h,        // h1
+                                          bl,       // bl1
+                                          tl,       // tl1
+                                          0.0,      // alpha1
+                                          h,        // h2
+                                          bl,       // bl2
+                                          tl,       // tl2
+                                          0.0);     // alpha2
+      TGeoVolume* trapezoidPassiveVolume = new TGeoVolume(passiveName.c_str(), trdShapePassive, medSi);
+      trapezoidPassiveVolume->SetLineColor(kGray);
+
+      // placing passive volume in chip:
+      const double zPassiveInChip = (-dzSensor) * (mZ < 0 ? 1 : -1); // place passive volume at the outer face of the chip, towards the incoming particles
+      TGeoCombiTrans* transPassive = new TGeoCombiTrans();
+      transPassive->SetTranslation(0, 0, zPassiveInChip);
+      trapezoidChipVolume->AddNode(trapezoidPassiveVolume, iTr, transPassive);
+
+      // prepare placing of chip in layer:
+      const double phi_c = (iTr + 0.5) * dphi; // sector center
+      const double phi_deg = phi_c * 180.0 / TMath::Pi();
+
+      // center of tile
+      const double x = rc * TMath::Cos(phi_c);
+      const double y = rc * TMath::Sin(phi_c);
+      const double z = 0.0;
+
+      // local +Y should point radially outward
+      auto rot = new TGeoRotation();
+      rot->RotateZ(phi_deg - 90.0);
+      auto transf = new TGeoCombiTrans(x, y, z, rot);
+
+      layerVol->AddNode(trapezoidChipVolume, iTr, transf);
+    }
+
+    LOG(info) << "Inserting " << NtrapezoidalSegments << " trapezoidal segments (Rmin="
+              << mInnerRadius << ", Rmax=" << mOuterRadius << ", z = " << mZ << "cm) inside " << layerVol->GetName();
+
+    auto* diskRotation = new TGeoRotation("TrapezoidalDiskRotation", 0, 0, 0);
+    auto* diskCombiTrans = new TGeoCombiTrans(0, 0, mZ, diskRotation);
+    motherVolume->AddNode(layerVol, 1, diskCombiTrans);
+  } else if (ft3Params.layoutFT3 == kCylindrical) {
+    // cylindrical ML+OT disks
 
     std::string chipName = o2::ft3::GeometryTGeo::getFT3ChipPattern() + std::to_string(mLayerNumber),
                 sensName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), mDirection, mLayerNumber);
@@ -265,9 +381,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
 
     LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
-
-  } else { // OT disks
-
+  } else if (ft3Params.layoutFT3 == kSegmented) {
     FT3Module module;
 
     // layer structure
@@ -276,7 +390,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     std::string separationLayerName = "FT3SeparationLayer" + std::to_string(mDirection) + std::to_string(mLayerNumber);
 
     TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$");
-    TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, 10 * mChipThickness / 2);
+    TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, 12 * mChipThickness / 2); // additional "thickness factor" is to avoid sub-volumes crossing the mother layer
     TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
     layerVol->SetLineColor(kYellow + 2);
 
@@ -293,5 +407,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
 
     LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
+  } else {
+    LOG(fatal) << "Unknown FT3 layout option: " << static_cast<int>(ft3Params.layoutFT3);
   }
 }
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index 9b097a0243597..0a83c19125b70 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -96,10 +96,10 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
   }
   if (itof) { // iTOF
     const std::string name = GeometryTGeo::getITOFLayerPattern();
-    const int nStaves = itofSegmented ? 24 : 0;               // number of staves in segmented case
-    const double staveWidth = itofSegmented ? 5.42 : 0.0;     // cm
-    const double staveTiltAngle = itofSegmented ? 10.0 : 0.0; // degrees
-    const int modulesPerStave = itofSegmented ? 10 : 0;       // number of modules per stave in segmented case
+    const int nStaves = itofSegmented ? 24 : 0;              // number of staves in segmented case
+    const double staveWidth = itofSegmented ? 5.42 : 0.0;    // cm
+    const double staveTiltAngle = itofSegmented ? 3.0 : 0.0; // degrees
+    const int modulesPerStave = itofSegmented ? 10 : 0;      // number of modules per stave in segmented case
     mITOFLayer = ITOFLayer(name,
                            dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, ITOFLayer::kBarrelSegmented,
                            nStaves, staveWidth, staveTiltAngle, modulesPerStave);
@@ -108,7 +108,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const std::string name = GeometryTGeo::getOTOFLayerPattern();
     const int nStaves = otofSegmented ? 62 : 0;              // number of staves in segmented case
     const double staveWidth = otofSegmented ? 9.74 : 0.0;    // cm
-    const double staveTiltAngle = otofSegmented ? 5.0 : 0.0; // degrees
+    const double staveTiltAngle = otofSegmented ? 3.0 : 0.0; // degrees
     const int modulesPerStave = otofSegmented ? 54 : 0;      // number of modules per stave in segmented case
     mOTOFLayer = OTOFLayer(name,
                            dOuterTof.first, 0.f, dOuterTof.second, 0.f, x2x0, OTOFLayer::kBarrelSegmented,
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 1744e4c4510bb..c3612b0276b2e 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -155,14 +155,17 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
     case kBarrelSegmented: {
       // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
-      const double staveSizeX = mStaves.second;                                                                                                          // cm
-      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                             // cm
-      const double staveSizeZ = mZLength;                                                                                                                // cm
-      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY); // we increase the size of the layer to account for the tilt of the staves
+      const double staveSizeX = mStaves.second;                                                                                                                    // cm
+      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                                       // cm
+      const double staveSizeZ = mZLength;                                                                                                                          // cm
+      const double rMargin = 0.2;                                                                                                                                  // cm, a small margin to avoid layer extrusion by sub-volumes
+      const double deltaForTilt = rMargin + 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY); // we increase the size of the layer to account for the tilt of the staves
       TGeoTube* layer = new TGeoTube(mInnerRadius - deltaForTilt, mOuterRadius + deltaForTilt, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
 
+      LOGP(info, "iTOF kBarrelSegmented layout: stave tilt angle {}, layer tube rMin {}, rMax {}", mTiltAngle, mInnerRadius - deltaForTilt, mOuterRadius + deltaForTilt);
+
       // Now we create the volume for a single stave
       TGeoBBox* stave = new TGeoBBox(staveSizeX * 0.5, staveSizeY * 0.5, staveSizeZ * 0.5);
       TGeoVolume* staveVol = new TGeoVolume(staveName, stave, medAir);
@@ -287,10 +290,13 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
     case kBarrelSegmented: {
       // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
-      TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, mZLength / 2);
+      const double rMargin = 0.8; // cm, a small margin to avoid layer extrusion by sub-volumes
+      TGeoTube* layer = new TGeoTube(mInnerRadius - rMargin, mOuterRadius + rMargin, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
 
+      LOGP(info, "oTOF kBarrelSegmented layout: stave tilt angle {}, layer tube rMin {}, rMax {}", mTiltAngle, mInnerRadius - rMargin, mOuterRadius + rMargin);
+
       // Now we create the volume for a single stave
       const double staveSizeX = mStaves.second;              // cm
       const double staveSizeY = mOuterRadius - mInnerRadius; // cm

From 37f5b04d571fd33dab1775888b039142eadf5489 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 14 Mar 2026 13:32:14 +0100
Subject: [PATCH 1419/1764] DPL: Fix order of initialisation (#15155)

---
 Framework/Core/include/Framework/ASoA.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 7586d6a6d3c63..475823b150d90 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2052,8 +2052,8 @@ class Table
 
   Table(std::shared_ptr<arrow::Table> table, uint64_t offset = 0)
     : mTable(table),
-      mEnd{table->num_rows()},
-      mOffset(offset)
+      mOffset(offset),
+      mEnd{table->num_rows()}
   {
     if (mTable->num_rows() == 0) {
       for (size_t ci = 0; ci < framework::pack_size(columns_t{}); ++ci) {

From 44b8e32057b84823444e92323c1de73cc89ac11e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 15 Mar 2026 19:30:16 +0100
Subject: [PATCH 1420/1764] DPL: simplify argument passing and do not scatter
 configuration (#15154)

---
 .../src/AODJAlienReaderHelpers.cxx            |  2 +-
 .../AnalysisSupport/src/DataInputDirector.cxx | 58 +++++++------------
 .../AnalysisSupport/src/DataInputDirector.h   | 23 ++++----
 .../test/test_DataInputDirector.cxx           | 12 ++--
 4 files changed, 40 insertions(+), 55 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
index cde6c85f2c624..57a397822d167 100644
--- a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
@@ -134,7 +134,7 @@ AlgorithmSpec AODJAlienReaderHelpers::rootFileReaderCallback(ConfigContext const
     auto maxRate = options.get<float>("aod-max-io-rate");
 
     // create a DataInputDirector
-    auto didir = std::make_shared<DataInputDirector>(filename, &monitoring, parentAccessLevel, parentFileReplacement);
+    auto didir = std::make_shared<DataInputDirector>(std::vector<std::string>{filename}, DataInputDirectorContext{&monitoring, parentAccessLevel, parentFileReplacement});
     if (options.isSet("aod-reader-json")) {
       auto jsonFile = options.get<std::string>("aod-reader-json");
       if (!didir->readJson(jsonFile)) {
diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index 2bc6c5613f065..ace4565449c4b 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -57,12 +57,10 @@ FileNameHolder* makeFileNameHolder(std::string fileName)
   return fileNameHolder;
 }
 
-DataInputDescriptor::DataInputDescriptor(bool alienSupport, int level, o2::monitoring::Monitoring* monitoring, int allowedParentLevel, std::string parentFileReplacement)
+DataInputDescriptor::DataInputDescriptor(bool alienSupport, int level, DataInputDirectorContext& context)
   : mAlienSupport(alienSupport),
-    mMonitoring(monitoring),
-    mAllowedParentLevel(allowedParentLevel),
-    mParentFileReplacement(std::move(parentFileReplacement)),
-    mLevel(level)
+    mLevel(level),
+    mContext(context)
 {
   std::vector<char const*> capabilitiesSpecs = {
     "O2Framework:RNTupleObjectReadingCapability",
@@ -157,13 +155,13 @@ bool DataInputDescriptor::setFile(int counter, std::string_view origin)
 
   // get the parent file map if exists
   mParentFileMap = (TMap*)rootFS->GetFile()->Get("parentFiles"); // folder name (DF_XXX) --> parent file (absolute path)
-  if (mParentFileMap && !mParentFileReplacement.empty()) {
-    auto pos = mParentFileReplacement.find(';');
+  if (mParentFileMap && !mContext.parentFileReplacement.empty()) {
+    auto pos = mContext.parentFileReplacement.find(';');
     if (pos == std::string::npos) {
-      throw std::runtime_error(fmt::format("Invalid syntax in aod-parent-base-path-replacement: \"{}\"", mParentFileReplacement.c_str()));
+      throw std::runtime_error(fmt::format("Invalid syntax in aod-parent-base-path-replacement: \"{}\"", mContext.parentFileReplacement.c_str()));
     }
-    auto from = mParentFileReplacement.substr(0, pos);
-    auto to = mParentFileReplacement.substr(pos + 1);
+    auto from = mContext.parentFileReplacement.substr(0, pos);
+    auto to = mContext.parentFileReplacement.substr(pos + 1);
 
     auto it = mParentFileMap->MakeIterator();
     while (auto obj = it->Next()) {
@@ -280,13 +278,13 @@ DataInputDescriptor* DataInputDescriptor::getParentFile(int counter, int numTF,
     }
   }
 
-  if (mLevel == mAllowedParentLevel) {
-    throw std::runtime_error(fmt::format(R"(while looking for tree "{}", the parent file was requested but we are already at level {} of maximal allowed level {} for DF "{}" in file "{}")", treename.c_str(), mLevel, mAllowedParentLevel, folderName.c_str(),
+  if (mLevel == mContext.allowedParentLevel) {
+    throw std::runtime_error(fmt::format(R"(while looking for tree "{}", the parent file was requested but we are already at level {} of maximal allowed level {} for DF "{}" in file "{}")", treename.c_str(), mLevel, mContext.allowedParentLevel, folderName.c_str(),
                                          rootFS->GetFile()->GetName()));
   }
 
   LOGP(info, "Opening parent file {} for DF {}", parentFileName->GetString().Data(), folderName.c_str());
-  mParentFile = new DataInputDescriptor(mAlienSupport, mLevel + 1, mMonitoring, mAllowedParentLevel, mParentFileReplacement);
+  mParentFile = new DataInputDescriptor(mAlienSupport, mLevel + 1, mContext);
   mParentFile->mdefaultFilenamesPtr = new std::vector<FileNameHolder*>;
   mParentFile->mdefaultFilenamesPtr->emplace_back(makeFileNameHolder(parentFileName->GetString().Data()));
   mParentFile->fillInputfiles();
@@ -316,7 +314,7 @@ void DataInputDescriptor::printFileOpening()
     monitoringInfo += fmt::format(",se={},open_time={:.1f}", alienFile->GetSE(), alienFile->GetElapsed());
   }
 #endif
-  mMonitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-open-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
+  mContext.monitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-open-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
   LOGP(info, "Opening file: {}", monitoringInfo);
 }
 
@@ -337,7 +335,7 @@ void DataInputDescriptor::printFileStatistics()
     monitoringInfo += fmt::format(",se={},open_time={:.1f}", alienFile->GetSE(), alienFile->GetElapsed());
   }
 #endif
-  mMonitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-read-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
+  mContext.monitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-read-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
   LOGP(info, "Read info: {}", monitoringInfo);
 }
 
@@ -524,27 +522,15 @@ bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh
   return true;
 }
 
-DataInputDirector::DataInputDirector()
+DataInputDirector::DataInputDirector(std::vector<std::string> inputFiles, DataInputDirectorContext&& context)
+  : mContext{context}
 {
-  createDefaultDataInputDescriptor();
-}
-
-DataInputDirector::DataInputDirector(std::string inputFile, o2::monitoring::Monitoring* monitoring, int allowedParentLevel, std::string parentFileReplacement) : mMonitoring(monitoring), mAllowedParentLevel(allowedParentLevel), mParentFileReplacement(std::move(parentFileReplacement))
-{
-  if (inputFile.size() && inputFile[0] == '@') {
-    inputFile.erase(0, 1);
-    setInputfilesFile(inputFile);
+  if (inputFiles.size() == 1 && !inputFiles[0].empty() && inputFiles[0][0] == '@') {
+    setInputfilesFile(inputFiles.back().substr(1, -1));
   } else {
-    mdefaultInputFiles.emplace_back(makeFileNameHolder(inputFile));
-  }
-
-  createDefaultDataInputDescriptor();
-}
-
-DataInputDirector::DataInputDirector(std::vector<std::string> inputFiles, o2::monitoring::Monitoring* monitoring, int allowedParentLevel, std::string parentFileReplacement) : mMonitoring(monitoring), mAllowedParentLevel(allowedParentLevel), mParentFileReplacement(std::move(parentFileReplacement))
-{
-  for (auto inputFile : inputFiles) {
-    mdefaultInputFiles.emplace_back(makeFileNameHolder(inputFile));
+    for (auto inputFile : inputFiles) {
+      mdefaultInputFiles.emplace_back(makeFileNameHolder(inputFile));
+    }
   }
 
   createDefaultDataInputDescriptor();
@@ -576,7 +562,7 @@ void DataInputDirector::createDefaultDataInputDescriptor()
   if (mdefaultDataInputDescriptor) {
     delete mdefaultDataInputDescriptor;
   }
-  mdefaultDataInputDescriptor = new DataInputDescriptor(mAlienSupport, 0, mMonitoring, mAllowedParentLevel, mParentFileReplacement);
+  mdefaultDataInputDescriptor = new DataInputDescriptor(mAlienSupport, 0, mContext);
 
   mdefaultDataInputDescriptor->setInputfilesFile(minputfilesFile);
   mdefaultDataInputDescriptor->setFilenamesRegex(mFilenameRegex);
@@ -700,7 +686,7 @@ bool DataInputDirector::readJsonDocument(Document* jsonDoc)
         return false;
       }
       // create a new dataInputDescriptor
-      auto didesc = new DataInputDescriptor(mAlienSupport, 0, mMonitoring, mAllowedParentLevel, mParentFileReplacement);
+      auto didesc = new DataInputDescriptor(mAlienSupport, 0, mContext);
       didesc->setDefaultInputfiles(&mdefaultInputFiles);
 
       itemName = "table";
diff --git a/Framework/AnalysisSupport/src/DataInputDirector.h b/Framework/AnalysisSupport/src/DataInputDirector.h
index 61b477bd8522d..2d63a1c71ea77 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.h
+++ b/Framework/AnalysisSupport/src/DataInputDirector.h
@@ -37,8 +37,15 @@ struct FileNameHolder {
   std::vector<uint64_t> listOfTimeFrameNumbers;
   std::vector<bool> alreadyRead;
 };
+
 FileNameHolder* makeFileNameHolder(std::string fileName);
 
+struct DataInputDirectorContext {
+  o2::monitoring::Monitoring* monitoring = nullptr;
+  int allowedParentLevel = 0;
+  std::string parentFileReplacement = "";
+};
+
 class DataInputDescriptor
 {
   /// Holds information concerning the reading of an aod table.
@@ -50,7 +57,7 @@ class DataInputDescriptor
   std::string treename = "";
   std::unique_ptr<data_matcher::DataDescriptorMatcher> matcher;
 
-  DataInputDescriptor(bool alienSupport, int level, o2::monitoring::Monitoring* monitoring = nullptr, int allowedParentLevel = 0, std::string parentFileReplacement = "");
+  DataInputDescriptor(bool alienSupport, int level, DataInputDirectorContext& context);
 
   void printOut();
 
@@ -93,16 +100,13 @@ class DataInputDescriptor
   std::string* minputfilesFilePtr = nullptr;
   std::string mFilenameRegex = "";
   std::string* mFilenameRegexPtr = nullptr;
-  int mAllowedParentLevel = 0;
-  std::string mParentFileReplacement;
   std::vector<FileNameHolder*> mfilenames;
   std::vector<FileNameHolder*>* mdefaultFilenamesPtr = nullptr;
   std::shared_ptr<arrow::fs::FileSystem> mCurrentFilesystem;
   int mCurrentFileID = -1;
   bool mAlienSupport = false;
 
-  o2::monitoring::Monitoring* mMonitoring = nullptr;
-
+  DataInputDirectorContext& mContext;
   TMap* mParentFileMap = nullptr;
   DataInputDescriptor* mParentFile = nullptr;
   int mLevel = 0; // level of parent files
@@ -120,9 +124,7 @@ class DataInputDirector
   /// and the related input files
 
  public:
-  DataInputDirector();
-  DataInputDirector(std::string inputFile, o2::monitoring::Monitoring* monitoring = nullptr, int allowedParentLevel = 0, std::string parentFileReplacement = "");
-  DataInputDirector(std::vector<std::string> inputFiles, o2::monitoring::Monitoring* monitoring = nullptr, int allowedParentLevel = 0, std::string parentFileReplacement = "");
+  DataInputDirector(std::vector<std::string> inputFiles, DataInputDirectorContext&& context);
   ~DataInputDirector();
 
   void reset();
@@ -149,18 +151,15 @@ class DataInputDirector
   uint64_t getTotalSizeUncompressed();
 
  private:
+  DataInputDirectorContext mContext;
   std::string minputfilesFile;
   std::string* const minputfilesFilePtr = &minputfilesFile;
   std::string mFilenameRegex;
-  int mAllowedParentLevel = 0;
-  std::string mParentFileReplacement;
   std::string* const mFilenameRegexPtr = &mFilenameRegex;
   DataInputDescriptor* mdefaultDataInputDescriptor = nullptr;
   std::vector<FileNameHolder*> mdefaultInputFiles;
   std::vector<DataInputDescriptor*> mdataInputDescriptors;
 
-  o2::monitoring::Monitoring* mMonitoring = nullptr;
-
   bool mDebugMode = false;
   bool mAlienSupport = false;
 
diff --git a/Framework/AnalysisSupport/test/test_DataInputDirector.cxx b/Framework/AnalysisSupport/test/test_DataInputDirector.cxx
index cb49ccb83b0b7..6ccaf3a92c0e1 100644
--- a/Framework/AnalysisSupport/test/test_DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/test/test_DataInputDirector.cxx
@@ -50,7 +50,7 @@ BOOST_AUTO_TEST_CASE(TestDatainputDirector)
   jf << R"(})" << std::endl;
   jf.close();
 
-  DataInputDirector didir1;
+  DataInputDirector didir1({}, {});
   BOOST_CHECK(didir1.readJson(jsonFile));
   didir1.printOut();
   printf("\n\n");
@@ -60,8 +60,8 @@ BOOST_AUTO_TEST_CASE(TestDatainputDirector)
   auto dh = DataHeader(DataDescription{"DUE"},
                        DataOrigin{"AOD"},
                        DataHeader::SubSpecificationType{0});
-  //auto [file1, directory1] = didir1.getFileFolder(dh, 1, 0);
-  //BOOST_CHECK_EQUAL(file1->GetName(), "Bresults_1.root");
+  // auto [file1, directory1] = didir1.getFileFolder(dh, 1, 0);
+  // BOOST_CHECK_EQUAL(file1->GetName(), "Bresults_1.root");
 
   auto didesc = didir1.getDataInputDescriptor(dh);
   BOOST_CHECK(didesc);
@@ -96,13 +96,13 @@ BOOST_AUTO_TEST_CASE(TestDatainputDirector)
                                          "Aresults_2.root",
                                          "Bresults_1.root",
                                          "Bresults_2.root"};
-  DataInputDirector didir2(inputFiles);
+  DataInputDirector didir2(inputFiles, {});
   didir2.printOut();
   printf("\n\n");
   BOOST_CHECK(didir2.readJson(jsonFile));
 
-  //auto [file2, directory2] = didir2.getFileFolder(dh, 1, 0);
-  //BOOST_CHECK_EQUAL(file2->GetName(), "Bresults_1.root");
+  // auto [file2, directory2] = didir2.getFileFolder(dh, 1, 0);
+  // BOOST_CHECK_EQUAL(file2->GetName(), "Bresults_1.root");
 
   didesc = didir2.getDataInputDescriptor(dh);
   BOOST_CHECK(didesc);

From 2f3b9725962e1d60c2b5be7deb861ab595e5ff75 Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Tue, 10 Mar 2026 18:12:35 +0100
Subject: [PATCH 1421/1764] Improve Vertex handling in MCEventHeader

---
 .../include/Generators/GeneratorFromFile.h    |  4 +++
 .../include/Generators/GeneratorHybrid.h      |  3 ++-
 Generators/src/GeneratorHybrid.cxx            | 27 +++++++++----------
 3 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/Generators/include/Generators/GeneratorFromFile.h b/Generators/include/Generators/GeneratorFromFile.h
index 706557ea2484b..329510f844f05 100644
--- a/Generators/include/Generators/GeneratorFromFile.h
+++ b/Generators/include/Generators/GeneratorFromFile.h
@@ -144,7 +144,11 @@ class GeneratorFromEventPool : public o2::eventgen::Generator
 
   void updateHeader(o2::dataformats::MCEventHeader* eventHeader) override
   {
+    // Copy current vertex position from the event header
+    const double xyz[3] = {eventHeader->GetX(), eventHeader->GetY(), eventHeader->GetZ()};
     mO2KineGenerator->updateHeader(eventHeader);
+    // Event pool uses vertex position from current simulation, only extKinO2 takes the one from the file instead
+    eventHeader->SetVertex(xyz[0], xyz[1], xyz[2]);
   }
 
   // determine the collection of available files
diff --git a/Generators/include/Generators/GeneratorHybrid.h b/Generators/include/Generators/GeneratorHybrid.h
index 97422df1c8e2d..b57257747c629 100644
--- a/Generators/include/Generators/GeneratorHybrid.h
+++ b/Generators/include/Generators/GeneratorHybrid.h
@@ -76,7 +76,7 @@ class GeneratorHybrid : public Generator
   ~GeneratorHybrid();
   o2::eventgen::Generator* currentgen = nullptr;
   std::vector<std::shared_ptr<o2::eventgen::Generator>> gens;
-  const std::vector<std::string> generatorNames = {"extkinO2", "evtpool", "boxgen", "external", "hepmc", "pythia8", "pythia8pp", "pythia8hi", "pythia8hf", "pythia8powheg"};
+  const std::vector<std::string> generatorNames = {"evtpool", "boxgen", "external", "hepmc", "pythia8", "pythia8pp", "pythia8hi", "pythia8hf", "pythia8powheg"};
   std::vector<std::string> mInputGens;
   std::vector<std::string> mGens;
   std::vector<std::string> mConfigs;
@@ -120,6 +120,7 @@ class GeneratorHybrid : public Generator
   bool mIsInitialized = false;
 
   o2::dataformats::MCEventHeader mMCEventHeader; // to capture event headers
+  int mHeaderGeneratorIndex = -1;                // index of the generator that updated the header in current event
 
   enum class GenMode {
     kSeq,
diff --git a/Generators/src/GeneratorHybrid.cxx b/Generators/src/GeneratorHybrid.cxx
index f853b772e3cd3..2741d874b1681 100644
--- a/Generators/src/GeneratorHybrid.cxx
+++ b/Generators/src/GeneratorHybrid.cxx
@@ -96,10 +96,6 @@ GeneratorHybrid::GeneratorHybrid(const std::string& inputgens)
         }
         mConfsPythia8.push_back(mConfigs[index]);
         mGens.push_back(gen);
-      } else if (gen.compare("extkinO2") == 0) {
-        int confO2KineIndex = std::stoi(mConfigs[index].substr(9));
-        gens.push_back(std::make_shared<o2::eventgen::GeneratorFromO2Kine>(*mO2KineGenConfigs[confO2KineIndex]));
-        mGens.push_back(gen);
       } else if (gen.compare("evtpool") == 0) {
         int confEvtPoolIndex = std::stoi(mConfigs[index].substr(8));
         gens.push_back(std::make_shared<o2::eventgen::GeneratorFromEventPool>(mEventPoolConfigs[confEvtPoolIndex]));
@@ -417,10 +413,12 @@ bool GeneratorHybrid::importParticles()
 
   // Clear particles and event header
   mParticles.clear();
-  mMCEventHeader.clearInfo();
+  // event header of underlying generator must be fully reset
+  // this is important when using event pools where the full header information is forwarded from the generator
+  // otherwise some events might have mixed header information from different generators
+  mMCEventHeader.Reset();
   if (mCocktailMode) {
     // in cocktail mode we need to merge the particles from the different generators
-    bool baseGen = true; // first generator of the cocktail is used as reference to update the event header information
     for (auto subIndex : subGenIndex) {
       LOG(info) << "Importing particles for task " << subIndex;
       auto subParticles = gens[subIndex]->getParticles();
@@ -442,9 +440,10 @@ bool GeneratorHybrid::importParticles()
       }
 
       mParticles.insert(mParticles.end(), subParticles.begin(), subParticles.end());
-      if (baseGen) {
+      // first generator of the cocktail is used as reference to update the event header information
+      if (mHeaderGeneratorIndex == -1) {
         gens[subIndex]->updateHeader(&mMCEventHeader);
-        baseGen = false;
+        mHeaderGeneratorIndex = subIndex; // store index of generator updating the header
       }
       mInputTaskQueue.push(subIndex);
       mTasksStarted++;
@@ -467,6 +466,7 @@ bool GeneratorHybrid::importParticles()
 
     // fetch the event Header information from the underlying generator
     gens[genIndex]->updateHeader(&mMCEventHeader);
+    mHeaderGeneratorIndex = genIndex; // store index of generator updating the header
     mInputTaskQueue.push(genIndex);
     mTasksStarted++;
   }
@@ -484,6 +484,10 @@ bool GeneratorHybrid::importParticles()
 void GeneratorHybrid::updateHeader(o2::dataformats::MCEventHeader* eventHeader)
 {
   if (eventHeader) {
+    // Overwrite current vertex information to the underlying generator header,
+    // otherwise the info will be dropped when copying the FairMCEventHeader part of the header
+    mMCEventHeader.SetVertex(eventHeader->GetX(), eventHeader->GetY(), eventHeader->GetZ());
+    mHeaderGeneratorIndex = -1; // reset header generator index for next event
     // Forward the base class fields from FairMCEventHeader
     static_cast<FairMCEventHeader&>(*eventHeader) = static_cast<FairMCEventHeader&>(mMCEventHeader);
     // Copy the key-value store info
@@ -518,11 +522,6 @@ Bool_t GeneratorHybrid::confSetter(const auto& gen)
       auto pythia8Config = TBufferJSON::FromJSON<o2::eventgen::Pythia8GenConfig>(jsonValueToString(pythia8conf).c_str());
       mPythia8GenConfigs.push_back(std::move(pythia8Config));
       mConfigs.push_back("pythia8_" + std::to_string(mPythia8GenConfigs.size() - 1));
-    } else if (name == "extkinO2") {
-      const auto& o2kineconf = gen["config"];
-      auto o2kineConfig = TBufferJSON::FromJSON<o2::eventgen::O2KineGenConfig>(jsonValueToString(o2kineconf).c_str());
-      mO2KineGenConfigs.push_back(std::move(o2kineConfig));
-      mConfigs.push_back("extkinO2_" + std::to_string(mO2KineGenConfigs.size() - 1));
     } else if (name == "evtpool") {
       const auto& o2kineconf = gen["config"];
       auto poolConfig = TBufferJSON::FromJSON<o2::eventgen::EventPoolGenConfig>(jsonValueToString(o2kineconf).c_str());
@@ -546,7 +545,7 @@ Bool_t GeneratorHybrid::confSetter(const auto& gen)
       mConfigs.push_back("");
     }
   } else {
-    if (name == "boxgen" || name == "pythia8" || name == "extkinO2" || name == "external" || name == "hepmc") {
+    if (name == "boxgen" || name == "pythia8" || name == "external" || name == "hepmc") {
       LOG(fatal) << "No configuration provided for generator " << name;
       return false;
     } else {

From 5250f03a9b31e121bbf8400f71dbb5dce75c0459 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 16 Mar 2026 11:00:35 +0100
Subject: [PATCH 1422/1764] O2: Adapt to Arrow 23 (#15152)

---
 Framework/Core/CMakeLists.txt                 |  2 +-
 .../include/Framework/IndexBuilderHelpers.h   |  2 +-
 Framework/Core/src/IndexBuilderHelpers.cxx    | 81 +++++++++++++------
 dependencies/O2Dependencies.cmake             | 32 +++++++-
 4 files changed, 89 insertions(+), 28 deletions(-)

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index e6a8db1077136..c311ba980a20b 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -8,7 +8,6 @@
 # In applying this license CERN does not waive the privileges and immunities
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
-
 o2_add_library(Framework
                SOURCES src/AnalysisHelpers.cxx
                        src/AlgorithmSpec.cxx
@@ -178,6 +177,7 @@ o2_add_library(Framework
                                      RapidJSON::RapidJSON
                                      Arrow::arrow_shared
                                      ArrowDataset::arrow_dataset_shared
+                                     $<$<TARGET_EXISTS:ArrowCompute::arrow_compute_shared>:ArrowCompute::arrow_compute_shared>
                                      Microsoft.GSL::GSL
                                      O2::FrameworkLogger
                                      Gandiva::gandiva_shared
diff --git a/Framework/Core/include/Framework/IndexBuilderHelpers.h b/Framework/Core/include/Framework/IndexBuilderHelpers.h
index 30754e62a8dc3..3a23d97a10d83 100644
--- a/Framework/Core/include/Framework/IndexBuilderHelpers.h
+++ b/Framework/Core/include/Framework/IndexBuilderHelpers.h
@@ -29,7 +29,7 @@ enum struct IndexKind : int {
 
 namespace o2::framework
 {
-void cannotBuildAnArray();
+void cannotBuildAnArray(const char* reason);
 void cannotCreateIndexBuilder();
 
 struct ChunkedArrayIterator {
diff --git a/Framework/Core/src/IndexBuilderHelpers.cxx b/Framework/Core/src/IndexBuilderHelpers.cxx
index 0943dea42169c..0c06aea11ef2c 100644
--- a/Framework/Core/src/IndexBuilderHelpers.cxx
+++ b/Framework/Core/src/IndexBuilderHelpers.cxx
@@ -13,17 +13,21 @@
 #include "Framework/IndexBuilderHelpers.h"
 #include "Framework/CompilerBuiltins.h"
 #include "Framework/VariantHelpers.h"
-#include <arrow/compute/api_aggregate.h>
+#include <arrow/util/config.h>
+#if (ARROW_VERSION_MAJOR > 20)
+#include <arrow/compute/initialize.h>
+#endif
 #include <arrow/compute/kernel.h>
+#include <arrow/compute/api_aggregate.h>
 #include <arrow/status.h>
 #include <arrow/table.h>
 #include <arrow/util/key_value_metadata.h>
 
 namespace o2::framework
 {
-void cannotBuildAnArray()
+void cannotBuildAnArray(const char* reason)
 {
-  throw framework::runtime_error("Cannot finish an array");
+  throw framework::runtime_error_f("Cannot finish an array: %s", reason);
 }
 
 void cannotCreateIndexBuilder()
@@ -62,10 +66,10 @@ SelfBuilder::SelfBuilder(arrow::MemoryPool* pool)
 {
   auto status = arrow::MakeBuilder(pool, arrow::int32(), &mBuilder);
   if (!status.ok()) {
-    throw framework::runtime_error("Cannot create array builder for the self-index!");
+    throw framework::runtime_error_f("Cannot create array builder for the self-index: %s", status.ToString().c_str());
   }
 }
-// static_cast<ChunkedArrayIterator*>(this)->reset(pool);
+
 void SelfBuilder::reset(std::shared_ptr<arrow::ChunkedArray>)
 {
   mBuilder->Reset();
@@ -74,7 +78,10 @@ void SelfBuilder::reset(std::shared_ptr<arrow::ChunkedArray>)
 
 void SelfBuilder::fill(int idx)
 {
-  (void)static_cast<arrow::Int32Builder*>(mBuilder.get())->Append(idx);
+  auto status = static_cast<arrow::Int32Builder*>(mBuilder.get())->Append(idx);
+  if (!status.ok()) {
+    throw framework::runtime_error_f("Cannot append to self-index array: %s", status.ToString().c_str());
+  }
 }
 
 std::shared_ptr<arrow::ChunkedArray> SelfBuilder::result() const
@@ -82,7 +89,7 @@ std::shared_ptr<arrow::ChunkedArray> SelfBuilder::result() const
   std::shared_ptr<arrow::Array> array;
   auto status = static_cast<arrow::Int32Builder*>(mBuilder.get())->Finish(&array);
   if (!status.ok()) {
-    cannotBuildAnArray();
+    cannotBuildAnArray(status.ToString().c_str());
   }
 
   return std::make_shared<arrow::ChunkedArray>(array);
@@ -93,7 +100,7 @@ SingleBuilder::SingleBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow:
 {
   auto status = arrow::MakeBuilder(pool, arrow::int32(), &mBuilder);
   if (!status.ok()) {
-    throw framework::runtime_error("Cannot create array builder for the single-valued index!");
+    throw framework::runtime_error_f("Cannot create array builder for the single-valued index: %s", status.ToString().c_str());
   }
 }
 
@@ -126,10 +133,14 @@ bool SingleBuilder::find(int idx)
 
 void SingleBuilder::fill(int idx)
 {
+  arrow::Status status;
   if (mPosition < mSourceSize && valueAt(mPosition) == idx) {
-    (void)static_cast<arrow::Int32Builder*>(mBuilder.get())->Append((int)mPosition);
+    status = static_cast<arrow::Int32Builder*>(mBuilder.get())->Append((int)mPosition);
   } else {
-    (void)static_cast<arrow::Int32Builder*>(mBuilder.get())->Append(-1);
+    status = static_cast<arrow::Int32Builder*>(mBuilder.get())->Append(-1);
+  }
+  if (!status.ok()) {
+    throw framework::runtime_error_f("Cannot append to array: %s", status.ToString().c_str());
   }
 }
 
@@ -138,7 +149,7 @@ std::shared_ptr<arrow::ChunkedArray> SingleBuilder::result() const
   std::shared_ptr<arrow::Array> array;
   auto status = static_cast<arrow::Int32Builder*>(mBuilder.get())->Finish(&array);
   if (!status.ok()) {
-    cannotBuildAnArray();
+    cannotBuildAnArray(status.ToString().c_str());
   }
   return std::make_shared<arrow::ChunkedArray>(array);
 }
@@ -146,14 +157,15 @@ std::shared_ptr<arrow::ChunkedArray> SingleBuilder::result() const
 SliceBuilder::SliceBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::MemoryPool* pool)
   : ChunkedArrayIterator{source}
 {
-  if (!preSlice().ok()) {
-    throw framework::runtime_error("Cannot pre-slice the source for slice-index building");
+  auto status = preSlice();
+  if (!status.ok()) {
+    throw framework::runtime_error_f("Cannot pre-slice the source for slice-index building: %s", status.ToString().c_str());
   }
 
   std::unique_ptr<arrow::ArrayBuilder> builder;
-  auto status = arrow::MakeBuilder(pool, arrow::int32(), &builder);
+  status = arrow::MakeBuilder(pool, arrow::int32(), &builder);
   if (!status.ok()) {
-    throw framework::runtime_error("Cannot create array for the slice-index builder!");
+    throw framework::runtime_error_f("Cannot create array for the slice-index builder: %s", status.ToString().c_str());
   }
   mListBuilder = std::make_unique<arrow::FixedSizeListBuilder>(pool, std::move(builder), 2);
   mValueBuilder = static_cast<arrow::FixedSizeListBuilder*>(mListBuilder.get())->value_builder();
@@ -166,8 +178,9 @@ void SliceBuilder::reset(std::shared_ptr<arrow::ChunkedArray> source)
   mListBuilder->Reset();
   mValuePos = 0;
   static_cast<ChunkedArrayIterator*>(this)->reset(source);
-  if (!preSlice().ok()) {
-    throw framework::runtime_error("Cannot pre-slice the source for slice-index building");
+  auto status = preSlice();
+  if (!status.ok()) {
+    throw framework::runtime_error_f("Cannot pre-slice the source for slice-index building: %s", status.ToString().c_str());
   }
 }
 
@@ -211,13 +224,21 @@ std::shared_ptr<arrow::ChunkedArray> SliceBuilder::result() const
   std::shared_ptr<arrow::Array> array;
   auto status = static_cast<arrow::FixedSizeListBuilder*>(mListBuilder.get())->Finish(&array);
   if (!status.ok()) {
-    cannotBuildAnArray();
+    cannotBuildAnArray(status.ToString().c_str());
   }
   return std::make_shared<arrow::ChunkedArray>(array);
 }
 
 arrow::Status SliceBuilder::SliceBuilder::preSlice()
 {
+#if (ARROW_VERSION_MAJOR > 20)
+  auto status = arrow::compute::Initialize();
+  if (!status.ok()) {
+    throw framework::runtime_error_f("Cannot initialize arrow compute: %s", status.ToString().c_str());
+  }
+#else
+  arrow::Status status;
+#endif
   arrow::Datum value_counts;
   auto options = arrow::compute::ScalarAggregateOptions::Defaults();
   ARROW_ASSIGN_OR_RAISE(value_counts, arrow::compute::CallFunction("value_counts", {mSource}, &options));
@@ -230,14 +251,15 @@ arrow::Status SliceBuilder::SliceBuilder::preSlice()
 ArrayBuilder::ArrayBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::MemoryPool* pool)
   : ChunkedArrayIterator{source}
 {
-  if (!preFind().ok()) {
-    throw framework::runtime_error("Cannot pre-find in a source for array-index building");
+  auto&& status = preFind();
+  if (!status.ok()) {
+    throw framework::runtime_error_f("Cannot pre-find in a source for array-index building: %s", status.ToString().c_str());
   }
 
   std::unique_ptr<arrow::ArrayBuilder> builder;
-  auto status = arrow::MakeBuilder(pool, arrow::int32(), &builder);
+  status = arrow::MakeBuilder(pool, arrow::int32(), &builder);
   if (!status.ok()) {
-    throw framework::runtime_error("Cannot create array for the array-index builder!");
+    throw framework::runtime_error_f("Cannot create array for the array-index builder: %s", status.ToString().c_str());
   }
   mListBuilder = std::make_unique<arrow::ListBuilder>(pool, std::move(builder));
   mValueBuilder = static_cast<arrow::ListBuilder*>(mListBuilder.get())->value_builder();
@@ -246,8 +268,9 @@ ArrayBuilder::ArrayBuilder(std::shared_ptr<arrow::ChunkedArray> source, arrow::M
 void ArrayBuilder::reset(std::shared_ptr<arrow::ChunkedArray> source)
 {
   static_cast<ChunkedArrayIterator*>(this)->reset(source);
-  if (!preFind().ok()) {
-    throw framework::runtime_error("Cannot pre-find in a source for array-index building");
+  auto status = preFind();
+  if (!status.ok()) {
+    throw framework::runtime_error_f("Cannot pre-find in a source for array-index building: %s", status.ToString().c_str());
   }
   mValues.clear();
   mIndices.clear();
@@ -274,13 +297,21 @@ std::shared_ptr<arrow::ChunkedArray> ArrayBuilder::result() const
   std::shared_ptr<arrow::Array> array;
   auto status = static_cast<arrow::ListBuilder*>(mListBuilder.get())->Finish(&array);
   if (!status.ok()) {
-    cannotBuildAnArray();
+    cannotBuildAnArray(status.ToString().c_str());
   }
   return std::make_shared<arrow::ChunkedArray>(array);
 }
 
 arrow::Status ArrayBuilder::preFind()
 {
+#if (ARROW_VERSION_MAJOR > 20)
+  auto status = arrow::compute::Initialize();
+  if (!status.ok()) {
+    throw framework::runtime_error_f("Cannot initialize arrow compute: %s", status.ToString().c_str());
+  }
+#else
+  arrow::Status status;
+#endif
   arrow::Datum max;
   auto options = arrow::compute::ScalarAggregateOptions::Defaults();
   ARROW_ASSIGN_OR_RAISE(max, arrow::compute::CallFunction("max", {mSource}, &options));
diff --git a/dependencies/O2Dependencies.cmake b/dependencies/O2Dependencies.cmake
index 8addb87a1a16f..71e9d9907ac28 100644
--- a/dependencies/O2Dependencies.cmake
+++ b/dependencies/O2Dependencies.cmake
@@ -92,7 +92,37 @@ if(NOT TARGET ArrowAcero::arrow_acero_shared)
   )
 endif()
 
-if (NOT TARGET Gandiva::gandiva_shared)
+string(REGEX MATCH "([0-9]+)\.*" ARROW_MAJOR "${ARROW_VERSION}")
+if(${ARROW_MAJOR} GREATER 20)
+  if(NOT TARGET ArrowCompute::arrow_compute_shared)
+    # ArrowCompute::arrow_compute_shared is linked for no reason to parquet
+    # so we cannot use it because we do not want to build parquet itself.
+    # For that reason at the moment we need to do the lookup by hand.
+    get_target_property(ARROW_SHARED_LOCATION Arrow::arrow_shared LOCATION)
+    get_filename_component(ARROW_SHARED_DIR ${ARROW_SHARED_LOCATION} DIRECTORY)
+
+    find_library(ARROW_COMPUTE_SHARED arrow_compute
+        PATHS ${ARROW_SHARED_DIR}
+        NO_DEFAULT_PATH
+    )
+
+    if(ARROW_COMPUTE_SHARED)
+      message(STATUS
+              "Found arrow_compute_shared library at: ${ARROW_COMPUTE_SHARED}")
+    else()
+      message(FATAL_ERROR
+              "arrow_compute_shared library not found in ${ARROW_SHARED_DIR}")
+    endif()
+
+    # Step 3: Create a target for ArrowCompute::arrow_compute_shared
+    add_library(ArrowCompute::arrow_compute_shared SHARED IMPORTED)
+    set_target_properties(ArrowCompute::arrow_compute_shared PROPERTIES
+        IMPORTED_LOCATION ${ARROW_COMPUTE_SHARED}
+    )
+  endif()
+endif()
+
+if(NOT TARGET Gandiva::gandiva_shared)
   add_library(Gandiva::gandiva_shared ALIAS gandiva_shared)
 endif()
 

From f9f6b0923525455da80fc75e8d0766624956044e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:46:47 +0100
Subject: [PATCH 1423/1764] [ALICE3] oTOF: fix missing tilt shift for overlaps
 (#15159)

---
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     | 23 ++++++++-----------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index c3612b0276b2e..0d0983958c46f 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -155,17 +155,14 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
     case kBarrelSegmented: {
       // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
-      const double staveSizeX = mStaves.second;                                                                                                                    // cm
-      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                                       // cm
-      const double staveSizeZ = mZLength;                                                                                                                          // cm
-      const double rMargin = 0.2;                                                                                                                                  // cm, a small margin to avoid layer extrusion by sub-volumes
-      const double deltaForTilt = rMargin + 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY); // we increase the size of the layer to account for the tilt of the staves
+      const double staveSizeX = mStaves.second;                                                                                                          // cm
+      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                             // cm
+      const double staveSizeZ = mZLength;                                                                                                                // cm
+      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY); // we increase the size of the layer to account for the tilt of the staves
       TGeoTube* layer = new TGeoTube(mInnerRadius - deltaForTilt, mOuterRadius + deltaForTilt, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
 
-      LOGP(info, "iTOF kBarrelSegmented layout: stave tilt angle {}, layer tube rMin {}, rMax {}", mTiltAngle, mInnerRadius - deltaForTilt, mOuterRadius + deltaForTilt);
-
       // Now we create the volume for a single stave
       TGeoBBox* stave = new TGeoBBox(staveSizeX * 0.5, staveSizeY * 0.5, staveSizeZ * 0.5);
       TGeoVolume* staveVol = new TGeoVolume(staveName, stave, medAir);
@@ -290,17 +287,15 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
     case kBarrelSegmented: {
       // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
-      const double rMargin = 0.8; // cm, a small margin to avoid layer extrusion by sub-volumes
-      TGeoTube* layer = new TGeoTube(mInnerRadius - rMargin, mOuterRadius + rMargin, mZLength / 2);
+      const double staveSizeX = mStaves.second;                                                                                                          // cm
+      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                             // cm
+      const double staveSizeZ = mZLength;                                                                                                                // cm
+      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY); // we increase the size of the layer to account for the tilt of the staves
+      TGeoTube* layer = new TGeoTube(mInnerRadius - deltaForTilt, mOuterRadius + deltaForTilt, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
 
-      LOGP(info, "oTOF kBarrelSegmented layout: stave tilt angle {}, layer tube rMin {}, rMax {}", mTiltAngle, mInnerRadius - rMargin, mOuterRadius + rMargin);
-
       // Now we create the volume for a single stave
-      const double staveSizeX = mStaves.second;              // cm
-      const double staveSizeY = mOuterRadius - mInnerRadius; // cm
-      const double staveSizeZ = mZLength;                    // cm
       TGeoBBox* stave = new TGeoBBox(staveSizeX * 0.5, staveSizeY * 0.5, staveSizeZ * 0.5);
       TGeoVolume* staveVol = new TGeoVolume(staveName, stave, medAir);
       setStaveStyle(staveVol);

From 4112fd1e5aaa3d43b1587c4d4fd4a499a657cbe8 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sat, 14 Mar 2026 22:40:15 +0100
Subject: [PATCH 1424/1764] Pass missing ctf-dict options

---
 .../ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx b/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
index b2a1b6ce75591..e0fc23ec70128 100644
--- a/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
@@ -43,7 +43,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   if (cfgc.options().get<bool>("runmft")) {
     wf.emplace_back(o2::itsmft::getEntropyEncoderSpec("MFT", selIR, cfgc.options().get<std::string>("ctf-dict")));
   } else {
-    wf.emplace_back(o2::itsmft::getEntropyEncoderSpec("ITS", selIR));
+    wf.emplace_back(o2::itsmft::getEntropyEncoderSpec("ITS", selIR, cfgc.options().get<std::string>("ctf-dict")));
   }
   return wf;
 }

From 6c759a2114d7700b851d7339738c53d790822fe7 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 16 Mar 2026 18:27:22 +0100
Subject: [PATCH 1425/1764] Export language variables (#15164)

Old code only works if the variables were already exported.
---
 GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh b/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
index d064c4f6b58d9..a607ea0eb3c8f 100755
--- a/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
+++ b/GPU/GPUTracking/Definitions/Parameters/csv_to_json.sh
@@ -2,9 +2,9 @@
 
 [[ -z $1 ]] && { echo "Usage: csv_to_json.sh CSV_FILE"; exit 1; }
 
-LANG=C
-LC_ALL=C
-DELIM=$'\xFF'
+export LANG=C
+export LC_ALL=C
+DELIM=$'\x1F'
 set -o pipefail
 sed -E \
   ':loop

From 850e1dc667ac595a1827f0568cf6708380ea12ac Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 16 Mar 2026 20:41:43 +0100
Subject: [PATCH 1426/1764] Add some initial skills to improve Claude Code /
 Codex / whatever experience (#15165)

---
 .skills/build-software-stack/SKILL.md         |  1 +
 .skills/create-a-new-file/SKILL.md            | 20 +++++++++++++++++++
 .../o2-copyright-statement.md                 | 11 ++++++++++
 CLAUDE.md                                     |  5 +++++
 4 files changed, 37 insertions(+)
 create mode 100644 .skills/build-software-stack/SKILL.md
 create mode 100644 .skills/create-a-new-file/SKILL.md
 create mode 100644 .skills/create-a-new-file/o2-copyright-statement.md
 create mode 100644 CLAUDE.md

diff --git a/.skills/build-software-stack/SKILL.md b/.skills/build-software-stack/SKILL.md
new file mode 100644
index 0000000000000..8b137891791fe
--- /dev/null
+++ b/.skills/build-software-stack/SKILL.md
@@ -0,0 +1 @@
+
diff --git a/.skills/create-a-new-file/SKILL.md b/.skills/create-a-new-file/SKILL.md
new file mode 100644
index 0000000000000..a7af739d49894
--- /dev/null
+++ b/.skills/create-a-new-file/SKILL.md
@@ -0,0 +1,20 @@
+---
+name: create-a-new-file
+description: describes how to create a new file
+---
+
+## Copyright statements
+
+The copyright statement for ALICE / O2 is found in ./o2-copyright-statement.md. It should be at the beginning of
+the new file using the proper commenting syntax for the given programming language. For example in C++ it should be commented via
+multiline comments:
+
+``` C++
+// Copyright 2019-<current-year> CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// ...
+```
+
+The only part which needs to be adapted by you is the `<current-year>` which you need to replace with the actual current year.
+
+
diff --git a/.skills/create-a-new-file/o2-copyright-statement.md b/.skills/create-a-new-file/o2-copyright-statement.md
new file mode 100644
index 0000000000000..0bc4b092e6ba6
--- /dev/null
+++ b/.skills/create-a-new-file/o2-copyright-statement.md
@@ -0,0 +1,11 @@
+// Copyright 2019-<current-year> CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000000000..9d8753a362a56
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,5 @@
+This is the main repository of the ALICE Experiment Simulation, Reconstruction and Analysis Framework.
+
+The skills specific to developing code for this repository can be found in
+the `.skills/` folder of this project.
+

From b7a497ba51cc0f656867623a45ceea9fc7f5af9a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 16 Mar 2026 15:09:15 +0100
Subject: [PATCH 1427/1764] fix field/material usage in the propagateToR...
 methods

---
 Detectors/Base/src/Propagator.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/Base/src/Propagator.cxx b/Detectors/Base/src/Propagator.cxx
index a5983cab8e257..208b9bf138688 100644
--- a/Detectors/Base/src/Propagator.cxx
+++ b/Detectors/Base/src/Propagator.cxx
@@ -608,7 +608,7 @@ GPUd() bool PropagatorImpl<value_T>::propagateToR(track_T& track, value_type r,
       // case1
       if (math_utils::detail::abs<value_type>(phiLocFin) < MaxPhiLocSafe) { // just 1 step propagation
         auto deltaX = (math_utils::detail::sin<double>(phiLocFin) - track.getSnp()) / track.getCurvature(bz);
-        if (!track.propagateTo(track.getX() + deltaX, bz)) {
+        if (!propagateTo(track, track.getX() + deltaX, bzOnly, maxSnp, maxStep, matCorr, tofInfo, signCorr)) {
           return false;
         }
         break;
@@ -631,7 +631,7 @@ GPUd() bool PropagatorImpl<value_T>::propagateToR(track_T& track, value_type r,
       // propagate to phiLoc = +-MaxPhiLocSafe
       auto tgtPhiLoc = deltaPhi > 0 ? MaxPhiLocSafe : -MaxPhiLocSafe;
       auto deltaX = (math_utils::detail::sin<double>(tgtPhiLoc) - track.getSnp()) / track.getCurvature(bz);
-      if (!track.propagateTo(track.getX() + deltaX, bz)) {
+      if (!propagateTo(track, track.getX() + deltaX, bzOnly, maxSnp, maxStep, matCorr, tofInfo, signCorr)) {
         return false;
       }
       deltaPhi -= tgtPhiLoc - phiLoc;

From a346105448731a5f50a407fdde887af393ba0da5 Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Tue, 17 Mar 2026 08:22:31 +0100
Subject: [PATCH 1428/1764] [ALICE 3] Fix cylindrical MLOT layout (#15168)

* Fix cylindrical version

* Fix print

* Remove commented lines
---
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      | 46 ++++++++--------
 .../ALICE3/TRK/simulation/src/Detector.cxx    | 54 ++++++++++++-------
 2 files changed, 59 insertions(+), 41 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 1a81723a18f63..36d26a6344e6c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -101,10 +101,17 @@ void GeometryTGeo::Build(int loadTrans)
   mLastChipIndexMLOT.resize(mNumberOfLayersMLOT); /// ML and OT are part of TRK as the same detector, without disks
 
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
-    mNumberOfStaves[i] = extractNumberOfStavesMLOT(i);
-    mNumberOfHalfStaves[i] = extractNumberOfHalfStavesMLOT(i);
-    mNumberOfModules[i] = extractNumberOfModulesMLOT(i);
-    mNumberOfChips[i] = extractNumberOfChipsMLOT(i);
+    if (mLayoutMLOT == eMLOTLayout::kCylindrical) {
+      mNumberOfStaves[i] = 1;
+      mNumberOfHalfStaves[i] = 1;
+      mNumberOfModules[i] = 1;
+      mNumberOfChips[i] = 1;
+    } else {
+      mNumberOfStaves[i] = extractNumberOfStavesMLOT(i);
+      mNumberOfHalfStaves[i] = extractNumberOfHalfStavesMLOT(i);
+      mNumberOfModules[i] = extractNumberOfModulesMLOT(i);
+      mNumberOfChips[i] = extractNumberOfChipsMLOT(i);
+    }
   }
 
   int numberOfChipsTotal = 0;
@@ -398,19 +405,8 @@ TString GeometryTGeo::getMatrixPath(int index) const
 
   // PrintChipID(index, subDetID, petalcase, disk, layer, stave, halfstave, mod, chip);
 
-  // TString path = "/cave_1/barrel_1/TRKV_2/TRKLayer0_1/TRKStave0_1/TRKChip0_1/TRKSensor0_1/"; /// dummy path, to be used for tests
   TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getTRKVolPattern());
 
-  // handling cylindrical configuration for ML and/or OT
-  // needed because of the different numbering scheme in the geometry for the cylindrical case wrt the staggered and turbo ones
-  if (subDetID == 1) {
-    if ((layer < 4 && mLayoutMLOT == eMLOTLayout::kCylindrical) || (layer > 3 && mLayoutMLOT == eMLOTLayout::kCylindrical)) {
-      stave = 1;
-      mod = 1;
-      chip = 1;
-    }
-  }
-
   // build the path
   if (subDetID == 0) { // VD
     if (disk >= 0) {
@@ -425,15 +421,19 @@ TString GeometryTGeo::getMatrixPath(int index) const
       path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKChipPattern(), layer);   // PETALCASEx_LAYERy_TRKChipy_1
       path += Form("%s%d_%s%d_%s%d_1/", getTRKPetalPattern(), petalcase, getTRKPetalLayerPattern(), layer, getTRKSensorPattern(), layer); // PETALCASEx_LAYERy_TRKSensory_1
     }
-  } else if (subDetID == 1) {                                               // MLOT
-    path += Form("%s%d_1/", getTRKLayerPattern(), layer);                   // TRKLayerx_1
-    path += Form("%s%d_%d/", getTRKStavePattern(), layer, stave);           // TRKStavex_y
-    if (mNumberOfHalfStaves[layer] == 2) {                                  // staggered geometry
-      path += Form("%s%d_%d/", getTRKHalfStavePattern(), layer, halfstave); // TRKHalfStavex_y
+  } else if (subDetID == 1) {                             // MLOT
+    path += Form("%s%d_1/", getTRKLayerPattern(), layer); // TRKLayerx_1
+    if (mLayoutMLOT == eMLOTLayout::kCylindrical) {
+      path += Form("%s%d_1/", getTRKSensorPattern(), layer); // TRKSensorx_1
+    } else {
+      path += Form("%s%d_%d/", getTRKStavePattern(), layer, stave);           // TRKStavex_y
+      if (mNumberOfHalfStaves[layer] == 2) {                                  // staggered geometry
+        path += Form("%s%d_%d/", getTRKHalfStavePattern(), layer, halfstave); // TRKHalfStavex_y
+      }
+      path += Form("%s%d_%d/", getTRKModulePattern(), layer, mod); // TRKModulx_y
+      path += Form("%s%d_%d/", getTRKChipPattern(), layer, chip);  // TRKChipx_y
+      path += Form("%s%d_1/", getTRKSensorPattern(), layer);       // TRKSensorx_1
     }
-    path += Form("%s%d_%d/", getTRKModulePattern(), layer, mod); // TRKModulx_y
-    path += Form("%s%d_%d/", getTRKChipPattern(), layer, chip);  // TRKChipx_y
-    path += Form("%s%d_1/", getTRKSensorPattern(), layer);       // TRKSensorx_1
   }
   return path;
 }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 8e13d31e7915c..66c02a080e0b6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -475,18 +475,24 @@ bool Detector::ProcessHits(FairVolume* vol)
   if (stopHit) {
     TLorentzVector positionStop;
     fMC->TrackPosition(positionStop);
+
     // Retrieve the indices with the volume path
     int stave(0), halfstave(0), mod(0), chip(0);
+
+    auto& trkPars = TRKBaseParam::Instance();
+
     if (subDetID == 1) {
-      fMC->CurrentVolOffID(1, chip);
-      fMC->CurrentVolOffID(2, mod);
-      if (mGeometryTGeo->getNumberOfHalfStaves(layer) == 2) {
-        fMC->CurrentVolOffID(3, halfstave);
-        fMC->CurrentVolOffID(4, stave);
-      } else if (mGeometryTGeo->getNumberOfHalfStaves(layer) == 1) {
-        fMC->CurrentVolOffID(3, stave);
-      } else {
-        LOGP(fatal, "Wrong number of halfstaves for layer {}", layer);
+      if (trkPars.layoutMLOT == o2::trk::eMLOTLayout::kSegmented) {
+        fMC->CurrentVolOffID(1, chip);
+        fMC->CurrentVolOffID(2, mod);
+        if (mGeometryTGeo->getNumberOfHalfStaves(layer) == 2) {
+          fMC->CurrentVolOffID(3, halfstave);
+          fMC->CurrentVolOffID(4, stave);
+        } else if (mGeometryTGeo->getNumberOfHalfStaves(layer) == 1) {
+          fMC->CurrentVolOffID(3, stave);
+        } else {
+          LOGP(fatal, "Wrong number of halfstaves for layer {}", layer);
+        }
       }
     } /// if VD, for the moment the volume is the "chipID" so no need to retrieve other elments
 
@@ -522,18 +528,30 @@ void Detector::Print(FairVolume* vol, int volume, int subDetID, int layer, int s
   int currentVol(0);
   LOG(info) << "Current volume name: " << fMC->CurrentVolName() << " and ID " << fMC->CurrentVolID(currentVol);
   LOG(info) << "volume: " << volume << "/" << mNumberOfVolumes - 1;
-  LOG(info) << "off volume name 1 " << fMC->CurrentVolOffName(1) << "  chip: " << chip;
-  LOG(info) << "off volume name 2  " << fMC->CurrentVolOffName(2) << "  module: " << mod;
-  if (subDetID == 1 && mGeometryTGeo->getNumberOfHalfStaves(layer) == 2) { // staggered geometry
-    LOG(info) << "off volume name 3  " << fMC->CurrentVolOffName(3) << "  halfstave: " << halfstave;
-    LOG(info) << "off volume name 4  " << fMC->CurrentVolOffName(4) << "  stave: " << stave;
-    LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  staveinLayer: " << stave << "  Chip ID: " << chipID;
-  } else if (subDetID == 1 && mGeometryTGeo->getNumberOfHalfStaves(layer) == 1) { // turbo geometry
-    LOG(info) << "off volume name 3  " << fMC->CurrentVolOffName(3) << "  stave: " << stave;
-    LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  staveinLayer: " << stave << "  Chip ID: " << chipID;
+
+  auto& trkPars = TRKBaseParam::Instance();
+
+  if (subDetID == 1) { // MLOT
+    if (trkPars.layoutMLOT == o2::trk::eMLOTLayout::kCylindrical) {
+      LOG(info) << "off volume name 1 " << fMC->CurrentVolOffName(1) << "  chip: " << chip;
+      LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  Chip ID: " << chipID;
+    } else {
+      LOG(info) << "off volume name 1 " << fMC->CurrentVolOffName(1) << "  chip: " << chip;
+      LOG(info) << "off volume name 2  " << fMC->CurrentVolOffName(2) << "  module: " << mod;
+      if (mGeometryTGeo->getNumberOfHalfStaves(layer) == 2) { // staggered geometry
+        LOG(info) << "off volume name 3  " << fMC->CurrentVolOffName(3) << "  halfstave: " << halfstave;
+        LOG(info) << "off volume name 4  " << fMC->CurrentVolOffName(4) << "  stave: " << stave;
+        LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  staveinLayer: " << stave << "  Chip ID: " << chipID;
+      } else if (mGeometryTGeo->getNumberOfHalfStaves(layer) == 1) { // turbo geometry
+        LOG(info) << "off volume name 3  " << fMC->CurrentVolOffName(3) << "  stave: " << stave;
+        LOG(info) << "SubDetector ID: " << subDetID << "  Layer: " << layer << "  staveinLayer: " << stave << "  Chip ID: " << chipID;
+      }
+    }
   } else {
+    // VD
     LOG(info) << "SubDetector ID: " << subDetID << "  Chip ID: " << chipID;
   }
+
   LOG(info);
 }
 

From 6808cc40b2abd5baea093ab54b5f96fed6cc1053 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 17 Mar 2026 09:23:51 +0100
Subject: [PATCH 1429/1764] GPU TPC: Use stored field value during TPC track
 model decoding (#15170)

---
 GPU/GPUTracking/Base/GPUParam.h               |  4 ++--
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  4 ++--
 GPU/GPUTracking/Base/GPUReconstruction.h      |  2 +-
 GPU/GPUTracking/Global/GPUChain.h             |  1 +
 .../Global/GPUChainTrackingCompression.cxx    | 19 +++++++++++++++++--
 .../Interface/GPUO2InterfaceRefit.cxx         |  2 +-
 .../Interface/GPUO2InterfaceUtils.cxx         |  2 +-
 7 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 847f3e05ea32e..0716274c5e198 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -80,10 +80,10 @@ struct GPUParam_t {
 struct GPUParam : public internal::GPUParam_t<GPUSettingsRec, GPUSettingsParam> {
 
 #ifndef GPUCA_GPUCODE
-  void SetDefaults(float solenoidBz, bool assumeConstantBz);
+  void SetDefaults(float solenoidBz, bool assumeConstantBz = false);
   void SetDefaults(const GPUSettingsGRP* g, const GPUSettingsRec* r = nullptr, const GPUSettingsProcessing* p = nullptr, const GPURecoStepConfiguration* w = nullptr);
   void UpdateSettings(const GPUSettingsGRP* g, const GPUSettingsProcessing* p = nullptr, const GPURecoStepConfiguration* w = nullptr, const GPUSettingsRecDynamic* d = nullptr);
-  void UpdateBzOnly(float newSolenoidBz, bool assumeConstantBz);
+  void UpdateBzOnly(float newSolenoidBz, bool assumeConstantBz = false);
   void UpdateRun3ClusterErrors(const float* yErrorParam, const float* zErrorParam);
 #endif
 
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index fbbe815f63c33..f34a049a1588d 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -433,11 +433,11 @@ int32_t GPUReconstruction::InitPhaseAfterDevice()
   return 0;
 }
 
-void GPUReconstruction::WriteConstantParams()
+void GPUReconstruction::WriteConstantParams(int32_t stream)
 {
   if (IsGPU()) {
     const auto threadContext = GetThreadContext();
-    WriteToConstantMemory(ptrDiff(&processors()->param, processors()), &param(), sizeof(param()), -1);
+    WriteToConstantMemory(ptrDiff(&processors()->param, processors()), &param(), sizeof(param()), stream);
   }
 }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index b5dd29f940143..9a337c02ad26d 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -260,7 +260,7 @@ class GPUReconstruction
   virtual int32_t InitDevice() = 0;
   int32_t InitPhasePermanentMemory();
   int32_t InitPhaseAfterDevice();
-  void WriteConstantParams();
+  void WriteConstantParams(int32_t stream = -1);
   virtual int32_t ExitDevice() = 0;
   virtual size_t WriteToConstantMemory(size_t offset, const void* src, size_t size, int32_t stream = -1, gpu_reconstruction_kernels::deviceEvent* ev = nullptr) = 0;
   void UpdateMaxMemoryUsed();
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index 907ed7ea97c12..a524fd9ec3992 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -124,6 +124,7 @@ class GPUChain
   inline void TransferMemoryResourceLinkToGPU(RecoStep step, int16_t res, int32_t stream = -1, deviceEvent* ev = nullptr, deviceEvent* evList = nullptr, int32_t nEvents = 1) { timeCpy(step, true, &GPUReconstructionCPU::TransferMemoryResourceLinkToGPU, res, stream, ev, evList, nEvents); }
   inline void TransferMemoryResourceLinkToHost(RecoStep step, int16_t res, int32_t stream = -1, deviceEvent* ev = nullptr, deviceEvent* evList = nullptr, int32_t nEvents = 1) { timeCpy(step, false, &GPUReconstructionCPU::TransferMemoryResourceLinkToHost, res, stream, ev, evList, nEvents); }
   // Todo: retrieve step from proc, move kernelClass->GetStep to retrieve it from GetProcessor
+  inline void WriteConstantParams(int32_t stream = -1) { mRec->WriteConstantParams(stream); }
   inline void WriteToConstantMemory(RecoStep step, size_t offset, const void* src, size_t size, int32_t stream = -1, deviceEvent* ev = nullptr) { timeCpy(step, true, &GPUReconstructionCPU::WriteToConstantMemory, offset, src, size, stream, ev); }
   inline void GPUMemCpy(RecoStep step, void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev = nullptr, deviceEvent* evList = nullptr, int32_t nEvents = 1) { timeCpy(step, toGPU, &GPUReconstructionCPU::GPUMemCpy, dst, src, size, stream, toGPU, ev, evList, nEvents); }
   inline void GPUMemCpyAlways(RecoStep step, void* dst, const void* src, size_t size, int32_t stream, int32_t toGPU, deviceEvent* ev = nullptr, deviceEvent* evList = nullptr, int32_t nEvents = 1)
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index 89d47d0e1b86c..f185348ed9169 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -225,6 +225,17 @@ int32_t GPUChainTracking::RunTPCDecompression()
     GPUFatal("tpcApplyCFCutsAtDecoding, tpcApplyClusterFilterOnCPU and tpcCutTimeBin currently require tpcUseOldCPUDecoding");
   }
 
+  CompressedClusters cmprClsHost = *mIOPtrs.tpcCompressedClusters;
+  const bool useTemporaryBz = cmprClsHost.nTracks && cmprClsHost.solenoidBz != -1e6f && cmprClsHost.solenoidBz != param().bzkG && !GetProcessingSettings().doublePipeline;
+  std::unique_ptr<GPUParam> tmpParam;
+  int32_t inputStream = 0;
+
+  if (useTemporaryBz) {
+    tmpParam = std::make_unique<GPUParam>(param());
+    SynchronizeGPU();
+    param().UpdateBzOnly(cmprClsHost.solenoidBz, mRec->GetGRPSettings().constBz);
+    WriteConstantParams(inputStream);
+  }
   if (GetProcessingSettings().tpcUseOldCPUDecoding) {
     const bool runFiltering = needFullFiltering || runTimeBinCutFiltering;
     const auto& threadContext = GetThreadContext();
@@ -268,7 +279,6 @@ int32_t GPUChainTracking::RunTPCDecompression()
     GPUTPCDecompression& Decompressor = processors()->tpcDecompressor;
     GPUTPCDecompression& DecompressorShadow = doGPU ? processorsShadow()->tpcDecompressor : Decompressor;
     const auto& threadContext = GetThreadContext();
-    CompressedClusters cmprClsHost = *mIOPtrs.tpcCompressedClusters;
     CompressedClusters& inputGPU = Decompressor.mInputGPU;
     CompressedClusters& inputGPUShadow = DecompressorShadow.mInputGPU;
 
@@ -279,7 +289,6 @@ int32_t GPUChainTracking::RunTPCDecompression()
       throw std::runtime_error("Configured max time bin " + std::to_string(param().continuousMaxTimeBin) + " does not match value used for track model encoding " + std::to_string(cmprClsHost.maxTimeBin));
     }
 
-    int32_t inputStream = 0;
     int32_t unattachedStream = mRec->NStreams() - 1;
     inputGPU = cmprClsHost;
     SetupGPUProcessor(&Decompressor, true);
@@ -437,6 +446,12 @@ int32_t GPUChainTracking::RunTPCDecompression()
     }
     mRec->PopNonPersistentMemory(RecoStep::TPCDecompression, qStr2Tag("TPCDCMPR"));
   }
+  if (useTemporaryBz) {
+    SynchronizeGPU();
+    param() = *tmpParam;
+    tmpParam.reset();
+    WriteConstantParams();
+  }
   DoDebugDump(GPUChainTrackingDebugFlags::TPCDecompressedClusters, &GPUChainTracking::DumpClusters, *mDebugFile, mIOPtrs.clustersNative);
   return 0;
 }
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
index f09c5d0a4b1cb..10a1a75368c96 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
@@ -129,7 +129,7 @@ GPUO2InterfaceRefit::GPUO2InterfaceRefit(const ClusterNativeAccess* cl, const Co
 
 void GPUO2InterfaceRefit::updateCalib(const CorrectionMapsHelper* trans, float bzNominalGPU)
 {
-  mParam->UpdateBzOnly(bzNominalGPU, false);
+  mParam->UpdateBzOnly(bzNominalGPU);
   mRefit->SetFastTransformHelper(trans);
 }
 
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
index 43b8dc21eaf15..7f230ff20eb10 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
@@ -52,7 +52,7 @@ template <>
 void GPUO2InterfaceUtils::RunZSEncoder<DigitArray>(const DigitArray& in, std::unique_ptr<uint64_t[]>* outBuffer, uint32_t* outSizes, o2::raw::RawFileWriter* raw, const o2::InteractionRecord* ir, int32_t version, bool verify, float threshold, bool padding, std::function<void(std::vector<o2::tpc::Digit>&)> digitsFilter)
 {
   GPUParam param;
-  param.SetDefaults(5.00668, false);
+  param.SetDefaults(5.00668);
   o2::gpu::GPUReconstructionConvert::RunZSEncoder(in, outBuffer, outSizes, raw, ir, param, version, verify, threshold, padding, digitsFilter);
 }
 template <>

From 6f830a202b69e489b1bbd4bce4215860cb93b242 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 10 Mar 2026 22:29:56 +0100
Subject: [PATCH 1430/1764] Fix GPU b-field initialization

The 12kA L3 field should be scaled wrt its own nominal rather than 30kA nominal Bz.
Keep the old scaling for backward compatibility
---
 GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx | 6 ++++++
 GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h   | 3 ++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
index 7f230ff20eb10..b6491c72d83f3 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
@@ -142,3 +142,9 @@ uint32_t GPUO2InterfaceUtils::getTpcMaxTimeBinFromNHbf(uint32_t nHbf)
 {
   return (nHbf * o2::constants::lhc::LHCMaxBunches + 2 * o2::tpc::constants::LHCBCPERTIMEBIN - 2) / o2::tpc::constants::LHCBCPERTIMEBIN;
 }
+
+float GPUO2InterfaceUtils::getNominalGPUBzFromCurrent(float l3curr)
+{
+  float al3curr = CAMath::Abs(l3curr);
+  return (CAMath::Abs(al3curr - 12000) < CAMath::Abs(al3curr - 30000) ? (2.04487f / 12000.f) : (5.00668f / 30000.f)) * l3curr;
+}
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h
index 0b5d2b5aa3f7a..813444470082e 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h
@@ -53,8 +53,9 @@ class GPUO2InterfaceUtils
   template <class T>
   static float getNominalGPUBz(T& src)
   {
-    return (5.00668f / 30000.f) * src.getL3Current();
+    return getNominalGPUBzFromCurrent(src.getL3Current());
   }
+  static float getNominalGPUBzFromCurrent(float l3curr);
   static std::unique_ptr<GPUParam> getFullParam(float solenoidBz, uint32_t nHbfPerTf = 0, std::unique_ptr<GPUO2InterfaceConfiguration>* pConfiguration = nullptr, std::unique_ptr<GPUSettingsO2>* pO2Settings = nullptr, bool* autoMaxTimeBin = nullptr);
   static std::shared_ptr<GPUParam> getFullParamShared(float solenoidBz, uint32_t nHbfPerTf = 0, std::unique_ptr<GPUO2InterfaceConfiguration>* pConfiguration = nullptr, std::unique_ptr<GPUSettingsO2>* pO2Settings = nullptr, bool* autoMaxTimeBin = nullptr); // Return owning pointer
   static void paramUseExternalOccupancyMap(GPUParam* param, uint32_t nHbfPerTf, const uint32_t* occupancymap, int32_t occupancyMapSize);

From b0b8814350a8b4404fbb588766a260ea82ba9e5c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 16 Mar 2026 20:50:53 +0100
Subject: [PATCH 1431/1764] GPU: Make memory scaling factors configKeyValues

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    |  2 +-
 .../DataTypes/GPUMemorySizeScalers.cxx        | 19 ++++++-
 .../DataTypes/GPUMemorySizeScalers.h          | 57 ++++++-------------
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 23 +++++++-
 .../GPUTrackingLinkDef_O2_DataTypes.h         |  1 +
 prodtests/full-system-test/dpl-workflow.sh    |  2 +-
 6 files changed, 60 insertions(+), 44 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index f34a049a1588d..f6aa62778a061 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -309,8 +309,8 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     mProcessingSettings->clusterizerZSSanityCheck = mProcessingSettings->mergerSanityCheck = mProcessingSettings->outputSanityCheck = true;
   }
 
+  static_cast<GPUSettingsProcessingScaling&>(*mMemoryScalers) = GetProcessingSettings().scaling;
   mMemoryScalers->scalingFactor = GetProcessingSettings().memoryScalingFactor;
-  mMemoryScalers->conservative = GetProcessingSettings().conservativeMemoryEstimate;
   mMemoryScalers->returnMaxVal = GetProcessingSettings().forceMaxMemScalers != 0;
   if (GetProcessingSettings().forceMaxMemScalers > 1) {
     mMemoryScalers->rescaleMaxMem(GetProcessingSettings().forceMaxMemScalers);
diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
index 42ac2e8015f45..e9e1484249399 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
@@ -39,7 +39,7 @@ void GPUMemorySizeScalers::rescaleMaxMem(size_t newAvailableMemory)
   availableMemory = newAvailableMemory;
 }
 
-double GPUMemorySizeScalers::getScalingFactor()
+float GPUMemorySizeScalers::getScalingFactor()
 {
   if (!doFuzzing) {
     return scalingFactor;
@@ -62,3 +62,20 @@ void GPUMemorySizeScalers::fuzzScalingFactor(uint64_t seed)
   fuzzSeed = seed;
   doFuzzing = true;
 }
+
+size_t GPUMemorySizeScalers::getValue(size_t maxVal, size_t val)
+{
+  return returnMaxVal ? maxVal : (std::min<size_t>(maxVal, offset + val) * (doFuzzing == 0 ? scalingFactor : getScalingFactor()) * temporaryFactor);
+}
+
+size_t GPUMemorySizeScalers::NTPCPeaks(size_t tpcDigits, bool perSector) { return getValue(perSector ? tpcMaxPeaks : (GPUCA_NSECTORS * tpcMaxPeaks), hitOffset + tpcDigits * tpcPeaksPerDigit); }
+size_t GPUMemorySizeScalers::NTPCClusters(size_t tpcDigits, bool perSector) { return getValue(perSector ? tpcMaxSectorClusters : tpcMaxClusters, (conservativeMemoryEstimate ? 1.0 : tpcClustersPerPeak) * NTPCPeaks(tpcDigits, perSector)); }
+size_t GPUMemorySizeScalers::NTPCStartHits(size_t tpcHits) { return getValue(tpcMaxStartHits, tpcHits * tpcStartHitsPerHit); }
+size_t GPUMemorySizeScalers::NTPCRowStartHits(size_t tpcHits) { return getValue(tpcMaxRowStartHits, std::max<size_t>(NTPCStartHits(tpcHits) * (tpcHits < 30000000 ? 20 : 12) / GPUCA_ROW_COUNT, tpcMinRowStartHits)); }
+size_t GPUMemorySizeScalers::NTPCTracklets(size_t tpcHits, bool lowField) { return getValue(tpcMaxTracklets, NTPCStartHits(tpcHits) * (lowField ? tpcTrackletsPerStartHitLowField : tpcTrackletsPerStartHit)); }
+size_t GPUMemorySizeScalers::NTPCTrackletHits(size_t tpcHits, bool lowField) { return getValue(tpcMaxTrackletHits, hitOffset + tpcHits * (lowField ? tpcTrackletHitsPerHitLowField : tpcTrackletHitsPerHit)); }
+size_t GPUMemorySizeScalers::NTPCSectorTracks(size_t tpcHits) { return getValue(tpcMaxSectorTracks, tpcHits * tpcSectorTracksPerHit); }
+size_t GPUMemorySizeScalers::NTPCSectorTrackHits(size_t tpcHits, uint8_t withRejection) { return getValue(tpcMaxSectorTrackHits, tpcHits * (withRejection ? tpcSectorTrackHitsPerHitWithRejection : tpcSectorTrackHitsPerHit)); }
+size_t GPUMemorySizeScalers::NTPCMergedTracks(size_t tpcSectorTracks) { return getValue(tpcMaxMergedTracks, tpcSectorTracks * (conservativeMemoryEstimate ? 1.0 : tpcMergedTrackPerSectorTrack)); }
+size_t GPUMemorySizeScalers::NTPCMergedTrackHits(size_t tpcSectorTrackHitss) { return getValue(tpcMaxMergedTrackHits, tpcSectorTrackHitss * tpcMergedTrackHitPerSectorHit); }
+size_t GPUMemorySizeScalers::NTPCUnattachedHitsBase1024(int32_t type) { return (returnMaxVal || conservativeMemoryEstimate) ? 1024 : std::min<size_t>(1024, tpcCompressedUnattachedHitsBase1024[type] * (doFuzzing == 0 ? scalingFactor : getScalingFactor()) * temporaryFactor); }
diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
index 067a11817d7ac..a81d296459acd 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.h
@@ -16,11 +16,12 @@
 #define O2_GPU_GPUMEMORYSIZESCALERS_H
 
 #include "GPUDef.h"
+#include "GPUSettings.h"
 
 namespace o2::gpu
 {
 
-struct GPUMemorySizeScalers {
+struct GPUMemorySizeScalers : public GPUSettingsProcessingScaling {
   // Input sizes
   size_t nTPCdigits = 0;
   size_t nTPCHits = 0;
@@ -28,30 +29,10 @@ struct GPUMemorySizeScalers {
   size_t nITSTracks = 0;
 
   // General scaling factor
-  double scalingFactor = 1;
+  float scalingFactor = 1;
   uint64_t fuzzSeed = 0;
   uint64_t fuzzLimit = 0;
-  double temporaryFactor = 1;
-  bool conservative = 0;
-
-  // Offset
-  double offset = 1000.;
-  double hitOffset = 20000;
-
-  // Scaling Factors
-  double tpcPeaksPerDigit = 0.2;
-  double tpcClustersPerPeak = 0.9;
-  double tpcStartHitsPerHit = 0.08;
-  double tpcTrackletsPerStartHit = 0.8;
-  double tpcTrackletsPerStartHitLowField = 0.85;
-  double tpcTrackletHitsPerHit = 5;
-  double tpcTrackletHitsPerHitLowField = 7;
-  double tpcSectorTracksPerHit = 0.02;
-  double tpcSectorTrackHitsPerHit = 0.8;
-  double tpcSectorTrackHitsPerHitWithRejection = 1.0;
-  double tpcMergedTrackPerSectorTrack = 1.0;
-  double tpcMergedTrackHitPerSectorHit = 1.1;
-  size_t tpcCompressedUnattachedHitsBase1024[3] = {900, 900, 500}; // No ratio, but integer fraction of 1024 for exact computation
+  float temporaryFactor = 1;
 
   // Upper limits
   size_t tpcMaxPeaks = 20000000;
@@ -71,24 +52,20 @@ struct GPUMemorySizeScalers {
   bool doFuzzing = false;
 
   void rescaleMaxMem(size_t newAvailableMemory);
-  double getScalingFactor();
+  float getScalingFactor();
   void fuzzScalingFactor(uint64_t seed);
-  inline size_t getValue(size_t maxVal, size_t val)
-  {
-    return returnMaxVal ? maxVal : (std::min<size_t>(maxVal, offset + val) * (doFuzzing == 0 ? scalingFactor : getScalingFactor()) * temporaryFactor);
-  }
-
-  inline size_t NTPCPeaks(size_t tpcDigits, bool perSector = false) { return getValue(perSector ? tpcMaxPeaks : (GPUCA_NSECTORS * tpcMaxPeaks), hitOffset + tpcDigits * tpcPeaksPerDigit); }
-  inline size_t NTPCClusters(size_t tpcDigits, bool perSector = false) { return getValue(perSector ? tpcMaxSectorClusters : tpcMaxClusters, (conservative ? 1.0 : tpcClustersPerPeak) * NTPCPeaks(tpcDigits, perSector)); }
-  inline size_t NTPCStartHits(size_t tpcHits) { return getValue(tpcMaxStartHits, tpcHits * tpcStartHitsPerHit); }
-  inline size_t NTPCRowStartHits(size_t tpcHits) { return getValue(tpcMaxRowStartHits, std::max<size_t>(NTPCStartHits(tpcHits) * (tpcHits < 30000000 ? 20 : 12) / GPUCA_ROW_COUNT, tpcMinRowStartHits)); }
-  inline size_t NTPCTracklets(size_t tpcHits, bool lowField) { return getValue(tpcMaxTracklets, NTPCStartHits(tpcHits) * (lowField ? tpcTrackletsPerStartHitLowField : tpcTrackletsPerStartHit)); }
-  inline size_t NTPCTrackletHits(size_t tpcHits, bool lowField) { return getValue(tpcMaxTrackletHits, hitOffset + tpcHits * (lowField ? tpcTrackletHitsPerHitLowField : tpcTrackletHitsPerHit)); }
-  inline size_t NTPCSectorTracks(size_t tpcHits) { return getValue(tpcMaxSectorTracks, tpcHits * tpcSectorTracksPerHit); }
-  inline size_t NTPCSectorTrackHits(size_t tpcHits, uint8_t withRejection = 0) { return getValue(tpcMaxSectorTrackHits, tpcHits * (withRejection ? tpcSectorTrackHitsPerHitWithRejection : tpcSectorTrackHitsPerHit)); }
-  inline size_t NTPCMergedTracks(size_t tpcSectorTracks) { return getValue(tpcMaxMergedTracks, tpcSectorTracks * (conservative ? 1.0 : tpcMergedTrackPerSectorTrack)); }
-  inline size_t NTPCMergedTrackHits(size_t tpcSectorTrackHitss) { return getValue(tpcMaxMergedTrackHits, tpcSectorTrackHitss * tpcMergedTrackHitPerSectorHit); }
-  inline size_t NTPCUnattachedHitsBase1024(int32_t type) { return (returnMaxVal || conservative) ? 1024 : std::min<size_t>(1024, tpcCompressedUnattachedHitsBase1024[type] * (doFuzzing == 0 ? scalingFactor : getScalingFactor()) * temporaryFactor); }
+  size_t getValue(size_t maxVal, size_t val);
+  size_t NTPCPeaks(size_t tpcDigits, bool perSector = false);
+  size_t NTPCClusters(size_t tpcDigits, bool perSector = false);
+  size_t NTPCStartHits(size_t tpcHits);
+  size_t NTPCRowStartHits(size_t tpcHits);
+  size_t NTPCTracklets(size_t tpcHits, bool lowField);
+  size_t NTPCTrackletHits(size_t tpcHits, bool lowField);
+  size_t NTPCSectorTracks(size_t tpcHits);
+  size_t NTPCSectorTrackHits(size_t tpcHits, uint8_t withRejection = 0);
+  size_t NTPCMergedTracks(size_t tpcSectorTracks);
+  size_t NTPCMergedTrackHits(size_t tpcSectorTrackHitss);
+  size_t NTPCUnattachedHitsBase1024(int32_t type);
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index e34af48d7a85e..57cb1371a4aa0 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -297,6 +297,27 @@ AddOption(nnCCDBInteractionRate, std::string, "500", "", 0, "Distinguishes betwe
 AddHelp("help", 'h')
 EndConfig()
 
+// Settings steering the processing of NN Clusterization
+BeginSubConfig(GPUSettingsProcessingScaling, scaling, configStandalone.proc, "SCALING", 0, "Processing settings for neural network clusterizer", proc_scaling)
+AddOption(offset, float, 1000., "", 0, "Scaling Factor: offset")
+AddOption(hitOffset, float, 20000, "", 0, "Scaling Factor: hitOffset")
+AddOption(tpcPeaksPerDigit, float, 0.2, "", 0, "Scaling Factor: tpcPeaksPerDigit")
+AddOption(tpcClustersPerPeak, float, 0.9, "", 0, "Scaling Factor: tpcClustersPerPeak")
+AddOption(tpcStartHitsPerHit, float, 0.08, "", 0, "Scaling Factor: tpcStartHitsPerHit")
+AddOption(tpcTrackletsPerStartHit, float, 0.8, "", 0, "Scaling Factor: tpcTrackletsPerStartHit")
+AddOption(tpcTrackletsPerStartHitLowField, float, 0.85, "", 0, "Scaling Factor: tpcTrackletsPerStartHitLowField")
+AddOption(tpcTrackletHitsPerHit, float, 5, "", 0, "Scaling Factor: tpcTrackletHitsPerHit")
+AddOption(tpcTrackletHitsPerHitLowField, float, 7, "", 0, "Scaling Factor: tpcTrackletHitsPerHitLowField")
+AddOption(tpcSectorTracksPerHit, float, 0.02, "", 0, "Scaling Factor: tpcSectorTracksPerHit")
+AddOption(tpcSectorTrackHitsPerHit, float, 0.8, "", 0, "Scaling Factor: tpcSectorTrackHitsPerHit")
+AddOption(tpcSectorTrackHitsPerHitWithRejection, float, 1.0, "", 0, "Scaling Factor: tpcSectorTrackHitsPerHitWithRejection")
+AddOption(tpcMergedTrackPerSectorTrack, float, 1.0, "", 0, "Scaling Factor: tpcMergedTrackPerSectorTrack")
+AddOption(tpcMergedTrackHitPerSectorHit, float, 1.1, "", 0, "Scaling Factor: tpcMergedTrackHitPerSectorHit")
+AddOptionArray(tpcCompressedUnattachedHitsBase1024, int32_t, 3, (900, 900, 500), "", 0, "Scaling Factor: tpcCompressedUnattachedHitsBase1024")
+AddOption(conservativeMemoryEstimate, bool, false, "", 0, "Use some more conservative defaults for larger buffers during TPC processing")
+AddHelp("help", 'h')
+EndConfig()
+
 // Settings steering the processing once the device was selected, only available on the host
 BeginSubConfig(GPUSettingsProcessing, proc, configStandalone, "PROC", 0, "Processing settings", proc)
 AddOption(deviceNum, int32_t, -1, "gpuDevice", 0, "Set GPU device to use (-1: automatic, -2: for round-robin usage in timeslice-pipeline)")
@@ -323,7 +344,6 @@ AddOption(forceMemoryPoolSize, uint64_t, 1, "memSize", 0, "Force size of allocat
 AddOption(forceHostMemoryPoolSize, uint64_t, 0, "hostMemSize", 0, "Force size of allocated host page locked host memory (overriding memSize)", min(0ul))
 AddOption(memoryScalingFactor, float, 1.f, "", 0, "Factor to apply to all memory scalers")
 AddOption(memoryScalingFuzz, uint64_t, 0, "", 0, "Fuzz the memoryScalingFactor (0 disable, 1 enable, >1 set seed", def(1))
-AddOption(conservativeMemoryEstimate, bool, false, "", 0, "Use some more conservative defaults for larger buffers during TPC processing")
 AddOption(tpcInputWithClusterRejection, uint8_t, 0, "", 0, "Indicate whether the TPC input is CTF data with cluster rejection, to tune buffer estimations")
 AddOption(forceMaxMemScalers, uint64_t, 0, "", 0, "Force using the maximum values for all buffers, Set a value n > 1 to rescale all maximums to a memory size of n")
 AddOption(registerStandaloneInputMemory, bool, false, "registerInputMemory", 0, "Automatically register input memory buffers for the GPU")
@@ -390,6 +410,7 @@ AddSubConfig(GPUSettingsProcessingRTC, rtc)
 AddSubConfig(GPUSettingsProcessingRTCtechnical, rtctech)
 AddSubConfig(GPUSettingsProcessingParam, param)
 AddSubConfig(GPUSettingsProcessingNNclusterizer, nn)
+AddSubConfig(GPUSettingsProcessingScaling, scaling)
 AddHelp("help", 'h')
 EndConfig()
 #endif // __OPENCL__
diff --git a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
index 5318e23e7d10f..9265c86f26ec9 100644
--- a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
+++ b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
@@ -32,6 +32,7 @@
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessingRTC + ;
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessingRTCtechnical + ;
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessingNNclusterizer + ;
+#pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsProcessingScaling + ;
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsDisplay + ;
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsDisplayLight + ;
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsDisplayHeavy + ;
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index a3048a494796e..5b7ffc3cc6547 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -250,7 +250,7 @@ if [[ $SYNCRAWMODE == 1 ]]; then
   TOF_CONFIG+=" --for-calib"
 fi
 if [[ $SYNCRAWMODE == 1 ]] || [[ $SYNCMODE == 0 && $CTFINPUT == 1 && $GPUTYPE != "CPU" ]]; then
-  GPU_CONFIG_KEY+="GPU_proc.conservativeMemoryEstimate=1;"
+  GPU_CONFIG_KEY+="GPU_proc_scaling.conservativeMemoryEstimate=1;"
 fi
 
 if [[ $SYNCMODE == 1 && "0${ED_NO_ITS_ROF_FILTER:-}" != "01" && $BEAMTYPE == "PbPb" ]] && has_detector ITS; then

From decf5734f5f3787efa512cf4b65d20e2e9844d8f Mon Sep 17 00:00:00 2001
From: Marco Giacalone <mgiacalo@gmail.com>
Date: Tue, 17 Mar 2026 13:49:44 +0100
Subject: [PATCH 1432/1764] Workaround for non-null vertexes in event pools
 (#15169)

---
 Generators/include/Generators/GeneratorFromFile.h | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/Generators/include/Generators/GeneratorFromFile.h b/Generators/include/Generators/GeneratorFromFile.h
index 329510f844f05..9bf1d4911008b 100644
--- a/Generators/include/Generators/GeneratorFromFile.h
+++ b/Generators/include/Generators/GeneratorFromFile.h
@@ -89,6 +89,7 @@ class GeneratorFromO2Kine : public o2::eventgen::Generator
   void setContinueMode(bool val) { mContinueMode = val; };
   /** methods that can be overridden **/
   void updateHeader(o2::dataformats::MCEventHeader* eventHeader) override;
+  const o2::dataformats::MCEventHeader* getOrigMCEventHeader() const { return mOrigMCEventHeader.get(); }
 
  private:
   TFile* mEventFile = nullptr;     //! the file containing the persistent events
@@ -138,7 +139,17 @@ class GeneratorFromEventPool : public o2::eventgen::Generator
     auto import_good = mO2KineGenerator->importParticles();
     // transfer the particles (could be avoided)
     mParticles = mO2KineGenerator->getParticles();
-
+    auto original_header = mO2KineGenerator->getOrigMCEventHeader();
+    // Workaround to fix vertex shifted particles from event pools (valid for builds released before 14 March 2026)
+    if (original_header) {
+      double vertex[3] = {original_header->GetX(), original_header->GetY(), original_header->GetZ()};
+      if (vertex[0] != 0. || vertex[1] != 0. || vertex[2] != 0.) {
+        LOG(debug) << "Subtracting shifted vertex from EventPool: (" << vertex[0] << ", " << vertex[1] << ", " << vertex[2] << ")";
+        for (auto& p : mParticles) {
+          p.SetProductionVertex(p.Vx() - vertex[0], p.Vy() - vertex[1], p.Vz() - vertex[2], p.T());
+        }
+      }
+    }
     return import_good;
   }
 

From 66124b288bf794bbc9b550dcdf8dc2e80997429c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 17 Mar 2026 17:11:39 +0100
Subject: [PATCH 1433/1764] Fix boost 1.90.0 / clang issue (#15176)

---
 Detectors/TPC/calibration/src/CalibdEdx.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/TPC/calibration/src/CalibdEdx.cxx b/Detectors/TPC/calibration/src/CalibdEdx.cxx
index 938ab8ae91065..5205c9348dec7 100644
--- a/Detectors/TPC/calibration/src/CalibdEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalibdEdx.cxx
@@ -590,7 +590,9 @@ int CalibdEdx::minStackEntries() const
   auto projection = bh::algorithm::project(mHist, std::vector<int>{Axis::Sector, Axis::Stack, Axis::Charge});
   auto dEdxCounts = bh::indexed(projection);
   // find the stack with the least number of entries
-  auto min_it = std::min_element(dEdxCounts.begin(), dEdxCounts.end());
+  // use explicit int comparator to avoid ambiguous operator< between accessor and unlimited_storage::reference (boost/clang issue)
+  auto min_it = std::min_element(dEdxCounts.begin(), dEdxCounts.end(),
+                                 [](const auto& a, const auto& b) { return static_cast<int>(*a) < static_cast<int>(*b); });
   return *min_it;
 }
 

From 6527904f57954ebe49d6eed18fba021a5cf32ea4 Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Tue, 17 Mar 2026 21:59:02 +0100
Subject: [PATCH 1434/1764] [ALICE3] update of readme for FT3 and ALICE3
 (#15178)

Co-authored-by: Igor Altsybeev <Igor.Altsybeev@cern.ch>
---
 Detectors/Upgrades/ALICE3/FT3/README.md | 20 ++++++++++++++++++++
 Detectors/Upgrades/ALICE3/README.md     | 15 +++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/Detectors/Upgrades/ALICE3/FT3/README.md b/Detectors/Upgrades/ALICE3/FT3/README.md
index 71cb7a6e63bb9..34a6782a2b0c2 100644
--- a/Detectors/Upgrades/ALICE3/FT3/README.md
+++ b/Detectors/Upgrades/ALICE3/FT3/README.md
@@ -6,5 +6,25 @@
 
 This is top page for the FT3 detector documentation.
 
+## Specific detector setup
+
+
+Configuration of the endcap disks can be done by setting values for the `FT3Base.layoutFT3` configurable,
+the available options are presented in the following Table:
+
+| Option                 | Comments                                                                                                          |
+| ---------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `kSegmented` (default) | Currently, only OT disks have realistic implementation, for ML - simple trapezoids                                |
+| `kTrapezoidal`         | Simple trapezoisal disks (in both ML and OT), with `FT3Base.nTrapezoidalSegments=32`                              |
+| `kCylindrical`         | Simplest possible disks as TGeoTubes (ML and OT), bad for ACTS (wrong digi due to polar coorinates on disk sides) |
+
+[ [Link to definitions](./base/include/FT3Base/FT3BaseParam.h) ]
+
+For example, a geometry with the endcaps-only can be obtained by
+```bash
+o2-sim-serial-run5 -n 1 -g pythia8hi -m FT3 \
+  --configKeyValues "FT3Base.layoutFT3=kTrapezoidal"
+```
+
 <!-- doxy
 /doxy -->
diff --git a/Detectors/Upgrades/ALICE3/README.md b/Detectors/Upgrades/ALICE3/README.md
index 44a478b592882..6ff034facb546 100644
--- a/Detectors/Upgrades/ALICE3/README.md
+++ b/Detectors/Upgrades/ALICE3/README.md
@@ -69,8 +69,23 @@ Configurables for various sub-detectors are presented in the following Table:
 | Available options | Link to options                                                  |
 | ----------------- | ---------------------------------------------------------------- |
 | TRK               | [Link to TRK options](./TRK/README.md#specific-detector-setup)   |
+| FT3               | [Link to FT3 options](./FT3/README.md#specific-detector-setup)   |
 | TOF               | [Link to TOF options](./IOTOF/README.md#specific-detector-setup) |
 
+Example O2 command to create a geometry with **segmented layers for TRK (expect for VD), FT3 and TOF:**
+
+```bash
+o2-sim-serial-run5 -n 1 -g pythia8hi -m A3IP TRK FT3 TF3 \
+--configKeyValues "TRKBase.layoutVD=kIRISFullCyl;TRKBase.layoutMLOT=kSegmented;FT3Base.layoutFT3=kSegmented;IOTOFBase.segmentedInnerTOF=true;IOTOFBase.segmentedOuterTOF=true"
+```
+
+Example O2 command to create a geometry with **simple (non-segmented) layers for TRK, FT3 and TOF**:
+
+```bash
+o2-sim-serial-run5 -n 1 -g pythia8hi -m A3IP TRK FT3 TF3 \
+--configKeyValues "TRKBase.layoutVD=kIRISFullCyl;TRKBase.layoutMLOT=kCylindrical;FT3Base.layoutFT3=kTrapezoidal;IOTOFBase.segmentedInnerTOF=false;IOTOFBase.segmentedOuterTOF=false"
+```
+
 ### Output of the simulation
 The simulation will produce a `o2sim_Hits<DetID>.root` file with a tree with the hits related to that detector.
 

From c14106b3db7cecd2149745d497b5eb81105e3998 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 17 Mar 2026 17:25:12 +0100
Subject: [PATCH 1435/1764] DPL: protect against missing monitoring

---
 Framework/AnalysisSupport/src/DataInputDirector.cxx | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index ace4565449c4b..7027655b7abe7 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -314,7 +314,9 @@ void DataInputDescriptor::printFileOpening()
     monitoringInfo += fmt::format(",se={},open_time={:.1f}", alienFile->GetSE(), alienFile->GetElapsed());
   }
 #endif
-  mContext.monitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-open-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
+  if (mContext.monitoring) {
+    mContext.monitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-open-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
+  }
   LOGP(info, "Opening file: {}", monitoringInfo);
 }
 
@@ -335,7 +337,9 @@ void DataInputDescriptor::printFileStatistics()
     monitoringInfo += fmt::format(",se={},open_time={:.1f}", alienFile->GetSE(), alienFile->GetElapsed());
   }
 #endif
-  mContext.monitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-read-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
+  if (mContext.monitoring) {
+    mContext.monitoring->send(o2::monitoring::Metric{monitoringInfo, "aod-file-read-info"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
+  }
   LOGP(info, "Read info: {}", monitoringInfo);
 }
 

From 87b5043479fa0db653b18cfdf84b41458acadac3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 17 Mar 2026 17:25:12 +0100
Subject: [PATCH 1436/1764] DPL: allow non-owning TFileFileSystem

Given this filesystem is really a virtual entity, it makes
sense to allow for actual ownership of the TFile elsewhere.
---
 .../Core/include/Framework/RootArrowFilesystem.h      |  3 ++-
 Framework/Core/src/RootArrowFilesystem.cxx            | 11 +++++++----
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/Framework/Core/include/Framework/RootArrowFilesystem.h b/Framework/Core/include/Framework/RootArrowFilesystem.h
index 5aceaed077001..07aaa348c220a 100644
--- a/Framework/Core/include/Framework/RootArrowFilesystem.h
+++ b/Framework/Core/include/Framework/RootArrowFilesystem.h
@@ -146,7 +146,7 @@ class TFileFileSystem : public VirtualRootFileSystemBase
  public:
   arrow::Result<arrow::fs::FileInfo> GetFileInfo(const std::string& path) override;
 
-  TFileFileSystem(TDirectoryFile* f, size_t readahead, RootObjectReadingFactory&);
+  TFileFileSystem(TDirectoryFile* f, size_t readahead, RootObjectReadingFactory&, bool ownsFile = true);
 
   ~TFileFileSystem() override;
 
@@ -172,6 +172,7 @@ class TFileFileSystem : public VirtualRootFileSystemBase
  private:
   TDirectoryFile* mFile;
   RootObjectReadingFactory& mObjectFactory;
+  bool mOwnsFile = true;
 };
 
 class TBufferFileFS : public VirtualRootFileSystemBase
diff --git a/Framework/Core/src/RootArrowFilesystem.cxx b/Framework/Core/src/RootArrowFilesystem.cxx
index 403e393ec6090..6976c710062e6 100644
--- a/Framework/Core/src/RootArrowFilesystem.cxx
+++ b/Framework/Core/src/RootArrowFilesystem.cxx
@@ -34,18 +34,21 @@ namespace o2::framework
 {
 using arrow::Status;
 
-TFileFileSystem::TFileFileSystem(TDirectoryFile* f, size_t readahead, RootObjectReadingFactory& factory)
+TFileFileSystem::TFileFileSystem(TDirectoryFile* f, size_t readahead, RootObjectReadingFactory& factory, bool ownsFile)
   : VirtualRootFileSystemBase(),
     mFile(f),
-    mObjectFactory(factory)
+    mObjectFactory(factory),
+    mOwnsFile(ownsFile)
 {
   ((TFile*)mFile)->SetReadaheadSize(50 * 1024 * 1024);
 }
 
 TFileFileSystem::~TFileFileSystem()
 {
-  mFile->Close();
-  delete mFile;
+  if (mOwnsFile) {
+    mFile->Close();
+    delete mFile;
+  }
 }
 
 std::shared_ptr<RootObjectHandler> TFileFileSystem::GetObjectHandler(arrow::dataset::FileSource source)

From f03975009cbea2a6d30736cf8c25f15711ea1e83 Mon Sep 17 00:00:00 2001
From: Pavel Larionov <pavel.larionov@cern.ch>
Date: Wed, 18 Mar 2026 06:35:38 +0100
Subject: [PATCH 1437/1764] Fix overlap IRIS vacuum (#15185)

---
 .../Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
index 48cd0f37d2eb5..2f1a83f73bca3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
@@ -608,8 +608,8 @@ static void addIRISServiceModulesSegmented(TGeoVolume* petalAsm, int nPetals)
 
   // --- Vacuum vessel window around z∈[-L/2, +L/2] with wall thickness on +Z side
   //     Keep these in sync with TRKServices::createVacuumCompositeShape()
-  constexpr double vacuumVesselLength = kPetalZ_cm;       // cm
-  constexpr double vacuumVesselThickness = kWallThick_cm; // cm (0.2 mm)
+  constexpr double vacuumVesselLength = 76.0;             // cm
+  constexpr double vacuumVesselThickness = 0.08;          // cm (0.8 mm)
   const double halfVess = 0.5 * vacuumVesselLength;       // 38.0 cm
   const double gapStart = halfVess;                       // 38.00
   const double gapEnd = halfVess + vacuumVesselThickness; // 38.08

From 38ccad5c51bb417ccd978e454f5256396f7c420e Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Wed, 18 Mar 2026 06:39:12 +0100
Subject: [PATCH 1438/1764] [ALICE3] TRK: add noise to the digitization process
 (#15167)

* ALICE3-TRK: add noise to the digitization process

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../TRKSimulation/ChipDigitsContainer.h       |  4 ++
 .../include/TRKSimulation/DPLDigitizerParam.h |  2 +-
 .../include/TRKSimulation/DigiParams.h        |  2 +-
 .../simulation/src/ChipDigitsContainer.cxx    | 47 +++++++++++++++++++
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   |  2 +-
 5 files changed, 54 insertions(+), 3 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
index 73c95b04c45e3..bf28ace0724bc 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/ChipDigitsContainer.h
@@ -35,6 +35,10 @@ class ChipDigitsContainer : public o2::itsmft::ChipDigitsContainer
     return (static_cast<ULong64_t>(roframe) << (8 * sizeof(UInt_t))) + (static_cast<ULong64_t>(col) << (8 * sizeof(Short_t))) + row;
   }
 
+  /// Adds noise digits, deleted the one using the itsmft::DigiParams interface
+  void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::itsmft::DigiParams* params, int maxRows = o2::itsmft::SegmentationAlpide::NRows, int maxCols = o2::itsmft::SegmentationAlpide::NCols) = delete;
+  void addNoise(UInt_t rofMin, UInt_t rofMax, const o2::trk::DigiParams* params, int subDetID, int layer);
+
   ClassDefNV(ChipDigitsContainer, 1);
 };
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
index 15ed63e46e21f..168ae172f4b86 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
@@ -54,7 +54,7 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
  private:
   static constexpr float DEFNoisePerPixel()
   {
-    return N == o2::detectors::DetID::TRK ? 1e-8 : 1e-8; // ITS/MFT values here!!
+    return N == o2::detectors::DetID::TRK ? 1e-7 : 1e-8; // ITS/MFT values here!!
   }
 
   static constexpr std::string_view ParamName[2] = {"TRKDigitizerParam", "FT3DigitizerParam"};
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
index 23824eaefa13d..d24af1bfe13f1 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
@@ -103,7 +103,7 @@ class DigiParams
  private:
   static constexpr double infTime = 1e99;
   bool mIsContinuous = false;            ///< flag for continuous simulation
-  float mNoisePerPixel = 1.e-8;          ///< ALPIDE Noise per chip
+  float mNoisePerPixel = 1.e-7;          ///< Noise per chip
   int mROFrameLengthInBC = 0;            ///< ROF length in BC for continuos mode
   float mROFrameLength = 0;              ///< length of RO frame in ns
   float mStrobeDelay = 0.;               ///< strobe start (in ns) wrt ROF start
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipDigitsContainer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipDigitsContainer.cxx
index 9ed4a4bedf5c5..d8e6df8b6099c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipDigitsContainer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/ChipDigitsContainer.cxx
@@ -15,3 +15,50 @@ using namespace o2::trk;
 
 ChipDigitsContainer::ChipDigitsContainer(UShort_t idx)
   : o2::itsmft::ChipDigitsContainer(idx) {}
+
+//______________________________________________________________________
+void ChipDigitsContainer::addNoise(UInt_t rofMin, UInt_t rofMax, const o2::trk::DigiParams* params, int subDetID, int layer)
+{
+  UInt_t row = 0;
+  UInt_t col = 0;
+  Int_t nhits = 0;
+  constexpr float ns2sec = 1e-9;
+  float mean = 0.f;
+  int nel = 0;
+  int maxRows = 0;
+  int maxCols = 0;
+
+  // TODO: set different noise and threshold for VD and MLOT
+  if (subDetID == 0) {                                   // VD
+    maxRows = constants::VD::petal::layer::nRows[layer]; // TODO: get the layer from the geometry
+    maxCols = constants::VD::petal::layer::nCols;
+    mean = params->getNoisePerPixel() * maxRows * maxCols;
+    nel = static_cast<int>(params->getChargeThreshold() * 1.1);
+  } else { // ML/OT
+    maxRows = constants::moduleMLOT::chip::nRows;
+    maxCols = constants::moduleMLOT::chip::nCols;
+    mean = params->getNoisePerPixel() * maxRows * maxCols;
+    nel = static_cast<int>(params->getChargeThreshold() * 1.1);
+  }
+
+  LOG(debug) << "Adding noise for chip " << mChipIndex << " with mean " << mean << " and charge " << nel;
+
+  for (UInt_t rof = rofMin; rof <= rofMax; rof++) {
+    nhits = gRandom->Poisson(mean);
+    for (Int_t i = 0; i < nhits; ++i) {
+      row = gRandom->Integer(maxRows);
+      col = gRandom->Integer(maxCols);
+      LOG(debug) << "Generated noise hit at ROF " << rof << ", row " << row << ", col " << col;
+      if (mNoiseMap && mNoiseMap->isNoisy(mChipIndex, row, col)) {
+        continue;
+      }
+      if (mDeadChanMap && mDeadChanMap->isNoisy(mChipIndex, row, col)) {
+        continue;
+      }
+      auto key = getOrderingKey(rof, row, col);
+      if (!findDigit(key)) {
+        addDigit(key, rof, row, col, nel, o2::MCCompLabel(true));
+      }
+    }
+  }
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 52eaccfe045f7..31ef19a21cce9 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -215,7 +215,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
       if (chip.isDisabled()) {
         continue;
       }
-      // chip.addNoise(mROFrameMin, mROFrameMin, &mParams);  /// TODO: add noise
+      chip.addNoise(mROFrameMin, mROFrameMin, &mParams, mGeometry->getSubDetID(chip.getChipIndex()), mGeometry->getLayer(chip.getChipIndex())); /// TODO: add noise
       auto& buffer = chip.getPreDigits();
       if (buffer.empty()) {
         continue;

From 084a2371c92a8988f37eb45ab3fc1865bca3960b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 18 Mar 2026 09:05:45 +0100
Subject: [PATCH 1439/1764] [ALICE3] TRK: allow ACTS clustering (#15174)

* [ALICE3] TRK: allow ACTS clustering

* Add ACTS clusterer
---
 .../ALICE3/TRK/reconstruction/CMakeLists.txt  |  22 +-
 .../include/TRKReconstruction/Clusterer.h     |  22 +-
 .../include/TRKReconstruction/ClustererACTS.h |  43 ++
 .../TRK/reconstruction/src/ClustererACTS.cxx  | 392 ++++++++++++++++++
 .../src/TRKReconstructionLinkDef.h            |   4 +
 .../include/TRKWorkflow/ClustererSpec.h       |   9 +
 .../ALICE3/TRK/workflow/src/ClustererSpec.cxx |  45 +-
 7 files changed, 514 insertions(+), 23 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
index b9866c7d6aa4d..59a7f47955938 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
@@ -9,10 +9,16 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
+if(Acts_FOUND)
+  set(actsTarget Acts::Core)
+endif()
+
 o2_add_library(TRKReconstruction
                TARGETVARNAME targetName
                SOURCES src/TimeFrame.cxx
                        src/Clusterer.cxx
+                       $<$<BOOL:${Acts_FOUND}>:src/ClustererACTS.cxx>
+                       $<$<BOOL:${Acts_FOUND}>:src/TrackerACTS.cxx>
                PUBLIC_LINK_LIBRARIES
                        O2::ITStracking
                        O2::GPUCommon
@@ -27,11 +33,23 @@ o2_add_library(TRKReconstruction
                        O2::DataFormatsITS
                        O2::TRKSimulation
                        nlohmann_json::nlohmann_json
+                       ${actsTarget}
                PRIVATE_LINK_LIBRARIES
                        O2::Steer
                        TBB::tbb)
 
+if(Acts_FOUND)
+  target_compile_definitions(${targetName} PUBLIC O2_WITH_ACTS)
+endif()
+
+set(dictHeaders include/TRKReconstruction/TimeFrame.h
+                include/TRKReconstruction/Clusterer.h)
+
+if(Acts_FOUND)
+  list(APPEND dictHeaders include/TRKReconstruction/ClustererACTS.h
+                          include/TRKReconstruction/TrackerACTS.h)
+endif()
+
 o2_target_root_dictionary(TRKReconstruction
-                          HEADERS include/TRKReconstruction/TimeFrame.h
-                                  include/TRKReconstruction/Clusterer.h
+                          HEADERS ${dictHeaders}
                           LINKDEF src/TRKReconstructionLinkDef.h)
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
index abddafa312fb9..70518b2ace593 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
@@ -161,17 +161,17 @@ class Clusterer
   };
   //----------------------------------------------
 
-  void process(gsl::span<const Digit> digits,
-               gsl::span<const DigROFRecord> digitROFs,
-               std::vector<o2::trk::Cluster>& clusters,
-               std::vector<unsigned char>& patterns,
-               std::vector<o2::trk::ROFRecord>& clusterROFs,
-               const ConstDigitTruth* digitLabels = nullptr,
-               ClusterTruth* clusterLabels = nullptr,
-               gsl::span<const DigMC2ROFRecord> digMC2ROFs = {},
-               std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs = nullptr);
-
- private:
+  virtual void process(gsl::span<const Digit> digits,
+                       gsl::span<const DigROFRecord> digitROFs,
+                       std::vector<o2::trk::Cluster>& clusters,
+                       std::vector<unsigned char>& patterns,
+                       std::vector<o2::trk::ROFRecord>& clusterROFs,
+                       const ConstDigitTruth* digitLabels = nullptr,
+                       ClusterTruth* clusterLabels = nullptr,
+                       gsl::span<const DigMC2ROFRecord> digMC2ROFs = {},
+                       std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs = nullptr);
+
+ protected:
   int mNHugeClus = 0;
   std::unique_ptr<ClustererThread> mThread;
   std::vector<int> mSortIdx; ///< reusable per-ROF sort buffer
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
new file mode 100644
index 0000000000000..4111737d17a9f
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
@@ -0,0 +1,43 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ClustererACTS.h
+/// \brief Definition of the TRK cluster finder
+
+#ifndef ALICEO2_TRK_CLUSTERERACTS_H
+#define ALICEO2_TRK_CLUSTERERACTS_H
+
+#include "TRKReconstruction/Clusterer.h"
+
+namespace o2::trk
+{
+
+class GeometryTGeo;
+
+class ClustererACTS : public Clusterer
+{
+ public:
+  void process(gsl::span<const Digit> digits,
+               gsl::span<const DigROFRecord> digitROFs,
+               std::vector<o2::trk::Cluster>& clusters,
+               std::vector<unsigned char>& patterns,
+               std::vector<o2::trk::ROFRecord>& clusterROFs,
+               const ConstDigitTruth* digitLabels = nullptr,
+               ClusterTruth* clusterLabels = nullptr,
+               gsl::span<const DigMC2ROFRecord> digMC2ROFs = {},
+               std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs = nullptr) override;
+
+ private:
+};
+
+} // namespace o2::trk
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
new file mode 100644
index 0000000000000..0cf7c26e0ea41
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
@@ -0,0 +1,392 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file ClustererACTS.cxx
+/// \brief Implementation of the TRK cluster finder with the ACTS
+
+#include "TRKReconstruction/ClustererACTS.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "DataFormatsITSMFT/ClusterPattern.h"
+#include <Acts/Clusterization/Clusterization.hpp>
+
+#include <algorithm>
+#include <array>
+#include <numeric>
+
+using namespace o2::trk;
+
+// Data formats for ACTS interface
+struct Cell2D {
+  Cell2D(int rowv, int colv, uint32_t digIdx = 0) : row(rowv), col(colv), digitIdx(digIdx) {}
+  int row, col;
+  uint32_t digitIdx; ///< Index of the original digit (for MC label retrieval)
+  Acts::Ccl::Label label{Acts::Ccl::NO_LABEL};
+};
+
+int getCellRow(const Cell2D& cell)
+{
+  return cell.row;
+}
+
+int getCellColumn(const Cell2D& cell)
+{
+  return cell.col;
+}
+
+bool operator==(const Cell2D& left, const Cell2D& right)
+{
+  return left.row == right.row && left.col == right.col;
+}
+
+bool cellComp(const Cell2D& left, const Cell2D& right)
+{
+  return (left.row == right.row) ? left.col < right.col : left.row < right.row;
+}
+
+struct Cluster2D {
+  std::vector<Cell2D> cells;
+  std::size_t hash{0};
+};
+
+void clusterAddCell(Cluster2D& cl, const Cell2D& cell)
+{
+  cl.cells.push_back(cell);
+}
+
+void hash(Cluster2D& cl)
+{
+  std::ranges::sort(cl.cells, cellComp);
+  cl.hash = 0;
+  // for (const Cell2D& c : cl.cells) {
+  //   boost::hash_combine(cl.hash, c.col);
+  // }
+}
+
+bool clHashComp(const Cluster2D& left, const Cluster2D& right)
+{
+  return left.hash < right.hash;
+}
+
+template <typename RNG>
+void genclusterw(int x, int y, int x0, int y0, int x1, int y1,
+                 std::vector<Cell2D>& cells, RNG& rng, double startp = 0.5,
+                 double decayp = 0.9)
+{
+  std::vector<Cell2D> add;
+
+  auto maybe_add = [&](int x_, int y_) {
+    Cell2D c(x_, y_);
+    // if (std::uniform_real_distribution<double>()(rng) < startp &&
+    //     !rangeContainsValue(cells, c)) {
+    //   cells.push_back(c);
+    //   add.push_back(c);
+    // }
+  };
+
+  // NORTH
+  if (y < y1) {
+    maybe_add(x, y + 1);
+  }
+  // NORTHEAST
+  if (x < x1 && y < y1) {
+    maybe_add(x + 1, y + 1);
+  }
+  // EAST
+  if (x < x1) {
+    maybe_add(x + 1, y);
+  }
+  // SOUTHEAST
+  if (x < x1 && y > y0) {
+    maybe_add(x + 1, y - 1);
+  }
+  // SOUTH
+  if (y > y0) {
+    maybe_add(x, y - 1);
+  }
+  // SOUTHWEST
+  if (x > x0 && y > y0) {
+    maybe_add(x - 1, y - 1);
+  }
+  // WEST
+  if (x > x0) {
+    maybe_add(x - 1, y);
+  }
+  // NORTHWEST
+  if (x > x0 && y < y1) {
+    maybe_add(x - 1, y + 1);
+  }
+
+  for (Cell2D& c : add) {
+    genclusterw(c.row, c.col, x0, y0, x1, y1, cells, rng, startp * decayp,
+                decayp);
+  }
+}
+
+template <typename RNG>
+Cluster2D gencluster(int x0, int y0, int x1, int y1, RNG& rng,
+                     double startp = 0.5, double decayp = 0.9)
+{
+  int x0_ = x0 + 1;
+  int x1_ = x1 - 1;
+  int y0_ = y0 + 1;
+  int y1_ = y1 - 1;
+
+  int x = std::uniform_int_distribution<std::int32_t>(x0_, x1_)(rng);
+  int y = std::uniform_int_distribution<std::int32_t>(y0_, y1_)(rng);
+
+  std::vector<Cell2D> cells = {Cell2D(x, y)};
+  genclusterw(x, y, x0_, y0_, x1_, y1_, cells, rng, startp, decayp);
+
+  Cluster2D cl;
+  cl.cells = std::move(cells);
+
+  return cl;
+}
+
+//__________________________________________________
+void ClustererACTS::process(gsl::span<const Digit> digits,
+                            gsl::span<const DigROFRecord> digitROFs,
+                            std::vector<o2::trk::Cluster>& clusters,
+                            std::vector<unsigned char>& patterns,
+                            std::vector<o2::trk::ROFRecord>& clusterROFs,
+                            const ConstDigitTruth* digitLabels,
+                            ClusterTruth* clusterLabels,
+                            gsl::span<const DigMC2ROFRecord> digMC2ROFs,
+                            std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs)
+{
+  if (!mThread) {
+    mThread = std::make_unique<ClustererThread>(this);
+  }
+
+  auto* geom = o2::trk::GeometryTGeo::Instance();
+
+  for (size_t iROF = 0; iROF < digitROFs.size(); ++iROF) {
+    const auto& inROF = digitROFs[iROF];
+    const auto outFirst = static_cast<int>(clusters.size());
+    const int first = inROF.getFirstEntry();
+    const int nEntries = inROF.getNEntries();
+
+    if (nEntries == 0) {
+      clusterROFs.emplace_back(inROF.getBCData(), inROF.getROFrame(), outFirst, 0);
+      continue;
+    }
+
+    // Sort digit indices within this ROF by (chipID, col, row) so we can process
+    // chip by chip, column by column -- the same ordering the ALPIDE scanner expects.
+    mSortIdx.resize(nEntries);
+    std::iota(mSortIdx.begin(), mSortIdx.end(), first);
+    std::sort(mSortIdx.begin(), mSortIdx.end(), [&digits](int a, int b) {
+      const auto& da = digits[a];
+      const auto& db = digits[b];
+      if (da.getChipIndex() != db.getChipIndex()) {
+        return da.getChipIndex() < db.getChipIndex();
+      }
+      if (da.getColumn() != db.getColumn()) {
+        return da.getColumn() < db.getColumn();
+      }
+      return da.getRow() < db.getRow();
+    });
+
+    // Type aliases for ACTS clustering
+    using Cell = Cell2D;
+    using CellCollection = std::vector<Cell>;
+    using Cluster = Cluster2D;
+    using ClusterCollection = std::vector<Cluster>;
+    static constexpr int GridDim = 2; ///< Dimensionality of the clustering grid (2D for pixel detectors)
+
+    CellCollection cells;            // Input collection of cells (pixels) to be clustered
+    Acts::Ccl::ClusteringData data;  // Internal data structure used by ACTS clustering algorithm
+    ClusterCollection clsCollection; // Output collection of clusters found by the algorithm
+
+    // Process one chip at a time
+    int sliceStart = 0;
+    while (sliceStart < nEntries) {
+      const int chipFirst = sliceStart;
+      const uint16_t chipID = digits[mSortIdx[sliceStart]].getChipIndex();
+      while (sliceStart < nEntries && digits[mSortIdx[sliceStart]].getChipIndex() == chipID) {
+        ++sliceStart;
+      }
+      const int chipN = sliceStart - chipFirst;
+
+      // Fill cells from digits for this chip
+      cells.clear();
+      data.clear();
+      clsCollection.clear();
+      cells.reserve(chipN);
+      for (int i = chipFirst; i < chipFirst + chipN; ++i) {
+        const auto& digit = digits[mSortIdx[i]];
+        cells.emplace_back(digit.getRow(), digit.getColumn(), mSortIdx[i]);
+      }
+
+      LOG(debug) << "Clustering with ACTS on chip " << chipID << " " << cells.size() << " digits";
+      Acts::Ccl::createClusters<CellCollection, ClusterCollection, GridDim>(data,
+                                                                            cells,
+                                                                            clsCollection,
+                                                                            Acts::Ccl::DefaultConnect<Cell, GridDim>(false));
+
+      LOG(debug) << "    found " << clsCollection.size() << " clusters";
+
+      // Convert ACTS clusters to O2 clusters
+      for (const auto& actsCluster : clsCollection) {
+        if (actsCluster.cells.empty()) {
+          continue;
+        }
+
+        // Calculate bounding box
+        uint16_t rowMin = static_cast<uint16_t>(actsCluster.cells[0].row);
+        uint16_t rowMax = rowMin;
+        uint16_t colMin = static_cast<uint16_t>(actsCluster.cells[0].col);
+        uint16_t colMax = colMin;
+
+        for (const auto& cell : actsCluster.cells) {
+          rowMin = std::min(rowMin, static_cast<uint16_t>(cell.row));
+          rowMax = std::max(rowMax, static_cast<uint16_t>(cell.row));
+          colMin = std::min(colMin, static_cast<uint16_t>(cell.col));
+          colMax = std::max(colMax, static_cast<uint16_t>(cell.col));
+        }
+
+        const uint16_t rowSpan = rowMax - rowMin + 1;
+        const uint16_t colSpan = colMax - colMin + 1;
+
+        // Check if cluster needs splitting (too large for pattern encoding)
+        const bool isHuge = rowSpan > o2::itsmft::ClusterPattern::MaxRowSpan ||
+                            colSpan > o2::itsmft::ClusterPattern::MaxColSpan;
+
+        if (isHuge) {
+          // Split huge cluster into MaxRowSpan x MaxColSpan tiles
+          LOG(warning) << "Splitting huge TRK cluster: chipID " << chipID
+                       << ", rows " << rowMin << ":" << rowMax
+                       << " cols " << colMin << ":" << colMax;
+
+          for (uint16_t tileColMin = colMin; tileColMin <= colMax;
+               tileColMin = static_cast<uint16_t>(tileColMin + o2::itsmft::ClusterPattern::MaxColSpan)) {
+            uint16_t tileColMax = std::min(colMax, static_cast<uint16_t>(tileColMin + o2::itsmft::ClusterPattern::MaxColSpan - 1));
+
+            for (uint16_t tileRowMin = rowMin; tileRowMin <= rowMax;
+                 tileRowMin = static_cast<uint16_t>(tileRowMin + o2::itsmft::ClusterPattern::MaxRowSpan)) {
+              uint16_t tileRowMax = std::min(rowMax, static_cast<uint16_t>(tileRowMin + o2::itsmft::ClusterPattern::MaxRowSpan - 1));
+
+              // Collect cells in this tile
+              std::vector<std::pair<uint16_t, uint16_t>> tileCells;
+              for (const auto& cell : actsCluster.cells) {
+                uint16_t r = static_cast<uint16_t>(cell.row);
+                uint16_t c = static_cast<uint16_t>(cell.col);
+                if (r >= tileRowMin && r <= tileRowMax && c >= tileColMin && c <= tileColMax) {
+                  tileCells.emplace_back(r, c);
+                }
+              }
+
+              if (tileCells.empty()) {
+                continue;
+              }
+
+              uint16_t tileRowSpan = tileRowMax - tileRowMin + 1;
+              uint16_t tileColSpan = tileColMax - tileColMin + 1;
+
+              // Encode pattern for this tile
+              std::array<unsigned char, o2::itsmft::ClusterPattern::MaxPatternBytes> patt{};
+              for (const auto& [r, c] : tileCells) {
+                uint32_t ir = r - tileRowMin;
+                uint32_t ic = c - tileColMin;
+                int nbit = ir * tileColSpan + ic;
+                patt[nbit >> 3] |= (0x1 << (7 - (nbit % 8)));
+              }
+              patterns.emplace_back(static_cast<unsigned char>(tileRowSpan));
+              patterns.emplace_back(static_cast<unsigned char>(tileColSpan));
+              const int nBytes = (tileRowSpan * tileColSpan + 7) / 8;
+              patterns.insert(patterns.end(), patt.begin(), patt.begin() + nBytes);
+
+              // Handle MC labels for this tile
+              if (clusterLabels && digitLabels) {
+                const auto clsIdx = static_cast<uint32_t>(clusters.size());
+                for (const auto& cell : actsCluster.cells) {
+                  uint16_t r = static_cast<uint16_t>(cell.row);
+                  uint16_t c = static_cast<uint16_t>(cell.col);
+                  if (r >= tileRowMin && r <= tileRowMax && c >= tileColMin && c <= tileColMax) {
+                    if (cell.digitIdx < digitLabels->getIndexedSize()) {
+                      const auto& lbls = digitLabels->getLabels(cell.digitIdx);
+                      for (const auto& lbl : lbls) {
+                        clusterLabels->addElement(clsIdx, lbl);
+                      }
+                    }
+                  }
+                }
+              }
+
+              // Create O2 cluster for this tile
+              o2::trk::Cluster cluster;
+              cluster.chipID = chipID;
+              cluster.row = tileRowMin;
+              cluster.col = tileColMin;
+              cluster.size = static_cast<uint16_t>(tileCells.size());
+              if (geom) {
+                cluster.subDetID = static_cast<int16_t>(geom->getSubDetID(chipID));
+                cluster.layer = static_cast<int16_t>(geom->getLayer(chipID));
+                cluster.disk = static_cast<int16_t>(geom->getDisk(chipID));
+              }
+              clusters.emplace_back(cluster);
+            }
+          }
+        } else {
+          // Normal cluster - encode directly
+          std::array<unsigned char, o2::itsmft::ClusterPattern::MaxPatternBytes> patt{};
+          for (const auto& cell : actsCluster.cells) {
+            uint32_t ir = static_cast<uint32_t>(cell.row - rowMin);
+            uint32_t ic = static_cast<uint32_t>(cell.col - colMin);
+            int nbit = ir * colSpan + ic;
+            patt[nbit >> 3] |= (0x1 << (7 - (nbit % 8)));
+          }
+          patterns.emplace_back(static_cast<unsigned char>(rowSpan));
+          patterns.emplace_back(static_cast<unsigned char>(colSpan));
+          const int nBytes = (rowSpan * colSpan + 7) / 8;
+          patterns.insert(patterns.end(), patt.begin(), patt.begin() + nBytes);
+
+          // Handle MC labels
+          if (clusterLabels && digitLabels) {
+            const auto clsIdx = static_cast<uint32_t>(clusters.size());
+            for (const auto& cell : actsCluster.cells) {
+              if (cell.digitIdx < digitLabels->getIndexedSize()) {
+                const auto& lbls = digitLabels->getLabels(cell.digitIdx);
+                for (const auto& lbl : lbls) {
+                  clusterLabels->addElement(clsIdx, lbl);
+                }
+              }
+            }
+          }
+
+          // Create O2 cluster
+          o2::trk::Cluster cluster;
+          cluster.chipID = chipID;
+          cluster.row = rowMin;
+          cluster.col = colMin;
+          cluster.size = static_cast<uint16_t>(actsCluster.cells.size());
+          if (geom) {
+            cluster.subDetID = static_cast<int16_t>(geom->getSubDetID(chipID));
+            cluster.layer = static_cast<int16_t>(geom->getLayer(chipID));
+            cluster.disk = static_cast<int16_t>(geom->getDisk(chipID));
+          }
+          clusters.emplace_back(cluster);
+        }
+      }
+
+      LOG(debug) << "    clusterization of chip " << chipID << " completed!";
+    }
+    clusterROFs.emplace_back(inROF.getBCData(), inROF.getROFrame(),
+                             outFirst, static_cast<int>(clusters.size()) - outFirst);
+  }
+
+  if (clusterMC2ROFs && !digMC2ROFs.empty()) {
+    clusterMC2ROFs->reserve(clusterMC2ROFs->size() + digMC2ROFs.size());
+    for (const auto& in : digMC2ROFs) {
+      clusterMC2ROFs->emplace_back(in.eventRecordID, in.rofRecordID, in.minROF, in.maxROF);
+    }
+  }
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
index 4eda22e350852..1f4c2193b91b1 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
@@ -17,5 +17,9 @@
 
 #pragma link C++ class o2::trk::TimeFrame < 11> + ;
 #pragma link C++ class o2::trk::Clusterer + ;
+#ifdef O2_WITH_ACTS
+#pragma link C++ class o2::trk::ClustererACTS + ;
+
+#endif
 
 #endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
index bacc1057c7b07..9cfab104ecdf9 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
@@ -15,6 +15,9 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "TRKReconstruction/Clusterer.h"
+#ifdef O2_WITH_ACTS
+#include "TRKReconstruction/ClustererACTS.h"
+#endif
 
 namespace o2::trk
 {
@@ -29,7 +32,13 @@ class ClustererDPL : public o2::framework::Task
  private:
   bool mUseMC = true;
   int mNThreads = 1;
+#ifdef O2_WITH_ACTS
+  bool mUseACTS = false;
+#endif
   o2::trk::Clusterer mClusterer;
+#ifdef O2_WITH_ACTS
+  o2::trk::ClustererACTS mClustererACTS;
+#endif
 };
 
 o2::framework::DataProcessorSpec getClustererSpec(bool useMC);
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx
index 8aec63d69206b..5d9ac463b3f54 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx
@@ -23,6 +23,9 @@ namespace o2::trk
 void ClustererDPL::init(o2::framework::InitContext& ic)
 {
   mNThreads = std::max(1, ic.options().get<int>("nthreads"));
+#ifdef O2_WITH_ACTS
+  mUseACTS = ic.options().get<bool>("useACTS");
+#endif
 }
 
 void ClustererDPL::run(o2::framework::ProcessingContext& pc)
@@ -48,15 +51,32 @@ void ClustererDPL::run(o2::framework::ProcessingContext& pc)
   }
   o2::base::GeometryManager::loadGeometry("o2sim_geometry.root", false, true);
 
-  mClusterer.process(digits,
-                     rofs,
-                     clusters,
-                     patterns,
-                     clusterROFs,
-                     mUseMC ? &labels : nullptr,
-                     clusterLabels.get(),
-                     mc2rofs,
-                     mUseMC ? &clusterMC2ROFs : nullptr);
+#ifdef O2_WITH_ACTS
+  if (mUseACTS) {
+    LOG(info) << "Running TRKClusterer with ACTS";
+    mClustererACTS.process(digits,
+                           rofs,
+                           clusters,
+                           patterns,
+                           clusterROFs,
+                           mUseMC ? &labels : nullptr,
+                           clusterLabels.get(),
+                           mc2rofs,
+                           mUseMC ? &clusterMC2ROFs : nullptr);
+  } else
+#endif
+  {
+    LOG(info) << "Running TRKClusterer";
+    mClusterer.process(digits,
+                       rofs,
+                       clusters,
+                       patterns,
+                       clusterROFs,
+                       mUseMC ? &labels : nullptr,
+                       clusterLabels.get(),
+                       mc2rofs,
+                       mUseMC ? &clusterMC2ROFs : nullptr);
+  }
 
   pc.outputs().snapshot(o2::framework::Output{"TRK", "COMPCLUSTERS", 0}, clusters);
   pc.outputs().snapshot(o2::framework::Output{"TRK", "PATTERNS", 0}, patterns);
@@ -93,7 +113,12 @@ o2::framework::DataProcessorSpec getClustererSpec(bool useMC)
     inputs,
     outputs,
     o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<o2::trk::ClustererDPL>(useMC)},
-    o2::framework::Options{{"nthreads", o2::framework::VariantType::Int, 1, {"Number of clustering threads"}}}};
+    o2::framework::Options{{"nthreads", o2::framework::VariantType::Int, 1, {"Number of clustering threads"}}
+#ifdef O2_WITH_ACTS
+                           ,
+                           {"useACTS", o2::framework::VariantType::Bool, false, {"Use ACTS for clustering"}}
+#endif
+    }};
 }
 
 } // namespace o2::trk

From 8e4cfe1c0a4cb84214defa378de41dfae1c7d411 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 18 Mar 2026 09:07:51 +0100
Subject: [PATCH 1440/1764] [ALICE3] Refactor TRK Hit class to rely on ITSMFT
 (#15173)

* [ALICE3] Refactor TRK Hit class to rely on ITSMFT

* Refactor Hit class by removing unused code

Removed unnecessary includes and simplified the Print method.

* Remove Hit class declaration from TimeFrame.h

Removed the declaration of the Hit class from TimeFrame.h.
---
 .../include/TRKReconstruction/TimeFrame.h     |   1 -
 .../simulation/include/TRKSimulation/Hit.h    | 136 +-----------------
 .../ALICE3/TRK/simulation/src/Hit.cxx         |  19 ---
 3 files changed, 6 insertions(+), 150 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
index f42a1c897efb6..c07767d50b113 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
@@ -33,7 +33,6 @@ namespace o2
 {
 namespace trk
 {
-class Hit;
 class GeometryTGeo;
 
 /// TRK TimeFrame class that extends ITS TimeFrame functionality
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
index a178c30069f14..88afac8682cf4 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
@@ -12,138 +12,14 @@
 /// \file Hit.h
 /// \brief Definition of the TRK Hit class
 
-#ifndef ALICEO2_TRK_POINT_H_
-#define ALICEO2_TRK_POINT_H_
+#ifndef ALICEO2_TRK_HIT_H_
+#define ALICEO2_TRK_HIT_H_
 
-#include "SimulationDataFormat/BaseHits.h" // for BasicXYZEHit
-#include "Rtypes.h"                        // for Bool_t, Double_t, Int_t, Double32_t, etc
-#include "TVector3.h"                      // for TVector3
-#include <iosfwd>
-#include "CommonUtils/ShmAllocator.h"
+#include "ITSMFTSimulation/Hit.h"
 
-namespace o2
+namespace o2::trk
 {
-namespace trk
-{
-
-class Hit : public o2::BasicXYZEHit<Float_t, Float_t>
-{
-
- public:
-  enum HitStatus_t {
-    kTrackEntering = 0x1,
-    kTrackInside = 0x1 << 1,
-    kTrackExiting = 0x1 << 2,
-    kTrackOut = 0x1 << 3,
-    kTrackStopped = 0x1 << 4,
-    kTrackAlive = 0x1 << 5
-  };
-
-  /// Default constructor
-  Hit() = default;
-
-  /// Class Constructor
-  /// \param trackID Index of MCTrack
-  /// \param detID Detector ID
-  /// \param startPos Coordinates at entrance to active volume [cm]
-  /// \param pos Coordinates to active volume [cm]
-  /// \param mom Momentum of track at entrance [GeV]
-  /// \param endTime Time at entrance [ns]
-  /// \param time Time since event start [ns]
-  /// \param eLoss Energy deposit [GeV]
-  /// \param startStatus: status at entrance
-  /// \param endStatus: status at exit
-  inline Hit(int trackID, unsigned short detID, const TVector3& startPos, const TVector3& pos, const TVector3& mom, double startE,
-             double endTime, double eLoss, unsigned char statusStart, unsigned char status);
-
-  // Entrance position getters
-  math_utils::Point3D<Float_t> GetPosStart() const { return mPosStart; }
-  Float_t GetStartX() const { return mPosStart.X(); }
-  Float_t GetStartY() const { return mPosStart.Y(); }
-  Float_t GetStartZ() const { return mPosStart.Z(); }
-  template <typename F>
-  void GetStartPosition(F& x, F& y, F& z) const
-  {
-    x = GetStartX();
-    y = GetStartY();
-    z = GetStartZ();
-  }
-  // momentum getters
-  math_utils::Vector3D<Float_t> GetMomentum() const { return mMomentum; }
-  math_utils::Vector3D<Float_t>& GetMomentum() { return mMomentum; }
-  Float_t GetPx() const { return mMomentum.X(); }
-  Float_t GetPy() const { return mMomentum.Y(); }
-  Float_t GetPz() const { return mMomentum.Z(); }
-  Float_t GetE() const { return mE; }
-  Float_t GetTotalEnergy() const { return GetE(); }
-
-  UChar_t GetStatusEnd() const { return mTrackStatusEnd; }
-  UChar_t GetStatusStart() const { return mTrackStatusStart; }
-
-  Bool_t IsEntering() const { return mTrackStatusEnd & kTrackEntering; }
-  Bool_t IsInside() const { return mTrackStatusEnd & kTrackInside; }
-  Bool_t IsExiting() const { return mTrackStatusEnd & kTrackExiting; }
-  Bool_t IsOut() const { return mTrackStatusEnd & kTrackOut; }
-  Bool_t IsStopped() const { return mTrackStatusEnd & kTrackStopped; }
-  Bool_t IsAlive() const { return mTrackStatusEnd & kTrackAlive; }
-
-  Bool_t IsEnteringStart() const { return mTrackStatusStart & kTrackEntering; }
-  Bool_t IsInsideStart() const { return mTrackStatusStart & kTrackInside; }
-  Bool_t IsExitingStart() const { return mTrackStatusStart & kTrackExiting; }
-  Bool_t IsOutStart() const { return mTrackStatusStart & kTrackOut; }
-  Bool_t IsStoppedStart() const { return mTrackStatusStart & kTrackStopped; }
-  Bool_t IsAliveStart() const { return mTrackStatusStart & kTrackAlive; }
-
-  // Entrance position setter
-  void SetPosStart(const math_utils::Point3D<Float_t>& p) { mPosStart = p; }
-
-  /// Output to screen
-  void Print(const Option_t* opt) const;
-  friend std::ostream& operator<<(std::ostream& of, const Hit& point)
-  {
-    of << "-I- Hit: O2its point for track " << point.GetTrackID() << " in detector " << point.GetDetectorID() << std::endl;
-    /*
-      of << "    Position (" << point.fX << ", " << point.fY << ", " << point.fZ << ") cm" << std::endl;
-      of << "    Momentum (" << point.fPx << ", " << point.fPy << ", " << point.fPz << ") GeV" << std::endl;
-      of << "    Time " << point.fTime << " ns,  Length " << point.fLength << " cm,  Energy loss "
-      << point.fELoss * 1.0e06 << " keV" << std::endl;
-      */
-    return of;
-  }
-
- private:
-  math_utils::Vector3D<Float_t> mMomentum; ///< momentum at entrance
-  math_utils::Point3D<Float_t> mPosStart;  ///< position at entrance (base mPos give position on exit)
-  Float_t mE;                              ///< total energy at entrance
-  UChar_t mTrackStatusEnd;                 ///< MC status flag at exit
-  UChar_t mTrackStatusStart;               ///< MC status at starting point
-
-  ClassDefNV(Hit, 1);
-};
-
-Hit::Hit(int trackID, unsigned short detID, const TVector3& startPos, const TVector3& endPos, const TVector3& startMom,
-         double startE, double endTime, double eLoss, unsigned char startStatus, unsigned char endStatus)
-  : BasicXYZEHit(endPos.X(), endPos.Y(), endPos.Z(), endTime, eLoss, trackID, detID),
-    mMomentum(startMom.Px(), startMom.Py(), startMom.Pz()),
-    mPosStart(startPos.X(), startPos.Y(), startPos.Z()),
-    mE(startE),
-    mTrackStatusEnd(endStatus),
-    mTrackStatusStart(startStatus)
-{
-}
-
-} // namespace trk
-} // namespace o2
-
-#ifdef USESHM
-namespace std
-{
-template <>
-class allocator<o2::trk::Hit> : public o2::utils::ShmAllocator<o2::trk::Hit>
-{
-};
-} // namespace std
-
-#endif
+using Hit = o2::itsmft::Hit; // For now we rely on the same Hit class as ITSMFT, but we can extend it with TRK-specific information if needed in the future
+} // namespace o2::trk
 
 #endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Hit.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Hit.cxx
index fe496bc59692f..1f49b84114b9d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Hit.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Hit.cxx
@@ -13,22 +13,3 @@
 /// \brief Implementation of the Hit class
 
 #include "TRKSimulation/Hit.h"
-
-#include <iostream>
-#include <iostream>
-
-ClassImp(o2::trk::Hit);
-
-using std::cout;
-using std::endl;
-using namespace o2::trk;
-using namespace o2; //::base;
-
-void Hit::Print(const Option_t* opt) const
-{
-  printf(
-    "Det: %5d Track: %6d E.loss: %.3e P: %+.3e %+.3e %+.3e\n"
-    "PosIn: %+.3e %+.3e %+.3e PosOut: %+.3e %+.3e %+.3e\n",
-    GetDetectorID(), GetTrackID(), GetEnergyLoss(), GetPx(), GetPy(), GetPz(),
-    GetStartX(), GetStartY(), GetStartZ(), GetX(), GetY(), GetZ());
-}

From ce92d025a59e7253392059ac604d007d99d2a828 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 18 Mar 2026 09:08:05 +0100
Subject: [PATCH 1441/1764] [ALICE3] TOF: Update stave tilt angles for iTOF and
 oTOF layers (#15172)

---
 .../Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx  | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index 0a83c19125b70..9b097a0243597 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -96,10 +96,10 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
   }
   if (itof) { // iTOF
     const std::string name = GeometryTGeo::getITOFLayerPattern();
-    const int nStaves = itofSegmented ? 24 : 0;              // number of staves in segmented case
-    const double staveWidth = itofSegmented ? 5.42 : 0.0;    // cm
-    const double staveTiltAngle = itofSegmented ? 3.0 : 0.0; // degrees
-    const int modulesPerStave = itofSegmented ? 10 : 0;      // number of modules per stave in segmented case
+    const int nStaves = itofSegmented ? 24 : 0;               // number of staves in segmented case
+    const double staveWidth = itofSegmented ? 5.42 : 0.0;     // cm
+    const double staveTiltAngle = itofSegmented ? 10.0 : 0.0; // degrees
+    const int modulesPerStave = itofSegmented ? 10 : 0;       // number of modules per stave in segmented case
     mITOFLayer = ITOFLayer(name,
                            dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, ITOFLayer::kBarrelSegmented,
                            nStaves, staveWidth, staveTiltAngle, modulesPerStave);
@@ -108,7 +108,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const std::string name = GeometryTGeo::getOTOFLayerPattern();
     const int nStaves = otofSegmented ? 62 : 0;              // number of staves in segmented case
     const double staveWidth = otofSegmented ? 9.74 : 0.0;    // cm
-    const double staveTiltAngle = otofSegmented ? 3.0 : 0.0; // degrees
+    const double staveTiltAngle = otofSegmented ? 5.0 : 0.0; // degrees
     const int modulesPerStave = otofSegmented ? 54 : 0;      // number of modules per stave in segmented case
     mOTOFLayer = OTOFLayer(name,
                            dOuterTof.first, 0.f, dOuterTof.second, 0.f, x2x0, OTOFLayer::kBarrelSegmented,

From 3b7244cf8ff2f0263e06144565452f8fd3ae6f27 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 17 Mar 2026 23:15:52 +0100
Subject: [PATCH 1442/1764] Fix warnings

---
 Framework/Core/include/Framework/Array2D.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/Framework/Core/include/Framework/Array2D.h b/Framework/Core/include/Framework/Array2D.h
index 593a50afd91f6..857e4b3c89f29 100644
--- a/Framework/Core/include/Framework/Array2D.h
+++ b/Framework/Core/include/Framework/Array2D.h
@@ -166,26 +166,26 @@ class LabeledArray : public LabelMap
   using element_t = T;
 
   LabeledArray()
-    : values{},
-      LabelMap{}
+    : LabelMap{},
+      values{}
   {
   }
 
   LabeledArray(T const* data, uint32_t rows_, uint32_t cols_, std::vector<std::string> labels_rows_ = {}, std::vector<std::string> labels_cols_ = {})
-    : values{data, rows_, cols_},
-      LabelMap{rows_, cols_, labels_rows_, labels_cols_}
+    : LabelMap{rows_, cols_, labels_rows_, labels_cols_},
+      values{data, rows_, cols_}
   {
   }
 
   LabeledArray(T const* data, uint32_t size, std::vector<std::string> labels_ = {})
-    : values{data, 1, size},
-      LabelMap{size, labels_}
+    : LabelMap{size, labels_},
+      values{data, 1, size}
   {
   }
 
   LabeledArray(Array2D<T> const& data, std::vector<std::string> labels_rows_ = {}, std::vector<std::string> labels_cols_ = {})
-    : values{data},
-      LabelMap{data.rows, data.cols, labels_rows_, labels_cols_}
+    : LabelMap{data.rows, data.cols, labels_rows_, labels_cols_},
+      values{data}
   {
   }
 

From bd173fab42693252ac9851a2a7610a87b957c205 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 17 Mar 2026 17:36:05 +0100
Subject: [PATCH 1443/1764] Use finer Z bins for mat LUT in 56.5 < R< 76 cm

---
 Detectors/Base/test/buildMatBudLUT.C | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/Detectors/Base/test/buildMatBudLUT.C b/Detectors/Base/test/buildMatBudLUT.C
index 85f8343a2d35d..14f6d078aee90 100644
--- a/Detectors/Base/test/buildMatBudLUT.C
+++ b/Detectors/Base/test/buildMatBudLUT.C
@@ -29,7 +29,7 @@ o2::base::MatLayerCylSet mbLUT;
 
 bool testMBLUT(const std::string& lutFile = "matbud.root");
 
-bool buildMatBudLUT(int nTst = 30, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomNamePrefix = "o2sim", const std::string& opts = "");
+bool buildMatBudLUT(int nTst = 60, int maxLr = -1, const std::string& outFile = "matbud.root", const std::string& geomName = "o2sim_geometry-aligned.root");
 
 struct LrData {
   float rMin = 0.f;
@@ -306,14 +306,17 @@ void configLayers()
   zBin = 10.;
   rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
   lrData.emplace_back(LrData(lrData.back().rMax, 56.5, zSpanH, zBin, rphiBin));
+
+  //------------------------------------
+  zBin = 1.;
   rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
   lrData.emplace_back(LrData(lrData.back().rMax, 60.5, zSpanH, zBin, rphiBin));
   rphiBin = lrData.back().rMax * TMath::Pi() * 2 / 18;
   lrData.emplace_back(LrData(lrData.back().rMax, 61.5, zSpanH, zBin, rphiBin));
 
   zSpanH = 150.f;
-  drStep = 3.5;
-  zBin = 15.;
+  drStep = 2;
+  zBin = 1.;
   do {
     auto rmean = lrData.back().rMax + drStep / 2;
     rphiBin = rmean * TMath::Pi() * 2 / (NSect * 2);
@@ -321,8 +324,8 @@ void configLayers()
   } while (lrData.back().rMax < 68.5 - kToler);
 
   zSpanH = 250.f;
-  zBin = 25.;
-  rphiBin = 5;
+  zBin = 1.;
+  rphiBin = 2.5;
   {
     auto rmean = (lrData.back().rMax + 76) / 2.;
     rphiBin = rmean * TMath::Pi() * 2 / (NSect * 2);

From 74f713a0c2ea595eb024dbe54076afaf7a8c235c Mon Sep 17 00:00:00 2001
From: Gauthier Legras <gauthier.legras@orange.fr>
Date: Tue, 17 Mar 2026 13:40:35 +0100
Subject: [PATCH 1444/1764] TRD: small fix for gain and VdExB calib

---
 .../TRD/include/DataFormatsTRD/CalGain.h         |  4 ++--
 .../TRD/include/DataFormatsTRD/CalVdriftExB.h    | 16 ++++++++--------
 Detectors/TRD/calibration/src/CalibratorGain.cxx |  4 ++--
 .../TRD/calibration/src/CalibratorVdExB.cxx      |  8 ++++----
 4 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalGain.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalGain.h
index b4e64db094a5c..97b3a73a86c03 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalGain.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalGain.h
@@ -40,7 +40,7 @@ class CalGain
     if (!defaultAvg || isGoodGain(iDet))
       return mMPVdEdx[iDet];
     else {
-      if (TMath::Abs(mMeanGain + 999.) < 1e-6)
+      if (std::fabs(mMeanGain + 999.) < 1e-6)
         mMeanGain = getAverageGain();
       return mMeanGain;
     }
@@ -68,7 +68,7 @@ class CalGain
 
   bool isGoodGain(int iDet) const
   {
-    if (TMath::Abs(mMPVdEdx[iDet] - constants::MPVDEDXDEFAULT) > 1e-6)
+    if (std::fabs(mMPVdEdx[iDet] - constants::MPVDEDXDEFAULT) > 1e-6)
       return true;
     else
       return false;
diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalVdriftExB.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalVdriftExB.h
index 65981e928fb39..280f9d0d4b8a9 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalVdriftExB.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/CalVdriftExB.h
@@ -41,7 +41,7 @@ class CalVdriftExB
     if (!defaultAvg || (isGoodExB(iDet) && isGoodVdrift(iDet)))
       return mVdrift[iDet];
     else {
-      if (TMath::Abs(mMeanVdrift + 999.) < 1e-6)
+      if (std::fabs(mMeanVdrift + 999.) < 1e-6)
         mMeanVdrift = getAverageVdrift();
       return mMeanVdrift;
     }
@@ -51,7 +51,7 @@ class CalVdriftExB
     if (!defaultAvg || (isGoodExB(iDet) && isGoodVdrift(iDet)))
       return mExB[iDet];
     else {
-      if (TMath::Abs(mMeanExB + 999.) < 1e-6)
+      if (std::fabs(mMeanExB + 999.) < 1e-6)
         mMeanExB = getAverageExB();
       return mMeanExB;
     }
@@ -102,9 +102,9 @@ class CalVdriftExB
     // check if value is well calibrated or not
     // default calibration if not enough entries
     // close to boundaries indicate a failed fit
-    if (TMath::Abs(mExB[iDet] - constants::EXBDEFAULT) > 1e-6 &&
-        TMath::Abs(mExB[iDet] - constants::EXBMIN) > 0.01 &&
-        TMath::Abs(mExB[iDet] - constants::EXBMAX) > 0.01)
+    if (std::fabs(mExB[iDet] - constants::EXBDEFAULT) > 1e-6 &&
+        std::fabs(mExB[iDet] - constants::EXBMIN) > 0.01 &&
+        std::fabs(mExB[iDet] - constants::EXBMAX) > 0.01)
       return true;
     else
       return false;
@@ -115,9 +115,9 @@ class CalVdriftExB
     // check if value is well calibrated or not
     // default calibration if not enough entries
     // close to boundaries indicate a failed fit
-    if (TMath::Abs(mVdrift[iDet] - constants::VDRIFTDEFAULT) > 1e-6 &&
-        TMath::Abs(mVdrift[iDet] - constants::VDRIFTMIN) > 0.1 &&
-        TMath::Abs(mVdrift[iDet] - constants::VDRIFTMAX) > 0.1)
+    if (std::fabs(mVdrift[iDet] - constants::VDRIFTDEFAULT) > 1e-6 &&
+        std::fabs(mVdrift[iDet] - constants::VDRIFTMIN) > 0.1 &&
+        std::fabs(mVdrift[iDet] - constants::VDRIFTMAX) > 0.1)
       return true;
     else
       return false;
diff --git a/Detectors/TRD/calibration/src/CalibratorGain.cxx b/Detectors/TRD/calibration/src/CalibratorGain.cxx
index 77efeaeb36f1e..c276563cac5fb 100644
--- a/Detectors/TRD/calibration/src/CalibratorGain.cxx
+++ b/Detectors/TRD/calibration/src/CalibratorGain.cxx
@@ -89,7 +89,7 @@ void CalibratorGain::retrievePrev(o2::framework::ProcessingContext& pc)
   std::string msg = "Default Object";
   // We check if the object we got is the default one by comparing it to the defaults.
   for (int iDet = 0; iDet < MAXCHAMBER; ++iDet) {
-    if (dataCalGain->getMPVdEdx(iDet) != constants::MPVDEDXDEFAULT) {
+    if (dataCalGain->getMPVdEdx(iDet, false) != constants::MPVDEDXDEFAULT) {
       msg = "Previous Object";
       break;
     }
@@ -98,7 +98,7 @@ void CalibratorGain::retrievePrev(o2::framework::ProcessingContext& pc)
 
   // Here we set each entry regardless if it is the default or not.
   for (int iDet = 0; iDet < MAXCHAMBER; ++iDet) {
-    mFitResults[iDet] = dataCalGain->getMPVdEdx(iDet);
+    mFitResults[iDet] = dataCalGain->getMPVdEdx(iDet, false);
   }
 }
 
diff --git a/Detectors/TRD/calibration/src/CalibratorVdExB.cxx b/Detectors/TRD/calibration/src/CalibratorVdExB.cxx
index fef7bdecef38c..961a74eefbe0f 100644
--- a/Detectors/TRD/calibration/src/CalibratorVdExB.cxx
+++ b/Detectors/TRD/calibration/src/CalibratorVdExB.cxx
@@ -166,8 +166,8 @@ void CalibratorVdExB::retrievePrev(o2::framework::ProcessingContext& pc)
   std::string msg = "Default Object";
   // We check if the object we got is the default one by comparing it to the defaults.
   for (int iDet = 0; iDet < MAXCHAMBER; ++iDet) {
-    if (dataCalVdriftExB->getVdrift(iDet) != VDRIFTDEFAULT ||
-        dataCalVdriftExB->getExB(iDet) != EXBDEFAULT) {
+    if (dataCalVdriftExB->getVdrift(iDet, false) != VDRIFTDEFAULT ||
+        dataCalVdriftExB->getExB(iDet, false) != EXBDEFAULT) {
       msg = "Previous Object";
       break;
     }
@@ -176,8 +176,8 @@ void CalibratorVdExB::retrievePrev(o2::framework::ProcessingContext& pc)
 
   // Here we set each entry regardless if it is the default or not.
   for (int iDet = 0; iDet < MAXCHAMBER; ++iDet) {
-    mFitFunctor.laPreCorr[iDet] = dataCalVdriftExB->getExB(iDet);
-    mFitFunctor.vdPreCorr[iDet] = dataCalVdriftExB->getVdrift(iDet);
+    mFitFunctor.laPreCorr[iDet] = dataCalVdriftExB->getExB(iDet, false);
+    mFitFunctor.vdPreCorr[iDet] = dataCalVdriftExB->getVdrift(iDet, false);
   }
 }
 

From 5b0ada5f3169f594fba3bd3a66d1714c836f067f Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Wed, 25 Feb 2026 11:45:59 +0100
Subject: [PATCH 1445/1764] Add treatment of channel saturation to all
 scenarios

---
 .../include/TPCSimulation/SAMPAProcessing.h   | 34 +++++++------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/Detectors/TPC/simulation/include/TPCSimulation/SAMPAProcessing.h b/Detectors/TPC/simulation/include/TPCSimulation/SAMPAProcessing.h
index be40c8652ad61..3f21b6723be14 100644
--- a/Detectors/TPC/simulation/include/TPCSimulation/SAMPAProcessing.h
+++ b/Detectors/TPC/simulation/include/TPCSimulation/SAMPAProcessing.h
@@ -158,23 +158,19 @@ template <DigitzationMode MODE>
 inline float SAMPAProcessing::makeSignal(float ADCcounts, const int sector, const int globalPadInSector, const float commonMode,
                                          float& pedestal, float& noise, float tot)
 {
-  float signal = ADCcounts;
   pedestal = getPedestal(sector, globalPadInSector);
-  float pedestalCRU = getPedestalCRU(sector, globalPadInSector);
   noise = getNoise(sector, globalPadInSector);
+
+  const float signal = ADCcounts;
+  const float pedestalCRU = getPedestalCRU(sector, globalPadInSector);
+  const float fullSignal = signal - commonMode + noise + pedestal + (tot > 0 ? 80 : 0); // TODO: improve to also add tail
+
   switch (MODE) {
     case DigitzationMode::FullMode: {
-      signal -= commonMode;
-      signal += noise;
-      signal += pedestal;
-      return getADCSaturation(signal);
+      return getADCSaturation(fullSignal);
       break;
     }
     case DigitzationMode::ZeroSuppression: {
-      signal -= commonMode;
-      signal += noise;
-      signal += pedestal;
-      signal += (tot > 0) ? 80 : 0; // TODO: improve to also add tail
       const float signalSubtractPedestal = getADCSaturation(signal) - pedestalCRU;
       const float zeroSuppression = getZeroSuppression(sector, globalPadInSector);
       if (signalSubtractPedestal < zeroSuppression) {
@@ -184,10 +180,10 @@ inline float SAMPAProcessing::makeSignal(float ADCcounts, const int sector, cons
       break;
     }
     case DigitzationMode::ZeroSuppressionCMCorr: {
-      signal += noise;
-      signal += pedestal;
-      signal += (tot > 0) ? 80 : 0; // TODO: improve to also add tail
-      const float signalSubtractPedestal = getADCSaturation(signal) - pedestalCRU;
+      // TODO: this is not really a common mode correction, since the common mode is simply not treated.
+      // Instead, the full common mode algorithm should be implemented and used
+      const float signalNoCM = signal + noise + pedestal + (tot > 0 ? 80 : 0); // TODO: improve to also add tail
+      const float signalSubtractPedestal = getADCSaturation(signalNoCM) - pedestalCRU;
       const float zeroSuppression = getZeroSuppression(sector, globalPadInSector);
       if (signalSubtractPedestal < zeroSuppression) {
         return 0.f;
@@ -196,18 +192,12 @@ inline float SAMPAProcessing::makeSignal(float ADCcounts, const int sector, cons
       break;
     }
     case DigitzationMode::SubtractPedestal: {
-      signal -= commonMode;
-      signal += noise;
-      signal += pedestal;
-      const float signalSubtractPedestal = getADCSaturation(signal) - pedestalCRU;
+      const float signalSubtractPedestal = getADCSaturation(fullSignal) - pedestalCRU;
       return signalSubtractPedestal;
       break;
     }
     case DigitzationMode::NoSaturation: {
-      signal -= commonMode;
-      signal += noise;
-      signal += pedestal;
-      return signal;
+      return fullSignal;
       break;
     }
     case DigitzationMode::PropagateADC: {

From 8572fc96fcf1ec1dabfc628ad741844f189025b4 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Tue, 17 Feb 2026 16:25:42 +0100
Subject: [PATCH 1446/1764] MID: remove input wildcards in MID workflows

---
 .../MIDWorkflow/ColumnDataSpecsUtils.h        | 35 +++++++--------
 .../Workflow/src/CalibDataProcessorSpec.cxx   | 22 +++-------
 .../MUON/MID/Workflow/src/ClusterizerSpec.cxx |  2 +-
 .../MID/Workflow/src/ColumnDataSpecsUtils.cxx | 44 ++++++++++++++-----
 .../src/DecodedDataAggregatorSpec.cxx         |  4 +-
 .../MID/Workflow/src/EntropyEncoderSpec.cxx   | 31 +++++--------
 .../MUON/MID/Workflow/src/FilteringBCSpec.cxx |  2 +-
 .../MUON/MID/Workflow/src/FilteringSpec.cxx   |  2 +-
 .../MUON/MID/Workflow/src/MaskMakerSpec.cxx   | 32 ++++----------
 .../MUON/MID/Workflow/src/TimingSpec.cxx      |  2 +-
 .../MID/Workflow/src/ZeroSuppressionSpec.cxx  |  2 +-
 11 files changed, 82 insertions(+), 96 deletions(-)

diff --git a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/ColumnDataSpecsUtils.h b/Detectors/MUON/MID/Workflow/include/MIDWorkflow/ColumnDataSpecsUtils.h
index d8ec401e6a473..5f0fc43e1afca 100644
--- a/Detectors/MUON/MID/Workflow/include/MIDWorkflow/ColumnDataSpecsUtils.h
+++ b/Detectors/MUON/MID/Workflow/include/MIDWorkflow/ColumnDataSpecsUtils.h
@@ -42,21 +42,28 @@ namespace mid
 namespace specs
 {
 
-/// Returns the input specs for MID Column Data and corresponding ROFs and labels
+/// Returns the input specs for MID Column Data and corresponding ROFs and labels for EventType Standard
 /// \param dataBind Data binding name
 /// \param dataDesc Input data description
 /// \param useMC Builds output specs for labels
 /// \return Vector of input specs
-std::vector<framework::InputSpec> buildInputSpecs(std::string_view dataBind, std::string_view dataDesc, bool useMC);
+std::vector<framework::InputSpec> buildStandardInputSpecs(std::string_view dataBind, std::string_view dataDesc, bool useMC);
 
-/// Returns the input specs for MID Column Data and corresponding ROFs and labels
+/// Returns the input specs for MID Column Data and corresponding ROFs and labels for EventType Standard
 /// \param dataBind Data binding name
 /// \param dataDesc Input data description
 /// \param rofDesc Input ROF record description
 /// \param labelsDesc Input MC labels description
 /// \param useMC Builds output specs for labels
 /// \return Vector of input specs
-std::vector<framework::InputSpec> buildInputSpecs(std::string_view dataBind, std::string_view dataDesc, std::string_view rofDesc, std::string_view labelsDesc, bool useMC);
+std::vector<framework::InputSpec> buildStandardInputSpecs(std::string_view dataBind, std::string_view dataDesc, std::string_view rofDesc, std::string_view labelsDesc, bool useMC);
+
+/// Returns the input specs for MID Column Data and corresponding ROFs and labels for all three EventTypes
+/// \param dataBind Data binding name
+/// \param dataDesc Input data description
+/// \param rofDesc Input ROF record description
+/// \return Vector of input specs
+std::vector<framework::InputSpec> buildInputSpecs(std::string_view dataBind, std::string_view dataDesc, std::string_view rofDesc);
 
 /// Returns the output specs for the different event types
 /// \param bind Binding name
@@ -71,22 +78,14 @@ std::vector<framework::OutputSpec> buildOutputSpecs(std::string_view bind, std::
 /// \return Vector of Output specs
 std::vector<framework::OutputSpec> buildStandardOutputSpecs(std::string_view dataBind, std::string_view dataDesc, bool useMC);
 
-/// Returns the inputs for the different event types
+/// Returns the input matching a specific binding
 /// \param pc Processing context
 /// \param bind Binding name
 /// \return Array of spans
 template <typename T>
-std::array<gsl::span<const T>, NEvTypes> getInput(framework::ProcessingContext& pc, std::string_view bind)
+gsl::span<const T> getInput(framework::ProcessingContext& pc, std::string_view bind, int subSpec = -1)
 {
-  std::array<gsl::span<const T>, 3> data;
-  for (auto const& inputRef : framework::InputRecordWalker(pc.inputs())) {
-    auto const* dh = framework::DataRefUtils::getHeader<o2::header::DataHeader*>(inputRef);
-    auto subSpecIdx = static_cast<size_t>(dh->subSpecification);
-    if (framework::DataRefUtils::match(inputRef, bind.data())) {
-      data[subSpecIdx] = pc.inputs().get<gsl::span<T>>(inputRef);
-    }
-  }
-  return data;
+  return pc.inputs().get<gsl::span<T>>(fmt::format("{}{}", bind.data(), subSpec >= 0 ? fmt::format("_{}", subSpec) : ""));
 }
 
 /// Gets the outputs
@@ -94,7 +93,7 @@ std::array<gsl::span<const T>, NEvTypes> getInput(framework::ProcessingContext&
 /// \return vector of outputs
 std::vector<framework::Output> buildOutputs(std::vector<framework::OutputSpec> outputSpecs);
 
-/// Returns the array of Column Data
+/// Returns the array of Column Data for all three EventTypes
 /// \param pc Processing context
 /// \param dataBind Data binding name
 /// \return Array of Column Data spans
@@ -107,7 +106,7 @@ std::array<gsl::span<const ColumnData>, NEvTypes> getData(framework::ProcessingC
 /// \return Span of ColumnData
 gsl::span<const ColumnData> getData(framework::ProcessingContext& pc, std::string_view dataBind, EventType eventType);
 
-/// Returns the array of ROF records
+/// Returns the array of ROF records for all three EventTypes
 /// \param pc Processing context
 /// \param dataBind Data binding name
 /// \return Array of ROF Records spans
@@ -124,7 +123,7 @@ gsl::span<const ROFRecord> getRofs(framework::ProcessingContext& pc, std::string
 /// \param pc Processing context
 /// \param dataBind Data binding name
 /// \return Pointer to MC labels
-std::unique_ptr<const o2::dataformats::MCTruthContainer<MCLabel>> getLabels(framework::ProcessingContext& pc, std::string_view dataBind);
+std::unique_ptr<const o2::dataformats::MCTruthContainer<MCLabel>> getLabels(framework::ProcessingContext& pc, std::string_view dataBind, EventType eventType = EventType::Standard);
 
 } // namespace specs
 } // namespace mid
diff --git a/Detectors/MUON/MID/Workflow/src/CalibDataProcessorSpec.cxx b/Detectors/MUON/MID/Workflow/src/CalibDataProcessorSpec.cxx
index 1a6f2de9cd886..036178c04e867 100644
--- a/Detectors/MUON/MID/Workflow/src/CalibDataProcessorSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/CalibDataProcessorSpec.cxx
@@ -61,19 +61,9 @@ class CalibDataProcessorDPL
     std::array<gsl::span<const ColumnData>, 3> data;
     std::array<gsl::span<const ROFRecord>, 3> dataRof;
 
-    std::vector<of::InputSpec> filter = {
-      {"check_data", of::ConcreteDataTypeMatcher{header::gDataOriginMID, "DATA"}, of::Lifetime::Timeframe},
-      {"check_rof", of::ConcreteDataTypeMatcher{header::gDataOriginMID, "DATAROF"}, of::Lifetime::Timeframe},
-    };
-
-    for (auto const& inputRef : of::InputRecordWalker(pc.inputs(), filter)) {
-      auto const* dh = framework::DataRefUtils::getHeader<o2::header::DataHeader*>(inputRef);
-      auto subSpecIdx = static_cast<size_t>(dh->subSpecification);
-      if (of::DataRefUtils::match(inputRef, "mid_data")) {
-        data[subSpecIdx] = pc.inputs().get<gsl::span<o2::mid::ColumnData>>(inputRef);
-      } else if (of::DataRefUtils::match(inputRef, "mid_data_rof")) {
-        dataRof[subSpecIdx] = pc.inputs().get<gsl::span<o2::mid::ROFRecord>>(inputRef);
-      }
+    for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < NEvTypes; ++subSpec) {
+      data[subSpec] = pc.inputs().get<gsl::span<o2::mid::ColumnData>>(fmt::format("mid_data_{}", subSpec));
+      dataRof[subSpec] = pc.inputs().get<gsl::span<o2::mid::ROFRecord>>(fmt::format("mid_data_rof_{}", subSpec));
     }
 
     mNoise.clear();
@@ -151,8 +141,10 @@ class CalibDataProcessorDPL
 of::DataProcessorSpec getCalibDataProcessorSpec(const FEEIdConfig& feeIdConfig, const CrateMasks& crateMasks)
 {
   std::vector<of::InputSpec> inputSpecs;
-  inputSpecs.emplace_back("mid_data", of::ConcreteDataTypeMatcher(header::gDataOriginMID, "DATA"), of::Lifetime::Timeframe);
-  inputSpecs.emplace_back("mid_data_rof", of::ConcreteDataTypeMatcher(header::gDataOriginMID, "DATAROF"), of::Lifetime::Timeframe);
+  for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < NEvTypes; ++subSpec) {
+    inputSpecs.emplace_back(fmt::format("mid_data_{}", subSpec), header::gDataOriginMID, "DATA", subSpec, of::Lifetime::Timeframe);
+    inputSpecs.emplace_back(fmt::format("mid_data_rof_{}", subSpec), header::gDataOriginMID, "DATAROF", subSpec, of::Lifetime::Timeframe);
+  }
 
   std::vector<of::OutputSpec> outputSpecs;
   outputSpecs.emplace_back(header::gDataOriginMID, "NOISE", 0);
diff --git a/Detectors/MUON/MID/Workflow/src/ClusterizerSpec.cxx b/Detectors/MUON/MID/Workflow/src/ClusterizerSpec.cxx
index c544ce19fcdea..bf0d9608a2119 100644
--- a/Detectors/MUON/MID/Workflow/src/ClusterizerSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/ClusterizerSpec.cxx
@@ -132,7 +132,7 @@ framework::DataProcessorSpec getClusterizerSpec(bool isMC, std::string_view inDa
   if (isMC) {
     outputSpecs.emplace_back(of::OutputSpec{header::gDataOriginMID, "CLUSTERSLABELS"});
   }
-  auto inputSpecs = specs::buildInputSpecs("mid_cluster_in", inDataDesc, inRofDesc, inLabelsDesc, isMC);
+  auto inputSpecs = specs::buildStandardInputSpecs("mid_cluster_in", inDataDesc, inRofDesc, inLabelsDesc, isMC);
 
   return of::DataProcessorSpec{
     "MIDClusterizer",
diff --git a/Detectors/MUON/MID/Workflow/src/ColumnDataSpecsUtils.cxx b/Detectors/MUON/MID/Workflow/src/ColumnDataSpecsUtils.cxx
index e0d41cd8d91d2..b4884ad68ad15 100644
--- a/Detectors/MUON/MID/Workflow/src/ColumnDataSpecsUtils.cxx
+++ b/Detectors/MUON/MID/Workflow/src/ColumnDataSpecsUtils.cxx
@@ -83,14 +83,26 @@ std::string buildSelectors(std::string_view dataBind, std::string_view dataDesc,
   return selector;
 }
 
-std::vector<framework::InputSpec> buildInputSpecs(std::string_view dataBind, std::string_view dataDesc, bool useMC)
+std::vector<framework::InputSpec> buildInputSpecs(std::string_view dataBind, std::string_view dataDesc, std::string_view rofDesc)
 {
-  return buildInputSpecs(dataBind, dataDesc, getROFDescription(dataDesc), getLabelsDescription(dataDesc), useMC);
+  std::string selector;
+  for (size_t ievt = 0; ievt < NEvTypes; ++ievt) {
+    if (!selector.empty()) {
+      selector += ";";
+    }
+    selector += buildSelectors(dataBind, dataDesc, rofDesc, "", false, ievt);
+  }
+  return framework::select(selector.c_str());
+}
+
+std::vector<framework::InputSpec> buildStandardInputSpecs(std::string_view dataBind, std::string_view dataDesc, bool useMC)
+{
+  return buildStandardInputSpecs(dataBind, dataDesc, getROFDescription(dataDesc), getLabelsDescription(dataDesc), useMC);
 }
 
-std::vector<framework::InputSpec> buildInputSpecs(std::string_view dataBind, std::string_view dataDesc, std::string_view rofDesc, std::string_view labelsDesc, bool useMC)
+std::vector<framework::InputSpec> buildStandardInputSpecs(std::string_view dataBind, std::string_view dataDesc, std::string_view rofDesc, std::string_view labelsDesc, bool useMC)
 {
-  std::string selector = buildSelectors(dataBind, dataDesc, rofDesc, labelsDesc, useMC);
+  std::string selector = buildSelectors(dataBind, dataDesc, rofDesc, labelsDesc, useMC, 0);
   return framework::select(selector.c_str());
 }
 
@@ -134,29 +146,37 @@ std::vector<framework::Output> buildOutputs(std::vector<framework::OutputSpec> o
 
 std::array<gsl::span<const ColumnData>, NEvTypes> getData(framework::ProcessingContext& pc, std::string_view dataBind)
 {
-  return getInput<ColumnData>(pc, dataBind);
+  std::array<gsl::span<const ColumnData>, 3> data;
+  for (size_t ievt = 0; ievt < NEvTypes; ++ievt) {
+    data[ievt] = getInput<ColumnData>(pc, dataBind, ievt);
+  }
+
+  return data;
 }
 
 gsl::span<const ColumnData> getData(framework::ProcessingContext& pc, std::string_view dataBind, EventType eventType)
 {
-  auto idx = static_cast<size_t>(eventType);
-  return getData(pc, dataBind)[idx];
+  return getInput<ColumnData>(pc, dataBind.data(), static_cast<int>(eventType));
 }
 
 std::array<gsl::span<const ROFRecord>, NEvTypes> getRofs(framework::ProcessingContext& pc, std::string_view dataBind)
 {
-  return getInput<ROFRecord>(pc, getROFBind(dataBind));
+  std::array<gsl::span<const ROFRecord>, 3> data;
+  for (size_t ievt = 0; ievt < NEvTypes; ++ievt) {
+    data[ievt] = getInput<ROFRecord>(pc, getROFBind(dataBind).data(), ievt);
+  }
+
+  return data;
 }
 
 gsl::span<const ROFRecord> getRofs(framework::ProcessingContext& pc, std::string_view dataBind, EventType eventType)
 {
-  auto idx = static_cast<size_t>(eventType);
-  return getRofs(pc, dataBind)[idx];
+  return getInput<ROFRecord>(pc, getROFBind(dataBind).data(), static_cast<int>(eventType));
 }
 
-std::unique_ptr<const o2::dataformats::MCTruthContainer<MCLabel>> getLabels(framework::ProcessingContext& pc, std::string_view dataBind)
+std::unique_ptr<const o2::dataformats::MCTruthContainer<MCLabel>> getLabels(framework::ProcessingContext& pc, std::string_view dataBind, EventType eventType)
 {
-  return pc.inputs().get<const o2::dataformats::MCTruthContainer<MCLabel>*>(getLabelsBind(dataBind).data());
+  return pc.inputs().get<const o2::dataformats::MCTruthContainer<MCLabel>*>(fmt::format("{}_{}", getLabelsBind(dataBind).data(), static_cast<size_t>(eventType)));
 }
 
 } // namespace specs
diff --git a/Detectors/MUON/MID/Workflow/src/DecodedDataAggregatorSpec.cxx b/Detectors/MUON/MID/Workflow/src/DecodedDataAggregatorSpec.cxx
index 192b4c52be9cc..54b1a458fec0f 100644
--- a/Detectors/MUON/MID/Workflow/src/DecodedDataAggregatorSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/DecodedDataAggregatorSpec.cxx
@@ -58,7 +58,7 @@ class DecodedDataAggregatorDeviceDPL
     mAggregator.process(data, inROFRecords);
     mTimerAlgo += std::chrono::high_resolution_clock::now() - tAlgoStart;
 
-    for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < 3; ++subSpec) {
+    for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < NEvTypes; ++subSpec) {
       EventType evtType = static_cast<EventType>(subSpec);
       pc.outputs().snapshot(of::Output{o2::header::gDataOriginMID, "DATA", subSpec}, mAggregator.getData(evtType));
       pc.outputs().snapshot(of::Output{o2::header::gDataOriginMID, "DATAROF", subSpec}, mAggregator.getROFRecords(evtType));
@@ -79,7 +79,7 @@ framework::DataProcessorSpec getDecodedDataAggregatorSpec()
 {
   std::vector<of::InputSpec> inputSpecs{of::InputSpec{"mid_decoded", header::gDataOriginMID, "DECODED"}, of::InputSpec{"mid_decoded_rof", header::gDataOriginMID, "DECODEDROF"}};
   std::vector<of::OutputSpec> outputSpecs;
-  for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < 3; ++subSpec) {
+  for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < NEvTypes; ++subSpec) {
     outputSpecs.emplace_back(of::OutputSpec{header::gDataOriginMID, "DATA", subSpec});
     outputSpecs.emplace_back(of::OutputSpec{header::gDataOriginMID, "DATAROF", subSpec});
   }
diff --git a/Detectors/MUON/MID/Workflow/src/EntropyEncoderSpec.cxx b/Detectors/MUON/MID/Workflow/src/EntropyEncoderSpec.cxx
index d75fe3fa6fbf2..f8d9922db25fa 100644
--- a/Detectors/MUON/MID/Workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/EntropyEncoderSpec.cxx
@@ -56,26 +56,15 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
   mTimer.Start(false);
   mCTFCoder.updateTimeDependentParams(pc, true);
   CTFHelper::TFData tfData;
-  std::vector<InputSpec>
-    filter = {
-      {"check", ConcreteDataTypeMatcher{header::gDataOriginMID, "DATA"}, Lifetime::Timeframe},
-      {"check", ConcreteDataTypeMatcher{header::gDataOriginMID, "DATAROF"}, Lifetime::Timeframe},
-    };
   size_t insize = 0;
-  for (auto const& inputRef : InputRecordWalker(pc.inputs(), filter)) {
-    auto const* dh = framework::DataRefUtils::getHeader<o2::header::DataHeader*>(inputRef);
-    if (dh->subSpecification >= NEvTypes) {
-      throw std::runtime_error(fmt::format("SubSpecification={} does not match EvenTypes for {}", dh->subSpecification, dh->dataDescription.as<std::string>()));
-    }
-    if (DataRefUtils::match(inputRef, "cols")) {
-      tfData.colData[dh->subSpecification] = pc.inputs().get<gsl::span<o2::mid::ColumnData>>(inputRef);
-      insize += tfData.colData[dh->subSpecification].size() * sizeof(o2::mid::ColumnData);
-    }
-    if (DataRefUtils::match(inputRef, "rofs")) {
-      tfData.rofData[dh->subSpecification] = pc.inputs().get<gsl::span<o2::mid::ROFRecord>>(inputRef);
-      insize += tfData.rofData[dh->subSpecification].size() * sizeof(o2::mid::ROFRecord);
-    }
+  for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < NEvTypes; ++subSpec) {
+    tfData.colData[subSpec] = pc.inputs().get<gsl::span<o2::mid::ColumnData>>(fmt::format("cols_{}", subSpec));
+    insize += tfData.colData[subSpec].size() * sizeof(o2::mid::ColumnData);
+
+    tfData.rofData[subSpec] = pc.inputs().get<gsl::span<o2::mid::ROFRecord>>(fmt::format("rofs_{}", subSpec));
+    insize += tfData.rofData[subSpec].size() * sizeof(o2::mid::ROFRecord);
   }
+
   if (mSelIR) {
     mCTFCoder.setSelectedIRFrames(pc.inputs().get<gsl::span<o2::dataformats::IRFrame>>("selIRFrames"));
   }
@@ -102,8 +91,10 @@ void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
 DataProcessorSpec getEntropyEncoderSpec(bool selIR, const std::string& ctfdictOpt)
 {
   std::vector<InputSpec> inputs;
-  inputs.emplace_back("rofs", ConcreteDataTypeMatcher(header::gDataOriginMID, "DATAROF"), Lifetime::Timeframe);
-  inputs.emplace_back("cols", ConcreteDataTypeMatcher(header::gDataOriginMID, "DATA"), Lifetime::Timeframe);
+  for (o2::header::DataHeader::SubSpecificationType subSpec = 0; subSpec < NEvTypes; ++subSpec) {
+    inputs.emplace_back(fmt::format("cols_{}", subSpec), header::gDataOriginMID, "DATA", subSpec, Lifetime::Timeframe);
+    inputs.emplace_back(fmt::format("rofs_{}", subSpec), header::gDataOriginMID, "DATAROF", subSpec, Lifetime::Timeframe);
+  }
 
   if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
     inputs.emplace_back("ctfdict", header::gDataOriginMID, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec("MID/Calib/CTFDictionaryTree"));
diff --git a/Detectors/MUON/MID/Workflow/src/FilteringBCSpec.cxx b/Detectors/MUON/MID/Workflow/src/FilteringBCSpec.cxx
index 2aadabeab0bed..2d697f4bc5b1d 100644
--- a/Detectors/MUON/MID/Workflow/src/FilteringBCSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/FilteringBCSpec.cxx
@@ -100,7 +100,7 @@ class FilteringBCDeviceDPL
 of::DataProcessorSpec getFilteringBCSpec(bool useMC, std::string_view inDesc)
 {
 
-  auto inputSpecs = specs::buildInputSpecs("mid_filter_BC_in", inDesc, useMC);
+  auto inputSpecs = specs::buildStandardInputSpecs("mid_filter_BC_in", inDesc, useMC);
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
                                                               false,                          // GRPECS=true
                                                               true,                           // GRPLHCIF
diff --git a/Detectors/MUON/MID/Workflow/src/FilteringSpec.cxx b/Detectors/MUON/MID/Workflow/src/FilteringSpec.cxx
index 0ccbbe237b9a5..6ef3424e1ec29 100644
--- a/Detectors/MUON/MID/Workflow/src/FilteringSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/FilteringSpec.cxx
@@ -143,7 +143,7 @@ class FilteringDeviceDPL
 of::DataProcessorSpec getFilteringSpec(bool useMC, std::string_view inDesc, std::string_view outDesc)
 {
 
-  auto inputSpecs = specs::buildInputSpecs("mid_filter_in", inDesc, useMC);
+  auto inputSpecs = specs::buildStandardInputSpecs("mid_filter_in", inDesc, useMC);
   inputSpecs.emplace_back("mid_bad_channels", header::gDataOriginMID, "BAD_CHANNELS", 0, of::Lifetime::Condition, of::ccdbParamSpec("MID/Calib/BadChannels"));
   inputSpecs.emplace_back("mid_rejectlist", header::gDataOriginMID, "REJECTLIST", 0, of::Lifetime::Condition, of::ccdbParamSpec("MID/Calib/RejectList"));
 
diff --git a/Detectors/MUON/MID/Workflow/src/MaskMakerSpec.cxx b/Detectors/MUON/MID/Workflow/src/MaskMakerSpec.cxx
index 28d2ff953ea23..d4b63de7e5d3f 100644
--- a/Detectors/MUON/MID/Workflow/src/MaskMakerSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/MaskMakerSpec.cxx
@@ -69,28 +69,10 @@ class MaskMakerDeviceDPL
     gsl::span<const ColumnData> calibData, fetData;
     gsl::span<const ROFRecord> calibDataRof, fetDataRof;
 
-    std::vector<of::InputSpec> filter = {
-      {"check_data", of::ConcreteDataTypeMatcher{header::gDataOriginMID, "DATA"}, of::Lifetime::Timeframe},
-      {"check_rof", of::ConcreteDataTypeMatcher{header::gDataOriginMID, "DATAROF"}, of::Lifetime::Timeframe},
-    };
-
-    for (auto const& inputRef : of::InputRecordWalker(pc.inputs(), filter)) {
-      auto const* dh = framework::DataRefUtils::getHeader<o2::header::DataHeader*>(inputRef);
-      if (of::DataRefUtils::match(inputRef, "mid_data")) {
-        if (dh->subSpecification == 1) {
-          calibData = pc.inputs().get<gsl::span<o2::mid::ColumnData>>(inputRef);
-        } else if (dh->subSpecification == 2) {
-          fetData = pc.inputs().get<gsl::span<o2::mid::ColumnData>>(inputRef);
-        }
-      }
-      if (of::DataRefUtils::match(inputRef, "mid_data_rof")) {
-        if (dh->subSpecification == 1) {
-          calibDataRof = pc.inputs().get<gsl::span<o2::mid::ROFRecord>>(inputRef);
-        } else if (dh->subSpecification == 2) {
-          fetDataRof = pc.inputs().get<gsl::span<o2::mid::ROFRecord>>(inputRef);
-        }
-      }
-    }
+    calibData = pc.inputs().get<gsl::span<o2::mid::ColumnData>>("mid_data_1");
+    calibDataRof = pc.inputs().get<gsl::span<o2::mid::ROFRecord>>("mid_data_rof_1");
+    fetData = pc.inputs().get<gsl::span<o2::mid::ColumnData>>("mid_data_2");
+    fetDataRof = pc.inputs().get<gsl::span<o2::mid::ROFRecord>>("mid_data_rof_2");
 
     unsigned long nEvents = calibDataRof.size();
     if (nEvents == 0) {
@@ -145,8 +127,10 @@ class MaskMakerDeviceDPL
 framework::DataProcessorSpec getMaskMakerSpec(const FEEIdConfig& feeIdConfig, const CrateMasks& crateMasks)
 {
   std::vector<of::InputSpec> inputSpecs;
-  inputSpecs.emplace_back("mid_data", of::ConcreteDataTypeMatcher(header::gDataOriginMID, "DATA"), of::Lifetime::Timeframe);
-  inputSpecs.emplace_back("mid_data_rof", of::ConcreteDataTypeMatcher(header::gDataOriginMID, "DATAROF"), of::Lifetime::Timeframe);
+  for (o2::header::DataHeader::SubSpecificationType subSpec = 1; subSpec < NEvTypes; ++subSpec) {
+    inputSpecs.emplace_back(fmt::format("mid_data_{}", subSpec), o2::header::gDataOriginMID, "DATA", subSpec, of::Lifetime::Timeframe);
+    inputSpecs.emplace_back(fmt::format("mid_data_rof_{}", subSpec), o2::header::gDataOriginMID, "DATAROF", subSpec, of::Lifetime::Timeframe);
+  }
 
   std::vector<of::OutputSpec> outputSpecs{
     of::OutputSpec{header::gDataOriginMID, "MASKS", 1},
diff --git a/Detectors/MUON/MID/Workflow/src/TimingSpec.cxx b/Detectors/MUON/MID/Workflow/src/TimingSpec.cxx
index 05f669ab76ba4..5a397de9a045f 100644
--- a/Detectors/MUON/MID/Workflow/src/TimingSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/TimingSpec.cxx
@@ -71,7 +71,7 @@ class TimingDeviceDPL
 
 of::DataProcessorSpec getTimingSpec(int localToBC, std::string_view inRofDesc)
 {
-  auto inputSpecs = specs::buildInputSpecs("mid_timing_in", "", inRofDesc, "", false);
+  auto inputSpecs = specs::buildInputSpecs("mid_timing_in", "", inRofDesc);
   auto outputSpecs = specs::buildOutputSpecs("mid_timing_out", "TDATAROF");
 
   return of::DataProcessorSpec{
diff --git a/Detectors/MUON/MID/Workflow/src/ZeroSuppressionSpec.cxx b/Detectors/MUON/MID/Workflow/src/ZeroSuppressionSpec.cxx
index 5d89eee81c629..7298ad9e506e3 100644
--- a/Detectors/MUON/MID/Workflow/src/ZeroSuppressionSpec.cxx
+++ b/Detectors/MUON/MID/Workflow/src/ZeroSuppressionSpec.cxx
@@ -103,7 +103,7 @@ class ZeroSuppressionDeviceDPL
 
 framework::DataProcessorSpec getZeroSuppressionSpec(bool useMC, std::string_view dataDesc)
 {
-  auto inputSpecs = specs::buildInputSpecs("mid_zs_in", dataDesc, useMC);
+  auto inputSpecs = specs::buildStandardInputSpecs("mid_zs_in", dataDesc, useMC);
   auto outputSpecs = specs::buildStandardOutputSpecs("mid_zs_out", "DATA", useMC);
 
   return of::DataProcessorSpec{

From 4bfc0a53f34c142e9dbc0ca0135533603d59c8de Mon Sep 17 00:00:00 2001
From: Sergio Garcia <sergio.garcia.de.la.cruz@cern.ch>
Date: Wed, 18 Mar 2026 16:29:47 +0100
Subject: [PATCH 1447/1764] Update clean PR action

---
 .github/workflows/clean-test.yml | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/clean-test.yml b/.github/workflows/clean-test.yml
index 0f15301d4eed9..b149ae86b991d 100644
--- a/.github/workflows/clean-test.yml
+++ b/.github/workflows/clean-test.yml
@@ -19,10 +19,6 @@ name: Clean PR checks
       # Warning: the check_* keys are magic and must consist of the string
       # "check_" followed by the applicable check name exactly. The
       # "description" field is only the human-readable label for the input.
-      'check_build/AliceO2/O2/o2/macOS':
-        description: build/AliceO2/O2/o2/macOS
-        type: boolean
-        default: true
       'check_build/AliceO2/O2/o2/macOS-arm':
         description: build/AliceO2/O2/o2/macOS-arm
         type: boolean
@@ -31,8 +27,8 @@ name: Clean PR checks
         description: build/O2/fullCI
         type: boolean
         default: true
-      'check_build/O2/o2-dataflow-cs8':
-        description: build/O2/o2-dataflow-cs8
+      'check_build/O2/o2-dataflow-slc9':
+        description: build/O2/o2-dataflow-slc9
         type: boolean
         default: true
       'check_build/O2/o2/aarch64':

From 866b9a243f0ee55c63a41be4f95aa896afa3cf87 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 18 Mar 2026 23:01:10 +0100
Subject: [PATCH 1448/1764] DPL: allow pipelining of the CCDB fetcher (#15192)

---
 Framework/Core/src/WorkflowCustomizationHelpers.cxx | 1 +
 Framework/Core/src/WorkflowHelpers.cxx              | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/WorkflowCustomizationHelpers.cxx b/Framework/Core/src/WorkflowCustomizationHelpers.cxx
index 05abb5dab98cd..2154d0fe26f8d 100644
--- a/Framework/Core/src/WorkflowCustomizationHelpers.cxx
+++ b/Framework/Core/src/WorkflowCustomizationHelpers.cxx
@@ -42,6 +42,7 @@ namespace o2::framework
 std::vector<ConfigParamSpec> WorkflowCustomizationHelpers::requiredWorkflowOptions()
 {
   return {{{"readers", VariantType::Int64, 1ll, {"number of parallel readers to use"}},
+           {"ccdb-fetchers", VariantType::Int64, 1ll, {"number of parallel ccdb-fetchers to use"}},
            {"spawners", VariantType::Int64, 1ll, {"number of parallel spawners to use"}},
            {"pipeline", VariantType::String, "", {"override default pipeline size"}},
            {"clone", VariantType::String, "", {"clone processors from a template"}},
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 714706952d26c..abe566e239618 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -505,7 +505,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     ccdbBackend.outputs.push_back(OutputSpec{"CTP", "OrbitReset", 0});
     // Load the CCDB backend from the plugin
     ccdbBackend.algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "CCDBFetcherPlugin", ctx);
-    extraSpecs.push_back(ccdbBackend);
+    extraSpecs.push_back(timePipeline(ccdbBackend, ctx.options().get<int64_t>("ccdb-fetchers")));
   } else if (requiresDISTSUBTIMEFRAME && enumCandidate != -1) {
     // add DSTF/ccdb source to the enumeration-driven source explicitly if it is required in the workflow
     DataSpecUtils::updateOutputList(workflow[enumCandidate].outputs, OutputSpec{{"ccdb-diststf"}, dstf, Lifetime::Timeframe});

From 2e6b8722d2d4b4926a03bdcd481222afe1641980 Mon Sep 17 00:00:00 2001
From: Piotr Konopka <piotr.jan.konopka@cern.ch>
Date: Thu, 19 Mar 2026 08:16:45 +0100
Subject: [PATCH 1449/1764] Correctly handle errors in merging histograms with
 kAverage (#15189)

As pointed out by Felix Schlepper, TH1::Add reports errors differently than Merge, see https://root.cern.ch/doc/master/classTH1.html#a6e3008f571628f0c9d17d754c8b88730

Fixes QC-1341.
---
 Utilities/Mergers/src/MergerAlgorithm.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Utilities/Mergers/src/MergerAlgorithm.cxx b/Utilities/Mergers/src/MergerAlgorithm.cxx
index 9395dd0a2b3f7..2cd09712e4a81 100644
--- a/Utilities/Mergers/src/MergerAlgorithm.cxx
+++ b/Utilities/Mergers/src/MergerAlgorithm.cxx
@@ -111,7 +111,7 @@ Long64_t mergeDefault(TObject* const target, TObject* const other)
       // Merge() does not support averages, we have to use Add()
       // this will break if collection.size != 1
       if (auto otherTH1 = dynamic_cast<TH1*>(otherCollection.First())) {
-        errorCode = targetTH1->Add(otherTH1);
+        errorCode = targetTH1->Add(otherTH1) == kFALSE ? -1 : 0;
       }
     } else {
       // Add() does not support histograms with labels, thus we resort to Merge() by default

From 20be6e73f6aaf46a30d3e2e21df455891c1f2167 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 19 Mar 2026 08:58:05 +0100
Subject: [PATCH 1450/1764] DPL: Better detection for injected workflows
 (#15130)

* detect tfnsource rather than the converter
* fix and update kine- and hepmc-publishers
* use detail instead of debug
---
 Framework/Core/src/ArrowSupport.cxx    |  8 ++-
 Framework/Core/src/WorkflowHelpers.cxx | 15 +++-
 run/o2sim_hepmc_publisher.cxx          | 94 +++++++++++++-------------
 run/o2sim_kine_publisher.cxx           |  3 +-
 run/o2sim_mctracks_to_aod.cxx          | 12 ++--
 5 files changed, 74 insertions(+), 58 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index c5cc021a53478..81acc26b1b097 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -680,8 +680,12 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
           workflow.erase(reader);
         } else {
           // load reader algorithm before deployment
-          auto mctracks2aod = std::find_if(workflow.begin(), workflow.end(), [](auto const& x) { return x.name == "mctracks-to-aod"; });
-          if (mctracks2aod == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
+          auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
+            return std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
+              return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
+            });
+          });
+          if (tfnsource == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
             reader->algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx));
           } // otherwise the algorithm was set in injectServiceDevices
         }
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index abe566e239618..2ef3df9426fde 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -411,13 +411,17 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   // add the reader
   if (aodReader.outputs.empty() == false) {
-    auto mctracks2aod = std::ranges::find_if(workflow, [](auto const& x) { return x.name == "mctracks-to-aod"; });
-    if (mctracks2aod == workflow.end()) {
+    auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
+      return std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
+        return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
+      });
+    });
+    if (tfnsource == workflow.end()) {
       // add normal reader
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
       aodReader.outputs.emplace_back(OutputSpec{"TFF", "TFFilename"});
     } else {
-      // AODs are being injected on-the-fly, add error-handler reader
+      // AODs are being injected the tfnsource is the entry point, add error-handler reader
       aodReader.algorithm = AlgorithmSpec{
         adaptStateful(
           [](DeviceSpec const& spec) {
@@ -700,6 +704,11 @@ void WorkflowHelpers::injectAODWriter(WorkflowSpec& workflow, ConfigContext cons
       return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
     });
     dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
+
+    it = std::find_if(dec.outputsInputs.begin(), dec.outputsInputs.end(), [](InputSpec const& spec) -> bool {
+      return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFF"));
+    });
+    dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
   }
 }
 
diff --git a/run/o2sim_hepmc_publisher.cxx b/run/o2sim_hepmc_publisher.cxx
index bf40abacb134f..f255b4a3a4f62 100644
--- a/run/o2sim_hepmc_publisher.cxx
+++ b/run/o2sim_hepmc_publisher.cxx
@@ -37,7 +37,9 @@ struct O2simHepmcPublisher {
   int tfCounter = 0;
   std::shared_ptr<HepMC3::Reader> hepMCReader;
   bool eos = false;
-  std::vector<o2::MCTrack> mcTracks;
+
+  std::vector<o2::pmr::vector<o2::MCTrack>*> mctracks_vector;
+  std::vector<o2::dataformats::MCEventHeader*> mcheader_vector;
 
   void init(o2::framework::InitContext& /*ic*/)
   {
@@ -50,13 +52,19 @@ struct O2simHepmcPublisher {
       LOGP(fatal, "Cannot open HEPMC kine file {}", (std::string)hepmcFileName);
     }
     // allocate the memory upfront to prevent reallocations later
-    mcTracks.reserve(1e3 * aggregate);
+    mctracks_vector.reserve(aggregate);
+    mcheader_vector.reserve(aggregate);
   }
 
   void run(o2::framework::ProcessingContext& pc)
   {
     HepMC3::GenEvent event;
-    for (auto i = 0; i < (int)aggregate; ++i) {
+    auto batch = maxEvents > 0 ? std::min((int)aggregate, (int)maxEvents - eventCounter) : (int)aggregate;
+    for (auto i = 0; i < batch; ++i) {
+      mctracks_vector.push_back(&pc.outputs().make<o2::pmr::vector<o2::MCTrack>>(Output{"MC", "MCTRACKS", 0}));
+      auto& mctracks = mctracks_vector.back();
+      mcheader_vector.push_back(&pc.outputs().make<o2::dataformats::MCEventHeader>(Output{"MC", "MCHEADER", 0}));
+      auto& mcheader = mcheader_vector.back();
       // read next entry
       hepMCReader->read_event(event);
       if (hepMCReader->failed()) {
@@ -66,61 +74,60 @@ struct O2simHepmcPublisher {
       }
 
       // create O2 MCHeader and MCtracks vector out of HEPMC event
-      o2::dataformats::MCEventHeader mcHeader;
-      mcHeader.SetEventID(event.event_number());
-      mcHeader.SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
+      mcheader->SetEventID(event.event_number());
+      mcheader->SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
       auto xsecInfo = event.cross_section();
       if (xsecInfo != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
-        mcHeader.putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
-        mcHeader.putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
-        mcHeader.putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
+        mcheader->putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
+        mcheader->putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
+        mcheader->putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
+        mcheader->putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
       }
       auto scale = event.attribute<HepMC3::DoubleAttribute>(MCInfoKeys::eventScale);
       if (scale != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::eventScale, (float)scale->value());
+        mcheader->putInfo(MCInfoKeys::eventScale, (float)scale->value());
       }
       auto nMPI = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::mpi);
       if (nMPI != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::mpi, nMPI->value());
+        mcheader->putInfo(MCInfoKeys::mpi, nMPI->value());
       }
       auto sid = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processCode);
       auto scode = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processID); // default pythia8 hepmc3 interface uses signal_process_id
       if (sid != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::processCode, sid->value());
+        mcheader->putInfo(MCInfoKeys::processCode, sid->value());
       } else if (scode != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::processCode, scode->value());
+        mcheader->putInfo(MCInfoKeys::processCode, scode->value());
       }
       auto pdfInfo = event.pdf_info();
       if (pdfInfo != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
-        mcHeader.putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
+        mcheader->putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
+        mcheader->putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
+        mcheader->putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
+        mcheader->putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
+        mcheader->putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
+        mcheader->putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
+        mcheader->putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
+        mcheader->putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
+        mcheader->putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
       }
       auto heavyIon = event.heavy_ion();
       if (heavyIon != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
-        mcHeader.putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
-        mcHeader.putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
-        mcHeader.putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
-        mcHeader.putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
-        mcHeader.putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
-        mcHeader.putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
-        mcHeader.putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
-        mcHeader.putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
-        mcHeader.putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
-        mcHeader.putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
-        mcHeader.putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
-        mcHeader.putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
-        mcHeader.putInfo("eccentricity", (float)heavyIon->eccentricity);
-        mcHeader.putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
-        mcHeader.putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
+        mcheader->putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
+        mcheader->putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
+        mcheader->putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
+        mcheader->putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
+        mcheader->putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
+        mcheader->putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
+        mcheader->putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
+        mcheader->putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
+        mcheader->putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
+        mcheader->putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
+        mcheader->putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
+        mcheader->putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
+        mcheader->putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
+        mcheader->putInfo("eccentricity", (float)heavyIon->eccentricity);
+        mcheader->putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
+        mcheader->putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
       }
 
       auto particles = event.particles();
@@ -131,7 +138,7 @@ struct O2simHepmcPublisher {
         auto has_children = children.size() > 0;
         auto p = particle->momentum();
         auto v = particle->production_vertex();
-        mcTracks.emplace_back(
+        mctracks->emplace_back(
           particle->pid(),
           has_parents ? parents.front()->id() : -1, has_parents ? parents.back()->id() : -1,
           has_children ? children.front()->id() : -1, has_children ? children.back()->id() : -1,
@@ -139,18 +146,13 @@ struct O2simHepmcPublisher {
           v->position().x(), v->position().y(), v->position().z(),
           v->position().t(), 0);
       }
-
-      // add to the message
-      pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcHeader);
-      pc.outputs().snapshot(Output{"MC", "MCTRACKS", 0}, mcTracks);
-      mcTracks.clear();
       ++eventCounter;
     }
 
     // report number of TFs injected for the rate limiter to work
     ++tfCounter;
     pc.services().get<o2::monitoring::Monitoring>().send(o2::monitoring::Metric{(uint64_t)tfCounter, "df-sent"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
-    if (eos || (maxEvents > 0 && eventCounter == maxEvents)) {
+    if (eos || (maxEvents > 0 && eventCounter >= maxEvents)) {
       pc.services().get<ControlService>().endOfStream();
       pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     }
diff --git a/run/o2sim_kine_publisher.cxx b/run/o2sim_kine_publisher.cxx
index cfbea6ae02a5f..5920743c3fafa 100644
--- a/run/o2sim_kine_publisher.cxx
+++ b/run/o2sim_kine_publisher.cxx
@@ -40,7 +40,8 @@ struct O2simKinePublisher {
 
   void run(o2::framework::ProcessingContext& pc)
   {
-    for (auto i = 0; i < std::min((int)aggregate, nEvents - eventCounter); ++i) {
+    auto batch = std::min((int)aggregate, nEvents - eventCounter);
+    for (auto i = 0; i < batch; ++i) {
       auto mcevent = mcKinReader->getMCEventHeader(0, eventCounter);
       auto mctracks = mcKinReader->getTracks(0, eventCounter);
       pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcevent);
diff --git a/run/o2sim_mctracks_to_aod.cxx b/run/o2sim_mctracks_to_aod.cxx
index 124e8aa7b3e42..d95a3b33cc38f 100644
--- a/run/o2sim_mctracks_to_aod.cxx
+++ b/run/o2sim_mctracks_to_aod.cxx
@@ -70,7 +70,7 @@ struct MctracksToAod {
   /** Run the conversion */
   void run(o2::framework::ProcessingContext& pc)
   {
-    LOG(debug) << "=== Running extended MC AOD exporter ===";
+    LOG(detail) << "=== Running extended MC AOD exporter ===";
     using namespace o2::aodmchelpers;
     using McHeader = o2::dataformats::MCEventHeader;
     using McTrack = o2::MCTrack;
@@ -94,13 +94,13 @@ struct MctracksToAod {
     // TODO: include BC simulation
     auto bcCounter = 0UL;
     size_t offset = 0;
-    LOG(debug) << "--- Loop over " << nParts << " parts ---";
+    LOG(detail) << "--- Loop over " << nParts << " parts ---";
     for (auto i = 0U; i < nParts; ++i) {
       auto record = mSampler.generateCollisionTime();
       auto header = pc.inputs().get<McHeader*>("mcheader", i);
       auto tracks = pc.inputs().get<McTracks>("mctracks", i);
 
-      LOG(debug) << "Updating collision table";
+      LOG(detail) << "Updating collision table";
       auto genID = updateMCCollisions(mCollisions.cursor,
                                       bcCounter,
                                       record.timeInBCNS * 1.e-3,
@@ -108,12 +108,12 @@ struct MctracksToAod {
                                       0,
                                       i);
 
-      LOG(debug) << "Updating HepMC tables";
+      LOG(detail) << "Updating HepMC tables";
       updateHepMCXSection(mXSections.cursor, bcCounter, genID, *header);
       updateHepMCPdfInfo(mPdfInfos.cursor, bcCounter, genID, *header);
       updateHepMCHeavyIon(mHeavyIons.cursor, bcCounter, genID, *header);
 
-      LOG(debug) << "Updating particles table";
+      LOG(detail) << "Updating particles table";
       TrackToIndex preselect;
       offset = updateParticles(mParticles.cursor,
                                bcCounter,
@@ -123,7 +123,7 @@ struct MctracksToAod {
                                (bool)filt,
                                false);
 
-      LOG(debug) << "Increment BC counter";
+      LOG(detail) << "Increment BC counter";
       bcCounter++;
     }
 

From d2e721631fc6cbee151340f049e4bbdfd1c4d5e4 Mon Sep 17 00:00:00 2001
From: wiechula <11199190+wiechula@users.noreply.github.com>
Date: Thu, 19 Mar 2026 14:43:56 +0100
Subject: [PATCH 1451/1764] TPC: Implement ad-hoc correction for r and z in old
 SCD map creation (#15103)

* Implement ad-hoc correction for r and z

* fix warning: usage of abs instead of std::abs
---
 .../include/SpacePoints/TrackResiduals.h      |  8 +++++++
 .../SpacePoints/src/TrackInterpolation.cxx    |  4 ++--
 .../SpacePoints/src/TrackResiduals.cxx        | 22 +++++++++++++++++--
 3 files changed, 30 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h
index e4d0a3a053728..2ade12d951c58 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h
@@ -443,6 +443,12 @@ class TrackResiduals
   /// output tree
   TTree* getOutputTree() { return mTreeOut.get(); }
 
+  /// Ad-hoc radial scaling factor A/C-Side
+  void setAdhocScalingFactorX(const std::array<float, 2>& scaling) { mAdhocScalingX = scaling; }
+
+  /// Ad-hoc correction of Z/X
+  void doAdhocCorrectionZ2X(bool corr) { mDoAdhocCorrectionZ2X = corr; }
+
  private:
   std::bitset<SECTORSPERSIDE * SIDES> mInitResultsContainer{};
 
@@ -502,6 +508,8 @@ class TrackResiduals
   std::array<std::vector<VoxRes>, SECTORSPERSIDE * SIDES> mVoxelResults{};                  ///< results per sector and per voxel for 3-D distortions
   VoxRes mVoxelResultsOut{};                                                                ///< the results from mVoxelResults are copied in here to be able to stream them
   VoxRes* mVoxelResultsOutPtr{&mVoxelResultsOut};                                           ///< pointer to set the branch address to for the output
+  std::array<float, 2> mAdhocScalingX{0, 0};                                                ///< Ad-hoc radial scaling factor
+  bool mDoAdhocCorrectionZ2X{false};                                                        ///< If to do ad-hoc correction for Z/X
 
   ClassDefNV(TrackResiduals, 3);
 };
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
index 539ae25862865..76daab93dd8e0 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackInterpolation.cxx
@@ -820,7 +820,7 @@ void TrackInterpolation::interpolateTrack(int iSeed)
           float xv = vtx.X() * cs + vtx.Y() * sn, yv = -vtx.X() * sn + vtx.Y() * cs, zv = vtx.Z();
           auto dy = yv - trkWorkITS.getY();
           auto dz = zv - trkWorkITS.getZ();
-          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && abs(xv) < param::MaxVtxX) {
+          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && std::abs(xv) < param::MaxVtxX) {
             short compXV = static_cast<short>(xv * 0x7fff / param::MaxVtxX);
             mClRes.emplace_back(dy, dz, alpha / TMath::Pi(), trkWorkITS.getY(), trkWorkITS.getZ(), 190, -1, compXV);
             if (!gidTable[GTrackID::ITSTPC].isIndexSet()) {
@@ -1168,7 +1168,7 @@ void TrackInterpolation::extrapolateTrack(int iSeed)
           float xv = vtx.X() * cs + vtx.Y() * sn, yv = -vtx.X() * sn + vtx.Y() * cs, zv = vtx.Z();
           auto dy = yv - trkWorkITS.getY();
           auto dz = zv - trkWorkITS.getZ();
-          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && abs(xv) < param::MaxVtxX) {
+          if ((std::abs(dy) < param::MaxResid) && (std::abs(dz) < param::MaxResid) && (std::abs(trkWorkITS.getY()) < param::MaxY) && (std::abs(trkWorkITS.getZ()) < param::MaxZ) && std::abs(xv) < param::MaxVtxX) {
             short compXV = static_cast<short>(xv * 0x7fff / param::MaxVtxX);
             mClRes.emplace_back(dy, dz, alpha / TMath::Pi(), trkWorkITS.getY(), trkWorkITS.getZ(), 190, -1, compXV);
             if (!gidTableFull[GTrackID::ITSTPC].isIndexSet()) {
diff --git a/Detectors/TPC/calibration/SpacePoints/src/TrackResiduals.cxx b/Detectors/TPC/calibration/SpacePoints/src/TrackResiduals.cxx
index 45d7a6ae3c231..d3db11daf9e87 100644
--- a/Detectors/TPC/calibration/SpacePoints/src/TrackResiduals.cxx
+++ b/Detectors/TPC/calibration/SpacePoints/src/TrackResiduals.cxx
@@ -719,8 +719,26 @@ void TrackResiduals::smooth(int iSec)
         if (!(resVox.flags & SmoothDone)) {
           continue;
         }
-        resVox.DS[ResZ] += resVox.stat[VoxZ] * resVox.DS[ResX]; // remove slope*dX contribution from dZ
-        resVox.D[ResZ] += resVox.stat[VoxZ] * resVox.DS[ResX];  // remove slope*dX contribution from dZ
+        // TODO: Usage of Z/X is bug???
+        float z2x = resVox.stat[VoxZ];
+        if (mDoAdhocCorrectionZ2X) {
+          //
+          const float z = z2x * resVox.stat[VoxX] - resVox.DS[ResZ];
+          const float x = resVox.stat[VoxX] - resVox.DS[ResX]; // is subration of DS[ResX] correct?
+          z2x = z / x;
+        }
+        resVox.DS[ResZ] += z2x * resVox.DS[ResX]; // remove slope*dX contribution from dZ
+        resVox.D[ResZ] += z2x * resVox.DS[ResX];  // remove slope*dX contribution from dZ
+                                                  //
+        if (mAdhocScalingX[iSec >= 18] != 0) {
+          const float aDX = resVox.DS[ResX] * mAdhocScalingX[iSec >= 18];
+          resVox.D[ResX] += aDX;
+          resVox.DS[ResX] += aDX;
+          resVox.D[ResY] += aDX * resVox.stat[VoxF];
+          resVox.DS[ResY] += aDX * resVox.stat[VoxF];
+          resVox.D[ResZ] += aDX * z2x;
+          resVox.DS[ResZ] += aDX * z2x;
+        }
       }
     }
   }

From f67af9e4329d828dc094cd99b5bce638087fa329 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Thu, 19 Mar 2026 10:45:18 +0100
Subject: [PATCH 1452/1764] Change default calibration interval to 5min

---
 .../tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
index 4912a1df36a33..4f17aec3d49d5 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/TPCInterpolationSpec.cxx
@@ -206,7 +206,7 @@ DataProcessorSpec getTPCInterpolationSpec(GTrackID::mask_t srcCls, GTrackID::mas
     AlgorithmSpec{adaptFromTask<TPCInterpolationDPL>(dataRequest, srcTrk, srcTrkMap, ggRequest, useMC, processITSTPConly, sendTrackData, debugOutput, extDetResid)},
     Options{
       {"matCorrType", VariantType::Int, 2, {"material correction type (definition in Propagator.h)"}},
-      {"sec-per-slot", VariantType::UInt32, 600u, {"number of seconds per calibration time slot (put 0 for infinite slot length)"}},
+      {"sec-per-slot", VariantType::UInt32, 300u, {"number of seconds per calibration time slot (put 0 for infinite slot length)"}},
       {"process-seeds", VariantType::Bool, false, {"do not remove duplicates, e.g. for ITS-TPC-TRD track also process its seeding ITS-TPC part"}}}};
 }
 

From ae084c77dca4654de4ad2d8a6a3b78aadef8df1e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 20 Mar 2026 09:00:36 +0100
Subject: [PATCH 1453/1764] Revert "DPL: Better detection for injected
 workflows (#15130)" (#15197)

This reverts commit 20be6e73f6aaf46a30d3e2e21df455891c1f2167.
---
 Framework/Core/src/ArrowSupport.cxx    |  8 +--
 Framework/Core/src/WorkflowHelpers.cxx | 15 +---
 run/o2sim_hepmc_publisher.cxx          | 94 +++++++++++++-------------
 run/o2sim_kine_publisher.cxx           |  3 +-
 run/o2sim_mctracks_to_aod.cxx          | 12 ++--
 5 files changed, 58 insertions(+), 74 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 81acc26b1b097..c5cc021a53478 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -680,12 +680,8 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
           workflow.erase(reader);
         } else {
           // load reader algorithm before deployment
-          auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
-            return std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
-              return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
-            });
-          });
-          if (tfnsource == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
+          auto mctracks2aod = std::find_if(workflow.begin(), workflow.end(), [](auto const& x) { return x.name == "mctracks-to-aod"; });
+          if (mctracks2aod == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
             reader->algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx));
           } // otherwise the algorithm was set in injectServiceDevices
         }
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 2ef3df9426fde..abe566e239618 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -411,17 +411,13 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   // add the reader
   if (aodReader.outputs.empty() == false) {
-    auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
-      return std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
-        return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
-      });
-    });
-    if (tfnsource == workflow.end()) {
+    auto mctracks2aod = std::ranges::find_if(workflow, [](auto const& x) { return x.name == "mctracks-to-aod"; });
+    if (mctracks2aod == workflow.end()) {
       // add normal reader
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
       aodReader.outputs.emplace_back(OutputSpec{"TFF", "TFFilename"});
     } else {
-      // AODs are being injected the tfnsource is the entry point, add error-handler reader
+      // AODs are being injected on-the-fly, add error-handler reader
       aodReader.algorithm = AlgorithmSpec{
         adaptStateful(
           [](DeviceSpec const& spec) {
@@ -704,11 +700,6 @@ void WorkflowHelpers::injectAODWriter(WorkflowSpec& workflow, ConfigContext cons
       return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
     });
     dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
-
-    it = std::find_if(dec.outputsInputs.begin(), dec.outputsInputs.end(), [](InputSpec const& spec) -> bool {
-      return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFF"));
-    });
-    dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
   }
 }
 
diff --git a/run/o2sim_hepmc_publisher.cxx b/run/o2sim_hepmc_publisher.cxx
index f255b4a3a4f62..bf40abacb134f 100644
--- a/run/o2sim_hepmc_publisher.cxx
+++ b/run/o2sim_hepmc_publisher.cxx
@@ -37,9 +37,7 @@ struct O2simHepmcPublisher {
   int tfCounter = 0;
   std::shared_ptr<HepMC3::Reader> hepMCReader;
   bool eos = false;
-
-  std::vector<o2::pmr::vector<o2::MCTrack>*> mctracks_vector;
-  std::vector<o2::dataformats::MCEventHeader*> mcheader_vector;
+  std::vector<o2::MCTrack> mcTracks;
 
   void init(o2::framework::InitContext& /*ic*/)
   {
@@ -52,19 +50,13 @@ struct O2simHepmcPublisher {
       LOGP(fatal, "Cannot open HEPMC kine file {}", (std::string)hepmcFileName);
     }
     // allocate the memory upfront to prevent reallocations later
-    mctracks_vector.reserve(aggregate);
-    mcheader_vector.reserve(aggregate);
+    mcTracks.reserve(1e3 * aggregate);
   }
 
   void run(o2::framework::ProcessingContext& pc)
   {
     HepMC3::GenEvent event;
-    auto batch = maxEvents > 0 ? std::min((int)aggregate, (int)maxEvents - eventCounter) : (int)aggregate;
-    for (auto i = 0; i < batch; ++i) {
-      mctracks_vector.push_back(&pc.outputs().make<o2::pmr::vector<o2::MCTrack>>(Output{"MC", "MCTRACKS", 0}));
-      auto& mctracks = mctracks_vector.back();
-      mcheader_vector.push_back(&pc.outputs().make<o2::dataformats::MCEventHeader>(Output{"MC", "MCHEADER", 0}));
-      auto& mcheader = mcheader_vector.back();
+    for (auto i = 0; i < (int)aggregate; ++i) {
       // read next entry
       hepMCReader->read_event(event);
       if (hepMCReader->failed()) {
@@ -74,60 +66,61 @@ struct O2simHepmcPublisher {
       }
 
       // create O2 MCHeader and MCtracks vector out of HEPMC event
-      mcheader->SetEventID(event.event_number());
-      mcheader->SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
+      o2::dataformats::MCEventHeader mcHeader;
+      mcHeader.SetEventID(event.event_number());
+      mcHeader.SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
       auto xsecInfo = event.cross_section();
       if (xsecInfo != nullptr) {
-        mcheader->putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
-        mcheader->putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
-        mcheader->putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
-        mcheader->putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
+        mcHeader.putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
+        mcHeader.putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
+        mcHeader.putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
+        mcHeader.putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
       }
       auto scale = event.attribute<HepMC3::DoubleAttribute>(MCInfoKeys::eventScale);
       if (scale != nullptr) {
-        mcheader->putInfo(MCInfoKeys::eventScale, (float)scale->value());
+        mcHeader.putInfo(MCInfoKeys::eventScale, (float)scale->value());
       }
       auto nMPI = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::mpi);
       if (nMPI != nullptr) {
-        mcheader->putInfo(MCInfoKeys::mpi, nMPI->value());
+        mcHeader.putInfo(MCInfoKeys::mpi, nMPI->value());
       }
       auto sid = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processCode);
       auto scode = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processID); // default pythia8 hepmc3 interface uses signal_process_id
       if (sid != nullptr) {
-        mcheader->putInfo(MCInfoKeys::processCode, sid->value());
+        mcHeader.putInfo(MCInfoKeys::processCode, sid->value());
       } else if (scode != nullptr) {
-        mcheader->putInfo(MCInfoKeys::processCode, scode->value());
+        mcHeader.putInfo(MCInfoKeys::processCode, scode->value());
       }
       auto pdfInfo = event.pdf_info();
       if (pdfInfo != nullptr) {
-        mcheader->putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
-        mcheader->putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
-        mcheader->putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
-        mcheader->putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
-        mcheader->putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
-        mcheader->putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
-        mcheader->putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
-        mcheader->putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
-        mcheader->putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
+        mcHeader.putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
+        mcHeader.putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
+        mcHeader.putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
+        mcHeader.putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
+        mcHeader.putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
+        mcHeader.putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
+        mcHeader.putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
+        mcHeader.putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
+        mcHeader.putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
       }
       auto heavyIon = event.heavy_ion();
       if (heavyIon != nullptr) {
-        mcheader->putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
-        mcheader->putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
-        mcheader->putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
-        mcheader->putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
-        mcheader->putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
-        mcheader->putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
-        mcheader->putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
-        mcheader->putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
-        mcheader->putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
-        mcheader->putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
-        mcheader->putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
-        mcheader->putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
-        mcheader->putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
-        mcheader->putInfo("eccentricity", (float)heavyIon->eccentricity);
-        mcheader->putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
-        mcheader->putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
+        mcHeader.putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
+        mcHeader.putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
+        mcHeader.putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
+        mcHeader.putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
+        mcHeader.putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
+        mcHeader.putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
+        mcHeader.putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
+        mcHeader.putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
+        mcHeader.putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
+        mcHeader.putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
+        mcHeader.putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
+        mcHeader.putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
+        mcHeader.putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
+        mcHeader.putInfo("eccentricity", (float)heavyIon->eccentricity);
+        mcHeader.putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
+        mcHeader.putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
       }
 
       auto particles = event.particles();
@@ -138,7 +131,7 @@ struct O2simHepmcPublisher {
         auto has_children = children.size() > 0;
         auto p = particle->momentum();
         auto v = particle->production_vertex();
-        mctracks->emplace_back(
+        mcTracks.emplace_back(
           particle->pid(),
           has_parents ? parents.front()->id() : -1, has_parents ? parents.back()->id() : -1,
           has_children ? children.front()->id() : -1, has_children ? children.back()->id() : -1,
@@ -146,13 +139,18 @@ struct O2simHepmcPublisher {
           v->position().x(), v->position().y(), v->position().z(),
           v->position().t(), 0);
       }
+
+      // add to the message
+      pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcHeader);
+      pc.outputs().snapshot(Output{"MC", "MCTRACKS", 0}, mcTracks);
+      mcTracks.clear();
       ++eventCounter;
     }
 
     // report number of TFs injected for the rate limiter to work
     ++tfCounter;
     pc.services().get<o2::monitoring::Monitoring>().send(o2::monitoring::Metric{(uint64_t)tfCounter, "df-sent"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
-    if (eos || (maxEvents > 0 && eventCounter >= maxEvents)) {
+    if (eos || (maxEvents > 0 && eventCounter == maxEvents)) {
       pc.services().get<ControlService>().endOfStream();
       pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     }
diff --git a/run/o2sim_kine_publisher.cxx b/run/o2sim_kine_publisher.cxx
index 5920743c3fafa..cfbea6ae02a5f 100644
--- a/run/o2sim_kine_publisher.cxx
+++ b/run/o2sim_kine_publisher.cxx
@@ -40,8 +40,7 @@ struct O2simKinePublisher {
 
   void run(o2::framework::ProcessingContext& pc)
   {
-    auto batch = std::min((int)aggregate, nEvents - eventCounter);
-    for (auto i = 0; i < batch; ++i) {
+    for (auto i = 0; i < std::min((int)aggregate, nEvents - eventCounter); ++i) {
       auto mcevent = mcKinReader->getMCEventHeader(0, eventCounter);
       auto mctracks = mcKinReader->getTracks(0, eventCounter);
       pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcevent);
diff --git a/run/o2sim_mctracks_to_aod.cxx b/run/o2sim_mctracks_to_aod.cxx
index d95a3b33cc38f..124e8aa7b3e42 100644
--- a/run/o2sim_mctracks_to_aod.cxx
+++ b/run/o2sim_mctracks_to_aod.cxx
@@ -70,7 +70,7 @@ struct MctracksToAod {
   /** Run the conversion */
   void run(o2::framework::ProcessingContext& pc)
   {
-    LOG(detail) << "=== Running extended MC AOD exporter ===";
+    LOG(debug) << "=== Running extended MC AOD exporter ===";
     using namespace o2::aodmchelpers;
     using McHeader = o2::dataformats::MCEventHeader;
     using McTrack = o2::MCTrack;
@@ -94,13 +94,13 @@ struct MctracksToAod {
     // TODO: include BC simulation
     auto bcCounter = 0UL;
     size_t offset = 0;
-    LOG(detail) << "--- Loop over " << nParts << " parts ---";
+    LOG(debug) << "--- Loop over " << nParts << " parts ---";
     for (auto i = 0U; i < nParts; ++i) {
       auto record = mSampler.generateCollisionTime();
       auto header = pc.inputs().get<McHeader*>("mcheader", i);
       auto tracks = pc.inputs().get<McTracks>("mctracks", i);
 
-      LOG(detail) << "Updating collision table";
+      LOG(debug) << "Updating collision table";
       auto genID = updateMCCollisions(mCollisions.cursor,
                                       bcCounter,
                                       record.timeInBCNS * 1.e-3,
@@ -108,12 +108,12 @@ struct MctracksToAod {
                                       0,
                                       i);
 
-      LOG(detail) << "Updating HepMC tables";
+      LOG(debug) << "Updating HepMC tables";
       updateHepMCXSection(mXSections.cursor, bcCounter, genID, *header);
       updateHepMCPdfInfo(mPdfInfos.cursor, bcCounter, genID, *header);
       updateHepMCHeavyIon(mHeavyIons.cursor, bcCounter, genID, *header);
 
-      LOG(detail) << "Updating particles table";
+      LOG(debug) << "Updating particles table";
       TrackToIndex preselect;
       offset = updateParticles(mParticles.cursor,
                                bcCounter,
@@ -123,7 +123,7 @@ struct MctracksToAod {
                                (bool)filt,
                                false);
 
-      LOG(detail) << "Increment BC counter";
+      LOG(debug) << "Increment BC counter";
       bcCounter++;
     }
 

From 70ca1a2fe8ac4e4bd86ad363541b63f749d96208 Mon Sep 17 00:00:00 2001
From: Fabio Colamaria <fabio.colamaria@ba.infn.it>
Date: Fri, 20 Mar 2026 14:32:41 +0100
Subject: [PATCH 1454/1764] [ALICE3] Updated ALICE 3 IRIS coldplate in O2
 geometry (#15198)

* Updated ALICE 3 IRIS coldplate in O2 geometry

* Please consider the following formatting changes

---------

Co-authored-by: fcolamar <fabio.colamaria@cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx  | 2 +-
 .../Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 0394c59780141..d8246bcd8640c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -108,7 +108,7 @@ void TRKServices::createMaterials()
   matmgr.Material("ALICE3_TRKSERVICES", 73, "BERYLLIUM", 9.01, 4., 1.848, 35.3, 36.7);                                                 // Beryllium - Candidate for IRIS vacuum vessel
   matmgr.Mixture("ALICE3_TRKSERVICES", 74, "ALUMINIUM5083", aAl5083, zAl5083, dAl5083, 9, wAl5083);                                    // AL5083 - Candidate for IRIS vacuum vessel
   matmgr.Mixture("ALICE3_TRKSERVICES", 75, "ALUMINIUMBERYLLIUMMETAL", aAlBeMet, zAlBeMet, dAlBeMet, 2, wAlBeMet);                      // Aluminium-Beryllium metal - Candidate for IRIS vacuum vessel
-  matmgr.Material("ALICE3_TRKSERVICES", 76, "CARBONFIBERM55J6K", 12.0107, 6, 1.92, 999, 999);                                          // Carbon Fiber M55J
+  matmgr.Material("ALICE3_TRKSERVICES", 76, "CARBONFIBERM55J6K", 12.0107, 6, 1.92, 22.4, 999);                                         // Carbon Fiber M55J
   matmgr.Mixture("ALICE3_PIPE", 77, "VACUUM", aAir, zAir, dAir1, 4, wAir);
 
   matmgr.Medium("ALICE3_TRKSERVICES", 1, "CERAMIC", 66, 0, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);                  // Ceramic for cold plate
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
index 2f1a83f73bca3..809923b048234 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/VDGeometryBuilder.cxx
@@ -272,8 +272,8 @@ static constexpr double kInclinedWallPhi0_deg = 27.799f;
 static constexpr double kInclinedWallRmax_cm = 4.75f; // 47.5 mm outer extension
 
 // Coldplate specs (cm)
-static constexpr double kColdplateRadius_cm = 2.6f;     // 26 mm (outer radius)
-static constexpr double kColdplateThickness_cm = 0.15f; // 1.5 mm
+static constexpr double kColdplateRadius_cm = 2.6f;     // 26 mm (inner radius)
+static constexpr double kColdplateThickness_cm = 0.02f; // 1.5 mm
 static constexpr double kColdplateZ_cm = 50.0f;         // full length
 
 // ========== φ-span helpers (gap/arc → degrees) ==========

From 43a3732a0f85f14a5795d7831cff5095903935da Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Fri, 20 Mar 2026 13:40:22 +0100
Subject: [PATCH 1455/1764] AODProducer: Option to specify and forward parent
 AOD file

This is needed in order to link a MC-AOD as "derived" from another
AOD, for instance for MC-on-DATA embeddings.
---
 .../AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h | 1 +
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx                 | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 588cd575ee7f5..c03c00f977648 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -283,6 +283,7 @@ class AODProducerWorkflowDPL : public Task
   TString mAnchorPass{""};
   TString mAnchorProd{""};
   TString mRecoPass{""};
+  std::string mAODParent{""}; // link to possible parent AOD file (MC embedding,...)
   TString mUser{"aliprod"}; // who created this AOD (aliprod, alidaq, individual users)
   TStopwatch mTimer;
   bool mEMCselectLeading{false};
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index fcb419d6c441b..80b9e6ef4b551 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -1818,6 +1818,7 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
   mAnchorProd = ic.options().get<std::string>("anchor-prod");
   mUser = ic.options().get<std::string>("created-by");
   mRecoPass = ic.options().get<std::string>("reco-pass");
+  mAODParent = ic.options().get<std::string>("aod-parent");
   mTFNumber = ic.options().get<int64_t>("aod-timeframe-id");
   mRecoOnly = ic.options().get<int>("reco-mctracks-only");
   mTruncate = ic.options().get<int>("enable-truncation");
@@ -2615,7 +2616,7 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
   pc.outputs().snapshot(Output{"AMD", "AODMetadataVals", 0}, mMetaDataVals);
 
   pc.outputs().snapshot(Output{"TFN", "TFNumber", 0}, tfNumber);
-  pc.outputs().snapshot(Output{"TFF", "TFFilename", 0}, "");
+  pc.outputs().snapshot(Output{"TFF", "TFFilename", 0}, mAODParent);
 
   mTimer.Stop();
 }
@@ -3485,6 +3486,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"anchor-pass", VariantType::String, "", {"AnchorPassName"}},
       ConfigParamSpec{"anchor-prod", VariantType::String, "", {"AnchorProduction"}},
       ConfigParamSpec{"reco-pass", VariantType::String, "", {"RecoPassName"}},
+      ConfigParamSpec{"aod-parent", VariantType::String, "", {"Parent AOD file name (if any)"}},
       ConfigParamSpec{"created-by", VariantType::String, "", {"Who created this AO2D"}},
       ConfigParamSpec{"nthreads", VariantType::Int, std::max(1, int(std::thread::hardware_concurrency() / 2)), {"Number of threads"}},
       ConfigParamSpec{"reco-mctracks-only", VariantType::Int, 0, {"Store only reconstructed MC tracks and their mothers/daughters. 0 -- off, != 0 -- on"}},

From 859d892adf57752d6858b51372e61e7e16db35e4 Mon Sep 17 00:00:00 2001
From: wiechula <Jens.Wiechula@cern.ch>
Date: Thu, 19 Mar 2026 14:48:28 +0100
Subject: [PATCH 1456/1764] Add missing include for gcc 15.2

---
 GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
index a1bee6ce47ebd..506cef9db7248 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendVulkan.cxx
@@ -23,6 +23,7 @@ VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE
 #include "GPUParam.h"
 
 #include <mutex>
+#include <iostream>
 
 using namespace o2::gpu;
 

From d17d862c1c8f64e12ea96bbb9f5adf74618922e5 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Sat, 21 Mar 2026 07:38:43 +0100
Subject: [PATCH 1457/1764] Fix MLOT digit residuals (#15200)

---
 .../ALICE3/TRK/macros/test/CheckDigits.C      | 36 ++++++++++++++++---
 1 file changed, 32 insertions(+), 4 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
index 618dbe929a943..ec1adf500f562 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
@@ -31,6 +31,8 @@
 #include "SimulationDataFormat/IOMCTruthContainerView.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "DetectorsBase/GeometryManager.h"
+#include "ITSMFTSimulation/AlpideSimResponse.h"
+#include "CCDB/BasicCCDBManager.h"
 
 #include "DataFormatsITSMFT/ROFRecord.h"
 
@@ -98,6 +100,15 @@ void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile =
   SegmentationChip seg;
   // seg.Print();
 
+  // MLOT response plane: y = halfThickness - depthMax.
+  float depthMax = (float)o2::trk::constants::apts::thickness; // fallback (no CCDB)
+  auto& ccdbMgr = o2::ccdb::BasicCCDBManager::instance();
+  ccdbMgr.setURL("http://alice-ccdb.cern.ch");
+  if (auto* alpResp = ccdbMgr.get<o2::itsmft::AlpideSimResponse>("IT3/Calib/APTSResponse")) {
+    depthMax = alpResp->getDepthMax();
+  }
+  const float yPlaneMLOT = o2::trk::SegmentationChip::SiliconThicknessMLOT / 2.f - depthMax;
+  const float yPlaneVD = -o2::trk::SegmentationChip::SiliconThicknessVD; // VD reference plane in local flat y
   // Hits
   TFile* hitFile = TFile::Open(hitfile.data());
   TTree* hitTree = (TTree*)hitFile->Get("o2sim");
@@ -254,23 +265,40 @@ void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile =
       auto xyzLocE = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
       auto xyzLocS = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
 
-      o2::math_utils::Vector3D<float> locH; /// Hit, average between start and end pos
-      locH.SetCoordinates(0.5f * (xyzLocE.X() + xyzLocS.X()), 0.5f * (xyzLocE.Y() + xyzLocS.Y()), 0.5f * (xyzLocE.Z() + xyzLocS.Z()));
+      // Hit local reference: Both VD and MLOT use response-plane interpolation (in flat local frame).
+      // For VD, transform curved → flat first, then interpolate.
+      o2::math_utils::Vector3D<float> locH;  /// Hit reference (at response plane)
       o2::math_utils::Vector3D<float> locHS; /// Hit, start pos
       locHS.SetCoordinates(xyzLocS.X(), xyzLocS.Y(), xyzLocS.Z());
       o2::math_utils::Vector3D<float> locHE; /// Hit, end pos
       locHE.SetCoordinates(xyzLocE.X(), xyzLocE.Y(), xyzLocE.Z());
       o2::math_utils::Vector3D<float> locHF;
 
+      if (subDetID == 0) {
+        // VD: Interpolate to VD reference plane in flat frame; apply same r to X and Z
+        auto flatSta = seg.curvedToFlat(layer, locHS.X(), locHS.Y());
+        auto flatEnd = seg.curvedToFlat(layer, locHE.X(), locHE.Y());
+        float x0 = flatSta.X(), y0 = flatSta.Y(), z0 = locHS.Z();
+        float dltx = flatEnd.X() - x0, dlty = flatEnd.Y() - y0, dltz = locHE.Z() - z0;
+        float r = (std::abs(dlty) > 1e-9f) ? (yPlaneVD - y0) / dlty : 0.5f;
+        locH.SetCoordinates(x0 + r * dltx, yPlaneVD, z0 + r * dltz);
+      } else {
+        // MLOT: Interpolate to response plane
+        float x0 = locHS.X(), y0 = locHS.Y(), z0 = locHS.Z();
+        float dltx = locHE.X() - x0, dlty = locHE.Y() - y0, dltz = locHE.Z() - z0;
+        float r = (std::abs(dlty) > 1e-9f) ? (yPlaneMLOT - y0) / dlty : 0.5f;
+        locH.SetCoordinates(x0 + r * dltx, yPlaneMLOT, z0 + r * dltz);
+      }
+
       int row = 0, col = 0;
       float xlc = 0., zlc = 0.;
 
       if (subDetID == 0) {
         Float_t x_flat = 0.f, y_flat = 0.f;
-        o2::math_utils::Vector2D<float> xyFlatH = seg.curvedToFlat(layer, locH.X(), locH.Y());
+        // locH is already in flat frame from interpolation above; convert digit to flat for comparison
         o2::math_utils::Vector2D<float> xyFlatD = seg.curvedToFlat(layer, locD.X(), locD.Y());
         locDF.SetCoordinates(xyFlatD.X(), xyFlatD.Y(), locD.Z());
-        locHF.SetCoordinates(xyFlatH.X(), xyFlatH.Y(), locH.Z());
+        locHF.SetCoordinates(locH.X(), locH.Y(), locH.Z()); // locH already in flat frame
         seg.localToDetector(locHF.X(), locHF.Z(), row, col, subDetID, layer, disk);
       }
 

From 909c5f9a70041c79be4260cba857410814613784 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 21 Mar 2026 09:42:31 +0100
Subject: [PATCH 1458/1764] DPL: propaedeutic to navigate a MessageSet without
 caching pairs (#15187)

All this should be fairly straight forward changes while still preserving
the old API. If something fails at this level it means that even the counting
of dataset changes with this included, which it should not be.
---
 .../Core/include/Framework/DataModelViews.h   |   7 +-
 Framework/Core/include/Framework/MessageSet.h |  22 +--
 Framework/Core/test/test_MessageSet.cxx       | 168 +++++++++++-------
 3 files changed, 115 insertions(+), 82 deletions(-)

diff --git a/Framework/Core/include/Framework/DataModelViews.h b/Framework/Core/include/Framework/DataModelViews.h
index b7a334454bb6e..f42ef85ec78e1 100644
--- a/Framework/Core/include/Framework/DataModelViews.h
+++ b/Framework/Core/include/Framework/DataModelViews.h
@@ -206,15 +206,10 @@ struct get_num_payloads {
 
 struct MessageSet;
 
-struct MessageStore {
-  std::span<MessageSet> sets;
-  size_t inputsPerSlot = 0;
-};
-
 struct inputs_for_slot {
   TimesliceSlot slot;
   template <typename R>
-    requires requires(R r) { std::ranges::random_access_range<decltype(r.sets)>; }
+    requires requires(R r) { requires std::ranges::random_access_range<decltype(r.sets)>; }
   friend std::span<o2::framework::MessageSet> operator|(R&& r, inputs_for_slot self)
   {
     return std::span(r.sets[self.slot.index * r.inputsPerSlot]);
diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index e7ae70e0ea2e5..281f9c42a0773 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -12,13 +12,13 @@
 #define FRAMEWORK_MESSAGESET_H
 
 #include "Framework/PartRef.h"
+#include <fairmq/Message.h>
+#include "Framework/DataModelViews.h"
 #include <memory>
 #include <vector>
 #include <cassert>
 
-namespace o2
-{
-namespace framework
+namespace o2::framework
 {
 
 /// A set of inflight messages.
@@ -83,21 +83,21 @@ struct MessageSet {
   }
 
   /// get number of in-flight O2 messages
-  size_t size() const
+  [[nodiscard]] size_t size() const
   {
-    return messageMap.size();
+    return messages | count_parts{};
   }
 
   /// get number of header-payload pairs
-  size_t getNumberOfPairs() const
+  [[nodiscard]] size_t getNumberOfPairs() const
   {
-    return pairMap.size();
+    return messages | count_payloads{};
   }
 
   /// get number of payloads for an in-flight message
-  size_t getNumberOfPayloads(size_t mi) const
+  [[nodiscard]] size_t getNumberOfPayloads(size_t mi) const
   {
-    return messageMap[mi].size;
+    return messages | get_num_payloads{mi};
   }
 
   /// clear the set
@@ -179,6 +179,6 @@ struct MessageSet {
   }
 };
 
-} // namespace framework
-} // namespace o2
+} // namespace o2::framework
+
 #endif // FRAMEWORK_MESSAGESET_H
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index d56e32fea1adb..37f823197ef18 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -10,126 +10,164 @@
 // or submit itself to any jurisdiction.
 
 #include <fairmq/Message.h>
+#include <fairmq/TransportFactory.h>
 #include "Framework/MessageSet.h"
+#include "Framework/DataProcessingHeader.h"
+#include "Headers/Stack.h"
+#include "MemoryResources/MemoryResources.h"
 #include <catch_amalgamated.hpp>
 
 using namespace o2::framework;
 
-TEST_CASE("MessageSet") {
+TEST_CASE("MessageSet")
+{
   o2::framework::MessageSet msgSet;
-  std::vector<fair::mq::MessagePtr> ptrs;
-  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  o2::header::DataHeader dh{};
+  dh.splitPayloadParts = 0;
+  dh.splitPayloadIndex = 0;
+  o2::framework::DataProcessingHeader dph{0, 1};
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  fair::mq::MessagePtr header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
   std::unique_ptr<fair::mq::Message> msg2(nullptr);
-  ptrs.emplace_back(std::move(msg));
+  std::vector<fair::mq::MessagePtr> ptrs;
+  ptrs.emplace_back(std::move(header));
   ptrs.emplace_back(std::move(msg2));
   msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
 
   REQUIRE(msgSet.messages.size() == 2);
-  REQUIRE(msgSet.messageMap.size() == 1);
-  REQUIRE(msgSet.pairMap.size() == 1);
-  REQUIRE(msgSet.messageMap[0].position == 0);
-  REQUIRE(msgSet.messageMap[0].size == 1);
-
-  REQUIRE(msgSet.pairMap[0].partIndex == 0);
-  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
+  REQUIRE((msgSet.messages | count_payloads{}) == 1);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  CHECK_THROWS((msgSet.messages | get_pair{1}));
 }
 
-TEST_CASE("MessageSetWithFunction") {
+TEST_CASE("MessageSetWithFunction")
+{
   std::vector<fair::mq::MessagePtr> ptrs;
-  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  o2::header::DataHeader dh{};
+  dh.splitPayloadParts = 0;
+  dh.splitPayloadIndex = 0;
+  o2::framework::DataProcessingHeader dph{0, 1};
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  fair::mq::MessagePtr header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
   std::unique_ptr<fair::mq::Message> msg2(nullptr);
-  ptrs.emplace_back(std::move(msg));
+  ptrs.emplace_back(std::move(header));
   ptrs.emplace_back(std::move(msg2));
   o2::framework::MessageSet msgSet([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
 
   REQUIRE(msgSet.messages.size() == 2);
-  REQUIRE(msgSet.messageMap.size() == 1);
-  REQUIRE(msgSet.pairMap.size() == 1);
-  REQUIRE(msgSet.messageMap[0].position == 0);
-  REQUIRE(msgSet.messageMap[0].size == 1);
-
-  REQUIRE(msgSet.pairMap[0].partIndex == 0);
-  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
+  REQUIRE((msgSet.messages | count_payloads{}) == 1);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  CHECK_THROWS((msgSet.messages | get_pair{1}));
 }
 
-TEST_CASE("MessageSetWithMultipart") {
+TEST_CASE("MessageSetWithMultipart")
+{
   std::vector<fair::mq::MessagePtr> ptrs;
-  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  o2::header::DataHeader dh{};
+  dh.splitPayloadParts = 2;
+  dh.splitPayloadIndex = 2;
+  o2::framework::DataProcessingHeader dph{0, 1};
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  fair::mq::MessagePtr header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
   std::unique_ptr<fair::mq::Message> msg2(nullptr);
   std::unique_ptr<fair::mq::Message> msg3(nullptr);
-  ptrs.emplace_back(std::move(msg));
+  ptrs.emplace_back(std::move(header));
   ptrs.emplace_back(std::move(msg2));
   ptrs.emplace_back(std::move(msg3));
   o2::framework::MessageSet msgSet([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 3);
 
   REQUIRE(msgSet.messages.size() == 3);
-  REQUIRE(msgSet.messageMap.size() == 1);
-  REQUIRE(msgSet.pairMap.size() == 2);
-  REQUIRE(msgSet.messageMap[0].position == 0);
-  REQUIRE(msgSet.messageMap[0].size == 2);
-
-  REQUIRE(msgSet.pairMap[0].partIndex == 0);
-  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
-  REQUIRE(msgSet.pairMap[1].partIndex == 0);
-  REQUIRE(msgSet.pairMap[1].payloadIndex == 1);
+  REQUIRE((msgSet.messages | count_payloads{}) == 2);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 1}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 1}).payloadIdx == 2);
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 2);
+  CHECK_THROWS((msgSet.messages | get_pair{2}));
 }
 
-TEST_CASE("MessageSetAddPartRef") {
+TEST_CASE("MessageSetAddPartRef")
+{
   std::vector<fair::mq::MessagePtr> ptrs;
   std::unique_ptr<fair::mq::Message> msg(nullptr);
   std::unique_ptr<fair::mq::Message> msg2(nullptr);
   ptrs.emplace_back(std::move(msg));
   ptrs.emplace_back(std::move(msg2));
-  PartRef ref {std::move(msg), std::move(msg2)};
+  PartRef ref{std::move(msg), std::move(msg2)};
   o2::framework::MessageSet msgSet;
   msgSet.add(std::move(ref));
 
   REQUIRE(msgSet.messages.size() == 2);
-  REQUIRE(msgSet.messageMap.size() == 1);
-  REQUIRE(msgSet.pairMap.size() == 1);
-  REQUIRE(msgSet.messageMap[0].position == 0);
-  REQUIRE(msgSet.messageMap[0].size == 1);
-
-  REQUIRE(msgSet.pairMap[0].partIndex == 0);
-  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
 }
 
 TEST_CASE("MessageSetAddMultiple")
 {
   std::vector<fair::mq::MessagePtr> ptrs;
-  std::unique_ptr<fair::mq::Message> msg(nullptr);
+  o2::header::DataHeader dh1{};
+  dh1.splitPayloadParts = 0;
+  dh1.splitPayloadIndex = 0;
+  o2::header::DataHeader dh2{};
+  dh2.splitPayloadParts = 1;
+  dh2.splitPayloadIndex = 0;
+  o2::header::DataHeader dh3{};
+  dh3.splitPayloadParts = 2;
+  dh3.splitPayloadIndex = 2;
+  o2::framework::DataProcessingHeader dph{0, 1};
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  fair::mq::MessagePtr payload(transport->CreateMessage());
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+  fair::mq::MessagePtr header1 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh1, dph});
+  fair::mq::MessagePtr header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
+  fair::mq::MessagePtr header3 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh3, dph});
+
   std::unique_ptr<fair::mq::Message> msg2(nullptr);
-  ptrs.emplace_back(std::move(msg));
-  ptrs.emplace_back(std::move(msg2));
-  PartRef ref{std::move(msg), std::move(msg2)};
+  std::unique_ptr<fair::mq::Message> msg3(nullptr);
+  PartRef ref{std::move(header1), std::move(msg2)};
   o2::framework::MessageSet msgSet;
   msgSet.add(std::move(ref));
-  PartRef ref2{std::move(msg), std::move(msg2)};
+  PartRef ref2{std::move(header2), std::move(msg2)};
   msgSet.add(std::move(ref2));
   std::vector<fair::mq::MessagePtr> msgs;
-  msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
+  msgs.push_back(std::move(header3));
   msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
   msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
   msgSet.add([&msgs](size_t i) {
     return std::move(msgs[i]);
-  }, 3);
+  },
+             3);
 
   REQUIRE(msgSet.messages.size() == 7);
-  REQUIRE(msgSet.messageMap.size() == 3);
-  REQUIRE(msgSet.pairMap.size() == 4);
-  REQUIRE(msgSet.messageMap[0].position == 0);
-  REQUIRE(msgSet.messageMap[0].size == 1);
-  REQUIRE(msgSet.messageMap[1].position == 2);
-  REQUIRE(msgSet.messageMap[1].size == 1);
-  REQUIRE(msgSet.messageMap[2].position == 4);
-  REQUIRE(msgSet.messageMap[2].size == 2);
 
-  REQUIRE(msgSet.pairMap[0].partIndex == 0);
-  REQUIRE(msgSet.pairMap[0].payloadIndex == 0);
-  REQUIRE(msgSet.pairMap[1].partIndex == 1);
-  REQUIRE(msgSet.pairMap[1].payloadIndex == 0);
-  REQUIRE(msgSet.pairMap[2].partIndex == 2);
-  REQUIRE(msgSet.pairMap[2].payloadIndex == 0);
-  REQUIRE(msgSet.pairMap[3].partIndex == 2);
-  REQUIRE(msgSet.pairMap[3].payloadIndex == 1);
+  REQUIRE((msgSet.messages | count_payloads{}) == 4);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_dataref_indices{1, 0}).headerIdx == 2);
+  REQUIRE((msgSet.messages | get_dataref_indices{1, 0}).payloadIdx == 3);
+  REQUIRE((msgSet.messages | get_dataref_indices{2, 0}).headerIdx == 4);
+  REQUIRE((msgSet.messages | get_dataref_indices{2, 0}).payloadIdx == 5);
+  REQUIRE((msgSet.messages | get_dataref_indices{2, 1}).headerIdx == 4);
+  REQUIRE((msgSet.messages | get_dataref_indices{2, 1}).payloadIdx == 6);
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
+  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
+  REQUIRE((msgSet.messages | get_pair{2}).headerIdx == 4);
+  REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 5);
+  REQUIRE((msgSet.messages | get_pair{3}).headerIdx == 4);
+  REQUIRE((msgSet.messages | get_pair{3}).payloadIdx == 6);
 }

From 45753477d82cfe8509cdeb2d45e7d511f789e20d Mon Sep 17 00:00:00 2001
From: Marco van Leeuwen <marco.van.leeuwen@cern.ch>
Date: Sun, 22 Mar 2026 07:10:04 +0100
Subject: [PATCH 1459/1764] [ALICE 3] Properly set FT3 sensitive volumes;
 improve tiling (#15201)

* [ALICE 3] Properly set FT3 sensitive volumes; improve tiling of v3 geometry (Rin = 30 cm)

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../ALICE3/FT3/simulation/src/Detector.cxx    |  9 +++-
 .../ALICE3/FT3/simulation/src/FT3Module.cxx   | 52 +++++++++++++++----
 2 files changed, 48 insertions(+), 13 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index 02aae95daacfe..94d56fd9625a0 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -630,6 +630,7 @@ void Detector::defineSensitiveVolumes()
     for (int iLayer = 0; iLayer < getNumberOfLayers(); iLayer++) {
       LOG(info) << "Adding FT3 Sensitive Volume for direction " << direction << " layer " << iLayer << "/" << getNumberOfLayers();
       volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer);
+      int iSens = 0;
       if (mLayers[direction][iLayer].getIsInMiddleLayer()) { // ML disks
         const std::string sensorName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer);
         v = geoManager->GetVolume(sensorName.c_str());
@@ -638,20 +639,24 @@ void Detector::defineSensitiveVolumes()
           LOG(fatal) << "Could not find volume " << sensorName << " for direction " << direction << " layer " << iLayer;
         }
         AddSensitiveVolume(v);
+        iSens++;
       } else { // OT disks
         for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) {
-          std::string sensor_name_front = "FT3sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-          std::string sensor_name_back = "FT3sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+          std::string sensor_name_front = "FT3Sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+          std::string sensor_name_back = "FT3Sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
           v = geoManager->GetVolume(sensor_name_front.c_str());
           if (v) {
             AddSensitiveVolume(v);
+            iSens++;
           }
           v = geoManager->GetVolume(sensor_name_back.c_str());
           if (v) {
             AddSensitiveVolume(v);
+            iSens++;
           }
         }
       }
+      LOG(info) << iSens << " sensitive volumes added";
     }
   }
 }
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
index 20a481cb36046..99322aa91f53f 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -140,6 +140,9 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
   double bottom_y_pos_value = 0;
   double bottom_y_neg_value = 0;
 
+  double Rin_offset = (sensor_height == 19.2) ? 1 : 0;
+  double Rout_offset = (sensor_height == 19.2) ? 1 : 0;
+
   if (Rin == 7 && sensor_height == 9.6 && sensor_width == 5) {
     x_condition_min = -Rin - 2;
     x_condition_max = Rin;
@@ -198,17 +201,23 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
     x_adjust_bottom_y_pos = 5.5;
     bottom_y_pos_value = 3.5;
     bottom_y_neg_value = -3.5;
+  } else if (Rin == 20 && sensor_height == 9.6 && sensor_width == 5.0) {
+    x_condition_min = -Rin - 4;
+    x_condition_max = Rin;
+    dist_offset = 2;
+    adjust_bottom_y_pos = false;
+    adjust_bottom_y_neg = false;
+    x_adjust_bottom_y_pos = 3.5;
+    bottom_y_pos_value = 3.5;
+    bottom_y_neg_value = -3.5;
   } else {
     LOG(warning) << "Different config - to determine offsets needed for " << "Rin = " << Rin << " ; sensor_height = " << sensor_height << " ; sensor_width = " << sensor_width << " layer " << layerNumber;
-    x_condition_min = -Rin;
+    x_condition_min = -Rin - sensor_width;
     x_condition_max = Rin;
     adjust_bottom_y_pos = false;
     adjust_bottom_y_neg = false;
   }
 
-  double Rin_offset = (sensor_height == 19.2) ? 1 : 0;
-  double Rout_offset = (sensor_height == 19.2) ? 1 : 0;
-
   offset_Rin_lower = Rin - Rin_offset;
   offset_Rin_upper = Rout + Rout_offset;
 
@@ -235,13 +244,34 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
       justSkipped1 = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
     }
   } else {
-    // filling for sensors with 2x width, each row skipped
-    if (face == "front") {
-      X_positions = {-63.4, -54.2, -45, -35.8, -26.6, -17.4, -8.2, 1., 10.2, 19.4, 28.6, 37.8, 47., 56.2, 65.4};
-      justSkipped1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
-    } else if (face == "back") {
-      X_positions = {-58.8, -49.6, -40.4, -31.2, -22, -12.8, -3.6, 5.6, 14.8, 24, 33.2, 42.4, 51.6, 60.8};
-      justSkipped1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+    if (Rin == 20) { // v3 paving, rough attempt
+      float overlap = 0.3;
+      // NB: these are left edges
+      float X_start = -2.0 - 13.5 * (sensor_width - overlap);
+      float X_start_pos = 2.0 - 0.5 * (sensor_width - overlap);
+      if (face == "back") {
+        X_start += (sensor_width - overlap);
+        X_start_pos += (sensor_width - overlap);
+      }
+      while (X_start < -2) {
+        X_positions.push_back(X_start);
+        justSkipped1.push_back(1);
+        X_start += 2 * (sensor_width - overlap);
+      }
+      while (X_start_pos < Rout + x_offset - sensor_width) {
+        X_positions.push_back(X_start_pos);
+        justSkipped1.push_back(1);
+        X_start_pos += 2 * (sensor_width - overlap);
+      }
+    } else {
+      // filling for sensors with 2x width, each row skipped
+      if (face == "front") {
+        X_positions = {-63.4, -54.2, -45, -35.8, -26.6, -17.4, -8.2, 1., 10.2, 19.4, 28.6, 37.8, 47., 56.2, 65.4};
+        justSkipped1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+      } else if (face == "back") {
+        X_positions = {-58.8, -49.6, -40.4, -31.2, -22, -12.8, -3.6, 5.6, 14.8, 24, 33.2, 42.4, 51.6, 60.8};
+        justSkipped1 = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+      }
     }
   }
 

From cfb2c3a6559bc8b66d7d3047c1a31041c16557af Mon Sep 17 00:00:00 2001
From: AizatDaribayeva <aizat.daribayeva@cern.ch>
Date: Sun, 22 Mar 2026 11:24:11 +0100
Subject: [PATCH 1460/1764] [ALICE3] Adding error msg for TGeo features and QA
 macro for reco (#15183)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Adding error msg for TGeo features and QA macro for reco

* Please consider the following formatting changes

* Fix range setting for hSigmaVsPt histogram

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
Co-authored-by: Nicolò Jacazio <njacazio@users.noreply.github.com>
---
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |  14 +-
 .../ALICE3/TRK/macros/test/CheckTracksCA.C    | 577 +++++++++++++-----
 2 files changed, 450 insertions(+), 141 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index 21d86378f59ec..e32a2546c6842 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -106,17 +106,23 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
 
   float getSensorRefAlphaMLOT(int chipId) const
   {
-    assert(getSubDetID(chipId) != 0 && "Called MLOT getter with VD chipId");
+    if (getSubDetID(chipId) == 0) {
+      LOG(error) << "getSensorRefAlphaMLOT(): VD layers are not supported yet! chipID = " << chipId
+                 << "please provide chipId for ML/OT! ";
+      return std::numeric_limits<float>::quiet_NaN();
+    }
     const int local = chipId - getNumberOfActivePartsVD();
-    assert(local >= 0 && local < (int)mCacheRefAlphaMLOT.size());
     return mCacheRefAlphaMLOT[local];
   }
 
   float getSensorXMLOT(int chipId) const
   {
-    assert(getSubDetID(chipId) != 0 && "Called MLOT getter with VD chipId");
+    if (getSubDetID(chipId) == 0) {
+      LOG(error) << "getSensorXMLOT(): VD layers are not supported yet! chipID = " << chipId
+                 << "please provide chipId for ML/OT! ";
+      return std::numeric_limits<float>::quiet_NaN();
+    }
     const int local = chipId - getNumberOfActivePartsVD();
-    assert(local >= 0 && local < (int)mCacheRefXMLOT.size());
     return mCacheRefXMLOT[local];
   }
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckTracksCA.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckTracksCA.C
index ae75616b7719c..f7917ca4203f1 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckTracksCA.C
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckTracksCA.C
@@ -9,8 +9,8 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file CheckTracksCA.C
-/// \brief Quality assurance macro for TRK tracking
+/// \author A. Daribayeva
+/// Quality assurance test on reconstructed tracks, producing efficiency plots and performance table
 
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 #include <array>
@@ -18,15 +18,24 @@
 #include <iostream>
 #include <unordered_map>
 #include <vector>
+#include <fstream>
+#include <algorithm>
+#include <iomanip>
 
 #include <TFile.h>
 #include <TTree.h>
-#include <TH1D.h>
+#include <TH1F.h>
+#include <TH2D.h>
 #include <TCanvas.h>
 #include <THStack.h>
 #include <TLegend.h>
 #include <TLatex.h>
 #include <TStyle.h>
+#include <TObjArray.h>
+#include <TSystem.h>
+#include <TROOT.h>
+#include <TAxis.h>
+#include <TH1.h>
 
 #include "DataFormatsITS/TrackITS.h"
 #include "SimulationDataFormat/MCCompLabel.h"
@@ -41,6 +50,18 @@
 using namespace std;
 using namespace o2;
 
+enum class RangeMode {
+  ContentOnly,
+  ContentOrError,
+  ReferenceContent
+};
+
+void setAutoXRange(TH1* h,
+                   RangeMode mode = RangeMode::ContentOnly,
+                   const TH1* hRef = nullptr,
+                   double threshold = 0.0,
+                   int marginBins = 1);
+
 /// Structure to track particle hit information
 struct ParticleHitInfo {
   std::bitset<11> layerHits; ///< Which layers have hits (11 layers for TRK)
@@ -73,25 +94,37 @@ struct ParticleHitInfo {
   }
 };
 
-void CheckTracksCA(std::string tracfile = "o2trac_trk.root",
+bool hasConsecutiveLayers(const o2::its::TrackITS& recoTrack, int nClusters)
+{
+  std::array<bool, 11> layers{};
+
+  for (int i = 0; i < 11; i++) {
+    layers[i] = recoTrack.hasHitOnLayer(i);
+  }
+
+  return std::search_n(layers.begin(), layers.end(), nClusters, true) != layers.end();
+}
+
+void CheckTracksCA(std::string trackfile = "o2trac_trk.root",
                    std::string kinefile = "o2sim_Kine.root",
                    std::string hitsfile = "o2sim_HitsTRK.root",
-                   std::string outputfile = "trk_qa_output.root")
+                   std::string outFile = "RecoPerformanceTable.dat",
+                   std::string outFile1 = "RecoTracksQA.root")
 {
-  gStyle->SetOptStat(0);
 
-  std::cout << "=== Starting TRK Track Quality Assurance ===" << std::endl;
+  std::cout << "=== Starting TRK Track Reconstruction Quality Assurance ===" << std::endl;
   std::cout << "Input files:" << std::endl;
-  std::cout << "  Tracks:      " << tracfile << std::endl;
+  std::cout << "  Tracks:      " << trackfile << std::endl;
   std::cout << "  Kinematics:  " << kinefile << std::endl;
   std::cout << "  Hits:        " << hitsfile << std::endl;
-  std::cout << "  Output:      " << outputfile << std::endl;
-  std::cout << std::endl;
+  std::cout << "  Output file with performance table: " << outFile << std::endl;
+  std::cout << "  Output root file with histograms: " << outFile1 << std::endl;
+
+  gROOT->SetBatch(true);
 
   // MC kinematics reader
   o2::steer::MCKinematicsReader kineReader("o2sim", o2::steer::MCKinematicsReader::Mode::kMCKine);
   const int nEvents = kineReader.getNEvents(0);
-  std::cout << "Number of MC events: " << nEvents << std::endl;
 
   // Open hits file to count hits per particle per layer
   TFile* hitsFile = TFile::Open(hitsfile.c_str(), "READ");
@@ -99,6 +132,7 @@ void CheckTracksCA(std::string tracfile = "o2trac_trk.root",
     std::cerr << "ERROR: Cannot open hits file: " << hitsfile << std::endl;
     return;
   }
+
   TTree* hitsTree = hitsFile->Get<TTree>("o2sim");
   if (!hitsTree) {
     std::cerr << "ERROR: Cannot find o2sim tree in hits file" << std::endl;
@@ -106,25 +140,19 @@ void CheckTracksCA(std::string tracfile = "o2trac_trk.root",
   }
 
   // Open reconstructed tracks file
-  TFile* tracFile = TFile::Open(tracfile.c_str(), "READ");
+  TFile* tracFile = TFile::Open(trackfile.c_str(), "READ");
   if (!tracFile || tracFile->IsZombie()) {
-    std::cerr << "ERROR: Cannot open tracks file: " << tracfile << std::endl;
+    std::cerr << "ERROR: Cannot open tracks file: " << trackfile << std::endl;
     return;
   }
+
   TTree* recTree = tracFile->Get<TTree>("o2sim");
   if (!recTree) {
     std::cerr << "ERROR: Cannot find o2sim tree in tracks file" << std::endl;
     return;
   }
 
-  // Reconstructed tracks and labels
-  std::vector<o2::its::TrackITS>* recTracks = nullptr;
-  std::vector<o2::MCCompLabel>* trkLabels = nullptr;
-  recTree->SetBranchAddress("TRKTrack", &recTracks);
-  recTree->SetBranchAddress("TRKTrackMCTruth", &trkLabels);
-
-  std::cout << "Reading tracks from tree..." << std::endl;
-
+  // ============== MC part ===============================
   // Analyze hits tree to count hits per particle per layer
   std::cout << "Analyzing hits from tree..." << std::endl;
   std::unordered_map<o2::MCCompLabel, ParticleHitInfo> particleHitMap;
@@ -133,9 +161,6 @@ void CheckTracksCA(std::string tracfile = "o2trac_trk.root",
   o2::base::GeometryManager::loadGeometry();
   auto* gman = o2::trk::GeometryTGeo::Instance();
 
-  // Array to map detector to starting layer
-  constexpr std::array<int, 2> startLayer{0, 3};
-
   std::vector<o2::trk::Hit>* trkHit = nullptr;
   hitsTree->SetBranchAddress("TRKHit", &trkHit);
 
@@ -152,8 +177,7 @@ void CheckTracksCA(std::string tracfile = "o2trac_trk.root",
       }
 
       // Determine layer
-      int subDetID = gman->getSubDetID(hit.GetDetectorID());
-      const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
+      const int layer = gman->getBarrelLayer(hit.GetDetectorID());
 
       // Create label for this particle
       o2::MCCompLabel label(hit.GetTrackID(), static_cast<int>(iEntry), 0);
@@ -165,81 +189,132 @@ void CheckTracksCA(std::string tracfile = "o2trac_trk.root",
 
   std::cout << "Found " << particleHitMap.size() << " unique particles with hits" << std::endl;
 
-  // Store particle info and fill generated histograms
-  std::unordered_map<o2::MCCompLabel, float> particlePtMap;
-
-  // Create histograms
-  constexpr int nLayers = 11;
-  constexpr int nb = 100;
-  double xbins[nb + 1], ptcutl = 0.05, ptcuth = 10.;
-  double a = std::log(ptcuth / ptcutl) / nb;
-  for (int i = 0; i <= nb; i++)
-    xbins[i] = ptcutl * std::exp(i * a);
-
-  TH1D genParticlePtHist("genParticlePt", "Generated Particle p_{T} (All Layers); #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
-  TH1D genParticlePt7LayersHist("genParticlePt7Layers", "Generated Particle p_{T} with hits in at least 7 consecutive layers; #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
-  TH1D goodTracks("goodTracks", "Good Tracks; p_{T} (GeV/c); Counts", nb, xbins);
-  TH1D fakeTracks("fakeTracks", "Fake Tracks; p_{T} (GeV/c); Counts", nb, xbins);
-
-  std::array<TH1D, 5> goodTracksMatching, fakeTracksMatching;
-  for (int i = 0; i < 5; ++i) {
-    goodTracksMatching[i] = TH1D(Form("goodTracksMatching_%dLayers", i + 7),
-                                 Form("Good Tracks with %d layer hits; p_{T} (GeV/c); Counts", i + 7),
-                                 nb, xbins);
-    fakeTracksMatching[i] = TH1D(Form("fakeTracksMatching_%dLayers", i + 7),
-                                 Form("Fake Tracks with %d layer hits; p_{T} (GeV/c); Counts", i + 7),
-                                 nb, xbins);
-  }
+  //=========== need to set the min and max ranges for hists
+  std::vector<float> pTDist;
+  std::unordered_map<o2::MCCompLabel, o2::MCTrack> MCTrackMap;
 
-  TH1D numberOfClustersPerTrack("numberOfClustersPerTrack",
-                                "Number of clusters per track; N_{clusters}; Counts",
-                                12, -0.5, 11.5);
+  // counters for general statisics
+  int counterPrimaries{0}, counterSecondaries{0};
 
-  // First pass: identify particles with full hit coverage from kinematics
-  std::cout << "Analyzing MC particles..." << std::endl;
   for (int iEvent = 0; iEvent < nEvents; ++iEvent) {
     const auto& mcTracks = kineReader.getTracks(iEvent);
+
     for (size_t iTrack = 0; iTrack < mcTracks.size(); ++iTrack) {
       const auto& mcTrack = mcTracks[iTrack];
-      if (!mcTrack.isPrimary()) {
-        continue;
-      }
 
       // Create label for this particle
       o2::MCCompLabel label(iTrack, iEvent, 0);
-      float pt = mcTrack.GetPt();
 
-      // Store particle info
-      particlePtMap[label] = pt;
-
-      // Check if this particle has hits
       auto hitIt = particleHitMap.find(label);
       if (hitIt != particleHitMap.end()) {
-        // Store pT in hit info
-        hitIt->second.pt = pt;
 
-        // Fill histogram for particles with hits in all 11 layers
-        if (hitIt->second.nHits == 11) {
-          genParticlePtHist.Fill(pt);
+        if (mcTrack.isPrimary()) {
+          counterPrimaries++;
         }
-
-        // Fill histogram for particles with at least 7 consecutive layer hits
-        if (hitIt->second.hasConsecutiveLayers(7)) {
-          genParticlePt7LayersHist.Fill(pt);
+        if (mcTrack.isSecondary()) {
+          counterSecondaries++;
         }
+
+        MCTrackMap.emplace(label, mcTrack);
+        pTDist.push_back(mcTrack.GetPt());
+      }
+    }
+  }
+
+  int nBins = 100;
+  auto [minpT, maxpT] = std::minmax_element(pTDist.begin(), pTDist.end());
+
+  //=========== histograms =============
+  // for exclusive studies
+  TH1F hPtDenExclusive("", "", nBins, *minpT, *maxpT);
+
+  TH1F hPtNumExclusive("", "", nBins, *minpT, *maxpT);
+
+  TH1F hPtEffExclusive("hPtEffExclusive",
+                       "efficiency (exclusive, good, primaries) vs p_{T}; p_{T} [GeV/c]; Efficiency",
+                       nBins, *minpT, *maxpT);
+
+  // for inclusive studies
+  TH1F hPtDenInclusive("", "", nBins, *minpT, *maxpT);
+
+  TH1F hPtNumInclusive("", "", nBins, *minpT, *maxpT);
+
+  TH1F hPtEffInclusive("hPtEffInclusive", "", nBins, *minpT, *maxpT);
+
+  // for inclusive studies, fake
+  TH1F hPtNumInclusiveFake("", "", nBins, *minpT, *maxpT);
+  TH1F hPtEffInclusiveFake("", "", nBins, *minpT, *maxpT);
+
+  TH2D hPtResVsPt("", "", nBins, *minpT, *maxpT, 100, -0.5, 0.5);
+
+  // for inclusive efficiencies
+  int counterAll{0}, prim_ge7{0}, sec_ge7{0};
+
+  // for exclusive studies when we have 7,8,9,10,11 hits
+  std::array<int, 12> mcExact{};
+
+  for (const auto& [label, mcTrack] : MCTrackMap) {
+
+    const auto& hitInfo = particleHitMap.at(label);
+    int nHits = hitInfo.nHits;
+
+    if (nHits < 7 || nHits > 11) {
+      continue;
+    }
+
+    float pT = mcTrack.GetPt();
+
+    bool consecutive7 = hitInfo.hasConsecutiveLayers(7);
+
+    if (mcTrack.isPrimary()) {
+
+      // exclusive - all hits should be on subsequent layers
+      if (hitInfo.hasConsecutiveLayers(nHits)) {
+        hPtDenExclusive.Fill(pT);
+        ++mcExact[nHits];
+      }
+
+      // inclusive - it's enough to be on 7 consequtive layers
+      if (consecutive7) {
+        hPtDenInclusive.Fill(pT);
+        ++prim_ge7;
+      }
+
+    } else if (mcTrack.isSecondary()) {
+
+      if (consecutive7) {
+        ++sec_ge7;
       }
     }
   }
 
-  std::cout << "Generated particles with 11 hits: " << genParticlePtHist.GetEntries() << std::endl;
-  std::cout << "Generated particles with 7+ consecutive hits: " << genParticlePt7LayersHist.GetEntries() << std::endl;
+  counterAll = prim_ge7 + sec_ge7;
+
+  //============  reco tracks ===============
+
+  // Reconstructed tracks and labels
+  std::vector<o2::its::TrackITS>* recTracks = nullptr;
+  std::vector<o2::MCCompLabel>* trkLabels = nullptr;
+  std::vector<float> pTResVector; // good, primaries, inclusive
+
+  recTree->SetBranchAddress("TRKTrack", &recTracks);
+  recTree->SetBranchAddress("TRKTrackMCTruth", &trkLabels);
 
   // Second pass: analyze reconstructed tracks
   std::cout << "Analyzing reconstructed tracks..." << std::endl;
   int nROFs = recTree->GetEntries();
-  int totalTracks = 0;
-  int goodTracksCount = 0;
-  int fakeTracksCount = 0;
+  int totalTracks{0};
+
+  // inclusive count
+  std::unordered_set<o2::MCCompLabel> foundAllGood, foundAllFake;
+  std::unordered_set<o2::MCCompLabel> foundPrimGood, foundPrimFake;
+  std::unordered_set<o2::MCCompLabel> foundSecGood, foundSecFake;
+
+  // exclusive count
+  std::array<std::unordered_set<o2::MCCompLabel>, 12> foundExclusiveGood, foundExclusiveFake;
+  std::array<std::unordered_set<o2::MCCompLabel>, 12> foundWithLessClusters;
+
+  int count7RecoGood{0};
 
   for (int iROF = 0; iROF < nROFs; ++iROF) {
     recTree->GetEntry(iROF);
@@ -258,88 +333,316 @@ void CheckTracksCA(std::string tracfile = "o2trac_trk.root",
         continue;
       }
 
-      int eventID = label.getEventID();
-      int trackID = label.getTrackID();
       int nClusters = track.getNumberOfClusters();
+      if (nClusters < 7 || nClusters > 11) {
+        continue;
+      }
+
+      auto key = o2::MCCompLabel(label.getTrackID(), label.getEventID(), 0);
+
+      auto hitIt = particleHitMap.find(key);
+      auto mcIt = MCTrackMap.find(key);
 
-      // Get MC track info
-      if (eventID < 0 || eventID >= nEvents) {
+      if (hitIt == particleHitMap.end() || mcIt == MCTrackMap.end()) {
         continue;
       }
 
-      const auto& mcTracks = kineReader.getTracks(eventID);
-      if (trackID < 0 || trackID >= (int)mcTracks.size()) {
+      int nHits = hitIt->second.nHits;
+      if (nHits < 7 || nHits > 11) {
         continue;
       }
 
-      float pt = mcTracks[trackID].GetPt();
+      bool mcHasN = hitIt->second.hasConsecutiveLayers(nHits);
+      bool recoHasN = hasConsecutiveLayers(track, nClusters);
 
-      // Fill histograms
-      numberOfClustersPerTrack.Fill(nClusters);
+      float mcPt = mcIt->second.GetPt();
+      float recoPT = track.getPt();
 
-      auto key = o2::MCCompLabel(trackID, eventID, 0);
-      if (particleHitMap.find(key) != particleHitMap.end() && particleHitMap[key].hasConsecutiveLayers(11)) {
+      // inclusive count
+      if (hitIt->second.hasConsecutiveLayers(7) && hasConsecutiveLayers(track, 7)) {
+
+        // for good tracks
+        if (label.isCorrect()) {
+          foundAllGood.insert(key);
+
+          if (mcIt->second.isPrimary()) {
+            foundPrimGood.insert(key);
+            hPtNumInclusive.Fill(mcPt);
+
+            float ptRes = (recoPT - mcPt) / mcPt;
+            pTResVector.push_back(ptRes);
+            hPtResVsPt.Fill(mcPt, ptRes);
+
+          } else if (mcIt->second.isSecondary()) {
+            foundSecGood.insert(key);
+          }
+        }
+
+        // for fake tracks
         if (label.isFake()) {
-          fakeTracks.Fill(pt);
-          fakeTracksCount++;
-          if (nClusters >= 7 && nClusters <= 11) {
-            fakeTracksMatching[nClusters - 7].Fill(pt);
+          foundAllFake.insert(key);
+
+          if (mcIt->second.isPrimary()) {
+            foundPrimFake.insert(key);
+            hPtNumInclusiveFake.Fill(mcPt);
+          } else if (mcIt->second.isSecondary()) {
+            foundSecFake.insert(key);
           }
-        } else {
-          goodTracks.Fill(pt);
-          goodTracksCount++;
-          if (nClusters >= 7 && nClusters <= 11) {
-            goodTracksMatching[nClusters - 7].Fill(pt);
+        }
+      }
+
+      // exclusive count
+      if (nHits == nClusters && mcHasN && recoHasN) {
+
+        if (mcIt->second.isPrimary()) {
+
+          if (label.isCorrect()) {
+
+            hPtNumExclusive.Fill(mcPt);
+            foundExclusiveGood[nHits].insert(key);
+          }
+
+          if (label.isFake()) {
+            foundExclusiveFake[nHits].insert(key);
           }
         }
       }
+
+      // counting cluster loss
+      if (mcIt->second.isPrimary() && mcHasN && recoHasN &&
+          label.isCorrect() &&
+          nClusters < nHits) {
+
+        foundWithLessClusters[nHits].insert(key);
+      }
+
+    } // end loop over reco tracks
+  } // end loop over RoFs
+
+  // inclusive efficiencies for Good tracks
+  float effForAllGood = counterAll > 0 ? 100.f * foundAllGood.size() / counterAll : 0.f;
+  float effForPrimGood = prim_ge7 > 0 ? 100.f * foundPrimGood.size() / prim_ge7 : 0.f;
+  float effForSecGood = sec_ge7 > 0 ? 100.f * foundSecGood.size() / sec_ge7 : 0.f;
+
+  // inclusive efficiencies for Fake tracks
+  float effForAllFake = counterAll > 0 ? 100.f * foundAllFake.size() / counterAll : 0.f;
+  float effForPrimFake = prim_ge7 > 0 ? 100.f * foundPrimFake.size() / prim_ge7 : 0.f;
+  float effForSecFake = sec_ge7 > 0 ? 100.f * foundSecFake.size() / sec_ge7 : 0.f;
+
+  // exclusive efficiencies for Good and Fake tracks
+  std::array<float, 12> effExactAllGood{}, effExactAllFake{};
+
+  for (int n = 7; n <= 11; ++n) {
+    effExactAllGood[n] = mcExact[n] > 0 ? 100.f * foundExclusiveGood[n].size() / mcExact[n] : 0.f;
+    effExactAllFake[n] = mcExact[n] > 0 ? 100.f * foundExclusiveFake[n].size() / mcExact[n] : 0.f;
+  }
+
+  // cluster loss
+  std::array<float, 12> fracWithLessClusters{};
+  for (int n = 7; n <= 11; ++n) {
+    fracWithLessClusters[n] = mcExact[n] > 0 ? 100.f * foundWithLessClusters[n].size() / mcExact[n] : 0.f;
+  }
+
+  // pT vs inclusive & exclusive track efficiencies
+  hPtEffExclusive.Divide(&hPtNumExclusive, &hPtDenExclusive, 1.0, 1.0, "B");
+  hPtEffInclusive.Divide(&hPtNumInclusive, &hPtDenInclusive, 1.0, 1.0, "B");
+  hPtEffInclusiveFake.Divide(&hPtNumInclusiveFake, &hPtDenInclusive, 1.0, 1.0, "B");
+
+  // pT resolution for good inclusive tracks, primaries
+  auto [minPtRes, maxPtRes] = std::minmax_element(pTResVector.begin(), pTResVector.end());
+  TH1F pTResolution("pTResolutionForInclusive", "p_{T} resolution; (p_{T}^{rec}-p_{T}^{MC})/p_{T}^{MC}; Counts", nBins, *minPtRes, *maxPtRes);
+  for (const auto& pTVal : pTResVector) {
+    pTResolution.Fill(pTVal);
+  }
+  pTResolution.Fit("gaus");
+
+  TObjArray fitSlices;
+  hPtResVsPt.FitSlicesY(nullptr, 0, -1, 0, "QNR", &fitSlices);
+
+  TH1D* hSigmaVsPt = nullptr;
+
+  if (fitSlices.GetEntries() > 2 && fitSlices.At(2)) {
+    hSigmaVsPt = dynamic_cast<TH1D*>(fitSlices.At(2)->Clone("hSigmaVsPt"));
+    if (hSigmaVsPt) {
+      hSigmaVsPt->SetTitle("#sigma(p_{T} resolution) vs p_{T}; p_{T}^{MC} [GeV/c]; #sigma");
+      hSigmaVsPt->GetXaxis()->SetRangeUser(0.5, *maxpT);
     }
   }
 
-  // Create efficiency histograms
-  std::cout << "Computing efficiencies..." << std::endl;
+  // Style
+  hPtEffInclusive.SetLineColor(kBlue + 1);
+  hPtEffInclusive.SetMarkerColor(kBlue + 1);
+  hPtEffInclusive.SetMarkerStyle(20);
+  hPtEffInclusive.SetMarkerSize(1.0);
+  hPtEffInclusive.SetLineWidth(2);
+
+  hPtEffInclusiveFake.SetLineColor(kRed + 1);
+  hPtEffInclusiveFake.SetMarkerColor(kRed + 1);
+  hPtEffInclusiveFake.SetMarkerStyle(24);
+  hPtEffInclusiveFake.SetMarkerSize(1.0);
+  hPtEffInclusiveFake.SetLineWidth(2);
+
+  // Titles and axis labels
+  hPtEffInclusive.SetTitle("Inclusive tracking performance vs p_{T}");
+  hPtEffInclusive.GetXaxis()->SetTitle("p_{T} [GeV/c]");
+  hPtEffInclusive.GetYaxis()->SetTitle("Rate");
+
+  // Canvas
+  TCanvas* cPtEff = new TCanvas("", "", 900, 700);
+
+  setAutoXRange(&hPtEffInclusive, RangeMode::ReferenceContent, &hPtDenInclusive);
+  setAutoXRange(&hPtEffInclusiveFake, RangeMode::ReferenceContent, &hPtDenInclusive);
+
+  hPtEffInclusive.Draw("E1");
+  hPtEffInclusiveFake.Draw("E1 SAME");
+
+  // Legend
+  TLegend* leg = new TLegend(0.60, 0.15, 0.88, 0.35);
+  leg->SetBorderSize(0);
+  leg->SetFillStyle(0);
+  leg->AddEntry(&hPtEffInclusive, "Inclusive good efficiency", "lp");
+  leg->AddEntry(&hPtEffInclusiveFake, "Inclusive fake rate", "lp");
+  leg->Draw("E1 SAME");
+
+  setAutoXRange(&hPtEffExclusive, RangeMode::ContentOnly);
+
+  // Writing to output Root file
+  std::cout << "Writing histograms to " << outFile1 << std::endl;
+  TFile outFileRoot(outFile1.c_str(), "RECREATE");
+  if (hSigmaVsPt) {
+    hSigmaVsPt->Write();
+  }
+  hPtEffExclusive.Write();
+  hPtEffInclusive.Write();
+  cPtEff->Write();
+  pTResolution.Write();
+  outFileRoot.Close();
+
+  // Building performance table
+  std::cout << "Building performance table ... " << std::endl;
+  std::ofstream outFileTxt(outFile.c_str());
+  outFileTxt << std::fixed << std::setprecision(2);
+
+  outFileTxt << "This is preliminary reconstruction performance table !!" << std::endl;
+  outFileTxt << "\nGenerated " << particleHitMap.size() << " unique particles with hits" << std::endl;
+  outFileTxt << "Among them, N primaries: " << counterPrimaries << " and secondaries: " << counterSecondaries << std::endl;
+  outFileTxt << "Number of total reconstructed tracks: " << totalTracks << std::endl;
+
+  outFileTxt << "\nReconstruction performance table\n\n";
+
+  outFileTxt << "| "
+             << std::left << std::setw(20) << "Track category"
+             << "| " << std::setw(14) << "Efficiency (%)"
+             << "| " << std::setw(14) << "Fake rate (%)"
+             << "| " << std::setw(12) << "MC counts"
+             << " |\n";
+
+  outFileTxt << std::string(70, '-') << "\n";
+
+  outFileTxt << "| "
+             << std::left << std::setw(20) << "All (prim+sec)"
+             << "| " << std::setw(14) << effForAllGood
+             << "| " << std::setw(14) << effForAllFake
+             << "| " << std::setw(12) << counterAll
+             << " |\n";
+
+  outFileTxt << "| "
+             << std::left << std::setw(20) << "Primaries"
+             << "| " << std::setw(14) << effForPrimGood
+             << "| " << std::setw(14) << effForPrimFake
+             << "| " << std::setw(12) << prim_ge7
+             << " |\n";
+
+  outFileTxt << "| "
+             << std::left << std::setw(20) << "Secondaries"
+             << "| " << std::setw(14) << effForSecGood
+             << "| " << std::setw(14) << effForSecFake
+             << "| " << std::setw(12) << sec_ge7
+             << " |\n";
+
+  outFileTxt << "\n\nExclusive efficiencies for primaries:\n\n";
+
+  outFileTxt << "| "
+             << std::left << std::setw(15) << "Track length"
+             << "| " << std::setw(14) << "Efficiency (%)"
+             << "| " << std::setw(14) << "Fake rate (%)"
+             << "| " << std::setw(14) << "Cluster loss (%)"
+             << "| " << std::setw(14) << "MC counts"
+             << " |\n";
+
+  outFileTxt << std::string(85, '-') << "\n";
+
+  for (int n = 11; n >= 7; --n) {
+    outFileTxt << "| "
+               << std::left << std::setw(15) << (std::to_string(n) + "-hit")
+               << "| " << std::setw(14) << effExactAllGood[n]
+               << "| " << std::setw(14) << effExactAllFake[n]
+               << "| " << std::setw(16) << fracWithLessClusters[n]
+               << "| " << std::setw(14) << mcExact[n]
+               << " |\n";
+  }
+
+  std::cout << "Analysis complete!" << std::endl;
 
-  std::array<TH1D, 5> efficiencyHistograms;
-  THStack* efficiencyStack = new THStack("efficiencyStack",
-                                         "Tracking Efficiency; #it{p}_{T} (GeV/#it{c}); Efficiency");
+} // end of macro
 
-  int colors[5] = {kRed, kBlue, kGreen + 2, kMagenta, kOrange};
-  for (int i = 0; i < 5; ++i) {
-    int nClusters = i + 7;
-    efficiencyHistograms[i] = TH1D(Form("efficiency_%dClusters", nClusters),
-                                   Form("Efficiency for %d cluster tracks; #it{p}_{T} (GeV/#it{c}); Efficiency", nClusters),
-                                   nb, xbins);
+void setAutoXRange(TH1* h, RangeMode mode,
+                   const TH1* hRef,
+                   double threshold,
+                   int marginBins)
+{
+  if (!h)
+    return;
 
-    efficiencyHistograms[i].Divide(&goodTracksMatching[i], &genParticlePtHist, 1, 1, "B");
+  const TH1* hScan = h;
 
-    efficiencyHistograms[i].SetLineColor(colors[i]);
-    efficiencyHistograms[i].SetFillColor(colors[i]);
-    efficiencyHistograms[i].SetLineWidth(2);
-    efficiencyHistograms[i].SetMarkerColor(colors[i]);
-    efficiencyHistograms[i].SetMarkerStyle(20 + i);
-    efficiencyStack->Add(&efficiencyHistograms[i]);
+  if (mode == RangeMode::ReferenceContent) {
+    if (!hRef)
+      return;
+    hScan = hRef;
   }
 
-  // Write output
-  std::cout << "Writing output to " << outputfile << std::endl;
-  TFile outFile(outputfile.c_str(), "RECREATE");
-  genParticlePtHist.Write();
-  goodTracks.Write();
-  fakeTracks.Write();
-  for (int i = 0; i < 5; ++i) {
-    goodTracksMatching[i].Write();
-    fakeTracksMatching[i].Write();
-    efficiencyHistograms[i].Write();
+  const int nBins = hScan->GetNbinsX();
+  int first = -1;
+  int last = -1;
+
+  auto isUsefulBin = [&](int i) -> bool {
+    const double content = hScan->GetBinContent(i);
+    const double error = hScan->GetBinError(i);
+
+    switch (mode) {
+      case RangeMode::ContentOnly:
+        return content > threshold;
+
+      case RangeMode::ContentOrError:
+        return (content > threshold) || (error > 0.0);
+
+      case RangeMode::ReferenceContent:
+        return content > threshold;
+    }
+    return false;
+  };
+
+  for (int i = 1; i <= nBins; ++i) {
+    if (isUsefulBin(i)) {
+      first = i;
+      break;
+    }
   }
-  efficiencyStack->Write();
-  genParticlePt7LayersHist.Write();
-  numberOfClustersPerTrack.Write();
-  outFile.Close();
-
-  // Clean up
-  hitsFile->Close();
-  tracFile->Close();
-  delete efficiencyStack;
-  delete hitsFile;
-  delete tracFile;
+
+  for (int i = nBins; i >= 1; --i) {
+    if (isUsefulBin(i)) {
+      last = i;
+      break;
+    }
+  }
+
+  if (first == -1 || last == -1 || first > last) {
+    return;
+  }
+
+  first = std::max(1, first - marginBins);
+  last = std::min(nBins, last + marginBins);
+
+  h->GetXaxis()->SetRange(first, last);
 }

From 35fc90d93321b4ea400a235e0c0b7d37b4d50afe Mon Sep 17 00:00:00 2001
From: Andrea Sofia Triolo <andrea.sofia.triolo@cern.ch>
Date: Mon, 23 Mar 2026 18:36:30 +0100
Subject: [PATCH 1461/1764] [ALICE3] TRK: changed ML/OT pitch to 20 um (#15203)

---
 Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index c3c7de9dbe910..91d6f5669ef33 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -79,8 +79,8 @@ namespace chip
 {
 constexpr double width{25 * mm};                                              // width of the chip
 constexpr double length{32 * mm};                                             // length of the chip
-constexpr double pitchX{50 * mu};                                             // pitch of the row
-constexpr double pitchZ{50 * mu};                                             // pitch of the column
+constexpr double pitchX{20 * mu};                                             // pitch of the row
+constexpr double pitchZ{20 * mu};                                             // pitch of the column
 constexpr double totalThickness{silicon::thickness + metalstack::thickness};  // total thickness of the chip
 static constexpr double passiveEdgeReadOut{1.5 * mm};                         // width of the readout edge -> dead zone
 constexpr int nRows{static_cast<int>((width - passiveEdgeReadOut) / pitchX)}; // number of rows in the chip
@@ -138,7 +138,6 @@ constexpr double pitchZ{10.0 * mu};
 constexpr double responseYShift{5 * mu}; /// center of the epitaxial layer
 constexpr double thickness{20 * mu};
 } // namespace alice3resp
-
 } // namespace o2::trk::constants
 
 #endif

From 056b5f4571a3c039e3ccae8cf9c7db19f74230f9 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 24 Mar 2026 08:48:11 +0100
Subject: [PATCH 1462/1764] DPL: get rid of the size method of the MessageSet
 (#15206)

One more step in getting rid of the artificial container "MessageSet".

By removing the size method, we imply that any sequence of messages can have their number of parts computed, regardless of how we store them and how the ownership of such parts works.
---
 Framework/Core/include/Framework/MessageSet.h |  6 -----
 Framework/Core/src/DataRelayer.cxx            | 24 +++++++++----------
 Framework/Core/test/benchmark_DataRelayer.cxx |  8 +++----
 Framework/Core/test/test_DataRelayer.cxx      | 12 +++++-----
 Framework/Core/test/test_ForwardInputs.cxx    | 24 +++++++++----------
 5 files changed, 34 insertions(+), 40 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 281f9c42a0773..166934238d647 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -82,12 +82,6 @@ struct MessageSet {
     return *this;
   }
 
-  /// get number of in-flight O2 messages
-  [[nodiscard]] size_t size() const
-  {
-    return messages | count_parts{};
-  }
-
   /// get number of header-payload pairs
   [[nodiscard]] size_t getNumberOfPairs() const
   {
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index cece5b343659f..5b85a63bf6c95 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -184,11 +184,11 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       // We check that no data is already there for the given cell
       // it is enough to check the first element
       auto& part = mCache[ti * mDistinctRoutesIndex.size() + expirator.routeIndex.value];
-      if (part.size() > 0 && part.header(0) != nullptr) {
+      if (!part.messages.empty() && part.header(0) != nullptr) {
         headerPresent++;
         continue;
       }
-      if (part.size() > 0 && part.payload(0) != nullptr) {
+      if (!part.messages.empty() && part.payload(0) != nullptr) {
         payloadPresent++;
         continue;
       }
@@ -213,7 +213,7 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       auto partial = getPartialRecord(ti);
       // TODO: get the data ref from message model
       auto getter = [&partial](size_t idx, size_t part) {
-        if (partial[idx].size() > 0 && partial[idx].header(part).get()) {
+        if (!partial[idx].messages.empty() && partial[idx].header(part).get()) {
           auto header = partial[idx].header(part).get();
           auto payload = partial[idx].payload(part).get();
           return DataRef{nullptr,
@@ -224,7 +224,7 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
         return DataRef{};
       };
       auto nPartsGetter = [&partial](size_t idx) {
-        return partial[idx].size();
+        return partial[idx].messages | count_parts{};
       };
       auto refCountGetter = [&partial](size_t idx) -> int {
         auto& header = static_cast<const fair::mq::shmem::Message&>(*partial[idx].header(0));
@@ -327,7 +327,7 @@ void DataRelayer::setOldestPossibleInput(TimesliceId proposed, ChannelIndex chan
     for (size_t mi = 0; mi < mInputs.size(); ++mi) {
       auto& input = mInputs[mi];
       auto& element = mCache[si * mInputs.size() + mi];
-      if (element.size() != 0) {
+      if (!element.messages.empty()) {
         if (input.lifetime != Lifetime::Condition && mCompletionPolicy.name != "internal-dpl-injected-dummy-sink") {
           didDrop = true;
           auto& state = mContext.get<DeviceState>();
@@ -353,7 +353,7 @@ void DataRelayer::setOldestPossibleInput(TimesliceId proposed, ChannelIndex chan
           continue;
         }
         auto& element = mCache[si * mInputs.size() + mi];
-        if (element.size() == 0) {
+        if (element.messages.empty()) {
           auto& state = mContext.get<DeviceState>();
           if (state.transitionHandling != TransitionHandlingState::NoTransition && DefaultsHelpers::onlineDeploymentMode()) {
             if (state.allowedProcessing == DeviceState::CalibrationOnly) {
@@ -411,11 +411,11 @@ void DataRelayer::pruneCache(TimesliceSlot slot, OnDropCallback onDrop)
         cachedStateMetrics[cacheId] = CacheEntryStatus::RUNNING;
         // TODO: in the original implementation of the cache, there have been only two messages per entry,
         // check if the 2 above corresponds to the number of messages.
-        if (cache[cacheId].size() > 0) {
+        if (!cache[cacheId].messages.empty()) {
           dropped[ai] = std::move(cache[cacheId]);
         }
       }
-      bool anyDropped = std::any_of(dropped.begin(), dropped.end(), [](auto& m) { return m.size(); });
+      bool anyDropped = std::any_of(dropped.begin(), dropped.end(), [](auto& m) { return !m.messages.empty(); });
       if (anyDropped) {
         O2_SIGNPOST_ID_GENERATE(aid, data_relayer);
         O2_SIGNPOST_EVENT_EMIT(data_relayer, aid, "pruneCache", "Dropping stuff from slot %zu with timeslice %zu", slot.index, oldestPossibleTimeslice.timeslice.value);
@@ -786,7 +786,7 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
     auto partial = getPartialRecord(li);
     // TODO: get the data ref from message model
     auto getter = [&partial](size_t idx, size_t part) {
-      if (partial[idx].size() > 0 && partial[idx].header(part).get()) {
+      if (!partial[idx].messages.empty() && partial[idx].header(part).get()) {
         auto header = partial[idx].header(part).get();
         auto payload = partial[idx].payload(part).get();
         return DataRef{nullptr,
@@ -797,7 +797,7 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
       return DataRef{};
     };
     auto nPartsGetter = [&partial](size_t idx) {
-      return partial[idx].size();
+      return partial[idx].messages | count_parts{};
     };
     auto refCountGetter = [&partial](size_t idx) -> int {
       auto& header = static_cast<const fair::mq::shmem::Message&>(*partial[idx].header(0));
@@ -897,7 +897,7 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeAllInputsForTimeslice
     cachedStateMetrics[cacheId] = CacheEntryStatus::RUNNING;
     // TODO: in the original implementation of the cache, there have been only two messages per entry,
     // check if the 2 above corresponds to the number of messages.
-    if (cache[cacheId].size() > 0) {
+    if (!cache[cacheId].messages.empty()) {
       messages[arg] = std::move(cache[cacheId]);
     }
     index.markAsInvalid(s);
@@ -951,7 +951,7 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeExistingInputsForTime
     cachedStateMetrics[cacheId] = CacheEntryStatus::RUNNING;
     // TODO: in the original implementation of the cache, there have been only two messages per entry,
     // check if the 2 above corresponds to the number of messages.
-    for (size_t pi = 0; pi < cache[cacheId].size(); pi++) {
+    for (size_t pi = 0; pi < (cache[cacheId].messages | count_parts{}); pi++) {
       auto& header = cache[cacheId].header(pi);
       auto&& newHeader = header->GetTransport()->CreateMessage();
       newHeader->Copy(*header);
diff --git a/Framework/Core/test/benchmark_DataRelayer.cxx b/Framework/Core/test/benchmark_DataRelayer.cxx
index 3c3d2294fdd7e..e983f3604cfab 100644
--- a/Framework/Core/test/benchmark_DataRelayer.cxx
+++ b/Framework/Core/test/benchmark_DataRelayer.cxx
@@ -96,7 +96,7 @@ static void BM_RelaySingleSlot(benchmark::State& state)
     assert(ready[0].op == CompletionPolicy::CompletionOp::Consume);
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     assert(result.size() == 1);
-    assert(result.at(0).size() == 1);
+    assert((result.at(0).messages | count_parts{}) == 1);
     inflightMessages = std::move(result[0].messages);
   }
 }
@@ -153,7 +153,7 @@ static void BM_RelayMultipleSlots(benchmark::State& state)
     assert(ready[0].op == CompletionPolicy::CompletionOp::Consume);
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     assert(result.size() == 1);
-    assert(result.at(0).size() == 1);
+    assert((result.at(0).messages | count_parts{}) == 1);
     inflightMessages = std::move(result[0].messages);
   }
 }
@@ -228,8 +228,8 @@ static void BM_RelayMultipleRoutes(benchmark::State& state)
     assert(ready[0].op == CompletionPolicy::CompletionOp::Consume);
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     assert(result.size() == 2);
-    assert(result.at(0).size() == 1);
-    assert(result.at(1).size() == 1);
+    assert((result.at(0).messages | count_parts{}) == 1);
+    assert((result.at(1).messages | count_parts{}) == 1);
     inflightMessages = std::move(result[0].messages);
     inflightMessages.emplace_back(std::move(result[1].messages[0]));
     inflightMessages.emplace_back(std::move(result[1].messages[1]));
diff --git a/Framework/Core/test/test_DataRelayer.cxx b/Framework/Core/test/test_DataRelayer.cxx
index 8957e361cb8a2..e5ca7c5d235e5 100644
--- a/Framework/Core/test/test_DataRelayer.cxx
+++ b/Framework/Core/test/test_DataRelayer.cxx
@@ -115,7 +115,7 @@ TEST_CASE("DataRelayer")
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     // one MessageSet with one PartRef with header and payload
     REQUIRE(result.size() == 1);
-    REQUIRE(result.at(0).size() == 1);
+    REQUIRE((result.at(0).messages | count_parts{}) == 1);
   }
 
   //
@@ -165,7 +165,7 @@ TEST_CASE("DataRelayer")
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     // one MessageSet with one PartRef with header and payload
     REQUIRE(result.size() == 1);
-    REQUIRE(result.at(0).size() == 1);
+    REQUIRE((result.at(0).messages | count_parts{}) == 1);
   }
 
   // This test a more complicated set of inputs, and verifies that data is
@@ -245,8 +245,8 @@ TEST_CASE("DataRelayer")
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     // two MessageSets, each with one PartRef
     REQUIRE(result.size() == 2);
-    REQUIRE(result.at(0).size() == 1);
-    REQUIRE(result.at(1).size() == 1);
+    REQUIRE((result.at(0).messages | count_parts{}) == 1);
+    REQUIRE((result.at(1).messages | count_parts{}) == 1);
   }
 
   // This test a more complicated set of inputs, and verifies that data is
@@ -733,7 +733,7 @@ TEST_CASE("DataRelayer")
     // we have one input route and thus one message set containing pairs for all
     // payloads
     REQUIRE(messageSet.size() == 1);
-    REQUIRE(messageSet[0].size() == nSplitParts);
+    REQUIRE((messageSet[0].messages | count_parts{}) == nSplitParts);
     REQUIRE(messageSet[0].getNumberOfPayloads(0) == 1);
   }
 
@@ -796,7 +796,7 @@ TEST_CASE("DataRelayer")
     // we have one input route
     REQUIRE(messageSet.size() == 1);
     // one message set containing number of added sequences of messages
-    REQUIRE(messageSet[0].size() == sequenceSize.size());
+    REQUIRE((messageSet[0].messages | count_parts{}) == sequenceSize.size());
     size_t counter = 0;
     for (auto seqid = 0; seqid < sequenceSize.size(); ++seqid) {
       REQUIRE(messageSet[0].getNumberOfPayloads(seqid) == sequenceSize[seqid]);
diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
index 7081d600080b1..e3031b7e72a69 100644
--- a/Framework/Core/test/test_ForwardInputs.cxx
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -92,7 +92,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRoute")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -143,7 +143,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteNoConsume")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, true);
@@ -198,7 +198,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteAtEOS")
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph, sih});
   REQUIRE(o2::header::get<SourceInfoHeader*>(header->GetData()));
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -256,7 +256,7 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteWithOldestPossible")
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph, dih});
   REQUIRE(o2::header::get<DomainInfoHeader*>(header->GetData()));
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -321,7 +321,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutes")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -384,7 +384,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesExternals")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -455,12 +455,12 @@ TEST_CASE("ForwardInputsMultiMessageMultipleRoutes")
   auto header1 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh1, dph});
   MessageSet messageSet1;
   messageSet1.add(PartRef{std::move(header1), std::move(payload1)});
-  REQUIRE(messageSet1.size() == 1);
+  REQUIRE((messageSet1.messages | count_parts{}) == 1);
 
   auto header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
   MessageSet messageSet2;
   messageSet2.add(PartRef{std::move(header2), std::move(payload2)});
-  REQUIRE(messageSet2.size() == 1);
+  REQUIRE((messageSet2.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet1));
   currentSetOfInputs.emplace_back(std::move(messageSet2));
   REQUIRE(currentSetOfInputs.size() == 2);
@@ -525,7 +525,7 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesOnlyOneMatches")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -607,7 +607,7 @@ TEST_CASE("ForwardInputsSplitPayload")
   PartRef part{std::move(header2), transport->CreateMessage()};
   messageSet.add(std::move(part));
 
-  REQUIRE(messageSet.size() == 2);
+  REQUIRE((messageSet.messages | count_parts{}) == 2);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -727,7 +727,7 @@ TEST_CASE("ForwardInputEOSSingleRoute")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, sih});
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -772,7 +772,7 @@ TEST_CASE("ForwardInputOldestPossibleSingleRoute")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dih});
   messageSet.add(PartRef{std::move(header), std::move(payload)});
-  REQUIRE(messageSet.size() == 1);
+  REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);

From 7cc1eed7a1ee3a3159259b23b5e1932dc7f6e5d6 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 23 Mar 2026 17:24:44 +0100
Subject: [PATCH 1463/1764] Fix using MeanVertex in the residuals monitoring
 workflow

---
 Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
index e6584a7055446..063edc65d7486 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
@@ -44,7 +44,7 @@
 
 // Attention: in case the residuals are checked with geometry different from the one used for initial reconstruction,
 // pass a --configKeyValues option for vertex refit as:
-// ;pvertexer.useMeanVertexConstraint=false;pvertexer.iniScale2=100;pvertexer.acceptableScale2=10.;
+// ;pvertexer.useMeanVertexConstraint=false;pvertexer.meanVertexExtraErrSelection=0.2;pvertexer.iniScale2=100;pvertexer.acceptableScale2=10.;
 // In any case, it is better to pass ;pvertexer.useMeanVertexConstraint=false;
 
 namespace o2::checkresid
@@ -152,6 +152,7 @@ void CheckResidSpec::updateTimeDependentParams(ProcessingContext& pc)
   }
   if (mMeanVertexUpdated) {
     mMeanVertexUpdated = false;
+    mVertexer.setMeanVertex(&mMeanVtx);
     mVertexer.initMeanVertexConstraint();
   }
   bool updateMaps = false;

From 80ca8b8f58e696b08c2865a958b3c84c99f7636d Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 24 Mar 2026 14:06:48 +0100
Subject: [PATCH 1464/1764] DPL: fix OutputSpec metadata ignored in workflow
 deserialization (#15204)

---
 .../Core/src/WorkflowSerializationHelpers.cxx |  5 +--
 .../Core/test/test_WorkflowSerialization.cxx  | 33 +++++++++++++++++++
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/WorkflowSerializationHelpers.cxx b/Framework/Core/src/WorkflowSerializationHelpers.cxx
index 9624a2dfd0d3e..b824e8d0bb424 100644
--- a/Framework/Core/src/WorkflowSerializationHelpers.cxx
+++ b/Framework/Core/src/WorkflowSerializationHelpers.cxx
@@ -430,10 +430,11 @@ struct WorkflowImporter : public rapidjson::BaseReaderHandler<rapidjson::UTF8<>,
       inputMatcherNodes.push_back(std::move(node));
     } else if (in(State::IN_OUTPUT)) {
       if (outputHasSubSpec) {
-        dataProcessors.back().outputs.push_back(OutputSpec({binding}, origin, description, subspec, lifetime));
+        dataProcessors.back().outputs.push_back(OutputSpec({binding}, origin, description, subspec, lifetime, outputOptions));
       } else {
-        dataProcessors.back().outputs.push_back(OutputSpec({binding}, {origin, description}, lifetime));
+        dataProcessors.back().outputs.push_back(OutputSpec({binding}, {origin, description}, lifetime, outputOptions));
       }
+      outputOptions.clear();
       outputHasSubSpec = false;
     } else if (in(State::IN_OPTION)) {
       std::unique_ptr<ConfigParamSpec> opt{nullptr};
diff --git a/Framework/Core/test/test_WorkflowSerialization.cxx b/Framework/Core/test/test_WorkflowSerialization.cxx
index 298956970713d..791c40c326733 100644
--- a/Framework/Core/test/test_WorkflowSerialization.cxx
+++ b/Framework/Core/test/test_WorkflowSerialization.cxx
@@ -120,3 +120,36 @@ TEST_CASE("TestVerifyWildcard")
   // also check if the conversion to ConcreteDataMatcher is working at import
   // REQUIRE(std::get_if<ConcreteDataTypeMatcher>(&w1[0].inputs[0].matcher) != nullptr);;
 }
+
+TEST_CASE("TestInputOutputSpecMetadata")
+{
+  WorkflowSpec wso{
+    DataProcessorSpec{
+      .name = "S1",
+      .outputs = {OutputSpec{OutputLabel{"o1"}, o2::header::DataOrigin{"TST"}, "OUTPUT1", 0, Lifetime::Timeframe, {{"param1", VariantType::Bool, true, ConfigParamSpec::HelpString{"\"\""}}, {"param2", VariantType::Bool, true, ConfigParamSpec::HelpString{"\"\""}}}},
+                  OutputSpec{OutputLabel{"o2"}, o2::header::DataOrigin{"TST"}, "OUTPUT2"}}}};
+
+  std::vector<DataProcessorInfo> dataProcessorInfoOut{
+    {.name = "S1", .executable = "test_Framework_test_SerializationWorkflow"},
+  };
+
+  CommandInfo commandInfoOut{"o2-dpl-workflow -b"};
+
+  std::vector<DataProcessorInfo> dataProcessorInfoIn{};
+  CommandInfo commandInfoIn;
+
+  std::ostringstream firstDump;
+  WorkflowSerializationHelpers::dump(firstDump, wso, dataProcessorInfoOut, commandInfoOut);
+  std::istringstream is;
+  is.str(firstDump.str());
+
+  WorkflowSpec wsi;
+  WorkflowSerializationHelpers::import(is, wsi, dataProcessorInfoIn, commandInfoIn);
+
+  REQUIRE(wsi[0].outputs[0].metadata.size() == 2);
+  REQUIRE(wsi[0].outputs[1].metadata.size() == 0);
+  REQUIRE(wso[0].outputs[0].metadata.size() == wsi[0].outputs[0].metadata.size());
+  REQUIRE(wso[0].outputs[1].metadata.size() == wsi[0].outputs[1].metadata.size());
+  REQUIRE(wso[0].outputs[0].metadata[0] == wsi[0].outputs[0].metadata[0]);
+  REQUIRE(wso[0].outputs[0].metadata[1] == wsi[0].outputs[0].metadata[1]);
+}

From 4edb7a80d92b8c3119e31026ed2adfbfe56f5692 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 24 Mar 2026 18:36:39 +0100
Subject: [PATCH 1465/1764] DPL Analysis: force index to only bind with tables
 of the same origin (#15177)

---
 Framework/Core/include/Framework/ASoA.h | 95 +++++++++++++++++++------
 1 file changed, 75 insertions(+), 20 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 475823b150d90..7a3307ae1a58c 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -1176,12 +1176,6 @@ struct TableIterator : IP, C... {
     return *this;
   }
 
-  template <typename... CL, typename TA>
-  void doSetCurrentIndex(framework::pack<CL...>, TA* current)
-  {
-    (CL::setCurrent(current), ...);
-  }
-
   template <typename CL>
   auto getCurrent() const
   {
@@ -1202,7 +1196,18 @@ struct TableIterator : IP, C... {
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
-    (doSetCurrentIndex(external_index_columns_t{}, current), ...);
+    ([this]<soa::is_index_column... CCs>(TA* cur, framework::pack<CCs...>) {
+      (CCs::setCurrent(cur), ...);
+    }(current, external_index_columns_t{}),
+     ...);
+  }
+
+  template <typename TA>
+  void bindExternalIndex(TA* current)
+  {
+    [this]<soa::is_index_column... CCs>(TA* cur, framework::pack<CCs...>) {
+      (CCs::setCurrent(cur), ...);
+    }(current, external_index_columns_t{});
   }
 
   template <typename... Cs>
@@ -1812,6 +1817,12 @@ consteval auto computeOriginals()
   return o2::soa::mergeOriginals<Ts...>();
 }
 
+template <size_t N, std::array<TableRef, N> refs>
+consteval auto commonOrigin()
+{
+  return (refs | std::ranges::views::filter([](TableRef const& r) { return (!(r.origin_hash == "DYN"_h || r.origin_hash == "IDX"_h)); })).front().origin_hash;
+}
+
 /// A Table class which observes an arrow::Table and provides
 /// It is templated on a set of Column / DynamicColumn types.
 template <aod::is_aod_hash L, aod::is_aod_hash D, aod::is_origin_hash O, typename... Ts>
@@ -1823,7 +1834,10 @@ class Table
   using table_t = self_t;
 
   static constexpr const auto originals = computeOriginals<ref, Ts...>();
-  static constexpr const auto originalLabels = []<size_t N, std::array<TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) { return std::array<const char*, N>{o2::aod::label<refs[Is]>()...}; }.template operator()<originals.size(), originals>(std::make_index_sequence<originals.size()>());
+  static constexpr const auto originalLabels = []<size_t N, std::array<TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) {
+    return std::array<const char*, N>{o2::aod::label<refs[Is]>()...};
+  }.template operator()<originals.size(), originals>(std::make_index_sequence<originals.size()>());
+  static constexpr const uint32_t binding_origin = commonOrigin<originals.size(), originals>();
 
   template <size_t N, std::array<TableRef, N> bindings>
     requires(ref.origin_hash == "CONC"_h)
@@ -1836,10 +1850,10 @@ class Table
     requires(ref.origin_hash == "JOIN"_h)
   static consteval auto isIndexTargetOf()
   {
-    return std::find_if(self_t::originals.begin(), self_t::originals.end(),
-                        [](TableRef const& r) {
-                          return std::find(bindings.begin(), bindings.end(), r) != bindings.end();
-                        }) != self_t::originals.end();
+    return std::ranges::find_if(self_t::originals,
+                                [](TableRef const& r) {
+                                  return std::ranges::find(bindings, r) != bindings.end();
+                                }) != self_t::originals.end();
   }
 
   template <size_t N, std::array<TableRef, N> bindings>
@@ -2179,7 +2193,18 @@ class Table
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
-    mBegin.bindExternalIndices(current...);
+    ([this](TA* cur) {
+      if constexpr (binding_origin == TA::binding_origin) {
+        mBegin.bindExternalIndex(cur);
+      }
+    }(current),
+     ...);
+  }
+
+  template <typename TA>
+  void bindExternalIndex(TA* current)
+  {
+    mBegin.bindExternalIndex(current); // unchecked binding for the derived tables
   }
 
   template <typename I>
@@ -3395,6 +3420,18 @@ struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts.
   }
   using base::bindExternalIndices;
   using base::bindInternalIndicesTo;
+  static constexpr const uint32_t binding_origin = base::binding_origin;
+
+  template <typename... TA>
+  void bindExternalIndices(TA*... current)
+  {
+    ([this](TA* cur) {
+      if constexpr (binding_origin == TA::binding_origin) {
+        this->bindExternalIndex(cur);
+      }
+    }(current),
+     ...);
+  }
 
   using self_t = JoinFull<D, Ts...>;
   using table_t = base;
@@ -3524,6 +3561,18 @@ class FilteredBase : public T
   using self_t = FilteredBase<T>;
   using table_t = typename T::table_t;
   using T::originals;
+  static constexpr const uint32_t binding_origin = T::binding_origin;
+  template <typename... TA>
+  void bindExternalIndices(TA*... current)
+  {
+    ([this](TA* cur) {
+      if constexpr (binding_origin == TA::binding_origin) {
+        this->bindExternalIndex(cur);
+        mFilteredBegin.bindExternalIndex(cur);
+      }
+    }(current),
+     ...);
+  }
   using columns_t = typename T::columns_t;
   using persistent_columns_t = typename T::persistent_columns_t;
   using external_index_columns_t = typename T::external_index_columns_t;
@@ -3645,13 +3694,6 @@ class FilteredBase : public T
 
   /// Bind the columns which refer to other tables
   /// to the associated tables.
-  template <typename... TA>
-  void bindExternalIndices(TA*... current)
-  {
-    table_t::bindExternalIndices(current...);
-    mFilteredBegin.bindExternalIndices(current...);
-  }
-
   void bindExternalIndicesRaw(std::vector<o2::soa::Binding>&& ptrs)
   {
     mFilteredBegin.bindExternalIndicesRaw(std::forward<std::vector<o2::soa::Binding>>(ptrs));
@@ -4134,6 +4176,19 @@ struct IndexTable : Table<L, D, O> {
   using first_t = typename H::binding_t;
   using rest_t = framework::pack<typename Ts::binding_t...>;
 
+  static constexpr const uint32_t binding_origin = Key::binding_origin;
+
+  template <typename... TA>
+  void bindExternalIndices(TA*... current)
+  {
+    ([this](TA* cur) {
+      if constexpr (binding_origin == TA::binding_origin) {
+        this->bindExternalIndex(cur);
+      }
+    }(current),
+     ...);
+  }
+
   IndexTable(std::shared_ptr<arrow::Table> table, uint64_t offset = 0)
     : base_t{table, offset}
   {

From 78b931b838cbfdcdbbf2789c80b0fa98d7b60f24 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Tue, 24 Mar 2026 20:39:06 +0100
Subject: [PATCH 1466/1764] ZDC: Delete unused files (#15028)

---
 .../ZDC/include/DataFormatsZDC/FEEConfig.h    | 52 -------------------
 1 file changed, 52 deletions(-)
 delete mode 100644 DataFormats/Detectors/ZDC/include/DataFormatsZDC/FEEConfig.h

diff --git a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/FEEConfig.h b/DataFormats/Detectors/ZDC/include/DataFormatsZDC/FEEConfig.h
deleted file mode 100644
index b084507b84519..0000000000000
--- a/DataFormats/Detectors/ZDC/include/DataFormatsZDC/FEEConfig.h
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-//
-// DataFormats/Detectors/ZDC/include/DataFormatsZDC/RawEventData.h
-
-#include "ZDCBase/Constants.h"
-
-#ifndef ALICEO2_ZDC_FEECONFIG_H
-#define ALICEO2_ZDC_FEECONFIG_H
-
-/// \file FEEConfig.h
-/// \brief ZDC FEE configuration
-/// \author pietro.cortese@cern.ch
-
-namespace o2
-{
-namespace zdc
-{
-
-struct FEEFillingMap {
-  uint64_t filling[56];
-};
-
-struct FEEConfigMap {
-  uint32_t address[5 * NChPerModule + 3] = {0, 1, 2, 3,
-                                            4, 5, 6, 7,
-                                            8, 9, 10, 11,
-                                            12, 13, 14, 15,
-                                            16, 17, 18, 19,
-                                            76, 77, 78};
-  uint64_t delay_sample[NChPerModule] = {6, 6, 6, 6};                                   // 4 bits
-  uint64_t delay_coarse[NChPerModule] = {200, 200, 200, 200};                           // 8 bits
-  uint64_t threshold_level[NChPerModule] = {10, 10, 10, 10};                            // 12 bits
-  uint64_t difference_delta[NChPerModule] = {4, 4, 4, 4};                               // 3 bits
-  uint64_t masking_difference[NChPerModule] = {0x00ff00, 0x00ff00, 0x00ff00, 0x00ff00}; // 24 bits
-  uint64_t masking_alicet = 0x00000010;                                                 // 32 bits
-  uint64_t masking_autot = 0xf;                                                         // 4 bits
-  uint64_t masking_readout = 0xf;                                                       // 4 bits
-};
-
-} // namespace zdc
-} // namespace o2
-
-#endif

From 4afa537700c0f0f89505d07f534a6de6ed3fb07f Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 25 Mar 2026 13:53:24 +0100
Subject: [PATCH 1467/1764] Filter raw linker flags from GBL_LIBRARIES (#15162)

---
 dependencies/O2Dependencies.cmake | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/dependencies/O2Dependencies.cmake b/dependencies/O2Dependencies.cmake
index 71e9d9907ac28..850ba0b909acc 100644
--- a/dependencies/O2Dependencies.cmake
+++ b/dependencies/O2Dependencies.cmake
@@ -286,12 +286,25 @@ find_package(GBL)
 set_package_properties(GBL PROPERTIES TYPE REQUIRED)
 if(GBL_FOUND AND NOT TARGET GBL::GBL)
     # As of now, GBL does not provide a cmake target so create a compatibility wrapper
+    # also GBL_LIBRARIES contains raw linker flags to ROOT we need to filter out
+    set(GBL_LIBRARIES_FILTERED "")
+    set(GBL_LINK_OPTIONS "")
+    foreach(_lib IN LISTS GBL_LIBRARIES)
+        if(_lib MATCHES "^-[lL]")
+            continue()
+        elseif(_lib MATCHES "^-")
+            list(APPEND GBL_LINK_OPTIONS "${_lib}")
+        else()
+            list(APPEND GBL_LIBRARIES_FILTERED "${_lib}")
+        endif()
+    endforeach()
     add_library(GBL::GBL INTERFACE IMPORTED)
     target_include_directories(GBL::GBL INTERFACE ${GBL_INCLUDE_DIR})
     target_link_libraries(GBL::GBL INTERFACE
-        ${GBL_LIBRARIES}
+        ${GBL_LIBRARIES_FILTERED}
         Eigen3::Eigen
     )
+    target_link_options(GBL::GBL INTERFACE ${GBL_LINK_OPTIONS})
 endif()
 
 feature_summary(WHAT ALL FATAL_ON_MISSING_REQUIRED_PACKAGES)

From a628b60489e45123f21c0eb3b721fc58e255ce9d Mon Sep 17 00:00:00 2001
From: ehellbar <ernst.hellbar@cern.ch>
Date: Wed, 25 Mar 2026 15:53:54 +0100
Subject: [PATCH 1468/1764] DPL: use constexpr for data description of EOS data
 header (#15175)

---
 DataFormats/Headers/include/Headers/DataHeader.h          | 1 +
 Framework/Core/src/ExternalFairMQDeviceProxy.cxx          | 4 ++--
 Framework/Core/test/test_ExternalFairMQDeviceWorkflow.cxx | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/DataFormats/Headers/include/Headers/DataHeader.h b/DataFormats/Headers/include/Headers/DataHeader.h
index b44f41c5d3cb3..dbcdb8e0bba89 100644
--- a/DataFormats/Headers/include/Headers/DataHeader.h
+++ b/DataFormats/Headers/include/Headers/DataHeader.h
@@ -600,6 +600,7 @@ constexpr o2::header::DataDescription gDataDescriptionClusters{"CLUSTERS"};
 constexpr o2::header::DataDescription gDataDescriptionTracks{"TRACKS"};
 constexpr o2::header::DataDescription gDataDescriptionConfig{"CONFIGURATION"};
 constexpr o2::header::DataDescription gDataDescriptionInfo{"INFORMATION"};
+constexpr o2::header::DataDescription gDataDescriptionEos{"EOS"};
 constexpr o2::header::DataDescription gDataDescriptionROOTStreamers{"ROOT STREAMERS"};
 constexpr o2::header::DataDescription gDataDescriptionDISTSTF{"DISTSUBTIMEFRAME"};
 /// @} // end of doxygen group
diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index 3b0275879a158..5867f53af4bd2 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -1005,7 +1005,7 @@ DataProcessorSpec specifyFairMQDeviceOutputProxy(char const* name,
         }
         DataHeader dh;
         dh.dataOrigin = "DPL";
-        dh.dataDescription = "EOS";
+        dh.dataDescription = o2::header::gDataDescriptionEos;
         dh.subSpecification = 0;
         dh.payloadSize = 0;
         dh.runNumber = runNumber;
@@ -1137,7 +1137,7 @@ DataProcessorSpec specifyFairMQDeviceMultiOutputProxy(char const* name,
         }
         DataHeader dh;
         dh.dataOrigin = "DPL";
-        dh.dataDescription = "EOS";
+        dh.dataDescription = o2::header::gDataDescriptionEos;
         dh.subSpecification = 0;
         dh.payloadSize = 0;
         dh.payloadSerializationMethod = o2::header::gSerializationMethodNone;
diff --git a/Framework/Core/test/test_ExternalFairMQDeviceWorkflow.cxx b/Framework/Core/test/test_ExternalFairMQDeviceWorkflow.cxx
index 6c991aba7fff5..b69cae5819fbf 100644
--- a/Framework/Core/test/test_ExternalFairMQDeviceWorkflow.cxx
+++ b/Framework/Core/test/test_ExternalFairMQDeviceWorkflow.cxx
@@ -243,7 +243,7 @@ std::vector<DataProcessorSpec> defineDataProcessing(ConfigContext const& config)
           // since we are sending on the bare channel, also the EOS message needs to be created.
           DataHeader dhEOS;
           dhEOS.dataOrigin = "DPL";
-          dhEOS.dataDescription = "EOS";
+          dhEOS.dataDescription = o2::header::gDataDescriptionEos;
           dhEOS.subSpecification = 0;
           dhEOS.payloadSize = 0;
           dhEOS.payloadSerializationMethod = o2::header::gSerializationMethodNone;

From 5768b117ee9eeeb16d1c84e384bb51d74084a293 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 25 Mar 2026 14:01:41 +0100
Subject: [PATCH 1469/1764] start_tmux.sh: remove double-checking for existing
 shm segments

---
 prodtests/full-system-test/start_tmux.sh | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/prodtests/full-system-test/start_tmux.sh b/prodtests/full-system-test/start_tmux.sh
index fb69cc1e6baec..18f019573904f 100755
--- a/prodtests/full-system-test/start_tmux.sh
+++ b/prodtests/full-system-test/start_tmux.sh
@@ -12,14 +12,7 @@ if [[ "${FST_RUN_WITHOUT_CHECKS:-0}" != "1" ]]; then
     exit 1
   fi
 
-  # 2. Abort if FMQ shared-memory files exist in /dev/shm
-  if compgen -G "/dev/shm/fmq*" > /dev/null; then
-    echo "ERROR: Found existing /dev/shm/fmq* files." >&2
-    echo "Please clean them manually before running the FST." >&2
-    exit 1
-  fi
-
-  # 3. MI100 check: detect MI100 GPU but EPN_NODE_MI100 not set or set to 0
+  # 2. MI100 check: detect MI100 GPU but EPN_NODE_MI100 not set or set to 0
   if lspci | grep -qi "MI100"; then
     if [[ -z "${EPN_NODE_MI100:-}" || "${EPN_NODE_MI100}" == "0" ]]; then
       echo "ERROR: MI100 GPU detected on this node, but EPN_NODE_MI100 is not set to 1." >&2

From 349a25edb8db27f8ca0888a496ed5b2f3eafdc37 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 24 Mar 2026 14:37:50 +0100
Subject: [PATCH 1470/1764] DPL: move away from MessageSet::header / payload

Abstract header / payload retrieval, with the idea that get_header / get_payload
will work on any range of fair::mq::MessagePtrs.

For now we only do the first header / payload pair only, to validate the trivial change.
---
 Framework/Core/include/Framework/DataModelViews.h |  4 ++--
 Framework/Core/src/DataProcessingDevice.cxx       |  2 +-
 Framework/Core/src/DataRelayer.cxx                | 12 ++++++------
 Framework/Core/test/test_DataRelayer.cxx          |  8 ++++----
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/Framework/Core/include/Framework/DataModelViews.h b/Framework/Core/include/Framework/DataModelViews.h
index f42ef85ec78e1..73faf7699834d 100644
--- a/Framework/Core/include/Framework/DataModelViews.h
+++ b/Framework/Core/include/Framework/DataModelViews.h
@@ -153,7 +153,7 @@ struct get_header {
   // ends the pipeline, returns the number of parts
   template <typename R>
     requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
-  friend fair::mq::MessagePtr& operator|(R&& r, get_header self)
+  friend auto& operator|(R&& r, get_header self)
   {
     return r[(r | get_dataref_indices{self.id, 0}).headerIdx];
   }
@@ -165,7 +165,7 @@ struct get_payload {
   // ends the pipeline, returns the number of parts
   template <typename R>
     requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
-  friend fair::mq::MessagePtr& operator|(R&& r, get_payload self)
+  friend auto& operator|(R&& r, get_payload self)
   {
     return r[(r | get_dataref_indices{self.part, self.subPart}).payloadIdx];
   }
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index da04a23e81c0c..0fa70947bf18c 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -2153,7 +2153,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
       return currentSetOfInputs[i].getNumberOfPairs();
     };
     auto refCountGetter = [&currentSetOfInputs](size_t idx) -> int {
-      auto& header = static_cast<const fair::mq::shmem::Message&>(*currentSetOfInputs[idx].header(0));
+      auto& header = static_cast<const fair::mq::shmem::Message&>(*(currentSetOfInputs[idx].messages | get_header{0}));
       return header.GetRefCount();
     };
     return InputSpan{getter, nofPartsGetter, refCountGetter, currentSetOfInputs.size()};
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 5b85a63bf6c95..7eb851e2aadd8 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -184,11 +184,11 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       // We check that no data is already there for the given cell
       // it is enough to check the first element
       auto& part = mCache[ti * mDistinctRoutesIndex.size() + expirator.routeIndex.value];
-      if (!part.messages.empty() && part.header(0) != nullptr) {
+      if (!part.messages.empty() && (part.messages | get_header{0}) != nullptr) {
         headerPresent++;
         continue;
       }
-      if (!part.messages.empty() && part.payload(0) != nullptr) {
+      if (!part.messages.empty() && (part.messages | get_payload{0, 0}) != nullptr) {
         payloadPresent++;
         continue;
       }
@@ -227,7 +227,7 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
         return partial[idx].messages | count_parts{};
       };
       auto refCountGetter = [&partial](size_t idx) -> int {
-        auto& header = static_cast<const fair::mq::shmem::Message&>(*partial[idx].header(0));
+        auto& header = static_cast<const fair::mq::shmem::Message&>(*(partial[idx].messages | get_header{0}));
         return header.GetRefCount();
       };
       InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
@@ -246,8 +246,8 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       activity.expiredSlots++;
 
       mTimesliceIndex.markAsDirty(slot, true);
-      assert(part.header(0) != nullptr);
-      assert(part.payload(0) != nullptr);
+      assert((part.messages | get_header{0}) != nullptr);
+      assert((part.messages | get_payload{0, 0}) != nullptr);
     }
   }
   LOGP(debug, "DataRelayer::processDanglingInputs headerPresent:{}, payloadPresent:{}, noCheckers:{}, badSlot:{}, checkerDenied:{}",
@@ -800,7 +800,7 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
       return partial[idx].messages | count_parts{};
     };
     auto refCountGetter = [&partial](size_t idx) -> int {
-      auto& header = static_cast<const fair::mq::shmem::Message&>(*partial[idx].header(0));
+      auto& header = static_cast<const fair::mq::shmem::Message&>(*(partial[idx].messages | get_header{0}));
       return header.GetRefCount();
     };
     InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
diff --git a/Framework/Core/test/test_DataRelayer.cxx b/Framework/Core/test/test_DataRelayer.cxx
index e5ca7c5d235e5..e4aa35286942d 100644
--- a/Framework/Core/test/test_DataRelayer.cxx
+++ b/Framework/Core/test/test_DataRelayer.cxx
@@ -798,11 +798,11 @@ TEST_CASE("DataRelayer")
     // one message set containing number of added sequences of messages
     REQUIRE((messageSet[0].messages | count_parts{}) == sequenceSize.size());
     size_t counter = 0;
-    for (auto seqid = 0; seqid < sequenceSize.size(); ++seqid) {
+    for (size_t seqid = 0; seqid < sequenceSize.size(); ++seqid) {
       REQUIRE(messageSet[0].getNumberOfPayloads(seqid) == sequenceSize[seqid]);
-      for (auto pi = 0; pi < messageSet[0].getNumberOfPayloads(seqid); ++pi) {
-        REQUIRE(messageSet[0].payload(seqid, pi));
-        auto const* data = messageSet[0].payload(seqid, pi)->GetData();
+      for (size_t pi = 0; pi < messageSet[0].getNumberOfPayloads(seqid); ++pi) {
+        REQUIRE((messageSet[0].messages | get_payload{seqid, pi}));
+        auto const* data = (messageSet[0].messages | get_payload{seqid, pi})->GetData();
         REQUIRE(*(reinterpret_cast<size_t const*>(data)) == counter);
         ++counter;
       }

From 45df7ad30d1515e0f9fa68f321ee91a4536bbbfb Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 26 Mar 2026 03:27:35 +0100
Subject: [PATCH 1471/1764] DPL: fix DataModelViews behavior (#15212)

---
 .../Core/include/Framework/DataModelViews.h   |  43 +--
 Framework/Core/test/test_DataRelayer.cxx      | 159 +++++++++++
 Framework/Core/test/test_MessageSet.cxx       | 250 ++++++++++++++++++
 3 files changed, 435 insertions(+), 17 deletions(-)

diff --git a/Framework/Core/include/Framework/DataModelViews.h b/Framework/Core/include/Framework/DataModelViews.h
index 73faf7699834d..7c39a94950e9c 100644
--- a/Framework/Core/include/Framework/DataModelViews.h
+++ b/Framework/Core/include/Framework/DataModelViews.h
@@ -70,7 +70,7 @@ struct count_parts {
         count += 1;
         mi += header->splitPayloadParts + 1;
       } else {
-        count += header->splitPayloadParts;
+        count += header->splitPayloadParts ? header->splitPayloadParts : 1;
         mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
       }
     }
@@ -104,11 +104,11 @@ struct get_pair {
         }
         mi += header->splitPayloadParts + 1;
       } else {
-        count += header->splitPayloadParts ? header->splitPayloadParts : 1;
-        if (self.pairId < count) {
-          return {mi, mi + 2 * diff + 1};
+        if (self.pairId == count) {
+          return {mi, mi + 1};
         }
-        mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
+        count += 1;
+        mi += 2;
       }
     }
     throw std::runtime_error("Payload not found");
@@ -138,10 +138,10 @@ struct get_dataref_indices {
         mi += header->splitPayloadParts + 1;
       } else {
         if (self.part == count) {
-          return {mi, mi + 2 * self.subPart + 1};
+          return {mi, mi + self.subPart + 1};
         }
         count += 1;
-        mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
+        mi += 2;
       }
     }
     throw std::runtime_error("Payload not found");
@@ -172,32 +172,41 @@ struct get_payload {
 };
 
 struct get_num_payloads {
-  size_t id;
-  // ends the pipeline, returns the number of parts
+  size_t n;
+  // ends the pipeline, returns the number of payloads which are associated
+  // to the multipart n-th sequence of messages found in the range
   template <typename R>
     requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
   friend size_t operator|(R&& r, get_num_payloads self)
   {
     size_t count = 0;
     size_t mi = 0;
+    // Un
     while (mi < r.size()) {
       auto* header = o2::header::get<o2::header::DataHeader*>(r[mi]->GetData());
       if (!header) {
         throw std::runtime_error("Not a DataHeader");
       }
-      if (self.id == count) {
-        if (header->splitPayloadParts > 1 && (header->splitPayloadIndex == header->splitPayloadParts)) {
+      if (header->splitPayloadParts > 1 && (header->splitPayloadIndex == header->splitPayloadParts)) {
+        // This is the case for the new multi payload messages where the number of parts
+        // is as many as the splitPayloadParts number.
+        if (self.n == count) {
           return header->splitPayloadParts;
-        } else {
-          return 1;
         }
-      }
-      if (header->splitPayloadParts > 1 && (header->splitPayloadIndex == header->splitPayloadParts)) {
+        // For multipayload we skip all the parts and their associated header
         count += 1;
         mi += header->splitPayloadParts + 1;
       } else {
-        count += 1;
-        mi += header->splitPayloadParts ? 2 * header->splitPayloadParts : 2;
+        // This is the case of a multipart (header, payload), (header, payload), ...
+        // sequence where we know how many pairs are there.
+        // When splitPayloadParts == 0, it means it is a non-multipart (header, payload)
+        // pair. Each pair has exactly 1 payload.
+        auto pairs = header->splitPayloadParts ? header->splitPayloadParts : 1;
+        if (self.n < count + pairs) {
+          return 1;
+        }
+        count += pairs;
+        mi += 2 * pairs;
       }
     }
     return 0;
diff --git a/Framework/Core/test/test_DataRelayer.cxx b/Framework/Core/test/test_DataRelayer.cxx
index e4aa35286942d..1f7518860bf57 100644
--- a/Framework/Core/test/test_DataRelayer.cxx
+++ b/Framework/Core/test/test_DataRelayer.cxx
@@ -26,6 +26,10 @@
 #include "Framework/WorkflowSpec.h"
 #include <Monitoring/Monitoring.h>
 #include <fairmq/TransportFactory.h>
+#include <fairmq/Channel.h>
+#include "Framework/FairMQDeviceProxy.h"
+#include "Framework/ExpirationHandler.h"
+#include "Framework/LifetimeHelpers.h"
 #include <array>
 #include <vector>
 #include <uv.h>
@@ -808,4 +812,159 @@ TEST_CASE("DataRelayer")
       }
     }
   }
+
+  SECTION("ProcessDanglingInputs")
+  {
+    InputSpec spec{"condition", "TST", "COND"};
+    std::vector<InputRoute> inputs = {
+      InputRoute{spec, 0, "from_source_to_self", 0}};
+
+    std::vector<InputChannelInfo> infos{1};
+    TimesliceIndex index{1, infos};
+    ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
+
+    // Bind a fake input channel so FairMQDeviceProxy::getInputChannelIndex works
+    FairMQDeviceProxy proxy;
+    std::vector<fair::mq::Channel> channels{fair::mq::Channel("from_source_to_self")};
+    auto findChannel = [&channels](std::string const& name) -> fair::mq::Channel& {
+      for (auto& ch : channels) {
+        if (ch.GetName() == name) {
+          return ch;
+        }
+      }
+      throw std::runtime_error("Channel not found: " + name);
+    };
+    proxy.bind({}, inputs, {}, findChannel, [] { return false; });
+    ref.registerService(ServiceRegistryHelpers::handleForService<FairMQDeviceProxy>(&proxy));
+
+    auto policy = CompletionPolicyHelpers::consumeWhenAny();
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
+    relayer.setPipelineLength(4);
+
+    auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+    auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+
+    DataHeader dh{"COND", "TST", 0};
+    dh.splitPayloadParts = 1;
+    dh.splitPayloadIndex = 0;
+    DataProcessingHeader dph{0, 1};
+
+    ExpirationHandler handler;
+    handler.name = "test-condition";
+    handler.routeIndex = RouteIndex{0};
+    handler.lifetime = Lifetime::Condition;
+
+    // Creator: claim an empty slot and assign timeslice 0 to it
+    handler.creator = [](ServiceRegistryRef services, ChannelIndex channelIndex) -> TimesliceSlot {
+      auto& index = services.get<TimesliceIndex>();
+      for (size_t si = 0; si < index.size(); si++) {
+        TimesliceSlot slot{si};
+        if (!index.isValid(slot)) {
+          index.associate(TimesliceId{0}, slot);
+          (void)index.setOldestPossibleInput({1}, channelIndex);
+          return slot;
+        }
+      }
+      return TimesliceSlot{TimesliceSlot::INVALID};
+    };
+
+    // Checker: always trigger expiration
+    handler.checker = LifetimeHelpers::expireAlways();
+
+    // Handler: materialise a dummy header+payload into the PartRef
+    handler.handler = [&transport, &channelAlloc, &dh, &dph](ServiceRegistryRef, PartRef& ref, data_matcher::VariableContext&) {
+      ref.header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+      ref.payload = transport->CreateMessage(4);
+    };
+
+    std::vector<ExpirationHandler> handlers{handler};
+    auto activity = relayer.processDanglingInputs(handlers, {registry}, true);
+
+    REQUIRE(activity.newSlots == 1);
+    REQUIRE(activity.expiredSlots == 1);
+
+    // The materialised data should now be ready to consume
+    std::vector<RecordAction> ready;
+    relayer.getReadyToProcess(ready);
+    REQUIRE(ready.size() == 1);
+    REQUIRE(ready[0].op == CompletionPolicy::CompletionOp::Consume);
+
+    auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
+    REQUIRE(result.size() == 1);
+    REQUIRE((result.at(0).messages | count_parts{}) == 1);
+  }
+
+  SECTION("ProcessDanglingInputsSkipsWhenDataPresent")
+  {
+    // processDanglingInputs must not overwrite a slot that already has data.
+    // This is guarded by the (part.messages | get_header{0}) != nullptr check.
+    InputSpec spec{"condition", "TST", "COND"};
+    std::vector<InputRoute> inputs = {
+      InputRoute{spec, 0, "from_source_to_self", 0}};
+
+    std::vector<InputChannelInfo> infos{1};
+    TimesliceIndex index{1, infos};
+    ref.registerService(ServiceRegistryHelpers::handleForService<TimesliceIndex>(&index));
+
+    FairMQDeviceProxy proxy;
+    std::vector<fair::mq::Channel> channels{fair::mq::Channel("from_source_to_self")};
+    auto findChannel = [&channels](std::string const& name) -> fair::mq::Channel& {
+      for (auto& ch : channels) {
+        if (ch.GetName() == name) {
+          return ch;
+        }
+      }
+      throw std::runtime_error("Channel not found: " + name);
+    };
+    proxy.bind({}, inputs, {}, findChannel, [] { return false; });
+    ref.registerService(ServiceRegistryHelpers::handleForService<FairMQDeviceProxy>(&proxy));
+
+    auto policy = CompletionPolicyHelpers::consumeWhenAny();
+    DataRelayer relayer(policy, inputs, index, {registry}, -1);
+    relayer.setPipelineLength(4);
+
+    auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+    auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+
+    DataHeader dh{"COND", "TST", 0};
+    dh.splitPayloadParts = 1;
+    dh.splitPayloadIndex = 0;
+    DataProcessingHeader dph{0, 1};
+
+    // Build an expiration handler that always tries to expire
+    ExpirationHandler handler;
+    handler.name = "test-condition";
+    handler.routeIndex = RouteIndex{0};
+    handler.lifetime = Lifetime::Condition;
+    handler.creator = [](ServiceRegistryRef services, ChannelIndex channelIndex) -> TimesliceSlot {
+      auto& index = services.get<TimesliceIndex>();
+      for (size_t si = 0; si < index.size(); si++) {
+        TimesliceSlot slot{si};
+        if (!index.isValid(slot)) {
+          index.associate(TimesliceId{0}, slot);
+          (void)index.setOldestPossibleInput({1}, channelIndex);
+          return slot;
+        }
+      }
+      return TimesliceSlot{TimesliceSlot::INVALID};
+    };
+    handler.checker = LifetimeHelpers::expireAlways();
+    int handlerCallCount = 0;
+    handler.handler = [&transport, &channelAlloc, &dh, &dph, &handlerCallCount](ServiceRegistryRef, PartRef& ref, data_matcher::VariableContext&) {
+      ref.header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
+      ref.payload = transport->CreateMessage(4);
+      handlerCallCount++;
+    };
+    std::vector<ExpirationHandler> handlers{handler};
+
+    // First call: slot is empty, so the handler fires and materialises data
+    auto activity1 = relayer.processDanglingInputs(handlers, {registry}, true);
+    REQUIRE(activity1.expiredSlots == 1);
+    REQUIRE(handlerCallCount == 1);
+
+    // Second call: slot already has data — the handler must NOT fire again
+    auto activity2 = relayer.processDanglingInputs(handlers, {registry}, false);
+    REQUIRE(activity2.expiredSlots == 0);
+    REQUIRE(handlerCallCount == 1); // handler was not called a second time
+  }
 }
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index 37f823197ef18..290e55220d6cb 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -12,8 +12,10 @@
 #include <fairmq/Message.h>
 #include <fairmq/TransportFactory.h>
 #include "Framework/MessageSet.h"
+#include "Framework/DataModelViews.h"
 #include "Framework/DataProcessingHeader.h"
 #include "Headers/Stack.h"
+#include "Headers/DataHeader.h"
 #include "MemoryResources/MemoryResources.h"
 #include <catch_amalgamated.hpp>
 
@@ -43,6 +45,12 @@ TEST_CASE("MessageSet")
   REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
   REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
   CHECK_THROWS((msgSet.messages | get_pair{1}));
+  // Validate pipe operators match old API
+  REQUIRE(&(msgSet.messages | get_header{0}) == &msgSet.header(0));
+  REQUIRE(&(msgSet.messages | get_payload{0, 0}) == &msgSet.payload(0));
+  REQUIRE((msgSet.messages | get_num_payloads{0}) == msgSet.messageMap[0].size);
+  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
+  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
 }
 
 TEST_CASE("MessageSetWithFunction")
@@ -68,6 +76,11 @@ TEST_CASE("MessageSetWithFunction")
   REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
   REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
   CHECK_THROWS((msgSet.messages | get_pair{1}));
+  REQUIRE(&(msgSet.messages | get_header{0}) == &msgSet.header(0));
+  REQUIRE(&(msgSet.messages | get_payload{0, 0}) == &msgSet.payload(0));
+  REQUIRE((msgSet.messages | get_num_payloads{0}) == msgSet.messageMap[0].size);
+  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
+  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
 }
 
 TEST_CASE("MessageSetWithMultipart")
@@ -99,6 +112,13 @@ TEST_CASE("MessageSetWithMultipart")
   REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 0);
   REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 2);
   CHECK_THROWS((msgSet.messages | get_pair{2}));
+  // Validate pipe operators match old API for multi-payload
+  REQUIRE(&(msgSet.messages | get_header{0}) == &msgSet.header(0));
+  REQUIRE(&(msgSet.messages | get_payload{0, 0}) == &msgSet.payload(0, 0));
+  REQUIRE(&(msgSet.messages | get_payload{0, 1}) == &msgSet.payload(0, 1));
+  REQUIRE((msgSet.messages | get_num_payloads{0}) == msgSet.messageMap[0].size);
+  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
+  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
 }
 
 TEST_CASE("MessageSetAddPartRef")
@@ -170,4 +190,234 @@ TEST_CASE("MessageSetAddMultiple")
   REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 5);
   REQUIRE((msgSet.messages | get_pair{3}).headerIdx == 4);
   REQUIRE((msgSet.messages | get_pair{3}).payloadIdx == 6);
+  // Validate pipe operators match old API for mixed modes
+  for (size_t i = 0; i < 3; ++i) {
+    REQUIRE(&(msgSet.messages | get_header{i}) == &msgSet.header(i));
+    REQUIRE(&(msgSet.messages | get_payload{i, 0}) == &msgSet.payload(i, 0));
+  }
+  // Part 2 has a second payload (multi-payload with splitPayloadParts=2, splitPayloadIndex=2)
+  REQUIRE(&(msgSet.messages | get_payload{2, 1}) == &msgSet.payload(2, 1));
+  for (size_t i = 0; i < 3; ++i) {
+    REQUIRE((msgSet.messages | get_num_payloads{i}) == msgSet.messageMap[i].size);
+  }
+  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
+  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+}
+
+TEST_CASE("GetHeaderPayloadOperators")
+{
+  // Validates that get_header{part} / get_payload{part, 0} pipe operators on .messages
+  // correctly replace the removed header(part) / payload(part) methods,
+  // including access to parts at index > 0.
+  o2::framework::DataProcessingHeader dph{0, 1};
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+
+  o2::framework::MessageSet msgSet;
+
+  // Add two separate header-payload pairs
+  for (size_t part = 0; part < 2; ++part) {
+    o2::header::DataHeader dh{};
+    dh.dataDescription = "CLUSTERS";
+    dh.dataOrigin = "TPC";
+    dh.subSpecification = part; // use part index as subSpecification to distinguish
+    dh.splitPayloadParts = 1;
+    dh.splitPayloadIndex = 0;
+    std::vector<fair::mq::MessagePtr> ptrs;
+    ptrs.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
+    ptrs.emplace_back(transport->CreateMessage(100 + part * 100)); // 100 and 200 bytes
+    msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
+  }
+
+  REQUIRE(msgSet.messages.size() == 4);
+
+  // Validate part 0
+  auto& hdr0 = msgSet.messages | get_header{0};
+  REQUIRE(hdr0.get() != nullptr);
+  auto* dh0 = o2::header::get<o2::header::DataHeader*>(hdr0->GetData());
+  REQUIRE(dh0 != nullptr);
+  REQUIRE(dh0->subSpecification == 0);
+  auto& pl0 = msgSet.messages | get_payload{0, 0};
+  REQUIRE(pl0.get() != nullptr);
+  REQUIRE(pl0->GetSize() == 100);
+
+  // Validate part 1
+  auto& hdr1 = msgSet.messages | get_header{1};
+  REQUIRE(hdr1.get() != nullptr);
+  auto* dh1 = o2::header::get<o2::header::DataHeader*>(hdr1->GetData());
+  REQUIRE(dh1 != nullptr);
+  REQUIRE(dh1->subSpecification == 1);
+  auto& pl1 = msgSet.messages | get_payload{1, 0};
+  REQUIRE(pl1.get() != nullptr);
+  REQUIRE(pl1->GetSize() == 200);
+}
+
+TEST_CASE("GetHeaderPayloadMultiPayload")
+{
+  // Validates get_header{part} / get_payload{part, subpart} where both
+  // part and subpart can be non-zero.
+  // Layout:
+  //   part 0: standard (1 header + 1 payload)  → splitPayloadParts=1
+  //   part 1: multi-payload (1 header + 3 payloads) → splitPayloadParts=3, splitPayloadIndex=3
+  o2::framework::DataProcessingHeader dph{0, 1};
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+
+  o2::framework::MessageSet msgSet;
+
+  // Part 0: standard header-payload pair
+  {
+    o2::header::DataHeader dh{};
+    dh.dataDescription = "CLUSTERS";
+    dh.dataOrigin = "TPC";
+    dh.subSpecification = 0;
+    dh.splitPayloadParts = 1;
+    dh.splitPayloadIndex = 0;
+    std::vector<fair::mq::MessagePtr> ptrs;
+    ptrs.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
+    ptrs.emplace_back(transport->CreateMessage(100));
+    msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
+  }
+
+  // Part 1: one header with 3 payloads (splitPayloadIndex == splitPayloadParts)
+  {
+    o2::header::DataHeader dh{};
+    dh.dataDescription = "TRACKS";
+    dh.dataOrigin = "TPC";
+    dh.subSpecification = 1;
+    dh.splitPayloadParts = 3;
+    dh.splitPayloadIndex = 3; // signals multi-payload layout
+    std::vector<fair::mq::MessagePtr> ptrs;
+    ptrs.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
+    ptrs.emplace_back(transport->CreateMessage(200));
+    ptrs.emplace_back(transport->CreateMessage(300));
+    ptrs.emplace_back(transport->CreateMessage(400));
+    msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 4);
+  }
+
+  // messages: [hdr0, pl0, hdr1, pl1_0, pl1_1, pl1_2]
+  REQUIRE(msgSet.messages.size() == 6);
+
+  // Part 0: standard
+  auto& hdr0 = msgSet.messages | get_header{0};
+  REQUIRE(hdr0.get() != nullptr);
+  auto* dh0 = o2::header::get<o2::header::DataHeader*>(hdr0->GetData());
+  REQUIRE(dh0->subSpecification == 0);
+  auto& pl0 = msgSet.messages | get_payload{0, 0};
+  REQUIRE(pl0.get() != nullptr);
+  REQUIRE(pl0->GetSize() == 100);
+
+  // Part 1: multi-payload header
+  auto& hdr1 = msgSet.messages | get_header{1};
+  REQUIRE(hdr1.get() != nullptr);
+  auto* dh1 = o2::header::get<o2::header::DataHeader*>(hdr1->GetData());
+  REQUIRE(dh1->subSpecification == 1);
+
+  // get_payload{1, 0} — first payload of part 1
+  auto& pl1_0 = msgSet.messages | get_payload{1, 0};
+  REQUIRE(pl1_0.get() != nullptr);
+  REQUIRE(pl1_0->GetSize() == 200);
+
+  // get_payload{1, 1} — second payload of part 1 (nonzero, nonzero)
+  auto& pl1_1 = msgSet.messages | get_payload{1, 1};
+  REQUIRE(pl1_1.get() != nullptr);
+  REQUIRE(pl1_1->GetSize() == 300);
+
+  // get_payload{1, 2} — third payload of part 1 (nonzero, nonzero)
+  auto& pl1_2 = msgSet.messages | get_payload{1, 2};
+  REQUIRE(pl1_2.get() != nullptr);
+  REQUIRE(pl1_2->GetSize() == 400);
+
+  // count_payloads should report 4 total (1 from part 0 + 3 from part 1)
+  REQUIRE((msgSet.messages | count_payloads{}) == 4);
+  // count_parts should report 2 (one per header)
+  REQUIRE((msgSet.messages | count_parts{}) == 2);
+  // get_num_payloads for part 1 should be 3
+  REQUIRE((msgSet.messages | get_num_payloads{1}) == 3);
+
+  // Validate pipe operators match old API for multi-payload (header, pl, pl, pl)
+  REQUIRE(&(msgSet.messages | get_header{0}) == &msgSet.header(0));
+  REQUIRE(&(msgSet.messages | get_header{1}) == &msgSet.header(1));
+  REQUIRE(&(msgSet.messages | get_payload{0, 0}) == &msgSet.payload(0, 0));
+  REQUIRE(&(msgSet.messages | get_payload{1, 0}) == &msgSet.payload(1, 0));
+  REQUIRE(&(msgSet.messages | get_payload{1, 1}) == &msgSet.payload(1, 1));
+  REQUIRE(&(msgSet.messages | get_payload{1, 2}) == &msgSet.payload(1, 2));
+  for (size_t i = 0; i < 2; ++i) {
+    REQUIRE((msgSet.messages | get_num_payloads{i}) == msgSet.messageMap[i].size);
+  }
+  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
+  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+}
+
+TEST_CASE("TraditionalSplitParts")
+{
+  // Validates operators with traditional split parts layout:
+  // 3 (header, payload) pairs where splitPayloadParts=3, splitPayloadIndex=0,1,2
+  // This is ONE logical part with 3 subparts.
+  // Memory layout: [hdr0, pl0, hdr1, pl1, hdr2, pl2]
+  o2::framework::DataProcessingHeader dph{0, 1};
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
+
+  o2::framework::MessageSet msgSet;
+
+  for (size_t i = 0; i < 3; ++i) {
+    o2::header::DataHeader dh{};
+    dh.dataDescription = "CLUSTERS";
+    dh.dataOrigin = "TPC";
+    dh.subSpecification = 0;
+    dh.splitPayloadParts = 3;
+    dh.splitPayloadIndex = i;
+    std::vector<fair::mq::MessagePtr> ptrs;
+    ptrs.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
+    ptrs.emplace_back(transport->CreateMessage(100 * (i + 1)));
+    msgSet.add([&ptrs](size_t idx) -> fair::mq::MessagePtr& { return ptrs[idx]; }, 2);
+  }
+
+  REQUIRE(msgSet.messages.size() == 6);
+
+  // count_payloads: 3 traditional split parts = 3 payloads
+  REQUIRE((msgSet.messages | count_payloads{}) == 3);
+  // count_parts: one logical entity split into 3 pairs = 3 parts
+  REQUIRE((msgSet.messages | count_parts{}) == 3);
+
+  // Each traditional split pair is a separate part, matching MessageSet::header(part) semantics
+  for (size_t i = 0; i < 3; ++i) {
+    auto& hdr = msgSet.messages | get_header{i};
+    REQUIRE(hdr.get() != nullptr);
+    auto* dh = o2::header::get<o2::header::DataHeader*>(hdr->GetData());
+    REQUIRE(dh != nullptr);
+    REQUIRE(dh->splitPayloadIndex == i);
+
+    auto& pl = msgSet.messages | get_payload{i, 0};
+    REQUIRE(pl.get() != nullptr);
+    REQUIRE(pl->GetSize() == 100 * (i + 1));
+  }
+
+  // get_dataref_indices: each part maps to its own (header, payload) pair
+  for (size_t i = 0; i < 3; ++i) {
+    auto indices = msgSet.messages | get_dataref_indices{i, 0};
+    REQUIRE(indices.headerIdx == 2 * i);
+    REQUIRE(indices.payloadIdx == 2 * i + 1);
+  }
+
+  // get_pair: same as get_dataref_indices for traditional split
+  for (size_t i = 0; i < 3; ++i) {
+    auto indices = msgSet.messages | get_pair{i};
+    REQUIRE(indices.headerIdx == 2 * i);
+    REQUIRE(indices.payloadIdx == 2 * i + 1);
+  }
+
+  // get_num_payloads: each traditional split pair has 1 payload
+  for (size_t i = 0; i < 3; ++i) {
+    REQUIRE((msgSet.messages | get_num_payloads{i}) == msgSet.messageMap[i].size);
+  }
+
+  // Validate pipe operators match old MessageSet::header()/payload() API
+  for (size_t i = 0; i < 3; ++i) {
+    REQUIRE(&(msgSet.messages | get_header{i}) == &msgSet.header(i));
+    REQUIRE(&(msgSet.messages | get_payload{i, 0}) == &msgSet.payload(i));
+  }
+  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
+  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
 }

From f7a8f7ca03ef19a0accfd7ea2b0efa5e970d31c0 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Wed, 25 Mar 2026 16:54:52 +0100
Subject: [PATCH 1472/1764] Add missing track->resetCov before refit for
 revertexing

Skip tracks with ill-defined cov. matrix
---
 .../GlobalTrackingWorkflow/study/src/CheckResid.cxx   | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
index 063edc65d7486..ed419700b339b 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
@@ -318,6 +318,7 @@ bool CheckResidSpec::processITSTrack(const o2::its::TrackITS& iTrack, const o2::
   auto inv2d = [](float s00, float s11, float s01) -> std::array<float, 3> {
     auto det = s00 * s11 - s01 * s01;
     if (det < 1e-16) {
+      LOGP(error, "Singular det {}, input: {} {} {}", det, s00, s11, s01);
       return {0.f, 0.f, 0.f};
     }
     det = 1.f / det;
@@ -329,11 +330,11 @@ bool CheckResidSpec::processITSTrack(const o2::its::TrackITS& iTrack, const o2::
     LOGP(debug, "Failed to propagateToDCA, {}", trFitOut.asString());
     return false;
   }
-  float cosAlp, sinAlp;
-  pvAlpha = trFitOut.getAlpha();
-  o2::math_utils::sincos(trFitOut.getAlpha(), sinAlp, cosAlp); // vertex position rotated to track frame
   o2::BaseCluster<float> bcPV;
   if (params.addPVAsCluster) {
+    float cosAlp, sinAlp;
+    pvAlpha = trFitOut.getAlpha();
+    o2::math_utils::sincos(trFitOut.getAlpha(), sinAlp, cosAlp); // vertex position rotated to track frame
     bcPV.setXYZ(pv.getX() * cosAlp + pv.getY() * sinAlp, -pv.getX() * sinAlp + pv.getY() * cosAlp, pv.getZ());
     bcPV.setSigmaY2(0.5 * (pv.getSigmaX2() + pv.getSigmaY2()));
     bcPV.setSigmaZ2(pv.getSigmaZ2());
@@ -400,7 +401,7 @@ bool CheckResidSpec::processITSTrack(const o2::its::TrackITS& iTrack, const o2::
         auto wInw = inv2d(tInw.getSigmaY2(), tInw.getSigmaZ2(), tInw.getSigmaZY());
         auto wOut = inv2d(tOut.getSigmaY2(), tOut.getSigmaZ2(), tOut.getSigmaZY());
         if (wInw[0] == 0.f || wOut[0] == 0.f) {
-          return -1;
+          return false;
         }
         std::array<float, 3> wTot = {wInw[0] + wOut[0], wInw[1] + wOut[1], wInw[2] + wOut[2]};
         auto cTot = inv2d(wTot[0], wTot[1], wTot[2]);
@@ -481,6 +482,8 @@ bool CheckResidSpec::refitITStrack(o2::track::TrackParCov& track, GTrackID gid)
   const auto& params = CheckResidConfig::Instance();
   auto pid = track.getPID();
   track = trkITS.getParamOut();
+  track.resetCovariance();
+  track.setCov(track.getQ2Pt() * track.getQ2Pt() * track.getCov()[14], 14);
   track.setPID(pid);
   auto nCl = trkITS.getNumberOfClusters();
   auto geom = o2::its::GeometryTGeo::Instance();

From 87b9775293c9734b0be767feb5915e614560a05c Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 26 Mar 2026 11:29:14 +0100
Subject: [PATCH 1473/1764] DPL: Better detection for injected workflows
 (fixed) (#15202)

---
 Framework/Core/src/ArrowSupport.cxx    |  8 ++-
 Framework/Core/src/WorkflowHelpers.cxx | 15 +++-
 run/o2sim_hepmc_publisher.cxx          | 94 +++++++++++++-------------
 run/o2sim_kine_publisher.cxx           |  3 +-
 run/o2sim_mctracks_to_aod.cxx          | 12 ++--
 5 files changed, 74 insertions(+), 58 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index c5cc021a53478..b701ba5f8e01c 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -680,8 +680,12 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
           workflow.erase(reader);
         } else {
           // load reader algorithm before deployment
-          auto mctracks2aod = std::find_if(workflow.begin(), workflow.end(), [](auto const& x) { return x.name == "mctracks-to-aod"; });
-          if (mctracks2aod == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
+          auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
+            return !spec.name.starts_with("internal-dpl-aod-reader") && std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
+              return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
+            });
+          });
+          if (tfnsource == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
             reader->algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx));
           } // otherwise the algorithm was set in injectServiceDevices
         }
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index abe566e239618..2ef3df9426fde 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -411,13 +411,17 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   // add the reader
   if (aodReader.outputs.empty() == false) {
-    auto mctracks2aod = std::ranges::find_if(workflow, [](auto const& x) { return x.name == "mctracks-to-aod"; });
-    if (mctracks2aod == workflow.end()) {
+    auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
+      return std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
+        return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
+      });
+    });
+    if (tfnsource == workflow.end()) {
       // add normal reader
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
       aodReader.outputs.emplace_back(OutputSpec{"TFF", "TFFilename"});
     } else {
-      // AODs are being injected on-the-fly, add error-handler reader
+      // AODs are being injected the tfnsource is the entry point, add error-handler reader
       aodReader.algorithm = AlgorithmSpec{
         adaptStateful(
           [](DeviceSpec const& spec) {
@@ -700,6 +704,11 @@ void WorkflowHelpers::injectAODWriter(WorkflowSpec& workflow, ConfigContext cons
       return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
     });
     dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
+
+    it = std::find_if(dec.outputsInputs.begin(), dec.outputsInputs.end(), [](InputSpec const& spec) -> bool {
+      return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFF"));
+    });
+    dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
   }
 }
 
diff --git a/run/o2sim_hepmc_publisher.cxx b/run/o2sim_hepmc_publisher.cxx
index bf40abacb134f..f255b4a3a4f62 100644
--- a/run/o2sim_hepmc_publisher.cxx
+++ b/run/o2sim_hepmc_publisher.cxx
@@ -37,7 +37,9 @@ struct O2simHepmcPublisher {
   int tfCounter = 0;
   std::shared_ptr<HepMC3::Reader> hepMCReader;
   bool eos = false;
-  std::vector<o2::MCTrack> mcTracks;
+
+  std::vector<o2::pmr::vector<o2::MCTrack>*> mctracks_vector;
+  std::vector<o2::dataformats::MCEventHeader*> mcheader_vector;
 
   void init(o2::framework::InitContext& /*ic*/)
   {
@@ -50,13 +52,19 @@ struct O2simHepmcPublisher {
       LOGP(fatal, "Cannot open HEPMC kine file {}", (std::string)hepmcFileName);
     }
     // allocate the memory upfront to prevent reallocations later
-    mcTracks.reserve(1e3 * aggregate);
+    mctracks_vector.reserve(aggregate);
+    mcheader_vector.reserve(aggregate);
   }
 
   void run(o2::framework::ProcessingContext& pc)
   {
     HepMC3::GenEvent event;
-    for (auto i = 0; i < (int)aggregate; ++i) {
+    auto batch = maxEvents > 0 ? std::min((int)aggregate, (int)maxEvents - eventCounter) : (int)aggregate;
+    for (auto i = 0; i < batch; ++i) {
+      mctracks_vector.push_back(&pc.outputs().make<o2::pmr::vector<o2::MCTrack>>(Output{"MC", "MCTRACKS", 0}));
+      auto& mctracks = mctracks_vector.back();
+      mcheader_vector.push_back(&pc.outputs().make<o2::dataformats::MCEventHeader>(Output{"MC", "MCHEADER", 0}));
+      auto& mcheader = mcheader_vector.back();
       // read next entry
       hepMCReader->read_event(event);
       if (hepMCReader->failed()) {
@@ -66,61 +74,60 @@ struct O2simHepmcPublisher {
       }
 
       // create O2 MCHeader and MCtracks vector out of HEPMC event
-      o2::dataformats::MCEventHeader mcHeader;
-      mcHeader.SetEventID(event.event_number());
-      mcHeader.SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
+      mcheader->SetEventID(event.event_number());
+      mcheader->SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
       auto xsecInfo = event.cross_section();
       if (xsecInfo != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
-        mcHeader.putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
-        mcHeader.putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
-        mcHeader.putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
+        mcheader->putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
+        mcheader->putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
+        mcheader->putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
+        mcheader->putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
       }
       auto scale = event.attribute<HepMC3::DoubleAttribute>(MCInfoKeys::eventScale);
       if (scale != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::eventScale, (float)scale->value());
+        mcheader->putInfo(MCInfoKeys::eventScale, (float)scale->value());
       }
       auto nMPI = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::mpi);
       if (nMPI != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::mpi, nMPI->value());
+        mcheader->putInfo(MCInfoKeys::mpi, nMPI->value());
       }
       auto sid = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processCode);
       auto scode = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processID); // default pythia8 hepmc3 interface uses signal_process_id
       if (sid != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::processCode, sid->value());
+        mcheader->putInfo(MCInfoKeys::processCode, sid->value());
       } else if (scode != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::processCode, scode->value());
+        mcheader->putInfo(MCInfoKeys::processCode, scode->value());
       }
       auto pdfInfo = event.pdf_info();
       if (pdfInfo != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
-        mcHeader.putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
+        mcheader->putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
+        mcheader->putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
+        mcheader->putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
+        mcheader->putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
+        mcheader->putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
+        mcheader->putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
+        mcheader->putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
+        mcheader->putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
+        mcheader->putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
       }
       auto heavyIon = event.heavy_ion();
       if (heavyIon != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
-        mcHeader.putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
-        mcHeader.putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
-        mcHeader.putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
-        mcHeader.putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
-        mcHeader.putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
-        mcHeader.putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
-        mcHeader.putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
-        mcHeader.putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
-        mcHeader.putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
-        mcHeader.putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
-        mcHeader.putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
-        mcHeader.putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
-        mcHeader.putInfo("eccentricity", (float)heavyIon->eccentricity);
-        mcHeader.putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
-        mcHeader.putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
+        mcheader->putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
+        mcheader->putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
+        mcheader->putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
+        mcheader->putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
+        mcheader->putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
+        mcheader->putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
+        mcheader->putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
+        mcheader->putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
+        mcheader->putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
+        mcheader->putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
+        mcheader->putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
+        mcheader->putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
+        mcheader->putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
+        mcheader->putInfo("eccentricity", (float)heavyIon->eccentricity);
+        mcheader->putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
+        mcheader->putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
       }
 
       auto particles = event.particles();
@@ -131,7 +138,7 @@ struct O2simHepmcPublisher {
         auto has_children = children.size() > 0;
         auto p = particle->momentum();
         auto v = particle->production_vertex();
-        mcTracks.emplace_back(
+        mctracks->emplace_back(
           particle->pid(),
           has_parents ? parents.front()->id() : -1, has_parents ? parents.back()->id() : -1,
           has_children ? children.front()->id() : -1, has_children ? children.back()->id() : -1,
@@ -139,18 +146,13 @@ struct O2simHepmcPublisher {
           v->position().x(), v->position().y(), v->position().z(),
           v->position().t(), 0);
       }
-
-      // add to the message
-      pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcHeader);
-      pc.outputs().snapshot(Output{"MC", "MCTRACKS", 0}, mcTracks);
-      mcTracks.clear();
       ++eventCounter;
     }
 
     // report number of TFs injected for the rate limiter to work
     ++tfCounter;
     pc.services().get<o2::monitoring::Monitoring>().send(o2::monitoring::Metric{(uint64_t)tfCounter, "df-sent"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
-    if (eos || (maxEvents > 0 && eventCounter == maxEvents)) {
+    if (eos || (maxEvents > 0 && eventCounter >= maxEvents)) {
       pc.services().get<ControlService>().endOfStream();
       pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     }
diff --git a/run/o2sim_kine_publisher.cxx b/run/o2sim_kine_publisher.cxx
index cfbea6ae02a5f..5920743c3fafa 100644
--- a/run/o2sim_kine_publisher.cxx
+++ b/run/o2sim_kine_publisher.cxx
@@ -40,7 +40,8 @@ struct O2simKinePublisher {
 
   void run(o2::framework::ProcessingContext& pc)
   {
-    for (auto i = 0; i < std::min((int)aggregate, nEvents - eventCounter); ++i) {
+    auto batch = std::min((int)aggregate, nEvents - eventCounter);
+    for (auto i = 0; i < batch; ++i) {
       auto mcevent = mcKinReader->getMCEventHeader(0, eventCounter);
       auto mctracks = mcKinReader->getTracks(0, eventCounter);
       pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcevent);
diff --git a/run/o2sim_mctracks_to_aod.cxx b/run/o2sim_mctracks_to_aod.cxx
index 124e8aa7b3e42..d95a3b33cc38f 100644
--- a/run/o2sim_mctracks_to_aod.cxx
+++ b/run/o2sim_mctracks_to_aod.cxx
@@ -70,7 +70,7 @@ struct MctracksToAod {
   /** Run the conversion */
   void run(o2::framework::ProcessingContext& pc)
   {
-    LOG(debug) << "=== Running extended MC AOD exporter ===";
+    LOG(detail) << "=== Running extended MC AOD exporter ===";
     using namespace o2::aodmchelpers;
     using McHeader = o2::dataformats::MCEventHeader;
     using McTrack = o2::MCTrack;
@@ -94,13 +94,13 @@ struct MctracksToAod {
     // TODO: include BC simulation
     auto bcCounter = 0UL;
     size_t offset = 0;
-    LOG(debug) << "--- Loop over " << nParts << " parts ---";
+    LOG(detail) << "--- Loop over " << nParts << " parts ---";
     for (auto i = 0U; i < nParts; ++i) {
       auto record = mSampler.generateCollisionTime();
       auto header = pc.inputs().get<McHeader*>("mcheader", i);
       auto tracks = pc.inputs().get<McTracks>("mctracks", i);
 
-      LOG(debug) << "Updating collision table";
+      LOG(detail) << "Updating collision table";
       auto genID = updateMCCollisions(mCollisions.cursor,
                                       bcCounter,
                                       record.timeInBCNS * 1.e-3,
@@ -108,12 +108,12 @@ struct MctracksToAod {
                                       0,
                                       i);
 
-      LOG(debug) << "Updating HepMC tables";
+      LOG(detail) << "Updating HepMC tables";
       updateHepMCXSection(mXSections.cursor, bcCounter, genID, *header);
       updateHepMCPdfInfo(mPdfInfos.cursor, bcCounter, genID, *header);
       updateHepMCHeavyIon(mHeavyIons.cursor, bcCounter, genID, *header);
 
-      LOG(debug) << "Updating particles table";
+      LOG(detail) << "Updating particles table";
       TrackToIndex preselect;
       offset = updateParticles(mParticles.cursor,
                                bcCounter,
@@ -123,7 +123,7 @@ struct MctracksToAod {
                                (bool)filt,
                                false);
 
-      LOG(debug) << "Increment BC counter";
+      LOG(detail) << "Increment BC counter";
       bcCounter++;
     }
 

From d1a5e60eeae674c9384bcadde10ac5dae9ce7db9 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 26 Mar 2026 13:53:29 +0100
Subject: [PATCH 1474/1764] DPL: make sure DataRelayer benchmark works again
 (#15216)

---
 Framework/Core/test/benchmark_DataRelayer.cxx | 68 +++++++++++++++----
 1 file changed, 53 insertions(+), 15 deletions(-)

diff --git a/Framework/Core/test/benchmark_DataRelayer.cxx b/Framework/Core/test/benchmark_DataRelayer.cxx
index e983f3604cfab..312711d73e95e 100644
--- a/Framework/Core/test/benchmark_DataRelayer.cxx
+++ b/Framework/Core/test/benchmark_DataRelayer.cxx
@@ -15,10 +15,17 @@
 #include "Framework/CompletionPolicyHelpers.h"
 #include "Framework/DataRelayer.h"
 #include "Framework/DataProcessingHeader.h"
+#include "Framework/DataProcessingStates.h"
+#include "Framework/DataProcessingStats.h"
+#include "Framework/DeviceState.h"
+#include "Framework/DriverConfig.h"
+#include "Framework/ServiceRegistryHelpers.h"
+#include "Framework/TimingHelpers.h"
 #include <Monitoring/Monitoring.h>
 #include <fairmq/TransportFactory.h>
 #include <cstring>
 #include <vector>
+#include <uv.h>
 
 using Monitoring = o2::monitoring::Monitoring;
 using namespace o2::framework;
@@ -26,6 +33,42 @@ using DataHeader = o2::header::DataHeader;
 using Stack = o2::header::Stack;
 using RecordAction = o2::framework::DataRelayer::RecordAction;
 
+struct BenchmarkServices {
+  Monitoring monitoring;
+  const DriverConfig driverConfig{.batch = false};
+  DataProcessingStates states{
+    TimingHelpers::defaultRealtimeBaseConfigurator(0, uv_default_loop()),
+    TimingHelpers::defaultCPUTimeConfigurator(uv_default_loop())};
+  DataProcessingStats stats{
+    TimingHelpers::defaultRealtimeBaseConfigurator(0, uv_default_loop()),
+    TimingHelpers::defaultCPUTimeConfigurator(uv_default_loop()),
+    {}};
+  DeviceState deviceState;
+  ServiceRegistry registry;
+
+  ServiceRegistryRef ref()
+  {
+    using MetricSpec = DataProcessingStats::MetricSpec;
+    int quickUpdateInterval = 1;
+    std::vector<MetricSpec> specs{
+      MetricSpec{.name = "malformed_inputs", .metricId = static_cast<short>(ProcessingStatsId::MALFORMED_INPUTS), .minPublishInterval = quickUpdateInterval},
+      MetricSpec{.name = "dropped_computations", .metricId = static_cast<short>(ProcessingStatsId::DROPPED_COMPUTATIONS), .minPublishInterval = quickUpdateInterval},
+      MetricSpec{.name = "dropped_incoming_messages", .metricId = static_cast<short>(ProcessingStatsId::DROPPED_INCOMING_MESSAGES), .minPublishInterval = quickUpdateInterval},
+      MetricSpec{.name = "relayed_messages", .metricId = static_cast<short>(ProcessingStatsId::RELAYED_MESSAGES), .minPublishInterval = quickUpdateInterval}};
+    for (auto& spec : specs) {
+      stats.registerMetric(spec);
+    }
+
+    ServiceRegistryRef r{registry};
+    r.registerService(ServiceRegistryHelpers::handleForService<Monitoring>(&monitoring));
+    r.registerService(ServiceRegistryHelpers::handleForService<DataProcessingStates>(&states));
+    r.registerService(ServiceRegistryHelpers::handleForService<DataProcessingStats>(&stats));
+    r.registerService(ServiceRegistryHelpers::handleForService<DriverConfig const>(&driverConfig));
+    r.registerService(ServiceRegistryHelpers::handleForService<DeviceState>(&deviceState));
+    return r;
+  }
+};
+
 // a simple benchmark of the contribution of the pure message creation
 // this was important when the benchmarks below included the message
 // creation inside the benchmark loop, its somewhat obsolete now but
@@ -54,7 +97,7 @@ BENCHMARK(BM_RelayMessageCreation);
 // and the subsequent InputRecord is immediately requested.
 static void BM_RelaySingleSlot(benchmark::State& state)
 {
-  Monitoring metrics;
+  BenchmarkServices services;
   InputSpec spec{"clusters", "TPC", "CLUSTERS"};
 
   std::vector<InputRoute> inputs = {
@@ -64,8 +107,7 @@ static void BM_RelaySingleSlot(benchmark::State& state)
   std::vector<InputChannelInfo> infos{1};
   TimesliceIndex index{1, infos};
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
-  ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry}, -1);
+  DataRelayer relayer(policy, inputs, index, services.ref(), -1);
   relayer.setPipelineLength(4);
 
   // Let's create a dummy O2 Message with two headers in the stack:
@@ -106,7 +148,7 @@ BENCHMARK(BM_RelaySingleSlot);
 // This one will simulate a single input.
 static void BM_RelayMultipleSlots(benchmark::State& state)
 {
-  Monitoring metrics;
+  BenchmarkServices services;
   InputSpec spec{"clusters", "TPC", "CLUSTERS"};
 
   std::vector<InputRoute> inputs = {
@@ -117,8 +159,7 @@ static void BM_RelayMultipleSlots(benchmark::State& state)
   TimesliceIndex index{1, infos};
 
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
-  ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry}, -1);
+  DataRelayer relayer(policy, inputs, index, services.ref(), -1);
   relayer.setPipelineLength(4);
 
   // Let's create a dummy O2 Message with two headers in the stack:
@@ -163,7 +204,7 @@ BENCHMARK(BM_RelayMultipleSlots);
 /// In this case we have a record with two entries
 static void BM_RelayMultipleRoutes(benchmark::State& state)
 {
-  Monitoring metrics;
+  BenchmarkServices services;
   InputSpec spec1{"clusters", "TPC", "CLUSTERS"};
   InputSpec spec2{"tracks", "TPC", "TRACKS"};
 
@@ -176,8 +217,7 @@ static void BM_RelayMultipleRoutes(benchmark::State& state)
   TimesliceIndex index{1, infos};
 
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
-  ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry}, -1);
+  DataRelayer relayer(policy, inputs, index, services.ref(), -1);
   relayer.setPipelineLength(4);
 
   // Let's create a dummy O2 Message with two headers in the stack:
@@ -241,7 +281,7 @@ BENCHMARK(BM_RelayMultipleRoutes);
 /// In this case we have a record with two entries
 static void BM_RelaySplitParts(benchmark::State& state)
 {
-  Monitoring metrics;
+  BenchmarkServices services;
   InputSpec spec1{"clusters", "TPC", "CLUSTERS"};
 
   std::vector<InputRoute> inputs = {
@@ -253,8 +293,7 @@ static void BM_RelaySplitParts(benchmark::State& state)
   TimesliceIndex index{1, infos};
 
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
-  ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry}, -1);
+  DataRelayer relayer(policy, inputs, index, services.ref(), -1);
   relayer.setPipelineLength(4);
 
   // Let's create a dummy O2 Message with two headers in the stack:
@@ -301,7 +340,7 @@ BENCHMARK(BM_RelaySplitParts)->Arg(10)->Arg(100)->Arg(1000);
 
 static void BM_RelayMultiplePayloads(benchmark::State& state)
 {
-  Monitoring metrics;
+  BenchmarkServices services;
   InputSpec spec1{"clusters", "TPC", "CLUSTERS"};
 
   std::vector<InputRoute> inputs = {
@@ -313,8 +352,7 @@ static void BM_RelayMultiplePayloads(benchmark::State& state)
   TimesliceIndex index{1, infos};
 
   auto policy = CompletionPolicyHelpers::consumeWhenAny();
-  ServiceRegistry registry;
-  DataRelayer relayer(policy, inputs, index, {registry}, -1);
+  DataRelayer relayer(policy, inputs, index, services.ref(), -1);
   relayer.setPipelineLength(4);
 
   // DataHeader matching the one provided in the input

From 9c8c644fb9e6d218c78cadaf7fc6c08ab465f250 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 26 Mar 2026 12:59:35 +0100
Subject: [PATCH 1475/1764] Set GPU field to 0 if L3 current <= 77A

---
 GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
index b6491c72d83f3..f0efaf48c8725 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.cxx
@@ -145,6 +145,7 @@ uint32_t GPUO2InterfaceUtils::getTpcMaxTimeBinFromNHbf(uint32_t nHbf)
 
 float GPUO2InterfaceUtils::getNominalGPUBzFromCurrent(float l3curr)
 {
+  // Field for the current below 77A is treated as 0.
   float al3curr = CAMath::Abs(l3curr);
-  return (CAMath::Abs(al3curr - 12000) < CAMath::Abs(al3curr - 30000) ? (2.04487f / 12000.f) : (5.00668f / 30000.f)) * l3curr;
+  return al3curr <= 77 ? 0 : ((CAMath::Abs(al3curr - 12000) < CAMath::Abs(al3curr - 30000) ? (2.04487f / 12000.f) : (5.00668f / 30000.f)) * l3curr);
 }

From a1fe043d4a82f892069f5d88a612ebe480ff466a Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 24 Mar 2026 13:10:57 +0100
Subject: [PATCH 1476/1764] In absence of svertexing pass
 --disable-strangeness-tracker to AOD producer

---
 prodtests/full-system-test/dpl-workflow.sh | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 5b7ffc3cc6547..1e1ea258d395f 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -709,7 +709,10 @@ workflow_has_parameter GPU_DISPLAY && [[ $NUMAID == 0 ]] && add_W o2-gpu-display
 
 # ---------------------------------------------------------------------------------------------------------------------
 # AOD
-[[ ${SECTVTX_ON:-} != "1" ]] && AODPROD_OPT+=" --disable-secondary-vertices "
+if [[ ${SECTVTX_ON:-} != "1" ]]; then
+  AODPROD_OPT+=" --disable-secondary-vertices "
+  [[ "0$STRTRACKING" == "0" ]] && STRTRACKING=" --disable-strangeness-tracker "
+fi
 AODPROD_OPT+=" $STRTRACKING "
 workflow_has_parameter AOD && [[ -n "$AOD_SOURCES" ]] && add_W o2-aod-producer-workflow "$AODPROD_OPT --info-sources $AOD_SOURCES $DISABLE_ROOT_INPUT --aod-writer-keep dangling --aod-writer-resfile \"AO2D\" --aod-writer-resmode UPDATE $DISABLE_MC --pipeline $(get_N aod-producer-workflow AOD REST 1 AODPROD)"
 

From 3d17e85f23f3a6347f77a240368a73bd77a8e2f0 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 27 Mar 2026 06:51:13 +0100
Subject: [PATCH 1477/1764] DPL: move away from MessageSet::header / payload
 (#15228)

Rest of the usecases removed. Abstract header / payload retrieval, with the idea that get_header / get_payload
will work on any range of fair::mq::MessagePtrs.
---
 Framework/Core/src/DataRelayer.cxx      | 16 ++++++++--------
 Framework/Core/test/test_MessageSet.cxx |  8 ++++++++
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 7eb851e2aadd8..4cda75ed001b0 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -213,9 +213,9 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       auto partial = getPartialRecord(ti);
       // TODO: get the data ref from message model
       auto getter = [&partial](size_t idx, size_t part) {
-        if (!partial[idx].messages.empty() && partial[idx].header(part).get()) {
-          auto header = partial[idx].header(part).get();
-          auto payload = partial[idx].payload(part).get();
+        if (!partial[idx].messages.empty() && (partial[idx].messages | get_header{part}).get()) {
+          auto header = (partial[idx].messages | get_header{part}).get();
+          auto payload = (partial[idx].messages | get_payload{part, 0}).get();
           return DataRef{nullptr,
                          reinterpret_cast<const char*>(header->GetData()),
                          reinterpret_cast<char const*>(payload ? payload->GetData() : nullptr),
@@ -786,9 +786,9 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
     auto partial = getPartialRecord(li);
     // TODO: get the data ref from message model
     auto getter = [&partial](size_t idx, size_t part) {
-      if (!partial[idx].messages.empty() && partial[idx].header(part).get()) {
-        auto header = partial[idx].header(part).get();
-        auto payload = partial[idx].payload(part).get();
+      if (!partial[idx].messages.empty() && (partial[idx].messages | get_header{part}).get()) {
+        auto header = (partial[idx].messages | get_header{part}).get();
+        auto payload = (partial[idx].messages | get_payload{part, 0}).get();
         return DataRef{nullptr,
                        reinterpret_cast<const char*>(header->GetData()),
                        reinterpret_cast<char const*>(payload ? payload->GetData() : nullptr),
@@ -952,10 +952,10 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeExistingInputsForTime
     // TODO: in the original implementation of the cache, there have been only two messages per entry,
     // check if the 2 above corresponds to the number of messages.
     for (size_t pi = 0; pi < (cache[cacheId].messages | count_parts{}); pi++) {
-      auto& header = cache[cacheId].header(pi);
+      auto& header = cache[cacheId].messages | get_header{pi};
       auto&& newHeader = header->GetTransport()->CreateMessage();
       newHeader->Copy(*header);
-      messages[arg].add(PartRef{std::move(newHeader), std::move(cache[cacheId].payload(pi))});
+      messages[arg].add(PartRef{std::move(newHeader), std::move(cache[cacheId].messages | get_payload{pi, 0})});
     }
   };
 
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index 290e55220d6cb..aa7b49c1d1d3c 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -250,6 +250,14 @@ TEST_CASE("GetHeaderPayloadOperators")
   auto& pl1 = msgSet.messages | get_payload{1, 0};
   REQUIRE(pl1.get() != nullptr);
   REQUIRE(pl1->GetSize() == 200);
+
+  // Validate pipe operators match old API
+  for (size_t i = 0; i < 2; ++i) {
+    REQUIRE(&(msgSet.messages | get_header{i}) == &msgSet.header(i));
+    REQUIRE(&(msgSet.messages | get_payload{i, 0}) == &msgSet.payload(i, 0));
+  }
+  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
+  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
 }
 
 TEST_CASE("GetHeaderPayloadMultiPayload")

From 6e2f625c53a8ed3f2baf8aa01b4fecd929420ee3 Mon Sep 17 00:00:00 2001
From: Oliver <45767754+OliverRietmann@users.noreply.github.com>
Date: Fri, 27 Mar 2026 07:23:53 +0100
Subject: [PATCH 1478/1764] Write standalone --debug output to CSV file

---
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  29 ++---
 GPU/GPUTracking/Base/GPUReconstructionCPU.h   |  13 +++
 .../Base/GPUReconstructionDebug.cxx           | 107 ++++++++++++++++++
 GPU/GPUTracking/Definitions/GPUSettingsList.h |   2 +
 .../Standalone/Benchmark/standalone.cxx       |   8 +-
 5 files changed, 140 insertions(+), 19 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 409c28b8bf328..752b5f27ded3f 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -35,6 +35,7 @@
 
 #include <atomic>
 #include <ctime>
+#include <string>
 
 #ifndef _WIN32
 #include <unistd.h>
@@ -230,6 +231,7 @@ int32_t GPUReconstructionCPU::RunChains()
     GPUInfo("Allocated memory when starting processing %34s", "");
     PrintMemoryOverview();
   }
+
   mTimerTotal.Start();
   const std::clock_t cpuTimerStart = std::clock();
   int32_t retVal = 0;
@@ -264,7 +266,10 @@ int32_t GPUReconstructionCPU::RunChains()
   double kernelTotal = 0;
   std::vector<double> kernelStepTimes(gpudatatypes::N_RECO_STEPS, 0.);
 
+  debugWriter writer(GetProcessingSettings().debugCSV, GetProcessingSettings().debugMarkdown, mStatNEvents);
+
   if (GetProcessingSettings().debugLevel >= 1) {
+    writer.header();
     for (uint32_t i = 0; i < mTimers.size(); i++) {
       double time = 0;
       if (mTimers[i] == nullptr) {
@@ -284,11 +289,7 @@ int32_t GPUReconstructionCPU::RunChains()
         int32_t stepNum = getRecoStepNum(mTimers[i]->step);
         kernelStepTimes[stepNum] += time;
       }
-      char bandwidth[256] = "";
-      if (mTimers[i]->memSize && mStatNEvents && time != 0.) {
-        snprintf(bandwidth, 256, " (%8.3f GB/s - %'14zu bytes - %'14zu per call)", mTimers[i]->memSize / time * 1e-9, mTimers[i]->memSize / mStatNEvents, mTimers[i]->memSize / mStatNEvents / mTimers[i]->count);
-      }
-      printf("Execution Time: Task (%c %8ux): %50s Time: %'10.0f us%s\n", type == 0 ? 'K' : 'C', mTimers[i]->count, mTimers[i]->name.c_str(), time * 1000000 / mStatNEvents, bandwidth);
+      writer.row('K', mTimers[i]->count, mTimers[i]->name.c_str(), time, -1.0, -1.0, mTimers[i]->memSize);
       if (GetProcessingSettings().resetTimers) {
         mTimers[i]->count = 0;
         mTimers[i]->memSize = 0;
@@ -298,16 +299,13 @@ int32_t GPUReconstructionCPU::RunChains()
   if (GetProcessingSettings().recoTaskTiming) {
     for (int32_t i = 0; i < gpudatatypes::N_RECO_STEPS; i++) {
       if (kernelStepTimes[i] != 0. || mTimersRecoSteps[i].timerTotal.GetElapsedTime() != 0.) {
-        printf("Execution Time: Step              : %11s %38s Time: %'10.0f us %64s ( Total Time : %'14.0f us, CPU Time : %'14.0f us, %'7.2fx )\n", "Tasks",
-               gpudatatypes::RECO_STEP_NAMES[i], kernelStepTimes[i] * 1000000 / mStatNEvents, "", mTimersRecoSteps[i].timerTotal.GetElapsedTime() * 1000000 / mStatNEvents, mTimersRecoSteps[i].timerCPU * 1000000 / mStatNEvents, mTimersRecoSteps[i].timerCPU / mTimersRecoSteps[i].timerTotal.GetElapsedTime());
+        writer.row(' ', 0, std::string(gpudatatypes::RECO_STEP_NAMES[i]) + " (Tasks)", kernelStepTimes[i], mTimersRecoSteps[i].timerCPU, mTimersRecoSteps[i].timerTotal.GetElapsedTime(), 0);
       }
       if (mTimersRecoSteps[i].bytesToGPU) {
-        printf("Execution Time: Step (D %8ux): %11s %38s Time: %'10.0f us (%8.3f GB/s - %'14zu bytes - %'14zu per call)\n", mTimersRecoSteps[i].countToGPU, "DMA to GPU", gpudatatypes::RECO_STEP_NAMES[i], mTimersRecoSteps[i].timerToGPU.GetElapsedTime() * 1000000 / mStatNEvents,
-               mTimersRecoSteps[i].bytesToGPU / mTimersRecoSteps[i].timerToGPU.GetElapsedTime() * 1e-9, mTimersRecoSteps[i].bytesToGPU / mStatNEvents, mTimersRecoSteps[i].bytesToGPU / mTimersRecoSteps[i].countToGPU);
+        writer.row('D', mTimersRecoSteps[i].countToGPU, std::string(gpudatatypes::RECO_STEP_NAMES[i]) + " (DMA to GPU)", mTimersRecoSteps[i].timerToGPU.GetElapsedTime(), -1.0, -1.0, mTimersRecoSteps[i].bytesToGPU);
       }
       if (mTimersRecoSteps[i].bytesToHost) {
-        printf("Execution Time: Step (D %8ux): %11s %38s Time: %'10.0f us (%8.3f GB/s - %'14zu bytes - %'14zu per call)\n", mTimersRecoSteps[i].countToHost, "DMA to Host", gpudatatypes::RECO_STEP_NAMES[i], mTimersRecoSteps[i].timerToHost.GetElapsedTime() * 1000000 / mStatNEvents,
-               mTimersRecoSteps[i].bytesToHost / mTimersRecoSteps[i].timerToHost.GetElapsedTime() * 1e-9, mTimersRecoSteps[i].bytesToHost / mStatNEvents, mTimersRecoSteps[i].bytesToHost / mTimersRecoSteps[i].countToHost);
+        writer.row('D', mTimersRecoSteps[i].countToHost, std::string(gpudatatypes::RECO_STEP_NAMES[i]) + " (DMA to Host)", mTimersRecoSteps[i].timerToHost.GetElapsedTime(), -1.0, -1.0, mTimersRecoSteps[i].bytesToHost);
       }
       if (GetProcessingSettings().resetTimers) {
         mTimersRecoSteps[i].bytesToGPU = mTimersRecoSteps[i].bytesToHost = 0;
@@ -321,14 +319,11 @@ int32_t GPUReconstructionCPU::RunChains()
     }
     for (int32_t i = 0; i < gpudatatypes::N_GENERAL_STEPS; i++) {
       if (mTimersGeneralSteps[i].GetElapsedTime() != 0.) {
-        printf("Execution Time: General Step      : %50s Time: %'10.0f us\n", gpudatatypes::GENERAL_STEP_NAMES[i], mTimersGeneralSteps[i].GetElapsedTime() * 1000000 / mStatNEvents);
+        writer.row(' ', 0, gpudatatypes::GENERAL_STEP_NAMES[i], mTimersGeneralSteps[i].GetElapsedTime(), -1.0, -1.0, 0);
       }
     }
-    if (GetProcessingSettings().debugLevel >= 1) {
-      mStatKernelTime = kernelTotal * 1000000 / mStatNEvents;
-      printf("Execution Time: Total   : %50s Time: %'10.0f us%s\n", "Total Kernel", mStatKernelTime, nEventReport.c_str());
-    }
-    printf("Execution Time: Total   : %50s Time: %'10.0f us ( CPU Time : %'10.0f us, %7.2fx ) %s\n", "Total Wall", mStatWallTime, mStatCPUTime * 1000000 / mStatNEvents, mStatCPUTime / mTimerTotal.GetElapsedTime(), nEventReport.c_str());
+    double gpu_time = GetProcessingSettings().debugLevel >= 1 ? kernelTotal : -1.0;
+    writer.row(' ', 0, "Wall", gpu_time, mStatCPUTime, mTimerTotal.GetElapsedTime(), 0, nEventReport);
   } else if (GetProcessingSettings().debugLevel >= 0) {
     GPUInfo("Total Wall Time: %10.0f us%s", mStatWallTime, nEventReport.c_str());
   }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.h b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
index d621d45fcd92b..466ad318bbe3b 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.h
@@ -16,7 +16,9 @@
 #define GPURECONSTRUCTIONICPU_H
 
 #include "GPUReconstructionProcessing.h"
+#include <fstream>
 #include <stdexcept>
+#include <string>
 #include <vector>
 
 namespace Ort
@@ -100,6 +102,17 @@ class GPUReconstructionCPU : public GPUReconstructionProcessing::KernelInterface
   size_t TransferMemoryResourcesHelper(GPUProcessor* proc, int32_t stream, bool all, bool toGPU);
   template <class S, int32_t I = 0, typename... Args>
   void runKernelInterface(krnlSetup&& setup, Args const&... args);
+
+  struct debugWriter {
+    debugWriter(std::string filenameCSV, bool markdown, uint32_t statNEvents);
+    void header();
+    void row(char type, uint32_t count, std::string name, double gpu_time, double cpu_time, double total_time, std::size_t memSize, std::string nEventReport = "");
+
+   private:
+    std::ofstream streamCSV;
+    bool mMarkdown;
+    uint32_t mStatNEvents;
+  };
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx b/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx
index c1c31eedde1b2..564c04ba7f745 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUReconstruction.h"
+#include "GPUReconstructionCPU.h"
 #include "GPULogging.h"
 #include "GPUSettings.h"
 
@@ -23,6 +24,8 @@
 #include <filesystem>
 #include <chrono>
 #include <format>
+#include <iostream>
+#include <string>
 
 using namespace o2::gpu;
 
@@ -186,3 +189,107 @@ bool GPUReconstruction::triggerDebugDump()
   }
   return false;
 }
+
+GPUReconstructionCPU::debugWriter::debugWriter(std::string filenameCSV, bool markdown, uint32_t statNEvents) : mMarkdown{markdown}, mStatNEvents{statNEvents}
+{
+  if (!filenameCSV.empty()) {
+    streamCSV.open(filenameCSV, std::ios::out | std::ios::app);
+  }
+}
+
+void GPUReconstructionCPU::debugWriter::header()
+{
+  if (streamCSV.is_open() && !streamCSV.tellp()) {
+    streamCSV << "type,count,name,gpu (us),cpu (us),cpu/total,total (us),GB/s,bytes,bytes/call\n";
+  }
+
+  if (mMarkdown) {
+    std::cout << "|   |  count | name                                      |  gpu (us) |  cpu (us) | cpu/tot |  tot (us) |      GB/s |         bytes |    bytes/call |\n";
+    std::cout << "|---|--------|-------------------------------------------|-----------|-----------|---------|-----------|-----------|---------------|---------------|\n";
+  }
+}
+
+void GPUReconstructionCPU::debugWriter::row(char type, uint32_t count, std::string name, double gpu_time, double cpu_time, double total_time, std::size_t memSize, std::string nEventReport)
+{
+  double scale = 1000000.0 / mStatNEvents;
+
+  if (streamCSV.is_open()) {
+    streamCSV << type << ",";
+    if (count != 0)
+      streamCSV << count;
+    streamCSV << "," << name << ",";
+    if (gpu_time != -1.0)
+      streamCSV << std::format("{:.0f}", gpu_time * scale);
+    streamCSV << ",";
+    if (cpu_time != -1.0)
+      streamCSV << std::format("{:.0f}", cpu_time * scale);
+    streamCSV << ",";
+    if (cpu_time != -1.0 && total_time != -1.0)
+      streamCSV << std::format("{:.2f}", cpu_time / total_time);
+    streamCSV << ",";
+    if (total_time != -1.0)
+      streamCSV << std::format("{:.0f}", total_time * scale);
+    streamCSV << ",";
+    if (memSize != 0 && count != 0)
+      streamCSV << std::format("{:.3f},{},{}", memSize / gpu_time * 1e-9, memSize / mStatNEvents, memSize / mStatNEvents / count);
+    else
+      streamCSV << ",,";
+    streamCSV << std::endl;
+  }
+
+  if (mMarkdown) {
+    std::cout << "| " << type << " | ";
+    if (count != 0)
+      std::cout << std::format("{:6} |", count);
+    else
+      std::cout << "       |";
+    std::cout << std::format(" {:42}|", name);
+    if (gpu_time != -1.0)
+      std::cout << std::format("{:10.0f} |", gpu_time * scale);
+    else
+      std::cout << "           |";
+    if (cpu_time != -1.0)
+      std::cout << std::format("{:10.0f} |", cpu_time * scale);
+    else
+      std::cout << "           |";
+    if (cpu_time != -1.0 && total_time != -1.0)
+      std::cout << std::format("{:8.2f} |", cpu_time / total_time);
+    else
+      std::cout << "         |";
+    if (total_time != -1.0)
+      std::cout << std::format("{:10.0f} |", total_time * scale);
+    else
+      std::cout << "           |";
+    if (memSize != 0 && count != 0)
+      std::cout << std::format("{:10.3f} |{:14} |{:14} |", memSize / gpu_time * 1e-9, memSize / mStatNEvents, memSize / mStatNEvents / count);
+    else
+      std::cout << "           |               |               |";
+    std::cout << std::endl;
+  } else {
+    if (name.substr(0, 3) == "GPU") {
+      char bandwidth[256] = "";
+      if (memSize && mStatNEvents && gpu_time != 0.0) {
+        snprintf(bandwidth, 256, " (%8.3f GB/s - %'14zu bytes - %'14zu per call)", memSize / gpu_time * 1e-9, memSize / mStatNEvents, memSize / mStatNEvents / count);
+      }
+      printf("Execution Time: Task (%c %8ux): %50s Time: %'10.0f us%s\n", type, count, name.c_str(), gpu_time * scale, bandwidth);
+    } else if (name.substr(0, 3) == "TPC") {
+      std::size_t n = name.find('(');
+      std::string basename = name.substr(0, n - 1);
+      std::string postfix = name.substr(n + 1, name.size() - n - 2);
+      if (total_time != -1.0) {
+        printf("Execution Time: Step              : %11s %38s Time: %'10.0f us %64s ( Total Time : %'14.0f us, CPU Time : %'14.0f us, %'7.2fx )\n", postfix.c_str(),
+               basename.c_str(), gpu_time * scale, "", total_time * scale, cpu_time * scale, cpu_time / total_time);
+      } else {
+        printf("Execution Time: Step (D %8ux): %11s %38s Time: %'10.0f us (%8.3f GB/s - %'14zu bytes - %'14zu per call)\n", count, postfix.c_str(), basename.c_str(), gpu_time * scale,
+               memSize / gpu_time * 1e-9, memSize / mStatNEvents, memSize / mStatNEvents / count);
+      }
+    } else if (name == "Prepare") {
+      printf("Execution Time: General Step      : %50s Time: %'10.0f us\n", name.c_str(), gpu_time * scale);
+    } else if (name == "Wall") {
+      if (gpu_time != -1.0) {
+        printf("Execution Time: Total   : %50s Time: %'10.0f us%s\n", "Total Kernel", gpu_time * scale, nEventReport.c_str());
+      }
+      printf("Execution Time: Total   : %50s Time: %'10.0f us ( CPU Time : %'10.0f us, %7.2fx ) %s\n", "Total Wall", total_time * scale, cpu_time * scale, cpu_time / total_time, nEventReport.c_str());
+    }
+  }
+}
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 57cb1371a4aa0..606deb44d9528 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -329,6 +329,8 @@ AddOption(debugLevel, int32_t, -1, "debug", 'd', "Set debug level (-2 = silent,
 AddOption(allocDebugLevel, int32_t, 0, "allocDebug", 0, "Some debug output for memory allocations (without messing with normal debug level)")
 AddOption(debugMask, uint32_t, (1 << 18) - 1, "debugMask", 0, "Mask for debug output dumps to file")
 AddOption(debugLogSuffix, std::string, "", "debugSuffix", 0, "Suffix for debug log files with --debug 6")
+AddOption(debugCSV, std::string, "", "", 0, "CSV filename to append the benchmark results. Verbosity determined by parameter --debug.")
+AddOption(debugMarkdown, bool, false, "", 0, "Print the results of standlaone benchmarks in markdown format")
 AddOption(serializeGPU, int8_t, 0, "", 0, "Synchronize after each kernel call (bit 1) and DMA transfer (bit 2) and identify failures")
 AddOption(recoTaskTiming, bool, 0, "", 0, "Perform summary timing after whole reconstruction tasks")
 AddOption(deterministicGPUReconstruction, int32_t, -1, "", 0, "Make CPU and GPU debug output comparable (sort / skip concurrent parts), -1 = automatic if debugLevel >= 6 or deterministic compile flag set", def(1))
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index a2e74c45fcb86..2a2f7adea8cb9 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -627,7 +627,9 @@ int32_t RunBenchmark(GPUReconstruction* recUse, GPUChainTracking* chainTrackingU
     if (configStandalone.runs > 1) {
       printf("Run %d (thread %d)\n", iteration + 1, threadId);
     }
-    recUse->SetResetTimers(iRun < configStandalone.runsInit);
+    if (configStandalone.runsInit > 0 && configStandalone.proc.debugCSV.empty()) {
+      recUse->SetResetTimers(iRun < configStandalone.runsInit);
+    }
     if (configStandalone.outputcontrolmem) {
       recUse->SetOutputControl(threadId ? outputmemoryPipeline.get() : outputmemory.get(), configStandalone.outputcontrolmem);
     }
@@ -685,7 +687,9 @@ int32_t RunBenchmark(GPUReconstruction* recUse, GPUChainTracking* chainTrackingU
         chainTrackingAsync->mIOPtrs.nRawClusters[i] = 0;
       }
       chainTrackingAsync->mIOPtrs.clustersNative = nullptr;
-      recAsync->SetResetTimers(iRun < configStandalone.runsInit);
+      if (configStandalone.runsInit > 0 && configStandalone.proc.debugCSV.empty()) {
+        recAsync->SetResetTimers(iRun < configStandalone.runsInit);
+      }
       tmpRetVal = recAsync->RunChains();
       if (tmpRetVal == 0 || tmpRetVal == 2) {
         OutputStat(chainTrackingAsync, nullptr, nullptr);

From 85d4143e39ee608db1a130471cdeb1cbaf09fe52 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Fri, 27 Mar 2026 09:08:29 +0100
Subject: [PATCH 1479/1764] [ALICE3] IOTOF: fix non segmented layers (#15195)

---
 Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index 9b097a0243597..61720f2172b92 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -101,7 +101,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const double staveTiltAngle = itofSegmented ? 10.0 : 0.0; // degrees
     const int modulesPerStave = itofSegmented ? 10 : 0;       // number of modules per stave in segmented case
     mITOFLayer = ITOFLayer(name,
-                           dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, ITOFLayer::kBarrelSegmented,
+                           dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, itofSegmented ? ITOFLayer::kBarrelSegmented : ITOFLayer::kBarrel,
                            nStaves, staveWidth, staveTiltAngle, modulesPerStave);
   }
   if (otof) { // oTOF
@@ -111,7 +111,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const double staveTiltAngle = otofSegmented ? 5.0 : 0.0; // degrees
     const int modulesPerStave = otofSegmented ? 54 : 0;      // number of modules per stave in segmented case
     mOTOFLayer = OTOFLayer(name,
-                           dOuterTof.first, 0.f, dOuterTof.second, 0.f, x2x0, OTOFLayer::kBarrelSegmented,
+                           dOuterTof.first, 0.f, dOuterTof.second, 0.f, x2x0, otofSegmented ? OTOFLayer::kBarrelSegmented : OTOFLayer::kBarrel,
                            nStaves, staveWidth, staveTiltAngle, modulesPerStave);
   }
   if (ftof) {

From 081240b92abe7fa9c4110000e82795e641557998 Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Fri, 27 Mar 2026 09:25:06 +0100
Subject: [PATCH 1480/1764] Fix BasicCCDBManager::isCacheValid(ts) method
 (#15223)

---
 CCDB/include/CCDB/BasicCCDBManager.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CCDB/include/CCDB/BasicCCDBManager.h b/CCDB/include/CCDB/BasicCCDBManager.h
index fd0fe7aa6d05b..b76beb2576eb3 100644
--- a/CCDB/include/CCDB/BasicCCDBManager.h
+++ b/CCDB/include/CCDB/BasicCCDBManager.h
@@ -64,8 +64,8 @@ class CCDBManagerInstance
     bool isValid(long ts) { return ts < endvalidity && ts >= startvalidity; }
     bool isCacheValid(long ts)
     {
-      LOGP(debug, "isCacheValid : {} : {} : {} --> {}", cacheValidFrom, ts, cacheValidUntil, ts < cacheValidUntil && ts >= cacheValidFrom);
-      return ts < cacheValidUntil && ts >= cacheValidFrom;
+      LOGP(debug, "isCacheValid : {} : {} : {} --> {}", cacheValidFrom, ts, cacheValidUntil, isValid(ts));
+      return ts < cacheValidUntil && isValid(ts);
     }
     void clear()
     {

From ea49c665efc212679910be88db82651dfec588a9 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 27 Mar 2026 10:37:28 +0100
Subject: [PATCH 1481/1764] ITS3: alignment code (#15161)

* ITS3: template detector coord conversion on input type

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS3: alignment

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Replace math.h with cmath in AlignmentHierarchy.cxx

Removed math.h and added cmath for better compatibility.

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../Upgrades/ITS3/alignment/CMakeLists.txt    |   37 +-
 Detectors/Upgrades/ITS3/alignment/README.md   |   30 +
 .../include/ITS3Align/AlignmentHierarchy.h    |  339 ++++++
 .../include/ITS3Align/AlignmentParams.h       |   67 ++
 .../include/ITS3Align/AlignmentSensors.h      |   41 +
 .../include/ITS3Align/AlignmentSpec.h         |   34 +
 .../include/ITS3Align/AlignmentTypes.h        |   64 ++
 .../include/ITS3Align/Deformations.h          |   84 --
 .../include/ITS3Align/MisalignmentHits.h      |  216 ----
 .../include/ITS3Align/MisalignmentManager.h   |   53 -
 .../ITS3Align/MisalignmentParameters.h        |   93 --
 .../alignment/include/ITS3Align/TrackFit.h    |  175 +++
 .../ITS3/alignment/src/AlignmentHierarchy.cxx |  486 ++++++++
 .../ITS3/alignment/src/AlignmentParams.cxx    |   13 +
 .../ITS3/alignment/src/AlignmentSensors.cxx   |  201 ++++
 .../ITS3/alignment/src/AlignmentSpec.cxx      | 1003 +++++++++++++++++
 .../ITS3/alignment/src/AlignmentTypes.cxx     |   24 +
 .../ITS3/alignment/src/Deformations.cxx       |   41 -
 .../ITS3/alignment/src/ITS3AlignLinkDef.h     |    8 +-
 .../ITS3/alignment/src/MisalignmentHits.cxx   |  368 ------
 .../alignment/src/MisalignmentManager.cxx     |  195 ----
 .../alignment/src/MisalignmentParameters.cxx  |   80 --
 .../ITS3/alignment/src/alignment-workflow.cxx |   71 ++
 .../ITS3/base/include/ITS3Base/ITS3Params.h   |    5 -
 .../include/ITS3Base/SegmentationMosaix.h     |   19 +-
 .../ITS3/base/include/ITS3Base/SpecsV2.h      |    2 +-
 .../Upgrades/ITS3/macros/align/CMakeLists.txt |    6 +-
 .../ITS3/macros/align/CheckHitResiduals.C     |  131 +++
 .../macros/align/CreateMisalignmentITS3.C     |   94 --
 .../ITS3/macros/align/MisAlignGeoITS3.notest  |  129 ---
 .../ITS3/macros/align/ShowCoefficients.C      |  333 ------
 .../ITS3/macros/align/TestLegendrePol.C       |  257 -----
 .../include/ITS3Reconstruction/IOUtils.h      |   23 +-
 .../ITS3/reconstruction/src/IOUtils.cxx       |   46 +-
 .../reconstruction/src/TopologyDictionary.cxx |    2 +
 Detectors/Upgrades/ITS3/study/CMakeLists.txt  |    6 +-
 .../ITS3TrackingStudyParam.h                  |   18 +-
 .../include/ITS3TrackingStudy/TrackingStudy.h |    2 +-
 .../Upgrades/ITS3/study/macros/CMakeLists.txt |    8 +
 .../ITS3/study/macros/PlotMisalignment.C      |  228 ++++
 .../ITS3/study/macros/PlotResiduals.C         |   70 ++
 .../Upgrades/ITS3/study/src/TrackingStudy.cxx |  667 ++++++++---
 .../src/its3-tracking-study-workflow.cxx      |    8 +-
 Steer/DigitizerWorkflow/CMakeLists.txt        |    1 -
 .../src/ITS3DigitizerSpec.cxx                 |    6 -
 45 files changed, 3627 insertions(+), 2157 deletions(-)
 create mode 100644 Detectors/Upgrades/ITS3/alignment/README.md
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentHierarchy.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSensors.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentTypes.h
 delete mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/Deformations.h
 delete mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentHits.h
 delete mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentManager.h
 delete mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentParameters.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/TrackFit.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/AlignmentParams.cxx
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/AlignmentSensors.cxx
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/AlignmentTypes.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/alignment/src/Deformations.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/alignment/src/MisalignmentHits.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/alignment/src/MisalignmentManager.cxx
 delete mode 100644 Detectors/Upgrades/ITS3/alignment/src/MisalignmentParameters.cxx
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/alignment-workflow.cxx
 create mode 100644 Detectors/Upgrades/ITS3/macros/align/CheckHitResiduals.C
 delete mode 100644 Detectors/Upgrades/ITS3/macros/align/CreateMisalignmentITS3.C
 delete mode 100644 Detectors/Upgrades/ITS3/macros/align/MisAlignGeoITS3.notest
 delete mode 100644 Detectors/Upgrades/ITS3/macros/align/ShowCoefficients.C
 delete mode 100644 Detectors/Upgrades/ITS3/macros/align/TestLegendrePol.C
 create mode 100644 Detectors/Upgrades/ITS3/study/macros/PlotMisalignment.C
 create mode 100644 Detectors/Upgrades/ITS3/study/macros/PlotResiduals.C

diff --git a/Detectors/Upgrades/ITS3/alignment/CMakeLists.txt b/Detectors/Upgrades/ITS3/alignment/CMakeLists.txt
index f89ad821c65e7..0bc8080c7a1b8 100644
--- a/Detectors/Upgrades/ITS3/alignment/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/alignment/CMakeLists.txt
@@ -9,18 +9,37 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
+# add_compile_options(-O0 -g -fPIC -fno-omit-frame-pointer)
 o2_add_library(ITS3Align
-               SOURCES src/MisalignmentParameters.cxx
-                       src/MisalignmentHits.cxx
-                       src/MisalignmentManager.cxx
-                       src/Deformations.cxx
+               TARGETVARNAME targetName
+               SOURCES src/AlignmentHierarchy.cxx
+                       src/AlignmentSensors.cxx
+                       src/AlignmentParams.cxx
+                       src/AlignmentTypes.cxx
+                       src/AlignmentSpec.cxx
                PUBLIC_LINK_LIBRARIES O2::MathUtils
                                      O2::Steer
                                      O2::ITSBase
-                                     O2::ITSMFTSimulation)
+                                     O2::ITSMFTSimulation
+                                     O2::ITS3Reconstruction
+                                     O2::Framework
+                                     O2::GlobalTrackingWorkflowReaders
+                                     O2::GlobalTrackingWorkflowHelpers
+                                     O2::DataFormatsGlobalTracking
+                                     O2::DetectorsVertexing
+                                     nlohmann_json::nlohmann_json
+                                     GBL::GBL)
+if (OpenMP_CXX_FOUND)
+    target_compile_definitions(${targetName} PRIVATE WITH_OPENMP)
+    target_link_libraries(${targetName} PRIVATE OpenMP::OpenMP_CXX)
+endif()
 
 o2_target_root_dictionary(ITS3Align
-                          HEADERS include/ITS3Align/MisalignmentParameters.h
-                                  include/ITS3Align/MisalignmentHits.h
-                                  include/ITS3Align/MisalignmentHits.h
-                                  include/ITS3Align/Deformations.h)
+                          HEADERS include/ITS3Align/AlignmentParams.h
+                                  include/ITS3Align/AlignmentTypes.h)
+
+
+o2_add_executable(alignment-workflow
+                  SOURCES src/alignment-workflow.cxx
+                  COMPONENT_NAME its3
+                  PUBLIC_LINK_LIBRARIES O2::ITS3Align)
diff --git a/Detectors/Upgrades/ITS3/alignment/README.md b/Detectors/Upgrades/ITS3/alignment/README.md
new file mode 100644
index 0000000000000..62633d1d7d313
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/README.md
@@ -0,0 +1,30 @@
+# Simulate ITS3 misalignment and re-alignment
+
+
+```bash
+o2-its3-alignment-workflow --track-sources ITS --output MilleData,MilleSteer --configKeyValues "ITS3AlignmentParams.minPt=0.1;ITS3AlignmentParams.doMisalignmentLeg=true;ITS3AlignmentParams.doMisalignmentRB=true;ITS3AlignmentParams.misAlgJson=test_closure.json;ITS3AlignmentParams.extraClsErrZ[0]=10e-4;ITS3AlignmentParams.extraClsErrY[0]=10e-4;ITS3AlignmentParams.extraClsErrZ[3]=10e-4;ITS3AlignmentParams.extraClsErrY[3]=10e-4;ITS3AlignmentParams.dofConfigJson=dofSet.json" -b --run
+```
+
+test_closure.json:
+```json
+[
+  {
+    "id": 0,
+    "rigidBody": [0.001, 0.0005, 0.0, 0.0, 0.0001, 0.0],
+    "matrix": [[0.0], [0.0008, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
+  }
+]
+```
+
+dofSet.json:
+```json
+{
+  "defaults": { "rigidBody": "fixed" },
+  "rules": [
+    {
+      "match": "ITS3Layer0/ITS3CarbonForm0",
+      "rigidBody": ["TX", "TY", "RY"],
+      "calib": { "type": "legendre", "order": 1, "fix": [0, 2] }
+    }
+  ]
+}```
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentHierarchy.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentHierarchy.h
new file mode 100644
index 0000000000000..04b8157084d0a
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentHierarchy.h
@@ -0,0 +1,339 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGNMENT_HIERARCHY_H
+#define O2_ITS3_ALIGNMENT_HIERARCHY_H
+
+#include <memory>
+#include <compare>
+#include <type_traits>
+#include <map>
+#include <utility>
+#include <vector>
+#include <ostream>
+#include <string>
+#include <format>
+#include <algorithm>
+
+#include <Eigen/Dense>
+
+#include <TGeoMatrix.h>
+#include <TGeoPhysicalNode.h>
+
+namespace o2::its3::align
+{
+using Matrix36 = Eigen::Matrix<double, 3, 6>;
+using Matrix66 = Eigen::Matrix<double, 6, 6>;
+
+// indices for rigid body parameters in LOC frame
+enum RigidBodyDOF : uint8_t {
+  TX = 0,
+  TY,
+  TZ,
+  RX,
+  RY,
+  RZ,
+  NDOF,
+};
+static constexpr const char* RigidBodyDOFNames[RigidBodyDOF::NDOF] = {"TX", "TY", "TZ", "RX", "RY", "RZ"};
+
+// return the rigid body derivatives
+// trk has be at in the measurment frame
+auto getRigidBodyDerivatives(const auto& trk)
+{
+  // calculate slopes
+  const double tgl = trk.getTgl(), snp = trk.getSnp();
+  const double csp = 1. / sqrt(1. + (tgl * tgl));
+  const double u = trk.getY(), v = trk.getZ();
+  const double uP = snp * csp, vP = tgl * csp;
+  Matrix36 der;
+  der.setZero();
+  // columns: Tt,  Tu,  Tv,  Rt,    Ru,   Rv
+  //          (X)  (Y)  (Z)  (RX)   (RY)  (RZ)
+  der << uP, -1., 0., v, v * uP, -u * uP,
+    vP, 0., -1., -u, v * vP, -u * vP;
+  return der;
+}
+
+class DOFSet
+{
+ public:
+  enum class Type : uint8_t { RigidBody,
+                              Legendre };
+  virtual ~DOFSet() = default;
+  virtual Type type() const = 0;
+  int nDOFs() const { return static_cast<int>(mFree.size()); }
+  virtual std::string dofName(int idx) const = 0;
+  bool isFree(int idx) const { return mFree[idx]; }
+  void setFree(int idx, bool f) { mFree[idx] = f; }
+  void setAllFree(bool f) { std::fill(mFree.begin(), mFree.end(), f); }
+  int nFreeDOFs() const
+  {
+    int n = 0;
+    for (bool f : mFree) {
+      n += f;
+    }
+    return n;
+  }
+
+ protected:
+  DOFSet(int n) : mFree(n, true) {}
+  std::vector<bool> mFree;
+};
+
+class RigidBodyDOFSet final : public DOFSet
+{
+ public:
+  static constexpr int NDOF = RigidBodyDOF::NDOF;
+  RigidBodyDOFSet() : DOFSet(NDOF) {}
+  // mask: bitmask of free DOFs (bit i = DOF i is free)
+  explicit RigidBodyDOFSet(uint8_t mask) : DOFSet(NDOF)
+  {
+    for (int i = 0; i < NDOF; ++i) {
+      mFree[i] = (mask >> i) & 1;
+    }
+  }
+  Type type() const override { return Type::RigidBody; }
+  std::string dofName(int idx) const override { return RigidBodyDOFNames[idx]; }
+  uint8_t mask() const
+  {
+    uint8_t m = 0;
+    for (int i = 0; i < NDOF; ++i) {
+      m |= (uint8_t(mFree[i]) << i);
+    }
+    return m;
+  }
+};
+
+class LegendreDOFSet final : public DOFSet
+{
+ public:
+  explicit LegendreDOFSet(int order) : DOFSet((order + 1) * (order + 2) / 2), mOrder(order) {}
+  Type type() const override { return Type::Legendre; }
+  int order() const { return mOrder; }
+  std::string dofName(int idx) const override
+  {
+    int i = 0;
+    while ((i + 1) * (i + 2) / 2 <= idx) {
+      ++i;
+    }
+    int j = idx - (i * (i + 1) / 2);
+    return std::format("L({},{})", i, j);
+  }
+
+ private:
+  int mOrder;
+};
+
+class GlobalLabel
+{
+  // Millepede label is any positive integer [1....)
+  // Layout: DOF(5) | CALIB(1) | ID(22) | SENS(1) | DET(2) = 31 usable bits (MSB reserved, GBL uses signed int)
+ public:
+  using T = uint32_t;
+  static constexpr int DOF_BITS = 5;   // bits 0-4
+  static constexpr int CALIB_BITS = 1; // bit 5: 0 = rigid body, 1 = calibration
+  static constexpr int ID_BITS = 22;   // bits 6-27
+  static constexpr int SENS_BITS = 1;  // bit 28
+  static constexpr int TOTAL_BITS = sizeof(T) * 8;
+  static constexpr int DET_BITS = TOTAL_BITS - (DOF_BITS + CALIB_BITS + ID_BITS + SENS_BITS) - 1; // one less bit since GBL uses int!
+  static constexpr T bitMask(int b) noexcept
+  {
+    return (T(1) << b) - T(1);
+  }
+  static constexpr int DOF_SHIFT = 0;
+  static constexpr T DOF_MAX = (T(1) << DOF_BITS) - T(1);
+  static constexpr T DOF_MASK = DOF_MAX << DOF_SHIFT;
+  static constexpr int CALIB_SHIFT = DOF_BITS;
+  static constexpr T CALIB_MAX = (T(1) << CALIB_BITS) - T(1);
+  static constexpr T CALIB_MASK = CALIB_MAX << CALIB_SHIFT;
+  static constexpr int ID_SHIFT = DOF_BITS + CALIB_BITS;
+  static constexpr T ID_MAX = (T(1) << ID_BITS) - T(1);
+  static constexpr T ID_MASK = ID_MAX << ID_SHIFT;
+  static constexpr int SENS_SHIFT = DOF_BITS + CALIB_BITS + ID_BITS;
+  static constexpr T SENS_MAX = (T(1) << SENS_BITS) - T(1);
+  static constexpr T SENS_MASK = SENS_MAX << SENS_SHIFT;
+  static constexpr int DET_SHIFT = DOF_BITS + CALIB_BITS + ID_BITS + SENS_BITS;
+  static constexpr T DET_MAX = (T(1) << DET_BITS) - T(1);
+  static constexpr T DET_MASK = DET_MAX << DET_SHIFT;
+
+  GlobalLabel(T det, T id, bool sens, bool calib = false)
+    : mID((((id + 1) & ID_MAX) << ID_SHIFT) |
+          ((det & DET_MAX) << DET_SHIFT) |
+          ((T(sens) & SENS_MAX) << SENS_SHIFT) |
+          ((T(calib) & CALIB_MAX) << CALIB_SHIFT))
+  {
+  }
+
+  /// produce the raw Millepede label for a given DOF index (rigid body: calib=0 in label)
+  constexpr T raw(T dof) const noexcept { return (mID & ~DOF_MASK) | ((dof & DOF_MAX) << DOF_SHIFT); }
+  constexpr int rawGBL(T dof) const noexcept { return static_cast<int>(raw(dof)); }
+
+  /// return a copy of this label with the CALIB bit set (for calibration DOFs on same volume)
+  GlobalLabel asCalib() const noexcept
+  {
+    GlobalLabel c{*this};
+    c.mID |= (T(1) << CALIB_SHIFT);
+    return c;
+  }
+
+  constexpr T id() const noexcept { return ((mID >> ID_SHIFT) & ID_MAX) - 1; }
+  constexpr T det() const noexcept { return (mID & DET_MASK) >> DET_SHIFT; }
+  constexpr bool sens() const noexcept { return (mID & SENS_MASK) >> SENS_SHIFT; }
+  constexpr bool calib() const noexcept { return (mID & CALIB_MASK) >> CALIB_SHIFT; }
+
+  std::string asString() const
+  {
+    return std::format("Det:{} Id:{} Sens:{} Calib:{}", det(), id(), sens(), calib());
+  }
+
+  constexpr auto operator<=>(const GlobalLabel&) const noexcept = default;
+
+ private:
+  T mID{0};
+};
+
+class HierarchyConstraint
+{
+ public:
+  HierarchyConstraint(std::string name, double value) : mName(std::move(name)), mValue(value) {}
+  void add(uint32_t lab, double coeff)
+  {
+    mLabels.push_back(lab);
+    mCoeff.push_back(coeff);
+  }
+  void write(std::ostream& os) const;
+  auto getSize() const noexcept { return mLabels.size(); }
+
+ private:
+  std::string mName;             // name of the constraint
+  double mValue{0.0};            // constraint value
+  std::vector<uint32_t> mLabels; // parameter labels
+  std::vector<double> mCoeff;    // their coefficients
+};
+
+// --- AlignableVolume ---
+
+class AlignableVolume
+{
+ public:
+  using Ptr = std::unique_ptr<AlignableVolume>;
+  using SensorMapping = std::map<GlobalLabel, AlignableVolume*>;
+
+  AlignableVolume(const AlignableVolume&) = delete;
+  AlignableVolume(AlignableVolume&&) = delete;
+  AlignableVolume& operator=(const AlignableVolume&) = delete;
+  AlignableVolume& operator=(AlignableVolume&&) = delete;
+  AlignableVolume(const char* symName, uint32_t label, uint32_t det, bool sens);
+  AlignableVolume(const char* symName, GlobalLabel label);
+  virtual ~AlignableVolume() = default;
+
+  void finalise(uint8_t level = 0);
+
+  // steering file output
+  void writeRigidBodyConstraints(std::ostream& os) const;
+  void writeParameters(std::ostream& os) const;
+  void writeTree(std::ostream& os, int indent = 0) const;
+
+  // tree-like
+  auto getLevel() const noexcept { return mLevel; }
+  bool isRoot() const noexcept { return mParent == nullptr; }
+  bool isLeaf() const noexcept { return mChildren.empty(); }
+  template <class T = AlignableVolume>
+    requires std::derived_from<T, AlignableVolume>
+  AlignableVolume* addChild(const char* symName, uint32_t label, uint32_t det, bool sens)
+  {
+    auto c = std::make_unique<T>(symName, label, det, sens);
+    return setParent(std::move(c));
+  }
+  template <class T = AlignableVolume>
+    requires std::derived_from<T, AlignableVolume>
+  AlignableVolume* addChild(const char* symName, GlobalLabel lbl)
+  {
+    auto c = std::make_unique<T>(symName, lbl);
+    return setParent(std::move(c));
+  }
+
+  // bfs traversal
+  void traverse(const std::function<void(AlignableVolume*)>& visitor)
+  {
+    visitor(this);
+    for (auto& c : mChildren) {
+      c->traverse(visitor);
+    }
+  }
+
+  std::string getSymName() const noexcept { return mSymName; }
+  GlobalLabel getLabel() const noexcept { return mLabel; }
+  AlignableVolume* getParent() const { return mParent; }
+  size_t getNChildren() const noexcept { return mChildren.size(); }
+
+  // DOF management
+  void setRigidBody(std::unique_ptr<DOFSet> rb) { mRigidBody = std::move(rb); }
+  void setCalib(std::unique_ptr<DOFSet> cal) { mCalib = std::move(cal); }
+  DOFSet* getRigidBody() const { return mRigidBody.get(); }
+  DOFSet* getCalib() const { return mCalib.get(); }
+  void setPseudo(bool p) noexcept { mIsPseudo = p; }
+  bool isPseudo() const noexcept { return mIsPseudo; }
+  void setSensorId(int id) noexcept { mSensorId = id; }
+  int getSensorId() const noexcept { return mSensorId; }
+  // true if this volume participates in the hierarchy (has DOFs or is pseudo)
+  bool isActive() const noexcept { return mRigidBody != nullptr || mIsPseudo; }
+
+  // transformation matrices
+  virtual void defineMatrixL2G() {}
+  virtual void defineMatrixT2L() {}
+  virtual void computeJacobianL2T(const double* pos, Matrix66& jac) const {};
+  const TGeoHMatrix& getL2P() const { return mL2P; }
+  const TGeoHMatrix& getT2L() const { return mT2L; }
+  const Matrix66& getJL2P() const { return mJL2P; }
+  const Matrix66& getJP2L() const { return mJP2L; }
+
+ protected:
+  /// matrices
+  AlignableVolume* mParent{nullptr}; // parent
+  TGeoPNEntry* mPNE{nullptr};        // physical entry
+  TGeoPhysicalNode* mPN{nullptr};    // physical node
+  TGeoHMatrix mL2G;                  // (LOC) -> (GLO)
+  TGeoHMatrix mL2P;                  // (LOC) -> (PAR)
+  Matrix66 mJL2P;                    // jac (LOC) -> (PAR)
+  Matrix66 mJP2L;                    // jac (PAR) -> (LOC)
+  TGeoHMatrix mT2L;                  // (TRK) -> (LOC)
+
+ private:
+  std::string mSymName;
+  GlobalLabel mLabel;
+  uint8_t mLevel{0};
+  bool mIsPseudo{false};
+  int mSensorId{-1};
+  std::unique_ptr<DOFSet> mRigidBody;
+  std::unique_ptr<DOFSet> mCalib;
+
+  AlignableVolume* setParent(Ptr c)
+  {
+    c->mParent = this;
+    mChildren.push_back(std::move(c));
+    return mChildren.back().get();
+  }
+  std::vector<Ptr> mChildren; // children
+
+  void init();
+};
+
+// apply DOF configuration from a JSON file to the hierarchy
+void applyDOFConfig(AlignableVolume* root, const std::string& jsonPath);
+
+// parse millepede.res and write result.json with fitted parameters for ITS3 half barrels
+void writeMillepedeResults(AlignableVolume* root, const std::string& milleResPath, const std::string& outJsonPath, const std::string& injectedJsonPath = "");
+
+} // namespace o2::its3::align
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h
new file mode 100644
index 0000000000000..a7785a2c04e11
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h
@@ -0,0 +1,67 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef ALICEO2_ITS3_ALIGNMENTPARAMS_H_
+#define ALICEO2_ITS3_ALIGNMENTPARAMS_H_
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include "DetectorsBase/Propagator.h"
+
+namespace o2::its3::align
+{
+struct AlignmentParams : public o2::conf::ConfigurableParamHelper<AlignmentParams> {
+  // Track selection
+  float minPt = 1.f;         // minimum pt required
+  int minITSCls = 7;         // minimum number of ITS clusters
+  float maxITSChi2Ndf = 1.2; // maximum ITS track chi2
+
+  // propagation opt
+  double maxSnp = 0.85;
+  double maxStep = 2.0;
+  // o2::base::PropagatorD::MatCorrType matCorrType = o2::base::PropagatorD::MatCorrType::USEMatCorrTGeo;
+  o2::base::PropagatorD::MatCorrType corrType = o2::base::PropagatorD::MatCorrType::USEMatCorrLUT;
+
+  bool useStableRef = true; // use input tracks as linearization point
+  float minMS = 1e-6f;      //  minimum scattering to account for
+  float maxChi2Ndf = 10;    // maximum Chi2/Ndf allowed for GBL fit
+
+  // per chip extra error
+  float extraClsErrY[6] = {0};
+  float extraClsErrZ[6] = {0};
+
+  // misalignment simulation
+  bool doMisalignmentLeg = false; // simulate Legendre deformation on ITS3 layers
+  bool doMisalignmentRB = false;  // simulate rigid body misalignment on ITS3 layers
+  std::string misAlgJson;         // JSON file with deformation and/or rigid body params
+
+  // DOF configuration (JSON file defining which volumes have which DOFs)
+  std::string dofConfigJson; // if empty, no DOFs are configured
+
+  // Ridder options
+  int ridderMaxExtrap = 10;
+  double ridderRelIniStep[5] = {0.01, 0.01, 0.02, 0.02, 0.02};
+  double ridderMaxIniStep[5] = {0.1, 0.1, 0.05, 0.05, 0.05};
+  double ridderShrinkFac = 2.0;
+  double ridderEps = 1e-16;
+
+  // MillePede output
+  std::string milleBinFile = "mp2data.bin";
+  std::string milleConFile = "mp2con.txt";
+  std::string milleParamFile = "mp2param.txt";
+  std::string milleTreeFile = "mp2tree.txt";
+  std::string milleResFile = "millepede.res";
+  std::string milleResOutJson = "result.json";
+
+  O2ParamDef(AlignmentParams, "ITS3AlignmentParams");
+};
+} // namespace o2::its3::align
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSensors.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSensors.h
new file mode 100644
index 0000000000000..535f67156a16c
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSensors.h
@@ -0,0 +1,41 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGNMENT_SENSORS_H
+#define O2_ITS3_ALIGNMENT_SENSORS_H
+
+#include "ITS3Align/AlignmentHierarchy.h"
+
+namespace o2::its3::align
+{
+
+AlignableVolume::Ptr buildHierarchyITS(AlignableVolume::SensorMapping& sensorMap);
+AlignableVolume::Ptr buildHierarchyIT3(AlignableVolume::SensorMapping& sensorMap);
+
+class AlignableSensorITS final : public AlignableVolume
+{
+  using AlignableVolume::AlignableVolume;
+  void defineMatrixL2G() final;
+  void defineMatrixT2L() final;
+  void computeJacobianL2T(const double* pos, Matrix66& jac) const final;
+};
+
+class AlignableSensorIT3 final : public AlignableVolume
+{
+  using AlignableVolume::AlignableVolume;
+  void defineMatrixL2G() final;
+  void defineMatrixT2L() final;
+  void computeJacobianL2T(const double* pos, Matrix66& jac) const final;
+};
+
+} // namespace o2::its3::align
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h
new file mode 100644
index 0000000000000..2344889657558
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h
@@ -0,0 +1,34 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGNMENT_H
+#define O2_ITS3_ALIGNMENT_H
+
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "Framework/DataProcessorSpec.h"
+#include "CommonUtils/EnumFlags.h"
+
+namespace o2::its3::align
+{
+
+enum class OutputOpt : uint8_t {
+  VerboseGBL = 0,
+  MilleData,
+  MilleSteer,
+  MilleRes,
+  Debug,
+};
+using OutputEnum = utils::EnumFlags<OutputOpt>;
+
+o2::framework::DataProcessorSpec getAlignmentSpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC, bool withPV, bool withITS3, OutputEnum out);
+} // namespace o2::its3::align
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentTypes.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentTypes.h
new file mode 100644
index 0000000000000..6dc84b2323d35
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentTypes.h
@@ -0,0 +1,64 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGNMENT_TYPES_H
+#define O2_ITS3_ALIGNMENT_TYPES_H
+
+#include <string>
+#include "ReconstructionDataFormats/Track.h"
+#include "DataFormatsITS/TrackITS.h"
+
+namespace o2::its3::align
+{
+
+struct Measurement final {
+  double dy = 0.f;
+  double dz = 0.f;
+  double sig2y = 0.f;
+  double sig2z = 0.f;
+  double phi = 0.f;
+  double z = 0.f;
+  ClassDefNV(Measurement, 1)
+};
+
+struct FrameInfoExt final {
+  int16_t sens = -1;
+  int8_t lr = -1; // -1 = vtx
+  double x{-999.f};
+  double alpha{-999.f};
+  std::array<double, 2> positionTrackingFrame = {999., 999.};
+  std::array<double, 3> covarianceTrackingFrame = {999., 999., 999.};
+
+  std::string asString() const;
+
+  ClassDefNV(FrameInfoExt, 1)
+};
+
+struct FitInfo final {
+  float chi2Ndf{-1}; // Chi2/Ndf of track refit
+  float chi2{-1};    // Chi2
+  int ndf{-1};       // ndf
+  ClassDefNV(FitInfo, 1)
+};
+
+struct Track {
+  o2::its::TrackITS its;           // original ITS track
+  o2::track::TrackParCovD track;   // track at innermost update point, refitted from outwards seed
+  FitInfo kfFit;                   // kf fit information
+  FitInfo gblFit;                  // gbl fit information
+  std::vector<Measurement> points; // measurment point
+  std::vector<FrameInfoExt> info;  // frame info
+  ClassDefNV(Track, 1)
+};
+
+} // namespace o2::its3::align
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/Deformations.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/Deformations.h
deleted file mode 100644
index dfaade51e82ff..0000000000000
--- a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/Deformations.h
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef ITS3_DEFORMATIONS_H_
-#define ITS3_DEFORMATIONS_H_
-
-#include "ITS3Align/MisalignmentParameters.h"
-#include "MathUtils/LegendrePols.h"
-
-#include <filesystem>
-
-namespace o2::its3::align
-{
-
-class Deformations
-{
- public:
-  // init deformations from the parameter file
-  void init(const std::filesystem::path&);
-
-  double getDeformationX(unsigned int id, double u, double v) const { return getDeformation<0>(id, u, v); }
-  double getDeformationY(unsigned int id, double u, double v) const { return getDeformation<1>(id, u, v); }
-  double getDeformationZ(unsigned int id, double u, double v) const { return getDeformation<2>(id, u, v); }
-  double getDeformation(unsigned int id, unsigned int axis, double u, double v) const
-  {
-    if (axis == 0) {
-      return mLegX[id](u, v);
-    } else if (axis == 1) {
-      return mLegY[id](u, v);
-    } else {
-      return mLegZ[id](u, v);
-    }
-  }
-  std::array<double, 3> getDeformation(unsigned int id, double u, double v) const
-  {
-    return {getDeformation<0>(id, u, v),
-            getDeformation<1>(id, u, v),
-            getDeformation<2>(id, u, v)};
-  }
-  std::array<unsigned int, 3> getOrders(unsigned int id) const
-  {
-    return {mLegX[id].NOrder(), mLegY[id].NOrder(), mLegZ[id].NOrder()};
-  }
-  const o2::math_utils::Legendre2DPolynominal& getLegendre(unsigned int id, unsigned int axis) const
-  {
-    if (axis == 0) {
-      return mLegX[id];
-    } else if (axis == 1) {
-      return mLegY[id];
-    } else {
-      return mLegZ[id];
-    }
-  }
-
- private:
-  template <int axis>
-  double getDeformation(unsigned int id, double u, double v) const
-  {
-    if constexpr (axis == 0) {
-      return mLegX[id](u, v);
-    } else if constexpr (axis == 1) {
-      return mLegY[id](u, v);
-    } else {
-      return mLegZ[id](u, v);
-    }
-  }
-
-  // 3 Legendre polynominals to model deformations in x,y,z; parameterized by normalized phi (u) and z (v) coordinates
-  std::array<o2::math_utils::Legendre2DPolynominal, 6> mLegX;
-  std::array<o2::math_utils::Legendre2DPolynominal, 6> mLegY;
-  std::array<o2::math_utils::Legendre2DPolynominal, 6> mLegZ;
-};
-
-} // namespace o2::its3::align
-
-#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentHits.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentHits.h
deleted file mode 100644
index 37f5c9fdf701d..0000000000000
--- a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentHits.h
+++ /dev/null
@@ -1,216 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef ITS3_MISALIGNMENTHITS_H_
-#define ITS3_MISALIGNMENTHITS_H_
-
-#include "Math/IFunction.h"
-#include "Math/Minimizer.h"
-
-#include "ReconstructionDataFormats/Track.h"
-#include "ITS3Align/Deformations.h"
-#include "ITSBase/GeometryTGeo.h"
-#include "ITSMFTSimulation/Hit.h"
-#include "MathUtils/Cartesian.h"
-#include "MathUtils/Utils.h"
-#include "Steer/MCKinematicsReader.h"
-
-#include <regex>
-#include <memory>
-#include <array>
-#include <optional>
-#include <tuple>
-
-namespace o2::its3::align
-{
-
-class MisAlignmentHits
-{
- public:
-  enum class PropMethod {
-    Propagator,
-    Line,
-  };
-
-  void init();
-
-  std::optional<o2::itsmft::Hit> processHit(int iEvent, const o2::itsmft::Hit& hit);
-
-  void resetStats() { mStats.fill(0ull); }
-  void printStats() const;
-
- private:
-  Deformations mDeformations;
-  std::unique_ptr<ROOT::Math::Minimizer> mMinimizer;
-  PropMethod mMethod{PropMethod::Line};
-  o2::its::GeometryTGeo* mGeo{nullptr};
-  std::unique_ptr<o2::steer::MCKinematicsReader> mMCReader;
-
-  short getDetID(const o2::math_utils::Point3D<float>& point);
-  short getDetIDFromCords(const o2::math_utils::Point3D<float>& point);
-  short getDetIDFromPath(const std::string& path) const;
-
-  // We treat each hit as two separate hits', one for the entering and one for the exiting hit
-  struct WorkingHit {
-    enum HitType : uint8_t {
-      kEntering = 0,
-      kExiting,
-      kTypes,
-    };
-
-    WorkingHit() = default;
-
-    WorkingHit(int eventID, HitType t, const o2::itsmft::Hit& hit) : mEvent(eventID),
-                                                                     mTrackID(hit.GetTrackID()),
-                                                                     mType(t),
-                                                                     mDetID(hit.GetDetectorID()),
-                                                                     mLayerID(constants::detID::getDetID2Layer(mDetID)),
-                                                                     mSensorID(constants::detID::getSensorID(mDetID))
-    {
-      if (mType == kEntering) {
-        mRadius = constants::radiiInner[mLayerID];
-        mPoint = hit.GetPosStart();
-      } else {
-        mRadius = constants::radiiOuter[mLayerID];
-        mPoint = hit.GetPos();
-      }
-
-      // Pre-calculate the normalized u,v coordinates as starting parameters
-      const bool isTop = mSensorID % 2 == 0;
-      mPhi = o2::math_utils::to02Pi(std::atan2(mPoint.Y(), mPoint.X()));
-      mPhiBorder1 = o2::math_utils::to02Pi(((isTop) ? 0.f : 1.f) * TMath::Pi() + std::asin(constants::equatorialGap / 2.f / mRadius));
-      mPhiBorder2 = o2::math_utils::to02Pi(((isTop) ? 1.f : 2.f) * TMath::Pi() - std::asin(constants::equatorialGap / 2.f / mRadius));
-      mU = ((mPhi - mPhiBorder1) * 2.f) / (mPhiBorder2 - mPhiBorder1) - 1.f;
-      mV = (2.f * mPoint.Z() + constants::segment::lengthSensitive) / constants::segment::lengthSensitive - 1.f;
-    }
-
-    void recalculateIdeal(float phi, float z)
-    {
-      mPointDef.SetX(mRadius * std::cos(phi));
-      mPointDef.SetY(mRadius * std::sin(phi));
-      mPointDef.SetZ(z);
-    }
-
-    int mEvent;
-    int mTrackID;
-    HitType mType;
-    short mDetID;
-    int mLayerID;
-    int mSensorID;
-    float mRadius;
-    float mPhi;
-    o2::math_utils::Point3D<float> mPoint;
-    o2::math_utils::Point3D<float> mPointDef;
-    float mU; // u is normalized phi
-    float mV; // u is normalized z
-
-    float mPhiBorder1;
-    float mPhiBorder2;
-  };
-  std::array<WorkingHit, WorkingHit::kTypes> mCurWorkingHits;
-  o2::itsmft::Hit mCurHit;
-
-  bool deformHit(WorkingHit::HitType t);
-
-  auto getDeformation(unsigned int id, double u, double v) const
-  {
-    return mDeformations.getDeformation(id, u, v);
-  }
-
-  // Mimize function assuming a straight line
-  // given in the parametric representation by y_v = t * d_x + x_s
-  // assuming no offset is needed
-  class StraightLine : public ROOT::Math::IBaseFunctionMultiDim
-  {
-   public:
-    StraightLine(const MisAlignmentHits* m) : mMis(m) {}
-
-    std::array<double, 3> mD;
-    o2::math_utils::Point3D<float> mStart;
-    unsigned int mSensorID;
-    double mRadius;
-    const MisAlignmentHits* mMis;
-
-    double mPhiTot;
-    double mPhi1;
-
-    unsigned int NDim() const override { return 3; }
-    ROOT::Math::IBaseFunctionMultiDim* Clone() const override { return nullptr; }
-
-   private:
-    double DoEval(const double* x) const override;
-  };
-  StraightLine mLine{this};
-  void prepareLineMethod(WorkingHit::HitType from);
-
-  // Mimize function using the MCTrack
-  class Propagator : public ROOT::Math::IBaseFunctionMultiDim
-  {
-   public:
-    Propagator(const MisAlignmentHits* m) : mMis(m) {}
-
-    o2::track::TrackPar mTrack;
-    float mBz;
-    unsigned int mSensorID;
-    double mRadius;
-    const MisAlignmentHits* mMis;
-
-    double mPhiTot;
-    double mPhi1;
-
-    unsigned int NDim() const override { return 3; }
-    ROOT::Math::IBaseFunctionMultiDim* Clone() const override { return nullptr; }
-
-   private:
-    double DoEval(const double* x) const override;
-  };
-  Propagator mPropagator{this};
-  bool preparePropagatorMethod(WorkingHit::HitType from);
-
-  enum Stats : uint8_t {
-    kHitTotal = 0,
-    kHitIsOB,
-    kHitIsIB,
-    kHitDead,
-    kHitAlive,
-    kHitSuccess,
-    kHitMigrated,
-    kHitNotMigrated,
-    kHitEntBoundary,
-    kHitExtBoundary,
-    kHitNoBoundary,
-    kHitSameBoundary,
-    kFindNodeFailed,
-    kFindNodeSuccess,
-    kProjSensitive,
-    kProjNonSensitive,
-    kDetIDOk,
-    kDetIDBad,
-    kMinimizerStatusOk,
-    kMinimizerStatusBad,
-    kMinimizerValueOk,
-    kMinimizerValueBad,
-    kMinimizerConverged,
-    kMinimizerCovPos,
-    kMinimizerHesse,
-    kMinimizerEDM,
-    kMinimizerLimit,
-    kMinimizerOther,
-    kPropTrackNull,
-    kPropPDGNull,
-    kALL,
-  };
-  std::array<ULong64_t, Stats::kALL> mStats;
-};
-
-} // namespace o2::its3::align
-
-#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentManager.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentManager.h
deleted file mode 100644
index 0fe972442809d..0000000000000
--- a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentManager.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright 2020-2022 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef ITS3_MISALIGNMENTMANAGER_H_
-#define ITS3_MISALIGNMENTMANAGER_H_
-
-#include "Math/Transform3D.h"
-#include "Math/Translation3D.h"
-#include "Math/Rotation3D.h"
-#include "Math/EulerAngles.h"
-#include "Math/PositionVector3D.h"
-#include "TGeoMatrix.h"
-
-#include <filesystem>
-
-namespace o2::its3::align
-{
-
-/// Collection of static functions and types to perform misalignment studies
-struct MisalignmentManager {
-  using Vector3D = ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<float>, ROOT::Math::DefaultCoordinateSystemTag>;
-  using Point3D = ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<float>, ROOT::Math::DefaultCoordinateSystemTag>;
-  using Trans3D = ROOT::Math::Translation3DF;
-  using Rot3D = ROOT::Math::Rotation3D;
-  using Euler3D = ROOT::Math::EulerAngles;
-  using Trafo3D = ROOT::Math::Transform3DF;
-
-  static void misalignHits();
-
-  static void createBackup(const std::filesystem::path& src, const std::filesystem::path& dest);
-
-  static std::string appendStem(const std::string& filename, const std::string& add);
-
-  static std::vector<std::string> split(const std::string& s, char delimiter = '/');
-
-  static void navigate(const std::string& path);
-
-  static std::string composePathSensor(int sensor);
-
-  static void applyGlobalMatrixVolume(const std::string& path, const TGeoHMatrix& globalMatrix);
-};
-
-} // namespace o2::its3::align
-
-#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentParameters.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentParameters.h
deleted file mode 100644
index 243623cc650e1..0000000000000
--- a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentParameters.h
+++ /dev/null
@@ -1,93 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file MisalignmentParameters.h
-/// \brief Definition of the MisalignmentParameters class
-
-#ifndef ITS3_MISALIGNMENTPARAMETERS_H_
-#define ITS3_MISALIGNMENTPARAMETERS_H_
-
-#include "ITS3Base/SpecsV2.h"
-
-#include "TNamed.h"
-#include "TFile.h"
-#include "TMatrixD.h"
-
-#include <array>
-#include <string>
-
-namespace o2::its3::align
-{
-
-class MisalignmentParameters : public TNamed
-{
- public:
-  MisalignmentParameters();
-
-  // IO
-  bool store(const std::string& file) const;
-  static MisalignmentParameters* load(const std::string& file);
-
-  /// Global getters
-  double getGloTransX(unsigned int detID) const { return mGloTransX[detID]; }
-  double getGloTransY(unsigned int detID) const { return mGloTransY[detID]; }
-  double getGloTransZ(unsigned int detID) const { return mGloTransZ[detID]; }
-  double getGloRotX(unsigned int detID) const { return mGloRotX[detID]; }
-  double getGloRotY(unsigned int detID) const { return mGloRotY[detID]; }
-  double getGloRotZ(unsigned int detID) const { return mGloRotZ[detID]; }
-  /// Global setters
-  void setGloTransX(unsigned int detID, double v) { mGloTransX[detID] = v; }
-  void setGloTransY(unsigned int detID, double v) { mGloTransY[detID] = v; }
-  void setGloTransZ(unsigned int detID, double v) { mGloTransZ[detID] = v; }
-  void setGloRotX(unsigned int detID, double v) { mGloRotX[detID] = v; }
-  void setGloRotY(unsigned int detID, double v) { mGloRotY[detID] = v; }
-  void setGloRotZ(unsigned int detID, double v) { mGloRotZ[detID] = v; }
-
-  /// Legendre Coeff. getters
-  const TMatrixD& getLegendreCoeffX(unsigned int sensorID) const { return mLegCoeffX[sensorID]; }
-  const TMatrixD& getLegendreCoeffY(unsigned int sensorID) const { return mLegCoeffY[sensorID]; }
-  const TMatrixD& getLegendreCoeffZ(unsigned int sensorID) const { return mLegCoeffZ[sensorID]; }
-  /// Legendre Coeff. setters
-  void setLegendreCoeffX(unsigned int sensorID, const TMatrixD& m) { setMatrix(mLegCoeffX[sensorID], m); }
-  void setLegendreCoeffY(unsigned int sensorID, const TMatrixD& m) { setMatrix(mLegCoeffY[sensorID], m); }
-  void setLegendreCoeffZ(unsigned int sensorID, const TMatrixD& m) { setMatrix(mLegCoeffZ[sensorID], m); }
-
-  void printParams(unsigned int detID) const;
-  void printLegendreParams(unsigned int sensorID) const;
-
- private:
-  inline void setMatrix(TMatrixD& o, const TMatrixD& n)
-  {
-    o.ResizeTo(n.GetNrows(), n.GetNcols());
-    o = n;
-  }
-
-  static constexpr unsigned int nDetectors{constants::detID::nChips}; ///! for now just the IB
-
-  // Global parameters
-  std::array<double, nDetectors> mGloTransX; ///< Array to hold the global misalignment in x-direction
-  std::array<double, nDetectors> mGloTransY; ///< Array to hold the global misalignment in y-direction
-  std::array<double, nDetectors> mGloTransZ; ///< Array to hold the global misalignment in z-direction
-  std::array<double, nDetectors> mGloRotX;   ///< Array to hold the global misalignment in x-direction
-  std::array<double, nDetectors> mGloRotY;   ///< Array to hold the global misalignment in y-direction
-  std::array<double, nDetectors> mGloRotZ;   ///< Array to hold the global misalignment in z-direction
-
-  // Legendre Polynominals coefficients
-  std::array<TMatrixD, constants::nSensorsIB> mLegCoeffX;
-  std::array<TMatrixD, constants::nSensorsIB> mLegCoeffY;
-  std::array<TMatrixD, constants::nSensorsIB> mLegCoeffZ;
-
-  ClassDefOverride(MisalignmentParameters, 1);
-};
-
-} // namespace o2::its3::align
-
-#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/TrackFit.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/TrackFit.h
new file mode 100644
index 0000000000000..3f36705271c9b
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/TrackFit.h
@@ -0,0 +1,175 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGN_TRACKFIT
+#define O2_ITS3_ALIGN_TRACKFIT
+
+#include <Eigen/Dense>
+
+#include "ITSBase/GeometryTGeo.h"
+#include "DetectorsBase/Propagator.h"
+#include "ReconstructionDataFormats/Track.h"
+#include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsGlobalTracking/RecoContainer.h"
+
+namespace o2::its3::align
+{
+using Mat51 = Eigen::Matrix<double, 5, 1>;
+using Mat55 = Eigen::Matrix<double, 5, 5>;
+using TrackD = o2::track::TrackParCovD;
+
+template <typename T>
+struct TrackingCluster : public o2::BaseCluster<T> {
+  using o2::BaseCluster<T>::BaseCluster;
+  T alpha{};
+};
+
+template <typename T, typename F>
+track::TrackParametrizationWithError<T> convertTrack(const track::TrackParametrizationWithError<F>& trk)
+{
+  if constexpr (std::is_same_v<T, F>) {
+    return trk;
+  }
+  track::TrackParametrizationWithError<T> dst;
+  dst.setX(trk.getX());
+  dst.setAlpha(trk.getAlpha());
+  for (int iPar{0}; iPar < track::kNParams; ++iPar) {
+    dst.setParam(trk.getParam(iPar), iPar);
+  }
+  dst.setAbsCharge(trk.getAbsCharge());
+  dst.setPID(trk.getPID());
+  dst.setUserField(trk.getUserField());
+  for (int iCov{0}; iCov < track::kCovMatSize; ++iCov) {
+    dst.setCov(trk.getCov()[iCov], iCov);
+  }
+  return dst;
+}
+
+// Both tracks must be at the same (alpha, x).
+// Returns the interpolated track.
+template <typename T>
+o2::track::TrackParametrizationWithError<T> interpolateTrackParCov(
+  const o2::track::TrackParametrizationWithError<T>& tA,
+  const o2::track::TrackParametrizationWithError<T>& tB)
+{
+  auto res = tA;
+  if (!tA.isValid() || !tB.isValid() || tA.getAlpha() != tB.getAlpha() || tA.getX() != tB.getX()) {
+    res.invalidate();
+    return res;
+  }
+  auto unpack = [](const std::array<T, track::kCovMatSize>& c) {
+    Mat55 m;
+    for (int i = 0, k = 0; i < 5; ++i) {
+      for (int j = 0; j <= i; ++j, ++k) {
+        m(i, j) = m(j, i) = (double)c[k];
+      }
+    }
+    return m;
+  };
+  Mat55 cA = unpack(tA.getCov());
+  Mat55 cB = unpack(tB.getCov());
+  Mat55 wA = cA.inverse();
+  Mat55 wB = cB.inverse();
+  Mat55 wTot = wA + wB;
+  Mat55 cTot = wTot.inverse();
+  Mat51 pA, pB;
+  for (int i = 0; i < 5; ++i) {
+    pA(i) = tA.getParam(i);
+    pB(i) = tB.getParam(i);
+  }
+  Mat51 pTot = cTot * (wA * pA + wB * pB);
+  // build result - same alpha/x as inputs
+  for (int i = 0; i < 5; ++i) {
+    res.setParam(pTot(i), i);
+  }
+  for (int i = 0, k = 0; i < 5; ++i) {
+    for (int j = 0; j <= i; ++j, ++k) {
+      res.setCov(static_cast<T>(cTot(i, j)), k);
+    }
+  }
+  return res;
+}
+
+// Performs an outward (0->7) and inward (7->0) Kalman refit storing the
+// extrapolation *before* the cluster update at each layer.
+// cluster array clArr[0] = PV (optional), clArr[1..7] = layers 0-6.
+// chi2 is accumulated only for the outward direction
+template <typename T>
+bool doBidirRefit(
+  const o2::its::TrackITS& iTrack,
+  std::array<const TrackingCluster<T>*, 8>& clArr,
+  std::array<o2::track::TrackParametrizationWithError<T>, 8>& extrapOut,
+  std::array<o2::track::TrackParametrizationWithError<T>, 8>& extrapInw,
+  T& chi2,
+  bool useStableRef,
+  typename o2::base::PropagatorImpl<T>::MatCorrType corrType)
+{
+  const auto prop = o2::base::PropagatorImpl<T>::Instance();
+  const auto geom = o2::its::GeometryTGeo::Instance();
+  const auto bz = prop->getNominalBz();
+
+  auto rotateTrack = [bz](o2::track::TrackParametrizationWithError<T>& tr, T alpha, o2::track::TrackParametrization<T>* refLin) {
+    return refLin ? tr.rotate(alpha, *refLin, bz) : tr.rotate(alpha);
+  };
+  auto accountCluster = [&](int i, std::array<o2::track::TrackParametrizationWithError<T>, 8>& extrapDest, o2::track::TrackParametrizationWithError<T>& tr, o2::track::TrackParametrization<T>* refLin) -> int {
+    if (clArr[i]) {
+      bool outward = tr.getX() < clArr[i]->getX();
+      if (!rotateTrack(tr, clArr[i]->alpha, refLin) || !prop->propagateTo(tr, refLin, clArr[i]->getX(), false, base::PropagatorImpl<T>::MAX_SIN_PHI, base::PropagatorImpl<T>::MAX_STEP, corrType)) {
+        return 0;
+      }
+      if (outward) {
+        chi2 += tr.getPredictedChi2Quiet(*clArr[i]);
+      }
+      extrapDest[i] = tr; // before update
+      if (!tr.update(*clArr[i])) {
+        return 0;
+      }
+    } else {
+      extrapDest[i].invalidate();
+      return -1;
+    }
+    return 1;
+  };
+  auto trFitInw = convertTrack<T>(iTrack.getParamOut());
+  auto trFitOut = convertTrack<T>(iTrack.getParamIn());
+  if (clArr[0]) { // propagate outward seed to PV cluster's tracking frame
+    if (!trFitOut.rotate(clArr[0]->alpha) || !prop->propagateToX(trFitOut, clArr[0]->getX(), bz, base::PropagatorImpl<T>::MAX_SIN_PHI, base::PropagatorImpl<T>::MAX_STEP, corrType)) {
+      return false;
+    }
+  }
+  // linearization references
+  o2::track::TrackParametrization<T> refLinInw0, refLinOut0, *refLinOut = nullptr, *refLinInw = nullptr;
+  if (useStableRef) {
+    refLinOut = &(refLinOut0 = trFitOut);
+    refLinInw = &(refLinInw0 = trFitInw);
+  }
+
+  auto resetTrackCov = [bz](auto& trk) {
+    trk.resetCovariance();
+    float qptB5Scale = std::abs(bz) > 0.1f ? std::abs(bz) / 5.006680f : 1.f;
+    float q2pt2 = trk.getQ2Pt() * trk.getQ2Pt(), q2pt2Wgh = q2pt2 * qptB5Scale * qptB5Scale;
+    float err2 = (100.f + q2pt2Wgh) / (1.f + q2pt2Wgh) * q2pt2; // -> 100 for high pTs, -> 1 for low pTs.
+    trk.setCov(err2, 14);                                       // 100% error
+  };
+  resetTrackCov(trFitOut);
+  resetTrackCov(trFitInw);
+
+  for (int i = 0; i <= 7; i++) {
+    if (!accountCluster(i, extrapOut, trFitOut, refLinOut) || !accountCluster(7 - i, extrapInw, trFitInw, refLinInw)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+} // namespace o2::its3::align
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx
new file mode 100644
index 0000000000000..9170165a36a41
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx
@@ -0,0 +1,486 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <format>
+#include <fstream>
+#include <sstream>
+#include <fnmatch.h>
+#include <cmath>
+#include <TGeoManager.h>
+#include <TGeoPhysicalNode.h>
+#include <nlohmann/json.hpp>
+
+#include "ITS3Align/AlignmentHierarchy.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "Framework/Logger.h"
+#include "MathUtils/Utils.h"
+
+namespace o2::its3::align
+{
+
+void HierarchyConstraint::write(std::ostream& os) const
+{
+  os << "!!! " << mName << '\n';
+  os << "Constraint " << mValue << '\n';
+  for (size_t i{0}; i < mLabels.size(); ++i) {
+    os << mLabels[i] << " " << mCoeff[i] << '\n';
+  }
+  os << '\n';
+}
+
+AlignableVolume::AlignableVolume(const char* symName, uint32_t label, uint32_t det, bool sens) : mSymName(symName), mLabel(det, label, sens)
+{
+  init();
+}
+
+AlignableVolume::AlignableVolume(const char* symName, GlobalLabel label) : mSymName(symName), mLabel(label)
+{
+  init();
+}
+
+void AlignableVolume::init()
+{
+  // check if this sym volume actually exists
+  mPNE = gGeoManager->GetAlignableEntry(mSymName.c_str());
+  if (mPNE == nullptr) {
+    LOGP(fatal, "Symbolic volume '{}' has no corresponding alignable entry!", mSymName);
+  }
+  mPN = mPNE->GetPhysicalNode();
+  if (mPN == nullptr) {
+    LOGP(debug, "Adding physical node to {}", mSymName);
+    mPN = gGeoManager->MakePhysicalNode(mPNE->GetTitle());
+    if (mPN == nullptr) {
+      LOGP(fatal, "Failed to make physical node for {}", mSymName);
+    }
+  }
+}
+
+void AlignableVolume::finalise(uint8_t level)
+{
+  if (level == 0 && !isRoot()) {
+    LOGP(fatal, "Finalise should be called only from the root node!");
+  }
+  mLevel = level;
+  if (!isLeaf()) {
+    // depth first
+    for (const auto& c : mChildren) {
+      c->finalise(level + 1);
+    }
+    // auto-disable parent RB DOFs if no children are active
+    if (mRigidBody) {
+      int nActiveChildren = 0;
+      for (const auto& c : mChildren) {
+        if (c->isActive()) {
+          ++nActiveChildren;
+        }
+      }
+      if (!nActiveChildren) {
+        for (int iDOF = 0; iDOF < mRigidBody->nDOFs(); ++iDOF) {
+          if (mRigidBody->isFree(iDOF)) {
+            LOGP(warn, "Auto-disabling DOF {} for {} since no active children",
+                 mRigidBody->dofName(iDOF), mSymName);
+            mRigidBody->setFree(iDOF, false);
+          }
+        }
+      }
+    }
+  } else {
+    // for sensors we need also to define the transformation from the measurment (TRK) to the local frame (LOC)
+    // need to it with including possible pre-alignment to allow for iterative convergence
+    // (TRK) is defined wrt global z-axis
+    defineMatrixL2G();
+    defineMatrixT2L();
+  }
+  if (!isRoot()) {
+    // prepare the transformation matrices, e.g. from child frame to parent frame
+    // this is not necessarily just one level transformation
+    TGeoHMatrix mat = *mPN->GetMatrix(); // global matrix (including possible pre-alignment) from this volume to the global frame
+    if (isLeaf()) {
+      mat = mL2G; // for sensor volumes they might have redefined the L2G definition
+    }
+    auto inv = mParent->mPN->GetMatrix()->Inverse(); // global (including possible pre-alignment) from this volume to the global frame
+    mat.MultiplyLeft(inv);                           // left mult. effectively subtracts the parent transformation which is included in the the childs
+    mL2P = mat;                                      // now this is directly the child to the parent transformation (LOC) (including possible pre-alignment)
+
+    // prepare jacobian from child to parent frame
+    Eigen::Map<const Eigen::Matrix<double, 3, 3, Eigen::RowMajor>> rotL2P(mL2P.GetRotationMatrix());
+    Eigen::Matrix3d rotInv = rotL2P.transpose(); // parent-to-child rotation
+    const double* t = mL2P.GetTranslation();     // child origin in parent frame
+    Eigen::Matrix3d skewT;
+    skewT << 0, -t[2], t[1], t[2], 0, -t[0], -t[1], t[0], 0;
+    mJL2P.setZero();
+    mJL2P.topLeftCorner<3, 3>() = rotInv;
+    mJL2P.topRightCorner<3, 3>() = -rotInv * skewT;
+    mJL2P.bottomRightCorner<3, 3>() = rotInv;
+    mJP2L = mJL2P.inverse();
+  }
+}
+
+void AlignableVolume::writeRigidBodyConstraints(std::ostream& os) const
+{
+  if (isLeaf() || !mRigidBody) {
+    // recurse even if this node has no RB DOFs
+    for (const auto& c : mChildren) {
+      c->writeRigidBodyConstraints(os);
+    }
+    return;
+  }
+
+  for (int iDOF = 0; iDOF < mRigidBody->nDOFs(); ++iDOF) {
+    if (!mRigidBody->isFree(iDOF)) {
+      continue;
+    }
+    double nActiveChildren = 0.;
+    for (const auto& c : mChildren) {
+      if (c->isActive()) {
+        ++nActiveChildren;
+      }
+    }
+    if (nActiveChildren == 0.) {
+      LOGP(fatal, "{} has dof {} active but no active children!", mSymName, mRigidBody->dofName(iDOF));
+    }
+    const double invN = 1.0 / nActiveChildren;
+    HierarchyConstraint con(std::format("DOF {} for {}", mRigidBody->dofName(iDOF), mSymName), 0.0);
+    for (const auto& c : mChildren) {
+      if (!c->mRigidBody) {
+        continue;
+      }
+      for (int jDOF = 0; jDOF < c->mRigidBody->nDOFs(); ++jDOF) {
+        if (!c->mRigidBody->isFree(jDOF)) {
+          continue;
+        }
+        double coeff = invN * c->getJP2L()(iDOF, jDOF);
+        if (std::abs(coeff) > 1e-16f) {
+          con.add(c->getLabel().raw(jDOF), coeff);
+        }
+      }
+    }
+
+    if (con.getSize() > 1) {
+      con.write(os);
+    }
+  }
+  for (const auto& c : mChildren) {
+    c->writeRigidBodyConstraints(os);
+  }
+}
+
+void AlignableVolume::writeParameters(std::ostream& os) const
+{
+  if (isRoot()) {
+    os << "Parameter\n";
+  }
+  if (mRigidBody) {
+    for (int iDOF = 0; iDOF < mRigidBody->nDOFs(); ++iDOF) {
+      os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {} ",
+                        mLabel.raw(iDOF), 0.0, (mRigidBody->isFree(iDOF) ? 0.0 : -1.0),
+                        (mRigidBody->isFree(iDOF) ? 'V' : 'F'), mRigidBody->dofName(iDOF))
+         << mSymName << '\n';
+    }
+  }
+  if (mCalib) {
+    auto calibLbl = mLabel.asCalib();
+    for (int iDOF = 0; iDOF < mCalib->nDOFs(); ++iDOF) {
+      os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {} ",
+                        calibLbl.raw(iDOF), 0.0, (mCalib->isFree(iDOF) ? 0.0 : -1.0),
+                        (mCalib->isFree(iDOF) ? 'V' : 'F'), mCalib->dofName(iDOF))
+         << mSymName << '\n';
+    }
+  }
+  for (const auto& c : mChildren) {
+    c->writeParameters(os);
+  }
+}
+
+void AlignableVolume::writeTree(std::ostream& os, int indent) const
+{
+  os << std::string(static_cast<size_t>(indent * 2), ' ') << mSymName << (mLabel.sens() ? " (sens)" : " (pasv)");
+  if (mIsPseudo) {
+    os << " pseudo";
+  } else {
+    int nFreeDofs{0};
+    if (mRigidBody && mRigidBody->nFreeDOFs()) {
+      nFreeDofs += mRigidBody->nFreeDOFs();
+      os << " RB[";
+      for (int i = 0; i < mRigidBody->nDOFs(); ++i) {
+        if (mRigidBody->isFree(i)) {
+          os << " " << mRigidBody->dofName(i) << "(" << mLabel.raw(i) << ")";
+        }
+      }
+      os << " ]";
+    }
+    if (mCalib && mCalib->nFreeDOFs()) {
+      nFreeDofs += mCalib->nFreeDOFs();
+      os << " CAL[";
+      auto calibLbl = mLabel.asCalib();
+      for (int i = 0; i < mCalib->nDOFs(); ++i) {
+        if (mCalib->isFree(i)) {
+          os << " " << mCalib->dofName(i) << "(" << calibLbl.raw(i) << ")";
+        }
+      }
+      os << " ]";
+    }
+    if (!nFreeDofs) {
+      os << " no DOFs";
+    }
+  }
+  os << '\n';
+  for (const auto& c : mChildren) {
+    c->writeTree(os, indent + 2);
+  }
+}
+
+void applyDOFConfig(AlignableVolume* root, const std::string& jsonPath)
+{
+  using json = nlohmann::json;
+  std::ifstream f(jsonPath);
+  if (!f.is_open()) {
+    LOGP(fatal, "Cannot open DOF config file: {}", jsonPath);
+  }
+  auto data = json::parse(f);
+  json rules = data.is_array() ? data : data.value("rules", json::array());
+
+  static const std::map<std::string, int> rbNameToIdx = {
+    {"TX", 0}, {"TY", 1}, {"TZ", 2}, {"RX", 3}, {"RY", 4}, {"RZ", 5}};
+
+  auto matchPattern = [](const std::string& pattern, const std::string& sym) -> bool {
+    if (fnmatch(pattern.c_str(), sym.c_str(), 0) == 0) {
+      return true;
+    }
+    std::string prefixed = "*" + pattern;
+    return fnmatch(prefixed.c_str(), sym.c_str(), 0) == 0;
+  };
+
+  if (data.is_object() && data.contains("defaults")) {
+    json defRule = data["defaults"];
+    defRule["match"] = "*";
+    rules.insert(rules.begin(), defRule);
+  }
+
+  root->traverse([&](AlignableVolume* vol) {
+    const std::string& sym = vol->getSymName();
+    for (const auto& rule : rules) {
+      const auto pattern = rule["match"].get<std::string>();
+      if (!matchPattern(pattern, sym)) {
+        continue;
+      }
+      // rigid body DOFs
+      if (rule.contains("rigidBody")) {
+        const auto& rb = rule["rigidBody"];
+        if (rb.is_string()) {
+          auto s = rb.get<std::string>();
+          if (s == "all" || s == "free") {
+            vol->setRigidBody(std::make_unique<RigidBodyDOFSet>());
+          } else if (s == "fixed") {
+            auto dofSet = std::make_unique<RigidBodyDOFSet>();
+            dofSet->setAllFree(false);
+            vol->setRigidBody(std::move(dofSet));
+          }
+        } else if (rb.is_array()) {
+          auto dofSet = std::make_unique<RigidBodyDOFSet>();
+          dofSet->setAllFree(false);
+          for (const auto& name : rb) {
+            auto it = rbNameToIdx.find(name.get<std::string>());
+            if (it != rbNameToIdx.end()) {
+              dofSet->setFree(it->second, true);
+            }
+          }
+          vol->setRigidBody(std::move(dofSet));
+        } else if (rb.is_object()) {
+          auto dofs = rb.value("dofs", std::string("all"));
+          bool fixed = rb.value("fixed", false);
+          if (dofs == "all") {
+            auto dofSet = std::make_unique<RigidBodyDOFSet>();
+            if (fixed) {
+              dofSet->setAllFree(false);
+            }
+            vol->setRigidBody(std::move(dofSet));
+          } else if (rb["dofs"].is_array()) {
+            auto dofSet = std::make_unique<RigidBodyDOFSet>();
+            dofSet->setAllFree(false);
+            for (const auto& name : rb["dofs"]) {
+              auto it = rbNameToIdx.find(name.get<std::string>());
+              if (it != rbNameToIdx.end()) {
+                dofSet->setFree(it->second, !fixed);
+              }
+            }
+            vol->setRigidBody(std::move(dofSet));
+          }
+        }
+      }
+      // calibration DOFs
+      if (rule.contains("calib")) {
+        const auto& cal = rule["calib"];
+        auto calType = cal.value("type", std::string(""));
+        if (calType == "legendre") {
+          int order = cal.value("order", 3);
+          auto dofSet = std::make_unique<LegendreDOFSet>(order);
+          bool fixed = cal.value("fixed", false);
+          if (fixed) {
+            dofSet->setAllFree(false);
+          }
+          // fix/free individual coefficients by name or index
+          if (cal.contains("free")) {
+            dofSet->setAllFree(false);
+            for (const auto& item : cal["free"]) {
+              if (item.is_number_integer()) {
+                dofSet->setFree(item.get<int>(), true);
+              } else if (item.is_string()) {
+                // match by name e.g. "L(1,0)"
+                for (int k = 0; k < dofSet->nDOFs(); ++k) {
+                  if (dofSet->dofName(k) == item.get<std::string>()) {
+                    dofSet->setFree(k, true);
+                  }
+                }
+              }
+            }
+          }
+          if (cal.contains("fix")) {
+            for (const auto& item : cal["fix"]) {
+              if (item.is_number_integer()) {
+                dofSet->setFree(item.get<int>(), false);
+              } else if (item.is_string()) {
+                for (int k = 0; k < dofSet->nDOFs(); ++k) {
+                  if (dofSet->dofName(k) == item.get<std::string>()) {
+                    dofSet->setFree(k, false);
+                  }
+                }
+              }
+            }
+          }
+          vol->setCalib(std::move(dofSet));
+        }
+      }
+    }
+  });
+}
+
+void writeMillepedeResults(AlignableVolume* root, const std::string& milleResPath, const std::string& outJsonPath, const std::string& injectedJsonPath)
+{
+  using json = nlohmann::json;
+
+  // parse millepede.res: label fittedValue presigma [...]
+  std::ifstream fin(milleResPath);
+  if (!fin.is_open()) {
+    LOGP(fatal, "Cannot open millepede result file: {}", milleResPath);
+  }
+  std::map<uint32_t, double> labelToValue;
+  std::string line;
+  while (std::getline(fin, line)) {
+    if (line.empty() || line[0] == '!' || line[0] == '*') {
+      continue;
+    }
+    if (line.find("Parameter") != std::string::npos) {
+      continue;
+    }
+    std::istringstream iss(line);
+    uint32_t label = 0;
+    double value = NAN, presigma = NAN;
+    if (!(iss >> label >> value >> presigma)) {
+      continue;
+    }
+    if (presigma >= 0.0) { // skip fixed parameters
+      labelToValue[label] = value;
+    }
+  }
+  fin.close();
+  LOGP(info, "Parsed {} not fixed parameters from {}", labelToValue.size(), milleResPath);
+
+  // load injected misalignment if provided (same format as closure test input)
+  // indexed by sensorID
+  std::map<int, std::vector<double>> injRB;
+  std::map<int, std::vector<std::vector<double>>> injMatrix;
+  if (!injectedJsonPath.empty()) {
+    std::ifstream injFile(injectedJsonPath);
+    if (injFile.is_open()) {
+      json injData = json::parse(injFile);
+      for (const auto& item : injData) {
+        int id = item["id"].get<int>();
+        if (item.contains("rigidBody")) {
+          injRB[id] = item["rigidBody"].get<std::vector<double>>();
+        }
+        if (item.contains("matrix")) {
+          injMatrix[id] = item["matrix"].get<std::vector<std::vector<double>>>();
+        }
+      }
+      LOGP(info, "Loaded injected misalignment for {} sensors", injData.size());
+    } else {
+      LOGP(warn, "Cannot open injected misalignment file: {}, writing absolute values", injectedJsonPath);
+    }
+  }
+
+  // collect results per volume that has RB or calib DOFs
+  json output = json::array();
+  root->traverse([&](AlignableVolume* vol) {
+    auto* rb = vol->getRigidBody();
+    auto* cal = vol->getCalib();
+    if ((!rb && !cal) || vol->isPseudo()) {
+      return;
+    }
+    int id = vol->getSensorId();
+    json entry;
+    entry["symName"] = vol->getSymName();
+    entry["id"] = id;
+    bool write = false;
+
+    // rigid body parameters
+    if (rb && rb->nFreeDOFs()) {
+      write = true;
+      json rbArr = json::array();
+      const auto& inj = injRB.contains(id) ? injRB[id] : std::vector<double>{};
+      for (int i = 0; i < rb->nDOFs(); ++i) {
+        uint32_t raw = vol->getLabel().raw(i);
+        auto it = labelToValue.find(raw);
+        double fitted = it != labelToValue.end() ? it->second : 0.0;
+        double ref = i < static_cast<int>(inj.size()) ? inj[i] : 0.0;
+        rbArr.push_back(fitted - ref);
+      }
+      entry["rigidBody"] = rbArr;
+    }
+
+    // calibration (Legendre) parameters
+    if (cal && cal->nFreeDOFs() && cal->type() == DOFSet::Type::Legendre) {
+      write = true;
+      auto* leg = dynamic_cast<const LegendreDOFSet*>(cal);
+      int order = leg->order();
+      auto calibLbl = vol->getLabel().asCalib();
+      const auto& inj = injMatrix.contains(id) ? injMatrix[id] : std::vector<std::vector<double>>{};
+      json matrix = json::array();
+      int idx = 0;
+      for (int i = 0; i <= order; ++i) {
+        json row = json::array();
+        for (int j = 0; j <= i; ++j) {
+          uint32_t raw = calibLbl.raw(idx);
+          auto it = labelToValue.find(raw);
+          double fitted = it != labelToValue.end() ? it->second : 0.0;
+          double ref = (i < static_cast<int>(inj.size()) && j < static_cast<int>(inj[i].size())) ? inj[i][j] : 0.0;
+          row.push_back(fitted - ref);
+          ++idx;
+        }
+        matrix.push_back(row);
+      }
+      entry["matrix"] = matrix;
+    }
+    if (write) {
+      output.push_back(entry);
+    }
+  });
+
+  std::ofstream fout(outJsonPath);
+  if (!fout.is_open()) {
+    LOGP(fatal, "Cannot open output file: {}", outJsonPath);
+  }
+  fout << output.dump(2) << '\n';
+  fout.close();
+  LOGP(info, "Wrote millepede results to {}", outJsonPath);
+}
+
+} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentParams.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentParams.cxx
new file mode 100644
index 0000000000000..0d89cb4d4cffd
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentParams.cxx
@@ -0,0 +1,13 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3Align/AlignmentParams.h"
+O2ParamImpl(o2::its3::align::AlignmentParams);
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentSensors.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentSensors.cxx
new file mode 100644
index 0000000000000..7644c37107104
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentSensors.cxx
@@ -0,0 +1,201 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <TGeoManager.h>
+#include <TGeoPhysicalNode.h>
+
+#include "Framework/Logger.h"
+#include "ITSMFTBase/SegmentationAlpide.h"
+#include "ITS3Align/AlignmentSensors.h"
+#include "ITSBase/GeometryTGeo.h"
+
+namespace o2::its3::align
+{
+
+AlignableVolume::Ptr buildHierarchyITS(AlignableVolume::SensorMapping& sensorMap)
+{
+  uint32_t gLbl{0}, det{0};
+  auto geom = o2::its::GeometryTGeo::Instance();
+  AlignableVolume *volHB{nullptr}, *volSt{nullptr}, *volHSt{nullptr}, *volMod{nullptr};
+  std::unordered_map<std::string, AlignableVolume*> sym2vol;
+
+  auto root = std::make_unique<AlignableVolume>(geom->composeSymNameITS(), gLbl++, det, false);
+  sym2vol[root->getSymName()] = root.get();
+  for (int ilr = 0; ilr < geom->getNumberOfLayers(); ilr++) {
+    for (int ihb = 0; ihb < geom->getNumberOfHalfBarrels(); ihb++) {
+      volHB = root->addChild(geom->composeSymNameHalfBarrel(ilr, ihb), gLbl++, det, false);
+      sym2vol[volHB->getSymName()] = volHB;
+      int nstavesHB = geom->getNumberOfStaves(ilr) / 2;
+      for (int ist = 0; ist < nstavesHB; ist++) {
+        volSt = volHB->addChild(geom->composeSymNameStave(ilr, ihb, ist), gLbl++, det, false);
+        sym2vol[volSt->getSymName()] = volSt;
+        for (int ihst = 0; ihst < geom->getNumberOfHalfStaves(ilr); ihst++) {
+          volHSt = volSt->addChild(geom->composeSymNameHalfStave(ilr, ihb, ist, ihst), gLbl++, det, false);
+          sym2vol[volHSt->getSymName()] = volHSt;
+          for (int imd = 0; imd < geom->getNumberOfModules(ilr); imd++) {
+            volMod = volHSt->addChild(geom->composeSymNameModule(ilr, ihb, ist, ihst, imd), gLbl++, det, false);
+            sym2vol[volMod->getSymName()] = volMod;
+          }
+        }
+      }
+    }
+  }
+
+  // NOTE: for ITS sensors the local x and y are swapped
+  int lay = 0, hba = 0, sta = 0, ssta = 0, modd = 0, chip = 0;
+  for (int ich = 0; ich < geom->getNumberOfChips(); ich++) {
+    geom->getChipId(ich, lay, hba, sta, ssta, modd, chip);
+    GlobalLabel lbl(det, ich, true);
+    AlignableVolume* parVol = sym2vol[modd < 0 ? geom->composeSymNameStave(lay, hba, sta) : geom->composeSymNameModule(lay, hba, sta, ssta, modd)];
+    if (!parVol) {
+      LOGP(fatal, "did not find parent for chip {}", ich);
+    }
+    int nch = modd < 0 ? geom->getNumberOfChipsPerStave(lay) : geom->getNumberOfChipsPerModule(lay);
+    int jch = ich % nch;
+    auto* chip = parVol->addChild<AlignableSensorITS>(geom->composeSymNameChip(lay, hba, sta, ssta, modd, jch), lbl);
+    chip->setSensorId(ich);
+    sensorMap[lbl] = chip;
+  }
+  return root;
+}
+
+AlignableVolume::Ptr buildHierarchyIT3(AlignableVolume::SensorMapping& sensorMap)
+{
+  uint32_t gLbl{0}, det{0};
+  auto geom = o2::its::GeometryTGeo::Instance();
+  AlignableVolume *volHB{nullptr}, *volSt{nullptr}, *volHSt{nullptr}, *volMod{nullptr};
+  std::unordered_map<std::string, AlignableVolume*> sym2vol;
+
+  auto root = std::make_unique<AlignableVolume>(geom->composeSymNameITS(), gLbl++, det, false);
+  sym2vol[root->getSymName()] = root.get();
+  for (int ilr = 0; ilr < geom->getNumberOfLayers(); ilr++) {
+    const bool isLayITS3 = (ilr < 3);
+    for (int ihb = 0; ihb < geom->getNumberOfHalfBarrels(); ihb++) {
+      volHB = root->addChild(geom->composeSymNameHalfBarrel(ilr, ihb, isLayITS3), gLbl++, det, false);
+      sym2vol[volHB->getSymName()] = volHB;
+      if (isLayITS3) {
+        volHB->setSensorId((2 * ilr) + ihb);
+        continue; // no deeper hierarchy for ITS3 layers
+      }
+      int nstavesHB = geom->getNumberOfStaves(ilr) / 2;
+      for (int ist = 0; ist < nstavesHB; ist++) {
+        volSt = volHB->addChild(geom->composeSymNameStave(ilr, ihb, ist), gLbl++, det, false);
+        sym2vol[volSt->getSymName()] = volSt;
+        for (int ihst = 0; ihst < geom->getNumberOfHalfStaves(ilr); ihst++) {
+          volHSt = volSt->addChild(geom->composeSymNameHalfStave(ilr, ihb, ist, ihst), gLbl++, det, false);
+          sym2vol[volHSt->getSymName()] = volHSt;
+          for (int imd = 0; imd < geom->getNumberOfModules(ilr); imd++) {
+            volMod = volHSt->addChild(geom->composeSymNameModule(ilr, ihb, ist, ihst, imd), gLbl++, det, false);
+            sym2vol[volMod->getSymName()] = volMod;
+          }
+        }
+      }
+    }
+  }
+
+  int lay = 0, hba = 0, sta = 0, ssta = 0, modd = 0, chip = 0;
+  for (int ich = 0; ich < geom->getNumberOfChips(); ich++) {
+    geom->getChipId(ich, lay, hba, sta, ssta, modd, chip);
+    const bool isLayITS3 = (lay < 3);
+    GlobalLabel lbl(det, ich, true);
+    if (isLayITS3) {
+      // ITS3 chips by construction do not have any DOFs still add them to have the measurment to alignable layer relation
+      AlignableVolume* parVol = sym2vol[geom->composeSymNameHalfBarrel(lay, hba, true)];
+      if (!parVol) {
+        LOGP(fatal, "did not find parent for chip {}", ich);
+      }
+      auto* tile = parVol->addChild<AlignableSensorIT3>(geom->composeSymNameChip(lay, hba, sta, ssta, modd, chip, true), lbl);
+      tile->setPseudo(true);
+      tile->setSensorId(ich);
+      sensorMap[lbl] = tile;
+    } else {
+      AlignableVolume* parVol = sym2vol[modd < 0 ? geom->composeSymNameStave(lay, hba, sta) : geom->composeSymNameModule(lay, hba, sta, ssta, modd)];
+      if (!parVol) {
+        LOGP(fatal, "did not find parent for chip {}", ich);
+      }
+      int nch = modd < 0 ? geom->getNumberOfChipsPerStave(lay) : geom->getNumberOfChipsPerModule(lay);
+      int jch = ich % nch;
+      auto* chip = parVol->addChild<AlignableSensorITS>(geom->composeSymNameChip(lay, hba, sta, ssta, modd, jch), lbl);
+      chip->setSensorId(ich);
+      sensorMap[lbl] = chip;
+    }
+  }
+  return root;
+}
+
+void AlignableSensorITS::defineMatrixL2G()
+{
+  // the chip volume is not the measurment plane, need to correct for the epitaxial layer
+  const auto* chipL2G = mPN->GetMatrix();
+  mL2G = *chipL2G;
+  double delta = itsmft::SegmentationAlpide::SensorLayerThickness - itsmft::SegmentationAlpide::SensorLayerThicknessEff;
+  TGeoTranslation tra(0., 0.5 * delta, 0.);
+  mL2G *= tra;
+}
+
+void AlignableSensorITS::defineMatrixT2L()
+{
+  double locA[3] = {-100., 0., 0.}, locB[3] = {100., 0., 0.}, gloA[3], gloB[3];
+  mL2G.LocalToMaster(locA, gloA);
+  mL2G.LocalToMaster(locB, gloB);
+  double dx = gloB[0] - gloA[0], dy = gloB[1] - gloA[1];
+  double t = (gloB[0] * dx + gloB[1] * dy) / (dx * dx + dy * dy);
+  double xp = gloB[0] - (dx * t), yp = gloB[1] - (dy * t);
+  double alp = std::atan2(yp, xp);
+  o2::math_utils::bringTo02Pid(alp);
+  mT2L.RotateZ(alp * TMath::RadToDeg()); // mT2L before is identity and afterwards rotated
+  const TGeoHMatrix l2gI = mL2G.Inverse();
+  mT2L.MultiplyLeft(l2gI);
+}
+
+void AlignableSensorITS::computeJacobianL2T(const double* posLoc, Matrix66& jac) const
+{
+  jac.setZero();
+  Eigen::Map<const Eigen::Matrix<double, 3, 3, Eigen::RowMajor>> rotT2L(mT2L.GetRotationMatrix());
+  Eigen::Matrix3d skew, rotL2T = rotT2L.transpose();
+  skew << 0, -posLoc[2], posLoc[1], posLoc[2], 0, -posLoc[0], -posLoc[1], posLoc[0], 0;
+  jac.topLeftCorner<3, 3>() = rotL2T;
+  jac.topRightCorner<3, 3>() = -rotL2T * skew;
+  jac.bottomRightCorner<3, 3>() = rotL2T;
+}
+
+void AlignableSensorIT3::defineMatrixL2G()
+{
+  mL2G = *mPN->GetMatrix();
+}
+
+void AlignableSensorIT3::defineMatrixT2L()
+{
+  double locA[3] = {-100., 0., 0.}, locB[3] = {100., 0., 0.}, gloA[3], gloB[3];
+  mL2G.LocalToMaster(locA, gloA);
+  mL2G.LocalToMaster(locB, gloB);
+  double dx = gloB[0] - gloA[0], dy = gloB[1] - gloA[1];
+  double t = (gloB[0] * dx + gloB[1] * dy) / (dx * dx + dy * dy);
+  double xp = gloB[0] - (dx * t), yp = gloB[1] - (dy * t);
+  double alp = std::atan2(yp, xp);
+  o2::math_utils::bringTo02Pid(alp);
+  mT2L.RotateZ(alp * TMath::RadToDeg());
+  const TGeoHMatrix l2gI = mL2G.Inverse();
+  mT2L.MultiplyLeft(l2gI);
+}
+
+void AlignableSensorIT3::computeJacobianL2T(const double* posLoc, Matrix66& jac) const
+{
+  jac.setZero();
+  Eigen::Map<const Eigen::Matrix<double, 3, 3, Eigen::RowMajor>> rotT2L(mT2L.GetRotationMatrix());
+  Eigen::Matrix3d skew, rotL2T = rotT2L.transpose();
+  skew << 0, -posLoc[2], posLoc[1], posLoc[2], 0, -posLoc[0], -posLoc[1], posLoc[0], 0;
+  jac.topLeftCorner<3, 3>() = rotL2T;
+  jac.topRightCorner<3, 3>() = -rotL2T * skew;
+  jac.bottomRightCorner<3, 3>() = rotL2T;
+}
+
+} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx
new file mode 100644
index 0000000000000..d381abc6aa567
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx
@@ -0,0 +1,1003 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <cmath>
+#include <memory>
+#include <chrono>
+
+#ifdef WITH_OPENMP
+#include <omp.h>
+#endif
+
+#include <Eigen/Dense>
+#include <GblTrajectory.h>
+#include <GblData.h>
+#include <GblPoint.h>
+#include <GblMeasurement.h>
+#include <MilleBinary.h>
+#include <nlohmann/json.hpp>
+
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/Task.h"
+#include "ITSBase/GeometryTGeo.h"
+#include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "DetectorsBase/Propagator.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "ReconstructionDataFormats/PrimaryVertex.h"
+#include "Steer/MCKinematicsReader.h"
+#include "CommonUtils/TreeStreamRedirector.h"
+#include "ReconstructionDataFormats/VtxTrackRef.h"
+#include "ITS3Reconstruction/TopologyDictionary.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+#include "ITStracking/MathUtils.h"
+#include "ITStracking/IOUtils.h"
+#include "ITS3Reconstruction/IOUtils.h"
+#include "ITS3Align/TrackFit.h"
+#include "ITS3Align/AlignmentSpec.h"
+#include "ITS3Align/AlignmentParams.h"
+#include "ITS3Align/AlignmentTypes.h"
+#include "ITS3Align/AlignmentHierarchy.h"
+#include "ITS3Align/AlignmentSensors.h"
+#include "MathUtils/LegendrePols.h"
+
+namespace o2::its3::align
+{
+using namespace o2::framework;
+using DetID = o2::detectors::DetID;
+using DataRequest = o2::globaltracking::DataRequest;
+using PVertex = o2::dataformats::PrimaryVertex;
+using V2TRef = o2::dataformats::VtxTrackRef;
+using VTIndex = o2::dataformats::VtxTrackIndex;
+using GTrackID = o2::dataformats::GlobalTrackID;
+using TrackD = o2::track::TrackParCovD;
+
+namespace
+{
+// compute normalized (u,v) in [-1,1] from global position on a sensor
+std::pair<double, double> computeUV(double gloX, double gloY, double gloZ, int sensorID, double radius)
+{
+  const bool isTop = sensorID % 2 == 0;
+  const double phi = o2::math_utils::to02Pid(std::atan2(gloY, gloX));
+  const double phiBorder1 = o2::math_utils::to02Pid(((isTop ? 0. : 1.) * TMath::Pi()) + std::asin(constants::equatorialGap / 2. / radius));
+  const double phiBorder2 = o2::math_utils::to02Pid(((isTop ? 1. : 2.) * TMath::Pi()) - std::asin(constants::equatorialGap / 2. / radius));
+  const double u = (((phi - phiBorder1) * 2.) / (phiBorder2 - phiBorder1)) - 1.;
+  const double v = ((2. * gloZ + constants::segment::lengthSensitive) / constants::segment::lengthSensitive) - 1.;
+  return {u, v};
+}
+
+// evaluate Legendre polynomials P_0(x) through P_order(x) via recurrence
+std::vector<double> legendrePols(int order, double x)
+{
+  std::vector<double> p(order + 1);
+  p[0] = 1.;
+  if (order > 0) {
+    p[1] = x;
+  }
+  for (int n = 1; n < order; ++n) {
+    p[n + 1] = ((2 * n + 1) * x * p[n] - n * p[n - 1]) / (n + 1);
+  }
+  return p;
+}
+} // namespace
+
+class AlignmentSpec final : public Task
+{
+ public:
+  ~AlignmentSpec() final = default;
+  AlignmentSpec(const AlignmentSpec&) = delete;
+  AlignmentSpec(AlignmentSpec&&) = delete;
+  AlignmentSpec& operator=(const AlignmentSpec&) = delete;
+  AlignmentSpec& operator=(AlignmentSpec&&) = delete;
+  AlignmentSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC, bool withPV, bool withITS, OutputEnum out)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC), mWithPV(withPV), mIsITS3(!withITS), mOutOpt(out)
+  {
+  }
+
+  void init(InitContext& ic) final;
+  void run(ProcessingContext& pc) final;
+  void endOfStream(EndOfStreamContext& ec) final;
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
+  void process();
+
+ private:
+  void updateTimeDependentParams(ProcessingContext& pc);
+  void buildHierarchy();
+
+  // calculate the transport jacobian for points FROM and TO numerically via ridder's method
+  // this assumes the track is already at point FROM and will be extrapolated to TO's x (xTo)
+  // method does not modify the original track
+  bool getTransportJacobian(const TrackD& track, double xTo, double alphaTo, gbl::Matrix5d& jac, gbl::Matrix5d& err);
+
+  // refit ITS track with inward/outward fit (opt. impose pv as additional constraint)
+  // after this we have the refitted track at the innermost update point
+  bool prepareITSTrack(int iTrk, const o2::its::TrackITS& itsTrack, Track& resTrack);
+
+  // prepare ITS measuremnt points
+  void prepareMeasurments(std::span<const itsmft::CompClusterExt> clusters, std::span<const unsigned char> pattIt);
+
+  // build track to vertex association
+  void buildT2V();
+
+  // apply some misalignment on inner ITS3 layers
+  // it can happen that a measurement is pushed outside of
+  // ITS3 acceptance so false is to discard track
+  bool applyMisalignment(Eigen::Vector2d& res, const FrameInfoExt& frame, const TrackD& wTrk, size_t iTrk);
+
+  OutputEnum mOutOpt;
+  std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
+  std::vector<dataformats::VertexBase> mPVs;
+  std::vector<int> mT2PV;
+  bool mIsITS3{true};
+  const o2::itsmft::TopologyDictionary* mITSDict{nullptr};
+  const o2::its3::TopologyDictionary* mIT3Dict{nullptr};
+  o2::globaltracking::RecoContainer* mRecoData = nullptr;
+  std::unique_ptr<steer::MCKinematicsReader> mcReader;
+  std::vector<FrameInfoExt> mITSTrackingInfo;
+  std::shared_ptr<DataRequest> mDataRequest;
+  std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
+  std::unique_ptr<AlignableVolume> mHierarchy;   // tree-hiearchy
+  AlignableVolume::SensorMapping mChip2Hiearchy; // global label mapping to leaves in the tree
+  bool mUseMC{false};
+  bool mWithPV{false};
+  GTrackID::mask_t mTracksSrc;
+  int mNThreads{1};
+  const AlignmentParams* mParams{nullptr};
+  std::array<o2::math_utils::Legendre2DPolynominal, 6> mDeformations; // one per sensorID (0-5)
+  std::array<Eigen::Matrix<double, 6, 1>, 6> mRigidBodyParams;        // (dx,dy,dz,rx,ry,rz) in LOC per sensorID
+};
+
+void AlignmentSpec::init(InitContext& ic)
+{
+  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
+  mNThreads = ic.options().get<int>("nthreads");
+  if (mOutOpt) {
+    LOG(info) << mOutOpt.pstring();
+    mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>("its3_debug_alg.root", "recreate");
+  }
+  if (mUseMC) {
+    mcReader = std::make_unique<steer::MCKinematicsReader>("collisioncontext.root");
+  }
+}
+
+void AlignmentSpec::run(ProcessingContext& pc)
+{
+  if (mOutOpt[OutputOpt::MilleRes]) {
+    updateTimeDependentParams(pc);
+    writeMillepedeResults(mHierarchy.get(), mParams->milleResFile, mParams->milleResOutJson, mParams->misAlgJson);
+  } else {
+    o2::globaltracking::RecoContainer recoData;
+    mRecoData = &recoData;
+    mRecoData->collectData(pc, *mDataRequest);
+    updateTimeDependentParams(pc);
+    process();
+  }
+  mRecoData = nullptr;
+}
+
+void AlignmentSpec::process()
+{
+  if (!mITSDict && !mIT3Dict) {
+    LOGP(fatal, "ITS data is not loaded");
+  }
+  auto prop = o2::base::PropagatorD::Instance();
+  const auto bz = prop->getNominalBz();
+  const auto itsTracks = mRecoData->getITSTracks();
+  const auto itsClRefs = mRecoData->getITSTracksClusterRefs();
+  const auto clusITS = mRecoData->getITSClusters();
+  const auto patterns = mRecoData->getITSClustersPatterns();
+  std::span<const o2::MCCompLabel> mcLbls;
+  if (mUseMC) {
+    mcLbls = mRecoData->getITSTracksMCLabels();
+  }
+  prepareMeasurments(clusITS, patterns);
+
+  if (mWithPV) {
+    buildT2V();
+  }
+
+  LOGP(info, "Starting fits with {} threads", mNThreads);
+
+  // Data
+  std::vector<std::vector<gbl::GblTrajectory>> gblTrajSlots(mNThreads);
+  std::vector<std::vector<Track>> resTrackSlots(mNThreads);
+
+  auto timeStart = std::chrono::high_resolution_clock::now();
+  int cFailedRefit{0}, cFailedProp{0}, cSelected{0}, cGBLFit{0}, cGBLFitFail{0}, cGBLChi2Rej{0}, cGBLConstruct{0};
+  double chi2Sum{0}, lostWeightSum{0};
+  int ndfSum{0};
+#ifdef WITH_OPENMP
+#pragma omp parallel num_threads(mNThreads) \
+  reduction(+ : cFailedRefit)               \
+  reduction(+ : cFailedProp)                \
+  reduction(+ : cSelected)                  \
+  reduction(+ : cGBLFit)                    \
+  reduction(+ : cGBLFitFail)                \
+  reduction(+ : cGBLChi2Rej)                \
+  reduction(+ : cGBLConstruct)              \
+  reduction(+ : chi2Sum)                    \
+  reduction(+ : lostWeightSum)              \
+  reduction(+ : ndfSum)
+#endif
+  {
+#ifdef WITH_OPENMP
+    const int tid = omp_get_thread_num();
+#else
+    const int tid = 0;
+#endif
+    auto& gblTrajSlot = gblTrajSlots[tid];
+    auto& resTrackSlot = resTrackSlots[tid];
+
+#ifdef WITH_OPENMP
+#pragma omp for schedule(dynamic)
+#endif
+    for (size_t iTrk = 0; iTrk < (int)itsTracks.size(); ++iTrk) {
+      const auto& trk = itsTracks[iTrk];
+      if (trk.getNClusters() < mParams->minITSCls ||
+          (trk.getChi2() / ((float)trk.getNClusters() * 2 - 5)) >= mParams->maxITSChi2Ndf ||
+          trk.getPt() < mParams->minPt ||
+          (mUseMC && (!mcLbls[iTrk].isValid() || !mcLbls[iTrk].isCorrect()))) {
+        continue;
+      }
+      ++cSelected;
+      Track& resTrack = resTrackSlot.emplace_back();
+      if (!prepareITSTrack((int)iTrk, trk, resTrack)) {
+        ++cFailedRefit;
+        resTrackSlot.pop_back();
+        continue;
+      }
+
+      o2::track::TrackParD* refLin = nullptr;
+      if (mParams->useStableRef) {
+        refLin = &resTrack.track;
+      }
+
+      // outward stepping from track IU
+      auto wTrk = resTrack.track;
+      const bool hasPV = resTrack.info[0].lr == -1;
+      std::vector<gbl::GblPoint> points;
+      bool failed = false;
+      const int np = (int)resTrack.points.size();
+      track::TrackLTIntegral lt;
+      lt.setTimeNotNeeded();
+      constexpr int perm[5] = {4, 2, 3, 0, 1}; // ALICE->GBL: Q/Pt,Snp,Tgl,Y,Z
+      for (int ip{0}; ip < np; ++ip) {
+        const auto& frame = resTrack.info[ip];
+        gbl::Matrix5d err = gbl::Matrix5d::Identity(), jacALICE = gbl::Matrix5d::Identity(), jacGBL;
+        float msErr = 0.f;
+        if (ip) {
+          // numerically calculates the transport jacobian from prev. point to this point
+          // then we actually do the step to the point and accumulate the material
+          if (!getTransportJacobian(wTrk, frame.x, frame.alpha, jacALICE, err) ||
+              !prop->propagateToAlphaX(wTrk, refLin, frame.alpha, frame.x, false, mParams->maxSnp, mParams->maxStep, 1, mParams->corrType, &lt)) {
+            ++cFailedProp;
+            failed = true;
+            break;
+          }
+          msErr = its::math_utils::MSangle(trk.getPID().getMass(), trk.getP(), lt.getX2X0());
+          // after computing jac, reorder to GBL convention
+          for (int i = 0; i < 5; i++) {
+            for (int j = 0; j < 5; j++) {
+              jacGBL(i, j) = jacALICE(perm[i], perm[j]);
+            }
+          }
+        }
+
+        // wTrk is now in the measurment frame
+        gbl::GblPoint point(jacGBL);
+        // measurement
+        Eigen::Vector2d res, prec;
+        res << frame.positionTrackingFrame[0] - wTrk.getY(), frame.positionTrackingFrame[1] - wTrk.getZ();
+
+        // here we can apply some misalignment on the measurment
+        if (!applyMisalignment(res, frame, wTrk, iTrk)) {
+          failed = true;
+          break;
+        }
+
+        prec << 1. / resTrack.points[ip].sig2y, 1. / resTrack.points[ip].sig2z;
+        // the projection matrix is in the tracking frame the idendity so no need to diagonalize it
+        point.addMeasurement(res, prec);
+        if (msErr > mParams->minMS && ip < np - 1) {
+          Eigen::Vector2d scat(0., 0.), scatPrec = Eigen::Vector2d::Constant(1. / (msErr * msErr));
+          point.addScatterer(scat, scatPrec);
+          lt.clearFast(); // clear if accounted
+        }
+
+        if (frame.lr >= 0) {
+          GlobalLabel lbl(0, frame.sens, true);
+          if (mChip2Hiearchy.find(lbl) == mChip2Hiearchy.end()) {
+            LOGP(fatal, "Cannot find global label: {}", lbl.asString());
+          }
+
+          // derivatives for all sensitive volumes and their parents
+          // this is the derivative in TRK but we want to align in LOC
+          // so dr/da_(LOC) = dr/da_(TRK) * da_(TRK)/da_(LOC)
+          const auto* tileVol = mChip2Hiearchy.at(lbl);
+          Matrix36 der = getRigidBodyDerivatives(wTrk);
+
+          // count rigid body columns: only volumes with real DOFs (not DOFPseudo)
+          int nColRB{0};
+          for (const auto* v = tileVol; v && !v->isRoot(); v = v->getParent()) {
+            if (v->getRigidBody()) {
+              nColRB += v->getRigidBody()->nDOFs();
+            }
+          }
+
+          // count calibration columns
+          const auto* sensorVol = tileVol->getParent();
+          const auto* calibSet = sensorVol ? sensorVol->getCalib() : nullptr;
+          const int nCalib = calibSet ? calibSet->nDOFs() : 0;
+          const int nCol = nColRB + nCalib;
+
+          std::vector<int> gLabels;
+          gLabels.reserve(nCol);
+          Eigen::MatrixXd gDer(3, nCol);
+          gDer.setZero();
+          Eigen::Index curCol{0};
+
+          // 1) tile: TRK -> LOC via precomputed T2L and J_L2T
+          const double posTrk[3] = {frame.x, 0., 0.};
+          double posLoc[3];
+          tileVol->getT2L().LocalToMaster(posTrk, posLoc);
+          Matrix66 jacL2T;
+          tileVol->computeJacobianL2T(posLoc, jacL2T);
+          der *= jacL2T;
+          if (tileVol->getRigidBody()) {
+            const int nd = tileVol->getRigidBody()->nDOFs();
+            for (int iDOF = 0; iDOF < nd; ++iDOF) {
+              gLabels.push_back(tileVol->getLabel().rawGBL(iDOF));
+            }
+            gDer.middleCols(curCol, nd) = der;
+            curCol += nd;
+          }
+
+          // 2) chain through parents: child's J_L2P
+          for (const auto* child = tileVol; child->getParent() && !child->getParent()->isRoot(); child = child->getParent()) {
+            der *= child->getJL2P();
+            const auto* parent = child->getParent();
+            if (parent->getRigidBody()) {
+              const int nd = parent->getRigidBody()->nDOFs();
+              for (int iDOF = 0; iDOF < nd; ++iDOF) {
+                gLabels.push_back(parent->getLabel().rawGBL(iDOF));
+              }
+              gDer.middleCols(curCol, nd) = der;
+              curCol += nd;
+            }
+          }
+
+          // 3) calibration derivatives (e.g. Legendre for ITS3 sensors, apply directly on the whole sensor, not on inidividual tiles)
+          if (calibSet && calibSet->type() == DOFSet::Type::Legendre) {
+            const auto* legSet = static_cast<const LegendreDOFSet*>(calibSet);
+            const int N = legSet->order();
+            const int sensorID = constants::detID::getSensorID(frame.sens);
+            const int layerID = constants::detID::getDetID2Layer(frame.sens);
+
+            const double r = frame.x;
+            const double gX = r * std::cos(frame.alpha);
+            const double gY = r * std::sin(frame.alpha);
+            const double gZ = frame.positionTrackingFrame[1];
+            auto [u, v] = computeUV(gX, gY, gZ, sensorID, constants::radii[layerID]);
+
+            const double snp = wTrk.getSnp();
+            const double tgl = wTrk.getTgl();
+            const double csci = 1. / std::sqrt(1. - (snp * snp));
+            const double dydx = snp * csci;
+            const double dzdx = tgl * csci;
+
+            auto pu = legendrePols(N, u);
+            auto pv = legendrePols(N, v);
+
+            int legIdx = 0;
+            const int legColStart = nColRB;
+            for (int i = 0; i <= N; ++i) {
+              for (int j = 0; j <= i; ++j) {
+                const double basis = pu[j] * pv[i - j];
+                gLabels.push_back(sensorVol->getLabel().asCalib().rawGBL(legIdx));
+                gDer(0, legColStart + legIdx) = dydx * basis;
+                gDer(1, legColStart + legIdx) = dzdx * basis;
+                ++legIdx;
+              }
+            }
+          }
+          point.addGlobals(gLabels, gDer);
+        }
+
+        if (mOutOpt[OutputOpt::VerboseGBL]) {
+          static Eigen::IOFormat fmt(4, 0, ", ", "\n", "[", "]");
+          LOGP(info, "WORKING-POINT {}", ip);
+          LOGP(info, "Track: {}", wTrk.asString());
+          LOGP(info, "FrameInfo: {}", frame.asString());
+          std::cout << "jacALICE:\n"
+                    << jacALICE.format(fmt) << '\n';
+          std::cout << "jacGBL:\n"
+                    << jacGBL.format(fmt) << '\n';
+          LOGP(info, "Point {}: GBL res=({}, {}), KF stored res=({}, {})",
+               ip, res[0], res[1], resTrack.points[ip].dy, resTrack.points[ip].dz);
+          LOGP(info, "residual: dy={} dz={}", res[0], res[1]);
+          LOGP(info, "precision: precY={} precZ={}", prec[0], prec[1]);
+          point.printPoint(5);
+        }
+        points.push_back(point);
+      }
+      if (!failed) {
+        gbl::GblTrajectory traj(points, std::abs(bz) > 0.01);
+        if (traj.isValid()) {
+          double chi2 = NAN, lostWeight = NAN;
+          int ndf = 0;
+          if (auto ierr = traj.fit(chi2, ndf, lostWeight); !ierr) {
+            if (mOutOpt[OutputOpt::VerboseGBL]) {
+              LOGP(info, "GBL FIT chi2 {} ndf {}", chi2, ndf);
+              traj.printTrajectory(5);
+            }
+            if (chi2 / ndf > mParams->maxChi2Ndf && cGBLChi2Rej++ < 10) {
+              LOGP(error, "GBL fit exceeded red chi2 {}", chi2 / ndf);
+              if (std::abs(resTrack.kfFit.chi2Ndf - 1) < 0.02) {
+                LOGP(error, "\tGBL is far away from good KF fit!!!!");
+                continue;
+              }
+            } else {
+              ++cGBLFit;
+              chi2Sum += chi2;
+              lostWeightSum += lostWeight;
+              ndfSum += ndf;
+              if (mOutOpt[OutputOpt::MilleData]) {
+                gblTrajSlot.push_back(traj);
+              }
+              FitInfo fit;
+              fit.ndf = ndf;
+              fit.chi2 = (float)chi2;
+              fit.chi2Ndf = (float)chi2 / (float)ndf;
+              resTrack.gblFit = fit;
+            }
+          } else {
+            ++cGBLFitFail;
+          }
+        } else {
+          ++cGBLConstruct;
+        }
+      }
+    }
+  }
+  auto timeEnd = std::chrono::high_resolution_clock::now();
+  auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(timeEnd - timeStart);
+  LOGP(info, "Fitted {} tracks out of {} (selected {}) in {} sec", cGBLFit, itsTracks.size(), cSelected, duration.count() / 1e3);
+  LOGP(info, "\tRefit failed for {} tracks; Failed prop for {} tracks", cFailedRefit, cFailedProp);
+  LOGP(info, "\tGBL SUMMARY:");
+  LOGP(info, "\t\tGBL construction failed {}", cGBLConstruct);
+  LOGP(info, "\t\tGBL fit failed {}", cGBLFitFail);
+  LOGP(info, "\t\tGBL chi2Ndf rejected {}", cGBLChi2Rej);
+  if (!ndfSum) {
+    LOGP(info, "\t\tGBL Chi2/Ndf = NDF IS 0");
+  } else {
+    LOGP(info, "\t\tGBL Chi2/Ndf = {}", chi2Sum / ndfSum);
+  }
+  LOGP(info, "\t\tGBL LostWeight = {}", lostWeightSum);
+  LOGP(info, "Streaming results to output");
+  if (mOutOpt[OutputOpt::MilleData]) {
+    gbl::MilleBinary mille(mParams->milleBinFile, true);
+    for (auto& slot : gblTrajSlots) {
+      for (auto& traj : slot) {
+        traj.milleOut(mille);
+      }
+    }
+  }
+  if (mOutOpt[OutputOpt::Debug]) {
+    for (auto& slot : resTrackSlots) {
+      for (auto& res : slot) {
+        (*mDBGOut) << "res"
+                   << "trk=" << res
+                   << "\n";
+      }
+    }
+  }
+}
+
+void AlignmentSpec::updateTimeDependentParams(ProcessingContext& pc)
+{
+  o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+  if (static bool initOnce{false}; !initOnce) {
+    initOnce = true;
+    auto geom = o2::its::GeometryTGeo::Instance();
+    o2::its::GeometryTGeo::Instance()->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2G));
+    mParams = &AlignmentParams::Instance();
+    mParams->printKeyValues(true, true);
+
+    buildHierarchy();
+
+    if (mParams->doMisalignmentLeg || mParams->doMisalignmentRB) {
+      TMatrixD null(1, 1);
+      null(0, 0) = 0;
+      for (int i = 0; i < 6; ++i) {
+        mDeformations[i] = o2::math_utils::Legendre2DPolynominal(null);
+        mRigidBodyParams[i].setZero();
+      }
+      if (!mParams->misAlgJson.empty()) {
+        using json = nlohmann::json;
+        std::ifstream f(mParams->misAlgJson);
+        auto data = json::parse(f);
+        for (const auto& item : data) {
+          int id = item["id"].get<int>();
+          if (mParams->doMisalignmentLeg && item.contains("matrix")) {
+            auto v = item["matrix"].get<std::vector<std::vector<double>>>();
+            TMatrixD m(v.size(), v[v.size() - 1].size());
+            for (size_t r{0}; r < v.size(); ++r) {
+              for (size_t c{0}; c < v[r].size(); ++c) {
+                m(r, c) = v[r][c];
+              }
+            }
+            mDeformations[id] = o2::math_utils::Legendre2DPolynominal(m);
+          }
+          if (mParams->doMisalignmentRB && item.contains("rigidBody")) {
+            auto rb = item["rigidBody"].get<std::vector<double>>();
+            for (int k = 0; k < 6 && k < (int)rb.size(); ++k) {
+              mRigidBodyParams[id](k) = rb[k];
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+void AlignmentSpec::buildHierarchy()
+{
+  if (mIsITS3) {
+    mHierarchy = buildHierarchyIT3(mChip2Hiearchy);
+  } else {
+    mHierarchy = buildHierarchyITS(mChip2Hiearchy);
+  }
+
+  if (!mParams->dofConfigJson.empty()) {
+    applyDOFConfig(mHierarchy.get(), mParams->dofConfigJson);
+  }
+
+  mHierarchy->finalise();
+  if (mOutOpt[OutputOpt::MilleSteer]) {
+    std::ofstream tree(mParams->milleTreeFile);
+    mHierarchy->writeTree(tree);
+    std::ofstream cons(mParams->milleConFile);
+    mHierarchy->writeRigidBodyConstraints(cons);
+    std::ofstream par(mParams->milleParamFile);
+    mHierarchy->writeParameters(par);
+  }
+}
+
+bool AlignmentSpec::getTransportJacobian(const TrackD& track, double xTo, double alphaTo, gbl::Matrix5d& jac, gbl::Matrix5d& err)
+{
+  auto prop = o2::base::PropagatorD::Instance();
+  const auto bz = prop->getNominalBz();
+  const auto minStep = std::sqrt(std::numeric_limits<double>::epsilon());
+  const gbl::Vector5d x0(track.getParams());
+  auto trackC = track;
+  o2::track::TrackParD* refLin{nullptr};
+  if (mParams->useStableRef) {
+    refLin = &trackC;
+  }
+
+  auto propagate = [&](gbl::Vector5d& p) -> bool {
+    TrackD tmp(track);
+    for (int i{0}; i < track::kNParams; ++i) {
+      tmp.setParam(p[i], i);
+    }
+    if (!prop->propagateToAlphaX(tmp, refLin, alphaTo, xTo, false, mParams->maxSnp, mParams->maxStep, 1, mParams->corrType)) {
+      return false;
+    }
+    p = gbl::Vector5d(tmp.getParams());
+    return true;
+  };
+
+  for (int iPar{0}; iPar < track::kNParams; ++iPar) {
+    // step size
+    double h = std::min(mParams->ridderMaxIniStep[iPar], std::max(minStep, std::abs(track.getParam(iPar)) * mParams->ridderRelIniStep[iPar]) * std::pow(mParams->ridderShrinkFac, mParams->ridderMaxExtrap / 2));
+    ;
+    // romberg tableu
+    Eigen::MatrixXd cur(track::kNParams, mParams->ridderMaxExtrap);
+    Eigen::MatrixXd pre(track::kNParams, mParams->ridderMaxExtrap);
+    double normErr = std::numeric_limits<double>::max();
+    gbl::Vector5d bestDeriv = gbl::Vector5d::Constant(std::numeric_limits<double>::max());
+    for (int iExt{0}; iExt < mParams->ridderMaxExtrap; ++iExt) {
+      gbl::Vector5d xPlus = x0, xMinus = x0;
+      xPlus(iPar) += h;
+      xMinus(iPar) -= h;
+      if (!propagate(xPlus) || !propagate(xMinus)) {
+        return false;
+      }
+      cur.col(0) = (xPlus - xMinus) / (2.0 * h);
+      if (!iExt) {
+        bestDeriv = cur.col(0);
+      }
+      // shrink step in next iteration
+      h /= mParams->ridderShrinkFac;
+      // richardson extrapolation
+      double fac = mParams->ridderShrinkFac * mParams->ridderShrinkFac;
+      for (int k{1}; k <= iExt; ++k) {
+        cur.col(k) = (fac * cur.col(k - 1) - pre.col(k - 1)) / (fac - 1.0);
+        fac *= mParams->ridderShrinkFac * mParams->ridderShrinkFac;
+        double e = std::max((cur.col(k) - cur.col(k - 1)).norm(), (cur.col(k) - pre.col(k - 1)).norm());
+        if (e <= normErr) {
+          normErr = e;
+          bestDeriv = cur.col(k);
+          if (normErr < mParams->ridderEps) {
+            break;
+          }
+        }
+      }
+      if (normErr < mParams->ridderEps) {
+        break;
+      }
+      // check stability
+      if (iExt > 0) {
+        double tableauErr = (cur.col(iExt) - pre.col(iExt - 1)).norm();
+        if (tableauErr >= 2.0 * normErr) {
+          break;
+        }
+      }
+      std::swap(cur, pre);
+    }
+    if (bestDeriv.isApproxToConstant(std::numeric_limits<double>::max())) {
+      return false;
+    }
+    jac.col(iPar) = bestDeriv;
+    err.col(iPar) = gbl::Vector5d::Constant(normErr);
+  }
+
+  if (jac.isIdentity(1e-8)) {
+    LOGP(error, "Near jacobian idendity for taking track from {} to {}", track.getX(), xTo);
+    return false;
+  }
+
+  return true;
+}
+
+bool AlignmentSpec::prepareITSTrack(int iTrk, const o2::its::TrackITS& itsTrack, align::Track& resTrack)
+{
+  const auto itsClRefs = mRecoData->getITSTracksClusterRefs();
+  auto trFit = convertTrack<double>(itsTrack.getParamOut()); // take outer track fit as start of refit
+  auto prop = o2::base::PropagatorD::Instance();
+  auto geom = o2::its::GeometryTGeo::Instance();
+  const auto bz = prop->getNominalBz();
+  std::array<const FrameInfoExt*, 8> frameArr{};
+  o2::track::TrackParD trkOut, *refLin = nullptr;
+  if (mParams->useStableRef) {
+    refLin = &(trkOut = trFit);
+  }
+
+  auto accountCluster = [&](int i, TrackD& tr, float& chi2, Measurement& meas, o2::track::TrackParD* refLin) {
+    if (frameArr[i]) { // update with cluster
+      if (!prop->propagateToAlphaX(tr, refLin, frameArr[i]->alpha, frameArr[i]->x, false, mParams->maxSnp, mParams->maxStep, 1, mParams->corrType)) {
+        return 2;
+      }
+      meas.dy = frameArr[i]->positionTrackingFrame[0] - tr.getY();
+      meas.dz = frameArr[i]->positionTrackingFrame[1] - tr.getZ();
+      meas.sig2y = frameArr[i]->covarianceTrackingFrame[0];
+      meas.sig2z = frameArr[i]->covarianceTrackingFrame[2];
+      meas.z = tr.getZ();
+      meas.phi = tr.getPhi();
+      o2::math_utils::bringTo02Pid(meas.phi);
+      chi2 += (float)tr.getPredictedChi2Quiet(frameArr[i]->positionTrackingFrame, frameArr[i]->covarianceTrackingFrame);
+      if (!tr.update(frameArr[i]->positionTrackingFrame, frameArr[i]->covarianceTrackingFrame)) {
+        return 2;
+      }
+      if (refLin) { // displace the reference to the last updated cluster
+        refLin->setY(frameArr[i]->positionTrackingFrame[0]);
+        refLin->setZ(frameArr[i]->positionTrackingFrame[1]);
+      }
+      return 0;
+    }
+    return 1;
+  };
+
+  FrameInfoExt pvInfo;
+  if (mWithPV) { // add PV as constraint
+    const int iPV = mT2PV[iTrk];
+    if (iPV < 0) {
+      return false;
+    }
+    const auto& pv = mPVs[iPV];
+    auto tmp = convertTrack<double>(itsTrack.getParamIn());
+    if (!prop->propagateToDCA(pv, tmp, bz)) {
+      return false;
+    }
+    pvInfo.alpha = (float)tmp.getAlpha();
+    double ca{0}, sa{0};
+    o2::math_utils::bringToPMPid(pvInfo.alpha);
+    o2::math_utils::sincosd(pvInfo.alpha, sa, ca);
+    pvInfo.x = tmp.getX();
+    pvInfo.positionTrackingFrame[0] = -pv.getX() * sa + pv.getY() * ca;
+    pvInfo.positionTrackingFrame[1] = pv.getZ();
+    pvInfo.covarianceTrackingFrame[0] = 0.5 * (pv.getSigmaX2() + pv.getSigmaY2());
+    pvInfo.covarianceTrackingFrame[2] = pv.getSigmaY2();
+    pvInfo.sens = -1;
+    pvInfo.lr = -1;
+    frameArr[0] = &pvInfo;
+  }
+
+  // collect all track clusters to array, placing them to layer+1 slot
+  int nCl = itsTrack.getNClusters();
+  for (int i = 0; i < nCl; i++) { // clusters are ordered from the outermost to the innermost
+    const auto& curInfo = mITSTrackingInfo[itsClRefs[itsTrack.getClusterEntry(i)]];
+    frameArr[1 + curInfo.lr] = &curInfo;
+  }
+
+  // start refit
+  resTrack.points.clear();
+  resTrack.info.clear();
+  trFit.resetCovariance();
+  trFit.setCov(trFit.getQ2Pt() * trFit.getQ2Pt() * trFit.getCov()[14], 14);
+  float chi2{0};
+  for (int i{7}; i >= 0; --i) {
+    Measurement point;
+    int res = accountCluster(i, trFit, chi2, point, refLin);
+    if (res == 2) {
+      return false;
+    } else if (res == 0) {
+      resTrack.points.push_back(point);
+      resTrack.info.push_back(*frameArr[i]);
+      resTrack.track = trFit; // put track to whatever the IU is
+    }
+  }
+  // reverse inserted points so they are in the same order as the track
+  std::reverse(resTrack.info.begin(), resTrack.info.end());
+  std::reverse(resTrack.points.begin(), resTrack.points.end());
+  resTrack.kfFit.chi2 = chi2;
+  resTrack.kfFit.ndf = (int)resTrack.info.size() * 2 - 5;
+  resTrack.kfFit.chi2Ndf = chi2 / (float)resTrack.kfFit.ndf;
+
+  return true;
+}
+
+void AlignmentSpec::prepareMeasurments(std::span<const itsmft::CompClusterExt> clusters, std::span<const unsigned char> patterns)
+{
+  LOGP(info, "Preparing {} measurments", clusters.size());
+  auto geom = its::GeometryTGeo::Instance();
+  geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
+  mITSTrackingInfo.clear();
+  mITSTrackingInfo.reserve(clusters.size());
+  auto pattIt = patterns.begin();
+  for (const auto& cls : clusters) {
+    const auto sens = cls.getSensorID();
+    const auto lay = geom->getLayer(sens);
+    double sigmaY2{0}, sigmaZ2{0};
+    math_utils::Point3D<float> locXYZ;
+    if (mIsITS3) {
+      locXYZ = o2::its3::ioutils::extractClusterData(cls, pattIt, mIT3Dict, sigmaY2, sigmaZ2);
+    } else {
+      locXYZ = o2::its::ioutils::extractClusterData(cls, pattIt, mITSDict, sigmaY2, sigmaZ2);
+    }
+    sigmaY2 += mParams->extraClsErrY[lay] * mParams->extraClsErrY[lay];
+    sigmaZ2 += mParams->extraClsErrZ[lay] * mParams->extraClsErrZ[lay];
+    // Transformation to the local --> global
+    const auto gloXYZ = geom->getMatrixL2G(sens) * locXYZ;
+    // Inverse transformation to the local --> tracking
+    auto trkXYZf = geom->getMatrixT2L(sens) ^ locXYZ;
+    o2::math_utils::Point3D<double> trkXYZ;
+    trkXYZ.SetCoordinates(trkXYZf.X(), trkXYZf.Y(), trkXYZf.Z());
+    // Tracking alpha angle
+    // We want that each cluster rotates its tracking frame to the clusters phi
+    // that way the track linearization around the measurement is less biases to the arc
+    // this means automatically that the measurement on the arc is at 0 for the curved layers
+    double alpha = geom->getSensorRefAlpha(sens);
+    double x = trkXYZ.x();
+    if (mIsITS3 && constants::detID::isDetITS3(sens)) {
+      trkXYZ.SetY(0.f);
+      // alpha&x always have to be defined wrt to the global Z axis!
+      x = std::hypot(gloXYZ.x(), gloXYZ.y());
+      trkXYZ.SetX(x);
+      alpha = std::atan2(gloXYZ.y(), gloXYZ.x());
+      auto chip = constants::detID::getSensorID(sens);
+      sigmaY2 += mParams->extraClsErrY[chip] * mParams->extraClsErrY[chip];
+      sigmaZ2 += mParams->extraClsErrZ[chip] * mParams->extraClsErrZ[chip];
+    }
+    math_utils::bringToPMPid(alpha);
+    mITSTrackingInfo.emplace_back(sens, lay, x, alpha,
+                                  std::array<double, 2>{trkXYZ.y(), trkXYZ.z()},
+                                  std::array<double, 3>{sigmaY2, 0., sigmaZ2});
+  }
+}
+
+void AlignmentSpec::buildT2V()
+{
+  const auto& itsTracks = mRecoData->getITSTracks();
+  mT2PV.clear();
+  mT2PV.resize(itsTracks.size(), -1);
+  if (mUseMC) {
+    mPVs.reserve(mcReader->getNEvents(0));
+    for (int iEve{0}; iEve < mcReader->getNEvents(0); ++iEve) {
+      const auto& eve = mcReader->getMCEventHeader(0, iEve);
+      dataformats::VertexBase vtx;
+      constexpr float err{22e-4f};
+      vtx.setX((float)eve.GetX());
+      vtx.setY((float)eve.GetY());
+      vtx.setZ((float)eve.GetZ());
+      vtx.setSigmaX(err);
+      vtx.setSigmaY(err);
+      vtx.setSigmaZ(err);
+      mPVs.push_back(vtx);
+    }
+    const auto& mcLbls = mRecoData->getITSTracksMCLabels();
+    for (size_t iTrk{0}; iTrk < mcLbls.size(); ++iTrk) {
+      const auto& lbl = mcLbls[iTrk];
+      if (!lbl.isValid() || !lbl.isCorrect()) {
+        continue;
+      }
+      const auto& mcTrk = mcReader->getTrack(lbl);
+      if (mcTrk->isPrimary()) {
+        mT2PV[iTrk] = lbl.getEventID();
+      }
+    }
+  } else {
+    LOGP(fatal, "Data PV to track TODO");
+  }
+}
+
+bool AlignmentSpec::applyMisalignment(Eigen::Vector2d& res, const FrameInfoExt& frame, const TrackD& wTrk, size_t iTrk)
+{
+  if (!constants::detID::isDetITS3(frame.sens)) {
+    return true;
+  }
+
+  const int sensorID = constants::detID::getSensorID(frame.sens);
+  const int layerID = constants::detID::getDetID2Layer(frame.sens);
+
+  // --- Legendre deformation (non-rigid-body) ---
+  if (mParams->doMisalignmentLeg && mIsITS3 && mUseMC) {
+    const auto prop = o2::base::PropagatorD::Instance();
+
+    const auto lbl = mRecoData->getITSTracksMCLabels()[iTrk];
+    const auto mcTrk = mcReader->getTrack(lbl);
+    if (!mcTrk) {
+      return false;
+    }
+    std::array<double, 3> xyz{mcTrk->GetStartVertexCoordinatesX(), mcTrk->GetStartVertexCoordinatesY(), mcTrk->GetStartVertexCoordinatesZ()};
+    std::array<double, 3> pxyz{mcTrk->GetStartVertexMomentumX(), mcTrk->GetStartVertexMomentumY(), mcTrk->GetStartVertexMomentumZ()};
+    TParticlePDG* pPDG = TDatabasePDG::Instance()->GetParticle(mcTrk->GetPdgCode());
+    if (!pPDG) {
+      return false;
+    }
+    o2::track::TrackParD mcPar(xyz, pxyz, TMath::Nint(pPDG->Charge() / 3), false);
+
+    const double r = frame.x;
+    const double gloX = r * std::cos(frame.alpha);
+    const double gloY = r * std::sin(frame.alpha);
+    const double gloZ = frame.positionTrackingFrame[1];
+    auto [u, v] = computeUV(gloX, gloY, gloZ, sensorID, constants::radii[layerID]);
+    const double h = mDeformations[sensorID](u, v);
+
+    auto mcAtCl = mcPar;
+    if (!mcAtCl.rotate(frame.alpha) || !prop->PropagateToXBxByBz(mcAtCl, frame.x)) {
+      return false;
+    }
+
+    const double snp = mcAtCl.getSnp();
+    const double tgl = mcAtCl.getTgl();
+    const double csci = 1. / std::sqrt(1. - (snp * snp));
+    const double dydx = snp * csci;
+    const double dzdx = tgl * csci;
+    const double dy = dydx * h;
+    const double dz = dzdx * h;
+
+    const double newGloY = (r * std::sin(frame.alpha)) + (dy * std::cos(frame.alpha));
+    const double newGloX = (r * std::cos(frame.alpha)) - (dy * std::sin(frame.alpha));
+    const double newGloZ = gloZ + dz;
+    auto [uNew, vNew] = computeUV(newGloX, newGloY, newGloZ, sensorID, constants::radii[layerID]);
+    if (std::abs(uNew) > 1. || std::abs(vNew) > 1.) {
+      return false;
+    }
+
+    res[0] += dy;
+    res[1] += dz;
+  }
+
+  // --- Rigid body misalignment ---
+  // Must use the same derivative chain as GBL:
+  //   dres/da_parent = dres/da_TRK * J_L2T_tile * J_L2P_tile
+  // The tile is a pseudo-volume; Millepede fits at the halfBarrel (parent) level.
+  if (mParams->doMisalignmentRB) {
+    GlobalLabel lbl(0, frame.sens, true);
+    if (mChip2Hiearchy.find(lbl) == mChip2Hiearchy.end()) {
+      return true; // sensor not in hierarchy, skip
+    }
+    const auto* tileVol = mChip2Hiearchy.at(lbl);
+
+    // derivative in TRK frame (3x6: rows = dy, dz, dsnp)
+    Matrix36 der = getRigidBodyDerivatives(wTrk);
+
+    // TRK -> tile LOC
+    const double posTrk[3] = {frame.x, 0., 0.};
+    double posLoc[3];
+    tileVol->getT2L().LocalToMaster(posTrk, posLoc);
+    Matrix66 jacL2T;
+    tileVol->computeJacobianL2T(posLoc, jacL2T);
+    der *= jacL2T;
+
+    // tile LOC -> halfBarrel LOC (same chain as GBL hierarchy walk)
+    der *= tileVol->getJL2P();
+
+    // apply: delta_res = der * delta_a_halfBarrel
+    Eigen::Vector3d shift = der * mRigidBodyParams[sensorID];
+    res[0] += shift[0]; // dy
+    res[1] += shift[1]; // dz
+  }
+
+  return true;
+}
+
+void AlignmentSpec::endOfStream(EndOfStreamContext& /*ec*/)
+{
+  mDBGOut->Close();
+  mDBGOut.reset();
+}
+
+void AlignmentSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+{
+  if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
+    return;
+  }
+  if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
+    LOG(info) << "its cluster dictionary updated";
+    mITSDict = (const o2::itsmft::TopologyDictionary*)obj;
+    return;
+  }
+  if (matcher == ConcreteDataMatcher("IT3", "CLUSDICT", 0)) {
+    LOG(info) << "it3 cluster dictionary updated";
+    mIT3Dict = (const o2::its3::TopologyDictionary*)obj;
+    return;
+  }
+}
+
+DataProcessorSpec getAlignmentSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC, bool withPV, bool withITS, OutputEnum out)
+{
+  auto dataRequest = std::make_shared<DataRequest>();
+  std::shared_ptr<o2::base::GRPGeomRequest> ggRequest{nullptr};
+  if (!out[OutputOpt::MilleRes]) {
+    dataRequest->requestTracks(srcTracks, useMC);
+    if (!withITS) {
+      dataRequest->requestIT3Clusters(useMC);
+    } else {
+      dataRequest->requestClusters(srcClusters, useMC);
+    }
+    if (withPV && !useMC) {
+      dataRequest->requestPrimaryVertices(useMC);
+    }
+    ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
+                                                           false,                             // GRPECS=true
+                                                           true,                              // GRPLHCIF
+                                                           true,                              // GRPMagField
+                                                           true,                              // askMatLUT
+                                                           o2::base::GRPGeomRequest::Aligned, // geometry
+                                                           dataRequest->inputs,               // inputs
+                                                           true,                              // askOnce
+                                                           true);                             // propagatorD
+  } else {
+    dataRequest->inputs.emplace_back("dummy", "GLO", "DUMMY_OUT", 0);
+    ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
+                                                           false,                             // GRPECS=true
+                                                           false,                             // GRPLHCIF
+                                                           false,                             // GRPMagField
+                                                           false,                             // askMatLUT
+                                                           o2::base::GRPGeomRequest::Aligned, // geometry
+                                                           dataRequest->inputs);
+  }
+
+  Options opts{
+    {"nthreads", VariantType::Int, 1, {"number of threads"}},
+  };
+
+  return DataProcessorSpec{
+    .name = "its3-alignment",
+    .inputs = dataRequest->inputs,
+    .outputs = {},
+    .algorithm = AlgorithmSpec{adaptFromTask<AlignmentSpec>(dataRequest, ggRequest, srcTracks, useMC, withPV, withITS, out)},
+    .options = opts};
+}
+} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentTypes.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentTypes.cxx
new file mode 100644
index 0000000000000..5ad06a6c78381
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentTypes.cxx
@@ -0,0 +1,24 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <string>
+#include <format>
+
+#include "ITS3Align/AlignmentTypes.h"
+ClassImp(o2::its3::align::Point);
+ClassImp(o2::its3::align::FrameInfoExt);
+ClassImp(o2::its3::align::FitInfo);
+ClassImp(o2::its3::align::Track);
+
+std::string o2::its3::align::FrameInfoExt::asString() const
+{
+  return std::format("Sensor={} Layer={} X={} Alpha={}\n\tMEAS: y={} z={}", sens, lr, x, alpha, positionTrackingFrame[0], positionTrackingFrame[1]);
+}
diff --git a/Detectors/Upgrades/ITS3/alignment/src/Deformations.cxx b/Detectors/Upgrades/ITS3/alignment/src/Deformations.cxx
deleted file mode 100644
index 38a959cf7030f..0000000000000
--- a/Detectors/Upgrades/ITS3/alignment/src/Deformations.cxx
+++ /dev/null
@@ -1,41 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "ITS3Align/Deformations.h"
-#include "ITS3Align/MisalignmentParameters.h"
-
-#include "Framework/Logger.h"
-
-#include <filesystem>
-
-namespace fs = std::filesystem;
-
-namespace o2::its3::align
-{
-
-void Deformations::init(const fs::path& path)
-{
-  if (!fs::exists(path)) {
-    LOGP(fatal, "File {} does not exists!", path.c_str());
-  }
-
-  auto params = MisalignmentParameters::load(path.string());
-  LOGP(info, "Loaded Parameters");
-
-  // Set the legendre pols
-  for (int iSensor{0}; iSensor < 6; ++iSensor) {
-    mLegX[iSensor] = o2::math_utils::Legendre2DPolynominal(params->getLegendreCoeffX(iSensor));
-    mLegY[iSensor] = o2::math_utils::Legendre2DPolynominal(params->getLegendreCoeffY(iSensor));
-    mLegZ[iSensor] = o2::math_utils::Legendre2DPolynominal(params->getLegendreCoeffZ(iSensor));
-  }
-}
-
-} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/alignment/src/ITS3AlignLinkDef.h b/Detectors/Upgrades/ITS3/alignment/src/ITS3AlignLinkDef.h
index ef526284f3a58..e6e6a8c2cc73c 100644
--- a/Detectors/Upgrades/ITS3/alignment/src/ITS3AlignLinkDef.h
+++ b/Detectors/Upgrades/ITS3/alignment/src/ITS3AlignLinkDef.h
@@ -15,6 +15,12 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
-#pragma link C++ class o2::its3::align::MisalignmentParameters + ;
+#pragma link C++ struct o2::its3::align::AlignmentParams + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its3::align::AlignmentParams> + ;
+
+#pragma link C++ struct o2::its3::align::Measurement + ;
+#pragma link C++ struct o2::its3::align::FrameInfoExt + ;
+#pragma link C++ struct o2::its3::align::FitInfo + ;
+#pragma link C++ struct o2::its3::align::Track + ;
 
 #endif
diff --git a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentHits.cxx b/Detectors/Upgrades/ITS3/alignment/src/MisalignmentHits.cxx
deleted file mode 100644
index 66ab4c8090b54..0000000000000
--- a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentHits.cxx
+++ /dev/null
@@ -1,368 +0,0 @@
-// Copyright 2020-2022 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "ITS3Align/MisalignmentHits.h"
-#include "ITS3Base/ITS3Params.h"
-#include "SimConfig/DigiParams.h"
-#include "DetectorsBase/Propagator.h"
-#include "Framework/Logger.h"
-
-#include "Math/Factory.h"
-#include "Math/UnaryOperators.h"
-#include "TGeoNode.h"
-#include "TGeoBBox.h"
-#include "TString.h"
-
-#include <memory>
-#include <string>
-#include <cstring>
-#include <algorithm>
-
-namespace o2::its3::align
-{
-
-void MisAlignmentHits::init()
-{
-  if (o2::its3::ITS3Params::Instance().misalignmentHitsUseProp) {
-    mMethod = PropMethod::Propagator;
-  } else {
-    mMethod = PropMethod::Line;
-  }
-
-  mGeo = o2::its::GeometryTGeo::Instance();
-
-  mMinimizer.reset(ROOT::Math::Factory::CreateMinimizer("Minuit2", "Migrad"));
-  if (mMinimizer == nullptr) {
-    LOGP(fatal, "Cannot create minimizer");
-  }
-  mMinimizer->SetMaxFunctionCalls(1'000'000'000);
-  mMinimizer->SetStrategy(0);
-  mMinimizer->SetPrintLevel(0);
-
-  if (mMethod == PropMethod::Propagator) {
-    LOGP(info, "Using propagator to find intersection");
-    const auto& prefix = o2::conf::DigiParams::Instance().digitizationgeometry_prefix;
-    mMCReader = std::make_unique<o2::steer::MCKinematicsReader>(prefix, o2::steer::MCKinematicsReader::Mode::kMCKine);
-    mMinimizer->SetFunction(mPropagator);
-  } else {
-    LOGP(info, "Using local straight-line to find intersection");
-    mMinimizer->SetFunction(mLine);
-  }
-
-  resetStats();
-
-  if (auto file = o2::its3::ITS3Params::Instance().misalignmentHitsParams; file.empty()) {
-    LOGP(fatal, "No parameter file specified");
-  } else {
-    mDeformations.init(file);
-  }
-}
-
-std::optional<o2::itsmft::Hit> MisAlignmentHits::processHit(int iEvent, const o2::itsmft::Hit& hit)
-{
-  ++mStats[Stats::kHitTotal];
-
-  if (!constants::detID::isDetITS3(hit.GetDetectorID())) {
-    ++mStats[Stats::kHitIsOB];
-    return hit;
-  }
-  ++mStats[Stats::kHitIsIB];
-
-  // Set the working hits
-  mCurHit = hit;
-  mCurWorkingHits[WorkingHit::kEntering] = WorkingHit(iEvent, WorkingHit::kEntering, hit);
-  mCurWorkingHits[WorkingHit::kExiting] = WorkingHit(iEvent, WorkingHit::kExiting, hit);
-
-  // Do work
-  if (!deformHit(WorkingHit::kEntering) || !deformHit(WorkingHit::kExiting)) {
-    ++mStats[Stats::kHitDead];
-    return std::nullopt;
-  }
-  ++mStats[Stats::kHitAlive];
-
-  // Set the possibly new detectorIDs with mid point approximation
-  auto midPointOrig = mCurWorkingHits[WorkingHit::kEntering].mPoint + (mCurWorkingHits[WorkingHit::kExiting].mPoint - mCurWorkingHits[WorkingHit::kEntering].mPoint) * 0.5;
-  auto midPointDef = mCurWorkingHits[WorkingHit::kEntering].mPointDef + (mCurWorkingHits[WorkingHit::kExiting].mPointDef - mCurWorkingHits[WorkingHit::kEntering].mPointDef) * 0.5;
-  const short idDef = getDetID(midPointDef), idOrig = getDetID(midPointOrig);
-  if (idDef == -1) {
-    return std::nullopt;
-  }
-
-  if (idDef != idOrig) {
-    ++mStats[Stats::kHitMigrated];
-  } else {
-    ++mStats[Stats::kHitNotMigrated];
-  }
-
-  if constexpr (false) {
-    /// TODO Does not yet work correctly
-    /// Check if we crossed a boundary within the entering and exiting hit from the midpoint
-    bool crossesBoundary{false};
-    TGeoNode *nEnt{nullptr}, *nExt{nullptr};
-    {
-      auto dirEnt = mCurWorkingHits[WorkingHit::kEntering].mPointDef - midPointDef;
-      auto stepEnt = std::min(static_cast<double>(dirEnt.R()), std::abs(dirEnt.R() - 5.e-4));
-      auto dirEntU = dirEnt.Unit();
-      gGeoManager->SetCurrentPoint(midPointDef.X(), midPointDef.Y(), midPointDef.Z());
-      gGeoManager->SetCurrentDirection(dirEntU.X(), dirEntU.Y(), dirEntU.Z());
-      nEnt = gGeoManager->FindNextBoundaryAndStep(stepEnt, false);
-      if (gGeoManager->IsOnBoundary()) {
-        ++mStats[Stats::kHitEntBoundary];
-        crossesBoundary = true;
-      }
-    }
-    {
-      auto dirExt = midPointDef - mCurWorkingHits[WorkingHit::kEntering].mPointDef;
-      auto stepExt = std::min(static_cast<double>(dirExt.R()), std::abs(dirExt.R() - 5.e-4));
-      auto dirExtU = dirExt.Unit();
-      gGeoManager->SetCurrentPoint(midPointDef.X(), midPointDef.Y(), midPointDef.Z());
-      gGeoManager->SetCurrentDirection(dirExtU.X(), dirExtU.Y(), dirExtU.Z());
-      nExt = gGeoManager->FindNextBoundaryAndStep(stepExt, false);
-      if (gGeoManager->IsOnBoundary()) {
-        ++mStats[Stats::kHitExtBoundary];
-        crossesBoundary = true;
-      }
-    }
-
-    if (crossesBoundary && nEnt != nullptr && nExt != nullptr) {
-      if (nEnt != nExt) {
-        return std::nullopt;
-      } else {
-        ++mStats[Stats::kHitSameBoundary]; // indicates that the step size is too large and we end up in the mother volume; just pretend that his fine for now
-      }
-    }
-    ++mStats[Stats::kHitNoBoundary];
-  }
-
-  // Get new postion
-  mCurHit.SetPosStart(mCurWorkingHits[WorkingHit::kEntering].mPointDef);
-  mCurHit.SetPos(mCurWorkingHits[WorkingHit::kExiting].mPointDef);
-  mCurHit.SetDetectorID(idDef);
-
-  ++mStats[Stats::kHitSuccess];
-  return mCurHit;
-}
-
-bool MisAlignmentHits::deformHit(WorkingHit::HitType t)
-{
-  auto& wHit = mCurWorkingHits[t];
-
-  mMinimizer->Clear(); // clear for next iteration
-  constexpr double minStep{1e-5};
-  constexpr double zMargin{4.0};
-  constexpr double phiMargin{0.4};
-  if (mMethod == PropMethod::Line) {
-    prepareLineMethod(t);
-    mMinimizer->SetVariable(0, "t", 0.0, minStep); // this is left as a free parameter on since t is very small since start and end of hit are close
-  } else {
-    if (!preparePropagatorMethod(t)) {
-      return false;
-    }
-    mMinimizer->SetVariable(0, "r", mPropagator.mTrack.getX(), minStep); // this is left as a free parameter on since t is very small since start and end of hit are close
-  }
-  mMinimizer->SetLimitedVariable(1, "phiStar", wHit.mPhi, minStep,
-                                 std::max(static_cast<double>(wHit.mPhiBorder1), static_cast<double>(wHit.mPhi) - phiMargin),
-                                 std::min(static_cast<double>(wHit.mPhiBorder2), static_cast<double>(wHit.mPhi) + phiMargin));
-  mMinimizer->SetLimitedVariable(2, "zStar", wHit.mPoint.Z(), minStep,
-                                 std::max(static_cast<double>(-constants::segment::lengthSensitive / 2.f), static_cast<double>(wHit.mPoint.Z()) - zMargin),
-                                 std::min(static_cast<double>(constants::segment::lengthSensitive / 2.f), static_cast<double>(wHit.mPoint.Z()) + zMargin));
-
-  mMinimizer->Minimize(); // perform the actual minimization
-
-  auto ss = mMinimizer->Status();
-  if (ss == 1) {
-    ++mStats[Stats::kMinimizerCovPos];
-  } else if (ss == 2) {
-    ++mStats[Stats::kMinimizerHesse];
-  } else if (ss == 3) {
-    ++mStats[Stats::kMinimizerEDM];
-  } else if (ss == 4) {
-    ++mStats[Stats::kMinimizerLimit];
-  } else if (ss == 5) {
-    ++mStats[Stats::kMinimizerOther];
-  } else {
-    ++mStats[Stats::kMinimizerConverged];
-  }
-
-  if (ss == 0 || ss == 1) { // for Minuit2 0=ok, 1=ok with pos. forced hesse
-    ++mStats[Stats::kMinimizerStatusOk];
-    if (mMinimizer->MinValue() < 2e-4) { // within 2 um considering the pixel pitch this good enough
-      ++mStats[Stats::kMinimizerValueOk];
-    } else {
-      ++mStats[Stats::kMinimizerValueBad];
-      return false;
-    }
-  } else {
-    ++mStats[Stats::kMinimizerStatusBad];
-    return false;
-  }
-
-  // Valid solution found; calculate new position on ideal geo
-  wHit.recalculateIdeal(static_cast<float>(mMinimizer->X()[1]), static_cast<float>(mMinimizer->X()[2]));
-
-  return true;
-}
-
-short MisAlignmentHits::getDetID(const o2::math_utils::Point3D<float>& point)
-{
-  // Do not modify the path, I do not know if this is needed but lets be safe
-  gGeoManager->PushPath();
-  auto id = getDetIDFromCords(point);
-  gGeoManager->PopPath();
-  return id;
-}
-
-short MisAlignmentHits::getDetIDFromCords(const o2::math_utils::Point3D<float>& point)
-{
-  // retrive if any the node which constains the point
-  const auto node = gGeoManager->FindNode(point.X(), point.Y(), point.Z());
-  if (node == nullptr) {
-    ++mStats[Stats::kFindNodeFailed];
-    return -1;
-  }
-  ++mStats[Stats::kFindNodeSuccess];
-
-  // check if this node is a sensitive volume
-  const std::string path = gGeoManager->GetPath();
-  if (path.find(o2::its::GeometryTGeo::getITS3SensorPattern()) == std::string::npos) {
-    ++mStats[Stats::kProjNonSensitive];
-    return -1;
-  }
-  ++mStats[Stats::kProjSensitive];
-
-  return getDetIDFromPath(path);
-}
-
-short MisAlignmentHits::getDetIDFromPath(const std::string& path) const
-{
-  static const std::regex pattern{R"(/cave_1/barrel_1/ITSV_2/ITSUWrapVol0_1/ITS3Layer(\d+)_(\d+)/ITS3CarbonForm(\d+)_(\d+)/ITS3Chip(\d+)_(\d+)/ITS3Segment(\d+)_(\d+)/ITS3RSU(\d+)_(\d+)/ITS3Tile(\d+)_(\d+)/ITS3PixelArray(\d+)_(\d+))"};
-  if (std::smatch matches; std::regex_search(path, matches, pattern)) {
-    if (matches.size() == 15) {
-      int iLayer = std::stoi(matches[1]);
-      int iCarbonForm = std::stoi(matches[4]);
-      int iSegment = std::stoi(matches[8]);
-      int iRSU = std::stoi(matches[10]);
-      int iTile = std::stoi(matches[12]);
-      return mGeo->getChipIndex(iLayer, iCarbonForm, 0, iSegment, iRSU, iTile);
-    } else {
-      LOGP(fatal, "Path did not contain expected number of matches ({})!", matches.size());
-    }
-  } else {
-    LOGP(fatal, "Path was not matched ({})!", path);
-  }
-  __builtin_unreachable();
-}
-
-void MisAlignmentHits::printStats() const
-{
-  auto makeFraction = [&](Stats n, Stats d) -> float { return static_cast<float>(mStats[n]) / static_cast<float>(mStats[d] + mStats[n]); };
-  LOGP(info, "Processed {} Hits (IB:{}; OB:{}) ({:.2f}%):", mStats[Stats::kHitTotal], mStats[Stats::kHitIsIB], mStats[Stats::kHitIsOB], makeFraction(Stats::kHitIsIB, Stats::kHitIsOB));
-  LOGP(info, "  - Minimizer Status: {} ok {} bad ({:.2f}%)", mStats[Stats::kMinimizerStatusOk], mStats[Stats::kMinimizerStatusBad], makeFraction(Stats::kMinimizerStatusOk, Stats::kMinimizerStatusBad));
-  LOGP(info, "  - Minimizer Value: {} ok {} bad ({:.2f}%)", mStats[Stats::kMinimizerValueOk], mStats[Stats::kMinimizerValueBad], makeFraction(Stats::kMinimizerValueOk, Stats::kMinimizerValueBad));
-  LOGP(info, "  - Minimizer Detailed: {} Converged {} pos. forced Hesse ({:.2f}%)", mStats[Stats::kMinimizerConverged], mStats[Stats::kMinimizerHesse], makeFraction(Stats::kMinimizerConverged, Stats::kMinimizerHesse));
-  LOGP(info, "  - Minimizer Detailed: {} EDM {} call limit {} other ({:.2f}%)", mStats[Stats::kMinimizerEDM], mStats[Stats::kMinimizerLimit], mStats[Stats::kMinimizerOther], makeFraction(Stats::kMinimizerEDM, Stats::kMinimizerLimit));
-  LOGP(info, "  - FindNode: {} ok {} failed", mStats[Stats::kFindNodeSuccess], mStats[Stats::kFindNodeFailed]);
-  LOGP(info, "  - IsSensitve: {} yes {} no ({:.2f}%)", mStats[Stats::kProjSensitive], mStats[Stats::kProjNonSensitive], makeFraction(Stats::kProjSensitive, Stats::kProjNonSensitive));
-  LOGP(info, "  - IsAlive: {} yes {} no ({:.2f}%)", mStats[Stats::kHitAlive], mStats[Stats::kHitDead], makeFraction(Stats::kHitAlive, Stats::kHitDead));
-  LOGP(info, "  - HasMigrated: {} yes {} no ({:.2f}%)", mStats[Stats::kHitMigrated], mStats[Stats::kHitNotMigrated], makeFraction(Stats::kHitMigrated, Stats::kHitNotMigrated));
-  // LOGP(info, "  - Crosses Boundary: {} entering {} exiting {} same {} no", mStats[Stats::kHitEntBoundary], mStats[Stats::kHitExtBoundary], mStats[Stats::kHitSameBoundary], mStats[Stats::kHitNoBoundary]);
-  if (mMethod == PropMethod::Propagator) {
-    LOGP(info, " - Propagator: {} null track {} null pdg", mStats[Stats::kPropTrackNull], mStats[Stats::kPropPDGNull]);
-  }
-  LOGP(info, "  --> Good Hits {} ({:.2f}%)", mStats[Stats::kHitSuccess], makeFraction(Stats::kHitSuccess, Stats::kHitIsIB));
-}
-
-void MisAlignmentHits::prepareLineMethod(WorkingHit::HitType from)
-{
-  // Set the starint point and radius
-  // always start from the entering hit that way t is always pos. defined
-  mLine.mStart = mCurWorkingHits[WorkingHit::kEntering].mPoint;
-  mLine.mRadius = mCurWorkingHits[from].mRadius;
-  mLine.mSensorID = mCurWorkingHits[from].mSensorID;
-  mLine.mPhiTot = mCurWorkingHits[from].mPhiBorder2 - mCurWorkingHits[from].mPhiBorder1;
-  mLine.mPhi1 = mCurWorkingHits[from].mPhiBorder1;
-  // Calculate the direction vector
-  mLine.mD[0] = mCurWorkingHits[WorkingHit::kExiting].mPoint.X() - mCurWorkingHits[WorkingHit::kEntering].mPoint.X();
-  mLine.mD[1] = mCurWorkingHits[WorkingHit::kExiting].mPoint.Y() - mCurWorkingHits[WorkingHit::kEntering].mPoint.Y();
-  mLine.mD[2] = mCurWorkingHits[WorkingHit::kExiting].mPoint.Z() - mCurWorkingHits[WorkingHit::kEntering].mPoint.Z();
-}
-
-double MisAlignmentHits::StraightLine::DoEval(const double* x) const
-{
-  const double t = x[0];
-  const double phi = x[1];
-  const double z = x[2];
-  const double nphi = std::clamp((phi - mPhi1) * 2.0 / mPhiTot - 1.0, -1.0, 1.0);
-  const double nz = std::clamp((z - (-constants::segment::lengthSensitive / 2.0)) * 2.0 / constants::segment::lengthSensitive - 1.0, -1.0, 1.0);
-
-  /// Find the point along the line given current t
-  double xline = mStart.X() + t * mD[0],
-         yline = mStart.Y() + t * mD[1],
-         zline = mStart.Z() + t * mD[2];
-
-  // Find the point of the deformed geometry given a certain phi' and z'
-  double xideal = mRadius * std::cos(phi), yideal = mRadius * std::sin(phi),
-         zideal = z;
-  const auto [dx, dy, dz] = mMis->getDeformation(mSensorID, nphi, nz);
-  double xdef = xideal + dx, ydef = yideal + dy, zdef = zideal + dz;
-
-  // Minimize the euclidean distance of the line point and the deformed point
-  return std::hypot(xline - xdef, yline - ydef, zline - zdef);
-}
-
-bool MisAlignmentHits::preparePropagatorMethod(WorkingHit::HitType from)
-{
-  mPropagator.mRadius = mCurWorkingHits[from].mRadius;
-  mPropagator.mSensorID = mCurWorkingHits[from].mSensorID;
-  mPropagator.mPhiTot = mCurWorkingHits[from].mPhiBorder2 - mCurWorkingHits[from].mPhiBorder1;
-  mPropagator.mPhi1 = mCurWorkingHits[from].mPhiBorder1;
-  const auto mcTrack = mMCReader->getTrack(mCurWorkingHits[from].mEvent, mCurWorkingHits[from].mTrackID);
-  if (mcTrack == nullptr) {
-    ++mStats[Stats::kPropTrackNull];
-    return false;
-  }
-  const std::array<float, 3> xyz{(float)mcTrack->GetStartVertexCoordinatesX(), (float)mcTrack->GetStartVertexCoordinatesY(), (float)mcTrack->GetStartVertexCoordinatesZ()},
-    pxyz{(float)mcTrack->GetStartVertexMomentumX(), (float)mcTrack->GetStartVertexMomentumY(), (float)mcTrack->GetStartVertexMomentumZ()};
-  const TParticlePDG* pPDG = TDatabasePDG::Instance()->GetParticle(mcTrack->GetPdgCode());
-  if (pPDG == nullptr) {
-    ++mStats[Stats::kPropPDGNull];
-    return false;
-  }
-  mPropagator.mTrack = o2::track::TrackPar(xyz, pxyz, TMath::Nint(pPDG->Charge() / 3), false);
-  mPropagator.mBz = o2::base::Propagator::Instance()->getNominalBz();
-  return true;
-}
-
-double MisAlignmentHits::Propagator::DoEval(const double* x) const
-{
-  const double r = x[0];
-  const double phi = x[1];
-  const double z = x[2];
-  const double nphi = (phi - mPhi1) * 2.0 / mPhiTot - 1.0;
-  const double nz = (z - (-constants::segment::lengthSensitive / 2.0)) * 2.0 / constants::segment::lengthSensitive - 1.0;
-
-  auto trc = mTrack;
-  if (!trc.propagateTo(r, mBz)) {
-    return 999;
-  }
-  const auto glo = trc.getXYZGlo();
-
-  // Find the point of the deformed geometry given a certain phi' and z'
-  double xideal = mRadius * std::cos(phi), yideal = mRadius * std::sin(phi),
-         zideal = z;
-  const auto [dx, dy, dz] = mMis->getDeformation(mSensorID, nphi, nz);
-  double xdef = xideal + dx, ydef = yideal + dy, zdef = zideal + dz;
-
-  // Minimize the euclidean distance of the propagator point and the deformed point
-  return std::hypot(glo.X() - xdef, glo.Y() - ydef, glo.Z() - zdef);
-}
-
-} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentManager.cxx b/Detectors/Upgrades/ITS3/alignment/src/MisalignmentManager.cxx
deleted file mode 100644
index c9d71541bcd0e..0000000000000
--- a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentManager.cxx
+++ /dev/null
@@ -1,195 +0,0 @@
-// Copyright 2020-2022 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "Framework/Logger.h"
-#include "ITS3Align/MisalignmentManager.h"
-#include "ITS3Align/MisalignmentHits.h"
-#include "SimConfig/DigiParams.h"
-
-#include "TFile.h"
-#include "TStopwatch.h"
-#include "TGeoManager.h"
-
-#include <string>
-#include <filesystem>
-#include <memory>
-#include <algorithm>
-#include <optional>
-#include <vector>
-
-namespace fs = std::filesystem;
-
-namespace o2::its3::align
-{
-
-void MisalignmentManager::createBackup(const fs::path& src, const fs::path& dest)
-{
-  if (fs::exists(dest)) {
-    LOGP(info, "Previous orignal file found, using this as src");
-  } else {
-    if (!fs::exists(src)) {
-      LOGP(fatal, "File {} does not exist", src.c_str());
-    }
-    LOGP(info, "Trying to backup file to {}", dest.c_str());
-    try {
-      fs::rename(src, dest);
-    } catch (const fs::filesystem_error& err) {
-      LOGP(fatal, "Cannot create backup file for Hit-File: {}", err.what());
-    }
-  }
-}
-
-void MisalignmentManager::misalignHits()
-{
-  LOGP(info, "{:*^90}", " ITS3 LOCAL MISALIGNMENT START ");
-
-  TStopwatch timer;
-  timer.Start();
-
-  MisAlignmentHits MisAligner;
-  MisAligner.init();
-
-  const fs::path oldHitFileSrc{fs::current_path().string() + "/" + o2::conf::DigiParams::Instance().digitizationgeometry_prefix + "_HitsIT3.root"};
-  const fs::path oldHitFileDest{fs::current_path().string() + "/" + o2::conf::DigiParams::Instance().digitizationgeometry_prefix + "_HitsIT3_Orig.root"};
-  createBackup(oldHitFileSrc, oldHitFileDest);
-
-  std::unique_ptr<TFile> origFile{TFile::Open(oldHitFileDest.c_str(), "READ")};
-  if (origFile == nullptr || origFile->IsZombie()) {
-    LOGP(fatal, "Original file {} cannot be opened", oldHitFileDest.c_str());
-  }
-
-  std::unique_ptr<TTree> origTree{origFile->Get<TTree>("o2sim")};
-  if (origTree == nullptr) {
-    LOGP(fatal, "Cannot get hit-tree from orignal file");
-  }
-  std::vector<o2::itsmft::Hit> origHits, *origHitsPtr{&origHits};
-  origTree->SetBranchAddress("IT3Hit", &origHitsPtr);
-
-  std::unique_ptr<TFile> newFile{TFile::Open(oldHitFileSrc.c_str(), "RECREATE")};
-  if (newFile == nullptr || newFile->IsZombie()) {
-    LOGP(fatal, "New file {} cannot be opened", oldHitFileSrc.c_str());
-  }
-
-  auto newTree = std::make_unique<TTree>("o2sim", "o2sim");
-  std::vector<o2::itsmft::Hit> newHits, *newHitsPtr{nullptr};
-  newTree->Branch("IT3Hit", &newHitsPtr);
-
-  LOGP(info, "Preparations done; starting hit loop");
-  auto nEntries = origTree->GetEntries();
-  ULong64_t totalOrigHits{0}, totalNewHits{0};
-  for (Long64_t iEntry{0}; origTree->LoadTree(iEntry) >= 0; ++iEntry) {
-    if (origTree->GetEntry(iEntry) <= 0) {
-      continue;
-    }
-
-    const auto progress = (iEntry * 100) / nEntries;
-    LOG_IF(info, progress % 10 == 0) << "Processing event " << iEntry << " / " << nEntries;
-
-    newHits.clear();
-    newHits.reserve(origHits.size());
-    for (const auto& origHit : origHits) {
-      if (auto newHit = MisAligner.processHit(iEntry, origHit)) {
-        newHits.emplace_back(*newHit);
-      }
-    }
-
-    newHitsPtr = &newHits;
-    newTree->Fill();
-
-    totalNewHits += newHits.size();
-    totalOrigHits += origHits.size();
-  }
-
-  newFile->WriteTObject(newTree.get());
-
-  timer.Stop();
-
-  MisAligner.printStats();
-
-  auto totalDiscardedHits = totalOrigHits - totalNewHits;
-  LOGP(info, "Summary: Total orignal Hits {}", totalOrigHits);
-  LOGP(info, "Summary: Total misaligned Hits {} ({:.2f}%)", totalNewHits, static_cast<float>(totalNewHits) / static_cast<float>(totalOrigHits) * 100);
-  LOGP(info, "Summary: Total discarded Hits {} ({:.2f}%)", totalDiscardedHits, static_cast<float>(totalDiscardedHits) / static_cast<float>(totalOrigHits) * 100);
-  LOGP(info, "Summary: Misalignment took {:.2f}s", timer.CpuTime());
-  LOGP(info, "{:*^90}", " ITS3 LOCAL MISALIGNMENT END ");
-}
-
-std::string MisalignmentManager::appendStem(const std::string& filename, const std::string& add)
-{
-  fs::path filepath{filename};
-  auto stem = filepath.stem().string();
-  auto extension = filepath.extension().string();
-  return stem + add + extension;
-}
-
-std::vector<std::string> MisalignmentManager::split(const std::string& s, char delimiter)
-{
-  std::vector<std::string> tokens;
-  std::string token;
-  std::istringstream tokenStream(s);
-  while (std::getline(tokenStream, token, delimiter)) {
-    if (!token.empty()) {
-      tokens.push_back(token);
-    }
-  }
-  return tokens;
-}
-
-void MisalignmentManager::navigate(const std::string& path)
-{
-  if (!gGeoManager->cd(path.c_str())) {
-    LOGP(fatal, "Cannot navigate to {}", path);
-  }
-}
-
-std::string MisalignmentManager::composePathSensor(int sensor)
-{
-  const int layerID{sensor / 2};
-  const int sensorID{sensor % 2};
-  return fmt::format("/cave/barrel_1/ITSV_2/ITSUWrapVol0_1/ITS3Layer{}_0/ITS3CarbonForm{}_{}",
-                     layerID, layerID, sensorID);
-}
-
-void MisalignmentManager::applyGlobalMatrixVolume(const std::string& path, const TGeoHMatrix& globalMatrix)
-{
-  gGeoManager->CdTop();
-  TGeoHMatrix* pgMatrix{nullptr};
-  TGeoHMatrix gAccMatrix;
-  std::string curPath{};
-  for (const auto& comp : split(path)) {
-    curPath += "/" + comp;
-    navigate(curPath);
-    pgMatrix = gGeoManager->GetCurrentMatrix();
-    gAccMatrix.Multiply(pgMatrix);
-  }
-  navigate(path);
-  auto node = gGeoManager->GetCurrentNode();
-  if (node == nullptr) {
-    LOGP(fatal, "Nullptr for node at {}", path);
-  }
-  auto motherVol = node->GetMotherVolume();
-  if (motherVol == nullptr) {
-    LOGP(fatal, "Nullptr for motherVol at {}", path);
-  }
-  // Compute the inverse of the accumulated global transformation matrix
-  auto gAccMatrix1 = gAccMatrix.Inverse();
-  // Compute the relative transformation matrix for the volume
-  auto relativeMatrix = globalMatrix;
-  relativeMatrix.MultiplyLeft(gAccMatrix1);
-
-  auto nodemat = dynamic_cast<TGeoNodeMatrix*>(node);
-  nodemat->SetMatrix(new TGeoHMatrix(globalMatrix));
-
-  // Force the container volume of the object to update itself
-  motherVol->Voxelize("");
-}
-
-} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentParameters.cxx b/Detectors/Upgrades/ITS3/alignment/src/MisalignmentParameters.cxx
deleted file mode 100644
index 0842b7252486a..0000000000000
--- a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentParameters.cxx
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file MisalignmentParameter.cxx
-/// \brief Implementation of the MisalignmentParameter class
-
-#include "ITS3Align/MisalignmentParameters.h"
-#include "Framework/Logger.h"
-
-#include "TFile.h"
-
-#include <memory>
-
-ClassImp(o2::its3::align::MisalignmentParameters);
-
-namespace o2::its3::align
-{
-
-MisalignmentParameters::MisalignmentParameters()
-{
-  SetName("MisalignmentParameters");
-  SetTitle("ITS3 MisalignmentParameters");
-}
-
-bool MisalignmentParameters::store(const std::string& file) const
-{
-  std::unique_ptr<TFile> fOut(TFile::Open(file.c_str(), "RECREATE"));
-  if (fOut == nullptr || fOut->IsZombie()) {
-    LOGP(info, "Unable to save misalignment parameters");
-    return false;
-  }
-  fOut->WriteObjectAny(this, "o2::its3::align::MisalignmentParameters", "ccdb_object");
-  return true;
-}
-
-MisalignmentParameters* MisalignmentParameters::load(const std::string& file)
-{
-  std::unique_ptr<TFile> fIn(TFile::Open(file.c_str(), "READ"));
-  auto p = fIn->Get<MisalignmentParameters>("ccdb_object");
-  if (p == nullptr) {
-    LOGP(fatal, "Unable to load parameters from file!");
-  }
-  return p;
-}
-
-void MisalignmentParameters::printParams(unsigned int detID) const
-{
-  LOGP(info, "Parameters for ID={}:", detID);
-  LOGP(info, " - Global Trans: X={} Y={} Z={}", getGloTransX(detID), getGloTransY(detID), getGloTransZ(detID));
-  LOGP(info, " - Global Rots: X={} Y={} Z={}", getGloRotX(detID), getGloRotY(detID), getGloRotZ(detID));
-  if (constants::detID::isDetITS3(detID)) {
-    auto sensorID = constants::detID::getSensorID(detID);
-    LOGP(info, " - Legendre Pol X:");
-    getLegendreCoeffX(sensorID).Print();
-    LOGP(info, " - Legendre Pol Y:");
-    getLegendreCoeffY(sensorID).Print();
-    LOGP(info, " - Legendre Pol Z:");
-    getLegendreCoeffZ(sensorID).Print();
-  }
-}
-
-void MisalignmentParameters::printLegendreParams(unsigned int sensorID) const
-{
-  LOGP(info, " - Legendre Pol X:");
-  getLegendreCoeffX(sensorID).Print();
-  LOGP(info, " - Legendre Pol Y:");
-  getLegendreCoeffY(sensorID).Print();
-  LOGP(info, " - Legendre Pol Z:");
-  getLegendreCoeffZ(sensorID).Print();
-}
-
-} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/alignment/src/alignment-workflow.cxx b/Detectors/Upgrades/ITS3/alignment/src/alignment-workflow.cxx
new file mode 100644
index 0000000000000..6ec7615885556
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/alignment-workflow.cxx
@@ -0,0 +1,71 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/CallbacksPolicy.h"
+#include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "GlobalTrackingWorkflowHelpers/NoInpDummyOutSpec.h"
+#include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "ITS3Align/AlignmentSpec.h"
+
+using namespace o2::framework;
+using namespace o2::its3::align;
+using GID = o2::dataformats::GlobalTrackID;
+using DetID = o2::detectors::DetID;
+
+void customize(std::vector<o2::framework::CallbacksPolicy>& policies)
+{
+  o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::vector<o2::framework::ConfigParamSpec> options{
+    {"disable-mc", o2::framework::VariantType::Bool, false, {"enable MC propagation"}},
+    {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of track sources to use"}},
+    {"cluster-sources", VariantType::String, "ITS", {"comma-separated list of cluster sources to use"}},
+    {"with-its", VariantType::Bool, false, {"ITS alignment mode"}},
+    {"without-pv", VariantType::Bool, false, {"Do not use in track refit the PV as an additional constraint"}},
+    {"output", VariantType::String, "", {"output steering"}},
+    {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::raw::HBFUtilsInitializer::addConfigOption(options);
+  std::swap(workflowOptions, options);
+}
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& cfg)
+{
+  o2::conf::ConfigurableParam::updateFromString(cfg.options().get<std::string>("configKeyValues"));
+  const GID::mask_t allowedSourcesTrc = GID::getSourcesMask("ITS,TPC,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
+  const GID::mask_t allowedSourcesClus = GID::getSourcesMask("ITS");
+  const GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(cfg.options().get<std::string>("track-sources"));
+  const GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(cfg.options().get<std::string>("cluster-sources"));
+  const auto useMC = !cfg.options().get<bool>("disable-mc");
+  const auto withPV = !cfg.options().get<bool>("without-pv");
+  const auto withITS = cfg.options().get<bool>("with-its");
+  const OutputEnum output(cfg.options().get<std::string>("output"));
+
+  WorkflowSpec specs;
+  if (!output[OutputOpt::MilleRes]) {
+    o2::globaltracking::InputHelper::addInputSpecs(cfg, specs, srcCls, srcTrc, srcTrc, useMC);
+    if (withPV && !useMC) {
+      o2::globaltracking::InputHelper::addInputSpecsPVertex(cfg, specs, useMC);
+    }
+  } else {
+    specs.emplace_back(o2::globaltracking::getNoInpDummyOutSpec(0));
+  }
+
+  specs.emplace_back(o2::its3::align::getAlignmentSpec(srcTrc, srcCls, useMC, withPV, withITS, output));
+
+  o2::raw::HBFUtilsInitializer hbfIni(cfg, specs);
+  return std::move(specs);
+}
diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/ITS3Params.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/ITS3Params.h
index 0bd548cef953d..1e3f4f47b8a29 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/ITS3Params.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/ITS3Params.h
@@ -19,11 +19,6 @@ namespace o2::its3
 {
 
 struct ITS3Params : public o2::conf::ConfigurableParamHelper<ITS3Params> {
-  // Alignment studies
-  bool applyMisalignmentHits{false};                                                // Apply detector misalignment on hit level
-  std::string misalignmentHitsParams{};                                             // Path to parameter file for mis-alignment
-  bool misalignmentHitsUseProp{false};                                              // Use propagtor for mis-alignment
-  std::string globalGeoMisAlignerMacro{"${O2_ROOT}/share/macro/MisAlignGeoITS3.C"}; // Path to macro for global geometry mis-alignment
   // Chip studies
   bool useDeadChannelMap{false};            // Query for a dead channel map to study disabling individual tiles
   std::string chipResponseFunction{"APTS"}; // Chip response function one of "Alpide", "APTS" or "Mosaix" (not yet available)
diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
index fbf9a59e6da4b..088dd858fff73 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SegmentationMosaix.h
@@ -151,7 +151,8 @@ class SegmentationMosaix
   }
 
   // Same as localToDetector w.o. checks.
-  constexpr void localToDetectorUnchecked(float const xRow, float const zCol, int& iRow, int& iCol) const noexcept
+  template <typename T = float>
+  constexpr void localToDetectorUnchecked(T const xRow, T const zCol, int& iRow, int& iCol) const noexcept
   {
     iRow = static_cast<int>(std::floor((WidthH - xRow) / PitchRow));
     iCol = static_cast<int>(std::floor((zCol + LengthH) / PitchCol));
@@ -167,7 +168,8 @@ class SegmentationMosaix
   /// center of the sensitive volume.
   /// If iRow and or iCol is outside of the segmentation range a value of -0.5*Dx()
   /// or -0.5*Dz() is returned.
-  bool detectorToLocal(float const row, float const col, float& xRow, float& zCol) const noexcept
+  template <typename T = float, typename L = float>
+  bool detectorToLocal(T const row, T const col, L& xRow, L& zCol) const noexcept
   {
     if (!isValidDet(row, col)) {
       return false;
@@ -178,15 +180,17 @@ class SegmentationMosaix
 
   // Same as detectorToLocal w.o. checks.
   // We position ourself in the middle of the pixel.
-  void detectorToLocalUnchecked(float const row, float const col, float& xRow, float& zCol) const noexcept
+  template <typename T = float, typename L = float>
+  void detectorToLocalUnchecked(T const row, T const col, L& xRow, L& zCol) const noexcept
   {
     xRow = -(row + 0.5f) * PitchRow + WidthH;
     zCol = (col + 0.5f) * PitchCol - LengthH;
   }
 
-  bool detectorToLocal(float const row, float const col, math_utils::Point3D<float>& loc) const noexcept
+  template <typename T = float, typename L = float>
+  bool detectorToLocal(T const row, T const col, math_utils::Point3D<L>& loc) const noexcept
   {
-    float xRow{0.}, zCol{0.};
+    L xRow{0.}, zCol{0.};
     if (!detectorToLocal(row, col, xRow, zCol)) {
       return false;
     }
@@ -194,9 +198,10 @@ class SegmentationMosaix
     return true;
   }
 
-  void detectorToLocalUnchecked(float const row, float const col, math_utils::Point3D<float>& loc) const noexcept
+  template <typename T = float, typename L = float>
+  void detectorToLocalUnchecked(T const row, T const col, math_utils::Point3D<L>& loc) const noexcept
   {
-    float xRow{0.}, zCol{0.};
+    L xRow{0.}, zCol{0.};
     detectorToLocalUnchecked(row, col, xRow, zCol);
     loc.SetCoordinates(xRow, 0.0f, zCol);
   }
diff --git a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
index 937fa8d2e982c..270b1a7148f61 100644
--- a/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
+++ b/Detectors/Upgrades/ITS3/base/include/ITS3Base/SpecsV2.h
@@ -209,7 +209,7 @@ inline T getSensorID(T detID)
 template <typename T = int>
 inline bool isDetITS3(T detID)
 {
-  return detID < static_cast<T>(nChips);
+  return detID < static_cast<T>(nChips) && detID >= 0;
 }
 
 } // namespace detID
diff --git a/Detectors/Upgrades/ITS3/macros/align/CMakeLists.txt b/Detectors/Upgrades/ITS3/macros/align/CMakeLists.txt
index 86ebd989133e0..1d5c18cc0f4f3 100644
--- a/Detectors/Upgrades/ITS3/macros/align/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/macros/align/CMakeLists.txt
@@ -9,9 +9,5 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-# install(FILES MisAlignGeoITS3.C DESTINATION share/macro/)
-# its3_add_macro(MisAlignGeoITS3.C)
-its3_add_macro(TestLegendrePol.C)
-its3_add_macro(CreateMisalignmentITS3.C)
-its3_add_macro(ShowCoefficients.C)
 its3_add_macro(CheckResidualsITS3.C)
+its3_add_macro(CheckHitResiduals.C)
diff --git a/Detectors/Upgrades/ITS3/macros/align/CheckHitResiduals.C b/Detectors/Upgrades/ITS3/macros/align/CheckHitResiduals.C
new file mode 100644
index 0000000000000..555ba177a60ce
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/macros/align/CheckHitResiduals.C
@@ -0,0 +1,131 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <TStyle.h>
+#include <TCanvas.h>
+#include <TFile.h>
+#include <TH2F.h>
+#include <TProfile2D.h>
+#include <TTree.h>
+
+#include "MathUtils/Utils.h"
+#include "ITSMFTSimulation/Hit.h"
+#include "ITS3Base/SpecsV2.h"
+#endif
+
+void CheckHitResiduals(const std::string& hitOFile = "o2sim_HitsIT3_Orig.root",
+                       const std::string& hitRFile = "o2sim_HitsIT3.root")
+{
+  gStyle->SetOptStat(0);
+
+  TFile fileO(hitOFile.data());
+  auto* hitOTree = dynamic_cast<TTree*>(fileO.Get("o2sim"));
+  std::vector<o2::itsmft::Hit>* hitOArray = nullptr;
+  hitOTree->SetBranchAddress("IT3Hit", &hitOArray);
+
+  TFile fileR(hitRFile.data());
+  auto* hitRTree = dynamic_cast<TTree*>(fileR.Get("o2sim"));
+  std::vector<o2::itsmft::Hit>* hitRArray = nullptr;
+  hitRTree->SetBranchAddress("IT3Hit", &hitRArray);
+
+  struct Hits {
+    o2::itsmft::Hit oHit, rHit;
+    int oEve{-1}, rEve{-1};
+    bool hasBoth() const noexcept { return oEve >= 0 && rEve >= 0 && oEve == rEve && oHit.GetDetectorID() == rHit.GetDetectorID() && rHit.GetTrackID() == oHit.GetTrackID(); }
+  };
+  std::unordered_map<uint64_t, Hits> hits;
+
+  size_t total{0};
+  for (int iEntry{0}; iEntry < hitOTree->GetEntries(); ++iEntry) {
+    hitOTree->GetEntry(iEntry);
+    total += hitOArray->size();
+    for (const auto& h : *hitOArray) {
+      if (!o2::its3::constants::detID::isDetITS3(h.GetDetectorID())) {
+        continue;
+      }
+      uint64_t key = (uint64_t(iEntry) << 48) | (uint64_t(h.GetTrackID()) << 24) | uint64_t(h.GetDetectorID());
+      auto& hh = hits[key];
+      hh.oHit = h;
+      hh.oEve = iEntry;
+    }
+  }
+  printf("placed %zu hits saw %zu\n", hits.size(), total);
+  for (int iEntry{0}; iEntry < hitRTree->GetEntries(); ++iEntry) {
+    hitRTree->GetEntry(iEntry);
+    for (const auto& h : *hitRArray) {
+      if (!o2::its3::constants::detID::isDetITS3(h.GetDetectorID())) {
+        continue;
+      }
+      uint64_t key = (uint64_t(iEntry) << 48) | (uint64_t(h.GetTrackID()) << 24) | uint64_t(h.GetDetectorID());
+      auto& hh = hits[key];
+      hh.rHit = h;
+      hh.rEve = iEntry;
+    }
+  }
+
+  // plot the residuals in dRPhi, dZ against ideal phi,z for each layer
+  std::array<TProfile2D*, 3> mDRPhi{}, mDZ{};
+  for (int i{0}; i < 3; ++i) {
+    mDRPhi[i] = new TProfile2D(Form("hDRPhi_%d", i), Form("#Delta_{r#varphi};z (cm); r#varphi (cm)"), 100, -15, 15, 100, 0, 2 * TMath::Pi());
+    mDRPhi[i]->SetDirectory(nullptr);
+    mDZ[i] = new TProfile2D(Form("hDZ_%d", i), Form("#Delta_{z};z (cm); r#varphi (cm)"), 100, -15, 15, 100, 0, 2 * TMath::Pi());
+    mDZ[i]->SetDirectory(nullptr);
+  }
+  std::array<int, 3> cIB{};
+  for (const auto& [_, h] : hits) {
+    if (h.hasBoth()) {
+      int chip = o2::its3::constants::detID::getSensorID(h.oHit.GetDetectorID()) / 2;
+      ++cIB[chip];
+      auto gloO = h.oHit.GetPosStart();
+      auto gloR = h.rHit.GetPosStart();
+      // ideal (original) cluster: phi, z, rphi
+      float phiO = std::atan2(gloO.Y(), gloO.X());
+      o2::math_utils::bringTo02Pi(phiO);
+      const float rO = std::hypot(gloO.X(), gloO.Y());
+
+      // deformed (reconstructed) cluster
+      float phiR = std::atan2(gloR.Y(), gloR.X());
+      o2::math_utils::bringTo02Pi(phiR);
+      const float rR = std::hypot(gloR.X(), gloR.Y());
+
+      // residuals
+      const float dRPhi = rO * (phiR - phiO); // or use average r, doesn't matter at this precision
+      const float dZ = gloR.Z() - gloO.Z();
+
+      // fill vs (z, phi) of ideal position
+      mDRPhi[chip]->Fill(gloO.Z(), phiO, dRPhi * 1e4);
+      mDZ[chip]->Fill(gloO.Z(), phiO, dZ * 1e4);
+    }
+  }
+  for (int lay{0}; lay < 3; ++lay) {
+    printf("\t%d has %d\n", lay, cIB[lay]);
+  }
+  auto c1 = new TCanvas;
+  c1->Divide(3, 1);
+  for (int i{0}; i < 3; ++i) {
+    c1->cd(1 + i);
+    gPad->SetRightMargin(3);
+    mDRPhi[i]->GetZaxis()->SetRangeUser(-200, 200);
+    mDRPhi[i]->Draw("colz");
+  }
+  c1->Draw();
+  c1->SaveAs("its3_clus_res_rphi.pdf");
+  auto c2 = new TCanvas;
+  c2->Divide(3, 1);
+  for (int i{0}; i < 3; ++i) {
+    c2->cd(1 + i);
+    gPad->SetRightMargin(3);
+    mDZ[i]->GetZaxis()->SetRangeUser(-200, 200);
+    mDZ[i]->Draw("colz");
+  }
+  c2->Draw();
+  c2->SaveAs("its3_clus_res_z.pdf");
+}
diff --git a/Detectors/Upgrades/ITS3/macros/align/CreateMisalignmentITS3.C b/Detectors/Upgrades/ITS3/macros/align/CreateMisalignmentITS3.C
deleted file mode 100644
index 8df00ee25de00..0000000000000
--- a/Detectors/Upgrades/ITS3/macros/align/CreateMisalignmentITS3.C
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#if !defined(__CLING__) || defined(__ROOTCLING__)
-#include "TRandom.h"
-#include "TMatrixD.h"
-
-#include "ITS3Align/MisalignmentParameters.h"
-#endif
-
-void CreateMisalignmentITS3(bool dummy = false, bool manual = false)
-{
-  gRandom->SetSeed(42);
-
-  // Legendre coeff.
-  constexpr int nOrder{2};
-  auto getRandom = []() {
-    constexpr double scale{50.e-4};
-    return scale * gRandom->Uniform(-1.0, 1.0);
-  };
-
-  auto getSign = []() { return gRandom->Uniform() ? -1.0 : 1.0; };
-
-  o2::its3::align::MisalignmentParameters params;
-
-  if (dummy) {
-    TMatrixD coeffNull(0 + 1, 0 + 1);
-    for (int sensorID{0}; sensorID < 6; ++sensorID) {
-      params.setLegendreCoeffX(sensorID, coeffNull);
-      params.setLegendreCoeffY(sensorID, coeffNull);
-      params.setLegendreCoeffZ(sensorID, coeffNull);
-    }
-  } else if (manual) {
-    // (0,0) -> shift
-    // (1,0) ->
-    for (int sensorID{0}; sensorID < 6; ++sensorID) {
-      constexpr double scale{20e-4};
-      TMatrixD coeffNull(1, 1);
-
-      TMatrixD coeffMinusX(1 + 1, 1 + 1);
-      TMatrixD coeffPlusX(1 + 1, 1 + 1);
-      coeffMinusX(1, 1) = -scale;
-      coeffPlusX(1, 1) = scale;
-
-      TMatrixD coeffMinusY(4 + 1, 4 + 1);
-      TMatrixD coeffPlusY(4 + 1, 4 + 1);
-      coeffMinusY(0, 0) = scale;
-      coeffPlusY(0, 0) = -scale;
-      coeffMinusY(4, 4) = -scale;
-      coeffPlusY(4, 4) = scale;
-      if (sensorID % 2 == 0) {
-        params.setLegendreCoeffX(sensorID, coeffPlusX);
-        params.setLegendreCoeffY(sensorID, coeffPlusY);
-        params.setLegendreCoeffZ(sensorID, coeffNull);
-      } else {
-        params.setLegendreCoeffX(sensorID, coeffMinusX);
-        params.setLegendreCoeffY(sensorID, coeffMinusY);
-        params.setLegendreCoeffZ(sensorID, coeffNull);
-      }
-    }
-  } else {
-    for (int sensorID{0}; sensorID < 6; ++sensorID) {
-      TMatrixD coeffX(nOrder + 1, nOrder + 1);
-      TMatrixD coeffY(nOrder + 1, nOrder + 1);
-      TMatrixD coeffZ(nOrder + 1, nOrder + 1);
-      for (int i{0}; i <= nOrder; ++i) {
-        for (int j{0}; j <= i; ++j) {
-          // some random scaling as higher order parameters have higher influence
-          coeffX(i, j) = getRandom() / (1.0 + i * j * 2.0);
-          coeffZ(i, j) = getRandom() / (1.0 + i * j * 2.0);
-          coeffY(i, j) = getRandom() / (1.0 + i * j * 2.0);
-        }
-      }
-
-      params.setLegendreCoeffX(sensorID, coeffX);
-      params.setLegendreCoeffY(sensorID, coeffY);
-      params.setLegendreCoeffZ(sensorID, coeffZ);
-    }
-  }
-
-  for (int sensorID{0}; sensorID < 6; ++sensorID) {
-    params.printLegendreParams(sensorID);
-  }
-
-  params.store("misparams.root");
-}
diff --git a/Detectors/Upgrades/ITS3/macros/align/MisAlignGeoITS3.notest b/Detectors/Upgrades/ITS3/macros/align/MisAlignGeoITS3.notest
deleted file mode 100644
index 2a4bef978d0da..0000000000000
--- a/Detectors/Upgrades/ITS3/macros/align/MisAlignGeoITS3.notest
+++ /dev/null
@@ -1,129 +0,0 @@
-// Copyright 2020-2022 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file MisAlignGeoITS3.C
-/// \brief Misalign the global geometry of ITS3
-/// \author felix.schlepper@cern.ch
-
-#include "ITS3Align/MisalignmentManager.h"
-
-#include "TGeoManager.h"
-#include "TGeoMatrix.h"
-#include "TMath.h"
-
-#include "CommonUtils/ConfigurableParam.h"
-#include "CommonUtils/ConfigurableParamHelper.h"
-#include "Framework/Logger.h"
-#include "ITS3Base/SpecsV2.h"
-
-#include <filesystem>
-
-#include "boost/property_tree/ptree.hpp"
-
-using MM = o2::its3::align::MisalignmentManager;
-namespace fs = std::filesystem;
-namespace pt = boost::property_tree;
-namespace its3c = o2::its3::constants;
-
-#define DECLARE_SENSOR(id)       \
-  float Sensor##id##Dx = 0.f;    \
-  float Sensor##id##Dy = 0.f;    \
-  float Sensor##id##Dz = 0.f;    \
-  float Sensor##id##Phi = 0.f;   \
-  float Sensor##id##Theta = 0.f; \
-  float Sensor##id##Psi = 0.f;
-
-struct MisAlignGlobalParams : public o2::conf::ConfigurableParamHelper<MisAlignGlobalParams> {
-  DECLARE_SENSOR(0)
-  DECLARE_SENSOR(1)
-  DECLARE_SENSOR(2)
-  DECLARE_SENSOR(3)
-  DECLARE_SENSOR(4)
-  DECLARE_SENSOR(5)
-
-  O2ParamDef(MisAlignGlobalParams, "MisAlignGlobalParams");
-};
-O2ParamImpl(MisAlignGlobalParams);
-
-void MisAlignGeoITS3(const std::string& configFilePath = "", bool _export = false, bool draw = false, bool check = false, const std::string& geomFile = "o2sim_geometry-aligned.root")
-{
-  LOGP(info, "{:*^90}", " ITS3 GLOBAL MISALIGNMENT START ");
-  auto& params = MisAlignGlobalParams::Instance();
-  params.writeINI("default_parameters_global.ini", "MisAlignGlobalParams");
-  if (configFilePath.empty()) {
-    LOGP(info, "No user config provided using defaults");
-  } else {
-    LOGP(info, "User config at {}", configFilePath);
-    params.updateFromFile(configFilePath);
-  }
-  params.writeINI("used_parameters_global.ini", "MisAlignGlobalParams");
-  params.printKeyValues(true, true);
-
-  const fs::path srcFile{geomFile};
-  const fs::path destFile{MM::appendStem(geomFile, "_Orig")};
-  if (gGeoManager == nullptr) {
-    MM::createBackup(srcFile, destFile);
-    TGeoManager::Import(destFile.c_str());
-  }
-
-  LOGP(info, "Building matrices");
-  std::array<TGeoHMatrix, its3c::nSensorsIB> gRotoTranslations{};
-  for (int iSensor{0}; iSensor < (int)its3c::nSensorsIB; ++iSensor) {
-    auto& mat = gRotoTranslations[iSensor];
-    // Phi Z rotation angle (first)  defined in [-PI,PI]
-    // Theta X rotation angle (second) defined only [0,PI]
-    // Psi Z rotation angle (third)  defined in [-PI,PI]
-    MM::Euler3D euler{
-      ((iSensor % 2 == 0) ? 0. : -TMath::Pi()) +
-        TMath::DegToRad() * params.getValueAs<float>(fmt::format("MisAlignGlobalParams.Sensor{}Phi", iSensor)),
-      TMath::DegToRad() * params.getValueAs<float>(fmt::format("MisAlignGlobalParams.Sensor{}Theta", iSensor)),
-      TMath::DegToRad() * params.getValueAs<float>(fmt::format("MisAlignGlobalParams.Sensor{}Psi", iSensor)),
-    };
-    MM::Rot3D rot(euler);
-    std::array<Double_t, 9> rota;
-    rot.GetComponents(std::begin(rota));
-    mat.SetRotation(rota.data());
-    std::array<Double_t, 3> trans{
-      params.getValueAs<float>(fmt::format("MisAlignGlobalParams.Sensor{}Dx", iSensor)),
-      params.getValueAs<float>(fmt::format("MisAlignGlobalParams.Sensor{}Dy", iSensor)),
-      params.getValueAs<float>(fmt::format("MisAlignGlobalParams.Sensor{}Dz", iSensor)),
-    };
-    mat.SetTranslation(trans.data());
-  }
-
-  LOGP(info, "Appying Global RotoTranslations");
-  for (int iSensor{0}; iSensor < (int)its3c::nSensorsIB; ++iSensor) {
-    auto path = MM::composePathSensor(iSensor);
-    auto& mat = gRotoTranslations[iSensor];
-    MM::applyGlobalMatrixVolume(path, mat);
-  }
-
-  if (_export) {
-    gGeoManager->Export(srcFile.c_str());
-  }
-  if (draw) {
-    MM::navigate("cave/barrel_1/ITSV_2/ITSUWrapVol0_1");
-    gGeoManager->GetCurrentVolume()->Draw();
-    gGeoManager->SetTopVisible();
-    gGeoManager->RestoreMasterVolume();
-  }
-  if (check) {
-    gGeoManager->CdTop();
-    gGeoManager->CloseGeometry();
-    gGeoManager->CheckGeometryFull();
-    gGeoManager->CheckOverlaps(0.1, "s");
-    gGeoManager->PrintOverlaps();
-    auto overlaps = gGeoManager->GetListOfOverlaps();
-    overlaps->At(0)->Print();
-    overlaps->At(0)->Draw("ogl");
-  }
-  LOGP(info, "{:*^90}", " ITS3 GLOBAL MISALIGNMENT END ");
-}
diff --git a/Detectors/Upgrades/ITS3/macros/align/ShowCoefficients.C b/Detectors/Upgrades/ITS3/macros/align/ShowCoefficients.C
deleted file mode 100644
index 42749b707e81d..0000000000000
--- a/Detectors/Upgrades/ITS3/macros/align/ShowCoefficients.C
+++ /dev/null
@@ -1,333 +0,0 @@
-// Copyright 2020-2022 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#if !defined(__CLING__) || defined(__ROOTCLING__)
-#include "Math/Factory.h"
-#include "Math/Minimizer.h"
-#include "TAxis.h"
-#include "TCanvas.h"
-#include "TGraph.h"
-#include "TGraph2D.h"
-#include "TLegend.h"
-#include "TMarker.h"
-#include "TMultiGraph.h"
-#include "TRandom.h"
-#include "TMath.h"
-
-#include "MathUtils/LegendrePols.h"
-#include "ITS3Align/Deformations.h"
-#include "MathUtils/Utils.h"
-#endif
-
-static ROOT::Math::Minimizer* gMin;
-
-void ShowCoefficients(const std::string& fileName = "misparams.root", bool findMin = false)
-{
-  constexpr double factor{10};
-  o2::its3::align::Deformations def;
-  def.init(fileName);
-
-  if (findMin) {
-    gMin = ROOT::Math::Factory::CreateMinimizer("Minuit2", "Migrad");
-    if (gMin == nullptr) {
-      Error("", "Cannot create minimizer !");
-      return;
-    }
-    gMin->SetMaxFunctionCalls(1000000); // for Minuit/Minuit2
-    gMin->SetTolerance(0.00001);
-    gMin->SetPrintLevel(1);
-  }
-
-  if constexpr (1) {
-    constexpr int nPoints{1000};
-    const std::array<double, 7> zFix{-12., -8.67, -4.33, 0., 4.33, 8.67, 12.};
-    const std::array<double, 7> phiFix{1. / 4. * TMath::Pi(), 0.5 * TMath::Pi(), 3. / 4. * TMath::Pi(), TMath::Pi(), 5. / 4. * TMath::Pi(), 6. / 4. * TMath::Pi(), 7. / 4. * TMath::Pi()};
-    const std::array<const char*, 7> phiFixName{"#frac{1}{4}", "#frac{1}{2}", "#frac{3}{4}", "1", "#frac{5}{4}", "#frac{6}{4}", "#frac{7}{4}"};
-    const std::array<bool, 7> phiFixTop{true, true, true, false, false, false, false};
-    const std::array<std::array<int, 3>, 2> sensorN{{{0, 2, 4}, {1, 3, 5}}};
-    constexpr double z1{-o2::its3::constants::segment::lengthSensitive / 2.0}, z2{o2::its3::constants::segment::lengthSensitive / 2.0}, zTot{z2 - z1}, zStep{zTot / (nPoints - 1)};
-    auto canv = new TCanvas();
-    canv->Divide(7, 2);
-    for (int i{0}; i < 7; ++i) {
-      std::array<double, nPoints * 6> xi, yi, xd, yd;
-      for (int s{0}; s < 6; ++s) {
-        const bool isTop = s % 2 == 0;
-        const double radius = o2::its3::constants::radii[s / 2];
-        const double nzFix = (zFix[i] - z1) * 2.0 / zTot - 1.0;
-        const double phi1 = o2::math_utils::to02Pi(((isTop) ? 0.f : 1.f) * TMath::Pi() + std::asin(o2::its3::constants::equatorialGap / 2.f / radius));
-        const double phi2 = o2::math_utils::to02Pi(((isTop) ? 1.f : 2.f) * TMath::Pi() - std::asin(o2::its3::constants::equatorialGap / 2.f / radius));
-        const double phiTot{phi2 - phi1}, phiStep{phiTot / (nPoints - 1)};
-        const double nphiFix = ((phiFix[i]) - phi1) * 2.0 / phiTot - 1.0;
-
-        for (int j{0}; j < nPoints; ++j) {
-          const int idx = s * nPoints + j;
-          const double phi = phi1 + j * phiStep;
-          const double nphi = (phi - phi1) * 2.0 / phiTot - 1.0;
-
-          xi[idx] = radius * std::cos(phi);
-          yi[idx] = radius * std::sin(phi);
-          const auto [dxXY, dyXY, _] = def.getDeformation(s, nphi, nzFix);
-          xd[idx] = xi[idx] + dxXY * factor;
-          yd[idx] = yi[idx] + dyXY * factor;
-        }
-      }
-      canv->cd(i + 1);
-      auto gixy = new TGraph(nPoints * 6, xi.data(), yi.data());
-      gixy->SetNameTitle(Form("g_i_xy_%d", i), Form("Ideal xy at z=%.2f; x (cm); y (cm)", zFix[i]));
-      gixy->SetMarkerColor(kBlue);
-      gixy->Draw("AP");
-      auto gdxy = new TGraph(nPoints * 6, xd.data(), yd.data());
-      gdxy->SetNameTitle(Form("g_d_xy_%d", i), Form("Deformed (x%.0f) xy at z=%.2f; x (cm); y (cm)", factor, zFix[i]));
-      gdxy->SetMarkerColor(kRed);
-      gdxy->Draw("P;same");
-
-      if (i == 3) {
-        continue;
-      }
-
-      std::array<double, nPoints * 3> zi, ri, zd, rd;
-      const bool isTop = phiFixTop[i];
-      for (const int s : ((isTop) ? sensorN[0] : sensorN[1])) {
-        const double radius = o2::its3::constants::radii[s / 2];
-        const double phi1 = o2::math_utils::to02Pi(((isTop) ? 0.f : 1.f) * TMath::Pi() + std::asin(o2::its3::constants::equatorialGap / 2.f / radius));
-        const double phi2 = o2::math_utils::to02Pi(((isTop) ? 1.f : 2.f) * TMath::Pi() - std::asin(o2::its3::constants::equatorialGap / 2.f / radius));
-        const double phiTot{phi2 - phi1}, phiStep{phiTot / (nPoints - 1)};
-        const double nphiFix = ((phiFix[i]) - phi1) * 2.0 / phiTot - 1.0;
-        for (int j{0}; j < nPoints; ++j) {
-          const int idx = (s / 2) * nPoints + j;
-          const double z = z1 + j * zStep;
-          const double nz = (z - z1) * 2.0 / zTot - 1.0;
-          const double xi = radius * std::cos(phiFix[i]), yi = radius * std::sin(phiFix[i]);
-          ri[idx] = radius;
-          zi[idx] = z;
-          const auto [dxZR, dyZR, dzZR] = def.getDeformation(s, nphiFix, nz);
-          zd[idx] = z + dzZR * factor;
-          const double xxd = xi + dxZR * factor, yyd = yi + dyZR * factor;
-          rd[idx] = std::sqrt(xxd * xxd + yyd * yyd);
-        }
-      }
-      canv->cd(i + 8);
-      auto gizr = new TGraph(nPoints * 3, zi.data(), ri.data());
-      gizr->SetNameTitle(Form("g_i_zr_%d", i), Form("Ideal zr at #varphi=%s #Pi; z (cm); r (cm)", phiFixName[i]));
-      gizr->SetMarkerColor(kBlue);
-      gizr->Draw("AP");
-      auto gdzr = new TGraph(nPoints * 3, zd.data(), rd.data());
-      gdzr->SetNameTitle(Form("g_d_zr_%d", i), Form("Deformed (x%0.f) zr at #varphi=%s #Pi; z (cm); r (cm)", factor, phiFixName[i]));
-      gdzr->SetMarkerColor(kRed);
-      gdzr->Draw("P;same");
-    }
-    canv->Draw();
-    canv->SaveAs("its3_deformation.pdf");
-  }
-
-  if constexpr (1) {
-    const std::array<const char*, 3> axisName{"x", "y", "z"};
-    constexpr int nPoints{100};
-    constexpr int nPoints2{nPoints * nPoints};
-    constexpr double minX{-1.0}, maxX{1.0},
-      stepX{(maxX - minX) / static_cast<double>(nPoints)};
-
-    for (unsigned int iSensor{0}; iSensor < 6; ++iSensor) {
-      const auto nOrders = def.getOrders(iSensor);
-      for (unsigned int iAxis{0}; iAxis < 3; ++iAxis) {
-        std::array<double, nPoints2> x, y, z;
-        auto canv = new TCanvas(Form("c_sensor%d_d%s", iSensor, axisName[iAxis]), Form("Legendre Coefficients Sensor %d - Axis %s", iSensor, axisName[iAxis]));
-        canv->Divide(nOrders[iAxis] + 1, nOrders[iAxis] + 1);
-
-        { // Draw total polynominal
-          for (int iPoint{0}; iPoint < nPoints; ++iPoint) {
-            double xcur = minX + iPoint * stepX;
-            for (int jPoint{0}; jPoint < nPoints; ++jPoint) {
-              double ycur = minX + jPoint * stepX;
-              int i = iPoint * nPoints + jPoint;
-              x[i] = xcur;
-              y[i] = ycur;
-              z[i] = def.getDeformation(iSensor, iAxis, xcur, ycur);
-            }
-          }
-          canv->cd(nOrders[iAxis] + 1);
-          auto g = new TGraph2D(nPoints2, x.data(), y.data(), z.data());
-          g->SetTitle(Form("Legendre Polynominal %d-deg Sensor %d #Delta%s;u;v;w", nOrders[iAxis], iSensor, axisName[iAxis]));
-          g->SetName(Form("g_%d_%s", iSensor, axisName[iAxis]));
-          g->Draw("surf1");
-          g->GetXaxis()->SetRangeUser(minX, maxX);
-          g->GetYaxis()->SetRangeUser(minX, maxX);
-          gPad->Update();
-        }
-
-        { // Draw decomposition of contributions to polynominal
-          const auto& leg = def.getLegendre(iSensor, iAxis);
-          const auto coeff = leg.getCoefficients();
-          for (unsigned int iOrder{0}; iOrder <= nOrders[iAxis]; ++iOrder) {
-            for (unsigned int jOrder{0}; jOrder <= iOrder; ++jOrder) {
-              for (int iPoint{0}; iPoint < nPoints; ++iPoint) {
-                double xcur = minX + iPoint * stepX;
-                for (int jPoint{0}; jPoint < nPoints; ++jPoint) {
-                  double ycur = minX + jPoint * stepX;
-                  int i = iPoint * nPoints + jPoint;
-                  x[i] = xcur;
-                  y[i] = ycur;
-                  z[i] = leg(iOrder, jOrder, xcur, ycur);
-                }
-              }
-              canv->cd(1 + iOrder * (nOrders[iAxis] + 1) + jOrder);
-              auto g = new TGraph2D(nPoints2, x.data(), y.data(), z.data());
-              g->SetTitle(Form("c_{%d,%d}=%.4f;u;v;w", iOrder, jOrder, coeff(iOrder, jOrder)));
-              g->SetName(Form("g_%d_%d_%d_%d", iSensor, iAxis, iOrder, jOrder));
-              if (iOrder == 0 && jOrder == 0) { // Fix display of constant value
-                g->Draw("P0");
-              } else {
-                g->Draw("surf1");
-              }
-              g->GetXaxis()->SetRangeUser(minX, maxX);
-              g->GetYaxis()->SetRangeUser(minX, maxX);
-              gPad->Update();
-            }
-          }
-        }
-
-        canv->Draw();
-        canv->SaveAs(Form("its3_sensor%d_%s.pdf", iSensor, axisName[iAxis]));
-      }
-    }
-  }
-
-  if constexpr (1) {
-    constexpr int nPoints{50};
-    constexpr int nPoints2{nPoints * nPoints};
-    constexpr double radL = o2::its3::constants::radii[2] + 0.3, zL = o2::its3::constants::segment::lengthSensitive / 2.0 + 2.0;
-
-    // Plot the whole geometry
-    std::array<TGraph2D*, 6> gIdeal;
-    std::array<TGraph2D*, 6> gDeformed;
-    constexpr double z1{-o2::its3::constants::segment::lengthSensitive / 2.0}, z2{o2::its3::constants::segment::lengthSensitive / 2.0}, zTot{z2 - z1}, zStep{zTot / (nPoints - 1)};
-    auto canv = new TCanvas();
-    canv->Divide(2, 1);
-    for (unsigned int iSensor{0}; iSensor < 6; ++iSensor) {
-      std::array<double, nPoints2> xi, yi, zi, xd, yd, zd;
-      const double radius = o2::its3::constants::radii[iSensor / 2];
-      const bool isTop = iSensor % 2 == 0;
-      const double phi1 = o2::math_utils::to02Pi(((isTop) ? 0.f : 1.f) * TMath::Pi() + std::asin(o2::its3::constants::equatorialGap / 2.f / radius));
-      const double phi2 = o2::math_utils::to02Pi(((isTop) ? 1.f : 2.f) * TMath::Pi() - std::asin(o2::its3::constants::equatorialGap / 2.f / radius));
-      const double phiTot{phi2 - phi1}, phiStep{phiTot / (nPoints - 1)};
-      for (int iZ{0}; iZ < nPoints; ++iZ) {
-        double z = z1 + iZ * zStep;
-        for (int iPhi{0}; iPhi < nPoints; ++iPhi) {
-          int i = iZ * nPoints + iPhi;
-          double phi = phi1 + iPhi * phiStep;
-
-          xi[i] = radius * std::cos(phi);
-          yi[i] = radius * std::sin(phi);
-          zi[i] = z;
-
-          const double u = ((phi - phi1) * 2.f) / phiTot - 1.f;
-          const double v = ((z - z1)) / zTot - 1.f;
-          const auto [dx, dy, dz] = def.getDeformation(iSensor, u, v);
-          xd[i] = xi[i] + dx * factor;
-          yd[i] = yi[i] + dy * factor;
-          zd[i] = zi[i] + dz * factor;
-        }
-      }
-
-      canv->cd(1);
-      auto ideal = new TGraph2D(Form("g_ideal_%d", iSensor), "Ideal Geometry", nPoints2, xi.data(), zi.data(), yi.data());
-      ideal->SetMarkerStyle(kFullCircle);
-      ideal->SetMarkerSize(1);
-      ideal->SetMarkerColor(kBlue);
-      ideal->SetLineColor(kBlue);
-      if (iSensor == 0) {
-        ideal->Draw("p0");
-      } else {
-        ideal->Draw("p0;same");
-        if (iSensor == 5) {
-          gPad->Update();
-          ideal->GetXaxis()->SetTitle("X");
-          ideal->GetYaxis()->SetTitle("Z");
-          ideal->GetZaxis()->SetTitle("Y");
-          ideal->GetXaxis()->SetRangeUser(-radL, radL);
-          ideal->GetZaxis()->SetRangeUser(-radL, radL);
-          ideal->GetYaxis()->SetRangeUser(-zL, zL);
-        }
-      }
-
-      canv->cd(2);
-      auto deformed = new TGraph2D(Form("g_def_%d", iSensor), "Deformed Geometry", nPoints2, xd.data(), zd.data(), yd.data());
-      deformed->SetMarkerStyle(kFullCircle);
-      deformed->SetMarkerSize(1);
-      deformed->SetMarkerColor(kRed);
-      deformed->SetLineColor(kRed);
-      if (iSensor == 0) {
-        deformed->Draw("p0");
-      } else {
-        deformed->Draw("p0;same");
-        if (iSensor == 5) {
-          gPad->Update();
-          deformed->GetXaxis()->SetTitle("X");
-          deformed->GetYaxis()->SetTitle("Z");
-          deformed->GetZaxis()->SetTitle("Y");
-          deformed->GetXaxis()->SetRangeUser(-radL, radL);
-          deformed->GetZaxis()->SetRangeUser(-radL, radL);
-          deformed->GetYaxis()->SetRangeUser(-zL, zL);
-        }
-      }
-    }
-
-    // Optionally find a deformation
-    /* if (findMin2D) { */
-    /*   std::vector<double> cccc(nOrder + 2, 0.0); */
-    /*   cccc[0] = nOrder; */
-    /*   for (int i{0}; i <= nOrder; ++i) { */
-    /*     for (int j{0}; j <= i; ++j) { */
-    /*       int k = i * (i + 1) / 2 + j; */
-    /*       cccc[1 + k] = coeff(i, j); */
-    /*     } */
-    /*   } */
-    /*   auto ig = legendre_poly2D_integral(cccc.data()); */
-
-    /*   gMin->Clear(); */
-    /*   ROOT::Math::Functor fmin(&legendre_poly2D_integral, */
-    /*                            2 + nOrder * (nOrder + 1) / 2 + nOrder); */
-    /*   Info("", "ig=%f    parameters=%d", ig, */
-    /*        2 + nOrder * (nOrder + 1) / 2 + nOrder); */
-    /*   gMin->SetFunction(fmin); */
-    /*   constexpr double minStep{0.001}; */
-    /*   gMin->SetFixedVariable(0, "nOrder", nOrder); */
-    /*   gMin->SetFixedVariable(1, "c_00", coeff(0, 0)); */
-    /*   for (int iOrder{1}; iOrder <= nOrder; ++iOrder) { */
-    /*     for (int jOrder{0}; jOrder <= iOrder; ++jOrder) { */
-    /*       int k = iOrder * (iOrder + 1) / 2 + jOrder + 1; */
-    /*       Info("", "Setting parameter %d", k); */
-    /*       if (getRandom() < 0.0) { */
-    /*         gMin->SetFixedVariable(k, Form("c_%d_%d", iOrder, jOrder), */
-    /*                                coeff(iOrder, jOrder)); */
-    /*       } else { */
-    /*         gMin->SetVariable(k, Form("c_%d_%d", iOrder, jOrder), */
-    /*                           coeff(iOrder, jOrder), minStep); */
-    /*       } */
-    /*     } */
-    /*   } */
-    /*   gMin->Minimize(); */
-    /*   return; */
-    /*   auto stat = gMin->Status(); */
-    /*   auto min = gMin->MinValue(); */
-    /*   if ((stat == 0 || stat == 1) && min < 0.01) { */
-    /*     Info("", "Minimizer converged with %f; using new values!", min); */
-    /*     const double *cmins = gMin->X(); */
-    /*     for (int iOrder{1}; iOrder <= nOrder; ++iOrder) { */
-    /*       for (int jOrder{0}; jOrder <= iOrder; ++jOrder) { */
-    /*         int k = iOrder * (iOrder + 1) / 2 + jOrder; */
-    /*         coeff(iOrder, jOrder) = cmins[k + 1]; */
-    /*       } */
-    /*     } */
-    /*   } */
-    /* } */
-  }
-}
diff --git a/Detectors/Upgrades/ITS3/macros/align/TestLegendrePol.C b/Detectors/Upgrades/ITS3/macros/align/TestLegendrePol.C
deleted file mode 100644
index 720ab80264838..0000000000000
--- a/Detectors/Upgrades/ITS3/macros/align/TestLegendrePol.C
+++ /dev/null
@@ -1,257 +0,0 @@
-// Copyright 2020-2022 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#if !defined(__CLING__) || defined(__ROOTCLING__)
-#include "Math/Factory.h"
-#include "Math/Minimizer.h"
-#include "TAxis.h"
-#include "TCanvas.h"
-#include "TGraph.h"
-#include "TGraph2D.h"
-#include "TLegend.h"
-#include "TMarker.h"
-#include "TMultiGraph.h"
-#include "TRandom.h"
-
-#include "MathUtils/LegendrePols.h"
-#endif
-
-static ROOT::Math::Minimizer* gMin;
-
-void TestLegendrePol(bool findMin1D = false, bool findMin2D = false)
-{
-  constexpr int nMaxOrder{2};
-  constexpr int nPoints{100};
-  constexpr int nPoints2{nPoints * nPoints};
-  constexpr double minX{-1.0}, maxX{1.0},
-    stepX{(maxX - minX) / static_cast<double>(nPoints)};
-
-  gRandom->SetSeed(0);
-  auto getRandom = []() {
-    constexpr double scale{80.e-4};
-    return scale * gRandom->Uniform(-1.0, 1.0);
-  };
-
-  if (findMin1D || findMin2D) {
-    gMin = ROOT::Math::Factory::CreateMinimizer("Minuit2", "Migrad");
-    if (gMin == nullptr) {
-      Error("", "Cannot create minimizer !");
-      return;
-    }
-    gMin->SetMaxFunctionCalls(1000000); // for Minuit/Minuit2
-    gMin->SetTolerance(0.00001);
-    gMin->SetPrintLevel(1);
-  }
-
-  { // 1D
-    Info("", "---------------- 1D -------------");
-    std::array<double, nPoints> x, y;
-    for (int nOrder{0}; nOrder <= nMaxOrder; ++nOrder) {
-      std::vector<double> coeff(nOrder + 1, 0.0);
-      std::generate(std::begin(coeff), std::end(coeff), getRandom);
-
-      o2::math_utils::Legendre1DPolynominal leg1D(coeff);
-
-      // Optionally find a deformation
-      if (findMin1D) {
-        std::vector<double> cccc(nOrder + 2, 0.0);
-        cccc[0] = nOrder;
-        for (int iOrder{0}; iOrder <= nOrder; ++iOrder) {
-          cccc[1 + iOrder] = coeff[iOrder];
-        }
-
-        gMin->Clear();
-        /* gMin->SetFunction(&leg1D.DoIntegralPar); */
-        constexpr double minStep{0.001};
-        gMin->SetFixedVariable(0, "c_0", coeff[0]);
-        for (int iOrder{1}; iOrder <= nOrder; ++iOrder) {
-          gMin->SetVariable(iOrder, Form("c_%d", iOrder), coeff[iOrder],
-                            minStep);
-        }
-        gMin->Minimize();
-        auto stat = gMin->Status();
-        auto min = gMin->MinValue();
-        if ((stat == 0 || stat == 1) && min < 0.01) {
-          Info("", "Minimizer converged with %f; using new values!", min);
-          const double* cmins = gMin->X();
-          for (int i{0}; i <= nOrder; ++i) {
-            Info("", "New values are c_%d=%.4f -> %.4f", i, coeff[i],
-                 cmins[1 + i]);
-            coeff[i] = cmins[1 + i];
-          }
-        }
-      }
-
-      auto c1d = new TCanvas(Form("c1D_%d", nOrder),
-                             Form("Legendre 1D Order %d", nOrder));
-      c1d->Divide(2, 1);
-
-      { // Draw total polynominal
-        for (int iPoint{0}; iPoint < nPoints; ++iPoint) {
-          double xcur = minX + iPoint * stepX;
-          x[iPoint] = xcur;
-          y[iPoint] = leg1D(xcur);
-        }
-        c1d->cd(2);
-        auto g = new TGraph(nPoints, x.data(), y.data());
-        g->SetName(Form("g1d_%d", nOrder));
-        g->SetTitle(Form("Legendre Polynominal %d-deg;u;w", nOrder));
-        g->Draw();
-      }
-
-      { // Draw single contributions
-        auto mg = new TMultiGraph();
-        auto leg = new TLegend();
-        for (int iOrder{0}; iOrder <= nOrder; ++iOrder) {
-          for (int iPoint{0}; iPoint < nPoints; ++iPoint) {
-            double xcur = minX + iPoint * stepX;
-            x[iPoint] = xcur;
-            y[iPoint] = leg1D(iOrder, xcur);
-          }
-          auto g = new TGraph(nPoints, x.data(), y.data());
-          g->SetName(Form("g1d_%d_%d", nOrder, iOrder));
-          g->SetTitle(Form("c_{%d}=%.4f;u;w", iOrder, coeff[iOrder]));
-          mg->Add(g, "PL");
-          leg->AddEntry(g, Form("c_{%d}=%.4f", iOrder, coeff[iOrder]), "lp");
-        }
-        c1d->cd(1);
-        mg->SetTitle("Contribution decomposition;u;w");
-        mg->Draw("A pmc plc");
-        leg->Draw();
-        gPad->Update();
-      }
-    }
-  }
-
-  { // 2D
-    Info("", "---------------- 2D -------------");
-    std::array<double, nPoints2> x, y, z;
-    for (int nOrder{0}; nOrder <= nMaxOrder; ++nOrder) {
-      auto c2d = new TCanvas(Form("c2D_%d", nOrder),
-                             Form("Legendre 2D Order %d", nOrder));
-      c2d->Divide(nOrder + 1, nOrder + 1);
-
-      TMatrixD coeff(nOrder + 1, nOrder + 1);
-      // Random initialization
-      for (int i{0}; i <= nOrder; ++i) {
-        for (int j{0}; j <= i; ++j) {
-          coeff(i, j) = getRandom();
-        }
-      }
-
-      o2::math_utils::Legendre2DPolynominal leg2D(coeff);
-
-      // Optionally find a deformation
-      /* if (findMin2D) { */
-      /*   std::vector<double> cccc(nOrder + 2, 0.0); */
-      /*   cccc[0] = nOrder; */
-      /*   for (int i{0}; i <= nOrder; ++i) { */
-      /*     for (int j{0}; j <= i; ++j) { */
-      /*       int k = i * (i + 1) / 2 + j; */
-      /*       cccc[1 + k] = coeff(i, j); */
-      /*     } */
-      /*   } */
-      /*   auto ig = legendre_poly2D_integral(cccc.data()); */
-
-      /*   gMin->Clear(); */
-      /*   ROOT::Math::Functor fmin(&legendre_poly2D_integral, */
-      /*                            2 + nOrder * (nOrder + 1) / 2 + nOrder); */
-      /*   Info("", "ig=%f    parameters=%d", ig, */
-      /*        2 + nOrder * (nOrder + 1) / 2 + nOrder); */
-      /*   gMin->SetFunction(fmin); */
-      /*   constexpr double minStep{0.001}; */
-      /*   gMin->SetFixedVariable(0, "nOrder", nOrder); */
-      /*   gMin->SetFixedVariable(1, "c_00", coeff(0, 0)); */
-      /*   for (int iOrder{1}; iOrder <= nOrder; ++iOrder) { */
-      /*     for (int jOrder{0}; jOrder <= iOrder; ++jOrder) { */
-      /*       int k = iOrder * (iOrder + 1) / 2 + jOrder + 1; */
-      /*       Info("", "Setting parameter %d", k); */
-      /*       if (getRandom() < 0.0) { */
-      /*         gMin->SetFixedVariable(k, Form("c_%d_%d", iOrder, jOrder), */
-      /*                                coeff(iOrder, jOrder)); */
-      /*       } else { */
-      /*         gMin->SetVariable(k, Form("c_%d_%d", iOrder, jOrder), */
-      /*                           coeff(iOrder, jOrder), minStep); */
-      /*       } */
-      /*     } */
-      /*   } */
-      /*   gMin->Minimize(); */
-      /*   return; */
-      /*   auto stat = gMin->Status(); */
-      /*   auto min = gMin->MinValue(); */
-      /*   if ((stat == 0 || stat == 1) && min < 0.01) { */
-      /*     Info("", "Minimizer converged with %f; using new values!", min); */
-      /*     const double *cmins = gMin->X(); */
-      /*     for (int iOrder{1}; iOrder <= nOrder; ++iOrder) { */
-      /*       for (int jOrder{0}; jOrder <= iOrder; ++jOrder) { */
-      /*         int k = iOrder * (iOrder + 1) / 2 + jOrder; */
-      /*         coeff(iOrder, jOrder) = cmins[k + 1]; */
-      /*       } */
-      /*     } */
-      /*   } */
-      /* } */
-
-      leg2D.printCoefficients();
-
-      { // Draw total polynominal
-        for (int iPoint{0}; iPoint < nPoints; ++iPoint) {
-          double xcur = minX + iPoint * stepX;
-          for (int jPoint{0}; jPoint < nPoints; ++jPoint) {
-            double ycur = minX + jPoint * stepX;
-            int i = iPoint * nPoints + jPoint;
-            x[i] = xcur;
-            y[i] = ycur;
-            z[i] = leg2D(xcur, ycur);
-          }
-        }
-        c2d->cd(nOrder + 1);
-        auto g = new TGraph2D(nPoints2, x.data(), y.data(), z.data());
-        g->SetTitle(Form("Legendre Polynominal %d-deg;u;v;w", nOrder));
-        g->SetName(Form("g2d_%d", nOrder));
-        g->Draw("surf1");
-        g->GetXaxis()->SetRangeUser(minX, maxX);
-        g->GetYaxis()->SetRangeUser(minX, maxX);
-        gPad->Update();
-      }
-
-      { // Draw decomposition of contributions to polynominal
-        for (int iOrder{0}; iOrder <= nOrder; ++iOrder) {
-          for (int jOrder{0}; jOrder <= iOrder; ++jOrder) {
-            for (int iPoint{0}; iPoint < nPoints; ++iPoint) {
-              double xcur = minX + iPoint * stepX;
-              for (int jPoint{0}; jPoint < nPoints; ++jPoint) {
-                double ycur = minX + jPoint * stepX;
-                int i = iPoint * nPoints + jPoint;
-                x[i] = xcur;
-                y[i] = ycur;
-                z[i] = leg2D(iOrder, jOrder, xcur, ycur);
-              }
-            }
-            c2d->cd(1 + iOrder * (nOrder + 1) + jOrder);
-            auto g = new TGraph2D(nPoints2, x.data(), y.data(), z.data());
-            g->SetTitle(Form("c_{%d,%d}=%.4f;u;v;w", iOrder, jOrder,
-                             coeff(iOrder, jOrder)));
-            g->SetName(Form("g2d_%d_%d_%d", nOrder, iOrder, jOrder));
-            if (iOrder == 0 && jOrder == 0) { // Fix display of constant value
-              g->Draw("P0");
-            } else {
-              g->Draw("surf1");
-            }
-            g->GetXaxis()->SetRangeUser(minX, maxX);
-            g->GetYaxis()->SetRangeUser(minX, maxX);
-            gPad->Update();
-          }
-        }
-      }
-      c2d->Draw();
-    }
-  }
-}
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
index fa15e73118524..d82cd26e63c56 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/IOUtils.h
@@ -14,12 +14,19 @@
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITS3Reconstruction/TopologyDictionary.h"
-#include "ITStracking/TimeFrame.h"
 #include "ITStracking/IOUtils.h"
 #include "ITS3Base/SegmentationMosaix.h"
 #include "ITS3Base/SpecsV2.h"
 
-namespace o2::its3::ioutils
+namespace o2
+{
+namespace its
+{
+template <int>
+class TimeFrame;
+}
+
+namespace its3::ioutils
 {
 constexpr float DefClusErrorRow = o2::its3::SegmentationMosaix::PitchRow * 0.5;
 constexpr float DefClusErrorCol = o2::its3::SegmentationMosaix::PitchCol * 0.5;
@@ -27,7 +34,7 @@ constexpr float DefClusError2Row = DefClusErrorRow * DefClusErrorRow;
 constexpr float DefClusError2Col = DefClusErrorCol * DefClusErrorCol;
 
 template <class iterator, typename T = float>
-o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, iterator& iter, const its3::TopologyDictionary* dict, T& sig2y, T& sig2z)
+o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, iterator& iter, const o2::its3::TopologyDictionary* dict, T& sig2y, T& sig2z)
 {
   auto pattID = c.getPatternID();
   auto ib = constants::detID::isDetITS3(c.getSensorID());
@@ -50,7 +57,7 @@ o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, i
 }
 
 template <class iterator, typename T = float>
-o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, iterator& iter, const its3::TopologyDictionary* dict, T& sig2y, T& sig2z, uint8_t& cls)
+o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, iterator& iter, const o2::its3::TopologyDictionary* dict, T& sig2y, T& sig2z, uint8_t& cls)
 {
   auto pattID = c.getPatternID();
   auto ib = constants::detID::isDetITS3(c.getSensorID());
@@ -69,13 +76,13 @@ o2::math_utils::Point3D<T> extractClusterData(const itsmft::CompClusterExt& c, i
 void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
                             gsl::span<const unsigned char>::iterator& pattIt,
                             std::vector<o2::BaseCluster<float>>& output,
-                            const its3::TopologyDictionary* dict);
+                            const o2::its3::TopologyDictionary* dict);
 
 int loadROFrameDataITS3(its::TimeFrame<7>* tf,
                         gsl::span<const o2::itsmft::ROFRecord> rofs,
                         gsl::span<const itsmft::CompClusterExt> clusters,
                         gsl::span<const unsigned char>::iterator& pattIt,
-                        const its3::TopologyDictionary* dict,
+                        const o2::its3::TopologyDictionary* dict,
                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
-
-} // namespace o2::its3::ioutils
+} // namespace its3::ioutils
+} // namespace o2
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index d7ba4d48dbce4..0fea07743b3df 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -10,18 +10,13 @@
 // or submit itself to any jurisdiction.
 
 #include "ITS3Reconstruction/IOUtils.h"
-#include "ITStracking/IOUtils.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/BoundedAllocator.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITS3Reconstruction/TopologyDictionary.h"
 #include "ITSBase/GeometryTGeo.h"
-#include "ITS3Base/SpecsV2.h"
 #include "ITStracking/TrackingConfigParam.h"
-#include "Framework/Logger.h"
-
-#include <limits>
 
 namespace o2::its3::ioutils
 {
@@ -45,16 +40,19 @@ void convertCompactClusters(gsl::span<const itsmft::CompClusterExt> clusters,
   }
 
   for (auto& c : clusters) {
-    float sigmaY2, sigmaZ2, sigmaYZ = 0;
+    float sigmaY2 = NAN, sigmaZ2 = NAN;
     auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2);
     const auto detID = c.getSensorID();
+    // NOTE: this is not consistent with the TRK definition below!
+    // There we put the alpha for everything cluster to its phi
+    // here we extract it from the middle of the tile
     auto& cl3d = output.emplace_back(detID, geom->getMatrixT2L(detID) ^ locXYZ); // local --> tracking
     if (applyMisalignment) {
-      auto lrID = geom->getLayer(detID);
+      const auto lrID = geom->getLayer(detID);
       sigmaY2 += conf.sysErrY2[lrID];
       sigmaZ2 += conf.sysErrZ2[lrID];
     }
-    cl3d.setErrors(sigmaY2, sigmaZ2, sigmaYZ);
+    cl3d.setErrors(sigmaY2, sigmaZ2, 0.f);
   }
 }
 
@@ -76,26 +74,36 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
   for (size_t iRof{0}; iRof < rofs.size(); ++iRof) {
     const auto& rof = rofs[iRof];
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {
-      auto& c = clusters[clusterId];
-      auto sensorID = c.getSensorID();
-      auto layer = geom->getLayer(sensorID);
+      const auto& c = clusters[clusterId];
+      const auto sensorID = c.getSensorID();
+      const auto layer = geom->getLayer(sensorID);
 
       float sigmaY2{0}, sigmaZ2{0}, sigmaYZ{0};
       uint8_t clusterSize{0};
-      auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2, clusterSize);
+      const auto locXYZ = extractClusterData(c, pattIt, dict, sigmaY2, sigmaZ2, clusterSize);
       clusterSizeVec.push_back(clusterSize);
 
       // Transformation to the local --> global
-      auto gloXYZ = geom->getMatrixL2G(sensorID) * locXYZ;
+      const auto gloXYZ = geom->getMatrixL2G(sensorID) * locXYZ;
 
       // Inverse transformation to the local --> tracking
-      o2::math_utils::Point3D<float> trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;
+      const o2::math_utils::Point3D<float> trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;
 
       // Tracking alpha angle
+      // We want that each cluster rotates its tracking frame to the clusters phi
+      // that way the track linearization around the measurement is less biases to the arc
+      // this means automatically that the measurement on the arc is at 0 for the curved layers
       float alpha = geom->getSensorRefAlpha(sensorID);
-
-      tf->addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), alpha,
-                                      std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
+      float x = trkXYZ.x(), y = trkXYZ.y();
+      if (constants::detID::isDetITS3(sensorID)) {
+        y = 0.f;
+        x = std::hypot(gloXYZ.x(), gloXYZ.y());
+        alpha = std::atan2(gloXYZ.y(), gloXYZ.x());
+      }
+      math_utils::detail::bringToPMPi(alpha); // alpha is defined on -Pi,Pi
+
+      tf->addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), x, alpha,
+                                      std::array<float, 2>{y, trkXYZ.z()},
                                       std::array<float, 3>{sigmaY2, sigmaYZ, sigmaZ2});
 
       /// Rotate to the global frame
@@ -103,7 +111,7 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
       tf->addClusterExternalIndexToLayer(layer, clusterId);
     }
     for (unsigned int iL{0}; iL < tf->getUnsortedClusters().size(); ++iL) {
-      tf->mROFramesClusters[iL][iRof + 1] = tf->getUnsortedClusters()[iL].size();
+      tf->mROFramesClusters[iL][iRof + 1] = (int)tf->getUnsortedClusters()[iL].size();
     }
   }
 
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
index 0d1deb77b7c2e..c7bb4dbe9b6ee 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/TopologyDictionary.cxx
@@ -255,5 +255,7 @@ TopologyDictionary* TopologyDictionary::loadFrom(const std::string& fname, const
 // Explicitly instaniate templates
 template math_utils::Point3D<float> TopologyDictionary::getClusterCoordinates<float>(const itsmft::CompClusterExt& cl) const;
 template math_utils::Point3D<float> TopologyDictionary::getClusterCoordinates<float>(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup);
+template math_utils::Point3D<double> TopologyDictionary::getClusterCoordinates<double>(const itsmft::CompClusterExt& cl) const;
+template math_utils::Point3D<double> TopologyDictionary::getClusterCoordinates<double>(const itsmft::CompClusterExt& cl, const itsmft::ClusterPattern& patt, bool isGroup);
 
 } // namespace o2::its3
diff --git a/Detectors/Upgrades/ITS3/study/CMakeLists.txt b/Detectors/Upgrades/ITS3/study/CMakeLists.txt
index 4bb1cbca7dcb0..314b21c529ebf 100644
--- a/Detectors/Upgrades/ITS3/study/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/study/CMakeLists.txt
@@ -17,12 +17,16 @@ o2_add_library(ITS3TrackingStudy
                        src/TrackingStudy.cxx
                        src/ParticleInfoExt.cxx
                PUBLIC_LINK_LIBRARIES O2::ITS3Workflow
+                                     O2::ITS3Align
                                      O2::GlobalTracking
                                      O2::GlobalTrackingWorkflowReaders
                                      O2::GlobalTrackingWorkflowHelpers
                                      O2::DataFormatsGlobalTracking
                                      O2::DetectorsVertexing
-                                     O2::SimulationDataFormat)
+                                     O2::SimulationDataFormat
+                                     Eigen3::Eigen
+                                     nlohmann_json::nlohmann_json
+)
 
 o2_target_root_dictionary(ITS3TrackingStudy
                           HEADERS include/ITS3TrackingStudy/ITS3TrackingStudyParam.h
diff --git a/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ITS3TrackingStudyParam.h b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ITS3TrackingStudyParam.h
index 2e718622daa90..1150dc19a1162 100644
--- a/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ITS3TrackingStudyParam.h
+++ b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/ITS3TrackingStudyParam.h
@@ -22,7 +22,7 @@ namespace o2::its3::study
 struct ITS3TrackingStudyParam : o2::conf::ConfigurableParamHelper<ITS3TrackingStudyParam> {
   /// general track selection
   float maxChi2{36};
-  float maxEta{1.0};
+  float maxEta{1.5};
   float minPt{0.1};
   float maxPt{1e2};
   /// PV selection
@@ -30,6 +30,8 @@ struct ITS3TrackingStudyParam : o2::conf::ConfigurableParamHelper<ITS3TrackingSt
   /// ITS track selection
   int minITSCls{7};
   bool refitITS{true}; // refit ITS track including the PV
+  bool useStableRef{true};
+  bool addPVAsCluster{true};
   /// TPC track selection
   int minTPCCls{110};
 
@@ -37,10 +39,18 @@ struct ITS3TrackingStudyParam : o2::conf::ConfigurableParamHelper<ITS3TrackingSt
   o2::base::PropagatorImpl<float>::MatCorrType CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT;
 
   /// studies
-  bool doDCA = true;
-  bool doDCARefit = true;
-  bool doPull = true;
+  bool doDCA = false;
+  bool doDCARefit = false;
+  bool doPull = false;
+  bool doResid = false;
   bool doMC = false;
+  bool doMisalignment = false;
+
+  // misalignment
+  std::string misAlgJson;       // json file containing to be applied misalignment
+  float misAlgExtCY[6] = {0.f}; // extra uncertainty on y
+  float misAlgExtCZ[6] = {0.f}; // extra uncertainty on z
+
   O2ParamDef(ITS3TrackingStudyParam, "ITS3TrackingStudyParam");
 };
 
diff --git a/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/TrackingStudy.h b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/TrackingStudy.h
index 065629058fd32..6d55dfc80aa8a 100644
--- a/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/TrackingStudy.h
+++ b/Detectors/Upgrades/ITS3/study/include/ITS3TrackingStudy/TrackingStudy.h
@@ -18,7 +18,7 @@
 namespace o2::its3::study
 {
 
-o2::framework::DataProcessorSpec getTrackingStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC);
+o2::framework::DataProcessorSpec getTrackingStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC, bool withPV);
 
 } // namespace o2::its3::study
 
diff --git a/Detectors/Upgrades/ITS3/study/macros/CMakeLists.txt b/Detectors/Upgrades/ITS3/study/macros/CMakeLists.txt
index aaf763888c5e0..a772913c51f15 100644
--- a/Detectors/Upgrades/ITS3/study/macros/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/study/macros/CMakeLists.txt
@@ -16,3 +16,11 @@ o2_add_test_root_macro(PlotDCA.C
 o2_add_test_root_macro(PlotPulls.C
                        PUBLIC_LINK_LIBRARIES O2::ITS3TrackingStudy
                        LABELS its COMPILE_ONLY)
+
+o2_add_test_root_macro(PlotResiduals.C
+                       PUBLIC_LINK_LIBRARIES O2::ITS3TrackingStudy
+                       LABELS its COMPILE_ONLY)
+
+o2_add_test_root_macro(PlotMisalignment.C
+                       PUBLIC_LINK_LIBRARIES O2::ITS3TrackingStudy
+                       LABELS its COMPILE_ONLY)
diff --git a/Detectors/Upgrades/ITS3/study/macros/PlotMisalignment.C b/Detectors/Upgrades/ITS3/study/macros/PlotMisalignment.C
new file mode 100644
index 0000000000000..5b9372bc3402e
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/macros/PlotMisalignment.C
@@ -0,0 +1,228 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <TFile.h>
+#include <TF1.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TProfile2D.h>
+#include <TCanvas.h>
+#include <TTree.h>
+#include <TStyle.h>
+#include <TMath.h>
+#include "ReconstructionDataFormats/Track.h"
+#include <cmath>
+#endif
+
+constexpr int kNLay = 8; // slots: PV(-1) + layers 0-6
+constexpr int kNVar = 2; // dY, dZ
+constexpr int kNPar = 5; // Y, Z, Snp, Tgl, Q2Pt
+// constexpr int kNPtBins = 6; // integrated + 5 differential
+// const float kPtEdges[kNPtBins] = {0., 0.3, 0.8, 2., 5., 10.};
+// const char* kPtLabels[kNPtBins] = {"", "0.0<p_{T}<0.3", "0.3<p_{T}<0.8", "0.8<p_{T}<2.0", "2.0<p_{T}<5.0", "5.0<p_{T}<10.0"};
+// const char* kPtTags[kNPtBins] = {"", "_pt0_3", "_pt3_8", "_pt8_20", "_pt20_50", "_pt50_100"};
+constexpr int kNPtBins = 1; // integrated + 5 differential
+const float kPtEdges[kNPtBins] = {0.};
+const char* kPtLabels[kNPtBins] = {""};
+const char* kPtTags[kNPtBins] = {""};
+const char* kVarNames[kNVar] = {"dY", "dZ"};
+const char* kVarTitles[kNVar] = {"d_{Y} (#mum)", "d_{Z} (#mum)"};
+const char* kParNames[kNPar] = {"Y", "Z", "Snp", "Tgl", "Q2Pt"};
+const int kCovIdx[kNPar] = {0, 2, 5, 9, 14};
+
+int getPtBin(float pt)
+{
+  for (int i = 0; i < kNPtBins - 1; i++) {
+    if (pt >= kPtEdges[i] && pt < kPtEdges[i + 1]) {
+      return i + 1; // 1-indexed, 0 = integrated
+    }
+  }
+  return -1;
+}
+
+void processTree(TFile* f, const char* treeName)
+{
+  auto* tree = f->Get<TTree>(treeName);
+  if (!tree) {
+    return;
+  }
+
+  // branch variables
+  float dY, dZ, phi, eta;
+  int lay;
+  auto* trk = new o2::track::TrackParCov;
+  auto* mcTrk = new o2::track::TrackPar;
+  tree->SetBranchAddress("dY", &dY);
+  tree->SetBranchAddress("dZ", &dZ);
+  tree->SetBranchAddress("phi", &phi);
+  tree->SetBranchAddress("eta", &eta);
+  tree->SetBranchAddress("lay", &lay);
+  tree->SetBranchAddress("trk", &trk);
+  tree->SetBranchAddress("mcTrk", &mcTrk);
+
+  // --- book histograms ---
+  // [ptBin][lay] for each plot type
+  // dY/dZ vs phi
+  TH2F* hVsPhi[kNVar][kNPtBins][kNLay];
+  // dY/dZ vs eta
+  TH2F* hVsEta[kNVar][kNPtBins][kNLay];
+  // profile2D phi vs eta
+  TProfile2D* hProf[kNVar][kNPtBins][kNLay];
+  // pulls
+  TH1F* hPull[kNPar][kNPtBins][kNLay];
+
+  for (int ipt = 0; ipt < kNPtBins; ipt++) {
+    for (int ilay = 0; ilay < kNLay; ilay++) {
+      for (int iv = 0; iv < kNVar; iv++) {
+        hVsPhi[iv][ipt][ilay] = new TH2F(
+          Form("%s_%s_phi%s_l%d", treeName, kVarNames[iv], kPtTags[ipt], ilay),
+          Form("Layer %d %s;#phi (rad);%s", ilay - 1, kPtLabels[ipt], kVarTitles[iv]),
+          100, 0, 2 * TMath::Pi(), 100, -100, 100);
+        hVsEta[iv][ipt][ilay] = new TH2F(
+          Form("%s_%s_eta%s_l%d", treeName, kVarNames[iv], kPtTags[ipt], ilay),
+          Form("Layer %d %s;#eta;%s", ilay - 1, kPtLabels[ipt], kVarTitles[iv]),
+          100, -1.5, 1.5, 100, -100, 100);
+        hProf[iv][ipt][ilay] = new TProfile2D(
+          Form("%s_%s_prof%s_l%d", treeName, kVarNames[iv], kPtTags[ipt], ilay),
+          Form("Layer %d %s;#phi (rad);#eta;#LT%s#GT", ilay - 1, kPtLabels[ipt], kVarTitles[iv]),
+          50, 0, 2 * TMath::Pi(), 50, -1.5, 1.5);
+      }
+      for (int ip = 0; ip < kNPar; ip++) {
+        hPull[ip][ipt][ilay] = new TH1F(
+          Form("%s_pull_%s%s_l%d", treeName, kParNames[ip], kPtTags[ipt], ilay),
+          Form("Layer %d %s;pull_{%s};counts", ilay - 1, kPtLabels[ipt], kParNames[ip]),
+          100, -5, 5);
+      }
+    }
+  }
+
+  // --- fill loop ---
+  const Long64_t nEntries = tree->GetEntries();
+  for (Long64_t i = 0; i < nEntries; i++) {
+    tree->GetEntry(i);
+    if (i % 100000 == 0) {
+      std::cout << "Progress: " << i << "/" << nEntries << " (" << (100.0 * i / nEntries) << "%)" << std::endl;
+    }
+
+    int ilay = lay + 1;
+    float pt = trk->getPt();
+    float dYum = dY * 10000.f;
+    float dZum = dZ * 10000.f;
+
+    // integrated (ipt=0) + differential
+    int iptDiff = getPtBin(pt);
+    for (int ipt : {0, iptDiff}) {
+      if (ipt < 0) {
+        continue;
+      }
+      for (int iv = 0; iv < kNVar; iv++) {
+        float val = (iv == 0) ? dYum : dZum;
+        hVsPhi[iv][ipt][ilay]->Fill(phi, val);
+        hVsEta[iv][ipt][ilay]->Fill(eta, val);
+        hProf[iv][ipt][ilay]->Fill(phi, eta, val);
+      }
+      for (int ip = 0; ip < kNPar; ip++) {
+        float sigma2 = trk->getDiagError2(ip);
+        if (sigma2 > 0) {
+          hPull[ip][ipt][ilay]->Fill((trk->getParam(ip) - mcTrk->getParam(ip)) / std::sqrt(sigma2));
+        }
+      }
+    }
+  }
+
+  // --- draw & save ---
+  auto drawSliceFits = [](TH2F* h) {
+    h->FitSlicesY(nullptr, 0, -1, 5);
+    auto* hMean = (TH1D*)gDirectory->Get(Form("%s_1", h->GetName()));
+    auto* hSigma = (TH1D*)gDirectory->Get(Form("%s_2", h->GetName()));
+    if (hMean && hSigma) {
+      for (auto* hh : {hMean, hSigma}) {
+        hh->SetMarkerStyle(20);
+        hh->SetMarkerSize(0.6);
+      }
+      hMean->SetMarkerColor(kRed);
+      hMean->SetLineColor(kRed);
+      hSigma->SetMarkerColor(kOrange + 1);
+      hSigma->SetLineColor(kOrange + 1);
+      hMean->Draw("same");
+      hSigma->Draw("same");
+    }
+  };
+
+  for (int ipt = 0; ipt < kNPtBins; ipt++) {
+    // dY/dZ vs phi
+    for (int iv = 0; iv < kNVar; iv++) {
+      auto* c = new TCanvas(Form("%s_%s_vs_phi%s", treeName, kVarNames[iv], kPtTags[ipt]),
+                            Form("%s vs #phi %s", kVarNames[iv], kPtLabels[ipt]), 800, 1600);
+      c->Divide(2, 4);
+      for (int ilay = 0; ilay < kNLay; ilay++) {
+        c->cd(ilay + 1);
+        gPad->SetRightMargin(0.13);
+        hVsPhi[iv][ipt][ilay]->Draw("col");
+        drawSliceFits(hVsPhi[iv][ipt][ilay]);
+      }
+      c->SaveAs(Form("%s.png", c->GetName()));
+    }
+
+    // dY/dZ vs eta
+    for (int iv = 0; iv < kNVar; iv++) {
+      auto* c = new TCanvas(Form("%s_%s_vs_eta%s", treeName, kVarNames[iv], kPtTags[ipt]),
+                            Form("%s vs #eta %s", kVarNames[iv], kPtLabels[ipt]), 800, 1600);
+      c->Divide(2, 4);
+      for (int ilay = 0; ilay < kNLay; ilay++) {
+        c->cd(ilay + 1);
+        gPad->SetRightMargin(0.13);
+        hVsEta[iv][ipt][ilay]->Draw("col");
+        drawSliceFits(hVsEta[iv][ipt][ilay]);
+      }
+      c->SaveAs(Form("%s.png", c->GetName()));
+    }
+
+    // profile2D
+    for (int iv = 0; iv < kNVar; iv++) {
+      auto* c = new TCanvas(Form("%s_%s_prof2d%s", treeName, kVarNames[iv], kPtTags[ipt]),
+                            Form("%s #phi vs #eta %s", kVarNames[iv], kPtLabels[ipt]), 800, 1600);
+      c->Divide(2, 4);
+      for (int ilay = 0; ilay < kNLay; ilay++) {
+        c->cd(ilay + 1);
+        gPad->SetRightMargin(0.15);
+        hProf[iv][ipt][ilay]->Draw("colz");
+        hProf[iv][ipt][ilay]->GetZaxis()->SetRangeUser(-100, 100);
+      }
+      c->SaveAs(Form("%s.png", c->GetName()));
+    }
+
+    // pulls
+    for (int ilay = 0; ilay < kNLay; ilay++) {
+      auto* c = new TCanvas(Form("%s_pulls_l%d%s", treeName, ilay, kPtTags[ipt]),
+                            Form("Pulls layer %d %s", ilay - 1, kPtLabels[ipt]), 1200, 800);
+      c->Divide(3, 2);
+      for (int ip = 0; ip < kNPar; ip++) {
+        c->cd(ip + 1);
+        hPull[ip][ipt][ilay]->Draw();
+        if (hPull[ip][ipt][ilay]->GetEntries() > 20) {
+          hPull[ip][ipt][ilay]->Fit("gaus", "Q");
+        }
+      }
+      c->SaveAs(Form("%s.png", c->GetName()));
+    }
+  }
+}
+
+void PlotMisalignment(const char* fname = "its3TrackStudy.root")
+{
+  gStyle->SetOptStat(0);
+  gStyle->SetOptFit(1);
+  auto f = TFile::Open(fname);
+  processTree(f, "idealRes");
+  processTree(f, "misRes");
+}
diff --git a/Detectors/Upgrades/ITS3/study/macros/PlotResiduals.C b/Detectors/Upgrades/ITS3/study/macros/PlotResiduals.C
new file mode 100644
index 0000000000000..e35fd4df125e5
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/study/macros/PlotResiduals.C
@@ -0,0 +1,70 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <TFile.h>
+#include <TF1.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TCanvas.h>
+#include <TTree.h>
+#endif
+
+void PlotResiduals(const char* fname = "its3TrackStudy.root")
+{
+  auto f = TFile::Open(fname);
+  auto res = f->Get<TTree>("res");
+
+  const int nLay = 8;
+  const int nVar = 6;
+  const char* vars[nVar] = {"dYInt", "dZInt", "dYIn", "dZIn", "dYOut", "dZOut"};
+  const char* titles[nVar] = {"d_{Y} (#mum) (weighted)", "d_{Z} (#mum) (weighted)", "d_{Y} (#mu) (inward)", "d_{Y} (#mu) (inward)", "d_{Y} (#mu) (outward)", "d_{Z} (#mu) (outward)"};
+
+  TCanvas* canvs[nVar];
+  for (int iv = 0; iv < nVar; iv++) {
+    canvs[iv] = new TCanvas(vars[iv], Form("%s residuals", vars[iv]), 800, 1600);
+    canvs[iv]->Divide(2, 4);
+  }
+
+  for (int iv = 0; iv < nVar; iv++) {
+    canvs[iv]->cd(0);
+    for (int lay = -1; lay <= 6; lay++) {
+      canvs[iv]->cd(lay + 2);
+      gPad->SetRightMargin(0.13);
+
+      TString hname = Form("h_%s_lay%d", vars[iv], lay + 1);
+      TString expr = Form("%s*10000:phi>>%s(100,0,6.283,100,-100,100)", vars[iv], hname.Data());
+      TString sel = Form("lay==%d", lay);
+      res->Draw(expr, sel, "col");
+
+      auto* h = (TH2F*)gDirectory->Get(hname);
+      h->SetTitle(Form("Layer %d ;#phi (rad);%s", lay, titles[iv]));
+      h->GetZaxis()->SetLabelSize(0.035);
+
+      // fit y-slices with gaussian
+      h->FitSlicesY(nullptr, 0, -1, 5);
+      auto* hMean = (TH1D*)gDirectory->Get(Form("%s_1", hname.Data()));
+      auto* hSigma = (TH1D*)gDirectory->Get(Form("%s_2", hname.Data()));
+
+      for (auto* hh : {hMean, hSigma}) {
+        hh->SetMarkerStyle(20);
+        hh->SetMarkerSize(0.6);
+      }
+      hMean->SetMarkerColor(kRed);
+      hMean->SetLineColor(kRed);
+      hSigma->SetMarkerColor(kOrange + 1);
+      hSigma->SetLineColor(kOrange + 1);
+      hMean->Draw("same");
+      hSigma->Draw("same");
+    }
+    canvs[iv]->SaveAs(Form("%s.png", canvs[iv]->GetName()));
+  }
+}
diff --git a/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx b/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
index cb1d7f381983d..4ce2c79cb23f1 100644
--- a/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
+++ b/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -11,9 +11,12 @@
 
 #include <vector>
 #include <cmath>
+#include <fstream>
 
 #include <TStopwatch.h>
 #include <TF1.h>
+#include <Eigen/Dense>
+#include <nlohmann/json.hpp>
 
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
@@ -35,6 +38,7 @@
 #include "ITS3Reconstruction/IOUtils.h"
 #include "ITS3TrackingStudy/ITS3TrackingStudyParam.h"
 #include "ITS3TrackingStudy/ParticleInfoExt.h"
+#include "ITS3Align/TrackFit.h"
 #include "ReconstructionDataFormats/DCA.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "ReconstructionDataFormats/PrimaryVertex.h"
@@ -43,6 +47,8 @@
 #include "SimulationDataFormat/MCEventLabel.h"
 #include "SimulationDataFormat/MCUtils.h"
 #include "Steer/MCKinematicsReader.h"
+#include "MathUtils/LegendrePols.h"
+#include "Framework/Logger.h"
 
 namespace o2::its3::study
 {
@@ -58,6 +64,10 @@ using T2VMap = std::unordered_map<GTrackID, size_t>;
 class TrackingStudySpec : public Task
 {
  public:
+  TrackingStudySpec(const TrackingStudySpec&) = delete;
+  TrackingStudySpec(TrackingStudySpec&&) = delete;
+  TrackingStudySpec& operator=(const TrackingStudySpec&) = delete;
+  TrackingStudySpec& operator=(TrackingStudySpec&&) = delete;
   TrackingStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC)
     : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC) {}
   ~TrackingStudySpec() final = default;
@@ -67,16 +77,19 @@ class TrackingStudySpec : public Task
   void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final;
 
  private:
-  void process(o2::globaltracking::RecoContainer& recoData);
+  void process();
   void updateTimeDependentParams(ProcessingContext& pc);
-  std::vector<o2::BaseCluster<float>> prepareITSClusters(const o2::globaltracking::RecoContainer& data) const;
-  bool selectTrack(GTrackID trkID, o2::globaltracking::RecoContainer& recoData, bool checkMCTruth = true) const;
-  T2VMap buildT2V(o2::globaltracking::RecoContainer& recoData, bool includeCont = false, bool requireMCMatch = true) const;
-  bool refitITSPVTrack(o2::globaltracking::RecoContainer& recoData, o2::track::TrackParCov& trFit, GTrackID gidx);
-  void doDCAStudy(o2::globaltracking::RecoContainer& recoData);
-  void doDCARefitStudy(o2::globaltracking::RecoContainer& recoData);
-  void doPullStudy(o2::globaltracking::RecoContainer& recoData);
-  void doMCStudy(o2::globaltracking::RecoContainer& recoData);
+  void prepareITSClusters();
+  bool selectTrack(GTrackID trkID, bool checkMCTruth = true) const;
+  T2VMap buildT2V(bool includeCont = false, bool requireMCMatch = true) const;
+  bool refitITSPVTrack(o2::track::TrackParCov& trFit, GTrackID gidx);
+
+  void doDCAStudy();
+  void doDCARefitStudy();
+  void doPullStudy();
+  void doMCStudy();
+  void doResidStudy();
+  void doMisalignmentStudy();
 
   struct TrackCounter {
     TrackCounter() = default;
@@ -126,14 +139,21 @@ class TrackingStudySpec : public Task
   };
   TrackCounter mTrackCounter;
 
+  using TrackingCluster = align::TrackingCluster<float>;
+  std::vector<TrackingCluster> mITScl;
+  std::span<const int> mITSclRef;
+
+  const ITS3TrackingStudyParam* mParams{nullptr};
   std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   bool mUseMC{false};
   GTrackID::mask_t mTracksSrc;
   o2::vertexing::PVertexer mVertexer;
-  o2::steer::MCKinematicsReader mcReader;                 // reader of MC information
+  o2::steer::MCKinematicsReader mMCReader;                // reader of MC information
   const o2::its3::TopologyDictionary* mITSDict = nullptr; // cluster patterns dictionary
+  o2::globaltracking::RecoContainer mRecoData;
+  std::array<o2::math_utils::Legendre2DPolynominal, 6> mDeformations; // one per sensorID (0-5)
 };
 
 void TrackingStudySpec::init(InitContext& ic)
@@ -144,17 +164,16 @@ void TrackingStudySpec::init(InitContext& ic)
   std::string dbgnm = maxLanes == 1 ? "its3TrackStudy.root" : fmt::format("its3TrackStudy_{}.root", lane);
   mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(dbgnm.c_str(), "recreate");
 
-  if (mUseMC && !mcReader.initFromDigitContext(o2::base::NameConf::getCollisionContextFileName())) {
+  if (mUseMC && !mMCReader.initFromDigitContext(o2::base::NameConf::getCollisionContextFileName())) {
     LOGP(fatal, "initialization of MCKinematicsReader failed");
   }
 }
 
 void TrackingStudySpec::run(ProcessingContext& pc)
 {
-  o2::globaltracking::RecoContainer recoData;
-  recoData.collectData(pc, *mDataRequest);
+  mRecoData.collectData(pc, *mDataRequest);
   updateTimeDependentParams(pc);
-  process(recoData);
+  process();
 }
 
 void TrackingStudySpec::updateTimeDependentParams(ProcessingContext& pc)
@@ -165,6 +184,30 @@ void TrackingStudySpec::updateTimeDependentParams(ProcessingContext& pc)
     auto grp = o2::base::GRPGeomHelper::instance().getGRPECS();
     mVertexer.init();
     o2::its::GeometryTGeo::Instance()->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2G));
+    mParams = &ITS3TrackingStudyParam::Instance();
+    if (mParams->doMisalignment) {
+      TMatrixD null(1, 1);
+      null(0, 0) = 0;
+      for (int i = 0; i < 6; ++i) {
+        mDeformations[i] = o2::math_utils::Legendre2DPolynominal(null);
+      }
+      if (!mParams->misAlgJson.empty()) {
+        using json = nlohmann::json;
+        std::ifstream f(mParams->misAlgJson);
+        auto data = json::parse(f);
+        for (const auto& item : data) {
+          int id = item["id"].get<int>();
+          auto v = item["matrix"].get<std::vector<std::vector<double>>>();
+          TMatrixD m(v.size(), v[v.size() - 1].size());
+          for (size_t r{0}; r < v.size(); ++r) {
+            for (size_t c{0}; c < v[r].size(); ++c) {
+              m(r, c) = v[r][c];
+            }
+          }
+          mDeformations[id] = o2::math_utils::Legendre2DPolynominal(m);
+        }
+      }
+    }
   }
 }
 
@@ -185,76 +228,105 @@ void TrackingStudySpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   }
 }
 
-void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
+void TrackingStudySpec::process()
 {
-  const auto& conf = ITS3TrackingStudyParam::Instance();
-  if (conf.doDCA) {
-    doDCAStudy(recoData);
+  prepareITSClusters();
+  if (mParams->doDCA) {
+    doDCAStudy();
+  }
+  if (mParams->doDCARefit) {
+    doDCARefitStudy();
+  }
+  if (mUseMC && mParams->doPull) {
+    doPullStudy();
   }
-  if (conf.doDCARefit) {
-    doDCARefitStudy(recoData);
+  if (mUseMC && mParams->doMC) {
+    doMCStudy();
   }
-  if (mUseMC && conf.doPull) {
-    doPullStudy(recoData);
+  if (mParams->doResid) {
+    doResidStudy();
   }
-  if (mUseMC && conf.doMC) {
-    doMCStudy(recoData);
+  if (mUseMC && mParams->doMisalignment) {
+    doMisalignmentStudy();
   }
 }
 
-std::vector<o2::BaseCluster<float>> TrackingStudySpec::prepareITSClusters(const o2::globaltracking::RecoContainer& data) const
+void TrackingStudySpec::prepareITSClusters()
 {
-  std::vector<o2::BaseCluster<float>> itscl;
-  const auto& clusITS = data.getITSClusters();
-  if (clusITS.size()) {
-    const auto& patterns = data.getITSClustersPatterns();
-    itscl.reserve(clusITS.size());
-    auto pattIt = patterns.begin();
-    o2::its3::ioutils::convertCompactClusters(clusITS, pattIt, itscl, mITSDict);
-  }
-  return std::move(itscl);
+  const auto& clusITS = mRecoData.getITSClusters();
+  LOGP(info, "Preparing {} measurments", clusITS.size());
+  const auto& patterns = mRecoData.getITSClustersPatterns();
+  mITScl.reserve(clusITS.size());
+  auto pattIt = patterns.begin();
+  auto geom = its::GeometryTGeo::Instance();
+  mITSclRef = mRecoData.getITSTracksClusterRefs();
+  mITScl.clear();
+  mITScl.reserve(clusITS.size());
+  for (const auto& cls : clusITS) {
+    const auto sens = cls.getSensorID();
+    float sigmaY2{0}, sigmaZ2{0};
+    math_utils::Point3D<float> locXYZ = o2::its3::ioutils::extractClusterData(cls, pattIt, mITSDict, sigmaY2, sigmaZ2);
+    // Transformation to the local --> global
+    const auto gloXYZ = geom->getMatrixL2G(sens) * locXYZ;
+    // Inverse transformation to the local --> tracking
+    o2::math_utils::Point3D<float> trkXYZ = geom->getMatrixT2L(sens) ^ locXYZ;
+    // Tracking alpha angle
+    // We want that each cluster rotates its tracking frame to the clusters phi
+    // that way the track linearization around the measurement is less biases to the arc
+    // this means automatically that the measurement on the arc is at 0 for the curved layers
+    float alpha = geom->getSensorRefAlpha(sens);
+    if (constants::detID::isDetITS3(sens)) {
+      trkXYZ.SetY(0.f);
+      // alpha&x always have to be defined wrt to the global Z axis!
+      trkXYZ.SetX(std::hypot(gloXYZ.x(), gloXYZ.y()));
+      alpha = std::atan2(gloXYZ.y(), gloXYZ.x());
+    }
+    auto& cl3d = mITScl.emplace_back(sens, trkXYZ);
+    cl3d.setErrors(sigmaY2, sigmaZ2, 0.f);
+    cl3d.alpha = alpha;
+    math_utils::detail::bringToPMPi(cl3d.alpha); // alpha is defined on -Pi,Pi
+  }
 }
 
-bool TrackingStudySpec::selectTrack(GTrackID trkID, o2::globaltracking::RecoContainer& recoData, bool checkMCTruth) const
+bool TrackingStudySpec::selectTrack(GTrackID trkID, bool checkMCTruth) const
 {
-  const auto& conf = ITS3TrackingStudyParam::Instance();
   if (!trkID.includesDet(GTrackID::ITS)) {
     return false;
   }
-  if (!recoData.isTrackSourceLoaded(trkID.getSource())) {
+  if (!mRecoData.isTrackSourceLoaded(trkID.getSource())) {
     return false;
   }
-  auto contributorsGID = recoData.getSingleDetectorRefs(trkID);
+  auto contributorsGID = mRecoData.getSingleDetectorRefs(trkID);
   if (!contributorsGID[GTrackID::ITS].isIndexSet()) { // we need of course ITS
     return false;
   }
   // ITS specific
-  const auto& itsTrk = recoData.getITSTrack(contributorsGID[GTrackID::ITS]);
-  if (itsTrk.getChi2() > conf.maxChi2 || itsTrk.getNClusters() < conf.minITSCls) {
+  const auto& itsTrk = mRecoData.getITSTrack(contributorsGID[GTrackID::ITS]);
+  if (itsTrk.getChi2() > mParams->maxChi2 || itsTrk.getNClusters() < mParams->minITSCls) {
     return false;
   }
   // TPC specific
   if (contributorsGID[GTrackID::TPC].isIndexSet()) {
-    const auto& tpcTrk = recoData.getTPCTrack(contributorsGID[GTrackID::TPC]);
-    if (tpcTrk.getNClusters() < conf.minTPCCls) {
+    const auto& tpcTrk = mRecoData.getTPCTrack(contributorsGID[GTrackID::TPC]);
+    if (tpcTrk.getNClusters() < mParams->minTPCCls) {
       return false;
     }
   }
   // general
-  const auto& gTrk = recoData.getTrackParam(trkID);
-  if (gTrk.getPt() < conf.minPt || gTrk.getPt() > conf.maxPt) {
+  const auto& gTrk = mRecoData.getTrackParam(trkID);
+  if (gTrk.getPt() < mParams->minPt || gTrk.getPt() > mParams->maxPt) {
     return false;
   }
-  if (std::abs(gTrk.getEta()) > conf.maxEta) {
+  if (std::abs(gTrk.getEta()) > mParams->maxEta) {
     return false;
   }
   if (mUseMC && checkMCTruth) {
-    const auto& itsLbl = recoData.getTrackMCLabel(contributorsGID[GTrackID::ITS]);
+    const auto& itsLbl = mRecoData.getTrackMCLabel(contributorsGID[GTrackID::ITS]);
     if (!itsLbl.isValid()) {
       return false;
     }
     if (contributorsGID[GTrackID::TPC].isIndexSet()) {
-      const auto& tpcLbl = recoData.getTrackMCLabel(contributorsGID[GTrackID::TPC]);
+      const auto& tpcLbl = mRecoData.getTrackMCLabel(contributorsGID[GTrackID::TPC]);
       if (itsLbl != tpcLbl) {
         return false;
       }
@@ -263,7 +335,7 @@ bool TrackingStudySpec::selectTrack(GTrackID trkID, o2::globaltracking::RecoCont
       // TODO
     }
     if (contributorsGID[GTrackID::TOF].isIndexSet()) {
-      const auto& tofLbls = recoData.getTOFClustersMCLabels()->getLabels(contributorsGID[GTrackID::TOF]);
+      const auto& tofLbls = mRecoData.getTOFClustersMCLabels()->getLabels(contributorsGID[GTrackID::TOF]);
       for (const auto& lbl : tofLbls) {
         if (lbl.isValid()) {
           return true;
@@ -274,22 +346,21 @@ bool TrackingStudySpec::selectTrack(GTrackID trkID, o2::globaltracking::RecoCont
   return true;
 }
 
-T2VMap TrackingStudySpec::buildT2V(o2::globaltracking::RecoContainer& recoData, bool includeCont, bool requireMCMatch) const
+T2VMap TrackingStudySpec::buildT2V(bool includeCont, bool requireMCMatch) const
 {
   // build track->vertex assoc., maybe including contributor tracks
-  const auto& conf = ITS3TrackingStudyParam::Instance();
-  auto pvvec = recoData.getPrimaryVertices();
-  auto trackIndex = recoData.getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
-  auto vtxRefs = recoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
-  auto nv = vtxRefs.size() - 1;                               // last entry is for unassigned tracks, ignore them
+  auto pvvec = mRecoData.getPrimaryVertices();
+  auto trackIndex = mRecoData.getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
+  auto vtxRefs = mRecoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
+  auto nv = vtxRefs.size() - 1;                                // last entry is for unassigned tracks, ignore them
   T2VMap t2v;
   for (size_t iv = 0; iv < nv; ++iv) {
     const auto& pv = pvvec[iv];
-    if (pv.getNContributors() - 1 < conf.minPVCont) {
+    if (pv.getNContributors() - 1 < mParams->minPVCont) {
       continue;
     }
     if (requireMCMatch) {
-      auto pvl = recoData.getPrimaryVertexMCLabel(iv);
+      auto pvl = mRecoData.getPrimaryVertexMCLabel(iv);
     }
     const auto& vtxRef = vtxRefs[iv];
     int it = vtxRef.getFirstEntry(), itLim = it + vtxRef.getEntries();
@@ -298,26 +369,26 @@ T2VMap TrackingStudySpec::buildT2V(o2::globaltracking::RecoContainer& recoData,
       if (tvid.isAmbiguous()) {
         continue;
       }
-      if (!recoData.isTrackSourceLoaded(tvid.getSource())) {
+      if (!mRecoData.isTrackSourceLoaded(tvid.getSource())) {
         continue;
       }
       if (mUseMC && requireMCMatch) {
-        const auto& pvlbl = recoData.getPrimaryVertexMCLabel(iv);
-        if (pvlbl.getEventID() != recoData.getTrackMCLabel(tvid).getEventID()) {
+        const auto& pvlbl = mRecoData.getPrimaryVertexMCLabel(iv);
+        if (pvlbl.getEventID() != mRecoData.getTrackMCLabel(tvid).getEventID()) {
           continue;
         }
       }
       t2v[tvid] = iv;
       if (includeCont) {
-        auto contributorsGID = recoData.getSingleDetectorRefs(tvid);
+        auto contributorsGID = mRecoData.getSingleDetectorRefs(tvid);
         for (int cis = 0; cis < GTrackID::NSources; cis++) {
           const auto cdm = GTrackID::getSourceDetectorsMask(cis);
-          if (!recoData.isTrackSourceLoaded(cis) || !cdm[DetID::ITS] || !contributorsGID[cis].isIndexSet()) {
+          if (!mRecoData.isTrackSourceLoaded(cis) || !cdm[DetID::ITS] || !contributorsGID[cis].isIndexSet()) {
             continue;
           }
           if (mUseMC && requireMCMatch) {
-            const auto& pvlbl = recoData.getPrimaryVertexMCLabel(iv);
-            if (pvlbl.getEventID() != recoData.getTrackMCLabel(contributorsGID[cis]).getEventID()) {
+            const auto& pvlbl = mRecoData.getPrimaryVertexMCLabel(iv);
+            if (pvlbl.getEventID() != mRecoData.getTrackMCLabel(contributorsGID[cis]).getEventID()) {
               continue;
             }
           }
@@ -329,19 +400,18 @@ T2VMap TrackingStudySpec::buildT2V(o2::globaltracking::RecoContainer& recoData,
   return std::move(t2v);
 }
 
-bool TrackingStudySpec::refitITSPVTrack(o2::globaltracking::RecoContainer& recoData, o2::track::TrackParCov& trFit, GTrackID gidx)
+bool TrackingStudySpec::refitITSPVTrack(o2::track::TrackParCov& trFit, GTrackID gidx)
 {
   if (gidx.getSource() != GTrackID::ITS) {
     return false;
   }
-  static auto pvvec = recoData.getPrimaryVertices();
-  static auto t2v = buildT2V(recoData, true, true);
-  static const auto itsClusters = prepareITSClusters(recoData);
+  static auto pvvec = mRecoData.getPrimaryVertices();
+  static auto t2v = buildT2V(true, true);
   static std::vector<unsigned int> itsTracksROF;
   if (static bool done{false}; !done) {
     done = true;
-    const auto& itsTracksROFRec = recoData.getITSTracksROFRecords();
-    itsTracksROF.resize(recoData.getITSTracks().size());
+    const auto& itsTracksROFRec = mRecoData.getITSTracksROFRecords();
+    itsTracksROF.resize(mRecoData.getITSTracks().size());
     for (unsigned irf = 0, cnt = 0; irf < itsTracksROFRec.size(); irf++) {
       int ntr = itsTracksROFRec[irf].getNEntries();
       for (int itr = 0; itr < ntr; itr++) {
@@ -350,20 +420,18 @@ bool TrackingStudySpec::refitITSPVTrack(o2::globaltracking::RecoContainer& recoD
     }
   }
   auto prop = o2::base::Propagator::Instance();
-  const auto& conf = ITS3TrackingStudyParam::Instance();
-  std::array<o2::BaseCluster<float>, 8> clArr{};
-  std::array<float, 8> clAlpha{};
-  const auto trkIn = recoData.getTrackParam(gidx);
-  const auto trkOut = recoData.getTrackParamOut(gidx);
-  const auto& itsTrOrig = recoData.getITSTrack(gidx);
+  std::array<const TrackingCluster*, 8> clArr{nullptr};
+  const auto trkIn = mRecoData.getTrackParam(gidx);
+  const auto trkOut = mRecoData.getTrackParamOut(gidx);
+  const auto& itsTrOrig = mRecoData.getITSTrack(gidx);
   int ncl = itsTrOrig.getNumberOfClusters(), rof = itsTracksROF[gidx.getIndex()];
-  const auto& itsTrackClusRefs = recoData.getITSTracksClusterRefs();
+  const auto& itsTrackClusRefs = mRecoData.getITSTracksClusterRefs();
   int clEntry = itsTrOrig.getFirstClusterEntry();
   const auto propagator = o2::base::Propagator::Instance();
   // convert PV to a fake cluster in the track DCA frame
   const auto& pv = pvvec[t2v[gidx]];
   auto trkPV = trkIn;
-  if (!prop->propagateToDCA(pv, trkPV, prop->getNominalBz(), 2.0, conf.CorrType)) {
+  if (!prop->propagateToDCA(pv, trkPV, prop->getNominalBz(), 2.0, mParams->CorrType)) {
     mTrackCounter -= gidx.getSource();
     return false;
   }
@@ -371,25 +439,25 @@ bool TrackingStudySpec::refitITSPVTrack(o2::globaltracking::RecoContainer& recoD
   float cosAlp = NAN, sinAlp = NAN;
   o2::math_utils::sincos(trkPV.getAlpha(), sinAlp, cosAlp);
   // vertex position rotated to track frame
-  clArr[0].setXYZ(pv.getX() * cosAlp + pv.getY() * sinAlp, -pv.getX() * sinAlp + pv.getY() * cosAlp, pv.getZ());
-  clArr[0].setSigmaY2(0.5 * (pv.getSigmaX2() + pv.getSigmaY2()));
-  clArr[0].setSigmaZ2(pv.getSigmaZ2());
-  clAlpha[0] = trkPV.getAlpha();
+  TrackingCluster pvCls;
+  pvCls.setXYZ((pv.getX() * cosAlp) + (pv.getY() * sinAlp), (-pv.getX() * sinAlp) + (pv.getY() * cosAlp), pv.getZ());
+  pvCls.setSigmaY2(0.5f * (pv.getSigmaX2() + pv.getSigmaY2()));
+  pvCls.setSigmaZ2(pv.getSigmaZ2());
+  clArr[0] = &pvCls;
   for (int icl = 0; icl < ncl; ++icl) { // ITS clusters are referred in layer decreasing order
-    clArr[ncl - icl] = itsClusters[itsTrackClusRefs[clEntry + icl]];
-    clAlpha[ncl - icl] = o2::its::GeometryTGeo::Instance()->getSensorRefAlpha(clArr[ncl - icl].getSensorID());
+    clArr[ncl - icl] = &mITScl[itsTrackClusRefs[clEntry + icl]];
   }
   // start refit
   trFit = trkOut;
   trFit.resetCovariance(1'000);
   float chi2{0};
   for (int icl = ncl; icl >= 0; --icl) { // go backwards
-    if (!trFit.rotate(clAlpha[icl]) || !prop->propagateToX(trFit, clArr[icl].getX(), prop->getNominalBz(), 0.85, 2.0, conf.CorrType)) {
+    if (!trFit.rotate(clArr[icl]->alpha) || !prop->propagateToX(trFit, clArr[icl]->getX(), prop->getNominalBz(), 0.85, 2.0, mParams->CorrType)) {
       mTrackCounter -= gidx.getSource();
       return false;
     }
-    chi2 += trFit.getPredictedChi2(clArr[icl]);
-    if (!trFit.update(clArr[icl])) {
+    chi2 += trFit.getPredictedChi2(*clArr[icl]);
+    if (!trFit.update(*clArr[icl])) {
       mTrackCounter -= gidx.getSource();
       return false;
     }
@@ -398,27 +466,26 @@ bool TrackingStudySpec::refitITSPVTrack(o2::globaltracking::RecoContainer& recoD
   return true;
 };
 
-void TrackingStudySpec::doDCAStudy(o2::globaltracking::RecoContainer& recoData)
+void TrackingStudySpec::doDCAStudy()
 {
   /// analyse DCA of impact parameter for different track types
   LOGP(info, "Doing DCA study");
   mTrackCounter.reset();
-  const auto& conf = ITS3TrackingStudyParam::Instance();
   auto prop = o2::base::Propagator::Instance();
   TStopwatch sw;
   sw.Start();
   int nDCAFits{0}, nDCAFitsFail{0};
-  auto pvvec = recoData.getPrimaryVertices();
-  auto trackIndex = recoData.getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
-  auto vtxRefs = recoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
-  auto nv = vtxRefs.size() - 1;                               // last entry is for unassigned tracks, ignore them
+  auto pvvec = mRecoData.getPrimaryVertices();
+  auto trackIndex = mRecoData.getPrimaryVertexMatchedTracks(); // Global ID's for associated tracks
+  auto vtxRefs = mRecoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
+  auto nv = vtxRefs.size() - 1;                                // last entry is for unassigned tracks, ignore them
   auto& stream = (*mDBGOut) << "dca";
   for (int iv = 0; iv < nv; iv++) {
     const auto& pv = pvvec[iv];
     const auto& vtref = vtxRefs[iv];
     for (int is = 0; is < GTrackID::NSources; is++) {
       const auto dm = GTrackID::getSourceDetectorsMask(is);
-      if (!recoData.isTrackSourceLoaded(is) || !dm[DetID::ITS]) {
+      if (!mRecoData.isTrackSourceLoaded(is) || !dm[DetID::ITS]) {
         mTrackCounter &= is;
         continue;
       }
@@ -432,23 +499,23 @@ void TrackingStudySpec::doDCAStudy(o2::globaltracking::RecoContainer& recoData)
 
         // we fit each different sub-track type, that include ITS, e.g.
         // ITS,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF
-        auto contributorsGID = recoData.getSingleDetectorRefs(vid);
+        auto contributorsGID = mRecoData.getSingleDetectorRefs(vid);
         for (int cis = 0; cis < GTrackID::NSources && cis <= is; cis++) {
           const auto cdm = GTrackID::getSourceDetectorsMask(cis);
-          if (!recoData.isTrackSourceLoaded(cis) || !cdm[DetID::ITS] || !contributorsGID[cis].isIndexSet()) {
+          if (!mRecoData.isTrackSourceLoaded(cis) || !cdm[DetID::ITS] || !contributorsGID[cis].isIndexSet()) {
             mTrackCounter &= cis;
             continue;
           }
-          if (!selectTrack(contributorsGID[cis], recoData)) {
+          if (!selectTrack(contributorsGID[cis])) {
             mTrackCounter &= vid.getSource();
             continue;
           }
 
           o2::dataformats::DCA dcaInfo;
-          const auto& trk = recoData.getTrackParam(contributorsGID[cis]);
+          const auto& trk = mRecoData.getTrackParam(contributorsGID[cis]);
           auto trkRefit = trk;
           // for ITS standalone tracks instead of having the trk at the pv we refit with the pv
-          if (conf.refitITS && cis == GTrackID::ITS && !refitITSPVTrack(recoData, trkRefit, contributorsGID[cis])) {
+          if (mParams->refitITS && cis == GTrackID::ITS && !refitITSPVTrack(trkRefit, contributorsGID[cis])) {
             mTrackCounter -= cis;
             continue;
           } else {
@@ -456,7 +523,7 @@ void TrackingStudySpec::doDCAStudy(o2::globaltracking::RecoContainer& recoData)
           };
 
           auto trkDCA = trk;
-          if (!prop->propagateToDCABxByBz(pv, trkDCA, 2.f, conf.CorrType, &dcaInfo)) {
+          if (!prop->propagateToDCABxByBz(pv, trkDCA, 2.f, mParams->CorrType, &dcaInfo)) {
             mTrackCounter -= cis;
             ++nDCAFitsFail;
             continue;
@@ -470,19 +537,19 @@ void TrackingStudySpec::doDCAStudy(o2::globaltracking::RecoContainer& recoData)
                  << "dca=" << dcaInfo;
 
           if (mUseMC) {
-            const auto& lbl = recoData.getTrackMCLabel(contributorsGID[cis]);
+            const auto& lbl = mRecoData.getTrackMCLabel(contributorsGID[cis]);
             lbl.print();
             o2::dataformats::DCA dcaInfoMC;
-            const auto& eve = mcReader.getMCEventHeader(lbl.getSourceID(), lbl.getEventID());
+            const auto& eve = mMCReader.getMCEventHeader(lbl.getSourceID(), lbl.getEventID());
             o2::dataformats::VertexBase mcEve;
             mcEve.setPos({(float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ()});
             auto trkC = trk;
-            if (!prop->propagateToDCABxByBz(mcEve, trkC, 2.f, conf.CorrType, &dcaInfoMC)) {
+            if (!prop->propagateToDCABxByBz(mcEve, trkC, 2.f, mParams->CorrType, &dcaInfoMC)) {
               mTrackCounter -= cis;
               ++nDCAFitsFail;
               continue;
             }
-            const auto& mcTrk = mcReader.getTrack(lbl);
+            const auto& mcTrk = mMCReader.getTrack(lbl);
             if (mcTrk == nullptr) {
               LOGP(fatal, "mcTrk is null did selection fail?");
             }
@@ -503,21 +570,20 @@ void TrackingStudySpec::doDCAStudy(o2::globaltracking::RecoContainer& recoData)
   mTrackCounter.print();
 }
 
-void TrackingStudySpec::doDCARefitStudy(o2::globaltracking::RecoContainer& recoData)
+void TrackingStudySpec::doDCARefitStudy()
 {
   /// analyse DCA of impact parameter for different track types while refitting the PV without the cand track
   LOGP(info, "Doing DCARefit study");
   mTrackCounter.reset();
-  const auto& conf = ITS3TrackingStudyParam::Instance();
   auto prop = o2::base::Propagator::Instance();
   TStopwatch sw;
   sw.Start();
 
   // build track->vertex assoc.
-  auto pvvec = recoData.getPrimaryVertices();
-  auto vtxRefs = recoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
-  auto nv = vtxRefs.size() - 1;                               // last entry is for unassigned tracks, ignore them
-  auto t2v = buildT2V(recoData);
+  auto pvvec = mRecoData.getPrimaryVertices();
+  auto vtxRefs = mRecoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
+  auto nv = vtxRefs.size() - 1;                                // last entry is for unassigned tracks, ignore them
+  auto t2v = buildT2V();
   std::vector<std::vector<GTrackID>> v2t;
   v2t.resize(nv);
   auto creator = [&](const auto& trk, GTrackID trkID, float _t0, float terr) -> bool {
@@ -531,11 +597,11 @@ void TrackingStudySpec::doDCARefitStudy(o2::globaltracking::RecoContainer& recoD
     }
     // general
     if constexpr (isBarrelTrack<decltype(trk)>()) {
-      if (trk.getPt() < conf.minPt || trk.getPt() > conf.maxPt) {
+      if (trk.getPt() < mParams->minPt || trk.getPt() > mParams->maxPt) {
         mTrackCounter &= trkID.getSource();
         return false;
       }
-      if (std::abs(trk.getEta()) > conf.maxEta) {
+      if (std::abs(trk.getEta()) > mParams->maxEta) {
         mTrackCounter &= trkID.getSource();
         return false;
       }
@@ -543,7 +609,7 @@ void TrackingStudySpec::doDCARefitStudy(o2::globaltracking::RecoContainer& recoD
         mTrackCounter &= trkID.getSource();
         return false;
       }
-      if (!selectTrack(trkID, recoData, mUseMC)) {
+      if (!selectTrack(trkID, mUseMC)) {
         mTrackCounter &= trkID.getSource();
         return false;
       }
@@ -551,20 +617,20 @@ void TrackingStudySpec::doDCARefitStudy(o2::globaltracking::RecoContainer& recoD
     v2t[t2v[trkID]].push_back(trkID);
     return true;
   };
-  recoData.createTracksVariadic(creator);
+  mRecoData.createTracksVariadic(creator);
 
   int nDCAFits{0}, nDCAFitsFail{0};
   auto& stream = (*mDBGOut) << "dcaRefit";
   for (size_t iv = 0; iv < nv; ++iv) {
     const auto& pv = pvvec[iv];
     const auto& trkIDs = v2t[iv];
-    if (trkIDs.size() - 1 < conf.minPVCont) {
+    if (trkIDs.size() - 1 < mParams->minPVCont) {
       continue;
     }
     std::vector<o2::track::TrackParCov> trks;
     trks.reserve(trkIDs.size());
     for (const auto& trkID : trkIDs) {
-      trks.push_back(recoData.getTrackParam(trkID));
+      trks.push_back(mRecoData.getTrackParam(trkID));
     }
 
     if (!mVertexer.prepareVertexRefit(trks, pv)) {
@@ -585,14 +651,14 @@ void TrackingStudySpec::doDCARefitStudy(o2::globaltracking::RecoContainer& recoD
       // check DCA both for refitted and original PV
       o2::dataformats::DCA dcaInfo;
       auto trkC = trks[it];
-      if (!prop->propagateToDCABxByBz(pv, trkC, 2.f, conf.CorrType, &dcaInfo)) {
+      if (!prop->propagateToDCABxByBz(pv, trkC, 2.f, mParams->CorrType, &dcaInfo)) {
         mTrackCounter -= trkIDs[it].getSource();
         ++nDCAFitsFail;
         continue;
       }
       o2::dataformats::DCA dcaInfoRefit;
       auto trkCRefit = trks[it];
-      if (!prop->propagateToDCABxByBz(pv, trkCRefit, 2.f, conf.CorrType, &dcaInfoRefit)) {
+      if (!prop->propagateToDCABxByBz(pv, trkCRefit, 2.f, mParams->CorrType, &dcaInfoRefit)) {
         mTrackCounter -= trkIDs[it].getSource();
         ++nDCAFitsFail;
         continue;
@@ -606,7 +672,7 @@ void TrackingStudySpec::doDCARefitStudy(o2::globaltracking::RecoContainer& recoD
              << "trkAtPVRefit=" << trkC
              << "dcaRefit=" << dcaInfoRefit;
       if (mUseMC) {
-        const auto& mcTrk = mcReader.getTrack(recoData.getTrackMCLabel(trkIDs[it]));
+        const auto& mcTrk = mMCReader.getTrack(mRecoData.getTrackMCLabel(trkIDs[it]));
         if (mcTrk == nullptr) {
           LOGP(fatal, "mcTrk is null did selection fail?");
         }
@@ -622,7 +688,7 @@ void TrackingStudySpec::doDCARefitStudy(o2::globaltracking::RecoContainer& recoD
   mTrackCounter.print();
 }
 
-void TrackingStudySpec::doPullStudy(o2::globaltracking::RecoContainer& recoData)
+void TrackingStudySpec::doPullStudy()
 {
   // check track pulls compared to mc generation
   LOGP(info, "Doing Pull study");
@@ -631,21 +697,20 @@ void TrackingStudySpec::doPullStudy(o2::globaltracking::RecoContainer& recoData)
   sw.Start();
   int nPulls{0}, nPullsFail{0};
   auto prop = o2::base::Propagator::Instance();
-  const auto& conf = ITS3TrackingStudyParam::Instance();
 
   auto checkInTrack = [&](GTrackID trkID) {
-    if (!selectTrack(trkID, recoData)) {
+    if (!selectTrack(trkID)) {
       mTrackCounter &= trkID.getSource();
       return;
     }
-    const auto mcTrk = mcReader.getTrack(recoData.getTrackMCLabel(trkID));
+    const auto mcTrk = mMCReader.getTrack(mRecoData.getTrackMCLabel(trkID));
     if (!mcTrk) {
       return;
     }
-    auto trk = recoData.getTrackParam(trkID);
+    auto trk = mRecoData.getTrackParam(trkID);
 
     // for ITS standalone tracks we add the PV as an additional measurement point
-    if (conf.refitITS && trkID.getSource() == GTrackID::ITS && !refitITSPVTrack(recoData, trk, trkID)) {
+    if (mParams->refitITS && trkID.getSource() == GTrackID::ITS && !refitITSPVTrack(trk, trkID)) {
       mTrackCounter -= trkID.getSource();
       ++nPullsFail;
       return;
@@ -666,8 +731,8 @@ void TrackingStudySpec::doPullStudy(o2::globaltracking::RecoContainer& recoData)
       ++nPullsFail;
       return;
     }
-    const auto contTrk = recoData.getSingleDetectorRefs(trkID);
-    const auto& itsTrk = recoData.getITSTrack(contTrk[GTrackID::ITS]);
+    const auto contTrk = mRecoData.getSingleDetectorRefs(trkID);
+    const auto& itsTrk = mRecoData.getITSTrack(contTrk[GTrackID::ITS]);
 
     (*mDBGOut)
       << "pull"
@@ -681,19 +746,19 @@ void TrackingStudySpec::doPullStudy(o2::globaltracking::RecoContainer& recoData)
     mTrackCounter += trkID.getSource();
   };
 
-  for (size_t iTrk{0}; iTrk < recoData.getITSTracks().size(); ++iTrk) {
+  for (size_t iTrk{0}; iTrk < mRecoData.getITSTracks().size(); ++iTrk) {
     checkInTrack(GTrackID(iTrk, GTrackID::ITS));
   }
-  for (size_t iTrk{0}; iTrk < recoData.getTPCITSTracks().size(); ++iTrk) {
+  for (size_t iTrk{0}; iTrk < mRecoData.getTPCITSTracks().size(); ++iTrk) {
     checkInTrack(GTrackID(iTrk, GTrackID::ITSTPC));
   }
-  for (size_t iTrk{0}; iTrk < recoData.getITSTPCTRDTracksMCLabels().size(); ++iTrk) {
+  for (size_t iTrk{0}; iTrk < mRecoData.getITSTPCTRDTracksMCLabels().size(); ++iTrk) {
     checkInTrack(GTrackID(iTrk, GTrackID::ITSTPCTRD));
   }
-  for (size_t iTrk{0}; iTrk < recoData.getITSTPCTOFMatches().size(); ++iTrk) {
+  for (size_t iTrk{0}; iTrk < mRecoData.getITSTPCTOFMatches().size(); ++iTrk) {
     checkInTrack(GTrackID(iTrk, GTrackID::ITSTPCTOF));
   }
-  for (size_t iTrk{0}; iTrk < recoData.getITSTPCTRDTOFMatches().size(); ++iTrk) {
+  for (size_t iTrk{0}; iTrk < mRecoData.getITSTPCTRDTOFMatches().size(); ++iTrk) {
     checkInTrack(GTrackID(iTrk, GTrackID::ITSTPCTRDTOF));
   }
   sw.Stop();
@@ -701,7 +766,7 @@ void TrackingStudySpec::doPullStudy(o2::globaltracking::RecoContainer& recoData)
   mTrackCounter.print();
 }
 
-void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
+void TrackingStudySpec::doMCStudy()
 {
   LOGP(info, "Doing MC study");
   mTrackCounter.reset();
@@ -710,12 +775,12 @@ void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
   int nTracks{0};
 
   const int iSrc{0};
-  const int nev = mcReader.getNEvents(iSrc);
+  const int nev = mMCReader.getNEvents(iSrc);
   std::unordered_map<o2::MCCompLabel, ParticleInfoExt> info;
 
   LOGP(info, "** Filling particle table ... ");
   for (int iEve{0}; iEve < nev; ++iEve) {
-    const auto& mcTrks = mcReader.getTracks(iSrc, iEve);
+    const auto& mcTrks = mMCReader.getTracks(iSrc, iEve);
     for (int iTrk{0}; iTrk < mcTrks.size(); ++iTrk) {
       const auto& mcTrk = mcTrks[iTrk];
       const auto pdg = mcTrk.GetPdgCode();
@@ -732,8 +797,8 @@ void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
     }
   }
   LOGP(info, "** Creating particle/clusters correspondence ... ");
-  const auto& clusters = recoData.getITSClusters();
-  const auto& clustersMCLCont = recoData.getITSClustersMCLabels();
+  const auto& clusters = mRecoData.getITSClusters();
+  const auto& clustersMCLCont = mRecoData.getITSClustersMCLabels();
   for (auto iCluster{0}; iCluster < clusters.size(); ++iCluster) {
     auto labs = clustersMCLCont->getLabels(iCluster);
     for (auto& lab : labs) {
@@ -755,7 +820,7 @@ void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
   LOGP(info, "** Analysing tracks ... ");
   auto accountLbl = [&](const globaltracking::RecoContainer::GlobalIDSet& contributorsGID, DetID::ID det) {
     if (contributorsGID[det].isIndexSet()) {
-      const auto& lbl = recoData.getTrackMCLabel(contributorsGID[det]);
+      const auto& lbl = mRecoData.getTrackMCLabel(contributorsGID[det]);
       if (lbl.isValid()) {
         o2::MCCompLabel iLbl(lbl.getTrackID(), lbl.getEventID(), lbl.getSourceID());
         if (info.contains(iLbl)) {
@@ -776,11 +841,11 @@ void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
       return false;
     }
     // general
-    auto contributorsGID = recoData.getSingleDetectorRefs(trkID);
+    auto contributorsGID = mRecoData.getSingleDetectorRefs(trkID);
     if (!contributorsGID[GTrackID::ITS].isIndexSet()) { // we need of course ITS
       return false;
     }
-    const auto& gLbl = recoData.getTrackMCLabel(trkID);
+    const auto& gLbl = mRecoData.getTrackMCLabel(trkID);
     if (!gLbl.isValid()) {
       return false;
     }
@@ -789,7 +854,7 @@ void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
       return false;
     }
     auto& part = info[iLbl];
-    part.recoTrack = recoData.getTrackParam(trkID);
+    part.recoTrack = mRecoData.getTrackParam(trkID);
 
     accountLbl(contributorsGID, DetID::ITS);
     accountLbl(contributorsGID, DetID::TPC);
@@ -799,7 +864,7 @@ void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
     ++nTracks;
     return true;
   };
-  recoData.createTracksVariadic(creator);
+  mRecoData.createTracksVariadic(creator);
 
   LOGP(info, "Streaming output to tree");
   for (const auto& [_, part] : info) {
@@ -812,7 +877,319 @@ void TrackingStudySpec::doMCStudy(o2::globaltracking::RecoContainer& recoData)
   LOGP(info, "doMCStudy: accounted {} MCParticles and {} tracks (in {:.2f} seconds)", info.size(), nTracks, sw.RealTime());
 }
 
-DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC)
+void TrackingStudySpec::doResidStudy()
+{
+  LOGP(info, "Doing residual study");
+  const auto geom = o2::its::GeometryTGeo::Instance();
+  const auto prop = o2::base::Propagator::Instance();
+  const float bz = prop->getNominalBz();
+
+  int goodRefit{0}, notPassedSel{0}, fitFail{0};
+
+  auto doRefits = [&](const o2::its::TrackITS& iTrack, const o2::MCCompLabel& lbl) {
+    std::array<TrackingCluster, 8> cl;
+    std::array<const TrackingCluster*, 8> clArr{nullptr};
+    if (mParams->addPVAsCluster) {
+      const auto& eve = mMCReader.getMCEventHeader(lbl.getSourceID(), lbl.getEventID());
+      dataformats::VertexBase pv;
+      auto trFitOut = iTrack.getParamIn();
+      pv.setXYZ(eve.GetX(), eve.GetY(), eve.GetZ());
+      if (!prop->propagateToDCA(pv, trFitOut, bz, base::Propagator::MAX_STEP, mParams->CorrType)) {
+        return;
+      }
+      pv.setSigmaX(20e-4f);
+      pv.setSigmaY(20e-4f);
+      pv.setSigmaZ(20e-4f);
+      float cosAlp = NAN, sinAlp = NAN;
+      o2::math_utils::sincos(trFitOut.getAlpha(), sinAlp, cosAlp);
+      cl[0].alpha = trFitOut.getAlpha();
+      cl[0].setXYZ((pv.getX() * cosAlp) + (pv.getY() * sinAlp), (-pv.getX() * sinAlp) + (pv.getY() * cosAlp), pv.getZ());
+      cl[0].setSigmaY2(0.5f * (pv.getSigmaX2() + pv.getSigmaY2()));
+      cl[0].setSigmaZ2(pv.getSigmaZ2());
+      cl[0].setSensorID(-1);
+      clArr[0] = &cl[0];
+    }
+
+    // collect track clusters into layer slots
+    int nCl = iTrack.getNClusters();
+    for (int i = 0; i < nCl; i++) {
+      const auto& curClu = mITScl[mITSclRef[iTrack.getClusterEntry(i)]];
+      int sens = curClu.getSensorID();
+      int llr = geom->getLayer(sens);
+      if (clArr[1 + llr]) {
+        LOGP(fatal, "Cluster at lr {} was already assigned, old sens {}, new sens {}", llr, clArr[1 + llr]->getSensorID(), sens);
+      }
+      clArr[1 + llr] = &curClu;
+    }
+
+    std::array<o2::track::TrackParCov, 8> extrapOut, extrapInw;
+    float chi2{0};
+    if (!align::doBidirRefit(iTrack, clArr, extrapOut, extrapInw, chi2, mParams->useStableRef, mParams->CorrType)) {
+      ++fitFail;
+      return;
+    }
+
+    for (int i = 0; i <= 7; i++) {
+      if (clArr[i]) {
+        const auto tInt = align::interpolateTrackParCov(extrapInw[i], extrapOut[i]);
+        if (!tInt.isValid()) {
+          continue;
+        }
+        auto phi = i == 0 ? tInt.getPhi() : tInt.getPhiPos();
+        o2::math_utils::bringTo02Pi(phi);
+        (*mDBGOut) << "res"
+                   << "dYInt=" << clArr[i]->getY() - tInt.getY()
+                   << "dZInt=" << clArr[i]->getZ() - tInt.getZ()
+                   << "dYIn=" << clArr[i]->getY() - extrapInw[i].getY()
+                   << "dZIn=" << clArr[i]->getZ() - extrapInw[i].getZ()
+                   << "dYOut=" << clArr[i]->getY() - extrapOut[i].getY()
+                   << "dZOut=" << clArr[i]->getZ() - extrapOut[i].getZ()
+                   << "chi2=" << chi2
+                   << "clY=" << clArr[i]->getY()
+                   << "clZ=" << clArr[i]->getZ()
+                   << "clX=" << clArr[i]->getX()
+                   << "alpha=" << clArr[i]->alpha
+                   << "sens=" << clArr[i]->getSensorID()
+                   << "phi=" << phi
+                   << "pt=" << tInt.getPt()
+                   << "chip=" << constants::detID::getSensorID(clArr[i]->getSensorID())
+                   << "lay=" << i - 1
+                   << "\n";
+      }
+    }
+    ++goodRefit;
+  };
+
+  const auto itsTracks = mRecoData.getITSTracks();
+  const auto itsMC = mRecoData.getITSTracksMCLabels();
+  for (size_t iTrk{0}; iTrk < itsTracks.size(); ++iTrk) {
+    const auto& iTrack = itsTracks[iTrk];
+    const auto& lbl = itsMC[iTrk];
+    const auto& mc = mMCReader.getTrack(lbl);
+    if (std::abs(iTrack.getEta()) > mParams->maxEta || iTrack.getChi2() > mParams->maxChi2 || iTrack.getNClusters() < mParams->minITSCls || iTrack.getPt() < mParams->minPt || !lbl.isCorrect() || !mc->isPrimary()) {
+      ++notPassedSel;
+      continue;
+    }
+    doRefits(iTrack, lbl);
+  }
+
+  LOGP(info, "\trefitted {} out of {} tracks ({} !sel, {} !fit)", goodRefit, itsTracks.size(), notPassedSel, fitFail);
+}
+
+void TrackingStudySpec::doMisalignmentStudy()
+{
+  LOGP(info, "Doing misalignment study");
+  const auto prop = o2::base::Propagator::Instance();
+  const auto geom = o2::its::GeometryTGeo::Instance();
+
+  int goodRefit{0}, notPassedSel{0}, fitFail{0}, fitFailMis{0};
+
+  // compute normalized (u,v) in [-1,1] from global position
+  auto computeUV = [](float gloX, float gloY, float gloZ, int sensorID, float radius) -> std::pair<double, double> {
+    const bool isTop = sensorID % 2 == 0;
+    const double phi = o2::math_utils::to02Pi(std::atan2(gloY, gloX));
+    const double phiBorder1 = o2::math_utils::to02Pi(((isTop ? 0. : 1.) * TMath::Pi()) + std::asin(constants::equatorialGap / 2. / radius));
+    const double phiBorder2 = o2::math_utils::to02Pi(((isTop ? 1. : 2.) * TMath::Pi()) - std::asin(constants::equatorialGap / 2. / radius));
+    const double u = (((phi - phiBorder1) * 2.) / (phiBorder2 - phiBorder1)) - 1.;
+    const double v = ((2. * gloZ + constants::segment::lengthSensitive) / constants::segment::lengthSensitive) - 1.;
+    return {u, v};
+  };
+
+  float chi2{0};
+  auto writeTree = [&](const char* treeName,
+                       const std::array<const TrackingCluster*, 8>& clArr,
+                       const std::array<o2::track::TrackParCov, 8>& extrapOut,
+                       const std::array<o2::track::TrackParCov, 8>& extrapInw,
+                       const o2::MCCompLabel& lbl) {
+    for (int i = 0; i <= 7; i++) {
+      if (!clArr[i]) {
+        continue;
+      }
+      // interpolated result
+      auto tInt = align::interpolateTrackParCov(extrapInw[i], extrapOut[i]);
+      if (!tInt.isValid()) {
+        continue;
+      }
+      float dY = clArr[i]->getY() - tInt.getY();
+      float dZ = clArr[i]->getZ() - tInt.getZ();
+      // MC truth at same (alpha, x)
+      o2::track::TrackPar mcTrkAtX;
+      const auto mcTrk = mMCReader.getTrack(lbl);
+      if (mcTrk) {
+        std::array<float, 3> xyz{(float)mcTrk->GetStartVertexCoordinatesX(), (float)mcTrk->GetStartVertexCoordinatesY(), (float)mcTrk->GetStartVertexCoordinatesZ()};
+        std::array<float, 3> pxyz{(float)mcTrk->GetStartVertexMomentumX(), (float)mcTrk->GetStartVertexMomentumY(), (float)mcTrk->GetStartVertexMomentumZ()};
+        TParticlePDG* pPDG = TDatabasePDG::Instance()->GetParticle(mcTrk->GetPdgCode());
+        if (pPDG) {
+          mcTrkAtX = o2::track::TrackPar(xyz, pxyz, TMath::Nint(pPDG->Charge() / 3), false);
+          if (mcTrkAtX.rotate(tInt.getAlpha()) && prop->PropagateToXBxByBz(mcTrkAtX, tInt.getX())) {
+            auto phi = i == 0 ? tInt.getPhi() : tInt.getPhiPos();
+            o2::math_utils::bringTo02Pi(phi);
+            (*mDBGOut) << treeName
+                       << "trk=" << tInt
+                       << "mcTrk=" << mcTrkAtX
+                       << "chi2=" << chi2
+                       << "dY=" << dY
+                       << "dZ=" << dZ
+                       << "phi=" << phi
+                       << "eta=" << tInt.getEta()
+                       << "lay=" << i - 1
+                       << "\n";
+          }
+        }
+      }
+    }
+  };
+
+  const auto itsTracks = mRecoData.getITSTracks();
+  const auto itsMC = mRecoData.getITSTracksMCLabels();
+  for (size_t iTrk{0}; iTrk < itsTracks.size(); ++iTrk) {
+    const auto& iTrack = itsTracks[iTrk];
+    if (std::abs(iTrack.getEta()) > mParams->maxEta || iTrack.getChi2() > mParams->maxChi2 || iTrack.getNClusters() < mParams->minITSCls || iTrack.getPt() < mParams->minPt) {
+      ++notPassedSel;
+      continue;
+    }
+    const auto& lbl = itsMC[iTrk];
+    if (!lbl.isCorrect() || !lbl.isValid()) {
+      ++notPassedSel;
+      continue;
+    }
+    const auto& mc = mMCReader.getTrack(lbl);
+    if (!mc->isPrimary()) {
+      ++notPassedSel;
+      continue;
+    }
+
+    // ideal clusters
+    std::array<TrackingCluster, 8> cl;
+    std::array<const TrackingCluster*, 8> clArr{nullptr};
+    if (mParams->addPVAsCluster) {
+      const auto& eve = mMCReader.getMCEventHeader(lbl.getSourceID(), lbl.getEventID());
+      dataformats::VertexBase pv;
+      auto trFitOut = iTrack.getParamIn();
+      pv.setXYZ(eve.GetX(), eve.GetY(), eve.GetZ());
+      if (!prop->propagateToDCA(pv, trFitOut, prop->getNominalBz(), base::Propagator::MAX_STEP, mParams->CorrType)) {
+        return;
+      }
+      pv.setSigmaX(20e-4f);
+      pv.setSigmaY(20e-4f);
+      pv.setSigmaZ(20e-4f);
+      float cosAlp = NAN, sinAlp = NAN;
+      o2::math_utils::sincos(trFitOut.getAlpha(), sinAlp, cosAlp);
+      cl[0].alpha = trFitOut.getAlpha();
+      cl[0].setXYZ((pv.getX() * cosAlp) + (pv.getY() * sinAlp), (-pv.getX() * sinAlp) + (pv.getY() * cosAlp), pv.getZ());
+      cl[0].setSigmaY2(0.5f * (pv.getSigmaX2() + pv.getSigmaY2()));
+      cl[0].setSigmaZ2(pv.getSigmaZ2());
+      cl[0].setSensorID(-1);
+      clArr[0] = &cl[0];
+    }
+
+    // collect track clusters into layer slots
+    int nCl = iTrack.getNClusters();
+    for (int i = 0; i < nCl; i++) {
+      const auto& curClu = mITScl[mITSclRef[iTrack.getClusterEntry(i)]];
+      int sens = curClu.getSensorID();
+      int llr = geom->getLayer(sens);
+      if (clArr[1 + llr]) {
+        LOGP(fatal, "Cluster at lr {} was already assigned, old sens {}, new sens {}", llr, clArr[1 + llr]->getSensorID(), sens);
+      }
+      clArr[1 + llr] = &curClu;
+    }
+    std::array<o2::track::TrackParCov, 8> extrapOut, extrapInw;
+    chi2 = 0;
+    if (!align::doBidirRefit(iTrack, clArr, extrapOut, extrapInw, chi2, mParams->useStableRef, mParams->CorrType)) {
+      ++fitFail;
+      continue;
+    }
+    writeTree("idealRes", clArr, extrapOut, extrapInw, lbl);
+
+    // Propagate MC truth to each cluster's (alpha, x) to get true track direction,
+    // then compute dy = dydx*h(u,v), dz = dzdx*h(u,v) - first Newton step.
+    const auto mcTrk = mMCReader.getTrack(lbl);
+    if (!mcTrk) {
+      continue;
+    }
+    std::array<float, 3> xyz{(float)mcTrk->GetStartVertexCoordinatesX(), (float)mcTrk->GetStartVertexCoordinatesY(), (float)mcTrk->GetStartVertexCoordinatesZ()};
+    std::array<float, 3> pxyz{(float)mcTrk->GetStartVertexMomentumX(), (float)mcTrk->GetStartVertexMomentumY(), (float)mcTrk->GetStartVertexMomentumZ()};
+    TParticlePDG* pPDG = TDatabasePDG::Instance()->GetParticle(mcTrk->GetPdgCode());
+    if (!pPDG) {
+      continue;
+    }
+    o2::track::TrackPar mcPar(xyz, pxyz, TMath::Nint(pPDG->Charge() / 3), false);
+
+    std::array<TrackingCluster, 3> misClArr; // shifted copies for up to 3 IT3 layers
+    std::array<const TrackingCluster*, 8> clArrMis{};
+    for (int i = 0; i <= 7; i++) {
+      clArrMis[i] = clArr[i]; // PV and OB clusters stay the same
+    }
+    for (int iLay = 0; iLay < 3; ++iLay) {
+      if (!clArr[1 + iLay]) {
+        continue;
+      }
+      const auto& orig = *clArr[1 + iLay];
+      const int sens = orig.getSensorID();
+      if (!constants::detID::isDetITS3(sens)) {
+        continue;
+      }
+      const int sensorID = constants::detID::getSensorID(sens);
+      const int layerID = constants::detID::getDetID2Layer(sens);
+
+      // compute h(u,v) at this cluster
+      const float r = orig.getX();
+      const float gloX = r * std::cos(orig.alpha);
+      const float gloY = r * std::sin(orig.alpha);
+      const float gloZ = orig.getZ();
+      auto [u, v] = computeUV(gloX, gloY, gloZ, sensorID, constants::radii[layerID]);
+      const double h = mDeformations[sensorID](u, v);
+
+      // propagate MC track to cluster's tracking frame to get true slopes
+      auto mcAtCl = mcPar;
+      if (!mcAtCl.rotate(orig.alpha) || !prop->PropagateToXBxByBz(mcAtCl, orig.getX())) {
+        clArrMis[1 + iLay] = nullptr; // can't compute slopes -> drop cluster
+        continue;
+      }
+      const float snp = mcAtCl.getSnp();
+      const float tgl = mcAtCl.getTgl();
+      const float csci = 1.f / std::sqrt(1.f - (snp * snp));
+      const float dydx = snp * csci;
+      const float dzdx = tgl * csci;
+      const float dy = dydx * static_cast<float>(h);
+      const float dz = dzdx * static_cast<float>(h);
+
+      // check if shifted position is still within sensor acceptance
+      const float newGloY = (r * std::sin(orig.alpha)) + (dy * std::cos(orig.alpha));
+      const float newGloX = (r * std::cos(orig.alpha)) - (dy * std::sin(orig.alpha));
+      const float newGloZ = gloZ + dz;
+      auto [uNew, vNew] = computeUV(newGloX, newGloY, newGloZ, sensorID, constants::radii[layerID]);
+      if (std::abs(uNew) > 1. || std::abs(vNew) > 1.) {
+        clArrMis[1 + iLay] = nullptr; // shifted outside acceptance
+        continue;
+      }
+
+      // create shifted copy: keep x=r (nominal), shift y and z
+      misClArr[iLay] = orig;
+      misClArr[iLay].setY(orig.getY() + dy);
+      misClArr[iLay].setZ(orig.getZ() + dz);
+      misClArr[iLay].setSigmaY2(orig.getSigmaY2() + (mParams->misAlgExtCY[sensorID] * mParams->misAlgExtCY[sensorID]));
+      misClArr[iLay].setSigmaZ2(orig.getSigmaZ2() + (mParams->misAlgExtCZ[sensorID] * mParams->misAlgExtCZ[sensorID]));
+      clArrMis[1 + iLay] = &misClArr[iLay];
+    }
+
+    // refit with shifted clusters
+    chi2 = 0;
+    if (!align::doBidirRefit(iTrack, clArrMis, extrapOut, extrapInw, chi2, mParams->useStableRef, mParams->CorrType)) {
+      ++fitFailMis;
+      ++goodRefit; // ideal still succeeded
+      continue;
+    }
+    writeTree("misRes", clArrMis, extrapOut, extrapInw, lbl);
+
+    ++goodRefit;
+  }
+
+  LOGP(info, "\tdoMisalignmentStudy: refitted {} out of {} tracks ({} !sel, {} !fit, {} !fitMis)", goodRefit, itsTracks.size(), notPassedSel, fitFail, fitFailMis);
+}
+
+DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC, bool withPV)
 {
   std::vector<OutputSpec> outputs;
   auto dataRequest = std::make_shared<DataRequest>();
@@ -820,7 +1197,9 @@ DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mas
   dataRequest->requestTracks(srcTracks, useMC);
   dataRequest->requestIT3Clusters(useMC);
   dataRequest->requestClusters(srcClusters, useMC);
-  dataRequest->requestPrimaryVertices(useMC);
+  if (withPV) {
+    dataRequest->requestPrimaryVertices(useMC);
+  }
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
                                                               true,                              // GRPECS=true
                                                               true,                              // GRPLHCIF
diff --git a/Detectors/Upgrades/ITS3/study/src/its3-tracking-study-workflow.cxx b/Detectors/Upgrades/ITS3/study/src/its3-tracking-study-workflow.cxx
index e0a0aea1c368a..482ef2bb71e1d 100644
--- a/Detectors/Upgrades/ITS3/study/src/its3-tracking-study-workflow.cxx
+++ b/Detectors/Upgrades/ITS3/study/src/its3-tracking-study-workflow.cxx
@@ -39,6 +39,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation"}},
     {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of track sources to use"}},
     {"cluster-sources", VariantType::String, "ITS,TRD,TOF", {"comma-separated list of cluster sources to use"}},
+    {"without-pv", VariantType::Bool, false, {"do not use the PV as an additional fit point"}},
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
@@ -58,14 +59,17 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
   auto useMC = !configcontext.options().get<bool>("disable-mc");
+  auto usePV = !configcontext.options().get<bool>("without-pv");
 
   GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
   GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(configcontext.options().get<std::string>("cluster-sources"));
 
   o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC);
-  o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC);
+  if (usePV) {
+    o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC);
+  }
 
-  specs.emplace_back(o2::its3::study::getTrackingStudySpec(srcTrc, srcCls, useMC));
+  specs.emplace_back(o2::its3::study::getTrackingStudySpec(srcTrc, srcCls, useMC, usePV));
 
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
 
diff --git a/Steer/DigitizerWorkflow/CMakeLists.txt b/Steer/DigitizerWorkflow/CMakeLists.txt
index 6b31550c83636..10e8dc2b13995 100644
--- a/Steer/DigitizerWorkflow/CMakeLists.txt
+++ b/Steer/DigitizerWorkflow/CMakeLists.txt
@@ -68,7 +68,6 @@ o2_add_executable(digitizer-workflow
                                         O2::DetectorsRaw
                                         $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3Simulation>
                                         $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3Workflow>
-                                        $<$<BOOL:${ENABLE_UPGRADES}>:O2::ITS3Align>
                                         $<$<BOOL:${ENABLE_UPGRADES}>:O2::TRKSimulation>
                                         $<$<BOOL:${ENABLE_UPGRADES}>:O2::TRKWorkflow>)
 
diff --git a/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
index 639203bdd6d38..60a1660288b9d 100644
--- a/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
@@ -31,7 +31,6 @@
 #include "ITSMFTBase/DPLAlpideParam.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITS3Base/ITS3Params.h"
-#include "ITS3Align/MisalignmentManager.h"
 
 #include <TChain.h>
 #include <TStopwatch.h>
@@ -79,11 +78,6 @@ class ITS3DPLDigitizerTask : BaseDPLDigitizer
     }
     updateTimeDependentParams(pc);
 
-    if (ITS3Params::Instance().applyMisalignmentHits) {
-      LOGP(info, "Applying misalignment to ITS3 Hits");
-      o2::its3::align::MisalignmentManager::misalignHits();
-    }
-
     // read collision context from input
     auto context = pc.inputs().get<o2::steer::DigitizationContext*>("collisioncontext");
     context->initSimChains(mID, mSimChains);

From 5ca454afeb0f9689f14dd46c252e7965ddfd6bf5 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 27 Mar 2026 13:46:12 +0100
Subject: [PATCH 1482/1764] Proter time-slice calibration from stray TFs

The TFs with bogus orbit, creation time or orbit<tfCounter will be discared when
filling calibration slots.
---
 .../common/include/CommonDataFormat/TFIDInfo.h     |  4 +++-
 Detectors/Base/src/TFIDInfoHelper.cxx              | 14 ++++----------
 .../DetectorsCalibration/TimeSlotCalibration.h     |  9 +++++++++
 Detectors/PHOS/calib/src/PHOSEnergyCalibDevice.cxx |  1 +
 .../PHOS/calib/src/PHOSL1phaseCalibDevice.cxx      |  2 +-
 .../PHOS/calib/src/PHOSRunbyrunCalibDevice.cxx     |  1 +
 Detectors/PHOS/calib/src/PHOSTurnonCalibDevice.cxx |  2 +-
 7 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/DataFormats/common/include/CommonDataFormat/TFIDInfo.h b/DataFormats/common/include/CommonDataFormat/TFIDInfo.h
index 2a41a4e725781..9628b38b95fa3 100644
--- a/DataFormats/common/include/CommonDataFormat/TFIDInfo.h
+++ b/DataFormats/common/include/CommonDataFormat/TFIDInfo.h
@@ -29,6 +29,7 @@ struct TFIDInfo { // helper info to patch DataHeader
   uint32_t runNumber = -1U;
   uint32_t startTime = -1U; // same as timeslot
   uint64_t creation = -1UL;
+  bool discard = false;
 
   bool isDummy() { return tfCounter == -1U; }
   void fill(uint32_t firstTForbit_, uint32_t tfCounter_, uint32_t runNumber_, uint32_t startTime_, uint64_t creation_)
@@ -38,9 +39,10 @@ struct TFIDInfo { // helper info to patch DataHeader
     runNumber = runNumber_;
     startTime = startTime_;
     creation = creation_;
+    discard = (firstTForbit < tfCounter) || firstTForbit == -1U || creation == -1;
   }
 
-  ClassDefNV(TFIDInfo, 2);
+  ClassDefNV(TFIDInfo, 3);
 };
 } // namespace dataformats
 } // namespace o2
diff --git a/Detectors/Base/src/TFIDInfoHelper.cxx b/Detectors/Base/src/TFIDInfoHelper.cxx
index f0bd8c0f15a30..6eac1cc18c81a 100644
--- a/Detectors/Base/src/TFIDInfoHelper.cxx
+++ b/Detectors/Base/src/TFIDInfoHelper.cxx
@@ -23,15 +23,9 @@ void o2::base::TFIDInfoHelper::fillTFIDInfo(ProcessingContext& pc, o2::dataforma
 {
   const auto& tinfo = pc.services().get<o2::framework::TimingInfo>();
   static int errCount = 0;
-  if (tinfo.firstTForbit == -1U || tinfo.creation == -1) {
-    if (errCount++ < 5) {
-      LOGP(warn, "Ignoring dummy input with orbit {} and creation time {} in fillTFIDInfo", tinfo.firstTForbit, tinfo.creation);
-    }
-    return;
+  ti.fill(tinfo.firstTForbit, tinfo.tfCounter, tinfo.runNumber, tinfo.timeslice, tinfo.creation);
+  if (ti.discard && errCount++ < 5) {
+    LOGP(warn, "Bad input with orbit {}, TFcounter {} and creation time {} in fillTFIDInfo", tinfo.firstTForbit, tinfo.tfCounter, tinfo.creation);
   }
-  ti.firstTForbit = tinfo.firstTForbit;
-  ti.tfCounter = tinfo.tfCounter;
-  ti.runNumber = tinfo.runNumber;
-  ti.startTime = tinfo.timeslice;
-  ti.creation = tinfo.creation;
+  return;
 }
diff --git a/Detectors/Calibration/include/DetectorsCalibration/TimeSlotCalibration.h b/Detectors/Calibration/include/DetectorsCalibration/TimeSlotCalibration.h
index 87562afddf2ca..a8be3644619a4 100644
--- a/Detectors/Calibration/include/DetectorsCalibration/TimeSlotCalibration.h
+++ b/Detectors/Calibration/include/DetectorsCalibration/TimeSlotCalibration.h
@@ -281,6 +281,15 @@ template <typename Container>
 template <typename... DATA>
 bool TimeSlotCalibration<Container>::process(const DATA&... data)
 {
+  if (mCurrentTFInfo.discard) {
+    LOGP(warn, "Ignoring TF with discard flag on: Orbit {}, TFcounter {}, Run:{}, StartTime:{} CreationTime {}, ",
+         mCurrentTFInfo.firstTForbit,
+         mCurrentTFInfo.tfCounter,
+         mCurrentTFInfo.runNumber,
+         mCurrentTFInfo.startTime,
+         mCurrentTFInfo.creation);
+    return false; // ignore bad TF
+  }
   static bool firstCall = true;
   if (firstCall) {
     firstCall = false;
diff --git a/Detectors/PHOS/calib/src/PHOSEnergyCalibDevice.cxx b/Detectors/PHOS/calib/src/PHOSEnergyCalibDevice.cxx
index 979ca690c03e0..51956a4dbf96e 100644
--- a/Detectors/PHOS/calib/src/PHOSEnergyCalibDevice.cxx
+++ b/Detectors/PHOS/calib/src/PHOSEnergyCalibDevice.cxx
@@ -133,6 +133,7 @@ void PHOSEnergyCalibDevice::run(o2::framework::ProcessingContext& pc)
       LOG(warning) << "LHCPeriod is not available, using current month " << mLHCPeriod;
     }
   }
+  o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
   mCalibrator->process(tfcounter, clusters, cluelements, cluTR, mOutputDigits);
 
   fillOutputTree();
diff --git a/Detectors/PHOS/calib/src/PHOSL1phaseCalibDevice.cxx b/Detectors/PHOS/calib/src/PHOSL1phaseCalibDevice.cxx
index c50a3faff4b01..baade755f2adf 100644
--- a/Detectors/PHOS/calib/src/PHOSL1phaseCalibDevice.cxx
+++ b/Detectors/PHOS/calib/src/PHOSL1phaseCalibDevice.cxx
@@ -30,7 +30,7 @@ void PHOSL1phaseCalibDevice::init(o2::framework::InitContext& ic)
 
 void PHOSL1phaseCalibDevice::run(o2::framework::ProcessingContext& pc)
 {
-
+  o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   auto crTime = pc.services().get<o2::framework::TimingInfo>().creation;
   if (mRunStartTime == 0 || crTime < mRunStartTime) {
diff --git a/Detectors/PHOS/calib/src/PHOSRunbyrunCalibDevice.cxx b/Detectors/PHOS/calib/src/PHOSRunbyrunCalibDevice.cxx
index cf767cb76c7ad..3c59ed8477940 100644
--- a/Detectors/PHOS/calib/src/PHOSRunbyrunCalibDevice.cxx
+++ b/Detectors/PHOS/calib/src/PHOSRunbyrunCalibDevice.cxx
@@ -54,6 +54,7 @@ void PHOSRunbyrunCalibDevice::run(o2::framework::ProcessingContext& pc)
   auto tfcounter = o2::header::get<o2::header::DataHeader*>(pc.inputs().get("clusters").header)->tfCounter;
   auto clusters = pc.inputs().get<gsl::span<Cluster>>("clusters");
   auto cluTR = pc.inputs().get<gsl::span<TriggerRecord>>("cluTR");
+  o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
   LOG(detail) << "Processing TF with " << clusters.size() << " clusters and " << cluTR.size() << " TriggerRecords";
   mCalibrator->process(tfcounter, clusters, cluTR);
 }
diff --git a/Detectors/PHOS/calib/src/PHOSTurnonCalibDevice.cxx b/Detectors/PHOS/calib/src/PHOSTurnonCalibDevice.cxx
index 52ec8cef0b438..c2b04aea381a3 100644
--- a/Detectors/PHOS/calib/src/PHOSTurnonCalibDevice.cxx
+++ b/Detectors/PHOS/calib/src/PHOSTurnonCalibDevice.cxx
@@ -49,7 +49,7 @@ void PHOSTurnonCalibDevice::run(o2::framework::ProcessingContext& pc)
   auto cellTR = pc.inputs().get<gsl::span<TriggerRecord>>("cellTriggerRecords");
   auto clusters = pc.inputs().get<gsl::span<Cluster>>("clusters");
   auto cluTR = pc.inputs().get<gsl::span<TriggerRecord>>("clusterTriggerRecords");
-
+  o2::base::TFIDInfoHelper::fillTFIDInfo(pc, mCalibrator->getCurrentTFInfo());
   LOG(detail) << "[PHOSTurnonCalibDevice - run]  Received " << cells.size() << " cells and " << clusters.size() << " clusters, running calibration";
 
   mCalibrator->process(tfcounter, cells, cellTR, clusters, cluTR);

From 462abe14ddecb634a9bb597e3440d022d961a6b7 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 27 Mar 2026 13:54:38 +0100
Subject: [PATCH 1483/1764] Avoid premature loop termination in ITS vertexer

---
 Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 0c4ecb0b12df1..6d51f7bab5d36 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -370,7 +370,7 @@ void VertexerTraits<nLayers>::computeVertices(const int iteration)
           std::array<float, 3> tmpVertex{mTimeFrame->getTrackletClusters(rofId).back().getVertex()};
           if (tmpVertex[0] * tmpVertex[0] + tmpVertex[1] * tmpVertex[1] > 4.f) {
             mTimeFrame->getTrackletClusters(rofId).pop_back();
-            break;
+            continue;
           }
           usedTracklets[line1] = true;
           usedTracklets[line2] = true;

From eeffa2752d17c70071bb1b656a0330ca56f293eb Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 27 Mar 2026 06:51:38 +0100
Subject: [PATCH 1484/1764] DPL: remove deprecated header / payload code

Rest of the usecases removed. Abstract header / payload retrieval, with the idea that get_header / get_payload
will work on any range of fair::mq::MessagePtrs.
---
 Framework/Core/include/Framework/MessageSet.h | 24 ------
 Framework/Core/test/test_MessageSet.cxx       | 78 +++++--------------
 2 files changed, 20 insertions(+), 82 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 166934238d647..323c0ad4608af 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -136,30 +136,6 @@ struct MessageSet {
     }
   }
 
-  fair::mq::MessagePtr& header(size_t partIndex)
-  {
-    return messages[messageMap[partIndex].position];
-  }
-
-  fair::mq::MessagePtr& payload(size_t partIndex, size_t payloadIndex = 0)
-  {
-    assert(partIndex < messageMap.size());
-    assert(messageMap[partIndex].position + payloadIndex + 1 < messages.size());
-    return messages[messageMap[partIndex].position + payloadIndex + 1];
-  }
-
-  fair::mq::MessagePtr const& header(size_t partIndex) const
-  {
-    return messages[messageMap[partIndex].position];
-  }
-
-  fair::mq::MessagePtr const& payload(size_t partIndex, size_t payloadIndex = 0) const
-  {
-    assert(partIndex < messageMap.size());
-    assert(messageMap[partIndex].position + payloadIndex + 1 < messages.size());
-    return messages[messageMap[partIndex].position + payloadIndex + 1];
-  }
-
   fair::mq::MessagePtr const& associatedHeader(size_t pos) const
   {
     return messages[messageMap[pairMap[pos].partIndex].position];
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index aa7b49c1d1d3c..c6d5030cf5e33 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -45,12 +45,8 @@ TEST_CASE("MessageSet")
   REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
   REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
   CHECK_THROWS((msgSet.messages | get_pair{1}));
-  // Validate pipe operators match old API
-  REQUIRE(&(msgSet.messages | get_header{0}) == &msgSet.header(0));
-  REQUIRE(&(msgSet.messages | get_payload{0, 0}) == &msgSet.payload(0));
-  REQUIRE((msgSet.messages | get_num_payloads{0}) == msgSet.messageMap[0].size);
-  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
-  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+  REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
+  REQUIRE((msgSet.messages | count_parts{}) == 1);
 }
 
 TEST_CASE("MessageSetWithFunction")
@@ -76,11 +72,8 @@ TEST_CASE("MessageSetWithFunction")
   REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
   REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
   CHECK_THROWS((msgSet.messages | get_pair{1}));
-  REQUIRE(&(msgSet.messages | get_header{0}) == &msgSet.header(0));
-  REQUIRE(&(msgSet.messages | get_payload{0, 0}) == &msgSet.payload(0));
-  REQUIRE((msgSet.messages | get_num_payloads{0}) == msgSet.messageMap[0].size);
-  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
-  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+  REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
+  REQUIRE((msgSet.messages | count_parts{}) == 1);
 }
 
 TEST_CASE("MessageSetWithMultipart")
@@ -112,13 +105,8 @@ TEST_CASE("MessageSetWithMultipart")
   REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 0);
   REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 2);
   CHECK_THROWS((msgSet.messages | get_pair{2}));
-  // Validate pipe operators match old API for multi-payload
-  REQUIRE(&(msgSet.messages | get_header{0}) == &msgSet.header(0));
-  REQUIRE(&(msgSet.messages | get_payload{0, 0}) == &msgSet.payload(0, 0));
-  REQUIRE(&(msgSet.messages | get_payload{0, 1}) == &msgSet.payload(0, 1));
-  REQUIRE((msgSet.messages | get_num_payloads{0}) == msgSet.messageMap[0].size);
-  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
-  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+  REQUIRE((msgSet.messages | get_num_payloads{0}) == 2);
+  REQUIRE((msgSet.messages | count_parts{}) == 1);
 }
 
 TEST_CASE("MessageSetAddPartRef")
@@ -190,18 +178,11 @@ TEST_CASE("MessageSetAddMultiple")
   REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 5);
   REQUIRE((msgSet.messages | get_pair{3}).headerIdx == 4);
   REQUIRE((msgSet.messages | get_pair{3}).payloadIdx == 6);
-  // Validate pipe operators match old API for mixed modes
-  for (size_t i = 0; i < 3; ++i) {
-    REQUIRE(&(msgSet.messages | get_header{i}) == &msgSet.header(i));
-    REQUIRE(&(msgSet.messages | get_payload{i, 0}) == &msgSet.payload(i, 0));
-  }
-  // Part 2 has a second payload (multi-payload with splitPayloadParts=2, splitPayloadIndex=2)
-  REQUIRE(&(msgSet.messages | get_payload{2, 1}) == &msgSet.payload(2, 1));
-  for (size_t i = 0; i < 3; ++i) {
-    REQUIRE((msgSet.messages | get_num_payloads{i}) == msgSet.messageMap[i].size);
-  }
-  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
-  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+  REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
+  REQUIRE((msgSet.messages | get_num_payloads{1}) == 1);
+  REQUIRE((msgSet.messages | get_num_payloads{2}) == 2);
+  REQUIRE((msgSet.messages | count_parts{}) == 3);
+  REQUIRE((msgSet.messages | count_payloads{}) == 4);
 }
 
 TEST_CASE("GetHeaderPayloadOperators")
@@ -251,13 +232,8 @@ TEST_CASE("GetHeaderPayloadOperators")
   REQUIRE(pl1.get() != nullptr);
   REQUIRE(pl1->GetSize() == 200);
 
-  // Validate pipe operators match old API
-  for (size_t i = 0; i < 2; ++i) {
-    REQUIRE(&(msgSet.messages | get_header{i}) == &msgSet.header(i));
-    REQUIRE(&(msgSet.messages | get_payload{i, 0}) == &msgSet.payload(i, 0));
-  }
-  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
-  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+  REQUIRE((msgSet.messages | count_parts{}) == 2);
+  REQUIRE((msgSet.messages | count_payloads{}) == 2);
 }
 
 TEST_CASE("GetHeaderPayloadMultiPayload")
@@ -343,18 +319,10 @@ TEST_CASE("GetHeaderPayloadMultiPayload")
   // get_num_payloads for part 1 should be 3
   REQUIRE((msgSet.messages | get_num_payloads{1}) == 3);
 
-  // Validate pipe operators match old API for multi-payload (header, pl, pl, pl)
-  REQUIRE(&(msgSet.messages | get_header{0}) == &msgSet.header(0));
-  REQUIRE(&(msgSet.messages | get_header{1}) == &msgSet.header(1));
-  REQUIRE(&(msgSet.messages | get_payload{0, 0}) == &msgSet.payload(0, 0));
-  REQUIRE(&(msgSet.messages | get_payload{1, 0}) == &msgSet.payload(1, 0));
-  REQUIRE(&(msgSet.messages | get_payload{1, 1}) == &msgSet.payload(1, 1));
-  REQUIRE(&(msgSet.messages | get_payload{1, 2}) == &msgSet.payload(1, 2));
-  for (size_t i = 0; i < 2; ++i) {
-    REQUIRE((msgSet.messages | get_num_payloads{i}) == msgSet.messageMap[i].size);
-  }
-  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
-  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+  REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
+  REQUIRE((msgSet.messages | get_num_payloads{1}) == 3);
+  REQUIRE((msgSet.messages | count_parts{}) == 2);
+  REQUIRE((msgSet.messages | count_payloads{}) == 4);
 }
 
 TEST_CASE("TraditionalSplitParts")
@@ -418,14 +386,8 @@ TEST_CASE("TraditionalSplitParts")
 
   // get_num_payloads: each traditional split pair has 1 payload
   for (size_t i = 0; i < 3; ++i) {
-    REQUIRE((msgSet.messages | get_num_payloads{i}) == msgSet.messageMap[i].size);
+    REQUIRE((msgSet.messages | get_num_payloads{i}) == 1);
   }
-
-  // Validate pipe operators match old MessageSet::header()/payload() API
-  for (size_t i = 0; i < 3; ++i) {
-    REQUIRE(&(msgSet.messages | get_header{i}) == &msgSet.header(i));
-    REQUIRE(&(msgSet.messages | get_payload{i, 0}) == &msgSet.payload(i));
-  }
-  REQUIRE((msgSet.messages | count_parts{}) == msgSet.messageMap.size());
-  REQUIRE((msgSet.messages | count_payloads{}) == msgSet.pairMap.size());
+  REQUIRE((msgSet.messages | count_parts{}) == 3);
+  REQUIRE((msgSet.messages | count_payloads{}) == 3);
 }

From 77efa21500fdad2b21ac56559874b2f25cfd9284 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 27 Mar 2026 06:51:38 +0100
Subject: [PATCH 1485/1764] DPL: replace MessageSet::associateHeader /
 associatePayload

---
 Framework/Core/src/DataProcessingDevice.cxx |  5 +-
 Framework/Core/test/test_MessageSet.cxx     | 64 +++++++++++++++++++++
 2 files changed, 67 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 0fa70947bf18c..bb6502758a95a 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -2140,8 +2140,9 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
         //   sequence is the header message
         // - each part has one or more payload messages
         // - InputRecord provides all payloads as header-payload pair
-        auto const& headerMsg = currentSetOfInputs[i].associatedHeader(partindex);
-        auto const& payloadMsg = currentSetOfInputs[i].associatedPayload(partindex);
+        auto const indices = currentSetOfInputs[i].messages | get_pair{partindex};
+        auto const& headerMsg = currentSetOfInputs[i].messages[indices.headerIdx];
+        auto const& payloadMsg = currentSetOfInputs[i].messages[indices.payloadIdx];
         headerptr = static_cast<char const*>(headerMsg->GetData());
         payloadptr = payloadMsg ? static_cast<char const*>(payloadMsg->GetData()) : nullptr;
         payloadSize = payloadMsg ? payloadMsg->GetSize() : 0;
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index c6d5030cf5e33..8c9ed4a7cbf1c 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -47,6 +47,14 @@ TEST_CASE("MessageSet")
   CHECK_THROWS((msgSet.messages | get_pair{1}));
   REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
   REQUIRE((msgSet.messages | count_parts{}) == 1);
+  // messages: [hdr, pl] — one pair
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
+    auto indices = msgSet.messages | get_pair{i};
+    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
+    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
+  }
 }
 
 TEST_CASE("MessageSetWithFunction")
@@ -74,6 +82,11 @@ TEST_CASE("MessageSetWithFunction")
   CHECK_THROWS((msgSet.messages | get_pair{1}));
   REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
   REQUIRE((msgSet.messages | count_parts{}) == 1);
+  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
+    auto indices = msgSet.messages | get_pair{i};
+    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
+    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
+  }
 }
 
 TEST_CASE("MessageSetWithMultipart")
@@ -107,6 +120,16 @@ TEST_CASE("MessageSetWithMultipart")
   CHECK_THROWS((msgSet.messages | get_pair{2}));
   REQUIRE((msgSet.messages | get_num_payloads{0}) == 2);
   REQUIRE((msgSet.messages | count_parts{}) == 1);
+  // messages: [hdr, pl0, pl1] — one header, two payloads
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 2);
+  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
+    auto indices = msgSet.messages | get_pair{i};
+    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
+    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
+  }
 }
 
 TEST_CASE("MessageSetAddPartRef")
@@ -183,6 +206,11 @@ TEST_CASE("MessageSetAddMultiple")
   REQUIRE((msgSet.messages | get_num_payloads{2}) == 2);
   REQUIRE((msgSet.messages | count_parts{}) == 3);
   REQUIRE((msgSet.messages | count_payloads{}) == 4);
+  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
+    auto indices = msgSet.messages | get_pair{i};
+    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
+    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
+  }
 }
 
 TEST_CASE("GetHeaderPayloadOperators")
@@ -234,6 +262,16 @@ TEST_CASE("GetHeaderPayloadOperators")
 
   REQUIRE((msgSet.messages | count_parts{}) == 2);
   REQUIRE((msgSet.messages | count_payloads{}) == 2);
+  // messages: [hdr0, pl0, hdr1, pl1] — two standard pairs
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
+  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
+  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
+    auto indices = msgSet.messages | get_pair{i};
+    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
+    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
+  }
 }
 
 TEST_CASE("GetHeaderPayloadMultiPayload")
@@ -323,6 +361,20 @@ TEST_CASE("GetHeaderPayloadMultiPayload")
   REQUIRE((msgSet.messages | get_num_payloads{1}) == 3);
   REQUIRE((msgSet.messages | count_parts{}) == 2);
   REQUIRE((msgSet.messages | count_payloads{}) == 4);
+  // messages: [hdr0, pl0, hdr1, pl1_0, pl1_1, pl1_2]
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
+  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
+  REQUIRE((msgSet.messages | get_pair{2}).headerIdx == 2);
+  REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 4);
+  REQUIRE((msgSet.messages | get_pair{3}).headerIdx == 2);
+  REQUIRE((msgSet.messages | get_pair{3}).payloadIdx == 5);
+  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
+    auto indices = msgSet.messages | get_pair{i};
+    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
+    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
+  }
 }
 
 TEST_CASE("TraditionalSplitParts")
@@ -390,4 +442,16 @@ TEST_CASE("TraditionalSplitParts")
   }
   REQUIRE((msgSet.messages | count_parts{}) == 3);
   REQUIRE((msgSet.messages | count_payloads{}) == 3);
+  // messages: [hdr0, pl0, hdr1, pl1, hdr2, pl2] — three traditional split pairs
+  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
+  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
+  REQUIRE((msgSet.messages | get_pair{2}).headerIdx == 4);
+  REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 5);
+  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
+    auto indices = msgSet.messages | get_pair{i};
+    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
+    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
+  }
 }

From 389aaf1627773d27a3fbfcfdbab8be6932f4efa0 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 25 Mar 2026 14:56:52 +0100
Subject: [PATCH 1486/1764] DPL: treat --ccdb-fetchers like --readers

---
 Framework/Core/src/runDataProcessing.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 815fce47544d0..98cbf70370c3d 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -2048,6 +2048,7 @@ int runStateMachine(DataProcessorSpecs const& workflow,
             "--driver-client-backend",
             "--fairmq-ipc-prefix",
             "--readers",
+            "--ccdb-fetchers",
             "--resources-monitoring",
             "--resources-monitoring-file",
             "--resources-monitoring-dump-interval",

From 2fd34a0af1eef89c33571e21b4d9ad7f3c87a92b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 28 Mar 2026 14:57:49 +0100
Subject: [PATCH 1487/1764] DPL: exponential back-off for missing resources.

---
 Framework/Core/src/DataProcessingDevice.cxx | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index bb6502758a95a..31b7b02172af7 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1377,6 +1377,7 @@ void DataProcessingDevice::Run()
         std::atomic<size_t> numberOfUnscheduledSinceLastScheduled = 0;
         std::atomic<size_t> numberOfUnscheduled = 0;
         std::atomic<size_t> numberOfScheduled = 0;
+        std::atomic<size_t> nextWarnAt = 1;
       };
       static SchedulingStats schedulingStats;
       O2_SIGNPOST_ID_GENERATE(sid, scheduling);
@@ -1387,6 +1388,7 @@ void DataProcessingDevice::Run()
         schedulingStats.lastScheduled = uv_now(state.loop);
         schedulingStats.numberOfScheduled++;
         schedulingStats.numberOfUnscheduledSinceLastScheduled = 0;
+        schedulingStats.nextWarnAt = 1;
         O2_SIGNPOST_EVENT_EMIT(scheduling, sid, "Run", "Enough resources to schedule computation on stream %d", streamRef.index);
         if (dplEnableMultithreding) [[unlikely]] {
           stream.task = &handle;
@@ -1396,12 +1398,12 @@ void DataProcessingDevice::Run()
           run_completion(&handle, 0);
         }
       } else {
-        if (schedulingStats.numberOfUnscheduledSinceLastScheduled > 100 ||
-            (uv_now(state.loop) - schedulingStats.lastScheduled) > 30000) {
+        if (schedulingStats.numberOfUnscheduledSinceLastScheduled >= schedulingStats.nextWarnAt) {
           O2_SIGNPOST_EVENT_EMIT_WARN(scheduling, sid, "Run",
                                       "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu. Data is not lost and it will be scheduled again.",
                                       schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
                                       schedulingStats.lastScheduled.load());
+          schedulingStats.nextWarnAt = schedulingStats.nextWarnAt * 2;
         } else {
           O2_SIGNPOST_EVENT_EMIT(scheduling, sid, "Run",
                                  "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu. Data is not lost and it will be scheduled again.",

From db1ede319f113e56c5fd0fb4131ac1ee276f1b52 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sat, 28 Mar 2026 22:49:56 +0100
Subject: [PATCH 1488/1764] Revert "DPL: Better detection for injected
 workflows (fixed) (#15202)"

This reverts commit 87b9775293c9734b0be767feb5915e614560a05c.
---
 Framework/Core/src/ArrowSupport.cxx    |  8 +--
 Framework/Core/src/WorkflowHelpers.cxx | 15 +---
 run/o2sim_hepmc_publisher.cxx          | 94 +++++++++++++-------------
 run/o2sim_kine_publisher.cxx           |  3 +-
 run/o2sim_mctracks_to_aod.cxx          | 12 ++--
 5 files changed, 58 insertions(+), 74 deletions(-)

diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index b701ba5f8e01c..c5cc021a53478 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -680,12 +680,8 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
           workflow.erase(reader);
         } else {
           // load reader algorithm before deployment
-          auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
-            return !spec.name.starts_with("internal-dpl-aod-reader") && std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
-              return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
-            });
-          });
-          if (tfnsource == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
+          auto mctracks2aod = std::find_if(workflow.begin(), workflow.end(), [](auto const& x) { return x.name == "mctracks-to-aod"; });
+          if (mctracks2aod == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
             reader->algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx));
           } // otherwise the algorithm was set in injectServiceDevices
         }
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 2ef3df9426fde..abe566e239618 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -411,17 +411,13 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   // add the reader
   if (aodReader.outputs.empty() == false) {
-    auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
-      return std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
-        return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
-      });
-    });
-    if (tfnsource == workflow.end()) {
+    auto mctracks2aod = std::ranges::find_if(workflow, [](auto const& x) { return x.name == "mctracks-to-aod"; });
+    if (mctracks2aod == workflow.end()) {
       // add normal reader
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
       aodReader.outputs.emplace_back(OutputSpec{"TFF", "TFFilename"});
     } else {
-      // AODs are being injected the tfnsource is the entry point, add error-handler reader
+      // AODs are being injected on-the-fly, add error-handler reader
       aodReader.algorithm = AlgorithmSpec{
         adaptStateful(
           [](DeviceSpec const& spec) {
@@ -704,11 +700,6 @@ void WorkflowHelpers::injectAODWriter(WorkflowSpec& workflow, ConfigContext cons
       return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
     });
     dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
-
-    it = std::find_if(dec.outputsInputs.begin(), dec.outputsInputs.end(), [](InputSpec const& spec) -> bool {
-      return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFF"));
-    });
-    dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
   }
 }
 
diff --git a/run/o2sim_hepmc_publisher.cxx b/run/o2sim_hepmc_publisher.cxx
index f255b4a3a4f62..bf40abacb134f 100644
--- a/run/o2sim_hepmc_publisher.cxx
+++ b/run/o2sim_hepmc_publisher.cxx
@@ -37,9 +37,7 @@ struct O2simHepmcPublisher {
   int tfCounter = 0;
   std::shared_ptr<HepMC3::Reader> hepMCReader;
   bool eos = false;
-
-  std::vector<o2::pmr::vector<o2::MCTrack>*> mctracks_vector;
-  std::vector<o2::dataformats::MCEventHeader*> mcheader_vector;
+  std::vector<o2::MCTrack> mcTracks;
 
   void init(o2::framework::InitContext& /*ic*/)
   {
@@ -52,19 +50,13 @@ struct O2simHepmcPublisher {
       LOGP(fatal, "Cannot open HEPMC kine file {}", (std::string)hepmcFileName);
     }
     // allocate the memory upfront to prevent reallocations later
-    mctracks_vector.reserve(aggregate);
-    mcheader_vector.reserve(aggregate);
+    mcTracks.reserve(1e3 * aggregate);
   }
 
   void run(o2::framework::ProcessingContext& pc)
   {
     HepMC3::GenEvent event;
-    auto batch = maxEvents > 0 ? std::min((int)aggregate, (int)maxEvents - eventCounter) : (int)aggregate;
-    for (auto i = 0; i < batch; ++i) {
-      mctracks_vector.push_back(&pc.outputs().make<o2::pmr::vector<o2::MCTrack>>(Output{"MC", "MCTRACKS", 0}));
-      auto& mctracks = mctracks_vector.back();
-      mcheader_vector.push_back(&pc.outputs().make<o2::dataformats::MCEventHeader>(Output{"MC", "MCHEADER", 0}));
-      auto& mcheader = mcheader_vector.back();
+    for (auto i = 0; i < (int)aggregate; ++i) {
       // read next entry
       hepMCReader->read_event(event);
       if (hepMCReader->failed()) {
@@ -74,60 +66,61 @@ struct O2simHepmcPublisher {
       }
 
       // create O2 MCHeader and MCtracks vector out of HEPMC event
-      mcheader->SetEventID(event.event_number());
-      mcheader->SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
+      o2::dataformats::MCEventHeader mcHeader;
+      mcHeader.SetEventID(event.event_number());
+      mcHeader.SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
       auto xsecInfo = event.cross_section();
       if (xsecInfo != nullptr) {
-        mcheader->putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
-        mcheader->putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
-        mcheader->putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
-        mcheader->putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
+        mcHeader.putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
+        mcHeader.putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
+        mcHeader.putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
+        mcHeader.putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
       }
       auto scale = event.attribute<HepMC3::DoubleAttribute>(MCInfoKeys::eventScale);
       if (scale != nullptr) {
-        mcheader->putInfo(MCInfoKeys::eventScale, (float)scale->value());
+        mcHeader.putInfo(MCInfoKeys::eventScale, (float)scale->value());
       }
       auto nMPI = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::mpi);
       if (nMPI != nullptr) {
-        mcheader->putInfo(MCInfoKeys::mpi, nMPI->value());
+        mcHeader.putInfo(MCInfoKeys::mpi, nMPI->value());
       }
       auto sid = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processCode);
       auto scode = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processID); // default pythia8 hepmc3 interface uses signal_process_id
       if (sid != nullptr) {
-        mcheader->putInfo(MCInfoKeys::processCode, sid->value());
+        mcHeader.putInfo(MCInfoKeys::processCode, sid->value());
       } else if (scode != nullptr) {
-        mcheader->putInfo(MCInfoKeys::processCode, scode->value());
+        mcHeader.putInfo(MCInfoKeys::processCode, scode->value());
       }
       auto pdfInfo = event.pdf_info();
       if (pdfInfo != nullptr) {
-        mcheader->putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
-        mcheader->putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
-        mcheader->putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
-        mcheader->putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
-        mcheader->putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
-        mcheader->putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
-        mcheader->putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
-        mcheader->putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
-        mcheader->putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
+        mcHeader.putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
+        mcHeader.putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
+        mcHeader.putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
+        mcHeader.putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
+        mcHeader.putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
+        mcHeader.putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
+        mcHeader.putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
+        mcHeader.putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
+        mcHeader.putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
       }
       auto heavyIon = event.heavy_ion();
       if (heavyIon != nullptr) {
-        mcheader->putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
-        mcheader->putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
-        mcheader->putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
-        mcheader->putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
-        mcheader->putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
-        mcheader->putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
-        mcheader->putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
-        mcheader->putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
-        mcheader->putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
-        mcheader->putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
-        mcheader->putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
-        mcheader->putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
-        mcheader->putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
-        mcheader->putInfo("eccentricity", (float)heavyIon->eccentricity);
-        mcheader->putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
-        mcheader->putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
+        mcHeader.putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
+        mcHeader.putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
+        mcHeader.putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
+        mcHeader.putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
+        mcHeader.putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
+        mcHeader.putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
+        mcHeader.putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
+        mcHeader.putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
+        mcHeader.putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
+        mcHeader.putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
+        mcHeader.putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
+        mcHeader.putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
+        mcHeader.putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
+        mcHeader.putInfo("eccentricity", (float)heavyIon->eccentricity);
+        mcHeader.putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
+        mcHeader.putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
       }
 
       auto particles = event.particles();
@@ -138,7 +131,7 @@ struct O2simHepmcPublisher {
         auto has_children = children.size() > 0;
         auto p = particle->momentum();
         auto v = particle->production_vertex();
-        mctracks->emplace_back(
+        mcTracks.emplace_back(
           particle->pid(),
           has_parents ? parents.front()->id() : -1, has_parents ? parents.back()->id() : -1,
           has_children ? children.front()->id() : -1, has_children ? children.back()->id() : -1,
@@ -146,13 +139,18 @@ struct O2simHepmcPublisher {
           v->position().x(), v->position().y(), v->position().z(),
           v->position().t(), 0);
       }
+
+      // add to the message
+      pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcHeader);
+      pc.outputs().snapshot(Output{"MC", "MCTRACKS", 0}, mcTracks);
+      mcTracks.clear();
       ++eventCounter;
     }
 
     // report number of TFs injected for the rate limiter to work
     ++tfCounter;
     pc.services().get<o2::monitoring::Monitoring>().send(o2::monitoring::Metric{(uint64_t)tfCounter, "df-sent"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
-    if (eos || (maxEvents > 0 && eventCounter >= maxEvents)) {
+    if (eos || (maxEvents > 0 && eventCounter == maxEvents)) {
       pc.services().get<ControlService>().endOfStream();
       pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     }
diff --git a/run/o2sim_kine_publisher.cxx b/run/o2sim_kine_publisher.cxx
index 5920743c3fafa..cfbea6ae02a5f 100644
--- a/run/o2sim_kine_publisher.cxx
+++ b/run/o2sim_kine_publisher.cxx
@@ -40,8 +40,7 @@ struct O2simKinePublisher {
 
   void run(o2::framework::ProcessingContext& pc)
   {
-    auto batch = std::min((int)aggregate, nEvents - eventCounter);
-    for (auto i = 0; i < batch; ++i) {
+    for (auto i = 0; i < std::min((int)aggregate, nEvents - eventCounter); ++i) {
       auto mcevent = mcKinReader->getMCEventHeader(0, eventCounter);
       auto mctracks = mcKinReader->getTracks(0, eventCounter);
       pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcevent);
diff --git a/run/o2sim_mctracks_to_aod.cxx b/run/o2sim_mctracks_to_aod.cxx
index d95a3b33cc38f..124e8aa7b3e42 100644
--- a/run/o2sim_mctracks_to_aod.cxx
+++ b/run/o2sim_mctracks_to_aod.cxx
@@ -70,7 +70,7 @@ struct MctracksToAod {
   /** Run the conversion */
   void run(o2::framework::ProcessingContext& pc)
   {
-    LOG(detail) << "=== Running extended MC AOD exporter ===";
+    LOG(debug) << "=== Running extended MC AOD exporter ===";
     using namespace o2::aodmchelpers;
     using McHeader = o2::dataformats::MCEventHeader;
     using McTrack = o2::MCTrack;
@@ -94,13 +94,13 @@ struct MctracksToAod {
     // TODO: include BC simulation
     auto bcCounter = 0UL;
     size_t offset = 0;
-    LOG(detail) << "--- Loop over " << nParts << " parts ---";
+    LOG(debug) << "--- Loop over " << nParts << " parts ---";
     for (auto i = 0U; i < nParts; ++i) {
       auto record = mSampler.generateCollisionTime();
       auto header = pc.inputs().get<McHeader*>("mcheader", i);
       auto tracks = pc.inputs().get<McTracks>("mctracks", i);
 
-      LOG(detail) << "Updating collision table";
+      LOG(debug) << "Updating collision table";
       auto genID = updateMCCollisions(mCollisions.cursor,
                                       bcCounter,
                                       record.timeInBCNS * 1.e-3,
@@ -108,12 +108,12 @@ struct MctracksToAod {
                                       0,
                                       i);
 
-      LOG(detail) << "Updating HepMC tables";
+      LOG(debug) << "Updating HepMC tables";
       updateHepMCXSection(mXSections.cursor, bcCounter, genID, *header);
       updateHepMCPdfInfo(mPdfInfos.cursor, bcCounter, genID, *header);
       updateHepMCHeavyIon(mHeavyIons.cursor, bcCounter, genID, *header);
 
-      LOG(detail) << "Updating particles table";
+      LOG(debug) << "Updating particles table";
       TrackToIndex preselect;
       offset = updateParticles(mParticles.cursor,
                                bcCounter,
@@ -123,7 +123,7 @@ struct MctracksToAod {
                                (bool)filt,
                                false);
 
-      LOG(detail) << "Increment BC counter";
+      LOG(debug) << "Increment BC counter";
       bcCounter++;
     }
 

From 757173be61c6ccf7d962476c222c60c64be2f785 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 08:40:38 +0200
Subject: [PATCH 1489/1764] DPL: drop MessageSet::associateHeader /
 associatePayload (#15234)

---
 Framework/Core/include/Framework/MessageSet.h | 11 ------
 Framework/Core/test/test_MessageSet.cxx       | 35 -------------------
 2 files changed, 46 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 323c0ad4608af..6ccabd8c5ffb5 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -136,17 +136,6 @@ struct MessageSet {
     }
   }
 
-  fair::mq::MessagePtr const& associatedHeader(size_t pos) const
-  {
-    return messages[messageMap[pairMap[pos].partIndex].position];
-  }
-
-  fair::mq::MessagePtr const& associatedPayload(size_t pos) const
-  {
-    auto partIndex = pairMap[pos].partIndex;
-    auto payloadIndex = pairMap[pos].payloadIndex;
-    return messages[messageMap[partIndex].position + payloadIndex + 1];
-  }
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index 8c9ed4a7cbf1c..bfbffb166da8d 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -50,11 +50,6 @@ TEST_CASE("MessageSet")
   // messages: [hdr, pl] — one pair
   REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
   REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
-    auto indices = msgSet.messages | get_pair{i};
-    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
-    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
-  }
 }
 
 TEST_CASE("MessageSetWithFunction")
@@ -82,11 +77,6 @@ TEST_CASE("MessageSetWithFunction")
   CHECK_THROWS((msgSet.messages | get_pair{1}));
   REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
   REQUIRE((msgSet.messages | count_parts{}) == 1);
-  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
-    auto indices = msgSet.messages | get_pair{i};
-    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
-    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
-  }
 }
 
 TEST_CASE("MessageSetWithMultipart")
@@ -125,11 +115,6 @@ TEST_CASE("MessageSetWithMultipart")
   REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
   REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 0);
   REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 2);
-  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
-    auto indices = msgSet.messages | get_pair{i};
-    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
-    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
-  }
 }
 
 TEST_CASE("MessageSetAddPartRef")
@@ -206,11 +191,6 @@ TEST_CASE("MessageSetAddMultiple")
   REQUIRE((msgSet.messages | get_num_payloads{2}) == 2);
   REQUIRE((msgSet.messages | count_parts{}) == 3);
   REQUIRE((msgSet.messages | count_payloads{}) == 4);
-  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
-    auto indices = msgSet.messages | get_pair{i};
-    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
-    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
-  }
 }
 
 TEST_CASE("GetHeaderPayloadOperators")
@@ -267,11 +247,6 @@ TEST_CASE("GetHeaderPayloadOperators")
   REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
   REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
   REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
-  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
-    auto indices = msgSet.messages | get_pair{i};
-    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
-    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
-  }
 }
 
 TEST_CASE("GetHeaderPayloadMultiPayload")
@@ -370,11 +345,6 @@ TEST_CASE("GetHeaderPayloadMultiPayload")
   REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 4);
   REQUIRE((msgSet.messages | get_pair{3}).headerIdx == 2);
   REQUIRE((msgSet.messages | get_pair{3}).payloadIdx == 5);
-  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
-    auto indices = msgSet.messages | get_pair{i};
-    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
-    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
-  }
 }
 
 TEST_CASE("TraditionalSplitParts")
@@ -449,9 +419,4 @@ TEST_CASE("TraditionalSplitParts")
   REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
   REQUIRE((msgSet.messages | get_pair{2}).headerIdx == 4);
   REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 5);
-  for (size_t i = 0; i < msgSet.pairMap.size(); ++i) {
-    auto indices = msgSet.messages | get_pair{i};
-    REQUIRE(&msgSet.messages[indices.headerIdx] == &msgSet.associatedHeader(i));
-    REQUIRE(&msgSet.messages[indices.payloadIdx] == &msgSet.associatedPayload(i));
-  }
 }

From cafa4ce8912a88addbce3ad515b6d215d3377923 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 14:46:13 +0200
Subject: [PATCH 1490/1764] DPL: get rid of MessageSet::pairMap (#15237)

Everything calculated on the fly
---
 Framework/Core/include/Framework/MessageSet.h | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 6ccabd8c5ffb5..bc718ca82714c 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -50,22 +50,21 @@ struct MessageSet {
     // payload index within the O2 message
     size_t payloadIndex = 0;
   };
-  std::vector<PairMapping> pairMap;
 
   MessageSet()
-    : messages(), messageMap(), pairMap()
+    : messages(), messageMap()
   {
   }
 
   template <typename F>
   MessageSet(F getter, size_t size)
-    : messages(), messageMap(), pairMap()
+    : messages(), messageMap()
   {
     add(std::forward<F>(getter), size);
   }
 
   MessageSet(MessageSet&& other)
-    : messages(std::move(other.messages)), messageMap(std::move(other.messageMap)), pairMap(std::move(other.pairMap))
+    : messages(std::move(other.messages)), messageMap(std::move(other.messageMap))
   {
     other.clear();
   }
@@ -77,7 +76,6 @@ struct MessageSet {
     }
     messages = std::move(other.messages);
     messageMap = std::move(other.messageMap);
-    pairMap = std::move(other.pairMap);
     other.clear();
     return *this;
   }
@@ -99,7 +97,6 @@ struct MessageSet {
   {
     messages.clear();
     messageMap.clear();
-    pairMap.clear();
   }
 
   // this is more or less legacy
@@ -116,7 +113,6 @@ struct MessageSet {
   // add  content of the part ref
   void add(PartRef&& ref)
   {
-    pairMap.emplace_back(messageMap.size(), 0);
     messageMap.emplace_back(messages.size(), 1);
     messages.emplace_back(std::move(ref.header));
     messages.emplace_back(std::move(ref.payload));
@@ -126,12 +122,8 @@ struct MessageSet {
   template <typename F>
   void add(F getter, size_t size)
   {
-    auto partid = messageMap.size();
     messageMap.emplace_back(messages.size(), size - 1);
     for (size_t i = 0; i < size; ++i) {
-      if (i > 0) {
-        pairMap.emplace_back(partid, i - 1);
-      }
       messages.emplace_back(std::move(getter(i)));
     }
   }

From e22690985d4b374e3b82770994e92779bb63b00b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 14:50:58 +0200
Subject: [PATCH 1491/1764] DPL: drop MessageSet::messageMap

---
 Framework/Core/include/Framework/MessageSet.h | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index bc718ca82714c..9cc11f0c35ee0 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -38,11 +38,6 @@ struct MessageSet {
   };
   // linear storage of messages
   std::vector<fair::mq::MessagePtr> messages;
-  // message map describes O2 messages consisting of a header message and
-  // payload message(s), index describes position in the linear storage
-  std::vector<Index> messageMap;
-  // pair map describes all messages in one sequence of header-payload pairs and
-  // where in the message index the associated header and payload can be found
   struct PairMapping {
     PairMapping(size_t partId, size_t payloadId) : partIndex(partId), payloadIndex(payloadId) {}
     // O2 message where the pair is located in
@@ -52,19 +47,19 @@ struct MessageSet {
   };
 
   MessageSet()
-    : messages(), messageMap()
+    : messages()
   {
   }
 
   template <typename F>
   MessageSet(F getter, size_t size)
-    : messages(), messageMap()
+    : messages()
   {
     add(std::forward<F>(getter), size);
   }
 
   MessageSet(MessageSet&& other)
-    : messages(std::move(other.messages)), messageMap(std::move(other.messageMap))
+    : messages(std::move(other.messages))
   {
     other.clear();
   }
@@ -75,7 +70,6 @@ struct MessageSet {
       return *this;
     }
     messages = std::move(other.messages);
-    messageMap = std::move(other.messageMap);
     other.clear();
     return *this;
   }
@@ -96,7 +90,6 @@ struct MessageSet {
   void clear()
   {
     messages.clear();
-    messageMap.clear();
   }
 
   // this is more or less legacy
@@ -113,7 +106,6 @@ struct MessageSet {
   // add  content of the part ref
   void add(PartRef&& ref)
   {
-    messageMap.emplace_back(messages.size(), 1);
     messages.emplace_back(std::move(ref.header));
     messages.emplace_back(std::move(ref.payload));
   }
@@ -122,7 +114,6 @@ struct MessageSet {
   template <typename F>
   void add(F getter, size_t size)
   {
-    messageMap.emplace_back(messages.size(), size - 1);
     for (size_t i = 0; i < size; ++i) {
       messages.emplace_back(std::move(getter(i)));
     }

From 4d74d840a04adc3099486ab53f5b0ae097bd26c3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 14:50:58 +0200
Subject: [PATCH 1492/1764] DPL: drop get number of pairs

---
 Framework/Core/include/Framework/MessageSet.h | 6 ------
 Framework/Core/src/DataProcessingDevice.cxx   | 4 ++--
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 9cc11f0c35ee0..440b98514eb51 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -74,12 +74,6 @@ struct MessageSet {
     return *this;
   }
 
-  /// get number of header-payload pairs
-  [[nodiscard]] size_t getNumberOfPairs() const
-  {
-    return messages | count_payloads{};
-  }
-
   /// get number of payloads for an in-flight message
   [[nodiscard]] size_t getNumberOfPayloads(size_t mi) const
   {
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 31b7b02172af7..9b6395a02916a 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -2133,7 +2133,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
       currentSetOfInputs = relayer.consumeExistingInputsForTimeslice(slot);
     }
     auto getter = [&currentSetOfInputs](size_t i, size_t partindex) -> DataRef {
-      if (currentSetOfInputs[i].getNumberOfPairs() > partindex) {
+      if ((currentSetOfInputs[i].messages | count_payloads{}) > partindex) {
         const char* headerptr = nullptr;
         const char* payloadptr = nullptr;
         size_t payloadSize = 0;
@@ -2153,7 +2153,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
       return DataRef{};
     };
     auto nofPartsGetter = [&currentSetOfInputs](size_t i) -> size_t {
-      return currentSetOfInputs[i].getNumberOfPairs();
+      return (currentSetOfInputs[i].messages | count_payloads{});
     };
     auto refCountGetter = [&currentSetOfInputs](size_t idx) -> int {
       auto& header = static_cast<const fair::mq::shmem::Message&>(*(currentSetOfInputs[idx].messages | get_header{0}));

From 1175e89185809f040661c9b928427f64fb9bd4a3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 14:50:58 +0200
Subject: [PATCH 1493/1764] DPL: fix also getNumberOfPayloads

---
 Framework/Core/include/Framework/MessageSet.h | 6 ------
 Framework/Core/test/test_DataRelayer.cxx      | 6 +++---
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 440b98514eb51..8a5aca854ca82 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -74,12 +74,6 @@ struct MessageSet {
     return *this;
   }
 
-  /// get number of payloads for an in-flight message
-  [[nodiscard]] size_t getNumberOfPayloads(size_t mi) const
-  {
-    return messages | get_num_payloads{mi};
-  }
-
   /// clear the set
   void clear()
   {
diff --git a/Framework/Core/test/test_DataRelayer.cxx b/Framework/Core/test/test_DataRelayer.cxx
index 1f7518860bf57..332a87970eda0 100644
--- a/Framework/Core/test/test_DataRelayer.cxx
+++ b/Framework/Core/test/test_DataRelayer.cxx
@@ -738,7 +738,7 @@ TEST_CASE("DataRelayer")
     // payloads
     REQUIRE(messageSet.size() == 1);
     REQUIRE((messageSet[0].messages | count_parts{}) == nSplitParts);
-    REQUIRE(messageSet[0].getNumberOfPayloads(0) == 1);
+    REQUIRE((messageSet[0].messages | get_num_payloads{0}) == 1);
   }
 
   SECTION("SplitPayloadSequence")
@@ -803,8 +803,8 @@ TEST_CASE("DataRelayer")
     REQUIRE((messageSet[0].messages | count_parts{}) == sequenceSize.size());
     size_t counter = 0;
     for (size_t seqid = 0; seqid < sequenceSize.size(); ++seqid) {
-      REQUIRE(messageSet[0].getNumberOfPayloads(seqid) == sequenceSize[seqid]);
-      for (size_t pi = 0; pi < messageSet[0].getNumberOfPayloads(seqid); ++pi) {
+      REQUIRE((messageSet[0].messages | get_num_payloads{seqid}) == sequenceSize[seqid]);
+      for (size_t pi = 0; pi < (messageSet[0].messages | get_num_payloads{seqid}); ++pi) {
         REQUIRE((messageSet[0].messages | get_payload{seqid, pi}));
         auto const* data = (messageSet[0].messages | get_payload{seqid, pi})->GetData();
         REQUIRE(*(reinterpret_cast<size_t const*>(data)) == counter);

From 3b23b764efc5c6255c2e0e1d40d0dcecdeff81f5 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 14:50:58 +0200
Subject: [PATCH 1494/1764] Remove unneeded parts in MessageSet

---
 Framework/Core/include/Framework/MessageSet.h | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 8a5aca854ca82..4f5943890ae68 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -31,20 +31,8 @@ namespace o2::framework
 /// O2 message model. For this purpose, also the pair index is filled and can
 /// be used to access header and payload associated with a pair
 struct MessageSet {
-  struct Index {
-    Index(size_t p, size_t s) : position(p), size(s) {}
-    size_t position = 0;
-    size_t size = 0;
-  };
   // linear storage of messages
   std::vector<fair::mq::MessagePtr> messages;
-  struct PairMapping {
-    PairMapping(size_t partId, size_t payloadId) : partIndex(partId), payloadIndex(payloadId) {}
-    // O2 message where the pair is located in
-    size_t partIndex = 0;
-    // payload index within the O2 message
-    size_t payloadIndex = 0;
-  };
 
   MessageSet()
     : messages()

From 8c44308e7f0cc953fa4e2ece1c31886e6652dec4 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 14:50:58 +0200
Subject: [PATCH 1495/1764] Drop add, reset

---
 Framework/Core/include/Framework/MessageSet.h | 32 ++-------------
 Framework/Core/src/DataRelayer.cxx            | 11 +++--
 Framework/Core/test/test_ForwardInputs.cxx    | 40 +++++++++++++------
 Framework/Core/test/test_MessageSet.cxx       | 20 ++++++----
 4 files changed, 50 insertions(+), 53 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 4f5943890ae68..233099e67dc0f 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -43,7 +43,9 @@ struct MessageSet {
   MessageSet(F getter, size_t size)
     : messages()
   {
-    add(std::forward<F>(getter), size);
+    for (size_t i = 0; i < size; ++i) {
+      messages.emplace_back(std::move(getter(i)));
+    }
   }
 
   MessageSet(MessageSet&& other)
@@ -67,34 +69,6 @@ struct MessageSet {
   {
     messages.clear();
   }
-
-  // this is more or less legacy
-  // PartRef has been earlier used to store fixed header-payload pairs
-  // reset the set and store content of the part ref
-  void reset(PartRef&& ref)
-  {
-    clear();
-    add(std::move(ref));
-  }
-
-  // this is more or less legacy
-  // PartRef has been earlier used to store fixed header-payload pairs
-  // add  content of the part ref
-  void add(PartRef&& ref)
-  {
-    messages.emplace_back(std::move(ref.header));
-    messages.emplace_back(std::move(ref.payload));
-  }
-
-  /// add an O2 message
-  template <typename F>
-  void add(F getter, size_t size)
-  {
-    for (size_t i = 0; i < size; ++i) {
-      messages.emplace_back(std::move(getter(i)));
-    }
-  }
-
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index 4cda75ed001b0..d34d12b282a9d 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -242,7 +242,9 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       assert(expirator.handler);
       PartRef newRef;
       expirator.handler(services, newRef, variables);
-      part.reset(std::move(newRef));
+      part.messages.clear();
+      part.messages.emplace_back(std::move(newRef.header));
+      part.messages.emplace_back(std::move(newRef.payload));
       activity.expiredSlots++;
 
       mTimesliceIndex.markAsDirty(slot, true);
@@ -536,7 +538,9 @@ DataRelayer::RelayChoice
       auto span = std::span<fair::mq::MessagePtr>(messages + mi, messages + mi + nPayloads + 1);
       // Notice this will split [(header, payload), (header, payload)] multiparts
       // in N different subParts for the message spec.
-      target.add([&span](size_t i) -> fair::mq::MessagePtr& { return span[i]; }, nPayloads + 1);
+      for (size_t i = 0; i < nPayloads + 1; ++i) {
+        target.messages.emplace_back(std::move(span[i]));
+      }
       mi += nPayloads;
       saved += nPayloads;
     }
@@ -955,7 +959,8 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeExistingInputsForTime
       auto& header = cache[cacheId].messages | get_header{pi};
       auto&& newHeader = header->GetTransport()->CreateMessage();
       newHeader->Copy(*header);
-      messages[arg].add(PartRef{std::move(newHeader), std::move(cache[cacheId].messages | get_payload{pi, 0})});
+      messages[arg].messages.emplace_back(std::move(newHeader));
+      messages[arg].messages.emplace_back(std::move(cache[cacheId].messages | get_payload{pi, 0}));
     }
   };
 
diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
index e3031b7e72a69..6da42c5a94aca 100644
--- a/Framework/Core/test/test_ForwardInputs.cxx
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -91,7 +91,8 @@ TEST_CASE("ForwardInputsSingleMessageSingleRoute")
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
@@ -142,7 +143,8 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteNoConsume")
   REQUIRE(payload.get() == nullptr);
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
@@ -197,7 +199,8 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteAtEOS")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph, sih});
   REQUIRE(o2::header::get<SourceInfoHeader*>(header->GetData()));
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
@@ -255,7 +258,8 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteWithOldestPossible")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph, dih});
   REQUIRE(o2::header::get<DomainInfoHeader*>(header->GetData()));
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
@@ -320,7 +324,8 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutes")
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
@@ -383,7 +388,8 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesExternals")
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
@@ -454,12 +460,14 @@ TEST_CASE("ForwardInputsMultiMessageMultipleRoutes")
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header1 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh1, dph});
   MessageSet messageSet1;
-  messageSet1.add(PartRef{std::move(header1), std::move(payload1)});
+  messageSet1.messages.emplace_back(std::move(header1));
+  messageSet1.messages.emplace_back(std::move(payload1));
   REQUIRE((messageSet1.messages | count_parts{}) == 1);
 
   auto header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
   MessageSet messageSet2;
-  messageSet2.add(PartRef{std::move(header2), std::move(payload2)});
+  messageSet2.messages.emplace_back(std::move(header2));
+  messageSet2.messages.emplace_back(std::move(payload2));
   REQUIRE((messageSet2.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet1));
   currentSetOfInputs.emplace_back(std::move(messageSet2));
@@ -524,7 +532,8 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesOnlyOneMatches")
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
@@ -602,10 +611,13 @@ TEST_CASE("ForwardInputsSplitPayload")
   auto fillMessages = [&messages](size_t t) -> fair::mq::MessagePtr {
     return std::move(messages[t]);
   };
-  messageSet.add(fillMessages, 3);
+  for (size_t i = 0; i < 3; ++i) {
+    messageSet.messages.emplace_back(fillMessages(i));
+  }
   auto header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
   PartRef part{std::move(header2), transport->CreateMessage()};
-  messageSet.add(std::move(part));
+  messageSet.messages.emplace_back(std::move(part.header));
+  messageSet.messages.emplace_back(std::move(part.payload));
 
   REQUIRE((messageSet.messages | count_parts{}) == 2);
   currentSetOfInputs.emplace_back(std::move(messageSet));
@@ -726,7 +738,8 @@ TEST_CASE("ForwardInputEOSSingleRoute")
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, sih});
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
@@ -771,7 +784,8 @@ TEST_CASE("ForwardInputOldestPossibleSingleRoute")
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dih});
-  messageSet.add(PartRef{std::move(header), std::move(payload)});
+  messageSet.messages.emplace_back(std::move(header));
+  messageSet.messages.emplace_back(std::move(payload));
   REQUIRE((messageSet.messages | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index bfbffb166da8d..d62a804e7681d 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -36,7 +36,9 @@ TEST_CASE("MessageSet")
   std::vector<fair::mq::MessagePtr> ptrs;
   ptrs.emplace_back(std::move(header));
   ptrs.emplace_back(std::move(msg2));
-  msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
+  for (size_t i = 0; i < 2; ++i) {
+    msgSet.messages.emplace_back(std::move(ptrs[i]));
+  }
 
   REQUIRE(msgSet.messages.size() == 2);
   REQUIRE((msgSet.messages | count_payloads{}) == 1);
@@ -126,7 +128,8 @@ TEST_CASE("MessageSetAddPartRef")
   ptrs.emplace_back(std::move(msg2));
   PartRef ref{std::move(msg), std::move(msg2)};
   o2::framework::MessageSet msgSet;
-  msgSet.add(std::move(ref));
+  msgSet.messages.emplace_back(std::move(ref.header));
+  msgSet.messages.emplace_back(std::move(ref.payload));
 
   REQUIRE(msgSet.messages.size() == 2);
 }
@@ -155,17 +158,18 @@ TEST_CASE("MessageSetAddMultiple")
   std::unique_ptr<fair::mq::Message> msg3(nullptr);
   PartRef ref{std::move(header1), std::move(msg2)};
   o2::framework::MessageSet msgSet;
-  msgSet.add(std::move(ref));
+  msgSet.messages.emplace_back(std::move(ref.header));
+  msgSet.messages.emplace_back(std::move(ref.payload));
   PartRef ref2{std::move(header2), std::move(msg2)};
-  msgSet.add(std::move(ref2));
+  msgSet.messages.emplace_back(std::move(ref2.header));
+  msgSet.messages.emplace_back(std::move(ref2.payload));
   std::vector<fair::mq::MessagePtr> msgs;
   msgs.push_back(std::move(header3));
   msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
   msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
-  msgSet.add([&msgs](size_t i) {
-    return std::move(msgs[i]);
-  },
-             3);
+  for (size_t i = 0; i < 3; ++i) {
+    msgSet.messages.emplace_back(std::move(msgs[i]));
+  }
 
   REQUIRE(msgSet.messages.size() == 7);
 

From 65b055fdccb1fd6f8c850cb959a49cb615c3828f Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 14:50:58 +0200
Subject: [PATCH 1496/1764] Get rid of the clear Method

---
 Framework/Core/include/Framework/MessageSet.h | 9 ++-------
 Framework/Core/src/DataProcessingDevice.cxx   | 2 +-
 Framework/Core/src/DataRelayer.cxx            | 6 +++---
 3 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
index 233099e67dc0f..1da8ca35c46f4 100644
--- a/Framework/Core/include/Framework/MessageSet.h
+++ b/Framework/Core/include/Framework/MessageSet.h
@@ -51,7 +51,7 @@ struct MessageSet {
   MessageSet(MessageSet&& other)
     : messages(std::move(other.messages))
   {
-    other.clear();
+    other.messages.clear();
   }
 
   MessageSet& operator=(MessageSet&& other)
@@ -60,15 +60,10 @@ struct MessageSet {
       return *this;
     }
     messages = std::move(other.messages);
-    other.clear();
+    other.messages.clear();
     return *this;
   }
 
-  /// clear the set
-  void clear()
-  {
-    messages.clear();
-  }
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 9b6395a02916a..af23219bfb509 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -2215,7 +2215,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
         continue;
       }
       // This will hopefully delete the message.
-      currentSetOfInputs[ii].clear();
+      currentSetOfInputs[ii].messages.clear();
     }
   };
 
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index d34d12b282a9d..dd051a2189c07 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -431,7 +431,7 @@ void DataRelayer::pruneCache(TimesliceSlot slot, OnDropCallback onDrop)
     // will be ignored.
     assert(numInputTypes * slot.index < cache.size());
     for (size_t ai = slot.index * numInputTypes, ae = ai + numInputTypes; ai != ae; ++ai) {
-      cache[ai].clear();
+      cache[ai].messages.clear();
       cachedStateMetrics[ai] = CacheEntryStatus::EMPTY;
     }
   };
@@ -914,7 +914,7 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeAllInputsForTimeslice
   auto invalidateCacheFor = [&numInputTypes, &index, &cache](TimesliceSlot s) {
     for (size_t ai = s.index * numInputTypes, ae = ai + numInputTypes; ai != ae; ++ai) {
       assert(std::accumulate(cache[ai].messages.begin(), cache[ai].messages.end(), true, [](bool result, auto const& element) { return result && element.get() == nullptr; }));
-      cache[ai].clear();
+      cache[ai].messages.clear();
     }
     index.markAsInvalid(s);
   };
@@ -978,7 +978,7 @@ void DataRelayer::clear()
   std::scoped_lock<O2_LOCKABLE(std::recursive_mutex)> lock(mMutex);
 
   for (auto& cache : mCache) {
-    cache.clear();
+    cache.messages.clear();
   }
   for (size_t s = 0; s < mTimesliceIndex.size(); ++s) {
     mTimesliceIndex.markAsInvalid(TimesliceSlot{s});

From c85788dfb6aa87cf3e7df348d58deddb2ba673ba Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 14:50:58 +0200
Subject: [PATCH 1497/1764] DPL: migrate away from MessageSet

Use a vector of messages instead. To be replaced by a B-Tree which
is able to keep track of all inputs / slots in a less rigid manner.
---
 .../Core/include/Framework/DataModelViews.h   |   8 +-
 .../include/Framework/DataProcessingHelpers.h |   4 +-
 .../Core/include/Framework/DataRelayer.h      |  10 +-
 Framework/Core/include/Framework/MessageSet.h |  71 ----
 Framework/Core/src/DataProcessingDevice.cxx   |  27 +-
 Framework/Core/src/DataProcessingHelpers.cxx  |   4 +-
 Framework/Core/src/DataRelayer.cxx            |  79 ++---
 Framework/Core/test/benchmark_DataRelayer.cxx |  23 +-
 Framework/Core/test/test_DataRelayer.cxx      |  25 +-
 Framework/Core/test/test_ForwardInputs.cxx    | 125 ++++---
 Framework/Core/test/test_MessageSet.cxx       | 331 ++++++++----------
 11 files changed, 296 insertions(+), 411 deletions(-)
 delete mode 100644 Framework/Core/include/Framework/MessageSet.h

diff --git a/Framework/Core/include/Framework/DataModelViews.h b/Framework/Core/include/Framework/DataModelViews.h
index 7c39a94950e9c..285f5ef15154e 100644
--- a/Framework/Core/include/Framework/DataModelViews.h
+++ b/Framework/Core/include/Framework/DataModelViews.h
@@ -16,7 +16,9 @@
 #include "DomainInfoHeader.h"
 #include "SourceInfoHeader.h"
 #include "Headers/DataHeader.h"
+#include "Framework/TimesliceSlot.h"
 #include <ranges>
+#include <span>
 
 namespace o2::framework
 {
@@ -213,13 +215,11 @@ struct get_num_payloads {
   }
 };
 
-struct MessageSet;
-
 struct inputs_for_slot {
   TimesliceSlot slot;
   template <typename R>
     requires requires(R r) { requires std::ranges::random_access_range<decltype(r.sets)>; }
-  friend std::span<o2::framework::MessageSet> operator|(R&& r, inputs_for_slot self)
+  friend auto operator|(R&& r, inputs_for_slot self)
   {
     return std::span(r.sets[self.slot.index * r.inputsPerSlot]);
   }
@@ -231,7 +231,7 @@ struct messages_for_input {
     requires std::ranges::random_access_range<R>
   friend std::span<fair::mq::MessagePtr> operator|(R&& r, messages_for_input self)
   {
-    return r[self.inputIdx].messages;
+    return std::span(r[self.inputIdx]);
   }
 };
 
diff --git a/Framework/Core/include/Framework/DataProcessingHelpers.h b/Framework/Core/include/Framework/DataProcessingHelpers.h
index 87aeeb8922da3..f414e3aa4ae00 100644
--- a/Framework/Core/include/Framework/DataProcessingHelpers.h
+++ b/Framework/Core/include/Framework/DataProcessingHelpers.h
@@ -15,6 +15,7 @@
 #include "Framework/TimesliceSlot.h"
 #include "Framework/TimesliceIndex.h"
 #include <fairmq/FwdDecls.h>
+#include <fairmq/Message.h>
 #include <vector>
 #include <span>
 
@@ -29,7 +30,6 @@ struct OutputChannelState;
 struct ProcessingPolicies;
 struct DeviceSpec;
 struct FairMQDeviceProxy;
-struct MessageSet;
 struct ChannelIndex;
 enum struct StreamingState;
 enum struct TransitionHandlingState;
@@ -54,7 +54,7 @@ struct DataProcessingHelpers {
   /// starts the EoS timers and returns the new TransitionHandlingState in case as new state is requested
   static TransitionHandlingState updateStateTransition(ServiceRegistryRef const& ref, ProcessingPolicies const& policies);
   /// Helper to route messages for forwarding
-  static std::vector<fair::mq::Parts> routeForwardedMessageSet(FairMQDeviceProxy& proxy, std::vector<MessageSet>& currentSetOfInputs,
+  static std::vector<fair::mq::Parts> routeForwardedMessageSet(FairMQDeviceProxy& proxy, std::vector<std::vector<fair::mq::MessagePtr>>& currentSetOfInputs,
                                                                bool copy, bool consume);
   /// Helper to route messages for forwarding
   static void routeForwardedMessages(FairMQDeviceProxy& proxy, std::span<fair::mq::MessagePtr>& currentSetOfInputs, std::vector<fair::mq::Parts>& forwardedParts,
diff --git a/Framework/Core/include/Framework/DataRelayer.h b/Framework/Core/include/Framework/DataRelayer.h
index e5a2aecea1de4..b56a2cb59ff10 100644
--- a/Framework/Core/include/Framework/DataRelayer.h
+++ b/Framework/Core/include/Framework/DataRelayer.h
@@ -16,7 +16,7 @@
 #include "Framework/DataDescriptorMatcher.h"
 #include "Framework/ForwardRoute.h"
 #include "Framework/CompletionPolicy.h"
-#include "Framework/MessageSet.h"
+#include <fairmq/Message.h>
 #include "Framework/TimesliceIndex.h"
 #include "Framework/Tracing.h"
 #include "Framework/TimesliceSlot.h"
@@ -113,7 +113,7 @@ class DataRelayer
   ActivityStats processDanglingInputs(std::vector<ExpirationHandler> const&,
                                       ServiceRegistryRef context, bool createNew);
 
-  using OnDropCallback = std::function<void(TimesliceSlot, std::vector<MessageSet>&, TimesliceIndex::OldestOutputInfo info)>;
+  using OnDropCallback = std::function<void(TimesliceSlot, std::vector<std::vector<fair::mq::MessagePtr>>&, TimesliceIndex::OldestOutputInfo info)>;
 
   // Callback for when some messages are about to be owned by the the DataRelayer
   using OnInsertionCallback = std::function<void(ServiceRegistryRef&, std::span<fair::mq::MessagePtr>&)>;
@@ -156,8 +156,8 @@ class DataRelayer
   /// Returns an input registry associated to the given timeslice and gives
   /// ownership to the caller. This is because once the inputs are out of the
   /// DataRelayer they need to be deleted once the processing is concluded.
-  std::vector<MessageSet> consumeAllInputsForTimeslice(TimesliceSlot id);
-  std::vector<MessageSet> consumeExistingInputsForTimeslice(TimesliceSlot id);
+  std::vector<std::vector<fair::mq::MessagePtr>> consumeAllInputsForTimeslice(TimesliceSlot id);
+  std::vector<std::vector<fair::mq::MessagePtr>> consumeExistingInputsForTimeslice(TimesliceSlot id);
 
   /// Returns how many timeslices we can handle in parallel
   [[nodiscard]] size_t getParallelTimeslices() const;
@@ -203,7 +203,7 @@ class DataRelayer
   /// Notice that we store them as a NxM sized vector, where
   /// N is the maximum number of inflight timeslices, while
   /// M is the number of inputs which are requested.
-  std::vector<MessageSet> mCache;
+  std::vector<std::vector<fair::mq::MessagePtr>> mCache;
 
   /// This is the index which maps a given timestamp to the associated
   /// cacheline.
diff --git a/Framework/Core/include/Framework/MessageSet.h b/Framework/Core/include/Framework/MessageSet.h
deleted file mode 100644
index 1da8ca35c46f4..0000000000000
--- a/Framework/Core/include/Framework/MessageSet.h
+++ /dev/null
@@ -1,71 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-#ifndef FRAMEWORK_MESSAGESET_H
-#define FRAMEWORK_MESSAGESET_H
-
-#include "Framework/PartRef.h"
-#include <fairmq/Message.h>
-#include "Framework/DataModelViews.h"
-#include <memory>
-#include <vector>
-#include <cassert>
-
-namespace o2::framework
-{
-
-/// A set of inflight messages.
-/// The messages are stored in a linear vector. Originally, an O2 message was
-/// comprised of a header-payload pair which makes indexing of pairs in the
-/// storage simple. To support O2 messages with multiple payloads in a future
-/// update of the data model, a message index is needed to store position in the
-/// linear storage and number of messages.
-/// DPL InputRecord API is providing refs of header-payload pairs, the original
-/// O2 message model. For this purpose, also the pair index is filled and can
-/// be used to access header and payload associated with a pair
-struct MessageSet {
-  // linear storage of messages
-  std::vector<fair::mq::MessagePtr> messages;
-
-  MessageSet()
-    : messages()
-  {
-  }
-
-  template <typename F>
-  MessageSet(F getter, size_t size)
-    : messages()
-  {
-    for (size_t i = 0; i < size; ++i) {
-      messages.emplace_back(std::move(getter(i)));
-    }
-  }
-
-  MessageSet(MessageSet&& other)
-    : messages(std::move(other.messages))
-  {
-    other.messages.clear();
-  }
-
-  MessageSet& operator=(MessageSet&& other)
-  {
-    if (&other == this) {
-      return *this;
-    }
-    messages = std::move(other.messages);
-    other.messages.clear();
-    return *this;
-  }
-
-};
-
-} // namespace o2::framework
-
-#endif // FRAMEWORK_MESSAGESET_H
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index af23219bfb509..6b90747550278 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -50,6 +50,7 @@
 
 #include "DecongestionService.h"
 #include "Framework/DataProcessingHelpers.h"
+#include "Framework/DataModelViews.h"
 #include "DataRelayerHelpers.h"
 #include "Headers/DataHeader.h"
 #include "Headers/DataHeaderHelpers.h"
@@ -585,7 +586,7 @@ auto decongestionCallbackLate = [](AsyncTask& task, size_t aid) -> void {
 // the inputs which are shared between this device and others
 // to the next one in the daisy chain.
 // FIXME: do it in a smarter way than O(N^2)
-static auto forwardInputs = [](ServiceRegistryRef registry, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
+static auto forwardInputs = [](ServiceRegistryRef registry, TimesliceSlot slot, std::vector<std::vector<fair::mq::MessagePtr>>& currentSetOfInputs,
                                TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume = true) {
   auto& proxy = registry.get<FairMQDeviceProxy>();
 
@@ -617,7 +618,7 @@ static auto forwardInputs = [](ServiceRegistryRef registry, TimesliceSlot slot,
   O2_SIGNPOST_END(forwarding, sid, "forwardInputs", "Forwarding done");
 };
 
-static auto cleanEarlyForward = [](ServiceRegistryRef registry, TimesliceSlot slot, std::vector<MessageSet>& currentSetOfInputs,
+static auto cleanEarlyForward = [](ServiceRegistryRef registry, TimesliceSlot slot, std::vector<std::vector<fair::mq::MessagePtr>>& currentSetOfInputs,
                                    TimesliceIndex::OldestOutputInfo oldestTimeslice, bool copy, bool consume = true) {
   auto& proxy = registry.get<FairMQDeviceProxy>();
 
@@ -627,7 +628,7 @@ static auto cleanEarlyForward = [](ServiceRegistryRef registry, TimesliceSlot sl
   // Always copy them, because we do not want to actually send them.
   // We merely need the side effect of the consume, if applicable.
   for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
-    auto span = std::span<fair::mq::MessagePtr>(currentSetOfInputs[ii].messages);
+    auto span = std::span<fair::mq::MessagePtr>(currentSetOfInputs[ii]);
     DataProcessingHelpers::cleanForwardedMessages(span, consume);
   }
 
@@ -1278,7 +1279,7 @@ void DataProcessingDevice::Run()
       // - we can trigger further events from the queue
       // - we can guarantee this is the last thing we do in the loop (
       //   assuming no one else is adding to the queue before this point).
-      auto onDrop = [&registry = mServiceRegistry, lid](TimesliceSlot slot, std::vector<MessageSet>& dropped, TimesliceIndex::OldestOutputInfo oldestOutputInfo) {
+      auto onDrop = [&registry = mServiceRegistry, lid](TimesliceSlot slot, std::vector<std::vector<fair::mq::MessagePtr>>& dropped, TimesliceIndex::OldestOutputInfo oldestOutputInfo) {
         O2_SIGNPOST_START(device, lid, "run_loop", "Dropping message from slot %" PRIu64 ". Forwarding as needed.", (uint64_t)slot.index);
         ServiceRegistryRef ref{registry};
         ref.get<AsyncQueue>();
@@ -1944,7 +1945,7 @@ void DataProcessingDevice::handleData(ServiceRegistryRef ref, InputChannelInfo&
             nPayloadsPerHeader = 1;
             ii += (nMessages / 2) - 1;
           }
-          auto onDrop = [ref](TimesliceSlot slot, std::vector<MessageSet>& dropped, TimesliceIndex::OldestOutputInfo oldestOutputInfo) {
+          auto onDrop = [ref](TimesliceSlot slot, std::vector<std::vector<fair::mq::MessagePtr>>& dropped, TimesliceIndex::OldestOutputInfo oldestOutputInfo) {
             O2_SIGNPOST_ID_GENERATE(cid, async_queue);
             O2_SIGNPOST_EVENT_EMIT(async_queue, cid, "onDrop", "Dropping message from slot %zu. Forwarding as needed. Timeslice %zu",
                                    slot.index, oldestOutputInfo.timeslice.value);
@@ -2122,7 +2123,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
   // want to support multithreaded dispatching of operations, I can simply
   // move these to some thread local store and the rest of the lambdas
   // should work just fine.
-  std::vector<MessageSet> currentSetOfInputs;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
 
   //
   auto getInputSpan = [ref, &currentSetOfInputs](TimesliceSlot slot, bool consume = true) {
@@ -2133,7 +2134,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
       currentSetOfInputs = relayer.consumeExistingInputsForTimeslice(slot);
     }
     auto getter = [&currentSetOfInputs](size_t i, size_t partindex) -> DataRef {
-      if ((currentSetOfInputs[i].messages | count_payloads{}) > partindex) {
+      if ((currentSetOfInputs[i] | count_payloads{}) > partindex) {
         const char* headerptr = nullptr;
         const char* payloadptr = nullptr;
         size_t payloadSize = 0;
@@ -2142,9 +2143,9 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
         //   sequence is the header message
         // - each part has one or more payload messages
         // - InputRecord provides all payloads as header-payload pair
-        auto const indices = currentSetOfInputs[i].messages | get_pair{partindex};
-        auto const& headerMsg = currentSetOfInputs[i].messages[indices.headerIdx];
-        auto const& payloadMsg = currentSetOfInputs[i].messages[indices.payloadIdx];
+        auto const indices = currentSetOfInputs[i] | get_pair{partindex};
+        auto const& headerMsg = currentSetOfInputs[i][indices.headerIdx];
+        auto const& payloadMsg = currentSetOfInputs[i][indices.payloadIdx];
         headerptr = static_cast<char const*>(headerMsg->GetData());
         payloadptr = payloadMsg ? static_cast<char const*>(payloadMsg->GetData()) : nullptr;
         payloadSize = payloadMsg ? payloadMsg->GetSize() : 0;
@@ -2153,10 +2154,10 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
       return DataRef{};
     };
     auto nofPartsGetter = [&currentSetOfInputs](size_t i) -> size_t {
-      return (currentSetOfInputs[i].messages | count_payloads{});
+      return (currentSetOfInputs[i] | count_payloads{});
     };
     auto refCountGetter = [&currentSetOfInputs](size_t idx) -> int {
-      auto& header = static_cast<const fair::mq::shmem::Message&>(*(currentSetOfInputs[idx].messages | get_header{0}));
+      auto& header = static_cast<const fair::mq::shmem::Message&>(*(currentSetOfInputs[idx] | get_header{0}));
       return header.GetRefCount();
     };
     return InputSpan{getter, nofPartsGetter, refCountGetter, currentSetOfInputs.size()};
@@ -2215,7 +2216,7 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
         continue;
       }
       // This will hopefully delete the message.
-      currentSetOfInputs[ii].messages.clear();
+      currentSetOfInputs[ii].clear();
     }
   };
 
diff --git a/Framework/Core/src/DataProcessingHelpers.cxx b/Framework/Core/src/DataProcessingHelpers.cxx
index 334a0fc6045f6..b8399a4c591e7 100644
--- a/Framework/Core/src/DataProcessingHelpers.cxx
+++ b/Framework/Core/src/DataProcessingHelpers.cxx
@@ -393,14 +393,14 @@ void DataProcessingHelpers::cleanForwardedMessages(std::span<fair::mq::MessagePt
 }
 
 auto DataProcessingHelpers::routeForwardedMessageSet(FairMQDeviceProxy& proxy,
-                                                     std::vector<MessageSet>& currentSetOfInputs,
+                                                     std::vector<std::vector<fair::mq::MessagePtr>>& currentSetOfInputs,
                                                      const bool copyByDefault, bool consume) -> std::vector<fair::mq::Parts>
 {
   // we collect all messages per forward in a map and send them together
   std::vector<fair::mq::Parts> forwardedParts(proxy.getNumForwardChannels());
 
   for (size_t ii = 0, ie = currentSetOfInputs.size(); ii < ie; ++ii) {
-    auto span = std::span<fair::mq::MessagePtr>(currentSetOfInputs[ii].messages);
+    auto span = std::span<fair::mq::MessagePtr>(currentSetOfInputs[ii]);
     routeForwardedMessages(proxy, span, forwardedParts, copyByDefault, consume);
   }
   return forwardedParts;
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index dd051a2189c07..fc9966ffad643 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -38,6 +38,7 @@
 #include "Framework/DataTakingContext.h"
 #include "Framework/DefaultsHelpers.h"
 #include "Framework/RawDeviceService.h"
+#include "Framework/DataModelViews.h"
 
 #include "Headers/DataHeaderHelpers.h"
 #include "Framework/Formatters.h"
@@ -184,11 +185,11 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       // We check that no data is already there for the given cell
       // it is enough to check the first element
       auto& part = mCache[ti * mDistinctRoutesIndex.size() + expirator.routeIndex.value];
-      if (!part.messages.empty() && (part.messages | get_header{0}) != nullptr) {
+      if (!part.empty() && (part | get_header{0}) != nullptr) {
         headerPresent++;
         continue;
       }
-      if (!part.messages.empty() && (part.messages | get_payload{0, 0}) != nullptr) {
+      if (!part.empty() && (part | get_payload{0, 0}) != nullptr) {
         payloadPresent++;
         continue;
       }
@@ -202,7 +203,7 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
         continue;
       }
 
-      auto getPartialRecord = [&cache = mCache, numInputTypes = mDistinctRoutesIndex.size()](int li) -> std::span<MessageSet const> {
+      auto getPartialRecord = [&cache = mCache, numInputTypes = mDistinctRoutesIndex.size()](int li) -> std::span<std::vector<fair::mq::MessagePtr> const> {
         auto offset = li * numInputTypes;
         assert(cache.size() >= offset + numInputTypes);
         auto const start = cache.data() + offset;
@@ -213,9 +214,9 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       auto partial = getPartialRecord(ti);
       // TODO: get the data ref from message model
       auto getter = [&partial](size_t idx, size_t part) {
-        if (!partial[idx].messages.empty() && (partial[idx].messages | get_header{part}).get()) {
-          auto header = (partial[idx].messages | get_header{part}).get();
-          auto payload = (partial[idx].messages | get_payload{part, 0}).get();
+        if (!partial[idx].empty() && (partial[idx] | get_header{part}).get()) {
+          auto header = (partial[idx] | get_header{part}).get();
+          auto payload = (partial[idx] | get_payload{part, 0}).get();
           return DataRef{nullptr,
                          reinterpret_cast<const char*>(header->GetData()),
                          reinterpret_cast<char const*>(payload ? payload->GetData() : nullptr),
@@ -224,10 +225,10 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
         return DataRef{};
       };
       auto nPartsGetter = [&partial](size_t idx) {
-        return partial[idx].messages | count_parts{};
+        return partial[idx] | count_parts{};
       };
       auto refCountGetter = [&partial](size_t idx) -> int {
-        auto& header = static_cast<const fair::mq::shmem::Message&>(*(partial[idx].messages | get_header{0}));
+        auto& header = static_cast<const fair::mq::shmem::Message&>(*(partial[idx] | get_header{0}));
         return header.GetRefCount();
       };
       InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
@@ -242,14 +243,14 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       assert(expirator.handler);
       PartRef newRef;
       expirator.handler(services, newRef, variables);
-      part.messages.clear();
-      part.messages.emplace_back(std::move(newRef.header));
-      part.messages.emplace_back(std::move(newRef.payload));
+      part.clear();
+      part.emplace_back(std::move(newRef.header));
+      part.emplace_back(std::move(newRef.payload));
       activity.expiredSlots++;
 
       mTimesliceIndex.markAsDirty(slot, true);
-      assert((part.messages | get_header{0}) != nullptr);
-      assert((part.messages | get_payload{0, 0}) != nullptr);
+      assert((part | get_header{0}) != nullptr);
+      assert((part | get_payload{0, 0}) != nullptr);
     }
   }
   LOGP(debug, "DataRelayer::processDanglingInputs headerPresent:{}, payloadPresent:{}, noCheckers:{}, badSlot:{}, checkerDenied:{}",
@@ -329,7 +330,7 @@ void DataRelayer::setOldestPossibleInput(TimesliceId proposed, ChannelIndex chan
     for (size_t mi = 0; mi < mInputs.size(); ++mi) {
       auto& input = mInputs[mi];
       auto& element = mCache[si * mInputs.size() + mi];
-      if (!element.messages.empty()) {
+      if (!element.empty()) {
         if (input.lifetime != Lifetime::Condition && mCompletionPolicy.name != "internal-dpl-injected-dummy-sink") {
           didDrop = true;
           auto& state = mContext.get<DeviceState>();
@@ -355,7 +356,7 @@ void DataRelayer::setOldestPossibleInput(TimesliceId proposed, ChannelIndex chan
           continue;
         }
         auto& element = mCache[si * mInputs.size() + mi];
-        if (element.messages.empty()) {
+        if (element.empty()) {
           auto& state = mContext.get<DeviceState>();
           if (state.transitionHandling != TransitionHandlingState::NoTransition && DefaultsHelpers::onlineDeploymentMode()) {
             if (state.allowedProcessing == DeviceState::CalibrationOnly) {
@@ -407,17 +408,17 @@ void DataRelayer::pruneCache(TimesliceSlot slot, OnDropCallback onDrop)
     if (onDrop) {
       auto oldestPossibleTimeslice = index.getOldestPossibleOutput();
       // State of the computation
-      std::vector<MessageSet> dropped(numInputTypes);
+      std::vector<std::vector<fair::mq::MessagePtr>> dropped(numInputTypes);
       for (size_t ai = 0, ae = numInputTypes; ai != ae; ++ai) {
         auto cacheId = slot.index * numInputTypes + ai;
         cachedStateMetrics[cacheId] = CacheEntryStatus::RUNNING;
         // TODO: in the original implementation of the cache, there have been only two messages per entry,
         // check if the 2 above corresponds to the number of messages.
-        if (!cache[cacheId].messages.empty()) {
+        if (!cache[cacheId].empty()) {
           dropped[ai] = std::move(cache[cacheId]);
         }
       }
-      bool anyDropped = std::any_of(dropped.begin(), dropped.end(), [](auto& m) { return !m.messages.empty(); });
+      bool anyDropped = std::any_of(dropped.begin(), dropped.end(), [](auto& m) { return !m.empty(); });
       if (anyDropped) {
         O2_SIGNPOST_ID_GENERATE(aid, data_relayer);
         O2_SIGNPOST_EVENT_EMIT(data_relayer, aid, "pruneCache", "Dropping stuff from slot %zu with timeslice %zu", slot.index, oldestPossibleTimeslice.timeslice.value);
@@ -431,7 +432,7 @@ void DataRelayer::pruneCache(TimesliceSlot slot, OnDropCallback onDrop)
     // will be ignored.
     assert(numInputTypes * slot.index < cache.size());
     for (size_t ai = slot.index * numInputTypes, ae = ai + numInputTypes; ai != ae; ++ai) {
-      cache[ai].messages.clear();
+      cache[ai].clear();
       cachedStateMetrics[ai] = CacheEntryStatus::EMPTY;
     }
   };
@@ -508,7 +509,7 @@ DataRelayer::RelayChoice
                            timeslice.value, slot.index,
                            info.index.value == ChannelIndex::INVALID ? "invalid" : services.get<FairMQDeviceProxy>().getInputChannel(info.index)->GetName().c_str());
     auto cacheIdx = numInputTypes * slot.index + input;
-    MessageSet& target = cache[cacheIdx];
+    auto& target = cache[cacheIdx];
     cachedStateMetrics[cacheIdx] = CacheEntryStatus::PENDING;
     // TODO: make sure that multiple parts can only be added within the same call of
     // DataRelayer::relay
@@ -539,7 +540,7 @@ DataRelayer::RelayChoice
       // Notice this will split [(header, payload), (header, payload)] multiparts
       // in N different subParts for the message spec.
       for (size_t i = 0; i < nPayloads + 1; ++i) {
-        target.messages.emplace_back(std::move(span[i]));
+        target.emplace_back(std::move(span[i]));
       }
       mi += nPayloads;
       saved += nPayloads;
@@ -732,7 +733,7 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
   //
   // We use this to bail out early from the check as soon as we find something
   // which we know is not complete.
-  auto getPartialRecord = [&cache, &numInputTypes](int li) -> std::span<MessageSet const> {
+  auto getPartialRecord = [&cache, &numInputTypes](int li) -> std::span<std::vector<fair::mq::MessagePtr> const> {
     auto offset = li * numInputTypes;
     assert(cache.size() >= offset + numInputTypes);
     auto const start = cache.data() + offset;
@@ -790,9 +791,9 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
     auto partial = getPartialRecord(li);
     // TODO: get the data ref from message model
     auto getter = [&partial](size_t idx, size_t part) {
-      if (!partial[idx].messages.empty() && (partial[idx].messages | get_header{part}).get()) {
-        auto header = (partial[idx].messages | get_header{part}).get();
-        auto payload = (partial[idx].messages | get_payload{part, 0}).get();
+      if (!partial[idx].empty() && (partial[idx] | get_header{part}).get()) {
+        auto header = (partial[idx] | get_header{part}).get();
+        auto payload = (partial[idx] | get_payload{part, 0}).get();
         return DataRef{nullptr,
                        reinterpret_cast<const char*>(header->GetData()),
                        reinterpret_cast<char const*>(payload ? payload->GetData() : nullptr),
@@ -801,10 +802,10 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
       return DataRef{};
     };
     auto nPartsGetter = [&partial](size_t idx) {
-      return partial[idx].messages | count_parts{};
+      return partial[idx] | count_parts{};
     };
     auto refCountGetter = [&partial](size_t idx) -> int {
-      auto& header = static_cast<const fair::mq::shmem::Message&>(*(partial[idx].messages | get_header{0}));
+      auto& header = static_cast<const fair::mq::shmem::Message&>(*(partial[idx] | get_header{0}));
       return header.GetRefCount();
     };
     InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
@@ -875,13 +876,13 @@ void DataRelayer::updateCacheStatus(TimesliceSlot slot, CacheEntryStatus oldStat
   }
 }
 
-std::vector<o2::framework::MessageSet> DataRelayer::consumeAllInputsForTimeslice(TimesliceSlot slot)
+std::vector<std::vector<fair::mq::MessagePtr>> DataRelayer::consumeAllInputsForTimeslice(TimesliceSlot slot)
 {
   std::scoped_lock<O2_LOCKABLE(std::recursive_mutex)> lock(mMutex);
 
   const auto numInputTypes = mDistinctRoutesIndex.size();
   // State of the computation
-  std::vector<MessageSet> messages(numInputTypes);
+  std::vector<std::vector<fair::mq::MessagePtr>> messages(numInputTypes);
   auto& cache = mCache;
   auto& index = mTimesliceIndex;
 
@@ -901,7 +902,7 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeAllInputsForTimeslice
     cachedStateMetrics[cacheId] = CacheEntryStatus::RUNNING;
     // TODO: in the original implementation of the cache, there have been only two messages per entry,
     // check if the 2 above corresponds to the number of messages.
-    if (!cache[cacheId].messages.empty()) {
+    if (!cache[cacheId].empty()) {
       messages[arg] = std::move(cache[cacheId]);
     }
     index.markAsInvalid(s);
@@ -913,8 +914,8 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeAllInputsForTimeslice
   // FIXME: what happens when we have enough timeslices to hit the invalid one?
   auto invalidateCacheFor = [&numInputTypes, &index, &cache](TimesliceSlot s) {
     for (size_t ai = s.index * numInputTypes, ae = ai + numInputTypes; ai != ae; ++ai) {
-      assert(std::accumulate(cache[ai].messages.begin(), cache[ai].messages.end(), true, [](bool result, auto const& element) { return result && element.get() == nullptr; }));
-      cache[ai].messages.clear();
+      assert(std::accumulate(cache[ai].begin(), cache[ai].end(), true, [](bool result, auto const& element) { return result && element.get() == nullptr; }));
+      cache[ai].clear();
     }
     index.markAsInvalid(s);
   };
@@ -929,13 +930,13 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeAllInputsForTimeslice
   return messages;
 }
 
-std::vector<o2::framework::MessageSet> DataRelayer::consumeExistingInputsForTimeslice(TimesliceSlot slot)
+std::vector<std::vector<fair::mq::MessagePtr>> DataRelayer::consumeExistingInputsForTimeslice(TimesliceSlot slot)
 {
   std::scoped_lock<O2_LOCKABLE(std::recursive_mutex)> lock(mMutex);
 
   const auto numInputTypes = mDistinctRoutesIndex.size();
   // State of the computation
-  std::vector<MessageSet> messages(numInputTypes);
+  std::vector<std::vector<fair::mq::MessagePtr>> messages(numInputTypes);
   auto& cache = mCache;
   auto& index = mTimesliceIndex;
 
@@ -955,12 +956,12 @@ std::vector<o2::framework::MessageSet> DataRelayer::consumeExistingInputsForTime
     cachedStateMetrics[cacheId] = CacheEntryStatus::RUNNING;
     // TODO: in the original implementation of the cache, there have been only two messages per entry,
     // check if the 2 above corresponds to the number of messages.
-    for (size_t pi = 0; pi < (cache[cacheId].messages | count_parts{}); pi++) {
-      auto& header = cache[cacheId].messages | get_header{pi};
+    for (size_t pi = 0; pi < (cache[cacheId] | count_parts{}); pi++) {
+      auto& header = cache[cacheId] | get_header{pi};
       auto&& newHeader = header->GetTransport()->CreateMessage();
       newHeader->Copy(*header);
-      messages[arg].messages.emplace_back(std::move(newHeader));
-      messages[arg].messages.emplace_back(std::move(cache[cacheId].messages | get_payload{pi, 0}));
+      messages[arg].emplace_back(std::move(newHeader));
+      messages[arg].emplace_back(std::move(cache[cacheId] | get_payload{pi, 0}));
     }
   };
 
@@ -978,7 +979,7 @@ void DataRelayer::clear()
   std::scoped_lock<O2_LOCKABLE(std::recursive_mutex)> lock(mMutex);
 
   for (auto& cache : mCache) {
-    cache.messages.clear();
+    cache.clear();
   }
   for (size_t s = 0; s < mTimesliceIndex.size(); ++s) {
     mTimesliceIndex.markAsInvalid(TimesliceSlot{s});
diff --git a/Framework/Core/test/benchmark_DataRelayer.cxx b/Framework/Core/test/benchmark_DataRelayer.cxx
index 312711d73e95e..e7df8fbb2fe9b 100644
--- a/Framework/Core/test/benchmark_DataRelayer.cxx
+++ b/Framework/Core/test/benchmark_DataRelayer.cxx
@@ -14,6 +14,7 @@
 #include "Headers/Stack.h"
 #include "Framework/CompletionPolicyHelpers.h"
 #include "Framework/DataRelayer.h"
+#include "Framework/DataModelViews.h"
 #include "Framework/DataProcessingHeader.h"
 #include "Framework/DataProcessingStates.h"
 #include "Framework/DataProcessingStats.h"
@@ -138,8 +139,8 @@ static void BM_RelaySingleSlot(benchmark::State& state)
     assert(ready[0].op == CompletionPolicy::CompletionOp::Consume);
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     assert(result.size() == 1);
-    assert((result.at(0).messages | count_parts{}) == 1);
-    inflightMessages = std::move(result[0].messages);
+    assert((result.at(0) | count_parts{}) == 1);
+    inflightMessages = std::move(result[0]);
   }
 }
 
@@ -194,8 +195,8 @@ static void BM_RelayMultipleSlots(benchmark::State& state)
     assert(ready[0].op == CompletionPolicy::CompletionOp::Consume);
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     assert(result.size() == 1);
-    assert((result.at(0).messages | count_parts{}) == 1);
-    inflightMessages = std::move(result[0].messages);
+    assert((result.at(0) | count_parts{}) == 1);
+    inflightMessages = std::move(result[0]);
   }
 }
 
@@ -268,11 +269,11 @@ static void BM_RelayMultipleRoutes(benchmark::State& state)
     assert(ready[0].op == CompletionPolicy::CompletionOp::Consume);
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     assert(result.size() == 2);
-    assert((result.at(0).messages | count_parts{}) == 1);
-    assert((result.at(1).messages | count_parts{}) == 1);
-    inflightMessages = std::move(result[0].messages);
-    inflightMessages.emplace_back(std::move(result[1].messages[0]));
-    inflightMessages.emplace_back(std::move(result[1].messages[1]));
+    assert((result.at(0) | count_parts{}) == 1);
+    assert((result.at(1) | count_parts{}) == 1);
+    inflightMessages = std::move(result[0]);
+    inflightMessages.emplace_back(std::move(result[1][0]));
+    inflightMessages.emplace_back(std::move(result[1][1]));
   }
 }
 
@@ -332,7 +333,7 @@ static void BM_RelaySplitParts(benchmark::State& state)
     relayer.getReadyToProcess(ready);
     assert(ready.size() == 1);
     assert(ready[0].op == CompletionPolicy::CompletionOp::Consume);
-    inflightMessages = std::move(relayer.consumeAllInputsForTimeslice(ready[0].slot)[0].messages);
+    inflightMessages = std::move(relayer.consumeAllInputsForTimeslice(ready[0].slot)[0]);
   }
 }
 
@@ -386,7 +387,7 @@ static void BM_RelayMultiplePayloads(benchmark::State& state)
     relayer.getReadyToProcess(ready);
     assert(ready.size() == 1);
     assert(ready[0].op == CompletionPolicy::CompletionOp::Consume);
-    inflightMessages = std::move(relayer.consumeAllInputsForTimeslice(ready[0].slot)[0].messages);
+    inflightMessages = std::move(relayer.consumeAllInputsForTimeslice(ready[0].slot)[0]);
   }
 }
 
diff --git a/Framework/Core/test/test_DataRelayer.cxx b/Framework/Core/test/test_DataRelayer.cxx
index 332a87970eda0..271b7829a9525 100644
--- a/Framework/Core/test/test_DataRelayer.cxx
+++ b/Framework/Core/test/test_DataRelayer.cxx
@@ -16,6 +16,7 @@
 #include "MemoryResources/MemoryResources.h"
 #include "Framework/CompletionPolicyHelpers.h"
 #include "Framework/DataRelayer.h"
+#include "Framework/DataModelViews.h"
 #include "Framework/DataProcessingStats.h"
 #include "Framework/DataProcessingStates.h"
 #include "Framework/DriverConfig.h"
@@ -119,7 +120,7 @@ TEST_CASE("DataRelayer")
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     // one MessageSet with one PartRef with header and payload
     REQUIRE(result.size() == 1);
-    REQUIRE((result.at(0).messages | count_parts{}) == 1);
+    REQUIRE((result.at(0) | count_parts{}) == 1);
   }
 
   //
@@ -169,7 +170,7 @@ TEST_CASE("DataRelayer")
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     // one MessageSet with one PartRef with header and payload
     REQUIRE(result.size() == 1);
-    REQUIRE((result.at(0).messages | count_parts{}) == 1);
+    REQUIRE((result.at(0) | count_parts{}) == 1);
   }
 
   // This test a more complicated set of inputs, and verifies that data is
@@ -249,8 +250,8 @@ TEST_CASE("DataRelayer")
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     // two MessageSets, each with one PartRef
     REQUIRE(result.size() == 2);
-    REQUIRE((result.at(0).messages | count_parts{}) == 1);
-    REQUIRE((result.at(1).messages | count_parts{}) == 1);
+    REQUIRE((result.at(0) | count_parts{}) == 1);
+    REQUIRE((result.at(1) | count_parts{}) == 1);
   }
 
   // This test a more complicated set of inputs, and verifies that data is
@@ -737,8 +738,8 @@ TEST_CASE("DataRelayer")
     // we have one input route and thus one message set containing pairs for all
     // payloads
     REQUIRE(messageSet.size() == 1);
-    REQUIRE((messageSet[0].messages | count_parts{}) == nSplitParts);
-    REQUIRE((messageSet[0].messages | get_num_payloads{0}) == 1);
+    REQUIRE((messageSet[0] | count_parts{}) == nSplitParts);
+    REQUIRE((messageSet[0] | get_num_payloads{0}) == 1);
   }
 
   SECTION("SplitPayloadSequence")
@@ -800,13 +801,13 @@ TEST_CASE("DataRelayer")
     // we have one input route
     REQUIRE(messageSet.size() == 1);
     // one message set containing number of added sequences of messages
-    REQUIRE((messageSet[0].messages | count_parts{}) == sequenceSize.size());
+    REQUIRE((messageSet[0] | count_parts{}) == sequenceSize.size());
     size_t counter = 0;
     for (size_t seqid = 0; seqid < sequenceSize.size(); ++seqid) {
-      REQUIRE((messageSet[0].messages | get_num_payloads{seqid}) == sequenceSize[seqid]);
-      for (size_t pi = 0; pi < (messageSet[0].messages | get_num_payloads{seqid}); ++pi) {
-        REQUIRE((messageSet[0].messages | get_payload{seqid, pi}));
-        auto const* data = (messageSet[0].messages | get_payload{seqid, pi})->GetData();
+      REQUIRE((messageSet[0] | get_num_payloads{seqid}) == sequenceSize[seqid]);
+      for (size_t pi = 0; pi < (messageSet[0] | get_num_payloads{seqid}); ++pi) {
+        REQUIRE((messageSet[0] | get_payload{seqid, pi}));
+        auto const* data = (messageSet[0] | get_payload{seqid, pi})->GetData();
         REQUIRE(*(reinterpret_cast<size_t const*>(data)) == counter);
         ++counter;
       }
@@ -891,7 +892,7 @@ TEST_CASE("DataRelayer")
 
     auto result = relayer.consumeAllInputsForTimeslice(ready[0].slot);
     REQUIRE(result.size() == 1);
-    REQUIRE((result.at(0).messages | count_parts{}) == 1);
+    REQUIRE((result.at(0) | count_parts{}) == 1);
   }
 
   SECTION("ProcessDanglingInputsSkipsWhenDataPresent")
diff --git a/Framework/Core/test/test_ForwardInputs.cxx b/Framework/Core/test/test_ForwardInputs.cxx
index 6da42c5a94aca..0263158ee0f9b 100644
--- a/Framework/Core/test/test_ForwardInputs.cxx
+++ b/Framework/Core/test/test_ForwardInputs.cxx
@@ -16,7 +16,7 @@
 #include "Framework/SourceInfoHeader.h"
 #include "Framework/DomainInfoHeader.h"
 #include "Framework/Signpost.h"
-#include "Framework/MessageSet.h"
+#include "Framework/DataModelViews.h"
 #include "Framework/FairMQDeviceProxy.h"
 #include "Headers/Stack.h"
 #include "MemoryResources/MemoryResources.h"
@@ -43,7 +43,7 @@ TEST_CASE("ForwardInputsEmpty")
   bool copyByDefault = true;
   FairMQDeviceProxy proxy;
 
-  std::vector<MessageSet> currentSetOfInputs;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
   REQUIRE(result.empty());
@@ -84,16 +84,16 @@ TEST_CASE("ForwardInputsSingleMessageSingleRoute")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -135,17 +135,17 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteNoConsume")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(nullptr);
   REQUIRE(payload.get() == nullptr);
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, true);
@@ -191,17 +191,17 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteAtEOS")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph, sih});
   REQUIRE(o2::header::get<SourceInfoHeader*>(header->GetData()));
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -250,17 +250,17 @@ TEST_CASE("ForwardInputsSingleMessageSingleRouteWithOldestPossible")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph, dih});
   REQUIRE(o2::header::get<DomainInfoHeader*>(header->GetData()));
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -317,16 +317,16 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutes")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -381,16 +381,16 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesExternals")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -452,23 +452,23 @@ TEST_CASE("ForwardInputsMultiMessageMultipleRoutes")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload1(transport->CreateMessage());
   fair::mq::MessagePtr payload2(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header1 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh1, dph});
-  MessageSet messageSet1;
-  messageSet1.messages.emplace_back(std::move(header1));
-  messageSet1.messages.emplace_back(std::move(payload1));
-  REQUIRE((messageSet1.messages | count_parts{}) == 1);
+  std::vector<fair::mq::MessagePtr> messageSet1;
+  messageSet1.emplace_back(std::move(header1));
+  messageSet1.emplace_back(std::move(payload1));
+  REQUIRE((messageSet1 | count_parts{}) == 1);
 
   auto header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
-  MessageSet messageSet2;
-  messageSet2.messages.emplace_back(std::move(header2));
-  messageSet2.messages.emplace_back(std::move(payload2));
-  REQUIRE((messageSet2.messages | count_parts{}) == 1);
+  std::vector<fair::mq::MessagePtr> messageSet2;
+  messageSet2.emplace_back(std::move(header2));
+  messageSet2.emplace_back(std::move(payload2));
+  REQUIRE((messageSet2 | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet1));
   currentSetOfInputs.emplace_back(std::move(messageSet2));
   REQUIRE(currentSetOfInputs.size() == 2);
@@ -525,16 +525,16 @@ TEST_CASE("ForwardInputsSingleMessageMultipleRoutesOnlyOneMatches")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph});
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -596,8 +596,8 @@ TEST_CASE("ForwardInputsSplitPayload")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload1(transport->CreateMessage());
@@ -612,14 +612,13 @@ TEST_CASE("ForwardInputsSplitPayload")
     return std::move(messages[t]);
   };
   for (size_t i = 0; i < 3; ++i) {
-    messageSet.messages.emplace_back(fillMessages(i));
+    messageSet.emplace_back(fillMessages(i));
   }
   auto header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
-  PartRef part{std::move(header2), transport->CreateMessage()};
-  messageSet.messages.emplace_back(std::move(part.header));
-  messageSet.messages.emplace_back(std::move(part.payload));
+  messageSet.emplace_back(std::move(header2));
+  messageSet.emplace_back(transport->CreateMessage());
 
-  REQUIRE((messageSet.messages | count_parts{}) == 2);
+  REQUIRE((messageSet | count_parts{}) == 2);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -731,16 +730,16 @@ TEST_CASE("ForwardInputEOSSingleRoute")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, sih});
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
@@ -777,16 +776,16 @@ TEST_CASE("ForwardInputOldestPossibleSingleRoute")
 
   proxy.bind({}, {}, routes, findChannelByName, nullptr);
 
-  std::vector<MessageSet> currentSetOfInputs;
-  MessageSet messageSet;
+  std::vector<std::vector<fair::mq::MessagePtr>> currentSetOfInputs;
+  std::vector<fair::mq::MessagePtr> messageSet;
 
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   auto header = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dih});
-  messageSet.messages.emplace_back(std::move(header));
-  messageSet.messages.emplace_back(std::move(payload));
-  REQUIRE((messageSet.messages | count_parts{}) == 1);
+  messageSet.emplace_back(std::move(header));
+  messageSet.emplace_back(std::move(payload));
+  REQUIRE((messageSet | count_parts{}) == 1);
   currentSetOfInputs.emplace_back(std::move(messageSet));
 
   auto result = o2::framework::DataProcessingHelpers::routeForwardedMessageSet(proxy, currentSetOfInputs, copyByDefault, consume);
diff --git a/Framework/Core/test/test_MessageSet.cxx b/Framework/Core/test/test_MessageSet.cxx
index d62a804e7681d..caa9a60323306 100644
--- a/Framework/Core/test/test_MessageSet.cxx
+++ b/Framework/Core/test/test_MessageSet.cxx
@@ -11,9 +11,9 @@
 
 #include <fairmq/Message.h>
 #include <fairmq/TransportFactory.h>
-#include "Framework/MessageSet.h"
 #include "Framework/DataModelViews.h"
 #include "Framework/DataProcessingHeader.h"
+#include "Framework/PartRef.h"
 #include "Headers/Stack.h"
 #include "Headers/DataHeader.h"
 #include "MemoryResources/MemoryResources.h"
@@ -23,7 +23,7 @@ using namespace o2::framework;
 
 TEST_CASE("MessageSet")
 {
-  o2::framework::MessageSet msgSet;
+  std::vector<fair::mq::MessagePtr> messages;
   o2::header::DataHeader dh{};
   dh.splitPayloadParts = 0;
   dh.splitPayloadIndex = 0;
@@ -37,21 +37,18 @@ TEST_CASE("MessageSet")
   ptrs.emplace_back(std::move(header));
   ptrs.emplace_back(std::move(msg2));
   for (size_t i = 0; i < 2; ++i) {
-    msgSet.messages.emplace_back(std::move(ptrs[i]));
+    messages.emplace_back(std::move(ptrs[i]));
   }
 
-  REQUIRE(msgSet.messages.size() == 2);
-  REQUIRE((msgSet.messages | count_payloads{}) == 1);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  CHECK_THROWS((msgSet.messages | get_pair{1}));
-  REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
-  REQUIRE((msgSet.messages | count_parts{}) == 1);
-  // messages: [hdr, pl] — one pair
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE(messages.size() == 2);
+  REQUIRE((messages | count_payloads{}) == 1);
+  REQUIRE((messages | get_dataref_indices{0, 0}).headerIdx == 0);
+  REQUIRE((messages | get_dataref_indices{0, 0}).payloadIdx == 1);
+  REQUIRE((messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((messages | get_pair{0}).payloadIdx == 1);
+  CHECK_THROWS((messages | get_pair{1}));
+  REQUIRE((messages | get_num_payloads{0}) == 1);
+  REQUIRE((messages | count_parts{}) == 1);
 }
 
 TEST_CASE("MessageSetWithFunction")
@@ -68,17 +65,20 @@ TEST_CASE("MessageSetWithFunction")
   std::unique_ptr<fair::mq::Message> msg2(nullptr);
   ptrs.emplace_back(std::move(header));
   ptrs.emplace_back(std::move(msg2));
-  o2::framework::MessageSet msgSet([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
-
-  REQUIRE(msgSet.messages.size() == 2);
-  REQUIRE((msgSet.messages | count_payloads{}) == 1);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  CHECK_THROWS((msgSet.messages | get_pair{1}));
-  REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
-  REQUIRE((msgSet.messages | count_parts{}) == 1);
+  std::vector<fair::mq::MessagePtr> messages;
+  for (size_t i = 0; i < 2; ++i) {
+    messages.emplace_back(std::move(ptrs[i]));
+  }
+
+  REQUIRE(messages.size() == 2);
+  REQUIRE((messages | count_payloads{}) == 1);
+  REQUIRE((messages | get_dataref_indices{0, 0}).headerIdx == 0);
+  REQUIRE((messages | get_dataref_indices{0, 0}).payloadIdx == 1);
+  REQUIRE((messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((messages | get_pair{0}).payloadIdx == 1);
+  CHECK_THROWS((messages | get_pair{1}));
+  REQUIRE((messages | get_num_payloads{0}) == 1);
+  REQUIRE((messages | count_parts{}) == 1);
 }
 
 TEST_CASE("MessageSetWithMultipart")
@@ -97,46 +97,40 @@ TEST_CASE("MessageSetWithMultipart")
   ptrs.emplace_back(std::move(header));
   ptrs.emplace_back(std::move(msg2));
   ptrs.emplace_back(std::move(msg3));
-  o2::framework::MessageSet msgSet([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 3);
-
-  REQUIRE(msgSet.messages.size() == 3);
-  REQUIRE((msgSet.messages | count_payloads{}) == 2);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 1}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 1}).payloadIdx == 2);
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 2);
-  CHECK_THROWS((msgSet.messages | get_pair{2}));
-  REQUIRE((msgSet.messages | get_num_payloads{0}) == 2);
-  REQUIRE((msgSet.messages | count_parts{}) == 1);
-  // messages: [hdr, pl0, pl1] — one header, two payloads
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 2);
+  std::vector<fair::mq::MessagePtr> messages;
+  for (size_t i = 0; i < 3; ++i) {
+    messages.emplace_back(std::move(ptrs[i]));
+  }
+
+  REQUIRE(messages.size() == 3);
+  REQUIRE((messages | count_payloads{}) == 2);
+  REQUIRE((messages | get_dataref_indices{0, 0}).headerIdx == 0);
+  REQUIRE((messages | get_dataref_indices{0, 0}).payloadIdx == 1);
+  REQUIRE((messages | get_dataref_indices{0, 1}).headerIdx == 0);
+  REQUIRE((messages | get_dataref_indices{0, 1}).payloadIdx == 2);
+  REQUIRE((messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((messages | get_pair{1}).headerIdx == 0);
+  REQUIRE((messages | get_pair{1}).payloadIdx == 2);
+  CHECK_THROWS((messages | get_pair{2}));
+  REQUIRE((messages | get_num_payloads{0}) == 2);
+  REQUIRE((messages | count_parts{}) == 1);
 }
 
 TEST_CASE("MessageSetAddPartRef")
 {
-  std::vector<fair::mq::MessagePtr> ptrs;
   std::unique_ptr<fair::mq::Message> msg(nullptr);
   std::unique_ptr<fair::mq::Message> msg2(nullptr);
-  ptrs.emplace_back(std::move(msg));
-  ptrs.emplace_back(std::move(msg2));
   PartRef ref{std::move(msg), std::move(msg2)};
-  o2::framework::MessageSet msgSet;
-  msgSet.messages.emplace_back(std::move(ref.header));
-  msgSet.messages.emplace_back(std::move(ref.payload));
+  std::vector<fair::mq::MessagePtr> messages;
+  messages.emplace_back(std::move(ref.header));
+  messages.emplace_back(std::move(ref.payload));
 
-  REQUIRE(msgSet.messages.size() == 2);
+  REQUIRE(messages.size() == 2);
 }
 
 TEST_CASE("MessageSetAddMultiple")
 {
-  std::vector<fair::mq::MessagePtr> ptrs;
   o2::header::DataHeader dh1{};
   dh1.splitPayloadParts = 0;
   dh1.splitPayloadIndex = 0;
@@ -148,109 +142,99 @@ TEST_CASE("MessageSetAddMultiple")
   dh3.splitPayloadIndex = 2;
   o2::framework::DataProcessingHeader dph{0, 1};
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
-  fair::mq::MessagePtr payload(transport->CreateMessage());
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
   fair::mq::MessagePtr header1 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh1, dph});
   fair::mq::MessagePtr header2 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh2, dph});
   fair::mq::MessagePtr header3 = o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh3, dph});
 
-  std::unique_ptr<fair::mq::Message> msg2(nullptr);
-  std::unique_ptr<fair::mq::Message> msg3(nullptr);
-  PartRef ref{std::move(header1), std::move(msg2)};
-  o2::framework::MessageSet msgSet;
-  msgSet.messages.emplace_back(std::move(ref.header));
-  msgSet.messages.emplace_back(std::move(ref.payload));
-  PartRef ref2{std::move(header2), std::move(msg2)};
-  msgSet.messages.emplace_back(std::move(ref2.header));
-  msgSet.messages.emplace_back(std::move(ref2.payload));
-  std::vector<fair::mq::MessagePtr> msgs;
-  msgs.push_back(std::move(header3));
-  msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
-  msgs.push_back(std::unique_ptr<fair::mq::Message>(nullptr));
-  for (size_t i = 0; i < 3; ++i) {
-    msgSet.messages.emplace_back(std::move(msgs[i]));
-  }
-
-  REQUIRE(msgSet.messages.size() == 7);
-
-  REQUIRE((msgSet.messages | count_payloads{}) == 4);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_dataref_indices{0, 0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_dataref_indices{1, 0}).headerIdx == 2);
-  REQUIRE((msgSet.messages | get_dataref_indices{1, 0}).payloadIdx == 3);
-  REQUIRE((msgSet.messages | get_dataref_indices{2, 0}).headerIdx == 4);
-  REQUIRE((msgSet.messages | get_dataref_indices{2, 0}).payloadIdx == 5);
-  REQUIRE((msgSet.messages | get_dataref_indices{2, 1}).headerIdx == 4);
-  REQUIRE((msgSet.messages | get_dataref_indices{2, 1}).payloadIdx == 6);
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
-  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
-  REQUIRE((msgSet.messages | get_pair{2}).headerIdx == 4);
-  REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 5);
-  REQUIRE((msgSet.messages | get_pair{3}).headerIdx == 4);
-  REQUIRE((msgSet.messages | get_pair{3}).payloadIdx == 6);
-  REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
-  REQUIRE((msgSet.messages | get_num_payloads{1}) == 1);
-  REQUIRE((msgSet.messages | get_num_payloads{2}) == 2);
-  REQUIRE((msgSet.messages | count_parts{}) == 3);
-  REQUIRE((msgSet.messages | count_payloads{}) == 4);
+  std::vector<fair::mq::MessagePtr> messages;
+  // part 0: dh1 (splitPayloadParts=0) — standard pair
+  messages.emplace_back(std::move(header1));
+  messages.emplace_back(std::unique_ptr<fair::mq::Message>(nullptr));
+  // part 1: dh2 (splitPayloadParts=1) — traditional split, one pair
+  messages.emplace_back(std::move(header2));
+  messages.emplace_back(std::unique_ptr<fair::mq::Message>(nullptr));
+  // part 2: dh3 (splitPayloadParts=2, splitPayloadIndex=2) — multi-payload, two payloads
+  messages.emplace_back(std::move(header3));
+  messages.emplace_back(std::unique_ptr<fair::mq::Message>(nullptr));
+  messages.emplace_back(std::unique_ptr<fair::mq::Message>(nullptr));
+
+  REQUIRE(messages.size() == 7);
+
+  REQUIRE((messages | count_payloads{}) == 4);
+  REQUIRE((messages | get_dataref_indices{0, 0}).headerIdx == 0);
+  REQUIRE((messages | get_dataref_indices{0, 0}).payloadIdx == 1);
+  REQUIRE((messages | get_dataref_indices{1, 0}).headerIdx == 2);
+  REQUIRE((messages | get_dataref_indices{1, 0}).payloadIdx == 3);
+  REQUIRE((messages | get_dataref_indices{2, 0}).headerIdx == 4);
+  REQUIRE((messages | get_dataref_indices{2, 0}).payloadIdx == 5);
+  REQUIRE((messages | get_dataref_indices{2, 1}).headerIdx == 4);
+  REQUIRE((messages | get_dataref_indices{2, 1}).payloadIdx == 6);
+  REQUIRE((messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((messages | get_pair{1}).headerIdx == 2);
+  REQUIRE((messages | get_pair{1}).payloadIdx == 3);
+  REQUIRE((messages | get_pair{2}).headerIdx == 4);
+  REQUIRE((messages | get_pair{2}).payloadIdx == 5);
+  REQUIRE((messages | get_pair{3}).headerIdx == 4);
+  REQUIRE((messages | get_pair{3}).payloadIdx == 6);
+  REQUIRE((messages | get_num_payloads{0}) == 1);
+  REQUIRE((messages | get_num_payloads{1}) == 1);
+  REQUIRE((messages | get_num_payloads{2}) == 2);
+  REQUIRE((messages | count_parts{}) == 3);
+  REQUIRE((messages | count_payloads{}) == 4);
 }
 
 TEST_CASE("GetHeaderPayloadOperators")
 {
-  // Validates that get_header{part} / get_payload{part, 0} pipe operators on .messages
-  // correctly replace the removed header(part) / payload(part) methods,
-  // including access to parts at index > 0.
+  // Validates that get_header{part} / get_payload{part, 0} pipe operators
+  // correctly return the right messages, including access to parts at index > 0.
   o2::framework::DataProcessingHeader dph{0, 1};
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
 
-  o2::framework::MessageSet msgSet;
+  std::vector<fair::mq::MessagePtr> messages;
 
   // Add two separate header-payload pairs
   for (size_t part = 0; part < 2; ++part) {
     o2::header::DataHeader dh{};
     dh.dataDescription = "CLUSTERS";
     dh.dataOrigin = "TPC";
-    dh.subSpecification = part; // use part index as subSpecification to distinguish
+    dh.subSpecification = part;
     dh.splitPayloadParts = 1;
     dh.splitPayloadIndex = 0;
-    std::vector<fair::mq::MessagePtr> ptrs;
-    ptrs.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
-    ptrs.emplace_back(transport->CreateMessage(100 + part * 100)); // 100 and 200 bytes
-    msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
+    messages.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
+    messages.emplace_back(transport->CreateMessage(100 + part * 100));
   }
 
-  REQUIRE(msgSet.messages.size() == 4);
+  REQUIRE(messages.size() == 4);
 
   // Validate part 0
-  auto& hdr0 = msgSet.messages | get_header{0};
+  auto& hdr0 = messages | get_header{0};
   REQUIRE(hdr0.get() != nullptr);
   auto* dh0 = o2::header::get<o2::header::DataHeader*>(hdr0->GetData());
   REQUIRE(dh0 != nullptr);
   REQUIRE(dh0->subSpecification == 0);
-  auto& pl0 = msgSet.messages | get_payload{0, 0};
+  auto& pl0 = messages | get_payload{0, 0};
   REQUIRE(pl0.get() != nullptr);
   REQUIRE(pl0->GetSize() == 100);
 
   // Validate part 1
-  auto& hdr1 = msgSet.messages | get_header{1};
+  auto& hdr1 = messages | get_header{1};
   REQUIRE(hdr1.get() != nullptr);
   auto* dh1 = o2::header::get<o2::header::DataHeader*>(hdr1->GetData());
   REQUIRE(dh1 != nullptr);
   REQUIRE(dh1->subSpecification == 1);
-  auto& pl1 = msgSet.messages | get_payload{1, 0};
+  auto& pl1 = messages | get_payload{1, 0};
   REQUIRE(pl1.get() != nullptr);
   REQUIRE(pl1->GetSize() == 200);
 
-  REQUIRE((msgSet.messages | count_parts{}) == 2);
-  REQUIRE((msgSet.messages | count_payloads{}) == 2);
-  // messages: [hdr0, pl0, hdr1, pl1] — two standard pairs
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
-  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
+  REQUIRE((messages | count_parts{}) == 2);
+  REQUIRE((messages | count_payloads{}) == 2);
+  REQUIRE((messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((messages | get_pair{1}).headerIdx == 2);
+  REQUIRE((messages | get_pair{1}).payloadIdx == 3);
 }
 
 TEST_CASE("GetHeaderPayloadMultiPayload")
@@ -264,7 +248,7 @@ TEST_CASE("GetHeaderPayloadMultiPayload")
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
 
-  o2::framework::MessageSet msgSet;
+  std::vector<fair::mq::MessagePtr> messages;
 
   // Part 0: standard header-payload pair
   {
@@ -274,10 +258,8 @@ TEST_CASE("GetHeaderPayloadMultiPayload")
     dh.subSpecification = 0;
     dh.splitPayloadParts = 1;
     dh.splitPayloadIndex = 0;
-    std::vector<fair::mq::MessagePtr> ptrs;
-    ptrs.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
-    ptrs.emplace_back(transport->CreateMessage(100));
-    msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 2);
+    messages.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
+    messages.emplace_back(transport->CreateMessage(100));
   }
 
   // Part 1: one header with 3 payloads (splitPayloadIndex == splitPayloadParts)
@@ -287,81 +269,67 @@ TEST_CASE("GetHeaderPayloadMultiPayload")
     dh.dataOrigin = "TPC";
     dh.subSpecification = 1;
     dh.splitPayloadParts = 3;
-    dh.splitPayloadIndex = 3; // signals multi-payload layout
-    std::vector<fair::mq::MessagePtr> ptrs;
-    ptrs.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
-    ptrs.emplace_back(transport->CreateMessage(200));
-    ptrs.emplace_back(transport->CreateMessage(300));
-    ptrs.emplace_back(transport->CreateMessage(400));
-    msgSet.add([&ptrs](size_t i) -> fair::mq::MessagePtr& { return ptrs[i]; }, 4);
+    dh.splitPayloadIndex = 3;
+    messages.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
+    messages.emplace_back(transport->CreateMessage(200));
+    messages.emplace_back(transport->CreateMessage(300));
+    messages.emplace_back(transport->CreateMessage(400));
   }
 
   // messages: [hdr0, pl0, hdr1, pl1_0, pl1_1, pl1_2]
-  REQUIRE(msgSet.messages.size() == 6);
+  REQUIRE(messages.size() == 6);
 
-  // Part 0: standard
-  auto& hdr0 = msgSet.messages | get_header{0};
+  // Part 0
+  auto& hdr0 = messages | get_header{0};
   REQUIRE(hdr0.get() != nullptr);
   auto* dh0 = o2::header::get<o2::header::DataHeader*>(hdr0->GetData());
   REQUIRE(dh0->subSpecification == 0);
-  auto& pl0 = msgSet.messages | get_payload{0, 0};
+  auto& pl0 = messages | get_payload{0, 0};
   REQUIRE(pl0.get() != nullptr);
   REQUIRE(pl0->GetSize() == 100);
 
   // Part 1: multi-payload header
-  auto& hdr1 = msgSet.messages | get_header{1};
+  auto& hdr1 = messages | get_header{1};
   REQUIRE(hdr1.get() != nullptr);
   auto* dh1 = o2::header::get<o2::header::DataHeader*>(hdr1->GetData());
   REQUIRE(dh1->subSpecification == 1);
 
-  // get_payload{1, 0} — first payload of part 1
-  auto& pl1_0 = msgSet.messages | get_payload{1, 0};
+  auto& pl1_0 = messages | get_payload{1, 0};
   REQUIRE(pl1_0.get() != nullptr);
   REQUIRE(pl1_0->GetSize() == 200);
 
-  // get_payload{1, 1} — second payload of part 1 (nonzero, nonzero)
-  auto& pl1_1 = msgSet.messages | get_payload{1, 1};
+  auto& pl1_1 = messages | get_payload{1, 1};
   REQUIRE(pl1_1.get() != nullptr);
   REQUIRE(pl1_1->GetSize() == 300);
 
-  // get_payload{1, 2} — third payload of part 1 (nonzero, nonzero)
-  auto& pl1_2 = msgSet.messages | get_payload{1, 2};
+  auto& pl1_2 = messages | get_payload{1, 2};
   REQUIRE(pl1_2.get() != nullptr);
   REQUIRE(pl1_2->GetSize() == 400);
 
-  // count_payloads should report 4 total (1 from part 0 + 3 from part 1)
-  REQUIRE((msgSet.messages | count_payloads{}) == 4);
-  // count_parts should report 2 (one per header)
-  REQUIRE((msgSet.messages | count_parts{}) == 2);
-  // get_num_payloads for part 1 should be 3
-  REQUIRE((msgSet.messages | get_num_payloads{1}) == 3);
-
-  REQUIRE((msgSet.messages | get_num_payloads{0}) == 1);
-  REQUIRE((msgSet.messages | get_num_payloads{1}) == 3);
-  REQUIRE((msgSet.messages | count_parts{}) == 2);
-  REQUIRE((msgSet.messages | count_payloads{}) == 4);
-  // messages: [hdr0, pl0, hdr1, pl1_0, pl1_1, pl1_2]
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
-  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
-  REQUIRE((msgSet.messages | get_pair{2}).headerIdx == 2);
-  REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 4);
-  REQUIRE((msgSet.messages | get_pair{3}).headerIdx == 2);
-  REQUIRE((msgSet.messages | get_pair{3}).payloadIdx == 5);
+  REQUIRE((messages | get_num_payloads{0}) == 1);
+  REQUIRE((messages | get_num_payloads{1}) == 3);
+  REQUIRE((messages | count_parts{}) == 2);
+  REQUIRE((messages | count_payloads{}) == 4);
+  REQUIRE((messages | get_pair{0}).headerIdx == 0);
+  REQUIRE((messages | get_pair{0}).payloadIdx == 1);
+  REQUIRE((messages | get_pair{1}).headerIdx == 2);
+  REQUIRE((messages | get_pair{1}).payloadIdx == 3);
+  REQUIRE((messages | get_pair{2}).headerIdx == 2);
+  REQUIRE((messages | get_pair{2}).payloadIdx == 4);
+  REQUIRE((messages | get_pair{3}).headerIdx == 2);
+  REQUIRE((messages | get_pair{3}).payloadIdx == 5);
 }
 
 TEST_CASE("TraditionalSplitParts")
 {
   // Validates operators with traditional split parts layout:
   // 3 (header, payload) pairs where splitPayloadParts=3, splitPayloadIndex=0,1,2
-  // This is ONE logical part with 3 subparts.
   // Memory layout: [hdr0, pl0, hdr1, pl1, hdr2, pl2]
   o2::framework::DataProcessingHeader dph{0, 1};
   auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
   auto channelAlloc = o2::pmr::getTransportAllocator(transport.get());
 
-  o2::framework::MessageSet msgSet;
+  std::vector<fair::mq::MessagePtr> messages;
 
   for (size_t i = 0; i < 3; ++i) {
     o2::header::DataHeader dh{};
@@ -370,57 +338,42 @@ TEST_CASE("TraditionalSplitParts")
     dh.subSpecification = 0;
     dh.splitPayloadParts = 3;
     dh.splitPayloadIndex = i;
-    std::vector<fair::mq::MessagePtr> ptrs;
-    ptrs.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
-    ptrs.emplace_back(transport->CreateMessage(100 * (i + 1)));
-    msgSet.add([&ptrs](size_t idx) -> fair::mq::MessagePtr& { return ptrs[idx]; }, 2);
+    messages.emplace_back(o2::pmr::getMessage(o2::header::Stack{channelAlloc, dh, dph}));
+    messages.emplace_back(transport->CreateMessage(100 * (i + 1)));
   }
 
-  REQUIRE(msgSet.messages.size() == 6);
+  REQUIRE(messages.size() == 6);
 
-  // count_payloads: 3 traditional split parts = 3 payloads
-  REQUIRE((msgSet.messages | count_payloads{}) == 3);
-  // count_parts: one logical entity split into 3 pairs = 3 parts
-  REQUIRE((msgSet.messages | count_parts{}) == 3);
+  REQUIRE((messages | count_payloads{}) == 3);
+  REQUIRE((messages | count_parts{}) == 3);
 
-  // Each traditional split pair is a separate part, matching MessageSet::header(part) semantics
   for (size_t i = 0; i < 3; ++i) {
-    auto& hdr = msgSet.messages | get_header{i};
+    auto& hdr = messages | get_header{i};
     REQUIRE(hdr.get() != nullptr);
     auto* dh = o2::header::get<o2::header::DataHeader*>(hdr->GetData());
     REQUIRE(dh != nullptr);
     REQUIRE(dh->splitPayloadIndex == i);
 
-    auto& pl = msgSet.messages | get_payload{i, 0};
+    auto& pl = messages | get_payload{i, 0};
     REQUIRE(pl.get() != nullptr);
     REQUIRE(pl->GetSize() == 100 * (i + 1));
   }
 
-  // get_dataref_indices: each part maps to its own (header, payload) pair
   for (size_t i = 0; i < 3; ++i) {
-    auto indices = msgSet.messages | get_dataref_indices{i, 0};
+    auto indices = messages | get_dataref_indices{i, 0};
     REQUIRE(indices.headerIdx == 2 * i);
     REQUIRE(indices.payloadIdx == 2 * i + 1);
   }
 
-  // get_pair: same as get_dataref_indices for traditional split
   for (size_t i = 0; i < 3; ++i) {
-    auto indices = msgSet.messages | get_pair{i};
+    auto indices = messages | get_pair{i};
     REQUIRE(indices.headerIdx == 2 * i);
     REQUIRE(indices.payloadIdx == 2 * i + 1);
   }
 
-  // get_num_payloads: each traditional split pair has 1 payload
   for (size_t i = 0; i < 3; ++i) {
-    REQUIRE((msgSet.messages | get_num_payloads{i}) == 1);
+    REQUIRE((messages | get_num_payloads{i}) == 1);
   }
-  REQUIRE((msgSet.messages | count_parts{}) == 3);
-  REQUIRE((msgSet.messages | count_payloads{}) == 3);
-  // messages: [hdr0, pl0, hdr1, pl1, hdr2, pl2] — three traditional split pairs
-  REQUIRE((msgSet.messages | get_pair{0}).headerIdx == 0);
-  REQUIRE((msgSet.messages | get_pair{0}).payloadIdx == 1);
-  REQUIRE((msgSet.messages | get_pair{1}).headerIdx == 2);
-  REQUIRE((msgSet.messages | get_pair{1}).payloadIdx == 3);
-  REQUIRE((msgSet.messages | get_pair{2}).headerIdx == 4);
-  REQUIRE((msgSet.messages | get_pair{2}).payloadIdx == 5);
+  REQUIRE((messages | count_parts{}) == 3);
+  REQUIRE((messages | count_payloads{}) == 3);
 }

From 33b11d46481332f1817393dad1b040c7c49ad28e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 25 Mar 2026 11:46:13 +0100
Subject: [PATCH 1498/1764] Add optional dependency for Acts package

---
 dependencies/O2Dependencies.cmake | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/dependencies/O2Dependencies.cmake b/dependencies/O2Dependencies.cmake
index 850ba0b909acc..b46dabb5690ff 100644
--- a/dependencies/O2Dependencies.cmake
+++ b/dependencies/O2Dependencies.cmake
@@ -143,6 +143,9 @@ set_package_properties(fmt PROPERTIES TYPE REQUIRED)
 find_package(nlohmann_json)
 set_package_properties(nlohmann_json PROPERTIES TYPE REQUIRED)
 
+find_package(Acts)
+set_package_properties(Acts PROPERTIES TYPE OPTIONAL)
+
 find_package(Boost 1.70
              COMPONENTS container
                         thread

From 198457e3462747b8eaf485ac86ec7d2617c61e98 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Mon, 30 Mar 2026 17:14:01 +0200
Subject: [PATCH 1499/1764] Add fcolamar as owner for ALICE3 upgrades (#15243)

---
 CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 369a7cf8a8463..f54738e2ce4e3 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -73,7 +73,7 @@
 /Detectors/TPC                     @davidrohr @wiechula @shahor02
 /Detectors/TRD                     @f3sch @bazinski @wille10
 /Detectors/Upgrades                @mconcas
-/Detectors/Upgrades/ALICE3         @mconcas @njacazio
+/Detectors/Upgrades/ALICE3         @mconcas @njacazio @fcolamar
 /Detectors/Upgrades/ITS3           @fgrosa @arossi81 @mconcas @f3sch
 /Detectors/ZDC                     @coppedis @cortesep
 /Detectors/CTF                     @shahor02

From 1b673ecbb297411272924776583a67a7a5335a81 Mon Sep 17 00:00:00 2001
From: Marco van Leeuwen <marco.van.leeuwen@cern.ch>
Date: Mon, 30 Mar 2026 17:22:46 +0200
Subject: [PATCH 1500/1764] [ALICE3] Fix extrusions in forward tracker (#15242)

---
 Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx | 2 +-
 Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
index 453d90501802e..333599c85eab6 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -390,7 +390,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     std::string separationLayerName = "FT3SeparationLayer" + std::to_string(mDirection) + std::to_string(mLayerNumber);
 
     TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$");
-    TGeoTube* layer = new TGeoTube(mInnerRadius, mOuterRadius, 12 * mChipThickness / 2); // additional "thickness factor" is to avoid sub-volumes crossing the mother layer
+    TGeoTube* layer = new TGeoTube(mInnerRadius - 0.1, mOuterRadius + 0.1, 1.5); // Add a little additional room in radius; Try with 1.5 cm thickness
     TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
     layerVol->SetLineColor(kYellow + 2);
 
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 0d0983958c46f..118078ebf7100 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -445,4 +445,4 @@ void BTOFLayer::createLayer(TGeoVolume* motherVolume)
 }
 
 } // namespace iotof
-} // namespace o2
\ No newline at end of file
+} // namespace o2

From d87ad11b206f555c3e4beab9a5a9823a6471010c Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 30 Mar 2026 18:37:13 +0200
Subject: [PATCH 1501/1764] Fix typo on the TPC A||C side contribution check

---
 Framework/Core/include/Framework/AnalysisDataModel.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index 9f48685820634..2869565454294 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -413,7 +413,7 @@ DECLARE_SOA_DYNAMIC_COLUMN(HasTPCSideC, hasTPCSideC, //! Run 3: Has this track T
 DECLARE_SOA_DYNAMIC_COLUMN(HasTPCSideCOnly, hasTPCSideCOnly, //! Run 3: Has this track TPC clusters from side C only?
                            [](uint8_t flags) -> bool { return (flags & (o2::aod::track::TPCSideA | o2::aod::track::TPCSideC)) == o2::aod::track::TPCSideC; });
 DECLARE_SOA_DYNAMIC_COLUMN(HasTPCBothSides, hasTPCBothSides, //! Run 3: Has this track TPC clusters from both side A and C?
-                           [](uint8_t flags) -> bool { return (flags & (o2::aod::track::TPCSideA | o2::aod::track::TPCSideC)) == (o2::aod::track::TPCSideA || o2::aod::track::TPCSideC); });
+                           [](uint8_t flags) -> bool { return (flags & (o2::aod::track::TPCSideA | o2::aod::track::TPCSideC)) == (o2::aod::track::TPCSideA | o2::aod::track::TPCSideC); });
 DECLARE_SOA_DYNAMIC_COLUMN(PIDForTracking, pidForTracking, //! PID hypothesis used during tracking. See the constants in the class PID in PID.h
                            [](uint32_t flags) -> uint32_t { return flags >> 28; });
 DECLARE_SOA_DYNAMIC_COLUMN(TPCNClsFound, tpcNClsFound, //! Number of found TPC clusters

From aa5d3c6ec3c67a0c15ae53a3705fa58eb6eee2e7 Mon Sep 17 00:00:00 2001
From: spulawsk <s.pulawski@cern.ch>
Date: Mon, 30 Mar 2026 23:00:48 +0200
Subject: [PATCH 1502/1764] FT0: update Digitizer signal shape and trigger
 logic; FV0: update trigger logic in digitizer (#15209)

* FT0: tune signal shape and trigger tunning for MC

* apply clang-format

* Update FV0 trigger settings and digitizer logic

* FV0: update Digitizer trigger handling

* Update parameter comments and default settings for Run 3

* Clang formating

* Default trigger settings set for pp. PbPb will be sent via parameters

* Default trigger settings set for pp. PbPb will be sent via parameters

---------

Co-authored-by: Szymon Pulawski <spulawsk@h010.nuph.us.edu.pl>
---
 .../FT0/base/include/FT0Base/FT0DigParam.h    |   9 +-
 .../FIT/FT0/simulation/src/Digitizer.cxx      | 185 ++++++++++++++++--
 .../include/FV0Simulation/FV0DigParam.h       |   4 +
 .../FIT/FV0/simulation/src/Digitizer.cxx      |  38 ++--
 4 files changed, 203 insertions(+), 33 deletions(-)

diff --git a/Detectors/FIT/FT0/base/include/FT0Base/FT0DigParam.h b/Detectors/FIT/FT0/base/include/FT0Base/FT0DigParam.h
index 2bf774859aa22..074d91bb04b27 100644
--- a/Detectors/FIT/FT0/base/include/FT0Base/FT0DigParam.h
+++ b/Detectors/FIT/FT0/base/include/FT0Base/FT0DigParam.h
@@ -31,8 +31,8 @@ struct FT0DigParam : o2::conf::ConfigurableParamHelper<FT0DigParam> {
   float mAmpRecordUp = 15;           // to [ns]
   float hitTimeOffsetA = 0;          ///< hit time offset on the A side [ns]
   float hitTimeOffsetC = 0;          ///< hit time offset on the C side [ns]
-  int mtrg_central_trh = 600.;       // channels
-  int mtrg_semicentral_trh = 300.;   // channels
+  int mtrg_central_trh = 40;         // Tclu units (40 for pp and 1433 for PbPb in Run3)
+  int mtrg_semicentral_trh = 20;     // Tclu units (20 for pp and 35 for PbPb in Run3)
 
   float mMip_in_V = 7;       // MIP to mV
   float mPe_in_mip = 0.004;  // invserse Np.e. in MIP 1./250.
@@ -43,11 +43,12 @@ struct FT0DigParam : o2::conf::ConfigurableParamHelper<FT0DigParam> {
   float mNoiseVar = 0.1;              // noise level
   float mNoisePeriod = 1 / 0.9;       // GHz low frequency noise period;
   short mTime_trg_gate = 153;         // #channels as in TCM as in Pilot beams ('OR gate' setting in TCM tab in ControlServer)
+  short mTime_trg_vertex_gate = 100;  // #channels as in TCM as in Pilot beams ('OR gate' setting in TCM tab in ControlServer)
   float mAmpThresholdForReco = 5;     // only channels with amplitude higher will participate in calibration and collision time: 0.3 MIP
   short mTimeThresholdForReco = 1000; // only channels with time below will participate in calibration and collision time
 
-  float mMV_2_Nchannels = 2.2857143;          // amplitude channel 7 mV ->16channels
-  float mMV_2_NchannelsInverse = 0.437499997; // inverse amplitude channel 7 mV ->16channels
+  float mMV_2_Nchannels = 2.;         // amplitude channel 7 mV ->14channels
+  float mMV_2_NchannelsInverse = 0.5; // inverse amplitude channel 7 mV ->14channels (nowhere used)
 
   O2ParamDef(FT0DigParam, "FT0DigParam");
 };
diff --git a/Detectors/FIT/FT0/simulation/src/Digitizer.cxx b/Detectors/FIT/FT0/simulation/src/Digitizer.cxx
index aca012f1bc5a9..de432a85765c7 100644
--- a/Detectors/FIT/FT0/simulation/src/Digitizer.cxx
+++ b/Detectors/FIT/FT0/simulation/src/Digitizer.cxx
@@ -16,6 +16,13 @@
 #include "CommonConstants/PhysicsConstants.h"
 #include "CommonDataFormat/InteractionRecord.h"
 
+#include "DataFormatsFT0/LookUpTable.h"
+#include "FT0Base/Constants.h"
+#include <map>
+#include <array>
+#include <regex>
+#include <string>
+
 #include "TMath.h"
 #include "TRandom.h"
 #include <TH1F.h>
@@ -35,24 +42,84 @@ namespace o2::ft0
 template <typename Float>
 Float signalForm_i(Float x)
 {
-  using namespace std;
-  Float const a = -0.45458;
-  Float const b = -0.83344945;
-  return x > Float(0) ? -(exp(b * x) - exp(a * x)) / Float(7.8446501) : Float(0);
+  float p0, p1, p2, p3, p4, p5, p6, p7;
+  p0 = 1.30853;
+  p1 = 0.516807;
+  p2 = 3.36714;
+  p3 = -1.01206;
+  p4 = 1.42832;
+  p5 = 1.1589;
+  p6 = 1.22019;
+  p7 = 0.426818;
+
+  Double_t val = 0;
+
+  if (x > p3) {
+    Double_t x1 = x - p3;
+    Double_t arg1 = (log(x1) - p0) / p1;
+    val += p2 * (1.0 / (x1 * p1 * sqrt(2 * TMath::Pi()))) * exp(-0.5 * arg1 * arg1);
+  }
+
+  if (x > p7) {
+    Double_t x2 = x - p7;
+    Double_t arg2 = (log(x2) - p4) / p5;
+    val += p6 * (1.0 / (x2 * p5 * sqrt(2 * TMath::Pi()))) * exp(-0.5 * arg2 * arg2);
+  }
+
+  return val;
 };
 
 // integrated signal shape function
 inline float signalForm_integral(float x)
 {
-  using namespace std;
-  double const a = -0.45458;
-  double const b = -0.83344945;
-  if (x < 0) {
-    x = 0;
+  float p0, p1, p2, p3, p4, p5, p6, p7;
+  p0 = 1.30853;
+  p1 = 0.516807;
+  p2 = 3.36714;
+  p3 = -1.01206;
+  p4 = 1.42832;
+  p5 = 1.1589;
+  p6 = 1.22019;
+  p7 = 0.426818;
+  Double_t val = 0;
+
+  if (x > p3) {
+    Double_t x1 = x - p3;
+    Double_t z1 = (log(x1) - p0) / (sqrt(2) * p1);
+    val += p2 * 0.5 * (1 + TMath::Erf(z1)); // norm1 * CDF1
   }
-  return -(exp(b * x) / b - exp(a * x) / a) / 7.8446501;
+
+  if (x > p7) {
+    Double_t x2 = x - p7;
+    Double_t z2 = (log(x2) - p4) / (sqrt(2) * p5);
+    val += p6 * 0.5 * (1 + TMath::Erf(z2)); // norm2 * CDF2
+  }
+
+  return val;
+};
+/*
+// signal shape function
+template <typename Float>
+Float signalForm_i(Float x)
+{
+using namespace std;
+Float const a = -0.45458;
+Float const b = -0.83344945;
+return x > Float(0) ? -(exp(b * x) - exp(a * x)) / Float(7.8446501) : Float(0);
 };
 
+// integrated signal shape function
+inline float signalForm_integral(float x)
+{
+using namespace std;
+double const a = -0.45458;
+double const b = -0.83344945;
+if (x < 0) {
+  x = 0;
+}
+return -(exp(b * x) / b - exp(a * x) / a) / 7.8446501;
+};
+*/
 // SIMD version of the integrated signal shape function
 inline Vc::float_v signalForm_integralVc(Vc::float_v x)
 {
@@ -249,8 +316,64 @@ void Digitizer::storeBC(BCCache& bc,
   if (bc.hits.empty()) {
     return;
   }
+  // Initialize mapping channelID -> PM hash and PM side (A/C) using FT0 LUT
+  static bool pmLutInitialized = false;
+  static std::array<uint8_t, o2::ft0::Constants::sNCHANNELS_PM> mChID2PMhash{};
+  static std::map<uint8_t, bool> mMapPMhash2isAside; // hashed PM -> is A side
+
+  if (!pmLutInitialized) {
+    std::map<std::string, uint8_t> mapFEE2hash; // module name -> hashed PM id
+    uint8_t tcmHash = 0;
+
+    const auto& lut = o2::ft0::SingleLUT::Instance().getVecMetadataFEE();
+    auto lutSorted = lut;
+    std::sort(lutSorted.begin(), lutSorted.end(),
+              [](const auto& first, const auto& second) { return first.mModuleName < second.mModuleName; });
+
+    uint8_t binPos = 0;
+    for (const auto& lutEntry : lutSorted) {
+      const auto& moduleName = lutEntry.mModuleName;
+      const auto& moduleType = lutEntry.mModuleType;
+      const auto& strChID = lutEntry.mChannelID;
+
+      auto [it, inserted] = mapFEE2hash.insert({moduleName, binPos});
+      if (inserted) {
+        if (moduleName.find("PMA") != std::string::npos) {
+          mMapPMhash2isAside.insert({binPos, true});
+        } else if (moduleName.find("PMC") != std::string::npos) {
+          mMapPMhash2isAside.insert({binPos, false});
+        }
+        ++binPos;
+      }
+
+      if (std::regex_match(strChID, std::regex("^[0-9]{1,3}$"))) {
+        int chID = std::stoi(strChID);
+        if (chID < o2::ft0::Constants::sNCHANNELS_PM) {
+          mChID2PMhash[chID] = mapFEE2hash[moduleName];
+        } else {
+          LOG(fatal) << "Incorrect LUT entry: chID " << strChID << " | " << moduleName;
+        }
+      } else if (moduleType != "TCM") {
+        LOG(fatal) << "Non-TCM module w/o numerical chID: chID " << strChID << " | " << moduleName;
+      } else { // TCM
+        tcmHash = mapFEE2hash[moduleName];
+      }
+    }
+
+    pmLutInitialized = true;
+  }
+
   int n_hit_A = 0, n_hit_C = 0, mean_time_A = 0, mean_time_C = 0;
   int summ_ampl_A = 0, summ_ampl_C = 0;
+  int sum_A_ampl = 0, sum_C_ampl = 0;
+  int nPMTs = mGeometry.NCellsA * 4 + mGeometry.NCellsC * 4;
+  std::vector<int> sum_ampl_ipmt(nPMTs, 0);
+  // Per-PM summed charge (like in digits2trgFT0)
+  std::map<uint8_t, int> mapPMhash2sumAmpl;
+  for (const auto& entry : mMapPMhash2isAside) {
+    mapPMhash2sumAmpl.insert({entry.first, 0});
+  }
+
   int vertex_time;
   const auto& params = FT0DigParam::Instance();
   int first = digitsCh.size(), nStored = 0;
@@ -297,6 +420,10 @@ void Digitizer::storeBC(BCCache& bc,
     if (is_time_in_signal_gate) {
       chain |= (1 << o2::ft0::ChannelData::EEventDataBit::kIsCFDinADCgate);
       chain |= (1 << o2::ft0::ChannelData::EEventDataBit::kIsEventInTVDC);
+      // Sum channel charge per PM (similar logic as in digits2trgFT0)
+      if (ipmt < o2::ft0::Constants::sNCHANNELS_PM) {
+        mapPMhash2sumAmpl[mChID2PMhash[static_cast<uint8_t>(ipmt)]] += static_cast<int>(amp);
+      }
     }
     digitsCh.emplace_back(ipmt, smeared_time, int(amp), chain);
     nStored++;
@@ -308,6 +435,8 @@ void Digitizer::storeBC(BCCache& bc,
       continue;
     }
 
+    sum_ampl_ipmt[ipmt] += amp;
+
     if (is_A_side) {
       n_hit_A++;
       summ_ampl_A += amp;
@@ -318,17 +447,47 @@ void Digitizer::storeBC(BCCache& bc,
       mean_time_C += smeared_time;
     }
   }
+
+  for (size_t i = 0; i < sum_ampl_ipmt.size(); i++) {
+    sum_ampl_ipmt[i] = sum_ampl_ipmt[i] >> 3;
+    if (i < 4 * mGeometry.NCellsA) {
+      sum_A_ampl += sum_ampl_ipmt[i];
+    } else {
+      sum_C_ampl += sum_ampl_ipmt[i];
+    }
+  }
+
+  // Sum over PMs (using per-PM map) for debug/monitoring
+  int sum_PM_ampl_debug = 0;
+  int sum_PM_ampl_A_debug = 0;
+  int sum_PM_ampl_C_debug = 0;
+  for (const auto& entry : mapPMhash2sumAmpl) {
+    int pmAmpl = (entry.second >> 3);
+    sum_PM_ampl_debug += pmAmpl;
+    auto itSide = mMapPMhash2isAside.find(entry.first);
+    if (itSide != mMapPMhash2isAside.end()) {
+      if (itSide->second) {
+        sum_PM_ampl_A_debug += pmAmpl;
+      } else {
+        sum_PM_ampl_C_debug += pmAmpl;
+      }
+    }
+  }
+  LOG(debug) << "Sum PM amplitude (LUT-based): total=" << sum_PM_ampl_debug
+             << " A-side=" << sum_PM_ampl_A_debug
+             << " C-side=" << sum_PM_ampl_C_debug;
+
   Bool_t is_A, is_C, isVertex, is_Central, is_SemiCentral = 0;
   is_A = n_hit_A > 0;
   is_C = n_hit_C > 0;
-  is_Central = summ_ampl_A + summ_ampl_C >= params.mtrg_central_trh;
-  is_SemiCentral = summ_ampl_A + summ_ampl_C >= params.mtrg_semicentral_trh;
+  is_Central = sum_PM_ampl_A_debug + sum_PM_ampl_C_debug >= 2 * params.mtrg_central_trh;
+  is_SemiCentral = sum_PM_ampl_A_debug + sum_PM_ampl_C_debug >= 2 * params.mtrg_semicentral_trh && !is_Central;
   uint32_t amplA = is_A ? summ_ampl_A * 0.125 : -5000; // sum amplitude A side / 8 (hardware)
   uint32_t amplC = is_C ? summ_ampl_C * 0.125 : -5000; // sum amplitude C side / 8 (hardware)
   int timeA = is_A ? mean_time_A / n_hit_A : -5000;    // average time A side
   int timeC = is_C ? mean_time_C / n_hit_C : -5000;    // average time C side
   vertex_time = (timeC - timeA) * 0.5;
-  isVertex = is_A && is_C && (vertex_time > -params.mTime_trg_gate && vertex_time < params.mTime_trg_gate);
+  isVertex = is_A && is_C && (vertex_time > -params.mTime_trg_vertex_gate && vertex_time < params.mTime_trg_vertex_gate);
   LOG(debug) << " A " << is_A << " timeA " << timeA << " mean_time_A " << mean_time_A << "  n_hit_A " << n_hit_A << " C " << is_C << " timeC " << timeC << " mean_time_C " << mean_time_C << "  n_hit_C " << n_hit_C << " vertex_time " << vertex_time;
   Triggers triggers;
   bool isLaser = false;
diff --git a/Detectors/FIT/FV0/simulation/include/FV0Simulation/FV0DigParam.h b/Detectors/FIT/FV0/simulation/include/FV0Simulation/FV0DigParam.h
index 383fa4cb494c1..6462323a279b7 100644
--- a/Detectors/FIT/FV0/simulation/include/FV0Simulation/FV0DigParam.h
+++ b/Detectors/FIT/FV0/simulation/include/FV0Simulation/FV0DigParam.h
@@ -69,6 +69,10 @@ struct FV0DigParam : o2::conf::ConfigurableParamHelper<FV0DigParam> {
   uint8_t defaultChainQtc = 0x48;     // only 2 flags are set by default in simulation: kIsCFDinADCgate and kIsEventInTVDC
   float mAmpThresholdForReco = 24;    // only channels with amplitude higher will participate in calibration and collision time
   short mTimeThresholdForReco = 1000; // only channels with time below will participate in calibration and collision time
+  int NchannelsLevel = 2;             // trigger Nchannels
+  float InnerChargeLevel = 4;         // InnerRingsChargeLevel
+  float OuterChargeLevel = 4;         // OuterRingsChargeLevel
+  float ChargeLevel = 8;              // ChargeLevel
 
   O2ParamDef(FV0DigParam, "FV0DigParam");
 };
diff --git a/Detectors/FIT/FV0/simulation/src/Digitizer.cxx b/Detectors/FIT/FV0/simulation/src/Digitizer.cxx
index 8c1d2dc8824e2..3237f9bab7879 100644
--- a/Detectors/FIT/FV0/simulation/src/Digitizer.cxx
+++ b/Detectors/FIT/FV0/simulation/src/Digitizer.cxx
@@ -38,8 +38,8 @@ void Digitizer::clear()
 void Digitizer::init()
 {
   LOG(info) << "init";
-  mNBins = FV0DigParam::Instance().waveformNbins;      //Will be computed using detector set-up from CDB
-  mBinSize = FV0DigParam::Instance().waveformBinWidth; //Will be set-up from CDB
+  mNBins = FV0DigParam::Instance().waveformNbins;                                  // Will be computed using detector set-up from CDB
+  mBinSize = FV0DigParam::Instance().waveformBinWidth;                             // Will be set-up from CDB
   mNTimeBinsPerBC = std::lround(o2::constants::lhc::LHCBunchSpacingNS / mBinSize); // 1920 bins/BC
 
   for (Int_t detID = 0; detID < Constants::nFv0Channels; detID++) {
@@ -149,8 +149,8 @@ void Digitizer::process(const std::vector<o2::fv0::Hit>& hits,
 
       createPulse(mipFraction, hit.GetTrackID(), hitTime, hit.GetPos().R(), cachedIR, nCachedIR, detId);
 
-    } //while loop
-  }   //hitloop
+    } // while loop
+  } // hitloop
 }
 
 void Digitizer::createPulse(float mipFraction, int parID, const double hitTime, const float hitR,
@@ -200,7 +200,7 @@ void Digitizer::createPulse(float mipFraction, int parID, const double hitTime,
     }
     added[ir] = true;
   }
-  ///Add MC labels to BCs for those contributed to the PMT signal
+  /// Add MC labels to BCs for those contributed to the PMT signal
   for (int ir = 0; ir < nCachedIR; ir++) {
     if (added[ir]) {
       auto bcCache = getBCCache(cachedIR[ir]);
@@ -238,6 +238,8 @@ void Digitizer::storeBC(const BCCache& bc,
   int8_t nTotFiredCells = 0;
   int8_t nTrgFiredCells = 0; // number of fired cells, that follow additional trigger conditions (time gate)
   int totalChargeAllRing = 0;
+  int totalChargeInnerRing = 0;
+  int totalChargeOuterRing = 0;
   int32_t avgTime = 0;
   double nSignalInner = 0;
   double nSignalOuter = 0;
@@ -285,8 +287,10 @@ void Digitizer::storeBC(const BCCache& bc,
       avgTime += iCfdZero;
       if (iPmt < 24) {
         nSignalInner++;
+        totalChargeInnerRing += iTotalCharge;
       } else {
         nSignalOuter++;
+        totalChargeOuterRing += iTotalCharge;
       }
     }
   }
@@ -300,13 +304,15 @@ void Digitizer::storeBC(const BCCache& bc,
   } else {
     avgTime = o2::fit::Triggers::DEFAULT_TIME;
   }
-  ///Triggers for FV0
-  bool isA, isAIn, isAOut, isCen, isSCen;
+  /// Triggers for FV0
+  bool isA, isNchannels, isAIn, isAOut, isTotalCharge;
   isA = nTrgFiredCells > 0;
-  isAIn = nSignalInner > 0;  // ring 1,2 and 3
-  isAOut = nSignalOuter > 0; // ring 4 and 5
-  isCen = totalChargeAllRing > FV0DigParam::Instance().adcChargeCenThr;
-  isSCen = totalChargeAllRing > FV0DigParam::Instance().adcChargeSCenThr;
+  isNchannels = nTrgFiredCells > FV0DigParam::Instance().NchannelsLevel;
+  // isAIn = nSignalInner > FV0DigParam::Instance().NchannelsLevel;  // ring 1,2 and 3
+  isAIn = 0.125 * totalChargeInnerRing > 2 * FV0DigParam::Instance().InnerChargeLevel; // ring 1,2 and 3
+  // isAOut = nSignalOuter > FV0DigParam::Instance().NchannelsLevel; // ring 4 and 5
+  isAOut = 0.125 * totalChargeOuterRing > 2 * FV0DigParam::Instance().OuterChargeLevel; // ring 4 and 5
+  isTotalCharge = 0.125 * totalChargeAllRing > 2 * FV0DigParam::Instance().ChargeLevel;
 
   Triggers triggers;
   const int unusedCharge = o2::fit::Triggers::DEFAULT_AMP;
@@ -314,10 +320,10 @@ void Digitizer::storeBC(const BCCache& bc,
   const int unusedZero = o2::fit::Triggers::DEFAULT_ZERO;
   const bool unusedBitsInSim = false; // bits related to laser and data validity
   const bool bitDataIsValid = true;
-  triggers.setTriggers(isA, isAIn, isAOut, isCen, isSCen, nTrgFiredCells, (int8_t)unusedZero,
+  triggers.setTriggers(isA, isAIn, isAOut, isTotalCharge, isNchannels, nTrgFiredCells, (int8_t)unusedZero,
                        (int32_t)(0.125 * totalChargeAllRing), (int32_t)unusedCharge, (int16_t)avgTime, (int16_t)unusedTime, unusedBitsInSim, unusedBitsInSim, bitDataIsValid);
   digitsBC.emplace_back(first, nTotFiredCells, bc, triggers, mEventId - 1);
-  digitsTrig.emplace_back(bc, isA, isAIn, isAOut, isCen, isSCen);
+  digitsTrig.emplace_back(bc, isA, isAIn, isAOut, isTotalCharge, isNchannels);
   for (auto const& lbl : bc.labels) {
     labels.addElement(nBC, lbl);
   }
@@ -342,8 +348,8 @@ Int_t Digitizer::SimulateLightYield(Int_t pmt, Int_t nPhot) const
 //---------------------------------------------------------------------------
 Float_t Digitizer::IntegrateCharge(const ChannelDigitF& pulse) const
 {
-  int const chargeIntMin = FV0DigParam::Instance().isIntegrateFull ? 0 : (FV0DigParam::Instance().avgCfdTimeForMip - 6.0) / mBinSize;                //Charge integration offset (cfd mean time - 6 ns)
-  int const chargeIntMax = FV0DigParam::Instance().isIntegrateFull ? mNTimeBinsPerBC : (FV0DigParam::Instance().avgCfdTimeForMip + 14.0) / mBinSize; //Charge integration offset (cfd mean time + 14 ns)
+  int const chargeIntMin = FV0DigParam::Instance().isIntegrateFull ? 0 : (FV0DigParam::Instance().avgCfdTimeForMip - 6.0) / mBinSize;                // Charge integration offset (cfd mean time - 6 ns)
+  int const chargeIntMax = FV0DigParam::Instance().isIntegrateFull ? mNTimeBinsPerBC : (FV0DigParam::Instance().avgCfdTimeForMip + 14.0) / mBinSize; // Charge integration offset (cfd mean time + 14 ns)
   if (chargeIntMin < 0 || chargeIntMin > mNTimeBinsPerBC || chargeIntMax > mNTimeBinsPerBC) {
     LOG(fatal) << "invalid indicess: chargeInMin=" << chargeIntMin << " chargeIntMax=" << chargeIntMax;
   }
@@ -400,7 +406,7 @@ float Digitizer::getDistFromCellCenter(UInt_t cellId, double hitx, double hity)
   double a = -(y0 - pCell->y) / (x0 - pCell->x);
   double b = 1;
   double c = -(y0 - a * x0);
-  //Return the distance from hit to this line
+  // Return the distance from hit to this line
   return (a * hitx + b * hity + c) / TMath::Sqrt(a * a + b * b);
 }
 

From bbb4570480ccb5f89af56913a9b7403e61610778 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Tue, 31 Mar 2026 00:34:34 +0200
Subject: [PATCH 1503/1764] [ALICE3] IOTOF: Adjust layer radius calculations
 for stave tilt and chip thickness (#15220)

* [ALICE3] IOTOF: Adjust layer radius calculations for stave tilt

* Refactor iTOF and oTOF layer initialization logic

* Update README.md

* Update IOTOFBaseParam.h default thickness

* Updated stave tilt angle for segmented iTOF configuration.
---
 Detectors/Upgrades/ALICE3/IOTOF/README.md     |  2 +-
 .../base/include/IOTOFBase/IOTOFBaseParam.h   |  4 ++--
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  |  8 +++----
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     | 24 +++++++++++--------
 4 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/README.md b/Detectors/Upgrades/ALICE3/IOTOF/README.md
index fba4d12252af6..d7a954c4718fe 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/README.md
+++ b/Detectors/Upgrades/ALICE3/IOTOF/README.md
@@ -23,7 +23,7 @@ Configurables for various sub-detectors are presented in the following Table:
 | `IOTOFBase.segmentedInnerTOF` | `false` (default), `true`                                        | Use segmented geometry for inner TOF           |
 | `IOTOFBase.segmentedOuterTOF` | `false` (default), `true`                                        | Use segmented geometry for outer TOF           |
 | `IOTOFBase.detectorPattern`   | ` ` (default), `v3b`, `v3b1a`, `v3b1b`, `v3b2a`, `v3b2b`, `v3b3` | Optional layout pattern                        |
-| `IOTOFBase.x2x0`              | `0.02` (default)                                                 | Chip thickness in fractions of the rad. lenght |
+| `IOTOFBase.x2x0`              | `0.000527` (default)                                             | Chip thickness in fractions of the rad. lenght |
 
 
 For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
index 91d005415891d..1f1a26b79077e 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
@@ -28,7 +28,7 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
   std::string detectorPattern = ""; // Layouts of the detector
   bool segmentedInnerTOF = false;   // If the inner TOF layer is segmented
   bool segmentedOuterTOF = false;   // If the outer TOF layer is segmented
-  float x2x0 = 0.02f;               // thickness expressed in radiation length, for all layers for the moment
+  float x2x0 = 0.000527f;           // thickness expressed in radiation length, for all layers for the moment
 
   O2ParamDef(IOTOFBaseParam, "IOTOFBase");
 };
@@ -36,4 +36,4 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
 } // namespace iotof
 } // end namespace o2
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index 61720f2172b92..d6417eba22041 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -96,10 +96,10 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
   }
   if (itof) { // iTOF
     const std::string name = GeometryTGeo::getITOFLayerPattern();
-    const int nStaves = itofSegmented ? 24 : 0;               // number of staves in segmented case
-    const double staveWidth = itofSegmented ? 5.42 : 0.0;     // cm
-    const double staveTiltAngle = itofSegmented ? 10.0 : 0.0; // degrees
-    const int modulesPerStave = itofSegmented ? 10 : 0;       // number of modules per stave in segmented case
+    const int nStaves = itofSegmented ? 24 : 0;              // number of staves in segmented case
+    const double staveWidth = itofSegmented ? 5.42 : 0.0;    // cm
+    const double staveTiltAngle = itofSegmented ? 3.0 : 0.0; // degrees
+    const int modulesPerStave = itofSegmented ? 10 : 0;      // number of modules per stave in segmented case
     mITOFLayer = ITOFLayer(name,
                            dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, itofSegmented ? ITOFLayer::kBarrelSegmented : ITOFLayer::kBarrel,
                            nStaves, staveWidth, staveTiltAngle, modulesPerStave);
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 118078ebf7100..66d0b2959c8bd 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -155,11 +155,13 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
     case kBarrelSegmented: {
       // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
-      const double staveSizeX = mStaves.second;                                                                                                          // cm
-      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                             // cm
-      const double staveSizeZ = mZLength;                                                                                                                // cm
-      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY); // we increase the size of the layer to account for the tilt of the staves
-      TGeoTube* layer = new TGeoTube(mInnerRadius - deltaForTilt, mOuterRadius + deltaForTilt, mZLength / 2);
+      const double staveSizeX = mStaves.second;                                                                                                                    // cm
+      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                                       // cm
+      const double staveSizeZ = mZLength;                                                                                                                          // cm
+      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY);           // we increase the size of the layer to account for the tilt of the staves
+      const double radiusMax = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY + avgRadius * 2. * deltaForTilt); // we increase the outer radius to account for the tilt of the staves
+      const double radiusMin = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY - avgRadius * 2. * deltaForTilt); // we decrease the inner radius to account for the tilt of the staves
+      TGeoTube* layer = new TGeoTube(radiusMin, radiusMax, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
 
@@ -287,11 +289,13 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
     case kBarrelSegmented: {
       // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
-      const double staveSizeX = mStaves.second;                                                                                                          // cm
-      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                             // cm
-      const double staveSizeZ = mZLength;                                                                                                                // cm
-      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY); // we increase the size of the layer to account for the tilt of the staves
-      TGeoTube* layer = new TGeoTube(mInnerRadius - deltaForTilt, mOuterRadius + deltaForTilt, mZLength / 2);
+      const double staveSizeX = mStaves.second;                                                                                                                    // cm
+      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                                       // cm
+      const double staveSizeZ = mZLength;                                                                                                                          // cm
+      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY);           // we increase the size of the layer to account for the tilt of the staves
+      const double radiusMax = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY + avgRadius * 2. * deltaForTilt); // we increase the outer radius to account for the tilt of the staves
+      const double radiusMin = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY - avgRadius * 2. * deltaForTilt); // we decrease the inner radius to account for the tilt of the staves
+      TGeoTube* layer = new TGeoTube(radiusMin, radiusMax, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
 

From 974bdc0596d1124a6ee69343962a2c6379f68f88 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 11:09:46 +0200
Subject: [PATCH 1504/1764] Use default constructor

---
 Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h | 2 +-
 Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h b/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
index 9aaf6e517336d..7050cc6c69370 100644
--- a/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
+++ b/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
@@ -83,7 +83,7 @@ struct DataPointCompositeObject final {
   /**
          * Copy constructor
          */
-  DataPointCompositeObject(const DataPointCompositeObject& src) noexcept : DataPointCompositeObject(src.id, src.data) {}
+  DataPointCompositeObject(const DataPointCompositeObject& src) noexcept = default;
 
   DataPointCompositeObject& operator=(const DataPointCompositeObject& src) noexcept
   {
diff --git a/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h b/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
index 79b7d7cf886c7..be21f71f8f3e3 100644
--- a/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
+++ b/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
@@ -85,7 +85,7 @@ class DataPointIdentifier final
   /**
    * A copy constructor for DataPointIdentifier.
    */
-  DataPointIdentifier(const DataPointIdentifier& src) noexcept : DataPointIdentifier(src.pt1, src.pt2, src.pt3, src.pt4, src.pt5, src.pt6, src.pt7, src.pt8) {}
+  DataPointIdentifier(const DataPointIdentifier& src) noexcept = default;
 
   DataPointIdentifier& operator=(const DataPointIdentifier& src) noexcept
   {

From e2e7eb846e103d55ac9ba725d5cb7dbdbb249f50 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 29 Mar 2026 11:17:29 +0200
Subject: [PATCH 1505/1764] Rework DCS point classes to have default assign
 operators

---
 .../DetectorsDCS/DataPointCompositeObject.h   | 10 ++-----
 .../DetectorsDCS/DataPointIdentifier.h        | 29 ++++++-------------
 2 files changed, 11 insertions(+), 28 deletions(-)

diff --git a/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h b/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
index 7050cc6c69370..6ea69f82277bf 100644
--- a/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
+++ b/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
@@ -47,7 +47,7 @@ struct DataPointCompositeObject final {
          *
          * @see ADAPRO::ADAPOS::DataPointIdentifier
          */
-  const DataPointIdentifier id;
+  DataPointIdentifier id;
 
   /**
          * The DataPointValue object, which occupies the last 64 bytes of the
@@ -85,13 +85,7 @@ struct DataPointCompositeObject final {
          */
   DataPointCompositeObject(const DataPointCompositeObject& src) noexcept = default;
 
-  DataPointCompositeObject& operator=(const DataPointCompositeObject& src) noexcept
-  {
-    if (&src != this) {
-      memcpy(this, &src, sizeof(DataPointCompositeObject));
-    }
-    return *this;
-  }
+  DataPointCompositeObject& operator=(const DataPointCompositeObject& src) noexcept = default;
 
   /**
          * Bit-by bit equality comparison of DataPointCompositeObjects.
diff --git a/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h b/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
index be21f71f8f3e3..8d156e04ebbca 100644
--- a/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
+++ b/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
@@ -41,19 +41,14 @@ namespace dcs
      */
 class DataPointIdentifier final
 {
-  const uint64_t pt1;
-  const uint64_t pt2;
-  const uint64_t pt3;
-  const uint64_t pt4;
-  const uint64_t pt5;
-  const uint64_t pt6;
-  const uint64_t pt7;
-  const uint64_t pt8; // Contains the last 6 chars of alias and the type.
-
-  DataPointIdentifier(
-    const uint64_t pt1, const uint64_t pt2, const uint64_t pt3,
-    const uint64_t pt4, const uint64_t pt5, const uint64_t pt6,
-    const uint64_t pt7, const uint64_t pt8) noexcept : pt1(pt1), pt2(pt2), pt3(pt3), pt4(pt4), pt5(pt5), pt6(pt6), pt7(pt7), pt8(pt8) {}
+  uint64_t pt1;
+  uint64_t pt2;
+  uint64_t pt3;
+  uint64_t pt4;
+  uint64_t pt5;
+  uint64_t pt6;
+  uint64_t pt7;
+  uint64_t pt8; // Contains the last 6 chars of alias and the type.
 
  public:
   /**
@@ -87,13 +82,7 @@ class DataPointIdentifier final
    */
   DataPointIdentifier(const DataPointIdentifier& src) noexcept = default;
 
-  DataPointIdentifier& operator=(const DataPointIdentifier& src) noexcept
-  {
-    if (&src != this) {
-      memcpy(this, &src, sizeof(DataPointIdentifier));
-    }
-    return *this;
-  }
+  DataPointIdentifier& operator=(const DataPointIdentifier& src) noexcept = default;
 
   /**
          * This stati procedure fills the given DataPointIdentifier object with

From ae345476bb628d972f7a44142649dffe456d7803 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 1 Apr 2026 12:59:16 +0200
Subject: [PATCH 1506/1764] Align to coding conventions

---
 .../Base/GPUReconstructionDebug.cxx           | 50 ++++++++++++-------
 1 file changed, 31 insertions(+), 19 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx b/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx
index 564c04ba7f745..559d1537464ab 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionDebug.cxx
@@ -215,55 +215,67 @@ void GPUReconstructionCPU::debugWriter::row(char type, uint32_t count, std::stri
 
   if (streamCSV.is_open()) {
     streamCSV << type << ",";
-    if (count != 0)
+    if (count != 0) {
       streamCSV << count;
+    }
     streamCSV << "," << name << ",";
-    if (gpu_time != -1.0)
+    if (gpu_time != -1.0) {
       streamCSV << std::format("{:.0f}", gpu_time * scale);
+    }
     streamCSV << ",";
-    if (cpu_time != -1.0)
+    if (cpu_time != -1.0) {
       streamCSV << std::format("{:.0f}", cpu_time * scale);
+    }
     streamCSV << ",";
-    if (cpu_time != -1.0 && total_time != -1.0)
+    if (cpu_time != -1.0 && total_time != -1.0) {
       streamCSV << std::format("{:.2f}", cpu_time / total_time);
+    }
     streamCSV << ",";
-    if (total_time != -1.0)
+    if (total_time != -1.0) {
       streamCSV << std::format("{:.0f}", total_time * scale);
+    }
     streamCSV << ",";
-    if (memSize != 0 && count != 0)
+    if (memSize != 0 && count != 0) {
       streamCSV << std::format("{:.3f},{},{}", memSize / gpu_time * 1e-9, memSize / mStatNEvents, memSize / mStatNEvents / count);
-    else
+    } else {
       streamCSV << ",,";
+    }
     streamCSV << std::endl;
   }
 
   if (mMarkdown) {
     std::cout << "| " << type << " | ";
-    if (count != 0)
+    if (count != 0) {
       std::cout << std::format("{:6} |", count);
-    else
+    } else {
       std::cout << "       |";
+    }
     std::cout << std::format(" {:42}|", name);
-    if (gpu_time != -1.0)
+    if (gpu_time != -1.0) {
       std::cout << std::format("{:10.0f} |", gpu_time * scale);
-    else
+    } else {
       std::cout << "           |";
-    if (cpu_time != -1.0)
+    }
+    if (cpu_time != -1.0) {
       std::cout << std::format("{:10.0f} |", cpu_time * scale);
-    else
+    } else {
       std::cout << "           |";
-    if (cpu_time != -1.0 && total_time != -1.0)
+    }
+    if (cpu_time != -1.0 && total_time != -1.0) {
       std::cout << std::format("{:8.2f} |", cpu_time / total_time);
-    else
+    } else {
       std::cout << "         |";
-    if (total_time != -1.0)
+    }
+    if (total_time != -1.0) {
       std::cout << std::format("{:10.0f} |", total_time * scale);
-    else
+    } else {
       std::cout << "           |";
-    if (memSize != 0 && count != 0)
+    }
+    if (memSize != 0 && count != 0) {
       std::cout << std::format("{:10.3f} |{:14} |{:14} |", memSize / gpu_time * 1e-9, memSize / mStatNEvents, memSize / mStatNEvents / count);
-    else
+    } else {
       std::cout << "           |               |               |";
+    }
     std::cout << std::endl;
   } else {
     if (name.substr(0, 3) == "GPU") {

From 4f64fb9cabd616e2e822d1a683918ba86fba366c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 25 Mar 2026 15:01:55 +0100
Subject: [PATCH 1507/1764] Drop async-list-label action

My understanding is that this is not actually used, as it is superseded by
the two / three tag approach.
---
 .github/workflows/async-list-label.yml | 19 -------------------
 1 file changed, 19 deletions(-)
 delete mode 100644 .github/workflows/async-list-label.yml

diff --git a/.github/workflows/async-list-label.yml b/.github/workflows/async-list-label.yml
deleted file mode 100644
index e0b4185c563b7..0000000000000
--- a/.github/workflows/async-list-label.yml
+++ /dev/null
@@ -1,19 +0,0 @@
----
-name: Collect and print async labels
-
-'on':
-  pull_request_target:
-    types:
-      - opened
-      - reopened
-    branches:
-      - dev
-
-permissions: {}
-
-jobs:
-  list_async_labels:
-    name: Collect and print async labels
-    uses: alisw/ali-bot/.github/workflows/async-list-label.yml@master
-    permissions:
-      pull-requests: write   # to update labels

From 74c80492483241afc58a5784cd6ce89e097520af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 1 Apr 2026 16:08:26 +0200
Subject: [PATCH 1508/1764] [ALICE3] IOTOF: allow reduced sensor thickness
 wihout reducing chip size (#15247)

* Enhance Layer class with sensor thickness handling

Added sensor thickness parameter and validation checks.

* Add sensor thickness to Layer class

Added sensor thickness parameter to Layer constructor and updated member variables accordingly.

* Modify configLayers to include sensorThickness

Added sensorThickness parameter to configLayers function for ITOF and OTOF layers.

* Update Detector.h

* Modify thickness parameters in IOTOFBaseParam.h

Updated the radiation length thickness and added sensor thickness parameter.

* Revise options table in README for IOTOF

Updated options table with new sensor thickness parameter and corrected default value for x2x0.

* Simplify chip size calculation in Layer.cxx

Removed sensor thickness adjustment for chip size calculation.

* Update sensor size calculation in Layer.cxx
---
 Detectors/Upgrades/ALICE3/IOTOF/README.md     | 22 ++++++++++---------
 .../base/include/IOTOFBase/IOTOFBaseParam.h   |  3 ++-
 .../include/IOTOFSimulation/Detector.h        |  4 ++--
 .../include/IOTOFSimulation/Layer.h           |  9 ++++----
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  |  6 ++---
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     | 15 +++++++++----
 6 files changed, 35 insertions(+), 24 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/README.md b/Detectors/Upgrades/ALICE3/IOTOF/README.md
index d7a954c4718fe..e52b5e2379e9c 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/README.md
+++ b/Detectors/Upgrades/ALICE3/IOTOF/README.md
@@ -14,16 +14,18 @@ Configurables for various sub-detectors are presented in the following Table:
 
 [link to definitions](./base/include/IOTOFBase/IOTOFBaseParam.h)
 
-| Options                       | Choices                                                          | Comments                                       |
-| ----------------------------- | ---------------------------------------------------------------- | ---------------------------------------------- |
-| `IOTOFBase.enableInnerTOF`    | `true` (default), `false`                                        | Enable inner TOF barrel layer                  |
-| `IOTOFBase.enableOuterTOF`    | `true` (default), `false`                                        | Enable outer TOF barrel layer                  |
-| `IOTOFBase.enableForwardTOF`  | `true` (default), `false`                                        | Enable forward TOF endcap                      |
-| `IOTOFBase.enableBackwardTOF` | `true` (default), `false`                                        | Enable backward TOF endcap                     |
-| `IOTOFBase.segmentedInnerTOF` | `false` (default), `true`                                        | Use segmented geometry for inner TOF           |
-| `IOTOFBase.segmentedOuterTOF` | `false` (default), `true`                                        | Use segmented geometry for outer TOF           |
-| `IOTOFBase.detectorPattern`   | ` ` (default), `v3b`, `v3b1a`, `v3b1b`, `v3b2a`, `v3b2b`, `v3b3` | Optional layout pattern                        |
-| `IOTOFBase.x2x0`              | `0.000527` (default)                                             | Chip thickness in fractions of the rad. lenght |
+| Options                       | Choices                                                          | Comments                                                                   |
+| ----------------------------- | ---------------------------------------------------------------- | -------------------------------------------------------------------------- |
+| `IOTOFBase.enableInnerTOF`    | `true` (default), `false`                                        | Enable inner TOF barrel layer                                              |
+| `IOTOFBase.enableOuterTOF`    | `true` (default), `false`                                        | Enable outer TOF barrel layer                                              |
+| `IOTOFBase.enableForwardTOF`  | `true` (default), `false`                                        | Enable forward TOF endcap                                                  |
+| `IOTOFBase.enableBackwardTOF` | `true` (default), `false`                                        | Enable backward TOF endcap                                                 |
+| `IOTOFBase.segmentedInnerTOF` | `false` (default), `true`                                        | Use segmented geometry for inner TOF                                       |
+| `IOTOFBase.segmentedOuterTOF` | `false` (default), `true`                                        | Use segmented geometry for outer TOF                                       |
+| `IOTOFBase.detectorPattern`   | ` ` (default), `v3b`, `v3b1a`, `v3b1b`, `v3b2a`, `v3b2b`, `v3b3` | Optional layout pattern                                                    |
+| `IOTOFBase.x2x0`              | `0.02` (default)                                                 | Chip thickness in fractions of the rad. lenght                             |
+| `IOTOFBase.sensorThickness`   | `0.0050` (default)                                               | Sensor thickness in cm, can be at maximum equivalent to the chip thickness |
+
 
 
 For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
index 1f1a26b79077e..c1a9578484c17 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
@@ -28,7 +28,8 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
   std::string detectorPattern = ""; // Layouts of the detector
   bool segmentedInnerTOF = false;   // If the inner TOF layer is segmented
   bool segmentedOuterTOF = false;   // If the outer TOF layer is segmented
-  float x2x0 = 0.000527f;           // thickness expressed in radiation length, for all layers for the moment
+  float x2x0 = 0.02f;               // thickness expressed in radiation length, for all layers for the moment
+  float sensorThickness = 0.0050f;  // thickness of the sensor in cm, for all layers for the moment, the default is set to 50 microns
 
   O2ParamDef(IOTOFBaseParam, "IOTOFBase");
 };
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
index acf754e1b1fa8..34097020c42ff 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Detector.h
@@ -60,7 +60,7 @@ class Detector : public o2::base::DetImpl<Detector>
     return nullptr;
   }
 
-  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "", bool itofSegmented = false, bool otofSegmented = false, const float x2x0 = 0.02f);
+  void configLayers(bool itof = true, bool otof = true, bool ftof = true, bool btof = true, std::string pattern = "", bool itofSegmented = false, bool otofSegmented = false, const float x2x0 = 0.02f, const float sensorThickness = 0.0050f);
 
   void configServices();
   void createMaterials();
@@ -104,4 +104,4 @@ struct UseShm<o2::iotof::Detector> {
 } // namespace base
 } // namespace o2
 #endif
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
index 29542810b8021..dc9fedf439a11 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Layer.h
@@ -26,7 +26,7 @@ class Layer
  public:
   Layer() = default;
   Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0,
-        int layout = kBarrel, int nStaves = 0, float staveSize = 0.0, double staveTiltAngle = 0.0, int modulesPerStave = 0);
+        int layout = kBarrel, int nStaves = 0, float staveSize = 0.0, double staveTiltAngle = 0.0, int modulesPerStave = 0, float sensorThickness = 0.0f);
   ~Layer() = default;
 
   auto getInnerRadius() const { return mInnerRadius; }
@@ -52,8 +52,9 @@ class Layer
   float mZLength;
   float mZOffset{0.f}; // Of use when fwd layers
   float mX2X0;
-  float mChipThickness;
-  int mLayout{kBarrel}; // Identifier of the type of layer layout (barrel, disk, barrel segmented, disk segmented)
+  float mChipThickness;   // Thickness of the chip in cm, derived from mX2X0 and the radiation length of silicon
+  float mSensorThickness; // Thickness of the sensor in cm, to be subtracted from the chip thickness to get the total module thickness
+  int mLayout{kBarrel};   // Identifier of the type of layer layout (barrel, disk, barrel segmented, disk segmented)
   // To be used only in case of the segmented layout, to define the number of staves in phi (for barrel) or in r (for disk)
   std::pair<int, float> mStaves{0, 0.0f}; // Number and size of staves in phi (for barrel) or in r (for disk) in case of segmented layout
   int mModulesPerStave{0};                // Number of modules along a stave
@@ -92,4 +93,4 @@ class BTOFLayer : public Layer
 
 } // namespace iotof
 } // namespace o2
-#endif // ALICEO2_IOTOF_LAYER_H
\ No newline at end of file
+#endif // ALICEO2_IOTOF_LAYER_H
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index d6417eba22041..59b914a3dd076 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -58,7 +58,7 @@ void Detector::ConstructGeometry()
 }
 
 void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::string pattern, bool itofSegmented, bool otofSegmented,
-                            const float x2x0)
+                            const float x2x0, const float sensorThickness)
 {
 
   const std::pair<float, float> dInnerTof = {21.f, 129.f}; // Radius and length
@@ -102,7 +102,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const int modulesPerStave = itofSegmented ? 10 : 0;      // number of modules per stave in segmented case
     mITOFLayer = ITOFLayer(name,
                            dInnerTof.first, 0.f, dInnerTof.second, 0.f, x2x0, itofSegmented ? ITOFLayer::kBarrelSegmented : ITOFLayer::kBarrel,
-                           nStaves, staveWidth, staveTiltAngle, modulesPerStave);
+                           nStaves, staveWidth, staveTiltAngle, modulesPerStave, itofSegmented ? sensorThickness : 0.0f);
   }
   if (otof) { // oTOF
     const std::string name = GeometryTGeo::getOTOFLayerPattern();
@@ -112,7 +112,7 @@ void Detector::configLayers(bool itof, bool otof, bool ftof, bool btof, std::str
     const int modulesPerStave = otofSegmented ? 54 : 0;      // number of modules per stave in segmented case
     mOTOFLayer = OTOFLayer(name,
                            dOuterTof.first, 0.f, dOuterTof.second, 0.f, x2x0, otofSegmented ? OTOFLayer::kBarrelSegmented : OTOFLayer::kBarrel,
-                           nStaves, staveWidth, staveTiltAngle, modulesPerStave);
+                           nStaves, staveWidth, staveTiltAngle, modulesPerStave, otofSegmented ? sensorThickness : 0.0f);
   }
   if (ftof) {
     const std::string name = GeometryTGeo::getFTOFLayerPattern();
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 66d0b2959c8bd..b603d2a4a423b 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -28,19 +28,20 @@ namespace o2
 namespace iotof
 {
 Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float zOffset, float layerX2X0,
-             int layout, int nStaves, float staveSize, double staveTiltAngle, int modulesPerStave)
+             int layout, int nStaves, float staveSize, double staveTiltAngle, int modulesPerStave, float sensorThickness)
   : mLayerName(layerName),
     mInnerRadius(rInn),
     mOuterRadius(rOut),
     mZLength(zLength),
     mZOffset(zOffset),
+    mSensorThickness(sensorThickness),
     mX2X0(layerX2X0),
     mLayout(layout),
     mStaves(nStaves, staveSize),
     mModulesPerStave(modulesPerStave),
     mTiltAngle(staveTiltAngle)
 {
-  const float Si_X0 = 9.5f;
+  const float Si_X0 = 9.5f; // cm, radiation length of silicon
   mChipThickness = mX2X0 * Si_X0;
   std::string name = "";
   switch (layout) {
@@ -76,6 +77,12 @@ Layer::Layer(std::string layerName, float rInn, float rOut, float zLength, float
   if ((mTiltAngle < 0.0 || mTiltAngle > 90.0) && (layout == kBarrelSegmented || layout == kDiskSegmented)) {
     LOG(fatal) << "Invalid configuration: tilt angle " << mTiltAngle << " is too large, it must be between 0 and 90 degrees";
   }
+  if (mSensorThickness < 0.0f || mSensorThickness > mChipThickness) {
+    LOG(fatal) << "Invalid configuration: sensor thickness " << mSensorThickness << " cm is out of range (0, " << mChipThickness << ") cm";
+  }
+  if (sensorThickness > 0.0f && (layout == kBarrel || layout == kDisk)) {
+    LOG(fatal) << "Invalid configuration: sensor thickness " << mSensorThickness << " cm is set for non-segmented layout, it should be 0";
+  }
 
   LOGP(info, "TOF: Creating {} layer: rInner: {} (cm) rOuter: {} (cm) zLength: {} (cm) zOffset: {} x2X0: {}", name.c_str(), mInnerRadius, mOuterRadius, mZLength, mZOffset, mX2X0);
 }
@@ -193,7 +200,7 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       const int sensorsPerChipX = 2;                          // we assume that each chip is divided in 2 sensors along the x direction
       const int sensorsPerChipZ = 2;                          // we assume that each chip is divided in 2 sensors along the z direction
       const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
-      const double sensorSizeY = chipSizeY;                   // cm
+      const double sensorSizeY = mSensorThickness;            // cm
       const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
       TGeoBBox* sensor = new TGeoBBox(sensorSizeX * 0.5, sensorSizeY * 0.5, sensorSizeZ * 0.5);
       TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);
@@ -327,7 +334,7 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
       const int sensorsPerChipX = 2;                          // we assume that each chip is divided in 2 sensors along the x direction
       const int sensorsPerChipZ = 2;                          // we assume that each chip is divided in 2 sensors along the z direction
       const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
-      const double sensorSizeY = chipSizeY;                   // cm
+      const double sensorSizeY = mSensorThickness;            // cm
       const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
       TGeoBBox* sensor = new TGeoBBox(sensorSizeX * 0.5, sensorSizeY * 0.5, sensorSizeZ * 0.5);
       TGeoVolume* sensVol = new TGeoVolume(sensName, sensor, medSi);

From ea6b15c3746b71a0fd4cf7886caf9921639de65f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 1 Apr 2026 16:08:40 +0200
Subject: [PATCH 1509/1764] [ALICE3] TRK: Collect services in a dedicated
 volume assembly (#15215)

* Refactor TRKServices to use volume assembly

* Add service volume name to GeometryTGeo

* Add getTRKServiceVolPattern method and variable
---
 .../ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h  |  2 ++
 .../Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx   |  1 +
 .../ALICE3/TRK/simulation/src/TRKServices.cxx       | 13 ++++++++-----
 3 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index e32a2546c6842..576dbf434f757 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -43,6 +43,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
     return sInstance.get();
   };
   static const char* getTRKVolPattern() { return sVolumeName.c_str(); }
+  static const char* getTRKServiceVolPattern() { return sServiceVolName.c_str(); }
   static const char* getTRKLayerPattern() { return sLayerName.c_str(); }
   static const char* getTRKPetalAssemblyPattern() { return sPetalAssemblyName.c_str(); }
   static const char* getTRKPetalPattern() { return sPetalName.c_str(); }
@@ -198,6 +199,7 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static constexpr int MAXLAYERS = 20; ///< max number of active layers
 
   static std::string sVolumeName;
+  static std::string sServiceVolName;
   static std::string sLayerName;
   static std::string sPetalAssemblyName;
   static std::string sPetalName;
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 36d26a6344e6c..10c1c63615d35 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -26,6 +26,7 @@ std::unique_ptr<o2::trk::GeometryTGeo> GeometryTGeo::sInstance;
 
 // Names
 std::string GeometryTGeo::sVolumeName = "TRKV";
+std::string GeometryTGeo::sServiceVolName = "TRKService";
 std::string GeometryTGeo::sLayerName = "TRKLayer";
 std::string GeometryTGeo::sPetalAssemblyName = "PETAL";
 std::string GeometryTGeo::sPetalName = "PETALCASE";
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index d8246bcd8640c..7cf7dc863607e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -127,18 +127,21 @@ void TRKServices::createMaterials()
 
 void TRKServices::createServices(TGeoVolume* motherVolume)
 {
+
+  TGeoVolumeAssembly* vol = new TGeoVolumeAssembly(GeometryTGeo::getTRKServiceVolPattern());
+  motherVolume->AddNode(vol, 2, new TGeoTranslation(0, 0., 0));
   createMaterials();
   createVacuumCompositeShape();
   auto& trkPars = TRKBaseParam::Instance();
   if (trkPars.getLayoutSRV() == kLOISymm) {
     LOGP(info, "TRK services: LoI version");
-    createMiddleServices(motherVolume);
-    createOuterDisksServices(motherVolume);
-    createOuterBarrelServices(motherVolume);
+    createMiddleServices(vol);
+    createOuterDisksServices(vol);
+    createOuterBarrelServices(vol);
   } else {
     LOGP(info, "TRK services: Peacock layout");
-    createMLServicesPeacock(motherVolume);
-    createOTServicesPeacock(motherVolume);
+    createMLServicesPeacock(vol);
+    createOTServicesPeacock(vol);
   }
 }
 

From ebf039321ea3b9851aceb6d333bcb36f9b4cc7fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 1 Apr 2026 16:09:07 +0200
Subject: [PATCH 1510/1764] [ALICE3] Copy class of ITSMFT Hit for TRK Hit
 (#15194)

---
 Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt     | 2 +-
 .../ALICE3/TRK/simulation/include/TRKSimulation/Hit.h       | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
index 10f117750d793..6d30d8d01bb12 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/CMakeLists.txt
@@ -39,4 +39,4 @@ o2_target_root_dictionary(TRKSimulation
                                   include/TRKSimulation/VDLayer.h
                                   include/TRKSimulation/VDGeometryBuilder.h
                                   include/TRKSimulation/VDSensorRegistry.h
-                                  include/TRKSimulation/DPLDigitizerParam.h)
\ No newline at end of file
+                                  include/TRKSimulation/DPLDigitizerParam.h)
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
index 88afac8682cf4..402a343ead472 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Hit.h
@@ -19,7 +19,11 @@
 
 namespace o2::trk
 {
-using Hit = o2::itsmft::Hit; // For now we rely on the same Hit class as ITSMFT, but we can extend it with TRK-specific information if needed in the future
+class Hit : public o2::itsmft::Hit
+{
+ public:
+  using o2::itsmft::Hit::Hit; // Inherit constructors
+};
 } // namespace o2::trk
 
 #endif

From 8050f83b9ae9f1963af5bd37c1ad6c4b312a4d77 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 31 Mar 2026 20:55:54 +0200
Subject: [PATCH 1511/1764] DPL: add status endpoint to the driver

---
 Framework/Core/CMakeLists.txt                 |   1 +
 Framework/Core/include/Framework/DeviceInfo.h |   3 +
 .../Core/src/ControlWebSocketHandler.cxx      |   5 +
 Framework/Core/src/DPLWebSocket.cxx           |  10 +-
 Framework/Core/src/DPLWebSocket.h             |   1 +
 Framework/Core/src/DriverServerContext.h      |   5 +
 Framework/Core/src/StatusWebSocketHandler.cxx | 503 ++++++++++++++++++
 Framework/Core/src/StatusWebSocketHandler.h   | 101 ++++
 Framework/Core/src/runDataProcessing.cxx      |   7 +
 9 files changed, 635 insertions(+), 1 deletion(-)
 create mode 100644 Framework/Core/src/StatusWebSocketHandler.cxx
 create mode 100644 Framework/Core/src/StatusWebSocketHandler.h

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index c311ba980a20b..0e67e1c0cc623 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -158,6 +158,7 @@ o2_add_library(Framework
                        src/StepTHn.cxx
                        src/Base64.cxx
                        src/DPLWebSocket.cxx
+                       src/StatusWebSocketHandler.cxx
                        src/TimerParamSpec.cxx
                        test/TestClasses.cxx
                TARGETVARNAME targetName
diff --git a/Framework/Core/include/Framework/DeviceInfo.h b/Framework/Core/include/Framework/DeviceInfo.h
index ef93ca83ca03f..bc3e895a3d8ed 100644
--- a/Framework/Core/include/Framework/DeviceInfo.h
+++ b/Framework/Core/include/Framework/DeviceInfo.h
@@ -61,6 +61,9 @@ struct DeviceInfo {
   std::string lastError;
   /// An unterminated string which is not ready to be printed yet
   std::string unprinted;
+  /// Total number of log lines ever stored in history (monotonically increasing).
+  /// Used by status clients to track which lines they have already sent.
+  size_t logSeq = 0;
   /// Whether the device is active (running) or not.
   bool active;
   /// Whether the device is ready to quit.
diff --git a/Framework/Core/src/ControlWebSocketHandler.cxx b/Framework/Core/src/ControlWebSocketHandler.cxx
index 6d7926918a8c7..35528a1d6dfec 100644
--- a/Framework/Core/src/ControlWebSocketHandler.cxx
+++ b/Framework/Core/src/ControlWebSocketHandler.cxx
@@ -11,6 +11,7 @@
 
 #include "ControlWebSocketHandler.h"
 #include "DriverServerContext.h"
+#include "StatusWebSocketHandler.h"
 #include "Framework/DeviceMetricsHelper.h"
 #include "Framework/ServiceMetricsInfo.h"
 #include <regex>
@@ -83,6 +84,10 @@ void ControlWebSocketHandler::endChunk()
   for (auto& callback : *mContext.metricProcessingCallbacks) {
     callback(mContext.registry, ServiceMetricsInfo{*mContext.metrics, *mContext.specs, *mContext.infos, mContext.driver->metrics, *mContext.driver}, timestamp);
   }
+  // Notify status clients before changed flags are reset so they can see what changed.
+  for (auto* statusHandler : mContext.statusHandlers) {
+    statusHandler->sendUpdate(mIndex);
+  }
   for (auto& metricsInfo : *mContext.metrics) {
     std::fill(metricsInfo.changed.begin(), metricsInfo.changed.end(), false);
   }
diff --git a/Framework/Core/src/DPLWebSocket.cxx b/Framework/Core/src/DPLWebSocket.cxx
index d9b6594d5f07c..06de46b387c29 100644
--- a/Framework/Core/src/DPLWebSocket.cxx
+++ b/Framework/Core/src/DPLWebSocket.cxx
@@ -18,6 +18,7 @@
 #include "DriverServerContext.h"
 #include "DriverClientContext.h"
 #include "ControlWebSocketHandler.h"
+#include "StatusWebSocketHandler.h"
 #include "HTTPParser.h"
 #include <algorithm>
 #include <atomic>
@@ -193,9 +194,10 @@ void WSDPLHandler::method(std::string_view const& s)
 
 void WSDPLHandler::target(std::string_view const& s)
 {
-  if (s != "/") {
+  if (s != "/" && s != "/status") {
     throw WSError{404, "Unknown"};
   }
+  mTarget = s;
 }
 
 void populateHeader(std::map<std::string, std::string>& headers, std::string_view const& k, std::string_view const& v)
@@ -294,6 +296,12 @@ void WSDPLHandler::endHeaders()
         break;
       }
     }
+  } else if (mTarget == "/status" && mServerContext->isDriver) {
+    LOGP(info, "Status client connected ({} total)", mServerContext->statusHandlers.size() + 1);
+    auto* statusHandler = new StatusWebSocketHandler(*mServerContext, this);
+    mServerContext->statusHandlers.push_back(statusHandler);
+    mHandler = std::unique_ptr<WebSocketHandler>(statusHandler);
+    mHandler->headers(mHeaders);
   } else {
     if ((mServerContext->isDriver && getenv("DPL_DRIVER_REMOTE_GUI")) || ((mServerContext->isDriver == false) && getenv("DPL_DEVICE_REMOTE_GUI"))) {
       LOG(info) << "Connection not bound to a PID";
diff --git a/Framework/Core/src/DPLWebSocket.h b/Framework/Core/src/DPLWebSocket.h
index 43ec27a6b54f0..1985c37157d65 100644
--- a/Framework/Core/src/DPLWebSocket.h
+++ b/Framework/Core/src/DPLWebSocket.h
@@ -62,6 +62,7 @@ struct WSDPLHandler : public HTTPParser {
   bool mHandshaken = false;
   uv_stream_t* mStream = nullptr;
   std::map<std::string, std::string> mHeaders;
+  std::string mTarget;
   DriverServerContext* mServerContext;
 };
 
diff --git a/Framework/Core/src/DriverServerContext.h b/Framework/Core/src/DriverServerContext.h
index 4d25c47bd172b..c9f2c80165d92 100644
--- a/Framework/Core/src/DriverServerContext.h
+++ b/Framework/Core/src/DriverServerContext.h
@@ -29,6 +29,7 @@ namespace o2::framework
 struct DriverInfo;
 struct ServiceRegistry;
 struct GuiCallbackContext;
+struct StatusWebSocketHandler;
 
 struct DriverServerContext {
   ServiceRegistryRef registry;
@@ -49,6 +50,10 @@ struct DriverServerContext {
   ///        or something like that.
   bool isDriver = false;
 
+  /// Connected MCP/status clients. Updated by StatusWebSocketHandler
+  /// on connect/disconnect; notified by ControlWebSocketHandler::endChunk().
+  std::vector<StatusWebSocketHandler*> statusHandlers;
+
   /// The handle to the server component of the
   /// driver.
   uv_tcp_t serverHandle;
diff --git a/Framework/Core/src/StatusWebSocketHandler.cxx b/Framework/Core/src/StatusWebSocketHandler.cxx
new file mode 100644
index 0000000000000..db715eff6592d
--- /dev/null
+++ b/Framework/Core/src/StatusWebSocketHandler.cxx
@@ -0,0 +1,503 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "StatusWebSocketHandler.h"
+#include "DPLWebSocket.h"
+#include "DriverServerContext.h"
+#include "Framework/DeviceInfo.h"
+#include "Framework/DeviceMetricsInfo.h"
+#include "Framework/DeviceSpec.h"
+#include "Framework/DeviceStateEnums.h"
+#include "Framework/LogParsingHelpers.h"
+#include <algorithm>
+#include <cstdio>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace o2::framework
+{
+
+namespace
+{
+
+std::string jsonEscape(std::string_view s)
+{
+  std::string out;
+  out.reserve(s.size() + 4);
+  for (unsigned char c : s) {
+    switch (c) {
+      case '"':
+        out += "\\\"";
+        break;
+      case '\\':
+        out += "\\\\";
+        break;
+      case '\n':
+        out += "\\n";
+        break;
+      case '\r':
+        out += "\\r";
+        break;
+      case '\t':
+        out += "\\t";
+        break;
+      default:
+        if (c < 0x20) {
+          char buf[8];
+          snprintf(buf, sizeof(buf), "\\u%04x", c);
+          out += buf;
+        } else {
+          out += static_cast<char>(c);
+        }
+    }
+  }
+  return out;
+}
+
+char const* logLevelName(LogParsingHelpers::LogLevel level)
+{
+  switch (level) {
+    case LogParsingHelpers::LogLevel::Debug:
+      return "debug";
+    case LogParsingHelpers::LogLevel::Info:
+      return "info";
+    case LogParsingHelpers::LogLevel::Important:
+      return "important";
+    case LogParsingHelpers::LogLevel::Warning:
+      return "warning";
+    case LogParsingHelpers::LogLevel::Alarm:
+      return "alarm";
+    case LogParsingHelpers::LogLevel::Error:
+      return "error";
+    case LogParsingHelpers::LogLevel::Critical:
+      return "critical";
+    case LogParsingHelpers::LogLevel::Fatal:
+      return "fatal";
+    default:
+      return "unknown";
+  }
+}
+
+char const* streamingStateName(StreamingState s)
+{
+  switch (s) {
+    case StreamingState::Streaming:
+      return "Streaming";
+    case StreamingState::EndOfStreaming:
+      return "EndOfStreaming";
+    case StreamingState::Idle:
+      return "Idle";
+    default:
+      return "Unknown";
+  }
+}
+
+void appendMetricValue(std::string& out, DeviceMetricsInfo const& info, size_t mi)
+{
+  auto const& metric = info.metrics[mi];
+  if (metric.pos == 0) {
+    out += "null";
+    return;
+  }
+  size_t last = (metric.pos - 1) % metricStorageSize(metric.type);
+  switch (metric.type) {
+    case MetricType::Int:
+      out += std::to_string(info.intMetrics[metric.storeIdx][last]);
+      break;
+    case MetricType::Float: {
+      char buf[32];
+      snprintf(buf, sizeof(buf), "%g", static_cast<double>(info.floatMetrics[metric.storeIdx][last]));
+      out += buf;
+      break;
+    }
+    case MetricType::Uint64:
+      out += std::to_string(info.uint64Metrics[metric.storeIdx][last]);
+      break;
+    default:
+      out += "null";
+  }
+}
+
+/// Extract the value of a simple string field from a flat JSON object.
+/// e.g. extractField(R"({"cmd":"subscribe","device":"prod"})", "device") → "prod"
+/// Returns empty string_view if not found.
+std::string_view extractStringField(std::string_view json, std::string_view key)
+{
+  std::string needle;
+  needle += '"';
+  needle += key;
+  needle += "\":";
+  auto pos = json.find(needle);
+  if (pos == std::string_view::npos) {
+    return {};
+  }
+  pos += needle.size();
+  // skip optional whitespace between ':' and '"'
+  while (pos < json.size() && json[pos] == ' ') {
+    ++pos;
+  }
+  if (pos >= json.size() || json[pos] != '"') {
+    return {};
+  }
+  ++pos; // skip opening quote
+  auto end = json.find('"', pos);
+  if (end == std::string_view::npos) {
+    return {};
+  }
+  return json.substr(pos, end - pos);
+}
+
+/// Extract the raw value of an array field from a flat JSON object.
+/// e.g. extractArrayField(R"({"metrics":["a","b"]})", "metrics") → R"(["a","b"])"
+std::string_view extractArrayField(std::string_view json, std::string_view key)
+{
+  std::string needle;
+  needle += '"';
+  needle += key;
+  needle += "\":";
+  auto pos = json.find(needle);
+  if (pos == std::string_view::npos) {
+    return {};
+  }
+  pos += needle.size();
+  // skip whitespace
+  while (pos < json.size() && json[pos] == ' ') {
+    ++pos;
+  }
+  if (pos >= json.size() || json[pos] != '[') {
+    return {};
+  }
+  auto start = pos;
+  size_t depth = 0;
+  while (pos < json.size()) {
+    if (json[pos] == '[') {
+      ++depth;
+    } else if (json[pos] == ']') {
+      --depth;
+      if (depth == 0) {
+        return json.substr(start, pos - start + 1);
+      }
+    }
+    ++pos;
+  }
+  return {};
+}
+
+/// Iterate over the string elements of a JSON array of strings.
+/// Calls @a callback for each unescaped string value.
+template <typename F>
+void forEachStringInArray(std::string_view arr, F&& callback)
+{
+  // arr is like ["name1","name2"]
+  size_t pos = 0;
+  while (pos < arr.size()) {
+    auto q = arr.find('"', pos);
+    if (q == std::string_view::npos) {
+      break;
+    }
+    auto end = arr.find('"', q + 1);
+    if (end == std::string_view::npos) {
+      break;
+    }
+    callback(arr.substr(q + 1, end - q - 1));
+    pos = end + 1;
+  }
+}
+
+} // anonymous namespace
+
+StatusWebSocketHandler::StatusWebSocketHandler(DriverServerContext& context, WSDPLHandler* handler)
+  : mContext{context}, mHandler{handler}
+{
+}
+
+StatusWebSocketHandler::~StatusWebSocketHandler()
+{
+  auto& handlers = mContext.statusHandlers;
+  handlers.erase(std::remove(handlers.begin(), handlers.end(), this), handlers.end());
+}
+
+void StatusWebSocketHandler::headers(std::map<std::string, std::string> const&)
+{
+  sendSnapshot();
+}
+
+void StatusWebSocketHandler::frame(char const* data, size_t s)
+{
+  std::string_view msg{data, s};
+  auto cmd = extractStringField(msg, "cmd");
+  if (cmd.empty()) {
+    return;
+  }
+  auto deviceName = extractStringField(msg, "device");
+
+  if (cmd == "list_metrics") {
+    handleListMetrics(deviceName);
+  } else if (cmd == "subscribe") {
+    handleSubscribe(deviceName, extractArrayField(msg, "metrics"));
+  } else if (cmd == "unsubscribe") {
+    handleUnsubscribe(deviceName, extractArrayField(msg, "metrics"));
+  } else if (cmd == "subscribe_logs") {
+    handleSubscribeLogs(deviceName);
+  } else if (cmd == "unsubscribe_logs") {
+    handleUnsubscribeLogs(deviceName);
+  }
+}
+
+void StatusWebSocketHandler::sendText(std::string const& json)
+{
+  std::vector<uv_buf_t> outputs;
+  encode_websocket_frames(outputs, json.data(), json.size(), WebSocketOpCode::Text, 0);
+  mHandler->write(outputs);
+}
+
+void StatusWebSocketHandler::sendSnapshot()
+{
+  auto const& specs = *mContext.specs;
+  auto const& infos = *mContext.infos;
+
+  // Size subscription tables to current device count; grow lazily as needed.
+  mSubscribedMetrics.resize(specs.size());
+  mLastLogSeq.resize(infos.size());
+  for (size_t di = 0; di < infos.size(); ++di) {
+    mLastLogSeq[di] = infos[di].logSeq;
+  }
+
+  std::string out;
+  out.reserve(512 + specs.size() * 128);
+  out += R"({"type":"snapshot","devices":[)";
+  for (size_t di = 0; di < specs.size(); ++di) {
+    if (di > 0) {
+      out += ',';
+    }
+    auto const& info = infos[di];
+    out += R"({"name":")";
+    out += jsonEscape(specs[di].name);
+    out += R"(","pid":)";
+    out += std::to_string(info.pid);
+    out += R"(,"active":)";
+    out += info.active ? "true" : "false";
+    out += R"(,"streamingState":")";
+    out += streamingStateName(info.streamingState);
+    out += R"(","deviceState":")";
+    out += jsonEscape(info.deviceState);
+    out += R"("})";
+  }
+  out += "]}";
+  sendText(out);
+}
+
+void StatusWebSocketHandler::sendUpdate(size_t deviceIndex)
+{
+  auto const& specs = *mContext.specs;
+  auto const& metrics = *mContext.metrics;
+
+  if (deviceIndex >= specs.size() || deviceIndex >= metrics.size()) {
+    return;
+  }
+
+  // Lazily grow the subscription table if new devices were added after snapshot.
+  if (mSubscribedMetrics.size() <= deviceIndex) {
+    mSubscribedMetrics.resize(deviceIndex + 1);
+  }
+
+  auto const& subscribed = mSubscribedMetrics[deviceIndex];
+  if (subscribed.empty()) {
+    return;
+  }
+
+  auto const& info = metrics[deviceIndex];
+  std::string metricsJson;
+  metricsJson += '{';
+  bool first = true;
+  for (size_t mi = 0; mi < info.metrics.size(); ++mi) {
+    if (!info.changed[mi]) {
+      continue;
+    }
+    auto const& metric = info.metrics[mi];
+    if (metric.type == MetricType::String ||
+        metric.type == MetricType::Enum ||
+        metric.type == MetricType::Unknown) {
+      continue;
+    }
+    auto const& label = info.metricLabels[mi];
+    std::string_view labelSV{label.label, label.size};
+    if (subscribed.find(std::string(labelSV)) == subscribed.end()) {
+      continue;
+    }
+    if (!first) {
+      metricsJson += ',';
+    }
+    first = false;
+    metricsJson += '"';
+    metricsJson += jsonEscape(labelSV);
+    metricsJson += "\":";
+    appendMetricValue(metricsJson, info, mi);
+  }
+  metricsJson += '}';
+
+  if (first) {
+    // Nothing subscribed changed in this cycle.
+    return;
+  }
+
+  std::string out;
+  out += R"({"type":"update","device":)";
+  out += std::to_string(deviceIndex);
+  out += R"(,"name":")";
+  out += jsonEscape(specs[deviceIndex].name);
+  out += R"(","metrics":)";
+  out += metricsJson;
+  out += '}';
+  sendText(out);
+}
+
+void StatusWebSocketHandler::handleListMetrics(std::string_view deviceName)
+{
+  size_t di = findDeviceIndex(deviceName);
+  if (di == SIZE_MAX) {
+    return;
+  }
+  auto const& metrics = *mContext.metrics;
+
+  std::string out;
+  out += R"({"type":"metrics_list","device":")";
+  out += jsonEscape(deviceName);
+  out += R"(","metrics":[)";
+  bool first = true;
+  if (di < metrics.size()) {
+    auto const& info = metrics[di];
+    for (size_t mi = 0; mi < info.metrics.size(); ++mi) {
+      auto const& metric = info.metrics[mi];
+      if (metric.type == MetricType::String ||
+          metric.type == MetricType::Enum ||
+          metric.type == MetricType::Unknown) {
+        continue;
+      }
+      if (!first) {
+        out += ',';
+      }
+      first = false;
+      auto const& label = info.metricLabels[mi];
+      out += '"';
+      out += jsonEscape({label.label, label.size});
+      out += '"';
+    }
+  }
+  out += "]}";
+  sendText(out);
+}
+
+void StatusWebSocketHandler::handleSubscribe(std::string_view deviceName, std::string_view metricsArr)
+{
+  size_t di = findDeviceIndex(deviceName);
+  if (di == SIZE_MAX || metricsArr.empty()) {
+    return;
+  }
+  if (mSubscribedMetrics.size() <= di) {
+    mSubscribedMetrics.resize(di + 1);
+  }
+  forEachStringInArray(metricsArr, [&](std::string_view name) {
+    mSubscribedMetrics[di].emplace(name);
+  });
+}
+
+void StatusWebSocketHandler::handleUnsubscribe(std::string_view deviceName, std::string_view metricsArr)
+{
+  size_t di = findDeviceIndex(deviceName);
+  if (di == SIZE_MAX || metricsArr.empty() || di >= mSubscribedMetrics.size()) {
+    return;
+  }
+  forEachStringInArray(metricsArr, [&](std::string_view name) {
+    mSubscribedMetrics[di].erase(std::string(name));
+  });
+}
+
+size_t StatusWebSocketHandler::findDeviceIndex(std::string_view name) const
+{
+  auto const& specs = *mContext.specs;
+  for (size_t di = 0; di < specs.size(); ++di) {
+    if (specs[di].name == name) {
+      return di;
+    }
+  }
+  return SIZE_MAX;
+}
+
+void StatusWebSocketHandler::handleSubscribeLogs(std::string_view deviceName)
+{
+  size_t di = findDeviceIndex(deviceName);
+  if (di == SIZE_MAX) {
+    return;
+  }
+  if (mLastLogSeq.size() <= di) {
+    mLastLogSeq.resize(di + 1, 0);
+  }
+  // Start the cursor at the current log position so we only push future lines.
+  mLastLogSeq[di] = (*mContext.infos)[di].logSeq;
+  mLogSubscriptions.insert(di);
+}
+
+void StatusWebSocketHandler::handleUnsubscribeLogs(std::string_view deviceName)
+{
+  size_t di = findDeviceIndex(deviceName);
+  if (di == SIZE_MAX) {
+    return;
+  }
+  mLogSubscriptions.erase(di);
+}
+
+void StatusWebSocketHandler::sendNewLogs(size_t deviceIndex)
+{
+  if (mLogSubscriptions.find(deviceIndex) == mLogSubscriptions.end()) {
+    return;
+  }
+  auto const& infos = *mContext.infos;
+  auto const& specs = *mContext.specs;
+  if (deviceIndex >= infos.size() || deviceIndex >= specs.size()) {
+    return;
+  }
+  if (mLastLogSeq.size() <= deviceIndex) {
+    mLastLogSeq.resize(deviceIndex + 1, 0);
+  }
+
+  auto const& info = infos[deviceIndex];
+  size_t newLines = info.logSeq - mLastLogSeq[deviceIndex];
+  if (newLines == 0) {
+    return;
+  }
+  // Cap to buffer size to avoid re-reading overwritten entries.
+  if (newLines > info.history.size()) {
+    newLines = info.history.size();
+  }
+
+  size_t histSize = info.history.size();
+  // The oldest unread entry sits at (historyPos - newLines + histSize) % histSize.
+  size_t startPos = (info.historyPos + histSize - newLines) % histSize;
+
+  std::string_view devName = specs[deviceIndex].name;
+  for (size_t i = 0; i < newLines; ++i) {
+    size_t pos = (startPos + i) % histSize;
+    std::string out;
+    out += R"({"type":"log","device":")";
+    out += jsonEscape(devName);
+    out += R"(","level":")";
+    out += logLevelName(info.historyLevel[pos]);
+    out += R"(","line":")";
+    out += jsonEscape(info.history[pos]);
+    out += R"("})";
+    sendText(out);
+  }
+  mLastLogSeq[deviceIndex] = info.logSeq;
+}
+
+} // namespace o2::framework
diff --git a/Framework/Core/src/StatusWebSocketHandler.h b/Framework/Core/src/StatusWebSocketHandler.h
new file mode 100644
index 0000000000000..86a460e289440
--- /dev/null
+++ b/Framework/Core/src/StatusWebSocketHandler.h
@@ -0,0 +1,101 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+#ifndef O2_FRAMEWORK_STATUSWEBSOCKETHANDLER_H_
+#define O2_FRAMEWORK_STATUSWEBSOCKETHANDLER_H_
+
+#include "HTTPParser.h"
+#include <map>
+#include <string>
+#include <unordered_set>
+#include <vector>
+#include <cstddef>
+
+namespace o2::framework
+{
+struct DriverServerContext;
+struct WSDPLHandler;
+
+/// WebSocket handler for the /status endpoint.
+///
+/// Protocol (client → driver):
+///   {"cmd":"list_metrics","device":"<name>"}
+///     → driver replies with {"type":"metrics_list","device":"<name>","metrics":[...]}
+///
+///   {"cmd":"subscribe","device":"<name>","metrics":["m1","m2",...]}
+///     → driver starts including those metrics in subsequent update frames
+///
+///   {"cmd":"unsubscribe","device":"<name>","metrics":["m1","m2",...]}
+///     → driver stops sending those metrics
+///
+///   {"cmd":"subscribe_logs","device":"<name>"}
+///     → driver starts pushing new log lines for the device
+///
+///   {"cmd":"unsubscribe_logs","device":"<name>"}
+///     → driver stops pushing log lines for the device
+///
+/// Protocol (driver → client):
+///   {"type":"snapshot","devices":[{"name","pid","active","streamingState","deviceState"},...]}
+///     → sent once on connect; contains no metrics or logs
+///
+///   {"type":"update","device":<index>,"name":"<name>","metrics":{<subscribed & changed>}}
+///     → sent after each metrics cycle for devices with subscribed metrics that changed
+///
+///   {"type":"metrics_list","device":"<name>","metrics":["m1","m2",...]}
+///     → reply to list_metrics command
+///
+///   {"type":"log","device":"<name>","level":"<level>","line":"<text>"}
+///     → pushed for each new log line from a subscribed device
+struct StatusWebSocketHandler : public WebSocketHandler {
+  StatusWebSocketHandler(DriverServerContext& context, WSDPLHandler* handler);
+  ~StatusWebSocketHandler() override;
+
+  /// Sends the minimal snapshot on handshake completion.
+  void headers(std::map<std::string, std::string> const& headers) override;
+  /// Handles incoming commands from the MCP client.
+  void frame(char const* data, size_t s) override;
+  void beginChunk() override {}
+  void endChunk() override {}
+  void beginFragmentation() override {}
+  void endFragmentation() override {}
+  void control(char const* frame, size_t s) override {}
+
+  /// Send a minimal JSON snapshot (device list + basic state, no metrics/logs).
+  void sendSnapshot();
+  /// Push an update for device at @a deviceIndex.
+  /// Only metrics that are both changed[] and subscribed are included.
+  /// No-op if nothing subscribed or nothing changed for this device.
+  void sendUpdate(size_t deviceIndex);
+  /// Push any log lines for @a deviceIndex that arrived since the last call.
+  /// No-op if the device is not subscribed for logs.
+  void sendNewLogs(size_t deviceIndex);
+
+ private:
+  void sendText(std::string const& json);
+  void handleListMetrics(std::string_view deviceName);
+  void handleSubscribe(std::string_view deviceName, std::string_view metricsJson);
+  void handleUnsubscribe(std::string_view deviceName, std::string_view metricsJson);
+  void handleSubscribeLogs(std::string_view deviceName);
+  void handleUnsubscribeLogs(std::string_view deviceName);
+  size_t findDeviceIndex(std::string_view name) const;
+
+  DriverServerContext& mContext;
+  WSDPLHandler* mHandler;
+  /// Per-device set of subscribed metric label strings.
+  /// Sized to specs->size() on sendSnapshot(); grows if new devices appear.
+  std::vector<std::unordered_set<std::string>> mSubscribedMetrics;
+  /// Per-device log cursor: value of DeviceInfo::logSeq when we last sent logs.
+  std::vector<size_t> mLastLogSeq;
+  /// Set of device indices whose logs are being streamed.
+  std::unordered_set<size_t> mLogSubscriptions;
+};
+
+} // namespace o2::framework
+#endif // O2_FRAMEWORK_STATUSWEBSOCKETHANDLER_H_
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 98cbf70370c3d..70f3c8940ef26 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -68,6 +68,7 @@
 #include "Framework/DefaultsHelpers.h"
 #include "ProcessingPoliciesHelpers.h"
 #include "DriverServerContext.h"
+#include "StatusWebSocketHandler.h"
 #include "HTTPParser.h"
 #include "DPLWebSocket.h"
 #include "ArrowSupport.h"
@@ -891,6 +892,7 @@ void processChildrenOutput(uv_loop_t* loop,
         info.history[info.historyPos] = token;
         info.historyLevel[info.historyPos] = logLevel;
         info.historyPos = (info.historyPos + 1) % info.history.size();
+        info.logSeq++;
         fmt::print("[{}:{}]: {}\n", info.pid, spec.id, token);
       }
       // We keep track of the maximum log error a
@@ -1541,6 +1543,11 @@ int runStateMachine(DataProcessorSpecs const& workflow,
   uv_async_init(loop, serverContext.asyncLogProcessing, [](uv_async_t* handle) {
     auto* context = (DriverServerContext*)handle->data;
     processChildrenOutput(context->loop, *context->driver, *context->infos, *context->specs, *context->controls);
+    for (auto* statusHandler : context->statusHandlers) {
+      for (size_t di = 0; di < context->infos->size(); ++di) {
+        statusHandler->sendNewLogs(di);
+      }
+    }
   });
 
   while (true) {

From 2b4851c08fec0e0c8d95006801beb984bc7e4869 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 31 Mar 2026 20:55:54 +0200
Subject: [PATCH 1512/1764] DPL: add MCP server for DPL

Allows debugging a DPL workflow using Claude, ChatGPT or
similar tools.
---
 .../Core/scripts/dpl-mcp-server/README.md     |  75 +++++
 .../scripts/dpl-mcp-server/dpl_mcp_server.py  | 304 ++++++++++++++++++
 .../scripts/dpl-mcp-server/pyproject.toml     |  19 ++
 3 files changed, 398 insertions(+)
 create mode 100644 Framework/Core/scripts/dpl-mcp-server/README.md
 create mode 100644 Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
 create mode 100644 Framework/Core/scripts/dpl-mcp-server/pyproject.toml

diff --git a/Framework/Core/scripts/dpl-mcp-server/README.md b/Framework/Core/scripts/dpl-mcp-server/README.md
new file mode 100644
index 0000000000000..65d2378c5d756
--- /dev/null
+++ b/Framework/Core/scripts/dpl-mcp-server/README.md
@@ -0,0 +1,75 @@
+# DPL Status MCP Server
+
+An MCP server that connects to a running DPL driver's `/status` WebSocket endpoint and exposes its device state and metrics as tools for an AI assistant (e.g. Claude).
+
+## Requirements
+
+```bash
+pip install mcp websockets
+# or install the package directly:
+pip install ./Framework/Core/scripts/dpl-mcp-server/
+```
+
+## Running
+
+The driver port defaults to `8080`. Override with `--port`, `--pid`, or `DPL_STATUS_PORT`:
+
+```bash
+python3 dpl_mcp_server.py --port 8080
+python3 dpl_mcp_server.py --pid 12345   # port = 8080 + pid % 30000
+DPL_STATUS_PORT=8080 python3 dpl_mcp_server.py
+```
+
+If installed as a package:
+
+```bash
+dpl-mcp-server --pid $(pgrep -f diamond-workflow | head -1)
+```
+
+## Claude Code integration
+
+Add to `.mcp.json` in your project (or `~/.claude.json` for global use):
+
+```json
+{
+  "mcpServers": {
+    "dpl": {
+      "command": "dpl-mcp-server",
+      "args": ["--pid", "12345"]
+    }
+  }
+}
+```
+
+Or with `claude mcp add`:
+
+```bash
+claude mcp add dpl -- dpl-mcp-server --pid 12345
+```
+
+## Available tools
+
+| Tool | Description |
+|------|-------------|
+| `list_devices` | List all devices with pid, active flag, streaming and device state |
+| `list_metrics(device)` | List numeric metrics available for a device |
+| `subscribe(device, metrics)` | Subscribe to metrics; driver will push updates when they change |
+| `unsubscribe(device, metrics)` | Stop receiving updates for specific metrics |
+| `get_updates(max_updates)` | Drain buffered update frames (default: up to 50) |
+
+## Protocol
+
+The driver sends a snapshot on connect, then pushes updates only for subscribed metrics that changed each processing cycle.  There is no polling — updates arrive in real time as the workflow runs.
+
+```
+connect  →  {"type":"snapshot","devices":[{"name","pid","active","streamingState","deviceState"},...]}
+
+client   →  {"cmd":"list_metrics","device":"producer"}
+driver   →  {"type":"metrics_list","device":"producer","metrics":["input-parts","output-bytes",...]}
+
+client   →  {"cmd":"subscribe","device":"producer","metrics":["output-bytes"]}
+driver   →  {"type":"update","device":0,"name":"producer","metrics":{"output-bytes":1048576}}
+             (pushed every cycle in which output-bytes changed)
+
+client   →  {"cmd":"unsubscribe","device":"producer","metrics":["output-bytes"]}
+```
diff --git a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
new file mode 100644
index 0000000000000..bc04acf026188
--- /dev/null
+++ b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+# Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+"""DPL status MCP server.
+
+Bridges the DPL driver /status WebSocket endpoint to MCP tools so that an
+AI assistant (e.g. Claude) can inspect and monitor a running DPL workflow.
+
+Usage
+-----
+    python3 dpl_mcp_server.py --port 8080
+    python3 dpl_mcp_server.py --pid 12345       # port derived as 8080 + pid % 30000
+    DPL_STATUS_PORT=8080 python3 dpl_mcp_server.py
+
+Wire protocol (client → driver)
+--------------------------------
+    {"cmd":"list_metrics","device":"<name>"}
+    {"cmd":"subscribe","device":"<name>","metrics":["m1","m2"]}
+    {"cmd":"unsubscribe","device":"<name>","metrics":["m1"]}
+
+Wire protocol (driver → client)
+--------------------------------
+    {"type":"snapshot","devices":[{"name","pid","active","streamingState","deviceState"},...]}
+    {"type":"update","device":<idx>,"name":"<name>","metrics":{<name:value,...>}}
+    {"type":"metrics_list","device":"<name>","metrics":["m1","m2",...]}
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from typing import Any
+
+import websockets
+from mcp.server.fastmcp import FastMCP
+
+# ---------------------------------------------------------------------------
+# Global connection state (all access from the single asyncio event loop)
+# ---------------------------------------------------------------------------
+_port: int = 8080
+_ws: Any = None
+_reader_task: asyncio.Task | None = None
+_snapshot: dict = {}
+_updates: list[dict] = []
+_logs: list[dict] = []
+_metrics_lists: dict[str, list[str]] = {}
+
+
+async def _ensure_connected() -> None:
+    """Connect (or reconnect) to the driver's /status WebSocket."""
+    global _ws, _reader_task
+
+    # Check liveness of existing connection.
+    if _ws is not None:
+        try:
+            pong = await asyncio.wait_for(_ws.ping(), timeout=2.0)
+            await pong
+            return
+        except Exception:
+            _ws = None
+            if _reader_task is not None and not _reader_task.done():
+                _reader_task.cancel()
+            _reader_task = None
+
+    url = f"ws://localhost:{_port}/status"
+    _ws = await websockets.connect(url, subprotocols=["dpl"])
+    if _reader_task is None or _reader_task.done():
+        _reader_task = asyncio.create_task(_reader())
+
+
+async def _reader() -> None:
+    """Background task: read frames from the driver and buffer them."""
+    global _ws, _snapshot, _updates, _logs, _metrics_lists
+    try:
+        async for raw in _ws:
+            try:
+                msg = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            t = msg.get("type")
+            if t == "snapshot":
+                _snapshot = msg
+                # Clear stale metric lists from a previous driver instance.
+                _metrics_lists.clear()
+            elif t == "update":
+                _updates.append(msg)
+            elif t == "log":
+                _logs.append(msg)
+            elif t == "metrics_list":
+                device = msg.get("device", "")
+                _metrics_lists[device] = msg.get("metrics", [])
+    except Exception:
+        pass
+    finally:
+        _ws = None
+
+
+async def _send(obj: dict) -> None:
+    await _ensure_connected()
+    await _ws.send(json.dumps(obj, separators=(",", ":")))
+
+
+# ---------------------------------------------------------------------------
+# MCP server definition
+# ---------------------------------------------------------------------------
+mcp = FastMCP("DPL Status")
+
+
+@mcp.tool()
+async def list_devices() -> str:
+    """List all DPL devices with their current status.
+
+    Returns each device's name, PID, active flag, streaming state, and device
+    state as reported by the driver snapshot.
+    """
+    await _ensure_connected()
+    if not _snapshot:
+        return "No snapshot received yet — the driver may still be starting."
+    devices = _snapshot.get("devices", [])
+    if not devices:
+        return "No devices in snapshot."
+    lines = []
+    for d in devices:
+        lines.append(
+            f"{d['name']}: pid={d['pid']} active={d['active']} "
+            f"streaming={d['streamingState']} state={d['deviceState']}"
+        )
+    return "\n".join(lines)
+
+
+@mcp.tool()
+async def list_metrics(device: str) -> str:
+    """List the available numeric metrics for a DPL device.
+
+    Sends a list_metrics command to the driver and waits up to 3 seconds for
+    the reply.  Only numeric metrics (int, float, uint64) are included; string
+    and enum metrics are excluded.
+
+    Args:
+        device: Device name exactly as shown by list_devices.
+    """
+    # Remove any stale cached result so we can detect the fresh reply.
+    _metrics_lists.pop(device, None)
+    await _send({"cmd": "list_metrics", "device": device})
+    for _ in range(60):          # up to 3 s
+        await asyncio.sleep(0.05)
+        if device in _metrics_lists:
+            names = _metrics_lists[device]
+            if not names:
+                return f"Device '{device}' has no numeric metrics yet."
+            return f"{len(names)} metric(s): " + ", ".join(names)
+    return f"No reply from driver for device '{device}' (timeout)."
+
+
+@mcp.tool()
+async def subscribe(device: str, metrics: list[str]) -> str:
+    """Subscribe to one or more metrics for a DPL device.
+
+    After subscribing, the driver will push update frames for the device
+    whenever any of the subscribed metrics change.  Use get_updates to drain
+    the buffer.
+
+    Args:
+        device: Device name exactly as shown by list_devices.
+        metrics: List of metric names to subscribe to (from list_metrics).
+    """
+    await _send({"cmd": "subscribe", "device": device, "metrics": metrics})
+    return f"Subscribed to {len(metrics)} metric(s) for '{device}': {', '.join(metrics)}"
+
+
+@mcp.tool()
+async def unsubscribe(device: str, metrics: list[str]) -> str:
+    """Stop receiving updates for specific metrics of a DPL device.
+
+    Args:
+        device: Device name exactly as shown by list_devices.
+        metrics: List of metric names to unsubscribe from.
+    """
+    await _send({"cmd": "unsubscribe", "device": device, "metrics": metrics})
+    return f"Unsubscribed from {len(metrics)} metric(s) for '{device}'."
+
+
+@mcp.tool()
+async def subscribe_logs(device: str) -> str:
+    """Subscribe to log output for a DPL device.
+
+    After subscribing, new log lines from the device will be buffered and
+    can be retrieved with get_logs().
+
+    Args:
+        device: Device name exactly as shown by list_devices.
+    """
+    await _send({"cmd": "subscribe_logs", "device": device})
+    return f"Subscribed to logs for '{device}'."
+
+
+@mcp.tool()
+async def unsubscribe_logs(device: str) -> str:
+    """Stop receiving log output for a DPL device.
+
+    Args:
+        device: Device name exactly as shown by list_devices.
+    """
+    await _send({"cmd": "unsubscribe_logs", "device": device})
+    return f"Unsubscribed from logs for '{device}'."
+
+
+@mcp.tool()
+async def get_logs(max_lines: int = 100) -> str:
+    """Drain and return buffered log lines received since the last call.
+
+    Args:
+        max_lines: Maximum number of log lines to return (default 100).
+    """
+    await _ensure_connected()
+    batch = _logs[:max_lines]
+    del _logs[:max_lines]
+    if not batch:
+        return "No buffered log lines."
+    lines = []
+    for entry in batch:
+        device = entry.get("device", "?")
+        level = entry.get("level", "?")
+        line = entry.get("line", "")
+        lines.append(f"[{device}][{level}] {line}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+async def get_updates(max_updates: int = 50) -> str:
+    """Drain and return buffered metric update frames received since the last call.
+
+    Each frame contains the latest values of all subscribed metrics that
+    changed during that processing cycle.  Calling this repeatedly gives a
+    time-ordered view of metric evolution.
+
+    Args:
+        max_updates: Maximum number of update frames to return (default 50).
+    """
+    await _ensure_connected()
+    batch = _updates[:max_updates]
+    del _updates[:max_updates]
+    if not batch:
+        return "No buffered updates."
+    lines = []
+    for upd in batch:
+        name = upd.get("name") or f"device[{upd.get('device', '?')}]"
+        metrics = upd.get("metrics", {})
+        if metrics:
+            parts = ", ".join(f"{k}={v}" for k, v in metrics.items())
+            lines.append(f"{name}: {parts}")
+        else:
+            lines.append(f"{name}: (empty update)")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+def main() -> None:
+    global _port
+
+    parser = argparse.ArgumentParser(
+        description="DPL status MCP server — expose DPL driver metrics via MCP tools"
+    )
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "--port",
+        type=int,
+        default=None,
+        help="TCP port of the DPL driver status WebSocket (default: 8080 or DPL_STATUS_PORT env var)",
+    )
+    group.add_argument(
+        "--pid",
+        type=int,
+        default=None,
+        help="PID of the DPL driver process; port is derived as 8080 + pid %% 30000",
+    )
+    args = parser.parse_args()
+
+    if args.pid is not None:
+        _port = 8080 + args.pid % 30000
+    elif args.port is not None:
+        _port = args.port
+    elif "DPL_STATUS_PORT" in os.environ:
+        _port = int(os.environ["DPL_STATUS_PORT"])
+    # else leave _port at the default 8080
+
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Framework/Core/scripts/dpl-mcp-server/pyproject.toml b/Framework/Core/scripts/dpl-mcp-server/pyproject.toml
new file mode 100644
index 0000000000000..f87c1b770c934
--- /dev/null
+++ b/Framework/Core/scripts/dpl-mcp-server/pyproject.toml
@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dpl-mcp-server"
+version = "0.1.0"
+description = "MCP server for monitoring DPL (Data Processing Layer) workflows"
+requires-python = ">=3.11"
+dependencies = [
+    "mcp>=1.0.0",
+    "websockets>=12.0",
+]
+
+[project.scripts]
+dpl-mcp-server = "dpl_mcp_server:main"
+
+[tool.hatch.build.targets.wheel]
+include = ["dpl_mcp_server.py"]

From 4f060ca921092cc4090c746b8ab08d3f4a72596a Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Sat, 28 Mar 2026 15:48:51 +0100
Subject: [PATCH 1513/1764] C++ standard fobids specializations of
 is_trivially_copyable

---
 .../MathUtils/include/MathUtils/Cartesian.h   | 20 ++++----------
 Common/MathUtils/test/testCartesian.cxx       |  2 +-
 .../DetectorsDCS/DataPointCompositeObject.h   | 26 ++-----------------
 .../DetectorsDCS/DataPointIdentifier.h        | 23 ++--------------
 Detectors/DCS/test/testDataPointTypes.cxx     |  4 +--
 Framework/Core/include/Framework/TypeTraits.h | 13 +++++++---
 6 files changed, 20 insertions(+), 68 deletions(-)

diff --git a/Common/MathUtils/include/MathUtils/Cartesian.h b/Common/MathUtils/include/MathUtils/Cartesian.h
index 9b917707835a6..d7e421ecd965b 100644
--- a/Common/MathUtils/include/MathUtils/Cartesian.h
+++ b/Common/MathUtils/include/MathUtils/Cartesian.h
@@ -284,25 +284,15 @@ GPUdi() SMatrix<T, D1, D1, MatRepSym<T, D1>> Similarity(const SMatrix<T, D1, D2,
 #if (!defined(GPUCA_STANDALONE) || !defined(DGPUCA_NO_ROOT)) && !defined(GPUCA_GPUCODE) && !defined(GPUCOMMONRTYPES_H_ACTIVE)
 std::ostream& operator<<(std::ostream& os, const o2::math_utils::Rotation2Df_t& t);
 std::ostream& operator<<(std::ostream& os, const o2::math_utils::Rotation2Dd_t& t);
-
-namespace std
+namespace o2::framework
 {
+template <typename T>
+struct is_forced_trivially_copyable;
 
-/// Defining Point3D explicitly as trivially copyable
-///
-/// std::is_trivially_copyable<ROOT::Math::Cartesian3D<T>> fails because the class
-/// implements a copy constructor, although it does not much more than the default copy
-/// constructor. We need Point3D to fulfill the condition in order to make types
-/// inheriting from it or using it as member can be safely detected as messageable.
-///
-/// We believe that Point3D is messageable and explicitly specialize the type trait.
-/// There is a unit test for checking trivial copy
-/// This is a workaround, we will also make suggestions to fix the cause in ROOT itself
-/// TODO: delete once it is fixed in ROOT
 template <typename T>
-struct is_trivially_copyable<o2::math_utils::Point3D<T>> : std::true_type {
+struct is_forced_trivially_copyable<o2::math_utils::Point3D<T>> : std::true_type {
 };
-} // namespace std
+} // namespace o2::framework
 #endif // Disable for GPU
 
 #endif
diff --git a/Common/MathUtils/test/testCartesian.cxx b/Common/MathUtils/test/testCartesian.cxx
index ec04c34670fc3..9f2b4c912007e 100644
--- a/Common/MathUtils/test/testCartesian.cxx
+++ b/Common/MathUtils/test/testCartesian.cxx
@@ -77,7 +77,7 @@ BOOST_AUTO_TEST_CASE(Cartesian_test)
 BOOST_AUTO_TEST_CASE(Point3D_messageable)
 {
   using ElementType = math_utils::Point3D<int>;
-  static_assert(std::is_trivially_copyable<ElementType>::value == true);
+  static_assert(o2::framework::is_forced_trivially_copyable<ElementType>::value == true);
   std::vector<ElementType> pts(10);
   auto makeElement = [](int idx) {
     return ElementType{idx, idx + 10, idx + 20};
diff --git a/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h b/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
index 6ea69f82277bf..84e15e4656cd2 100644
--- a/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
+++ b/Detectors/DCS/include/DetectorsDCS/DataPointCompositeObject.h
@@ -28,9 +28,7 @@
 #include "DetectorsDCS/DataPointValue.h"
 #include "DetectorsDCS/DeliveryType.h"
 
-namespace o2
-{
-namespace dcs
+namespace o2::dcs
 {
 /**
      * DataPointCompositeObject is a composition of a DataPointIdentifier and a
@@ -291,26 +289,6 @@ struct DataPointCompositeObject final {
 template <typename T>
 T getValue(const DataPointCompositeObject& dpcom);
 
-} // namespace dcs
-
-/// Defining DataPointCompositeObject explicitly as messageable
-namespace framework
-{
-template <typename T>
-struct is_messageable;
-template <>
-struct is_messageable<o2::dcs::DataPointCompositeObject> : std::true_type {
-};
-} // namespace framework
-
-} // namespace o2
-
-/// Defining DataPointCompositeObject explicitly as copiable
-namespace std
-{
-template <>
-struct is_trivially_copyable<o2::dcs::DataPointCompositeObject> : std::true_type {
-};
-} // namespace std
+} // namespace o2::dcs
 
 #endif /* O2_DCS_DATAPOINT_COMPOSITE_OBJECT_H */
diff --git a/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h b/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
index 8d156e04ebbca..faa12a3306d4f 100644
--- a/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
+++ b/Detectors/DCS/include/DetectorsDCS/DataPointIdentifier.h
@@ -31,9 +31,7 @@
 #include "DetectorsDCS/GenericFunctions.h"
 #include "DetectorsDCS/DeliveryType.h"
 
-namespace o2
-{
-namespace dcs
+namespace o2::dcs
 {
 /**
      * DataPointIdentifier object is responsible for storing the alias and type
@@ -208,19 +206,7 @@ struct DPIDHash {
     return dpid.hash_code();
   }
 };
-} // namespace dcs
-
-/// Defining DataPointIdentifier explicitly as messageable
-namespace framework
-{
-template <typename T>
-struct is_messageable;
-template <>
-struct is_messageable<o2::dcs::DataPointIdentifier> : std::true_type {
-};
-} // namespace framework
-
-} // namespace o2
+} // namespace o2::dcs
 
 // specailized std::hash
 namespace std
@@ -232,11 +218,6 @@ struct hash<o2::dcs::DataPointIdentifier> {
     return std::hash<uint64_t>{}(dpid.hash_code());
   }
 };
-
-template <>
-struct is_trivially_copyable<o2::dcs::DataPointIdentifier> : std::true_type {
-};
-
 } // namespace std
 
 #endif /* O2_DCS_DATAPOINT_IDENTIFIER_H */
diff --git a/Detectors/DCS/test/testDataPointTypes.cxx b/Detectors/DCS/test/testDataPointTypes.cxx
index 491ebae1f5d00..dd7511f63217c 100644
--- a/Detectors/DCS/test/testDataPointTypes.cxx
+++ b/Detectors/DCS/test/testDataPointTypes.cxx
@@ -17,8 +17,6 @@
 #include <boost/test/unit_test.hpp>
 #include "DetectorsDCS/DataPointCompositeObject.h"
 #include "Framework/TypeTraits.h"
-#include <vector>
-#include <list>
 #include <gsl/gsl>
 #include <boost/mpl/list.hpp>
 
@@ -26,7 +24,7 @@ typedef boost::mpl::list<o2::dcs::DataPointIdentifier, o2::dcs::DataPointValue,
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(DataPointCompositeObjectTypeTraits, T, testTypes)
 {
-  BOOST_CHECK_EQUAL(std::is_trivially_copyable<T>::value, true);
+  BOOST_CHECK_EQUAL(std::is_trivially_copyable_v<T>, true);
   BOOST_CHECK_EQUAL(std::is_polymorphic<T>::value, false);
   BOOST_CHECK_EQUAL(std::is_pointer<T>::value, false);
   BOOST_CHECK_EQUAL(o2::framework::is_forced_non_messageable<T>::value, false);
diff --git a/Framework/Core/include/Framework/TypeTraits.h b/Framework/Core/include/Framework/TypeTraits.h
index faa9055de3280..bb2d338f42af3 100644
--- a/Framework/Core/include/Framework/TypeTraits.h
+++ b/Framework/Core/include/Framework/TypeTraits.h
@@ -38,13 +38,18 @@ struct is_forced_non_messageable<
   typename std::enable_if<std::is_same<typename T::non_messageable, MarkAsNonMessageable>::value>::type> : public std::true_type {
 };
 
+template <typename T>
+struct is_forced_trivially_copyable : std::false_type {
+};
+
 // TODO: extend this to exclude structs with pointer data members
 // see e.g. https://stackoverflow.com/questions/32880990/how-to-check-if-class-has-pointers-in-c14
 template <typename T>
-struct is_messageable : std::conditional<std::is_trivially_copyable<T>::value && //
-                                           !std::is_polymorphic<T>::value &&     //
-                                           !std::is_pointer<T>::value &&         //
-                                           !is_forced_non_messageable<T>::value, //
+struct is_messageable : std::conditional<(std::is_trivially_copyable<T>::value ||               //
+                                          framework::is_forced_trivially_copyable<T>::value) && //
+                                           !std::is_polymorphic<T>::value &&                    //
+                                           !std::is_pointer<T>::value &&                        //
+                                           !is_forced_non_messageable<T>::value,                //
                                          std::true_type,
                                          std::false_type>::type {
 };

From 81075c53830501c0b999fee685bac5cba02169c7 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 2 Apr 2026 11:40:20 +0200
Subject: [PATCH 1514/1764] DPL: fix long standing bug with ArrayString
 serialization

This is actually the reason why tables are lost from the metadata.
---
 Framework/Core/src/VariantJSONHelpers.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/VariantJSONHelpers.cxx b/Framework/Core/src/VariantJSONHelpers.cxx
index fbb5abb331867..f3d6061020ea2 100644
--- a/Framework/Core/src/VariantJSONHelpers.cxx
+++ b/Framework/Core/src/VariantJSONHelpers.cxx
@@ -339,7 +339,7 @@ void writeVariant(std::ostream& o, Variant const& v)
     rapidjson::Writer<rapidjson::OStreamWrapper> w(osw);
 
     auto writeArray = [&](auto* values, size_t size) {
-      using T = std::remove_pointer_t<decltype(values)>;
+      using T = std::remove_cv_t<std::remove_pointer_t<decltype(values)>>;
       w.StartArray();
       for (auto i = 0u; i < size; ++i) {
         if constexpr (std::is_same_v<int, T>) {

From 5a5010afd0bd3d49e2f4d749f535d0ad74cad874 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Thu, 2 Apr 2026 14:43:20 +0200
Subject: [PATCH 1515/1764] DPL: Update serialization/deserialization test for
 string array Variant

---
 Framework/Core/test/test_Variants.cxx | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/test/test_Variants.cxx b/Framework/Core/test/test_Variants.cxx
index a364b228871da..da1f39f241e96 100644
--- a/Framework/Core/test/test_Variants.cxx
+++ b/Framework/Core/test/test_Variants.cxx
@@ -327,14 +327,16 @@ TEST_CASE("VariantJSONConversionsTest")
 
   std::vector<std::string> vstrings{"myoption_one", "myoption_two"};
   Variant vvstr(vstrings);
+  REQUIRE(vvstr.size() == 2);
   std::stringstream osal;
-  VariantJSONHelpers::write(osal, vvstr);
+  osal << vvstr;
 
   std::stringstream isal;
   isal.str(osal.str());
   auto vvstra = VariantJSONHelpers::read<VariantType::ArrayString>(isal);
 
-  for (auto i = 0U; i < vvstra.size(); ++i) {
+  REQUIRE(vvstr.size() == vvstra.size());
+  for (auto i = 0U; i < vstrings.size(); ++i) {
     REQUIRE(vstrings[i] == vvstra.get<std::string*>()[i]);
   }
 }

From ddec5e319145c71f2eba11bcc082bcfaef6e8d71 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sawenzel@gmail.com>
Date: Thu, 2 Apr 2026 16:18:51 +0200
Subject: [PATCH 1516/1764] aodMerger: Special option to merge only folders of
 the same name (#15205)

Adding a special `merge-by-name` option which asks the merger only
to merge together dataframe folders of the same name.

This is needed only in special situations where we want to enfore the output
structure of the AOD to be the same as that of a reference (data) AOD.
An example is MC-DATA embedding.
---
 Framework/AODMerger/src/aodMerger.cxx | 67 ++++++++++++++++-----------
 1 file changed, 41 insertions(+), 26 deletions(-)

diff --git a/Framework/AODMerger/src/aodMerger.cxx b/Framework/AODMerger/src/aodMerger.cxx
index 3ea45e84a39e0..11dae2dc5eac4 100644
--- a/Framework/AODMerger/src/aodMerger.cxx
+++ b/Framework/AODMerger/src/aodMerger.cxx
@@ -38,6 +38,7 @@ int main(int argc, char* argv[])
   long maxDirSize = 100000000;
   bool skipNonExistingFiles = false;
   bool skipParentFilesList = false;
+  bool mergeByName = false;
   int verbosity = 2;
   int exitCode = 0; // 0: success, >0: failure
   int compression = 505;
@@ -50,6 +51,7 @@ int main(int argc, char* argv[])
     {"skip-non-existing-files", no_argument, nullptr, 3},
     {"skip-parent-files-list", no_argument, nullptr, 4},
     {"compression", required_argument, nullptr, 5},
+    {"merge-by-name", no_argument, nullptr, 6},
     {"verbosity", required_argument, nullptr, 'v'},
     {"help", no_argument, nullptr, 'h'},
     {nullptr, 0, nullptr, 0}};
@@ -70,6 +72,8 @@ int main(int argc, char* argv[])
       skipParentFilesList = true;
     } else if (c == 5) {
       compression = atoi(optarg);
+    } else if (c == 6) {
+      mergeByName = true;
     } else if (c == 'v') {
       verbosity = atoi(optarg);
     } else if (c == 'h') {
@@ -80,6 +84,7 @@ int main(int argc, char* argv[])
       printf("  --skip-non-existing-files    Flag to allow skipping of non-existing files in the input list.\n");
       printf("  --skip-parent-files-list     Flag to allow skipping the merging of the parent files list.\n");
       printf("  --compression <root compression id>  Compression algorithm / level to use (default: %d)\n", compression);
+      printf("  --merge-by-name              Only merge TTrees from folders with the same name.\n");
       printf("  --verbosity <flag>           Verbosity of output (default: %d).\n", verbosity);
       return -1;
     } else {
@@ -94,6 +99,9 @@ int main(int argc, char* argv[])
   if (skipNonExistingFiles) {
     printf("  WARNING: Skipping non-existing files.\n");
   }
+  if (mergeByName) {
+    printf("  Merging only folders with the same name.\n");
+  }
 
   std::map<std::string, TTree*> trees;
   std::map<std::string, uint64_t> sizeCompressed;
@@ -112,6 +120,28 @@ int main(int argc, char* argv[])
   TMap* parentFiles = nullptr;
   int totalMergedDFs = 0;
   int mergedDFs = 0;
+
+  // Write all accumulated trees to outputDir, update stats, and clean up state.
+  auto flushTrees = [&](bool resetState) {
+    if (!outputDir) {
+      return;
+    }
+    for (auto const& tree : trees) {
+      outputDir->cd();
+      tree.second->Write();
+      sizeCompressed[tree.first] += tree.second->GetZipBytes();
+      sizeUncompressed[tree.first] += tree.second->GetTotBytes();
+      delete tree.second;
+    }
+    if (resetState) {
+      outputDir = nullptr;
+      trees.clear();
+      offsets.clear();
+      mergedDFs = 0;
+      currentDirSize = 0;
+    }
+  };
+
   while (in.good() && exitCode == 0) {
     in >> line;
 
@@ -182,6 +212,14 @@ int main(int argc, char* argv[])
 
       auto dfName = ((TObjString*)key1)->GetString().Data();
 
+      // If merge-by-name is active, flush accumulated trees when the folder name changes
+      if (mergeByName && outputDir && std::string(outputDir->GetName()) != std::string(dfName)) {
+        if (verbosity > 0) {
+          printf("Folder name changed: closing folder %s.\n", outputDir->GetName());
+        }
+        flushTrees(true);
+      }
+
       if (verbosity > 0) {
         printf("  Processing folder %s\n", dfName);
       }
@@ -396,21 +434,7 @@ int main(int argc, char* argv[])
         if (verbosity > 0) {
           printf("Maximum size reached: %ld. Closing folder %s.\n", currentDirSize, dfName);
         }
-        for (auto const& tree : trees) {
-          // printf("Writing %s\n", tree.first.c_str());
-          outputDir->cd();
-          tree.second->Write();
-
-          // stats
-          sizeCompressed[tree.first] += tree.second->GetZipBytes();
-          sizeUncompressed[tree.first] += tree.second->GetTotBytes();
-
-          delete tree.second;
-        }
-        outputDir = nullptr;
-        trees.clear();
-        offsets.clear();
-        mergedDFs = 0;
+        flushTrees(true);
       }
     }
     inputFile->Close();
@@ -421,16 +445,7 @@ int main(int argc, char* argv[])
     parentFiles->Write("parentFiles", TObject::kSingleKey);
   }
 
-  for (auto const& tree : trees) {
-    outputDir->cd();
-    tree.second->Write();
-
-    // stats
-    sizeCompressed[tree.first] += tree.second->GetZipBytes();
-    sizeUncompressed[tree.first] += tree.second->GetTotBytes();
-
-    delete tree.second;
-  }
+  flushTrees(false);
 
   outputFile->Write();
   outputFile->Close();
@@ -462,4 +477,4 @@ int main(int argc, char* argv[])
   printf("\n");
 
   return exitCode;
-}
+}
\ No newline at end of file

From c391bc139713ec61256b73b4f32dc25e165782f5 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 2 Apr 2026 12:31:39 +0200
Subject: [PATCH 1517/1764] DPL: speedup old split parts indexing

---
 Framework/Core/include/Framework/DataModelViews.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Framework/Core/include/Framework/DataModelViews.h b/Framework/Core/include/Framework/DataModelViews.h
index 285f5ef15154e..2a8b057525f41 100644
--- a/Framework/Core/include/Framework/DataModelViews.h
+++ b/Framework/Core/include/Framework/DataModelViews.h
@@ -100,12 +100,22 @@ struct get_pair {
       }
       size_t diff = self.pairId - count;
       if (header->splitPayloadParts > 1 && header->splitPayloadIndex == header->splitPayloadParts) {
+        // New style: one header followed by splitPayloadParts contiguous payloads.
         count += header->splitPayloadParts;
         if (self.pairId < count) {
           return {mi, mi + 1 + diff};
         }
         mi += header->splitPayloadParts + 1;
+      } else if (header->splitPayloadParts > 1 && header->splitPayloadIndex != header->splitPayloadParts) {
+        // Old style multi-part: splitPayloadParts [header, payload] pairs.
+        // We are at the first pair of the block; jump directly.
+        if (diff < header->splitPayloadParts) {
+          return {mi + 2 * diff, mi + 2 * diff + 1};
+        }
+        count += header->splitPayloadParts;
+        mi += 2 * header->splitPayloadParts;
       } else {
+        // Single [header, payload] pair (splitPayloadParts == 0).
         if (self.pairId == count) {
           return {mi, mi + 1};
         }

From 2cec68714384aa7fe0b126a336b30d1da50437df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Thu, 2 Apr 2026 20:53:43 +0200
Subject: [PATCH 1518/1764] [ALICE3] Remove TrackerACTS from CMakeLists.txt
 (#15250)

---
 Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
index 59a7f47955938..81a75e209124a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
@@ -18,7 +18,6 @@ o2_add_library(TRKReconstruction
                SOURCES src/TimeFrame.cxx
                        src/Clusterer.cxx
                        $<$<BOOL:${Acts_FOUND}>:src/ClustererACTS.cxx>
-                       $<$<BOOL:${Acts_FOUND}>:src/TrackerACTS.cxx>
                PUBLIC_LINK_LIBRARIES
                        O2::ITStracking
                        O2::GPUCommon
@@ -46,8 +45,7 @@ set(dictHeaders include/TRKReconstruction/TimeFrame.h
                 include/TRKReconstruction/Clusterer.h)
 
 if(Acts_FOUND)
-  list(APPEND dictHeaders include/TRKReconstruction/ClustererACTS.h
-                          include/TRKReconstruction/TrackerACTS.h)
+  list(APPEND dictHeaders include/TRKReconstruction/ClustererACTS.h)
 endif()
 
 o2_target_root_dictionary(TRKReconstruction

From 1d8469de4bf5231211be7a280e16f2eb3ca3fbe3 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 1 Apr 2026 21:41:46 +0200
Subject: [PATCH 1519/1764] DPL: allow generic control of signposts from the
 driver

---
 Framework/Core/src/WSDriverClient.cxx         | 66 ++++++++-----------
 .../src/FrameworkGUIDeviceInspector.cxx       | 27 +++++---
 2 files changed, 47 insertions(+), 46 deletions(-)

diff --git a/Framework/Core/src/WSDriverClient.cxx b/Framework/Core/src/WSDriverClient.cxx
index 43a407536cb59..97ea1b3dbf66a 100644
--- a/Framework/Core/src/WSDriverClient.cxx
+++ b/Framework/Core/src/WSDriverClient.cxx
@@ -188,48 +188,40 @@ void on_connect(uv_connect_t* connection, int status)
     state.tracingFlags = tracingFlags;
   });
 
-  client->observe("/log-streams", [ref = context->ref](std::string_view cmd) {
-    auto& state = ref.get<DeviceState>();
-    static constexpr int prefixSize = std::string_view{"/log-streams "}.size();
-    if (prefixSize > cmd.size()) {
-      LOG(error) << "Malformed log-streams request";
+  client->observe("/signpost:enable", [](std::string_view cmd) {
+    static constexpr int prefixSize = std::string_view{"/signpost:enable "}.size();
+    if (cmd.size() <= prefixSize) {
+      LOG(error) << "Malformed /signpost:enable request";
       return;
     }
-    cmd.remove_prefix(prefixSize);
-    int logStreams = 0;
+    std::string name(cmd.substr(prefixSize));
+    o2_walk_logs([](char const* logName, void* l, void* context) -> bool {
+      auto* log = static_cast<_o2_log_t*>(l);
+      auto* target = static_cast<std::string*>(context);
+      if (*target == logName) {
+        _o2_log_set_stacktrace(log, log->defaultStacktrace);
+        return false;
+      }
+      return true;
+    }, &name);
+  });
 
-    auto error = std::from_chars(cmd.data(), cmd.data() + cmd.size(), logStreams);
-    if (error.ec != std::errc()) {
-      LOG(error) << "Malformed log-streams mask";
+  client->observe("/signpost:disable", [](std::string_view cmd) {
+    static constexpr int prefixSize = std::string_view{"/signpost:disable "}.size();
+    if (cmd.size() <= prefixSize) {
+      LOG(error) << "Malformed /signpost:disable request";
       return;
     }
-    LOGP(info, "Logstreams flags set to {}", logStreams);
-    state.logStreams = logStreams;
-    if ((state.logStreams & DeviceState::LogStreams::DEVICE_LOG) != 0) {
-      O2_LOG_ENABLE(device);
-    } else {
-      O2_LOG_DISABLE(device);
-    }
-    if ((state.logStreams & DeviceState::LogStreams::COMPLETION_LOG) != 0) {
-      O2_LOG_ENABLE(completion);
-    } else {
-      O2_LOG_DISABLE(completion);
-    }
-    if ((state.logStreams & DeviceState::LogStreams::MONITORING_SERVICE_LOG) != 0) {
-      O2_LOG_ENABLE(monitoring_service);
-    } else {
-      O2_LOG_DISABLE(monitoring_service);
-    }
-    if ((state.logStreams & DeviceState::LogStreams::DATA_PROCESSOR_CONTEXT_LOG) != 0) {
-      O2_LOG_ENABLE(data_processor_context);
-    } else {
-      O2_LOG_DISABLE(data_processor_context);
-    }
-    if ((state.logStreams & DeviceState::LogStreams::STREAM_CONTEXT_LOG) != 0) {
-      O2_LOG_ENABLE(stream_context);
-    } else {
-      O2_LOG_DISABLE(stream_context);
-    }
+    std::string name(cmd.substr(prefixSize));
+    o2_walk_logs([](char const* logName, void* l, void* context) -> bool {
+      auto* log = static_cast<_o2_log_t*>(l);
+      auto* target = static_cast<std::string*>(context);
+      if (*target == logName) {
+        _o2_log_set_stacktrace(log, 0);
+        return false;
+      }
+      return true;
+    }, &name);
   });
 
   // Client will be filled in the line after. I can probably have a single
diff --git a/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx b/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
index aa546b8a9ab49..b29e024ec641e 100644
--- a/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDeviceInspector.cxx
@@ -400,16 +400,25 @@ void displayDeviceInspector(DeviceSpec const& spec,
     }
   }
 
-  bool logsChanged = false;
   if (ImGui::CollapsingHeader("Signposts", ImGuiTreeNodeFlags_DefaultOpen)) {
-    logsChanged = ImGui::CheckboxFlags("Device", &control.logStreams, DeviceState::LogStreams::DEVICE_LOG);
-    logsChanged = ImGui::CheckboxFlags("Completion", &control.logStreams, DeviceState::LogStreams::COMPLETION_LOG);
-    logsChanged = ImGui::CheckboxFlags("Monitoring", &control.logStreams, DeviceState::LogStreams::MONITORING_SERVICE_LOG);
-    logsChanged = ImGui::CheckboxFlags("DataProcessorContext", &control.logStreams, DeviceState::LogStreams::DATA_PROCESSOR_CONTEXT_LOG);
-    logsChanged = ImGui::CheckboxFlags("StreamContext", &control.logStreams, DeviceState::LogStreams::STREAM_CONTEXT_LOG);
-    if (logsChanged && control.controller) {
-      std::string cmd = fmt::format("/log-streams {}", control.logStreams);
-      control.controller->write(cmd.c_str(), cmd.size());
+    static const struct {
+      const char* label;
+      int bit;
+      const char* fullName;
+    } kStreams[] = {
+      {"Device", DeviceState::LogStreams::DEVICE_LOG, "ch.cern.aliceo2.device"},
+      {"Completion", DeviceState::LogStreams::COMPLETION_LOG, "ch.cern.aliceo2.completion"},
+      {"Monitoring", DeviceState::LogStreams::MONITORING_SERVICE_LOG, "ch.cern.aliceo2.monitoring_service"},
+      {"DataProcessorContext", DeviceState::LogStreams::DATA_PROCESSOR_CONTEXT_LOG, "ch.cern.aliceo2.data_processor_context"},
+      {"StreamContext", DeviceState::LogStreams::STREAM_CONTEXT_LOG, "ch.cern.aliceo2.stream_context"},
+    };
+    for (auto const& s : kStreams) {
+      if (ImGui::CheckboxFlags(s.label, &control.logStreams, s.bit) && control.controller) {
+        bool enabled = (control.logStreams & s.bit) != 0;
+        std::string cmd = enabled ? fmt::format("/signpost:enable {}", s.fullName)
+                                  : fmt::format("/signpost:disable {}", s.fullName);
+        control.controller->write(cmd.c_str(), cmd.size());
+      }
     }
   }
 

From 401d04c82258cb5270de02dc55f496627f0c9597 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 1 Apr 2026 21:41:46 +0200
Subject: [PATCH 1520/1764] DPL MCP: allow client to control signposts

---
 .../scripts/dpl-mcp-server/dpl_mcp_server.py  | 31 ++++++++
 Framework/Core/src/StatusWebSocketHandler.cxx | 71 +++++++++++++++++++
 Framework/Core/src/StatusWebSocketHandler.h   | 13 ++++
 3 files changed, 115 insertions(+)

diff --git a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
index bc04acf026188..febb1278f6045 100644
--- a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
+++ b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
@@ -237,6 +237,37 @@ async def get_logs(max_lines: int = 100) -> str:
     return "\n".join(lines)
 
 
+@mcp.tool()
+async def enable_signpost(device: str, streams: list[str]) -> str:
+    """Enable one or more signpost log streams for a DPL device.
+
+    Signpost streams produce detailed trace output visible in the device logs.
+    Use get_logs() after subscribing to see the output.
+
+    Known stream names (full form): ch.cern.aliceo2.device,
+    ch.cern.aliceo2.completion, ch.cern.aliceo2.monitoring_service,
+    ch.cern.aliceo2.data_processor_context, ch.cern.aliceo2.stream_context.
+
+    Args:
+        device: Device name as shown by list_devices, or "" for the driver.
+        streams: List of full signpost log names to enable.
+    """
+    await _send({"cmd": "enable_signpost", "device": device, "streams": streams})
+    return f"Enabled {len(streams)} signpost stream(s) for '{device or 'driver'}': {', '.join(streams)}"
+
+
+@mcp.tool()
+async def disable_signpost(device: str, streams: list[str]) -> str:
+    """Disable one or more signpost log streams for a DPL device.
+
+    Args:
+        device: Device name as shown by list_devices, or "" for the driver.
+        streams: List of full signpost log names to disable.
+    """
+    await _send({"cmd": "disable_signpost", "device": device, "streams": streams})
+    return f"Disabled {len(streams)} signpost stream(s) for '{device or 'driver'}': {', '.join(streams)}"
+
+
 @mcp.tool()
 async def get_updates(max_updates: int = 50) -> str:
     """Drain and return buffered metric update frames received since the last call.
diff --git a/Framework/Core/src/StatusWebSocketHandler.cxx b/Framework/Core/src/StatusWebSocketHandler.cxx
index db715eff6592d..cdf08c4f2f349 100644
--- a/Framework/Core/src/StatusWebSocketHandler.cxx
+++ b/Framework/Core/src/StatusWebSocketHandler.cxx
@@ -12,11 +12,15 @@
 #include "StatusWebSocketHandler.h"
 #include "DPLWebSocket.h"
 #include "DriverServerContext.h"
+#include "Framework/DeviceControl.h"
+#include "Framework/DeviceController.h"
 #include "Framework/DeviceInfo.h"
 #include "Framework/DeviceMetricsInfo.h"
 #include "Framework/DeviceSpec.h"
+#include "Framework/DeviceState.h"
 #include "Framework/DeviceStateEnums.h"
 #include "Framework/LogParsingHelpers.h"
+#include "Framework/Signpost.h"
 #include <algorithm>
 #include <cstdio>
 #include <string>
@@ -250,6 +254,10 @@ void StatusWebSocketHandler::frame(char const* data, size_t s)
     handleSubscribeLogs(deviceName);
   } else if (cmd == "unsubscribe_logs") {
     handleUnsubscribeLogs(deviceName);
+  } else if (cmd == "enable_signpost") {
+    handleEnableSignpost(deviceName, extractArrayField(msg, "streams"));
+  } else if (cmd == "disable_signpost") {
+    handleDisableSignpost(deviceName, extractArrayField(msg, "streams"));
   }
 }
 
@@ -433,6 +441,69 @@ size_t StatusWebSocketHandler::findDeviceIndex(std::string_view name) const
   return SIZE_MAX;
 }
 
+void StatusWebSocketHandler::handleEnableSignpost(std::string_view deviceName, std::string_view streamsArr)
+{
+  if (streamsArr.empty()) {
+    return;
+  }
+  if (deviceName.empty()) {
+    // Driver process — toggle in-process via o2_walk_logs.
+    forEachStringInArray(streamsArr, [](std::string_view streamName) {
+      std::string target(streamName);
+      o2_walk_logs([](char const* name, void* l, void* context) -> bool {
+        auto* log = static_cast<_o2_log_t*>(l);
+        if (static_cast<std::string*>(context)->compare(name) == 0) {
+          _o2_log_set_stacktrace(log, log->defaultStacktrace);
+          return false;
+        }
+        return true;
+      }, &target);
+    });
+  } else {
+    size_t di = findDeviceIndex(deviceName);
+    if (di == SIZE_MAX || di >= mContext.controls->size() || !(*mContext.controls)[di].controller) {
+      return;
+    }
+    auto* controller = (*mContext.controls)[di].controller;
+    forEachStringInArray(streamsArr, [controller](std::string_view name) {
+      std::string cmd = "/signpost:enable ";
+      cmd += name;
+      controller->write(cmd.c_str(), cmd.size());
+    });
+  }
+}
+
+void StatusWebSocketHandler::handleDisableSignpost(std::string_view deviceName, std::string_view streamsArr)
+{
+  if (streamsArr.empty()) {
+    return;
+  }
+  if (deviceName.empty()) {
+    forEachStringInArray(streamsArr, [](std::string_view streamName) {
+      std::string target(streamName);
+      o2_walk_logs([](char const* name, void* l, void* context) -> bool {
+        auto* log = static_cast<_o2_log_t*>(l);
+        if (static_cast<std::string*>(context)->compare(name) == 0) {
+          _o2_log_set_stacktrace(log, 0);
+          return false;
+        }
+        return true;
+      }, &target);
+    });
+  } else {
+    size_t di = findDeviceIndex(deviceName);
+    if (di == SIZE_MAX || di >= mContext.controls->size() || !(*mContext.controls)[di].controller) {
+      return;
+    }
+    auto* controller = (*mContext.controls)[di].controller;
+    forEachStringInArray(streamsArr, [controller](std::string_view name) {
+      std::string cmd = "/signpost:disable ";
+      cmd += name;
+      controller->write(cmd.c_str(), cmd.size());
+    });
+  }
+}
+
 void StatusWebSocketHandler::handleSubscribeLogs(std::string_view deviceName)
 {
   size_t di = findDeviceIndex(deviceName);
diff --git a/Framework/Core/src/StatusWebSocketHandler.h b/Framework/Core/src/StatusWebSocketHandler.h
index 86a460e289440..3b040d68e26f0 100644
--- a/Framework/Core/src/StatusWebSocketHandler.h
+++ b/Framework/Core/src/StatusWebSocketHandler.h
@@ -41,6 +41,17 @@ struct WSDPLHandler;
 ///   {"cmd":"unsubscribe_logs","device":"<name>"}
 ///     → driver stops pushing log lines for the device
 ///
+///   {"cmd":"enable_signpost","device":"<name>","streams":["device","completion",...]}
+///     → enable the named signpost log streams for a device (or the driver if device=="")
+///     → known streams: "device","completion","monitoring_service","data_processor_context","stream_context"
+///
+///   {"cmd":"disable_signpost","device":"<name>","streams":["device","completion",...]}
+///     → disable the named signpost log streams for a device
+///
+///   {"cmd":"list_signposts"}
+///     → driver replies with {"type":"signposts_list","streams":["device","completion",...]}
+///     → lists the known stream names
+///
 /// Protocol (driver → client):
 ///   {"type":"snapshot","devices":[{"name","pid","active","streamingState","deviceState"},...]}
 ///     → sent once on connect; contains no metrics or logs
@@ -84,6 +95,8 @@ struct StatusWebSocketHandler : public WebSocketHandler {
   void handleUnsubscribe(std::string_view deviceName, std::string_view metricsJson);
   void handleSubscribeLogs(std::string_view deviceName);
   void handleUnsubscribeLogs(std::string_view deviceName);
+  void handleEnableSignpost(std::string_view deviceName, std::string_view streamsArr);
+  void handleDisableSignpost(std::string_view deviceName, std::string_view streamsArr);
   size_t findDeviceIndex(std::string_view name) const;
 
   DriverServerContext& mContext;

From 12611f702b492d69897f8c24b85e1b26a0a336c1 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 3 Apr 2026 12:12:10 +0200
Subject: [PATCH 1521/1764] DPL MCP: add ability to start a stopped topology

---
 Framework/Core/src/StatusWebSocketHandler.cxx | 13 +++++++++++++
 Framework/Core/src/StatusWebSocketHandler.h   |  1 +
 2 files changed, 14 insertions(+)

diff --git a/Framework/Core/src/StatusWebSocketHandler.cxx b/Framework/Core/src/StatusWebSocketHandler.cxx
index cdf08c4f2f349..065a6f4b05b4a 100644
--- a/Framework/Core/src/StatusWebSocketHandler.cxx
+++ b/Framework/Core/src/StatusWebSocketHandler.cxx
@@ -13,6 +13,8 @@
 #include "DPLWebSocket.h"
 #include "DriverServerContext.h"
 #include "Framework/DeviceControl.h"
+#include <csignal>
+#include <unistd.h>
 #include "Framework/DeviceController.h"
 #include "Framework/DeviceInfo.h"
 #include "Framework/DeviceMetricsInfo.h"
@@ -254,6 +256,8 @@ void StatusWebSocketHandler::frame(char const* data, size_t s)
     handleSubscribeLogs(deviceName);
   } else if (cmd == "unsubscribe_logs") {
     handleUnsubscribeLogs(deviceName);
+  } else if (cmd == "start_devices") {
+    handleStartDevices();
   } else if (cmd == "enable_signpost") {
     handleEnableSignpost(deviceName, extractArrayField(msg, "streams"));
   } else if (cmd == "disable_signpost") {
@@ -441,6 +445,15 @@ size_t StatusWebSocketHandler::findDeviceIndex(std::string_view name) const
   return SIZE_MAX;
 }
 
+void StatusWebSocketHandler::handleStartDevices()
+{
+  for (auto const& info : *mContext.infos) {
+    if (info.active) {
+      kill(info.pid, SIGCONT);
+    }
+  }
+}
+
 void StatusWebSocketHandler::handleEnableSignpost(std::string_view deviceName, std::string_view streamsArr)
 {
   if (streamsArr.empty()) {
diff --git a/Framework/Core/src/StatusWebSocketHandler.h b/Framework/Core/src/StatusWebSocketHandler.h
index 3b040d68e26f0..fb2f0beebbec2 100644
--- a/Framework/Core/src/StatusWebSocketHandler.h
+++ b/Framework/Core/src/StatusWebSocketHandler.h
@@ -95,6 +95,7 @@ struct StatusWebSocketHandler : public WebSocketHandler {
   void handleUnsubscribe(std::string_view deviceName, std::string_view metricsJson);
   void handleSubscribeLogs(std::string_view deviceName);
   void handleUnsubscribeLogs(std::string_view deviceName);
+  void handleStartDevices();
   void handleEnableSignpost(std::string_view deviceName, std::string_view streamsArr);
   void handleDisableSignpost(std::string_view deviceName, std::string_view streamsArr);
   size_t findDeviceIndex(std::string_view name) const;

From 37e43e384b375dde431c1a4f85bee992af94b83b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 3 Apr 2026 12:12:10 +0200
Subject: [PATCH 1522/1764] DPL MCP: add tool to resume a stopped topology

---
 .../Core/scripts/dpl-mcp-server/dpl_mcp_server.py      | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
index febb1278f6045..3900a646632a1 100644
--- a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
+++ b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
@@ -237,6 +237,16 @@ async def get_logs(max_lines: int = 100) -> str:
     return "\n".join(lines)
 
 
+@mcp.tool()
+async def start_devices() -> str:
+    """Resume all stopped DPL devices (send SIGCONT).
+
+    Use this when the workflow was started with -s (all devices paused).
+    """
+    await _send({"cmd": "start_devices"})
+    return "Sent SIGCONT to all active devices."
+
+
 @mcp.tool()
 async def enable_signpost(device: str, streams: list[str]) -> str:
     """Enable one or more signpost log streams for a DPL device.

From 74b32651eba638fb3beb594c6be6b9657a0cf41c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 3 Apr 2026 18:27:14 +0200
Subject: [PATCH 1523/1764] DPL: add formatters for ConfigParamSpec

---
 Framework/Core/COOKBOOK.md                   |  40 +++
 Framework/Core/scripts/lldb_o2_formatters.py | 296 +++++++++++++++++++
 2 files changed, 336 insertions(+)
 create mode 100644 Framework/Core/scripts/lldb_o2_formatters.py

diff --git a/Framework/Core/COOKBOOK.md b/Framework/Core/COOKBOOK.md
index c327651ae53ca..a99890bdcfa85 100644
--- a/Framework/Core/COOKBOOK.md
+++ b/Framework/Core/COOKBOOK.md
@@ -549,3 +549,43 @@ Streams can be explicitly enabled or disabled in code using the `O2_SIGNPOST_ENA
 If a process is already running and you wish to enable one or more of its signposts logs, you can do so using the `o2-log` utility, passing the address of the log to enable and the PID of the running process. E.g. `o2-log -p <PID> -a <hook address of the signpost>`.
 
 Finally, on macOS, you can also use Instruments to visualise your Signpost, just like any other macOS application. In order to do so you need to enable the "Signpost" instrument, making sure you add `ch.cern.aliceo2.completion` to the list of loggers to watch.
+
+## Improving lldb experience
+
+You can make lldb understand some of the O2 types by having the following
+in your `~/.lldbinit` (or `$PWD/.lldbinit`):
+
+```lldb
+command script import Framework/Core/scripts/lldb_o2_formatters.py
+```
+
+
+Before:
+
+```gdb
+(o2::framework::ConfigParamSpec &) 0x0000000774871e20: {
+  name = "timeframes-rate-limit-ipcid"
+  type = String
+  defaultValue = {
+    mStore = (__data = "\xa0\xae\x80t\a")
+    mType = String
+    mSize = 1
+  }
+  help = (str = "Suffix for IPC channel for metric-feedback, -1 = disable")
+  kind = kGeneric
+}
+```
+
+After:
+
+```gdb
+(o2::framework::ConfigParamSpec &) 0x00000007cac75e20: {
+  name = "timeframes-rate-limit-ipcid"
+  type = String
+  defaultValue = {
+    value = 0x00000007cac0eea0 "-1"
+  }
+  help = (str = "Suffix for IPC channel for metric-feedback, -1 = disable")
+  kind = kGeneric
+}
+```
diff --git a/Framework/Core/scripts/lldb_o2_formatters.py b/Framework/Core/scripts/lldb_o2_formatters.py
new file mode 100644
index 0000000000000..84bc7cda8dac3
--- /dev/null
+++ b/Framework/Core/scripts/lldb_o2_formatters.py
@@ -0,0 +1,296 @@
+# Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+#
+# lldb data formatters for o2::framework types.
+#
+# Usage: add to ~/.lldbinit or a project .lldbinit:
+#   command script import /path/to/O2/Framework/Core/scripts/lldb_o2_formatters.py
+
+import lldb
+
+# o2::framework::VariantType enum values (must match Variant.h)
+_VARIANT_TYPE = {
+    0:  'Int',
+    1:  'Int64',
+    2:  'Float',
+    3:  'Double',
+    4:  'String',
+    5:  'Bool',
+    6:  'ArrayInt',
+    7:  'ArrayFloat',
+    8:  'ArrayDouble',
+    9:  'ArrayBool',
+    10: 'ArrayString',
+    11: 'Array2DInt',
+    12: 'Array2DFloat',
+    13: 'Array2DDouble',
+    14: 'LabeledArrayInt',
+    15: 'LabeledArrayFloat',
+    16: 'LabeledArrayDouble',
+    17: 'UInt8',
+    18: 'UInt16',
+    19: 'UInt32',
+    20: 'UInt64',
+    21: 'Int8',
+    22: 'Int16',
+    23: 'LabeledArrayString',
+    24: 'Empty',
+    25: 'Dict',
+    26: 'Unknown',
+}
+
+# Map VariantType value → (C type name for FindFirstType, is_pointer_to_value)
+# is_pointer_to_value=True means mStore holds a T* pointing to heap data (arrays)
+_SIMPLE_TYPES = {
+    0:  ('int',           False),
+    1:  ('long long',     False),
+    2:  ('float',         False),
+    3:  ('double',        False),
+    5:  ('bool',          False),
+    17: ('unsigned char', False),
+    18: ('unsigned short',False),
+    19: ('unsigned int',  False),
+    20: ('unsigned long long', False),
+    21: ('signed char',   False),
+    22: ('short',         False),
+}
+
+_ARRAY_ELEM_TYPES = {
+    6:  'int',
+    7:  'float',
+    8:  'double',
+    9:  'bool',
+}
+
+MAX_ARRAY_DISPLAY = 16
+
+
+import struct as _struct
+
+
+def _read_pointer(process, addr):
+    err = lldb.SBError()
+    ptr_size = process.GetAddressByteSize()
+    data = process.ReadMemory(addr, ptr_size, err)
+    if err.Fail() or not data:
+        return None
+    fmt = '<Q' if ptr_size == 8 else '<I'
+    return _struct.unpack(fmt, data)[0]
+
+
+def _read_libcxx_string(process, addr):
+    """Read a libc++ std::string directly from memory (no type lookup needed).
+
+    libc++ std::string on 64-bit little-endian (macOS x86_64 / arm64):
+      sizeof = 24 bytes, union of:
+        __short: byte[0] = (size<<1)|0  (short flag),  bytes[1..22] = inline data
+        __long:  byte[0] low bit = 1,  bytes[8..15] = size,  bytes[16..23] = data ptr
+    """
+    err = lldb.SBError()
+    raw = process.ReadMemory(addr, 24, err)
+    if err.Fail() or not raw:
+        return '"<read error>"'
+    b = raw if isinstance(raw[0], int) else bytes(ord(c) for c in raw)
+    if (b[0] & 1) == 0:          # short form
+        size = b[0] >> 1
+        text = b[1:1 + size].decode('utf-8', errors='replace')
+    else:                          # long form
+        size     = _struct.unpack_from('<Q', b, 8)[0]
+        data_ptr = _struct.unpack_from('<Q', b, 16)[0]
+        if data_ptr == 0:
+            return '"<null>"'
+        heap = process.ReadMemory(data_ptr, min(size, 512), err)
+        if err.Fail() or not heap:
+            return '"<read error>"'
+        h = heap if isinstance(heap[0], int) else bytes(ord(c) for c in heap)
+        text = h[:size].decode('utf-8', errors='replace')
+        if size > 512:
+            text += '...'
+    return f'"{text}"'
+
+
+def variant_summary(valobj, _internal_dict):
+    # Use GetNonSyntheticValue() so we see the real struct members even when
+    # the synthetic provider has replaced the children with decoded values.
+    raw = valobj.GetNonSyntheticValue()
+    mType_val = raw.GetChildMemberWithName('mType')
+    if not mType_val.IsValid():
+        return '<invalid Variant>'
+
+    mType = mType_val.GetValueAsUnsigned(26)  # default Unknown
+    mSize = raw.GetChildMemberWithName('mSize').GetValueAsUnsigned(1)
+    mStore = raw.GetChildMemberWithName('mStore')
+    store_addr = mStore.GetLoadAddress()
+
+    type_name = _VARIANT_TYPE.get(mType, f'<type={mType}>')
+    target = valobj.GetTarget()
+    process = valobj.GetProcess()
+
+    # --- simple scalar types ---
+    if mType in _SIMPLE_TYPES:
+        ctype, _ = _SIMPLE_TYPES[mType]
+        t = target.FindFirstType(ctype)
+        if t.IsValid():
+            v = valobj.CreateValueFromAddress('v', store_addr, t)
+            return f'{type_name}({v.GetValue()})'
+        return f'{type_name}(?)'
+
+    # --- String (const char* stored in mStore) ---
+    if mType == 4:
+        ptr = _read_pointer(process, store_addr)
+        if ptr and ptr != 0:
+            s = _read_cstring(process, ptr)
+            return f'String("{s}")'
+        return 'String(null)'
+
+    # --- C-style numeric arrays (int*, float*, double*, bool*) ---
+    if mType in _ARRAY_ELEM_TYPES:
+        elem_type_name = _ARRAY_ELEM_TYPES[mType]
+        ptr = _read_pointer(process, store_addr)
+        if not ptr or ptr == 0:
+            return f'{type_name}(null)'
+        elem_t = target.FindFirstType(elem_type_name)
+        if not elem_t.IsValid():
+            return f'{type_name}(? x {mSize})'
+        count = min(mSize, MAX_ARRAY_DISPLAY)
+        items = []
+        for i in range(count):
+            v = valobj.CreateValueFromAddress(f'e{i}', ptr + i * elem_t.GetByteSize(), elem_t)
+            items.append(v.GetValue() or '?')
+        result = f'{type_name}([{", ".join(items)}]'
+        if mSize > MAX_ARRAY_DISPLAY:
+            result += f', ... ({mSize} total)'
+        result += ')'
+        return result
+
+    # --- ArrayString: std::vector<std::string> stored via placement new in mStore ---
+    if mType == 10:
+        # libc++ std::vector layout: __begin_, __end_, __end_cap_ (all pointers)
+        # libc++ std::string is always 24 bytes on 64-bit (SSO layout)
+        STR_SIZE = 24
+        ptr_size = process.GetAddressByteSize()
+        begin_ptr = _read_pointer(process, store_addr)
+        end_ptr   = _read_pointer(process, store_addr + ptr_size)
+        if begin_ptr is None or end_ptr is None:
+            return 'ArrayString(?)'
+
+        count = (end_ptr - begin_ptr) // STR_SIZE if end_ptr >= begin_ptr else 0
+        items = []
+        for i in range(min(count, MAX_ARRAY_DISPLAY)):
+            items.append(_read_libcxx_string(process, begin_ptr + i * STR_SIZE))
+        result = f'ArrayString([{", ".join(items)}]'
+        if count > MAX_ARRAY_DISPLAY:
+            result += f', ... ({count} total)'
+        result += ')'
+        return result
+
+    return f'{type_name}(mSize={mSize})'
+
+
+class VariantSyntheticProvider:
+    """Synthetic children for o2::framework::Variant — exposes decoded value as child."""
+
+    def __init__(self, valobj, _internal_dict):
+        self.valobj = valobj
+        self.children = []
+
+    def num_children(self):
+        return len(self.children)
+
+    def get_child_index(self, name):
+        for i, (n, _) in enumerate(self.children):
+            if n == name:
+                return i
+        return -1
+
+    def get_child_at_index(self, index):
+        if 0 <= index < len(self.children):
+            return self.children[index][1]
+        return None
+
+    def update(self):
+        self.children = []
+        # Use GetNonSyntheticValue() to read the real struct members.
+        raw = self.valobj.GetNonSyntheticValue()
+        mType = raw.GetChildMemberWithName('mType').GetValueAsUnsigned(26)
+        mSize = raw.GetChildMemberWithName('mSize').GetValueAsUnsigned(1)
+        mStore = raw.GetChildMemberWithName('mStore')
+        store_addr = mStore.GetLoadAddress()
+        target = self.valobj.GetTarget()
+        process = self.valobj.GetProcess()
+
+        if mType in _SIMPLE_TYPES:
+            ctype, _ = _SIMPLE_TYPES[mType]
+            t = target.FindFirstType(ctype)
+            if t.IsValid():
+                v = self.valobj.CreateValueFromAddress('value', store_addr, t)
+                self.children.append(('value', v))
+
+        elif mType == 4:  # String
+            ptr = _read_pointer(process, store_addr)
+            if ptr and ptr != 0:
+                char_t = target.FindFirstType('char').GetPointerType()
+                v = self.valobj.CreateValueFromAddress('value', store_addr, char_t)
+                self.children.append(('value', v))
+
+        elif mType in _ARRAY_ELEM_TYPES:
+            elem_type_name = _ARRAY_ELEM_TYPES[mType]
+            ptr = _read_pointer(process, store_addr)
+            if ptr and ptr != 0:
+                elem_t = target.FindFirstType(elem_type_name)
+                if elem_t.IsValid():
+                    for i in range(min(mSize, MAX_ARRAY_DISPLAY)):
+                        v = self.valobj.CreateValueFromAddress(f'[{i}]', ptr + i * elem_t.GetByteSize(), elem_t)
+                        self.children.append((f'[{i}]', v))
+
+        elif mType == 10:  # ArrayString
+            # std::vector<std::string> via placement new; std::string = 24 bytes (libc++ 64-bit)
+            STR_SIZE = 24
+            ptr_size = process.GetAddressByteSize()
+            begin_ptr = _read_pointer(process, store_addr)
+            end_ptr   = _read_pointer(process, store_addr + ptr_size)
+            char_t = target.FindFirstType('char')
+            if begin_ptr is not None and end_ptr is not None and end_ptr >= begin_ptr and char_t.IsValid():
+                count = (end_ptr - begin_ptr) // STR_SIZE
+                err = lldb.SBError()
+                for i in range(min(count, MAX_ARRAY_DISPLAY)):
+                    str_addr = begin_ptr + i * STR_SIZE
+                    raw = process.ReadMemory(str_addr, STR_SIZE, err)
+                    if err.Fail() or not raw:
+                        continue
+                    b = raw if isinstance(raw[0], int) else bytes(ord(c) for c in raw)
+                    if (b[0] & 1) == 0:  # short form: data inline at offset 1
+                        data_addr = str_addr + 1
+                        sz = max(b[0] >> 1, 1)
+                    else:               # long form: data pointer at offset 16
+                        data_addr = _struct.unpack_from('<Q', b, 16)[0]
+                        sz = max(_struct.unpack_from('<Q', b, 8)[0], 1)
+                    # Expose as char[sz] so lldb renders it as a string literal
+                    arr_t = char_t.GetArrayType(min(sz + 1, 256))
+                    sv = self.valobj.CreateValueFromAddress(f'[{i}]', data_addr, arr_t)
+                    self.children.append((f'[{i}]', sv))
+
+        return False  # no pruning needed
+
+    def has_children(self):
+        return len(self.children) > 0
+
+
+def __lldb_init_module(debugger, _internal_dict):
+    debugger.HandleCommand(
+        'type summary add -x "^o2::framework::Variant$" '
+        '--python-function lldb_o2_formatters.variant_summary'
+    )
+    debugger.HandleCommand(
+        'type synthetic add -x "^o2::framework::Variant$" '
+        '--python-class lldb_o2_formatters.VariantSyntheticProvider'
+    )
+    print('o2::framework::Variant formatters loaded.')

From bccbaff4e0d76463ca798aa7bc612d2f2f214ebb Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 5 Apr 2026 21:31:13 +0200
Subject: [PATCH 1524/1764] DPL: add helper get_next_pair

This will simplify and speed up iterations over multipart messages.
---
 Framework/Core/CMakeLists.txt                 |   1 +
 .../Core/include/Framework/DataModelViews.h   |  37 ++++
 Framework/Core/test/test_DataModelViews.cxx   | 199 ++++++++++++++++++
 3 files changed, 237 insertions(+)
 create mode 100644 Framework/Core/test/test_DataModelViews.cxx

diff --git a/Framework/Core/CMakeLists.txt b/Framework/Core/CMakeLists.txt
index 0e67e1c0cc623..45af3ad6c59cc 100644
--- a/Framework/Core/CMakeLists.txt
+++ b/Framework/Core/CMakeLists.txt
@@ -238,6 +238,7 @@ add_executable(o2-test-framework-core
               test/test_IndexBuilder.cxx
               test/test_InputRecord.cxx
               test/test_InputRecordWalker.cxx
+              test/test_DataModelViews.cxx
               test/test_InputSpan.cxx
               test/test_InputSpec.cxx
               test/test_LogParsingHelpers.cxx
diff --git a/Framework/Core/include/Framework/DataModelViews.h b/Framework/Core/include/Framework/DataModelViews.h
index 2a8b057525f41..53d6e6615b96e 100644
--- a/Framework/Core/include/Framework/DataModelViews.h
+++ b/Framework/Core/include/Framework/DataModelViews.h
@@ -127,6 +127,43 @@ struct get_pair {
   }
 };
 
+// Advance from a DataRefIndices to the next one in O(1), reading only the
+// current header.  Intended for use in iterators so that ++ is O(1) rather
+// than the O(n) while-loop that get_pair requires.
+//
+// New-style block  (splitPayloadIndex == splitPayloadParts > 1):
+//   layout: [header, payload_0, payload_1, ..., payload_{N-1}]
+//   advance within block while payloads remain, then jump to the next block.
+//
+// Old-style block  (splitPayloadIndex != splitPayloadParts, splitPayloadParts > 1)
+// or single pair   (splitPayloadParts == 0):
+//   layout: [header, payload]  – always advance by two messages.
+struct get_next_pair {
+  DataRefIndices current;
+  template <typename R>
+    requires std::ranges::random_access_range<R> && std::ranges::sized_range<R>
+  friend DataRefIndices operator|(R&& r, get_next_pair self)
+  {
+    size_t hIdx = self.current.headerIdx;
+    auto* header = o2::header::get<o2::header::DataHeader*>(r[hIdx]->GetData());
+    if (!header) {
+      throw std::runtime_error("Not a DataHeader");
+    }
+    if (header->splitPayloadParts > 1 && header->splitPayloadIndex == header->splitPayloadParts) {
+      // New-style block: one header followed by splitPayloadParts contiguous payloads.
+      if (self.current.payloadIdx < hIdx + header->splitPayloadParts) {
+        // More sub-payloads remain in this block.
+        return {hIdx, self.current.payloadIdx + 1};
+      }
+      // Last sub-payload consumed; move to the first pair of the next block.
+      size_t nextHIdx = hIdx + header->splitPayloadParts + 1;
+      return {nextHIdx, nextHIdx + 1};
+    }
+    // Old-style [header, payload] pairs or a single pair: advance by two messages.
+    return {hIdx + 2, hIdx + 3};
+  }
+};
+
 struct get_dataref_indices {
   size_t part;
   size_t subPart;
diff --git a/Framework/Core/test/test_DataModelViews.cxx b/Framework/Core/test/test_DataModelViews.cxx
new file mode 100644
index 0000000000000..37d163e9e41c6
--- /dev/null
+++ b/Framework/Core/test/test_DataModelViews.cxx
@@ -0,0 +1,199 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Framework/DataModelViews.h"
+#include "Framework/DataProcessingHeader.h"
+#include "Headers/DataHeader.h"
+#include "Headers/Stack.h"
+#include <fairmq/TransportFactory.h>
+#include <cstring>
+#include <catch_amalgamated.hpp>
+
+using namespace o2::framework;
+using DataHeader = o2::header::DataHeader;
+using Stack = o2::header::Stack;
+
+namespace
+{
+// Build a header message containing a DataHeader with the given split-payload fields.
+fair::mq::MessagePtr makeHeader(fair::mq::TransportFactory& transport,
+                                uint32_t splitPayloadParts, uint32_t splitPayloadIndex)
+{
+  DataHeader dh;
+  dh.dataDescription = "TEST";
+  dh.dataOrigin = "TST";
+  dh.subSpecification = 0;
+  dh.splitPayloadParts = splitPayloadParts;
+  dh.splitPayloadIndex = splitPayloadIndex;
+  DataProcessingHeader dph{0, 1};
+  Stack stack{dh, dph};
+  auto msg = transport.CreateMessage(stack.size());
+  memcpy(msg->GetData(), stack.data(), stack.size());
+  return msg;
+}
+
+fair::mq::MessagePtr makePayload(fair::mq::TransportFactory& transport)
+{
+  return transport.CreateMessage(4);
+}
+} // namespace
+
+// ---------------------------------------------------------------------------
+// Single [header, payload] pair (splitPayloadParts == 0)
+// ---------------------------------------------------------------------------
+TEST_CASE("SinglePair")
+{
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+
+  std::vector<fair::mq::MessagePtr> msgs;
+  msgs.emplace_back(makeHeader(*transport, 0, 0));
+  msgs.emplace_back(makePayload(*transport));
+
+  REQUIRE((msgs | count_parts{}) == 1);
+  REQUIRE((msgs | count_payloads{}) == 1);
+  REQUIRE((msgs | get_num_payloads{0}) == 1);
+
+  auto idx = msgs | get_pair{0};
+  REQUIRE(idx.headerIdx == 0);
+  REQUIRE(idx.payloadIdx == 1);
+
+  // Advancing past the only pair goes out of range.
+  auto next = msgs | get_next_pair{idx};
+  REQUIRE(next.headerIdx >= msgs.size());
+}
+
+// ---------------------------------------------------------------------------
+// Old-style multipart: N [header, payload] pairs, each with splitPayloadParts=N
+// and splitPayloadIndex running 0..N-1 (0-indexed).
+// The new-style sentinel is splitPayloadIndex == splitPayloadParts, which is
+// never true for old-style (max index is N-1 < N).
+// Layout: [h0,p0, h1,p1, h2,p2]
+// count_parts returns N because each [h,p] pair is a separate logical part.
+// ---------------------------------------------------------------------------
+TEST_CASE("OldStyleMultipart")
+{
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  constexpr uint32_t N = 3;
+
+  std::vector<fair::mq::MessagePtr> msgs;
+  for (uint32_t i = 0; i < N; ++i) {
+    msgs.emplace_back(makeHeader(*transport, N, i)); // 0-indexed
+    msgs.emplace_back(makePayload(*transport));
+  }
+
+  REQUIRE((msgs | count_parts{}) == N);    // N separate logical parts
+  REQUIRE((msgs | count_payloads{}) == N); // one payload each
+  for (uint32_t i = 0; i < N; ++i) {
+    REQUIRE((msgs | get_num_payloads{i}) == 1);
+  }
+
+  // get_pair reaches each sub-part directly.
+  for (uint32_t i = 0; i < N; ++i) {
+    auto idx = msgs | get_pair{i};
+    REQUIRE(idx.headerIdx == 2 * i);
+    REQUIRE(idx.payloadIdx == 2 * i + 1);
+  }
+
+  // get_next_pair advances sequentially through all pairs.
+  DataRefIndices idx{0, 1};
+  for (uint32_t i = 1; i < N; ++i) {
+    idx = msgs | get_next_pair{idx};
+    REQUIRE(idx.headerIdx == 2 * i);
+    REQUIRE(idx.payloadIdx == 2 * i + 1);
+  }
+  // One more step goes out of range.
+  idx = msgs | get_next_pair{idx};
+  REQUIRE(idx.headerIdx >= msgs.size());
+}
+
+// ---------------------------------------------------------------------------
+// New-style multipart: one header followed by N contiguous payloads.
+// splitPayloadParts == splitPayloadIndex == N  (the sentinel for new style).
+// Layout: [h, p0, p1, p2]
+// ---------------------------------------------------------------------------
+TEST_CASE("NewStyleMultiPayload")
+{
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+  constexpr uint32_t N = 3;
+
+  std::vector<fair::mq::MessagePtr> msgs;
+  msgs.emplace_back(makeHeader(*transport, N, N));
+  for (uint32_t i = 0; i < N; ++i) {
+    msgs.emplace_back(makePayload(*transport));
+  }
+
+  REQUIRE((msgs | count_parts{}) == 1);
+  REQUIRE((msgs | count_payloads{}) == N);
+  REQUIRE((msgs | get_num_payloads{0}) == N); // all payloads belong to part 0
+
+  // get_pair returns the same header for every sub-part, advancing payloadIdx.
+  for (uint32_t i = 0; i < N; ++i) {
+    auto idx = msgs | get_pair{i};
+    REQUIRE(idx.headerIdx == 0);
+    REQUIRE(idx.payloadIdx == 1 + i);
+  }
+
+  // get_next_pair advances payloadIdx within the block, then moves to next block.
+  DataRefIndices idx{0, 1};
+  for (uint32_t i = 1; i < N; ++i) {
+    idx = msgs | get_next_pair{idx};
+    REQUIRE(idx.headerIdx == 0);
+    REQUIRE(idx.payloadIdx == 1 + i);
+  }
+  // One more step exits the block.
+  idx = msgs | get_next_pair{idx};
+  REQUIRE(idx.headerIdx >= msgs.size());
+}
+
+// ---------------------------------------------------------------------------
+// Mixed message set: two routes, one single-pair and one new-style block.
+// Layout: [h0, p0,  h1, p1_0, p1_1]
+// ---------------------------------------------------------------------------
+TEST_CASE("MixedLayout")
+{
+  auto transport = fair::mq::TransportFactory::CreateTransportFactory("zeromq");
+
+  std::vector<fair::mq::MessagePtr> msgs;
+  // Route 0: single pair
+  msgs.emplace_back(makeHeader(*transport, 0, 0));
+  msgs.emplace_back(makePayload(*transport));
+  // Route 1: new-style 2-payload block
+  msgs.emplace_back(makeHeader(*transport, 2, 2));
+  msgs.emplace_back(makePayload(*transport));
+  msgs.emplace_back(makePayload(*transport));
+
+  REQUIRE((msgs | count_parts{}) == 2);
+  REQUIRE((msgs | count_payloads{}) == 3);
+
+  // get_pair across routes
+  auto idx0 = msgs | get_pair{0};
+  REQUIRE(idx0.headerIdx == 0);
+  REQUIRE(idx0.payloadIdx == 1);
+
+  auto idx1 = msgs | get_pair{1};
+  REQUIRE(idx1.headerIdx == 2);
+  REQUIRE(idx1.payloadIdx == 3);
+
+  auto idx2 = msgs | get_pair{2};
+  REQUIRE(idx2.headerIdx == 2);
+  REQUIRE(idx2.payloadIdx == 4);
+
+  // get_next_pair traversal from the first element
+  DataRefIndices idx{0, 1};
+  idx = msgs | get_next_pair{idx};
+  REQUIRE(idx.headerIdx == 2);
+  REQUIRE(idx.payloadIdx == 3);
+  idx = msgs | get_next_pair{idx};
+  REQUIRE(idx.headerIdx == 2);
+  REQUIRE(idx.payloadIdx == 4);
+  idx = msgs | get_next_pair{idx};
+  REQUIRE(idx.headerIdx >= msgs.size());
+}

From 5cf005b9a2caf9e5c17251a32b0c7b490261e09a Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 7 Apr 2026 08:47:47 +0200
Subject: [PATCH 1525/1764] ITS3: add cylinder parameterisation preserving zero
 gaussian curvature (#15260)

* ITS3: exploit symmetric matrices for interpolation

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS3: cleanup code

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS3: alignment for inextionsial surfaces

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS3: harmonize study and alignment wfx for misalignment

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../Upgrades/ITS3/alignment/CMakeLists.txt    |   3 +
 Detectors/Upgrades/ITS3/alignment/README.md   |  36 +++-
 .../include/ITS3Align/AlignmentDOF.h          | 176 +++++++++++++++++
 .../include/ITS3Align/AlignmentHierarchy.h    | 178 +----------------
 .../include/ITS3Align/AlignmentLabel.h        |  87 +++++++++
 .../include/ITS3Align/AlignmentMath.h         |  32 +++
 .../include/ITS3Align/AlignmentParams.h       |   7 +-
 .../include/ITS3Align/AlignmentSpec.h         |   1 +
 .../include/ITS3Align/MisalignmentUtils.h     |  79 ++++++++
 .../alignment/include/ITS3Align/TrackFit.h    |   8 +-
 .../ITS3/alignment/src/AlignmentDOF.cxx       | 114 +++++++++++
 .../ITS3/alignment/src/AlignmentHierarchy.cxx | 127 ++++++++++--
 .../ITS3/alignment/src/AlignmentMath.cxx      |  54 ++++++
 .../ITS3/alignment/src/AlignmentSpec.cxx      | 183 ++++++++----------
 .../ITS3/alignment/src/MisalignmentUtils.cxx  | 151 +++++++++++++++
 .../Upgrades/ITS3/study/src/TrackingStudy.cxx |  90 +++------
 16 files changed, 967 insertions(+), 359 deletions(-)
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentDOF.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentLabel.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentMath.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentUtils.h
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/AlignmentDOF.cxx
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/AlignmentMath.cxx
 create mode 100644 Detectors/Upgrades/ITS3/alignment/src/MisalignmentUtils.cxx

diff --git a/Detectors/Upgrades/ITS3/alignment/CMakeLists.txt b/Detectors/Upgrades/ITS3/alignment/CMakeLists.txt
index 0bc8080c7a1b8..e04dfcbb43963 100644
--- a/Detectors/Upgrades/ITS3/alignment/CMakeLists.txt
+++ b/Detectors/Upgrades/ITS3/alignment/CMakeLists.txt
@@ -13,6 +13,9 @@
 o2_add_library(ITS3Align
                TARGETVARNAME targetName
                SOURCES src/AlignmentHierarchy.cxx
+                       src/AlignmentDOF.cxx
+                       src/AlignmentMath.cxx
+                       src/MisalignmentUtils.cxx
                        src/AlignmentSensors.cxx
                        src/AlignmentParams.cxx
                        src/AlignmentTypes.cxx
diff --git a/Detectors/Upgrades/ITS3/alignment/README.md b/Detectors/Upgrades/ITS3/alignment/README.md
index 62633d1d7d313..80213eb4e03b1 100644
--- a/Detectors/Upgrades/ITS3/alignment/README.md
+++ b/Detectors/Upgrades/ITS3/alignment/README.md
@@ -27,4 +27,38 @@ dofSet.json:
       "calib": { "type": "legendre", "order": 1, "fix": [0, 2] }
     }
   ]
-}```
+}
+```
+
+
+## In-existensional modes
+```json
+{
+  "defaults": { "rigidBody": "fixed" },
+  "rules": [
+    {
+      "match": "ITS3Layer1/ITS3CarbonForm0",
+      "calib": {
+        "type": "inextensional",
+        "order": 2,
+        "free": ["a_2", "b_2", "c_2", "d_2", "alpha", "beta"]
+      }
+    }
+  ]
+}
+```
+
+```json
+[
+  {
+    "id": 2,
+    "inextensional": {
+      "modes": {
+        "2": [0.0008, -0.0005, 0.0006, -0.0007]
+      },
+      "alpha": 0.0004,
+      "beta": -0.0003
+    }
+  }
+]
+```
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentDOF.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentDOF.h
new file mode 100644
index 0000000000000..3fed9decbd6e7
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentDOF.h
@@ -0,0 +1,176 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGNMENT_DOF_H
+#define O2_ITS3_ALIGNMENT_DOF_H
+
+#include <algorithm>
+#include <cstdint>
+#include <format>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <Eigen/Dense>
+
+struct DerivativeContext {
+  int sensorID{-1};
+  int layerID{-1};
+  double measX{0.};
+  double measAlpha{0.};
+  double measZ{0.};
+  double trkY{0.};
+  double trkZ{0.};
+  double snp{0.};
+  double tgl{0.};
+  double dydx{0.};
+  double dzdx{0.};
+};
+
+// Generic set of DOF
+class DOFSet
+{
+ public:
+  enum class Type : uint8_t {
+    RigidBody,
+    Legendre,
+    Inextensional
+  };
+  virtual ~DOFSet() = default;
+  virtual Type type() const = 0;
+  int nDOFs() const { return static_cast<int>(mFree.size()); }
+  virtual std::string dofName(int idx) const = 0;
+  virtual void fillDerivatives(const DerivativeContext& ctx, Eigen::Ref<Eigen::MatrixXd> out) const = 0;
+  bool isFree(int idx) const { return mFree[idx]; }
+  void setFree(int idx, bool f) { mFree[idx] = f; }
+  void setAllFree(bool f) { std::fill(mFree.begin(), mFree.end(), f); }
+  int nFreeDOFs() const
+  {
+    int n = 0;
+    for (bool f : mFree) {
+      n += f;
+    }
+    return n;
+  }
+
+ protected:
+  DOFSet(int n) : mFree(n, true) {}
+  std::vector<bool> mFree;
+};
+
+// Rigid body set
+class RigidBodyDOFSet final : public DOFSet
+{
+ public:
+  // indices for rigid body parameters in LOC frame
+  enum RigidBodyDOF : uint8_t {
+    TX = 0,
+    TY,
+    TZ,
+    RX,
+    RY,
+    RZ,
+    NDOF,
+  };
+  static constexpr const char* RigidBodyDOFNames[RigidBodyDOF::NDOF] = {"TX", "TY", "TZ", "RX", "RY", "RZ"};
+
+  RigidBodyDOFSet() : DOFSet(NDOF) {}
+  // mask: bitmask of free DOFs (bit i = DOF i is free)
+  explicit RigidBodyDOFSet(uint8_t mask) : DOFSet(NDOF)
+  {
+    for (int i = 0; i < NDOF; ++i) {
+      mFree[i] = (mask >> i) & 1;
+    }
+  }
+  Type type() const override { return Type::RigidBody; }
+  std::string dofName(int idx) const override { return RigidBodyDOFNames[idx]; }
+  void fillDerivatives(const DerivativeContext& ctx, Eigen::Ref<Eigen::MatrixXd> out) const override;
+  uint8_t mask() const
+  {
+    uint8_t m = 0;
+    for (int i = 0; i < NDOF; ++i) {
+      m |= (uint8_t(mFree[i]) << i);
+    }
+    return m;
+  }
+};
+
+// Legendre DOFs
+// Describing radial misplacement
+class LegendreDOFSet final : public DOFSet
+{
+ public:
+  explicit LegendreDOFSet(int order) : DOFSet((order + 1) * (order + 2) / 2), mOrder(order) {}
+  Type type() const override { return Type::Legendre; }
+  int order() const { return mOrder; }
+  std::string dofName(int idx) const override
+  {
+    int i = 0;
+    while ((i + 1) * (i + 2) / 2 <= idx) {
+      ++i;
+    }
+    int j = idx - (i * (i + 1) / 2);
+    return std::format("L({},{})", i, j);
+  }
+  void fillDerivatives(const DerivativeContext& ctx, Eigen::Ref<Eigen::MatrixXd> out) const override;
+
+ private:
+  int mOrder;
+};
+
+// In-extensional deformation DOFs for cylindrical half-shells
+// Fourier modes n=2..N: 4 params each (a_n, b_n, c_n, d_n)
+// Plus 2 non-periodic modes (alpha, beta) for the half-cylinder open edges
+// Total: 4*(N-1) + 2
+class InextensionalDOFSet final : public DOFSet
+{
+ public:
+  explicit InextensionalDOFSet(int maxOrder) : DOFSet((4 * (maxOrder - 1)) + 2), mMaxOrder(maxOrder)
+  {
+    if (maxOrder < 2) {
+      // the rest is eq. to rigid body
+      throw std::invalid_argument("InextensionalDOFSet requires maxOrder >= 2");
+    }
+  }
+  Type type() const override { return Type::Inextensional; }
+  int maxOrder() const { return mMaxOrder; }
+
+  // number of periodic DOFs (before alpha, beta)
+  int nPeriodic() const { return 4 * (mMaxOrder - 1); }
+
+  // flat index layout: [a_2, b_2, c_2, d_2, a_3, b_3, c_3, d_3, ..., alpha, beta]
+  // index of first DOF for mode n
+  static int modeOffset(int n) { return 4 * (n - 2); }
+
+  // indices of the non-periodic modes
+  int alphaIdx() const { return nPeriodic(); }
+  int betaIdx() const { return nPeriodic() + 1; }
+
+  std::string dofName(int idx) const override
+  {
+    if (idx == alphaIdx()) {
+      return "alpha";
+    }
+    if (idx == betaIdx()) {
+      return "beta";
+    }
+    int n = (idx / 4) + 2;
+    int sub = idx % 4;
+    static constexpr const char* subNames[] = {"a", "b", "c", "d"};
+    return std::format("{}_{}", subNames[sub], n);
+  }
+  void fillDerivatives(const DerivativeContext& ctx, Eigen::Ref<Eigen::MatrixXd> out) const override;
+
+ private:
+  int mMaxOrder;
+};
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentHierarchy.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentHierarchy.h
index 04b8157084d0a..ae8989deec21b 100644
--- a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentHierarchy.h
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentHierarchy.h
@@ -13,14 +13,11 @@
 #define O2_ITS3_ALIGNMENT_HIERARCHY_H
 
 #include <memory>
-#include <compare>
-#include <type_traits>
-#include <map>
 #include <utility>
 #include <vector>
 #include <ostream>
 #include <string>
-#include <format>
+#include <map>
 #include <algorithm>
 
 #include <Eigen/Dense>
@@ -28,179 +25,14 @@
 #include <TGeoMatrix.h>
 #include <TGeoPhysicalNode.h>
 
+#include "ITS3Align/AlignmentLabel.h"
+#include "ITS3Align/AlignmentDOF.h"
+
 namespace o2::its3::align
 {
 using Matrix36 = Eigen::Matrix<double, 3, 6>;
 using Matrix66 = Eigen::Matrix<double, 6, 6>;
 
-// indices for rigid body parameters in LOC frame
-enum RigidBodyDOF : uint8_t {
-  TX = 0,
-  TY,
-  TZ,
-  RX,
-  RY,
-  RZ,
-  NDOF,
-};
-static constexpr const char* RigidBodyDOFNames[RigidBodyDOF::NDOF] = {"TX", "TY", "TZ", "RX", "RY", "RZ"};
-
-// return the rigid body derivatives
-// trk has be at in the measurment frame
-auto getRigidBodyDerivatives(const auto& trk)
-{
-  // calculate slopes
-  const double tgl = trk.getTgl(), snp = trk.getSnp();
-  const double csp = 1. / sqrt(1. + (tgl * tgl));
-  const double u = trk.getY(), v = trk.getZ();
-  const double uP = snp * csp, vP = tgl * csp;
-  Matrix36 der;
-  der.setZero();
-  // columns: Tt,  Tu,  Tv,  Rt,    Ru,   Rv
-  //          (X)  (Y)  (Z)  (RX)   (RY)  (RZ)
-  der << uP, -1., 0., v, v * uP, -u * uP,
-    vP, 0., -1., -u, v * vP, -u * vP;
-  return der;
-}
-
-class DOFSet
-{
- public:
-  enum class Type : uint8_t { RigidBody,
-                              Legendre };
-  virtual ~DOFSet() = default;
-  virtual Type type() const = 0;
-  int nDOFs() const { return static_cast<int>(mFree.size()); }
-  virtual std::string dofName(int idx) const = 0;
-  bool isFree(int idx) const { return mFree[idx]; }
-  void setFree(int idx, bool f) { mFree[idx] = f; }
-  void setAllFree(bool f) { std::fill(mFree.begin(), mFree.end(), f); }
-  int nFreeDOFs() const
-  {
-    int n = 0;
-    for (bool f : mFree) {
-      n += f;
-    }
-    return n;
-  }
-
- protected:
-  DOFSet(int n) : mFree(n, true) {}
-  std::vector<bool> mFree;
-};
-
-class RigidBodyDOFSet final : public DOFSet
-{
- public:
-  static constexpr int NDOF = RigidBodyDOF::NDOF;
-  RigidBodyDOFSet() : DOFSet(NDOF) {}
-  // mask: bitmask of free DOFs (bit i = DOF i is free)
-  explicit RigidBodyDOFSet(uint8_t mask) : DOFSet(NDOF)
-  {
-    for (int i = 0; i < NDOF; ++i) {
-      mFree[i] = (mask >> i) & 1;
-    }
-  }
-  Type type() const override { return Type::RigidBody; }
-  std::string dofName(int idx) const override { return RigidBodyDOFNames[idx]; }
-  uint8_t mask() const
-  {
-    uint8_t m = 0;
-    for (int i = 0; i < NDOF; ++i) {
-      m |= (uint8_t(mFree[i]) << i);
-    }
-    return m;
-  }
-};
-
-class LegendreDOFSet final : public DOFSet
-{
- public:
-  explicit LegendreDOFSet(int order) : DOFSet((order + 1) * (order + 2) / 2), mOrder(order) {}
-  Type type() const override { return Type::Legendre; }
-  int order() const { return mOrder; }
-  std::string dofName(int idx) const override
-  {
-    int i = 0;
-    while ((i + 1) * (i + 2) / 2 <= idx) {
-      ++i;
-    }
-    int j = idx - (i * (i + 1) / 2);
-    return std::format("L({},{})", i, j);
-  }
-
- private:
-  int mOrder;
-};
-
-class GlobalLabel
-{
-  // Millepede label is any positive integer [1....)
-  // Layout: DOF(5) | CALIB(1) | ID(22) | SENS(1) | DET(2) = 31 usable bits (MSB reserved, GBL uses signed int)
- public:
-  using T = uint32_t;
-  static constexpr int DOF_BITS = 5;   // bits 0-4
-  static constexpr int CALIB_BITS = 1; // bit 5: 0 = rigid body, 1 = calibration
-  static constexpr int ID_BITS = 22;   // bits 6-27
-  static constexpr int SENS_BITS = 1;  // bit 28
-  static constexpr int TOTAL_BITS = sizeof(T) * 8;
-  static constexpr int DET_BITS = TOTAL_BITS - (DOF_BITS + CALIB_BITS + ID_BITS + SENS_BITS) - 1; // one less bit since GBL uses int!
-  static constexpr T bitMask(int b) noexcept
-  {
-    return (T(1) << b) - T(1);
-  }
-  static constexpr int DOF_SHIFT = 0;
-  static constexpr T DOF_MAX = (T(1) << DOF_BITS) - T(1);
-  static constexpr T DOF_MASK = DOF_MAX << DOF_SHIFT;
-  static constexpr int CALIB_SHIFT = DOF_BITS;
-  static constexpr T CALIB_MAX = (T(1) << CALIB_BITS) - T(1);
-  static constexpr T CALIB_MASK = CALIB_MAX << CALIB_SHIFT;
-  static constexpr int ID_SHIFT = DOF_BITS + CALIB_BITS;
-  static constexpr T ID_MAX = (T(1) << ID_BITS) - T(1);
-  static constexpr T ID_MASK = ID_MAX << ID_SHIFT;
-  static constexpr int SENS_SHIFT = DOF_BITS + CALIB_BITS + ID_BITS;
-  static constexpr T SENS_MAX = (T(1) << SENS_BITS) - T(1);
-  static constexpr T SENS_MASK = SENS_MAX << SENS_SHIFT;
-  static constexpr int DET_SHIFT = DOF_BITS + CALIB_BITS + ID_BITS + SENS_BITS;
-  static constexpr T DET_MAX = (T(1) << DET_BITS) - T(1);
-  static constexpr T DET_MASK = DET_MAX << DET_SHIFT;
-
-  GlobalLabel(T det, T id, bool sens, bool calib = false)
-    : mID((((id + 1) & ID_MAX) << ID_SHIFT) |
-          ((det & DET_MAX) << DET_SHIFT) |
-          ((T(sens) & SENS_MAX) << SENS_SHIFT) |
-          ((T(calib) & CALIB_MAX) << CALIB_SHIFT))
-  {
-  }
-
-  /// produce the raw Millepede label for a given DOF index (rigid body: calib=0 in label)
-  constexpr T raw(T dof) const noexcept { return (mID & ~DOF_MASK) | ((dof & DOF_MAX) << DOF_SHIFT); }
-  constexpr int rawGBL(T dof) const noexcept { return static_cast<int>(raw(dof)); }
-
-  /// return a copy of this label with the CALIB bit set (for calibration DOFs on same volume)
-  GlobalLabel asCalib() const noexcept
-  {
-    GlobalLabel c{*this};
-    c.mID |= (T(1) << CALIB_SHIFT);
-    return c;
-  }
-
-  constexpr T id() const noexcept { return ((mID >> ID_SHIFT) & ID_MAX) - 1; }
-  constexpr T det() const noexcept { return (mID & DET_MASK) >> DET_SHIFT; }
-  constexpr bool sens() const noexcept { return (mID & SENS_MASK) >> SENS_SHIFT; }
-  constexpr bool calib() const noexcept { return (mID & CALIB_MASK) >> CALIB_SHIFT; }
-
-  std::string asString() const
-  {
-    return std::format("Det:{} Id:{} Sens:{} Calib:{}", det(), id(), sens(), calib());
-  }
-
-  constexpr auto operator<=>(const GlobalLabel&) const noexcept = default;
-
- private:
-  T mID{0};
-};
-
 class HierarchyConstraint
 {
  public:
@@ -220,8 +52,6 @@ class HierarchyConstraint
   std::vector<double> mCoeff;    // their coefficients
 };
 
-// --- AlignableVolume ---
-
 class AlignableVolume
 {
  public:
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentLabel.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentLabel.h
new file mode 100644
index 0000000000000..83495491b87e0
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentLabel.h
@@ -0,0 +1,87 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGNMENT_LABEL_H
+#define O2_ITS3_ALIGNMENT_LABEL_H
+
+#include <cstdint>
+#include <string>
+#include <format>
+
+class GlobalLabel
+{
+  // Millepede label is any positive integer [1....)
+  // Layout: DOF(5) | CALIB(1) | ID(22) | SENS(1) | DET(2) = 31 usable bits (MSB reserved, GBL uses signed int)
+ public:
+  using T = uint32_t;
+  static constexpr int DOF_BITS = 5;   // bits 0-4
+  static constexpr int CALIB_BITS = 1; // bit 5: 0 = rigid body, 1 = calibration (only allow for one calibration, could be extended if needed)
+  static constexpr int ID_BITS = 22;   // bits 6-27
+  static constexpr int SENS_BITS = 1;  // bit 28
+  static constexpr int TOTAL_BITS = sizeof(T) * 8;
+  static constexpr int DET_BITS = TOTAL_BITS - (DOF_BITS + CALIB_BITS + ID_BITS + SENS_BITS) - 1; // one less bit since GBL uses int!
+  static constexpr T bitMask(int b) noexcept
+  {
+    return (T(1) << b) - T(1);
+  }
+  static constexpr int DOF_SHIFT = 0;
+  static constexpr T DOF_MAX = (T(1) << DOF_BITS) - T(1);
+  static constexpr T DOF_MASK = DOF_MAX << DOF_SHIFT;
+  static constexpr int CALIB_SHIFT = DOF_BITS;
+  static constexpr T CALIB_MAX = (T(1) << CALIB_BITS) - T(1);
+  static constexpr T CALIB_MASK = CALIB_MAX << CALIB_SHIFT;
+  static constexpr int ID_SHIFT = DOF_BITS + CALIB_BITS;
+  static constexpr T ID_MAX = (T(1) << ID_BITS) - T(1);
+  static constexpr T ID_MASK = ID_MAX << ID_SHIFT;
+  static constexpr int SENS_SHIFT = DOF_BITS + CALIB_BITS + ID_BITS;
+  static constexpr T SENS_MAX = (T(1) << SENS_BITS) - T(1);
+  static constexpr T SENS_MASK = SENS_MAX << SENS_SHIFT;
+  static constexpr int DET_SHIFT = DOF_BITS + CALIB_BITS + ID_BITS + SENS_BITS;
+  static constexpr T DET_MAX = (T(1) << DET_BITS) - T(1);
+  static constexpr T DET_MASK = DET_MAX << DET_SHIFT;
+
+  GlobalLabel(T det, T id, bool sens, bool calib = false)
+    : mID((((id + 1) & ID_MAX) << ID_SHIFT) |
+          ((det & DET_MAX) << DET_SHIFT) |
+          ((T(sens) & SENS_MAX) << SENS_SHIFT) |
+          ((T(calib) & CALIB_MAX) << CALIB_SHIFT))
+  {
+  }
+
+  /// produce the raw Millepede label for a given DOF index (rigid body: calib=0 in label)
+  constexpr T raw(T dof) const noexcept { return (mID & ~DOF_MASK) | ((dof & DOF_MAX) << DOF_SHIFT); }
+  constexpr int rawGBL(T dof) const noexcept { return static_cast<int>(raw(dof)); }
+
+  /// return a copy of this label with the CALIB bit set (for calibration DOFs on same volume)
+  GlobalLabel asCalib() const noexcept
+  {
+    GlobalLabel c{*this};
+    c.mID |= (T(1) << CALIB_SHIFT);
+    return c;
+  }
+
+  constexpr T id() const noexcept { return ((mID >> ID_SHIFT) & ID_MAX) - 1; }
+  constexpr T det() const noexcept { return (mID & DET_MASK) >> DET_SHIFT; }
+  constexpr bool sens() const noexcept { return (mID & SENS_MASK) >> SENS_SHIFT; }
+  constexpr bool calib() const noexcept { return (mID & CALIB_MASK) >> CALIB_SHIFT; }
+
+  std::string asString() const
+  {
+    return std::format("Det:{} Id:{} Sens:{} Calib:{}", det(), id(), sens(), calib());
+  }
+
+  constexpr auto operator<=>(const GlobalLabel&) const noexcept = default;
+
+ private:
+  T mID{0};
+};
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentMath.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentMath.h
new file mode 100644
index 0000000000000..9409648dca3e4
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentMath.h
@@ -0,0 +1,32 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGNMENT_MATH_H
+#define O2_ITS3_ALIGNMENT_MATH_H
+
+#include <utility>
+#include <vector>
+
+namespace o2::its3::align
+{
+
+struct TrackSlopes {
+  double dydx{0.};
+  double dzdx{0.};
+};
+
+std::pair<double, double> computeUV(double gloX, double gloY, double gloZ, int sensorID, double radius);
+TrackSlopes computeTrackSlopes(double snp, double tgl);
+std::vector<double> legendrePols(int order, double x);
+
+} // namespace o2::its3::align
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h
index a7785a2c04e11..5a11066fd3c3b 100644
--- a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h
@@ -38,9 +38,10 @@ struct AlignmentParams : public o2::conf::ConfigurableParamHelper<AlignmentParam
   float extraClsErrZ[6] = {0};
 
   // misalignment simulation
-  bool doMisalignmentLeg = false; // simulate Legendre deformation on ITS3 layers
-  bool doMisalignmentRB = false;  // simulate rigid body misalignment on ITS3 layers
-  std::string misAlgJson;         // JSON file with deformation and/or rigid body params
+  bool doMisalignmentLeg = false;  // simulate Legendre deformation on ITS3 layers
+  bool doMisalignmentRB = false;   // simulate rigid body misalignment on ITS3 layers
+  bool doMisalignmentInex = false; // simulate in-extensional deformation on ITS3 layers
+  std::string misAlgJson;          // JSON file with deformation and/or rigid body params
 
   // DOF configuration (JSON file defining which volumes have which DOFs)
   std::string dofConfigJson; // if empty, no DOFs are configured
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h
index 2344889657558..d171454bc4794 100644
--- a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h
@@ -24,6 +24,7 @@ enum class OutputOpt : uint8_t {
   MilleData,
   MilleSteer,
   MilleRes,
+  MisRes,
   Debug,
 };
 using OutputEnum = utils::EnumFlags<OutputOpt>;
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentUtils.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentUtils.h
new file mode 100644
index 0000000000000..457eccaeff4e6
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/MisalignmentUtils.h
@@ -0,0 +1,79 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS3_ALIGNMENT_MISALIGNMENTUTILS_H
+#define O2_ITS3_ALIGNMENT_MISALIGNMENTUTILS_H
+
+#include <array>
+#include <cstddef>
+#include <map>
+#include <string>
+#include <utility>
+
+#include "ITS3Align/AlignmentMath.h"
+#include "MathUtils/LegendrePols.h"
+
+namespace o2::its3::align
+{
+
+struct InextensionalMisalignment {
+  std::map<int, std::array<double, 4>> modes; // n -> (a_n, b_n, c_n, d_n)
+  double alpha{0.};
+  double beta{0.};
+};
+
+struct SensorMisalignment {
+  o2::math_utils::Legendre2DPolynominal legendre;
+  bool hasLegendre{false};
+  InextensionalMisalignment inextensional;
+  bool hasInextensional{false};
+
+  bool empty() const noexcept { return !hasLegendre && !hasInextensional; }
+};
+
+struct MisalignmentModel {
+  static constexpr std::size_t NSensors = 6;
+  std::array<SensorMisalignment, NSensors> sensors{};
+
+  bool empty() const noexcept;
+  const SensorMisalignment& operator[](std::size_t idx) const { return sensors[idx]; }
+  SensorMisalignment& operator[](std::size_t idx) { return sensors[idx]; }
+};
+
+struct MisalignmentFrame {
+  int sensorID{-1};
+  int layerID{-1};
+  double x{0.};     // tracking-frame X / nominal radius at the measurement
+  double alpha{0.}; // tracking-frame alpha
+  double z{0.};     // tracking-frame measurement z
+};
+
+struct MisalignmentShift {
+  double dy{0.};
+  double dz{0.};
+  bool accepted{true};
+
+  MisalignmentShift& operator+=(const MisalignmentShift& other)
+  {
+    dy += other.dy;
+    dz += other.dz;
+    accepted = accepted && other.accepted;
+    return *this;
+  }
+};
+
+MisalignmentModel loadMisalignmentModel(const std::string& jsonPath);
+MisalignmentShift evaluateLegendreShift(const SensorMisalignment& sensor, const MisalignmentFrame& frame, const TrackSlopes& slopes);
+MisalignmentShift evaluateInextensionalShift(const SensorMisalignment& sensor, const MisalignmentFrame& frame, const TrackSlopes& slopes);
+
+} // namespace o2::its3::align
+
+#endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/TrackFit.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/TrackFit.h
index 3f36705271c9b..4625776398c89 100644
--- a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/TrackFit.h
+++ b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/TrackFit.h
@@ -76,10 +76,12 @@ o2::track::TrackParametrizationWithError<T> interpolateTrackParCov(
   };
   Mat55 cA = unpack(tA.getCov());
   Mat55 cB = unpack(tB.getCov());
-  Mat55 wA = cA.inverse();
-  Mat55 wB = cB.inverse();
+  Eigen::LLT<Mat55> lltA(cA), lltB(cB);
+  Mat55 wA = lltA.solve(Mat55::Identity());
+  Mat55 wB = lltB.solve(Mat55::Identity());
   Mat55 wTot = wA + wB;
-  Mat55 cTot = wTot.inverse();
+  Eigen::LLT<Mat55> lltTot(wTot);
+  Mat55 cTot = lltTot.solve(Mat55::Identity());
   Mat51 pA, pB;
   for (int i = 0; i < 5; ++i) {
     pA(i) = tA.getParam(i);
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentDOF.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentDOF.cxx
new file mode 100644
index 0000000000000..d2a78dba791e6
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentDOF.cxx
@@ -0,0 +1,114 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3Align/AlignmentDOF.h"
+
+#include <cmath>
+#include <stdexcept>
+
+#include "ITS3Align/AlignmentMath.h"
+#include "ITS3Base/SpecsV2.h"
+
+namespace
+{
+
+void validateDerivativeOutput(const DOFSet& dofSet, Eigen::Ref<Eigen::MatrixXd> out)
+{
+  if (out.rows() != 3 || out.cols() != dofSet.nDOFs()) {
+    throw std::invalid_argument(std::format("Derivative buffer shape {}x{} does not match expected 3x{}",
+                                            out.rows(), out.cols(), dofSet.nDOFs()));
+  }
+  out.setZero();
+}
+
+} // namespace
+
+void RigidBodyDOFSet::fillDerivatives(const DerivativeContext& ctx, Eigen::Ref<Eigen::MatrixXd> out) const
+{
+  validateDerivativeOutput(*this, out);
+
+  const double csp = 1. / std::sqrt(1. + (ctx.tgl * ctx.tgl));
+  const double uP = ctx.snp * csp;
+  const double vP = ctx.tgl * csp;
+
+  out(0, TX) = uP;
+  out(0, TY) = -1.;
+  out(0, RX) = ctx.trkZ;
+  out(0, RY) = ctx.trkZ * uP;
+  out(0, RZ) = -ctx.trkY * uP;
+
+  out(1, TX) = vP;
+  out(1, TZ) = -1.;
+  out(1, RX) = -ctx.trkY;
+  out(1, RY) = ctx.trkZ * vP;
+  out(1, RZ) = -ctx.trkY * vP;
+}
+
+void LegendreDOFSet::fillDerivatives(const DerivativeContext& ctx, Eigen::Ref<Eigen::MatrixXd> out) const
+{
+  validateDerivativeOutput(*this, out);
+  if (ctx.sensorID < 0 || ctx.layerID < 0) {
+    throw std::invalid_argument("LegendreDOFSet requires an ITS3 measurement context");
+  }
+
+  const double gloX = ctx.measX * std::cos(ctx.measAlpha);
+  const double gloY = ctx.measX * std::sin(ctx.measAlpha);
+  const auto [u, v] = o2::its3::align::computeUV(gloX, gloY, ctx.measZ, ctx.sensorID, o2::its3::constants::radii[ctx.layerID]);
+  const auto pu = o2::its3::align::legendrePols(mOrder, u);
+  const auto pv = o2::its3::align::legendrePols(mOrder, v);
+
+  int idx = 0;
+  for (int i = 0; i <= mOrder; ++i) {
+    for (int j = 0; j <= i; ++j) {
+      const double basis = pu[j] * pv[i - j];
+      out(0, idx) = ctx.dydx * basis;
+      out(1, idx) = ctx.dzdx * basis;
+      ++idx;
+    }
+  }
+}
+
+void InextensionalDOFSet::fillDerivatives(const DerivativeContext& ctx, Eigen::Ref<Eigen::MatrixXd> out) const
+{
+  validateDerivativeOutput(*this, out);
+  if (ctx.layerID < 0) {
+    throw std::invalid_argument("InextensionalDOFSet requires an ITS3 measurement context");
+  }
+
+  const double r = o2::its3::constants::radii[ctx.layerID];
+  const double phi = std::atan2(r * std::sin(ctx.measAlpha), r * std::cos(ctx.measAlpha));
+  const double z = ctx.measZ;
+
+  for (int n = 2; n <= mMaxOrder; ++n) {
+    const double sn = std::sin(n * phi);
+    const double cn = std::cos(n * phi);
+    const double n2 = static_cast<double>(n * n);
+    const int off = modeOffset(n);
+
+    out(0, off + 0) = -(z / r) * (n * sn + ctx.dydx * n2 * cn);
+    out(1, off + 0) = -cn - ctx.dzdx * (z / r) * n2 * cn;
+
+    out(0, off + 1) = (z / r) * (n * cn - ctx.dydx * n2 * sn);
+    out(1, off + 1) = -sn * (1. + ctx.dzdx * (z / r) * n2);
+
+    out(0, off + 2) = -cn + ctx.dydx * n * sn;
+    out(1, off + 2) = ctx.dzdx * n * sn;
+
+    out(0, off + 3) = -sn - ctx.dydx * n * cn;
+    out(1, off + 3) = -ctx.dzdx * n * cn;
+  }
+
+  out(0, alphaIdx()) = z / r;
+  out(1, alphaIdx()) = -phi;
+
+  out(0, betaIdx()) = -phi - ctx.dydx;
+  out(1, betaIdx()) = -ctx.dzdx;
+}
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx
index 9170165a36a41..938c14c2c4759 100644
--- a/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx
@@ -178,21 +178,23 @@ void AlignableVolume::writeParameters(std::ostream& os) const
   if (isRoot()) {
     os << "Parameter\n";
   }
-  if (mRigidBody) {
-    for (int iDOF = 0; iDOF < mRigidBody->nDOFs(); ++iDOF) {
-      os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {} ",
-                        mLabel.raw(iDOF), 0.0, (mRigidBody->isFree(iDOF) ? 0.0 : -1.0),
-                        (mRigidBody->isFree(iDOF) ? 'V' : 'F'), mRigidBody->dofName(iDOF))
-         << mSymName << '\n';
+  if (!mIsPseudo) {
+    if (mRigidBody) {
+      for (int iDOF = 0; iDOF < mRigidBody->nDOFs(); ++iDOF) {
+        os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {} ",
+                          mLabel.raw(iDOF), 0.0, (mRigidBody->isFree(iDOF) ? 0.0 : -1.0),
+                          (mRigidBody->isFree(iDOF) ? 'V' : 'F'), mRigidBody->dofName(iDOF))
+           << mSymName << '\n';
+      }
     }
-  }
-  if (mCalib) {
-    auto calibLbl = mLabel.asCalib();
-    for (int iDOF = 0; iDOF < mCalib->nDOFs(); ++iDOF) {
-      os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {} ",
-                        calibLbl.raw(iDOF), 0.0, (mCalib->isFree(iDOF) ? 0.0 : -1.0),
-                        (mCalib->isFree(iDOF) ? 'V' : 'F'), mCalib->dofName(iDOF))
-         << mSymName << '\n';
+    if (mCalib) {
+      auto calibLbl = mLabel.asCalib();
+      for (int iDOF = 0; iDOF < mCalib->nDOFs(); ++iDOF) {
+        os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {:<5} ",
+                          calibLbl.raw(iDOF), 0.0, (mCalib->isFree(iDOF) ? 0.0 : -1.0),
+                          (mCalib->isFree(iDOF) ? 'V' : 'F'), mCalib->dofName(iDOF))
+           << mSymName << '\n';
+      }
     }
   }
   for (const auto& c : mChildren) {
@@ -266,6 +268,9 @@ void applyDOFConfig(AlignableVolume* root, const std::string& jsonPath)
   }
 
   root->traverse([&](AlignableVolume* vol) {
+    if (vol->isPseudo()) {
+      return;
+    }
     const std::string& sym = vol->getSymName();
     for (const auto& rule : rules) {
       const auto pattern = rule["match"].get<std::string>();
@@ -357,6 +362,41 @@ void applyDOFConfig(AlignableVolume* root, const std::string& jsonPath)
             }
           }
           vol->setCalib(std::move(dofSet));
+        } else if (calType == "inextensional") {
+          int maxOrder = cal.value("order", 2);
+          auto dofSet = std::make_unique<InextensionalDOFSet>(maxOrder);
+          bool fixed = cal.value("fixed", false);
+          if (fixed) {
+            dofSet->setAllFree(false);
+          }
+          if (cal.contains("free")) {
+            dofSet->setAllFree(false);
+            for (const auto& item : cal["free"]) {
+              if (item.is_number_integer()) {
+                dofSet->setFree(item.get<int>(), true);
+              } else if (item.is_string()) {
+                for (int k = 0; k < dofSet->nDOFs(); ++k) {
+                  if (dofSet->dofName(k) == item.get<std::string>()) {
+                    dofSet->setFree(k, true);
+                  }
+                }
+              }
+            }
+          }
+          if (cal.contains("fix")) {
+            for (const auto& item : cal["fix"]) {
+              if (item.is_number_integer()) {
+                dofSet->setFree(item.get<int>(), false);
+              } else if (item.is_string()) {
+                for (int k = 0; k < dofSet->nDOFs(); ++k) {
+                  if (dofSet->dofName(k) == item.get<std::string>()) {
+                    dofSet->setFree(k, false);
+                  }
+                }
+              }
+            }
+          }
+          vol->setCalib(std::move(dofSet));
         }
       }
     }
@@ -398,6 +438,12 @@ void writeMillepedeResults(AlignableVolume* root, const std::string& milleResPat
   // indexed by sensorID
   std::map<int, std::vector<double>> injRB;
   std::map<int, std::vector<std::vector<double>>> injMatrix;
+  struct InjInex {
+    std::map<int, std::array<double, 4>> modes;
+    double alpha{0.};
+    double beta{0.};
+  };
+  std::map<int, InjInex> injInex;
   if (!injectedJsonPath.empty()) {
     std::ifstream injFile(injectedJsonPath);
     if (injFile.is_open()) {
@@ -410,6 +456,22 @@ void writeMillepedeResults(AlignableVolume* root, const std::string& milleResPat
         if (item.contains("matrix")) {
           injMatrix[id] = item["matrix"].get<std::vector<std::vector<double>>>();
         }
+        if (item.contains("inextensional")) {
+          InjInex ii;
+          const auto& inex = item["inextensional"];
+          if (inex.contains("modes")) {
+            for (auto& [key, val] : inex["modes"].items()) {
+              ii.modes[std::stoi(key)] = val.get<std::array<double, 4>>();
+            }
+          }
+          if (inex.contains("alpha")) {
+            ii.alpha = inex["alpha"].get<double>();
+          }
+          if (inex.contains("beta")) {
+            ii.beta = inex["beta"].get<double>();
+          }
+          injInex[id] = ii;
+        }
       }
       LOGP(info, "Loaded injected misalignment for {} sensors", injData.size());
     } else {
@@ -468,6 +530,43 @@ void writeMillepedeResults(AlignableVolume* root, const std::string& milleResPat
         matrix.push_back(row);
       }
       entry["matrix"] = matrix;
+    } else if (cal && cal->nFreeDOFs() && cal->type() == DOFSet::Type::Inextensional) {
+      write = true;
+      auto* inexSet = static_cast<const InextensionalDOFSet*>(cal);
+      int maxN = inexSet->maxOrder();
+      auto calibLbl = vol->getLabel().asCalib();
+      const auto& inj = injInex.contains(id) ? injInex[id] : InjInex{};
+
+      json inexEntry;
+      json modesObj = json::object();
+      for (int n = 2; n <= maxN; ++n) {
+        int off = InextensionalDOFSet::modeOffset(n);
+        std::array<double, 4> injCoeffs = {0., 0., 0., 0.};
+        if (inj.modes.contains(n)) {
+          injCoeffs = inj.modes.at(n);
+        }
+        json modeArr = json::array();
+        for (int k = 0; k < 4; ++k) {
+          uint32_t raw = calibLbl.raw(off + k);
+          auto it = labelToValue.find(raw);
+          double fitted = it != labelToValue.end() ? it->second : 0.0;
+          modeArr.push_back(fitted - injCoeffs[k]);
+        }
+        modesObj[std::to_string(n)] = modeArr;
+      }
+      inexEntry["modes"] = modesObj;
+
+      // alpha
+      uint32_t rawAlpha = calibLbl.raw(inexSet->alphaIdx());
+      auto itA = labelToValue.find(rawAlpha);
+      inexEntry["alpha"] = (itA != labelToValue.end() ? itA->second : 0.0) - inj.alpha;
+
+      // beta
+      uint32_t rawBeta = calibLbl.raw(inexSet->betaIdx());
+      auto itB = labelToValue.find(rawBeta);
+      inexEntry["beta"] = (itB != labelToValue.end() ? itB->second : 0.0) - inj.beta;
+
+      entry["inextensional"] = inexEntry;
     }
     if (write) {
       output.push_back(entry);
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentMath.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentMath.cxx
new file mode 100644
index 0000000000000..52e9c03540d4c
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentMath.cxx
@@ -0,0 +1,54 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3Align/AlignmentMath.h"
+
+#include <cmath>
+
+#include <TMath.h>
+
+#include "ITS3Base/SpecsV2.h"
+#include "MathUtils/Utils.h"
+
+namespace o2::its3::align
+{
+
+std::pair<double, double> computeUV(double gloX, double gloY, double gloZ, int sensorID, double radius)
+{
+  const bool isTop = sensorID % 2 == 0;
+  const double phi = o2::math_utils::to02Pid(std::atan2(gloY, gloX));
+  const double phiBorder1 = o2::math_utils::to02Pid(((isTop ? 0. : 1.) * TMath::Pi()) + std::asin(constants::equatorialGap / 2. / radius));
+  const double phiBorder2 = o2::math_utils::to02Pid(((isTop ? 1. : 2.) * TMath::Pi()) - std::asin(constants::equatorialGap / 2. / radius));
+  const double u = (((phi - phiBorder1) * 2.) / (phiBorder2 - phiBorder1)) - 1.;
+  const double v = ((2. * gloZ + constants::segment::lengthSensitive) / constants::segment::lengthSensitive) - 1.;
+  return {u, v};
+}
+
+TrackSlopes computeTrackSlopes(double snp, double tgl)
+{
+  const double csci = 1. / std::sqrt(1. - (snp * snp));
+  return {.dydx = snp * csci, .dzdx = tgl * csci};
+}
+
+std::vector<double> legendrePols(int order, double x)
+{
+  std::vector<double> p(order + 1);
+  p[0] = 1.;
+  if (order > 0) {
+    p[1] = x;
+  }
+  for (int n = 1; n < order; ++n) {
+    p[n + 1] = ((2 * n + 1) * x * p[n] - n * p[n - 1]) / (n + 1);
+  }
+  return p;
+}
+
+} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx
index d381abc6aa567..72f968bdbf338 100644
--- a/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx
+++ b/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx
@@ -10,8 +10,9 @@
 // or submit itself to any jurisdiction.
 
 #include <cmath>
-#include <memory>
 #include <chrono>
+#include <fstream>
+#include <memory>
 
 #ifdef WITH_OPENMP
 #include <omp.h>
@@ -43,12 +44,13 @@
 #include "ITStracking/IOUtils.h"
 #include "ITS3Reconstruction/IOUtils.h"
 #include "ITS3Align/TrackFit.h"
+#include "ITS3Align/AlignmentMath.h"
 #include "ITS3Align/AlignmentSpec.h"
 #include "ITS3Align/AlignmentParams.h"
 #include "ITS3Align/AlignmentTypes.h"
 #include "ITS3Align/AlignmentHierarchy.h"
+#include "ITS3Align/MisalignmentUtils.h"
 #include "ITS3Align/AlignmentSensors.h"
-#include "MathUtils/LegendrePols.h"
 
 namespace o2::its3::align
 {
@@ -63,30 +65,29 @@ using TrackD = o2::track::TrackParCovD;
 
 namespace
 {
-// compute normalized (u,v) in [-1,1] from global position on a sensor
-std::pair<double, double> computeUV(double gloX, double gloY, double gloZ, int sensorID, double radius)
+DerivativeContext makeDerivativeContext(const FrameInfoExt& frame, const TrackD& trk)
 {
-  const bool isTop = sensorID % 2 == 0;
-  const double phi = o2::math_utils::to02Pid(std::atan2(gloY, gloX));
-  const double phiBorder1 = o2::math_utils::to02Pid(((isTop ? 0. : 1.) * TMath::Pi()) + std::asin(constants::equatorialGap / 2. / radius));
-  const double phiBorder2 = o2::math_utils::to02Pid(((isTop ? 1. : 2.) * TMath::Pi()) - std::asin(constants::equatorialGap / 2. / radius));
-  const double u = (((phi - phiBorder1) * 2.) / (phiBorder2 - phiBorder1)) - 1.;
-  const double v = ((2. * gloZ + constants::segment::lengthSensitive) / constants::segment::lengthSensitive) - 1.;
-  return {u, v};
+  const auto slopes = computeTrackSlopes(trk.getSnp(), trk.getTgl());
+  const bool isITS3 = constants::detID::isDetITS3(frame.sens);
+  return {.sensorID = isITS3 ? constants::detID::getSensorID(frame.sens) : -1,
+          .layerID = isITS3 ? constants::detID::getDetID2Layer(frame.sens) : -1,
+          .measX = frame.x,
+          .measAlpha = frame.alpha,
+          .measZ = frame.positionTrackingFrame[1],
+          .trkY = trk.getY(),
+          .trkZ = trk.getZ(),
+          .snp = trk.getSnp(),
+          .tgl = trk.getTgl(),
+          .dydx = slopes.dydx,
+          .dzdx = slopes.dzdx};
 }
 
-// evaluate Legendre polynomials P_0(x) through P_order(x) via recurrence
-std::vector<double> legendrePols(int order, double x)
+Matrix36 getRigidBodyBaseDerivatives(const DerivativeContext& ctx)
 {
-  std::vector<double> p(order + 1);
-  p[0] = 1.;
-  if (order > 0) {
-    p[1] = x;
-  }
-  for (int n = 1; n < order; ++n) {
-    p[n + 1] = ((2 * n + 1) * x * p[n] - n * p[n - 1]) / (n + 1);
-  }
-  return p;
+  static const RigidBodyDOFSet sRigidBodyBasis;
+  Eigen::MatrixXd dyn(3, sRigidBodyBasis.nDOFs());
+  sRigidBodyBasis.fillDerivatives(ctx, dyn);
+  return dyn;
 }
 } // namespace
 
@@ -152,8 +153,8 @@ class AlignmentSpec final : public Task
   GTrackID::mask_t mTracksSrc;
   int mNThreads{1};
   const AlignmentParams* mParams{nullptr};
-  std::array<o2::math_utils::Legendre2DPolynominal, 6> mDeformations; // one per sensorID (0-5)
-  std::array<Eigen::Matrix<double, 6, 1>, 6> mRigidBodyParams;        // (dx,dy,dz,rx,ry,rz) in LOC per sensorID
+  MisalignmentModel mMisalignment;
+  std::array<Eigen::Matrix<double, 6, 1>, 6> mRigidBodyParams; // (dx,dy,dz,rx,ry,rz) in LOC per sensorID
 };
 
 void AlignmentSpec::init(InitContext& ic)
@@ -323,7 +324,8 @@ void AlignmentSpec::process()
           // this is the derivative in TRK but we want to align in LOC
           // so dr/da_(LOC) = dr/da_(TRK) * da_(TRK)/da_(LOC)
           const auto* tileVol = mChip2Hiearchy.at(lbl);
-          Matrix36 der = getRigidBodyDerivatives(wTrk);
+          const auto derCtx = makeDerivativeContext(frame, wTrk);
+          Matrix36 der = getRigidBodyBaseDerivatives(derCtx);
 
           // count rigid body columns: only volumes with real DOFs (not DOFPseudo)
           int nColRB{0};
@@ -375,39 +377,16 @@ void AlignmentSpec::process()
             }
           }
 
-          // 3) calibration derivatives (e.g. Legendre for ITS3 sensors, apply directly on the whole sensor, not on inidividual tiles)
-          if (calibSet && calibSet->type() == DOFSet::Type::Legendre) {
-            const auto* legSet = static_cast<const LegendreDOFSet*>(calibSet);
-            const int N = legSet->order();
-            const int sensorID = constants::detID::getSensorID(frame.sens);
-            const int layerID = constants::detID::getDetID2Layer(frame.sens);
-
-            const double r = frame.x;
-            const double gX = r * std::cos(frame.alpha);
-            const double gY = r * std::sin(frame.alpha);
-            const double gZ = frame.positionTrackingFrame[1];
-            auto [u, v] = computeUV(gX, gY, gZ, sensorID, constants::radii[layerID]);
-
-            const double snp = wTrk.getSnp();
-            const double tgl = wTrk.getTgl();
-            const double csci = 1. / std::sqrt(1. - (snp * snp));
-            const double dydx = snp * csci;
-            const double dzdx = tgl * csci;
-
-            auto pu = legendrePols(N, u);
-            auto pv = legendrePols(N, v);
-
-            int legIdx = 0;
-            const int legColStart = nColRB;
-            for (int i = 0; i <= N; ++i) {
-              for (int j = 0; j <= i; ++j) {
-                const double basis = pu[j] * pv[i - j];
-                gLabels.push_back(sensorVol->getLabel().asCalib().rawGBL(legIdx));
-                gDer(0, legColStart + legIdx) = dydx * basis;
-                gDer(1, legColStart + legIdx) = dzdx * basis;
-                ++legIdx;
-              }
+          // 3) calibration derivatives (apply directly on the whole sensor, not on individual tiles)
+          if (calibSet) {
+            const int nd = calibSet->nDOFs();
+            Eigen::MatrixXd calDer(3, nd);
+            calibSet->fillDerivatives(derCtx, calDer);
+            for (int iDOF = 0; iDOF < nd; ++iDOF) {
+              gLabels.push_back(sensorVol->getLabel().asCalib().rawGBL(iDOF));
             }
+            gDer.middleCols(curCol, nd) = calDer;
+            curCol += nd;
           }
           point.addGlobals(gLabels, gDer);
         }
@@ -514,32 +493,24 @@ void AlignmentSpec::updateTimeDependentParams(ProcessingContext& pc)
 
     buildHierarchy();
 
-    if (mParams->doMisalignmentLeg || mParams->doMisalignmentRB) {
-      TMatrixD null(1, 1);
-      null(0, 0) = 0;
-      for (int i = 0; i < 6; ++i) {
-        mDeformations[i] = o2::math_utils::Legendre2DPolynominal(null);
-        mRigidBodyParams[i].setZero();
+    if (mParams->doMisalignmentLeg || mParams->doMisalignmentRB || mParams->doMisalignmentInex) {
+      mMisalignment = {};
+      for (auto& rb : mRigidBodyParams) {
+        rb.setZero();
       }
       if (!mParams->misAlgJson.empty()) {
-        using json = nlohmann::json;
-        std::ifstream f(mParams->misAlgJson);
-        auto data = json::parse(f);
-        for (const auto& item : data) {
-          int id = item["id"].get<int>();
-          if (mParams->doMisalignmentLeg && item.contains("matrix")) {
-            auto v = item["matrix"].get<std::vector<std::vector<double>>>();
-            TMatrixD m(v.size(), v[v.size() - 1].size());
-            for (size_t r{0}; r < v.size(); ++r) {
-              for (size_t c{0}; c < v[r].size(); ++c) {
-                m(r, c) = v[r][c];
-              }
+        mMisalignment = loadMisalignmentModel(mParams->misAlgJson);
+        if (mParams->doMisalignmentRB) {
+          using json = nlohmann::json;
+          std::ifstream f(mParams->misAlgJson);
+          auto data = json::parse(f);
+          for (const auto& item : data) {
+            int id = item["id"].get<int>();
+            if (!item.contains("rigidBody")) {
+              continue;
             }
-            mDeformations[id] = o2::math_utils::Legendre2DPolynominal(m);
-          }
-          if (mParams->doMisalignmentRB && item.contains("rigidBody")) {
             auto rb = item["rigidBody"].get<std::vector<double>>();
-            for (int k = 0; k < 6 && k < (int)rb.size(); ++k) {
+            for (int k = 0; k < 6 && k < static_cast<int>(rb.size()); ++k) {
               mRigidBodyParams[id](k) = rb[k];
             }
           }
@@ -848,6 +819,12 @@ bool AlignmentSpec::applyMisalignment(Eigen::Vector2d& res, const FrameInfoExt&
 
   const int sensorID = constants::detID::getSensorID(frame.sens);
   const int layerID = constants::detID::getDetID2Layer(frame.sens);
+  const MisalignmentFrame misFrame{
+    .sensorID = sensorID,
+    .layerID = layerID,
+    .x = frame.x,
+    .alpha = frame.alpha,
+    .z = frame.positionTrackingFrame[1]};
 
   // --- Legendre deformation (non-rigid-body) ---
   if (mParams->doMisalignmentLeg && mIsITS3 && mUseMC) {
@@ -866,36 +843,18 @@ bool AlignmentSpec::applyMisalignment(Eigen::Vector2d& res, const FrameInfoExt&
     }
     o2::track::TrackParD mcPar(xyz, pxyz, TMath::Nint(pPDG->Charge() / 3), false);
 
-    const double r = frame.x;
-    const double gloX = r * std::cos(frame.alpha);
-    const double gloY = r * std::sin(frame.alpha);
-    const double gloZ = frame.positionTrackingFrame[1];
-    auto [u, v] = computeUV(gloX, gloY, gloZ, sensorID, constants::radii[layerID]);
-    const double h = mDeformations[sensorID](u, v);
-
     auto mcAtCl = mcPar;
     if (!mcAtCl.rotate(frame.alpha) || !prop->PropagateToXBxByBz(mcAtCl, frame.x)) {
       return false;
     }
 
-    const double snp = mcAtCl.getSnp();
-    const double tgl = mcAtCl.getTgl();
-    const double csci = 1. / std::sqrt(1. - (snp * snp));
-    const double dydx = snp * csci;
-    const double dzdx = tgl * csci;
-    const double dy = dydx * h;
-    const double dz = dzdx * h;
-
-    const double newGloY = (r * std::sin(frame.alpha)) + (dy * std::cos(frame.alpha));
-    const double newGloX = (r * std::cos(frame.alpha)) - (dy * std::sin(frame.alpha));
-    const double newGloZ = gloZ + dz;
-    auto [uNew, vNew] = computeUV(newGloX, newGloY, newGloZ, sensorID, constants::radii[layerID]);
-    if (std::abs(uNew) > 1. || std::abs(vNew) > 1.) {
+    const auto shift = evaluateLegendreShift(mMisalignment[sensorID], misFrame, computeTrackSlopes(mcAtCl.getSnp(), mcAtCl.getTgl()));
+    if (!shift.accepted) {
       return false;
     }
 
-    res[0] += dy;
-    res[1] += dz;
+    res[0] += shift.dy;
+    res[1] += shift.dz;
   }
 
   // --- Rigid body misalignment ---
@@ -910,7 +869,7 @@ bool AlignmentSpec::applyMisalignment(Eigen::Vector2d& res, const FrameInfoExt&
     const auto* tileVol = mChip2Hiearchy.at(lbl);
 
     // derivative in TRK frame (3x6: rows = dy, dz, dsnp)
-    Matrix36 der = getRigidBodyDerivatives(wTrk);
+    Matrix36 der = getRigidBodyBaseDerivatives(makeDerivativeContext(frame, wTrk));
 
     // TRK -> tile LOC
     const double posTrk[3] = {frame.x, 0., 0.};
@@ -929,6 +888,26 @@ bool AlignmentSpec::applyMisalignment(Eigen::Vector2d& res, const FrameInfoExt&
     res[1] += shift[1]; // dz
   }
 
+  // --- In-extensional deformation ---
+  // displacement field u(phi,z) = (u_phi, u_z, u_r)
+  //   dy = -u_phi + y' * u_r,  dz = -u_z + z' * u_r
+  if (mParams->doMisalignmentInex) {
+    const auto shift = evaluateInextensionalShift(mMisalignment[sensorID], misFrame, computeTrackSlopes(wTrk.getSnp(), wTrk.getTgl()));
+    res[0] += shift.dy;
+    res[1] += shift.dz;
+  }
+
+  if (mOutOpt[OutputOpt::MisRes]) {
+    (*mDBGOut) << "mis"
+               << "dy=" << res[0]
+               << "dz=" << res[1]
+               << "sens=" << sensorID
+               << "lay=" << layerID
+               << "z=" << frame.positionTrackingFrame[1]
+               << "phi=" << frame.alpha
+               << "\n";
+  }
+
   return true;
 }
 
diff --git a/Detectors/Upgrades/ITS3/alignment/src/MisalignmentUtils.cxx b/Detectors/Upgrades/ITS3/alignment/src/MisalignmentUtils.cxx
new file mode 100644
index 0000000000000..ee5198ee98e0c
--- /dev/null
+++ b/Detectors/Upgrades/ITS3/alignment/src/MisalignmentUtils.cxx
@@ -0,0 +1,151 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITS3Align/MisalignmentUtils.h"
+
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+#include <vector>
+
+#include <TMatrixD.h>
+#include <nlohmann/json.hpp>
+
+#include "Framework/Logger.h"
+#include "ITS3Base/SpecsV2.h"
+
+namespace o2::its3::align
+{
+
+bool MisalignmentModel::empty() const noexcept
+{
+  return std::all_of(sensors.begin(), sensors.end(), [](const auto& sensor) { return sensor.empty(); });
+}
+
+MisalignmentModel loadMisalignmentModel(const std::string& jsonPath)
+{
+  MisalignmentModel model;
+  if (jsonPath.empty()) {
+    return model;
+  }
+
+  std::ifstream f(jsonPath);
+  if (!f.is_open()) {
+    LOGP(fatal, "Cannot open misalignment JSON file: {}", jsonPath);
+  }
+
+  using json = nlohmann::json;
+  const auto data = json::parse(f);
+  for (const auto& item : data) {
+    const int id = item["id"].get<int>();
+    if (id < 0 || id >= static_cast<int>(MisalignmentModel::NSensors)) {
+      LOGP(fatal, "Misalignment sensor id {} out of range [0, {}) in {}", id, MisalignmentModel::NSensors, jsonPath);
+    }
+
+    auto& sensor = model[id];
+    if (item.contains("matrix")) {
+      auto v = item["matrix"].get<std::vector<std::vector<double>>>();
+      if (v.empty()) {
+        LOGP(fatal, "Legendre matrix for sensor {} is empty in {}", id, jsonPath);
+      }
+      TMatrixD m(v.size(), v.back().size());
+      for (std::size_t r{0}; r < v.size(); ++r) {
+        for (std::size_t c{0}; c < v[r].size(); ++c) {
+          m(r, c) = v[r][c];
+        }
+      }
+      sensor.legendre = o2::math_utils::Legendre2DPolynominal(m);
+      sensor.hasLegendre = true;
+    }
+    if (item.contains("inextensional")) {
+      const auto& inex = item["inextensional"];
+      sensor.hasInextensional = true;
+      if (inex.contains("modes")) {
+        for (const auto& [key, val] : inex["modes"].items()) {
+          sensor.inextensional.modes[std::stoi(key)] = val.get<std::array<double, 4>>();
+        }
+      }
+      if (inex.contains("alpha")) {
+        sensor.inextensional.alpha = inex["alpha"].get<double>();
+      }
+      if (inex.contains("beta")) {
+        sensor.inextensional.beta = inex["beta"].get<double>();
+      }
+    }
+  }
+
+  return model;
+}
+
+MisalignmentShift evaluateLegendreShift(const SensorMisalignment& sensor, const MisalignmentFrame& frame, const TrackSlopes& slopes)
+{
+  MisalignmentShift shift;
+  if (!sensor.hasLegendre) {
+    return shift;
+  }
+
+  const double gloX = frame.x * std::cos(frame.alpha);
+  const double gloY = frame.x * std::sin(frame.alpha);
+  const double gloZ = frame.z;
+  auto [u, v] = computeUV(gloX, gloY, gloZ, frame.sensorID, constants::radii[frame.layerID]);
+  const double h = sensor.legendre(u, v);
+
+  shift.dy = slopes.dydx * h;
+  shift.dz = slopes.dzdx * h;
+
+  const double newGloY = gloY + (shift.dy * std::cos(frame.alpha));
+  const double newGloX = gloX - (shift.dy * std::sin(frame.alpha));
+  const double newGloZ = gloZ + shift.dz;
+  auto [uNew, vNew] = computeUV(newGloX, newGloY, newGloZ, frame.sensorID, constants::radii[frame.layerID]);
+  shift.accepted = std::abs(uNew) <= 1. && std::abs(vNew) <= 1.;
+  return shift;
+}
+
+MisalignmentShift evaluateInextensionalShift(const SensorMisalignment& sensor, const MisalignmentFrame& frame, const TrackSlopes& slopes)
+{
+  MisalignmentShift shift;
+  if (!sensor.hasInextensional) {
+    return shift;
+  }
+
+  const double r = constants::radii[frame.layerID];
+  const double phi = std::atan2(r * std::sin(frame.alpha), r * std::cos(frame.alpha));
+  const double z = frame.z;
+  const auto& inex = sensor.inextensional;
+
+  double uz = 0., uphi = 0., ur = 0.;
+  for (const auto& [n, coeffs] : inex.modes) {
+    const double a_n = coeffs[0], b_n = coeffs[1], c_n = coeffs[2], d_n = coeffs[3];
+    const double sn = std::sin(n * phi);
+    const double cn = std::cos(n * phi);
+    const int n2 = n * n;
+
+    const double fn = (a_n * cn) + (b_n * sn);
+    const double fpn = (-n * a_n * sn) + (n * b_n * cn);
+    const double fppn = (-n2 * a_n * cn) - (n2 * b_n * sn);
+    const double gn = (c_n * cn) + (d_n * sn);
+    const double gpn = (-n * c_n * sn) + (n * d_n * cn);
+
+    uz += fn;
+    uphi += -(z / r) * fpn + gn;
+    ur += (z / r) * fppn - gpn;
+  }
+
+  uz += inex.alpha * phi;
+  uphi += -(z / r) * inex.alpha + inex.beta * phi;
+  ur += -inex.beta;
+
+  shift.dy = -uphi + (slopes.dydx * ur);
+  shift.dz = -uz + (slopes.dzdx * ur);
+  return shift;
+}
+
+} // namespace o2::its3::align
diff --git a/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx b/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
index 4ce2c79cb23f1..63a08d1c9c6ab 100644
--- a/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
+++ b/Detectors/Upgrades/ITS3/study/src/TrackingStudy.cxx
@@ -11,12 +11,10 @@
 
 #include <vector>
 #include <cmath>
-#include <fstream>
 
 #include <TStopwatch.h>
 #include <TF1.h>
 #include <Eigen/Dense>
-#include <nlohmann/json.hpp>
 
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
@@ -38,6 +36,7 @@
 #include "ITS3Reconstruction/IOUtils.h"
 #include "ITS3TrackingStudy/ITS3TrackingStudyParam.h"
 #include "ITS3TrackingStudy/ParticleInfoExt.h"
+#include "ITS3Align/MisalignmentUtils.h"
 #include "ITS3Align/TrackFit.h"
 #include "ReconstructionDataFormats/DCA.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
@@ -47,7 +46,6 @@
 #include "SimulationDataFormat/MCEventLabel.h"
 #include "SimulationDataFormat/MCUtils.h"
 #include "Steer/MCKinematicsReader.h"
-#include "MathUtils/LegendrePols.h"
 #include "Framework/Logger.h"
 
 namespace o2::its3::study
@@ -153,7 +151,7 @@ class TrackingStudySpec : public Task
   o2::steer::MCKinematicsReader mMCReader;                // reader of MC information
   const o2::its3::TopologyDictionary* mITSDict = nullptr; // cluster patterns dictionary
   o2::globaltracking::RecoContainer mRecoData;
-  std::array<o2::math_utils::Legendre2DPolynominal, 6> mDeformations; // one per sensorID (0-5)
+  align::MisalignmentModel mMisalignment;
 };
 
 void TrackingStudySpec::init(InitContext& ic)
@@ -186,26 +184,9 @@ void TrackingStudySpec::updateTimeDependentParams(ProcessingContext& pc)
     o2::its::GeometryTGeo::Instance()->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G, o2::math_utils::TransformType::T2G));
     mParams = &ITS3TrackingStudyParam::Instance();
     if (mParams->doMisalignment) {
-      TMatrixD null(1, 1);
-      null(0, 0) = 0;
-      for (int i = 0; i < 6; ++i) {
-        mDeformations[i] = o2::math_utils::Legendre2DPolynominal(null);
-      }
+      mMisalignment = {};
       if (!mParams->misAlgJson.empty()) {
-        using json = nlohmann::json;
-        std::ifstream f(mParams->misAlgJson);
-        auto data = json::parse(f);
-        for (const auto& item : data) {
-          int id = item["id"].get<int>();
-          auto v = item["matrix"].get<std::vector<std::vector<double>>>();
-          TMatrixD m(v.size(), v[v.size() - 1].size());
-          for (size_t r{0}; r < v.size(); ++r) {
-            for (size_t c{0}; c < v[r].size(); ++c) {
-              m(r, c) = v[r][c];
-            }
-          }
-          mDeformations[id] = o2::math_utils::Legendre2DPolynominal(m);
-        }
+        mMisalignment = align::loadMisalignmentModel(mParams->misAlgJson);
       }
     }
   }
@@ -984,17 +965,6 @@ void TrackingStudySpec::doMisalignmentStudy()
 
   int goodRefit{0}, notPassedSel{0}, fitFail{0}, fitFailMis{0};
 
-  // compute normalized (u,v) in [-1,1] from global position
-  auto computeUV = [](float gloX, float gloY, float gloZ, int sensorID, float radius) -> std::pair<double, double> {
-    const bool isTop = sensorID % 2 == 0;
-    const double phi = o2::math_utils::to02Pi(std::atan2(gloY, gloX));
-    const double phiBorder1 = o2::math_utils::to02Pi(((isTop ? 0. : 1.) * TMath::Pi()) + std::asin(constants::equatorialGap / 2. / radius));
-    const double phiBorder2 = o2::math_utils::to02Pi(((isTop ? 1. : 2.) * TMath::Pi()) - std::asin(constants::equatorialGap / 2. / radius));
-    const double u = (((phi - phiBorder1) * 2.) / (phiBorder2 - phiBorder1)) - 1.;
-    const double v = ((2. * gloZ + constants::segment::lengthSensitive) / constants::segment::lengthSensitive) - 1.;
-    return {u, v};
-  };
-
   float chi2{0};
   auto writeTree = [&](const char* treeName,
                        const std::array<const TrackingCluster*, 8>& clArr,
@@ -1102,8 +1072,8 @@ void TrackingStudySpec::doMisalignmentStudy()
     }
     writeTree("idealRes", clArr, extrapOut, extrapInw, lbl);
 
-    // Propagate MC truth to each cluster's (alpha, x) to get true track direction,
-    // then compute dy = dydx*h(u,v), dz = dzdx*h(u,v) - first Newton step.
+    // Propagate MC truth to each cluster's (alpha, x) to get true track direction.
+    // The shared misalignment evaluators then provide the tracking-frame dy/dz shift.
     const auto mcTrk = mMCReader.getTrack(lbl);
     if (!mcTrk) {
       continue;
@@ -1132,14 +1102,7 @@ void TrackingStudySpec::doMisalignmentStudy()
       }
       const int sensorID = constants::detID::getSensorID(sens);
       const int layerID = constants::detID::getDetID2Layer(sens);
-
-      // compute h(u,v) at this cluster
-      const float r = orig.getX();
-      const float gloX = r * std::cos(orig.alpha);
-      const float gloY = r * std::sin(orig.alpha);
-      const float gloZ = orig.getZ();
-      auto [u, v] = computeUV(gloX, gloY, gloZ, sensorID, constants::radii[layerID]);
-      const double h = mDeformations[sensorID](u, v);
+      const auto& sensorMis = mMisalignment[sensorID];
 
       // propagate MC track to cluster's tracking frame to get true slopes
       auto mcAtCl = mcPar;
@@ -1147,28 +1110,31 @@ void TrackingStudySpec::doMisalignmentStudy()
         clArrMis[1 + iLay] = nullptr; // can't compute slopes -> drop cluster
         continue;
       }
-      const float snp = mcAtCl.getSnp();
-      const float tgl = mcAtCl.getTgl();
-      const float csci = 1.f / std::sqrt(1.f - (snp * snp));
-      const float dydx = snp * csci;
-      const float dzdx = tgl * csci;
-      const float dy = dydx * static_cast<float>(h);
-      const float dz = dzdx * static_cast<float>(h);
-
-      // check if shifted position is still within sensor acceptance
-      const float newGloY = (r * std::sin(orig.alpha)) + (dy * std::cos(orig.alpha));
-      const float newGloX = (r * std::cos(orig.alpha)) - (dy * std::sin(orig.alpha));
-      const float newGloZ = gloZ + dz;
-      auto [uNew, vNew] = computeUV(newGloX, newGloY, newGloZ, sensorID, constants::radii[layerID]);
-      if (std::abs(uNew) > 1. || std::abs(vNew) > 1.) {
-        clArrMis[1 + iLay] = nullptr; // shifted outside acceptance
-        continue;
+      const align::MisalignmentFrame misFrame{
+        .sensorID = sensorID,
+        .layerID = layerID,
+        .x = orig.getX(),
+        .alpha = orig.alpha,
+        .z = orig.getZ()};
+      const auto slopes = align::computeTrackSlopes(mcAtCl.getSnp(), mcAtCl.getTgl());
+
+      align::MisalignmentShift totalShift;
+      if (sensorMis.hasLegendre) {
+        const auto shift = align::evaluateLegendreShift(sensorMis, misFrame, slopes);
+        if (!shift.accepted) {
+          clArrMis[1 + iLay] = nullptr; // shifted outside acceptance
+          continue;
+        }
+        totalShift += shift;
+      }
+      if (sensorMis.hasInextensional) {
+        totalShift += align::evaluateInextensionalShift(sensorMis, misFrame, slopes);
       }
 
       // create shifted copy: keep x=r (nominal), shift y and z
       misClArr[iLay] = orig;
-      misClArr[iLay].setY(orig.getY() + dy);
-      misClArr[iLay].setZ(orig.getZ() + dz);
+      misClArr[iLay].setY(orig.getY() + totalShift.dy);
+      misClArr[iLay].setZ(orig.getZ() + totalShift.dz);
       misClArr[iLay].setSigmaY2(orig.getSigmaY2() + (mParams->misAlgExtCY[sensorID] * mParams->misAlgExtCY[sensorID]));
       misClArr[iLay].setSigmaZ2(orig.getSigmaZ2() + (mParams->misAlgExtCZ[sensorID] * mParams->misAlgExtCZ[sensorID]));
       clArrMis[1 + iLay] = &misClArr[iLay];

From 4b43e4050f38d86147b85fb38aa9337d5d4496ca Mon Sep 17 00:00:00 2001
From: Francesco Noferini <noferini@bo.infn.it>
Date: Tue, 7 Apr 2026 12:27:18 +0200
Subject: [PATCH 1526/1764] require min num of entries for TOF Diagnostic
 calibs (#15249)

---
 .../include/TOFCalibration/TOFDiagnosticCalibrator.h   |  9 ++++++---
 .../TOF/calibration/src/TOFDiagnosticCalibrator.cxx    | 10 ++++++++++
 .../testWorkflow/TOFDiagnosticCalibratorSpec.h         |  8 +++++---
 .../testWorkflow/tof-diagnostic-workflow.cxx           |  4 +++-
 4 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/Detectors/TOF/calibration/include/TOFCalibration/TOFDiagnosticCalibrator.h b/Detectors/TOF/calibration/include/TOFCalibration/TOFDiagnosticCalibrator.h
index 7b23df6040d3d..fccfcf51fdaa9 100644
--- a/Detectors/TOF/calibration/include/TOFCalibration/TOFDiagnosticCalibrator.h
+++ b/Detectors/TOF/calibration/include/TOFCalibration/TOFDiagnosticCalibrator.h
@@ -31,9 +31,9 @@ class TOFDiagnosticCalibrator final : public o2::calibration::TimeSlotCalibratio
   int mRunNumber = -1;
 
  public:
-  TOFDiagnosticCalibrator() = default;
+  TOFDiagnosticCalibrator(int minROwin = 100) : mMinROwin(minROwin) {}
   ~TOFDiagnosticCalibrator() final = default;
-  bool hasEnoughData(const Slot& slot) const final { return true; }
+  bool hasEnoughData(const Slot& slot) const final;
   void initOutput() final;
   void finalizeSlot(Slot& slot) final;
   Slot& emplaceNewSlot(bool front, TFType tstart, TFType tend) final;
@@ -43,12 +43,15 @@ class TOFDiagnosticCalibrator final : public o2::calibration::TimeSlotCalibratio
   const std::vector<Diagnostic>& getDiagnosticVector() const { return mDiagnosticVector; }
   const CcdbObjectInfoVector& getDiagnosticInfoVector() const { return mccdbInfoVector; }
   CcdbObjectInfoVector& getDiagnosticInfoVector() { return mccdbInfoVector; }
+  int getMinROwin() const { return mMinROwin; }
+  void setMinROwin(int rowin) { mMinROwin = rowin; }
 
  private:
   CcdbObjectInfoVector mccdbInfoVector;
   std::vector<Diagnostic> mDiagnosticVector;
+  int mMinROwin; // minimal number of readout windows needed to finalize the object
 
-  ClassDefOverride(TOFDiagnosticCalibrator, 1);
+  ClassDefOverride(TOFDiagnosticCalibrator, 2);
 };
 
 } // end namespace tof
diff --git a/Detectors/TOF/calibration/src/TOFDiagnosticCalibrator.cxx b/Detectors/TOF/calibration/src/TOFDiagnosticCalibrator.cxx
index 9a4118dbba493..f238d69bb75ed 100644
--- a/Detectors/TOF/calibration/src/TOFDiagnosticCalibrator.cxx
+++ b/Detectors/TOF/calibration/src/TOFDiagnosticCalibrator.cxx
@@ -28,7 +28,17 @@ void TOFDiagnosticCalibrator::initOutput()
   mccdbInfoVector.clear();
   mDiagnosticVector.clear();
 }
+//----------------------------------------------------------
+bool TOFDiagnosticCalibrator::hasEnoughData(const Slot& slot) const
+{
+  const Diagnostic* diag = slot.getContainer();
 
+  if (diag->getFrequencyROW() < mMinROwin) {
+    return false;
+  }
+
+  return true;
+}
 //----------------------------------------------------------
 void TOFDiagnosticCalibrator::finalizeSlot(Slot& slot)
 {
diff --git a/Detectors/TOF/calibration/testWorkflow/TOFDiagnosticCalibratorSpec.h b/Detectors/TOF/calibration/testWorkflow/TOFDiagnosticCalibratorSpec.h
index 7887ff848d544..91b931f3b96b3 100644
--- a/Detectors/TOF/calibration/testWorkflow/TOFDiagnosticCalibratorSpec.h
+++ b/Detectors/TOF/calibration/testWorkflow/TOFDiagnosticCalibratorSpec.h
@@ -37,7 +37,7 @@ namespace calibration
 class TOFDiagnosticCalibDevice : public o2::framework::Task
 {
  public:
-  TOFDiagnosticCalibDevice(std::shared_ptr<o2::base::GRPGeomRequest> req, int runnumber = -1) : mCCDBRequest(req), mRunNumber(runnumber) {}
+  TOFDiagnosticCalibDevice(std::shared_ptr<o2::base::GRPGeomRequest> req, int runnumber = -1, int rowinMin = 100000) : mCCDBRequest(req), mRunNumber(runnumber), mMinROwin(rowinMin) {}
   void init(o2::framework::InitContext& ic) final
   {
     o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
@@ -47,6 +47,7 @@ class TOFDiagnosticCalibDevice : public o2::framework::Task
     mCalibrator->setSlotLength(slotL);
     mCalibrator->setMaxSlotsDelay(delay);
     mCalibrator->setRunNumber(mRunNumber);
+    mCalibrator->setMinROwin(mMinROwin);
   }
 
   void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
@@ -75,6 +76,7 @@ class TOFDiagnosticCalibDevice : public o2::framework::Task
   std::unique_ptr<o2::tof::TOFDiagnosticCalibrator> mCalibrator;
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;
   int mRunNumber = -1;
+  int mMinROwin = 100000;
 
   //________________________________________________________________
   void sendOutput(DataAllocator& output)
@@ -104,7 +106,7 @@ class TOFDiagnosticCalibDevice : public o2::framework::Task
 namespace framework
 {
 
-DataProcessorSpec getTOFDiagnosticCalibDeviceSpec(int runnumber)
+DataProcessorSpec getTOFDiagnosticCalibDeviceSpec(int runnumber, int rowinMin)
 {
   using device = o2::calibration::TOFDiagnosticCalibDevice;
   using clbUtils = o2::calibration::Utils;
@@ -125,7 +127,7 @@ DataProcessorSpec getTOFDiagnosticCalibDeviceSpec(int runnumber)
     "tof-diagnostic-calibration",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<device>(ccdbRequest, runnumber)},
+    AlgorithmSpec{adaptFromTask<device>(ccdbRequest, runnumber, rowinMin)},
     Options{
       {"tf-per-slot", VariantType::UInt32, 5u, {"number of TFs per calibration time slot"}},
       {"max-delay", VariantType::UInt32, 3u, {"number of slots in past to consider"}}}};
diff --git a/Detectors/TOF/calibration/testWorkflow/tof-diagnostic-workflow.cxx b/Detectors/TOF/calibration/testWorkflow/tof-diagnostic-workflow.cxx
index 3cde7be96867a..b45fcc2b5498c 100644
--- a/Detectors/TOF/calibration/testWorkflow/tof-diagnostic-workflow.cxx
+++ b/Detectors/TOF/calibration/testWorkflow/tof-diagnostic-workflow.cxx
@@ -19,6 +19,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 {
   // option allowing to set parameters
   workflowOptions.push_back(ConfigParamSpec{"tof-dia-run-number", o2::framework::VariantType::Int, -1, {"run number"}});
+  workflowOptions.push_back(ConfigParamSpec{"tof-dia-min-rowin", o2::framework::VariantType::Int, 100000, {"min number of TOF Readout Windows, def=100k (3 s)"}});
 }
 
 // ------------------------------------------------------------------
@@ -29,6 +30,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   WorkflowSpec specs;
   auto runnumber = configcontext.options().get<int>("tof-dia-run-number");
-  specs.emplace_back(getTOFDiagnosticCalibDeviceSpec(runnumber));
+  auto rowinMin = configcontext.options().get<int>("tof-dia-min-rowin");
+  specs.emplace_back(getTOFDiagnosticCalibDeviceSpec(runnumber, rowinMin));
   return specs;
 }

From 5b27406094d6e12bc2daeb32bf6a25bebe1d7f95 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 5 Apr 2026 21:52:34 +0200
Subject: [PATCH 1527/1764] DPL: refactor InputSpan

Now that navigating the MessageSet does not have an index anymore
it does not make sense to use a random accessor to implement the
InputSpan::Iterator, because that results in an O(N^2) loop for
normal linear iterations. It is much better to simply implement
a proper advancement operator, so that looping stays O(N).

This resumes the performance when iterating on old-style multiparts
which are apparently still used in some cases.

General modernization of InputSpan also done.
---
 .../Core/include/Framework/DataModelViews.h   |   6 +-
 Framework/Core/include/Framework/DataRef.h    |  10 ++
 .../Core/include/Framework/InputRecord.h      |  47 +++++--
 Framework/Core/include/Framework/InputSpan.h  | 130 ++++++++++--------
 .../Core/src/CompletionPolicyHelpers.cxx      |   6 +-
 Framework/Core/src/DataProcessingDevice.cxx   |  41 +++---
 Framework/Core/src/DataRelayer.cxx            |  62 +++++----
 Framework/Core/src/InputRecord.cxx            |  10 ++
 Framework/Core/src/InputSpan.cxx              |  24 +---
 Framework/Core/test/benchmark_InputRecord.cxx |  14 +-
 Framework/Core/test/test_CompletionPolicy.cxx |   7 +-
 Framework/Core/test/test_InputRecord.cxx      |  12 +-
 .../Core/test/test_InputRecordWalker.cxx      |  16 +--
 Framework/Core/test/test_InputSpan.cxx        |  12 +-
 Framework/Utils/test/RawPageTestData.h        |  14 +-
 Framework/Utils/test/test_RootTreeWriter.cxx  |  12 +-
 Utilities/DataSampling/src/Dispatcher.cxx     |   2 +-
 17 files changed, 253 insertions(+), 172 deletions(-)

diff --git a/Framework/Core/include/Framework/DataModelViews.h b/Framework/Core/include/Framework/DataModelViews.h
index 53d6e6615b96e..dd8d65ea16459 100644
--- a/Framework/Core/include/Framework/DataModelViews.h
+++ b/Framework/Core/include/Framework/DataModelViews.h
@@ -16,6 +16,7 @@
 #include "DomainInfoHeader.h"
 #include "SourceInfoHeader.h"
 #include "Headers/DataHeader.h"
+#include "Framework/DataRef.h"
 #include "Framework/TimesliceSlot.h"
 #include <ranges>
 #include <span>
@@ -80,10 +81,7 @@ struct count_parts {
   }
 };
 
-struct DataRefIndices {
-  size_t headerIdx;
-  size_t payloadIdx;
-};
+// DataRefIndices is defined in Framework/DataRef.h
 
 struct get_pair {
   size_t pairId;
diff --git a/Framework/Core/include/Framework/DataRef.h b/Framework/Core/include/Framework/DataRef.h
index d4cba88b19333..aad667c8c33bd 100644
--- a/Framework/Core/include/Framework/DataRef.h
+++ b/Framework/Core/include/Framework/DataRef.h
@@ -12,6 +12,7 @@
 #define FRAMEWORK_DATAREF_H
 
 #include <cstddef> // for size_t
+#include <compare>
 
 namespace o2
 {
@@ -29,6 +30,15 @@ struct DataRef {
   size_t payloadSize = 0;
 };
 
+/// Raw indices into the message vector for one (header, payload) pair.
+/// Kept in a lightweight header so InputSpan can use it without pulling in FairMQ.
+struct DataRefIndices {
+  size_t headerIdx;
+  size_t payloadIdx;
+  bool operator==(const DataRefIndices&) const = default;
+  auto operator<=>(const DataRefIndices&) const = default;
+};
+
 } // namespace framework
 } // namespace o2
 
diff --git a/Framework/Core/include/Framework/InputRecord.h b/Framework/Core/include/Framework/InputRecord.h
index 96963f88524be..d2e152c1bcacc 100644
--- a/Framework/Core/include/Framework/InputRecord.h
+++ b/Framework/Core/include/Framework/InputRecord.h
@@ -13,6 +13,7 @@
 
 #include "Framework/DataRef.h"
 #include "Framework/DataRefUtils.h"
+#include "Framework/InputSpan.h"
 #include "Framework/InputRoute.h"
 #include "Framework/TypeTraits.h"
 #include "Framework/TableConsumer.h"
@@ -202,6 +203,15 @@ class InputRecord
 
   [[nodiscard]] size_t getNofParts(int pos) const;
 
+  /// O(1) access to the part described by @a indices in slot @a pos.
+  [[nodiscard]] DataRef getAtIndices(int pos, DataRefIndices indices) const;
+
+  /// O(1) advance from @a current to the next part's indices in slot @a pos.
+  [[nodiscard]] DataRefIndices nextIndices(int pos, DataRefIndices current) const
+  {
+    return mSpan.nextIndices(pos, current);
+  }
+
   // Given a binding by string, return the associated DataRef
   DataRef getDataRefByString(const char* bindingName, int part = 0) const
   {
@@ -568,8 +578,8 @@ class InputRecord
 
     Iterator() = delete;
 
-    Iterator(ParentType const* parent, size_t position = 0, size_t size = 0)
-      : mPosition(position), mSize(size > position ? size : position), mParent(parent), mElement{nullptr, nullptr, nullptr}
+    Iterator(ParentType const* parent, bool isEnd = false)
+      : mPosition(isEnd ? parent->size() : 0), mSize(parent->size()), mParent(parent), mElement{nullptr, nullptr, nullptr}
     {
       if (mPosition < mSize) {
         if (mParent->isValid(mPosition)) {
@@ -678,18 +688,29 @@ class InputRecord
     using reference = typename BaseType::reference;
     using pointer = typename BaseType::pointer;
     using ElementType = typename std::remove_const<value_type>::type;
-    using iterator = Iterator<SelfType, T>;
-    using const_iterator = Iterator<SelfType, const T>;
+    using iterator = InputSpan::Iterator<SelfType, T>;
+    using const_iterator = InputSpan::Iterator<SelfType, const T>;
+
+    InputRecordIterator(InputRecord const* parent, bool isEnd = false)
+      : BaseType(parent, isEnd)
+    {
+    }
+
+    /// Initial indices for part-level iteration: first part starts at {headerIdx=0, payloadIdx=1}.
+    [[nodiscard]] DataRefIndices initialIndices() const { return {0, 1}; }
+    /// Sentinel used by nextIndicesGetter to signal end-of-slot.
+    [[nodiscard]] DataRefIndices endIndices() const { return {size_t(-1), size_t(-1)}; }
 
-    InputRecordIterator(InputRecord const* parent, size_t position = 0, size_t size = 0)
-      : BaseType(parent, position, size)
+    /// Get element at the given raw message indices in O(1).
+    [[nodiscard]] ElementType getAtIndices(DataRefIndices indices) const
     {
+      return this->parent()->getAtIndices(this->position(), indices);
     }
 
-    /// Get element at {slotindex, partindex}
-    [[nodiscard]] ElementType getByPos(size_t pos) const
+    /// Advance @a current to the next part's indices in O(1).
+    [[nodiscard]] DataRefIndices nextIndices(DataRefIndices current) const
     {
-      return this->parent()->getByPos(this->position(), pos);
+      return this->parent()->nextIndices(this->position(), current);
     }
 
     /// Check if slot is valid, index of part is not used
@@ -709,12 +730,12 @@ class InputRecord
 
     [[nodiscard]] const_iterator begin() const
     {
-      return const_iterator(this, 0, size());
+      return const_iterator(this, size() == 0);
     }
 
     [[nodiscard]] const_iterator end() const
     {
-      return const_iterator(this, size());
+      return const_iterator(this, true);
     }
   };
 
@@ -723,12 +744,12 @@ class InputRecord
 
   [[nodiscard]] const_iterator begin() const
   {
-    return {this, 0, size()};
+    return {this, false};
   }
 
   [[nodiscard]] const_iterator end() const
   {
-    return {this, size()};
+    return {this, true};
   }
 
   InputSpan& span()
diff --git a/Framework/Core/include/Framework/InputSpan.h b/Framework/Core/include/Framework/InputSpan.h
index cf8c8acda6796..dbe270f0e030d 100644
--- a/Framework/Core/include/Framework/InputSpan.h
+++ b/Framework/Core/include/Framework/InputSpan.h
@@ -14,8 +14,8 @@
 #include "Framework/DataRef.h"
 #include <functional>
 
-extern template class std::function<o2::framework::DataRef(size_t)>;
-extern template class std::function<o2::framework::DataRef(size_t, size_t)>;
+extern template class std::function<o2::framework::DataRef(size_t, o2::framework::DataRefIndices)>;
+extern template class std::function<o2::framework::DataRefIndices(size_t, o2::framework::DataRefIndices)>;
 
 namespace o2::framework
 {
@@ -32,37 +32,48 @@ class InputSpan
   InputSpan(InputSpan const&) = delete;
   InputSpan(InputSpan&&) = default;
 
-  /// @a getter is the mapping between an element of the span referred by
-  /// index and the buffer associated.
-  /// @a size is the number of elements in the span.
-  InputSpan(std::function<DataRef(size_t)> getter, size_t size);
+  /// Navigate the message store via the DataRefIndices protocol.
+  /// get_next_pair (DataModelViews.h) provides O(1) sequential advancement for nextIndicesGetter.
+  InputSpan(std::function<size_t(size_t)> nofPartsGetter,
+            std::function<int(size_t)> refCountGetter,
+            std::function<DataRef(size_t, DataRefIndices)> indicesGetter,
+            std::function<DataRefIndices(size_t, DataRefIndices)> nextIndicesGetter,
+            size_t size);
 
-  /// @a getter is the mapping between an element of the span referred by
-  /// index and the buffer associated.
-  /// @a size is the number of elements in the span.
-  InputSpan(std::function<DataRef(size_t, size_t)> getter, size_t size);
+  /// @a i-th element of the InputSpan (O(partidx) sequential scan via indices protocol)
+  [[nodiscard]] DataRef get(size_t i, size_t partidx = 0) const
+  {
+    DataRefIndices idx{0, 1};
+    for (size_t p = 0; p < partidx; ++p) {
+      idx = mNextIndicesGetter(i, idx);
+    }
+    return mIndicesGetter(i, idx);
+  }
 
-  /// @a getter is the mapping between an element of the span referred by
-  /// index and the buffer associated.
-  /// @nofPartsGetter is the getter for the number of parts associated with an index
-  /// @a size is the number of elements in the span.
-  InputSpan(std::function<DataRef(size_t, size_t)> getter, std::function<size_t(size_t)> nofPartsGetter, std::function<int(size_t)> refCountGetter, size_t size);
+  /// Return the DataRef for the part described by @a indices in slot @a slotIdx in O(1).
+  [[nodiscard]] DataRef getAtIndices(size_t slotIdx, DataRefIndices indices) const
+  {
+    return mIndicesGetter(slotIdx, indices);
+  }
 
-  /// @a i-th element of the InputSpan
-  [[nodiscard]] DataRef get(size_t i, size_t partidx = 0) const
+  /// Advance from @a current to the indices of the next part in slot @a slotIdx in O(1).
+  [[nodiscard]] DataRefIndices nextIndices(size_t slotIdx, DataRefIndices current) const
   {
-    return mGetter(i, partidx);
+    return mNextIndicesGetter(slotIdx, current);
   }
 
+  // --- slot-level Iterator protocol (headerIdx doubles as slot position) ---
+  [[nodiscard]] DataRefIndices initialIndices() const { return {0, 0}; }
+  [[nodiscard]] DataRefIndices endIndices() const { return {mSize, 0}; }
+  [[nodiscard]] DataRef getAtIndices(DataRefIndices indices) const { return mIndicesGetter(indices.headerIdx, {0, 1}); }
+  [[nodiscard]] DataRefIndices nextIndices(DataRefIndices current) const { return {current.headerIdx + 1, 0}; }
+
   /// @a number of parts in the i-th element of the InputSpan
   [[nodiscard]] size_t getNofParts(size_t i) const
   {
     if (i >= mSize) {
       return 0;
     }
-    if (!mNofPartsGetter) {
-      return 1;
-    }
     return mNofPartsGetter(i);
   }
 
@@ -94,7 +105,8 @@ class InputSpan
     return get(i).payload;
   }
 
-  /// an iterator class working on position within the a parent class
+  /// An iterator over the elements of a parent container using the DataRefIndices protocol.
+  /// ParentT must provide: initialIndices(), getAtIndices(DataRefIndices), nextIndices(DataRefIndices).
   template <typename ParentT, typename T>
   class Iterator
   {
@@ -110,23 +122,23 @@ class InputSpan
 
     Iterator() = delete;
 
-    Iterator(ParentType const* parent, size_t position = 0, size_t size = 0)
-      : mPosition(position), mSize(size > position ? size : position), mParent(parent), mElement{}
+    Iterator(ParentType const* parent, bool isEnd = false)
+      : mParent(parent),
+        mCurrentIndices(isEnd ? parent->endIndices() : parent->initialIndices()),
+        mElement{}
     {
-      if (mPosition < mSize) {
-        mElement = mParent->get(mPosition);
+      if (mCurrentIndices != mParent->endIndices()) {
+        mElement = mParent->getAtIndices(mCurrentIndices);
       }
     }
 
-    ~Iterator() = default;
-
     // prefix increment
     SelfType& operator++()
     {
-      if (mPosition < mSize && ++mPosition < mSize) {
-        mElement = mParent->get(mPosition);
+      mCurrentIndices = mParent->nextIndices(mCurrentIndices);
+      if (mCurrentIndices != mParent->endIndices()) {
+        mElement = mParent->getAtIndices(mCurrentIndices);
       } else {
-        // reset the element to the default value of the type
         mElement = ElementType{};
       }
       return *this;
@@ -145,16 +157,14 @@ class InputSpan
       return mElement;
     }
 
-    // comparison
     bool operator==(const SelfType& rh) const
     {
-      return mPosition == rh.mPosition;
+      return mCurrentIndices == rh.mCurrentIndices;
     }
 
-    // comparison
-    bool operator!=(const SelfType& rh) const
+    auto operator<=>(const SelfType& rh) const
     {
-      return mPosition != rh.mPosition;
+      return mCurrentIndices <=> rh.mCurrentIndices;
     }
 
     // return pointer to parent instance
@@ -163,22 +173,21 @@ class InputSpan
       return mParent;
     }
 
-    // return current position
+    // return current position (headerIdx serves as the slot index for slot-level iteration)
     [[nodiscard]] size_t position() const
     {
-      return mPosition;
+      return mCurrentIndices.headerIdx;
     }
 
    private:
-    size_t mPosition;
-    size_t mSize;
     ParentType const* mParent;
+    DataRefIndices mCurrentIndices;
     ElementType mElement;
   };
 
   /// @class InputSpanIterator
-  /// An iterator over the input slots
-  /// It supports an iterator interface to access the parts in the slot
+  /// An iterator over the input slots.
+  /// It supports an iterator interface to access the parts in the slot.
   template <typename T>
   class InputSpanIterator : public Iterator<InputSpan, T>
   {
@@ -192,24 +201,26 @@ class InputSpan
     using iterator = Iterator<SelfType, T>;
     using const_iterator = Iterator<SelfType, const T>;
 
-    InputSpanIterator(InputSpan const* parent, size_t position = 0, size_t size = 0)
-      : BaseType(parent, position, size)
+    InputSpanIterator(InputSpan const* parent, bool isEnd = false)
+      : BaseType(parent, isEnd)
     {
     }
 
-    /// Get element at {slotindex, partindex}
-    [[nodiscard]] ElementType get(size_t pos) const
+    /// Initial indices for part-level iteration: first part starts at {headerIdx=0, payloadIdx=1}.
+    [[nodiscard]] DataRefIndices initialIndices() const { return {0, 1}; }
+    /// Sentinel used by nextIndicesGetter to signal end-of-slot.
+    [[nodiscard]] DataRefIndices endIndices() const { return {size_t(-1), size_t(-1)}; }
+
+    /// Get element at the given raw message indices in O(1).
+    [[nodiscard]] ElementType getAtIndices(DataRefIndices indices) const
     {
-      return this->parent()->get(this->position(), pos);
+      return this->parent()->getAtIndices(this->position(), indices);
     }
 
-    /// Check if slot is valid, index of part is not used
-    [[nodiscard]] bool isValid(size_t = 0) const
+    /// Advance @a current to the next part's indices in O(1).
+    [[nodiscard]] DataRefIndices nextIndices(DataRefIndices current) const
     {
-      if (this->position() < this->parent()->size()) {
-        return this->parent()->isValid(this->position());
-      }
-      return false;
+      return this->parent()->nextIndices(this->position(), current);
     }
 
     /// Get number of parts in input slot
@@ -218,15 +229,14 @@ class InputSpan
       return this->parent()->getNofParts(this->position());
     }
 
-    // iterator for the part access
     [[nodiscard]] const_iterator begin() const
     {
-      return const_iterator(this, 0, size());
+      return const_iterator(this, size() == 0);
     }
 
     [[nodiscard]] const_iterator end() const
     {
-      return const_iterator(this, size());
+      return const_iterator(this, true);
     }
   };
 
@@ -236,19 +246,19 @@ class InputSpan
   // supporting read-only access and returning const_iterator
   [[nodiscard]] const_iterator begin() const
   {
-    return {this, 0, size()};
+    return {this, false};
   }
 
-  // supporting read-only access and returning const_iterator
   [[nodiscard]] const_iterator end() const
   {
-    return {this, size()};
+    return {this, true};
   }
 
  private:
-  std::function<DataRef(size_t, size_t)> mGetter;
   std::function<size_t(size_t)> mNofPartsGetter;
   std::function<int(size_t)> mRefCountGetter;
+  std::function<DataRef(size_t, DataRefIndices)> mIndicesGetter;
+  std::function<DataRefIndices(size_t, DataRefIndices)> mNextIndicesGetter;
   size_t mSize;
 };
 
diff --git a/Framework/Core/src/CompletionPolicyHelpers.cxx b/Framework/Core/src/CompletionPolicyHelpers.cxx
index 2b49b8dfa9acd..cc593ee7a2ed9 100644
--- a/Framework/Core/src/CompletionPolicyHelpers.cxx
+++ b/Framework/Core/src/CompletionPolicyHelpers.cxx
@@ -325,9 +325,9 @@ CompletionPolicy CompletionPolicyHelpers::consumeWhenAnyWithAllConditions(const
                                     // But I don't see any possibility to handle this in a better way.
 
     // Iterate on all specs and all inputs simultaneously
-    for (size_t i = 0; i < inputs.size(); ++i) {
-      char const* header = inputs.header(i);
-      auto& spec = specs[i];
+    for (auto it = inputs.begin(), end = inputs.end(); it != end; ++it) {
+      char const* header = (*it).header;
+      auto& spec = specs[it.position()];
       // In case a condition object is not there, we need to wait.
       if (header != nullptr) {
         canConsume = true;
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 6b90747550278..b062f2bf68a75 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -2133,25 +2133,24 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
     } else {
       currentSetOfInputs = relayer.consumeExistingInputsForTimeslice(slot);
     }
-    auto getter = [&currentSetOfInputs](size_t i, size_t partindex) -> DataRef {
-      if ((currentSetOfInputs[i] | count_payloads{}) > partindex) {
-        const char* headerptr = nullptr;
-        const char* payloadptr = nullptr;
-        size_t payloadSize = 0;
-        // - each input can have multiple parts
-        // - "part" denotes a sequence of messages belonging together, the first message of the
-        //   sequence is the header message
-        // - each part has one or more payload messages
-        // - InputRecord provides all payloads as header-payload pair
-        auto const indices = currentSetOfInputs[i] | get_pair{partindex};
-        auto const& headerMsg = currentSetOfInputs[i][indices.headerIdx];
-        auto const& payloadMsg = currentSetOfInputs[i][indices.payloadIdx];
-        headerptr = static_cast<char const*>(headerMsg->GetData());
-        payloadptr = payloadMsg ? static_cast<char const*>(payloadMsg->GetData()) : nullptr;
-        payloadSize = payloadMsg ? payloadMsg->GetSize() : 0;
-        return DataRef{nullptr, headerptr, payloadptr, payloadSize};
+    // Convert raw message indices directly to a DataRef in O(1).
+    // Used both by the sequential PartIterator and as the fallback for positional access.
+    auto indicesGetter = [&currentSetOfInputs](size_t i, DataRefIndices indices) -> DataRef {
+      auto const& msgs = currentSetOfInputs[i];
+      if (msgs.size() <= indices.headerIdx) {
+        return DataRef{};
       }
-      return DataRef{};
+      auto const& headerMsg = msgs[indices.headerIdx];
+      char const* payloadData = nullptr;
+      size_t payloadSize = 0;
+      if (msgs.size() > indices.payloadIdx && msgs[indices.payloadIdx]) {
+        payloadData = static_cast<char const*>(msgs[indices.payloadIdx]->GetData());
+        payloadSize = msgs[indices.payloadIdx]->GetSize();
+      }
+      return DataRef{nullptr,
+                     headerMsg ? static_cast<char const*>(headerMsg->GetData()) : nullptr,
+                     payloadData,
+                     payloadSize};
     };
     auto nofPartsGetter = [&currentSetOfInputs](size_t i) -> size_t {
       return (currentSetOfInputs[i] | count_payloads{});
@@ -2160,7 +2159,11 @@ bool DataProcessingDevice::tryDispatchComputation(ServiceRegistryRef ref, std::v
       auto& header = static_cast<const fair::mq::shmem::Message&>(*(currentSetOfInputs[idx] | get_header{0}));
       return header.GetRefCount();
     };
-    return InputSpan{getter, nofPartsGetter, refCountGetter, currentSetOfInputs.size()};
+    auto nextIndicesGetter = [&currentSetOfInputs](size_t i, DataRefIndices current) -> DataRefIndices {
+      auto next = currentSetOfInputs[i] | get_next_pair{current};
+      return next.headerIdx < currentSetOfInputs[i].size() ? next : DataRefIndices{size_t(-1), size_t(-1)};
+    };
+    return InputSpan{nofPartsGetter, refCountGetter, indicesGetter, nextIndicesGetter, currentSetOfInputs.size()};
   };
 
   auto markInputsAsDone = [ref](TimesliceSlot slot) -> void {
diff --git a/Framework/Core/src/DataRelayer.cxx b/Framework/Core/src/DataRelayer.cxx
index fc9966ffad643..7adf5b5c97fbb 100644
--- a/Framework/Core/src/DataRelayer.cxx
+++ b/Framework/Core/src/DataRelayer.cxx
@@ -212,18 +212,6 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
       };
 
       auto partial = getPartialRecord(ti);
-      // TODO: get the data ref from message model
-      auto getter = [&partial](size_t idx, size_t part) {
-        if (!partial[idx].empty() && (partial[idx] | get_header{part}).get()) {
-          auto header = (partial[idx] | get_header{part}).get();
-          auto payload = (partial[idx] | get_payload{part, 0}).get();
-          return DataRef{nullptr,
-                         reinterpret_cast<const char*>(header->GetData()),
-                         reinterpret_cast<char const*>(payload ? payload->GetData() : nullptr),
-                         payload ? payload->GetSize() : 0};
-        }
-        return DataRef{};
-      };
       auto nPartsGetter = [&partial](size_t idx) {
         return partial[idx] | count_parts{};
       };
@@ -231,7 +219,24 @@ DataRelayer::ActivityStats DataRelayer::processDanglingInputs(std::vector<Expira
         auto& header = static_cast<const fair::mq::shmem::Message&>(*(partial[idx] | get_header{0}));
         return header.GetRefCount();
       };
-      InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
+      auto indicesGetter = [&partial](size_t idx, DataRefIndices indices) -> DataRef {
+        if (!partial[idx].empty()) {
+          auto const& headerMsg = partial[idx][indices.headerIdx];
+          auto const& payloadMsg = partial[idx][indices.payloadIdx];
+          if (headerMsg) {
+            return DataRef{nullptr,
+                           reinterpret_cast<const char*>(headerMsg->GetData()),
+                           payloadMsg ? reinterpret_cast<char const*>(payloadMsg->GetData()) : nullptr,
+                           payloadMsg ? payloadMsg->GetSize() : 0};
+          }
+        }
+        return DataRef{};
+      };
+      auto nextIndicesGetter = [&partial](size_t idx, DataRefIndices current) -> DataRefIndices {
+        auto next = partial[idx] | get_next_pair{current};
+        return next.headerIdx < partial[idx].size() ? next : DataRefIndices{size_t(-1), size_t(-1)};
+      };
+      InputSpan span{nPartsGetter, refCountGetter, indicesGetter, nextIndicesGetter, static_cast<size_t>(partial.size())};
       // Setup the input span
 
       if (expirator.checker(services, timestamp.value, span) == false) {
@@ -789,18 +794,6 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
       throw runtime_error_f("Completion police %s has no callback set", mCompletionPolicy.name.c_str());
     }
     auto partial = getPartialRecord(li);
-    // TODO: get the data ref from message model
-    auto getter = [&partial](size_t idx, size_t part) {
-      if (!partial[idx].empty() && (partial[idx] | get_header{part}).get()) {
-        auto header = (partial[idx] | get_header{part}).get();
-        auto payload = (partial[idx] | get_payload{part, 0}).get();
-        return DataRef{nullptr,
-                       reinterpret_cast<const char*>(header->GetData()),
-                       reinterpret_cast<char const*>(payload ? payload->GetData() : nullptr),
-                       payload ? payload->GetSize() : 0};
-      }
-      return DataRef{};
-    };
     auto nPartsGetter = [&partial](size_t idx) {
       return partial[idx] | count_parts{};
     };
@@ -808,7 +801,24 @@ void DataRelayer::getReadyToProcess(std::vector<DataRelayer::RecordAction>& comp
       auto& header = static_cast<const fair::mq::shmem::Message&>(*(partial[idx] | get_header{0}));
       return header.GetRefCount();
     };
-    InputSpan span{getter, nPartsGetter, refCountGetter, static_cast<size_t>(partial.size())};
+    auto indicesGetter = [&partial](size_t idx, DataRefIndices indices) -> DataRef {
+      if (!partial[idx].empty()) {
+        auto const& headerMsg = partial[idx][indices.headerIdx];
+        auto const& payloadMsg = partial[idx][indices.payloadIdx];
+        if (headerMsg) {
+          return DataRef{nullptr,
+                         reinterpret_cast<const char*>(headerMsg->GetData()),
+                         payloadMsg ? reinterpret_cast<char const*>(payloadMsg->GetData()) : nullptr,
+                         payloadMsg ? payloadMsg->GetSize() : 0};
+        }
+      }
+      return DataRef{};
+    };
+    auto nextIndicesGetter = [&partial](size_t idx, DataRefIndices current) -> DataRefIndices {
+      auto next = partial[idx] | get_next_pair{current};
+      return next.headerIdx < partial[idx].size() ? next : DataRefIndices{size_t(-1), size_t(-1)};
+    };
+    InputSpan span{nPartsGetter, refCountGetter, indicesGetter, nextIndicesGetter, static_cast<size_t>(partial.size())};
     CompletionPolicy::CompletionOp action = mCompletionPolicy.callbackFull(span, mInputs, mContext);
 
     auto& variables = mTimesliceIndex.getVariablesForSlot(slot);
diff --git a/Framework/Core/src/InputRecord.cxx b/Framework/Core/src/InputRecord.cxx
index 18b341704ffcb..7bc9907b13ba4 100644
--- a/Framework/Core/src/InputRecord.cxx
+++ b/Framework/Core/src/InputRecord.cxx
@@ -139,6 +139,16 @@ size_t InputRecord::getNofParts(int pos) const
   }
   return mSpan.getNofParts(pos);
 }
+
+DataRef InputRecord::getAtIndices(int pos, DataRefIndices indices) const
+{
+  auto ref = mSpan.getAtIndices(pos, indices);
+  if (pos >= 0 && pos < (int)mInputsSchema.size()) {
+    ref.spec = &mInputsSchema[pos].matcher;
+  }
+  return ref;
+}
+
 size_t InputRecord::size() const
 {
   return mSpan.size();
diff --git a/Framework/Core/src/InputSpan.cxx b/Framework/Core/src/InputSpan.cxx
index d1dffc85602a5..ccea2d1dd66ed 100644
--- a/Framework/Core/src/InputSpan.cxx
+++ b/Framework/Core/src/InputSpan.cxx
@@ -11,29 +11,17 @@
 
 #include "Framework/InputSpan.h"
 
-template class std::function<o2::framework::DataRef(size_t)>;
-template class std::function<o2::framework::DataRef(size_t, size_t)>;
+template class std::function<o2::framework::DataRef(size_t, o2::framework::DataRefIndices)>;
+template class std::function<o2::framework::DataRefIndices(size_t, o2::framework::DataRefIndices)>;
 
 namespace o2::framework
 {
-InputSpan::InputSpan(std::function<DataRef(size_t)> getter, size_t size)
-  : mGetter{}, mNofPartsGetter{}, mSize{size}
-{
-  mGetter = [getter](size_t index, size_t) -> DataRef {
-    return getter(index);
-  };
-}
-
-InputSpan::InputSpan(std::function<DataRef(size_t, size_t)> getter, size_t size)
-  : mGetter{getter}, mNofPartsGetter{}, mSize{size}
-{
-}
-
-InputSpan::InputSpan(std::function<DataRef(size_t, size_t)> getter,
-                     std::function<size_t(size_t)> nofPartsGetter,
+InputSpan::InputSpan(std::function<size_t(size_t)> nofPartsGetter,
                      std::function<int(size_t)> refCountGetter,
+                     std::function<DataRef(size_t, DataRefIndices)> indicesGetter,
+                     std::function<DataRefIndices(size_t, DataRefIndices)> nextIndicesGetter,
                      size_t size)
-  : mGetter{getter}, mNofPartsGetter{nofPartsGetter}, mRefCountGetter(refCountGetter), mSize{size}
+  : mNofPartsGetter{nofPartsGetter}, mRefCountGetter(refCountGetter), mIndicesGetter{std::move(indicesGetter)}, mNextIndicesGetter{std::move(nextIndicesGetter)}, mSize{size}
 {
 }
 
diff --git a/Framework/Core/test/benchmark_InputRecord.cxx b/Framework/Core/test/benchmark_InputRecord.cxx
index 69fc3c970c1e1..e3ec00ac815ed 100644
--- a/Framework/Core/test/benchmark_InputRecord.cxx
+++ b/Framework/Core/test/benchmark_InputRecord.cxx
@@ -47,7 +47,12 @@ static void BM_InputRecordGenericGetters(benchmark::State& state)
     createRoute("z_source", spec3)};
   // First of all we test if an empty registry behaves as expected, raising a
   // bunch of exceptions.
-  InputSpan span{[](size_t) { return DataRef{nullptr, nullptr, nullptr}; }, 0};
+  InputSpan span{
+    [](size_t) -> size_t { return 0; },
+    nullptr,
+    [](size_t, DataRefIndices) { return DataRef{nullptr, nullptr, nullptr}; },
+    [](size_t, DataRefIndices) -> DataRefIndices { return {size_t(-1), size_t(-1)}; },
+    0};
   ServiceRegistry registry;
   InputRecord emptyRecord(schema, span, registry);
 
@@ -82,7 +87,12 @@ static void BM_InputRecordGenericGetters(benchmark::State& state)
   createMessage(dh1, 1);
   createMessage(dh2, 2);
   createEmpty();
-  InputSpan span2{[&inputs](size_t i) { return DataRef{nullptr, static_cast<char const*>(inputs[2 * i]), static_cast<char const*>(inputs[2 * i + 1])}; }, inputs.size() / 2};
+  InputSpan span2{
+    [](size_t) -> size_t { return 1; },
+    nullptr,
+    [&inputs](size_t i, DataRefIndices idx) { return DataRef{nullptr, static_cast<char const*>(inputs[2 * i + idx.headerIdx]), static_cast<char const*>(inputs[2 * i + idx.payloadIdx])}; },
+    [](size_t, DataRefIndices) -> DataRefIndices { return {size_t(-1), size_t(-1)}; },
+    inputs.size() / 2};
   InputRecord record{schema, span2, registry};
 
   for (auto _ : state) {
diff --git a/Framework/Core/test/test_CompletionPolicy.cxx b/Framework/Core/test/test_CompletionPolicy.cxx
index 059f20b352b3d..cc16ba95ba8f2 100644
--- a/Framework/Core/test/test_CompletionPolicy.cxx
+++ b/Framework/Core/test/test_CompletionPolicy.cxx
@@ -55,7 +55,12 @@ TEST_CASE("TestCompletionPolicy_callback")
   std::vector<CompletionPolicy> policies{
     {"test", matcher, callback}};
   CompletionPolicy::InputSetElement ref{nullptr, reinterpret_cast<const char*>(stack.data()), nullptr};
-  InputSpan const& inputs{[&ref](size_t) { return ref; }, 1};
+  InputSpan const inputs{
+    [](size_t) -> size_t { return 1; },
+    nullptr,
+    [&ref](size_t, DataRefIndices) -> DataRef { return ref; },
+    [](size_t, DataRefIndices) -> DataRefIndices { return {size_t(-1), size_t(-1)}; },
+    1};
   std::vector<InputSpec> specs;
   ServiceRegistryRef servicesRef{services};
   for (auto& policy : policies) {
diff --git a/Framework/Core/test/test_InputRecord.cxx b/Framework/Core/test/test_InputRecord.cxx
index 4eb1265dcff53..355e52539ea5a 100644
--- a/Framework/Core/test/test_InputRecord.cxx
+++ b/Framework/Core/test/test_InputRecord.cxx
@@ -47,7 +47,10 @@ TEST_CASE("TestInputRecord")
   // First of all we test if an empty registry behaves as expected, raising a
   // bunch of exceptions.
   InputSpan span{
-    [](size_t) { return DataRef{nullptr, nullptr, nullptr}; },
+    [](size_t) -> size_t { return 0; },
+    nullptr,
+    [](size_t, DataRefIndices) { return DataRef{nullptr, nullptr, nullptr}; },
+    [](size_t, DataRefIndices) -> DataRefIndices { return {size_t(-1), size_t(-1)}; },
     0};
   ServiceRegistry registry;
   InputRecord emptyRecord(schema, span, registry);
@@ -91,7 +94,12 @@ TEST_CASE("TestInputRecord")
   createMessage(dh1, 1);
   createMessage(dh2, 2);
   createEmpty();
-  InputSpan span2{[&inputs](size_t i) { return DataRef{nullptr, static_cast<char const*>(inputs[2 * i]), static_cast<char const*>(inputs[2 * i + 1])}; }, inputs.size() / 2};
+  InputSpan span2{
+    [](size_t) -> size_t { return 1; },
+    nullptr,
+    [&inputs](size_t i, DataRefIndices idx) { return DataRef{nullptr, static_cast<char const*>(inputs[2 * i + idx.headerIdx]), static_cast<char const*>(inputs[2 * i + idx.payloadIdx])}; },
+    [](size_t, DataRefIndices) -> DataRefIndices { return {size_t(-1), size_t(-1)}; },
+    inputs.size() / 2};
   InputRecord record{schema, span2, registry};
 
   // Checking we can get the whole ref by name
diff --git a/Framework/Core/test/test_InputRecordWalker.cxx b/Framework/Core/test/test_InputRecordWalker.cxx
index 9af3c0dd2dbe2..1fcfea1ba1587 100644
--- a/Framework/Core/test/test_InputRecordWalker.cxx
+++ b/Framework/Core/test/test_InputRecordWalker.cxx
@@ -35,16 +35,12 @@ struct DataSet {
   using Messages = std::vector<TaggedSet>;
   using CheckType = std::vector<std::string>;
   DataSet(std::vector<InputRoute>&& s, Messages&& m, CheckType&& v, ServiceRegistryRef registry)
-    : schema{std::move(s)}, messages{std::move(m)}, span{[this](size_t i, size_t part) {
-                                                           REQUIRE(i < this->messages.size());
-                                                           REQUIRE(part < this->messages[i].second.size() / 2);
-                                                           auto header = static_cast<char const*>(this->messages[i].second.at(2 * part)->data());
-                                                           auto payload = static_cast<char const*>(this->messages[i].second.at(2 * part + 1)->data());
-                                                           return DataRef{nullptr, header, payload};
-                                                         },
-                                                         [this](size_t i) { return i < this->messages.size() ? messages[i].second.size() / 2 : 0; }, nullptr, this->messages.size()},
-      record{schema, span, registry},
-      values{std::move(v)}
+    : schema{std::move(s)}, messages{std::move(m)}, span{[this](size_t i) { return i < this->messages.size() ? messages[i].second.size() / 2 : 0; }, nullptr, [this](size_t i, DataRefIndices idx) {
+                                                           auto header = static_cast<char const*>(this->messages[i].second.at(idx.headerIdx)->data());
+                                                           auto payload = static_cast<char const*>(this->messages[i].second.at(idx.payloadIdx)->data());
+                                                           return DataRef{nullptr, header, payload}; }, [this](size_t i, DataRefIndices current) -> DataRefIndices {
+                                                           size_t next = current.headerIdx + 2;
+                                                           return next < this->messages[i].second.size() ? DataRefIndices{next, next + 1} : DataRefIndices{size_t(-1), size_t(-1)}; }, this->messages.size()}, record{schema, span, registry}, values{std::move(v)}
   {
     REQUIRE(messages.size() == schema.size());
   }
diff --git a/Framework/Core/test/test_InputSpan.cxx b/Framework/Core/test/test_InputSpan.cxx
index c5682aea80b6c..dc31085e741fd 100644
--- a/Framework/Core/test/test_InputSpan.cxx
+++ b/Framework/Core/test/test_InputSpan.cxx
@@ -30,14 +30,18 @@ TEST_CASE("TestInputSpan")
     routeNo++;
   }
 
-  auto getter = [&inputs](size_t i, size_t part) {
-    return DataRef{nullptr, inputs[i].at(part * 2).data(), inputs[i].at(part * 2 + 1).data()};
-  };
   auto nPartsGetter = [&inputs](size_t i) {
     return inputs[i].size() / 2;
   };
+  auto indicesGetter = [&inputs](size_t i, DataRefIndices indices) {
+    return DataRef{nullptr, inputs[i].at(indices.headerIdx).data(), inputs[i].at(indices.payloadIdx).data()};
+  };
+  auto nextIndicesGetter = [&inputs](size_t i, DataRefIndices current) -> DataRefIndices {
+    size_t next = current.headerIdx + 2;
+    return next < inputs[i].size() ? DataRefIndices{next, next + 1} : DataRefIndices{size_t(-1), size_t(-1)};
+  };
 
-  InputSpan span{getter, nPartsGetter, nullptr, inputs.size()};
+  InputSpan span{nPartsGetter, nullptr, indicesGetter, nextIndicesGetter, inputs.size()};
   REQUIRE(span.size() == inputs.size());
   routeNo = 0;
   for (; routeNo < span.size(); ++routeNo) {
diff --git a/Framework/Utils/test/RawPageTestData.h b/Framework/Utils/test/RawPageTestData.h
index a6b800f7cba32..29ac4eeba6b5b 100644
--- a/Framework/Utils/test/RawPageTestData.h
+++ b/Framework/Utils/test/RawPageTestData.h
@@ -42,13 +42,17 @@ struct DataSet {
   DataSet(std::vector<InputRoute>&& s, Messages&& m, std::vector<int>&& v, ServiceRegistryRef registry)
     : schema{std::move(s)},
       messages{std::move(m)},
-      span{[this](size_t i, size_t part) {
-             auto header = static_cast<char const*>(this->messages[i].at(2 * part)->data());
-             auto payload = static_cast<char const*>(this->messages[i].at(2 * part + 1)->data());
+      span{[this](size_t i) { return i < this->messages.size() ? messages[i].size() / 2 : 0; },
+           nullptr,
+           [this](size_t i, DataRefIndices idx) {
+             auto header = static_cast<char const*>(this->messages[i].at(idx.headerIdx)->data());
+             auto payload = static_cast<char const*>(this->messages[i].at(idx.payloadIdx)->data());
              return DataRef{nullptr, header, payload};
            },
-           [this](size_t i) { return i < this->messages.size() ? messages[i].size() / 2 : 0; },
-           nullptr,
+           [this](size_t i, DataRefIndices current) -> DataRefIndices {
+             size_t next = current.headerIdx + 2;
+             return next < this->messages[i].size() ? DataRefIndices{next, next + 1} : DataRefIndices{size_t(-1), size_t(-1)};
+           },
            this->messages.size()},
       record{schema, span, registry},
       values{std::move(v)}
diff --git a/Framework/Utils/test/test_RootTreeWriter.cxx b/Framework/Utils/test/test_RootTreeWriter.cxx
index 62e1eb62cb4f1..e372fb4e1302e 100644
--- a/Framework/Utils/test/test_RootTreeWriter.cxx
+++ b/Framework/Utils/test/test_RootTreeWriter.cxx
@@ -224,10 +224,14 @@ TEST_CASE("test_RootTreeWriter")
     {InputSpec{"input8", "TST", "SRLZDVEC"}, 7, "input8", 0},  //
   };
 
-  auto getter = [&store](size_t i) -> DataRef {
-    return DataRef{nullptr, static_cast<char const*>(store[2 * i]->GetData()), static_cast<char const*>(store[2 * i + 1]->GetData())};
-  };
-  InputSpan span{getter, store.size() / 2};
+  InputSpan span{
+    [](size_t) -> size_t { return 1; },
+    nullptr,
+    [&store](size_t i, DataRefIndices idx) -> DataRef {
+      return DataRef{nullptr, static_cast<char const*>(store[2 * i + idx.headerIdx]->GetData()), static_cast<char const*>(store[2 * i + idx.payloadIdx]->GetData())};
+    },
+    [](size_t, DataRefIndices) -> DataRefIndices { return {size_t(-1), size_t(-1)}; },
+    store.size() / 2};
   ServiceRegistry registry;
   InputRecord inputs{
     schema,
diff --git a/Utilities/DataSampling/src/Dispatcher.cxx b/Utilities/DataSampling/src/Dispatcher.cxx
index 3ff0ba661fd93..22dd457a1211a 100644
--- a/Utilities/DataSampling/src/Dispatcher.cxx
+++ b/Utilities/DataSampling/src/Dispatcher.cxx
@@ -122,7 +122,7 @@ void Dispatcher::run(ProcessingContext& ctx)
 
   for (auto inputIt = ctx.inputs().begin(); inputIt != ctx.inputs().end(); inputIt++) {
 
-    const DataRef& firstPart = inputIt.getByPos(0);
+    const DataRef& firstPart = *inputIt;
     if (firstPart.header == nullptr) {
       continue;
     }

From 3df669bc765bdca795e17fa23081633d0d146173 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 8 Apr 2026 10:10:25 +0200
Subject: [PATCH 1528/1764] [ALICE3] TRK: Add TrackerACTS header for ACTS-based
 tracking (#15263)

* Add ACTS support for tracking in TrackerSpec
---
 .../ALICE3/TRK/reconstruction/CMakeLists.txt  |   4 +-
 .../include/TRKReconstruction/TrackerACTS.h   | 189 +++++++++++
 .../TRK/reconstruction/src/TrackerACTS.cxx    | 306 ++++++++++++++++++
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   |  30 +-
 4 files changed, 524 insertions(+), 5 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TrackerACTS.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
index 81a75e209124a..59a7f47955938 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
@@ -18,6 +18,7 @@ o2_add_library(TRKReconstruction
                SOURCES src/TimeFrame.cxx
                        src/Clusterer.cxx
                        $<$<BOOL:${Acts_FOUND}>:src/ClustererACTS.cxx>
+                       $<$<BOOL:${Acts_FOUND}>:src/TrackerACTS.cxx>
                PUBLIC_LINK_LIBRARIES
                        O2::ITStracking
                        O2::GPUCommon
@@ -45,7 +46,8 @@ set(dictHeaders include/TRKReconstruction/TimeFrame.h
                 include/TRKReconstruction/Clusterer.h)
 
 if(Acts_FOUND)
-  list(APPEND dictHeaders include/TRKReconstruction/ClustererACTS.h)
+  list(APPEND dictHeaders include/TRKReconstruction/ClustererACTS.h
+                          include/TRKReconstruction/TrackerACTS.h)
 endif()
 
 o2_target_root_dictionary(TRKReconstruction
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TrackerACTS.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TrackerACTS.h
new file mode 100644
index 0000000000000..2910abf480961
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TrackerACTS.h
@@ -0,0 +1,189 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file TrackerACTS.h
+/// \brief TRK tracker using ACTS seeding algorithm
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
+/// \since 2026-04-01
+///
+
+#ifndef ALICE3_INCLUDE_TRACKERACTS_H_
+#define ALICE3_INCLUDE_TRACKERACTS_H_
+
+#include "Acts/Definitions/Units.hpp"
+#include "Framework/Logger.h"
+
+#include "ITStracking/TimeFrame.h"
+#include "TH2F.h"
+
+namespace o2::trk
+{
+
+/// Configuration for the ACTS-based tracker
+struct TrackerACTSConfig {
+  // Seeding parameters
+  float minPt = 0.4f * Acts::UnitConstants::GeV;             ///< Minimum pT for seeds
+  float maxImpactParameter = 10.f * Acts::UnitConstants::mm; ///< Maximum impact parameter
+  float cotThetaMax = std::sinh(4.0f);                       ///< Maximum cot(theta), corresponds to eta ~4
+
+  // Delta R cuts for doublet/triplet formation
+  float deltaRMinBottom = 5.f * Acts::UnitConstants::mm;   ///< Min deltaR for bottom-middle
+  float deltaRMaxBottom = 200.f * Acts::UnitConstants::mm; ///< Max deltaR for bottom-middle
+  float deltaRMinTop = 5.f * Acts::UnitConstants::mm;      ///< Min deltaR for middle-top
+  float deltaRMaxTop = 200.f * Acts::UnitConstants::mm;    ///< Max deltaR for middle-top
+
+  // Z cuts
+  float zMin = -3000.f * Acts::UnitConstants::mm;
+  float zMax = 3000.f * Acts::UnitConstants::mm;
+
+  // Collision region
+  float collisionRegionMin = -150.f * Acts::UnitConstants::mm;
+  float collisionRegionMax = 150.f * Acts::UnitConstants::mm;
+
+  // Quality cuts
+  float maxSeedsPerMiddleSP = 2;
+  float deltaPhiMax = 0.1f; ///< Maximum phi difference for doublets
+};
+
+/// Space point representation for tracking
+struct SpacePoint {
+  float x{0.f};
+  float y{0.f};
+  float z{0.f};
+  int layer{-1};
+  int clusterId{-1};
+  int rof{-1};
+
+  // Derived quantities
+  float r() const { return std::hypot(x, y); }
+  float radius() const { return r(); } // required by Acts::CylindricalGridElement concept
+  float phi() const { return std::atan2(y, x); }
+
+  // Variance estimates (can be refined based on cluster properties)
+  float varianceR{0.01f}; // ~100 um resolution squared
+  float varianceZ{0.01f};
+};
+
+/// Seed (triplet of space points)
+struct SeedACTS {
+  const SpacePoint* bottom{nullptr};
+  const SpacePoint* middle{nullptr};
+  const SpacePoint* top{nullptr};
+  float quality{0.f};
+};
+
+/// TRK Tracker using ACTS algorithms for seeding and track finding
+template <int nLayers>
+class TrackerACTS
+{
+ public:
+  TrackerACTS();
+  ~TrackerACTS()
+  {
+    if (mHistSpacePoints) {
+      mHistSpacePoints->SaveAs("/tmp/mHistSpacePoints.C");
+      delete mHistSpacePoints;
+      mHistSpacePoints = nullptr;
+    }
+  }
+
+  /// Adopt a TimeFrame for processing
+  void adoptTimeFrame(o2::its::TimeFrame<nLayers>& tf);
+
+  /// Main tracking entry point: convert clusters to tracks
+  void clustersToTracks();
+
+  /// Configuration
+  void setConfig(const TrackerACTSConfig& cfg) { mConfig = cfg; }
+  TrackerACTSConfig& getConfig() { return mConfig; }
+  const TrackerACTSConfig& getConfig() const { return mConfig; }
+
+  /// Set the magnetic field strength
+  void setBz(float bz) { mBz = bz; }
+
+  /// Get the magnetic field strength
+  float getBz() const { return mBz; }
+
+  /// Print tracking summary
+  void printSummary() const;
+
+ private:
+  TH2F* mHistSpacePoints = nullptr;
+
+  /// Build space points from clusters in the TimeFrame
+  void buildSpacePoints(int rof);
+
+  /// Create seeds (triplets) from space points using ACTS SeedFinder
+  void createSeeds();
+
+  /// Estimate track parameters from a seed using ACTS
+  bool estimateTrackParams(const SeedACTS& seed, o2::its::TrackITSExt& track) const;
+
+  /// Run track finding from seeds
+  void findTracks();
+
+  /// Assign MC labels to tracks
+  void computeTracksMClabels();
+
+  /// Helper: time a task
+  template <typename Func>
+  float evaluateTask(Func&& task, std::string_view taskName);
+
+  // Configuration
+  TrackerACTSConfig mConfig;
+
+  // TimeFrame data
+  o2::its::TimeFrame<nLayers>* mTimeFrame = nullptr;
+
+  // Space points built from clusters
+  std::vector<SpacePoint> mSpacePoints;
+  std::vector<std::vector<const SpacePoint*>> mSpacePointsPerLayer;
+
+  // Seeds
+  std::vector<SeedACTS> mSeeds;
+
+  // Tracking state
+  float mBz{0.5f}; ///< Magnetic field in Tesla
+  unsigned int mTimeFrameCounter{0};
+  double mTotalTime{0.};
+
+  // Tracking states for logging
+  enum State {
+    SpacePointBuilding = 0,
+    Seeding,
+    TrackFinding,
+    NStates,
+  };
+  State mCurState{SpacePointBuilding};
+  static constexpr std::array<const char*, NStates> StateNames{
+    "Space point building",
+    "ACTS seeding",
+    "Track finding"};
+};
+
+template <int nLayers>
+template <typename Func>
+float TrackerACTS<nLayers>::evaluateTask(Func&& task, std::string_view taskName)
+{
+  LOG(debug) << " + Starting " << taskName;
+  const auto start = std::chrono::high_resolution_clock::now();
+  task();
+  const auto end = std::chrono::high_resolution_clock::now();
+  std::chrono::duration<double, std::milli> diff{end - start};
+
+  LOG(debug) << " - " << taskName << " completed in: " << std::fixed << std::setprecision(2) << diff.count() << " ms";
+  return static_cast<float>(diff.count());
+}
+
+} // namespace o2::trk
+
+#endif /* ALICE3_INCLUDE_TRACKERACTS_H_ */
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx
new file mode 100644
index 0000000000000..67dcfe25e33bb
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx
@@ -0,0 +1,306 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file TrackerACTS.cxx
+/// \brief TRK tracker using ACTS seeding and track finding
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
+/// \since 2026-04-01
+///
+
+#include "TRKReconstruction/TrackerACTS.h"
+
+#include <Acts/EventData/Seed.hpp>
+#include <Acts/EventData/SpacePointContainer.hpp>
+#include <Acts/Seeding/BinnedGroup.hpp>
+#include <Acts/Seeding/SeedFilter.hpp>
+#include <Acts/Seeding/SeedFilterConfig.hpp>
+#include <Acts/Seeding/SeedFinder.hpp>
+#include <Acts/Seeding/SeedFinderConfig.hpp>
+#include <Acts/Seeding/detail/CylindricalSpacePointGrid.hpp>
+#include <Acts/Utilities/GridBinFinder.hpp>
+#include <Acts/Utilities/RangeXD.hpp>
+
+namespace o2::trk
+{
+
+template <int nLayers>
+TrackerACTS<nLayers>::TrackerACTS()
+{
+  // Initialize space points storage per layer
+  mSpacePointsPerLayer.resize(nLayers);
+  mHistSpacePoints = new TH2F("hSpacePoints", "Space points; x (cm); y (cm)", 200, -100, 100, 200, -100, 100);
+}
+
+template <int nLayers>
+void TrackerACTS<nLayers>::adoptTimeFrame(o2::its::TimeFrame<nLayers>& tf)
+{
+  mTimeFrame = &tf;
+}
+
+template <int nLayers>
+void TrackerACTS<nLayers>::buildSpacePoints(int rof)
+{
+  mSpacePoints.clear();
+  for (auto& layerSPs : mSpacePointsPerLayer) {
+    layerSPs.clear();
+  }
+
+  // Get clusters from the TimeFrame and convert to space points
+  for (int layer = 0; layer < nLayers; ++layer) {
+    // For now we take unsorted clusters, as soon as the cluster trackin is in place we can piggy back on it and switch to the clusters
+    auto clusters = mTimeFrame->getUnsortedClusters()[layer];
+    // Resize the clusters to the first 100 clusters for testing
+    // clusters = clusters.subspan(0, std::min<size_t>(clusters.size(), 100));
+    LOG(debug) << "ACTSTracker: got " << clusters.size() << " clusters";
+
+    for (size_t iCluster = 0; iCluster < clusters.size(); ++iCluster) {
+      const auto& cluster = clusters[iCluster];
+
+      SpacePoint sp;
+      // Check that these are in global coordinates
+      sp.x = cluster.xCoordinate * Acts::UnitConstants::cm;
+      sp.y = cluster.yCoordinate * Acts::UnitConstants::cm;
+      sp.z = cluster.zCoordinate * Acts::UnitConstants::cm;
+
+      if (mHistSpacePoints) {
+        mHistSpacePoints->Fill(sp.x / Acts::UnitConstants::cm, sp.y / Acts::UnitConstants::cm);
+      }
+      sp.layer = layer;
+      sp.clusterId = static_cast<int>(iCluster);
+      sp.rof = rof;
+
+      // Position uncertainties (could be refined based on cluster properties)
+      sp.varianceR = 0.01f; // ~100 um resolution squared
+      sp.varianceZ = 0.01f;
+
+      mSpacePoints.push_back(sp);
+    }
+  }
+
+  // Build per-layer pointers for seeding
+  for (auto& sp : mSpacePoints) {
+    if (sp.layer >= 0 && sp.layer < nLayers) {
+      mSpacePointsPerLayer[sp.layer].push_back(&sp);
+    }
+  }
+}
+
+template <int nLayers>
+void TrackerACTS<nLayers>::createSeeds()
+{
+  if (mSpacePoints.empty()) {
+    LOGF(info, "No space points available for seeding");
+    return;
+  }
+  mSeeds.clear();
+
+  // Backend adaptor that exposes mSpacePoints to Acts::SpacePointContainer
+  struct SpacePointBackend {
+    using ValueType = SpacePoint;
+    explicit SpacePointBackend(const std::vector<SpacePoint>& sps) : m_sps{&sps} {}
+    std::size_t size_impl() const { return m_sps->size(); }
+    float x_impl(std::size_t i) const { return (*m_sps)[i].x; }
+    float y_impl(std::size_t i) const { return (*m_sps)[i].y; }
+    float z_impl(std::size_t i) const { return (*m_sps)[i].z; }
+    float varianceR_impl(std::size_t i) const { return (*m_sps)[i].varianceR; }
+    float varianceZ_impl(std::size_t i) const { return (*m_sps)[i].varianceZ; }
+    const SpacePoint& get_impl(std::size_t i) const { return (*m_sps)[i]; }
+    std::any component_impl(Acts::HashedString /*key*/, std::size_t /*i*/) const
+    {
+      LOG(fatal) << "No additional components available for space points";
+      throw std::runtime_error("SpacePointBackend: no strip component available");
+    }
+    const std::vector<SpacePoint>* m_sps;
+  };
+
+  // Wrap mSpacePoints in an Acts space-point container
+  SpacePointBackend backend{mSpacePoints};
+
+  // Configure the ACTS space point container
+  Acts::SpacePointContainerConfig spContainerConfig;
+  Acts::SpacePointContainerOptions spContainerOpts;
+  spContainerOpts.beamPos = {0.f, 0.f};
+  Acts::SpacePointContainer<SpacePointBackend, Acts::detail::RefHolder> spContainer{spContainerConfig, spContainerOpts, backend};
+
+  // Configure the ACTS seed finder
+  const unsigned int maxSeeds = static_cast<unsigned int>(mConfig.maxSeedsPerMiddleSP);
+  Acts::SeedFilterConfig filterConfig;
+  filterConfig.maxSeedsPerSpM = maxSeeds;
+
+  // ACTS requires minPt / bFieldInZ >= rMax / 2 (minHelixRadius >= rMax/2).
+  // Cap rMax so that the constraint is satisfied for the configured minPt and field.
+  const float bFieldInZ = mBz * Acts::UnitConstants::T;
+  const float safeRMax = 1.8f * mConfig.minPt / bFieldInZ; // 10% margin below the hard limit
+
+  using SPProxy = typename Acts::SpacePointContainer<SpacePointBackend, Acts::detail::RefHolder>::SpacePointProxyType;
+  Acts::SeedFinderConfig<SPProxy> finderConfig;
+  finderConfig.rMin = 0.f;
+  finderConfig.rMax = 100.f * Acts::UnitConstants::cm;
+  finderConfig.zMin = mConfig.zMin;
+  finderConfig.zMax = mConfig.zMax;
+  finderConfig.deltaRMin = std::min(mConfig.deltaRMinBottom, mConfig.deltaRMinTop);
+  finderConfig.deltaRMax = std::max(mConfig.deltaRMaxBottom, mConfig.deltaRMaxTop);
+  finderConfig.deltaRMinBottomSP = mConfig.deltaRMinBottom;
+  finderConfig.deltaRMaxBottomSP = mConfig.deltaRMaxBottom;
+  finderConfig.deltaRMinTopSP = mConfig.deltaRMinTop;
+  finderConfig.deltaRMaxTopSP = mConfig.deltaRMaxTop;
+  finderConfig.collisionRegionMin = mConfig.collisionRegionMin;
+  finderConfig.collisionRegionMax = mConfig.collisionRegionMax;
+  finderConfig.cotThetaMax = mConfig.cotThetaMax;
+  finderConfig.minPt = mConfig.minPt;
+  finderConfig.impactMax = mConfig.maxImpactParameter;
+  finderConfig.maxSeedsPerSpM = maxSeeds;
+  finderConfig.sigmaScattering = 5.f;
+  finderConfig.radLengthPerSeed = 0.05f;
+  finderConfig.seedFilter = std::make_shared<Acts::SeedFilter<SPProxy>>(filterConfig);
+  finderConfig = finderConfig.calculateDerivedQuantities();
+  Acts::SeedFinder<SPProxy, Acts::CylindricalSpacePointGrid<SPProxy>> seedFinder{finderConfig,
+                                                                                 Acts::getDefaultLogger("Finder", Acts::Logging::Level::VERBOSE)};
+
+  // Configure and create the cylindrical space-point grid
+  Acts::CylindricalSpacePointGridConfig gridConfig;
+  gridConfig.minPt = finderConfig.minPt;
+  gridConfig.rMin = finderConfig.rMin;
+  gridConfig.rMax = finderConfig.rMax;
+  gridConfig.zMin = finderConfig.zMin;
+  gridConfig.zMax = finderConfig.zMax;
+  gridConfig.deltaRMax = finderConfig.deltaRMax;
+  gridConfig.cotThetaMax = finderConfig.cotThetaMax;
+  gridConfig.impactMax = finderConfig.impactMax;
+
+  Acts::CylindricalSpacePointGridOptions gridOpts;
+  gridOpts.bFieldInZ = bFieldInZ;
+
+  Acts::SeedFinderOptions finderOpts;
+  finderOpts.beamPos = spContainerOpts.beamPos;
+  finderOpts.bFieldInZ = gridOpts.bFieldInZ;
+  try {
+    finderOpts = finderOpts.calculateDerivedQuantities(finderConfig);
+  } catch (const std::exception& e) {
+    LOG(fatal) << "Error in seed finder configuration: " << e.what();
+    return;
+  }
+
+  Acts::CylindricalSpacePointGrid<SPProxy> grid = Acts::CylindricalSpacePointGridCreator::createGrid<SPProxy>(gridConfig, gridOpts);
+  try {
+    Acts::CylindricalSpacePointGridCreator::fillGrid(finderConfig, finderOpts, grid,
+                                                     spContainer.begin(), spContainer.end());
+  } catch (const std::exception& e) {
+    LOG(fatal) << "Error during grid creation/filling: " << e.what();
+    return;
+  }
+  LOG(debug) << "Grid created with " << grid.dimensions();
+
+  // Build the binned group and iterate over triplet combinations
+  Acts::GridBinFinder<3ul> bottomBinFinder{1, std::vector<std::pair<int, int>>{}, 0};
+  Acts::GridBinFinder<3ul> topBinFinder{1, std::vector<std::pair<int, int>>{}, 0};
+  Acts::CylindricalBinnedGroup<SPProxy> spGroup{std::move(grid), bottomBinFinder, topBinFinder};
+
+  std::vector<std::vector<Acts::Seed<SPProxy>>> seedsPerGroup;
+  typename Acts::SeedFinder<SPProxy, Acts::CylindricalSpacePointGrid<SPProxy>>::SeedingState seedingState;
+  seedingState.spacePointMutableData.resize(spContainer.size());
+  const Acts::Range1D<float> rMiddleSPRange;
+  for (auto [bottom, middle, top] : spGroup) {
+    auto& v = seedsPerGroup.emplace_back();
+    try {
+      seedFinder.createSeedsForGroup(finderOpts, seedingState, spGroup.grid(), v, bottom, middle, top, rMiddleSPRange);
+    } catch (const std::exception& e) {
+      LOG(fatal) << "Error during seed finding for a group: " << e.what();
+      return;
+    }
+  }
+  LOG(debug) << "Seed finding completed, found " << seedsPerGroup.size() << " groups with seeds";
+
+  // Convert Acts seeds to the internal SeedACTS representation
+  for (const auto& groupSeeds : seedsPerGroup) {
+    for (const auto& actsSeed : groupSeeds) {
+      SeedACTS seed;
+      seed.bottom = &actsSeed.sp()[0]->externalSpacePoint();
+      seed.middle = &actsSeed.sp()[1]->externalSpacePoint();
+      seed.top = &actsSeed.sp()[2]->externalSpacePoint();
+      seed.quality = actsSeed.seedQuality();
+      mSeeds.push_back(seed);
+    }
+  }
+
+  LOGF(info, "Created %zu seeds from %zu space points", mSeeds.size(), mSpacePoints.size());
+}
+
+template <int nLayers>
+bool TrackerACTS<nLayers>::estimateTrackParams(const SeedACTS& seed, o2::its::TrackITSExt& track) const
+{
+  return true;
+}
+
+template <int nLayers>
+void TrackerACTS<nLayers>::findTracks()
+{
+}
+
+template <int nLayers>
+void TrackerACTS<nLayers>::computeTracksMClabels()
+{
+}
+
+template <int nLayers>
+void TrackerACTS<nLayers>::clustersToTracks()
+{
+  if (!mTimeFrame) {
+    LOG(error) << "Cannot run TrackerACTS: No TimeFrame adopted";
+    return;
+  }
+
+  double totalTime = 0.;
+  LOG(info) << "==== TRK ACTS Tracking ====";
+  LOG(info) << "Processing " << mTimeFrame->getNrof() << " ROFs with B = " << mBz << " T";
+
+  // Process each ROF
+  for (int iROF = 0; iROF < mTimeFrame->getNrof(); ++iROF) {
+    LOG(info) << "Processing ROF " << iROF;
+    // Build space points
+    mCurState = SpacePointBuilding;
+    totalTime += evaluateTask([this, iROF]() { buildSpacePoints(iROF); },
+                              StateNames[mCurState]);
+
+    // Run seeding
+    mCurState = Seeding;
+    totalTime += evaluateTask([this]() { createSeeds(); },
+                              StateNames[mCurState]);
+
+    // Find tracks
+    mCurState = TrackFinding;
+    totalTime += evaluateTask([this]() { findTracks(); },
+                              StateNames[mCurState]);
+  }
+
+  // MC labeling
+  if (mTimeFrame->hasMCinformation()) {
+    computeTracksMClabels();
+  }
+
+  LOG(info) << "=== TimeFrame " << mTimeFrameCounter << " completed in: " << totalTime << " ms ===";
+
+  ++mTimeFrameCounter;
+  mTotalTime += totalTime;
+}
+
+template <int nLayers>
+void TrackerACTS<nLayers>::printSummary() const
+{
+  float avgTF = mTimeFrameCounter > 0 ? static_cast<float>(mTotalTime) / mTimeFrameCounter : 0.f;
+  LOGP(info, "TrackerACTS summary: Processed {} TFs in TOT={:.2f} ms, AVG/TF={:.2f} ms",
+       mTimeFrameCounter, mTotalTime, avgTF);
+}
+
+// Explicit template instantiations
+template class TrackerACTS<11>;
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
index 20bd45557dac5..b587ec24775b4 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -29,6 +29,10 @@
 #include "TRKWorkflow/TrackerSpec.h"
 #include <TGeoGlobalMagField.h>
 
+#ifdef O2_WITH_ACTS
+#include "TRKReconstruction/TrackerACTS.h"
+#endif
+
 #include <TFile.h>
 #include <TTree.h>
 
@@ -61,6 +65,10 @@ void TrackerDPL::init(InitContext& ic)
   // mITSTrackingInterface.setTraitsFromProvider(mChainITS->GetITSVertexerTraits(),
   //                                             mChainITS->GetITSTrackerTraits(),
   //                                             mChainITS->GetITSTimeframe());
+
+#ifdef O2_WITH_ACTS
+  mUseACTS = ic.options().get<bool>("useACTS");
+#endif
 }
 
 void TrackerDPL::stop()
@@ -276,14 +284,13 @@ void TrackerDPL::run(ProcessingContext& pc)
     itsTrackerTraits.setMemoryPool(mMemoryPool);
     itsTrackerTraits.setNThreads(mTaskArena->max_concurrency(), mTaskArena);
     itsTrackerTraits.adoptTimeFrame(static_cast<o2::its::TimeFrame<11>*>(&timeFrame));
-    itsTracker.adoptTimeFrame(timeFrame);
     itsTrackerTraits.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
     auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mHitRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
     TGeoGlobalMagField::Instance()->SetField(field);
     TGeoGlobalMagField::Instance()->Lock();
+    itsTracker.adoptTimeFrame(timeFrame);
 
-    int nRofs = timeFrame.loadROFsFromHitTree(hitsTree, gman, mHitRecoConfig);
-
+    const int nRofs = timeFrame.loadROFsFromHitTree(hitsTree, gman, mHitRecoConfig);
     const int inROFpileup{mHitRecoConfig.contains("inROFpileup") ? mHitRecoConfig["inROFpileup"].get<int>() : 1};
 
     // Add primary vertices from MC headers for each ROF
@@ -293,6 +300,16 @@ void TrackerDPL::run(ProcessingContext& pc)
 
     itsTrackerTraits.updateTrackingParameters(trackingParams);
 
+#ifdef O2_WITH_ACTS
+    if (mUseACTS) {
+      LOG(info) << "Running the tracking with ACTS";
+      o2::trk::TrackerACTS<11> actsTracker;
+      actsTracker.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
+      actsTracker.adoptTimeFrame(timeFrame);
+      actsTracker.clustersToTracks();
+    }
+#endif
+
     const auto trackingLoopStart = std::chrono::steady_clock::now();
     for (size_t iter{0}; iter < trackingParams.size(); ++iter) {
       LOGP(info, "{}", trackingParams[iter].asString());
@@ -391,7 +408,12 @@ DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, o
                                               useMC,
                                               hitRecoConfig,
                                               dType)},
-      Options{ConfigParamSpec{"max-loops", VariantType::Int, 1, {"max number of loops"}}}};
+      Options{ConfigParamSpec{"max-loops", VariantType::Int, 1, {"max number of loops"}}
+#ifdef O2_WITH_ACTS
+              ,
+              {"useACTS", o2::framework::VariantType::Bool, false, {"Use ACTS for tracking"}}
+#endif
+      }};
   }
 
   inputs.emplace_back("dummy", "TRK", "DUMMY", 0, Lifetime::Timeframe);

From 6593df3e4e809f9abca321c8f5720c53421530a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 8 Apr 2026 19:31:57 +0200
Subject: [PATCH 1529/1764] [ALICE3] Fix missing bool in ACTS integration
 (#15264)

- specify since for acts integrations
---
 .../reconstruction/include/TRKReconstruction/ClustererACTS.h  | 4 ++++
 .../Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx  | 4 ++++
 .../ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h   | 4 +---
 .../ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h     | 3 +++
 4 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
index 4111737d17a9f..37a148aa78afb 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
@@ -9,8 +9,12 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+///
 /// \file ClustererACTS.h
 /// \brief Definition of the TRK cluster finder
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
+/// \since 2026-03-01
+///
 
 #ifndef ALICEO2_TRK_CLUSTERERACTS_H
 #define ALICEO2_TRK_CLUSTERERACTS_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
index 0cf7c26e0ea41..2dbf56ae610e3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
@@ -9,8 +9,12 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+///
 /// \file ClustererACTS.cxx
 /// \brief Implementation of the TRK cluster finder with the ACTS
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
+/// \since 2026-03-01
+///
 
 #include "TRKReconstruction/ClustererACTS.h"
 #include "TRKBase/GeometryTGeo.h"
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
index 9cfab104ecdf9..18cc6d245025a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
@@ -32,11 +32,9 @@ class ClustererDPL : public o2::framework::Task
  private:
   bool mUseMC = true;
   int mNThreads = 1;
-#ifdef O2_WITH_ACTS
-  bool mUseACTS = false;
-#endif
   o2::trk::Clusterer mClusterer;
 #ifdef O2_WITH_ACTS
+  bool mUseACTS = false;
   o2::trk::ClustererACTS mClustererACTS;
 #endif
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
index 33b25737bbc29..304b32041c2dc 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
@@ -58,6 +58,9 @@ class TrackerDPL : public framework::Task
   std::shared_ptr<tbb::task_arena> mTaskArena;
   nlohmann::json mHitRecoConfig;
   TStopwatch mTimer;
+#ifdef O2_WITH_ACTS
+  bool mUseACTS = false;
+#endif
 };
 
 framework::DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);

From 9e8f22b292d5709d39b33310d779a990b31f2142 Mon Sep 17 00:00:00 2001
From: Francesco Noferini <noferini@bo.infn.it>
Date: Wed, 8 Apr 2026 18:54:21 +0200
Subject: [PATCH 1530/1764] fix wrong long_to_int converstion in TOF readout
 window indexing

---
 Detectors/TOF/base/include/TOFBase/WindowFiller.h | 2 +-
 Detectors/TOF/base/src/WindowFiller.cxx           | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/TOF/base/include/TOFBase/WindowFiller.h b/Detectors/TOF/base/include/TOFBase/WindowFiller.h
index 77827ee5e7057..5c9abca6da0ea 100644
--- a/Detectors/TOF/base/include/TOFBase/WindowFiller.h
+++ b/Detectors/TOF/base/include/TOFBase/WindowFiller.h
@@ -96,7 +96,7 @@ class WindowFiller
   }
 
   std::vector<uint8_t>& getPatterns() { return mPatterns; }
-  void addPattern(const uint32_t val, int icrate, int orbit, int bc) { mCratePatterns.emplace_back(val, icrate, orbit * 3 + (bc + 100) / Geo::BC_IN_WINDOW); }
+  void addPattern(const uint32_t val, int icrate, int orbit, int bc) { mCratePatterns.emplace_back(val, icrate, ((unsigned long)orbit) * 3 + (bc + 100) / Geo::BC_IN_WINDOW); }
   void addCrateHeaderData(unsigned long orbit, int crate, int32_t bc, uint32_t eventCounter);
   Diagnostic& getDiagnosticFrequency() { return mDiagnosticFrequency; }
 
diff --git a/Detectors/TOF/base/src/WindowFiller.cxx b/Detectors/TOF/base/src/WindowFiller.cxx
index 0362222b55bf5..35ec27070bda1 100644
--- a/Detectors/TOF/base/src/WindowFiller.cxx
+++ b/Detectors/TOF/base/src/WindowFiller.cxx
@@ -194,9 +194,9 @@ void WindowFiller::fillOutputContainer(std::vector<Digit>& digits)
     int npatterns = 0;
 
     // check if patterns are in the current row
-    unsigned int initrow = mFirstIR.orbit * Geo::NWINDOW_IN_ORBIT;
+    unsigned long initrow = ((unsigned long)mFirstIR.orbit) * Geo::NWINDOW_IN_ORBIT;
     for (std::vector<PatternData>::reverse_iterator it = mCratePatterns.rbegin(); it != mCratePatterns.rend(); ++it) {
-      unsigned int irow = it->row;
+      unsigned long irow = it->row;
       // printf("pattern row=%ld (%u - %u) current=%ld\n",irow - initrow,irow,initrow,mReadoutWindowCurrent);
 
       if (irow - initrow > mReadoutWindowCurrent) {

From a1e83082354311a027b2807ece60d682055d8905 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <gab.cima22@gmail.com>
Date: Wed, 18 Mar 2026 16:22:37 +0100
Subject: [PATCH 1531/1764] GPU Framework: fix detection for gfx90a GPU

---
 dependencies/FindO2GPU.cmake | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 3e8f012fea4b5..ad9cc11d56b40 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 13
+# FindO2GPU.cmake Version 14
 
 set(CUDA_COMPUTETARGET_DEFAULT_FULL 80-real 86-real 89-real 120-real 75-virtual)
 set(HIP_AMDGPUTARGET_DEFAULT_FULL gfx906;gfx908)
@@ -66,7 +66,7 @@ function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterri
     set(CUDA_TARGET TESLA)
   endif()
 
-  string(REGEX MATCH "^[ \t\r\n]*gfx[0-9]+" HIP_FIRST_TARGET "${HIP_AMDGPUTARGET}")
+  string(REGEX MATCH "^[ \t\r\n]*gfx[0-9a-fA-F]+" HIP_FIRST_TARGET "${HIP_AMDGPUTARGET}")
   string(STRIP "${HIP_FIRST_TARGET}" HIP_FIRST_TARGET)
   string(REGEX REPLACE "^gfx" "" HIP_FIRST_TARGET "${HIP_FIRST_TARGET}")
   if(NOT HIP_FIRST_TARGET)

From 97a77d9365664c504e4968132c087f89067452f5 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Fri, 10 Apr 2026 17:22:07 +0200
Subject: [PATCH 1532/1764] DPL: use new indices methods to navigate through
 InputRecord in output-proxy

---
 Framework/Core/src/ExternalFairMQDeviceProxy.cxx | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
index 5867f53af4bd2..d4ee776986184 100644
--- a/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
+++ b/Framework/Core/src/ExternalFairMQDeviceProxy.cxx
@@ -1027,9 +1027,9 @@ DataProcessorSpec specifyFairMQDeviceOutputProxy(char const* name,
     callbacks.set<CallbackService::Id::EndOfStream>(forwardEos);
 
     return adaptStateless([lastDataProcessingHeader](InputRecord& inputs) {
-      for (size_t ii = 0; ii != inputs.size(); ++ii) {
-        for (size_t pi = 0; pi < inputs.getNofParts(ii); ++pi) {
-          auto part = inputs.getByPos(ii, pi);
+      for (auto it = inputs.begin(); it != inputs.end(); it++) {
+        for (auto indices = it.initialIndices(); indices != it.endIndices(); indices = it.nextIndices(indices)) {
+          auto part = it.getAtIndices(indices);
           const auto* dph = o2::header::get<DataProcessingHeader*>(part.header);
           if (dph) {
             // FIXME: should we implement an assignment operator for DataProcessingHeader?
@@ -1163,9 +1163,9 @@ DataProcessorSpec specifyFairMQDeviceMultiOutputProxy(char const* name,
       // there is nothing to do if the forwarding is handled on the framework level
       // as forward routes but we need to keep a copy of the last DataProcessingHeader
       // for sending the EOS
-      for (size_t ii = 0; ii != inputs.size(); ++ii) {
-        for (size_t pi = 0; pi < inputs.getNofParts(ii); ++pi) {
-          auto part = inputs.getByPos(ii, pi);
+      for (auto it = inputs.begin(); it != inputs.end(); it++) {
+        for (auto indices = it.initialIndices(); indices != it.endIndices(); indices = it.nextIndices(indices)) {
+          auto part = it.getAtIndices(indices);
           const auto* dph = o2::header::get<DataProcessingHeader*>(part.header);
           if (dph) {
             // FIXME: should we implement an assignment operator for DataProcessingHeader?

From 85fad0700b377263cbadbf4144a734c2ab79f0e7 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Mon, 13 Apr 2026 14:02:25 +0200
Subject: [PATCH 1533/1764] [ALICE3] TRK: Introduce Almira params and shorten
 ROF/response for TRK (#15267)

* Add Almira params

* Use Almira params in the digitisation

* Clip number of ROFs to the requested number of orbits

* Add macro to check bandwidth for MLOT
---
 .../Upgrades/ALICE3/TRK/base/CMakeLists.txt   |   6 +-
 .../TRK/base/include/TRKBase/AlmiraParam.h    |  48 +++
 .../ALICE3/TRK/base/src/AlmiraParam.cxx       |  14 +
 .../ALICE3/TRK/base/src/TRKBaseLinkDef.h      |   4 +-
 .../ALICE3/TRK/macros/test/CMakeLists.txt     |  12 +
 .../ALICE3/TRK/macros/test/CheckBandwidth.C   | 299 ++++++++++++++++++
 .../include/TRKSimulation/DPLDigitizerParam.h |   6 +-
 .../include/TRKSimulation/DigiParams.h        |   6 +-
 .../ALICE3/TRK/simulation/src/DigiParams.cxx  |   4 +-
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   |  11 +-
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   |   2 +-
 .../src/TRKDigitizerSpec.cxx                  | 108 +++++--
 12 files changed, 479 insertions(+), 41 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/AlmiraParam.h
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/base/src/AlmiraParam.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/base/CMakeLists.txt
index 96ebf4ead4b7b..89775e22ed8d0 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/base/CMakeLists.txt
@@ -11,11 +11,13 @@
 
 o2_add_library(TRKBase
                SOURCES src/GeometryTGeo.cxx
+                       src/AlmiraParam.cxx
                        src/TRKBaseParam.cxx
                        src/SegmentationChip.cxx
                PUBLIC_LINK_LIBRARIES O2::DetectorsBase)
 
 o2_target_root_dictionary(TRKBase
-               HEADERS include/TRKBase/GeometryTGeo.h
+               HEADERS include/TRKBase/AlmiraParam.h
+                       include/TRKBase/GeometryTGeo.h
                        include/TRKBase/TRKBaseParam.h
-                       include/TRKBase/SegmentationChip.h)
\ No newline at end of file
+                       include/TRKBase/SegmentationChip.h)
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/AlmiraParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/AlmiraParam.h
new file mode 100644
index 0000000000000..2048666e21c00
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/AlmiraParam.h
@@ -0,0 +1,48 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRK_ALMIRAPARAM_H
+#define O2_TRK_ALMIRAPARAM_H
+
+#include "CommonConstants/LHCConstants.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+namespace o2
+{
+namespace trk
+{
+constexpr float DEFAlmiraStrobeDelay = 0.f; ///< default strobe delay in ns wrt ROF start, to be tuned with the real chip response
+
+struct AlmiraParam : public o2::conf::ConfigurableParamHelper<AlmiraParam> {
+  int roFrameLengthInBC = o2::constants::lhc::LHCMaxBunches / 198; ///< ROF length in BC for continuous mode
+  float strobeDelay = DEFAlmiraStrobeDelay;                        ///< strobe start in ns wrt ROF start
+  float strobeLengthCont = -1.;                                    ///< if < 0, full ROF length minus delay
+  int roFrameBiasInBC = 0;                                         ///< ROF start bias in BC wrt orbit start
+
+  O2ParamDef(AlmiraParam, "TRKAlmiraParam");
+};
+
+} // namespace trk
+
+namespace framework
+{
+template <typename T>
+struct is_messageable;
+
+template <>
+struct is_messageable<o2::trk::AlmiraParam> : std::true_type {
+};
+} // namespace framework
+
+} // namespace o2
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/AlmiraParam.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/AlmiraParam.cxx
new file mode 100644
index 0000000000000..572c902fb23f1
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/AlmiraParam.cxx
@@ -0,0 +1,14 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TRKBase/AlmiraParam.h"
+
+O2ParamImpl(o2::trk::AlmiraParam);
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/TRKBaseLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/base/src/TRKBaseLinkDef.h
index eee9a23eaf5e7..e36955cdd150d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/TRKBaseLinkDef.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/TRKBaseLinkDef.h
@@ -15,10 +15,12 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::AlmiraParam> + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::trk::TRKBaseParam> + ;
 
+#pragma link C++ class o2::trk::AlmiraParam + ;
 #pragma link C++ class o2::trk::GeometryTGeo +
 #pragma link C++ class o2::trk::TRKBaseParam + ;
 #pragma link C++ class o2::trk::SegmentationChip + ;
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
index edd9c785d89ce..54e42c6857249 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
@@ -9,6 +9,18 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
+
+o2_add_test_root_macro(CheckBandwidth.C
+                       PUBLIC_LINK_LIBRARIES O2::ITSMFTBase
+                                             O2::ITSMFTSimulation
+                                             O2::TRKBase
+                                             O2::TRKSimulation
+                                             O2::MathUtils
+                                             O2::SimulationDataFormat
+                                             O2::DetectorsBase
+                                             O2::Steer
+                       LABELS trk COMPILE_ONLY)
+
 o2_add_test_root_macro(CheckDigits.C
                        PUBLIC_LINK_LIBRARIES O2::ITSMFTBase
                                              O2::ITSMFTSimulation
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C
new file mode 100644
index 0000000000000..2087f88a87d6b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C
@@ -0,0 +1,299 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CheckDigits.C
+/// \brief Simple macro to check TRK digits
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <algorithm>
+#include <cmath>
+#include <map>
+#include <TCanvas.h>
+#include <TFile.h>
+#include <TH1D.h>
+#include <TH2F.h>
+#include <TLatex.h>
+#include <TString.h>
+#include <TTree.h>
+#include <TStyle.h>
+
+#include "TRKBase/GeometryTGeo.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "MathUtils/Utils.h"
+#include "DetectorsBase/GeometryManager.h"
+
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "CommonDataFormat/InteractionRecord.h"
+#include "SimulationDataFormat/DigitizationContext.h"
+
+#endif
+
+namespace
+{
+constexpr double DigitBits = 16.;
+constexpr double BunchCrossingNS = 25.;
+constexpr int ReadoutCycleBC = 18;
+constexpr int ReadoutCycleSimBC = 18;
+constexpr double ReadoutCycleSeconds = ReadoutCycleBC * BunchCrossingNS * 1.e-9;
+} // namespace
+
+void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGeom = "o2sim_geometry.root", std::string collContextFile = "collisioncontext.root")
+{
+  gStyle->SetPalette(55);
+  gStyle->SetOptStat(0);
+
+  auto drawSummary = [](double averageValue, double peakValue, const char* unit) {
+    TLatex latex;
+    latex.SetNDC();
+    latex.SetTextSize(0.03);
+    latex.SetTextAlign(13);
+    latex.DrawLatex(0.04, 0.05, Form("avg: %.3f %s", averageValue, unit));
+    latex.DrawLatex(0.34, 0.05, Form("peak: %.3f %s", peakValue, unit));
+  };
+
+  auto drawCollisionSummary = [](double averageValue, double nonEmptyAverageValue, double peakValue) {
+    TLatex latex;
+    latex.SetNDC();
+    latex.SetTextSize(0.03);
+    latex.SetTextAlign(13);
+    latex.DrawLatex(0.04, 0.025, Form("avg: %.3f collisions/ROF", averageValue));
+    latex.DrawLatex(0.42, 0.025, Form("peak: %.3f collisions/ROF", peakValue));
+    latex.DrawLatex(0.04, 0.06, Form("avg non-empty: %.3f collisions/ROF", nonEmptyAverageValue));
+  };
+
+  using namespace o2::base;
+  using namespace o2::trk;
+
+  TFile* f = TFile::Open("CheckBandwidth.root", "recreate");
+
+  // Geometry
+  o2::base::GeometryManager::loadGeometry(inputGeom);
+  auto* gman = o2::trk::GeometryTGeo::Instance();
+  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+
+  // Collision Context
+  TFile* ccFile = TFile::Open(collContextFile.data());
+  auto* digiContext = (o2::steer::DigitizationContext*)ccFile->Get("DigitizationContext");
+  const o2::InteractionRecord firstSampledIR{0, digiContext->getFirstOrbitForSampling()};
+  std::vector<unsigned int> collisionsPerROF;
+
+  for (const auto& record : digiContext->getEventRecords()) {
+    auto nbc = record.differenceInBC(firstSampledIR);
+    if (record.getTimeOffsetWrtBC() < 0. && nbc > 0) {
+      --nbc;
+    }
+    if (nbc < 0) {
+      continue;
+    }
+
+    const size_t rofID = nbc / ReadoutCycleSimBC;
+    if (rofID >= collisionsPerROF.size()) {
+      collisionsPerROF.resize(rofID + 1, 0u);
+    }
+    ++collisionsPerROF[rofID];
+  }
+
+  // Digits
+  TFile* digFile = TFile::Open(digifile.data());
+  TTree* digTree = (TTree*)digFile->Get("o2sim");
+  const int nDigitTreeEntries = digTree->GetEntries();
+
+  std::vector<o2::itsmft::Digit>* digArr = nullptr;
+  digTree->SetBranchAddress("TRKDigit", &digArr);
+
+  // Get Read Out Frame arrays
+  std::vector<o2::itsmft::ROFRecord>* ROFRecordArrray = nullptr;
+  digTree->SetBranchAddress("TRKDigitROF", &ROFRecordArrray);
+  std::vector<o2::itsmft::ROFRecord>& ROFRecordArrrayRef = *ROFRecordArrray;
+
+  digTree->GetEntry(0);
+
+  if (nDigitTreeEntries > 1) {
+    LOG(warning) << "Digit tree has " << nDigitTreeEntries << " entries, but this macro processes entry 0 only.";
+  }
+
+  std::vector<unsigned long long> digitsPerChip(gman->getNumberOfChips(), 0ull);
+  std::vector<unsigned int> maxDigitsPerROFPerChip(gman->getNumberOfChips(), 0u);
+  std::vector<unsigned int> digitsInCurrentROFPerChip(gman->getNumberOfChips(), 0u);
+
+  const int nROFRec = (int)ROFRecordArrrayRef.size();
+  const int nCollisionROFBins = std::max(nROFRec, static_cast<int>(collisionsPerROF.size()));
+
+  if (nCollisionROFBins > 0) {
+    auto* hCollisionsPerROF = new TH1D("h_collisions_per_rof", "Collisions per ROF;ROF id;N collisions", nCollisionROFBins, -0.5, nCollisionROFBins - 0.5);
+    double totalCollisionsPerROF = 0.;
+    double peakCollisionsPerROF = 0.;
+    int nNonEmptyROFs = 0;
+
+    for (int rofID = 0; rofID < nCollisionROFBins; ++rofID) {
+      const double nCollisions = rofID < static_cast<int>(collisionsPerROF.size()) ? collisionsPerROF[rofID] : 0.;
+      hCollisionsPerROF->SetBinContent(rofID + 1, nCollisions);
+      totalCollisionsPerROF += nCollisions;
+      peakCollisionsPerROF = std::max(peakCollisionsPerROF, nCollisions);
+      if (nCollisions > 0.) {
+        ++nNonEmptyROFs;
+      }
+    }
+
+    auto* canvCollisionsPerROF = new TCanvas("canvCollisionsPerROF", "Collisions per ROF", 1050, 1050);
+    canvCollisionsPerROF->SetTopMargin(0.08);
+    hCollisionsPerROF->Draw("hist");
+    drawCollisionSummary(totalCollisionsPerROF / nCollisionROFBins,
+                         nNonEmptyROFs > 0 ? totalCollisionsPerROF / nNonEmptyROFs : 0.,
+                         peakCollisionsPerROF);
+    canvCollisionsPerROF->SaveAs("trk_collisions_per_rof.png");
+  }
+
+  unsigned int rofIndex = 0;
+  unsigned int rofNEntries = 0;
+
+  // LOOP on : ROFRecord array
+  for (unsigned int iROF = 0; iROF < ROFRecordArrrayRef.size(); iROF++) {
+    std::vector<int> touchedChips;
+
+    rofIndex = ROFRecordArrrayRef[iROF].getFirstEntry();
+    rofNEntries = ROFRecordArrrayRef[iROF].getNEntries();
+
+    // LOOP on : digits array
+    for (unsigned int iDigit = rofIndex; iDigit < rofIndex + rofNEntries; iDigit++) {
+      if (iDigit % 1000 == 0)
+        std::cout << "Reading digit " << iDigit << " / " << digArr->size() << std::endl;
+
+      Int_t iDetID = (*digArr)[iDigit].getChipIndex();
+      Int_t disk = gman->getDisk(iDetID);
+      Int_t subDetID = gman->getSubDetID(iDetID);
+
+      if (subDetID == 1 && disk == -1) {
+        if (digitsInCurrentROFPerChip[iDetID] == 0) {
+          touchedChips.push_back(iDetID);
+        }
+        digitsPerChip[iDetID]++;
+        ++digitsInCurrentROFPerChip[iDetID];
+      }
+
+    } // end loop on digits array
+
+    for (const auto chipID : touchedChips) {
+      maxDigitsPerROFPerChip[chipID] = std::max(maxDigitsPerROFPerChip[chipID], digitsInCurrentROFPerChip[chipID]);
+      digitsInCurrentROFPerChip[chipID] = 0;
+    }
+
+  } // end loop on ROFRecords array
+
+  const double rofNorm = nROFRec > 0 ? 1. / nROFRec : 0.;
+  const double bitsToMbps = ReadoutCycleSeconds > 0. ? DigitBits / ReadoutCycleSeconds / 1.e6 : 0.;
+  const int nMLOTLayers = gman->getNumberOfLayersMLOT();
+
+  for (int layer = 0; layer < nMLOTLayers; ++layer) {
+    int nStaves = gman->extractNumberOfStavesMLOT(layer);
+    std::map<int, std::vector<std::pair<double, int>>> chipsPerStave;
+    std::vector<int> sensorIdPerChip(gman->getNumberOfChips(), -1);
+    int maxSensorsPerStave = 0;
+
+    for (int chipID = 0; chipID < gman->getNumberOfChips(); ++chipID) {
+      if (gman->getSubDetID(chipID) != 1 || gman->getLayer(chipID) != layer) {
+        continue;
+      }
+      const int staveID = gman->getStave(chipID);
+      const auto sensorCenter = gman->getMatrixL2G(chipID)(o2::math_utils::Point3D<float>(0.f, 0.f, 0.f));
+      chipsPerStave[staveID].push_back({sensorCenter.Z(), chipID});
+    }
+
+    for (auto& [staveID, chips] : chipsPerStave) {
+      std::sort(chips.begin(), chips.end(), [](const auto& left, const auto& right) {
+        if (std::abs(left.first - right.first) > 1.e-4) {
+          return left.first < right.first;
+        }
+        return left.second < right.second;
+      });
+
+      for (size_t sensorIndex = 0; sensorIndex < chips.size(); ++sensorIndex) {
+        sensorIdPerChip[chips[sensorIndex].second] = sensorIndex;
+      }
+
+      maxSensorsPerStave = std::max(maxSensorsPerStave, static_cast<int>(chips.size()));
+    }
+
+    if (maxSensorsPerStave == 0) {
+      continue;
+    }
+
+    auto* hDigitsPerROF = new TH2F(Form("h_digits_per_rof_layer%d", layer),
+                                   Form("Layer %d average digits per ROF;stave id;sensor id in stave;digits / ROF", layer),
+                                   nStaves, -0.5, nStaves - 0.5, maxSensorsPerStave, -0.5, maxSensorsPerStave - 0.5);
+    auto* hMaxDigitsPerROF = new TH2F(Form("h_max_digits_per_rof_layer%d", layer),
+                                      Form("Layer %d max digits in one ROF;stave id;sensor id in stave;max digits / ROF", layer),
+                                      nStaves, -0.5, nStaves - 0.5, maxSensorsPerStave, -0.5, maxSensorsPerStave - 0.5);
+    auto* hBandwidth = new TH2F(Form("h_bandwidth_layer%d", layer),
+                                Form("Layer %d bandwidth map;stave id;sensor id in stave;bandwidth (Mbit/s)", layer),
+                                nStaves, -0.5, nStaves - 0.5, maxSensorsPerStave, -0.5, maxSensorsPerStave - 0.5);
+    double totalAvgDigitsPerROF = 0.;
+    double totalMaxDigitsPerROF = 0.;
+    double totalBandwidthMbps = 0.;
+    double peakAvgDigitsPerROF = 0.;
+    double peakMaxDigitsPerROF = 0.;
+    double peakBandwidthMbps = 0.;
+    int nFilledSensors = 0;
+
+    for (int chipID = 0; chipID < gman->getNumberOfChips(); ++chipID) {
+      if (gman->getSubDetID(chipID) != 1 || gman->getLayer(chipID) != layer) {
+        continue;
+      }
+
+      const int staveID = gman->getStave(chipID);
+      const int sensorID = sensorIdPerChip[chipID];
+      const double avgDigitsPerROF = digitsPerChip[chipID] * rofNorm;
+      const double maxDigitsPerROF = maxDigitsPerROFPerChip[chipID];
+      const double bandwidthMbps = avgDigitsPerROF * bitsToMbps;
+
+      if (sensorID >= 0) {
+        hDigitsPerROF->Fill(staveID, sensorID, avgDigitsPerROF);
+        hMaxDigitsPerROF->Fill(staveID, sensorID, maxDigitsPerROF);
+        hBandwidth->Fill(staveID, sensorID, bandwidthMbps);
+        totalAvgDigitsPerROF += avgDigitsPerROF;
+        totalMaxDigitsPerROF += maxDigitsPerROF;
+        totalBandwidthMbps += bandwidthMbps;
+        peakAvgDigitsPerROF = std::max(peakAvgDigitsPerROF, avgDigitsPerROF);
+        peakMaxDigitsPerROF = std::max(peakMaxDigitsPerROF, maxDigitsPerROF);
+        peakBandwidthMbps = std::max(peakBandwidthMbps, bandwidthMbps);
+        ++nFilledSensors;
+      }
+    }
+
+    auto* canvLayer = new TCanvas(Form("canvBandwidthLayer%d", layer), Form("Layer %d bandwidth", layer), 1050, 1050);
+    canvLayer->SetTopMargin(0.08);
+    canvLayer->SetRightMargin(0.18);
+    const double avgDigitsPerROFLayer = nFilledSensors > 0 ? totalAvgDigitsPerROF / nFilledSensors : 0.;
+    const double avgMaxDigitsPerROFLayer = nFilledSensors > 0 ? totalMaxDigitsPerROF / nFilledSensors : 0.;
+    const double avgBandwidthMbps = nFilledSensors > 0 ? totalBandwidthMbps / nFilledSensors : 0.;
+    hBandwidth->GetZaxis()->SetRangeUser(0., avgBandwidthMbps > 0. ? 3. * avgBandwidthMbps : 1.);
+    hBandwidth->Draw("colz");
+    drawSummary(avgBandwidthMbps, peakBandwidthMbps, "Mbit/s");
+    canvLayer->SaveAs(Form("trk_layer%d_bandwidth_map.png", layer));
+
+    auto* canvLayerDigits = new TCanvas(Form("canvDigitsLayer%d", layer), Form("Layer %d digits per ROF", layer), 1050, 1050);
+    canvLayerDigits->SetTopMargin(0.08);
+    canvLayerDigits->SetRightMargin(0.18);
+    hDigitsPerROF->Draw("colz");
+    drawSummary(avgDigitsPerROFLayer, peakAvgDigitsPerROF, "digits/ROF");
+    canvLayerDigits->SaveAs(Form("trk_layer%d_digits_per_rof_map.png", layer));
+
+    auto* canvLayerMaxDigits = new TCanvas(Form("canvMaxDigitsLayer%d", layer), Form("Layer %d max digits per ROF", layer), 1050, 1050);
+    canvLayerMaxDigits->SetTopMargin(0.08);
+    canvLayerMaxDigits->SetRightMargin(0.18);
+    hMaxDigitsPerROF->Draw("colz");
+    drawSummary(avgMaxDigitsPerROFLayer, peakMaxDigitsPerROF, "digits/ROF");
+    canvLayerMaxDigits->SaveAs(Form("trk_layer%d_max_digits_per_rof_map.png", layer));
+  }
+
+  f->Write();
+  f->Close();
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
index 168ae172f4b86..de839b27aefee 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DPLDigitizerParam.h
@@ -32,9 +32,9 @@ struct DPLDigitizerParam : public o2::conf::ConfigurableParamHelper<DPLDigitizer
 
   bool continuous = true;                   ///< flag for continuous simulation
   float noisePerPixel = DEFNoisePerPixel(); ///< ALPIDE Noise per channel
-  float strobeFlatTop = 7500.;              ///< strobe shape flat top
-  float strobeMaxRiseTime = 1100.;          ///< strobe max rise time
-  float strobeQRiseTime0 = 450.;            ///< q @ which strobe rise time is 0
+  float strobeFlatTop = 20.;                ///< strobe shape flat top
+  float strobeMaxRiseTime = 0.;             ///< strobe max rise time
+  float strobeQRiseTime0 = 0.;              ///< q @ which strobe rise time is 0
 
   double timeOffset = 0.;                 ///< time offset (in seconds!) to calculate ROFrame from hit time
   int chargeThreshold = 75;               ///< charge threshold in Nelectrons
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
index d24af1bfe13f1..3bb58f21dd33b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
@@ -92,8 +92,8 @@ class DigiParams
 
   bool isTimeOffsetSet() const { return mTimeOffset > -infTime; }
 
-  const o2::trk::ChipSimResponse* getAlpSimResponse() const { return mAlpSimResponse.get(); }
-  void setAlpSimResponse(const o2::itsmft::AlpideSimResponse*);
+  const o2::trk::ChipSimResponse* getResponse() const { return mResponse.get(); }
+  void setResponse(const o2::itsmft::AlpideSimResponse*);
 
   const SignalShape& getSignalShape() const { return mSignalShape; }
   SignalShape& getSignalShape() { return (SignalShape&)mSignalShape; }
@@ -123,7 +123,7 @@ class DigiParams
 
   o2::itsmft::AlpideSignalTrapezoid mSignalShape; ///< signal timeshape parameterization
 
-  std::unique_ptr<o2::trk::ChipSimResponse> mAlpSimResponse; //!< pointer on external response
+  std::unique_ptr<o2::trk::ChipSimResponse> mResponse; //!< pointer on external response
 
   // auxiliary precalculated parameters
   float mROFrameLengthInv = 0; ///< inverse length of RO frame in ns
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
index e2a78702204e5..d5d47b3658b04 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
@@ -72,7 +72,7 @@ void DigiParams::print() const
   mSignalShape.print();
 }
 
-void DigiParams::setAlpSimResponse(const o2::itsmft::AlpideSimResponse* resp)
+void DigiParams::setResponse(const o2::itsmft::AlpideSimResponse* resp)
 {
   LOG(debug) << "Response function data path: " << resp->getDataPath();
   LOG(debug) << "Response function info: ";
@@ -80,5 +80,5 @@ void DigiParams::setAlpSimResponse(const o2::itsmft::AlpideSimResponse* resp)
   if (!resp) {
     LOGP(fatal, "cannot set response function from null");
   }
-  mAlpSimResponse = std::make_unique<o2::trk::ChipSimResponse>(resp);
+  mResponse = std::make_unique<o2::trk::ChipSimResponse>(resp);
 }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 31ef19a21cce9..31b9a25b7e5f8 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -50,7 +50,7 @@ void Digitizer::init()
   }
 
   // setting the correct response function (for the moment, for both VD and MLOT the same response function is used)
-  mChipSimResp = mParams.getAlpSimResponse();
+  mChipSimResp = mParams.getResponse();
   mChipSimRespVD = mChipSimResp;   /// for the moment considering the same response
   mChipSimRespMLOT = mChipSimResp; /// for the moment considering the same response
 
@@ -171,7 +171,13 @@ void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
       nbc--;
     }
 
-    mNewROFrame = nbc / mParams.getROFrameLengthInBC();
+    if (nbc < 0) {
+      mNewROFrame = 0;
+      mIsBeforeFirstRO = true;
+    } else {
+      mNewROFrame = nbc / mParams.getROFrameLengthInBC();
+      mIsBeforeFirstRO = false;
+    }
 
     LOG(debug) << " NewROFrame " << mNewROFrame << " = " << nbc << "/" << mParams.getROFrameLengthInBC() << " (nbc/mParams.getROFrameLengthInBC()";
 
@@ -179,6 +185,7 @@ void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
     mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC()) * o2::constants::lhc::LHCBunchSpacingNS;
   } else {
     mNewROFrame = 0;
+    mIsBeforeFirstRO = false;
   }
 
   if (mNewROFrame < mROFrameMin) {
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
index b587ec24775b4..3801228422a62 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -427,7 +427,7 @@ DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, o
   }
 
   // inputs.emplace_back("itscldict", "TRK", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
-  // inputs.emplace_back("itsalppar", "TRK", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+  // inputs.emplace_back("TRK_almiraparam", "TRK", "ALMIRAPARAM", 0, Lifetime::Condition, ccdbParamSpec("TRK/Config/AlmiraParam"));
 
   // outputs.emplace_back("TRK", "TRACKCLSID", 0, Lifetime::Timeframe);
   // outputs.emplace_back("TRK", "TRKTrackROF", 0, Lifetime::Timeframe);
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
index 30f9d33983712..8957ebed223b2 100644
--- a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
@@ -21,19 +21,21 @@
 #include "DataFormatsITSMFT/Digit.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "DetectorsBase/BaseDPLDigitizer.h"
+#include "DetectorsRaw/HBFUtils.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsCommonDataFormats/SimTraits.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "TRKSimulation/Digitizer.h"
 #include "TRKSimulation/DPLDigitizerParam.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "TRKBase/AlmiraParam.h"
 #include "TRKBase/GeometryTGeo.h"
 #include "TRKBase/TRKBaseParam.h"
 
 #include <TChain.h>
 #include <TStopwatch.h>
 
+#include <algorithm>
 #include <memory>
 #include <string>
 
@@ -77,6 +79,8 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     if (mFinished) {
       return;
     }
+    mFirstOrbitTF = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
+    const o2::InteractionRecord firstIR(0, mFirstOrbitTF);
     updateTimeDependentParams(pc);
 
     // read collision context from input
@@ -102,6 +106,11 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     // digits are directly put into DPL owned resource
     auto& digitsAccum = pc.outputs().make<std::vector<itsmft::Digit>>(Output{mOrigin, "DIGITS", 0});
 
+    const int roFrameLengthInBC = mDigitizer.getParams().getROFrameLengthInBC();
+    const int nROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / roFrameLengthInBC;
+    const int nROFsTF = nROFsPerOrbit * raw::HBFUtils::Instance().getNOrbitsPerTF();
+    mROFRecordsAccum.reserve(nROFsTF);
+
     auto accumulate = [this, &digitsAccum]() {
       // accumulate result of single event processing, called after processing every event supplied
       // AND after the final flushing via digitizer::fillOutputContainer
@@ -180,10 +189,62 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     accumulate();
 
     // here we have all digits and labels and we can send them to consumer (aka snapshot it onto output)
+    std::vector<o2::itsmft::ROFRecord> expDigitRofVec(nROFsTF);
+    for (int iROF = 0; iROF < nROFsTF; ++iROF) {
+      auto& rof = expDigitRofVec[iROF];
+      const int orb = iROF * roFrameLengthInBC / o2::constants::lhc::LHCMaxBunches + mFirstOrbitTF;
+      const int bc = iROF * roFrameLengthInBC % o2::constants::lhc::LHCMaxBunches;
+      rof.setBCData(o2::InteractionRecord(bc, orb));
+      rof.setROFrame(iROF);
+      rof.setNEntries(0);
+      rof.setFirstEntry(-1);
+    }
+
+    for (const auto& rof : mROFRecordsAccum) {
+      const auto& ir = rof.getBCData();
+      const auto irToFirst = ir - firstIR;
+      const auto irROF = irToFirst.toLong() / roFrameLengthInBC;
+      if (irROF < 0 || irROF >= nROFsTF) {
+        continue;
+      }
+      auto& expROF = expDigitRofVec[irROF];
+      expROF.setFirstEntry(rof.getFirstEntry());
+      expROF.setNEntries(rof.getNEntries());
+      if (expROF.getBCData() != rof.getBCData()) {
+        LOGP(fatal, "detected mismatch between expected {} and received {}", expROF.asString(), rof.asString());
+      }
+    }
 
-    pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, mROFRecordsAccum);
+    int prevFirst = 0;
+    for (auto& rof : expDigitRofVec) {
+      if (rof.getFirstEntry() < 0) {
+        rof.setFirstEntry(prevFirst);
+      }
+      prevFirst = rof.getFirstEntry();
+    }
+
+    pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, expDigitRofVec);
     if (mWithMCTruth) {
-      pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, mMC2ROFRecordsAccum);
+      std::vector<o2::itsmft::MC2ROFRecord> clippedMC2ROFRecords;
+      clippedMC2ROFRecords.reserve(mMC2ROFRecordsAccum.size());
+      for (auto mc2rof : mMC2ROFRecordsAccum) {
+        if (mc2rof.rofRecordID < 0 || mc2rof.minROF >= static_cast<uint32_t>(nROFsTF)) {
+          mc2rof.rofRecordID = -1;
+          mc2rof.minROF = 0;
+          mc2rof.maxROF = 0;
+        } else {
+          mc2rof.maxROF = std::min<uint32_t>(mc2rof.maxROF, nROFsTF - 1);
+          if (mc2rof.minROF > mc2rof.maxROF) {
+            mc2rof.rofRecordID = -1;
+            mc2rof.minROF = 0;
+            mc2rof.maxROF = 0;
+          } else {
+            mc2rof.rofRecordID = mc2rof.minROF;
+          }
+        }
+        clippedMC2ROFRecords.push_back(mc2rof);
+      }
+      pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, clippedMC2ROFRecords);
       auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", 0});
       mLabelsAccum.flatten_to(sharedlabels);
       // free space of existing label containers
@@ -208,7 +269,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     if (!file) {
       LOG(fatal) << "Cannot open response file " << mLocalRespFile;
     }
-    mDigitizer.getParams().setAlpSimResponse((const o2::itsmft::AlpideSimResponse*)file->Get("response1"));
+    mDigitizer.getParams().setResponse((const o2::itsmft::AlpideSimResponse*)file->Get("response1"));
   }
 
   void updateTimeDependentParams(ProcessingContext& pc)
@@ -225,21 +286,15 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       mDigitizer.setGeometry(geom);
 
       const auto& dopt = o2::trk::DPLDigitizerParam<o2::detectors::DetID::TRK>::Instance();
-      pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("ITS_alppar");
-      const auto& aopt = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-      digipar.setContinuous(dopt.continuous);
+      // pc.inputs().get<o2::trk::AlmiraParam*>("TRK_almiraparam");
+      const auto& aopt = o2::trk::AlmiraParam::Instance();
+      auto frameNS = aopt.roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingNS;
+      digipar.setContinuous(true);
       digipar.setROFrameBiasInBC(aopt.roFrameBiasInBC);
-      if (dopt.continuous) {
-        auto frameNS = aopt.roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingNS;
-        digipar.setROFrameLengthInBC(aopt.roFrameLengthInBC);
-        digipar.setROFrameLength(frameNS);                                                                       // RO frame in ns
-        digipar.setStrobeDelay(aopt.strobeDelay);                                                                // Strobe delay wrt beginning of the RO frame, in ns
-        digipar.setStrobeLength(aopt.strobeLengthCont > 0 ? aopt.strobeLengthCont : frameNS - aopt.strobeDelay); // Strobe length in ns
-      } else {
-        digipar.setROFrameLength(aopt.roFrameLengthTrig); // RO frame in ns
-        digipar.setStrobeDelay(aopt.strobeDelay);         // Strobe delay wrt beginning of the RO frame, in ns
-        digipar.setStrobeLength(aopt.strobeLengthTrig);   // Strobe length in ns
-      }
+      digipar.setROFrameLengthInBC(aopt.roFrameLengthInBC);
+      digipar.setROFrameLength(frameNS); // RO frame in ns
+      digipar.setStrobeDelay(aopt.strobeDelay);
+      digipar.setStrobeLength(aopt.strobeLengthCont > 0 ? aopt.strobeLengthCont : frameNS - aopt.strobeDelay);
       // parameters of signal time response: flat-top duration, max rise time and q @ which rise time is 0
       digipar.getSignalShape().setParameters(dopt.strobeFlatTop, dopt.strobeMaxRiseTime, dopt.strobeQRiseTime0);
       digipar.setChargeThreshold(dopt.chargeThreshold); // charge threshold in electrons
@@ -247,10 +302,8 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       digipar.setTimeOffset(dopt.timeOffset);
       digipar.setNSimSteps(dopt.nSimSteps);
 
-      mROMode = digipar.isContinuous() ? o2::parameters::GRPObject::CONTINUOUS : o2::parameters::GRPObject::PRESENT;
-      LOG(info) << mID.getName() << " simulated in "
-                << ((mROMode == o2::parameters::GRPObject::CONTINUOUS) ? "CONTINUOUS" : "TRIGGERED")
-                << " RO mode";
+      mROMode = o2::parameters::GRPObject::CONTINUOUS;
+      LOG(info) << mID.getName() << " simulated in CONTINUOUS RO mode";
 
       // if (oTRKParams::Instance().useDeadChannelMap) {
       //   pc.inputs().get<o2::itsmft::NoiseMap*>("TRK_dead"); // trigger final ccdb update
@@ -265,9 +318,9 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
 
   void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   {
-    if (matcher == ConcreteDataMatcher(detectors::DetID::ITS, "ALPIDEPARAM", 0)) {
-      LOG(info) << mID.getName() << " Alpide param updated";
-      const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
+    if (matcher == ConcreteDataMatcher(mOrigin, "ALMIRAPARAM", 0)) {
+      LOG(info) << mID.getName() << " Almira param updated";
+      const auto& par = o2::trk::AlmiraParam::Instance();
       par.printKeyValues();
       return;
     }
@@ -280,7 +333,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       LOG(info) << mID.getName() << " loaded APTSResponseData";
       if (mLocalRespFile.empty()) {
         LOG(info) << "Using CCDB/APTS response file";
-        mDigitizer.getParams().setAlpSimResponse((const o2::itsmft::AlpideSimResponse*)obj);
+        mDigitizer.getParams().setResponse((const o2::itsmft::AlpideSimResponse*)obj);
         mDigitizer.setResponseName("APTS");
       } else {
         LOG(info) << "Response function will be loaded from local file: " << mLocalRespFile;
@@ -294,6 +347,7 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
   bool mWithMCTruth{true};
   bool mFinished{false};
   bool mDisableQED{false};
+  unsigned long mFirstOrbitTF = 0x0;
   std::string mLocalRespFile{""};
   const o2::detectors::DetID mID{o2::detectors::DetID::TRK};
   const o2::header::DataOrigin mOrigin{o2::header::gDataOriginTRK};
@@ -318,7 +372,7 @@ DataProcessorSpec getTRKDigitizerSpec(int channel, bool mctruth)
   auto detOrig = o2::header::gDataOriginTRK;
   std::vector<InputSpec> inputs;
   inputs.emplace_back("collisioncontext", "SIM", "COLLISIONCONTEXT", static_cast<SubSpecificationType>(channel), Lifetime::Timeframe);
-  inputs.emplace_back("ITS_alppar", "ITS", "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec("ITS/Config/AlpideParam"));
+  // inputs.emplace_back("TRK_almiraparam", "TRK", "ALMIRAPARAM", 0, Lifetime::Condition, ccdbParamSpec("TRK/Config/AlmiraParam"));
   // if (oTRKParams::Instance().useDeadChannelMap) {
   //   inputs.emplace_back("TRK_dead", "TRK", "DEADMAP", 0, Lifetime::Condition, ccdbParamSpec("TRK/Calib/DeadMap"));
   // }

From c9acd57adde48c3bf39e491f29e86083352c282f Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 13 Apr 2026 15:00:09 +0200
Subject: [PATCH 1534/1764] ITS: staggering (#15188)

* ITS: staggered tracking

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: various fixes also for GPU

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix vertexer and move new types

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: format

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: account for layer ROF bias in tracker

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: sort tracks in time by lower edge

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: ensure mc labels are nullptr

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITSMFT: account for possible delay of received ROFs

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: staggered STF decoder

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix track time-assignment

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: output vertices

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: add macro to check staggering in data

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Adapt ITS/MFT CTF machinery to staggered data

* Fix compilation of ALICE3 tracking with staggering

* ITS: modify staggering macro

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITSMFT: runtime staggering option

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITSMFT: fix instantiation in namespace

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS3: fix compilation

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Raw,CTF: add option to specify base cache dir for remote files

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: tracking same as dev

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: add back datastreams

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITSMFT: improve logging

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: add rofs for vertices back

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* add copyright to macro

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: hide print functions for device code

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITSMFT: add shim file for alpide param

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* try to fix macro compilation

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Avoid wildcarded subspecs in Digit/ClusterWriter

* ITS: fix rof lut to work properly with added errors

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Fix/add some staggering options

* Add ITS/MFT staggering options to dpl-workflow.sh

To activate ITS or MFT staggering in the topology generation, export ITSSTAGGERED=1
or MFTSTAGGERED=1 respectively

* ITS: try fix for QC

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix ROFLookpTables warning

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix tracklet formatting

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: set BCData properly for ROFs

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: remove deprecated settings

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix cluster label access for non-staggered

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITSMFT: fix staggering wfx option for digit-writer-workflow

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Fix loop condition for ITS tracking layers

* Fix/add some staggering options

* Add ITS/MFT staggering options to dpl-workflow.sh

To activate ITS or MFT staggering in the topology generation, export ITSSTAGGERED=1
or MFTSTAGGERED=1 respectively

* ITSMFT: fix staggering wfx option for digit-writer-workflow

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Fix loop condition for ITS tracking layers

* Make ITS vertex messageable

* remove unused variable

* Add/fix staggering options to all workflows reading ITS,MFT clusters

To pass the sim-challenge test. W/o this option even <workflow> -h leads to a crash.
Strictly speaking, one could use in the DPLAlpideParamInitializer::isITSStaggeringEnabled
and DPLAlpideParamInitializer::isMFTStaggeringEnabled a test
ic.options().hasOption(stagITSOpt) and ic.options().hasOption(stagMFTOpt) before testing
the option itself. But better to have an explicit detection of missing staggering option.

* ITSMFT: fix digit reader

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Remove leftover NROFs configurable from dpl-workflow.sh

* ITS: fix time assignments

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix degenerate LSE for matrix solving

Comparing the output of dev and this PR, I saw plently of cases where
the system of equation was fully degenerate and produced to different
floating instructions and compiler optimizations slightly different
results. The solution is to discard the vertex cand. if the LSE becomes
degenerate as not to produce non-sense solutions.

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix macro

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* MFT: fix track writer

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix gpu compile due change in vertexer types

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: move lookup table creation to proper place

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Move FastMultEstimation to ITS tracking library

* ITS: add containedIn to TS

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix vertexer

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: improve STFDecoder&Clusterer error messages and account for delay longer that ROF

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Implement new kind of multiplicity mask

* Adapt GPU code to the new mult mask

* ITS: finalize tracking code

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: remove deltaRof for vertexer

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: report current timeslice

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Vertex: also print time error

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: speedup vertexer

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
Co-authored-by: shahoian <ruben.shahoyan@cern.ch>
Co-authored-by: Maximiliano Puccio <maximiliano.puccio@cern.ch>
---
 .../GlobalTracking/src/RecoContainer.cxx      |   2 +-
 .../Detectors/ITSMFT/ITS/CMakeLists.txt       |   6 +-
 .../ITS/include/DataFormatsITS/TimeEstBC.h    | 103 +++
 .../ITS/include/DataFormatsITS/TrackITS.h     |  26 +-
 .../ITS/include/DataFormatsITS/Vertex.h       |  42 +
 .../ITSMFT/ITS/src/DataFormatsITSLinkDef.h    |   7 +
 .../Detectors/ITSMFT/ITS/src/TimeEstBC.cxx    |  13 +
 .../Detectors/ITSMFT/common/CMakeLists.txt    |   7 +-
 .../common/include/DataFormatsITSMFT/CTF.h    |   4 +-
 .../DataFormatsITSMFT/DPLAlpideParam.h        | 104 +++
 .../DPLAlpideParamInitializer.h               |  42 +
 .../ITSMFT/common}/src/DPLAlpideParam.cxx     |  11 +-
 .../common/src/DPLAlpideParamInitializer.cxx  |  46 +
 .../common/src/ITSMFTDataFormatsLinkDef.h     |   5 +
 .../ReconstructionDataFormats/Vertex.h        |  25 +-
 .../include/CommonDataFormat/TimeStamp.h      |  16 +-
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx |   2 +-
 Detectors/AOD/src/aod-producer-workflow.cxx   |   2 +
 .../Workflow/src/BarrelAlignmentSpec.cxx      |   2 +-
 .../src/barrel-alignment-workflow.cxx         |   2 +
 Detectors/CTF/test/test_ctf_io_itsmft.cxx     |   4 +-
 .../include/CTFWorkflow/CTFReaderSpec.h       |   3 +
 .../include/CTFWorkflow/CTFWriterSpec.h       |  11 +-
 Detectors/CTF/workflow/src/CTFReaderSpec.cxx  |  75 +-
 Detectors/CTF/workflow/src/CTFWriterSpec.cxx  | 215 +++--
 .../CTF/workflow/src/ctf-reader-workflow.cxx  |  12 +-
 .../CTF/workflow/src/ctf-writer-workflow.cxx  |  16 +-
 Detectors/Filtering/src/FilteringSpec.cxx     |   2 +-
 .../Filtering/src/filtering-workflow.cxx      |   2 +
 .../helpers/src/InputHelper.cxx               |   7 +-
 .../src/CosmicsMatchingSpec.cxx               |   2 +-
 .../src/GlobalFwdMatchingSpec.cxx             |   2 +-
 .../src/PrimaryVertexingSpec.cxx              |   2 +-
 .../src/TPCITSMatchingSpec.cxx                |   2 +-
 .../src/VertexTrackMatcherSpec.cxx            |   2 +-
 .../src/cosmics-match-workflow.cxx            |   2 +
 .../src/globalfwd-matcher-workflow.cxx        |   2 +
 .../src/secondary-vertexing-workflow.cxx      |   2 +
 .../src/strangeness-tracking-workflow.cxx     |   2 +
 .../src/tpcits-match-workflow.cxx             |   3 +
 .../study/src/CheckResid.cxx                  |   2 +-
 .../study/src/DumpTracks.cxx                  |   2 +-
 .../study/src/SVStudy.cxx                     |   2 +-
 .../study/src/TrackMCStudy.cxx                |   2 +-
 .../study/src/TrackingStudy.cxx               |   2 +-
 .../study/src/check-resid-workflow.cxx        |   2 +
 .../study/src/its-offset-study-workflow.cxx   |   2 +
 .../study/src/trackMCStudy-workflow.cxx       |   2 +
 .../study/src/tracking-study-workflow.cxx     |   2 +
 .../src/tpc-interpolation-workflow.cxx        |   2 +
 .../ITSMFT/ITS/macros/test/CMakeLists.txt     |  10 +
 Detectors/ITSMFT/ITS/macros/test/CheckDROF.C  |  21 +-
 .../ITSMFT/ITS/macros/test/CheckStaggering.C  | 521 +++++++++++
 .../studies/src/ImpactParameter.cxx           |   2 +-
 .../standalone-postprocessing-workflow.cxx    |   6 +-
 .../ITSMFT/ITS/reconstruction/CMakeLists.txt  |   6 +-
 .../include/ITSReconstruction/FastMultEst.h   |  70 --
 .../ITSReconstruction/TrivialVertexer.h       |  70 --
 .../ITS/reconstruction/src/FastMultEst.cxx    | 189 ----
 .../src/ITSReconstructionLinkDef.h            |   3 -
 .../reconstruction/src/TrivialVertexer.cxx    | 108 ---
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt  |   8 +-
 .../GPU/ITStrackingGPU/ClusterLinesGPU.h      |  73 --
 .../GPU/ITStrackingGPU/TimeFrameChunk.h       | 148 ---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         | 161 ++--
 .../tracking/GPU/ITStrackingGPU/TracerGPU.h   |  38 -
 .../GPU/ITStrackingGPU/TrackerTraitsGPU.h     |  15 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  75 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   |   6 +-
 .../GPU/ITStrackingGPU/VertexerTraitsGPU.h    |  55 --
 .../GPU/ITStrackingGPU/VertexingKernels.h     | 115 ---
 .../ITS/tracking/GPU/cuda/CMakeLists.txt      |  19 +-
 .../ITS/tracking/GPU/cuda/ClusterLinesGPU.cu  | 138 ---
 .../ITS/tracking/GPU/cuda/TimeFrameChunk.cu   | 293 ------
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 483 +++++-----
 .../ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu |  48 -
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 129 ++-
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 289 +++---
 .../tracking/GPU/cuda/VertexerTraitsGPU.cxx   | 179 ----
 .../ITS/tracking/GPU/cuda/VertexingKernels.cu | 660 --------------
 .../ITS/tracking/GPU/hip/CMakeLists.txt       |   6 +-
 .../include/ITStracking/BoundedAllocator.h    |   3 +
 .../ITS/tracking/include/ITStracking/Cell.h   |  39 +-
 .../tracking/include/ITStracking/Cluster.h    |   5 +-
 .../include/ITStracking/ClusterLines.h        | 221 +----
 .../include/ITStracking/Configuration.h       |  42 +-
 .../tracking/include/ITStracking/Constants.h  |   2 +-
 .../include/ITStracking/Definitions.h         |  38 +-
 .../include/ITStracking/FastMultEst.h         |  93 ++
 .../include/ITStracking}/FastMultEstConfig.h  |  30 +-
 .../tracking/include/ITStracking/MathUtils.h  |  33 +-
 .../include/ITStracking/ROFLookupTables.h     | 850 ++++++++++++++++++
 .../ITS/tracking/include/ITStracking/Road.h   |  72 --
 .../tracking/include/ITStracking/Smoother.h   |  60 --
 .../tracking/include/ITStracking/TimeFrame.h  | 480 ++++------
 .../tracking/include/ITStracking/Tracker.h    |  31 +-
 .../include/ITStracking/TrackerTraits.h       |  50 +-
 .../include/ITStracking/TrackingConfigParam.h |  28 +-
 .../include/ITStracking/TrackingInterface.h   |   5 +
 .../tracking/include/ITStracking/Tracklet.h   |  46 +-
 .../tracking/include/ITStracking/Vertexer.h   |  15 +-
 .../include/ITStracking/VertexerTraits.h      |  31 +-
 .../ITSMFT/ITS/tracking/src/ClusterLines.cxx  | 453 +++-------
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |  60 +-
 .../ITSMFT/ITS/tracking/src/FastMultEst.cxx   | 252 ++++++
 .../src/FastMultEstConfig.cxx                 |   2 +-
 .../ITS/tracking/src/IndexTableUtils.cxx      |  49 -
 .../ITSMFT/ITS/tracking/src/Smoother.cxx      | 222 -----
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 426 +++------
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx | 307 ++-----
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 576 +++---------
 .../ITS/tracking/src/TrackingInterface.cxx    | 397 ++++----
 .../ITSMFT/ITS/tracking/src/TrackingLinkDef.h |   7 +
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      |  60 +-
 .../ITS/tracking/src/VertexerTraits.cxx       | 742 +++++----------
 .../ITSMFT/ITS/tracking/test/CMakeLists.txt   |   8 +-
 .../ITS/tracking/test/testROFLookupTables.cxx | 744 +++++++++++++++
 .../ITSWorkflow/ClusterWriterWorkflow.h       |   2 +-
 .../include/ITSWorkflow/DCSAdaposParserSpec.h |   2 +-
 .../include/ITSWorkflow/RecoWorkflow.h        |   2 +-
 .../include/ITSWorkflow/TrackReaderSpec.h     |  27 +-
 .../include/ITSWorkflow/TrackerSpec.h         |   3 +-
 .../include/ITSWorkflow/VertexReaderSpec.h    |   2 +-
 .../workflow/src/ClusterWriterWorkflow.cxx    |   4 +-
 .../ITSMFT/ITS/workflow/src/RecoWorkflow.cxx  |  11 +-
 .../ITS/workflow/src/TrackReaderSpec.cxx      |  34 +-
 .../ITS/workflow/src/TrackWriterSpec.cxx      |  21 +-
 .../ITS/workflow/src/TrackWriterWorkflow.cxx  |   4 +-
 .../ITSMFT/ITS/workflow/src/TrackerSpec.cxx   |  49 +-
 .../src/its-cluster-reader-workflow.cxx       |   7 +-
 .../src/its-cluster-writer-workflow.cxx       |   8 +-
 .../ITS/workflow/src/its-reco-workflow.cxx    |  25 +-
 .../src/its-track-writer-workflow.cxx         |   3 +-
 .../calibration/src/NoiseCalibratorSpec.cxx   |   2 +-
 .../include/MFTCondition/DCSConfigReader.h    |   2 +-
 .../include/MFTWorkflow/RecoWorkflow.h        |   1 +
 .../include/MFTWorkflow/TrackerSpec.h         |   2 +-
 .../ITSMFT/MFT/workflow/src/RecoWorkflow.cxx  |   7 +-
 .../MFT/workflow/src/TrackWriterSpec.cxx      |  11 +-
 .../ITSMFT/MFT/workflow/src/TrackerSpec.cxx   |  13 +-
 .../src/mft-cluster-reader-workflow.cxx       |   5 +-
 .../src/mft-cluster-writer-workflow.cxx       |   8 +-
 .../MFT/workflow/src/mft-reco-workflow.cxx    |   4 +
 Detectors/ITSMFT/common/base/CMakeLists.txt   |   4 +-
 .../base/include/ITSMFTBase/DPLAlpideParam.h  | 111 +--
 .../common/base/src/ITSMFTBaseLinkDef.h       |   5 -
 .../include/ITSMFTReconstruction/CTFCoder.h   |  40 +-
 .../ITSMFTReconstruction/ChipMappingITS.h     |   5 +-
 .../ITSMFTReconstruction/ChipMappingMFT.h     |   3 +
 .../ITSMFTReconstruction/PixelReader.h        |   8 +-
 .../ITSMFTReconstruction/RawPixelDecoder.h    |  11 +-
 .../ITSMFTReconstruction/RawPixelReader.h     |   7 +-
 .../common/reconstruction/src/CTFCoder.cxx    |  42 +-
 .../reconstruction/src/ChipMappingITS.cxx     |  24 +-
 .../reconstruction/src/ChipMappingMFT.cxx     |  14 +
 .../common/reconstruction/src/Clusterer.cxx   |   2 +-
 .../common/reconstruction/src/GBTLink.cxx     |   2 +-
 .../reconstruction/src/RawPixelDecoder.cxx    |  43 +-
 .../include/ITSMFTSimulation/DigiParams.h     |   2 +-
 .../ITSMFTWorkflow/ClusterReaderSpec.h        |  41 +-
 .../ITSMFTWorkflow/ClusterWriterSpec.h        |   6 +-
 .../include/ITSMFTWorkflow/ClustererSpec.h    |  11 +-
 .../include/ITSMFTWorkflow/DigitReaderSpec.h  |  47 +-
 .../include/ITSMFTWorkflow/DigitWriterSpec.h  |   4 +-
 .../ITSMFTWorkflow/EntropyDecoderSpec.h       |  17 +-
 .../ITSMFTWorkflow/EntropyEncoderSpec.h       |  16 +-
 .../include/ITSMFTWorkflow/STFDecoderSpec.h   |  30 +-
 .../common/workflow/src/ClusterReaderSpec.cxx |  47 +-
 .../common/workflow/src/ClusterWriterSpec.cxx |  57 +-
 .../common/workflow/src/ClustererSpec.cxx     |  81 +-
 .../common/workflow/src/DigitReaderSpec.cxx   |  77 +-
 .../common/workflow/src/DigitWriterSpec.cxx   |  54 +-
 .../workflow/src/EntropyDecoderSpec.cxx       | 172 ++--
 .../workflow/src/EntropyEncoderSpec.cxx       | 118 ++-
 .../common/workflow/src/STFDecoderSpec.cxx    | 394 +++++---
 .../workflow/src/digit-reader-workflow.cxx    |   8 +-
 .../workflow/src/digit-writer-workflow.cxx    |   9 +-
 .../workflow/src/entropy-encoder-workflow.cxx |   9 +-
 .../workflow/src/stf-decoder-workflow.cxx     |   8 +-
 Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx |   2 +-
 Detectors/Raw/TFReaderDD/src/TFReaderSpec.h   |   1 +
 .../Raw/TFReaderDD/src/tf-reader-workflow.cxx |   2 +
 .../workflow/src/trd-tracking-workflow.cxx    |   2 +
 .../include/TRKReconstruction/TimeFrame.h     |   9 +-
 .../TRK/reconstruction/src/TimeFrame.cxx      |  93 +-
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   |  92 +-
 .../ITS3Reconstruction/TrackingInterface.h    |   1 +
 .../ITS3/reconstruction/src/IOUtils.cxx       |  10 +-
 .../reconstruction/src/TrackingInterface.cxx  |   5 +-
 .../ITS3/workflow/src/ClustererSpec.cxx       |   2 +-
 .../ITS3/workflow/src/RecoWorkflow.cxx        |   2 +-
 .../ITS3/workflow/src/TrackerSpec.cxx         |   4 +-
 .../include/DetectorsVertexing/PVertexer.h    |   2 +-
 .../Vertexing/src/VertexTrackMatcher.cxx      |   2 +-
 Detectors/Vertexing/test/PVFromPool.C         |  13 +-
 .../Workflow/src/EveWorkflowHelper.cxx        |   2 +-
 .../Workflow/src/O2DPLDisplay.cxx             |   3 +-
 .../Base/GPUReconstructionIncludesITS.h       |   5 -
 .../Base/cuda/GPUReconstructionCUDA.cu        |   6 +-
 GPU/GPUTracking/Global/GPUChainITS.h          |   3 -
 .../display/render/GPUDisplayImportEvent.cxx  |   2 +-
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |   1 +
 GPU/Workflow/src/GPUWorkflowITS.cxx           |   9 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |  16 +-
 GPU/Workflow/src/O2GPUDPLDisplay.cxx          |   3 +-
 GPU/Workflow/src/gpu-reco-workflow.cxx        |   3 +
 .../src/ITS3DigitizerSpec.cxx                 |   2 +-
 .../src/ITSMFTDigitizerSpec.cxx               |  99 +-
 .../src/ITSMFTDigitizerSpec.h                 |   4 +-
 .../src/SimpleDigitizerWorkflow.cxx           |  12 +-
 doc/data/2021-02-o2_prs.json                  |   2 +-
 doc/data/2022-01-o2_prs.json                  |   2 +-
 macro/run_rawdecoding_its.C                   |  21 +-
 macro/run_rawdecoding_mft.C                   |  21 +-
 prodtests/full-system-test/dpl-workflow.sh    |  30 +-
 prodtests/full_system_test.sh                 |   4 -
 216 files changed, 6352 insertions(+), 7206 deletions(-)
 create mode 100644 DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TimeEstBC.h
 create mode 100644 DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/Vertex.h
 create mode 100644 DataFormats/Detectors/ITSMFT/ITS/src/TimeEstBC.cxx
 create mode 100644 DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/DPLAlpideParam.h
 create mode 100644 DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/DPLAlpideParamInitializer.h
 rename {Detectors/ITSMFT/common/base => DataFormats/Detectors/ITSMFT/common}/src/DPLAlpideParam.cxx (82%)
 create mode 100644 DataFormats/Detectors/ITSMFT/common/src/DPLAlpideParamInitializer.cxx
 create mode 100644 Detectors/ITSMFT/ITS/macros/test/CheckStaggering.C
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/FastMultEst.h
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/TrivialVertexer.h
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/src/FastMultEst.cxx
 delete mode 100644 Detectors/ITSMFT/ITS/reconstruction/src/TrivialVertexer.cxx
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/ClusterLinesGPU.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TracerGPU.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/cuda/ClusterLinesGPU.cu
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameChunk.cu
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
 create mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h
 rename Detectors/ITSMFT/ITS/{reconstruction/include/ITSReconstruction => tracking/include/ITStracking}/FastMultEstConfig.h (58%)
 create mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROFLookupTables.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/Smoother.h
 create mode 100644 Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx
 rename Detectors/ITSMFT/ITS/{reconstruction => tracking}/src/FastMultEstConfig.cxx (94%)
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/src/IndexTableUtils.cxx
 delete mode 100644 Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
 create mode 100644 Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx

diff --git a/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx b/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
index dd206ffe3b70d..277466fb2e969 100644
--- a/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
+++ b/DataFormats/Detectors/GlobalTracking/src/RecoContainer.cxx
@@ -34,7 +34,7 @@
 #include "ReconstructionDataFormats/TrackMCHMID.h"
 #include "DataFormatsITSMFT/TrkClusRef.h"
 #include "DataFormatsITSMFT/TopologyDictionary.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 // FIXME: ideally, the data formats definition should be independent of the framework
 // collectData is using the input of ProcessingContext to extract the first valid
 // header and the TF orbit from it
diff --git a/DataFormats/Detectors/ITSMFT/ITS/CMakeLists.txt b/DataFormats/Detectors/ITSMFT/ITS/CMakeLists.txt
index 5a353881e27ba..f05979d749fc0 100644
--- a/DataFormats/Detectors/ITSMFT/ITS/CMakeLists.txt
+++ b/DataFormats/Detectors/ITSMFT/ITS/CMakeLists.txt
@@ -11,8 +11,12 @@
 
 o2_add_library(DataFormatsITS
                SOURCES src/TrackITS.cxx
+                       src/TimeEstBC.cxx
                PUBLIC_LINK_LIBRARIES O2::ReconstructionDataFormats
+                                     O2::SimulationDataFormat
                                      O2::DataFormatsITSMFT)
 
 o2_target_root_dictionary(DataFormatsITS
-                          HEADERS include/DataFormatsITS/TrackITS.h)
+                          HEADERS include/DataFormatsITS/TrackITS.h
+                                  include/DataFormatsITS/Vertex.h
+                                  include/DataFormatsITS/TimeEstBC.h)
diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TimeEstBC.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TimeEstBC.h
new file mode 100644
index 0000000000000..695d9aff42858
--- /dev/null
+++ b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TimeEstBC.h
@@ -0,0 +1,103 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRACKINGITS_TIMEESTBC_H_
+#define O2_TRACKINGITS_TIMEESTBC_H_
+
+#include <limits>
+#include <cstdint>
+#include "CommonDataFormat/TimeStamp.h"
+#include "GPUCommonRtypes.h"
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
+
+namespace o2::its
+{
+// Time estimates are given in BC
+// error needs to cover maximum 1 orbit
+using TimeStampType = uint32_t;
+using TimeStampErrorType = uint16_t;
+// this is an symmetric time error [t0-tE, t0+tE]
+using TimeStamp = o2::dataformats::TimeStampWithError<float, float>;
+// this is an asymmetric time interval [t0, t0+tE] used for internal calculations
+class TimeEstBC : public o2::dataformats::TimeStampWithError<TimeStampType, TimeStampErrorType>
+{
+  using Base = o2::dataformats::TimeStampWithError<TimeStampType, TimeStampErrorType>;
+
+ public:
+  GPUhdDefault() TimeEstBC() = default;
+  GPUhdi() TimeEstBC(TimeStampType t, TimeStampErrorType e) : Base(t, e) {}
+
+  // convert to symmetric center+-half representation
+  GPUhdi() its::TimeStamp makeSymmetrical() const noexcept
+  {
+    const auto start = static_cast<float>(this->getTimeStamp());
+    const float half = (float)this->getTimeStampError() / 2.f;
+    return {start + half, half};
+  }
+
+  // check if timestamps overlap within their interval
+  GPUhdi() bool isCompatible(const TimeEstBC& o) const noexcept
+  {
+    return this->upper() > o.lower() && o.upper() > this->lower();
+  }
+
+  // check if this time interval is fully contained within o
+  GPUhdi() bool isContainedIn(const TimeEstBC& o) const noexcept
+  {
+    return this->lower() >= o.lower() && this->upper() <= o.upper();
+  }
+
+  GPUhdi() TimeEstBC& operator+=(const TimeEstBC& o) noexcept
+  {
+    add(o);
+    return *this;
+  }
+
+  GPUhdi() TimeEstBC operator+(const TimeEstBC& o) const noexcept
+  {
+    TimeEstBC res = *this;
+    res += o;
+    return res;
+  }
+
+  // upper bound of interval t0+tE
+  GPUhdi() TimeStampType upper() const noexcept
+  {
+    TimeStampType t = this->getTimeStamp();
+    TimeStampType e = this->getTimeStampError();
+    constexpr TimeStampType max = std::numeric_limits<TimeStampType>::max();
+    return (t > (max - e)) ? max : t + e;
+  }
+
+  // lower bound of interval t0
+  GPUhdi() TimeStampType lower() const noexcept
+  {
+    return this->getTimeStamp();
+  }
+
+ private:
+  // intersect with the other timestamp
+  // this assumes already that both overlap
+  GPUhdi() void add(const TimeEstBC& o) noexcept
+  {
+    const TimeStampType lo = o2::gpu::CAMath::Max(this->lower(), o.lower());
+    const TimeStampType hi = o2::gpu::CAMath::Min(this->upper(), o.upper());
+    this->setTimeStamp(lo);
+    this->setTimeStampError(static_cast<TimeStampErrorType>(hi - lo));
+  }
+
+  ClassDefNV(TimeEstBC, 1);
+};
+
+} // namespace o2::its
+
+#endif
diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
index 06d4fba51bd54..5d13ad753b8bc 100644
--- a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
+++ b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -16,11 +16,12 @@
 #ifndef ALICEO2_ITS_TRACKITS_H
 #define ALICEO2_ITS_TRACKITS_H
 
-#include <vector>
+#include <cstdint>
 
 #include "GPUCommonDef.h"
 #include "ReconstructionDataFormats/Track.h"
 #include "CommonDataFormat/RangeReference.h"
+#include "DataFormatsITS/TimeEstBC.h"
 
 namespace o2
 {
@@ -35,8 +36,7 @@ namespace its
 class TrackITS : public o2::track::TrackParCov
 {
   enum UserBits {
-    kNextROF = 1 << 28,
-    kSharedClusters = 1 << 29
+    kSharedClusters = 1 << 28
   };
 
   using Cluster = o2::itsmft::Cluster;
@@ -93,6 +93,9 @@ class TrackITS : public o2::track::TrackParCov
 
   bool isBetter(const TrackITS& best, float maxChi2) const;
 
+  GPUhdi() auto& getTimeStamp() { return mTime; }
+  GPUhdi() const auto& getTimeStamp() const { return mTime; }
+
   GPUhdi() o2::track::TrackParCov& getParamIn() { return *this; }
   GPUhdi() const o2::track::TrackParCov& getParamIn() const { return *this; }
 
@@ -122,8 +125,6 @@ class TrackITS : public o2::track::TrackParCov
   }
   int getNFakeClusters() const;
 
-  void setNextROFbit(bool toggle = true) { mClusterSizes = toggle ? (mClusterSizes | kNextROF) : (mClusterSizes & ~kNextROF); }
-  bool hasHitInNextROF() const { return mClusterSizes & kNextROF; }
   void setSharedClusters(bool toggle = true) { mClusterSizes = toggle ? (mClusterSizes | kSharedClusters) : (mClusterSizes & ~kSharedClusters); }
   bool hasSharedClusters() const { return mClusterSizes & kSharedClusters; }
 
@@ -157,9 +158,10 @@ class TrackITS : public o2::track::TrackParCov
   ClusRefs mClusRef;                ///< references on clusters
   float mChi2 = 0.;                 ///< Chi2 for this track
   uint32_t mPattern = 0;            ///< layers pattern
-  unsigned int mClusterSizes = 0u;
+  uint32_t mClusterSizes = 0u;      ///< 4bit packed cluster sizes
+  TimeStamp mTime;                  ///< track time stamp with error in BC since start of TF, symmetrical
 
-  ClassDefNV(TrackITS, 6);
+  ClassDefNV(TrackITS, 7);
 };
 
 class TrackITSExt : public TrackITS
@@ -169,15 +171,13 @@ class TrackITSExt : public TrackITS
   static constexpr int MaxClusters = 16; /// Prepare for overlaps and new detector configurations
   using TrackITS::TrackITS;              // inherit base constructors
 
-  GPUh() TrackITSExt(o2::track::TrackParCov&& parCov, short ncl, float chi2,
-                     o2::track::TrackParCov&& outer, std::array<int, MaxClusters> cls)
+  GPUh() TrackITSExt(o2::track::TrackParCov&& parCov, short ncl, float chi2, o2::track::TrackParCov&& outer, std::array<int, MaxClusters> cls)
     : TrackITS(parCov, chi2, outer), mIndex{cls}
   {
     setNumberOfClusters(ncl);
   }
 
-  GPUh() TrackITSExt(o2::track::TrackParCov& parCov, short ncl, float chi2, std::uint32_t rof,
-                     o2::track::TrackParCov& outer, std::array<int, MaxClusters> cls)
+  GPUh() TrackITSExt(o2::track::TrackParCov& parCov, short ncl, float chi2, std::uint32_t rof, o2::track::TrackParCov& outer, std::array<int, MaxClusters> cls)
     : TrackITS(parCov, chi2, outer), mIndex{cls}
   {
     setNumberOfClusters(ncl);
@@ -212,7 +212,7 @@ class TrackITSExt : public TrackITS
 
  private:
   std::array<int, MaxClusters> mIndex = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; ///< Indices of associated clusters
-  ClassDefNV(TrackITSExt, 2);
+  ClassDefNV(TrackITSExt, 3);
 };
 } // namespace its
 } // namespace o2
diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/Vertex.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/Vertex.h
new file mode 100644
index 0000000000000..1e4ed03b753eb
--- /dev/null
+++ b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/Vertex.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRACKINGITS_VERTEX_H_
+#define O2_TRACKINGITS_VERTEX_H_
+
+#include "GPUCommonDef.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <type_traits>
+#endif
+#include "ReconstructionDataFormats/Vertex.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "DataFormatsITS/TimeEstBC.h"
+
+namespace o2::its
+{
+// NOTE: this uses the internal asymmetrical time reprenstation!
+using Vertex = o2::dataformats::Vertex<o2::its::TimeEstBC>;
+using VertexLabel = std::pair<o2::MCCompLabel, float>;
+} // namespace o2::its
+
+#ifndef GPUCA_GPUCODE_DEVICE
+/// Defining ITS Vertex explicitly as messageable
+namespace o2::framework
+{
+template <typename T>
+struct is_messageable;
+template <>
+struct is_messageable<o2::dataformats::Vertex<o2::its::TimeEstBC>> : std::true_type {
+};
+} // namespace o2::framework
+#endif
+
+#endif
diff --git a/DataFormats/Detectors/ITSMFT/ITS/src/DataFormatsITSLinkDef.h b/DataFormats/Detectors/ITSMFT/ITS/src/DataFormatsITSLinkDef.h
index 91a71847148fb..a0d5b25c65b70 100644
--- a/DataFormats/Detectors/ITSMFT/ITS/src/DataFormatsITSLinkDef.h
+++ b/DataFormats/Detectors/ITSMFT/ITS/src/DataFormatsITSLinkDef.h
@@ -14,7 +14,14 @@
 #pragma link off all globals;
 #pragma link off all classes;
 #pragma link off all functions;
+
 #pragma link C++ class o2::its::TrackITS + ;
 #pragma link C++ class std::vector < o2::its::TrackITS> + ;
 
+#pragma link C++ class o2::its::TimeEstBC + ;
+#pragma link C++ class std::vector < o2::its::TimeEstBC> + ;
+
+#pragma link C++ class o2::dataformats::Vertex < o2::its::TimeEstBC> + ;
+#pragma link C++ class std::vector < o2::dataformats::Vertex < o2::its::TimeEstBC>> + ;
+
 #endif
diff --git a/DataFormats/Detectors/ITSMFT/ITS/src/TimeEstBC.cxx b/DataFormats/Detectors/ITSMFT/ITS/src/TimeEstBC.cxx
new file mode 100644
index 0000000000000..3af299cf74d25
--- /dev/null
+++ b/DataFormats/Detectors/ITSMFT/ITS/src/TimeEstBC.cxx
@@ -0,0 +1,13 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "DataFormatsITS/TimeEstBC.h"
+ClassImp(o2::its::TimeEstBC);
\ No newline at end of file
diff --git a/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt b/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
index 96d376526a1a4..a619f8ad0081d 100644
--- a/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
+++ b/DataFormats/Detectors/ITSMFT/common/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 # See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 # All rights not expressly granted are reserved.
 #
@@ -20,13 +20,18 @@ o2_add_library(DataFormatsITSMFT
                        src/TopologyDictionary.cxx
                        src/TimeDeadMap.cxx
                        src/CTF.cxx
+                       src/DPLAlpideParam.cxx
+                       src/DPLAlpideParamInitializer.cxx
                PUBLIC_LINK_LIBRARIES O2::ITSMFTBase
+                       O2::DetectorsCommonDataFormats
                        O2::ReconstructionDataFormats
+                       O2::CommonUtils
                        Microsoft.GSL::GSL)
 
 o2_target_root_dictionary(DataFormatsITSMFT
                           HEADERS include/DataFormatsITSMFT/ROFRecord.h
                                   include/DataFormatsITSMFT/Digit.h
+                                  include/DataFormatsITSMFT/DPLAlpideParam.h
                                   include/DataFormatsITSMFT/GBTCalibData.h
                                   include/DataFormatsITSMFT/NoiseMap.h
                                   include/DataFormatsITSMFT/TimeDeadMap.h
diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/CTF.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/CTF.h
index 314523aa878ba..0510b6df5225c 100644
--- a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/CTF.h
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/CTF.h
@@ -36,7 +36,9 @@ struct CTFHeader : public o2::ctf::CTFDictHeader {
   uint32_t nPatternBytes = 0; /// number of bytes for explict patterns
   uint32_t firstOrbit = 0;    /// 1st orbit of TF
   uint16_t firstBC = 0;       /// 1st BC of TF
-  ClassDefNV(CTFHeader, 2);
+  uint8_t maxStreams = 1;     /// Number of streams per TF (== NLayers for staggered ITS/MFT readout, 1 for non-staggered one)
+  uint8_t streamID = 0;       /// ID of the stream (0:maxStreams-1)
+  ClassDefNV(CTFHeader, 3);
 };
 
 /// Compressed but not yet entropy-encoded clusters
diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/DPLAlpideParam.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/DPLAlpideParam.h
new file mode 100644
index 0000000000000..a06ba0745edbd
--- /dev/null
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/DPLAlpideParam.h
@@ -0,0 +1,104 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_ITSMFTALPIDEPARAM_H_
+#define ALICEO2_ITSMFTALPIDEPARAM_H_
+
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+#include "CommonConstants/LHCConstants.h"
+#include <string_view>
+
+namespace o2
+{
+namespace itsmft
+{
+constexpr float DEFStrobeDelay = o2::constants::lhc::LHCBunchSpacingNS * 4; // ~100 ns delay
+
+template <int N>
+struct DPLAlpideParam : public o2::conf::ConfigurableParamHelper<DPLAlpideParam<N>> {
+  static constexpr int getNLayers()
+  {
+    return N == o2::detectors::DetID::ITS ? 7 : 10;
+  }
+
+  static constexpr std::string_view getParamName()
+  {
+    return N == o2::detectors::DetID::ITS ? ParamName[0] : ParamName[1];
+  }
+
+  int roFrameLengthInBC = DEFROFLengthBC();      ///< ROF length in BC for continuous mode
+  float roFrameLengthTrig = DEFROFLengthTrig();  ///< length of RO frame in ns for triggered mode
+  float strobeDelay = DEFStrobeDelay;            ///< strobe start (in ns) wrt ROF start
+  float strobeLengthCont = -1.;                  ///< if < 0, full ROF length - delay
+  float strobeLengthTrig = 100.;                 ///< length of the strobe in ns (sig. over threshold checked in this window only)
+  int roFrameBiasInBC = DEFROFBiasInBC();        ///< bias of the start of ROF wrt orbit start: t_irof = (irof*roFrameLengthInBC + roFrameBiasInBC)*BClengthMUS
+  int roFrameLayerLengthInBC[getNLayers()] = {}; ///< staggering ROF length in BC for continuous mode per layer
+  int roFrameLayerBiasInBC[getNLayers()] = {};   ///< staggering ROF bias in BC for continuous mode per layer
+  int roFrameLayerDelayInBC[getNLayers()] = {};  ///< staggering ROF delay in BC for continuous mode per layer
+
+  // get ROF length for any layer
+  int getROFLengthInBC(int layer) const noexcept { return roFrameLayerLengthInBC[layer] ? roFrameLayerLengthInBC[layer] : roFrameLengthInBC; }
+  int getROFBiasInBC(int layer) const noexcept { return roFrameLayerBiasInBC[layer] ? roFrameLayerBiasInBC[layer] : roFrameBiasInBC; }
+  int getROFDelayInBC(int layer) const noexcept { return roFrameLayerDelayInBC[layer] ? roFrameLayerDelayInBC[layer] : 0; }
+
+  // boilerplate stuff + make principal key
+  O2ParamDef(DPLAlpideParam, getParamName().data());
+
+ private:
+  static constexpr std::string_view ParamName[2] = {"ITSAlpideParam", "MFTAlpideParam"};
+
+  static constexpr int DEFROFLengthBC()
+  {
+    // default ROF length in BC for continuous mode
+    // allowed values: 1,2,3,4,6,9,11,12,18,22,27,33,36
+    return N == o2::detectors::DetID::ITS ? o2::constants::lhc::LHCMaxBunches / 4 : o2::constants::lhc::LHCMaxBunches / 18;
+  }
+  static constexpr float DEFROFLengthTrig()
+  {
+    // length of RO frame in ns for triggered mode
+    return N == o2::detectors::DetID::ITS ? 6000. : 6000.;
+  }
+
+  static constexpr int DEFROFBiasInBC()
+  {
+    // default ROF length bias in MC, see https://github.com/AliceO2Group/AliceO2/pull/11108 for ITS
+    return N == o2::detectors::DetID::ITS ? 64 : 60;
+  }
+
+  static_assert(N == o2::detectors::DetID::ITS || N == o2::detectors::DetID::MFT, "only DetID::ITS orDetID:: MFT are allowed");
+  static_assert(o2::constants::lhc::LHCMaxBunches % DEFROFLengthBC() == 0); // make sure ROF length is divisor of the orbit
+};
+
+template <int N>
+DPLAlpideParam<N> DPLAlpideParam<N>::sInstance;
+
+} // namespace itsmft
+
+namespace framework
+{
+template <typename T>
+struct is_messageable;
+template <>
+struct is_messageable<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>> : std::true_type {
+};
+template <typename T>
+struct is_messageable;
+template <>
+struct is_messageable<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>> : std::true_type {
+};
+
+} // namespace framework
+
+} // namespace o2
+
+#endif
diff --git a/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/DPLAlpideParamInitializer.h b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/DPLAlpideParamInitializer.h
new file mode 100644
index 0000000000000..b3ec20f2a68b7
--- /dev/null
+++ b/DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/DPLAlpideParamInitializer.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_ITSMFTALPIDEPARAM_INITIALIZER_H_
+#define ALICEO2_ITSMFTALPIDEPARAM_INITIALIZER_H_
+#include <vector>
+
+namespace o2
+{
+namespace framework
+{
+class ConfigParamSpec;
+class ConfigContext;
+} // namespace framework
+namespace itsmft
+{
+
+struct DPLAlpideParamInitializer {
+  static constexpr char stagITSOpt[] = "enable-its-staggering";
+  static constexpr char stagMFTOpt[] = "enable-mft-staggering";
+  static constexpr bool stagDef = false;
+
+  // DPL workflow options for staggering
+  static void addConfigOption(std::vector<o2::framework::ConfigParamSpec>& opts);
+  static void addITSConfigOption(std::vector<o2::framework::ConfigParamSpec>& opts);
+  static bool isITSStaggeringEnabled(o2::framework::ConfigContext const& cfgc);
+  static void addMFTConfigOption(std::vector<o2::framework::ConfigParamSpec>& opts);
+  static bool isMFTStaggeringEnabled(o2::framework::ConfigContext const& cfgc);
+};
+
+} // namespace itsmft
+} // namespace o2
+
+#endif
diff --git a/Detectors/ITSMFT/common/base/src/DPLAlpideParam.cxx b/DataFormats/Detectors/ITSMFT/common/src/DPLAlpideParam.cxx
similarity index 82%
rename from Detectors/ITSMFT/common/base/src/DPLAlpideParam.cxx
rename to DataFormats/Detectors/ITSMFT/common/src/DPLAlpideParam.cxx
index 1cb9bdf997d68..205f8a008a661 100644
--- a/Detectors/ITSMFT/common/base/src/DPLAlpideParam.cxx
+++ b/DataFormats/Detectors/ITSMFT/common/src/DPLAlpideParam.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -9,15 +9,12 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 
-namespace o2
-{
-namespace itsmft
+namespace o2::itsmft
 {
 // this makes sure that the constructor of the parameters is statically called
 // so that these params are part of the parameter database
 static auto& sAlpideParamITS = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
 static auto& sAlpideParamMFT = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>::Instance();
-} // namespace itsmft
-} // namespace o2
+} // namespace o2::itsmft
diff --git a/DataFormats/Detectors/ITSMFT/common/src/DPLAlpideParamInitializer.cxx b/DataFormats/Detectors/ITSMFT/common/src/DPLAlpideParamInitializer.cxx
new file mode 100644
index 0000000000000..715ec5d90b813
--- /dev/null
+++ b/DataFormats/Detectors/ITSMFT/common/src/DPLAlpideParamInitializer.cxx
@@ -0,0 +1,46 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
+#include "Framework/ConfigParamsHelper.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/ConfigContext.h"
+
+namespace o2::itsmft
+{
+
+void DPLAlpideParamInitializer::addConfigOption(std::vector<o2::framework::ConfigParamSpec>& opts)
+{
+  addITSConfigOption(opts);
+  addMFTConfigOption(opts);
+}
+
+void DPLAlpideParamInitializer::addITSConfigOption(std::vector<o2::framework::ConfigParamSpec>& opts)
+{
+  o2::framework::ConfigParamsHelper::addOptionIfMissing(opts, {stagITSOpt, o2::framework::VariantType::Bool, stagDef, {"enable per layer ITS in&out-put for staggered readout"}});
+}
+
+void DPLAlpideParamInitializer::addMFTConfigOption(std::vector<o2::framework::ConfigParamSpec>& opts)
+{
+  o2::framework::ConfigParamsHelper::addOptionIfMissing(opts, {stagMFTOpt, o2::framework::VariantType::Bool, stagDef, {"enable per layer MFT in&out-put for staggered readout"}});
+}
+
+bool DPLAlpideParamInitializer::isITSStaggeringEnabled(const o2::framework::ConfigContext& cfgc)
+{
+  return cfgc.options().get<bool>(stagITSOpt);
+}
+
+bool DPLAlpideParamInitializer::isMFTStaggeringEnabled(const o2::framework::ConfigContext& cfgc)
+{
+  return cfgc.options().get<bool>(stagMFTOpt);
+}
+
+} // namespace o2::itsmft
diff --git a/DataFormats/Detectors/ITSMFT/common/src/ITSMFTDataFormatsLinkDef.h b/DataFormats/Detectors/ITSMFT/common/src/ITSMFTDataFormatsLinkDef.h
index fc67fdf028436..1b1918b46c9d4 100644
--- a/DataFormats/Detectors/ITSMFT/common/src/ITSMFTDataFormatsLinkDef.h
+++ b/DataFormats/Detectors/ITSMFT/common/src/ITSMFTDataFormatsLinkDef.h
@@ -15,6 +15,11 @@
 #pragma link off all classes;
 #pragma link off all functions;
 
+#pragma link C++ class o2::itsmft::DPLAlpideParam < o2::detectors::DetID::ITS> + ;
+#pragma link C++ class o2::itsmft::DPLAlpideParam < o2::detectors::DetID::MFT> + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::itsmft::DPLAlpideParam < o2::detectors::DetID::ITS>> + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::itsmft::DPLAlpideParam < o2::detectors::DetID::MFT>> + ;
+
 #pragma link C++ class o2::itsmft::Digit + ;
 #pragma link C++ class o2::itsmft::NoiseMap + ;
 #pragma link C++ class o2::itsmft::TimeDeadMap + ;
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
index cb1c9d5d87c7f..588a23d25a000 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/Vertex.h
@@ -152,7 +152,10 @@ class Vertex : public VertexBase
   std::string asString() const;
 #endif
 
-  GPUd() ushort getNContributors() const { return mNContributors; }
+  GPUd() ushort getNContributors() const
+  {
+    return mNContributors;
+  }
   GPUd() void setNContributors(ushort v) { mNContributors = v; }
   GPUd() void addContributor() { mNContributors++; }
 
@@ -184,12 +187,26 @@ namespace detail
 {
 template <typename T>
 concept Streamable = requires(std::ostream& os, const T& a) {
-  { os << a } -> std::same_as<std::ostream&>;
+  {
+    os << a
+  }
+  -> std::same_as<std::ostream&>;
 };
 
 template <typename T>
 concept HasFormattableTimeStamp = requires(const T& t) {
-  { fmt::format("{}", t.getTimeStamp()) } -> std::convertible_to<std::string>;
+  {
+    fmt::format("{}", t.getTimeStamp())
+  }
+  -> std::convertible_to<std::string>;
+};
+
+template <typename T>
+concept HasFormattableTimeStampWithError = requires(const T& t) {
+  {
+    fmt::format("{}+-{}", t.getTimeStamp(), t.getTimeStampError())
+  }
+  -> std::convertible_to<std::string>;
 };
 } // namespace detail
 
@@ -201,6 +218,8 @@ inline std::string Vertex<Stamp>::asString() const
       std::ostringstream oss;
       oss << mTimeStamp;
       return oss.str();
+    } else if constexpr (detail::HasFormattableTimeStampWithError<Stamp>) {
+      return fmt::format("{}+-{}", mTimeStamp.getTimeStamp(), mTimeStamp.getTimeStampError());
     } else if constexpr (detail::HasFormattableTimeStamp<Stamp>) {
       return fmt::format("{}", mTimeStamp.getTimeStamp());
     } else {
diff --git a/DataFormats/common/include/CommonDataFormat/TimeStamp.h b/DataFormats/common/include/CommonDataFormat/TimeStamp.h
index 56a71414c6b86..709af221c28f8 100644
--- a/DataFormats/common/include/CommonDataFormat/TimeStamp.h
+++ b/DataFormats/common/include/CommonDataFormat/TimeStamp.h
@@ -27,10 +27,10 @@ class TimeStamp
  public:
   GPUhdDefault() TimeStamp() = default;
   GPUhdDefault() ~TimeStamp() = default;
-  GPUdi() TimeStamp(T time) { mTimeStamp = time; }
+  GPUhdi() TimeStamp(T time) { mTimeStamp = time; }
   GPUhdi() T getTimeStamp() const { return mTimeStamp; }
-  GPUdi() void setTimeStamp(T t) { mTimeStamp = t; }
-  GPUdi() bool operator==(const TimeStamp<T>& t) const { return mTimeStamp == t.mTimeStamp; }
+  GPUhdi() void setTimeStamp(T t) { mTimeStamp = t; }
+  GPUhdi() bool operator==(const TimeStamp<T>& t) const { return mTimeStamp == t.mTimeStamp; }
 
  private:
   T mTimeStamp = 0;
@@ -41,11 +41,11 @@ template <typename T, typename E>
 class TimeStampWithError : public TimeStamp<T>
 {
  public:
-  GPUdDefault() TimeStampWithError() = default;
-  GPUd() TimeStampWithError(T t, E te) : TimeStamp<T>(t), mTimeStampError(te) {}
-  GPUdi() E getTimeStampError() const { return mTimeStampError; }
-  GPUdi() E getTimeStampError2() const { return mTimeStampError * mTimeStampError; }
-  GPUdi() void setTimeStampError(E te) { mTimeStampError = te; }
+  GPUhdDefault() TimeStampWithError() = default;
+  GPUhd() TimeStampWithError(T t, E te) : TimeStamp<T>(t), mTimeStampError(te) {}
+  GPUhdi() E getTimeStampError() const { return mTimeStampError; }
+  GPUhdi() E getTimeStampError2() const { return mTimeStampError * mTimeStampError; }
+  GPUhdi() void setTimeStampError(E te) { mTimeStampError = te; }
 
  private:
   E mTimeStampError = 0;
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 80b9e6ef4b551..afff39791e4ec 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -60,7 +60,7 @@
 #include "GlobalTracking/MatchGlobalFwd.h"
 #include "MCHTracking/TrackExtrap.h"
 #include "MCHTracking/TrackParam.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsVertexing/PVertexerParams.h"
 #include "ReconstructionDataFormats/GlobalFwdTrack.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
diff --git a/Detectors/AOD/src/aod-producer-workflow.cxx b/Detectors/AOD/src/aod-producer-workflow.cxx
index f6bfaae170bbd..d75694f3bd512 100644
--- a/Detectors/AOD/src/aod-producer-workflow.cxx
+++ b/Detectors/AOD/src/aod-producer-workflow.cxx
@@ -18,6 +18,7 @@
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
 #include "DetectorsBase/DPLWorkflowUtils.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -43,6 +44,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}},
     {"combine-source-devices", o2::framework::VariantType::Bool, false, {"merge DPL source devices"}},
     {"ctpconfig-run-independent", o2::framework::VariantType::Bool, false, {"Use CTP config w/o runNumber tag"}}};
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
diff --git a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
index d4ab53c8181ce..2e63a1a65483c 100644
--- a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
+++ b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
@@ -64,7 +64,7 @@
 #include "DataFormatsTPC/ClusterNative.h"
 #include "DataFormatsTPC/WorkflowHelper.h"
 #include "ITSBase/GeometryTGeo.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 */
 
 using namespace o2::framework;
diff --git a/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx b/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
index 8df479ba39260..cdd0620affec9 100644
--- a/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
+++ b/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
@@ -27,6 +27,7 @@
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "GlobalTrackingWorkflowReaders/TrackTPCITSReaderSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 #include "Algorithm/RangeTokenizer.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
@@ -59,6 +60,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"enable-cosmic", VariantType::Bool, false, {"enable cosmic tracks)"}},
     {"postprocessing", VariantType::Int, 0, {"postprocessing bits: 1 - extract alignment objects, 2 - check constraints, 4 - print mpParams/Constraints, 8 - relabel pede results"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
diff --git a/Detectors/CTF/test/test_ctf_io_itsmft.cxx b/Detectors/CTF/test/test_ctf_io_itsmft.cxx
index 13cbdf7745961..7f2ff8ce9f340 100644
--- a/Detectors/CTF/test/test_ctf_io_itsmft.cxx
+++ b/Detectors/CTF/test/test_ctf_io_itsmft.cxx
@@ -81,7 +81,7 @@ BOOST_DATA_TEST_CASE(CompressedClustersTest, boost_data::make(ANSVersions), ansV
   sw.Start();
   std::vector<o2::ctf::BufferType> vec;
   {
-    CTFCoder coder(o2::ctf::CTFCoderBase::OpType::Encoder, o2::detectors::DetID::ITS);
+    CTFCoder<o2::detectors::DetID::ITS> coder(o2::ctf::CTFCoderBase::OpType::Encoder, false);
     coder.setANSVersion(ansVersion);
     coder.encode(vec, rofRecVec, cclusVec, pattVec, pattIdConverter, 0); // compress
   }
@@ -120,7 +120,7 @@ BOOST_DATA_TEST_CASE(CompressedClustersTest, boost_data::make(ANSVersions), ansV
   sw.Start();
   const auto ctfImage = o2::itsmft::CTF::getImage(vec.data());
   {
-    CTFCoder coder(o2::ctf::CTFCoderBase::OpType::Decoder, o2::detectors::DetID::ITS);
+    CTFCoder<o2::detectors::DetID::ITS> coder(o2::ctf::CTFCoderBase::OpType::Decoder, false);
     coder.decode(ctfImage, rofRecVecD, cclusVecD, pattVecD, nullptr, clPattLookup); // decompress
   }
   sw.Stop();
diff --git a/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h b/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
index 081e6cf4d968a..51f2fca2c8303 100644
--- a/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
+++ b/Detectors/CTF/workflow/include/CTFWorkflow/CTFReaderSpec.h
@@ -27,6 +27,7 @@ struct CTFReaderInp {
   std::string inpdata{};
   o2::detectors::DetID::mask_t detMask = o2::detectors::DetID::FullMask;
   std::string copyCmd{};
+  std::string copyDir{};
   std::string tffileRegex{};
   std::string remoteRegex{};
   std::string metricChannel{};
@@ -50,6 +51,8 @@ struct CTFReaderInp {
   int tfRateLimit = -999;
   size_t minSHM = 0;
   bool shuffle{false};
+  bool doITSStaggering = false;
+  bool doMFTStaggering = false;
 };
 
 /// create a processor spec
diff --git a/Detectors/CTF/workflow/include/CTFWorkflow/CTFWriterSpec.h b/Detectors/CTF/workflow/include/CTFWorkflow/CTFWriterSpec.h
index 5eb6d65e26cec..12ad483d90881 100644
--- a/Detectors/CTF/workflow/include/CTFWorkflow/CTFWriterSpec.h
+++ b/Detectors/CTF/workflow/include/CTFWorkflow/CTFWriterSpec.h
@@ -15,16 +15,23 @@
 #define O2_CTFWRITER_SPEC
 
 #include "Framework/DataProcessorSpec.h"
-#include "Framework/Task.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 
 namespace o2
 {
 namespace ctf
 {
+struct CTFWriterInp {
+  o2::detectors::DetID::mask_t detMask = o2::detectors::DetID::FullMask;
+  int verbosity = 0;
+  int reportInterval = 200;
+  std::string outType = "";
+  bool doITSStaggering = false;
+  bool doMFTStaggering = false;
+};
 
 /// create a processor spec
-framework::DataProcessorSpec getCTFWriterSpec(o2::detectors::DetID::mask_t dets, const std::string& outType, int verbosity, int reportInterval);
+framework::DataProcessorSpec getCTFWriterSpec(const o2::ctf::CTFWriterInp& inp);
 
 } // namespace ctf
 } // namespace o2
diff --git a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
index 4100ebb37c61d..9fba8a220be55 100644
--- a/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
+++ b/Detectors/CTF/workflow/src/CTFReaderSpec.cxx
@@ -35,6 +35,7 @@
 #include "CommonUtils/NameConf.h"
 #include "DetectorsCommonDataFormats/CTFHeader.h"
 #include "Headers/STFHeader.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/CTF.h"
 #include "DataFormatsTPC/CTF.h"
 #include "DataFormatsTRD/CTF.h"
@@ -170,7 +171,7 @@ void CTFReaderSpec::init(InitContext& ic)
   mInput.maxTFsPerFile = ic.options().get<int>("max-tf-per-file");
   mInput.maxTFsPerFile = mInput.maxTFsPerFile > 0 ? mInput.maxTFsPerFile : 0x7fffffff;
   mRunning = true;
-  mFileFetcher = std::make_unique<o2::utils::FileFetcher>(mInput.inpdata, mInput.tffileRegex, mInput.remoteRegex, mInput.copyCmd);
+  mFileFetcher = std::make_unique<o2::utils::FileFetcher>(mInput.inpdata, mInput.tffileRegex, mInput.remoteRegex, mInput.copyCmd, mInput.copyDir);
   mFileFetcher->setMaxFilesInQueue(mInput.maxFileCache);
   mFileFetcher->setMaxLoops(mInput.maxLoops);
   mFileFetcher->setFailThreshold(ic.options().get<float>("fetch-failure-threshold"));
@@ -188,6 +189,48 @@ void CTFReaderSpec::init(InitContext& ic)
   }
 }
 
+///_______________________________________
+template <>
+void CTFReaderSpec::processDetector<o2::itsmft::CTF>(DetID det, const CTFHeader& ctfHeader, ProcessingContext& pc) const
+{
+  if (mInput.detMask[det]) {
+    std::string lbl = det.getName();
+    int nLayers = 1;
+    if (det == DetID::ITS) {
+      nLayers = mInput.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+    } else if (det == DetID::MFT) {
+      nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::MFT>::getNLayers() : 1;
+    } else {
+      LOGP(fatal, "This specialization is define only for ITS and MFT detectors, {} provided", det.getName());
+    }
+    for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+      auto& bufVec = pc.outputs().make<std::vector<o2::ctf::BufferType>>({lbl, mInput.subspec * 100 + iLayer}, ctfHeader.detectors[det] ? sizeof(o2::itsmft::CTF) : 0);
+      if (ctfHeader.detectors[det]) {
+        auto brName = nLayers == 1 ? lbl : fmt::format("{}_{}", lbl, iLayer);
+        o2::itsmft::CTF::readFromTree(bufVec, *(mCTFTree.get()), brName, mCurrTreeEntry);
+      } else if (!mInput.allowMissingDetectors) {
+        throw std::runtime_error(fmt::format("Requested detector {} is missing in the CTF", lbl));
+      }
+    }
+  }
+}
+
+///_______________________________________
+template <typename C>
+void CTFReaderSpec::processDetector(DetID det, const CTFHeader& ctfHeader, ProcessingContext& pc) const
+{
+  if (mInput.detMask[det]) {
+    const auto lbl = det.getName();
+    auto& bufVec = pc.outputs().make<std::vector<o2::ctf::BufferType>>({lbl, mInput.subspec}, ctfHeader.detectors[det] ? sizeof(C) : 0);
+    if (ctfHeader.detectors[det]) {
+      C::readFromTree(bufVec, *(mCTFTree.get()), lbl, mCurrTreeEntry);
+    } else if (!mInput.allowMissingDetectors) {
+      throw std::runtime_error(fmt::format("Requested detector {} is missing in the CTF", lbl));
+    }
+    //    setMessageHeader(pc, ctfHeader, lbl);
+  }
+}
+
 void CTFReaderSpec::runTimeRangesToIRFrameSelector(const o2::framework::TimingInfo& timingInfo)
 {
   // convert entries in the runTimeRanges to IRFrameSelector, if needed, convert time to orbit
@@ -562,22 +605,6 @@ void CTFReaderSpec::setMessageHeader(ProcessingContext& pc, const CTFHeader& ctf
   dph->creation = ctfHeader.creationTime;
 }
 
-///_______________________________________
-template <typename C>
-void CTFReaderSpec::processDetector(DetID det, const CTFHeader& ctfHeader, ProcessingContext& pc) const
-{
-  if (mInput.detMask[det]) {
-    const auto lbl = det.getName();
-    auto& bufVec = pc.outputs().make<std::vector<o2::ctf::BufferType>>({lbl, mInput.subspec}, ctfHeader.detectors[det] ? sizeof(C) : 0);
-    if (ctfHeader.detectors[det]) {
-      C::readFromTree(bufVec, *(mCTFTree.get()), lbl, mCurrTreeEntry);
-    } else if (!mInput.allowMissingDetectors) {
-      throw std::runtime_error(fmt::format("Requested detector {} is missing in the CTF", lbl));
-    }
-    //    setMessageHeader(pc, ctfHeader, lbl);
-  }
-}
-
 ///_______________________________________
 void CTFReaderSpec::tryToFixCTFHeader(CTFHeader& ctfHeader) const
 {
@@ -636,7 +663,19 @@ DataProcessorSpec getCTFReaderSpec(const CTFReaderInp& inp)
   for (auto id = DetID::First; id <= DetID::Last; id++) {
     if (inp.detMask[id]) {
       DetID det(id);
-      outputs.emplace_back(OutputLabel{det.getName()}, det.getDataOrigin(), "CTFDATA", inp.subspec, Lifetime::Timeframe);
+      if (det == DetID::ITS) {
+        uint32_t nLayers = inp.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+        for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
+          outputs.emplace_back(OutputLabel{det.getName()}, det.getDataOrigin(), "CTFDATA", inp.subspec * 100 + iLayer, Lifetime::Timeframe);
+        }
+      } else if (det == DetID::MFT) {
+        uint32_t nLayers = inp.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::MFT>::getNLayers() : 1;
+        for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
+          outputs.emplace_back(OutputLabel{det.getName()}, det.getDataOrigin(), "CTFDATA", inp.subspec * 100 + iLayer, Lifetime::Timeframe);
+        }
+      } else {
+        outputs.emplace_back(OutputLabel{det.getName()}, det.getDataOrigin(), "CTFDATA", inp.subspec, Lifetime::Timeframe);
+      }
     }
   }
   if (!inp.fileIRFrames.empty() || !inp.fileRunTimeSpans.empty()) {
diff --git a/Detectors/CTF/workflow/src/CTFWriterSpec.cxx b/Detectors/CTF/workflow/src/CTFWriterSpec.cxx
index ba4542969a712..5d6db7d613674 100644
--- a/Detectors/CTF/workflow/src/CTFWriterSpec.cxx
+++ b/Detectors/CTF/workflow/src/CTFWriterSpec.cxx
@@ -12,11 +12,10 @@
 /// @file   CTFWriterSpec.cxx
 
 #include "Framework/Logger.h"
-#include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/InputSpec.h"
+#include "Framework/Task.h"
 #include "Framework/RawDeviceService.h"
-#include "Framework/CommonServices.h"
 #include "Framework/DataTakingContext.h"
 #include "Framework/TimingInfo.h"
 #include <fairmq/Device.h>
@@ -29,6 +28,7 @@
 #include "DetectorsCommonDataFormats/EncodedBlocks.h"
 #include "DetectorsCommonDataFormats/FileMetaData.h"
 #include "CommonUtils/StringUtils.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/CTF.h"
 #include "DataFormatsTPC/CTF.h"
 #include "DataFormatsTRD/CTF.h"
@@ -94,17 +94,19 @@ size_t appendToTree(TTree& tree, const std::string brname, T& ptr)
 using DetID = o2::detectors::DetID;
 using FTrans = o2::rans::DenseHistogram<int32_t>;
 
-class CTFWriterSpec : public o2::framework::Task
+class CTFWriterSpec final : public o2::framework::Task
 {
  public:
   CTFWriterSpec() = delete;
-  CTFWriterSpec(DetID::mask_t dm, const std::string& outType, int verbosity, int reportInterval);
+  CTFWriterSpec(const o2::ctf::CTFWriterInp&);
   ~CTFWriterSpec() final { finalize(); }
   void init(o2::framework::InitContext& ic) final;
   void run(o2::framework::ProcessingContext& pc) final;
   void endOfStream(o2::framework::EndOfStreamContext& ec) final { finalize(); }
   void stop() final { finalize(); }
-  bool isPresent(DetID id) const { return mDets[id]; }
+  bool isPresent(DetID id) const { return mInput.detMask[id]; }
+
+  static std::string getBinding(const std::string& name, int spec) { return fmt::format("{}_{}", name, spec); }
 
  private:
   void updateTimeDependentParams(ProcessingContext& pc);
@@ -121,7 +123,7 @@ class CTFWriterSpec : public o2::framework::Task
   void removeLockFile();
   void finalize();
 
-  DetID::mask_t mDets; // detectors
+  CTFWriterInp mInput;
   bool mFinalized = false;
   bool mWriteCTF = true;
   bool mCreateDict = false;
@@ -130,8 +132,6 @@ class CTFWriterSpec : public o2::framework::Task
   bool mRejectCurrentTF = false;
   bool mFallBackDirUsed = false;
   bool mFallBackDirProvided = false;
-  int mReportInterval = -1;
-  int mVerbosity = 0;
   int mSaveDictAfter = 0;          // if positive and mWriteCTF==true, save dictionary after each mSaveDictAfter TFs processed
   uint32_t mPrevDictTimeStamp = 0; // timestamp of the previously stored dictionary
   uint32_t mDictTimeStamp = 0;     // timestamp of the currently stored dictionary
@@ -155,7 +155,6 @@ class CTFWriterSpec : public o2::framework::Task
   std::vector<uint32_t> mTFOrbits{}; // 1st orbits of TF accumulated in current file
   o2::framework::DataTakingContext mDataTakingContext{};
   o2::framework::TimingInfo mTimingInfo{};
-  std::string mOutputType{}; // RS FIXME once global/local options clash is solved, --output-type will become device option
   std::string mDictDir{};
   std::string mCTFDir{};
   std::string mHostName{};
@@ -190,8 +189,8 @@ class CTFWriterSpec : public o2::framework::Task
 const std::string CTFWriterSpec::TMPFileEnding{".part"};
 
 //___________________________________________________________________
-CTFWriterSpec::CTFWriterSpec(DetID::mask_t dm, const std::string& outType, int verbosity, int reportInterval)
-  : mDets(dm), mOutputType(outType), mReportInterval(reportInterval), mVerbosity(verbosity)
+CTFWriterSpec::CTFWriterSpec(const o2::ctf::CTFWriterInp& inp)
+  : mInput(inp)
 {
   std::for_each(mIsSaturatedFrequencyTable.begin(), mIsSaturatedFrequencyTable.end(), [](auto& bitset) { bitset.reset(); });
   mTimer.Stop();
@@ -202,7 +201,7 @@ CTFWriterSpec::CTFWriterSpec(DetID::mask_t dm, const std::string& outType, int v
 void CTFWriterSpec::init(InitContext& ic)
 {
   // auto outmode = ic.options().get<std::string>("output-type"); // RS FIXME once global/local options clash is solved, --output-type will become device option
-  auto outmode = mOutputType;
+  auto outmode = mInput.outType;
   if (outmode == "ctf") {
     mWriteCTF = true;
     mCreateDict = false;
@@ -301,71 +300,82 @@ size_t CTFWriterSpec::processDet(o2::framework::ProcessingContext& pc, DetID det
 {
   static bool warnedEmpty = false;
   size_t sz = 0;
-  if (!isPresent(det) || !pc.inputs().isValid(det.getName())) {
+
+  if (!isPresent(det) || !pc.inputs().isValid(getBinding(det.getName(), 0))) {
     mSizeReport += fmt::format(" {}:N/A", det.getName());
     return sz;
   }
-  auto ctfBuffer = pc.inputs().get<gsl::span<o2::ctf::BufferType>>(det.getName());
-  const o2::ctf::BufferType* bdata = ctfBuffer.data();
-  if (bdata) {
-    if (warnedEmpty) {
-      throw std::runtime_error(fmt::format("Non-empty input was seen at {}-th TF after empty one for {}, this will lead to misalignment of detectors in CTF", mNCTF, det.getName()));
-    }
-    const auto ctfImage = C::getImage(bdata);
-    ctfImage.print(o2::utils::Str::concat_string(det.getName(), ": "), mVerbosity);
-    if (mWriteCTF && !mRejectCurrentTF) {
-      sz = ctfImage.appendToTree(*tree, det.getName());
-      header.detectors.set(det);
-    } else {
-      sz = ctfBuffer.size();
-    }
-    if (mCreateDict) {
-      if (mFreqsAccumulation[det].empty()) {
-        mFreqsAccumulation[det].resize(C::getNBlocks());
-        mFreqsMetaData[det].resize(C::getNBlocks());
+
+  uint32_t nLayers = 1;
+  if (det == DetID::ITS) {
+    nLayers = mInput.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+  } else if (det == DetID::MFT) {
+    nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+  }
+  for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
+    auto binding = getBinding(det.getName(), iLayer);
+    auto ctfBuffer = pc.inputs().get<gsl::span<o2::ctf::BufferType>>(binding);
+    const o2::ctf::BufferType* bdata = ctfBuffer.data();
+    if (bdata) {
+      if (warnedEmpty) {
+        throw std::runtime_error(fmt::format("Non-empty input was seen at {}-th TF after empty one for {}, this will lead to misalignment of detectors in CTF", mNCTF, det.getName()));
       }
-      if (!mHeaders[det]) { // store 1st header
-        mHeaders[det] = ctfImage.cloneHeader();
-        auto& hb = *static_cast<o2::ctf::CTFDictHeader*>(mHeaders[det].get());
-        hb.det = det;
+      const auto ctfImage = C::getImage(bdata);
+      ctfImage.print(o2::utils::Str::concat_string(binding, ": "), mInput.verbosity);
+      if (mWriteCTF && !mRejectCurrentTF) {
+        sz += ctfImage.appendToTree(*tree, nLayers > 1 ? binding : det.getName());
+        header.detectors.set(det);
+      } else {
+        sz += ctfBuffer.size();
       }
-      for (int ib = 0; ib < C::getNBlocks(); ib++) {
-        if (!mIsSaturatedFrequencyTable[det][ib]) {
-          const auto& bl = ctfImage.getBlock(ib);
-          if (bl.getNDict()) {
-            auto freq = mFreqsAccumulation[det][ib];
-            auto& mdSave = mFreqsMetaData[det][ib];
-            const auto& md = ctfImage.getMetadata(ib);
-            if ([&, this]() {
-                  try {
-                    freq.addFrequencies(bl.getDict(), bl.getDict() + bl.getNDict(), md.min);
-                  } catch (const std::overflow_error& e) {
-                    LOGP(warning, "unable to add frequency table for {}, block {} due to overflow", det.getName(), ib);
-                    mIsSaturatedFrequencyTable[det][ib] = true;
-                    return false;
-                  }
-                  return true;
-                }()) {
-              auto newProbBits = static_cast<uint8_t>(o2::rans::compat::computeRenormingPrecision(countNUsedAlphabetSymbols(freq)));
-              auto histogramView = o2::rans::trim(o2::rans::makeHistogramView(freq));
-              mdSave = ctf::detail::makeMetadataRansDict(newProbBits,
-                                                         static_cast<int32_t>(histogramView.getMin()),
-                                                         static_cast<int32_t>(histogramView.getMax()),
-                                                         static_cast<int32_t>(histogramView.size()),
-                                                         md.opt);
-              mFreqsAccumulation[det][ib] = std::move(freq);
+      if (mCreateDict) { // RSTODO
+        if (mFreqsAccumulation[det].empty()) {
+          mFreqsAccumulation[det].resize(C::getNBlocks());
+          mFreqsMetaData[det].resize(C::getNBlocks());
+        }
+        if (!mHeaders[det]) { // store 1st header
+          mHeaders[det] = ctfImage.cloneHeader();
+          auto& hb = *static_cast<o2::ctf::CTFDictHeader*>(mHeaders[det].get());
+          hb.det = det;
+        }
+        for (int ib = 0; ib < C::getNBlocks(); ib++) {
+          if (!mIsSaturatedFrequencyTable[det][ib]) {
+            const auto& bl = ctfImage.getBlock(ib);
+            if (bl.getNDict()) {
+              auto freq = mFreqsAccumulation[det][ib];
+              auto& mdSave = mFreqsMetaData[det][ib];
+              const auto& md = ctfImage.getMetadata(ib);
+              if ([&, this]() {
+                    try {
+                      freq.addFrequencies(bl.getDict(), bl.getDict() + bl.getNDict(), md.min);
+                    } catch (const std::overflow_error& e) {
+                      LOGP(warning, "unable to add frequency table for {}, block {} due to overflow", det.getName(), ib);
+                      mIsSaturatedFrequencyTable[det][ib] = true;
+                      return false;
+                    }
+                    return true;
+                  }()) {
+                auto newProbBits = static_cast<uint8_t>(o2::rans::compat::computeRenormingPrecision(countNUsedAlphabetSymbols(freq)));
+                auto histogramView = o2::rans::trim(o2::rans::makeHistogramView(freq));
+                mdSave = ctf::detail::makeMetadataRansDict(newProbBits,
+                                                           static_cast<int32_t>(histogramView.getMin()),
+                                                           static_cast<int32_t>(histogramView.getMax()),
+                                                           static_cast<int32_t>(histogramView.size()),
+                                                           md.opt);
+                mFreqsAccumulation[det][ib] = std::move(freq);
+              }
             }
           }
         }
       }
-    }
-  } else {
-    if (!warnedEmpty) {
-      if (mNCTF) {
-        throw std::runtime_error(fmt::format("Empty input was seen at {}-th TF after non-empty one for {}, this will lead to misalignment of detectors in CTF", mNCTF, det.getName()));
+    } else {
+      if (!warnedEmpty) {
+        if (mNCTF) {
+          throw std::runtime_error(fmt::format("Empty input was seen at {}-th TF after non-empty one for {}, this will lead to misalignment of detectors in CTF", mNCTF, det.getName()));
+        }
+        LOGP(important, "Empty CTF provided for {}, skipping and will not report anymore", det.getName());
+        warnedEmpty = true;
       }
-      LOGP(important, "Empty CTF provided for {}, skipping and will not report anymore", det.getName());
-      warnedEmpty = true;
     }
   }
   mSizeReport += fmt::format(" {}:{}", det.getName(), fmt::group_digits(sz));
@@ -417,10 +427,19 @@ size_t CTFWriterSpec::estimateCTFSize(ProcessingContext& pc)
   size_t s = 0;
   for (auto id = DetID::First; id <= DetID::Last; id++) {
     DetID det(id);
-    if (!isPresent(det) || !pc.inputs().isValid(det.getName())) {
-      continue;
+    uint32_t nLayers = 1;
+    if (det == DetID::ITS) {
+      nLayers = mInput.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+    } else if (det == DetID::MFT) {
+      nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+    }
+    for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
+      auto binding = getBinding(det.getName(), iLayer);
+      if (!isPresent(det) || !pc.inputs().isValid(binding)) {
+        continue;
+      }
+      s += pc.inputs().get<gsl::span<o2::ctf::BufferType>>(binding).size();
     }
-    s += pc.inputs().get<gsl::span<o2::ctf::BufferType>>(det.getName()).size();
   }
   return s;
 }
@@ -496,7 +515,7 @@ void CTFWriterSpec::run(ProcessingContext& pc)
   szCTFperDet[DetID::FDD] = processDet<o2::fdd::CTF>(pc, DetID::FDD, header, mCTFTreeOut.get());
   szCTFperDet[DetID::CTP] = processDet<o2::ctp::CTF>(pc, DetID::CTP, header, mCTFTreeOut.get());
   szCTF = std::accumulate(szCTFperDet.begin(), szCTFperDet.end(), 0);
-  if (mReportInterval > 0 && (mTimingInfo.tfCounter % mReportInterval) == 0) {
+  if (mInput.reportInterval > 0 && (mTimingInfo.tfCounter % mInput.reportInterval) == 0) {
     LOGP(important, "CTF {} size report:{} - Total:{}", mTimingInfo.tfCounter, mSizeReport, fmt::group_digits(szCTF));
   }
 
@@ -660,7 +679,7 @@ void CTFWriterSpec::storeDictionaries()
   // monolitic dictionary in tree format
   mDictTimeStamp = uint32_t(std::time(nullptr));
   auto getFileName = [this](bool curr) {
-    return fmt::format("{}{}Tree_{}_{}_{}.root", this->mDictDir, o2::base::NameConf::CTFDICT, DetID::getNames(this->mDets, '-'), curr ? this->mDictTimeStamp : this->mPrevDictTimeStamp, curr ? this->mNCTF : this->mNCTFPrevDict);
+    return fmt::format("{}{}Tree_{}_{}_{}.root", this->mDictDir, o2::base::NameConf::CTFDICT, DetID::getNames(this->mInput.detMask, '-'), curr ? this->mDictTimeStamp : this->mPrevDictTimeStamp, curr ? this->mNCTF : this->mNCTFPrevDict);
   };
   auto dictFileName = getFileName(true);
   mDictFileOut.reset(TFile::Open(dictFileName.c_str(), "recreate"));
@@ -788,13 +807,22 @@ size_t CTFWriterSpec::getAvailableDiskSpace(const std::string& path, int level)
 }
 
 //___________________________________________________________________
-DataProcessorSpec getCTFWriterSpec(DetID::mask_t dets, const std::string& outType, int verbosity, int reportInterval)
+DataProcessorSpec getCTFWriterSpec(const o2::ctf::CTFWriterInp& inp)
 {
   std::vector<InputSpec> inputs;
   LOG(debug) << "Detectors list:";
   for (auto id = DetID::First; id <= DetID::Last; id++) {
-    if (dets[id]) {
-      inputs.emplace_back(DetID::getName(id), DetID::getDataOrigin(id), "CTFDATA", 0, Lifetime::Timeframe);
+    if (inp.detMask[id]) {
+      uint32_t nLayers = 1;
+      DetID det{id};
+      if (det == DetID::ITS) {
+        nLayers = inp.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+      } else if (det == DetID::MFT) {
+        nLayers = inp.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+      }
+      for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
+        inputs.emplace_back(CTFWriterSpec::getBinding(det.getName(), iLayer), det.getDataOrigin(), "CTFDATA", iLayer, Lifetime::Timeframe);
+      }
       LOG(debug) << "Det " << DetID::getName(id) << " added";
     }
   }
@@ -803,24 +831,25 @@ DataProcessorSpec getCTFWriterSpec(DetID::mask_t dets, const std::string& outTyp
     inputs,
     Outputs{{OutputLabel{"ctfdone"}, "CTF", "DONE", 0, Lifetime::Timeframe},
             {"CTF", "SIZES", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<CTFWriterSpec>(dets, outType, verbosity, reportInterval)}, // RS FIXME once global/local options clash is solved, --output-type will become device option
-    Options{                                                                               //{"output-type", VariantType::String, "ctf", {"output types: ctf (per TF) or dict (create dictionaries) or both or none"}},
-            {"save-ctf-after", VariantType::Int64, 0ll, {"autosave CTF tree with multiple CTFs after every N CTFs if >0 or every -N MBytes if < 0"}},
-            {"save-dict-after", VariantType::Int, 0, {"if > 0, in dictionary generation mode save it dictionary after certain number of TFs processed"}},
-            {"ctf-dict-dir", VariantType::String, "none", {"CTF dictionary directory, must exist"}},
-            {"output-dir", VariantType::String, "none", {"CTF output directory, must exist"}},
-            {"output-dir-alt", VariantType::String, "/dev/null", {"Alternative CTF output directory, must exist (if not /dev/null)"}},
-            {"meta-output-dir", VariantType::String, "/dev/null", {"CTF metadata output directory, must exist (if not /dev/null)"}},
-            {"md5-for-meta", VariantType::Bool, false, {"fill CTF file MD5 sum in the metadata file"}},
-            {"min-file-size", VariantType::Int64, 0l, {"accumulate CTFs until given file size reached"}},
-            {"max-file-size", VariantType::Int64, 0l, {"if > 0, try to avoid exceeding given file size, also used for space check"}},
-            {"max-ctf-per-file", VariantType::Int, 0, {"if > 0, avoid storing more than requested CTFs per file"}},
-            {"ctf-rejection", VariantType::Int, 0, {">0: percentage to reject randomly, <0: reject if timeslice%|value|!=0"}},
-            {"ctf-file-compression", VariantType::Int, 0, {"if >= 0: impose CTF file compression level"}},
-            {"require-free-disk", VariantType::Float, 0.f, {"pause writing op. if available disk space is below this margin, in bytes if >0, as a fraction of total if <0"}},
-            {"wait-for-free-disk", VariantType::Float, 10.f, {"if paused due to the low disk space, recheck after this time (in s)"}},
-            {"max-wait-for-free-disk", VariantType::Float, 60.f, {"produce fatal if paused due to the low disk space for more than this amount in s."}},
-            {"ignore-partition-run-dir", VariantType::Bool, false, {"Do not creare partition-run directory in output-dir"}}}};
+    AlgorithmSpec{adaptFromTask<CTFWriterSpec>(inp)},
+    Options{
+      //{"output-type", VariantType::String, "ctf", {"output types: ctf (per TF) or dict (create dictionaries) or both or none"}},
+      {"save-ctf-after", VariantType::Int64, 0ll, {"autosave CTF tree with multiple CTFs after every N CTFs if >0 or every -N MBytes if < 0"}},
+      {"save-dict-after", VariantType::Int, 0, {"if > 0, in dictionary generation mode save it dictionary after certain number of TFs processed"}},
+      {"ctf-dict-dir", VariantType::String, "none", {"CTF dictionary directory, must exist"}},
+      {"output-dir", VariantType::String, "none", {"CTF output directory, must exist"}},
+      {"output-dir-alt", VariantType::String, "/dev/null", {"Alternative CTF output directory, must exist (if not /dev/null)"}},
+      {"meta-output-dir", VariantType::String, "/dev/null", {"CTF metadata output directory, must exist (if not /dev/null)"}},
+      {"md5-for-meta", VariantType::Bool, false, {"fill CTF file MD5 sum in the metadata file"}},
+      {"min-file-size", VariantType::Int64, 0l, {"accumulate CTFs until given file size reached"}},
+      {"max-file-size", VariantType::Int64, 0l, {"if > 0, try to avoid exceeding given file size, also used for space check"}},
+      {"max-ctf-per-file", VariantType::Int, 0, {"if > 0, avoid storing more than requested CTFs per file"}},
+      {"ctf-rejection", VariantType::Int, 0, {">0: percentage to reject randomly, <0: reject if timeslice%|value|!=0"}},
+      {"ctf-file-compression", VariantType::Int, 0, {"if >= 0: impose CTF file compression level"}},
+      {"require-free-disk", VariantType::Float, 0.f, {"pause writing op. if available disk space is below this margin, in bytes if >0, as a fraction of total if <0"}},
+      {"wait-for-free-disk", VariantType::Float, 10.f, {"if paused due to the low disk space, recheck after this time (in s)"}},
+      {"max-wait-for-free-disk", VariantType::Float, 60.f, {"produce fatal if paused due to the low disk space for more than this amount in s."}},
+      {"ignore-partition-run-dir", VariantType::Bool, false, {"Do not creare partition-run directory in output-dir"}}}};
 }
 
 } // namespace ctf
diff --git a/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx b/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
index fc50c971c5d20..366fa76f74983 100644
--- a/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
+++ b/Detectors/CTF/workflow/src/ctf-reader-workflow.cxx
@@ -25,6 +25,7 @@
 
 // Specific detectors specs
 #include "ITSMFTWorkflow/EntropyDecoderSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "TPCWorkflow/EntropyDecoderSpec.h"
 #include "TRDWorkflow/EntropyDecoderSpec.h"
 #include "HMPIDWorkflow/EntropyDecoderSpec.h"
@@ -59,6 +60,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   options.push_back(ConfigParamSpec{"delay", VariantType::Float, 0.f, {"delay in seconds between consecutive TFs sending"}});
   options.push_back(ConfigParamSpec{"shuffle", VariantType::Bool, false, {"shuffle TF sending order (for debug)"}});
   options.push_back(ConfigParamSpec{"copy-cmd", VariantType::String, "alien_cp ?src file://?dst", {"copy command for remote files or no-copy to avoid copying"}}); // Use "XrdSecPROTOCOL=sss,unix xrdcp -N root://eosaliceo2.cern.ch/?src ?dst" for direct EOS access
+  options.push_back(ConfigParamSpec{"copy-dir", VariantType::String, "/tmp/", {"copy base directory for remote files"}});
   options.push_back(ConfigParamSpec{"ctf-file-regex", VariantType::String, ".*o2_ctf_run.+\\.root$", {"regex string to identify CTF files"}});
   options.push_back(ConfigParamSpec{"remote-regex", VariantType::String, "^(alien://|)/alice/data/.+", {"regex string to identify remote files"}}); // Use "^/eos/aliceo2/.+" for direct EOS access
   options.push_back(ConfigParamSpec{"max-cached-files", VariantType::Int, 3, {"max CTF files queued (copied for remote source)"}});
@@ -80,6 +82,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   options.push_back(ConfigParamSpec{"timeframes-shm-limit", VariantType::String, "0", {"Minimum amount of SHM required in order to publish data"}});
   options.push_back(ConfigParamSpec{"metric-feedback-channel-format", VariantType::String, "name=metric-feedback,type=pull,method=connect,address=ipc://{}metric-feedback-{},transport=shmem,rateLogging=0", {"format for the metric-feedback channel for TF rate limiting"}});
   options.push_back(ConfigParamSpec{"combine-devices", VariantType::Bool, false, {"combine multiple DPL devices (entropy decoders)"}});
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -124,6 +127,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   ctfInput.shuffle = configcontext.options().get<bool>("shuffle");
   ctfInput.copyCmd = configcontext.options().get<std::string>("copy-cmd");
+  ctfInput.copyDir = configcontext.options().get<std::string>("copy-dir");
   ctfInput.tffileRegex = configcontext.options().get<std::string>("ctf-file-regex");
   ctfInput.remoteRegex = configcontext.options().get<std::string>("remote-regex");
   ctfInput.allowMissingDetectors = configcontext.options().get<bool>("allow-missing-detectors");
@@ -147,6 +151,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   if (!ctfInput.fileIRFrames.empty() && !ctfInput.fileRunTimeSpans.empty()) {
     LOGP(fatal, "One cannot provide --ir-frames-files and --run-time-span-file options simultaneously");
   }
+  ctfInput.doITSStaggering = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext);
+  ctfInput.doMFTStaggering = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
 
   specs.push_back(o2::ctf::getCTFReaderSpec(ctfInput));
 
@@ -183,10 +189,12 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   // add decoders for all allowed detectors.
   if (ctfInput.detMask[DetID::ITS]) {
-    addSpecs(o2::itsmft::getEntropyDecoderSpec(DetID::getDataOrigin(DetID::ITS), verbosity, configcontext.options().get<bool>("its-digits"), ctfInput.subspec, ctfInput.dictOpt));
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext);
+    addSpecs(o2::itsmft::getITSEntropyDecoderSpec(verbosity, doStag, configcontext.options().get<bool>("its-digits"), ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::MFT]) {
-    addSpecs(o2::itsmft::getEntropyDecoderSpec(DetID::getDataOrigin(DetID::MFT), verbosity, configcontext.options().get<bool>("mft-digits"), ctfInput.subspec, ctfInput.dictOpt));
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
+    addSpecs(o2::itsmft::getMFTEntropyDecoderSpec(verbosity, doStag, configcontext.options().get<bool>("mft-digits"), ctfInput.subspec, ctfInput.dictOpt));
   }
   if (ctfInput.detMask[DetID::TPC]) {
     addSpecs(o2::tpc::getEntropyDecoderSpec(verbosity, ctfInput.subspec, ctfInput.dictOpt));
diff --git a/Detectors/CTF/workflow/src/ctf-writer-workflow.cxx b/Detectors/CTF/workflow/src/ctf-writer-workflow.cxx
index 2757192727521..77dbbd80bc1a7 100644
--- a/Detectors/CTF/workflow/src/ctf-writer-workflow.cxx
+++ b/Detectors/CTF/workflow/src/ctf-writer-workflow.cxx
@@ -20,6 +20,7 @@
 #include "CTFWorkflow/CTFWriterSpec.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "CommonUtils/ConfigurableParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using DetID = o2::detectors::DetID;
@@ -35,6 +36,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
   options.push_back(ConfigParamSpec{"ctf-writer-verbosity", VariantType::Int, 0, {"verbosity level (0: summary per detector, 1: summary per block"}});
   options.push_back(ConfigParamSpec{"report-data-size-interval", VariantType::Int, 200, {"report sizes per detector for every N-th timeframe"}});
   options.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}});
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -51,7 +53,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   DetID::mask_t dets = 0;
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
-  std::string outType{}; // RS FIXME once global/local options clash is solved, --output-type will become device option
+  o2::ctf::CTFWriterInp inp;
   if (!configcontext.helpOnCommandLine()) {
     dets.set(); // by default read all
     auto mskOnly = DetID::getMask(configcontext.options().get<std::string>("onlyDet"));
@@ -64,10 +66,14 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     if (dets.none()) {
       throw std::invalid_argument("Invalid workflow: no detectors found");
     }
-    outType = configcontext.options().get<std::string>("output-type");
+    inp.detMask = dets;
+    inp.outType = configcontext.options().get<std::string>("output-type");
   }
-  WorkflowSpec specs{o2::ctf::getCTFWriterSpec(dets, outType,
-                                               configcontext.options().get<int>("ctf-writer-verbosity"),
-                                               configcontext.options().get<int>("report-data-size-interval"))};
+  inp.verbosity = configcontext.options().get<int>("ctf-writer-verbosity");
+  inp.reportInterval = configcontext.options().get<int>("report-data-size-interval");
+  inp.doITSStaggering = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext);
+  inp.doMFTStaggering = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
+
+  WorkflowSpec specs{o2::ctf::getCTFWriterSpec(inp)};
   return std::move(specs);
 }
diff --git a/Detectors/Filtering/src/FilteringSpec.cxx b/Detectors/Filtering/src/FilteringSpec.cxx
index bcf3c6c3539d4..ea82b1456d955 100644
--- a/Detectors/Filtering/src/FilteringSpec.cxx
+++ b/Detectors/Filtering/src/FilteringSpec.cxx
@@ -46,7 +46,7 @@
 #include "ReconstructionDataFormats/Cascade.h"
 #include "MCHTracking/TrackExtrap.h"
 #include "MCHTracking/TrackParam.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsVertexing/PVertexerParams.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "ReconstructionDataFormats/Track.h"
diff --git a/Detectors/Filtering/src/filtering-workflow.cxx b/Detectors/Filtering/src/filtering-workflow.cxx
index 8e36cfc36b197..faf5463281ed8 100644
--- a/Detectors/Filtering/src/filtering-workflow.cxx
+++ b/Detectors/Filtering/src/filtering-workflow.cxx
@@ -17,6 +17,7 @@
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -36,6 +37,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"disable-secondary-vertices", o2::framework::VariantType::Bool, false, {"disable filling secondary vertices"}},
     {"data-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of sources to use"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
diff --git a/Detectors/GlobalTrackingWorkflow/helpers/src/InputHelper.cxx b/Detectors/GlobalTrackingWorkflow/helpers/src/InputHelper.cxx
index c6c163f4b8911..e4c1e40b3a4d3 100644
--- a/Detectors/GlobalTrackingWorkflow/helpers/src/InputHelper.cxx
+++ b/Detectors/GlobalTrackingWorkflow/helpers/src/InputHelper.cxx
@@ -14,6 +14,7 @@
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "ITSMFTWorkflow/ClusterReaderSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "ITSWorkflow/TrackReaderSpec.h"
 #include "MFTWorkflow/TrackReaderSpec.h"
 #include "TPCReaderWorkflow/TrackReaderSpec.h"
@@ -79,13 +80,15 @@ int InputHelper::addInputSpecs(const ConfigContext& configcontext, WorkflowSpec&
     specs.emplace_back(o2::its::getITSTrackReaderSpec(maskTracksMC[GID::ITS]));
   }
   if (maskClusters[GID::ITS]) {
-    specs.emplace_back(o2::itsmft::getITSClusterReaderSpec(maskClustersMC[GID::ITS], true));
+    bool doStag = itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext);
+    specs.emplace_back(o2::itsmft::getITSClusterReaderSpec(maskClustersMC[GID::ITS], doStag, true));
   }
   if (maskTracks[GID::MFT]) {
     specs.emplace_back(o2::mft::getMFTTrackReaderSpec(maskTracksMC[GID::MFT]));
   }
   if (maskClusters[GID::MFT]) {
-    specs.emplace_back(o2::itsmft::getMFTClusterReaderSpec(maskClustersMC[GID::MFT], true));
+    bool doStag = itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
+    specs.emplace_back(o2::itsmft::getMFTClusterReaderSpec(maskClustersMC[GID::MFT], doStag, true));
   }
   if (maskTracks[GID::MCH] || maskMatches[GID::MCHMID]) {
     specs.emplace_back(o2::mch::getTrackReaderSpec(maskTracksMC[GID::MCH] || maskTracksMC[GID::MCHMID]));
diff --git a/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
index 34c41ec234dc5..5bcdded0e1223 100644
--- a/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
@@ -40,7 +40,7 @@
 #include "Headers/DataHeader.h"
 #include "CommonDataFormat/InteractionRecord.h"
 #include "ITSBase/GeometryTGeo.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
 #include "Framework/Task.h"
 #include "Framework/CCDBParamSpec.h"
diff --git a/Detectors/GlobalTrackingWorkflow/src/GlobalFwdMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/GlobalFwdMatchingSpec.cxx
index 03dc823c62c42..a43a1e8943739 100644
--- a/Detectors/GlobalTrackingWorkflow/src/GlobalFwdMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/GlobalFwdMatchingSpec.cxx
@@ -20,7 +20,7 @@
 #include "Framework/CCDBParamSpec.h"
 #include "CommonUtils/StringUtils.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "DataFormatsMFT/TrackMFT.h"
 #include "DataFormatsITSMFT/Cluster.h"
diff --git a/Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx
index dc1107bacb18a..c1d7b62bbf731 100644
--- a/Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/PrimaryVertexingSpec.cxx
@@ -30,7 +30,7 @@
 #include "Framework/CCDBParamSpec.h"
 #include "Framework/DeviceSpec.h"
 #include "FT0Reconstruction/InteractionTag.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsVertexing/PVertexer.h"
 #include "DetectorsBase/GRPGeomHelper.h"
diff --git a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
index c333c37ff245b..cb3384b0631c2 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
@@ -39,7 +39,7 @@
 #include "DetectorsBase/GeometryManager.h"
 #include "DetectorsBase/Propagator.h"
 #include "DetectorsBase/GlobalParams.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "GlobalTracking/MatchTPCITSParams.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
diff --git a/Detectors/GlobalTrackingWorkflow/src/VertexTrackMatcherSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/VertexTrackMatcherSpec.cxx
index f24e7c13e336f..90e4dd4b0f001 100644
--- a/Detectors/GlobalTrackingWorkflow/src/VertexTrackMatcherSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/VertexTrackMatcherSpec.cxx
@@ -23,7 +23,7 @@
 #include "TPCBase/ParameterElectronics.h"
 #include "TPCBase/ParameterDetector.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "TStopwatch.h"
 
 using namespace o2::framework;
diff --git a/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
index e4082bdd14d86..3f7ecfbbea809 100644
--- a/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
@@ -32,6 +32,7 @@
 #include "Framework/CallbacksPolicy.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using DetID = o2::detectors::DetID;
@@ -52,6 +53,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-root-output", o2::framework::VariantType::Bool, false, {"disable root-files output writer"}},
     {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of sources to use"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
diff --git a/Detectors/GlobalTrackingWorkflow/src/globalfwd-matcher-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/globalfwd-matcher-workflow.cxx
index 13a842130e5d1..fd90aff5f32ff 100644
--- a/Detectors/GlobalTrackingWorkflow/src/globalfwd-matcher-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/globalfwd-matcher-workflow.cxx
@@ -21,6 +21,7 @@
 #include "GlobalTrackingWorkflow/MatchedMFTMCHWriterSpec.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "GlobalTracking/MatchGlobalFwdParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -46,6 +47,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-root-output", o2::framework::VariantType::Bool, false, {"do not write output root files"}},
     {"enable-match-output", o2::framework::VariantType::Bool, false, {"stores mftmch matching info on mftmchmatches.root"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addMFTConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
diff --git a/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
index 0ac640cbad9fd..9108e8577fd5a 100644
--- a/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
@@ -30,6 +30,7 @@
 #include "Framework/CompletionPolicyHelpers.h"
 #include "DetectorsBase/DPLWorkflowUtils.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -62,6 +63,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight ITS part"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}},
     {"combine-source-devices", o2::framework::VariantType::Bool, false, {"merge DPL source devices"}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
diff --git a/Detectors/GlobalTrackingWorkflow/src/strangeness-tracking-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/strangeness-tracking-workflow.cxx
index bdc1af958886c..8c42871ac05bf 100644
--- a/Detectors/GlobalTrackingWorkflow/src/strangeness-tracking-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/strangeness-tracking-workflow.cxx
@@ -21,6 +21,7 @@
 #include "GlobalTrackingWorkflowReaders/TrackTPCITSReaderSpec.h"
 #include "GlobalTrackingWorkflowReaders/PrimaryVertexReaderSpec.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
@@ -46,6 +47,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC"}},
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight ITS part"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
diff --git a/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
index 810c7c564b4a8..17ab2191f0e1e 100644
--- a/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
@@ -25,6 +25,7 @@
 #include "Framework/ConfigContext.h"
 #include "Framework/CompletionPolicyHelpers.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -46,6 +47,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"produce-calibration-data", o2::framework::VariantType::Bool, false, {"produce output for TPC vdrift calibration"}},
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight ITS part"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
@@ -76,6 +78,7 @@ WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& configcont
   GID::mask_t alowedSources = GID::getSourcesMask("ITS,TPC,TPC-TOF");
   GID::mask_t src = alowedSources & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
   bool needStrictTRDTOF = (src & GID::getSourcesMask("TPC-TRD,TPC-TOF,TPC-TRD-TOF")).any();
+  auto doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext); // RS at the moment is not passed to the matching w-flow
   auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
   auto useFT0 = configcontext.options().get<bool>("use-ft0");
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
index ed419700b339b..dc002489c24e2 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
@@ -29,7 +29,7 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
 #include "Framework/DeviceSpec.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITStracking/IOUtils.h"
 #include "DetectorsCommonDataFormats/DetID.h"
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx b/Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx
index d02f1df3903ec..8c7931d599e93 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/DumpTracks.cxx
@@ -21,7 +21,7 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
 #include "FT0Reconstruction/InteractionTag.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "GlobalTrackingStudy/TrackingStudy.h"
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
index 0129d19b02346..4d0b6bdbdb213 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/SVStudy.cxx
@@ -29,7 +29,7 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
 #include "FT0Reconstruction/InteractionTag.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "GlobalTrackingStudy/TrackingStudy.h"
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 8f6604b029605..1db303d20e5d9 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -34,7 +34,7 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
 #include "FT0Reconstruction/InteractionTag.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "GlobalTrackingStudy/TrackMCStudy.h"
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index c68e60059cd3f..a184058a1bfd6 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -28,7 +28,7 @@
 #include "Framework/CCDBParamSpec.h"
 #include "Framework/DeviceSpec.h"
 #include "FT0Reconstruction/InteractionTag.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "GlobalTrackingStudy/TrackingStudy.h"
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
index b8230b59405d8..fd4485585103c 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
@@ -22,6 +22,7 @@
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -44,6 +45,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   //  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/its-offset-study-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/its-offset-study-workflow.cxx
index 9638312e13f78..5d89ba9b7eabf 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/its-offset-study-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/its-offset-study-workflow.cxx
@@ -20,6 +20,7 @@
 #include "DetectorsBase/DPLWorkflowUtils.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -39,6 +40,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"track-sources", VariantType::String, std::string{"ITS,ITS-TPC-TRD-TOF,ITS-TPC-TOF,ITS-TPC,ITS-TPC-TRD"}, {"comma-separated list of track sources to use"}},
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options, "o2_tfidinfo.root");
   std::swap(workflowOptions, options);
 }
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
index 7aa53e2190a9e..9e0055a389bfe 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
@@ -22,6 +22,7 @@
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -44,6 +45,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"ignore-sv-check", VariantType::Bool, false, {"disable check for SV combinatorics"}},
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation, never use it"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
index 413d2e63653fc..ae2e3b5301a14 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
@@ -22,6 +22,7 @@
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -43,6 +44,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"cluster-sources", VariantType::String, "TPC,TOF", {"comma-separated list of cluster sources to use"}},
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
diff --git a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx
index 2f28fc5bb2d34..65a79a8635a49 100644
--- a/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/tpcinterpolationworkflow/src/tpc-interpolation-workflow.cxx
@@ -19,6 +19,7 @@
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "TPCInterpolationWorkflow/TPCInterpolationSpec.h"
 #include "TPCInterpolationWorkflow/TPCResidualWriterSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -44,6 +45,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"debug-output", VariantType::Bool, false, {"Dump extended tracking information for debugging"}},
     {"skip-ext-det-residuals", VariantType::Bool, false, {"Do not produce residuals for external detectors"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
diff --git a/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt b/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
index dd6aacf65db99..a23682b085311 100644
--- a/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
@@ -118,3 +118,13 @@ o2_add_test_root_macro(CheckDROF.C
                        PUBLIC_LINK_LIBRARIES O2::DataFormatsITS
                                              O2::DataFormatsITSMFT
                        LABELS its)
+
+o2_add_test_root_macro(CheckStaggering.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsITS
+                                             O2::DataFormatsITSMFT
+                                             O2::ITSMFTReconstruction
+                                             O2::DCAFitter
+                                             O2::CCDB
+                                             O2::DetectorsVertexing
+                                             O2::ReconstructionDataFormats
+                       LABELS its COMPILE_ONLY)
diff --git a/Detectors/ITSMFT/ITS/macros/test/CheckDROF.C b/Detectors/ITSMFT/ITS/macros/test/CheckDROF.C
index 21428ea4fcbc2..01acd2935981d 100644
--- a/Detectors/ITSMFT/ITS/macros/test/CheckDROF.C
+++ b/Detectors/ITSMFT/ITS/macros/test/CheckDROF.C
@@ -39,13 +39,13 @@
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsITS/Vertex.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "SimulationDataFormat/DigitizationContext.h"
 
 #endif
 
 using namespace std;
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 void plotHistos(TFile* fWO, TFile* f, const char* append = "");
 
@@ -93,9 +93,9 @@ struct ParticleInfo { // particle level information for tracks
 #pragma link C++ class ParticleInfo + ;
 #pragma link C++ class std::vector < ParticleInfo> + ;
 
-struct VertexInfo { // Vertex level info
-  float purity;     // fraction of main cont. labels to all
-  Vertex vertex;    // reconstructed vertex
+struct VertexInfo {       // Vertex level info
+  float purity;           // fraction of main cont. labels to all
+  o2::its::Vertex vertex; // reconstructed vertex
   int bcInROF{-1};
   int rofId{-1};
   int event{-1};                       // corresponding MC event
@@ -199,7 +199,7 @@ void CheckDROF(bool plot = false, bool write = false, const std::string& tracfil
     std::vector<o2::itsmft::ROFRecord> rofRecVec, *rofRecVecP = &rofRecVec;
     recTree->SetBranchAddress("ITSTracksROF", &rofRecVecP);
     // Vertices
-    std::vector<Vertex>* recVerArr = nullptr;
+    std::vector<o2::its::Vertex>* recVerArr = nullptr;
     recTree->SetBranchAddress("Vertices", &recVerArr);
     std::vector<ROFRecord>* recVerROFArr = nullptr;
     recTree->SetBranchAddress("VerticesROF", &recVerROFArr);
@@ -876,11 +876,12 @@ void CheckDROF(bool plot = false, bool write = false, const std::string& tracfil
             if (!trk.hasHitOnLayer(iL) || !trk.isFakeOnLayer(iL) || (part.clusters & (0x1 << iL)) == 0) {
               continue;
             }
-            if (trk.hasHitInNextROF()) {
-              hFakMig->Fill(trk.getPt(), trk.getNClusters(), iL);
-            } else {
-              hFakVal->Fill(trk.getPt(), trk.getNClusters(), iL);
-            }
+            // TODO: figure out how to find hit migration
+            // if (trk.hasHitInNextROF()) {
+            //   hFakMig->Fill(trk.getPt(), trk.getNClusters(), iL);
+            // } else {
+            //   hFakVal->Fill(trk.getPt(), trk.getNClusters(), iL);
+            // }
           }
         }
       }
diff --git a/Detectors/ITSMFT/ITS/macros/test/CheckStaggering.C b/Detectors/ITSMFT/ITS/macros/test/CheckStaggering.C
new file mode 100644
index 0000000000000..e3a79779a5fb1
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/macros/test/CheckStaggering.C
@@ -0,0 +1,521 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <cmath>
+#include <vector>
+#include <filesystem>
+#include <algorithm>
+#include <random>
+
+#include <TGeoManager.h>
+#include <TRandom.h>
+#include <TFile.h>
+#include <TTree.h>
+#include <TF1.h>
+#include <TH2F.h>
+#include <TCanvas.h>
+#include <THStack.h>
+#include <TLegend.h>
+#include <TPad.h>
+#include <TLatex.h>
+#include <TProfile.h>
+#include <TStyle.h>
+#include <TLine.h>
+#include <TLorentzVector.h>
+#include <TPaveText.h>
+
+#include "DetectorsBase/Propagator.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsITS/Vertex.h"
+#include "DataFormatsITS/TimeEstBC.h"
+#include "CCDB/CcdbApi.h"
+#include "CCDB/BasicCCDBManager.h"
+#include "CommonConstants/LHCConstants.h"
+#include "DataFormatsParameters/GRPMagField.h"
+#include "DataFormatsParameters/GRPLHCIFData.h"
+#include "ReconstructionDataFormats/Vertex.h"
+#include "DetectorsVertexing/SVertexHypothesis.h"
+#include "DCAFitter/DCAFitterN.h"
+#endif
+
+constexpr const char* tracFile = "o2trac_its.root";
+constexpr const char* clsFile = "o2clus_its.root";
+
+struct PairCandidate {
+  int posIdx;
+  int negIdx;
+  double dca;
+  double mass;
+};
+
+std::vector<std::filesystem::path> findDirs(const std::string&);
+
+void CheckStaggering(int runNumber, int max = -1, const std::string& dir = "")
+{
+  gStyle->SetOptStat(0);
+  auto dirs = findDirs(dir);
+  printf("Will iterate over %zu input dirs", dirs.size());
+  if (dirs.empty()) {
+    printf("No input found");
+    return;
+  }
+  if (max > 0 && (int)dirs.size() > max) {
+    std::random_device rd;
+    std::mt19937 g(rd());
+    std::shuffle(dirs.begin(), dirs.end(), g);
+    dirs.resize(max);
+    printf("restricting to %ddirs", max);
+  }
+
+  auto& ccdbmgr = o2::ccdb::BasicCCDBManager::instance();
+  ccdbmgr.setURL("https://alice-ccdb.cern.ch");
+  auto runDuration = ccdbmgr.getRunDuration(runNumber);
+  auto tRun = runDuration.first + (runDuration.second - runDuration.first) / 2; // time stamp for the middle of the run duration
+  ccdbmgr.setTimestamp(tRun);
+  printf("Run %d has TS %lld", runNumber, tRun);
+  auto geoAligned = ccdbmgr.get<TGeoManager>("GLO/Config/GeometryAligned");
+  auto magField = ccdbmgr.get<o2::parameters::GRPMagField>("GLO/Config/GRPMagField");
+  auto grpLHC = ccdbmgr.get<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF");
+  auto bcFill = grpLHC->getBunchFilling();
+  bcFill.print(-1);
+  const o2::base::MatLayerCylSet* matLut = o2::base::MatLayerCylSet::rectifyPtrFromFile(ccdbmgr.get<o2::base::MatLayerCylSet>("GLO/Param/MatLUT"));
+  o2::base::Propagator::initFieldFromGRP(magField);
+  auto prop = o2::base::Propagator::Instance();
+  prop->setMatLUT(matLut);
+  const float bz = prop->getNominalBz();
+
+  auto hNTrkCls = new TH1D("hNTrkCls", "Number of cluster per track;nCls;entries", 4, 3.5, 7.5);
+  std::array<TH1*, 5> hTrkTS{nullptr};
+  for (int i{0}; i < 5; ++i) {
+    hTrkTS[i] = new TH1D(Form("hTrkTS_%d", i), Form("track time t0 (%s);t0 (BC)", i == 0 ? "all" : Form("NCls=%d", 3 + i)), o2::constants::lhc::LHCMaxBunches, 0, o2::constants::lhc::LHCMaxBunches);
+  }
+  auto hTrkTSE = new TH1D("hTrkTSE", "assigned time errors; tE (BC)", 198, -0.5, 198 - 0.5);
+
+  // K0 && Phi-Meson
+  const float mMinITSPt{0.15};
+  //
+  const int phiMinNCls{7};
+  const float phiMaxDCAR2MVTX{0.05}; // max distance to mean vtx
+  auto hPhiMeson = new TH1D("hPhiMeson", "#phi meson;mass (GeV/c^{2})", 200, 0.96, 1.1);
+  auto hPhiMesonBkg = new TH1D("hPhiMesonBkg", "#phi meson background;mass (GeV/c^{2})", 200, 0.96, 1.1);
+
+  const int mK0MinNCls{7};
+  const float mK0minCosPAXYMeanVertex = 0.98;
+  const float mK0MaxDCAXY2ToMeanVertex = 0.2;
+  const float mK0MaxTgl2V0 = 1;
+  const float mK0MinPt2V0 = 0.3;
+  const float mK0MinCosPA = 0.999;
+  o2::vertexing::DCAFitterN<2> k0Ft;
+  k0Ft.setBz(bz);
+  k0Ft.setPropagateToPCA(true); // After finding the vertex, propagate tracks to the DCA. This is default anyway
+  k0Ft.setMaxR(30);
+  k0Ft.setMaxDZIni(0.1);
+  k0Ft.setMaxDXYIni(0.1);
+  k0Ft.setMinParamChange(1e-3);
+  k0Ft.setMinRelChi2Change(0.9);
+  k0Ft.setMaxChi2(5);
+  k0Ft.setUseAbsDCA(true);
+  auto hK0 = new TH1D("hK0", "K0;mass (GeV/c^{2})", 100, 0.4, 0.6);
+  o2::vertexing::SVertexHypothesis k0Hyp;
+  const float k0Par[] = {0., 20, 0., 5.0, 0.0, 1.09004e-03, 2.62291e-04, 8.93179e-03, 2.83121};
+  k0Hyp.set(o2::track::PID::K0, o2::track::PID::Pion, o2::track::PID::Pion, k0Par, bz);
+
+  auto hVtxXY = new TH2F("hVtxXY", "seeding vertices XY", 200, -0.3, 0.3, 200, -0.3, 0.3);
+  auto hVtxZ = new TH1F("hVtxZ", "seeding vertices Z", 200, -16, 16);
+  auto hVtxNCont = new TH1F("hVtxNCont", "seeding vertices contributors", 100, 0, 100);
+  auto hVtxZNCont = new TProfile("hVtxZNCont", "seeding vertices z-contributors", 200, -16, 16);
+  auto hVtxCls = new TProfile("hVtxCls", ";Cls/TF;Cls/Vtx", 400, 20000, 60000);
+  auto hVtxTS = new TH1D("hVtxTS", "vtx time t0;t0 (BC)", o2::constants::lhc::LHCMaxBunches, 0, o2::constants::lhc::LHCMaxBunches);
+
+  const float minVtxWeight{5};
+  float meanVtxWeight{0};
+  o2::dataformats::VertexBase meanVtx;
+  auto accountVtx = [&](o2::its::Vertex const& vtx) {
+    const float w = vtx.getNContributors();
+    if (w >= minVtxWeight) {
+      meanVtx.setX((meanVtx.getX() * meanVtxWeight + vtx.getX() * w) / (meanVtxWeight + w));
+      meanVtx.setY((meanVtx.getY() * meanVtxWeight + vtx.getY() * w) / (meanVtxWeight + w));
+      meanVtxWeight += w;
+    }
+  };
+
+  std::vector<o2::its::TrackITS> trkArr, *trkArrPtr{&trkArr};
+  std::vector<o2::its::Vertex> vtxArr, *vtxArrPtr{&vtxArr};
+  std::array<std::vector<o2::itsmft::CompClusterExt>*, 7> clsArr{nullptr};
+  for (size_t iDir{0}; iDir < dirs.size(); ++iDir) {
+    int progress = static_cast<int>((iDir + 1) * 100 / dirs.size());
+    printf("\rProgress: [");
+    int barWidth = 50;
+    int pos = barWidth * progress / 100;
+    for (int j = 0; j < barWidth; ++j) {
+      if (j < pos) {
+        printf("=");
+      } else if (j == pos) {
+        printf(">");
+      } else {
+        printf(" ");
+      }
+    }
+    printf("] %d%%", progress);
+    fflush(stdout);
+
+    const auto& d = dirs[iDir];
+    auto fTrks = TFile::Open((d / tracFile).c_str());
+    auto fCls = TFile::Open((d / clsFile).c_str());
+    if (!fTrks || !fCls || fTrks->IsZombie() || fCls->IsZombie()) {
+      continue;
+    }
+    auto tTrks = fTrks->Get<TTree>("o2sim");
+    auto tCls = fCls->Get<TTree>("o2sim");
+    if (!tTrks || !tCls) {
+      continue;
+    }
+
+    tTrks->SetBranchAddress("ITSTrack", &trkArrPtr);
+    tTrks->SetBranchAddress("Vertices", &vtxArrPtr);
+    for (int i{0}; i < 7; ++i) {
+      tCls->SetBranchAddress(Form("ITSClusterComp_%d", i), &clsArr[i]);
+    }
+
+    for (int iTF{0}; tTrks->LoadTree(iTF) >= 0; ++iTF) {
+      tTrks->GetEntry(iTF);
+      tCls->GetEntry(iTF);
+
+      size_t ncls = 0;
+      for (int i{0}; i < 7; ++i) {
+        ncls += clsArr[i]->size();
+      }
+
+      // for each TF built pool of positive and negaitve tracks
+      std::vector<const o2::its::TrackITS*> posPool, negPool;
+
+      for (const auto& trk : trkArr) {
+        hNTrkCls->Fill(trk.getNClusters());
+        hTrkTS[0]->Fill(std::fmod(trk.getTimeStamp().getTimeStamp(), o2::constants::lhc::LHCMaxBunches));
+        hTrkTS[trk.getNClusters() - 3]->Fill(std::fmod(trk.getTimeStamp().getTimeStamp(), o2::constants::lhc::LHCMaxBunches));
+        hTrkTSE->Fill(trk.getTimeStamp().getTimeStampError());
+
+        if (trk.getPt() > mMinITSPt) {
+          if (trk.getCharge() > 0) {
+            posPool.push_back(&trk);
+          } else {
+            negPool.push_back(&trk);
+          }
+        }
+      }
+
+      for (const auto& vtx : vtxArr) {
+        hVtxXY->Fill(vtx.getX(), vtx.getY());
+        hVtxZ->Fill(vtx.getZ());
+        hVtxNCont->Fill(vtx.getNContributors());
+        hVtxZNCont->Fill(vtx.getZ(), vtx.getNContributors());
+        hVtxTS->Fill(vtx.getTimeStamp().getTimeStamp());
+        accountVtx(vtx);
+      }
+      hVtxCls->Fill(ncls, (float)ncls / (float)vtxArr.size());
+
+      std::vector<PairCandidate> k0Cands;
+      for (int iPos{0}; iPos < (int)posPool.size(); ++iPos) {
+        const auto pos = posPool[iPos];
+        for (int iNeg{0}; iNeg < (int)negPool.size(); ++iNeg) {
+          const auto neg = negPool[iNeg];
+          bool overlap = std::abs(pos->getTimeStamp().getTimeStamp() - neg->getTimeStamp().getTimeStamp()) <= (pos->getTimeStamp().getTimeStampError() + neg->getTimeStamp().getTimeStampError());
+          if (!overlap) {
+            continue;
+          }
+
+          // phi-meson
+          if (pos->getNClusters() >= phiMinNCls && neg->getNClusters() >= phiMinNCls) {
+            o2::dataformats::DCA posDCA, negDCA;
+            o2::track::TrackParCov posPhi = *pos;
+            posPhi.setPID(o2::track::PID::Kaon);
+            o2::track::TrackParCov negPhi = *neg;
+            negPhi.setPID(o2::track::PID::Kaon);
+            if (prop->propagateToDCA(meanVtx, posPhi, bz, 2.0, o2::base::Propagator::MatCorrType::USEMatCorrLUT, &posDCA) && prop->propagateToDCA(meanVtx, negPhi, bz, 2.0, o2::base::Propagator::MatCorrType::USEMatCorrLUT, &negDCA)) {
+              if (posDCA.getR2() < phiMaxDCAR2MVTX && negDCA.getR2() < phiMaxDCAR2MVTX) {
+                std::array<float, 3> pP{}, pN{};
+                posPhi.getPxPyPzGlo(pP);
+                negPhi.getPxPyPzGlo(pN);
+                TLorentzVector p1, p2;
+                p1.SetXYZM(pP[0], pP[1], pP[2], posPhi.getPID().getMass());
+                p2.SetXYZM(pN[0], pN[1], pN[2], negPhi.getPID().getMass());
+                TLorentzVector mother = p1 + p2;
+                hPhiMeson->Fill(mother.M());
+                // rotate on daughter track to estimate background
+                for (int i{0}; i < 10; ++i) {
+                  double theta = gRandom->Uniform(165.f, 195.f) * TMath::DegToRad();
+                  double pxN = pN[0] * cos(theta) - pN[1] * sin(theta);
+                  double pyN = pN[0] * sin(theta) + pN[1] * cos(theta);
+                  double pxP = pP[0] * cos(-theta) - pP[1] * sin(-theta);
+                  double pyP = pP[0] * sin(-theta) + pP[1] * cos(-theta);
+                  p1.SetXYZM(pxP, pyP, pP[2], posPhi.getPID().getMass());
+                  p2.SetXYZM(pxN, pyN, pN[2], negPhi.getPID().getMass());
+                  mother = p1 + p2;
+                  hPhiMesonBkg->Fill(mother.M());
+                }
+              }
+            }
+          }
+          // K0
+          if (pos->getNClusters() >= mK0MinNCls && neg->getNClusters() >= mK0MinNCls) {
+            o2::track::TrackParCov posPion = *pos;
+            posPion.setPID(o2::track::PID::Pion);
+            o2::track::TrackParCov negPion = *neg;
+            negPion.setPID(o2::track::PID::Pion);
+            int ncand = k0Ft.process(posPion, negPion);
+            const int cand = 0;
+            if (ncand) {
+              const auto& v0XYZ = k0Ft.getPCACandidate();
+              float dxv0 = v0XYZ[0] - meanVtx.getX(), dyv0 = v0XYZ[1] - meanVtx.getY(), r2v0 = dxv0 * dxv0 + dyv0 * dyv0;
+              if (!k0Ft.isPropagateTracksToVertexDone(cand) && !k0Ft.propagateTracksToVertex(cand)) {
+                continue;
+              }
+              const auto& trPProp = k0Ft.getTrack(0, cand);
+              const auto& trNProp = k0Ft.getTrack(1, cand);
+              std::array<float, 3> pP{}, pN{};
+              trPProp.getPxPyPzGlo(pP);
+              trNProp.getPxPyPzGlo(pN);
+              // estimate DCA of neutral V0 track to beamline: straight line with parametric equation
+              // x = X0 + pV0[0]*t, y = Y0 + pV0[1]*t reaches DCA to beamline (Xv, Yv) at
+              // t = -[ (x0-Xv)*pV0[0] + (y0-Yv)*pV0[1]) ] / ( pT(pV0)^2 )
+              // Similar equation for 3D distance involving pV0[2]
+              std::array<float, 3> pV0 = {pP[0] + pN[0], pP[1] + pN[1], pP[2] + pN[2]};
+              float pt2V0 = pV0[0] * pV0[0] + pV0[1] * pV0[1], prodXYv0 = dxv0 * pV0[0] + dyv0 * pV0[1], tDCAXY = prodXYv0 / pt2V0;
+              if (pt2V0 < mK0MinPt2V0) { // pt cut
+                continue;
+              }
+              if (pV0[2] * pV0[2] / pt2V0 > mK0MaxTgl2V0) { // tgLambda cut
+                continue;
+              }
+              float dcaX = dxv0 - pV0[0] * tDCAXY, dcaY = dyv0 - pV0[1] * tDCAXY, dca2 = dcaX * dcaX + dcaY * dcaY;
+              float cosPAXY = prodXYv0 / std::sqrt(r2v0 * pt2V0);
+              if (dca2 > mK0MaxDCAXY2ToMeanVertex || cosPAXY < mK0minCosPAXYMeanVertex) {
+                continue;
+              }
+              float p2V0 = pt2V0 + pV0[2] * pV0[2], ptV0 = std::sqrt(pt2V0);
+              float p2Pos = pP[0] * pP[0] + pP[1] * pP[1] + pP[2] * pP[2], p2Neg = pN[0] * pN[0] + pN[1] * pN[1] + pN[2] * pN[2];
+              if (!k0Hyp.check(p2Pos, p2Neg, p2V0, ptV0)) {
+                continue;
+              }
+
+              float bestCosPA = mK0MinCosPA;
+              bool candFound = false;
+              for (const auto& vtx : vtxArr) {
+                if (vtx.getNContributors() > minVtxWeight) {
+                  const auto vtxT = vtx.getTimeStamp().makeSymmetrical();
+                  bool overlapPos = std::abs(pos->getTimeStamp().getTimeStamp() - vtxT.getTimeStamp()) <= (pos->getTimeStamp().getTimeStampError() + vtxT.getTimeStampError());
+                  bool overlapNeg = std::abs(neg->getTimeStamp().getTimeStamp() - vtxT.getTimeStamp()) <= (neg->getTimeStamp().getTimeStampError() + vtxT.getTimeStampError());
+                  if (overlapPos && overlapNeg) {
+                    float dx = v0XYZ[0] - vtx.getX(), dy = v0XYZ[1] - vtx.getY(), dz = v0XYZ[2] - vtx.getZ(), prodXYZv0 = dx * pV0[0] + dy * pV0[1] + dz * pV0[2];
+                    float cosPA = prodXYZv0 / std::sqrt((dx * dx + dy * dy + dz * dz) * p2V0);
+                    if (cosPA > bestCosPA) {
+                      bestCosPA = cosPA;
+                      candFound = true;
+                    }
+                  }
+                }
+              }
+              if (candFound) {
+                TLorentzVector p1, p2;
+                p1.SetXYZM(pP[0], pP[1], pP[2], posPion.getPID().getMass());
+                p2.SetXYZM(pN[0], pN[1], pN[2], negPion.getPID().getMass());
+                TLorentzVector mother = p1 + p2;
+                double mass = mother.M();
+                k0Cands.emplace_back(iPos, iNeg, k0Ft.getChi2AtPCACandidate(cand), mass);
+              }
+            }
+          }
+        }
+      }
+
+      // disambiguiate candidates by using the smallest DCA one
+      std::sort(k0Cands.begin(), k0Cands.end(), [](const auto& a, const auto& b) { return a.dca < b.dca; });
+      std::vector<bool> posUsed(posPool.size(), false);
+      std::vector<bool> negUsed(negPool.size(), false);
+      for (const auto& c : k0Cands) {
+        if (!posUsed[c.posIdx] && !negUsed[c.negIdx]) {
+          posUsed[c.posIdx] = true;
+          negUsed[c.negIdx] = true;
+          hK0->Fill(c.mass);
+        }
+      }
+    }
+
+    fTrks->Close();
+    fCls->Close();
+  }
+
+  auto drawBCPattern = [&]() {
+    gPad->Update();
+    // draw BC pattern
+    double ymin = gPad->GetUymin();
+    double ymax = gPad->GetUymax();
+    auto interactingBC = bcFill.getPattern();
+    TLine* lastLine{nullptr};
+    for (int iBC{0}; iBC < (int)interactingBC.size(); ++iBC) {
+      if (interactingBC.test(iBC)) {
+        TLine* line = new TLine(iBC, ymin, iBC, ymax);
+        line->SetLineColor(kRed);
+        line->SetLineWidth(1);
+        line->SetLineStyle(kDashed);
+        line->Draw();
+        lastLine = line;
+      }
+    }
+    return lastLine;
+  };
+
+  {
+    TFile out(Form("check_%d.root", runNumber), "RECREATE");
+    out.WriteTObject(hNTrkCls);
+    for (int i{0}; i < 5; ++i) {
+      out.WriteTObject(hTrkTS[i]);
+    }
+    out.WriteTObject(hTrkTSE);
+    out.WriteTObject(hPhiMeson);
+    out.WriteTObject(hPhiMesonBkg);
+    out.WriteTObject(hK0);
+    out.WriteTObject(hVtxXY);
+    out.WriteTObject(hVtxZ);
+    out.WriteTObject(hVtxNCont);
+    out.WriteTObject(hVtxZNCont);
+    out.WriteTObject(hVtxTS);
+    out.WriteTObject(hVtxCls);
+  }
+
+  // fitK0(hK0, runNumber);
+  // fitPhiMeson(hPhiMeson, runNumber);
+  {
+    auto c = new TCanvas();
+    hNTrkCls->Draw();
+    c->Draw();
+    c->SaveAs(Form("trk_%d.pdf", runNumber));
+  }
+  {
+    auto c = new TCanvas();
+    c->Divide(3, 2);
+    for (int i{0}; i < 5; ++i) {
+      c->cd(i + 1);
+      hTrkTS[i]->Draw();
+      auto lastLine = drawBCPattern();
+      if (i == 0) {
+        auto leg = new TLegend(0.6, 0.6, 0.9, 0.9);
+        leg->AddEntry(lastLine, "Interacting BCs", "l");
+        leg->AddEntry(hTrkTS[i], "Track timestamp");
+        leg->Draw();
+      }
+    }
+    c->cd(6);
+    hTrkTSE->Draw();
+    c->Draw();
+    c->SaveAs(Form("time_%d.pdf", runNumber));
+  }
+  {
+    auto c = new TCanvas();
+    c->Divide(2, 1);
+    {
+      c->cd(1);
+      hPhiMeson->Draw();
+      gPad->Update();
+      double ymin = gPad->GetUymin();
+      double ymax = gPad->GetUymax();
+      const float mass = 1.019461;
+      TLine* line = new TLine(mass, ymin, mass, ymax);
+      line->SetLineColor(kRed);
+      line->SetLineWidth(1);
+      line->SetLineStyle(kDashed);
+      line->Draw();
+    }
+    {
+      c->cd(2);
+      hK0->Draw();
+      gPad->Update();
+      double ymin = gPad->GetUymin();
+      double ymax = gPad->GetUymax();
+      const float mass = 0.497611;
+      TLine* line = new TLine(mass, ymin, mass, ymax);
+      line->SetLineColor(kRed);
+      line->SetLineWidth(1);
+      line->SetLineStyle(kDashed);
+      line->Draw();
+    }
+    c->Draw();
+    c->SaveAs(Form("mass_%d.pdf", runNumber));
+  }
+  {
+    auto c = new TCanvas();
+    c->Divide(3, 2);
+    {
+      c->cd(1);
+      hVtxXY->Draw("col");
+    }
+    {
+      c->cd(2);
+      hVtxZ->Draw();
+    }
+    {
+      c->cd(3);
+      hVtxNCont->Draw();
+    }
+    {
+      c->cd(4);
+      hVtxZNCont->Draw();
+    }
+    {
+      c->cd(5);
+      hVtxCls->Draw();
+    }
+    {
+      c->cd(6);
+      hVtxTS->Draw();
+      auto lastLine = drawBCPattern();
+      auto leg = new TLegend(0.6, 0.6, 0.9, 0.9);
+      leg->AddEntry(lastLine, "Interacting BCs", "l");
+      leg->AddEntry(hVtxTS, "Track timestamp");
+      leg->Draw();
+    }
+    c->Draw();
+    c->SaveAs(Form("vertex_%d.pdf", runNumber));
+  }
+}
+
+std::vector<std::filesystem::path> findDirs(const std::string& roots)
+{
+  std::filesystem::path root;
+  if (roots.empty()) {
+    root = std::filesystem::current_path();
+  } else {
+    root = roots;
+  }
+  namespace fs = std::filesystem;
+  std::vector<fs::path> result;
+  auto has_files = [](const fs::path& dir) {
+    auto s = dir / tracFile;
+    return fs::exists(dir / tracFile) && fs::exists(dir / clsFile) &&
+           fs::is_regular_file(dir / tracFile) && fs::is_regular_file(dir / clsFile);
+  };
+  if (fs::is_directory(root) && has_files(root)) {
+    result.push_back(root);
+    return result;
+  }
+  for (const auto& entry : fs::recursive_directory_iterator(root)) {
+    if (!entry.is_directory()) {
+      continue;
+    }
+    const fs::path dir = entry.path();
+    if (has_files(dir)) {
+      result.push_back(dir);
+    }
+  }
+  return result;
+}
diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ImpactParameter.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ImpactParameter.cxx
index c0aaabddaca1b..bc8b931190ed1 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ImpactParameter.cxx
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ImpactParameter.cxx
@@ -29,7 +29,7 @@
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "DataFormatsParameters/GRPECSObject.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "Framework/DeviceSpec.h"
 #include "CommonUtils/ConfigurableParam.h"
diff --git a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx
index 30fb39c77f235..8bcb444f650bd 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx
@@ -16,6 +16,7 @@
 #include "Framework/CompletionPolicyHelpers.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 // Include studies hereafter
 #include "ITSStudies/ImpactParameter.h"
@@ -54,6 +55,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"track-extension-study", VariantType::Bool, false, {"Perform the track extension study"}},
     {"efficiency-study", VariantType::Bool, false, {"Perform the efficiency study"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   // o2::raw::HBFUtilsInitializer::addConfigOption(options, "o2_tfidinfo.root");
   std::swap(workflowOptions, options);
 }
@@ -135,8 +137,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     LOGP(info, "No study selected, dryrunning");
   }
 
-  o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
-  // write the configuration used for the studies workflow
+  // o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
+  //  write the configuration used for the studies workflow
   o2::conf::ConfigurableParam::writeINI("o2_its_standalone_configuration.ini");
 
   return std::move(specs);
diff --git a/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt b/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
index d2126be1da2c6..be42015b95795 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/reconstruction/CMakeLists.txt
@@ -11,8 +11,6 @@
 
 o2_add_library(ITSReconstruction
         SOURCES src/RecoGeomHelper.cxx
-                src/FastMultEstConfig.cxx
-                src/FastMultEst.cxx
         PUBLIC_LINK_LIBRARIES O2::ITSBase
                               O2::ITSMFTReconstruction
                               O2::DataFormatsITS
@@ -20,6 +18,4 @@ o2_add_library(ITSReconstruction
 
 o2_target_root_dictionary(
   ITSReconstruction
-  HEADERS include/ITSReconstruction/RecoGeomHelper.h
-          include/ITSReconstruction/FastMultEst.h
-          include/ITSReconstruction/FastMultEstConfig.h)
+        HEADERS include/ITSReconstruction/RecoGeomHelper.h)
diff --git a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/FastMultEst.h b/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/FastMultEst.h
deleted file mode 100644
index 9e8299e89b404..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/FastMultEst.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file  FastMultEst.h
-/// \brief Fast multiplicity estimator for ITS
-/// \author ruben.shahoyan@cern.ch
-
-#ifndef ALICEO2_ITS_FASTMULTEST_
-#define ALICEO2_ITS_FASTMULTEST_
-
-#include "ITSMFTReconstruction/ChipMappingITS.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include <DataFormatsITSMFT/PhysTrigger.h>
-#include "ITSReconstruction/FastMultEstConfig.h"
-#include <gsl/span>
-#include <array>
-
-namespace o2
-{
-namespace its
-{
-
-struct FastMultEst {
-
-  static constexpr int NLayers = o2::itsmft::ChipMappingITS::NLayers;
-
-  float mult = 0.;                         /// estimated signal clusters multipliciy at reference (1st?) layer
-  float noisePerChip = 0.;                 /// estimated or imposed noise per chip
-  float cov[3] = {0.};                     /// covariance matrix of estimation
-  float chi2 = 0.;                         /// chi2
-  int nLayersUsed = 0;                     /// number of layers actually used
-  uint32_t lastRandomSeed = 0;             /// state of the gRandom before
-
-  std::array<int, NLayers> nClPerLayer{0}; // measured N Cl per layer selectROFs
-  FastMultEst();
-
-  static uint32_t getCurrentRandomSeed();
-  int selectROFs(const gsl::span<const o2::itsmft::ROFRecord> rofs, const gsl::span<const o2::itsmft::CompClusterExt> clus,
-                 const gsl::span<const o2::itsmft::PhysTrigger> trig, std::vector<uint8_t>& sel);
-
-  void fillNClPerLayer(const gsl::span<const o2::itsmft::CompClusterExt>& clusters);
-  float process(const std::array<int, NLayers> ncl)
-  {
-    return FastMultEstConfig::Instance().imposeNoisePerChip > 0 ? processNoiseImposed(ncl) : processNoiseFree(ncl);
-  }
-  float processNoiseFree(const std::array<int, NLayers> ncl);
-  float processNoiseImposed(const std::array<int, NLayers> ncl);
-  float process(const gsl::span<const o2::itsmft::CompClusterExt>& clusters)
-  {
-    fillNClPerLayer(clusters);
-    return process(nClPerLayer);
-  }
-  static bool sSeedSet;
-
-  ClassDefNV(FastMultEst, 1);
-};
-
-} // namespace its
-} // namespace o2
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/TrivialVertexer.h b/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/TrivialVertexer.h
deleted file mode 100644
index 3eb218dc973f6..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/TrivialVertexer.h
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file TrivialVertexer.h
-/// \brief Definition of the ITS trivial vertex finder
-#ifndef ALICEO2_ITS_TRIVIALVERTEXER_H
-#define ALICEO2_ITS_TRIVIALVERTEXER_H
-
-#include <array>
-
-#include "Rtypes.h" // for TrivialVertexer::Class, Double_t, ClassDef, etc
-
-class TFile;
-class TTree;
-class FairMCEventHeader;
-
-namespace o2
-{
-namespace itsmft
-{
-class Cluster;
-}
-} // namespace o2
-
-namespace o2
-{
-class MCCompLabel;
-namespace dataformats
-{
-template <typename T>
-class MCTruthContainer;
-}
-namespace its
-{
-class TrivialVertexer
-{
-  using Cluster = o2::itsmft::Cluster;
-  using Label = o2::MCCompLabel;
-
- public:
-  TrivialVertexer();
-  ~TrivialVertexer();
-
-  TrivialVertexer(const TrivialVertexer&) = delete;
-  TrivialVertexer& operator=(const TrivialVertexer&) = delete;
-
-  Bool_t openInputFile(const Char_t*);
-
-  void process(const std::vector<Cluster>& clusters, std::vector<std::array<Double_t, 3>>& vertices);
-  void setMCTruthContainer(const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* truth) { mClsLabels = truth; }
-
- private:
-  const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mClsLabels = nullptr; // Cluster MC labels
-
-  TFile* mFile = nullptr;
-  TTree* mTree = nullptr;
-  FairMCEventHeader* mHeader = nullptr;
-};
-} // namespace its
-} // namespace o2
-
-#endif /* ALICEO2_ITS_TRIVIALVERTEXER_H */
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/FastMultEst.cxx b/Detectors/ITSMFT/ITS/reconstruction/src/FastMultEst.cxx
deleted file mode 100644
index c547996c6f356..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/src/FastMultEst.cxx
+++ /dev/null
@@ -1,189 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file  FastMultEst.h
-/// \brief Fast multiplicity estimator for ITS
-/// \author ruben.shahoyan@cern.ch
-
-#include "ITSReconstruction/FastMultEst.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
-#include "Framework/Logger.h"
-#include <ctime>
-#include <cstring>
-#include <TRandom.h>
-
-using namespace o2::its;
-
-bool FastMultEst::sSeedSet = false;
-
-///______________________________________________________
-FastMultEst::FastMultEst()
-{
-  if (!sSeedSet && FastMultEstConfig::Instance().cutRandomFraction > 0.f) {
-    sSeedSet = true;
-    if (FastMultEstConfig::Instance().randomSeed > 0) {
-      gRandom->SetSeed(FastMultEstConfig::Instance().randomSeed);
-    } else if (FastMultEstConfig::Instance().randomSeed < 0) {
-      gRandom->SetSeed(std::time(nullptr) % 0xffff);
-    }
-  }
-}
-
-///______________________________________________________
-/// find multiplicity for given set of clusters
-void FastMultEst::fillNClPerLayer(const gsl::span<const o2::itsmft::CompClusterExt>& clusters)
-{
-  int lr = FastMultEst::NLayers - 1, nchAcc = o2::itsmft::ChipMappingITS::getNChips() - o2::itsmft::ChipMappingITS::getNChipsPerLr(lr);
-  std::memset(&nClPerLayer[0], 0, sizeof(int) * FastMultEst::NLayers);
-  for (int i = clusters.size(); i--;) { // profit from clusters being ordered in chip increasing order
-    while (clusters[i].getSensorID() < nchAcc) {
-      assert(lr >= 0);
-      nchAcc -= o2::itsmft::ChipMappingITS::getNChipsPerLr(--lr);
-    }
-    nClPerLayer[lr]++;
-  }
-}
-
-///______________________________________________________
-/// find multiplicity for given number of clusters per layer
-float FastMultEst::processNoiseFree(const std::array<int, NLayers> ncl)
-{
-  // we assume that on the used layers the observed number of clusters is defined by the
-  // the noise ~ nu * Nchips and contribution from the signal tracks Ntr*mAccCorr
-  const auto& conf = FastMultEstConfig::Instance();
-
-  float mat[3] = {0}, b[2] = {0};
-  nLayersUsed = 0;
-  for (int il = conf.firstLayer; il <= conf.lastLayer; il++) {
-    if (ncl[il] > 0) {
-      int nch = o2::itsmft::ChipMappingITS::getNChipsPerLr(il);
-      float err2i = 1. / ncl[il];
-      float m2n = nch * err2i;
-      mat[0] += err2i * conf.accCorr[il] * conf.accCorr[il];
-      mat[2] += nch * m2n;
-      mat[1] += conf.accCorr[il] * m2n; // non-diagonal element
-      b[0] += conf.accCorr[il];
-      b[1] += nch;
-      nLayersUsed++;
-    }
-  }
-  mult = noisePerChip = chi2 = -1;
-  float det = mat[0] * mat[2] - mat[1] * mat[1];
-  if (nLayersUsed < 2 || std::abs(det) < 1e-15) {
-    return -1;
-  }
-  float detI = 1. / det;
-  mult = detI * (b[0] * mat[2] - b[1] * mat[1]);
-  noisePerChip = detI * (b[1] * mat[0] - b[0] * mat[1]);
-  cov[0] = mat[2] * detI;
-  cov[2] = mat[0] * detI;
-  cov[1] = -mat[1] * detI;
-  chi2 = 0.;
-  for (int il = conf.firstLayer; il <= conf.lastLayer; il++) {
-    if (ncl[il] > 0) {
-      int nch = o2::itsmft::ChipMappingITS::getNChipsPerLr(il);
-      float diff = mult * conf.accCorr[il] + nch * noisePerChip - ncl[il];
-      chi2 += diff * diff / ncl[il];
-    }
-  }
-  chi2 = nLayersUsed > 2 ? chi2 / (nLayersUsed - 2) : 0.;
-  return mult > 0 ? mult : 0;
-}
-
-///______________________________________________________
-/// find multiplicity for given number of clusters per layer with mean noise imposed
-float FastMultEst::processNoiseImposed(const std::array<int, NLayers> ncl)
-{
-  // we assume that on the used layers the observed number of clusters is defined by the
-  // the noise ~ nu * Nchips and contribution from the signal tracks Ntr*conf.accCorr
-  //
-  const auto& conf = FastMultEstConfig::Instance();
-  float accSum = 0., accWSum = 0., noiseSum = 0.;
-  nLayersUsed = 0;
-  for (int il = conf.firstLayer; il <= conf.lastLayer; il++) {
-    if (ncl[il] > 0) {
-      float err = 1. / ncl[il];
-      accSum += conf.accCorr[il];
-      accWSum += conf.accCorr[il] * conf.accCorr[il] * err;
-      noiseSum += o2::itsmft::ChipMappingITS::getNChipsPerLr(il) * conf.accCorr[il] * err;
-      nLayersUsed++;
-    }
-  }
-  mult = 0;
-  if (nLayersUsed) {
-    mult = (accSum - noisePerChip * noiseSum) / accWSum;
-  }
-  return mult;
-}
-
-int FastMultEst::selectROFs(const gsl::span<const o2::itsmft::ROFRecord> rofs, const gsl::span<const o2::itsmft::CompClusterExt> clus,
-                            const gsl::span<const o2::itsmft::PhysTrigger> trig, std::vector<uint8_t>& sel)
-{
-  int nrof = rofs.size(), nsel = 0;
-  const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
-  sel.clear();
-  sel.resize(nrof, true); // by default select all
-  lastRandomSeed = gRandom->GetSeed();
-  if (multEstConf.isMultCutRequested()) {
-    for (uint32_t irof = 0; irof < nrof; irof++) {
-      nsel += sel[irof] = multEstConf.isPassingMultCut(process(rofs[irof].getROFData(clus)));
-    }
-  } else {
-    nsel = nrof;
-  }
-  using IdNT = std::pair<int, int>;
-  if (multEstConf.cutRandomFraction > 0.) {
-    int ntrig = trig.size(), currTrig = 0;
-    if (multEstConf.preferTriggered) {
-      const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-      std::vector<IdNT> nTrigROF;
-      nTrigROF.reserve(nrof);
-      for (uint32_t irof = 0; irof < nrof; irof++) {
-        if (sel[irof]) {
-          if (nsel && gRandom->Rndm() < multEstConf.cutRandomFraction) {
-            nsel--;
-          }
-          auto irROF = rofs[irof].getBCData();
-          while (currTrig < ntrig && trig[currTrig].ir < irROF) { // triggers are sorted, jump to 1st one not less than current ROF
-            currTrig++;
-          }
-          auto& trof = nTrigROF.emplace_back(irof, 0);
-          irROF += alpParams.roFrameLengthInBC;
-          while (currTrig < ntrig && trig[currTrig].ir < irROF) {
-            trof.second++;
-            currTrig++;
-          }
-        }
-      }
-      if (nsel > 0) {
-        sort(nTrigROF.begin(), nTrigROF.end(), [](const IdNT& a, const IdNT& b) { return a.second > b.second; }); // order in number of triggers
-        auto last = nTrigROF.begin() + nsel;
-        sort(nTrigROF.begin(), last, [](const IdNT& a, const IdNT& b) { return a.first < b.first; }); // order in ROF ID first nsel ROFs
-      }
-      for (int i = nsel; i < int(nTrigROF.size()); i++) { // reject ROFs in the tail
-        sel[nTrigROF[i].first] = false;
-      }
-    } else { // dummy random rejection
-      for (int irof = 0; irof < nrof; irof++) {
-        if (sel[irof]) {
-          float sr = gRandom->Rndm();
-          if (gRandom->Rndm() < multEstConf.cutRandomFraction) {
-            sel[irof] = false;
-            nsel--;
-          }
-        }
-      }
-    }
-  }
-  LOGP(debug, "NSel = {} of {} rofs Seeds: before {} after {}", nsel, nrof, lastRandomSeed, gRandom->GetSeed());
-
-  return nsel;
-}
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/ITSReconstructionLinkDef.h b/Detectors/ITSMFT/ITS/reconstruction/src/ITSReconstructionLinkDef.h
index 67622303fc840..3bc8ee0f5403b 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/src/ITSReconstructionLinkDef.h
+++ b/Detectors/ITSMFT/ITS/reconstruction/src/ITSReconstructionLinkDef.h
@@ -16,8 +16,5 @@
 #pragma link off all functions;
 
 #pragma link C++ class o2::its::RecoGeomHelper + ;
-#pragma link C++ class o2::its::FastMultEst + ;
-#pragma link C++ class o2::its::FastMultEstConfig + ;
-#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::FastMultEstConfig> + ;
 
 #endif
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/TrivialVertexer.cxx b/Detectors/ITSMFT/ITS/reconstruction/src/TrivialVertexer.cxx
deleted file mode 100644
index cb7f1eeacb02e..0000000000000
--- a/Detectors/ITSMFT/ITS/reconstruction/src/TrivialVertexer.cxx
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file TrivialVertexer.cxx
-/// \brief Implementation of the ITS trivial vertex finder
-
-#include <limits>
-
-#include "TFile.h"
-#include "TTree.h"
-
-#include "FairMCEventHeader.h"
-#include <fairlogger/Logger.h>
-
-#include "ITSReconstruction/TrivialVertexer.h"
-#include "DataFormatsITSMFT/CompCluster.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "SimulationDataFormat/MCTruthContainer.h"
-
-using namespace o2::itsmft;
-using namespace o2::its;
-
-using Point3Df = o2::math_utils::Point3D<float>;
-
-TrivialVertexer::TrivialVertexer() = default;
-
-TrivialVertexer::~TrivialVertexer()
-{
-  if (mHeader)
-    delete mHeader;
-  if (mTree)
-    delete mTree;
-  if (mFile)
-    delete mFile;
-}
-
-Bool_t TrivialVertexer::openInputFile(const Char_t* fname)
-{
-  mFile = TFile::Open(fname, "old");
-  if (!mFile) {
-    LOG(error) << "TrivialVertexer::openInputFile() : "
-               << "Cannot open the input file !";
-    return kFALSE;
-  }
-  mTree = (TTree*)mFile->Get("o2sim");
-  if (!mTree) {
-    LOG(error) << "TrivialVertexer::openInputFile() : "
-               << "Cannot get the input tree !";
-    return kFALSE;
-  }
-  Int_t rc = mTree->SetBranchAddress("MCEventHeader.", &mHeader);
-  if (rc != 0) {
-    LOG(error) << "TrivialVertexer::openInputFile() : "
-               << "Cannot get the input branch ! rc=" << rc;
-    return kFALSE;
-  }
-  return kTRUE;
-}
-
-void TrivialVertexer::process(const std::vector<CompCluster>& clusters, std::vector<std::array<Double_t, 3>>& vertices)
-{
-  if (mClsLabels == nullptr) {
-    LOG(info) << "TrivialVertexer::process() : "
-              << "No cluster labels available ! Running with a default MC vertex...";
-    vertices.emplace_back(std::array<Double_t, 3>{0., 0., 0.});
-    return;
-  }
-
-  if (mTree == nullptr) {
-    LOG(info) << "TrivialVertexer::process() : "
-              << "No MC information available ! Running with a default MC vertex...";
-    vertices.emplace_back(std::array<Double_t, 3>{0., 0., 0.});
-    return;
-  }
-
-  Int_t lastEventID = 0;
-  Int_t firstEventID = std::numeric_limits<Int_t>::max();
-
-  // Find the first and last MC event within this TF
-  for (Int_t i = 0; i < clusters.size(); ++i) {
-    auto mclab = (mClsLabels->getLabels(i))[0];
-    if (mclab.getTrackID() == -1)
-      continue; // noise
-    auto id = mclab.getEventID();
-    if (id < firstEventID)
-      firstEventID = id;
-    if (id > lastEventID)
-      lastEventID = id;
-  }
-
-  for (Int_t mcEv = firstEventID; mcEv <= lastEventID; ++mcEv) {
-    mTree->GetEvent(mcEv);
-    Double_t vx = mHeader->GetX();
-    Double_t vy = mHeader->GetY();
-    Double_t vz = mHeader->GetZ();
-    vertices.emplace_back(std::array<Double_t, 3>{vx, vy, vz});
-    LOG(info) << "TrivialVertexer::process() : "
-              << "MC event #" << mcEv << " with vertex (" << vx << ',' << vy << ',' << vz << ')';
-  }
-}
diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index 001ee537f50d2..8d8304d16764f 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -14,15 +14,15 @@ o2_add_library(ITStracking
                SOURCES src/ClusterLines.cxx
                        src/Cluster.cxx
                        src/Configuration.cxx
+                       src/FastMultEstConfig.cxx
+                       src/FastMultEst.cxx
                        src/TimeFrame.cxx
                        src/IOUtils.cxx
                        src/Tracker.cxx
                        src/TrackerTraits.cxx
                        src/TrackingConfigParam.cxx
-                       src/ClusterLines.cxx
                        src/Vertexer.cxx
                        src/VertexerTraits.cxx
-                       src/Smoother.cxx
                PUBLIC_LINK_LIBRARIES
                        O2::GPUCommon
                        Microsoft.GSL::GSL
@@ -30,6 +30,7 @@ o2_add_library(ITStracking
                        O2::DataFormatsITSMFT
                        O2::SimulationDataFormat
                        O2::ITSBase
+                       O2::CommonUtils
                        O2::ITSReconstruction
                        O2::ITSMFTReconstruction
                        O2::DataFormatsITS
@@ -50,6 +51,9 @@ o2_target_root_dictionary(ITStracking
                           HEADERS include/ITStracking/ClusterLines.h
                                   include/ITStracking/Tracklet.h
                                   include/ITStracking/Cluster.h
+                                  include/ITStracking/Definitions.h
+                                  include/ITStracking/FastMultEst.h
+                                  include/ITStracking/FastMultEstConfig.h
                                   include/ITStracking/TrackingConfigParam.h
                           LINKDEF src/TrackingLinkDef.h)
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/ClusterLinesGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/ClusterLinesGPU.h
deleted file mode 100644
index 75d75e0f67700..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/ClusterLinesGPU.h
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file ClusterLinesGPU.h
-/// \brief GPU-compliant version of ClusterLines, for the moment separated, might create a common traits for ClusterLines + later specifications for each arch, later.
-
-#ifndef ITSTRACKINGGPU_CLUSTERLINESGPU_H_
-#define ITSTRACKINGGPU_CLUSTERLINESGPU_H_
-
-#include "GPUCommonDef.h"
-#include <cstdint> /// Required to properly compile MathUtils
-#include "ITStracking/ClusterLines.h"
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-
-struct GPUVertex final {
-  GPUhd() GPUVertex() : realVertex{false}
-  {
-  }
-
-  GPUhd() GPUVertex(float x, float y, float z, float eX, float eY, float eZ, int contrib) : xCoord{x},
-                                                                                            yCoord{y},
-                                                                                            zCoord{z},
-                                                                                            errorX{eZ},
-                                                                                            errorY{eY},
-                                                                                            errorZ{eZ},
-                                                                                            contributors{contrib},
-                                                                                            realVertex{true}
-  {
-  }
-  float xCoord;
-  float yCoord;
-  float zCoord;
-  float errorX;
-  float errorY;
-  float errorZ;
-  int contributors;
-  int timeStamp;
-  unsigned char realVertex;
-};
-
-class ClusterLinesGPU final
-{
- public:
-  GPUd() ClusterLinesGPU(const Line& firstLine, const Line& secondLine); // poor man solution to calculate duplets' centroid
-  GPUd() void computeClusterCentroid();
-  GPUdi() float* getVertex() { return mVertex; }
-
- private:
-  float mAMatrix[6];         // AX=B
-  float mBMatrix[3];         // AX=B
-  float mVertexCandidate[3]; // vertex candidate
-  float mWeightMatrix[9];    // weight matrix
-  float mVertex[3];          // cluster centroid position
-};
-
-} // namespace gpu
-} // namespace its
-} // namespace o2
-#endif
\ No newline at end of file
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
deleted file mode 100644
index 4a028bf12eb40..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameChunk.h
+++ /dev/null
@@ -1,148 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-
-#ifndef TRACKINGITSGPU_INCLUDE_TIMEFRAMECHUNKGPU_H
-#define TRACKINGITSGPU_INCLUDE_TIMEFRAMECHUNKGPU_H
-
-#include "ITStracking/Configuration.h"
-#include "ITStracking/TimeFrame.h"
-
-#include "ITStrackingGPU/ClusterLinesGPU.h"
-#include "ITStrackingGPU/Stream.h"
-
-#include <gsl/gsl>
-
-namespace o2::its::gpu
-{
-template <int nLayers>
-struct StaticTrackingParameters {
-  StaticTrackingParameters<nLayers>& operator=(const StaticTrackingParameters<nLayers>& t) = default;
-  void set(const TrackingParameters& pars)
-  {
-    ClusterSharing = pars.ClusterSharing;
-    MinTrackLength = pars.MinTrackLength;
-    NSigmaCut = pars.NSigmaCut;
-    PVres = pars.PVres;
-    DeltaROF = pars.DeltaROF;
-    ZBins = pars.ZBins;
-    PhiBins = pars.PhiBins;
-    CellDeltaTanLambdaSigma = pars.CellDeltaTanLambdaSigma;
-  }
-
-  /// General parameters
-  int ClusterSharing = 0;
-  int MinTrackLength = nLayers;
-  float NSigmaCut = 5;
-  float PVres = 1.e-2f;
-  int DeltaROF = 0;
-  int ZBins{256};
-  int PhiBins{128};
-
-  /// Cell finding cuts
-  float CellDeltaTanLambdaSigma = 0.007f;
-};
-
-template <int nLayers>
-class GpuTimeFrameChunk
-{
- public:
-  static size_t computeScalingSizeBytes(const int, const TimeFrameGPUParameters&);
-  static size_t computeFixedSizeBytes(const TimeFrameGPUParameters&);
-  static size_t computeRofPerChunk(const TimeFrameGPUParameters&, const size_t);
-
-  GpuTimeFrameChunk() = delete;
-  GpuTimeFrameChunk(o2::its::TimeFrame* tf, TimeFrameGPUParameters& conf)
-  {
-    mTimeFramePtr = tf;
-    mTFGPUParams = &conf;
-  }
-  ~GpuTimeFrameChunk();
-
-  /// Most relevant operations
-  void allocate(const size_t, Stream&);
-  void reset(const Task, Stream&);
-  size_t loadDataOnDevice(const size_t, const size_t, const int, Stream&);
-
-  /// Interface
-  Cluster* getDeviceClusters(const int);
-  int* getDeviceClusterExternalIndices(const int);
-  int* getDeviceIndexTables(const int);
-  Tracklet* getDeviceTracklets(const int);
-  int* getDeviceTrackletsLookupTables(const int);
-  CellSeed* getDeviceCells(const int);
-  int* getDeviceCellsLookupTables(const int);
-  int* getDeviceRoadsLookupTables(const int);
-  TimeFrameGPUParameters* getTimeFrameGPUParameters() const { return mTFGPUParams; }
-
-  int* getDeviceCUBTmpBuffer() { return mCUBTmpBufferDevice; }
-  int* getDeviceFoundTracklets() { return mFoundTrackletsDevice; }
-  int* getDeviceNFoundCells() { return mNFoundCellsDevice; }
-  int* getDeviceCellNeigboursLookupTables(const int);
-  int* getDeviceCellNeighbours(const int);
-  CellSeed** getDeviceArrayCells() const { return mCellsDeviceArray; }
-  int** getDeviceArrayNeighboursCell() const { return mNeighboursCellDeviceArray; }
-  int** getDeviceArrayNeighboursCellLUT() const { return mNeighboursCellLookupTablesDeviceArray; }
-
-  /// Vertexer only
-  int* getDeviceNTrackletCluster(const int combid) { return mNTrackletsPerClusterDevice[combid]; }
-  Line* getDeviceLines() { return mLinesDevice; };
-  int* getDeviceNFoundLines() { return mNFoundLinesDevice; }
-  int* getDeviceNExclusiveFoundLines() { return mNExclusiveFoundLinesDevice; }
-  unsigned char* getDeviceUsedTracklets() { return mUsedTrackletsDevice; }
-  int* getDeviceClusteredLines() { return mClusteredLinesDevice; }
-  size_t getNPopulatedRof() const { return mNPopulatedRof; }
-
- private:
-  /// Host
-  std::array<gsl::span<const Cluster>, nLayers> mHostClusters;
-  std::array<gsl::span<const int>, nLayers> mHostIndexTables;
-
-  /// Device
-  std::array<Cluster*, nLayers> mClustersDevice;
-  std::array<int*, nLayers> mClusterExternalIndicesDevice;
-  std::array<int*, nLayers> mIndexTablesDevice;
-  std::array<Tracklet*, nLayers - 1> mTrackletsDevice;
-  std::array<int*, nLayers - 1> mTrackletsLookupTablesDevice;
-  std::array<CellSeed*, nLayers - 2> mCellsDevice;
-  // Road<nLayers - 2>* mRoadsDevice;
-  std::array<int*, nLayers - 2> mCellsLookupTablesDevice;
-  std::array<int*, nLayers - 3> mNeighboursCellDevice;
-  std::array<int*, nLayers - 3> mNeighboursCellLookupTablesDevice;
-  std::array<int*, nLayers - 2> mRoadsLookupTablesDevice;
-
-  // These are to make them accessible using layer index
-  CellSeed** mCellsDeviceArray;
-  int** mNeighboursCellDeviceArray;
-  int** mNeighboursCellLookupTablesDeviceArray;
-
-  // Small accessory buffers
-  int* mCUBTmpBufferDevice;
-  int* mFoundTrackletsDevice;
-  int* mNFoundCellsDevice;
-
-  /// Vertexer only
-  Line* mLinesDevice;
-  int* mNFoundLinesDevice;
-  int* mNExclusiveFoundLinesDevice;
-  unsigned char* mUsedTrackletsDevice;
-  std::array<int*, 2> mNTrackletsPerClusterDevice;
-  int* mClusteredLinesDevice;
-
-  /// State and configuration
-  bool mAllocated = false;
-  size_t mNRof = 0;
-  size_t mNPopulatedRof = 0;
-  o2::its::TimeFrame* mTimeFramePtr = nullptr;
-  TimeFrameGPUParameters* mTFGPUParams = nullptr;
-};
-} // namespace o2::its::gpu
-#endif
\ No newline at end of file
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index d6d87eb8c1143..cf1295e08bd76 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -24,40 +24,44 @@
 namespace o2::its::gpu
 {
 
-template <int nLayers = 7>
-class TimeFrameGPU final : public TimeFrame<nLayers>
+template <int NLayers>
+class TimeFrameGPU final : public TimeFrame<NLayers>
 {
-  using typename TimeFrame<nLayers>::CellSeedN;
-  using typename TimeFrame<nLayers>::IndexTableUtilsN;
+  using typename TimeFrame<NLayers>::CellSeedN;
+  using typename TimeFrame<NLayers>::IndexTableUtilsN;
+  using typename TimeFrame<NLayers>::ROFOverlapTableN;
+  using typename TimeFrame<NLayers>::ROFVertexLookupTableN;
+  using typename TimeFrame<NLayers>::ROFMaskTableN;
 
  public:
   TimeFrameGPU() = default;
-  ~TimeFrameGPU() = default;
+  ~TimeFrameGPU() final = default;
 
   /// Most relevant operations
   void pushMemoryStack(const int);
   void popMemoryStack(const int);
   void registerHostMemory(const int);
   void unregisterHostMemory(const int);
-  void initialise(const int, const TrackingParameters&, const int, IndexTableUtilsN* utils = nullptr, const TimeFrameGPUParameters* pars = nullptr);
-  void initDevice(IndexTableUtilsN*, const TrackingParameters& trkParam, const TimeFrameGPUParameters&, const int, const int);
-  void initDeviceSAFitting();
+  void initialise(const int, const TrackingParameters&, const int);
   void loadIndexTableUtils(const int);
   void loadTrackingFrameInfoDevice(const int, const int);
   void createTrackingFrameInfoDeviceArray(const int);
   void loadUnsortedClustersDevice(const int, const int);
-  void createUnsortedClustersDeviceArray(const int, const int = nLayers);
+  void createUnsortedClustersDeviceArray(const int, const int = NLayers);
   void loadClustersDevice(const int, const int);
-  void createClustersDeviceArray(const int, const int = nLayers);
+  void createClustersDeviceArray(const int, const int = NLayers);
   void loadClustersIndexTables(const int, const int);
   void createClustersIndexTablesArray(const int);
   void createUsedClustersDevice(const int, const int);
-  void createUsedClustersDeviceArray(const int, const int = nLayers);
+  void createUsedClustersDeviceArray(const int, const int = NLayers);
   void loadUsedClustersDevice();
   void loadROFrameClustersDevice(const int, const int);
   void createROFrameClustersDeviceArray(const int);
-  void loadMultiplicityCutMask(const int);
+  void loadROFCutMask(const int);
   void loadVertices(const int);
+  void loadROFOverlapTable(const int);
+  void loadROFVertexLookupTable(const int);
+  void updateROFVertexLookupTable(const int);
 
   ///
   void createTrackletsLUTDevice(const int, const int);
@@ -68,7 +72,6 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   void loadCellsLUTDevice();
   void loadTrackSeedsDevice();
   void loadTrackSeedsChi2Device();
-  void loadRoadsDevice();
   void loadTrackSeedsDevice(bounded_vector<CellSeedN>&);
   void createTrackletsBuffers(const int);
   void createTrackletsBuffersArray(const int);
@@ -87,12 +90,6 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
 
-  /// Vertexer
-  void createVtxTrackletsLUTDevice(const int32_t);
-  void createVtxTrackletsBuffers(const int32_t);
-  void createVtxLinesLUTDevice(const int32_t);
-  void createVtxLinesBuffer(const int32_t);
-
   /// synchronization
   auto& getStream(const size_t stream) { return mGpuStreams[stream]; }
   auto& getStreams() { return mGpuStreams; }
@@ -100,7 +97,7 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   void syncStreams(const bool = true);
   void waitEvent(const int, const int);
   void recordEvent(const int);
-  void recordEvents(const int = 0, const int = nLayers);
+  void recordEvents(const int = 0, const int = NLayers);
 
   /// cleanup
   virtual void wipe() final;
@@ -108,8 +105,10 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   /// interface
   virtual bool isGPU() const noexcept final { return true; }
   virtual const char* getName() const noexcept { return "GPU"; }
-  int getNClustersInRofSpan(const int, const int, const int) const;
   IndexTableUtilsN* getDeviceIndexTableUtils() { return mIndexTableUtilsDevice; }
+  const auto getDeviceROFOverlapTableView() { return mDeviceROFOverlapTableView; }
+  const auto getDeviceROFVertexLookupTableView() { return mDeviceROFVertexLookupTableView; }
+  const auto getDeviceROFMaskTableView() { return mDeviceROFMaskTableView; }
   int* getDeviceROFramesClusters(const int layer) { return mROFramesClustersDevice[layer]; }
   auto& getTrackITSExt() { return mTrackITSExt; }
   Vertex* getDeviceVertices() { return mPrimaryVerticesDevice; }
@@ -118,12 +117,11 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   const o2::base::Propagator* getChainPropagator();
 
   // Hybrid
-  Road<nLayers - 2>* getDeviceRoads() { return mRoadsDevice; }
   TrackITSExt* getDeviceTrackITSExt() { return mTrackITSExtDevice; }
   int* getDeviceNeighboursLUT(const int layer) { return mNeighboursLUTDevice[layer]; }
   gsl::span<int*> getDeviceNeighboursLUTs() { return mNeighboursLUTDevice; }
   gpuPair<int, int>* getDeviceNeighbourPairs(const int layer) { return mNeighbourPairsDevice[layer]; }
-  std::array<int*, nLayers - 2>& getDeviceNeighboursAll() { return mNeighboursDevice; }
+  std::array<int*, NLayers - 2>& getDeviceNeighboursAll() { return mNeighboursDevice; }
   int* getDeviceNeighbours(const int layer) { return mNeighboursDevice[layer]; }
   int** getDeviceNeighboursArray() { return mNeighboursDevice.data(); }
   TrackingFrameInfo* getDeviceTrackingFrameInfo(const int);
@@ -145,28 +143,14 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   o2::track::TrackParCovF** getDeviceArrayTrackSeeds() { return mCellSeedsDeviceArray; }
   float** getDeviceArrayTrackSeedsChi2() { return mCellSeedsChi2DeviceArray; }
   int* getDeviceNeighboursIndexTables(const int layer) { return mNeighboursIndexTablesDevice[layer]; }
-  uint8_t* getDeviceMultCutMask() { return mMultMaskDevice; }
-
-  // Vertexer
-  auto& getDeviceNTrackletsPerROF() const noexcept { return mNTrackletsPerROFDevice; }
-  auto& getDeviceNTrackletsPerCluster() const noexcept { return mNTrackletsPerClusterDevice; }
-  auto& getDeviceNTrackletsPerClusterSum() const noexcept { return mNTrackletsPerClusterSumDevice; }
-  int32_t** getDeviceArrayNTrackletsPerROF() const noexcept { return mNTrackletsPerROFDeviceArray; }
-  int32_t** getDeviceArrayNTrackletsPerCluster() const noexcept { return mNTrackletsPerClusterDeviceArray; }
-  int32_t** getDeviceArrayNTrackletsPerClusterSum() const noexcept { return mNTrackletsPerClusterSumDeviceArray; }
-  uint8_t* getDeviceUsedTracklets() const noexcept { return mUsedTrackletsDevice; }
-  int32_t* getDeviceNLinesPerCluster() const noexcept { return mNLinesPerClusterDevice; }
-  int32_t* getDeviceNLinesPerClusterSum() const noexcept { return mNLinesPerClusterSumDevice; }
-  Line* getDeviceLines() const noexcept { return mLinesDevice; }
-  gsl::span<int*> getDeviceTrackletsPerROFs() { return mNTrackletsPerROFDevice; }
 
   void setDevicePropagator(const o2::base::PropagatorImpl<float>* p) final { this->mPropagatorDevice = p; }
 
   // Host-specific getters
-  gsl::span<int, nLayers - 1> getNTracklets() { return mNTracklets; }
-  gsl::span<int, nLayers - 2> getNCells() { return mNCells; }
+  gsl::span<int, NLayers - 1> getNTracklets() { return mNTracklets; }
+  gsl::span<int, NLayers - 2> getNCells() { return mNCells; }
   auto& getArrayNCells() { return mNCells; }
-  gsl::span<int, nLayers - 3> getNNeighbours() { return mNNeighbours; }
+  gsl::span<int, NLayers - 3> getNNeighbours() { return mNNeighbours; }
   auto& getArrayNNeighbours() { return mNNeighbours; }
 
   // Host-available device getters
@@ -176,98 +160,81 @@ class TimeFrameGPU final : public TimeFrame<nLayers>
   gsl::span<CellSeedN*> getDeviceCells() { return mCellsDevice; }
 
   // Overridden getters
-  int getNumberOfTracklets() const final;
-  int getNumberOfCells() const final;
-  int getNumberOfNeighbours() const final;
+  size_t getNumberOfTracklets() const final;
+  size_t getNumberOfCells() const final;
+  size_t getNumberOfNeighbours() const final;
 
  private:
   void allocMemAsync(void**, size_t, Stream&, bool, int32_t = o2::gpu::GPUMemoryResource::MEMORY_GPU); // Abstract owned and unowned memory allocations on specific stream
   void allocMem(void**, size_t, bool, int32_t = o2::gpu::GPUMemoryResource::MEMORY_GPU);               // Abstract owned and unowned memory allocations on default stream
-  TimeFrameGPUParameters mGpuParams;
 
   // Host-available device buffer sizes
-  std::array<int, nLayers - 1> mNTracklets;
-  std::array<int, nLayers - 2> mNCells;
-  std::array<int, nLayers - 3> mNNeighbours;
+  std::array<int, NLayers - 1> mNTracklets;
+  std::array<int, NLayers - 2> mNCells;
+  std::array<int, NLayers - 3> mNNeighbours;
 
   // Device pointers
   IndexTableUtilsN* mIndexTableUtilsDevice;
+  // device navigation views
+  ROFOverlapTableN::View mDeviceROFOverlapTableView;
+  ROFVertexLookupTableN::View mDeviceROFVertexLookupTableView;
+  ROFMaskTableN::View mDeviceROFMaskTableView;
 
   // Hybrid pref
-  uint8_t* mMultMaskDevice;
   Vertex* mPrimaryVerticesDevice;
   int* mROFramesPVDevice;
-  std::array<Cluster*, nLayers> mClustersDevice;
-  std::array<Cluster*, nLayers> mUnsortedClustersDevice;
-  std::array<int*, nLayers> mClustersIndexTablesDevice;
-  std::array<unsigned char*, nLayers> mUsedClustersDevice;
-  std::array<int*, nLayers> mROFramesClustersDevice;
+  std::array<Cluster*, NLayers> mClustersDevice;
+  std::array<Cluster*, NLayers> mUnsortedClustersDevice;
+  std::array<int*, NLayers> mClustersIndexTablesDevice;
+  std::array<unsigned char*, NLayers> mUsedClustersDevice;
+  std::array<int*, NLayers> mROFramesClustersDevice;
   const Cluster** mClustersDeviceArray;
   const Cluster** mUnsortedClustersDeviceArray;
   const int** mClustersIndexTablesDeviceArray;
   uint8_t** mUsedClustersDeviceArray;
   const int** mROFramesClustersDeviceArray;
-  std::array<Tracklet*, nLayers - 1> mTrackletsDevice;
-  std::array<int*, nLayers - 1> mTrackletsLUTDevice;
-  std::array<int*, nLayers - 2> mCellsLUTDevice;
-  std::array<int*, nLayers - 3> mNeighboursLUTDevice;
+  std::array<Tracklet*, NLayers - 1> mTrackletsDevice;
+  std::array<int*, NLayers - 1> mTrackletsLUTDevice;
+  std::array<int*, NLayers - 2> mCellsLUTDevice;
+  std::array<int*, NLayers - 3> mNeighboursLUTDevice;
 
   Tracklet** mTrackletsDeviceArray{nullptr};
   int** mCellsLUTDeviceArray{nullptr};
   int** mNeighboursCellDeviceArray{nullptr};
   int** mNeighboursCellLUTDeviceArray{nullptr};
   int** mTrackletsLUTDeviceArray{nullptr};
-  std::array<CellSeedN*, nLayers - 2> mCellsDevice;
+  std::array<CellSeedN*, NLayers - 2> mCellsDevice;
   CellSeedN** mCellsDeviceArray;
-  std::array<int*, nLayers - 3> mNeighboursIndexTablesDevice;
+  std::array<int*, NLayers - 3> mNeighboursIndexTablesDevice;
   CellSeedN* mTrackSeedsDevice{nullptr};
   int* mTrackSeedsLUTDevice{nullptr};
   unsigned int mNTracks{0};
-  std::array<o2::track::TrackParCovF*, nLayers - 2> mCellSeedsDevice;
+  std::array<o2::track::TrackParCovF*, NLayers - 2> mCellSeedsDevice;
   o2::track::TrackParCovF** mCellSeedsDeviceArray;
-  std::array<float*, nLayers - 2> mCellSeedsChi2Device;
+  std::array<float*, NLayers - 2> mCellSeedsChi2Device;
   float** mCellSeedsChi2DeviceArray;
 
-  Road<nLayers - 2>* mRoadsDevice;
   TrackITSExt* mTrackITSExtDevice;
-  std::array<gpuPair<int, int>*, nLayers - 2> mNeighbourPairsDevice;
-  std::array<int*, nLayers - 2> mNeighboursDevice;
-  std::array<TrackingFrameInfo*, nLayers> mTrackingFrameInfoDevice;
+  std::array<gpuPair<int, int>*, NLayers - 2> mNeighbourPairsDevice;
+  std::array<int*, NLayers - 2> mNeighboursDevice;
+  std::array<TrackingFrameInfo*, NLayers> mTrackingFrameInfoDevice;
   const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
-  /// Vertexer
-  std::array<int32_t*, 2> mNTrackletsPerROFDevice;
-  std::array<int32_t*, 2> mNTrackletsPerClusterDevice;
-  std::array<int32_t*, 2> mNTrackletsPerClusterSumDevice;
-  uint8_t* mUsedTrackletsDevice;
-  int32_t* mNLinesPerClusterDevice;
-  int32_t* mNLinesPerClusterSumDevice;
-  int32_t** mNTrackletsPerROFDeviceArray;
-  int32_t** mNTrackletsPerClusterDeviceArray;
-  int32_t** mNTrackletsPerClusterSumDeviceArray;
-  Line* mLinesDevice;
-
   // State
   Streams mGpuStreams;
-  std::bitset<nLayers + 1> mPinnedUnsortedClusters{0};
-  std::bitset<nLayers + 1> mPinnedClusters{0};
-  std::bitset<nLayers + 1> mPinnedClustersIndexTables{0};
-  std::bitset<nLayers + 1> mPinnedUsedClusters{0};
-  std::bitset<nLayers + 1> mPinnedROFramesClusters{0};
-  std::bitset<nLayers + 1> mPinnedTrackingFrameInfo{0};
+  std::bitset<NLayers + 1> mPinnedUnsortedClusters{0};
+  std::bitset<NLayers + 1> mPinnedClusters{0};
+  std::bitset<NLayers + 1> mPinnedClustersIndexTables{0};
+  std::bitset<NLayers + 1> mPinnedUsedClusters{0};
+  std::bitset<NLayers + 1> mPinnedROFramesClusters{0};
+  std::bitset<NLayers + 1> mPinnedTrackingFrameInfo{0};
 
   // Temporary buffer for storing output tracks from GPU tracking
   bounded_vector<TrackITSExt> mTrackITSExt;
 };
 
-template <int nLayers>
-inline int TimeFrameGPU<nLayers>::getNClustersInRofSpan(const int rofIdstart, const int rofSpanSize, const int layerId) const
-{
-  return static_cast<int>(this->mROFramesClusters[layerId][(rofIdstart + rofSpanSize) < this->mROFramesClusters.size() ? rofIdstart + rofSpanSize : this->mROFramesClusters.size() - 1] - this->mROFramesClusters[layerId][rofIdstart]);
-}
-
-template <int nLayers>
-inline std::vector<unsigned int> TimeFrameGPU<nLayers>::getClusterSizes()
+template <int NLayers>
+inline std::vector<unsigned int> TimeFrameGPU<NLayers>::getClusterSizes()
 {
   std::vector<unsigned int> sizes(this->mUnsortedClusters.size());
   std::transform(this->mUnsortedClusters.begin(), this->mUnsortedClusters.end(), sizes.begin(),
@@ -275,20 +242,20 @@ inline std::vector<unsigned int> TimeFrameGPU<nLayers>::getClusterSizes()
   return sizes;
 }
 
-template <int nLayers>
-inline int TimeFrameGPU<nLayers>::getNumberOfTracklets() const
+template <int NLayers>
+inline size_t TimeFrameGPU<NLayers>::getNumberOfTracklets() const
 {
   return std::accumulate(mNTracklets.begin(), mNTracklets.end(), 0);
 }
 
-template <int nLayers>
-inline int TimeFrameGPU<nLayers>::getNumberOfCells() const
+template <int NLayers>
+inline size_t TimeFrameGPU<NLayers>::getNumberOfCells() const
 {
   return std::accumulate(mNCells.begin(), mNCells.end(), 0);
 }
 
-template <int nLayers>
-inline int TimeFrameGPU<nLayers>::getNumberOfNeighbours() const
+template <int NLayers>
+inline size_t TimeFrameGPU<NLayers>::getNumberOfNeighbours() const
 {
   return std::accumulate(mNNeighbours.begin(), mNNeighbours.end(), 0);
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TracerGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TracerGPU.h
deleted file mode 100644
index e2bd7266caff9..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TracerGPU.h
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-#include "ITStracking/Definitions.h"
-
-#ifndef TRACKINGITSGPU_INCLUDE_TRACER_H
-#define TRACKINGITSGPU_INCLUDE_TRACER_H
-
-#if defined(__CUDACC__) && defined(__USE_GPU_TRACER__)
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-class Tracer
-{
- public:
-  Tracer(const char* name, int color_id = 0);
-  ~Tracer();
-};
-} // namespace gpu
-} // namespace its
-} // namespace o2
-#define RANGE(name, cid) o2::its::gpu::Tracer tracer(name, cid);
-#else
-#define RANGE(name, cid)
-#endif
-
-#endif // TRACKINGITSGPU_INCLUDE_TRACER_H
\ No newline at end of file
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
index 7d26e74692aa5..38d2a8ad5ddc2 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
@@ -19,26 +19,23 @@
 namespace o2::its
 {
 
-template <int nLayers = 7>
-class TrackerTraitsGPU final : public TrackerTraits<nLayers>
+template <int NLayers = 7>
+class TrackerTraitsGPU final : public TrackerTraits<NLayers>
 {
-  using typename TrackerTraits<nLayers>::IndexTableUtilsN;
+  using typename TrackerTraits<NLayers>::IndexTableUtilsN;
 
  public:
   TrackerTraitsGPU() = default;
   ~TrackerTraitsGPU() final = default;
 
-  void adoptTimeFrame(TimeFrame<nLayers>* tf) final;
+  void adoptTimeFrame(TimeFrame<NLayers>* tf) final;
   void initialiseTimeFrame(const int iteration) final;
 
-  void computeLayerTracklets(const int iteration, int, int) final;
+  void computeLayerTracklets(const int iteration, int) final;
   void computeLayerCells(const int iteration) final;
   void findCellsNeighbours(const int iteration) final;
   void findRoads(const int iteration) final;
 
-  bool supportsExtendTracks() const noexcept final { return false; }
-  bool supportsFindShortPrimaries() const noexcept final { return false; }
-
   void setBz(float) final;
 
   const char* getName() const noexcept final { return "GPU"; }
@@ -51,7 +48,7 @@ class TrackerTraitsGPU final : public TrackerTraits<nLayers>
 
  private:
   IndexTableUtilsN* mDeviceIndexTableUtils;
-  gpu::TimeFrameGPU<nLayers>* mTimeFrameGPU;
+  gpu::TimeFrameGPU<NLayers>* mTimeFrameGPU;
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 53992ccf3eb85..a83d9d0d52e8f 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -16,6 +16,7 @@
 #include <gsl/gsl>
 
 #include "ITStracking/BoundedAllocator.h"
+#include "ITStracking/ROFLookupTables.h"
 #include "ITStracking/Definitions.h"
 #include "ITStrackingGPU/Utils.h"
 #include "DetectorsBase/Propagator.h"
@@ -33,18 +34,15 @@ class Cluster;
 class TrackITSExt;
 class ExternalAllocator;
 
-template <int nLayers = 7>
-void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
-                                 const uint8_t* multMask,
+template <int NLayers = 7>
+void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
+                                 const typename ROFMaskTable<NLayers>::View& rofMask,
                                  const int layer,
-                                 const int startROF,
-                                 const int endROF,
-                                 const int maxROF,
-                                 const int deltaROF,
+                                 const typename ROFOverlapTable<NLayers>::View& rofOverlaps,
+                                 const typename ROFVertexLookupTable<NLayers>::View& vertexLUT,
                                  const int vertexId,
                                  const Vertex* vertices,
                                  const int* rofPV,
-                                 const int nVertices,
                                  const Cluster** clusters,
                                  std::vector<unsigned int> nClusters,
                                  const int** ROFClusters,
@@ -56,8 +54,8 @@ void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                  const float NSigmaCut,
                                  bounded_vector<float>& phiCuts,
                                  const float resolutionPV,
-                                 std::array<float, nLayers>& minR,
-                                 std::array<float, nLayers>& maxR,
+                                 std::array<float, NLayers>& minR,
+                                 std::array<float, NLayers>& maxR,
                                  bounded_vector<float>& resolutions,
                                  std::vector<float>& radii,
                                  bounded_vector<float>& mulScatAng,
@@ -66,18 +64,15 @@ void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                  const int nThreads,
                                  gpu::Streams& streams);
 
-template <int nLayers = 7>
-void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
-                                   const uint8_t* multMask,
+template <int NLayers = 7>
+void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
+                                   const typename ROFMaskTable<NLayers>::View& rofMask,
                                    const int layer,
-                                   const int startROF,
-                                   const int endROF,
-                                   const int maxROF,
-                                   const int deltaROF,
+                                   const typename ROFOverlapTable<NLayers>::View& rofOverlaps,
+                                   const typename ROFVertexLookupTable<NLayers>::View& vertexLUT,
                                    const int vertexId,
                                    const Vertex* vertices,
                                    const int* rofPV,
-                                   const int nVertices,
                                    const Cluster** clusters,
                                    std::vector<unsigned int> nClusters,
                                    const int** ROFClusters,
@@ -92,8 +87,8 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                    const float NSigmaCut,
                                    bounded_vector<float>& phiCuts,
                                    const float resolutionPV,
-                                   std::array<float, nLayers>& minR,
-                                   std::array<float, nLayers>& maxR,
+                                   std::array<float, NLayers>& minR,
+                                   std::array<float, NLayers>& maxR,
                                    bounded_vector<float>& resolutions,
                                    std::vector<float>& radii,
                                    bounded_vector<float>& mulScatAng,
@@ -102,7 +97,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                    const int nThreads,
                                    gpu::Streams& streams);
 
-template <int nLayers>
+template <int NLayers>
 void countCellsHandler(const Cluster** sortedClusters,
                        const Cluster** unsortedClusters,
                        const TrackingFrameInfo** tfInfo,
@@ -110,10 +105,9 @@ void countCellsHandler(const Cluster** sortedClusters,
                        int** trackletsLUT,
                        const int nTracklets,
                        const int layer,
-                       CellSeed<nLayers>* cells,
+                       CellSeed<NLayers>* cells,
                        int** cellsLUTsDeviceArray,
                        int* cellsLUTsHost,
-                       const int deltaROF,
                        const float bz,
                        const float maxChi2ClusterAttachment,
                        const float cellDeltaTanLambdaSigma,
@@ -123,7 +117,7 @@ void countCellsHandler(const Cluster** sortedClusters,
                        const int nThreads,
                        gpu::Streams& streams);
 
-template <int nLayers>
+template <int NLayers>
 void computeCellsHandler(const Cluster** sortedClusters,
                          const Cluster** unsortedClusters,
                          const TrackingFrameInfo** tfInfo,
@@ -131,10 +125,9 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          int** trackletsLUT,
                          const int nTracklets,
                          const int layer,
-                         CellSeed<nLayers>* cells,
+                         CellSeed<NLayers>* cells,
                          int** cellsLUTsDeviceArray,
                          int* cellsLUTsHost,
-                         const int deltaROF,
                          const float bz,
                          const float maxChi2ClusterAttachment,
                          const float cellDeltaTanLambdaSigma,
@@ -143,14 +136,13 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          const int nThreads,
                          gpu::Streams& streams);
 
-template <int nLayers>
-void countCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
+template <int NLayers>
+void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                 int* neighboursLUTs,
                                 int** cellsLUTs,
                                 gpuPair<int, int>* cellNeighbours,
                                 int* neighboursIndexTable,
                                 const Tracklet** tracklets,
-                                const int deltaROF,
                                 const float maxChi2ClusterAttachment,
                                 const float bz,
                                 const int layerIndex,
@@ -162,14 +154,13 @@ void countCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
                                 const int nThreads,
                                 gpu::Stream& stream);
 
-template <int nLayers>
-void computeCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
+template <int NLayers>
+void computeCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                   int* neighboursLUTs,
                                   int** cellsLUTs,
                                   gpuPair<int, int>* cellNeighbours,
                                   int* neighboursIndexTable,
                                   const Tracklet** tracklets,
-                                  const int deltaROF,
                                   const float maxChi2ClusterAttachment,
                                   const float bz,
                                   const int layerIndex,
@@ -186,17 +177,17 @@ int filterCellNeighboursHandler(gpuPair<int, int>*,
                                 gpu::Stream&,
                                 o2::its::ExternalAllocator* = nullptr);
 
-template <int nLayers = 7>
+template <int NLayers = 7>
 void processNeighboursHandler(const int startLayer,
                               const int startLevel,
-                              CellSeed<nLayers>** allCellSeeds,
-                              CellSeed<nLayers>* currentCellSeeds,
-                              std::array<int, nLayers - 2>& nCells,
+                              CellSeed<NLayers>** allCellSeeds,
+                              CellSeed<NLayers>* currentCellSeeds,
+                              std::array<int, NLayers - 2>& nCells,
                               const unsigned char** usedClusters,
-                              std::array<int*, nLayers - 2>& neighbours,
+                              std::array<int*, NLayers - 2>& neighbours,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                              bounded_vector<CellSeed<nLayers>>& seedsHost,
+                              bounded_vector<CellSeed<NLayers>>& seedsHost,
                               const float bz,
                               const float MaxChi2ClusterAttachment,
                               const float maxChi2NDF,
@@ -206,8 +197,8 @@ void processNeighboursHandler(const int startLayer,
                               const int nBlocks,
                               const int nThreads);
 
-template <int nLayers = 7>
-void countTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
+template <int NLayers = 7>
+void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                            const TrackingFrameInfo** foundTrackingFrameInfo,
                            const Cluster** unsortedClusters,
                            int* seedLUT,
@@ -227,8 +218,8 @@ void countTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
                            const int nBlocks,
                            const int nThreads);
 
-template <int nLayers = 7>
-void computeTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
+template <int NLayers = 7>
+void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                              const TrackingFrameInfo** foundTrackingFrameInfo,
                              const Cluster** unsortedClusters,
                              o2::its::TrackITSExt* tracks,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index ee0a203f32fda..44cd8d7e7492b 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -38,7 +38,11 @@
 #endif
 
 #ifdef ITS_GPU_LOG
-#define GPULog(...) LOGP(info, __VA_ARGS__)
+#define GPULog(...)                      \
+  do {                                   \
+    LOGP(info, __VA_ARGS__);             \
+    GPUChkErrS(cudaDeviceSynchronize()); \
+  } while (0)
 #else
 #define GPULog(...)
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
deleted file mode 100644
index dddc247466c65..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexerTraitsGPU.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file VertexerTraitsGPU.h
-/// \brief
-/// \author matteo.concas@cern.ch
-
-// #define VTX_DEBUG
-#ifndef ITSTRACKINGGPU_VERTEXERTRAITSGPU_H_
-#define ITSTRACKINGGPU_VERTEXERTRAITSGPU_H_
-
-#include <vector>
-
-#include "ITStracking/VertexerTraits.h"
-#include "ITStracking/Configuration.h"
-#include "ITStracking/Cluster.h"
-#include "ITStracking/Constants.h"
-#include "ITStracking/Definitions.h"
-#include "ITStracking/Tracklet.h"
-
-#include "ITStrackingGPU/TimeFrameGPU.h"
-
-namespace o2::its
-{
-
-template <int nLayers>
-class VertexerTraitsGPU final : public VertexerTraits<nLayers>
-{
- public:
-  void initialise(const TrackingParameters&, const int iteration = 0) final;
-  void adoptTimeFrame(TimeFrame<nLayers>* tf) noexcept final;
-  void computeTracklets(const int iteration = 0) final;
-  void computeTrackletMatching(const int iteration = 0) final;
-  void computeVertices(const int iteration = 0) final;
-  void updateVertexingParameters(const std::vector<VertexingParameters>&, const TimeFrameGPUParameters&) final;
-
-  bool isGPU() const noexcept final { return true; }
-  const char* getName() const noexcept final { return "GPU"; }
-
- protected:
-  gpu::TimeFrameGPU<nLayers>* mTimeFrameGPU;
-  TimeFrameGPUParameters mTfGPUParams;
-};
-
-} // namespace o2::its
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
deleted file mode 100644
index 67f12bad8486c..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-
-#ifndef ITSTRACKINGGPU_VERTEXINGKERNELS_H_
-#define ITSTRACKINGGPU_VERTEXINGKERNELS_H_
-
-#include <cstdint>
-#include <gsl/span>
-#include <array>
-#include "ITStracking/Tracklet.h"
-#include "ITStracking/Cluster.h"
-#include "ITStracking/ClusterLines.h"
-#include "ITStrackingGPU/Utils.h"
-
-namespace o2::its
-{
-
-/// Trackleting
-template <int32_t nLayers>
-void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* GPUrestrict() utils,
-                                 const uint8_t* GPUrestrict() multMask,
-                                 const int32_t nRofs,
-                                 const int32_t deltaROF,
-                                 const int32_t* GPUrestrict() rofPV,
-                                 const int32_t vertPerRofThreshold,
-                                 const Cluster** GPUrestrict() clusters,
-                                 const uint32_t nClusters,
-                                 const int32_t** GPUrestrict() ROFClusters,
-                                 const uint8_t** GPUrestrict() usedClusters,
-                                 const int32_t** GPUrestrict() clustersIndexTables,
-                                 int32_t** trackletsPerClusterLUTs,
-                                 int32_t** trackletsPerClusterSumLUTs,
-                                 int32_t** trackletsPerROF,
-                                 const std::array<int32_t*, 2>& trackletsPerClusterLUTsHost,
-                                 const std::array<int32_t*, 2>& trackletsPerClusterSumLUTsHost,
-                                 const int32_t iteration,
-                                 const float phiCut,
-                                 const int32_t maxTrackletsPerCluster,
-                                 const int32_t nBlocks,
-                                 const int32_t nThreads,
-                                 gpu::Streams& streams);
-
-template <int32_t nLayers>
-void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* GPUrestrict() utils,
-                                   const uint8_t* GPUrestrict() multMask,
-                                   const int32_t nRofs,
-                                   const int32_t deltaROF,
-                                   const int32_t* GPUrestrict() rofPV,
-                                   const int vertPerRofThreshold,
-                                   const Cluster** GPUrestrict() clusters,
-                                   const uint32_t nClusters,
-                                   const int32_t** GPUrestrict() ROFClusters,
-                                   const uint8_t** GPUrestrict() usedClusters,
-                                   const int32_t** GPUrestrict() clustersIndexTables,
-                                   Tracklet** GPUrestrict() foundTracklets,
-                                   const int32_t** GPUrestrict() trackletsPerClusterLUTs,
-                                   const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
-                                   const int32_t** GPUrestrict() trackletsPerROF,
-                                   const int32_t iteration,
-                                   const float phiCut,
-                                   const int32_t maxTrackletsPerCluster,
-                                   const int32_t nBlocks,
-                                   const int32_t nThreads,
-                                   gpu::Streams& streams);
-
-/// Selection
-void countTrackletsMatchingInROFsHandler(const int32_t nRofs,
-                                         const int32_t deltaROF,
-                                         const uint32_t nClusters,
-                                         const int32_t** GPUrestrict() ROFClusters,
-                                         const Cluster** GPUrestrict() clusters,
-                                         uint8_t** GPUrestrict() usedClusters,
-                                         const Tracklet** GPUrestrict() foundTracklets,
-                                         uint8_t* GPUrestrict() usedTracklets,
-                                         const int32_t** GPUrestrict() trackletsPerClusterLUTs,
-                                         const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
-                                         int32_t* GPUrestrict() linesPerClusterLUT,
-                                         int32_t* GPUrestrict() linesPerClusterSumLUT,
-                                         const int32_t iteration,
-                                         const float phiCut,
-                                         const float tanLambdaCut,
-                                         const int32_t nBlocks,
-                                         const int32_t nThreads,
-                                         gpu::Streams& streams);
-
-void computeTrackletsMatchingInROFsHandler(const int32_t nRofs,
-                                           const int32_t deltaROF,
-                                           const uint32_t nClusters,
-                                           const int32_t** GPUrestrict() ROFClusters,
-                                           const Cluster** GPUrestrict() clusters,
-                                           const uint8_t** GPUrestrict() usedClusters,
-                                           const Tracklet** GPUrestrict() foundTracklets,
-                                           uint8_t* GPUrestrict() usedTracklets,
-                                           const int32_t** GPUrestrict() trackletsPerClusterLUTs,
-                                           const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
-                                           const int32_t* GPUrestrict() linesPerClusterSumLUT,
-                                           Line* GPUrestrict() lines,
-                                           const int32_t iteration,
-                                           const float phiCut,
-                                           const float tanLambdaCut,
-                                           const int32_t nBlocks,
-                                           const int32_t nThreads,
-                                           gpu::Streams& streams);
-
-} // namespace o2::its
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
index e38dbb1ef20e8..38f11265682ce 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/CMakeLists.txt
@@ -13,19 +13,13 @@
 if(CUDA_ENABLED)
     find_package(CUDAToolkit)
     message(STATUS "Building ITS CUDA tracker")
-    # add_compile_options(-O0 -g -lineinfo -fPIC -DGPU_FORCE_DEVICE_ASSERTS=ON)
-    # add_compile_definitions(ITS_MEASURE_GPU_TIME)
-    # add_compile_definitions(ITS_GPU_LOG)
     o2_add_library(ITStrackingCUDA
-                   SOURCES ClusterLinesGPU.cu
-                           TrackerTraitsGPU.cxx
+                   SOURCES TrackerTraitsGPU.cxx
                            TimeFrameGPU.cu
-                           TracerGPU.cu
                            TrackingKernels.cu
-                           VertexingKernels.cu
-                           VertexerTraitsGPU.cxx
                    PUBLIC_INCLUDE_DIRECTORIES ../
                    PUBLIC_LINK_LIBRARIES O2::ITStracking
+                                         O2::MathUtils
                                          O2::SimConfig
                                          O2::SimulationDataFormat
                                          O2::ReconstructionDataFormats
@@ -33,7 +27,14 @@ if(CUDA_ENABLED)
                    PRIVATE_LINK_LIBRARIES O2::GPUTrackingCUDAExternalProvider
                    TARGETVARNAME targetName)
 
+    set_target_gpu_arch("CUDA" ${targetName})
+    # Enable relocatable device code (needed for separable compilation + debugging)
     set_property(TARGET ${targetName} PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+    target_compile_options(${targetName} PRIVATE
+        $<$<COMPILE_LANGUAGE:CUDA>:-diag-error=20014>
+    #     $<$<COMPILE_LANGUAGE:CUDA>:-G;-O0;-Xptxas=-O0>
+    #     $<$<COMPILE_LANGUAGE:CXX>:-O0;-g>
+    )
+    # target_compile_definitions(${targetName} PRIVATE ITS_MEASURE_GPU_TIME ITS_GPU_LOG)
     target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::ITStracking,COMPILE_DEFINITIONS>)
-    set_target_gpu_arch("CUDA" ${targetName})
 endif()
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/ClusterLinesGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/ClusterLinesGPU.cu
deleted file mode 100644
index 79f4e40dc5f10..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/ClusterLinesGPU.cu
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \author matteo.concas@cern.ch
-
-#include <cuda_runtime.h>
-#include "ITStrackingGPU/ClusterLinesGPU.h"
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-
-GPUd() ClusterLinesGPU::ClusterLinesGPU(const Line& firstLine, const Line& secondLine)
-{
-  float covarianceFirst[3];
-  float covarianceSecond[3];
-
-  for (int i{0}; i < 3; ++i) {
-    covarianceFirst[i] = 1.f;
-    covarianceSecond[i] = 1.f;
-  }
-
-  double determinantFirst =
-    firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[0] * covarianceFirst[1] +
-    firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[0] * covarianceFirst[2] +
-    firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[1] * covarianceFirst[2];
-  double determinantSecond =
-    secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[0] * covarianceSecond[1] +
-    secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[0] * covarianceSecond[2] +
-    secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[1] * covarianceSecond[2];
-
-  mAMatrix[0] = (firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[1] +
-                 firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[2]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[1] +
-                 secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[2]) /
-                  determinantSecond;
-
-  mAMatrix[1] = -firstLine.cosinesDirector[0] * firstLine.cosinesDirector[1] * covarianceFirst[2] / determinantFirst -
-                secondLine.cosinesDirector[0] * secondLine.cosinesDirector[1] * covarianceSecond[2] / determinantSecond;
-
-  mAMatrix[2] = -firstLine.cosinesDirector[0] * firstLine.cosinesDirector[2] * covarianceFirst[1] / determinantFirst -
-                secondLine.cosinesDirector[0] * secondLine.cosinesDirector[2] * covarianceSecond[1] / determinantSecond;
-
-  mAMatrix[3] = (firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[0] +
-                 firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[2]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[0] +
-                 secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[2]) /
-                  determinantSecond;
-
-  mAMatrix[4] = -firstLine.cosinesDirector[1] * firstLine.cosinesDirector[2] * covarianceFirst[0] / determinantFirst -
-                secondLine.cosinesDirector[1] * secondLine.cosinesDirector[2] * covarianceSecond[0] / determinantSecond;
-
-  mAMatrix[5] = (firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[0] +
-                 firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[1]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[0] +
-                 secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[1]) /
-                  determinantSecond;
-
-  mBMatrix[0] =
-    (firstLine.cosinesDirector[1] * covarianceFirst[2] * (-firstLine.cosinesDirector[1] * firstLine.originPoint[0] + firstLine.cosinesDirector[0] * firstLine.originPoint[1]) +
-     firstLine.cosinesDirector[2] * covarianceFirst[1] * (-firstLine.cosinesDirector[2] * firstLine.originPoint[0] + firstLine.cosinesDirector[0] * firstLine.originPoint[2])) /
-    determinantFirst;
-
-  mBMatrix[0] +=
-    (secondLine.cosinesDirector[1] * covarianceSecond[2] * (-secondLine.cosinesDirector[1] * secondLine.originPoint[0] + secondLine.cosinesDirector[0] * secondLine.originPoint[1]) +
-     secondLine.cosinesDirector[2] * covarianceSecond[1] *
-       (-secondLine.cosinesDirector[2] * secondLine.originPoint[0] +
-        secondLine.cosinesDirector[0] * secondLine.originPoint[2])) /
-    determinantSecond;
-
-  mBMatrix[1] =
-    (firstLine.cosinesDirector[0] * covarianceFirst[2] * (-firstLine.cosinesDirector[0] * firstLine.originPoint[1] + firstLine.cosinesDirector[1] * firstLine.originPoint[0]) +
-     firstLine.cosinesDirector[2] * covarianceFirst[0] * (-firstLine.cosinesDirector[2] * firstLine.originPoint[1] + firstLine.cosinesDirector[1] * firstLine.originPoint[2])) /
-    determinantFirst;
-
-  mBMatrix[1] +=
-    (secondLine.cosinesDirector[0] * covarianceSecond[2] * (-secondLine.cosinesDirector[0] * secondLine.originPoint[1] + secondLine.cosinesDirector[1] * secondLine.originPoint[0]) +
-     secondLine.cosinesDirector[2] * covarianceSecond[0] *
-       (-secondLine.cosinesDirector[2] * secondLine.originPoint[1] +
-        secondLine.cosinesDirector[1] * secondLine.originPoint[2])) /
-    determinantSecond;
-
-  mBMatrix[2] =
-    (firstLine.cosinesDirector[0] * covarianceFirst[1] * (-firstLine.cosinesDirector[0] * firstLine.originPoint[2] + firstLine.cosinesDirector[2] * firstLine.originPoint[0]) +
-     firstLine.cosinesDirector[1] * covarianceFirst[0] * (-firstLine.cosinesDirector[1] * firstLine.originPoint[2] + firstLine.cosinesDirector[2] * firstLine.originPoint[1])) /
-    determinantFirst;
-
-  mBMatrix[2] +=
-    (secondLine.cosinesDirector[0] * covarianceSecond[1] * (-secondLine.cosinesDirector[0] * secondLine.originPoint[2] + secondLine.cosinesDirector[2] * secondLine.originPoint[0]) +
-     secondLine.cosinesDirector[1] * covarianceSecond[0] *
-       (-secondLine.cosinesDirector[1] * secondLine.originPoint[2] +
-        secondLine.cosinesDirector[2] * secondLine.originPoint[1])) /
-    determinantSecond;
-
-  computeClusterCentroid();
-}
-
-GPUd() void ClusterLinesGPU::computeClusterCentroid()
-{
-
-  double determinant{mAMatrix[0] * (mAMatrix[3] * mAMatrix[5] - mAMatrix[4] * mAMatrix[4]) -
-                     mAMatrix[1] * (mAMatrix[1] * mAMatrix[5] - mAMatrix[4] * mAMatrix[2]) +
-                     mAMatrix[2] * (mAMatrix[1] * mAMatrix[4] - mAMatrix[2] * mAMatrix[3])};
-
-  if (determinant == 0) {
-    return;
-  }
-
-  mVertex[0] = -(mBMatrix[0] * (mAMatrix[3] * mAMatrix[5] - mAMatrix[4] * mAMatrix[4]) -
-                 mAMatrix[1] * (mBMatrix[1] * mAMatrix[5] - mAMatrix[4] * mBMatrix[2]) +
-                 mAMatrix[2] * (mBMatrix[1] * mAMatrix[4] - mBMatrix[2] * mAMatrix[3])) /
-               determinant;
-  mVertex[1] = -(mAMatrix[0] * (mBMatrix[1] * mAMatrix[5] - mBMatrix[2] * mAMatrix[4]) -
-                 mBMatrix[0] * (mAMatrix[1] * mAMatrix[5] - mAMatrix[4] * mAMatrix[2]) +
-                 mAMatrix[2] * (mAMatrix[1] * mBMatrix[2] - mAMatrix[2] * mBMatrix[1])) /
-               determinant;
-  mVertex[2] = -(mAMatrix[0] * (mAMatrix[3] * mBMatrix[2] - mBMatrix[1] * mAMatrix[4]) -
-                 mAMatrix[1] * (mAMatrix[1] * mBMatrix[2] - mBMatrix[1] * mAMatrix[2]) +
-                 mBMatrix[0] * (mAMatrix[1] * mAMatrix[4] - mAMatrix[2] * mAMatrix[3])) /
-               determinant;
-}
-} // namespace gpu
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameChunk.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameChunk.cu
deleted file mode 100644
index c8512e667aea8..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameChunk.cu
+++ /dev/null
@@ -1,293 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include <cuda_runtime.h>
-#include <thrust/fill.h>
-#include <thrust/execution_policy.h>
-
-#include "ITStracking/Constants.h"
-
-#include "ITStrackingGPU/Utils.h"
-#include "ITStrackingGPU/TracerGPU.h"
-
-#include "ITStrackingGPU/TimeFrameChunk.h"
-
-#include <unistd.h>
-#include <thread>
-
-#include "GPUCommonDef.h"
-#include "GPUCommonMath.h"
-#include "GPUCommonLogger.h"
-#include "GPUCommonHelpers.h"
-
-#ifndef __HIPCC__
-#define THRUST_NAMESPACE thrust::cuda
-#else
-#define THRUST_NAMESPACE thrust::hip
-#endif
-
-namespace o2::its
-{
-using constants::GB;
-using constants::MB;
-namespace gpu
-{
-
-template <int nLayers>
-GpuTimeFrameChunk<nLayers>::~GpuTimeFrameChunk()
-{
-  if (mAllocated) {
-    for (int i = 0; i < nLayers; ++i) {
-      GPUChkErrS(cudaFree(mClustersDevice[i]));
-      // GPUChkErrS(cudaFree(mTrackingFrameInfoDevice[i]));
-      GPUChkErrS(cudaFree(mClusterExternalIndicesDevice[i]));
-      GPUChkErrS(cudaFree(mIndexTablesDevice[i]));
-      if (i < nLayers - 1) {
-        GPUChkErrS(cudaFree(mTrackletsDevice[i]));
-        GPUChkErrS(cudaFree(mTrackletsLookupTablesDevice[i]));
-        if (i < nLayers - 2) {
-          GPUChkErrS(cudaFree(mCellsDevice[i]));
-          GPUChkErrS(cudaFree(mCellsLookupTablesDevice[i]));
-          GPUChkErrS(cudaFree(mRoadsLookupTablesDevice[i]));
-          if (i < nLayers - 3) {
-            GPUChkErrS(cudaFree(mNeighboursCellLookupTablesDevice[i]));
-            GPUChkErrS(cudaFree(mNeighboursCellDevice[i]));
-          }
-        }
-      }
-    }
-    // GPUChkErrS(cudaFree(mRoadsDevice));
-    GPUChkErrS(cudaFree(mCUBTmpBufferDevice));
-    GPUChkErrS(cudaFree(mFoundTrackletsDevice));
-    GPUChkErrS(cudaFree(mNFoundCellsDevice));
-    GPUChkErrS(cudaFree(mCellsDeviceArray));
-    GPUChkErrS(cudaFree(mNeighboursCellDeviceArray));
-    GPUChkErrS(cudaFree(mNeighboursCellLookupTablesDeviceArray));
-  }
-}
-
-template <int nLayers>
-void GpuTimeFrameChunk<nLayers>::allocate(const size_t nrof, Stream& stream)
-{
-  RANGE("device_partition_allocation", 2);
-  mNRof = nrof;
-  // for (int i = 0; i < nLayers; ++i) {
-  //   static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mClustersDevice[i])), sizeof(Cluster) * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  //   // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mTrackingFrameInfoDevice[i])), sizeof(TrackingFrameInfo) * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  //   static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mClusterExternalIndicesDevice[i])), sizeof(int) * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  //   static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mIndexTablesDevice[i])), sizeof(int) * (256 * 128 + 1) * nrof, &stream, true);
-  //   if (i < nLayers - 1) {
-  //     static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mTrackletsLookupTablesDevice[i])), sizeof(int) * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  //     static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mTrackletsDevice[i])), sizeof(Tracklet) * mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  //     if (i < nLayers - 2) {
-  //       static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mCellsLookupTablesDevice[i])), sizeof(int) * mTFGPUParams->validatedTrackletsCapacity * nrof, &stream, true);
-  //       static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mCellsDevice[i])), sizeof(CellSeed) * mTFGPUParams->maxNeighboursSize * nrof, &stream, true);
-  //       static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mRoadsLookupTablesDevice[i]), sizeof(int) * mTFGPUParams->maxNeighboursSize * nrof, &stream, true);
-  //       if (i < nLayers - 3) {
-  //         static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mNeighboursCellLookupTablesDevice[i])), sizeof(int) * mTFGPUParams->maxNeighboursSize * nrof, &stream, true);
-  //         static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mNeighboursCellDevice[i])), sizeof(int) * mTFGPUParams->maxNeighboursSize * nrof, &stream, true);
-  //       }
-  //       if (i < 2) {
-  //         static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&(mNTrackletsPerClusterDevice[i])), sizeof(int) * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  //       }
-  //     }
-  //   }
-  // }
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mCUBTmpBufferDevice), mTFGPUParams->tmpCUBBufferSize * nrof, &stream, true);
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mLinesDevice), sizeof(Line) * mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mNFoundLinesDevice), sizeof(int) * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mNExclusiveFoundLinesDevice), sizeof(int) * mTFGPUParams->clustersPerROfCapacity * nrof + 1, &stream, true); // + 1 for cub::DeviceScan::ExclusiveSum, to cover cases where we have maximum number of clusters per ROF
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mUsedTrackletsDevice), sizeof(unsigned char) * mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * nrof, &stream, true);
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mClusteredLinesDevice), sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mTFGPUParams->maxTrackletsPerCluster * nrof, &stream, true);
-  // // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mRoadsDevice), sizeof(Road<nLayers - 2>) * mTFGPUParams->maxRoadPerRofSize * nrof, &stream, true);
-
-  // /// Invariant allocations
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mFoundTrackletsDevice), (nLayers - 1) * sizeof(int) * nrof, &stream, true); // No need to reset, we always read it after writing
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mNFoundCellsDevice), (nLayers - 2) * sizeof(int) * nrof, &stream, true);
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeed*), &stream, true);
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mNeighboursCellDeviceArray), (nLayers - 3) * sizeof(int*), &stream, true);
-  // static_cast<TimeFrameGPU<nLayers>*>(mTimeFramePtr)->allocMemAsync(reinterpret_cast<void**>(&mNeighboursCellLookupTablesDeviceArray), (nLayers - 3) * sizeof(int*), &stream, true);
-
-  // /// Copy pointers of allocated memory to regrouping arrays
-  // GPUChkErrS(cudaMemcpyAsync(mCellsDeviceArray, mCellsDevice.data(), (nLayers - 2) * sizeof(CellSeed*), cudaMemcpyHostToDevice, stream.get()));
-  // GPUChkErrS(cudaMemcpyAsync(mNeighboursCellDeviceArray, mNeighboursCellDevice.data(), (nLayers - 3) * sizeof(int*), cudaMemcpyHostToDevice, stream.get()));
-  // GPUChkErrS(cudaMemcpyAsync(mNeighboursCellLookupTablesDeviceArray, mNeighboursCellLookupTablesDevice.data(), (nLayers - 3) * sizeof(int*), cudaMemcpyHostToDevice, stream.get()));
-
-  mAllocated = true;
-}
-
-template <int nLayers>
-void GpuTimeFrameChunk<nLayers>::reset(const Task task, Stream& stream)
-{
-  RANGE("buffer_reset", 0);
-  // if ((bool)task) { // Vertexer-only initialisation (cannot be constexpr: due to the presence of gpu raw calls can't be put in header)
-  //   for (int i = 0; i < 2; i++) {
-  //     auto thrustTrackletsBegin = thrust::device_ptr<Tracklet>(mTrackletsDevice[i]);
-  //     auto thrustTrackletsEnd = thrustTrackletsBegin + mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * mNRof;
-  //     thrust::fill(THRUST_NAMESPACE::par.on(stream.get()), thrustTrackletsBegin, thrustTrackletsEnd, Tracklet{});
-  //     GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterDevice[i], 0, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
-  //   }
-  //   GPUChkErrS(cudaMemsetAsync(mUsedTrackletsDevice, false, sizeof(unsigned char) * mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
-  //   GPUChkErrS(cudaMemsetAsync(mClusteredLinesDevice, -1, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mTFGPUParams->maxTrackletsPerCluster * mNRof, stream.get()));
-  // } else {
-  //   for (int i = 0; i < nLayers; ++i) {
-  //     if (i < nLayers - 1) {
-  //       GPUChkErrS(cudaMemsetAsync(mTrackletsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->clustersPerROfCapacity * mNRof, stream.get()));
-  //       auto thrustTrackletsBegin = thrust::device_ptr<Tracklet>(mTrackletsDevice[i]);
-  //       auto thrustTrackletsEnd = thrustTrackletsBegin + mTFGPUParams->maxTrackletsPerCluster * mTFGPUParams->clustersPerROfCapacity * mNRof;
-  //       thrust::fill(THRUST_NAMESPACE::par.on(stream.get()), thrustTrackletsBegin, thrustTrackletsEnd, Tracklet{});
-  //       if (i < nLayers - 2) {
-  //         GPUChkErrS(cudaMemsetAsync(mCellsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->cellsLUTsize * mNRof, stream.get()));
-  //         GPUChkErrS(cudaMemsetAsync(mRoadsLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
-  //         if (i < nLayers - 3) {
-  //           GPUChkErrS(cudaMemsetAsync(mNeighboursCellLookupTablesDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
-  //           GPUChkErrS(cudaMemsetAsync(mNeighboursCellDevice[i], 0, sizeof(int) * mTFGPUParams->maxNeighboursSize * mNRof, stream.get()));
-  //         }
-  //       }
-  //     }
-  //   }
-  //   GPUChkErrS(cudaMemsetAsync(mNFoundCellsDevice, 0, (nLayers - 2) * sizeof(int), stream.get()));
-  // }
-}
-
-template <int nLayers>
-size_t GpuTimeFrameChunk<nLayers>::computeScalingSizeBytes(const int nrof, const TimeFrameGPUParameters& config)
-{
-  size_t rofsize = nLayers * sizeof(int); // number of clusters per ROF
-  // rofsize += nLayers * sizeof(Cluster) * config.clustersPerROfCapacity;                                        // clusters
-  // rofsize += nLayers * sizeof(TrackingFrameInfo) * config.clustersPerROfCapacity;                              // tracking frame info
-  // rofsize += nLayers * sizeof(int) * config.clustersPerROfCapacity;                                            // external cluster indices
-  // rofsize += nLayers * sizeof(int) * (256 * 128 + 1);                                                          // index tables
-  // rofsize += (nLayers - 1) * sizeof(int) * config.clustersPerROfCapacity;                                      // tracklets lookup tables
-  // rofsize += (nLayers - 1) * sizeof(Tracklet) * config.maxTrackletsPerCluster * config.clustersPerROfCapacity; // tracklets
-  // rofsize += 2 * sizeof(int) * config.clustersPerROfCapacity;                                                  // tracklets found per cluster (vertexer)
-  // rofsize += sizeof(unsigned char) * config.maxTrackletsPerCluster * config.clustersPerROfCapacity;            // used tracklets (vertexer)
-  // rofsize += (nLayers - 2) * sizeof(int) * config.validatedTrackletsCapacity;                                  // cells lookup tables
-  // rofsize += (nLayers - 2) * sizeof(CellSeed) * config.maxNeighboursSize;                                      // cells
-  // rofsize += (nLayers - 3) * sizeof(int) * config.maxNeighboursSize;                                           // cell neighbours lookup tables
-  // rofsize += (nLayers - 3) * sizeof(int) * config.maxNeighboursSize;                                           // cell neighbours
-  // rofsize += sizeof(Road<nLayers - 2>) * config.maxRoadPerRofSize;                                             // roads
-  // rofsize += (nLayers - 2) * sizeof(int) * config.maxNeighboursSize;                                           // road LUT
-  // rofsize += sizeof(Line) * config.maxTrackletsPerCluster * config.clustersPerROfCapacity;                     // lines
-  // rofsize += sizeof(int) * config.clustersPerROfCapacity;                                                      // found lines
-  // rofsize += sizeof(int) * config.clustersPerROfCapacity;                                                      // found lines exclusive sum
-  // rofsize += sizeof(int) * config.clustersPerROfCapacity * config.maxTrackletsPerCluster;                      // lines used in clusterlines
-
-  // rofsize += (nLayers - 1) * sizeof(int); // total found tracklets
-  // rofsize += (nLayers - 2) * sizeof(int); // total found cells
-
-  return rofsize * nrof;
-}
-
-template <int nLayers>
-size_t GpuTimeFrameChunk<nLayers>::computeFixedSizeBytes(const TimeFrameGPUParameters& config)
-{
-  size_t total = config.tmpCUBBufferSize;                  // CUB tmp buffers
-  total += sizeof(gpu::StaticTrackingParameters<nLayers>); // static parameters loaded once
-  return total;
-}
-
-template <int nLayers>
-size_t GpuTimeFrameChunk<nLayers>::computeRofPerChunk(const TimeFrameGPUParameters& config, const size_t m)
-{
-  return (m * GB / (float)(config.nTimeFrameChunks) - GpuTimeFrameChunk<nLayers>::computeFixedSizeBytes(config)) / (float)GpuTimeFrameChunk<nLayers>::computeScalingSizeBytes(1, config);
-}
-
-/// Interface
-template <int nLayers>
-Cluster* GpuTimeFrameChunk<nLayers>::getDeviceClusters(const int layer)
-{
-  return mClustersDevice[layer];
-}
-
-template <int nLayers>
-int* GpuTimeFrameChunk<nLayers>::getDeviceClusterExternalIndices(const int layer)
-{
-  return mClusterExternalIndicesDevice[layer];
-}
-
-template <int nLayers>
-int* GpuTimeFrameChunk<nLayers>::getDeviceIndexTables(const int layer)
-{
-  return mIndexTablesDevice[layer];
-}
-
-template <int nLayers>
-Tracklet* GpuTimeFrameChunk<nLayers>::getDeviceTracklets(const int layer)
-{
-  return mTrackletsDevice[layer];
-}
-
-template <int nLayers>
-int* GpuTimeFrameChunk<nLayers>::getDeviceTrackletsLookupTables(const int layer)
-{
-  return mTrackletsLookupTablesDevice[layer];
-}
-
-template <int nLayers>
-CellSeed* GpuTimeFrameChunk<nLayers>::getDeviceCells(const int layer)
-{
-  return mCellsDevice[layer];
-}
-
-template <int nLayers>
-int* GpuTimeFrameChunk<nLayers>::getDeviceCellsLookupTables(const int layer)
-{
-  return mCellsLookupTablesDevice[layer];
-}
-
-template <int nLayers>
-int* GpuTimeFrameChunk<nLayers>::getDeviceCellNeigboursLookupTables(const int layer)
-{
-  return mNeighboursCellLookupTablesDevice[layer];
-}
-
-template <int nLayers>
-int* GpuTimeFrameChunk<nLayers>::getDeviceCellNeighbours(const int layer)
-{
-  return mNeighboursCellDevice[layer];
-}
-
-template <int nLayers>
-int* GpuTimeFrameChunk<nLayers>::getDeviceRoadsLookupTables(const int layer)
-{
-  return mRoadsLookupTablesDevice[layer];
-}
-
-// Load data
-template <int nLayers>
-size_t GpuTimeFrameChunk<nLayers>::loadDataOnDevice(const size_t startRof, const size_t maxRof, const int maxLayers, Stream& stream)
-{
-  RANGE("load_clusters_data", 5);
-  // auto nRofs = std::min(maxRof - startRof, mNRof);
-  // mNPopulatedRof = mTimeFramePtr->getNClustersROFrange(startRof, nRofs, 0).size();
-  // for (int i = 0; i < maxLayers; ++i) {
-  //   mHostClusters[i] = mTimeFramePtr->getClustersPerROFrange(startRof, nRofs, i);
-  //   mHostIndexTables[i] = mTimeFramePtr->getIndexTablePerROFrange(startRof, nRofs, i);
-  //   if (mHostClusters[i].size() > mTFGPUParams->clustersPerROfCapacity * nRofs) {
-  //     LOGP(warning, "Clusters on layer {} exceed the expected value, resizing to config value: {}, will lose information!", i, mTFGPUParams->clustersPerROfCapacity * nRofs);
-  //   }
-  //   GPUChkErrS(cudaMemcpyAsync(mClustersDevice[i],
-  //                                 mHostClusters[i].data(),
-  //                                 (int)std::min(mHostClusters[i].size(), mTFGPUParams->clustersPerROfCapacity * nRofs) * sizeof(Cluster),
-  //                                 cudaMemcpyHostToDevice, stream.get()));
-  //   if (mHostIndexTables[i].data()) {
-  //     GPUChkErrS(cudaMemcpyAsync(mIndexTablesDevice[i],
-  //                                   mHostIndexTables[i].data(),
-  //                                   mHostIndexTables[i].size() * sizeof(int),
-  //                                   cudaMemcpyHostToDevice, stream.get()));
-  //   }
-  // }
-  return mNPopulatedRof; // return the number of ROFs we loaded the data for.
-}
-template class GpuTimeFrameChunk<7>;
-} // namespace gpu
-} // namespace o2::its
\ No newline at end of file
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index da0cd51478945..a9b51580f9be7 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -29,8 +29,8 @@
 namespace o2::its::gpu
 {
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& stream, bool extAllocator, int32_t type)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::allocMemAsync(void** ptr, size_t size, Stream& stream, bool extAllocator, int32_t type)
 {
   if (extAllocator) {
     *ptr = (this->mExternalAllocator)->allocate(size, type);
@@ -40,8 +40,8 @@ void TimeFrameGPU<nLayers>::allocMemAsync(void** ptr, size_t size, Stream& strea
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::allocMem(void** ptr, size_t size, bool extAllocator, int32_t type)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::allocMem(void** ptr, size_t size, bool extAllocator, int32_t type)
 {
   if (extAllocator) {
     *ptr = (this->mExternalAllocator)->allocate(size, type);
@@ -51,8 +51,8 @@ void TimeFrameGPU<nLayers>::allocMem(void** ptr, size_t size, bool extAllocator,
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadIndexTableUtils(const int iteration)
 {
   GPUTimer timer("loading indextable utils");
   if (!iteration) {
@@ -63,16 +63,16 @@ void TimeFrameGPU<nLayers>::loadIndexTableUtils(const int iteration)
   GPUChkErrS(cudaMemcpy(mIndexTableUtilsDevice, &(this->mIndexTableUtils), sizeof(IndexTableUtilsN), cudaMemcpyHostToDevice));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createUnsortedClustersDeviceArray(const int iteration, const int maxLayers)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createUnsortedClustersDeviceArray(const int iteration, const int maxLayers)
 {
   if (!iteration) {
     GPUTimer timer("creating unsorted clusters array");
-    allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), nLayers * sizeof(Cluster*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    mPinnedUnsortedClusters.set(nLayers);
+    allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), NLayers * sizeof(Cluster*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), NLayers * sizeof(Cluster*), cudaHostRegisterPortable));
+    mPinnedUnsortedClusters.set(NLayers);
     if (!this->hasFrameworkAllocator()) {
-      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
+      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, NLayers); ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mUnsortedClusters[iLayer].data(), this->mUnsortedClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
         mPinnedUnsortedClusters.set(iLayer);
       }
@@ -80,8 +80,8 @@ void TimeFrameGPU<nLayers>::createUnsortedClustersDeviceArray(const int iteratio
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadUnsortedClustersDevice(const int iteration, const int layer)
 {
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading unsorted clusters", layer);
@@ -92,16 +92,16 @@ void TimeFrameGPU<nLayers>::loadUnsortedClustersDevice(const int iteration, cons
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createClustersDeviceArray(const int iteration, const int maxLayers)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createClustersDeviceArray(const int iteration, const int maxLayers)
 {
   if (!iteration) {
     GPUTimer timer("creating sorted clusters array");
-    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), nLayers * sizeof(Cluster*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaHostRegister(mClustersDevice.data(), nLayers * sizeof(Cluster*), cudaHostRegisterPortable));
-    mPinnedClusters.set(nLayers);
+    allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), NLayers * sizeof(Cluster*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaHostRegister(mClustersDevice.data(), NLayers * sizeof(Cluster*), cudaHostRegisterPortable));
+    mPinnedClusters.set(NLayers);
     if (!this->hasFrameworkAllocator()) {
-      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
+      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, NLayers); ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mClusters[iLayer].data(), this->mClusters[iLayer].size() * sizeof(Cluster), cudaHostRegisterPortable));
         mPinnedClusters.set(iLayer);
       }
@@ -109,8 +109,8 @@ void TimeFrameGPU<nLayers>::createClustersDeviceArray(const int iteration, const
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadClustersDevice(const int iteration, const int layer)
 {
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
@@ -121,16 +121,16 @@ void TimeFrameGPU<nLayers>::loadClustersDevice(const int iteration, const int la
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createClustersIndexTablesArray(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createClustersIndexTablesArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating clustersindextable array");
-    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), nLayers * sizeof(int*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaHostRegister(mClustersIndexTablesDevice.data(), nLayers * sizeof(int*), cudaHostRegisterPortable));
-    mPinnedClustersIndexTables.set(nLayers);
+    allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), NLayers * sizeof(int*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaHostRegister(mClustersIndexTablesDevice.data(), NLayers * sizeof(int*), cudaHostRegisterPortable));
+    mPinnedClustersIndexTables.set(NLayers);
     if (!this->hasFrameworkAllocator()) {
-      for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+      for (auto iLayer{0}; iLayer < NLayers; ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mIndexTables[iLayer].data(), this->mIndexTables[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
         mPinnedClustersIndexTables.set(iLayer);
       }
@@ -138,8 +138,8 @@ void TimeFrameGPU<nLayers>::createClustersIndexTablesArray(const int iteration)
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadClustersIndexTables(const int iteration, const int layer)
 {
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
@@ -150,16 +150,16 @@ void TimeFrameGPU<nLayers>::loadClustersIndexTables(const int iteration, const i
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createUsedClustersDeviceArray(const int iteration, const int maxLayers)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createUsedClustersDeviceArray(const int iteration, const int maxLayers)
 {
   if (!iteration) {
     GPUTimer timer("creating used clusters flags");
-    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), nLayers * sizeof(uint8_t*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaHostRegister(mUsedClustersDevice.data(), nLayers * sizeof(uint8_t*), cudaHostRegisterPortable));
-    mPinnedUsedClusters.set(nLayers);
+    allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), NLayers * sizeof(uint8_t*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaHostRegister(mUsedClustersDevice.data(), NLayers * sizeof(uint8_t*), cudaHostRegisterPortable));
+    mPinnedUsedClusters.set(NLayers);
     if (!this->hasFrameworkAllocator()) {
-      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, nLayers); ++iLayer) {
+      for (auto iLayer{0}; iLayer < o2::gpu::CAMath::Min(maxLayers, NLayers); ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(uint8_t), cudaHostRegisterPortable));
         mPinnedUsedClusters.set(iLayer);
       }
@@ -167,8 +167,8 @@ void TimeFrameGPU<nLayers>::createUsedClustersDeviceArray(const int iteration, c
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createUsedClustersDevice(const int iteration, const int layer)
 {
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "creating used clusters flags", layer);
@@ -179,26 +179,26 @@ void TimeFrameGPU<nLayers>::createUsedClustersDevice(const int iteration, const
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadUsedClustersDevice()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadUsedClustersDevice()
 {
-  for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+  for (auto iLayer{0}; iLayer < NLayers; ++iLayer) {
     GPUTimer timer(mGpuStreams[iLayer], "loading used clusters flags", iLayer);
     GPULog("gpu-transfer: loading {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[iLayer].size(), iLayer, this->mUsedClusters[iLayer].size() * sizeof(unsigned char) / constants::MB);
     GPUChkErrS(cudaMemcpyAsync(mUsedClustersDevice[iLayer], this->mUsedClusters[iLayer].data(), this->mUsedClusters[iLayer].size() * sizeof(unsigned char), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createROFrameClustersDeviceArray(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createROFrameClustersDeviceArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating ROFrame clusters array");
-    allocMem(reinterpret_cast<void**>(&mROFramesClustersDeviceArray), nLayers * sizeof(int*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaHostRegister(mROFramesClustersDevice.data(), nLayers * sizeof(int*), cudaHostRegisterPortable));
-    mPinnedROFramesClusters.set(nLayers);
+    allocMem(reinterpret_cast<void**>(&mROFramesClustersDeviceArray), NLayers * sizeof(int*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaHostRegister(mROFramesClustersDevice.data(), NLayers * sizeof(int*), cudaHostRegisterPortable));
+    mPinnedROFramesClusters.set(NLayers);
     if (!this->hasFrameworkAllocator()) {
-      for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+      for (auto iLayer{0}; iLayer < NLayers; ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mROFramesClusters[iLayer].data(), this->mROFramesClusters[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
         mPinnedROFramesClusters.set(iLayer);
       }
@@ -206,8 +206,8 @@ void TimeFrameGPU<nLayers>::createROFrameClustersDeviceArray(const int iteration
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadROFrameClustersDevice(const int iteration, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadROFrameClustersDevice(const int iteration, const int layer)
 {
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading ROframe clusters", layer);
@@ -218,16 +218,16 @@ void TimeFrameGPU<nLayers>::loadROFrameClustersDevice(const int iteration, const
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackingFrameInfoDeviceArray(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createTrackingFrameInfoDeviceArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating trackingframeinfo array");
-    allocMem(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), nLayers * sizeof(TrackingFrameInfo*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), nLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
-    mPinnedTrackingFrameInfo.set(nLayers);
+    allocMem(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), NLayers * sizeof(TrackingFrameInfo*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), NLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
+    mPinnedTrackingFrameInfo.set(NLayers);
     if (!this->hasFrameworkAllocator()) {
-      for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+      for (auto iLayer{0}; iLayer < NLayers; ++iLayer) {
         GPUChkErrS(cudaHostRegister(this->mTrackingFrameInfo[iLayer].data(), this->mTrackingFrameInfo[iLayer].size() * sizeof(TrackingFrameInfo), cudaHostRegisterPortable));
         mPinnedTrackingFrameInfo.set(iLayer);
       }
@@ -235,8 +235,8 @@ void TimeFrameGPU<nLayers>::createTrackingFrameInfoDeviceArray(const int iterati
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadTrackingFrameInfoDevice(const int iteration, const int layer)
 {
   if (!iteration) {
     GPUTimer timer(mGpuStreams[layer], "loading trackingframeinfo", layer);
@@ -247,43 +247,113 @@ void TimeFrameGPU<nLayers>::loadTrackingFrameInfoDevice(const int iteration, con
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadMultiplicityCutMask(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadROFCutMask(const int iteration)
 {
   if (!iteration || iteration == 3) { // we need to re-load the swapped mult-mask in upc iteration
     GPUTimer timer("loading multiplicity cut mask");
-    GPULog("gpu-transfer: iteration {} loading multiplicity cut mask with {} elements, for {:.2f} MB.", iteration, this->mMultiplicityCutMask.size(), this->mMultiplicityCutMask.size() * sizeof(uint8_t) / constants::MB);
-    if (!iteration) { // only allocate on first call
-      allocMem(reinterpret_cast<void**>(&mMultMaskDevice), this->mMultiplicityCutMask.size() * sizeof(uint8_t), this->hasFrameworkAllocator());
-    }
-    GPUChkErrS(cudaMemcpy(mMultMaskDevice, this->mMultiplicityCutMask.data(), this->mMultiplicityCutMask.size() * sizeof(uint8_t), cudaMemcpyHostToDevice));
-  }
-}
-
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadVertices(const int iteration)
+    const auto& hostTable = *(this->mROFMask);
+    const auto hostView = hostTable.getView();
+    using TableEntry = ROFMaskTable<NLayers>::TableEntry;
+    using TableIndex = ROFMaskTable<NLayers>::TableIndex;
+    TableEntry* d_flatTable{nullptr};
+    TableIndex* d_indices{nullptr};
+    GPULog("gpu-transfer: iteration {} loading multiplicity cut mask with {} elements, for {:.2f} MB.",
+           iteration, hostTable.getFlatMaskSize(), hostTable.getFlatMaskSize() * sizeof(TableEntry) / constants::MB);
+    allocMem(reinterpret_cast<void**>(&d_flatTable), hostTable.getFlatMaskSize() * sizeof(TableEntry), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&d_indices), NLayers * sizeof(uint32_t), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(d_indices, hostView.mLayerROFOffsets, NLayers * sizeof(TableIndex), cudaMemcpyHostToDevice));
+    // Re-copy the flat mask on every qualifying iteration (e.g. after swapMasks() for UPC)
+    GPUChkErrS(cudaMemcpy(d_flatTable, hostView.mFlatMask, hostTable.getFlatMaskSize() * sizeof(TableEntry), cudaMemcpyHostToDevice));
+    mDeviceROFMaskTableView = hostTable.getDeviceView(d_flatTable, d_indices);
+  }
+}
+
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadVertices(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("loading seeding vertices");
-    GPULog("gpu-transfer: loading {} ROframes vertices, for {:.2f} MB.", this->mROFramesPV.size(), this->mROFramesPV.size() * sizeof(int) / constants::MB);
-    allocMem(reinterpret_cast<void**>(&mROFramesPVDevice), this->mROFramesPV.size() * sizeof(int), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaMemcpy(mROFramesPVDevice, this->mROFramesPV.data(), this->mROFramesPV.size() * sizeof(int), cudaMemcpyHostToDevice));
     GPULog("gpu-transfer: loading {} seeding vertices, for {:.2f} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / constants::MB);
     allocMem(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mPrimaryVerticesDevice, this->mPrimaryVertices.data(), this->mPrimaryVertices.size() * sizeof(Vertex), cudaMemcpyHostToDevice));
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackletsLUTDeviceArray(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadROFOverlapTable(const int iteration)
+{
+  if (!iteration) {
+    GPUTimer timer("initialising device view of ROFOverlapTable");
+    const auto& hostTable = this->getROFOverlapTable();
+    const auto& hostView = this->getROFOverlapTableView();
+    using TableEntry = ROFOverlapTable<NLayers>::TableEntry;
+    using TableIndex = ROFOverlapTable<NLayers>::TableIndex;
+    using LayerTiming = o2::its::LayerTiming;
+    TableEntry* d_flatTable{nullptr};
+    TableIndex* d_indices{nullptr};
+    LayerTiming* d_layers{nullptr};
+    size_t flatTableSize = hostTable.getFlatTableSize();
+    allocMem(reinterpret_cast<void**>(&d_flatTable), flatTableSize * sizeof(TableEntry), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(d_flatTable, hostView.mFlatTable, flatTableSize * sizeof(TableEntry), cudaMemcpyHostToDevice));
+    allocMem(reinterpret_cast<void**>(&d_indices), hostTable.getIndicesSize() * sizeof(TableIndex), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(d_indices, hostView.mIndices, hostTable.getIndicesSize() * sizeof(TableIndex), cudaMemcpyHostToDevice));
+    allocMem(reinterpret_cast<void**>(&d_layers), NLayers * sizeof(LayerTiming), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(d_layers, hostView.mLayers, NLayers * sizeof(LayerTiming), cudaMemcpyHostToDevice));
+    mDeviceROFOverlapTableView = hostTable.getDeviceView(d_flatTable, d_indices, d_layers);
+  }
+}
+
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadROFVertexLookupTable(const int iteration)
+{
+  if (!iteration) {
+    GPUTimer timer("initialising device view of ROFVertexLookupTable");
+    const auto& hostTable = this->getROFVertexLookupTable();
+    const auto& hostView = this->getROFVertexLookupTableView();
+    using TableEntry = ROFVertexLookupTable<NLayers>::TableEntry;
+    using TableIndex = ROFVertexLookupTable<NLayers>::TableIndex;
+    using LayerTiming = o2::its::LayerTiming;
+    TableEntry* d_flatTable{nullptr};
+    TableIndex* d_indices{nullptr};
+    LayerTiming* d_layers{nullptr};
+    size_t flatTableSize = hostTable.getFlatTableSize();
+    allocMem(reinterpret_cast<void**>(&d_flatTable), flatTableSize * sizeof(TableEntry), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(d_flatTable, hostView.mFlatTable, flatTableSize * sizeof(TableEntry), cudaMemcpyHostToDevice));
+    allocMem(reinterpret_cast<void**>(&d_indices), hostTable.getIndicesSize() * sizeof(TableIndex), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(d_indices, hostView.mIndices, hostTable.getIndicesSize() * sizeof(TableIndex), cudaMemcpyHostToDevice));
+    allocMem(reinterpret_cast<void**>(&d_layers), NLayers * sizeof(LayerTiming), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(d_layers, hostView.mLayers, NLayers * sizeof(LayerTiming), cudaMemcpyHostToDevice));
+    mDeviceROFVertexLookupTableView = hostTable.getDeviceView(d_flatTable, d_indices, d_layers);
+  }
+}
+
+template <int NLayers>
+void TimeFrameGPU<NLayers>::updateROFVertexLookupTable(const int iteration)
+{
+  const auto& hostTable = this->getROFVertexLookupTable();
+  if (!iteration) {
+    GPUTimer timer("updating device view of ROFVertexLookupTable");
+    const auto& hostView = this->getROFVertexLookupTableView();
+    using TableEntry = ROFVertexLookupTable<NLayers>::TableEntry;
+    TableEntry* d_flatTable{nullptr};
+    size_t flatTableSize = hostTable.getFlatTableSize();
+    allocMem(reinterpret_cast<void**>(&d_flatTable), flatTableSize * sizeof(TableEntry), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(d_flatTable, hostView.mFlatTable, flatTableSize * sizeof(TableEntry), cudaMemcpyHostToDevice));
+    mDeviceROFVertexLookupTableView = hostTable.getDeviceView(d_flatTable, hostView.mIndices, hostView.mLayers);
+  }
+}
+
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createTrackletsLUTDeviceArray(const int iteration)
 {
   if (!iteration) {
-    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (nLayers - 1) * sizeof(int*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (NLayers - 1) * sizeof(int*), this->hasFrameworkAllocator());
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createTrackletsLUTDevice(const int iteration, const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating tracklets LUTs", layer);
   const int ncls = this->mClusters[layer].size() + 1;
@@ -295,17 +365,17 @@ void TimeFrameGPU<nLayers>::createTrackletsLUTDevice(const int iteration, const
   GPUChkErrS(cudaMemsetAsync(mTrackletsLUTDevice[layer], 0, ncls * sizeof(int), mGpuStreams[layer].get()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackletsBuffersArray(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createTrackletsBuffersArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating tracklet buffers array");
-    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (nLayers - 1) * sizeof(Tracklet*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (NLayers - 1) * sizeof(Tracklet*), this->hasFrameworkAllocator());
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackletsBuffers(const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createTrackletsBuffers(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating tracklet buffers", layer);
   mNTracklets[layer] = 0;
@@ -313,34 +383,35 @@ void TimeFrameGPU<nLayers>::createTrackletsBuffers(const int layer)
   mGpuStreams[layer].sync(); // ensure number of tracklets is correct
   GPULog("gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer], layer, mNTracklets[layer] * sizeof(Tracklet) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[layer]), mNTracklets[layer] * sizeof(Tracklet), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  GPUChkErrS(cudaMemsetAsync(mTrackletsDevice[layer], 0, mNTracklets[layer] * sizeof(Tracklet), mGpuStreams[layer].get()));
   GPUChkErrS(cudaMemcpyAsync(&mTrackletsDeviceArray[layer], &mTrackletsDevice[layer], sizeof(Tracklet*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadTrackletsDevice()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadTrackletsDevice()
 {
-  GPUTimer timer(mGpuStreams, "loading tracklets", nLayers - 1);
-  for (auto iLayer{0}; iLayer < nLayers - 1; ++iLayer) {
+  GPUTimer timer(mGpuStreams, "loading tracklets", NLayers - 1);
+  for (auto iLayer{0}; iLayer < NLayers - 1; ++iLayer) {
     GPULog("gpu-transfer: loading {} tracklets on layer {}, for {:.2f} MB.", this->mTracklets[iLayer].size(), iLayer, this->mTracklets[iLayer].size() * sizeof(Tracklet) / constants::MB);
     GPUChkErrS(cudaHostRegister(this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mTrackletsDevice[iLayer], this->mTracklets[iLayer].data(), this->mTracklets[iLayer].size() * sizeof(Tracklet), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadTrackletsLUTDevice()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadTrackletsLUTDevice()
 {
   GPUTimer timer("loading tracklets");
-  for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
+  for (auto iLayer{0}; iLayer < NLayers - 2; ++iLayer) {
     GPULog("gpu-transfer: loading tracklets LUT for {} elements on layer {}, for {:.2f} MB", this->mTrackletsLookupTable[iLayer].size(), iLayer + 1, this->mTrackletsLookupTable[iLayer].size() * sizeof(int) / constants::MB);
     GPUChkErrS(cudaMemcpyAsync(mTrackletsLUTDevice[iLayer + 1], this->mTrackletsLookupTable[iLayer].data(), this->mTrackletsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
   mGpuStreams.sync();
-  GPUChkErrS(cudaMemcpy(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (nLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
+  GPUChkErrS(cudaMemcpy(mTrackletsLUTDeviceArray, mTrackletsLUTDevice.data(), (NLayers - 1) * sizeof(int*), cudaMemcpyHostToDevice));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice(const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createNeighboursIndexTablesDevice(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells neighbours", layer);
   GPULog("gpu-transfer: reserving neighbours LUT for {} elements on layer {}, for {:.2f} MB.", mNCells[layer] + 1, layer, (mNCells[layer] + 1) * sizeof(int) / constants::MB);
@@ -348,8 +419,8 @@ void TimeFrameGPU<nLayers>::createNeighboursIndexTablesDevice(const int layer)
   GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[layer], 0, (mNCells[layer] + 1) * sizeof(int), mGpuStreams[layer].get()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const unsigned int nCells)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createNeighboursLUTDevice(const int layer, const unsigned int nCells)
 {
   GPUTimer timer(mGpuStreams[layer], "reserving neighboursLUT");
   GPULog("gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {:.2f} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / constants::MB);
@@ -357,11 +428,11 @@ void TimeFrameGPU<nLayers>::createNeighboursLUTDevice(const int layer, const uns
   GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[layer].get()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadCellsDevice()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadCellsDevice()
 {
-  GPUTimer timer(mGpuStreams, "loading cell seeds", nLayers - 2);
-  for (auto iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
+  GPUTimer timer(mGpuStreams, "loading cell seeds", NLayers - 2);
+  for (auto iLayer{0}; iLayer < NLayers - 2; ++iLayer) {
     GPULog("gpu-transfer: loading {} cell seeds on layer {}, for {:.2f} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeedN) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeedN), mGpuStreams[iLayer], this->hasFrameworkAllocator());
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->hasFrameworkAllocator()); // accessory for the neigh. finding.
@@ -370,17 +441,17 @@ void TimeFrameGPU<nLayers>::loadCellsDevice()
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createCellsLUTDeviceArray(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createCellsLUTDeviceArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating cells LUTs array");
-    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (nLayers - 2) * sizeof(int*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (NLayers - 2) * sizeof(int*), this->hasFrameworkAllocator());
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createCellsLUTDevice(const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createCellsLUTDevice(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells LUTs", layer);
   GPULog("gpu-transfer: creating cell LUT for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer] + 1, layer, (mNTracklets[layer] + 1) * sizeof(int) / constants::MB);
@@ -389,18 +460,18 @@ void TimeFrameGPU<nLayers>::createCellsLUTDevice(const int layer)
   GPUChkErrS(cudaMemcpyAsync(&mCellsLUTDeviceArray[layer], &mCellsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createCellsBuffersArray(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createCellsBuffersArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating cells buffers array");
-    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (nLayers - 2) * sizeof(CellSeedN*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (NLayers - 2) * sizeof(CellSeedN*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeedN*), cudaMemcpyHostToDevice));
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createCellsBuffers(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells buffers");
   mNCells[layer] = 0;
@@ -408,32 +479,23 @@ void TimeFrameGPU<nLayers>::createCellsBuffers(const int layer)
   mGpuStreams[layer].sync(); // ensure number of cells is correct
   GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeedN) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  GPUChkErrS(cudaMemsetAsync(mCellsDevice[layer], 0, mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer].get()));
   GPUChkErrS(cudaMemcpyAsync(&mCellsDeviceArray[layer], &mCellsDevice[layer], sizeof(CellSeedN*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadCellsLUTDevice()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadCellsLUTDevice()
 {
-  GPUTimer timer(mGpuStreams, "loading cells LUTs", nLayers - 3);
-  for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
+  GPUTimer timer(mGpuStreams, "loading cells LUTs", NLayers - 3);
+  for (auto iLayer{0}; iLayer < NLayers - 3; ++iLayer) {
     GPULog("gpu-transfer: loading cell LUT for {} elements on layer {}, for {:.2f} MB.", this->mCellsLookupTable[iLayer].size(), iLayer, this->mCellsLookupTable[iLayer].size() * sizeof(int) / constants::MB);
     GPUChkErrS(cudaHostRegister(this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaHostRegisterPortable));
     GPUChkErrS(cudaMemcpyAsync(mCellsLUTDevice[iLayer + 1], this->mCellsLookupTable[iLayer].data(), this->mCellsLookupTable[iLayer].size() * sizeof(int), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadRoadsDevice()
-{
-  GPUTimer timer("loading roads device");
-  GPULog("gpu-transfer: loading {} roads, for {:.2f} MB.", this->mRoads.size(), this->mRoads.size() * sizeof(Road<nLayers - 2>) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mRoadsDevice), this->mRoads.size() * sizeof(Road<nLayers - 2>), this->hasFrameworkAllocator());
-  GPUChkErrS(cudaHostRegister(this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpy(mRoadsDevice, this->mRoads.data(), this->mRoads.size() * sizeof(Road<nLayers - 2>), cudaMemcpyHostToDevice));
-}
-
-template <int nLayers>
-void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeedN>& seeds)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadTrackSeedsDevice(bounded_vector<CellSeedN>& seeds)
 {
   GPUTimer timer("loading track seeds");
   GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeedN) / constants::MB);
@@ -444,8 +506,8 @@ void TimeFrameGPU<nLayers>::loadTrackSeedsDevice(bounded_vector<CellSeedN>& seed
   GPUChkErrS(cudaMemset(mTrackSeedsLUTDevice, 0, (seeds.size() + 1) * sizeof(int)));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createNeighboursDevice(const unsigned int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "reserving neighbours", layer);
   this->mNNeighbours[layer] = 0;
@@ -458,8 +520,8 @@ void TimeFrameGPU<nLayers>::createNeighboursDevice(const unsigned int layer)
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createTrackITSExtDevice(const size_t nSeeds)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::createTrackITSExtDevice(const size_t nSeeds)
 {
   GPUTimer timer("reserving tracks");
   mNTracks = 0;
@@ -470,135 +532,54 @@ void TimeFrameGPU<nLayers>::createTrackITSExtDevice(const size_t nSeeds)
   GPUChkErrS(cudaMemset(mTrackITSExtDevice, 0, mNTracks * sizeof(o2::its::TrackITSExt)));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createVtxTrackletsLUTDevice(const int32_t iteration)
-{
-  GPUTimer timer("creating vertexer tracklet LUTs");
-  const int32_t ncls = this->mClusters[1].size();
-  for (int32_t iMode{0}; iMode < 2; ++iMode) {
-    if (!iteration) {
-      GPULog("gpu-transfer: creating vertexer tracklets per cluster for {} elements for mode {}, for {:.2f} MB.", ncls, iMode, ncls * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterDevice[iMode]), ncls * sizeof(int32_t), mGpuStreams[iMode], this->hasFrameworkAllocator());
-
-      GPULog("gpu-transfer: creating vertexer tracklets per cluster sum for {} elements for mode {}, for {:.2f} MB.", ncls + 1, iMode, (ncls + 1) * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDevice[iMode]), (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode], this->hasFrameworkAllocator());
-
-      GPULog("gpu-transfer: creating vertexer tracklets per ROF for {} elements for mode {}, for {:.2f} MB.", this->mNrof + 1, iMode, (this->mNrof + 1) * sizeof(int32_t) / constants::MB);
-      allocMemAsync(reinterpret_cast<void**>(&mNTrackletsPerROFDevice[iMode]), (this->mNrof + 1) * sizeof(int32_t), mGpuStreams[iMode], this->hasFrameworkAllocator());
-    }
-    GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterDevice[iMode], 0, ncls * sizeof(int32_t), mGpuStreams[iMode].get()));
-    GPUChkErrS(cudaMemsetAsync(mNTrackletsPerClusterSumDevice[iMode], 0, (ncls + 1) * sizeof(int32_t), mGpuStreams[iMode].get()));
-    GPUChkErrS(cudaMemsetAsync(mNTrackletsPerROFDevice[iMode], 0, (this->mNrof + 1) * sizeof(int32_t), mGpuStreams[iMode].get()));
-  }
-  mGpuStreams[0].sync();
-  mGpuStreams[1].sync();
-  if (!iteration) {
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterDeviceArray), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaMemcpy(mNTrackletsPerClusterDeviceArray, mNTrackletsPerClusterDevice.data(), mNTrackletsPerClusterDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
-
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerClusterSumDeviceArray), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaMemcpy(mNTrackletsPerClusterSumDeviceArray, mNTrackletsPerClusterSumDevice.data(), mNTrackletsPerClusterSumDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
-
-    allocMem(reinterpret_cast<void**>(&mNTrackletsPerROFDeviceArray), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaMemcpy(mNTrackletsPerROFDeviceArray, mNTrackletsPerROFDevice.data(), mNTrackletsPerROFDevice.size() * sizeof(int32_t*), cudaMemcpyHostToDevice));
-  }
-}
-
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createVtxTrackletsBuffers(const int32_t iteration)
-{
-  GPUTimer timer("creating vertexer tracklet buffers");
-  for (int32_t iMode{0}; iMode < 2; ++iMode) {
-    this->mTotalTracklets[iMode] = 0;
-    GPUChkErrS(cudaMemcpyAsync(&(this->mTotalTracklets[iMode]), mNTrackletsPerClusterSumDevice[iMode] + this->mClusters[1].size(), sizeof(int32_t), cudaMemcpyDeviceToHost, mGpuStreams[iMode].get()));
-    GPULog("gpu-transfer: creating vertexer tracklets buffer for {} elements on layer {}, for {:.2f} MB.", this->mTotalTracklets[iMode], iMode, this->mTotalTracklets[iMode] * sizeof(Tracklet) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[iMode]), this->mTotalTracklets[iMode] * sizeof(Tracklet), mGpuStreams[iMode], this->hasFrameworkAllocator());
-  }
-  mGpuStreams[0].sync();
-  mGpuStreams[1].sync();
-  allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), 2 * sizeof(Tracklet*), this->hasFrameworkAllocator());
-  GPUChkErrS(cudaHostRegister(mTrackletsDevice.data(), 2 * sizeof(Tracklet*), cudaHostRegisterPortable));
-  GPUChkErrS(cudaMemcpy(mTrackletsDeviceArray, mTrackletsDevice.data(), 2 * sizeof(Tracklet*), cudaMemcpyHostToDevice));
-}
-
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createVtxLinesLUTDevice(const int32_t iteration)
-{
-  GPUTimer timer("creating vertexer lines LUT and used tracklets buffer");
-  const int32_t ncls = this->mClusters[1].size();
-
-  GPULog("gpu-transfer: creating vertexer lines per cluster for {} elements , for {:.2f} MB.", ncls, ncls * sizeof(int32_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterDevice), ncls * sizeof(int32_t), this->hasFrameworkAllocator());
-
-  GPULog("gpu-transfer: creating vertexer lines per cluster sum for {} elements , for {:.2f} MB.", ncls + 1, (ncls + 1) * sizeof(int32_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mNLinesPerClusterSumDevice), (ncls + 1) * sizeof(int32_t), this->hasFrameworkAllocator());
-
-  const int32_t ntrkls = this->mTotalTracklets[0];
-  GPULog("gpu-transfer: creating vertexer used tracklets for {} elements , for {:.2f} MB.", ntrkls, ntrkls * sizeof(uint8_t) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mUsedTrackletsDevice), ntrkls * sizeof(uint8_t), this->hasFrameworkAllocator());
-}
-
-template <int nLayers>
-void TimeFrameGPU<nLayers>::createVtxLinesBuffer(const int32_t iteration)
-{
-  GPUTimer timer("creating vertexer lines buffer and resetting used tracklets");
-  int32_t nlines = 0;
-  GPUChkErrS(cudaMemcpy(&nlines, mNLinesPerClusterDevice + this->mClusters[1].size(), sizeof(int32_t), cudaMemcpyDeviceToHost));
-  this->mTotalLines = nlines;
-  GPULog("gpu-transfer: creating vertexer lines for {} elements , for {:.2f} MB.", nlines, nlines * sizeof(Line) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mLinesDevice), nlines * sizeof(Line), this->hasFrameworkAllocator());
-  // reset used tracklets
-  GPUChkErrS(cudaMemset(mUsedTrackletsDevice, 0, this->mTotalTracklets[0] * sizeof(uint8_t)));
-}
-
-template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadCellsDevice()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::downloadCellsDevice()
 {
-  GPUTimer timer(mGpuStreams, "downloading cells", nLayers - 2);
-  for (int iLayer{0}; iLayer < nLayers - 2; ++iLayer) {
+  GPUTimer timer(mGpuStreams, "downloading cells", NLayers - 2);
+  for (int iLayer{0}; iLayer < NLayers - 2; ++iLayer) {
     GPULog("gpu-transfer: downloading {} cells on layer: {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeedN) / constants::MB);
     this->mCells[iLayer].resize(mNCells[iLayer]);
     GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeedN), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadCellsLUTDevice()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::downloadCellsLUTDevice()
 {
-  GPUTimer timer(mGpuStreams, "downloading cell luts", nLayers - 3);
-  for (auto iLayer{0}; iLayer < nLayers - 3; ++iLayer) {
+  GPUTimer timer(mGpuStreams, "downloading cell luts", NLayers - 3);
+  for (auto iLayer{0}; iLayer < NLayers - 3; ++iLayer) {
     GPULog("gpu-transfer: downloading cells lut on layer {} for {} elements", iLayer, (mNTracklets[iLayer + 1] + 1));
     this->mCellsLookupTable[iLayer].resize(mNTracklets[iLayer + 1] + 1);
     GPUChkErrS(cudaMemcpyAsync(this->mCellsLookupTable[iLayer].data(), mCellsLUTDevice[iLayer + 1], (mNTracklets[iLayer + 1] + 1) * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>& neighbours, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>& neighbours, const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "downloading neighbours from layer", layer);
   GPULog("gpu-transfer: downloading {} neighbours, for {:.2f} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / constants::MB);
   GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut, const int layer)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::downloadNeighboursLUTDevice(bounded_vector<int>& lut, const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "downloading neighbours LUT from layer", layer);
   GPULog("gpu-transfer: downloading neighbours LUT for {} elements on layer {}, for {:.2f} MB.", lut.size(), layer, lut.size() * sizeof(int) / constants::MB);
   GPUChkErrS(cudaMemcpyAsync(lut.data(), mNeighboursLUTDevice[layer], lut.size() * sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::downloadTrackITSExtDevice()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::downloadTrackITSExtDevice()
 {
   GPUTimer timer("downloading tracks");
   GPULog("gpu-transfer: downloading {} tracks, for {:.2f} MB.", mTrackITSExt.size(), mTrackITSExt.size() * sizeof(o2::its::TrackITSExt) / constants::MB);
   GPUChkErrS(cudaMemcpy(mTrackITSExt.data(), mTrackITSExtDevice, mTrackITSExt.size() * sizeof(o2::its::TrackITSExt), cudaMemcpyDeviceToHost));
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::unregisterHostMemory(const int maxLayers)
 {
   GPUTimer timer("unregistering host memory");
   GPULog("unregistering host memory");
@@ -610,13 +591,13 @@ void TimeFrameGPU<nLayers>::unregisterHostMemory(const int maxLayers)
     }
   };
   auto checkedUnregisterArray = [](auto& bits, auto& vec) {
-    if (bits.test(nLayers)) {
+    if (bits.test(NLayers)) {
       GPUChkErrS(cudaHostUnregister(vec.data()));
-      bits.reset(nLayers);
+      bits.reset(NLayers);
     }
   };
 
-  for (auto iLayer{0}; iLayer < nLayers; ++iLayer) {
+  for (auto iLayer{0}; iLayer < NLayers; ++iLayer) {
     checkedUnregisterEntry(mPinnedUsedClusters, this->mUsedClusters, iLayer);
     checkedUnregisterEntry(mPinnedUnsortedClusters, this->mUnsortedClusters, iLayer);
     checkedUnregisterEntry(mPinnedClusters, this->mClusters, iLayer);
@@ -650,69 +631,67 @@ constexpr auto makeIterTags(std::index_sequence<I...>)
 constexpr auto kIterTags = makeIterTags(std::make_index_sequence<4>{});
 } // namespace detail
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::pushMemoryStack(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::pushMemoryStack(const int iteration)
 {
   // mark the beginning of memory marked with MEMORY_STACK that can be discarded
   // after doing one iteration
   (this->mExternalAllocator)->pushTagOnStack(detail::kIterTags[iteration]);
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::popMemoryStack(const int iteration)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::popMemoryStack(const int iteration)
 {
   // pop all memory on the stack from this iteration
   (this->mExternalAllocator)->popTagOffStack(detail::kIterTags[iteration]);
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::initialise(const int iteration,
+template <int NLayers>
+void TimeFrameGPU<NLayers>::initialise(const int iteration,
                                        const TrackingParameters& trkParam,
-                                       const int maxLayers,
-                                       IndexTableUtilsN* utils,
-                                       const TimeFrameGPUParameters* gpuParam)
+                                       const int maxLayers)
 {
-  mGpuStreams.resize(nLayers);
-  o2::its::TimeFrame<nLayers>::initialise(iteration, trkParam, maxLayers);
+  mGpuStreams.resize(NLayers);
+  o2::its::TimeFrame<NLayers>::initialise(iteration, trkParam, maxLayers, false);
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::syncStream(const size_t stream)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::syncStream(const size_t stream)
 {
   mGpuStreams[stream].sync();
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::syncStreams(const bool device)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::syncStreams(const bool device)
 {
   mGpuStreams.sync(device);
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::waitEvent(const int stream, const int event)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::waitEvent(const int stream, const int event)
 {
   mGpuStreams.waitEvent(stream, event);
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::recordEvent(const int event)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::recordEvent(const int event)
 {
   mGpuStreams[event].record();
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::recordEvents(const int start, const int end)
+template <int NLayers>
+void TimeFrameGPU<NLayers>::recordEvents(const int start, const int end)
 {
   for (int i{start}; i < end; ++i) {
     recordEvent(i);
   }
 }
 
-template <int nLayers>
-void TimeFrameGPU<nLayers>::wipe()
+template <int NLayers>
+void TimeFrameGPU<NLayers>::wipe()
 {
   unregisterHostMemory(0);
-  o2::its::TimeFrame<nLayers>::wipe();
+  o2::its::TimeFrame<NLayers>::wipe();
 }
 
 template class TimeFrameGPU<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu
deleted file mode 100644
index 7c42658242231..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TracerGPU.cu
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include <cuda_runtime.h>
-#include "ITStrackingGPU/TracerGPU.h"
-
-#if !defined(__HIPCC__) && defined(__USE_GPU_TRACER__)
-#include <nvtx3/nvToolsExt.h>
-
-constexpr uint32_t colors[] = {0xff00ff00, 0xff0000ff, 0xffffff00, 0xffff00ff, 0xff00ffff, 0xffff0000, 0xffffffff};
-constexpr int num_colors = sizeof(colors) / sizeof(uint32_t);
-
-namespace o2
-{
-namespace its
-{
-namespace gpu
-{
-Tracer::Tracer(const char* name, int color_id)
-{
-  color_id = color_id % num_colors;
-  nvtxEventAttributes_t eventAttrib = {0};
-  eventAttrib.version = NVTX_VERSION;
-  eventAttrib.size = NVTX_EVENT_ATTRIB_STRUCT_SIZE;
-  eventAttrib.colorType = NVTX_COLOR_ARGB;
-  eventAttrib.color = colors[color_id];
-  eventAttrib.messageType = NVTX_MESSAGE_TYPE_ASCII;
-  eventAttrib.message.ascii = name;
-  nvtxRangePushEx(&eventAttrib);
-}
-
-Tracer::~Tracer()
-{
-  nvtxRangePop();
-}
-
-} // namespace gpu
-} // namespace its
-} // namespace o2
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 42d2227de60f8..3de2871dd458e 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -24,14 +24,19 @@
 namespace o2::its
 {
 
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
+template <int NLayers>
+void TrackerTraitsGPU<NLayers>::initialiseTimeFrame(const int iteration)
 {
-  mTimeFrameGPU->initialise(iteration, this->mTrkParams[iteration], nLayers);
+  mTimeFrameGPU->initialise(iteration, this->mTrkParams[iteration], NLayers);
   // on default stream
   mTimeFrameGPU->loadVertices(iteration);
+  // TODO these tables can be put in persistent memory
+  mTimeFrameGPU->loadROFOverlapTable(iteration); // this can be put in constant memory actually
+  mTimeFrameGPU->loadROFVertexLookupTable(iteration);
+  // once the tables are in persistent memory just update the vertex one
+  // mTimeFrameGPU->updateROFVertexLookupTable(iteration);
   mTimeFrameGPU->loadIndexTableUtils(iteration);
-  mTimeFrameGPU->loadMultiplicityCutMask(iteration);
+  mTimeFrameGPU->loadROFCutMask(iteration);
   // pinned on host
   mTimeFrameGPU->createUsedClustersDeviceArray(iteration);
   mTimeFrameGPU->createClustersDeviceArray(iteration);
@@ -48,23 +53,20 @@ void TrackerTraitsGPU<nLayers>::initialiseTimeFrame(const int iteration)
   mTimeFrameGPU->pushMemoryStack(iteration);
 }
 
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::adoptTimeFrame(TimeFrame<nLayers>* tf)
+template <int NLayers>
+void TrackerTraitsGPU<NLayers>::adoptTimeFrame(TimeFrame<NLayers>* tf)
 {
-  mTimeFrameGPU = static_cast<gpu::TimeFrameGPU<nLayers>*>(tf);
-  this->mTimeFrame = static_cast<TimeFrame<nLayers>*>(tf);
+  mTimeFrameGPU = static_cast<gpu::TimeFrameGPU<NLayers>*>(tf);
+  this->mTimeFrame = static_cast<TimeFrame<NLayers>*>(tf);
 }
 
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
+template <int NLayers>
+void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int iVertex)
 {
   const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
-  int startROF{0};
-  int endROF{mTimeFrameGPU->getNrof()};
-
   // start by queuing loading needed of two last layers
-  for (int iLayer{nLayers}; iLayer-- > nLayers - 2;) {
+  for (int iLayer{NLayers}; iLayer-- > NLayers - 2;) {
     mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer);
     mTimeFrameGPU->loadClustersDevice(iteration, iLayer);
     mTimeFrameGPU->loadClustersIndexTables(iteration, iLayer);
@@ -82,17 +84,14 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
     }
     mTimeFrameGPU->createTrackletsLUTDevice(iteration, iLayer);
     mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
-    countTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
-                                         mTimeFrameGPU->getDeviceMultCutMask(),
+    countTrackletsInROFsHandler<NLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
+                                         mTimeFrameGPU->getDeviceROFMaskTableView(),
                                          iLayer,
-                                         startROF,
-                                         endROF,
-                                         mTimeFrameGPU->getNrof(),
-                                         this->mTrkParams[iteration].DeltaROF,
+                                         mTimeFrameGPU->getDeviceROFOverlapTableView(),
+                                         mTimeFrameGPU->getDeviceROFVertexLookupTableView(),
                                          iVertex,
                                          mTimeFrameGPU->getDeviceVertices(),
                                          mTimeFrameGPU->getDeviceROFramesPV(),
-                                         mTimeFrameGPU->getPrimaryVerticesNum(),
                                          mTimeFrameGPU->getDeviceArrayClusters(),
                                          mTimeFrameGPU->getClusterSizes(),
                                          mTimeFrameGPU->getDeviceROFrameClusters(),
@@ -117,17 +116,14 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
     if (mTimeFrameGPU->getNTracklets()[iLayer] == 0) {
       continue;
     }
-    computeTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
-                                           mTimeFrameGPU->getDeviceMultCutMask(),
+    computeTrackletsInROFsHandler<NLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
+                                           mTimeFrameGPU->getDeviceROFMaskTableView(),
                                            iLayer,
-                                           startROF,
-                                           endROF,
-                                           mTimeFrameGPU->getNrof(),
-                                           this->mTrkParams[iteration].DeltaROF,
+                                           mTimeFrameGPU->getDeviceROFOverlapTableView(),
+                                           mTimeFrameGPU->getDeviceROFVertexLookupTableView(),
                                            iVertex,
                                            mTimeFrameGPU->getDeviceVertices(),
                                            mTimeFrameGPU->getDeviceROFramesPV(),
-                                           mTimeFrameGPU->getPrimaryVerticesNum(),
                                            mTimeFrameGPU->getDeviceArrayClusters(),
                                            mTimeFrameGPU->getClusterSizes(),
                                            mTimeFrameGPU->getDeviceROFrameClusters(),
@@ -154,13 +150,13 @@ void TrackerTraitsGPU<nLayers>::computeLayerTracklets(const int iteration, int i
   }
 }
 
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
+template <int NLayers>
+void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
   // start by queuing loading needed of three last layers
-  for (int iLayer{nLayers}; iLayer-- > nLayers - 3;) {
+  for (int iLayer{NLayers}; iLayer-- > NLayers - 3;) {
     mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer);
     mTimeFrameGPU->loadTrackingFrameInfoDevice(iteration, iLayer);
     mTimeFrameGPU->recordEvent(iLayer);
@@ -183,7 +179,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
     mTimeFrameGPU->createCellsLUTDevice(iLayer);
     mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
     mTimeFrameGPU->waitEvent(iLayer, iLayer + 2); // wait stream until all data is available
-    countCellsHandler<nLayers>(mTimeFrameGPU->getDeviceArrayClusters(),
+    countCellsHandler<NLayers>(mTimeFrameGPU->getDeviceArrayClusters(),
                                mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
                                mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                                mTimeFrameGPU->getDeviceArrayTracklets(),
@@ -193,7 +189,6 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                                nullptr,
                                mTimeFrameGPU->getDeviceArrayCellsLUT(),
                                mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
-                               this->mTrkParams[iteration].DeltaROF,
                                this->mBz,
                                this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
@@ -206,7 +201,7 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
     if (mTimeFrameGPU->getNCells()[iLayer] == 0) {
       continue;
     }
-    computeCellsHandler<nLayers>(mTimeFrameGPU->getDeviceArrayClusters(),
+    computeCellsHandler<NLayers>(mTimeFrameGPU->getDeviceArrayClusters(),
                                  mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
                                  mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                                  mTimeFrameGPU->getDeviceArrayTracklets(),
@@ -216,7 +211,6 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
                                  mTimeFrameGPU->getDeviceCells()[iLayer],
                                  mTimeFrameGPU->getDeviceArrayCellsLUT(),
                                  mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
-                                 this->mTrkParams[iteration].DeltaROF,
                                  this->mBz,
                                  this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                  this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
@@ -227,8 +221,8 @@ void TrackerTraitsGPU<nLayers>::computeLayerCells(const int iteration)
   }
 }
 
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
+template <int NLayers>
+void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
 {
   const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
 
@@ -241,14 +235,13 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
     }
     mTimeFrameGPU->createNeighboursIndexTablesDevice(iLayer);
     mTimeFrameGPU->createNeighboursLUTDevice(iLayer, nextLayerCellsNum);
-    countCellNeighboursHandler<nLayers>(mTimeFrameGPU->getDeviceArrayCells(),
+    countCellNeighboursHandler<NLayers>(mTimeFrameGPU->getDeviceArrayCells(),
                                         mTimeFrameGPU->getDeviceNeighboursLUT(iLayer), // LUT is initialised here.
                                         mTimeFrameGPU->getDeviceArrayCellsLUT(),
                                         mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                         mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
                                         (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                                        this->mTrkParams[0].DeltaROF,
-                                        this->mTrkParams[0].MaxChi2ClusterAttachment,
+                                        this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                         this->mBz,
                                         iLayer,
                                         currentLayerCellsNum,
@@ -262,14 +255,13 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
     if (mTimeFrameGPU->getNNeighbours()[iLayer] == 0) {
       continue;
     }
-    computeCellNeighboursHandler<nLayers>(mTimeFrameGPU->getDeviceArrayCells(),
+    computeCellNeighboursHandler<NLayers>(mTimeFrameGPU->getDeviceArrayCells(),
                                           mTimeFrameGPU->getDeviceNeighboursLUT(iLayer),
                                           mTimeFrameGPU->getDeviceArrayCellsLUT(),
                                           mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                           mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
                                           (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                                          this->mTrkParams[0].DeltaROF,
-                                          this->mTrkParams[0].MaxChi2ClusterAttachment,
+                                          this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                           this->mBz,
                                           iLayer,
                                           currentLayerCellsNum,
@@ -287,18 +279,18 @@ void TrackerTraitsGPU<nLayers>::findCellsNeighbours(const int iteration)
   mTimeFrameGPU->syncStreams(false);
 }
 
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
+template <int NLayers>
+void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
 {
   auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   for (int startLevel{this->mTrkParams[iteration].CellsPerRoad()}; startLevel >= this->mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     const int minimumLayer{startLevel - 1};
-    bounded_vector<CellSeed<nLayers>> trackSeeds(this->getMemoryPool().get());
+    bounded_vector<CellSeed<NLayers>> trackSeeds(this->getMemoryPool().get());
     for (int startLayer{this->mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= minimumLayer; --startLayer) {
       if ((this->mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
       }
-      processNeighboursHandler<nLayers>(startLayer,
+      processNeighboursHandler<NLayers>(startLayer,
                                         startLevel,
                                         mTimeFrameGPU->getDeviceArrayCells(),
                                         mTimeFrameGPU->getDeviceCells()[startLayer],
@@ -389,29 +381,28 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
         continue;
       }
 
-      std::array<int, 3> rofs{INT_MAX, INT_MAX, INT_MAX};
+      bool firstCls{true};
+      TimeEstBC ts;
       for (int iLayer{0}; iLayer < this->mTrkParams[0].NLayers; ++iLayer) {
         if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
           continue;
         }
         mTimeFrameGPU->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
         int currentROF = mTimeFrameGPU->getClusterROF(iLayer, track.getClusterIndex(iLayer));
-        for (int iR{0}; iR < 3; ++iR) {
-          if (rofs[iR] == INT_MAX) {
-            rofs[iR] = currentROF;
-          }
-          if (rofs[iR] == currentROF) {
-            break;
+        auto rofTS = mTimeFrameGPU->getROFOverlapTableView().getLayer(iLayer).getROFTimeBounds(currentROF, true);
+        if (firstCls) {
+          ts = rofTS;
+        } else {
+          if (!ts.isCompatible(rofTS)) {
+            LOGP(fatal, "TS {}+/-{} are incompatible with {}+/-{}, this should not happen!", rofTS.getTimeStamp(), rofTS.getTimeStampError(), ts.getTimeStamp(), ts.getTimeStampError());
           }
+          ts += rofTS;
         }
       }
-      if (rofs[2] != INT_MAX) {
-        continue;
-      }
-      if (rofs[1] != INT_MAX) {
-        track.setNextROFbit();
-      }
-      mTimeFrameGPU->getTracks(std::min(rofs[0], rofs[1])).emplace_back(track);
+      track.getTimeStamp() = ts.makeSymmetrical();
+      track.setUserField(0);
+      track.getParamOut().setUserField(0);
+      mTimeFrameGPU->getTracks().emplace_back(track);
     }
     mTimeFrameGPU->loadUsedClustersDevice();
   }
@@ -419,26 +410,26 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
   mTimeFrameGPU->popMemoryStack(iteration);
 };
 
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfClusters() const
+template <int NLayers>
+int TrackerTraitsGPU<NLayers>::getTFNumberOfClusters() const
 {
   return mTimeFrameGPU->getNumberOfClusters();
 }
 
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfTracklets() const
+template <int NLayers>
+int TrackerTraitsGPU<NLayers>::getTFNumberOfTracklets() const
 {
   return std::accumulate(mTimeFrameGPU->getNTracklets().begin(), mTimeFrameGPU->getNTracklets().end(), 0);
 }
 
-template <int nLayers>
-int TrackerTraitsGPU<nLayers>::getTFNumberOfCells() const
+template <int NLayers>
+int TrackerTraitsGPU<NLayers>::getTFNumberOfCells() const
 {
   return mTimeFrameGPU->getNumberOfCells();
 }
 
-template <int nLayers>
-void TrackerTraitsGPU<nLayers>::setBz(float bz)
+template <int NLayers>
+void TrackerTraitsGPU<NLayers>::setBz(float bz)
 {
   this->mBz = bz;
   mTimeFrameGPU->setBz(bz);
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 525b37eb52891..795b568f6174d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -162,8 +162,8 @@ GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
   return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
 }
 
-template <int nLayers>
-GPUdii() TrackITSExt seedTrackForRefit(const CellSeed<nLayers>& seed,
+template <int NLayers>
+GPUdii() TrackITSExt seedTrackForRefit(const CellSeed<NLayers>& seed,
                                        const TrackingFrameInfo** foundTrackingFrameInfo,
                                        const Cluster** unsortedClusters,
                                        const float* layerRadii,
@@ -171,8 +171,8 @@ GPUdii() TrackITSExt seedTrackForRefit(const CellSeed<nLayers>& seed,
                                        const int reseedIfShorter)
 {
   TrackITSExt temporaryTrack(seed);
-  int lrMin = nLayers, lrMax = 0, lrMid = 0;
-  for (int iL{0}; iL < nLayers; ++iL) {
+  int lrMin = NLayers, lrMax = 0, lrMid = 0;
+  for (int iL{0}; iL < NLayers; ++iL) {
     const int idx = seed.getCluster(iL);
     temporaryTrack.setExternalClusterIndex(iL, idx, idx != constants::UnusedIndex);
     if (idx != constants::UnusedIndex) {
@@ -183,9 +183,9 @@ GPUdii() TrackITSExt seedTrackForRefit(const CellSeed<nLayers>& seed,
   }
   const int ncl = temporaryTrack.getNClusters();
   if (ncl < reseedIfShorter && ncl > 0) { // need to check if there are any clusters since we keep invalidate seeeds around
-    if (ncl == nLayers) {
+    if (ncl == NLayers) {
       lrMin = 0;
-      lrMax = nLayers - 1;
+      lrMax = NLayers - 1;
       lrMid = (lrMin + lrMax) / 2;
     } else {
       lrMid = lrMin + 1;
@@ -259,13 +259,13 @@ struct is_valid_pair {
   }
 };
 
-template <int nLayers>
+template <int NLayers>
 struct seed_selector {
   float maxQ2Pt;
   float maxChi2;
 
   GPUhd() seed_selector(float maxQ2Pt, float maxChi2) : maxQ2Pt(maxQ2Pt), maxChi2(maxChi2) {}
-  GPUhd() bool operator()(const CellSeed<nLayers>& seed) const
+  GPUhd() bool operator()(const CellSeed<NLayers>& seed) const
   {
     return !(seed.getQ2Pt() > maxQ2Pt || seed.getChi2() > maxChi2);
   }
@@ -278,9 +278,9 @@ struct compare_track_chi2 {
   }
 };
 
-template <bool initRun, int nLayers>
+template <bool initRun, int NLayers>
 GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
-  CellSeed<nLayers>* trackSeeds,
+  CellSeed<NLayers>* trackSeeds,
   const TrackingFrameInfo** foundTrackingFrameInfo,
   const Cluster** unsortedClusters,
   o2::its::TrackITSExt* tracks,
@@ -306,11 +306,11 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
       }
     }
 
-    TrackITSExt temporaryTrack = seedTrackForRefit<nLayers>(trackSeeds[iCurrentTrackSeedIndex], foundTrackingFrameInfo, unsortedClusters, layerRadii, bz, reseedIfShorter);
+    TrackITSExt temporaryTrack = seedTrackForRefit<NLayers>(trackSeeds[iCurrentTrackSeedIndex], foundTrackingFrameInfo, unsortedClusters, layerRadii, bz, reseedIfShorter);
     o2::track::TrackPar linRef{temporaryTrack};
     bool fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
                                0,                            // int lastLayer,
-                               nLayers,                      // int firstLayer,
+                               NLayers,                      // int firstLayer,
                                1,                            // int firstCluster,
                                maxChi2ClusterAttachment,     // float maxChi2ClusterAttachment,
                                maxChi2NDF,                   // float maxChi2NDF,
@@ -331,7 +331,7 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
     temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
     temporaryTrack.setChi2(0);
     fitSuccess = fitTrack(temporaryTrack,           // TrackITSExt& track,
-                          nLayers - 1,              // int lastLayer,
+                          NLayers - 1,              // int lastLayer,
                           -1,                       // int firstLayer,
                           -1,                       // int firstCluster,
                           maxChi2ClusterAttachment, // float maxChi2ClusterAttachment,
@@ -344,7 +344,7 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
                           matCorrType,              // o2::base::PropagatorF::MatCorrType matCorrType
                           &linRef,
                           shifRefToCluster);
-    if (!fitSuccess || temporaryTrack.getPt() < minPts[nLayers - temporaryTrack.getNClusters()]) {
+    if (!fitSuccess || temporaryTrack.getPt() < minPts[NLayers - temporaryTrack.getNClusters()]) {
       continue;
     }
     if (repeatRefitOut) { // repeat outward refit seeding and linearizing with the stable inward fit result
@@ -356,7 +356,7 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
       temporaryTrack.setChi2(0);
       fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
                             0,                            // int lastLayer,
-                            nLayers,                      // int firstLayer,
+                            NLayers,                      // int firstLayer,
                             1,                            // int firstCluster,
                             maxChi2ClusterAttachment,     // float maxChi2ClusterAttachment,
                             maxChi2NDF,                   // float maxChi2NDF,
@@ -384,15 +384,14 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   }
 }
 
-template <bool initRun, int nLayers = 7>
+template <bool initRun, int NLayers = 7>
 GPUg() void __launch_bounds__(256, 1) computeLayerCellNeighboursKernel(
-  CellSeed<nLayers>** cellSeedArray,
+  CellSeed<NLayers>** cellSeedArray,
   int* neighboursLUT,
   int* neighboursIndexTable,
   int** cellsLUTs,
   gpuPair<int, int>* cellNeighbours,
   const Tracklet** tracklets,
-  const int deltaROF,
   const float maxChi2ClusterAttachment,
   const float bz,
   const int layerIndex,
@@ -411,30 +410,18 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellNeighboursKernel(
     const int nextLayerLastCellIndex{cellsLUTs[layerIndex + 1][nextLayerTrackletIndex + 1]};
     int foundNeighbours{0};
     for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
-      auto nextCellSeed{cellSeedArray[layerIndex + 1][iNextCell]};          // Copy
-      if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) { // Check if cells share the same tracklet
+      auto nextCellSeed{cellSeedArray[layerIndex + 1][iNextCell]}; // Copy
+      if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex || !currentCellSeed.getTimeStamp().isCompatible(nextCellSeed.getTimeStamp())) {
         break;
       }
 
-      if (deltaROF) {
-        const auto& trkl00 = tracklets[layerIndex][currentCellSeed.getFirstTrackletIndex()];
-        const auto& trkl01 = tracklets[layerIndex + 1][currentCellSeed.getSecondTrackletIndex()];
-        const auto& trkl10 = tracklets[layerIndex + 1][nextCellSeed.getFirstTrackletIndex()];
-        const auto& trkl11 = tracklets[layerIndex + 2][nextCellSeed.getSecondTrackletIndex()];
-        if ((o2::gpu::CAMath::Max(trkl00.getMaxRof(), o2::gpu::CAMath::Max(trkl01.getMaxRof(), o2::gpu::CAMath::Max(trkl10.getMaxRof(), trkl11.getMaxRof()))) -
-             o2::gpu::CAMath::Min(trkl00.getMinRof(), o2::gpu::CAMath::Min(trkl01.getMinRof(), o2::gpu::CAMath::Min(trkl10.getMinRof(), trkl11.getMinRof())))) > deltaROF) {
-          continue;
-        }
-      }
-
       if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
           !nextCellSeed.propagateTo(currentCellSeed.getX(), bz)) {
         continue;
       }
 
       float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed);
-      if (chi2 > maxChi2ClusterAttachment) /// TODO: switch to the chi2 wrt cluster to avoid correlation
-      {
+      if (chi2 > maxChi2ClusterAttachment) {
         continue;
       }
 
@@ -453,7 +440,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellNeighboursKernel(
   }
 }
 
-template <bool initRun, int nLayers>
+template <bool initRun, int NLayers>
 GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
   const Cluster** sortedClusters,
   const Cluster** unsortedClusters,
@@ -462,9 +449,8 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
   int** trackletsLUT,
   const int nTrackletsCurrent,
   const int layer,
-  CellSeed<nLayers>* cells,
+  CellSeed<NLayers>* cells,
   int** cellsLUTs,
-  const int deltaROF,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
@@ -490,7 +476,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
         break;
       }
       const Tracklet& nextTracklet = tracklets[layer + 1][iNextTrackletIndex];
-      if (deltaROF && currentTracklet.getSpanRof(nextTracklet) > deltaROF) {
+      if (!currentTracklet.getTimeStamp().isCompatible(nextTracklet.getTimeStamp())) {
         continue;
       }
       const float deltaTanLambda{o2::gpu::CAMath::Abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
@@ -534,7 +520,9 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
           continue;
         }
         if constexpr (!initRun) {
-          new (cells + cellsLUTs[layer][iCurrentTrackletIndex] + foundCells) CellSeed<nLayers>{layer, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2};
+          TimeEstBC ts = currentTracklet.getTimeStamp();
+          ts += nextTracklet.getTimeStamp();
+          new (cells + cellsLUTs[layer][iCurrentTrackletIndex] + foundCells) CellSeed<NLayers>{layer, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2, ts};
         }
         ++foundCells;
       }
@@ -545,24 +533,21 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
   }
 }
 
-template <bool initRun, int nLayers>
+template <bool initRun, int NLayers>
 GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
-  const IndexTableUtils<nLayers>* utils,
-  const uint8_t* multMask,
+  const IndexTableUtils<NLayers>* utils,
+  const typename ROFMaskTable<NLayers>::View rofMask,
   const int layerIndex,
-  const int startROF,
-  const int endROF,
-  const int totalROFs,
-  const int deltaROF,
+  const typename ROFOverlapTable<NLayers>::View rofOverlaps,
+  const typename ROFVertexLookupTable<NLayers>::View vertexLUT,
   const Vertex* vertices,
   const int* rofPV,
-  const int nVertices,
   const int vertexId,
-  const Cluster** clusters,           // Input data rof0
-  const int** ROFClusters,            // Number of clusters on layers per ROF
-  const unsigned char** usedClusters, // Used clusters
-  const int** indexTables,            // Input data rof0-delta <rof0< rof0+delta (up to 3 rofs)
-  Tracklet** tracklets,               // Output data
+  const Cluster** clusters,
+  const int** ROFClusters,
+  const unsigned char** usedClusters,
+  const int** indexTables,
+  Tracklet** tracklets,
   int** trackletsLUT,
   const int iteration,
   const float NSigmaCut,
@@ -571,27 +556,36 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
   const float minR,
   const float maxR,
   const float positionResolution,
-  const float meanDeltaR = -42.f,
-  const float MSAngle = -42.f)
+  const float meanDeltaR,
+  const float MSAngle)
 {
   const int phiBins{utils->getNphiBins()};
   const int zBins{utils->getNzBins()};
   const int tableSize{phiBins * zBins + 1};
-  for (unsigned int iROF{blockIdx.x}; iROF < endROF - startROF; iROF += gridDim.x) {
-    const short pivotROF = iROF + startROF;
-    const short minROF = o2::gpu::CAMath::Max(startROF, static_cast<int>(pivotROF - deltaROF));
-    const short maxROF = o2::gpu::CAMath::Min(endROF - 1, static_cast<int>(pivotROF + deltaROF));
-    auto primaryVertices = getPrimaryVertices(minROF, maxROF, rofPV, totalROFs, vertices);
+  const int totalROFs0 = rofOverlaps.getLayer(layerIndex).mNROFsTF;
+  const int totalROFs1 = rofOverlaps.getLayer(layerIndex + 1).mNROFsTF;
+  for (unsigned int pivotROF{blockIdx.x}; pivotROF < totalROFs0; pivotROF += gridDim.x) {
+    if (!rofMask.isROFEnabled(layerIndex, pivotROF)) {
+      continue;
+    }
+
+    const auto& pvs = vertexLUT.getVertices(layerIndex, pivotROF);
+    auto primaryVertices = gpuSpan<const Vertex>(&vertices[pvs.getFirstEntry()], pvs.getEntries());
     if (primaryVertices.empty()) {
       continue;
     }
     const auto startVtx{vertexId >= 0 ? vertexId : 0};
     const auto endVtx{vertexId >= 0 ? o2::gpu::CAMath::Min(vertexId + 1, static_cast<int>(primaryVertices.size())) : static_cast<int>(primaryVertices.size())};
-    if ((endVtx - startVtx) <= 0) {
+    if (endVtx <= startVtx || (vertexId + 1) > primaryVertices.size()) {
+      continue;
+    }
+
+    const auto& rofOverlap = rofOverlaps.getOverlap(layerIndex, layerIndex + 1, pivotROF);
+    if (!rofOverlap.getEntries()) {
       continue;
     }
 
-    auto clustersCurrentLayer = getClustersOnLayer(pivotROF, totalROFs, layerIndex, ROFClusters, clusters);
+    auto clustersCurrentLayer = getClustersOnLayer(pivotROF, totalROFs0, layerIndex, ROFClusters, clusters);
     if (clustersCurrentLayer.empty()) {
       continue;
     }
@@ -613,6 +607,9 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
       const float inverseR0{1.f / currentCluster.radius};
       for (int iV{startVtx}; iV < endVtx; ++iV) {
         auto& primaryVertex{primaryVertices[iV]};
+        if (!vertexLUT.isVertexCompatible(layerIndex, pivotROF, primaryVertex)) {
+          continue;
+        }
         if ((primaryVertex.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) || (iteration == 3 && !primaryVertex.isFlagSet(Vertex::Flags::UPCMode))) {
           continue;
         }
@@ -623,7 +620,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
         const float zAtRmax{tanLambda * (maxR - currentCluster.radius) + currentCluster.zCoordinate};
         const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + constants::Tolerance)}; /// protecting from overflows adding the detector resolution
         const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * MSAngle))};
-        const int4 selectedBinsRect{getBinsRect<nLayers>(currentCluster, layerIndex + 1, utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
+        const int4 selectedBinsRect{getBinsRect<NLayers>(currentCluster, layerIndex + 1, utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
         if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
           continue;
         }
@@ -633,11 +630,18 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
           phiBinsNum += phiBins;
         }
 
-        for (short targetROF{minROF}; targetROF <= maxROF; ++targetROF) {
-          auto clustersNextLayer = getClustersOnLayer(targetROF, totalROFs, layerIndex + 1, ROFClusters, clusters);
+        for (short targetROF = rofOverlap.getFirstEntry(); targetROF < rofOverlap.getEntriesBound(); ++targetROF) {
+          if (!rofMask.isROFEnabled(layerIndex + 1, pivotROF)) {
+            continue;
+          }
+          auto clustersNextLayer = getClustersOnLayer(targetROF, totalROFs1, layerIndex + 1, ROFClusters, clusters);
           if (clustersNextLayer.empty()) {
             continue;
           }
+          const auto ts = rofOverlaps.getTimeStamp(layerIndex, pivotROF, layerIndex + 1, targetROF);
+          if (!ts.isCompatible(primaryVertex.getTimeStamp())) {
+            continue;
+          }
           for (int iPhiCount{0}; iPhiCount < phiBinsNum; iPhiCount++) {
             int iPhiBin = (selectedBinsRect.y + iPhiCount) % phiBins;
             const int firstBinIndex{utils->getBinIndex(selectedBinsRect.x, iPhiBin)};
@@ -661,7 +665,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
                   const float phi{o2::gpu::CAMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate)};
                   const float tanL{(currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius)};
                   const int nextSortedIndex{ROFClusters[layerIndex + 1][targetROF] + nextClusterIndex};
-                  new (tracklets[layerIndex] + trackletsLUT[layerIndex][currentSortedIndex] + storedTracklets) Tracklet{currentSortedIndex, nextSortedIndex, tanL, phi, pivotROF, targetROF};
+                  new (tracklets[layerIndex] + trackletsLUT[layerIndex][currentSortedIndex] + storedTracklets) Tracklet{currentSortedIndex, nextSortedIndex, tanL, phi, ts};
                 }
                 ++storedTracklets;
               }
@@ -683,15 +687,15 @@ GPUg() void __launch_bounds__(256, 1) compileTrackletsLookupTableKernel(
   }
 }
 
-template <bool dryRun, int nLayers = 7>
+template <bool dryRun, int NLayers = 7>
 GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
   const int layer,
   const int level,
-  CellSeed<nLayers>** allCellSeeds,
-  CellSeed<nLayers>* currentCellSeeds,
+  CellSeed<NLayers>** allCellSeeds,
+  CellSeed<NLayers>* currentCellSeeds,
   const int* currentCellIds,
   const unsigned int nCurrentCells,
-  CellSeed<nLayers>* updatedCellSeeds,
+  CellSeed<NLayers>* updatedCellSeeds,
   int* updatedCellsIds,
   int* foundSeedsTable,               // auxiliary only in GPU code to compute the number of cells per iteration
   const unsigned char** usedClusters, // Used clusters
@@ -732,12 +736,15 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
       if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
         continue;
       }
-      if (usedClusters[layer - 1][neighbourCell.getFirstClusterIndex()]) {
+      if (!currentCell.getTimeStamp().isCompatible(neighbourCell.getTimeStamp())) {
         continue;
       }
       if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
         continue;
       }
+      if (usedClusters[layer - 1][neighbourCell.getFirstClusterIndex()]) {
+        continue;
+      }
       auto seed{currentCell};
       auto& trHit = foundTrackingFrameInfo[layer - 1][neighbourCell.getFirstClusterIndex()];
 
@@ -780,18 +787,15 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
 
 } // namespace gpu
 
-template <int nLayers>
-void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
-                                 const uint8_t* multMask,
+template <int NLayers>
+void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
+                                 const typename ROFMaskTable<NLayers>::View& rofMask,
                                  const int layer,
-                                 const int startROF,
-                                 const int endROF,
-                                 const int maxROF,
-                                 const int deltaROF,
+                                 const typename ROFOverlapTable<NLayers>::View& rofOverlaps,
+                                 const typename ROFVertexLookupTable<NLayers>::View& vertexLUT,
                                  const int vertexId,
                                  const Vertex* vertices,
                                  const int* rofPV,
-                                 const int nVertices,
                                  const Cluster** clusters,
                                  std::vector<unsigned int> nClusters,
                                  const int** ROFClusters,
@@ -803,8 +807,8 @@ void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                  const float NSigmaCut,
                                  bounded_vector<float>& phiCuts,
                                  const float resolutionPV,
-                                 std::array<float, nLayers>& minRs,
-                                 std::array<float, nLayers>& maxRs,
+                                 std::array<float, NLayers>& minRs,
+                                 std::array<float, NLayers>& maxRs,
                                  bounded_vector<float>& resolutions,
                                  std::vector<float>& radii,
                                  bounded_vector<float>& mulScatAng,
@@ -815,15 +819,12 @@ void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
 {
   gpu::computeLayerTrackletsMultiROFKernel<true><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
     utils,
-    multMask,
+    rofMask,
     layer,
-    startROF,
-    endROF,
-    maxROF,
-    deltaROF,
+    rofOverlaps,
+    vertexLUT,
     vertices,
     rofPV,
-    nVertices,
     vertexId,
     clusters,
     ROFClusters,
@@ -844,18 +845,15 @@ void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
   thrust::exclusive_scan(nosync_policy, trackletsLUTsHost[layer], trackletsLUTsHost[layer] + nClusters[layer] + 1, trackletsLUTsHost[layer]);
 }
 
-template <int nLayers>
-void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
-                                   const uint8_t* multMask,
+template <int NLayers>
+void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
+                                   const typename ROFMaskTable<NLayers>::View& rofMask,
                                    const int layer,
-                                   const int startROF,
-                                   const int endROF,
-                                   const int maxROF,
-                                   const int deltaROF,
+                                   const typename ROFOverlapTable<NLayers>::View& rofOverlaps,
+                                   const typename ROFVertexLookupTable<NLayers>::View& vertexLUT,
                                    const int vertexId,
                                    const Vertex* vertices,
                                    const int* rofPV,
-                                   const int nVertices,
                                    const Cluster** clusters,
                                    std::vector<unsigned int> nClusters,
                                    const int** ROFClusters,
@@ -870,8 +868,8 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
                                    const float NSigmaCut,
                                    bounded_vector<float>& phiCuts,
                                    const float resolutionPV,
-                                   std::array<float, nLayers>& minRs,
-                                   std::array<float, nLayers>& maxRs,
+                                   std::array<float, NLayers>& minRs,
+                                   std::array<float, NLayers>& maxRs,
                                    bounded_vector<float>& resolutions,
                                    std::vector<float>& radii,
                                    bounded_vector<float>& mulScatAng,
@@ -882,15 +880,12 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
 {
   gpu::computeLayerTrackletsMultiROFKernel<false><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
     utils,
-    multMask,
+    rofMask,
     layer,
-    startROF,
-    endROF,
-    maxROF,
-    deltaROF,
+    rofOverlaps,
+    vertexLUT,
     vertices,
     rofPV,
-    nVertices,
     vertexId,
     clusters,
     ROFClusters,
@@ -922,7 +917,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* utils,
   }
 }
 
-template <int nLayers>
+template <int NLayers>
 void countCellsHandler(
   const Cluster** sortedClusters,
   const Cluster** unsortedClusters,
@@ -931,10 +926,9 @@ void countCellsHandler(
   int** trackletsLUT,
   const int nTracklets,
   const int layer,
-  CellSeed<nLayers>* cells,
+  CellSeed<NLayers>* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
-  const int deltaROF,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
@@ -954,7 +948,6 @@ void countCellsHandler(
     layer,                    // const int
     cells,                    // CellSeed*
     cellsLUTsArrayDevice,     // int**
-    deltaROF,                 // const int
     bz,                       // const float
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
@@ -963,7 +956,7 @@ void countCellsHandler(
   thrust::exclusive_scan(nosync_policy, cellsLUTsHost, cellsLUTsHost + nTracklets + 1, cellsLUTsHost);
 }
 
-template <int nLayers>
+template <int NLayers>
 void computeCellsHandler(
   const Cluster** sortedClusters,
   const Cluster** unsortedClusters,
@@ -972,10 +965,9 @@ void computeCellsHandler(
   int** trackletsLUT,
   const int nTracklets,
   const int layer,
-  CellSeed<nLayers>* cells,
+  CellSeed<NLayers>* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
-  const int deltaROF,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
@@ -994,21 +986,19 @@ void computeCellsHandler(
     layer,                    // const int
     cells,                    // CellSeed*
     cellsLUTsArrayDevice,     // int**
-    deltaROF,                 // const int
     bz,                       // const float
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
     nSigmaCut);               // const float
 }
 
-template <int nLayers>
-void countCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
+template <int NLayers>
+void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                 int* neighboursLUT,
                                 int** cellsLUTs,
                                 gpuPair<int, int>* cellNeighbours,
                                 int* neighboursIndexTable,
                                 const Tracklet** tracklets,
-                                const int deltaROF,
                                 const float maxChi2ClusterAttachment,
                                 const float bz,
                                 const int layerIndex,
@@ -1027,7 +1017,6 @@ void countCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
     cellsLUTs,
     cellNeighbours,
     tracklets,
-    deltaROF,
     maxChi2ClusterAttachment,
     bz,
     layerIndex,
@@ -1038,14 +1027,13 @@ void countCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
   thrust::exclusive_scan(nosync_policy, neighboursIndexTable, neighboursIndexTable + nCells + 1, neighboursIndexTable);
 }
 
-template <int nLayers>
-void computeCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
+template <int NLayers>
+void computeCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                   int* neighboursLUT,
                                   int** cellsLUTs,
                                   gpuPair<int, int>* cellNeighbours,
                                   int* neighboursIndexTable,
                                   const Tracklet** tracklets,
-                                  const int deltaROF,
                                   const float maxChi2ClusterAttachment,
                                   const float bz,
                                   const int layerIndex,
@@ -1063,7 +1051,6 @@ void computeCellNeighboursHandler(CellSeed<nLayers>** cellsLayersDevice,
     cellsLUTs,
     cellNeighbours,
     tracklets,
-    deltaROF,
     maxChi2ClusterAttachment,
     bz,
     layerIndex,
@@ -1087,17 +1074,17 @@ int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
   return newSize;
 }
 
-template <int nLayers>
+template <int NLayers>
 void processNeighboursHandler(const int startLayer,
                               const int startLevel,
-                              CellSeed<nLayers>** allCellSeeds,
-                              CellSeed<nLayers>* currentCellSeeds,
-                              std::array<int, nLayers - 2>& nCells,
+                              CellSeed<NLayers>** allCellSeeds,
+                              CellSeed<NLayers>* currentCellSeeds,
+                              std::array<int, NLayers - 2>& nCells,
                               const unsigned char** usedClusters,
-                              std::array<int*, nLayers - 2>& neighbours,
+                              std::array<int*, NLayers - 2>& neighbours,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                              bounded_vector<CellSeed<nLayers>>& seedsHost,
+                              bounded_vector<CellSeed<NLayers>>& seedsHost,
                               const float bz,
                               const float maxChi2ClusterAttachment,
                               const float maxChi2NDF,
@@ -1110,11 +1097,11 @@ void processNeighboursHandler(const int startLayer,
   constexpr uint64_t Tag = qStr2Tag("ITS_PNH1");
   alloc->pushTagOnStack(Tag);
   auto allocInt = gpu::TypedAllocator<int>(alloc);
-  auto allocCellSeed = gpu::TypedAllocator<CellSeed<nLayers>>(alloc);
+  auto allocCellSeed = gpu::TypedAllocator<CellSeed<NLayers>>(alloc);
   thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
   auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(gpu::Stream::DefaultStream);
 
-  gpu::processNeighboursKernel<true, nLayers><<<nBlocks, nThreads>>>(
+  gpu::processNeighboursKernel<true, NLayers><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1135,8 +1122,8 @@ void processNeighboursHandler(const int startLayer,
   thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
 
   thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
-  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
-  gpu::processNeighboursKernel<false, nLayers><<<nBlocks, nThreads>>>(
+  thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
+  gpu::processNeighboursKernel<false, NLayers><<<nBlocks, nThreads>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1158,17 +1145,17 @@ void processNeighboursHandler(const int startLayer,
 
   int level = startLevel;
   thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
-  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> lastCellSeed(allocCellSeed);
+  thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>> lastCellSeed(allocCellSeed);
   for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
     lastCellSeed.swap(updatedCellSeed);
     lastCellId.swap(updatedCellId);
-    thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>>(allocCellSeed).swap(updatedCellSeed);
+    thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>>(allocCellSeed).swap(updatedCellSeed);
     thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellId);
     auto lastCellSeedSize{lastCellSeed.size()};
     foundSeedsTable.resize(lastCellSeedSize + 1);
     thrust::fill(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
-    gpu::processNeighboursKernel<true, nLayers><<<nBlocks, nThreads>>>(
+    gpu::processNeighboursKernel<true, NLayers><<<nBlocks, nThreads>>>(
       iLayer,
       --level,
       allCellSeeds,
@@ -1192,9 +1179,9 @@ void processNeighboursHandler(const int startLayer,
     updatedCellId.resize(foundSeeds);
     thrust::fill(nosync_policy, updatedCellId.begin(), updatedCellId.end(), 0);
     updatedCellSeed.resize(foundSeeds);
-    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed<nLayers>());
+    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed<NLayers>());
 
-    gpu::processNeighboursKernel<false, nLayers><<<nBlocks, nThreads>>>(
+    gpu::processNeighboursKernel<false, NLayers><<<nBlocks, nThreads>>>(
       iLayer,
       level,
       allCellSeeds,
@@ -1214,16 +1201,16 @@ void processNeighboursHandler(const int startLayer,
       matCorrType);
   }
   GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
-  thrust::device_vector<CellSeed<nLayers>, gpu::TypedAllocator<CellSeed<nLayers>>> outSeeds(updatedCellSeed.size(), allocCellSeed);
-  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector<nLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
+  thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>> outSeeds(updatedCellSeed.size(), allocCellSeed);
+  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector<NLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
   auto s{end - outSeeds.begin()};
   seedsHost.reserve(seedsHost.size() + s);
   thrust::copy(outSeeds.begin(), outSeeds.begin() + s, std::back_inserter(seedsHost));
   alloc->popTagOffStack(Tag);
 }
 
-template <int nLayers>
-void countTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
+template <int NLayers>
+void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                            const TrackingFrameInfo** foundTrackingFrameInfo,
                            const Cluster** unsortedClusters,
                            int* seedLUT,
@@ -1248,7 +1235,7 @@ void countTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
   // small transferes!
   thrust::device_vector<float> minPts(minPtsHost);
   thrust::device_vector<float> layerRadii(layerRadiiHost);
-  gpu::fitTrackSeedsKernel<true, nLayers><<<nBlocks, nThreads>>>(
+  gpu::fitTrackSeedsKernel<true, NLayers><<<nBlocks, nThreads>>>(
     trackSeeds,                               // CellSeed*
     foundTrackingFrameInfo,                   // TrackingFrameInfo**
     unsortedClusters,                         // Cluster**
@@ -1270,8 +1257,8 @@ void countTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
   thrust::exclusive_scan(sync_policy, seedLUT, seedLUT + nSeeds + 1, seedLUT);
 }
 
-template <int nLayers>
-void computeTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
+template <int NLayers>
+void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                              const TrackingFrameInfo** foundTrackingFrameInfo,
                              const Cluster** unsortedClusters,
                              o2::its::TrackITSExt* tracks,
@@ -1295,7 +1282,7 @@ void computeTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
 {
   thrust::device_vector<float> minPts(minPtsHost);
   thrust::device_vector<float> layerRadii(layerRadiiHost);
-  gpu::fitTrackSeedsKernel<false, nLayers><<<nBlocks, nThreads>>>(
+  gpu::fitTrackSeedsKernel<false, NLayers><<<nBlocks, nThreads>>>(
     trackSeeds,                               // CellSeed*
     foundTrackingFrameInfo,                   // TrackingFrameInfo**
     unsortedClusters,                         // Cluster**
@@ -1320,16 +1307,13 @@ void computeTrackSeedHandler(CellSeed<nLayers>* trackSeeds,
 
 /// Explicit instantiation of ITS2 handlers
 template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
-                                             const uint8_t* multMask,
+                                             const ROFMaskTable<7>::View& rofMask,
                                              const int layer,
-                                             const int startROF,
-                                             const int endROF,
-                                             const int maxROF,
-                                             const int deltaROF,
+                                             const ROFOverlapTable<7>::View& rofOverlaps,
+                                             const ROFVertexLookupTable<7>::View& vertexLUT,
                                              const int vertexId,
                                              const Vertex* vertices,
                                              const int* rofPV,
-                                             const int nVertices,
                                              const Cluster** clusters,
                                              std::vector<unsigned int> nClusters,
                                              const int** ROFClusters,
@@ -1352,16 +1336,13 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                              gpu::Streams& streams);
 
 template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
-                                               const uint8_t* multMask,
+                                               const ROFMaskTable<7>::View& rofMask,
                                                const int layer,
-                                               const int startROF,
-                                               const int endROF,
-                                               const int maxROF,
-                                               const int deltaROF,
+                                               const ROFOverlapTable<7>::View& rofOverlaps,
+                                               const ROFVertexLookupTable<7>::View& vertexLUT,
                                                const int vertexId,
                                                const Vertex* vertices,
                                                const int* rofPV,
-                                               const int nVertices,
                                                const Cluster** clusters,
                                                std::vector<unsigned int> nClusters,
                                                const int** ROFClusters,
@@ -1396,7 +1377,6 @@ template void countCellsHandler<7>(const Cluster** sortedClusters,
                                    CellSeed<7>* cells,
                                    int** cellsLUTsArrayDevice,
                                    int* cellsLUTsHost,
-                                   const int deltaROF,
                                    const float bz,
                                    const float maxChi2ClusterAttachment,
                                    const float cellDeltaTanLambdaSigma,
@@ -1416,7 +1396,6 @@ template void computeCellsHandler<7>(const Cluster** sortedClusters,
                                      CellSeed<7>* cells,
                                      int** cellsLUTsArrayDevice,
                                      int* cellsLUTsHost,
-                                     const int deltaROF,
                                      const float bz,
                                      const float maxChi2ClusterAttachment,
                                      const float cellDeltaTanLambdaSigma,
@@ -1431,7 +1410,6 @@ template void countCellNeighboursHandler<7>(CellSeed<7>** cellsLayersDevice,
                                             gpuPair<int, int>* cellNeighbours,
                                             int* neighboursIndexTable,
                                             const Tracklet** tracklets,
-                                            const int deltaROF,
                                             const float maxChi2ClusterAttachment,
                                             const float bz,
                                             const int layerIndex,
@@ -1449,7 +1427,6 @@ template void computeCellNeighboursHandler(CellSeed<7>** cellsLayersDevice,
                                            gpuPair<int, int>* cellNeighbours,
                                            int* neighboursIndexTable,
                                            const Tracklet** tracklets,
-                                           const int deltaROF,
                                            const float maxChi2ClusterAttachment,
                                            const float bz,
                                            const int layerIndex,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
deleted file mode 100644
index 658d3cf0dfb91..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexerTraitsGPU.cxx
+++ /dev/null
@@ -1,179 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-//
-/// \author matteo.concas@cern.ch
-
-#include <gsl/span>
-
-#include "ITStracking/TrackingConfigParam.h"
-#include "ITStrackingGPU/VertexingKernels.h"
-#include "ITStrackingGPU/VertexerTraitsGPU.h"
-
-namespace o2::its
-{
-
-template <int nLayers>
-void VertexerTraitsGPU<nLayers>::initialise(const TrackingParameters& trackingParams, const int iteration)
-{
-  // FIXME
-  // Two things to fix here:
-  // This loads all necessary data for this step at once, can be overlayed with computation
-  // Also if running with the tracker some data is loaded twice!
-  mTimeFrameGPU->initialise(0, trackingParams, 3, &this->mIndexTableUtils, &mTfGPUParams);
-
-  // FIXME some of these only need to be created once!
-  mTimeFrameGPU->loadIndexTableUtils(iteration);
-  mTimeFrameGPU->createUsedClustersDeviceArray(iteration, 3);
-  mTimeFrameGPU->createClustersDeviceArray(iteration, 3);
-  mTimeFrameGPU->createUnsortedClustersDeviceArray(iteration, 3);
-  mTimeFrameGPU->createClustersIndexTablesArray(iteration);
-  mTimeFrameGPU->createROFrameClustersDeviceArray(iteration);
-  for (int iLayer{0}; iLayer < 3; ++iLayer) {
-    mTimeFrameGPU->loadClustersDevice(iteration, iLayer);
-    mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer);
-    mTimeFrameGPU->loadClustersIndexTables(iteration, iLayer);
-    mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer);
-    mTimeFrameGPU->loadROFrameClustersDevice(iteration, iLayer);
-  }
-}
-
-template <int nLayers>
-void VertexerTraitsGPU<nLayers>::adoptTimeFrame(TimeFrame<nLayers>* tf) noexcept
-{
-  mTimeFrameGPU = static_cast<gpu::TimeFrameGPU<nLayers>*>(tf);
-  this->mTimeFrame = static_cast<TimeFrame<nLayers>*>(tf);
-}
-
-template <int nLayers>
-void VertexerTraitsGPU<nLayers>::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& tfPar)
-{
-  this->mVrtParams = vrtPar;
-  mTfGPUParams = tfPar;
-  this->mIndexTableUtils.setTrackingParameters(vrtPar[0]);
-  for (auto& par : this->mVrtParams) {
-    par.phiSpan = static_cast<int>(std::ceil(this->mIndexTableUtils.getNphiBins() * par.phiCut / o2::constants::math::TwoPI));
-    par.zSpan = static_cast<int>(std::ceil(par.zCut * this->mIndexTableUtils.getInverseZCoordinate(0)));
-  }
-}
-
-template <int nLayers>
-void VertexerTraitsGPU<nLayers>::computeTracklets(const int iteration)
-{
-  if (mTimeFrameGPU->getClusters().empty()) {
-    return;
-  }
-  const auto& conf = ITSGpuTrackingParamConfig::Instance();
-
-  mTimeFrameGPU->createVtxTrackletsLUTDevice(iteration);
-  countTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
-                                       mTimeFrameGPU->getDeviceMultCutMask(),
-                                       mTimeFrameGPU->getNrof(),
-                                       this->mVrtParams[iteration].deltaRof,
-                                       mTimeFrameGPU->getDeviceROFramesPV(),
-                                       this->mVrtParams[iteration].vertPerRofThreshold,
-                                       mTimeFrameGPU->getDeviceArrayClusters(),
-                                       mTimeFrameGPU->getClusterSizes()[1],
-                                       mTimeFrameGPU->getDeviceROFrameClusters(),
-                                       (const uint8_t**)mTimeFrameGPU->getDeviceArrayUsedClusters(),
-                                       mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
-                                       mTimeFrameGPU->getDeviceArrayNTrackletsPerCluster(),
-                                       mTimeFrameGPU->getDeviceArrayNTrackletsPerClusterSum(),
-                                       mTimeFrameGPU->getDeviceArrayNTrackletsPerROF(),
-                                       mTimeFrameGPU->getDeviceNTrackletsPerCluster(),
-                                       mTimeFrameGPU->getDeviceNTrackletsPerClusterSum(),
-                                       iteration,
-                                       this->mVrtParams[iteration].phiCut,
-                                       this->mVrtParams[iteration].maxTrackletsPerCluster,
-                                       conf.nBlocksVtxComputeTracklets[iteration],
-                                       conf.nThreadsVtxComputeTracklets[iteration],
-                                       mTimeFrameGPU->getStreams());
-  mTimeFrameGPU->createVtxTrackletsBuffers(iteration);
-  computeTrackletsInROFsHandler<nLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
-                                         mTimeFrameGPU->getDeviceMultCutMask(),
-                                         mTimeFrameGPU->getNrof(),
-                                         this->mVrtParams[iteration].deltaRof,
-                                         mTimeFrameGPU->getDeviceROFramesPV(),
-                                         this->mVrtParams[iteration].vertPerRofThreshold,
-                                         mTimeFrameGPU->getDeviceArrayClusters(),
-                                         mTimeFrameGPU->getClusterSizes()[1],
-                                         mTimeFrameGPU->getDeviceROFrameClusters(),
-                                         (const uint8_t**)mTimeFrameGPU->getDeviceArrayUsedClusters(),
-                                         mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
-                                         mTimeFrameGPU->getDeviceArrayTracklets(),
-                                         (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerCluster(),
-                                         (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerClusterSum(),
-                                         (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerROF(),
-                                         iteration,
-                                         this->mVrtParams[iteration].phiCut,
-                                         this->mVrtParams[iteration].maxTrackletsPerCluster,
-                                         conf.nBlocksVtxComputeTracklets[iteration],
-                                         conf.nThreadsVtxComputeTracklets[iteration],
-                                         mTimeFrameGPU->getStreams());
-}
-
-template <int nLayers>
-void VertexerTraitsGPU<nLayers>::computeTrackletMatching(const int iteration)
-{
-  if (!mTimeFrameGPU->getTotalTrackletsTF(0) || !mTimeFrameGPU->getTotalTrackletsTF(1)) {
-    return;
-  }
-
-  const auto& conf = ITSGpuTrackingParamConfig::Instance();
-  mTimeFrameGPU->createVtxLinesLUTDevice(iteration);
-  countTrackletsMatchingInROFsHandler(mTimeFrameGPU->getNrof(),
-                                      this->mVrtParams[iteration].deltaRof,
-                                      mTimeFrameGPU->getClusterSizes()[1],
-                                      mTimeFrameGPU->getDeviceROFrameClusters(),
-                                      mTimeFrameGPU->getDeviceArrayClusters(),
-                                      mTimeFrameGPU->getDeviceArrayUsedClusters(),
-                                      (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                                      mTimeFrameGPU->getDeviceUsedTracklets(),
-                                      (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerCluster(),
-                                      (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerClusterSum(),
-                                      mTimeFrameGPU->getDeviceNLinesPerCluster(),
-                                      mTimeFrameGPU->getDeviceNLinesPerClusterSum(),
-                                      iteration,
-                                      this->mVrtParams[iteration].phiCut,
-                                      this->mVrtParams[iteration].tanLambdaCut,
-                                      conf.nBlocksVtxComputeMatching[iteration],
-                                      conf.nThreadsVtxComputeMatching[iteration],
-                                      mTimeFrameGPU->getStreams());
-  mTimeFrameGPU->createVtxLinesBuffer(iteration);
-  computeTrackletsMatchingInROFsHandler(mTimeFrameGPU->getNrof(),
-                                        this->mVrtParams[iteration].deltaRof,
-                                        mTimeFrameGPU->getClusterSizes()[1],
-                                        mTimeFrameGPU->getDeviceROFrameClusters(),
-                                        mTimeFrameGPU->getDeviceArrayClusters(),
-                                        nullptr,
-                                        (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                                        mTimeFrameGPU->getDeviceUsedTracklets(),
-                                        (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerCluster(),
-                                        (const int32_t**)mTimeFrameGPU->getDeviceArrayNTrackletsPerClusterSum(),
-                                        (const int32_t*)mTimeFrameGPU->getDeviceNLinesPerClusterSum(),
-                                        mTimeFrameGPU->getDeviceLines(),
-                                        iteration,
-                                        this->mVrtParams[iteration].phiCut,
-                                        this->mVrtParams[iteration].tanLambdaCut,
-                                        conf.nBlocksVtxComputeMatching[iteration],
-                                        conf.nThreadsVtxComputeMatching[iteration],
-                                        mTimeFrameGPU->getStreams());
-}
-
-template <int nLayers>
-void VertexerTraitsGPU<nLayers>::computeVertices(const int iteration)
-{
-  LOGP(fatal, "This step is not implemented yet!");
-  mTimeFrameGPU->loadUsedClustersDevice();
-}
-
-template class VertexerTraitsGPU<7>;
-
-} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
deleted file mode 100644
index a2787bb13598d..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/VertexingKernels.cu
+++ /dev/null
@@ -1,660 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-
-#include <cuda_runtime.h>
-#include <cub/cub.cuh>
-
-#include "ITStrackingGPU/VertexingKernels.h"
-#include "ITStracking/Tracklet.h"
-#include "ITStracking/IndexTableUtils.h"
-#include "ITStracking/ClusterLines.h"
-
-#include "GPUCommonMath.h"
-#include "GPUCommonHelpers.h"
-#include "GPUCommonDef.h"
-
-namespace o2::its
-{
-
-namespace gpu
-{
-
-template <int nLayers, TrackletMode Mode, bool dryRun>
-GPUg() void computeLayerTrackletMutliROFKernel(const Cluster** GPUrestrict() clusters,
-                                               const int32_t** GPUrestrict() rofClusters,
-                                               const uint8_t** GPUrestrict() usedClusters,
-                                               const int32_t** GPUrestrict() clusterIndexTables,
-                                               const float phiCut,
-                                               maybe_const<dryRun, Tracklet>** GPUrestrict() tracklets,
-                                               maybe_const<!dryRun, int32_t>** GPUrestrict() trackletOffsets,
-                                               const IndexTableUtils<nLayers>* GPUrestrict() utils,
-                                               const int32_t nRofs,
-                                               const int32_t deltaRof,
-                                               const int32_t* GPUrestrict() rofPV,
-                                               const int32_t iteration,
-                                               const int32_t verPerRofThreshold,
-                                               const int32_t maxTrackletsPerCluster)
-{
-  constexpr int32_t iMode = (Mode == TrackletMode::Layer0Layer1) ? 0 : 1;
-  const int32_t phiBins(utils->getNphiBins());
-  const int32_t zBins(utils->getNzBins());
-  const int32_t tableSize{phiBins * zBins + 1};
-  extern __shared__ uint16_t storedTrackletsShared[]; // each deltaROF needs its own counters
-  uint16_t* storedTrackletsLocal = storedTrackletsShared + threadIdx.x * (2 * deltaRof + 1);
-  for (uint32_t pivotRofId{blockIdx.x}; pivotRofId < (uint32_t)nRofs; pivotRofId += gridDim.x) {
-    if (iteration && rofPV[pivotRofId] > verPerRofThreshold) {
-      continue;
-    }
-    const uint16_t startROF = o2::gpu::CAMath::Max(0, (int)pivotRofId - deltaRof);
-    const uint16_t endROF = o2::gpu::CAMath::Min(nRofs, (int)pivotRofId + deltaRof + 1);
-    const auto clustersCurrentLayer = getClustersOnLayer((int32_t)pivotRofId, nRofs, 1, rofClusters, clusters);
-    if (clustersCurrentLayer.empty()) {
-      continue;
-    }
-    auto trackletsPerCluster = getNTrackletsPerCluster(pivotRofId, nRofs, iMode, rofClusters, trackletOffsets);
-    for (uint32_t iCurrentLayerClusterIndex{threadIdx.x}; iCurrentLayerClusterIndex < (uint32_t)clustersCurrentLayer.size(); iCurrentLayerClusterIndex += blockDim.x) {
-      for (int16_t i{0}; i < (int16_t)((2 * deltaRof) + 1); ++i) {
-        storedTrackletsLocal[i] = 0;
-      }
-      const Cluster& GPUrestrict() currentCluster { clustersCurrentLayer[iCurrentLayerClusterIndex] };
-      const int4 selectedBinsRect{getBinsRect(currentCluster, (int)Mode, utils, 0.f, 0.f, 50.f, phiCut / 2)};
-      if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) {
-        int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
-        if (phiBinsNum < 0) {
-          phiBinsNum += phiBins;
-        }
-        for (int32_t iPhiBin{selectedBinsRect.y}, iPhiCount{0}; iPhiCount < phiBinsNum; iPhiBin = ++iPhiBin == phiBins ? 0 : iPhiBin, iPhiCount++) {
-          for (uint16_t targetRofId{startROF}; targetRofId < endROF; ++targetRofId) {
-            uint16_t& storedTracklets = storedTrackletsLocal[pivotRofId - targetRofId + deltaRof];
-            const int32_t firstBinIndex{utils->getBinIndex(selectedBinsRect.x, iPhiBin)};
-            const int32_t maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
-            const int32_t firstRowClusterIndex{clusterIndexTables[(int)Mode][(targetRofId)*tableSize + firstBinIndex]};
-            const int32_t maxRowClusterIndex{clusterIndexTables[(int)Mode][(targetRofId)*tableSize + maxBinIndex]};
-            auto clustersNextLayer = getClustersOnLayer((int32_t)targetRofId, nRofs, (int32_t)Mode, rofClusters, clusters);
-            if (clustersNextLayer.empty()) {
-              continue;
-            }
-            for (int32_t iNextLayerClusterIndex{firstRowClusterIndex}; iNextLayerClusterIndex < maxRowClusterIndex && iNextLayerClusterIndex < (int32_t)clustersNextLayer.size(); ++iNextLayerClusterIndex) {
-              if (iteration && usedClusters[(int32_t)Mode][iNextLayerClusterIndex]) {
-                continue;
-              }
-              const Cluster& GPUrestrict() nextCluster { clustersNextLayer[iNextLayerClusterIndex] };
-              if (o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(currentCluster.phi, nextCluster.phi)) < phiCut) {
-                if (storedTracklets < maxTrackletsPerCluster) {
-                  if constexpr (!dryRun) {
-                    if constexpr (Mode == TrackletMode::Layer0Layer1) {
-                      tracklets[0][trackletsPerCluster[iCurrentLayerClusterIndex] + storedTracklets] = Tracklet{iNextLayerClusterIndex, (int)iCurrentLayerClusterIndex, nextCluster, currentCluster, (short)targetRofId, (short)pivotRofId};
-                    } else {
-                      tracklets[1][trackletsPerCluster[iCurrentLayerClusterIndex] + storedTracklets] = Tracklet{(int)iCurrentLayerClusterIndex, iNextLayerClusterIndex, currentCluster, nextCluster, (short)pivotRofId, (short)targetRofId};
-                    }
-                  }
-                  ++storedTracklets;
-                }
-              }
-            }
-          }
-        }
-      }
-      if constexpr (dryRun) {
-        for (int32_t i{0}; i < (int32_t)((2 * deltaRof) + 1); ++i) {
-          trackletsPerCluster[iCurrentLayerClusterIndex] += storedTrackletsLocal[i];
-        }
-      }
-    }
-  }
-}
-
-template <bool dryRun>
-GPUg() void computeTrackletSelectionMutliROFKernel(const Cluster** GPUrestrict() clusters,
-                                                   maybe_const<!dryRun, uint8_t>** GPUrestrict() usedClusters,
-                                                   const int32_t** GPUrestrict() rofClusters,
-                                                   const float phiCut,
-                                                   const float tanLambdaCut,
-                                                   const Tracklet** GPUrestrict() tracklets,
-                                                   uint8_t* GPUrestrict() usedTracklets,
-                                                   const int32_t** GPUrestrict() trackletOffsets,
-                                                   const int32_t** GPUrestrict() trackletLUTs,
-                                                   maybe_const<!dryRun, int32_t>* lineOffsets,
-                                                   maybe_const<dryRun, Line>* GPUrestrict() lines,
-                                                   const int32_t nRofs,
-                                                   const int32_t deltaRof,
-                                                   const int32_t maxTracklets)
-{
-  for (uint32_t pivotRofId{blockIdx.x}; pivotRofId < nRofs; pivotRofId += gridDim.x) {
-    const int16_t startROF = o2::gpu::CAMath::Max(0, (int32_t)pivotRofId - deltaRof);
-    const int16_t endROF = o2::gpu::CAMath::Min(nRofs, (int32_t)pivotRofId + deltaRof + 1);
-
-    const uint32_t clusterOffset = rofClusters[1][pivotRofId];
-    const uint32_t nClustersCurrentLayer = rofClusters[1][pivotRofId + 1] - clusterOffset;
-    if (nClustersCurrentLayer <= 0) {
-      continue;
-    }
-
-    auto linesPerCluster = getNLinesPerCluster(pivotRofId, nRofs, rofClusters, lineOffsets);
-    auto nTrackletsPerCluster01 = getNTrackletsPerCluster(pivotRofId, nRofs, 0, rofClusters, trackletOffsets);
-    auto nTrackletsPerCluster12 = getNTrackletsPerCluster(pivotRofId, nRofs, 1, rofClusters, trackletOffsets);
-
-    for (uint32_t iCurrentLayerClusterIndex{threadIdx.x}; iCurrentLayerClusterIndex < nClustersCurrentLayer; iCurrentLayerClusterIndex += blockDim.x) {
-      int32_t validTracklets{0};
-      const int32_t nTracklets01 = nTrackletsPerCluster01[iCurrentLayerClusterIndex];
-      const int32_t nTracklets12 = nTrackletsPerCluster12[iCurrentLayerClusterIndex];
-      for (int32_t iTracklet12{0}; iTracklet12 < nTracklets12; ++iTracklet12) {
-        for (int32_t iTracklet01{0}; iTracklet01 < nTracklets01; ++iTracklet01) {
-
-          if (usedTracklets[trackletLUTs[0][clusterOffset + iCurrentLayerClusterIndex] + iTracklet01]) {
-            continue;
-          }
-
-          const auto& GPUrestrict() tracklet01 { tracklets[0][trackletLUTs[0][clusterOffset + iCurrentLayerClusterIndex] + iTracklet01] };
-          const auto& GPUrestrict() tracklet12 { tracklets[1][trackletLUTs[1][clusterOffset + iCurrentLayerClusterIndex] + iTracklet12] };
-          const int16_t rof0 = tracklet01.rof[0];
-          const int16_t rof2 = tracklet12.rof[1];
-          if (deltaRof > 0 && ((rof0 < startROF) || (rof0 >= endROF) || (rof2 < startROF) || (rof2 >= endROF) || (o2::gpu::CAMath::Abs(rof0 - rof2) > deltaRof))) {
-            continue;
-          }
-
-          const float deltaTanLambda{o2::gpu::GPUCommonMath::Abs(tracklet01.tanLambda - tracklet12.tanLambda)};
-          const float deltaPhi{o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(tracklet01.phi, tracklet12.phi))};
-          //
-          if (deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets < maxTracklets) {
-            // TODO use atomics to avoid race conditions for torn writes but is it needed here?
-            usedTracklets[trackletLUTs[0][clusterOffset + iCurrentLayerClusterIndex] + iTracklet01] = 1;
-            if constexpr (dryRun) {
-              usedClusters[0][rofClusters[0][rof0] + tracklet01.firstClusterIndex] = 1;
-              usedClusters[2][rofClusters[2][rof2] + tracklet12.secondClusterIndex] = 1;
-            } else {
-              const Cluster* clusters0 = clusters[0] + rofClusters[0][tracklet01.rof[0]];
-              const Cluster* clusters1 = clusters[1] + rofClusters[1][tracklet01.rof[1]];
-              lines[lineOffsets[iCurrentLayerClusterIndex] + validTracklets] = Line(tracklet01, clusters0, clusters1);
-            }
-            ++validTracklets;
-          }
-        }
-      }
-
-      if constexpr (dryRun) {
-        linesPerCluster[iCurrentLayerClusterIndex] = validTracklets;
-      }
-    }
-  }
-}
-
-template <TrackletMode Mode>
-GPUg() void compileTrackletsPerROFKernel(const int32_t nRofs,
-                                         int** GPUrestrict() nTrackletsPerROF,
-                                         const int32_t** GPUrestrict() rofClusters,
-                                         const int32_t** GPUrestrict() nTrackletsPerCluster)
-{
-  // TODO is this the best reduction kernel?
-  constexpr int32_t iMode = (Mode == TrackletMode::Layer0Layer1) ? 0 : 1;
-  extern __shared__ int32_t ssum[];
-  for (uint32_t rof = blockIdx.x; rof < (uint32_t)nRofs; rof += gridDim.x) {
-    const auto& GPUrestrict() currentNTracklets = getNTrackletsPerCluster(rof, nRofs, iMode, rofClusters, nTrackletsPerCluster);
-    int32_t localSum = 0;
-    for (uint32_t ci = threadIdx.x; ci < (uint32_t)currentNTracklets.size(); ci += blockDim.x) {
-      localSum += currentNTracklets[ci];
-    }
-    ssum[threadIdx.x] = localSum;
-    __syncthreads();
-    for (uint32_t stride = blockDim.x / 2; stride > 0; stride >>= 1) {
-      if (threadIdx.x < stride) {
-        ssum[threadIdx.x] += ssum[threadIdx.x + stride];
-      }
-      __syncthreads();
-    }
-    if (threadIdx.x == 0) {
-      nTrackletsPerROF[iMode][rof] = ssum[0];
-    }
-  }
-}
-
-template <typename T>
-GPUhi() void cubExclusiveScan(const T* GPUrestrict() in, T* GPUrestrict() out, int32_t num_items, cudaStream_t stream)
-{
-  void* d_temp_storage = nullptr;
-  size_t temp_storage_bytes = 0;
-  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in, out + 1, num_items, stream));
-  GPUChkErrS(cudaMallocAsync(&d_temp_storage, temp_storage_bytes, stream));
-  GPUChkErrS(cub::DeviceScan::InclusiveSum(d_temp_storage, temp_storage_bytes, in, out + 1, num_items, stream));
-  GPUChkErrS(cudaFreeAsync(d_temp_storage, stream));
-}
-
-} // namespace gpu
-
-template <int nLayers>
-void countTrackletsInROFsHandler(const IndexTableUtils<nLayers>* GPUrestrict() utils,
-                                 const uint8_t* GPUrestrict() multMask,
-                                 const int32_t nRofs,
-                                 const int32_t deltaROF,
-                                 const int32_t* GPUrestrict() rofPV,
-                                 const int32_t vertPerRofThreshold,
-                                 const Cluster** GPUrestrict() clusters,
-                                 const uint32_t nClusters,
-                                 const int32_t** GPUrestrict() ROFClusters,
-                                 const uint8_t** GPUrestrict() usedClusters,
-                                 const int32_t** GPUrestrict() clustersIndexTables,
-                                 int32_t** GPUrestrict() trackletsPerClusterLUTs,
-                                 int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
-                                 int32_t** GPUrestrict() trackletsPerROF,
-                                 const std::array<int32_t*, 2>& trackletsPerClusterLUTsHost,
-                                 const std::array<int32_t*, 2>& trackletsPerClusterSumLUTsHost,
-                                 const int32_t iteration,
-                                 const float phiCut,
-                                 const int32_t maxTrackletsPerCluster,
-                                 const int32_t nBlocks,
-                                 const int32_t nThreads,
-                                 gpu::Streams& streams)
-{
-  const uint32_t sharedBytes = nThreads * (2 * deltaROF + 1) * sizeof(uint16_t);
-  gpu::computeLayerTrackletMutliROFKernel<nLayers, TrackletMode::Layer0Layer1, true><<<nBlocks, nThreads, sharedBytes, streams[0].get()>>>(clusters,
-                                                                                                                                           ROFClusters,
-                                                                                                                                           usedClusters,
-                                                                                                                                           clustersIndexTables,
-                                                                                                                                           phiCut,
-                                                                                                                                           nullptr,
-                                                                                                                                           trackletsPerClusterLUTs,
-                                                                                                                                           utils,
-                                                                                                                                           nRofs,
-                                                                                                                                           deltaROF,
-                                                                                                                                           rofPV,
-                                                                                                                                           iteration,
-                                                                                                                                           vertPerRofThreshold,
-                                                                                                                                           maxTrackletsPerCluster);
-  gpu::compileTrackletsPerROFKernel<TrackletMode::Layer0Layer1><<<nBlocks, nThreads, nThreads * sizeof(int32_t), streams[0].get()>>>(nRofs, trackletsPerROF, ROFClusters, (const int32_t**)trackletsPerClusterLUTs);
-  gpu::cubExclusiveScan(trackletsPerClusterLUTsHost[0], trackletsPerClusterSumLUTsHost[0], nClusters, streams[0].get());
-
-  gpu::computeLayerTrackletMutliROFKernel<nLayers, TrackletMode::Layer1Layer2, true><<<nBlocks, nThreads, sharedBytes, streams[1].get()>>>(clusters,
-                                                                                                                                           ROFClusters,
-                                                                                                                                           usedClusters,
-                                                                                                                                           clustersIndexTables,
-                                                                                                                                           phiCut,
-                                                                                                                                           nullptr,
-                                                                                                                                           trackletsPerClusterLUTs,
-                                                                                                                                           utils,
-                                                                                                                                           nRofs,
-                                                                                                                                           deltaROF,
-                                                                                                                                           rofPV,
-                                                                                                                                           iteration,
-                                                                                                                                           vertPerRofThreshold,
-                                                                                                                                           maxTrackletsPerCluster);
-  gpu::compileTrackletsPerROFKernel<TrackletMode::Layer1Layer2><<<nBlocks, nThreads, nThreads * sizeof(int), streams[1].get()>>>(nRofs, trackletsPerROF, ROFClusters, (const int**)trackletsPerClusterLUTs);
-  gpu::cubExclusiveScan(trackletsPerClusterLUTsHost[1], trackletsPerClusterSumLUTsHost[1], nClusters, streams[1].get());
-}
-
-template <int32_t nLayers>
-void computeTrackletsInROFsHandler(const IndexTableUtils<nLayers>* GPUrestrict() utils,
-                                   const uint8_t* GPUrestrict() multMask,
-                                   const int32_t nRofs,
-                                   const int32_t deltaROF,
-                                   const int32_t* GPUrestrict() rofPV,
-                                   const int vertPerRofThreshold,
-                                   const Cluster** GPUrestrict() clusters,
-                                   const uint32_t nClusters,
-                                   const int32_t** GPUrestrict() ROFClusters,
-                                   const uint8_t** GPUrestrict() usedClusters,
-                                   const int32_t** GPUrestrict() clustersIndexTables,
-                                   Tracklet** GPUrestrict() foundTracklets,
-                                   const int32_t** GPUrestrict() trackletsPerClusterLUTs,
-                                   const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
-                                   const int32_t** GPUrestrict() trackletsPerROF,
-                                   const int32_t iteration,
-                                   const float phiCut,
-                                   const int32_t maxTrackletsPerCluster,
-                                   const int32_t nBlocks,
-                                   const int32_t nThreads,
-                                   gpu::Streams& streams)
-{
-  const uint32_t sharedBytes = nThreads * (2 * deltaROF + 1) * sizeof(uint16_t);
-  gpu::computeLayerTrackletMutliROFKernel<nLayers, TrackletMode::Layer0Layer1, false><<<nBlocks, nThreads, sharedBytes, streams[0].get()>>>(clusters,
-                                                                                                                                            ROFClusters,
-                                                                                                                                            usedClusters,
-                                                                                                                                            clustersIndexTables,
-                                                                                                                                            phiCut,
-                                                                                                                                            foundTracklets,
-                                                                                                                                            trackletsPerClusterSumLUTs,
-                                                                                                                                            utils,
-                                                                                                                                            nRofs,
-                                                                                                                                            deltaROF,
-                                                                                                                                            rofPV,
-                                                                                                                                            iteration,
-                                                                                                                                            vertPerRofThreshold,
-                                                                                                                                            maxTrackletsPerCluster);
-  gpu::computeLayerTrackletMutliROFKernel<nLayers, TrackletMode::Layer1Layer2, false><<<nBlocks, nThreads, sharedBytes, streams[1].get()>>>(clusters,
-                                                                                                                                            ROFClusters,
-                                                                                                                                            usedClusters,
-                                                                                                                                            clustersIndexTables,
-                                                                                                                                            phiCut,
-                                                                                                                                            foundTracklets,
-                                                                                                                                            trackletsPerClusterSumLUTs,
-                                                                                                                                            utils,
-                                                                                                                                            nRofs,
-                                                                                                                                            deltaROF,
-                                                                                                                                            rofPV,
-                                                                                                                                            iteration,
-                                                                                                                                            vertPerRofThreshold,
-                                                                                                                                            maxTrackletsPerCluster);
-}
-
-void countTrackletsMatchingInROFsHandler(const int32_t nRofs,
-                                         const int32_t deltaROF,
-                                         const uint32_t nClusters,
-                                         const int32_t** GPUrestrict() ROFClusters,
-                                         const Cluster** GPUrestrict() clusters,
-                                         uint8_t** GPUrestrict() usedClusters,
-                                         const Tracklet** GPUrestrict() foundTracklets,
-                                         uint8_t* GPUrestrict() usedTracklets,
-                                         const int32_t** GPUrestrict() trackletsPerClusterLUTs,
-                                         const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
-                                         int32_t* GPUrestrict() linesPerClusterLUT,
-                                         int32_t* GPUrestrict() linesPerClusterSumLUT,
-                                         const int32_t iteration,
-                                         const float phiCut,
-                                         const float tanLambdaCut,
-                                         const int32_t nBlocks,
-                                         const int32_t nThreads,
-                                         gpu::Streams& streams)
-{
-  streams[1].sync(); // need to make sure that all tracklets are done, since this placed in 0 tracklet01 will be done but tracklet12 needs to be guaranteed
-  gpu::computeTrackletSelectionMutliROFKernel<true><<<nBlocks, nThreads, 0, streams[0].get()>>>(nullptr,
-                                                                                                usedClusters,
-                                                                                                ROFClusters,
-                                                                                                phiCut,
-                                                                                                tanLambdaCut,
-                                                                                                foundTracklets,
-                                                                                                usedTracklets,
-                                                                                                trackletsPerClusterLUTs,
-                                                                                                trackletsPerClusterSumLUTs,
-                                                                                                linesPerClusterLUT,
-                                                                                                nullptr,
-                                                                                                nRofs,
-                                                                                                deltaROF,
-                                                                                                100);
-  gpu::cubExclusiveScan(linesPerClusterLUT, linesPerClusterSumLUT, nClusters, streams[0].get());
-}
-
-void computeTrackletsMatchingInROFsHandler(const int32_t nRofs,
-                                           const int32_t deltaROF,
-                                           const uint32_t nClusters,
-                                           const int32_t** GPUrestrict() ROFClusters,
-                                           const Cluster** GPUrestrict() clusters,
-                                           const uint8_t** GPUrestrict() usedClusters,
-                                           const Tracklet** GPUrestrict() foundTracklets,
-                                           uint8_t* GPUrestrict() usedTracklets,
-                                           const int32_t** GPUrestrict() trackletsPerClusterLUTs,
-                                           const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
-                                           const int32_t* GPUrestrict() linesPerClusterSumLUT,
-                                           Line* GPUrestrict() lines,
-                                           const int32_t iteration,
-                                           const float phiCut,
-                                           const float tanLambdaCut,
-                                           const int32_t nBlocks,
-                                           const int32_t nThreads,
-                                           gpu::Streams& streams)
-{
-  gpu::computeTrackletSelectionMutliROFKernel<false><<<nBlocks, nThreads, 0, streams[0].get()>>>(clusters,
-                                                                                                 nullptr,
-                                                                                                 ROFClusters,
-                                                                                                 phiCut,
-                                                                                                 tanLambdaCut,
-                                                                                                 foundTracklets,
-                                                                                                 usedTracklets,
-                                                                                                 trackletsPerClusterLUTs,
-                                                                                                 trackletsPerClusterSumLUTs,
-                                                                                                 linesPerClusterSumLUT,
-                                                                                                 lines,
-                                                                                                 nRofs,
-                                                                                                 deltaROF,
-                                                                                                 100);
-}
-
-/// Explicit instantiation of ITS2 handlers
-template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* GPUrestrict() utils,
-                                             const uint8_t* GPUrestrict() multMask,
-                                             const int32_t nRofs,
-                                             const int32_t deltaROF,
-                                             const int32_t* GPUrestrict() rofPV,
-                                             const int32_t vertPerRofThreshold,
-                                             const Cluster** GPUrestrict() clusters,
-                                             const uint32_t nClusters,
-                                             const int32_t** GPUrestrict() ROFClusters,
-                                             const uint8_t** GPUrestrict() usedClusters,
-                                             const int32_t** GPUrestrict() clustersIndexTables,
-                                             int32_t** trackletsPerClusterLUTs,
-                                             int32_t** trackletsPerClusterSumLUTs,
-                                             int32_t** trackletsPerROF,
-                                             const std::array<int32_t*, 2>& trackletsPerClusterLUTsHost,
-                                             const std::array<int32_t*, 2>& trackletsPerClusterSumLUTsHost,
-                                             const int32_t iteration,
-                                             const float phiCut,
-                                             const int32_t maxTrackletsPerCluster,
-                                             const int32_t nBlocks,
-                                             const int32_t nThreads,
-                                             gpu::Streams& streams);
-
-template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* GPUrestrict() utils,
-                                               const uint8_t* GPUrestrict() multMask,
-                                               const int32_t nRofs,
-                                               const int32_t deltaROF,
-                                               const int32_t* GPUrestrict() rofPV,
-                                               const int vertPerRofThreshold,
-                                               const Cluster** GPUrestrict() clusters,
-                                               const uint32_t nClusters,
-                                               const int32_t** GPUrestrict() ROFClusters,
-                                               const uint8_t** GPUrestrict() usedClusters,
-                                               const int32_t** GPUrestrict() clustersIndexTables,
-                                               Tracklet** GPUrestrict() foundTracklets,
-                                               const int32_t** GPUrestrict() trackletsPerClusterLUTs,
-                                               const int32_t** GPUrestrict() trackletsPerClusterSumLUTs,
-                                               const int32_t** GPUrestrict() trackletsPerROF,
-                                               const int32_t iteration,
-                                               const float phiCut,
-                                               const int32_t maxTrackletsPerCluster,
-                                               const int32_t nBlocks,
-                                               const int32_t nThreads,
-                                               gpu::Streams& streams);
-/*
-GPUg() void lineClustererMultipleRof(
-  const int* sizeClustersL1,     // Number of clusters on layer 1 per ROF
-  Line* lines,                   // Lines
-  int* nFoundLines,              // Number of found lines
-  int* nExclusiveFoundLines,     // Number of found lines exclusive scan
-  int* clusteredLines,           // Clustered lines
-  const unsigned int startRofId, // Starting ROF ID
-  const unsigned int rofSize,    // Number of ROFs to consider // Number of found lines exclusive scan
-  const float pairCut)           // Selection on line pairs
-{
-  for (unsigned int iRof{threadIdx.x}; iRof < rofSize; iRof += blockDim.x) {
-    auto rof = iRof + startRofId;
-    auto clustersL1offsetRof = sizeClustersL1[rof] - sizeClustersL1[startRofId]; // starting cluster offset for this ROF
-    auto nClustersL1Rof = sizeClustersL1[rof + 1] - sizeClustersL1[rof];         // number of clusters for this ROF
-    auto linesOffsetRof = nExclusiveFoundLines[clustersL1offsetRof];             // starting line offset for this ROF
-    // auto* foundLinesRof = nFoundLines + clustersL1offsetRof;
-    auto nLinesRof = nExclusiveFoundLines[clustersL1offsetRof + nClustersL1Rof] - linesOffsetRof;
-    // printf("rof: %d -> %d lines.\n", rof, nLinesRof);
-    for (int iLine1 = 0; iLine1 < nLinesRof; ++iLine1) {
-      auto absLine1Index = nExclusiveFoundLines[clustersL1offsetRof] + iLine1;
-      if (clusteredLines[absLine1Index] > -1) {
-        continue;
-      }
-      for (int iLine2 = iLine1 + 1; iLine2 < nLinesRof; ++iLine2) {
-        auto absLine2Index = nExclusiveFoundLines[clustersL1offsetRof] + iLine2;
-        if (clusteredLines[absLine2Index] > -1) {
-          continue;
-        }
-
-        if (Line::getDCA(lines[absLine1Index], lines[absLine2Index]) < pairCut) {
-          ClusterLinesGPU tmpClus{lines[absLine1Index], lines[absLine2Index]};
-          float tmpVertex[3];
-          tmpVertex[0] = tmpClus.getVertex()[0];
-          tmpVertex[1] = tmpClus.getVertex()[1];
-          tmpVertex[2] = tmpClus.getVertex()[2];
-          if (tmpVertex[0] * tmpVertex[0] + tmpVertex[1] * tmpVertex[1] > 4.f) { // outside the beampipe, skip it
-            break;
-          }
-          clusteredLines[absLine1Index] = iLine1; // We set local index of first line to contribute, so we can retrieve the cluster later
-          clusteredLines[absLine2Index] = iLine1;
-          for (int iLine3 = 0; iLine3 < nLinesRof; ++iLine3) {
-            auto absLine3Index = nExclusiveFoundLines[clustersL1offsetRof] + iLine3;
-            if (clusteredLines[absLine3Index] > -1) {
-              continue;
-            }
-            if (Line::getDistanceFromPoint(lines[absLine3Index], tmpVertex) < pairCut) {
-              clusteredLines[absLine3Index] = iLine1;
-            }
-          }
-          break;
-        }
-      }
-    }
-  } // rof loop
-}
-
-GPUg() void computeCentroidsKernel(
-  Line* lines,
-  int* nFoundLines,
-  int* nExclusiveFoundLines,
-  const unsigned int nClustersMiddleLayer,
-  float* centroids,
-  const float lowHistX,
-  const float highHistX,
-  const float lowHistY,
-  const float highHistY,
-  const float pairCut)
-{
-  const int nLines = nExclusiveFoundLines[nClustersMiddleLayer - 1] + nFoundLines[nClustersMiddleLayer - 1];
-  const int maxIterations{nLines * (nLines - 1) / 2};
-  for (unsigned int currentThreadIndex = blockIdx.x * blockDim.x + threadIdx.x; currentThreadIndex < maxIterations; currentThreadIndex += blockDim.x * gridDim.x) {
-    int iFirstLine = currentThreadIndex / nLines;
-    int iSecondLine = currentThreadIndex % nLines;
-    // All unique pairs
-    if (iSecondLine <= iFirstLine) {
-      iFirstLine = nLines - iFirstLine - 2;
-      iSecondLine = nLines - iSecondLine - 1;
-    }
-    if (Line::getDCA(lines[iFirstLine], lines[iSecondLine]) < pairCut) {
-      ClusterLinesGPU cluster{lines[iFirstLine], lines[iSecondLine]};
-      if (cluster.getVertex()[0] * cluster.getVertex()[0] + cluster.getVertex()[1] * cluster.getVertex()[1] < 1.98f * 1.98f) {
-        // printOnThread(0, "xCentr: %f, yCentr: %f \n", cluster.getVertex()[0], cluster.getVertex()[1]);
-        centroids[2 * currentThreadIndex] = cluster.getVertex()[0];
-        centroids[2 * currentThreadIndex + 1] = cluster.getVertex()[1];
-      } else {
-        // write values outside the histogram boundaries,
-        // default behaviour is not to have them added to histogram later
-        // (writing zeroes would be problematic)
-        centroids[2 * currentThreadIndex] = 2 * lowHistX;
-        centroids[2 * currentThreadIndex + 1] = 2 * lowHistY;
-      }
-    } else {
-      // write values outside the histogram boundaries,
-      // default behaviour is not to have them added to histogram later
-      // (writing zeroes would be problematic)
-      centroids[2 * currentThreadIndex] = 2 * highHistX;
-      centroids[2 * currentThreadIndex + 1] = 2 * highHistY;
-    }
-  }
-}
-
-GPUg() void computeZCentroidsKernel(
-  const int nLines,
-  const cub::KeyValuePair<int, int>* tmpVtX,
-  float* beamPosition,
-  Line* lines,
-  float* centroids,
-  const int* histX, // X
-  const float lowHistX,
-  const float binSizeHistX,
-  const int nBinsHistX,
-  const int* histY, // Y
-  const float lowHistY,
-  const float binSizeHistY,
-  const int nBinsHistY,
-  const float lowHistZ, // Z
-  const float pairCut,
-  const int binOpeningX,
-  const int binOpeningY)
-{
-  for (unsigned int currentThreadIndex = blockIdx.x * blockDim.x + threadIdx.x; currentThreadIndex < nLines; currentThreadIndex += blockDim.x * gridDim.x) {
-    if (tmpVtX[0].value || tmpVtX[1].value) {
-      float tmpX{lowHistX + tmpVtX[0].key * binSizeHistX + binSizeHistX / 2};
-      int sumWX{tmpVtX[0].value};
-      float wX{tmpX * tmpVtX[0].value};
-      for (int iBin{o2::gpu::GPUCommonMath::Max(0, tmpVtX[0].key - binOpeningX)}; iBin < o2::gpu::GPUCommonMath::Min(tmpVtX[0].key + binOpeningX + 1, nBinsHistX - 1); ++iBin) {
-        if (iBin != tmpVtX[0].key) {
-          wX += (lowHistX + iBin * binSizeHistX + binSizeHistX / 2) * histX[iBin];
-          sumWX += histX[iBin];
-        }
-      }
-      float tmpY{lowHistY + tmpVtX[1].key * binSizeHistY + binSizeHistY / 2};
-      int sumWY{tmpVtX[1].value};
-      float wY{tmpY * tmpVtX[1].value};
-      for (int iBin{o2::gpu::GPUCommonMath::Max(0, tmpVtX[1].key - binOpeningY)}; iBin < o2::gpu::GPUCommonMath::Min(tmpVtX[1].key + binOpeningY + 1, nBinsHistY - 1); ++iBin) {
-        if (iBin != tmpVtX[1].key) {
-          wY += (lowHistY + iBin * binSizeHistY + binSizeHistY / 2) * histY[iBin];
-          sumWY += histY[iBin];
-        }
-      }
-      beamPosition[0] = wX / sumWX;
-      beamPosition[1] = wY / sumWY;
-      float mockBeamPoint1[3] = {beamPosition[0], beamPosition[1], -1}; // get two points laying at different z, to create line object
-      float mockBeamPoint2[3] = {beamPosition[0], beamPosition[1], 1};
-      Line pseudoBeam = {mockBeamPoint1, mockBeamPoint2};
-      if (Line::getDCA(lines[currentThreadIndex], pseudoBeam) < pairCut) {
-        ClusterLinesGPU cluster{lines[currentThreadIndex], pseudoBeam};
-        centroids[currentThreadIndex] = cluster.getVertex()[2];
-      } else {
-        centroids[currentThreadIndex] = 2 * lowHistZ;
-      }
-    }
-  }
-}
-
-GPUg() void computeVertexKernel(
-  cub::KeyValuePair<int, int>* tmpVertexBins,
-  int* histZ, // Z
-  const float lowHistZ,
-  const float binSizeHistZ,
-  const int nBinsHistZ,
-  Vertex* vertices,
-  float* beamPosition,
-  const int vertIndex,
-  const int minContributors,
-  const int binOpeningZ)
-{
-  for (unsigned int currentThreadIndex = blockIdx.x * blockDim.x + threadIdx.x; currentThreadIndex < binOpeningZ; currentThreadIndex += blockDim.x * gridDim.x) {
-    if (currentThreadIndex == 0) {
-      if (tmpVertexBins[2].value > 1 && (tmpVertexBins[0].value || tmpVertexBins[1].value)) {
-        float z{lowHistZ + tmpVertexBins[2].key * binSizeHistZ + binSizeHistZ / 2};
-        float ex{0.f};
-        float ey{0.f};
-        float ez{0.f};
-        int sumWZ{tmpVertexBins[2].value};
-        float wZ{z * tmpVertexBins[2].value};
-        for (int iBin{o2::gpu::GPUCommonMath::Max(0, tmpVertexBins[2].key - binOpeningZ)}; iBin < o2::gpu::GPUCommonMath::Min(tmpVertexBins[2].key + binOpeningZ + 1, nBinsHistZ - 1); ++iBin) {
-          if (iBin != tmpVertexBins[2].key) {
-            wZ += (lowHistZ + iBin * binSizeHistZ + binSizeHistZ / 2) * histZ[iBin];
-            sumWZ += histZ[iBin];
-          }
-          histZ[iBin] = 0;
-        }
-        if (sumWZ > minContributors || vertIndex == 0) {
-          new (vertices + vertIndex) Vertex{o2::math_utils::Point3D<float>(beamPosition[0], beamPosition[1], wZ / sumWZ), std::array<float, 6>{ex, 0, ey, 0, 0, ez}, static_cast<ushort>(sumWZ), 0};
-        } else {
-          new (vertices + vertIndex) Vertex{};
-        }
-      } else {
-        new (vertices + vertIndex) Vertex{};
-      }
-    }
-  }
-}
-*/
-} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
index a40aac491a386..e28fe04c06772 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/hip/CMakeLists.txt
@@ -16,13 +16,9 @@ if(HIP_ENABLED)
   # add_compile_definitions(ITS_MEASURE_GPU_TIME)
   # add_compile_definitions(ITS_GPU_LOG)
   o2_add_hipified_library(ITStrackingHIP
-                 SOURCES ../cuda/ClusterLinesGPU.cu
-                         ../cuda/TimeFrameGPU.cu
+                 SOURCES ../cuda/TimeFrameGPU.cu
                          ../cuda/TrackerTraitsGPU.cxx
-                         ../cuda/TracerGPU.cu
                          ../cuda/TrackingKernels.cu
-                         ../cuda/VertexingKernels.cu
-                         ../cuda/VertexerTraitsGPU.cxx
                  PUBLIC_INCLUDE_DIRECTORIES ../
                  PUBLIC_LINK_LIBRARIES O2::ITStracking
                                        O2::GPUTracking
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
index 66634c1a07eea..91d5edeedcdb1 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
@@ -97,6 +97,9 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   size_t getMaxMemory() const noexcept { return mMaxMemory; }
   void setMaxMemory(size_t max)
   {
+    if (max == mMaxMemory) {
+      return;
+    }
     size_t used = mUsedMemory.load(std::memory_order_acquire);
     if (used > max) {
       ++mCountThrow;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index 902092a510eb0..d223adcef6214 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -17,38 +17,19 @@
 #define TRACKINGITSU_INCLUDE_CACELL_H_
 
 #include "ITStracking/Constants.h"
+#include "DataFormatsITS/TimeEstBC.h"
+#include "ReconstructionDataFormats/Track.h"
 #include "GPUCommonDef.h"
 
 namespace o2::its
 {
 
-class Cell final
-{
- public:
-  GPUhd() int getFirstClusterIndex() const { return mFirstClusterIndex; };
-  GPUhd() int getSecondClusterIndex() const { return mSecondClusterIndex; };
-  GPUhd() int getThirdClusterIndex() const { return mThirdClusterIndex; };
-  GPUhd() int getFirstTrackletIndex() const { return mFirstTrackletIndex; };
-  GPUhd() int getSecondTrackletIndex() const { return mSecondTrackletIndex; };
-  GPUhd() int getLevel() const { return mLevel; };
-  GPUhd() void setLevel(const int level) { mLevel = level; };
-  GPUhd() int* getLevelPtr() { return &mLevel; }
-
- private:
-  int mFirstClusterIndex{constants::UnusedIndex};
-  int mSecondClusterIndex{constants::UnusedIndex};
-  int mThirdClusterIndex{constants::UnusedIndex};
-  int mFirstTrackletIndex{constants::UnusedIndex};
-  int mSecondTrackletIndex{constants::UnusedIndex};
-  int mLevel{constants::UnusedIndex};
-};
-
-template <int nLayers>
+template <int NLayers>
 class CellSeed final : public o2::track::TrackParCovF
 {
  public:
   GPUhdDefault() CellSeed() = default;
-  GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2) : o2::track::TrackParCovF(tpc), mChi2(chi2), mLevel(1)
+  GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2, const TimeEstBC& time) : o2::track::TrackParCovF(tpc), mChi2(chi2), mLevel(1), mTime(time)
   {
     mClusters.fill(constants::UnusedIndex);
     setUserField(innerL);
@@ -81,20 +62,24 @@ class CellSeed final : public o2::track::TrackParCovF
   GPUhd() void printCell() const
   {
     printf("cell: %d, %d\t lvl: %d\t chi2: %f\tcls: [", mTracklets[0], mTracklets[1], mLevel, mChi2);
-    for (int i = 0; i < nLayers; ++i) {
+    for (int i = 0; i < NLayers; ++i) {
       printf("%d", mClusters[i]);
-      if (i < nLayers - 1) {
+      if (i < NLayers - 1) {
         printf(" | ");
       }
     }
-    printf("]\n");
+    printf("]");
+    printf(" ts: %u +/- %u\n", mTime.getTimeStamp(), mTime.getTimeStampError());
   }
+  GPUhd() auto& getTimeStamp() noexcept { return mTime; }
+  GPUhd() const auto& getTimeStamp() const noexcept { return mTime; }
 
  private:
   float mChi2 = -999.f;
   int mLevel = constants::UnusedIndex;
   std::array<int, 2> mTracklets = constants::helpers::initArray<int, 2, constants::UnusedIndex>();
-  std::array<int, nLayers> mClusters = constants::helpers::initArray<int, nLayers, constants::UnusedIndex>();
+  std::array<int, NLayers> mClusters = constants::helpers::initArray<int, NLayers, constants::UnusedIndex>();
+  TimeEstBC mTime;
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
index b96f0558943a6..34014d858648b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cluster.h
@@ -19,6 +19,7 @@
 #include <array>
 #include "ITStracking/Constants.h"
 #include "GPUCommonRtypes.h"
+#include "GPUCommonDef.h"
 
 namespace o2::its
 {
@@ -71,8 +72,8 @@ struct TrackingFrameInfo final {
   float zCoordinate{-999.f};
   float xTrackingFrame{-999.f};
   float alphaTrackingFrame{-999.f};
-  std::array<float, 2> positionTrackingFrame = {constants::UnusedIndex, constants::UnusedIndex};
-  std::array<float, 3> covarianceTrackingFrame = {999., 999., 999.};
+  std::array<float, 2> positionTrackingFrame = {-999.f, -999.f};
+  std::array<float, 3> covarianceTrackingFrame = {-999.f, -999.f, -999.f};
 
   ClassDefNV(TrackingFrameInfo, 1);
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
index 0e7ad474ae455..6fbc6d7da7721 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
@@ -14,200 +14,77 @@
 
 #include <array>
 #include <vector>
+#include <Math/SMatrix.h>
+#include <Math/SVector.h>
 #include "ITStracking/Cluster.h"
 #include "ITStracking/Constants.h"
 #include "ITStracking/Tracklet.h"
 #include "GPUCommonRtypes.h"
-#include "GPUCommonMath.h"
 
 namespace o2::its
 {
+
 struct Line final {
-  GPUhdDefault() Line() = default;
-  GPUhd() Line(const Line&);
-  Line(std::array<float, 3> firstPoint, std::array<float, 3> secondPoint);
-  GPUhd() Line(const Tracklet&, const Cluster*, const Cluster*);
+#if !defined(__HIPCC__) && !defined(__CUDACC__) // hide the class completely for gpu-cc
+  using SVector3f = ROOT::Math::SVector<float, 3>;
+  using SMatrix3f = ROOT::Math::SMatrix<float, 3, 3, ROOT::Math::MatRepSym<float, 3>>;
+
+  Line() = default;
+  Line(const Tracklet&, const Cluster*, const Cluster*);
+  bool operator==(const Line&) const = default;
 
+  static float getDistance2FromPoint(const Line& line, const std::array<float, 3>& point);
   static float getDistanceFromPoint(const Line& line, const std::array<float, 3>& point);
-  GPUhd() static float getDistanceFromPoint(const Line& line, const float point[3]);
-  static std::array<float, 6> getDCAComponents(const Line& line, const std::array<float, 3> point);
-  GPUhd() static void getDCAComponents(const Line& line, const float point[3], float destArray[6]);
-  GPUhd() static float getDCA(const Line&, const Line&, const float precision = constants::Tolerance);
-  static bool areParallel(const Line&, const Line&, const float precision = constants::Tolerance);
-  GPUhd() unsigned char isEmpty() const { return (originPoint[0] == 0.f && originPoint[1] == 0.f && originPoint[2] == 0.f) &&
-                                                 (cosinesDirector[0] == 0.f && cosinesDirector[1] == 0.f && cosinesDirector[2] == 0.f); }
-  GPUhdi() auto getDeltaROF() const { return rof[1] - rof[0]; }
-  GPUhd() void print() const;
-  bool operator==(const Line&) const;
-  bool operator!=(const Line&) const;
-  short getMinROF() const { return rof[0] < rof[1] ? rof[0] : rof[1]; }
+  static SMatrix3f getDCAComponents(const Line& line, const std::array<float, 3>& point);
+  static float getDCA2(const Line&, const Line&, const float precision = constants::Tolerance);
+  static float getDCA(const Line&, const Line&, const float precision = constants::Tolerance);
+  bool isEmpty() const noexcept;
+  void print() const;
 
-  float originPoint[3] = {0, 0, 0};
-  float cosinesDirector[3] = {0, 0, 0};
-  // float weightMatrix[6] = {1., 0., 0., 1., 0., 1.};
-  // weightMatrix is a symmetric matrix internally stored as
-  //    0 --> row = 0, col = 0
-  //    1 --> 0,1
-  //    2 --> 0,2
-  //    3 --> 1,1
-  //    4 --> 1,2
-  //    5 --> 2,2
-  short rof[2] = {constants::UnusedIndex, constants::UnusedIndex};
+  SVector3f originPoint;
+  SVector3f cosinesDirector;
+  TimeEstBC mTime;
 
   ClassDefNV(Line, 1);
+#endif
 };
 
-GPUhdi() Line::Line(const Line& other)
-{
-  for (int i{0}; i < 3; ++i) {
-    originPoint[i] = other.originPoint[i];
-    cosinesDirector[i] = other.cosinesDirector[i];
-  }
-  // for (int i{0}; i < 6; ++i) {
-  //   weightMatrix[i] = other.weightMatrix[i];
-  // }
-  for (int i{0}; i < 2; ++i) {
-    rof[i] = other.rof[i];
-  }
-}
-
-GPUhdi() Line::Line(const Tracklet& tracklet, const Cluster* innerClusters, const Cluster* outerClusters)
-{
-  originPoint[0] = innerClusters[tracklet.firstClusterIndex].xCoordinate;
-  originPoint[1] = innerClusters[tracklet.firstClusterIndex].yCoordinate;
-  originPoint[2] = innerClusters[tracklet.firstClusterIndex].zCoordinate;
-
-  cosinesDirector[0] = outerClusters[tracklet.secondClusterIndex].xCoordinate - innerClusters[tracklet.firstClusterIndex].xCoordinate;
-  cosinesDirector[1] = outerClusters[tracklet.secondClusterIndex].yCoordinate - innerClusters[tracklet.firstClusterIndex].yCoordinate;
-  cosinesDirector[2] = outerClusters[tracklet.secondClusterIndex].zCoordinate - innerClusters[tracklet.firstClusterIndex].zCoordinate;
-
-  float inverseNorm{1.f / o2::gpu::CAMath::Hypot(cosinesDirector[0], cosinesDirector[1], cosinesDirector[2])};
-  cosinesDirector[0] *= inverseNorm;
-  cosinesDirector[1] *= inverseNorm;
-  cosinesDirector[2] *= inverseNorm;
-
-  rof[0] = tracklet.rof[0];
-  rof[1] = tracklet.rof[1];
-}
-
-// static functions:
-inline float Line::getDistanceFromPoint(const Line& line, const std::array<float, 3>& point)
-{
-  float DCASquared{0};
-  float cdelta{0};
-  for (int i{0}; i < 3; ++i) {
-    cdelta -= line.cosinesDirector[i] * (line.originPoint[i] - point[i]);
-  }
-  for (int i{0}; i < 3; ++i) {
-    DCASquared += (line.originPoint[i] - point[i] + line.cosinesDirector[i] * cdelta) *
-                  (line.originPoint[i] - point[i] + line.cosinesDirector[i] * cdelta);
-  }
-  return o2::gpu::CAMath::Sqrt(DCASquared);
-}
-
-GPUhdi() float Line::getDistanceFromPoint(const Line& line, const float point[3])
-{
-  const float dx = point[0] - line.originPoint[0];
-  const float dy = point[1] - line.originPoint[1];
-  const float dz = point[2] - line.originPoint[2];
-  const float d = (dx * line.cosinesDirector[0]) + (dy * line.cosinesDirector[1]) + (dz * line.cosinesDirector[2]);
-
-  const float vx = dx - (d * line.cosinesDirector[0]);
-  const float vy = dy - (d * line.cosinesDirector[1]);
-  const float vz = dz - (d * line.cosinesDirector[2]);
-
-  return o2::gpu::CAMath::Hypot(vx, vy, vz);
-}
-
-GPUhdi() float Line::getDCA(const Line& firstLine, const Line& secondLine, const float precision)
-{
-  const float nx = (firstLine.cosinesDirector[1] * secondLine.cosinesDirector[2]) -
-                   (firstLine.cosinesDirector[2] * secondLine.cosinesDirector[1]);
-  const float ny = -(firstLine.cosinesDirector[0] * secondLine.cosinesDirector[2]) +
-                   (firstLine.cosinesDirector[2] * secondLine.cosinesDirector[0]);
-  const float nz = (firstLine.cosinesDirector[0] * secondLine.cosinesDirector[1]) -
-                   (firstLine.cosinesDirector[1] * secondLine.cosinesDirector[0]);
-  const float norm2 = (nx * nx) + (ny * ny) + (nz * nz);
-
-  if (norm2 <= precision * precision) {
-    return getDistanceFromPoint(firstLine, secondLine.originPoint);
-  }
-
-  const float dx = secondLine.originPoint[0] - firstLine.originPoint[0];
-  const float dy = secondLine.originPoint[1] - firstLine.originPoint[1];
-  const float dz = secondLine.originPoint[2] - firstLine.originPoint[2];
-  const float triple = (dx * nx) + (dy * ny) + (dz * nz);
-
-  return o2::gpu::CAMath::Abs(triple) / o2::gpu::CAMath::Sqrt(norm2);
-}
-
-GPUhdi() void Line::getDCAComponents(const Line& line, const float point[3], float destArray[6])
-{
-  float cdelta{0.};
-  for (int i{0}; i < 3; ++i) {
-    cdelta -= line.cosinesDirector[i] * (line.originPoint[i] - point[i]);
-  }
-
-  destArray[0] = line.originPoint[0] - point[0] + line.cosinesDirector[0] * cdelta;
-  destArray[3] = line.originPoint[1] - point[1] + line.cosinesDirector[1] * cdelta;
-  destArray[5] = line.originPoint[2] - point[2] + line.cosinesDirector[2] * cdelta;
-  destArray[1] = o2::gpu::CAMath::Sqrt(destArray[0] * destArray[0] + destArray[3] * destArray[3]);
-  destArray[2] = o2::gpu::CAMath::Sqrt(destArray[0] * destArray[0] + destArray[5] * destArray[5]);
-  destArray[4] = o2::gpu::CAMath::Sqrt(destArray[3] * destArray[3] + destArray[5] * destArray[5]);
-}
-
-inline bool Line::operator==(const Line& rhs) const
-{
-  bool val{false};
-  for (int i{0}; i < 3; ++i) {
-    val &= this->originPoint[i] == rhs.originPoint[i];
-  }
-  return val;
-}
-
-inline bool Line::operator!=(const Line& rhs) const
-{
-  return !(*this == rhs);
-}
-
-GPUhdi() void Line::print() const
-{
-  printf("Line: originPoint = (%f, %f, %f), cosinesDirector = (%f, %f, %f), rofs = (%hd, %hd)\n",
-         originPoint[0], originPoint[1], originPoint[2], cosinesDirector[0], cosinesDirector[1], cosinesDirector[2], rof[0], rof[1]);
-}
-
 class ClusterLines final
 {
+#if !defined(__HIPCC__) && !defined(__CUDACC__) // hide the class completely for gpu-cc
+  using SMatrix3 = ROOT::Math::SMatrix<double, 3, 3, ROOT::Math::MatRepSym<double, 3>>;
+  using SMatrix3f = ROOT::Math::SMatrix<float, 3, 3, ROOT::Math::MatRepSym<float, 3>>;
+  using SVector3 = ROOT::Math::SVector<double, 3>;
+
  public:
   ClusterLines() = default;
-  ClusterLines(const int firstLabel, const Line& firstLine, const int secondLabel, const Line& secondLine,
-               const bool weight = false);
-  ClusterLines(const Line& firstLine, const Line& secondLine);
-  void add(const int& lineLabel, const Line& line, const bool& weight = false);
+  ClusterLines(const int firstLabel, const Line& firstLine, const int secondLabel, const Line& secondLine);
+  void add(const int lineLabel, const Line& line);
   void computeClusterCentroid();
-  void updateROFPoll(const Line&);
-  inline std::vector<int>& getLabels()
-  {
-    return mLabels;
-  }
-  inline int getSize() const { return mLabels.size(); }
-  inline short getROF() const { return mROF; }
-  inline std::array<float, 3> getVertex() const { return mVertex; }
-  inline std::array<float, 6> getRMS2() const { return mRMS2; }
-  inline float getAvgDistance2() const { return mAvgDistance2; }
-
-  bool operator==(const ClusterLines&) const;
+  void accumulate(const Line& line);
+  bool isValid() const noexcept { return mIsValid; }
+  auto const& getVertex() const { return mVertex; }
+  const float* getRMS2() const { return mRMS2.Array(); }
+  float getAvgDistance2() const { return mAvgDistance2; }
+  auto getSize() const noexcept { return mLabels.size(); }
+  auto& getLabels() noexcept { return mLabels; }
+  const auto& getTimeStamp() const noexcept { return mTime; }
+  bool operator==(const ClusterLines& rhs) const noexcept;
+  float getR2() const noexcept { return (mVertex[0] * mVertex[0]) + (mVertex[1] * mVertex[1]); }
+  float getR() const noexcept { return std::sqrt(getR2()); }
 
  protected:
-  std::array<double, 6> mAMatrix;             // AX=B
-  std::array<double, 3> mBMatrix;             // AX=B
-  std::vector<int> mLabels;                   // labels
-  std::array<float, 9> mWeightMatrix = {0.f}; // weight matrix
-  std::array<float, 3> mVertex = {0.f};       // cluster centroid position
-  std::array<float, 6> mRMS2 = {0.f};         // symmetric matrix: diagonal is RMS2
-  float mAvgDistance2 = 0.f;                  // substitute for chi2
-  int mROFWeight = 0;                         // rof weight for voting
-  short mROF = constants::UnusedIndex;        // rof
+  SMatrix3 mAMatrix;                 // AX=B, symmetric normal matrix
+  SVector3 mBMatrix;                 // AX=B, right-hand side
+  std::array<float, 3> mVertex = {}; // cluster centroid position
+  SMatrix3f mRMS2;                   // symmetric matrix: diagonal is RMS2
+  float mAvgDistance2 = 0.f;         // substitute for chi2
+  bool mIsValid = false;             // true if linear system was solved successfully
+  TimeEstBC mTime;                   // time stamp
+  std::vector<int> mLabels;          // contributing labels
+
+  ClassDefNV(ClusterLines, 1);
+#endif
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 10e1681c73e8d..02dbeb8cf3992 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -16,9 +16,11 @@
 #ifndef TRACKINGITSU_INCLUDE_CONFIGURATION_H_
 #define TRACKINGITSU_INCLUDE_CONFIGURATION_H_
 
+#include <cstdint>
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <array>
 #include <limits>
+#include <string>
 #include <vector>
 #include <cmath>
 #endif
@@ -37,7 +39,7 @@ struct TrackingParameters {
   std::string asString() const;
 
   int NLayers = 7;
-  int DeltaROF = 0;
+  std::vector<uint32_t> AddTimeError = {0, 0, 0, 0, 0, 0, 0};
   std::vector<float> LayerZ = {16.333f + 1, 16.333f + 1, 16.333f + 1, 42.140f + 1, 42.140f + 1, 73.745f + 1, 73.745f + 1};
   std::vector<float> LayerRadii = {2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f};
   std::vector<float> LayerxX0 = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f};
@@ -46,9 +48,9 @@ struct TrackingParameters {
   std::vector<float> SystErrorZ2 = {0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f};
   int ZBins{256};
   int PhiBins{128};
-  int nROFsPerIterations = -1;
   bool UseDiamond = false;
   float Diamond[3] = {0.f, 0.f, 0.f};
+  float DiamondCov[6] = {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f};
 
   /// General parameters
   bool AllowSharingFirstCluster = false;
@@ -58,10 +60,8 @@ struct TrackingParameters {
   float PVres = 1.e-2f;
   /// Trackleting cuts
   float TrackletMinPt = 0.3f;
-  float TrackletsPerClusterLimit = 2.f;
   /// Cell finding cuts
   float CellDeltaTanLambdaSigma = 0.007f;
-  float CellsPerClusterLimit = 2.f;
   /// Fitter parameters
   o2::base::PropagatorImpl<float>::MatCorrType CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrNONE;
   float MaxChi2ClusterAttachment = 60.f;
@@ -71,18 +71,10 @@ struct TrackingParameters {
   uint16_t StartLayerMask = 0x7F;
   bool RepeatRefitOut = false;   // repeat outward refit using inward refit as a seed
   bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
-  bool FindShortTracks = false;
   bool PerPrimaryVertexProcessing = false;
   bool SaveTimeBenchmarks = false;
   bool DoUPCIteration = false;
   bool FataliseUponFailure = true;
-  /// Cluster attachment
-  bool UseTrackFollower = false;
-  bool UseTrackFollowerTop = false;
-  bool UseTrackFollowerBot = false;
-  bool UseTrackFollowerMix = false;
-  float TrackFollowerNSigmaCutZ = 1.f;
-  float TrackFollowerNSigmaCutPhi = 1.f;
 
   bool createArtefactLabels{false};
 
@@ -94,14 +86,11 @@ struct TrackingParameters {
 struct VertexingParameters {
   std::string asString() const;
 
-  int nIterations = 1;         // Number of vertexing passes to perform
-  int vertPerRofThreshold = 0; // Maximum number of vertices per ROF to trigger second a round
-  bool allowSingleContribClusters = false;
+  int nIterations = 1; // Number of vertexing passes to perform
   std::vector<float> LayerZ = {16.333f + 1, 16.333f + 1, 16.333f + 1, 42.140f + 1, 42.140f + 1, 73.745f + 1, 73.745f + 1};
   std::vector<float> LayerRadii = {2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f};
   int ZBins{1};
   int PhiBins{128};
-  int deltaRof = 0;
   float zCut = 0.002f;
   float phiCut = 0.005f;
   float pairCut = 0.04f;
@@ -120,7 +109,6 @@ struct VertexingParameters {
   bool SaveTimeBenchmarks = false;
 
   bool useTruthSeeding = false; // overwrite found vertices with MC events
-  bool outputContLabels = false;
 
   int nThreads = 1;
   bool PrintMemory = false; // print allocator usage in epilog report
@@ -128,26 +116,6 @@ struct VertexingParameters {
   bool DropTFUponFailure = false;
 };
 
-struct TimeFrameGPUParameters {
-  std::string asString() const;
-
-  size_t tmpCUBBufferSize = 1e5; // In average in pp events there are required 4096 bytes
-  size_t maxTrackletsPerCluster = 1e2;
-  size_t clustersPerLayerCapacity = 2.5e5;
-  size_t clustersPerROfCapacity = 1.5e3;
-  size_t validatedTrackletsCapacity = 1e3;
-  size_t cellsLUTsize = validatedTrackletsCapacity;
-  size_t maxNeighboursSize = 1e2;
-  size_t neighboursLUTsize = maxNeighboursSize;
-  size_t maxRoadPerRofSize = 1e3; // pp!
-  size_t maxLinesCapacity = 1e2;
-  size_t maxVerticesCapacity = 5e4;
-  size_t nMaxROFs = 1e3;
-  size_t nTimeFrameChunks = 3;
-  size_t nROFsPerChunk = 768; // pp defaults
-  int maxGPUMemoryGB = -1;
-};
-
 namespace TrackingMode
 {
 enum Type : int8_t {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index 22642f2e23229..4b2528b62f057 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -19,7 +19,7 @@
 #include <array>
 #include <utility>
 
-#include "ITStracking/Definitions.h"
+#include "GPUCommonDef.h"
 #include "GPUCommonDefAPI.h"
 
 namespace o2::its::constants
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
index c3be0de2dade7..8dadf826aa80a 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -16,16 +16,7 @@
 #define TRACKINGITS_DEFINITIONS_H_
 
 #include <type_traits>
-
-#include "ReconstructionDataFormats/Vertex.h"
-
-#ifdef CA_DEBUG
-#define CA_DEBUGGER(x) x
-#else
-#define CA_DEBUGGER(x) \
-  do {                 \
-  } while (0)
-#endif
+#include <cstdint>
 
 namespace o2::its
 {
@@ -35,11 +26,30 @@ enum class TrackletMode {
   Layer1Layer2 = 2
 };
 
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
-
 template <bool IsConst, typename T>
 using maybe_const = typename std::conditional<IsConst, const T, T>::type;
 
+// simple implemnetion of logging with exp. backoff
+struct LogLogThrottler {
+  uint64_t evCount{0};
+  uint64_t nextLog{1};
+  int32_t iteration{-1};
+  int32_t layer{-1};
+  bool needToLog(int32_t iter, int32_t lay)
+  {
+    if (iteration != iter || layer != lay) {
+      iteration = iter;
+      layer = lay;
+      evCount = 0;
+      nextLog = 1;
+    }
+    if (++evCount > nextLog) {
+      nextLog *= 2;
+      return true;
+    }
+    return false;
+  }
+};
 } // namespace o2::its
 
-#endif
+#endif
\ No newline at end of file
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h
new file mode 100644
index 0000000000000..3083a8fe9c2ec
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h
@@ -0,0 +1,93 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  FastMultEst.h
+/// \brief Fast multiplicity estimator for ITS
+/// \author ruben.shahoyan@cern.ch
+
+#ifndef ALICEO2_ITS_FASTMULTEST_
+#define ALICEO2_ITS_FASTMULTEST_
+
+#include "ITSMFTReconstruction/ChipMappingITS.h"
+#include "DataFormatsITS/Vertex.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/PhysTrigger.h"
+#include "ITStracking/FastMultEstConfig.h"
+#include "ITStracking/ROFLookupTables.h"
+#include <gsl/span>
+#include <array>
+
+namespace o2::its
+{
+
+struct FastMultEst {
+
+  static constexpr int NLayers = o2::itsmft::ChipMappingITS::NLayers;
+  using ROFOverlapTableN = ROFOverlapTable<NLayers>;
+  using ROFMaskTableN = ROFMaskTable<NLayers>;
+
+  float mult = 0.;             /// estimated signal clusters multiplicity on the selected multiplicity layer
+  float noisePerChip = 0.;     /// imposed noise per chip (when enabled by configuration)
+  float cov[3] = {0.};         /// retained for compatibility; set to zero in single-layer mode
+  float chi2 = 0.;             /// retained for compatibility; set to zero in single-layer mode
+  int nLayersUsed = 0;         /// number of layers used by estimator (0/1 in single-layer mode)
+  uint32_t lastRandomSeed = 0; /// state of the gRandom before
+  FastMultEst();
+
+  static uint32_t getCurrentRandomSeed();
+  int selectROFs(const std::array<gsl::span<const o2::itsmft::ROFRecord>, NLayers>& rofs,
+                 const std::array<gsl::span<const o2::itsmft::CompClusterExt>, NLayers>& clus,
+                 const gsl::span<const o2::itsmft::PhysTrigger> trig,
+                 uint32_t firstTForbit,
+                 bool doStaggering,
+                 const ROFOverlapTableN::View& overlapView,
+                 ROFMaskTableN& sel);
+  void selectROFsWithVertices(const auto& vertices, const ROFOverlapTableN::View& overlapView, ROFMaskTableN& sel) const
+  {
+    const auto& multEstConf = FastMultEstConfig::Instance();
+    if (!multEstConf.isVtxMultCutRequested()) {
+      return;
+    }
+
+    for (const auto& vertex : vertices) {
+      if (!multEstConf.isPassingVtxMultCut(vertex.getNContributors())) {
+        const auto& timestamp{vertex.getTimeStamp()};
+        for (int layer = 0; layer < NLayers; ++layer) {
+          uint32_t startROF = sel.getLayer(layer).getROF(timestamp.lower());
+          uint32_t endROF = sel.getLayer(layer).getROF(timestamp.upper());
+          for (uint32_t rof = startROF; rof <= endROF; ++rof) {
+            sel.setROFsEnabled(layer, rof, 0);
+          }
+        }
+      }
+    }
+  }
+
+  int countClustersOnLayer(const gsl::span<const o2::itsmft::CompClusterExt>& clusters) const;
+  float process(int nClusters)
+  {
+    return FastMultEstConfig::Instance().imposeNoisePerChip > 0 ? processNoiseImposed(nClusters) : processNoiseFree(nClusters);
+  }
+  float processNoiseFree(int nClusters);
+  float processNoiseImposed(int nClusters);
+  float process(const gsl::span<const o2::itsmft::CompClusterExt>& clusters)
+  {
+    return process(countClustersOnLayer(clusters));
+  }
+  static bool sSeedSet;
+
+  ClassDefNV(FastMultEst, 1);
+};
+
+} // namespace o2::its
+
+#endif
diff --git a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/FastMultEstConfig.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEstConfig.h
similarity index 58%
rename from Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/FastMultEstConfig.h
rename to Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEstConfig.h
index c6bce50995a4b..1ab9796aa8cf6 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/include/ITSReconstruction/FastMultEstConfig.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEstConfig.h
@@ -20,9 +20,7 @@
 #include "CommonUtils/ConfigurableParamHelper.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 struct FastMultEstConfig : public o2::conf::ConfigurableParamHelper<FastMultEstConfig> {
   static constexpr int NLayers = o2::itsmft::ChipMappingITS::NLayers;
@@ -34,16 +32,19 @@ struct FastMultEstConfig : public o2::conf::ConfigurableParamHelper<FastMultEstC
   float imposeNoisePerChip = 1.e-9 * 1024 * 512; // assumed noise, free parameter if<0
 
   // cuts to reject to low or too high mult events
-  float cutMultClusLow = 0;   /// reject ROF with estimated cluster mult. below this value (no cut if <0)
-  float cutMultClusHigh = -1; /// reject ROF with estimated cluster mult. above this value (no cut if <0)
-  float cutMultVtxLow = -1;   /// reject seed vertex if its multiplicity below this value (no cut if <0)
-  float cutMultVtxHigh = -1;  /// reject seed vertex if its multiplicity above this value (no cut if <0)
-  float cutRandomFraction = -1.; /// apply random cut rejecting requested fraction
-  int randomSeed = 0;            /// 0 - do not seet seed, >0 : set as is, <0 : use current time
-  bool preferTriggered = true;   /// prefer ROFs with highest number of physics triggers
-
-  bool isMultCutRequested() const { return cutMultClusLow >= 0.f && cutMultClusHigh > 0.f; };
-  bool isVtxMultCutRequested() const { return cutMultVtxLow >= 0.f && cutMultVtxHigh > 0.f; };
+  int cutMultClusLayer = NLayers - 1; /// layer used for cluster multiplicity selection (by default the outermost one)
+  float cutMultClusLow = 0;           /// reject ROF with estimated cluster mult. below this value (no cut if <0)
+  float cutMultClusHigh = -1;         /// reject ROF with estimated cluster mult. above this value (no cut if <0)
+  float cutMultVtxLow = -1;           /// reject seed vertex if its multiplicity below this value (no cut if <0)
+  float cutMultVtxHigh = -1;          /// reject seed vertex if its multiplicity above this value (no cut if <0)
+  float cutRandomFraction = -1.;      /// apply random cut rejecting requested fraction
+  int randomSeed = 0;                 /// 0 - do not seet seed, >0 : set as is, <0 : use current time
+  bool preferTriggered = true;        /// prefer ROFs with highest number of physics triggers
+
+  bool isMultCutRequested() const noexcept { return cutMultClusLow >= 0.f && cutMultClusHigh > 0.f; };
+  bool isVtxMultCutRequested() const noexcept { return cutMultVtxLow >= 0.f && cutMultVtxHigh > 0.f; };
+  bool isRandCutRequested() const noexcept { return cutRandomFraction >= 0.; }
+  bool isRequested() const noexcept { return isMultCutRequested() || isVtxMultCutRequested() || isRandCutRequested(); }
   bool isPassingRandomRejection() const;
   bool isPassingMultCut(float mult) const { return mult >= cutMultClusLow && (mult <= cutMultClusHigh || cutMultClusHigh <= 0.f); }
   bool isPassingVtxMultCut(int mult) const { return mult >= cutMultVtxLow && (mult <= cutMultVtxHigh || cutMultVtxHigh <= 0.f); }
@@ -51,7 +52,6 @@ struct FastMultEstConfig : public o2::conf::ConfigurableParamHelper<FastMultEstC
   O2ParamDef(FastMultEstConfig, "fastMultConfig");
 };
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
index c5c1e4a8ce220..95e0b4554e32c 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -44,19 +44,17 @@ GPUhdi() constexpr float getNormalizedPhi(float phi)
 GPUhdi() float computeCurvature(float x1, float y1, float x2, float y2, float x3, float y3)
 {
   // in case the triangle is degenerate we return infinite curvature.
-  const float d = (x2 - x1) * (y3 - y2) - (x3 - x2) * (y2 - y1);
-  if (o2::gpu::CAMath::Abs(d) < o2::its::constants::Tolerance) {
-    return 0.f;
-  }
-  const float a =
-    0.5f * ((y3 - y2) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1) - (y2 - y1) * (y3 * y3 - y2 * y2 + x3 * x3 - x2 * x2));
-  const float b =
-    0.5f * ((x2 - x1) * (y3 * y3 - y2 * y2 + x3 * x3 - x2 * x2) - (x3 - x2) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1));
-  const float den = o2::gpu::CAMath::Hypot(d * x1 - a, d * y1 - b);
-  if (den < o2::its::constants::Tolerance) {
-    return 0.f;
+  const float area = ((x2 - x1) * (y3 - y1)) - ((x3 - x1) * (y2 - y1));
+  if (o2::gpu::CAMath::Abs(area) < constants::Tolerance) {
+    return o2::constants::math::Almost0;
   }
-  return -d / den;
+  const float dx1 = x2 - x1, dy1 = y2 - y1;
+  const float dx2 = x3 - x2, dy2 = y3 - y2;
+  const float dx3 = x1 - x3, dy3 = y1 - y3;
+  const float d1 = o2::gpu::CAMath::Sqrt((dx1 * dx1) + (dy1 * dy1));
+  const float d2 = o2::gpu::CAMath::Sqrt((dx2 * dx2) + (dy2 * dy2));
+  const float d3 = o2::gpu::CAMath::Sqrt((dx3 * dx3) + (dy3 * dy3));
+  return -2.f * area / (d1 * d2 * d3);
 }
 
 GPUhdi() float computeCurvatureCentreX(float x1, float y1, float x2, float y2, float x3, float y3)
@@ -78,7 +76,7 @@ GPUhdi() float computeCurvatureCentreX(float x1, float y1, float x2, float y2, f
 
 GPUhdi() float computeTanDipAngle(float x1, float y1, float x2, float y2, float z1, float z2)
 {
-  // in case the points vertically align we go to pos/neg inifinity.
+  // in case the points vertically align we go to pos/neg infinity.
   const float d = o2::gpu::CAMath::Hypot(x1 - x2, y1 - y2);
   if (o2::gpu::CAMath::Abs(d) < o2::its::constants::Tolerance) {
     return ((z1 > z2) ? -1.f : 1.f) * o2::constants::math::VeryBig;
@@ -91,11 +89,16 @@ GPUhdi() float smallestAngleDifference(float a, float b)
   return o2::gpu::CAMath::Remainderf(b - a, o2::constants::math::TwoPI);
 }
 
-GPUhdi() float Sq(float v)
+GPUhdi() constexpr float Sq(float v)
 {
   return v * v;
 }
 
+GPUhdi() constexpr float SqDiff(float x, float y)
+{
+  return Sq(x - y);
+}
+
 GPUhdi() float MSangle(float mass, float p, float xX0)
 {
   float beta = p / o2::gpu::CAMath::Hypot(mass, p);
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROFLookupTables.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROFLookupTables.h
new file mode 100644
index 0000000000000..ce20169e36c64
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ROFLookupTables.h
@@ -0,0 +1,850 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef TRACKINGITSU_INCLUDE_ROFOVERLAPTABLE_H_
+#define TRACKINGITSU_INCLUDE_ROFOVERLAPTABLE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <string>
+#include <vector>
+#include <ranges>
+
+#ifndef GPUCA_GPUCODE
+#include <format>
+#include "Framework/Logger.h"
+#endif
+
+#include "CommonConstants/LHCConstants.h"
+#include "CommonDataFormat/RangeReference.h"
+#include "DataFormatsITS/TimeEstBC.h"
+#include "DataFormatsITS/Vertex.h"
+#include "GPUCommonMath.h"
+#include "GPUCommonDef.h"
+
+namespace o2::its
+{
+
+// Layer timing definition
+struct LayerTiming {
+  using BCType = TimeStampType;
+  BCType mNROFsTF{0};       // number of ROFs per timeframe
+  BCType mROFLength{0};     // ROF length in BC
+  BCType mROFDelay{0};      // delay of ROFs wrt start of first orbit in TF in BC
+  BCType mROFBias{0};       // bias wrt to the LHC clock in BC
+  BCType mROFAddTimeErr{0}; // additionally imposed uncertainty on ROF time in BC
+
+  // return start of ROF in BC
+  // this does not account for the opt. error!
+  GPUhdi() BCType getROFStartInBC(BCType rofId) const noexcept
+  {
+    assert(rofId < mNROFsTF && rofId >= 0);
+    return (mROFLength * rofId) + mROFDelay + mROFBias;
+  }
+
+  // return end of ROF in BCs
+  // this does not account for the opt. error!
+  GPUhdi() BCType getROFEndInBC(BCType rofId) const noexcept
+  {
+    assert(rofId < mNROFsTF);
+    return getROFStartInBC(rofId) + mROFLength;
+  }
+
+  // return (clamped) time-interval of rof
+  GPUhdi() TimeEstBC getROFTimeBounds(BCType rofId, bool withError = false) const noexcept
+  {
+    if (withError) {
+      int64_t start = getROFStartInBC(rofId);
+      int64_t end = getROFEndInBC(rofId);
+      start = o2::gpu::CAMath::Max(start - mROFAddTimeErr, int64_t(0));
+      end += mROFAddTimeErr;
+      return {static_cast<BCType>(start), static_cast<TimeStampErrorType>(end - start)};
+    }
+    return {getROFStartInBC(rofId), static_cast<TimeStampErrorType>(mROFLength)};
+  }
+
+  // return which ROF this BC belongs to
+  GPUhi() BCType getROF(BCType bc) const noexcept
+  {
+    const BCType offset = mROFDelay + mROFBias;
+    if (bc <= offset) {
+      return 0;
+    }
+    return (bc - offset) / mROFLength;
+  }
+
+  // return which ROF this timestamp belongs by its lower edge
+  GPUhi() BCType getROF(TimeStamp ts) const noexcept
+  {
+    const BCType offset = mROFDelay + mROFBias;
+    const BCType bc = (ts.getTimeStamp() < ts.getTimeStampError()) ? BCType(0) : static_cast<BCType>(o2::gpu::CAMath::Floor(ts.getTimeStamp() - ts.getTimeStampError()));
+    if (bc <= offset) {
+      return 0;
+    }
+    return (bc - offset) / mROFLength;
+  }
+
+#ifndef GPUCA_GPUCODE
+  GPUh() std::string asString() const
+  {
+    return std::format("NROFsPerTF {:4} ROFLength {:4} ({:4} per Orbit) ROFDelay {:4} ROFBias {:4} ROFAddTimeErr {:4}", mNROFsTF, mROFLength, (o2::constants::lhc::LHCMaxBunches / mROFLength), mROFDelay, mROFBias, mROFAddTimeErr);
+  }
+
+  GPUh() void print() const
+  {
+    LOG(info) << asString();
+  }
+#endif
+};
+
+// Base class for lookup to define layers
+template <int32_t NLayers>
+class LayerTimingBase
+{
+ protected:
+  LayerTiming mLayers[NLayers];
+
+ public:
+  using T = LayerTiming::BCType;
+  LayerTimingBase() = default;
+
+  GPUh() void defineLayer(int32_t layer, T nROFsTF, T rofLength, T rofDelay, T rofBias, T rofTE)
+  {
+    assert(layer >= 0 && layer < NLayers);
+    mLayers[layer] = {nROFsTF, rofLength, rofDelay, rofBias, rofTE};
+  }
+
+  GPUh() void defineLayer(int32_t layer, const LayerTiming& timing)
+  {
+    assert(layer >= 0 && layer < NLayers);
+    mLayers[layer] = timing;
+  }
+
+  GPUhdi() const LayerTiming& getLayer(int32_t layer) const
+  {
+    assert(layer >= 0 && layer < NLayers);
+    return mLayers[layer];
+  }
+
+  GPUhdi() constexpr int32_t getEntries() noexcept { return NLayers; }
+
+#ifndef GPUCA_GPUCODE
+  GPUh() void print() const
+  {
+    LOGP(info, "Imposed time structure:");
+    for (int32_t iL{0}; iL < NLayers; ++iL) {
+      LOGP(info, "\tLayer:{} {}", iL, mLayers[iL].asString());
+    }
+  }
+#endif
+};
+
+// GPU friendly view of the table below
+template <int32_t NLayers, typename TableEntry, typename TableIndex>
+struct ROFOverlapTableView {
+  const TableEntry* mFlatTable{nullptr};
+  const TableIndex* mIndices{nullptr};
+  const LayerTiming* mLayers{nullptr};
+
+  GPUhdi() const LayerTiming& getLayer(int32_t layer) const noexcept
+  {
+    assert(layer >= 0 && layer < NLayers);
+    return mLayers[layer];
+  }
+
+  GPUh() int32_t getClock() const noexcept
+  {
+    // we take the fastest layer as clock
+    int32_t fastest = 0;
+    uint32_t maxNROFs{0};
+    for (int32_t iL{0}; iL < NLayers; ++iL) {
+      const auto& layer = getLayer(iL);
+      // by definition the fastest layer has the most ROFs
+      // this also solves the problem of a delay large than ROFLength
+      // if mNROFsTF is correct
+      if (layer.mNROFsTF > maxNROFs) {
+        fastest = iL;
+        maxNROFs = layer.mNROFsTF;
+      }
+    }
+    return fastest;
+  }
+
+  GPUh() const LayerTiming& getClockLayer() const noexcept
+  {
+    return mLayers[getClock()];
+  }
+
+  GPUhdi() const TableEntry& getOverlap(int32_t from, int32_t to, size_t rofIdx) const noexcept
+  {
+    assert(from < NLayers && to < NLayers);
+    const size_t linearIdx = (from * NLayers) + to;
+    const auto& idx = mIndices[linearIdx];
+    assert(rofIdx < idx.getEntries());
+    return mFlatTable[idx.getFirstEntry() + rofIdx];
+  }
+
+  GPUhdi() bool doROFsOverlap(int32_t layer0, size_t rof0, int32_t layer1, size_t rof1) const noexcept
+  {
+    if (layer0 == layer1) { // layer is compatible with itself
+      return rof0 == rof1;
+    }
+
+    assert(layer0 < NLayers && layer1 < NLayers);
+    const size_t linearIdx = (layer0 * NLayers) + layer1;
+    const auto& idx = mIndices[linearIdx];
+
+    if (rof0 >= idx.getEntries()) {
+      return false;
+    }
+
+    const auto& overlap = mFlatTable[idx.getFirstEntry() + rof0];
+
+    if (overlap.getEntries() == 0) {
+      return false;
+    }
+
+    const size_t firstCompatible = overlap.getFirstEntry();
+    const size_t lastCompatible = firstCompatible + overlap.getEntries() - 1;
+    return rof1 >= firstCompatible && rof1 <= lastCompatible;
+  }
+
+  GPUhdi() TimeEstBC getTimeStamp(int32_t layer0, size_t rof0, int32_t layer1, size_t rof1) const noexcept
+  {
+    assert(layer0 < NLayers && layer1 < NLayers);
+    assert(doROFsOverlap(layer0, rof0, layer1, rof1));
+    // retrieves the combined timestamp
+    // e.g., taking one cluster from rof0 and one from rof1
+    //       and constructing a tracklet (doublet) what is its time
+    // this assumes that the rofs overlap, e.g. doROFsOverlap -> true
+    // get timestamp including margins from rof0 and rof1
+    const auto t0 = mLayers[layer0].getROFTimeBounds(rof0, true);
+    const auto t1 = mLayers[layer1].getROFTimeBounds(rof1, true);
+    return t0 + t1;
+  }
+
+#ifndef GPUCA_GPUCODE
+  /// Print functions
+  GPUh() void printAll() const
+  {
+    for (int32_t i = 0; i < NLayers; ++i) {
+      for (int32_t j = 0; j < NLayers; ++j) {
+        if (i != j) {
+          printMapping(i, j);
+        }
+      }
+    }
+    printSummary();
+  }
+
+  GPUh() void printMapping(int32_t from, int32_t to) const
+  {
+    if (from == to) {
+      LOGP(error, "No self-lookup supported");
+      return;
+    }
+
+    constexpr int w_index = 10;
+    constexpr int w_first = 12;
+    constexpr int w_last = 12;
+    constexpr int w_count = 10;
+
+    LOGF(info, "Overlap mapping: Layer %d -> Layer %d", from, to);
+    LOGP(info, "From: {}", mLayers[from].asString());
+    LOGP(info, "To  : {}", mLayers[to].asString());
+    LOGF(info, "%*s | %*s | %*s | %*s", w_index, "ROF.index", w_first, "First.ROF", w_last, "Last.ROF", w_count, "Count");
+    LOGF(info, "%.*s-+-%.*s-+-%.*s-+-%.*s", w_index, "----------", w_first, "------------", w_last, "------------", w_count, "----------");
+
+    const size_t linearIdx = (from * NLayers) + to;
+    const auto& idx = mIndices[linearIdx];
+    for (int32_t i = 0; i < idx.getEntries(); ++i) {
+      const auto& overlap = getOverlap(from, to, i);
+      LOGF(info, "%*d | %*d | %*d | %*d", w_index, i, w_first, overlap.getFirstEntry(), w_last, overlap.getEntriesBound() - 1, w_count, overlap.getEntries());
+    }
+  }
+
+  GPUh() void printSummary() const
+  {
+    uint32_t totalEntries{0};
+    size_t flatTableSize{0};
+
+    for (int32_t i = 0; i < NLayers; ++i) {
+      for (int32_t j = 0; j < NLayers; ++j) {
+        if (i != j) {
+          const size_t linearIdx = (i * NLayers) + j;
+          const auto& idx = mIndices[linearIdx];
+          totalEntries += idx.getEntries();
+          flatTableSize += idx.getEntries();
+        }
+      }
+    }
+
+    for (int32_t i = 0; i < NLayers; ++i) {
+      mLayers[i].print();
+    }
+
+    const uint32_t totalBytes = (flatTableSize * sizeof(TableEntry)) + (static_cast<unsigned long>(NLayers * NLayers) * sizeof(TableIndex));
+    LOGF(info, "------------------------------------------------------------");
+    LOGF(info, "Total overlap table size: %u entries", totalEntries);
+    LOGF(info, "Flat table size: %zu entries", flatTableSize);
+    LOGF(info, "Total view size: %u bytes", totalBytes);
+    LOGF(info, "------------------------------------------------------------");
+  }
+#endif
+};
+
+// Precalculated lookup table to find overlapping ROFs in another layer given a ROF index in the current layer
+template <int32_t NLayers>
+class ROFOverlapTable : public LayerTimingBase<NLayers>
+{
+ public:
+  using T = LayerTimingBase<NLayers>::T;
+  using TableEntry = dataformats::RangeReference<T, T>;
+  using TableIndex = dataformats::RangeReference<T, T>;
+
+  using View = ROFOverlapTableView<NLayers, TableEntry, TableIndex>;
+  ROFOverlapTable() = default;
+
+  GPUh() void init()
+  {
+    std::vector<TableEntry> table[NLayers][NLayers];
+    for (int32_t i{0}; i < NLayers; ++i) {
+      for (int32_t j{0}; j < NLayers; ++j) {
+        if (i != j) { // we do not need self-lookup
+          buildMapping(i, j, table[i][j]);
+        }
+      }
+    }
+    flatten(table);
+  }
+
+  GPUh() View getView() const
+  {
+    View view;
+    view.mFlatTable = mFlatTable.data();
+    view.mIndices = mIndices;
+    view.mLayers = this->mLayers;
+    return view;
+  }
+
+  GPUh() View getDeviceView(const TableEntry* deviceFlatTablePtr, const TableIndex* deviceIndicesPtr, const LayerTiming* deviceLayerTimingPtr) const
+  {
+    View view;
+    view.mFlatTable = deviceFlatTablePtr;
+    view.mIndices = deviceIndicesPtr;
+    view.mLayers = deviceLayerTimingPtr;
+    return view;
+  }
+
+  GPUh() size_t getFlatTableSize() const noexcept { return mFlatTable.size(); }
+  static GPUh() constexpr size_t getIndicesSize() { return static_cast<size_t>(NLayers * NLayers); }
+
+ private:
+  GPUh() void buildMapping(int32_t from, int32_t to, std::vector<TableEntry>& table)
+  {
+    const auto& layerFrom = this->mLayers[from];
+    const auto& layerTo = this->mLayers[to];
+    table.resize(layerFrom.mNROFsTF);
+
+    for (int32_t iROF{0}; iROF < layerFrom.mNROFsTF; ++iROF) {
+      int64_t fromStart = o2::gpu::CAMath::Max((int64_t)layerFrom.getROFStartInBC(iROF) - (int64_t)layerFrom.mROFAddTimeErr, int64_t(0));
+      int64_t fromEnd = (int64_t)layerFrom.getROFEndInBC(iROF) + layerFrom.mROFAddTimeErr;
+
+      int32_t firstROFTo = o2::gpu::CAMath::Max(0, (int32_t)((fromStart - (int64_t)layerTo.mROFAddTimeErr - (int64_t)layerTo.mROFDelay - (int64_t)layerTo.mROFBias) / (int64_t)layerTo.mROFLength));
+      auto lastROFTo = (int32_t)((fromEnd + (int64_t)layerTo.mROFAddTimeErr - (int64_t)layerTo.mROFDelay - (int64_t)layerTo.mROFBias - 1) / (int64_t)layerTo.mROFLength);
+      firstROFTo = o2::gpu::CAMath::Max(0, firstROFTo);
+      lastROFTo = o2::gpu::CAMath::Min((int32_t)layerTo.mNROFsTF - 1, lastROFTo);
+
+      while (firstROFTo <= lastROFTo) {
+        int64_t toStart = o2::gpu::CAMath::Max((int64_t)layerTo.getROFStartInBC(firstROFTo) - (int64_t)layerTo.mROFAddTimeErr, int64_t(0));
+        int64_t toEnd = (int64_t)layerTo.getROFEndInBC(firstROFTo) + layerTo.mROFAddTimeErr;
+        if (toEnd > fromStart && toStart < fromEnd) {
+          break;
+        }
+        ++firstROFTo;
+      }
+      while (lastROFTo >= firstROFTo) {
+        int64_t toStart = o2::gpu::CAMath::Max((int64_t)layerTo.getROFStartInBC(lastROFTo) - (int64_t)layerTo.mROFAddTimeErr, int64_t(0));
+        int64_t toEnd = (int64_t)layerTo.getROFEndInBC(lastROFTo) + layerTo.mROFAddTimeErr;
+        if (toEnd > fromStart && toStart < fromEnd) {
+          break;
+        }
+        --lastROFTo;
+      }
+      int32_t count = (firstROFTo <= lastROFTo) ? (lastROFTo - firstROFTo + 1) : 0;
+      table[iROF] = {static_cast<T>(firstROFTo), static_cast<T>(count)};
+    }
+  }
+
+  GPUh() void flatten(const std::vector<TableEntry> table[NLayers][NLayers])
+  {
+    size_t total{0};
+    for (int32_t i{0}; i < NLayers; ++i) {
+      for (int32_t j{0}; j < NLayers; ++j) {
+        if (i != j) { // we do not need self-lookup
+          total += table[i][j].size();
+        }
+      }
+    }
+
+    mFlatTable.reserve(total);
+
+    for (int32_t i{0}; i < NLayers; ++i) {
+      for (int32_t j{0}; j < NLayers; ++j) {
+        size_t idx = (i * NLayers) + j;
+        if (i != j) {
+          mIndices[idx].setFirstEntry(static_cast<T>(mFlatTable.size()));
+          mIndices[idx].setEntries(static_cast<T>(table[i][j].size()));
+          mFlatTable.insert(mFlatTable.end(), table[i][j].begin(), table[i][j].end());
+        } else {
+          mIndices[idx] = {0, 0};
+        }
+      }
+    }
+  }
+
+  TableIndex mIndices[NLayers * NLayers];
+  std::vector<TableEntry> mFlatTable;
+};
+
+// GPU friendly view of the table below
+template <int32_t NLayers, typename TableEntry, typename TableIndex>
+struct ROFVertexLookupTableView {
+  const TableEntry* mFlatTable{nullptr};
+  const TableIndex* mIndices{nullptr};
+  const LayerTiming* mLayers{nullptr};
+
+  GPUhdi() const LayerTiming& getLayer(int32_t layer) const noexcept
+  {
+    assert(layer >= 0 && layer < NLayers);
+    return mLayers[layer];
+  }
+
+  GPUhdi() const TableEntry& getVertices(int32_t layer, size_t rofIdx) const noexcept
+  {
+    assert(layer < NLayers);
+    const auto& idx = mIndices[layer];
+    assert(rofIdx < idx.getEntries());
+    return mFlatTable[idx.getFirstEntry() + rofIdx];
+  }
+
+  GPUh() int32_t getMaxVerticesPerROF() const noexcept
+  {
+    int32_t maxCount = 0;
+    for (int32_t layer = 0; layer < NLayers; ++layer) {
+      const auto& idx = mIndices[layer];
+      for (int32_t i = 0; i < idx.getEntries(); ++i) {
+        const auto& entry = mFlatTable[idx.getFirstEntry() + i];
+        maxCount = o2::gpu::CAMath::Max(maxCount, static_cast<int32_t>(entry.getEntries()));
+      }
+    }
+    return maxCount;
+  }
+
+  // Check if a specific vertex is compatible with a given ROF
+  GPUhdi() bool isVertexCompatible(int32_t layer, size_t rofIdx, const Vertex& vertex) const noexcept
+  {
+    assert(layer < NLayers);
+    const auto& layerDef = mLayers[layer];
+    int64_t rofLower = o2::gpu::CAMath::Max((int64_t)layerDef.getROFStartInBC(rofIdx) - (int64_t)layerDef.mROFAddTimeErr, int64_t(0));
+    int64_t rofUpper = (int64_t)layerDef.getROFEndInBC(rofIdx) + layerDef.mROFAddTimeErr;
+    auto vLower = (int64_t)vertex.getTimeStamp().lower();
+    auto vUpper = (int64_t)vertex.getTimeStamp().upper();
+    return vUpper >= rofLower && vLower < rofUpper;
+  }
+
+#ifndef GPUCA_GPUCODE
+  GPUh() void printAll() const
+  {
+    for (int32_t i = 0; i < NLayers; ++i) {
+      printLayer(i);
+    }
+    printSummary();
+  }
+
+  GPUh() void printLayer(int32_t layer) const
+  {
+    constexpr int w_rof = 10;
+    constexpr int w_first = 12;
+    constexpr int w_last = 12;
+    constexpr int w_count = 10;
+
+    LOGF(info, "Vertex lookup: Layer %d", layer);
+    LOGF(info, "%*s | %*s | %*s | %*s", w_rof, "ROF.index", w_first, "First.Vtx", w_last, "Last.Vtx", w_count, "Count");
+    LOGF(info, "%.*s-+-%.*s-+-%.*s-+-%.*s", w_rof, "----------", w_first, "------------", w_last, "------------", w_count, "----------");
+
+    const auto& idx = mIndices[layer];
+    for (int32_t i = 0; i < idx.getEntries(); ++i) {
+      const auto& entry = mFlatTable[idx.getFirstEntry() + i];
+      int first = entry.getFirstEntry();
+      int count = entry.getEntries();
+      int last = first + count - 1;
+      LOGF(info, "%*d | %*d | %*d | %*d", w_rof, i, w_first, first, w_last, last, w_count, count);
+    }
+  }
+
+  GPUh() void printSummary() const
+  {
+    uint32_t totalROFs{0};
+    uint32_t totalVertexRefs{0};
+
+    for (int32_t i = 0; i < NLayers; ++i) {
+      const auto& idx = mIndices[i];
+      totalROFs += idx.getEntries();
+
+      for (int32_t j = 0; j < idx.getEntries(); ++j) {
+        const auto& entry = mFlatTable[idx.getFirstEntry() + j];
+        totalVertexRefs += entry.getEntries();
+      }
+    }
+
+    const uint32_t totalBytes = (totalROFs * sizeof(TableEntry)) + (NLayers * sizeof(TableIndex));
+    LOGF(info, "------------------------------------------------------------");
+    LOGF(info, "Total ROFs in table: %u", totalROFs);
+    LOGF(info, "Total vertex references: %u", totalVertexRefs);
+    LOGF(info, "Total view size: %u bytes", totalBytes);
+    LOGF(info, "------------------------------------------------------------");
+  }
+#endif
+};
+
+// Precalculated lookup table to find vertices compatible with ROFs
+// Given a layer and ROF index, returns the range of vertices that overlap in time.
+// The vertex time is defined as symmetrical [t0-e,t0+e]
+// It needs to be guaranteed that the input vertices are sorted by their lower-bound!
+// additionally compatibliyty has to be queried per vertex!
+template <int32_t NLayers>
+class ROFVertexLookupTable : public LayerTimingBase<NLayers>
+{
+ public:
+  using T = LayerTimingBase<NLayers>::T;
+  using BCType = LayerTiming::BCType;
+  using TableEntry = dataformats::RangeReference<T, T>;
+  using TableIndex = dataformats::RangeReference<T, T>;
+  using View = ROFVertexLookupTableView<NLayers, TableEntry, TableIndex>;
+
+  ROFVertexLookupTable() = default;
+
+  GPUh() size_t getFlatTableSize() const noexcept { return mFlatTable.size(); }
+  static GPUh() constexpr size_t getIndicesSize() { return NLayers; }
+
+  // Build the lookup table given a sorted array of vertices
+  // vertices must be sorted by timestamp, then by error (secondary)
+  GPUh() void init(const Vertex* vertices, size_t nVertices)
+  {
+    if (nVertices > std::numeric_limits<T>::max()) {
+      LOGF(fatal, "too many vertices %zu, max supported is %u", nVertices, std::numeric_limits<T>::max());
+    }
+
+    std::vector<TableEntry> table[NLayers];
+    for (int32_t layer{0}; layer < NLayers; ++layer) {
+      buildMapping(layer, vertices, nVertices, table[layer]);
+    }
+    flatten(table);
+  }
+
+  // Pre-allocated needed memory, then use update(...)
+  GPUh() void init()
+  {
+    size_t total{0};
+    for (int32_t layer{0}; layer < NLayers; ++layer) {
+      total += this->mLayers[layer].mNROFsTF;
+    }
+    mFlatTable.resize(total, {0, 0});
+    size_t offset = 0;
+    for (int32_t layer{0}; layer < NLayers; ++layer) {
+      size_t nROFs = this->mLayers[layer].mNROFsTF;
+      mIndices[layer].setFirstEntry(static_cast<T>(offset));
+      mIndices[layer].setEntries(static_cast<T>(nROFs));
+      offset += nROFs;
+    }
+  }
+
+  // Recalculate lookup table with new vertices
+  GPUh() void update(const Vertex* vertices, size_t nVertices)
+  {
+    size_t offset = 0;
+    for (int32_t layer{0}; layer < NLayers; ++layer) {
+      const auto& idx = mIndices[layer];
+      size_t nROFs = idx.getEntries();
+      for (size_t iROF = 0; iROF < nROFs; ++iROF) {
+        updateROFMapping(layer, iROF, vertices, nVertices, offset + iROF);
+      }
+      offset += nROFs;
+    }
+  }
+
+  GPUh() View getView() const
+  {
+    View view;
+    view.mFlatTable = mFlatTable.data();
+    view.mIndices = mIndices;
+    view.mLayers = this->mLayers;
+    return view;
+  }
+
+  GPUh() View getDeviceView(const TableEntry* deviceFlatTablePtr, const TableIndex* deviceIndicesPtr, const LayerTiming* deviceLayerTimingPtr) const
+  {
+    View view;
+    view.mFlatTable = deviceFlatTablePtr;
+    view.mIndices = deviceIndicesPtr;
+    view.mLayers = deviceLayerTimingPtr;
+    return view;
+  }
+
+ private:
+  // Build the mapping for one layer
+  GPUh() void buildMapping(int32_t layer, const Vertex* vertices, size_t nVertices, std::vector<TableEntry>& table)
+  {
+    const auto& layerDef = this->mLayers[layer];
+    table.resize(layerDef.mNROFsTF);
+    size_t vertexSearchStart = 0;
+    for (int32_t iROF{0}; iROF < layerDef.mNROFsTF; ++iROF) {
+      int64_t rofLower = o2::gpu::CAMath::Max((int64_t)layerDef.getROFStartInBC(iROF) - (int64_t)layerDef.mROFAddTimeErr, int64_t(0));
+      int64_t rofUpper = (int64_t)layerDef.getROFEndInBC(iROF) + layerDef.mROFAddTimeErr;
+      size_t lastVertex = binarySearchFirst(vertices, nVertices, vertexSearchStart, rofUpper);
+      size_t firstVertex = vertexSearchStart;
+      while (firstVertex < lastVertex) {
+        auto vUpper = (int64_t)vertices[firstVertex].getTimeStamp().upper();
+        if (vUpper > rofLower) {
+          break;
+        }
+        ++firstVertex;
+      }
+      size_t count = (lastVertex > firstVertex) ? (lastVertex - firstVertex) : 0;
+      table[iROF] = {static_cast<T>(firstVertex), static_cast<T>(count)};
+      vertexSearchStart = firstVertex;
+    }
+  }
+
+  // Update a single ROF's vertex mapping
+  GPUh() void updateROFMapping(int32_t layer, size_t iROF, const Vertex* vertices, size_t nVertices, size_t flatTableIdx)
+  {
+    const auto& layerDef = this->mLayers[layer];
+    int64_t rofLower = o2::gpu::CAMath::Max((int64_t)layerDef.getROFStartInBC(iROF) - (int64_t)layerDef.mROFAddTimeErr, int64_t(0));
+    int64_t rofUpper = (int64_t)layerDef.getROFEndInBC(iROF) + layerDef.mROFAddTimeErr;
+    size_t lastVertex = binarySearchFirst(vertices, nVertices, 0, rofUpper);
+    size_t firstVertex = 0;
+    while (firstVertex < lastVertex) {
+      int64_t vUpper = (int64_t)vertices[firstVertex].getTimeStamp().getTimeStamp() +
+                       (int64_t)vertices[firstVertex].getTimeStamp().getTimeStampError();
+      if (vUpper > rofLower) {
+        break;
+      }
+      ++firstVertex;
+    }
+    size_t count = (lastVertex > firstVertex) ? (lastVertex - firstVertex) : 0;
+    mFlatTable[flatTableIdx].setFirstEntry(static_cast<T>(firstVertex));
+    mFlatTable[flatTableIdx].setEntries(static_cast<T>(count));
+  }
+
+  // Binary search for first vertex where maxBC >= targetBC
+  GPUh() size_t binarySearchFirst(const Vertex* vertices, size_t nVertices, size_t searchStart, BCType targetBC) const
+  {
+    size_t left = searchStart;
+    size_t right = nVertices;
+    while (left < right) {
+      size_t mid = left + ((right - left) / 2);
+      int64_t lower = (int64_t)vertices[mid].getTimeStamp().getTimeStamp() -
+                      (int64_t)vertices[mid].getTimeStamp().getTimeStampError();
+      if (lower < targetBC) {
+        left = mid + 1;
+      } else {
+        right = mid;
+      }
+    }
+    return left;
+  }
+
+  // Compress the temporary table into a single flat table
+  GPUh() void flatten(const std::vector<TableEntry> table[NLayers])
+  {
+    // Count total entries
+    size_t total{0};
+    for (int32_t i{0}; i < NLayers; ++i) {
+      total += table[i].size();
+    }
+
+    mFlatTable.reserve(total);
+
+    // Build flat table and indices
+    for (int32_t i{0}; i < NLayers; ++i) {
+      mIndices[i].setFirstEntry(static_cast<T>(mFlatTable.size()));
+      mIndices[i].setEntries(static_cast<T>(table[i].size()));
+      mFlatTable.insert(mFlatTable.end(), table[i].begin(), table[i].end());
+    }
+  }
+
+  TableIndex mIndices[NLayers];
+  std::vector<TableEntry> mFlatTable;
+};
+
+// GPU-friendly view of the ROF mask table
+template <int32_t NLayers, typename TableEntry, typename TableIndex>
+struct ROFMaskTableView {
+  const TableEntry* mFlatMask{nullptr};
+  const TableIndex* mLayerROFOffsets{nullptr}; // size NLayers+1
+
+  GPUhdi() bool isROFEnabled(int32_t layer, int32_t rofId) const noexcept
+  {
+    assert(layer >= 0 && layer < NLayers);
+    return mFlatMask[mLayerROFOffsets[layer] + rofId] != 0u;
+  }
+
+#ifndef GPUCA_GPUCODE
+  GPUh() void printAll() const
+  {
+    for (int32_t i = 0; i < NLayers; ++i) {
+      printLayer(i);
+    }
+  }
+
+  GPUh() void printLayer(int32_t layer) const
+  {
+    constexpr int w_rof = 10;
+    constexpr int w_active = 10;
+    int32_t nROFs = mLayerROFOffsets[layer + 1] - mLayerROFOffsets[layer];
+    LOGF(info, "Mask table: Layer %d", layer);
+    LOGF(info, "%*s | %*s", w_rof, "ROF", w_active, "Enabled");
+    LOGF(info, "%.*s-+-%.*s", w_rof, "----------", w_active, "----------");
+    for (int32_t i = 0; i < nROFs; ++i) {
+      LOGF(info, "%*d | %*d", w_rof, i, w_active, (int)isROFEnabled(layer, i));
+    }
+  }
+
+  GPUh() std::string asString(int32_t layer) const
+  {
+    int32_t nROFs = mLayerROFOffsets[layer + 1] - mLayerROFOffsets[layer];
+    int32_t enabledROFs = 0;
+    for (int32_t j = 0; j < nROFs; ++j) {
+      if (isROFEnabled(layer, j)) {
+        ++enabledROFs;
+      }
+    }
+    return std::format("ROFMask on Layer {} ROFs enabled: {}/{}", layer, enabledROFs, nROFs);
+  }
+
+  GPUh() void print(int32_t layer) const
+  {
+    LOG(info) << asString(layer);
+  }
+#endif
+};
+
+// Per-ROF per-layer boolean mask (uint8_t for GPU compatibility).
+template <int32_t NLayers>
+class ROFMaskTable : public LayerTimingBase<NLayers>
+{
+ public:
+  using T = LayerTimingBase<NLayers>::T;
+  using BCRange = dataformats::RangeReference<T, T>;
+  using TableIndex = uint32_t;
+  using TableEntry = uint8_t;
+  using View = ROFMaskTableView<NLayers, TableEntry, TableIndex>;
+
+  ROFMaskTable() = default;
+  GPUh() explicit ROFMaskTable(const LayerTimingBase<NLayers>& timingBase) : LayerTimingBase<NLayers>(timingBase) { init(); }
+
+  GPUh() void init()
+  {
+    int32_t totalROFs = 0;
+    for (int32_t layer{0}; layer < NLayers; ++layer) {
+      mLayerROFOffsets[layer] = totalROFs;
+      totalROFs += this->getLayer(layer).mNROFsTF;
+    }
+    mLayerROFOffsets[NLayers] = totalROFs; // sentinel
+    mFlatMask.resize(totalROFs, 0u);
+  }
+
+  GPUh() size_t getFlatMaskSize() const noexcept { return mFlatMask.size(); }
+
+  GPUh() void setROFEnabled(int32_t layer, int32_t rofId, uint8_t state = 1) noexcept
+  {
+    assert(layer >= 0 && layer < NLayers);
+    assert(rofId >= 0 && rofId < mLayerROFOffsets[layer + 1] - mLayerROFOffsets[layer]);
+    mFlatMask[mLayerROFOffsets[layer] + rofId] = state;
+  }
+
+  GPUh() void setROFsEnabled(int32_t layer, int32_t firstRof, int32_t nRofs, uint8_t state = 1) noexcept
+  {
+    assert(layer >= 0 && layer < NLayers);
+    assert(firstRof >= 0);
+    assert(firstRof + nRofs <= mLayerROFOffsets[layer + 1] - mLayerROFOffsets[layer]);
+    std::memset(mFlatMask.data() + mLayerROFOffsets[layer] + firstRof, state, nRofs);
+  }
+
+  // Enable all ROFs in all layers that are time-compatible with the given BC range
+  GPUh() void selectROF(const BCRange& t)
+  {
+    const int32_t bcStart = t.getFirstEntry();
+    const int32_t bcEnd = t.getEntriesBound();
+    for (int32_t layer{0}; layer < NLayers; ++layer) {
+      const auto& lay = this->getLayer(layer);
+      const int32_t offset = mLayerROFOffsets[layer];
+      for (int32_t rofId{0}; rofId < lay.mNROFsTF; ++rofId) {
+        if (static_cast<int32_t>(lay.getROFStartInBC(rofId)) < bcEnd &&
+            static_cast<int32_t>(lay.getROFEndInBC(rofId)) > bcStart) {
+          mFlatMask[offset + rofId] = 1u;
+        }
+      }
+    }
+  }
+
+  // Reset mask to 0, then enable all ROFs compatible with any of the given BC ranges
+  GPUh() void selectROFs(const std::vector<BCRange>& ts)
+  {
+    resetMask();
+    for (const auto& t : ts) {
+      selectROF(t);
+    }
+  }
+
+  GPUh() void resetMask(uint8_t s = 0u)
+  {
+    std::memset(mFlatMask.data(), s, mFlatMask.size());
+  }
+
+  GPUh() void invertMask()
+  {
+    std::ranges::transform(mFlatMask, mFlatMask.begin(), [](uint8_t x) { return 1 - x; });
+  }
+
+  GPUh() void swap(ROFMaskTable& other) noexcept
+  {
+    std::swap(mFlatMask, other.mFlatMask);
+    std::swap(mLayerROFOffsets, other.mLayerROFOffsets);
+  }
+
+  GPUh() View getView() const
+  {
+    View view;
+    view.mFlatMask = mFlatMask.data();
+    view.mLayerROFOffsets = mLayerROFOffsets;
+    return view;
+  }
+
+  GPUh() View getDeviceView(const TableEntry* deviceFlatMaskPtr, const TableIndex* deviceOffsetPtr) const
+  {
+    View view;
+    view.mFlatMask = deviceFlatMaskPtr;
+    view.mLayerROFOffsets = deviceOffsetPtr;
+    return view;
+  }
+
+ private:
+  TableIndex mLayerROFOffsets[NLayers + 1] = {0};
+  std::vector<TableEntry> mFlatMask;
+};
+
+} // namespace o2::its
+
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
deleted file mode 100644
index 009f3a1b5b146..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Road.h
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file Road.h
-/// \brief
-///
-
-#ifndef TRACKINGCA_INCLUDE_ROAD_H
-#define TRACKINGCA_INCLUDE_ROAD_H
-
-#include <array>
-
-#include "ITStracking/Constants.h"
-#include "GPUCommonDef.h"
-
-namespace o2::its
-{
-
-template <unsigned char maxRoadSize>
-class Road final
-{
- public:
-  GPUhdDefault() Road() = default;
-  GPUhd() Road(int cellLayer, int cellId) : Road() { addCell(cellLayer, cellId); }
-
-  GPUhdDefault() Road(const Road&) = default;
-  GPUhdDefault() Road(Road&&) noexcept = default;
-  GPUhdDefault() ~Road() = default;
-
-  GPUhdDefault() Road& operator=(const Road&) = default;
-  GPUhdDefault() Road& operator=(Road&&) noexcept = default;
-
-  GPUhdi() uint8_t getRoadSize() const { return mRoadSize; }
-  GPUhdi() bool isFakeRoad() const { return mIsFakeRoad; }
-  GPUhdi() void setFakeRoad(const bool fake) { mIsFakeRoad = fake; }
-  GPUhdi() int& operator[](const int& i) { return mCellIds[i]; }
-  GPUhdi() int operator[](const int& i) const { return mCellIds[i]; }
-
-  GPUhd() void resetRoad()
-  {
-    for (int i = 0; i < maxRoadSize; i++) {
-      mCellIds[i] = constants::UnusedIndex;
-    }
-    mRoadSize = 0;
-  }
-
-  GPUhd() void addCell(int cellLayer, int cellId)
-  {
-    if (mCellIds[cellLayer] == constants::UnusedIndex) {
-      ++mRoadSize;
-    }
-
-    mCellIds[cellLayer] = cellId;
-  }
-
- private:
-  std::array<int, maxRoadSize> mCellIds = constants::helpers::initArray<int, maxRoadSize, constants::UnusedIndex>();
-  unsigned char mRoadSize{0};
-  bool mIsFakeRoad{false};
-};
-
-} // namespace o2::its
-
-#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Smoother.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Smoother.h
deleted file mode 100644
index 101f4b8d72601..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Smoother.h
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-//
-/// \file Smoother.h
-/// \brief Class to handle Kalman smoothing for ITS tracking.
-///         Its instance stores the state of the track to the level we want to smooth to avoid multiple re-propagations when testing different clusters.
-///
-
-#include "ReconstructionDataFormats/Track.h"
-#include "DataFormatsITS/TrackITS.h"
-#include "DetectorsBase/Propagator.h"
-
-namespace o2
-{
-namespace its
-{
-
-template <unsigned int D>
-class Smoother
-{
- public:
-  // Smoother(TrackITSExt& track, size_t layer, const ROframe& event, float bZ, o2::base::PropagatorF::MatCorrType corr);
-  ~Smoother();
-
-  bool isValidInit() const
-  {
-    return mInitStatus;
-  }
-  // bool testCluster(const int clusterId, const ROframe& event);
-  bool getSmoothedTrack();
-  float getChi2() const { return mBestChi2; }
-  float getLastChi2() const { return mLastChi2; }
-
- private:
-  float computeSmoothedPredictedChi2(const o2::track::TrackParCov& outwTrack,
-                                     const o2::track::TrackParCov& inwTrack,
-                                     const std::array<float, 2>& cls,
-                                     const std::array<float, 3>& clCov);
-  bool smoothTrack();
-
- private:
-  size_t mLayerToSmooth;                    // Layer to compute smoothing optimization
-  float mBz;                                // Magnetic field along Z
-  bool mInitStatus;                         // State after the initialization
-  o2::base::PropagatorF::MatCorrType mCorr; // Type of correction to use
-  TrackITSExt mInwardsTrack;                // outwards track: from innermost cluster to outermost
-  TrackITSExt mOutwardsTrack;               // inwards track: from outermost cluster to innermost
-  float mBestChi2;                          // Best value of local smoothed chi2
-  float mLastChi2 = 1e8;                    // Latest computed chi2
-};
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index acc884ea68b8b..3dd1b05cf8969 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -21,6 +21,7 @@
 #include <gsl/gsl>
 
 #include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsITS/Vertex.h"
 
 #include "ITStracking/Cell.h"
 #include "ITStracking/Cluster.h"
@@ -28,15 +29,14 @@
 #include "ITStracking/Constants.h"
 #include "ITStracking/ClusterLines.h"
 #include "ITStracking/Definitions.h"
-#include "ITStracking/Road.h"
 #include "ITStracking/Tracklet.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/ExternalAllocator.h"
 #include "ITStracking/BoundedAllocator.h"
+#include "ITStracking/ROFLookupTables.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 
-#include "ReconstructionDataFormats/Vertex.h"
 #include "DetectorsBase/Propagator.h"
 
 namespace o2
@@ -62,48 +62,42 @@ template <int>
 class TimeFrameGPU;
 }
 
-template <int nLayers = 7>
+template <int NLayers>
 struct TimeFrame {
-  using IndexTableUtilsN = IndexTableUtils<nLayers>;
-  using CellSeedN = CellSeed<nLayers>;
-  friend class gpu::TimeFrameGPU<nLayers>;
+  using IndexTableUtilsN = IndexTableUtils<NLayers>;
+  using ROFOverlapTableN = ROFOverlapTable<NLayers>;
+  using ROFVertexLookupTableN = ROFVertexLookupTable<NLayers>;
+  using ROFMaskTableN = ROFMaskTable<NLayers>;
+  using CellSeedN = CellSeed<NLayers>;
+  friend class gpu::TimeFrameGPU<NLayers>;
 
   TimeFrame() = default;
   virtual ~TimeFrame() = default;
 
   const Vertex& getPrimaryVertex(const int ivtx) const { return mPrimaryVertices[ivtx]; }
-  gsl::span<const Vertex> getPrimaryVertices(int rofId) const;
-  gsl::span<const Vertex> getPrimaryVertices(int romin, int romax) const;
-  gsl::span<const std::pair<MCCompLabel, float>> getPrimaryVerticesMCRecInfo(const int rofId) const;
-  gsl::span<const MCCompLabel> getPrimaryVerticesContributors(const int rofId) const;
-  gsl::span<const std::array<float, 2>> getPrimaryVerticesXAlpha(int rofId) const;
-  void fillPrimaryVerticesXandAlpha();
-  int getPrimaryVerticesNum(int rofId = -1) const;
-  void addPrimaryVerticesLabels(bounded_vector<std::pair<MCCompLabel, float>>& labels);
-  void addPrimaryVerticesContributorLabels(bounded_vector<MCCompLabel>& labels);
-  void addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int iteration);
-  void addPrimaryVerticesInROF(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration);
-  void addPrimaryVerticesLabelsInROF(const bounded_vector<std::pair<MCCompLabel, float>>& labels, const int rofId);
-  void addPrimaryVerticesContributorLabelsInROF(const bounded_vector<MCCompLabel>& labels, const int rofId);
-  void removePrimaryVerticesInROf(const int rofId);
-  int loadROFrameData(const o2::itsmft::ROFRecord& rof, gsl::span<const itsmft::Cluster> clusters,
-                      const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
-
-  int loadROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
-                      gsl::span<const itsmft::CompClusterExt> clusters,
-                      gsl::span<const unsigned char>::iterator& pattIt,
-                      const itsmft::TopologyDictionary* dict,
-                      const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
-  void resetROFrameData(size_t nROFs);
-  void prepareROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
-                          gsl::span<const itsmft::CompClusterExt> clusters);
+  auto& getPrimaryVertices() { return mPrimaryVertices; };
+  auto getPrimaryVerticesNum() { return mPrimaryVertices.size(); };
+  const auto& getPrimaryVertices() const { return mPrimaryVertices; };
+  auto& getPrimaryVerticesLabels() { return mPrimaryVerticesLabels; };
+  gsl::span<const Vertex> getPrimaryVertices(int layer, int rofId) const;
+  void addPrimaryVertex(const Vertex& vertex);
+  void addPrimaryVertexLabel(const VertexLabel& label) { mPrimaryVerticesLabels.push_back(label); }
+
+  // read-in data
+  void loadROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
+                       gsl::span<const itsmft::CompClusterExt> clusters,
+                       gsl::span<const unsigned char>::iterator& pattIt,
+                       const itsmft::TopologyDictionary* dict,
+                       int layer,
+                       const dataformats::MCTruthContainer<MCCompLabel>* mcLabels = nullptr);
+  void resetROFrameData(int iLayer);
+  void prepareROFrameData(gsl::span<const itsmft::CompClusterExt> clusters, int layer);
 
   int getTotalClusters() const;
-  auto& getTotVertIteration() { return mTotVertPerIteration; }
   bool empty() const { return getTotalClusters() == 0; }
   int getSortedIndex(int rofId, int layer, int idx) const { return mROFramesClusters[layer][rofId] + idx; }
   int getSortedStartIndex(const int rofId, const int layer) const { return mROFramesClusters[layer][rofId]; }
-  int getNrof() const { return mNrof; }
+  int getNrof(int layer) const { return mROFramesClusters[layer].size() - 1; }
 
   void resetBeamXY(const float x, const float y, const float w = 0);
   void setBeamPosition(const float x, const float y, const float s2, const float base = 50.f, const float systematic = 0.f)
@@ -114,6 +108,8 @@ struct TimeFrame {
 
   float getBeamX() const { return mBeamPos[0]; }
   float getBeamY() const { return mBeamPos[1]; }
+  std::array<float, 2>& getBeamXY() { return mBeamPos; }
+
   auto& getMinRs() { return mMinR; }
   auto& getMaxRs() { return mMaxR; }
   float getMinR(int layer) const { return mMinR[layer]; }
@@ -134,29 +130,56 @@ struct TimeFrame {
   gsl::span<const int> getROFramesClustersPerROFrange(int rofMin, int range, int layerId) const;
   gsl::span<const int> getROFrameClusters(int layerId) const;
   gsl::span<const int> getNClustersROFrange(int rofMin, int range, int layerId) const;
-  gsl::span<const int> getIndexTablePerROFrange(int rofMin, int range, int layerId) const;
   gsl::span<int> getIndexTable(int rofId, int layerId);
-  auto& getIndexTableWhole(int layerId) { return mIndexTables[layerId]; }
   const auto& getTrackingFrameInfoOnLayer(int layerId) const { return mTrackingFrameInfo[layerId]; }
 
+  // navigation tables
+  const auto& getIndexTableUtils() const { return mIndexTableUtils; }
+  const auto& getROFOverlapTable() const { return mROFOverlapTable; }
+  const auto& getROFOverlapTableView() const { return mROFOverlapTableView; }
+  void setROFOverlapTable(ROFOverlapTableN table)
+  {
+    mROFOverlapTable = std::move(table);
+    mROFOverlapTableView = mROFOverlapTable.getView();
+  }
+  const auto& getROFVertexLookupTable() const { return mROFVertexLookupTable; }
+  const auto& getROFVertexLookupTableView() const { return mROFVertexLookupTableView; }
+  void setROFVertexLookupTable(ROFVertexLookupTableN table)
+  {
+    mROFVertexLookupTable = std::move(table);
+    mROFVertexLookupTableView = mROFVertexLookupTable.getView();
+  }
+  void updateROFVertexLookupTable() { mROFVertexLookupTable.update(mPrimaryVertices.data(), mPrimaryVertices.size()); }
+  void setMultiplicityCutMask(ROFMaskTableN cutMask)
+  {
+    mMultiplicityCutMask = std::move(cutMask);
+    mROFMaskView = mROFMask->getView();
+  }
+  void useMultiplictyMask() noexcept
+  {
+    mROFMask = &mMultiplicityCutMask;
+    mROFMaskView = mROFMask->getView();
+  }
+  void setUPCCutMask(ROFMaskTableN cutMask) { mUPCCutMask = std::move(cutMask); }
+  void useUPCMask() noexcept
+  {
+    mROFMask = &mUPCCutMask;
+    mROFMaskView = mROFMask->getView();
+  }
+  const auto& getROFMaskView() const { return mROFMaskView; }
+
   const TrackingFrameInfo& getClusterTrackingFrameInfo(int layerId, const Cluster& cl) const;
   gsl::span<const MCCompLabel> getClusterLabels(int layerId, const Cluster& cl) const { return getClusterLabels(layerId, cl.clusterId); }
-  gsl::span<const MCCompLabel> getClusterLabels(int layerId, const int clId) const { return mClusterLabels->getLabels(mClusterExternalIndices[layerId][clId]); }
+  gsl::span<const MCCompLabel> getClusterLabels(int layerId, const int clId) const { return mClusterLabels[((mIsStaggered) ? layerId : 0)]->getLabels(mClusterExternalIndices[layerId][clId]); }
   int getClusterExternalIndex(int layerId, const int clId) const { return mClusterExternalIndices[layerId][clId]; }
-  int getClusterSize(int clusterId) const { return mClusterSize[clusterId]; }
-  void setClusterSize(bounded_vector<uint8_t>& v) { mClusterSize = std::move(v); }
+  int getClusterSize(int layer, int clusterId) const { return mClusterSize[layer][clusterId]; }
+  void setClusterSize(int layer, bounded_vector<uint8_t>& v) { mClusterSize[layer] = std::move(v); }
 
   auto& getTrackletsLabel(int layer) { return mTrackletLabels[layer]; }
   auto& getCellsLabel(int layer) { return mCellLabels[layer]; }
 
-  bool hasMCinformation() const { return mClusterLabels; }
-  void initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers = 7, bool resetVertices = true);
-  void resetRofPV()
-  {
-    deepVectorClear(mPrimaryVertices);
-    mROFramesPV.resize(1, 0);
-    mTotVertPerIteration.resize(1);
-  }
+  bool hasMCinformation() const { return mClusterLabels[0] != nullptr; }
+  void initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers = NLayers, bool resetVertices = true);
 
   bool isClusterUsed(int layer, int clusterId) const { return mUsedClusters[layer][clusterId]; }
   void markUsedCluster(int layer, int clusterId) { mUsedClusters[layer][clusterId] = true; }
@@ -173,20 +196,16 @@ struct TimeFrame {
   auto& getCellsLookupTable() { return mCellsLookupTable; }
   auto& getCellsNeighbours() { return mCellsNeighbours; }
   auto& getCellsNeighboursLUT() { return mCellsNeighboursLUT; }
-  auto& getRoads() { return mRoads; }
-  auto& getTracks(int rofId) { return mTracks[rofId]; }
-  auto& getTracksLabel(const int rofId) { return mTracksLabel[rofId]; }
+  auto& getTracks() { return mTracks; }
+  auto& getTracksLabel() { return mTracksLabel; }
   auto& getLinesLabel(const int rofId) { return mLinesLabels[rofId]; }
-  auto& getVerticesMCRecInfo() { return mVerticesMCRecInfo; }
 
-  int getNumberOfClusters() const;
-  virtual int getNumberOfCells() const;
-  virtual int getNumberOfTracklets() const;
-  virtual int getNumberOfNeighbours() const;
+  size_t getNumberOfClusters() const;
+  virtual size_t getNumberOfCells() const;
+  virtual size_t getNumberOfTracklets() const;
+  virtual size_t getNumberOfNeighbours() const;
   size_t getNumberOfTracks() const;
   size_t getNumberOfUsedClusters() const;
-  auto getNumberOfExtendedTracks() const { return mNExtendedTracks; }
-  auto getNumberOfUsedExtendedClusters() const { return mNExtendedUsedClusters; }
 
   /// memory management
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool);
@@ -195,10 +214,8 @@ struct TimeFrame {
   unsigned long getArtefactsMemory() const;
   void printArtefactsMemory() const;
 
-  /// ROF cuts
-  int getROFCutClusterMult() const { return mCutClusterMult; };
-  int getROFCutVertexMult() const { return mCutVertexMult; };
-  int getROFCutAllMult() const { return mCutClusterMult + mCutVertexMult; }
+  /// staggering
+  void setIsStaggered(bool b) noexcept { mIsStaggered = b; }
 
   // Vertexer
   void computeTrackletsPerROFScans();
@@ -215,20 +232,8 @@ struct TimeFrame {
   gsl::span<int> getExclusiveNTrackletsCluster(int rofId, int combId);
   uint32_t getTotalTrackletsTF(const int iLayer) { return mTotalTracklets[iLayer]; }
   int getTotalClustersPerROFrange(int rofMin, int range, int layerId) const;
-  std::array<float, 2>& getBeamXY() { return mBeamPos; }
-  unsigned int& getNoVertexROF() { return mNoVertexROF; }
-  void insertPastVertex(const Vertex& vertex, const int refROFId);
   // \Vertexer
 
-  void initialiseRoadLabels();
-  void setRoadLabel(int i, const unsigned long long& lab, bool fake);
-  const unsigned long long& getRoadLabel(int i) const { return mRoadLabels[i].first; }
-  bool isRoadFake(int i) const { return mRoadLabels[i].second; }
-
-  void setMultiplicityCutMask(const std::vector<uint8_t>& cutMask) { mMultiplicityCutMask = cutMask; }
-  void setROFMask(const std::vector<uint8_t>& rofMask) { mROFMask = rofMask; }
-  void swapMasks() { mMultiplicityCutMask.swap(mROFMask); }
-
   int hasBogusClusters() const { return std::accumulate(mBogusClusters.begin(), mBogusClusters.end(), 0); }
 
   void setBz(float bz) { mBz = bz; }
@@ -252,44 +257,25 @@ struct TimeFrame {
   void addTrackingFrameInfoToLayer(int layer, T&&... args);
   void addClusterExternalIndexToLayer(int layer, const int idx) { mClusterExternalIndices[layer].push_back(idx); }
 
-  /// Debug and printing
-  void checkTrackletLUTs();
-  void printROFoffsets();
-  void printNClsPerROF();
-  void printVertices();
-  void printTrackletLUTonLayer(int i);
-  void printCellLUTonLayer(int i);
-  void printTrackletLUTs();
-  void printCellLUTs();
-  void printSliceInfo(const int, const int);
-
-  IndexTableUtilsN mIndexTableUtils;
-
-  std::array<bounded_vector<Cluster>, nLayers> mClusters;
-  std::array<bounded_vector<TrackingFrameInfo>, nLayers> mTrackingFrameInfo;
-  std::array<bounded_vector<int>, nLayers> mClusterExternalIndices;
-  std::array<bounded_vector<int>, nLayers> mROFramesClusters;
-  const dataformats::MCTruthContainer<MCCompLabel>* mClusterLabels = nullptr;
+  std::array<bounded_vector<Cluster>, NLayers> mClusters;
+  std::array<bounded_vector<TrackingFrameInfo>, NLayers> mTrackingFrameInfo;
+  std::array<bounded_vector<int>, NLayers> mClusterExternalIndices;
+  std::array<bounded_vector<int>, NLayers> mROFramesClusters;
+  std::array<const dataformats::MCTruthContainer<MCCompLabel>*, NLayers> mClusterLabels{nullptr};
   std::array<bounded_vector<int>, 2> mNTrackletsPerCluster;
   std::array<bounded_vector<int>, 2> mNTrackletsPerClusterSum;
-  std::array<bounded_vector<int>, nLayers> mNClustersPerROF;
-  std::array<bounded_vector<int>, nLayers> mIndexTables;
+  std::array<bounded_vector<int>, NLayers> mNClustersPerROF;
+  std::array<bounded_vector<int>, NLayers> mIndexTables;
   std::vector<bounded_vector<int>> mTrackletsLookupTable;
-  std::array<bounded_vector<uint8_t>, nLayers> mUsedClusters;
-  int mNrof = 0;
-  int mNExtendedTracks{0};
-  int mNExtendedUsedClusters{0};
-  bounded_vector<int> mROFramesPV;
-  bounded_vector<Vertex> mPrimaryVertices;
+  std::array<bounded_vector<uint8_t>, NLayers> mUsedClusters;
 
-  std::array<bounded_vector<Cluster>, nLayers> mUnsortedClusters;
+  std::array<bounded_vector<Cluster>, NLayers> mUnsortedClusters;
   std::vector<bounded_vector<Tracklet>> mTracklets;
   std::vector<bounded_vector<CellSeedN>> mCells;
-  bounded_vector<Road<nLayers - 2>> mRoads;
-  std::vector<bounded_vector<TrackITSExt>> mTracks;
+  bounded_vector<TrackITSExt> mTracks;
+  bounded_vector<MCCompLabel> mTracksLabel;
   std::vector<bounded_vector<int>> mCellsNeighbours;
   std::vector<bounded_vector<int>> mCellsLookupTable;
-  std::vector<uint8_t> mMultiplicityCutMask;
 
   const o2::base::PropagatorImpl<float>* mPropagatorDevice = nullptr; // Needed only for GPU
 
@@ -300,279 +286,210 @@ struct TimeFrame {
   virtual const char* getName() const noexcept { return "CPU"; }
 
  protected:
-  void prepareClusters(const TrackingParameters& trkParam, const int maxLayers = nLayers);
+  void prepareClusters(const TrackingParameters& trkParam, const int maxLayers = NLayers);
   float mBz = 5.;
   unsigned int mNTotalLowPtVertices = 0;
   int mBeamPosWeight = 0;
   std::array<float, 2> mBeamPos = {0.f, 0.f};
   bool isBeamPositionOverridden = false;
-  std::array<float, nLayers> mMinR;
-  std::array<float, nLayers> mMaxR;
+  std::array<float, NLayers> mMinR;
+  std::array<float, NLayers> mMaxR;
   bounded_vector<float> mMSangles;
   bounded_vector<float> mPhiCuts;
   bounded_vector<float> mPositionResolution;
-  bounded_vector<uint8_t> mClusterSize;
+  std::array<bounded_vector<uint8_t>, NLayers> mClusterSize;
 
-  std::vector<uint8_t> mROFMask;
   bounded_vector<std::array<float, 2>> mPValphaX; /// PV x and alpha for track propagation
   std::vector<bounded_vector<MCCompLabel>> mTrackletLabels;
   std::vector<bounded_vector<MCCompLabel>> mCellLabels;
   std::vector<bounded_vector<int>> mCellsNeighboursLUT;
-  std::vector<bounded_vector<MCCompLabel>> mTracksLabel;
   bounded_vector<int> mBogusClusters; /// keep track of clusters with wild coordinates
 
-  bounded_vector<std::pair<unsigned long long, bool>> mRoadLabels;
-  int mCutClusterMult{-999};
-  int mCutVertexMult{-999};
-
   // Vertexer
+  bounded_vector<Vertex> mPrimaryVertices;
+  bounded_vector<VertexLabel> mPrimaryVerticesLabels;
   std::vector<bounded_vector<int>> mNTrackletsPerROF;
   std::vector<bounded_vector<Line>> mLines;
   std::vector<bounded_vector<ClusterLines>> mTrackletClusters;
   std::array<bounded_vector<int>, 2> mTrackletsIndexROF;
   std::vector<bounded_vector<MCCompLabel>> mLinesLabels;
-  std::vector<std::pair<MCCompLabel, float>> mVerticesMCRecInfo;
-  bounded_vector<MCCompLabel> mVerticesContributorLabels;
   std::array<uint32_t, 2> mTotalTracklets = {0, 0};
   uint32_t mTotalLines = 0;
-  unsigned int mNoVertexROF = 0;
-  bounded_vector<int> mTotVertPerIteration;
   // \Vertexer
 
-  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
-};
-
-template <int nLayers>
-inline gsl::span<const Vertex> TimeFrame<nLayers>::getPrimaryVertices(int rofId) const
-{
-  if (mPrimaryVertices.empty()) {
-    return {};
-  }
-  const int start = mROFramesPV[rofId];
-  const int stop_idx = rofId >= mNrof - 1 ? mNrof : rofId + 1;
-  int delta = mMultiplicityCutMask[rofId] ? mROFramesPV[stop_idx] - start : 0; // return empty span if Rof is excluded
-  return {&mPrimaryVertices[start], static_cast<gsl::span<const Vertex>::size_type>(delta)};
-}
+  // lookup tables
+  IndexTableUtilsN mIndexTableUtils;
+  ROFOverlapTableN mROFOverlapTable;
+  ROFOverlapTableN::View mROFOverlapTableView;
+  ROFVertexLookupTableN mROFVertexLookupTable;
+  ROFVertexLookupTableN::View mROFVertexLookupTableView;
+  ROFMaskTableN mMultiplicityCutMask;
+  ROFMaskTableN mUPCCutMask;
+  ROFMaskTableN* mROFMask = &mMultiplicityCutMask;
+  ROFMaskTableN::View mROFMaskView;
 
-template <int nLayers>
-inline gsl::span<const std::pair<MCCompLabel, float>> TimeFrame<nLayers>::getPrimaryVerticesMCRecInfo(const int rofId) const
-{
-  const int start = mROFramesPV[rofId];
-  const int stop_idx = rofId >= mNrof - 1 ? mNrof : rofId + 1;
-  int delta = mMultiplicityCutMask[rofId] ? mROFramesPV[stop_idx] - start : 0; // return empty span if Rof is excluded
-  return {&(mVerticesMCRecInfo[start]), static_cast<gsl::span<const std::pair<MCCompLabel, float>>::size_type>(delta)};
-}
+  bool mIsStaggered{false};
 
-template <int nLayers>
-inline gsl::span<const MCCompLabel> TimeFrame<nLayers>::getPrimaryVerticesContributors(const int rofId) const
-{
-  // count the number of cont. in rofs before target rof
-  unsigned int start{0}, delta{0};
-  const auto& pvsBefore = getPrimaryVertices(0, rofId - 1);
-  for (const auto& pv : pvsBefore) {
-    start += pv.getNContributors();
-  }
-  const auto& pvsIn = getPrimaryVertices(rofId);
-  for (const auto& pv : pvsIn) {
-    delta += pv.getNContributors();
-  }
-  return {&(mVerticesContributorLabels[start]), static_cast<gsl::span<const MCCompLabel>::size_type>(delta)};
-}
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+};
 
-template <int nLayers>
-inline gsl::span<const Vertex> TimeFrame<nLayers>::getPrimaryVertices(int romin, int romax) const
+template <int NLayers>
+gsl::span<const Vertex> TimeFrame<NLayers>::getPrimaryVertices(int layer, int rofId) const
 {
-  if (mPrimaryVertices.empty()) {
+  if (rofId < 0 || rofId >= getNrof(layer)) {
     return {};
   }
-  const int stop_idx = romax >= mNrof - 1 ? mNrof : romax + 1;
-  return {&mPrimaryVertices[mROFramesPV[romin]], static_cast<gsl::span<const Vertex>::size_type>(mROFramesPV[stop_idx] - mROFramesPV[romin])};
-}
-
-template <int nLayers>
-inline gsl::span<const std::array<float, 2>> TimeFrame<nLayers>::getPrimaryVerticesXAlpha(int rofId) const
-{
-  const int start = mROFramesPV[rofId];
-  const int stop_idx = rofId >= mNrof - 1 ? mNrof : rofId + 1;
-  int delta = mMultiplicityCutMask[rofId] ? mROFramesPV[stop_idx] - start : 0; // return empty span if Rof is excluded
-  return {&(mPValphaX[start]), static_cast<gsl::span<const std::array<float, 2>>::size_type>(delta)};
-}
-
-template <int nLayers>
-inline int TimeFrame<nLayers>::getPrimaryVerticesNum(int rofId) const
-{
-  return rofId < 0 ? mPrimaryVertices.size() : mROFramesPV[rofId + 1] - mROFramesPV[rofId];
+  const auto& entry = mROFVertexLookupTableView.getVertices(layer, rofId);
+  return {&mPrimaryVertices[entry.getFirstEntry()], static_cast<gsl::span<const Vertex>::size_type>(entry.getEntries())};
 }
 
-template <int nLayers>
-inline void TimeFrame<nLayers>::resetBeamXY(const float x, const float y, const float w)
+template <int NLayers>
+inline void TimeFrame<NLayers>::resetBeamXY(const float x, const float y, const float w)
 {
   mBeamPos[0] = x;
   mBeamPos[1] = y;
   mBeamPosWeight = w;
 }
 
-template <int nLayers>
-inline gsl::span<const int> TimeFrame<nLayers>::getROFrameClusters(int layerId) const
+template <int NLayers>
+inline gsl::span<const int> TimeFrame<NLayers>::getROFrameClusters(int layerId) const
 {
   return {&mROFramesClusters[layerId][0], static_cast<gsl::span<const int>::size_type>(mROFramesClusters[layerId].size())};
 }
 
-template <int nLayers>
-inline gsl::span<Cluster> TimeFrame<nLayers>::getClustersOnLayer(int rofId, int layerId)
+template <int NLayers>
+inline gsl::span<Cluster> TimeFrame<NLayers>::getClustersOnLayer(int rofId, int layerId)
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(layerId)) {
     return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
   return {&mClusters[layerId][startIdx], static_cast<gsl::span<Cluster>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<const Cluster> TimeFrame<nLayers>::getClustersOnLayer(int rofId, int layerId) const
+template <int NLayers>
+inline gsl::span<const Cluster> TimeFrame<NLayers>::getClustersOnLayer(int rofId, int layerId) const
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(layerId)) {
     return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
   return {&mClusters[layerId][startIdx], static_cast<gsl::span<const Cluster>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<uint8_t> TimeFrame<nLayers>::getUsedClustersROF(int rofId, int layerId)
+template <int NLayers>
+inline gsl::span<uint8_t> TimeFrame<NLayers>::getUsedClustersROF(int rofId, int layerId)
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(layerId)) {
     return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
   return {&mUsedClusters[layerId][startIdx], static_cast<gsl::span<uint8_t>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<const uint8_t> TimeFrame<nLayers>::getUsedClustersROF(int rofId, int layerId) const
+template <int NLayers>
+inline gsl::span<const uint8_t> TimeFrame<NLayers>::getUsedClustersROF(int rofId, int layerId) const
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(layerId)) {
     return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
   return {&mUsedClusters[layerId][startIdx], static_cast<gsl::span<const uint8_t>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<const Cluster> TimeFrame<nLayers>::getClustersPerROFrange(int rofMin, int range, int layerId) const
+template <int NLayers>
+inline gsl::span<const Cluster> TimeFrame<NLayers>::getClustersPerROFrange(int rofMin, int range, int layerId) const
 {
-  if (rofMin < 0 || rofMin >= mNrof) {
+  if (rofMin < 0 || rofMin >= getNrof(layerId)) {
     return {};
   }
   int startIdx{mROFramesClusters[layerId][rofMin]}; // First cluster of rofMin
-  int endIdx{mROFramesClusters[layerId][o2::gpu::CAMath::Min(rofMin + range, mNrof)]};
+  int endIdx{mROFramesClusters[layerId][o2::gpu::CAMath::Min(rofMin + range, getNrof(layerId))]};
   return {&mClusters[layerId][startIdx], static_cast<gsl::span<Cluster>::size_type>(endIdx - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<const int> TimeFrame<nLayers>::getROFramesClustersPerROFrange(int rofMin, int range, int layerId) const
+template <int NLayers>
+inline gsl::span<const int> TimeFrame<NLayers>::getROFramesClustersPerROFrange(int rofMin, int range, int layerId) const
 {
-  int chkdRange{o2::gpu::CAMath::Min(range, mNrof - rofMin)};
+  int chkdRange{o2::gpu::CAMath::Min(range, getNrof(layerId) - rofMin)};
   return {&mROFramesClusters[layerId][rofMin], static_cast<gsl::span<int>::size_type>(chkdRange)};
 }
 
-template <int nLayers>
-inline gsl::span<const int> TimeFrame<nLayers>::getNClustersROFrange(int rofMin, int range, int layerId) const
+template <int NLayers>
+inline gsl::span<const int> TimeFrame<NLayers>::getNClustersROFrange(int rofMin, int range, int layerId) const
 {
-  int chkdRange{o2::gpu::CAMath::Min(range, mNrof - rofMin)};
+  int chkdRange{o2::gpu::CAMath::Min(range, getNrof(layerId) - rofMin)};
   return {&mNClustersPerROF[layerId][rofMin], static_cast<gsl::span<int>::size_type>(chkdRange)};
 }
 
-template <int nLayers>
-inline int TimeFrame<nLayers>::getTotalClustersPerROFrange(int rofMin, int range, int layerId) const
+template <int NLayers>
+inline int TimeFrame<NLayers>::getTotalClustersPerROFrange(int rofMin, int range, int layerId) const
 {
   int startIdx{rofMin}; // First cluster of rofMin
-  int endIdx{o2::gpu::CAMath::Min(rofMin + range, mNrof)};
+  int endIdx{o2::gpu::CAMath::Min(rofMin + range, getNrof(layerId))};
   return mROFramesClusters[layerId][endIdx] - mROFramesClusters[layerId][startIdx];
 }
 
-template <int nLayers>
-inline gsl::span<const int> TimeFrame<nLayers>::getIndexTablePerROFrange(int rofMin, int range, int layerId) const
-{
-  const int iTableSize{mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1};
-  int chkdRange{o2::gpu::CAMath::Min(range, mNrof - rofMin)};
-  return {&mIndexTables[layerId][rofMin * iTableSize], static_cast<gsl::span<int>::size_type>(chkdRange * iTableSize)};
-}
-
-template <int nLayers>
-inline int TimeFrame<nLayers>::getClusterROF(int iLayer, int iCluster)
+template <int NLayers>
+inline int TimeFrame<NLayers>::getClusterROF(int iLayer, int iCluster)
 {
   return std::lower_bound(mROFramesClusters[iLayer].begin(), mROFramesClusters[iLayer].end(), iCluster + 1) - mROFramesClusters[iLayer].begin() - 1;
 }
 
-template <int nLayers>
-inline gsl::span<const Cluster> TimeFrame<nLayers>::getUnsortedClustersOnLayer(int rofId, int layerId) const
+template <int NLayers>
+inline gsl::span<const Cluster> TimeFrame<NLayers>::getUnsortedClustersOnLayer(int rofId, int layerId) const
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(layerId)) {
     return {};
   }
   int startIdx{mROFramesClusters[layerId][rofId]};
   return {&mUnsortedClusters[layerId][startIdx], static_cast<gsl::span<Cluster>::size_type>(mROFramesClusters[layerId][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<int> TimeFrame<nLayers>::getIndexTable(int rofId, int layer)
+template <int NLayers>
+inline gsl::span<int> TimeFrame<NLayers>::getIndexTable(int rofId, int layer)
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(layer)) {
     return {};
   }
   const int tableSize = mIndexTableUtils.getNphiBins() * mIndexTableUtils.getNzBins() + 1;
   return {&mIndexTables[layer][rofId * tableSize], static_cast<gsl::span<int>::size_type>(tableSize)};
 }
 
-template <int nLayers>
+template <int NLayers>
 template <typename... T>
-void TimeFrame<nLayers>::addClusterToLayer(int layer, T&&... values)
+void TimeFrame<NLayers>::addClusterToLayer(int layer, T&&... values)
 {
   mUnsortedClusters[layer].emplace_back(std::forward<T>(values)...);
 }
 
-template <int nLayers>
+template <int NLayers>
 template <typename... T>
-void TimeFrame<nLayers>::addTrackingFrameInfoToLayer(int layer, T&&... values)
+void TimeFrame<NLayers>::addTrackingFrameInfoToLayer(int layer, T&&... values)
 {
   mTrackingFrameInfo[layer].emplace_back(std::forward<T>(values)...);
 }
 
-template <int nLayers>
-inline gsl::span<uint8_t> TimeFrame<nLayers>::getUsedClusters(const int layer)
+template <int NLayers>
+inline gsl::span<uint8_t> TimeFrame<NLayers>::getUsedClusters(const int layer)
 {
   return {&mUsedClusters[layer][0], static_cast<gsl::span<uint8_t>::size_type>(mUsedClusters[layer].size())};
 }
 
-template <int nLayers>
-inline void TimeFrame<nLayers>::initialiseRoadLabels()
+template <int NLayers>
+inline gsl::span<int> TimeFrame<NLayers>::getNTrackletsCluster(int rofId, int combId)
 {
-  mRoadLabels.clear();
-  mRoadLabels.resize(mRoads.size());
-}
-
-template <int nLayers>
-inline void TimeFrame<nLayers>::setRoadLabel(int i, const unsigned long long& lab, bool fake)
-{
-  mRoadLabels[i].first = lab;
-  mRoadLabels[i].second = fake;
-}
-
-template <int nLayers>
-inline gsl::span<int> TimeFrame<nLayers>::getNTrackletsCluster(int rofId, int combId)
-{
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(1)) {
     return {};
   }
   auto startIdx{mROFramesClusters[1][rofId]};
   return {&mNTrackletsPerCluster[combId][startIdx], static_cast<gsl::span<int>::size_type>(mROFramesClusters[1][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<int> TimeFrame<nLayers>::getExclusiveNTrackletsCluster(int rofId, int combId)
+template <int NLayers>
+inline gsl::span<int> TimeFrame<NLayers>::getExclusiveNTrackletsCluster(int rofId, int combId)
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(1)) {
     return {};
   }
   auto clusStartIdx{mROFramesClusters[1][rofId]};
@@ -580,38 +497,38 @@ inline gsl::span<int> TimeFrame<nLayers>::getExclusiveNTrackletsCluster(int rofI
   return {&mNTrackletsPerClusterSum[combId][clusStartIdx], static_cast<gsl::span<int>::size_type>(mROFramesClusters[1][rofId + 1] - clusStartIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<Tracklet> TimeFrame<nLayers>::getFoundTracklets(int rofId, int combId)
+template <int NLayers>
+inline gsl::span<Tracklet> TimeFrame<NLayers>::getFoundTracklets(int rofId, int combId)
 {
-  if (rofId < 0 || rofId >= mNrof || mTracklets[combId].empty()) {
+  if (rofId < 0 || rofId >= getNrof(1) || mTracklets[combId].empty()) {
     return {};
   }
   auto startIdx{mNTrackletsPerROF[combId][rofId]};
   return {&mTracklets[combId][startIdx], static_cast<gsl::span<Tracklet>::size_type>(mNTrackletsPerROF[combId][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<const Tracklet> TimeFrame<nLayers>::getFoundTracklets(int rofId, int combId) const
+template <int NLayers>
+inline gsl::span<const Tracklet> TimeFrame<NLayers>::getFoundTracklets(int rofId, int combId) const
 {
-  if (rofId < 0 || rofId >= mNrof) {
+  if (rofId < 0 || rofId >= getNrof(1)) {
     return {};
   }
   auto startIdx{mNTrackletsPerROF[combId][rofId]};
   return {&mTracklets[combId][startIdx], static_cast<gsl::span<Tracklet>::size_type>(mNTrackletsPerROF[combId][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline gsl::span<const MCCompLabel> TimeFrame<nLayers>::getLabelsFoundTracklets(int rofId, int combId) const
+template <int NLayers>
+inline gsl::span<const MCCompLabel> TimeFrame<NLayers>::getLabelsFoundTracklets(int rofId, int combId) const
 {
-  if (rofId < 0 || rofId >= mNrof || !hasMCinformation()) {
+  if (rofId < 0 || rofId >= getNrof(1) || !hasMCinformation()) {
     return {};
   }
   auto startIdx{mNTrackletsPerROF[combId][rofId]};
   return {&mTrackletLabels[combId][startIdx], static_cast<gsl::span<Tracklet>::size_type>(mNTrackletsPerROF[combId][rofId + 1] - startIdx)};
 }
 
-template <int nLayers>
-inline int TimeFrame<nLayers>::getTotalClusters() const
+template <int NLayers>
+inline int TimeFrame<NLayers>::getTotalClusters() const
 {
   size_t totalClusters{0};
   for (const auto& clusters : mUnsortedClusters) {
@@ -620,58 +537,54 @@ inline int TimeFrame<nLayers>::getTotalClusters() const
   return int(totalClusters);
 }
 
-template <int nLayers>
-inline int TimeFrame<nLayers>::getNumberOfClusters() const
+template <int NLayers>
+inline size_t TimeFrame<NLayers>::getNumberOfClusters() const
 {
-  int nClusters = 0;
+  size_t nClusters{0};
   for (const auto& layer : mClusters) {
     nClusters += layer.size();
   }
   return nClusters;
 }
 
-template <int nLayers>
-inline int TimeFrame<nLayers>::getNumberOfCells() const
+template <int NLayers>
+inline size_t TimeFrame<NLayers>::getNumberOfCells() const
 {
-  int nCells = 0;
+  size_t nCells{0};
   for (const auto& layer : mCells) {
     nCells += layer.size();
   }
   return nCells;
 }
 
-template <int nLayers>
-inline int TimeFrame<nLayers>::getNumberOfTracklets() const
+template <int NLayers>
+inline size_t TimeFrame<NLayers>::getNumberOfTracklets() const
 {
-  int nTracklets = 0;
+  size_t nTracklets{0};
   for (const auto& layer : mTracklets) {
     nTracklets += layer.size();
   }
   return nTracklets;
 }
 
-template <int nLayers>
-inline int TimeFrame<nLayers>::getNumberOfNeighbours() const
+template <int NLayers>
+inline size_t TimeFrame<NLayers>::getNumberOfNeighbours() const
 {
-  int n{0};
+  size_t neigh{0};
   for (const auto& l : mCellsNeighbours) {
-    n += l.size();
+    neigh += l.size();
   }
-  return n;
+  return neigh;
 }
 
-template <int nLayers>
-inline size_t TimeFrame<nLayers>::getNumberOfTracks() const
+template <int NLayers>
+inline size_t TimeFrame<NLayers>::getNumberOfTracks() const
 {
-  int nTracks = 0;
-  for (const auto& t : mTracks) {
-    nTracks += t.size();
-  }
-  return nTracks;
+  return mTracks.size();
 }
 
-template <int nLayers>
-inline size_t TimeFrame<nLayers>::getNumberOfUsedClusters() const
+template <int NLayers>
+inline size_t TimeFrame<NLayers>::getNumberOfUsedClusters() const
 {
   size_t nClusters = 0;
   for (const auto& layer : mUsedClusters) {
@@ -680,17 +593,6 @@ inline size_t TimeFrame<nLayers>::getNumberOfUsedClusters() const
   return nClusters;
 }
 
-template <int nLayers>
-inline void TimeFrame<nLayers>::insertPastVertex(const Vertex& vertex, const int iteration)
-{
-  int rofId = vertex.getTimeStamp().getTimeStamp();
-  mPrimaryVertices.insert(mPrimaryVertices.begin() + mROFramesPV[rofId], vertex);
-  for (int i = rofId + 1; i < mROFramesPV.size(); ++i) {
-    mROFramesPV[i]++;
-  }
-  mTotVertPerIteration[iteration]++;
-}
-
 } // namespace its
 } // namespace o2
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index 3ea382c626fed..a1a0bf7249a21 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -30,17 +30,10 @@
 #include <oneapi/tbb/task_arena.h>
 
 #include "ITStracking/Configuration.h"
-#include "CommonConstants/MathConstants.h"
-#include "ITStracking/Definitions.h"
-#include "ITStracking/MathUtils.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/TrackerTraits.h"
-#include "ITStracking/Road.h"
 #include "ITStracking/BoundedAllocator.h"
 
-#include "DataFormatsITS/TrackITS.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-
 namespace o2
 {
 
@@ -51,15 +44,15 @@ class GPUChainITS;
 namespace its
 {
 
-template <int nLayers>
+template <int NLayers>
 class Tracker
 {
   using LogFunc = std::function<void(const std::string& s)>;
 
  public:
-  Tracker(TrackerTraits<nLayers>* traits);
+  Tracker(TrackerTraits<NLayers>* traits);
 
-  void adoptTimeFrame(TimeFrame<nLayers>& tf);
+  void adoptTimeFrame(TimeFrame<NLayers>& tf);
 
   void clustersToTracks(
     const LogFunc& = [](const std::string& s) { std::cout << s << '\n'; },
@@ -69,33 +62,31 @@ class Tracker
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
   std::vector<TrackingParameters>& getParameters() { return mTrkParams; }
   void setBz(float bz) { mTraits->setBz(bz); }
-  bool isMatLUT() const { return mTraits->isMatLUT(); }
+  void setTimeSlice(size_t slice) noexcept { mTimeSlice = slice; }
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena) { mTraits->setNThreads(n, arena); }
   void printSummary() const;
   void computeTracksMClabels();
 
  private:
   void initialiseTimeFrame(int iteration) { mTraits->initialiseTimeFrame(iteration); }
-  void computeTracklets(int iteration, int iROFslice, int iVertex) { mTraits->computeLayerTracklets(iteration, iROFslice, iVertex); }
+  void computeTracklets(int iteration, int iVertex) { mTraits->computeLayerTracklets(iteration, iVertex); }
   void computeCells(int iteration) { mTraits->computeLayerCells(iteration); }
   void findCellsNeighbours(int iteration) { mTraits->findCellsNeighbours(iteration); }
   void findRoads(int iteration) { mTraits->findRoads(iteration); }
-  void findShortPrimaries() { mTraits->findShortPrimaries(); }
-  void extendTracks(int iteration) { mTraits->extendTracks(iteration); }
 
-  // MC interaction
-  void computeRoadsMClabels();
   void rectifyClusterIndices();
+  void sortTracks();
 
   template <typename... T, typename... F>
   float evaluateTask(void (Tracker::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args);
 
-  TrackerTraits<nLayers>* mTraits = nullptr; /// Observer pointer, not owned by this class
-  TimeFrame<nLayers>* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
+  TrackerTraits<NLayers>* mTraits = nullptr; /// Observer pointer, not owned by this class
+  TimeFrame<NLayers>* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
 
   std::vector<TrackingParameters> mTrkParams;
   o2::gpu::GPUChainITS* mRecoChain = nullptr;
 
+  size_t mTimeSlice{0}; // current timeslice
   unsigned int mNumberOfDroppedTFs{0};
   unsigned int mTimeFrameCounter{0};
   double mTotalTime{0};
@@ -113,9 +104,9 @@ class Tracker
   static constexpr std::array<const char*, NStates> StateNames{"TimeFrame initialisation", "Tracklet finding", "Cell finding", "Neighbour finding", "Road finding"};
 };
 
-template <int nLayers>
+template <int NLayers>
 template <typename... T, typename... F>
-float Tracker<nLayers>::evaluateTask(void (Tracker<nLayers>::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args)
+float Tracker<NLayers>::evaluateTask(void (Tracker<NLayers>::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args)
 {
   float diff{0.f};
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index ddc32ed18cbfe..fd3251a59d835 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -38,36 +38,28 @@ namespace its
 {
 class TrackITSExt;
 
-template <int nLayers = 7>
+template <int NLayers>
 class TrackerTraits
 {
  public:
-  using IndexTableUtilsN = IndexTableUtils<nLayers>;
-  using CellSeedN = CellSeed<nLayers>;
+  using IndexTableUtilsN = IndexTableUtils<NLayers>;
+  using CellSeedN = CellSeed<NLayers>;
 
   virtual ~TrackerTraits() = default;
-  virtual void adoptTimeFrame(TimeFrame<nLayers>* tf) { mTimeFrame = tf; }
-  virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers); }
+  virtual void adoptTimeFrame(TimeFrame<NLayers>* tf) { mTimeFrame = tf; }
+  virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers, false); }
 
-  virtual void computeLayerTracklets(const int iteration, int iROFslice, int iVertex);
+  virtual void computeLayerTracklets(const int iteration, int iVertex);
   virtual void computeLayerCells(const int iteration);
   virtual void findCellsNeighbours(const int iteration);
   virtual void findRoads(const int iteration);
-
-  virtual bool supportsExtendTracks() const noexcept { return true; }
-  virtual void extendTracks(const int iteration);
-  virtual bool supportsFindShortPrimaries() const noexcept { return true; }
-  virtual void findShortPrimaries();
-
-  virtual bool trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration);
   virtual void processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId);
 
   void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars) { mTrkParams = trkPars; }
-  TimeFrame<nLayers>* getTimeFrame() { return mTimeFrame; }
+  TimeFrame<NLayers>* getTimeFrame() { return mTimeFrame; }
 
   virtual void setBz(float bz);
   float getBz() const { return mBz; }
-  bool isMatLUT() const;
   virtual const char* getName() const noexcept { return "CPU"; }
   virtual bool isGPU() const noexcept { return false; }
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) noexcept { mMemoryPool = pool; }
@@ -75,17 +67,14 @@ class TrackerTraits
 
   // Others
   GPUhd() static consteval int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
-  const int4 getBinsRect(int layer, float phi, float maxdeltaphi, float z, float maxdeltaz) const noexcept { return getBinsRect(layer, phi, maxdeltaphi, z, z, maxdeltaz); }
-  const int4 getBinsRect(const Cluster& cls, int layer, float z1, float z2, float maxdeltaz, float maxdeltaphi) const noexcept { return getBinsRect(layer, cls.phi, maxdeltaphi, z1, z2, maxdeltaz); }
-  const int4 getBinsRect(int layer, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept;
-  void SetRecoChain(o2::gpu::GPUChainITS* chain) { mChain = chain; }
-  void setSmoothing(bool v) { mApplySmoothing = v; }
-  bool getSmoothing() const { return mApplySmoothing; }
+  int4 getBinsRect(const int iteration, int layer, float phi, float maxdeltaphi, float z, float maxdeltaz)
+    const noexcept { return getBinsRect(iteration, layer, phi, maxdeltaphi, z, z, maxdeltaz); }
+  int4 getBinsRect(const int iteration, const Cluster& cls, int layer, float z1, float z2, float maxdeltaz, float maxdeltaphi) const noexcept { return getBinsRect(iteration, layer, cls.phi, maxdeltaphi, z1, z2, maxdeltaz); }
+  const int4 getBinsRect(const int iteration, int layer, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept;
+
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena);
   int getNThreads() { return mTaskArena->max_concurrency(); }
 
-  o2::gpu::GPUChainITS* getChain() const { return mChain; }
-
   // TimeFrame information forwarding
   virtual int getTFNumberOfClusters() const { return mTimeFrame->getNumberOfClusters(); }
   virtual int getTFNumberOfTracklets() const { return mTimeFrame->getNumberOfTracklets(); }
@@ -96,36 +85,35 @@ class TrackerTraits
   TrackITSExt seedTrackForRefit(const CellSeedN& seed);
   bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0, o2::track::TrackPar* refLin = nullptr);
 
-  bool mApplySmoothing = false;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
 
  protected:
   o2::gpu::GPUChainITS* mChain = nullptr;
-  TimeFrame<nLayers>* mTimeFrame;
+  TimeFrame<NLayers>* mTimeFrame;
   std::vector<TrackingParameters> mTrkParams;
 
   float mBz{-999.f};
   bool mIsZeroField{false};
 };
 
-template <int nLayers>
-inline const int4 TrackerTraits<nLayers>::getBinsRect(const int layerIndex, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept
+template <int NLayers>
+inline const int4 TrackerTraits<NLayers>::getBinsRect(const int iteration, const int layerIndex, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept
 {
   const float zRangeMin = o2::gpu::GPUCommonMath::Min(z1, z2) - maxdeltaz;
   const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : phi - maxdeltaphi;
   const float zRangeMax = o2::gpu::GPUCommonMath::Max(z1, z2) + maxdeltaz;
   const float phiRangeMax = (maxdeltaphi > o2::constants::math::PI) ? o2::constants::math::TwoPI : phi + maxdeltaphi;
 
-  if (zRangeMax < -mTrkParams[0].LayerZ[layerIndex] ||
-      zRangeMin > mTrkParams[0].LayerZ[layerIndex] || zRangeMin > zRangeMax) {
+  if (zRangeMax < -mTrkParams[iteration].LayerZ[layerIndex] ||
+      zRangeMin > mTrkParams[iteration].LayerZ[layerIndex] || zRangeMin > zRangeMax) {
     return getEmptyBinsRect();
   }
 
-  const IndexTableUtilsN& utils{mTimeFrame->mIndexTableUtils};
+  const IndexTableUtilsN& utils{mTimeFrame->getIndexTableUtils()};
   return int4{o2::gpu::GPUCommonMath::Max(0, utils.getZBinIndex(layerIndex, zRangeMin)),
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
-              o2::gpu::GPUCommonMath::Min(mTrkParams[0].ZBins - 1, utils.getZBinIndex(layerIndex, zRangeMax)), // /!\ trkParams can potentially change across iterations
+              o2::gpu::GPUCommonMath::Min(mTrkParams[iteration].ZBins - 1, utils.getZBinIndex(layerIndex, zRangeMax)),
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 0529bd53f2073..e77200a1432d1 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -22,10 +22,9 @@ namespace o2::its
 struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerParamConfig> {
   bool saveTimeBenchmarks = false; // dump metrics on file
 
-  int nIterations = 1;                     // Number of vertexing passes to perform.
-  int vertPerRofThreshold = 0;             // Maximum number of vertices per ROF to trigger second a iteration.
-  bool allowSingleContribClusters = false; // attempt to find vertices in case of a single tracklet found.
-  int deltaRof = 0;                        // Number of ROFs to be considered for the vertexing.
+  int nIterations = 1;         // Number of vertexing passes to perform.
+  int vertPerRofThreshold = 0; // Maximum number of vertices per ROF to trigger second a iteration.
+  int deltaRof = 0;            // Number of ROFs to be considered for the vertexing.
 
   // geometrical cuts for tracklet selection
   float zCut = 0.002f;
@@ -48,8 +47,7 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   int ZBins = 1;     // z-phi index table configutation: number of z bins
   int PhiBins = 128; // z-phi index table configutation: number of phi bins
 
-  bool useTruthSeeding{false};  // overwrite seeding vertices with MC truth
-  bool outputContLabels{false}; // output additioanlly for each vertex its contributing line labels
+  bool useTruthSeeding{false}; // overwrite seeding vertices with MC truth
 
   int nThreads = 1;
   bool printMemory = false;
@@ -66,7 +64,7 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   static const int MaxTrackLength = 7;
   bool useMatCorrTGeo = false;                                              // use full geometry to corect for material budget accounting in the fits. Default is to use the material budget LUT.
   bool useFastMaterial = false;                                             // use faster material approximation for material budget accounting in the fits.
-  int deltaRof = 0;                                                         // configure the width of the window in ROFs to be considered for the tracking.
+  int addTimeError[7] = {0};                                                // configure the width of the window in BC to be considered for the tracking.
   int minTrackLgtIter[MaxIter] = {};                                        // minimum track length at each iteration, used only if >0, otherwise use code defaults
   uint8_t startLayerMask[MaxIter] = {};                                     // mask of start layer for this iteration (if >0)
   float minPtIterLgt[MaxIter * (MaxTrackLength - MinTrackLength + 1)] = {}; // min.pT for given track length at this iteration, used only if >0, otherwise use code defaults
@@ -80,16 +78,8 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   float pvRes = -1.f;
   int LUTbinsPhi = -1;
   int LUTbinsZ = -1;
-  float diamondPos[3] = {0.f, 0.f, 0.f}; // override the position of the vertex
-  bool useDiamond = false;               // enable overriding the vertex position
-  int useTrackFollower = -1;             // bit 0: allow mixing implies bits 1&2; bit 1: topwards; bit2: downwards; => 0 off
-  float trackFollowerNSigmaZ = 1.f;      // sigma in z-cut for track-following search rectangle
-  float trackFollowerNSigmaPhi = 1.f;    // sigma in phi-cut for track-following search rectangle
-  float cellsPerClusterLimit = -1.f;
-  float trackletsPerClusterLimit = -1.f;
-  int findShortTracks = -1;
-  int nROFsPerIterations = 0;              // size of the slice of ROFs to be processed at a time, preferably integer divisors of nROFs per TF, to balance the iterations.
-  int nOrbitsPerIterations = 0;            // not implemented: size of the slice of ROFs to be processed at a time, computed using the number of ROFs per orbit.
+  float diamondPos[3] = {0.f, 0.f, 0.f};   // override the position of the vertex
+  bool useDiamond = false;                 // enable overriding the vertex position
   bool perPrimaryVertexProcessing = false; // perform the full tracking considering the vertex hypotheses one at the time.
   bool saveTimeBenchmarks = false;         // dump metrics on file
   bool overrideBeamEstimation = false;     // use beam position from meanVertex CCDB object
@@ -99,13 +89,13 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   int reseedIfShorter = 6;                 // for the final refit reseed the track with circle if they are shorter than this value
   bool shiftRefToCluster{true};            // TrackFit: after update shift the linearization reference to cluster
   bool repeatRefitOut{false};              // repeat outward refit using inward refit as a seed
-  bool createArtefactLabels{false}; // create on-the-fly labels for the artefacts
+  bool createArtefactLabels{false};        // create on-the-fly labels for the artefacts
 
   int nThreads = 1;
   bool printMemory = false;
   size_t maxMemory = std::numeric_limits<size_t>::max();
   bool dropTFUponFailure = false;
-  bool fataliseUponFailure = true; // granular management of the fatalisation in async mode
+  bool fataliseUponFailure = true;       // granular management of the fatalisation in async mode
   bool allowSharingFirstCluster = false; // allow first cluster sharing among tracks
 
   O2ParamDef(TrackerParamConfig, "ITSCATrackerParam");
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index a882ca9b779c4..ac4b99a0a8cd8 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -43,9 +43,11 @@ class ITSTrackingInterface
 
  public:
   ITSTrackingInterface(bool isMC,
+                       bool doStag,
                        int trgType,
                        const bool overrBeamEst)
     : mIsMC{isMC},
+      mDoStaggering(doStag),
       mUseTriggers{trgType},
       mOverrideBeamEstimation{overrBeamEst} {}
 
@@ -81,13 +83,16 @@ class ITSTrackingInterface
   virtual void loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                        gsl::span<const itsmft::CompClusterExt> clusters,
                        gsl::span<const unsigned char>::iterator& pattIt,
+                       int layer,
                        const dataformats::MCTruthContainer<MCCompLabel>* mcLabels);
 
  private:
   bool mIsMC = false;
+  bool mDoStaggering = false;
   bool mRunVertexer = true;
   bool mCosmicsProcessing = false;
   int mUseTriggers = 0;
+  std::vector<o2::framework::InputSpec> mFilter;
   TrackingMode::Type mMode = TrackingMode::Unset;
   bool mOverrideBeamEstimation = false;
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
index e6c9db55198a3..d93a5e1c7d70e 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -17,6 +17,7 @@
 #define TRACKINGITS_INCLUDE_TRACKLET_H_
 
 #include "ITStracking/Constants.h"
+#include "DataFormatsITS/TimeEstBC.h"
 #include "ITStracking/Cluster.h"
 #include "GPUCommonRtypes.h"
 #include "GPUCommonMath.h"
@@ -35,51 +36,50 @@ namespace o2::its
 
 struct Tracklet final {
   GPUhdDefault() Tracklet() = default;
-  GPUhdi() Tracklet(const int, const int, const Cluster&, const Cluster&, short rof0, short rof1);
-  GPUhdi() Tracklet(const int, const int, float tanL, float phi, short rof0, short rof1);
+  GPUhdi() Tracklet(const int, const int, const Cluster&, const Cluster&, const TimeEstBC& t);
+  GPUhdi() Tracklet(const int, const int, float tanL, float phi, const TimeEstBC& t);
   GPUhdDefault() bool operator==(const Tracklet&) const = default;
   GPUhdi() unsigned char isEmpty() const
   {
     return firstClusterIndex < 0 || secondClusterIndex < 0;
   }
-  GPUhdi() auto getMinRof() const noexcept { return o2::gpu::CAMath::Min(rof[0], rof[1]); }
-  GPUhdi() auto getMaxRof() const noexcept { return o2::gpu::CAMath::Max(rof[0], rof[1]); }
-  GPUhdi() auto getDeltaRof() const { return rof[1] - rof[0]; }
-  GPUhdi() auto getSpanRof(const Tracklet& o) const noexcept { return o2::gpu::CAMath::Max(getMaxRof(), o.getMaxRof()) - o2::gpu::CAMath::Min(getMinRof(), o.getMinRof()); }
+  GPUhdi() bool isCompatible(const Tracklet& o) const { return mTime.isCompatible(o.mTime); }
   GPUhdi() unsigned char operator<(const Tracklet&) const;
   GPUhd() void print() const
   {
-    printf("TRKLT: fClIdx:%d fROF:%d sClIdx:%d sROF:%d (DROF:%d) tgl=%f phi=%f\n", firstClusterIndex, rof[0], secondClusterIndex, rof[1], getDeltaRof(), tanLambda, phi);
+    LOGP(info, "TRKLT: fClIdx:{} sClIdx:{} ts:{}+/-{} TgL={} Phi={}", firstClusterIndex, secondClusterIndex, mTime.getTimeStamp(), mTime.getTimeStampError(), tanLambda, phi);
   }
+  GPUhd() auto& getTimeStamp() noexcept { return mTime; }
+  GPUhd() const auto& getTimeStamp() const noexcept { return mTime; }
 
   int firstClusterIndex{constants::UnusedIndex};
   int secondClusterIndex{constants::UnusedIndex};
   float tanLambda{-999};
   float phi{-999};
-  short rof[2] = {constants::UnusedIndex, constants::UnusedIndex};
+  TimeEstBC mTime;
 
   ClassDefNV(Tracklet, 1);
 };
 
 GPUhdi() Tracklet::Tracklet(const int firstClusterOrderingIndex, const int secondClusterOrderingIndex,
-                            const Cluster& firstCluster, const Cluster& secondCluster, short rof0 = -1, short rof1 = -1)
-  : firstClusterIndex{firstClusterOrderingIndex},
-    secondClusterIndex{secondClusterOrderingIndex},
-    tanLambda{(firstCluster.zCoordinate - secondCluster.zCoordinate) /
-              (firstCluster.radius - secondCluster.radius)},
-    phi{o2::gpu::GPUCommonMath::ATan2(firstCluster.yCoordinate - secondCluster.yCoordinate,
-                                      firstCluster.xCoordinate - secondCluster.xCoordinate)},
-    rof{static_cast<short>(rof0), static_cast<short>(rof1)}
+                            const Cluster& firstCluster, const Cluster& secondCluster, const TimeEstBC& t)
+  : firstClusterIndex(firstClusterOrderingIndex),
+    secondClusterIndex(secondClusterOrderingIndex),
+    tanLambda((firstCluster.zCoordinate - secondCluster.zCoordinate) /
+              (firstCluster.radius - secondCluster.radius)),
+    phi(o2::gpu::GPUCommonMath::ATan2(firstCluster.yCoordinate - secondCluster.yCoordinate,
+                                      firstCluster.xCoordinate - secondCluster.xCoordinate)),
+    mTime(t)
 {
   // Nothing to do
 }
 
-GPUhdi() Tracklet::Tracklet(const int idx0, const int idx1, float tanL, float phi, short rof0, short rof1)
-  : firstClusterIndex{idx0},
-    secondClusterIndex{idx1},
-    tanLambda{tanL},
-    phi{phi},
-    rof{static_cast<short>(rof0), static_cast<short>(rof1)}
+GPUhdi() Tracklet::Tracklet(const int idx0, const int idx1, float tanL, float phi, const TimeEstBC& t)
+  : firstClusterIndex(idx0),
+    secondClusterIndex(idx1),
+    tanLambda(tanL),
+    phi(phi),
+    mTime(t)
 {
   // Nothing to do
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index d66bcd6ee2358..77218754dbda3 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -35,11 +35,11 @@
 namespace o2::its
 {
 
-template <int nLayers>
+template <int NLayers>
 class Vertexer
 {
-  using TimeFrameN = TimeFrame<nLayers>;
-  using VertexerTraitsN = VertexerTraits<nLayers>;
+  using TimeFrameN = TimeFrame<NLayers>;
+  using VertexerTraitsN = VertexerTraits<NLayers>;
   using LogFunc = std::function<void(const std::string& s)>;
 
  public:
@@ -54,9 +54,6 @@ class Vertexer
   const auto& getParameters() const noexcept { return mVertParams; }
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
 
-  std::vector<Vertex> exportVertices();
-  VertexerTraitsN* getTraits() const { return mTraits; };
-
   float clustersToVertices(LogFunc = [](const std::string& s) { std::cout << s << '\n'; });
   void filterMCTracklets();
 
@@ -86,6 +83,8 @@ class Vertexer
   template <typename... T>
   void initialiseTimeFrame(T&&... args);
 
+  void sortVertices();
+
   // Utils
   template <typename... T>
   float evaluateTask(void (Vertexer::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args);
@@ -118,9 +117,9 @@ class Vertexer
   static constexpr std::array<const char*, NStates> StateNames{"Initialisation", "Tracklet finding", "Tracklet validation", "Vertex finding", "Truth seeding"};
 };
 
-template <int nLayers>
+template <int NLayers>
 template <typename... T>
-float Vertexer<nLayers>::evaluateTask(void (Vertexer<nLayers>::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args)
+float Vertexer<NLayers>::evaluateTask(void (Vertexer<NLayers>::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args)
 {
   float diff{0.f};
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index b1422d66e12df..02ecbe2be8eea 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -43,11 +43,11 @@ class MCCompLabel;
 namespace its
 {
 
-template <int nLayers>
+template <int NLayers>
 class VertexerTraits
 {
-  using IndexTableUtilsN = IndexTableUtils<nLayers>;
-  using TimeFrameN = TimeFrame<nLayers>;
+  using IndexTableUtilsN = IndexTableUtils<NLayers>;
+  using TimeFrameN = TimeFrame<NLayers>;
 
  public:
   VertexerTraits() = default;
@@ -68,7 +68,7 @@ class VertexerTraits
   virtual void computeTrackletMatching(const int iteration = 0);
   virtual void computeVertices(const int iteration = 0);
   virtual void adoptTimeFrame(TimeFrameN* tf) noexcept { mTimeFrame = tf; }
-  virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& gpuTfPar);
+  virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar);
 
   // truth tracking
   void addTruthSeedingVertices();
@@ -84,7 +84,7 @@ class VertexerTraits
   virtual bool usesMemoryPool() const noexcept { return true; }
   void setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool) { mMemoryPool = pool; }
 
-  static std::pair<o2::MCCompLabel, float> computeMain(const bounded_vector<o2::MCCompLabel>& elements)
+  static VertexLabel computeMain(const bounded_vector<o2::MCCompLabel>& elements)
   {
     // we only care about the source&event of the tracks, not the trackId
     auto composeVtxLabel = [](const o2::MCCompLabel& lbl) -> o2::MCCompLabel {
@@ -114,28 +114,23 @@ class VertexerTraits
  private:
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
-
-  // debug output
-  void debugComputeTracklets(int iteration);
-  void debugComputeTrackletMatching(int iteration);
-  void debugComputeVertices(int iteration);
 };
 
-template <int nLayers>
-inline void VertexerTraits<nLayers>::initialise(const TrackingParameters& trackingParams, const int iteration)
+template <int NLayers>
+inline void VertexerTraits<NLayers>::initialise(const TrackingParameters& trackingParams, const int iteration)
 {
   mTimeFrame->initialise(0, trackingParams, 3, (bool)(!iteration)); // iteration for initialisation must be 0 for correctly resetting the frame, we need to pass the non-reset flag for vertices as well, tho.
 }
 
-template <int nLayers>
-GPUhdi() const int2 VertexerTraits<nLayers>::getPhiBins(float phi, float dPhi, const IndexTableUtilsN& utils)
+template <int NLayers>
+GPUhdi() const int2 VertexerTraits<NLayers>::getPhiBins(float phi, float dPhi, const IndexTableUtilsN& utils)
 {
   return int2{utils.getPhiBinIndex(math_utils::getNormalizedPhi(phi - dPhi)),
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phi + dPhi))};
 }
 
-template <int nLayers>
-GPUhdi() const int4 VertexerTraits<nLayers>::getBinsRect(const Cluster& currentCluster, const int layerIndex,
+template <int NLayers>
+GPUhdi() const int4 VertexerTraits<NLayers>::getBinsRect(const Cluster& currentCluster, const int layerIndex,
                                                          const float directionZIntersection, float maxdeltaz, float maxdeltaphi,
                                                          const IndexTableUtilsN& utils)
 {
@@ -155,8 +150,8 @@ GPUhdi() const int4 VertexerTraits<nLayers>::getBinsRect(const Cluster& currentC
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
 }
 
-template <int nLayers>
-GPUhdi() const int4 VertexerTraits<nLayers>::getBinsRect(const Cluster& currentCluster, const int layerIndex,
+template <int NLayers>
+GPUhdi() const int4 VertexerTraits<NLayers>::getBinsRect(const Cluster& currentCluster, const int layerIndex,
                                                          const float directionZIntersection, float maxdeltaz, float maxdeltaphi)
 {
   return VertexerTraits::getBinsRect(currentCluster, layerIndex, directionZIntersection, maxdeltaz, maxdeltaphi, mIndexTableUtils);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx b/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
index 1a0fa1d3908a4..f561fe0436c4a 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
@@ -10,385 +10,176 @@
 // or submit itself to any jurisdiction.
 
 #include <cmath>
-#include <algorithm>
+#include "Framework/Logger.h"
 #include "ITStracking/ClusterLines.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
-Line::Line(std::array<float, 3> firstPoint, std::array<float, 3> secondPoint)
+Line::Line(const Tracklet& tracklet, const Cluster* innerClusters, const Cluster* outerClusters) : mTime(tracklet.mTime)
 {
-  for (int index{0}; index < 3; ++index) {
-    originPoint[index] = firstPoint.data()[index];
-    cosinesDirector[index] = secondPoint[index] - firstPoint[index];
-  }
+  const auto& inner = innerClusters[tracklet.firstClusterIndex];
+  const auto& outer = outerClusters[tracklet.secondClusterIndex];
+
+  originPoint = SVector3f(inner.xCoordinate, inner.yCoordinate, inner.zCoordinate);
+  cosinesDirector = SVector3f(outer.xCoordinate - inner.xCoordinate,
+                              outer.yCoordinate - inner.yCoordinate,
+                              outer.zCoordinate - inner.zCoordinate);
+  cosinesDirector /= std::sqrt(ROOT::Math::Dot(cosinesDirector, cosinesDirector));
+}
 
-  float inverseNorm{1.f / o2::gpu::CAMath::Sqrt(cosinesDirector[0] * cosinesDirector[0] + cosinesDirector[1] * cosinesDirector[1] +
-                                                cosinesDirector[2] * cosinesDirector[2])};
-  for (int index{0}; index < 3; ++index) {
-    cosinesDirector[index] *= inverseNorm;
-  }
+float Line::getDistance2FromPoint(const Line& line, const std::array<float, 3>& point)
+{
+  const SVector3f p(point.data(), 3);
+  const SVector3f delta = p - line.originPoint;
+  const float proj = ROOT::Math::Dot(delta, line.cosinesDirector);
+  const SVector3f residual = delta - proj * line.cosinesDirector;
+  return ROOT::Math::Dot(residual, residual);
 }
 
-bool Line::areParallel(const Line& firstLine, const Line& secondLine, const float precision)
+float Line::getDistanceFromPoint(const Line& line, const std::array<float, 3>& point)
 {
-  float crossProdX{firstLine.cosinesDirector[1] * secondLine.cosinesDirector[2] -
-                   firstLine.cosinesDirector[2] * secondLine.cosinesDirector[1]};
-  float module{std::abs(firstLine.cosinesDirector[1] * secondLine.cosinesDirector[2]) +
-               std::abs(firstLine.cosinesDirector[2] * secondLine.cosinesDirector[1])};
-  if (std::abs(crossProdX) > precision * module) {
-    return false;
-  }
+  return std::sqrt(getDistance2FromPoint(line, point));
+}
 
-  float crossProdY{-firstLine.cosinesDirector[0] * secondLine.cosinesDirector[2] +
-                   firstLine.cosinesDirector[2] * secondLine.cosinesDirector[0]};
-  module = std::abs(firstLine.cosinesDirector[0] * secondLine.cosinesDirector[2]) +
-           std::abs(firstLine.cosinesDirector[2] * secondLine.cosinesDirector[0]);
-  if (std::abs(crossProdY) > precision * module) {
-    return false;
+float Line::getDCA2(const Line& firstLine, const Line& secondLine, const float precision)
+{
+  const SVector3f n = ROOT::Math::Cross(firstLine.cosinesDirector, secondLine.cosinesDirector);
+  const float norm2 = ROOT::Math::Dot(n, n);
+
+  if (norm2 <= precision * precision) {
+    // lines are parallel, fall back to point-to-line distance
+    const SVector3f d = secondLine.originPoint - firstLine.originPoint;
+    const float proj = ROOT::Math::Dot(d, firstLine.cosinesDirector);
+    const SVector3f residual = d - proj * firstLine.cosinesDirector;
+    return ROOT::Math::Dot(residual, residual);
   }
 
-  float crossProdZ = firstLine.cosinesDirector[0] * secondLine.cosinesDirector[1] -
-                     firstLine.cosinesDirector[1] * secondLine.cosinesDirector[0];
-  module = std::abs(firstLine.cosinesDirector[0] * secondLine.cosinesDirector[1]) +
-           std::abs(firstLine.cosinesDirector[1] * secondLine.cosinesDirector[0]);
-  if (std::abs(crossProdZ) > precision * module) {
-    return false;
-  }
+  const SVector3f delta = secondLine.originPoint - firstLine.originPoint;
+  const float numerator = ROOT::Math::Dot(delta, n);
+  return (numerator * numerator) / norm2;
+}
 
-  return true;
+float Line::getDCA(const Line& firstLine, const Line& secondLine, const float precision)
+{
+  return std::sqrt(getDCA2(firstLine, secondLine, precision));
 }
 
-std::array<float, 6> Line::getDCAComponents(const Line& line, const std::array<float, 3> point)
+Line::SMatrix3f Line::getDCAComponents(const Line& line, const std::array<float, 3>& point)
 {
-  std::array<float, 6> components{0., 0., 0., 0., 0., 0.};
-  float cdelta{0.};
-  for (int i{0}; i < 3; ++i) {
-    cdelta -= line.cosinesDirector[i] * (line.originPoint[i] - point[i]);
-  }
+  const SVector3f p(point.data(), 3);
+  const SVector3f delta = line.originPoint - p;
+  const float proj = ROOT::Math::Dot(line.cosinesDirector, delta);
+  const SVector3f residual = delta - proj * line.cosinesDirector;
+
+  // symmetric 3x3: diagonal = residual components, off-diagonal = 2D projected distances
+  SMatrix3f m;
+  m(0, 0) = residual(0);
+  m(1, 1) = residual(1);
+  m(2, 2) = residual(2);
+  m(0, 1) = std::hypot(m(0, 0), m(1, 1));
+  m(0, 2) = std::hypot(m(0, 0), m(2, 2));
+  m(1, 2) = std::hypot(m(1, 1), m(2, 2));
+  return m;
+}
 
-  components[0] = line.originPoint[0] - point[0] + line.cosinesDirector[0] * cdelta;
-  components[3] = line.originPoint[1] - point[1] + line.cosinesDirector[1] * cdelta;
-  components[5] = line.originPoint[2] - point[2] + line.cosinesDirector[2] * cdelta;
-  components[1] = o2::gpu::CAMath::Sqrt(components[0] * components[0] + components[3] * components[3]);
-  components[2] = o2::gpu::CAMath::Sqrt(components[0] * components[0] + components[5] * components[5]);
-  components[4] = o2::gpu::CAMath::Sqrt(components[3] * components[3] + components[5] * components[5]);
+bool Line::isEmpty() const noexcept
+{
+  return ROOT::Math::Dot(originPoint, originPoint) == 0.f &&
+         ROOT::Math::Dot(cosinesDirector, cosinesDirector) == 0.f;
+}
 
-  return components;
+void Line::print() const
+{
+  LOGP(info, "\tLine: originPoint = ({}, {}, {}), cosinesDirector = ({}, {}, {}) ts={}+-{}",
+       originPoint(0), originPoint(1), originPoint(2),
+       cosinesDirector(0), cosinesDirector(1), cosinesDirector(2),
+       mTime.getTimeStamp(), mTime.getTimeStampError());
 }
 
-ClusterLines::ClusterLines(const int firstLabel, const Line& firstLine, const int secondLabel, const Line& secondLine,
-                           const bool weight)
+// Accumulate the weighted normal equation contributions (A matrix and B vector)
+// from a single line into the running sums. The covariance is assumed to be
+// diagonal and uniform ({1,1,1}) so the weights simplify accordingly.
+// The A matrix entry (i,j) = (delta_ij - d_i*d_j) / det, and the B vector
+// entry b_i = sum_j d_j*(d_j*o_i - d_i*o_j) / det, where d = cosinesDirector
+// and o = originPoint.
+void ClusterLines::accumulate(const Line& line)
+{
+  const ROOT::Math::SVector<double, 3> d(line.cosinesDirector(0), line.cosinesDirector(1), line.cosinesDirector(2));
+  const ROOT::Math::SVector<double, 3> o(line.originPoint(0), line.originPoint(1), line.originPoint(2));
+
+  // == 1 for normalised directors, kept for generality
+  const double det = ROOT::Math::Dot(d, d);
 
+  // A matrix (symmetric): A_ij = (delta_ij * |d|^2 - d_i * d_j) / det
+  for (int i = 0; i < 3; ++i) {
+    for (int j = i; j < 3; ++j) {
+      mAMatrix(i, j) += ((i == j ? det : 0.) - d(i) * d(j)) / det;
+    }
+  }
+
+  // B vector: b_i = (d_i * dot(d,o) - |d|^2 * o_i) / det
+  const double dDotO = ROOT::Math::Dot(d, o);
+  for (int i = 0; i < 3; ++i) {
+    mBMatrix(i) += (d(i) * dDotO - det * o(i)) / det;
+  }
+}
+
+ClusterLines::ClusterLines(const int firstLabel, const Line& firstLine, const int secondLabel, const Line& secondLine) : mTime(firstLine.mTime)
 {
-  updateROFPoll(firstLine);
-  updateROFPoll(secondLine);
+  mTime += secondLine.mTime;
 
   mLabels.push_back(firstLabel);
   if (secondLabel > 0) {
     mLabels.push_back(secondLabel); // don't add info in case of beamline used
   }
 
-  std::array<float, 3> covarianceFirst{1., 1., 1.};
-  std::array<float, 3> covarianceSecond{1., 1., 1.};
-
-  // for (int i{0}; i < 6; ++i) {
-  //   mWeightMatrix[i] = firstLine.weightMatrix[i] + secondLine.weightMatrix[i];
-  // }
-
-  float determinantFirst =
-    firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[0] * covarianceFirst[1] +
-    firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[0] * covarianceFirst[2] +
-    firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[1] * covarianceFirst[2];
-  float determinantSecond =
-    secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[0] * covarianceSecond[1] +
-    secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[0] * covarianceSecond[2] +
-    secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[1] * covarianceSecond[2];
-
-  mAMatrix[0] = (firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[1] +
-                 firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[2]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[1] +
-                 secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[2]) /
-                  determinantSecond;
-
-  mAMatrix[1] = -firstLine.cosinesDirector[0] * firstLine.cosinesDirector[1] * covarianceFirst[2] / determinantFirst -
-                secondLine.cosinesDirector[0] * secondLine.cosinesDirector[1] * covarianceSecond[2] / determinantSecond;
-
-  mAMatrix[2] = -firstLine.cosinesDirector[0] * firstLine.cosinesDirector[2] * covarianceFirst[1] / determinantFirst -
-                secondLine.cosinesDirector[0] * secondLine.cosinesDirector[2] * covarianceSecond[1] / determinantSecond;
-
-  mAMatrix[3] = (firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[0] +
-                 firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[2]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[0] +
-                 secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[2]) /
-                  determinantSecond;
-
-  mAMatrix[4] = -firstLine.cosinesDirector[1] * firstLine.cosinesDirector[2] * covarianceFirst[0] / determinantFirst -
-                secondLine.cosinesDirector[1] * secondLine.cosinesDirector[2] * covarianceSecond[0] / determinantSecond;
-
-  mAMatrix[5] = (firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[0] +
-                 firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[1]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[0] +
-                 secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[1]) /
-                  determinantSecond;
-
-  mBMatrix[0] =
-    (firstLine.cosinesDirector[1] * covarianceFirst[2] * (-firstLine.cosinesDirector[1] * firstLine.originPoint[0] + firstLine.cosinesDirector[0] * firstLine.originPoint[1]) +
-     firstLine.cosinesDirector[2] * covarianceFirst[1] * (-firstLine.cosinesDirector[2] * firstLine.originPoint[0] + firstLine.cosinesDirector[0] * firstLine.originPoint[2])) /
-    determinantFirst;
-
-  mBMatrix[0] +=
-    (secondLine.cosinesDirector[1] * covarianceSecond[2] * (-secondLine.cosinesDirector[1] * secondLine.originPoint[0] + secondLine.cosinesDirector[0] * secondLine.originPoint[1]) +
-     secondLine.cosinesDirector[2] * covarianceSecond[1] *
-       (-secondLine.cosinesDirector[2] * secondLine.originPoint[0] +
-        secondLine.cosinesDirector[0] * secondLine.originPoint[2])) /
-    determinantSecond;
-
-  mBMatrix[1] =
-    (firstLine.cosinesDirector[0] * covarianceFirst[2] * (-firstLine.cosinesDirector[0] * firstLine.originPoint[1] + firstLine.cosinesDirector[1] * firstLine.originPoint[0]) +
-     firstLine.cosinesDirector[2] * covarianceFirst[0] * (-firstLine.cosinesDirector[2] * firstLine.originPoint[1] + firstLine.cosinesDirector[1] * firstLine.originPoint[2])) /
-    determinantFirst;
-
-  mBMatrix[1] +=
-    (secondLine.cosinesDirector[0] * covarianceSecond[2] * (-secondLine.cosinesDirector[0] * secondLine.originPoint[1] + secondLine.cosinesDirector[1] * secondLine.originPoint[0]) +
-     secondLine.cosinesDirector[2] * covarianceSecond[0] *
-       (-secondLine.cosinesDirector[2] * secondLine.originPoint[1] +
-        secondLine.cosinesDirector[1] * secondLine.originPoint[2])) /
-    determinantSecond;
-
-  mBMatrix[2] =
-    (firstLine.cosinesDirector[0] * covarianceFirst[1] * (-firstLine.cosinesDirector[0] * firstLine.originPoint[2] + firstLine.cosinesDirector[2] * firstLine.originPoint[0]) +
-     firstLine.cosinesDirector[1] * covarianceFirst[0] * (-firstLine.cosinesDirector[1] * firstLine.originPoint[2] + firstLine.cosinesDirector[2] * firstLine.originPoint[1])) /
-    determinantFirst;
-
-  mBMatrix[2] +=
-    (secondLine.cosinesDirector[0] * covarianceSecond[1] * (-secondLine.cosinesDirector[0] * secondLine.originPoint[2] + secondLine.cosinesDirector[2] * secondLine.originPoint[0]) +
-     secondLine.cosinesDirector[1] * covarianceSecond[0] *
-       (-secondLine.cosinesDirector[1] * secondLine.originPoint[2] +
-        secondLine.cosinesDirector[2] * secondLine.originPoint[1])) /
-    determinantSecond;
-
+  accumulate(firstLine);
+  accumulate(secondLine);
   computeClusterCentroid();
 
-  // RMS2
+  // RMS2: running mean update
   mRMS2 = Line::getDCAComponents(firstLine, mVertex);
-  const std::array<float, 6> tmpRMS2Line2 = Line::getDCAComponents(secondLine, mVertex);
-  std::transform(mRMS2.begin(), mRMS2.end(), tmpRMS2Line2.begin(), mRMS2.begin(), [&](const float a, const float b) { return a + (b - a) / mLabels.size(); });
+  const auto tmpRMS2 = Line::getDCAComponents(secondLine, mVertex);
+  mRMS2 += (tmpRMS2 - mRMS2) * (1.f / static_cast<float>(getSize()));
 
   // AvgDistance2
-  mAvgDistance2 = std::move(Line::getDistanceFromPoint(firstLine, mVertex) * Line::getDistanceFromPoint(firstLine, mVertex));
-  mAvgDistance2 += (Line::getDistanceFromPoint(secondLine, mVertex) * Line::getDistanceFromPoint(secondLine, mVertex) - mAvgDistance2) / mLabels.size();
+  mAvgDistance2 = Line::getDistance2FromPoint(firstLine, mVertex);
+  mAvgDistance2 += (Line::getDistance2FromPoint(secondLine, mVertex) - mAvgDistance2) / (float)getSize();
 }
 
-ClusterLines::ClusterLines(const Line& firstLine, const Line& secondLine)
-{
-
-  std::array<float, 3> covarianceFirst{1., 1., 1.};
-  std::array<float, 3> covarianceSecond{1., 1., 1.};
-  updateROFPoll(firstLine);
-  updateROFPoll(secondLine);
-  // for (int i{0}; i < 6; ++i) {
-  //   mWeightMatrix[i] = firstLine.weightMatrix[i] + secondLine.weightMatrix[i];
-  // }
-
-  float determinantFirst =
-    firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[0] * covarianceFirst[1] +
-    firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[0] * covarianceFirst[2] +
-    firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[1] * covarianceFirst[2];
-  float determinantSecond =
-    secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[0] * covarianceSecond[1] +
-    secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[0] * covarianceSecond[2] +
-    secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[1] * covarianceSecond[2];
-
-  mAMatrix[0] = (firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[1] +
-                 firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[2]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[1] +
-                 secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[2]) /
-                  determinantSecond;
-
-  mAMatrix[1] = -firstLine.cosinesDirector[0] * firstLine.cosinesDirector[1] * covarianceFirst[2] / determinantFirst -
-                secondLine.cosinesDirector[0] * secondLine.cosinesDirector[1] * covarianceSecond[2] / determinantSecond;
-
-  mAMatrix[2] = -firstLine.cosinesDirector[0] * firstLine.cosinesDirector[2] * covarianceFirst[1] / determinantFirst -
-                secondLine.cosinesDirector[0] * secondLine.cosinesDirector[2] * covarianceSecond[1] / determinantSecond;
-
-  mAMatrix[3] = (firstLine.cosinesDirector[2] * firstLine.cosinesDirector[2] * covarianceFirst[0] +
-                 firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[2]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[2] * secondLine.cosinesDirector[2] * covarianceSecond[0] +
-                 secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[2]) /
-                  determinantSecond;
-
-  mAMatrix[4] = -firstLine.cosinesDirector[1] * firstLine.cosinesDirector[2] * covarianceFirst[0] / determinantFirst -
-                secondLine.cosinesDirector[1] * secondLine.cosinesDirector[2] * covarianceSecond[0] / determinantSecond;
-
-  mAMatrix[5] = (firstLine.cosinesDirector[1] * firstLine.cosinesDirector[1] * covarianceFirst[0] +
-                 firstLine.cosinesDirector[0] * firstLine.cosinesDirector[0] * covarianceFirst[1]) /
-                  determinantFirst +
-                (secondLine.cosinesDirector[1] * secondLine.cosinesDirector[1] * covarianceSecond[0] +
-                 secondLine.cosinesDirector[0] * secondLine.cosinesDirector[0] * covarianceSecond[1]) /
-                  determinantSecond;
-
-  mBMatrix[0] =
-    (firstLine.cosinesDirector[1] * covarianceFirst[2] * (-firstLine.cosinesDirector[1] * firstLine.originPoint[0] + firstLine.cosinesDirector[0] * firstLine.originPoint[1]) +
-     firstLine.cosinesDirector[2] * covarianceFirst[1] * (-firstLine.cosinesDirector[2] * firstLine.originPoint[0] + firstLine.cosinesDirector[0] * firstLine.originPoint[2])) /
-    determinantFirst;
-
-  mBMatrix[0] +=
-    (secondLine.cosinesDirector[1] * covarianceSecond[2] * (-secondLine.cosinesDirector[1] * secondLine.originPoint[0] + secondLine.cosinesDirector[0] * secondLine.originPoint[1]) +
-     secondLine.cosinesDirector[2] * covarianceSecond[1] *
-       (-secondLine.cosinesDirector[2] * secondLine.originPoint[0] +
-        secondLine.cosinesDirector[0] * secondLine.originPoint[2])) /
-    determinantSecond;
-
-  mBMatrix[1] =
-    (firstLine.cosinesDirector[0] * covarianceFirst[2] * (-firstLine.cosinesDirector[0] * firstLine.originPoint[1] + firstLine.cosinesDirector[1] * firstLine.originPoint[0]) +
-     firstLine.cosinesDirector[2] * covarianceFirst[0] * (-firstLine.cosinesDirector[2] * firstLine.originPoint[1] + firstLine.cosinesDirector[1] * firstLine.originPoint[2])) /
-    determinantFirst;
-
-  mBMatrix[1] +=
-    (secondLine.cosinesDirector[0] * covarianceSecond[2] * (-secondLine.cosinesDirector[0] * secondLine.originPoint[1] + secondLine.cosinesDirector[1] * secondLine.originPoint[0]) +
-     secondLine.cosinesDirector[2] * covarianceSecond[0] *
-       (-secondLine.cosinesDirector[2] * secondLine.originPoint[1] +
-        secondLine.cosinesDirector[1] * secondLine.originPoint[2])) /
-    determinantSecond;
-
-  mBMatrix[2] =
-    (firstLine.cosinesDirector[0] * covarianceFirst[1] * (-firstLine.cosinesDirector[0] * firstLine.originPoint[2] + firstLine.cosinesDirector[2] * firstLine.originPoint[0]) +
-     firstLine.cosinesDirector[1] * covarianceFirst[0] * (-firstLine.cosinesDirector[1] * firstLine.originPoint[2] + firstLine.cosinesDirector[2] * firstLine.originPoint[1])) /
-    determinantFirst;
-
-  mBMatrix[2] +=
-    (secondLine.cosinesDirector[0] * covarianceSecond[1] * (-secondLine.cosinesDirector[0] * secondLine.originPoint[2] + secondLine.cosinesDirector[2] * secondLine.originPoint[0]) +
-     secondLine.cosinesDirector[1] * covarianceSecond[0] *
-       (-secondLine.cosinesDirector[1] * secondLine.originPoint[2] +
-        secondLine.cosinesDirector[2] * secondLine.originPoint[1])) /
-    determinantSecond;
-
-  computeClusterCentroid();
-}
-
-void ClusterLines::add(const int& lineLabel, const Line& line, const bool& weight)
+void ClusterLines::add(const int lineLabel, const Line& line)
 {
+  mTime += line.mTime;
   mLabels.push_back(lineLabel);
-  updateROFPoll(line);
-  std::array<float, 3> covariance{1., 1., 1.};
-
-  // for (int i{0}; i < 6; ++i) {
-  //   mWeightMatrix[i] += line.weightMatrix[i];
-  // }
-  // if(weight) line->GetSigma2P0(covariance);
-
-  double determinant{line.cosinesDirector[2] * line.cosinesDirector[2] * covariance[0] * covariance[1] +
-                     line.cosinesDirector[1] * line.cosinesDirector[1] * covariance[0] * covariance[2] +
-                     line.cosinesDirector[0] * line.cosinesDirector[0] * covariance[1] * covariance[2]};
-
-  mAMatrix[0] += (line.cosinesDirector[2] * line.cosinesDirector[2] * covariance[1] +
-                  line.cosinesDirector[1] * line.cosinesDirector[1] * covariance[2]) /
-                 determinant;
-  mAMatrix[1] += -line.cosinesDirector[0] * line.cosinesDirector[1] * covariance[2] / determinant;
-  mAMatrix[2] += -line.cosinesDirector[0] * line.cosinesDirector[2] * covariance[1] / determinant;
-  mAMatrix[3] += (line.cosinesDirector[2] * line.cosinesDirector[2] * covariance[0] +
-                  line.cosinesDirector[0] * line.cosinesDirector[0] * covariance[2]) /
-                 determinant;
-  mAMatrix[4] += -line.cosinesDirector[1] * line.cosinesDirector[2] * covariance[0] / determinant;
-  mAMatrix[5] += (line.cosinesDirector[1] * line.cosinesDirector[1] * covariance[0] +
-                  line.cosinesDirector[0] * line.cosinesDirector[0] * covariance[1]) /
-                 determinant;
-
-  mBMatrix[0] += (line.cosinesDirector[1] * covariance[2] *
-                    (-line.cosinesDirector[1] * line.originPoint[0] + line.cosinesDirector[0] * line.originPoint[1]) +
-                  line.cosinesDirector[2] * covariance[1] *
-                    (-line.cosinesDirector[2] * line.originPoint[0] + line.cosinesDirector[0] * line.originPoint[2])) /
-                 determinant;
-  mBMatrix[1] += (line.cosinesDirector[0] * covariance[2] *
-                    (-line.cosinesDirector[0] * line.originPoint[1] + line.cosinesDirector[1] * line.originPoint[0]) +
-                  line.cosinesDirector[2] * covariance[0] *
-                    (-line.cosinesDirector[2] * line.originPoint[1] + line.cosinesDirector[1] * line.originPoint[2])) /
-                 determinant;
-  mBMatrix[2] += (line.cosinesDirector[0] * covariance[1] *
-                    (-line.cosinesDirector[0] * line.originPoint[2] + line.cosinesDirector[2] * line.originPoint[0]) +
-                  line.cosinesDirector[1] * covariance[0] *
-                    (-line.cosinesDirector[1] * line.originPoint[2] + line.cosinesDirector[2] * line.originPoint[1])) /
-                 determinant;
 
+  accumulate(line);
   computeClusterCentroid();
-  mAvgDistance2 += (Line::getDistanceFromPoint(line, mVertex) * Line::getDistanceFromPoint(line, mVertex) - mAvgDistance2) / mLabels.size();
+  mAvgDistance2 += (Line::getDistance2FromPoint(line, mVertex) - mAvgDistance2) / (float)getSize();
 }
 
 void ClusterLines::computeClusterCentroid()
 {
-
-  double determinant{mAMatrix[0] * (mAMatrix[3] * mAMatrix[5] - mAMatrix[4] * mAMatrix[4]) -
-                     mAMatrix[1] * (mAMatrix[1] * mAMatrix[5] - mAMatrix[4] * mAMatrix[2]) +
-                     mAMatrix[2] * (mAMatrix[1] * mAMatrix[4] - mAMatrix[2] * mAMatrix[3])};
-
-  if (determinant == 0) {
+  // Solve the 3x3 symmetric linear system AX = -B using SMatrix inversion.
+  // Invert() returns false if the matrix is singular or ill-conditioned.
+  SMatrix3 invA{mAMatrix};
+  mIsValid = invA.Invert();
+  if (!mIsValid) {
     return;
   }
 
-  mVertex[0] = -(mBMatrix[0] * (mAMatrix[3] * mAMatrix[5] - mAMatrix[4] * mAMatrix[4]) -
-                 mAMatrix[1] * (mBMatrix[1] * mAMatrix[5] - mAMatrix[4] * mBMatrix[2]) +
-                 mAMatrix[2] * (mBMatrix[1] * mAMatrix[4] - mBMatrix[2] * mAMatrix[3])) /
-               determinant;
-  mVertex[1] = -(mAMatrix[0] * (mBMatrix[1] * mAMatrix[5] - mBMatrix[2] * mAMatrix[4]) -
-                 mBMatrix[0] * (mAMatrix[1] * mAMatrix[5] - mAMatrix[4] * mAMatrix[2]) +
-                 mAMatrix[2] * (mAMatrix[1] * mBMatrix[2] - mAMatrix[2] * mBMatrix[1])) /
-               determinant;
-  mVertex[2] = -(mAMatrix[0] * (mAMatrix[3] * mBMatrix[2] - mBMatrix[1] * mAMatrix[4]) -
-                 mAMatrix[1] * (mAMatrix[1] * mBMatrix[2] - mBMatrix[1] * mAMatrix[2]) +
-                 mBMatrix[0] * (mAMatrix[1] * mAMatrix[4] - mAMatrix[2] * mAMatrix[3])) /
-               determinant;
-}
-
-bool ClusterLines::operator==(const ClusterLines& rhs) const
-{
-  bool retval{true};
-  for (auto i{0}; i < 6; ++i) {
-    retval &= this->mRMS2[i] == rhs.mRMS2[i];
-  }
-  for (auto i{0}; i < 3; ++i) {
-    retval &= this->mVertex[i] == rhs.mVertex[i];
-  }
-  if (this->mLabels.size() != rhs.mLabels.size()) {
-    retval = false;
-  } else {
-    for (size_t i{0}; i < this->mLabels.size(); ++i) {
-      retval &= this->mLabels[i] == rhs.mLabels[i];
-    }
-  }
-  return retval && this->mAvgDistance2 == rhs.mAvgDistance2;
+  SVector3 result = invA * mBMatrix;
+  mVertex[0] = static_cast<float>(-result(0));
+  mVertex[1] = static_cast<float>(-result(1));
+  mVertex[2] = static_cast<float>(-result(2));
 }
 
-GPUhdi() void ClusterLines::updateROFPoll(const Line& line)
+bool ClusterLines::operator==(const ClusterLines& rhs) const noexcept
 {
-  // option 1: Boyer-Moore voting for rof label
-  if (mROFWeight == 0) {
-    mROF = line.getMinROF();
-    mROFWeight = 1;
-  } else {
-    if (mROF == line.getMinROF()) {
-      mROFWeight++;
-    } else {
-      mROFWeight--;
-    }
-  }
-
-  // option 2
-  // if (mROF == -1) {
-  //   mROF = line.getMinROF();
-  // } else {
-  //   if (line.getMinROF() < mROF) {
-  //     mROF = line.getMinROF();
-  //   }
-  // }
+  return mRMS2 == rhs.mRMS2 &&
+         mVertex == rhs.mVertex &&
+         mLabels == rhs.mLabels &&
+         mAvgDistance2 == rhs.mAvgDistance2;
 }
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 202dc87f04237..c447bb6bcc880 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -24,8 +24,8 @@ using namespace o2::its;
 
 std::string TrackingParameters::asString() const
 {
-  std::string str = std::format("NZb:{} NPhB:{} NROFIt:{} DRof:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{}",
-                                ZBins, PhiBins, nROFsPerIterations, DeltaROF, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength);
+  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{}",
+                                ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength);
   bool first = true;
   for (int il = NLayers; il >= MinTrackLength; il--) {
     int slot = NLayers - il;
@@ -37,9 +37,17 @@ std::string TrackingParameters::asString() const
       str += std::format("L{}:{:.2f} ", il, MinPt[slot]);
     }
   }
-  str += " SystErrY/Z:";
-  for (size_t i = 0; i < SystErrorY2.size(); i++) {
-    str += std::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);
+  if (!SystErrorY2.empty() || !SystErrorZ2.empty()) {
+    str += " SystErrY/Z:";
+    for (size_t i = 0; i < SystErrorY2.size(); i++) {
+      str += std::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);
+    }
+  }
+  if (!AddTimeError.empty()) {
+    str += " AddTimeError:";
+    for (size_t i = 0; i < AddTimeError.size(); i++) {
+      str += std::format("{} ", AddTimeError[i]);
+    }
   }
   if (std::numeric_limits<size_t>::max() != MaxMemory) {
     str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
@@ -49,7 +57,7 @@ std::string TrackingParameters::asString() const
 
 std::string VertexingParameters::asString() const
 {
-  std::string str = std::format("NZb:{} NPhB:{} DRof:{} ClsCont:{} MaxTrkltCls:{} ZCut:{} PhCut:{}", ZBins, PhiBins, deltaRof, clusterContributorsCut, maxTrackletsPerCluster, zCut, phiCut);
+  std::string str = std::format("NZb:{} NPhB:{} ClsCont:{} MaxTrkltCls:{} ZCut:{} PhCut:{}", ZBins, PhiBins, clusterContributorsCut, maxTrackletsPerCluster, zCut, phiCut);
   if (std::numeric_limits<size_t>::max() != MaxMemory) {
     str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
   }
@@ -126,14 +134,11 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       trackParams[3].MinTrackLength = 4;
       trackParams[3].TrackletMinPt = 0.1f;
       trackParams[3].CellDeltaTanLambdaSigma *= 4.;
-      trackParams[3].DeltaROF = 0; // UPC specific setting
     }
     for (size_t ip = 0; ip < trackParams.size(); ip++) {
       auto& param = trackParams[ip];
       param.ZBins = 64;
       param.PhiBins = 32;
-      param.CellsPerClusterLimit = 1.e3f;
-      param.TrackletsPerClusterLimit = 1.e3f;
       // check if something was overridden via configurable params
       if (ip < tc.MaxIter) {
         if (tc.startLayerMask[ip] > 0) {
@@ -164,19 +169,12 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     trackParams[0].PVres = 1.e5f;
     trackParams[0].MaxChi2ClusterAttachment = 60.;
     trackParams[0].MaxChi2NDF = 40.;
-    trackParams[0].TrackletsPerClusterLimit = 100.;
-    trackParams[0].CellsPerClusterLimit = 100.;
   } else {
     LOGP(fatal, "Unsupported ITS tracking mode {} ", toString(mode));
   }
 
   float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791;
   float bFactorTracklets = bFactor < 0.01 ? 1. : bFactor; // for tracklets only
-  int nROFsPerIterations = tc.nROFsPerIterations > 0 ? tc.nROFsPerIterations : -1;
-
-  if (tc.nOrbitsPerIterations > 0) {
-    /// code to be used when the number of ROFs per orbit is known, this gets priority over the number of ROFs per iteration
-  }
 
   // global parameters set for every iteration
   for (auto& p : trackParams) {
@@ -212,7 +210,9 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
         p.SystErrorZ2[i] = tc.sysErrZ2[i] > 0 ? tc.sysErrZ2[i] : p.SystErrorZ2[i];
       }
     }
-    p.DeltaROF = tc.deltaRof;
+    for (int i{0}; i < 7; ++i) {
+      p.AddTimeError[i] = tc.addTimeError[i];
+    }
     p.DoUPCIteration = tc.doUPCIteration;
     p.MaxChi2ClusterAttachment = tc.maxChi2ClusterAttachment > 0 ? tc.maxChi2ClusterAttachment : p.MaxChi2ClusterAttachment;
     p.MaxChi2NDF = tc.maxChi2NDF > 0 ? tc.maxChi2NDF : p.MaxChi2NDF;
@@ -222,32 +222,11 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     p.NSigmaCut *= tc.nSigmaCut > 0 ? tc.nSigmaCut : 1.f;
     p.CellDeltaTanLambdaSigma *= tc.deltaTanLres > 0 ? tc.deltaTanLres : 1.f;
     p.TrackletMinPt *= tc.minPt > 0 ? tc.minPt : 1.f;
-    p.nROFsPerIterations = nROFsPerIterations;
     p.PerPrimaryVertexProcessing = tc.perPrimaryVertexProcessing;
     for (int iD{0}; iD < 3; ++iD) {
       p.Diamond[iD] = tc.diamondPos[iD];
     }
     p.UseDiamond = tc.useDiamond;
-    if (tc.useTrackFollower > 0) {
-      p.UseTrackFollower = true;
-      // Bit 0: Allow for mixing of top&bot extension --> implies Bits 1&2 set
-      // Bit 1: Allow for top extension
-      // Bit 2: Allow for bot extension
-      p.UseTrackFollowerMix = ((tc.useTrackFollower & (1 << 0)) != 0);
-      p.UseTrackFollowerTop = ((tc.useTrackFollower & (1 << 1)) != 0);
-      p.UseTrackFollowerBot = ((tc.useTrackFollower & (1 << 2)) != 0);
-      p.TrackFollowerNSigmaCutZ = tc.trackFollowerNSigmaZ;
-      p.TrackFollowerNSigmaCutPhi = tc.trackFollowerNSigmaPhi;
-    }
-    if (tc.cellsPerClusterLimit >= 0) {
-      p.CellsPerClusterLimit = tc.cellsPerClusterLimit;
-    }
-    if (tc.trackletsPerClusterLimit >= 0) {
-      p.TrackletsPerClusterLimit = tc.trackletsPerClusterLimit;
-    }
-    if (tc.findShortTracks >= 0) {
-      p.FindShortTracks = tc.findShortTracks;
-    }
   }
 
   if (trackParams.size() > tc.nIterations) {
@@ -265,8 +244,6 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
     vertParams.resize(2); // The number of actual iterations will be set as a configKeyVal to allow for pp/PbPb choice
     vertParams[1].phiCut = 0.015f;
     vertParams[1].tanLambdaCut = 0.015f;
-    vertParams[1].vertPerRofThreshold = 0;
-    vertParams[1].deltaRof = 0;
   } else if (mode == TrackingMode::Sync) {
     vertParams.resize(1);
   } else if (mode == TrackingMode::Cosmics) {
@@ -282,8 +259,6 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
     p.MaxMemory = vc.maxMemory;
     p.DropTFUponFailure = vc.dropTFUponFailure;
     p.nIterations = vc.nIterations;
-    p.deltaRof = vc.deltaRof;
-    p.allowSingleContribClusters = vc.allowSingleContribClusters;
     p.trackletSigma = vc.trackletSigma;
     p.maxZPositionAllowed = vc.maxZPositionAllowed;
     p.clusterContributorsCut = vc.clusterContributorsCut;
@@ -293,7 +268,6 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
     p.PhiBins = vc.PhiBins;
 
     p.useTruthSeeding = vc.useTruthSeeding;
-    p.outputContLabels = vc.outputContLabels;
   }
   // set for now outside to not disturb status quo
   vertParams[0].vertNsigmaCut = vc.vertNsigmaCut;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx b/Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx
new file mode 100644
index 0000000000000..cb831d7db71d0
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx
@@ -0,0 +1,252 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  FastMultEst.h
+/// \brief Fast multiplicity estimator for ITS
+/// \author ruben.shahoyan@cern.ch
+
+#include "ITStracking/FastMultEst.h"
+#include "Framework/Logger.h"
+#include <ctime>
+#include <cstring>
+#include <algorithm>
+#include <TRandom.h>
+
+using namespace o2::its;
+
+namespace
+{
+
+// Convert trigger IR to ROF index on a given layer using LayerTiming
+int findROFForIR(const o2::InteractionRecord& ir,
+                 const o2::InteractionRecord& tfStartIR,
+                 const LayerTiming& layerTiming)
+{
+  // Convert IR to BC-from-TF-start, which is the time base expected by LayerTiming.
+  const int64_t bcFromTFStart = ir.differenceInBC(tfStartIR);
+  if (bcFromTFStart < 0) {
+    return -1;
+  }
+  return layerTiming.getROF(static_cast<LayerTiming::BCType>(bcFromTFStart));
+}
+
+template <int NLayers>
+void enableCompatibleROFs(int baseLayer,
+                          int baseRof,
+                          const typename o2::its::ROFOverlapTable<NLayers>::View& overlapView,
+                          o2::its::ROFMaskTable<NLayers>& sel)
+{
+  sel.setROFEnabled(baseLayer, baseRof);
+  for (int layer = 0; layer < NLayers; ++layer) {
+    if (layer == baseLayer) {
+      continue;
+    }
+    const auto& overlap = overlapView.getOverlap(baseLayer, layer, baseRof);
+    if (overlap.getEntries() > 0) {
+      sel.setROFsEnabled(layer, overlap.getFirstEntry(), overlap.getEntries());
+    }
+  }
+}
+
+template <int NLayers>
+std::vector<int> buildMultiplicityCounts(const std::array<gsl::span<const o2::itsmft::ROFRecord>, NLayers>& rofs,
+                                         const std::array<gsl::span<const o2::itsmft::CompClusterExt>, NLayers>& clus,
+                                         bool doStaggering,
+                                         int multLayer)
+{
+  std::vector<int> multCounts;
+  if (doStaggering) {
+    multCounts.resize(rofs[multLayer].size());
+    for (size_t iRof = 0; iRof < rofs[multLayer].size(); ++iRof) {
+      multCounts[iRof] = rofs[multLayer][iRof].getNEntries();
+    }
+    return multCounts;
+  }
+
+  static const o2::itsmft::ChipMappingITS chipMapping;
+  multCounts.resize(rofs[0].size(), 0);
+  for (size_t iRof = 0; iRof < rofs[0].size(); ++iRof) {
+    for (const auto& cluster : rofs[0][iRof].getROFData(clus[0])) {
+      if (chipMapping.getLayer(cluster.getSensorID()) == multLayer) {
+        ++multCounts[iRof];
+      }
+    }
+  }
+  return multCounts;
+}
+} // namespace
+
+bool FastMultEst::sSeedSet = false;
+
+///______________________________________________________
+FastMultEst::FastMultEst()
+{
+  if (!sSeedSet && FastMultEstConfig::Instance().cutRandomFraction > 0.f) {
+    sSeedSet = true;
+    if (FastMultEstConfig::Instance().randomSeed > 0) {
+      gRandom->SetSeed(FastMultEstConfig::Instance().randomSeed);
+    } else if (FastMultEstConfig::Instance().randomSeed < 0) {
+      gRandom->SetSeed(std::time(nullptr) % 0xffff);
+    }
+  }
+}
+
+///______________________________________________________
+/// count clusters on the configured multiplicity layer
+int FastMultEst::countClustersOnLayer(const gsl::span<const o2::itsmft::CompClusterExt>& clusters) const
+{
+  const int targetLayer = std::clamp(FastMultEstConfig::Instance().cutMultClusLayer, 0, NLayers - 1);
+  int count = 0;
+  int lr = FastMultEst::NLayers - 1;
+  int nchAcc = o2::itsmft::ChipMappingITS::getNChips() - o2::itsmft::ChipMappingITS::getNChipsPerLr(lr);
+  for (int i = clusters.size(); i--;) { // profit from clusters being ordered in chip increasing order
+    while (clusters[i].getSensorID() < nchAcc) {
+      assert(lr >= 0);
+      nchAcc -= o2::itsmft::ChipMappingITS::getNChipsPerLr(--lr);
+    }
+    if (lr == targetLayer) {
+      ++count;
+    }
+  }
+  return count;
+}
+
+///______________________________________________________
+/// find multiplicity for given number of clusters per layer
+float FastMultEst::processNoiseFree(int nClusters)
+{
+  // Single-layer regime: estimate multiplicity from one configured layer only.
+  const auto& conf = FastMultEstConfig::Instance();
+  const int layer = std::clamp(conf.cutMultClusLayer, 0, NLayers - 1);
+  const float acc = conf.accCorr[layer];
+  nLayersUsed = nClusters > 0 ? 1 : 0;
+  noisePerChip = 0.f;
+  chi2 = 0.f;
+  cov[0] = cov[1] = cov[2] = 0.f;
+  if (nLayersUsed == 0 || acc <= 0.f) {
+    mult = -1.f;
+    return -1.f;
+  }
+  mult = nClusters / acc;
+  return mult > 0 ? mult : 0;
+}
+
+///______________________________________________________
+/// find multiplicity for given number of clusters per layer with mean noise imposed
+float FastMultEst::processNoiseImposed(int nClusters)
+{
+  // Single-layer regime with imposed noise subtraction.
+  const auto& conf = FastMultEstConfig::Instance();
+  const int layer = std::clamp(conf.cutMultClusLayer, 0, NLayers - 1);
+  const float acc = conf.accCorr[layer];
+  const float nch = static_cast<float>(o2::itsmft::ChipMappingITS::getNChipsPerLr(layer));
+  nLayersUsed = nClusters > 0 ? 1 : 0;
+  chi2 = 0.f;
+  cov[0] = cov[1] = cov[2] = 0.f;
+  if (nLayersUsed == 0 || acc <= 0.f) {
+    mult = -1.f;
+    return -1.f;
+  }
+  mult = (nClusters - noisePerChip * nch) / acc;
+  return mult;
+}
+
+int FastMultEst::selectROFs(const std::array<gsl::span<const o2::itsmft::ROFRecord>, NLayers>& rofs,
+                            const std::array<gsl::span<const o2::itsmft::CompClusterExt>, NLayers>& clus,
+                            const gsl::span<const o2::itsmft::PhysTrigger> trig,
+                            uint32_t firstTForbit,
+                            bool doStaggering,
+                            const ROFOverlapTableN::View& overlapView,
+                            ROFMaskTableN& sel)
+{
+  const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
+  const int selectionLayer = overlapView.getClock();
+  int multLayer = std::clamp(multEstConf.cutMultClusLayer, 0, NLayers - 1);
+  if (doStaggering && rofs[multLayer].empty()) {
+    LOGP(info, "FastMultEst multiplicity layer {} has no ROFs, falling back to selection layer {}", multLayer, selectionLayer);
+    multLayer = selectionLayer;
+  }
+
+  const auto multCounts = buildMultiplicityCounts<NLayers>(rofs, clus, doStaggering, multLayer);
+  const int selectionRofCount = doStaggering ? static_cast<int>(rofs[selectionLayer].size()) : static_cast<int>(rofs[0].size());
+
+  sel.resetMask();
+  lastRandomSeed = gRandom->GetSeed();
+  const o2::InteractionRecord tfStartIR{0, firstTForbit};
+
+  if (!trig.empty()) {
+    const auto& selectionLayerTiming = overlapView.getLayer(selectionLayer);
+    const auto& multLayerTiming = overlapView.getLayer(multLayer);
+
+    for (const auto& trigger : trig) {
+      const int selectionRof = findROFForIR(trigger.ir, tfStartIR, selectionLayerTiming);
+      if (selectionRof < 0) {
+        continue;
+      }
+      if (multEstConf.cutRandomFraction > 0.f && gRandom->Rndm() < multEstConf.cutRandomFraction) {
+        continue;
+      }
+      if (multEstConf.isMultCutRequested()) {
+        const int triggerMultRof = doStaggering ? findROFForIR(trigger.ir, tfStartIR, multLayerTiming) : selectionRof;
+        if (triggerMultRof < 0 || triggerMultRof >= static_cast<int>(multCounts.size())) {
+          continue;
+        }
+        if (!multEstConf.isPassingMultCut(process(multCounts[triggerMultRof]))) {
+          continue;
+        }
+      }
+      enableCompatibleROFs<NLayers>(selectionLayer, selectionRof, overlapView, sel);
+    }
+  } else {
+    LOGP(info, "FastMultEst received no physics/TRD triggers, falling back to ROF-driven filtering on layer {}", selectionLayer);
+    for (int selectionRof = 0; selectionRof < selectionRofCount; ++selectionRof) {
+      if (multEstConf.isMultCutRequested()) {
+        bool passes = false;
+        if (!doStaggering || selectionLayer == multLayer) {
+          if (selectionRof < static_cast<int>(multCounts.size())) {
+            passes = multEstConf.isPassingMultCut(process(multCounts[selectionRof]));
+          }
+        } else {
+          const auto& overlap = overlapView.getOverlap(selectionLayer, multLayer, selectionRof);
+          for (int rof = overlap.getFirstEntry(); rof < overlap.getEntriesBound(); ++rof) {
+            if (rof < static_cast<int>(multCounts.size())) {
+              if (multEstConf.isPassingMultCut(process(multCounts[rof]))) {
+                passes = true;
+                break;
+              }
+            }
+          }
+        }
+        if (!passes) {
+          continue;
+        }
+      }
+      if (multEstConf.cutRandomFraction > 0.f && gRandom->Rndm() < multEstConf.cutRandomFraction) {
+        continue;
+      }
+      enableCompatibleROFs<NLayers>(selectionLayer, selectionRof, overlapView, sel);
+    }
+  }
+
+  const auto selView = sel.getView();
+  int nsel = 0;
+  for (int irof = 0; irof < selectionRofCount; ++irof) {
+    nsel += selView.isROFEnabled(selectionLayer, irof);
+  }
+
+  if (!trig.empty() && multEstConf.preferTriggered) {
+    LOGP(debug, "FastMultEst preferTriggered is ignored in trigger-driven mask mode");
+  }
+
+  LOGP(debug, "NSel = {} of {} rofs on layer {} Seeds: before {} after {}", nsel, selectionRofCount, selectionLayer, lastRandomSeed, gRandom->GetSeed());
+
+  return nsel;
+}
diff --git a/Detectors/ITSMFT/ITS/reconstruction/src/FastMultEstConfig.cxx b/Detectors/ITSMFT/ITS/tracking/src/FastMultEstConfig.cxx
similarity index 94%
rename from Detectors/ITSMFT/ITS/reconstruction/src/FastMultEstConfig.cxx
rename to Detectors/ITSMFT/ITS/tracking/src/FastMultEstConfig.cxx
index 63c43cf26ba15..1568d8ed9f9fb 100644
--- a/Detectors/ITSMFT/ITS/reconstruction/src/FastMultEstConfig.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/FastMultEstConfig.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "ITSReconstruction/FastMultEstConfig.h"
+#include "ITStracking/FastMultEstConfig.h"
 #include "TRandom.h"
 
 O2ParamImpl(o2::its::FastMultEstConfig);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/IndexTableUtils.cxx b/Detectors/ITSMFT/ITS/tracking/src/IndexTableUtils.cxx
deleted file mode 100644
index 7152640e9a70f..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/src/IndexTableUtils.cxx
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file IndexTableUtils.cxx
-/// \brief
-///
-
-#include "ITStracking/IndexTableUtils.h"
-
-namespace o2
-{
-namespace its
-{
-
-const std::vector<std::pair<int, int>> index_table_utils::selectClusters(
-  const std::array<int, constants::index_table::ZBins * constants::index_table::PhiBins + 1>& indexTable,
-  const std::array<int, 4>& selectedBinsRect)
-{
-  std::vector<std::pair<int, int>> filteredBins{};
-
-  int phiBinsNum{selectedBinsRect[3] - selectedBinsRect[1] + 1};
-
-  if (phiBinsNum < 0) {
-    phiBinsNum += constants::index_table::PhiBins;
-  }
-
-  filteredBins.reserve(phiBinsNum);
-
-  for (int iPhiBin{selectedBinsRect[1]}, iPhiCount{0}; iPhiCount < phiBinsNum;
-       iPhiBin = ++iPhiBin == constants::index_table::PhiBins ? 0 : iPhiBin, iPhiCount++) {
-
-    const int firstBinIndex{index_table_utils::getBinIndex(selectedBinsRect[0], iPhiBin)};
-
-    filteredBins.emplace_back(indexTable[firstBinIndex],
-                              countRowSelectedBins(indexTable, iPhiBin, selectedBinsRect[0], selectedBinsRect[2]));
-  }
-
-  return filteredBins;
-}
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx b/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
deleted file mode 100644
index f2f7dbc81398f..0000000000000
--- a/Detectors/ITSMFT/ITS/tracking/src/Smoother.cxx
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-//
-// \author matteo.concas@cern.ch
-
-#include "ITStracking/Smoother.h"
-
-namespace o2
-{
-namespace its
-{
-
-constexpr std::array<double, 3> getInverseSymm2D(const std::array<double, 3>& mat)
-{
-  const double det = mat[0] * mat[2] - mat[1] * mat[1];
-  return std::array<double, 3>{mat[2] / det, -mat[1] / det, mat[0] / det};
-}
-
-// Smoother
-// template <unsigned int D>
-// Smoother<D>::Smoother(TrackITSExt& track, size_t smoothingLayer, const ROframe& event, float bZ, o2::base::PropagatorF::MatCorrType corr) : mLayerToSmooth{smoothingLayer},
-//                                                                                                                                             mBz(bZ),
-//                                                                                                                                             mCorr(corr)
-// {
-//
-//   auto propInstance = o2::base::Propagator::Instance();
-//   const TrackingFrameInfo& originalTf = event.getTrackingFrameInfoOnLayer(mLayerToSmooth).at(track.getClusterIndex(mLayerToSmooth));
-//
-//   mOutwardsTrack = track;               // This track will be propagated outwards inside the smoother! (as last step of fitting did inward propagation)
-//   mInwardsTrack = {track.getParamOut(), // This track will be propagated inwards inside the smoother!
-//                    static_cast<short>(mOutwardsTrack.getNumberOfClusters()), -999, static_cast<std::uint32_t>(event.getROFrameId()),
-//                    mOutwardsTrack.getParamOut(), mOutwardsTrack.getClusterIndexes()};
-//
-//   mOutwardsTrack.resetCovariance();
-//   mOutwardsTrack.setChi2(0);
-//   mInwardsTrack.resetCovariance();
-//   mInwardsTrack.setChi2(0);
-//
-//   bool statusOutw{false};
-//   bool statusInw{false};
-//
-//   //////////////////////
-//   // Outward propagation
-//   for (size_t iLayer{0}; iLayer < mLayerToSmooth; ++iLayer) {
-//     if (mOutwardsTrack.getClusterIndex(iLayer) == constants::UnusedIndex) { // Shorter tracks
-//       continue;
-//     }
-//     const TrackingFrameInfo& tF = event.getTrackingFrameInfoOnLayer(iLayer).at(mOutwardsTrack.getClusterIndex(iLayer));
-//     statusOutw = mOutwardsTrack.rotate(tF.alphaTrackingFrame);
-//     statusOutw &= propInstance->propagateToX(mOutwardsTrack,
-//                                              tF.xTrackingFrame,
-//                                              mBz,
-//                                              o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-//                                              o2::base::PropagatorImpl<float>::MAX_STEP,
-//                                              mCorr);
-//     mOutwardsTrack.setChi2(mOutwardsTrack.getChi2() + mOutwardsTrack.getPredictedChi2(tF.positionTrackingFrame, tF.covarianceTrackingFrame));
-//     statusOutw &= mOutwardsTrack.o2::track::TrackParCov::update(tF.positionTrackingFrame, tF.covarianceTrackingFrame);
-//     // LOG(info) << "Outwards loop on inwards track, layer: " << iLayer << " x: " << mOutwardsTrack.getX();
-//   }
-//
-//   // Prediction on the previously outwards-propagated track is done on a copy, as the process seems to be not reversible
-//   auto outwardsClone = mOutwardsTrack;
-//   statusOutw = outwardsClone.rotate(originalTf.alphaTrackingFrame);
-//   statusOutw &= propInstance->propagateToX(outwardsClone,
-//                                            originalTf.xTrackingFrame,
-//                                            mBz,
-//                                            o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-//                                            o2::base::PropagatorImpl<float>::MAX_STEP,
-//                                            mCorr);
-//   /////////////////////
-//   // Inward propagation
-//   for (size_t iLayer{D - 1}; iLayer > mLayerToSmooth; --iLayer) {
-//     if (mInwardsTrack.getClusterIndex(iLayer) == constants::UnusedIndex) { // Shorter tracks
-//       continue;
-//     }
-//     const TrackingFrameInfo& tF = event.getTrackingFrameInfoOnLayer(iLayer).at(mInwardsTrack.getClusterIndex(iLayer));
-//     statusInw = mInwardsTrack.rotate(tF.alphaTrackingFrame);
-//     statusInw &= propInstance->propagateToX(mInwardsTrack,
-//                                             tF.xTrackingFrame,
-//                                             mBz,
-//                                             o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-//                                             o2::base::PropagatorImpl<float>::MAX_STEP,
-//                                             mCorr);
-//     mInwardsTrack.setChi2(mInwardsTrack.getChi2() + mInwardsTrack.getPredictedChi2(tF.positionTrackingFrame, tF.covarianceTrackingFrame));
-//     statusInw &= mInwardsTrack.o2::track::TrackParCov::update(tF.positionTrackingFrame, tF.covarianceTrackingFrame);
-//     // LOG(info) << "Inwards loop on outwards track, layer: " << iLayer << " x: " << mInwardsTrack.getX();
-//   }
-//
-//   // Prediction on the previously inwards-propagated track is done on a copy, as the process seems to be not revesible
-//   auto inwardsClone = mInwardsTrack;
-//   statusInw = inwardsClone.rotate(originalTf.alphaTrackingFrame);
-//   statusInw &= propInstance->propagateToX(inwardsClone,
-//                                           originalTf.xTrackingFrame,
-//                                           mBz,
-//                                           o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-//                                           o2::base::PropagatorImpl<float>::MAX_STEP,
-//                                           mCorr);
-//   // Compute weighted local chi2
-//   mInitStatus = statusInw && statusOutw;
-//   if (mInitStatus) {
-//     mBestChi2 = computeSmoothedPredictedChi2(inwardsClone, outwardsClone, originalTf.positionTrackingFrame, originalTf.covarianceTrackingFrame);
-//     mLastChi2 = mBestChi2;
-//     LOG(info) << "Smoothed chi2 on original cluster: " << mBestChi2;
-//   }
-// }
-
-template <unsigned int D>
-Smoother<D>::~Smoother() = default;
-
-template <unsigned int D>
-float Smoother<D>::computeSmoothedPredictedChi2(const o2::track::TrackParCov& firstTrack,  // outwards track: from innermost cluster to outermost
-                                                const o2::track::TrackParCov& secondTrack, // inwards track: from outermost cluster to innermost
-                                                const std::array<float, 2>& cls,
-                                                const std::array<float, 3>& clCov)
-{
-  // Tracks need to be already propagated, compute only chi2
-  // Symmetric covariances assumed
-
-  if (firstTrack.getX() != secondTrack.getX()) {
-    LOG(fatal) << "Tracks need to be propagated to the same point! secondTrack.X=" << secondTrack.getX() << " firstTrack.X=" << firstTrack.getX();
-  }
-
-  std::array<double, 2> pp1 = {static_cast<double>(firstTrack.getY()), static_cast<double>(firstTrack.getZ())};   // P1: predicted Y,Z points
-  std::array<double, 2> pp2 = {static_cast<double>(secondTrack.getY()), static_cast<double>(secondTrack.getZ())}; // P2: predicted Y,Z points
-
-  std::array<double, 3> c1 = {static_cast<double>(firstTrack.getSigmaY2()),
-                              static_cast<double>(firstTrack.getSigmaZY()),
-                              static_cast<double>(firstTrack.getSigmaZ2())}; // Cov. track 1
-
-  std::array<double, 3> c2 = {static_cast<double>(secondTrack.getSigmaY2()),
-                              static_cast<double>(secondTrack.getSigmaZY()),
-                              static_cast<double>(secondTrack.getSigmaZ2())}; // Cov. track 2
-
-  std::array<double, 3> w1 = getInverseSymm2D(c1); // weight matrices
-  std::array<double, 3> w2 = getInverseSymm2D(c2);
-
-  std::array<double, 3> w1w2 = {w1[0] + w2[0], w1[1] + w2[1], w1[2] + w2[2]}; // (W1 + W2)
-  std::array<double, 3> C = getInverseSymm2D(w1w2);                           // C = (W1+W2)^-1
-
-  std::array<double, 2> w1pp1 = {w1[0] * pp1[0] + w1[1] * pp1[1], w1[1] * pp1[0] + w1[2] * pp1[1]}; // W1 * P1
-  std::array<double, 2> w2pp2 = {w2[0] * pp2[0] + w2[1] * pp2[1], w2[1] * pp2[0] + w2[2] * pp2[1]}; // W2 * P2
-
-  double Y = C[0] * (w1pp1[0] + w2pp2[0]) + C[1] * (w1pp1[1] + w2pp2[1]); // Pp: weighted normalized combination of the predictions:
-  double Z = C[1] * (w1pp1[0] + w2pp2[0]) + C[2] * (w1pp1[1] + w2pp2[1]); // Pp = [(W1 * P1) + (W2 * P2)] / (W1 + W2)
-
-  std::array<double, 2> delta = {Y - cls[0], Z - cls[1]};                                                                                         // Δ = Pp - X, X: space point of cluster (Y,Z)
-  std::array<double, 3> CCp = {C[0] + static_cast<double>(clCov[0]), C[1] + static_cast<double>(clCov[1]), C[2] + static_cast<double>(clCov[2])}; // Transformation of cluster covmat: CCp = C + Cov
-  std::array<double, 3> Wp = getInverseSymm2D(CCp);                                                                                               // Get weight matrix: Wp = CCp^-1
-
-  float chi2 = static_cast<float>(delta[0] * (Wp[0] * delta[0] + Wp[1] * delta[1]) + delta[1] * (Wp[1] * delta[0] + Wp[2] * delta[1])); // chi2 = tΔ * (Wp * Δ)
-
-  // #ifdef CA_DEBUG
-  LOG(info) << "Cluster_y: " << cls[0] << " Cluster_z: " << cls[1];
-  LOG(info) << "\t\t- Covariance cluster: Y2: " << clCov[0] << " YZ: " << clCov[1] << " Z2: " << clCov[2];
-  LOG(info) << "\t\t- Propagated t1_y: " << pp1[0] << " t1_z: " << pp1[1];
-  LOG(info) << "\t\t- Propagated t2_y: " << pp2[0] << " t2_z: " << pp2[1];
-  LOG(info) << "\t\t- Covariance t1: sY2: " << c1[0] << " sYZ: " << c1[1] << " sZ2: " << c1[2];
-  LOG(info) << "\t\t- Covariance t2: sY2: " << c2[0] << " sYZ: " << c2[1] << " sZ2: " << c2[2];
-  LOG(info) << "Smoother prediction Y: " << Y << " Z: " << Z;
-  LOG(info) << "\t\t- Delta_y: " << delta[0] << " Delta_z: " << delta[1];
-  LOG(info) << "\t\t- Covariance Pr: Y2: " << C[0] << " YZ: " << C[1] << " Z2: " << C[2];
-  LOG(info) << "\t\t- predicted chi2 t1: " << firstTrack.getPredictedChi2(cls, clCov);
-  LOG(info) << "\t\t- predicted chi2 t2: " << secondTrack.getPredictedChi2(cls, clCov);
-  // #endif
-  return chi2;
-}
-
-// template <unsigned int D>
-// bool Smoother<D>::testCluster(const int clusterId, const ROframe& event)
-// {
-//   if (!mInitStatus) {
-//     return false;
-//   }
-//   auto propInstance = o2::base::Propagator::Instance();
-//   const TrackingFrameInfo& testTf = event.getTrackingFrameInfoOnLayer(mLayerToSmooth).at(clusterId);
-//
-//   bool statusOutw{false};
-//   bool statusInw{false};
-//
-//   // Prediction on the previously outwards-propagated track is done on a copy, as the process seems to be not reversible
-//   auto outwardsClone = mOutwardsTrack;
-//   statusOutw = outwardsClone.rotate(testTf.alphaTrackingFrame);
-//   statusOutw &= propInstance->propagateToX(outwardsClone,
-//                                            testTf.xTrackingFrame,
-//                                            mBz,
-//                                            o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-//                                            o2::base::PropagatorImpl<float>::MAX_STEP,
-//                                            mCorr);
-//
-//   // Prediction on the previously inwards-propagated track is done on a copy, as the process seems to be not reversible
-//   auto inwardsClone = mInwardsTrack;
-//   statusInw = inwardsClone.rotate(testTf.alphaTrackingFrame);
-//   statusInw &= propInstance->propagateToX(inwardsClone,
-//                                           testTf.xTrackingFrame,
-//                                           mBz,
-//                                           o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-//                                           o2::base::PropagatorImpl<float>::MAX_STEP,
-//                                           mCorr);
-//   if (!(statusOutw && statusInw)) {
-//     LOG(warning) << "Failed propagation in smoother!";
-//     return false;
-//   }
-//
-//   // Compute weighted local chi2
-//   mLastChi2 = computeSmoothedPredictedChi2(inwardsClone, outwardsClone, testTf.positionTrackingFrame, testTf.covarianceTrackingFrame);
-//   LOG(info) << "Smoothed chi2 on tested cluster: " << mLastChi2;
-//
-//   return true;
-// }
-
-template class Smoother<7>;
-
-} // namespace its
-} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 29fb4ac4c69b5..5a32b3d3b1a95 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -46,82 +46,43 @@ constexpr float DefClusErrorCol = o2::itsmft::SegmentationAlpide::PitchCol * 0.5
 constexpr float DefClusError2Row = DefClusErrorRow * DefClusErrorRow;
 constexpr float DefClusError2Col = DefClusErrorCol * DefClusErrorCol;
 
-template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVertices(const bounded_vector<Vertex>& vertices, const int iteration)
+template <int NLayers>
+void TimeFrame<NLayers>::addPrimaryVertex(const Vertex& vert)
 {
-  for (const auto& vertex : vertices) {
-    mPrimaryVertices.emplace_back(vertex); // put a copy in the present
-    mTotVertPerIteration[iteration]++;
-    if (!isBeamPositionOverridden) { // beam position is updated only at first occurrence of the vertex. A bit sketchy if we have past/future vertices, it should not impact too much.
-      const float w = vertex.getNContributors();
-      mBeamPos[0] = (mBeamPos[0] * mBeamPosWeight + vertex.getX() * w) / (mBeamPosWeight + w);
-      mBeamPos[1] = (mBeamPos[1] * mBeamPosWeight + vertex.getY() * w) / (mBeamPosWeight + w);
-      mBeamPosWeight += w;
-    }
-  }
-  mROFramesPV.push_back(mPrimaryVertices.size()); // current rof must have number of vertices up to present
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVerticesLabels(bounded_vector<std::pair<MCCompLabel, float>>& labels)
-{
-  mVerticesMCRecInfo.insert(mVerticesMCRecInfo.end(), labels.begin(), labels.end());
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVerticesContributorLabels(bounded_vector<MCCompLabel>& labels)
-{
-  mVerticesContributorLabels.insert(mVerticesContributorLabels.end(), labels.begin(), labels.end());
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVerticesInROF(const bounded_vector<Vertex>& vertices, const int rofId, const int iteration)
-{
-  mPrimaryVertices.insert(mPrimaryVertices.begin() + mROFramesPV[rofId], vertices.begin(), vertices.end());
-  for (int i = rofId + 1; i < mROFramesPV.size(); ++i) {
-    mROFramesPV[i] += vertices.size();
+  mPrimaryVertices.emplace_back(vert);
+  if (!isBeamPositionOverridden) {
+    const float w = vert.getNContributors();
+    mBeamPos[0] = (mBeamPos[0] * mBeamPosWeight + vert.getX() * w) / (mBeamPosWeight + w);
+    mBeamPos[1] = (mBeamPos[1] * mBeamPosWeight + vert.getY() * w) / (mBeamPosWeight + w);
+    mBeamPosWeight += w;
   }
-  mTotVertPerIteration[iteration] += vertices.size();
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVerticesLabelsInROF(const bounded_vector<std::pair<MCCompLabel, float>>& labels, const int rofId)
-{
-  mVerticesMCRecInfo.insert(mVerticesMCRecInfo.begin() + mROFramesPV[rofId], labels.begin(), labels.end());
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::addPrimaryVerticesContributorLabelsInROF(const bounded_vector<MCCompLabel>& labels, const int rofId)
-{
-  // count the number of cont. in rofs before and including the target rof
-  unsigned int n{0};
-  const auto& pvs = getPrimaryVertices(0, rofId);
-  for (const auto& pv : pvs) {
-    n += pv.getNContributors();
-  }
-  mVerticesContributorLabels.insert(mVerticesContributorLabels.begin() + n, labels.begin(), labels.end());
-}
-
-template <int nLayers>
-int TimeFrame<nLayers>::loadROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
-                                        gsl::span<const itsmft::CompClusterExt> clusters,
-                                        gsl::span<const unsigned char>::iterator& pattIt,
-                                        const itsmft::TopologyDictionary* dict,
-                                        const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
+template <int NLayers>
+void TimeFrame<NLayers>::loadROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
+                                         gsl::span<const itsmft::CompClusterExt> clusters,
+                                         gsl::span<const unsigned char>::iterator& pattIt,
+                                         const itsmft::TopologyDictionary* dict,
+                                         int layer,
+                                         const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
   GeometryTGeo* geom = GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
+  resetROFrameData(layer);
+  prepareROFrameData(clusters, layer);
 
-  resetROFrameData(rofs.size());
-  prepareROFrameData(rofs, clusters);
+  // check for missing/empty/unset rofs
+  // the code requires consistent monotonically increasing input without gaps
+  const auto& timing = mROFOverlapTableView.getLayer(layer >= 0 ? layer : 0);
+  if (timing.mNROFsTF != rofs.size()) {
+    LOGP(fatal, "Received inconsistent number of rofs on layer:{} expected:{} received:{}", layer, timing.mNROFsTF, rofs.size());
+  }
 
-  for (size_t iRof{0}; iRof < rofs.size(); ++iRof) {
+  for (int32_t iRof{0}; iRof < rofs.size(); ++iRof) {
     const auto& rof = rofs[iRof];
     for (int clusterId{rof.getFirstEntry()}; clusterId < rof.getFirstEntry() + rof.getNEntries(); ++clusterId) {
       const auto& c = clusters[clusterId];
-
-      int layer = geom->getLayer(c.getSensorID());
-
+      int lay = geom->getLayer(c.getSensorID());
       auto pattID = c.getPatternID();
       o2::math_utils::Point3D<float> locXYZ;
       float sigmaY2 = DefClusError2Row, sigmaZ2 = DefClusError2Col, sigmaYZ = 0; // Dummy COG errors (about half pixel size)
@@ -142,85 +103,97 @@ int TimeFrame<nLayers>::loadROFrameData(gsl::span<const o2::itsmft::ROFRecord> r
         locXYZ = dict->getClusterCoordinates(c, patt, false);
         clusterSize = patt.getNPixels();
       }
-      mClusterSize[clusterId] = std::clamp(clusterSize, 0u, 255u);
+      mClusterSize[layer >= 0 ? layer : 0][clusterId] = std::clamp(clusterSize, 0u, 255u);
       auto sensorID = c.getSensorID();
       // Inverse transformation to the local --> tracking
       auto trkXYZ = geom->getMatrixT2L(sensorID) ^ locXYZ;
       // Transformation to the local --> global
       auto gloXYZ = geom->getMatrixL2G(sensorID) * locXYZ;
-
-      addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), geom->getSensorRefAlpha(sensorID),
+      addTrackingFrameInfoToLayer(lay, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), geom->getSensorRefAlpha(sensorID),
                                   std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
                                   std::array<float, 3>{sigmaY2, sigmaYZ, sigmaZ2});
       /// Rotate to the global frame
-      addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), mUnsortedClusters[layer].size());
-      addClusterExternalIndexToLayer(layer, clusterId);
+      addClusterToLayer(lay, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), mUnsortedClusters[lay].size());
+      addClusterExternalIndexToLayer(lay, clusterId);
     }
-    for (unsigned int iL{0}; iL < mUnsortedClusters.size(); ++iL) {
-      mROFramesClusters[iL][iRof + 1] = mUnsortedClusters[iL].size(); // effectively calculating and exclusive sum
+    // effectively calculating an exclusive sum
+    if (layer >= 0) {
+      mROFramesClusters[layer][iRof + 1] = mUnsortedClusters[layer].size();
+    } else {
+      for (unsigned int iL{0}; iL < mUnsortedClusters.size(); ++iL) {
+        mROFramesClusters[iL][iRof + 1] = mUnsortedClusters[iL].size();
+      }
     }
   }
 
-  for (auto i = 0; i < mNTrackletsPerCluster.size(); ++i) {
-    mNTrackletsPerCluster[i].resize(mUnsortedClusters[1].size());
-    mNTrackletsPerClusterSum[i].resize(mUnsortedClusters[1].size() + 1); // Exc sum "prepends" a 0
+  if (layer == 1 || layer == -1) {
+    for (auto i = 0; i < mNTrackletsPerCluster.size(); ++i) {
+      mNTrackletsPerCluster[i].resize(mUnsortedClusters[1].size());
+      mNTrackletsPerClusterSum[i].resize(mUnsortedClusters[1].size() + 1);
+    }
   }
 
   if (mcLabels != nullptr) {
-    mClusterLabels = mcLabels;
+    mClusterLabels[layer >= 0 ? layer : 0] = mcLabels;
+  } else {
+    mClusterLabels[layer >= 0 ? layer : 0] = nullptr;
   }
-
-  return mNrof;
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::resetROFrameData(size_t nRofs)
+template <int NLayers>
+void TimeFrame<NLayers>::resetROFrameData(int layer)
 {
-  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
-    deepVectorClear(mUnsortedClusters[iLayer], getMaybeFrameworkHostResource());
-    deepVectorClear(mTrackingFrameInfo[iLayer], getMaybeFrameworkHostResource());
-    clearResizeBoundedVector(mROFramesClusters[iLayer], nRofs + 1, getMaybeFrameworkHostResource());
-    deepVectorClear(mClusterExternalIndices[iLayer], mMemoryPool.get());
-
-    if (iLayer < 2) {
-      deepVectorClear(mTrackletsIndexROF[iLayer], mMemoryPool.get());
-      deepVectorClear(mNTrackletsPerCluster[iLayer], mMemoryPool.get());
-      deepVectorClear(mNTrackletsPerClusterSum[iLayer], mMemoryPool.get());
+  if (layer >= 0) {
+    deepVectorClear(mUnsortedClusters[layer], getMaybeFrameworkHostResource());
+    deepVectorClear(mTrackingFrameInfo[layer], getMaybeFrameworkHostResource());
+    deepVectorClear(mClusterExternalIndices[layer], mMemoryPool.get());
+    clearResizeBoundedVector(mROFramesClusters[layer], mROFOverlapTableView.getLayer(layer).mNROFsTF + 1, getMaybeFrameworkHostResource());
+  } else {
+    for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
+      deepVectorClear(mUnsortedClusters[iLayer], getMaybeFrameworkHostResource());
+      deepVectorClear(mTrackingFrameInfo[iLayer], getMaybeFrameworkHostResource());
+      deepVectorClear(mClusterExternalIndices[iLayer], mMemoryPool.get());
+      clearResizeBoundedVector(mROFramesClusters[iLayer], mROFOverlapTableView.getLayer(iLayer).mNROFsTF + 1, getMaybeFrameworkHostResource());
     }
   }
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::prepareROFrameData(gsl::span<const o2::itsmft::ROFRecord> rofs,
-                                            gsl::span<const itsmft::CompClusterExt> clusters)
+template <int NLayers>
+void TimeFrame<NLayers>::prepareROFrameData(gsl::span<const itsmft::CompClusterExt> clusters, int layer)
 {
-  GeometryTGeo* geom = GeometryTGeo::Instance();
-  mNrof = rofs.size();
-  clearResizeBoundedVector(mClusterSize, clusters.size(), mMemoryPool.get());
-  std::array<int, nLayers> clusterCountPerLayer{};
-  for (const auto& clus : clusters) {
-    ++clusterCountPerLayer[geom->getLayer(clus.getSensorID())];
-  }
-  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
-    mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
-    mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
-    mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
+  if (layer >= 0) {
+    mUnsortedClusters[layer].reserve(clusters.size());
+    mTrackingFrameInfo[layer].reserve(clusters.size());
+    mClusterExternalIndices[layer].reserve(clusters.size());
+    clearResizeBoundedVector(mClusterSize[layer], clusters.size(), mMemoryPool.get());
+  } else {
+    auto* geom = GeometryTGeo::Instance();
+    clearResizeBoundedVector(mClusterSize[0], clusters.size(), mMemoryPool.get());
+    std::array<size_t, NLayers> clusterCountPerLayer{0};
+    for (const auto& cls : clusters) {
+      ++clusterCountPerLayer[geom->getLayer(cls.getChipID())];
+    }
+    for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
+      mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
+      mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
+      mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    }
   }
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, const int maxLayers)
+template <int NLayers>
+void TimeFrame<NLayers>::prepareClusters(const TrackingParameters& trkParam, const int maxLayers)
 {
   const int numBins{trkParam.PhiBins * trkParam.ZBins};
   const int stride{numBins + 1};
   bounded_vector<ClusterHelper> cHelper(mMemoryPool.get());
   bounded_vector<int> clsPerBin(numBins, 0, mMemoryPool.get());
   bounded_vector<int> lutPerBin(numBins, 0, mMemoryPool.get());
-  for (int rof{0}; rof < mNrof; ++rof) {
-    if ((int)mMultiplicityCutMask.size() == mNrof && !mMultiplicityCutMask[rof]) {
-      continue;
-    }
-    for (int iLayer{0}, stopLayer = std::min(trkParam.NLayers, maxLayers); iLayer < stopLayer; ++iLayer) {
+  for (int iLayer{0}, stopLayer = std::min(trkParam.NLayers, maxLayers); iLayer < stopLayer; ++iLayer) {
+    for (int rof{0}; rof < getNrof(iLayer); ++rof) {
+      if (!mROFMaskView.isROFEnabled(iLayer, rof)) {
+        continue;
+      }
       const auto& unsortedClusters{getUnsortedClustersOnLayer(rof, iLayer)};
       const int clustersNum{static_cast<int>(unsortedClusters.size())};
       auto* tableBase = mIndexTables[iLayer].data() + rof * stride;
@@ -270,25 +243,19 @@ void TimeFrame<nLayers>::prepareClusters(const TrackingParameters& trkParam, con
   }
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers, bool resetVertices)
+template <int NLayers>
+void TimeFrame<NLayers>::initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers, bool resetVertices)
 {
   if (iteration == 0) {
-    if (maxLayers < trkParam.NLayers && resetVertices) {
-      resetRofPV();
-      deepVectorClear(mTotVertPerIteration);
-    }
     deepVectorClear(mTracks);
     deepVectorClear(mTracksLabel);
     deepVectorClear(mLines);
     deepVectorClear(mLinesLabels);
     if (resetVertices) {
-      deepVectorClear(mVerticesMCRecInfo);
-      deepVectorClear(mVerticesContributorLabels);
+      deepVectorClear(mPrimaryVertices);
+      deepVectorClear(mPrimaryVerticesLabels);
     }
-    clearResizeBoundedVector(mTracks, mNrof, mMemoryPool.get());
-    clearResizeBoundedVector(mTracksLabel, mNrof, mMemoryPool.get());
-    clearResizeBoundedVector(mLinesLabels, mNrof, mMemoryPool.get());
+    clearResizeBoundedVector(mLinesLabels, getNrof(1), mMemoryPool.get());
     clearResizeBoundedVector(mCells, trkParam.CellsPerRoad(), mMemoryPool.get());
     clearResizeBoundedVector(mCellsLookupTable, trkParam.CellsPerRoad() - 1, mMemoryPool.get());
     clearResizeBoundedVector(mCellsNeighbours, trkParam.CellsPerRoad() - 1, mMemoryPool.get());
@@ -302,14 +269,16 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     clearResizeBoundedVector(mBogusClusters, trkParam.NLayers, mMemoryPool.get());
     deepVectorClear(mTrackletClusters);
     for (unsigned int iLayer{0}; iLayer < std::min((int)mClusters.size(), maxLayers); ++iLayer) {
-      clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeFrameworkHostResource(maxLayers != nLayers));
-      clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeFrameworkHostResource(maxLayers != nLayers));
+      clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeFrameworkHostResource(maxLayers != NLayers));
+      clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeFrameworkHostResource(maxLayers != NLayers));
       mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
     }
-    clearResizeBoundedArray(mIndexTables, mNrof * (trkParam.ZBins * trkParam.PhiBins + 1), getMaybeFrameworkHostResource(maxLayers != nLayers));
-    clearResizeBoundedVector(mLines, mNrof, mMemoryPool.get());
-    clearResizeBoundedVector(mTrackletClusters, mNrof, mMemoryPool.get());
+    clearResizeBoundedVector(mLines, getNrof(1), mMemoryPool.get());
+    clearResizeBoundedVector(mTrackletClusters, getNrof(1), mMemoryPool.get());
 
+    for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
+      clearResizeBoundedVector(mIndexTables[iLayer], getNrof(iLayer) * ((trkParam.ZBins * trkParam.PhiBins) + 1), getMaybeFrameworkHostResource());
+    }
     for (int iLayer{0}; iLayer < trkParam.NLayers; ++iLayer) {
       if (trkParam.SystErrorY2[iLayer] > 0.f || trkParam.SystErrorZ2[iLayer] > 0.f) {
         for (auto& tfInfo : mTrackingFrameInfo[iLayer]) {
@@ -319,12 +288,13 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
         }
       }
     }
-    mMinR.fill(10000.);
-    mMaxR.fill(-1.);
+
+    mMinR.fill(std::numeric_limits<float>::max());
+    mMaxR.fill(std::numeric_limits<float>::min());
   }
   mNTrackletsPerROF.resize(2);
   for (auto& v : mNTrackletsPerROF) {
-    v = bounded_vector<int>(mNrof + 1, 0, mMemoryPool.get());
+    v = bounded_vector<int>(getNrof(1) + 1, 0, mMemoryPool.get());
   }
   if (iteration == 0 || iteration == 3) {
     prepareClusters(trkParam, maxLayers);
@@ -337,15 +307,10 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
     }
   }
 
-  mTotVertPerIteration.resize(1 + iteration);
-  mNoVertexROF = 0;
-  deepVectorClear(mRoads);
-  deepVectorClear(mRoadLabels);
-
   mMSangles.resize(trkParam.NLayers);
   mPhiCuts.resize(mClusters.size() - 1, 0.f);
   float oneOverR{0.001f * 0.3f * std::abs(mBz) / trkParam.TrackletMinPt};
-  for (unsigned int iLayer{0}; iLayer < nLayers; ++iLayer) {
+  for (unsigned int iLayer{0}; iLayer < NLayers; ++iLayer) {
     mMSangles[iLayer] = math_utils::MSangle(0.14f, trkParam.TrackletMinPt, trkParam.LayerxX0[iLayer]);
     mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
     if (iLayer < mClusters.size() - 1) {
@@ -381,8 +346,8 @@ void TimeFrame<nLayers>::initialise(const int iteration, const TrackingParameter
   }
 }
 
-template <int nLayers>
-unsigned long TimeFrame<nLayers>::getArtefactsMemory() const
+template <int NLayers>
+unsigned long TimeFrame<NLayers>::getArtefactsMemory() const
 {
   unsigned long size{0};
   for (const auto& trkl : mTracklets) {
@@ -394,31 +359,21 @@ unsigned long TimeFrame<nLayers>::getArtefactsMemory() const
   for (const auto& cellsN : mCellsNeighbours) {
     size += sizeof(int) * cellsN.size();
   }
-  return size + sizeof(Road<nLayers - 2>) * mRoads.size();
+  return size;
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::printArtefactsMemory() const
+template <int NLayers>
+void TimeFrame<NLayers>::printArtefactsMemory() const
 {
   LOGP(info, "TimeFrame: Artefacts occupy {:.2f} MB", getArtefactsMemory() / constants::MB);
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::fillPrimaryVerticesXandAlpha()
-{
-  deepVectorClear(mPValphaX);
-  mPValphaX.reserve(mPrimaryVertices.size());
-  for (auto& pv : mPrimaryVertices) {
-    mPValphaX.emplace_back(std::array<float, 2>{o2::gpu::CAMath::Hypot(pv.getX(), pv.getY()), math_utils::computePhi(pv.getX(), pv.getY())});
-  }
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::computeTrackletsPerROFScans()
+template <int NLayers>
+void TimeFrame<NLayers>::computeTrackletsPerROFScans()
 {
   for (ushort iLayer = 0; iLayer < 2; ++iLayer) {
-    for (unsigned int iRof{0}; iRof < mNrof; ++iRof) {
-      if (mMultiplicityCutMask[iRof]) {
+    for (unsigned int iRof{0}; iRof < getNrof(1); ++iRof) {
+      if (mROFMaskView.isROFEnabled(1, iRof)) {
         mTotalTracklets[iLayer] += mNTrackletsPerROF[iLayer][iRof];
       }
     }
@@ -427,141 +382,8 @@ void TimeFrame<nLayers>::computeTrackletsPerROFScans()
   }
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::checkTrackletLUTs()
-{
-  for (uint32_t iLayer{0}; iLayer < getTracklets().size(); ++iLayer) {
-    int prev{-1};
-    int count{0};
-    for (uint32_t iTracklet{0}; iTracklet < getTracklets()[iLayer].size(); ++iTracklet) {
-      auto& trk = getTracklets()[iLayer][iTracklet];
-      int currentId{trk.firstClusterIndex};
-      if (currentId < prev) {
-        LOG(info) << "First Cluster Index not increasing monotonically on L:T:ID:Prev " << iLayer << "\t" << iTracklet << "\t" << currentId << "\t" << prev;
-      } else if (currentId == prev) {
-        count++;
-      } else {
-        if (iLayer > 0) {
-          auto& lut{getTrackletsLookupTable()[iLayer - 1]};
-          if (count != lut[prev + 1] - lut[prev]) {
-            LOG(info) << "LUT count broken " << iLayer - 1 << "\t" << prev << "\t" << count << "\t" << lut[prev + 1] << "\t" << lut[prev];
-          }
-        }
-        count = 1;
-      }
-      prev = currentId;
-      if (iLayer > 0) {
-        auto& lut{getTrackletsLookupTable()[iLayer - 1]};
-        if (iTracklet >= (uint32_t)(lut[currentId + 1]) || iTracklet < (uint32_t)(lut[currentId])) {
-          LOG(info) << "LUT broken: " << iLayer - 1 << "\t" << currentId << "\t" << iTracklet;
-        }
-      }
-    }
-  }
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::printTrackletLUTonLayer(int i)
-{
-  LOG(info) << "-------- Tracklet LUT " << i;
-  std::stringstream s;
-  for (int j : mTrackletsLookupTable[i]) {
-    s << j << "\t";
-  }
-  LOG(info) << s.str();
-  LOG(info) << "--------";
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::printCellLUTonLayer(int i)
-{
-  LOG(info) << "-------- Cell LUT " << i;
-  std::stringstream s;
-  for (int j : mCellsLookupTable[i]) {
-    s << j << "\t";
-  }
-  LOG(info) << s.str();
-  LOG(info) << "--------";
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::printTrackletLUTs()
-{
-  for (unsigned int i{0}; i < mTrackletsLookupTable.size(); ++i) {
-    printTrackletLUTonLayer(i);
-  }
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::printCellLUTs()
-{
-  for (unsigned int i{0}; i < mCellsLookupTable.size(); ++i) {
-    printCellLUTonLayer(i);
-  }
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::printVertices()
-{
-  LOG(info) << "Vertices in ROF (nROF = " << mNrof << ", lut size = " << mROFramesPV.size() << ")";
-  for (unsigned int iR{0}; iR < mROFramesPV.size(); ++iR) {
-    LOG(info) << mROFramesPV[iR] << "\t";
-  }
-  LOG(info) << "\n\n Vertices:";
-  for (unsigned int iV{0}; iV < mPrimaryVertices.size(); ++iV) {
-    LOG(info) << mPrimaryVertices[iV].getX() << "\t" << mPrimaryVertices[iV].getY() << "\t" << mPrimaryVertices[iV].getZ();
-  }
-  LOG(info) << "--------";
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::printROFoffsets()
-{
-  LOG(info) << "--------";
-  for (unsigned int iLayer{0}; iLayer < mROFramesClusters.size(); ++iLayer) {
-    LOG(info) << "Layer " << iLayer;
-    std::stringstream s;
-    for (auto value : mROFramesClusters[iLayer]) {
-      s << value << "\t";
-    }
-    LOG(info) << s.str();
-  }
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::printNClsPerROF()
-{
-  LOG(info) << "--------";
-  for (unsigned int iLayer{0}; iLayer < mNClustersPerROF.size(); ++iLayer) {
-    LOG(info) << "Layer " << iLayer;
-    std::stringstream s;
-    for (auto& value : mNClustersPerROF[iLayer]) {
-      s << value << "\t";
-    }
-    LOG(info) << s.str();
-  }
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::printSliceInfo(const int startROF, const int sliceSize)
-{
-  LOG(info) << "Dumping slice of " << sliceSize << " rofs:";
-  for (int iROF{startROF}; iROF < startROF + sliceSize; ++iROF) {
-    LOG(info) << "ROF " << iROF << " dump:";
-    for (unsigned int iLayer{0}; iLayer < mClusters.size(); ++iLayer) {
-      LOG(info) << "Layer " << iLayer << " has: " << getClustersOnLayer(iROF, iLayer).size() << " clusters.";
-    }
-    LOG(info) << "Number of seeding vertices: " << getPrimaryVertices(iROF).size();
-    int iVertex{0};
-    for (auto& v : getPrimaryVertices(iROF)) {
-      LOG(info) << "\t vertex " << iVertex++ << ": x=" << v.getX() << " "
-                << " y=" << v.getY() << " z=" << v.getZ() << " has " << v.getNContributors() << " contributors.";
-    }
-  }
-}
-
-template <int nLayers>
-void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
+template <int NLayers>
+void TimeFrame<NLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> pool)
 {
   mMemoryPool = pool;
 
@@ -577,33 +399,29 @@ void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> po
   };
 
   // these will only reside on the host for the cpu part
-  initVector(mTotVertPerIteration);
   initContainers(mClusterExternalIndices);
   initContainers(mNTrackletsPerCluster);
   initContainers(mNTrackletsPerClusterSum);
   initContainers(mNClustersPerROF);
-  initVector(mROFramesPV);
   initVector(mPrimaryVertices);
-  initVector(mRoads);
   initVector(mMSangles);
   initVector(mPhiCuts);
   initVector(mPositionResolution);
-  initVector(mClusterSize);
+  initContainers(mClusterSize);
   initVector(mPValphaX);
   initVector(mBogusClusters);
   initContainers(mTrackletsIndexROF);
-  initContainers(mTracks);
+  initVector(mTracks);
   initContainers(mTracklets);
   initContainers(mCells);
   initContainers(mCellsNeighbours);
   initContainers(mCellsLookupTable);
   // MC info (we don't know if we have MC)
-  initVector(mVerticesContributorLabels);
+  initVector(mPrimaryVerticesLabels);
   initContainers(mLinesLabels);
   initContainers(mTrackletLabels);
   initContainers(mCellLabels);
-  initVector(mRoadLabels);
-  initContainers(mTracksLabel);
+  initVector(mTracksLabel);
   // these will use possibly an externally provided allocator
   initContainers(mClusters, hasFrameworkAllocator());
   initContainers(mUsedClusters, hasFrameworkAllocator());
@@ -613,30 +431,27 @@ void TimeFrame<nLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> po
   initContainers(mROFramesClusters, hasFrameworkAllocator());
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::setFrameworkAllocator(ExternalAllocator* ext)
+template <int NLayers>
+void TimeFrame<NLayers>::setFrameworkAllocator(ExternalAllocator* ext)
 {
   mExternalAllocator = ext;
   mExtMemoryPool = std::make_shared<BoundedMemoryResource>(mExternalAllocator);
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::wipe()
+template <int NLayers>
+void TimeFrame<NLayers>::wipe()
 {
   deepVectorClear(mTracks);
   deepVectorClear(mTracklets);
   deepVectorClear(mCells);
-  deepVectorClear(mRoads);
   deepVectorClear(mCellsNeighbours);
   deepVectorClear(mCellsLookupTable);
-  deepVectorClear(mTotVertPerIteration);
   deepVectorClear(mPrimaryVertices);
   deepVectorClear(mTrackletsLookupTable);
   deepVectorClear(mClusterExternalIndices);
   deepVectorClear(mNTrackletsPerCluster);
   deepVectorClear(mNTrackletsPerClusterSum);
   deepVectorClear(mNClustersPerROF);
-  deepVectorClear(mROFramesPV);
   deepVectorClear(mMSangles);
   deepVectorClear(mPhiCuts);
   deepVectorClear(mPositionResolution);
@@ -659,10 +474,9 @@ void TimeFrame<nLayers>::wipe()
   // only needed to clear if we have MC info
   if (hasMCinformation()) {
     deepVectorClear(mLinesLabels);
-    deepVectorClear(mVerticesContributorLabels);
+    deepVectorClear(mPrimaryVerticesLabels);
     deepVectorClear(mTrackletLabels);
     deepVectorClear(mCellLabels);
-    deepVectorClear(mRoadLabels);
     deepVectorClear(mTracksLabel);
   }
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 658a90b37613f..dc032a46213a9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -14,28 +14,22 @@
 ///
 
 #include "ITStracking/Tracker.h"
-
 #include "ITStracking/BoundedAllocator.h"
-#include "ITStracking/Cell.h"
 #include "ITStracking/Constants.h"
-#include "ITStracking/IndexTableUtils.h"
-#include "ITStracking/Tracklet.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITStracking/TrackingConfigParam.h"
 
-#include "ReconstructionDataFormats/Track.h"
 #include <cassert>
 #include <format>
 #include <cstdlib>
 #include <string>
-#include <climits>
 
 namespace o2::its
 {
 using o2::its::constants::GB;
 
-template <int nLayers>
-Tracker<nLayers>::Tracker(TrackerTraits<nLayers>* traits) : mTraits(traits)
+template <int NLayers>
+Tracker<NLayers>::Tracker(TrackerTraits<NLayers>* traits) : mTraits(traits)
 {
   /// Initialise standard configuration with 1 iteration
   mTrkParams.resize(1);
@@ -45,27 +39,26 @@ Tracker<nLayers>::Tracker(TrackerTraits<nLayers>* traits) : mTraits(traits)
   }
 }
 
-template <int nLayers>
-void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& error)
+template <int NLayers>
+void Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& error)
 {
   LogFunc evalLog = [](const std::string&) {};
 
   double total{0};
   mTraits->updateTrackingParameters(mTrkParams);
+  mTimeFrame->updateROFVertexLookupTable();
+
   int maxNvertices{-1};
   if (mTrkParams[0].PerPrimaryVertexProcessing) {
-    for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
-      int minRof = o2::gpu::CAMath::Max(0, iROF - mTrkParams[0].DeltaROF);
-      int maxRof = o2::gpu::CAMath::Min(mTimeFrame->getNrof(), iROF + mTrkParams[0].DeltaROF);
-      maxNvertices = std::max(maxNvertices, (int)mTimeFrame->getPrimaryVertices(minRof, maxRof).size());
-    }
+    maxNvertices = mTimeFrame->getROFVertexLookupTableView().getMaxVerticesPerROF();
   }
 
-  int iteration{0}, iROFs{0}, iVertex{0};
+  int iteration{0}, iVertex{0};
   auto handleException = [&](const auto& err) {
-    LOGP(error, "Too much memory used during {} in iteration {} in ROF span {}-{} iVtx={}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
-         StateNames[mCurState], iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, iVertex,
-         (double)mTimeFrame->getArtefactsMemory() / GB, (double)mTrkParams[iteration].MaxMemory / GB);
+    LOGP(error, "Too much memory in {} in iteration {} iVtx={}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
+         StateNames[mCurState], iteration, iVertex,
+         (double)mTimeFrame->getArtefactsMemory() / GB,
+         (double)mTrkParams[iteration].MaxMemory / GB);
     if (typeid(err) != typeid(std::bad_alloc)) { // only print if the exceptions is different from what is expected
       LOGP(error, "Exception: {}", err.what());
     }
@@ -73,7 +66,7 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
       mMemoryPool->print();
       mTimeFrame->wipe();
       ++mNumberOfDroppedTFs;
-      error("...Dropping Timeframe...");
+      error(std::format("...Dropping TimeSlice {} (out of {} dropped {})...", mTimeSlice, mTimeFrameCounter, mNumberOfDroppedTFs));
     } else {
       throw err;
     }
@@ -83,61 +76,34 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
     for (iteration = 0; iteration < (int)mTrkParams.size(); ++iteration) {
       mMemoryPool->setMaxMemory(mTrkParams[iteration].MaxMemory);
       if (iteration == 3 && mTrkParams[0].DoUPCIteration) {
-        mTimeFrame->swapMasks();
+        mTimeFrame->useUPCMask();
       }
-      double timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
-      int nTracklets{0}, nCells{0}, nNeighbours{0}, nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
-      int nROFsIterations = (mTrkParams[iteration].nROFsPerIterations > 0 && !mTimeFrame->isGPU()) ? mTimeFrame->getNrof() / mTrkParams[iteration].nROFsPerIterations + bool(mTimeFrame->getNrof() % mTrkParams[iteration].nROFsPerIterations) : 1;
+      float timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
+      size_t nTracklets{0}, nCells{0}, nNeighbours{0};
+      int nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
       iVertex = std::min(maxNvertices, 0);
       logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
-
       total += evaluateTask(&Tracker::initialiseTimeFrame, StateNames[mCurState = TFInit], iteration, logger, iteration);
       do {
-        for (iROFs = 0; iROFs < nROFsIterations; ++iROFs) {
-          timeTracklets += evaluateTask(&Tracker::computeTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration, iROFs, iVertex);
-          nTracklets += mTraits->getTFNumberOfTracklets();
-          float trackletsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfTracklets()) / float(mTraits->getTFNumberOfClusters()) : 0.f;
-          if (trackletsPerCluster > mTrkParams[iteration].TrackletsPerClusterLimit) {
-            error(std::format("Too many tracklets per cluster ({}) in iteration {} in ROF span {}-{}:, check the detector status and/or the selections. Current limit is {}",
-                              trackletsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].TrackletsPerClusterLimit));
-            break;
-          }
-          timeCells += evaluateTask(&Tracker::computeCells, StateNames[mCurState = Celling], iteration, evalLog, iteration);
-          nCells += mTraits->getTFNumberOfCells();
-          float cellsPerCluster = mTraits->getTFNumberOfClusters() > 0 ? float(mTraits->getTFNumberOfCells()) / float(mTraits->getTFNumberOfClusters()) : 0.f;
-          if (cellsPerCluster > mTrkParams[iteration].CellsPerClusterLimit) {
-            error(std::format("Too many cells per cluster ({}) in iteration {} in ROF span {}-{}, check the detector status and/or the selections. Current limit is {}",
-                              cellsPerCluster, iteration, iROFs, iROFs + mTrkParams[iteration].nROFsPerIterations, mTrkParams[iteration].CellsPerClusterLimit));
-            break;
-          }
-          timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, StateNames[mCurState = Neighbouring], iteration, evalLog, iteration);
-          nNeighbours += mTimeFrame->getNumberOfNeighbours();
-          timeRoads += evaluateTask(&Tracker::findRoads, StateNames[mCurState = Roading], iteration, evalLog, iteration);
-        }
+        timeTracklets += evaluateTask(&Tracker::computeTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration, iVertex);
+        nTracklets += mTraits->getTFNumberOfTracklets();
+        timeCells += evaluateTask(&Tracker::computeCells, StateNames[mCurState = Celling], iteration, evalLog, iteration);
+        nCells += mTraits->getTFNumberOfCells();
+        timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, StateNames[mCurState = Neighbouring], iteration, evalLog, iteration);
+        nNeighbours += mTimeFrame->getNumberOfNeighbours();
+        timeRoads += evaluateTask(&Tracker::findRoads, StateNames[mCurState = Roading], iteration, evalLog, iteration);
       } while (++iVertex < maxNvertices);
       logger(std::format(" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
       logger(std::format(" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
       logger(std::format(" - Neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
       logger(std::format(" - Track finding: {} tracks found in {:.2f} ms", nTracks + mTimeFrame->getNumberOfTracks(), timeRoads));
       total += timeTracklets + timeCells + timeNeighbours + timeRoads;
-      if (mTraits->supportsExtendTracks() && mTrkParams[iteration].UseTrackFollower) {
-        int nExtendedTracks{-mTimeFrame->mNExtendedTracks}, nExtendedClusters{-mTimeFrame->mNExtendedUsedClusters};
-        auto timeExtending = evaluateTask(&Tracker::extendTracks, "Extending tracks", iteration, evalLog, iteration);
-        total += timeExtending;
-        logger(std::format(" - Extending Tracks: {} extended tracks using {} clusters found in {:.2f} ms", nExtendedTracks + mTimeFrame->mNExtendedTracks, nExtendedClusters + mTimeFrame->mNExtendedUsedClusters, timeExtending));
-      }
       if (mTrkParams[iteration].PrintMemory) {
         mMemoryPool->print();
       }
     }
-    if (mTraits->supportsFindShortPrimaries() && mTrkParams[0].FindShortTracks) {
-      auto nTracksB = mTimeFrame->getNumberOfTracks();
-      total += evaluateTask(&Tracker::findShortPrimaries, "Short primaries finding", 0, logger);
-      auto nTracksA = mTimeFrame->getNumberOfTracks();
-      logger(std::format("  `-> found {} additional tracks", nTracksA - nTracksB));
-    }
     if constexpr (constants::DoTimeBenchmarks) {
-      logger(std::format("=== TimeFrame {} processing completed in: {:.2f} ms using {} thread(s) ===", mTimeFrameCounter, total, mTraits->getNThreads()));
+      logger(std::format("=== TimeSlice {} processing completed in: {:.2f} ms using {} thread(s) ===", mTimeSlice, total, mTraits->getNThreads()));
     }
   } catch (const BoundedMemoryResource::MemoryLimitExceeded& err) {
     handleException(err);
@@ -148,9 +114,7 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
   } catch (const std::exception& err) {
     error(std::format("Uncaught exception, all bets are off... {}", err.what()));
     // clear tracks explicitly since if not fatalising on exception this may contain partial output
-    for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
-      mTimeFrame->getTracks(iROF).clear();
-    }
+    mTimeFrame->getTracks().clear();
     return;
   }
 
@@ -158,6 +122,8 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
     computeTracksMClabels();
   }
   rectifyClusterIndices();
+  sortTracks();
+
   ++mTimeFrameCounter;
   mTotalTime += total;
 
@@ -167,88 +133,23 @@ void Tracker<nLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
   }
 }
 
-template <int nLayers>
-void Tracker<nLayers>::computeRoadsMClabels()
+template <int NLayers>
+void Tracker<NLayers>::computeTracksMClabels()
 {
-  /// Moore's Voting Algorithm
-  if (!mTimeFrame->hasMCinformation()) {
-    return;
-  }
-
-  mTimeFrame->initialiseRoadLabels();
-
-  int roadsNum{static_cast<int>(mTimeFrame->getRoads().size())};
-
-  for (int iRoad{0}; iRoad < roadsNum; ++iRoad) {
-
-    auto& currentRoad{mTimeFrame->getRoads()[iRoad]};
+  for (auto& track : mTimeFrame->getTracks()) {
     std::vector<std::pair<MCCompLabel, size_t>> occurrences;
-    bool isFakeRoad{false};
-    bool isFirstRoadCell{true};
-
-    for (int iCell{0}; iCell < mTrkParams[0].CellsPerRoad(); ++iCell) {
-      const int currentCellIndex{currentRoad[iCell]};
-
-      if (currentCellIndex == constants::UnusedIndex) {
-        if (isFirstRoadCell) {
-          continue;
-        } else {
-          break;
-        }
-      }
-
-      const auto& currentCell{mTimeFrame->getCells()[iCell][currentCellIndex]};
-
-      if (isFirstRoadCell) {
-
-        const int cl0index{mTimeFrame->getClusters()[iCell][currentCell.getFirstClusterIndex()].clusterId};
-        auto cl0labs{mTimeFrame->getClusterLabels(iCell, cl0index)};
-        bool found{false};
-        for (size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
-          std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
-          for (const auto& label : cl0labs) {
-            if (label == occurrence.first) {
-              ++occurrence.second;
-              found = true;
-              // break; // uncomment to stop to the first hit
-            }
-          }
-        }
-        if (!found) {
-          for (const auto& label : cl0labs) {
-            occurrences.emplace_back(label, 1);
-          }
-        }
+    occurrences.clear();
 
-        const int cl1index{mTimeFrame->getClusters()[iCell + 1][currentCell.getSecondClusterIndex()].clusterId};
-
-        const auto& cl1labs{mTimeFrame->getClusterLabels(iCell + 1, cl1index)};
-        found = false;
-        for (size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
-          std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
-          for (auto& label : cl1labs) {
-            if (label == occurrence.first) {
-              ++occurrence.second;
-              found = true;
-              // break; // uncomment to stop to the first hit
-            }
-          }
-        }
-        if (!found) {
-          for (auto& label : cl1labs) {
-            occurrences.emplace_back(label, 1);
-          }
-        }
-
-        isFirstRoadCell = false;
+    for (int iCluster = 0; iCluster < TrackITSExt::MaxClusters; ++iCluster) {
+      const int index = track.getClusterIndex(iCluster);
+      if (index == constants::UnusedIndex) {
+        continue;
       }
-
-      const int cl2index{mTimeFrame->getClusters()[iCell + 2][currentCell.getThirdClusterIndex()].clusterId};
-      const auto& cl2labs{mTimeFrame->getClusterLabels(iCell + 2, cl2index)};
+      auto labels = mTimeFrame->getClusterLabels(iCluster, index);
       bool found{false};
       for (size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
         std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
-        for (auto& label : cl2labs) {
+        for (const auto& label : labels) {
           if (label == occurrence.first) {
             ++occurrence.second;
             found = true;
@@ -257,104 +158,94 @@ void Tracker<nLayers>::computeRoadsMClabels()
         }
       }
       if (!found) {
-        for (auto& label : cl2labs) {
+        for (const auto& label : labels) {
           occurrences.emplace_back(label, 1);
         }
       }
     }
-
-    std::sort(occurrences.begin(), occurrences.end(), [](auto e1, auto e2) {
+    std::sort(std::begin(occurrences), std::end(occurrences), [](auto e1, auto e2) {
       return e1.second > e2.second;
     });
 
     auto maxOccurrencesValue = occurrences[0].first;
-    mTimeFrame->setRoadLabel(iRoad, maxOccurrencesValue.getRawValue(), isFakeRoad);
-  }
-}
-
-template <int nLayers>
-void Tracker<nLayers>::computeTracksMClabels()
-{
-  for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
-    for (auto& track : mTimeFrame->getTracks(iROF)) {
-      std::vector<std::pair<MCCompLabel, size_t>> occurrences;
-      occurrences.clear();
-
-      for (int iCluster = 0; iCluster < TrackITSExt::MaxClusters; ++iCluster) {
-        const int index = track.getClusterIndex(iCluster);
-        if (index == constants::UnusedIndex) {
-          continue;
-        }
-        auto labels = mTimeFrame->getClusterLabels(iCluster, index);
-        bool found{false};
-        for (size_t iOcc{0}; iOcc < occurrences.size(); ++iOcc) {
-          std::pair<o2::MCCompLabel, size_t>& occurrence = occurrences[iOcc];
-          for (const auto& label : labels) {
-            if (label == occurrence.first) {
-              ++occurrence.second;
-              found = true;
-              // break; // uncomment to stop to the first hit
-            }
-          }
-        }
-        if (!found) {
-          for (const auto& label : labels) {
-            occurrences.emplace_back(label, 1);
+    uint32_t pattern = track.getPattern();
+    // set fake clusters pattern
+    for (int ic{TrackITSExt::MaxClusters}; ic--;) {
+      auto clid = track.getClusterIndex(ic);
+      if (clid != constants::UnusedIndex) {
+        auto labelsSpan = mTimeFrame->getClusterLabels(ic, clid);
+        for (const auto& currentLabel : labelsSpan) {
+          if (currentLabel == maxOccurrencesValue) {
+            pattern |= 0x1 << (16 + ic); // set bit if correct
+            break;
           }
         }
       }
-      std::sort(std::begin(occurrences), std::end(occurrences), [](auto e1, auto e2) {
-        return e1.second > e2.second;
-      });
+    }
+    track.setPattern(pattern);
+    if (occurrences[0].second < track.getNumberOfClusters()) {
+      maxOccurrencesValue.setFakeFlag();
+    }
+    mTimeFrame->getTracksLabel().emplace_back(maxOccurrencesValue);
+  }
+}
 
-      auto maxOccurrencesValue = occurrences[0].first;
-      uint32_t pattern = track.getPattern();
-      // set fake clusters pattern
-      for (int ic{TrackITSExt::MaxClusters}; ic--;) {
-        auto clid = track.getClusterIndex(ic);
-        if (clid != constants::UnusedIndex) {
-          auto labelsSpan = mTimeFrame->getClusterLabels(ic, clid);
-          for (const auto& currentLabel : labelsSpan) {
-            if (currentLabel == maxOccurrencesValue) {
-              pattern |= 0x1 << (16 + ic); // set bit if correct
-              break;
-            }
-          }
-        }
-      }
-      track.setPattern(pattern);
-      if (occurrences[0].second < track.getNumberOfClusters()) {
-        maxOccurrencesValue.setFakeFlag();
+template <int NLayers>
+void Tracker<NLayers>::rectifyClusterIndices()
+{
+  for (auto& track : mTimeFrame->getTracks()) {
+    for (int iCluster = 0; iCluster < TrackITSExt::MaxClusters; ++iCluster) {
+      const int index = track.getClusterIndex(iCluster);
+      if (index != constants::UnusedIndex) {
+        track.setExternalClusterIndex(iCluster, mTimeFrame->getClusterExternalIndex(iCluster, index));
       }
-      mTimeFrame->getTracksLabel(iROF).emplace_back(maxOccurrencesValue);
     }
   }
 }
 
-template <int nLayers>
-void Tracker<nLayers>::rectifyClusterIndices()
+template <int NLayers>
+void Tracker<NLayers>::sortTracks()
 {
-  for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
-    for (auto& track : mTimeFrame->getTracks(iROF)) {
-      for (int iCluster = 0; iCluster < TrackITSExt::MaxClusters; ++iCluster) {
-        const int index = track.getClusterIndex(iCluster);
-        if (index != constants::UnusedIndex) {
-          track.setExternalClusterIndex(iCluster, mTimeFrame->getClusterExternalIndex(iCluster, index));
-        }
-      }
+  auto& trks = mTimeFrame->getTracks();
+  bounded_vector<size_t> indices(trks.size(), mMemoryPool.get());
+  std::iota(indices.begin(), indices.end(), 0);
+  std::sort(indices.begin(), indices.end(), [&trks](size_t i, size_t j) {
+    // provide tracks sorted by lower-bound
+    const auto& a = trks[i];
+    const auto& b = trks[j];
+    const auto aLower = a.getTimeStamp().getTimeStamp() - a.getTimeStamp().getTimeStampError();
+    const auto bLower = b.getTimeStamp().getTimeStamp() - b.getTimeStamp().getTimeStampError();
+    if (aLower != bLower) {
+      return aLower < bLower;
+    }
+    return a.isBetter(b, 1e9); // then sort tracks in quality
+  });
+  bounded_vector<TrackITSExt> sortedTrks(mMemoryPool.get());
+  sortedTrks.reserve(trks.size());
+  for (size_t idx : indices) {
+    sortedTrks.push_back(trks[idx]);
+  }
+  trks.swap(sortedTrks);
+  if (mTimeFrame->hasMCinformation()) {
+    auto& trksLabels = mTimeFrame->getTracksLabel();
+    bounded_vector<MCCompLabel> sortedLabels(mMemoryPool.get());
+    sortedLabels.reserve(trksLabels.size());
+    for (size_t idx : indices) {
+      sortedLabels.push_back(trksLabels[idx]);
     }
+    trksLabels.swap(sortedLabels);
   }
 }
 
-template <int nLayers>
-void Tracker<nLayers>::adoptTimeFrame(TimeFrame<nLayers>& tf)
+template <int NLayers>
+void Tracker<NLayers>::adoptTimeFrame(TimeFrame<NLayers>& tf)
 {
   mTimeFrame = &tf;
   mTraits->adoptTimeFrame(&tf);
 }
 
-template <int nLayers>
-void Tracker<nLayers>::printSummary() const
+template <int NLayers>
+void Tracker<NLayers>::printSummary() const
 {
   auto avgTF = mTotalTime * 1.e-3 / ((mTimeFrameCounter > 0) ? (double)mTimeFrameCounter : -1.0);
   auto avgTFwithDropped = mTotalTime * 1.e-3 / (((mTimeFrameCounter + mNumberOfDroppedTFs) > 0) ? (double)(mTimeFrameCounter + mNumberOfDroppedTFs) : -1.0);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index da7c9afdd3ed6..f996c0d25e7d7 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -14,27 +14,22 @@
 ///
 
 #include <algorithm>
-#include <iostream>
 #include <iterator>
 #include <ranges>
 #include <type_traits>
 
-#ifdef OPTIMISATION_OUTPUT
-#include <format>
-#include <fstream>
-#endif
-
 #include <oneapi/tbb/blocked_range.h>
 #include <oneapi/tbb/parallel_sort.h>
 
 #include "CommonConstants/MathConstants.h"
 #include "DetectorsBase/Propagator.h"
 #include "GPUCommonMath.h"
+#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/Cell.h"
 #include "ITStracking/Constants.h"
-#include "ITStracking/TrackerTraits.h"
-#include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/IndexTableUtils.h"
+#include "ITStracking/ROFLookupTables.h"
+#include "ITStracking/TrackerTraits.h"
 #include "ITStracking/Tracklet.h"
 #include "ReconstructionDataFormats/Track.h"
 
@@ -49,42 +44,38 @@ struct PassMode {
   using TwoPassInsert = std::integral_constant<int, 2>;
 };
 
-template <int nLayers>
-void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROFslice, int iVertex)
+template <int NLayers>
+void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVertex)
 {
-#ifdef OPTIMISATION_OUTPUT
-  static int iter{0};
-  std::ofstream off(std::format("tracklets{}.txt", iter++));
-#endif
-
   for (int iLayer = 0; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
     mTimeFrame->getTracklets()[iLayer].clear();
     mTimeFrame->getTrackletsLabel(iLayer).clear();
     if (iLayer > 0) {
-      std::fill(mTimeFrame->getTrackletsLookupTable()[iLayer - 1].begin(),
-                mTimeFrame->getTrackletsLookupTable()[iLayer - 1].end(), 0);
+      std::fill(mTimeFrame->getTrackletsLookupTable()[iLayer - 1].begin(), mTimeFrame->getTrackletsLookupTable()[iLayer - 1].end(), 0);
     }
   }
 
-  const Vertex diamondVert({mTrkParams[iteration].Diamond[0], mTrkParams[iteration].Diamond[1], mTrkParams[iteration].Diamond[2]}, {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f}, 1, 1.f);
+  const Vertex diamondVert(mTrkParams[iteration].Diamond, mTrkParams[iteration].DiamondCov, 1, 1.f);
   gsl::span<const Vertex> diamondSpan(&diamondVert, 1);
-  int startROF{mTrkParams[iteration].nROFsPerIterations > 0 ? iROFslice * mTrkParams[iteration].nROFsPerIterations : 0};
-  int endROF{o2::gpu::GPUCommonMath::Min(mTrkParams[iteration].nROFsPerIterations > 0 ? (iROFslice + 1) * mTrkParams[iteration].nROFsPerIterations + mTrkParams[iteration].DeltaROF : mTimeFrame->getNrof(), mTimeFrame->getNrof())};
 
   mTaskArena->execute([&] {
     auto forTracklets = [&](auto Tag, int iLayer, int pivotROF, int base, int& offset) -> int {
-      if (!mTimeFrame->mMultiplicityCutMask[pivotROF]) {
+      if (!mTimeFrame->getROFMaskView().isROFEnabled(iLayer, pivotROF)) {
         return 0;
       }
-      int minROF = o2::gpu::CAMath::Max(startROF, pivotROF - mTrkParams[iteration].DeltaROF);
-      int maxROF = o2::gpu::CAMath::Min(endROF - 1, pivotROF + mTrkParams[iteration].DeltaROF);
-      gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(minROF, maxROF);
+      gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(iLayer, pivotROF);
       if (primaryVertices.empty()) {
         return 0;
       }
       const int startVtx = iVertex >= 0 ? iVertex : 0;
       const int endVtx = iVertex >= 0 ? o2::gpu::CAMath::Min(iVertex + 1, int(primaryVertices.size())) : int(primaryVertices.size());
-      if (endVtx <= startVtx) {
+      if (endVtx <= startVtx || (iVertex + 1) > primaryVertices.size()) {
+        return 0;
+      }
+
+      // does this layer have any overlap with the next layer
+      const auto& rofOverlap = mTimeFrame->getROFOverlapTableView().getOverlap(iLayer, iLayer + 1, pivotROF);
+      if (!rofOverlap.getEntries()) {
         return 0;
       }
 
@@ -107,10 +98,12 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
 
         for (int iV = startVtx; iV < endVtx; ++iV) {
           const auto& pv = primaryVertices[iV];
+          if (!mTimeFrame->getROFVertexLookupTableView().isVertexCompatible(iLayer, pivotROF, pv)) {
+            continue;
+          }
           if ((pv.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) || (iteration == 3 && !pv.isFlagSet(Vertex::Flags::UPCMode))) {
             continue;
           }
-
           const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)) + math_utils::Sq(mTrkParams[iteration].PVres) / float(pv.getNContributors()));
           const float tanLambda = (currentCluster.zCoordinate - pv.getZ()) * inverseR0;
           const float zAtRmin = tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
@@ -118,8 +111,7 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
           const float sqInvDeltaZ0 = 1.f / (math_utils::Sq(currentCluster.zCoordinate - pv.getZ()) + constants::Tolerance);
           const float sigmaZ = o2::gpu::CAMath::Sqrt(
             math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInvDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)));
-
-          auto bins = getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer));
+          const auto bins = getBinsRect(iteration, currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer));
           if (bins.x == 0 && bins.y == 0 && bins.z == 0 && bins.w == 0) {
             continue;
           }
@@ -128,20 +120,26 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
             phiBinsNum += mTrkParams[iteration].PhiBins;
           }
 
-          for (int targetROF{minROF}; targetROF <= maxROF; ++targetROF) {
-            if (!mTimeFrame->mMultiplicityCutMask[targetROF]) {
+          for (int targetROF = rofOverlap.getFirstEntry(); targetROF < rofOverlap.getEntriesBound(); ++targetROF) {
+            if (!mTimeFrame->getROFMaskView().isROFEnabled(iLayer + 1, targetROF)) {
               continue;
             }
             auto layer1 = mTimeFrame->getClustersOnLayer(targetROF, iLayer + 1);
             if (layer1.empty()) {
               continue;
             }
+            const auto ts = mTimeFrame->getROFOverlapTableView().getTimeStamp(iLayer, pivotROF, iLayer + 1, targetROF);
+            if (!ts.isCompatible(pv.getTimeStamp())) {
+              continue;
+            }
+            const auto& targetIndexTable = mTimeFrame->getIndexTable(targetROF, iLayer + 1);
+            const int zBinRange = (bins.z - bins.x) + 1;
             for (int iPhi = 0; iPhi < phiBinsNum; ++iPhi) {
               const int iPhiBin = (bins.y + iPhi) % mTrkParams[iteration].PhiBins;
-              const int firstBinIdx = mTimeFrame->mIndexTableUtils.getBinIndex(bins.x, iPhiBin);
-              const int maxBinIdx = firstBinIdx + (bins.z - bins.x) + 1;
-              const int firstRow = mTimeFrame->getIndexTable(targetROF, iLayer + 1)[firstBinIdx];
-              const int lastRow = mTimeFrame->getIndexTable(targetROF, iLayer + 1)[maxBinIdx];
+              const int firstBinIdx = mTimeFrame->getIndexTableUtils().getBinIndex(bins.x, iPhiBin);
+              const int maxBinIdx = firstBinIdx + zBinRange;
+              const int firstRow = targetIndexTable[firstBinIdx];
+              const int lastRow = targetIndexTable[maxBinIdx];
               for (int iNext = firstRow; iNext < lastRow; ++iNext) {
                 if (iNext >= int(layer1.size())) {
                   break;
@@ -150,38 +148,20 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
                 if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
                   continue;
                 }
-                float deltaPhi = o2::gpu::GPUCommonMath::Abs(currentCluster.phi - nextCluster.phi);
-                float deltaZ = o2::gpu::GPUCommonMath::Abs((tanLambda * (nextCluster.radius - currentCluster.radius)) + currentCluster.zCoordinate - nextCluster.zCoordinate);
-
-#ifdef OPTIMISATION_OUTPUT
-                MCCompLabel label;
-                int currentId{currentCluster.clusterId};
-                int nextId{nextCluster.clusterId};
-                for (auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
-                  for (auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
-                    if (lab1 == lab2 && lab1.isValid()) {
-                      label = lab1;
-                      break;
-                    }
-                  }
-                  if (label.isValid()) {
-                    break;
-                  }
-                }
-                off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, label.isValid(), (tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate) / sigmaZ, tanLambda, resolution, sigmaZ) << std::endl;
-#endif
+                const float deltaPhi = o2::gpu::CAMath::Abs(o2::math_utils::toPMPi(currentCluster.phi - nextCluster.phi));
+                const float deltaZ = o2::gpu::CAMath::Abs((tanLambda * (nextCluster.radius - currentCluster.radius)) + currentCluster.zCoordinate - nextCluster.zCoordinate);
 
                 if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
                     ((deltaPhi < mTimeFrame->getPhiCut(iLayer) || o2::gpu::GPUCommonMath::Abs(deltaPhi - o2::constants::math::TwoPI) < mTimeFrame->getPhiCut(iLayer)))) {
                   const float phi{o2::gpu::CAMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate)};
                   const float tanL = (currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius);
                   if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
-                    tracklets.emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, iLayer + 1, iNext), tanL, phi, pivotROF, targetROF);
+                    tracklets.emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, iLayer + 1, iNext), tanL, phi, ts);
                   } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
                     ++localCount;
                   } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
                     const int idx = base + offset++;
-                    tracklets[idx] = Tracklet(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, iLayer + 1, iNext), tanL, phi, pivotROF, targetROF);
+                    tracklets[idx] = Tracklet(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, iLayer + 1, iNext), tanL, phi, ts);
                   }
                 }
               }
@@ -194,47 +174,34 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
 
     int dummy{0};
     if (mTaskArena->max_concurrency() <= 1) {
-      for (int pivotROF{startROF}; pivotROF < endROF; ++pivotROF) {
-        for (int iLayer{0}; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
+      for (int iLayer{0}; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
+        const int startROF = 0, endROF = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).mNROFsTF;
+        for (int pivotROF{startROF}; pivotROF < endROF; ++pivotROF) {
           forTracklets(PassMode::OnePass{}, iLayer, pivotROF, 0, dummy);
         }
       }
     } else {
-      bounded_vector<bounded_vector<int>> perROFCount(mTrkParams[iteration].TrackletsPerRoad(), bounded_vector<int>(endROF - startROF + 1, 0, mMemoryPool.get()), mMemoryPool.get());
-      tbb::parallel_for(
-        tbb::blocked_range2d<int, int>(0, mTrkParams[iteration].TrackletsPerRoad(), 1,
-                                       startROF, endROF, 1),
-        [&](auto const& Range) {
-          for (int iLayer{Range.rows().begin()}; iLayer < Range.rows().end(); ++iLayer) {
-            for (int pivotROF = Range.cols().begin(); pivotROF < Range.cols().end(); ++pivotROF) {
-              perROFCount[iLayer][pivotROF - startROF] = forTracklets(PassMode::TwoPassCount{}, iLayer, pivotROF, 0, dummy);
-            }
-          }
-        });
-
       tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
-        std::exclusive_scan(perROFCount[iLayer].begin(), perROFCount[iLayer].end(), perROFCount[iLayer].begin(), 0);
-        mTimeFrame->getTracklets()[iLayer].resize(perROFCount[iLayer].back());
-      });
-
-      tbb::parallel_for(
-        tbb::blocked_range2d<int, int>(0, mTrkParams[iteration].TrackletsPerRoad(), 1,
-                                       startROF, endROF, 1),
-        [&](auto const& Range) {
-          for (int iLayer{Range.rows().begin()}; iLayer < Range.rows().end(); ++iLayer) {
-            if (perROFCount[iLayer].back() == 0) {
-              continue;
-            }
-            for (int pivotROF = Range.cols().begin(); pivotROF < Range.cols().end(); ++pivotROF) {
-              int baseIdx = perROFCount[iLayer][pivotROF - startROF];
-              if (baseIdx == perROFCount[iLayer][pivotROF - startROF + 1]) {
-                continue;
-              }
-              int localIdx = 0;
-              forTracklets(PassMode::TwoPassInsert{}, iLayer, pivotROF, baseIdx, localIdx);
-            }
+        const int startROF = 0, endROF = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).mNROFsTF;
+        bounded_vector<int> perROFCount((endROF - startROF) + 1, mMemoryPool.get());
+        tbb::parallel_for(startROF, endROF, [&](const int pivotROF) {
+          perROFCount[pivotROF - startROF] = forTracklets(PassMode::TwoPassCount{}, iLayer, pivotROF, 0, dummy);
+        });
+        std::exclusive_scan(perROFCount.begin(), perROFCount.end(), perROFCount.begin(), 0);
+        const int nTracklets = perROFCount.back();
+        mTimeFrame->getTracklets()[iLayer].resize(nTracklets);
+        if (nTracklets == 0) {
+          return;
+        }
+        tbb::parallel_for(startROF, endROF, [&](const int pivotROF) {
+          int baseIdx = perROFCount[pivotROF - startROF];
+          if (baseIdx == perROFCount[pivotROF + 1 - startROF]) {
+            return;
           }
+          int localIdx = 0;
+          forTracklets(PassMode::TwoPassInsert{}, iLayer, pivotROF, baseIdx, localIdx);
         });
+      });
     }
 
     tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
@@ -286,16 +253,11 @@ void TrackerTraits<nLayers>::computeLayerTracklets(const int iteration, int iROF
       });
     }
   });
-} // namespace o2::its
+}
 
-template <int nLayers>
-void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
+template <int NLayers>
+void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
 {
-#ifdef OPTIMISATION_OUTPUT
-  static int iter{0};
-  std::ofstream off(std::format("cells{}.txt", iter++));
-#endif
-
   for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
     deepVectorClear(mTimeFrame->getCells()[iLayer]);
     if (iLayer > 0) {
@@ -315,24 +277,15 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
       int foundCells{0};
       for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
         const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
-        const auto& nextLbl = mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet];
         if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
           break;
         }
-        if (mTrkParams[iteration].DeltaROF && currentTracklet.getSpanRof(nextTracklet) > mTrkParams[iteration].DeltaROF) { // TODO this has to be improved for the staggering
+        if (!currentTracklet.getTimeStamp().isCompatible(nextTracklet.getTimeStamp())) {
           continue;
         }
-        const float deltaTanLambda{std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda)};
-
-#ifdef OPTIMISATION_OUTPUT
-        float resolution{o2::gpu::CAMath::Sqrt(0.5f * (mTrkParams[iteration].SystErrorZ2[iLayer] + mTrkParams[iteration].SystErrorZ2[iLayer + 1] + mTrkParams[iteration].SystErrorZ2[iLayer + 2] + mTrkParams[iteration].SystErrorY2[iLayer] + mTrkParams[iteration].SystErrorY2[iLayer + 1] + mTrkParams[iteration].SystErrorY2[iLayer + 2])) / mTrkParams[iteration].LayerResolution[iLayer]};
-        resolution = resolution > 1.e-12 ? resolution : 1.f;
-        bool good{mTimeFrame->getTrackletsLabel(iLayer)[iTracklet] == mTimeFrame->getTrackletsLabel(iLayer + 1)[iNextTracklet]};
-        float signedDelta{currentTracklet.tanLambda - nextTracklet.tanLambda};
-        off << std::format("{}\t{:d}\t{}\t{}\t{}\t{}", iLayer, good, signedDelta, signedDelta / (mTrkParams[iteration].CellDeltaTanLambdaSigma), tanLambda, resolution) << std::endl;
-#endif
 
-        if (deltaTanLambda / mTrkParams[iteration].CellDeltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
+        const float deltaTanLambdaSigma = std::abs(currentTracklet.tanLambda - nextTracklet.tanLambda) / mTrkParams[iteration].CellDeltaTanLambdaSigma;
+        if (deltaTanLambdaSigma < mTrkParams[iteration].NSigmaCut) {
 
           /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
           const int clusId[3]{
@@ -374,13 +327,16 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
             chi2 += predChi2;
           }
           if (good) {
+            TimeEstBC ts = currentTracklet.getTimeStamp();
+            ts += nextTracklet.getTimeStamp();
             if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
-              layerCells.emplace_back(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
+              //
+              layerCells.emplace_back(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
               ++foundCells;
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
               ++foundCells;
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
-              layerCells[offset++] = CellSeedN(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2);
+              layerCells[offset++] = CellSeedN(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
             } else {
               static_assert(false, "Unknown mode!");
             }
@@ -446,13 +402,9 @@ void TrackerTraits<nLayers>::computeLayerCells(const int iteration)
   });
 }
 
-template <int nLayers>
-void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
+template <int NLayers>
+void TrackerTraits<NLayers>::findCellsNeighbours(const int iteration)
 {
-#ifdef OPTIMISATION_OUTPUT
-  std::ofstream off(std::format("cellneighs{}.txt", iteration));
-#endif
-
   struct Neighbor {
     int cell{-1}, nextCell{-1}, level{-1};
   };
@@ -477,33 +429,17 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
         int foundNextCells{0};
         for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
           auto nextCellSeed{mTimeFrame->getCells()[iLayer + 1][iNextCell]}; /// copy
-          if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex) {
+          if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex || !currentCellSeed.getTimeStamp().isCompatible(nextCellSeed.getTimeStamp())) {
             break;
           }
 
-          if (mTrkParams[iteration].DeltaROF) { // TODO this has to be improved for the staggering
-            const auto& trkl00 = mTimeFrame->getTracklets()[iLayer][currentCellSeed.getFirstTrackletIndex()];
-            const auto& trkl01 = mTimeFrame->getTracklets()[iLayer + 1][currentCellSeed.getSecondTrackletIndex()];
-            const auto& trkl10 = mTimeFrame->getTracklets()[iLayer + 1][nextCellSeed.getFirstTrackletIndex()];
-            const auto& trkl11 = mTimeFrame->getTracklets()[iLayer + 2][nextCellSeed.getSecondTrackletIndex()];
-            if ((std::max({trkl00.getMaxRof(), trkl01.getMaxRof(), trkl10.getMaxRof(), trkl11.getMaxRof()}) -
-                 std::min({trkl00.getMinRof(), trkl01.getMinRof(), trkl10.getMinRof(), trkl11.getMinRof()})) > mTrkParams[0].DeltaROF) {
-              continue;
-            }
-          }
-
           if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
               !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
             continue;
           }
-          float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
 
-#ifdef OPTIMISATION_OUTPUT
-          bool good{mTimeFrame->getCellsLabel(iLayer)[iCell] == mTimeFrame->getCellsLabel(iLayer + 1)[iNextCell]};
-          off << std::format("{}\t{:d}\t{}", iLayer, good, chi2) << std::endl;
-#endif
-
-          if (chi2 > mTrkParams[0].MaxChi2ClusterAttachment) {
+          float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
+          if (chi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
             continue;
           }
 
@@ -577,16 +513,11 @@ void TrackerTraits<nLayers>::findCellsNeighbours(const int iteration)
   });
 }
 
-template <int nLayers>
-void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
+template <int NLayers>
+void TrackerTraits<NLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
 {
-  CA_DEBUGGER(std::cout << "Processing neighbours layer " << iLayer << " level " << iLevel << ", size of the cell seeds: " << currentCellSeed.size() << std::endl);
   auto propagator = o2::base::Propagator::Instance();
 
-#ifdef CA_DEBUG
-  int failed[5]{0, 0, 0, 0, 0}, attempts{0}, failedByMismatch{0};
-#endif
-
   mTaskArena->execute([&] {
     auto forCellNeighbours = [&](auto Tag, int iCell, int offset = 0) -> int {
       const auto& currentCell{currentCellSeed[iCell]};
@@ -607,32 +538,32 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
       const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId]};
       int foundSeeds{0};
       for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
-        CA_DEBUGGER(attempts++);
         const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
         const auto& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
         if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
-          CA_DEBUGGER(failedByMismatch++);
           continue;
         }
-        if (mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex())) {
+        if (!currentCell.getTimeStamp().isCompatible(neighbourCell.getTimeStamp())) {
           continue;
         }
         if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
-          CA_DEBUGGER(failed[0]++);
+          continue;
+        }
+        if (mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex())) {
           continue;
         }
 
         /// Let's start the fitting procedure
         CellSeedN seed{currentCell};
+        seed.getTimeStamp() = currentCell.getTimeStamp();
+        seed.getTimeStamp() += neighbourCell.getTimeStamp();
         const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
 
         if (!seed.rotate(trHit.alphaTrackingFrame)) {
-          CA_DEBUGGER(failed[1]++);
           continue;
         }
 
         if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
-          CA_DEBUGGER(failed[2]++);
           continue;
         }
 
@@ -644,12 +575,10 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
 
         auto predChi2{seed.getPredictedChi2Quiet(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)};
         if ((predChi2 > mTrkParams[0].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
-          CA_DEBUGGER(failed[3]++);
           continue;
         }
         seed.setChi2(seed.getChi2() + predChi2);
         if (!seed.o2::track::TrackParCov::update(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)) {
-          CA_DEBUGGER(failed[4]++);
           continue;
         }
 
@@ -703,20 +632,10 @@ void TrackerTraits<nLayers>::processNeighbours(int iLayer, int iLevel, const bou
       });
     }
   });
-
-#ifdef CA_DEBUG
-  std::cout << "\t\t- Found " << updatedCellSeeds.size() << " cell seeds out of " << attempts << " attempts" << std::endl;
-  std::cout << "\t\t\t> " << failed[0] << " failed because of level" << std::endl;
-  std::cout << "\t\t\t> " << failed[1] << " failed because of rotation" << std::endl;
-  std::cout << "\t\t\t> " << failed[2] << " failed because of propagation" << std::endl;
-  std::cout << "\t\t\t> " << failed[3] << " failed because of chi2 cut" << std::endl;
-  std::cout << "\t\t\t> " << failed[4] << " failed because of update" << std::endl;
-  std::cout << "\t\t\t> " << failedByMismatch << " failed because of mismatch" << std::endl;
-#endif
 }
 
-template <int nLayers>
-void TrackerTraits<nLayers>::findRoads(const int iteration)
+template <int NLayers>
+void TrackerTraits<NLayers>::findRoads(const int iteration)
 {
   bounded_vector<bounded_vector<int>> firstClusters(mTrkParams[iteration].NLayers, bounded_vector<int>(mMemoryPool.get()), mMemoryPool.get());
   bounded_vector<bounded_vector<int>> sharedFirstClusters(mTrkParams[iteration].NLayers, bounded_vector<int>(mMemoryPool.get()), mMemoryPool.get());
@@ -860,31 +779,29 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
         continue;
       }
 
-      std::array<int, 3> rofs{INT_MAX, INT_MAX, INT_MAX};
+      bool firstCls{true};
+      TimeEstBC ts;
       for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
         if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
           continue;
         }
         mTimeFrame->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
         int currentROF = mTimeFrame->getClusterROF(iLayer, track.getClusterIndex(iLayer));
-        for (int iR{0}; iR < 3; ++iR) {
-          if (rofs[iR] == INT_MAX) {
-            rofs[iR] = currentROF;
-          }
-          if (rofs[iR] == currentROF) {
-            break;
+        auto rofTS = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).getROFTimeBounds(currentROF, true);
+        if (firstCls) {
+          firstCls = false;
+          ts = rofTS;
+        } else {
+          if (!ts.isCompatible(rofTS)) {
+            LOGP(fatal, "TS {}+/-{} are incompatible with {}+/-{}, this should not happen!", rofTS.getTimeStamp(), rofTS.getTimeStampError(), ts.getTimeStamp(), ts.getTimeStampError());
           }
+          ts += rofTS;
         }
       }
-      if (rofs[2] != INT_MAX) {
-        continue;
-      }
+      track.getTimeStamp() = ts.makeSymmetrical();
       track.setUserField(0);
       track.getParamOut().setUserField(0);
-      if (rofs[1] != INT_MAX) {
-        track.setNextROFbit();
-      }
-      mTimeFrame->getTracks(o2::gpu::CAMath::Min(rofs[0], rofs[1])).emplace_back(track);
+      mTimeFrame->getTracks().emplace_back(track);
 
       firstClusters[firstLayer].push_back(firstCluster);
       if (isFirstShared) {
@@ -898,164 +815,24 @@ void TrackerTraits<nLayers>::findRoads(const int iteration)
     std::sort(sharedFirstClusters[iLayer].begin(), sharedFirstClusters[iLayer].end());
   }
 
-  for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
-    for (auto& track : mTimeFrame->getTracks(iROF)) {
-      int firstLayer{mTrkParams[0].NLayers}, firstCluster{constants::UnusedIndex};
-      for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
-          continue;
-        }
-        firstLayer = iLayer;
-        firstCluster = track.getClusterIndex(iLayer);
-        break;
-      }
-      if (std::binary_search(sharedFirstClusters[firstLayer].begin(), sharedFirstClusters[firstLayer].end(), firstCluster)) {
-        track.setSharedClusters();
-      }
-    }
-  }
-}
-
-template <int nLayers>
-void TrackerTraits<nLayers>::extendTracks(const int iteration)
-{
-  for (int rof{0}; rof < mTimeFrame->getNrof(); ++rof) {
-    for (auto& track : mTimeFrame->getTracks(rof)) {
-      auto backup{track};
-      bool success{false};
-      // the order here biases towards top extension, tracks should probably be fitted separately in the directions and then compared.
-      if ((mTrkParams[iteration].UseTrackFollowerMix || mTrkParams[iteration].UseTrackFollowerTop) && track.getLastClusterLayer() != mTrkParams[iteration].NLayers - 1) {
-        success = success || trackFollowing(&track, rof, true, iteration);
-      }
-      if ((mTrkParams[iteration].UseTrackFollowerMix || (mTrkParams[iteration].UseTrackFollowerBot && !success)) && track.getFirstClusterLayer() != 0) {
-        success = success || trackFollowing(&track, rof, false, iteration);
-      }
-      if (success) {
-        /// We have to refit the track
-        track.resetCovariance();
-        track.setChi2(0);
-        bool fitSuccess = fitTrack(track, 0, mTrkParams[iteration].NLayers, 1, mTrkParams[iteration].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
-        if (!fitSuccess) {
-          track = backup;
-          continue;
-        }
-        track.getParamOut() = track;
-        track.resetCovariance();
-        track.setChi2(0);
-        fitSuccess = fitTrack(track, mTrkParams[iteration].NLayers - 1, -1, -1, mTrkParams[iteration].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.);
-        if (!fitSuccess) {
-          track = backup;
-          continue;
-        }
-        mTimeFrame->mNExtendedTracks++;
-        mTimeFrame->mNExtendedUsedClusters += track.getNClusters() - backup.getNClusters();
-        auto pattern = track.getPattern();
-        auto diff = (pattern & ~backup.getPattern()) & 0xff;
-        pattern |= (diff << 24);
-        track.setPattern(pattern);
-        /// Make sure that the newly attached clusters get marked as used
-        for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
-          if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
-            continue;
-          }
-          mTimeFrame->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
-        }
-      }
-    }
-  }
-}
-
-template <int nLayers>
-void TrackerTraits<nLayers>::findShortPrimaries()
-{
-  const auto propagator = o2::base::Propagator::Instance();
-  mTimeFrame->fillPrimaryVerticesXandAlpha();
-
-  for (auto& cell : mTimeFrame->getCells()[0]) {
-    auto& cluster3_glo = mTimeFrame->getClusters()[2][cell.getThirdClusterIndex()];
-    auto& cluster2_glo = mTimeFrame->getClusters()[1][cell.getSecondClusterIndex()];
-    auto& cluster1_glo = mTimeFrame->getClusters()[0][cell.getFirstClusterIndex()];
-    if (mTimeFrame->isClusterUsed(2, cluster1_glo.clusterId) ||
-        mTimeFrame->isClusterUsed(1, cluster2_glo.clusterId) ||
-        mTimeFrame->isClusterUsed(0, cluster3_glo.clusterId)) {
-      continue;
-    }
-
-    std::array<int, 3> rofs{
-      mTimeFrame->getClusterROF(2, cluster3_glo.clusterId),
-      mTimeFrame->getClusterROF(1, cluster2_glo.clusterId),
-      mTimeFrame->getClusterROF(0, cluster1_glo.clusterId)};
-    if (rofs[0] != rofs[1] && rofs[1] != rofs[2] && rofs[0] != rofs[2]) {
-      continue;
-    }
-
-    int rof{rofs[0]};
-    if (rofs[1] == rofs[2]) {
-      rof = rofs[2];
-    }
-
-    auto pvs{mTimeFrame->getPrimaryVertices(rof)};
-    auto pvsXAlpha{mTimeFrame->getPrimaryVerticesXAlpha(rof)};
-
-    const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(2)[cluster3_glo.clusterId];
-    TrackITSExt temporaryTrack{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
-    temporaryTrack.setExternalClusterIndex(0, cluster1_glo.clusterId, true);
-    temporaryTrack.setExternalClusterIndex(1, cluster2_glo.clusterId, true);
-    temporaryTrack.setExternalClusterIndex(2, cluster3_glo.clusterId, true);
-
-    /// add propagation to the primary vertices compatible with the ROF(s) of the cell
-    bool fitSuccess = fitTrack(temporaryTrack, 1, -1, -1);
-    if (!fitSuccess) {
-      continue;
-    }
-    fitSuccess = false;
-
-    TrackITSExt bestTrack{temporaryTrack}, backup{temporaryTrack};
-    float bestChi2{std::numeric_limits<float>::max()};
-    for (int iV{0}; iV < (int)pvs.size(); ++iV) {
-      temporaryTrack = backup;
-      if (!temporaryTrack.rotate(pvsXAlpha[iV][1])) {
-        continue;
-      }
-      if (!propagator->propagateTo(temporaryTrack, pvsXAlpha[iV][0], true)) {
+  for (auto& track : mTimeFrame->getTracks()) {
+    int firstLayer{mTrkParams[0].NLayers}, firstCluster{constants::UnusedIndex};
+    for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
+      if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
         continue;
       }
-
-      float pvRes{mTrkParams[0].PVres / o2::gpu::CAMath::Sqrt(float(pvs[iV].getNContributors()))};
-      const float posVtx[2]{0.f, pvs[iV].getZ()};
-      const float covVtx[3]{pvRes, 0.f, pvRes};
-      float chi2 = temporaryTrack.getPredictedChi2Quiet(posVtx, covVtx);
-      if (chi2 < bestChi2) {
-        if (!temporaryTrack.track::TrackParCov::update(posVtx, covVtx)) {
-          continue;
-        }
-        bestTrack = temporaryTrack;
-        bestChi2 = chi2;
-      }
+      firstLayer = iLayer;
+      firstCluster = track.getClusterIndex(iLayer);
+      break;
     }
-
-    bestTrack.resetCovariance();
-    bestTrack.setChi2(0.f);
-    fitSuccess = fitTrack(bestTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF);
-    if (!fitSuccess) {
-      continue;
-    }
-    bestTrack.getParamOut() = bestTrack;
-    bestTrack.resetCovariance();
-    bestTrack.setChi2(0.f);
-    fitSuccess = fitTrack(bestTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.);
-    if (!fitSuccess) {
-      continue;
+    if (std::binary_search(sharedFirstClusters[firstLayer].begin(), sharedFirstClusters[firstLayer].end(), firstCluster)) {
+      track.setSharedClusters();
     }
-    mTimeFrame->markUsedCluster(0, bestTrack.getClusterIndex(0));
-    mTimeFrame->markUsedCluster(1, bestTrack.getClusterIndex(1));
-    mTimeFrame->markUsedCluster(2, bestTrack.getClusterIndex(2));
-    mTimeFrame->getTracks(rof).emplace_back(bestTrack);
   }
 }
 
-template <int nLayers>
-bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut, float chi2ndfcut, float maxQoverPt, int nCl, o2::track::TrackPar* linRef)
+template <int NLayers>
+bool TrackerTraits<NLayers>::fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut, float chi2ndfcut, float maxQoverPt, int nCl, o2::track::TrackPar* linRef)
 {
   auto propInstance = o2::base::Propagator::Instance();
 
@@ -1106,125 +883,13 @@ bool TrackerTraits<nLayers>::fitTrack(TrackITSExt& track, int start, int end, in
   return std::abs(track.getQ2Pt()) < maxQoverPt && track.getChi2() < chi2ndfcut * (nCl * 2 - 5);
 }
 
-template <int nLayers>
-bool TrackerTraits<nLayers>::trackFollowing(TrackITSExt* track, int rof, bool outward, const int iteration)
-{
-  auto propInstance = o2::base::Propagator::Instance();
-  const int step = -1 + outward * 2;
-  const int end = outward ? mTrkParams[iteration].NLayers - 1 : 0;
-  bounded_vector<TrackITSExt> hypotheses(1, *track, mMemoryPool.get()); // possibly avoid reallocation
-  for (size_t iHypo{0}; iHypo < hypotheses.size(); ++iHypo) {
-    auto hypo{hypotheses[iHypo]};
-    int iLayer = static_cast<int>(outward ? hypo.getLastClusterLayer() : hypo.getFirstClusterLayer());
-    // per layer we add new hypotheses
-    while (iLayer != end) {
-      iLayer += step; // step through all layers until we reach the end, this allows for skipping on empty layers
-      const float r = mTrkParams[iteration].LayerRadii[iLayer];
-      // get an estimate of the trackinf-frame x for the next step
-      float x{-999};
-      if (!hypo.getXatLabR(r, x, mTimeFrame->getBz(), o2::track::DirAuto) || x <= 0.f) {
-        continue;
-      }
-      // estimate hypo's trk parameters at that x
-      auto& hypoParam{outward ? hypo.getParamOut() : hypo.getParamIn()};
-      if (!propInstance->propagateToX(hypoParam, x, mTimeFrame->getBz(), PropagatorF::MAX_SIN_PHI,
-                                      PropagatorF::MAX_STEP, mTrkParams[iteration].CorrType)) {
-        continue;
-      }
-
-      if (mTrkParams[iteration].CorrType == PropagatorF::MatCorrType::USEMatCorrNONE) { // account for material affects if propagator does not
-        if (!hypoParam.correctForMaterial(mTrkParams[iteration].LayerxX0[iLayer], mTrkParams[iteration].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
-          continue;
-        }
-      }
-
-      // calculate the search window on this layer
-      const float phi{hypoParam.getPhi()};
-      const float ePhi{o2::gpu::CAMath::Sqrt(hypoParam.getSigmaSnp2() / hypoParam.getCsp2())};
-      const float z{hypoParam.getZ()};
-      const float eZ{o2::gpu::CAMath::Sqrt(hypoParam.getSigmaZ2())};
-      const int4 selectedBinsRect{getBinsRect(iLayer, phi, mTrkParams[iteration].TrackFollowerNSigmaCutPhi * ePhi, z, mTrkParams[iteration].TrackFollowerNSigmaCutZ * eZ)};
-      if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
-        continue;
-      }
-
-      int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
-
-      if (phiBinsNum < 0) {
-        phiBinsNum += mTrkParams[iteration].PhiBins;
-      }
-
-      gsl::span<const Cluster> layer1 = mTimeFrame->getClustersOnLayer(rof, iLayer);
-      if (layer1.empty()) {
-        continue;
-      }
-
-      // check all clusters in search windows for possible new hypotheses
-      for (int iPhiCount = 0; iPhiCount < phiBinsNum; iPhiCount++) {
-        int iPhiBin = (selectedBinsRect.y + iPhiCount) % mTrkParams[iteration].PhiBins;
-        const int firstBinIndex{mTimeFrame->mIndexTableUtils.getBinIndex(selectedBinsRect.x, iPhiBin)};
-        const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
-        const int firstRowClusterIndex = mTimeFrame->getIndexTable(rof, iLayer)[firstBinIndex];
-        const int maxRowClusterIndex = mTimeFrame->getIndexTable(rof, iLayer)[maxBinIndex];
-
-        for (int iNextCluster{firstRowClusterIndex}; iNextCluster < maxRowClusterIndex; ++iNextCluster) {
-          if (iNextCluster >= (int)layer1.size()) {
-            break;
-          }
-          const Cluster& nextCluster{layer1[iNextCluster]};
-
-          if (mTimeFrame->isClusterUsed(iLayer, nextCluster.clusterId)) {
-            continue;
-          }
-
-          const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer)[nextCluster.clusterId];
-
-          auto tbupdated{hypo};
-          auto& tbuParams = outward ? tbupdated.getParamOut() : tbupdated.getParamIn();
-          if (!tbuParams.rotate(trackingHit.alphaTrackingFrame)) {
-            continue;
-          }
-
-          if (!propInstance->propagateToX(tbuParams, trackingHit.xTrackingFrame, mTimeFrame->getBz(),
-                                          PropagatorF::MAX_SIN_PHI, PropagatorF::MAX_STEP, PropagatorF::MatCorrType::USEMatCorrNONE)) {
-            continue;
-          }
-
-          auto predChi2{tbuParams.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
-          if (predChi2 >= track->getChi2() * mTrkParams[iteration].NSigmaCut) {
-            continue;
-          }
-
-          if (!tbuParams.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
-            continue;
-          }
-          tbupdated.setChi2(tbupdated.getChi2() + predChi2); /// This is wrong for outward propagation as the chi2 refers to inward parameters
-          tbupdated.setExternalClusterIndex(iLayer, nextCluster.clusterId, true);
-          hypotheses.emplace_back(tbupdated);
-        }
-      }
-    }
-  }
-
-  TrackITSExt* bestHypo{track};
-  bool swapped{false};
-  for (auto& hypo : hypotheses) {
-    if (hypo.isBetter(*bestHypo, track->getChi2() * mTrkParams[iteration].NSigmaCut)) {
-      bestHypo = &hypo;
-      swapped = true;
-    }
-  }
-  *track = *bestHypo;
-  return swapped;
-}
-
 // create a new seed either from the existing track inner param or reseed from the edgepointd and cluster in the middle
-template <int nLayers>
-TrackITSExt TrackerTraits<nLayers>::seedTrackForRefit(const CellSeedN& seed)
+template <int NLayers>
+TrackITSExt TrackerTraits<NLayers>::seedTrackForRefit(const CellSeedN& seed)
 {
   TrackITSExt temporaryTrack(seed);
-  int lrMin = nLayers, lrMax = 0, lrMid = 0;
-  for (int iL = 0; iL < nLayers; ++iL) {
+  int lrMin = NLayers, lrMax = 0, lrMid = 0;
+  for (int iL = 0; iL < NLayers; ++iL) {
     const int idx = seed.getCluster(iL);
     temporaryTrack.setExternalClusterIndex(iL, idx, idx != constants::UnusedIndex);
     if (idx != constants::UnusedIndex) {
@@ -1261,8 +926,8 @@ TrackITSExt TrackerTraits<nLayers>::seedTrackForRefit(const CellSeedN& seed)
 
 /// Clusters are given from inside outward (cluster3 is the outermost). The outermost cluster is given in the tracking
 /// frame coordinates whereas the others are referred to the global frame.
-template <int nLayers>
-track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse)
+template <int NLayers>
+track::TrackParCov TrackerTraits<NLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse)
 {
   const float sign = reverse ? -1.f : 1.f;
 
@@ -1297,24 +962,18 @@ track::TrackParCov TrackerTraits<nLayers>::buildTrackSeed(const Cluster& cluster
   return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
 }
 
-template <int nLayers>
-void TrackerTraits<nLayers>::setBz(float bz)
+template <int NLayers>
+void TrackerTraits<NLayers>::setBz(float bz)
 {
   mBz = bz;
   mIsZeroField = std::abs(mBz) < 0.01;
   mTimeFrame->setBz(bz);
 }
 
-template <int nLayers>
-bool TrackerTraits<nLayers>::isMatLUT() const
-{
-  return o2::base::Propagator::Instance()->getMatLUT() && (mTrkParams[0].CorrType == o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrLUT);
-}
-
-template <int nLayers>
-void TrackerTraits<nLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
+template <int NLayers>
+void TrackerTraits<NLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
 {
-#if defined(OPTIMISATION_OUTPUT) || defined(CA_DEBUG)
+#if defined(OPTIMISATION_OUTPUT)
   mTaskArena = std::make_shared<tbb::task_arena>(1);
 #else
   if (arena == nullptr) {
@@ -1322,7 +981,6 @@ void TrackerTraits<nLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>
     LOGP(info, "Setting tracker with {} threads.", n);
   } else {
     mTaskArena = arena;
-    LOGP(info, "Attaching tracker to calling thread's arena");
   }
 #endif
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index d5f13cd9d25ea..a41560e2e9e9a 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -9,16 +9,18 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <algorithm>
 #include <memory>
 
 #include <oneapi/tbb/task_arena.h>
 
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSBase/GeometryTGeo.h"
 
-#include "ITSReconstruction/FastMultEstConfig.h"
-#include "ITSReconstruction/FastMultEst.h"
+#include "ITStracking/FastMultEstConfig.h"
+#include "ITStracking/FastMultEst.h"
 
+#include "ITStracking/ROFLookupTables.h"
 #include "ITStracking/TrackingConfigParam.h"
 #include "ITStracking/TrackingInterface.h"
 
@@ -28,6 +30,8 @@
 #include "CommonDataFormat/IRFrame.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "ITStracking/BoundedAllocator.h"
+#include "Framework/InputRecordWalker.h"
+#include "Framework/DataRefUtils.h"
 #include "Framework/DeviceSpec.h"
 
 using namespace o2::framework;
@@ -69,21 +73,67 @@ void ITSTrackingInterface::initialise()
   }
   mVertexer->setNThreads(vertConf.nThreads, mTaskArena);
   mTracker->setNThreads(trackConf.nThreads, mTaskArena);
+  mTimeFrame->setIsStaggered(mDoStaggering);
+
+  // prepare data filter
+  for (int iLayer = 0; iLayer < ((mDoStaggering) ? NLayers : 1); ++iLayer) {
+    mFilter.emplace_back("compClusters", "ITS", "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
+    mFilter.emplace_back("patterns", "ITS", "PATTERNS", iLayer, Lifetime::Timeframe);
+    mFilter.emplace_back("ROframe", "ITS", "CLUSTERSROF", iLayer, Lifetime::Timeframe);
+    if (mIsMC) {
+      mFilter.emplace_back("itsmclabels", "ITS", "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
+    }
+  }
 }
 
 void ITSTrackingInterface::run(framework::ProcessingContext& pc)
 {
-  auto compClusters = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compClusters");
-  gsl::span<const unsigned char> patterns = pc.inputs().get<gsl::span<unsigned char>>("patterns");
+  const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
+
+  // filter input and compose
+  std::array<gsl::span<const itsmft::CompClusterExt>, NLayers> compClusters;
+  std::array<gsl::span<const unsigned char>, NLayers> patterns;
+  std::array<gsl::span<const itsmft::ROFRecord>, NLayers> rofsinput;
+  std::array<const dataformats::MCTruthContainer<MCCompLabel>*, NLayers> labels{};
+  for (const DataRef& ref : framework::InputRecordWalker{pc.inputs(), mFilter}) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    if (framework::DataRefUtils::match(ref, {"compClusters", framework::ConcreteDataTypeMatcher{"ITS", "COMPCLUSTERS"}})) {
+      compClusters[dh->subSpecification] = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>(ref);
+    }
+    if (framework::DataRefUtils::match(ref, {"patterns", framework::ConcreteDataTypeMatcher{"ITS", "PATTERNS"}})) {
+      patterns[dh->subSpecification] = pc.inputs().get<gsl::span<unsigned char>>(ref);
+    }
+    if (framework::DataRefUtils::match(ref, {"ROframes", framework::ConcreteDataTypeMatcher{"ITS", "CLUSTERSROF"}})) {
+      rofsinput[dh->subSpecification] = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>(ref);
+    }
+    if (framework::DataRefUtils::match(ref, {"itsmclabels", framework::ConcreteDataTypeMatcher{"ITS", "CLUSTERSMCTR"}})) {
+      labels[dh->subSpecification] = pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>(ref).release();
+    }
+  }
+
+  bool hasClusters = false;
+  for (int iLayer = 0; iLayer < ((mDoStaggering) ? NLayers : 1); ++iLayer) {
+    LOGP(info, "ITSTracker{} pulled {} clusters, {} RO frames", ((mDoStaggering) ? std::format(" on layer {}", iLayer) : ""), compClusters[iLayer].size(), rofsinput[iLayer].size());
+    if (compClusters[iLayer].empty()) {
+      LOGP(warn, " -> received no processable data{}", (mDoStaggering) ? std::format(" on layer {}", iLayer) : "");
+    } else {
+      hasClusters = true;
+    }
+    if (mIsMC) {
+      LOG(info) << " -> " << labels[iLayer]->getIndexedSize() << " MC label objects";
+    }
+  }
+
+  const auto& tfInfo = pc.services().get<o2::framework::TimingInfo>();
   gsl::span<const o2::itsmft::PhysTrigger> physTriggers;
   std::vector<o2::itsmft::PhysTrigger> fromTRD;
   if (mUseTriggers == 2) { // use TRD triggers
-    o2::InteractionRecord ir{0, pc.services().get<o2::framework::TimingInfo>().firstTForbit};
+    o2::InteractionRecord ir{0, tfInfo.firstTForbit};
     auto trdTriggers = pc.inputs().get<gsl::span<o2::trd::TriggerRecord>>("phystrig");
     for (const auto& trig : trdTriggers) {
       if (trig.getBCData() >= ir && trig.getNumberOfTracklets()) {
         ir = trig.getBCData();
-        fromTRD.emplace_back(o2::itsmft::PhysTrigger{ir, 0});
+        fromTRD.emplace_back(o2::itsmft::PhysTrigger{.ir = ir, .data = 0});
       }
     }
     physTriggers = gsl::span<const o2::itsmft::PhysTrigger>(fromTRD.data(), fromTRD.size());
@@ -91,43 +141,23 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     physTriggers = pc.inputs().get<gsl::span<o2::itsmft::PhysTrigger>>("phystrig");
   }
 
-  auto rofsinput = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
-  auto& trackROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "ITSTrackROF", 0}, rofsinput.begin(), rofsinput.end());
+  const int clockLayerId{mDoStaggering ? mTimeFrame->getROFOverlapTableView().getClock() : 0};
   auto& irFrames = pc.outputs().make<std::vector<o2::dataformats::IRFrame>>(Output{"ITS", "IRFRAMES", 0});
-  const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance(); // RS: this should come from CCDB
-
-  irFrames.reserve(trackROFvec.size());
-  int nBCPerTF = alpParams.roFrameLengthInBC;
-
-  LOGP(info, "ITSTracker pulled {} clusters, {} RO frames {}", compClusters.size(), trackROFvec.size(), compClusters.empty() ? " -> received no processable data will skip" : "");
-  const dataformats::MCTruthContainer<MCCompLabel>* labels = nullptr;
-  gsl::span<itsmft::MC2ROFRecord const> mc2rofs;
-  if (mIsMC) {
-    labels = pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>("itsmclabels").release();
-    // get the array as read-only span, a snapshot is sent forward
-    pc.outputs().snapshot(Output{"ITS", "ITSTrackMC2ROF", 0}, pc.inputs().get<gsl::span<itsmft::MC2ROFRecord>>("ITSMC2ROframes"));
-    LOG(info) << labels->getIndexedSize() << " MC label objects , in " << mc2rofs.size() << " MC events";
-  }
+  irFrames.reserve(rofsinput[clockLayerId].size());
 
   auto& allClusIdx = pc.outputs().make<std::vector<int>>(Output{"ITS", "TRACKCLSID", 0});
   auto& allTracks = pc.outputs().make<std::vector<o2::its::TrackITS>>(Output{"ITS", "TRACKS", 0});
-  auto& vertROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "VERTICESROF", 0});
+  auto& allTrackROFs = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "ITSTrackROF", 0});
   auto& vertices = pc.outputs().make<std::vector<Vertex>>(Output{"ITS", "VERTICES", 0});
+  auto& vertROFvec = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(Output{"ITS", "VERTICESROF", 0}); // TODO fill this!
 
   // MC
   static pmr::vector<o2::MCCompLabel> dummyMCLabTracks, dummyMCLabVerts;
   static pmr::vector<float> dummyMCPurVerts;
   auto& allTrackLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "TRACKSMCTR", 0}) : dummyMCLabTracks;
   auto& allVerticesLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTR", 0}) : dummyMCLabVerts;
-  bool writeContLabels = mIsMC && o2::its::VertexerParamConfig::Instance().outputContLabels;
-  auto& allVerticesContLabels = writeContLabels ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTRCONT", 0}) : dummyMCLabVerts;
   auto& allVerticesPurities = mIsMC ? pc.outputs().make<std::vector<float>>(Output{"ITS", "VERTICESMCPUR", 0}) : dummyMCPurVerts;
 
-  std::uint32_t roFrame = 0;
-
-  bool continuous = o2::base::GRPGeomHelper::instance().getGRPECS()->isDetContinuousReadOut(o2::detectors::DetID::ITS);
-  LOG(info) << "ITSTracker RO: continuous=" << continuous;
-
   if (mOverrideBeamEstimation) {
     mTimeFrame->setBeamPosition(mMeanVertex->getX(),
                                 mMeanVertex->getY(),
@@ -137,52 +167,57 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   }
 
   mTracker->setBz(o2::base::Propagator::Instance()->getNominalBz());
+  mTracker->setTimeSlice(tfInfo.timeslice);
 
-  gsl::span<const unsigned char>::iterator pattIt = patterns.begin();
-  gsl::span<const itsmft::ROFRecord> trackROFspan(trackROFvec);
-  loadROF(trackROFspan, compClusters, pattIt, labels);
-  pattIt = patterns.begin();
+  for (int iLayer = 0; iLayer < ((mDoStaggering) ? NLayers : 1); ++iLayer) {
+    gsl::span<const unsigned char>::iterator pattIt = patterns[iLayer].begin();
+    loadROF(rofsinput[iLayer], compClusters[iLayer], pattIt, ((mDoStaggering) ? iLayer : -1), labels[iLayer]);
+  }
 
   auto logger = [&](const std::string& s) { LOG(info) << s; };
   auto fatalLogger = [&](const std::string& s) { LOG(fatal) << s; };
   auto errorLogger = [&](const std::string& s) { LOG(error) << s; };
 
   FastMultEst multEst; // mult estimator
-  std::vector<uint8_t> processingMask, processUPCMask;
-  int cutVertexMult{0}, cutUPCVertex{0}, cutRandomMult = int(trackROFvec.size()) - multEst.selectROFs(trackROFvec, compClusters, physTriggers, processingMask);
-  processUPCMask.resize(processingMask.size(), false);
-  mTimeFrame->setMultiplicityCutMask(processingMask);
+  o2::its::ROFMaskTable<NLayers> processMultiplictyMask{mTimeFrame->getROFOverlapTable()}, processUPCMask{mTimeFrame->getROFOverlapTable()};
+  multEst.selectROFs(rofsinput, compClusters, physTriggers, tfInfo.firstTForbit, mDoStaggering, mTimeFrame->getROFOverlapTableView(), processMultiplictyMask);
+  mTimeFrame->setMultiplicityCutMask(processMultiplictyMask);
+  for (int iLayer = 0; iLayer < ((mDoStaggering) ? NLayers : 1); ++iLayer) {
+    mTimeFrame->getROFMaskView().print(iLayer);
+  }
+
   float vertexerElapsedTime{0.f};
   if (mRunVertexer) {
-    vertROFvec.reserve(trackROFvec.size());
     // Run seeding vertexer
-    if (!compClusters.empty()) {
-      vertexerElapsedTime = mVertexer->clustersToVertices(logger);
+    vertexerElapsedTime = mVertexer->clustersToVertices(logger);
+    // FIXME: this is a temporary stop-gap measure until we figure the rest out
+    const auto& vtx = mTimeFrame->getPrimaryVertices();
+    vertices.insert(vertices.begin(), vtx.begin(), vtx.end());
+    if (mIsMC) {
+      allVerticesLabels.reserve(vertices.size());
+      allVerticesPurities.reserve(vertices.size());
+      for (const auto& lbl : mTimeFrame->getPrimaryVerticesLabels()) {
+        allVerticesLabels.push_back(lbl.first);
+        allVerticesPurities.push_back(lbl.second);
+      }
     }
-  } else { // cosmics
-    mTimeFrame->resetRofPV();
   }
-  const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
-  gsl::span<const std::pair<MCCompLabel, float>> vMCRecInfo;
-  gsl::span<const MCCompLabel> vMCContLabels;
-  for (auto iRof{0}; iRof < trackROFspan.size(); ++iRof) {
+  multEst.selectROFsWithVertices(vertices, mTimeFrame->getROFOverlapTableView(), processMultiplictyMask);
+
+  auto clockROFspan = rofsinput[clockLayerId];
+  auto clockTiming = mTimeFrame->getROFOverlapTableView().getClockLayer();
+  for (auto iRof{0}; iRof < clockROFspan.size(); ++iRof) {
     bounded_vector<Vertex> vtxVecLoc;
-    auto& vtxROF = vertROFvec.emplace_back(trackROFspan[iRof]);
-    vtxROF.setFirstEntry(vertices.size());
+    auto& vtxROF = vertROFvec.emplace_back(clockROFspan[iRof]);
+    vtxROF.setFirstEntry((int)vertices.size());
+
     if (mRunVertexer) {
-      auto vtxSpan = mTimeFrame->getPrimaryVertices(iRof);
-      if (mIsMC) {
-        vMCRecInfo = mTimeFrame->getPrimaryVerticesMCRecInfo(iRof);
-        if (o2::its::VertexerParamConfig::Instance().outputContLabels) {
-          vMCContLabels = mTimeFrame->getPrimaryVerticesContributors(iRof);
-        }
-      }
+      auto vtxSpan = mTimeFrame->getPrimaryVertices(clockLayerId, iRof);
       if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
         if (!vtxSpan.empty()) {
           if (vtxSpan[0].isFlagSet(Vertex::UPCMode) == 1) { // at least one vertex in this ROF and it is from second vertex iteration
             LOGP(debug, "ROF {} rejected as vertices are from the UPC iteration", iRof);
-            processUPCMask[iRof] = true;
-            cutUPCVertex++;
+            processUPCMask.selectROF({clockTiming.getROFStartInBC(iRof), clockTiming.getROFEndInBC(iRof)});
             vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
           } else { // in all cases except if as standard mode vertex was found, the ROF was processed with UPC settings
             vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
@@ -193,125 +228,129 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       } else {
         vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
       }
-      vtxROF.setNEntries(vtxSpan.size());
-      bool selROF = vtxSpan.empty();
-      for (int iV{0}, iVC{0}; iV < vtxSpan.size(); ++iV) {
-        const auto& v = vtxSpan[iV];
-        if (multEstConf.isVtxMultCutRequested() && !multEstConf.isPassingVtxMultCut(v.getNContributors())) {
-          iVC += v.getNContributors();
-          continue; // skip vertex of unwanted multiplicity
-        }
-        selROF = true;
-        vertices.push_back(v);
-        if (mIsMC && !VertexerParamConfig::Instance().useTruthSeeding) {
-          allVerticesLabels.push_back(vMCRecInfo[iV].first);
-          allVerticesPurities.push_back(vMCRecInfo[iV].second);
-          if (o2::its::VertexerParamConfig::Instance().outputContLabels) {
-            allVerticesContLabels.insert(allVerticesContLabels.end(), vMCContLabels.begin() + iVC, vMCContLabels.begin() + iVC + v.getNContributors());
-          }
-        }
-        iVC += v.getNContributors();
-      }
-      if (processingMask[iRof] && !selROF) { // passed selection in clusters and not in vertex multiplicity
-        LOGP(info, "ROF {} rejected by the vertex multiplicity selection [{},{}]", iRof, multEstConf.cutMultVtxLow, multEstConf.cutMultVtxHigh);
-        processingMask[iRof] = selROF;
-        cutVertexMult++;
-      }
-    } else { // cosmics
-      vtxVecLoc.emplace_back();
-      vtxVecLoc.back().setNContributors(1);
-      vtxROF.setNEntries(vtxVecLoc.size());
-      for (auto& v : vtxVecLoc) {
-        vertices.push_back(v);
-      }
-      mTimeFrame->addPrimaryVertices(vtxVecLoc, 0);
+      vtxROF.setNEntries((int)vtxSpan.size());
     }
   }
-  if (mRunVertexer && !compClusters.empty()) {
-    LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms for {} ({} + {}) vertices found in {}/{} ROFs",
+
+  if (mRunVertexer && hasClusters) {
+    LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms for {} vertices found",
                              vertexerElapsedTime,
-                             mTimeFrame->getPrimaryVerticesNum(),
-                             mTimeFrame->getTotVertIteration()[0],
-                             o2::its::VertexerParamConfig::Instance().nIterations > 1 ? mTimeFrame->getTotVertIteration()[1] : 0,
-                             trackROFspan.size() - mTimeFrame->getNoVertexROF(),
-                             trackROFspan.size());
-    LOG(info) << fmt::format(" - FastMultEst: rejected {}/{} ROFs: random/mult.sel:{} (seed {}), vtx.sel:{}", cutRandomMult + cutVertexMult, trackROFspan.size(), cutRandomMult, multEst.lastRandomSeed, cutVertexMult);
+                             mTimeFrame->getPrimaryVerticesNum());
   }
+
   if (mOverrideBeamEstimation) {
     LOG(info) << fmt::format(" - Beam position set to: {}, {} from meanvertex object", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
   } else {
     LOG(info) << fmt::format(" - Beam position computed for the TF: {}, {}", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
   }
-  if (mCosmicsProcessing && compClusters.size() > 1500 * trackROFspan.size()) {
-    LOG(error) << "Cosmics processing was requested with an average detector occupancy exceeding 1.e-7, skipping TF processing.";
-  } else {
-    if (!compClusters.empty()) {
-      mTimeFrame->setMultiplicityCutMask(processingMask);
-      mTimeFrame->setROFMask(processUPCMask);
-      // Run CA tracker
-      if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
-        mTracker->clustersToTracks(logger, fatalLogger);
-      } else {
-        mTracker->clustersToTracks(logger, errorLogger);
-      }
+
+  if (hasClusters) {
+    mTimeFrame->setMultiplicityCutMask(processMultiplictyMask);
+    mTimeFrame->setUPCCutMask(processUPCMask);
+    // Run CA tracker
+    if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
+      mTracker->clustersToTracks(logger, fatalLogger);
+    } else {
+      mTracker->clustersToTracks(logger, errorLogger);
     }
-    size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
-    if (totTracks) {
-      allTracks.reserve(totTracks);
-      allClusIdx.reserve(totClusIDs);
+  }
 
-      if (mTimeFrame->hasBogusClusters()) {
-        LOG(warning) << fmt::format(" - The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
-      }
+  size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
+  if (totTracks) {
+    allTracks.reserve(totTracks);
+    allClusIdx.reserve(totClusIDs);
 
-      for (unsigned int iROF{0}; iROF < trackROFvec.size(); ++iROF) {
-        auto& tracksROF{trackROFvec[iROF]};
-        auto& vtxROF = vertROFvec[iROF];
-        auto& tracks = mTimeFrame->getTracks(iROF);
-        auto number{tracks.size()};
-        auto first{allTracks.size()};
-        int offset = -tracksROF.getFirstEntry(); // cluster entry!!!
-        tracksROF.setFirstEntry(first);
-        tracksROF.setNEntries(number);
-        tracksROF.setFlags(vtxROF.getFlags()); // copies 0xffffffff if cosmics
-        if (processingMask[iROF]) {
-          irFrames.emplace_back(tracksROF.getBCData(), tracksROF.getBCData() + nBCPerTF - 1).info = tracks.size();
+    if (mTimeFrame->hasBogusClusters()) {
+      LOG(warning) << fmt::format(" - The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
+    }
+
+    auto& tracks = mTimeFrame->getTracks();
+    allTrackLabels.reserve(mTimeFrame->getTracksLabel().size()); // should be 0 if not MC
+    std::copy(mTimeFrame->getTracksLabel().begin(), mTimeFrame->getTracksLabel().end(), std::back_inserter(allTrackLabels));
+    {
+      // create the track to clock ROF association here
+      // the clock ROF is just the fastest ROF
+      // the number of ROFs does not necessarily reflect the actual ROFs
+      // due to possible delay of other layers, however it is guaranteed to be >=0
+      // tracks are guaranteed to be sorted here by their lower edge
+      const auto& clock = mTimeFrame->getROFOverlapTableView().getClock();
+      const auto& clockLayer = mTimeFrame->getROFOverlapTableView().getClockLayer();
+      auto setBCData = [&](auto& rofs) {
+        for (size_t iROF{0}; iROF < rofs.size(); ++iROF) { // set BC data
+          auto& rof = rofs[iROF];
+          int orb = (iROF * par.getROFLengthInBC(clock) / o2::constants::lhc::LHCMaxBunches) + tfInfo.firstTForbit;
+          int bc = (iROF * par.getROFLengthInBC(clock) % o2::constants::lhc::LHCMaxBunches) + par.getROFDelayInBC(clock);
+          o2::InteractionRecord ir(bc, orb);
+          rof.setBCData(ir);
+          rof.setROFrame(iROF);
+          rof.setNEntries(0);
+          rof.setFirstEntry(-1);
         }
-        allTrackLabels.reserve(mTimeFrame->getTracksLabel(iROF).size()); // should be 0 if not MC
-        std::copy(mTimeFrame->getTracksLabel(iROF).begin(), mTimeFrame->getTracksLabel(iROF).end(), std::back_inserter(allTrackLabels));
-        // Some conversions that needs to be moved in the tracker internals
-        for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
-          auto& trc{tracks[iTrk]};
-          trc.setFirstClusterEntry(allClusIdx.size()); // before adding tracks, create final cluster indices
-          int ncl = trc.getNumberOfClusters(), nclf = 0;
-          for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
-            auto clid = trc.getClusterIndex(ic);
-            if (clid >= 0) {
-              trc.setClusterSize(ic, mTimeFrame->getClusterSize(clid));
-              allClusIdx.push_back(clid);
-              nclf++;
-            }
+      };
+      // we pick whatever is the largest possible number of rofs since there might be tracks/vertices which are beyond
+      // the clock layer
+      int highestROF{0};
+      for (const auto& trc : tracks) {
+        highestROF = std::max(highestROF, (int)clockLayer.getROF(trc.getTimeStamp()));
+      }
+      for (const auto& vtx : vertices) {
+        highestROF = std::max(highestROF, (int)clockLayer.getROF(vtx.getTimeStamp().lower()));
+      }
+      highestROF = std::max(highestROF, (int)clockLayer.mNROFsTF);
+      allTrackROFs.resize(highestROF);
+      vertROFvec.resize(highestROF);
+      setBCData(allTrackROFs);
+      setBCData(vertROFvec);
+
+      mTimeFrame->useMultiplictyMask(); // use multiplicty selection for IR frames
+
+      std::vector<int> rofEntries(highestROF + 1, 0);
+      for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
+        auto& trc{tracks[iTrk]};
+        trc.setFirstClusterEntry((int)allClusIdx.size()); // before adding tracks, create final cluster indices
+        int ncl = trc.getNumberOfClusters(), nclf = 0;
+        for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
+          auto clid = trc.getClusterIndex(ic);
+          if (clid >= 0) {
+            trc.setClusterSize(ic, mTimeFrame->getClusterSize((mDoStaggering) ? ic : 0, clid));
+            allClusIdx.push_back(clid);
+            nclf++;
           }
-          assert(ncl == nclf);
-          allTracks.emplace_back(trc);
         }
+        assert(ncl == nclf);
+        allTracks.emplace_back(trc);
+        auto rof = clockLayer.getROF(trc.getTimeStamp());
+        ++rofEntries[rof];
       }
-    } else {
-      for (auto& r : trackROFvec) { // reset data copied from the clusters
-        r.setFirstEntry(0);
-        r.setNEntries(0);
+      std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
+      for (size_t iROF{0}; iROF < allTrackROFs.size(); ++iROF) {
+        allTrackROFs[iROF].setFirstEntry(rofEntries[iROF]);
+        allTrackROFs[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
+        if (mTimeFrame->getROFMaskView().isROFEnabled(clockLayerId, (int)iROF)) {
+          auto& irFrame = irFrames.emplace_back(allTrackROFs[iROF].getBCData(), allTrackROFs[iROF].getBCData() + clockLayer.mROFLength - 1);
+          irFrame.info = allTrackROFs[iROF].getNEntries();
+        }
       }
-    }
-    LOGP(info, "ITSTracker pushed {} tracks and {} vertices", allTracks.size(), vertices.size());
-    if (mIsMC) {
-      LOGP(info, "ITSTracker pushed {} track labels", allTrackLabels.size());
-      LOGP(info, "ITSTracker pushed {} vertex labels", allVerticesLabels.size());
-      if (!allVerticesContLabels.empty()) {
-        LOGP(info, "ITSTracker pushed {} vertex contributor labels", allVerticesContLabels.size());
+      // same thing for vertices rofs
+      std::fill(rofEntries.begin(), rofEntries.end(), 0);
+      for (const auto& vtx : vertices) {
+        auto rof = clockLayer.getROF(vtx.getTimeStamp().lower());
+        ++rofEntries[rof];
+      }
+      std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
+      for (size_t iROF{0}; iROF < vertROFvec.size(); ++iROF) {
+        vertROFvec[iROF].setFirstEntry(rofEntries[iROF]);
+        vertROFvec[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
       }
-      LOGP(info, "ITSTracker pushed {} vertex purities", allVerticesPurities.size());
     }
   }
+
+  LOGP(info, "ITSTracker pushed {} tracks in {} rofs and {} vertices {}", allTracks.size(), allTrackROFs.size(), vertices.size(), ((mDoStaggering) ? "in staggered-readout mode" : "in normal mode"));
+  if (mIsMC) {
+    LOGP(info, "ITSTracker pushed {} track labels", allTrackLabels.size());
+    LOGP(info, "ITSTracker pushed {} vertex labels", allVerticesLabels.size());
+    LOGP(info, "ITSTracker pushed {} vertex purities", allVerticesPurities.size());
+  }
   mTimeFrame->wipe();
 }
 
@@ -334,19 +373,50 @@ void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContex
     initialise();
 
     if (pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) { // print settings only for the 1st pipeling
-      o2::its::VertexerParamConfig::Instance().printKeyValues();
-      o2::its::TrackerParamConfig::Instance().printKeyValues();
+      // print all used settings
+      if (o2::its::FastMultEstConfig::Instance().isRequested()) {
+        o2::its::FastMultEstConfig::Instance().printKeyValues(true, true);
+      }
       const auto& vtxParams = mVertexer->getParameters();
+      if (!vtxParams.empty()) {
+        o2::its::VertexerParamConfig::Instance().printKeyValues(true, true);
+      }
+      const auto& trParams = mTracker->getParameters();
+      if (!trParams.empty()) {
+        o2::its::TrackerParamConfig::Instance().printKeyValues(true, true);
+      }
+      // quick summary
       for (size_t it = 0; it < vtxParams.size(); it++) {
         const auto& par = vtxParams[it];
         LOGP(info, "vtxIter#{} : {}", it, par.asString());
       }
-      const auto& trParams = mTracker->getParameters();
       for (size_t it = 0; it < trParams.size(); it++) {
         const auto& par = trParams[it];
         LOGP(info, "recoIter#{} : {}", it, par.asString());
       }
     }
+
+    // prepare rof lookup table(s)
+    const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
+    const int nOrbitsPerTF = o2::base::GRPGeomHelper::getNHBFPerTF();
+    TimeFrameN::ROFOverlapTableN rofTable;
+    TimeFrameN::ROFVertexLookupTableN vtxTable;
+    const auto& trackParams = mTracker->getParameters();
+    for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
+      const unsigned int nROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / par.getROFLengthInBC(iLayer);
+      const LayerTiming timing{
+        .mNROFsTF = (nROFsPerOrbit * nOrbitsPerTF),
+        .mROFLength = (uint32_t)par.getROFLengthInBC(iLayer),
+        .mROFDelay = (uint32_t)par.getROFDelayInBC(iLayer),
+        .mROFBias = (uint32_t)par.getROFBiasInBC(iLayer),
+        .mROFAddTimeErr = (trackParams.empty() ? o2::its::TrackerParamConfig::Instance().addTimeError[iLayer] : trackParams[0].AddTimeError[iLayer])};
+      rofTable.defineLayer(iLayer, timing);
+      vtxTable.defineLayer(iLayer, timing);
+    }
+    rofTable.init();
+    mTimeFrame->setROFOverlapTable(rofTable);
+    vtxTable.init();
+    mTimeFrame->setROFVertexLookupTable(vtxTable);
   }
 }
 
@@ -408,7 +478,8 @@ void ITSTrackingInterface::setTraitsFromProvider(VertexerTraitsN* vertexerTraits
 void ITSTrackingInterface::loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                                    gsl::span<const itsmft::CompClusterExt> clusters,
                                    gsl::span<const unsigned char>::iterator& pattIt,
+                                   int layer,
                                    const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  mTimeFrame->loadROFrameData(trackROFspan, clusters, pattIt, mDict, mcLabels);
+  mTimeFrame->loadROFrameData(trackROFspan, clusters, pattIt, mDict, layer, mcLabels);
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h b/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
index 2fe70e96248f9..9efd6dde0176d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
@@ -24,6 +24,9 @@
 #pragma link C++ class o2::its::TrackingFrameInfo + ;
 #pragma link C++ class std::vector < o2::its::TrackingFrameInfo> + ;
 
+#pragma link C++ class o2::its::TrackingFrameInfo + ;
+#pragma link C++ class std::vector < o2::its::TrackingFrameInfo> + ;
+
 #pragma link C++ class o2::its::Line + ;
 #pragma link C++ class std::vector < o2::its::Line> + ;
 
@@ -39,4 +42,8 @@
 #pragma link C++ class o2::its::ITSGpuTrackingParamConfig + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::ITSGpuTrackingParamConfig> + ;
 
+#pragma link C++ class o2::its::FastMultEst + ;
+#pragma link C++ class o2::its::FastMultEstConfig + ;
+#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::FastMultEstConfig> + ;
+
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index c4b1fb427513f..222b4801a5767 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -26,8 +26,8 @@
 namespace o2::its
 {
 
-template <int nLayers>
-Vertexer<nLayers>::Vertexer(VertexerTraitsN* traits) : mTraits(traits)
+template <int NLayers>
+Vertexer<NLayers>::Vertexer(VertexerTraitsN* traits) : mTraits(traits)
 {
   if (!mTraits) {
     LOG(fatal) << "nullptr passed to ITS vertexer construction.";
@@ -35,18 +35,19 @@ Vertexer<nLayers>::Vertexer(VertexerTraitsN* traits) : mTraits(traits)
   mVertParams.resize(1);
 }
 
-template <int nLayers>
-float Vertexer<nLayers>::clustersToVertices(LogFunc logger)
+template <int NLayers>
+float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
 {
   LogFunc evalLog = [](const std::string&) {};
 
   if (mTimeFrame->hasMCinformation() && mVertParams[0].useTruthSeeding) {
-    return evaluateTask(&Vertexer::addTruthSeeds, StateNames[mCurState = TruthSeeding], 0, evalLog);
+    float t = evaluateTask(&Vertexer::addTruthSeeds, StateNames[mCurState = TruthSeeding], 0, evalLog);
+    sortVertices();
+    return t;
   }
 
   TrackingParameters trkPars;
-  TimeFrameGPUParameters tfGPUpar;
-  mTraits->updateVertexingParameters(mVertParams, tfGPUpar);
+  mTraits->updateVertexingParameters(mVertParams);
 
   auto handleException = [&](const auto& err) {
     LOGP(error, "Encountered critical error in step {}, stopping further processing of this TF: {}", StateNames[mCurState], err.what());
@@ -71,7 +72,7 @@ float Vertexer<nLayers>::clustersToVertices(LogFunc logger)
       nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
       auto timeSelectionIteration = evaluateTask(&Vertexer::validateTracklets, StateNames[mCurState = Validating], iteration, evalLog, iteration);
       auto timeVertexingIteration = evaluateTask(&Vertexer::findVertices, StateNames[mCurState = Finding], iteration, evalLog, iteration);
-      printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getTotVertIteration()[iteration], timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
+      printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getPrimaryVertices().size(), timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
       timeInit += timeInitIteration;
       timeTracklet += timeTrackletIteration;
       timeSelection += timeSelectionIteration;
@@ -85,18 +86,53 @@ float Vertexer<nLayers>::clustersToVertices(LogFunc logger)
     LOGP(fatal, "Uncaught exception!");
   }
 
+  sortVertices();
+
   return timeInit + timeTracklet + timeSelection + timeVertexing;
 }
 
-template <int nLayers>
-void Vertexer<nLayers>::adoptTimeFrame(TimeFrameN& tf)
+template <int NLayers>
+void Vertexer<NLayers>::sortVertices()
+{
+  auto& pvs = mTimeFrame->getPrimaryVertices();
+  bounded_vector<size_t> indices(pvs.size(), mMemoryPool.get());
+  std::iota(indices.begin(), indices.end(), 0);
+  // provide vertices sorted by lower-bound
+  std::sort(indices.begin(), indices.end(), [&pvs](size_t i, size_t j) {
+    const auto& a = pvs[i].getTimeStamp();
+    const auto& b = pvs[j].getTimeStamp();
+    const auto aLower = a.lower();
+    const auto bLower = b.lower();
+    if (aLower != bLower) {
+      return aLower < bLower;
+    }
+    return pvs[i].getNContributors() > pvs[j].getNContributors();
+  });
+  bounded_vector<Vertex> sortedVtx(mMemoryPool.get());
+  sortedVtx.reserve(pvs.size());
+  for (const size_t idx : indices) {
+    sortedVtx.push_back(pvs[idx]);
+  }
+  pvs.swap(sortedVtx);
+  if (mTimeFrame->hasMCinformation()) {
+    auto& mc = mTimeFrame->getPrimaryVerticesLabels();
+    bounded_vector<VertexLabel> sortedMC(mMemoryPool.get());
+    for (const size_t idx : indices) {
+      sortedMC.push_back(mc[idx]);
+    }
+    mc.swap(sortedMC);
+  }
+}
+
+template <int NLayers>
+void Vertexer<NLayers>::adoptTimeFrame(TimeFrameN& tf)
 {
   mTimeFrame = &tf;
   mTraits->adoptTimeFrame(&tf);
 }
 
-template <int nLayers>
-void Vertexer<nLayers>::printEpilog(LogFunc& logger,
+template <int NLayers>
+void Vertexer<NLayers>::printEpilog(LogFunc& logger,
                                     const unsigned int trackletN01, const unsigned int trackletN12,
                                     const unsigned selectedN, const unsigned int vertexN, const float initT,
                                     const float trackletT, const float selecT, const float vertexT)
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 6d51f7bab5d36..5e27e20b3ddee 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -10,10 +10,9 @@
 // or submit itself to any jurisdiction.
 ///
 
+#include <algorithm>
 #include <memory>
 #include <ranges>
-#include <map>
-#include <algorithm>
 
 #include <oneapi/tbb/blocked_range.h>
 #include <oneapi/tbb/parallel_for.h>
@@ -22,17 +21,18 @@
 #include "ITStracking/VertexerTraits.h"
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/ClusterLines.h"
+#include "ITStracking/Definitions.h"
 #include "ITStracking/Tracklet.h"
 #include "SimulationDataFormat/DigitizationContext.h"
+#include "SimulationDataFormat/O2DatabasePDG.h"
 #include "Steer/MCKinematicsReader.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsRaw/HBFUtils.h"
-#include "CommonUtils/TreeStreamRedirector.h"
 
 namespace o2::its
 {
 
-template <TrackletMode Mode, bool EvalRun, int nLayers>
+template <TrackletMode Mode, bool EvalRun, int NLayers>
 static void trackleterKernelHost(
   const gsl::span<const Cluster>& clustersNextLayer,    // 0 2
   const gsl::span<const Cluster>& clustersCurrentLayer, // 1 1
@@ -41,10 +41,11 @@ static void trackleterKernelHost(
   const float phiCut,
   bounded_vector<Tracklet>& tracklets,
   gsl::span<int> foundTracklets,
-  const IndexTableUtils<nLayers>& utils,
-  const short pivotRof,
-  const short targetRof,
-  gsl::span<int> rofFoundTrackletsOffsets, // we want to change those, to keep track of the offset in deltaRof>0
+  const IndexTableUtils<NLayers>& utils,
+  const TimeEstBC& timErr,
+  gsl::span<int> rofFoundTrackletsOffsets,
+  const int globalOffsetNextLayer = 0,
+  const int globalOffsetCurrentLayer = 0,
   const int maxTrackletsPerCluster = static_cast<int>(2e3))
 {
   const int PhiBins{utils.getNphiBins()};
@@ -53,7 +54,7 @@ static void trackleterKernelHost(
   for (int iCurrentLayerClusterIndex = 0; iCurrentLayerClusterIndex < clustersCurrentLayer.size(); ++iCurrentLayerClusterIndex) {
     int storedTracklets{0};
     const Cluster& currentCluster{clustersCurrentLayer[iCurrentLayerClusterIndex]};
-    const int4 selectedBinsRect{VertexerTraits<nLayers>::getBinsRect(currentCluster, (int)Mode, 0.f, 50.f, phiCut / 2, utils)};
+    const int4 selectedBinsRect{VertexerTraits<NLayers>::getBinsRect(currentCluster, (int)Mode, 0.f, 50.f, phiCut / 2, utils)};
     if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) {
       int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
       if (phiBinsNum < 0) {
@@ -74,9 +75,9 @@ static void trackleterKernelHost(
             if (storedTracklets < maxTrackletsPerCluster) {
               if constexpr (!EvalRun) {
                 if constexpr (Mode == TrackletMode::Layer0Layer1) {
-                  tracklets[rofFoundTrackletsOffsets[iCurrentLayerClusterIndex] + storedTracklets] = Tracklet{iNextLayerClusterIndex, iCurrentLayerClusterIndex, nextCluster, currentCluster, targetRof, pivotRof};
+                  tracklets[rofFoundTrackletsOffsets[iCurrentLayerClusterIndex] + storedTracklets] = Tracklet{globalOffsetNextLayer + iNextLayerClusterIndex, globalOffsetCurrentLayer + iCurrentLayerClusterIndex, nextCluster, currentCluster, timErr};
                 } else {
-                  tracklets[rofFoundTrackletsOffsets[iCurrentLayerClusterIndex] + storedTracklets] = Tracklet{iCurrentLayerClusterIndex, iNextLayerClusterIndex, currentCluster, nextCluster, pivotRof, targetRof};
+                  tracklets[rofFoundTrackletsOffsets[iCurrentLayerClusterIndex] + storedTracklets] = Tracklet{globalOffsetCurrentLayer + iCurrentLayerClusterIndex, globalOffsetNextLayer + iNextLayerClusterIndex, currentCluster, nextCluster, timErr};
                 }
               }
               ++storedTracklets;
@@ -94,10 +95,10 @@ static void trackleterKernelHost(
 }
 
 static void trackletSelectionKernelHost(
-  const gsl::span<const Cluster> clusters0, // 0
-  const gsl::span<const Cluster> clusters1, // 1
-  gsl::span<unsigned char> usedClusters0,   // Layer 0
-  gsl::span<unsigned char> usedClusters2,   // Layer 2
+  const Cluster* clusters0,               // global layer 0 clusters
+  const Cluster* clusters1,               // global layer 1 clusters
+  gsl::span<unsigned char> usedClusters0, // global layer 0 used clusters
+  gsl::span<unsigned char> usedClusters2, // global layer 2 used clusters
   const gsl::span<const Tracklet>& tracklets01,
   const gsl::span<const Tracklet>& tracklets12,
   bounded_vector<bool>& usedTracklets,
@@ -106,15 +107,13 @@ static void trackletSelectionKernelHost(
   bounded_vector<Line>& lines,
   const gsl::span<const o2::MCCompLabel>& trackletLabels,
   bounded_vector<o2::MCCompLabel>& linesLabels,
-  const short targetRofId0,
-  const short targetRofId2,
-  bool safeWrites = false,
+  const int nLayer1Clusters,
   const float tanLambdaCut = 0.025f,
   const float phiCut = 0.005f,
-  const int maxTracklets = static_cast<int>(1e2))
+  const int maxTracklets = 100)
 {
   int offset01{0}, offset12{0};
-  for (unsigned int iCurrentLayerClusterIndex{0}; iCurrentLayerClusterIndex < clusters1.size(); ++iCurrentLayerClusterIndex) {
+  for (int iCurrentLayerClusterIndex{0}; iCurrentLayerClusterIndex < nLayer1Clusters; ++iCurrentLayerClusterIndex) {
     int validTracklets{0};
     for (int iTracklet12{offset12}; iTracklet12 < offset12 + foundTracklets12[iCurrentLayerClusterIndex]; ++iTracklet12) {
       for (int iTracklet01{offset01}; iTracklet01 < offset01 + foundTracklets01[iCurrentLayerClusterIndex]; ++iTracklet01) {
@@ -124,23 +123,17 @@ static void trackletSelectionKernelHost(
 
         const auto& tracklet01{tracklets01[iTracklet01]};
         const auto& tracklet12{tracklets12[iTracklet12]};
-
-        if (tracklet01.rof[0] != targetRofId0 || tracklet12.rof[1] != targetRofId2) {
+        if (!tracklet01.getTimeStamp().isCompatible(tracklet12.getTimeStamp())) {
           continue;
         }
 
         const float deltaTanLambda{o2::gpu::GPUCommonMath::Abs(tracklet01.tanLambda - tracklet12.tanLambda)};
         const float deltaPhi{o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(tracklet01.phi, tracklet12.phi))};
         if (deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets != maxTracklets) {
-          if (safeWrites) {
-            __atomic_store_n(&usedClusters0[tracklet01.firstClusterIndex], 1, __ATOMIC_RELAXED);
-            __atomic_store_n(&usedClusters2[tracklet12.secondClusterIndex], 1, __ATOMIC_RELAXED);
-          } else {
-            usedClusters0[tracklet01.firstClusterIndex] = 1;
-            usedClusters2[tracklet12.secondClusterIndex] = 1;
-          }
+          usedClusters0[tracklet01.firstClusterIndex] = 1;
+          usedClusters2[tracklet12.secondClusterIndex] = 1;
           usedTracklets[iTracklet01] = true;
-          lines.emplace_back(tracklet01, clusters0.data(), clusters1.data());
+          lines.emplace_back(tracklet01, clusters0, clusters1);
           if (!trackletLabels.empty()) {
             linesLabels.emplace_back(trackletLabels[iTracklet01]);
           }
@@ -153,8 +146,8 @@ static void trackletSelectionKernelHost(
   }
 }
 
-template <int nLayers>
-void VertexerTraits<nLayers>::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar, const TimeFrameGPUParameters& tfPar)
+template <int NLayers>
+void VertexerTraits<NLayers>::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar)
 {
   mVrtParams = vrtPar;
   mIndexTableUtils.setTrackingParameters(vrtPar[0]);
@@ -165,15 +158,15 @@ void VertexerTraits<nLayers>::updateVertexingParameters(const std::vector<Vertex
 }
 
 // Main functions
-template <int nLayers>
-void VertexerTraits<nLayers>::computeTracklets(const int iteration)
+template <int NLayers>
+void VertexerTraits<NLayers>::computeTracklets(const int iteration)
 {
   mTaskArena->execute([&] {
-    tbb::parallel_for(0, mTimeFrame->getNrof(), [&](const short pivotRofId) {
-      bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
-      short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
-      short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-      for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
+    tbb::parallel_for(0, mTimeFrame->getNrof(1), [&](const short pivotRofId) {
+      bool skipROF = !mTimeFrame->getROFMaskView().isROFEnabled(1, pivotRofId);
+      const auto& rofRange01 = mTimeFrame->getROFOverlapTableView().getOverlap(1, 0, pivotRofId);
+      for (auto targetRofId = rofRange01.getFirstEntry(); targetRofId < rofRange01.getEntriesBound(); ++targetRofId) {
+        const auto timeErr = mTimeFrame->getROFOverlapTableView().getTimeStamp(0, targetRofId, 1, pivotRofId);
         trackleterKernelHost<TrackletMode::Layer0Layer1, true>(
           !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(), // Clusters to be matched with the next layer in target rof
           !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),  // Clusters to be matched with the current layer in pivot rof
@@ -183,10 +176,15 @@ void VertexerTraits<nLayers>::computeTracklets(const int iteration)
           mTimeFrame->getTracklets()[0],                   // Flat tracklet buffer
           mTimeFrame->getNTrackletsCluster(pivotRofId, 0), // Span of the number of tracklets per each cluster in pivot rof
           mIndexTableUtils,
-          pivotRofId,
-          targetRofId,
+          timeErr,
           gsl::span<int>(), // Offset in the tracklet buffer
+          0,
+          0,
           mVrtParams[iteration].maxTrackletsPerCluster);
+      }
+      const auto& rofRange12 = mTimeFrame->getROFOverlapTableView().getOverlap(1, 2, pivotRofId);
+      for (auto targetRofId = rofRange12.getFirstEntry(); targetRofId < rofRange12.getEntriesBound(); ++targetRofId) {
+        const auto timeErr = mTimeFrame->getROFOverlapTableView().getTimeStamp(2, targetRofId, 1, pivotRofId);
         trackleterKernelHost<TrackletMode::Layer1Layer2, true>(
           !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
           !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
@@ -196,9 +194,10 @@ void VertexerTraits<nLayers>::computeTracklets(const int iteration)
           mTimeFrame->getTracklets()[1],
           mTimeFrame->getNTrackletsCluster(pivotRofId, 1), // Span of the number of tracklets per each cluster in pivot rof
           mIndexTableUtils,
-          pivotRofId,
-          targetRofId,
+          timeErr,
           gsl::span<int>(), // Offset in the tracklet buffer
+          0,
+          0,
           mVrtParams[iteration].maxTrackletsPerCluster);
       }
       mTimeFrame->getNTrackletsROF(pivotRofId, 0) = std::accumulate(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).begin(), mTimeFrame->getNTrackletsCluster(pivotRofId, 0).end(), 0);
@@ -214,13 +213,12 @@ void VertexerTraits<nLayers>::computeTracklets(const int iteration)
       mTimeFrame->getTracklets()[1].resize(tot1);
     }
 
-    tbb::parallel_for(0, mTimeFrame->getNrof(), [&](const short pivotRofId) {
-      bool skipROF = iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold;
-      short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
-      short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-      auto mobileOffset0 = mTimeFrame->getNTrackletsROF(pivotRofId, 0);
-      auto mobileOffset1 = mTimeFrame->getNTrackletsROF(pivotRofId, 1);
-      for (auto targetRofId = startROF; targetRofId < endROF; ++targetRofId) {
+    tbb::parallel_for(0, mTimeFrame->getNrof(1), [&](const short pivotRofId) {
+      bool skipROF = !mTimeFrame->getROFMaskView().isROFEnabled(1, pivotRofId);
+      const int globalOffsetPivot = mTimeFrame->getSortedStartIndex(pivotRofId, 1);
+      const auto& rofRange01 = mTimeFrame->getROFOverlapTableView().getOverlap(1, 0, pivotRofId);
+      for (auto targetRofId = rofRange01.getFirstEntry(); targetRofId < rofRange01.getEntriesBound(); ++targetRofId) {
+        const auto timeErr = mTimeFrame->getROFOverlapTableView().getTimeStamp(0, targetRofId, 1, pivotRofId);
         trackleterKernelHost<TrackletMode::Layer0Layer1, false>(
           !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(),
           !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
@@ -230,10 +228,15 @@ void VertexerTraits<nLayers>::computeTracklets(const int iteration)
           mTimeFrame->getTracklets()[0],
           mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
           mIndexTableUtils,
-          pivotRofId,
-          targetRofId,
+          timeErr,
           mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 0),
+          mTimeFrame->getSortedStartIndex(targetRofId, 0),
+          globalOffsetPivot,
           mVrtParams[iteration].maxTrackletsPerCluster);
+      }
+      const auto& rofRange12 = mTimeFrame->getROFOverlapTableView().getOverlap(1, 2, pivotRofId);
+      for (auto targetRofId = rofRange12.getFirstEntry(); targetRofId < rofRange12.getEntriesBound(); ++targetRofId) {
+        const auto timeErr = mTimeFrame->getROFOverlapTableView().getTimeStamp(2, targetRofId, 1, pivotRofId);
         trackleterKernelHost<TrackletMode::Layer1Layer2, false>(
           !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
           !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
@@ -243,9 +246,10 @@ void VertexerTraits<nLayers>::computeTracklets(const int iteration)
           mTimeFrame->getTracklets()[1],
           mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
           mIndexTableUtils,
-          pivotRofId,
-          targetRofId,
+          timeErr,
           mTimeFrame->getExclusiveNTrackletsCluster(pivotRofId, 1),
+          mTimeFrame->getSortedStartIndex(targetRofId, 2),
+          globalOffsetPivot,
           mVrtParams[iteration].maxTrackletsPerCluster);
       }
     });
@@ -256,8 +260,8 @@ void VertexerTraits<nLayers>::computeTracklets(const int iteration)
     for (const auto& trk : mTimeFrame->getTracklets()[0]) {
       o2::MCCompLabel label;
       if (!trk.isEmpty()) {
-        int sortedId0{mTimeFrame->getSortedIndex(trk.rof[0], 0, trk.firstClusterIndex)};
-        int sortedId1{mTimeFrame->getSortedIndex(trk.rof[1], 1, trk.secondClusterIndex)};
+        int sortedId0{trk.firstClusterIndex};
+        int sortedId1{trk.secondClusterIndex};
         for (const auto& lab0 : mTimeFrame->getClusterLabels(0, mTimeFrame->getClusters()[0][sortedId0].clusterId)) {
           for (const auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
             if (lab0 == lab1 && lab0.isValid()) {
@@ -273,570 +277,260 @@ void VertexerTraits<nLayers>::computeTracklets(const int iteration)
       mTimeFrame->getTrackletsLabel(0).emplace_back(label);
     }
   }
-
-#ifdef VTX_DEBUG
-  debugComputeTracklets(iteration);
-#endif
 }
 
-template <int nLayers>
-void VertexerTraits<nLayers>::computeTrackletMatching(const int iteration)
+template <int NLayers>
+void VertexerTraits<NLayers>::computeTrackletMatching(const int iteration)
 {
   mTaskArena->execute([&] {
     tbb::combinable<int> totalLines{0};
     tbb::parallel_for(
-      tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof()),
+      tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof(1)),
       [&](const tbb::blocked_range<short>& Rofs) {
         for (short pivotRofId = Rofs.begin(); pivotRofId < Rofs.end(); ++pivotRofId) {
-          if (iteration && (int)mTimeFrame->getPrimaryVertices(pivotRofId).size() > mVrtParams[iteration].vertPerRofThreshold) {
-            continue;
-          }
           if (mTimeFrame->getFoundTracklets(pivotRofId, 0).empty()) {
             continue;
           }
           mTimeFrame->getLines(pivotRofId).reserve(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).size());
           bounded_vector<bool> usedTracklets(mTimeFrame->getFoundTracklets(pivotRofId, 0).size(), false, mMemoryPool.get());
-          short startROF{std::max((short)0, static_cast<short>(pivotRofId - mVrtParams[iteration].deltaRof))};
-          short endROF{std::min(static_cast<short>(mTimeFrame->getNrof()), static_cast<short>(pivotRofId + mVrtParams[iteration].deltaRof + 1))};
-
-          // needed only if multi-threaded using deltaRof and only at the overlap edges of the ranges
-          bool safeWrite = mTaskArena->max_concurrency() > 1 && mVrtParams[iteration].deltaRof != 0 && ((Rofs.begin() - startROF < 0) || (endROF - Rofs.end() > 0));
-
-          for (short targetRofId0 = startROF; targetRofId0 < endROF; ++targetRofId0) {
-            for (short targetRofId2 = startROF; targetRofId2 < endROF; ++targetRofId2) {
-              if (std::abs(targetRofId0 - targetRofId2) > mVrtParams[iteration].deltaRof) { // do not allow over 3 ROFs
-                continue;
-              }
-              trackletSelectionKernelHost(
-                mTimeFrame->getClustersOnLayer(targetRofId0, 0),
-                mTimeFrame->getClustersOnLayer(pivotRofId, 1),
-                mTimeFrame->getUsedClustersROF(targetRofId0, 0),
-                mTimeFrame->getUsedClustersROF(targetRofId2, 2),
-                mTimeFrame->getFoundTracklets(pivotRofId, 0),
-                mTimeFrame->getFoundTracklets(pivotRofId, 1),
-                usedTracklets,
-                mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
-                mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
-                mTimeFrame->getLines(pivotRofId),
-                mTimeFrame->getLabelsFoundTracklets(pivotRofId, 0),
-                mTimeFrame->getLinesLabel(pivotRofId),
-                targetRofId0,
-                targetRofId2,
-                safeWrite,
-                mVrtParams[iteration].tanLambdaCut,
-                mVrtParams[iteration].phiCut);
+          trackletSelectionKernelHost(
+            mTimeFrame->getClusters()[0].data(),
+            mTimeFrame->getClusters()[1].data(),
+            mTimeFrame->getUsedClusters(0),
+            mTimeFrame->getUsedClusters(2),
+            mTimeFrame->getFoundTracklets(pivotRofId, 0),
+            mTimeFrame->getFoundTracklets(pivotRofId, 1),
+            usedTracklets,
+            mTimeFrame->getNTrackletsCluster(pivotRofId, 0),
+            mTimeFrame->getNTrackletsCluster(pivotRofId, 1),
+            mTimeFrame->getLines(pivotRofId),
+            mTimeFrame->getLabelsFoundTracklets(pivotRofId, 0),
+            mTimeFrame->getLinesLabel(pivotRofId),
+            static_cast<int>(mTimeFrame->getClustersOnLayer(pivotRofId, 1).size()),
+            mVrtParams[iteration].tanLambdaCut,
+            mVrtParams[iteration].phiCut);
+          auto& lines = mTimeFrame->getLines(pivotRofId);
+          totalLines.local() += lines.size();
+          std::stable_sort(lines.begin(), lines.end(), [](const Line& a, const Line& b) {
+            // sort by lower edge and secondly prefer wider windows
+            if (a.mTime.lower() != b.mTime.lower()) {
+              return a.mTime.lower() < b.mTime.lower();
             }
-          }
-          totalLines.local() += mTimeFrame->getLines(pivotRofId).size();
+            return a.mTime.upper() > b.mTime.upper();
+          });
         }
       });
     mTimeFrame->setNLinesTotal(totalLines.combine(std::plus<int>()));
   });
 
-#ifdef VTX_DEBUG
-  debugComputeTrackletMatching(iteration);
-#endif
-
-  // from here on we do not use tracklets from L1-2 anymore, so let's free them
-  deepVectorClear(mTimeFrame->getTracklets()[1]);
+  // from here on we do not use tracklets anymore, so let's free them
+  deepVectorClear(mTimeFrame->getTracklets());
 }
 
-template <int nLayers>
-void VertexerTraits<nLayers>::computeVertices(const int iteration)
+template <int NLayers>
+void VertexerTraits<NLayers>::computeVertices(const int iteration)
 {
-  auto nsigmaCut{std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f)};
-  bounded_vector<Vertex> vertices(mMemoryPool.get());
-  bounded_vector<std::pair<o2::MCCompLabel, float>> polls(mMemoryPool.get());
-  bounded_vector<o2::MCCompLabel> contLabels(mMemoryPool.get());
-  bounded_vector<int> noClustersVec(mTimeFrame->getNrof(), 0, mMemoryPool.get());
-  for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    if (iteration && (int)mTimeFrame->getPrimaryVertices(rofId).size() > mVrtParams[iteration].vertPerRofThreshold) {
-      continue;
-    }
-    const int numTracklets{static_cast<int>(mTimeFrame->getLines(rofId).size())};
-
-    bounded_vector<bool> usedTracklets(numTracklets, false, mMemoryPool.get());
-    for (int line1{0}; line1 < numTracklets; ++line1) {
-      if (usedTracklets[line1]) {
+  const auto nsigmaCut{std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f)};
+  const auto pairCut2{mVrtParams[iteration].pairCut * mVrtParams[iteration].pairCut};
+  const int nRofs = mTimeFrame->getNrof(1);
+  const bool hasMC = mTimeFrame->hasMCinformation();
+  std::vector<std::vector<Vertex>> rofVertices(nRofs);
+  std::vector<std::vector<VertexLabel>> rofLabels(nRofs);
+
+  const auto processROF = [&](const int rofId) {
+    auto& lines = mTimeFrame->getLines(rofId);
+    const int nLines{static_cast<int>(lines.size())};
+    bounded_vector<uint8_t> usedTracklets(nLines, 0, mMemoryPool.get());
+    auto& clusters = mTimeFrame->getTrackletClusters(rofId);
+
+    for (int iLine1{0}; iLine1 < nLines; ++iLine1) {
+      if (usedTracklets[iLine1]) {
         continue;
       }
-      for (int line2{line1 + 1}; line2 < numTracklets; ++line2) {
-        if (usedTracklets[line2]) {
+      const auto& line1 = lines[iLine1];
+      for (int iLine2{iLine1 + 1}; iLine2 < nLines; ++iLine2) {
+        if (usedTracklets[iLine2]) {
+          continue;
+        }
+        const auto& line2 = lines[iLine2];
+        if (!line1.mTime.isCompatible(line2.mTime)) {
           continue;
         }
-        auto dca{Line::getDCA(mTimeFrame->getLines(rofId)[line1], mTimeFrame->getLines(rofId)[line2])};
-        if (dca < mVrtParams[iteration].pairCut) {
-          mTimeFrame->getTrackletClusters(rofId).emplace_back(line1, mTimeFrame->getLines(rofId)[line1], line2, mTimeFrame->getLines(rofId)[line2]);
-          std::array<float, 3> tmpVertex{mTimeFrame->getTrackletClusters(rofId).back().getVertex()};
-          if (tmpVertex[0] * tmpVertex[0] + tmpVertex[1] * tmpVertex[1] > 4.f) {
-            mTimeFrame->getTrackletClusters(rofId).pop_back();
+        auto dca2{Line::getDCA2(line1, line2)};
+        if (dca2 < pairCut2) {
+          auto& cluster = clusters.emplace_back(iLine1, line1, iLine2, line2);
+          if (!cluster.isValid() || cluster.getR2() > 4.f) {
+            clusters.pop_back();
             continue;
           }
-          usedTracklets[line1] = true;
-          usedTracklets[line2] = true;
-          for (int tracklet3{0}; tracklet3 < numTracklets; ++tracklet3) {
-            if (usedTracklets[tracklet3]) {
+
+          usedTracklets[iLine1] = 1;
+          usedTracklets[iLine2] = 1;
+          for (int iLine3{0}; iLine3 < nLines; ++iLine3) {
+            if (usedTracklets[iLine3]) {
               continue;
             }
-            if (Line::getDistanceFromPoint(mTimeFrame->getLines(rofId)[tracklet3], tmpVertex) < mVrtParams[iteration].pairCut) {
-              mTimeFrame->getTrackletClusters(rofId).back().add(tracklet3, mTimeFrame->getLines(rofId)[tracklet3]);
-              usedTracklets[tracklet3] = true;
-              tmpVertex = mTimeFrame->getTrackletClusters(rofId).back().getVertex();
+            const auto& line3 = lines[iLine3];
+            if (!line3.mTime.isCompatible(cluster.getTimeStamp())) {
+              continue;
+            }
+            const auto distance2 = Line::getDistance2FromPoint(line3, cluster.getVertex());
+            if (distance2 < pairCut2) {
+              cluster.add(iLine3, line3);
+              usedTracklets[iLine3] = 1;
             }
           }
           break;
         }
       }
     }
-    if (mVrtParams[iteration].allowSingleContribClusters) {
-      auto beamLine = Line{{mTimeFrame->getBeamX(), mTimeFrame->getBeamY(), -50.f}, {mTimeFrame->getBeamX(), mTimeFrame->getBeamY(), 50.f}}; // use beam position as contributor
-      for (size_t iLine{0}; iLine < numTracklets; ++iLine) {
-        if (!usedTracklets[iLine]) {
-          auto dca = Line::getDCA(mTimeFrame->getLines(rofId)[iLine], beamLine);
-          if (dca < mVrtParams[iteration].pairCut) {
-            mTimeFrame->getTrackletClusters(rofId).emplace_back(iLine, mTimeFrame->getLines(rofId)[iLine], -1, beamLine); // beamline must be passed as second line argument
-          }
-        }
-      }
-    }
 
     // Cluster merging
-    std::sort(mTimeFrame->getTrackletClusters(rofId).begin(), mTimeFrame->getTrackletClusters(rofId).end(),
+    std::sort(clusters.begin(), clusters.end(),
               [](ClusterLines& cluster1, ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); });
-    noClustersVec[rofId] = static_cast<int>(mTimeFrame->getTrackletClusters(rofId).size());
-    for (int iCluster1{0}; iCluster1 < noClustersVec[rofId]; ++iCluster1) {
-      std::array<float, 3> vertex1{mTimeFrame->getTrackletClusters(rofId)[iCluster1].getVertex()};
+    int nClusters = static_cast<int>(clusters.size());
+    for (int iCluster1{0}; iCluster1 < nClusters; ++iCluster1) {
+      std::array<float, 3> vertex1{clusters[iCluster1].getVertex()};
       std::array<float, 3> vertex2{};
-      for (int iCluster2{iCluster1 + 1}; iCluster2 < noClustersVec[rofId]; ++iCluster2) {
-        vertex2 = mTimeFrame->getTrackletClusters(rofId)[iCluster2].getVertex();
-        if (o2::gpu::GPUCommonMath::Abs(vertex1[2] - vertex2[2]) < mVrtParams[iteration].clusterCut) {
-          float distance{(vertex1[0] - vertex2[0]) * (vertex1[0] - vertex2[0]) +
-                         (vertex1[1] - vertex2[1]) * (vertex1[1] - vertex2[1]) +
-                         (vertex1[2] - vertex2[2]) * (vertex1[2] - vertex2[2])};
-          if (distance < mVrtParams[iteration].pairCut * mVrtParams[iteration].pairCut) {
-            for (auto label : mTimeFrame->getTrackletClusters(rofId)[iCluster2].getLabels()) {
-              mTimeFrame->getTrackletClusters(rofId)[iCluster1].add(label, mTimeFrame->getLines(rofId)[label]);
-              vertex1 = mTimeFrame->getTrackletClusters(rofId)[iCluster1].getVertex();
+      for (int iCluster2{iCluster1 + 1}; iCluster2 < nClusters; ++iCluster2) {
+        if (clusters[iCluster1].getTimeStamp().isCompatible(clusters[iCluster2].getTimeStamp())) {
+          vertex2 = clusters[iCluster2].getVertex();
+          if (o2::gpu::GPUCommonMath::Abs(vertex1[2] - vertex2[2]) < mVrtParams[iteration].clusterCut) {
+            float distance{((vertex1[0] - vertex2[0]) * (vertex1[0] - vertex2[0])) +
+                           ((vertex1[1] - vertex2[1]) * (vertex1[1] - vertex2[1])) +
+                           ((vertex1[2] - vertex2[2]) * (vertex1[2] - vertex2[2]))};
+            if (distance < mVrtParams[iteration].pairCut * mVrtParams[iteration].pairCut) {
+              for (auto label : clusters[iCluster2].getLabels()) {
+                clusters[iCluster1].add(label, lines[label]);
+                vertex1 = clusters[iCluster1].getVertex();
+              }
+              clusters.erase(clusters.begin() + iCluster2);
+              --iCluster2;
+              --nClusters;
             }
-            mTimeFrame->getTrackletClusters(rofId).erase(mTimeFrame->getTrackletClusters(rofId).begin() + iCluster2);
-            --iCluster2;
-            --noClustersVec[rofId];
           }
         }
       }
     }
-  }
-  for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    std::sort(mTimeFrame->getTrackletClusters(rofId).begin(), mTimeFrame->getTrackletClusters(rofId).end(),
-              [](const ClusterLines& cluster1, const ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); }); // ensure clusters are ordered by contributors, so that we can cat after the first.
+
+    // Vertex filtering
+    std::sort(clusters.begin(), clusters.end(),
+              [](const ClusterLines& cluster1, const ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); });
     bool atLeastOneFound{false};
-    for (int iCluster{0}; iCluster < noClustersVec[rofId]; ++iCluster) {
+    for (int iCluster{0}; iCluster < nClusters; ++iCluster) {
       bool lowMultCandidate{false};
-      double beamDistance2{(mTimeFrame->getBeamX() - mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[0]) * (mTimeFrame->getBeamX() - mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[0]) +
-                           (mTimeFrame->getBeamY() - mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[1]) * (mTimeFrame->getBeamY() - mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[1])};
-      if (atLeastOneFound && (lowMultCandidate = mTimeFrame->getTrackletClusters(rofId)[iCluster].getSize() < mVrtParams[iteration].clusterContributorsCut)) { // We might have pile up with nContr > cut.
+      double beamDistance2{(mTimeFrame->getBeamX() - clusters[iCluster].getVertex()[0]) * (mTimeFrame->getBeamX() - clusters[iCluster].getVertex()[0]) +
+                           (mTimeFrame->getBeamY() - clusters[iCluster].getVertex()[1]) * (mTimeFrame->getBeamY() - clusters[iCluster].getVertex()[1])};
+      if (atLeastOneFound && (lowMultCandidate = clusters[iCluster].getSize() < mVrtParams[iteration].clusterContributorsCut)) {
         lowMultCandidate &= (beamDistance2 < mVrtParams[iteration].lowMultBeamDistCut * mVrtParams[iteration].lowMultBeamDistCut);
-        if (!lowMultCandidate) { // Not the first cluster and not a low multiplicity candidate, we can remove it
-          mTimeFrame->getTrackletClusters(rofId).erase(mTimeFrame->getTrackletClusters(rofId).begin() + iCluster);
-          noClustersVec[rofId]--;
+        if (!lowMultCandidate) {
+          clusters.erase(clusters.begin() + iCluster);
+          nClusters--;
           continue;
         }
       }
 
-      if (beamDistance2 < nsigmaCut && o2::gpu::GPUCommonMath::Abs(mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[2]) < mVrtParams[iteration].maxZPositionAllowed) {
+      if (beamDistance2 < nsigmaCut && o2::gpu::GPUCommonMath::Abs(clusters[iCluster].getVertex()[2]) < mVrtParams[iteration].maxZPositionAllowed) {
         atLeastOneFound = true;
-        auto& vertex = vertices.emplace_back(o2::math_utils::Point3D<float>(mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[0],
-                                                                            mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[1],
-                                                                            mTimeFrame->getTrackletClusters(rofId)[iCluster].getVertex()[2]),
-                                             mTimeFrame->getTrackletClusters(rofId)[iCluster].getRMS2(),          // Symm matrix. Diagonal: RMS2 components,
-                                                                                                                  // off-diagonal: square mean of projections on planes.
-                                             mTimeFrame->getTrackletClusters(rofId)[iCluster].getSize(),          // Contributors
-                                             mTimeFrame->getTrackletClusters(rofId)[iCluster].getAvgDistance2()); // In place of chi2
+        Vertex vertex{clusters[iCluster].getVertex().data(),
+                      clusters[iCluster].getRMS2(),
+                      (ushort)clusters[iCluster].getSize(),
+                      clusters[iCluster].getAvgDistance2()};
 
         if (iteration) {
           vertex.setFlags(Vertex::UPCMode);
         }
-        vertex.setTimeStamp(mTimeFrame->getTrackletClusters(rofId)[iCluster].getROF());
-        if (mTimeFrame->hasMCinformation()) {
+        vertex.setTimeStamp(clusters[iCluster].getTimeStamp());
+        rofVertices[rofId].push_back(vertex);
+        if (hasMC) {
           bounded_vector<o2::MCCompLabel> labels(mMemoryPool.get());
-          for (auto& index : mTimeFrame->getTrackletClusters(rofId)[iCluster].getLabels()) {
-            labels.push_back(mTimeFrame->getLinesLabel(rofId)[index]); // then we can use nContributors from vertices to get the labels
-          }
-          polls.push_back(computeMain(labels));
-          if (mVrtParams[iteration].outputContLabels) {
-            contLabels.insert(contLabels.end(), labels.begin(), labels.end());
+          for (auto& index : clusters[iCluster].getLabels()) {
+            labels.push_back(mTimeFrame->getLinesLabel(rofId)[index]);
           }
+          rofLabels[rofId].push_back(computeMain(labels));
         }
       }
     }
-    if (!iteration) {
-      mTimeFrame->addPrimaryVertices(vertices, iteration);
-      if (mTimeFrame->hasMCinformation()) {
-        mTimeFrame->addPrimaryVerticesLabels(polls);
-        if (mVrtParams[iteration].outputContLabels) {
-          mTimeFrame->addPrimaryVerticesContributorLabels(contLabels);
-        }
-      }
-    } else {
-      mTimeFrame->addPrimaryVerticesInROF(vertices, rofId, iteration);
-      if (mTimeFrame->hasMCinformation()) {
-        mTimeFrame->addPrimaryVerticesLabelsInROF(polls, rofId);
-        if (mVrtParams[iteration].outputContLabels) {
-          mTimeFrame->addPrimaryVerticesContributorLabelsInROF(contLabels, rofId);
-        }
-      }
+  };
+
+  if (mTaskArena->max_concurrency() <= 1) {
+    for (int rofId{0}; rofId < nRofs; ++rofId) {
+      processROF(rofId);
     }
-    if (vertices.empty() && !(iteration && (int)mTimeFrame->getPrimaryVertices(rofId).size() > mVrtParams[iteration].vertPerRofThreshold)) {
-      mTimeFrame->getNoVertexROF()++;
+  } else {
+    mTaskArena->execute([&] {
+      tbb::parallel_for(0, nRofs, [&](const int rofId) {
+        processROF(rofId);
+      });
+    });
+  }
+  // add vertices, these anyways get sorted afterward
+  for (int rofId{0}; rofId < nRofs; ++rofId) {
+    for (auto& vertex : rofVertices[rofId]) {
+      mTimeFrame->addPrimaryVertex(vertex);
+    }
+    if (hasMC) {
+      for (auto& label : rofLabels[rofId]) {
+        mTimeFrame->addPrimaryVertexLabel(label);
+      }
     }
-    vertices.clear();
-    polls.clear();
   }
-
-#ifdef VTX_DEBUG
-  debugComputeVertices(iteration);
-#endif
 }
 
-template <int nLayers>
-void VertexerTraits<nLayers>::addTruthSeedingVertices()
+template <int NLayers>
+void VertexerTraits<NLayers>::addTruthSeedingVertices()
 {
   LOGP(info, "Using truth seeds as vertices; will skip computations");
-  mTimeFrame->resetRofPV();
   const auto dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
   const auto irs = dc->getEventRecords();
-  int64_t roFrameBiasInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC;
-  int64_t roFrameLengthInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameLengthInBC;
+  int64_t roFrameBiasInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().getROFBiasInBC(1);
+  int64_t roFrameLengthInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().getROFLengthInBC(1);
   o2::steer::MCKinematicsReader mcReader(dc);
-  struct VertInfo {
-    bounded_vector<Vertex> vertices;
-    bounded_vector<int> srcs;
-    bounded_vector<int> events;
-  };
-  std::map<int, VertInfo> vertices;
   const int iSrc = 0; // take only events from collision generator
   auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
   for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
     const auto& ir = irs[eveId2colId[iEve]];
     if (!ir.isDummy()) { // do we need this, is this for diffractive events?
       const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
-      int rofId = ((ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC) / roFrameLengthInBC;
-      if (!vertices.contains(rofId)) {
-        vertices[rofId] = {
-          .vertices = bounded_vector<Vertex>(mMemoryPool.get()),
-          .srcs = bounded_vector<int>(mMemoryPool.get()),
-          .events = bounded_vector<int>(mMemoryPool.get()),
-        };
+      auto bc = (ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC;
+      if (bc < 0) { // event happened before TF
+        continue;
       }
       Vertex vert;
-      vert.setTimeStamp(rofId);
+      vert.getTimeStamp().setTimeStamp(bc);
+      vert.getTimeStamp().setTimeStampError(roFrameLengthInBC / 2);
       // set minimum to 1 sometimes for diffractive events there is nothing acceptance
       vert.setNContributors(std::max(1L, std::ranges::count_if(mcReader.getTracks(iSrc, iEve), [](const auto& trk) {
-                                       return trk.isPrimary() && trk.GetPt() > 0.05 && std::abs(trk.GetEta()) < 1.1;
+                                       if (!trk.isPrimary() || trk.GetPt() < 0.05 || std::abs(trk.GetEta()) > 1.1) {
+                                         return false;
+                                       }
+                                       return o2::O2DatabasePDG::Instance()->GetParticle(trk.GetPdgCode())->Charge() != 0;
                                      })));
       vert.setXYZ((float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ());
       vert.setChi2(1); // not used as constraint
-      constexpr float cov = 50e-9;
-      vert.setCov(cov, cov, cov, cov, cov, cov);
-      vertices[rofId].vertices.push_back(vert);
-      vertices[rofId].srcs.push_back(iSrc);
-      vertices[rofId].events.push_back(iEve);
+      constexpr float cov = 25e-4;
+      vert.setSigmaX(cov);
+      vert.setSigmaY(cov);
+      vert.setSigmaZ(cov);
+      mTimeFrame->addPrimaryVertex(vert);
+      o2::MCCompLabel mcLbl(o2::MCCompLabel::maxTrackID(), iEve, iSrc, false);
+      VertexLabel lbl(mcLbl, 1.0);
+      mTimeFrame->addPrimaryVertexLabel(lbl);
     }
     mcReader.releaseTracksForSourceAndEvent(iSrc, iEve);
   }
-  size_t nVerts{0};
-  for (int iROF{0}; iROF < mTimeFrame->getNrof(); ++iROF) {
-    bounded_vector<Vertex> verts(mMemoryPool.get());
-    bounded_vector<std::pair<o2::MCCompLabel, float>> polls(mMemoryPool.get());
-    if (vertices.contains(iROF)) {
-      const auto& vertInfo = vertices[iROF];
-      verts = vertInfo.vertices;
-      nVerts += verts.size();
-      for (size_t i{0}; i < verts.size(); ++i) {
-        o2::MCCompLabel lbl(o2::MCCompLabel::maxTrackID(), vertInfo.events[i], vertInfo.srcs[i], false);
-        polls.emplace_back(lbl, 1.f);
-      }
-    } else {
-      mTimeFrame->getNoVertexROF()++;
-    }
-    mTimeFrame->addPrimaryVertices(verts, 0);
-    mTimeFrame->addPrimaryVerticesLabels(polls);
-  }
-  LOGP(info, "Found {}/{} ROFs with {} vertices -> <NV>={:.2f}", vertices.size(), mTimeFrame->getNrof(), nVerts, (float)nVerts / (float)vertices.size());
+  LOGP(info, "Imposed {} pv collisions from mc-truth", mTimeFrame->getPrimaryVertices().size());
 }
 
-template <int nLayers>
-void VertexerTraits<nLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
+template <int NLayers>
+void VertexerTraits<NLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena)
 {
-#if defined(VTX_DEBUG)
-  LOGP(info, "Vertexer with debug output forcing single thread");
-  mTaskArena = std::make_shared<tbb::task_arena>(1);
-#else
   if (arena == nullptr) {
     mTaskArena = std::make_shared<tbb::task_arena>(std::abs(n));
     LOGP(info, "Setting seeding vertexer with {} threads.", n);
   } else {
     mTaskArena = arena;
-    LOGP(info, "Attaching vertexer to calling thread's arena");
-  }
-#endif
-}
-
-template <int nLayers>
-void VertexerTraits<nLayers>::debugComputeTracklets(int iteration)
-{
-  auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "recreate");
-  LOGP(info, "writing debug output for computeTracklets");
-  for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    const auto& strk0 = mTimeFrame->getFoundTracklets(rofId, 0);
-    std::vector<Tracklet> trk0(strk0.begin(), strk0.end());
-    const auto& strk1 = mTimeFrame->getFoundTracklets(rofId, 1);
-    std::vector<Tracklet> trk1(strk1.begin(), strk1.end());
-    (*stream) << "tracklets"
-              << "Tracklets0=" << trk0
-              << "Tracklets1=" << trk1
-              << "iteration=" << iteration
-              << "\n";
-  }
-  stream->Close();
-  delete stream;
-}
-
-template <int nLayers>
-void VertexerTraits<nLayers>::debugComputeTrackletMatching(int iteration)
-{
-  auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "update");
-  LOGP(info, "writing debug output for computeTrackletMatching");
-  for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    (*stream) << "lines"
-              << "Lines=" << toSTDVector(mTimeFrame->getLines(rofId))
-              << "NTrackletCluster01=" << mTimeFrame->getNTrackletsCluster(rofId, 0)
-              << "NTrackletCluster12=" << mTimeFrame->getNTrackletsCluster(rofId, 1)
-              << "iteration=" << iteration
-              << "\n";
-  }
-
-  if (mTimeFrame->hasMCinformation()) {
-    LOGP(info, "\tdumping also MC information");
-    const auto dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
-    const auto irs = dc->getEventRecords();
-    int64_t roFrameBiasInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC;
-    int64_t roFrameLengthInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameLengthInBC;
-    o2::steer::MCKinematicsReader mcReader(dc);
-
-    std::map<int, int> eve2BcInROF, bcInRofNEve;
-    for (int iSrc{0}; iSrc < mcReader.getNSources(); ++iSrc) {
-      auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
-      for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
-        const auto& ir = irs[eveId2colId[iEve]];
-        if (!ir.isDummy()) { // do we need this, is this for diffractive events?
-          const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
-          const int bcInROF = ((ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC) % roFrameLengthInBC;
-          eve2BcInROF[iEve] = bcInROF;
-          ++bcInRofNEve[bcInROF];
-        }
-      }
-    }
-
-    std::unordered_map<int, int> bcROFNTracklets01, bcROFNTracklets12;
-    std::vector<std::vector<int>> tracklet01BC, tracklet12BC;
-    for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-      { // 0-1
-        const auto& tracklet01 = mTimeFrame->getFoundTracklets(rofId, 0);
-        const auto& lbls01 = mTimeFrame->getLabelsFoundTracklets(rofId, 0);
-        auto& trkls01 = tracklet01BC.emplace_back();
-        for (int iTrklt{0}; iTrklt < (int)tracklet01.size(); ++iTrklt) {
-          const auto& tracklet = tracklet01[iTrklt];
-          const auto& lbl = lbls01[iTrklt];
-          if (lbl.isCorrect()) {
-            ++bcROFNTracklets01[eve2BcInROF[lbl.getEventID()]];
-            trkls01.push_back(eve2BcInROF[lbl.getEventID()]);
-          } else {
-            trkls01.push_back(-1);
-          }
-        }
-      }
-      { // 1-2 computed on the fly!
-        const auto& tracklet12 = mTimeFrame->getFoundTracklets(rofId, 1);
-        auto& trkls12 = tracklet12BC.emplace_back();
-        for (int iTrklt{0}; iTrklt < (int)tracklet12.size(); ++iTrklt) {
-          const auto& tracklet = tracklet12[iTrklt];
-          o2::MCCompLabel label;
-
-          int sortedId1{mTimeFrame->getSortedIndex(tracklet.rof[0], 1, tracklet.firstClusterIndex)};
-          int sortedId2{mTimeFrame->getSortedIndex(tracklet.rof[1], 2, tracklet.secondClusterIndex)};
-          for (const auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
-            for (const auto& lab2 : mTimeFrame->getClusterLabels(2, mTimeFrame->getClusters()[2][sortedId2].clusterId)) {
-              if (lab1 == lab2 && lab1.isValid()) {
-                label = lab1;
-                break;
-              }
-            }
-            if (label.isValid()) {
-              break;
-            }
-          }
-
-          if (label.isCorrect()) {
-            ++bcROFNTracklets12[eve2BcInROF[label.getEventID()]];
-            trkls12.push_back(eve2BcInROF[label.getEventID()]);
-          } else {
-            trkls12.push_back(-1);
-          }
-        }
-      }
-    }
-    LOGP(info, "\tdumping ntracklets/RofBC ({})", bcInRofNEve.size());
-    for (const auto& [bcInRof, neve] : bcInRofNEve) {
-      (*stream) << "ntracklets"
-                << "bcInROF=" << bcInRof
-                << "ntrkl01=" << bcROFNTracklets01[bcInRof]
-                << "ntrkl12=" << bcROFNTracklets12[bcInRof]
-                << "neve=" << neve
-                << "iteration=" << iteration
-                << "\n";
-    }
-
-    std::unordered_map<int, int> bcROFNLines;
-    for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-      const auto& lines = mTimeFrame->getLines(rofId);
-      const auto& lbls = mTimeFrame->getLinesLabel(rofId);
-      for (int iLine{0}; iLine < (int)lines.size(); ++iLine) {
-        const auto& line = lines[iLine];
-        const auto& lbl = lbls[iLine];
-        if (lbl.isCorrect()) {
-          ++bcROFNLines[eve2BcInROF[lbl.getEventID()]];
-        }
-      }
-    }
-
-    LOGP(info, "\tdumping nlines/RofBC");
-    for (const auto& [bcInRof, neve] : bcInRofNEve) {
-      (*stream) << "nlines"
-                << "bcInROF=" << bcInRof
-                << "nline=" << bcROFNLines[bcInRof]
-                << "neve=" << neve
-                << "iteration=" << iteration
-                << "\n";
-    }
-  }
-  stream->Close();
-  delete stream;
-}
-
-template <int nLayers>
-void VertexerTraits<nLayers>::debugComputeVertices(int iteration)
-{
-  auto stream = new utils::TreeStreamRedirector("artefacts_tf.root", "update");
-  LOGP(info, "writing debug output for computeVertices");
-  for (auto rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-    (*stream) << "clusterlines"
-              << "clines_post=" << toSTDVector(mTimeFrame->getTrackletClusters(rofId))
-              << "iteration=" << iteration
-              << "\n";
-  }
-
-  if (mTimeFrame->hasMCinformation()) {
-    LOGP(info, "\tdumping also MC information");
-    const auto dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
-    const auto irs = dc->getEventRecords();
-    int64_t roFrameBiasInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC;
-    int64_t roFrameLengthInBC = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameLengthInBC;
-    o2::steer::MCKinematicsReader mcReader(dc);
-
-    std::map<int, int> eve2BcInROF, bcInRofNEve;
-    for (int iSrc{0}; iSrc < mcReader.getNSources(); ++iSrc) {
-      auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
-      for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
-        const auto& ir = irs[eveId2colId[iEve]];
-        if (!ir.isDummy()) { // do we need this, is this for diffractive events?
-          const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
-          const int bcInROF = ((ir - raw::HBFUtils::Instance().getFirstSampledTFIR()).toLong() - roFrameBiasInBC) % roFrameLengthInBC;
-          eve2BcInROF[iEve] = bcInROF;
-          ++bcInRofNEve[bcInROF];
-        }
-      }
-    }
-
-    std::unordered_map<int, int> bcROFNVtx;
-    std::unordered_map<int, float> bcROFNPur;
-    std::unordered_map<o2::MCCompLabel, size_t> uniqueVertices;
-    for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-      const auto& pvs = mTimeFrame->getPrimaryVertices(rofId);
-      const auto& lblspv = mTimeFrame->getPrimaryVerticesMCRecInfo(rofId);
-      for (int i{0}; i < (int)pvs.size(); ++i) {
-        const auto& pv = pvs[i];
-        const auto& [lbl, pur] = lblspv[i];
-        if (lbl.isCorrect()) {
-          ++uniqueVertices[lbl];
-          ++bcROFNVtx[eve2BcInROF[lbl.getEventID()]];
-          bcROFNPur[eve2BcInROF[lbl.getEventID()]] += pur;
-        }
-      }
-    }
-
-    std::unordered_map<int, int> bcROFNUVtx, bcROFNCVtx;
-    for (const auto& [k, _] : eve2BcInROF) {
-      bcROFNUVtx[k] = bcROFNCVtx[k] = 0;
-    }
-
-    for (const auto& [lbl, c] : uniqueVertices) {
-      if (c <= 1) {
-        ++bcROFNUVtx[eve2BcInROF[lbl.getEventID()]];
-      } else {
-        ++bcROFNCVtx[eve2BcInROF[lbl.getEventID()]];
-      }
-    }
-
-    LOGP(info, "\tdumping nvtx/RofBC");
-    for (const auto& [bcInRof, neve] : bcInRofNEve) {
-      (*stream) << "nvtx"
-                << "bcInROF=" << bcInRof
-                << "nvtx=" << bcROFNVtx[bcInRof]   // all vertices
-                << "nuvtx=" << bcROFNUVtx[bcInRof] // unique vertices
-                << "ncvtx=" << bcROFNCVtx[bcInRof] // cloned vertices
-                << "npur=" << bcROFNPur[bcInRof]
-                << "neve=" << neve
-                << "iteration=" << iteration
-                << "\n";
-    }
-
-    // check dist of clones
-    std::unordered_map<o2::MCCompLabel, std::vector<Vertex>> cVtx;
-    for (int rofId{0}; rofId < mTimeFrame->getNrof(); ++rofId) {
-      const auto& pvs = mTimeFrame->getPrimaryVertices(rofId);
-      const auto& lblspv = mTimeFrame->getPrimaryVerticesMCRecInfo(rofId);
-      for (int i{0}; i < (int)pvs.size(); ++i) {
-        const auto& pv = pvs[i];
-        const auto& [lbl, pur] = lblspv[i];
-        if (lbl.isCorrect() && uniqueVertices.contains(lbl) && uniqueVertices[lbl] > 1) {
-          if (!cVtx.contains(lbl)) {
-            cVtx[lbl] = std::vector<Vertex>();
-          }
-          cVtx[lbl].push_back(pv);
-        }
-      }
-    }
-
-    for (auto& [_, vertices] : cVtx) {
-      std::sort(vertices.begin(), vertices.end(), [](const Vertex& a, const Vertex& b) { return a.getNContributors() > b.getNContributors(); });
-      for (int i{0}; i < (int)vertices.size(); ++i) {
-        const auto vtx = vertices[i];
-        (*stream) << "cvtx"
-                  << "vertex=" << vtx
-                  << "i=" << i
-                  << "dx=" << vertices[0].getX() - vtx.getX()
-                  << "dy=" << vertices[0].getY() - vtx.getY()
-                  << "dz=" << vertices[0].getZ() - vtx.getZ()
-                  << "drof=" << vertices[0].getTimeStamp().getTimeStamp() - vtx.getTimeStamp().getTimeStamp()
-                  << "dnc=" << vertices[0].getNContributors() - vtx.getNContributors()
-                  << "iteration=" << iteration
-                  << "\n";
-      }
-    }
   }
-  stream->Close();
-  delete stream;
 }
 
 template class VertexerTraits<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
index 818ad1d667371..063583b4cfa1b 100644
--- a/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
@@ -1,4 +1,4 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 # See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 # All rights not expressly granted are reserved.
 #
@@ -14,3 +14,9 @@ o2_add_test(boundedmemoryresource
             COMPONENT_NAME its-tracking
             LABELS "its;tracking"
             PUBLIC_LINK_LIBRARIES O2::ITStracking)
+
+o2_add_test(roflookuptables
+            SOURCES testROFLookupTables.cxx
+            COMPONENT_NAME its-tracking
+            LABELS "its;tracking"
+            PUBLIC_LINK_LIBRARIES O2::ITStracking)
diff --git a/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx b/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx
new file mode 100644
index 0000000000000..8594e59149444
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx
@@ -0,0 +1,744 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <boost/test/tools/old/interface.hpp>
+#define BOOST_TEST_MODULE ITS ROFLookupTables
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_DYN_LINK
+
+#include <boost/test/unit_test.hpp>
+#include "ITStracking/ROFLookupTables.h"
+
+/// -------- Tests --------
+// LayerTiming
+BOOST_AUTO_TEST_CASE(layertiming_basic)
+{
+  o2::its::ROFOverlapTable<1> table;
+  table.defineLayer(0, 10, 594, 100, 0, 50);
+  const auto& layer = table.getLayer(0);
+
+  // test ROF time calculations
+  auto start0 = layer.getROFStartInBC(0);
+  BOOST_CHECK_EQUAL(start0, 100); // delay only
+
+  auto end0 = layer.getROFEndInBC(0);
+  BOOST_CHECK_EQUAL(end0, 100 + 594);
+
+  // test second ROF
+  auto start1 = layer.getROFStartInBC(1);
+  BOOST_CHECK_EQUAL(start1, 100 + 594);
+}
+
+BOOST_AUTO_TEST_CASE(layertiming_base)
+{
+  o2::its::ROFOverlapTable<3> table;
+  table.defineLayer(0, 10, 500, 0, 0, 0);
+  table.defineLayer(1, 12, 600, 50, 0, 0);
+  table.defineLayer(2, 8, 400, 100, 0, 0);
+  const auto& layer1 = table.getLayer(1);
+  BOOST_CHECK_EQUAL(layer1.mNROFsTF, 12);
+  BOOST_CHECK_EQUAL(layer1.mROFLength, 600);
+}
+
+BOOST_AUTO_TEST_CASE(rofmask_construct_from_timing)
+{
+  o2::its::ROFOverlapTable<2> timing;
+  timing.defineLayer(0, 3, 100, 0, 0, 0);
+  timing.defineLayer(1, 4, 50, 25, 0, 0);
+
+  o2::its::ROFMaskTable<2> mask{timing};
+  const auto view = mask.getView();
+
+  BOOST_REQUIRE(view.mFlatMask != nullptr);
+  BOOST_REQUIRE(view.mLayerROFOffsets != nullptr);
+  BOOST_CHECK_EQUAL(view.mLayerROFOffsets[0], 0);
+  BOOST_CHECK_EQUAL(view.mLayerROFOffsets[1], 3);
+  BOOST_CHECK_EQUAL(view.mLayerROFOffsets[2], 7);
+
+  // by default all rofs are disabled
+  for (int rof{0}; rof < 3; ++rof) {
+    BOOST_CHECK(!view.isROFEnabled(0, rof));
+  }
+  for (int rof{0}; rof < 4; ++rof) {
+    BOOST_CHECK(!view.isROFEnabled(1, rof));
+  }
+
+  mask.selectROF({110, 20});
+
+  BOOST_CHECK(!view.isROFEnabled(0, 0));
+  BOOST_CHECK(view.isROFEnabled(0, 1));
+  BOOST_CHECK(!view.isROFEnabled(0, 2));
+
+  BOOST_CHECK(!view.isROFEnabled(1, 0));
+  BOOST_CHECK(view.isROFEnabled(1, 1));
+  BOOST_CHECK(view.isROFEnabled(1, 2));
+  BOOST_CHECK(!view.isROFEnabled(1, 3));
+}
+
+// ROFOverlapTable
+BOOST_AUTO_TEST_CASE(rofoverlap_basic)
+{
+  // define 2 layers with the same definitions (no staggering)
+  o2::its::ROFOverlapTable<2> table;
+  table.defineLayer(0, 12, 594, 0, 0, 0);
+  table.defineLayer(1, 12, 594, 0, 0, 0);
+  table.init();
+  const auto view = table.getView();
+  // each rof in layer 0 should be compatible with its layer 1 equivalent
+  for (int rof{0}; rof < 12; ++rof) {
+    BOOST_CHECK(view.doROFsOverlap(0, rof, 1, rof));
+    BOOST_CHECK(view.doROFsOverlap(1, rof, 0, rof));
+    BOOST_CHECK(view.getOverlap(0, 1, rof).getEntries() == 1);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_staggered)
+{
+  // test staggered layers with ROF delay
+  o2::its::ROFOverlapTable<2> table;
+  table.defineLayer(0, 10, 500, 0, 0, 0);
+  table.defineLayer(1, 10, 500, 250, 0, 0); // 250 BC delay
+  table.init();
+  const auto view = table.getView();
+
+  // verify overlap range
+  { // from 0 to 1
+    const auto& range = view.getOverlap(0, 1, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 1 to 0
+    const auto& range = view.getOverlap(1, 0, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_staggered_pp)
+{
+  const uint32_t rofLen{198}, rofBins{6};
+  const uint32_t rofDelay{rofLen / rofBins};
+  o2::its::ROFOverlapTable<3> table;
+  for (uint32_t lay{0}; lay < 3; ++lay) {
+    table.defineLayer(lay, 6, rofLen, lay * rofDelay, 0, 0);
+  }
+  table.init();
+  const auto view = table.getView();
+  view.printAll();
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_staggered_alllayers)
+{
+  // test staggered layers with ROF delay
+  o2::its::ROFOverlapTable<3> table;
+  table.defineLayer(0, 2, 3, 0, 0, 0);
+  table.defineLayer(1, 3, 2, 0, 0, 0);
+  table.defineLayer(2, 6, 1, 0, 0, 0);
+  table.init();
+  const auto view = table.getView();
+  // verify overlap range
+  { // from 0 to 1 rof=0
+    const auto& range = view.getOverlap(0, 1, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 0 to 2 rof=0
+    const auto& range = view.getOverlap(0, 2, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 3);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 0 to 1 rof=1
+    const auto& range = view.getOverlap(0, 1, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 0 to 2 rof=1
+    const auto& range = view.getOverlap(0, 2, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 3);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 3);
+  }
+  { // from 1 to 2 rof=0
+    const auto& range = view.getOverlap(1, 2, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 1 to 0 rof=0
+    const auto& range = view.getOverlap(1, 0, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 1 to 2 rof=1
+    const auto& range = view.getOverlap(1, 2, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 2);
+  }
+  { // from 1 to 0 rof=1
+    const auto& range = view.getOverlap(1, 0, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 1 to 2 rof=2
+    const auto& range = view.getOverlap(1, 2, 2);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 4);
+  }
+  { // from 1 to 0 rof=2
+    const auto& range = view.getOverlap(1, 0, 2);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 1 rof=0
+    const auto& range = view.getOverlap(2, 1, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 1 rof=1
+    const auto& range = view.getOverlap(2, 1, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 1 rof=2
+    const auto& range = view.getOverlap(2, 1, 2);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 1 rof=3
+    const auto& range = view.getOverlap(2, 1, 3);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 1 rof=4
+    const auto& range = view.getOverlap(2, 1, 4);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 2);
+  }
+  { // from 2 to 1 rof=5
+    const auto& range = view.getOverlap(2, 1, 5);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 2);
+  }
+  { // from 2 to 0 rof=0
+    const auto& range = view.getOverlap(2, 0, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 0 rof=1
+    const auto& range = view.getOverlap(2, 0, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 0 rof=2
+    const auto& range = view.getOverlap(2, 0, 2);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 0 rof=3
+    const auto& range = view.getOverlap(2, 0, 3);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 0 rof=4
+    const auto& range = view.getOverlap(2, 0, 4);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 0 rof=5
+    const auto& range = view.getOverlap(2, 0, 5);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_staggered_alllayers_delay_delta)
+{
+  // test staggered layers with ROF delay
+  o2::its::ROFOverlapTable<3> table;
+  table.defineLayer(0, 2, 3, 0, 0, 0);
+  table.defineLayer(1, 3, 2, 1, 0, 0);
+  table.defineLayer(2, 6, 1, 0, 0, 1);
+  table.init();
+  const auto view = table.getView();
+
+  // verify overlap range
+  { // from 0 to 1 rof=0
+    const auto& range = view.getOverlap(0, 1, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 0 to 2 rof=0
+    const auto& range = view.getOverlap(0, 2, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 4);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 0 to 1 rof=1
+    const auto& range = view.getOverlap(0, 1, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 0 to 2 rof=1
+    const auto& range = view.getOverlap(0, 2, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 4);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 2);
+  }
+  { // from 1 to 2 rof=0
+    const auto& range = view.getOverlap(1, 2, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 4);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 1 to 0 rof=0
+    const auto& range = view.getOverlap(1, 0, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 1 to 2 rof=1
+    const auto& range = view.getOverlap(1, 2, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 4);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 2);
+  }
+  { // from 1 to 0 rof=1
+    const auto& range = view.getOverlap(1, 0, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 1 to 2 rof=2
+    const auto& range = view.getOverlap(1, 2, 2);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 4);
+  }
+  { // from 1 to 0 rof=2
+    const auto& range = view.getOverlap(1, 0, 2);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 1 rof=0
+    const auto& range = view.getOverlap(2, 1, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 1 rof=1
+    const auto& range = view.getOverlap(2, 1, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 1 rof=2
+    const auto& range = view.getOverlap(2, 1, 2);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 1 rof=3
+    const auto& range = view.getOverlap(2, 1, 3);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 1 rof=4
+    const auto& range = view.getOverlap(2, 1, 4);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 1 rof=5
+    const auto& range = view.getOverlap(2, 1, 5);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 0 rof=0
+    const auto& range = view.getOverlap(2, 0, 0);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 0 rof=1
+    const auto& range = view.getOverlap(2, 0, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 0 rof=2
+    const auto& range = view.getOverlap(2, 0, 2);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 0 rof=3
+    const auto& range = view.getOverlap(2, 0, 3);
+    BOOST_CHECK_EQUAL(range.getEntries(), 2);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 0);
+  }
+  { // from 2 to 0 rof=4
+    const auto& range = view.getOverlap(2, 0, 4);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+  { // from 2 to 0 rof=5
+    const auto& range = view.getOverlap(2, 0, 5);
+    BOOST_CHECK_EQUAL(range.getEntries(), 1);
+    BOOST_CHECK_EQUAL(range.getFirstEntry(), 1);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_with_delta)
+{
+  // test with ROF delta for compatibility window
+  o2::its::ROFOverlapTable<2> table;
+  table.defineLayer(0, 8, 600, 0, 0, 100); // +/- 100 BC delta
+  table.defineLayer(1, 8, 600, 0, 0, 100);
+  table.init();
+  const auto view = table.getView();
+
+  // with delta, ROFs should have wider compatibility
+  for (int rof{0}; rof < 8; ++rof) {
+    auto overlap = view.getOverlap(0, 1, rof);
+    if (rof == 0 || rof == 7) {
+      // edges should see only two
+      BOOST_CHECK_EQUAL(overlap.getEntries(), 2);
+    } else {
+      BOOST_CHECK_EQUAL(overlap.getEntries(), 3);
+    }
+  }
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_same_layer)
+{
+  // test same layer compatibility
+  o2::its::ROFOverlapTable<1> table;
+  table.defineLayer(0, 10, 500, 0, 0, 0);
+  table.init();
+  const auto view = table.getView();
+
+  // same ROF in same layer should be compatible
+  BOOST_CHECK(view.doROFsOverlap(0, 5, 0, 5));
+  // different ROFs in same layer should not be compatible
+  BOOST_CHECK(!view.doROFsOverlap(0, 5, 0, 6));
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_timestamp_basic)
+{
+  o2::its::ROFOverlapTable<4> table;
+  table.defineLayer(0, 4, 100, 0, 0, 0);
+  table.defineLayer(1, 4, 100, 0, 0, 0);
+  table.defineLayer(2, 8, 50, 0, 0, 0);
+  table.defineLayer(3, 7, 50, 50, 0, 0);
+  table.init();
+  const auto& view = table.getView();
+
+  const auto t01 = view.getTimeStamp(0, 3, 1, 3);
+  BOOST_CHECK_EQUAL(t01.getTimeStamp(), 300);
+  BOOST_CHECK_EQUAL(t01.getTimeStampError(), 100);
+
+  const auto t02 = view.getTimeStamp(0, 1, 2, 3);
+  BOOST_CHECK_EQUAL(t02.getTimeStamp(), 150);
+  BOOST_CHECK_EQUAL(t02.getTimeStampError(), 50);
+
+  const auto t03 = view.getTimeStamp(0, 0, 3, 0);
+  BOOST_CHECK_EQUAL(t03.getTimeStamp(), 50);
+  BOOST_CHECK_EQUAL(t03.getTimeStampError(), 50);
+
+  const auto t23 = view.getTimeStamp(2, 2, 3, 1);
+  BOOST_CHECK_EQUAL(t23.getTimeStamp(), 100);
+  BOOST_CHECK_EQUAL(t23.getTimeStampError(), 50);
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_timestamp_complex)
+{
+  o2::its::ROFOverlapTable<4> table;
+  table.defineLayer(0, 4, 100, 0, 0, 0);
+  table.defineLayer(1, 4, 100, 0, 0, 10);
+  table.defineLayer(2, 8, 50, 0, 0, 0);
+  table.defineLayer(3, 7, 50, 50, 0, 10);
+  table.init();
+  const auto& view = table.getView();
+  view.printMapping(0, 1);
+
+  const auto t010 = view.getTimeStamp(0, 3, 1, 3);
+  BOOST_CHECK_EQUAL(t010.getTimeStamp(), 300);
+  BOOST_CHECK_EQUAL(t010.getTimeStampError(), 100);
+
+  const auto t011 = view.getTimeStamp(0, 2, 1, 3);
+  BOOST_CHECK_EQUAL(t011.getTimeStamp(), 290);
+  BOOST_CHECK_EQUAL(t011.getTimeStampError(), 10);
+
+  const auto t02 = view.getTimeStamp(0, 1, 2, 3);
+  BOOST_CHECK_EQUAL(t02.getTimeStamp(), 150);
+  BOOST_CHECK_EQUAL(t02.getTimeStampError(), 50);
+
+  const auto t03 = view.getTimeStamp(0, 0, 3, 0);
+  BOOST_CHECK_EQUAL(t03.getTimeStamp(), 40);
+  BOOST_CHECK_EQUAL(t03.getTimeStampError(), 60);
+}
+
+// ROFVertexLookupTable
+BOOST_AUTO_TEST_CASE(rofvertex_basic)
+{
+  o2::its::ROFVertexLookupTable<1> table;
+  table.defineLayer(0, 6, 594, 0, 0, 0);
+  table.init();
+  std::vector<o2::its::Vertex> vertices;
+  o2::its::Vertex vert0;
+  vert0.getTimeStamp().setTimeStamp(594);
+  vert0.getTimeStamp().setTimeStampError(594);
+  vertices.push_back(vert0);
+  o2::its::Vertex vert1;
+  vert1.getTimeStamp().setTimeStamp(2375);
+  vert1.getTimeStamp().setTimeStampError(594);
+  vertices.push_back(vert1);
+  table.update(vertices.data(), vertices.size());
+  const auto view = table.getView();
+}
+
+BOOST_AUTO_TEST_CASE(rofvertex_init_with_vertices)
+{
+  o2::its::ROFVertexLookupTable<2> table;
+  table.defineLayer(0, 10, 500, 0, 0, 0);
+  table.defineLayer(1, 10, 500, 0, 0, 0);
+
+  // create vertices at different timestamps
+  std::vector<o2::its::Vertex> vertices;
+  for (int i = 0; i < 5; ++i) {
+    o2::its::Vertex v;
+    v.getTimeStamp().setTimeStamp(i * 1000);
+    v.getTimeStamp().setTimeStampError(500);
+    vertices.push_back(v);
+  }
+
+  table.init(vertices.data(), vertices.size());
+  const auto view = table.getView();
+
+  // verify vertices can be queried
+  const auto& vtxRange = view.getVertices(0, 0);
+  BOOST_CHECK_EQUAL(vtxRange.getEntries(), 1);
+}
+
+BOOST_AUTO_TEST_CASE(rofvertex_max_vertices)
+{
+  o2::its::ROFVertexLookupTable<1> table;
+  table.defineLayer(0, 3, 1000, 0, 0, 500);
+
+  std::vector<o2::its::Vertex> vertices;
+  for (int i = 0; i < 10; ++i) {
+    o2::its::Vertex v;
+    v.getTimeStamp().setTimeStamp(500 + i * 100);
+    v.getTimeStamp().setTimeStampError(50);
+    vertices.push_back(v);
+  }
+
+  table.init(vertices.data(), vertices.size());
+  const auto view = table.getView();
+
+  int32_t maxVtx = view.getMaxVerticesPerROF();
+  BOOST_CHECK(maxVtx >= 0);
+}
+
+BOOST_AUTO_TEST_CASE(rofvertex_vertex_more)
+{
+  o2::its::ROFVertexLookupTable<4> table;
+  table.defineLayer(0, 4, 100, 0, 0, 0);
+  table.defineLayer(1, 4, 100, 0, 0, 10);
+  table.defineLayer(2, 8, 50, 0, 0, 0);
+  table.defineLayer(3, 7, 50, 50, 0, 10);
+  table.init();
+
+  std::vector<o2::its::Vertex> vertices;
+  { // vertex 0 overlapping
+    auto& v = vertices.emplace_back();
+    v.getTimeStamp().setTimeStamp(100);
+    v.getTimeStamp().setTimeStampError(10);
+  }
+  { // vertex 1
+    auto& v = vertices.emplace_back();
+    v.getTimeStamp().setTimeStamp(100);
+    v.getTimeStamp().setTimeStampError(0);
+  }
+  { // vertex 2 spanning multiple rofs
+    auto& v = vertices.emplace_back();
+    v.getTimeStamp().setTimeStamp(100);
+    v.getTimeStamp().setTimeStampError(60);
+  }
+
+  // sorty vertices by lower bound
+  std::sort(vertices.begin(), vertices.end(), [](const auto& pvA, const auto& pvB) {
+    const auto& a = pvA.getTimeStamp();
+    const auto& b = pvB.getTimeStamp();
+    const auto aLower = a.getTimeStamp() - a.getTimeStampError();
+    const auto bLower = b.getTimeStamp() - b.getTimeStampError();
+    if (aLower != bLower) {
+      return aLower < bLower;
+    }
+    return pvA.getNContributors() > pvB.getNContributors();
+  });
+
+  table.update(vertices.data(), vertices.size());
+  const auto& view = table.getView();
+
+  const auto& v0 = vertices[0]; // 100+60
+  const auto& v1 = vertices[1]; // 100+10
+  const auto& v2 = vertices[2]; // 100+0
+
+  // check for v0
+  // layer 0
+  BOOST_CHECK(!view.isVertexCompatible(0, 0, v0));
+  BOOST_CHECK(view.isVertexCompatible(0, 1, v0));
+  BOOST_CHECK(!view.isVertexCompatible(0, 2, v0));
+  BOOST_CHECK(!view.isVertexCompatible(0, 3, v0));
+  // layer 1
+  BOOST_CHECK(view.isVertexCompatible(1, 0, v0));
+  BOOST_CHECK(view.isVertexCompatible(1, 1, v0));
+  BOOST_CHECK(!view.isVertexCompatible(1, 2, v0));
+  BOOST_CHECK(!view.isVertexCompatible(1, 3, v0));
+  // layer 2
+  BOOST_CHECK(!view.isVertexCompatible(2, 0, v0));
+  BOOST_CHECK(!view.isVertexCompatible(2, 1, v0));
+  BOOST_CHECK(view.isVertexCompatible(2, 2, v0));
+  BOOST_CHECK(view.isVertexCompatible(2, 3, v0));
+  BOOST_CHECK(!view.isVertexCompatible(2, 4, v0));
+  BOOST_CHECK(!view.isVertexCompatible(2, 5, v0));
+  BOOST_CHECK(!view.isVertexCompatible(2, 6, v0));
+  BOOST_CHECK(!view.isVertexCompatible(2, 7, v0));
+  // layer 3
+  BOOST_CHECK(view.isVertexCompatible(3, 0, v0));
+  BOOST_CHECK(view.isVertexCompatible(3, 1, v0));
+  BOOST_CHECK(view.isVertexCompatible(3, 2, v0));
+  BOOST_CHECK(!view.isVertexCompatible(3, 3, v0));
+  BOOST_CHECK(!view.isVertexCompatible(3, 4, v0));
+  BOOST_CHECK(!view.isVertexCompatible(3, 5, v0));
+  BOOST_CHECK(!view.isVertexCompatible(3, 6, v0));
+
+  // check for v1
+  // layer 0
+  BOOST_CHECK(!view.isVertexCompatible(0, 0, v1));
+  BOOST_CHECK(view.isVertexCompatible(0, 1, v1));
+  BOOST_CHECK(!view.isVertexCompatible(0, 2, v1));
+  BOOST_CHECK(!view.isVertexCompatible(0, 3, v1));
+  // layer 1
+  BOOST_CHECK(view.isVertexCompatible(1, 0, v1));
+  BOOST_CHECK(view.isVertexCompatible(1, 1, v1));
+  BOOST_CHECK(!view.isVertexCompatible(1, 2, v1));
+  BOOST_CHECK(!view.isVertexCompatible(1, 3, v1));
+  // layer 2
+  BOOST_CHECK(!view.isVertexCompatible(2, 0, v1));
+  BOOST_CHECK(!view.isVertexCompatible(2, 1, v1));
+  BOOST_CHECK(view.isVertexCompatible(2, 2, v1));
+  BOOST_CHECK(!view.isVertexCompatible(2, 3, v1));
+  BOOST_CHECK(!view.isVertexCompatible(2, 4, v1));
+  BOOST_CHECK(!view.isVertexCompatible(2, 5, v1));
+  BOOST_CHECK(!view.isVertexCompatible(2, 6, v1));
+  BOOST_CHECK(!view.isVertexCompatible(2, 7, v1));
+  // layer 3
+  BOOST_CHECK(view.isVertexCompatible(3, 0, v1));
+  BOOST_CHECK(view.isVertexCompatible(3, 1, v1));
+  BOOST_CHECK(!view.isVertexCompatible(3, 2, v1));
+  BOOST_CHECK(!view.isVertexCompatible(3, 3, v1));
+  BOOST_CHECK(!view.isVertexCompatible(3, 4, v1));
+  BOOST_CHECK(!view.isVertexCompatible(3, 5, v1));
+  BOOST_CHECK(!view.isVertexCompatible(3, 6, v1));
+
+  // check for v2
+  // layer 0
+  BOOST_CHECK(!view.isVertexCompatible(0, 0, v2));
+  BOOST_CHECK(view.isVertexCompatible(0, 1, v2));
+  BOOST_CHECK(!view.isVertexCompatible(0, 2, v2));
+  BOOST_CHECK(!view.isVertexCompatible(0, 3, v2));
+  // layer 1
+  BOOST_CHECK(view.isVertexCompatible(1, 0, v2));
+  BOOST_CHECK(view.isVertexCompatible(1, 1, v2));
+  BOOST_CHECK(!view.isVertexCompatible(1, 2, v2));
+  BOOST_CHECK(!view.isVertexCompatible(1, 3, v2));
+  // layer 2
+  BOOST_CHECK(!view.isVertexCompatible(2, 0, v2));
+  BOOST_CHECK(!view.isVertexCompatible(2, 1, v2));
+  BOOST_CHECK(view.isVertexCompatible(2, 2, v2));
+  BOOST_CHECK(!view.isVertexCompatible(2, 3, v2));
+  BOOST_CHECK(!view.isVertexCompatible(2, 4, v2));
+  BOOST_CHECK(!view.isVertexCompatible(2, 5, v2));
+  BOOST_CHECK(!view.isVertexCompatible(2, 6, v2));
+  BOOST_CHECK(!view.isVertexCompatible(2, 7, v2));
+  // layer 3
+  BOOST_CHECK(view.isVertexCompatible(3, 0, v2));
+  BOOST_CHECK(view.isVertexCompatible(3, 1, v2));
+  BOOST_CHECK(!view.isVertexCompatible(3, 2, v2));
+  BOOST_CHECK(!view.isVertexCompatible(3, 3, v2));
+  BOOST_CHECK(!view.isVertexCompatible(3, 4, v2));
+  BOOST_CHECK(!view.isVertexCompatible(3, 5, v2));
+  BOOST_CHECK(!view.isVertexCompatible(3, 6, v2));
+}
+
+BOOST_AUTO_TEST_CASE(rofvertex_exact_compatibility)
+{
+  o2::its::ROFVertexLookupTable<4> table;
+  table.defineLayer(0, 4, 100, 0, 0, 0);
+  table.defineLayer(1, 4, 100, 0, 0, 10);
+  table.defineLayer(2, 8, 50, 0, 0, 0);
+  table.defineLayer(3, 7, 50, 50, 0, 10);
+  table.init();
+
+  // sorted by lower bound timestamp
+  std::vector<o2::its::Vertex> vertices;
+  { // idx 0: [40, 160] - wide span
+    auto& v = vertices.emplace_back();
+    v.getTimeStamp().setTimeStamp(100);
+    v.getTimeStamp().setTimeStampError(60);
+  }
+  { // idx 1: [90, 110]
+    auto& v = vertices.emplace_back();
+    v.getTimeStamp().setTimeStamp(100);
+    v.getTimeStamp().setTimeStampError(10);
+  }
+  { // idx 2: [100, 100] - zero width, false-positive prone
+    auto& v = vertices.emplace_back();
+    v.getTimeStamp().setTimeStamp(100);
+    v.getTimeStamp().setTimeStampError(0);
+  }
+
+  table.update(vertices.data(), vertices.size());
+  const auto& view = table.getView();
+
+  // Layer 0 ROF 0: [0, 100)
+  BOOST_CHECK(!view.isVertexCompatible(0, 0, vertices[0]));
+  BOOST_CHECK(!view.isVertexCompatible(0, 0, vertices[1]));
+  BOOST_CHECK(!view.isVertexCompatible(0, 0, vertices[2]));
+
+  // Layer 0 ROF 1: [100, 200) - range includes idx 2 as false positive
+  {
+    const auto& range = view.getVertices(0, 1);
+    BOOST_CHECK_EQUAL(range.getEntries(), 3); // superset
+
+    size_t exactCount = 0;
+    for (size_t i = range.getFirstEntry(); i < range.getEntriesBound(); ++i) {
+      if (view.isVertexCompatible(0, 1, vertices[i])) {
+        ++exactCount;
+      }
+    }
+    // BOOST_CHECK_EQUAL(exactCount, 2); // idx 2 filtered out
+  }
+
+  // Layer 0 ROF 2: [200, 300) - nothing overlaps
+  BOOST_CHECK(!view.isVertexCompatible(0, 2, vertices[0]));
+  BOOST_CHECK(!view.isVertexCompatible(0, 2, vertices[1]));
+  BOOST_CHECK(!view.isVertexCompatible(0, 2, vertices[2]));
+
+  // Layer 2 ROF 0: [0, 50) - only idx 0
+  BOOST_CHECK(!view.isVertexCompatible(2, 0, vertices[0]));
+  BOOST_CHECK(!view.isVertexCompatible(2, 0, vertices[1]));
+
+  // Layer 2 ROF 1: [50, 100) - idx 0 and 1
+  BOOST_CHECK(!view.isVertexCompatible(2, 1, vertices[0]));
+  BOOST_CHECK(!view.isVertexCompatible(2, 1, vertices[1]));
+  BOOST_CHECK(!view.isVertexCompatible(2, 1, vertices[2]));
+
+  // Layer 2 ROF 3: [150, 200) - only idx 0
+  BOOST_CHECK(view.isVertexCompatible(2, 3, vertices[0]));
+  BOOST_CHECK(!view.isVertexCompatible(2, 3, vertices[1]));
+
+  // Layer 3 ROF 0: [40, 110) - all three genuine
+  BOOST_CHECK(view.isVertexCompatible(3, 0, vertices[0]));
+  BOOST_CHECK(view.isVertexCompatible(3, 0, vertices[1]));
+  BOOST_CHECK(view.isVertexCompatible(3, 0, vertices[2]));
+
+  // Layer 3 ROF 2: [140, 210) - only idx 0
+  BOOST_CHECK(view.isVertexCompatible(3, 2, vertices[0]));
+  BOOST_CHECK(!view.isVertexCompatible(3, 2, vertices[1]));
+  BOOST_CHECK(!view.isVertexCompatible(3, 2, vertices[2]));
+}
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterWorkflow.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterWorkflow.h
index 15c22f9bcf23d..a91038b32a1c1 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterWorkflow.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterWorkflow.h
@@ -23,7 +23,7 @@ namespace its
 
 namespace cluster_writer_workflow
 {
-framework::WorkflowSpec getWorkflow(bool useMC);
+framework::WorkflowSpec getWorkflow(bool useMC, bool doStag);
 }
 
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/DCSAdaposParserSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/DCSAdaposParserSpec.h
index bcc19ff15b85d..808fef81b586f 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/DCSAdaposParserSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/DCSAdaposParserSpec.h
@@ -37,7 +37,7 @@
 #include "DetectorsDCS/DataPointIdentifier.h"
 #include "DetectorsDCS/DataPointValue.h"
 #include "DetectorsDCS/DataPointCompositeObject.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "CCDB/BasicCCDBManager.h"
 
 using namespace o2::framework;
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
index 1d5d829a6f79a..bfbde0093d55d 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
@@ -26,7 +26,7 @@ namespace its
 namespace reco_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
+framework::WorkflowSpec getWorkflow(bool useMC, bool doStag, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
                                     bool upstreamDigits = false, bool upstreamClusters = false, bool disableRootOutput = false, bool useGeom = false, int useTrig = 0,
                                     bool useGPUWF = false, o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackReaderSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackReaderSpec.h
index 8666864ca1ae9..f4bcba750723f 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackReaderSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackReaderSpec.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -14,28 +14,26 @@
 #ifndef O2_ITS_TRACKREADER
 #define O2_ITS_TRACKREADER
 
-#include "TFile.h"
-#include "TTree.h"
+#include <TFile.h>
+#include <TTree.h>
 
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "Headers/DataHeader.h"
-#include "ITStracking/Definitions.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
 #include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsITS/Vertex.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
-#include "DataFormatsITSMFT/ROFRecord.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 
-class TrackReader : public o2::framework::Task
+class TrackReader final : public o2::framework::Task
 {
  public:
-  TrackReader(bool useMC = true);
-  ~TrackReader() override = default;
+  TrackReader(bool useMC = true) : mUseMC(useMC) {}
+  ~TrackReader() final = default;
   void init(o2::framework::InitContext& ic) final;
   void run(o2::framework::ProcessingContext& pc) final;
 
@@ -43,9 +41,9 @@ class TrackReader : public o2::framework::Task
   void connectTree(const std::string& filename);
 
   std::vector<o2::itsmft::ROFRecord> mROFRec, *mROFRecInp = &mROFRec;
-  std::vector<o2::itsmft::ROFRecord> mVerticesROFRec, *mVerticesROFRecInp = &mVerticesROFRec;
   std::vector<o2::its::TrackITS> mTracks, *mTracksInp = &mTracks;
   std::vector<Vertex> mVertices, *mVerticesInp = &mVertices;
+  std::vector<o2::itsmft::ROFRecord> mVerticesROFRec, *mVerticesROFRecInp = &mVerticesROFRec;
   std::vector<int> mClusInd, *mClusIndInp = &mClusInd;
   std::vector<o2::MCCompLabel> mMCTruth, *mMCTruthInp = &mMCTruth;
   std::vector<o2::MCCompLabel> mMCVertTruth, *mMCVTruthInp = &mMCTruth;
@@ -56,7 +54,7 @@ class TrackReader : public o2::framework::Task
 
   std::unique_ptr<TFile> mFile;
   std::unique_ptr<TTree> mTree;
-  std::string mInputFileName = "";
+  std::string mInputFileName;
   std::string mTrackTreeName = "o2sim";
   std::string mROFBranchName = "ITSTracksROF";
   std::string mTrackBranchName = "ITSTrack";
@@ -71,7 +69,6 @@ class TrackReader : public o2::framework::Task
 /// read ITS track data from a root file
 framework::DataProcessorSpec getITSTrackReaderSpec(bool useMC = true);
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 
 #endif /* O2_ITS_TRACKREADER */
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
index 01eb7cb7b69aa..8ce63efcb7a3b 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/TrackerSpec.h
@@ -42,6 +42,7 @@ class TrackerDPL : public framework::Task
  public:
   TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
              bool isMC,
+             bool doStag,
              int trgType,
              const TrackingMode::Type trMode = TrackingMode::Unset,
              const bool overrBeamEst = false,
@@ -63,7 +64,7 @@ class TrackerDPL : public framework::Task
   TStopwatch mTimer;
 };
 
-framework::DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int useTrig, TrackingMode::Type trMode, const bool overrBeamEst = false, o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, bool doStag, bool useGeom, int useTrig, TrackingMode::Type trMode, const bool overrBeamEst = false, o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
 
 } // namespace o2::its
 
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/VertexReaderSpec.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/VertexReaderSpec.h
index b300967408256..10ee70eeafeea 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/VertexReaderSpec.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/VertexReaderSpec.h
@@ -19,8 +19,8 @@
 
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
-#include "ITStracking/Definitions.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsITS/Vertex.h"
 
 namespace o2
 {
diff --git a/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
index aba468b3e9460..35c911f856436 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
@@ -22,11 +22,11 @@ namespace its
 namespace cluster_writer_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC)
+framework::WorkflowSpec getWorkflow(bool useMC, bool doStag)
 {
   framework::WorkflowSpec specs;
 
-  specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC));
+  specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC, doStag));
 
   return specs;
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index 9f8cb6c83ef99..5da4b080995b5 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -27,7 +27,7 @@
 namespace o2::its::reco_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC,
+framework::WorkflowSpec getWorkflow(bool useMC, bool doStag,
                                     TrackingMode::Type trmode,
                                     const bool overrideBeamPosition,
                                     bool upstreamDigits,
@@ -40,13 +40,13 @@ framework::WorkflowSpec getWorkflow(bool useMC,
 {
   framework::WorkflowSpec specs;
   if (!(upstreamDigits || upstreamClusters)) {
-    specs.emplace_back(o2::itsmft::getITSDigitReaderSpec(useMC, false, true, "itsdigits.root"));
+    specs.emplace_back(o2::itsmft::getITSDigitReaderSpec(useMC, doStag, false, true, "itsdigits.root"));
   }
   if (!upstreamClusters) {
-    specs.emplace_back(o2::itsmft::getITSClustererSpec(useMC));
+    specs.emplace_back(o2::itsmft::getITSClustererSpec(useMC, doStag));
   }
   if (!disableRootOutput) {
-    specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC));
+    specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC, doStag));
   }
   if ((trmode != TrackingMode::Off) && (TrackerParamConfig::Instance().trackingMode != TrackingMode::Off)) {
     if (useGPUWF) {
@@ -54,6 +54,7 @@ framework::WorkflowSpec getWorkflow(bool useMC,
         .itsTriggerType = useTrig,
         .processMC = useMC,
         .runITSTracking = true,
+        .itsStaggered = doStag,
         .itsOverrBeamEst = overrideBeamPosition,
       };
 
@@ -78,7 +79,7 @@ framework::WorkflowSpec getWorkflow(bool useMC,
         .algorithm = AlgorithmSpec{adoptTask<o2::gpu::GPURecoWorkflowSpec>(task)},
         .options = taskOptions});
     } else {
-      specs.emplace_back(o2::its::getTrackerSpec(useMC, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
+      specs.emplace_back(o2::its::getTrackerSpec(useMC, doStag, useGeom, useTrig, trmode, overrideBeamPosition, dtype));
     }
     if (!disableRootOutput) {
       specs.emplace_back(o2::its::getTrackWriterSpec(useMC));
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackReaderSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackReaderSpec.cxx
index 8e72faae9fd37..2f081a11c28b9 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackReaderSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackReaderSpec.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -15,21 +15,14 @@
 #include <cassert>
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
+#include "CommonUtils/StringUtils.h"
 #include "ITSWorkflow/TrackReaderSpec.h"
-#include "CommonUtils/NameConf.h"
 
 using namespace o2::framework;
 using namespace o2::its;
 
-namespace o2
+namespace o2::its
 {
-namespace its
-{
-
-TrackReader::TrackReader(bool useMC)
-{
-  mUseMC = useMC;
-}
 
 void TrackReader::init(InitContext& ic)
 {
@@ -43,7 +36,7 @@ void TrackReader::run(ProcessingContext& pc)
   auto ent = mTree->GetReadEntry() + 1;
   assert(ent < mTree->GetEntries()); // this should not happen
   mTree->GetEntry(ent);
-  LOG(info) << "Pushing " << mTracks.size() << " track in " << mROFRec.size() << " ROFs at entry " << ent;
+  LOG(info) << "Pushing " << mTracks.size() << " track at entry " << ent;
   pc.outputs().snapshot(Output{mOrigin, "ITSTrackROF", 0}, mROFRec);
   pc.outputs().snapshot(Output{mOrigin, "TRACKS", 0}, mTracks);
   pc.outputs().snapshot(Output{mOrigin, "TRACKCLSID", 0}, mClusInd);
@@ -77,12 +70,6 @@ void TrackReader::connectTree(const std::string& filename)
   } else {
     mTree->SetBranchAddress(mVertexBranchName.c_str(), &mVerticesInp);
   }
-  if (!mTree->GetBranch(mVertexROFBranchName.c_str())) {
-    LOG(warning) << "No " << mVertexROFBranchName << " branch in " << mTrackTreeName
-                 << " -> vertices ROFrecords will be empty";
-  } else {
-    mTree->SetBranchAddress(mVertexROFBranchName.c_str(), &mVerticesROFRecInp);
-  }
   if (mUseMC) {
     if (mTree->GetBranch(mTrackMCTruthBranchName.c_str())) {
       mTree->SetBranchAddress(mTrackMCTruthBranchName.c_str(), &mMCTruthInp);
@@ -107,14 +94,13 @@ DataProcessorSpec getITSTrackReaderSpec(bool useMC)
   }
 
   return DataProcessorSpec{
-    "its-track-reader",
-    Inputs{},
-    outputSpec,
-    AlgorithmSpec{adaptFromTask<TrackReader>(useMC)},
-    Options{
+    .name = "its-track-reader",
+    .inputs = Inputs{},
+    .outputs = outputSpec,
+    .algorithm = AlgorithmSpec{adaptFromTask<TrackReader>(useMC)},
+    .options = Options{
       {"its-tracks-infile", VariantType::String, "o2trac_its.root", {"Name of the input track file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
 }
 
-} // namespace its
-} // namespace o2
+} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
index c10b4aa32f054..84f43ee148302 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackWriterSpec.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -19,8 +19,7 @@
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
-#include "ITStracking/Definitions.h"
-#include "ITStracking/TrackingConfigParam.h"
+#include "DataFormatsITS/Vertex.h"
 
 using namespace o2::framework;
 
@@ -39,8 +38,7 @@ DataProcessorSpec getTrackWriterSpec(bool useMC)
 {
   // Spectators for logging
   // this is only to restore the original behavior
-  const auto writeContLabels = VertexerParamConfig::Instance().outputContLabels && useMC;
-  auto tracksSize = std::make_shared<int>(0);
+  auto tracksSize = std::make_shared<size_t>(0);
   auto tracksSizeGetter = [tracksSize](std::vector<o2::its::TrackITS> const& tracks) {
     *tracksSize = tracks.size();
   };
@@ -57,11 +55,11 @@ DataProcessorSpec getTrackWriterSpec(bool useMC)
                                                                    "ITSTrackClusIdx"},
                                 BranchDefinition<std::vector<Vertex>>{InputSpec{"vertices", "ITS", "VERTICES", 0},
                                                                       "Vertices"},
-                                BranchDefinition<std::vector<o2::itsmft::ROFRecord>>{InputSpec{"vtxROF", "ITS", "VERTICESROF", 0},
-                                                                                     "VerticesROF"},
                                 BranchDefinition<std::vector<o2::itsmft::ROFRecord>>{InputSpec{"ROframes", "ITS", "ITSTrackROF", 0},
                                                                                      "ITSTracksROF",
                                                                                      logger},
+                                BranchDefinition<std::vector<o2::itsmft::ROFRecord>>{InputSpec{"vtxROF", "ITS", "VERTICESROF", 0},
+                                                                                     "VerticesROF"},
                                 BranchDefinition<LabelsType>{InputSpec{"labels", "ITS", "TRACKSMCTR", 0},
                                                              "ITSTrackMCTruth",
                                                              (useMC ? 1 : 0), // one branch if mc labels enabled
@@ -70,15 +68,6 @@ DataProcessorSpec getTrackWriterSpec(bool useMC)
                                                              "ITSVertexMCTruth",
                                                              (useMC ? 1 : 0), // one branch if mc labels enabled
                                                              ""},
-                                BranchDefinition<LabelsType>{InputSpec{"labelsVerticesContributors", "ITS", "VERTICESMCTRCONT", 0},
-                                                             "ITSVertexMCTruthCont",
-                                                             (writeContLabels ? 1 : 0), // one branch if
-                                                                                        // requested
-                                                             ""},
-                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", "ITS", "ITSTrackMC2ROF", 0},
-                                                             "ITSTracksMC2ROF",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""},
                                 BranchDefinition<std::vector<float>>{InputSpec{"purityVertices", "ITS", "VERTICESMCPUR", 0},
                                                                      "ITSVertexMCPurity", (useMC ? 1 : 0), // one branch if mc labels enabled
                                                                      ""})();
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackWriterWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackWriterWorkflow.cxx
index ae2cb3648ec86..ce1d238188ec5 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackWriterWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackWriterWorkflow.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -31,4 +31,4 @@ framework::WorkflowSpec getWorkflow(bool useMC)
 
 } // namespace track_writer_workflow
 } // namespace its
-} // namespace o2
\ No newline at end of file
+} // namespace o2
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index 3d07048aaf1e6..932c82c2d1ca4 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -15,6 +15,7 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/CCDBParamSpec.h"
 #include "Framework/DeviceSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSWorkflow/TrackerSpec.h"
 #include "ITStracking/Definitions.h"
 #include "ITStracking/TrackingConfigParam.h"
@@ -26,12 +27,13 @@ namespace its
 {
 TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        bool isMC,
+                       bool doStag,
                        int trgType,
                        const TrackingMode::Type trMode,
                        const bool overrBeamEst,
                        o2::gpu::gpudatatypes::DeviceType dType) : mGGCCDBRequest(gr),
                                                                   mRecChain{o2::gpu::GPUReconstruction::CreateInstance(dType, true)},
-                                                                  mITSTrackingInterface{isMC, trgType, overrBeamEst}
+                                                                  mITSTrackingInterface{isMC, doStag, trgType, overrBeamEst}
 {
   mITSTrackingInterface.setTrackingMode(trMode);
 }
@@ -87,13 +89,18 @@ void TrackerDPL::end()
   LOGF(info, "ITS CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::gpudatatypes::DeviceType dType)
+DataProcessorSpec getTrackerSpec(bool useMC, bool doStag, bool useGeom, int trgType, TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::gpudatatypes::DeviceType dType)
 {
+  const int mLayers = doStag ? o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::getNLayers() : 1;
   std::vector<InputSpec> inputs;
-
-  inputs.emplace_back("compClusters", "ITS", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("patterns", "ITS", "PATTERNS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ROframes", "ITS", "CLUSTERSROF", 0, Lifetime::Timeframe);
+  for (int iLayer = 0; iLayer < mLayers; ++iLayer) {
+    inputs.emplace_back("compClusters", "ITS", "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
+    inputs.emplace_back("patterns", "ITS", "PATTERNS", iLayer, Lifetime::Timeframe);
+    inputs.emplace_back("ROframes", "ITS", "CLUSTERSROF", iLayer, Lifetime::Timeframe);
+    if (useMC) {
+      inputs.emplace_back("itsmclabels", "ITS", "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
+    }
+  }
   if (trgType == 1) {
     inputs.emplace_back("phystrig", "ITS", "PHYSTRIG", 0, Lifetime::Timeframe);
   } else if (trgType == 2) {
@@ -123,30 +130,24 @@ DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int trgType, Tracking
   outputs.emplace_back("ITS", "VERTICES", 0, Lifetime::Timeframe);
   outputs.emplace_back("ITS", "VERTICESROF", 0, Lifetime::Timeframe);
   outputs.emplace_back("ITS", "IRFRAMES", 0, Lifetime::Timeframe);
-
   if (useMC) {
-    inputs.emplace_back("itsmclabels", "ITS", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    inputs.emplace_back("ITSMC2ROframes", "ITS", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "VERTICESMCTR", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "VERTICESMCPUR", 0, Lifetime::Timeframe);
     outputs.emplace_back("ITS", "TRACKSMCTR", 0, Lifetime::Timeframe);
-    outputs.emplace_back("ITS", "ITSTrackMC2ROF", 0, Lifetime::Timeframe);
-    if (VertexerParamConfig::Instance().outputContLabels) {
-      outputs.emplace_back("ITS", "VERTICESMCTRCONT", 0, Lifetime::Timeframe);
-    }
   }
 
   return DataProcessorSpec{
-    "its-tracker",
-    inputs,
-    outputs,
-    AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
-                                            useMC,
-                                            trgType,
-                                            trMode,
-                                            overrBeamEst,
-                                            dType)},
-    Options{}};
+    .name = "its-tracker",
+    .inputs = inputs,
+    .outputs = outputs,
+    .algorithm = AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
+                                                         useMC,
+                                                         doStag,
+                                                         trgType,
+                                                         trMode,
+                                                         overrBeamEst,
+                                                         dType)},
+    .options = Options{}};
 }
 
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-cluster-reader-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-cluster-reader-workflow.cxx
index da843526f9296..cbbb4bea09f4b 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-cluster-reader-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-cluster-reader-workflow.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "Framework/ConfigParamSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
@@ -47,6 +48,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
       VariantType::String,
       "",
       {"Semicolon separated key=value strings"}});
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(workflowOptions);
   o2::raw::HBFUtilsInitializer::addConfigOption(workflowOptions);
 }
 
@@ -60,8 +62,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cc)
   auto withTriggers = !cc.options().get<bool>("suppress-triggers-output");
   auto withMC = cc.options().get<bool>("with-mc");
   auto withPatterns = !cc.options().get<bool>("without-patterns");
+  auto doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(cc);
 
-  specs.emplace_back(o2::itsmft::getITSClusterReaderSpec(withMC, withPatterns, withTriggers));
+  specs.emplace_back(o2::itsmft::getITSClusterReaderSpec(withMC, doStag, withPatterns, withTriggers));
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(cc, specs);
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-cluster-writer-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-cluster-writer-workflow.cxx
index ad3d8eea6e636..c10a1659d5f76 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-cluster-writer-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-cluster-writer-workflow.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "ITSWorkflow/ClusterWriterWorkflow.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/CompletionPolicyHelpers.h"
 
@@ -29,13 +30,14 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
       o2::framework::VariantType::Bool,
       false,
       {"disable MC propagation even if available"}});
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(workflowOptions);
 }
 
 #include "Framework/runDataProcessing.h"
-#include "Framework/Logger.h"
 
 WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   auto useMC = !configcontext.options().get<bool>("disable-mc");
-  return std::move(o2::its::cluster_writer_workflow::getWorkflow(useMC));
+  auto doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext);
+  return std::move(o2::its::cluster_writer_workflow::getWorkflow(useMC, doStag));
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
index 8080883888d40..bdade0effcbf0 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "ITSWorkflow/RecoWorkflow.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "ITStracking/Configuration.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
@@ -50,6 +51,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight ITS part"}},
     {"use-gpu-workflow", o2::framework::VariantType::Bool, false, {"use GPU workflow (default: false)"}},
     {"gpu-device", o2::framework::VariantType::Int, 1, {"use gpu device: CPU=1,CUDA=2,HIP=3 (default: CPU)"}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -72,6 +74,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto extClusters = configcontext.options().get<bool>("clusters-from-upstream");
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
+  auto doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext);
   if (configcontext.options().get<bool>("disable-tracking")) {
     trmode = "off";
   }
@@ -87,16 +90,18 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
       LOG(fatal) << "Unknown trigger type requested for events prescaling: " << selTrig;
     }
   }
-  auto wf = o2::its::reco_workflow::getWorkflow(useMC,
-                                                o2::its::TrackingMode::fromString(trmode),
-                                                beamPosOVerride,
-                                                extDigits,
-                                                extClusters,
-                                                disableRootOutput,
-                                                useGeom,
-                                                trType,
-                                                useGpuWF,
-                                                gpuDevice);
+  auto wf = o2::its::reco_workflow::getWorkflow(
+    useMC,
+    doStag,
+    o2::its::TrackingMode::fromString(trmode),
+    beamPosOVerride,
+    extDigits,
+    extClusters,
+    disableRootOutput,
+    useGeom,
+    trType,
+    useGpuWF,
+    gpuDevice);
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, wf);
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-track-writer-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-track-writer-workflow.cxx
index d06ab366ef54c..ebd10ab3b16ce 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-track-writer-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-track-writer-workflow.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -27,7 +27,6 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 }
 
 #include "Framework/runDataProcessing.h"
-#include "Framework/Logger.h"
 
 WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
diff --git a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
index 86107106dc2ba..e55e822847177 100644
--- a/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
+++ b/Detectors/ITSMFT/MFT/calibration/src/NoiseCalibratorSpec.cxx
@@ -18,7 +18,7 @@
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSMFTReconstruction/ClustererParam.h"
 
 #include <fairlogger/Logger.h>
diff --git a/Detectors/ITSMFT/MFT/condition/include/MFTCondition/DCSConfigReader.h b/Detectors/ITSMFT/MFT/condition/include/MFTCondition/DCSConfigReader.h
index efae3104279e1..110465bb92757 100644
--- a/Detectors/ITSMFT/MFT/condition/include/MFTCondition/DCSConfigReader.h
+++ b/Detectors/ITSMFT/MFT/condition/include/MFTCondition/DCSConfigReader.h
@@ -14,7 +14,7 @@
 
 #include "Rtypes.h"
 #include "DataFormatsITSMFT/NoiseMap.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "MFTCondition/DCSConfigInfo.h"
 #include "MFTCondition/DCSConfigUtils.h"
 #include <gsl/span>
diff --git a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/RecoWorkflow.h b/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/RecoWorkflow.h
index 0e0b8af1da70a..51234e2e8017d 100644
--- a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/RecoWorkflow.h
+++ b/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/RecoWorkflow.h
@@ -25,6 +25,7 @@ namespace reco_workflow
 {
 framework::WorkflowSpec getWorkflow(
   bool useMC,
+  bool doStag,
   bool useGeom,
   bool upstreamDigits,
   bool upstreamClusters,
diff --git a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/TrackerSpec.h b/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/TrackerSpec.h
index 4274710b23867..8bd290caf5a41 100644
--- a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/TrackerSpec.h
+++ b/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/TrackerSpec.h
@@ -16,7 +16,7 @@
 
 #include "MFTTracking/Tracker.h"
 #include "DetectorsBase/GRPGeomHelper.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 
 #include "Framework/DataProcessorSpec.h"
 #include "MFTTracking/TrackCA.h"
diff --git a/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
index 5d85c0ef81670..fb99715cae4ee 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
@@ -32,6 +32,7 @@ namespace reco_workflow
 
 framework::WorkflowSpec getWorkflow(
   bool useMC,
+  bool doStag,
   bool useGeom,
   bool upstreamDigits,
   bool upstreamClusters,
@@ -45,17 +46,17 @@ framework::WorkflowSpec getWorkflow(
   framework::WorkflowSpec specs;
 
   if (!(upstreamDigits || upstreamClusters)) {
-    specs.emplace_back(o2::itsmft::getMFTDigitReaderSpec(useMC, false, true, "mftdigits.root"));
+    specs.emplace_back(o2::itsmft::getMFTDigitReaderSpec(useMC, doStag, false, true, "mftdigits.root"));
     auto& trackingParam = MFTTrackingParam::Instance();
     if (trackingParam.irFramesOnly) {
       specs.emplace_back(o2::globaltracking::getIRFrameReaderSpec("ITS", 0, "its-irframe-reader", "o2_its_irframe.root"));
     }
   }
   if (!upstreamClusters) {
-    specs.emplace_back(o2::itsmft::getMFTClustererSpec(useMC));
+    specs.emplace_back(o2::itsmft::getMFTClustererSpec(useMC, doStag));
   }
   if (!disableRootOutput) {
-    specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC));
+    specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC, doStag));
   }
 
   if (runTracking) {
diff --git a/Detectors/ITSMFT/MFT/workflow/src/TrackWriterSpec.cxx b/Detectors/ITSMFT/MFT/workflow/src/TrackWriterSpec.cxx
index d9c132c97abdf..f8a848f6fde32 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/TrackWriterSpec.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/TrackWriterSpec.cxx
@@ -24,7 +24,6 @@
 
 using namespace o2::framework;
 using LabelsType = std::vector<o2::MCCompLabel>;
-using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
 
 namespace o2
 {
@@ -44,7 +43,7 @@ DataProcessorSpec getTrackWriterSpec(bool useMC)
     *tracksSize = tracks.size();
   };
   auto logger = [tracksSize](std::vector<o2::itsmft::ROFRecord> const& rofs) {
-    LOG(debug) << "MFTTrackWriter pulled " << *tracksSize << " tracks, in " << rofs.size() << " RO frames";
+    LOG(info) << "MFTTrackWriter pulled " << *tracksSize << " tracks, in " << rofs.size() << " RO frames";
   };
   return MakeRootTreeWriterSpec("mft-track-writer",
                                 "mfttracks.root",
@@ -54,15 +53,11 @@ DataProcessorSpec getTrackWriterSpec(bool useMC)
                                                                                  tracksSizeGetter},
                                 BranchDefinition<std::vector<int>>{InputSpec{"trackClIdx", "MFT", "TRACKCLSID", 0},
                                                                    "MFTTrackClusIdx"},
-                                BranchDefinition<LabelsType>{InputSpec{"labels", "MFT", "TRACKSMCTR", 0},
-                                                             "MFTTrackMCTruth",
-                                                             (useMC ? 1 : 0), // one branch if mc labels enabled
-                                                             ""},
                                 BranchDefinition<std::vector<o2::itsmft::ROFRecord>>{InputSpec{"ROframes", "MFT", "MFTTrackROF", 0},
                                                                                      "MFTTracksROF",
                                                                                      logger},
-                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", "MFT", "TRACKSMC2ROF", 0},
-                                                             "MFTTracksMC2ROF",
+                                BranchDefinition<LabelsType>{InputSpec{"labels", "MFT", "TRACKSMCTR", 0},
+                                                             "MFTTrackMCTruth",
                                                              (useMC ? 1 : 0), // one branch if mc labels enabled
                                                              ""})();
 }
diff --git a/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
index 3e726fe37c38c..a13a3402eb260 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
@@ -45,7 +45,7 @@ namespace o2
 {
 namespace mft
 {
-//#define _TIMING_
+// #define _TIMING_
 
 void TrackerDPL::init(InitContext& ic)
 {
@@ -98,12 +98,6 @@ void TrackerDPL::run(ProcessingContext& pc)
   }
 
   const dataformats::MCTruthContainer<MCCompLabel>* labels = mUseMC ? pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>("labels").release() : nullptr;
-  gsl::span<itsmft::MC2ROFRecord const> mc2rofs;
-  if (mUseMC) {
-    // get the array as read-only span, a snapshot of the object is sent forward
-    mc2rofs = pc.inputs().get<gsl::span<itsmft::MC2ROFRecord>>("MC2ROframes");
-    LOG(info) << labels->getIndexedSize() << " MC label objects , in " << mc2rofs.size() << " MC events";
-  }
 
   auto& allClusIdx = pc.outputs().make<std::vector<int>>(Output{"MFT", "TRACKCLSID", 0});
   std::vector<o2::MCCompLabel> trackLabels;
@@ -325,11 +319,10 @@ void TrackerDPL::run(ProcessingContext& pc)
     }
   }
 
-  LOG(info) << "MFTTracker pushed " << allTracksMFT.size() << " tracks";
+  LOG(info) << "MFTTracker pushed " << allTracksMFT.size() << " tracks in " << nROFs << " rofs";
 
   if (mUseMC) {
     pc.outputs().snapshot(Output{"MFT", "TRACKSMCTR", 0}, allTrackLabels);
-    pc.outputs().snapshot(Output{"MFT", "TRACKSMC2ROF", 0}, mc2rofs);
   }
 
   static bool first = true;
@@ -466,9 +459,7 @@ DataProcessorSpec getTrackerSpec(bool useMC, bool useGeom, int nThreads)
 
   if (useMC) {
     inputs.emplace_back("labels", "MFT", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    inputs.emplace_back("MC2ROframes", "MFT", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
     outputs.emplace_back("MFT", "TRACKSMCTR", 0, Lifetime::Timeframe);
-    outputs.emplace_back("MFT", "TRACKSMC2ROF", 0, Lifetime::Timeframe);
   }
 
   return DataProcessorSpec{
diff --git a/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-reader-workflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-reader-workflow.cxx
index 9907705fb1e7c..eaa525345fd9f 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-reader-workflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-reader-workflow.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "Framework/ConfigParamSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
 
@@ -41,6 +42,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
       false,
       {"do not propagate pixel patterns"}});
   workflowOptions.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}});
+  o2::itsmft::DPLAlpideParamInitializer::addMFTConfigOption(workflowOptions);
   o2::raw::HBFUtilsInitializer::addConfigOption(workflowOptions);
 }
 
@@ -53,7 +55,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cc)
   auto withTriggers = !cc.options().get<bool>("suppress-triggers-output");
   auto withMC = cc.options().get<bool>("with-mc");
   auto withPatterns = !cc.options().get<bool>("without-patterns");
-  specs.emplace_back(o2::itsmft::getMFTClusterReaderSpec(withMC, withPatterns, withTriggers));
+  auto doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(cc);
+  specs.emplace_back(o2::itsmft::getMFTClusterReaderSpec(withMC, doStag, withPatterns, withTriggers));
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(cc, specs);
diff --git a/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
index b656970693808..5a5112e03c866 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "ITSMFTWorkflow/ClusterWriterSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/CompletionPolicyHelpers.h"
 
@@ -25,15 +26,16 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 {
   workflowOptions.push_back(
     ConfigParamSpec{"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}});
+  o2::itsmft::DPLAlpideParamInitializer::addMFTConfigOption(workflowOptions);
 }
 
 #include "Framework/runDataProcessing.h"
-#include "Framework/Logger.h"
 
 WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   auto useMC = !configcontext.options().get<bool>("disable-mc");
+  auto doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
   WorkflowSpec specs;
-  specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC));
+  specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC, doStag));
   return specs;
 }
diff --git a/Detectors/ITSMFT/MFT/workflow/src/mft-reco-workflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/mft-reco-workflow.cxx
index 19e41ed984f11..11b4fc233c6b4 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/mft-reco-workflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/mft-reco-workflow.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "MFTWorkflow/RecoWorkflow.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
@@ -45,6 +46,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight MFT part"}},
     {"run-tracks2records", o2::framework::VariantType::Bool, false, {"run MFT alignment tracks to records workflow"}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
+  o2::itsmft::DPLAlpideParamInitializer::addMFTConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -67,9 +69,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto nThreads = configcontext.options().get<int>("nThreads");
   auto runTracks2Records = configcontext.options().get<bool>("run-tracks2records");
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
+  auto doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
 
   auto wf = o2::mft::reco_workflow::getWorkflow(
     useMC,
+    doStag,
     useGeom,
     extDigits,
     extClusters,
diff --git a/Detectors/ITSMFT/common/base/CMakeLists.txt b/Detectors/ITSMFT/common/base/CMakeLists.txt
index a3e0718d64a6b..43d60f6d2b11d 100644
--- a/Detectors/ITSMFT/common/base/CMakeLists.txt
+++ b/Detectors/ITSMFT/common/base/CMakeLists.txt
@@ -11,12 +11,10 @@
 
 o2_add_library(ITSMFTBase
                SOURCES src/SegmentationAlpide.cxx
-                       src/GeometryTGeo.cxx src/DPLAlpideParam.cxx
                PUBLIC_LINK_LIBRARIES O2::MathUtils
                                      O2::DetectorsCommonDataFormats
                                      O2::SimConfig)
 
 o2_target_root_dictionary(ITSMFTBase
                           HEADERS include/ITSMFTBase/SegmentationAlpide.h
-                                  include/ITSMFTBase/GeometryTGeo.h
-                                  include/ITSMFTBase/DPLAlpideParam.h)
+                                  include/ITSMFTBase/GeometryTGeo.h)
diff --git a/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h b/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h
index de39bed299634..e217808c06177 100644
--- a/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h
+++ b/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -9,110 +9,5 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#ifndef ALICEO2_ITSMFTDPLBASEPARAM_H_
-#define ALICEO2_ITSMFTDPLBASEPARAM_H_
-
-#include "DetectorsCommonDataFormats/DetID.h"
-#include "CommonUtils/ConfigurableParam.h"
-#include "CommonUtils/ConfigurableParamHelper.h"
-#include "CommonConstants/LHCConstants.h"
-#include <string_view>
-
-namespace o2
-{
-namespace itsmft
-{
-constexpr float DEFStrobeDelay = o2::constants::lhc::LHCBunchSpacingNS * 4; // ~100 ns delay
-
-template <int N>
-struct DPLAlpideParam : public o2::conf::ConfigurableParamHelper<DPLAlpideParam<N>> {
-  static constexpr int getNLayers()
-  {
-    return N == o2::detectors::DetID::ITS ? 7 : 10;
-  }
-
-  static constexpr std::string_view getParamName()
-  {
-    return N == o2::detectors::DetID::ITS ? ParamName[0] : ParamName[1];
-  }
-
-  int roFrameLengthInBC = DEFROFLengthBC();      ///< ROF length in BC for continuous mode
-  float roFrameLengthTrig = DEFROFLengthTrig();  ///< length of RO frame in ns for triggered mode
-  float strobeDelay = DEFStrobeDelay;            ///< strobe start (in ns) wrt ROF start
-  float strobeLengthCont = -1.;                  ///< if < 0, full ROF length - delay
-  float strobeLengthTrig = 100.;                 ///< length of the strobe in ns (sig. over threshold checked in this window only)
-  int roFrameBiasInBC = DEFROFBiasInBC();        ///< bias of the start of ROF wrt orbit start: t_irof = (irof*roFrameLengthInBC + roFrameBiasInBC)*BClengthMUS
-  int roFrameLayerLengthInBC[getNLayers()] = {}; ///< staggering ROF length in BC for continuous mode per layer
-  int roFrameLayerBiasInBC[getNLayers()] = {};   ///< staggering ROF bias in BC for continuous mode per layer
-  int roFrameLayerDelayInBC[getNLayers()] = {};  ///< staggering ROF delay in BC for continuous mode per layer
-
-  static constexpr bool supportsStaggering() noexcept { return (N == o2::detectors::DetID::ITS) ? false : false; }
-  // test if staggering is on
-  bool withStaggering() const noexcept
-  {
-    if constexpr (!supportsStaggering()) {
-      return false;
-    }
-    for (int i{0}; i < getNLayers(); ++i) {
-      if (roFrameLayerLengthInBC[i] != 0) {
-        return true;
-      }
-    }
-    return false;
-  }
-  // get ROF length for any layer
-  int getROFLengthInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerLengthInBC[layer] : roFrameLengthInBC; }
-  int getROFBiasInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerBiasInBC[layer] : roFrameBiasInBC; }
-  int getROFDelayInBC(int layer) const noexcept { return (withStaggering()) ? roFrameLayerDelayInBC[layer] : 0; }
-
-  // boilerplate stuff + make principal key
-  O2ParamDef(DPLAlpideParam, getParamName().data());
-
- private:
-  static constexpr std::string_view ParamName[2] = {"ITSAlpideParam", "MFTAlpideParam"};
-
-  static constexpr int DEFROFLengthBC()
-  {
-    // default ROF length in BC for continuous mode
-    // allowed values: 1,2,3,4,6,9,11,12,18,22,27,33,36
-    return N == o2::detectors::DetID::ITS ? o2::constants::lhc::LHCMaxBunches / 4 : o2::constants::lhc::LHCMaxBunches / 18;
-  }
-  static constexpr float DEFROFLengthTrig()
-  {
-    // length of RO frame in ns for triggered mode
-    return N == o2::detectors::DetID::ITS ? 6000. : 6000.;
-  }
-
-  static constexpr int DEFROFBiasInBC()
-  {
-    // default ROF length bias in MC, see https://github.com/AliceO2Group/AliceO2/pull/11108 for ITS
-    return N == o2::detectors::DetID::ITS ? 64 : 60;
-  }
-
-  static_assert(N == o2::detectors::DetID::ITS || N == o2::detectors::DetID::MFT, "only DetID::ITS orDetID:: MFT are allowed");
-  static_assert(o2::constants::lhc::LHCMaxBunches % DEFROFLengthBC() == 0); // make sure ROF length is divisor of the orbit
-};
-
-template <int N>
-DPLAlpideParam<N> DPLAlpideParam<N>::sInstance;
-
-} // namespace itsmft
-
-namespace framework
-{
-template <typename T>
-struct is_messageable;
-template <>
-struct is_messageable<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>> : std::true_type {
-};
-template <typename T>
-struct is_messageable;
-template <>
-struct is_messageable<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>> : std::true_type {
-};
-
-} // namespace framework
-
-} // namespace o2
-
-#endif
+// FIXME: temporary shim to no not break O2Physics
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
diff --git a/Detectors/ITSMFT/common/base/src/ITSMFTBaseLinkDef.h b/Detectors/ITSMFT/common/base/src/ITSMFTBaseLinkDef.h
index 6202f372cf2d3..9296c21e81cae 100644
--- a/Detectors/ITSMFT/common/base/src/ITSMFTBaseLinkDef.h
+++ b/Detectors/ITSMFT/common/base/src/ITSMFTBaseLinkDef.h
@@ -17,11 +17,6 @@
 
 #pragma link C++ class o2::itsmft::SegmentationAlpide + ;
 
-#pragma link C++ class o2::itsmft::DPLAlpideParam < o2::detectors::DetID::ITS> + ;
-#pragma link C++ class o2::itsmft::DPLAlpideParam < o2::detectors::DetID::MFT> + ;
-#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::itsmft::DPLAlpideParam < o2::detectors::DetID::ITS>> + ;
-#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::itsmft::DPLAlpideParam < o2::detectors::DetID::MFT>> + ;
-
 #pragma link C++ class o2::itsmft::GeometryTGeo;
 
 #endif
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
index 7e266052efb3c..4f9bc90c1c758 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
@@ -27,6 +27,7 @@
 #include "ITSMFTReconstruction/LookUp.h"
 #include "ITSMFTReconstruction/PixelData.h"
 #include "ITSMFTReconstruction/Clusterer.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsBase/CTFCoderBase.h"
 
@@ -39,19 +40,22 @@ namespace o2
 namespace itsmft
 {
 
+template <int N>
 class CTFCoder final : public o2::ctf::CTFCoderBase
 {
  public:
+  static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+
   using PMatrix = std::array<std::array<bool, ClusterPattern::MaxRowSpan + 2>, ClusterPattern::MaxColSpan + 2>;
   using RowColBuff = std::vector<PixelData>;
 
-  CTFCoder(o2::ctf::CTFCoderBase::OpType op, o2::detectors::DetID det, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), det, 1.f, ctfdictOpt) {}
+  CTFCoder(o2::ctf::CTFCoderBase::OpType op, bool doStag, const std::string& ctfdictOpt = "none") : o2::ctf::CTFCoderBase(op, CTF::getNBlocks(), ID, 1.f, ctfdictOpt), mDoStaggering(doStag) {}
   ~CTFCoder() final = default;
 
   /// entropy-encode clusters to buffer with CTF
   template <typename VEC>
   o2::ctf::CTFIOSize encode(VEC& buff, const gsl::span<const ROFRecord>& rofRecVec, const gsl::span<const CompClusterExt>& cclusVec,
-                            const gsl::span<const unsigned char>& pattVec, const LookUp& clPattLookup, int strobeLength);
+                            const gsl::span<const unsigned char>& pattVec, const LookUp& clPattLookup, int layer);
 
   /// entropy decode clusters from buffer with CTF
   template <typename VROF, typename VCLUS, typename VPAT>
@@ -79,16 +83,21 @@ class CTFCoder final : public o2::ctf::CTFCoderBase
   template <typename VROF, typename VDIG>
   void decompress(const CompressedClusters& compCl, VROF& rofRecVec, VDIG& digVec, const NoiseMap* noiseMap, const LookUp& clPattLookup);
 
-  void appendToTree(TTree& tree, CTF& ec);
-  void readFromTree(TTree& tree, int entry, std::vector<ROFRecord>& rofRecVec, std::vector<CompClusterExt>& cclusVec, std::vector<unsigned char>& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup);
+  void appendToTree(TTree& tree, CTF& ec, int id = -1);
+  void readFromTree(TTree& tree, int entry, int id, std::vector<ROFRecord>& rofRecVec, std::vector<CompClusterExt>& cclusVec, std::vector<unsigned char>& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup);
+
+  bool mDoStaggering{false};
 };
 
 /// entropy-encode clusters to buffer with CTF
+template <int N>
 template <typename VEC>
-o2::ctf::CTFIOSize CTFCoder::encode(VEC& buff, const gsl::span<const ROFRecord>& rofRecVec, const gsl::span<const CompClusterExt>& cclusVec,
-                                    const gsl::span<const unsigned char>& pattVec, const LookUp& clPattLookup, int strobeLength)
+o2::ctf::CTFIOSize CTFCoder<N>::encode(VEC& buff, const gsl::span<const ROFRecord>& rofRecVec, const gsl::span<const CompClusterExt>& cclusVec,
+                                       const gsl::span<const unsigned char>& pattVec, const LookUp& clPattLookup, int layer)
 {
   using MD = o2::ctf::Metadata::OptStore;
+  const auto& par = DPLAlpideParam<N>::Instance();
+  int strobeLength = mDoStaggering ? par.roFrameLayerLengthInBC[layer] : par.roFrameLengthInBC;
   // what to do which each field: see o2::ctd::Metadata explanation
   constexpr MD optField[CTF::getNBlocks()] = {
     MD::EENCODE_OR_PACK, // BLCfirstChipROF
@@ -104,6 +113,8 @@ o2::ctf::CTFIOSize CTFCoder::encode(VEC& buff, const gsl::span<const ROFRecord>&
   };
   CompressedClusters compCl;
   compress(compCl, rofRecVec, cclusVec, pattVec, clPattLookup, strobeLength);
+  compCl.header.maxStreams = mDoStaggering ? par.getNLayers() : 1;
+  compCl.header.streamID = mDoStaggering ? layer : 0;
   // book output size with some margin
   auto szIni = estimateCompressedSize(compCl);
   buff.resize(szIni);
@@ -136,19 +147,26 @@ o2::ctf::CTFIOSize CTFCoder::encode(VEC& buff, const gsl::span<const ROFRecord>&
 }
 
 /// decode entropy-encoded clusters to standard compact clusters
+template <int N>
 template <typename VROF, typename VCLUS, typename VPAT>
-o2::ctf::CTFIOSize CTFCoder::decode(const CTF::base& ec, VROF& rofRecVec, VCLUS& cclusVec, VPAT& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
+o2::ctf::CTFIOSize CTFCoder<N>::decode(const CTF::base& ec, VROF& rofRecVec, VCLUS& cclusVec, VPAT& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
 {
   o2::ctf::CTFIOSize iosize;
   auto compCl = decodeCompressedClusters(ec, iosize);
+  const auto& par = DPLAlpideParam<N>::Instance();
+  uint32_t nLayers = mDoStaggering ? par.getNLayers() : 1;
+  if (compCl.header.maxStreams != nLayers) {
+    throw std::runtime_error(fmt::format("header maxStreams={} is not the same as NStreams={} in {}staggered mode", compCl.header.maxStreams, nLayers, mDoStaggering ? "" : "non-"));
+  }
   decompress(compCl, rofRecVec, cclusVec, pattVec, noiseMap, clPattLookup);
   iosize.rawIn = rofRecVec.size() * sizeof(ROFRecord) + cclusVec.size() * sizeof(CompClusterExt) + pattVec.size() * sizeof(unsigned char);
   return iosize;
 }
 
 /// decode entropy-encoded clusters to digits
+template <int N>
 template <typename VROF, typename VDIG>
-o2::ctf::CTFIOSize CTFCoder::decode(const CTF::base& ec, VROF& rofRecVec, VDIG& digVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
+o2::ctf::CTFIOSize CTFCoder<N>::decode(const CTF::base& ec, VROF& rofRecVec, VDIG& digVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
 {
   o2::ctf::CTFIOSize iosize;
   auto compCl = decodeCompressedClusters(ec, iosize);
@@ -158,8 +176,9 @@ o2::ctf::CTFIOSize CTFCoder::decode(const CTF::base& ec, VROF& rofRecVec, VDIG&
 }
 
 /// decompress compressed clusters to standard compact clusters
+template <int N>
 template <typename VROF, typename VCLUS, typename VPAT>
-void CTFCoder::decompress(const CompressedClusters& compCl, VROF& rofRecVec, VCLUS& cclusVec, VPAT& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
+void CTFCoder<N>::decompress(const CompressedClusters& compCl, VROF& rofRecVec, VCLUS& cclusVec, VPAT& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
 {
   PMatrix pmat{};
   RowColBuff firedPixBuff{}, maskedPixBuff{};
@@ -343,8 +362,9 @@ void CTFCoder::decompress(const CompressedClusters& compCl, VROF& rofRecVec, VCL
 }
 
 /// decompress compressed clusters to digits
+template <int N>
 template <typename VROF, typename VDIG>
-void CTFCoder::decompress(const CompressedClusters& compCl, VROF& rofRecVec, VDIG& digVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
+void CTFCoder<N>::decompress(const CompressedClusters& compCl, VROF& rofRecVec, VDIG& digVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
 {
   rofRecVec.resize(compCl.header.nROFs);
   digVec.reserve(compCl.header.nClusters * 2);
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingITS.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingITS.h
index 45668ca507280..6110a8492d416 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingITS.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingITS.h
@@ -310,6 +310,9 @@ class ChipMappingITS
 
   std::vector<Overlaps> getOverlapsInfo() const;
 
+  ///< Collect all FEEIDs for one layer (lr>=0) or all (lr==-1)
+  std::vector<uint16_t> getLayer2FEEIDs(int lr);
+
   // sub-barrel types, their number, N layers, Max N GBT Links per RU
   static constexpr int IB = 0, MB = 1, OB = 2, NSubB = 3, NLayers = 7, NLinks = 3;
 
@@ -395,7 +398,7 @@ class ChipMappingITS
   std::vector<uint8_t> mCablePos[NSubB];         ///< table of cables positions in the ActiveLanes mask for each RU type (sequential numbering)
   std::vector<uint8_t> mCableHWFirstChip[NSubB]; ///< 1st chip of module (relative to the 1st chip of the stave) served by each cable
 
-  std::array<int, NSubB> mCablesOnStaveSB = {0}; ///< pattern of cables per stave of sub-barrel
+  std::array<int, NSubB> mCablesOnStaveSB = {0};                                       ///< pattern of cables per stave of sub-barrel
   std::array<std::array<uint8_t, 15>, MaxHWCableID[MB] + 1> HWCableHWChip2ChipOnRU_MB; // mapping from HW cable ID / HW chip ID to Chip on RU, 255 means NA
   std::array<std::array<uint8_t, 15>, MaxHWCableID[OB] + 1> HWCableHWChip2ChipOnRU_OB; // mapping from HW cable ID / HW chip ID to Chip on RU, 255 means NA
 
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h
index 3fa94c2628f3a..eee9bdbb6a4dc 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h
@@ -266,6 +266,9 @@ class ChipMappingMFT
 
   const auto& getModuleMappingData() const { return ModuleMappingData; }
 
+  ///< Collect all FEEIDs for one layer (lr>=0) or all (lr==-1)
+  std::vector<uint16_t> getLayer2FEEIDs(int lr);
+
   void print() const;
 
   ///< LayerID of each MFT chip
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/PixelReader.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/PixelReader.h
index 80ef5ed7abec8..b98abf1d9b2d4 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/PixelReader.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/PixelReader.h
@@ -50,11 +50,6 @@ class PixelReader
   {
     return nullptr;
   }
-  const o2::InteractionRecord& getInteractionRecordHB() const
-  {
-    return mInteractionRecordHB;
-  }
-
   const o2::InteractionRecord& getInteractionRecord() const
   {
     return mInteractionRecord;
@@ -70,8 +65,7 @@ class PixelReader
   //
  protected:
   //
-  o2::InteractionRecord mInteractionRecord = {};   // interation record for the trigger
-  o2::InteractionRecord mInteractionRecordHB = {}; // interation record for the HB
+  o2::InteractionRecord mInteractionRecord = {}; // interation record for the trigger
   uint32_t mTrigger = 0;
   bool mDecodeNextAuto = true; // try to fetch/decode next trigger when getNextChipData does not see any decoded data
 
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelDecoder.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelDecoder.h
index 3a53253da2b42..b10f60c749f7c 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelDecoder.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelDecoder.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -14,9 +14,11 @@
 #ifndef ALICEO2_ITSMFT_RAWPIXELDECODER_H_
 #define ALICEO2_ITSMFT_RAWPIXELDECODER_H_
 
+#include <unordered_map>
 #include <array>
 #include <TStopwatch.h>
 #include "Framework/Logger.h"
+#include "Framework/InputSpec.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
 #include "ITSMFTReconstruction/ChipMappingMFT.h"
 #include "DetectorsRaw/HBFUtils.h"
@@ -29,7 +31,6 @@
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITSMFTReconstruction/PixelData.h"
 #include "ITSMFTReconstruction/GBTWord.h"
-#include <unordered_map>
 
 namespace o2
 {
@@ -91,6 +92,9 @@ class RawPixelDecoder final : public PixelReader
   void setVerbosity(int v);
   int getVerbosity() const { return mVerbosity; }
 
+  void setInputFilter(std::vector<o2::framework::InputSpec> filter) { mInputFilter = std::move(filter); }
+  const auto& getInputFilter() const noexcept { return mInputFilter; }
+
   void setAlwaysParseTrigger(bool v) { mAlwaysParseTrigger = v; }
   bool getAlwaysParseTrigger() const { return mAlwaysParseTrigger; }
 
@@ -138,7 +142,7 @@ class RawPixelDecoder final : public PixelReader
   void reset();
 
  private:
-  void setupLinks(o2::framework::InputRecord& inputs);
+  void setupLinks(o2::framework::InputRecord& inputsm);
   int getRUEntrySW(int ruSW) const { return mRUEntry[ruSW]; }
   RUDecodeData* getRUDecode(int ruSW) { return &mRUDecodeVec[mRUEntry[ruSW]]; }
   GBTLink* getGBTLink(int i) { return i < 0 ? nullptr : &mGBTLinks[i]; }
@@ -146,6 +150,7 @@ class RawPixelDecoder final : public PixelReader
 
   static constexpr uint16_t NORUDECODED = 0xffff; // this must be > than max N RUs
 
+  std::vector<o2::framework::InputSpec> mInputFilter;                                 //  input spec filter
   std::vector<GBTLink> mGBTLinks;                                                     // active links pool
   std::unordered_map<uint32_t, LinkEntry> mSubsSpec2LinkID;                           // link subspec to link entry in the pool mapping
   std::vector<RUDecodeData> mRUDecodeVec;                                             // set of active RUs
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelReader.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelReader.h
index 97716059f12d6..ce6582853788d 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelReader.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/RawPixelReader.h
@@ -53,8 +53,8 @@ namespace o2
 namespace itsmft
 {
 
-constexpr int MaxGBTPacketBytes = 8 * 1024;                                   // Max size of GBT packet in bytes (8KB)
-constexpr int NCRUPagesPerSuperpage = 256;                                    // Expected max number of CRU pages per superpage
+constexpr int MaxGBTPacketBytes = 8 * 1024; // Max size of GBT packet in bytes (8KB)
+constexpr int NCRUPagesPerSuperpage = 256;  // Expected max number of CRU pages per superpage
 using RDHUtils = o2::raw::RDHUtils;
 
 struct RawDecodingStat {
@@ -633,7 +633,6 @@ class RawPixelReader : public PixelReader
             const auto rdh = reinterpret_cast<const o2::header::RAWDataHeader*>(link->data.getPtr());
             mInteractionRecord = RDHUtils::getTriggerIR(rdh);
             mTrigger = RDHUtils::getTriggerType(rdh);
-            mInteractionRecordHB = RDHUtils::getHeartBeatIR(rdh);
             break;
           }
         }
@@ -674,7 +673,7 @@ class RawPixelReader : public PixelReader
       }
     }
     if (ruDecData.ruInfo->nCables) { // there are cables with data to decode
-      decodeAlpideData(ruDecData); // decode Alpide data from the compressed RU Data
+      decodeAlpideData(ruDecData);   // decode Alpide data from the compressed RU Data
     }
     return res;
   }
diff --git a/Detectors/ITSMFT/common/reconstruction/src/CTFCoder.cxx b/Detectors/ITSMFT/common/reconstruction/src/CTFCoder.cxx
index ec0ee9e3f0f24..4a0c83fd0c859 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/CTFCoder.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/CTFCoder.cxx
@@ -14,35 +14,38 @@
 /// \brief class for entropy encoding/decoding of ITS/MFT compressmed clusters data
 
 #include "ITSMFTReconstruction/CTFCoder.h"
-#include "CommonUtils/StringUtils.h"
 #include <TTree.h>
 
-using namespace o2::itsmft;
+namespace o2::itsmft
+{
 
 ///___________________________________________________________________________________
 // Register encoded data in the tree (Fill is not called, will be done by caller)
-void CTFCoder::appendToTree(TTree& tree, CTF& ec)
+template <int N>
+void CTFCoder<N>::appendToTree(TTree& tree, CTF& ec, int id)
 {
-  ec.appendToTree(tree, mDet.getName());
+  ec.appendToTree(tree, id >= 0 ? fmt::format("{}_{}", mDet.getName(), id) : mDet.getName());
 }
 
 ///___________________________________________________________________________________
 // extract and decode data from the tree
-void CTFCoder::readFromTree(TTree& tree, int entry, std::vector<ROFRecord>& rofRecVec,
-                            std::vector<CompClusterExt>& cclusVec, std::vector<unsigned char>& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
+template <int N>
+void CTFCoder<N>::readFromTree(TTree& tree, int entry, int id, std::vector<ROFRecord>& rofRecVec,
+                               std::vector<CompClusterExt>& cclusVec, std::vector<unsigned char>& pattVec, const NoiseMap* noiseMap, const LookUp& clPattLookup)
 {
   assert(entry >= 0 && entry < tree.GetEntries());
   CTF ec;
-  ec.readFromTree(tree, mDet.getName(), entry);
+  ec.readFromTree(tree, id >= 0 ? fmt::format("{}_{}", mDet.getName(), id) : mDet.getName(), entry);
   decode(ec, rofRecVec, cclusVec, pattVec, noiseMap, clPattLookup);
 }
 
 ///________________________________
-void CTFCoder::compress(CompressedClusters& cc,
-                        const gsl::span<const ROFRecord>& rofRecVec,
-                        const gsl::span<const CompClusterExt>& cclusVec,
-                        const gsl::span<const unsigned char>& pattVec,
-                        const LookUp& clPattLookup, int strobeLength)
+template <int N>
+void CTFCoder<N>::compress(CompressedClusters& cc,
+                           const gsl::span<const ROFRecord>& rofRecVec,
+                           const gsl::span<const CompClusterExt>& cclusVec,
+                           const gsl::span<const unsigned char>& pattVec,
+                           const LookUp& clPattLookup, int strobeLength)
 {
   // store in the header the orbit of 1st ROF
   cc.clear();
@@ -191,11 +194,12 @@ void CTFCoder::compress(CompressedClusters& cc,
 }
 
 ///________________________________
-void CTFCoder::createCoders(const std::vector<char>& bufVec, o2::ctf::CTFCoderBase::OpType op)
+template <int N>
+void CTFCoder<N>::createCoders(const std::vector<char>& bufVec, o2::ctf::CTFCoderBase::OpType op)
 {
   const auto ctf = CTF::getImage(bufVec.data());
   CompressedClusters cc; // just to get member types
-#define MAKECODER(part, slot) createCoder(op, std::get<rans::RenormedDenseHistogram<decltype(part)::value_type>>(ctf.getDictionary<decltype(part)::value_type>(slot, mANSVersion)), int(slot))
+#define MAKECODER(part, slot) createCoder(op, std::get<rans::RenormedDenseHistogram<typename decltype(part)::value_type>>(ctf.getDictionary<typename decltype(part)::value_type>(slot, mANSVersion)), int(slot))
   // clang-format off
   MAKECODER(cc.firstChipROF, CTF::BLCfirstChipROF);
   MAKECODER(cc.bcIncROF,     CTF::BLCbcIncROF    );
@@ -212,7 +216,8 @@ void CTFCoder::createCoders(const std::vector<char>& bufVec, o2::ctf::CTFCoderBa
 }
 
 ///________________________________
-size_t CTFCoder::estimateCompressedSize(const CompressedClusters& cc)
+template <int N>
+size_t CTFCoder<N>::estimateCompressedSize(const CompressedClusters& cc)
 {
   size_t sz = 0;
   // RS FIXME this is very crude estimate, instead, an empirical values should be used
@@ -234,7 +239,8 @@ size_t CTFCoder::estimateCompressedSize(const CompressedClusters& cc)
 }
 
 ///________________________________
-CompressedClusters CTFCoder::decodeCompressedClusters(const CTF::base& ec, o2::ctf::CTFIOSize& iosize)
+template <int N>
+CompressedClusters CTFCoder<N>::decodeCompressedClusters(const CTF::base& ec, o2::ctf::CTFIOSize& iosize)
 {
   CompressedClusters cc;
   cc.header = ec.getHeader();
@@ -256,3 +262,7 @@ CompressedClusters CTFCoder::decodeCompressedClusters(const CTF::base& ec, o2::c
   // clang-format on
   return cc;
 }
+
+template class CTFCoder<o2::detectors::DetID::ITS>;
+template class CTFCoder<o2::detectors::DetID::MFT>;
+} // namespace o2::itsmft
diff --git a/Detectors/ITSMFT/common/reconstruction/src/ChipMappingITS.cxx b/Detectors/ITSMFT/common/reconstruction/src/ChipMappingITS.cxx
index 7d9733554ef12..f143e4bb23f3d 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/ChipMappingITS.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/ChipMappingITS.cxx
@@ -78,14 +78,14 @@ ChipMappingITS::ChipMappingITS()
     cInfo.moduleSW = 0;
     cInfo.chipOnModuleSW = i;
     cInfo.chipOnModuleHW = i;
-    cInfo.cableHW = i;                              //1-to-1 mapping
-    cInfo.cableHWPos = i;                           //1-to-1 mapping
-    cInfo.cableSW = i;                              //1-to-1 mapping
-    cInfo.chipOnCable = 0;                          // every chip is master
+    cInfo.cableHW = i;     // 1-to-1 mapping
+    cInfo.cableHWPos = i;  // 1-to-1 mapping
+    cInfo.cableSW = i;     // 1-to-1 mapping
+    cInfo.chipOnCable = 0; // every chip is master
     mCableHW2SW[IB][cInfo.cableHW] = cInfo.cableSW;
     mCableHW2Pos[IB][cInfo.cableHW] = cInfo.cableHWPos;
     mCablesOnStaveSB[IB] |= 0x1 << cInfo.cableHWPos; // account in lanes pattern
-    mCableHWFirstChip[IB][i] = 0;                   // stave and module are the same
+    mCableHWFirstChip[IB][i] = 0;                    // stave and module are the same
   }
 
   // [i][j] gives lane id for  lowest(i=0) and highest(i=1) 7 chips of HW module (j+1) (1-4 for ML, 1-7 for OL)
@@ -289,3 +289,17 @@ std::vector<ChipMappingITS::Overlaps> ChipMappingITS::getOverlapsInfo() const
   }
   return v;
 }
+
+//_____________________________________________________________________________
+std::vector<uint16_t> ChipMappingITS::getLayer2FEEIDs(int lr)
+{
+  std::vector<uint16_t> feeIDs;
+  for (int ilr = (lr >= 0 ? lr : 0); ilr < (lr >= 0 ? lr + 1 : NLayers); ++ilr) {
+    for (int ist = 0; ist < NStavesOnLr[ilr]; ++ist) {
+      for (int lnk = 0; lnk < NLinks; ++lnk) {
+        feeIDs.push_back(composeFEEId(ilr, ist, lnk));
+      }
+    }
+  }
+  return feeIDs;
+}
diff --git a/Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx b/Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx
index 259df62921c8f..de2358469e894 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx
@@ -1753,3 +1753,17 @@ void ChipMappingMFT::print() const
            ChipMappingData[iChip].chipOnRU);
   }
 }
+
+//_____________________________________________________________________________
+std::vector<uint16_t> ChipMappingMFT::getLayer2FEEIDs(int lr)
+{
+  std::vector<uint16_t> feeIDs;
+  for (int ilr = (lr >= 0 ? lr : 0); ilr < (lr >= 0 ? lr + 1 : NLayers); ++ilr) {
+    for (int iz = 0; iz < NZonesPerLayer; ++iz) {
+      for (int lnk = 0; lnk < NLinks; ++lnk) {
+        feeIDs.push_back(composeFEEId(ilr, iz, lnk));
+      }
+    }
+  }
+  return feeIDs;
+}
diff --git a/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx b/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
index 3c741321e7780..dcc268a4504a9 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/Clusterer.cxx
@@ -479,7 +479,7 @@ void Clusterer::print(bool showsTiming) const
   } else {
     LOGP(info, "Clusterizer squashes overflow pixels <= {} in row/col", mMaxRowColDiffToMask);
     for (size_t i{0}; i < mSquashingLayerDepth.size(); ++i) {
-      LOGP(info, "\tlay:{} separated by {} BC seeking down to {} neighbour ROFs", i, mMaxBCSeparationToSquashLayer[i], mSquashingLayerDepth[i]);
+      LOGP(info, "\tClusterizer on layer {} separated by {} BC seeking down to {} neighbour ROFs", i, mMaxBCSeparationToSquashLayer[i], mSquashingLayerDepth[i]);
     }
   }
   LOGP(info, "Clusterizer masks overflow pixels separated by < {} BC and <= {} in row/col", mMaxBCSeparationToMask, mMaxRowColDiffToMask);
diff --git a/Detectors/ITSMFT/common/reconstruction/src/GBTLink.cxx b/Detectors/ITSMFT/common/reconstruction/src/GBTLink.cxx
index af4c8de5caf39..4d336d9adb1ee 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/GBTLink.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/GBTLink.cxx
@@ -41,7 +41,7 @@ GBTLink::GBTLink(uint16_t _cru, uint16_t _fee, uint8_t _ep, uint8_t _idInCru, ui
 /// create string describing the link
 std::string GBTLink::describe() const
 {
-  std::string ss = fmt::format("link cruID:{:#06x}/lID{} feeID:{:#06x}", cruID, int(idInCRU), feeID);
+  std::string ss = fmt::format("link cruID:{:#06x}/lID{:02} feeID:{:#06x}", cruID, int(idInCRU), feeID);
   if (lanes) {
     ss += fmt::format(" lanes {}", std::bitset<28>(lanes).to_string());
   }
diff --git a/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx b/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
index dc61bea9f406e..7158551e02e20 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -40,7 +40,8 @@ RawPixelDecoder<Mapping>::RawPixelDecoder()
   mTimerDecode.Stop();
   mTimerFetchData.Stop();
   mSelfName = o2::utils::Str::concat_string(Mapping::getName(), "Decoder");
-  DPLRawParser<>::setCheckIncompleteHBF(false); // Disable incomplete HBF checking, see ErrPacketCounterJump check in GBTLink.cxx
+  DPLRawParser<>::setCheckIncompleteHBF(false);                                                                             // Disable incomplete HBF checking, see ErrPacketCounterJump check in GBTLink.cxx
+  mInputFilter = {InputSpec{"filter", ConcreteDataTypeMatcher{Mapping::getOrigin(), o2::header::gDataDescriptionRawData}}}; // by default take all raw data
 }
 
 ///______________________________________________________________
@@ -102,8 +103,7 @@ int RawPixelDecoder<Mapping>::decodeNextTrigger()
     }
 
 #ifdef WITH_OPENMP
-#pragma omp parallel for schedule(dynamic) num_threads(mNThreads) reduction(+ \
-                                                                            : mNChipsFiredROF, mNPixelsFiredROF)
+#pragma omp parallel for schedule(dynamic) num_threads(mNThreads) reduction(+ : mNChipsFiredROF, mNPixelsFiredROF)
 #endif
     for (int iru = 0; iru < nru; iru++) {
       auto& ru = mRUDecodeVec[iru];
@@ -186,6 +186,9 @@ bool RawPixelDecoder<Mapping>::doIRMajorityPoll()
     if (link.statusInTF == GBTLink::DataSeen) {
       if (link.status == GBTLink::DataSeen || link.status == GBTLink::CachedDataExist) {
         mIRPoll[link.ir]++;
+        if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
+          LOGP(info, "doIRMajorityPoll: {} contributes to poll {}", link.describe(), link.ir.asString());
+        }
       } else if (link.status == GBTLink::StoppedOnEndOfData || link.status == GBTLink::AbortedOnError) {
         link.statusInTF = GBTLink::StoppedOnEndOfData;
         if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
@@ -195,6 +198,12 @@ bool RawPixelDecoder<Mapping>::doIRMajorityPoll()
       }
     }
   }
+  if (mNLinksDone == mNLinksInTF) {
+    if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
+      LOGP(info, "doIRMajorityPoll: All {} links registered in TF are done", mNLinksInTF);
+    }
+    return false;
+  }
   int majIR = -1;
   for (const auto& entIR : mIRPoll) {
     if (entIR.second > majIR) {
@@ -202,16 +211,14 @@ bool RawPixelDecoder<Mapping>::doIRMajorityPoll()
       mInteractionRecord = entIR.first;
     }
   }
-  mInteractionRecordHB = mInteractionRecord;
   if (mInteractionRecord.isDummy()) {
     if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
       LOG(info) << "doIRMajorityPoll: did not find any valid IR";
     }
     return false;
   }
-  mInteractionRecordHB.bc = 0;
   if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
-    LOG(info) << "doIRMajorityPoll: " << mInteractionRecordHB.asString() << " majority = " << majIR << " for " << mNLinksInTF << " links seen, LinksDone = " << mNLinksDone;
+    LOG(info) << "doIRMajorityPoll: " << mInteractionRecord.asString() << " majority = " << majIR << " for " << mNLinksInTF << " links seen, LinksDone = " << mNLinksDone;
   }
   return true;
 }
@@ -228,7 +235,14 @@ void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
   auto nLinks = mGBTLinks.size();
   auto origin = (mUserDataOrigin == o2::header::gDataOriginInvalid) ? mMAP.getOrigin() : mUserDataOrigin;
   auto datadesc = (mUserDataDescription == o2::header::gDataDescriptionInvalid) ? o2::header::gDataDescriptionRawData : mUserDataDescription;
-  std::vector<InputSpec> filter{InputSpec{"filter", ConcreteDataTypeMatcher{origin, datadesc}}};
+  if (mUserDataDescription != o2::header::gDataDescriptionInvalid) { // overwrite data filter origin&descriptions with user defined ones if possible
+    for (auto& filt : mInputFilter) {
+      if (std::holds_alternative<o2::framework::ConcreteDataMatcher>(filt.matcher)) {
+        std::get<o2::framework::ConcreteDataMatcher>(filt.matcher).origin = origin;
+        std::get<o2::framework::ConcreteDataMatcher>(filt.matcher).description = datadesc;
+      }
+    }
+  }
 
   // if we see requested data type input with 0xDEADBEEF subspec and 0 payload this means that the "delayed message"
   // mechanism created it in absence of real data from upstream. Processor should send empty output to not block the workflow
@@ -251,28 +265,31 @@ void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
     contDeadBeef = 0; // if good data, reset the counter
   }
   mROFRampUpStage = false;
-  DPLRawParser parser(inputs, filter, o2::conf::VerbosityConfig::Instance().rawParserSeverity);
+  DPLRawParser parser(inputs, mInputFilter, o2::conf::VerbosityConfig::Instance().rawParserSeverity);
   parser.setMaxFailureMessages(o2::conf::VerbosityConfig::Instance().maxWarnRawParser);
   static size_t cntParserFailures = 0;
   parser.setExtFailureCounter(&cntParserFailures);
 
   uint32_t currSSpec = 0xffffffff; // dummy starting subspec
   int linksAdded = 0;
+  uint16_t lr, dummy; // extraxted info from FEEId
   for (auto it = parser.begin(); it != parser.end(); ++it) {
     auto const* dh = it.o2DataHeader();
     auto& lnkref = mSubsSpec2LinkID[dh->subSpecification];
     const auto& rdh = *reinterpret_cast<const header::RDHAny*>(it.raw()); // RSTODO this is a hack in absence of generic header getter
+    const auto feeID = RDHUtils::getFEEID(rdh);
+    mMAP.expandFEEId(feeID, lr, dummy, dummy);
 
     if (lnkref.entry == -1) { // new link needs to be added
       lnkref.entry = int(mGBTLinks.size());
-      auto& lnk = mGBTLinks.emplace_back(RDHUtils::getCRUID(rdh), RDHUtils::getFEEID(rdh), RDHUtils::getEndPointID(rdh), RDHUtils::getLinkID(rdh), lnkref.entry);
+      auto& lnk = mGBTLinks.emplace_back(RDHUtils::getCRUID(rdh), feeID, RDHUtils::getEndPointID(rdh), RDHUtils::getLinkID(rdh), lnkref.entry);
       lnk.subSpec = dh->subSpecification;
       lnk.wordLength = (lnk.expectPadding = (RDHUtils::getDataFormat(rdh) == 0)) ? o2::itsmft::GBTPaddedWordLength : o2::itsmft::GBTWordLength;
-      getCreateRUDecode(mMAP.FEEId2RUSW(RDHUtils::getFEEID(rdh))); // make sure there is a RU for this link
+      getCreateRUDecode(mMAP.FEEId2RUSW(feeID)); // make sure there is a RU for this link
       lnk.verbosity = GBTLink::Verbosity(mVerbosity);
       lnk.alwaysParseTrigger = mAlwaysParseTrigger;
       if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
-        LOG(info) << mSelfName << " registered new link " << lnk.describe() << " RUSW=" << int(mMAP.FEEId2RUSW(lnk.feeID));
+        LOG(info) << mSelfName << " registered new " << lnk.describe() << " RUSW=" << int(mMAP.FEEId2RUSW(lnk.feeID));
       }
       linksAdded++;
     }
@@ -330,7 +347,7 @@ void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
       mMAP.expandFEEId(link.feeID, lr, ruOnLr, linkInRU);
       if (newLinkAdded) {
         if (mVerbosity >= GBTLink::Verbosity::VerboseHeaders) {
-          LOG(info) << mSelfName << " Attaching " << link.describe() << " to RU#" << int(mMAP.FEEId2RUSW(link.feeID)) << " (stave " << ruOnLr << " of layer " << lr << ')';
+          LOGP(info, "{} Attaching {} to RU#{:02} (stave {:02} of layer {})", mSelfName, link.describe(), int(mMAP.FEEId2RUSW(link.feeID)), ruOnLr, lr);
         }
       }
       link.idInRU = linkInRU;
diff --git a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
index fa75a65728675..f4482c651b090 100644
--- a/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
+++ b/Detectors/ITSMFT/common/simulation/include/ITSMFTSimulation/DigiParams.h
@@ -19,7 +19,7 @@
 #include <algorithm>
 #include <Rtypes.h>
 #include "ITSMFTSimulation/AlpideSignalTrapezoid.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 
 ////////////////////////////////////////////////////////////
 //                                                        //
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterReaderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterReaderSpec.h
index 82e3890de7475..9d58b6fde16c1 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterReaderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterReaderSpec.h
@@ -14,8 +14,10 @@
 #ifndef O2_ITSMFT_CLUSTERREADER
 #define O2_ITSMFT_CLUSTERREADER
 
-#include "TFile.h"
-#include "TTree.h"
+#include <vector>
+
+#include <TFile.h>
+#include <TTree.h>
 
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
@@ -23,7 +25,7 @@
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 
@@ -38,10 +40,9 @@ class ClusterReader : public Task
  public:
   static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
   static constexpr o2::header::DataOrigin Origin{(N == o2::detectors::DetID::ITS) ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
-  static constexpr int NLayers{o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1};
 
   ClusterReader() = delete;
-  ClusterReader(bool useMC, bool usePatterns = true, bool triggers = true);
+  ClusterReader(bool useMC = true, bool doStag = false, bool usePatterns = true, bool triggers = true);
   ~ClusterReader() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -52,18 +53,19 @@ class ClusterReader : public Task
   void setBranchAddress(const std::string& base, Ptr& addr, int layer);
   std::string getBranchName(const std::string& base, int index) const;
 
-  std::array<std::vector<o2::itsmft::ROFRecord>*, NLayers> mClusROFRec;
-  std::array<std::vector<o2::itsmft::CompClusterExt>*, NLayers> mClusterCompArray;
-  std::array<std::vector<unsigned char>*, NLayers> mPatternsArray;
-  std::array<o2::dataformats::MCTruthContainer<o2::MCCompLabel>*, NLayers> mClusterMCTruth;
-  std::array<std::vector<o2::itsmft::MC2ROFRecord>*, NLayers> mClusMC2ROFs;
+  std::vector<std::vector<o2::itsmft::ROFRecord>*> mClusROFRec{nullptr};
+  std::vector<std::vector<o2::itsmft::CompClusterExt>*> mClusterCompArray{nullptr};
+  std::vector<std::vector<unsigned char>*> mPatternsArray{nullptr};
+  std::vector<o2::dataformats::MCTruthContainer<o2::MCCompLabel>*> mClusterMCTruth{nullptr};
 
   std::unique_ptr<TFile> mFile;
   std::unique_ptr<TTree> mTree;
 
-  bool mUseMC = true;       // use MC truth
-  bool mUsePatterns = true; // send patterns
-  bool mTriggerOut = true;  // send dummy triggers vector
+  int mLayers = 1;
+  bool mUseMC = true;         // use MC truth
+  bool mDoStaggering = false; // read staggered data
+  bool mUsePatterns = true;   // send patterns
+  bool mTriggerOut = true;    // send dummy triggers vector
 
   std::string mDetName;
   std::string mDetNameLC;
@@ -73,27 +75,26 @@ class ClusterReader : public Task
   std::string mClusterPattBranchName = "ClusterPatt";
   std::string mClusterCompBranchName = "ClusterComp";
   std::string mClustMCTruthBranchName = "ClusterMCTruth";
-  std::string mClustMC2ROFBranchName = "ClustersMC2ROF";
 };
 
 class ITSClusterReader : public ClusterReader<o2::detectors::DetID::ITS>
 {
  public:
-  ITSClusterReader(bool useMC = true, bool usePatterns = true, bool triggerOut = true)
-    : ClusterReader(useMC, usePatterns, triggerOut) {}
+  ITSClusterReader(bool useMC = true, bool doStag = false, bool usePatterns = true, bool triggerOut = true)
+    : ClusterReader(useMC, doStag, usePatterns, triggerOut) {}
 };
 
 class MFTClusterReader : public ClusterReader<o2::detectors::DetID::MFT>
 {
  public:
-  MFTClusterReader(bool useMC = true, bool usePatterns = true, bool triggerOut = true)
-    : ClusterReader(useMC, usePatterns, triggerOut) {}
+  MFTClusterReader(bool useMC = true, bool doStag = false, bool usePatterns = true, bool triggerOut = true)
+    : ClusterReader(useMC, doStag, usePatterns, triggerOut) {}
 };
 
 /// create a processor spec
 /// read ITS/MFT cluster data from a root file
-framework::DataProcessorSpec getITSClusterReaderSpec(bool useMC = true, bool usePatterns = true, bool useTriggers = true);
-framework::DataProcessorSpec getMFTClusterReaderSpec(bool useMC = true, bool usePatterns = true, bool useTriggers = true);
+framework::DataProcessorSpec getITSClusterReaderSpec(bool useMC = true, bool doStag = false, bool usePatterns = true, bool useTriggers = true);
+framework::DataProcessorSpec getMFTClusterReaderSpec(bool useMC = true, bool doStag = false, bool usePatterns = true, bool useTriggers = true);
 
 } // namespace o2::itsmft
 
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
index 5ae371e7e09c4..6607c05fb141d 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
@@ -20,9 +20,9 @@ namespace o2::itsmft
 {
 
 template <int N>
-framework::DataProcessorSpec getClusterWriterSpec(bool useMC);
-framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC);
-framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC);
+framework::DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag);
+framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC, bool doStag);
+framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC, bool doStag);
 
 } // namespace o2::itsmft
 
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClustererSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClustererSpec.h
index b6ebc282c2a27..5535ecb42d645 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClustererSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClustererSpec.h
@@ -18,7 +18,6 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "ITSMFTReconstruction/Clusterer.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
 
 using namespace o2::framework;
 
@@ -30,10 +29,9 @@ class ClustererDPL : public Task
 {
   static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
   static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
-  static constexpr int NLayers{o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1};
 
  public:
-  ClustererDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC) : mGGCCDBRequest(gr), mUseMC(useMC) {}
+  ClustererDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool doStag);
   ~ClustererDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -48,12 +46,13 @@ class ClustererDPL : public Task
   int mNThreads = 1;
   std::unique_ptr<o2::itsmft::Clusterer> mClusterer = nullptr;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
-  int mLayers{NLayers};
+  bool mDoStaggering = false;
+  int mLayers = 1;
   std::vector<InputSpec> mFilter;
 };
 
-framework::DataProcessorSpec getITSClustererSpec(bool useMC);
-framework::DataProcessorSpec getMFTClustererSpec(bool useMC);
+framework::DataProcessorSpec getITSClustererSpec(bool useMC, bool doStag);
+framework::DataProcessorSpec getMFTClustererSpec(bool useMC, bool doStag);
 
 } // namespace o2::itsmft
 
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitReaderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitReaderSpec.h
index 348ba76468144..2954c27af886e 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitReaderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitReaderSpec.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -14,9 +14,12 @@
 #ifndef O2_ITSMFT_DIGITREADER
 #define O2_ITSMFT_DIGITREADER
 
-#include "TFile.h"
-#include "TTree.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include <vector>
+
+#include <TFile.h>
+#include <TTree.h>
+
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/GBTCalibData.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
@@ -41,11 +44,9 @@ class DigitReader : public Task
  public:
   static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
   static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
-  static constexpr int NLayers{o2::itsmft::DPLAlpideParam<N>::getNLayers()};
-  static constexpr int RLayers = o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? NLayers : 1;
 
   DigitReader() = delete;
-  DigitReader(bool useMC, bool useCalib, bool triggerOut);
+  DigitReader(bool useMC, bool doStag, bool useCalib, bool triggerOut);
   ~DigitReader() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -56,22 +57,23 @@ class DigitReader : public Task
   void setBranchAddress(const std::string& base, Ptr& addr, int layer = -1);
   std::string getBranchName(const std::string& base, int index);
 
-  std::array<std::vector<o2::itsmft::Digit>*, NLayers> mDigits;
+  std::vector<std::vector<o2::itsmft::Digit>*> mDigits{nullptr};
   std::vector<o2::itsmft::GBTCalibData> mCalib, *mCalibPtr = &mCalib;
-  std::array<std::vector<o2::itsmft::ROFRecord>*, NLayers> mDigROFRec;
-  std::array<std::vector<o2::itsmft::MC2ROFRecord>*, NLayers> mDigMC2ROFs;
-  std::array<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>, NLayers> mConstLabels;
-  std::array<o2::dataformats::IOMCTruthContainerView*, NLayers> mPLabels;
+  std::vector<std::vector<o2::itsmft::ROFRecord>*> mDigROFRec{nullptr};
+  std::vector<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>> mConstLabels{};
+  std::vector<o2::dataformats::IOMCTruthContainerView*> mPLabels{nullptr};
 
   std::unique_ptr<TFile> mFile;
   std::unique_ptr<TTree> mTree;
-  bool mUseMC = true;        // use MC truth
-  bool mUseCalib = true;     // send calib data
-  bool mTriggerOut = true;   // send dummy triggers vector
-  bool mUseIRFrames = false; // selected IRFrames modes
+  bool mUseMC = true;         // use MC truth
+  bool mDoStaggering = false; // read staggered data
+  bool mUseCalib = true;      // send calib data
+  bool mTriggerOut = true;    // send dummy triggers vector
+  bool mUseIRFrames = false;  // selected IRFrames modes
   int mROFBiasInBC = 0;
   int mROFLengthInBC = 0;
   int mNRUs = 0;
+  int mLayers = 1;
   std::string mDetName;
   std::string mDetNameLC;
   std::string mFileName;
@@ -81,27 +83,26 @@ class DigitReader : public Task
   std::string mCalibBranchName = "Calib";
 
   std::string mDigitMCTruthBranchName = "DigitMCTruth";
-  std::string mDigitMC2ROFBranchName = "DigitMC2ROF";
 };
 
 class ITSDigitReader : public DigitReader<o2::detectors::DetID::ITS>
 {
  public:
-  ITSDigitReader(bool useMC = true, bool useCalib = false, bool useTriggers = true)
-    : DigitReader<o2::detectors::DetID::ITS>(useMC, useCalib, useTriggers) {}
+  ITSDigitReader(bool useMC = true, bool doStag = false, bool useCalib = false, bool useTriggers = true)
+    : DigitReader<o2::detectors::DetID::ITS>(useMC, doStag, useCalib, useTriggers) {}
 };
 
 class MFTDigitReader : public DigitReader<o2::detectors::DetID::MFT>
 {
  public:
-  MFTDigitReader(bool useMC = true, bool useCalib = false, bool useTriggers = true)
-    : DigitReader<o2::detectors::DetID::MFT>(useMC, useCalib, useTriggers) {}
+  MFTDigitReader(bool useMC = true, bool doStag = false, bool useCalib = false, bool useTriggers = true)
+    : DigitReader<o2::detectors::DetID::MFT>(useMC, doStag, useCalib, useTriggers) {}
 };
 
 /// create a processor spec
 /// read ITS/MFT Digit data from a root file
-framework::DataProcessorSpec getITSDigitReaderSpec(bool useMC = true, bool useCalib = false, bool useTriggers = true, std::string defname = "o2_itsdigits.root");
-framework::DataProcessorSpec getMFTDigitReaderSpec(bool useMC = true, bool useCalib = false, bool useTriggers = true, std::string defname = "o2_mftdigits.root");
+framework::DataProcessorSpec getITSDigitReaderSpec(bool useMC = true, bool doStag = false, bool useCalib = false, bool useTriggers = true, std::string defname = "itsdigits.root");
+framework::DataProcessorSpec getMFTDigitReaderSpec(bool useMC = true, bool doStag = false, bool useCalib = false, bool useTriggers = true, std::string defname = "mftdigits.root");
 
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitWriterSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitWriterSpec.h
index 7bef1643ddcbb..6fde609f1ccb5 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitWriterSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/DigitWriterSpec.h
@@ -19,8 +19,8 @@ namespace o2
 namespace itsmft
 {
 
-o2::framework::DataProcessorSpec getITSDigitWriterSpec(bool mctruth = true, bool dec = false, bool calib = false);
-o2::framework::DataProcessorSpec getMFTDigitWriterSpec(bool mctruth = true, bool dec = false, bool calib = false);
+o2::framework::DataProcessorSpec getITSDigitWriterSpec(bool mctruth = true, bool doStag = false, bool dec = false, bool calib = false);
+o2::framework::DataProcessorSpec getMFTDigitWriterSpec(bool mctruth = true, bool doStag = false, bool dec = false, bool calib = false);
 
 } // end namespace itsmft
 } // end namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyDecoderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyDecoderSpec.h
index a64f2bf8c063c..6862e96c17afe 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyDecoderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyDecoderSpec.h
@@ -29,38 +29,39 @@ namespace o2
 namespace itsmft
 {
 
+template <int N>
 class EntropyDecoderSpec : public o2::framework::Task
 {
  public:
-  EntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits = false, const std::string& ctfdictOpt = "none");
+  EntropyDecoderSpec(int verbosity, bool doStag, bool getDigits = false, const std::string& ctfdictOpt = "none");
   ~EntropyDecoderSpec() override = default;
   void init(o2::framework::InitContext& ic) final;
   void run(o2::framework::ProcessingContext& pc) final;
   void endOfStream(o2::framework::EndOfStreamContext& ec) final;
   void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final;
 
-  static auto getName(o2::header::DataOrigin orig) { return std::string{orig == o2::header::gDataOriginITS ? ITSDeviceName : MFTDeviceName}; }
+  static std::string getBinding(const std::string& name, int spec);
+  static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+  static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
 
  private:
   void updateTimeDependentParams(o2::framework::ProcessingContext& pc);
 
-  static constexpr std::string_view ITSDeviceName = "its-entropy-decoder";
-  static constexpr std::string_view MFTDeviceName = "mft-entropy-decoder";
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginInvalid;
-  o2::itsmft::CTFCoder mCTFCoder;
+  o2::itsmft::CTFCoder<N> mCTFCoder;
   const NoiseMap* mNoiseMap = nullptr;
   LookUp mPattIdConverter;
+  bool mDoStaggering{false};
   bool mGetDigits{false};
   bool mMaskNoise{false};
   bool mUseClusterDictionary{true};
-  std::string mDetPrefix{};
 
   std::string mCTFDictPath{};
   TStopwatch mTimer;
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt);
+framework::DataProcessorSpec getITSEntropyDecoderSpec(int verbosity, bool doStag, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt);
+framework::DataProcessorSpec getMFTEntropyDecoderSpec(int verbosity, bool doStag, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt);
 
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyEncoderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyEncoderSpec.h
index 588cae6339489..597c0ca63f489 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyEncoderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/EntropyEncoderSpec.h
@@ -27,10 +27,12 @@ namespace o2
 namespace itsmft
 {
 
+template <int N>
 class EntropyEncoderSpec : public o2::framework::Task
 {
+
  public:
-  EntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR, const std::string& ctfdictOpt = "none");
+  EntropyEncoderSpec(bool doStag, bool selIR, const std::string& ctfdictOpt = "none");
   ~EntropyEncoderSpec() override = default;
   void run(o2::framework::ProcessingContext& pc) final;
   void init(o2::framework::InitContext& ic) final;
@@ -38,17 +40,21 @@ class EntropyEncoderSpec : public o2::framework::Task
   void updateTimeDependentParams(o2::framework::ProcessingContext& pc);
   void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final;
 
+  static std::string getBinding(const std::string& name, int spec);
+  static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+  static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+
  private:
-  o2::header::DataOrigin mOrigin = o2::header::gDataOriginInvalid;
-  o2::itsmft::CTFCoder mCTFCoder;
+  o2::itsmft::CTFCoder<N> mCTFCoder;
   LookUp mPattIdConverter;
-  int mStrobeLength = 0;
   bool mSelIR = false;
+  bool mDoStaggering = false;
   TStopwatch mTimer;
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getEntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR = false, const std::string& ctfdictOpt = "none");
+framework::DataProcessorSpec getITSEntropyEncoderSpec(bool doStag = false, bool selIR = false, const std::string& ctfdictOpt = "none");
+framework::DataProcessorSpec getMFTEntropyEncoderSpec(bool doStag = false, bool selIR = false, const std::string& ctfdictOpt = "none");
 
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
index a6876c456842d..29b9f75bcbc4e 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -16,12 +16,14 @@
 #ifndef O2_ITSMFT_STFDECODER_
 #define O2_ITSMFT_STFDECODER_
 
+#include <memory>
+#include <string>
+#include <vector>
 #include <TStopwatch.h>
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
-#include <memory>
-#include <string>
-#include <string_view>
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
 #include "ITSMFTReconstruction/ChipMappingMFT.h"
 #include "ITSMFTReconstruction/RawPixelDecoder.h"
@@ -44,6 +46,7 @@ struct STFDecoderInp {
   bool doDigits = false;
   bool doCalib = false;
   bool doSquashing = false;
+  bool doStaggering = false;
   bool askSTFDist = true;
   bool allowReporting = true;
   bool verifyDecoder = false;
@@ -55,6 +58,8 @@ struct STFDecoderInp {
 template <class Mapping>
 class STFDecoder : public Task
 {
+  using AlpideParam = DPLAlpideParam<Mapping::getDetID()>;
+
  public:
   STFDecoder(const STFDecoderInp& inp, std::shared_ptr<o2::base::GRPGeomRequest> gr);
   STFDecoder() = default;
@@ -70,11 +75,14 @@ class STFDecoder : public Task
   void finalize();
   void reset();
   std::unique_ptr<o2::itsmft::Clusterer> setupClusterer(const std::string& dictName);
+  void ensureContinuousROF(const std::vector<ROFRecord>& in, std::vector<ROFRecord>& out, int lr, int nROFsTF, const char* name);
+
   TStopwatch mTimer;
   bool mDoClusters = false;
   bool mDoPatterns = false;
   bool mDoDigits = false;
   bool mDoCalibData = false;
+  bool mDoStaggering = false;
   bool mUnmutExtraLanes = false;
   bool mFinalizeDone = false;
   bool mAllowReporting = true;
@@ -85,18 +93,20 @@ class STFDecoder : public Task
   int mDumpOnError = 0;
   int mNThreads = 1;
   int mVerbosity = 0;
+  int mLayers = 1;
   long mROFErrRepIntervalMS = 0;
   size_t mTFCounter = 0;
-  size_t mEstNDig = 0;
-  size_t mEstNClus = 0;
-  size_t mEstNClusPatt = 0;
-  size_t mEstNCalib = 0;
-  size_t mEstNROF = 0;
+  uint32_t mFirstTFOrbit = 0;
+  o2::InteractionRecord mFirstIR;
+  std::vector<size_t> mEstNDig{0};
+  std::vector<size_t> mEstNClus{0};
+  std::vector<size_t> mEstNClusPatt{0};
+  std::vector<size_t> mEstNCalib{0};
   size_t mMaxRawDumpsSize = 0;
   size_t mRawDumpedSize = 0;
   std::string mInputSpec;
   std::string mSelfName;
-  std::unique_ptr<RawPixelDecoder<Mapping>> mDecoder;
+  std::vector<std::unique_ptr<RawPixelDecoder<Mapping>>> mDecoder;
   std::unique_ptr<Clusterer> mClusterer;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
 };
diff --git a/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
index bc6418a077810..bd24c9d2591d5 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
@@ -20,7 +20,7 @@
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/Logger.h"
 #include "ITSMFTWorkflow/ClusterReaderSpec.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/PhysTrigger.h"
 #include "CommonUtils/NameConf.h"
 
@@ -33,15 +33,16 @@ namespace itsmft
 {
 
 template <int N>
-ClusterReader<N>::ClusterReader(bool useMC, bool usePatterns, bool triggerOut) : mUseMC(useMC), mUsePatterns(usePatterns), mTriggerOut(triggerOut), mDetName(Origin.as<std::string>()), mDetNameLC(mDetName)
+ClusterReader<N>::ClusterReader(bool useMC, bool doStag, bool usePatterns, bool triggerOut) : mUseMC(useMC), mUsePatterns(usePatterns), mTriggerOut(triggerOut), mDetName(Origin.as<std::string>()), mDetNameLC(mDetName)
 {
   std::transform(mDetNameLC.begin(), mDetNameLC.end(), mDetNameLC.begin(), ::tolower);
-
-  mClusROFRec.fill(nullptr);
-  mClusterCompArray.fill(nullptr);
-  mPatternsArray.fill(nullptr);
-  mClusterMCTruth.fill(nullptr);
-  mClusMC2ROFs.fill(nullptr);
+  if (doStag) {
+    mLayers = DPLAlpideParam<N>::getNLayers();
+    mClusROFRec.resize(mLayers, nullptr);
+    mClusterCompArray.resize(mLayers, nullptr);
+    mPatternsArray.resize(mLayers, nullptr);
+    mClusterMCTruth.resize(mLayers, nullptr);
+  }
 }
 
 template <int N>
@@ -59,8 +60,8 @@ void ClusterReader<N>::run(ProcessingContext& pc)
   assert(ent < mTree->GetEntries()); // this should not happen
   mTree->GetEntry(ent);
 
-  for (uint32_t iLayer = 0; iLayer < NLayers; ++iLayer) {
-    LOG(info) << mDetName << "ClusterReader:" << iLayer << " pushes " << mClusROFRec[iLayer]->size() << " ROFRecords, " << mClusterCompArray[iLayer]->size() << " compact clusters at entry " << ent;
+  for (uint32_t iLayer = 0; iLayer < mLayers; ++iLayer) {
+    LOG(info) << mDetName << "ClusterReader" << (mDoStaggering ? std::format(" on layer {}", iLayer) : "") << " pushes " << mClusROFRec[iLayer]->size() << " ROFRecords, " << mClusterCompArray[iLayer]->size() << " compact clusters at entry " << ent;
     pc.outputs().snapshot(Output{Origin, "CLUSTERSROF", iLayer}, *mClusROFRec[iLayer]);
     pc.outputs().snapshot(Output{Origin, "COMPCLUSTERS", iLayer}, *mClusterCompArray[iLayer]);
     if (mUsePatterns) {
@@ -68,7 +69,6 @@ void ClusterReader<N>::run(ProcessingContext& pc)
     }
     if (mUseMC) {
       pc.outputs().snapshot(Output{Origin, "CLUSTERSMCTR", iLayer}, *mClusterMCTruth[iLayer]);
-      pc.outputs().snapshot(Output{Origin, "CLUSTERSMC2ROF", iLayer}, *mClusMC2ROFs[iLayer]);
     }
   }
   if (mTriggerOut) {
@@ -90,17 +90,15 @@ void ClusterReader<N>::connectTree(const std::string& filename)
   mTree.reset((TTree*)mFile->Get(mClusTreeName.c_str()));
   assert(mTree);
 
-  for (uint32_t iLayer = 0; iLayer < NLayers; ++iLayer) {
+  for (uint32_t iLayer = 0; iLayer < mLayers; ++iLayer) {
     setBranchAddress(mClusROFBranchName, mClusROFRec[iLayer], iLayer);
     setBranchAddress(mClusterCompBranchName, mClusterCompArray[iLayer], iLayer);
     if (mUsePatterns) {
       setBranchAddress(mClusterPattBranchName, mPatternsArray[iLayer], iLayer);
     }
     if (mUseMC) {
-      if (mTree->GetBranch(getBranchName(mClustMCTruthBranchName, iLayer).c_str()) &&
-          mTree->GetBranch(getBranchName(mClustMC2ROFBranchName, iLayer).c_str())) {
+      if (mTree->GetBranch(getBranchName(mClustMCTruthBranchName, iLayer).c_str())) {
         setBranchAddress(mClustMCTruthBranchName, mClusterMCTruth[iLayer], iLayer);
-        setBranchAddress(mClustMC2ROFBranchName, mClusMC2ROFs[iLayer], iLayer);
       } else {
         LOG(info) << "MC-truth is missing";
         mUseMC = false;
@@ -113,7 +111,7 @@ void ClusterReader<N>::connectTree(const std::string& filename)
 template <int N>
 std::string ClusterReader<N>::getBranchName(const std::string& base, int index) const
 {
-  if constexpr (o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) {
+  if (mDoStaggering) {
     return mDetName + base + "_" + std::to_string(index);
   }
   return mDetName + base;
@@ -132,10 +130,10 @@ void ClusterReader<N>::setBranchAddress(const std::string& base, Ptr& addr, int
 namespace
 {
 template <int N>
-std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mctruth, bool usePatterns, bool triggerOut)
+std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mctruth, bool doStag, bool usePatterns, bool triggerOut)
 {
   std::vector<OutputSpec> outputs;
-  for (uint32_t iLayer = 0; iLayer < ((o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1); ++iLayer) {
+  for (uint32_t iLayer = 0; iLayer < ((doStag) ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1); ++iLayer) {
     outputs.emplace_back(detOrig, "CLUSTERSROF", iLayer, Lifetime::Timeframe);
     outputs.emplace_back(detOrig, "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
     if (usePatterns) {
@@ -143,7 +141,6 @@ std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mct
     }
     if (mctruth) {
       outputs.emplace_back(detOrig, "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
-      outputs.emplace_back(detOrig, "CLUSTERSMC2ROF", iLayer, Lifetime::Timeframe);
     }
   }
   if (triggerOut) {
@@ -153,25 +150,25 @@ std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mct
 }
 } // namespace
 
-DataProcessorSpec getITSClusterReaderSpec(bool useMC, bool usePatterns, bool triggerOut)
+DataProcessorSpec getITSClusterReaderSpec(bool useMC, bool doStag, bool usePatterns, bool triggerOut)
 {
   return DataProcessorSpec{
     .name = "its-cluster-reader",
     .inputs = Inputs{},
-    .outputs = makeOutChannels<o2::detectors::DetID::ITS>("ITS", useMC, usePatterns, triggerOut),
-    .algorithm = AlgorithmSpec{adaptFromTask<ITSClusterReader>(useMC, usePatterns, triggerOut)},
+    .outputs = makeOutChannels<o2::detectors::DetID::ITS>("ITS", useMC, doStag, usePatterns, triggerOut),
+    .algorithm = AlgorithmSpec{adaptFromTask<ITSClusterReader>(useMC, doStag, usePatterns, triggerOut)},
     .options = Options{
       {"its-cluster-infile", VariantType::String, "o2clus_its.root", {"Name of the input cluster file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
 }
 
-DataProcessorSpec getMFTClusterReaderSpec(bool useMC, bool usePatterns, bool triggerOut)
+DataProcessorSpec getMFTClusterReaderSpec(bool useMC, bool doStag, bool usePatterns, bool triggerOut)
 {
   return DataProcessorSpec{
     .name = "mft-cluster-reader",
     .inputs = Inputs{},
-    .outputs = makeOutChannels<o2::detectors::DetID::MFT>("MFT", useMC, usePatterns, triggerOut),
-    .algorithm = AlgorithmSpec{adaptFromTask<MFTClusterReader>(useMC, usePatterns, triggerOut)},
+    .outputs = makeOutChannels<o2::detectors::DetID::MFT>("MFT", useMC, doStag, usePatterns, triggerOut),
+    .algorithm = AlgorithmSpec{adaptFromTask<MFTClusterReader>(useMC, doStag, usePatterns, triggerOut)},
     .options = Options{
       {"mft-cluster-infile", VariantType::String, "mftclusters.root", {"Name of the input cluster file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
diff --git a/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
index c1900c346133b..e1857cbf2f775 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -18,7 +18,7 @@
 #include <format>
 
 #include "Framework/ConcreteDataMatcher.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSMFTWorkflow/ClusterWriterSpec.h"
 #include "DPLUtils/MakeRootTreeWriterSpec.h"
 #include "DataFormatsITSMFT/CompCluster.h"
@@ -37,71 +37,78 @@ using CompClusType = std::vector<o2::itsmft::CompClusterExt>;
 using PatternsType = std::vector<unsigned char>;
 using ROFrameRType = std::vector<o2::itsmft::ROFRecord>;
 using LabelsType = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
-using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
 using namespace o2::header;
 
 template <int N>
-DataProcessorSpec getClusterWriterSpec(bool useMC)
+DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag)
 {
   static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
-  constexpr int NLayers = (DPLAlpideParam<N>::supportsStaggering()) ? DPLAlpideParam<N>::getNLayers() : 1;
+  const int nLayers = (doStag) ? DPLAlpideParam<N>::getNLayers() : 1;
   const auto detName = Origin.as<std::string>();
   // Spectators for logging
-  auto compClusterSizes = std::make_shared<std::array<size_t, NLayers>>();
+  auto compClusterSizes = std::make_shared<std::vector<size_t>>(nLayers, 0);
   auto compClustersSizeGetter = [compClusterSizes](CompClusType const& compClusters, DataRef const& ref) {
     auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
     (*compClusterSizes)[dh->subSpecification] = compClusters.size();
   };
-  auto logger = [detName, compClusterSizes](std::vector<o2::itsmft::ROFRecord> const& rofs, DataRef const& ref) {
+  auto logger = [detName, compClusterSizes, doStag](std::vector<o2::itsmft::ROFRecord> const& rofs, DataRef const& ref) {
     auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
     const auto i = dh->subSpecification;
-    LOG(info) << detName << "ClusterWriter:" << i << " pulled " << (*compClusterSizes)[i] << " clusters, in " << rofs.size() << " RO frames";
+    LOG(info) << detName << "ClusterWriter" << ((doStag) ? std::format(" on layer {}", i) : "")
+              << " pulled " << (*compClusterSizes)[i] << " clusters, in " << rofs.size() << " RO frames";
   };
   auto getIndex = [](DataRef const& ref) -> size_t {
     auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
     return static_cast<size_t>(dh->subSpecification);
   };
-  auto getName = [](std::string base, size_t index) -> std::string {
-    if constexpr (DPLAlpideParam<N>::supportsStaggering()) {
+  auto getName = [doStag](std::string base, size_t index) -> std::string {
+    if (doStag) {
       return base += "_" + std::to_string(index);
     }
     return base;
   };
   auto detNameLC = detName;
   std::transform(detNameLC.begin(), detNameLC.end(), detNameLC.begin(), [](unsigned char c) { return std::tolower(c); });
+  std::vector<InputSpec> vecInpSpecClus, vecInpSpecPatt, vecInpSpecROF, vecInpSpecLbl;
+  vecInpSpecClus.reserve(nLayers);
+  vecInpSpecPatt.reserve(nLayers);
+  vecInpSpecROF.reserve(nLayers);
+  vecInpSpecLbl.reserve(nLayers);
+  for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    vecInpSpecClus.emplace_back(getName("compclus", iLayer), Origin, "COMPCLUSTERS", iLayer);
+    vecInpSpecPatt.emplace_back(getName("patterns", iLayer), Origin, "PATTERNS", iLayer);
+    vecInpSpecROF.emplace_back(getName("ROframes", iLayer), Origin, "CLUSTERSROF", iLayer);
+    vecInpSpecLbl.emplace_back(getName("labels", iLayer), Origin, "CLUSTERSMCTR", iLayer);
+  }
+
   return MakeRootTreeWriterSpec(std::format("{}-cluster-writer", detNameLC).c_str(),
                                 (o2::detectors::DetID::ITS == N) ? "o2clus_its.root" : "mftclusters.root",
                                 MakeRootTreeWriterSpec::TreeAttributes{.name = "o2sim", .title = std::format("Tree with {} clusters", detName)},
-                                BranchDefinition<CompClusType>{InputSpec{"compclus", ConcreteDataTypeMatcher{Origin, "COMPCLUSTERS"}},
+                                BranchDefinition<CompClusType>{vecInpSpecClus,
                                                                (detName + "ClusterComp").c_str(), "compact-cluster-branch",
-                                                               NLayers,
+                                                               nLayers,
                                                                compClustersSizeGetter,
                                                                getIndex,
                                                                getName},
-                                BranchDefinition<PatternsType>{InputSpec{"patterns", ConcreteDataTypeMatcher{Origin, "PATTERNS"}},
+                                BranchDefinition<PatternsType>{vecInpSpecPatt,
                                                                (detName + "ClusterPatt").c_str(), "cluster-pattern-branch",
-                                                               NLayers,
+                                                               nLayers,
                                                                getIndex,
                                                                getName},
-                                BranchDefinition<ROFrameRType>{InputSpec{"ROframes", ConcreteDataTypeMatcher{Origin, "CLUSTERSROF"}},
+                                BranchDefinition<ROFrameRType>{vecInpSpecROF,
                                                                (detName + "ClustersROF").c_str(), "cluster-rof-branch",
-                                                               NLayers,
+                                                               nLayers,
                                                                logger,
                                                                getIndex,
                                                                getName},
-                                BranchDefinition<LabelsType>{InputSpec{"labels", ConcreteDataTypeMatcher{Origin, "CLUSTERSMCTR"}},
+                                BranchDefinition<LabelsType>{vecInpSpecLbl,
                                                              (detName + "ClusterMCTruth").c_str(), "cluster-label-branch",
-                                                             (useMC ? NLayers : 0),
-                                                             getIndex,
-                                                             getName},
-                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", ConcreteDataTypeMatcher{Origin, "CLUSTERSMC2ROF"}},
-                                                             (detName + "ClustersMC2ROF").c_str(), "cluster-mc2rof-branch",
-                                                             (useMC ? NLayers : 0),
+                                                             (useMC ? nLayers : 0),
                                                              getIndex,
                                                              getName})();
 }
 
-framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC) { return getClusterWriterSpec<o2::detectors::DetID::ITS>(useMC); }
-framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC) { return getClusterWriterSpec<o2::detectors::DetID::MFT>(useMC); }
+framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC, bool doStag) { return getClusterWriterSpec<o2::detectors::DetID::ITS>(useMC, doStag); }
+framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC, bool doStag) { return getClusterWriterSpec<o2::detectors::DetID::MFT>(useMC, doStag); }
 
 } // namespace o2::itsmft
diff --git a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
index fc0dd5dbae7da..0672f7d13bed2 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -12,6 +12,7 @@
 /// @file   ClustererSpec.cxx
 
 #include <vector>
+#include <format>
 
 #include "ITSMFTWorkflow/ClustererSpec.h"
 #include "Framework/ControlService.h"
@@ -29,7 +30,7 @@
 #include "DataFormatsParameters/GRPObject.h"
 #include "ITSMFTReconstruction/DigitPixelReader.h"
 #include "DetectorsBase/GeometryManager.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "CommonConstants/LHCConstants.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
 #include "ITSMFTReconstruction/ClustererParam.h"
@@ -37,6 +38,14 @@
 namespace o2::itsmft
 {
 
+template <int N>
+ClustererDPL<N>::ClustererDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool doStag) : mGGCCDBRequest(gr), mUseMC(useMC), mDoStaggering(doStag)
+{
+  if (mDoStaggering) {
+    mLayers = DPLAlpideParam<N>::getNLayers();
+  }
+}
+
 template <int N>
 void ClustererDPL<N>::init(InitContext& ic)
 {
@@ -48,12 +57,11 @@ void ClustererDPL<N>::init(InitContext& ic)
   mDetName = Origin.as<std::string>();
 
   // prepare data filter
-  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
+  for (int iLayer = 0; iLayer < mLayers; ++iLayer) {
     mFilter.emplace_back("digits", Origin, "DIGITS", iLayer, Lifetime::Timeframe);
     mFilter.emplace_back("ROframe", Origin, "DIGITSROF", iLayer, Lifetime::Timeframe);
     if (mUseMC) {
       mFilter.emplace_back("labels", Origin, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
-      mFilter.emplace_back("MC2ROframes", Origin, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
     }
   }
 }
@@ -64,10 +72,9 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
   updateTimeDependentParams(pc);
 
   // filter input and compose
-  std::array<gsl::span<const o2::itsmft::Digit>, NLayers> digits;
-  std::array<gsl::span<const o2::itsmft::ROFRecord>, NLayers> rofs;
-  std::array<gsl::span<const char>, NLayers> labelsbuffer;
-  std::array<gsl::span<const o2::itsmft::MC2ROFRecord>, NLayers> mc2rofs;
+  std::vector<gsl::span<const o2::itsmft::Digit>> digits(mLayers);
+  std::vector<gsl::span<const o2::itsmft::ROFRecord>> rofs(mLayers);
+  std::vector<gsl::span<const char>> labelsbuffer(mLayers);
   for (const DataRef& ref : InputRecordWalker{pc.inputs(), mFilter}) {
     auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
     if (DataRefUtils::match(ref, {"digits", ConcreteDataTypeMatcher{Origin, "DIGITS"}})) {
@@ -79,9 +86,6 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
     if (DataRefUtils::match(ref, {"labels", ConcreteDataTypeMatcher{Origin, "DIGITSMCTR"}})) {
       labelsbuffer[dh->subSpecification] = pc.inputs().get<gsl::span<char>>(ref);
     }
-    if (DataRefUtils::match(ref, {"MC2ROframes", ConcreteDataTypeMatcher{Origin, "DIGITSMC2ROF"}})) {
-      mc2rofs[dh->subSpecification] = pc.inputs().get<gsl::span<o2::itsmft::MC2ROFRecord>>(ref);
-    }
   }
 
   // query the first orbit in this TF
@@ -93,10 +97,10 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
   uint64_t nClusters{0};
   TStopwatch sw;
   o2::itsmft::DigitPixelReader reader;
-  for (uint32_t iLayer{0}; iLayer < NLayers; ++iLayer) {
-    int layer = (DPLAlpideParam<N>::supportsStaggering()) ? iLayer : -1;
+  for (uint32_t iLayer{0}; iLayer < mLayers; ++iLayer) {
+    int layer = (mDoStaggering) ? iLayer : -1;
     sw.Start();
-    LOG(info) << mDetName << "Clusterer:" << layer << " pulled " << digits[iLayer].size() << " digits, in " << rofs[iLayer].size() << " RO frames";
+    LOG(info) << mDetName << "Clusterer" << ((mDoStaggering) ? std::format(" on layer {}", layer) : "") << " pulled " << digits[iLayer].size() << " digits, in " << rofs[iLayer].size() << " RO frames";
 
     mClusterer->setMaxROFDepthToSquash(mClusterer->getMaxROFDepthToSquash(layer));
     o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelsbuffer[iLayer]);
@@ -106,8 +110,7 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
     reader.setDigits(digits[iLayer]);
     reader.setROFRecords(rofs[iLayer]);
     if (mUseMC) {
-      reader.setMC2ROFRecords(mc2rofs[iLayer]);
-      LOG(info) << mDetName << "Clusterer:" << layer << " pulled " << labels.getNElements() << " labels ";
+      LOG(info) << mDetName << "Clusterer" << ((mDoStaggering) ? std::format(" on layer {}", layer) : "") << " pulled " << labels.getNElements() << " labels ";
       reader.setDigitsMCTruth(labels.getIndexedSize() > 0 ? &labels : nullptr);
     }
     reader.init();
@@ -131,7 +134,7 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
     for (int iROF{0}; iROF < nROFsTF; ++iROF) {
       auto& rof = expClusRofVec[iROF];
       int orb = iROF * par.getROFLengthInBC(iLayer) / o2::constants::lhc::LHCMaxBunches + firstTForbit;
-      int bc = iROF * par.getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches;
+      int bc = iROF * par.getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches + par.getROFDelayInBC(iLayer);
       o2::InteractionRecord ir(bc, orb);
       rof.setBCData(ir);
       rof.setROFrame(iROF);
@@ -142,13 +145,18 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
     for (const auto& rof : clusROFVec) {
       const auto& ir = rof.getBCData();
       if (ir < firstIR) {
-        LOGP(warn, "Discard ROF {} preceding TF 1st orbit {}, layer:{}", ir.asString(), firstTForbit, iLayer);
+        LOGP(warn, "Discard ROF {} preceding TF 1st orbit {}{}", ir.asString(), firstTForbit, ((mDoStaggering) ? std::format(" on layer {}", layer) : ""));
+        continue;
+      }
+      auto irToFirst = ir - firstIR;
+      if (irToFirst.toLong() - par.getROFDelayInBC(iLayer) < 0) {
+        LOGP(warn, "Discard ROF {} preceding TF 1st orbit {} due to imposed ROF delay{}", ir.asString(), firstTForbit, ((mDoStaggering) ? std::format(" on layer {}", iLayer) : ""));
         continue;
       }
-      const auto irToFirst = ir - firstIR;
+      irToFirst -= par.getROFDelayInBC(iLayer);
       const long irROF = irToFirst.toLong() / par.getROFLengthInBC(iLayer);
       if (irROF >= nROFsTF) {
-        LOGP(warn, "Discard ROF {} exceding TF orbit range, layer:{}", ir.asString(), iLayer);
+        LOGP(warn, "Discard ROF {} exceeding TF orbit range{}", ir.asString(), ((mDoStaggering) ? std::format(" on layer {}", layer) : ""));
         continue;
       }
       auto& expROF = expClusRofVec[irROF];
@@ -157,11 +165,11 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
         expROF.setNEntries(rof.getNEntries());
       } else {
         if (expROF.getNEntries() < rof.getNEntries()) {
-          LOGP(warn, "Repeating ROF {} with {} clusters, prefer to already processed instance with {} clusters", rof.asString(), rof.getNEntries(), expROF.getNEntries());
+          LOGP(warn, "Repeating {} with {} clusters, prefer to already processed instance with {} clusters{}", rof.asString(), rof.getNEntries(), expROF.getNEntries(), ((mDoStaggering) ? std::format(" on layer {}", layer) : ""));
           expROF.setFirstEntry(rof.getFirstEntry());
           expROF.setNEntries(rof.getNEntries());
         } else {
-          LOGP(warn, "Repeating ROF {} with {} clusters, discard preferring already processed instance with {} clusters", rof.asString(), rof.getNEntries(), expROF.getNEntries());
+          LOGP(warn, "Repeating {} with {} clusters, discard preferring already processed instance with {} clusters{}", rof.asString(), rof.getNEntries(), expROF.getNEntries(), ((mDoStaggering) ? std::format(" on layer {}", layer) : ""));
         }
       }
     }
@@ -182,18 +190,11 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
 
     if (mUseMC) {
       pc.outputs().snapshot(Output{Origin, "CLUSTERSMCTR", iLayer}, *clusterLabels); // at the moment requires snapshot
-      std::vector<o2::itsmft::MC2ROFRecord> clusterMC2ROframes(mc2rofs[iLayer].size());
-      for (int i = mc2rofs[iLayer].size(); i--;) {
-        clusterMC2ROframes[i] = mc2rofs[iLayer][i]; // Simply, replicate it from digits ?
-      }
-      pc.outputs().snapshot(Output{Origin, "CLUSTERSMC2ROF", iLayer}, clusterMC2ROframes);
     }
     reader.reset();
 
-    // TODO: in principle, after masking "overflow" pixels the MC2ROFRecord maxROF supposed to change, nominally to minROF
-    // -> consider recalculationg maxROF
     sw.Stop();
-    LOG(info) << mDetName << "Clusterer:" << layer << " pushed " << clusCompVec.size() << " clusters, in " << nROFs << " RO frames in " << sw.RealTime() << " s";
+    LOG(info) << mDetName << "Clusterer" << ((mDoStaggering) ? std::format(": {}", iLayer) : "") << " pushed " << clusCompVec.size() << " clusters, in " << nROFs << " RO frames in " << sw.RealTime() << " s";
   }
 
   LOG(info) << mDetName << "Clusterer produced " << nClusters << " clusters";
@@ -230,9 +231,9 @@ void ClustererDPL<N>::updateTimeDependentParams(ProcessingContext& pc)
       nROFsToSquash = 2 + int(clParams.maxSOTMUS / (rofBC * o2::constants::lhc::LHCBunchSpacingMUS)); // use squashing
     }
     mClusterer->setMaxROFDepthToSquash(nROFsToSquash);
-    if constexpr (DPLAlpideParam<N>::supportsStaggering()) {
+    if (mDoStaggering) {
       if (mClusterer->isContinuousReadOut()) {
-        for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
+        for (int iLayer{0}; iLayer < mLayers; ++iLayer) {
           mClusterer->addMaxBCSeparationToSquash(alpParams.getROFLengthInBC(iLayer) + clParams.getMaxBCDiffToSquashBias(iLayer));
           mClusterer->addMaxROFDepthToSquash((clParams.getMaxBCDiffToSquashBias(iLayer) > 0) ? 2 + int(clParams.maxSOTMUS / (alpParams.getROFLengthInBC(iLayer) * o2::constants::lhc::LHCBunchSpacingMUS)) : 0);
         }
@@ -275,17 +276,16 @@ void ClustererDPL<N>::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 namespace
 {
 template <int N>
-DataProcessorSpec getClustererSpec(bool useMC)
+DataProcessorSpec getClustererSpec(bool useMC, bool doStag)
 {
   constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
   std::vector<InputSpec> inputs;
-  constexpr uint32_t nLayers = (DPLAlpideParam<N>::supportsStaggering()) ? DPLAlpideParam<N>::getNLayers() : 1;
+  uint32_t nLayers = doStag ? DPLAlpideParam<N>::getNLayers() : 1;
   for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
     inputs.emplace_back("digits", Origin, "DIGITS", iLayer, Lifetime::Timeframe);
     inputs.emplace_back("ROframes", Origin, "DIGITSROF", iLayer, Lifetime::Timeframe);
     if (useMC) {
       inputs.emplace_back("labels", Origin, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
-      inputs.emplace_back("MC2ROframes", Origin, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
     }
   }
   inputs.emplace_back("cldict", Origin, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(Origin.as<std::string>() + "/Calib/ClusterDictionary"));
@@ -306,28 +306,27 @@ DataProcessorSpec getClustererSpec(bool useMC)
     outputs.emplace_back(Origin, "CLUSTERSROF", iLayer, Lifetime::Timeframe);
     if (useMC) {
       outputs.emplace_back(Origin, "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
-      outputs.emplace_back(Origin, "CLUSTERSMC2ROF", iLayer, Lifetime::Timeframe);
     }
   }
   return DataProcessorSpec{
     .name = (N == o2::detectors::DetID::ITS) ? "its-clusterer" : "mft-clusterer",
     .inputs = inputs,
     .outputs = outputs,
-    .algorithm = AlgorithmSpec{adaptFromTask<ClustererDPL<N>>(ggRequest, useMC)},
+    .algorithm = AlgorithmSpec{adaptFromTask<ClustererDPL<N>>(ggRequest, useMC, doStag)},
     .options = Options{
       {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}},
       {"nthreads", VariantType::Int, 1, {"Number of clustering threads"}}}};
 }
 } // namespace
 
-framework::DataProcessorSpec getITSClustererSpec(bool useMC)
+framework::DataProcessorSpec getITSClustererSpec(bool useMC, bool doStag)
 {
-  return getClustererSpec<o2::detectors::DetID::ITS>(useMC);
+  return getClustererSpec<o2::detectors::DetID::ITS>(useMC, doStag);
 }
 
-framework::DataProcessorSpec getMFTClustererSpec(bool useMC)
+framework::DataProcessorSpec getMFTClustererSpec(bool useMC, bool doStag)
 {
-  return getClustererSpec<o2::detectors::DetID::MFT>(useMC);
+  return getClustererSpec<o2::detectors::DetID::MFT>(useMC, doStag);
 }
 
 } // namespace o2::itsmft
diff --git a/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
index ec86da4833a0d..6a57933f18048 100644
--- a/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -13,14 +13,15 @@
 
 #include <string>
 #include <vector>
+#include <format>
 
-#include "TTree.h"
+#include <TTree.h>
 
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/Logger.h"
 #include "ITSMFTWorkflow/DigitReaderSpec.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
 #include "ITSMFTReconstruction/ChipMappingMFT.h"
 #include "SimulationDataFormat/MCCompLabel.h"
@@ -41,22 +42,21 @@ namespace itsmft
 {
 
 template <int N>
-DigitReader<N>::DigitReader(bool useMC, bool useCalib, bool triggerOut) : mUseMC(useMC), mUseCalib(useCalib), mTriggerOut(triggerOut), mDetNameLC(mDetName = ID.getName()), mDigTreeName("o2sim")
+DigitReader<N>::DigitReader(bool useMC, bool doStag, bool useCalib, bool triggerOut) : mUseMC(useMC), mDoStaggering(doStag), mUseCalib(useCalib), mTriggerOut(triggerOut), mDetNameLC(mDetName = ID.getName()), mDigTreeName("o2sim")
 {
   mDigitBranchName = mDetName + mDigitBranchName;
   mDigitROFBranchName = mDetName + mDigitROFBranchName;
   mCalibBranchName = mDetName + mCalibBranchName;
 
   mDigitMCTruthBranchName = mDetName + mDigitMCTruthBranchName;
-  mDigitMC2ROFBranchName = mDetName + mDigitMC2ROFBranchName;
 
   std::transform(mDetNameLC.begin(), mDetNameLC.end(), mDetNameLC.begin(), ::tolower);
 
-  for (uint32_t i = 0; i < NLayers; ++i) {
-    mDigits[i] = nullptr;
-    mDigROFRec[i] = nullptr;
-    mDigMC2ROFs[i] = nullptr;
-    mPLabels[i] = nullptr;
+  if (mDoStaggering) {
+    mLayers = DPLAlpideParam<N>::getNLayers();
+    mDigits.resize(mLayers, nullptr);
+    mDigROFRec.resize(mLayers, nullptr);
+    mPLabels.resize(mLayers, nullptr);
   }
 }
 
@@ -103,8 +103,8 @@ void DigitReader<N>::run(ProcessingContext& pc)
     ent++;
     assert(ent < mTree->GetEntries()); // this should not happen
     mTree->GetEntry(ent);
-    for (uint32_t iLayer = 0; iLayer < RLayers; ++iLayer) {
-      LOG(info) << mDetName << "DigitReader:" << iLayer << " pushes " << mDigROFRec[iLayer]->size() << " ROFRecords, " << mDigits[iLayer]->size() << " digits at entry " << ent;
+    for (uint32_t iLayer = 0; iLayer < mLayers; ++iLayer) {
+      LOG(info) << mDetName << "DigitReader" << ((mDoStaggering) ? std::format(": {}", iLayer) : "") << " pushes " << mDigROFRec[iLayer]->size() << " ROFRecords, " << mDigits[iLayer]->size() << " digits at entry " << ent;
       pc.outputs().snapshot(Output{Origin, "DIGITSROF", iLayer}, *mDigROFRec[iLayer]);
       pc.outputs().snapshot(Output{Origin, "DIGITS", iLayer}, *mDigits[iLayer]);
       if (mUseMC) {
@@ -112,7 +112,6 @@ void DigitReader<N>::run(ProcessingContext& pc)
         mPLabels[iLayer]->copyandflatten(sharedlabels);
         delete mPLabels[iLayer];
         mPLabels[iLayer] = nullptr;
-        pc.outputs().snapshot(Output{Origin, "DIGITSMC2ROF", iLayer}, *mDigMC2ROFs[iLayer]);
       }
     }
     if (mUseCalib) {
@@ -131,7 +130,6 @@ void DigitReader<N>::run(ProcessingContext& pc)
     std::vector<o2::itsmft::Digit> digitsSel;
     std::vector<o2::itsmft::GBTCalibData> calibSel;
     std::vector<o2::itsmft::ROFRecord> digROFRecSel;
-    std::vector<o2::itsmft::MC2ROFRecord> digMC2ROFsSel;
     o2::dataformats::MCTruthContainer<o2::MCCompLabel> digitLabelsSel;
 
     if (irFrames.size()) { // we assume the IRFrames are in the increasing order
@@ -181,26 +179,6 @@ void DigitReader<N>::run(ProcessingContext& pc)
             }
           }
         }
-        if (mUseMC) {
-          digMC2ROFsSel = *mDigMC2ROFs[0];
-          for (auto& mc2rof : digMC2ROFsSel) {
-            if (mc2rof.rofRecordID < 0) {
-              continue; // did not contribute even to the original data
-            }
-            unsigned int mn = 0xffff, mx = 0;
-            for (int ir = mc2rof.minROF; ir <= mc2rof.maxROF; ir++) {
-              if (rofOld2New[ir] >= 0) { // used
-                mx = rofOld2New[ir];
-                if (mn > mx) {
-                  mn = mx;
-                }
-              }
-            }
-            mc2rof.rofRecordID = mn == 0xffff ? -1 : int(mn);
-            mc2rof.minROF = mn;
-            mc2rof.maxROF = mx;
-          }
-        }
         if (mDigROFRec[0]->back().getBCData() + mROFLengthInBC - 1 < irMax) { // need to check the next entry
           ent++;
           continue;
@@ -220,7 +198,6 @@ void DigitReader<N>::run(ProcessingContext& pc)
     if (mUseMC) {
       auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{Origin, "DIGITSMCTR", 0});
       digitLabelsSel.flatten_to(sharedlabels);
-      pc.outputs().snapshot(Output{Origin, "DIGITSMC2ROF", 0}, digMC2ROFsSel);
     }
 
     if (!irFrames.size() || irFrames.back().isLast()) {
@@ -238,14 +215,13 @@ void DigitReader<N>::connectTree(const std::string& filename)
   assert(mFile && !mFile->IsZombie());
   mTree.reset((TTree*)mFile->Get(mDigTreeName.c_str()));
   assert(mTree);
-  for (uint32_t iLayer = 0; iLayer < RLayers; ++iLayer) {
+  for (uint32_t iLayer = 0; iLayer < mLayers; ++iLayer) {
     setBranchAddress(mDigitROFBranchName, mDigROFRec[iLayer], iLayer);
     setBranchAddress(mDigitBranchName, mDigits[iLayer], iLayer);
     if (mUseMC) {
-      if (!mTree->GetBranch(getBranchName(mDigitMC2ROFBranchName, iLayer).c_str()) || !mTree->GetBranch(getBranchName(mDigitMCTruthBranchName, iLayer).c_str())) {
+      if (!mTree->GetBranch(getBranchName(mDigitMCTruthBranchName, iLayer).c_str())) {
         throw std::runtime_error("MC data requested but not found in the tree");
       }
-      setBranchAddress(mDigitMC2ROFBranchName, mDigMC2ROFs[iLayer], iLayer);
       if (!mPLabels[iLayer]) {
         setBranchAddress(mDigitMCTruthBranchName, mPLabels[iLayer], iLayer);
       }
@@ -263,10 +239,10 @@ void DigitReader<N>::connectTree(const std::string& filename)
 template <int N>
 std::string DigitReader<N>::getBranchName(const std::string& base, int index)
 {
-  if constexpr (!o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) {
-    return base;
+  if (mDoStaggering) {
+    return base + "_" + std::to_string(index);
   }
-  return base + "_" + std::to_string(index);
+  return base;
 }
 
 template <int N>
@@ -282,16 +258,15 @@ void DigitReader<N>::setBranchAddress(const std::string& base, Ptr& addr, int la
 namespace
 {
 template <int N>
-std::vector<OutputSpec> makeOutChannels(bool mctruth, bool useCalib)
+std::vector<OutputSpec> makeOutChannels(bool mctruth, bool doStag, bool useCalib)
 {
   constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
   std::vector<OutputSpec> outputs;
-  static constexpr int RLayers = o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1;
-  for (int iLayer = 0; iLayer < RLayers; ++iLayer) {
+  int nLayers = doStag ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1;
+  for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
     outputs.emplace_back(Origin, "DIGITS", iLayer, Lifetime::Timeframe);
     outputs.emplace_back(Origin, "DIGITSROF", iLayer, Lifetime::Timeframe);
     if (mctruth) {
-      outputs.emplace_back(Origin, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
       outputs.emplace_back(Origin, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
     }
   }
@@ -303,25 +278,25 @@ std::vector<OutputSpec> makeOutChannels(bool mctruth, bool useCalib)
 }
 } // namespace
 
-DataProcessorSpec getITSDigitReaderSpec(bool useMC, bool useCalib, bool useTriggers, std::string defname)
+DataProcessorSpec getITSDigitReaderSpec(bool useMC, bool doStag, bool useCalib, bool useTriggers, std::string defname)
 {
   return DataProcessorSpec{
     .name = "its-digit-reader",
     .inputs = Inputs{},
-    .outputs = makeOutChannels<o2::detectors::DetID::ITS>(useMC, useCalib),
-    .algorithm = AlgorithmSpec{adaptFromTask<ITSDigitReader>(useMC, useCalib)},
+    .outputs = makeOutChannels<o2::detectors::DetID::ITS>(useMC, doStag, useCalib),
+    .algorithm = AlgorithmSpec{adaptFromTask<ITSDigitReader>(useMC, doStag, useCalib, useTriggers)},
     .options = Options{
       {"its-digit-infile", VariantType::String, defname, {"Name of the input digit file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
 }
 
-DataProcessorSpec getMFTDigitReaderSpec(bool useMC, bool useCalib, bool useTriggers, std::string defname)
+DataProcessorSpec getMFTDigitReaderSpec(bool useMC, bool doStag, bool useCalib, bool useTriggers, std::string defname)
 {
   return DataProcessorSpec{
     .name = "mft-digit-reader",
     .inputs = Inputs{},
-    .outputs = makeOutChannels<o2::detectors::DetID::MFT>(useMC, useCalib),
-    .algorithm = AlgorithmSpec{adaptFromTask<MFTDigitReader>(useMC, useCalib)},
+    .outputs = makeOutChannels<o2::detectors::DetID::MFT>(useMC, doStag, useCalib),
+    .algorithm = AlgorithmSpec{adaptFromTask<MFTDigitReader>(useMC, doStag, useCalib, useTriggers)},
     .options = Options{
       {"mft-digit-infile", VariantType::String, defname, {"Name of the input digit file"}},
       {"input-dir", VariantType::String, "none", {"Input directory"}}}};
diff --git a/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx b/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
index c4f1e336180c7..d409356c6846f 100644
--- a/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
@@ -14,7 +14,7 @@
 #include "ITSMFTWorkflow/DigitWriterSpec.h"
 #include "Framework/ConcreteDataMatcher.h"
 #include "Framework/DataRef.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DPLUtils/MakeRootTreeWriterSpec.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/GBTCalibData.h"
@@ -43,20 +43,20 @@ using MCCont = o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>;
 /// create the processor spec
 /// describing a processor receiving digits for ITS/MFT and writing them to file
 template <int N>
-DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib)
+DataProcessorSpec getDigitWriterSpec(bool mctruth, bool doStag, bool dec, bool calib)
 {
   static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
-  constexpr int NLayers = o2::itsmft::DPLAlpideParam<N>::supportsStaggering() ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1;
+  int mLayers = doStag ? o2::itsmft::DPLAlpideParam<N>::getNLayers() : 1;
   std::string detStr = o2::detectors::DetID::getName(N);
   std::string detStrL = dec ? "o2_" : ""; // for decoded digits prepend by o2
   detStrL += detStr;
   std::transform(detStrL.begin(), detStrL.end(), detStrL.begin(), ::tolower);
-  auto digitSizes = std::make_shared<std::array<size_t, NLayers>>();
+  auto digitSizes = std::make_shared<std::vector<size_t>>(mLayers, 0);
   auto digitSizeGetter = [digitSizes](std::vector<o2::itsmft::Digit> const& inDigits, DataRef const& ref) {
     auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
     (*digitSizes)[dh->subSpecification] = inDigits.size();
   };
-  auto rofSizes = std::make_shared<std::array<size_t, NLayers>>();
+  auto rofSizes = std::make_shared<std::vector<size_t>>(mLayers, 0);
   auto rofSizeGetter = [rofSizes](std::vector<o2::itsmft::ROFRecord> const& inROFs, DataRef const& ref) {
     auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
     (*rofSizes)[dh->subSpecification] = inROFs.size();
@@ -84,11 +84,11 @@ DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib)
   // handler for labels
   // This is necessary since we can't store the original label buffer in a ROOT entry -- as is -- if it exceeds a certain size.
   // We therefore convert it to a special split class.
-  auto fillLabels = [digitSizes, rofSizes](TBranch& branch, std::vector<char> const& labelbuffer, DataRef const& ref) {
+  auto fillLabels = [detStr, doStag, digitSizes, rofSizes](TBranch& branch, std::vector<char> const& labelbuffer, DataRef const& ref) {
     o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
     auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
     auto layer = static_cast<size_t>(dh->subSpecification);
-    LOG(info) << "WRITING " << labels.getNElements() << " LABELS FOR " << layer << " WITH " << (*digitSizes)[layer] << " DIGITS IN " << (*rofSizes)[layer] << " ROFS";
+    LOG(info) << detStr << ": WRITING " << labels.getNElements() << " LABELS" << (doStag ? std::format(" FOR LAYER {}", layer) : "") << " WITH " << (*digitSizes)[layer] << " DIGITS IN " << (*rofSizes)[layer] << " ROFS";
 
     o2::dataformats::IOMCTruthContainerView outputcontainer;
     auto ptr = &outputcontainer;
@@ -102,52 +102,58 @@ DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib)
     auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
     return static_cast<size_t>(dh->subSpecification);
   };
-  auto getName = [](std::string base, size_t index) -> std::string {
-    if constexpr (o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) {
+  auto getName = [doStag](std::string base, size_t index) -> std::string {
+    if (doStag) {
       return base += "_" + std::to_string(index);
     }
     return base;
   };
+
+  std::vector<InputSpec> vecInpSpecDig, vecInpSpecROF, vecInpSpecLbl;
+  vecInpSpecDig.reserve(mLayers);
+  vecInpSpecROF.reserve(mLayers);
+  vecInpSpecLbl.reserve(mLayers);
+  for (int iLayer = 0; iLayer < mLayers; iLayer++) {
+    vecInpSpecDig.emplace_back(getName(detStr + "digits", iLayer), Origin, "DIGITS", iLayer);
+    vecInpSpecROF.emplace_back(getName(detStr + "digitsROF", iLayer), Origin, "DIGITSROF", iLayer);
+    vecInpSpecLbl.emplace_back(getName(detStr + "_digitsMCTR", iLayer), Origin, "DIGITSMCTR", iLayer);
+  }
+
   return MakeRootTreeWriterSpec((detStr + "DigitWriter" + (dec ? "_dec" : "")).c_str(),
                                 (detStrL + "digits.root").c_str(),
                                 MakeRootTreeWriterSpec::TreeAttributes{.name = "o2sim", .title = detStr + " Digits tree"},
                                 MakeRootTreeWriterSpec::CustomClose(finishWriting),
-                                BranchDefinition<std::vector<itsmft::Digit>>{InputSpec{detStr + "digits", ConcreteDataTypeMatcher{Origin, "DIGITS"}},
+                                BranchDefinition<std::vector<itsmft::Digit>>{vecInpSpecDig,
                                                                              detStr + "Digit", "digit-branch",
-                                                                             NLayers,
+                                                                             mLayers,
                                                                              digitSizeGetter,
                                                                              getIndex,
                                                                              getName},
-                                BranchDefinition<std::vector<itsmft::ROFRecord>>{InputSpec{detStr + "digitsROF", ConcreteDataTypeMatcher{Origin, "DIGITSROF"}},
+                                BranchDefinition<std::vector<itsmft::ROFRecord>>{vecInpSpecROF,
                                                                                  detStr + "DigitROF", "digit-rof-branch",
-                                                                                 NLayers,
+                                                                                 mLayers,
                                                                                  rofSizeGetter,
                                                                                  getIndex,
                                                                                  getName},
-                                BranchDefinition<std::vector<char>>{InputSpec{detStr + "_digitsMCTR", ConcreteDataTypeMatcher{Origin, "DIGITSMCTR"}},
+                                BranchDefinition<std::vector<char>>{vecInpSpecLbl,
                                                                     detStr + "DigitMCTruth", "digit-mctruth-branch",
-                                                                    (mctruth ? NLayers : 0),
+                                                                    (mctruth ? mLayers : 0),
                                                                     fillLabels,
                                                                     getIndex,
                                                                     getName},
-                                BranchDefinition<std::vector<itsmft::MC2ROFRecord>>{InputSpec{detStr + "_digitsMC2ROF", ConcreteDataTypeMatcher{Origin, "DIGITSMC2ROF"}},
-                                                                                    detStr + "DigitMC2ROF", "digit-mc2rof-branch",
-                                                                                    (mctruth ? NLayers : 0),
-                                                                                    getIndex,
-                                                                                    getName},
                                 BranchDefinition<std::vector<itsmft::GBTCalibData>>{InputSpec{detStr + "calib", ConcreteDataTypeMatcher{Origin, "GBTCALIB"}},
                                                                                     detStr + "Calib", "digit-calib-branch",
                                                                                     (calib ? 1 : 0)})();
 }
 
-DataProcessorSpec getITSDigitWriterSpec(bool mctruth, bool dec, bool calib)
+DataProcessorSpec getITSDigitWriterSpec(bool mctruth, bool doStag, bool dec, bool calib)
 {
-  return getDigitWriterSpec<o2::detectors::DetID::ITS>(mctruth, dec, calib);
+  return getDigitWriterSpec<o2::detectors::DetID::ITS>(mctruth, doStag, dec, calib);
 }
 
-DataProcessorSpec getMFTDigitWriterSpec(bool mctruth, bool dec, bool calib)
+DataProcessorSpec getMFTDigitWriterSpec(bool mctruth, bool doStag, bool dec, bool calib)
 {
-  return getDigitWriterSpec<o2::detectors::DetID::MFT>(mctruth, dec, calib);
+  return getDigitWriterSpec<o2::detectors::DetID::MFT>(mctruth, doStag, dec, calib);
 }
 
 } // end namespace itsmft
diff --git a/Detectors/ITSMFT/common/workflow/src/EntropyDecoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/EntropyDecoderSpec.cxx
index f90b708af1996..1107ca2fd34f6 100644
--- a/Detectors/ITSMFT/common/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/EntropyDecoderSpec.cxx
@@ -20,6 +20,7 @@
 #include "ITSMFTWorkflow/EntropyDecoderSpec.h"
 #include "ITSMFTReconstruction/ClustererParam.h"
 #include "DetectorsCommonDataFormats/DetectorNameConf.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/PhysTrigger.h"
 
 using namespace o2::framework;
@@ -28,25 +29,33 @@ namespace o2
 {
 namespace itsmft
 {
-EntropyDecoderSpec::EntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits, const std::string& ctfdictOpt)
-  : mOrigin(orig), mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, orig == o2::header::gDataOriginITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT, ctfdictOpt), mGetDigits(getDigits)
+
+template <int N>
+std::string EntropyDecoderSpec<N>::getBinding(const std::string& name, int spec)
+{
+  return fmt::format("{}_{}", name, spec);
+}
+
+template <int N>
+EntropyDecoderSpec<N>::EntropyDecoderSpec(int verbosity, bool doStag, bool getDigits, const std::string& ctfdictOpt)
+  : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Decoder, doStag, ctfdictOpt), mDoStaggering(doStag), mGetDigits(getDigits)
 {
-  assert(orig == o2::header::gDataOriginITS || orig == o2::header::gDataOriginMFT);
-  mDetPrefix = orig == o2::header::gDataOriginITS ? "_ITS" : "_MFT";
   mTimer.Stop();
   mTimer.Reset();
   mCTFCoder.setVerbosity(verbosity);
-  mCTFCoder.setDictBinding(std::string("ctfdict") + mDetPrefix);
+  mCTFCoder.setDictBinding(std::string("ctfdict_") + ID.getName());
 }
 
-void EntropyDecoderSpec::init(o2::framework::InitContext& ic)
+template <int N>
+void EntropyDecoderSpec<N>::init(o2::framework::InitContext& ic)
 {
-  mCTFCoder.init<CTF>(ic);
+  mCTFCoder.template init<CTF>(ic);
   mMaskNoise = ic.options().get<bool>("mask-noise");
   mUseClusterDictionary = !ic.options().get<bool>("ignore-cluster-dictionary");
 }
 
-void EntropyDecoderSpec::run(ProcessingContext& pc)
+template <int N>
+void EntropyDecoderSpec<N>::run(ProcessingContext& pc)
 {
   if (pc.services().get<o2::framework::TimingInfo>().globalRunNumberChanged) {
     mTimer.Reset();
@@ -54,105 +63,142 @@ void EntropyDecoderSpec::run(ProcessingContext& pc)
   auto cput = mTimer.CpuTime();
   mTimer.Start(false);
   o2::ctf::CTFIOSize iosize;
+  size_t ndigcl = 0, nrofs = 0;
   updateTimeDependentParams(pc);
-  auto buff = pc.inputs().get<gsl::span<o2::ctf::BufferType>>(std::string("ctf") + mDetPrefix);
-  // since the buff is const, we cannot use EncodedBlocks::relocate directly, instead we wrap its data to another flat object
-  //  const auto ctfImage = o2::itsmft::CTF::getImage(buff.data());
-
-  // this produces weird memory problems in unrelated devices, to be understood
-  // auto& trigs = pc.outputs().make<std::vector<o2::itsmft::PhysTrigger>>(OutputRef{"phystrig"}); // dummy output
-
-  auto& rofs = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(OutputRef{"ROframes"});
-  if (mGetDigits) {
-    auto& digits = pc.outputs().make<std::vector<o2::itsmft::Digit>>(OutputRef{"Digits"});
-    if (buff.size()) {
-      iosize = mCTFCoder.decode(o2::itsmft::CTF::getImage(buff.data()), rofs, digits, mNoiseMap, mPattIdConverter);
+  std::string nm = ID.getName();
+  uint32_t nLayers = mDoStaggering ? DPLAlpideParam<N>::getNLayers() : 1;
+  for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
+    auto buff = pc.inputs().get<gsl::span<o2::ctf::BufferType>>(getBinding(nm + "CTF", iLayer));
+    // since the buff is const, we cannot use EncodedBlocks::relocate directly, instead we wrap its data to another flat object
+    // const auto ctfImage = o2::itsmft::CTF::getImage(buff.data());
+    const auto& ctf = o2::itsmft::CTF::getImage(buff.data());
+    if (ctf.getHeader().maxStreams != nLayers) {
+      LOGP(fatal, "Number of streams {} in the CTF header is not equal to NLayers {} from AlpideParam in {}staggered mode",
+           ctf.getHeader().maxStreams, nLayers, mDoStaggering ? "" : "non-");
     }
-    mTimer.Stop();
-    LOG(info) << "Decoded " << digits.size() << " digits in " << rofs.size() << " RO frames, (" << iosize.asString() << ") in " << mTimer.CpuTime() - cput << " s";
-  } else {
-    auto& compcl = pc.outputs().make<std::vector<o2::itsmft::CompClusterExt>>(OutputRef{"compClusters"});
-    auto& patterns = pc.outputs().make<std::vector<unsigned char>>(OutputRef{"patterns"});
-    if (buff.size()) {
-      iosize = mCTFCoder.decode(o2::itsmft::CTF::getImage(buff.data()), rofs, compcl, patterns, mNoiseMap, mPattIdConverter);
+    // this produces weird memory problems in unrelated devices, to be understood
+    // auto& trigs = pc.outputs().make<std::vector<o2::itsmft::PhysTrigger>>(OutputRef{"phystrig"}); // dummy output
+    auto& rofs = pc.outputs().make<std::vector<o2::itsmft::ROFRecord>>(OutputRef{nm + "ROframes", iLayer});
+    if (mGetDigits) {
+      auto& digits = pc.outputs().make<std::vector<o2::itsmft::Digit>>(OutputRef{nm + "Digits", iLayer});
+      if (buff.size()) {
+        iosize += mCTFCoder.decode(ctf, rofs, digits, mNoiseMap, mPattIdConverter);
+      }
+      ndigcl += digits.size();
+      nrofs += rofs.size();
+    } else {
+      auto& compcl = pc.outputs().make<std::vector<o2::itsmft::CompClusterExt>>(OutputRef{nm + "compClusters", iLayer});
+      auto& patterns = pc.outputs().make<std::vector<unsigned char>>(OutputRef{nm + "patterns", iLayer});
+      if (buff.size()) {
+        iosize += mCTFCoder.decode(ctf, rofs, compcl, patterns, mNoiseMap, mPattIdConverter);
+      }
+      ndigcl += compcl.size();
     }
-    mTimer.Stop();
-    LOG(info) << "Decoded " << compcl.size() << " clusters in " << rofs.size() << " RO frames, (" << iosize.asString() << ") in " << mTimer.CpuTime() - cput << " s";
   }
-  pc.outputs().snapshot({"ctfrep", 0}, iosize);
+  pc.outputs().snapshot({nm + "ctfrep", 0}, iosize);
+  mTimer.Stop();
+  LOGP(info, "Decoded {} {} in {} ROFs of {} streams ({}) in {}staggerd mode in {} s", ndigcl, mGetDigits ? "digits" : "clusters",
+       nrofs, nLayers, iosize.asString(), mDoStaggering ? "" : "non-", mTimer.CpuTime() - cput);
 }
 
-void EntropyDecoderSpec::endOfStream(EndOfStreamContext& ec)
+template <int N>
+void EntropyDecoderSpec<N>::endOfStream(EndOfStreamContext& ec)
 {
-  LOGF(info, "%s Entropy Decoding total timing: Cpu: %.3e Real: %.3e s in %d slots",
-       mOrigin.as<std::string>(), mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+  LOGP(info, "{} Entropy Decoding total timing: Cpu: {:.3e} Real: {:.3e} s in {} slots",
+       Origin.as<std::string>(), mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-void EntropyDecoderSpec::updateTimeDependentParams(ProcessingContext& pc)
+template <int N>
+void EntropyDecoderSpec<N>::updateTimeDependentParams(ProcessingContext& pc)
 {
+  std::string nm = ID.getName();
   if (pc.services().get<o2::framework::TimingInfo>().globalRunNumberChanged) { // this params need to be queried only once
     if (mMaskNoise) {
-      pc.inputs().get<o2::itsmft::NoiseMap*>(std::string("noise") + mDetPrefix);
+      pc.inputs().get<o2::itsmft::NoiseMap*>(nm + "noise");
     }
     if (mGetDigits || mMaskNoise) {
-      pc.inputs().get<o2::itsmft::TopologyDictionary*>(std::string("cldict") + mDetPrefix);
+      pc.inputs().get<o2::itsmft::TopologyDictionary*>(nm + "cldict");
     }
   }
+  pc.inputs().get<o2::itsmft::DPLAlpideParam<N>*>(nm + "alppar");
   mCTFCoder.updateTimeDependentParams(pc, true);
 }
 
-void EntropyDecoderSpec::finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
+template <int N>
+void EntropyDecoderSpec<N>::finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj)
 {
-  if (matcher == ConcreteDataMatcher(mOrigin, "NOISEMAP", 0)) {
+  if (matcher == ConcreteDataMatcher(Origin, "NOISEMAP", 0)) {
     mNoiseMap = (o2::itsmft::NoiseMap*)obj;
-    LOG(info) << mOrigin.as<std::string>() << " noise map updated";
+    LOG(info) << Origin.as<std::string>() << " noise map updated";
     return;
   }
-  if (matcher == ConcreteDataMatcher(mOrigin, "CLUSDICT", 0)) {
-    LOG(info) << mOrigin.as<std::string>() << " cluster dictionary updated" << (!mUseClusterDictionary ? " but its using is disabled" : "");
+  if (matcher == ConcreteDataMatcher(Origin, "CLUSDICT", 0)) {
+    LOG(info) << Origin.as<std::string>() << " cluster dictionary updated" << (!mUseClusterDictionary ? " but its using is disabled" : "");
     mPattIdConverter.setDictionary((const TopologyDictionary*)obj);
     return;
   }
-  if (mCTFCoder.finaliseCCDB<CTF>(matcher, obj)) {
+  if (matcher == ConcreteDataMatcher(Origin, "ALPIDEPARAM", 0)) {
+    LOG(info) << "Alpide param updated";
+    return;
+  }
+  if (mCTFCoder.template finaliseCCDB<CTF>(matcher, obj)) {
     return;
   }
 }
 
-DataProcessorSpec getEntropyDecoderSpec(o2::header::DataOrigin orig, int verbosity, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt)
+template <int N>
+DataProcessorSpec getEntropyDecoderSpec(int verbosity, bool doStag, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt)
 {
+  constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+  uint32_t nLayers = doStag ? DPLAlpideParam<N>::getNLayers() : 1;
+
+  std::vector<InputSpec> inputs;
   std::vector<OutputSpec> outputs;
-  // this is a special dummy input which makes sense only in sync workflows
 
   // this produces weird memory problems in unrelated devices, to be understood
-  // outputs.emplace_back(OutputSpec{{"phystrig"}, orig, "PHYSTRIG", 0, Lifetime::Timeframe});
-
-  if (getDigits) {
-    outputs.emplace_back(OutputSpec{{"Digits"}, orig, "DIGITS", 0, Lifetime::Timeframe});
-    outputs.emplace_back(OutputSpec{{"ROframes"}, orig, "DIGITSROF", 0, Lifetime::Timeframe});
-  } else {
-    outputs.emplace_back(OutputSpec{{"compClusters"}, orig, "COMPCLUSTERS", 0, Lifetime::Timeframe});
-    outputs.emplace_back(OutputSpec{{"ROframes"}, orig, "CLUSTERSROF", 0, Lifetime::Timeframe});
-    outputs.emplace_back(OutputSpec{{"patterns"}, orig, "PATTERNS", 0, Lifetime::Timeframe});
+  // outputs.emplace_back(OutputSpec{{"phystrig"}, Origin, "PHYSTRIG", 0, Lifetime::Timeframe});
+  std::string nm = ID.getName();
+  for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
+    if (getDigits) {
+      outputs.emplace_back(OutputSpec{{nm + "Digits"}, Origin, "DIGITS", iLayer, Lifetime::Timeframe});
+      outputs.emplace_back(OutputSpec{{nm + "ROframes"}, Origin, "DIGITSROF", iLayer, Lifetime::Timeframe});
+    } else {
+      outputs.emplace_back(OutputSpec{{nm + "compClusters"}, Origin, "COMPCLUSTERS", iLayer, Lifetime::Timeframe});
+      outputs.emplace_back(OutputSpec{{nm + "ROframes"}, Origin, "CLUSTERSROF", iLayer, Lifetime::Timeframe});
+      outputs.emplace_back(OutputSpec{{nm + "patterns"}, Origin, "PATTERNS", iLayer, Lifetime::Timeframe});
+    }
+    inputs.emplace_back(EntropyDecoderSpec<N>::getBinding(nm + "CTF", iLayer), Origin, "CTFDATA", sspec * 100 + iLayer, Lifetime::Timeframe);
   }
-  outputs.emplace_back(OutputSpec{{"ctfrep"}, orig, "CTFDECREP", 0, Lifetime::Timeframe});
-  std::string nm = orig == o2::header::gDataOriginITS ? "_ITS" : "_MFT";
-  std::vector<InputSpec> inputs;
-  inputs.emplace_back(std::string("ctf") + nm, orig, "CTFDATA", sspec, Lifetime::Timeframe);
-  inputs.emplace_back(std::string("noise") + nm, orig, "NOISEMAP", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/NoiseMap", orig.as<std::string>())));
-  inputs.emplace_back(std::string("cldict") + nm, orig, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/ClusterDictionary", orig.as<std::string>())));
+  outputs.emplace_back(OutputSpec{{nm + "ctfrep"}, Origin, "CTFDECREP", 0, Lifetime::Timeframe});
+
+  inputs.emplace_back(nm + "alppar", Origin, "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Config/AlpideParam", Origin.as<std::string>())));
+  inputs.emplace_back(nm + "noise", Origin, "NOISEMAP", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/NoiseMap", Origin.as<std::string>())));
+  inputs.emplace_back(nm + "cldict", Origin, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/ClusterDictionary", Origin.as<std::string>())));
   if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
-    inputs.emplace_back(std::string("ctfdict") + nm, orig, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/CTFDictionaryTree", orig.as<std::string>())));
+    inputs.emplace_back(std::string{"ctfdict_"} + ID.getName(), Origin, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/CTFDictionaryTree", Origin.as<std::string>())));
   }
-  inputs.emplace_back(std::string("trigoffset"), "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
+  inputs.emplace_back("trigoffset", "CTP", "Trig_Offset", 0, Lifetime::Condition, ccdbParamSpec("CTP/Config/TriggerOffsets"));
 
   return DataProcessorSpec{
-    EntropyDecoderSpec::getName(orig),
+    Origin == o2::header::gDataOriginITS ? "its-entropy-decoder" : "mft-entropy-decoder",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec>(orig, verbosity, getDigits, ctfdictOpt)},
+    AlgorithmSpec{adaptFromTask<EntropyDecoderSpec<N>>(verbosity, doStag, getDigits, ctfdictOpt)},
     Options{{"mask-noise", VariantType::Bool, false, {"apply noise mask to digits or clusters (involves reclusterization)"}},
             {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
+
+framework::DataProcessorSpec getITSEntropyDecoderSpec(int verbosity, bool doStag, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt)
+{
+  return getEntropyDecoderSpec<o2::detectors::DetID::ITS>(verbosity, doStag, getDigits, sspec, ctfdictOpt);
+}
+
+framework::DataProcessorSpec getMFTEntropyDecoderSpec(int verbosity, bool doStag, bool getDigits, unsigned int sspec, const std::string& ctfdictOpt)
+{
+  return getEntropyDecoderSpec<o2::detectors::DetID::MFT>(verbosity, doStag, getDigits, sspec, ctfdictOpt);
+}
+
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/src/EntropyEncoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/EntropyEncoderSpec.cxx
index a824184330547..f80555efed384 100644
--- a/Detectors/ITSMFT/common/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/EntropyEncoderSpec.cxx
@@ -18,7 +18,7 @@
 #include "Framework/CCDBParamSpec.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "ITSMFTWorkflow/EntropyEncoderSpec.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 
 using namespace o2::framework;
@@ -27,20 +27,31 @@ namespace o2
 {
 namespace itsmft
 {
-EntropyEncoderSpec::EntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR, const std::string& ctfdictOpt)
-  : mOrigin(orig), mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, orig == o2::header::gDataOriginITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT, ctfdictOpt), mSelIR(selIR)
+
+template <int N>
+std::string EntropyEncoderSpec<N>::getBinding(const std::string& name, int spec)
+{
+  return fmt::format("{}_{}", name, spec);
+}
+
+template <int N>
+EntropyEncoderSpec<N>::EntropyEncoderSpec(bool doStag, bool selIR, const std::string& ctfdictOpt)
+  : mCTFCoder(o2::ctf::CTFCoderBase::OpType::Encoder, doStag, ctfdictOpt),
+    mSelIR(selIR),
+    mDoStaggering(doStag)
 {
-  assert(orig == o2::header::gDataOriginITS || orig == o2::header::gDataOriginMFT);
   mTimer.Stop();
   mTimer.Reset();
 }
 
-void EntropyEncoderSpec::init(o2::framework::InitContext& ic)
+template <int N>
+void EntropyEncoderSpec<N>::init(o2::framework::InitContext& ic)
 {
-  mCTFCoder.init<CTF>(ic);
+  mCTFCoder.template init<CTF>(ic);
 }
 
-void EntropyEncoderSpec::run(ProcessingContext& pc)
+template <int N>
+void EntropyEncoderSpec<N>::run(ProcessingContext& pc)
 {
   if (pc.services().get<o2::framework::TimingInfo>().globalRunNumberChanged) {
     mTimer.Reset();
@@ -49,14 +60,20 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
   mTimer.Start(false);
   updateTimeDependentParams(pc);
 
-  auto compClusters = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>("compClusters");
-  auto pspan = pc.inputs().get<gsl::span<unsigned char>>("patterns");
-  auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
+  uint32_t nLayers = mDoStaggering ? DPLAlpideParam<N>::getNLayers() : 1;
+
   if (mSelIR) {
     mCTFCoder.setSelectedIRFrames(pc.inputs().get<gsl::span<o2::dataformats::IRFrame>>("selIRFrames"));
   }
-  auto& buffer = pc.outputs().make<std::vector<o2::ctf::BufferType>>(Output{mOrigin, "CTFDATA", 0});
-  auto iosize = mCTFCoder.encode(buffer, rofs, compClusters, pspan, mPattIdConverter, mStrobeLength);
+  o2::ctf::CTFIOSize iosize{};
+  for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
+    auto compClusters = pc.inputs().get<gsl::span<o2::itsmft::CompClusterExt>>(getBinding("compClusters", iLayer));
+    auto pspan = pc.inputs().get<gsl::span<unsigned char>>(getBinding("patterns", iLayer));
+    auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>(getBinding("ROframes", iLayer));
+
+    auto& buffer = pc.outputs().make<std::vector<o2::ctf::BufferType>>(Output{Origin, "CTFDATA", iLayer});
+    iosize += mCTFCoder.encode(buffer, rofs, compClusters, pspan, mPattIdConverter, iLayer);
+  }
   pc.outputs().snapshot({"ctfrep", 0}, iosize);
   if (mSelIR) {
     mCTFCoder.getIRFramesSelector().clear();
@@ -65,77 +82,90 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
   LOG(info) << iosize.asString() << " in " << mTimer.CpuTime() - cput << " s";
 }
 
-void EntropyEncoderSpec::endOfStream(EndOfStreamContext& ec)
+template <int N>
+void EntropyEncoderSpec<N>::endOfStream(EndOfStreamContext& ec)
 {
-  LOGF(info, "%s Entropy Encoding total timing: Cpu: %.3e Real: %.3e s in %d slots",
-       mOrigin.as<std::string>(), mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+  LOGP(info, "{} Entropy Encoding total timing: Cpu: {:.3e} Real: {:.3e} s in {} slots",
+       Origin.as<std::string>(), mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-void EntropyEncoderSpec::updateTimeDependentParams(ProcessingContext& pc)
+template <int N>
+void EntropyEncoderSpec<N>::updateTimeDependentParams(ProcessingContext& pc)
 {
   mCTFCoder.updateTimeDependentParams(pc, true);
   if (pc.services().get<o2::framework::TimingInfo>().globalRunNumberChanged) { // this params need to be queried only once
     if (mSelIR) {
       pc.inputs().get<o2::itsmft::TopologyDictionary*>("cldict");
-      if (mOrigin == o2::header::gDataOriginITS) {
-        pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("alppar");
-      } else {
-        pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::MFT>*>("alppar");
-      }
     }
   }
+  pc.inputs().get<o2::itsmft::DPLAlpideParam<N>*>("alppar");
 }
 
-void EntropyEncoderSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+template <int N>
+void EntropyEncoderSpec<N>::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 {
-  if (matcher == ConcreteDataMatcher(mOrigin, "CLUSDICT", 0)) {
-    LOG(info) << mOrigin.as<std::string>() << " cluster dictionary updated";
+  if (matcher == ConcreteDataMatcher(Origin, "CLUSDICT", 0)) {
+    LOG(info) << Origin.as<std::string>() << " cluster dictionary updated";
     mPattIdConverter.setDictionary((const TopologyDictionary*)obj);
     return;
   }
   // Note: strictly speaking, for Configurable params we don't need finaliseCCDB check, the singletons are updated at the CCDB fetcher level
-  if (matcher == ConcreteDataMatcher(mOrigin, "ALPIDEPARAM", 0)) {
+  if (matcher == ConcreteDataMatcher(Origin, "ALPIDEPARAM", 0)) {
     LOG(info) << "Alpide param updated";
-    if (mOrigin == o2::header::gDataOriginITS) {
-      const auto& par = DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
-      mStrobeLength = par.roFrameLengthInBC;
-    } else {
-      const auto& par = DPLAlpideParam<o2::detectors::DetID::MFT>::Instance();
-      mStrobeLength = par.roFrameLengthInBC;
-    }
     return;
   }
 
-  if (mCTFCoder.finaliseCCDB<CTF>(matcher, obj)) {
+  if (mCTFCoder.template finaliseCCDB<CTF>(matcher, obj)) {
     return;
   }
 }
 
-DataProcessorSpec getEntropyEncoderSpec(o2::header::DataOrigin orig, bool selIR, const std::string& ctfdictOpt)
+template <int N>
+DataProcessorSpec getEntropyEncoderSpec(bool doStag, bool selIR, const std::string& ctfdictOpt)
 {
+  constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
+  constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
+  const auto& par = DPLAlpideParam<N>::Instance();
+  uint32_t nLayers = doStag ? DPLAlpideParam<N>::getNLayers() : 1;
+
   std::vector<InputSpec> inputs;
-  inputs.emplace_back("compClusters", orig, "COMPCLUSTERS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("patterns", orig, "PATTERNS", 0, Lifetime::Timeframe);
-  inputs.emplace_back("ROframes", orig, "CLUSTERSROF", 0, Lifetime::Timeframe);
+  std::vector<OutputSpec> outputs;
+  for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
+    inputs.emplace_back(EntropyEncoderSpec<N>::getBinding("compClusters", iLayer), Origin, "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
+    inputs.emplace_back(EntropyEncoderSpec<N>::getBinding("patterns", iLayer), Origin, "PATTERNS", iLayer, Lifetime::Timeframe);
+    inputs.emplace_back(EntropyEncoderSpec<N>::getBinding("ROframes", iLayer), Origin, "CLUSTERSROF", iLayer, Lifetime::Timeframe);
+    outputs.emplace_back(Origin, "CTFDATA", iLayer, Lifetime::Timeframe);
+  }
   if (selIR) {
     inputs.emplace_back("selIRFrames", "CTF", "SELIRFRAMES", 0, Lifetime::Timeframe);
-    inputs.emplace_back("cldict", orig, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/ClusterDictionary", orig.as<std::string>())));
-    inputs.emplace_back("alppar", orig, "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Config/AlpideParam", orig.as<std::string>())));
+    inputs.emplace_back("cldict", Origin, "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/ClusterDictionary", Origin.as<std::string>())));
   }
+  inputs.emplace_back("alppar", Origin, "ALPIDEPARAM", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Config/AlpideParam", Origin.as<std::string>())));
 
   if (ctfdictOpt.empty() || ctfdictOpt == "ccdb") {
-    inputs.emplace_back("ctfdict", orig, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/CTFDictionaryTree", orig.as<std::string>())));
+    inputs.emplace_back("ctfdict", Origin, "CTFDICT", 0, Lifetime::Condition, ccdbParamSpec(fmt::format("{}/Calib/CTFDictionaryTree", Origin.as<std::string>())));
   }
+  outputs.emplace_back(OutputSpec{{"ctfrep"}, Origin, "CTFENCREP", 0, Lifetime::Timeframe});
   return DataProcessorSpec{
-    orig == o2::header::gDataOriginITS ? "its-entropy-encoder" : "mft-entropy-encoder",
+    Origin == o2::header::gDataOriginITS ? "its-entropy-encoder" : "mft-entropy-encoder",
     inputs,
-    Outputs{{orig, "CTFDATA", 0, Lifetime::Timeframe},
-            {{"ctfrep"}, orig, "CTFENCREP", 0, Lifetime::Timeframe}},
-    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec>(orig, selIR, ctfdictOpt)},
+    outputs,
+    AlgorithmSpec{adaptFromTask<EntropyEncoderSpec<N>>(doStag, selIR, ctfdictOpt)},
     Options{{"irframe-margin-bwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame lower boundary when selection is requested"}},
             {"irframe-margin-fwd", VariantType::UInt32, 0u, {"margin in BC to add to the IRFrame upper boundary when selection is requested"}},
             {"mem-factor", VariantType::Float, 1.f, {"Memory allocation margin factor"}},
             {"ans-version", VariantType::String, {"version of ans entropy coder implementation to use"}}}};
 }
+
+framework::DataProcessorSpec getITSEntropyEncoderSpec(bool doStag, bool selIR, const std::string& ctfdictOpt)
+{
+  return getEntropyEncoderSpec<o2::detectors::DetID::ITS>(doStag, selIR, ctfdictOpt);
+}
+
+framework::DataProcessorSpec getMFTEntropyEncoderSpec(bool doStag, bool selIR, const std::string& ctfdictOpt)
+{
+  return getEntropyEncoderSpec<o2::detectors::DetID::MFT>(doStag, selIR, ctfdictOpt);
+}
+
 } // namespace itsmft
 } // namespace o2
diff --git a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
index da1af34376ff1..8fb6ba4e6aa97 100644
--- a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -17,7 +17,6 @@
 
 #include "Framework/WorkflowSpec.h"
 #include "Framework/ConfigParamRegistry.h"
-#include "Framework/ControlService.h"
 #include "Framework/DeviceSpec.h"
 #include "Framework/CCDBParamSpec.h"
 #include "DataFormatsITSMFT/Digit.h"
@@ -28,8 +27,7 @@
 #include "ITSMFTReconstruction/ClustererParam.h"
 #include "ITSMFTReconstruction/GBTLink.h"
 #include "ITSMFTWorkflow/STFDecoderSpec.h"
-#include "DetectorsCommonDataFormats/DetectorNameConf.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "CommonUtils/StringUtils.h"
@@ -47,11 +45,18 @@ using namespace o2::framework;
 ///_______________________________________
 template <class Mapping>
 STFDecoder<Mapping>::STFDecoder(const STFDecoderInp& inp, std::shared_ptr<o2::base::GRPGeomRequest> gr)
-  : mDoClusters(inp.doClusters), mDoPatterns(inp.doPatterns), mDoDigits(inp.doDigits), mDoCalibData(inp.doCalib), mAllowReporting(inp.allowReporting), mVerifyDecoder(inp.verifyDecoder), mInputSpec(inp.inputSpec), mGGCCDBRequest(gr)
+  : mDoClusters(inp.doClusters), mDoPatterns(inp.doPatterns), mDoDigits(inp.doDigits), mDoCalibData(inp.doCalib), mDoStaggering(inp.doStaggering), mAllowReporting(inp.allowReporting), mVerifyDecoder(inp.verifyDecoder), mInputSpec(inp.inputSpec), mGGCCDBRequest(gr)
 {
   mSelfName = o2::utils::Str::concat_string(Mapping::getName(), "STFDecoder");
   mTimer.Stop();
   mTimer.Reset();
+  if (mDoStaggering) {
+    mLayers = Mapping::NLayers;
+    mEstNDig.resize(mLayers, 0);
+    mEstNClus.resize(mLayers, 0);
+    mEstNClusPatt.resize(mLayers, 0);
+    mEstNCalib.resize(mLayers, 0);
+  }
 }
 
 ///_______________________________________
@@ -60,7 +65,6 @@ void STFDecoder<Mapping>::init(InitContext& ic)
 {
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
   try {
-    mDecoder = std::make_unique<RawPixelDecoder<Mapping>>();
     auto v0 = o2::utils::Str::tokenize(mInputSpec, ':');
     auto v1 = o2::utils::Str::tokenize(v0[1], '/');
     auto v2 = o2::utils::Str::tokenize(v1[1], '?');
@@ -68,9 +72,12 @@ void STFDecoder<Mapping>::init(InitContext& ic)
     header::DataDescription dataDesc;
     dataOrig.runtimeInit(v1[0].c_str());
     dataDesc.runtimeInit(v2[0].c_str());
-    mDecoder->setUserDataOrigin(dataOrig);
-    mDecoder->setUserDataDescription(dataDesc);
-    mDecoder->init(); // is this no-op?
+    for (int iLayer{0}; iLayer < mLayers; ++iLayer) {
+      auto& dec = mDecoder.emplace_back(std::make_unique<RawPixelDecoder<Mapping>>());
+      dec->setUserDataOrigin(dataOrig);
+      dec->setUserDataDescription(dataDesc);
+      dec->init(); // is this no-op?
+    }
   } catch (const std::exception& e) {
     LOG(error) << "exception was thrown in decoder creation: " << e.what();
     throw;
@@ -81,10 +88,9 @@ void STFDecoder<Mapping>::init(InitContext& ic)
   mApplyNoiseMap = !ic.options().get<bool>("ignore-noise-map");
   mUseClusterDictionary = !ic.options().get<bool>("ignore-cluster-dictionary");
   try {
-    float fr = ic.options().get<float>("rof-lenght-error-freq");
+    float fr = ic.options().get<float>("rof-length-error-freq");
     mROFErrRepIntervalMS = fr <= 0. ? -1 : long(fr * 1e3);
     mNThreads = std::max(1, ic.options().get<int>("nthreads"));
-    mDecoder->setNThreads(mNThreads);
     mUnmutExtraLanes = ic.options().get<bool>("unmute-extra-lanes");
     mVerbosity = ic.options().get<int>("decoder-verbosity");
     auto dmpSz = ic.options().get<int>("stop-raw-data-dumps-after-size");
@@ -103,13 +109,16 @@ void STFDecoder<Mapping>::init(InitContext& ic)
     if (mDumpOnError != int(GBTLink::RawDataDumps::DUMP_NONE) && (!dumpDir.empty() && !o2::utils::Str::pathIsDirectory(dumpDir))) {
       throw std::runtime_error(fmt::format("directory {} for raw data dumps does not exist", dumpDir));
     }
-    mDecoder->setAlwaysParseTrigger(ic.options().get<bool>("always-parse-trigger"));
-    mDecoder->setAllowEmptyROFs(ic.options().get<bool>("allow-empty-rofs"));
-    mDecoder->setRawDumpDirectory(dumpDir);
-    mDecoder->setFillCalibData(mDoCalibData);
-    mDecoder->setVerifyDecoder(mVerifyDecoder);
-    bool ignoreRampUp = !ic.options().get<bool>("accept-rof-rampup-data");
-    mDecoder->setSkipRampUpData(ignoreRampUp);
+    for (int iLayer{0}; iLayer < mLayers; ++iLayer) {
+      mDecoder[iLayer]->setNThreads(mNThreads);
+      mDecoder[iLayer]->setAlwaysParseTrigger(ic.options().get<bool>("always-parse-trigger"));
+      mDecoder[iLayer]->setAllowEmptyROFs(ic.options().get<bool>("allow-empty-rofs"));
+      mDecoder[iLayer]->setRawDumpDirectory(dumpDir);
+      mDecoder[iLayer]->setFillCalibData(mDoCalibData);
+      mDecoder[iLayer]->setVerifyDecoder(mVerifyDecoder);
+      bool ignoreRampUp = !ic.options().get<bool>("accept-rof-rampup-data");
+      mDecoder[iLayer]->setSkipRampUpData(ignoreRampUp);
+    }
   } catch (const std::exception& e) {
     LOG(error) << "exception was thrown in decoder configuration: " << e.what();
     throw;
@@ -122,6 +131,17 @@ void STFDecoder<Mapping>::init(InitContext& ic)
     mClusterer = std::make_unique<Clusterer>();
     mClusterer->setNChips(Mapping::getNChips());
   }
+
+  if (mDoStaggering) {
+    Mapping map;
+    for (uint32_t iLayer{0}; iLayer < mLayers; ++iLayer) {
+      std::vector<o2::framework::InputSpec> filter;
+      for (const auto feeID : map.getLayer2FEEIDs(iLayer)) {
+        filter.emplace_back("filter", ConcreteDataMatcher{Mapping::getOrigin(), o2::header::gDataDescriptionRawData, (o2::header::DataHeader::SubSpecificationType)feeID});
+      }
+      mDecoder[iLayer]->setInputFilter(filter);
+    }
+  }
 }
 
 ///_______________________________________
@@ -135,141 +155,147 @@ void STFDecoder<Mapping>::run(ProcessingContext& pc)
   }
   if (firstCall) {
     firstCall = false;
-    mDecoder->setInstanceID(pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId);
-    mDecoder->setNInstances(pc.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices);
-    mDecoder->setVerbosity(mDecoder->getInstanceID() == 0 ? mVerbosity : (mUnmutExtraLanes ? mVerbosity : -1));
-    mAllowReporting &= (mDecoder->getInstanceID() == 0) || mUnmutExtraLanes;
+    for (int iLayer{0}; iLayer < mLayers; ++iLayer) {
+      mDecoder[iLayer]->setInstanceID(pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId);
+      mDecoder[iLayer]->setNInstances(pc.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices);
+      mDecoder[iLayer]->setVerbosity(mDecoder[iLayer]->getInstanceID() == 0 ? mVerbosity : (mUnmutExtraLanes ? mVerbosity : -1));
+    }
+    mAllowReporting &= (mDecoder[0]->getInstanceID() == 0) || mUnmutExtraLanes;
   }
 
   int nSlots = pc.inputs().getNofParts(0);
   double timeCPU0 = mTimer.CpuTime(), timeReal0 = mTimer.RealTime();
   mTimer.Start(false);
   auto orig = Mapping::getOrigin();
-  std::vector<o2::itsmft::CompClusterExt> clusCompVec;
-  std::vector<o2::itsmft::ROFRecord> clusROFVec;
-  std::vector<unsigned char> clusPattVec;
 
-  std::vector<Digit> digVec;
-  std::vector<GBTCalibData> calVec;
-  std::vector<ROFRecord> digROFVec;
+  // these are accumulated from each layer
   auto& chipStatus = pc.outputs().make<std::vector<char>>(Output{orig, "CHIPSSTATUS", 0}, (size_t)Mapping::getNChips());
+  auto& linkErrors = pc.outputs().make<std::vector<GBTLinkDecodingStat>>(Output{orig, "LinkErrors", 0});
+  auto& decErrors = pc.outputs().make<std::vector<ChipError>>(Output{orig, "ChipErrors", 0});
+  auto& errMessages = pc.outputs().make<std::vector<ErrorMessage>>(Output{orig, "ErrorInfo", 0});
+  auto& physTriggers = pc.outputs().make<std::vector<PhysTrigger>>(Output{orig, "PHYSTRIG", 0});
 
-  try {
-    mDecoder->startNewTF(pc.inputs());
+  for (uint32_t iLayer{0}; iLayer < mLayers; ++iLayer) {
+    const auto& par = AlpideParam::Instance();
+    const int nROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / par.getROFLengthInBC(iLayer);
+    const int nROFsTF = nROFsPerOrbit * o2::base::GRPGeomHelper::getNHBFPerTF();
+    int nLayer = mDoStaggering ? iLayer : -1;
+    std::vector<o2::itsmft::CompClusterExt> clusCompVec;
+    std::vector<o2::itsmft::ROFRecord> clusROFVec;
+    std::vector<unsigned char> clusPattVec;
+    std::vector<Digit> digVec;
+    std::vector<GBTCalibData> calVec;
+    std::vector<ROFRecord> digROFVec;
     if (mDoDigits) {
-      digVec.reserve(mEstNDig);
-      digROFVec.reserve(mEstNROF);
+      digVec.reserve(mEstNDig[iLayer]);
+      digROFVec.reserve(nROFsTF);
     }
     if (mDoClusters) {
-      clusCompVec.reserve(mEstNClus);
-      clusROFVec.reserve(mEstNROF);
-      clusPattVec.reserve(mEstNClusPatt);
+      clusCompVec.reserve(mEstNClus[iLayer]);
+      clusROFVec.reserve(nROFsTF);
+      clusPattVec.reserve(mEstNClusPatt[iLayer]);
     }
     if (mDoCalibData) {
-      calVec.reserve(mEstNCalib);
+      calVec.reserve(mEstNCalib[iLayer]);
     }
 
-    mDecoder->setDecodeNextAuto(false);
-    o2::InteractionRecord lastIR{}, firstIR{0, pc.services().get<o2::framework::TimingInfo>().firstTForbit};
-    int nTriggersProcessed = mDecoder->getNROFsProcessed();
-    static long lastErrReportTS = 0;
-    while (mDecoder->decodeNextTrigger() >= 0) {
-      if ((!lastIR.isDummy() && lastIR >= mDecoder->getInteractionRecord()) || firstIR > mDecoder->getInteractionRecord()) {
-        const int MaxErrLog = 2;
-        static int errLocCount = 0;
-        if (errLocCount++ < MaxErrLog) {
-          LOGP(warn, "Impossible ROF IR {}, previous was {}, TF 1st IR was {}, discarding in decoding", mDecoder->getInteractionRecord().asString(), lastIR.asString(), firstIR.asString());
+    try {
+      mDecoder[iLayer]->startNewTF(pc.inputs());
+      mDecoder[iLayer]->setDecodeNextAuto(false);
+
+      o2::InteractionRecord lastIR{};
+      int nTriggersProcessed = mDecoder[iLayer]->getNROFsProcessed();
+      static long lastErrReportTS = 0;
+      while (mDecoder[iLayer]->decodeNextTrigger() >= 0) {
+        if ((!lastIR.isDummy() && lastIR >= mDecoder[iLayer]->getInteractionRecord()) || mFirstIR > mDecoder[iLayer]->getInteractionRecord()) {
+          const int MaxErrLog = 2;
+          static int errLocCount = 0;
+          if (errLocCount++ < MaxErrLog) {
+            LOGP(warn, "Impossible ROF IR {}{}, previous was {}, TF 1st IR was {}, discarding in decoding", mDecoder[iLayer]->getInteractionRecord().asString(), ((mDoStaggering) ? std::format(" on layer {}", iLayer) : ""), lastIR.asString(), mFirstIR.asString());
+          }
+          nTriggersProcessed = 0x7fffffff; // to account for a problem with event
+          continue;
+        }
+        lastIR = mDecoder[iLayer]->getInteractionRecord();
+        mDecoder[iLayer]->fillChipsStatus(chipStatus);
+        if (mDoDigits || mClusterer->getMaxROFDepthToSquash(nLayer)) { // call before clusterization, since the latter will hide the digits
+          mDecoder[iLayer]->fillDecodedDigits(digVec, digROFVec);      // lot of copying involved
+          if (mDoCalibData) {
+            mDecoder[iLayer]->fillCalibData(calVec);
+          }
+        }
+        if (mDoClusters && !mClusterer->getMaxROFDepthToSquash(nLayer)) { // !!! THREADS !!!
+          mClusterer->process(mNThreads, *mDecoder[iLayer].get(), &clusCompVec, mDoPatterns ? &clusPattVec : nullptr, &clusROFVec);
         }
-        nTriggersProcessed = 0x7fffffff; // to account for a problem with event
-        continue;
       }
-      lastIR = mDecoder->getInteractionRecord();
-      mDecoder->fillChipsStatus(chipStatus);
-      if (mDoDigits || mClusterer->getMaxROFDepthToSquash()) {      // call before clusterization, since the latter will hide the digits
-        mDecoder->fillDecodedDigits(digVec, digROFVec);             // lot of copying involved
-        if (mDoCalibData) {
-          mDecoder->fillCalibData(calVec);
+      nTriggersProcessed = mDecoder[iLayer]->getNROFsProcessed() - nTriggersProcessed - 1;
+
+      if ((nROFsTF != nTriggersProcessed) && mROFErrRepIntervalMS > 0 && mTFCounter > 1 && nTriggersProcessed > 0) {
+        long currTS = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+        if (currTS - lastErrReportTS > mROFErrRepIntervalMS) {
+          LOGP(critical, "Inconsistent number of ROF per TF {}{} from parameters. Received {} from readout (muting further reporting for {} ms)", nROFsTF, ((mDoStaggering) ? std::format(" on layer {}", iLayer) : ""), nTriggersProcessed, mROFErrRepIntervalMS);
+          lastErrReportTS = currTS;
         }
       }
-      if (mDoClusters && !mClusterer->getMaxROFDepthToSquash()) { // !!! THREADS !!!
-        mClusterer->process(mNThreads, *mDecoder.get(), &clusCompVec, mDoPatterns ? &clusPattVec : nullptr, &clusROFVec);
+      if (mDoClusters && mClusterer->getMaxROFDepthToSquash(nLayer)) {
+        // Digits squashing require to run on a batch of digits and uses a digit reader, cannot (?) run with decoder
+        //  - Setup decoder for running on a batch of digits
+        o2::itsmft::DigitPixelReader reader;
+        reader.setSquashingDepth(mClusterer->getMaxROFDepthToSquash(nLayer));
+        reader.setSquashingDist(mClusterer->getMaxRowColDiffToMask()); // Sharing same parameter/logic with masking
+        reader.setMaxBCSeparationToSquash(mClusterer->getMaxBCSeparationToSquash(nLayer));
+        reader.setDigits(digVec);
+        reader.setROFRecords(digROFVec);
+        reader.init();
+        mClusterer->setMaxROFDepthToSquash(mClusterer->getMaxROFDepthToSquash(nLayer));
+        mClusterer->process(mNThreads, reader, &clusCompVec, mDoPatterns ? &clusPattVec : nullptr, &clusROFVec);
+      }
+    } catch (const std::exception& e) {
+      static size_t nErr = 0;
+      auto maxWarn = o2::conf::VerbosityConfig::Instance().maxWarnRawParser;
+      if (++nErr < maxWarn) {
+        LOGP(alarm, "EXCEPTION {} in raw decoder{}, abandoning TF decoding {}", e.what(), ((mDoStaggering) ? std::format(" on layer {}", iLayer) : ""), nErr == maxWarn ? "(will mute further warnings)" : "");
       }
     }
-    nTriggersProcessed = mDecoder->getNROFsProcessed() - nTriggersProcessed - 1;
-
-    const auto& alpParams = o2::itsmft::DPLAlpideParam<Mapping::getDetID()>::Instance();
-    int expectedTFSize = static_cast<int>(o2::constants::lhc::LHCMaxBunches * o2::base::GRPGeomHelper::instance().getGRPECS()->getNHBFPerTF() / alpParams.roFrameLengthInBC); // 3564*32 / ROF Length in BS = number of ROFs per TF
-    if ((expectedTFSize != nTriggersProcessed) && mROFErrRepIntervalMS > 0 && mTFCounter > 1 && nTriggersProcessed > 0) {
-      long currTS = std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
-      if (currTS - lastErrReportTS > mROFErrRepIntervalMS) {
-        LOGP(critical, "Inconsistent number of ROF per TF. From parameters: {} from readout: {} (muting further reporting for {} ms)", expectedTFSize, nTriggersProcessed, mROFErrRepIntervalMS);
-        lastErrReportTS = currTS;
+    if (mDoDigits) {
+      pc.outputs().snapshot(Output{orig, "DIGITS", iLayer}, digVec);
+      std::vector<o2::itsmft::ROFRecord> expDigRofVec(nROFsTF);
+      ensureContinuousROF(digROFVec, expDigRofVec, iLayer, nROFsTF, "digits");
+      pc.outputs().snapshot(Output{orig, "DIGITSROF", iLayer}, digROFVec);
+      mEstNDig[iLayer] = std::max(mEstNDig[iLayer], size_t(digVec.size() * 1.2));
+      if (mDoCalibData) {
+        pc.outputs().snapshot(Output{orig, "GBTCALIB", iLayer}, calVec);
+        mEstNCalib[iLayer] = std::max(mEstNCalib[iLayer], size_t(calVec.size() * 1.2));
       }
+      LOG(debug) << mSelfName << " Decoded " << digVec.size() << " Digits in " << digROFVec.size() << " ROFs" << ((mDoStaggering) ? std::format(" on layer {}", iLayer) : "");
     }
-    if (mDoClusters && mClusterer->getMaxROFDepthToSquash()) {
-      // Digits squashing require to run on a batch of digits and uses a digit reader, cannot (?) run with decoder
-      //  - Setup decoder for running on a batch of digits
-      o2::itsmft::DigitPixelReader reader;
-      reader.setSquashingDepth(mClusterer->getMaxROFDepthToSquash());
-      reader.setSquashingDist(mClusterer->getMaxRowColDiffToMask()); // Sharing same parameter/logic with masking
-      reader.setMaxBCSeparationToSquash(mClusterer->getMaxBCSeparationToSquash());
-      reader.setDigits(digVec);
-      reader.setROFRecords(digROFVec);
-      reader.init();
 
-      mClusterer->process(mNThreads, reader, &clusCompVec, mDoPatterns ? &clusPattVec : nullptr, &clusROFVec);
-    }
-  } catch (const std::exception& e) {
-    static size_t nErr = 0;
-    auto maxWarn = o2::conf::VerbosityConfig::Instance().maxWarnRawParser;
-    if (++nErr < maxWarn) {
-      LOGP(alarm, "EXCEPTION {} in raw decoder, abandoning TF decoding {}", e.what(), nErr == maxWarn ? "(will mute further warnings)" : "");
-    }
-  }
-  if (mDoDigits) {
-    pc.outputs().snapshot(Output{orig, "DIGITS", 0}, digVec);
-    pc.outputs().snapshot(Output{orig, "DIGITSROF", 0}, digROFVec);
-    mEstNDig = std::max(mEstNDig, size_t(digVec.size() * 1.2));
-    mEstNROF = std::max(mEstNROF, size_t(digROFVec.size() * 1.2));
-    if (mDoCalibData) {
-      pc.outputs().snapshot(Output{orig, "GBTCALIB", 0}, calVec);
-      mEstNCalib = std::max(mEstNCalib, size_t(calVec.size() * 1.2));
+    if (mDoClusters) { // we are not obliged to create vectors which are not requested, but other devices might not know the options of this one
+      std::vector<o2::itsmft::ROFRecord> expClusRofVec(nROFsTF);
+      ensureContinuousROF(clusROFVec, expClusRofVec, iLayer, nROFsTF, "clusters");
+      pc.outputs().snapshot(Output{orig, "COMPCLUSTERS", iLayer}, clusCompVec);
+      pc.outputs().snapshot(Output{orig, "PATTERNS", iLayer}, clusPattVec);
+      pc.outputs().snapshot(Output{orig, "CLUSTERSROF", iLayer}, expClusRofVec);
+      mEstNClus[iLayer] = std::max(mEstNClus[iLayer], size_t(clusCompVec.size() * 1.2));
+      mEstNClusPatt[iLayer] = std::max(mEstNClusPatt[iLayer], size_t(clusPattVec.size() * 1.2));
+      LOG(info) << mSelfName << " Built " << clusCompVec.size() << " clusters in " << expClusRofVec.size() << " ROFs" << ((mDoStaggering) ? std::format(" on layer {}", iLayer) : "");
     }
-  }
 
-  if (mDoClusters) { // we are not obliged to create vectors which are not requested, but other devices might not know the options of this one
-    pc.outputs().snapshot(Output{orig, "COMPCLUSTERS", 0}, clusCompVec);
-    pc.outputs().snapshot(Output{orig, "PATTERNS", 0}, clusPattVec);
-    pc.outputs().snapshot(Output{orig, "CLUSTERSROF", 0}, clusROFVec);
-    mEstNClus = std::max(mEstNClus, size_t(clusCompVec.size() * 1.2));
-    mEstNClusPatt = std::max(mEstNClusPatt, size_t(clusPattVec.size() * 1.2));
-    mEstNROF = std::max(mEstNROF, size_t(clusROFVec.size() * 1.2));
-  }
-  auto& linkErrors = pc.outputs().make<std::vector<GBTLinkDecodingStat>>(Output{orig, "LinkErrors", 0});
-  auto& decErrors = pc.outputs().make<std::vector<ChipError>>(Output{orig, "ChipErrors", 0});
-  auto& errMessages = pc.outputs().make<std::vector<ErrorMessage>>(Output{orig, "ErrorInfo", 0});
-  mDecoder->collectDecodingErrors(linkErrors, decErrors, errMessages);
+    mDecoder[iLayer]->collectDecodingErrors(linkErrors, decErrors, errMessages);
+    physTriggers.insert(physTriggers.end(), mDecoder[iLayer]->getExternalTriggers().begin(), mDecoder[iLayer]->getExternalTriggers().end());
 
-  pc.outputs().snapshot(Output{orig, "PHYSTRIG", 0}, mDecoder->getExternalTriggers());
-
-  if (mDumpOnError != int(GBTLink::RawDataDumps::DUMP_NONE) &&
-      (!mDumpFrom1stPipeline || pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0)) {
-    mRawDumpedSize += mDecoder->produceRawDataDumps(mDumpOnError, pc.services().get<o2::framework::TimingInfo>());
-    if (mRawDumpedSize > mMaxRawDumpsSize && mMaxRawDumpsSize > 0) {
-      LOGP(info, "Max total dumped size {} MB exceeded allowed limit, disabling further dumping", mRawDumpedSize / (1024 * 1024));
-      mDumpOnError = int(GBTLink::RawDataDumps::DUMP_NONE);
+    if (mDumpOnError != int(GBTLink::RawDataDumps::DUMP_NONE) &&
+        (!mDumpFrom1stPipeline || pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0)) {
+      mRawDumpedSize += mDecoder[iLayer]->produceRawDataDumps(mDumpOnError, pc.services().get<o2::framework::TimingInfo>());
+      if (mRawDumpedSize > mMaxRawDumpsSize && mMaxRawDumpsSize > 0) {
+        LOGP(info, "Max total dumped size {} MB exceeded allowed limit, disabling further dumping", mRawDumpedSize / (1024 * 1024));
+        mDumpOnError = int(GBTLink::RawDataDumps::DUMP_NONE);
+      }
     }
   }
 
-  if (mDoClusters) {
-    LOG(debug) << mSelfName << " Built " << clusCompVec.size() << " clusters in " << clusROFVec.size() << " ROFs";
-  }
-  if (mDoDigits) {
-    LOG(debug) << mSelfName << " Decoded " << digVec.size() << " Digits in " << digROFVec.size() << " ROFs";
-  }
   mTimer.Stop();
   auto tfID = pc.services().get<o2::framework::TimingInfo>().tfCounter;
-
   LOG(debug) << mSelfName << " Total time for TF " << tfID << '(' << mTFCounter << ") : CPU: " << mTimer.CpuTime() - timeCPU0 << " Real: " << mTimer.RealTime() - timeReal0;
   mTFCounter++;
 }
@@ -285,8 +311,11 @@ void STFDecoder<Mapping>::finalize()
   LOGF(info, "%s statistics:", mSelfName);
   LOGF(info, "%s Total STF decoding%s timing (w/o disk IO): Cpu: %.3e Real: %.3e s in %d slots", mSelfName,
        mDoClusters ? "/clustering" : "", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
-  if (mDecoder && mAllowReporting) {
-    mDecoder->printReport();
+  for (int iLayer{0}; iLayer < mLayers && mAllowReporting; ++iLayer) {
+    if (mDecoder[iLayer]) {
+      LOG_IF(info, mDoStaggering) << "Report for decoder of layer " << iLayer;
+      mDecoder[iLayer]->printReport();
+    }
   }
   if (mClusterer) {
     mClusterer->print();
@@ -326,9 +355,17 @@ void STFDecoder<Mapping>::updateTimeDependentParams(ProcessingContext& pc)
         nROFsToSquash = 2 + int(clParams.maxSOTMUS / (rofBC * o2::constants::lhc::LHCBunchSpacingMUS)); // use squashing
       }
       mClusterer->setMaxROFDepthToSquash(clParams.maxBCDiffToSquashBias > 0 ? nROFsToSquash : 0);
-      mClusterer->print();
+      if (mDoStaggering) {
+        for (int iLayer{0}; iLayer < mLayers; ++iLayer) {
+          mClusterer->addMaxBCSeparationToSquash(alpParams.getROFLengthInBC(iLayer) + clParams.getMaxBCDiffToSquashBias(iLayer));
+          mClusterer->addMaxROFDepthToSquash((clParams.getMaxBCDiffToSquashBias(iLayer) > 0) ? 2 + int(clParams.maxSOTMUS / (alpParams.getROFLengthInBC(iLayer) * o2::constants::lhc::LHCBunchSpacingMUS)) : 0);
+        }
+      }
+      mClusterer->print(false);
     }
   }
+  mFirstTFOrbit = pc.services().get<o2::framework::TimingInfo>().firstTForbit;
+  mFirstIR = o2::InteractionRecord(0, mFirstTFOrbit);
 }
 
 ///_______________________________________
@@ -367,36 +404,105 @@ void STFDecoder<Mapping>::reset()
   mFinalizeDone = false;
   mTFCounter = 0;
   mTimer.Reset();
-  if (mDecoder) {
-    mDecoder->reset();
+  for (int iLayer{0}; iLayer < mLayers; ++iLayer) {
+    if (mDecoder[iLayer]) {
+      mDecoder[iLayer]->reset();
+    }
   }
   if (mClusterer) {
     mClusterer->reset();
   }
 }
 
+///_______________________________________
+template <class Mapping>
+void STFDecoder<Mapping>::ensureContinuousROF(const std::vector<ROFRecord>& rofVec, std::vector<ROFRecord>& expROFVec, int lr, int nROFsTF, const char* name)
+{
+  const auto& par = AlpideParam::Instance();
+  // ensure that the rof output is continuous
+  // we will preserve the digits/clusters as they are but the stray ROFs will be removed (leaving their clusters/digits unaddressed).
+  expROFVec.clear();
+  expROFVec.resize(nROFsTF);
+  for (int iROF{0}; iROF < nROFsTF; ++iROF) {
+    auto& rof = expROFVec[iROF];
+    int orb = iROF * par.getROFLengthInBC(lr) / o2::constants::lhc::LHCMaxBunches + mFirstTFOrbit;
+    int bc = iROF * par.getROFLengthInBC(lr) % o2::constants::lhc::LHCMaxBunches + par.getROFDelayInBC(lr);
+    o2::InteractionRecord ir(bc, orb);
+    rof.setBCData(ir);
+    rof.setROFrame(iROF);
+    rof.setNEntries(0);
+    rof.setFirstEntry(-1);
+  }
+  uint32_t prevEntry{0};
+  for (const auto& rof : rofVec) {
+    const auto& ir = rof.getBCData();
+    if (ir < mFirstIR) {
+      LOGP(warn, "Discard ROF {} preceding TF 1st orbit {}{}", ir.asString(), mFirstTFOrbit, ((mDoStaggering) ? std::format(" on layer {}", lr) : ""));
+      continue;
+    }
+    auto irToFirst = ir - mFirstIR;
+    if (irToFirst.toLong() - par.getROFDelayInBC(lr) < 0) {
+      LOGP(warn, "Discard ROF {} preceding TF 1st orbit {} due to imposed ROF delay{}", ir.asString(), mFirstTFOrbit, ((mDoStaggering) ? std::format(" on layer {}", lr) : ""));
+      continue;
+    }
+    irToFirst -= par.getROFDelayInBC(lr);
+    const long irROF = irToFirst.toLong() / par.getROFLengthInBC(lr);
+    if (irROF >= nROFsTF) {
+      LOGP(warn, "Discard ROF {} exceeding TF orbit range{}", ir.asString(), ((mDoStaggering) ? std::format(" on layer {}", lr) : ""));
+      continue;
+    }
+    auto& expROF = expROFVec[irROF];
+    if (expROF.getNEntries() == 0) {
+      expROF.setFirstEntry(rof.getFirstEntry());
+      expROF.setNEntries(rof.getNEntries());
+    } else {
+      if (expROF.getNEntries() < rof.getNEntries()) {
+        LOGP(warn, "Repeating {} with {} {}, prefer to already processed instance with {} {}{}", rof.asString(), rof.getNEntries(), name, expROF.getNEntries(), name, ((mDoStaggering) ? std::format(" on layer {}", lr) : ""));
+        expROF.setFirstEntry(rof.getFirstEntry());
+        expROF.setNEntries(rof.getNEntries());
+      } else {
+        LOGP(warn, "Repeating {} with {} {}, discard preferring already processed instance with {} {}{}", rof.asString(), rof.getNEntries(), name, expROF.getNEntries(), name, ((mDoStaggering) ? std::format(" on layer {}", lr) : ""));
+      }
+    }
+  }
+  int prevFirst{0};
+  for (auto& rof : expROFVec) {
+    if (rof.getFirstEntry() < 0) {
+      rof.setFirstEntry(prevFirst);
+    }
+    prevFirst = rof.getFirstEntry();
+  }
+}
+
 ///_______________________________________
 DataProcessorSpec getSTFDecoderSpec(const STFDecoderInp& inp)
 {
   std::vector<OutputSpec> outputs;
   auto inputs = o2::framework::select(inp.inputSpec.c_str());
-  if (inp.doDigits) {
-    outputs.emplace_back(inp.origin, "DIGITS", 0, Lifetime::Timeframe);
-    outputs.emplace_back(inp.origin, "DIGITSROF", 0, Lifetime::Timeframe);
-    if (inp.doCalib) {
-      outputs.emplace_back(inp.origin, "GBTCALIB", 0, Lifetime::Timeframe);
+  uint32_t nLayers = 1;
+  if (inp.origin == o2::header::gDataOriginITS && inp.doStaggering) {
+    nLayers = DPLAlpideParam<o2::detectors::DetID::ITS>::getNLayers();
+  } else if (inp.origin == o2::header::gDataOriginMFT && inp.doStaggering) {
+    nLayers = DPLAlpideParam<o2::detectors::DetID::MFT>::getNLayers();
+  }
+  for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
+    if (inp.doDigits) {
+      outputs.emplace_back(inp.origin, "DIGITS", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(inp.origin, "DIGITSROF", iLayer, Lifetime::Timeframe);
+    }
+    if (inp.doClusters) {
+      outputs.emplace_back(inp.origin, "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(inp.origin, "CLUSTERSROF", iLayer, Lifetime::Timeframe);
+      // in principle, we don't need to open this input if we don't need to send real data,
+      // but other devices expecting it do not know about options of this device: problem?
+      // if (doClusters && doPatterns)
+      outputs.emplace_back(inp.origin, "PATTERNS", iLayer, Lifetime::Timeframe);
     }
   }
-  if (inp.doClusters) {
-    outputs.emplace_back(inp.origin, "COMPCLUSTERS", 0, Lifetime::Timeframe);
-    outputs.emplace_back(inp.origin, "CLUSTERSROF", 0, Lifetime::Timeframe);
-    // in principle, we don't need to open this input if we don't need to send real data,
-    // but other devices expecting it do not know about options of this device: problem?
-    // if (doClusters && doPatterns)
-    outputs.emplace_back(inp.origin, "PATTERNS", 0, Lifetime::Timeframe);
+  if (inp.doDigits && inp.doCalib) {
+    outputs.emplace_back(inp.origin, "GBTCALIB", 0, Lifetime::Timeframe);
   }
   outputs.emplace_back(inp.origin, "PHYSTRIG", 0, Lifetime::Timeframe);
-
   outputs.emplace_back(inp.origin, "LinkErrors", 0, Lifetime::Timeframe);
   outputs.emplace_back(inp.origin, "ChipErrors", 0, Lifetime::Timeframe);
   outputs.emplace_back(inp.origin, "ErrorInfo", 0, Lifetime::Timeframe);
@@ -424,11 +530,11 @@ DataProcessorSpec getSTFDecoderSpec(const STFDecoderInp& inp)
                                                               true); // query only once all objects except mag.field
 
   return DataProcessorSpec{
-    inp.deviceName,
-    inputs,
-    outputs,
-    inp.origin == o2::header::gDataOriginITS ? AlgorithmSpec{adaptFromTask<STFDecoder<ChipMappingITS>>(inp, ggRequest)} : AlgorithmSpec{adaptFromTask<STFDecoder<ChipMappingMFT>>(inp, ggRequest)},
-    Options{
+    .name = inp.deviceName,
+    .inputs = inputs,
+    .outputs = outputs,
+    .algorithm = inp.origin == o2::header::gDataOriginITS ? AlgorithmSpec{adaptFromTask<STFDecoder<ChipMappingITS>>(inp, ggRequest)} : AlgorithmSpec{adaptFromTask<STFDecoder<ChipMappingMFT>>(inp, ggRequest)},
+    .options = Options{
       {"nthreads", VariantType::Int, 1, {"Number of decoding/clustering threads"}},
       {"decoder-verbosity", VariantType::Int, 0, {"Verbosity level (-1: silent, 0: errors, 1: headers, 2: data, 3: raw data dump) of 1st lane"}},
       {"always-parse-trigger", VariantType::Bool, false, {"parse trigger word even if flags continuation of old trigger"}},
@@ -439,7 +545,7 @@ DataProcessorSpec getSTFDecoderSpec(const STFDecoderInp& inp)
       {"allow-empty-rofs", VariantType::Bool, false, {"record ROFs w/o any hit"}},
       {"ignore-noise-map", VariantType::Bool, false, {"do not mask pixels flagged in the noise map"}},
       {"accept-rof-rampup-data", VariantType::Bool, false, {"do not discard data during ROF ramp up"}},
-      {"rof-lenght-error-freq", VariantType::Float, 60.f, {"do not report ROF lenght error more frequently than this value, disable if negative"}},
+      {"rof-length-error-freq", VariantType::Float, 60.f, {"do not report ROF length error more frequently than this value, disable if negative"}},
       {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}}}};
 }
 
diff --git a/Detectors/ITSMFT/common/workflow/src/digit-reader-workflow.cxx b/Detectors/ITSMFT/common/workflow/src/digit-reader-workflow.cxx
index 71b4b82a14126..04453abe464b7 100644
--- a/Detectors/ITSMFT/common/workflow/src/digit-reader-workflow.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/digit-reader-workflow.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "ITSMFTWorkflow/DigitReaderSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/CallbacksPolicy.h"
@@ -34,6 +35,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     ConfigParamSpec{"runmft", VariantType::Bool, false, {"expect MFT data"}},
     ConfigParamSpec{"suppress-triggers-output", VariantType::Bool, false, {"suppress dummy triggers output"}},
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"semicolon separated key=value strings"}}};
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -52,9 +54,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
 
   if (cfgc.options().get<bool>("runmft")) {
-    wf.emplace_back(o2::itsmft::getMFTDigitReaderSpec(useMC, calib, withTriggers));
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(cfgc);
+    wf.emplace_back(o2::itsmft::getMFTDigitReaderSpec(useMC, doStag, calib, withTriggers));
   } else {
-    wf.emplace_back(o2::itsmft::getITSDigitReaderSpec(useMC, calib, withTriggers));
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(cfgc);
+    wf.emplace_back(o2::itsmft::getITSDigitReaderSpec(useMC, doStag, calib, withTriggers));
   }
   o2::raw::HBFUtilsInitializer hbfIni(cfgc, wf);
   return wf;
diff --git a/Detectors/ITSMFT/common/workflow/src/digit-writer-workflow.cxx b/Detectors/ITSMFT/common/workflow/src/digit-writer-workflow.cxx
index 2d4fbea9aef6c..98391846c49c8 100644
--- a/Detectors/ITSMFT/common/workflow/src/digit-writer-workflow.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/digit-writer-workflow.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "ITSMFTWorkflow/DigitWriterSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/CompletionPolicyHelpers.h"
@@ -32,7 +33,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     ConfigParamSpec{"enable-calib-data", VariantType::Bool, false, {"enable writing GBT calibration data"}},
     ConfigParamSpec{"runmft", VariantType::Bool, false, {"expect MFT data"}},
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"semicolon separated key=value strings"}}};
-
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -49,9 +50,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
 
   if (cfgc.options().get<bool>("runmft")) {
-    wf.emplace_back(o2::itsmft::getMFTDigitWriterSpec(useMC, true, calib));
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(cfgc);
+    wf.emplace_back(o2::itsmft::getMFTDigitWriterSpec(useMC, doStag, true, calib));
   } else {
-    wf.emplace_back(o2::itsmft::getITSDigitWriterSpec(useMC, true, calib));
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(cfgc);
+    wf.emplace_back(o2::itsmft::getITSDigitWriterSpec(useMC, doStag, true, calib));
   }
   return wf;
 }
diff --git a/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx b/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
index e0fc23ec70128..fed7268100428 100644
--- a/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/entropy-encoder-workflow.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include "ITSMFTWorkflow/EntropyEncoderSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "Framework/ConfigParamSpec.h"
 
@@ -26,7 +27,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     ConfigParamSpec{"ctf-dict", VariantType::String, "none", {"CTF dictionary: empty or ccdb=CCDB, none=no external dictionary otherwise: local filename"}},
     ConfigParamSpec{"select-ir-frames", VariantType::Bool, false, {"Subscribe and filter according to external IR Frames"}}};
-
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -41,9 +42,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
   bool selIR = cfgc.options().get<bool>("select-ir-frames");
   if (cfgc.options().get<bool>("runmft")) {
-    wf.emplace_back(o2::itsmft::getEntropyEncoderSpec("MFT", selIR, cfgc.options().get<std::string>("ctf-dict")));
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(cfgc);
+    wf.emplace_back(o2::itsmft::getMFTEntropyEncoderSpec(doStag, selIR, cfgc.options().get<std::string>("ctf-dict")));
   } else {
-    wf.emplace_back(o2::itsmft::getEntropyEncoderSpec("ITS", selIR, cfgc.options().get<std::string>("ctf-dict")));
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(cfgc);
+    wf.emplace_back(o2::itsmft::getITSEntropyEncoderSpec(doStag, selIR, cfgc.options().get<std::string>("ctf-dict")));
   }
   return wf;
 }
diff --git a/Detectors/ITSMFT/common/workflow/src/stf-decoder-workflow.cxx b/Detectors/ITSMFT/common/workflow/src/stf-decoder-workflow.cxx
index 7b1b97ec0c4f5..219e8915e11f3 100644
--- a/Detectors/ITSMFT/common/workflow/src/stf-decoder-workflow.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/stf-decoder-workflow.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -12,6 +12,7 @@
 #include "ITSMFTWorkflow/STFDecoderSpec.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "Framework/ConfigParamSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 
@@ -33,7 +34,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     ConfigParamSpec{"dataspec", VariantType::String, "", {"selection string for the input data, if not provided <DET>Raw:<DET>/RAWDATA with DET=ITS or MFT will be used"}},
     ConfigParamSpec{"report-dds-collection-index", VariantType::Int, -1, {"number of dpl collection allowed to produce decoding report (-1 means no limit)"}},
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
-
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -53,6 +54,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   inp.askSTFDist = !cfgc.options().get<bool>("ignore-dist-stf");
   inp.verifyDecoder = cfgc.options().get<bool>("verify");
   inp.inputSpec = cfgc.options().get<std::string>("dataspec");
+
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
 
@@ -62,12 +64,14 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     }
     inp.origin = o2::header::gDataOriginMFT;
     inp.deviceName = "mft-stf-decoder";
+    inp.doStaggering = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(cfgc);
   } else {
     if (inp.inputSpec.empty()) {
       inp.inputSpec = "itsRAW:ITS/RAWDATA";
     }
     inp.origin = o2::header::gDataOriginITS;
     inp.deviceName = "its-stf-decoder";
+    inp.doStaggering = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(cfgc);
   }
 
   inp.allowReporting = true;
diff --git a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
index 2b8090af42648..919e76083f595 100644
--- a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
+++ b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
@@ -121,7 +121,7 @@ void TFReaderSpec::init(o2f::InitContext& ic)
   if (!mInput.fileRunTimeSpans.empty()) {
     loadRunTimeSpans(mInput.fileRunTimeSpans);
   }
-  mFileFetcher = std::make_unique<o2::utils::FileFetcher>(mInput.inpdata, mInput.tffileRegex, mInput.remoteRegex, mInput.copyCmd);
+  mFileFetcher = std::make_unique<o2::utils::FileFetcher>(mInput.inpdata, mInput.tffileRegex, mInput.remoteRegex, mInput.copyCmd, mInput.copyDir);
   mFileFetcher->setMaxFilesInQueue(mInput.maxFileCache);
   mFileFetcher->setMaxLoops(mInput.maxLoops);
   mFileFetcher->setFailThreshold(ic.options().get<float>("fetch-failure-threshold"));
diff --git a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
index 9db18768c1bfe..2c1c62ecbb414 100644
--- a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
+++ b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
@@ -29,6 +29,7 @@ struct TFReaderInp {
   std::string detListNonRawOnly{};
   std::string rawChannelConfig{};
   std::string copyCmd{};
+  std::string copyDir{};
   std::string tffileRegex{};
   std::string remoteRegex{};
   std::string metricChannel{};
diff --git a/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx b/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
index bc682127b0d3f..b424353531de7 100644
--- a/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
+++ b/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
@@ -31,6 +31,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   options.push_back(ConfigParamSpec{"loop", VariantType::Int, 0, {"loop N times (-1 = infinite)"}});
   options.push_back(ConfigParamSpec{"delay", VariantType::Float, 0.f, {"delay in seconds between consecutive TFs sending"}});
   options.push_back(ConfigParamSpec{"copy-cmd", VariantType::String, "alien_cp ?src file://?dst", {"copy command for remote files"}}); // Use "XrdSecPROTOCOL=sss,unix xrdcp -N root://eosaliceo2.cern.ch/?src ?dst" for direct EOS access
+  options.push_back(ConfigParamSpec{"copy-dir", VariantType::String, "/tmp/", {"copy base directory for remote files"}});
   options.push_back(ConfigParamSpec{"tf-file-regex", VariantType::String, ".+\\.tf$", {"regex string to identify TF files"}});
   options.push_back(ConfigParamSpec{"remote-regex", VariantType::String, "^(alien://|)/alice/data/.+", {"regex string to identify remote files"}}); // Use "^/eos/aliceo2/.+" for direct EOS access
   options.push_back(ConfigParamSpec{"tf-reader-verbosity", VariantType::Int, 0, {"verbosity level (1 or 2: check RDH, print DH/DPH for 1st or all slices, >2 print RDH)"}});
@@ -71,6 +72,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   rinp.delay_us = uint64_t(1e6 * configcontext.options().get<float>("delay")); // delay in microseconds
   rinp.verbosity = configcontext.options().get<int>("tf-reader-verbosity");
   rinp.copyCmd = configcontext.options().get<std::string>("copy-cmd");
+  rinp.copyDir = configcontext.options().get<std::string>("copy-dir");
   rinp.tffileRegex = configcontext.options().get<std::string>("tf-file-regex");
   rinp.remoteRegex = configcontext.options().get<std::string>("remote-regex");
   rinp.sendDummyForMissing = !configcontext.options().get<bool>("disable-dummy-output");
diff --git a/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx b/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
index 1d8243ff8cbc0..7781b5ed187cb 100644
--- a/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
+++ b/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
@@ -26,6 +26,7 @@
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using GTrackID = o2::dataformats::GlobalTrackID;
@@ -62,6 +63,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"disable-ft0-pileup-tagging", VariantType::Bool, false, {"Do not request FT0 for pile-up determination"}},
     {"policy", VariantType::String, "default", {"Pick PID policy (=default)"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
index c07767d50b113..005237fe28839 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
@@ -37,8 +37,8 @@ class GeometryTGeo;
 
 /// TRK TimeFrame class that extends ITS TimeFrame functionality
 /// This allows for customization of tracking algorithms specific to the TRK detector
-template <int nLayers = 11>
-class TimeFrame : public o2::its::TimeFrame<nLayers>
+template <int NLayers = 11>
+class TimeFrame : public o2::its::TimeFrame<NLayers>
 {
  public:
   TimeFrame() = default;
@@ -49,8 +49,6 @@ class TimeFrame : public o2::its::TimeFrame<nLayers>
 
   /// Process hits from TTree to initialize ROFs
   /// \param hitsTree Tree containing TRK hits
-  /// \param mcHeaderTree Tree containing MC event headers
-  /// \param nEvents Number of events to process
   /// \param gman TRK geometry manager instance
   /// \param config Configuration parameters for hit reconstruction
   int loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config);
@@ -60,7 +58,8 @@ class TimeFrame : public o2::its::TimeFrame<nLayers>
   /// \param nRofs Number of ROFs (Read-Out Frames)
   /// \param nEvents Number of events to process
   /// \param inROFpileup Number of events per ROF
-  void getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup);
+  /// \param rofLength ROF length in BCs (must match what was used in loadROFsFromHitTree)
+  void getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup, uint32_t rofLength = 198);
 };
 
 } // namespace trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
index 610a08450d5ee..957560aea8cae 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
@@ -23,11 +23,13 @@
 #include <vector>
 #include <array>
 
+using o2::its::clearResizeBoundedVector;
+
 namespace o2::trk
 {
 
-template <int nLayers>
-int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config)
+template <int NLayers>
+int TimeFrame<NLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config)
 {
   constexpr std::array<int, 2> startLayer{0, 3};
   const Long64_t nEvents = hitsTree->GetEntries();
@@ -39,23 +41,39 @@ int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman,
 
   const int inROFpileup{config.contains("inROFpileup") ? config["inROFpileup"].get<int>() : 1};
 
-  // Calculate number of ROFs and initialize data structures
-  this->mNrof = (nEvents + inROFpileup - 1) / inROFpileup;
+  // Calculate number of ROFs
+  const int nRofs = (nEvents + inROFpileup - 1) / inROFpileup;
+
+  // Set up ROF timing for all layers (no staggering in TRK simulation, all layers read out together)
+  constexpr uint32_t rofLength = 198; // ROF length in BC
+  o2::its::ROFOverlapTable<NLayers> overlapTable;
+  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
+    overlapTable.defineLayer(iLayer, nRofs, rofLength, 0, 0, 0);
+  }
+  overlapTable.init();
+  this->setROFOverlapTable(overlapTable);
+
+  // Set up the vertex lookup table timing (pre-allocate, vertices will be filled later)
+  o2::its::ROFVertexLookupTable<NLayers> vtxLookupTable;
+  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
+    vtxLookupTable.defineLayer(iLayer, nRofs, rofLength, 0, 0, 0);
+  }
+  vtxLookupTable.init(); // pre-allocate without vertices
+  this->setROFVertexLookupTable(vtxLookupTable);
 
   // Reset and prepare ROF data structures
-  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+  for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
     this->mMinR[iLayer] = std::numeric_limits<float>::max();
     this->mMaxR[iLayer] = std::numeric_limits<float>::lowest();
     this->mROFramesClusters[iLayer].clear();
-    this->mROFramesClusters[iLayer].resize(this->mNrof + 1, 0);
+    this->mROFramesClusters[iLayer].resize(nRofs + 1, 0);
     this->mUnsortedClusters[iLayer].clear();
     this->mTrackingFrameInfo[iLayer].clear();
     this->mClusterExternalIndices[iLayer].clear();
   }
 
   // Pre-count hits to reserve memory efficiently
-  int totalNHits{0};
-  std::array<int, nLayers> clusterCountPerLayer{};
+  std::array<int, NLayers> clusterCountPerLayer{};
   for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
     hitsTree->GetEntry(iEvent);
     for (const auto& hit : *trkHit) {
@@ -64,25 +82,24 @@ int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman,
       }
       int subDetID = gman->getSubDetID(hit.GetDetectorID());
       const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
-      if (layer >= nLayers) {
+      if (layer >= NLayers) {
         continue;
       }
       ++clusterCountPerLayer[layer];
-      totalNHits++;
     }
   }
 
-  // Reserve memory for all layers
-  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+  // Reserve memory for all layers (mClusterSize is now per-layer)
+  for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
     this->mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
     this->mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
     this->mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    clearResizeBoundedVector(this->mClusterSize[iLayer], clusterCountPerLayer[iLayer], this->mMemoryPool.get());
   }
-  clearResizeBoundedVector(this->mClusterSize, totalNHits, this->mMemoryPool.get());
 
   std::array<float, 11> resolution{0.001, 0.001, 0.001, 0.001, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004};
-  if (config["geometry"]["pitch"].size() == nLayers) {
-    for (int iLayer{0}; iLayer < config["geometry"]["pitch"].size(); ++iLayer) {
+  if (config["geometry"]["pitch"].size() == static_cast<size_t>(NLayers)) {
+    for (size_t iLayer{0}; iLayer < config["geometry"]["pitch"].size(); ++iLayer) {
       LOGP(info, "Setting resolution for layer {} from config", iLayer);
       LOGP(info, "Layer {} pitch {} cm", iLayer, config["geometry"]["pitch"][iLayer].get<float>());
       resolution[iLayer] = config["geometry"]["pitch"][iLayer].get<float>() / std::sqrt(12.f);
@@ -90,9 +107,10 @@ int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman,
   }
   LOGP(info, "Number of active parts in VD: {}", gman->getNumberOfActivePartsVD());
 
-  int hitCounter{0};
-  auto labels = new dataformats::MCTruthContainer<MCCompLabel>();
+  // One shared MC label container for all layers
+  auto* labels = new dataformats::MCTruthContainer<MCCompLabel>();
 
+  int hitCounter{0};
   int iRof{0}; // Current ROF index
   for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
     hitsTree->GetEntry(iEvent);
@@ -108,7 +126,7 @@ int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman,
       o2::math_utils::Point3D<float> gloXYZ;
       o2::math_utils::Point3D<float> trkXYZ;
       float r{0.f};
-      if (layer >= nLayers) {
+      if (layer >= NLayers) {
         continue;
       }
       if (layer >= 3) {
@@ -139,11 +157,12 @@ int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman,
                                         std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
                                         std::array<float, 3>{resolution[layer] * resolution[layer], 0., resolution[layer] * resolution[layer]});
       /// Rotate to the global frame
-      this->addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), this->mUnsortedClusters[layer].size());
+      const int clusterIdxInLayer = this->mUnsortedClusters[layer].size();
+      this->addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), clusterIdxInLayer);
       this->addClusterExternalIndexToLayer(layer, hitCounter);
       MCCompLabel label{hit.GetTrackID(), static_cast<int>(iEvent), 0};
       labels->addElement(hitCounter, label);
-      this->mClusterSize[hitCounter] = 1; // For compatibility with cluster-based tracking, set cluster size to 1 for hits
+      this->mClusterSize[layer][clusterIdxInLayer] = 1;
       hitCounter++;
     }
     trkHit->clear();
@@ -154,21 +173,23 @@ int TimeFrame<nLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman,
       for (unsigned int iLayer{0}; iLayer < this->mUnsortedClusters.size(); ++iLayer) {
         this->mROFramesClusters[iLayer][iRof] = this->mUnsortedClusters[iLayer].size(); // effectively calculating an exclusive sum
       }
-      // Update primary vertices ROF structure
     }
-    this->mClusterLabels = labels;
   }
-  return this->mNrof;
+
+  // Set the shared labels container for all layers
+  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
+    this->mClusterLabels[iLayer] = labels;
+  }
+
+  return nRofs;
 }
 
-template <int nLayers>
-void TimeFrame<nLayers>::getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup)
+template <int NLayers>
+void TimeFrame<NLayers>::getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup, uint32_t rofLength)
 {
   auto mcheader = new o2::dataformats::MCEventHeader;
   mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
 
-  this->mROFramesPV.clear();
-  this->mROFramesPV.resize(nRofs + 1, 0);
   this->mPrimaryVertices.clear();
 
   int iRof{0};
@@ -178,14 +199,24 @@ void TimeFrame<nLayers>::getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs
     vertex.setXYZ(mcheader->GetX(), mcheader->GetY(), mcheader->GetZ());
     vertex.setNContributors(30);
     vertex.setChi2(0.f);
-    LOGP(debug, "ROF {}: Added primary vertex at ({}, {}, {})", iRof, mcheader->GetX(), mcheader->GetY(), mcheader->GetZ());
-    this->mPrimaryVertices.push_back(vertex);
+
+    // Set proper BC timestamp for vertex-ROF compatibility
+    // The vertex timestamp is set to the center of its ROF with half-ROF as error
+    const uint32_t rofCenter = static_cast<uint32_t>(rofLength * iRof + rofLength / 2);
+    const uint16_t rofHalf = static_cast<uint16_t>(rofLength / 2);
+    vertex.setTimeStamp({rofCenter, rofHalf});
+
+    LOGP(debug, "ROF {}: Added primary vertex at ({}, {}, {}) with BC timestamp [{}, +/-{}]",
+         iRof, mcheader->GetX(), mcheader->GetY(), mcheader->GetZ(), rofCenter, rofHalf);
+    this->addPrimaryVertex(vertex);
     if ((iEvent + 1) % inROFpileup == 0 || iEvent == nEvents - 1) {
       iRof++;
-      this->mROFramesPV[iRof] = this->mPrimaryVertices.size(); // effectively calculating an exclusive sum
     }
   }
-  this->mMultiplicityCutMask.resize(nRofs, true); /// all ROFs are valid with MC primary vertices.
+  this->mMultiplicityCutMask.resetMask(1u); /// all ROFs are valid with MC primary vertices.
+
+  // Update the vertex lookup table with the newly added vertices
+  this->updateROFVertexLookupTable();
 }
 
 // Explicit template instantiation for TRK with 11 layers
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
index 3801228422a62..c9d793a3ec78f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -41,7 +41,6 @@ namespace o2
 using namespace framework;
 namespace trk
 {
-using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
 TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        bool isMC,
@@ -92,18 +91,12 @@ std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromCon
     if (paramConfig.contains("NLayers")) {
       params.NLayers = paramConfig["NLayers"].get<int>();
     }
-    if (paramConfig.contains("DeltaROF")) {
-      params.DeltaROF = paramConfig["DeltaROF"].get<int>();
-    }
     if (paramConfig.contains("ZBins")) {
       params.ZBins = paramConfig["ZBins"].get<int>();
     }
     if (paramConfig.contains("PhiBins")) {
       params.PhiBins = paramConfig["PhiBins"].get<int>();
     }
-    if (paramConfig.contains("nROFsPerIterations")) {
-      params.nROFsPerIterations = paramConfig["nROFsPerIterations"].get<int>();
-    }
     if (paramConfig.contains("ClusterSharing")) {
       params.ClusterSharing = paramConfig["ClusterSharing"].get<int>();
     }
@@ -127,27 +120,21 @@ std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromCon
     if (paramConfig.contains("TrackletMinPt")) {
       params.TrackletMinPt = paramConfig["TrackletMinPt"].get<float>();
     }
-    if (paramConfig.contains("TrackletsPerClusterLimit")) {
-      params.TrackletsPerClusterLimit = paramConfig["TrackletsPerClusterLimit"].get<float>();
-    }
     if (paramConfig.contains("CellDeltaTanLambdaSigma")) {
       params.CellDeltaTanLambdaSigma = paramConfig["CellDeltaTanLambdaSigma"].get<float>();
     }
-    if (paramConfig.contains("CellsPerClusterLimit")) {
-      params.CellsPerClusterLimit = paramConfig["CellsPerClusterLimit"].get<float>();
-    }
     if (paramConfig.contains("MaxChi2ClusterAttachment")) {
       params.MaxChi2ClusterAttachment = paramConfig["MaxChi2ClusterAttachment"].get<float>();
     }
     if (paramConfig.contains("MaxChi2NDF")) {
       params.MaxChi2NDF = paramConfig["MaxChi2NDF"].get<float>();
     }
-    if (paramConfig.contains("TrackFollowerNSigmaCutZ")) {
-      params.TrackFollowerNSigmaCutZ = paramConfig["TrackFollowerNSigmaCutZ"].get<float>();
-    }
-    if (paramConfig.contains("TrackFollowerNSigmaCutPhi")) {
-      params.TrackFollowerNSigmaCutPhi = paramConfig["TrackFollowerNSigmaCutPhi"].get<float>();
-    }
+    // if (paramConfig.contains("TrackFollowerNSigmaCutZ")) {
+    //   params.TrackFollowerNSigmaCutZ = paramConfig["TrackFollowerNSigmaCutZ"].get<float>();
+    // }
+    // if (paramConfig.contains("TrackFollowerNSigmaCutPhi")) {
+    //   params.TrackFollowerNSigmaCutPhi = paramConfig["TrackFollowerNSigmaCutPhi"].get<float>();
+    // }
 
     // Parse boolean parameters
     if (paramConfig.contains("UseDiamond")) {
@@ -162,9 +149,9 @@ std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromCon
     if (paramConfig.contains("ShiftRefToCluster")) {
       params.ShiftRefToCluster = paramConfig["ShiftRefToCluster"].get<bool>();
     }
-    if (paramConfig.contains("FindShortTracks")) {
-      params.FindShortTracks = paramConfig["FindShortTracks"].get<bool>();
-    }
+    // if (paramConfig.contains("FindShortTracks")) {
+    //   params.FindShortTracks = paramConfig["FindShortTracks"].get<bool>();
+    // }
     if (paramConfig.contains("PerPrimaryVertexProcessing")) {
       params.PerPrimaryVertexProcessing = paramConfig["PerPrimaryVertexProcessing"].get<bool>();
     }
@@ -177,18 +164,18 @@ std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromCon
     if (paramConfig.contains("FataliseUponFailure")) {
       params.FataliseUponFailure = paramConfig["FataliseUponFailure"].get<bool>();
     }
-    if (paramConfig.contains("UseTrackFollower")) {
-      params.UseTrackFollower = paramConfig["UseTrackFollower"].get<bool>();
-    }
-    if (paramConfig.contains("UseTrackFollowerTop")) {
-      params.UseTrackFollowerTop = paramConfig["UseTrackFollowerTop"].get<bool>();
-    }
-    if (paramConfig.contains("UseTrackFollowerBot")) {
-      params.UseTrackFollowerBot = paramConfig["UseTrackFollowerBot"].get<bool>();
-    }
-    if (paramConfig.contains("UseTrackFollowerMix")) {
-      params.UseTrackFollowerMix = paramConfig["UseTrackFollowerMix"].get<bool>();
-    }
+    // if (paramConfig.contains("UseTrackFollower")) {
+    //   params.UseTrackFollower = paramConfig["UseTrackFollower"].get<bool>();
+    // }
+    // if (paramConfig.contains("UseTrackFollowerTop")) {
+    //   params.UseTrackFollowerTop = paramConfig["UseTrackFollowerTop"].get<bool>();
+    // }
+    // if (paramConfig.contains("UseTrackFollowerBot")) {
+    //   params.UseTrackFollowerBot = paramConfig["UseTrackFollowerBot"].get<bool>();
+    // }
+    // if (paramConfig.contains("UseTrackFollowerMix")) {
+    //   params.UseTrackFollowerMix = paramConfig["UseTrackFollowerMix"].get<bool>();
+    // }
     if (paramConfig.contains("createArtefactLabels")) {
       params.createArtefactLabels = paramConfig["createArtefactLabels"].get<bool>();
     }
@@ -314,44 +301,37 @@ void TrackerDPL::run(ProcessingContext& pc)
     for (size_t iter{0}; iter < trackingParams.size(); ++iter) {
       LOGP(info, "{}", trackingParams[iter].asString());
       timeFrame.initialise(iter, trackingParams[iter], 11, false);
-      itsTrackerTraits.computeLayerTracklets(iter, -1, -1);
+      itsTrackerTraits.computeLayerTracklets(iter, -1);
       LOGP(info, "Number of tracklets in iteration {}: {}", iter, timeFrame.getNumberOfTracklets());
       itsTrackerTraits.computeLayerCells(iter);
       LOGP(info, "Number of cells in iteration {}: {}", iter, timeFrame.getNumberOfCells());
       itsTrackerTraits.findCellsNeighbours(iter);
       LOGP(info, "Number of cell neighbours in iteration {}: {}", iter, timeFrame.getNumberOfNeighbours());
       itsTrackerTraits.findRoads(iter);
-      LOGP(info, "Number of roads in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
-      itsTrackerTraits.extendTracks(iter);
+      LOGP(info, "Number of tracks in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
     }
     const auto trackingLoopElapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - trackingLoopStart).count();
     LOGP(info, "Tracking iterations block took {} ms", trackingLoopElapsedMs);
 
     itsTracker.computeTracksMClabels();
 
-    // Stream tracks and their MC labels to the output
-    // Collect all tracks and labels from all ROFs
-    std::vector<o2::its::TrackITS> allTracks;
-    std::vector<o2::MCCompLabel> allLabels;
+    // Collect tracks and labels (flat vectors in the new interface)
+    const auto& tracks = timeFrame.getTracks();
+    const auto& labels = timeFrame.getTracksLabel();
 
-    int totalTracks = 0;
+    // Copy to output vectors (TrackITSExt -> TrackITS slicing for output compatibility)
+    std::vector<o2::its::TrackITS> allTracks(tracks.begin(), tracks.end());
+    std::vector<o2::MCCompLabel> allLabels(labels.begin(), labels.end());
+
+    int totalTracks = allTracks.size();
     int goodTracks = 0;
     int fakeTracks = 0;
 
-    for (int iRof = 0; iRof < nRofs; ++iRof) {
-      const auto& rofTracks = timeFrame.getTracks(iRof);
-      const auto& rofLabels = timeFrame.getTracksLabel(iRof);
-
-      allTracks.insert(allTracks.end(), rofTracks.begin(), rofTracks.end());
-      allLabels.insert(allLabels.end(), rofLabels.begin(), rofLabels.end());
-
-      totalTracks += rofTracks.size();
-      for (const auto& label : rofLabels) {
-        if (label.isFake()) {
-          fakeTracks++;
-        } else {
-          goodTracks++;
-        }
+    for (const auto& label : allLabels) {
+      if (label.isFake()) {
+        fakeTracks++;
+      } else {
+        goodTracks++;
       }
     }
 
diff --git a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h
index 931628f2cf876..3b743c59524d2 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h
+++ b/Detectors/Upgrades/ITS3/reconstruction/include/ITS3Reconstruction/TrackingInterface.h
@@ -31,6 +31,7 @@ class ITS3TrackingInterface final : public its::ITSTrackingInterface
   void loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                gsl::span<const itsmft::CompClusterExt> clusters,
                gsl::span<const unsigned char>::iterator& pattIt,
+               int layer,
                const dataformats::MCTruthContainer<MCCompLabel>* mcLabels) final;
 
  private:
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
index 0fea07743b3df..92e36cd2a4b84 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/IOUtils.cxx
@@ -66,8 +66,8 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
   auto geom = its::GeometryTGeo::Instance();
   geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::L2G));
 
-  tf->resetROFrameData(rofs.size());
-  tf->prepareROFrameData(rofs, clusters);
+  // tf->resetROFrameData(rofs.size()); // FIXME
+  // tf->prepareROFrameData(rofs, clusters); FIXME
 
   its::bounded_vector<uint8_t> clusterSizeVec(clusters.size(), tf->getMemoryPool().get());
 
@@ -115,7 +115,7 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
     }
   }
 
-  tf->setClusterSize(clusterSizeVec);
+  // tf->setClusterSize(clusterSizeVec); FIXME
 
   for (auto& v : tf->mNTrackletsPerCluster) {
     v.resize(tf->getUnsortedClusters()[1].size());
@@ -125,8 +125,8 @@ int loadROFrameDataITS3(its::TimeFrame<7>* tf,
   }
 
   if (mcLabels != nullptr) {
-    tf->mClusterLabels = mcLabels;
+    // tf->mClusterLabels = mcLabels; // FIXME
   }
-  return tf->mNrof;
+  return 0;
 }
 } // namespace o2::its3::ioutils
diff --git a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
index 0f5c66a7f9663..9fe6f3735a845 100644
--- a/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
+++ b/Detectors/Upgrades/ITS3/reconstruction/src/TrackingInterface.cxx
@@ -13,7 +13,7 @@
 #include "ITS3Reconstruction/IOUtils.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITStracking/TrackingConfigParam.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "Framework/DeviceSpec.h"
 
@@ -77,9 +77,10 @@ void ITS3TrackingInterface::finaliseCCDB(framework::ConcreteDataMatcher& matcher
 void ITS3TrackingInterface::loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                                     gsl::span<const itsmft::CompClusterExt> clusters,
                                     gsl::span<const unsigned char>::iterator& pattIt,
+                                    int layer,
                                     const dataformats::MCTruthContainer<MCCompLabel>* mcLabels)
 {
-  ioutils::loadROFrameDataITS3(mTimeFrame, trackROFspan, clusters, pattIt, mDict, mcLabels);
+  // ioutils::loadROFrameDataITS3(mTimeFrame, trackROFspan, clusters, pattIt, mDict, mcLabels);
 }
 
 } // namespace o2::its3
diff --git a/Detectors/Upgrades/ITS3/workflow/src/ClustererSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/ClustererSpec.cxx
index f0238b74a3502..73b5f4650d02d 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/ClustererSpec.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/ClustererSpec.cxx
@@ -27,7 +27,7 @@
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "ITSMFTReconstruction/DigitPixelReader.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "CommonConstants/LHCConstants.h"
 
 using namespace o2::framework;
diff --git a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
index 60fe4fabfe481..f27fda19fe00c 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/RecoWorkflow.cxx
@@ -40,7 +40,7 @@ framework::WorkflowSpec getWorkflow(bool useMC, its::TrackingMode::Type trmode,
   }
 
   if (!disableRootOutput) {
-    specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC));
+    specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC, false));
   }
 
   if (trmode != its::TrackingMode::Off) {
diff --git a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
index 0326c12f804e0..8db02d7227e7f 100644
--- a/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ITS3/workflow/src/TrackerSpec.cxx
@@ -23,7 +23,7 @@
 #include "DataFormatsITSMFT/PhysTrigger.h"
 
 #include "ITStracking/TrackingConfigParam.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 
 #include "ITSBase/GeometryTGeo.h"
 #include "CommonDataFormat/IRFrame.h"
@@ -46,7 +46,7 @@ TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        const bool overrBeamEst,
                        o2::gpu::gpudatatypes::DeviceType dType) : mGGCCDBRequest(gr),
                                                                   mRecChain{o2::gpu::GPUReconstruction::CreateInstance(dType, true)},
-                                                                  mITS3TrackingInterface{isMC, trgType, overrBeamEst}
+                                                                  mITS3TrackingInterface{isMC, false, trgType, overrBeamEst}
 {
   mITS3TrackingInterface.setTrackingMode(trMode);
 }
diff --git a/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h b/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
index c06c2119b0cd1..cdf83603258cd 100644
--- a/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
+++ b/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
@@ -31,7 +31,7 @@
 #include "DetectorsVertexing/PVertexerParams.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DataFormatsCalibration/MeanVertexObject.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "gsl/span"
 #include <numeric>
 #include <TTree.h>
diff --git a/Detectors/Vertexing/src/VertexTrackMatcher.cxx b/Detectors/Vertexing/src/VertexTrackMatcher.cxx
index 8612187c0bffc..f66d2b8c4d347 100644
--- a/Detectors/Vertexing/src/VertexTrackMatcher.cxx
+++ b/Detectors/Vertexing/src/VertexTrackMatcher.cxx
@@ -15,7 +15,7 @@
 
 #include "DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h"
 #include "DetectorsVertexing/VertexTrackMatcher.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include <unordered_map>
 #include <numeric>
 
diff --git a/Detectors/Vertexing/test/PVFromPool.C b/Detectors/Vertexing/test/PVFromPool.C
index 7bca9c03bf42f..248cbda401eca 100644
--- a/Detectors/Vertexing/test/PVFromPool.C
+++ b/Detectors/Vertexing/test/PVFromPool.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
 #include "DetectorsVertexing/PVertexer.h"
@@ -11,7 +22,7 @@
 #include "DataFormatsParameters/GRPECSObject.h"
 #include "DataFormatsParameters/GRPMagField.h"
 #include "DetectorsBase/Propagator.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "CCDB/BasicCCDBManager.h"
 #include <string>
 
diff --git a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
index 2bb3c220d67a0..b4f7655648001 100644
--- a/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
+++ b/EventVisualisation/Workflow/src/EveWorkflowHelper.cxx
@@ -32,7 +32,7 @@
 #include "MCHTracking/TrackParam.h"
 #include "MCHTracking/TrackExtrap.h"
 #include "DataFormatsITSMFT/TrkClusRef.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "CommonDataFormat/IRFrame.h"
 #include "MFTBase/GeometryTGeo.h"
 #include "ITSBase/GeometryTGeo.h"
diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index bd8ab5a664d99..828892ea97406 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -37,6 +37,7 @@
 #include "DataFormatsMCH/ROFRecord.h"
 #include <EventVisualisationBase/DirectoryLoader.h>
 #include "DataFormatsMCH/Cluster.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include <unistd.h>
 
 using std::chrono::duration_cast;
@@ -78,7 +79,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"configKeyValues", VariantType::String, "", {"semicolon separated key=value strings, e.g. EveConfParam content..."}},
     {"skipOnEmptyInput", VariantType::Bool, false, {"don't run the ED when no input is provided"}},
   };
-
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
index 813e0aef2d1aa..36a2b3ebca103 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIncludesITS.h
@@ -21,7 +21,6 @@
 #include "ITStracking/TimeFrame.h"
 #if defined(__CUDACC__) || defined(__HIPCC__)
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
-#include "ITStrackingGPU/VertexerTraitsGPU.h"
 #include "ITStrackingGPU/TimeFrameGPU.h"
 #endif
 #else
@@ -39,10 +38,6 @@ template <int32_t>
 class TimeFrame
 {
 };
-template <int32_t NLayers>
-class VertexerTraitsGPU : public VertexerTraits<NLayers>
-{
-};
 template <int32_t NLayers = 7>
 class TrackerTraitsGPU : public TrackerTraits<NLayers>
 {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index c919581eefdde..eb49a02fbb946 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -94,15 +94,13 @@ GPUReconstruction* GPUReconstruction_Create_CUDA(const GPUSettingsDeviceBackend&
 void GPUReconstructionCUDA::GetITSTraits(std::unique_ptr<o2::its::TrackerTraits<7>>* trackerTraits, std::unique_ptr<o2::its::VertexerTraits<7>>* vertexerTraits, std::unique_ptr<o2::its::TimeFrame<7>>* timeFrame)
 {
   if (trackerTraits) {
-    trackerTraits->reset(new o2::its::TrackerTraitsGPU);
+    trackerTraits->reset(new o2::its::TrackerTraitsGPU<7>);
   }
   if (vertexerTraits) {
     vertexerTraits->reset(new o2::its::VertexerTraits<7>);
-    // TODO gpu-code to be implemented then remove line above and uncomment line below
-    // vertexerTraits->reset(new o2::its::VertexerTraitsGPU<7>);
   }
   if (timeFrame) {
-    timeFrame->reset(new o2::its::gpu::TimeFrameGPU);
+    timeFrame->reset(new o2::its::gpu::TimeFrameGPU<7>);
   }
 }
 
diff --git a/GPU/GPUTracking/Global/GPUChainITS.h b/GPU/GPUTracking/Global/GPUChainITS.h
index 4aa97f3f47784..ee466365a157d 100644
--- a/GPU/GPUTracking/Global/GPUChainITS.h
+++ b/GPU/GPUTracking/Global/GPUChainITS.h
@@ -19,9 +19,6 @@
 namespace o2::its
 {
 struct Cluster;
-template <uint8_t N>
-class Road;
-class Cell;
 struct TrackingFrameInfo;
 class TrackITSExt;
 class GPUFrameworkExternalAllocator;
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index 9c516ebb960d7..658cdc46cb6cb 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -31,7 +31,7 @@
 #include "TOFBase/Geo.h"
 #include "ITSBase/GeometryTGeo.h"
 #ifdef GPUCA_O2_LIB
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #endif
 
 #include <oneapi/tbb.h>
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 8dfbdaff7272f..c5e4124c41650 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -132,6 +132,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     int32_t lumiScaleType = 0; // 0=off, 1=CTP, 2=TPC scalers
     bool outputErrorQA = false;
     bool runITSTracking = false;
+    bool itsStaggered = false;
     bool itsOverrBeamEst = false;
     bool tpcTriggerHandling = false;
     bool isITS3 = false;
diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index 46e1b1578285c..fb27df2ec08b9 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -52,18 +52,21 @@ void GPURecoWorkflowSpec::initFunctionITS(o2::framework::InitContext& ic)
 #ifdef ENABLE_UPGRADES
   if (mSpecConfig.isITS3) {
     mITSTrackingInterface = std::make_unique<o2::its3::ITS3TrackingInterface>(mSpecConfig.processMC,
+                                                                              mSpecConfig.itsStaggered,
                                                                               mSpecConfig.itsTriggerType,
                                                                               mSpecConfig.itsOverrBeamEst);
-  } else
-#endif
-  {
+  } else {
     mITSTrackingInterface = std::make_unique<o2::its::ITSTrackingInterface>(mSpecConfig.processMC,
+                                                                            mSpecConfig.itsStaggered,
                                                                             mSpecConfig.itsTriggerType,
                                                                             mSpecConfig.itsOverrBeamEst);
   }
+#else
   mITSTrackingInterface = std::make_unique<o2::its::ITSTrackingInterface>(mSpecConfig.processMC,
+                                                                          mSpecConfig.itsStaggered,
                                                                           mSpecConfig.itsTriggerType,
                                                                           mSpecConfig.itsOverrBeamEst);
+#endif
   mGPUReco->GetITSTraits(trkTraits, vtxTraits, mITSTimeFrame);
   mITSTrackingInterface->setTraitsFromProvider(vtxTraits, trkTraits, mITSTimeFrame);
 }
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index dbb554a14cea4..4b1aa7fd58bd5 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -1229,9 +1229,14 @@ Inputs GPURecoWorkflowSpec::inputs()
   }
 
   if (mSpecConfig.runITSTracking) {
-    inputs.emplace_back("compClusters", "ITS", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-    inputs.emplace_back("patterns", "ITS", "PATTERNS", 0, Lifetime::Timeframe);
-    inputs.emplace_back("ROframes", "ITS", "CLUSTERSROF", 0, Lifetime::Timeframe);
+    for (unsigned int iLay{0}; iLay < (mSpecConfig.itsStaggered ? 7 : 1); ++iLay) {
+      inputs.emplace_back("compClusters", "ITS", "COMPCLUSTERS", iLay, Lifetime::Timeframe);
+      inputs.emplace_back("patterns", "ITS", "PATTERNS", iLay, Lifetime::Timeframe);
+      inputs.emplace_back("ROframes", "ITS", "CLUSTERSROF", iLay, Lifetime::Timeframe);
+      if (mSpecConfig.processMC) {
+        inputs.emplace_back("itsmclabels", "ITS", "CLUSTERSMCTR", iLay, Lifetime::Timeframe);
+      }
+    }
     if (mSpecConfig.itsTriggerType == 1) {
       inputs.emplace_back("phystrig", "ITS", "PHYSTRIG", 0, Lifetime::Timeframe);
     } else if (mSpecConfig.itsTriggerType == 2) {
@@ -1249,10 +1254,6 @@ Inputs GPURecoWorkflowSpec::inputs()
         inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
       }
     }
-    if (mSpecConfig.processMC) {
-      inputs.emplace_back("itsmclabels", "ITS", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-      inputs.emplace_back("ITSMC2ROframes", "ITS", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
-    }
   }
 
   // NN clusterizer
@@ -1388,7 +1389,6 @@ Outputs GPURecoWorkflowSpec::outputs()
       outputSpecs.emplace_back(gDataOriginITS, "VERTICESMCTR", 0, Lifetime::Timeframe);
       outputSpecs.emplace_back(gDataOriginITS, "VERTICESMCPUR", 0, Lifetime::Timeframe);
       outputSpecs.emplace_back(gDataOriginITS, "TRACKSMCTR", 0, Lifetime::Timeframe);
-      outputSpecs.emplace_back(gDataOriginITS, "ITSTrackMC2ROF", 0, Lifetime::Timeframe);
     }
   }
 
diff --git a/GPU/Workflow/src/O2GPUDPLDisplay.cxx b/GPU/Workflow/src/O2GPUDPLDisplay.cxx
index 8513541bcae43..ed0d522b4d7ea 100644
--- a/GPU/Workflow/src/O2GPUDPLDisplay.cxx
+++ b/GPU/Workflow/src/O2GPUDPLDisplay.cxx
@@ -34,6 +34,7 @@
 #include "GPUWorkflowHelper/GPUWorkflowHelper.h"
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "DetectorsRaw/HBFUtils.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
 using namespace o2::dataformats;
@@ -53,7 +54,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"read-from-files", o2::framework::VariantType::Bool, false, {"Automatically create readers for input"}},
     {"disable-root-input", o2::framework::VariantType::Bool, false, {"Disable root input overriding read-from-files"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
-
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index e620d013cc925..13e28a1c341b3 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -29,6 +29,7 @@
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 #include <unordered_map>
 #include <numeric>
@@ -66,6 +67,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   };
   o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
+  o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   std::swap(workflowOptions, options);
 }
 
@@ -190,6 +192,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
   cfg.tpcDeadMapSources = cfgc.options().get<int32_t>("tpc-deadMap-sources");
   cfg.tpcUseMCTimeGain = cfgc.options().get<bool>("tpc-mc-time-gain");
   cfg.runITSTracking = isEnabled(outputTypes, ioType::ITSTracks);
+  cfg.itsStaggered = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(cfgc);
   cfg.itsOverrBeamEst = isEnabled(inputTypes, ioType::MeanVertex);
   cfg.useFilteredOutputSpecs = cfgc.options().get<bool>("filtered-output-specs");
 
diff --git a/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
index 60a1660288b9d..19552a407ec57 100644
--- a/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITS3DigitizerSpec.cxx
@@ -28,7 +28,7 @@
 #include "ITS3Simulation/Digitizer.h"
 #include "ITSMFTSimulation/DPLDigitizerParam.h"
 #include "ITS3Simulation/ITS3DPLDigitizerParam.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITS3Base/ITS3Params.h"
 
diff --git a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
index eafb72c675a58..a4c401bbf8b42 100644
--- a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
@@ -13,7 +13,6 @@
 #include "Framework/ControlService.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/DataProcessorSpec.h"
-#include "Framework/DataRefUtils.h"
 #include "Framework/Lifetime.h"
 #include "Framework/Task.h"
 #include "Framework/CCDBParamSpec.h"
@@ -26,18 +25,16 @@
 #include "DetectorsRaw/HBFUtils.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "DetectorsCommonDataFormats/SimTraits.h"
-#include "DetectorsCommonDataFormats/DetectorNameConf.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "ITSMFTSimulation/Digitizer.h"
 #include "ITSMFTSimulation/DPLDigitizerParam.h"
-#include "ITSMFTBase/DPLAlpideParam.h"
+#include "DataFormatsITSMFT/DPLAlpideParam.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "MFTBase/GeometryTGeo.h"
 #include <TChain.h>
 #include <TStopwatch.h>
 #include <string>
-#include <format>
 
 using namespace o2::framework;
 using SubSpecificationType = o2::framework::DataAllocator::SubSpecificationType;
@@ -52,13 +49,20 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
  public:
   static constexpr o2::detectors::DetID ID{N == o2::detectors::DetID::ITS ? o2::detectors::DetID::ITS : o2::detectors::DetID::MFT};
   static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
-  static constexpr int NLayers{o2::itsmft::DPLAlpideParam<N>::getNLayers()};
 
   using BaseDPLDigitizer::init;
 
   void initDigitizerTask(framework::InitContext& ic) override
   {
     mDisableQED = ic.options().get<bool>("disable-qed");
+    if (mDoStaggering) {
+      mLayers = DPLAlpideParam<N>::getNLayers();
+    }
+    mDigits.resize(mLayers);
+    mROFRecords.resize(mLayers);
+    mROFRecordsAccum.resize(mLayers);
+    mLabels.resize(mLayers);
+    mLabelsAccum.resize(mLayers);
   }
 
   void run(framework::ProcessingContext& pc)
@@ -89,9 +93,8 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
     }
 
     uint64_t nDigits{0};
-    constexpr uint32_t nLayers = (DPLAlpideParam<N>::supportsStaggering()) ? NLayers : 1;
-    for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
-      const int layer = (DPLAlpideParam<N>::supportsStaggering()) ? iLayer : -1;
+    for (uint32_t iLayer = 0; iLayer < mLayers; ++iLayer) {
+      const int layer = (mDoStaggering) ? iLayer : -1;
       mDigitizer.setDigits(&mDigits[iLayer]);
       mDigitizer.setROFRecords(&mROFRecords[iLayer]);
       mDigitizer.setMCLabels(&mLabels[iLayer]);
@@ -121,25 +124,13 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
           auto& rof = mROFRecords[iLayer][i];
           rof.setFirstEntry(ndigAcc + rof.getFirstEntry());
           rof.print();
-
-          if (mFixMC2ROF[iLayer] < mMC2ROFRecordsAccum[iLayer].size()) { // fix ROFRecord entry in MC2ROF records
-            for (int m2rid = mFixMC2ROF[iLayer]; m2rid < mMC2ROFRecordsAccum[iLayer].size(); m2rid++) {
-              // need to register the ROFRecors entry for MC event starting from this entry
-              auto& mc2rof = mMC2ROFRecordsAccum[iLayer][m2rid];
-              if (rof.getROFrame() == mc2rof.minROF) {
-                mFixMC2ROF[iLayer]++;
-                mc2rof.rofRecordID = nROFRecsOld + i;
-                mc2rof.print();
-              }
-            }
-          }
         }
 
         std::copy(mROFRecords[iLayer].begin(), mROFRecords[iLayer].end(), std::back_inserter(mROFRecordsAccum[iLayer]));
         if (mWithMCTruth) {
           mLabelsAccum[iLayer].mergeAtBack(mLabels[iLayer]);
         }
-        LOG(info) << "Added " << mDigits[iLayer].size() << " digits:" << iLayer;
+        LOG(info) << "Added " << mDigits[iLayer].size() << " digits" << ((mDoStaggering) ? std::format(" on layer {}", iLayer) : "");
         // clean containers from already accumulated stuff
         mLabels[iLayer].clear();
         mDigits[iLayer].clear();
@@ -171,7 +162,6 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
             mDigitizer.process(&mHits, part.entryID, part.sourceID, layer); // call actual digitization procedure
           }
         }
-        mMC2ROFRecordsAccum[iLayer].emplace_back(collID, -1, mDigitizer.getEventROFrameMin(), mDigitizer.getEventROFrameMax());
         accumulate();
       }
       mDigitizer.fillOutputContainer(0xffffffff, layer);
@@ -190,7 +180,7 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
         for (int iROF{0}; iROF < nROFsLayer; ++iROF) {
           auto& rof = expDigitRofVec[iROF];
           int orb = iROF * DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer) / o2::constants::lhc::LHCMaxBunches + mFirstOrbitTF;
-          int bc = iROF * DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches;
+          int bc = iROF * DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer) % o2::constants::lhc::LHCMaxBunches + DPLAlpideParam<N>::Instance().getROFDelayInBC(iLayer);
           o2::InteractionRecord ir(bc, orb);
           rof.setBCData(ir);
           rof.setROFrame(iROF);
@@ -200,7 +190,16 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
         uint32_t prevEntry{0};
         for (const auto& rof : mROFRecordsAccum[iLayer]) {
           const auto& ir = rof.getBCData();
-          const auto irToFirst = ir - firstIR;
+          if (ir < firstIR) {
+            LOGP(warn, "Discard ROF {} preceding TF 1st orbit {}{}", ir.asString(), mFirstOrbitTF, ((mDoStaggering) ? std::format(" on layer {}", iLayer) : ""));
+            continue;
+          }
+          auto irToFirst = ir - firstIR;
+          if (irToFirst.toLong() - DPLAlpideParam<N>::Instance().getROFDelayInBC(iLayer) < 0) {
+            LOGP(warn, "Discard ROF {} preceding TF 1st orbit {} due to imposed ROF delay{}", ir.asString(), mFirstOrbitTF, ((mDoStaggering) ? std::format(" on layer {}", iLayer) : ""));
+            continue;
+          }
+          irToFirst -= DPLAlpideParam<N>::Instance().getROFDelayInBC(iLayer);
           const int irROF = irToFirst.toLong() / DPLAlpideParam<N>::Instance().getROFLengthInBC(iLayer);
           auto& expROF = expDigitRofVec[irROF];
           expROF.setFirstEntry(rof.getFirstEntry());
@@ -224,7 +223,6 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
         pc.outputs().snapshot(Output{Origin, "DIGITSROF", iLayer}, mROFRecordsAccum[iLayer]);
       }
       if (mWithMCTruth) {
-        pc.outputs().snapshot(Output{Origin, "DIGITSMC2ROF", iLayer}, mMC2ROFRecordsAccum[iLayer]);
         auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{Origin, "DIGITSMCTR", iLayer});
         mLabelsAccum[iLayer].flatten_to(sharedlabels);
         // free space of existing label containers
@@ -292,7 +290,7 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
   }
 
  protected:
-  ITSMFTDPLDigitizerTask(bool mctruth = true) : BaseDPLDigitizer(InitServices::FIELD | InitServices::GEOM), mWithMCTruth(mctruth) {}
+  ITSMFTDPLDigitizerTask(bool mctruth = true, bool doStag = false) : BaseDPLDigitizer(InitServices::FIELD | InitServices::GEOM), mWithMCTruth(mctruth), mDoStaggering(doStag) {}
 
   void updateTimeDependentParams(ProcessingContext& pc)
   {
@@ -331,17 +329,15 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
     digipar.setOBVbb(dopt.OBVbb);
     digipar.setVbb(dopt.Vbb);
     // staggering parameters
-    if constexpr (o2::itsmft::DPLAlpideParam<N>::supportsStaggering()) {
-      const bool withStag = aopt.withStaggering();
+    if (mDoStaggering) {
       for (int iLayer{0}; iLayer < o2::itsmft::DPLAlpideParam<N>::getNLayers(); ++iLayer) {
-        const int nLayer = (withStag) ? iLayer : -1;
-        auto frameNS = aopt.getROFLengthInBC(nLayer) * o2::constants::lhc::LHCBunchSpacingNS;
-        digipar.addROFrameLayerLengthInBC(aopt.getROFLengthInBC(nLayer));
+        auto frameNS = aopt.getROFLengthInBC(iLayer) * o2::constants::lhc::LHCBunchSpacingNS;
+        digipar.addROFrameLayerLengthInBC(aopt.getROFLengthInBC(iLayer));
         // NOTE: the rof delay looks from the digitizer like an additional bias
-        digipar.addROFrameLayerBiasInBC(aopt.getROFBiasInBC(nLayer) + aopt.getROFDelayInBC(nLayer));
+        digipar.addROFrameLayerBiasInBC(aopt.getROFBiasInBC(iLayer) + aopt.getROFDelayInBC(iLayer));
         digipar.addStrobeDelay(aopt.strobeDelay);
         digipar.addStrobeLength(aopt.strobeLengthCont > 0 ? aopt.strobeLengthCont : frameNS - aopt.strobeDelay);
-        digipar.setROFrameLength(aopt.getROFLengthInBC(nLayer) * o2::constants::lhc::LHCBunchSpacingNS, iLayer);
+        digipar.setROFrameLength(aopt.getROFLengthInBC(iLayer) * o2::constants::lhc::LHCBunchSpacingNS, iLayer);
       }
     }
 
@@ -363,22 +359,22 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
   }
 
   bool mWithMCTruth = true;
+  bool mDoStaggering = false;
   bool mFinished = false;
   bool mDisableQED = false;
+  int mLayers = 1;
   unsigned long mFirstOrbitTF = 0x0;
   o2::itsmft::Digitizer mDigitizer;
-  std::array<std::vector<o2::itsmft::Digit>, NLayers> mDigits;
-  std::array<std::vector<o2::itsmft::ROFRecord>, NLayers> mROFRecords;
-  std::array<std::vector<o2::itsmft::ROFRecord>, NLayers> mROFRecordsAccum;
+  std::vector<std::vector<o2::itsmft::Digit>> mDigits;
+  std::vector<std::vector<o2::itsmft::ROFRecord>> mROFRecords;
+  std::vector<std::vector<o2::itsmft::ROFRecord>> mROFRecordsAccum;
   std::vector<o2::itsmft::Hit> mHits;
   std::vector<o2::itsmft::Hit>* mHitsP = &mHits;
-  std::array<o2::dataformats::MCTruthContainer<o2::MCCompLabel>, NLayers> mLabels;
-  std::array<o2::dataformats::MCTruthContainer<o2::MCCompLabel>, NLayers> mLabelsAccum;
-  std::array<std::vector<o2::itsmft::MC2ROFRecord>, NLayers> mMC2ROFRecordsAccum;
+  std::vector<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> mLabels;
+  std::vector<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> mLabelsAccum;
   std::vector<TChain*> mSimChains;
   o2::itsmft::NoiseMap* mDeadMap = nullptr;
 
-  std::array<int, NLayers> mFixMC2ROF{}; // 1st entry in mc2rofRecordsAccum to be fixed for ROFRecordID
   bool mTimeDeadMapUpdated = false;
   o2::parameters::GRPObject::ROMode mROMode = o2::parameters::GRPObject::PRESENT; // readout mode
 };
@@ -387,28 +383,27 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
 class ITSDPLDigitizerTask : public ITSMFTDPLDigitizerTask<o2::detectors::DetID::ITS>
 {
  public:
-  ITSDPLDigitizerTask(bool mctruth = true) : ITSMFTDPLDigitizerTask<o2::detectors::DetID::ITS>(mctruth) {}
+  ITSDPLDigitizerTask(bool mctruth = true, bool doStag = false) : ITSMFTDPLDigitizerTask<o2::detectors::DetID::ITS>(mctruth, doStag) {}
 };
 
 //_______________________________________________
 class MFTDPLDigitizerTask : public ITSMFTDPLDigitizerTask<o2::detectors::DetID::MFT>
 {
  public:
-  MFTDPLDigitizerTask(bool mctruth = true) : ITSMFTDPLDigitizerTask<o2::detectors::DetID::MFT>(mctruth) {}
+  MFTDPLDigitizerTask(bool mctruth = true, bool doStag = false) : ITSMFTDPLDigitizerTask<o2::detectors::DetID::MFT>(mctruth, doStag) {}
 };
 
 namespace
 {
 template <int N>
-std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mctruth)
+std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mctruth, bool doStag)
 {
   std::vector<OutputSpec> outputs;
-  constexpr uint32_t nLayers = (DPLAlpideParam<N>::supportsStaggering()) ? DPLAlpideParam<N>::getNLayers() : 1;
+  uint32_t nLayers = doStag ? DPLAlpideParam<N>::getNLayers() : 1;
   for (uint32_t iLayer = 0; iLayer < nLayers; ++iLayer) {
     outputs.emplace_back(detOrig, "DIGITS", iLayer, Lifetime::Timeframe);
     outputs.emplace_back(detOrig, "DIGITSROF", iLayer, Lifetime::Timeframe);
     if (mctruth) {
-      outputs.emplace_back(detOrig, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
       outputs.emplace_back(detOrig, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
     }
   }
@@ -417,7 +412,7 @@ std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mct
 }
 } // namespace
 
-DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth)
+DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth, bool doStag)
 {
   std::string detStr = o2::detectors::DetID::getName(ITSDPLDigitizerTask::ID);
   auto detOrig = ITSDPLDigitizerTask::Origin;
@@ -431,13 +426,13 @@ DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth)
   inputs.emplace_back("ITS_alpiderespvbbm3", "ITS", "ALPIDERESPVbbM3", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbbM3"));
   return DataProcessorSpec{.name = detStr + "Digitizer",
                            .inputs = inputs,
-                           .outputs = makeOutChannels<o2::detectors::DetID::ITS>(detOrig, mctruth),
-                           .algorithm = AlgorithmSpec{adaptFromTask<ITSDPLDigitizerTask>(mctruth)},
+                           .outputs = makeOutChannels<o2::detectors::DetID::ITS>(detOrig, mctruth, doStag),
+                           .algorithm = AlgorithmSpec{adaptFromTask<ITSDPLDigitizerTask>(mctruth, doStag)},
                            .options = Options{
                              {"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
 }
 
-DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth)
+DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth, bool doStag)
 {
   std::string detStr = o2::detectors::DetID::getName(MFTDPLDigitizerTask::ID);
   auto detOrig = MFTDPLDigitizerTask::Origin;
@@ -451,10 +446,10 @@ DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth)
   inputs.emplace_back("MFT_alpiderespvbbm3", "MFT", "ALPIDERESPVbbM3", 0, Lifetime::Condition, ccdbParamSpec("ITSMFT/Calib/ALPIDEResponseVbbM3"));
   return DataProcessorSpec{.name = detStr + "Digitizer",
                            .inputs = inputs,
-                           .outputs = makeOutChannels<o2::detectors::DetID::MFT>(detOrig, mctruth),
-                           .algorithm = AlgorithmSpec{adaptFromTask<MFTDPLDigitizerTask>(mctruth)},
+                           .outputs = makeOutChannels<o2::detectors::DetID::MFT>(detOrig, mctruth, doStag),
+                           .algorithm = AlgorithmSpec{adaptFromTask<MFTDPLDigitizerTask>(mctruth, doStag)},
                            .options = Options{{"disable-qed", o2::framework::VariantType::Bool, false, {"disable QED handling"}}}};
 }
 
 } // namespace o2::itsmft
-  // end namespace o2
+// end namespace o2
diff --git a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.h b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.h
index 55fd88b1e1f80..e763cfe9565f4 100644
--- a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.h
+++ b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.h
@@ -19,8 +19,8 @@ namespace o2
 namespace itsmft
 {
 
-o2::framework::DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth = true);
-o2::framework::DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth = true);
+o2::framework::DataProcessorSpec getITSDigitizerSpec(int channel, bool mctruth = true, bool doStag = false);
+o2::framework::DataProcessorSpec getMFTDigitizerSpec(int channel, bool mctruth = true, bool doStag = false);
 
 } // end namespace itsmft
 } // end namespace o2
diff --git a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
index 6f956efe79304..b4f9c1643d150 100644
--- a/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
+++ b/Steer/DigitizerWorkflow/src/SimpleDigitizerWorkflow.cxx
@@ -37,6 +37,7 @@
 #include "TPCSimulation/GEMAmplification.h"
 
 // for ITSMFT
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "ITSMFTDigitizerSpec.h"
 #include "ITSMFTWorkflow/DigitWriterSpec.h"
 
@@ -225,6 +226,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 
   // option to propagate CTP Lumi scaler counts (if >=0) into the CTP digits
   workflowOptions.push_back(ConfigParamSpec{"store-ctp-lumi", VariantType::Float, -1.f, {"store CTP lumi scaler in CTP digits (if >= 0)"}});
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(workflowOptions);
 }
 
 void customize(std::vector<o2::framework::DispatchPolicy>& policies)
@@ -637,10 +639,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // the ITS part
   if (isEnabled(o2::detectors::DetID::ITS)) {
     detList.emplace_back(o2::detectors::DetID::ITS);
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
     // connect the ITS digitization
-    digitizerSpecs.emplace_back(o2::itsmft::getITSDigitizerSpec(fanoutsize++, mctruth));
+    digitizerSpecs.emplace_back(o2::itsmft::getITSDigitizerSpec(fanoutsize++, mctruth, doStag));
     // connect ITS digit writer
-    writerSpecs.emplace_back(o2::itsmft::getITSDigitWriterSpec(mctruth));
+    writerSpecs.emplace_back(o2::itsmft::getITSDigitWriterSpec(mctruth, doStag));
   }
 
 #ifdef ENABLE_UPGRADES
@@ -666,10 +669,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // the MFT part
   if (isEnabled(o2::detectors::DetID::MFT)) {
     detList.emplace_back(o2::detectors::DetID::MFT);
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
     // connect the MFT digitization
-    digitizerSpecs.emplace_back(o2::itsmft::getMFTDigitizerSpec(fanoutsize++, mctruth));
+    digitizerSpecs.emplace_back(o2::itsmft::getMFTDigitizerSpec(fanoutsize++, mctruth, doStag));
     // connect MFT digit writer
-    writerSpecs.emplace_back(o2::itsmft::getMFTDigitWriterSpec(mctruth));
+    writerSpecs.emplace_back(o2::itsmft::getMFTDigitWriterSpec(mctruth, doStag));
   }
 
   // the TOF part
diff --git a/doc/data/2021-02-o2_prs.json b/doc/data/2021-02-o2_prs.json
index d36bfadccf499..2bf9b8ff3cb4b 100644
--- a/doc/data/2021-02-o2_prs.json
+++ b/doc/data/2021-02-o2_prs.json
@@ -2399,7 +2399,7 @@
                 },
                 {
                   "node": {
-                    "path": "Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h"
+                    "path": "Detectors/ITSMFT/common/base/include/DataFormatsITSMFT/DPLAlpideParam.h"
                   }
                 },
                 {
diff --git a/doc/data/2022-01-o2_prs.json b/doc/data/2022-01-o2_prs.json
index 155ab6ed3d8d5..1e21f2e051c5e 100644
--- a/doc/data/2022-01-o2_prs.json
+++ b/doc/data/2022-01-o2_prs.json
@@ -3475,7 +3475,7 @@
               "edges": [
                 {
                   "node": {
-                    "path": "Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h"
+                    "path": "Detectors/ITSMFT/common/base/include/DataFormatsITSMFT/DPLAlpideParam.h"
                   }
                 }
               ]
diff --git a/macro/run_rawdecoding_its.C b/macro/run_rawdecoding_its.C
index c5ee6c9b0ff5e..d05681356019a 100644
--- a/macro/run_rawdecoding_its.C
+++ b/macro/run_rawdecoding_its.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
 #include <TTree.h>
@@ -42,7 +53,7 @@ void run_rawdecoding_its(std::string inpName = "rawits.bin", // input binary dat
   TStopwatch sw;
   sw.Start();
   uint32_t roFrame = 0;
-  o2::InteractionRecord irHB, irTrig;
+  o2::InteractionRecord irTrig;
   std::vector<o2::itsmft::Digit> digits, *digitsPtr = &digits;
   std::vector<o2::itsmft::ROFRecord> rofRecVec, *rofRecVecPtr = &rofRecVec;
   std::size_t rofEntry = 0, nrofdig = 0;
@@ -62,12 +73,11 @@ void run_rawdecoding_its(std::string inpName = "rawits.bin", // input binary dat
     }
 
     if (outTreeDig) { // >> store digits
-      if (irHB != rawReader.getInteractionRecordHB() || irTrig != rawReader.getInteractionRecord()) {
+      if (irTrig != rawReader.getInteractionRecord()) {
         if (!irTrig.isDummy()) {
-          rofRecVec.emplace_back(irHB, roFrame, rofEntry, nrofdig); // registed finished ROF
+          rofRecVec.emplace_back(irTrig, roFrame, rofEntry, nrofdig); // registed finished ROF
           roFrame++;
         }
-        irHB = rawReader.getInteractionRecordHB();
         irTrig = rawReader.getInteractionRecord();
         rofEntry = digits.size();
         nrofdig = 0;
@@ -79,7 +89,6 @@ void run_rawdecoding_its(std::string inpName = "rawits.bin", // input binary dat
       }
 
       printf("ROF %7d ch: %5d IR: ", roFrame, chipData.getChipID());
-      irHB.print();
 
     } // << store digits
     //
@@ -87,7 +96,7 @@ void run_rawdecoding_its(std::string inpName = "rawits.bin", // input binary dat
 
   if (outTreeDig) {
     // register last ROF
-    rofRecVec.emplace_back(irHB, roFrame, rofEntry, nrofdig); // registed finished ROF
+    rofRecVec.emplace_back(irTrig, roFrame, rofEntry, nrofdig); // registed finished ROF
 
     // fill last (and the only one?) entry
     outTreeDig->Fill();
diff --git a/macro/run_rawdecoding_mft.C b/macro/run_rawdecoding_mft.C
index d8bdb0ce1e2ce..d23668f7e5498 100644
--- a/macro/run_rawdecoding_mft.C
+++ b/macro/run_rawdecoding_mft.C
@@ -1,3 +1,14 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
 #include <TTree.h>
@@ -42,7 +53,7 @@ void run_rawdecoding_mft(std::string inpName = "06282019_1854_output.bin", // in
   TStopwatch sw;
   sw.Start();
   uint32_t roFrame = 0;
-  o2::InteractionRecord irHB, irTrig;
+  o2::InteractionRecord irTrig;
   std::vector<o2::itsmft::Digit> digits, *digitsPtr = &digits;
   std::vector<o2::itsmft::ROFRecord> rofRecVec, *rofRecVecPtr = &rofRecVec;
   int rofEntry = 0, nrofdig = 0;
@@ -62,12 +73,11 @@ void run_rawdecoding_mft(std::string inpName = "06282019_1854_output.bin", // in
     }
 
     if (outTreeDig) { // >> store digits
-      if (irHB != rawReader.getInteractionRecordHB() || irTrig != rawReader.getInteractionRecord()) {
+      if (irTrig != rawReader.getInteractionRecord()) {
         if (!irTrig.isDummy()) {
-          rofRecVec.emplace_back(irHB, roFrame, rofEntry, nrofdig); // registed finished ROF
+          rofRecVec.emplace_back(irTrig, roFrame, rofEntry, nrofdig); // registed finished ROF
           roFrame++;
         }
-        irHB = rawReader.getInteractionRecordHB();
         irTrig = rawReader.getInteractionRecord();
         rofEntry = digits.size();
         nrofdig = 0;
@@ -79,7 +89,6 @@ void run_rawdecoding_mft(std::string inpName = "06282019_1854_output.bin", // in
       }
 
       printf("ROF %7d ch: %5d IR: ", roFrame, chipData.getChipID());
-      irHB.print();
 
     } // << store digits
     //
@@ -87,7 +96,7 @@ void run_rawdecoding_mft(std::string inpName = "06282019_1854_output.bin", // in
 
   if (outTreeDig) {
     // register last ROF
-    rofRecVec.emplace_back(irHB, roFrame, rofEntry, nrofdig); // registed finished ROF
+    rofRecVec.emplace_back(irTrig, roFrame, rofEntry, nrofdig); // registed finished ROF
 
     // fill last (and the only one?) entry
     outTreeDig->Fill();
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 1e1ea258d395f..9f982513fdffd 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -107,10 +107,16 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 : ${AOD_SOURCES:=$TRACK_SOURCES}
 : ${AODPROD_OPT:=}
 : ${ALPIDE_ERR_DUMPS:=}
+: ${ITSSTAGGERED:=}
+: ${MFTSTAGGERED:=}
+
 [[ -z $ALPIDE_ERR_DUMPS ]] && [[ $EPNSYNCMODE == 1 && $RUNTYPE == "PHYSICS" ]] && ALPIDE_ERR_DUMPS=1 || ALPIDE_ERR_DUMPS=0
 
 [[ "0$DISABLE_ROOT_OUTPUT" == "00" ]] && DISABLE_ROOT_OUTPUT=
 
+[[ "0$ITSSTAGGERED" == "01" ]] && ITS_STAGGERED=" --enable-its-staggering " || ITS_STAGGERED=
+[[ "0$MFTSTAGGERED" == "01" ]] && MFT_STAGGERED=" --enable-its-staggering " || MFT_STAGGERED=
+
 if [[ $CTFINPUT != 1 ]]; then
   GPU_OUTPUT+=",tpc-triggers"
 fi
@@ -127,7 +133,6 @@ if [[ $SYNCMODE == 1 ]]; then
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=20000;MCHTracking.maxTrackingDuration=10;"
   fi
   [[ -n ${CUT_RANDOM_FRACTION_ITS:-} ]] && ITS_CONFIG_KEY+="fastMultConfig.cutRandomFraction=$CUT_RANDOM_FRACTION_ITS;"
-  ITS_CONFIG_KEY+="ITSCATrackerParam.trackletsPerClusterLimit=${CUT_TRACKLETSPERCLUSTER_MAX_ITS:--1};ITSCATrackerParam.cellsPerClusterLimit=${CUT_CELLSPERCLUSTER_MAX_ITS:--1};"
   if has_detector_reco ITS && [[ $RUNTYPE != "COSMICS" && x"${MFT_DISABLE_ITS_IRFRAMES_SELECTION:-}" != "x1" ]]; then
     MFT_CONFIG_KEY+="MFTTracking.irFramesOnly=1;"
   fi
@@ -156,7 +161,6 @@ else
     ITS_CONFIG_KEY+="ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;"
   elif [[ $BEAMTYPE == "PbPb" ]]; then
     ITS_CONFIG_KEY+="ITSVertexerParam.lowMultBeamDistCut=0;"
-    ! has_detectors_gpu TPC ITS && ITS_CONFIG_KEY+="ITSCATrackerParam.nROFsPerIterations=12;"
   fi
 
   if [[ $IS_SIMULATED_DATA == 0 && $CTFINPUT == 1 ]]; then # Enable fixes to the MCH readout mapping for async processing of real data
@@ -463,7 +467,7 @@ if [[ -n $INPUT_DETECTOR_LIST ]]; then
     if [[ $NTIMEFRAMES == -1 ]]; then NTIMEFRAMES_CMD= ; else NTIMEFRAMES_CMD="--max-tf $NTIMEFRAMES"; fi
     CTF_EMC_SUBSPEC=
     ( workflow_has_parameter AOD || [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-emcal-cell-writer-workflow ) && has_detector EMC && CTF_EMC_SUBSPEC="--emcal-decoded-subspec 1"
-    add_W o2-ctf-reader-workflow "$RANS_OPT --delay $TFDELAY --loop $TFLOOP $NTIMEFRAMES_CMD --ctf-input ${CTFName} ${INPUT_FILE_COPY_CMD+--copy-cmd} ${INPUT_FILE_COPY_CMD:-} --onlyDet $INPUT_DETECTOR_LIST $CTF_EMC_SUBSPEC ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} ${TIMEFRAME_SHM_LIMIT:-} --pipeline $(get_N tpc-entropy-decoder TPC REST 1 TPCENTDEC)"
+    add_W o2-ctf-reader-workflow "$RANS_OPT --delay $TFDELAY --loop $TFLOOP $NTIMEFRAMES_CMD $ITS_STAGGERED $MFT_STAGGERED --ctf-input ${CTFName} ${INPUT_FILE_COPY_CMD+--copy-cmd} ${INPUT_FILE_COPY_CMD:-} --onlyDet $INPUT_DETECTOR_LIST $CTF_EMC_SUBSPEC ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} ${TIMEFRAME_SHM_LIMIT:-} --pipeline $(get_N tpc-entropy-decoder TPC REST 1 TPCENTDEC)"
   elif [[ $RAWTFINPUT == 1 ]]; then
     TFName=`ls -t $RAWINPUTDIR/o2_*.tf 2> /dev/null | head -n1`
     [[ -z $TFName && $WORKFLOWMODE == "print" ]] && TFName='$TFName'
@@ -556,8 +560,8 @@ if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
     add_W o2-tpc-raw-to-digits-workflow "--input-spec \"\" --remove-duplicates $RAWTODIGITOPTIONS --pipeline $(get_N tpc-raw-to-digits-0 TPC RAW 1 TPCRAWDEC)"
     add_W o2-tpc-reco-workflow "--input-type digitizer --output-type zsraw,disable-writer --pipeline $(get_N tpc-zsEncoder TPC RAW 1 TPCRAWDEC)" "GPU_rec_tpc.zsThreshold=0"
   fi
-  has_detector ITS && ! has_detector_from_global_reader ITS && add_W o2-itsmft-stf-decoder-workflow "--nthreads ${NITSDECTHREADS} --raw-data-dumps $ALPIDE_ERR_DUMPS --pipeline $(get_N its-stf-decoder ITS RAW 1 ITSRAWDEC)" "$ITS_STF_DEC_CONFIG;$ITSMFT_STROBES;VerbosityConfig.rawParserSeverity=warn;"
-  has_detector MFT && ! has_detector_from_global_reader MFT && add_W o2-itsmft-stf-decoder-workflow "--nthreads ${NMFTDECTHREADS} --raw-data-dumps $ALPIDE_ERR_DUMPS --pipeline $(get_N mft-stf-decoder MFT RAW 1 MFTRAWDEC) --runmft true" "$MFT_STF_DEC_CONFIG;$ITSMFT_STROBES;VerbosityConfig.rawParserSeverity=warn;"
+  has_detector ITS && ! has_detector_from_global_reader ITS && add_W o2-itsmft-stf-decoder-workflow "--nthreads ${NITSDECTHREADS} --raw-data-dumps $ALPIDE_ERR_DUMPS $ITS_STAGGERED --pipeline $(get_N its-stf-decoder ITS RAW 1 ITSRAWDEC)" "$ITS_STF_DEC_CONFIG;$ITSMFT_STROBES;VerbosityConfig.rawParserSeverity=warn;"
+  has_detector MFT && ! has_detector_from_global_reader MFT && add_W o2-itsmft-stf-decoder-workflow "--nthreads ${NMFTDECTHREADS} --raw-data-dumps $ALPIDE_ERR_DUMPS $MFT_STAGGERED --pipeline $(get_N mft-stf-decoder MFT RAW 1 MFTRAWDEC) --runmft true" "$MFT_STF_DEC_CONFIG;$ITSMFT_STROBES;VerbosityConfig.rawParserSeverity=warn;"
   has_detector FT0 && ! has_detector_from_global_reader FT0 && ! has_detector_flp_processing FT0 && add_W o2-ft0-flp-dpl-workflow "$DISABLE_ROOT_OUTPUT --pipeline $(get_N ft0-datareader-dpl FT0 RAW 1)"
   has_detector FV0 && ! has_detector_from_global_reader FV0 && ! has_detector_flp_processing FV0 && add_W o2-fv0-flp-dpl-workflow "$DISABLE_ROOT_OUTPUT --pipeline $(get_N fv0-datareader-dpl FV0 RAW 1)"
   has_detector MID && ! has_detector_from_global_reader MID && add_W o2-mid-raw-to-digits-workflow "$MIDDEC_CONFIG --pipeline $(get_N MIDRawDecoder MID RAW 1),$(get_N MIDDecodedDataAggregator MID RAW 1)"
@@ -581,13 +585,13 @@ has_detector_gpu ITS && GPU_OUTPUT+=",its-tracks"
 
 # ---------------------------------------------------------------------------------------------------------------------
 # Common reconstruction workflows
-(has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--trackerCA $ITS_CONFIG $DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
-[[ ${DISABLE_DIGIT_CLUSTER_INPUT:-} =~ "--digits-from-upstream" ]]  && has_detector_gpu ITS && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--disable-tracking ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_MC $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
-(has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $TPC_CORR_OPT --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;$TPC_CORR_KEY"
+(has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--trackerCA $ITS_CONFIG $ITS_STAGGERED $DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
+[[ ${DISABLE_DIGIT_CLUSTER_INPUT:-} =~ "--digits-from-upstream" ]]  && has_detector_gpu ITS && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--disable-tracking ${DISABLE_DIGIT_CLUSTER_INPUT:-} $ITS_STAGGERED $DISABLE_MC $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
+(has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $TPC_CORR_OPT $ITS_STAGGERED --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;$TPC_CORR_KEY"
 (has_detector_reco TOF || has_detector_ctf TOF) && ! has_detector_from_global_reader TOF && add_W o2-tof-reco-workflow "$TOF_CONFIG --input-type $TOF_INPUT --output-type $TOF_OUTPUT $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N tof-compressed-decoder TOF RAW 1),$(get_N TOFClusterer TOF REST 1)"
 has_detector_reco FT0 && ! has_detector_from_global_reader FT0 && add_W o2-ft0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N ft0-reconstructor FT0 REST 1)"
 has_detector_reco TRD && ! has_detector_from_global_reader TRD && add_W o2-trd-tracklet-transformer "--disable-irframe-reader $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_FILTER_CONFIG --pipeline $(get_N TRDTRACKLETTRANSFORMER TRD REST 1 TRDTRKTRANS)"
-has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $SEND_ITSTPC_DTGL  $TPC_CORR_OPT --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
+has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $ITS_STAGGERED $SEND_ITSTPC_DTGL  $TPC_CORR_OPT --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
 has_detector_reco TRD && [[ -n "$TRD_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-global-tracking "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_CONFIG $TRD_FILTER_CONFIG $TPC_CORR_OPT --track-sources $TRD_SOURCES --pipeline $(get_N trd-globaltracking_TPC_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_CTP_ TRD REST 1 TRDTRK)" "$TRD_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
 has_detector_reco TOF && [[ -n "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TPC_CORR_OPT ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY;$INTERACTION_TAG_CONFIG_KEY"
 has_detectors TPC && [[ -z "$DISABLE_ROOT_OUTPUT" && "${SKIP_TPC_CLUSTERSTRACKS_OUTPUT:-}" != 1 ]] && ! has_detector_from_global_reader TPC && add_W o2-tpc-reco-workflow "--input-type pass-through --output-type clusters,tpc-triggers,tracks,send-clusters-per-sector $DISABLE_MC"
@@ -596,7 +600,7 @@ has_detectors TPC && [[ -z "$DISABLE_ROOT_OUTPUT" && "${SKIP_TPC_CLUSTERSTRACKS_
 # Reconstruction workflows normally active only in async mode ($LIST_OF_ASYNC_RECO_STEPS), but can be forced via $WORKFLOW_EXTRA_PROCESSING_STEPS
 has_detector MID && ! has_detector_from_global_reader MID && has_processing_step MID_RECO && add_W o2-mid-reco-workflow "$DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N MIDClusterizer MID REST 1),$(get_N MIDTracker MID REST 1)"
 has_detector MCH && ! has_detector_from_global_reader MCH && has_processing_step MCH_RECO && add_W o2-mch-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N mch-track-finder MCH REST 1 MCHTRK),$(get_N mch-cluster-finder MCH REST 1 MCHCL),$(get_N mch-cluster-transformer MCH REST 1)" "$MCH_CONFIG_KEY"
-has_detector MFT && ! has_detector_from_global_reader MFT && has_processing_step MFT_RECO && add_W o2-mft-reco-workflow "$DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT $MFT_CONFIG --pipeline $(get_N mft-tracker MFT REST 1 MFTTRK)" "$MFT_CONFIG_KEY;$ITSMFT_STROBES"
+has_detector MFT && ! has_detector_from_global_reader MFT && has_processing_step MFT_RECO && add_W o2-mft-reco-workflow "$DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT $MFT_CONFIG $MFT_STAGGERED --pipeline $(get_N mft-tracker MFT REST 1 MFTTRK)" "$MFT_CONFIG_KEY;$ITSMFT_STROBES"
 has_detector FDD && ! has_detector_from_global_reader FDD && has_processing_step FDD_RECO && add_W o2-fdd-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC"
 has_detector FV0 && ! has_detector_from_global_reader FV0 && has_processing_step FV0_RECO && add_W o2-fv0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC"
 has_detector ZDC && ! has_detector_from_global_reader ZDC && has_processing_step ZDC_RECO && add_W o2-zdc-digits-reco "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC"
@@ -658,7 +662,7 @@ fi
 # Entropy encoding / ctf creation workflows - disabled in async mode
 if has_processing_step ENTROPY_ENCODER && [[ -n "$WORKFLOW_DETECTORS_CTF" ]] && [[ $WORKFLOW_DETECTORS_CTF != "NONE" ]]; then
   # Entropy encoder workflows
-  has_detector_ctf MFT && add_W o2-itsmft-entropy-encoder-workflow "$RANS_OPT --mem-factor ${MFT_ENC_MEMFACT:-1.5} --runmft true --pipeline $(get_N mft-entropy-encoder MFT CTF 1)"
+  has_detector_ctf MFT && add_W o2-itsmft-entropy-encoder-workflow "$RANS_OPT --mem-factor ${MFT_ENC_MEMFACT:-1.5} $MFT_STAGGERED --runmft true --pipeline $(get_N mft-entropy-encoder MFT CTF 1)"
   has_detector_ctf FT0 && add_W o2-ft0-entropy-encoder-workflow "$RANS_OPT --mem-factor ${FT0_ENC_MEMFACT:-1.5} --pipeline $(get_N ft0-entropy-encoder FT0 CTF 1)"
   has_detector_ctf FV0 && add_W o2-fv0-entropy-encoder-workflow "$RANS_OPT --mem-factor ${FV0_ENC_MEMFACT:-1.5} --pipeline $(get_N fv0-entropy-encoder FV0 CTF 1)"
   has_detector_ctf MID && add_W o2-mid-entropy-encoder-workflow "$RANS_OPT --mem-factor ${MID_ENC_MEMFACT:-1.5} --pipeline $(get_N mid-entropy-encoder MID CTF 1)"
@@ -670,7 +674,7 @@ if has_processing_step ENTROPY_ENCODER && [[ -n "$WORKFLOW_DETECTORS_CTF" ]] &&
   has_detector_ctf FDD && add_W o2-fdd-entropy-encoder-workflow "$RANS_OPT --mem-factor ${FDD_ENC_MEMFACT:-1.5} --pipeline $(get_N fdd-entropy-encoder FDD CTF 1)"
   has_detector_ctf HMP && add_W o2-hmpid-entropy-encoder-workflow "$RANS_OPT --mem-factor ${HMP_ENC_MEMFACT:-1.5} --pipeline $(get_N hmpid-entropy-encoder HMP CTF 1)"
   has_detector_ctf TOF && add_W o2-tof-entropy-encoder-workflow "$RANS_OPT --mem-factor ${TOF_ENC_MEMFACT:-1.5} --pipeline $(get_N tof-entropy-encoder TOF CTF 1)"
-  has_detector_ctf ITS && add_W o2-itsmft-entropy-encoder-workflow "$RANS_OPT --mem-factor ${ITS_ENC_MEMFACT:-1.5} --pipeline $(get_N its-entropy-encoder ITS CTF 1)"
+  has_detector_ctf ITS && add_W o2-itsmft-entropy-encoder-workflow "$RANS_OPT --mem-factor ${ITS_ENC_MEMFACT:-1.5} $ITS_STAGGERED --pipeline $(get_N its-entropy-encoder ITS CTF 1)"
   has_detector_ctf TRD && add_W o2-trd-entropy-encoder-workflow "$RANS_OPT --mem-factor ${TRD_ENC_MEMFACT:-1.5} --pipeline $(get_N trd-entropy-encoder TRD CTF 1 TRDENT)"
   has_detector_ctf TPC && add_W o2-tpc-reco-workflow " $RANS_OPT --mem-factor ${TPC_ENC_MEMFACT:-1.} --input-type compressed-clusters-flat-for-encode --output-type encoded-clusters,disable-writer --pipeline $(get_N tpc-entropy-encoder TPC CTF 1 TPCENT)"
   has_detector_ctf CTP && add_W o2-ctp-entropy-encoder-workflow "$RANS_OPT --mem-factor ${CTP_ENC_MEMFACT:-1.5} --pipeline $(get_N its-entropy-encoder CTP CTF 1)"
@@ -690,7 +694,7 @@ if has_processing_step ENTROPY_ENCODER && [[ -n "$WORKFLOW_DETECTORS_CTF" ]] &&
   CONFIG_CTF="--output-dir \"$CTF_DIR\" $CTF_CONFIG --output-type $CTF_OUTPUT_TYPE --min-file-size ${CTF_MINSIZE} --max-ctf-per-file ${CTF_MAX_PER_FILE} --onlyDet ${WORKFLOW_DETECTORS_CTF/TST/} --meta-output-dir $EPN2EOS_METAFILES_DIR"
   if [[ $CREATECTFDICT == 1 ]] && [[ $EXTINPUT == 1 ]]; then CONFIG_CTF+=" --save-dict-after $SAVE_CTFDICT_NTIMEFRAMES"; fi
   [[ $EPNSYNCMODE == 1 ]] && CONFIG_CTF+=" --require-free-disk 53687091200 --wait-for-free-disk $CTF_FREE_DISK_WAIT --max-wait-for-free-disk $CTF_MAX_FREE_DISK_WAIT"
-  add_W o2-ctf-writer-workflow "$CONFIG_CTF"
+  add_W o2-ctf-writer-workflow "$CONFIG_CTF $ITS_STAGGERED $MFT_STAGGERED"
 fi
 
 # ---------------------------------------------------------------------------------------------------------------------
diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 8e252c5a8378f..46739e76f103b 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -321,10 +321,6 @@ for STAGE in $STAGES; do
     : ${CUT_MULT_MIN_ITS:=-1}
     : ${CUT_MULT_MAX_ITS:=-1}
     : ${CUT_MULT_VTX_ITS:=-1}
-    : ${CUT_TRACKLETSPERCLUSTER_MAX_ITS:=100}
-    : ${CUT_CELLSPERCLUSTER_MAX_ITS:=100}
-    export CUT_TRACKLETSPERCLUSTER_MAX_ITS
-    export CUT_CELLSPERCLUSTER_MAX_ITS
     export CUT_RANDOM_FRACTION_ITS
     export CUT_MULT_MIN_ITS
     export CUT_MULT_MAX_ITS

From 14ff7dbba9255ac1b852c4c629364a4f24759768 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tuba=20G=C3=BCndem?=
 <48834043+tubagundem@users.noreply.github.com>
Date: Mon, 13 Apr 2026 15:02:33 +0200
Subject: [PATCH 1535/1764] TPC: Processing of common mode values in O2
 (#15137)

* TPC: Processing of common mode values in O2

* Added CMVContainer.cxx, fixed missing links and includes

* Fix formatting

* Removed unused includes, directly write the TTree object to CCDB without TMem file, small fixes

* Changed the decoding and encoding of CMVs, removed grouping per side

* Update the dataformat of CMV

* Updated the CMVContainer, corrected the timestamp range for CCDB

* Fix formatting

* Removed factorize workflow, updated the distribute workflow accordingly

* Fix formatting

* Extend error tracking in CMVToVectorSpec.cxx

* Replace CMVPerInterval with per TF TTree accumulation and raw uint16_t storage, fix CCDB timestamp for partial intervals, fix TMemFile padding

* Added delta+zigzag+varint compression, added drawCMV.C macro for visualization

* Added small value zeroing, added `--use-compression` and `--cmv-zero-threshold` flags to TPCDistributeCMVSpec, updated drawCMV.C macro to auto detect branch format (compressed or not)

* Added sparse and HUffman encoding to the CMVContainer, updatet the drawCMV.C macro and TPCDistributeCMVSpec.h accordingly

* Added CMVPerTFCombined to CMVContainer to combine sparse encoding with varint/Huffman compression, updated drawing macro and workflow options accordingly

* Added gaussian dynamic precision

* Refactored CMVContainer, unified CMV compression in a flag based container

* Added CMV workflow documentation to README and fixed CMV packet size mismatch handling
---
 .../TPC/include/DataFormatsTPC/CMV.h          | 122 +++
 Detectors/TPC/base/include/TPCBase/RDHUtils.h |   3 +-
 Detectors/TPC/calibration/CMakeLists.txt      |   8 +-
 .../include/TPCCalibration/CMVContainer.h     | 141 ++++
 Detectors/TPC/calibration/macro/drawCMV.C     | 160 ++++
 .../TPC/calibration/src/CMVContainer.cxx      | 729 ++++++++++++++++++
 .../calibration/src/TPCCalibrationLinkDef.h   |   4 +
 Detectors/TPC/workflow/CMakeLists.txt         |  18 +-
 Detectors/TPC/workflow/README.md              | 188 +++++
 .../include/TPCWorkflow/CMVToVectorSpec.h     |  30 +
 .../TPCWorkflow/TPCDistributeCMVSpec.h        | 621 +++++++++++++++
 .../include/TPCWorkflow/TPCFLPCMVSpec.h       | 172 +++++
 .../TPC/workflow/src/CMVToVectorSpec.cxx      | 434 +++++++++++
 .../TPC/workflow/src/tpc-cmv-to-vector.cxx    |  71 ++
 .../TPC/workflow/src/tpc-distribute-cmv.cxx   |  84 ++
 Detectors/TPC/workflow/src/tpc-flp-cmv.cxx    |  72 ++
 16 files changed, 2854 insertions(+), 3 deletions(-)
 create mode 100644 DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h
 create mode 100644 Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h
 create mode 100644 Detectors/TPC/calibration/macro/drawCMV.C
 create mode 100644 Detectors/TPC/calibration/src/CMVContainer.cxx
 create mode 100644 Detectors/TPC/workflow/include/TPCWorkflow/CMVToVectorSpec.h
 create mode 100644 Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
 create mode 100644 Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
 create mode 100644 Detectors/TPC/workflow/src/CMVToVectorSpec.cxx
 create mode 100644 Detectors/TPC/workflow/src/tpc-cmv-to-vector.cxx
 create mode 100644 Detectors/TPC/workflow/src/tpc-distribute-cmv.cxx
 create mode 100644 Detectors/TPC/workflow/src/tpc-flp-cmv.cxx

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h
new file mode 100644
index 0000000000000..109eff2654466
--- /dev/null
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h
@@ -0,0 +1,122 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   CMV.h
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  Common mode values data format definition
+
+/// The data is sent by the CRU as 256+16 bit words. The CMV data layout is as follows:
+/// - 256-bit Header: [version:8][packetID:8][errorCode:8][magicWord:8][heartbeatOrbit:32][heartbeatBC:16][padding:176]
+/// - 16-bit CMV value: [sign:1][I8F7:15] where bit 15 is the sign (1=positive, 0=negative) and the lower 15 bits are a fixed point I8F7 value (8 integer bits, 7 fractional bits)
+///   Float conversion: sign ? (value & 0x7FFF) / 128.0 : -(value & 0x7FFF) / 128.0
+
+#ifndef ALICEO2_DATAFORMATSTPC_CMV_H
+#define ALICEO2_DATAFORMATSTPC_CMV_H
+
+#include <cstdint>
+#include <cmath>
+
+namespace o2::tpc::cmv
+{
+
+static constexpr uint32_t NTimeBinsPerPacket = 3564;                                 ///< number of time bins (covering 8 heartbeats)
+static constexpr uint32_t NPacketsPerTFPerCRU = 4;                                   ///< 4 packets per timeframe
+static constexpr uint32_t NTimeBinsPerTF = NTimeBinsPerPacket * NPacketsPerTFPerCRU; ///< maximum number of timebins per timeframe (14256)
+
+/// Data padding: NTimeBinsPerPacket * sizeof(Data) = 3564 * 2 = 7128 bytes
+static constexpr uint32_t DataSizeBytes = NTimeBinsPerPacket * sizeof(uint16_t); ///< 7128 bytes
+static constexpr uint32_t DataPaddingBytes = (32 - (DataSizeBytes % 32)) % 32;   ///< 8 bytes
+
+/// Header definition of the CMVs
+struct Header {
+  static constexpr uint8_t MagicWord = 0xDC;
+  union {
+    uint64_t word0 = 0; ///< bits 0 - 63
+    struct {
+      uint8_t version : 8;          ///< version
+      uint8_t packetID : 8;         ///< packet id
+      uint8_t errorCode : 8;        ///< errors
+      uint8_t magicWord : 8;        ///< magic word
+      uint32_t heartbeatOrbit : 32; ///< first heart beat timing of the package
+    };
+  };
+  union {
+    uint64_t word1 = 0; ///< bits 64 - 127
+    struct {
+      uint16_t heartbeatBC : 16; ///< first BC id of the package
+      uint16_t unused1 : 16;     ///< reserved
+      uint32_t unused2 : 32;     ///< reserved
+    };
+  };
+  union {
+    uint64_t word3 = 0; ///< bits 128 - 191
+    struct {
+      uint64_t unused3 : 64; ///< reserved
+    };
+  };
+  union {
+    uint64_t word4 = 0; ///< bits 192 - 255
+    struct {
+      uint64_t unused4 : 64; ///< reserved
+    };
+  };
+};
+
+/// CMV single data container
+struct Data {
+  uint16_t cmv{0}; ///< 16-bit signed fixed point value: bit 15 = sign (1=positive, 0=negative), bits 14-0 = I8F7 magnitude
+
+  uint16_t getCMV() const { return cmv; }      ///< raw 16-bit integer representation
+  void setCMV(uint16_t value) { cmv = value; } ///< set raw 16-bit integer representation
+
+  // Decode to float: sign-magnitude with 7 fractional bits, range ±255.992
+  float getCMVFloat() const
+  {
+    const bool positive = (cmv >> 15) & 1;          // bit 15: sign (1=positive, 0=negative)
+    const float magnitude = (cmv & 0x7FFF) / 128.f; // lower 15 bits, shift right by 7 (divide by 2^7)
+    return positive ? magnitude : -magnitude;
+  }
+
+  // Encode from float: clamps magnitude to 15 bits, range ±255.992
+  void setCMVFloat(float value)
+  {
+    const bool positive = (value >= 0.f);
+    const uint16_t magnitude = static_cast<uint16_t>(std::abs(value) * 128.f + 0.5f) & 0x7FFF;
+    cmv = (positive ? 0x8000 : 0x0000) | magnitude;
+  }
+};
+
+/// CMV full data container: one packet carries NTimeBinsPerPacket CMV values followed by padding
+/// Layout: Header (32 bytes) + Data[NTimeBinsPerPacket] (7128 bytes) + padding (8 bytes) = 7168 bytes total (224 * 32 = 7168)
+/// The padding bytes at the end of the data array are rubbish/unused and must not be interpreted as CMV values
+struct Container {
+  Header header;                       ///< CMV data header
+  Data data[NTimeBinsPerPacket];       ///< data values
+  uint8_t padding[DataPaddingBytes]{}; ///< trailing padding to align data to 32-byte boundary
+
+  // Header and data accessors
+  const Header& getHeader() const { return header; }
+  Header& getHeader() { return header; }
+
+  const Data* getData() const { return data; }
+  Data* getData() { return data; }
+
+  // Per timebin CMV accessors
+  uint16_t getCMV(uint32_t timeBin) const { return data[timeBin].getCMV(); }
+  void setCMV(uint32_t timeBin, uint16_t value) { data[timeBin].setCMV(value); }
+
+  float getCMVFloat(uint32_t timeBin) const { return data[timeBin].getCMVFloat(); }
+  void setCMVFloat(uint32_t timeBin, float value) { data[timeBin].setCMVFloat(value); }
+};
+
+} // namespace o2::tpc::cmv
+
+#endif
\ No newline at end of file
diff --git a/Detectors/TPC/base/include/TPCBase/RDHUtils.h b/Detectors/TPC/base/include/TPCBase/RDHUtils.h
index adfd94cf6b703..71b5d16b85702 100644
--- a/Detectors/TPC/base/include/TPCBase/RDHUtils.h
+++ b/Detectors/TPC/base/include/TPCBase/RDHUtils.h
@@ -13,7 +13,7 @@
 #define AliceO2_TPC_RDHUtils_H
 
 #include "DetectorsRaw/RDHUtils.h"
-//#include "Headers/RAWDataHeader.h"
+// #include "Headers/RAWDataHeader.h"
 
 namespace o2
 {
@@ -28,6 +28,7 @@ static constexpr FEEIDType UserLogicLinkID = 15; ///< virtual link ID for ZS dat
 static constexpr FEEIDType IDCLinkID = 20;       ///< Identifier for integrated digital currents
 static constexpr FEEIDType ILBZSLinkID = 21;     ///< Identifier for improved link-based ZS
 static constexpr FEEIDType DLBZSLinkID = 22;     ///< Identifier for dense link-based ZS
+static constexpr FEEIDType CMVLinkID = 23;       ///< Identifier for common mode values
 static constexpr FEEIDType SACLinkID = 25;       ///< Identifier for sampled analog currents
 
 /// compose feeid from cru, endpoint and link
diff --git a/Detectors/TPC/calibration/CMakeLists.txt b/Detectors/TPC/calibration/CMakeLists.txt
index 27f7f0200bb92..a1068b928780d 100644
--- a/Detectors/TPC/calibration/CMakeLists.txt
+++ b/Detectors/TPC/calibration/CMakeLists.txt
@@ -58,6 +58,7 @@ o2_add_library(TPCCalibration
                        src/DigitAdd.cxx
                        src/CorrectdEdxDistortions.cxx
                        src/PressureTemperatureHelper.cxx
+                       src/CMVContainer.cxx
                PUBLIC_LINK_LIBRARIES O2::DataFormatsTPC O2::TPCBaseRecSim
                                      O2::TPCReconstruction ROOT::Minuit
                                      Microsoft.GSL::GSL
@@ -115,7 +116,8 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/TPCMShapeCorrection.h
                                   include/TPCCalibration/DigitAdd.h
                                   include/TPCCalibration/CorrectdEdxDistortions.h
-                                  include/TPCCalibration/PressureTemperatureHelper.h)
+                                  include/TPCCalibration/PressureTemperatureHelper.h
+                                  include/TPCCalibration/CMVContainer.h)
 
 o2_add_test_root_macro(macro/comparePedestalsAndNoise.C
                        PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
@@ -153,6 +155,10 @@ o2_add_test_root_macro(macro/prepareITFiles.C
                        COMPILE_ONLY
                        PUBLIC_LINK_LIBRARIES O2::TPCCalibration
                        LABELS tpc)
+o2_add_test_root_macro(macro/drawCMV.C
+                       COMPILE_ONLY
+                       PUBLIC_LINK_LIBRARIES O2::TPCCalibration O2::TPCBase
+                       LABELS tpc)
 
 o2_add_test(IDCFourierTransform
             COMPONENT_NAME calibration
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h b/Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h
new file mode 100644
index 0000000000000..f1904c3db8f8d
--- /dev/null
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h
@@ -0,0 +1,141 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   CMVContainer.h
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  Structs for storing CMVs to the CCDB
+
+#ifndef ALICEO2_TPC_CMVCONTAINER_H_
+#define ALICEO2_TPC_CMVCONTAINER_H_
+
+#include <string>
+#include <memory>
+#include <vector>
+#include <cstdint>
+
+#include "TTree.h"
+#include "TPCBase/CRU.h"
+#include "DataFormatsTPC/CMV.h"
+
+namespace o2::tpc
+{
+
+struct CMVPerTF;           // forward declaration
+struct CMVPerTFCompressed; // forward declaration
+
+/// Bitmask flags describing which encoding stages are applied in CMVPerTFCompressed
+struct CMVEncoding {
+  static constexpr uint8_t kNone = 0x00;    ///< No compression — raw uint16 values stored flat
+  static constexpr uint8_t kSparse = 0x01;  ///< Non-zero positions stored sparsely (varint-encoded deltas)
+  static constexpr uint8_t kDelta = 0x02;   ///< Delta coding between consecutive values (dense only)
+  static constexpr uint8_t kZigzag = 0x04;  ///< Zigzag encoding of deltas or signed values
+  static constexpr uint8_t kVarint = 0x08;  ///< Varint compression of the value stream
+  static constexpr uint8_t kHuffman = 0x10; ///< Canonical Huffman compression of the value stream
+};
+
+/// Single compressed representation for one TF across all CRUs, stored in a TTree
+/// mFlags is a bitmask of CMVEncoding values that fully describes the encoding pipeline
+/// mData holds the encoded payload whose binary layout depends on mFlags:
+///
+///   Dense path (!kSparse):
+///     kZigzag absent → N × uint16_t LE  (raw values, CRU-major order)
+///     kZigzag + kVarint  → N × varint(zigzag(delta(signed(raw))))
+///     kZigzag + kHuffman → [Huffman table] + [bitstream] of zigzag(delta(signed(raw)))
+///
+///   Sparse path (kSparse):
+///     4 bytes LE uint32_t : posStreamSize
+///     posStream: for each CRU: varint(N), N × varint(tb_delta)
+///     valStream (one entry per non-zero):
+///       default          → uint16_t LE raw value
+///       kZigzag + kVarint  → varint(zigzag(signed(raw)))
+///       kZigzag + kHuffman → [Huffman table] + [bitstream] of zigzag(signed(raw))
+struct CMVPerTFCompressed {
+  uint32_t firstOrbit{0}; ///< First orbit of this TF
+  uint16_t firstBC{0};    ///< First bunch crossing of this TF
+  uint8_t mFlags{0};      ///< Bitmask of CMVEncoding values
+
+  std::vector<uint8_t> mData; ///< Encoded payload
+
+  /// Restore a CMVPerTF from this compressed object into *cmv (must not be null)
+  void decompress(CMVPerTF* cmv) const;
+
+  /// Serialise into a TTree; each Fill() call appends one entry (one TF)
+  std::unique_ptr<TTree> toTTree() const;
+
+ private:
+  /// Decode the sparse position stream; advances ptr past the position block
+  /// Returns (cru, timeBin) pairs for every non-zero entry, in CRU-major order
+  static std::vector<std::pair<int, uint32_t>> decodeSparsePositions(const uint8_t*& ptr, const uint8_t* end);
+
+  /// Decode the value stream into raw uint32_t symbols
+  /// Dispatches to Huffman, varint, or raw uint16 based on flags
+  static std::vector<uint32_t> decodeValueStream(const uint8_t*& ptr, const uint8_t* end, uint32_t N, uint8_t flags);
+
+  /// Apply inverse zigzag and scatter decoded values into the sparse positions of *cmv
+  static void decodeSparseValues(const std::vector<uint32_t>& symbols,
+                                 const std::vector<std::pair<int, uint32_t>>& positions,
+                                 uint8_t flags, CMVPerTF* cmv);
+
+  /// Apply inverse zigzag and inverse delta, then fill the full dense CMV array in *cmv
+  static void decodeDenseValues(const std::vector<uint32_t>& symbols, uint8_t flags, CMVPerTF* cmv);
+
+ public:
+  ClassDefNV(CMVPerTFCompressed, 1)
+};
+
+/// CMV data for one TF across all CRUs
+/// Raw 16-bit CMV values are stored in a flat C array indexed as [cru * NTimeBinsPerTF + timeBin]
+struct CMVPerTF {
+  uint32_t firstOrbit{0}; ///< First orbit of this TF, from heartbeatOrbit of the first CMV packet
+  uint16_t firstBC{0};    ///< First bunch crossing of this TF, from heartbeatBC of the first CMV packet
+
+  // Raw 16-bit CMV values, flat array indexed as [cru * NTimeBinsPerTF + timeBin]
+  uint16_t mDataPerTF[CRU::MaxCRU * cmv::NTimeBinsPerTF]{};
+
+  /// Return the raw 16-bit CMV value for a given CRU and timebin within this TF
+  uint16_t getCMV(const int cru, const int timeBin) const;
+
+  /// Return the float CMV value for a given CRU and timebin within this TF
+  float getCMVFloat(const int cru, const int timeBin) const;
+
+  /// Zero out raw CMV values whose float magnitude is below threshold
+  void zeroSmallValues(float threshold = 1.0f);
+
+  /// Round values to the nearest integer ADC for all values whose rounded magnitude is <= threshold
+  void roundToIntegers(uint16_t threshold);
+
+  /// Quantise |v| with a Gaussian-CDF recovery profile:
+  /// Coarse decimal-style precision below and around mean, then a smooth return to the full native I8F7 precision as the magnitude increases with width sigma
+  void trimGaussianPrecision(float mean, float sigma);
+
+  /// Compress this object into a CMVPerTFCompressed using the encoding pipeline described by flags
+  /// Quantisation (trimGaussianPrecision / roundToIntegers / zeroSmallValues) should be applied to this object before calling compress(); it is not part of the flags pipeline
+  CMVPerTFCompressed compress(uint8_t flags) const;
+
+  /// Serialise into a TTree; each Fill() call appends one entry (one TF)
+  std::unique_ptr<TTree> toTTree() const;
+
+  /// Write the TTree to a ROOT file
+  static void writeToFile(const std::string& filename, const std::unique_ptr<TTree>& tree);
+
+ private:
+  static int32_t cmvToSigned(uint16_t raw);                                                              ///< Sign-magnitude uint16_t → signed integer
+  static uint16_t quantizeBelowThreshold(uint16_t raw, float quantizationMean, float quantizationSigma); ///< Quantise sub-threshold values with a Gaussian-shaped recovery to full precision
+  static uint32_t zigzagEncode(int32_t value);                                                           ///< Zigzag encode
+  static void encodeVarintInto(uint32_t value, std::vector<uint8_t>& out);                               ///< Varint encode
+
+ public:
+  ClassDefNV(CMVPerTF, 1)
+};
+
+} // namespace o2::tpc
+
+#endif // ALICEO2_TPC_CMVCONTAINER_H_
diff --git a/Detectors/TPC/calibration/macro/drawCMV.C b/Detectors/TPC/calibration/macro/drawCMV.C
new file mode 100644
index 0000000000000..8a89157b75721
--- /dev/null
+++ b/Detectors/TPC/calibration/macro/drawCMV.C
@@ -0,0 +1,160 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <string>
+#include <vector>
+#include <string_view>
+#include <fmt/format.h>
+
+#include "TFile.h"
+#include "TParameter.h"
+#include "TTree.h"
+#include "TH1F.h"
+#include "TH2F.h"
+#include "TCanvas.h"
+
+#include "TPCCalibration/CMVContainer.h"
+#include "TPCBase/Utils.h"
+#endif
+
+using namespace o2::tpc;
+
+/// Draw CMV (Common Mode Values) vs timebin from a CCDB TTree file
+/// \param filename  input ROOT file containing the ccdb_object TTree
+/// \param outDir    output directory for saved plots; nothing is saved if empty
+/// \return          array of canvases
+TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
+{
+  TObjArray* arrCanvases = new TObjArray;
+  arrCanvases->SetName("CMV");
+
+  // open file
+  TFile f(filename.data(), "READ");
+  if (f.IsZombie()) {
+    fmt::print("ERROR: cannot open '{}'\n", filename);
+    return arrCanvases;
+  }
+  fmt::print("Opened file: {}\n", filename);
+
+  // get TTree
+  TTree* tree = nullptr;
+  f.GetObject("ccdb_object", tree);
+  if (!tree) {
+    fmt::print("ERROR: TTree 'ccdb_object' not found\n");
+    return arrCanvases;
+  }
+  fmt::print("Tree 'ccdb_object' found, entries: {}\n", tree->GetEntries());
+
+  // read metadata
+  long firstTF = -1, lastTF = -1;
+  if (auto* userInfo = tree->GetUserInfo()) {
+    for (int i = 0; i < userInfo->GetSize(); ++i) {
+      if (auto* p = dynamic_cast<TParameter<long>*>(userInfo->At(i))) {
+        if (std::string(p->GetName()) == "firstTF")
+          firstTF = p->GetVal();
+        if (std::string(p->GetName()) == "lastTF")
+          lastTF = p->GetVal();
+      }
+    }
+  }
+  fmt::print("firstTF: {}, lastTF: {}\n", firstTF, lastTF);
+
+  const int nEntries = tree->GetEntries();
+  if (nEntries == 0) {
+    fmt::print("ERROR: no entries in tree\n");
+    return arrCanvases;
+  }
+
+  constexpr int nCRUs = CRU::MaxCRU;
+  constexpr int nTimeBins = cmv::NTimeBinsPerTF;
+
+  TH2F* h2d = new TH2F("hCMVvsTimeBin", ";Timebin (200 ns);Common Mode Values (ADC)",
+                       100, 0, nTimeBins,
+                       110, -100.5, 9.5);
+  h2d->SetStats(1);
+  TH1F* h1d = new TH1F("hCMV", ";Common Mode Values (ADC);Counts",
+                       1100, -100.5, 9.5);
+  h1d->SetStats(1);
+
+  // auto-detect branch format: compressed or raw
+  const bool isCompressed = (tree->GetBranch("CMVPerTFCompressed") != nullptr);
+  const bool isRaw = (tree->GetBranch("CMVPerTF") != nullptr);
+  if (!isCompressed && !isRaw) {
+    fmt::print("ERROR: no recognised branch found (expected 'CMVPerTFCompressed' or 'CMVPerTF')\n");
+    return arrCanvases;
+  }
+  fmt::print("Branch format: {}\n", isCompressed ? "CMVPerTFCompressed" : "CMVPerTF (raw)");
+
+  o2::tpc::CMVPerTFCompressed* tfCompressed = nullptr;
+  o2::tpc::CMVPerTF* tfRaw = nullptr;
+  CMVPerTF* tfDecoded = isCompressed ? new CMVPerTF() : nullptr;
+
+  if (isCompressed) {
+    tree->SetBranchAddress("CMVPerTFCompressed", &tfCompressed);
+  } else {
+    tree->SetBranchAddress("CMVPerTF", &tfRaw);
+  }
+
+  long firstOrbit = -1;
+
+  for (int i = 0; i < nEntries; ++i) {
+    tree->GetEntry(i);
+
+    // Decompress if needed; resolve to a unified CMVPerTF pointer
+    const CMVPerTF* tf = nullptr;
+    if (isCompressed) {
+      tfCompressed->decompress(tfDecoded);
+      tf = tfDecoded;
+    } else {
+      tf = tfRaw;
+    }
+
+    if (i == 0) {
+      firstOrbit = tf->firstOrbit;
+    }
+
+    for (int cru = 0; cru < nCRUs; ++cru) {
+      for (int tb = 0; tb < nTimeBins; ++tb) {
+        const float cmvValue = tf->getCMVFloat(cru, tb);
+        h2d->Fill(tb, cmvValue);
+        h1d->Fill(cmvValue);
+        // fmt::print("cru: {}, tb: {}, cmv: {}\n", cru, tb, cmvValue);
+      }
+    }
+  }
+
+  delete tfDecoded;
+  tree->ResetBranchAddresses();
+  delete tfCompressed;
+
+  fmt::print("firstOrbit: {}\n", firstOrbit);
+
+  // draw
+  auto* c = new TCanvas("cCMVvsTimeBin", "");
+  c->SetLogz();
+  h2d->Draw("colz");
+
+  arrCanvases->Add(c);
+
+  auto* c1 = new TCanvas("cCMVDistribution", "");
+  c1->SetLogy();
+  h1d->Draw();
+
+  arrCanvases->Add(c1);
+
+  if (outDir.size()) {
+    utils::saveCanvases(*arrCanvases, outDir, "png,pdf", "CMVCanvases.root");
+  }
+
+  f.Close();
+  return arrCanvases;
+}
diff --git a/Detectors/TPC/calibration/src/CMVContainer.cxx b/Detectors/TPC/calibration/src/CMVContainer.cxx
new file mode 100644
index 0000000000000..5a3b8f1c63c3a
--- /dev/null
+++ b/Detectors/TPC/calibration/src/CMVContainer.cxx
@@ -0,0 +1,729 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   CMVContainer.cxx
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+
+#include <stdexcept>
+#include <cstdint>
+#include <cmath>
+#include <algorithm>
+#include <map>
+#include <fmt/format.h>
+
+#include "TFile.h"
+
+#include "TPCCalibration/CMVContainer.h"
+#include "TPCBase/CRU.h"
+#include "DataFormatsTPC/CMV.h"
+
+namespace o2::tpc
+{
+
+// CMVPerTF private helpers
+
+int32_t CMVPerTF::cmvToSigned(uint16_t raw)
+{
+  const int32_t mag = raw & 0x7FFF;
+  return (raw >> 15) ? mag : -mag;
+}
+
+uint16_t CMVPerTF::quantizeBelowThreshold(uint16_t raw, float quantizationMean, float quantizationSigma)
+{
+  if (raw == 0u) {
+    return raw;
+  }
+
+  if (quantizationSigma <= 0.f) {
+    return raw;
+  }
+
+  const float adc = (raw & 0x7FFFu) / 128.f;
+  const float distance = (adc - quantizationMean) / quantizationSigma;
+  const float lossStrength = std::exp(-0.5f * distance * distance);
+
+  // A true Gaussian bell: strongest trimming around the mean, then gradual recovery away from it
+  float quantizedADC = adc;
+  if (lossStrength > 0.85f) {
+    quantizedADC = std::round(adc * 10.f) / 10.f;
+  } else if (lossStrength > 0.60f) {
+    quantizedADC = std::round(adc * 100.f) / 100.f;
+  } else if (lossStrength > 0.30f) {
+    quantizedADC = std::round(adc * 1000.f) / 1000.f;
+  } else if (lossStrength > 0.12f) {
+    quantizedADC = std::round(adc * 10000.f) / 10000.f;
+  } else if (lossStrength > 0.03f) {
+    quantizedADC = std::round(adc * 1000000.f) / 1000000.f;
+  }
+
+  // Snap the chosen decimal-style value back to the nearest raw I8F7 level
+  const uint16_t quantizedMagnitude = static_cast<uint16_t>(std::clamp(std::lround(quantizedADC * 128.f), 0l, 0x7FFFl));
+  return static_cast<uint16_t>((raw & 0x8000u) | quantizedMagnitude);
+}
+
+uint32_t CMVPerTF::zigzagEncode(int32_t value)
+{
+  return (static_cast<uint32_t>(value) << 1) ^ static_cast<uint32_t>(value >> 31);
+}
+
+void CMVPerTF::encodeVarintInto(uint32_t value, std::vector<uint8_t>& out)
+{
+  while (value > 0x7F) {
+    out.push_back(static_cast<uint8_t>((value & 0x7F) | 0x80));
+    value >>= 7;
+  }
+  out.push_back(static_cast<uint8_t>(value));
+}
+
+// Shared file-local helpers
+
+namespace
+{
+
+int32_t zigzagDecodeLocal(uint32_t value)
+{
+  return static_cast<int32_t>((value >> 1) ^ -(value & 1));
+}
+
+uint16_t signedToCmvLocal(int32_t val)
+{
+  const uint16_t mag = static_cast<uint16_t>(std::abs(val)) & 0x7FFF;
+  return static_cast<uint16_t>((val >= 0 ? 0x8000u : 0u) | mag);
+}
+
+uint32_t decodeVarintLocal(const uint8_t*& data, const uint8_t* end)
+{
+  uint32_t value = 0;
+  int shift = 0;
+  while (data < end && (*data & 0x80)) {
+    value |= static_cast<uint32_t>(*data & 0x7F) << shift;
+    shift += 7;
+    ++data;
+  }
+  if (data >= end) {
+    throw std::runtime_error("decodeVarintLocal: unexpected end of varint data");
+  }
+  value |= static_cast<uint32_t>(*data) << shift;
+  ++data;
+  return value;
+}
+
+/// Build and serialise a canonical Huffman table + bitstream over `symbols` into `buf`
+/// Format:
+///   4 bytes LE uint32_t : numSymbols
+///   numSymbols × 5 bytes: symbol (4 bytes LE) + code length (1 byte)
+///   8 bytes LE uint64_t : totalBits
+///   ceil(totalBits/8) bytes: MSB-first bitstream
+void huffmanEncode(const std::vector<uint32_t>& symbols, std::vector<uint8_t>& buf)
+{
+  // Frequency count
+  std::map<uint32_t, uint64_t> freq;
+  for (const uint32_t z : symbols) {
+    ++freq[z];
+  }
+
+  // Build tree using index-based min-heap
+  struct HNode {
+    uint64_t freq{0};
+    uint32_t sym{0};
+    int left{-1}, right{-1};
+    bool isLeaf{true};
+  };
+  std::vector<HNode> nodes;
+  nodes.reserve(freq.size() * 2);
+  for (const auto& [sym, f] : freq) {
+    nodes.push_back({f, sym, -1, -1, true});
+  }
+
+  auto cmp = [&](int a, int b) {
+    return nodes[a].freq != nodes[b].freq ? nodes[a].freq > nodes[b].freq : nodes[a].sym > nodes[b].sym;
+  };
+  std::vector<int> heap;
+  heap.reserve(nodes.size());
+  for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
+    heap.push_back(i);
+  }
+  std::make_heap(heap.begin(), heap.end(), cmp);
+
+  while (heap.size() > 1) {
+    std::pop_heap(heap.begin(), heap.end(), cmp);
+    const int a = heap.back();
+    heap.pop_back();
+    std::pop_heap(heap.begin(), heap.end(), cmp);
+    const int b = heap.back();
+    heap.pop_back();
+    nodes.push_back({nodes[a].freq + nodes[b].freq, 0, a, b, false});
+    heap.push_back(static_cast<int>(nodes.size()) - 1);
+    std::push_heap(heap.begin(), heap.end(), cmp);
+  }
+
+  // Assign code lengths via iterative DFS
+  std::map<uint32_t, uint8_t> codeLens;
+  {
+    const int root = heap[0];
+    std::vector<std::pair<int, int>> stack;
+    stack.push_back({root, 0});
+    while (!stack.empty()) {
+      auto [idx, depth] = stack.back();
+      stack.pop_back();
+      if (nodes[idx].isLeaf) {
+        codeLens[nodes[idx].sym] = static_cast<uint8_t>(depth == 0 ? 1 : depth);
+      } else {
+        stack.push_back({nodes[idx].left, depth + 1});
+        stack.push_back({nodes[idx].right, depth + 1});
+      }
+    }
+  }
+
+  // Sort by (codeLen ASC, symbol ASC) for canonical assignment
+  struct SymLen {
+    uint32_t sym;
+    uint8_t len;
+  };
+  std::vector<SymLen> symLens;
+  symLens.reserve(codeLens.size());
+  for (const auto& [sym, len] : codeLens) {
+    symLens.push_back({sym, len});
+  }
+  std::sort(symLens.begin(), symLens.end(), [](const SymLen& a, const SymLen& b) {
+    return a.len != b.len ? a.len < b.len : a.sym < b.sym;
+  });
+
+  // Assign canonical codes
+  std::map<uint32_t, std::pair<uint32_t, uint8_t>> codeTable;
+  {
+    uint32_t code = 0;
+    uint8_t prevLen = 0;
+    for (const auto& sl : symLens) {
+      if (prevLen != 0) {
+        code = (code + 1) << (sl.len - prevLen);
+      }
+      codeTable[sl.sym] = {code, sl.len};
+      prevLen = sl.len;
+    }
+  }
+
+  // Serialise table header
+  buf.reserve(buf.size() + 4 + symLens.size() * 5 + 8 + (symbols.size() / 8 + 1));
+  const uint32_t numSym = static_cast<uint32_t>(symLens.size());
+  for (int i = 0; i < 4; ++i) {
+    buf.push_back(static_cast<uint8_t>((numSym >> (8 * i)) & 0xFF));
+  }
+  for (const auto& sl : symLens) {
+    for (int i = 0; i < 4; ++i) {
+      buf.push_back(static_cast<uint8_t>((sl.sym >> (8 * i)) & 0xFF));
+    }
+    buf.push_back(sl.len);
+  }
+
+  // Placeholder for totalBits
+  const size_t totalBitsOffset = buf.size();
+  for (int i = 0; i < 8; ++i) {
+    buf.push_back(0);
+  }
+
+  // Encode bitstream (MSB-first)
+  uint64_t totalBits = 0;
+  uint8_t curByte = 0;
+  int bitsInByte = 0;
+  for (const uint32_t z : symbols) {
+    const auto& [code, len] = codeTable.at(z);
+    for (int b = static_cast<int>(len) - 1; b >= 0; --b) {
+      curByte = static_cast<uint8_t>(curByte | (((code >> b) & 1u) << (7 - bitsInByte)));
+      ++bitsInByte;
+      ++totalBits;
+      if (bitsInByte == 8) {
+        buf.push_back(curByte);
+        curByte = 0;
+        bitsInByte = 0;
+      }
+    }
+  }
+  if (bitsInByte > 0) {
+    buf.push_back(curByte);
+  }
+
+  // Backfill totalBits
+  for (int i = 0; i < 8; ++i) {
+    buf[totalBitsOffset + i] = static_cast<uint8_t>((totalBits >> (8 * i)) & 0xFF);
+  }
+}
+
+/// Decode `N` symbols from a canonical Huffman payload at [ptr, end)
+/// `ptr` must point to the start of the Huffman table header (numSymbols field)
+/// After return, `ptr` is advanced past the bitstream
+std::vector<uint32_t> huffmanDecode(const uint8_t*& ptr, const uint8_t* end, uint32_t N)
+{
+  auto readU32 = [&]() -> uint32_t {
+    if (ptr + 4 > end) {
+      throw std::runtime_error("huffmanDecode: unexpected end reading uint32");
+    }
+    const uint32_t v = static_cast<uint32_t>(ptr[0]) | (static_cast<uint32_t>(ptr[1]) << 8) |
+                       (static_cast<uint32_t>(ptr[2]) << 16) | (static_cast<uint32_t>(ptr[3]) << 24);
+    ptr += 4;
+    return v;
+  };
+
+  const uint32_t numSym = readU32();
+  struct SymLen {
+    uint32_t sym;
+    uint8_t len;
+  };
+  std::vector<SymLen> symLens(numSym);
+  for (uint32_t i = 0; i < numSym; ++i) {
+    symLens[i].sym = readU32();
+    if (ptr >= end) {
+      throw std::runtime_error("huffmanDecode: unexpected end reading code length");
+    }
+    symLens[i].len = *ptr++;
+  }
+
+  std::map<uint8_t, uint32_t> firstCode;
+  std::map<uint8_t, std::vector<uint32_t>> symsByLen;
+  {
+    uint32_t code = 0;
+    uint8_t prevLen = 0;
+    for (const auto& sl : symLens) {
+      if (prevLen != 0) {
+        code = (code + 1) << (sl.len - prevLen);
+      }
+      if (!firstCode.count(sl.len)) {
+        firstCode[sl.len] = code;
+      }
+      symsByLen[sl.len].push_back(sl.sym);
+      prevLen = sl.len;
+    }
+  }
+
+  if (ptr + 8 > end) {
+    throw std::runtime_error("huffmanDecode: unexpected end reading totalBits");
+  }
+  uint64_t totalBits = 0;
+  for (int i = 0; i < 8; ++i) {
+    totalBits |= static_cast<uint64_t>(ptr[i]) << (8 * i);
+  }
+  ptr += 8;
+
+  const uint8_t minLen = symLens.empty() ? 1 : symLens.front().len;
+  const uint8_t maxLen = symLens.empty() ? 1 : symLens.back().len;
+  uint64_t bitsRead = 0;
+  uint8_t curByte = 0;
+  int bitPos = -1;
+
+  auto nextBit = [&]() -> int {
+    if (bitPos < 0) {
+      if (ptr >= end) {
+        throw std::runtime_error("huffmanDecode: unexpected end of bitstream");
+      }
+      curByte = *ptr++;
+      bitPos = 7;
+    }
+    const int bit = (curByte >> bitPos) & 1;
+    --bitPos;
+    return bit;
+  };
+
+  std::vector<uint32_t> out;
+  out.reserve(N);
+  while (out.size() < N) {
+    uint32_t accum = 0;
+    bool found = false;
+    for (uint8_t curLen = 1; curLen <= maxLen; ++curLen) {
+      if (bitsRead >= totalBits) {
+        throw std::runtime_error("huffmanDecode: bitstream exhausted before all symbols decoded");
+      }
+      accum = (accum << 1) | static_cast<uint32_t>(nextBit());
+      ++bitsRead;
+      if (curLen < minLen) {
+        continue;
+      }
+      const auto fcIt = firstCode.find(curLen);
+      if (fcIt == firstCode.end()) {
+        continue;
+      }
+      if (accum >= fcIt->second) {
+        const uint32_t idx = accum - fcIt->second;
+        const auto& sv = symsByLen.at(curLen);
+        if (idx < sv.size()) {
+          out.push_back(sv[idx]);
+          found = true;
+          break;
+        }
+      }
+    }
+    if (!found) {
+      throw std::runtime_error("huffmanDecode: invalid Huffman code in bitstream");
+    }
+  }
+  return out;
+}
+
+} // anonymous namespace
+
+// CMVPerTF public methods
+
+uint16_t CMVPerTF::getCMV(const int cru, const int timeBin) const
+{
+  if (cru < 0 || cru >= static_cast<int>(CRU::MaxCRU)) {
+    throw std::out_of_range(fmt::format("CMVPerTF::getCMV: cru {} out of range [0, {})", cru, static_cast<int>(CRU::MaxCRU)));
+  }
+  if (timeBin < 0 || static_cast<uint32_t>(timeBin) >= cmv::NTimeBinsPerTF) {
+    throw std::out_of_range(fmt::format("CMVPerTF::getCMV: timeBin {} out of range [0, {})", timeBin, static_cast<int>(cmv::NTimeBinsPerTF)));
+  }
+  return mDataPerTF[cru * cmv::NTimeBinsPerTF + timeBin];
+}
+
+float CMVPerTF::getCMVFloat(const int cru, const int timeBin) const
+{
+  const uint16_t raw = getCMV(cru, timeBin);
+  const uint16_t mag = raw & 0x7FFF;
+  if (mag == 0) {
+    return 0.0f; // 0x0000 and 0x8000 both represent zero; return +0 to avoid -0 display
+  }
+  const bool positive = (raw >> 15) & 1; // bit 15: sign (1=positive, 0=negative)
+  return positive ? mag / 128.f : -mag / 128.f;
+}
+
+void CMVPerTF::zeroSmallValues(float threshold)
+{
+  if (threshold <= 0.f) {
+    return;
+  }
+  for (uint32_t i = 0; i < static_cast<uint32_t>(CRU::MaxCRU) * cmv::NTimeBinsPerTF; ++i) {
+    const float mag = (mDataPerTF[i] & 0x7FFF) / 128.f;
+    if (mag < threshold) {
+      mDataPerTF[i] = 0;
+    }
+  }
+}
+
+void CMVPerTF::roundToIntegers(uint16_t threshold)
+{
+  if (threshold == 0) {
+    return;
+  }
+  for (uint32_t i = 0; i < static_cast<uint32_t>(CRU::MaxCRU) * cmv::NTimeBinsPerTF; ++i) {
+    const uint16_t raw = mDataPerTF[i];
+    if (raw == 0) {
+      continue;
+    }
+    const uint16_t rounded = static_cast<uint16_t>(((raw & 0x7FFFu) + 64u) >> 7);
+    if (rounded > threshold) {
+      continue; // above range: keep full precision
+    }
+    mDataPerTF[i] = (rounded == 0) ? 0 : static_cast<uint16_t>((raw & 0x8000u) | (rounded << 7));
+  }
+}
+
+void CMVPerTF::trimGaussianPrecision(float mean, float sigma)
+{
+  if (sigma <= 0.f) {
+    return;
+  }
+
+  for (uint32_t i = 0; i < static_cast<uint32_t>(CRU::MaxCRU) * cmv::NTimeBinsPerTF; ++i) {
+    mDataPerTF[i] = quantizeBelowThreshold(mDataPerTF[i], mean, sigma);
+  }
+}
+
+CMVPerTFCompressed CMVPerTF::compress(uint8_t flags) const
+{
+  CMVPerTFCompressed out;
+  out.firstOrbit = firstOrbit;
+  out.firstBC = firstBC;
+  out.mFlags = flags;
+
+  if (flags & CMVEncoding::kSparse) {
+    // --- Sparse path: position stream + value stream ---
+
+    // Single pass per CRU: build the position stream and collect raw non-zero values.
+    std::vector<uint8_t> posStream;
+    std::vector<uint16_t> rawValues;
+
+    for (int cru = 0; cru < static_cast<int>(CRU::MaxCRU); ++cru) {
+      struct Entry {
+        uint32_t tb;
+        uint16_t val;
+      };
+      std::vector<Entry> entries;
+      for (uint32_t tb = 0; tb < cmv::NTimeBinsPerTF; ++tb) {
+        const uint16_t val = mDataPerTF[cru * cmv::NTimeBinsPerTF + tb];
+        if (val != 0) {
+          entries.push_back({tb, val});
+        }
+      }
+
+      encodeVarintInto(static_cast<uint32_t>(entries.size()), posStream);
+      uint32_t prevTB = 0;
+      bool first = true;
+      for (const auto& e : entries) {
+        encodeVarintInto(first ? e.tb : (e.tb - prevTB), posStream);
+        rawValues.push_back(e.val);
+        prevTB = e.tb;
+        first = false;
+      }
+    }
+
+    // Encode the value stream based on flags.
+    std::vector<uint8_t> valStream;
+    if (flags & CMVEncoding::kZigzag) {
+      std::vector<uint32_t> zigzags;
+      zigzags.reserve(rawValues.size());
+      for (const uint16_t v : rawValues) {
+        zigzags.push_back(zigzagEncode(cmvToSigned(v)));
+      }
+      if (flags & CMVEncoding::kHuffman) {
+        huffmanEncode(zigzags, valStream);
+      } else { // kVarint
+        for (const uint32_t z : zigzags) {
+          encodeVarintInto(z, valStream);
+        }
+      }
+    } else {
+      // Raw uint16 LE
+      for (const uint16_t v : rawValues) {
+        valStream.push_back(static_cast<uint8_t>(v & 0xFF));
+        valStream.push_back(static_cast<uint8_t>(v >> 8));
+      }
+    }
+
+    // Assemble: [4 bytes posStreamSize][posStream][valStream]
+    const uint32_t posStreamSize = static_cast<uint32_t>(posStream.size());
+    out.mData.reserve(4 + posStream.size() + valStream.size());
+    for (int i = 0; i < 4; ++i) {
+      out.mData.push_back(static_cast<uint8_t>((posStreamSize >> (8 * i)) & 0xFF));
+    }
+    out.mData.insert(out.mData.end(), posStream.begin(), posStream.end());
+    out.mData.insert(out.mData.end(), valStream.begin(), valStream.end());
+
+  } else {
+    // --- Dense path: all CRU * TimeBin values ---
+    const uint32_t total = static_cast<uint32_t>(CRU::MaxCRU) * cmv::NTimeBinsPerTF;
+
+    if (!(flags & CMVEncoding::kZigzag)) {
+      // No encoding: raw uint16 LE
+      out.mData.reserve(total * 2);
+      for (uint32_t i = 0; i < total; ++i) {
+        out.mData.push_back(static_cast<uint8_t>(mDataPerTF[i] & 0xFF));
+        out.mData.push_back(static_cast<uint8_t>(mDataPerTF[i] >> 8));
+      }
+    } else {
+      // Zigzag + optional delta (CRU-major, time-minor)
+      const bool useDelta = (flags & CMVEncoding::kDelta) != 0;
+      std::vector<uint32_t> zigzags;
+      zigzags.reserve(total);
+      for (int cru = 0; cru < static_cast<int>(CRU::MaxCRU); ++cru) {
+        int32_t prev = 0;
+        for (uint32_t tb = 0; tb < cmv::NTimeBinsPerTF; ++tb) {
+          const int32_t val = cmvToSigned(mDataPerTF[cru * cmv::NTimeBinsPerTF + tb]);
+          const int32_t encoded = useDelta ? (val - prev) : val;
+          if (useDelta) {
+            prev = val;
+          }
+          zigzags.push_back(zigzagEncode(encoded));
+        }
+      }
+
+      if (flags & CMVEncoding::kHuffman) {
+        huffmanEncode(zigzags, out.mData);
+      } else { // kVarint
+        for (const uint32_t z : zigzags) {
+          encodeVarintInto(z, out.mData);
+        }
+      }
+    }
+  }
+
+  return out;
+}
+
+// CMVPerTFCompressed::decompress staged pipeline
+
+std::vector<std::pair<int, uint32_t>> CMVPerTFCompressed::decodeSparsePositions(const uint8_t*& ptr, const uint8_t* end)
+{
+  // Read 4-byte LE posStreamSize
+  if (ptr + 4 > end) {
+    throw std::runtime_error("CMVPerTFCompressed::decompress: truncated position header");
+  }
+  const uint32_t posStreamSize = static_cast<uint32_t>(ptr[0]) | (static_cast<uint32_t>(ptr[1]) << 8) |
+                                 (static_cast<uint32_t>(ptr[2]) << 16) | (static_cast<uint32_t>(ptr[3]) << 24);
+  ptr += 4;
+
+  const uint8_t* posEnd = ptr + posStreamSize;
+  if (posEnd > end) {
+    throw std::runtime_error("CMVPerTFCompressed::decompress: posStream overflows payload");
+  }
+
+  // Decode per-CRU varint(N) + N×varint(tb_delta)
+  std::vector<std::pair<int, uint32_t>> positions;
+  const uint8_t* p = ptr;
+  for (int cru = 0; cru < static_cast<int>(CRU::MaxCRU); ++cru) {
+    const uint32_t count = decodeVarintLocal(p, posEnd);
+    uint32_t tb = 0;
+    bool first = true;
+    for (uint32_t i = 0; i < count; ++i) {
+      const uint32_t delta = decodeVarintLocal(p, posEnd);
+      tb = first ? delta : (tb + delta);
+      first = false;
+      positions.emplace_back(cru, tb);
+    }
+  }
+  ptr = posEnd; // advance past the entire position block
+  return positions;
+}
+
+std::vector<uint32_t> CMVPerTFCompressed::decodeValueStream(const uint8_t*& ptr, const uint8_t* end, uint32_t N, uint8_t flags)
+{
+  if (flags & CMVEncoding::kHuffman) {
+    // Huffman-encoded symbols
+    return huffmanDecode(ptr, end, N);
+  }
+
+  if (flags & CMVEncoding::kVarint) {
+    // Varint-encoded symbols
+    std::vector<uint32_t> out;
+    out.reserve(N);
+    for (uint32_t i = 0; i < N; ++i) {
+      out.push_back(decodeVarintLocal(ptr, end));
+    }
+    return out;
+  }
+
+  // Raw uint16 LE (no value encoding)
+  std::vector<uint32_t> out;
+  out.reserve(N);
+  for (uint32_t i = 0; i < N; ++i) {
+    if (ptr + 2 > end) {
+      throw std::runtime_error("CMVPerTFCompressed::decompress: unexpected end in raw value stream");
+    }
+    const uint16_t v = static_cast<uint16_t>(ptr[0]) | (static_cast<uint16_t>(ptr[1]) << 8);
+    ptr += 2;
+    out.push_back(v);
+  }
+  return out;
+}
+
+void CMVPerTFCompressed::decodeSparseValues(const std::vector<uint32_t>& symbols,
+                                            const std::vector<std::pair<int, uint32_t>>& positions,
+                                            uint8_t flags, CMVPerTF* cmv)
+{
+  const bool useZigzag = (flags & CMVEncoding::kZigzag) != 0;
+  for (uint32_t i = 0; i < static_cast<uint32_t>(positions.size()); ++i) {
+    uint16_t raw;
+    if (useZigzag) {
+      raw = signedToCmvLocal(zigzagDecodeLocal(symbols[i]));
+    } else {
+      raw = static_cast<uint16_t>(symbols[i]);
+    }
+    cmv->mDataPerTF[positions[i].first * cmv::NTimeBinsPerTF + positions[i].second] = raw;
+  }
+}
+
+void CMVPerTFCompressed::decodeDenseValues(const std::vector<uint32_t>& symbols, uint8_t flags, CMVPerTF* cmv)
+{
+  const bool useZigzag = (flags & CMVEncoding::kZigzag) != 0;
+  const bool useDelta = (flags & CMVEncoding::kDelta) != 0;
+
+  if (!useZigzag) {
+    // Symbols are raw uint16 values; write directly
+    for (uint32_t i = 0; i < static_cast<uint32_t>(symbols.size()); ++i) {
+      cmv->mDataPerTF[i] = static_cast<uint16_t>(symbols[i]);
+    }
+    return;
+  }
+
+  // Inverse zigzag + optional inverse delta (CRU-major, time-minor)
+  uint32_t s = 0;
+  for (int cru = 0; cru < static_cast<int>(CRU::MaxCRU); ++cru) {
+    int32_t prev = 0;
+    for (uint32_t tb = 0; tb < cmv::NTimeBinsPerTF; ++tb, ++s) {
+      int32_t val = zigzagDecodeLocal(symbols[s]);
+      if (useDelta) {
+        val += prev;
+        prev = val;
+      }
+      cmv->mDataPerTF[s] = signedToCmvLocal(val);
+    }
+  }
+}
+
+void CMVPerTFCompressed::decompress(CMVPerTF* cmv) const
+{
+  if (!cmv) {
+    throw std::invalid_argument("CMVPerTFCompressed::decompress: cmv pointer is null");
+  }
+  cmv->firstOrbit = firstOrbit;
+  cmv->firstBC = firstBC;
+  std::fill(std::begin(cmv->mDataPerTF), std::end(cmv->mDataPerTF), uint16_t(0));
+
+  const uint8_t* ptr = mData.data();
+  const uint8_t* end = ptr + mData.size();
+
+  if (mFlags & CMVEncoding::kSparse) {
+    // Stage 1: decode position stream
+    auto positions = decodeSparsePositions(ptr, end);
+    const uint32_t N = static_cast<uint32_t>(positions.size());
+
+    // Stage 2: decode value stream (Huffman / varint / raw)
+    auto symbols = decodeValueStream(ptr, end, N, mFlags);
+
+    // Stage 3: inverse zigzag and scatter into CMV array
+    decodeSparseValues(symbols, positions, mFlags, cmv);
+  } else {
+    const uint32_t N = static_cast<uint32_t>(CRU::MaxCRU) * cmv::NTimeBinsPerTF;
+
+    // Stage 1: decode value stream (Huffman / varint / raw)
+    auto symbols = decodeValueStream(ptr, end, N, mFlags);
+
+    // Stage 2: inverse zigzag, inverse delta, fill CMV array
+    decodeDenseValues(symbols, mFlags, cmv);
+  }
+}
+
+std::unique_ptr<TTree> CMVPerTF::toTTree() const
+{
+  auto tree = std::make_unique<TTree>("ccdb_object", "ccdb_object");
+  tree->SetAutoSave(0);
+  tree->SetDirectory(nullptr);
+
+  const CMVPerTF* ptr = this;
+  tree->Branch("CMVPerTF", &ptr);
+  tree->Fill();
+
+  tree->ResetBranchAddresses();
+  return tree;
+}
+
+std::unique_ptr<TTree> CMVPerTFCompressed::toTTree() const
+{
+  auto tree = std::make_unique<TTree>("ccdb_object", "ccdb_object");
+  tree->SetAutoSave(0);
+  tree->SetDirectory(nullptr);
+
+  const CMVPerTFCompressed* ptr = this;
+  tree->Branch("CMVPerTFCompressed", &ptr);
+  tree->Fill();
+
+  tree->ResetBranchAddresses();
+  return tree;
+}
+
+void CMVPerTF::writeToFile(const std::string& filename, const std::unique_ptr<TTree>& tree)
+{
+  TFile f(filename.c_str(), "RECREATE");
+  if (f.IsZombie()) {
+    throw std::runtime_error(fmt::format("CMVPerTF::writeToFile: cannot open '{}'", filename));
+  }
+  tree->Write();
+  f.Close();
+}
+
+} // namespace o2::tpc
diff --git a/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h b/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
index 6e15e2dd0427a..14d3d0a8ffb8e 100644
--- a/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
+++ b/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
@@ -123,4 +123,8 @@
 #pragma link C++ class o2::tpc::DigitAdd + ;
 #pragma link C++ class std::vector < o2::tpc::DigitAdd> + ;
 #pragma link C++ class o2::tpc::PressureTemperatureHelper + ;
+
+#pragma link C++ class o2::tpc::CMVPerTF + ;
+#pragma link C++ class o2::tpc::CMVPerTFCompressed + ;
+
 #endif
diff --git a/Detectors/TPC/workflow/CMakeLists.txt b/Detectors/TPC/workflow/CMakeLists.txt
index 6930f332bfbf1..0f8d73b1cbe7e 100644
--- a/Detectors/TPC/workflow/CMakeLists.txt
+++ b/Detectors/TPC/workflow/CMakeLists.txt
@@ -25,6 +25,7 @@ o2_add_library(TPCWorkflow
                        src/KryptonRawFilterSpec.cxx
                        src/OccupancyFilterSpec.cxx
                        src/SACProcessorSpec.cxx
+                       src/CMVToVectorSpec.cxx
                        src/IDCToVectorSpec.cxx
                        src/CalibdEdxSpec.cxx
                        src/CalibratordEdxSpec.cxx
@@ -288,4 +289,19 @@ o2_add_executable(pressure-temperature
                   SOURCES src/tpc-pressure-temperature.cxx
                   PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
 
-add_subdirectory(readers)
+o2_add_executable(cmv-to-vector
+                  COMPONENT_NAME tpc
+                  SOURCES src/tpc-cmv-to-vector.cxx
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+
+o2_add_executable(cmv-flp
+                  COMPONENT_NAME tpc
+                  SOURCES src/tpc-flp-cmv.cxx
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+
+o2_add_executable(cmv-distribute
+                  COMPONENT_NAME tpc
+                  SOURCES src/tpc-distribute-cmv.cxx
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+
+add_subdirectory(readers)
\ No newline at end of file
diff --git a/Detectors/TPC/workflow/README.md b/Detectors/TPC/workflow/README.md
index e34faa2813edf..b7a19da121e9b 100644
--- a/Detectors/TPC/workflow/README.md
+++ b/Detectors/TPC/workflow/README.md
@@ -274,3 +274,191 @@ To directly dump the digits to file for inspection use for the reco workflow
 ```bash
 | o2-tpc-reco-workflow --input-type digitizer --output-type digits --disable-mc
 ```
+
+## TPC Common Mode Value (CMV) Workflows
+
+The CMV workflows parse raw TPC data, buffer Common Mode Values per CRU on FLPs, then merge and aggregate them on a calibration node before serializing the CMVContainer in a TTree. The resulting object can be uploaded to the CCDB or written to the disk.
+
+### Workflow components
+
+| Executable | Output | Description |
+|---|---|---|
+| `o2-tpc-cmv-to-vector` | `TPC/CMVVECTOR` | Parses raw TPC data and creates vectors of CMVs per CRU |
+| `o2-tpc-cmv-flp` | `TPC/CMVGROUP` | Buffers N TFs per CRU on the FLP and groups them for forwarding |
+| `o2-tpc-cmv-distribute` | TTree / CCDB payload | Merges CRUs over N TFs on the calibration node, serializes the CMVContainer into a TTree, and either writes it to disk (`--dump-cmvs`) or forwards it as a CCDB object (`--enable-CCDB-output`) |
+
+#### `o2-tpc-cmv-to-vector`
+
+| Option | Default | Description |
+|---|---|---|
+| `--input-spec` | `A:TPC/RAWDATA` | DPL input spec for raw TPC data |
+| `--crus` | `0-359` | CRU range to process, comma-separated ranges |
+| `--write-debug` | false | Write a debug output tree every TF |
+| `--write-debug-on-error` | false | Write a debug output tree only when decoding errors occur |
+| `--debug-file-name` | `/tmp/cmv_vector_debug.{run}.root` | Name of the debug output ROOT file |
+| `--write-raw-data-on-error` | false | Dump raw data to file when decoding errors occur |
+| `--raw-file-name` | `/tmp/cmv_debug.{run}.{raw_type}` | Name of the raw debug output file |
+| `--raw-data-type` | 0 | Raw data format to dump on error: 0 = full TPC with DPL header, 1 = full TPC with DPL header (skip empty), 2 = full TPC no DPL header, 3 = full TPC no DPL header (skip empty), 4 = IDC raw only, 5 = CMV raw only |
+| `--check-incomplete-hbf` | false | Check and report incomplete HBFs in the raw parser |
+
+#### `o2-tpc-cmv-flp`
+
+| Option | Default | Description |
+|---|---|---|
+| `--crus` | `0-359` | CRU range handled by this FLP |
+| `--lanes` | hw_concurrency/2 | Parallel processing lanes (CRUs split per lane) |
+| `--time-lanes` | 1 | Parallel lanes for time-frame splitting |
+| `--n-TFs-buffer` | 1 | Number of TFs to buffer before forwarding |
+| `--dump-cmvs-flp` | false | Dump raw CMV vectors per CRU to a ROOT file each TF (for debugging) |
+
+#### `o2-tpc-cmv-distribute`
+
+| Option | Default | Description |
+|---|---|---|
+| `--crus` | `0-359` | CRU range expected from upstream |
+| `--timeframes` | 2000 | Number of TFs aggregated per calibration interval |
+| `--firstTF` | -1 | First time frame index; -1 = auto-detect from first incoming TF; values < -1 set an offset of `\|firstTF\|+1` TFs before the first interval begins |
+| `--lanes` | 1 | Number of parallel lanes (CRUs are split evenly across lanes) |
+| `--n-TFs-buffer` | 1 | Number of TFs buffered per group in the upstream `o2-tpc-cmv-flp` (must match that workflow's setting) |
+| `--enable-CCDB-output` | false | Forward the CMVContainer TTree as a CCDB object to `o2-calibration-ccdb-populator-workflow` |
+| `--use-precise-timestamp` | false | Fetch orbit-reset and GRPECS from CCDB to compute a precise CCDB validity timestamp |
+| `--dump-cmvs` | false | Write the CMVContainer TTree to a local ROOT file on disk |
+| `--use-sparse` | false | Sparse encoding: skip zero time bins (raw uint16 values; combine with `--use-compression-varint` or `--use-compression-huffman` for compressed sparse output) |
+| `--use-compression-varint` | false | Delta + zigzag + varint compression over all values; combined with `--use-sparse`: varint-encoded exact values at non-zero positions |
+| `--use-compression-huffman` | false | Huffman encoding over all values; combined with `--use-sparse`: Huffman-encoded exact values at non-zero positions |
+| `--cmv-zero-threshold` | 0 | Zero out CMV values whose magnitude is below this threshold (ADC) after optional rounding and before compression; 0 disables |
+| `--cmv-round-integers-threshold` | 0 | Round values to nearest integer ADC for \|v\| ≤ N ADC before compression; 0 disables |
+| `--cmv-dynamic-precision-mean` | 1.0 | Gaussian centre in \|CMV\| (ADC) where the strongest fractional-bit trimming is applied |
+| `--cmv-dynamic-precision-sigma` | 0 | Gaussian width (ADC) for smooth CMV fractional-bit trimming; 0 disables |
+| `--drop-data-after-nTFs` | 0 | Drop data for a relative TF slot after this many TFs have passed without receiving all CRUs; 0 uses the default derived from `--check-data-every-n` |
+| `--check-data-every-n` | 0 | Check for missing CRU data every N invocations of the run function; -1 disables checking, 0 uses the default (timeframes/2) |
+| `--nFactorTFs` | 1000 | Number of TFs to skip before flushing the oldest incomplete aggregation interval |
+
+### Example 1 — Simple usage for testing
+
+```bash
+#!/bin/bash
+
+hash="test"
+MAX_TFS=1
+CRUS="0-359"
+
+ARGS_ALL="-b --session ${USER}.${hash} --shm-segment-size $((8<<30))"
+
+o2-raw-tf-reader-workflow $ARGS_ALL \
+  --input-data tf.subset.list \
+  --max-tf ${MAX_TFS} |
+o2-tfidinfo-writer-workflow $ARGS_ALL \
+  --early-forward-policy noraw \
+  --fairmq-rate-logging 0 \
+  --timeframes-rate-limit ${MAX_TFS} \
+  --timeframes-rate-limit-ipcid 583693664 |
+o2-tpc-cmv-to-vector $ARGS_ALL \
+  --input-spec "A:TPC/RAWDATA" \
+  --write-debug-on-error \
+  --crus ${CRUS} |
+o2-tpc-cmv-flp $ARGS_ALL \
+  --crus ${CRUS} |
+o2-tpc-cmv-distribute $ARGS_ALL \
+  --crus ${CRUS} \
+  --dump-cmvs \
+  --enable-CCDB-output \
+  --cmv-zero-threshold 1.0 \
+  --cmv-dynamic-precision-mean 1.0 \
+  --cmv-dynamic-precision-sigma 8.0 \
+  --use-sparse \
+  --use-compression-huffman |
+o2-calibration-ccdb-populator-workflow $ARGS_ALL \
+  --ccdb-path ccdb-test.cern.ch:8080
+```
+
+### Example 2 — Bash scripts for more realistic testing
+
+In a real online setup, multiple FLPs each process their own CRU subset and forward compressed CMV groups to a central aggregator node via ZeroMQ.
+
+**FLP side (`Send.sh`)** — run one instance per FLP (pass `N_FLPs` as first argument):
+
+```bash
+#!/bin/bash
+
+# Number of FLPs (passed as first argument, default 1)
+N_FLPs=${1:-1}
+
+hash="test"
+MAX_TFS=1
+
+minCRU=0
+maxCRU=360
+
+ARGS_ALL="-b --shm-segment-size $((8<<30))"
+
+for ((i = 0; i < ${N_FLPs}; i++)); do
+  xpos_start=100
+  xpos=$((xpos_start + 1000 * $i))
+
+  let diff=${maxCRU}-${minCRU}
+  let Start=${minCRU}+$i*${diff}/${N_FLPs}
+  let End=$Start+${diff}/${N_FLPs}-1
+
+  crus="$Start-$End"
+  echo "FLP $i: crus $crus"
+
+  xterm -hold -geometry 150x41+$xpos+300 -e bash -c "unset PYTHONHOME PYTHONPATH; echo FLP $i;
+  o2-raw-tf-reader-workflow $ARGS_ALL \
+    --session ${USER}.${hash}.send.$i \
+    --input-data tf.subset.list \
+    --max-tf ${MAX_TFS} |
+  o2-tfidinfo-writer-workflow $ARGS_ALL \
+    --session ${USER}.${hash}.send.$i \
+    --early-forward-policy noraw \
+    --fairmq-rate-logging 0 \
+    --timeframes-rate-limit ${MAX_TFS} \
+    --timeframes-rate-limit-ipcid $((583693664 + $i)) |
+  o2-tpc-cmv-to-vector $ARGS_ALL \
+    --session ${USER}.${hash}.send.$i \
+    --input-spec 'A:TPC/RAWDATA' \
+    --write-debug-on-error \
+    --crus ${crus} |
+  o2-tpc-cmv-flp $ARGS_ALL \
+    --session ${USER}.${hash}.send.$i \
+    --crus ${crus} |
+  o2-dpl-output-proxy $ARGS_ALL \
+    --session ${USER}.${hash}.send.$i \
+    --sporadic-inputs \
+    --channel-config 'name=downstream,method=connect,address=tcp://localhost:30453,type=push,transport=zeromq' \
+    --dataspec 'downstream:TPC/CMVGROUP;downstream:TPC/CMVORBITINFO'; exec bash" &
+done
+```
+
+Each FLP connects to the aggregator's pull socket on port `30453` and pushes `TPC/CMVGROUP` and `TPC/CMVORBITINFO` messages. The CRU range is automatically split evenly across `N_FLPs`.
+
+**Aggregator side (`Receive.sh`)**:
+
+```bash
+#!/bin/bash
+
+hash="test"
+CRUS="0-359"
+
+ARGS_ALL="-b --session ${USER}.${hash}.receive --shm-segment-size $((8<<30))"
+
+# ZeroMQ proxy: pull from all FLPs connecting on port 30453
+configProxy="name=readout-proxy,type=pull,method=bind,address=tcp://localhost:30453,rateLogging=1,transport=zeromq"
+
+o2-dpl-raw-proxy $ARGS_ALL \
+  --channel-config "${configProxy}" \
+  --dataspec "A:TPC/CMVGROUP;A:TPC/CMVORBITINFO" |
+o2-tpc-cmv-distribute $ARGS_ALL \
+  --crus ${CRUS} \
+  --dump-cmvs \
+  --enable-CCDB-output \
+  --cmv-zero-threshold 1.0 \
+  --cmv-dynamic-precision-mean 1.0 \
+  --cmv-dynamic-precision-sigma 8.0 \
+  --use-sparse \
+  --use-compression-huffman |
+o2-calibration-ccdb-populator-workflow $ARGS_ALL \
+  --ccdb-path ccdb-test.cern.ch:8080
+```
+
+The aggregator binds the ZeroMQ pull socket and waits for all FLPs to connect. Once `TPC/CMVGROUP` and `TPC/CMVORBITINFO` data arrive, `o2-tpc-cmv-distribute` merges them, applies compression, writes the object to the disk and uploads to the CCDB.
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/CMVToVectorSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/CMVToVectorSpec.h
new file mode 100644
index 0000000000000..add37af5706e5
--- /dev/null
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/CMVToVectorSpec.h
@@ -0,0 +1,30 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   CMVToVectorSpec.h
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  Processor to convert CMVs to a vector in a CRU
+
+#ifndef TPC_CMVToVectorSpec_H_
+#define TPC_CMVToVectorSpec_H_
+
+#include "Framework/DataProcessorSpec.h"
+
+namespace o2::tpc
+{
+
+/// create a processor spec
+/// convert CMV raw values to a vector in a CRU
+o2::framework::DataProcessorSpec getCMVToVectorSpec(const std::string inputSpec, std::vector<uint32_t> const& crus);
+
+} // end namespace o2::tpc
+
+#endif // TPC_CMVToVectorSpec_H_
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
new file mode 100644
index 0000000000000..c1744ce86d3ac
--- /dev/null
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
@@ -0,0 +1,621 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   TPCDistributeCMVSpec.h
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  TPC aggregation of grouped CMVs
+
+#ifndef O2_TPCDISTRIBUTECMVSPEC_H
+#define O2_TPCDISTRIBUTECMVSPEC_H
+
+#include <vector>
+#include <chrono>
+#include <fmt/format.h>
+#include "TParameter.h"
+#include "Framework/Task.h"
+#include "Framework/ControlService.h"
+#include "Framework/Logger.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/InputRecordWalker.h"
+#include "Framework/DataTakingContext.h"
+#include "Headers/DataHeader.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "TPCWorkflow/TPCFLPCMVSpec.h"
+#include "MemoryResources/MemoryResources.h"
+#include "TPCWorkflow/ProcessingHelpers.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "CommonDataFormat/Pair.h"
+#include "TMemFile.h"
+#include "CCDB/CcdbApi.h"
+#include "CCDB/CcdbObjectInfo.h"
+#include "DetectorsCalibration/Utils.h"
+#include "TPCCalibration/CMVContainer.h"
+#include "DataFormatsTPC/CMV.h"
+
+using namespace o2::framework;
+using o2::header::gDataOriginTPC;
+using namespace o2::tpc;
+
+namespace o2::tpc
+{
+
+class TPCDistributeCMVSpec : public o2::framework::Task
+{
+ public:
+  TPCDistributeCMVSpec(const std::vector<uint32_t>& crus, const unsigned int timeframes, const int nTFsBuffer, const int firstTF, const bool sendCCDB, const bool usePreciseTimestamp, std::shared_ptr<o2::base::GRPGeomRequest> req)
+    : mCRUs{crus},
+      mTimeFrames{timeframes},
+      mNTFsBuffer{nTFsBuffer},
+      mProcessedCRU{{std::vector<unsigned int>(timeframes), std::vector<unsigned int>(timeframes)}},
+      mTFStart{{firstTF, firstTF + timeframes}},
+      mTFEnd{{firstTF + timeframes - 1, mTFStart[1] + timeframes - 1}},
+      mCCDBRequest(req),
+      mSendCCDB{sendCCDB},
+      mUsePreciseTimestamp{usePreciseTimestamp},
+      mSendCCDBOutputOrbitReset(1),
+      mSendCCDBOutputGRPECS(1),
+      mOrbitInfoForwarded{{std::vector<bool>(timeframes, false), std::vector<bool>(timeframes, false)}}
+  {
+    // sort vector for binary_search
+    std::sort(mCRUs.begin(), mCRUs.end());
+
+    for (auto& processedCRUbuffer : mProcessedCRUs) {
+      processedCRUbuffer.resize(mTimeFrames);
+      for (auto& crusMap : processedCRUbuffer) {
+        crusMap.reserve(mCRUs.size());
+        for (const auto cruID : mCRUs) {
+          crusMap.emplace(cruID, false);
+        }
+      }
+    }
+
+    mFilter.emplace_back(InputSpec{"cmvsgroup", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, Lifetime::Sporadic});
+    mOrbitFilter.emplace_back(InputSpec{"cmvorbit", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo()}, Lifetime::Sporadic});
+
+    // pre-allocate the accumulator TTree for the current aggregation interval
+    initIntervalTree();
+  };
+
+  void init(o2::framework::InitContext& ic) final
+  {
+    o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
+    mNFactorTFs = ic.options().get<int>("nFactorTFs");
+    mNTFsDataDrop = ic.options().get<int>("drop-data-after-nTFs");
+    mCheckEveryNData = ic.options().get<int>("check-data-every-n");
+    if (mCheckEveryNData == 0) {
+      mCheckEveryNData = mTimeFrames / 2;
+      if (mCheckEveryNData == 0) {
+        mCheckEveryNData = 1;
+      }
+      mNTFsDataDrop = mCheckEveryNData;
+    }
+    mDumpCMVs = ic.options().get<bool>("dump-cmvs");
+    mUseCompressionVarint = ic.options().get<bool>("use-compression-varint");
+    mUseSparse = ic.options().get<bool>("use-sparse");
+    mUseCompressionHuffman = ic.options().get<bool>("use-compression-huffman");
+    mRoundIntegersThreshold = static_cast<uint16_t>(ic.options().get<int>("cmv-round-integers-threshold"));
+    mZeroThreshold = ic.options().get<float>("cmv-zero-threshold");
+    mDynamicPrecisionMean = ic.options().get<float>("cmv-dynamic-precision-mean");
+    mDynamicPrecisionSigma = ic.options().get<float>("cmv-dynamic-precision-sigma");
+    LOGP(info, "CMV compression settings: use-compression-varint={}, use-sparse={}, use-compression-huffman={}, cmv-round-integers-threshold={}, cmv-zero-threshold={}, cmv-dynamic-precision-mean={}, cmv-dynamic-precision-sigma={}",
+         mUseCompressionVarint, mUseSparse, mUseCompressionHuffman, mRoundIntegersThreshold, mZeroThreshold, mDynamicPrecisionMean, mDynamicPrecisionSigma);
+    // re-initialise the interval tree now that compression options are known (constructor used the defaults)
+    initIntervalTree();
+  }
+
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final
+  {
+    o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
+    if (matcher == ConcreteDataMatcher("CTP", "ORBITRESET", 0)) {
+      LOGP(info, "Updating ORBITRESET");
+      std::fill(mSendCCDBOutputOrbitReset.begin(), mSendCCDBOutputOrbitReset.end(), true);
+    } else if (matcher == ConcreteDataMatcher("GLO", "GRPECS", 0)) {
+      // check if received object is valid
+      if (o2::base::GRPGeomHelper::instance().getGRPECS()->getRun() != 0) {
+        LOGP(info, "Updating GRPECS");
+        std::fill(mSendCCDBOutputGRPECS.begin(), mSendCCDBOutputGRPECS.end(), true);
+      } else {
+        LOGP(info, "Detected default GRPECS object");
+      }
+    }
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    // capture orbit-reset info once for precise CCDB timestamp calculation
+    if (mCCDBRequest->askTime) {
+      const bool grpecsValid = pc.inputs().isValid("grpecs");
+      const bool orbitResetValid = pc.inputs().isValid("orbitReset");
+      if (grpecsValid) {
+        pc.inputs().get<o2::parameters::GRPECSObject*>("grpecs");
+      }
+      if (orbitResetValid) {
+        pc.inputs().get<std::vector<Long64_t>*>("orbitReset");
+      }
+      if (pc.inputs().countValidInputs() == (grpecsValid + orbitResetValid)) {
+        return;
+      }
+      // update mTFInfo from GRPGeomHelper whenever orbit-reset or GRPECS objects are fresh
+      if (mSendCCDBOutputOrbitReset[0] && mSendCCDBOutputGRPECS[0]) {
+        mSendCCDBOutputOrbitReset[0] = false;
+        mSendCCDBOutputGRPECS[0] = false;
+        mTFInfo = dataformats::Pair<long, int>{o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS(), o2::base::GRPGeomHelper::instance().getNHBFPerTF()};
+      }
+    }
+
+    const auto tf = processing_helpers::getCurrentTF(pc);
+    mLastSeenTF = tf; // track for endOfStream flush
+
+    // automatically detect firstTF in case firstTF was not specified
+    if (mTFStart.front() <= -1) {
+      const auto firstTF = tf;
+      const long offsetTF = std::abs(mTFStart.front() + 1);
+      const auto nTotTFs = getNRealTFs();
+      mTFStart = {firstTF + offsetTF, firstTF + offsetTF + nTotTFs};
+      mTFEnd = {mTFStart[1] - 1, mTFStart[1] - 1 + nTotTFs};
+      LOGP(info, "Setting {} as first TF", mTFStart[0]);
+      LOGP(info, "Using offset of {} TFs for setting the first TF", offsetTF);
+    }
+
+    // check which buffer to use for current incoming data
+    const bool currentBuffer = (tf > mTFEnd[mBuffer]) ? !mBuffer : mBuffer;
+    if (mTFStart[currentBuffer] > tf) {
+      LOGP(info, "All CRUs for current TF {} already received. Skipping this TF", tf);
+      return;
+    }
+
+    const unsigned int relTF = (tf - mTFStart[currentBuffer]) / mNTFsBuffer;
+    LOGP(info, "Current TF: {}, relative TF: {}, current buffer: {}, mTFStart: {}", tf, relTF, currentBuffer, mTFStart[currentBuffer]);
+
+    if (relTF >= mProcessedCRU[currentBuffer].size()) {
+      LOGP(warning, "Skipping tf {}: relative tf {} is larger than size of buffer: {}", tf, relTF, mProcessedCRU[currentBuffer].size());
+
+      // check number of processed CRUs for previous TFs. If CRUs are missing for them, they are probably lost/not received
+      mProcessedTotalData = mCheckEveryNData;
+      checkIntervalsForMissingData(pc, currentBuffer, relTF, tf);
+      return;
+    }
+
+    if (mProcessedCRU[currentBuffer][relTF] == mCRUs.size()) {
+      return;
+    }
+
+    // record the absolute first TF of this aggregation interval
+    if (mIntervalTFCount == 0) {
+      mIntervalFirstTF = tf;
+    }
+
+    // set CCDB start timestamp once at the start of each aggregation interval
+    if (mTimestampStart == 0) {
+      setTimestampCCDB(relTF, pc);
+    }
+
+    // capture orbit/BC info into the interval once per relTF.
+    // all CRUs within a TF carry identical timing, so the first one is sufficient.
+    if (!mOrbitInfoForwarded[currentBuffer][relTF]) {
+      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+        auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+        const unsigned int cru = hdr->subSpecification >> 7;
+        if (std::binary_search(mCRUs.begin(), mCRUs.end(), cru)) {
+          const auto orbitBC = pc.inputs().get<uint64_t>(ref);
+          if (mCurrentTF.firstOrbit == 0 && mCurrentTF.firstBC == 0) {
+            mCurrentTF.firstOrbit = static_cast<uint32_t>(orbitBC >> 32);
+            mCurrentTF.firstBC = static_cast<uint16_t>(orbitBC & 0xFFFFu);
+          }
+          mOrbitInfoForwarded[currentBuffer][relTF] = true;
+          break; // one per relTF is enough
+        }
+      }
+    }
+
+    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+      auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+      const unsigned int cru = tpcCRUHeader->subSpecification >> 7;
+
+      // check if cru is specified in input cru list
+      if (!(std::binary_search(mCRUs.begin(), mCRUs.end(), cru))) {
+        LOGP(info, "Received data from CRU: {} which was not specified as input. Skipping", cru);
+        continue;
+      }
+
+      if (mProcessedCRUs[currentBuffer][relTF][cru]) {
+        continue;
+      } else {
+        // count total number of processed CRUs for given TF
+        ++mProcessedCRU[currentBuffer][relTF];
+
+        // to keep track of processed CRUs
+        mProcessedCRUs[currentBuffer][relTF][cru] = true;
+      }
+
+      // accumulate raw 16-bit CMVs into the flat array for the current TF
+      auto cmvVec = pc.inputs().get<pmr::vector<uint16_t>>(ref);
+      const uint32_t nTimeBins = std::min(static_cast<uint32_t>(cmvVec.size()), cmv::NTimeBinsPerTF);
+      for (uint32_t tb = 0; tb < nTimeBins; ++tb) {
+        mCurrentTF.mDataPerTF[cru * cmv::NTimeBinsPerTF + tb] = cmvVec[tb];
+      }
+    }
+
+    LOGP(info, "Number of received CRUs for current TF: {} Needed a total number of processed CRUs of: {} Current TF: {}", mProcessedCRU[currentBuffer][relTF], mCRUs.size(), tf);
+
+    // check for missing data if specified
+    if (mNTFsDataDrop > 0) {
+      checkIntervalsForMissingData(pc, currentBuffer, relTF, tf);
+    }
+
+    if (mProcessedCRU[currentBuffer][relTF] == mCRUs.size()) {
+      ++mProcessedTFs[currentBuffer];
+
+      // Pre-processing: quantisation / rounding / zeroing (applied before compression)
+      mCurrentTF.roundToIntegers(mRoundIntegersThreshold);
+      if (mZeroThreshold > 0.f) {
+        mCurrentTF.zeroSmallValues(mZeroThreshold);
+      }
+      if (mDynamicPrecisionSigma > 0.f) {
+        mCurrentTF.trimGaussianPrecision(mDynamicPrecisionMean, mDynamicPrecisionSigma);
+      }
+
+      // Compress; the raw CMVPerTF branch is used when all flags are zero
+      const uint8_t flags = buildCompressionFlags();
+      if (flags != CMVEncoding::kNone) {
+        mCurrentCompressedTF = mCurrentTF.compress(flags);
+      }
+
+      mIntervalTree->Fill();
+      ++mIntervalTFCount;
+      mCurrentTF = CMVPerTF{};
+    }
+
+    if (mProcessedTFs[currentBuffer] == mTimeFrames) {
+      sendOutput(pc.outputs(), tf);
+      finishInterval(pc, currentBuffer, tf);
+    }
+  }
+
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final
+  {
+    LOGP(info, "End of stream, flushing CMV interval ({} TFs)", mIntervalTFCount);
+    // correct mTFEnd for the partial last interval so the CCDB validity end timestamp reflects the actual last TF, not the expected interval end
+    mTFEnd[mBuffer] = mLastSeenTF;
+    sendOutput(ec.outputs(), mLastSeenTF);
+    ec.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+  }
+
+  static constexpr header::DataDescription getDataDescriptionCCDBCMV() { return header::DataDescription{"TPC_CMV"}; }
+
+  /// Return data description for aggregated CMVs for a given lane
+  static header::DataDescription getDataDescriptionCMV(const unsigned int lane)
+  {
+    const std::string name = fmt::format("CMVAGG{}", lane).data();
+    header::DataDescription description;
+    description.runtimeInit(name.substr(0, 16).c_str());
+    return description;
+  }
+
+  /// Return data description for orbit/BC info for a given output lane
+  static header::DataDescription getDataDescriptionCMVOrbitInfo(const unsigned int lane)
+  {
+    const std::string name = fmt::format("CMVORB{}", lane);
+    header::DataDescription description;
+    description.runtimeInit(name.substr(0, 16).c_str());
+    return description;
+  }
+
+  static constexpr header::DataDescription getDataDescriptionCMVFirstTF() { return header::DataDescription{"CMVFIRSTTF"}; }
+  static constexpr header::DataDescription getDataDescriptionCMVOrbitReset() { return header::DataDescription{"CMVORBITRESET"}; }
+
+ private:
+  std::vector<uint32_t> mCRUs{};                                                       ///< CRUs to process in this instance
+  const unsigned int mTimeFrames{};                                                    ///< number of TFs per aggregation interval
+  const int mNTFsBuffer{1};                                                            ///< number of TFs for which the CMVs will be buffered
+  std::array<unsigned int, 2> mProcessedTFs{{0, 0}};                                   ///< number of processed time frames to keep track of when the writing to CCDB will be done
+  std::array<std::vector<unsigned int>, 2> mProcessedCRU{};                            ///< counter of received data from CRUs per TF to merge incoming data from FLPs. Buffer used in case one FLP delivers the TF after the last TF for the current aggregation interval faster then the other FLPs the last TF.
+  std::array<std::vector<std::unordered_map<unsigned int, bool>>, 2> mProcessedCRUs{}; ///< to keep track of the already processed CRUs ([buffer][relTF][CRU])
+  std::array<long, 2> mTFStart{};                                                      ///< storing of first TF for buffer interval
+  std::array<long, 2> mTFEnd{};                                                        ///< storing of last TF for buffer interval
+  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;                              ///< info for CCDB request
+  std::vector<bool> mSendCCDBOutputOrbitReset{};                                       ///< flag for received orbit reset time from CCDB
+  std::vector<bool> mSendCCDBOutputGRPECS{};                                           ///< flag for received orbit GRPECS from CCDB
+  bool mBuffer{false};                                                                 ///< buffer index
+  bool mSendCCDB{false};                                                               ///< send output to CCDB populator
+  bool mUsePreciseTimestamp{false};                                                    ///< use precise timestamp from orbit-reset info
+  bool mDumpCMVs{false};                                                               ///< write a local ROOT debug file
+  bool mUseCompressionVarint{false};                                                   ///< use delta+zigzag+varint compression (all values, no sparse skip); combined with mUseSparse → SparseV2 mode 1
+  bool mUseSparse{false};                                                              ///< sparse encoding; alone = raw uint16 values; combined with varint/Huffman flag → SparseV2
+  bool mUseCompressionHuffman{false};                                                  ///< Huffman encoding; combined with mUseSparse → SparseV2 mode 2
+  uint16_t mRoundIntegersThreshold{0};                                                 ///< round values to nearest integer ADC for |v| <= N ADC; 0 = disabled
+  float mZeroThreshold{0.f};                                                           ///< zero out CMV values whose float magnitude is below this threshold; 0 = disabled
+  float mDynamicPrecisionMean{1.f};                                                    ///< Gaussian centre in |CMV| ADC where the strongest fractional-bit trimming is applied
+  float mDynamicPrecisionSigma{0.f};                                                   ///< Gaussian width in ADC for the fractional-bit trimming; 0 disables
+  long mTimestampStart{0};                                                             ///< CCDB validity start timestamp
+  dataformats::Pair<long, int> mTFInfo{};                                              ///< orbit-reset time and NHBFPerTF for precise timestamp
+  std::unique_ptr<TTree> mIntervalTree{};                                              ///< TTree accumulating one entry per completed TF in the current interval
+  CMVPerTF mCurrentTF{};                                                               ///< staging object filled per CRU before compression
+  CMVPerTFCompressed mCurrentCompressedTF{};                                           ///< compressed output for the current TF (used when flags != kNone)
+  long mIntervalFirstTF{0};                                                            ///< absolute TF counter of the first TF in the current aggregation interval
+  unsigned int mIntervalTFCount{0};                                                    ///< number of TTree entries filled for the current aggregation interval
+  int mNFactorTFs{0};                                                                  ///< Number of TFs to skip for sending oldest TF
+  int mNTFsDataDrop{0};                                                                ///< delay for the check if TFs are missing in TF units
+  std::array<int, 2> mStartNTFsDataDrop{0};                                            ///< first relative TF to check
+  long mProcessedTotalData{0};                                                         ///< used to check for dropeed TF data
+  int mCheckEveryNData{1};                                                             ///< factor after which to check for missing data (in case data missing -> send dummy data)
+  std::vector<InputSpec> mFilter{};                                                    ///< filter for looping over input data
+  std::vector<InputSpec> mOrbitFilter{};                                               ///< filter for CMVORBITINFO from FLP
+  std::array<std::vector<bool>, 2> mOrbitInfoForwarded{};                              ///< tracks whether orbit/BC has been captured per (buffer, relTF)
+  uint32_t mLastSeenTF{0};                                                             ///< last TF counter seen in run(), used to set lastTF in endOfStream flush
+
+  /// Returns real number of TFs taking buffer size into account
+  unsigned int getNRealTFs() const { return mNTFsBuffer * mTimeFrames; }
+
+  /// Build the CMVEncoding bitmask from the current option flags.
+  uint8_t buildCompressionFlags() const
+  {
+    uint8_t flags = CMVEncoding::kNone;
+    if (mUseSparse) {
+      flags |= CMVEncoding::kSparse;
+    }
+    if (mUseCompressionHuffman) {
+      flags |= CMVEncoding::kZigzag | CMVEncoding::kHuffman;
+    } else if (mUseCompressionVarint) {
+      flags |= CMVEncoding::kZigzag | CMVEncoding::kVarint;
+    }
+    // Delta coding is only applied for the dense (non-sparse) path with a value compressor
+    if (!(flags & CMVEncoding::kSparse) && (flags & (CMVEncoding::kVarint | CMVEncoding::kHuffman))) {
+      flags |= CMVEncoding::kDelta;
+    }
+    return flags;
+  }
+
+  /// Create a fresh in-memory TTree for the next aggregation interval.
+  /// Uses a single CMVPerTFCompressed branch whenever any compression is active,
+  /// or a raw CMVPerTF branch when no compression flags are set.
+  void initIntervalTree()
+  {
+    mIntervalTree = std::make_unique<TTree>("ccdb_object", "ccdb_object");
+    mIntervalTree->SetAutoSave(0);
+    mIntervalTree->SetDirectory(nullptr);
+    if (buildCompressionFlags() != CMVEncoding::kNone) {
+      mIntervalTree->Branch("CMVPerTFCompressed", &mCurrentCompressedTF);
+    } else {
+      mIntervalTree->Branch("CMVPerTF", &mCurrentTF);
+    }
+  }
+
+  void clearBuffer(const bool currentBuffer)
+  {
+    // resetting received CRUs
+    for (auto& crusMap : mProcessedCRUs[currentBuffer]) {
+      for (auto& it : crusMap) {
+        it.second = false;
+      }
+    }
+
+    mProcessedTFs[currentBuffer] = 0; // reset processed TFs for next aggregation interval
+    std::fill(mProcessedCRU[currentBuffer].begin(), mProcessedCRU[currentBuffer].end(), 0);
+    std::fill(mOrbitInfoForwarded[currentBuffer].begin(), mOrbitInfoForwarded[currentBuffer].end(), false);
+
+    // set integration range for next integration interval
+    mTFStart[mBuffer] = mTFEnd[!mBuffer] + 1;
+    mTFEnd[mBuffer] = mTFStart[mBuffer] + getNRealTFs() - 1;
+
+    // switch buffer
+    mBuffer = !mBuffer;
+  }
+
+  void checkIntervalsForMissingData(o2::framework::ProcessingContext& pc, const bool currentBuffer, const long relTF, const uint32_t tf)
+  {
+    if (!(mProcessedTotalData++ % mCheckEveryNData)) {
+      LOGP(info, "Checking for dropped packages...");
+
+      // if last buffer has smaller time range check the whole last buffer
+      if ((mTFStart[currentBuffer] > mTFStart[!currentBuffer]) && (relTF > mNTFsDataDrop)) {
+        LOGP(warning, "Checking last buffer from {} to {}", mStartNTFsDataDrop[!currentBuffer], mProcessedCRU[!currentBuffer].size());
+        checkMissingData(pc, !currentBuffer, mStartNTFsDataDrop[!currentBuffer], mProcessedCRU[!currentBuffer].size());
+        LOGP(info, "All empty TFs for TF {} for current buffer filled with dummy and sent. Clearing buffer", tf);
+        sendOutput(pc.outputs(), tf);
+        finishInterval(pc, !currentBuffer, tf);
+      }
+
+      const int tfEndCheck = std::clamp(static_cast<int>(relTF) - mNTFsDataDrop, 0, static_cast<int>(mProcessedCRU[currentBuffer].size()));
+      LOGP(info, "Checking current buffer from {} to {}", mStartNTFsDataDrop[currentBuffer], tfEndCheck);
+      checkMissingData(pc, currentBuffer, mStartNTFsDataDrop[currentBuffer], tfEndCheck);
+      mStartNTFsDataDrop[currentBuffer] = tfEndCheck;
+    }
+  }
+
+  void checkMissingData(o2::framework::ProcessingContext& pc, const bool currentBuffer, const int startTF, const int endTF)
+  {
+    for (int iTF = startTF; iTF < endTF; ++iTF) {
+      if (mProcessedCRU[currentBuffer][iTF] != mCRUs.size()) {
+        LOGP(warning, "CRUs for rel. TF: {}  curr TF {} are missing! Processed {} CRUs out of {}", iTF, mTFStart[currentBuffer] + iTF, mProcessedCRU[currentBuffer][iTF], mCRUs.size());
+        ++mProcessedTFs[currentBuffer];
+        mProcessedCRU[currentBuffer][iTF] = mCRUs.size();
+
+        // find missing CRUs and leave their interval slots empty (zero-filled)
+        for (auto& it : mProcessedCRUs[currentBuffer][iTF]) {
+          if (!it.second) {
+            it.second = true;
+          }
+        }
+
+        // leave orbit/BC as zero placeholder for missing TFs
+        mOrbitInfoForwarded[currentBuffer][iTF] = true;
+      }
+    }
+  }
+
+  void finishInterval(o2::framework::ProcessingContext& pc, const bool buffer, const uint32_t tf)
+  {
+    if (mNFactorTFs > 0) {
+      mNFactorTFs = 0;
+      // ToDo: Find better fix
+      auto& deviceProxy = pc.services().get<FairMQDeviceProxy>();
+      if (deviceProxy.getNumOutputChannels() > 0) {
+        auto& state = deviceProxy.getOutputChannelState({0});
+        size_t oldest = std::numeric_limits<size_t>::max() - 1; // just set to really large value
+        state.oldestForChannel = {oldest};
+      }
+    }
+
+    LOGP(info, "All TFs {} for current buffer received. Clearing buffer", tf);
+    clearBuffer(buffer);
+    mStartNTFsDataDrop[buffer] = 0;
+
+    // reset per-interval state for the next aggregation interval
+    initIntervalTree();
+    mIntervalFirstTF = 0;
+    mIntervalTFCount = 0;
+    mCurrentTF = CMVPerTF{};
+    mCurrentCompressedTF = CMVPerTFCompressed{};
+    mTimestampStart = 0;
+    LOGP(info, "Everything cleared. Waiting for new data to arrive.");
+  }
+
+  void setTimestampCCDB(const long relTF, o2::framework::ProcessingContext& pc)
+  {
+    if (mUsePreciseTimestamp && !mTFInfo.second) {
+      return;
+    }
+    const auto& tinfo = pc.services().get<o2::framework::TimingInfo>();
+    const auto nOrbitsOffset = (relTF * mNTFsBuffer + (mNTFsBuffer - 1)) * mTFInfo.second;
+    mTimestampStart = mUsePreciseTimestamp
+                        ? (mTFInfo.first + (tinfo.firstTForbit - nOrbitsOffset) * o2::constants::lhc::LHCOrbitMUS * 0.001)
+                        : tinfo.creation;
+    LOGP(info, "Setting timestamp reset reference to: {}, at tfCounter: {}, firstTForbit: {}, NHBFPerTF: {}, relTF: {}, nOrbitsOffset: {}",
+         mTFInfo.first, tinfo.tfCounter, tinfo.firstTForbit, mTFInfo.second, relTF, nOrbitsOffset);
+  }
+
+  void sendOutput(DataAllocator& output, const uint32_t tf)
+  {
+    using timer = std::chrono::high_resolution_clock;
+
+    if (mIntervalTFCount == 0) {
+      LOGP(warning, "CMV interval is empty at sendOutput, skipping");
+      return;
+    }
+
+    // attach interval metadata to the TTree (stored once per tree)
+    mIntervalTree->GetUserInfo()->Clear();
+    mIntervalTree->GetUserInfo()->Add(new TParameter<long>("firstTF", mIntervalFirstTF));
+    mIntervalTree->GetUserInfo()->Add(new TParameter<long>("lastTF", mLastSeenTF));
+
+    LOGP(info, "CMVPerTF TTree: {} entries, firstTF={}, lastTF={}", mIntervalTFCount, mIntervalFirstTF, mLastSeenTF);
+    auto start = timer::now();
+
+    // write local ROOT file for debugging
+    if (mDumpCMVs) {
+      const std::string fname = fmt::format("CMV_timestamp{}.root", mTimestampStart);
+      try {
+        mCurrentTF.writeToFile(fname, mIntervalTree);
+        LOGP(info, "CMV debug file written to {}", fname);
+      } catch (const std::exception& e) {
+        LOGP(error, "Failed to write CMV debug file: {}", e.what());
+      }
+    }
+
+    if (!mSendCCDB) {
+      LOGP(warning, "CCDB output disabled, skipping upload!");
+      return;
+    }
+
+    const int nHBFPerTF = o2::base::GRPGeomHelper::instance().getNHBFPerTF();
+    // use the actual number of TFs in this interval (mIntervalTFCount) rather than mTimeFrames, so the CCDB validity end is correct for partial last intervals
+    const long timeStampEnd = mTimestampStart + static_cast<long>(mIntervalTFCount * mNTFsBuffer * nHBFPerTF * o2::constants::lhc::LHCOrbitMUS * 1e-3);
+
+    if (timeStampEnd <= mTimestampStart) {
+      LOGP(warning, "Invalid CCDB timestamp range start:{} end:{}, skipping upload!",
+           mTimestampStart, timeStampEnd);
+      return;
+    }
+
+    LOGP(info, "CCDB timestamp range start:{} end:{}", mTimestampStart, timeStampEnd);
+
+    o2::ccdb::CcdbObjectInfo ccdbInfoCMV(
+      "TPC/Calib/CMV",
+      "TTree",
+      "CMV.root",
+      {},
+      mTimestampStart,
+      timeStampEnd);
+
+    auto image = o2::ccdb::CcdbApi::createObjectImage((mIntervalTree.get()), &ccdbInfoCMV);
+    // trim TMemFile zero-padding: GetSize() is block-rounded, GetEND() is the actual file end
+    {
+      TMemFile mf("trim", image->data(), static_cast<Long64_t>(image->size()), "READ");
+      image->resize(static_cast<size_t>(mf.GetEND()));
+      mf.Close();
+    }
+    LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {}",
+         ccdbInfoCMV.getPath(), ccdbInfoCMV.getFileName(), image->size(),
+         ccdbInfoCMV.getStartValidityTimestamp(), ccdbInfoCMV.getEndValidityTimestamp());
+
+    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBCMV(), 0}, *image);
+    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBCMV(), 0}, ccdbInfoCMV);
+
+    auto stop = timer::now();
+    std::chrono::duration<float> elapsed = stop - start;
+    LOGP(info, "CMV CCDB serialisation time: {:.3f} s", elapsed.count());
+  }
+};
+
+DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const unsigned int timeframes, const int firstTF, const bool sendCCDB = false, const bool usePreciseTimestamp = false, const int nTFsBuffer = 1)
+{
+  std::vector<InputSpec> inputSpecs;
+  inputSpecs.emplace_back(InputSpec{"cmvsgroup", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, Lifetime::Sporadic});
+  inputSpecs.emplace_back(InputSpec{"cmvorbit", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo()}, Lifetime::Sporadic});
+
+  std::vector<OutputSpec> outputSpecs;
+  if (sendCCDB) {
+    outputSpecs.emplace_back(
+      ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload,
+                              TPCDistributeCMVSpec::getDataDescriptionCCDBCMV()},
+      Lifetime::Sporadic);
+    outputSpecs.emplace_back(
+      ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper,
+                              TPCDistributeCMVSpec::getDataDescriptionCCDBCMV()},
+      Lifetime::Sporadic);
+  }
+
+  const bool fetchCCDB = usePreciseTimestamp;
+  auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(fetchCCDB,                      // orbitResetTime
+                                                                fetchCCDB,                      // GRPECS=true
+                                                                false,                          // GRPLHCIF
+                                                                false,                          // GRPMagField
+                                                                false,                          // askMatLUT
+                                                                o2::base::GRPGeomRequest::None, // geometry
+                                                                inputSpecs);
+
+  const std::string type = "cmv";
+  const auto id = fmt::format("tpc-distribute-{}-{:02}", type, ilane);
+  DataProcessorSpec spec{
+    id.data(),
+    inputSpecs,
+    outputSpecs,
+    AlgorithmSpec{adaptFromTask<TPCDistributeCMVSpec>(crus, timeframes, nTFsBuffer, firstTF, sendCCDB, usePreciseTimestamp, ccdbRequest)},
+    Options{{"drop-data-after-nTFs", VariantType::Int, 0, {"Number of TFs after which to drop the data"}},
+            {"check-data-every-n", VariantType::Int, 0, {"Number of run function called after which to check for missing data (-1 for no checking, 0 for default checking)"}},
+            {"nFactorTFs", VariantType::Int, 1000, {"Number of TFs to skip for sending oldest TF"}},
+            {"dump-cmvs", VariantType::Bool, false, {"Dump CMVs to a local ROOT file for debugging"}},
+            {"use-sparse", VariantType::Bool, false, {"Sparse encoding (skip zero time bins). Alone: raw uint16 values. With --use-compression-varint: varint exact values. With --use-compression-huffman: Huffman exact values"}},
+            {"use-compression-varint", VariantType::Bool, false, {"Delta+zigzag+varint compression (all values). Combined with --use-sparse: sparse positions + varint encoded exact CMV values"}},
+            {"use-compression-huffman", VariantType::Bool, false, {"Huffman encoding. Combined with --use-sparse: sparse positions + Huffman-encoded exact CMV values"}},
+            {"cmv-zero-threshold", VariantType::Float, 0.f, {"Zero out CMV values whose float magnitude is below this threshold after optional integer rounding and before compression; 0 disables"}},
+            {"cmv-round-integers-threshold", VariantType::Int, 0, {"Round values to nearest integer ADC for |v| <= N ADC before compression; 0 disables"}},
+            {"cmv-dynamic-precision-mean", VariantType::Float, 1.f, {"Gaussian centre in |CMV| ADC where the strongest fractional bit trimming is applied"}},
+            {"cmv-dynamic-precision-sigma", VariantType::Float, 0.f, {"Gaussian width in ADC for smooth CMV fractional bit trimming; 0 disables"}}}}; // end DataProcessorSpec
+
+  spec.rank = ilane;
+  return spec;
+}
+
+} // namespace o2::tpc
+
+#endif
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
new file mode 100644
index 0000000000000..9931c27c9d3fa
--- /dev/null
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
@@ -0,0 +1,172 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file TPCFLPCMVSpec.h
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief TPC device for processing CMVs on FLPs
+
+#ifndef O2_TPCFLPIDCSPEC_H
+#define O2_TPCFLPIDCSPEC_H
+
+#include <vector>
+#include <unordered_map>
+#include <fmt/format.h>
+#include "Framework/Task.h"
+#include "Framework/ControlService.h"
+#include "Framework/Logger.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/InputRecordWalker.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Headers/DataHeader.h"
+#include "TPCWorkflow/ProcessingHelpers.h"
+#include "TPCBase/CRU.h"
+#include "TFile.h"
+
+using namespace o2::framework;
+using o2::header::gDataOriginTPC;
+using namespace o2::tpc;
+
+namespace o2::tpc
+{
+
+class TPCFLPCMVDevice : public o2::framework::Task
+{
+ public:
+  TPCFLPCMVDevice(const int lane, const std::vector<uint32_t>& crus, const int nTFsBuffer)
+    : mLane{lane}, mCRUs{crus}, mNTFsBuffer{nTFsBuffer} {}
+
+  void init(o2::framework::InitContext& ic) final
+  {
+    mDumpCMVs = ic.options().get<bool>("dump-cmvs-flp");
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    LOGP(debug, "Processing CMVs for TF {} for CRUs {} to {}", processing_helpers::getCurrentTF(pc), mCRUs.front(), mCRUs.back());
+
+    ++mCountTFsForBuffer;
+
+    // Capture heartbeatOrbit / heartbeatBC from the first TF in the buffer
+    if (mCountTFsForBuffer == 1) {
+      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+        auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+        const uint32_t cru = hdr->subSpecification >> 7;
+        if (mFirstOrbitBC.find(cru) == mFirstOrbitBC.end()) {
+          auto orbitVec = pc.inputs().get<std::vector<uint64_t>>(ref);
+          if (!orbitVec.empty()) {
+            mFirstOrbitBC[cru] = orbitVec[0]; // packed: orbit<<32 | bc
+          }
+        }
+      }
+    }
+
+    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+      auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+      const int cru = tpcCRUHeader->subSpecification >> 7;
+      auto vecCMVs = pc.inputs().get<o2::pmr::vector<uint16_t>>(ref);
+      mCMVs[cru].insert(mCMVs[cru].end(), vecCMVs.begin(), vecCMVs.end());
+    }
+
+    if (mCountTFsForBuffer >= mNTFsBuffer) {
+      mCountTFsForBuffer = 0;
+      for (const auto cru : mCRUs) {
+        LOGP(debug, "Sending CMVs of size {} for TF {}", mCMVs[cru].size(), processing_helpers::getCurrentTF(pc));
+        sendOutput(pc.outputs(), cru);
+      }
+      mFirstOrbitBC.clear();
+    }
+
+    if (mDumpCMVs) {
+      TFile fOut(fmt::format("CMVs_{}_tf_{}.root", mLane, processing_helpers::getCurrentTF(pc)).data(), "RECREATE");
+      for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+        auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+        const int cru = tpcCRUHeader->subSpecification >> 7;
+        auto vec = pc.inputs().get<std::vector<uint16_t>>(ref);
+        fOut.WriteObject(&vec, fmt::format("CRU_{}", cru).data());
+      }
+    }
+  }
+
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final
+  {
+    if (mCountTFsForBuffer > 0) {
+      LOGP(info, "Flushing remaining {} buffered TFs at end of stream", mCountTFsForBuffer);
+      for (const auto cru : mCRUs) {
+        sendOutput(ec.outputs(), cru);
+      }
+    }
+    ec.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+  }
+
+  static constexpr header::DataDescription getDataDescriptionCMVGroup() { return header::DataDescription{"CMVGROUP"}; }
+
+  /// Data description for the packed (orbit<<32|bc) scalar forwarded alongside each CRU's CMVGROUP.
+  static constexpr header::DataDescription getDataDescriptionCMVOrbitInfo() { return header::DataDescription{"CMVORBITINFO"}; }
+
+ private:
+  const int mLane{};                                                   ///< lane number of processor
+  const std::vector<uint32_t> mCRUs{};                                 ///< CRUs to process in this instance
+  int mNTFsBuffer{1};                                                  ///< number of TFs to buffer before sending
+  bool mDumpCMVs{};                                                    ///< dump CMVs to file for debugging
+  int mCountTFsForBuffer{0};                                           ///< counts TFs to track when to send output
+  std::unordered_map<unsigned int, o2::pmr::vector<uint16_t>> mCMVs{}; ///< buffered raw 16-bit CMV values per CRU
+  std::unordered_map<uint32_t, uint64_t> mFirstOrbitBC{};              ///< first packed orbit/BC per CRU for the current buffer window
+
+  /// Filter for CMV float vectors (one CMVVECTOR message per CRU per TF)
+  const std::vector<InputSpec> mFilter = {{"cmvs", ConcreteDataTypeMatcher{gDataOriginTPC, "CMVVECTOR"}, Lifetime::Timeframe}};
+  /// Filter for CMV packet timing info (one CMVORBITS message per CRU per TF, sent by CMVToVectorSpec)
+  const std::vector<InputSpec> mOrbitFilter = {{"cmvorbits", ConcreteDataTypeMatcher{gDataOriginTPC, "CMVORBITS"}, Lifetime::Timeframe}};
+
+  void sendOutput(DataAllocator& output, const uint32_t cru)
+  {
+    const header::DataHeader::SubSpecificationType subSpec{cru << 7};
+
+    // Forward the first-TF orbit/BC for this CRU (0 if unavailable for any reason)
+    uint64_t orbitBC = 0;
+    if (auto it = mFirstOrbitBC.find(cru); it != mFirstOrbitBC.end()) {
+      orbitBC = it->second;
+    }
+    output.snapshot(Output{gDataOriginTPC, getDataDescriptionCMVOrbitInfo(), subSpec}, orbitBC);
+
+    output.adoptContainer(Output{gDataOriginTPC, getDataDescriptionCMVGroup(), subSpec}, std::move(mCMVs[cru]));
+  }
+};
+
+DataProcessorSpec getTPCFLPCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const int nTFsBuffer = 1)
+{
+  std::vector<OutputSpec> outputSpecs;
+  std::vector<InputSpec> inputSpecs;
+  outputSpecs.reserve(crus.size());
+  inputSpecs.reserve(crus.size());
+
+  for (const auto& cru : crus) {
+    const header::DataHeader::SubSpecificationType subSpec{cru << 7};
+
+    // Inputs from CMVToVectorSpec
+    inputSpecs.emplace_back(InputSpec{"cmvs", gDataOriginTPC, "CMVVECTOR", subSpec, Lifetime::Timeframe});
+    inputSpecs.emplace_back(InputSpec{"cmvorbits", gDataOriginTPC, "CMVORBITS", subSpec, Lifetime::Timeframe});
+
+    // Outputs to TPCDistributeCMVSpec
+    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup(), subSpec}, Lifetime::Sporadic);
+    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo(), subSpec}, Lifetime::Sporadic);
+  }
+
+  const auto id = fmt::format("tpc-flp-cmv-{:02}", ilane);
+  return DataProcessorSpec{
+    id.data(),
+    inputSpecs,
+    outputSpecs,
+    AlgorithmSpec{adaptFromTask<TPCFLPCMVDevice>(ilane, crus, nTFsBuffer)},
+    Options{{"dump-cmvs-flp", VariantType::Bool, false, {"Dump CMVs to file"}}}};
+}
+
+} // namespace o2::tpc
+#endif
\ No newline at end of file
diff --git a/Detectors/TPC/workflow/src/CMVToVectorSpec.cxx b/Detectors/TPC/workflow/src/CMVToVectorSpec.cxx
new file mode 100644
index 0000000000000..81ce358d1a809
--- /dev/null
+++ b/Detectors/TPC/workflow/src/CMVToVectorSpec.cxx
@@ -0,0 +1,434 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   CMVToVectorSpec.cxx
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  Processor to convert CMVs to a vector in a CRU
+
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <vector>
+#include <string>
+#include <fstream>
+#include <algorithm>
+#include <fmt/format.h>
+#include <fmt/chrono.h>
+
+#include "TFile.h"
+#include "DetectorsRaw/RDHUtils.h"
+#include "Framework/Task.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/Logger.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/WorkflowSpec.h"
+#include "Framework/InputRecordWalker.h"
+#include "Framework/DataRefUtils.h"
+#include "DPLUtils/RawParser.h"
+#include "Headers/DataHeader.h"
+#include "Headers/DataHeaderHelpers.h"
+#include "CommonUtils/TreeStreamRedirector.h"
+
+#include "DataFormatsTPC/CMV.h"
+#include "DataFormatsTPC/RawDataTypes.h"
+#include "TPCBase/RDHUtils.h"
+#include "TPCBase/Mapper.h"
+#include "TPCWorkflow/ProcessingHelpers.h"
+
+using namespace o2::framework;
+using o2::header::gDataOriginTPC;
+using RDHUtils = o2::raw::RDHUtils;
+using RawDataType = o2::tpc::raw_data_types::Type;
+
+namespace o2::tpc
+{
+
+class CMVToVectorDevice : public o2::framework::Task
+{
+ public:
+  using FEEIDType = rdh_utils::FEEIDType;
+  CMVToVectorDevice(const std::vector<uint32_t>& crus) : mCRUs(crus) {}
+
+  void init(o2::framework::InitContext& ic) final
+  {
+    // set up ADC value filling
+    mWriteDebug = ic.options().get<bool>("write-debug");
+    mWriteDebugOnError = ic.options().get<bool>("write-debug-on-error");
+    mWriteRawDataOnError = ic.options().get<bool>("write-raw-data-on-error");
+    mRawDataType = ic.options().get<int>("raw-data-type");
+    o2::framework::RawParser<>::setCheckIncompleteHBF(ic.options().get<bool>("check-incomplete-hbf"));
+
+    mDebugStreamFileName = ic.options().get<std::string>("debug-file-name").data();
+    mRawOutputFileName = ic.options().get<std::string>("raw-file-name").data();
+
+    initCMV();
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    const auto runNumber = processing_helpers::getRunNumber(pc);
+    std::vector<InputSpec> filter = {{"check", ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, "RAWDATA"}, Lifetime::Timeframe}};
+    const auto& mapper = Mapper::instance();
+
+    // open files if necessary
+    if ((mWriteDebug || mWriteDebugOnError) && !mDebugStream) {
+      const auto debugFileName = fmt::format(fmt::runtime(mDebugStreamFileName), fmt::arg("run", runNumber));
+      LOGP(info, "Creating debug stream {}", debugFileName);
+      mDebugStream = std::make_unique<o2::utils::TreeStreamRedirector>(debugFileName.data(), "recreate");
+    }
+
+    if (mWriteRawDataOnError && !mRawOutputFile.is_open()) {
+      std::string_view rawType = (mRawDataType < 2) ? "tf" : "raw";
+      if (mRawDataType == 5) {
+        rawType = "cmv.raw";
+      }
+      const auto rawFileName = fmt::format(fmt::runtime(mRawOutputFileName), fmt::arg("run", runNumber), fmt::arg("raw_type", rawType));
+      LOGP(info, "Creating raw debug file {}", rawFileName);
+      mRawOutputFile.open(rawFileName, std::ios::binary);
+    }
+
+    uint32_t heartbeatOrbit = 0;
+    uint16_t heartbeatBC = 0;
+    uint32_t tfCounter = 0;
+    bool first = true;
+    bool hasErrors = false;
+
+    for (auto const& ref : InputRecordWalker(pc.inputs(), filter)) {
+      const auto* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+      tfCounter = dh->tfCounter;
+      const auto subSpecification = dh->subSpecification;
+      auto payloadSize = DataRefUtils::getPayloadSize(ref);
+      LOGP(debug, "Processing TF {}, subSpecification {}, payloadSize {}", tfCounter, subSpecification, payloadSize);
+
+      // ---| data loop |---
+      const gsl::span<const char> raw = pc.inputs().get<gsl::span<char>>(ref);
+      try {
+        o2::framework::RawParser parser(raw.data(), raw.size());
+        size_t lastErrorCount = 0;
+
+        for (auto it = parser.begin(), end = parser.end(); it != end; ++it) {
+          const auto size = it.size();
+
+          if (parser.getNErrors() > lastErrorCount) {
+            lastErrorCount = parser.getNErrors();
+            hasErrors = true;
+          }
+
+          // skip empty packages (HBF open)
+          if (size == 0) {
+            continue;
+          }
+
+          auto rdhPtr = reinterpret_cast<const o2::header::RDHAny*>(it.raw());
+          const auto rdhVersion = RDHUtils::getVersion(rdhPtr);
+          if (!rdhPtr || rdhVersion < 6) {
+            throw std::runtime_error(fmt::format("could not get RDH from packet, or version {} < 6", rdhVersion).data());
+          }
+
+          // ---| extract hardware information to do the processing |---
+          const auto feeId = (FEEIDType)RDHUtils::getFEEID(*rdhPtr);
+          const auto link = rdh_utils::getLink(feeId);
+          const uint32_t cruID = rdh_utils::getCRU(feeId);
+          const auto detField = RDHUtils::getDetectorField(*rdhPtr);
+
+          LOGP(debug, "Detected CMV packet: CRU {}, link {}, feeId {}", cruID, link, feeId);
+
+          if ((detField != (decltype(detField))RawDataType::CMV) || (link != rdh_utils::CMVLinkID)) {
+            LOGP(debug, "Skipping packet: detField {}, (expected RawDataType {}), link {}, (expected CMVLinkID {})", detField, (decltype(detField))RawDataType::CMV, link, rdh_utils::CMVLinkID);
+            continue;
+          }
+
+          LOGP(debug, "Processing firstTForbit {:9}, tfCounter {:5}, run {:6}, feeId {:6}, cruID {:3}, link {:2}", dh->firstTForbit, dh->tfCounter, dh->runNumber, feeId, cruID, link);
+
+          if (std::find(mCRUs.begin(), mCRUs.end(), cruID) == mCRUs.end()) {
+            LOGP(warning, "CMV CRU {:3} not configured in CRUs, skipping", cruID);
+            continue;
+          }
+
+          auto& cmvVec = mCMVvectors[cruID];
+          auto& infoVec = mCMVInfos[cruID];
+
+          if (size != sizeof(cmv::Container)) {
+            LOGP(warning, "CMV packet size mismatch: got {} bytes, expected {} bytes (sizeof cmv::Container). Skipping package.", size, sizeof(cmv::Container));
+            hasErrors = true;
+            continue;
+          }
+          auto data = it.data();
+          auto& cmvs = *((cmv::Container*)(data));
+          const uint32_t orbit = cmvs.header.heartbeatOrbit;
+          const uint16_t bc = cmvs.header.heartbeatBC;
+
+          // record packet meta and append its CMV vector (3564 TB)
+          infoVec.emplace_back(orbit, bc);
+          cmvVec.reserve(cmvVec.size() + cmv::NTimeBinsPerPacket);
+          for (uint32_t tb = 0; tb < cmv::NTimeBinsPerPacket; ++tb) {
+            cmvVec.push_back(cmvs.getCMV(tb));
+            // LOGP(debug, "Appended CMV {} for timebin {}, CRU {}, orbit {}, bc {}", cmvs.getCMV(tb), tb, cruID, orbit, bc);
+          }
+        }
+      } catch (const std::exception& e) {
+        // error message throtteling
+        using namespace std::literals::chrono_literals;
+        static std::unordered_map<uint32_t, size_t> nErrorPerSubspec;
+        static std::chrono::time_point<std::chrono::steady_clock> lastReport = std::chrono::steady_clock::now();
+        const auto now = std::chrono::steady_clock::now();
+        static size_t reportedErrors = 0;
+        const size_t MAXERRORS = 10;
+        const auto sleepTime = 10min;
+        ++nErrorPerSubspec[subSpecification];
+
+        if ((now - lastReport) < sleepTime) {
+          if (reportedErrors < MAXERRORS) {
+            ++reportedErrors;
+            std::string sleepInfo;
+            if (reportedErrors == MAXERRORS) {
+              sleepInfo = fmt::format(", maximum error count ({}) reached, not reporting for the next {}", MAXERRORS, sleepTime);
+            }
+            LOGP(alarm, "EXCEPTION in processRawData: {} -> skipping part:{}/{} of spec:{}/{}/{}, size:{}, error count for subspec: {}{}", e.what(), dh->splitPayloadIndex, dh->splitPayloadParts,
+                 dh->dataOrigin, dh->dataDescription, subSpecification, payloadSize, nErrorPerSubspec.at(subSpecification), sleepInfo);
+            lastReport = now;
+          }
+        } else {
+          lastReport = now;
+          reportedErrors = 0;
+        }
+        continue;
+      }
+    }
+
+    hasErrors |= snapshotCMVs(pc.outputs(), tfCounter);
+
+    if (mWriteDebug || (mWriteDebugOnError && hasErrors)) {
+      writeDebugOutput(tfCounter);
+    }
+
+    if (mWriteRawDataOnError && hasErrors) {
+      writeRawData(pc.inputs());
+    }
+
+    // clear output
+    initCMV();
+  }
+
+  void closeFiles()
+  {
+    LOGP(info, "closeFiles");
+
+    if (mDebugStream) {
+      // set some default aliases
+      auto& stream = (*mDebugStream) << "cmvs";
+      auto& tree = stream.getTree();
+      tree.SetAlias("sector", "int(cru/10)");
+      mDebugStream->Close();
+      mDebugStream.reset(nullptr);
+      mRawOutputFile.close();
+    }
+  }
+
+  void stop() final
+  {
+    LOGP(info, "stop");
+    closeFiles();
+  }
+
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final
+  {
+    LOGP(info, "endOfStream");
+    // ec.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+    closeFiles();
+  }
+
+ private:
+  /// CMV information for each cru
+  struct CMVInfo {
+    CMVInfo() = default;
+    CMVInfo(const CMVInfo&) = default;
+    CMVInfo(uint32_t orbit, uint16_t bc) : heartbeatOrbit(orbit), heartbeatBC(bc) {}
+
+    uint32_t heartbeatOrbit{0};
+    uint16_t heartbeatBC{0};
+
+    bool operator==(const uint32_t orbit) const { return (heartbeatOrbit == orbit); }
+    bool operator==(const CMVInfo& inf) const { return (inf.heartbeatOrbit == heartbeatOrbit) && (inf.heartbeatBC == heartbeatBC); }
+    bool matches(uint32_t orbit, int16_t bc) const { return ((heartbeatOrbit == orbit) && (heartbeatBC == bc)); }
+  };
+
+  int mRawDataType{0};                                             ///< type of raw data to dump in case of errors
+  bool mWriteDebug{false};                                         ///< write a debug output
+  bool mWriteDebugOnError{false};                                  ///< write a debug output in case of errors
+  bool mWriteRawDataOnError{false};                                ///< write raw data in case of errors
+  std::vector<uint32_t> mCRUs;                                     ///< CRUs expected for this device
+  std::unordered_map<uint32_t, std::vector<uint16_t>> mCMVvectors; ///< raw 16-bit CMV values per cru over all CMV packets in the TF
+  std::unordered_map<uint32_t, std::vector<CMVInfo>> mCMVInfos;    ///< CMV packet information within the TF
+  std::string mDebugStreamFileName;                                ///< name of the debug stream output file
+  std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugStream;   ///< debug output streamer
+  std::ofstream mRawOutputFile;                                    ///< raw output file
+  std::string mRawOutputFileName;                                  ///< name of the raw output file
+
+  //____________________________________________________________________________
+  bool snapshotCMVs(DataAllocator& output, uint32_t tfCounter)
+  {
+    bool hasErrors = false;
+
+    // send data per CRU with its own orbit/BC vector
+    for (auto& [cru, cmvVec] : mCMVvectors) {
+      const header::DataHeader::SubSpecificationType subSpec{cru << 7};
+      const auto& infVec = mCMVInfos[cru];
+
+      if (infVec.size() != 4) {
+        // LOGP(error, "CRU {:3}: expected 4 packets per TF, got {}", cru, infVec.size());
+        hasErrors = true;
+      }
+      if (cmvVec.size() != cmv::NTimeBinsPerPacket * infVec.size()) {
+        // LOGP(error, "CRU {:3}: vector size {} does not match expected {}", cru, cmvVec.size(), cmv::NTimeBinsPerPacket * infVec.size());
+        hasErrors = true;
+      }
+
+      std::vector<uint64_t> orbitBCInfo;
+      orbitBCInfo.reserve(infVec.size());
+      for (const auto& inf : infVec) {
+        orbitBCInfo.emplace_back((uint64_t(inf.heartbeatOrbit) << 32) + uint64_t(inf.heartbeatBC));
+      }
+
+      LOGP(debug, "Sending CMVs for CRU {} of size {} ({} packets)", cru, cmvVec.size(), infVec.size());
+      output.snapshot(Output{gDataOriginTPC, "CMVVECTOR", subSpec}, cmvVec);
+      output.snapshot(Output{gDataOriginTPC, "CMVORBITS", subSpec}, orbitBCInfo);
+    }
+
+    return hasErrors;
+  }
+
+  //____________________________________________________________________________
+  void initCMV()
+  {
+    for (const auto cruID : mCRUs) {
+      auto& cmvVec = mCMVvectors[cruID];
+      cmvVec.clear();
+
+      auto& infosCRU = mCMVInfos[cruID];
+      infosCRU.clear();
+    }
+  }
+
+  //____________________________________________________________________________
+  void writeDebugOutput(uint32_t tfCounter)
+  {
+    const auto& mapper = Mapper::instance();
+
+    mDebugStream->GetFile()->cd();
+    auto& stream = (*mDebugStream) << "cmvs";
+    uint32_t seen = 0;
+    static uint32_t firstOrbit = std::numeric_limits<uint32_t>::max();
+
+    for (auto cru : mCRUs) {
+      if (mCMVInfos.find(cru) == mCMVInfos.end()) {
+        continue;
+      }
+
+      auto& infos = mCMVInfos[cru];
+      auto& cmvVec = mCMVvectors[cru];
+
+      stream << "cru=" << cru
+             << "tfCounter=" << tfCounter
+             << "nCMVs=" << cmvVec.size()
+             << "cmvs=" << cmvVec
+             << "\n";
+    }
+  }
+
+  void writeRawData(InputRecord& inputs)
+  {
+    if (!mRawOutputFile.is_open()) {
+      return;
+    }
+
+    using DataHeader = o2::header::DataHeader;
+
+    std::vector<InputSpec> filter = {{"check", ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, "RAWDATA"}, Lifetime::Timeframe}};
+    for (auto const& ref : InputRecordWalker(inputs, filter)) {
+      auto dh = DataRefUtils::getHeader<header::DataHeader*>(ref);
+      // LOGP(info, "write header: {}/{}/{}, payload size: {} / {}", dh->dataOrigin, dh->dataDescription, dh->subSpecification, dh->payloadSize, ref.payloadSize);
+      if (((mRawDataType == 1) || (mRawDataType == 3)) && (dh->payloadSize == 2 * sizeof(o2::header::RAWDataHeader))) {
+        continue;
+      }
+
+      if (mRawDataType < 2) {
+        mRawOutputFile.write(ref.header, sizeof(DataHeader));
+      }
+      if (mRawDataType < 5) {
+        mRawOutputFile.write(ref.payload, ref.payloadSize);
+      }
+
+      if (mRawDataType == 5) {
+        const gsl::span<const char> raw = inputs.get<gsl::span<char>>(ref);
+        try {
+          o2::framework::RawParser parser(raw.data(), raw.size());
+          for (auto it = parser.begin(), end = parser.end(); it != end; ++it) {
+            const auto size = it.size();
+            // skip empty packages (HBF open)
+            if (size == 0) {
+              continue;
+            }
+
+            auto rdhPtr = reinterpret_cast<const o2::header::RDHAny*>(it.raw());
+            const auto rdhVersion = RDHUtils::getVersion(rdhPtr);
+            if (!rdhPtr || rdhVersion < 6) {
+              throw std::runtime_error(fmt::format("could not get RDH from packet, or version {} < 6", rdhVersion).data());
+            }
+
+            // ---| extract hardware information to do the processing |---
+            const auto feeId = (FEEIDType)RDHUtils::getFEEID(*rdhPtr);
+            const auto link = rdh_utils::getLink(feeId);
+            const auto detField = RDHUtils::getDetectorField(*rdhPtr);
+
+            // only select CMVs
+            if ((detField != (decltype(detField))RawDataType::CMV) || (link != rdh_utils::CMVLinkID)) {
+              continue;
+            }
+
+            // write out raw data
+            mRawOutputFile.write((const char*)it.raw(), RDHUtils::getMemorySize(rdhPtr));
+          }
+        } catch (...) {
+        }
+      }
+    }
+  }
+};
+
+o2::framework::DataProcessorSpec getCMVToVectorSpec(const std::string inputSpec, std::vector<uint32_t> const& crus)
+{
+  using device = o2::tpc::CMVToVectorDevice;
+
+  std::vector<OutputSpec> outputs;
+  for (const uint32_t cru : crus) {
+    const header::DataHeader::SubSpecificationType subSpec{cru << 7};
+    outputs.emplace_back(gDataOriginTPC, "CMVVECTOR", subSpec, Lifetime::Timeframe);
+    outputs.emplace_back(gDataOriginTPC, "CMVORBITS", subSpec, Lifetime::Timeframe);
+  }
+
+  return DataProcessorSpec{
+    fmt::format("tpc-cmv-to-vector"),
+    select(inputSpec.data()),
+    outputs,
+    AlgorithmSpec{adaptFromTask<device>(crus)},
+    Options{
+      {"write-debug", VariantType::Bool, false, {"write a debug output tree"}},
+      {"write-debug-on-error", VariantType::Bool, false, {"write a debug output tree in case errors occurred"}},
+      {"debug-file-name", VariantType::String, "/tmp/cmv_vector_debug.{run}.root", {"name of the debug output file"}},
+      {"write-raw-data-on-error", VariantType::Bool, false, {"dump raw data in case errors occurred"}},
+      {"raw-file-name", VariantType::String, "/tmp/cmv_debug.{run}.{raw_type}", {"name of the raw output file"}},
+      {"raw-data-type", VariantType::Int, 0, {"Which raw data to dump: 0-full TPC with DH, 1-full TPC with DH skip empty, 2-full TPC no DH, 3-full TPC no DH skip empty, 4-IDC raw only 5-CMV raw only"}},
+      {"check-incomplete-hbf", VariantType::Bool, false, {"false: don't check; true: check and report"}},
+    } // end Options
+  }; // end DataProcessorSpec
+}
+} // namespace o2::tpc
\ No newline at end of file
diff --git a/Detectors/TPC/workflow/src/tpc-cmv-to-vector.cxx b/Detectors/TPC/workflow/src/tpc-cmv-to-vector.cxx
new file mode 100644
index 0000000000000..1040b64f98d04
--- /dev/null
+++ b/Detectors/TPC/workflow/src/tpc-cmv-to-vector.cxx
@@ -0,0 +1,71 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <vector>
+#include <string>
+#include <fmt/format.h>
+
+#include "Algorithm/RangeTokenizer.h"
+#include "Framework/WorkflowSpec.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/CompletionPolicy.h"
+#include "Framework/CompletionPolicyHelpers.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "TPCBase/CRU.h"
+#include "TPCWorkflow/CMVToVectorSpec.h"
+
+using namespace o2::framework;
+using namespace o2::tpc;
+
+// customize the completion policy
+void customize(std::vector<o2::framework::CompletionPolicy>& policies)
+{
+  using o2::framework::CompletionPolicy;
+  policies.push_back(CompletionPolicyHelpers::defineByName("tpc-cmv-to-vector", CompletionPolicy::CompletionOp::Consume));
+}
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::string crusDefault = "0-" + std::to_string(CRU::MaxCRU - 1);
+
+  std::vector<ConfigParamSpec> options{
+    {"input-spec", VariantType::String, "A:TPC/RAWDATA", {"selection string input specs"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings (e.g.: 'TPCCalibPedestal.FirstTimeBin=10;...')"}},
+    {"configFile", VariantType::String, "", {"configuration file for configurable parameters"}},
+    {"crus", VariantType::String, crusDefault.c_str(), {"List of TPC crus, comma separated ranges, e.g. 0-3,7,9-15"}},
+  };
+
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& config)
+{
+
+  using namespace o2::tpc;
+
+  // set up configuration
+  o2::conf::ConfigurableParam::updateFromFile(config.options().get<std::string>("configFile"));
+  o2::conf::ConfigurableParam::updateFromString(config.options().get<std::string>("configKeyValues"));
+  o2::conf::ConfigurableParam::writeINI("o2tpccmv_configuration.ini");
+
+  const std::string inputSpec = config.options().get<std::string>("input-spec");
+
+  const auto crus = o2::RangeTokenizer::tokenize<uint32_t>(config.options().get<std::string>("crus"));
+
+  WorkflowSpec workflow;
+
+  workflow.emplace_back(getCMVToVectorSpec(inputSpec, crus));
+
+  return workflow;
+}
diff --git a/Detectors/TPC/workflow/src/tpc-distribute-cmv.cxx b/Detectors/TPC/workflow/src/tpc-distribute-cmv.cxx
new file mode 100644
index 0000000000000..b6aaaa0a109ad
--- /dev/null
+++ b/Detectors/TPC/workflow/src/tpc-distribute-cmv.cxx
@@ -0,0 +1,84 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <vector>
+#include <string>
+#include "Algorithm/RangeTokenizer.h"
+#include "Framework/WorkflowSpec.h"
+#include "Framework/ConfigParamSpec.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "TPCWorkflow/TPCDistributeCMVSpec.h"
+#include "Framework/CompletionPolicyHelpers.h"
+
+using namespace o2::framework;
+
+// customize the completion policy
+void customize(std::vector<o2::framework::CompletionPolicy>& policies)
+{
+  using o2::framework::CompletionPolicy;
+  policies.push_back(CompletionPolicyHelpers::defineByName("tpc-distribute-*.*", CompletionPolicy::CompletionOp::Consume));
+}
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  const std::string cruDefault = "0-" + std::to_string(o2::tpc::CRU::MaxCRU - 1);
+
+  std::vector<ConfigParamSpec> options{
+    {"crus", VariantType::String, cruDefault.c_str(), {"List of CRUs, comma separated ranges, e.g. 0-3,7,9-15"}},
+    {"timeframes", VariantType::Int, 2000, {"Number of TFs which will be aggregated per aggregation interval."}},
+    {"firstTF", VariantType::Int, -1, {"First time frame index. (if set to -1 the first TF will be automatically detected. Values < -1 are setting an offset for skipping the first TFs)"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    {"lanes", VariantType::Int, 1, {"Number of lanes of this device (CRUs are split per lane)"}},
+    {"use-precise-timestamp", VariantType::Bool, false, {"Use precise timestamp which can be used for writing to CCDB"}},
+    {"enable-CCDB-output", VariantType::Bool, false, {"Send output to the CCDB populator"}},
+    {"n-TFs-buffer", VariantType::Int, 1, {"Buffer which was defined in the TPCFLPCMVSpec."}}};
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& config)
+{
+  using namespace o2::tpc;
+
+  // set up configuration
+  o2::conf::ConfigurableParam::updateFromString(config.options().get<std::string>("configKeyValues"));
+  o2::conf::ConfigurableParam::writeINI("o2tpcdistributecmv_configuration.ini");
+
+  const auto tpcCRUs = o2::RangeTokenizer::tokenize<int>(config.options().get<std::string>("crus"));
+  const auto nCRUs = tpcCRUs.size();
+  auto timeframes = static_cast<unsigned int>(config.options().get<int>("timeframes"));
+  const auto nLanes = static_cast<unsigned int>(config.options().get<int>("lanes"));
+  const auto firstTF = static_cast<unsigned int>(config.options().get<int>("firstTF"));
+  const bool usePreciseTimestamp = config.options().get<bool>("use-precise-timestamp");
+  const bool sendCCDB = config.options().get<bool>("enable-CCDB-output");
+  int nTFsBuffer = config.options().get<int>("n-TFs-buffer");
+  if (nTFsBuffer <= 0) {
+    nTFsBuffer = 1;
+  }
+  assert(timeframes >= nTFsBuffer);
+  timeframes /= nTFsBuffer;
+  LOGP(info, "Using {} timeframes as each TF contains {} CMVs", timeframes, nTFsBuffer);
+  const auto crusPerLane = nCRUs / nLanes + ((nCRUs % nLanes) != 0);
+  WorkflowSpec workflow;
+  for (int ilane = 0; ilane < nLanes; ++ilane) {
+    const auto first = tpcCRUs.begin() + ilane * crusPerLane;
+    if (first >= tpcCRUs.end()) {
+      break;
+    }
+    const auto last = std::min(tpcCRUs.end(), first + crusPerLane);
+    const std::vector<uint32_t> rangeCRUs(first, last);
+    workflow.emplace_back(getTPCDistributeCMVSpec(ilane, rangeCRUs, timeframes, firstTF, sendCCDB, usePreciseTimestamp, nTFsBuffer));
+  }
+
+  return workflow;
+}
\ No newline at end of file
diff --git a/Detectors/TPC/workflow/src/tpc-flp-cmv.cxx b/Detectors/TPC/workflow/src/tpc-flp-cmv.cxx
new file mode 100644
index 0000000000000..f41fe5b8fbd15
--- /dev/null
+++ b/Detectors/TPC/workflow/src/tpc-flp-cmv.cxx
@@ -0,0 +1,72 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <vector>
+#include <string>
+#include <thread>
+#include "CommonUtils/ConfigurableParam.h"
+#include "Algorithm/RangeTokenizer.h"
+#include "Framework/WorkflowSpec.h"
+#include "Framework/ConfigParamSpec.h"
+#include "TPCWorkflow/TPCFLPCMVSpec.h"
+#include "TPCBase/CRU.h"
+
+using namespace o2::framework;
+
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  const std::string cruDefault = "0-" + std::to_string(o2::tpc::CRU::MaxCRU - 1);
+  const int defaultlanes = std::max(1u, std::thread::hardware_concurrency() / 2);
+
+  std::vector<ConfigParamSpec> options{
+    {"configFile", VariantType::String, "", {"configuration file for configurable parameters"}},
+    {"lanes", VariantType::Int, defaultlanes, {"Number of parallel processing lanes (crus are split per device)"}},
+    {"time-lanes", VariantType::Int, 1, {"Number of parallel processing lanes (timeframes are split per device)"}},
+    {"crus", VariantType::String, cruDefault.c_str(), {"List of CRUs, comma separated ranges, e.g. 0-3,7,9-15"}},
+    {"n-TFs-buffer", VariantType::Int, 1, {"Buffer n-TFs before sending output"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
+
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& config)
+{
+  using namespace o2::tpc;
+  o2::conf::ConfigurableParam::updateFromString(config.options().get<std::string>("configKeyValues"));
+  const auto tpcCRUs = o2::RangeTokenizer::tokenize<int>(config.options().get<std::string>("crus"));
+  const auto nCRUs = tpcCRUs.size();
+  const auto nLanes = std::min(static_cast<unsigned long>(config.options().get<int>("lanes")), nCRUs);
+  const auto time_lanes = static_cast<unsigned int>(config.options().get<int>("time-lanes"));
+  const auto crusPerLane = nCRUs / nLanes + ((nCRUs % nLanes) != 0);
+  const int nTFsBuffer = config.options().get<int>("n-TFs-buffer");
+
+  o2::conf::ConfigurableParam::updateFromFile(config.options().get<std::string>("configFile"));
+  o2::conf::ConfigurableParam::writeINI("o2tpcflp_configuration.ini");
+
+  WorkflowSpec workflow;
+  if (nLanes <= 0) {
+    return workflow;
+  }
+
+  for (int ilane = 0; ilane < nLanes; ++ilane) {
+    const auto first = tpcCRUs.begin() + ilane * crusPerLane;
+    if (first >= tpcCRUs.end()) {
+      break;
+    }
+    const auto last = std::min(tpcCRUs.end(), first + crusPerLane);
+    const std::vector<uint32_t> rangeCRUs(first, last);
+    workflow.emplace_back(timePipeline(getTPCFLPCMVSpec(ilane, rangeCRUs, nTFsBuffer), time_lanes));
+  }
+
+  return workflow;
+}
\ No newline at end of file

From ca2fdfa6534bb466aa0c62ec4af4274487af4bcc Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 13 Apr 2026 15:55:28 +0200
Subject: [PATCH 1536/1764] Allow BC correction in FIT CTF decoders

---
 .../FDD/reconstruction/include/FDDReconstruction/CTFCoder.h   | 4 +++-
 Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx         | 1 +
 .../FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h   | 4 +++-
 Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx         | 1 +
 .../FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h   | 4 +++-
 Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx         | 1 +
 6 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
index c62e013447416..24649f73a4ca3 100644
--- a/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
+++ b/Detectors/FIT/FDD/reconstruction/include/FDDReconstruction/CTFCoder.h
@@ -165,7 +165,9 @@ void CTFCoder::decompress(const CompressedDigits& cd, VDIG& digitVec, VCHAN& cha
 
   uint32_t firstEntry = 0, clCount = 0, chipCount = 0;
   o2::InteractionRecord ir(cd.header.firstBC, cd.header.firstOrbit);
-
+  if (mBCShift && ir.toLong() >= mBCShift) {
+    ir -= mBCShift;
+  }
   for (uint32_t idig = 0; idig < cd.header.nTriggers; idig++) {
     // restore ROFRecord
     if (cd.orbitInc[idig]) {  // non-0 increment => new orbit
diff --git a/Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx b/Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx
index 33c140b5bc198..43615b175734d 100644
--- a/Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/FIT/FDD/workflow/src/EntropyDecoderSpec.cxx
@@ -29,6 +29,7 @@ EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdict
   mTimer.Stop();
   mTimer.Reset();
   mCTFCoder.setVerbosity(verbosity);
+  mCTFCoder.setSupportBCShifts(true);
   mCTFCoder.setDictBinding("ctfdict_FDD");
 }
 
diff --git a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
index 5dc367204e1a3..41f11e303db67 100644
--- a/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
+++ b/Detectors/FIT/FT0/reconstruction/include/FT0Reconstruction/CTFCoder.h
@@ -165,7 +165,9 @@ void CTFCoder::decompress(const CompressedDigits& cd, VDIG& digitVec, VCHAN& cha
 
   uint32_t firstEntry = 0, clCount = 0, chipCount = 0;
   o2::InteractionRecord ir(cd.header.firstBC, cd.header.firstOrbit);
-
+  if (mBCShift && ir.toLong() >= mBCShift) {
+    ir -= mBCShift;
+  }
   for (uint32_t idig = 0; idig < cd.header.nTriggers; idig++) {
     // restore ROFRecord
     if (cd.orbitInc[idig]) {  // non-0 increment => new orbit
diff --git a/Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx b/Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx
index 066c5cc547c2e..97ea337705fee 100644
--- a/Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/FIT/FT0/workflow/src/EntropyDecoderSpec.cxx
@@ -29,6 +29,7 @@ EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdict
   mTimer.Stop();
   mTimer.Reset();
   mCTFCoder.setVerbosity(verbosity);
+  mCTFCoder.setSupportBCShifts(true);
   mCTFCoder.setDictBinding("ctfdict_FT0");
 }
 
diff --git a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
index 80dcd6060455b..082fbd93a705a 100644
--- a/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
+++ b/Detectors/FIT/FV0/reconstruction/include/FV0Reconstruction/CTFCoder.h
@@ -168,7 +168,9 @@ void CTFCoder::decompress(const CompressedDigits& cd, VDIG& digitVec, VCHAN& cha
 
   uint32_t firstEntry = 0, clCount = 0, chipCount = 0;
   o2::InteractionRecord ir(cd.header.firstBC, cd.header.firstOrbit);
-
+  if (mBCShift && ir.toLong() >= mBCShift) {
+    ir -= mBCShift;
+  }
   for (uint32_t idig = 0; idig < cd.header.nTriggers; idig++) {
     // restore ROFRecord
     if (cd.orbitInc[idig]) {  // non-0 increment => new orbit
diff --git a/Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx b/Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx
index 7babe9fdea6ed..6cf8043cf683f 100644
--- a/Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx
+++ b/Detectors/FIT/FV0/workflow/src/EntropyDecoderSpec.cxx
@@ -29,6 +29,7 @@ EntropyDecoderSpec::EntropyDecoderSpec(int verbosity, const std::string& ctfdict
   mTimer.Stop();
   mTimer.Reset();
   mCTFCoder.setVerbosity(verbosity);
+  mCTFCoder.setSupportBCShifts(true);
   mCTFCoder.setDictBinding("ctfdict_FV0");
 }
 

From 1010e83338a2f7ee389e99c5655e7f6151ee765c Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 9 Apr 2026 11:42:50 +0200
Subject: [PATCH 1537/1764] secondary-vertexing-workflow: request CTP sources
 only if TPC is included

---
 .../src/secondary-vertexing-workflow.cxx                    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
index 9108e8577fd5a..5bc80f527d4d0 100644
--- a/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
@@ -96,9 +96,9 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   }
   if (src[GID::TPC]) {
     srcClus |= GID::getSourceMask(GID::TPC);
-  }
-  if (sclOpt.requestCTPLumi) {
-    src = src | GID::getSourcesMask("CTP");
+    if (sclOpt.requestCTPLumi) {
+      src = src | GID::getSourcesMask("CTP");
+    }
   }
   WorkflowSpec specs;
   if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {

From ef2f17856086155b6a4885d3b7c685151d51edde Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Tue, 14 Apr 2026 08:47:10 +0200
Subject: [PATCH 1538/1764] [ALICE3] IOTOF: Add geometry macros (#15257)

---
 .../Upgrades/ALICE3/IOTOF/CMakeLists.txt      |   3 +-
 .../ALICE3/IOTOF/macros/CMakeLists.txt        |  13 ++
 .../ALICE3/IOTOF/macros/defineIOTOFGeo.C      | 139 ++++++++++++++++++
 3 files changed, 154 insertions(+), 1 deletion(-)
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/macros/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/macros/defineIOTOFGeo.C

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/CMakeLists.txt b/Detectors/Upgrades/ALICE3/IOTOF/CMakeLists.txt
index 83838a01d13f1..808320bf66404 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/IOTOF/CMakeLists.txt
@@ -10,4 +10,5 @@
 # or submit itself to any jurisdiction.
 
 add_subdirectory(base)
-add_subdirectory(simulation)
\ No newline at end of file
+add_subdirectory(simulation)
+add_subdirectory(macros)
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/macros/CMakeLists.txt b/Detectors/Upgrades/ALICE3/IOTOF/macros/CMakeLists.txt
new file mode 100644
index 0000000000000..b2f1857186c0b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/macros/CMakeLists.txt
@@ -0,0 +1,13 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_test_root_macro(defineIOTOFGeo.C
+                       LABELS alice3)
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/macros/defineIOTOFGeo.C b/Detectors/Upgrades/ALICE3/IOTOF/macros/defineIOTOFGeo.C
new file mode 100644
index 0000000000000..f096fc85aec7a
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/macros/defineIOTOFGeo.C
@@ -0,0 +1,139 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <TCanvas.h>
+#include <TGraph.h>
+#include <TArc.h>
+#include <TH2F.h>
+#include <TMath.h>
+#include <TLatex.h>
+#include <TStyle.h>
+#include <algorithm>
+#include <cmath>
+
+void defineIOTOFGeo(const double rAvg = 21,              // cm, average radius of the layer (used for stave size calculations)
+                    const int nStaves = 24,              // Number of staves
+                    const double staveWidth = 5.42,      // cm, Stave width (arc length at avg radius at 0 degrees)
+                    const double staveHeightX2X0 = 0.02, // Stave height (radial at 0 degrees)
+                    const double staveTilt = 10          // Stave tilt angle in degrees
+)
+{
+  const double Si_X0 = 9.5f; // cm, radiation length of silicon
+  const double staveHeight = staveHeightX2X0 * Si_X0;
+
+  // 1. Define inner and outer radii for the disk.
+  //    The radius corresponds to the distance of the center of the stave to the origin
+  const double rInner = rAvg - staveHeight / 2.0;
+  const double rOuter = rAvg + staveHeight / 2.0;
+
+  const double alpha = staveTilt * TMath::DegToRad(); // Tilt angle in radians
+  const double H = staveHeight;
+  const double W = staveWidth;
+
+  // 2. Analytical calculation of Inscribed and Outscribed Radii
+  //    We project the global origin (0,0) into the local, unrotated coordinate
+  //    system of a single stave centered at (0,0).
+  const double u0 = -rAvg * TMath::Cos(alpha);
+  const double v0 = rAvg * TMath::Sin(alpha);
+
+  // Inscribed Radius: Distance to the closest point on the stave rectangle
+  const double uc = std::max(-H / 2.0, std::min(H / 2.0, u0));
+  const double vc = std::max(-W / 2.0, std::min(W / 2.0, v0));
+  const double rInscribed = TMath::Sqrt((uc - u0) * (uc - u0) + (vc - v0) * (vc - v0));
+
+  // Outscribed Radius: Maximum distance to one of the 4 corners
+  double rOutscribed = 0;
+  const double uCorners[4] = {-H / 2.0, H / 2.0, H / 2.0, -H / 2.0};
+  const double vCorners[4] = {-W / 2.0, -W / 2.0, W / 2.0, W / 2.0};
+  for (int i = 0; i < 4; ++i) {
+    const double dist = std::hypot(uCorners[i] - u0, vCorners[i] - v0);
+    if (dist > rOutscribed) {
+      rOutscribed = dist;
+    }
+  }
+
+  // 3. Visualization
+  new TCanvas("DiskWithStaves", "Disk with Staves", 800, 800);
+  gPad->SetGrid();
+  gPad->SetLeftMargin(0.15);
+  gPad->SetBottomMargin(0.15);
+  gPad->SetRightMargin(0.05);
+  gPad->SetTopMargin(0.05);
+
+  const double maxR = std::max(rOuter, rOutscribed) * 1.5;
+  gPad->DrawFrame(-maxR, -maxR, maxR, maxR, ";X (cm);Y (cm)");
+
+  // Draw Inner and Outer Disk Radii (Reference)
+  TArc* arcInner = new TArc(0, 0, rInner);
+  arcInner->SetLineStyle(2);
+  arcInner->SetLineColor(kGray + 1);
+  arcInner->SetFillStyle(0);
+  arcInner->Draw("same");
+
+  TArc* arcOuter = new TArc(0, 0, rOuter);
+  arcOuter->SetLineStyle(2);
+  arcOuter->SetLineColor(kGray + 1);
+  arcOuter->SetFillStyle(0);
+  arcOuter->Draw("same");
+
+  // Draw Inscribed and Outscribed circles
+  TArc* arcInscribed = new TArc(0, 0, rInscribed);
+  arcInscribed->SetLineColor(kBlue);
+  arcInscribed->SetLineWidth(2);
+  arcInscribed->SetFillStyle(0);
+  arcInscribed->Draw("same");
+
+  TArc* arcOutscribed = new TArc(0, 0, rOutscribed);
+  arcOutscribed->SetLineColor(kRed);
+  arcOutscribed->SetLineWidth(2);
+  arcOutscribed->SetFillStyle(0);
+  arcOutscribed->Draw("same");
+
+  // Generate and Draw Staves
+  for (int i = 0; i < nStaves; ++i) {
+    double phi = i * TMath::TwoPi() / nStaves;
+    double xPts[5], yPts[5];
+    for (int j = 0; j < 4; ++j) {
+      double u = uCorners[j];
+      double v = vCorners[j];
+      // Apply stave tilt (alpha) around its own center
+      double uRot = u * TMath::Cos(alpha) - v * TMath::Sin(alpha);
+      double vRot = u * TMath::Sin(alpha) + v * TMath::Cos(alpha);
+      // Move stave to rAvg and apply azimuthal rotation (phi)
+      double x_phi0 = rAvg + uRot;
+      double y_phi0 = vRot;
+      xPts[j] = x_phi0 * TMath::Cos(phi) - y_phi0 * TMath::Sin(phi);
+      yPts[j] = x_phi0 * TMath::Sin(phi) + y_phi0 * TMath::Cos(phi);
+    }
+    // Close the geometric polygon
+    xPts[4] = xPts[0];
+    yPts[4] = yPts[0];
+    TGraph* gStave = new TGraph(5, xPts, yPts);
+    gStave->SetFillColorAlpha(kGreen + 2, 0.4);
+    gStave->SetLineColor(kBlack);
+    gStave->SetLineWidth(1);
+    gStave->Draw("f same"); // Fill
+    gStave->Draw("l same"); // Outline
+  }
+
+  // 7. Add Legend / Parameter Text
+  TLatex* tex = new TLatex();
+  tex->SetNDC();
+  tex->SetTextSize(0.028);
+  tex->SetTextFont(42);
+  tex->SetTextColor(kBlack);
+  tex->DrawLatex(0.12, 0.88, Form("R_{inner} = %.1f, R_{outer} = %.1f", rInner, rOuter));
+  tex->DrawLatex(0.12, 0.84, Form("Staves: %d, Tilt: %.1f#circ", nStaves, staveTilt));
+  tex->SetTextColor(kBlue);
+  tex->DrawLatex(0.12, 0.80, Form("Inscribed Radius = %.2f", rInscribed));
+  tex->SetTextColor(kRed);
+  tex->DrawLatex(0.12, 0.76, Form("Outscribed Radius = %.2f", rOutscribed));
+}

From 14045caca9a91c39625e97bde4e57131c14b3131 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 14 Apr 2026 14:29:09 +0200
Subject: [PATCH 1539/1764] Restrict ITS max timestamp uncertainty to shortest
 ROF

---
 Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index f996c0d25e7d7..3cf462206bf94 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -757,6 +757,7 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
       });
     });
 
+    const float smallestROFHalf = mTimeFrame->getROFOverlapTableView().getClockLayer().mROFLength * 0.5f;
     for (auto& track : tracks) {
       int nShared = 0;
       bool isFirstShared{false};
@@ -799,6 +800,10 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
         }
       }
       track.getTimeStamp() = ts.makeSymmetrical();
+      if (track.getTimeStamp().getTimeStampError() > smallestROFHalf) {
+        track.getTimeStamp().setTimeStampError(smallestROFHalf);
+      }
+
       track.setUserField(0);
       track.getParamOut().setUserField(0);
       mTimeFrame->getTracks().emplace_back(track);

From 74098a4054b9560c36836a22f405dd4881e2678c Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <9267733+fweig@users.noreply.github.com>
Date: Wed, 15 Apr 2026 10:55:36 +0200
Subject: [PATCH 1540/1764] GPU/TPC: Simplify pad indexing in noisy-pad filter

---
 .../DataTypes/CalibdEdxContainer.cxx          |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx    |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadBitMap.h      |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadGainCalib.h   |  6 +--
 .../DataTypes/TPCZSLinkMapping.cxx            |  2 +-
 .../Definitions/clusterFinderDefs.h           | 16 +++---
 .../Global/GPUChainTrackingClusterizer.cxx    |  4 +-
 GPU/GPUTracking/TPCClusterFinder/CfArray2D.h  |  8 +--
 .../TPCClusterFinder/CfChargePos.h            |  6 +--
 .../GPUTPCCFCheckPadBaseline.cxx              | 53 ++++---------------
 .../GPUTPCCFCheckPadBaseline.h                | 11 +---
 .../TPCClusterFinder/GPUTPCCFPeakFinder.cxx   |  6 +--
 .../TPCClusterFinder/GPUTPCClusterFinder.cxx  |  2 +-
 .../GPUTPCClusterFinderDump.cxx               |  4 +-
 15 files changed, 44 insertions(+), 82 deletions(-)

diff --git a/GPU/GPUTracking/DataTypes/CalibdEdxContainer.cxx b/GPU/GPUTracking/DataTypes/CalibdEdxContainer.cxx
index 0b3ee65ef7578..ba4b230e1f6f2 100644
--- a/GPU/GPUTracking/DataTypes/CalibdEdxContainer.cxx
+++ b/GPU/GPUTracking/DataTypes/CalibdEdxContainer.cxx
@@ -265,7 +265,7 @@ void CalibdEdxContainer::setDefaultZeroSupresssionThreshold()
   mThresholdMap.setMinCorrectionFactor(defaultVal - 0.1f);
   mThresholdMap.setMaxCorrectionFactor(defaultVal + 0.1f);
   for (int32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; ++sector) {
-    for (uint16_t globPad = 0; globPad < TPC_PADS_IN_SECTOR; ++globPad) {
+    for (uint16_t globPad = 0; globPad < TPC_REAL_PADS_IN_SECTOR; ++globPad) {
       mThresholdMap.setGainCorrection(sector, globPad, defaultVal);
     }
   }
diff --git a/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx b/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
index 0b8e67fbe495e..2d12f98b8cf16 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
@@ -40,7 +40,7 @@ TPCPadBitMap::TPCPadBitMap(const o2::tpc::CalDet<bool>& map) : TPCPadBitMap()
 void TPCPadBitMap::setFromMap(const o2::tpc::CalDet<bool>& map)
 {
   for (int32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; sector++) {
-    for (int32_t p = 0; p < TPC_PADS_IN_SECTOR; p++) {
+    for (int32_t p = 0; p < TPC_REAL_PADS_IN_SECTOR; p++) {
       const auto val = map.getValue(sector, p);
       mBitMap[sector].set(p, val);
     }
diff --git a/GPU/GPUTracking/DataTypes/TPCPadBitMap.h b/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
index 6ddfac8c268ee..299b880fcbcc6 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
+++ b/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
@@ -68,7 +68,7 @@ struct TPCPadBitMap {
   {
    public:
     using T = uint32_t;
-    static constexpr int32_t NWORDS = (TPC_PADS_IN_SECTOR + sizeof(T) * 8 - 1) / sizeof(T);
+    static constexpr int32_t NWORDS = (TPC_REAL_PADS_IN_SECTOR + sizeof(T) * 8 - 1) / sizeof(T);
     GPUdi() SectorBitMap()
     {
       reset();
diff --git a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
index a20f3dc8aac1d..6cc70c7afa7e1 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
@@ -47,7 +47,7 @@ TPCPadGainCalib::TPCPadGainCalib(const o2::tpc::CalDet<float>& gainMap, const fl
 void TPCPadGainCalib::setFromMap(const o2::tpc::CalDet<float>& gainMap, const bool inv)
 {
   for (int32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; sector++) {
-    for (int32_t p = 0; p < TPC_PADS_IN_SECTOR; p++) {
+    for (int32_t p = 0; p < TPC_REAL_PADS_IN_SECTOR; p++) {
       const float gainVal = gainMap.getValue(sector, p);
       inv ? mGainCorrection[sector].set(p, (gainVal > 1.e-5f) ? 1.f / gainVal : 1.f) : mGainCorrection[sector].set(p, gainVal);
     }
diff --git a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
index 263956c8b5602..dbea56ee5ea6b 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
+++ b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
@@ -120,12 +120,14 @@ struct TPCPadGainCalib {
 
     GPUd() void reset()
     {
-      for (uint16_t p = 0; p < TPC_PADS_IN_SECTOR; p++) {
+      for (uint16_t p = 0; p < TPC_REAL_PADS_IN_SECTOR; p++) {
         set(p, 1.0f);
       }
     }
 
    private:
+    T mGainCorrection[TPC_REAL_PADS_IN_SECTOR];
+
     GPUd() T pack(float f) const
     {
       f = CAMath::Clamp(f, mMinCorrectionFactor, mMaxCorrectionFactor);
@@ -140,8 +142,6 @@ struct TPCPadGainCalib {
       return mMinCorrectionFactor + (mMaxCorrectionFactor - mMinCorrectionFactor) * float(c) / float(NumOfSteps);
     }
 
-    T mGainCorrection[TPC_PADS_IN_SECTOR];
-
     GPUdi() T& at(uint16_t globalPad)
     {
       return mGainCorrection[globalPad];
diff --git a/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx b/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
index 60f960d1b25f0..f520282bfa35b 100644
--- a/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
@@ -27,7 +27,7 @@ TPCZSLinkMapping::TPCZSLinkMapping(o2::tpc::Mapper& mapper)
   assert(fecToGlobalPad.size() == TPC_FEC_IDS_IN_SECTOR);
 
   const auto& globalPadToPadPos = mapper.getMapGlobalPadToPadPos();
-  assert(globalPadToPadPos.size() == TPC_PADS_IN_SECTOR);
+  assert(globalPadToPadPos.size() == TPC_REAL_PADS_IN_SECTOR);
 
   for (size_t i = 0; i < TPC_FEC_IDS_IN_SECTOR; i++) {
     FECIDToPadPos[i] = globalPadToPadPos[fecToGlobalPad[i]];
diff --git a/GPU/GPUTracking/Definitions/clusterFinderDefs.h b/GPU/GPUTracking/Definitions/clusterFinderDefs.h
index b36a94fc2bd54..8d9ec60e551b9 100644
--- a/GPU/GPUTracking/Definitions/clusterFinderDefs.h
+++ b/GPU/GPUTracking/Definitions/clusterFinderDefs.h
@@ -32,15 +32,19 @@
 #endif
 
 // Padding of 2 and 3 respectively would be enough. But this ensures that
-// rows are always aligned along cache lines. Likewise for TPC_PADS_PER_ROW.
+// rows are always aligned along cache lines. Likewise for TPC_CLUSTERER_ROW_PAD_CAPACITY.
 #define GPUCF_PADDING_PAD 8
 #define GPUCF_PADDING_TIME 4
-#define TPC_PADS_PER_ROW 144
+// Largest possible number of pads in a TPC row
+#define TPC_CLUSTERER_ROW_PAD_CAPACITY 144
 
-#define TPC_ROWS_PER_CRU 18
-#define TPC_PADS_PER_ROW_PADDED (TPC_PADS_PER_ROW + GPUCF_PADDING_PAD)
-#define TPC_NUM_OF_PADS (GPUCA_ROW_COUNT * TPC_PADS_PER_ROW_PADDED + GPUCF_PADDING_PAD)
-#define TPC_PADS_IN_SECTOR 14560
+// Stride between rows as stored internally by the clusterizer
+#define TPC_CLUSTERER_ROW_STRIDE (TPC_CLUSTERER_ROW_PAD_CAPACITY + GPUCF_PADDING_PAD)
+// Number of pads in a sector as stored internally by the clusterizer.
+// This includes fake pads for constant strides between rows
+#define TPC_CLUSTERER_STRIDED_PAD_COUNT (GPUCA_ROW_COUNT * TPC_CLUSTERER_ROW_STRIDE + GPUCF_PADDING_PAD)
+// Real of number of pads in a sector
+#define TPC_REAL_PADS_IN_SECTOR 14560
 #define TPC_FEC_IDS_IN_SECTOR 23296
 #define TPC_MAX_FRAGMENT_LEN_GPU 4000
 #define TPC_MAX_FRAGMENT_LEN_HOST 1000
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index bf6577cfd929e..12a12d4c47585 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -861,7 +861,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPchargeMap, TPCMapMemoryLayout<ChargeMapType>::items(GetProcessingSettings().overrideClusterizerFragmentLen) * sizeof(ChargeMapType));
         runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPpeakMap, TPCMapMemoryLayout<PeakMapType>::items(GetProcessingSettings().overrideClusterizerFragmentLen) * sizeof(PeakMapType));
         if (fragment.index == 0) {
-          runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPpadIsNoisy, TPC_PADS_IN_SECTOR * sizeof(*clustererShadow.mPpadIsNoisy));
+          runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding)}, clustererShadow.mPpadIsNoisy, TPC_CLUSTERER_STRIDED_PAD_COUNT * sizeof(*clustererShadow.mPpadIsNoisy));
         }
         DoDebugAndDump(RecoStep::TPCClusterFinding, GPUChainTrackingDebugFlags::TPCClustererZeroedCharges, clusterer, &GPUTPCClusterFinder::DumpChargeMap, *mDebugFile, "Zeroed Charges");
 
@@ -965,7 +965,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
           const int32_t nBlocks = GPUTPCCFCheckPadBaseline::GetNBlocks(doGPU);
 
           runKernel<GPUTPCCFCheckPadBaseline>({GetGridBlk(nBlocks, lane), {iSector}});
-          getKernelTimer<GPUTPCCFCheckPadBaseline>(RecoStep::TPCClusterFinding, iSector, TPC_PADS_IN_SECTOR * fragment.lengthWithoutOverlap() * sizeof(PackedCharge), false);
+          getKernelTimer<GPUTPCCFCheckPadBaseline>(RecoStep::TPCClusterFinding, iSector, TPC_REAL_PADS_IN_SECTOR * fragment.lengthWithoutOverlap() * sizeof(PackedCharge), false);
         }
 
         runKernel<GPUTPCCFPeakFinder>({GetGrid(clusterer.mPmemory->counters.nPositions, lane), {iSector}});
diff --git a/GPU/GPUTracking/TPCClusterFinder/CfArray2D.h b/GPU/GPUTracking/TPCClusterFinder/CfArray2D.h
index 3c8bcf94da4b3..e61ec532bf7e0 100644
--- a/GPU/GPUTracking/TPCClusterFinder/CfArray2D.h
+++ b/GPU/GPUTracking/TPCClusterFinder/CfArray2D.h
@@ -49,7 +49,7 @@ class TilingLayout
   enum {
     Height = Grid::Height,
     Width = Grid::Width,
-    WidthInTiles = (TPC_NUM_OF_PADS + Width - 1) / Width,
+    WidthInTiles = (TPC_CLUSTERER_STRIDED_PAD_COUNT + Width - 1) / Width,
   };
 
   GPUdi() static tpccf::SizeT idx(const CfChargePos& p)
@@ -65,7 +65,7 @@ class TilingLayout
 
   GPUd() static size_t items(size_t fragmentLen)
   {
-    return (TPC_NUM_OF_PADS + Width - 1) / Width * Width * (TPC_MAX_FRAGMENT_LEN_PADDED(fragmentLen) + Height - 1) / Height * Height;
+    return (TPC_CLUSTERER_STRIDED_PAD_COUNT + Width - 1) / Width * Width * (TPC_MAX_FRAGMENT_LEN_PADDED(fragmentLen) + Height - 1) / Height * Height;
   }
 };
 
@@ -74,12 +74,12 @@ class LinearLayout
  public:
   GPUdi() static tpccf::SizeT idx(const CfChargePos& p)
   {
-    return TPC_NUM_OF_PADS * p.timePadded + p.gpad;
+    return TPC_CLUSTERER_STRIDED_PAD_COUNT * p.timePadded + p.gpad;
   }
 
   GPUd() static size_t items(size_t fragmentLen)
   {
-    return TPC_NUM_OF_PADS * TPC_MAX_FRAGMENT_LEN_PADDED(fragmentLen);
+    return TPC_CLUSTERER_STRIDED_PAD_COUNT * TPC_MAX_FRAGMENT_LEN_PADDED(fragmentLen);
   }
 };
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/CfChargePos.h b/GPU/GPUTracking/TPCClusterFinder/CfChargePos.h
index bf6ce2fc804ba..3d853345b8f95 100644
--- a/GPU/GPUTracking/TPCClusterFinder/CfChargePos.h
+++ b/GPU/GPUTracking/TPCClusterFinder/CfChargePos.h
@@ -42,8 +42,8 @@ struct CfChargePos {
 
   GPUdi() bool valid() const { return timePadded >= 0; }
 
-  GPUdi() tpccf::Row row() const { return gpad / TPC_PADS_PER_ROW_PADDED; }
-  GPUdi() tpccf::Pad pad() const { return gpad % TPC_PADS_PER_ROW_PADDED - GPUCF_PADDING_PAD; }
+  GPUdi() tpccf::Row row() const { return gpad / TPC_CLUSTERER_ROW_STRIDE; }
+  GPUdi() tpccf::Pad pad() const { return gpad % TPC_CLUSTERER_ROW_STRIDE - GPUCF_PADDING_PAD; }
   GPUdi() tpccf::TPCFragmentTime time() const { return timePadded - GPUCF_PADDING_TIME; }
   GPUdi() tpccf::TPCFragmentTime globalTime() const { return timePadded; }
 
@@ -52,7 +52,7 @@ struct CfChargePos {
   // index between 0 and TPC_NUM_OF_PADS.
   static constexpr GPUdi() tpccf::GlobalPad tpcGlobalPadIdx(tpccf::Row row, tpccf::Pad pad)
   {
-    return TPC_PADS_PER_ROW_PADDED * row + pad + GPUCF_PADDING_PAD;
+    return TPC_CLUSTERER_ROW_STRIDE * row + pad + GPUCF_PADDING_PAD;
   }
 };
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
index 33ed089890bc4..8cbcf320e2547 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
@@ -50,8 +50,10 @@ GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineGPU(int32_t nBlocks, int32_t
   const CfFragment& fragment = clusterer.mPmemory->fragment;
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
 
+  constexpr GPUTPCGeometry geo;
+
   const auto iRow = iBlock;
-  const auto rowinfo = GetRowInfo(iRow);
+  const auto nPads = geo.NPads(iRow);
   const CfChargePos basePos{(Row)iRow, 0, 0};
 
   int32_t totalCharges = 0;
@@ -62,7 +64,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineGPU(int32_t nBlocks, int32_t
   const int16_t iPadOffset = iThread % MaxNPadsPerRow;
   const int16_t iTimeOffset = iThread / MaxNPadsPerRow;
   const int16_t iPadHandle = iThread;
-  const bool handlePad = iPadHandle < rowinfo.nPads;
+  const bool handlePad = iPadHandle < nPads;
 
   const auto firstTB = fragment.firstNonOverlapTimeBin();
   const auto lastTB = fragment.lastNonOverlapTimeBin();
@@ -73,7 +75,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineGPU(int32_t nBlocks, int32_t
 
     const CfChargePos pos = basePos.delta({iPadOffset, iTime});
 
-    smem.charges[iTimeOffset][iPadOffset] = iTime < lastTB && iPadOffset < rowinfo.nPads ? chargeMap[pos].unpack() : 0;
+    smem.charges[iTimeOffset][iPadOffset] = iTime < lastTB && iPadOffset < nPads ? chargeMap[pos].unpack() : 0;
 
     GPUbarrier();
 
@@ -91,7 +93,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineGPU(int32_t nBlocks, int32_t
   }
 
   if (handlePad) {
-    updatePadBaseline(rowinfo.globalPadOffset + iPadOffset, clusterer, totalCharges, maxConsecCharges, maxCharge);
+    updatePadBaseline(basePos.gpad + iPadHandle, clusterer, totalCharges, maxConsecCharges, maxCharge);
   }
 #endif
 }
@@ -102,11 +104,10 @@ GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineCPU(int32_t nBlocks, int32_t
   const CfFragment& fragment = clusterer.mPmemory->fragment;
   CfArray2D<PackedCharge> chargeMap(reinterpret_cast<PackedCharge*>(clusterer.mPchargeMap));
 
-  int32_t basePad = iBlock * PadsPerCacheline;
-  int32_t padsPerRow;
-  CfChargePos basePos = padToCfChargePos<PadsPerCacheline>(basePad, clusterer, padsPerRow);
+  CfChargePos basePos(iBlock * PadsPerCacheline, 0);
 
-  if (not basePos.valid()) {
+  constexpr GPUTPCGeometry geo;
+  if (basePos.pad() >= geo.NPads(basePos.row())) {
     return;
   }
 
@@ -153,45 +154,11 @@ GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineCPU(int32_t nBlocks, int32_t
   }
 
   for (tpccf::Pad localpad = 0; localpad < PadsPerCacheline; localpad++) {
-    updatePadBaseline(basePad + localpad, clusterer, totalCharges[localpad], maxConsecCharges[localpad], maxCharge[localpad]);
+    updatePadBaseline(basePos.gpad + localpad, clusterer, totalCharges[localpad], maxConsecCharges[localpad], maxCharge[localpad]);
   }
 #endif
 }
 
-template <int32_t PadsPerBlock>
-GPUd() CfChargePos GPUTPCCFCheckPadBaseline::padToCfChargePos(int32_t& pad, const GPUTPCClusterFinder& clusterer, int32_t& padsPerRow)
-{
-  constexpr GPUTPCGeometry geo;
-
-  int32_t padOffset = 0;
-  for (Row r = 0; r < GPUCA_ROW_COUNT; r++) {
-    int32_t npads = geo.NPads(r);
-    int32_t padInRow = pad - padOffset;
-    if (0 <= padInRow && padInRow < npads) {
-      int32_t cachelineOffset = padInRow % PadsPerBlock;
-      pad -= cachelineOffset;
-      padsPerRow = npads;
-      return CfChargePos{r, Pad(padInRow - cachelineOffset), 0};
-    }
-    padOffset += npads;
-  }
-
-  padsPerRow = 0;
-  return CfChargePos{0, 0, INVALID_TIME_BIN};
-}
-
-GPUd() GPUTPCCFCheckPadBaseline::RowInfo GPUTPCCFCheckPadBaseline::GetRowInfo(int16_t row)
-{
-  constexpr GPUTPCGeometry geo;
-
-  int16_t padOffset = 0;
-  for (int16_t r = 0; r < row; r++) {
-    padOffset += geo.NPads(r);
-  }
-
-  return RowInfo{padOffset, geo.NPads(row)};
-}
-
 GPUd() void GPUTPCCFCheckPadBaseline::updatePadBaseline(int32_t pad, const GPUTPCClusterFinder& clusterer, int32_t totalCharges, int32_t consecCharges, Charge maxCharge)
 {
   const CfFragment& fragment = clusterer.mPmemory->fragment;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
index a71f1358a73a6..bb44e5e69a9e1 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
@@ -63,7 +63,7 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
 
   static int32_t GetNBlocks(bool isGPU)
   {
-    const int32_t nBlocks = TPC_PADS_IN_SECTOR / PadsPerCacheline;
+    const int32_t nBlocks = TPC_CLUSTERER_STRIDED_PAD_COUNT / PadsPerCacheline;
     return isGPU ? GPUCA_ROW_COUNT : nBlocks;
   }
 
@@ -74,15 +74,6 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
   GPUd() static void CheckBaselineGPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer);
   GPUd() static void CheckBaselineCPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer);
 
-  template <int32_t PadsPerBlock>
-  GPUd() static CfChargePos padToCfChargePos(int32_t& pad, const GPUTPCClusterFinder&, int32_t& padsPerRow);
-
-  struct RowInfo {
-    int16_t globalPadOffset;
-    int16_t nPads;
-  };
-  GPUd() static RowInfo GetRowInfo(int16_t row);
-
   GPUd() static void updatePadBaseline(int32_t pad, const GPUTPCClusterFinder&, int32_t totalCharges, int32_t consecCharges, tpccf::Charge maxCharge);
 };
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
index 6749ab8e8485e..5d94e36febc0a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
@@ -105,11 +105,11 @@ GPUd() void GPUTPCCFPeakFinder::findPeaksImpl(int32_t nBlocks, int32_t nThreads,
   // For certain configurations dummy work items are added, so the total
   // number of work items is dividable by 64.
   // These dummy items also compute the last digit but discard the result.
-  CfChargePos pos = positions[CAMath::Min(idx, (SizeT)(digitnum - 1))];
+  CfChargePos pos = positions[CAMath::Min<SizeT>(idx, digitnum - 1)];
   Charge charge = pos.valid() ? chargeMap[pos].unpack() : Charge(0);
 
-  bool hasLostBaseline = padHasLostBaseline[gainCorrection.globalPad(pos.row(), pos.pad())];
-  charge = (hasLostBaseline) ? 0.f : charge;
+  bool hasLostBaseline = padHasLostBaseline[pos.gpad];
+  charge = hasLostBaseline ? 0.f : charge;
 
   uint8_t peak = isPeak(smem, charge, pos, SCRATCH_PAD_SEARCH_N, chargeMap, calib, smem.posBcast, smem.buf);
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
index 44b005eb20233..979980f32a479 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
@@ -79,7 +79,7 @@ void* GPUTPCClusterFinder::SetPointersOutput(void* mem)
 
 void* GPUTPCClusterFinder::SetPointersScratch(void* mem)
 {
-  computePointerWithAlignment(mem, mPpadIsNoisy, TPC_PADS_IN_SECTOR);
+  computePointerWithAlignment(mem, mPpadIsNoisy, TPC_CLUSTERER_STRIDED_PAD_COUNT);
   computePointerWithAlignment(mem, mPpositions, mNMaxDigitsFragment);
   computePointerWithAlignment(mem, mPpeakPositions, mNMaxPeaks);
   computePointerWithAlignment(mem, mPfilteredPeakPositions, mNMaxClusters);
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
index d676cf9cd3887..242f6963a0b50 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
@@ -48,7 +48,7 @@ void GPUTPCClusterFinder::DumpChargeMap(std::ostream& out, std::string_view titl
 
   for (TPCFragmentTime i = start; i < end; i++) {
     int32_t zeros = 0;
-    for (GlobalPad j = 0; j < TPC_NUM_OF_PADS; j++) {
+    for (GlobalPad j = 0; j < TPC_CLUSTERER_STRIDED_PAD_COUNT; j++) {
       uint16_t q = map[{j, i}];
       zeros += (q == 0);
       if (q != 0) {
@@ -84,7 +84,7 @@ void GPUTPCClusterFinder::DumpPeakMap(std::ostream& out, std::string_view title)
     int32_t zeros = 0;
 
     out << i << ":";
-    for (GlobalPad j = 0; j < TPC_NUM_OF_PADS; j++) {
+    for (GlobalPad j = 0; j < TPC_CLUSTERER_STRIDED_PAD_COUNT; j++) {
       uint8_t q = map[{j, i}];
       zeros += (q == 0);
       if (q != 0) {

From b7bfb2c0c2235654afe8a162eca0cf48aed40a0b Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Thu, 16 Apr 2026 10:16:21 +0200
Subject: [PATCH 1541/1764] [ALICE3] Rough attempt to pave ML disks as done for
 OT (#15269)

* Updated FT3Module

* First attempt to pave ML disks
---
 .../ALICE3/FT3/simulation/src/Detector.cxx    | 30 +++++++++----------
 .../ALICE3/FT3/simulation/src/FT3Layer.cxx    |  2 +-
 .../ALICE3/FT3/simulation/src/FT3Module.cxx   | 16 ++++++----
 3 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index 94d56fd9625a0..2a9a9633cdd11 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -631,7 +631,7 @@ void Detector::defineSensitiveVolumes()
       LOG(info) << "Adding FT3 Sensitive Volume for direction " << direction << " layer " << iLayer << "/" << getNumberOfLayers();
       volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer);
       int iSens = 0;
-      if (mLayers[direction][iLayer].getIsInMiddleLayer()) { // ML disks
+      /*if (mLayers[direction][iLayer].getIsInMiddleLayer()) { // ML disks
         const std::string sensorName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer);
         v = geoManager->GetVolume(sensorName.c_str());
         if (!v) {
@@ -640,22 +640,22 @@ void Detector::defineSensitiveVolumes()
         }
         AddSensitiveVolume(v);
         iSens++;
-      } else { // OT disks
-        for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) {
-          std::string sensor_name_front = "FT3Sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-          std::string sensor_name_back = "FT3Sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-          v = geoManager->GetVolume(sensor_name_front.c_str());
-          if (v) {
-            AddSensitiveVolume(v);
-            iSens++;
-          }
-          v = geoManager->GetVolume(sensor_name_back.c_str());
-          if (v) {
-            AddSensitiveVolume(v);
-            iSens++;
-          }
+      } else { // OT disks*/
+      for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) {
+        std::string sensor_name_front = "FT3Sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+        std::string sensor_name_back = "FT3Sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
+        v = geoManager->GetVolume(sensor_name_front.c_str());
+        if (v) {
+          AddSensitiveVolume(v);
+          iSens++;
+        }
+        v = geoManager->GetVolume(sensor_name_back.c_str());
+        if (v) {
+          AddSensitiveVolume(v);
+          iSens++;
         }
       }
+      //}
       LOG(info) << iSens << " sensitive volumes added";
     }
   }
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
index 333599c85eab6..5be3c7abc30a3 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -237,7 +237,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
   LOG(info) << "FT3: ft3Params.layoutFT3 = " << ft3Params.layoutFT3;
 
   // ### options for ML and OT disk layout
-  if (ft3Params.layoutFT3 == kTrapezoidal || (mIsMiddleLayer && ft3Params.layoutFT3 == kSegmented)) {
+  if (ft3Params.layoutFT3 == kTrapezoidal /*|| (mIsMiddleLayer && ft3Params.layoutFT3 == kSegmented)*/) {
     // trapezoidal ML+OT disks
     // (disks with TGeoTubes doesn'n work properly in ACTS, due to polar coordinates on TGeoTube sides)
 
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
index 99322aa91f53f..4ed330c35ae59 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -124,7 +124,6 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
   } else if (sensor_height == 19.2 && sensor_width == 5) {
     x_offset = 0.7;
     y_offset = 9;
-
   } else {
     x_offset = sensor_width / 2;
     y_offset = sensor_height / 2;
@@ -146,14 +145,12 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
   if (Rin == 7 && sensor_height == 9.6 && sensor_width == 5) {
     x_condition_min = -Rin - 2;
     x_condition_max = Rin;
+    dist_offset = 2;
     adjust_bottom_y_pos = true;
     adjust_bottom_y_neg = true;
     x_adjust_bottom_y_pos = 3.5;
     bottom_y_pos_value = 3.5;
     bottom_y_neg_value = -3.5;
-
-    dist_offset = 2;
-
   } else if (Rin == 5 && sensor_height == 9.6 && sensor_width == 5) {
     x_condition_min = -Rin - 6;
     x_condition_max = Rin;
@@ -201,6 +198,15 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
     x_adjust_bottom_y_pos = 5.5;
     bottom_y_pos_value = 3.5;
     bottom_y_neg_value = -3.5;
+  } else if (Rin == 10 && sensor_height == 9.6 && sensor_width == 5.0) {
+    x_condition_min = -Rin - 4;
+    x_condition_max = Rin;
+    dist_offset = 2;
+    adjust_bottom_y_pos = false;
+    adjust_bottom_y_neg = false;
+    x_adjust_bottom_y_pos = 3.5;
+    bottom_y_pos_value = 3.5;
+    bottom_y_neg_value = -3.5;
   } else if (Rin == 20 && sensor_height == 9.6 && sensor_width == 5.0) {
     x_condition_min = -Rin - 4;
     x_condition_max = Rin;
@@ -244,7 +250,7 @@ void FT3Module::create_layout(double mZ, int layerNumber, int direction, double
       justSkipped1 = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0};
     }
   } else {
-    if (Rin == 20) { // v3 paving, rough attempt
+    if (Rin == 10 || Rin == 20) { // v3 paving, rough attempt
       float overlap = 0.3;
       // NB: these are left edges
       float X_start = -2.0 - 13.5 * (sensor_width - overlap);

From af3e63398be353dedec10d97545101eac2fee123 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <maximiliano.puccio@cern.ch>
Date: Mon, 13 Apr 2026 15:25:03 +0200
Subject: [PATCH 1542/1764] FastMultEst does not need to be streamed

---
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt                    | 1 -
 Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h | 2 --
 Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h             | 1 -
 3 files changed, 4 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index 8d8304d16764f..c9c5196da617b 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -52,7 +52,6 @@ o2_target_root_dictionary(ITStracking
                                   include/ITStracking/Tracklet.h
                                   include/ITStracking/Cluster.h
                                   include/ITStracking/Definitions.h
-                                  include/ITStracking/FastMultEst.h
                                   include/ITStracking/FastMultEstConfig.h
                                   include/ITStracking/TrackingConfigParam.h
                           LINKDEF src/TrackingLinkDef.h)
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h
index 3083a8fe9c2ec..f94c7c2034b46 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/FastMultEst.h
@@ -84,8 +84,6 @@ struct FastMultEst {
     return process(countClustersOnLayer(clusters));
   }
   static bool sSeedSet;
-
-  ClassDefNV(FastMultEst, 1);
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h b/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
index 9efd6dde0176d..0640ff98297b9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
@@ -42,7 +42,6 @@
 #pragma link C++ class o2::its::ITSGpuTrackingParamConfig + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::ITSGpuTrackingParamConfig> + ;
 
-#pragma link C++ class o2::its::FastMultEst + ;
 #pragma link C++ class o2::its::FastMultEstConfig + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::FastMultEstConfig> + ;
 

From 97af52220cb1a28a426b7dec6191e941235e52bb Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 16 Apr 2026 16:57:53 +0200
Subject: [PATCH 1543/1764] ITS: speedup final step in vertexer (#15279)

* ITS: speedup final step in vertexer

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: suppress low mult 2nd vertices

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/macros/test/CMakeLists.txt     |    6 +
 .../ITSMFT/ITS/macros/test/CheckSeeding.C     |  706 +++++++++++
 Detectors/ITSMFT/ITS/tracking/CMakeLists.txt  |    1 +
 .../include/ITStracking/ClusterLines.h        |    6 +-
 .../include/ITStracking/Configuration.h       |   39 +-
 .../include/ITStracking/LineVertexerHelpers.h |   46 +
 .../tracking/include/ITStracking/MathUtils.h  |   10 +
 .../include/ITStracking/TrackingConfigParam.h |   32 +-
 .../include/ITStracking/VertexerTraits.h      |    3 +
 .../ITSMFT/ITS/tracking/src/ClusterLines.cxx  |   32 +
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |   22 +-
 .../ITS/tracking/src/LineVertexerHelpers.cxx  | 1036 +++++++++++++++++
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |   13 +-
 .../ITS/tracking/src/TrackingInterface.cxx    |   13 +-
 .../ITS/tracking/src/VertexerTraits.cxx       |  309 +++--
 prodtests/full-system-test/dpl-workflow.sh    |   16 +-
 prodtests/full_system_test.sh                 |    2 +-
 prodtests/sim_challenge.sh                    |    2 +-
 18 files changed, 2121 insertions(+), 173 deletions(-)
 create mode 100644 Detectors/ITSMFT/ITS/macros/test/CheckSeeding.C
 create mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/LineVertexerHelpers.h
 create mode 100644 Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx

diff --git a/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt b/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
index a23682b085311..ffdbdf1990a32 100644
--- a/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/macros/test/CMakeLists.txt
@@ -128,3 +128,9 @@ o2_add_test_root_macro(CheckStaggering.C
                                              O2::DetectorsVertexing
                                              O2::ReconstructionDataFormats
                        LABELS its COMPILE_ONLY)
+
+o2_add_test_root_macro(CheckSeeding.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsITS
+                                             O2::SimulationDataFormat
+                                             O2::Steer
+                       LABELS its COMPILE_ONLY)
diff --git a/Detectors/ITSMFT/ITS/macros/test/CheckSeeding.C b/Detectors/ITSMFT/ITS/macros/test/CheckSeeding.C
new file mode 100644
index 0000000000000..915f2dda75032
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/macros/test/CheckSeeding.C
@@ -0,0 +1,706 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdio>
+#include <cstdint>
+#include <filesystem>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include <TCanvas.h>
+#include <TF1.h>
+#include <TH1.h>
+#include <TH1D.h>
+#include <TFile.h>
+#include <TLegend.h>
+#include <TPad.h>
+#include <TPaveText.h>
+#include <TStyle.h>
+#include <TTree.h>
+
+#include "DataFormatsITS/Vertex.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTrack.h"
+#include "SimulationDataFormat/O2DatabasePDG.h"
+#include "Steer/MCKinematicsReader.h"
+#endif
+
+constexpr const char* tracFile = "o2trac_its.root";
+constexpr const char* collContextFile = "collisioncontext.root";
+
+namespace
+{
+namespace fs = std::filesystem;
+
+constexpr float MinPt = 0.05f;
+constexpr float MaxEta = 1.1f;
+constexpr int NMultiplicityBins = 11;
+constexpr std::array<const char*, NMultiplicityBins> MultiplicityLabels{{"2", "3", "4-5", "6-8", "9-13", "14-21", "22-33", "34-52", "53-83", "84-128", "128+"}};
+
+struct TruthInfo {
+  int multiplicity = 0;
+  float x = 0.f;
+  float y = 0.f;
+  float z = 0.f;
+};
+
+struct BestRecoInfo {
+  o2::its::Vertex vertex;
+  float purity = -1.f;
+};
+
+struct GaussianSummary {
+  bool valid = false;
+  double mean = 0.;
+  double sigma = 0.;
+};
+
+bool isTrueVertexLabel(const o2::MCCompLabel& label)
+{
+  return label.isValid() && !label.isFake() && label.getSourceID() == 0;
+}
+
+bool isChargedPrimary(const o2::MCTrack& track)
+{
+  if (!track.isPrimary() || track.GetPt() < MinPt || std::abs(track.GetEta()) > MaxEta) {
+    return false;
+  }
+  auto* pdg = o2::O2DatabasePDG::Instance()->GetParticle(track.GetPdgCode());
+  return pdg != nullptr && pdg->Charge() != 0.;
+}
+
+bool isBetterReco(const o2::its::Vertex& candidate, float candidatePurity, const o2::its::Vertex& current, float currentPurity)
+{
+  if (candidatePurity != currentPurity) {
+    return candidatePurity > currentPurity;
+  }
+  if (candidate.getNContributors() != current.getNContributors()) {
+    return candidate.getNContributors() > current.getNContributors();
+  }
+  return candidate.getChi2() < current.getChi2();
+}
+
+int getMultiplicityCategory(int multiplicity)
+{
+  if (multiplicity <= 2) {
+    return 1;
+  }
+  if (multiplicity <= 3) {
+    return 2;
+  }
+  if (multiplicity <= 5) {
+    return 3;
+  }
+  if (multiplicity <= 8) {
+    return 4;
+  }
+  if (multiplicity <= 13) {
+    return 5;
+  }
+  if (multiplicity <= 21) {
+    return 6;
+  }
+  if (multiplicity <= 33) {
+    return 7;
+  }
+  if (multiplicity <= 52) {
+    return 8;
+  }
+  if (multiplicity <= 83) {
+    return 9;
+  }
+  if (multiplicity <= 128) {
+    return 10;
+  }
+  return 11;
+}
+
+void fillMultiplicityHistogram(TH1* hist, int multiplicity)
+{
+  hist->Fill(getMultiplicityCategory(multiplicity));
+}
+
+GaussianSummary fitGaussianCore(TH1* hist, const char* funcName)
+{
+  if (hist == nullptr || hist->GetEntries() < 20) {
+    return {};
+  }
+  const auto rms = hist->GetRMS();
+  if (!(rms > 0.)) {
+    return {};
+  }
+
+  TF1 fit(funcName, "gaus", hist->GetMean() - 2. * rms, hist->GetMean() + 2. * rms);
+  fit.SetParameters(hist->GetMaximum(), hist->GetMean(), rms);
+  hist->Fit(&fit, "Q0R");
+
+  const auto mean = fit.GetParameter(1);
+  const auto sigma = std::abs(fit.GetParameter(2));
+  if (!(sigma > 0.)) {
+    return {};
+  }
+
+  fit.SetRange(mean - 2. * sigma, mean + 2. * sigma);
+  hist->Fit(&fit, "Q0R");
+  return {true, fit.GetParameter(1), std::abs(fit.GetParameter(2))};
+}
+
+TH1D* makeNormalizedCopy(const TH1D* source, const char* name, const char* title)
+{
+  auto* copy = static_cast<TH1D*>(source->Clone(name));
+  copy->SetTitle(title);
+  const auto integral = copy->Integral("width");
+  if (integral > 0.) {
+    copy->Scale(1. / integral);
+  }
+  return copy;
+}
+
+void setMultiplicityBinLabels(TH1* hist)
+{
+  for (int i = 0; i < NMultiplicityBins; ++i) {
+    hist->GetXaxis()->SetBinLabel(i + 1, MultiplicityLabels[i]);
+  }
+}
+
+void setHistogramStyle(TH1* hist, int color, int marker)
+{
+  hist->SetLineColor(color);
+  hist->SetMarkerColor(color);
+  hist->SetMarkerStyle(marker);
+  hist->SetLineWidth(2);
+}
+
+void printGaussianByMultiplicity(const std::array<GaussianSummary, NMultiplicityBins>& summaries, const char* title)
+{
+  std::printf("%s:\n", title);
+  for (int i = 0; i < NMultiplicityBins; ++i) {
+    if (summaries[i].valid) {
+      std::printf("  %-4s : mean=%.6g sigma=%.6g\n", MultiplicityLabels[i], summaries[i].mean, summaries[i].sigma);
+    } else {
+      std::printf("  %-4s : n/a\n", MultiplicityLabels[i]);
+    }
+  }
+}
+
+fs::path resolveContextFile(const fs::path& dir)
+{
+  const std::array<fs::path, 3> candidates{
+    dir / collContextFile,
+    dir.parent_path() / collContextFile,
+    fs::current_path() / collContextFile};
+  for (const auto& candidate : candidates) {
+    if (!candidate.empty() && fs::exists(candidate) && fs::is_regular_file(candidate)) {
+      return candidate;
+    }
+  }
+  return {};
+}
+
+void printBinnedFractions(const TH1* numerator, const TH1* denominator, const char* title)
+{
+  if (numerator == nullptr || denominator == nullptr) {
+    return;
+  }
+  std::printf("%s:\n", title);
+  for (int iBin = 1; iBin <= denominator->GetNbinsX(); ++iBin) {
+    const auto den = denominator->GetBinContent(iBin);
+    const auto num = numerator->GetBinContent(iBin);
+    const auto value = den > 0. ? num / den : 0.;
+    std::printf("  %-4s : %.4f (%g / %g)\n", denominator->GetXaxis()->GetBinLabel(iBin), value, num, den);
+  }
+}
+
+std::vector<fs::path> findDirs(const std::string& roots)
+{
+  fs::path root = roots.empty() ? fs::current_path() : fs::path{roots};
+  std::vector<fs::path> result;
+  const auto hasFiles = [](const fs::path& dir) {
+    const auto tracPath = dir / tracFile;
+    return fs::exists(tracPath) && fs::is_regular_file(tracPath);
+  };
+
+  if (fs::is_directory(root) && hasFiles(root)) {
+    result.push_back(root);
+    return result;
+  }
+
+  for (const auto& entry : fs::recursive_directory_iterator(root)) {
+    if (entry.is_directory() && hasFiles(entry.path())) {
+      result.push_back(entry.path());
+    }
+  }
+  std::sort(result.begin(), result.end());
+  return result;
+}
+
+} // namespace
+
+void CheckSeeding(const std::string& dir = "")
+{
+  using Vertex = o2::its::Vertex;
+  const auto cwd = fs::current_path();
+  gStyle->SetOptStat(0);
+  TH1::AddDirectory(kFALSE);
+
+  auto dirs = findDirs(dir);
+  std::printf("Will iterate over %zu input dirs\n", dirs.size());
+  if (dirs.empty()) {
+    std::printf("No input directories containing %s were found.\n", tracFile);
+    return;
+  }
+
+  auto* hTruthMultiplicityFindable = new TH1D("hTruthMultiplicityFindable",
+                                              "Findable truth vertices;truth multiplicity bin;vertices",
+                                              NMultiplicityBins, 0.5, NMultiplicityBins + 0.5);
+  auto* hTruthMultiplicityFound = new TH1D("hTruthMultiplicityFound",
+                                           "Found truth vertices;truth multiplicity bin;vertices",
+                                           NMultiplicityBins, 0.5, NMultiplicityBins + 0.5);
+  auto* hRecoMultiplicityTrue = new TH1D("hRecoMultiplicityTrue",
+                                         "True reconstructed vertices;reco multiplicity bin;vertices",
+                                         NMultiplicityBins, 0.5, NMultiplicityBins + 0.5);
+  auto* hRecoMultiplicityFake = new TH1D("hRecoMultiplicityFake",
+                                         "Fake reconstructed vertices;reco multiplicity bin;vertices",
+                                         NMultiplicityBins, 0.5, NMultiplicityBins + 0.5);
+  auto* hDx = new TH1D("hDx", "Matched vertex residuals;x_{reco}-x_{MC} (cm);vertices", 400, -0.02, 0.02);
+  auto* hDy = new TH1D("hDy", "Matched vertex residuals;y_{reco}-y_{MC} (cm);vertices", 400, -0.02, 0.02);
+  auto* hDz = new TH1D("hDz", "Matched vertex residuals;z_{reco}-z_{MC} (cm);vertices", 400, -0.02, 0.02);
+  auto* hPullX = new TH1D("hPullX", "Matched vertex pulls;x pull;vertices", 600, -30., 30.);
+  auto* hPullY = new TH1D("hPullY", "Matched vertex pulls;y pull;vertices", 600, -30., 30.);
+  auto* hPullZ = new TH1D("hPullZ", "Matched vertex pulls;z pull;vertices", 600, -30., 30.);
+  std::array<TH1D*, NMultiplicityBins> hPullXByMult{};
+  std::array<TH1D*, NMultiplicityBins> hPullYByMult{};
+  std::array<TH1D*, NMultiplicityBins> hPullZByMult{};
+  for (int i = 0; i < NMultiplicityBins; ++i) {
+    const auto nameX = std::string("hPullX_") + std::to_string(i + 1);
+    const auto nameY = std::string("hPullY_") + std::to_string(i + 1);
+    const auto nameZ = std::string("hPullZ_") + std::to_string(i + 1);
+    const auto titleX = std::string("x pull ") + MultiplicityLabels[i] + ";x pull;vertices";
+    const auto titleY = std::string("y pull ") + MultiplicityLabels[i] + ";y pull;vertices";
+    const auto titleZ = std::string("z pull ") + MultiplicityLabels[i] + ";z pull;vertices";
+    hPullXByMult[i] = new TH1D(nameX.c_str(), titleX.c_str(), 600, -30., 30.);
+    hPullYByMult[i] = new TH1D(nameY.c_str(), titleY.c_str(), 600, -30., 30.);
+    hPullZByMult[i] = new TH1D(nameZ.c_str(), titleZ.c_str(), 600, -30., 30.);
+  }
+
+  setMultiplicityBinLabels(hTruthMultiplicityFindable);
+  setMultiplicityBinLabels(hTruthMultiplicityFound);
+  setMultiplicityBinLabels(hRecoMultiplicityTrue);
+  setMultiplicityBinLabels(hRecoMultiplicityFake);
+  setHistogramStyle(hTruthMultiplicityFindable, kGray + 2, 20);
+  setHistogramStyle(hTruthMultiplicityFound, kAzure + 2, 20);
+  setHistogramStyle(hRecoMultiplicityTrue, kAzure + 2, 20);
+  setHistogramStyle(hRecoMultiplicityFake, kOrange + 7, 24);
+  setHistogramStyle(hDx, kAzure + 2, 20);
+  setHistogramStyle(hDy, kGreen + 2, 21);
+  setHistogramStyle(hDz, kRed + 1, 24);
+  setHistogramStyle(hPullX, kAzure + 2, 20);
+  setHistogramStyle(hPullY, kGreen + 2, 21);
+  setHistogramStyle(hPullZ, kRed + 1, 24);
+
+  size_t findable = 0;
+  size_t totalFound = 0;
+  size_t trueFound = 0;
+  size_t fakeFound = 0;
+  size_t uniqueTrueReco = 0;
+  size_t uniqueFindableFound = 0;
+  size_t sigmaXCount = 0;
+  size_t sigmaYCount = 0;
+  size_t sigmaZCount = 0;
+  double sumSigmaX = 0.;
+  double sumSigmaY = 0.;
+  double sumSigmaZ = 0.;
+
+  for (const auto& inputDir : dirs) {
+    fs::current_path(inputDir);
+    std::printf("Working on %s\n", inputDir.c_str());
+    const auto contextPath = resolveContextFile(inputDir);
+    if (contextPath.empty()) {
+      std::printf("Skipping %s: could not locate %s\n", inputDir.c_str(), collContextFile);
+      continue;
+    }
+
+    o2::steer::MCKinematicsReader mcReader(contextPath.string());
+    if (!mcReader.isInitialized()) {
+      std::printf("Skipping %s: failed to initialize MCKinematicsReader from %s\n", inputDir.c_str(), contextPath.c_str());
+      continue;
+    }
+
+    std::unordered_map<int, TruthInfo> findableTruths;
+    std::unordered_set<int> uniqueTrueLabelsReco;
+    std::unordered_set<int> uniqueFindableTruthFound;
+    std::unordered_map<int, BestRecoInfo> bestRecoByTruth;
+
+    const int iSrc = 0;
+    const auto nEvents = static_cast<int>(mcReader.getNEvents(iSrc));
+    for (int iEve = 0; iEve < nEvents; ++iEve) {
+      const auto& tracks = mcReader.getTracks(iSrc, iEve);
+      const auto contributors = static_cast<int>(std::count_if(tracks.begin(), tracks.end(), isChargedPrimary));
+      if (contributors >= 2) {
+        const auto& header = mcReader.getMCEventHeader(iSrc, iEve);
+        findableTruths.emplace(iEve, TruthInfo{contributors, (float)header.GetX(), (float)header.GetY(), (float)header.GetZ()});
+        fillMultiplicityHistogram(hTruthMultiplicityFindable, contributors);
+      }
+      mcReader.releaseTracksForSourceAndEvent(iSrc, iEve);
+    }
+
+    auto* tracFileHandle = TFile::Open((inputDir / tracFile).c_str());
+    if (tracFileHandle == nullptr || tracFileHandle->IsZombie()) {
+      std::printf("Skipping %s: failed to open %s\n", inputDir.c_str(), tracFile);
+      delete tracFileHandle;
+      continue;
+    }
+
+    auto* tracTree = tracFileHandle->Get<TTree>("o2sim");
+    if (tracTree == nullptr) {
+      std::printf("Skipping %s: missing o2sim tree in %s\n", inputDir.c_str(), tracFile);
+      tracFileHandle->Close();
+      delete tracFileHandle;
+      continue;
+    }
+
+    if (tracTree->GetBranch("Vertices") == nullptr || tracTree->GetBranch("ITSVertexMCTruth") == nullptr) {
+      std::printf("Skipping %s: missing vertex branches in %s\n", inputDir.c_str(), tracFile);
+      tracFileHandle->Close();
+      delete tracFileHandle;
+      continue;
+    }
+
+    std::vector<Vertex>* vertices = nullptr;
+    std::vector<o2::MCCompLabel>* labels = nullptr;
+    std::vector<float>* purities = nullptr;
+    const bool hasPurityBranch = tracTree->GetBranch("ITSVertexMCPurity") != nullptr;
+
+    tracTree->SetBranchAddress("Vertices", &vertices);
+    tracTree->SetBranchAddress("ITSVertexMCTruth", &labels);
+    if (hasPurityBranch) {
+      tracTree->SetBranchAddress("ITSVertexMCPurity", &purities);
+    }
+
+    const auto nEntries = tracTree->GetEntriesFast();
+    for (Long64_t iEntry = 0; iEntry < nEntries; ++iEntry) {
+      tracTree->GetEntry(iEntry);
+      if (vertices == nullptr || labels == nullptr) {
+        continue;
+      }
+      auto nVertices = std::min(vertices->size(), labels->size());
+      if (hasPurityBranch && purities != nullptr) {
+        nVertices = std::min(nVertices, purities->size());
+      }
+
+      for (size_t iVtx = 0; iVtx < nVertices; ++iVtx) {
+        const auto& vertex = (*vertices)[iVtx];
+        const auto& label = (*labels)[iVtx];
+        const auto multiplicity = static_cast<int>(vertex.getNContributors());
+        ++totalFound;
+
+        if (!isTrueVertexLabel(label)) {
+          ++fakeFound;
+          fillMultiplicityHistogram(hRecoMultiplicityFake, multiplicity);
+          continue;
+        }
+
+        ++trueFound;
+        const auto eventID = label.getEventID();
+        uniqueTrueLabelsReco.insert(eventID);
+        fillMultiplicityHistogram(hRecoMultiplicityTrue, multiplicity);
+
+        const auto truthIt = findableTruths.find(eventID);
+        if (truthIt == findableTruths.end()) {
+          continue;
+        }
+
+        uniqueFindableTruthFound.insert(eventID);
+        const auto purity = (hasPurityBranch && purities != nullptr) ? (*purities)[iVtx] : -1.f;
+        const auto bestIt = bestRecoByTruth.find(eventID);
+        if (bestIt == bestRecoByTruth.end() || isBetterReco(vertex, purity, bestIt->second.vertex, bestIt->second.purity)) {
+          bestRecoByTruth[eventID] = BestRecoInfo{vertex, purity};
+        }
+      }
+    }
+
+    tracFileHandle->Close();
+    delete tracFileHandle;
+
+    findable += findableTruths.size();
+    uniqueTrueReco += uniqueTrueLabelsReco.size();
+    uniqueFindableFound += uniqueFindableTruthFound.size();
+
+    for (const auto eventID : uniqueFindableTruthFound) {
+      const auto truthIt = findableTruths.find(eventID);
+      if (truthIt != findableTruths.end()) {
+        fillMultiplicityHistogram(hTruthMultiplicityFound, truthIt->second.multiplicity);
+      }
+    }
+
+    for (const auto& [eventID, reco] : bestRecoByTruth) {
+      const auto truthIt = findableTruths.find(eventID);
+      if (truthIt == findableTruths.end()) {
+        continue;
+      }
+      const auto dx = reco.vertex.getX() - truthIt->second.x;
+      const auto dy = reco.vertex.getY() - truthIt->second.y;
+      const auto dz = reco.vertex.getZ() - truthIt->second.z;
+      hDx->Fill(dx);
+      hDy->Fill(dy);
+      hDz->Fill(dz);
+      if (reco.vertex.getSigmaX() > 0.f) {
+        const auto pullX = dx / reco.vertex.getSigmaX();
+        hPullX->Fill(pullX);
+        hPullXByMult[getMultiplicityCategory(reco.vertex.getNContributors()) - 1]->Fill(pullX);
+        sumSigmaX += reco.vertex.getSigmaX();
+        ++sigmaXCount;
+      }
+      if (reco.vertex.getSigmaY() > 0.f) {
+        const auto pullY = dy / reco.vertex.getSigmaY();
+        hPullY->Fill(pullY);
+        hPullYByMult[getMultiplicityCategory(reco.vertex.getNContributors()) - 1]->Fill(pullY);
+        sumSigmaY += reco.vertex.getSigmaY();
+        ++sigmaYCount;
+      }
+      if (reco.vertex.getSigmaZ() > 0.f) {
+        const auto pullZ = dz / reco.vertex.getSigmaZ();
+        hPullZ->Fill(pullZ);
+        hPullZByMult[getMultiplicityCategory(reco.vertex.getNContributors()) - 1]->Fill(pullZ);
+        sumSigmaZ += reco.vertex.getSigmaZ();
+        ++sigmaZCount;
+      }
+    }
+    fs::current_path(cwd);
+  }
+
+  auto* hTruthMultiplicityEfficiency = static_cast<TH1D*>(hTruthMultiplicityFound->Clone("hTruthMultiplicityEfficiency"));
+  hTruthMultiplicityEfficiency->SetTitle("Unique efficiency vs truth multiplicity;truth multiplicity bin;efficiency");
+  hTruthMultiplicityEfficiency->Divide(hTruthMultiplicityFound, hTruthMultiplicityFindable, 1., 1., "B");
+  setMultiplicityBinLabels(hTruthMultiplicityEfficiency);
+  hTruthMultiplicityEfficiency->SetMinimum(0.);
+  hTruthMultiplicityEfficiency->SetMaximum(1.05);
+
+  auto* hRecoMultiplicityTotal = static_cast<TH1D*>(hRecoMultiplicityTrue->Clone("hRecoMultiplicityTotal"));
+  hRecoMultiplicityTotal->SetTitle("All reconstructed vertices;reco multiplicity bin;vertices");
+  hRecoMultiplicityTotal->Add(hRecoMultiplicityFake);
+  setMultiplicityBinLabels(hRecoMultiplicityTotal);
+
+  auto* hRecoMultiplicityPurity = static_cast<TH1D*>(hRecoMultiplicityTrue->Clone("hRecoMultiplicityPurity"));
+  hRecoMultiplicityPurity->SetTitle("Purity vs reconstructed multiplicity;reco multiplicity bin;purity");
+  hRecoMultiplicityPurity->Divide(hRecoMultiplicityTrue, hRecoMultiplicityTotal, 1., 1., "B");
+  setMultiplicityBinLabels(hRecoMultiplicityPurity);
+  hRecoMultiplicityPurity->SetMinimum(0.);
+  hRecoMultiplicityPurity->SetMaximum(1.05);
+
+  const auto duplicates = trueFound >= uniqueTrueReco ? (trueFound - uniqueTrueReco) : 0UL;
+
+  const double uniqueEfficiency = findable > 0 ? static_cast<double>(uniqueFindableFound) / findable : 0.;
+  const double purity = totalFound > 0 ? static_cast<double>(trueFound) / totalFound : 0.;
+  const double fakeRate = totalFound > 0 ? static_cast<double>(fakeFound) / totalFound : 0.;
+  const double duplicateRate = trueFound > 0 ? static_cast<double>(duplicates) / trueFound : 0.;
+  const double f1 = (uniqueEfficiency + purity) > 0. ? 2. * uniqueEfficiency * purity / (uniqueEfficiency + purity) : 0.;
+
+  const auto dxFit = fitGaussianCore(hDx, "fitDx");
+  const auto dyFit = fitGaussianCore(hDy, "fitDy");
+  const auto dzFit = fitGaussianCore(hDz, "fitDz");
+  const auto pullXFit = fitGaussianCore(hPullX, "fitPullX");
+  const auto pullYFit = fitGaussianCore(hPullY, "fitPullY");
+  const auto pullZFit = fitGaussianCore(hPullZ, "fitPullZ");
+  std::array<GaussianSummary, NMultiplicityBins> pullXByMultFit{};
+  std::array<GaussianSummary, NMultiplicityBins> pullYByMultFit{};
+  std::array<GaussianSummary, NMultiplicityBins> pullZByMultFit{};
+  for (int i = 0; i < NMultiplicityBins; ++i) {
+    const auto fitX = std::string("fitPullX_") + std::to_string(i + 1);
+    const auto fitY = std::string("fitPullY_") + std::to_string(i + 1);
+    const auto fitZ = std::string("fitPullZ_") + std::to_string(i + 1);
+    pullXByMultFit[i] = fitGaussianCore(hPullXByMult[i], fitX.c_str());
+    pullYByMultFit[i] = fitGaussianCore(hPullYByMult[i], fitY.c_str());
+    pullZByMultFit[i] = fitGaussianCore(hPullZByMult[i], fitZ.c_str());
+  }
+
+  std::printf("\nVertex validation summary\n");
+  std::printf("  findable truth vertices      : %zu\n", findable);
+  std::printf("  total reconstructed vertices : %zu\n", totalFound);
+  std::printf("  true reconstructed vertices  : %zu\n", trueFound);
+  std::printf("  fake reconstructed vertices  : %zu\n", fakeFound);
+  std::printf("  unique true labels (all)     : %zu\n", uniqueTrueReco);
+  std::printf("  unique findable truth found  : %zu\n", uniqueFindableFound);
+  std::printf("  unique efficiency            : %.5f\n", uniqueEfficiency);
+  std::printf("  purity                       : %.5f\n", purity);
+  std::printf("  fake rate                    : %.5f\n", fakeRate);
+  std::printf("  duplicate rate               : %.5f\n", duplicateRate);
+  std::printf("  F1(purity,efficiency)        : %.5f\n", f1);
+  std::printf("  mean reported sigma x/y/z    : %.6g / %.6g / %.6g cm\n",
+              sigmaXCount > 0 ? sumSigmaX / sigmaXCount : 0.,
+              sigmaYCount > 0 ? sumSigmaY / sigmaYCount : 0.,
+              sigmaZCount > 0 ? sumSigmaZ / sigmaZCount : 0.);
+
+  if (dxFit.valid) {
+    std::printf("  x residual Gaussian: mean=%.6g cm sigma=%.6g cm\n", dxFit.mean, dxFit.sigma);
+  }
+  if (dyFit.valid) {
+    std::printf("  y residual Gaussian: mean=%.6g cm sigma=%.6g cm\n", dyFit.mean, dyFit.sigma);
+  }
+  if (dzFit.valid) {
+    std::printf("  z residual Gaussian: mean=%.6g cm sigma=%.6g cm\n", dzFit.mean, dzFit.sigma);
+  }
+  if (pullXFit.valid) {
+    std::printf("  x pull Gaussian    : mean=%.6g sigma=%.6g\n", pullXFit.mean, pullXFit.sigma);
+  }
+  if (pullYFit.valid) {
+    std::printf("  y pull Gaussian    : mean=%.6g sigma=%.6g\n", pullYFit.mean, pullYFit.sigma);
+  }
+  if (pullZFit.valid) {
+    std::printf("  z pull Gaussian    : mean=%.6g sigma=%.6g\n", pullZFit.mean, pullZFit.sigma);
+  }
+  printGaussianByMultiplicity(pullXByMultFit, "x pull Gaussian by reconstructed multiplicity");
+  printGaussianByMultiplicity(pullYByMultFit, "y pull Gaussian by reconstructed multiplicity");
+  printGaussianByMultiplicity(pullZByMultFit, "z pull Gaussian by reconstructed multiplicity");
+
+  printBinnedFractions(hTruthMultiplicityFound, hTruthMultiplicityFindable, "Efficiency vs truth multiplicity");
+  printBinnedFractions(hRecoMultiplicityTrue, hRecoMultiplicityTotal, "Purity vs reconstructed multiplicity");
+
+  auto* cValidation = new TCanvas("cVertexValidation", "Vertex validation summary", 1800, 1000);
+  cValidation->Divide(3, 2);
+
+  cValidation->cd(1);
+  gPad->SetMargin(0.05, 0.05, 0.05, 0.05);
+  auto* summary = new TPaveText(0.02, 0.02, 0.98, 0.98, "NDC");
+  summary->SetBorderSize(0);
+  summary->SetFillColor(0);
+  summary->SetTextAlign(12);
+  summary->SetTextFont(42);
+  char line[256];
+  std::snprintf(line, sizeof(line), "Findable truth vertices : %zu", findable);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "Total reconstructed     : %zu", totalFound);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "True reconstructed      : %zu", trueFound);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "Fake reconstructed      : %zu", fakeFound);
+  summary->AddText(line);
+  summary->AddText("");
+  std::snprintf(line, sizeof(line), "Unique truth found      : %zu", uniqueFindableFound);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "Unique efficiency       : %.5f", uniqueEfficiency);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "Purity                  : %.5f", purity);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "Fake rate               : %.5f", fakeRate);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "Duplicate rate          : %.5f", duplicateRate);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "F1                      : %.5f", f1);
+  summary->AddText(line);
+  std::snprintf(line, sizeof(line), "mean sigma x/y/z cm     : %.3g / %.3g / %.3g",
+                sigmaXCount > 0 ? sumSigmaX / sigmaXCount : 0.,
+                sigmaYCount > 0 ? sumSigmaY / sigmaYCount : 0.,
+                sigmaZCount > 0 ? sumSigmaZ / sigmaZCount : 0.);
+  summary->AddText(line);
+  summary->AddText("");
+  if (dxFit.valid) {
+    std::snprintf(line, sizeof(line), "dx fit mean/sigma cm : %.3g / %.3g", dxFit.mean, dxFit.sigma);
+    summary->AddText(line);
+  }
+  if (dyFit.valid) {
+    std::snprintf(line, sizeof(line), "dy fit mean/sigma cm : %.3g / %.3g", dyFit.mean, dyFit.sigma);
+    summary->AddText(line);
+  }
+  if (dzFit.valid) {
+    std::snprintf(line, sizeof(line), "dz fit mean/sigma cm : %.3g / %.3g", dzFit.mean, dzFit.sigma);
+    summary->AddText(line);
+  }
+  if (pullXFit.valid) {
+    std::snprintf(line, sizeof(line), "pull x sigma         : %.3g", pullXFit.sigma);
+    summary->AddText(line);
+  }
+  if (pullYFit.valid) {
+    std::snprintf(line, sizeof(line), "pull y sigma         : %.3g", pullYFit.sigma);
+    summary->AddText(line);
+  }
+  if (pullZFit.valid) {
+    std::snprintf(line, sizeof(line), "pull z sigma         : %.3g", pullZFit.sigma);
+    summary->AddText(line);
+  }
+  summary->Draw();
+
+  cValidation->cd(2);
+  gPad->SetGridy();
+  hTruthMultiplicityEfficiency->Draw("hist e1");
+
+  cValidation->cd(3);
+  gPad->SetGridy();
+  const auto maxReco = std::max(hRecoMultiplicityTrue->GetMaximum(), hRecoMultiplicityFake->GetMaximum());
+  hRecoMultiplicityTrue->SetMaximum(1.2 * std::max(1., maxReco));
+  hRecoMultiplicityTrue->Draw("hist e1");
+  hRecoMultiplicityFake->Draw("hist e1 same");
+  auto hRecoMultiplicitySum = (TH1D*)hRecoMultiplicityTrue->Clone("hRecoMultiplicitySum");
+  hRecoMultiplicitySum->Add(hRecoMultiplicityFake);
+  setHistogramStyle(hRecoMultiplicitySum, kBlack, 23);
+  hRecoMultiplicitySum->Draw("hist e1 same");
+  {
+    auto* legend = new TLegend(0.58, 0.75, 0.88, 0.88);
+    legend->SetBorderSize(0);
+    legend->AddEntry(hRecoMultiplicityTrue, "true", "lep");
+    legend->AddEntry(hRecoMultiplicityFake, "fake", "lep");
+    legend->AddEntry(hRecoMultiplicitySum, "sum", "lep");
+    legend->Draw();
+  }
+
+  cValidation->cd(4);
+  gPad->SetGridy();
+  hRecoMultiplicityPurity->Draw("hist e1");
+
+  cValidation->cd(5);
+  gPad->SetGridy();
+  auto* hDxNorm = makeNormalizedCopy(hDx, "hDxNorm", "Matched vertex residuals;residual (cm);normalized entries");
+  auto* hDyNorm = makeNormalizedCopy(hDy, "hDyNorm", "Matched vertex residuals;residual (cm);normalized entries");
+  auto* hDzNorm = makeNormalizedCopy(hDz, "hDzNorm", "Matched vertex residuals;residual (cm);normalized entries");
+  const auto maxResidual = std::max({hDxNorm->GetMaximum(), hDyNorm->GetMaximum(), hDzNorm->GetMaximum()});
+  hDzNorm->SetMaximum(1.2 * std::max(1., maxResidual));
+  hDzNorm->Draw("hist");
+  hDxNorm->Draw("hist same");
+  hDyNorm->Draw("hist same");
+  {
+    auto* legend = new TLegend(0.62, 0.72, 0.88, 0.88);
+    legend->SetBorderSize(0);
+    legend->AddEntry(hDxNorm, "dx", "l");
+    legend->AddEntry(hDyNorm, "dy", "l");
+    legend->AddEntry(hDzNorm, "dz", "l");
+    legend->Draw();
+  }
+
+  cValidation->cd(6);
+  gPad->SetGridy();
+  auto* hPullXNorm = makeNormalizedCopy(hPullX, "hPullXNorm", "Matched vertex pulls;pull;normalized entries");
+  auto* hPullYNorm = makeNormalizedCopy(hPullY, "hPullYNorm", "Matched vertex pulls;pull;normalized entries");
+  auto* hPullZNorm = makeNormalizedCopy(hPullZ, "hPullZNorm", "Matched vertex pulls;pull;normalized entries");
+  const auto maxPull = std::max({hPullXNorm->GetMaximum(), hPullYNorm->GetMaximum(), hPullZNorm->GetMaximum()});
+  hPullZNorm->SetMaximum(1.2 * std::max(1., maxPull));
+  hPullZNorm->Draw("hist");
+  hPullXNorm->Draw("hist same");
+  hPullYNorm->Draw("hist same");
+  {
+    auto* legend = new TLegend(0.62, 0.72, 0.88, 0.88);
+    legend->SetBorderSize(0);
+    legend->AddEntry(hPullXNorm, "pull x", "l");
+    legend->AddEntry(hPullYNorm, "pull y", "l");
+    legend->AddEntry(hPullZNorm, "pull z", "l");
+    legend->Draw();
+  }
+
+  cValidation->cd();
+  cValidation->Update();
+  cValidation->SaveAs("checkSeeding.pdf");
+}
diff --git a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
index c9c5196da617b..1dd64b6f1874b 100644
--- a/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/CMakeLists.txt
@@ -16,6 +16,7 @@ o2_add_library(ITStracking
                        src/Configuration.cxx
                        src/FastMultEstConfig.cxx
                        src/FastMultEst.cxx
+                       src/LineVertexerHelpers.cxx
                        src/TimeFrame.cxx
                        src/IOUtils.cxx
                        src/Tracker.cxx
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
index 6fbc6d7da7721..bcb8a98a62cab 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/ClusterLines.h
@@ -12,8 +12,9 @@
 #ifndef O2_ITS_CLUSTERLINES_H
 #define O2_ITS_CLUSTERLINES_H
 
-#include <array>
+#include <gsl/span>
 #include <vector>
+#include <array>
 #include <Math/SMatrix.h>
 #include <Math/SVector.h>
 #include "ITStracking/Cluster.h"
@@ -59,6 +60,7 @@ class ClusterLines final
  public:
   ClusterLines() = default;
   ClusterLines(const int firstLabel, const Line& firstLine, const int secondLabel, const Line& secondLine);
+  ClusterLines(gsl::span<const int> lineLabels, gsl::span<const Line> lines);
   void add(const int lineLabel, const Line& line);
   void computeClusterCentroid();
   void accumulate(const Line& line);
@@ -67,7 +69,7 @@ class ClusterLines final
   const float* getRMS2() const { return mRMS2.Array(); }
   float getAvgDistance2() const { return mAvgDistance2; }
   auto getSize() const noexcept { return mLabels.size(); }
-  auto& getLabels() noexcept { return mLabels; }
+  auto& getLabels() const noexcept { return mLabels; }
   const auto& getTimeStamp() const noexcept { return mTime; }
   bool operator==(const ClusterLines& rhs) const noexcept;
   float getR2() const noexcept { return (mVertex[0] * mVertex[0]) + (mVertex[1] * mVertex[1]); }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 02dbeb8cf3992..1f55a95ca0d65 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -18,11 +18,9 @@
 
 #include <cstdint>
 #ifndef GPUCA_GPUCODE_DEVICE
-#include <array>
 #include <limits>
 #include <string>
 #include <vector>
-#include <cmath>
 #endif
 
 #include "DetectorsBase/Propagator.h"
@@ -89,21 +87,28 @@ struct VertexingParameters {
   int nIterations = 1; // Number of vertexing passes to perform
   std::vector<float> LayerZ = {16.333f + 1, 16.333f + 1, 16.333f + 1, 42.140f + 1, 42.140f + 1, 73.745f + 1, 73.745f + 1};
   std::vector<float> LayerRadii = {2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f};
-  int ZBins{1};
-  int PhiBins{128};
-  float zCut = 0.002f;
-  float phiCut = 0.005f;
-  float pairCut = 0.04f;
-  float clusterCut = 0.8f;
-  float histPairCut = 0.04f;
-  float tanLambdaCut = 0.002f;     // tanLambda = deltaZ/deltaR
-  float lowMultBeamDistCut = 0.1f; // XY cut for low-multiplicity pile up
-  int vertNsigmaCut = 6;           // N sigma cut for vertex XY
-  float vertRadiusSigma = 0.33f;   // sigma of vertex XY
-  float trackletSigma = 0.01f;     // tracklet to vertex sigma
-  float maxZPositionAllowed = 25.f;
-  int clusterContributorsCut = 16;
-  int maxTrackletsPerCluster = 2e3;
+  int ZBins = 1;
+  int PhiBins = 128;
+  float zCut = -1.f;
+  float phiCut = -1.f;
+  float pairCut = -1.f;
+  float clusterCut = -1.f;
+  float coarseZWindow = -1.f;
+  float seedDedupZCut = -1.f;
+  float refitDedupZCut = -1.f;
+  float duplicateZCut = -1.f;
+  float finalSelectionZCut = -1.f;
+  float duplicateDistance2Cut = -1.f;
+  float tanLambdaCut = -1.f;
+  float vertNsigmaCut = -1.f;
+  float vertRadiusSigma = -1.f;
+  float trackletSigma = -1.f;
+  float maxZPositionAllowed = -1.f;
+  int clusterContributorsCut = -1;
+  int suppressLowMultDebris = -1;
+  int seedMemberRadiusTime = -1;
+  int seedMemberRadiusZ = -1;
+  int maxTrackletsPerCluster = -1;
   int phiSpan = -1;
   int zSpan = -1;
   bool SaveTimeBenchmarks = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LineVertexerHelpers.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LineVertexerHelpers.h
new file mode 100644
index 0000000000000..0e3807aba8efb
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LineVertexerHelpers.h
@@ -0,0 +1,46 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS_TRACKING_LINE_VERTEXER_HELPERS_H_
+#define O2_ITS_TRACKING_LINE_VERTEXER_HELPERS_H_
+
+#include <memory>
+#include <span>
+
+#include "ITStracking/BoundedAllocator.h"
+#include "ITStracking/ClusterLines.h"
+
+namespace o2::its::line_vertexer
+{
+
+struct Settings {
+  float beamX = 0.f;
+  float beamY = 0.f;
+  float pairCut = 0.f;
+  float pairCut2 = 0.f;
+  float clusterCut = 0.f;
+  float coarseZWindow = 0.f;
+  float seedDedupZCut = 0.f;
+  float refitDedupZCut = 0.f;
+  float duplicateZCut = 0.f;
+  float duplicateDistance2Cut = 0.f;
+  float finalSelectionZCut = 0.f;
+  float maxZ = 0.f;
+  int seedMemberRadiusTime = 1;
+  int seedMemberRadiusZ = 2;
+  std::shared_ptr<BoundedMemoryResource> memoryPool;
+};
+
+bounded_vector<ClusterLines> buildClusters(std::span<const Line> lines, const Settings& settings);
+
+} // namespace o2::its::line_vertexer
+
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
index 95e0b4554e32c..ab3c7d5d29873 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
@@ -94,6 +94,16 @@ GPUhdi() constexpr float Sq(float v)
   return v * v;
 }
 
+GPUhdi() constexpr float SqSum(float v, float w)
+{
+  return Sq(v) + Sq(w);
+}
+
+GPUhdi() constexpr float SqSum(float u, float v, float w)
+{
+  return Sq(u) + SqSum(v, w);
+}
+
 GPUhdi() constexpr float SqDiff(float x, float y)
 {
   return Sq(x - y);
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index e77200a1432d1..cb291b46f5e44 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -24,24 +24,30 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
 
   int nIterations = 1;         // Number of vertexing passes to perform.
   int vertPerRofThreshold = 0; // Maximum number of vertices per ROF to trigger second a iteration.
-  int deltaRof = 0;            // Number of ROFs to be considered for the vertexing.
 
   // geometrical cuts for tracklet selection
   float zCut = 0.002f;
-  float phiCut = 0.005f;
-  float pairCut = 0.04f;
-  float clusterCut = 0.8f;
-  float histPairCut = 0.04f;
-  float tanLambdaCut = 0.002f;      // tanLambda = deltaZ/deltaR
-  float lowMultBeamDistCut = 0.1f;  // XY cut for low-multiplicity pile up
-  int vertNsigmaCut = 4;            // N sigma cut for vertex XY
-  float vertRadiusSigma = 0.05f;    // sigma of vertex XY
-  float trackletSigma = 0.01f;      // tracklet to vertex sigma
-  float maxZPositionAllowed = 25.f; // 4x sZ of the beam
+  float phiCut = 0.4f;
+  float pairCut = 0.0211211f;
+  float clusterCut = 0.4275412f;
+  float coarseZWindow = 0.6521316f;
+  float seedDedupZCut = 0.1461061f;
+  float refitDedupZCut = 0.1873750f;
+  float duplicateZCut = 0.7985643f;
+  float finalSelectionZCut = 0.2932624f;
+  float duplicateDistance2Cut = 0.0223001f;
+  float tanLambdaCut = 0.17f;         // tanLambda = deltaZ/deltaR
+  float vertNsigmaCut = 5.8762583f;   // N sigma cut for vertex XY
+  float vertRadiusSigma = 0.0343575f; // sigma of vertex XY
+  float trackletSigma = 0.0143798f;   // tracklet to vertex sigma
+  float maxZPositionAllowed = 25.f;   // 4x sZ of the beam
 
   // Artefacts selections
-  int clusterContributorsCut = 16; // minimum number of contributors for the second vertex found in the same ROF (pileup cut)
-  int maxTrackletsPerCluster = 1e2;
+  int clusterContributorsCut = 3; // minimum number of contributors for an accepted final vertex
+  int suppressLowMultDebris = 16; // suppress all vertices below this threshold if a vertex was already found in a rof
+  int seedMemberRadiusTime = 0;
+  int seedMemberRadiusZ = 2;
+  int maxTrackletsPerCluster = 100;
   int phiSpan = -1;
   int zSpan = -1;
   int ZBins = 1;     // z-phi index table configutation: number of z bins
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 02ecbe2be8eea..5b609c2fa6c85 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -102,6 +102,9 @@ class VertexerTraits
         elem = key;
       }
     }
+    if (maxCount <= 1) { // need >50%
+      elem.setFakeFlag();
+    }
     return std::make_pair(elem, static_cast<float>(maxCount) / static_cast<float>(elements.size()));
   }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx b/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
index f561fe0436c4a..3e3e1b8b46338 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/ClusterLines.cxx
@@ -148,6 +148,38 @@ ClusterLines::ClusterLines(const int firstLabel, const Line& firstLine, const in
   mAvgDistance2 += (Line::getDistance2FromPoint(secondLine, mVertex) - mAvgDistance2) / (float)getSize();
 }
 
+ClusterLines::ClusterLines(gsl::span<const int> lineLabels, gsl::span<const Line> lines)
+{
+  if (lineLabels.size() < 2) {
+    return;
+  }
+
+  mLabels.reserve(lineLabels.size());
+  mTime = lines[lineLabels[0]].mTime;
+  for (size_t index = 0; index < lineLabels.size(); ++index) {
+    const auto lineLabel = lineLabels[index];
+    if (index > 0) {
+      mTime += lines[lineLabel].mTime;
+    }
+    mLabels.push_back(lineLabel);
+    accumulate(lines[lineLabel]);
+  }
+
+  computeClusterCentroid();
+  if (!mIsValid) {
+    return;
+  }
+
+  mRMS2 = Line::getDCAComponents(lines[lineLabels[0]], mVertex);
+  mAvgDistance2 = Line::getDistance2FromPoint(lines[lineLabels[0]], mVertex);
+  for (size_t index = 1; index < lineLabels.size(); ++index) {
+    const auto lineLabel = lineLabels[index];
+    const auto tmpRMS2 = Line::getDCAComponents(lines[lineLabel], mVertex);
+    mRMS2 += (tmpRMS2 - mRMS2) * (1.f / static_cast<float>(index + 1));
+    mAvgDistance2 += (Line::getDistance2FromPoint(lines[lineLabel], mVertex) - mAvgDistance2) / static_cast<float>(index + 1);
+  }
+}
+
 void ClusterLines::add(const int lineLabel, const Line& line)
 {
   mTime += line.mTime;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index c447bb6bcc880..6c88b61f2df07 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -45,8 +45,8 @@ std::string TrackingParameters::asString() const
   }
   if (!AddTimeError.empty()) {
     str += " AddTimeError:";
-    for (size_t i = 0; i < AddTimeError.size(); i++) {
-      str += std::format("{} ", AddTimeError[i]);
+    for (unsigned int i : AddTimeError) {
+      str += std::format("{} ", i);
     }
   }
   if (std::numeric_limits<size_t>::max() != MaxMemory) {
@@ -57,7 +57,8 @@ std::string TrackingParameters::asString() const
 
 std::string VertexingParameters::asString() const
 {
-  std::string str = std::format("NZb:{} NPhB:{} ClsCont:{} MaxTrkltCls:{} ZCut:{} PhCut:{}", ZBins, PhiBins, clusterContributorsCut, maxTrackletsPerCluster, zCut, phiCut);
+  std::string str = std::format("NZb:{} NPhB:{} MinVtxCont:{} SupLowMultDebris:{} MaxTrkltCls:{} ZCut:{} PhCut:{} PairCut:{} ClCut:{} SeedRad:{}x{}",
+                                ZBins, PhiBins, clusterContributorsCut, suppressLowMultDebris, maxTrackletsPerCluster, zCut, phiCut, pairCut, clusterCut, seedMemberRadiusTime, seedMemberRadiusZ);
   if (std::numeric_limits<size_t>::max() != MaxMemory) {
     str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
   }
@@ -173,8 +174,8 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     LOGP(fatal, "Unsupported ITS tracking mode {} ", toString(mode));
   }
 
-  float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791;
-  float bFactorTracklets = bFactor < 0.01 ? 1. : bFactor; // for tracklets only
+  float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791f;
+  float bFactorTracklets = bFactor < 0.01f ? 1.f : bFactor; // for tracklets only
 
   // global parameters set for every iteration
   for (auto& p : trackParams) {
@@ -262,6 +263,9 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
     p.trackletSigma = vc.trackletSigma;
     p.maxZPositionAllowed = vc.maxZPositionAllowed;
     p.clusterContributorsCut = vc.clusterContributorsCut;
+    p.suppressLowMultDebris = vc.suppressLowMultDebris;
+    p.seedMemberRadiusTime = vc.seedMemberRadiusTime;
+    p.seedMemberRadiusZ = vc.seedMemberRadiusZ;
     p.phiSpan = vc.phiSpan;
     p.nThreads = vc.nThreads;
     p.ZBins = vc.ZBins;
@@ -273,12 +277,16 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
   vertParams[0].vertNsigmaCut = vc.vertNsigmaCut;
   vertParams[0].vertRadiusSigma = vc.vertRadiusSigma;
   vertParams[0].maxTrackletsPerCluster = vc.maxTrackletsPerCluster;
-  vertParams[0].lowMultBeamDistCut = vc.lowMultBeamDistCut;
   vertParams[0].zCut = vc.zCut;
   vertParams[0].phiCut = vc.phiCut;
   vertParams[0].pairCut = vc.pairCut;
   vertParams[0].clusterCut = vc.clusterCut;
-  vertParams[0].histPairCut = vc.histPairCut;
+  vertParams[0].coarseZWindow = vc.coarseZWindow;
+  vertParams[0].seedDedupZCut = vc.seedDedupZCut;
+  vertParams[0].refitDedupZCut = vc.refitDedupZCut;
+  vertParams[0].duplicateZCut = vc.duplicateZCut;
+  vertParams[0].finalSelectionZCut = vc.finalSelectionZCut;
+  vertParams[0].duplicateDistance2Cut = vc.duplicateDistance2Cut;
   vertParams[0].tanLambdaCut = vc.tanLambdaCut;
 
   return vertParams;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx b/Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx
new file mode 100644
index 0000000000000..592c22dedf347
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx
@@ -0,0 +1,1036 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <numeric>
+#include <queue>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <Math/SMatrix.h>
+#include <Math/SVector.h>
+
+#include "ITStracking/Constants.h"
+#include "ITStracking/MathUtils.h"
+#include "ITStracking/LineVertexerHelpers.h"
+
+namespace o2::its::line_vertexer
+{
+namespace
+{
+using SymMatrix3 = ROOT::Math::SMatrix<float, 3, 3, ROOT::Math::MatRepSym<float, 3>>;
+using SVector3 = ROOT::Math::SVector<float, 3>;
+
+constexpr float TukeyC = 4.685f;
+constexpr float TukeyC2 = TukeyC * TukeyC;
+constexpr float InitialScale2 = 5.f;
+constexpr float MinScale2 = 1.f;
+constexpr float MedianToSigma = 1.4826f;
+constexpr float VertexShiftZTol = 0.01f;
+constexpr float VertexShiftR2Tol = 1.e-4f;
+constexpr int MaxFitIterations = 10;
+constexpr int MaxSeedsPerCluster = 32;
+constexpr float MinRelativePeakSupport = 0.1f;
+constexpr int MaxHistogramBins = 0x7fff;
+constexpr float TieTolerance = 1e-5f;
+
+struct LineRef {
+  LineRef(const Line& line, const int index, const float beamX, const float beamY, const float maxZ) : lineIndex(index)
+  {
+    const auto symTime = line.mTime.makeSymmetrical();
+    tCenter = symTime.getTimeStamp();
+    tHalfWidth = symTime.getTimeStampError();
+    const auto dx = line.originPoint(0) - beamX;
+    const auto dy = line.originPoint(1) - beamY;
+    const auto ux = line.cosinesDirector(0);
+    const auto uy = line.cosinesDirector(1);
+    const auto uz = line.cosinesDirector(2);
+    const auto den = math_utils::SqSum(ux, uy);
+    if (den <= constants::Tolerance) {
+      lineIndex = constants::UnusedIndex;
+      return;
+    }
+    const auto s0 = -((dx * ux) + (dy * uy)) / den;
+    const auto xb = dx + (s0 * ux);
+    const auto yb = dy + (s0 * uy);
+    zBeam = line.originPoint(2) + s0 * uz;
+    if (!std::isfinite(zBeam) || o2::gpu::CAMath::Abs(zBeam) > maxZ) {
+      lineIndex = constants::UnusedIndex;
+    }
+  }
+  bool isDead() const noexcept { return lineIndex == constants::UnusedIndex; }
+
+  int lineIndex = constants::UnusedIndex;
+  float zBeam = 0.f;
+  float tCenter = 0.f;
+  float tHalfWidth = 0.f;
+};
+
+struct VertexSeed {
+  explicit VertexSeed(const std::shared_ptr<BoundedMemoryResource>& mr) : contributors(mr.get()), assigned(mr.get()) {}
+
+  std::array<float, 3> vertex = {};
+  TimeEstBC time;
+  float scale2 = InitialScale2;
+  bounded_vector<int> contributors;
+  bounded_vector<int> assigned;
+  bool valid = false;
+  bool isUsableSeed() const noexcept
+  {
+    return valid && contributors.size() >= 2;
+  }
+};
+
+void compactSeeds(bounded_vector<VertexSeed>& seeds)
+{
+  seeds.erase(std::remove_if(seeds.begin(), seeds.end(), [](const VertexSeed& seed) {
+                return !seed.isUsableSeed();
+              }),
+              seeds.end());
+}
+
+struct Histogram2D {
+  explicit Histogram2D(const std::shared_ptr<BoundedMemoryResource>& mr) : bins(mr.get()) {}
+
+  int nTimeBins = 0;
+  int nZBins = 0;
+  float timeMin = 0.f;
+  float zMin = 0.f;
+  float timeBinSize = 1.f;
+  float zBinSize = 1.f;
+  bounded_vector<float> bins;
+
+  int getIndex(const int tBin, const int zBin) const noexcept
+  {
+    return (tBin * nZBins) + zBin;
+  }
+
+  std::pair<int, int> decodeIndex(const int index) const noexcept
+  {
+    return {index / nZBins, index % nZBins};
+  }
+
+  int getTimeBin(const float time) const noexcept
+  {
+    if (time < timeMin) {
+      return -1;
+    }
+    const auto bin = static_cast<int>((time - timeMin) / timeBinSize);
+    return (bin >= 0 && bin < nTimeBins) ? bin : -1;
+  }
+
+  int getZBin(const float z) const noexcept
+  {
+    if (z < zMin) {
+      return -1;
+    }
+    const auto bin = static_cast<int>((z - zMin) / zBinSize);
+    return (bin >= 0 && bin < nZBins) ? bin : -1;
+  }
+
+  void fill(const float time, const float z, const float weight) noexcept
+  {
+    const auto tBin = getTimeBin(time);
+    const auto zBin = getZBin(z);
+    if (tBin < 0 || zBin < 0) {
+      return;
+    }
+    bins[getIndex(tBin, zBin)] += weight;
+  }
+
+  int findPeakBin() const noexcept
+  {
+    float bestWeight = 0.f;
+    int bestIndex = -1;
+    for (int index = 0; index < static_cast<int>(bins.size()); ++index) {
+      if (bins[index] > bestWeight) {
+        bestWeight = bins[index];
+        bestIndex = index;
+      }
+    }
+    return bestIndex;
+  }
+
+  void suppressBin(const int index) noexcept
+  {
+    if (index >= 0 && index < static_cast<int>(bins.size())) {
+      bins[index] = -1.f;
+    }
+  }
+
+  void suppressNeighborhood(const int index, const int radiusTime, const int radiusZ) noexcept
+  {
+    if (index < 0) {
+      return;
+    }
+    const auto [tBin, zBin] = decodeIndex(index);
+    for (int dt = -radiusTime; dt <= radiusTime; ++dt) {
+      const auto tt = tBin + dt;
+      if (tt < 0 || tt >= nTimeBins) {
+        continue;
+      }
+      for (int dz = -radiusZ; dz <= radiusZ; ++dz) {
+        const auto zz = zBin + dz;
+        if (zz < 0 || zz >= nZBins) {
+          continue;
+        }
+        bins[getIndex(tt, zz)] = -1.f;
+      }
+    }
+  }
+
+  float getNeighborhoodSum(const int index, const int radiusTime, const int radiusZ) const noexcept
+  {
+    if (index < 0) {
+      return 0.f;
+    }
+    const auto [tBin, zBin] = decodeIndex(index);
+    float sum = 0.f;
+    for (int dt = -radiusTime; dt <= radiusTime; ++dt) {
+      const auto tt = tBin + dt;
+      if (tt < 0 || tt >= nTimeBins) {
+        continue;
+      }
+      for (int dz = -radiusZ; dz <= radiusZ; ++dz) {
+        const auto zz = zBin + dz;
+        if (zz < 0 || zz >= nZBins) {
+          continue;
+        }
+        const auto value = bins[getIndex(tt, zz)];
+        if (value > 0.f) {
+          sum += value;
+        }
+      }
+    }
+    return sum;
+  }
+
+  float getTimeBinCenter(const int tBin) const noexcept
+  {
+    return timeMin + ((static_cast<float>(tBin) + 0.5f) * timeBinSize);
+  }
+
+  float getZBinCenter(const int zBin) const noexcept
+  {
+    return zMin + ((static_cast<float>(zBin) + 0.5f) * zBinSize);
+  }
+
+  TimeEstBC getTimeInterval(const int tBin) const noexcept
+  {
+    const auto lowFloat = timeMin + (static_cast<float>(tBin) * timeBinSize);
+    const auto highFloat = lowFloat + timeBinSize;
+    const auto low = std::max<double>(0., std::floor(lowFloat));
+    const auto high = std::max(low + 1., (double)std::ceil(highFloat));
+    constexpr auto maxTS = std::numeric_limits<TimeStampType>::max();
+    const auto clampedLow = std::min<double>(low, maxTS - 1.);
+    const auto width = std::min<double>(high - clampedLow, std::numeric_limits<TimeStampErrorType>::max());
+    return {static_cast<TimeStampType>(clampedLow), static_cast<TimeStampErrorType>(std::max<double>(1., width))};
+  }
+
+  TimeEstBC getTimeNeighborhoodInterval(const int tBin, const int radius) const noexcept
+  {
+    const auto lowBin = std::max(0, tBin - radius);
+    const auto highBin = std::min(nTimeBins - 1, tBin + radius);
+    const auto lowFloat = timeMin + (static_cast<float>(lowBin) * timeBinSize);
+    const auto highFloat = timeMin + (static_cast<float>(highBin + 1) * timeBinSize);
+    const auto low = std::max<double>(0., std::floor(lowFloat));
+    const auto high = std::max(low + 1., (double)std::ceil(highFloat));
+    constexpr auto maxTS = std::numeric_limits<TimeStampType>::max();
+    const auto clampedLow = std::min<double>(low, maxTS - 1.);
+    const auto width = std::min<double>(high - clampedLow, std::numeric_limits<TimeStampErrorType>::max());
+    return {static_cast<TimeStampType>(clampedLow), static_cast<TimeStampErrorType>(std::max<double>(1., width))};
+  }
+};
+
+class SeedHistogram
+{
+ public:
+  SeedHistogram(std::span<const int> members,
+                std::span<const LineRef> lineRefs,
+                std::span<const Line> lines,
+                const Settings& settings)
+    : mMembers(members), mLineRefs(lineRefs), mSeedMemberRadiusTime(settings.seedMemberRadiusTime), mSeedMemberRadiusZ(settings.seedMemberRadiusZ), mMemoryPool(settings.memoryPool), mHistogram(mMemoryPool)
+  {
+    const auto zBinSize = 0.25f * settings.clusterCut;
+    const auto timeBinSize = medianTimeError(lines);
+
+    float minZ = std::numeric_limits<float>::max();
+    float maxZ = std::numeric_limits<float>::lowest();
+    float minTime = std::numeric_limits<float>::max();
+    float maxTime = std::numeric_limits<float>::lowest();
+    for (const auto lineRefIdx : mMembers) {
+      minZ = std::min(minZ, mLineRefs[lineRefIdx].zBeam);
+      maxZ = std::max(maxZ, mLineRefs[lineRefIdx].zBeam);
+      minTime = std::min(minTime, mLineRefs[lineRefIdx].tCenter);
+      maxTime = std::max(maxTime, mLineRefs[lineRefIdx].tCenter);
+    }
+
+    const auto dz = std::max(0.f, maxZ - minZ);
+    const auto dt = std::max(0.f, maxTime - minTime);
+    mHistogram.nZBins = 1 + static_cast<int>(dz / zBinSize);
+    mHistogram.nTimeBins = 1 + static_cast<int>(dt / timeBinSize);
+    if (mHistogram.nTimeBins * mHistogram.nZBins > MaxHistogramBins) {
+      if (mHistogram.nTimeBins > mHistogram.nZBins) {
+        mHistogram.nTimeBins = std::max(1, (MaxHistogramBins - 1) / std::max(1, mHistogram.nZBins));
+      } else {
+        mHistogram.nZBins = std::max(1, (MaxHistogramBins - 1) / std::max(1, mHistogram.nTimeBins));
+      }
+    }
+
+    mHistogram.timeBinSize = std::max(timeBinSize, dt / (float)std::max(1, mHistogram.nTimeBins));
+    mHistogram.zBinSize = std::max(zBinSize, dz / (float)std::max(1, mHistogram.nZBins));
+    const auto paddedTime = 0.5f * ((float)mHistogram.nTimeBins * mHistogram.timeBinSize - dt);
+    const auto paddedZ = 0.5f * ((float)mHistogram.nZBins * mHistogram.zBinSize - dz);
+    mHistogram.timeMin = minTime - paddedTime;
+    mHistogram.zMin = minZ - paddedZ;
+    mHistogram.bins.assign((size_t)mHistogram.nTimeBins * (size_t)mHistogram.nZBins, 0.f);
+
+    for (const auto lineRefIdx : mMembers) {
+      mHistogram.fill(mLineRefs[lineRefIdx].tCenter, mLineRefs[lineRefIdx].zBeam, 1.f);
+    }
+  }
+
+  int findPeakBin() const noexcept
+  {
+    return mHistogram.findPeakBin();
+  }
+
+  float getPeakSupport(const int peakIndex) const noexcept
+  {
+    return mHistogram.getNeighborhoodSum(peakIndex, mSeedMemberRadiusTime, mSeedMemberRadiusZ);
+  }
+
+  bounded_vector<int> collectLocalMembers(const int peakIndex, const int radiusTime, const int radiusZ) const
+  {
+    bounded_vector<int> localMembers(mMemoryPool.get());
+    localMembers.reserve(mMembers.size());
+    const auto [timeBin, zBin] = mHistogram.decodeIndex(peakIndex);
+    for (const auto lineRefIdx : mMembers) {
+      const auto memberTimeBin = mHistogram.getTimeBin(mLineRefs[lineRefIdx].tCenter);
+      const auto memberZBin = mHistogram.getZBin(mLineRefs[lineRefIdx].zBeam);
+      if (memberTimeBin < 0 || memberZBin < 0) {
+        continue;
+      }
+      if (o2::gpu::GPUCommonMath::Abs(memberTimeBin - timeBin) > radiusTime) {
+        continue;
+      }
+      if (o2::gpu::GPUCommonMath::Abs(memberZBin - zBin) > radiusZ) {
+        continue;
+      }
+      localMembers.push_back(lineRefIdx);
+    }
+    return localMembers;
+  }
+
+  TimeEstBC getPeakTimeInterval(const int peakIndex, const int radius = 0) const noexcept
+  {
+    return mHistogram.getTimeNeighborhoodInterval(mHistogram.decodeIndex(peakIndex).first, radius);
+  }
+
+  float getPeakZCenter(const int peakIndex) const noexcept
+  {
+    return mHistogram.getZBinCenter(mHistogram.decodeIndex(peakIndex).second);
+  }
+
+  void suppressPeak(const int peakIndex) noexcept
+  {
+    mHistogram.suppressBin(peakIndex);
+  }
+
+  void suppressPeakNeighborhood(const int peakIndex) noexcept
+  {
+    mHistogram.suppressNeighborhood(peakIndex, mSeedMemberRadiusTime, mSeedMemberRadiusZ);
+  }
+
+ private:
+  float medianTimeError(std::span<const Line> lines) const
+  {
+    bounded_vector<float> errors(mMemoryPool.get());
+    errors.reserve(mMembers.size());
+    for (const auto lineRefIdx : mMembers) {
+      errors.push_back(static_cast<float>(lines[mLineRefs[lineRefIdx].lineIndex].mTime.getTimeStampError()));
+    }
+    std::sort(errors.begin(), errors.end());
+    return errors.empty() ? 1.f : std::max(1.f, errors[errors.size() / 2]);
+  }
+
+  std::span<const int> mMembers;
+  std::span<const LineRef> mLineRefs;
+  int mSeedMemberRadiusTime = 1;
+  int mSeedMemberRadiusZ = 2;
+  std::shared_ptr<BoundedMemoryResource> mMemoryPool;
+  Histogram2D mHistogram;
+};
+
+float updateScale2(const std::span<const float> chi2s, const std::shared_ptr<BoundedMemoryResource>& mr) noexcept
+{
+  if (chi2s.empty()) {
+    return MinScale2;
+  }
+
+  bounded_vector<float> sorted(chi2s.begin(), chi2s.end(), mr.get());
+  std::sort(sorted.begin(), sorted.end());
+  const auto median = sorted[sorted.size() / 2];
+
+  for (auto& value : sorted) {
+    value = o2::gpu::GPUCommonMath::Abs(value - median);
+  }
+  std::sort(sorted.begin(), sorted.end());
+  const auto mad = sorted[sorted.size() / 2];
+  if (!std::isfinite(mad) || mad <= constants::Tolerance) {
+    return MinScale2;
+  }
+  return std::max(MinScale2, MedianToSigma * mad);
+}
+
+class VertexFit
+{
+ public:
+  void add(const Line& line, const float weight) noexcept
+  {
+    const auto& direction = line.cosinesDirector;
+    const auto& origin = line.originPoint;
+    const auto det = ROOT::Math::Dot(direction, direction);
+    if (det <= constants::Tolerance) {
+      return;
+    }
+
+    for (int i = 0; i < 3; ++i) {
+      for (int j = i; j < 3; ++j) {
+        mMatrix(i, j) += weight * (((i == j ? det : 0.f) - direction(i) * direction(j)) / det);
+      }
+    }
+
+    const auto dDotO = ROOT::Math::Dot(direction, origin);
+    for (int i = 0; i < 3; ++i) {
+      mRhs(i) += weight * ((direction(i) * dDotO - det * origin(i)) / det);
+    }
+  }
+
+  bool solve(std::array<float, 3>& vertexOut) const noexcept
+  {
+    SymMatrix3 inv{mMatrix};
+    if (!inv.InvertFast()) {
+      return false;
+    }
+    const auto solution = inv * mRhs;
+    vertexOut[0] = static_cast<float>(-solution(0));
+    vertexOut[1] = static_cast<float>(-solution(1));
+    vertexOut[2] = static_cast<float>(-solution(2));
+    return std::isfinite(vertexOut[0]) && std::isfinite(vertexOut[1]) && std::isfinite(vertexOut[2]);
+  }
+
+ private:
+  SymMatrix3 mMatrix;
+  SVector3 mRhs;
+};
+
+VertexSeed fitSeed(const VertexSeed& initialSeed,
+                   std::span<const int> members,
+                   std::span<const LineRef> lineRefs,
+                   std::span<const Line> lines,
+                   const std::shared_ptr<BoundedMemoryResource>& mr,
+                   const float pairCut2)
+{
+  VertexSeed seed{mr};
+  seed.vertex = initialSeed.vertex;
+  seed.time = initialSeed.time;
+  seed.scale2 = initialSeed.scale2;
+  seed.valid = false;
+  seed.contributors.clear();
+  seed.assigned.clear();
+  if (members.size() < 2) {
+    return seed;
+  }
+
+  for (int iteration = 0; iteration < MaxFitIterations; ++iteration) {
+    VertexFit vertexFit;
+    TimeEstBC commonTime{};
+    bool hasCommonTime = false;
+    bounded_vector<int> contributors{mr.get()};
+    const auto scale2 = std::max(seed.scale2, MinScale2);
+    const auto tukeyFactor = 1.f / (scale2 * TukeyC2);
+
+    for (const auto lineRefIdx : members) {
+      const auto lineIdx = lineRefs[lineRefIdx].lineIndex;
+      const auto& line = lines[lineIdx];
+      if (!line.mTime.isCompatible(seed.time)) {
+        continue;
+      }
+      if (hasCommonTime && !line.mTime.isCompatible(commonTime)) {
+        continue;
+      }
+
+      const auto chi2 = Line::getDistance2FromPoint(line, seed.vertex) / pairCut2;
+      auto weight = 1.f - (chi2 * tukeyFactor);
+      if (weight <= 0.f) {
+        continue;
+      }
+      weight *= weight;
+
+      if (!hasCommonTime) {
+        commonTime = line.mTime;
+        hasCommonTime = true;
+      } else {
+        commonTime += line.mTime;
+      }
+
+      contributors.push_back(lineRefIdx);
+      vertexFit.add(line, weight);
+    }
+
+    if (!hasCommonTime || contributors.size() < 2) {
+      return seed;
+    }
+
+    std::sort(contributors.begin(), contributors.end());
+
+    std::array<float, 3> updatedVertex{};
+    if (!vertexFit.solve(updatedVertex)) {
+      return seed;
+    }
+
+    const auto sameContributors = contributors == seed.contributors;
+    const auto dz = o2::gpu::GPUCommonMath::Abs(updatedVertex[2] - seed.vertex[2]);
+    const auto oldR2 = (seed.vertex[0] * seed.vertex[0]) + (seed.vertex[1] * seed.vertex[1]);
+    const auto newR2 = (updatedVertex[0] * updatedVertex[0]) + (updatedVertex[1] * updatedVertex[1]);
+    const auto dr2 = o2::gpu::GPUCommonMath::Abs(newR2 - oldR2);
+
+    seed.vertex = updatedVertex;
+    seed.time = commonTime;
+    bounded_vector<float> updatedChi2s{mr.get()};
+    updatedChi2s.reserve(contributors.size());
+    for (const auto lineRefIx : contributors) {
+      updatedChi2s.push_back(Line::getDistance2FromPoint(lines[lineRefs[lineRefIx].lineIndex], seed.vertex) / pairCut2);
+    }
+    seed.scale2 = updateScale2(updatedChi2s, mr);
+    seed.contributors = std::move(contributors);
+    seed.valid = true;
+
+    if (sameContributors && dz < VertexShiftZTol && dr2 < VertexShiftR2Tol) {
+      break;
+    }
+  }
+
+  return seed;
+}
+
+size_t countSharedContributors(std::span<const int> lhs, std::span<const int> rhs) noexcept
+{
+  size_t shared = 0;
+  auto lhsIt = lhs.begin();
+  auto rhsIt = rhs.begin();
+  while (lhsIt != lhs.end() && rhsIt != rhs.end()) {
+    if (*lhsIt == *rhsIt) {
+      ++shared;
+      ++lhsIt;
+      ++rhsIt;
+    } else if (*lhsIt < *rhsIt) {
+      ++lhsIt;
+    } else {
+      ++rhsIt;
+    }
+  }
+  return shared;
+}
+
+bounded_vector<int> collectCompatibleContributors(const VertexSeed& seed,
+                                                  std::span<const int> members,
+                                                  std::span<const LineRef> lineRefs,
+                                                  std::span<const Line> lines,
+                                                  const std::shared_ptr<BoundedMemoryResource>& mr,
+                                                  const float pairCut2)
+{
+  bounded_vector<int> contributors{mr.get()};
+  contributors.reserve(members.size());
+  for (const auto lineRefIdx : members) {
+    const auto lineIdx = lineRefs[lineRefIdx].lineIndex;
+    const auto& line = lines[lineIdx];
+    if (!line.mTime.isCompatible(seed.time)) {
+      continue;
+    }
+    if (Line::getDistance2FromPoint(line, seed.vertex) >= pairCut2) {
+      continue;
+    }
+    contributors.push_back(lineRefIdx);
+  }
+  std::sort(contributors.begin(), contributors.end());
+  return contributors;
+}
+
+void deduplicateSeeds(bounded_vector<VertexSeed>& seeds, const Settings& settings)
+{
+  if (seeds.size() < 2) {
+    return;
+  }
+
+  std::sort(seeds.begin(), seeds.end(), [](const VertexSeed& lhs, const VertexSeed& rhs) {
+    if (lhs.contributors.size() != rhs.contributors.size()) {
+      return lhs.contributors.size() > rhs.contributors.size();
+    }
+    if (o2::gpu::GPUCommonMath::Abs(lhs.scale2 - rhs.scale2) > constants::Tolerance) {
+      return lhs.scale2 < rhs.scale2;
+    }
+    return lhs.vertex[2] < rhs.vertex[2];
+  });
+
+  const auto dedupZCut = settings.seedDedupZCut > 0.f ? settings.seedDedupZCut : 0.25f * settings.clusterCut;
+  for (size_t i = 0; i < seeds.size(); ++i) {
+    auto& candidate = seeds[i];
+    if (!candidate.isUsableSeed()) {
+      candidate.valid = false;
+      continue;
+    }
+    bool duplicate = false;
+    for (size_t j = 0; j < i; ++j) {
+      const auto& kept = seeds[j];
+      if (!kept.isUsableSeed()) {
+        continue;
+      }
+      if (!candidate.time.isCompatible(kept.time)) {
+        continue;
+      }
+      const auto shared = countSharedContributors(candidate.contributors, kept.contributors);
+      const auto minSize = std::min(candidate.contributors.size(), kept.contributors.size());
+      const auto zDelta = o2::gpu::GPUCommonMath::Abs(candidate.vertex[2] - kept.vertex[2]);
+      const bool clearlyWorse = kept.contributors.size() > candidate.contributors.size() ||
+                                kept.scale2 + constants::Tolerance < 0.9f * candidate.scale2;
+      const bool overlapDuplicate = shared > 0 && shared * 2 >= minSize;
+      const bool nearbyDuplicate = zDelta < dedupZCut && (shared > 0 || clearlyWorse);
+      if (overlapDuplicate || nearbyDuplicate) {
+        duplicate = true;
+        break;
+      }
+    }
+    if (duplicate) {
+      candidate.valid = false;
+    }
+  }
+  compactSeeds(seeds);
+}
+
+void deduplicateRefittedSeeds(bounded_vector<VertexSeed>& seeds, const Settings& settings)
+{
+  if (seeds.size() < 2) {
+    return;
+  }
+
+  std::sort(seeds.begin(), seeds.end(), [](const VertexSeed& lhs, const VertexSeed& rhs) {
+    if (lhs.contributors.size() != rhs.contributors.size()) {
+      return lhs.contributors.size() > rhs.contributors.size();
+    }
+    if (o2::gpu::GPUCommonMath::Abs(lhs.scale2 - rhs.scale2) > constants::Tolerance) {
+      return lhs.scale2 < rhs.scale2;
+    }
+    return lhs.vertex[2] < rhs.vertex[2];
+  });
+
+  const auto zCut = settings.refitDedupZCut > 0.f ? settings.refitDedupZCut : 0.25f * settings.clusterCut;
+  for (size_t i = 0; i < seeds.size(); ++i) {
+    auto& candidate = seeds[i];
+    if (!candidate.isUsableSeed()) {
+      candidate.valid = false;
+      continue;
+    }
+    bool duplicate = false;
+    for (size_t j = 0; j < i; ++j) {
+      const auto& kept = seeds[j];
+      if (!kept.isUsableSeed()) {
+        continue;
+      }
+      if (!candidate.time.isCompatible(kept.time)) {
+        continue;
+      }
+      const auto shared = countSharedContributors(candidate.contributors, kept.contributors);
+      const auto minSize = std::min(candidate.contributors.size(), kept.contributors.size());
+      const auto zDelta = o2::gpu::GPUCommonMath::Abs(candidate.vertex[2] - kept.vertex[2]);
+      const bool overlapDuplicate = shared > 0 && shared * 2 >= minSize;
+      const bool lowSupportPair = std::min(candidate.contributors.size(), kept.contributors.size()) < 4;
+      const bool clearlyWorse = kept.contributors.size() > candidate.contributors.size() ||
+                                kept.scale2 + constants::Tolerance < 0.9f * candidate.scale2;
+      const bool geometricDuplicate = zDelta < zCut && (lowSupportPair || clearlyWorse);
+      if (overlapDuplicate || geometricDuplicate) {
+        duplicate = true;
+        break;
+      }
+    }
+    if (duplicate) {
+      candidate.valid = false;
+    }
+  }
+  compactSeeds(seeds);
+}
+
+struct OrderedComponent {
+  explicit OrderedComponent(const std::shared_ptr<BoundedMemoryResource>& mr) : members(mr.get()) {}
+  float center = 0.f;
+  bounded_vector<int> members;
+};
+
+bounded_vector<bounded_vector<int>> buildCoarseClusters(std::span<const LineRef> lineRefs,
+                                                        std::span<const Line> lines,
+                                                        const Settings& settings)
+{
+  bounded_vector<bounded_vector<int>> clusters(settings.memoryPool.get());
+  if (lineRefs.size() < 2) {
+    return clusters;
+  }
+
+  bounded_vector<int> sortedByLower(lineRefs.size(), settings.memoryPool.get());
+  std::iota(sortedByLower.begin(), sortedByLower.end(), 0);
+  std::sort(sortedByLower.begin(), sortedByLower.end(), [&](const int lhs, const int rhs) {
+    const auto lhsLower = lines[lineRefs[lhs].lineIndex].mTime.lower();
+    const auto rhsLower = lines[lineRefs[rhs].lineIndex].mTime.lower();
+    if (lhsLower != rhsLower) {
+      return lhsLower < rhsLower;
+    }
+    return lineRefs[lhs].lineIndex < lineRefs[rhs].lineIndex;
+  });
+
+  const auto coarseZWindow = settings.coarseZWindow > 0.f ? settings.coarseZWindow : settings.clusterCut;
+  bounded_vector<int> parent(lineRefs.size(), settings.memoryPool.get());
+  bounded_vector<int> componentSize(lineRefs.size(), 1, settings.memoryPool.get());
+  std::iota(parent.begin(), parent.end(), 0);
+  float minZ = std::numeric_limits<float>::max();
+  float maxZ = std::numeric_limits<float>::lowest();
+  for (const auto& lineRef : lineRefs) {
+    minZ = std::min(minZ, lineRef.zBeam);
+    maxZ = std::max(maxZ, lineRef.zBeam);
+  }
+  const auto nZBins = std::max(1, 1 + static_cast<int>((maxZ - minZ) / coarseZWindow));
+  auto getZBin = [&](const float z) {
+    return std::clamp(static_cast<int>((z - minZ) / coarseZWindow), 0, nZBins - 1);
+  };
+
+  auto findRoot = [&](int idx) {
+    int root = idx;
+    while (parent[root] != root) {
+      root = parent[root];
+    }
+    while (parent[idx] != idx) {
+      const auto next = parent[idx];
+      parent[idx] = root;
+      idx = next;
+    }
+    return root;
+  };
+
+  auto unite = [&](const int lhs, const int rhs) {
+    auto lhsRoot = findRoot(lhs);
+    auto rhsRoot = findRoot(rhs);
+    if (lhsRoot == rhsRoot) {
+      return;
+    }
+    if (componentSize[lhsRoot] < componentSize[rhsRoot]) {
+      std::swap(lhsRoot, rhsRoot);
+    }
+    parent[rhsRoot] = lhsRoot;
+    componentSize[lhsRoot] += componentSize[rhsRoot];
+  };
+
+  using ActiveEntry = std::pair<TimeStampType, int>;
+  bounded_vector<ActiveEntry> activeEntries(settings.memoryPool.get());
+  std::priority_queue<ActiveEntry, bounded_vector<ActiveEntry>, std::greater<ActiveEntry>> activeByUpper(std::greater<ActiveEntry>{}, std::move(activeEntries));
+  bounded_vector<uint8_t> activeMask(lineRefs.size(), 0, settings.memoryPool.get());
+  bounded_vector<bounded_vector<int>> activeByZBin(settings.memoryPool.get());
+  activeByZBin.reserve(nZBins);
+  for (int iBin = 0; iBin < nZBins; ++iBin) {
+    activeByZBin.emplace_back();
+  }
+  for (const auto lineRefIdx : sortedByLower) {
+    const auto& lineRef = lineRefs[lineRefIdx];
+    const auto& line = lines[lineRef.lineIndex];
+    const auto currentLower = line.mTime.lower();
+
+    while (!activeByUpper.empty() && activeByUpper.top().first < currentLower) {
+      activeMask[activeByUpper.top().second] = 0;
+      activeByUpper.pop();
+    }
+
+    const auto zBin = getZBin(lineRef.zBeam);
+    for (int neighborBin = std::max(0, zBin - 1); neighborBin <= std::min(nZBins - 1, zBin + 1); ++neighborBin) {
+      auto& bucket = activeByZBin[neighborBin];
+      size_t writePos = 0;
+      for (size_t readPos = 0; readPos < bucket.size(); ++readPos) {
+        const auto oLineRefIdx = bucket[readPos];
+        if (!activeMask[oLineRefIdx]) {
+          continue;
+        }
+        bucket[writePos++] = oLineRefIdx;
+        const auto& oLineRef = lineRefs[oLineRefIdx];
+        if (o2::gpu::GPUCommonMath::Abs(lineRef.zBeam - oLineRef.zBeam) >= coarseZWindow) {
+          continue;
+        }
+        const auto& otherLine = lines[oLineRef.lineIndex];
+        if (line.mTime.isCompatible(otherLine.mTime)) {
+          unite(lineRefIdx, oLineRefIdx);
+        }
+      }
+      bucket.resize(writePos);
+    }
+
+    activeMask[lineRefIdx] = 1;
+    activeByUpper.emplace(line.mTime.upper(), lineRefIdx);
+    activeByZBin[zBin].push_back(lineRefIdx);
+  }
+
+  std::unordered_map<int, bounded_vector<int>> components;
+  components.reserve(lineRefs.size());
+  for (int lineRefIdx = 0; lineRefIdx < static_cast<int>(lineRefs.size()); ++lineRefIdx) {
+    const auto root = findRoot(lineRefIdx);
+    auto [it, inserted] = components.try_emplace(root, std::pmr::polymorphic_allocator<int>{settings.memoryPool.get()});
+    (void)inserted;
+    it->second.push_back(lineRefIdx);
+  }
+
+  bounded_vector<OrderedComponent> orderedComponents(settings.memoryPool.get());
+  orderedComponents.reserve(components.size());
+  for (auto& [root, members] : components) {
+    (void)root;
+    if (members.size() < 2) {
+      continue;
+    }
+    std::sort(members.begin(), members.end(), [&](const int lhs, const int rhs) {
+      const auto lhsLower = lines[lineRefs[lhs].lineIndex].mTime.lower();
+      const auto rhsLower = lines[lineRefs[rhs].lineIndex].mTime.lower();
+      if (lhsLower != rhsLower) {
+        return lhsLower < rhsLower;
+      }
+      return lineRefs[lhs].lineIndex < lineRefs[rhs].lineIndex;
+    });
+    orderedComponents.emplace_back(settings.memoryPool);
+    orderedComponents.back().center = lineRefs[members.front()].tCenter;
+    orderedComponents.back().members = std::move(members);
+  }
+
+  std::sort(orderedComponents.begin(), orderedComponents.end(), [](const auto& lhs, const auto& rhs) {
+    if (o2::gpu::GPUCommonMath::Abs(lhs.center - rhs.center) > TieTolerance) {
+      return lhs.center < rhs.center;
+    }
+    return lhs.members.front() < rhs.members.front();
+  });
+  clusters.reserve(orderedComponents.size());
+  for (auto& component : orderedComponents) {
+    clusters.push_back(std::move(component.members));
+  }
+  return clusters;
+}
+
+bounded_vector<VertexSeed> buildSeeds(std::span<const int> members,
+                                      std::span<const LineRef> lineRefs,
+                                      std::span<const Line> lines,
+                                      const Settings& settings)
+{
+  SeedHistogram histogram(members, lineRefs, lines, settings);
+  bounded_vector<VertexSeed> seeds(settings.memoryPool.get());
+  seeds.reserve(MaxSeedsPerCluster);
+  float leadingPeakSupport = 0.f;
+
+  while (static_cast<int>(seeds.size()) < MaxSeedsPerCluster) {
+    const auto peak = histogram.findPeakBin();
+    if (peak < 0) {
+      break;
+    }
+    const auto peakSupport = histogram.getPeakSupport(peak);
+    if (peakSupport < 2.f) {
+      break;
+    }
+    if (leadingPeakSupport <= 0.f) {
+      leadingPeakSupport = peakSupport;
+    } else if (peakSupport < std::max(2.f, MinRelativePeakSupport * leadingPeakSupport)) {
+      break;
+    }
+    auto localMembers = histogram.collectLocalMembers(peak, 0, 0);
+    if (localMembers.size() < 2) {
+      localMembers = histogram.collectLocalMembers(peak, settings.seedMemberRadiusTime, settings.seedMemberRadiusZ);
+    }
+    if (localMembers.size() < 2) {
+      histogram.suppressPeak(peak);
+      continue;
+    }
+
+    VertexSeed seed(settings.memoryPool);
+    seed.vertex = {settings.beamX, settings.beamY, histogram.getPeakZCenter(peak)};
+    seed.time = histogram.getPeakTimeInterval(peak);
+    seed.scale2 = InitialScale2;
+
+    auto fitted = fitSeed(seed, localMembers, lineRefs, lines, settings.memoryPool, settings.pairCut2);
+    if (fitted.valid && fitted.contributors.size() >= 2) {
+      seeds.push_back(std::move(fitted));
+      histogram.suppressPeakNeighborhood(peak);
+    } else {
+      histogram.suppressPeak(peak);
+    }
+  }
+
+  return seeds;
+}
+
+void assignLinesToSeeds(bounded_vector<VertexSeed>& seeds,
+                        std::span<const int> members,
+                        std::span<const LineRef> lineRefs,
+                        std::span<const Line> lines,
+                        const float pairCut2)
+{
+  for (auto& seed : seeds) {
+    seed.assigned.clear();
+  }
+
+  for (const auto lineRefIdx : members) {
+    const auto lineIdx = lineRefs[lineRefIdx].lineIndex;
+    const auto& line = lines[lineIdx];
+
+    int bestSeed = -1;
+    float bestScore = std::numeric_limits<float>::max();
+    size_t bestMult = 0;
+    float bestZResidual = std::numeric_limits<float>::max();
+
+    for (int seedIdx = 0; seedIdx < static_cast<int>(seeds.size()); ++seedIdx) {
+      const auto& seed = seeds[seedIdx];
+      if (!seed.valid || seed.contributors.size() < 2) {
+        continue;
+      }
+      if (!line.mTime.isCompatible(seed.time)) {
+        continue;
+      }
+
+      const auto distance2 = Line::getDistance2FromPoint(line, seed.vertex);
+      if (distance2 >= pairCut2) {
+        continue;
+      }
+
+      const auto score = distance2 / std::max(seed.scale2, MinScale2);
+      const auto zResidual = o2::gpu::GPUCommonMath::Abs(lineRefs[lineRefIdx].zBeam - seed.vertex[2]);
+      const auto multiplicity = seed.contributors.size();
+
+      const auto betterScore = score + TieTolerance < bestScore;
+      const auto betterMultiplicity = o2::gpu::GPUCommonMath::Abs(score - bestScore) <= TieTolerance && multiplicity > bestMult;
+      const auto betterZ = o2::gpu::GPUCommonMath::Abs(score - bestScore) <= TieTolerance &&
+                           multiplicity == bestMult && zResidual + constants::Tolerance < bestZResidual;
+      if (betterScore || betterMultiplicity || betterZ) {
+        bestSeed = seedIdx;
+        bestScore = score;
+        bestMult = multiplicity;
+        bestZResidual = zResidual;
+      }
+    }
+
+    if (bestSeed >= 0) {
+      seeds[bestSeed].assigned.push_back(lineRefIdx);
+    }
+  }
+}
+
+ClusterLines materializeCluster(const VertexSeed& seed,
+                                std::span<const LineRef> lineRefs,
+                                std::span<const Line> lines,
+                                const std::shared_ptr<BoundedMemoryResource>& mr)
+{
+  bounded_vector<int> lineIndices{mr.get()};
+  lineIndices.reserve(seed.contributors.size());
+  for (const auto lineRefIdx : seed.contributors) {
+    lineIndices.push_back(lineRefs[lineRefIdx].lineIndex);
+  }
+  std::sort(lineIndices.begin(), lineIndices.end());
+  lineIndices.erase(std::unique(lineIndices.begin(), lineIndices.end()), lineIndices.end());
+
+  if (lineIndices.size() < 2) {
+    return {};
+  }
+
+  return {std::span<const int>{lineIndices.data(), lineIndices.size()}, lines};
+}
+
+} // namespace
+
+bounded_vector<ClusterLines> buildClusters(std::span<const Line> lines, const Settings& settings)
+{
+  bounded_vector<ClusterLines> clusters(settings.memoryPool.get());
+  if (lines.size() < 2) {
+    return clusters;
+  }
+
+  bounded_vector<LineRef> refs(settings.memoryPool.get());
+  refs.reserve(lines.size());
+  for (int lineIdx = 0; lineIdx < static_cast<int>(lines.size()); ++lineIdx) {
+    LineRef ref(lines[lineIdx], lineIdx, settings.beamX, settings.beamY, settings.maxZ);
+    if (!ref.isDead()) {
+      refs.push_back(ref);
+    }
+  }
+
+  if (refs.size() < 2) {
+    return clusters;
+  }
+
+  const auto coarseClusters = buildCoarseClusters(refs, lines, settings);
+
+  for (const auto& members : coarseClusters) {
+    auto seeds = buildSeeds(members, refs, lines, settings);
+    if (seeds.empty()) {
+      continue;
+    }
+
+    for (auto& seed : seeds) {
+      if (!seed.isUsableSeed()) {
+        seed.valid = false;
+        continue;
+      }
+      auto contributors = collectCompatibleContributors(seed, members, refs, lines, settings.memoryPool, settings.pairCut2);
+      if (contributors.size() < 2) {
+        seed.valid = false;
+        continue;
+      }
+      seed.contributors = std::move(contributors);
+    }
+    compactSeeds(seeds);
+    if (seeds.empty()) {
+      continue;
+    }
+    deduplicateSeeds(seeds, settings);
+    if (seeds.empty()) {
+      continue;
+    }
+    assignLinesToSeeds(seeds, members, refs, lines, settings.pairCut2);
+    for (auto& seed : seeds) {
+      if (seed.assigned.size() < 2) {
+        seed.valid = false;
+        continue;
+      }
+      seed = fitSeed(seed, seed.assigned, refs, lines, settings.memoryPool, settings.pairCut2);
+      if (!seed.isUsableSeed()) {
+        seed.valid = false;
+        continue;
+      }
+    }
+    compactSeeds(seeds);
+    deduplicateRefittedSeeds(seeds, settings);
+    for (auto& refit : seeds) {
+      auto cluster = materializeCluster(refit, refs, lines, settings.memoryPool);
+      if (cluster.getSize() < 2) {
+        continue;
+      }
+      if (!cluster.isValid()) {
+        continue;
+      }
+      clusters.push_back(std::move(cluster));
+    }
+  }
+
+  return clusters;
+}
+
+} // namespace o2::its::line_vertexer
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 5a32b3d3b1a95..5b412ea4eea69 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -14,19 +14,16 @@
 ///
 
 #include <numeric>
-#include <sstream>
 
 #include "Framework/Logger.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/MathUtils.h"
-#include "DataFormatsITSMFT/Cluster.h"
 #include "DataFormatsITSMFT/CompCluster.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "ITSBase/GeometryTGeo.h"
 #include "ITSMFTBase/SegmentationAlpide.h"
 #include "ITStracking/BoundedAllocator.h"
-#include "ITStracking/TrackingConfigParam.h"
 
 namespace
 {
@@ -271,7 +268,7 @@ void TimeFrame<NLayers>::initialise(const int iteration, const TrackingParameter
     for (unsigned int iLayer{0}; iLayer < std::min((int)mClusters.size(), maxLayers); ++iLayer) {
       clearResizeBoundedVector(mClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeFrameworkHostResource(maxLayers != NLayers));
       clearResizeBoundedVector(mUsedClusters[iLayer], mUnsortedClusters[iLayer].size(), getMaybeFrameworkHostResource(maxLayers != NLayers));
-      mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
+      mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt((0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer])) + (trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]));
     }
     clearResizeBoundedVector(mLines, getNrof(1), mMemoryPool.get());
     clearResizeBoundedVector(mTrackletClusters, getNrof(1), mMemoryPool.get());
@@ -312,17 +309,17 @@ void TimeFrame<NLayers>::initialise(const int iteration, const TrackingParameter
   float oneOverR{0.001f * 0.3f * std::abs(mBz) / trkParam.TrackletMinPt};
   for (unsigned int iLayer{0}; iLayer < NLayers; ++iLayer) {
     mMSangles[iLayer] = math_utils::MSangle(0.14f, trkParam.TrackletMinPt, trkParam.LayerxX0[iLayer]);
-    mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt(0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer]) + trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]);
+    mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt((0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer])) + (trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]));
     if (iLayer < mClusters.size() - 1) {
       const float& r1 = trkParam.LayerRadii[iLayer];
       const float& r2 = trkParam.LayerRadii[iLayer + 1];
-      oneOverR = (0.5 * oneOverR >= 1.f / r2) ? 2.f / r2 - o2::constants::math::Almost0 : oneOverR;
+      oneOverR = (0.5 * oneOverR >= 1.f / r2) ? (2.f / r2) - o2::constants::math::Almost0 : oneOverR;
       const float res1 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[iLayer]);
       const float res2 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[iLayer + 1]);
       const float cosTheta1half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r1 * oneOverR));
       const float cosTheta2half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r2 * oneOverR));
-      float x = r2 * cosTheta1half - r1 * cosTheta2half;
-      float delta = o2::gpu::CAMath::Sqrt(1.f / (1.f - 0.25f * math_utils::Sq(x * oneOverR)) * (math_utils::Sq(0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta2half + cosTheta1half) * math_utils::Sq(res1) + math_utils::Sq(0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta1half + cosTheta2half) * math_utils::Sq(res2)));
+      float x = (r2 * cosTheta1half) - (r1 * cosTheta2half);
+      float delta = o2::gpu::CAMath::Sqrt(1.f / (1.f - 0.25f * math_utils::Sq(x * oneOverR)) * (math_utils::Sq((0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta2half) + cosTheta1half) * math_utils::Sq(res1) + math_utils::Sq((0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta1half) + cosTheta2half) * math_utils::Sq(res2)));
       /// the expression std::asin(0.5f * x * oneOverR) is equivalent to std::aCos(0.5f * r1 * oneOverR) - std::acos(0.5 * r2 * oneOverR)
       mPhiCuts[iLayer] = std::min(o2::gpu::CAMath::ASin(0.5f * x * oneOverR) + 2.f * mMSangles[iLayer] + delta, o2::constants::math::PI * 0.5f);
     }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index a41560e2e9e9a..eb0841888b03e 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -10,6 +10,8 @@
 // or submit itself to any jurisdiction.
 
 #include <algorithm>
+#include <array>
+#include <format>
 #include <memory>
 
 #include <oneapi/tbb/task_arena.h>
@@ -128,12 +130,12 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   gsl::span<const o2::itsmft::PhysTrigger> physTriggers;
   std::vector<o2::itsmft::PhysTrigger> fromTRD;
   if (mUseTriggers == 2) { // use TRD triggers
-    o2::InteractionRecord ir{0, tfInfo.firstTForbit};
+    o2::InteractionRecord irFirstTF{0, tfInfo.firstTForbit};
     auto trdTriggers = pc.inputs().get<gsl::span<o2::trd::TriggerRecord>>("phystrig");
     for (const auto& trig : trdTriggers) {
-      if (trig.getBCData() >= ir && trig.getNumberOfTracklets()) {
-        ir = trig.getBCData();
-        fromTRD.emplace_back(o2::itsmft::PhysTrigger{.ir = ir, .data = 0});
+      if (trig.getBCData() >= irFirstTF && trig.getNumberOfTracklets()) {
+        irFirstTF = trig.getBCData();
+        fromTRD.emplace_back(o2::itsmft::PhysTrigger{.ir = irFirstTF, .data = 0});
       }
     }
     physTriggers = gsl::span<const o2::itsmft::PhysTrigger>(fromTRD.data(), fromTRD.size());
@@ -215,7 +217,8 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       auto vtxSpan = mTimeFrame->getPrimaryVertices(clockLayerId, iRof);
       if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
         if (!vtxSpan.empty()) {
-          if (vtxSpan[0].isFlagSet(Vertex::UPCMode) == 1) { // at least one vertex in this ROF and it is from second vertex iteration
+          bool hasUPC = std::any_of(vtxSpan.begin(), vtxSpan.end(), [](const auto& v) { return v.isFlagSet(Vertex::UPCMode); });
+          if (hasUPC) { // at least one vertex in this ROF and it is from second vertex iteration
             LOGP(debug, "ROF {} rejected as vertices are from the UPC iteration", iRof);
             processUPCMask.selectROF({clockTiming.getROFStartInBC(iRof), clockTiming.getROFEndInBC(iRof)});
             vtxROF.setFlag(o2::itsmft::ROFRecord::VtxUPCMode);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 5e27e20b3ddee..a22d2d6c60990 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -13,6 +13,8 @@
 #include <algorithm>
 #include <memory>
 #include <ranges>
+#include <span>
+#include <unordered_map>
 
 #include <oneapi/tbb/blocked_range.h>
 #include <oneapi/tbb/parallel_for.h>
@@ -22,6 +24,7 @@
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/ClusterLines.h"
 #include "ITStracking/Definitions.h"
+#include "ITStracking/LineVertexerHelpers.h"
 #include "ITStracking/Tracklet.h"
 #include "SimulationDataFormat/DigitizationContext.h"
 #include "SimulationDataFormat/O2DatabasePDG.h"
@@ -31,13 +34,14 @@
 
 namespace o2::its
 {
-
+namespace
+{
 template <TrackletMode Mode, bool EvalRun, int NLayers>
-static void trackleterKernelHost(
+void trackleterKernelHost(
   const gsl::span<const Cluster>& clustersNextLayer,    // 0 2
   const gsl::span<const Cluster>& clustersCurrentLayer, // 1 1
   const gsl::span<uint8_t>& usedClustersNextLayer,      // 0 2
-  int* indexTableNext,
+  const int* indexTableNext,
   const float phiCut,
   bounded_vector<Tracklet>& tracklets,
   gsl::span<int> foundTracklets,
@@ -94,7 +98,7 @@ static void trackleterKernelHost(
   }
 }
 
-static void trackletSelectionKernelHost(
+void trackletSelectionKernelHost(
   const Cluster* clusters0,               // global layer 0 clusters
   const Cluster* clusters1,               // global layer 1 clusters
   gsl::span<unsigned char> usedClusters0, // global layer 0 used clusters
@@ -145,6 +149,7 @@ static void trackletSelectionKernelHost(
     offset12 += foundTracklets12[iCurrentLayerClusterIndex];
   }
 }
+} // namespace
 
 template <int NLayers>
 void VertexerTraits<NLayers>::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar)
@@ -255,7 +260,7 @@ void VertexerTraits<NLayers>::computeTracklets(const int iteration)
     });
   });
 
-  /// Create tracklets labels for L0-L1, information is as flat as in tracklets vector (no rofId)
+  /// Create flat L0-L1 tracklet labels (no rofId)
   if (mTimeFrame->hasMCinformation()) {
     for (const auto& trk : mTimeFrame->getTracklets()[0]) {
       o2::MCCompLabel label;
@@ -309,15 +314,7 @@ void VertexerTraits<NLayers>::computeTrackletMatching(const int iteration)
             static_cast<int>(mTimeFrame->getClustersOnLayer(pivotRofId, 1).size()),
             mVrtParams[iteration].tanLambdaCut,
             mVrtParams[iteration].phiCut);
-          auto& lines = mTimeFrame->getLines(pivotRofId);
-          totalLines.local() += lines.size();
-          std::stable_sort(lines.begin(), lines.end(), [](const Line& a, const Line& b) {
-            // sort by lower edge and secondly prefer wider windows
-            if (a.mTime.lower() != b.mTime.lower()) {
-              return a.mTime.lower() < b.mTime.lower();
-            }
-            return a.mTime.upper() > b.mTime.upper();
-          });
+          totalLines.local() += mTimeFrame->getLines(pivotRofId).size();
         }
       });
     mTimeFrame->setNLinesTotal(totalLines.combine(std::plus<int>()));
@@ -330,125 +327,214 @@ void VertexerTraits<NLayers>::computeTrackletMatching(const int iteration)
 template <int NLayers>
 void VertexerTraits<NLayers>::computeVertices(const int iteration)
 {
-  const auto nsigmaCut{std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f)};
-  const auto pairCut2{mVrtParams[iteration].pairCut * mVrtParams[iteration].pairCut};
   const int nRofs = mTimeFrame->getNrof(1);
-  const bool hasMC = mTimeFrame->hasMCinformation();
   std::vector<std::vector<Vertex>> rofVertices(nRofs);
   std::vector<std::vector<VertexLabel>> rofLabels(nRofs);
+  const float nsigmaCut = std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f);
+  const float pairCut2 = mVrtParams[iteration].pairCut * mVrtParams[iteration].pairCut;
+  const float duplicateZCut = mVrtParams[iteration].duplicateZCut > 0.f ? mVrtParams[iteration].duplicateZCut : std::max(4.f * mVrtParams[iteration].pairCut, 0.5f * mVrtParams[iteration].clusterCut);
+  const float duplicateDistance2Cut = mVrtParams[iteration].duplicateDistance2Cut > 0.f ? mVrtParams[iteration].duplicateDistance2Cut : std::max(16.f * pairCut2, 0.0625f * mVrtParams[iteration].clusterCut * mVrtParams[iteration].clusterCut);
+  line_vertexer::Settings settings;
+  settings.beamX = mTimeFrame->getBeamX();
+  settings.beamY = mTimeFrame->getBeamY();
+  settings.pairCut = mVrtParams[iteration].pairCut;
+  settings.pairCut2 = pairCut2;
+  settings.clusterCut = mVrtParams[iteration].clusterCut;
+  settings.coarseZWindow = mVrtParams[iteration].coarseZWindow;
+  settings.seedDedupZCut = mVrtParams[iteration].seedDedupZCut;
+  settings.refitDedupZCut = mVrtParams[iteration].refitDedupZCut;
+  settings.duplicateZCut = duplicateZCut;
+  settings.duplicateDistance2Cut = duplicateDistance2Cut;
+  settings.finalSelectionZCut = mVrtParams[iteration].finalSelectionZCut;
+  settings.maxZ = mVrtParams[iteration].maxZPositionAllowed;
+  settings.seedMemberRadiusTime = mVrtParams[iteration].seedMemberRadiusTime;
+  settings.seedMemberRadiusZ = mVrtParams[iteration].seedMemberRadiusZ;
+  settings.memoryPool = mMemoryPool;
 
   const auto processROF = [&](const int rofId) {
     auto& lines = mTimeFrame->getLines(rofId);
-    const int nLines{static_cast<int>(lines.size())};
-    bounded_vector<uint8_t> usedTracklets(nLines, 0, mMemoryPool.get());
-    auto& clusters = mTimeFrame->getTrackletClusters(rofId);
-
-    for (int iLine1{0}; iLine1 < nLines; ++iLine1) {
-      if (usedTracklets[iLine1]) {
-        continue;
+    auto clusters = line_vertexer::buildClusters(std::span<const Line>{lines.data(), lines.size()}, settings);
+    deepVectorClear(lines); // not needed after
+    auto clusterBeamDistance2 = [&](const ClusterLines& cluster) {
+      return (mTimeFrame->getBeamX() - cluster.getVertex()[0]) * (mTimeFrame->getBeamX() - cluster.getVertex()[0]) +
+             (mTimeFrame->getBeamY() - cluster.getVertex()[1]) * (mTimeFrame->getBeamY() - cluster.getVertex()[1]);
+    };
+    auto clusterBetter = [&](const ClusterLines& lhs, const ClusterLines& rhs) {
+      if (lhs.getSize() != rhs.getSize()) {
+        return lhs.getSize() > rhs.getSize();
       }
-      const auto& line1 = lines[iLine1];
-      for (int iLine2{iLine1 + 1}; iLine2 < nLines; ++iLine2) {
-        if (usedTracklets[iLine2]) {
-          continue;
-        }
-        const auto& line2 = lines[iLine2];
-        if (!line1.mTime.isCompatible(line2.mTime)) {
+      if (o2::gpu::GPUCommonMath::Abs(lhs.getAvgDistance2() - rhs.getAvgDistance2()) > constants::Tolerance) {
+        return lhs.getAvgDistance2() < rhs.getAvgDistance2();
+      }
+      const auto lhsBeam = clusterBeamDistance2(lhs);
+      const auto rhsBeam = clusterBeamDistance2(rhs);
+      if (o2::gpu::GPUCommonMath::Abs(lhsBeam - rhsBeam) > constants::Tolerance) {
+        return lhsBeam < rhsBeam;
+      }
+      return lhs.getVertex()[2] < rhs.getVertex()[2];
+    };
+
+    // Cluster deduplication by local non-maximum suppression in time/space
+    std::sort(clusters.begin(), clusters.end(), clusterBetter);
+    float minClusterZ = std::numeric_limits<float>::max();
+    for (const auto& cluster : clusters) {
+      minClusterZ = std::min(minClusterZ, cluster.getVertex()[2]);
+    }
+    bounded_vector<ClusterLines> deduplicated(mMemoryPool.get());
+    deduplicated.reserve(clusters.size());
+    std::unordered_map<int, std::vector<int>> keptByZBin;
+    for (auto& candidate : clusters) {
+      bool duplicate = false;
+      const auto candidateZ = candidate.getVertex()[2];
+      const auto zBin = static_cast<int>(std::floor((candidateZ - minClusterZ) / settings.duplicateZCut));
+      for (int neighborBin = zBin - 1; neighborBin <= zBin + 1 && !duplicate; ++neighborBin) {
+        const auto found = keptByZBin.find(neighborBin);
+        if (found == keptByZBin.end()) {
           continue;
         }
-        auto dca2{Line::getDCA2(line1, line2)};
-        if (dca2 < pairCut2) {
-          auto& cluster = clusters.emplace_back(iLine1, line1, iLine2, line2);
-          if (!cluster.isValid() || cluster.getR2() > 4.f) {
-            clusters.pop_back();
+        for (const auto ownerId : found->second) {
+          const auto& owner = deduplicated[ownerId];
+          if (!candidate.getTimeStamp().isCompatible(owner.getTimeStamp())) {
             continue;
           }
-
-          usedTracklets[iLine1] = 1;
-          usedTracklets[iLine2] = 1;
-          for (int iLine3{0}; iLine3 < nLines; ++iLine3) {
-            if (usedTracklets[iLine3]) {
-              continue;
-            }
-            const auto& line3 = lines[iLine3];
-            if (!line3.mTime.isCompatible(cluster.getTimeStamp())) {
-              continue;
-            }
-            const auto distance2 = Line::getDistance2FromPoint(line3, cluster.getVertex());
-            if (distance2 < pairCut2) {
-              cluster.add(iLine3, line3);
-              usedTracklets[iLine3] = 1;
-            }
+          if (o2::gpu::GPUCommonMath::Abs(candidate.getVertex()[2] - owner.getVertex()[2]) >= settings.duplicateZCut) {
+            continue;
+          }
+          const auto dx = candidate.getVertex()[0] - owner.getVertex()[0];
+          const auto dy = candidate.getVertex()[1] - owner.getVertex()[1];
+          const auto dz = candidate.getVertex()[2] - owner.getVertex()[2];
+          const auto distance2 = math_utils::SqSum(dx, dy, dz);
+          if (distance2 < settings.duplicateDistance2Cut) {
+            duplicate = true;
+            break;
           }
-          break;
         }
       }
-    }
+      if (duplicate) {
+        continue;
+      }
 
-    // Cluster merging
-    std::sort(clusters.begin(), clusters.end(),
-              [](ClusterLines& cluster1, ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); });
+      const auto ownerId = static_cast<int>(deduplicated.size());
+      keptByZBin[zBin].push_back(ownerId);
+      deduplicated.push_back(std::move(candidate));
+    }
+    clusters = std::move(deduplicated);
     int nClusters = static_cast<int>(clusters.size());
-    for (int iCluster1{0}; iCluster1 < nClusters; ++iCluster1) {
-      std::array<float, 3> vertex1{clusters[iCluster1].getVertex()};
-      std::array<float, 3> vertex2{};
-      for (int iCluster2{iCluster1 + 1}; iCluster2 < nClusters; ++iCluster2) {
-        if (clusters[iCluster1].getTimeStamp().isCompatible(clusters[iCluster2].getTimeStamp())) {
-          vertex2 = clusters[iCluster2].getVertex();
-          if (o2::gpu::GPUCommonMath::Abs(vertex1[2] - vertex2[2]) < mVrtParams[iteration].clusterCut) {
-            float distance{((vertex1[0] - vertex2[0]) * (vertex1[0] - vertex2[0])) +
-                           ((vertex1[1] - vertex2[1]) * (vertex1[1] - vertex2[1])) +
-                           ((vertex1[2] - vertex2[2]) * (vertex1[2] - vertex2[2]))};
-            if (distance < mVrtParams[iteration].pairCut * mVrtParams[iteration].pairCut) {
-              for (auto label : clusters[iCluster2].getLabels()) {
-                clusters[iCluster1].add(label, lines[label]);
-                vertex1 = clusters[iCluster1].getVertex();
-              }
-              clusters.erase(clusters.begin() + iCluster2);
-              --iCluster2;
-              --nClusters;
-            }
-          }
-        }
+
+    // Vertex filtering with score-based local NMS
+    std::sort(clusters.begin(), clusters.end(), clusterBetter);
+    std::vector<int> candidateIndices;
+    candidateIndices.reserve(nClusters);
+    for (int iCluster{0}; iCluster < nClusters; ++iCluster) {
+      const bool zCompatible = o2::gpu::GPUCommonMath::Abs(clusters[iCluster].getVertex()[2]) < mVrtParams[iteration].maxZPositionAllowed;
+
+      if (zCompatible) {
+        candidateIndices.push_back(iCluster);
       }
     }
 
-    // Vertex filtering
-    std::sort(clusters.begin(), clusters.end(),
-              [](const ClusterLines& cluster1, const ClusterLines& cluster2) { return cluster1.getSize() > cluster2.getSize(); });
-    bool atLeastOneFound{false};
-    for (int iCluster{0}; iCluster < nClusters; ++iCluster) {
-      bool lowMultCandidate{false};
-      double beamDistance2{(mTimeFrame->getBeamX() - clusters[iCluster].getVertex()[0]) * (mTimeFrame->getBeamX() - clusters[iCluster].getVertex()[0]) +
-                           (mTimeFrame->getBeamY() - clusters[iCluster].getVertex()[1]) * (mTimeFrame->getBeamY() - clusters[iCluster].getVertex()[1])};
-      if (atLeastOneFound && (lowMultCandidate = clusters[iCluster].getSize() < mVrtParams[iteration].clusterContributorsCut)) {
-        lowMultCandidate &= (beamDistance2 < mVrtParams[iteration].lowMultBeamDistCut * mVrtParams[iteration].lowMultBeamDistCut);
-        if (!lowMultCandidate) {
-          clusters.erase(clusters.begin() + iCluster);
-          nClusters--;
-          continue;
+    if (candidateIndices.empty()) {
+      return;
+    }
+
+    auto countSharedLabels = [](const ClusterLines& lhs, const ClusterLines& rhs) {
+      size_t shared = 0;
+      auto lhsIt = lhs.getLabels().begin();
+      auto rhsIt = rhs.getLabels().begin();
+      while (lhsIt != lhs.getLabels().end() && rhsIt != rhs.getLabels().end()) {
+        if (*lhsIt == *rhsIt) {
+          ++shared;
+          ++lhsIt;
+          ++rhsIt;
+        } else if (*lhsIt < *rhsIt) {
+          ++lhsIt;
+        } else {
+          ++rhsIt;
         }
       }
+      return shared;
+    };
 
-      if (beamDistance2 < nsigmaCut && o2::gpu::GPUCommonMath::Abs(clusters[iCluster].getVertex()[2]) < mVrtParams[iteration].maxZPositionAllowed) {
-        atLeastOneFound = true;
-        Vertex vertex{clusters[iCluster].getVertex().data(),
-                      clusters[iCluster].getRMS2(),
-                      (ushort)clusters[iCluster].getSize(),
-                      clusters[iCluster].getAvgDistance2()};
-
-        if (iteration) {
-          vertex.setFlags(Vertex::UPCMode);
+    float minCandidateZ = std::numeric_limits<float>::max();
+    for (const auto clusterId : candidateIndices) {
+      minCandidateZ = std::min(minCandidateZ, clusters[clusterId].getVertex()[2]);
+    }
+    std::unordered_map<int, std::vector<int>> selectedByZBin;
+    std::vector<int> selectedIndices;
+    selectedIndices.reserve(candidateIndices.size());
+    for (const auto clusterId : candidateIndices) {
+      const auto& candidate = clusters[clusterId];
+      const auto candidateZ = candidate.getVertex()[2];
+      const auto zBin = static_cast<int>((candidateZ - minCandidateZ) / settings.finalSelectionZCut);
+      bool suppressed = false;
+      for (int neighborBin = zBin - 1; neighborBin <= zBin + 1 && !suppressed; ++neighborBin) {
+        const auto found = selectedByZBin.find(neighborBin);
+        if (found == selectedByZBin.end()) {
+          continue;
         }
-        vertex.setTimeStamp(clusters[iCluster].getTimeStamp());
-        rofVertices[rofId].push_back(vertex);
-        if (hasMC) {
-          bounded_vector<o2::MCCompLabel> labels(mMemoryPool.get());
-          for (auto& index : clusters[iCluster].getLabels()) {
-            labels.push_back(mTimeFrame->getLinesLabel(rofId)[index]);
+        for (const auto selectedId : found->second) {
+          const auto& selected = clusters[selectedId];
+          if (!candidate.getTimeStamp().isCompatible(selected.getTimeStamp())) {
+            continue;
           }
-          rofLabels[rofId].push_back(computeMain(labels));
+          const auto zDelta = o2::gpu::GPUCommonMath::Abs(candidateZ - selected.getVertex()[2]);
+          const auto sharedLabels = countSharedLabels(candidate, selected);
+          const auto minSize = std::min(candidate.getSize(), selected.getSize());
+          const bool overlapDuplicate = sharedLabels > 0 && sharedLabels * 4 >= minSize;
+          const bool strongZDuplicate = zDelta < settings.finalSelectionZCut;
+          const bool clearlyBetterMultiplicity = selected.getSize() >= candidate.getSize() + 3;
+          const bool clearlyBetterQuality = selected.getSize() > candidate.getSize() &&
+                                            selected.getAvgDistance2() + constants::Tolerance < 0.8f * candidate.getAvgDistance2();
+          const bool weakCandidate = clearlyBetterMultiplicity || clearlyBetterQuality;
+          if (overlapDuplicate || (strongZDuplicate && weakCandidate)) {
+            suppressed = true;
+            break;
+          }
+        }
+      }
+      if (suppressed) {
+        continue;
+      }
+      selectedByZBin[zBin].push_back(clusterId);
+      selectedIndices.push_back(clusterId);
+    }
+
+    // sort vertices by their multiplicity to opt. suppress lower mult. debris
+    std::vector<int> sortedIndices(selectedIndices.size());
+    std::iota(sortedIndices.begin(), sortedIndices.end(), 0);
+    std::sort(sortedIndices.begin(), sortedIndices.end(), [&selectedIndices, &clusters](int i, int j) {
+      return clusters[selectedIndices[i]].getSize() > clusters[selectedIndices[j]].getSize();
+    });
+    for (const auto sortedId : sortedIndices) {
+      const auto& cluster = clusters[selectedIndices[sortedId]];
+      const auto beamDistance2 = clusterBeamDistance2(cluster);
+      if (!(beamDistance2 < nsigmaCut)) {
+        continue;
+      }
+      if (cluster.getSize() < mVrtParams[iteration].clusterContributorsCut) {
+        continue;
+      }
+      if (!rofVertices[rofId].empty() && cluster.getSize() < mVrtParams[iteration].suppressLowMultDebris) {
+        continue;
+      }
+
+      Vertex vertex{cluster.getVertex().data(),
+                    cluster.getRMS2(),
+                    (ushort)cluster.getSize(),
+                    cluster.getAvgDistance2()};
+      if (iteration) {
+        vertex.setFlags(Vertex::UPCMode);
+      }
+      vertex.setTimeStamp(cluster.getTimeStamp());
+      rofVertices[rofId].push_back(vertex);
+      if (mTimeFrame->hasMCinformation()) {
+        auto& lineLabels = mTimeFrame->getLinesLabel(rofId);
+        bounded_vector<o2::MCCompLabel> labels(mMemoryPool.get());
+        for (auto& index : cluster.getLabels()) {
+          labels.push_back(lineLabels[index]);
         }
+        const auto mainLabel = computeMain(labels);
+        rofLabels[rofId].push_back(mainLabel);
       }
     }
   };
@@ -469,7 +555,7 @@ void VertexerTraits<NLayers>::computeVertices(const int iteration)
     for (auto& vertex : rofVertices[rofId]) {
       mTimeFrame->addPrimaryVertex(vertex);
     }
-    if (hasMC) {
+    if (mTimeFrame->hasMCinformation()) {
       for (auto& label : rofLabels[rofId]) {
         mTimeFrame->addPrimaryVertexLabel(label);
       }
@@ -504,7 +590,8 @@ void VertexerTraits<NLayers>::addTruthSeedingVertices()
                                        if (!trk.isPrimary() || trk.GetPt() < 0.05 || std::abs(trk.GetEta()) > 1.1) {
                                          return false;
                                        }
-                                       return o2::O2DatabasePDG::Instance()->GetParticle(trk.GetPdgCode())->Charge() != 0;
+                                       const auto* p = o2::O2DatabasePDG::Instance()->GetParticle(trk.GetPdgCode());
+                                       return (!p) ? false : p->Charge() != 0;
                                      })));
       vert.setXYZ((float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ());
       vert.setChi2(1); // not used as constraint
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 9f982513fdffd..d54c05ff0f20e 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -117,6 +117,11 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 [[ "0$ITSSTAGGERED" == "01" ]] && ITS_STAGGERED=" --enable-its-staggering " || ITS_STAGGERED=
 [[ "0$MFTSTAGGERED" == "01" ]] && MFT_STAGGERED=" --enable-its-staggering " || MFT_STAGGERED=
 
+# ITS vertexing settings
+if [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then
+  ITS_CONFIG_KEY+=";ITSVertexerParam.pairCut=0.0317563;ITSVertexerParam.clusterCut=0.6640964;ITSVertexerParam.coarseZWindow=0.2049018;ITSVertexerParam.seedDedupZCut=0.0711793;ITSVertexerParam.refitDedupZCut=0.0680009;ITSVertexerParam.duplicateZCut=0.1582193;ITSVertexerParam.finalSelectionZCut=0.1081465;ITSVertexerParam.duplicateDistance2Cut=0.0117033;ITSVertexerParam.clusterContributorsCut=2;ITSVertexerParam.seedMemberRadiusZ=0;ITSVertexerParam.vertNsigmaCut=4.0;ITSVertexerParam.vertRadiusSigma=0.0452309;ITSVertexerParam.trackletSigma=0.0025941;ITSVertexerParam.suppressLowMultDebris=0;"
+fi
+
 if [[ $CTFINPUT != 1 ]]; then
   GPU_OUTPUT+=",tpc-triggers"
 fi
@@ -126,10 +131,10 @@ if [[ $SYNCMODE == 1 ]]; then
   MFT_STF_DEC_CONFIG+="MFTClustererParam.maxBCDiffToMaskBias=-1;"
   [[ $BEAMTYPE == "PbPb" || $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]] && MFT_CONFIG_KEY+="MFTTracking.cutMultClusLow=0;MFTTracking.cutMultClusHigh=4000;"
   if [[ $BEAMTYPE == "PbPb" ]]; then
-    ITS_CONFIG_KEY+="fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:-0};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:-400};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:-20};"
+    ITS_CONFIG_KEY+=";fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:-0};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:-400};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:-20};"
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=50000;MCHTracking.maxTrackingDuration=20;"
   elif [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then
-    ITS_CONFIG_KEY+="fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:--1};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:--1};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:--1};ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;"
+    ITS_CONFIG_KEY+=";fastMultConfig.cutMultClusLow=${CUT_MULT_MIN_ITS:--1};fastMultConfig.cutMultClusHigh=${CUT_MULT_MAX_ITS:--1};fastMultConfig.cutMultVtxHigh=${CUT_MULT_VTX_ITS:--1};"
     MCH_CONFIG_KEY="MCHTracking.maxCandidates=20000;MCHTracking.maxTrackingDuration=10;"
   fi
   [[ -n ${CUT_RANDOM_FRACTION_ITS:-} ]] && ITS_CONFIG_KEY+="fastMultConfig.cutRandomFraction=$CUT_RANDOM_FRACTION_ITS;"
@@ -157,11 +162,6 @@ if [[ $SYNCMODE == 1 ]]; then
   has_detector ITS && TRD_FILTER_CONFIG+=" --filter-trigrec"
 else
   has_detectors_gpu TPC ITS && ITS_CONFIG_KEY+="ITSCATrackerParam.trackingMode=1;" # sets ITS gpu reco to async
-  if [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then
-    ITS_CONFIG_KEY+="ITSVertexerParam.phiCut=0.5;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;"
-  elif [[ $BEAMTYPE == "PbPb" ]]; then
-    ITS_CONFIG_KEY+="ITSVertexerParam.lowMultBeamDistCut=0;"
-  fi
 
   if [[ $IS_SIMULATED_DATA == 0 && $CTFINPUT == 1 ]]; then # Enable fixes to the MCH readout mapping for async processing of real data
     MCH_CONFIG_KEY+="MCHDigitModifier.updateST1=true;MCHDigitModifier.updateST2=true;"
@@ -585,7 +585,7 @@ has_detector_gpu ITS && GPU_OUTPUT+=",its-tracks"
 
 # ---------------------------------------------------------------------------------------------------------------------
 # Common reconstruction workflows
-(has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--trackerCA $ITS_CONFIG $ITS_STAGGERED $DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
+(has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "$ITS_CONFIG $ITS_STAGGERED $DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
 [[ ${DISABLE_DIGIT_CLUSTER_INPUT:-} =~ "--digits-from-upstream" ]]  && has_detector_gpu ITS && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--disable-tracking ${DISABLE_DIGIT_CLUSTER_INPUT:-} $ITS_STAGGERED $DISABLE_MC $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
 (has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $TPC_CORR_OPT $ITS_STAGGERED --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;$TPC_CORR_KEY"
 (has_detector_reco TOF || has_detector_ctf TOF) && ! has_detector_from_global_reader TOF && add_W o2-tof-reco-workflow "$TOF_CONFIG --input-type $TOF_INPUT --output-type $TOF_OUTPUT $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N tof-compressed-decoder TOF RAW 1),$(get_N TOFClusterer TOF REST 1)"
diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 46739e76f103b..e89d8ee09dee9 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -188,7 +188,7 @@ taskwrapper digi.log o2-sim-digitizer-workflow -n $NEvents ${DIGIQED} ${NOMCLABE
 touch digiTRD.log_done
 
 if [[ "0$GENERATE_ITSMFT_DICTIONARIES" == "01" ]]; then
-  taskwrapper itsmftdict1.log o2-its-reco-workflow --trackerCA --disable-mc --configKeyValues '"fastMultConfig.cutMultClusLow=30000;fastMultConfig.cutMultClusHigh=2000000;fastMultConfig.cutMultVtxHigh=500;"'
+  taskwrapper itsmftdict1.log o2-its-reco-workflow --disable-mc --configKeyValues '"fastMultConfig.cutMultClusLow=30000;fastMultConfig.cutMultClusHigh=2000000;fastMultConfig.cutMultVtxHigh=500;"'
   cp ~/alice/O2/Detectors/ITSMFT/ITS/macros/test/CreateDictionaries.C .
   taskwrapper itsmftdict2.log root -b -q CreateDictionaries.C++
   rm -f CreateDictionaries_C* CreateDictionaries.C
diff --git a/prodtests/sim_challenge.sh b/prodtests/sim_challenge.sh
index 8c7cfb1a024b0..f5bbf8ab74ff8 100755
--- a/prodtests/sim_challenge.sh
+++ b/prodtests/sim_challenge.sh
@@ -153,7 +153,7 @@ if [ "$doreco" == "1" ]; then
   echo "Return status of tpcreco: $?"
 
   echo "Running ITS reco flow"
-  taskwrapper itsreco.log  o2-its-reco-workflow --trackerCA --tracking-mode async $gloOpt $ITSRecOpt
+  taskwrapper itsreco.log  o2-its-reco-workflow --tracking-mode async $gloOpt $ITSRecOpt
   echo "Return status of itsreco: $?"
 
   # existing checks

From c91f52ea802aee9e43fa68e1b7c597e0bfe45df6 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 16 Apr 2026 17:51:40 +0200
Subject: [PATCH 1544/1764] ITS: move all pp settings to dpl-workflow.sh

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/include/ITStracking/TrackingConfigParam.h  | 6 +++---
 prodtests/full-system-test/dpl-workflow.sh                  | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index cb291b46f5e44..5ffd55f715a1a 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -25,9 +25,9 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   int nIterations = 1;         // Number of vertexing passes to perform.
   int vertPerRofThreshold = 0; // Maximum number of vertices per ROF to trigger second a iteration.
 
-  // geometrical cuts for tracklet selection
+  // geometrical cuts for tracklet selection for Pb-Pb
   float zCut = 0.002f;
-  float phiCut = 0.4f;
+  float phiCut = 0.005f;
   float pairCut = 0.0211211f;
   float clusterCut = 0.4275412f;
   float coarseZWindow = 0.6521316f;
@@ -36,7 +36,7 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   float duplicateZCut = 0.7985643f;
   float finalSelectionZCut = 0.2932624f;
   float duplicateDistance2Cut = 0.0223001f;
-  float tanLambdaCut = 0.17f;         // tanLambda = deltaZ/deltaR
+  float tanLambdaCut = 0.002f;        // tanLambda = deltaZ/deltaR
   float vertNsigmaCut = 5.8762583f;   // N sigma cut for vertex XY
   float vertRadiusSigma = 0.0343575f; // sigma of vertex XY
   float trackletSigma = 0.0143798f;   // tracklet to vertex sigma
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index d54c05ff0f20e..e954f6875eb30 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -119,7 +119,7 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 
 # ITS vertexing settings
 if [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then
-  ITS_CONFIG_KEY+=";ITSVertexerParam.pairCut=0.0317563;ITSVertexerParam.clusterCut=0.6640964;ITSVertexerParam.coarseZWindow=0.2049018;ITSVertexerParam.seedDedupZCut=0.0711793;ITSVertexerParam.refitDedupZCut=0.0680009;ITSVertexerParam.duplicateZCut=0.1582193;ITSVertexerParam.finalSelectionZCut=0.1081465;ITSVertexerParam.duplicateDistance2Cut=0.0117033;ITSVertexerParam.clusterContributorsCut=2;ITSVertexerParam.seedMemberRadiusZ=0;ITSVertexerParam.vertNsigmaCut=4.0;ITSVertexerParam.vertRadiusSigma=0.0452309;ITSVertexerParam.trackletSigma=0.0025941;ITSVertexerParam.suppressLowMultDebris=0;"
+  ITS_CONFIG_KEY+="ITSVertexerParam.phiCut=0.4;ITSVertexerParam.tanLambdaCut=0.17;ITSVertexerParam.pairCut=0.0317563;ITSVertexerParam.clusterCut=0.6640964;ITSVertexerParam.coarseZWindow=0.2049018;ITSVertexerParam.seedDedupZCut=0.0711793;ITSVertexerParam.refitDedupZCut=0.0680009;ITSVertexerParam.duplicateZCut=0.1582193;ITSVertexerParam.finalSelectionZCut=0.1081465;ITSVertexerParam.duplicateDistance2Cut=0.0117033;ITSVertexerParam.clusterContributorsCut=2;ITSVertexerParam.seedMemberRadiusZ=0;ITSVertexerParam.vertNsigmaCut=4.0;ITSVertexerParam.vertRadiusSigma=0.0452309;ITSVertexerParam.trackletSigma=0.0025941;ITSVertexerParam.suppressLowMultDebris=0;"
 fi
 
 if [[ $CTFINPUT != 1 ]]; then

From f208bb241be18ecf5c9f7efd2e488f62c2221e96 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <maximiliano.puccio@cern.ch>
Date: Mon, 13 Apr 2026 16:34:19 +0200
Subject: [PATCH 1545/1764] Remove unnecessary dictionaries in ALICE3

---
 .../ALICE3/TRK/reconstruction/CMakeLists.txt  | 12 ---------
 .../src/TRKReconstructionLinkDef.h            | 25 -------------------
 2 files changed, 37 deletions(-)
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
index 59a7f47955938..b8cb6a88f7163 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
@@ -41,15 +41,3 @@ o2_add_library(TRKReconstruction
 if(Acts_FOUND)
   target_compile_definitions(${targetName} PUBLIC O2_WITH_ACTS)
 endif()
-
-set(dictHeaders include/TRKReconstruction/TimeFrame.h
-                include/TRKReconstruction/Clusterer.h)
-
-if(Acts_FOUND)
-  list(APPEND dictHeaders include/TRKReconstruction/ClustererACTS.h
-                          include/TRKReconstruction/TrackerACTS.h)
-endif()
-
-o2_target_root_dictionary(TRKReconstruction
-                          HEADERS ${dictHeaders}
-                          LINKDEF src/TRKReconstructionLinkDef.h)
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
deleted file mode 100644
index 1f4c2193b91b1..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TRKReconstructionLinkDef.h
+++ /dev/null
@@ -1,25 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifdef __CLING__
-
-#pragma link off all globals;
-#pragma link off all classes;
-#pragma link off all functions;
-
-#pragma link C++ class o2::trk::TimeFrame < 11> + ;
-#pragma link C++ class o2::trk::Clusterer + ;
-#ifdef O2_WITH_ACTS
-#pragma link C++ class o2::trk::ClustererACTS + ;
-
-#endif
-
-#endif

From b083788580acd997aaced935f2f107daf0917182 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Fri, 17 Apr 2026 08:43:36 +0200
Subject: [PATCH 1546/1764] [ALICE3] TRK: Fix getNrof calls to use index in
 TrackerACTS (#15277)

---
 .../Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx
index 67dcfe25e33bb..732a0acc14b66 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx
@@ -261,10 +261,10 @@ void TrackerACTS<nLayers>::clustersToTracks()
 
   double totalTime = 0.;
   LOG(info) << "==== TRK ACTS Tracking ====";
-  LOG(info) << "Processing " << mTimeFrame->getNrof() << " ROFs with B = " << mBz << " T";
+  LOG(info) << "Processing " << mTimeFrame->getNrof(0) << " ROFs with B = " << mBz << " T";
 
   // Process each ROF
-  for (int iROF = 0; iROF < mTimeFrame->getNrof(); ++iROF) {
+  for (int iROF = 0; iROF < mTimeFrame->getNrof(0); ++iROF) {
     LOG(info) << "Processing ROF " << iROF;
     // Build space points
     mCurState = SpacePointBuilding;

From b50e6f2d05366106888c1f6918d9eb1be6496a4a Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Fri, 17 Apr 2026 08:53:21 +0200
Subject: [PATCH 1547/1764] [ALICE3] TRK:  update geometry, fix in extrusions,
 cleanup (#15262)

* Update TRK

* For L6 the nominal radius corresponds to the outer one

* Removed unused variable

* Fix extrusions for OT layers

* Minor

* Negative staggering for L6
---
 .../include/TRKSimulation/TRKLayer.h          |  35 ++-
 .../ALICE3/TRK/simulation/src/Detector.cxx    |  90 ++++++--
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx    | 217 +++++++++++++++---
 3 files changed, 282 insertions(+), 60 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
index 6077d9e5f9839..ef4d5657a1b4f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
@@ -12,11 +12,14 @@
 #ifndef ALICEO2_TRK_LAYER_H
 #define ALICEO2_TRK_LAYER_H
 
+#include "TRKBase/Specs.h"
+#include "TRKBase/TRKBaseParam.h"
 #include <TGeoManager.h>
+
 #include <Rtypes.h>
 
-#include "TRKBase/TRKBaseParam.h"
-#include "TRKBase/Specs.h"
+#include <string>
+#include <utility>
 
 namespace o2
 {
@@ -68,7 +71,7 @@ class TRKSegmentedLayer : public TRKCylindricalLayer
 {
  public:
   TRKSegmentedLayer() = default;
-  TRKSegmentedLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
+  TRKSegmentedLayer(int layerNumber, std::string layerName, float rInn, float tiltAngle, int numberOfStaves, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
   ~TRKSegmentedLayer() override = default;
 
   TGeoVolume* createSensor() override;
@@ -80,7 +83,10 @@ class TRKSegmentedLayer : public TRKCylindricalLayer
   void createLayer(TGeoVolume* motherVolume) override = 0;
 
  protected:
+  float mTiltAngle;
   int mNumberOfModules;
+  int mNumberOfStaves;
+  bool mIsFlipped = false;
 
   // Fixed parameters for the layer, to be set based on the specifications of the chip and module
   static constexpr double sChipWidth = constants::moduleMLOT::chip::width;
@@ -93,6 +99,12 @@ class TRKSegmentedLayer : public TRKCylindricalLayer
   // TGeo objects outside logical volumes can cause errors
   static constexpr float sLogicalVolumeThickness = 1.3;
 
+  // For the segmented layers, because of tilting and staggering the bounding radii can be different
+  // from the inner radius and inner radius + thickness.
+  // This function calculates the bounding radii based on the geometry of the stave and the tilt angle,
+  // to ensure that the layer volume is large enough to contain all the staves without overlaps.
+  virtual std::pair<float, float> getBoundingRadii(double staveWidth) const;
+
   ClassDefOverride(TRKSegmentedLayer, 0);
 };
 
@@ -100,14 +112,20 @@ class TRKMLLayer : public TRKSegmentedLayer
 {
  public:
   TRKMLLayer() = default;
-  TRKMLLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
+  TRKMLLayer(int layerNumber, std::string layerName, float rInn, float staggerOffset, float tiltAngle, int numberOfStaves, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
   ~TRKMLLayer() override = default;
 
   TGeoVolume* createStave() override;
   void createLayer(TGeoVolume* motherVolume) override;
 
  private:
+  float mStaggerOffset;
+
   static constexpr double sStaveWidth = constants::ML::width;
+  static constexpr int sFlippedLayerNumber = 3;
+
+  // Override to account for the staggering offset present in specific ML layers
+  std::pair<float, float> getBoundingRadii(double staveWidth) const override;
 
   ClassDefOverride(TRKMLLayer, 0);
 };
@@ -116,7 +134,7 @@ class TRKOTLayer : public TRKSegmentedLayer
 {
  public:
   TRKOTLayer() = default;
-  TRKOTLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
+  TRKOTLayer(int layerNumber, std::string layerName, float rInn, float tiltAngle, int numberOfStaves, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode);
   ~TRKOTLayer() override = default;
 
   TGeoVolume* createStave() override;
@@ -128,9 +146,12 @@ class TRKOTLayer : public TRKSegmentedLayer
   static constexpr double sInStaveOverlap = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true) overlap
   static constexpr double sStaveWidth = constants::OT::width - sInStaveOverlap;
 
-  ClassDefOverride(TRKOTLayer, 0)
+  // Override to account for the staggering offset present in OT layers
+  std::pair<float, float> getBoundingRadii(double staveWidth) const override;
+
+  ClassDefOverride(TRKOTLayer, 0);
 };
 
 } // namespace trk
 } // namespace o2
-#endif // ALICEO2_TRK_LAYER_H
\ No newline at end of file
+#endif // ALICEO2_TRK_LAYER_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 66c02a080e0b6..66ace4746d399 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -9,18 +9,19 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include <FairVolume.h>
-
-#include <TVirtualMC.h>
-#include <TVirtualMCStack.h>
-#include <TGeoVolume.h>
+#include "TRKSimulation/Detector.h"
 
 #include "DetectorsBase/Stack.h"
-#include "TRKSimulation/Hit.h"
-#include "TRKSimulation/Detector.h"
+
 #include "TRKBase/TRKBaseParam.h"
+#include "TRKSimulation/Hit.h"
 #include "TRKSimulation/VDGeometryBuilder.h"
 #include "TRKSimulation/VDSensorRegistry.h"
+#include <TGeoVolume.h>
+#include <TVirtualMC.h>
+#include <TVirtualMCStack.h>
+
+#include <FairVolume.h>
 
 #include <string>
 #include <type_traits>
@@ -105,14 +106,21 @@ void Detector::configMLOT()
       break;
     }
     case kSegmented: {
+      const std::vector<float> tiltAngles{11.2f, 11.9f, 11.4f, 0.f, 0.f, 0.f, 0.f, 0.f};
+      // const std::vector<float> tiltAngles{10.f, 16.1f, 19.2f, 0.f, 0.f, 0.f, 0.f, 0.f};
+      const std::vector<int> nStaves{10, 14, 18, 26, 38, 32, 42, 56};
+      // const std::vector<int> nStaves{10, 16, 22, 26, 38, 32, 42, 56};
       const std::vector<int> nMods{10, 10, 10, 10, 10, 20, 20, 20};
+
+      const std::vector<float> stagOffsets{0.f, 0.f, 0.f, 1.17f, 0.89f};
+
       LOGP(warning, "Loading segmented configuration for ALICE3 TRK");
       for (int i{0}; i < 8; ++i) {
         std::string name = GeometryTGeo::getTRKLayerPattern() + std::to_string(i);
-        if (i < 4) {
-          mLayers.push_back(std::make_unique<TRKMLLayer>(i, name, rInn[i], nMods[i], thick, MatBudgetParamMode::Thickness));
+        if (i < 5) {
+          mLayers.push_back(std::make_unique<TRKMLLayer>(i, name, rInn[i], stagOffsets[i], tiltAngles[i], nStaves[i], nMods[i], thick, MatBudgetParamMode::Thickness));
         } else {
-          mLayers.push_back(std::make_unique<TRKOTLayer>(i, name, rInn[i], nMods[i], thick, MatBudgetParamMode::Thickness));
+          mLayers.push_back(std::make_unique<TRKOTLayer>(i, name, rInn[i], tiltAngles[i], nStaves[i], nMods[i], thick, MatBudgetParamMode::Thickness));
         }
       }
       break;
@@ -153,16 +161,66 @@ void Detector::configFromFile(std::string fileName)
     }
 
     std::string name = GeometryTGeo::getTRKLayerPattern() + std::to_string(layerCount);
+
     switch (trkPars.layoutMLOT) {
-      case kCylindrical:
-        mLayers.push_back(std::make_unique<TRKCylindricalLayer>(layerCount, name, tmpBuff[0], tmpBuff[1], tmpBuff[2], MatBudgetParamMode::Thickness));
+      case kCylindrical: {
+        // Cylindrical requires at least 3 parameters
+        if (tmpBuff.size() < 3) {
+          LOGP(fatal, "Invalid configuration for cylindrical layer {}: insufficient parameters.", layerCount);
+        }
+
+        // Default mode is Thickness
+        MatBudgetParamMode mode = MatBudgetParamMode::Thickness;
+        if (tmpBuff.size() >= 4) {
+          mode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[3]));
+        }
+
+        mLayers.push_back(std::make_unique<TRKCylindricalLayer>(layerCount, name, tmpBuff[0], tmpBuff[1], tmpBuff[2], mode));
         break;
+      }
       case kSegmented: {
-        int nMods = static_cast<int>(tmpBuff[1]);
-        if (layerCount < 4) {
-          mLayers.push_back(std::make_unique<TRKMLLayer>(layerCount, name, tmpBuff[0], nMods, tmpBuff[2], MatBudgetParamMode::Thickness));
+        // Expected column mapping in the text file (separated by \t):
+        // tmpBuff[0] = rInn
+        // tmpBuff[1] = thick
+        // tmpBuff[2] = tiltAngle
+        // tmpBuff[3] = nStaves
+        // tmpBuff[4] = nMods
+        // tmpBuff[5] = stagOffset (required ONLY for ML)
+        // tmpBuff[6] = matBudgetMode (optional, default = Thickness)
+
+        // Base parameters for all segmented layers (at least 5 needed)
+        if (tmpBuff.size() < 5) {
+          LOGP(fatal, "Invalid configuration for segmented layer {}: missing base parameters.", layerCount);
+        }
+
+        float rInn = tmpBuff[0];
+        float thick = tmpBuff[1];
+        float tiltAngle = tmpBuff[2];
+        int nStaves = static_cast<int>(tmpBuff[3]);
+        int nMods = static_cast<int>(tmpBuff[4]);
+
+        // Default mode is Thickness
+        MatBudgetParamMode mode = MatBudgetParamMode::Thickness;
+
+        if (layerCount < 5) {
+          // ML layers (0 to 4) require stagOffset (index 5)
+          if (tmpBuff.size() < 6) {
+            LOGP(fatal, "Invalid configuration for ML layer {}: stagOffset is missing.", layerCount);
+          }
+          float stagOffset = tmpBuff[5];
+
+          if (tmpBuff.size() >= 7) {
+            mode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[6]));
+          }
+
+          mLayers.push_back(std::make_unique<TRKMLLayer>(layerCount, name, rInn, stagOffset, tiltAngle, nStaves, nMods, thick, mode));
         } else {
-          mLayers.push_back(std::make_unique<TRKOTLayer>(layerCount, name, tmpBuff[0], nMods, tmpBuff[2], MatBudgetParamMode::Thickness));
+          // OT layers (5+) do NOT have stagOffset. The optional mode is at index 5.
+          if (tmpBuff.size() >= 6) {
+            mode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[5]));
+          }
+
+          mLayers.push_back(std::make_unique<TRKOTLayer>(layerCount, name, rInn, tiltAngle, nStaves, nMods, thick, mode));
         }
         break;
       }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index 39c7b3598d19b..7a4b7bef34e03 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -10,17 +10,21 @@
 // or submit itself to any jurisdiction.
 
 #include "TRKSimulation/TRKLayer.h"
-#include "TRKBase/GeometryTGeo.h"
-#include "TRKBase/Specs.h"
 
 #include "Framework/Logger.h"
 
-#include <TGeoTube.h>
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/Specs.h"
 #include <TGeoBBox.h>
+#include <TGeoTube.h>
 #include <TGeoVolume.h>
-
 #include <TMath.h>
 
+#include <cassert>
+#include <cmath>
+#include <string>
+#include <utility>
+
 namespace o2
 {
 namespace trk
@@ -84,9 +88,10 @@ void TRKCylindricalLayer::createLayer(TGeoVolume* motherVolume)
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-TRKSegmentedLayer::TRKSegmentedLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
-  : TRKCylindricalLayer(layerNumber, layerName, rInn, numberOfModules * sModuleLength, thickOrX2X0, mode), mNumberOfModules(numberOfModules)
+TRKSegmentedLayer::TRKSegmentedLayer(int layerNumber, std::string layerName, float rInn, float tiltAngle, int numberOfStaves, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
+  : TRKCylindricalLayer(layerNumber, layerName, rInn, numberOfModules * sModuleLength, thickOrX2X0, mode), mTiltAngle(tiltAngle), mNumberOfStaves(numberOfStaves), mNumberOfModules(numberOfModules)
 {
+  assert(numberOfStaves % 2 == 0 && "Error: numberOfStaves must be even!");
 }
 
 TGeoVolume* TRKSegmentedLayer::createSensor()
@@ -132,22 +137,29 @@ TGeoVolume* TRKSegmentedLayer::createChip()
 
   TGeoVolume* sensVol = createSensor();
   TGeoCombiTrans* transSens = new TGeoCombiTrans();
-  // transSens->SetTranslation(-sDeadzoneWidth / 2, -(mChipThickness - sSensorThickness) / 2, 0);
-  transSens->SetTranslation(-sDeadzoneWidth / 2, (mChipThickness - sSensorThickness) / 2, 0);
-  LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
-  chipVol->AddNode(sensVol, 1, transSens);
 
   TGeoVolume* deadVol = createDeadzone();
   TGeoCombiTrans* transDead = new TGeoCombiTrans();
-  // transDead->SetTranslation((sChipWidth - sDeadzoneWidth) / 2, -(mChipThickness - sSensorThickness) / 2, 0);
-  transDead->SetTranslation((sChipWidth - sDeadzoneWidth) / 2, (mChipThickness - sSensorThickness) / 2, 0);
-  LOGP(debug, "Inserting {} in {} ", deadVol->GetName(), chipVol->GetName());
-  chipVol->AddNode(deadVol, 1, transDead);
 
   TGeoVolume* metalVol = createMetalStack();
   TGeoCombiTrans* transMetal = new TGeoCombiTrans();
-  // transMetal->SetTranslation(0, sSensorThickness / 2, 0);
-  transMetal->SetTranslation(0, -sSensorThickness / 2, 0);
+
+  if (!mIsFlipped) {
+    transSens->SetTranslation(-sDeadzoneWidth / 2, (mChipThickness - sSensorThickness) / 2, 0);
+    transDead->SetTranslation((sChipWidth - sDeadzoneWidth) / 2, (mChipThickness - sSensorThickness) / 2, 0);
+    transMetal->SetTranslation(0, -sSensorThickness / 2, 0);
+  } else {
+    transSens->SetTranslation(-sDeadzoneWidth / 2, -(mChipThickness - sSensorThickness) / 2, 0);
+    transDead->SetTranslation((sChipWidth - sDeadzoneWidth) / 2, -(mChipThickness - sSensorThickness) / 2, 0);
+    transMetal->SetTranslation(0, sSensorThickness / 2, 0);
+  }
+
+  LOGP(debug, "Inserting {} in {} ", sensVol->GetName(), chipVol->GetName());
+  chipVol->AddNode(sensVol, 1, transSens);
+
+  LOGP(debug, "Inserting {} in {} ", deadVol->GetName(), chipVol->GetName());
+  chipVol->AddNode(deadVol, 1, transDead);
+
   LOGP(debug, "Inserting {} in {} ", metalVol->GetName(), chipVol->GetName());
   chipVol->AddNode(metalVol, 1, transMetal);
 
@@ -186,11 +198,59 @@ TGeoVolume* TRKSegmentedLayer::createModule()
   return moduleVol;
 }
 
+std::pair<float, float> TRKSegmentedLayer::getBoundingRadii(double staveWidth) const
+{
+  const float avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
+  const float staveSizeX = staveWidth;
+  const float staveSizeY = mOuterRadius - mInnerRadius;
+
+  /*const float deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY);
+
+  float radiusMin = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY - avgRadius * 2. * deltaForTilt);
+  float radiusMax = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY + avgRadius * 2. * deltaForTilt);*/
+
+  const double alpha = TMath::DegToRad() * std::abs(mTiltAngle);
+
+  // The maximum distance from the center is always the outer top corner
+  double u_max = avgRadius * std::sin(alpha) + staveSizeX / 2.0;
+  double v_max = avgRadius * std::cos(alpha) + staveSizeY / 2.0;
+  double radiusMax = std::sqrt(u_max * u_max + v_max * v_max);
+
+  // The perpendicular distance from the center to the line where the inner face lies
+  double perpDistance = avgRadius * std::cos(alpha) - staveSizeY / 2.0;
+
+  // The projection of the center along the width of the stave
+  double projDistance = avgRadius * std::sin(alpha);
+
+  double radiusMin;
+  if (projDistance <= staveSizeX / 2.0) {
+    // The center projects directly inside the flat face.
+    // The closest point is on the face itself, not on the corner
+    radiusMin = perpDistance;
+  } else {
+    // The center projects outside the face. The closest point is the inner corner
+    double u_min = projDistance - staveSizeX / 2.0;
+    radiusMin = std::sqrt(u_min * u_min + perpDistance * perpDistance);
+  }
+
+  // Add a 0.5 mm safety margin to prevent false-positive overlaps in ROOT's geometry checker caused by floating-point inaccuracies
+  const float precisionMargin = 0.05f;
+
+  return {radiusMin - precisionMargin, radiusMax + precisionMargin};
+}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-TRKMLLayer::TRKMLLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
-  : TRKSegmentedLayer(layerNumber, layerName, rInn, numberOfModules, thickOrX2X0, mode)
+TRKMLLayer::TRKMLLayer(int layerNumber, std::string layerName, float rInn, float staggerOffset, float tiltAngle, int numberOfStaves, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
+  : TRKSegmentedLayer(layerNumber, layerName, rInn, tiltAngle, numberOfStaves, numberOfModules, thickOrX2X0, mode), mStaggerOffset(staggerOffset)
 {
+  if (mLayerNumber == sFlippedLayerNumber) {
+    mOuterRadius = rInn;
+    mInnerRadius = rInn - mChipThickness;
+    mIsFlipped = true;
+    mStaggerOffset = -staggerOffset;
+    LOGP(info, "Layer {} is flipped: sensor and metal stack positions are switched", mLayerNumber);
+  }
 }
 
 TGeoVolume* TRKMLLayer::createStave()
@@ -215,32 +275,43 @@ TGeoVolume* TRKMLLayer::createStave()
 
 void TRKMLLayer::createLayer(TGeoVolume* motherVolume)
 {
+  // Retrieve exact bounding boundaries and create the logical container volume
+  auto [rMin, rMax] = getBoundingRadii(sStaveWidth);
+
   TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
-  TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * sLogicalVolumeThickness, mInnerRadius + 0.667 * sLogicalVolumeThickness, mLength / 2);
+  // TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * sLogicalVolumeThickness, mInnerRadius + 0.667 * sLogicalVolumeThickness, mLength / 2);
+  TGeoTube* layer = new TGeoTube(rMin, rMax, mLength / 2);
   TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
   layerVol->SetLineColor(kYellow);
 
   // Compute the number of staves
-  int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / sStaveWidth);
-  nStaves += nStaves % 2; // Require an even number of staves
+  // int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / sStaveWidth);
+  // nStaves += nStaves % 2; // Require an even number of staves
+
+  // Nominal average radii used as placement barycenters for the staves
+  const double avgRadiusInner = 0.5 * (mInnerRadius + mOuterRadius);
+  const double avgRadiusOuter = avgRadiusInner + mStaggerOffset;
 
   // Compute the size of the overlap region
-  double theta = 2 * TMath::Pi() / nStaves;
+  double theta = 2. * TMath::Pi() / mNumberOfStaves;
   double theta1 = std::atan(sStaveWidth / 2 / mInnerRadius);
   double st = std::sin(theta);
   double ct = std::cos(theta);
   double theta2 = std::atan((mInnerRadius * st - sStaveWidth / 2 * ct) / (mInnerRadius * ct + sStaveWidth / 2 * st));
   double overlap = (theta1 - theta2) * mInnerRadius;
-  LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
+  LOGP(info, "Creating a layer with {} staves and {} mm overlap", mNumberOfStaves, overlap * 10);
 
-  for (int iStave = 0; iStave < nStaves; iStave++) {
+  for (int iStave = 0; iStave < mNumberOfStaves; iStave++) {
     TGeoVolume* staveVol = createStave();
     TGeoCombiTrans* trans = new TGeoCombiTrans();
-    double theta = 360. * iStave / nStaves;
-    // TGeoRotation* rot = new TGeoRotation("rot", theta - 90 + 4, 0, 0);
-    TGeoRotation* rot = new TGeoRotation("rot", theta + 90 + 4, 0, 0);
+    // If the number of staves is a multiple of 4, rotate by half a stave to avoid having the first one exactly on the x
+    double phi = (mNumberOfStaves % 4 == 0) ? theta * (iStave + 0.5) : theta * iStave;
+    double phiDeg = phi * TMath::RadToDeg();
+    TGeoRotation* rot = new TGeoRotation("rot", phiDeg + 90 + mTiltAngle, 0, 0);
     trans->SetRotation(rot);
-    trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
+    // float trueRadius = (mLayerNumber == 3 || mLayerNumber == 4) ? (iStave % 2 == 0 ? mInnerRadius : mInnerRadius + mStaggerOffset) : mInnerRadius;
+    float trueRadius = (mLayerNumber == 3 || mLayerNumber == 4) ? (iStave % 2 == 0 ? avgRadiusInner : avgRadiusOuter) : avgRadiusInner;
+    trans->SetTranslation(trueRadius * std::cos(phi), trueRadius * std::sin(phi), 0);
     LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
     layerVol->AddNode(staveVol, iStave, trans);
   }
@@ -249,10 +320,67 @@ void TRKMLLayer::createLayer(TGeoVolume* motherVolume)
   motherVolume->AddNode(layerVol, 1, nullptr);
 }
 
+std::pair<float, float> TRKMLLayer::getBoundingRadii(double staveWidth) const
+{
+  // Get the baseline RMin from the base class
+  auto [defaultRadiusMin, defaultRadiusMax] = TRKSegmentedLayer::getBoundingRadii(staveWidth);
+
+  // If we are not in the staggered layers, return the baseline values
+  if (mLayerNumber != 3 && mLayerNumber != 4) {
+    return {defaultRadiusMin, defaultRadiusMax};
+  }
+
+  /*// For staggered layers, we must recalculate RMax based on the outer shifted row
+  const float avgRadiusInner = 0.5 * (mInnerRadius + mOuterRadius);
+  const float avgRadiusOuter = avgRadiusInner + mStaggerOffset;
+
+  const float staveSizeX = staveWidth;
+  const float staveSizeY = mOuterRadius - mInnerRadius;
+
+  const float deltaForTiltOuter = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY);
+
+  const float radiusMax = std::sqrt(avgRadiusOuter * avgRadiusOuter + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY + avgRadiusOuter * 2. * deltaForTiltOuter);*/
+
+  const float avgRadiusInner = 0.5 * (mInnerRadius + mOuterRadius);
+  const float avgRadiusStaggered = avgRadiusInner + mStaggerOffset;
+
+  const float staveSizeX = staveWidth;
+  const float staveSizeY = mOuterRadius - mInnerRadius;
+  const float alpha = TMath::DegToRad() * std::abs(mTiltAngle);
+
+  const float precisionMargin = 0.05f;
+
+  // If the layer is NOT flipped (e.g., Layer 4), the stagger goes outwards
+  // Therefore, we must recalculate only the maximum radius based on the outer shifted row
+  if (!mIsFlipped) {
+    float u_max = avgRadiusStaggered * std::sin(alpha) + staveSizeX / 2.0;
+    float v_max = avgRadiusStaggered * std::cos(alpha) + staveSizeY / 2.0;
+    float radiusMax = std::sqrt(u_max * u_max + v_max * v_max);
+
+    return {defaultRadiusMin, radiusMax + precisionMargin};
+  }
+  // If the layer IS flipped (e.g., Layer 3), the stagger goes inwards
+  // Therefore, we must recalculate only the minimum radius based on the inner shifted row
+  else {
+    double perpDistance = avgRadiusStaggered * std::cos(alpha) - staveSizeY / 2.0;
+    double projDistance = avgRadiusStaggered * std::sin(alpha);
+    double newRadiusMin;
+
+    if (projDistance <= staveSizeX / 2.0) {
+      newRadiusMin = perpDistance;
+    } else {
+      double u_min = projDistance - staveSizeX / 2.0;
+      newRadiusMin = std::sqrt(u_min * u_min + perpDistance * perpDistance);
+    }
+
+    return {newRadiusMin - precisionMargin, defaultRadiusMax};
+  }
+}
+
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-TRKOTLayer::TRKOTLayer(int layerNumber, std::string layerName, float rInn, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
-  : TRKSegmentedLayer(layerNumber, layerName, rInn, numberOfModules, thickOrX2X0, mode)
+TRKOTLayer::TRKOTLayer(int layerNumber, std::string layerName, float rInn, float tiltAngle, int numberOfStaves, int numberOfModules, float thickOrX2X0, MatBudgetParamMode mode)
+  : TRKSegmentedLayer(layerNumber, layerName, rInn, tiltAngle, numberOfStaves, numberOfModules, thickOrX2X0, mode)
 {
 }
 
@@ -298,8 +426,12 @@ TGeoVolume* TRKOTLayer::createStave()
 
 void TRKOTLayer::createLayer(TGeoVolume* motherVolume)
 {
+  // Retrieve exact bounding boundaries automatically inherited from TRKSegmentedLayer
+  auto [rMin, rMax] = getBoundingRadii(sStaveWidth);
+
   TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
-  TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * sLogicalVolumeThickness, mInnerRadius + 0.667 * sLogicalVolumeThickness, mLength / 2);
+  // TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * sLogicalVolumeThickness, mInnerRadius + 0.667 * sLogicalVolumeThickness, mLength / 2);
+  TGeoTube* layer = new TGeoTube(rMin, rMax, mLength / 2);
   TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
   layerVol->SetLineColor(kYellow);
 
@@ -307,8 +439,11 @@ void TRKOTLayer::createLayer(TGeoVolume* motherVolume)
   int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / sStaveWidth);
   nStaves += nStaves % 2; // Require an even number of staves
 
+  // Nominal average radius used as the placement barycenter for all staves
+  const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
+
   // Compute the size of the overlap region
-  double theta = 2 * TMath::Pi() / nStaves;
+  double theta = 2. * TMath::Pi() / nStaves;
   double theta1 = std::atan(sStaveWidth / 2 / mInnerRadius);
   double st = std::sin(theta);
   double ct = std::cos(theta);
@@ -319,11 +454,12 @@ void TRKOTLayer::createLayer(TGeoVolume* motherVolume)
   for (int iStave = 0; iStave < nStaves; iStave++) {
     TGeoVolume* staveVol = createStave();
     TGeoCombiTrans* trans = new TGeoCombiTrans();
-    double theta = 360. * iStave / nStaves;
-    // TGeoRotation* rot = new TGeoRotation("rot", theta - 90, 0, 0);
-    TGeoRotation* rot = new TGeoRotation("rot", theta + 90, 0, 0);
+    double phi = theta * iStave;
+    double phiDeg = phi * TMath::RadToDeg();
+    TGeoRotation* rot = new TGeoRotation("rot", phiDeg + 90 + mTiltAngle, 0, 0);
     trans->SetRotation(rot);
-    trans->SetTranslation(mInnerRadius * std::cos(2. * TMath::Pi() * iStave / nStaves), mInnerRadius * std::sin(2 * TMath::Pi() * iStave / nStaves), 0);
+    // trans->SetTranslation(mInnerRadius * std::cos(phi), mInnerRadius * std::sin(phi), 0);
+    trans->SetTranslation(avgRadius * std::cos(phi), avgRadius * std::sin(phi), 0);
     LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
     layerVol->AddNode(staveVol, iStave, trans);
   }
@@ -331,7 +467,14 @@ void TRKOTLayer::createLayer(TGeoVolume* motherVolume)
   LOGP(debug, "Inserting {} in {} ", layerVol->GetName(), motherVolume->GetName());
   motherVolume->AddNode(layerVol, 1, nullptr);
 }
+
+std::pair<float, float> TRKOTLayer::getBoundingRadii(double staveWidth) const
+{
+  auto [radiusMin, radiusMax] = TRKSegmentedLayer::getBoundingRadii(staveWidth);
+
+  return {radiusMin - 0.201f, radiusMax};
+}
 // ClassImp(TRKLayer);
 
 } // namespace trk
-} // namespace o2
\ No newline at end of file
+} // namespace o2

From b1bac33d1cd77bfedf9465b4b5e0665bf86c8dc3 Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Fri, 17 Apr 2026 09:34:38 +0200
Subject: [PATCH 1548/1764] [ALICE3] TKR: add post CheckClusterSize.C macro vs
 Eta (#15274)

---
 .../ALICE3/TRK/macros/test/CMakeLists.txt     |   8 +
 .../TRK/macros/test/postClusterSizeVsEta.C    | 199 ++++++++++++++++++
 2 files changed, 207 insertions(+)
 create mode 100644 Detectors/Upgrades/ALICE3/TRK/macros/test/postClusterSizeVsEta.C

diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
index 54e42c6857249..33d1b4a5afdc6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
@@ -49,3 +49,11 @@ o2_add_test_root_macro(CheckClusters.C
                                              O2::TRKBase
                                              O2::TRKSimulation
                        LABELS trk COMPILE_ONLY)
+
+o2_add_test_root_macro(postClusterSizeVsEta.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsTRK
+                                             O2::SimulationDataFormat
+                                             O2::Framework
+                                             O2::TRKBase
+                                             O2::TRKSimulation
+                       LABELS trk COMPILE_ONLY)
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/postClusterSizeVsEta.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/postClusterSizeVsEta.C
new file mode 100644
index 0000000000000..47beaf36f2957
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/postClusterSizeVsEta.C
@@ -0,0 +1,199 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file postClusterSizeVsEta.C
+/// \brief A post-processing macro to draw average cluster size vs eta
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <iostream>
+#include <TCanvas.h>
+#include <TFile.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TNtuple.h>
+#include <TString.h>
+#include <TTree.h>
+#include <TROOT.h>
+#include <TStyle.h>
+#include <TLegend.h>
+#include <TProfile.h>
+#endif
+
+using namespace std;
+
+// ### required input file: CheckClusters.root, which is the output of CheckClusters.C macro
+void postClusterSizeVsEta(const std::string& strFileInput = "CheckClusters.root")
+{
+  gStyle->SetOptStat(0);
+
+  TFile* fileInput = new TFile(strFileInput.c_str());
+  TTree* tree = (TTree*)fileInput->Get("ntc");
+  std::cout << "Opened tree: " << tree->GetName() << ", entries = " << tree->GetEntries() << std::endl;
+
+  // set branch addresses
+  Float_t event;
+  Float_t mcTrackID;
+  Float_t hitLocX, hitLocZ;
+  Float_t hitGlobX, hitGlobY, hitGlobZ;
+  Float_t clusGlobX, clusGlobY, clusGlobZ;
+  Float_t clusLocX, clusLocZ;
+  Float_t rofFrame;
+  Float_t clusSize;
+  Float_t chipID;
+  Float_t layer;
+  Float_t disk;
+  Float_t subdet;
+  Float_t row, col;
+  Float_t pt;
+
+  // set branch addresses
+  tree->SetBranchAddress("event", &event);
+  tree->SetBranchAddress("mcTrackID", &mcTrackID);
+  tree->SetBranchAddress("hitLocX", &hitLocX);
+  tree->SetBranchAddress("hitLocZ", &hitLocZ);
+  tree->SetBranchAddress("hitGlobX", &hitGlobX);
+  tree->SetBranchAddress("hitGlobY", &hitGlobY);
+  tree->SetBranchAddress("hitGlobZ", &hitGlobZ);
+  tree->SetBranchAddress("clusGlobX", &clusGlobX);
+  tree->SetBranchAddress("clusGlobY", &clusGlobY);
+  tree->SetBranchAddress("clusGlobZ", &clusGlobZ);
+  tree->SetBranchAddress("clusLocX", &clusLocX);
+  tree->SetBranchAddress("clusLocZ", &clusLocZ);
+  tree->SetBranchAddress("rofFrame", &rofFrame);
+  tree->SetBranchAddress("clusSize", &clusSize);
+  tree->SetBranchAddress("chipID", &chipID);
+  tree->SetBranchAddress("layer", &layer);
+  tree->SetBranchAddress("disk", &disk);
+  tree->SetBranchAddress("subdet", &subdet);
+  tree->SetBranchAddress("row", &row);
+  tree->SetBranchAddress("col", &col);
+  tree->SetBranchAddress("pt", &pt);
+
+  // Some QA histograms
+  TH1F* hPt = new TH1F("hPt", "p_{T};p_{T};Entries", 100, 0., 10.);
+  TH1F* hClusSize = new TH1F("hClusSize", "Cluster size;clusSize;Entries", 20, 0., 20.);
+  TH1F* hLayer = new TH1F("hLayer", "Layer;layer;Entries", 20, -0.5, 19.5);
+  TH1F* hDxGlob = new TH1F("hDxGlob", "clusGlobX - hitGlobX;#DeltaX [global];Entries", 200, -1., 1.);
+  TH1F* hDzGlob = new TH1F("hDzGlob", "clusGlobZ - hitGlobZ;#DeltaZ [global];Entries", 200, -1., 1.);
+  TH2F* hHitXY = new TH2F("hHitXY", "Hit global XY;hitGlobX;hitGlobY", 200, -20., 20., 200, -20., 20.);
+  TH2F* hClusVsHitX = new TH2F("hClusVsHitX", "clusGlobX vs hitGlobX;hitGlobX;clusGlobX", 200, -20., 20., 200, -20., 20.);
+
+  // histograms for cluster size vs eta for each barrel layer:
+  const int nLayers = 11;
+  TH2F* hClustSizePerLayerVsEta[nLayers];
+  for (int i = 0; i < nLayers; i++) {
+    hClustSizePerLayerVsEta[i] = new TH2F(Form("hClustSizePerLayerVsEta_Lay%d", i), Form("Cluster size vs eta for layer %d;#eta;Cluster size", i), 200, -5, 5, 101, -0.5, 100.5);
+  }
+
+  // Loop over entries
+  const Long64_t nEntries = tree->GetEntries();
+  for (Long64_t i = 0; i < nEntries; ++i) {
+    tree->GetEntry(i);
+
+    // Fill QA histograms
+    float dXGlob = clusGlobX - hitGlobX;
+    float dZGlob = clusGlobZ - hitGlobZ;
+    hPt->Fill(pt);
+    hClusSize->Fill(clusSize);
+    hLayer->Fill(layer);
+    hDxGlob->Fill(dXGlob);
+    hDzGlob->Fill(dZGlob);
+    hHitXY->Fill(hitGlobX, hitGlobY);
+    hClusVsHitX->Fill(hitGlobX, clusGlobX);
+
+    // cls size vs eta:
+    float clustR = sqrt(clusGlobX * clusGlobX + clusGlobY * clusGlobY);
+    float clustPhi = atan2(clusGlobY, clusGlobX);
+    float clustTheta = atan2(clustR, clusGlobZ);
+    float clustEta = -log(tan(clustTheta / 2));
+
+    // !!! important: to avoid VD layers (numeration for ML starts from 0, while VD layers are also numbered as 0,1,2)
+    if (clustR > 5) // cm
+      hClustSizePerLayerVsEta[(int)layer + 3]->Fill(clustEta, clusSize);
+    else if (layer < 3) // VD layers
+      hClustSizePerLayerVsEta[(int)layer]->Fill(clustEta, clusSize);
+
+    // progress print
+    if ((i + 1) % 200000 == 0) {
+      std::cout << "Processed " << (i + 1) << " / " << nEntries << " entries" << std::endl;
+    }
+  }
+
+  // Save histograms to file
+  TFile* fout = TFile::Open("clusterSizes_vs_eta.root", "RECREATE");
+  hPt->Write();
+  hClusSize->Write();
+  hLayer->Write();
+  hDxGlob->Write();
+  hDzGlob->Write();
+  hHitXY->Write();
+  hClusVsHitX->Write();
+
+  // draw some QA histograms
+  TCanvas* c1 = new TCanvas("canv_clusters_QA", "Clusters QA", 1200, 800);
+  c1->Divide(2, 2);
+  c1->cd(1);
+  hPt->Draw();
+  c1->cd(2);
+  hClusSize->Draw();
+  c1->cd(3);
+  hDxGlob->Draw();
+  c1->cd(4);
+  hHitXY->Draw("COLZ");
+
+  int colors[] = {kRed, kBlue + 1, kMagenta + 1,
+                  kRed, kBlue + 1, kMagenta + 1,
+                  kCyan + 1, kGray + 2, kRed, kBlue, kMagenta + 1, kCyan, kAzure + 1, kOrange - 9, kRed + 2, kBlue + 2, kMagenta + 2};
+
+  TCanvas* canv_clsSize_vs_eta[nLayers];
+  TProfile* profPerLayerVsEta[nLayers];
+  for (int i = 0; i < nLayers; i++) {
+    canv_clsSize_vs_eta[i] = new TCanvas(Form("canv_clsSize_vs_eta_Lay%d", i), Form("Cluster size vs eta for layer %d", i), 800, 600);
+    hClustSizePerLayerVsEta[i]->Draw("COLZ");
+    gPad->SetLogz();
+    profPerLayerVsEta[i] = hClustSizePerLayerVsEta[i]->ProfileX();
+    profPerLayerVsEta[i]->SetLineColor(colors[i]);
+    profPerLayerVsEta[i]->SetMarkerColor(colors[i]);
+    profPerLayerVsEta[i]->SetMarkerStyle(i < 8 ? 20 : 24);
+    profPerLayerVsEta[i]->SetTitle(";#eta;#LTcluster size#GT");
+    profPerLayerVsEta[i]->DrawCopy("same");
+
+    hClustSizePerLayerVsEta[i]->Write();
+    profPerLayerVsEta[i]->Write();
+  }
+
+  // ### canvas with profiles for 3 VD layers
+  TCanvas* canv_av_clsSize_vs_eta_VD_layers = new TCanvas("canv_clsSize_vs_eta_VD_layers", "Cluster size vs eta for VD layers", 800, 600);
+  TLegend* legLayersVD = new TLegend(0.3, 0.72, 0.65, 0.89);
+  for (int i = 0; i < 3; i++) {
+    profPerLayerVsEta[i]->GetYaxis()->SetRangeUser(0., 60.);
+    profPerLayerVsEta[i]->DrawCopy(i == 0 ? "P" : "P same");
+    legLayersVD->AddEntry(profPerLayerVsEta[i], Form("VD layer %d", i), "P");
+  }
+  legLayersVD->Draw();
+  gPad->SetGrid();
+  canv_av_clsSize_vs_eta_VD_layers->SaveAs("clsSize_vs_eta_VD_layers.png");
+  canv_av_clsSize_vs_eta_VD_layers->Write();
+
+  // ### canvas with profiles for MLOT layers
+  TCanvas* canv_av_clsSize_vs_eta_MLOT_layers = new TCanvas("canv_clsSize_vs_eta_MLOT_layers", "Cluster size vs eta for MLOT layers", 800, 600);
+  TLegend* legLayersMLOT = new TLegend(0.3, 0.52, 0.65, 0.89);
+  for (int i = 3; i < nLayers; i++) {
+    profPerLayerVsEta[i]->GetYaxis()->SetRangeUser(0., 12.5);
+    profPerLayerVsEta[i]->GetXaxis()->SetRangeUser(-3.5, 3.5);
+    profPerLayerVsEta[i]->DrawCopy(i == 3 ? "P" : "P same");
+    legLayersMLOT->AddEntry(profPerLayerVsEta[i], Form("MLOT layer %d", i), "P");
+  }
+  legLayersMLOT->Draw();
+  gPad->SetGrid();
+  canv_av_clsSize_vs_eta_MLOT_layers->SaveAs("clsSize_vs_eta_MLOT_layers.png");
+  canv_av_clsSize_vs_eta_MLOT_layers->Write();
+}
\ No newline at end of file

From b61cf4a80bcadf909cae6135b412faa54b92f106 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 16 Apr 2026 17:28:07 +0200
Subject: [PATCH 1549/1764] Tentative improvement of 3-body decay cov. matrix
 creation

---
 DataFormats/Reconstruction/src/Decay3Body.cxx | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/DataFormats/Reconstruction/src/Decay3Body.cxx b/DataFormats/Reconstruction/src/Decay3Body.cxx
index aa071cea675cd..eb1b7ea1fd57d 100644
--- a/DataFormats/Reconstruction/src/Decay3Body.cxx
+++ b/DataFormats/Reconstruction/src/Decay3Body.cxx
@@ -16,15 +16,14 @@ using namespace o2::dataformats;
 Decay3Body::Decay3Body(const std::array<float, 3>& xyz, const std::array<float, 3>& pxyz, const std::array<float, 6>& covxyz, const Track& tr0, const Track& tr1, const Track& tr2, o2::track::PID pid)
   : mProngs{tr0, tr1, tr2}
 {
-  std::array<float, 21> cov{}, cov1{}, cov2{};
-  tr0.getCovXYZPxPyPzGlo(cov);
+  std::array<float, 21> cov{}, cov0{}, cov1{}, cov2{};
+  tr0.getCovXYZPxPyPzGlo(cov0);
   tr1.getCovXYZPxPyPzGlo(cov1);
   tr2.getCovXYZPxPyPzGlo(cov2);
-  for (int i = 0; i < 21; i++) {
-    cov[i] += cov1[i] + cov2[i];
-  }
+  constexpr int MomInd[6] = {9, 13, 14, 18, 19, 20}; // cov matrix elements for momentum component
   for (int i = 0; i < 6; i++) {
     cov[i] = covxyz[i];
+    cov[MomInd[i]] = cov0[MomInd[i]] + cov1[MomInd[i]] + cov2[MomInd[i]];
   }
   this->set(xyz, pxyz, cov, tr0.getCharge() + tr1.getCharge() + tr2.getCharge(), true, pid);
 }

From 1e1c6e59cd667daec5e23981670bd3c767a710c0 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 17 Apr 2026 14:49:54 +0200
Subject: [PATCH 1550/1764] Fix typo in the TPCTimeSeriesSpec

---
 Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
index ee3acc808ccb7..ac3ff15fd3a29 100644
--- a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
@@ -1377,7 +1377,7 @@ class TPCTimeSeries : public Task
             if (propTPCOk) {
               // store delta parameters
               deltaP0OuterITS = trackTmp.getParam(0) - trackTmpOut.getParam(0);
-              deltaP1OuterITS = trackTmp.getParam(1) - trackTmpOut.getParam(2);
+              deltaP1OuterITS = trackTmp.getParam(1) - trackTmpOut.getParam(1);
               deltaP2OuterITS = trackTmp.getParam(2) - trackTmpOut.getParam(2);
               deltaP3OuterITS = trackTmp.getParam(3) - trackTmpOut.getParam(3);
               deltaP4OuterITS = trackTmp.getParam(4) - trackTmpOut.getParam(4);

From 8a51b175ab3fd3bf02ced8bd3c6eb837407f1ff1 Mon Sep 17 00:00:00 2001
From: Andreas Morsch <andreas.morsch@cern.ch>
Date: Fri, 17 Apr 2026 09:23:37 +0200
Subject: [PATCH 1551/1764] link to neutron point-like cross-sections needed
 starting from FLUKA_4.5

---
 Detectors/gconfig/src/FlukaConfig.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Detectors/gconfig/src/FlukaConfig.cxx b/Detectors/gconfig/src/FlukaConfig.cxx
index 4723d98244ca9..fe5f73bc7026c 100644
--- a/Detectors/gconfig/src/FlukaConfig.cxx
+++ b/Detectors/gconfig/src/FlukaConfig.cxx
@@ -42,6 +42,7 @@ void linkFlukaFiles()
   gSystem->Exec("ln -s $FLUKADATA/random.dat  .");
   gSystem->Exec("ln -s $FLUKADATA/dnr.dat  .");
   gSystem->Exec("ln -s $FLUKADATA/nunstab.data .");
+  gSystem->Exec("ln -s $FLUKADATA/neutron .");
   // Give some meaningfull name to the output
   gSystem->Exec("ln -s fluka.out fort.11");
   gSystem->Exec("ln -s fluka.err fort.15");

From 5500dfcc8141feaf3d86bfb0f43f4b990353edb0 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Thu, 26 Mar 2026 11:34:49 +0100
Subject: [PATCH 1552/1764] Cleanup: Remove old version of jobutils and
 cpulimit tool

Remove code no longer used
---
 Utilities/Tools/CMakeLists.txt                |   2 -
 Utilities/Tools/cpulimit/.clang-format        |   2 -
 Utilities/Tools/cpulimit/CMakeLists.txt       |  16 -
 Utilities/Tools/cpulimit/README               |   2 -
 Utilities/Tools/cpulimit/cpulimit.c           | 529 ------------------
 Utilities/Tools/cpulimit/list.c               | 148 -----
 Utilities/Tools/cpulimit/list.h               | 138 -----
 Utilities/Tools/cpulimit/process_group.c      | 219 --------
 Utilities/Tools/cpulimit/process_group.h      |  55 --
 Utilities/Tools/cpulimit/process_iterator.c   |  49 --
 Utilities/Tools/cpulimit/process_iterator.h   |  97 ----
 .../Tools/cpulimit/process_iterator_apple.c   | 148 -----
 .../Tools/cpulimit/process_iterator_freebsd.c | 119 ----
 .../Tools/cpulimit/process_iterator_linux.c   | 198 -------
 prodtests/full_system_test.sh                 |   2 +-
 prodtests/full_system_test_ci_extra_tests.sh  |   2 +-
 prodtests/full_system_test_pipeline.sh        |   4 +-
 prodtests/sim_challenge.sh                    |   2 +-
 run/SimExamples/SimAsService_biasing1/run.sh  |   4 +-
 19 files changed, 7 insertions(+), 1729 deletions(-)
 delete mode 100644 Utilities/Tools/cpulimit/.clang-format
 delete mode 100644 Utilities/Tools/cpulimit/CMakeLists.txt
 delete mode 100644 Utilities/Tools/cpulimit/README
 delete mode 100644 Utilities/Tools/cpulimit/cpulimit.c
 delete mode 100644 Utilities/Tools/cpulimit/list.c
 delete mode 100644 Utilities/Tools/cpulimit/list.h
 delete mode 100644 Utilities/Tools/cpulimit/process_group.c
 delete mode 100644 Utilities/Tools/cpulimit/process_group.h
 delete mode 100644 Utilities/Tools/cpulimit/process_iterator.c
 delete mode 100644 Utilities/Tools/cpulimit/process_iterator.h
 delete mode 100644 Utilities/Tools/cpulimit/process_iterator_apple.c
 delete mode 100644 Utilities/Tools/cpulimit/process_iterator_freebsd.c
 delete mode 100644 Utilities/Tools/cpulimit/process_iterator_linux.c

diff --git a/Utilities/Tools/CMakeLists.txt b/Utilities/Tools/CMakeLists.txt
index 55048623739b9..04002ad85dae7 100644
--- a/Utilities/Tools/CMakeLists.txt
+++ b/Utilities/Tools/CMakeLists.txt
@@ -9,9 +9,7 @@
 # granted to it by virtue of its status as an Intergovernmental Organization
 # or submit itself to any jurisdiction.
 
-add_subdirectory(cpulimit)
 
 install(PROGRAMS monitor-mem.sh DESTINATION share/scripts/)
-install(PROGRAMS jobutils.sh DESTINATION share/scripts/)
 install(PROGRAMS jobutils2.sh DESTINATION share/scripts/)
 install(PROGRAMS grid_submit.sh DESTINATION share/scripts/)
diff --git a/Utilities/Tools/cpulimit/.clang-format b/Utilities/Tools/cpulimit/.clang-format
deleted file mode 100644
index a43d914ec38dd..0000000000000
--- a/Utilities/Tools/cpulimit/.clang-format
+++ /dev/null
@@ -1,2 +0,0 @@
-DisableFormat: true
-SortIncludes: false
\ No newline at end of file
diff --git a/Utilities/Tools/cpulimit/CMakeLists.txt b/Utilities/Tools/cpulimit/CMakeLists.txt
deleted file mode 100644
index f1109c65fdb69..0000000000000
--- a/Utilities/Tools/cpulimit/CMakeLists.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-# All rights not expressly granted are reserved.
-#
-# This software is distributed under the terms of the GNU General Public
-# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-#
-# In applying this license CERN does not waive the privileges and immunities
-# granted to it by virtue of its status as an Intergovernmental Organization
-# or submit itself to any jurisdiction.
-
-add_executable(cpulimit
-               cpulimit.c list.c process_group.c process_iterator.c)
-target_compile_definitions(cpulimit PUBLIC _GNU_SOURCE)
-
-install(TARGETS cpulimit DESTINATION share/scripts/)
diff --git a/Utilities/Tools/cpulimit/README b/Utilities/Tools/cpulimit/README
deleted file mode 100644
index 20f543f9491ee..0000000000000
--- a/Utilities/Tools/cpulimit/README
+++ /dev/null
@@ -1,2 +0,0 @@
-These sources have been copied from https://github.com/opsengine/cpulimit
-commit f4d2682804931e.
\ No newline at end of file
diff --git a/Utilities/Tools/cpulimit/cpulimit.c b/Utilities/Tools/cpulimit/cpulimit.c
deleted file mode 100644
index e35a1565253e7..0000000000000
--- a/Utilities/Tools/cpulimit/cpulimit.c
+++ /dev/null
@@ -1,529 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- **************************************************************
- *
- * This is a simple program to limit the cpu usage of a process
- * If you modify this code, send me a copy please
- *
- * Get the latest version at: http://github.com/opsengine/cpulimit
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <getopt.h>
-#include <time.h>
-#include <signal.h>
-#include <errno.h>
-#include <string.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#if defined(__APPLE__)
-#include <sys/sysctl.h>
-#endif
-#include <sys/resource.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-
-#if defined(__APPLE__) || defined(__FREEBSD__)
-#include <libgen.h>
-#endif
-
-#include "process_group.h"
-#include "list.h"
-
-#ifdef HAVE_SYS_SYSINFO_H
-#include <sys/sysinfo.h>
-#endif
-
-//some useful macro
-#ifndef MIN
-#define MIN(a,b) (((a)<(b))?(a):(b))
-#endif
-#ifndef MAX
-#define MAX(a,b) (((a)>(b))?(a):(b))
-#endif
-
-//control time slot in microseconds
-//each slot is splitted in a working slice and a sleeping slice
-//TODO: make it adaptive, based on the actual system load
-#define TIME_SLOT 100000
-
-#define MAX_PRIORITY -10
-
-/* GLOBAL VARIABLES */
-
-//the "family"
-struct process_group pgroup;
-//pid of cpulimit
-pid_t cpulimit_pid;
-//name of this program (maybe cpulimit...)
-char *program_name;
-
-//number of cpu
-int NCPU;
-
-/* CONFIGURATION VARIABLES */
-
-//verbose mode
-int verbose = 0;
-//lazy mode (exits if there is no process)
-int lazy = 0;
-
-//SIGINT and SIGTERM signal handler
-static void quit(int sig)
-{
-	//let all the processes continue if stopped
-	struct list_node *node = NULL;
-	if (pgroup.proclist != NULL)
-	{
-		for (node = pgroup.proclist->first; node != NULL; node = node->next) {
-			struct process *p = (struct process*)(node->data);
-			kill(p->pid, SIGCONT);
-		}
-		close_process_group(&pgroup);
-	}
-	//fix ^C little problem
-	printf("\r");
-	fflush(stdout);
-	exit(0);
-}
-
-//return t1-t2 in microseconds (no overflow checks, so better watch out!)
-static inline unsigned long timediff(const struct timeval *t1,const struct timeval *t2)
-{
-	return (t1->tv_sec - t2->tv_sec) * 1000000 + (t1->tv_usec - t2->tv_usec);
-}
-
-static void print_usage(FILE *stream, int exit_code)
-{
-	fprintf(stream, "Usage: %s [OPTIONS...] TARGET\n", program_name);
-	fprintf(stream, "   OPTIONS\n");
-	fprintf(stream, "      -l, --limit=N          percentage of cpu allowed from 0 to %d (required)\n", 100*NCPU);
-	fprintf(stream, "      -v, --verbose          show control statistics\n");
-	fprintf(stream, "      -z, --lazy             exit if there is no target process, or if it dies\n");
-	fprintf(stream, "      -i, --include-children limit also the children processes\n");
-	fprintf(stream, "      -h, --help             display this help and exit\n");
-	fprintf(stream, "   TARGET must be exactly one of these:\n");
-	fprintf(stream, "      -p, --pid=N            pid of the process (implies -z)\n");
-	fprintf(stream, "      -e, --exe=FILE         name of the executable program file or path name\n");
-	fprintf(stream, "      COMMAND [ARGS]         run this command and limit it (implies -z)\n");
-	fprintf(stream, "\nReport bugs to <marlonx80@hotmail.com>.\n");
-	exit(exit_code);
-}
-
-static void increase_priority() {
-	//find the best available nice value
-	int old_priority = getpriority(PRIO_PROCESS, 0);
-	int priority = old_priority;
-	while (setpriority(PRIO_PROCESS, 0, priority-1) == 0 && priority>MAX_PRIORITY) {
-		priority--;	
-	}
-	if (priority != old_priority) {
-		if (verbose) { printf("Priority changed to %d\n", priority); }
-	}
-	else {
-		if (verbose) { printf("Warning: Cannot change priority. Run as root or renice for best results.\n"); }
-	}
-}
-
-/* Get the number of CPUs */
-static int get_ncpu() {
-	int ncpu;
-#ifdef _SC_NPROCESSORS_ONLN
-	ncpu = sysconf(_SC_NPROCESSORS_ONLN);
-#elif defined __APPLE__
-	int mib[2] = {CTL_HW, HW_NCPU};
-	size_t len = sizeof(ncpu);
-	sysctl(mib, 2, &ncpu, &len, NULL, 0);
-#elif defined _GNU_SOURCE
-	ncpu = get_nprocs();
-#else
-	ncpu = -1;
-#endif
-	return ncpu;
-}
-
-int get_pid_max()
-{
-#ifdef __linux__
-	//read /proc/sys/kernel/pid_max
-	static char buffer[1024];
-	FILE *fd = fopen("/proc/sys/kernel/pid_max", "r");
-	if (fd==NULL) { return -1; }
-	if (fgets(buffer, sizeof(buffer), fd)==NULL) {
-		fclose(fd);
-		return -1;
-	}
-	fclose(fd);
-	return atoi(buffer);
-#elif defined __FreeBSD__
-	return 99998;
-#elif defined __APPLE__
-	return 99998;
-#endif
-}
-
-void limit_process(pid_t pid, double limit, int include_children)
-{
-	//slice of the slot in which the process is allowed to run
-	struct timespec twork;
-	//slice of the slot in which the process is stopped
-	struct timespec tsleep;
-	//when the last twork has started
-	struct timeval startwork;
-	//when the last twork has finished
-	struct timeval endwork;
-	//initialization
-	memset(&twork, 0, sizeof(struct timespec));
-	memset(&tsleep, 0, sizeof(struct timespec));
-	memset(&startwork, 0, sizeof(struct timeval));
-	memset(&endwork, 0, sizeof(struct timeval));	
-	//last working time in microseconds
-	unsigned long workingtime = 0;
-	//generic list item
-	struct list_node *node;
-	//counter
-	int c = 0;
-
-	//get a better priority
-	increase_priority();
-	
-	//build the family
-	init_process_group(&pgroup, pid, include_children);
-
-	if (verbose) { printf("Members in the process group owned by %d: %d\n", pgroup.target_pid, pgroup.proclist->count); }
-
-	//rate at which we are keeping active the processes (range 0-1)
-	//1 means that the process are using all the twork slice
-	double workingrate = -1;
-	while(1) {
-		update_process_group(&pgroup);
-
-		if (pgroup.proclist->count==0) {
-			if (verbose) { printf("No more processes.\n"); }
-			break;
-		}
-		
-		//total cpu actual usage (range 0-1)
-		//1 means that the processes are using 100% cpu
-		double pcpu = -1;
-
-		//estimate how much the controlled processes are using the cpu in the working interval
-		for (node = pgroup.proclist->first; node != NULL; node = node->next) {
-			struct process *proc = (struct process*)(node->data);
-			if (proc->cpu_usage < 0) {
-				continue;
-			}
-			if (pcpu < 0) { pcpu = 0; }
-			pcpu += proc->cpu_usage;
-		}
-
-		//adjust work and sleep time slices
-		if (pcpu < 0) {
-			//it's the 1st cycle, initialize workingrate
-			pcpu = limit;
-			workingrate = limit;
-			twork.tv_nsec = TIME_SLOT * limit * 1000;
-		}
-		else {
-			//adjust workingrate
-			workingrate = MIN(workingrate / pcpu * limit, 1);
-			twork.tv_nsec = TIME_SLOT * 1000 * workingrate;
-		}
-		tsleep.tv_nsec = TIME_SLOT * 1000 - twork.tv_nsec;
-
-		if (verbose) {
-			if (c%200==0) {
-				printf("\n%%CPU\twork quantum\tsleep quantum\tactive rate\n");
-			}
-			if (c%10==0 && c>0) {
-				printf("%0.2lf%%\t%6ld us\t%6ld us\t%0.2lf%%\n", pcpu*100, twork.tv_nsec/1000, tsleep.tv_nsec/1000, workingrate*100);
-			}
-		}
-
-		//resume processes
-		node = pgroup.proclist->first;
-		while (node != NULL)
-		{
-			struct list_node *next_node = node->next;
-			struct process *proc = (struct process*)(node->data);
-			if (kill(proc->pid,SIGCONT) != 0) {
-				//process is dead, remove it from family
-				if (verbose) { fprintf(stderr, "SIGCONT failed. Process %d dead!\n", proc->pid); }
-				//remove process from group
-				delete_node(pgroup.proclist, node);
-				remove_process(&pgroup, proc->pid);
-			}
-			node = next_node;
-		}
-
-		//now processes are free to run (same working slice for all)
-		gettimeofday(&startwork, NULL);
-		nanosleep(&twork, NULL);
-		gettimeofday(&endwork, NULL);
-		workingtime = timediff(&endwork, &startwork);
-		
-		long delay = workingtime - twork.tv_nsec/1000;
-		if (c>0 && delay>10000) {
-			//delay is too much! signal to user?
-			//fprintf(stderr, "%d %ld us\n", c, delay);
-		}
-
-		if (tsleep.tv_nsec>0) {
-			//stop processes only if tsleep>0
-			node = pgroup.proclist->first;
-			while (node != NULL)
-			{
-				struct list_node *next_node = node->next;
-				struct process *proc = (struct process*)(node->data);
-				if (kill(proc->pid,SIGSTOP)!=0) {
-					//process is dead, remove it from family
-					if (verbose) { fprintf(stderr, "SIGSTOP failed. Process %d dead!\n", proc->pid); }
-					//remove process from group
-					delete_node(pgroup.proclist, node);
-					remove_process(&pgroup, proc->pid);
-				}
-				node = next_node;
-			}
-			//now the processes are sleeping
-			nanosleep(&tsleep,NULL);
-		}
-		c++;
-	}
-	close_process_group(&pgroup);
-}
-
-int main(int argc, char **argv) {
-	//argument variables
-	const char *exe = NULL;
-	int perclimit = 0;
-	int exe_ok = 0;
-	int pid_ok = 0;
-	int limit_ok = 0;
-	pid_t pid = 0;
-	int include_children = 0;
-
-	//get program name
-	char *p = (char*)strrchr(argv[0], '/');
-	program_name = p==NULL ? argv[0] : (p+1);
-	//get current pid
-	cpulimit_pid = getpid();
-	//get cpu count
-	NCPU = get_ncpu();
-
-	//parse arguments
-	int next_option;
-    int option_index = 0;
-	//A string listing valid short options letters
-	const char* short_options = "+p:e:l:vzih";
-	//An array describing valid long options
-	const struct option long_options[] = {
-		{ "pid",        required_argument, NULL, 'p' },
-		{ "exe",        required_argument, NULL, 'e' },
-		{ "limit",      required_argument, NULL, 'l' },
-		{ "verbose",    no_argument,       NULL, 'v' },
-		{ "lazy",       no_argument,       NULL, 'z' },
-		{ "include-children", no_argument,  NULL, 'i' },
-		{ "help",       no_argument,       NULL, 'h' },
-		{ 0,            0,                 0,     0  }
-	};
-
-	do {
-		next_option = getopt_long(argc, argv, short_options,long_options, &option_index);
-		switch(next_option) {
-			case 'p':
-				pid = atoi(optarg);
-				pid_ok = 1;
-				break;
-			case 'e':
-				exe = optarg;
-				exe_ok = 1;
-				break;
-			case 'l':
-				perclimit = atoi(optarg);
-				limit_ok = 1;
-				break;
-			case 'v':
-				verbose = 1;
-				break;
-			case 'z':
-				lazy = 1;
-				break;
-			case 'i':
-				include_children = 1;
-				break;
-			case 'h':
-				print_usage(stdout, 1);
-				break;
-			case '?':
-				print_usage(stderr, 1);
-				break;
-			case -1:
-				break;
-			default:
-				abort();
-		}
-	} while(next_option != -1);
-
-	if (pid_ok && (pid <= 1 || pid >= get_pid_max())) {
-		fprintf(stderr,"Error: Invalid value for argument PID\n");
-		print_usage(stderr, 1);
-		exit(1);
-	}
-	if (pid != 0) {
-		lazy = 1;
-	}
-
-	if (!limit_ok) {
-		fprintf(stderr,"Error: You must specify a cpu limit percentage\n");
-		print_usage(stderr, 1);
-		exit(1);
-	}
-	double limit = perclimit / 100.0;
-	if (limit<0 || limit >NCPU) {
-		fprintf(stderr,"Error: limit must be in the range 0-%d00\n", NCPU);
-		print_usage(stderr, 1);
-		exit(1);
-	}
-
-	int command_mode = optind < argc;
-	if (exe_ok + pid_ok + command_mode == 0) {
-		fprintf(stderr,"Error: You must specify one target process, either by name, pid, or command line\n");
-		print_usage(stderr, 1);
-		exit(1);
-	}
-	
-	if (exe_ok + pid_ok + command_mode > 1) {
-		fprintf(stderr,"Error: You must specify exactly one target process, either by name, pid, or command line\n");
-		print_usage(stderr, 1);
-		exit(1);
-	}
-
-	//all arguments are ok!
-	signal(SIGINT, quit);
-	signal(SIGTERM, quit);
-
-	//print the number of available cpu
-	if (verbose) { printf("%d cpu detected\n", NCPU); }
-
-	if (command_mode) {
-		int i;
-		//executable file
-		const char *cmd = argv[optind];
-		//command line arguments
-		char **cmd_args = (char**)malloc((argc-optind + 1) * sizeof(char*));
-		if (cmd_args==NULL) { exit(2); }
-		for (i=0; i<argc-optind; i++) {
-			cmd_args[i] = argv[i+optind];
-		}
-		cmd_args[i] = NULL;
-
-		if (verbose) {
-			printf("Running command: '%s", cmd);
-			for (i=1; i<argc-optind; i++) {
-				printf(" %s", cmd_args[i]);
-			}
-			printf("'\n");
-		}
-		
-		int child = fork();
-		if (child < 0) {
-			exit(EXIT_FAILURE);
-		}
-		else if (child == 0) {
-			//target process code
-			int ret = execvp(cmd, cmd_args);
-			//if we are here there was an error, show it
-			perror("Error");
-			exit(ret);
-		}
-		else {
-			//parent code
-			free(cmd_args);
-			int limiter = fork();
-			if (limiter < 0) {
-				exit(EXIT_FAILURE);
-			}
-			else if (limiter > 0) {
-				//parent
-				int status_process;
-				int status_limiter;
-				waitpid(child, &status_process, 0);
-				waitpid(limiter, &status_limiter, 0);
-				if (WIFEXITED(status_process)) {
-					if (verbose) { printf("Process %d terminated with exit status %d\n", child, (int)WEXITSTATUS(status_process)); }
-					exit(WEXITSTATUS(status_process));
-				}
-				printf("Process %d terminated abnormally\n", child);
-				exit(status_process);
-			}
-			else {
-				//limiter code
-				if (verbose) { printf("Limiting process %d\n",child); }
-				limit_process(child, limit, include_children);
-				exit(0);
-			}
-		}
-	}
-
-	while(1) {
-		//look for the target process..or wait for it
-		pid_t ret = 0;
-		if (pid_ok) {
-			//search by pid
-			ret = find_process_by_pid(pid);
-			if (ret == 0) {
-				printf("No process found\n");
-			}
-			else if (ret < 0) {
-				printf("Process found but you aren't allowed to control it\n");
-			}
-		}
-		else {
-			//search by file or path name
-			ret = find_process_by_name(exe);
-			if (ret == 0) {
-				printf("No process found\n");
-			}
-			else if (ret < 0) {
-				printf("Process found but you aren't allowed to control it\n");
-			}
-			else {
-				pid = ret;
-			}
-		}
-		if (ret > 0) {
-			if (ret == cpulimit_pid) {
-				printf("Target process %d is cpulimit itself! Aborting because it makes no sense\n", ret);
-				exit(1);
-			}
-			printf("Process %d found\n", pid);
-			//control
-			limit_process(pid, limit, include_children);
-		}
-		if (lazy) { break; }
-		sleep(2);
-	};
-	
-	exit(0);
-}
diff --git a/Utilities/Tools/cpulimit/list.c b/Utilities/Tools/cpulimit/list.c
deleted file mode 100644
index 2ac36708d4a08..0000000000000
--- a/Utilities/Tools/cpulimit/list.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "list.h"
-
-#define EMPTYLIST NULL
-
-void init_list(struct list *l,int keysize) {
-	l->first=l->last=NULL;
-	l->keysize=keysize;
-	l->count=0;
-}
-
-struct list_node *add_elem(struct list *l,void *elem) {
-	struct list_node *newnode=(struct list_node*)malloc(sizeof(struct list_node));
-	newnode->data=elem;
-	newnode->previous=l->last;
-	newnode->next=NULL;
-	if (l->count==0) {
-		l->first=l->last=newnode;
-	}
-	else {
-		l->last->next=newnode;
-		l->last=newnode;
-	}
-	l->count++;
-	return newnode;
-}
-
-void delete_node(struct list *l,struct list_node *node) {
-	if (l->count==1) {
-		l->first=l->last=NULL;
-	}
-	else if (node==l->first) {
-		node->next->previous=NULL;
-		l->first=node->next;
-	}
-	else if (node==l->last) {
-		node->previous->next=NULL;
-		l->last=node->previous;
-	}
-	else {
-		node->previous->next=node->next;
-		node->next->previous=node->previous;
-	}
-	l->count--;
-	free(node);
-}
-
-void destroy_node(struct list *l,struct list_node *node) {
-	free(node->data);
-	node->data=NULL;
-	delete_node(l,node);
-}
-
-int is_empty_list(struct list *l) {
-	return (l->count==0?TRUE:FALSE);
-}
-
-int get_list_count(struct list *l) {
-	return l->count;
-}
-
-void *first_elem(struct list *l) {
-	return l->first->data;
-}
-
-struct list_node *first_node(struct list *l) {
-	return l->first;
-}
-
-void *last_elem(struct list *l) {
-	return l->last->data;
-}
-
-struct list_node *last_node(struct list *l) {
-	return l->last;
-}
-
-struct list_node *xlocate_node(struct list *l,void *elem,int offset,int length) {
-	struct list_node *tmp;
-	tmp=l->first;
-	while(tmp!=NULL) {
-		if(!memcmp((char*)tmp->data+offset,elem,length==0?l->keysize:length)) { return (tmp); }
-		tmp=tmp->next;
-	}
-	return EMPTYLIST;
-}
-
-struct list_node *locate_node(struct list *l,void *elem) {
-	return(xlocate_node(l,elem,0,0));
-}
-
-void *xlocate_elem(struct list *l,void *elem,int offset,int length) {
-	struct list_node *node=xlocate_node(l,elem,offset,length);
-	return(node==NULL?NULL:node->data);
-}
-
-void *locate_elem(struct list *l,void *elem) {
-	return(xlocate_elem(l,elem,0,0));
-}
-
-void clear_list(struct list *l) {
-	while(l->first!=EMPTYLIST) {
-		struct list_node *tmp;
-		tmp=l->first;
-		l->first=l->first->next;
-		free(tmp);
-		tmp=NULL;
-	}
-	l->last=EMPTYLIST;
-	l->count=0;
-}
-
-void destroy_list(struct list *l) {
-	while(l->first!=EMPTYLIST) {
-		struct list_node *tmp;
-		tmp=l->first;
-		l->first=l->first->next;
-		free(tmp->data);
-		tmp->data=NULL;
-		free(tmp);
-		tmp=NULL;
-	}
-	l->last=EMPTYLIST;
-	l->count=0;
-}
diff --git a/Utilities/Tools/cpulimit/list.h b/Utilities/Tools/cpulimit/list.h
deleted file mode 100644
index 0b43a2b39c0f3..0000000000000
--- a/Utilities/Tools/cpulimit/list.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#ifndef __LIST__
-
-#define __LIST__
-
-#ifndef  TRUE
-    #define TRUE 1
-    #define FALSE 0
-#endif
-
-struct list_node {
-    //pointer to the content of the node
-    void *data;
-    //pointer to previous node
-    struct list_node *previous;
-    //pointer to next node
-    struct list_node *next;
-};
-
-struct list {
-    //first node
-    struct list_node *first;
-    //last node
-    struct list_node *last;
-    //size of the search key in bytes
-    int keysize;
-    //element count
-    int count;
-};
-
-/*
- * Initialize a list, with a specified key size
- */
-void init_list(struct list *l,int keysize);
-
-/*
- * Add a new element at the end of the list
- * return the pointer to the new node
- */
-struct list_node *add_elem(struct list *l,void *elem);
-
-/*
- * Delete a node
- */
-void delete_node(struct list *l,struct list_node *node);
-
-/*
- * Delete a node from the list, even the content pointed by it
- * Use only when the content is a dynamically allocated pointer
- */
-void destroy_node(struct list *l,struct list_node *node);
-
-/*
- * Check whether a list is empty or not
- */
-int is_empty_list(struct list *l);
-
-/*
- * Return the element count of the list
- */
-int get_list_count(struct list *l);
-
-/*
- * Return the first element (content of the node) from the list
- */
-void *first_elem(struct list *l);
-
-/*
- * Return the first node from the list
- */
-struct list_node *first_node(struct list *l);
-
-/*
- * Return the last element (content of the node) from the list
- */
-void *last_elem(struct list *l);
-
-/*
- * Return the last node from the list
- */
-struct list_node *last_node(struct list *l);
-
-/*
- * Search an element of the list by content
- * the comparison is done from the specified offset and for a specified length
- * if offset=0, the comparison starts from the address pointed by data
- * if length=0, default keysize is used for length
- * if the element is found, return the node address
- * else return NULL
- */
-struct list_node *xlocate_node(struct list *l,void *elem,int offset,int length);
-
-/*
- * The same of xlocate_node(), but return the content of the node
- */
-void *xlocate_elem(struct list *l,void *elem,int offset,int length);
-
-/*
- * The same of calling xlocate_node() with offset=0 and length=0
- */
-struct list_node *locate_node(struct list *l,void *elem);
-
-/*
- * The same of locate_node, but return the content of the node
- */
-void *locate_elem(struct list *l,void *elem);
-
-/*
- * Delete all the elements in the list
- */
-void clear_list(struct list *l);
-
-/*
- * Delete every element in the list, and free the memory pointed by all the node data
- */
-void destroy_list(struct list *l);
-
-#endif
diff --git a/Utilities/Tools/cpulimit/process_group.c b/Utilities/Tools/cpulimit/process_group.c
deleted file mode 100644
index c5343e32bd9a1..0000000000000
--- a/Utilities/Tools/cpulimit/process_group.c
+++ /dev/null
@@ -1,219 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#if defined(__APPLE__) || defined(__FREEBSD__)
-#include <libgen.h>
-#endif
-
-#include <string.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <sys/time.h>
-#include <signal.h>
-
-#include <assert.h>
-
-#include "process_iterator.h"
-#include "process_group.h"
-#include "list.h"
-
-// look for a process by pid
-// search_pid   : pid of the wanted process
-// return:  pid of the found process, if successful
-//          negative pid, if the process does not exist or if the signal fails
-int find_process_by_pid(pid_t pid)
-{
-	return (kill(pid,0)==0) ? pid : -pid;
-}
-
-// look for a process with a given name
-// process: the name of the wanted process. it can be an absolute path name to the executable file
-//         or just the file name
-// return:  pid of the found process, if it is found
-//         0, if it's not found
-//         negative pid, if it is found but it's not possible to control it
-int find_process_by_name(const char *process_name)
-{
-	//pid of the target process
-	pid_t pid = -1;
-
-	//process iterator
-	struct process_iterator it;
-	struct process proc;
-	struct process_filter filter;
-	filter.pid = 0;
-	filter.include_children = 0;
-	init_process_iterator(&it, &filter);
-	while (get_next_process(&it, &proc) != -1)
-	{
-		//process found
-		if (strncmp(basename(proc.command), process_name, strlen(process_name))==0 && kill(pid,SIGCONT)==0) {
-			//process is ok!
-			pid = proc.pid;
-			break;
-		}
-	}
-	if (close_process_iterator(&it) != 0) {
-		exit(1);
-	}
-	if (pid >= 0) {
-		//ok, the process was found
-		return pid;
-	}
-	else {
-		//process not found
-		return 0;
-	}
-}
-
-int init_process_group(struct process_group *pgroup, int target_pid, int include_children)
-{
-	//hashtable initialization
-	memset(&pgroup->proctable, 0, sizeof(pgroup->proctable));
-	pgroup->target_pid = target_pid;
-	pgroup->include_children = include_children;
-	pgroup->proclist = (struct list*)malloc(sizeof(struct list));
-	init_list(pgroup->proclist, 4);
-	memset(&pgroup->last_update, 0, sizeof(pgroup->last_update));
-	update_process_group(pgroup);
-	return 0;
-}
-
-int close_process_group(struct process_group *pgroup)
-{
-	int i;
-	int size = sizeof(pgroup->proctable) / sizeof(struct process*);
-	for (i=0; i<size; i++) {
-		if (pgroup->proctable[i] != NULL) {
-			//free() history for each process
-			destroy_list(pgroup->proctable[i]);
-			free(pgroup->proctable[i]);
-			pgroup->proctable[i] = NULL;
-		}
-	}
-	clear_list(pgroup->proclist);
-	free(pgroup->proclist);
-	pgroup->proclist = NULL;
-	return 0;
-}
-
-void remove_terminated_processes(struct process_group *pgroup)
-{
-	//TODO
-}
-
-//return t1-t2 in microseconds (no overflow checks, so better watch out!)
-static inline unsigned long timediff(const struct timeval *t1,const struct timeval *t2)
-{
-	return (t1->tv_sec - t2->tv_sec) * 1000000 + (t1->tv_usec - t2->tv_usec);
-}
-
-//parameter in range 0-1
-#define ALFA 0.08
-#define MIN_DT 20
-
-void update_process_group(struct process_group *pgroup)
-{
-	struct process_iterator it;
-	struct process tmp_process;
-	struct process_filter filter;
-	struct timeval now;
-	gettimeofday(&now, NULL);
-	//time elapsed from previous sample (in ms)
-	long dt = timediff(&now, &pgroup->last_update) / 1000;
-	filter.pid = pgroup->target_pid;
-	filter.include_children = pgroup->include_children;
-	init_process_iterator(&it, &filter);
-	clear_list(pgroup->proclist);
-	init_list(pgroup->proclist, 4);
-
-	while (get_next_process(&it, &tmp_process) != -1)
-	{
-//		struct timeval t;
-//		gettimeofday(&t, NULL);
-//		printf("T=%ld.%ld PID=%d PPID=%d START=%d CPUTIME=%d\n", t.tv_sec, t.tv_usec, tmp_process.pid, tmp_process.ppid, tmp_process.starttime, tmp_process.cputime);
-		int hashkey = pid_hashfn(tmp_process.pid);
-		if (pgroup->proctable[hashkey] == NULL)
-		{
-			//empty bucket
-			pgroup->proctable[hashkey] = malloc(sizeof(struct list));
-			struct process *new_process = malloc(sizeof(struct process));
-			tmp_process.cpu_usage = -1;
-			memcpy(new_process, &tmp_process, sizeof(struct process));
-			init_list(pgroup->proctable[hashkey], 4);
-			add_elem(pgroup->proctable[hashkey], new_process);
-			add_elem(pgroup->proclist, new_process);
-		}
-		else
-		{
-			//existing bucket
-			struct process *p = (struct process*)locate_elem(pgroup->proctable[hashkey], &tmp_process);
-			if (p == NULL)
-			{
-				//process is new. add it
-				struct process *new_process = malloc(sizeof(struct process));
-				tmp_process.cpu_usage = -1;
-				memcpy(new_process, &tmp_process, sizeof(struct process));
-				add_elem(pgroup->proctable[hashkey], new_process);
-				add_elem(pgroup->proclist, new_process);
-			}
-			else
-			{
-				assert(tmp_process.pid == p->pid);
-				assert(tmp_process.starttime == p->starttime);
-				add_elem(pgroup->proclist, p);
-				if (dt < MIN_DT) {
-					continue;
-				}
-				//process exists. update CPU usage
-				double sample = 1.0 * (tmp_process.cputime - p->cputime) / dt;
-				if (p->cpu_usage == -1) {
-					//initialization
-					p->cpu_usage = sample;
-				}
-				else {
-					//usage adjustment
-					p->cpu_usage = (1.0-ALFA) * p->cpu_usage + ALFA * sample;
-				}
-				p->cputime = tmp_process.cputime;
-			}
-		}
-	}
-	close_process_iterator(&it);
-	if (dt < MIN_DT) {
-		return;
-	}
-	pgroup->last_update = now;
-}
-
-int remove_process(struct process_group *pgroup, int pid)
-{
-	int hashkey = pid_hashfn(pid);
-	if (pgroup->proctable[hashkey] == NULL) {
-		return 1; //nothing to delete
-	}
-	struct list_node *node = (struct list_node*)locate_node(pgroup->proctable[hashkey], &pid);
-	if (node == NULL) {
-		return 2;
-	}
-	delete_node(pgroup->proctable[hashkey], node);
-	return 0;
-}
diff --git a/Utilities/Tools/cpulimit/process_group.h b/Utilities/Tools/cpulimit/process_group.h
deleted file mode 100644
index 5a5b581554a80..0000000000000
--- a/Utilities/Tools/cpulimit/process_group.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#ifndef __PROCESS_GROUP_H
-
-#define __PROCESS_GROUP_H
-
-#include "process_iterator.h"
-
-#include "list.h"
-
-#define PIDHASH_SZ 1024
-#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
-
-struct process_group
-{
-	//hashtable with all the processes (array of struct list of struct process)
-	struct list *proctable[PIDHASH_SZ];
-	struct list *proclist;
-	pid_t target_pid;
-	int include_children;
-	struct timeval last_update;
-};
-
-int init_process_group(struct process_group *pgroup, int target_pid, int include_children);
-
-void update_process_group(struct process_group *pgroup);
-
-int close_process_group(struct process_group *pgroup);
-
-int find_process_by_pid(pid_t pid);
-
-int find_process_by_name(const char *process_name);
-
-int remove_process(struct process_group *pgroup, int pid);
-
-#endif
diff --git a/Utilities/Tools/cpulimit/process_iterator.c b/Utilities/Tools/cpulimit/process_iterator.c
deleted file mode 100644
index 8b4019d237f2b..0000000000000
--- a/Utilities/Tools/cpulimit/process_iterator.c
+++ /dev/null
@@ -1,49 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#ifndef __APPLE__
-#include <sys/procfs.h>
-#endif
-#include <time.h>
-#include "process_iterator.h"
-
-//See this link to port to other systems: http://www.steve.org.uk/Reference/Unix/faq_8.html#SEC85
-
-#ifdef __linux__
-
-#include "process_iterator_linux.c"
-
-#elif defined __FreeBSD__
-
-#include "process_iterator_freebsd.c"
-
-#elif defined __APPLE__
-
-#include "process_iterator_apple.c"
-
-#else
-
-#error Platform not supported
-
-#endif
diff --git a/Utilities/Tools/cpulimit/process_iterator.h b/Utilities/Tools/cpulimit/process_iterator.h
deleted file mode 100644
index 70520b68a6e88..0000000000000
--- a/Utilities/Tools/cpulimit/process_iterator.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#ifndef __PROCESS_ITERATOR_H
-
-#define __PROCESS_ITERATOR_H
-
-#include <unistd.h>
-#include <limits.h>
-#include <dirent.h>
-
-//USER_HZ detection, from openssl code
-#ifndef HZ
-# if defined(_SC_CLK_TCK) \
-     && (!defined(OPENSSL_SYS_VMS) || __CTRL_VER >= 70000000)
-#  define HZ ((double)sysconf(_SC_CLK_TCK))
-# else
-#  ifndef CLK_TCK
-#   ifndef _BSD_CLK_TCK_ /* FreeBSD hack */
-#    define HZ  100.0
-#   else /* _BSD_CLK_TCK_ */
-#    define HZ ((double)_BSD_CLK_TCK_)
-#   endif
-#  else /* CLK_TCK */
-#   define HZ ((double)CLK_TCK)
-#  endif
-# endif
-#endif
-
-#ifdef __FreeBSD__
-#include <kvm.h>
-#endif
-
-// process descriptor
-struct process {
-	//pid of the process
-	pid_t pid;
-	//ppid of the process
-	pid_t ppid;
-	//start time (unix timestamp)
-	int starttime;
-	//cputime used by the process (in milliseconds)
-	int cputime;
-	//actual cpu usage estimation (value in range 0-1)
-	double cpu_usage;
-	//absolute path of the executable file
-	char command[PATH_MAX+1];
-};
-
-struct process_filter {
-	int pid;
-	int include_children;
-	char program_name[PATH_MAX+1];
-};
-
-struct process_iterator {
-#ifdef __linux__
-	DIR *dip;
-	int boot_time;
-#elif defined __FreeBSD__
-	kvm_t *kd;
-	struct kinfo_proc *procs;
-	int count;
-	int i;
-#elif defined __APPLE__
-	int i;
-	int count;
-	int *pidlist;
-#endif
-	struct process_filter *filter;
-};
-
-int init_process_iterator(struct process_iterator *i, struct process_filter *filter);
-
-int get_next_process(struct process_iterator *i, struct process *p);
-
-int close_process_iterator(struct process_iterator *i);
-
-#endif
diff --git a/Utilities/Tools/cpulimit/process_iterator_apple.c b/Utilities/Tools/cpulimit/process_iterator_apple.c
deleted file mode 100644
index b878ed8c9a946..0000000000000
--- a/Utilities/Tools/cpulimit/process_iterator_apple.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- * 
- * Author: Simon Sigurdhsson
- *
- */
-
-#include <errno.h>
-#include <stdio.h>
-#include <libproc.h>
-
-int unique_nonzero_ints(int* arr_in, int len_in, int* arr_out) {
-	int* source = arr_in;
-	if (arr_out == NULL) return -1;
-	if (arr_in == arr_out) {
-		source = malloc(sizeof(int)*len_in);
-		memcpy(source, arr_in, sizeof(int)*len_in);
-		memset(arr_out, -1, sizeof(int)*len_in);
-	}
-	int len_out = 0;
-        int i, j;
-	for (i=0; i<len_in; i++) {
-		int found = 0;
-		if (source[i] == 0) continue;
-		for (j=0; !found && j<len_out; j++) {
-			found = (source[i] == arr_out[j]) ? 1 : 0;
-		}
-		if (!found) {
-			arr_out[len_out++] = source[i];
-		}
-	}
-	if (arr_in == arr_out) {
-		free(source);
-	}
-	return len_out-1;
-}
-
-int init_process_iterator(struct process_iterator *it, struct process_filter *filter) {
-	it->i = 0;
-	/* Find out how much to allocate for it->pidlist */
-	if ((it->count = proc_listpids(PROC_ALL_PIDS, 0, NULL, 0)) <= 0) {
-		fprintf(stderr, "proc_listpids: %s\n", strerror(errno));
-		return -1;
-	}
-	/* Allocate and populate it->pidlist */
-	if ((it->pidlist = (int *)malloc((it->count)*sizeof(int))) == NULL) {
-		fprintf(stderr, "malloc: %s\n", strerror(errno));
-	}
-	if ((it->count = proc_listpids(PROC_ALL_PIDS, 0, it->pidlist, it->count)) <= 0) {
-		fprintf(stderr, "proc_listpids: %s\n", strerror(errno));
-		return -1;
-	}
-	it->count = unique_nonzero_ints(it->pidlist, it->count, it->pidlist);
-	it->filter = filter;
-	return 0;
-}
-
-static int pti2proc(struct proc_taskallinfo *ti, struct process *process) {
-	int bytes;
-	process->pid = ti->pbsd.pbi_pid;
-	process->ppid = ti->pbsd.pbi_ppid;
-	process->starttime = ti->pbsd.pbi_start_tvsec;
-	process->cputime = (ti->ptinfo.pti_total_user + ti->ptinfo.pti_total_system) / 1000000;
-	bytes = strlen(ti->pbsd.pbi_comm);
-	memcpy(process->command, ti->pbsd.pbi_comm, (bytes < PATH_MAX ? bytes : PATH_MAX) + 1);
-	return 0;
-}
-
-static int get_process_pti(pid_t pid, struct proc_taskallinfo *ti) {
-	int bytes;
-	bytes = proc_pidinfo(pid, PROC_PIDTASKALLINFO, 0, ti, sizeof(*ti));
-	if (bytes <= 0) {
-		if (!(errno & (EPERM | ESRCH))) {
-			fprintf(stderr, "proc_pidinfo: %s\n", strerror(errno));
-		}
-		return -1;
-	} else if (bytes < sizeof(ti)) {
-		fprintf(stderr, "proc_pidinfo: too few bytes; expected %ld, got %d\n", sizeof(ti), bytes);
-		return -1;
-	}
-	return 0;
-}
-
-int get_next_process(struct process_iterator *it, struct process *p) {
-	if (it->i == it->count) return -1;
-	if (it->filter->pid != 0 && !it->filter->include_children) {
-		struct proc_taskallinfo ti;
-		if (get_process_pti(it->filter->pid, &ti) != 0) {
-			it->i = it->count = 0;
-			return -1;
-		}
-		it->i = it->count = 1;
-		return pti2proc(&ti, p);
-	}
-	while (it->i < it->count) {
-		struct proc_taskallinfo ti;
-		if (get_process_pti(it->pidlist[it->i], &ti) != 0) {
-			it->i++;
-			continue;
-		}
-		if (ti.pbsd.pbi_flags & PROC_FLAG_SYSTEM) {
-			it->i++;
-			continue;
-		}
-		if (it->filter->pid != 0 && it->filter->include_children) {
-			pti2proc(&ti, p);
-			it->i++;
-			if (p->pid != it->pidlist[it->i - 1]) // I don't know why this can happen
-				continue;
-			if (p->pid != it->filter->pid && p->ppid != it->filter->pid)
-				continue;
-			return 0;
-		}
-		else if (it->filter->pid == 0)
-		{
-			pti2proc(&ti, p);
-			it->i++;
-			return 0;
-		}
-	}
-	return -1;
-}
-
-int close_process_iterator(struct process_iterator *it) {
-	free(it->pidlist);
-	it->pidlist = NULL;
-	it->filter = NULL;
-	it->count = 0;
-	it->i = 0;
-	return 0;
-}
diff --git a/Utilities/Tools/cpulimit/process_iterator_freebsd.c b/Utilities/Tools/cpulimit/process_iterator_freebsd.c
deleted file mode 100644
index a6381123e1251..0000000000000
--- a/Utilities/Tools/cpulimit/process_iterator_freebsd.c
+++ /dev/null
@@ -1,119 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#include <sys/sysctl.h>
-#include <sys/user.h>
-#include <fcntl.h>
-#include <paths.h>
-
-int init_process_iterator(struct process_iterator *it, struct process_filter *filter) {
-	char errbuf[_POSIX2_LINE_MAX];
-	it->i = 0;
-	/* Open the kvm interface, get a descriptor */
-	if ((it->kd = kvm_openfiles(NULL, _PATH_DEVNULL, NULL, O_RDONLY, errbuf)) == NULL) {
-		fprintf(stderr, "kvm_open: %s\n", errbuf);
-		return -1;
-	}
-	/* Get the list of processes. */
-	if ((it->procs = kvm_getprocs(it->kd, KERN_PROC_PROC, 0, &it->count)) == NULL) {
-		kvm_close(it->kd);
-//		fprintf(stderr, "kvm_getprocs: %s\n", kvm_geterr(it->kd));
-		return -1;
-	}
-	it->filter = filter;
-	return 0;
-}
-
-static int kproc2proc(kvm_t *kd, struct kinfo_proc *kproc, struct process *proc)
-{
-	proc->pid = kproc->ki_pid;
-	proc->ppid = kproc->ki_ppid;
-	proc->cputime = kproc->ki_runtime / 1000;
-	proc->starttime = kproc->ki_start.tv_sec;
-	char **args = kvm_getargv(kd, kproc, sizeof(proc->command));
-	if (args == NULL) return -1;
-	memcpy(proc->command, args[0], strlen(args[0]) + 1);
-	return 0;
-}
-
-static int get_single_process(kvm_t *kd, pid_t pid, struct process *process)
-{
-	int count;
-	struct kinfo_proc *kproc = kvm_getprocs(kd, KERN_PROC_PID, pid, &count);
-	if (count == 0 || kproc == NULL)
-	{
-//		fprintf(stderr, "kvm_getprocs: %s\n", kvm_geterr(kd));
-		return -1;
-	}
-	kproc2proc(kd, kproc, process);
-	return 0;
-}
-
-int get_next_process(struct process_iterator *it, struct process *p) {
-	if (it->i == it->count)
-	{
-		return -1;
-	}
-	if (it->filter->pid != 0 && !it->filter->include_children)
-	{
-		if (get_single_process(it->kd, it->filter->pid, p) != 0)
-		{
-			it->i = it->count = 0;
-			return -1;
-		}
-		it->i = it->count = 1;
-		return 0;
-	}
-	while (it->i < it->count)
-	{
-		struct kinfo_proc *kproc = &(it->procs[it->i]);
-		if (kproc->ki_flag & P_SYSTEM)
-		{
-			// skip system processes
-			it->i++;
-			continue;
-		}
-		if (it->filter->pid != 0 && it->filter->include_children)
-		{
-			kproc2proc(it->kd, kproc, p);
-			it->i++;
-			if (p->pid != it->filter->pid && p->ppid != it->filter->pid)
-				continue;
-			return 0;
-		}
-		else if (it->filter->pid == 0)
-		{
-			kproc2proc(it->kd, kproc, p);
-			it->i++;
-			return 0;
-		}
-	}
-	return -1;
-}
-
-int close_process_iterator(struct process_iterator *it) {
-	if (kvm_close(it->kd) == -1) {
-		fprintf(stderr, "kvm_getprocs: %s\n", kvm_geterr(it->kd));
-		return -1;
-	}
-	return 0;
-}
-
diff --git a/Utilities/Tools/cpulimit/process_iterator_linux.c b/Utilities/Tools/cpulimit/process_iterator_linux.c
deleted file mode 100644
index d8d2cab3571da..0000000000000
--- a/Utilities/Tools/cpulimit/process_iterator_linux.c
+++ /dev/null
@@ -1,198 +0,0 @@
-/**
- *
- * cpulimit - a CPU limiter for Linux
- *
- * Copyright (C) 2005-2012, by:  Angelo Marletta <angelo dot marletta at gmail dot com> 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#include <sys/vfs.h>
-
-static int get_boot_time()
-{
-	int uptime = 0;
-	FILE *fp = fopen ("/proc/uptime", "r");
-	if (fp != NULL)
-	{
-		char buf[BUFSIZ];
-		char *b = fgets(buf, BUFSIZ, fp);
-		if (b == buf)
-		{
-			char *end_ptr;
-			double upsecs = strtod(buf, &end_ptr);
-			uptime = (int)upsecs;
-		}
-		fclose (fp);
-	}
-	time_t now = time(NULL);
-	return now - uptime;
-}
-
-static int check_proc()
-{
-	struct statfs mnt;
-	if (statfs("/proc", &mnt) < 0) {
-		return 0;
-	}
-	if (mnt.f_type!=0x9fa0) {
-		return 0;
-	}
-	return 1;
-}
-
-int init_process_iterator(struct process_iterator *it, struct process_filter *filter)
-{
-	if (!check_proc()) {
-		fprintf(stderr, "procfs is not mounted!\nAborting\n");
-		exit(-2);
-	}
-	//open a directory stream to /proc directory
-	if ((it->dip = opendir("/proc")) == NULL)
-	{
-		perror("opendir");
-		return -1;
-	}
-	it->filter = filter;
-	it->boot_time = get_boot_time();
-	return 0;
-}
-
-static int read_process_info(pid_t pid, struct process *p)
-{
-	static char buffer[1024];
-	static char statfile[32];
-	static char exefile[1024];
-	p->pid = pid;
-	//read stat file
-	sprintf(statfile, "/proc/%d/stat", p->pid);
-	FILE *fd = fopen(statfile, "r");
-	if (fd==NULL) {
-		return -1;
-	}
-	if (fgets(buffer, sizeof(buffer), fd)==NULL) {
-		fclose(fd);
-		return -1;
-	}
-	fclose(fd);
-	char *token = strtok(buffer, " ");
-	int i;
-	for (i=0; i<3; i++) {
-		token = strtok(NULL, " ");
-	}
-	p->ppid = atoi(token);
-	for (i=0; i<10; i++) {
-		token = strtok(NULL, " ");
-	}
-	p->cputime = atoi(token) * 1000 / HZ;
-	token = strtok(NULL, " ");
-	p->cputime += atoi(token) * 1000 / HZ;
-	for (i=0; i<7; i++) {
-		token = strtok(NULL, " ");
-	}
-	p->starttime = atoi(token) / sysconf(_SC_CLK_TCK);
-	//read command line
-	sprintf(exefile,"/proc/%d/cmdline", p->pid);
-	fd = fopen(exefile, "r");
-	if (fgets(buffer, sizeof(buffer), fd)==NULL) {
-		fclose(fd);
-		return -1;
-	}
-	fclose(fd);
-	strcpy(p->command, buffer);
-	return 0;
-}
-
-static pid_t getppid_of(pid_t pid)
-{
-	char statfile[20];
-	char buffer[1024];
-	sprintf(statfile, "/proc/%d/stat", pid);
-	FILE *fd = fopen(statfile, "r");
-	if (fd==NULL) {
-		return -1;
-	}
-	if (fgets(buffer, sizeof(buffer), fd)==NULL) {
-		fclose(fd);
-		return -1;
-	}
-	fclose(fd);
-	char *token = strtok(buffer, " ");
-	int i;
-	for (i=0; i<3; i++) {
-		token = strtok(NULL, " ");
-	}
-	return atoi(token);
-}
-
-static int is_child_of(pid_t child_pid, pid_t parent_pid)
-{
-	int ppid = child_pid;
-	while(ppid > 1 && ppid != parent_pid) {
-		ppid = getppid_of(ppid);
-	}
-	return ppid == parent_pid;
-}
-
-int get_next_process(struct process_iterator *it, struct process *p)
-{
-	if (it->dip == NULL)
-	{
-		//end of processes
-		return -1;
-	}
-	if (it->filter->pid != 0 && !it->filter->include_children)
-	{
-		int ret = read_process_info(it->filter->pid, p);
-		//p->starttime += it->boot_time;
-		closedir(it->dip);
-		it->dip = NULL;
-		if (ret != 0) {
-			return -1;
-		}
-		return 0;
-	}
-	struct dirent *dit = NULL;
-	//read in from /proc and seek for process dirs
-	while ((dit = readdir(it->dip)) != NULL) {
-		if(strtok(dit->d_name, "0123456789") != NULL) {
-			continue;
-		}
-		p->pid = atoi(dit->d_name);
-		if (it->filter->pid != 0 && it->filter->pid != p->pid && !is_child_of(p->pid, it->filter->pid)) {
-			continue;
-		}
-		read_process_info(p->pid, p);
-		//p->starttime += it->boot_time;
-		break;
-	}
-	if (dit == NULL)
-	{
-		//end of processes
-		closedir(it->dip);
-		it->dip = NULL;
-		return -1;
-	}
-	return 0;
-}
-
-int close_process_iterator(struct process_iterator *it) {
-	if (it->dip != NULL && closedir(it->dip) == -1) {
-		perror("closedir");
-		return 1;
-	}
-	it->dip = NULL;
-	return 0;
-}
diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index e89d8ee09dee9..8496a31d577bc 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -29,7 +29,7 @@ fi
 
 # include jobutils, which notably brings
 # --> the taskwrapper as a simple control and monitoring tool
-#     (look inside the jobutils.sh file for documentation)
+#     (look inside the jobutils2.sh file for documentation)
 # --> utilities to query CPU count
 . ${O2_ROOT}/share/scripts/jobutils2.sh
 
diff --git a/prodtests/full_system_test_ci_extra_tests.sh b/prodtests/full_system_test_ci_extra_tests.sh
index 2d8a165f647fd..d0c4f23ef93c6 100755
--- a/prodtests/full_system_test_ci_extra_tests.sh
+++ b/prodtests/full_system_test_ci_extra_tests.sh
@@ -3,7 +3,7 @@
 # Set of extra tests which may run after the full_system_test.sh
 # Particularly, they use the files generated by the full_system_test.sh
 #
-. ${O2_ROOT}/share/scripts/jobutils.sh
+. ${O2_ROOT}/share/scripts/jobutils2.sh
 
 if [ "0$O2_ROOT" == "0" ]; then
   eval "`alienv shell-helper`"
diff --git a/prodtests/full_system_test_pipeline.sh b/prodtests/full_system_test_pipeline.sh
index 235a590953d8e..bb29ea263dae0 100755
--- a/prodtests/full_system_test_pipeline.sh
+++ b/prodtests/full_system_test_pipeline.sh
@@ -14,9 +14,9 @@
 
 # include jobutils, which notably brings
 # --> the taskwrapper as a simple control and monitoring tool
-#     (look inside the jobutils.sh file for documentation)
+#     (look inside the jobutils2.sh file for documentation)
 # --> utilities to query CPU count
-. ${O2_ROOT}/share/scripts/jobutils.sh
+. ${O2_ROOT}/share/scripts/jobutils2.sh
 
 export NEvents=${NEvents:-10} #550 for full TF (the number of PbPb events)
 export NEventsQED=${NEventsQED:-1000} #35000 for full TF
diff --git a/prodtests/sim_challenge.sh b/prodtests/sim_challenge.sh
index f5bbf8ab74ff8..a7c7e7f7993d7 100755
--- a/prodtests/sim_challenge.sh
+++ b/prodtests/sim_challenge.sh
@@ -8,7 +8,7 @@
 # and it is advised to use that one. Some documentation can be found here: https://aliceo2group.github.io/simulation/docs/o2dpgworkflow/
 
 # ------------ LOAD UTILITY FUNCTIONS ----------------------------
-. ${O2_ROOT}/share/scripts/jobutils.sh
+. ${O2_ROOT}/share/scripts/jobutils2.sh
 # ----------- START WITH ACTUAL SCRIPT ---------------------------
 
 
diff --git a/run/SimExamples/SimAsService_biasing1/run.sh b/run/SimExamples/SimAsService_biasing1/run.sh
index 3bf8f51890fec..e038541ff6035 100755
--- a/run/SimExamples/SimAsService_biasing1/run.sh
+++ b/run/SimExamples/SimAsService_biasing1/run.sh
@@ -83,11 +83,11 @@ o2-sim-client.py --pid ${SERVICE2_PID} --command "--stop 1"
 sleep 1
 
 # just some tmp safety-net to make sure all processes are really gone
-. ${O2_ROOT}/share/scripts/jobutils.sh
+. ${O2_ROOT}/share/scripts/jobutils2.sh
 for p in $(childprocs ${SERVICE1_PID}); do
   kill -9 ${p}
 done
-. ${O2_ROOT}/share/scripts/jobutils.sh
+. ${O2_ROOT}/share/scripts/jobutils2.sh
 for p in $(childprocs ${SERVICE2_PID}); do
   kill -9 ${p}
 done

From a105f1ea0a7e8b336921abf0adaa46243690ea9e Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 20 Apr 2026 12:21:10 +0200
Subject: [PATCH 1553/1764] DPL Analysis: return span directly if the CCDB
 column is declared as a span (#15275)

---
 Framework/Core/include/Framework/ASoA.h | 78 +++++++++++++------------
 1 file changed, 41 insertions(+), 37 deletions(-)

diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 7a3307ae1a58c..96a4fe08cdd61 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -2452,43 +2452,47 @@ consteval static std::string_view namespace_prefix()
   };                                                                                                                                                                              \
   [[maybe_unused]] static constexpr o2::framework::expressions::BindingNode _Getter_ { _Label_, _Name_::hash, o2::framework::expressions::selectArrowType<_Type_>() }
 
-#define DECLARE_SOA_CCDB_COLUMN_FULL(_Name_, _Label_, _Getter_, _ConcreteType_, _CCDBQuery_)                    \
-  struct _Name_ : o2::soa::Column<std::span<std::byte>, _Name_> {                                               \
-    static constexpr const char* mLabel = _Label_;                                                              \
-    static constexpr const char* query = _CCDBQuery_;                                                           \
-    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_});      \
-    using base = o2::soa::Column<std::span<std::byte>, _Name_>;                                                 \
-    using type = std::span<std::byte>;                                                                          \
-    using column_t = _Name_;                                                                                    \
-    _Name_(arrow::ChunkedArray const* column)                                                                   \
-      : o2::soa::Column<std::span<std::byte>, _Name_>(o2::soa::ColumnIterator<std::span<std::byte>>(column))    \
-    {                                                                                                           \
-    }                                                                                                           \
-                                                                                                                \
-    _Name_() = default;                                                                                         \
-    _Name_(_Name_ const& other) = default;                                                                      \
-    _Name_& operator=(_Name_ const& other) = default;                                                           \
-                                                                                                                \
-    decltype(auto) _Getter_() const                                                                             \
-    {                                                                                                           \
-      static std::byte* payload = nullptr;                                                                      \
-      static _ConcreteType_* deserialised = nullptr;                                                            \
-      static TClass* c = TClass::GetClass(#_ConcreteType_);                                                     \
-      auto span = *mColumnIterator;                                                                             \
-      if (payload != (std::byte*)span.data()) {                                                                 \
-        payload = (std::byte*)span.data();                                                                      \
-        delete deserialised;                                                                                    \
-        TBufferFile f(TBufferFile::EMode::kRead, span.size(), (char*)span.data(), kFALSE);                      \
-        deserialised = (_ConcreteType_*)soa::extractCCDBPayload((char*)payload, span.size(), c, "ccdb_object"); \
-      }                                                                                                         \
-      return *deserialised;                                                                                     \
-    }                                                                                                           \
-                                                                                                                \
-    decltype(auto)                                                                                              \
-      get() const                                                                                               \
-    {                                                                                                           \
-      return _Getter_();                                                                                        \
-    }                                                                                                           \
+#define DECLARE_SOA_CCDB_COLUMN_FULL(_Name_, _Label_, _Getter_, _ConcreteType_, _CCDBQuery_)                      \
+  struct _Name_ : o2::soa::Column<std::span<std::byte>, _Name_> {                                                 \
+    static constexpr const char* mLabel = _Label_;                                                                \
+    static constexpr const char* query = _CCDBQuery_;                                                             \
+    static constexpr const uint32_t hash = crc32(namespace_prefix<_Name_>(), std::string_view{#_Getter_});        \
+    using base = o2::soa::Column<std::span<std::byte>, _Name_>;                                                   \
+    using type = std::span<std::byte>;                                                                            \
+    using column_t = _Name_;                                                                                      \
+    _Name_(arrow::ChunkedArray const* column)                                                                     \
+      : o2::soa::Column<std::span<std::byte>, _Name_>(o2::soa::ColumnIterator<std::span<std::byte>>(column))      \
+    {                                                                                                             \
+    }                                                                                                             \
+                                                                                                                  \
+    _Name_() = default;                                                                                           \
+    _Name_(_Name_ const& other) = default;                                                                        \
+    _Name_& operator=(_Name_ const& other) = default;                                                             \
+                                                                                                                  \
+    decltype(auto) _Getter_() const                                                                               \
+    {                                                                                                             \
+      if constexpr (std::same_as<_ConcreteType_, std::span<std::byte>>) {                                         \
+        return *mColumnIterator;                                                                                  \
+      } else {                                                                                                    \
+        static std::byte* payload = nullptr;                                                                      \
+        static _ConcreteType_* deserialised = nullptr;                                                            \
+        static TClass* c = TClass::GetClass(#_ConcreteType_);                                                     \
+        auto span = *mColumnIterator;                                                                             \
+        if (payload != (std::byte*)span.data()) {                                                                 \
+          payload = (std::byte*)span.data();                                                                      \
+          delete deserialised;                                                                                    \
+          TBufferFile f(TBufferFile::EMode::kRead, span.size(), (char*)span.data(), kFALSE);                      \
+          deserialised = (_ConcreteType_*)soa::extractCCDBPayload((char*)payload, span.size(), c, "ccdb_object"); \
+        }                                                                                                         \
+        return *deserialised;                                                                                     \
+      }                                                                                                           \
+    }                                                                                                             \
+                                                                                                                  \
+    decltype(auto)                                                                                                \
+      get() const                                                                                                 \
+    {                                                                                                             \
+      return _Getter_();                                                                                          \
+    }                                                                                                             \
   };
 
 #define DECLARE_SOA_CCDB_COLUMN(_Name_, _Getter_, _ConcreteType_, _CCDBQuery_) \

From ded827ee065090f35bdeb91e2e0195b9b8d880ef Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 20 Apr 2026 14:30:43 +0200
Subject: [PATCH 1554/1764] ITS: restore previous UPC iteration (#15289)

* ITS: fix upc iteration

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: simplify configurables to single one for Vertexer

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: make MaxIter a constant

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: remove GPU params

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TrackingKernels.h      | 24 +-----
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     |  3 +-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 32 +-------
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 74 +++++--------------
 .../include/ITStracking/Configuration.h       |  6 +-
 .../tracking/include/ITStracking/Constants.h  |  9 ++-
 .../include/ITStracking/TrackingConfigParam.h | 67 ++++-------------
 .../tracking/include/ITStracking/Vertexer.h   |  2 +-
 .../include/ITStracking/VertexerTraits.h      |  2 +
 .../ITSMFT/ITS/tracking/src/Configuration.cxx | 67 +++++++++--------
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  7 --
 .../ITS/tracking/src/TrackingConfigParam.cxx  | 32 +-------
 .../ITS/tracking/src/TrackingInterface.cxx    |  4 -
 .../ITSMFT/ITS/tracking/src/TrackingLinkDef.h |  3 -
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      | 16 ++--
 .../ITS/tracking/src/VertexerTraits.cxx       | 38 ++++++----
 GPU/Workflow/src/GPUWorkflowITS.cxx           |  1 -
 prodtests/full-system-test/dpl-workflow.sh    |  2 +-
 18 files changed, 118 insertions(+), 271 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index a83d9d0d52e8f..6a977f8fef21a 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -60,8 +60,6 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  std::vector<float>& radii,
                                  bounded_vector<float>& mulScatAng,
                                  o2::its::ExternalAllocator* alloc,
-                                 const int nBlocks,
-                                 const int nThreads,
                                  gpu::Streams& streams);
 
 template <int NLayers = 7>
@@ -93,8 +91,6 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    std::vector<float>& radii,
                                    bounded_vector<float>& mulScatAng,
                                    o2::its::ExternalAllocator* alloc,
-                                   const int nBlocks,
-                                   const int nThreads,
                                    gpu::Streams& streams);
 
 template <int NLayers>
@@ -113,8 +109,6 @@ void countCellsHandler(const Cluster** sortedClusters,
                        const float cellDeltaTanLambdaSigma,
                        const float nSigmaCut,
                        o2::its::ExternalAllocator* alloc,
-                       const int nBlocks,
-                       const int nThreads,
                        gpu::Streams& streams);
 
 template <int NLayers>
@@ -132,8 +126,6 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          const float maxChi2ClusterAttachment,
                          const float cellDeltaTanLambdaSigma,
                          const float nSigmaCut,
-                         const int nBlocks,
-                         const int nThreads,
                          gpu::Streams& streams);
 
 template <int NLayers>
@@ -150,8 +142,6 @@ void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                 const unsigned int nCellsNext,
                                 const int maxCellNeighbours,
                                 o2::its::ExternalAllocator* alloc,
-                                const int nBlocks,
-                                const int nThreads,
                                 gpu::Stream& stream);
 
 template <int NLayers>
@@ -167,8 +157,6 @@ void computeCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                   const unsigned int nCells,
                                   const unsigned int nCellsNext,
                                   const int maxCellNeighbours,
-                                  const int nBlocks,
-                                  const int nThreads,
                                   gpu::Stream& stream);
 
 int filterCellNeighboursHandler(gpuPair<int, int>*,
@@ -193,9 +181,7 @@ void processNeighboursHandler(const int startLayer,
                               const float maxChi2NDF,
                               const o2::base::Propagator* propagator,
                               const o2::base::PropagatorF::MatCorrType matCorrType,
-                              o2::its::ExternalAllocator* alloc,
-                              const int nBlocks,
-                              const int nThreads);
+                              o2::its::ExternalAllocator* alloc);
 
 template <int NLayers = 7>
 void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
@@ -214,9 +200,7 @@ void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                            const bool shiftRefToCluster,
                            const o2::base::Propagator* propagator,
                            const o2::base::PropagatorF::MatCorrType matCorrType,
-                           o2::its::ExternalAllocator* alloc,
-                           const int nBlocks,
-                           const int nThreads);
+                           o2::its::ExternalAllocator* alloc);
 
 template <int NLayers = 7>
 void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
@@ -237,9 +221,7 @@ void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                              const bool shiftRefToCluster,
                              const o2::base::Propagator* propagator,
                              const o2::base::PropagatorF::MatCorrType matCorrType,
-                             o2::its::ExternalAllocator* alloc,
-                             const int nBlocks,
-                             const int nThreads);
+                             o2::its::ExternalAllocator* alloc);
 
 } // namespace o2::its
 #endif // ITSTRACKINGGPU_TRACKINGKERNELS_H_
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index a9b51580f9be7..bd5e7a8bc59f8 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -627,8 +627,7 @@ constexpr auto makeIterTags(std::index_sequence<I...>)
 {
   return std::array<uint64_t, sizeof...(I)>{makeIterTag<I>()...};
 }
-// FIXME: we have to be careful that the MaxIter does not diverge from the 4 here!
-constexpr auto kIterTags = makeIterTags(std::make_index_sequence<4>{});
+constexpr auto kIterTags = makeIterTags(std::make_index_sequence<constants::MaxIter>{});
 } // namespace detail
 
 template <int NLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 3de2871dd458e..f7a416808fec7 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -18,7 +18,6 @@
 
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
 #include "ITStrackingGPU/TrackingKernels.h"
-#include "ITStracking/TrackingConfigParam.h"
 #include "ITStracking/Constants.h"
 
 namespace o2::its
@@ -63,8 +62,6 @@ void TrackerTraitsGPU<NLayers>::adoptTimeFrame(TimeFrame<NLayers>* tf)
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int iVertex)
 {
-  const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
-
   // start by queuing loading needed of two last layers
   for (int iLayer{NLayers}; iLayer-- > NLayers - 2;) {
     mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer);
@@ -109,8 +106,6 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
                                          this->mTrkParams[iteration].LayerRadii,
                                          mTimeFrameGPU->getMSangles(),
                                          mTimeFrameGPU->getFrameworkAllocator(),
-                                         conf.nBlocksLayerTracklets[iteration],
-                                         conf.nThreadsLayerTracklets[iteration],
                                          mTimeFrameGPU->getStreams());
     mTimeFrameGPU->createTrackletsBuffers(iLayer);
     if (mTimeFrameGPU->getNTracklets()[iLayer] == 0) {
@@ -144,8 +139,6 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
                                            this->mTrkParams[iteration].LayerRadii,
                                            mTimeFrameGPU->getMSangles(),
                                            mTimeFrameGPU->getFrameworkAllocator(),
-                                           conf.nBlocksLayerTracklets[iteration],
-                                           conf.nThreadsLayerTracklets[iteration],
                                            mTimeFrameGPU->getStreams());
   }
 }
@@ -153,8 +146,6 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
 {
-  auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
-
   // start by queuing loading needed of three last layers
   for (int iLayer{NLayers}; iLayer-- > NLayers - 3;) {
     mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer);
@@ -194,8 +185,6 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
                                this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                                this->mTrkParams[iteration].NSigmaCut,
                                mTimeFrameGPU->getFrameworkAllocator(),
-                               conf.nBlocksLayerCells[iteration],
-                               conf.nThreadsLayerCells[iteration],
                                mTimeFrameGPU->getStreams());
     mTimeFrameGPU->createCellsBuffers(iLayer);
     if (mTimeFrameGPU->getNCells()[iLayer] == 0) {
@@ -215,8 +204,6 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
                                  this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                  this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                                  this->mTrkParams[iteration].NSigmaCut,
-                                 conf.nBlocksLayerCells[iteration],
-                                 conf.nThreadsLayerCells[iteration],
                                  mTimeFrameGPU->getStreams());
   }
 }
@@ -224,8 +211,6 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
 {
-  const auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
-
   for (int iLayer{0}; iLayer < this->mTrkParams[iteration].NeighboursPerRoad(); ++iLayer) {
     const int currentLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer])};
     const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};
@@ -248,8 +233,6 @@ void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
                                         nextLayerCellsNum,
                                         1e2,
                                         mTimeFrameGPU->getFrameworkAllocator(),
-                                        conf.nBlocksFindNeighbours[iteration],
-                                        conf.nThreadsFindNeighbours[iteration],
                                         mTimeFrameGPU->getStream(iLayer));
     mTimeFrameGPU->createNeighboursDevice(iLayer);
     if (mTimeFrameGPU->getNNeighbours()[iLayer] == 0) {
@@ -267,8 +250,6 @@ void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
                                           currentLayerCellsNum,
                                           nextLayerCellsNum,
                                           1e2,
-                                          conf.nBlocksFindNeighbours[iteration],
-                                          conf.nThreadsFindNeighbours[iteration],
                                           mTimeFrameGPU->getStream(iLayer));
     mTimeFrameGPU->getArrayNNeighbours()[iLayer] = filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
                                                                                mTimeFrameGPU->getDeviceNeighbours(iLayer),
@@ -282,7 +263,6 @@ void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
 {
-  auto& conf = o2::its::ITSGpuTrackingParamConfig::Instance();
   for (int startLevel{this->mTrkParams[iteration].CellsPerRoad()}; startLevel >= this->mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     const int minimumLayer{startLevel - 1};
     bounded_vector<CellSeed<NLayers>> trackSeeds(this->getMemoryPool().get());
@@ -305,9 +285,7 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
                                         this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
                                         this->mTrkParams[0].CorrType,
-                                        mTimeFrameGPU->getFrameworkAllocator(),
-                                        conf.nBlocksProcessNeighbours[iteration],
-                                        conf.nThreadsProcessNeighbours[iteration]);
+                                        mTimeFrameGPU->getFrameworkAllocator());
     }
     // fixme: I don't want to move tracks back and forth, but I need a way to use a thrust::allocator that is aware of our managed memory.
     if (trackSeeds.empty()) {
@@ -334,9 +312,7 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
                           this->mTrkParams[0].ShiftRefToCluster,
                           mTimeFrameGPU->getDevicePropagator(),
                           this->mTrkParams[0].CorrType,
-                          mTimeFrameGPU->getFrameworkAllocator(),
-                          conf.nBlocksTracksSeeds[iteration],
-                          conf.nThreadsTracksSeeds[iteration]);
+                          mTimeFrameGPU->getFrameworkAllocator());
     mTimeFrameGPU->createTrackITSExtDevice(trackSeeds.size());
     computeTrackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),
                             mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
@@ -356,9 +332,7 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
                             this->mTrkParams[0].ShiftRefToCluster,
                             mTimeFrameGPU->getDevicePropagator(),
                             this->mTrkParams[0].CorrType,
-                            mTimeFrameGPU->getFrameworkAllocator(),
-                            conf.nBlocksTracksSeeds[iteration],
-                            conf.nThreadsTracksSeeds[iteration]);
+                            mTimeFrameGPU->getFrameworkAllocator());
     mTimeFrameGPU->downloadTrackITSExtDevice();
 
     auto& tracks = mTimeFrameGPU->getTrackITSExt();
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 795b568f6174d..54f92411a3df1 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -813,11 +813,9 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  std::vector<float>& radii,
                                  bounded_vector<float>& mulScatAng,
                                  o2::its::ExternalAllocator* alloc,
-                                 const int nBlocks,
-                                 const int nThreads,
                                  gpu::Streams& streams)
 {
-  gpu::computeLayerTrackletsMultiROFKernel<true><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
+  gpu::computeLayerTrackletsMultiROFKernel<true><<<60, 256, 0, streams[layer].get()>>>(
     utils,
     rofMask,
     layer,
@@ -874,11 +872,9 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    std::vector<float>& radii,
                                    bounded_vector<float>& mulScatAng,
                                    o2::its::ExternalAllocator* alloc,
-                                   const int nBlocks,
-                                   const int nThreads,
                                    gpu::Streams& streams)
 {
-  gpu::computeLayerTrackletsMultiROFKernel<false><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
+  gpu::computeLayerTrackletsMultiROFKernel<false><<<60, 256, 0, streams[layer].get()>>>(
     utils,
     rofMask,
     layer,
@@ -909,7 +905,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
   nTracklets[layer] = unique_end - tracklets_ptr;
   if (layer) {
     GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[layer], 0, (nClusters[layer] + 1) * sizeof(int), streams[layer].get()));
-    gpu::compileTrackletsLookupTableKernel<<<nBlocks, nThreads, 0, streams[layer].get()>>>(
+    gpu::compileTrackletsLookupTableKernel<<<60, 256, 0, streams[layer].get()>>>(
       spanTracklets[layer],
       trackletsLUTsHost[layer],
       nTracklets[layer]);
@@ -934,11 +930,9 @@ void countCellsHandler(
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut,
   o2::its::ExternalAllocator* alloc,
-  const int nBlocks,
-  const int nThreads,
   gpu::Streams& streams)
 {
-  gpu::computeLayerCellsKernel<true><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
+  gpu::computeLayerCellsKernel<true><<<60, 256, 0, streams[layer].get()>>>(
     sortedClusters,           // const Cluster**
     unsortedClusters,         // const Cluster**
     tfInfo,                   // const TrackingFrameInfo**
@@ -972,11 +966,9 @@ void computeCellsHandler(
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut,
-  const int nBlocks,
-  const int nThreads,
   gpu::Streams& streams)
 {
-  gpu::computeLayerCellsKernel<false><<<nBlocks, nThreads, 0, streams[layer].get()>>>(
+  gpu::computeLayerCellsKernel<false><<<60, 256, 0, streams[layer].get()>>>(
     sortedClusters,           // const Cluster**
     unsortedClusters,         // const Cluster**
     tfInfo,                   // const TrackingFrameInfo**
@@ -1006,11 +998,9 @@ void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                 const unsigned int nCellsNext,
                                 const int maxCellNeighbours,
                                 o2::its::ExternalAllocator* alloc,
-                                const int nBlocks,
-                                const int nThreads,
                                 gpu::Stream& stream)
 {
-  gpu::computeLayerCellNeighboursKernel<true><<<nBlocks, nThreads, 0, stream.get()>>>(
+  gpu::computeLayerCellNeighboursKernel<true><<<60, 256, 0, stream.get()>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1040,11 +1030,9 @@ void computeCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                   const unsigned int nCells,
                                   const unsigned int nCellsNext,
                                   const int maxCellNeighbours,
-                                  const int nBlocks,
-                                  const int nThreads,
                                   gpu::Stream& stream)
 {
-  gpu::computeLayerCellNeighboursKernel<false><<<nBlocks, nThreads, 0, stream.get()>>>(
+  gpu::computeLayerCellNeighboursKernel<false><<<60, 256, 0, stream.get()>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1090,9 +1078,7 @@ void processNeighboursHandler(const int startLayer,
                               const float maxChi2NDF,
                               const o2::base::Propagator* propagator,
                               const o2::base::PropagatorF::MatCorrType matCorrType,
-                              o2::its::ExternalAllocator* alloc,
-                              const int nBlocks,
-                              const int nThreads)
+                              o2::its::ExternalAllocator* alloc)
 {
   constexpr uint64_t Tag = qStr2Tag("ITS_PNH1");
   alloc->pushTagOnStack(Tag);
@@ -1101,7 +1087,7 @@ void processNeighboursHandler(const int startLayer,
   thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
   auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(gpu::Stream::DefaultStream);
 
-  gpu::processNeighboursKernel<true, NLayers><<<nBlocks, nThreads>>>(
+  gpu::processNeighboursKernel<true, NLayers><<<60, 256>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1123,7 +1109,7 @@ void processNeighboursHandler(const int startLayer,
 
   thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
   thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
-  gpu::processNeighboursKernel<false, NLayers><<<nBlocks, nThreads>>>(
+  gpu::processNeighboursKernel<false, NLayers><<<60, 256>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1155,7 +1141,7 @@ void processNeighboursHandler(const int startLayer,
     foundSeedsTable.resize(lastCellSeedSize + 1);
     thrust::fill(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
-    gpu::processNeighboursKernel<true, NLayers><<<nBlocks, nThreads>>>(
+    gpu::processNeighboursKernel<true, NLayers><<<60, 256>>>(
       iLayer,
       --level,
       allCellSeeds,
@@ -1181,7 +1167,7 @@ void processNeighboursHandler(const int startLayer,
     updatedCellSeed.resize(foundSeeds);
     thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed<NLayers>());
 
-    gpu::processNeighboursKernel<false, NLayers><<<nBlocks, nThreads>>>(
+    gpu::processNeighboursKernel<false, NLayers><<<60, 256>>>(
       iLayer,
       level,
       allCellSeeds,
@@ -1226,16 +1212,14 @@ void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                            const bool shiftRefToCluster,
                            const o2::base::Propagator* propagator,
                            const o2::base::PropagatorF::MatCorrType matCorrType,
-                           o2::its::ExternalAllocator* alloc,
-                           const int nBlocks,
-                           const int nThreads)
+                           o2::its::ExternalAllocator* alloc)
 {
   // TODO: the minPts&layerRadii is transfered twice
   // we should allocate this in constant memory and stop these
   // small transferes!
   thrust::device_vector<float> minPts(minPtsHost);
   thrust::device_vector<float> layerRadii(layerRadiiHost);
-  gpu::fitTrackSeedsKernel<true, NLayers><<<nBlocks, nThreads>>>(
+  gpu::fitTrackSeedsKernel<true, NLayers><<<60, 256>>>(
     trackSeeds,                               // CellSeed*
     foundTrackingFrameInfo,                   // TrackingFrameInfo**
     unsortedClusters,                         // Cluster**
@@ -1276,13 +1260,11 @@ void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                              const bool shiftRefToCluster,
                              const o2::base::Propagator* propagator,
                              const o2::base::PropagatorF::MatCorrType matCorrType,
-                             o2::its::ExternalAllocator* alloc,
-                             const int nBlocks,
-                             const int nThreads)
+                             o2::its::ExternalAllocator* alloc)
 {
   thrust::device_vector<float> minPts(minPtsHost);
   thrust::device_vector<float> layerRadii(layerRadiiHost);
-  gpu::fitTrackSeedsKernel<false, NLayers><<<nBlocks, nThreads>>>(
+  gpu::fitTrackSeedsKernel<false, NLayers><<<60, 256>>>(
     trackSeeds,                               // CellSeed*
     foundTrackingFrameInfo,                   // TrackingFrameInfo**
     unsortedClusters,                         // Cluster**
@@ -1331,8 +1313,6 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                              std::vector<float>& radii,
                                              bounded_vector<float>& mulScatAng,
                                              o2::its::ExternalAllocator* alloc,
-                                             const int nBlocks,
-                                             const int nThreads,
                                              gpu::Streams& streams);
 
 template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
@@ -1363,8 +1343,6 @@ template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                                std::vector<float>& radii,
                                                bounded_vector<float>& mulScatAng,
                                                o2::its::ExternalAllocator* alloc,
-                                               const int nBlocks,
-                                               const int nThreads,
                                                gpu::Streams& streams);
 
 template void countCellsHandler<7>(const Cluster** sortedClusters,
@@ -1382,8 +1360,6 @@ template void countCellsHandler<7>(const Cluster** sortedClusters,
                                    const float cellDeltaTanLambdaSigma,
                                    const float nSigmaCut,
                                    o2::its::ExternalAllocator* alloc,
-                                   const int nBlocks,
-                                   const int nThreads,
                                    gpu::Streams& streams);
 
 template void computeCellsHandler<7>(const Cluster** sortedClusters,
@@ -1400,8 +1376,6 @@ template void computeCellsHandler<7>(const Cluster** sortedClusters,
                                      const float maxChi2ClusterAttachment,
                                      const float cellDeltaTanLambdaSigma,
                                      const float nSigmaCut,
-                                     const int nBlocks,
-                                     const int nThreads,
                                      gpu::Streams& streams);
 
 template void countCellNeighboursHandler<7>(CellSeed<7>** cellsLayersDevice,
@@ -1417,8 +1391,6 @@ template void countCellNeighboursHandler<7>(CellSeed<7>** cellsLayersDevice,
                                             const unsigned int nCellsNext,
                                             const int maxCellNeighbours,
                                             o2::its::ExternalAllocator* alloc,
-                                            const int nBlocks,
-                                            const int nThreads,
                                             gpu::Stream& stream);
 
 template void computeCellNeighboursHandler(CellSeed<7>** cellsLayersDevice,
@@ -1433,8 +1405,6 @@ template void computeCellNeighboursHandler(CellSeed<7>** cellsLayersDevice,
                                            const unsigned int nCells,
                                            const unsigned int nCellsNext,
                                            const int maxCellNeighbours,
-                                           const int nBlocks,
-                                           const int nThreads,
                                            gpu::Stream& stream);
 
 template void processNeighboursHandler<7>(const int startLayer,
@@ -1452,9 +1422,7 @@ template void processNeighboursHandler<7>(const int startLayer,
                                           const float maxChi2NDF,
                                           const o2::base::Propagator* propagator,
                                           const o2::base::PropagatorF::MatCorrType matCorrType,
-                                          o2::its::ExternalAllocator* alloc,
-                                          const int nBlocks,
-                                          const int nThreads);
+                                          o2::its::ExternalAllocator* alloc);
 
 template void countTrackSeedHandler(CellSeed<7>* trackSeeds,
                                     const TrackingFrameInfo** foundTrackingFrameInfo,
@@ -1472,9 +1440,7 @@ template void countTrackSeedHandler(CellSeed<7>* trackSeeds,
                                     const bool shiftRefToCluster,
                                     const o2::base::Propagator* propagator,
                                     const o2::base::PropagatorF::MatCorrType matCorrType,
-                                    o2::its::ExternalAllocator* alloc,
-                                    const int nBlocks,
-                                    const int nThreads);
+                                    o2::its::ExternalAllocator* alloc);
 
 template void computeTrackSeedHandler(CellSeed<7>* trackSeeds,
                                       const TrackingFrameInfo** foundTrackingFrameInfo,
@@ -1494,8 +1460,6 @@ template void computeTrackSeedHandler(CellSeed<7>* trackSeeds,
                                       const bool shiftRefToCluster,
                                       const o2::base::Propagator* propagator,
                                       const o2::base::PropagatorF::MatCorrType matCorrType,
-                                      o2::its::ExternalAllocator* alloc,
-                                      const int nBlocks,
-                                      const int nThreads);
+                                      o2::its::ExternalAllocator* alloc);
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 1f55a95ca0d65..dbce5e0dc08a7 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -84,9 +84,9 @@ struct TrackingParameters {
 struct VertexingParameters {
   std::string asString() const;
 
-  int nIterations = 1; // Number of vertexing passes to perform
   std::vector<float> LayerZ = {16.333f + 1, 16.333f + 1, 16.333f + 1, 42.140f + 1, 42.140f + 1, 73.745f + 1, 73.745f + 1};
   std::vector<float> LayerRadii = {2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f};
+  int vertPerRofThreshold = 0; // Maximum number of vertices per ROF to trigger second a round
   int ZBins = 1;
   int PhiBins = 128;
   float zCut = -1.f;
@@ -100,9 +100,7 @@ struct VertexingParameters {
   float finalSelectionZCut = -1.f;
   float duplicateDistance2Cut = -1.f;
   float tanLambdaCut = -1.f;
-  float vertNsigmaCut = -1.f;
-  float vertRadiusSigma = -1.f;
-  float trackletSigma = -1.f;
+  float NSigmaCut = -1;
   float maxZPositionAllowed = -1.f;
   int clusterContributorsCut = -1;
   int suppressLowMultDebris = -1;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index 4b2528b62f057..f8009e3ce8008 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -31,12 +31,13 @@ constexpr float GB = MB * KB;
 constexpr bool DoTimeBenchmarks = true;
 constexpr bool SaveTimeBenchmarks = false;
 
-GPUconstexpr() float Tolerance{1e-12}; // numerical tolerance
-GPUconstexpr() int ClustersPerCell{3};
-GPUconstexpr() int UnusedIndex{-1};
-GPUconstexpr() float Resolution{0.0005f};
+GPUconstexpr() float Tolerance = 1e-12; // numerical tolerance
+GPUconstexpr() int ClustersPerCell = 3;
+GPUconstexpr() int UnusedIndex = -1;
+GPUconstexpr() float Resolution = 0.0005f;
 GPUconstexpr() float Radl = 9.36f; // Radiation length of Si [cm]
 GPUconstexpr() float Rho = 2.33f;  // Density of Si [g/cm^3]
+GPUconstexpr() int MaxIter = 4;    // Max. supported iterations
 
 namespace helpers
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 5ffd55f715a1a..acb55eb1cf993 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -15,6 +15,7 @@
 #include <limits>
 #include "CommonUtils/ConfigurableParam.h"
 #include "CommonUtils/ConfigurableParamHelper.h"
+#include "ITStracking/Constants.h"
 
 namespace o2::its
 {
@@ -36,11 +37,9 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   float duplicateZCut = 0.7985643f;
   float finalSelectionZCut = 0.2932624f;
   float duplicateDistance2Cut = 0.0223001f;
-  float tanLambdaCut = 0.002f;        // tanLambda = deltaZ/deltaR
-  float vertNsigmaCut = 5.8762583f;   // N sigma cut for vertex XY
-  float vertRadiusSigma = 0.0343575f; // sigma of vertex XY
-  float trackletSigma = 0.0143798f;   // tracklet to vertex sigma
-  float maxZPositionAllowed = 25.f;   // 4x sZ of the beam
+  float tanLambdaCut = 0.002f; // tanLambda = deltaZ/deltaR
+  float nSigmaCut = 0.0479011f;
+  float maxZPositionAllowed = 25.f; // 4x sZ of the beam
 
   // Artefacts selections
   int clusterContributorsCut = 3; // minimum number of contributors for an accepted final vertex
@@ -64,18 +63,17 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
 };
 
 struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerParamConfig> {
-  // Use TGeo for mat. budget
-  static const int MaxIter = 4;
   static const int MinTrackLength = 4;
   static const int MaxTrackLength = 7;
-  bool useMatCorrTGeo = false;                                              // use full geometry to corect for material budget accounting in the fits. Default is to use the material budget LUT.
-  bool useFastMaterial = false;                                             // use faster material approximation for material budget accounting in the fits.
-  int addTimeError[7] = {0};                                                // configure the width of the window in BC to be considered for the tracking.
-  int minTrackLgtIter[MaxIter] = {};                                        // minimum track length at each iteration, used only if >0, otherwise use code defaults
-  uint8_t startLayerMask[MaxIter] = {};                                     // mask of start layer for this iteration (if >0)
-  float minPtIterLgt[MaxIter * (MaxTrackLength - MinTrackLength + 1)] = {}; // min.pT for given track length at this iteration, used only if >0, otherwise use code defaults
-  float sysErrY2[7] = {0};                                                  // systematic error^2 in Y per layer
-  float sysErrZ2[7] = {0};                                                  // systematic error^2 in Z per layer
+
+  bool useMatCorrTGeo = false;                                                         // use full geometry to corect for material budget accounting in the fits. Default is to use the material budget LUT.
+  bool useFastMaterial = false;                                                        // use faster material approximation for material budget accounting in the fits.
+  int addTimeError[7] = {0};                                                           // configure the width of the window in BC to be considered for the tracking.
+  int minTrackLgtIter[constants::MaxIter] = {};                                        // minimum track length at each iteration, used only if >0, otherwise use code defaults
+  uint8_t startLayerMask[constants::MaxIter] = {};                                     // mask of start layer for this iteration (if >0)
+  float minPtIterLgt[constants::MaxIter * (MaxTrackLength - MinTrackLength + 1)] = {}; // min.pT for given track length at this iteration, used only if >0, otherwise use code defaults
+  float sysErrY2[7] = {0};                                                             // systematic error^2 in Y per layer
+  float sysErrZ2[7] = {0};                                                             // systematic error^2 in Z per layer
   float maxChi2ClusterAttachment = -1.f;
   float maxChi2NDF = -1.f;
   float nSigmaCut = -1.f;
@@ -91,7 +89,7 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   bool overrideBeamEstimation = false;     // use beam position from meanVertex CCDB object
   int trackingMode = -1;                   // -1: unset, 0=sync, 1=async, 2=cosmics used by gpuwf only
   bool doUPCIteration = false;             // Perform an additional iteration for UPC events on tagged vertices. You want to combine this config with VertexerParamConfig.nIterations=2
-  int nIterations = MaxIter;               // overwrite the number of iterations
+  int nIterations = constants::MaxIter;    // overwrite the number of iterations
   int reseedIfShorter = 6;                 // for the final refit reseed the track with circle if they are shorter than this value
   bool shiftRefToCluster{true};            // TrackFit: after update shift the linearization reference to cluster
   bool repeatRefitOut{false};              // repeat outward refit using inward refit as a seed
@@ -107,42 +105,5 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   O2ParamDef(TrackerParamConfig, "ITSCATrackerParam");
 };
 
-struct ITSGpuTrackingParamConfig : public o2::conf::ConfigurableParamHelper<ITSGpuTrackingParamConfig> {
-  static constexpr int MaxIter = TrackerParamConfig::MaxIter;
-
-  /// Set nBlocks/nThreads to summarily override all kernel launch parameters in each iteration.
-  /// Parameters must start with nBlocks/nThreads.
-  static constexpr int OverrideValue{-1};
-  static constexpr char const* BlocksName = "nBlocks";
-  static constexpr char const* ThreadsName = "nThreads";
-  int nBlocks = OverrideValue;
-  int nThreads = OverrideValue;
-  void maybeOverride() const;
-
-  /// Individual kernel launch parameter for each iteration
-  int nBlocksLayerTracklets[MaxIter] = {60, 60, 60, 60};
-  int nThreadsLayerTracklets[MaxIter] = {256, 256, 256, 256};
-
-  int nBlocksLayerCells[MaxIter] = {60, 60, 60, 60};
-  int nThreadsLayerCells[MaxIter] = {256, 256, 256, 256};
-
-  int nBlocksFindNeighbours[MaxIter] = {60, 60, 60, 60};
-  int nThreadsFindNeighbours[MaxIter] = {256, 256, 256, 256};
-
-  int nBlocksProcessNeighbours[MaxIter] = {60, 60, 60, 60};
-  int nThreadsProcessNeighbours[MaxIter] = {256, 256, 256, 256};
-
-  int nBlocksTracksSeeds[MaxIter] = {60, 60, 60, 60};
-  int nThreadsTracksSeeds[MaxIter] = {256, 256, 256, 256};
-
-  int nBlocksVtxComputeTracklets[2] = {60, 60};
-  int nThreadsVtxComputeTracklets[2] = {256, 256};
-
-  int nBlocksVtxComputeMatching[2] = {60, 60};
-  int nThreadsVtxComputeMatching[2] = {256, 256};
-
-  O2ParamDef(ITSGpuTrackingParamConfig, "ITSGpuTrackingParam");
-};
-
 } // namespace o2::its
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index 77218754dbda3..a045ba1639b13 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -91,7 +91,7 @@ class Vertexer
 
   void printEpilog(LogFunc& logger,
                    const unsigned int trackletN01, const unsigned int trackletN12,
-                   const unsigned selectedN, const unsigned int vertexN, const float initT,
+                   const unsigned selectedN, const unsigned int vertexN, const unsigned int totalVertexN,
                    const float trackletT, const float selecT, const float vertexT);
 
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena) { mTraits->setNThreads(n, arena); }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 5b609c2fa6c85..1adb09551e326 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -115,6 +115,8 @@ class VertexerTraits
   // Frame related quantities
   TimeFrameN* mTimeFrame = nullptr; // observer ptr
  private:
+  bool skipROF(int iteration, int rof) const;
+
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 6c88b61f2df07..49bf9b5b1887d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -136,12 +136,12 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       trackParams[3].TrackletMinPt = 0.1f;
       trackParams[3].CellDeltaTanLambdaSigma *= 4.;
     }
-    for (size_t ip = 0; ip < trackParams.size(); ip++) {
+    for (int ip = 0; ip < (int)trackParams.size(); ip++) {
       auto& param = trackParams[ip];
       param.ZBins = 64;
       param.PhiBins = 32;
       // check if something was overridden via configurable params
-      if (ip < tc.MaxIter) {
+      if (ip < constants::MaxIter) {
         if (tc.startLayerMask[ip] > 0) {
           trackParams[2].StartLayerMask = tc.startLayerMask[ip];
         }
@@ -149,7 +149,7 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
           param.MinTrackLength = tc.minTrackLgtIter[ip];
         }
         for (int ilg = tc.MaxTrackLength; ilg >= tc.MinTrackLength; ilg--) {
-          int lslot0 = (tc.MaxTrackLength - ilg), lslot = lslot0 + ip * (tc.MaxTrackLength - tc.MinTrackLength + 1);
+          int lslot0 = (tc.MaxTrackLength - ilg), lslot = lslot0 + (ip * (tc.MaxTrackLength - tc.MinTrackLength + 1));
           if (tc.minPtIterLgt[lslot] > 0.) {
             param.MinPt[lslot0] = tc.minPtIterLgt[lslot];
           }
@@ -240,27 +240,15 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
 std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMode::Type mode)
 {
   const auto& vc = o2::its::VertexerParamConfig::Instance();
-  std::vector<VertexingParameters> vertParams;
-  if (mode == TrackingMode::Async) {
-    vertParams.resize(2); // The number of actual iterations will be set as a configKeyVal to allow for pp/PbPb choice
-    vertParams[1].phiCut = 0.015f;
-    vertParams[1].tanLambdaCut = 0.015f;
-  } else if (mode == TrackingMode::Sync) {
-    vertParams.resize(1);
-  } else if (mode == TrackingMode::Cosmics) {
-    vertParams.resize(1);
-  } else {
-    LOGP(fatal, "Unsupported ITS vertexing mode {} ", toString(mode));
-  }
-
+  std::vector<VertexingParameters> vertParams(2); // The number of actual iterations will be set as a configKeyVal to allow for pp/PbPb choice
   // global parameters set for every iteration
   for (auto& p : vertParams) {
+    p.vertPerRofThreshold = vc.vertPerRofThreshold;
     p.SaveTimeBenchmarks = vc.saveTimeBenchmarks;
     p.PrintMemory = vc.printMemory;
     p.MaxMemory = vc.maxMemory;
     p.DropTFUponFailure = vc.dropTFUponFailure;
-    p.nIterations = vc.nIterations;
-    p.trackletSigma = vc.trackletSigma;
+    p.NSigmaCut = vc.nSigmaCut;
     p.maxZPositionAllowed = vc.maxZPositionAllowed;
     p.clusterContributorsCut = vc.clusterContributorsCut;
     p.suppressLowMultDebris = vc.suppressLowMultDebris;
@@ -270,24 +258,35 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
     p.nThreads = vc.nThreads;
     p.ZBins = vc.ZBins;
     p.PhiBins = vc.PhiBins;
-
     p.useTruthSeeding = vc.useTruthSeeding;
+    p.maxTrackletsPerCluster = vc.maxTrackletsPerCluster;
+    p.zCut = vc.zCut;
+    p.phiCut = vc.phiCut;
+    p.pairCut = vc.pairCut;
+    p.clusterCut = vc.clusterCut;
+    p.coarseZWindow = vc.coarseZWindow;
+    p.seedDedupZCut = vc.seedDedupZCut;
+    p.refitDedupZCut = vc.refitDedupZCut;
+    p.duplicateZCut = vc.duplicateZCut;
+    p.finalSelectionZCut = vc.finalSelectionZCut;
+    p.duplicateDistance2Cut = vc.duplicateDistance2Cut;
+    p.tanLambdaCut = vc.tanLambdaCut;
+  }
+
+  if (mode == TrackingMode::Async) {
+    // relax for UPC iteration
+    vertParams[1].phiCut = 0.015f;
+    vertParams[1].tanLambdaCut = 0.015f;
+    vertParams[1].maxTrackletsPerCluster = 2000;
+  } else if (mode == TrackingMode::Sync || TrackingMode::Cosmics) {
+    vertParams.resize(1);
+  } else {
+    LOGP(fatal, "Unsupported ITS vertexing mode {} ", toString(mode));
+  }
+
+  if (vertParams.size() > vc.nIterations) {
+    vertParams.resize(vc.nIterations);
   }
-  // set for now outside to not disturb status quo
-  vertParams[0].vertNsigmaCut = vc.vertNsigmaCut;
-  vertParams[0].vertRadiusSigma = vc.vertRadiusSigma;
-  vertParams[0].maxTrackletsPerCluster = vc.maxTrackletsPerCluster;
-  vertParams[0].zCut = vc.zCut;
-  vertParams[0].phiCut = vc.phiCut;
-  vertParams[0].pairCut = vc.pairCut;
-  vertParams[0].clusterCut = vc.clusterCut;
-  vertParams[0].coarseZWindow = vc.coarseZWindow;
-  vertParams[0].seedDedupZCut = vc.seedDedupZCut;
-  vertParams[0].refitDedupZCut = vc.refitDedupZCut;
-  vertParams[0].duplicateZCut = vc.duplicateZCut;
-  vertParams[0].finalSelectionZCut = vc.finalSelectionZCut;
-  vertParams[0].duplicateDistance2Cut = vc.duplicateDistance2Cut;
-  vertParams[0].tanLambdaCut = vc.tanLambdaCut;
 
   return vertParams;
 }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index dc032a46213a9..fa881789af296 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -31,12 +31,6 @@ using o2::its::constants::GB;
 template <int NLayers>
 Tracker<NLayers>::Tracker(TrackerTraits<NLayers>* traits) : mTraits(traits)
 {
-  /// Initialise standard configuration with 1 iteration
-  mTrkParams.resize(1);
-  if (traits->isGPU()) {
-    ITSGpuTrackingParamConfig::Instance().maybeOverride();
-    ITSGpuTrackingParamConfig::Instance().printKeyValues(true, true);
-  }
 }
 
 template <int NLayers>
@@ -46,7 +40,6 @@ void Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
 
   double total{0};
   mTraits->updateTrackingParameters(mTrkParams);
-  mTimeFrame->updateROFVertexLookupTable();
 
   int maxNvertices{-1};
   if (mTrkParams[0].PerPrimaryVertexProcessing) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
index 3101c34d4ab8f..47b5f8ffffdb1 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingConfigParam.cxx
@@ -1,4 +1,4 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
 // See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
 // All rights not expressly granted are reserved.
 //
@@ -9,36 +9,6 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include <boost/property_tree/ptree.hpp>
-
-#include "Framework/Logger.h"
 #include "ITStracking/TrackingConfigParam.h"
-
 O2ParamImpl(o2::its::VertexerParamConfig);
 O2ParamImpl(o2::its::TrackerParamConfig);
-O2ParamImpl(o2::its::ITSGpuTrackingParamConfig);
-
-namespace o2::its
-{
-
-void ITSGpuTrackingParamConfig::maybeOverride() const
-{
-  if (nBlocks == OverrideValue && nThreads == OverrideValue) {
-    return;
-  }
-  const auto name = getName();
-  auto members = getDataMembers();
-  for (auto member : *members) {
-    if (!member.name.ends_with(BlocksName) && !member.name.ends_with(ThreadsName)) {
-      if (nBlocks != OverrideValue && member.name.starts_with(BlocksName) && (member.value != nBlocks)) {
-        o2::conf::ConfigurableParam::setValue<int>(name, member.name, nBlocks);
-      }
-      if (nThreads != OverrideValue && member.name.starts_with(ThreadsName) && (member.value != nThreads)) {
-        o2::conf::ConfigurableParam::setValue<int>(name, member.name, nThreads);
-      }
-    }
-  }
-  LOGP(info, "Overwriting gpu threading parameters");
-} // namespace o2::its
-
-} // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index eb0841888b03e..fcd9024a74709 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -209,10 +209,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   auto clockROFspan = rofsinput[clockLayerId];
   auto clockTiming = mTimeFrame->getROFOverlapTableView().getClockLayer();
   for (auto iRof{0}; iRof < clockROFspan.size(); ++iRof) {
-    bounded_vector<Vertex> vtxVecLoc;
     auto& vtxROF = vertROFvec.emplace_back(clockROFspan[iRof]);
-    vtxROF.setFirstEntry((int)vertices.size());
-
     if (mRunVertexer) {
       auto vtxSpan = mTimeFrame->getPrimaryVertices(clockLayerId, iRof);
       if (o2::its::TrackerParamConfig::Instance().doUPCIteration) {
@@ -231,7 +228,6 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
       } else {
         vtxROF.setFlag(o2::itsmft::ROFRecord::VtxStdMode);
       }
-      vtxROF.setNEntries((int)vtxSpan.size());
     }
   }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h b/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
index 0640ff98297b9..46af692fe0c15 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingLinkDef.h
@@ -39,9 +39,6 @@
 #pragma link C++ class o2::its::TrackerParamConfig + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::TrackerParamConfig> + ;
 
-#pragma link C++ class o2::its::ITSGpuTrackingParamConfig + ;
-#pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::ITSGpuTrackingParamConfig> + ;
-
 #pragma link C++ class o2::its::FastMultEstConfig + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::its::FastMultEstConfig> + ;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 222b4801a5767..cbff174634ec8 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -60,7 +60,7 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
 
   float timeTracklet{0.f}, timeSelection{0.f}, timeVertexing{0.f}, timeInit{0.f};
   try {
-    for (int iteration = 0; iteration < std::min(mVertParams[0].nIterations, (int)mVertParams.size()); ++iteration) {
+    for (int iteration = 0; iteration < (int)mVertParams.size(); ++iteration) {
       mMemoryPool->setMaxMemory(mVertParams[iteration].MaxMemory);
       unsigned int nTracklets01{0}, nTracklets12{0};
       logger(fmt::format("=== ITS {} Seeding vertexer iteration {} summary:", mTraits->getName(), iteration));
@@ -71,12 +71,18 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
       nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
       nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
       auto timeSelectionIteration = evaluateTask(&Vertexer::validateTracklets, StateNames[mCurState = Validating], iteration, evalLog, iteration);
+      const auto nVerticesBefore = mTimeFrame->getPrimaryVertices().size();
       auto timeVertexingIteration = evaluateTask(&Vertexer::findVertices, StateNames[mCurState = Finding], iteration, evalLog, iteration);
-      printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), mTimeFrame->getPrimaryVertices().size(), timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
+      const auto nVerticesAfter = mTimeFrame->getPrimaryVertices().size();
+      printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), nVerticesAfter - nVerticesBefore, nVerticesAfter, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
       timeInit += timeInitIteration;
       timeTracklet += timeTrackletIteration;
       timeSelection += timeSelectionIteration;
       timeVertexing += timeVertexingIteration;
+
+      // update LUT with all currently found vertices so in second iteration we can check vertPerROFThreshold
+      sortVertices();
+      mTimeFrame->updateROFVertexLookupTable();
     }
   } catch (const BoundedMemoryResource::MemoryLimitExceeded& err) {
     handleException(err);
@@ -86,8 +92,6 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
     LOGP(fatal, "Uncaught exception!");
   }
 
-  sortVertices();
-
   return timeInit + timeTracklet + timeSelection + timeVertexing;
 }
 
@@ -134,12 +138,12 @@ void Vertexer<NLayers>::adoptTimeFrame(TimeFrameN& tf)
 template <int NLayers>
 void Vertexer<NLayers>::printEpilog(LogFunc& logger,
                                     const unsigned int trackletN01, const unsigned int trackletN12,
-                                    const unsigned selectedN, const unsigned int vertexN, const float initT,
+                                    const unsigned selectedN, const unsigned int vertexN, const unsigned int totalVertexN,
                                     const float trackletT, const float selecT, const float vertexT)
 {
   logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
   logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {} ms", mTraits->getName(), selectedN, selecT));
-  logger(fmt::format(" - {} Vertexer: found {} vertices in: {} ms", mTraits->getName(), vertexN, vertexT));
+  logger(fmt::format(" - {} Vertexer: found {} vertices in: {} ms (total: {})", mTraits->getName(), vertexN, vertexT, totalVertexN));
   if (mVertParams[0].PrintMemory) {
     mTimeFrame->printArtefactsMemory();
     mMemoryPool->print();
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index a22d2d6c60990..d0baa65c49147 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -168,15 +168,15 @@ void VertexerTraits<NLayers>::computeTracklets(const int iteration)
 {
   mTaskArena->execute([&] {
     tbb::parallel_for(0, mTimeFrame->getNrof(1), [&](const short pivotRofId) {
-      bool skipROF = !mTimeFrame->getROFMaskView().isROFEnabled(1, pivotRofId);
+      bool skip = skipROF(iteration, pivotRofId);
       const auto& rofRange01 = mTimeFrame->getROFOverlapTableView().getOverlap(1, 0, pivotRofId);
       for (auto targetRofId = rofRange01.getFirstEntry(); targetRofId < rofRange01.getEntriesBound(); ++targetRofId) {
         const auto timeErr = mTimeFrame->getROFOverlapTableView().getTimeStamp(0, targetRofId, 1, pivotRofId);
         trackleterKernelHost<TrackletMode::Layer0Layer1, true>(
-          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(), // Clusters to be matched with the next layer in target rof
-          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),  // Clusters to be matched with the current layer in pivot rof
-          mTimeFrame->getUsedClustersROF(targetRofId, 0),                                   // Span of the used clusters in the target rof
-          mTimeFrame->getIndexTable(targetRofId, 0).data(),                                 // Index table to access the data on the next layer in target rof
+          !skip ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(), // Clusters to be matched with the next layer in target rof
+          !skip ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),  // Clusters to be matched with the current layer in pivot rof
+          mTimeFrame->getUsedClustersROF(targetRofId, 0),                                // Span of the used clusters in the target rof
+          mTimeFrame->getIndexTable(targetRofId, 0).data(),                              // Index table to access the data on the next layer in target rof
           mVrtParams[iteration].phiCut,
           mTimeFrame->getTracklets()[0],                   // Flat tracklet buffer
           mTimeFrame->getNTrackletsCluster(pivotRofId, 0), // Span of the number of tracklets per each cluster in pivot rof
@@ -191,8 +191,8 @@ void VertexerTraits<NLayers>::computeTracklets(const int iteration)
       for (auto targetRofId = rofRange12.getFirstEntry(); targetRofId < rofRange12.getEntriesBound(); ++targetRofId) {
         const auto timeErr = mTimeFrame->getROFOverlapTableView().getTimeStamp(2, targetRofId, 1, pivotRofId);
         trackleterKernelHost<TrackletMode::Layer1Layer2, true>(
-          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
-          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+          !skip ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
+          !skip ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
           mTimeFrame->getUsedClustersROF(targetRofId, 2),
           mTimeFrame->getIndexTable(targetRofId, 2).data(),
           mVrtParams[iteration].phiCut,
@@ -219,14 +219,14 @@ void VertexerTraits<NLayers>::computeTracklets(const int iteration)
     }
 
     tbb::parallel_for(0, mTimeFrame->getNrof(1), [&](const short pivotRofId) {
-      bool skipROF = !mTimeFrame->getROFMaskView().isROFEnabled(1, pivotRofId);
+      bool skip = skipROF(iteration, pivotRofId);
       const int globalOffsetPivot = mTimeFrame->getSortedStartIndex(pivotRofId, 1);
       const auto& rofRange01 = mTimeFrame->getROFOverlapTableView().getOverlap(1, 0, pivotRofId);
       for (auto targetRofId = rofRange01.getFirstEntry(); targetRofId < rofRange01.getEntriesBound(); ++targetRofId) {
         const auto timeErr = mTimeFrame->getROFOverlapTableView().getTimeStamp(0, targetRofId, 1, pivotRofId);
         trackleterKernelHost<TrackletMode::Layer0Layer1, false>(
-          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(),
-          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+          !skip ? mTimeFrame->getClustersOnLayer(targetRofId, 0) : gsl::span<Cluster>(),
+          !skip ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
           mTimeFrame->getUsedClustersROF(targetRofId, 0),
           mTimeFrame->getIndexTable(targetRofId, 0).data(),
           mVrtParams[iteration].phiCut,
@@ -243,8 +243,8 @@ void VertexerTraits<NLayers>::computeTracklets(const int iteration)
       for (auto targetRofId = rofRange12.getFirstEntry(); targetRofId < rofRange12.getEntriesBound(); ++targetRofId) {
         const auto timeErr = mTimeFrame->getROFOverlapTableView().getTimeStamp(2, targetRofId, 1, pivotRofId);
         trackleterKernelHost<TrackletMode::Layer1Layer2, false>(
-          !skipROF ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
-          !skipROF ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
+          !skip ? mTimeFrame->getClustersOnLayer(targetRofId, 2) : gsl::span<Cluster>(),
+          !skip ? mTimeFrame->getClustersOnLayer(pivotRofId, 1) : gsl::span<Cluster>(),
           mTimeFrame->getUsedClustersROF(targetRofId, 2),
           mTimeFrame->getIndexTable(targetRofId, 2).data(),
           mVrtParams[iteration].phiCut,
@@ -293,7 +293,7 @@ void VertexerTraits<NLayers>::computeTrackletMatching(const int iteration)
       tbb::blocked_range<short>(0, (short)mTimeFrame->getNrof(1)),
       [&](const tbb::blocked_range<short>& Rofs) {
         for (short pivotRofId = Rofs.begin(); pivotRofId < Rofs.end(); ++pivotRofId) {
-          if (mTimeFrame->getFoundTracklets(pivotRofId, 0).empty()) {
+          if (mTimeFrame->getFoundTracklets(pivotRofId, 0).empty() || skipROF(iteration, pivotRofId)) {
             continue;
           }
           mTimeFrame->getLines(pivotRofId).reserve(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).size());
@@ -330,7 +330,6 @@ void VertexerTraits<NLayers>::computeVertices(const int iteration)
   const int nRofs = mTimeFrame->getNrof(1);
   std::vector<std::vector<Vertex>> rofVertices(nRofs);
   std::vector<std::vector<VertexLabel>> rofLabels(nRofs);
-  const float nsigmaCut = std::min(mVrtParams[iteration].vertNsigmaCut * mVrtParams[iteration].vertNsigmaCut * (mVrtParams[iteration].vertRadiusSigma * mVrtParams[iteration].vertRadiusSigma + mVrtParams[iteration].trackletSigma * mVrtParams[iteration].trackletSigma), 1.98f);
   const float pairCut2 = mVrtParams[iteration].pairCut * mVrtParams[iteration].pairCut;
   const float duplicateZCut = mVrtParams[iteration].duplicateZCut > 0.f ? mVrtParams[iteration].duplicateZCut : std::max(4.f * mVrtParams[iteration].pairCut, 0.5f * mVrtParams[iteration].clusterCut);
   const float duplicateDistance2Cut = mVrtParams[iteration].duplicateDistance2Cut > 0.f ? mVrtParams[iteration].duplicateDistance2Cut : std::max(16.f * pairCut2, 0.0625f * mVrtParams[iteration].clusterCut * mVrtParams[iteration].clusterCut);
@@ -352,6 +351,9 @@ void VertexerTraits<NLayers>::computeVertices(const int iteration)
   settings.memoryPool = mMemoryPool;
 
   const auto processROF = [&](const int rofId) {
+    if (skipROF(iteration, rofId)) {
+      return;
+    }
     auto& lines = mTimeFrame->getLines(rofId);
     auto clusters = line_vertexer::buildClusters(std::span<const Line>{lines.data(), lines.size()}, settings);
     deepVectorClear(lines); // not needed after
@@ -508,7 +510,7 @@ void VertexerTraits<NLayers>::computeVertices(const int iteration)
     for (const auto sortedId : sortedIndices) {
       const auto& cluster = clusters[selectedIndices[sortedId]];
       const auto beamDistance2 = clusterBeamDistance2(cluster);
-      if (!(beamDistance2 < nsigmaCut)) {
+      if (!(beamDistance2 < mVrtParams[iteration].NSigmaCut)) {
         continue;
       }
       if (cluster.getSize() < mVrtParams[iteration].clusterContributorsCut) {
@@ -620,5 +622,11 @@ void VertexerTraits<NLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena
   }
 }
 
+template <int NLayers>
+bool VertexerTraits<NLayers>::skipROF(int iteration, int rof) const
+{
+  return iteration && (int)mTimeFrame->getROFVertexLookupTableView().getVertices(1, rof).getEntries() > mVrtParams[iteration].vertPerRofThreshold;
+}
+
 template class VertexerTraits<7>;
 } // namespace o2::its
diff --git a/GPU/Workflow/src/GPUWorkflowITS.cxx b/GPU/Workflow/src/GPUWorkflowITS.cxx
index fb27df2ec08b9..ac9834d3eacd1 100644
--- a/GPU/Workflow/src/GPUWorkflowITS.cxx
+++ b/GPU/Workflow/src/GPUWorkflowITS.cxx
@@ -40,7 +40,6 @@ int32_t GPURecoWorkflowSpec::runITSTracking(o2::framework::ProcessingContext& pc
   if (mNTFs == 1 && pc.services().get<const o2::framework::DeviceSpec>().inputTimesliceId == 0) {
     o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::VertexerParamConfig::Instance().getName()), o2::its::VertexerParamConfig::Instance().getName());
     o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::TrackerParamConfig::Instance().getName()), o2::its::TrackerParamConfig::Instance().getName());
-    o2::conf::ConfigurableParam::write(o2::base::NameConf::getConfigOutputFileName(pc.services().get<const o2::framework::DeviceSpec>().name, o2::its::ITSGpuTrackingParamConfig::Instance().getName()), o2::its::ITSGpuTrackingParamConfig::Instance().getName());
   }
   return 0;
 }
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index e954f6875eb30..52407cc3a4073 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -119,7 +119,7 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 
 # ITS vertexing settings
 if [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then
-  ITS_CONFIG_KEY+="ITSVertexerParam.phiCut=0.4;ITSVertexerParam.tanLambdaCut=0.17;ITSVertexerParam.pairCut=0.0317563;ITSVertexerParam.clusterCut=0.6640964;ITSVertexerParam.coarseZWindow=0.2049018;ITSVertexerParam.seedDedupZCut=0.0711793;ITSVertexerParam.refitDedupZCut=0.0680009;ITSVertexerParam.duplicateZCut=0.1582193;ITSVertexerParam.finalSelectionZCut=0.1081465;ITSVertexerParam.duplicateDistance2Cut=0.0117033;ITSVertexerParam.clusterContributorsCut=2;ITSVertexerParam.seedMemberRadiusZ=0;ITSVertexerParam.vertNsigmaCut=4.0;ITSVertexerParam.vertRadiusSigma=0.0452309;ITSVertexerParam.trackletSigma=0.0025941;ITSVertexerParam.suppressLowMultDebris=0;"
+  ITS_CONFIG_KEY+="ITSVertexerParam.phiCut=0.4;ITSVertexerParam.tanLambdaCut=0.17;ITSVertexerParam.pairCut=0.0317563;ITSVertexerParam.clusterCut=0.6640964;ITSVertexerParam.coarseZWindow=0.2049018;ITSVertexerParam.seedDedupZCut=0.0711793;ITSVertexerParam.refitDedupZCut=0.0680009;ITSVertexerParam.duplicateZCut=0.1582193;ITSVertexerParam.finalSelectionZCut=0.1081465;ITSVertexerParam.duplicateDistance2Cut=0.0117033;ITSVertexerParam.clusterContributorsCut=2;ITSVertexerParam.seedMemberRadiusZ=0;ITSVertexerParam.nSigmaCut=0.032841;ITSVertexerParam.suppressLowMultDebris=0;"
 fi
 
 if [[ $CTFINPUT != 1 ]]; then

From 541bbcc89994e8595ec5090d1d9131277ad9a260 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 19 Apr 2026 19:13:34 +0200
Subject: [PATCH 1555/1764] Modernize to std::greater<> to please code checker

---
 Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx b/Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx
index 592c22dedf347..cbb8d52571ec9 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/LineVertexerHelpers.cxx
@@ -743,7 +743,7 @@ bounded_vector<bounded_vector<int>> buildCoarseClusters(std::span<const LineRef>
 
   using ActiveEntry = std::pair<TimeStampType, int>;
   bounded_vector<ActiveEntry> activeEntries(settings.memoryPool.get());
-  std::priority_queue<ActiveEntry, bounded_vector<ActiveEntry>, std::greater<ActiveEntry>> activeByUpper(std::greater<ActiveEntry>{}, std::move(activeEntries));
+  std::priority_queue<ActiveEntry, bounded_vector<ActiveEntry>, std::greater<>> activeByUpper(std::greater<>{}, std::move(activeEntries));
   bounded_vector<uint8_t> activeMask(lineRefs.size(), 0, settings.memoryPool.get());
   bounded_vector<bounded_vector<int>> activeByZBin(settings.memoryPool.get());
   activeByZBin.reserve(nZBins);

From 08549f4ee915deb8b18e205b2dd631a66c7c4114 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Tue, 21 Apr 2026 10:40:03 +0200
Subject: [PATCH 1556/1764] ALICE3: Add VD bandwidth monitoring macro (#15295)

---
 .../ALICE3/TRK/macros/test/CheckBandwidth.C   | 561 +++++++++++++-----
 1 file changed, 418 insertions(+), 143 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C
index 2087f88a87d6b..06d24361c7721 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C
@@ -9,17 +9,19 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// \file CheckDigits.C
-/// \brief Simple macro to check TRK digits
+/// \file CheckBandwidth.C
+/// \brief Simple macro to check TRK bandwidth
 
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 #include <algorithm>
 #include <cmath>
 #include <map>
+#include <numeric>
 #include <TCanvas.h>
 #include <TFile.h>
 #include <TH1D.h>
 #include <TH2F.h>
+#include <TPaveText.h>
 #include <TLatex.h>
 #include <TString.h>
 #include <TTree.h>
@@ -38,7 +40,7 @@
 
 namespace
 {
-constexpr double DigitBits = 16.;
+constexpr double DigitBits = 24.;
 constexpr double BunchCrossingNS = 25.;
 constexpr int ReadoutCycleBC = 18;
 constexpr int ReadoutCycleSimBC = 18;
@@ -50,13 +52,15 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
   gStyle->SetPalette(55);
   gStyle->SetOptStat(0);
 
+  // --- Drawing helpers ---
+
   auto drawSummary = [](double averageValue, double peakValue, const char* unit) {
     TLatex latex;
     latex.SetNDC();
     latex.SetTextSize(0.03);
     latex.SetTextAlign(13);
-    latex.DrawLatex(0.04, 0.05, Form("avg: %.3f %s", averageValue, unit));
-    latex.DrawLatex(0.34, 0.05, Form("peak: %.3f %s", peakValue, unit));
+    latex.DrawLatex(0.04, 0.06, Form("avg: %.3f %s", averageValue, unit));
+    latex.DrawLatex(0.04, 0.03, Form("peak: %.3f %s", peakValue, unit));
   };
 
   auto drawCollisionSummary = [](double averageValue, double nonEmptyAverageValue, double peakValue) {
@@ -69,17 +73,103 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
     latex.DrawLatex(0.04, 0.06, Form("avg non-empty: %.3f collisions/ROF", nonEmptyAverageValue));
   };
 
+  auto drawCollisionInfoBox = [](double averageValue) {
+    const double effectiveIRRateHz = ReadoutCycleSeconds > 0. ? averageValue / ReadoutCycleSeconds : 0.;
+    TPaveText infoBox(0.55, 0.79, 0.88, 0.9, "NDC");
+    infoBox.SetFillColor(0);
+    infoBox.SetBorderSize(1);
+    infoBox.SetTextAlign(12);
+    infoBox.SetTextSize(0.028);
+    infoBox.AddText(Form("effective IR: %.3f MHz", effectiveIRRateHz * 1.e-6));
+    infoBox.AddText(Form("ROF length: %d BC", ReadoutCycleBC));
+    infoBox.DrawClone();
+  };
+
+  const TString outputPdf = "trk_bandwidth_report.pdf";
+  bool pdfOpened = false;
+  TCanvas* lastPdfCanvas = nullptr;
+  auto appendCanvasToPdf = [&](TCanvas* canvas) {
+    if (!pdfOpened) {
+      canvas->Print(Form("%s[", outputPdf.Data()));
+      pdfOpened = true;
+    }
+    canvas->Print(outputPdf.Data());
+    lastPdfCanvas = canvas;
+  };
+
   using namespace o2::base;
   using namespace o2::trk;
 
   TFile* f = TFile::Open("CheckBandwidth.root", "recreate");
 
-  // Geometry
+  // --- Geometry ---
+
   o2::base::GeometryManager::loadGeometry(inputGeom);
   auto* gman = o2::trk::GeometryTGeo::Instance();
   gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
 
-  // Collision Context
+  const int nVDPetals = gman->extractNumberOfPetalsVD();
+  const int nVDLayers = gman->extractNumberOfLayersVD();
+  const int nMLOTLayers = gman->getNumberOfLayersMLOT();
+  const int nTotalLayers = nVDLayers + nMLOTLayers;
+  const int nChips = gman->getNumberOfChips();
+
+  // Precompute per-chip geometry — centralises all gman queries.
+  // globalLayer maps VD layers to [0, nVDLayers) and MLOT layers to [nVDLayers, nTotalLayers).
+  // disk == -1 identifies barrel chips (the only ones that produce digits in this detector).
+  struct ChipGeom {
+    int subDetID = -1, localLayer = -1, globalLayer = -1, disk = -1;
+    int stave = -1, halfStave = -1, petal = -1;
+  };
+  std::vector<ChipGeom> chipGeom(nChips);
+  for (int chipID = 0; chipID < nChips; ++chipID) {
+    auto& g = chipGeom[chipID];
+    g.subDetID = gman->getSubDetID(chipID);
+    g.localLayer = gman->getLayer(chipID);
+    g.disk = gman->getDisk(chipID);
+    g.globalLayer = g.localLayer + g.subDetID * nVDLayers;
+    g.stave = gman->getStave(chipID);
+    g.halfStave = std::max(0, gman->getHalfStave(chipID));
+    g.petal = (g.subDetID == 0) ? gman->getPetalCase(chipID) : -1;
+  }
+
+  // Number of barrel chips per global layer (used for per-layer bandwidth normalisation).
+  std::vector<unsigned int> chipsPerLayer(nTotalLayers, 0u);
+  for (int chipID = 0; chipID < nChips; ++chipID) {
+    const auto& g = chipGeom[chipID];
+    if (g.disk != -1 || g.globalLayer < 0 || g.globalLayer >= nTotalLayers) {
+      continue;
+    }
+    ++chipsPerLayer[g.globalLayer];
+  }
+
+  // MLOT sensor index within its half-stave, ordered by Z position.
+  // Precomputed here so the plotting loop only reads results.
+  std::vector<int> chipSensorIndex(nChips, -1);
+  std::vector<int> maxSensorsPerHalfStaveMLOT(nMLOTLayers, 0);
+  for (int layer = 0; layer < nMLOTLayers; ++layer) {
+    std::map<std::pair<int, int>, std::vector<std::pair<double, int>>> chipsPerHalfStave;
+    for (int chipID = 0; chipID < nChips; ++chipID) {
+      const auto& g = chipGeom[chipID];
+      if (g.subDetID != 1 || g.localLayer != layer || g.disk != -1) {
+        continue;
+      }
+      const auto center = gman->getMatrixL2G(chipID)(o2::math_utils::Point3D<float>(0.f, 0.f, 0.f));
+      chipsPerHalfStave[{g.stave, g.halfStave}].push_back({center.Z(), chipID});
+    }
+    for (auto& [key, chips] : chipsPerHalfStave) {
+      std::sort(chips.begin(), chips.end(), [](const auto& a, const auto& b) {
+        return std::abs(a.first - b.first) > 1.e-4 ? a.first < b.first : a.second < b.second;
+      });
+      for (size_t i = 0; i < chips.size(); ++i) {
+        chipSensorIndex[chips[i].second] = (int)i;
+      }
+      maxSensorsPerHalfStaveMLOT[layer] = std::max(maxSensorsPerHalfStaveMLOT[layer], (int)chips.size());
+    }
+  }
+
+  // --- Collision context ---
+
   TFile* ccFile = TFile::Open(collContextFile.data());
   auto* digiContext = (o2::steer::DigitizationContext*)ccFile->Get("DigitizationContext");
   const o2::InteractionRecord firstSampledIR{0, digiContext->getFirstOrbitForSampling()};
@@ -93,7 +183,6 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
     if (nbc < 0) {
       continue;
     }
-
     const size_t rofID = nbc / ReadoutCycleSimBC;
     if (rofID >= collisionsPerROF.size()) {
       collisionsPerROF.resize(rofID + 1, 0u);
@@ -101,197 +190,383 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
     ++collisionsPerROF[rofID];
   }
 
-  // Digits
+  // --- Digits ---
+
   TFile* digFile = TFile::Open(digifile.data());
   TTree* digTree = (TTree*)digFile->Get("o2sim");
   const int nDigitTreeEntries = digTree->GetEntries();
 
   std::vector<o2::itsmft::Digit>* digArr = nullptr;
+  std::vector<o2::itsmft::ROFRecord>* rofRecords = nullptr;
   digTree->SetBranchAddress("TRKDigit", &digArr);
-
-  // Get Read Out Frame arrays
-  std::vector<o2::itsmft::ROFRecord>* ROFRecordArrray = nullptr;
-  digTree->SetBranchAddress("TRKDigitROF", &ROFRecordArrray);
-  std::vector<o2::itsmft::ROFRecord>& ROFRecordArrrayRef = *ROFRecordArrray;
+  digTree->SetBranchAddress("TRKDigitROF", &rofRecords);
 
   digTree->GetEntry(0);
-
   if (nDigitTreeEntries > 1) {
     LOG(warning) << "Digit tree has " << nDigitTreeEntries << " entries, but this macro processes entry 0 only.";
   }
 
-  std::vector<unsigned long long> digitsPerChip(gman->getNumberOfChips(), 0ull);
-  std::vector<unsigned int> maxDigitsPerROFPerChip(gman->getNumberOfChips(), 0u);
-  std::vector<unsigned int> digitsInCurrentROFPerChip(gman->getNumberOfChips(), 0u);
+  const int nROFRec = (int)rofRecords->size();
+  if (nROFRec != (int)collisionsPerROF.size()) {
+    LOG(fatal) << "Mismatch between number of ROF records in digit tree (" << nROFRec
+               << ") and number of ROFs computed from collisioncontext.root (" << collisionsPerROF.size()
+               << "). Check input files.";
+  }
+
+  // --- Accumulate per-chip digit counts across all ROFs ---
 
-  const int nROFRec = (int)ROFRecordArrrayRef.size();
-  const int nCollisionROFBins = std::max(nROFRec, static_cast<int>(collisionsPerROF.size()));
+  const double rofNorm = nROFRec > 0 ? 1. / nROFRec : 0.;
+  const double bitsToGbps = ReadoutCycleSeconds > 0. ? DigitBits / ReadoutCycleSeconds / 1.e9 : 0.;
 
-  if (nCollisionROFBins > 0) {
-    auto* hCollisionsPerROF = new TH1D("h_collisions_per_rof", "Collisions per ROF;ROF id;N collisions", nCollisionROFBins, -0.5, nCollisionROFBins - 0.5);
-    double totalCollisionsPerROF = 0.;
-    double peakCollisionsPerROF = 0.;
-    int nNonEmptyROFs = 0;
+  std::vector<unsigned long long> digitsPerChip(nChips, 0ull);
+  std::vector<unsigned int> maxDigitsPerROFPerChip(nChips, 0u);
+  std::vector<unsigned int> digitsInCurrentROFPerChip(nChips, 0u);
 
-    for (int rofID = 0; rofID < nCollisionROFBins; ++rofID) {
-      const double nCollisions = rofID < static_cast<int>(collisionsPerROF.size()) ? collisionsPerROF[rofID] : 0.;
-      hCollisionsPerROF->SetBinContent(rofID + 1, nCollisions);
-      totalCollisionsPerROF += nCollisions;
-      peakCollisionsPerROF = std::max(peakCollisionsPerROF, nCollisions);
-      if (nCollisions > 0.) {
-        ++nNonEmptyROFs;
+  for (unsigned int iROF = 0; iROF < rofRecords->size(); ++iROF) {
+    std::vector<int> touchedChips;
+    const unsigned int rofStart = (*rofRecords)[iROF].getFirstEntry();
+    const unsigned int rofEnd = rofStart + (*rofRecords)[iROF].getNEntries();
+
+    for (unsigned int iDigit = rofStart; iDigit < rofEnd; ++iDigit) {
+      if (iDigit % 1000 == 0) {
+        std::cout << "Reading digit " << iDigit << " / " << digArr->size() << "\r" << std::flush;
       }
+      const int chipID = (*digArr)[iDigit].getChipIndex();
+      if (chipGeom[chipID].disk != -1) {
+        continue;
+      }
+      if (digitsInCurrentROFPerChip[chipID] == 0) {
+        touchedChips.push_back(chipID);
+      }
+      ++digitsPerChip[chipID];
+      ++digitsInCurrentROFPerChip[chipID];
     }
 
-    auto* canvCollisionsPerROF = new TCanvas("canvCollisionsPerROF", "Collisions per ROF", 1050, 1050);
-    canvCollisionsPerROF->SetTopMargin(0.08);
-    hCollisionsPerROF->Draw("hist");
-    drawCollisionSummary(totalCollisionsPerROF / nCollisionROFBins,
-                         nNonEmptyROFs > 0 ? totalCollisionsPerROF / nNonEmptyROFs : 0.,
-                         peakCollisionsPerROF);
-    canvCollisionsPerROF->SaveAs("trk_collisions_per_rof.png");
+    for (const int chipID : touchedChips) {
+      maxDigitsPerROFPerChip[chipID] = std::max(maxDigitsPerROFPerChip[chipID], digitsInCurrentROFPerChip[chipID]);
+      digitsInCurrentROFPerChip[chipID] = 0;
+    }
   }
 
-  unsigned int rofIndex = 0;
-  unsigned int rofNEntries = 0;
-
-  // LOOP on : ROFRecord array
-  for (unsigned int iROF = 0; iROF < ROFRecordArrrayRef.size(); iROF++) {
-    std::vector<int> touchedChips;
-
-    rofIndex = ROFRecordArrrayRef[iROF].getFirstEntry();
-    rofNEntries = ROFRecordArrrayRef[iROF].getNEntries();
-
-    // LOOP on : digits array
-    for (unsigned int iDigit = rofIndex; iDigit < rofIndex + rofNEntries; iDigit++) {
-      if (iDigit % 1000 == 0)
-        std::cout << "Reading digit " << iDigit << " / " << digArr->size() << std::endl;
+  // --- Per-layer bandwidth distribution histograms (second scan over digits) ---
 
-      Int_t iDetID = (*digArr)[iDigit].getChipIndex();
-      Int_t disk = gman->getDisk(iDetID);
-      Int_t subDetID = gman->getSubDetID(iDetID);
+  // Per-layer peak digit count (from per-chip maxima) — drives histogram binning.
+  std::vector<unsigned int> maxDigitsPerLayer(nTotalLayers, 0u);
+  for (int chipID = 0; chipID < nChips; ++chipID) {
+    const auto& g = chipGeom[chipID];
+    if (g.disk != -1 || g.globalLayer < 0 || g.globalLayer >= nTotalLayers) {
+      continue;
+    }
+    maxDigitsPerLayer[g.globalLayer] = std::max(maxDigitsPerLayer[g.globalLayer], maxDigitsPerROFPerChip[chipID]);
+  }
 
-      if (subDetID == 1 && disk == -1) {
-        if (digitsInCurrentROFPerChip[iDetID] == 0) {
-          touchedChips.push_back(iDetID);
+  std::vector<TH1D*> hDigitsDistPerLayer(nTotalLayers, nullptr);
+  for (int l = 0; l < nTotalLayers; ++l) {
+    if (chipsPerLayer[l] == 0 || maxDigitsPerLayer[l] == 0) {
+      continue;
+    }
+    const int nBins = std::min((int)maxDigitsPerLayer[l] + 1, 200);
+    hDigitsDistPerLayer[l] = new TH1D(Form("h_digits_dist_layer%d", l),
+                                      Form("Layer %d;Fired pixels / ROF / chip;Probability", l),
+                                      nBins, -0.5, (double)maxDigitsPerLayer[l] + 0.5);
+  }
+  // digitsInCurrentROFPerChip is all zeros after the first scan — reuse it here.
+  {
+    std::vector<int> touchedChips;
+    for (unsigned int iROF = 0; iROF < rofRecords->size(); ++iROF) {
+      touchedChips.clear();
+      const unsigned int rofStart = (*rofRecords)[iROF].getFirstEntry();
+      const unsigned int rofEnd = rofStart + (*rofRecords)[iROF].getNEntries();
+      for (unsigned int iDigit = rofStart; iDigit < rofEnd; ++iDigit) {
+        const int chipID = (*digArr)[iDigit].getChipIndex();
+        if (chipGeom[chipID].disk != -1) {
+          continue;
         }
-        digitsPerChip[iDetID]++;
-        ++digitsInCurrentROFPerChip[iDetID];
+        if (digitsInCurrentROFPerChip[chipID] == 0) {
+          touchedChips.push_back(chipID);
+        }
+        ++digitsInCurrentROFPerChip[chipID];
+      }
+      for (const int chipID : touchedChips) {
+        const int l = chipGeom[chipID].globalLayer;
+        if (hDigitsDistPerLayer[l]) {
+          hDigitsDistPerLayer[l]->Fill(digitsInCurrentROFPerChip[chipID]);
+        }
+        digitsInCurrentROFPerChip[chipID] = 0;
       }
+    }
+  }
 
-    } // end loop on digits array
+  // --- Per-layer bandwidth statistics, normalised by chips per layer ---
+  //
+  // avgDigitsPerROF     : mean over chips of (total chip digits / nROFs)
+  // peakAvgDigitsPerROF : max  over chips of (total chip digits / nROFs)
+  // avgMaxDigitsPerROF  : mean over chips of (peak single-ROF digit count)
+  // peakMaxDigitsPerROF : max  over chips of (peak single-ROF digit count)
+  // avg/peakBandwidthGbps derived from the avg/peak digit quantities above.
 
-    for (const auto chipID : touchedChips) {
-      maxDigitsPerROFPerChip[chipID] = std::max(maxDigitsPerROFPerChip[chipID], digitsInCurrentROFPerChip[chipID]);
-      digitsInCurrentROFPerChip[chipID] = 0;
-    }
+  struct LayerStats {
+    double avgDigitsPerROF = 0.;
+    double peakAvgDigitsPerROF = 0.;
+    double avgMaxDigitsPerROF = 0.;
+    double peakMaxDigitsPerROF = 0.;
+    double avgBandwidthGbps = 0.;
+    double peakBandwidthGbps = 0.;
+  };
+  std::vector<LayerStats> layerStats(nTotalLayers);
 
-  } // end loop on ROFRecords array
+  for (int chipID = 0; chipID < nChips; ++chipID) {
+    const auto& g = chipGeom[chipID];
+    if (g.disk != -1 || g.globalLayer < 0 || g.globalLayer >= nTotalLayers) {
+      continue;
+    }
+    const int l = g.globalLayer;
+    const double avgDigits = digitsPerChip[chipID] * rofNorm;
+    const double maxDigits = (double)maxDigitsPerROFPerChip[chipID];
+    layerStats[l].avgDigitsPerROF += avgDigits;
+    layerStats[l].avgMaxDigitsPerROF += maxDigits;
+    layerStats[l].peakAvgDigitsPerROF = std::max(layerStats[l].peakAvgDigitsPerROF, avgDigits);
+    layerStats[l].peakMaxDigitsPerROF = std::max(layerStats[l].peakMaxDigitsPerROF, maxDigits);
+  }
+  for (int l = 0; l < nTotalLayers; ++l) {
+    if (chipsPerLayer[l] > 0) {
+      const double norm = 1. / chipsPerLayer[l];
+      layerStats[l].avgDigitsPerROF *= norm;
+      layerStats[l].avgMaxDigitsPerROF *= norm;
+    }
+    layerStats[l].avgBandwidthGbps = layerStats[l].avgDigitsPerROF * bitsToGbps;
+    layerStats[l].peakBandwidthGbps = layerStats[l].peakAvgDigitsPerROF * bitsToGbps;
+  }
 
-  const double rofNorm = nROFRec > 0 ? 1. / nROFRec : 0.;
-  const double bitsToMbps = ReadoutCycleSeconds > 0. ? DigitBits / ReadoutCycleSeconds / 1.e6 : 0.;
-  const int nMLOTLayers = gman->getNumberOfLayersMLOT();
+  // --- Collision plots ---
 
-  for (int layer = 0; layer < nMLOTLayers; ++layer) {
-    int nStaves = gman->extractNumberOfStavesMLOT(layer);
-    std::map<int, std::vector<std::pair<double, int>>> chipsPerStave;
-    std::vector<int> sensorIdPerChip(gman->getNumberOfChips(), -1);
-    int maxSensorsPerStave = 0;
+  if (nROFRec > 0) {
+    auto* hCollisionsPerROF = new TH1D("h_collisions_per_rof", "Collisions per ROF;ROF id;N collisions",
+                                       nROFRec, -0.5, nROFRec - 0.5);
+    double totalCollisionsPerROF = 0.;
+    double peakCollisionsPerROF = 0.;
+    int nNonEmptyROFs = 0;
 
-    for (int chipID = 0; chipID < gman->getNumberOfChips(); ++chipID) {
-      if (gman->getSubDetID(chipID) != 1 || gman->getLayer(chipID) != layer) {
-        continue;
+    for (int rofID = 0; rofID < nROFRec; ++rofID) {
+      const double nColl = collisionsPerROF[rofID];
+      hCollisionsPerROF->SetBinContent(rofID + 1, nColl);
+      totalCollisionsPerROF += nColl;
+      peakCollisionsPerROF = std::max(peakCollisionsPerROF, nColl);
+      if (nColl > 0.) {
+        ++nNonEmptyROFs;
       }
-      const int staveID = gman->getStave(chipID);
-      const auto sensorCenter = gman->getMatrixL2G(chipID)(o2::math_utils::Point3D<float>(0.f, 0.f, 0.f));
-      chipsPerStave[staveID].push_back({sensorCenter.Z(), chipID});
     }
 
-    for (auto& [staveID, chips] : chipsPerStave) {
-      std::sort(chips.begin(), chips.end(), [](const auto& left, const auto& right) {
-        if (std::abs(left.first - right.first) > 1.e-4) {
-          return left.first < right.first;
-        }
-        return left.second < right.second;
-      });
-
-      for (size_t sensorIndex = 0; sensorIndex < chips.size(); ++sensorIndex) {
-        sensorIdPerChip[chips[sensorIndex].second] = sensorIndex;
-      }
+    const double avgCollisionsPerROF = totalCollisionsPerROF / nROFRec;
+    auto* canvCollisionsPerROF = new TCanvas("canvCollisionsPerROF", "Collisions per ROF", 1050, 1050);
+    canvCollisionsPerROF->SetTopMargin(0.08);
+    hCollisionsPerROF->Draw("hist");
+    drawCollisionSummary(avgCollisionsPerROF,
+                         nNonEmptyROFs > 0 ? totalCollisionsPerROF / nNonEmptyROFs : 0.,
+                         peakCollisionsPerROF);
+    drawCollisionInfoBox(avgCollisionsPerROF);
+    appendCanvasToPdf(canvCollisionsPerROF);
+  }
 
-      maxSensorsPerStave = std::max(maxSensorsPerStave, static_cast<int>(chips.size()));
+  // --- VD plots ---
+
+  auto* hVDDigitsPerROF = new TH2F("h_digits_per_rof_vd",
+                                   "VD average digits per ROF;petal id;layer id;digits / ROF",
+                                   nVDPetals, -0.5, nVDPetals - 0.5, nVDLayers, -0.5, nVDLayers - 0.5);
+  auto* hVDMaxDigitsPerROF = new TH2F("h_max_digits_per_rof_vd",
+                                      "VD max digits in one ROF;petal id;layer id;max digits / ROF",
+                                      nVDPetals, -0.5, nVDPetals - 0.5, nVDLayers, -0.5, nVDLayers - 0.5);
+  auto* hVDBandwidth = new TH2F("h_bandwidth_vd",
+                                "VD bandwidth map;petal id;layer id;bandwidth (Gbit/s)",
+                                nVDPetals, -0.5, nVDPetals - 0.5, nVDLayers, -0.5, nVDLayers - 0.5);
+
+  for (auto* hist : {hVDDigitsPerROF, hVDMaxDigitsPerROF, hVDBandwidth}) {
+    for (int petalID = 0; petalID < nVDPetals; ++petalID) {
+      hist->GetXaxis()->SetBinLabel(petalID + 1, Form("%d", petalID));
     }
+    for (int layerID = 0; layerID < nVDLayers; ++layerID) {
+      hist->GetYaxis()->SetBinLabel(layerID + 1, Form("%d", layerID));
+    }
+    hist->GetXaxis()->SetNdivisions(0, kFALSE);
+    hist->GetYaxis()->SetNdivisions(0, kFALSE);
+    hist->LabelsOption("h", "X");
+    hist->LabelsOption("h", "Y");
+  }
 
-    if (maxSensorsPerStave == 0) {
+  double totalVDAvgDigits = 0., peakVDAvgDigits = 0.;
+  double totalVDMaxDigits = 0., peakVDMaxDigits = 0.;
+  double totalVDBandwidth = 0., peakVDBandwidth = 0.;
+
+  for (int chipID = 0; chipID < nChips; ++chipID) {
+    const auto& g = chipGeom[chipID];
+    if (g.subDetID != 0 || g.disk != -1 || g.localLayer < 0 || g.localLayer >= nVDLayers) {
       continue;
     }
+    if (g.petal < 0 || g.petal >= nVDPetals) {
+      continue;
+    }
+    const double avgDigits = digitsPerChip[chipID] * rofNorm;
+    const double maxDigits = (double)maxDigitsPerROFPerChip[chipID];
+    const double bandwidth = avgDigits * bitsToGbps;
+
+    hVDDigitsPerROF->SetBinContent(g.petal + 1, g.localLayer + 1, avgDigits);
+    hVDMaxDigitsPerROF->SetBinContent(g.petal + 1, g.localLayer + 1, maxDigits);
+    hVDBandwidth->SetBinContent(g.petal + 1, g.localLayer + 1, bandwidth);
+
+    totalVDAvgDigits += avgDigits;
+    totalVDMaxDigits += maxDigits;
+    totalVDBandwidth += bandwidth;
+    peakVDAvgDigits = std::max(peakVDAvgDigits, avgDigits);
+    peakVDMaxDigits = std::max(peakVDMaxDigits, maxDigits);
+    peakVDBandwidth = std::max(peakVDBandwidth, bandwidth);
+  }
 
-    auto* hDigitsPerROF = new TH2F(Form("h_digits_per_rof_layer%d", layer),
-                                   Form("Layer %d average digits per ROF;stave id;sensor id in stave;digits / ROF", layer),
-                                   nStaves, -0.5, nStaves - 0.5, maxSensorsPerStave, -0.5, maxSensorsPerStave - 0.5);
-    auto* hMaxDigitsPerROF = new TH2F(Form("h_max_digits_per_rof_layer%d", layer),
-                                      Form("Layer %d max digits in one ROF;stave id;sensor id in stave;max digits / ROF", layer),
-                                      nStaves, -0.5, nStaves - 0.5, maxSensorsPerStave, -0.5, maxSensorsPerStave - 0.5);
-    auto* hBandwidth = new TH2F(Form("h_bandwidth_layer%d", layer),
-                                Form("Layer %d bandwidth map;stave id;sensor id in stave;bandwidth (Mbit/s)", layer),
-                                nStaves, -0.5, nStaves - 0.5, maxSensorsPerStave, -0.5, maxSensorsPerStave - 0.5);
-    double totalAvgDigitsPerROF = 0.;
-    double totalMaxDigitsPerROF = 0.;
-    double totalBandwidthMbps = 0.;
-    double peakAvgDigitsPerROF = 0.;
-    double peakMaxDigitsPerROF = 0.;
-    double peakBandwidthMbps = 0.;
-    int nFilledSensors = 0;
+  const int nVDBarrelChips = std::accumulate(chipsPerLayer.begin(), chipsPerLayer.begin() + nVDLayers, 0);
+  const double normVD = nVDBarrelChips > 0 ? 1. / nVDBarrelChips : 0.;
+  const double avgVDAvgDigits = totalVDAvgDigits * normVD;
+  const double avgVDMaxDigits = totalVDMaxDigits * normVD;
+  const double avgVDBandwidth = totalVDBandwidth * normVD;
+
+  auto* canvVDBandwidth = new TCanvas("canvBandwidthVD", "VD bandwidth", 1050, 1050);
+  canvVDBandwidth->SetTopMargin(0.08);
+  canvVDBandwidth->SetRightMargin(0.18);
+  hVDBandwidth->GetZaxis()->SetRangeUser(0., avgVDBandwidth > 0. ? 3. * avgVDBandwidth : 1.);
+  hVDBandwidth->SetMarkerSize(1.8);
+  hVDBandwidth->Draw("colz text");
+  drawSummary(avgVDBandwidth, peakVDBandwidth, "Gbit/s");
+  appendCanvasToPdf(canvVDBandwidth);
+
+  auto* canvVDDigits = new TCanvas("canvDigitsVD", "VD digits per ROF", 1050, 1050);
+  canvVDDigits->SetTopMargin(0.08);
+  canvVDDigits->SetRightMargin(0.18);
+  hVDDigitsPerROF->SetMarkerSize(1.8);
+  hVDDigitsPerROF->Draw("colz text");
+  drawSummary(avgVDAvgDigits, peakVDAvgDigits, "digits/ROF");
+  appendCanvasToPdf(canvVDDigits);
+
+  auto* canvVDMaxDigits = new TCanvas("canvMaxDigitsVD", "VD max digits per ROF", 1050, 1050);
+  canvVDMaxDigits->SetTopMargin(0.08);
+  canvVDMaxDigits->SetRightMargin(0.18);
+  hVDMaxDigitsPerROF->SetMarkerSize(1.8);
+  hVDMaxDigitsPerROF->Draw("colz text");
+  drawSummary(avgVDMaxDigits, peakVDMaxDigits, "digits/ROF");
+  appendCanvasToPdf(canvVDMaxDigits);
+
+  // --- MLOT per-layer plots ---
 
-    for (int chipID = 0; chipID < gman->getNumberOfChips(); ++chipID) {
-      if (gman->getSubDetID(chipID) != 1 || gman->getLayer(chipID) != layer) {
+  for (int layer = 0; layer < nMLOTLayers; ++layer) {
+    if (maxSensorsPerHalfStaveMLOT[layer] == 0) {
+      continue;
+    }
+    const int outputLayer = nVDLayers + layer;
+    const int nStaves = gman->extractNumberOfStavesMLOT(layer);
+    const int nHalfStaves = std::max(1, gman->getNumberOfHalfStaves(layer));
+    const int maxSensors = maxSensorsPerHalfStaveMLOT[layer];
+
+    auto* hDigitsPerROF = new TH2F(Form("h_digits_per_rof_layer%d", outputLayer),
+                                   Form("Layer %d average digits per ROF;stave id / half-stave;sensor id in half-stave;digits / ROF", outputLayer),
+                                   nStaves * nHalfStaves, -0.5, nStaves - 0.5, maxSensors, -0.5, maxSensors - 0.5);
+    auto* hMaxDigitsPerROF = new TH2F(Form("h_max_digits_per_rof_layer%d", outputLayer),
+                                      Form("Layer %d max digits in one ROF;stave id / half-stave;sensor id in half-stave;max digits / ROF", outputLayer),
+                                      nStaves * nHalfStaves, -0.5, nStaves - 0.5, maxSensors, -0.5, maxSensors - 0.5);
+    auto* hBandwidth = new TH2F(Form("h_bandwidth_layer%d", outputLayer),
+                                Form("Layer %d bandwidth map;stave id / half-stave;sensor id in half-stave;bandwidth (Gbit/s)", outputLayer),
+                                nStaves * nHalfStaves, -0.5, nStaves - 0.5, maxSensors, -0.5, maxSensors - 0.5);
+
+    for (int chipID = 0; chipID < nChips; ++chipID) {
+      const auto& g = chipGeom[chipID];
+      if (g.subDetID != 1 || g.localLayer != layer || g.disk != -1) {
         continue;
       }
-
-      const int staveID = gman->getStave(chipID);
-      const int sensorID = sensorIdPerChip[chipID];
-      const double avgDigitsPerROF = digitsPerChip[chipID] * rofNorm;
-      const double maxDigitsPerROF = maxDigitsPerROFPerChip[chipID];
-      const double bandwidthMbps = avgDigitsPerROF * bitsToMbps;
-
-      if (sensorID >= 0) {
-        hDigitsPerROF->Fill(staveID, sensorID, avgDigitsPerROF);
-        hMaxDigitsPerROF->Fill(staveID, sensorID, maxDigitsPerROF);
-        hBandwidth->Fill(staveID, sensorID, bandwidthMbps);
-        totalAvgDigitsPerROF += avgDigitsPerROF;
-        totalMaxDigitsPerROF += maxDigitsPerROF;
-        totalBandwidthMbps += bandwidthMbps;
-        peakAvgDigitsPerROF = std::max(peakAvgDigitsPerROF, avgDigitsPerROF);
-        peakMaxDigitsPerROF = std::max(peakMaxDigitsPerROF, maxDigitsPerROF);
-        peakBandwidthMbps = std::max(peakBandwidthMbps, bandwidthMbps);
-        ++nFilledSensors;
+      const int sensorID = chipSensorIndex[chipID];
+      if (sensorID < 0) {
+        continue;
       }
+      const double staveBinX = g.stave + (g.halfStave + 0.5) / nHalfStaves - 0.5;
+      const double avgDigits = digitsPerChip[chipID] * rofNorm;
+      const double maxDigits = (double)maxDigitsPerROFPerChip[chipID];
+
+      hDigitsPerROF->Fill(staveBinX, sensorID, avgDigits);
+      hMaxDigitsPerROF->Fill(staveBinX, sensorID, maxDigits);
+      hBandwidth->Fill(staveBinX, sensorID, avgDigits * bitsToGbps);
     }
 
-    auto* canvLayer = new TCanvas(Form("canvBandwidthLayer%d", layer), Form("Layer %d bandwidth", layer), 1050, 1050);
+    const auto& ls = layerStats[outputLayer];
+
+    auto* canvLayer = new TCanvas(Form("canvBandwidthLayer%d", outputLayer), Form("Layer %d bandwidth", outputLayer), 1050, 1050);
     canvLayer->SetTopMargin(0.08);
     canvLayer->SetRightMargin(0.18);
-    const double avgDigitsPerROFLayer = nFilledSensors > 0 ? totalAvgDigitsPerROF / nFilledSensors : 0.;
-    const double avgMaxDigitsPerROFLayer = nFilledSensors > 0 ? totalMaxDigitsPerROF / nFilledSensors : 0.;
-    const double avgBandwidthMbps = nFilledSensors > 0 ? totalBandwidthMbps / nFilledSensors : 0.;
-    hBandwidth->GetZaxis()->SetRangeUser(0., avgBandwidthMbps > 0. ? 3. * avgBandwidthMbps : 1.);
+    hBandwidth->GetZaxis()->SetRangeUser(0., ls.avgBandwidthGbps > 0. ? 3. * ls.avgBandwidthGbps : 1.);
     hBandwidth->Draw("colz");
-    drawSummary(avgBandwidthMbps, peakBandwidthMbps, "Mbit/s");
-    canvLayer->SaveAs(Form("trk_layer%d_bandwidth_map.png", layer));
+    drawSummary(ls.avgBandwidthGbps, ls.peakBandwidthGbps, "Gbit/s");
+    appendCanvasToPdf(canvLayer);
 
-    auto* canvLayerDigits = new TCanvas(Form("canvDigitsLayer%d", layer), Form("Layer %d digits per ROF", layer), 1050, 1050);
+    auto* canvLayerDigits = new TCanvas(Form("canvDigitsLayer%d", outputLayer), Form("Layer %d digits per ROF", outputLayer), 1050, 1050);
     canvLayerDigits->SetTopMargin(0.08);
     canvLayerDigits->SetRightMargin(0.18);
     hDigitsPerROF->Draw("colz");
-    drawSummary(avgDigitsPerROFLayer, peakAvgDigitsPerROF, "digits/ROF");
-    canvLayerDigits->SaveAs(Form("trk_layer%d_digits_per_rof_map.png", layer));
+    drawSummary(ls.avgDigitsPerROF, ls.peakAvgDigitsPerROF, "digits/ROF");
+    appendCanvasToPdf(canvLayerDigits);
 
-    auto* canvLayerMaxDigits = new TCanvas(Form("canvMaxDigitsLayer%d", layer), Form("Layer %d max digits per ROF", layer), 1050, 1050);
+    auto* canvLayerMaxDigits = new TCanvas(Form("canvMaxDigitsLayer%d", outputLayer), Form("Layer %d max digits per ROF", outputLayer), 1050, 1050);
     canvLayerMaxDigits->SetTopMargin(0.08);
     canvLayerMaxDigits->SetRightMargin(0.18);
     hMaxDigitsPerROF->Draw("colz");
-    drawSummary(avgMaxDigitsPerROFLayer, peakMaxDigitsPerROF, "digits/ROF");
-    canvLayerMaxDigits->SaveAs(Form("trk_layer%d_max_digits_per_rof_map.png", layer));
+    drawSummary(ls.avgMaxDigitsPerROF, ls.peakMaxDigitsPerROF, "digits/ROF");
+    appendCanvasToPdf(canvLayerMaxDigits);
+  }
+
+  // --- Digits distribution per layer ---
+  // Each histogram shows the distribution of total-layer bandwidth across ROFs.
+
+  {
+    const int nCols = std::max(1, (int)std::ceil(std::sqrt((double)nTotalLayers)));
+    const int nRows = (nTotalLayers + nCols - 1) / nCols;
+    auto* canvBwDist = new TCanvas("canvDigitsDistPerLayer", "Digits distribution per layer", 350 * nCols, 300 * nRows);
+    canvBwDist->Divide(nCols, nRows);
+    for (int layer = 0; layer < nTotalLayers; ++layer) {
+      if (!hDigitsDistPerLayer[layer]) {
+        continue;
+      }
+      canvBwDist->cd(layer + 1);
+      gPad->SetLogy();
+      gPad->SetTopMargin(0.10);
+      gPad->SetBottomMargin(0.14);
+      gPad->SetLeftMargin(0.14);
+      hDigitsDistPerLayer[layer]->Scale(1. / hDigitsDistPerLayer[layer]->GetEntries());
+      hDigitsDistPerLayer[layer]->Draw("hist");
+    }
+    appendCanvasToPdf(canvBwDist);
+  }
+
+  // --- Summary: bandwidth vs layer ---
+
+  auto* hAvgBandwidthVsLayer = new TH1D("h_avg_bandwidth_vs_layer",
+                                        "Average bandwidth by layer;layer id;average bandwidth (Gbit/s)",
+                                        nTotalLayers, -0.5, nTotalLayers - 0.5);
+  auto* hPeakBandwidthVsLayer = new TH1D("h_peak_bandwidth_vs_layer",
+                                         "Peak bandwidth by layer;layer id;peak bandwidth (Gbit/s)",
+                                         nTotalLayers, -0.5, nTotalLayers - 0.5);
+  for (int layer = 0; layer < nTotalLayers; ++layer) {
+    hAvgBandwidthVsLayer->SetBinContent(layer + 1, layerStats[layer].avgBandwidthGbps);
+    hPeakBandwidthVsLayer->SetBinContent(layer + 1, layerStats[layer].peakBandwidthGbps);
+  }
+
+  auto* canvBandwidthSummary = new TCanvas("canvBandwidthSummary", "Bandwidth summary by layer", 1050, 1050);
+  gStyle->SetOptTitle(0);
+  canvBandwidthSummary->cd();
+  canvBandwidthSummary->SetTopMargin(0.08);
+  canvBandwidthSummary->SetBottomMargin(0.14);
+  canvBandwidthSummary->SetLogy();
+  hAvgBandwidthVsLayer->SetTitle("Average bandwidth by layer;layer id;Bandwidth (Gbit/s)");
+  hAvgBandwidthVsLayer->Draw("hist");
+  hPeakBandwidthVsLayer->SetLineColor(kRed);
+  hPeakBandwidthVsLayer->Draw("hist same");
+  canvBandwidthSummary->BuildLegend(0.6, 0.75, 0.9, 0.9);
+  appendCanvasToPdf(canvBandwidthSummary);
+
+  if (lastPdfCanvas != nullptr) {
+    lastPdfCanvas->Print(Form("%s]", outputPdf.Data()));
   }
 
   f->Write();

From afa69e4b715bf1057de28ac8b85b04b8e3a69e53 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Fri, 15 Mar 2024 15:59:14 +0000
Subject: [PATCH 1557/1764] TPC Splines: fix initialization of the track
 residuals in the test macro

---
 .../macro/TPCFastTransformInit.C              | 43 ++++++++++++++++++-
 1 file changed, 41 insertions(+), 2 deletions(-)

diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 6b3756aca3b73..b13d031d6d10d 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -21,19 +21,24 @@
 /// root -l TPCFastTransformInit.C'("debugVoxRes.root")'
 ///
 
+#include "Algorithm/RangeTokenizer.h"
+
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
+#include <filesystem>
+#include <string>
 #include "TFile.h"
 #include "TSystem.h"
 #include "TTree.h"
 #include "TNtuple.h"
 #include "Riostream.h"
 
+#include "Algorithm/RangeTokenizer.h"
+#include "Framework/Logger.h"
 #include "GPU/TPCFastTransform.h"
 #include "SpacePoints/TrackResiduals.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h"
-
 #endif
 
 using namespace o2::tpc;
@@ -54,6 +59,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     corr->Draw("cx:y:z","iRoc==0&&iRow==10","")
     grid->Draw("cx:y:z","iRoc==0&&iRow==10","same")
     vox->Draw("vx:y:z","iRoc==0&&iRow==10","same")
+    points->Draw("px:y:z","iRoc==0&&iRow==10","same")
   */
 
   if (gSystem->AccessPathName(fileName)) {
@@ -75,15 +81,42 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     return;
   }
 
+  auto userInfo = voxResTree->GetUserInfo();
+
+  if (!userInfo->FindObject("y2xBinning") || !userInfo->FindObject("z2xBinning")) {
+    std::cout << "'y2xBinning' or 'z2xBinning' not found in UserInfo, but required to get the correct binning" << std::endl;
+    return;
+  }
+
+  userInfo->Print();
+
+  // required for the binning that was used
   o2::tpc::TrackResiduals trackResiduals;
-  trackResiduals.init(); // also initializes the default binning which was used
+  auto y2xBins = o2::RangeTokenizer::tokenize<float>(userInfo->FindObject("y2xBinning")->GetTitle());
+  auto z2xBins = o2::RangeTokenizer::tokenize<float>(userInfo->FindObject("z2xBinning")->GetTitle());
+  trackResiduals.setY2XBinning(y2xBins);
+  trackResiduals.setZ2XBinning(z2xBins);
+  trackResiduals.init();
+
+  std::cout << "y2xBins: " << y2xBins.size() << " z2xBins: " << z2xBins.size() << std::endl;
 
+  for (auto y2x : y2xBins) {
+    std::cout << "y2x: " << y2x << std::endl;
+  }
+
+  std::cout << std::endl;
+
+  for (auto z2x : z2xBins) {
+    std::cout << "z2x: " << z2x << std::endl;
+  }
   std::cout << "create fast transformation ... " << std::endl;
 
   auto* helper = o2::tpc::TPCFastTransformHelperO2::instance();
 
   o2::tpc::TPCFastSpaceChargeCorrectionHelper* corrHelper = o2::tpc::TPCFastSpaceChargeCorrectionHelper::instance();
 
+  corrHelper->setNthreadsToMaximum();
+
   auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, useSmoothed, invertSigns);
 
   std::unique_ptr<o2::gpu::TPCFastTransform> fastTransform(
@@ -162,6 +195,9 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   branch->SetAddress(&v);
   branch->SetAutoDelete(kTRUE);
 
+  int iRocLast = -1;
+  int iRowLast = -1;
+
   for (int32_t iVox = 0; iVox < voxResTree->GetEntriesFast(); iVox++) {
 
     voxResTree->GetEntry(iVox);
@@ -180,6 +216,9 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     int32_t iRoc = (int32_t)v->bsec;
     int32_t iRow = (int32_t)xBin;
 
+    iRocLast = iRoc;
+    iRowLast = iRow;
+
     double x = trackResiduals.getX(xBin); // radius of the pad row
 
     double y2x = trackResiduals.getY2X(

From f878d89be6c7b930f8f7c5b65979064d2418d8fb Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Fri, 15 Mar 2024 16:02:00 +0000
Subject: [PATCH 1558/1764] TPC Splines: fix propagation of the track residual
 data to the TPC row edges

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 389 +++++++++++++-----
 1 file changed, 279 insertions(+), 110 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index e2960c73e4d50..9910e2206ca11 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -118,6 +118,8 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
   // calculate correction map: dx,du,dv = ( origTransform() -> x,u,v) - fastTransformNominal:x,u,v
   // for the future: switch TOF correction off for a while
 
+  TStopwatch watch;
+
   if (!mIsInitialized) {
     initGeometry();
   }
@@ -176,6 +178,10 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
 
   } // slice
 
+  watch.Stop();
+
+  LOGP(info, "Space charge correction tooks: {}s", watch.RealTime());
+
   initInverse(correction, 0);
 }
 
@@ -380,20 +386,14 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 {
   // create o2::gpu::TPCFastSpaceChargeCorrection  from o2::tpc::TrackResiduals::VoxRes voxel tree
 
-  LOG(info) << "fast space charge correction helper: create correction using " << mNthreads << " threads";
+  LOG(info) << "fast space charge correction helper: create correction from track residuals using " << mNthreads << " threads";
+
+  TStopwatch watch1, watch2;
 
   std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> correctionPtr(new o2::gpu::TPCFastSpaceChargeCorrection);
 
   o2::gpu::TPCFastSpaceChargeCorrection& correction = *correctionPtr;
 
-  // o2::tpc::TrackResiduals::VoxRes* v = nullptr;
-  // voxResTree->SetBranchAddress("voxRes", &v);
-
-  o2::tpc::TrackResiduals::VoxRes* v = nullptr;
-  TBranch* branch = voxResTree->GetBranch("voxRes");
-  branch->SetAddress(&v);
-  branch->SetAutoDelete(kTRUE);
-
   auto* helper = o2::tpc::TPCFastSpaceChargeCorrectionHelper::instance();
   const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
@@ -417,9 +417,11 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   // std::cout << "n knots Y: " << nKnotsY << std::endl;
   // std::cout << "n knots Z: " << nKnotsZ << std::endl;
 
+  const int nRows = geo.getNumberOfRows();
+  const int nROCs = geo.getNumberOfSlices();
+
   { // create the correction object
 
-    const int nRows = geo.getNumberOfRows();
     const int nCorrectionScenarios = 1;
 
     correction.startConstruction(geo, nCorrectionScenarios);
@@ -451,131 +453,298 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
   LOG(info) << "fast space charge correction helper: fill data points from track residuals";
 
-  for (int iVox = 0; iVox < voxResTree->GetEntriesFast(); iVox++) {
-
-    voxResTree->GetEntry(iVox);
-    auto xBin =
-      v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
-    auto y2xBin =
-      v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
-    auto z2xBin =
-      v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
-
-    int iRoc = (int)v->bsec;
-    int iRow = (int)xBin;
+  // o2::tpc::TrackResiduals::VoxRes* v = nullptr;
+  // voxResTree->SetBranchAddress("voxRes", &v);
 
-    // x,y,z of the voxel in local TPC coordinates
+  o2::tpc::TrackResiduals::VoxRes* v = nullptr;
+  TBranch* branch = voxResTree->GetBranch("voxRes");
+  branch->SetAddress(&v);
+  branch->SetAutoDelete(kTRUE);
 
-    double x = trackResiduals.getX(xBin); // radius of the pad row
-    double y2x = trackResiduals.getY2X(
-      xBin, y2xBin); // y/x coordinate of the bin ~-0.15 ... 0.15
-    double z2x =
-      trackResiduals.getZ2X(z2xBin); // z/x coordinate of the bin 0.1 .. 0.9
-    double y = x * y2x;
-    double z = x * z2x;
+  // find the first and the last voxel for each ROC
+  // we assume the data is sorted by ROC, othwerwise it will be read nROCs times
 
-    if (iRoc >= geo.getNumberOfSlicesA()) {
-      z = -z;
-      // y = -y;
-    }
+  std::vector<int> vROCdataFirst(nROCs, -1);
+  std::vector<int> vROCdataLast(nROCs, -2);
 
-    {
-      float sx, sy, sz;
-      trackResiduals.getVoxelCoordinates(iRoc, xBin, y2xBin, z2xBin, sx, sy, sz);
-      sy *= x;
-      sz *= x;
-      if (fabs(sx - x) + fabs(sy - y) + fabs(sz - z) > 1.e-4) {
-        std::cout << "wrong coordinates: " << x << " " << y << " " << z << " / " << sx << " " << sy << " " << sz << std::endl;
+  {
+    int iRocLast = -1;
+    bool isSorted = true;
+    for (int iVox = 0; iVox < voxResTree->GetEntriesFast(); iVox++) {
+      voxResTree->GetEntry(iVox);
+      int iRoc = (int)v->bsec;
+      // ensure the data is in the expacted order
+      if (iRoc < iRocLast) {
+        isSorted = false;
+      }
+      iRocLast = iRoc;
+      if (iRoc < 0 || iRoc >= nROCs) {
+        LOG(fatal) << "ROC number " << iRoc << " is out of range";
       }
+      if (vROCdataFirst[iRoc] < 0) {
+        vROCdataFirst[iRoc] = iVox;
+      }
+      vROCdataLast[iRoc] = iVox;
     }
-
-    // skip empty voxels
-    float voxEntries = v->stat[o2::tpc::TrackResiduals::VoxV];
-    if (voxEntries < 1.) { // no statistics
-      continue;
+    if (!isSorted) {
+      LOG(warning) << "Data is not sorted by ROC as expected";
     }
+  }
 
-    // double statX = v->stat[o2::tpc::TrackResiduals::VoxX]; // weight
-    // double statY = v->stat[o2::tpc::TrackResiduals::VoxF]; // weight
-    // double statZ = v->stat[o2::tpc::TrackResiduals::VoxZ]; // weight
-
-    // double dx = 1. / trackResiduals.getDXI(xBin);
-    double dy = x / trackResiduals.getDY2XI(xBin, y2xBin);
-    double dz = x * trackResiduals.getDZ2X(z2xBin);
-
-    double correctionX = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
-    double correctionY = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
-    double correctionZ = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
-    if (invertSigns) {
-      correctionX *= -1.;
-      correctionY *= -1.;
-      correctionZ *= -1.;
-    }
-    // add one point per voxel
+  // read the data ROC by ROC
 
-    // map.addCorrectionPoint(iRoc, iRow, y, z, correctionX, correctionY,
-    //                     correctionZ);
+  // data in the tree is not sorted by row
+  // first find which data belong to which row
 
-    // add several points per voxel,
-    // extend values of the edge voxels to the edges of the TPC row
-    //
+  struct VoxelData {
+    int mNentries{0};    // number of entries
+    float mCx, mCy, mCz; // corrections to the local coordinates
+  };
 
-    double yFirst = y - dy / 2.;
-    double yLast = y + dy / 2.;
+  std::vector<VoxelData> vRocData[nRows];
+  for (int ir = 0; ir < nRows; ir++) {
+    vRocData[ir].resize(nY2Xbins * nZ2Xbins);
+  }
 
-    if (y2xBin == 0) { // extend value of the first Y bin to the row edge
-      float u, v;
-      if (iRoc < geo.getNumberOfSlicesA()) {
-        geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
-      } else {
-        geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
+  struct Voxel {
+    float mY, mZ;            // not-distorted local coordinates
+    float mDy, mDz;          // bin size
+    int mSmoothingStep{100}; // is the voxel data original or smoothed at this step
+  };
+
+  std::vector<Voxel> vRowVoxels(nY2Xbins * nZ2Xbins);
+
+  for (int iRoc = 0; iRoc < nROCs; iRoc++) {
+
+    for (int ir = 0; ir < nRows; ir++) {
+      for (int iv = 0; iv < nY2Xbins * nZ2Xbins; iv++) {
+        vRocData[ir][iv].mNentries = 0;
       }
-      float py, pz;
-      geo.convUVtoLocal(iRoc, u, v, py, pz);
-      yFirst = py;
     }
 
-    if (y2xBin == trackResiduals.getNY2XBins() - 1) { // extend value of the last Y bin to the row edge
-      float u, v;
-      if (iRoc < geo.getNumberOfSlicesA()) {
-        geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
-      } else {
-        geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
+    for (int iVox = vROCdataFirst[iRoc]; iVox <= vROCdataLast[iRoc]; iVox++) {
+      voxResTree->GetEntry(iVox);
+      if ((int)v->bsec != iRoc) {
+        LOG(fatal) << "ROC number " << v->bsec << " is not equal to " << iRoc;
+        continue;
+      }
+      int iRow = (int)v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
+      if (iRow < 0 || iRow >= nRows) {
+        LOG(fatal) << "Row number " << iRow << " is out of range";
       }
-      float py, pz;
-      geo.convUVtoLocal(iRoc, u, v, py, pz);
-      yLast = py;
+      int iy = v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
+      int iz = v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
+      auto& vox = vRocData[iRow][iy * nZ2Xbins + iz];
+      vox.mNentries = (int)v->stat[o2::tpc::TrackResiduals::VoxV];
+      vox.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
+      vox.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
+      vox.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
     }
 
-    double z0 = 0.;
-    if (iRoc < geo.getNumberOfSlicesA()) {
-      z0 = geo.getTPCzLengthA();
-    } else {
-      z0 = -geo.getTPCzLengthC();
-    }
+    // now process the data row-by-row
+
+    for (int iRow = 0; iRow < nRows; iRow++) {
+
+      // LOG(info) << "Processing ROC " << iRoc << " row " << iRow;
+
+      // complete the voxel data
+      {
+        int xBin = iRow;
+        double x = trackResiduals.getX(xBin); // radius of the pad row
+        bool isDataFound = false;
+        for (int iy = 0; iy < nY2Xbins; iy++) {
+          for (int iz = 0; iz < nZ2Xbins; iz++) {
+            auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+            auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+            // y/x coordinate of the bin ~-0.15 ... 0.15
+            double y2x = trackResiduals.getY2X(xBin, iy);
+            // z/x coordinate of the bin 0.1 .. 0.9
+            double z2x = trackResiduals.getZ2X(iz);
+            vox.mY = x * y2x;
+            vox.mZ = x * z2x;
+            vox.mDy = x / trackResiduals.getDY2XI(xBin, iy);
+            vox.mDz = x * trackResiduals.getDZ2X(iz);
+            if (iRoc >= geo.getNumberOfSlicesA()) {
+              vox.mZ = -vox.mZ;
+            }
+            if (data.mNentries < 1) { // no data
+              data.mCx = 0.;
+              data.mCy = 0.;
+              data.mCz = 0.;
+              vox.mSmoothingStep = 100;
+            } else { // voxel contains data
+              if (invertSigns) {
+                data.mCx *= -1.;
+                data.mCy *= -1.;
+                data.mCz *= -1.;
+              }
+              vox.mSmoothingStep = 0; // original data
+              isDataFound = true;
+            }
+          }
+        }
 
-    double yStep = (yLast - yFirst) / 2;
+        if (!isDataFound) { // fill everything with 0
+          for (int iy = 0; iy < nY2Xbins; iy++) {
+            for (int iz = 0; iz < nZ2Xbins; iz++) {
+              vRowVoxels[iy * nZ2Xbins + iz].mSmoothingStep = 0;
+            }
+          }
+        }
+      } // complete the voxel data
+
+      // repare the voxel data: fill empty voxels
+
+      int nRepairs = 0;
+
+      for (int ismooth = 1; ismooth <= 2; ismooth++) {
+        for (int iy = 0; iy < nY2Xbins; iy++) {
+          for (int iz = 0; iz < nZ2Xbins; iz++) {
+            auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+            auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+            if (vox.mSmoothingStep <= ismooth) { // already filled
+              continue;
+            }
+            nRepairs++;
+            data.mCx = 0.;
+            data.mCy = 0.;
+            data.mCz = 0.;
+            double w = 0.;
+            bool filled = false;
+            auto update = [&](int iy1, int iz1) {
+              auto& data1 = vRocData[iRow][iy1 * nZ2Xbins + iz1];
+              auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
+              if (vox1.mSmoothingStep >= ismooth) {
+                return false;
+              }
+              double w1 = 1. / (abs(iy - iy1) + abs(iz - iz1) + 1);
+              data.mCx += w1 * data1.mCx;
+              data.mCy += w1 * data1.mCy;
+              data.mCz += w1 * data1.mCz;
+              w += w1;
+              filled = true;
+              return true;
+            };
+
+            for (int iy1 = iy - 1; iy1 >= 0 && !update(iy1, iz); iy1--) {
+            }
+            for (int iy1 = iy + 1; iy1 < nY2Xbins && !update(iy1, iz); iy1++) {
+            }
+            for (int iz1 = iz - 1; iz1 >= 0 && !update(iy, iz1); iz1--) {
+            }
+            for (int iz1 = iz + 1; iz1 < nZ2Xbins && !update(iy, iz1); iz1++) {
+            }
 
-    for (double py = yFirst; py <= yLast + yStep / 2.; py += yStep) {
+            if (filled) {
+              data.mCx /= w;
+              data.mCy /= w;
+              data.mCz /= w;
+              vox.mSmoothingStep = ismooth;
+            }
+          } // iz
+        }   // iy
+      }     // ismooth
 
-      for (double pz = z - dz / 2.; pz <= z + dz / 2. + 1.e-4; pz += dz / 2.) {
-        map.addCorrectionPoint(iRoc, iRow, py, pz, correctionX, correctionY,
-                               correctionZ);
+      if (nRepairs > 0) {
+        LOG(info) << "ROC " << iRoc << " row " << iRow << ": " << nRepairs << " voxel repairs for " << nY2Xbins * nZ2Xbins << " voxels";
       }
 
-      if (z2xBin == trackResiduals.getNZ2XBins() - 1) {
-        // extend value of the first Z bin to the readout, linear decrease of all values to 0.
-        int nZsteps = 3;
-        for (int is = 0; is < nZsteps; is++) {
-          double pz = z + (z0 - z) * (is + 1.) / nZsteps;
-          double s = (nZsteps - 1. - is) / nZsteps;
-          map.addCorrectionPoint(iRoc, iRow, py, pz, s * correctionX,
-                                 s * correctionY, s * correctionZ);
+      // feed the row data to the helper
+
+      double yMin = 0., yMax = 0.;
+
+      {
+        float u, v;
+        if (iRoc < geo.getNumberOfSlicesA()) {
+          geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
+        } else {
+          geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
         }
+        float py, pz;
+        geo.convUVtoLocal(iRoc, u, v, py, pz);
+        yMin = py;
       }
-    }
-  }
+      {
+        float u, v;
+        if (iRoc < geo.getNumberOfSlicesA()) {
+          geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
+        } else {
+          geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
+        }
+        float py, pz;
+        geo.convUVtoLocal(iRoc, u, v, py, pz);
+        yMax = py;
+      }
+
+      double zEdge = 0.;
+      if (iRoc < geo.getNumberOfSlicesA()) {
+        zEdge = geo.getTPCzLengthA();
+      } else {
+        zEdge = -geo.getTPCzLengthC();
+      }
+
+      for (int iy = 0; iy < nY2Xbins; iy++) {
+        for (int iz = 0; iz < nZ2Xbins; iz++) {
+          auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+          auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+          if (vox.mSmoothingStep > 2) {
+            LOG(fatal) << "empty voxel is not repared";
+          }
+
+          double y = vox.mY;
+          double z = vox.mZ;
+          double dy = vox.mDy;
+          double dz = vox.mDz;
+          double correctionX = data.mCx;
+          double correctionY = data.mCy;
+          double correctionZ = data.mCz;
+
+          double yFirst = y - dy / 2.;
+          double yLast = y + dy / 2.;
+
+          if (iy == 0) { // extend value of the first Y bin to the row edge
+            yFirst = yMin;
+          }
+
+          if (iy == nY2Xbins - 1) { // extend value of the last Y bin to the row edge
+            yLast = yMax;
+          }
+
+          double yStep = (yLast - yFirst) / 2;
+
+          for (double py = yFirst; py <= yLast + yStep / 2.; py += yStep) {
+
+            for (double pz = z - dz / 2.; pz <= z + dz / 2. + 1.e-4; pz += dz / 2.) {
+              map.addCorrectionPoint(iRoc, iRow, py, pz, correctionX, correctionY,
+                                     correctionZ);
+            }
+
+            if (iz == nZ2Xbins - 1) {
+              // extend value of the first Z bin to the readout, linear decrease of all values to 0.
+              int nZsteps = 3;
+              for (int is = 0; is < nZsteps; is++) {
+                double pz = z + (zEdge - z) * (is + 1.) / nZsteps;
+                double s = (nZsteps - 1. - is) / nZsteps;
+                map.addCorrectionPoint(iRoc, iRow, py, pz, s * correctionX,
+                                       s * correctionY, s * correctionZ);
+              }
+            }
+          }
+        } // iz
+      }   // iy
+
+    } // iRow
+
+  } // iRoc
+
+  LOGP(info, "Reading & reparing of the track residuals tooks: {}s", watch1.RealTime());
+
+  LOG(info) << "fast space charge correction helper: create space charge from the map of data points..";
+
   helper->fillSpaceChargeCorrectionFromMap(correction);
+
+  LOGP(info, "Creation from track residuals tooks in total: {}s", watch2.RealTime());
+
   return std::move(correctionPtr);
 }
 
@@ -814,7 +983,7 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
 
   } // slice
   float duration = watch.RealTime();
-  LOGP(info, "Inverse took: {}s", duration);
+  LOGP(info, "Inverse tooks: {}s", duration);
 }
 
 } // namespace tpc

From e42a6256596eb57e022d037ca74cf1de11460e66 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Mon, 15 Apr 2024 14:41:19 +0000
Subject: [PATCH 1559/1764] TPC Splines: non-uniform grid that corresponds to
 the track residual voxels

---
 .../include/SpacePoints/TrackResiduals.h      |  19 +-
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 530 ++++++++++--------
 .../TPCFastSpaceChargeCorrection.cxx          | 181 +++---
 .../TPCFastSpaceChargeCorrection.h            |  64 +--
 .../TPCFastTransformGeo.h                     |   9 +
 .../macro/TPCFastTransformInit.C              | 203 +++++--
 6 files changed, 619 insertions(+), 387 deletions(-)

diff --git a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h
index 2ade12d951c58..c9226589ec703 100644
--- a/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h
+++ b/Detectors/TPC/calibration/SpacePoints/include/SpacePoints/TrackResiduals.h
@@ -318,9 +318,14 @@ class TrackResiduals
   void getVoxelCoordinates(int isec, int ix, int ip, int iz, float& x, float& p, float& z) const;
 
   /// Calculates the x-coordinate for given x bin.
-  /// \param i Bin index
+  /// \param ix Bin index in x
   /// \return Coordinate in X
-  float getX(int i) const;
+  float getX(int ix) const;
+
+  /// Calculates the max y/x-coordinate for given x bin taking the dead zone into account.
+  /// \param ix Bin index in x
+  /// \return Max coordinate in Y/X
+  float getMaxY2X(int ix) const;
 
   /// Calculates the y/x-coordinate.
   /// \param ix Bin index in X
@@ -560,9 +565,15 @@ inline float TrackResiduals::getDXI(int ix) const
 }
 
 //_____________________________________________________
-inline float TrackResiduals::getX(int i) const
+inline float TrackResiduals::getX(int ix) const
+{
+  return mUniformBins[VoxX] ? param::MinX + (ix + 0.5) * mDX : param::RowX[ix];
+}
+
+//_____________________________________________________
+inline float TrackResiduals::getMaxY2X(int ix) const
 {
-  return mUniformBins[VoxX] ? param::MinX + (i + 0.5) * mDX : param::RowX[i];
+  return mMaxY2X[ix];
 }
 
 //_____________________________________________________
diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 9910e2206ca11..861cacbe00012 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -29,6 +29,8 @@
 #include <fairlogger/Logger.h>
 #include <thread>
 #include "TStopwatch.h"
+#include "TTreeReader.h"
+#include "TTreeReaderValue.h"
 
 using namespace o2::gpu;
 
@@ -154,7 +156,7 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
             pointCorr[3 * i + 1] = du;
             pointCorr[3 * i + 2] = dv;
           }
-          helper.approximateDataPoints(spline, splineParameters, 0., spline.getGridX1().getNumberOfKnots() - 1, 0., spline.getGridX2().getNumberOfKnots() - 1, &pointSU[0],
+          helper.approximateDataPoints(spline, splineParameters, 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), &pointSU[0],
                                        &pointSV[0], &pointCorr[0], nDataPoints);
         } else {
           for (int i = 0; i < spline.getNumberOfParameters(); i++) {
@@ -388,7 +390,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
   LOG(info) << "fast space charge correction helper: create correction from track residuals using " << mNthreads << " threads";
 
-  TStopwatch watch1, watch2;
+  TStopwatch watch, watch1;
 
   std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> correctionPtr(new o2::gpu::TPCFastSpaceChargeCorrection);
 
@@ -403,17 +405,90 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   int nY2Xbins = trackResiduals.getNY2XBins();
   int nZ2Xbins = trackResiduals.getNZ2XBins();
 
-  int nKnotsY = nY2Xbins / 2;
-  int nKnotsZ = nZ2Xbins / 2;
+  std::vector<int> yBinsInt;
+  {
+    std::vector<double> yBins;
+    yBins.reserve(nY2Xbins);
+    for (int i = 0, j = nY2Xbins - 1; i <= j; i += 2, j -= 2) {
+      if (i == j) {
+        yBins.push_back(trackResiduals.getY2X(0, i));
+      } else if (i + 1 == j) {
+        yBins.push_back(trackResiduals.getY2X(0, i));
+      } else {
+        yBins.push_back(trackResiduals.getY2X(0, i));
+        yBins.push_back(trackResiduals.getY2X(0, j));
+      }
+    }
+    std::sort(yBins.begin(), yBins.end());
+    double dy = yBins[1] - yBins[0];
+    for (int i = 1; i < yBins.size(); i++) {
+      if (yBins[i] - yBins[i - 1] < dy) {
+        dy = yBins[i] - yBins[i - 1];
+      }
+    }
+    yBinsInt.reserve(yBins.size());
+    // spline knots must be positioned on the grid with integer internal coordinate
+    // take the knot position accuracy of 0.1*dy
+    dy = dy / 10.;
+    double y0 = yBins[0];
+    double y1 = yBins[yBins.size() - 1];
+    for (auto& y : yBins) {
+      y -= y0;
+      int iy = int(y / dy + 0.5);
+      yBinsInt.push_back(iy);
+      double yold = y / (y1 - y0) * 2 - 1.;
+      y = iy * dy;
+      y = y / (y1 - y0) * 2 - 1.;
+      LOG(info) << "convert y bin: " << yold << " -> " << y << " -> " << iy;
+    }
+  }
+
+  std::vector<int> zBinsInt;
+  {
+    std::vector<double> zBins;
+    zBins.reserve(nZ2Xbins);
+    for (int i = 0; i < nZ2Xbins; i += 2) {
+      zBins.push_back(-trackResiduals.getZ2X(i));
+    }
+    std::sort(zBins.begin(), zBins.end());
+    double dz = zBins[1] - zBins[0];
+    for (int i = 1; i < zBins.size(); i++) {
+      if (zBins[i] - zBins[i - 1] < dz) {
+        dz = zBins[i] - zBins[i - 1];
+      }
+    }
+    zBinsInt.reserve(zBins.size());
+    // spline knots must be positioned on the grid with an integer internal coordinate
+    // lets copy the knot positions with the accuracy of 0.1*dz
+    dz = dz / 10.;
+    double z0 = zBins[0];
+    double z1 = zBins[zBins.size() - 1];
+    for (auto& z : zBins) {
+      z -= z0;
+      int iz = int(z / dz + 0.5);
+      zBinsInt.push_back(iz);
+      double zold = z / (z1 - z0);
+      z = iz * dz;
+      z = z / (z1 - z0);
+      LOG(info) << "convert z bin: " << zold << " -> " << z << " -> " << iz;
+    }
+  }
 
-  if (nKnotsY < 2) {
-    nKnotsY = 2;
+  if (yBinsInt.size() < 2) {
+    yBinsInt.clear();
+    yBinsInt.push_back(0);
+    yBinsInt.push_back(1);
   }
 
-  if (nKnotsZ < 2) {
-    nKnotsZ = 2;
+  if (zBinsInt.size() < 2) {
+    zBinsInt.clear();
+    zBinsInt.push_back(0);
+    zBinsInt.push_back(1);
   }
 
+  int nKnotsY = yBinsInt.size();
+  int nKnotsZ = zBinsInt.size();
+
   // std::cout << "n knots Y: " << nKnotsY << std::endl;
   // std::cout << "n knots Z: " << nKnotsZ << std::endl;
 
@@ -432,64 +507,42 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
     }
     { // init spline scenario
       TPCFastSpaceChargeCorrection::SplineType spline;
-      spline.recreate(nKnotsY, nKnotsZ);
+      spline.recreate(nKnotsY, &yBinsInt[0], nKnotsZ, &zBinsInt[0]);
       correction.setSplineScenario(0, spline);
     }
     correction.finishConstruction();
   } // .. create the correction object
 
-  // set the grid borders in Z to Z/X==1
+  // set the grid borders
   for (int iRoc = 0; iRoc < geo.getNumberOfSlices(); iRoc++) {
     for (int iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
-      auto rowInfo = geo.getRowInfo(iRow);
-      o2::gpu::TPCFastSpaceChargeCorrection::SliceRowInfo& info = correction.getSliceRowInfo(iRoc, iRow);
-      double len = geo.getTPCzLength(iRoc);
-      info.gridV0 = len - rowInfo.x;
-      if (info.gridV0 < 0.) {
-        info.gridV0 = 0.;
-      }
+      const auto& rowInfo = geo.getRowInfo(iRow);
+      auto& info = correction.getSliceRowInfo(iRoc, iRow);
+      const auto& spline = correction.getSpline(iRoc, iRow);
+      double yMin = rowInfo.x * trackResiduals.getY2X(iRow, 0);
+      double yMax = rowInfo.x * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
+      double zMin = rowInfo.x * trackResiduals.getZ2X(0);
+      double zMax = rowInfo.x * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
+      double uMin = yMin;
+      double uMax = yMax;
+      double vMin = geo.getTPCzLength(iRoc) - zMax;
+      double vMax = geo.getTPCzLength(iRoc) - zMin;
+      // std::cout << " uMin: " << uMin << " uMax: " << yuMax << " zMin: " << vMin << " zMax: " << vMax << std::endl;
+      info.gridU0 = uMin;
+      info.scaleUtoGrid = spline.getGridX1().getUmax() / (uMax - uMin);
+      info.gridV0 = vMin;
+      info.scaleVtoGrid = spline.getGridX2().getUmax() / (vMax - vMin);
     }
   }
 
-  LOG(info) << "fast space charge correction helper: fill data points from track residuals";
-
-  // o2::tpc::TrackResiduals::VoxRes* v = nullptr;
-  // voxResTree->SetBranchAddress("voxRes", &v);
+  LOG(info) << "fast space charge correction helper: preparation took " << watch1.RealTime() << "s";
 
-  o2::tpc::TrackResiduals::VoxRes* v = nullptr;
-  TBranch* branch = voxResTree->GetBranch("voxRes");
-  branch->SetAddress(&v);
-  branch->SetAutoDelete(kTRUE);
+  LOG(info) << "fast space charge correction helper: fill data points from track residuals.. ";
 
-  // find the first and the last voxel for each ROC
-  // we assume the data is sorted by ROC, othwerwise it will be read nROCs times
+  TStopwatch watch3;
 
-  std::vector<int> vROCdataFirst(nROCs, -1);
-  std::vector<int> vROCdataLast(nROCs, -2);
-
-  {
-    int iRocLast = -1;
-    bool isSorted = true;
-    for (int iVox = 0; iVox < voxResTree->GetEntriesFast(); iVox++) {
-      voxResTree->GetEntry(iVox);
-      int iRoc = (int)v->bsec;
-      // ensure the data is in the expacted order
-      if (iRoc < iRocLast) {
-        isSorted = false;
-      }
-      iRocLast = iRoc;
-      if (iRoc < 0 || iRoc >= nROCs) {
-        LOG(fatal) << "ROC number " << iRoc << " is out of range";
-      }
-      if (vROCdataFirst[iRoc] < 0) {
-        vROCdataFirst[iRoc] = iVox;
-      }
-      vROCdataLast[iRoc] = iVox;
-    }
-    if (!isSorted) {
-      LOG(warning) << "Data is not sorted by ROC as expected";
-    }
-  }
+  // TTreeProcessorMT treeProcessor(*voxResTree); // multi-threaded tree processor
+  // treeProcessor.Init(voxResTree);
 
   // read the data ROC by ROC
 
@@ -506,14 +559,6 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
     vRocData[ir].resize(nY2Xbins * nZ2Xbins);
   }
 
-  struct Voxel {
-    float mY, mZ;            // not-distorted local coordinates
-    float mDy, mDz;          // bin size
-    int mSmoothingStep{100}; // is the voxel data original or smoothed at this step
-  };
-
-  std::vector<Voxel> vRowVoxels(nY2Xbins * nZ2Xbins);
-
   for (int iRoc = 0; iRoc < nROCs; iRoc++) {
 
     for (int ir = 0; ir < nRows; ir++) {
@@ -522,10 +567,17 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       }
     }
 
-    for (int iVox = vROCdataFirst[iRoc]; iVox <= vROCdataLast[iRoc]; iVox++) {
-      voxResTree->GetEntry(iVox);
+    const int rocDataStart = iRoc * trackResiduals.getNVoxelsPerSector();
+    const int rocDataEnd = rocDataStart + trackResiduals.getNVoxelsPerSector();
+
+    TTreeReader reader(voxResTree);
+    reader.SetEntriesRange(rocDataStart, rocDataEnd);
+    TTreeReaderValue<o2::tpc::TrackResiduals::VoxRes> v(reader, "voxRes");
+    for (int iVox = rocDataStart; iVox < rocDataEnd; iVox++) {
+      reader.Next();
+      // voxResTree->GetEntry(iVox);
       if ((int)v->bsec != iRoc) {
-        LOG(fatal) << "ROC number " << v->bsec << " is not equal to " << iRoc;
+        LOG(fatal) << "Error reading voxels: voxel ROC number " << v->bsec << " is not equal to the expected " << iRoc;
         continue;
       }
       int iRow = (int)v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
@@ -543,207 +595,237 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
     // now process the data row-by-row
 
-    for (int iRow = 0; iRow < nRows; iRow++) {
+    auto myThread = [&](int iThread, int nTreads) {
+      struct Voxel {
+        float mY, mZ;            // not-distorted local coordinates
+        float mDy, mDz;          // bin size
+        int mSmoothingStep{100}; // is the voxel data original or smoothed at this step
+      };
 
-      // LOG(info) << "Processing ROC " << iRoc << " row " << iRow;
+      std::vector<Voxel> vRowVoxels(nY2Xbins * nZ2Xbins);
 
-      // complete the voxel data
-      {
-        int xBin = iRow;
-        double x = trackResiduals.getX(xBin); // radius of the pad row
-        bool isDataFound = false;
-        for (int iy = 0; iy < nY2Xbins; iy++) {
-          for (int iz = 0; iz < nZ2Xbins; iz++) {
-            auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
-            auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
-            // y/x coordinate of the bin ~-0.15 ... 0.15
-            double y2x = trackResiduals.getY2X(xBin, iy);
-            // z/x coordinate of the bin 0.1 .. 0.9
-            double z2x = trackResiduals.getZ2X(iz);
-            vox.mY = x * y2x;
-            vox.mZ = x * z2x;
-            vox.mDy = x / trackResiduals.getDY2XI(xBin, iy);
-            vox.mDz = x * trackResiduals.getDZ2X(iz);
-            if (iRoc >= geo.getNumberOfSlicesA()) {
-              vox.mZ = -vox.mZ;
-            }
-            if (data.mNentries < 1) { // no data
-              data.mCx = 0.;
-              data.mCy = 0.;
-              data.mCz = 0.;
-              vox.mSmoothingStep = 100;
-            } else { // voxel contains data
-              if (invertSigns) {
-                data.mCx *= -1.;
-                data.mCy *= -1.;
-                data.mCz *= -1.;
+      for (int iRow = iThread; iRow < nRows; iRow += nTreads) {
+        // LOG(info) << "Processing ROC " << iRoc << " row " << iRow;
+
+        // complete the voxel data
+
+        {
+          int xBin = iRow;
+          double x = trackResiduals.getX(xBin); // radius of the pad row
+          bool isDataFound = false;
+          for (int iy = 0; iy < nY2Xbins; iy++) {
+            for (int iz = 0; iz < nZ2Xbins; iz++) {
+              auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+              auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+              // y/x coordinate of the bin ~-0.15 ... 0.15
+              double y2x = trackResiduals.getY2X(xBin, iy);
+              // z/x coordinate of the bin 0.1 .. 0.9
+              double z2x = trackResiduals.getZ2X(iz);
+              vox.mY = x * y2x;
+              vox.mZ = x * z2x;
+              vox.mDy = x / trackResiduals.getDY2XI(xBin, iy);
+              vox.mDz = x * trackResiduals.getDZ2X(iz);
+              if (iRoc >= geo.getNumberOfSlicesA()) {
+                vox.mZ = -vox.mZ;
+              }
+              if (data.mNentries < 1) { // no data
+                data.mCx = 0.;
+                data.mCy = 0.;
+                data.mCz = 0.;
+                vox.mSmoothingStep = 100;
+              } else { // voxel contains data
+                if (invertSigns) {
+                  data.mCx *= -1.;
+                  data.mCy *= -1.;
+                  data.mCz *= -1.;
+                }
+                vox.mSmoothingStep = 0; // original data
+                isDataFound = true;
               }
-              vox.mSmoothingStep = 0; // original data
-              isDataFound = true;
             }
           }
-        }
 
-        if (!isDataFound) { // fill everything with 0
-          for (int iy = 0; iy < nY2Xbins; iy++) {
-            for (int iz = 0; iz < nZ2Xbins; iz++) {
-              vRowVoxels[iy * nZ2Xbins + iz].mSmoothingStep = 0;
+          if (!isDataFound) { // fill everything with 0
+            for (int iy = 0; iy < nY2Xbins; iy++) {
+              for (int iz = 0; iz < nZ2Xbins; iz++) {
+                vRowVoxels[iy * nZ2Xbins + iz].mSmoothingStep = 0;
+              }
             }
           }
-        }
-      } // complete the voxel data
+        } // complete the voxel data
 
-      // repare the voxel data: fill empty voxels
+        // repare the voxel data: fill empty voxels
 
-      int nRepairs = 0;
+        int nRepairs = 0;
 
-      for (int ismooth = 1; ismooth <= 2; ismooth++) {
-        for (int iy = 0; iy < nY2Xbins; iy++) {
-          for (int iz = 0; iz < nZ2Xbins; iz++) {
-            auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
-            auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
-            if (vox.mSmoothingStep <= ismooth) { // already filled
-              continue;
-            }
-            nRepairs++;
-            data.mCx = 0.;
-            data.mCy = 0.;
-            data.mCz = 0.;
-            double w = 0.;
-            bool filled = false;
-            auto update = [&](int iy1, int iz1) {
-              auto& data1 = vRocData[iRow][iy1 * nZ2Xbins + iz1];
-              auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
-              if (vox1.mSmoothingStep >= ismooth) {
-                return false;
+        for (int ismooth = 1; ismooth <= 2; ismooth++) {
+          for (int iy = 0; iy < nY2Xbins; iy++) {
+            for (int iz = 0; iz < nZ2Xbins; iz++) {
+              auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+              auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+              if (vox.mSmoothingStep <= ismooth) { // already filled
+                continue;
+              }
+              nRepairs++;
+              data.mCx = 0.;
+              data.mCy = 0.;
+              data.mCz = 0.;
+              double w = 0.;
+              bool filled = false;
+              auto update = [&](int iy1, int iz1) {
+                auto& data1 = vRocData[iRow][iy1 * nZ2Xbins + iz1];
+                auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
+                if (vox1.mSmoothingStep >= ismooth) {
+                  return false;
+                }
+                double w1 = 1. / (abs(iy - iy1) + abs(iz - iz1) + 1);
+                data.mCx += w1 * data1.mCx;
+                data.mCy += w1 * data1.mCy;
+                data.mCz += w1 * data1.mCz;
+                w += w1;
+                filled = true;
+                return true;
+              };
+
+              for (int iy1 = iy - 1; iy1 >= 0 && !update(iy1, iz); iy1--) {
+              }
+              for (int iy1 = iy + 1; iy1 < nY2Xbins && !update(iy1, iz); iy1++) {
+              }
+              for (int iz1 = iz - 1; iz1 >= 0 && !update(iy, iz1); iz1--) {
+              }
+              for (int iz1 = iz + 1; iz1 < nZ2Xbins && !update(iy, iz1); iz1++) {
               }
-              double w1 = 1. / (abs(iy - iy1) + abs(iz - iz1) + 1);
-              data.mCx += w1 * data1.mCx;
-              data.mCy += w1 * data1.mCy;
-              data.mCz += w1 * data1.mCz;
-              w += w1;
-              filled = true;
-              return true;
-            };
-
-            for (int iy1 = iy - 1; iy1 >= 0 && !update(iy1, iz); iy1--) {
-            }
-            for (int iy1 = iy + 1; iy1 < nY2Xbins && !update(iy1, iz); iy1++) {
-            }
-            for (int iz1 = iz - 1; iz1 >= 0 && !update(iy, iz1); iz1--) {
-            }
-            for (int iz1 = iz + 1; iz1 < nZ2Xbins && !update(iy, iz1); iz1++) {
-            }
 
-            if (filled) {
-              data.mCx /= w;
-              data.mCy /= w;
-              data.mCz /= w;
-              vox.mSmoothingStep = ismooth;
-            }
-          } // iz
-        }   // iy
-      }     // ismooth
+              if (filled) {
+                data.mCx /= w;
+                data.mCy /= w;
+                data.mCz /= w;
+                vox.mSmoothingStep = ismooth;
+              }
+            } // iz
+          }   // iy
+        }     // ismooth
 
-      if (nRepairs > 0) {
-        LOG(info) << "ROC " << iRoc << " row " << iRow << ": " << nRepairs << " voxel repairs for " << nY2Xbins * nZ2Xbins << " voxels";
-      }
+        if (nRepairs > 0) {
+          LOG(debug) << "ROC " << iRoc << " row " << iRow << ": " << nRepairs << " voxel repairs for " << nY2Xbins * nZ2Xbins << " voxels";
+        }
 
-      // feed the row data to the helper
+        // feed the row data to the helper
 
-      double yMin = 0., yMax = 0.;
+        double yMin = 0., yMax = 0.;
 
-      {
-        float u, v;
-        if (iRoc < geo.getNumberOfSlicesA()) {
-          geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
-        } else {
-          geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
+        {
+          float u, v;
+          if (iRoc < geo.getNumberOfSlicesA()) {
+            geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
+          } else {
+            geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
+          }
+          float py, pz;
+          geo.convUVtoLocal(iRoc, u, v, py, pz);
+          yMin = py;
         }
-        float py, pz;
-        geo.convUVtoLocal(iRoc, u, v, py, pz);
-        yMin = py;
-      }
-      {
-        float u, v;
+        {
+          float u, v;
+          if (iRoc < geo.getNumberOfSlicesA()) {
+            geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
+          } else {
+            geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
+          }
+          float py, pz;
+          geo.convUVtoLocal(iRoc, u, v, py, pz);
+          yMax = py;
+        }
+
+        double zEdge = 0.;
         if (iRoc < geo.getNumberOfSlicesA()) {
-          geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
+          zEdge = geo.getTPCzLengthA();
         } else {
-          geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
+          zEdge = -geo.getTPCzLengthC();
         }
-        float py, pz;
-        geo.convUVtoLocal(iRoc, u, v, py, pz);
-        yMax = py;
-      }
-
-      double zEdge = 0.;
-      if (iRoc < geo.getNumberOfSlicesA()) {
-        zEdge = geo.getTPCzLengthA();
-      } else {
-        zEdge = -geo.getTPCzLengthC();
-      }
 
-      for (int iy = 0; iy < nY2Xbins; iy++) {
-        for (int iz = 0; iz < nZ2Xbins; iz++) {
-          auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
-          auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
-          if (vox.mSmoothingStep > 2) {
-            LOG(fatal) << "empty voxel is not repared";
-          }
+        for (int iy = 0; iy < nY2Xbins; iy++) {
+          for (int iz = 0; iz < nZ2Xbins; iz++) {
+            auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+            auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+            if (vox.mSmoothingStep > 2) {
+              LOG(fatal) << "empty voxel is not repared";
+            }
 
-          double y = vox.mY;
-          double z = vox.mZ;
-          double dy = vox.mDy;
-          double dz = vox.mDz;
-          double correctionX = data.mCx;
-          double correctionY = data.mCy;
-          double correctionZ = data.mCz;
+            double y = vox.mY;
+            double z = vox.mZ;
+            double dy = vox.mDy;
+            double dz = vox.mDz;
+            double correctionX = data.mCx;
+            double correctionY = data.mCy;
+            double correctionZ = data.mCz;
 
-          double yFirst = y - dy / 2.;
-          double yLast = y + dy / 2.;
+            double yFirst = y - dy / 2.;
+            double yLast = y + dy / 2.;
 
-          if (iy == 0) { // extend value of the first Y bin to the row edge
-            yFirst = yMin;
-          }
+            if (iy == 0) { // extend value of the first Y bin to the row edge
+              yFirst = yMin;
+            }
 
-          if (iy == nY2Xbins - 1) { // extend value of the last Y bin to the row edge
-            yLast = yMax;
-          }
+            if (iy == nY2Xbins - 1) { // extend value of the last Y bin to the row edge
+              yLast = yMax;
+            }
 
-          double yStep = (yLast - yFirst) / 2;
+            double yStep = (yLast - yFirst) / 2;
 
-          for (double py = yFirst; py <= yLast + yStep / 2.; py += yStep) {
+            for (double py = yFirst; py <= yLast + yStep / 2.; py += yStep) {
 
-            for (double pz = z - dz / 2.; pz <= z + dz / 2. + 1.e-4; pz += dz / 2.) {
-              map.addCorrectionPoint(iRoc, iRow, py, pz, correctionX, correctionY,
-                                     correctionZ);
-            }
+              for (double pz = z - dz / 2.; pz <= z + dz / 2. + 1.e-4; pz += dz / 2.) {
+                map.addCorrectionPoint(iRoc, iRow, py, pz, correctionX, correctionY,
+                                       correctionZ);
+              }
 
-            if (iz == nZ2Xbins - 1) {
-              // extend value of the first Z bin to the readout, linear decrease of all values to 0.
-              int nZsteps = 3;
-              for (int is = 0; is < nZsteps; is++) {
-                double pz = z + (zEdge - z) * (is + 1.) / nZsteps;
-                double s = (nZsteps - 1. - is) / nZsteps;
-                map.addCorrectionPoint(iRoc, iRow, py, pz, s * correctionX,
-                                       s * correctionY, s * correctionZ);
+              if (iz == nZ2Xbins - 1) {
+                // extend value of the first Z bin to the readout, linear decrease of all values to 0.
+                int nZsteps = 3;
+                for (int is = 0; is < nZsteps; is++) {
+                  double pz = z + (zEdge - z) * (is + 1.) / nZsteps;
+                  double s = (nZsteps - 1. - is) / nZsteps;
+                  map.addCorrectionPoint(iRoc, iRow, py, pz, s * correctionX,
+                                         s * correctionY, s * correctionZ);
+                }
               }
             }
-          }
-        } // iz
-      }   // iy
+          } // iz
+        }   // iy
+
+      } // iRow
+    };  // myThread
+
+    // run n threads
+
+    int nThreads = mNthreads;
+    // nThreads = 1;
+
+    std::vector<std::thread> threads(nThreads);
+
+    for (int i = 0; i < nThreads; i++) {
+      threads[i] = std::thread(myThread, i, nThreads);
+    }
 
-    } // iRow
+    // wait for the threads to finish
+    for (auto& th : threads) {
+      th.join();
+    }
 
   } // iRoc
 
-  LOGP(info, "Reading & reparing of the track residuals tooks: {}s", watch1.RealTime());
+  LOGP(info, "Reading & reparing of the track residuals tooks: {}s", watch3.RealTime());
 
   LOG(info) << "fast space charge correction helper: create space charge from the map of data points..";
 
+  TStopwatch watch4;
+
   helper->fillSpaceChargeCorrectionFromMap(correction);
 
-  LOGP(info, "Creation from track residuals tooks in total: {}s", watch2.RealTime());
+  LOG(info) << "fast space charge correction helper: creation from the data map took " << watch4.RealTime() << "s";
+
+  LOGP(info, "Creation from track residuals tooks in total: {}s", watch.RealTime());
 
   return std::move(correctionPtr);
 }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 5a7dffd2a753b..35c6e43daa43b 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -29,12 +29,9 @@ ClassImp(TPCFastSpaceChargeCorrection);
 
 TPCFastSpaceChargeCorrection::TPCFastSpaceChargeCorrection()
   : FlatObject(),
-    mConstructionRowInfos(nullptr),
     mConstructionScenarios(nullptr),
     mNumberOfScenarios(0),
     mScenarioPtr(nullptr),
-    mRowInfoPtr(nullptr),
-    mSliceRowInfoPtr(nullptr),
     mTimeStamp(-1),
     mSplineData{nullptr, nullptr, nullptr},
     mSliceDataSizeBytes{0, 0, 0}
@@ -52,21 +49,16 @@ void TPCFastSpaceChargeCorrection::releaseConstructionMemory()
 {
 // release temporary arrays
 #if !defined(GPUCA_GPUCODE)
-  delete[] mConstructionRowInfos;
   delete[] mConstructionScenarios;
 #endif
-  mConstructionRowInfos = nullptr;
   mConstructionScenarios = nullptr;
 }
 
 void TPCFastSpaceChargeCorrection::destroy()
 {
   releaseConstructionMemory();
-  mConstructionRowInfos = nullptr;
   mConstructionScenarios = nullptr;
   mNumberOfScenarios = 0;
-  mRowInfoPtr = nullptr;
-  mSliceRowInfoPtr = nullptr;
   mScenarioPtr = nullptr;
   mTimeStamp = -1;
   for (int32_t is = 0; is < 3; is++) {
@@ -78,8 +70,6 @@ void TPCFastSpaceChargeCorrection::destroy()
 
 void TPCFastSpaceChargeCorrection::relocateBufferPointers(const char* oldBuffer, char* newBuffer)
 {
-  mRowInfoPtr = FlatObject::relocatePointer(oldBuffer, newBuffer, mRowInfoPtr);
-  mSliceRowInfoPtr = FlatObject::relocatePointer(oldBuffer, newBuffer, mSliceRowInfoPtr);
   mScenarioPtr = FlatObject::relocatePointer(oldBuffer, newBuffer, mScenarioPtr);
 
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -119,13 +109,21 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
   mSliceDataSizeBytes[2] = obj.mSliceDataSizeBytes[2];
 
   // variable-size data
-  mRowInfoPtr = obj.mRowInfoPtr;
-  mSliceRowInfoPtr = obj.mSliceRowInfoPtr;
   mScenarioPtr = obj.mScenarioPtr;
   mSplineData[0] = obj.mSplineData[0];
   mSplineData[1] = obj.mSplineData[1];
   mSplineData[2] = obj.mSplineData[2];
 
+  mClassVersion = obj.mClassVersion;
+
+  for (int i = 0; i < TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
+    mRowInfos[i] = obj.mRowInfos[i];
+  }
+
+  for (int i = 0; i < TPCFastTransformGeo::getNumberOfSlices() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
+    mSliceRowInfos[i] = obj.mSliceRowInfos[i];
+  }
+
   relocateBufferPointers(oldFlatBufferPtr, mFlatBufferPtr);
 }
 
@@ -140,19 +138,43 @@ void TPCFastSpaceChargeCorrection::moveBufferTo(char* newFlatBufferPtr)
 
 void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBufferPtr)
 {
-  /// Sets the actual location of the external flat buffer after it has been moved (i.e. to another maschine)
+  /// Sets the actual location of the external flat buffer after it has been moved (e.g. to another maschine)
+
+  struct RowInfoVersion3 {
+    int splineScenarioID{0};      ///< scenario index (which of Spline2D splines to use)
+    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC slice
+  };
+
+  struct RowActiveAreaVersion3 {
+    float maxDriftLengthCheb[5]{0.f};
+    float vMax{0.f};
+    float cuMin{0.f};
+    float cuMax{0.f};
+    float cvMax{0.f};
+  };
+
+  struct SliceRowInfoVersion3 {
+    float gridV0{0.f};           ///< V coordinate of the V-grid start
+    float gridCorrU0{0.f};       ///< U coordinate of the U-grid start for corrected U
+    float gridCorrV0{0.f};       ///< V coordinate of the V-grid start for corrected V
+    float scaleCorrUtoGrid{0.f}; ///< scale corrected U to U-grid coordinate
+    float scaleCorrVtoGrid{0.f}; ///< scale corrected V to V-grid coordinate
+    RowActiveAreaVersion3 activeArea;
+  };
 
   FlatObject::setActualBufferAddress(actualFlatBufferPtr);
 
   size_t rowsOffset = 0;
-  size_t rowsSize = sizeof(RowInfo) * mGeo.getNumberOfRows();
-
-  mRowInfoPtr = reinterpret_cast<RowInfo*>(mFlatBufferPtr + rowsOffset);
+  size_t rowsSize = 0;
+  if (mClassVersion == 3) {
+    rowsSize = sizeof(RowInfoVersion3) * mGeo.getNumberOfRows();
+  }
 
   size_t sliceRowsOffset = rowsOffset + rowsSize;
-  size_t sliceRowsSize = sizeof(SliceRowInfo) * mGeo.getNumberOfRows() * mGeo.getNumberOfSlices();
-
-  mSliceRowInfoPtr = reinterpret_cast<SliceRowInfo*>(mFlatBufferPtr + sliceRowsOffset);
+  size_t sliceRowsSize = 0;
+  if (mClassVersion == 3) { // copy old-format slicerow data from the buffer to the arrays
+    sliceRowsSize = sizeof(SliceRowInfoVersion3) * mGeo.getNumberOfRows() * mGeo.getNumberOfSlices();
+  }
 
   size_t scOffset = alignSize(sliceRowsOffset + sliceRowsSize, SplineType::getClassAlignmentBytes());
   size_t scSize = sizeof(SplineType) * mNumberOfScenarios;
@@ -173,6 +195,53 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + sliceDataOffset);
     bufferSize = sliceDataOffset + mSliceDataSizeBytes[is] * mGeo.getNumberOfSlices();
   }
+
+  if (mClassVersion == 3) { // copy old-format slicerow data from the buffer to the arrays
+
+    auto* rowInfosOld = reinterpret_cast<RowInfoVersion3*>(mFlatBufferPtr + rowsOffset);
+    for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+      RowInfoVersion3& infoOld = rowInfosOld[i];
+      RowInfo& info = mRowInfos[i];
+      info.splineScenarioID = infoOld.splineScenarioID;
+      for (int is = 0; is < 3; is++) {
+        info.dataOffsetBytes[is] = infoOld.dataOffsetBytes[is];
+      }
+    }
+
+    for (int is = 0; is < mNumberOfScenarios; is++) {
+      auto& spline = mScenarioPtr[is];
+      spline.setXrange(0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax());
+    }
+
+    auto* sliceRowInfosOld = reinterpret_cast<SliceRowInfoVersion3*>(mFlatBufferPtr + sliceRowsOffset);
+
+    for (int slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
+      for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
+        SliceRowInfoVersion3& infoOld = sliceRowInfosOld[mGeo.getNumberOfRows() * slice + row];
+        SliceRowInfo& info = getSliceRowInfo(slice, row);
+        const auto& spline = getSpline(slice, row);
+        info.gridU0 = mGeo.getRowInfo(row).u0;
+        info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
+
+        info.gridV0 = infoOld.gridV0;
+        info.scaleVtoGrid = spline.getGridX2().getUmax() / (mGeo.getTPCzLength(slice) + 3. - info.gridV0);
+
+        info.gridCorrU0 = infoOld.gridCorrU0;
+        info.scaleCorrUtoGrid = infoOld.scaleCorrUtoGrid;
+
+        info.gridCorrV0 = infoOld.gridCorrV0;
+        info.scaleCorrVtoGrid = infoOld.scaleCorrVtoGrid;
+
+        info.activeArea.vMax = infoOld.activeArea.vMax;
+        info.activeArea.cuMin = infoOld.activeArea.cuMin;
+        info.activeArea.cuMax = infoOld.activeArea.cuMax;
+        info.activeArea.cvMax = infoOld.activeArea.cvMax;
+        for (int i = 0; i < 5; i++) {
+          info.activeArea.maxDriftLengthCheb[i] = infoOld.activeArea.maxDriftLengthCheb[i];
+        }
+      }
+    }
+  }
 }
 
 void TPCFastSpaceChargeCorrection::setFutureBufferAddress(char* futureFlatBufferPtr)
@@ -187,10 +256,7 @@ void TPCFastSpaceChargeCorrection::setFutureBufferAddress(char* futureFlatBuffer
   char* oldBuffer = mFlatBufferPtr;
   char* newBuffer = futureFlatBufferPtr;
 
-  mRowInfoPtr = relocatePointer(oldBuffer, newBuffer, mRowInfoPtr);
-  mSliceRowInfoPtr = relocatePointer(oldBuffer, newBuffer, mSliceRowInfoPtr);
-
-  for (int32_t i = 0; i < mNumberOfScenarios; i++) {
+  for (int i = 0; i < mNumberOfScenarios; i++) {
     SplineType& sp = mScenarioPtr[i];
     char* newSplineBuf = relocatePointer(oldBuffer, newBuffer, sp.getFlatBufferPtr());
     sp.setFutureBufferAddress(newSplineBuf);
@@ -210,10 +276,10 @@ void TPCFastSpaceChargeCorrection::print() const
   LOG(info) << "  mNumberOfScenarios = " << mNumberOfScenarios;
   LOG(info) << "  mTimeStamp = " << mTimeStamp;
   LOG(info) << "  mSliceDataSizeBytes = " << mSliceDataSizeBytes[0] << " " << mSliceDataSizeBytes[1] << " " << mSliceDataSizeBytes[2];
-  if (mRowInfoPtr) {
+  {
     LOG(info) << "  TPC rows: ";
-    for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-      RowInfo& r = mRowInfoPtr[i];
+    for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+      const RowInfo& r = mRowInfos[i];
       LOG(info) << " tpc row " << i << ": splineScenarioID = " << r.splineScenarioID << " dataOffsetBytes = " << r.dataOffsetBytes;
     }
   }
@@ -223,7 +289,7 @@ void TPCFastSpaceChargeCorrection::print() const
       mScenarioPtr[i].print();
     }
   }
-  if (mRowInfoPtr && mScenarioPtr && mSliceRowInfoPtr) {
+  if (mScenarioPtr) {
     LOG(info) << " Spline Data: ";
     for (int32_t is = 0; is < mGeo.getNumberOfSlices(); is++) {
       for (int32_t ir = 0; ir < mGeo.getNumberOfRows(); ir++) {
@@ -260,15 +326,13 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
   releaseConstructionMemory();
 
 #if !defined(GPUCA_GPUCODE)
-  mConstructionRowInfos = new RowInfo[mGeo.getNumberOfRows()];
   mConstructionScenarios = new SplineType[mNumberOfScenarios];
 #endif
 
-  assert(mConstructionRowInfos != nullptr);
   assert(mConstructionScenarios != nullptr);
 
-  for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-    mConstructionRowInfos[i].splineScenarioID = -1;
+  for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+    mRowInfos[i].splineScenarioID = -1;
   }
 
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -277,13 +341,12 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
 
   mTimeStamp = -1;
 
-  mRowInfoPtr = nullptr;
-  mSliceRowInfoPtr = nullptr;
   mScenarioPtr = nullptr;
   for (int32_t s = 0; s < 3; s++) {
     mSplineData[s] = nullptr;
     mSliceDataSizeBytes[s] = 0;
   }
+  mClassVersion = 4;
 }
 
 void TPCFastSpaceChargeCorrection::setRowScenarioID(int32_t iRow, int32_t iScenario)
@@ -292,7 +355,7 @@ void TPCFastSpaceChargeCorrection::setRowScenarioID(int32_t iRow, int32_t iScena
   assert(mConstructionMask & ConstructionState::InProgress);
   assert(iRow >= 0 && iRow < mGeo.getNumberOfRows() && iScenario >= 0 && iScenario < mNumberOfScenarios);
 
-  RowInfo& row = mConstructionRowInfos[iRow];
+  RowInfo& row = mRowInfos[iRow];
   row.splineScenarioID = iScenario;
   for (int32_t s = 0; s < 3; s++) {
     row.dataOffsetBytes[s] = 0;
@@ -315,8 +378,8 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 
   assert(mConstructionMask & ConstructionState::InProgress);
 
-  for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-    assert(mConstructionRowInfos[i].splineScenarioID >= 0);
+  for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+    assert(mRowInfos[i].splineScenarioID >= 0);
   }
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
     assert(mConstructionScenarios[i].isConstructed());
@@ -324,13 +387,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 
   // organize memory for the flat buffer and caculate its size
 
-  size_t rowsOffset = 0;
-  size_t rowsSize = sizeof(RowInfo) * mGeo.getNumberOfRows();
-
-  size_t sliceRowsOffset = rowsSize;
-  size_t sliceRowsSize = sizeof(SliceRowInfo) * mGeo.getNumberOfRows() * mGeo.getNumberOfSlices();
-
-  size_t scOffset = alignSize(sliceRowsOffset + sliceRowsSize, SplineType::getClassAlignmentBytes());
+  size_t scOffset = 0;
   size_t scSize = sizeof(SplineType) * mNumberOfScenarios;
 
   size_t scBufferOffsets[mNumberOfScenarios];
@@ -347,8 +404,8 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   for (int32_t is = 0; is < 3; is++) {
     sliceDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
     mSliceDataSizeBytes[is] = 0;
-    for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-      RowInfo& row = mConstructionRowInfos[i];
+    for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+      RowInfo& row = mRowInfos[i];
       SplineType& spline = mConstructionScenarios[row.splineScenarioID];
       row.dataOffsetBytes[is] = alignSize(mSliceDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
       mSliceDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
@@ -359,20 +416,6 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 
   FlatObject::finishConstruction(bufferSize);
 
-  mRowInfoPtr = reinterpret_cast<RowInfo*>(mFlatBufferPtr + rowsOffset);
-  for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-    mRowInfoPtr[i] = mConstructionRowInfos[i];
-  }
-
-  mSliceRowInfoPtr = reinterpret_cast<SliceRowInfo*>(mFlatBufferPtr + sliceRowsOffset);
-  for (int32_t s = 0; s < mGeo.getNumberOfSlices(); s++) {
-    for (int32_t r = 0; r < mGeo.getNumberOfRows(); r++) {
-      mSliceRowInfoPtr[s * mGeo.getNumberOfRows() + r].gridCorrU0 = 0.;
-      mSliceRowInfoPtr[s * mGeo.getNumberOfRows() + r].scaleCorrUtoGrid = 0.;
-      mSliceRowInfoPtr[s * mGeo.getNumberOfRows() + r].scaleCorrVtoGrid = 0.;
-    }
-  }
-
   mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr + scOffset);
 
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -417,20 +460,28 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
       }
 
       SliceRowInfo& info = getSliceRowInfo(slice, row);
+
+      info.gridU0 = mGeo.getRowInfo(row).u0;
+      info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
+
+      info.gridV0 = 0.f;
+      info.scaleVtoGrid = spline.getGridX2().getUmax() / vLength;
+
+      info.gridCorrU0 = info.gridU0;
+      info.gridCorrV0 = info.gridV0;
+      info.scaleCorrUtoGrid = info.scaleUtoGrid;
+      info.scaleCorrVtoGrid = info.scaleVtoGrid;
+
       RowActiveArea& area = info.activeArea;
       for (int32_t i = 1; i < 5; i++) {
         area.maxDriftLengthCheb[i] = 0;
       }
       area.maxDriftLengthCheb[0] = vLength;
-      area.cuMin = mGeo.convPadToU(row, 0.f);
+      area.cuMin = info.gridCorrU0;
       area.cuMax = -area.cuMin;
       area.vMax = vLength;
       area.cvMax = vLength;
-      info.gridV0 = 0.f;
-      info.gridCorrU0 = area.cuMin;
-      info.gridCorrV0 = info.gridV0;
-      info.scaleCorrUtoGrid = spline.getGridX1().getUmax() / (area.cuMax - area.cuMin);
-      info.scaleCorrVtoGrid = spline.getGridX2().getUmax() / area.cvMax;
+
     } // row
   } // slice
 }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 9589ecbfc1fc4..b29d65b98458a 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -58,13 +58,16 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   };
 
   struct SliceRowInfo {
+    float gridU0{0.f};           //< U coordinate of the U-grid start
+    float scaleUtoGrid{0.f};     //< scale U to U-grid coordinate
     float gridV0{0.f};           ///< V coordinate of the V-grid start
+    float scaleVtoGrid{0.f};     //< scale V to V-grid coordinate
     float gridCorrU0{0.f};       ///< U coordinate of the U-grid start for corrected U
-    float gridCorrV0{0.f};       ///< V coordinate of the V-grid start for corrected V
     float scaleCorrUtoGrid{0.f}; ///< scale corrected U to U-grid coordinate
+    float gridCorrV0{0.f};       ///< V coordinate of the V-grid start for corrected V
     float scaleCorrVtoGrid{0.f}; ///< scale corrected V to V-grid coordinate
     RowActiveArea activeArea;
-    ClassDefNV(SliceRowInfo, 1);
+    ClassDefNV(SliceRowInfo, 2);
   };
 
   struct SliceInfo {
@@ -199,7 +202,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() float getInterpolationSafetyMargin() const { return fInterpolationSafetyMargin; }
 
   /// Gives TPC row info
-  GPUd() const RowInfo& getRowInfo(int32_t row) const { return mRowInfoPtr[row]; }
+  GPUd() const RowInfo& getRowInfo(int row) const { return mRowInfos[row]; }
 
   /// Gives TPC slice info
   GPUd() const SliceInfo& getSliceInfo(int32_t slice) const
@@ -216,13 +219,13 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// Gives TPC slice & row info
   GPUd() const SliceRowInfo& getSliceRowInfo(int32_t slice, int32_t row) const
   {
-    return mSliceRowInfoPtr[mGeo.getNumberOfRows() * slice + row];
+    return mSliceRowInfos[mGeo.getMaxNumberOfRows() * slice + row];
   }
 
   /// Gives TPC slice & row info
   GPUd() SliceRowInfo& getSliceRowInfo(int32_t slice, int32_t row)
   {
-    return mSliceRowInfoPtr[mGeo.getNumberOfRows() * slice + row];
+    return mSliceRowInfos[mGeo.getMaxNumberOfRows() * slice + row];
   }
 
 #if !defined(GPUCA_GPUCODE)
@@ -244,7 +247,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   /// _______________  Construction control  _______________________________________________
 
-  RowInfo* mConstructionRowInfos = nullptr;     //! (transient!!) Temporary container of the row infos during construction
   SplineType* mConstructionScenarios = nullptr; //! (transient!!) Temporary container for spline scenarios
 
   /// _______________  Geometry  _______________________________________________
@@ -255,9 +257,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   SliceInfo mSliceInfo[TPCFastTransformGeo::getNumberOfSlices()]; ///< SliceInfo array
 
-  SplineType* mScenarioPtr;       //! (transient!!) pointer to spline scenarios
-  RowInfo* mRowInfoPtr;           //! (transient!!) pointer to RowInfo array inside the mFlatBufferPtr buffer
-  SliceRowInfo* mSliceRowInfoPtr; //! (transient!!) pointer to SliceRowInfo array inside the mFlatBufferPtr
+  SplineType* mScenarioPtr; //! (transient!!) pointer to spline scenarios
 
   /// _______________  Calibration data  _______________________________________________
 
@@ -269,7 +269,16 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   float fInterpolationSafetyMargin{0.1f}; // 10% area around the TPC row. Outside of this area the interpolation returns the boundary values.
 
-  ClassDefNV(TPCFastSpaceChargeCorrection, 3);
+  /// Class version. It is used to read older versions from disc.
+  /// The default version 3 is the one before this field was introduced.
+  /// The actual version must be set in startConstruction().
+  int mClassVersion{3};
+
+  RowInfo mRowInfos[TPCFastTransformGeo::getMaxNumberOfRows()]; ///< RowInfo array
+
+  SliceRowInfo mSliceRowInfos[TPCFastTransformGeo::getNumberOfSlices() * TPCFastTransformGeo::getMaxNumberOfRows()]; ///< SliceRowInfo array
+
+  ClassDefNV(TPCFastSpaceChargeCorrection, 4);
 };
 
 /// ====================================================
@@ -279,28 +288,28 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 GPUdi() const TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t slice, int32_t row) const
 {
   /// Gives const pointer to spline
-  const RowInfo& rowInfo = mRowInfoPtr[row];
+  const RowInfo& rowInfo = mRowInfos[row];
   return mScenarioPtr[rowInfo.splineScenarioID];
 }
 
 GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t slice, int32_t row)
 {
   /// Gives pointer to spline
-  const RowInfo& rowInfo = mRowInfoPtr[row];
+  const RowInfo& rowInfo = mRowInfos[row];
   return mScenarioPtr[rowInfo.splineScenarioID];
 }
 
 GPUdi() float* TPCFastSpaceChargeCorrection::getSplineData(int32_t slice, int32_t row, int32_t iSpline)
 {
   /// Gives pointer to spline data
-  const RowInfo& rowInfo = mRowInfoPtr[row];
+  const RowInfo& rowInfo = mRowInfos[row];
   return reinterpret_cast<float*>(mSplineData[iSpline] + mSliceDataSizeBytes[iSpline] * slice + rowInfo.dataOffsetBytes[iSpline]);
 }
 
 GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t slice, int32_t row, int32_t iSpline) const
 {
   /// Gives pointer to spline data
-  const RowInfo& rowInfo = mRowInfoPtr[row];
+  const RowInfo& rowInfo = mRowInfos[row];
   return reinterpret_cast<float*>(mSplineData[iSpline] + mSliceDataSizeBytes[iSpline] * slice + rowInfo.dataOffsetBytes[iSpline]);
 }
 
@@ -356,35 +365,18 @@ GPUdi() void TPCFastSpaceChargeCorrection::schrinkCorrectedUV(int32_t slice, int
 
 GPUdi() void TPCFastSpaceChargeCorrection::convUVtoGrid(int32_t slice, int32_t row, float u, float v, float& gu, float& gv) const
 {
-  // TODO optimise !!!
-  gu = 0.f;
-  gv = 0.f;
-
   schrinkUV(slice, row, u, v);
-
   const SliceRowInfo& info = getSliceRowInfo(slice, row);
-  const SplineType& spline = getSpline(slice, row);
-
-  float su0 = 0.f, sv0 = 0.f;
-  mGeo.convUVtoScaledUV(slice, row, u, info.gridV0, su0, sv0);
-  mGeo.convUVtoScaledUV(slice, row, u, v, gu, gv);
-
-  gv = (gv - sv0) / (1.f - sv0);
-  gu *= spline.getGridX1().getUmax();
-  gv *= spline.getGridX2().getUmax();
+  gu = (u - info.gridU0) * info.scaleUtoGrid;
+  gv = (v - info.gridV0) * info.scaleVtoGrid;
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::convGridToUV(int32_t slice, int32_t row, float gridU, float gridV, float& u, float& v) const
 {
-  // TODO optimise
-  /// convert u,v to internal grid coordinates
-  float su0 = 0.f, sv0 = 0.f;
+  /// convert internal grid coordinates to u,v
   const SliceRowInfo& info = getSliceRowInfo(slice, row);
-  const SplineType& spline = getSpline(slice, row);
-  mGeo.convUVtoScaledUV(slice, row, 0.f, info.gridV0, su0, sv0);
-  float su = gridU / spline.getGridX1().getUmax();
-  float sv = sv0 + gridV / spline.getGridX2().getUmax() * (1.f - sv0);
-  mGeo.convScaledUVtoUV(slice, row, su, sv, u, v);
+  u = info.gridU0 + gridU / info.scaleUtoGrid;
+  v = info.gridV0 + gridV / info.scaleVtoGrid;
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::convCorrectedUVtoGrid(int32_t slice, int32_t row, float corrU, float corrV, float& gridU, float& gridV) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 5eddada1e9acc..d20331ba6ab0f 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -50,6 +50,12 @@ class TPCFastTransformGeo
     float scaleUtoSU; ///< scale for su (scaled u ) coordinate
     float scaleSUtoU; ///< scale for u coordinate
 
+    /// get U min
+    GPUd() float getUmin() const { return u0; }
+
+    /// get U max
+    GPUd() float getUmax() const { return -u0; }
+
     /// get width in U
     GPUd() float getUwidth() const { return -2.f * u0; }
     ClassDefNV(RowInfo, 1);
@@ -110,6 +116,9 @@ class TPCFastTransformGeo
   /// Gives number of TPC rows
   GPUd() int32_t getNumberOfRows() const { return mNumberOfRows; }
 
+  /// Gives number of TPC rows
+  GPUd() static constexpr int getMaxNumberOfRows() { return MaxNumberOfRows; }
+
   /// Gives slice info
   GPUd() const SliceInfo& getSliceInfo(int32_t slice) const;
 
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index b13d031d6d10d..bf3e14d552715 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -59,6 +59,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     corr->Draw("cx:y:z","iRoc==0&&iRow==10","")
     grid->Draw("cx:y:z","iRoc==0&&iRow==10","same")
     vox->Draw("vx:y:z","iRoc==0&&iRow==10","same")
+    corrvox->Draw("cx:y:z","iRoc==0&&iRow==10","same")
     points->Draw("px:y:z","iRoc==0&&iRow==10","same")
   */
 
@@ -98,17 +99,36 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   trackResiduals.setZ2XBinning(z2xBins);
   trackResiduals.init();
 
-  std::cout << "y2xBins: " << y2xBins.size() << " z2xBins: " << z2xBins.size() << std::endl;
+  {
+    std::cout << "input track residuals: " << std::endl;
+    std::cout << "voxel tree y2xBins: " << y2xBins.size() << std::endl;
 
-  for (auto y2x : y2xBins) {
-    std::cout << "y2x: " << y2x << std::endl;
-  }
+    for (auto y2x : y2xBins) {
+      std::cout << " y2x: " << y2x << std::endl;
+    }
+    std::cout << std::endl;
+
+    int nY2Xbins = trackResiduals.getNY2XBins();
+
+    std::cout << " TrackResiduals y2x bins: " << nY2Xbins << std::endl;
+    for (int i = 0; i < nY2Xbins; i++) {
+      std::cout << "scaled getY2X(bin) : " << trackResiduals.getY2X(0, i) / trackResiduals.getMaxY2X(0) << std::endl;
+    }
+
+    std::cout << "voxel tree z2xBins: " << z2xBins.size() << std::endl;
 
-  std::cout << std::endl;
+    for (auto z2x : z2xBins) {
+      std::cout << "z2x: " << z2x << std::endl;
+    }
+    std::cout << std::endl;
 
-  for (auto z2x : z2xBins) {
-    std::cout << "z2x: " << z2x << std::endl;
+    int nZ2Xbins = trackResiduals.getNZ2XBins();
+    std::cout << " TrackResiduals z2x bins: " << nZ2Xbins << std::endl;
+    for (int i = 0; i < nZ2Xbins; i++) {
+      std::cout << "getZ2X(bin) : " << trackResiduals.getZ2X(i) << std::endl;
+    }
   }
+
   std::cout << "create fast transformation ... " << std::endl;
 
   auto* helper = o2::tpc::TPCFastTransformHelperO2::instance();
@@ -122,16 +142,47 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   std::unique_ptr<o2::gpu::TPCFastTransform> fastTransform(
     helper->create(0, *corrPtr));
 
-  o2::gpu::TPCFastSpaceChargeCorrection& corr = fastTransform->getCorrection();
-
   std::cout << "... create fast transformation completed " << std::endl;
 
   if (*outFileName) {
     fastTransform->writeToFile(outFileName, "ccdb_object");
   }
 
+  if (1) { // read transformation from the file
+
+    // const char* fileName = "master/out.root";
+
+    const char* fileName = outFileName;
+
+    std::cout << "load corrections from file " << fileName << std::endl;
+
+    fastTransform->cloneFromObject(*TPCFastTransform::loadFromFile(fileName, "ccdb_object"), nullptr);
+
+    o2::gpu::TPCFastSpaceChargeCorrection& corr = fastTransform->getCorrection();
+
+    if (0) {
+      std::cout << "check the loaded correction ..." << std::endl;
+
+      const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
+
+      // for (int iRoc = 0; iRoc < geo.getNumberOfSlices(); iRoc++) {
+      for (int iRoc = 0; iRoc < 1; iRoc++) {
+        for (int iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
+          auto& info = corr.getSliceRowInfo(iRoc, iRow);
+          std::cout << "roc " << iRoc << " row " << iRow
+                    << " gridV0 " << info.gridV0 << " gridCorrU0 " << info.gridCorrU0 << " gridCorrV0 " << info.gridCorrV0
+                    << " scaleCorrUtoGrid " << info.scaleCorrUtoGrid << " scaleCorrVtoGrid " << info.scaleCorrVtoGrid
+                    << " gridU0 " << info.gridU0 << " scaleUtoGrid " << info.scaleUtoGrid << " scaleVtoGrid " << info.scaleVtoGrid
+                    << std::endl;
+        }
+      }
+    }
+  }
+
   std::cout << "verify the results ..." << std::endl;
 
+  o2::gpu::TPCFastSpaceChargeCorrection& corr = fastTransform->getCorrection();
+
   // the difference
 
   double maxDiff[3] = {0., 0., 0.};
@@ -158,12 +209,21 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   // ntuple with the input data: voxel corrections
   debugFile->cd();
   TNtuple* debugVox =
-    new TNtuple("vox", "vox", "iRoc:iRow:x:y:z:vx:vy:vz:cx:cy:cz");
+    new TNtuple("vox", "vox", "iRoc:iRow:n:x:y:z:vx:vy:vz:cx:cy:cz");
 
   debugVox->SetMarkerStyle(8);
   debugVox->SetMarkerSize(0.8);
   debugVox->SetMarkerColor(kBlue);
 
+  // duplicate of debugVox
+  debugFile->cd();
+  TNtuple* debugCorrVox =
+    new TNtuple("corrvox", "corrvox", "iRoc:iRow:n:x:y:z:vx:vy:vz:cx:cy:cz");
+
+  debugCorrVox->SetMarkerStyle(8);
+  debugCorrVox->SetMarkerSize(0.8);
+  debugCorrVox->SetMarkerColor(kMagenta);
+
   // ntuple with spline grid points
   debugFile->cd();
   TNtuple* debugGrid = new TNtuple("grid", "grid", "iRoc:iRow:x:y:z:cx:cy:cz");
@@ -244,13 +304,6 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
       correctionZ *= -1.;
     }
 
-    // TODO: skip empty voxels?
-    if (voxEntries < 1.) { // no statistics
-      // std::cout << "Empty Voxel!!! corrections: " << correctionX << " "
-      //         << correctionY << " " << correctionZ << std::endl;
-      //  continue;
-    }
-
     float u, v, cx, cu, cv, cy, cz;
     geo.convLocalToUV(iRoc, y, z, u, v);
     corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
@@ -258,19 +311,24 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     cy -= y;
     cz -= z;
     double d[3] = {cx - correctionX, cy - correctionY, cz - correctionZ};
-    for (int32_t i = 0; i < 3; i++) {
-      if (fabs(maxDiff[i]) < fabs(d[i])) {
-        maxDiff[i] = d[i];
-        maxDiffRoc[i] = iRoc;
-        maxDiffRow[i] = iRow;
-        std::cout << " roc " << iRoc << " row " << iRow << " xyz " << i
-                  << " diff " << d[i] << std::endl;
+    if (voxEntries >= 1.) {
+      for (int i = 0; i < 3; i++) {
+        if (fabs(maxDiff[i]) < fabs(d[i])) {
+          maxDiff[i] = d[i];
+          maxDiffRoc[i] = iRoc;
+          maxDiffRow[i] = iRow;
+          std::cout << " roc " << iRoc << " row " << iRow << " xyz " << i
+                    << " diff " << d[i] << " entries " << voxEntries << " y " << y2xBin << " z " << z2xBin << std::endl;
+        }
+        sumDiff[i] += d[i] * d[i];
       }
-      sumDiff[i] += d[i] * d[i];
+      nDiff++;
     }
-    nDiff++;
-    debugVox->Fill(iRoc, iRow, x, y, z, correctionX, correctionY, correctionZ,
+
+    debugVox->Fill(iRoc, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ,
                    cx, cy, cz);
+    debugCorrVox->Fill(iRoc, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ,
+                       cx, cy, cz);
   }
 
   std::cout << "create debug ntuples ..." << std::endl;
@@ -282,43 +340,71 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
 
       double x = geo.getRowInfo(iRow).x;
 
+      // the spline grid
+
+      const auto& gridU = corr.getSpline(iRoc, iRow).getGridX1();
+      const auto& gridV = corr.getSpline(iRoc, iRow).getGridX2();
+      if (iRoc == 0 && iRow == 0) {
+        std::cout << "spline scenario " << corr.getRowInfo(iRow).splineScenarioID << std::endl;
+        std::cout << "spline grid U: u = " << 0 << ".." << gridU.getUmax() << ", x = " << gridU.getXmin() << ".." << gridU.getXmax() << std::endl;
+        std::cout << "spline grid V: u = " << 0 << ".." << gridV.getUmax() << ", x = " << gridV.getXmin() << ".." << gridV.getXmax() << std::endl;
+      }
+
       // the correction
+      {
+        std::vector<double> p[2], g[2];
 
-      for (double su = 0.; su <= 1.0001; su += 0.01) {
-        for (double sv = 0.; sv <= 1.0001; sv += 0.1) {
+        p[0].push_back(geo.getRowInfo(iRow).getUmin());
+        for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
           float u, v;
-          geo.convScaledUVtoUV(iRoc, iRow, su, sv, u, v);
-          float y, z;
-          geo.convUVtoLocal(iRoc, u, v, y, z);
-          float cx, cu, cv;
-          corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
-          float cy, cz;
-          geo.convUVtoLocal(iRoc, u + cu, v + cv, cy, cz);
-          cy -= y;
-          cz -= z;
-          debugCorr->Fill(iRoc, iRow, x, y, z, cx, cy, cz);
+          corr.convGridToUV(iRoc, iRow, gridU.getKnot(iu).getU(), 0., u, v);
+          g[0].push_back(u);
+          p[0].push_back(u);
         }
-      }
-
-      // the spline grid
+        p[0].push_back(geo.getRowInfo(iRow).getUmax());
 
-      const auto& gridU = corr.getSpline(iRoc, iRow).getGridX1();
-      const auto& gridV = corr.getSpline(iRoc, iRow).getGridX2();
-      for (int32_t iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
-        double su = gridU.convUtoX(gridU.getKnot(iu).getU());
-        for (int32_t iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
-          double sv = gridV.convUtoX(gridV.getKnot(iv).getU());
+        p[1].push_back(0.);
+        for (int iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
           float u, v;
-          corr.convGridToUV(iRoc, iRow, iu, iv, u, v);
-          float y, z;
-          geo.convUVtoLocal(iRoc, u, v, y, z);
-          float cx, cu, cv;
-          corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
-          float cy, cz;
-          geo.convUVtoLocal(iRoc, u + cu, v + cv, cy, cz);
-          cy -= y;
-          cz -= z;
-          debugGrid->Fill(iRoc, iRow, x, y, z, cx, cy, cz);
+          corr.convGridToUV(iRoc, iRow, 0., gridV.getKnot(iv).getU(), u, v);
+          g[1].push_back(v);
+          p[1].push_back(v);
+        }
+        p[1].push_back(geo.getTPCzLength(iRoc));
+
+        for (int iuv = 0; iuv < 2; iuv++) {
+          int n = p[iuv].size();
+          for (unsigned int i = 0; i < n - 1; i++) {
+            double d = (p[iuv][i + 1] - p[iuv][i]) / 10.;
+            for (int ii = 1; ii < 10; ii++) {
+              p[iuv].push_back(p[iuv][i] + d * ii);
+            }
+          }
+          std::sort(p[iuv].begin(), p[iuv].end());
+        }
+
+        for (int iter = 0; iter < 2; iter++) {
+          std::vector<double>& pu = ((iter == 0) ? g[0] : p[0]);
+          std::vector<double>& pv = ((iter == 0) ? g[1] : p[1]);
+          for (unsigned int iu = 0; iu < pu.size(); iu++) {
+            for (unsigned int iv = 0; iv < pv.size(); iv++) {
+              float u = pu[iu];
+              float v = pv[iv];
+              float x, y, z;
+              geo.convUVtoLocal(iRoc, u, v, y, z);
+              float cx, cu, cv;
+              corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
+              float cy, cz;
+              geo.convUVtoLocal(iRoc, u + cu, v + cv, cy, cz);
+              cy -= y;
+              cz -= z;
+              if (iter == 0) {
+                debugGrid->Fill(iRoc, iRow, x, y, z, cx, cy, cz);
+              } else {
+                debugCorr->Fill(iRoc, iRow, x, y, z, cx, cy, cz);
+              }
+            }
+          }
         }
       }
 
@@ -372,6 +458,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   debugFile->cd();
   debugCorr->Write();
   debugVox->Write();
+  debugCorrVox->Write();
   debugGrid->Write();
   debugPoints->Write();
   debugFile->Close();

From 658149075aa6fb4d8749d0a19dea12e1b792a3f8 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Thu, 18 Apr 2024 00:30:38 +0000
Subject: [PATCH 1560/1764] TPC Splines: multithreaded reading of the residual
 tree

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 73 +++++++++----------
 1 file changed, 33 insertions(+), 40 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 861cacbe00012..ce0954120281f 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -31,6 +31,7 @@
 #include "TStopwatch.h"
 #include "TTreeReader.h"
 #include "TTreeReaderValue.h"
+#include "ROOT/TTreeProcessorMT.hxx"
 
 using namespace o2::gpu;
 
@@ -541,9 +542,6 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
   TStopwatch watch3;
 
-  // TTreeProcessorMT treeProcessor(*voxResTree); // multi-threaded tree processor
-  // treeProcessor.Init(voxResTree);
-
   // read the data ROC by ROC
 
   // data in the tree is not sorted by row
@@ -554,44 +552,40 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
     float mCx, mCy, mCz; // corrections to the local coordinates
   };
 
-  std::vector<VoxelData> vRocData[nRows];
-  for (int ir = 0; ir < nRows; ir++) {
+  std::vector<VoxelData> vRocData[nRows * nROCs];
+  for (int ir = 0; ir < nRows * nROCs; ir++) {
     vRocData[ir].resize(nY2Xbins * nZ2Xbins);
   }
 
-  for (int iRoc = 0; iRoc < nROCs; iRoc++) {
+  { // read data from the tree to vRocData
 
-    for (int ir = 0; ir < nRows; ir++) {
-      for (int iv = 0; iv < nY2Xbins * nZ2Xbins; iv++) {
-        vRocData[ir][iv].mNentries = 0;
-      }
-    }
+    ROOT::TTreeProcessorMT processor(*voxResTree, mNthreads);
 
-    const int rocDataStart = iRoc * trackResiduals.getNVoxelsPerSector();
-    const int rocDataEnd = rocDataStart + trackResiduals.getNVoxelsPerSector();
-
-    TTreeReader reader(voxResTree);
-    reader.SetEntriesRange(rocDataStart, rocDataEnd);
-    TTreeReaderValue<o2::tpc::TrackResiduals::VoxRes> v(reader, "voxRes");
-    for (int iVox = rocDataStart; iVox < rocDataEnd; iVox++) {
-      reader.Next();
-      // voxResTree->GetEntry(iVox);
-      if ((int)v->bsec != iRoc) {
-        LOG(fatal) << "Error reading voxels: voxel ROC number " << v->bsec << " is not equal to the expected " << iRoc;
-        continue;
-      }
-      int iRow = (int)v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
-      if (iRow < 0 || iRow >= nRows) {
-        LOG(fatal) << "Row number " << iRow << " is out of range";
+    auto myThread = [&](TTreeReader& readerSubRange) {
+      TTreeReaderValue<o2::tpc::TrackResiduals::VoxRes> v(readerSubRange, "voxRes");
+      while (readerSubRange.Next()) {
+        int iRoc = (int)v->bsec;
+        if (iRoc < 0 || iRoc >= nROCs) {
+          LOG(fatal) << "Error reading voxels: voxel ROC number " << iRoc << " is out of range";
+          continue;
+        }
+        int iRow = (int)v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
+        if (iRow < 0 || iRow >= nRows) {
+          LOG(fatal) << "Row number " << iRow << " is out of range";
+        }
+        int iy = v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
+        int iz = v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
+        auto& vox = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
+        vox.mNentries = (int)v->stat[o2::tpc::TrackResiduals::VoxV];
+        vox.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
+        vox.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
+        vox.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
       }
-      int iy = v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
-      int iz = v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
-      auto& vox = vRocData[iRow][iy * nZ2Xbins + iz];
-      vox.mNentries = (int)v->stat[o2::tpc::TrackResiduals::VoxV];
-      vox.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
-      vox.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
-      vox.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
-    }
+    };
+    processor.Process(myThread);
+  }
+
+  for (int iRoc = 0; iRoc < nROCs; iRoc++) {
 
     // now process the data row-by-row
 
@@ -615,7 +609,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
           bool isDataFound = false;
           for (int iy = 0; iy < nY2Xbins; iy++) {
             for (int iz = 0; iz < nZ2Xbins; iz++) {
-              auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+              auto& data = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
               auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
               // y/x coordinate of the bin ~-0.15 ... 0.15
               double y2x = trackResiduals.getY2X(xBin, iy);
@@ -661,7 +655,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
         for (int ismooth = 1; ismooth <= 2; ismooth++) {
           for (int iy = 0; iy < nY2Xbins; iy++) {
             for (int iz = 0; iz < nZ2Xbins; iz++) {
-              auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+              auto& data = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
               auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
               if (vox.mSmoothingStep <= ismooth) { // already filled
                 continue;
@@ -673,7 +667,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
               double w = 0.;
               bool filled = false;
               auto update = [&](int iy1, int iz1) {
-                auto& data1 = vRocData[iRow][iy1 * nZ2Xbins + iz1];
+                auto& data1 = vRocData[iRoc * nRows + iRow][iy1 * nZ2Xbins + iz1];
                 auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
                 if (vox1.mSmoothingStep >= ismooth) {
                   return false;
@@ -746,7 +740,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
         for (int iy = 0; iy < nY2Xbins; iy++) {
           for (int iz = 0; iz < nZ2Xbins; iz++) {
-            auto& data = vRocData[iRow][iy * nZ2Xbins + iz];
+            auto& data = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
             auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
             if (vox.mSmoothingStep > 2) {
               LOG(fatal) << "empty voxel is not repared";
@@ -812,7 +806,6 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
     for (auto& th : threads) {
       th.join();
     }
-
   } // iRoc
 
   LOGP(info, "Reading & reparing of the track residuals tooks: {}s", watch3.RealTime());

From 2ffa48f319f2f1670ee52bccc6a24968cd3de4f0 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Thu, 20 Jun 2024 15:15:41 +0000
Subject: [PATCH 1561/1764] TPC Splines: add limits for SP correction values
 per TPC row

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 18 +++-
 .../TPCFastSpaceChargeCorrection.h            | 96 ++++++++++++++-----
 .../macro/TPCFastTransformInit.C              | 15 +--
 3 files changed, 96 insertions(+), 33 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index ce0954120281f..e71340a555227 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -144,6 +144,9 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
         float* splineParameters = correction.getSplineData(slice, row);
         const std::vector<o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint>& data = mCorrectionMap.getPoints(slice, row);
         int nDataPoints = data.size();
+        auto& info = correction.getSliceRowInfo(slice, row);
+        info.resetMaxValues();
+        info.resetMaxValuesInv();
         if (nDataPoints >= 4) {
           std::vector<double> pointSU(nDataPoints);
           std::vector<double> pointSV(nDataPoints);
@@ -156,6 +159,8 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
             pointCorr[3 * i + 0] = dx;
             pointCorr[3 * i + 1] = du;
             pointCorr[3 * i + 2] = dv;
+            info.updateMaxValues(2. * dx, 2. * du, 2. * dv);
+            info.updateMaxValuesInv(-2. * dx, -2. * du, -2. * dv);
           }
           helper.approximateDataPoints(spline, splineParameters, 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), &pointSU[0],
                                        &pointSV[0], &pointCorr[0], nDataPoints);
@@ -767,9 +772,20 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
             double yStep = (yLast - yFirst) / 2;
 
+            double zFirst = z - dz / 2.;
+            double zLast = z + dz / 2.;
+            double zStep = (zLast - zFirst) / 2.;
+
+            if (0) { // no smoothing
+              yFirst = y;
+              yLast = y;
+              zFirst = z;
+              zLast = z;
+            }
+
             for (double py = yFirst; py <= yLast + yStep / 2.; py += yStep) {
 
-              for (double pz = z - dz / 2.; pz <= z + dz / 2. + 1.e-4; pz += dz / 2.) {
+              for (double pz = zFirst; pz <= zLast + zStep / 2.; pz += zStep) {
                 map.addCorrectionPoint(iRoc, iRow, py, pz, correctionX, correctionY,
                                        correctionZ);
               }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index b29d65b98458a..3fdc9b32e640c 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -58,15 +58,64 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   };
 
   struct SliceRowInfo {
-    float gridU0{0.f};           //< U coordinate of the U-grid start
-    float scaleUtoGrid{0.f};     //< scale U to U-grid coordinate
-    float gridV0{0.f};           ///< V coordinate of the V-grid start
-    float scaleVtoGrid{0.f};     //< scale V to V-grid coordinate
-    float gridCorrU0{0.f};       ///< U coordinate of the U-grid start for corrected U
-    float scaleCorrUtoGrid{0.f}; ///< scale corrected U to U-grid coordinate
-    float gridCorrV0{0.f};       ///< V coordinate of the V-grid start for corrected V
-    float scaleCorrVtoGrid{0.f}; ///< scale corrected V to V-grid coordinate
+    float gridU0{0.f};                        //< U coordinate of the U-grid start
+    float scaleUtoGrid{0.f};                  //< scale U to U-grid coordinate
+    float gridV0{0.f};                        ///< V coordinate of the V-grid start
+    float scaleVtoGrid{0.f};                  //< scale V to V-grid coordinate
+    float gridCorrU0{0.f};                    ///< U coordinate of the U-grid start for corrected U
+    float scaleCorrUtoGrid{0.f};              ///< scale corrected U to U-grid coordinate
+    float gridCorrV0{0.f};                    ///< V coordinate of the V-grid start for corrected V
+    float scaleCorrVtoGrid{0.f};              ///< scale corrected V to V-grid coordinate
+    float maxCorr[3]{10.f, 10.f, 10.f};       ///< max correction for dX, dU, dV
+    float minCorr[3]{-10.f, -10.f, -10.f};    ///< min correction for dX, dU, dV
+    float maxInvCorr[3]{10.f, 10.f, 10.f};    ///< max inverse correction for dX, dU, dV
+    float minInvCorr[3]{-10.f, -10.f, -10.f}; ///< min inverse correction for dX, dU, dV
     RowActiveArea activeArea;
+
+    void resetMaxValues()
+    {
+      maxCorr[0] = 1.f;
+      minCorr[0] = -1.f;
+      maxCorr[1] = 1.f;
+      minCorr[1] = -1.f;
+      maxCorr[2] = 1.f;
+      minCorr[2] = -1.f;
+    }
+
+    void updateMaxValues(float dx, float du, float dv)
+    {
+      maxCorr[0] = GPUCommonMath::Max(maxCorr[0], dx);
+      minCorr[0] = GPUCommonMath::Min(minCorr[0], dx);
+
+      maxCorr[1] = GPUCommonMath::Max(maxCorr[1], du);
+      minCorr[1] = GPUCommonMath::Min(minCorr[1], du);
+
+      maxCorr[2] = GPUCommonMath::Max(maxCorr[2], dv);
+      minCorr[2] = GPUCommonMath::Min(minCorr[2], dv);
+    }
+
+    void resetMaxValuesInv()
+    {
+      maxInvCorr[0] = 1.f;
+      minInvCorr[0] = -1.f;
+      maxInvCorr[1] = 1.f;
+      minInvCorr[1] = -1.f;
+      maxInvCorr[2] = 1.f;
+      minInvCorr[2] = -1.f;
+    }
+
+    void updateMaxValuesInv(float dx, float du, float dv)
+    {
+      maxInvCorr[0] = GPUCommonMath::Max(maxInvCorr[0], dx);
+      minInvCorr[0] = GPUCommonMath::Min(minInvCorr[0], dx);
+
+      maxInvCorr[1] = GPUCommonMath::Max(maxInvCorr[1], du);
+      minInvCorr[1] = GPUCommonMath::Min(minInvCorr[1], du);
+
+      maxInvCorr[2] = GPUCommonMath::Max(maxInvCorr[2], dv);
+      minInvCorr[2] = GPUCommonMath::Min(minInvCorr[2], dv);
+    }
+
     ClassDefNV(SliceRowInfo, 2);
   };
 
@@ -397,12 +446,10 @@ GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrection(int32_t slice, int32
   convUVtoGrid(slice, row, u, v, gridU, gridV);
   float dxuv[3];
   spline.interpolateU(splineData, gridU, gridV, dxuv);
-  if (CAMath::Abs(dxuv[0]) > 100 || CAMath::Abs(dxuv[1]) > 100 || CAMath::Abs(dxuv[2]) > 100) {
-    dxuv[0] = dxuv[1] = dxuv[2] = 0;
-  }
-  dx = dxuv[0];
-  du = dxuv[1];
-  dv = dxuv[2];
+  const auto& info = getSliceRowInfo(slice, row);
+  dx = GPUCommonMath::Max(info.minCorr[0], GPUCommonMath::Min(info.maxCorr[0], dxuv[0]));
+  du = GPUCommonMath::Max(info.minCorr[1], GPUCommonMath::Min(info.maxCorr[1], dxuv[1]));
+  dv = GPUCommonMath::Max(info.minCorr[2], GPUCommonMath::Min(info.maxCorr[2], dxuv[2]));
   return 0;
 }
 
@@ -414,12 +461,10 @@ GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionOld(int32_t slice, in
   convUVtoGrid(slice, row, u, v, gridU, gridV);
   float dxuv[3];
   spline.interpolateUold(splineData, gridU, gridV, dxuv);
-  if (CAMath::Abs(dxuv[0]) > 100 || CAMath::Abs(dxuv[1]) > 100 || CAMath::Abs(dxuv[2]) > 100) {
-    dxuv[0] = dxuv[1] = dxuv[2] = 0;
-  }
-  dx = dxuv[0];
-  du = dxuv[1];
-  dv = dxuv[2];
+  const auto& info = getSliceRowInfo(slice, row);
+  dx = GPUCommonMath::Max(info.minCorr[0], GPUCommonMath::Min(info.maxCorr[0], dxuv[0]));
+  du = GPUCommonMath::Max(info.minCorr[1], GPUCommonMath::Min(info.maxCorr[1], dxuv[1]));
+  dv = GPUCommonMath::Max(info.minCorr[2], GPUCommonMath::Min(info.maxCorr[2], dxuv[2]));
   return 0;
 }
 
@@ -433,9 +478,8 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvCorrectedX(
   const float* splineData = getSplineData(slice, row, 1);
   float dx = 0;
   spline.interpolateU(splineData, gridU, gridV, &dx);
-  if (CAMath::Abs(dx) > 100) {
-    dx = 0;
-  }
+  const auto& info = getSliceRowInfo(slice, row);
+  dx = GPUCommonMath::Max(info.minInvCorr[0], GPUCommonMath::Min(info.maxInvCorr[0], dx));
   x = mGeo.getRowInfo(row).x + dx;
 }
 
@@ -450,9 +494,9 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvUV(
 
   float duv[2];
   spline.interpolateU(splineData, gridU, gridV, duv);
-  if (CAMath::Abs(duv[0]) > 100 || CAMath::Abs(duv[1]) > 100) {
-    duv[0] = duv[1] = 0;
-  }
+  const auto& info = getSliceRowInfo(slice, row);
+  duv[0] = GPUCommonMath::Max(info.minInvCorr[1], GPUCommonMath::Min(info.maxInvCorr[1], duv[0]));
+  duv[1] = GPUCommonMath::Max(info.minInvCorr[2], GPUCommonMath::Min(info.maxInvCorr[2], duv[1]));
   nomU = corrU - duv[0];
   nomV = corrV - duv[1];
 }
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index bf3e14d552715..6134f33bcc423 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -21,8 +21,6 @@
 /// root -l TPCFastTransformInit.C'("debugVoxRes.root")'
 ///
 
-#include "Algorithm/RangeTokenizer.h"
-
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 
 #include <filesystem>
@@ -41,6 +39,8 @@
 #include "TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h"
 #endif
 
+#include "Algorithm/RangeTokenizer.h"
+
 using namespace o2::tpc;
 using namespace o2::gpu;
 
@@ -99,8 +99,9 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   trackResiduals.setZ2XBinning(z2xBins);
   trackResiduals.init();
 
-  {
-    std::cout << "input track residuals: " << std::endl;
+  { // debug output
+
+    std::cout << " ===== input track residuals ==== " << std::endl;
     std::cout << "voxel tree y2xBins: " << y2xBins.size() << std::endl;
 
     for (auto y2x : y2xBins) {
@@ -127,6 +128,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     for (int i = 0; i < nZ2Xbins; i++) {
       std::cout << "getZ2X(bin) : " << trackResiduals.getZ2X(i) << std::endl;
     }
+    std::cout << " ==================================== " << std::endl;
   }
 
   std::cout << "create fast transformation ... " << std::endl;
@@ -310,6 +312,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     geo.convUVtoLocal(iRoc, u + cu, v + cv, cy, cz);
     cy -= y;
     cz -= z;
+
     double d[3] = {cx - correctionX, cy - correctionY, cz - correctionZ};
     if (voxEntries >= 1.) {
       for (int i = 0; i < 3; i++) {
@@ -317,8 +320,8 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
           maxDiff[i] = d[i];
           maxDiffRoc[i] = iRoc;
           maxDiffRow[i] = iRow;
-          std::cout << " roc " << iRoc << " row " << iRow << " xyz " << i
-                    << " diff " << d[i] << " entries " << voxEntries << " y " << y2xBin << " z " << z2xBin << std::endl;
+          // std::cout << " roc " << iRoc << " row " << iRow << " xyz " << i
+          //  << " diff " << d[i] << " entries " << voxEntries << " y " << y2xBin << " z " << z2xBin << std::endl;
         }
         sumDiff[i] += d[i] * d[i];
       }

From 552c46fb3fc56278ae4396724567828e6cf740f6 Mon Sep 17 00:00:00 2001
From: sgorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Fri, 5 Jul 2024 00:09:05 +0200
Subject: [PATCH 1562/1764] TPC Splines: disable smoothing

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 106 ++++++++++--------
 1 file changed, 61 insertions(+), 45 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index e71340a555227..acaf9c474e275 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -411,10 +411,14 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   int nY2Xbins = trackResiduals.getNY2XBins();
   int nZ2Xbins = trackResiduals.getNZ2XBins();
 
+  double marginY2X = trackResiduals.getY2X(0, 2) - trackResiduals.getY2X(0, 0);
+  double marginZ2X = trackResiduals.getZ2X(1) - trackResiduals.getZ2X(0);
+
   std::vector<int> yBinsInt;
   {
     std::vector<double> yBins;
-    yBins.reserve(nY2Xbins);
+    yBins.reserve(nY2Xbins + 2);
+    yBins.push_back(trackResiduals.getY2X(0, 0) - marginY2X);
     for (int i = 0, j = nY2Xbins - 1; i <= j; i += 2, j -= 2) {
       if (i == j) {
         yBins.push_back(trackResiduals.getY2X(0, i));
@@ -425,6 +429,8 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
         yBins.push_back(trackResiduals.getY2X(0, j));
       }
     }
+    yBins.push_back(trackResiduals.getY2X(0, nY2Xbins - 1) + marginY2X);
+
     std::sort(yBins.begin(), yBins.end());
     double dy = yBins[1] - yBins[0];
     for (int i = 1; i < yBins.size(); i++) {
@@ -452,10 +458,13 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   std::vector<int> zBinsInt;
   {
     std::vector<double> zBins;
-    zBins.reserve(nZ2Xbins);
+    zBins.reserve(nZ2Xbins + 2);
+    zBins.push_back(-(trackResiduals.getZ2X(0) - marginZ2X));
     for (int i = 0; i < nZ2Xbins; i += 2) {
       zBins.push_back(-trackResiduals.getZ2X(i));
     }
+    zBins.push_back(-(trackResiduals.getZ2X(nZ2Xbins - 1) + 2. * marginZ2X));
+
     std::sort(zBins.begin(), zBins.end());
     double dz = zBins[1] - zBins[0];
     for (int i = 1; i < zBins.size(); i++) {
@@ -465,7 +474,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
     }
     zBinsInt.reserve(zBins.size());
     // spline knots must be positioned on the grid with an integer internal coordinate
-    // lets copy the knot positions with the accuracy of 0.1*dz
+    // lets copy the knot positions with the accuracy of 0.01*dz
     dz = dz / 10.;
     double z0 = zBins[0];
     double z1 = zBins[zBins.size() - 1];
@@ -525,10 +534,10 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       const auto& rowInfo = geo.getRowInfo(iRow);
       auto& info = correction.getSliceRowInfo(iRoc, iRow);
       const auto& spline = correction.getSpline(iRoc, iRow);
-      double yMin = rowInfo.x * trackResiduals.getY2X(iRow, 0);
-      double yMax = rowInfo.x * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
-      double zMin = rowInfo.x * trackResiduals.getZ2X(0);
-      double zMax = rowInfo.x * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
+      double yMin = rowInfo.x * (trackResiduals.getY2X(iRow, 0) - marginY2X);
+      double yMax = rowInfo.x * (trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1) + marginY2X);
+      double zMin = rowInfo.x * (trackResiduals.getZ2X(0) - marginZ2X);
+      double zMax = rowInfo.x * (trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1) + 2. * marginZ2X);
       double uMin = yMin;
       double uMax = yMax;
       double vMin = geo.getTPCzLength(iRoc) - zMax;
@@ -585,6 +594,12 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
         vox.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
         vox.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
         vox.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
+        if (0 && vox.mNentries < 1) {
+          vox.mCx = 0.;
+          vox.mCy = 0.;
+          vox.mCz = 0.;
+          vox.mNentries = 1;
+        }
       }
     };
     processor.Process(myThread);
@@ -711,29 +726,27 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
         // feed the row data to the helper
 
-        double yMin = 0., yMax = 0.;
+        double yMin = 0., yMax = 0., zMin = 0.;
+
+        auto& info = correction.getSliceRowInfo(iRoc, iRow);
+        const auto& spline = correction.getSpline(iRoc, iRow);
 
         {
-          float u, v;
-          if (iRoc < geo.getNumberOfSlicesA()) {
-            geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
-          } else {
-            geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
-          }
-          float py, pz;
-          geo.convUVtoLocal(iRoc, u, v, py, pz);
-          yMin = py;
-        }
-        {
-          float u, v;
+          float u0, u1, v0, v1;
+          correction.convGridToUV(iRoc, iRow, 0., 0., u0, v0);
+          correction.convGridToUV(iRoc, iRow,
+                                  spline.getGridX1().getUmax(), spline.getGridX2().getUmax(), u1, v1);
+          float y0, y1, z0, z1;
+          geo.convUVtoLocal(iRoc, u0, v0, y0, z0);
+          geo.convUVtoLocal(iRoc, u1, v1, y1, z1);
           if (iRoc < geo.getNumberOfSlicesA()) {
-            geo.convScaledUVtoUV(iRoc, iRow, 1., 0., u, v);
+            yMin = y0;
+            yMax = y1;
           } else {
-            geo.convScaledUVtoUV(iRoc, iRow, 0., 0., u, v);
+            yMin = y1;
+            yMax = y0;
           }
-          float py, pz;
-          geo.convUVtoLocal(iRoc, u, v, py, pz);
-          yMax = py;
+          zMin = z1;
         }
 
         double zEdge = 0.;
@@ -759,28 +772,22 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
             double correctionY = data.mCy;
             double correctionZ = data.mCz;
 
-            double yFirst = y - dy / 2.;
-            double yLast = y + dy / 2.;
+            double yStep = dy / 2.;
+            double zStep = dz / 2.;
+
+            double yFirst = y;
+            double yLast = y;
+            double zFirst = z;
+            double zLast = z;
 
             if (iy == 0) { // extend value of the first Y bin to the row edge
               yFirst = yMin;
+              yStep = (yLast - yFirst) / 2.;
             }
 
             if (iy == nY2Xbins - 1) { // extend value of the last Y bin to the row edge
               yLast = yMax;
-            }
-
-            double yStep = (yLast - yFirst) / 2;
-
-            double zFirst = z - dz / 2.;
-            double zLast = z + dz / 2.;
-            double zStep = (zLast - zFirst) / 2.;
-
-            if (0) { // no smoothing
-              yFirst = y;
-              yLast = y;
-              zFirst = z;
-              zLast = z;
+              yStep = (yLast - yFirst) / 2.;
             }
 
             for (double py = yFirst; py <= yLast + yStep / 2.; py += yStep) {
@@ -790,9 +797,19 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
                                        correctionZ);
               }
 
+              if (iz == 0) { // extend value of the first Z bin to Z=0.
+                int nZsteps = 2;
+                for (int is = 0; is < nZsteps; is++) {
+                  double pz = z + (zMin - z) * (is + 1.) / nZsteps;
+                  double s = 1.; //(nZsteps - 1. - is) / nZsteps;
+                  map.addCorrectionPoint(iRoc, iRow, py, pz, s * correctionX,
+                                         s * correctionY, s * correctionZ);
+                }
+              }
+
               if (iz == nZ2Xbins - 1) {
-                // extend value of the first Z bin to the readout, linear decrease of all values to 0.
-                int nZsteps = 3;
+                // extend value of the last Z bin to the readout, linear decrease of all values to 0.
+                int nZsteps = 2;
                 for (int is = 0; is < nZsteps; is++) {
                   double pz = z + (zEdge - z) * (is + 1.) / nZsteps;
                   double s = (nZsteps - 1. - is) / nZsteps;
@@ -803,9 +820,8 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
             }
           } // iz
         }   // iy
-
-      } // iRow
-    };  // myThread
+      }     // iRow
+    };      // myThread
 
     // run n threads
 

From bc7e81e7766c4390137eb847ba5ab3e2d5c92f75 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sgorbuno@lxi096.gsi.de>
Date: Thu, 18 Jul 2024 20:27:35 +0200
Subject: [PATCH 1563/1764] TPC Splines: smooth to linear edges, crop at grid
 borders, use mean position of residuals

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 302 ++++++++----------
 GPU/TPCFastTransformation/Spline1DSpec.h      |  20 +-
 .../TPCFastSpaceChargeCorrection.cxx          |  28 +-
 .../TPCFastSpaceChargeCorrection.h            |  31 +-
 .../macro/TPCFastTransformInit.C              |  44 +--
 5 files changed, 207 insertions(+), 218 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index acaf9c474e275..82a23dfa5242a 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -159,8 +159,8 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
             pointCorr[3 * i + 0] = dx;
             pointCorr[3 * i + 1] = du;
             pointCorr[3 * i + 2] = dv;
-            info.updateMaxValues(2. * dx, 2. * du, 2. * dv);
-            info.updateMaxValuesInv(-2. * dx, -2. * du, -2. * dv);
+            info.updateMaxValues(20. * dx, 20. * du, 20. * dv);
+            info.updateMaxValuesInv(-20. * dx, -20. * du, -20. * dv);
           }
           helper.approximateDataPoints(spline, splineParameters, 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), &pointSU[0],
                                        &pointSV[0], &pointCorr[0], nDataPoints);
@@ -411,95 +411,69 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   int nY2Xbins = trackResiduals.getNY2XBins();
   int nZ2Xbins = trackResiduals.getNZ2XBins();
 
-  double marginY2X = trackResiduals.getY2X(0, 2) - trackResiduals.getY2X(0, 0);
-  double marginZ2X = trackResiduals.getZ2X(1) - trackResiduals.getZ2X(0);
+  std::vector<double> uvBinsDouble[2];
 
-  std::vector<int> yBinsInt;
-  {
-    std::vector<double> yBins;
-    yBins.reserve(nY2Xbins + 2);
-    yBins.push_back(trackResiduals.getY2X(0, 0) - marginY2X);
-    for (int i = 0, j = nY2Xbins - 1; i <= j; i += 2, j -= 2) {
-      if (i == j) {
-        yBins.push_back(trackResiduals.getY2X(0, i));
-      } else if (i + 1 == j) {
-        yBins.push_back(trackResiduals.getY2X(0, i));
-      } else {
-        yBins.push_back(trackResiduals.getY2X(0, i));
-        yBins.push_back(trackResiduals.getY2X(0, j));
-      }
+  uvBinsDouble[0].reserve(nY2Xbins);
+  uvBinsDouble[1].reserve(nZ2Xbins);
+
+  for (int i = 0, j = nY2Xbins - 1; i <= j; i += 2, j -= 2) {
+    uvBinsDouble[0].push_back(trackResiduals.getY2X(0, i));
+    if (j >= i + 1) {
+      uvBinsDouble[0].push_back(trackResiduals.getY2X(0, j));
     }
-    yBins.push_back(trackResiduals.getY2X(0, nY2Xbins - 1) + marginY2X);
+  }
 
-    std::sort(yBins.begin(), yBins.end());
-    double dy = yBins[1] - yBins[0];
-    for (int i = 1; i < yBins.size(); i++) {
-      if (yBins[i] - yBins[i - 1] < dy) {
-        dy = yBins[i] - yBins[i - 1];
+  for (int i = 0, j = nZ2Xbins - 1; i <= j; i += 2, j -= 2) {
+    uvBinsDouble[1].push_back(-trackResiduals.getZ2X(i));
+    if (j >= i + 1) {
+      uvBinsDouble[1].push_back(-trackResiduals.getZ2X(j));
+    }
+  }
+
+  std::vector<int> uvBinsInt[2];
+
+  for (int iuv = 0; iuv < 2; iuv++) {
+    auto& bins = uvBinsDouble[iuv];
+    std::sort(bins.begin(), bins.end());
+
+    auto& binsInt = uvBinsInt[iuv];
+    binsInt.reserve(bins.size());
+
+    double dy = bins[1] - bins[0];
+    for (int i = 2; i < bins.size(); i++) {
+      double dd = bins[i] - bins[i - 1];
+      if (dd < dy) {
+        dy = dd;
       }
     }
-    yBinsInt.reserve(yBins.size());
     // spline knots must be positioned on the grid with integer internal coordinate
     // take the knot position accuracy of 0.1*dy
     dy = dy / 10.;
-    double y0 = yBins[0];
-    double y1 = yBins[yBins.size() - 1];
-    for (auto& y : yBins) {
+    double y0 = bins[0];
+    double y1 = bins[bins.size() - 1];
+    for (auto& y : bins) {
       y -= y0;
       int iy = int(y / dy + 0.5);
-      yBinsInt.push_back(iy);
+      binsInt.push_back(iy);
       double yold = y / (y1 - y0) * 2 - 1.;
       y = iy * dy;
       y = y / (y1 - y0) * 2 - 1.;
-      LOG(info) << "convert y bin: " << yold << " -> " << y << " -> " << iy;
-    }
-  }
-
-  std::vector<int> zBinsInt;
-  {
-    std::vector<double> zBins;
-    zBins.reserve(nZ2Xbins + 2);
-    zBins.push_back(-(trackResiduals.getZ2X(0) - marginZ2X));
-    for (int i = 0; i < nZ2Xbins; i += 2) {
-      zBins.push_back(-trackResiduals.getZ2X(i));
-    }
-    zBins.push_back(-(trackResiduals.getZ2X(nZ2Xbins - 1) + 2. * marginZ2X));
-
-    std::sort(zBins.begin(), zBins.end());
-    double dz = zBins[1] - zBins[0];
-    for (int i = 1; i < zBins.size(); i++) {
-      if (zBins[i] - zBins[i - 1] < dz) {
-        dz = zBins[i] - zBins[i - 1];
+      if (iuv == 0) {
+        LOG(info) << "convert y bin: " << yold << " -> " << y << " -> " << iy;
+      } else {
+        LOG(info) << "convert z bin: " << yold << " -> " << y << " -> " << iy;
       }
     }
-    zBinsInt.reserve(zBins.size());
-    // spline knots must be positioned on the grid with an integer internal coordinate
-    // lets copy the knot positions with the accuracy of 0.01*dz
-    dz = dz / 10.;
-    double z0 = zBins[0];
-    double z1 = zBins[zBins.size() - 1];
-    for (auto& z : zBins) {
-      z -= z0;
-      int iz = int(z / dz + 0.5);
-      zBinsInt.push_back(iz);
-      double zold = z / (z1 - z0);
-      z = iz * dz;
-      z = z / (z1 - z0);
-      LOG(info) << "convert z bin: " << zold << " -> " << z << " -> " << iz;
-    }
-  }
 
-  if (yBinsInt.size() < 2) {
-    yBinsInt.clear();
-    yBinsInt.push_back(0);
-    yBinsInt.push_back(1);
+    if (binsInt.size() < 2) {
+      binsInt.clear();
+      binsInt.push_back(0);
+      binsInt.push_back(1);
+    }
   }
 
-  if (zBinsInt.size() < 2) {
-    zBinsInt.clear();
-    zBinsInt.push_back(0);
-    zBinsInt.push_back(1);
-  }
+  auto& yBinsInt = uvBinsInt[0];
+  auto& zBinsInt = uvBinsInt[1];
 
   int nKnotsY = yBinsInt.size();
   int nKnotsZ = zBinsInt.size();
@@ -534,10 +508,10 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       const auto& rowInfo = geo.getRowInfo(iRow);
       auto& info = correction.getSliceRowInfo(iRoc, iRow);
       const auto& spline = correction.getSpline(iRoc, iRow);
-      double yMin = rowInfo.x * (trackResiduals.getY2X(iRow, 0) - marginY2X);
-      double yMax = rowInfo.x * (trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1) + marginY2X);
-      double zMin = rowInfo.x * (trackResiduals.getZ2X(0) - marginZ2X);
-      double zMax = rowInfo.x * (trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1) + 2. * marginZ2X);
+      double yMin = rowInfo.x * trackResiduals.getY2X(iRow, 0);
+      double yMax = rowInfo.x * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
+      double zMin = rowInfo.x * trackResiduals.getZ2X(0);
+      double zMax = rowInfo.x * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
       double uMin = yMin;
       double uMax = yMax;
       double vMin = geo.getTPCzLength(iRoc) - zMax;
@@ -563,6 +537,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
   struct VoxelData {
     int mNentries{0};    // number of entries
+    float mX, mY, mZ;    // mean position in the local coordinates
     float mCx, mCy, mCz; // corrections to the local coordinates
   };
 
@@ -589,16 +564,19 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
         }
         int iy = v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
         int iz = v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
-        auto& vox = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
-        vox.mNentries = (int)v->stat[o2::tpc::TrackResiduals::VoxV];
-        vox.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
-        vox.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
-        vox.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
-        if (0 && vox.mNentries < 1) {
-          vox.mCx = 0.;
-          vox.mCy = 0.;
-          vox.mCz = 0.;
-          vox.mNentries = 1;
+        auto& data = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
+        data.mNentries = (int)v->stat[o2::tpc::TrackResiduals::VoxV];
+        data.mX = v->stat[o2::tpc::TrackResiduals::VoxX];
+        data.mY = v->stat[o2::tpc::TrackResiduals::VoxF];
+        data.mZ = v->stat[o2::tpc::TrackResiduals::VoxZ];
+        data.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
+        data.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
+        data.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
+        if (0 && data.mNentries < 1) {
+          data.mCx = 0.;
+          data.mCy = 0.;
+          data.mCz = 0.;
+          data.mNentries = 1;
         }
       }
     };
@@ -642,10 +620,27 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
               if (iRoc >= geo.getNumberOfSlicesA()) {
                 vox.mZ = -vox.mZ;
               }
+              data.mY *= x;
+              data.mZ *= x;
+              /*
+              if ( fabs(x - data.mX) > 0.01 || fabs(vox.mY - data.mY) > 5. || fabs(vox.mZ - data.mZ) > 5.) {
+                std::cout
+                  << " roc " << iRoc << " row " << iRow
+                  << " voxel x " << x << " y " << vox.mY << " z " << vox.mZ
+                  << " data x " << data.mX << " y " << data.mY << " z " << data.mZ
+                  << std::endl;
+              }
+              */
+              if (1) { // always use voxel center instead of the mean position
+                data.mY = vox.mY;
+                data.mZ = vox.mZ;
+              }
               if (data.mNentries < 1) { // no data
                 data.mCx = 0.;
                 data.mCy = 0.;
                 data.mCz = 0.;
+                data.mY = vox.mY;
+                data.mZ = vox.mZ;
                 vox.mSmoothingStep = 100;
               } else { // voxel contains data
                 if (invertSigns) {
@@ -726,102 +721,59 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
         // feed the row data to the helper
 
-        double yMin = 0., yMax = 0., zMin = 0.;
-
         auto& info = correction.getSliceRowInfo(iRoc, iRow);
         const auto& spline = correction.getSpline(iRoc, iRow);
 
-        {
-          float u0, u1, v0, v1;
-          correction.convGridToUV(iRoc, iRow, 0., 0., u0, v0);
-          correction.convGridToUV(iRoc, iRow,
-                                  spline.getGridX1().getUmax(), spline.getGridX2().getUmax(), u1, v1);
-          float y0, y1, z0, z1;
-          geo.convUVtoLocal(iRoc, u0, v0, y0, z0);
-          geo.convUVtoLocal(iRoc, u1, v1, y1, z1);
-          if (iRoc < geo.getNumberOfSlicesA()) {
-            yMin = y0;
-            yMax = y1;
-          } else {
-            yMin = y1;
-            yMax = y0;
+        auto addEdge = [&](int iy1, int iz1, int iy2, int iz2, int nSteps) {
+          auto& data1 = vRocData[iRoc * nRows + iRow][iy1 * nZ2Xbins + iz1];
+          auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
+          auto& data2 = vRocData[iRoc * nRows + iRow][iy2 * nZ2Xbins + iz2];
+          auto& vox2 = vRowVoxels[iy2 * nZ2Xbins + iz2];
+          if (vox1.mSmoothingStep > 2) {
+            LOG(fatal) << "empty voxel is not repared: y " << iy1 << " z " << iz1;
           }
-          zMin = z1;
-        }
-
-        double zEdge = 0.;
-        if (iRoc < geo.getNumberOfSlicesA()) {
-          zEdge = geo.getTPCzLengthA();
-        } else {
-          zEdge = -geo.getTPCzLengthC();
-        }
+          if (vox2.mSmoothingStep > 2) {
+            LOG(fatal) << "empty voxel is not repared: y " << iy2 << " z " << iz2;
+          }
+          double y1 = vox1.mY;
+          double z1 = vox1.mZ;
+          double cx1 = data1.mCx;
+          double cy1 = data1.mCy;
+          double cz1 = data1.mCz;
+          double y2 = vox2.mY;
+          double z2 = vox2.mZ;
+          double cx2 = data2.mCx;
+          double cy2 = data2.mCy;
+          double cz2 = data2.mCz;
+
+          for (int is = 0; is < nSteps; is++) {
+            double s2 = is / (double)nSteps;
+            double s1 = 1. - s2;
+            double y = s1 * y1 + s2 * y2;
+            double z = s1 * z1 + s2 * z2;
+            double cx = s1 * cx1 + s2 * cx2;
+            double cy = s1 * cy1 + s2 * cy2;
+            double cz = s1 * cz1 + s2 * cz2;
+            map.addCorrectionPoint(iRoc, iRow, y, z, cx, cy, cz);
+          }
+        };
 
         for (int iy = 0; iy < nY2Xbins; iy++) {
-          for (int iz = 0; iz < nZ2Xbins; iz++) {
-            auto& data = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
-            auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
-            if (vox.mSmoothingStep > 2) {
-              LOG(fatal) << "empty voxel is not repared";
-            }
-
-            double y = vox.mY;
-            double z = vox.mZ;
-            double dy = vox.mDy;
-            double dz = vox.mDz;
-            double correctionX = data.mCx;
-            double correctionY = data.mCy;
-            double correctionZ = data.mCz;
-
-            double yStep = dy / 2.;
-            double zStep = dz / 2.;
-
-            double yFirst = y;
-            double yLast = y;
-            double zFirst = z;
-            double zLast = z;
-
-            if (iy == 0) { // extend value of the first Y bin to the row edge
-              yFirst = yMin;
-              yStep = (yLast - yFirst) / 2.;
-            }
-
-            if (iy == nY2Xbins - 1) { // extend value of the last Y bin to the row edge
-              yLast = yMax;
-              yStep = (yLast - yFirst) / 2.;
-            }
-
-            for (double py = yFirst; py <= yLast + yStep / 2.; py += yStep) {
-
-              for (double pz = zFirst; pz <= zLast + zStep / 2.; pz += zStep) {
-                map.addCorrectionPoint(iRoc, iRow, py, pz, correctionX, correctionY,
-                                       correctionZ);
-              }
+          for (int iz = 0; iz < nZ2Xbins - 1; iz++) {
+            addEdge(iy, iz, iy, iz + 1, 3);
+          }
+          addEdge(iy, nZ2Xbins - 1, iy, nZ2Xbins - 1, 1);
+        }
 
-              if (iz == 0) { // extend value of the first Z bin to Z=0.
-                int nZsteps = 2;
-                for (int is = 0; is < nZsteps; is++) {
-                  double pz = z + (zMin - z) * (is + 1.) / nZsteps;
-                  double s = 1.; //(nZsteps - 1. - is) / nZsteps;
-                  map.addCorrectionPoint(iRoc, iRow, py, pz, s * correctionX,
-                                         s * correctionY, s * correctionZ);
-                }
-              }
+        for (int iz = 0; iz < nZ2Xbins; iz++) {
+          for (int iy = 0; iy < nY2Xbins - 1; iy++) {
+            addEdge(iy, iz, iy + 1, iz, 3);
+          }
+          addEdge(nY2Xbins - 1, iz, nY2Xbins - 1, iz, 1);
+        } // iy
 
-              if (iz == nZ2Xbins - 1) {
-                // extend value of the last Z bin to the readout, linear decrease of all values to 0.
-                int nZsteps = 2;
-                for (int is = 0; is < nZsteps; is++) {
-                  double pz = z + (zEdge - z) * (is + 1.) / nZsteps;
-                  double s = (nZsteps - 1. - is) / nZsteps;
-                  map.addCorrectionPoint(iRoc, iRow, py, pz, s * correctionX,
-                                         s * correctionY, s * correctionZ);
-                }
-              }
-            }
-          } // iz
-        }   // iy
-      }     // iRow
-    };      // myThread
+      } // iRow
+    };  // myThread
 
     // run n threads
 
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 6462f291d1136..dc59e77e308a1 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -313,6 +313,14 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
   {
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
     const auto nYdim = nYdimTmp.get();
+
+    if (u < (DataT)0) {
+      u = (DataT)0;
+    }
+    if (u > (DataT)TBase::getUmax()) {
+      u = (DataT)TBase::getUmax();
+    }
+
     T uu = T(u - knotL.u);
     T li = T(knotL.Li);
     T v = uu * li; // scaled u
@@ -337,11 +345,19 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
   }
 
   template <typename T>
-  GPUd() static void getUderivatives(const Knot& knotL, DataT u,
-                                     T& dSl, T& dDl, T& dSr, T& dDr)
+  GPUd() void getUderivatives(const Knot& knotL, DataT u,
+                              T& dSl, T& dDl, T& dSr, T& dDr) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline values Sl, Sr and the slopes Dl, Dr
+
+    if (u < (DataT)0) {
+      u = (DataT)0;
+    }
+    if (u > (DataT)TBase::getUmax()) {
+      u = (DataT)TBase::getUmax();
+    }
+
     u = u - knotL.u;
     T v = u * T(knotL.Li); // scaled u
     T vm1 = v - 1.;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 35c6e43daa43b..eb69983cf87ce 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -116,11 +116,11 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
 
   mClassVersion = obj.mClassVersion;
 
-  for (int i = 0; i < TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
+  for (int32_t i = 0; i < TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
     mRowInfos[i] = obj.mRowInfos[i];
   }
 
-  for (int i = 0; i < TPCFastTransformGeo::getNumberOfSlices() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
+  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfSlices() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
     mSliceRowInfos[i] = obj.mSliceRowInfos[i];
   }
 
@@ -141,7 +141,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
   /// Sets the actual location of the external flat buffer after it has been moved (e.g. to another maschine)
 
   struct RowInfoVersion3 {
-    int splineScenarioID{0};      ///< scenario index (which of Spline2D splines to use)
+    int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
     size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC slice
   };
 
@@ -199,24 +199,24 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
   if (mClassVersion == 3) { // copy old-format slicerow data from the buffer to the arrays
 
     auto* rowInfosOld = reinterpret_cast<RowInfoVersion3*>(mFlatBufferPtr + rowsOffset);
-    for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+    for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
       RowInfoVersion3& infoOld = rowInfosOld[i];
       RowInfo& info = mRowInfos[i];
       info.splineScenarioID = infoOld.splineScenarioID;
-      for (int is = 0; is < 3; is++) {
+      for (int32_t is = 0; is < 3; is++) {
         info.dataOffsetBytes[is] = infoOld.dataOffsetBytes[is];
       }
     }
 
-    for (int is = 0; is < mNumberOfScenarios; is++) {
+    for (int32_t is = 0; is < mNumberOfScenarios; is++) {
       auto& spline = mScenarioPtr[is];
       spline.setXrange(0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax());
     }
 
     auto* sliceRowInfosOld = reinterpret_cast<SliceRowInfoVersion3*>(mFlatBufferPtr + sliceRowsOffset);
 
-    for (int slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
-      for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
+    for (int32_t slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
+      for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
         SliceRowInfoVersion3& infoOld = sliceRowInfosOld[mGeo.getNumberOfRows() * slice + row];
         SliceRowInfo& info = getSliceRowInfo(slice, row);
         const auto& spline = getSpline(slice, row);
@@ -236,7 +236,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
         info.activeArea.cuMin = infoOld.activeArea.cuMin;
         info.activeArea.cuMax = infoOld.activeArea.cuMax;
         info.activeArea.cvMax = infoOld.activeArea.cvMax;
-        for (int i = 0; i < 5; i++) {
+        for (int32_t i = 0; i < 5; i++) {
           info.activeArea.maxDriftLengthCheb[i] = infoOld.activeArea.maxDriftLengthCheb[i];
         }
       }
@@ -256,7 +256,7 @@ void TPCFastSpaceChargeCorrection::setFutureBufferAddress(char* futureFlatBuffer
   char* oldBuffer = mFlatBufferPtr;
   char* newBuffer = futureFlatBufferPtr;
 
-  for (int i = 0; i < mNumberOfScenarios; i++) {
+  for (int32_t i = 0; i < mNumberOfScenarios; i++) {
     SplineType& sp = mScenarioPtr[i];
     char* newSplineBuf = relocatePointer(oldBuffer, newBuffer, sp.getFlatBufferPtr());
     sp.setFutureBufferAddress(newSplineBuf);
@@ -278,7 +278,7 @@ void TPCFastSpaceChargeCorrection::print() const
   LOG(info) << "  mSliceDataSizeBytes = " << mSliceDataSizeBytes[0] << " " << mSliceDataSizeBytes[1] << " " << mSliceDataSizeBytes[2];
   {
     LOG(info) << "  TPC rows: ";
-    for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+    for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
       const RowInfo& r = mRowInfos[i];
       LOG(info) << " tpc row " << i << ": splineScenarioID = " << r.splineScenarioID << " dataOffsetBytes = " << r.dataOffsetBytes;
     }
@@ -331,7 +331,7 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
 
   assert(mConstructionScenarios != nullptr);
 
-  for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+  for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
     mRowInfos[i].splineScenarioID = -1;
   }
 
@@ -378,7 +378,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 
   assert(mConstructionMask & ConstructionState::InProgress);
 
-  for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+  for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
     assert(mRowInfos[i].splineScenarioID >= 0);
   }
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -404,7 +404,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   for (int32_t is = 0; is < 3; is++) {
     sliceDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
     mSliceDataSizeBytes[is] = 0;
-    for (int i = 0; i < mGeo.getNumberOfRows(); i++) {
+    for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
       RowInfo& row = mRowInfos[i];
       SplineType& spline = mConstructionScenarios[row.splineScenarioID];
       row.dataOffsetBytes[is] = alignSize(mSliceDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 3fdc9b32e640c..e69983fab9175 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -251,7 +251,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() float getInterpolationSafetyMargin() const { return fInterpolationSafetyMargin; }
 
   /// Gives TPC row info
-  GPUd() const RowInfo& getRowInfo(int row) const { return mRowInfos[row]; }
+  GPUd() const RowInfo& getRowInfo(int32_t row) const { return mRowInfos[row]; }
 
   /// Gives TPC slice info
   GPUd() const SliceInfo& getSliceInfo(int32_t slice) const
@@ -321,7 +321,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// Class version. It is used to read older versions from disc.
   /// The default version 3 is the one before this field was introduced.
   /// The actual version must be set in startConstruction().
-  int mClassVersion{3};
+  int32_t mClassVersion{3};
 
   RowInfo mRowInfos[TPCFastTransformGeo::getMaxNumberOfRows()]; ///< RowInfo array
 
@@ -447,9 +447,17 @@ GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrection(int32_t slice, int32
   float dxuv[3];
   spline.interpolateU(splineData, gridU, gridV, dxuv);
   const auto& info = getSliceRowInfo(slice, row);
-  dx = GPUCommonMath::Max(info.minCorr[0], GPUCommonMath::Min(info.maxCorr[0], dxuv[0]));
-  du = GPUCommonMath::Max(info.minCorr[1], GPUCommonMath::Min(info.maxCorr[1], dxuv[1]));
-  dv = GPUCommonMath::Max(info.minCorr[2], GPUCommonMath::Min(info.maxCorr[2], dxuv[2]));
+  float s = v / info.gridV0;
+  if (s < 0.) {
+    s = 0.;
+  }
+  if (s > 1.) {
+    s = 1.;
+  }
+
+  dx = GPUCommonMath::Max(info.minCorr[0], GPUCommonMath::Min(info.maxCorr[0], s * dxuv[0]));
+  du = GPUCommonMath::Max(info.minCorr[1], GPUCommonMath::Min(info.maxCorr[1], s * dxuv[1]));
+  dv = GPUCommonMath::Max(info.minCorr[2], GPUCommonMath::Min(info.maxCorr[2], s * dxuv[2]));
   return 0;
 }
 
@@ -462,9 +470,16 @@ GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionOld(int32_t slice, in
   float dxuv[3];
   spline.interpolateUold(splineData, gridU, gridV, dxuv);
   const auto& info = getSliceRowInfo(slice, row);
-  dx = GPUCommonMath::Max(info.minCorr[0], GPUCommonMath::Min(info.maxCorr[0], dxuv[0]));
-  du = GPUCommonMath::Max(info.minCorr[1], GPUCommonMath::Min(info.maxCorr[1], dxuv[1]));
-  dv = GPUCommonMath::Max(info.minCorr[2], GPUCommonMath::Min(info.maxCorr[2], dxuv[2]));
+  float s = v / info.gridV0;
+  if (s < 0.) {
+    s = 0.;
+  }
+  if (s > 1.) {
+    s = 1.;
+  }
+  dx = GPUCommonMath::Max(info.minCorr[0], GPUCommonMath::Min(info.maxCorr[0], s * dxuv[0]));
+  du = GPUCommonMath::Max(info.minCorr[1], GPUCommonMath::Min(info.maxCorr[1], s * dxuv[1]));
+  dv = GPUCommonMath::Max(info.minCorr[2], GPUCommonMath::Min(info.maxCorr[2], s * dxuv[2]));
   return 0;
 }
 
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 6134f33bcc423..c4b0680f2edd4 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -109,10 +109,10 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     }
     std::cout << std::endl;
 
-    int nY2Xbins = trackResiduals.getNY2XBins();
+    int32_t nY2Xbins = trackResiduals.getNY2XBins();
 
     std::cout << " TrackResiduals y2x bins: " << nY2Xbins << std::endl;
-    for (int i = 0; i < nY2Xbins; i++) {
+    for (int32_t i = 0; i < nY2Xbins; i++) {
       std::cout << "scaled getY2X(bin) : " << trackResiduals.getY2X(0, i) / trackResiduals.getMaxY2X(0) << std::endl;
     }
 
@@ -123,9 +123,9 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     }
     std::cout << std::endl;
 
-    int nZ2Xbins = trackResiduals.getNZ2XBins();
+    int32_t nZ2Xbins = trackResiduals.getNZ2XBins();
     std::cout << " TrackResiduals z2x bins: " << nZ2Xbins << std::endl;
-    for (int i = 0; i < nZ2Xbins; i++) {
+    for (int32_t i = 0; i < nZ2Xbins; i++) {
       std::cout << "getZ2X(bin) : " << trackResiduals.getZ2X(i) << std::endl;
     }
     std::cout << " ==================================== " << std::endl;
@@ -138,6 +138,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   o2::tpc::TPCFastSpaceChargeCorrectionHelper* corrHelper = o2::tpc::TPCFastSpaceChargeCorrectionHelper::instance();
 
   corrHelper->setNthreadsToMaximum();
+  // corrHelper->setNthreads(1);
 
   auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, useSmoothed, invertSigns);
 
@@ -167,9 +168,9 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
 
       const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
-      // for (int iRoc = 0; iRoc < geo.getNumberOfSlices(); iRoc++) {
-      for (int iRoc = 0; iRoc < 1; iRoc++) {
-        for (int iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
+      // for (int32_t iRoc = 0; iRoc < geo.getNumberOfSlices(); iRoc++) {
+      for (int32_t iRoc = 0; iRoc < 1; iRoc++) {
+        for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
           auto& info = corr.getSliceRowInfo(iRoc, iRow);
           std::cout << "roc " << iRoc << " row " << iRow
                     << " gridV0 " << info.gridV0 << " gridCorrU0 " << info.gridCorrU0 << " gridCorrV0 " << info.gridCorrV0
@@ -257,8 +258,8 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   branch->SetAddress(&v);
   branch->SetAutoDelete(kTRUE);
 
-  int iRocLast = -1;
-  int iRowLast = -1;
+  int32_t iRocLast = -1;
+  int32_t iRowLast = -1;
 
   for (int32_t iVox = 0; iVox < voxResTree->GetEntriesFast(); iVox++) {
 
@@ -306,6 +307,11 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
       correctionZ *= -1.;
     }
 
+    if (voxEntries > 0.) { // use mean statistical positions instead of the bin centers:
+      y = x * v->stat[o2::tpc::TrackResiduals::VoxF];
+      z = x * v->stat[o2::tpc::TrackResiduals::VoxZ];
+    }
+
     float u, v, cx, cu, cv, cy, cz;
     geo.convLocalToUV(iRoc, y, z, u, v);
     corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
@@ -315,7 +321,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
 
     double d[3] = {cx - correctionX, cy - correctionY, cz - correctionZ};
     if (voxEntries >= 1.) {
-      for (int i = 0; i < 3; i++) {
+      for (int32_t i = 0; i < 3; i++) {
         if (fabs(maxDiff[i]) < fabs(d[i])) {
           maxDiff[i] = d[i];
           maxDiffRoc[i] = iRoc;
@@ -358,7 +364,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
         std::vector<double> p[2], g[2];
 
         p[0].push_back(geo.getRowInfo(iRow).getUmin());
-        for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
+        for (int32_t iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
           float u, v;
           corr.convGridToUV(iRoc, iRow, gridU.getKnot(iu).getU(), 0., u, v);
           g[0].push_back(u);
@@ -367,7 +373,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
         p[0].push_back(geo.getRowInfo(iRow).getUmax());
 
         p[1].push_back(0.);
-        for (int iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
+        for (int32_t iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
           float u, v;
           corr.convGridToUV(iRoc, iRow, 0., gridV.getKnot(iv).getU(), u, v);
           g[1].push_back(v);
@@ -375,22 +381,22 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
         }
         p[1].push_back(geo.getTPCzLength(iRoc));
 
-        for (int iuv = 0; iuv < 2; iuv++) {
-          int n = p[iuv].size();
-          for (unsigned int i = 0; i < n - 1; i++) {
+        for (int32_t iuv = 0; iuv < 2; iuv++) {
+          int32_t n = p[iuv].size();
+          for (int32_t i = 0; i < n - 1; i++) {
             double d = (p[iuv][i + 1] - p[iuv][i]) / 10.;
-            for (int ii = 1; ii < 10; ii++) {
+            for (int32_t ii = 1; ii < 10; ii++) {
               p[iuv].push_back(p[iuv][i] + d * ii);
             }
           }
           std::sort(p[iuv].begin(), p[iuv].end());
         }
 
-        for (int iter = 0; iter < 2; iter++) {
+        for (int32_t iter = 0; iter < 2; iter++) {
           std::vector<double>& pu = ((iter == 0) ? g[0] : p[0]);
           std::vector<double>& pv = ((iter == 0) ? g[1] : p[1]);
-          for (unsigned int iu = 0; iu < pu.size(); iu++) {
-            for (unsigned int iv = 0; iv < pv.size(); iv++) {
+          for (uint32_t iu = 0; iu < pu.size(); iu++) {
+            for (uint32_t iv = 0; iv < pv.size(); iv++) {
               float u = pu[iu];
               float v = pv[iv];
               float x, y, z;

From d15629fbfa3a511c9553cf08d03963a7c6b16a0f Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Thu, 16 Jan 2025 21:06:18 +0000
Subject: [PATCH 1564/1764] TPC Splines: fix the inverse correction

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 100 ++++++++++--------
 .../TPCFastSpaceChargeCorrection.cxx          |  70 +++++++-----
 .../TPCFastSpaceChargeCorrection.h            |  45 ++++----
 .../macro/TPCFastTransformInit.C              |  88 +++++++++------
 4 files changed, 179 insertions(+), 124 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 82a23dfa5242a..3696df5343ad3 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -146,7 +146,6 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
         int nDataPoints = data.size();
         auto& info = correction.getSliceRowInfo(slice, row);
         info.resetMaxValues();
-        info.resetMaxValuesInv();
         if (nDataPoints >= 4) {
           std::vector<double> pointSU(nDataPoints);
           std::vector<double> pointSV(nDataPoints);
@@ -160,7 +159,6 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
             pointCorr[3 * i + 1] = du;
             pointCorr[3 * i + 2] = dv;
             info.updateMaxValues(20. * dx, 20. * du, 20. * dv);
-            info.updateMaxValuesInv(-20. * dx, -20. * du, -20. * dv);
           }
           helper.approximateDataPoints(spline, splineParameters, 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), &pointSU[0],
                                        &pointSV[0], &pointCorr[0], nDataPoints);
@@ -908,46 +906,60 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
 
   for (int slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
     // LOG(info) << "inverse transform for slice " << slice ;
-    double vLength = (slice < mGeo.getNumberOfSlicesA()) ? mGeo.getTPCzLengthA() : mGeo.getTPCzLengthC();
 
     auto myThread = [&](int iThread) {
       Spline2DHelper<float> helper;
       std::vector<float> splineParameters;
-      ChebyshevFit1D chebFitterX, chebFitterU, chebFitterV;
 
       for (int row = iThread; row < mGeo.getNumberOfRows(); row += mNthreads) {
         TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(slice, row);
         helper.setSpline(spline, 10, 10);
-        std::vector<double> dataPointCU, dataPointCV, dataPointF;
-
-        float u0, u1, v0, v1;
-        mGeo.convScaledUVtoUV(slice, row, 0., 0., u0, v0);
-        mGeo.convScaledUVtoUV(slice, row, 1., 1., u1, v1);
 
         double x = mGeo.getRowInfo(row).x;
-        int nPointsU = (spline.getGridX1().getNumberOfKnots() - 1) * 10;
-        int nPointsV = (spline.getGridX2().getNumberOfKnots() - 1) * 10;
-
-        double stepU = (u1 - u0) / (nPointsU - 1);
-        double stepV = (v1 - v0) / (nPointsV - 1);
+        auto& sliceRowInfo = correction.getSliceRowInfo(slice, row);
 
-        if (prn) {
-          LOG(info) << "u0 " << u0 << " u1 " << u1 << " v0 " << v0 << " v1 " << v1;
+        std::vector<double> gridU;
+        {
+          const auto& grid = spline.getGridX1();
+          for (int i = 0; i < grid.getNumberOfKnots(); i++) {
+            if (i == grid.getNumberOfKnots() - 1) {
+              gridU.push_back(grid.getKnot(i).u);
+              break;
+            }
+            for (double s = 1.; s > 0.; s -= 0.1) {
+              gridU.push_back(s * grid.getKnot(i).u + (1. - s) * grid.getKnot(i + 1).u);
+            }
+          }
+        }
+        std::vector<double> gridV;
+        {
+          const auto& grid = spline.getGridX2();
+          for (int i = 0; i < grid.getNumberOfKnots(); i++) {
+            if (i == grid.getNumberOfKnots() - 1) {
+              gridV.push_back(grid.getKnot(i).u);
+              break;
+            }
+            for (double s = 1.; s > 0.; s -= 0.1) {
+              gridV.push_back(s * grid.getKnot(i).u + (1. - s) * grid.getKnot(i + 1).u);
+            }
+          }
         }
-        TPCFastSpaceChargeCorrection::RowActiveArea& area = correction.getSliceRowInfo(slice, row).activeArea;
+
+        std::vector<double> dataPointCU, dataPointCV, dataPointF;
+        dataPointCU.reserve(gridU.size() * gridV.size());
+        dataPointCV.reserve(gridU.size() * gridV.size());
+        dataPointF.reserve(gridU.size() * gridV.size());
+
+        TPCFastSpaceChargeCorrection::RowActiveArea& area = sliceRowInfo.activeArea;
         area.cuMin = 1.e10;
         area.cuMax = -1.e10;
+        double cvMin = 1.e10;
 
-        /*
-        v1 = area.vMax;
-        stepV = (v1 - v0) / (nPointsU - 1);
-        if (stepV < 1.f) {
-          stepV = 1.f;
-        }
-        */
+        for (int iu = 0; iu < gridU.size(); iu++) {
+          for (int iv = 0; iv < gridV.size(); iv++) {
+            float u, v;
+            correction.convGridToUV(slice, row, gridU[iu], gridV[iv], u, v);
 
-        for (double u = u0; u < u1 + stepU; u += stepU) {
-          for (double v = v0; v < v1 + stepV; v += stepV) {
             float dx, du, dv;
             correction.getCorrection(slice, row, u, v, dx, du, dv);
             dx *= scaling[0];
@@ -976,39 +988,41 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
             dataPointF.push_back(dx);
             dataPointF.push_back(du);
             dataPointF.push_back(dv);
-
-            if (prn) {
-              LOG(info) << "measurement cu " << cu << " cv " << cv << " dx " << dx << " du " << du << " dv " << dv;
-            }
-          } // v
-        }   // u
+          }
+        }
 
         if (area.cuMax - area.cuMin < 0.2) {
           area.cuMax = .1;
           area.cuMin = -.1;
         }
-        if (area.cvMax < 0.1) {
+        if (area.cvMax - cvMin < 0.2) {
           area.cvMax = .1;
+          cvMin = -.1;
         }
+
         if (prn) {
           LOG(info) << "slice " << slice << " row " << row << " max drift L = " << correction.getMaxDriftLength(slice, row)
                     << " active area: cuMin " << area.cuMin << " cuMax " << area.cuMax << " vMax " << area.vMax << " cvMax " << area.cvMax;
         }
 
-        TPCFastSpaceChargeCorrection::SliceRowInfo& info = correction.getSliceRowInfo(slice, row);
-        info.gridCorrU0 = area.cuMin;
-        info.scaleCorrUtoGrid = spline.getGridX1().getUmax() / (area.cuMax - area.cuMin);
-        info.scaleCorrVtoGrid = spline.getGridX2().getUmax() / area.cvMax;
+        // define the grid for the inverse correction
 
-        info.gridCorrU0 = u0;
-        info.gridCorrV0 = info.gridV0;
-        info.scaleCorrUtoGrid = spline.getGridX1().getUmax() / (u1 - info.gridCorrU0);
-        info.scaleCorrVtoGrid = spline.getGridX2().getUmax() / (v1 - info.gridCorrV0);
+        sliceRowInfo.gridCorrU0 = area.cuMin;
+        sliceRowInfo.gridCorrV0 = cvMin;
+        sliceRowInfo.scaleCorrUtoGrid = spline.getGridX1().getUmax() / (area.cuMax - area.cuMin);
+        sliceRowInfo.scaleCorrVtoGrid = spline.getGridX2().getUmax() / area.cvMax;
+
+        /*
+        sliceRowInfo.gridCorrU0 = sliceRowInfo.gridU0;
+        sliceRowInfo.gridCorrV0 = sliceRowInfo.gridV0;
+        sliceRowInfo.scaleCorrUtoGrid = sliceRowInfo.scaleUtoGrid;
+        sliceRowInfo.scaleCorrVtoGrid = sliceRowInfo.scaleVtoGrid;
+        */
 
         int nDataPoints = dataPointCU.size();
         for (int i = 0; i < nDataPoints; i++) {
-          dataPointCU[i] = (dataPointCU[i] - info.gridCorrU0) * info.scaleCorrUtoGrid;
-          dataPointCV[i] = (dataPointCV[i] - info.gridCorrV0) * info.scaleCorrVtoGrid;
+          dataPointCU[i] = (dataPointCU[i] - sliceRowInfo.gridCorrU0) * sliceRowInfo.scaleCorrUtoGrid;
+          dataPointCV[i] = (dataPointCV[i] - sliceRowInfo.gridCorrV0) * sliceRowInfo.scaleCorrVtoGrid;
         }
 
         splineParameters.resize(spline.getNumberOfParameters());
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index eb69983cf87ce..e519716b6eec0 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -19,6 +19,7 @@
 
 #if !defined(GPUCA_GPUCODE)
 #include <iostream>
+#include <string>
 #include <cmath>
 #include "Spline2DHelper.h"
 #endif
@@ -514,15 +515,41 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
   tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfSlicesA() / 2) + 1.;
   tpcR2max = tpcR2max * tpcR2max;
 
-  double maxDtpc[3] = {0, 0, 0};
-  double maxD = 0;
+  struct MaxValue {
+    double V{0.};
+    int Roc{-1};
+    int Row{-1};
+
+    void update(double v, int roc, int row)
+    {
+      if (fabs(v) > fabs(V)) {
+        V = v;
+        Roc = roc;
+        Row = row;
+      }
+    }
+    void update(const MaxValue& other)
+    {
+      update(other.V, other.Roc, other.Row);
+    }
+
+    std::string toString()
+    {
+      std::stringstream ss;
+      ss << V << "(" << Roc << "," << Row << ")";
+      return ss.str();
+    }
+  };
+
+  MaxValue maxDtpc[3];
+  MaxValue maxD;
 
   for (int32_t slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
     if (prn) {
       LOG(info) << "check inverse transform for slice " << slice;
     }
-    double vLength = (slice < mGeo.getNumberOfSlicesA()) ? mGeo.getTPCzLengthA() : mGeo.getTPCzLengthC();
-    double maxDslice[3] = {0, 0, 0};
+    double vLength = mGeo.getTPCzLength(slice);
+    MaxValue maxDslice[3];
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
       float u0, u1, v0, v1;
       mGeo.convScaledUVtoUV(slice, row, 0., 0., u0, v0);
@@ -530,9 +557,12 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
       double x = mGeo.getRowInfo(row).x;
       double stepU = (u1 - u0) / 100.;
       double stepV = (v1 - v0) / 100.;
-      double maxDrow[3] = {0, 0, 0};
+      MaxValue maxDrow[3];
       for (double u = u0; u < u1; u += stepU) {
         for (double v = v0; v < v1; v += stepV) {
+          if (v < getSliceRowInfo(slice, row).gridV0) {
+            continue;
+          }
           float dx, du, dv;
           getCorrection(slice, row, u, v, dx, du, dv);
           double cx = x + dx;
@@ -545,11 +575,9 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
           float nx, nu, nv;
           getCorrectionInvCorrectedX(slice, row, cu, cv, nx);
           getCorrectionInvUV(slice, row, cu, cv, nu, nv);
-          double d[3] = {nx - cx, nu - u, nv - v};
+          double d[3] = {(cx - nx) - dx, (cu - nu) - du, (cv - nv) - dv};
           for (int32_t i = 0; i < 3; i++) {
-            if (fabs(d[i]) > fabs(maxDrow[i])) {
-              maxDrow[i] = d[i];
-            }
+            maxDrow[i].update(d[i], slice, row);
           }
 
           if (0 && prn && fabs(d[0]) + fabs(d[1]) + fabs(d[2]) > 0.1) {
@@ -560,32 +588,26 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
           }
         }
       }
-      if (0 && prn) {
+      if (1 && prn) {
         LOG(info) << "slice " << slice << " row " << row
-                  << " dx " << maxDrow[0] << " du " << maxDrow[1] << " dv " << maxDrow[2];
+                  << " dx " << maxDrow[0].V << " du " << maxDrow[1].V << " dv " << maxDrow[2].V;
       }
       for (int32_t i = 0; i < 3; i++) {
-        if (fabs(maxDslice[i]) < fabs(maxDrow[i])) {
-          maxDslice[i] = maxDrow[i];
-        }
-        if (fabs(maxDtpc[i]) < fabs(maxDrow[i])) {
-          maxDtpc[i] = maxDrow[i];
-        }
-        if (fabs(maxD) < fabs(maxDrow[i])) {
-          maxD = maxDrow[i];
-        }
+        maxDslice[i].update(maxDrow[i]);
+        maxDtpc[i].update(maxDrow[i]);
+        maxD.update(maxDrow[i]);
       }
     }
     if (prn) {
-      LOG(info) << "inverse correction: slice " << slice
-                << " dx " << maxDslice[0] << " du " << maxDslice[1] << " dv " << maxDslice[2];
+      LOG(info) << "inverse correction: slice " << slice << ". Max deviations: "
+                << " dx " << maxDslice[0].toString() << " du " << maxDslice[1].toString() << " dv " << maxDslice[2].toString();
     }
   } // slice
 
   LOG(info) << "Test inverse TPC correction. max deviations: "
-            << " dx " << maxDtpc[0] << " du " << maxDtpc[1] << " dv " << maxDtpc[2] << " cm";
+            << " dx " << maxDtpc[0].toString() << " du " << maxDtpc[1].toString() << " dv " << maxDtpc[2].toString() << " cm";
 
-  return maxD;
+  return maxD.V;
 }
 
 #endif // GPUCA_GPUCODE
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index e69983fab9175..2d2940054023e 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -68,8 +68,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     float scaleCorrVtoGrid{0.f};              ///< scale corrected V to V-grid coordinate
     float maxCorr[3]{10.f, 10.f, 10.f};       ///< max correction for dX, dU, dV
     float minCorr[3]{-10.f, -10.f, -10.f};    ///< min correction for dX, dU, dV
-    float maxInvCorr[3]{10.f, 10.f, 10.f};    ///< max inverse correction for dX, dU, dV
-    float minInvCorr[3]{-10.f, -10.f, -10.f}; ///< min inverse correction for dX, dU, dV
     RowActiveArea activeArea;
 
     void resetMaxValues()
@@ -94,28 +92,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
       minCorr[2] = GPUCommonMath::Min(minCorr[2], dv);
     }
 
-    void resetMaxValuesInv()
-    {
-      maxInvCorr[0] = 1.f;
-      minInvCorr[0] = -1.f;
-      maxInvCorr[1] = 1.f;
-      minInvCorr[1] = -1.f;
-      maxInvCorr[2] = 1.f;
-      minInvCorr[2] = -1.f;
-    }
-
-    void updateMaxValuesInv(float dx, float du, float dv)
-    {
-      maxInvCorr[0] = GPUCommonMath::Max(maxInvCorr[0], dx);
-      minInvCorr[0] = GPUCommonMath::Min(minInvCorr[0], dx);
-
-      maxInvCorr[1] = GPUCommonMath::Max(maxInvCorr[1], du);
-      minInvCorr[1] = GPUCommonMath::Min(minInvCorr[1], du);
-
-      maxInvCorr[2] = GPUCommonMath::Max(maxInvCorr[2], dv);
-      minInvCorr[2] = GPUCommonMath::Min(minInvCorr[2], dv);
-    }
-
     ClassDefNV(SliceRowInfo, 2);
   };
 
@@ -494,7 +470,15 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvCorrectedX(
   float dx = 0;
   spline.interpolateU(splineData, gridU, gridV, &dx);
   const auto& info = getSliceRowInfo(slice, row);
-  dx = GPUCommonMath::Max(info.minInvCorr[0], GPUCommonMath::Min(info.maxInvCorr[0], dx));
+
+  float s = corrV / info.gridCorrV0;
+  if (s < 0.) {
+    s = 0.;
+  }
+  if (s > 1.) {
+    s = 1.;
+  }
+  dx = GPUCommonMath::Clamp(s * dx, info.minCorr[0], info.maxCorr[0]);
   x = mGeo.getRowInfo(row).x + dx;
 }
 
@@ -510,8 +494,15 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvUV(
   float duv[2];
   spline.interpolateU(splineData, gridU, gridV, duv);
   const auto& info = getSliceRowInfo(slice, row);
-  duv[0] = GPUCommonMath::Max(info.minInvCorr[1], GPUCommonMath::Min(info.maxInvCorr[1], duv[0]));
-  duv[1] = GPUCommonMath::Max(info.minInvCorr[2], GPUCommonMath::Min(info.maxInvCorr[2], duv[1]));
+  float s = corrV / info.gridCorrV0;
+  if (s < 0.) {
+    s = 0.;
+  }
+  if (s > 1.) {
+    s = 1.;
+  }
+  duv[0] = GPUCommonMath::Clamp(s * duv[0], info.minCorr[1], info.maxCorr[1]);
+  duv[1] = GPUCommonMath::Clamp(s * duv[1], info.minCorr[2], info.maxCorr[2]);
   nomU = corrU - duv[0];
   nomV = corrV - duv[1];
 }
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index c4b0680f2edd4..7e889d5a9e7db 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -202,41 +202,44 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   TFile* debugFile = new TFile("transformDebug.root", "RECREATE");
   debugFile->cd();
 
-  // ntuple with created TPC corrections
-  TNtuple* debugCorr = new TNtuple("corr", "corr", "iRoc:iRow:x:y:z:cx:cy:cz");
+  // debug ntuple with created TPC corrections
+  //
+  // measured x,y,z; corrections cx,cy,cz from the measured to the real x,y,z;
+  // inverse corrections ix,iy,iz at the real position (x+cx,y+cy,z+cz)
+  // ideally, ix = cx, iy = cy, iz = cz
+  TNtuple* debugCorr = new TNtuple("corr", "corr", "iRoc:iRow:x:y:z:cx:cy:cz:ix:iy:iz");
 
   debugCorr->SetMarkerStyle(8);
   debugCorr->SetMarkerSize(0.1);
   debugCorr->SetMarkerColor(kBlack);
 
-  // ntuple with the input data: voxel corrections
+  // ntuple with the input data: voxels and corrections
   debugFile->cd();
   TNtuple* debugVox =
-    new TNtuple("vox", "vox", "iRoc:iRow:n:x:y:z:vx:vy:vz:cx:cy:cz");
+    new TNtuple("vox", "vox", "iRoc:iRow:n:x:y:z:vx:vy:vz");
 
   debugVox->SetMarkerStyle(8);
   debugVox->SetMarkerSize(0.8);
   debugVox->SetMarkerColor(kBlue);
 
-  // duplicate of debugVox
+  // duplicate of debugVox + the spline data at voxels in a different color
   debugFile->cd();
   TNtuple* debugCorrVox =
-    new TNtuple("corrvox", "corrvox", "iRoc:iRow:n:x:y:z:vx:vy:vz:cx:cy:cz");
+    new TNtuple("corrvox", "corrvox", "iRoc:iRow:n:x:y:z:vx:vy:vz:cx:cy:cz:ix:iy:iz");
 
   debugCorrVox->SetMarkerStyle(8);
   debugCorrVox->SetMarkerSize(0.8);
   debugCorrVox->SetMarkerColor(kMagenta);
 
-  // ntuple with spline grid points
+  // corrections at the spline grid points
   debugFile->cd();
-  TNtuple* debugGrid = new TNtuple("grid", "grid", "iRoc:iRow:x:y:z:cx:cy:cz");
+  TNtuple* debugGrid = new TNtuple("grid", "grid", "iRoc:iRow:x:y:z:cx:cy:cz:ix:iy:iz");
 
   debugGrid->SetMarkerStyle(8);
   debugGrid->SetMarkerSize(1.2);
   debugGrid->SetMarkerColor(kBlack);
 
-  // ntuple with data points created from voxels (with data smearing and
-  // extension to the edges)
+  // ntuple with data points created from voxels (with the data smearing, extension to the edges etc.)
   debugFile->cd();
   TNtuple* debugPoints =
     new TNtuple("points", "points", "iRoc:iRow:x:y:z:px:py:pz:cx:cy:cz");
@@ -253,6 +256,34 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
 
   const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
+  auto getAllCorrections = [&](int iRoc, int iRow, float u, float v, float& x, float& y, float& z, float& cx, float& cy, float& cz, float& ix, float& iy, float& iz) {
+    // define x,y,z
+
+    x = geo.getRowInfo(iRow).x;
+    geo.convUVtoLocal(iRoc, u, v, y, z);
+
+    // get the corrections cx,cy,cz at x,y,z
+    float cu, cv;
+    corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
+    geo.convUVtoLocal(iRoc, cu, cv, cy, cz);
+
+    float corrected_u = u + cu;
+    float corrected_v = v + cv;
+    float corrected_x = x + cx;
+    float corrected_y, corrected_z;
+    geo.convUVtoLocal(iRoc, corrected_u, corrected_v, corrected_y, corrected_z);
+
+    // get the inverse corrections ix,iy,iz at the corrected x,y,z
+    float inverted_x, inverted_u, inverted_v, inverted_y, inverted_z;
+    corr.getCorrectionInvCorrectedX(iRoc, iRow, corrected_u, corrected_v, inverted_x);
+    corr.getCorrectionInvUV(iRoc, iRow, corrected_u, corrected_v, inverted_u, inverted_v);
+    geo.convUVtoLocal(iRoc, inverted_u, inverted_v, inverted_y, inverted_z);
+
+    ix = corrected_x - inverted_x;
+    iy = corrected_y - inverted_y;
+    iz = corrected_z - inverted_z;
+  };
+
   o2::tpc::TrackResiduals::VoxRes* v = nullptr;
   TBranch* branch = voxResTree->GetBranch("voxRes");
   branch->SetAddress(&v);
@@ -261,6 +292,8 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   int32_t iRocLast = -1;
   int32_t iRowLast = -1;
 
+  std::cout << "fill debug ntuples at voxels ..." << std::endl;
+
   for (int32_t iVox = 0; iVox < voxResTree->GetEntriesFast(); iVox++) {
 
     voxResTree->GetEntry(iVox);
@@ -312,12 +345,10 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
       z = x * v->stat[o2::tpc::TrackResiduals::VoxZ];
     }
 
-    float u, v, cx, cu, cv, cy, cz;
+    float u, v;
     geo.convLocalToUV(iRoc, y, z, u, v);
-    corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
-    geo.convUVtoLocal(iRoc, u + cu, v + cv, cy, cz);
-    cy -= y;
-    cz -= z;
+    float x1, y1, z1, cx, cy, cz, ix, iy, iz;
+    getAllCorrections(iRoc, iRow, u, v, x1, y1, z1, cx, cy, cz, ix, iy, iz);
 
     double d[3] = {cx - correctionX, cy - correctionY, cz - correctionZ};
     if (voxEntries >= 1.) {
@@ -334,13 +365,14 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
       nDiff++;
     }
 
-    debugVox->Fill(iRoc, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ,
-                   cx, cy, cz);
+    debugVox->Fill(iRoc, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ);
+
     debugCorrVox->Fill(iRoc, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ,
-                       cx, cy, cz);
+                       cx, cy, cz, ix, iy, iz);
   }
 
-  std::cout << "create debug ntuples ..." << std::endl;
+  std::cout
+    << "fill debug ntuples everywhere .." << std::endl;
 
   for (int32_t iRoc = 0; iRoc < geo.getNumberOfSlices(); iRoc++) {
     // for (int32_t iRoc = 0; iRoc < 1; iRoc++) {
@@ -399,18 +431,14 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
             for (uint32_t iv = 0; iv < pv.size(); iv++) {
               float u = pu[iu];
               float v = pv[iv];
-              float x, y, z;
-              geo.convUVtoLocal(iRoc, u, v, y, z);
-              float cx, cu, cv;
-              corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
-              float cy, cz;
-              geo.convUVtoLocal(iRoc, u + cu, v + cv, cy, cz);
-              cy -= y;
-              cz -= z;
+
+              float x, y, z, cx, cy, cz, ix, iy, iz;
+              getAllCorrections(iRoc, iRow, u, v, x, y, z, cx, cy, cz, ix, iy, iz);
+
               if (iter == 0) {
-                debugGrid->Fill(iRoc, iRow, x, y, z, cx, cy, cz);
+                debugGrid->Fill(iRoc, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
               } else {
-                debugCorr->Fill(iRoc, iRow, x, y, z, cx, cy, cz);
+                debugCorr->Fill(iRoc, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
               }
             }
           }
@@ -462,7 +490,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   std::cout << "Mean difference in x,y,z : " << sumDiff[0] << " " << sumDiff[1]
             << " " << sumDiff[2] << std::endl;
 
-  corr.testInverse(0);
+  corr.testInverse(true);
 
   debugFile->cd();
   debugCorr->Write();

From 2caa885e6231d3aa71291cd5d451c9f9c8ca78f9 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Mon, 27 Jan 2025 17:35:50 +0000
Subject: [PATCH 1565/1764] TPC Splines: fix reading track residuals

---
 .../src/TPCFastSpaceChargeCorrectionHelper.cxx           | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 3696df5343ad3..c0bba6f4908a8 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -457,9 +457,9 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       y = iy * dy;
       y = y / (y1 - y0) * 2 - 1.;
       if (iuv == 0) {
-        LOG(info) << "convert y bin: " << yold << " -> " << y << " -> " << iy;
+        LOG(info) << "TPC SC splines: convert y bin: " << yold << " -> " << y << " -> " << iy;
       } else {
-        LOG(info) << "convert z bin: " << yold << " -> " << y << " -> " << iy;
+        LOG(info) << "TPC SC splines: convert z bin: " << yold << " -> " << y << " -> " << iy;
       }
     }
 
@@ -514,11 +514,12 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       double uMax = yMax;
       double vMin = geo.getTPCzLength(iRoc) - zMax;
       double vMax = geo.getTPCzLength(iRoc) - zMin;
-      // std::cout << " uMin: " << uMin << " uMax: " << yuMax << " zMin: " << vMin << " zMax: " << vMax << std::endl;
       info.gridU0 = uMin;
       info.scaleUtoGrid = spline.getGridX1().getUmax() / (uMax - uMin);
       info.gridV0 = vMin;
       info.scaleVtoGrid = spline.getGridX2().getUmax() / (vMax - vMin);
+      // std::cout << " iRoc " << iRoc << " iRow " << iRow << " uMin: " << uMin << " uMax: " << uMax << " vMin: " << vMin << " vMax: " << vMax
+      //<< " grid scale u "<< info.scaleUtoGrid << " grid scale v "<< info.scaleVtoGrid<< std::endl;
     }
   }
 
@@ -629,7 +630,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
                   << std::endl;
               }
               */
-              if (1) { // always use voxel center instead of the mean position
+              if (0) { // debug: always use voxel center instead of the mean position
                 data.mY = vox.mY;
                 data.mZ = vox.mZ;
               }

From d5fc994e621f559e7d0d063c05c0a0048143b378 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Mon, 27 Jan 2025 17:37:35 +0000
Subject: [PATCH 1566/1764] TPC Splines: fix scaling splines outside of the
 measured area

---
 .../TPCFastSpaceChargeCorrection.h            | 152 +++++++-----------
 1 file changed, 54 insertions(+), 98 deletions(-)

diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 2d2940054023e..7957d36b494c3 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -58,16 +58,16 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   };
 
   struct SliceRowInfo {
-    float gridU0{0.f};                        //< U coordinate of the U-grid start
-    float scaleUtoGrid{0.f};                  //< scale U to U-grid coordinate
-    float gridV0{0.f};                        ///< V coordinate of the V-grid start
-    float scaleVtoGrid{0.f};                  //< scale V to V-grid coordinate
-    float gridCorrU0{0.f};                    ///< U coordinate of the U-grid start for corrected U
-    float scaleCorrUtoGrid{0.f};              ///< scale corrected U to U-grid coordinate
-    float gridCorrV0{0.f};                    ///< V coordinate of the V-grid start for corrected V
-    float scaleCorrVtoGrid{0.f};              ///< scale corrected V to V-grid coordinate
-    float maxCorr[3]{10.f, 10.f, 10.f};       ///< max correction for dX, dU, dV
-    float minCorr[3]{-10.f, -10.f, -10.f};    ///< min correction for dX, dU, dV
+    float gridU0{0.f};                     //< U coordinate of the U-grid start
+    float scaleUtoGrid{0.f};               //< scale U to U-grid coordinate
+    float gridV0{0.f};                     ///< V coordinate of the V-grid start
+    float scaleVtoGrid{0.f};               //< scale V to V-grid coordinate
+    float gridCorrU0{0.f};                 ///< U coordinate of the U-grid start for corrected U
+    float scaleCorrUtoGrid{0.f};           ///< scale corrected U to U-grid coordinate
+    float gridCorrV0{0.f};                 ///< V coordinate of the V-grid start for corrected V
+    float scaleCorrVtoGrid{0.f};           ///< scale corrected V to V-grid coordinate
+    float maxCorr[3]{10.f, 10.f, 10.f};    ///< max correction for dX, dU, dV
+    float minCorr[3]{-10.f, -10.f, -10.f}; ///< min correction for dX, dU, dV
     RowActiveArea activeArea;
 
     void resetMaxValues()
@@ -199,12 +199,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   /// _______________  Utilities  _______________________________________________
 
-  /// shrink u,v coordinats to the TPC row area +/- fkInterpolationSafetyMargin
-  GPUd() void schrinkUV(int32_t slice, int32_t row, float& u, float& v) const;
-
-  /// shrink corrected u,v coordinats to the TPC row area +/- fkInterpolationSafetyMargin
-  GPUd() void schrinkCorrectedUV(int32_t slice, int32_t row, float& corrU, float& corrV) const;
-
   /// convert u,v to internal grid coordinates
   GPUd() void convUVtoGrid(int32_t slice, int32_t row, float u, float v, float& gridU, float& gridV) const;
 
@@ -338,60 +332,9 @@ GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t slice,
   return reinterpret_cast<float*>(mSplineData[iSpline] + mSliceDataSizeBytes[iSpline] * slice + rowInfo.dataOffsetBytes[iSpline]);
 }
 
-GPUdi() void TPCFastSpaceChargeCorrection::schrinkUV(int32_t slice, int32_t row, float& u, float& v) const
-{
-  /// shrink u,v coordinats to the TPC row area +/- fInterpolationSafetyMargin
-
-  const TPCFastTransformGeo::RowInfo& rowInfo = mGeo.getRowInfo(row);
-
-  float uWidth05 = rowInfo.getUwidth() * (0.5f + fInterpolationSafetyMargin);
-  float vWidth = mGeo.getTPCzLength(slice);
-
-  if (u < -uWidth05) {
-    u = -uWidth05;
-  }
-  if (u > uWidth05) {
-    u = uWidth05;
-  }
-  if (v < -0.1f * vWidth) {
-    v = -0.1f * vWidth;
-  }
-  if (v > 1.1f * vWidth) {
-    v = 1.1f * vWidth;
-  }
-}
-
-GPUdi() void TPCFastSpaceChargeCorrection::schrinkCorrectedUV(int32_t slice, int32_t row, float& corrU, float& corrV) const
-{
-  /// shrink corrected u,v coordinats to the TPC row area +/- fInterpolationSafetyMargin
-
-  const TPCFastTransformGeo::RowInfo& rowInfo = mGeo.getRowInfo(row);
-  const SliceRowInfo& sliceRowInfo = getSliceRowInfo(slice, row);
-
-  float uMargin = fInterpolationSafetyMargin * rowInfo.getUwidth();
-  float vMargin = fInterpolationSafetyMargin * mGeo.getTPCzLength(slice);
-
-  if (corrU < sliceRowInfo.activeArea.cuMin - uMargin) {
-    corrU = sliceRowInfo.activeArea.cuMin - uMargin;
-  }
-
-  if (corrU > sliceRowInfo.activeArea.cuMax + uMargin) {
-    corrU = sliceRowInfo.activeArea.cuMax + uMargin;
-  }
-
-  if (corrV < 0.f - vMargin) {
-    corrV = 0.f - vMargin;
-  }
-
-  if (corrV > sliceRowInfo.activeArea.cvMax + vMargin) {
-    corrV = sliceRowInfo.activeArea.cvMax + vMargin;
-  }
-}
-
 GPUdi() void TPCFastSpaceChargeCorrection::convUVtoGrid(int32_t slice, int32_t row, float u, float v, float& gu, float& gv) const
 {
-  schrinkUV(slice, row, u, v);
-  const SliceRowInfo& info = getSliceRowInfo(slice, row);
+  const auto& info = getSliceRowInfo(slice, row);
   gu = (u - info.gridU0) * info.scaleUtoGrid;
   gv = (v - info.gridV0) * info.scaleVtoGrid;
 }
@@ -406,34 +349,36 @@ GPUdi() void TPCFastSpaceChargeCorrection::convGridToUV(int32_t slice, int32_t r
 
 GPUdi() void TPCFastSpaceChargeCorrection::convCorrectedUVtoGrid(int32_t slice, int32_t row, float corrU, float corrV, float& gridU, float& gridV) const
 {
-  schrinkCorrectedUV(slice, row, corrU, corrV);
-
-  const SliceRowInfo& sliceRowInfo = getSliceRowInfo(slice, row);
-
-  gridU = (corrU - sliceRowInfo.gridCorrU0) * sliceRowInfo.scaleCorrUtoGrid;
-  gridV = (corrV - sliceRowInfo.gridCorrV0) * sliceRowInfo.scaleCorrVtoGrid;
+  const SliceRowInfo& info = getSliceRowInfo(slice, row);
+  gridU = (corrU - info.gridCorrU0) * info.scaleCorrUtoGrid;
+  gridV = (corrV - info.gridCorrV0) * info.scaleCorrVtoGrid;
 }
 
 GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrection(int32_t slice, int32_t row, float u, float v, float& dx, float& du, float& dv) const
 {
+  const auto& info = getSliceRowInfo(slice, row);
   const SplineType& spline = getSpline(slice, row);
   const float* splineData = getSplineData(slice, row);
   float gridU = 0, gridV = 0;
   convUVtoGrid(slice, row, u, v, gridU, gridV);
+  // shrink to the grid area
+  gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
+  gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
+
   float dxuv[3];
   spline.interpolateU(splineData, gridU, gridV, dxuv);
-  const auto& info = getSliceRowInfo(slice, row);
+
   float s = v / info.gridV0;
-  if (s < 0.) {
-    s = 0.;
-  }
-  if (s > 1.) {
-    s = 1.;
+
+  if (v >= info.gridV0) {
+    s = 1.f;
+  } else if (v <= 0.f) {
+    s = 0.f;
   }
 
-  dx = GPUCommonMath::Max(info.minCorr[0], GPUCommonMath::Min(info.maxCorr[0], s * dxuv[0]));
-  du = GPUCommonMath::Max(info.minCorr[1], GPUCommonMath::Min(info.maxCorr[1], s * dxuv[1]));
-  dv = GPUCommonMath::Max(info.minCorr[2], GPUCommonMath::Min(info.maxCorr[2], s * dxuv[2]));
+  dx = GPUCommonMath::Clamp(s * dxuv[0], info.minCorr[0], info.maxCorr[0]);
+  du = GPUCommonMath::Clamp(s * dxuv[1], info.minCorr[1], info.maxCorr[1]);
+  dv = GPUCommonMath::Clamp(s * dxuv[2], info.minCorr[2], info.maxCorr[2]);
   return 0;
 }
 
@@ -462,22 +407,28 @@ GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionOld(int32_t slice, in
 GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvCorrectedX(
   int32_t slice, int32_t row, float corrU, float corrV, float& x) const
 {
+  const auto& info = getSliceRowInfo(slice, row);
+  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(slice, row));
+  const float* splineData = getSplineData(slice, row, 1);
+
   float gridU, gridV;
   convCorrectedUVtoGrid(slice, row, corrU, corrV, gridU, gridV);
 
-  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(slice, row));
-  const float* splineData = getSplineData(slice, row, 1);
+  // shrink to the grid area
+  gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
+  gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
+
   float dx = 0;
   spline.interpolateU(splineData, gridU, gridV, &dx);
-  const auto& info = getSliceRowInfo(slice, row);
 
   float s = corrV / info.gridCorrV0;
-  if (s < 0.) {
-    s = 0.;
-  }
-  if (s > 1.) {
-    s = 1.;
+
+  if (corrV >= info.gridCorrV0) {
+    s = 1.f;
+  } else if (corrV <= 0.f) {
+    s = 0.f;
   }
+
   dx = GPUCommonMath::Clamp(s * dx, info.minCorr[0], info.maxCorr[0]);
   x = mGeo.getRowInfo(row).x + dx;
 }
@@ -485,22 +436,27 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvCorrectedX(
 GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvUV(
   int32_t slice, int32_t row, float corrU, float corrV, float& nomU, float& nomV) const
 {
+  const Spline2D<float, 2>& spline = reinterpret_cast<const Spline2D<float, 2>&>(getSpline(slice, row));
+  const float* splineData = getSplineData(slice, row, 2);
+
   float gridU, gridV;
   convCorrectedUVtoGrid(slice, row, corrU, corrV, gridU, gridV);
 
-  const Spline2D<float, 2>& spline = reinterpret_cast<const Spline2D<float, 2>&>(getSpline(slice, row));
-  const float* splineData = getSplineData(slice, row, 2);
+  // shrink to the grid area
+  gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
+  gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
 
   float duv[2];
   spline.interpolateU(splineData, gridU, gridV, duv);
   const auto& info = getSliceRowInfo(slice, row);
   float s = corrV / info.gridCorrV0;
-  if (s < 0.) {
-    s = 0.;
-  }
-  if (s > 1.) {
-    s = 1.;
+
+  if (corrV >= info.gridCorrV0) {
+    s = 1.f;
+  } else if (corrV <= 0.f) {
+    s = 0.f;
   }
+
   duv[0] = GPUCommonMath::Clamp(s * duv[0], info.minCorr[1], info.maxCorr[1]);
   duv[1] = GPUCommonMath::Clamp(s * duv[1], info.minCorr[2], info.maxCorr[2]);
   nomU = corrU - duv[0];

From 020b243ecb859232223db86d63b1a97ab1d783c5 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Mon, 27 Jan 2025 19:41:36 +0000
Subject: [PATCH 1567/1764] TPC Splines: rename Slice -> Roc in geometry

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 110 +++----
 .../src/TPCFastTransformHelperO2.cxx          |   4 +-
 .../test/testTPCFastTransform.cxx             |  30 +-
 .../TPCFastSpaceChargeCorrection.cxx          | 130 ++++----
 .../TPCFastSpaceChargeCorrection.h            | 146 ++++-----
 GPU/TPCFastTransformation/TPCFastTransform.h  | 278 +++++++++---------
 .../TPCFastTransformGeo.cxx                   |  24 +-
 .../TPCFastTransformGeo.h                     | 107 +++----
 .../TPCFastTransformManager.cxx               |  26 +-
 .../TPCFastTransformationLinkDef_O2.h         |   6 +-
 .../macro/generateTPCCorrectionNTuple.C       |  24 +-
 11 files changed, 443 insertions(+), 442 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index c0bba6f4908a8..bac332a837c55 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -134,17 +134,17 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
 
   LOG(info) << "fast space charge correction helper: init from data points";
 
-  for (int slice = 0; slice < correction.getGeometry().getNumberOfSlices(); slice++) {
+  for (int roc = 0; roc < correction.getGeometry().getNumberOfRocs(); roc++) {
 
     auto myThread = [&](int iThread) {
       for (int row = iThread; row < correction.getGeometry().getNumberOfRows(); row += mNthreads) {
 
-        TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSpline(slice, row);
+        TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSpline(roc, row);
         Spline2DHelper<float> helper;
-        float* splineParameters = correction.getSplineData(slice, row);
-        const std::vector<o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint>& data = mCorrectionMap.getPoints(slice, row);
+        float* splineParameters = correction.getSplineData(roc, row);
+        const std::vector<o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint>& data = mCorrectionMap.getPoints(roc, row);
         int nDataPoints = data.size();
-        auto& info = correction.getSliceRowInfo(slice, row);
+        auto& info = correction.getRocRowInfo(roc, row);
         info.resetMaxValues();
         if (nDataPoints >= 4) {
           std::vector<double> pointSU(nDataPoints);
@@ -152,7 +152,7 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
           std::vector<double> pointCorr(3 * nDataPoints); // 3 dimensions
           for (int i = 0; i < nDataPoints; ++i) {
             double su, sv, dx, du, dv;
-            getSpaceChargeCorrection(correction, slice, row, data[i], su, sv, dx, du, dv);
+            getSpaceChargeCorrection(correction, roc, row, data[i], su, sv, dx, du, dv);
             pointSU[i] = su;
             pointSV[i] = sv;
             pointCorr[3 * i + 0] = dx;
@@ -182,7 +182,7 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
       th.join();
     }
 
-  } // slice
+  } // roc
 
   watch.Stop();
 
@@ -191,7 +191,7 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
   initInverse(correction, 0);
 }
 
-void TPCFastSpaceChargeCorrectionHelper::getSpaceChargeCorrection(const TPCFastSpaceChargeCorrection& correction, int slice, int row, o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p,
+void TPCFastSpaceChargeCorrectionHelper::getSpaceChargeCorrection(const TPCFastSpaceChargeCorrection& correction, int roc, int row, o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p,
                                                                   double& su, double& sv, double& dx, double& du, double& dv)
 {
   // get space charge correction in internal TPCFastTransform coordinates su,sv->dx,du,dv
@@ -202,14 +202,14 @@ void TPCFastSpaceChargeCorrectionHelper::getSpaceChargeCorrection(const TPCFastS
 
   // not corrected coordinates in u,v
   float u = 0.f, v = 0.f, fsu = 0.f, fsv = 0.f;
-  mGeo.convLocalToUV(slice, p.mY, p.mZ, u, v);
-  correction.convUVtoGrid(slice, row, u, v, fsu, fsv);
-  // mGeo.convUVtoScaledUV(slice, row, u, v, fsu, fsv);
+  mGeo.convLocalToUV(roc, p.mY, p.mZ, u, v);
+  correction.convUVtoGrid(roc, row, u, v, fsu, fsv);
+  // mGeo.convUVtoScaledUV(roc, row, u, v, fsu, fsv);
   su = fsu;
   sv = fsv;
   // corrected coordinates in u,v
   float u1 = 0.f, v1 = 0.f;
-  mGeo.convLocalToUV(slice, p.mY + p.mDy, p.mZ + p.mDz, u1, v1);
+  mGeo.convLocalToUV(roc, p.mY + p.mDy, p.mZ + p.mDz, u1, v1);
 
   dx = p.mDx;
   du = u1 - u;
@@ -286,7 +286,7 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
     /// set space charge correction in the local coordinates
     /// as a continious function
 
-    int nRocs = mGeo.getNumberOfSlices();
+    int nRocs = mGeo.getNumberOfRocs();
     int nRows = mGeo.getNumberOfRows();
     mCorrectionMap.init(nRocs, nRows);
 
@@ -337,8 +337,8 @@ void TPCFastSpaceChargeCorrectionHelper::testGeometry(const TPCFastTransformGeo&
 {
   const Mapper& mapper = Mapper::instance();
 
-  if (geo.getNumberOfSlices() != Sector::MAXSECTOR) {
-    LOG(fatal) << "Wrong number of sectors :" << geo.getNumberOfSlices() << " instead of " << Sector::MAXSECTOR << std::endl;
+  if (geo.getNumberOfRocs() != Sector::MAXSECTOR) {
+    LOG(fatal) << "Wrong number of sectors :" << geo.getNumberOfRocs() << " instead of " << Sector::MAXSECTOR << std::endl;
   }
 
   if (geo.getNumberOfRows() != mapper.getNumberOfRows()) {
@@ -404,7 +404,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
   o2::gpu::TPCFastSpaceChargeCorrectionMap& map = helper->getCorrectionMap();
-  map.init(geo.getNumberOfSlices(), geo.getNumberOfRows());
+  map.init(geo.getNumberOfRocs(), geo.getNumberOfRows());
 
   int nY2Xbins = trackResiduals.getNY2XBins();
   int nZ2Xbins = trackResiduals.getNZ2XBins();
@@ -480,7 +480,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   // std::cout << "n knots Z: " << nKnotsZ << std::endl;
 
   const int nRows = geo.getNumberOfRows();
-  const int nROCs = geo.getNumberOfSlices();
+  const int nROCs = geo.getNumberOfRocs();
 
   { // create the correction object
 
@@ -501,10 +501,10 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   } // .. create the correction object
 
   // set the grid borders
-  for (int iRoc = 0; iRoc < geo.getNumberOfSlices(); iRoc++) {
+  for (int iRoc = 0; iRoc < geo.getNumberOfRocs(); iRoc++) {
     for (int iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
       const auto& rowInfo = geo.getRowInfo(iRow);
-      auto& info = correction.getSliceRowInfo(iRoc, iRow);
+      auto& info = correction.getRocRowInfo(iRoc, iRow);
       const auto& spline = correction.getSpline(iRoc, iRow);
       double yMin = rowInfo.x * trackResiduals.getY2X(iRow, 0);
       double yMax = rowInfo.x * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
@@ -616,7 +616,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
               vox.mZ = x * z2x;
               vox.mDy = x / trackResiduals.getDY2XI(xBin, iy);
               vox.mDz = x * trackResiduals.getDZ2X(iz);
-              if (iRoc >= geo.getNumberOfSlicesA()) {
+              if (iRoc >= geo.getNumberOfRocsA()) {
                 vox.mZ = -vox.mZ;
               }
               data.mY *= x;
@@ -720,7 +720,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
         // feed the row data to the helper
 
-        auto& info = correction.getSliceRowInfo(iRoc, iRow);
+        auto& info = correction.getRocRowInfo(iRoc, iRow);
         const auto& spline = correction.getSpline(iRoc, iRow);
 
         auto addEdge = [&](int iy1, int iz1, int iy2, int iz2, int nSteps) {
@@ -813,21 +813,21 @@ void TPCFastSpaceChargeCorrectionHelper::initMaxDriftLength(o2::gpu::TPCFastSpac
   double tpcR2min = mGeo.getRowInfo(0).x - 1.;
   tpcR2min = tpcR2min * tpcR2min;
   double tpcR2max = mGeo.getRowInfo(mGeo.getNumberOfRows() - 1).x;
-  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfSlicesA() / 2) + 1.;
+  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfRocsA() / 2) + 1.;
   tpcR2max = tpcR2max * tpcR2max;
 
   ChebyshevFit1D chebFitter;
 
-  for (int slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
+  for (int roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
     if (prn) {
-      LOG(info) << "init MaxDriftLength for slice " << slice;
+      LOG(info) << "init MaxDriftLength for roc " << roc;
     }
-    double vLength = (slice < mGeo.getNumberOfSlicesA()) ? mGeo.getTPCzLengthA() : mGeo.getTPCzLengthC();
-    TPCFastSpaceChargeCorrection::SliceInfo& sliceInfo = correction.getSliceInfo(slice);
-    sliceInfo.vMax = 0.f;
+    double vLength = (roc < mGeo.getNumberOfRocsA()) ? mGeo.getTPCzLengthA() : mGeo.getTPCzLengthC();
+    TPCFastSpaceChargeCorrection::RocInfo& rocInfo = correction.getRocInfo(roc);
+    rocInfo.vMax = 0.f;
 
     for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
-      TPCFastSpaceChargeCorrection::RowActiveArea& area = correction.getSliceRowInfo(slice, row).activeArea;
+      TPCFastSpaceChargeCorrection::RowActiveArea& area = correction.getRocRowInfo(roc, row).activeArea;
       area.cvMax = 0;
       area.vMax = 0;
       area.cuMin = mGeo.convPadToU(row, 0.f);
@@ -843,7 +843,7 @@ void TPCFastSpaceChargeCorrectionHelper::initMaxDriftLength(o2::gpu::TPCFastSpac
         while (v1 - v0 > 0.1) {
           float v = 0.5 * (v0 + v1);
           float dx, du, dv;
-          correction.getCorrection(slice, row, u, v, dx, du, dv);
+          correction.getCorrection(roc, row, u, v, dx, du, dv);
           double cx = x + dx;
           double cu = u + du;
           double cv = v + dv;
@@ -872,11 +872,11 @@ void TPCFastSpaceChargeCorrectionHelper::initMaxDriftLength(o2::gpu::TPCFastSpac
       for (int i = 0; i < 5; i++) {
         area.maxDriftLengthCheb[i] = chebFitter.getCoefficients()[i];
       }
-      if (sliceInfo.vMax < area.vMax) {
-        sliceInfo.vMax = area.vMax;
+      if (rocInfo.vMax < area.vMax) {
+        rocInfo.vMax = area.vMax;
       }
     } // row
-  }   // slice
+  } // roc
 }
 
 void TPCFastSpaceChargeCorrectionHelper::initInverse(o2::gpu::TPCFastSpaceChargeCorrection& correction, bool prn)
@@ -902,22 +902,22 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
   double tpcR2min = mGeo.getRowInfo(0).x - 1.;
   tpcR2min = tpcR2min * tpcR2min;
   double tpcR2max = mGeo.getRowInfo(mGeo.getNumberOfRows() - 1).x;
-  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfSlicesA() / 2) + 1.;
+  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfRocsA() / 2) + 1.;
   tpcR2max = tpcR2max * tpcR2max;
 
-  for (int slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
-    // LOG(info) << "inverse transform for slice " << slice ;
+  for (int roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
+    // LOG(info) << "inverse transform for roc " << roc ;
 
     auto myThread = [&](int iThread) {
       Spline2DHelper<float> helper;
       std::vector<float> splineParameters;
 
       for (int row = iThread; row < mGeo.getNumberOfRows(); row += mNthreads) {
-        TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(slice, row);
+        TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(roc, row);
         helper.setSpline(spline, 10, 10);
 
         double x = mGeo.getRowInfo(row).x;
-        auto& sliceRowInfo = correction.getSliceRowInfo(slice, row);
+        auto& rocRowInfo = correction.getRocRowInfo(roc, row);
 
         std::vector<double> gridU;
         {
@@ -951,7 +951,7 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
         dataPointCV.reserve(gridU.size() * gridV.size());
         dataPointF.reserve(gridU.size() * gridV.size());
 
-        TPCFastSpaceChargeCorrection::RowActiveArea& area = sliceRowInfo.activeArea;
+        TPCFastSpaceChargeCorrection::RowActiveArea& area = rocRowInfo.activeArea;
         area.cuMin = 1.e10;
         area.cuMax = -1.e10;
         double cvMin = 1.e10;
@@ -959,17 +959,17 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
         for (int iu = 0; iu < gridU.size(); iu++) {
           for (int iv = 0; iv < gridV.size(); iv++) {
             float u, v;
-            correction.convGridToUV(slice, row, gridU[iu], gridV[iv], u, v);
+            correction.convGridToUV(roc, row, gridU[iu], gridV[iv], u, v);
 
             float dx, du, dv;
-            correction.getCorrection(slice, row, u, v, dx, du, dv);
+            correction.getCorrection(roc, row, u, v, dx, du, dv);
             dx *= scaling[0];
             du *= scaling[0];
             dv *= scaling[0];
             // add remaining corrections
             for (int i = 1; i < corrections.size(); ++i) {
               float dxTmp, duTmp, dvTmp;
-              corrections[i]->getCorrection(slice, row, u, v, dxTmp, duTmp, dvTmp);
+              corrections[i]->getCorrection(roc, row, u, v, dxTmp, duTmp, dvTmp);
               dx += dxTmp * scaling[i];
               du += duTmp * scaling[i];
               dv += dvTmp * scaling[i];
@@ -1002,28 +1002,28 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
         }
 
         if (prn) {
-          LOG(info) << "slice " << slice << " row " << row << " max drift L = " << correction.getMaxDriftLength(slice, row)
+          LOG(info) << "roc " << roc << " row " << row << " max drift L = " << correction.getMaxDriftLength(roc, row)
                     << " active area: cuMin " << area.cuMin << " cuMax " << area.cuMax << " vMax " << area.vMax << " cvMax " << area.cvMax;
         }
 
         // define the grid for the inverse correction
 
-        sliceRowInfo.gridCorrU0 = area.cuMin;
-        sliceRowInfo.gridCorrV0 = cvMin;
-        sliceRowInfo.scaleCorrUtoGrid = spline.getGridX1().getUmax() / (area.cuMax - area.cuMin);
-        sliceRowInfo.scaleCorrVtoGrid = spline.getGridX2().getUmax() / area.cvMax;
+        rocRowInfo.gridCorrU0 = area.cuMin;
+        rocRowInfo.gridCorrV0 = cvMin;
+        rocRowInfo.scaleCorrUtoGrid = spline.getGridX1().getUmax() / (area.cuMax - area.cuMin);
+        rocRowInfo.scaleCorrVtoGrid = spline.getGridX2().getUmax() / area.cvMax;
 
         /*
-        sliceRowInfo.gridCorrU0 = sliceRowInfo.gridU0;
-        sliceRowInfo.gridCorrV0 = sliceRowInfo.gridV0;
-        sliceRowInfo.scaleCorrUtoGrid = sliceRowInfo.scaleUtoGrid;
-        sliceRowInfo.scaleCorrVtoGrid = sliceRowInfo.scaleVtoGrid;
+        rocRowInfo.gridCorrU0 = rocRowInfo.gridU0;
+        rocRowInfo.gridCorrV0 = rocRowInfo.gridV0;
+        rocRowInfo.scaleCorrUtoGrid = rocRowInfo.scaleUtoGrid;
+        rocRowInfo.scaleCorrVtoGrid = rocRowInfo.scaleVtoGrid;
         */
 
         int nDataPoints = dataPointCU.size();
         for (int i = 0; i < nDataPoints; i++) {
-          dataPointCU[i] = (dataPointCU[i] - sliceRowInfo.gridCorrU0) * sliceRowInfo.scaleCorrUtoGrid;
-          dataPointCV[i] = (dataPointCV[i] - sliceRowInfo.gridCorrV0) * sliceRowInfo.scaleCorrVtoGrid;
+          dataPointCU[i] = (dataPointCU[i] - rocRowInfo.gridCorrU0) * rocRowInfo.scaleCorrUtoGrid;
+          dataPointCV[i] = (dataPointCV[i] - rocRowInfo.gridCorrV0) * rocRowInfo.scaleCorrVtoGrid;
         }
 
         splineParameters.resize(spline.getNumberOfParameters());
@@ -1033,8 +1033,8 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
                                      dataPointCU.data(), dataPointCV.data(),
                                      dataPointF.data(), dataPointCU.size());
 
-        float* splineX = correction.getSplineData(slice, row, 1);
-        float* splineUV = correction.getSplineData(slice, row, 2);
+        float* splineX = correction.getSplineData(roc, row, 1);
+        float* splineUV = correction.getSplineData(roc, row, 2);
         for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
           splineX[i] = splineParameters[3 * i + 0];
           splineUV[2 * i + 0] = splineParameters[3 * i + 1];
@@ -1055,7 +1055,7 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
       th.join();
     }
 
-  } // slice
+  } // roc
   float duration = watch.RealTime();
   LOGP(info, "Inverse tooks: {}s", duration);
 }
diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index 7db84f0e94968..cfa54a12f9f42 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -192,8 +192,8 @@ void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) cons
 {
   const Mapper& mapper = Mapper::instance();
 
-  if (geo.getNumberOfSlices() != Sector::MAXSECTOR) {
-    LOG(fatal) << "Wrong number of sectors :" << geo.getNumberOfSlices() << " instead of " << Sector::MAXSECTOR << std::endl;
+  if (geo.getNumberOfRocs() != Sector::MAXSECTOR) {
+    LOG(fatal) << "Wrong number of sectors :" << geo.getNumberOfRocs() << " instead of " << Sector::MAXSECTOR << std::endl;
   }
 
   if (geo.getNumberOfRows() != mapper.getNumberOfRows()) {
diff --git a/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx b/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
index 5e37bd608c4a1..0141b80819b64 100644
--- a/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
+++ b/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
@@ -53,7 +53,7 @@ BOOST_AUTO_TEST_CASE(FastTransform_test1)
 
   BOOST_CHECK_EQUAL(geo.test(), 0);
 
-  BOOST_CHECK_EQUAL(geo.getNumberOfSlices(), Sector::MAXSECTOR);
+  BOOST_CHECK_EQUAL(geo.getNumberOfRocs(), Sector::MAXSECTOR);
   BOOST_CHECK_EQUAL(geo.getNumberOfRows(), mapper.getNumberOfRows());
 
   double maxDx = 0, maxDy = 0;
@@ -123,7 +123,7 @@ BOOST_AUTO_TEST_CASE(FastTransform_test_setSpaceChargeCorrection)
     dlz = lz1 - lz;
   };
 
-  int nRocs = geo.getNumberOfSlices();
+  int nRocs = geo.getNumberOfRocs();
   int nRows = geo.getNumberOfRows();
   TPCFastSpaceChargeCorrectionMap& scData = TPCFastTransformHelperO2::instance()->getCorrectionMap();
   scData.init(nRocs, nRows);
@@ -143,7 +143,7 @@ BOOST_AUTO_TEST_CASE(FastTransform_test_setSpaceChargeCorrection)
         }
       }
     } // row
-  }   // slice
+  } // roc
 
   std::unique_ptr<TPCFastTransform> fastTransform(TPCFastTransformHelperO2::instance()->create(0));
 
@@ -158,12 +158,12 @@ BOOST_AUTO_TEST_CASE(FastTransform_test_setSpaceChargeCorrection)
   double statDiff = 0., statN = 0.;
   double statDiffFile = 0., statNFile = 0.;
 
-  for (int slice = 0; slice < geo.getNumberOfSlices(); slice += 1) {
-    //std::cout << "slice " << slice << " ... " << std::endl;
+  for (int roc = 0; roc < geo.getNumberOfRocs(); roc += 1) {
+    // std::cout << "roc " << roc << " ... " << std::endl;
 
-    const TPCFastTransformGeo::SliceInfo& sliceInfo = geo.getSliceInfo(slice);
+    const TPCFastTransformGeo::RocInfo& rocInfo = geo.getRocInfo(roc);
 
-    float lastTimeBin = fastTransform->getMaxDriftTime(slice, 0.f);
+    float lastTimeBin = fastTransform->getMaxDriftTime(roc, 0.f);
 
     for (int row = 0; row < geo.getNumberOfRows(); row++) {
 
@@ -172,31 +172,31 @@ BOOST_AUTO_TEST_CASE(FastTransform_test_setSpaceChargeCorrection)
       for (int pad = 0; pad < nPads; pad += 10) {
 
         for (float time = 0; time < lastTimeBin; time += 30) {
-          //std::cout<<"slice "<<slice<<" row "<<row<<" pad "<<pad<<" time "<<time<<std::endl;
+          // std::cout<<"roc "<<roc<<" row "<<row<<" pad "<<pad<<" time "<<time<<std::endl;
 
           fastTransform->setApplyCorrectionOff();
           float x0, y0, z0;
-          fastTransform->Transform(slice, row, pad, time, x0, y0, z0);
+          fastTransform->Transform(roc, row, pad, time, x0, y0, z0);
 
-          BOOST_CHECK_EQUAL(geo.test(slice, row, y0, z0), 0);
+          BOOST_CHECK_EQUAL(geo.test(roc, row, y0, z0), 0);
 
           fastTransform->setApplyCorrectionOn();
           float x1, y1, z1;
-          fastTransform->Transform(slice, row, pad, time, x1, y1, z1);
+          fastTransform->Transform(roc, row, pad, time, x1, y1, z1);
 
           // local to UV
           float u0, v0, u1, v1;
-          geo.convLocalToUV(slice, y0, z0, u0, v0);
-          geo.convLocalToUV(slice, y1, z1, u1, v1);
+          geo.convLocalToUV(roc, y0, z0, u0, v0);
+          geo.convLocalToUV(roc, y1, z1, u1, v1);
           double dx, du, dv;
-          correctionUV(slice, row, u0, v0, dx, du, dv);
+          correctionUV(roc, row, u0, v0, dx, du, dv);
           statDiff += fabs((x1 - x0) - dx) + fabs((u1 - u0) - du) + fabs((v1 - v0) - dv);
           statN += 3;
           //std::cout << (x1 - x0) - dx << " " << (u1 - u0) - du << " " << (v1 - v0) - dv << std::endl; //": v0 " << v0 <<" z0 "<<z0<<" v1 "<< v1<<" z1 "<<z1 << std::endl;
           //BOOST_CHECK_MESSAGE(0, "SG");
 
           float x1f, y1f, z1f;
-          fromFile->Transform(slice, row, pad, time, x1f, y1f, z1f);
+          fromFile->Transform(roc, row, pad, time, x1f, y1f, z1f);
           statDiffFile += fabs(x1f - x1) + fabs(y1f - y1) + fabs(z1f - z1);
           statNFile += 3;
         }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index e519716b6eec0..5d3c186a06d42 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -35,7 +35,7 @@ TPCFastSpaceChargeCorrection::TPCFastSpaceChargeCorrection()
     mScenarioPtr(nullptr),
     mTimeStamp(-1),
     mSplineData{nullptr, nullptr, nullptr},
-    mSliceDataSizeBytes{0, 0, 0}
+    mRocDataSizeBytes{0, 0, 0}
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -64,7 +64,7 @@ void TPCFastSpaceChargeCorrection::destroy()
   mTimeStamp = -1;
   for (int32_t is = 0; is < 3; is++) {
     mSplineData[is] = nullptr;
-    mSliceDataSizeBytes[is] = 0;
+    mRocDataSizeBytes[is] = 0;
   }
   FlatObject::destroy();
 }
@@ -101,13 +101,13 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
 
   mTimeStamp = obj.mTimeStamp;
 
-  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfSlices(); ++i) {
-    mSliceInfo[i] = obj.mSliceInfo[i];
+  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfRocs(); ++i) {
+    mRocInfo[i] = obj.mRocInfo[i];
   }
 
-  mSliceDataSizeBytes[0] = obj.mSliceDataSizeBytes[0];
-  mSliceDataSizeBytes[1] = obj.mSliceDataSizeBytes[1];
-  mSliceDataSizeBytes[2] = obj.mSliceDataSizeBytes[2];
+  mRocDataSizeBytes[0] = obj.mRocDataSizeBytes[0];
+  mRocDataSizeBytes[1] = obj.mRocDataSizeBytes[1];
+  mRocDataSizeBytes[2] = obj.mRocDataSizeBytes[2];
 
   // variable-size data
   mScenarioPtr = obj.mScenarioPtr;
@@ -121,8 +121,8 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
     mRowInfos[i] = obj.mRowInfos[i];
   }
 
-  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfSlices() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
-    mSliceRowInfos[i] = obj.mSliceRowInfos[i];
+  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfRocs() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
+    mRocRowInfos[i] = obj.mRocRowInfos[i];
   }
 
   relocateBufferPointers(oldFlatBufferPtr, mFlatBufferPtr);
@@ -143,7 +143,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
 
   struct RowInfoVersion3 {
     int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
-    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC slice
+    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC roc
   };
 
   struct RowActiveAreaVersion3 {
@@ -154,7 +154,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     float cvMax{0.f};
   };
 
-  struct SliceRowInfoVersion3 {
+  struct RocRowInfoVersion3 {
     float gridV0{0.f};           ///< V coordinate of the V-grid start
     float gridCorrU0{0.f};       ///< U coordinate of the U-grid start for corrected U
     float gridCorrV0{0.f};       ///< V coordinate of the V-grid start for corrected V
@@ -171,13 +171,13 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     rowsSize = sizeof(RowInfoVersion3) * mGeo.getNumberOfRows();
   }
 
-  size_t sliceRowsOffset = rowsOffset + rowsSize;
-  size_t sliceRowsSize = 0;
-  if (mClassVersion == 3) { // copy old-format slicerow data from the buffer to the arrays
-    sliceRowsSize = sizeof(SliceRowInfoVersion3) * mGeo.getNumberOfRows() * mGeo.getNumberOfSlices();
+  size_t rocRowsOffset = rowsOffset + rowsSize;
+  size_t rocRowsSize = 0;
+  if (mClassVersion == 3) { // copy old-format rocrow data from the buffer to the arrays
+    rocRowsSize = sizeof(RocRowInfoVersion3) * mGeo.getNumberOfRows() * mGeo.getNumberOfRocs();
   }
 
-  size_t scOffset = alignSize(sliceRowsOffset + sliceRowsSize, SplineType::getClassAlignmentBytes());
+  size_t scOffset = alignSize(rocRowsOffset + rocRowsSize, SplineType::getClassAlignmentBytes());
   size_t scSize = sizeof(SplineType) * mNumberOfScenarios;
 
   mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr + scOffset);
@@ -192,12 +192,12 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
   }
   size_t bufferSize = scBufferOffset + scBufferSize;
   for (int32_t is = 0; is < 3; is++) {
-    size_t sliceDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + sliceDataOffset);
-    bufferSize = sliceDataOffset + mSliceDataSizeBytes[is] * mGeo.getNumberOfSlices();
+    size_t rocDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + rocDataOffset);
+    bufferSize = rocDataOffset + mRocDataSizeBytes[is] * mGeo.getNumberOfRocs();
   }
 
-  if (mClassVersion == 3) { // copy old-format slicerow data from the buffer to the arrays
+  if (mClassVersion == 3) { // copy old-format rocrow data from the buffer to the arrays
 
     auto* rowInfosOld = reinterpret_cast<RowInfoVersion3*>(mFlatBufferPtr + rowsOffset);
     for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
@@ -214,18 +214,18 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
       spline.setXrange(0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax());
     }
 
-    auto* sliceRowInfosOld = reinterpret_cast<SliceRowInfoVersion3*>(mFlatBufferPtr + sliceRowsOffset);
+    auto* rocRowInfosOld = reinterpret_cast<RocRowInfoVersion3*>(mFlatBufferPtr + rocRowsOffset);
 
-    for (int32_t slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
+    for (int32_t roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
       for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
-        SliceRowInfoVersion3& infoOld = sliceRowInfosOld[mGeo.getNumberOfRows() * slice + row];
-        SliceRowInfo& info = getSliceRowInfo(slice, row);
-        const auto& spline = getSpline(slice, row);
+        RocRowInfoVersion3& infoOld = rocRowInfosOld[mGeo.getNumberOfRows() * roc + row];
+        RocRowInfo& info = getRocRowInfo(roc, row);
+        const auto& spline = getSpline(roc, row);
         info.gridU0 = mGeo.getRowInfo(row).u0;
         info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
 
         info.gridV0 = infoOld.gridV0;
-        info.scaleVtoGrid = spline.getGridX2().getUmax() / (mGeo.getTPCzLength(slice) + 3. - info.gridV0);
+        info.scaleVtoGrid = spline.getGridX2().getUmax() / (mGeo.getTPCzLength(roc) + 3. - info.gridV0);
 
         info.gridCorrU0 = infoOld.gridCorrU0;
         info.scaleCorrUtoGrid = infoOld.scaleCorrUtoGrid;
@@ -276,7 +276,7 @@ void TPCFastSpaceChargeCorrection::print() const
   mGeo.print();
   LOG(info) << "  mNumberOfScenarios = " << mNumberOfScenarios;
   LOG(info) << "  mTimeStamp = " << mTimeStamp;
-  LOG(info) << "  mSliceDataSizeBytes = " << mSliceDataSizeBytes[0] << " " << mSliceDataSizeBytes[1] << " " << mSliceDataSizeBytes[2];
+  LOG(info) << "  mRocDataSizeBytes = " << mRocDataSizeBytes[0] << " " << mRocDataSizeBytes[1] << " " << mRocDataSizeBytes[2];
   {
     LOG(info) << "  TPC rows: ";
     for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
@@ -292,9 +292,9 @@ void TPCFastSpaceChargeCorrection::print() const
   }
   if (mScenarioPtr) {
     LOG(info) << " Spline Data: ";
-    for (int32_t is = 0; is < mGeo.getNumberOfSlices(); is++) {
+    for (int32_t is = 0; is < mGeo.getNumberOfRocs(); is++) {
       for (int32_t ir = 0; ir < mGeo.getNumberOfRows(); ir++) {
-        LOG(info) << "slice " << is << " row " << ir << ": ";
+        LOG(info) << "roc " << is << " row " << ir << ": ";
         const SplineType& spline = getSpline(is, ir);
         const float* d = getSplineData(is, ir);
         int32_t k = 0;
@@ -305,8 +305,8 @@ void TPCFastSpaceChargeCorrection::print() const
           LOG(info) << "";
         }
       }
-      //    LOG(info) << "inverse correction: slice " << slice
-      //            << " dx " << maxDslice[0] << " du " << maxDslice[1] << " dv " << maxDslice[2] ;
+      //    LOG(info) << "inverse correction: roc " << roc
+      //            << " dx " << maxDroc[0] << " du " << maxDroc[1] << " dv " << maxDroc[2] ;
     }
   }
 }
@@ -345,7 +345,7 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
   mScenarioPtr = nullptr;
   for (int32_t s = 0; s < 3; s++) {
     mSplineData[s] = nullptr;
-    mSliceDataSizeBytes[s] = 0;
+    mRocDataSizeBytes[s] = 0;
   }
   mClassVersion = 4;
 }
@@ -401,18 +401,18 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
     scBufferSize = alignSize(scBufferSize + sp.getFlatBufferSize(), sp.getBufferAlignmentBytes());
   }
   size_t bufferSize = scBufferOffsets[0] + scBufferSize;
-  size_t sliceDataOffset[3];
+  size_t rocDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
-    sliceDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mSliceDataSizeBytes[is] = 0;
+    rocDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mRocDataSizeBytes[is] = 0;
     for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
       RowInfo& row = mRowInfos[i];
       SplineType& spline = mConstructionScenarios[row.splineScenarioID];
-      row.dataOffsetBytes[is] = alignSize(mSliceDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-      mSliceDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
+      row.dataOffsetBytes[is] = alignSize(mRocDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
+      mRocDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
     }
-    mSliceDataSizeBytes[is] = alignSize(mSliceDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-    bufferSize = sliceDataOffset[is] + mSliceDataSizeBytes[is] * mGeo.getNumberOfSlices();
+    mRocDataSizeBytes[is] = alignSize(mRocDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
+    bufferSize = rocDataOffset[is] + mRocDataSizeBytes[is] * mGeo.getNumberOfRocs();
   }
 
   FlatObject::finishConstruction(bufferSize);
@@ -427,7 +427,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   }
 
   for (int32_t is = 0; is < 3; is++) {
-    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + sliceDataOffset[is]);
+    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + rocDataOffset[is]);
   }
   releaseConstructionMemory();
 
@@ -439,15 +439,15 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
 {
   // initialise all corrections to 0.
-  for (int32_t slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
-    double vLength = (slice < mGeo.getNumberOfSlicesA()) ? mGeo.getTPCzLengthA() : mGeo.getTPCzLengthC();
-    SliceInfo& sliceInfo = getSliceInfo(slice);
-    sliceInfo.vMax = vLength;
+  for (int32_t roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
+    double vLength = (roc < mGeo.getNumberOfRocsA()) ? mGeo.getTPCzLengthA() : mGeo.getTPCzLengthC();
+    RocInfo& rocInfo = getRocInfo(roc);
+    rocInfo.vMax = vLength;
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
-      const SplineType& spline = getSpline(slice, row);
+      const SplineType& spline = getSpline(roc, row);
 
       for (int32_t is = 0; is < 3; is++) {
-        float* data = getSplineData(slice, row, is);
+        float* data = getSplineData(roc, row, is);
         int32_t nPar = spline.getNumberOfParameters();
         if (is == 1) {
           nPar = nPar / 3;
@@ -460,7 +460,7 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
         }
       }
 
-      SliceRowInfo& info = getSliceRowInfo(slice, row);
+      RocRowInfo& info = getRocRowInfo(roc, row);
 
       info.gridU0 = mGeo.getRowInfo(row).u0;
       info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
@@ -484,7 +484,7 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
       area.cvMax = vLength;
 
     } // row
-  } // slice
+  } // roc
 }
 
 void TPCFastSpaceChargeCorrection::constructWithNoCorrection(const TPCFastTransformGeo& geo)
@@ -512,7 +512,7 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
   double tpcR2min = mGeo.getRowInfo(0).x - 1.;
   tpcR2min = tpcR2min * tpcR2min;
   double tpcR2max = mGeo.getRowInfo(mGeo.getNumberOfRows() - 1).x;
-  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfSlicesA() / 2) + 1.;
+  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfRocsA() / 2) + 1.;
   tpcR2max = tpcR2max * tpcR2max;
 
   struct MaxValue {
@@ -544,27 +544,27 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
   MaxValue maxDtpc[3];
   MaxValue maxD;
 
-  for (int32_t slice = 0; slice < mGeo.getNumberOfSlices(); slice++) {
+  for (int32_t roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
     if (prn) {
-      LOG(info) << "check inverse transform for slice " << slice;
+      LOG(info) << "check inverse transform for roc " << roc;
     }
-    double vLength = mGeo.getTPCzLength(slice);
-    MaxValue maxDslice[3];
+    double vLength = mGeo.getTPCzLength(roc);
+    MaxValue maxDroc[3];
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
       float u0, u1, v0, v1;
-      mGeo.convScaledUVtoUV(slice, row, 0., 0., u0, v0);
-      mGeo.convScaledUVtoUV(slice, row, 1., 1., u1, v1);
+      mGeo.convScaledUVtoUV(roc, row, 0., 0., u0, v0);
+      mGeo.convScaledUVtoUV(roc, row, 1., 1., u1, v1);
       double x = mGeo.getRowInfo(row).x;
       double stepU = (u1 - u0) / 100.;
       double stepV = (v1 - v0) / 100.;
       MaxValue maxDrow[3];
       for (double u = u0; u < u1; u += stepU) {
         for (double v = v0; v < v1; v += stepV) {
-          if (v < getSliceRowInfo(slice, row).gridV0) {
+          if (v < getRocRowInfo(roc, row).gridV0) {
             continue;
           }
           float dx, du, dv;
-          getCorrection(slice, row, u, v, dx, du, dv);
+          getCorrection(roc, row, u, v, dx, du, dv);
           double cx = x + dx;
           double cu = u + du;
           double cv = v + dv;
@@ -573,11 +573,11 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
             continue;
           }
           float nx, nu, nv;
-          getCorrectionInvCorrectedX(slice, row, cu, cv, nx);
-          getCorrectionInvUV(slice, row, cu, cv, nu, nv);
+          getCorrectionInvCorrectedX(roc, row, cu, cv, nx);
+          getCorrectionInvUV(roc, row, cu, cv, nu, nv);
           double d[3] = {(cx - nx) - dx, (cu - nu) - du, (cv - nv) - dv};
           for (int32_t i = 0; i < 3; i++) {
-            maxDrow[i].update(d[i], slice, row);
+            maxDrow[i].update(d[i], roc, row);
           }
 
           if (0 && prn && fabs(d[0]) + fabs(d[1]) + fabs(d[2]) > 0.1) {
@@ -589,20 +589,20 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
         }
       }
       if (1 && prn) {
-        LOG(info) << "slice " << slice << " row " << row
+        LOG(info) << "roc " << roc << " row " << row
                   << " dx " << maxDrow[0].V << " du " << maxDrow[1].V << " dv " << maxDrow[2].V;
       }
       for (int32_t i = 0; i < 3; i++) {
-        maxDslice[i].update(maxDrow[i]);
+        maxDroc[i].update(maxDrow[i]);
         maxDtpc[i].update(maxDrow[i]);
         maxD.update(maxDrow[i]);
       }
     }
     if (prn) {
-      LOG(info) << "inverse correction: slice " << slice << ". Max deviations: "
-                << " dx " << maxDslice[0].toString() << " du " << maxDslice[1].toString() << " dv " << maxDslice[2].toString();
+      LOG(info) << "inverse correction: roc " << roc << ". Max deviations: "
+                << " dx " << maxDroc[0].toString() << " du " << maxDroc[1].toString() << " dv " << maxDroc[2].toString();
     }
-  } // slice
+  } // roc
 
   LOG(info) << "Test inverse TPC correction. max deviations: "
             << " dx " << maxDtpc[0].toString() << " du " << maxDtpc[1].toString() << " dv " << maxDtpc[2].toString() << " cm";
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 7957d36b494c3..b6244bfee1e0f 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -44,7 +44,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   ///
   struct RowInfo {
     int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
-    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC slice
+    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing the TPC roc
     ClassDefNV(RowInfo, 1);
   };
 
@@ -57,7 +57,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     ClassDefNV(RowActiveArea, 1);
   };
 
-  struct SliceRowInfo {
+  struct RocRowInfo {
     float gridU0{0.f};                     //< U coordinate of the U-grid start
     float scaleUtoGrid{0.f};               //< scale U to U-grid coordinate
     float gridV0{0.f};                     ///< V coordinate of the V-grid start
@@ -92,12 +92,12 @@ class TPCFastSpaceChargeCorrection : public FlatObject
       minCorr[2] = GPUCommonMath::Min(minCorr[2], dv);
     }
 
-    ClassDefNV(SliceRowInfo, 2);
+    ClassDefNV(RocRowInfo, 2);
   };
 
-  struct SliceInfo {
+  struct RocInfo {
     float vMax{0.f}; ///< Max value of V coordinate
-    ClassDefNV(SliceInfo, 1);
+    ClassDefNV(RocInfo, 1);
   };
 
   typedef Spline2D<float, 3> SplineType;
@@ -167,46 +167,46 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() void setInterpolationSafetyMargin(float val) { fInterpolationSafetyMargin = val; }
 
   /// Gives const pointer to a spline
-  GPUd() const SplineType& getSpline(int32_t slice, int32_t row) const;
+  GPUd() const SplineType& getSpline(int32_t roc, int32_t row) const;
 
   /// Gives pointer to a spline
-  GPUd() SplineType& getSpline(int32_t slice, int32_t row);
+  GPUd() SplineType& getSpline(int32_t roc, int32_t row);
 
   /// Gives pointer to spline data
-  GPUd() float* getSplineData(int32_t slice, int32_t row, int32_t iSpline = 0);
+  GPUd() float* getSplineData(int32_t roc, int32_t row, int32_t iSpline = 0);
 
   /// Gives pointer to spline data
-  GPUd() const float* getSplineData(int32_t slice, int32_t row, int32_t iSpline = 0) const;
+  GPUd() const float* getSplineData(int32_t roc, int32_t row, int32_t iSpline = 0) const;
 
   /// _______________ The main method: cluster correction  _______________________
   ///
-  GPUd() int32_t getCorrection(int32_t slice, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
+  GPUd() int32_t getCorrection(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
 
   /// inverse correction: Corrected U and V -> coorrected X
-  GPUd() void getCorrectionInvCorrectedX(int32_t slice, int32_t row, float corrU, float corrV, float& corrX) const;
+  GPUd() void getCorrectionInvCorrectedX(int32_t roc, int32_t row, float corrU, float corrV, float& corrX) const;
 
   /// inverse correction: Corrected U and V -> uncorrected U and V
-  GPUd() void getCorrectionInvUV(int32_t slice, int32_t row, float corrU, float corrV, float& nomU, float& nomV) const;
+  GPUd() void getCorrectionInvUV(int32_t roc, int32_t row, float corrU, float corrV, float& nomU, float& nomV) const;
 
   /// maximal possible drift length of the active area
-  GPUd() float getMaxDriftLength(int32_t slice, int32_t row, float pad) const;
+  GPUd() float getMaxDriftLength(int32_t roc, int32_t row, float pad) const;
 
   /// maximal possible drift length of the active area
-  GPUd() float getMaxDriftLength(int32_t slice, int32_t row) const;
+  GPUd() float getMaxDriftLength(int32_t roc, int32_t row) const;
 
   /// maximal possible drift length of the active area
-  GPUd() float getMaxDriftLength(int32_t slice) const;
+  GPUd() float getMaxDriftLength(int32_t roc) const;
 
   /// _______________  Utilities  _______________________________________________
 
   /// convert u,v to internal grid coordinates
-  GPUd() void convUVtoGrid(int32_t slice, int32_t row, float u, float v, float& gridU, float& gridV) const;
+  GPUd() void convUVtoGrid(int32_t roc, int32_t row, float u, float v, float& gridU, float& gridV) const;
 
   /// convert u,v to internal grid coordinates
-  GPUd() void convGridToUV(int32_t slice, int32_t row, float gridU, float gridV, float& u, float& v) const;
+  GPUd() void convGridToUV(int32_t roc, int32_t row, float gridU, float gridV, float& u, float& v) const;
 
   /// convert corrected u,v to internal grid coordinates
-  GPUd() void convCorrectedUVtoGrid(int32_t slice, int32_t row, float cu, float cv, float& gridU, float& gridV) const;
+  GPUd() void convCorrectedUVtoGrid(int32_t roc, int32_t row, float cu, float cv, float& gridU, float& gridV) const;
 
   /// TPC geometry information
   GPUd() const TPCFastTransformGeo& getGeometry() const
@@ -223,28 +223,28 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// Gives TPC row info
   GPUd() const RowInfo& getRowInfo(int32_t row) const { return mRowInfos[row]; }
 
-  /// Gives TPC slice info
-  GPUd() const SliceInfo& getSliceInfo(int32_t slice) const
+  /// Gives TPC roc info
+  GPUd() const RocInfo& getRocInfo(int32_t roc) const
   {
-    return mSliceInfo[slice];
+    return mRocInfo[roc];
   }
 
-  /// Gives TPC slice info
-  GPUd() SliceInfo& getSliceInfo(int32_t slice)
+  /// Gives TPC roc info
+  GPUd() RocInfo& getRocInfo(int32_t roc)
   {
-    return mSliceInfo[slice];
+    return mRocInfo[roc];
   }
 
-  /// Gives TPC slice & row info
-  GPUd() const SliceRowInfo& getSliceRowInfo(int32_t slice, int32_t row) const
+  /// Gives TPC roc & row info
+  GPUd() const RocRowInfo& getRocRowInfo(int32_t roc, int32_t row) const
   {
-    return mSliceRowInfos[mGeo.getMaxNumberOfRows() * slice + row];
+    return mRocRowInfos[mGeo.getMaxNumberOfRows() * roc + row];
   }
 
-  /// Gives TPC slice & row info
-  GPUd() SliceRowInfo& getSliceRowInfo(int32_t slice, int32_t row)
+  /// Gives TPC roc & row info
+  GPUd() RocRowInfo& getRocRowInfo(int32_t roc, int32_t row)
   {
-    return mSliceRowInfos[mGeo.getMaxNumberOfRows() * slice + row];
+    return mRocRowInfos[mGeo.getMaxNumberOfRows() * roc + row];
   }
 
 #if !defined(GPUCA_GPUCODE)
@@ -260,7 +260,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   void releaseConstructionMemory();
 
   /// temporary method with the an way of calculating 2D spline
-  GPUd() int32_t getCorrectionOld(int32_t slice, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
+  GPUd() int32_t getCorrectionOld(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
 
   /// _______________  Data members  _______________________________________________
 
@@ -274,7 +274,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   int32_t mNumberOfScenarios; ///< Number of approximation spline scenarios
 
-  SliceInfo mSliceInfo[TPCFastTransformGeo::getNumberOfSlices()]; ///< SliceInfo array
+  RocInfo mRocInfo[TPCFastTransformGeo::getNumberOfRocs()]; ///< RocInfo array
 
   SplineType* mScenarioPtr; //! (transient!!) pointer to spline scenarios
 
@@ -284,7 +284,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   char* mSplineData[3]; //! (transient!!) pointer to the spline data in the flat buffer
 
-  size_t mSliceDataSizeBytes[3]; ///< size of the data for one slice in the flat buffer
+  size_t mRocDataSizeBytes[3]; ///< size of the data for one roc in the flat buffer
 
   float fInterpolationSafetyMargin{0.1f}; // 10% area around the TPC row. Outside of this area the interpolation returns the boundary values.
 
@@ -295,72 +295,72 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   RowInfo mRowInfos[TPCFastTransformGeo::getMaxNumberOfRows()]; ///< RowInfo array
 
-  SliceRowInfo mSliceRowInfos[TPCFastTransformGeo::getNumberOfSlices() * TPCFastTransformGeo::getMaxNumberOfRows()]; ///< SliceRowInfo array
+  RocRowInfo mRocRowInfos[TPCFastTransformGeo::getNumberOfRocs() * TPCFastTransformGeo::getMaxNumberOfRows()]; ///< RocRowInfo array
 
-  ClassDefNV(TPCFastSpaceChargeCorrection, 4);
+  ClassDefNV(TPCFastSpaceChargeCorrection, 5);
 };
 
 /// ====================================================
 ///       Inline implementations of some methods
 /// ====================================================
 
-GPUdi() const TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t slice, int32_t row) const
+GPUdi() const TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t roc, int32_t row) const
 {
   /// Gives const pointer to spline
   const RowInfo& rowInfo = mRowInfos[row];
   return mScenarioPtr[rowInfo.splineScenarioID];
 }
 
-GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t slice, int32_t row)
+GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t roc, int32_t row)
 {
   /// Gives pointer to spline
   const RowInfo& rowInfo = mRowInfos[row];
   return mScenarioPtr[rowInfo.splineScenarioID];
 }
 
-GPUdi() float* TPCFastSpaceChargeCorrection::getSplineData(int32_t slice, int32_t row, int32_t iSpline)
+GPUdi() float* TPCFastSpaceChargeCorrection::getSplineData(int32_t roc, int32_t row, int32_t iSpline)
 {
   /// Gives pointer to spline data
   const RowInfo& rowInfo = mRowInfos[row];
-  return reinterpret_cast<float*>(mSplineData[iSpline] + mSliceDataSizeBytes[iSpline] * slice + rowInfo.dataOffsetBytes[iSpline]);
+  return reinterpret_cast<float*>(mSplineData[iSpline] + mRocDataSizeBytes[iSpline] * roc + rowInfo.dataOffsetBytes[iSpline]);
 }
 
-GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t slice, int32_t row, int32_t iSpline) const
+GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t roc, int32_t row, int32_t iSpline) const
 {
   /// Gives pointer to spline data
   const RowInfo& rowInfo = mRowInfos[row];
-  return reinterpret_cast<float*>(mSplineData[iSpline] + mSliceDataSizeBytes[iSpline] * slice + rowInfo.dataOffsetBytes[iSpline]);
+  return reinterpret_cast<float*>(mSplineData[iSpline] + mRocDataSizeBytes[iSpline] * roc + rowInfo.dataOffsetBytes[iSpline]);
 }
 
-GPUdi() void TPCFastSpaceChargeCorrection::convUVtoGrid(int32_t slice, int32_t row, float u, float v, float& gu, float& gv) const
+GPUdi() void TPCFastSpaceChargeCorrection::convUVtoGrid(int32_t roc, int32_t row, float u, float v, float& gu, float& gv) const
 {
-  const auto& info = getSliceRowInfo(slice, row);
+  const auto& info = getRocRowInfo(roc, row);
   gu = (u - info.gridU0) * info.scaleUtoGrid;
   gv = (v - info.gridV0) * info.scaleVtoGrid;
 }
 
-GPUdi() void TPCFastSpaceChargeCorrection::convGridToUV(int32_t slice, int32_t row, float gridU, float gridV, float& u, float& v) const
+GPUdi() void TPCFastSpaceChargeCorrection::convGridToUV(int32_t roc, int32_t row, float gridU, float gridV, float& u, float& v) const
 {
   /// convert internal grid coordinates to u,v
-  const SliceRowInfo& info = getSliceRowInfo(slice, row);
+  const RocRowInfo& info = getRocRowInfo(roc, row);
   u = info.gridU0 + gridU / info.scaleUtoGrid;
   v = info.gridV0 + gridV / info.scaleVtoGrid;
 }
 
-GPUdi() void TPCFastSpaceChargeCorrection::convCorrectedUVtoGrid(int32_t slice, int32_t row, float corrU, float corrV, float& gridU, float& gridV) const
+GPUdi() void TPCFastSpaceChargeCorrection::convCorrectedUVtoGrid(int32_t roc, int32_t row, float corrU, float corrV, float& gridU, float& gridV) const
 {
-  const SliceRowInfo& info = getSliceRowInfo(slice, row);
+  const RocRowInfo& info = getRocRowInfo(roc, row);
   gridU = (corrU - info.gridCorrU0) * info.scaleCorrUtoGrid;
   gridV = (corrV - info.gridCorrV0) * info.scaleCorrVtoGrid;
 }
 
-GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrection(int32_t slice, int32_t row, float u, float v, float& dx, float& du, float& dv) const
+GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrection(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const
 {
-  const auto& info = getSliceRowInfo(slice, row);
-  const SplineType& spline = getSpline(slice, row);
-  const float* splineData = getSplineData(slice, row);
+  const auto& info = getRocRowInfo(roc, row);
+  const SplineType& spline = getSpline(roc, row);
+  const float* splineData = getSplineData(roc, row);
   float gridU = 0, gridV = 0;
-  convUVtoGrid(slice, row, u, v, gridU, gridV);
+  convUVtoGrid(roc, row, u, v, gridU, gridV);
   // shrink to the grid area
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
   gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
@@ -382,15 +382,15 @@ GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrection(int32_t slice, int32
   return 0;
 }
 
-GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionOld(int32_t slice, int32_t row, float u, float v, float& dx, float& du, float& dv) const
+GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionOld(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const
 {
-  const SplineType& spline = getSpline(slice, row);
-  const float* splineData = getSplineData(slice, row);
+  const SplineType& spline = getSpline(roc, row);
+  const float* splineData = getSplineData(roc, row);
   float gridU = 0, gridV = 0;
-  convUVtoGrid(slice, row, u, v, gridU, gridV);
+  convUVtoGrid(roc, row, u, v, gridU, gridV);
   float dxuv[3];
   spline.interpolateUold(splineData, gridU, gridV, dxuv);
-  const auto& info = getSliceRowInfo(slice, row);
+  const auto& info = getRocRowInfo(roc, row);
   float s = v / info.gridV0;
   if (s < 0.) {
     s = 0.;
@@ -405,14 +405,14 @@ GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionOld(int32_t slice, in
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvCorrectedX(
-  int32_t slice, int32_t row, float corrU, float corrV, float& x) const
+  int32_t roc, int32_t row, float corrU, float corrV, float& x) const
 {
-  const auto& info = getSliceRowInfo(slice, row);
-  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(slice, row));
-  const float* splineData = getSplineData(slice, row, 1);
+  const auto& info = getRocRowInfo(roc, row);
+  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(roc, row));
+  const float* splineData = getSplineData(roc, row, 1);
 
   float gridU, gridV;
-  convCorrectedUVtoGrid(slice, row, corrU, corrV, gridU, gridV);
+  convCorrectedUVtoGrid(roc, row, corrU, corrV, gridU, gridV);
 
   // shrink to the grid area
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
@@ -434,13 +434,13 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvCorrectedX(
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvUV(
-  int32_t slice, int32_t row, float corrU, float corrV, float& nomU, float& nomV) const
+  int32_t roc, int32_t row, float corrU, float corrV, float& nomU, float& nomV) const
 {
-  const Spline2D<float, 2>& spline = reinterpret_cast<const Spline2D<float, 2>&>(getSpline(slice, row));
-  const float* splineData = getSplineData(slice, row, 2);
+  const Spline2D<float, 2>& spline = reinterpret_cast<const Spline2D<float, 2>&>(getSpline(roc, row));
+  const float* splineData = getSplineData(roc, row, 2);
 
   float gridU, gridV;
-  convCorrectedUVtoGrid(slice, row, corrU, corrV, gridU, gridV);
+  convCorrectedUVtoGrid(roc, row, corrU, corrV, gridU, gridV);
 
   // shrink to the grid area
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
@@ -448,7 +448,7 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvUV(
 
   float duv[2];
   spline.interpolateU(splineData, gridU, gridV, duv);
-  const auto& info = getSliceRowInfo(slice, row);
+  const auto& info = getRocRowInfo(roc, row);
   float s = corrV / info.gridCorrV0;
 
   if (corrV >= info.gridCorrV0) {
@@ -463,9 +463,9 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvUV(
   nomV = corrV - duv[1];
 }
 
-GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t slice, int32_t row, float pad) const
+GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t roc, int32_t row, float pad) const
 {
-  const RowActiveArea& area = getSliceRowInfo(slice, row).activeArea;
+  const RowActiveArea& area = getRocRowInfo(roc, row).activeArea;
   const float* c = area.maxDriftLengthCheb;
   float x = -1.f + 2.f * pad / mGeo.getRowInfo(row).maxPad;
   float y = c[0] + c[1] * x;
@@ -481,14 +481,14 @@ GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t slice, int
   return y;
 }
 
-GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t slice, int32_t row) const
+GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t roc, int32_t row) const
 {
-  return getSliceRowInfo(slice, row).activeArea.vMax;
+  return getRocRowInfo(roc, row).activeArea.vMax;
 }
 
-GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t slice) const
+GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t roc) const
 {
-  return getSliceInfo(slice).vMax;
+  return getRocInfo(roc).vMax;
 }
 
 } // namespace gpu
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index d9e35ba8bf405..8aef1748ebf62 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -46,14 +46,14 @@ struct TPCSlowSpaceChargeCorrection {
   ~TPCSlowSpaceChargeCorrection();
 
   /// getting the corrections for global coordinates
-  void getCorrections(const float gx, const float gy, const float gz, const int32_t slice, float& gdxC, float& gdyC, float& gdzC) const;
+  void getCorrections(const float gx, const float gy, const float gz, const int32_t roc, float& gdxC, float& gdyC, float& gdzC) const;
 
   o2::tpc::SpaceCharge<float>* mCorr{nullptr}; ///< reference space charge corrections
 #else
   ~TPCSlowSpaceChargeCorrection() = default;
 
   /// setting dummy corrections for GPU
-  GPUd() void getCorrections(const float gx, const float gy, const float gz, const int32_t slice, float& gdxC, float& gdyC, float& gdzC) const
+  GPUd() void getCorrections(const float gx, const float gy, const float gz, const int32_t roc, float& gdxC, float& gdyC, float& gdzC) const
   {
     gdxC = 0;
     gdyC = 0;
@@ -182,50 +182,50 @@ class TPCFastTransform : public FlatObject
 
   /// _______________ The main method: cluster transformation _______________________
   ///
-  /// Transforms raw TPC coordinates to local XYZ withing a slice
+  /// Transforms raw TPC coordinates to local XYZ withing a roc
   /// taking calibration + alignment into account.
   ///
-  GPUd() void Transform(int32_t slice, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
-  GPUd() void TransformXYZ(int32_t slice, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void Transform(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void TransformXYZ(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
 
   /// Transformation in the time frame
-  GPUd() void TransformInTimeFrame(int32_t slice, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const;
-  GPUd() void TransformInTimeFrame(int32_t slice, float time, float& z, float maxTimeBin) const;
+  GPUd() void TransformInTimeFrame(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const;
+  GPUd() void TransformInTimeFrame(int32_t roc, float time, float& z, float maxTimeBin) const;
 
   /// Inverse transformation
-  GPUd() void InverseTransformInTimeFrame(int32_t slice, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const;
-  GPUd() float InverseTransformInTimeFrame(int32_t slice, float z, float maxTimeBin) const;
+  GPUd() void InverseTransformInTimeFrame(int32_t roc, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const;
+  GPUd() float InverseTransformInTimeFrame(int32_t roc, float z, float maxTimeBin) const;
 
   /// Inverse transformation: Transformed Y and Z -> transformed X
-  GPUd() void InverseTransformYZtoX(int32_t slice, int32_t row, float y, float z, float& x, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformYZtoX(int32_t roc, int32_t row, float y, float z, float& x, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
 
   /// Inverse transformation: Transformed Y and Z -> Y and Z, transformed w/o space charge correction
-  GPUd() void InverseTransformYZtoNominalYZ(int32_t slice, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformYZtoNominalYZ(int32_t roc, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
 
   /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
-  GPUd() void InverseTransformXYZtoNominalXYZ(int32_t slice, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformXYZtoNominalXYZ(int32_t roc, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
 
   /// Ideal transformation with Vdrift only - without calibration
-  GPUd() void TransformIdeal(int32_t slice, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;
-  GPUd() void TransformIdealZ(int32_t slice, float time, float& z, float vertexTime) const;
+  GPUd() void TransformIdeal(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;
+  GPUd() void TransformIdealZ(int32_t roc, float time, float& z, float vertexTime) const;
 
-  GPUd() void convPadTimeToUV(int32_t slice, int32_t row, float pad, float time, float& u, float& v, float vertexTime) const;
-  GPUd() void convPadTimeToUVinTimeFrame(int32_t slice, int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const;
-  GPUd() void convTimeToVinTimeFrame(int32_t slice, float time, float& v, float maxTimeBin) const;
+  GPUd() void convPadTimeToUV(int32_t roc, int32_t row, float pad, float time, float& u, float& v, float vertexTime) const;
+  GPUd() void convPadTimeToUVinTimeFrame(int32_t roc, int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const;
+  GPUd() void convTimeToVinTimeFrame(int32_t roc, float time, float& v, float maxTimeBin) const;
 
-  GPUd() void convUVtoPadTime(int32_t slice, int32_t row, float u, float v, float& pad, float& time, float vertexTime) const;
-  GPUd() void convUVtoPadTimeInTimeFrame(int32_t slice, int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const;
+  GPUd() void convUVtoPadTime(int32_t roc, int32_t row, float u, float v, float& pad, float& time, float vertexTime) const;
+  GPUd() void convUVtoPadTimeInTimeFrame(int32_t roc, int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const;
   GPUd() void convVtoTime(float v, float& time, float vertexTime) const;
 
-  GPUd() float convTimeToZinTimeFrame(int32_t slice, float time, float maxTimeBin) const;
-  GPUd() float convZtoTimeInTimeFrame(int32_t slice, float z, float maxTimeBin) const;
-  GPUd() float convDeltaTimeToDeltaZinTimeFrame(int32_t slice, float deltaTime) const;
-  GPUd() float convDeltaZtoDeltaTimeInTimeFrame(int32_t slice, float deltaZ) const;
+  GPUd() float convTimeToZinTimeFrame(int32_t roc, float time, float maxTimeBin) const;
+  GPUd() float convZtoTimeInTimeFrame(int32_t roc, float z, float maxTimeBin) const;
+  GPUd() float convDeltaTimeToDeltaZinTimeFrame(int32_t roc, float deltaTime) const;
+  GPUd() float convDeltaZtoDeltaTimeInTimeFrame(int32_t roc, float deltaZ) const;
   GPUd() float convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const;
-  GPUd() float convZOffsetToVertexTime(int32_t slice, float zOffset, float maxTimeBin) const;
-  GPUd() float convVertexTimeToZOffset(int32_t slice, float vertexTime, float maxTimeBin) const;
+  GPUd() float convZOffsetToVertexTime(int32_t roc, float zOffset, float maxTimeBin) const;
+  GPUd() float convVertexTimeToZOffset(int32_t roc, float vertexTime, float maxTimeBin) const;
 
-  GPUd() void getTOFcorrection(int32_t slice, int32_t row, float x, float y, float z, float& dz) const;
+  GPUd() void getTOFcorrection(int32_t roc, int32_t row, float x, float y, float z, float& dz) const;
 
   void setApplyCorrectionOn() { mApplyCorrection = 1; }
   void setApplyCorrectionOff() { mApplyCorrection = 0; }
@@ -276,13 +276,13 @@ class TPCFastTransform : public FlatObject
   GPUd() float getLumiScaleFactor() const { return mLumiScaleFactor; }
 
   /// maximal possible drift time of the active area
-  GPUd() float getMaxDriftTime(int32_t slice, int32_t row, float pad) const;
+  GPUd() float getMaxDriftTime(int32_t roc, int32_t row, float pad) const;
 
   /// maximal possible drift time of the active area
-  GPUd() float getMaxDriftTime(int32_t slice, int32_t row) const;
+  GPUd() float getMaxDriftTime(int32_t roc, int32_t row) const;
 
   /// maximal possible drift time of the active area
-  GPUd() float getMaxDriftTime(int32_t slice) const;
+  GPUd() float getMaxDriftTime(int32_t roc) const;
 
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 
@@ -359,7 +359,7 @@ class TPCFastTransform : public FlatObject
   /// Correction of (x,u,v) with tricubic interpolator on a regular grid
   TPCSlowSpaceChargeCorrection* mCorrectionSlow{nullptr}; ///< reference space charge corrections
 
-  GPUd() void TransformInternal(int32_t slice, int32_t row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const;
+  GPUd() void TransformInternal(int32_t roc, int32_t row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const;
 
   ClassDefNV(TPCFastTransform, 4);
 };
@@ -368,69 +368,69 @@ class TPCFastTransform : public FlatObject
 //              Inline implementations of some methods
 // =======================================================================
 
-GPUdi() void TPCFastTransform::convPadTimeToUV(int32_t slice, int32_t row, float pad, float time, float& u, float& v, float vertexTime) const
+GPUdi() void TPCFastTransform::convPadTimeToUV(int32_t roc, int32_t row, float pad, float time, float& u, float& v, float vertexTime) const
 {
-  bool sideC = (slice >= getGeometry().getNumberOfSlicesA());
+  bool sideC = (roc >= getGeometry().getNumberOfRocsA());
 
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  const TPCFastTransformGeo::SliceInfo& sliceInfo = getGeometry().getSliceInfo(slice);
+  const TPCFastTransformGeo::RocInfo& rocInfo = getGeometry().getRocInfo(roc);
 
   float x = rowInfo.x;
   u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
 
   float y = sideC ? -u : u; // pads are mirrorred on C-side
-  float yLab = y * sliceInfo.cosAlpha + x * sliceInfo.sinAlpha;
+  float yLab = y * rocInfo.cosAlpha + x * rocInfo.sinAlpha;
 
   v = (time - mT0 - vertexTime) * (mVdrift + mVdriftCorrY * yLab) + mLdriftCorr; // drift length cm
 }
 
-GPUdi() void TPCFastTransform::convTimeToVinTimeFrame(int32_t slice, float time, float& v, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convTimeToVinTimeFrame(int32_t roc, float time, float& v, float maxTimeBin) const
 {
   v = (time - mT0 - maxTimeBin) * mVdrift + mLdriftCorr; // drift length cm
-  if (slice < getGeometry().getNumberOfSlicesA()) {
+  if (roc < getGeometry().getNumberOfRocsA()) {
     v += getGeometry().getTPCzLengthA();
   } else {
     v += getGeometry().getTPCzLengthC();
   }
 }
 
-GPUdi() void TPCFastTransform::convPadTimeToUVinTimeFrame(int32_t slice, int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convPadTimeToUVinTimeFrame(int32_t roc, int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const
 {
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
   u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-  convTimeToVinTimeFrame(slice, time, v, maxTimeBin);
+  convTimeToVinTimeFrame(roc, time, v, maxTimeBin);
 }
 
-GPUdi() float TPCFastTransform::convZOffsetToVertexTime(int32_t slice, float zOffset, float maxTimeBin) const
+GPUdi() float TPCFastTransform::convZOffsetToVertexTime(int32_t roc, float zOffset, float maxTimeBin) const
 {
-  if (slice < getGeometry().getNumberOfSlicesA()) {
+  if (roc < getGeometry().getNumberOfRocsA()) {
     return maxTimeBin - (getGeometry().getTPCzLengthA() + zOffset) / mVdrift;
   } else {
     return maxTimeBin - (getGeometry().getTPCzLengthC() - zOffset) / mVdrift;
   }
 }
 
-GPUdi() float TPCFastTransform::convVertexTimeToZOffset(int32_t slice, float vertexTime, float maxTimeBin) const
+GPUdi() float TPCFastTransform::convVertexTimeToZOffset(int32_t roc, float vertexTime, float maxTimeBin) const
 {
-  if (slice < getGeometry().getNumberOfSlicesA()) {
+  if (roc < getGeometry().getNumberOfRocsA()) {
     return (maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLengthA();
   } else {
     return -((maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLengthC());
   }
 }
 
-GPUdi() void TPCFastTransform::convUVtoPadTime(int32_t slice, int32_t row, float u, float v, float& pad, float& time, float vertexTime) const
+GPUdi() void TPCFastTransform::convUVtoPadTime(int32_t roc, int32_t row, float u, float v, float& pad, float& time, float vertexTime) const
 {
-  bool sideC = (slice >= getGeometry().getNumberOfSlicesA());
+  bool sideC = (roc >= getGeometry().getNumberOfRocsA());
 
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  const TPCFastTransformGeo::SliceInfo& sliceInfo = getGeometry().getSliceInfo(slice);
+  const TPCFastTransformGeo::RocInfo& rocInfo = getGeometry().getRocInfo(roc);
 
   pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
 
   float x = rowInfo.x;
   float y = sideC ? -u : u; // pads are mirrorred on C-side
-  float yLab = y * sliceInfo.cosAlpha + x * sliceInfo.sinAlpha;
+  float yLab = y * rocInfo.cosAlpha + x * rocInfo.sinAlpha;
   time = mT0 + vertexTime + (v - mLdriftCorr) / (mVdrift + mVdriftCorrY * yLab);
 }
 
@@ -440,9 +440,9 @@ GPUdi() void TPCFastTransform::convVtoTime(float v, float& time, float vertexTim
   time = mT0 + vertexTime + (v - mLdriftCorr) / (mVdrift + mVdriftCorrY * yLab);
 }
 
-GPUdi() void TPCFastTransform::convUVtoPadTimeInTimeFrame(int32_t slice, int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convUVtoPadTimeInTimeFrame(int32_t roc, int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const
 {
-  if (slice < getGeometry().getNumberOfSlicesA()) {
+  if (roc < getGeometry().getNumberOfRocsA()) {
     v -= getGeometry().getTPCzLengthA();
   } else {
     v -= getGeometry().getTPCzLengthC();
@@ -452,17 +452,17 @@ GPUdi() void TPCFastTransform::convUVtoPadTimeInTimeFrame(int32_t slice, int32_t
   time = mT0 + maxTimeBin + (v - mLdriftCorr) / mVdrift;
 }
 
-GPUdi() void TPCFastTransform::getTOFcorrection(int32_t slice, int32_t /*row*/, float x, float y, float z, float& dz) const
+GPUdi() void TPCFastTransform::getTOFcorrection(int32_t roc, int32_t /*row*/, float x, float y, float z, float& dz) const
 {
   // calculate time of flight correction for  z coordinate
 
-  bool sideC = (slice >= getGeometry().getNumberOfSlicesA());
+  bool sideC = (roc >= getGeometry().getNumberOfRocsA());
   float distZ = z - mPrimVtxZ;
   float dv = -GPUCommonMath::Sqrt(x * x + y * y + distZ * distZ) * mTOFcorr;
   dz = sideC ? dv : -dv;
 }
 
-GPUdi() void TPCFastTransform::TransformInternal(int32_t slice, int32_t row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::TransformInternal(int32_t roc, int32_t row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
   if (mApplyCorrection) {
@@ -471,15 +471,15 @@ GPUdi() void TPCFastTransform::TransformInternal(int32_t slice, int32_t row, flo
 #ifndef GPUCA_GPUCODE
       if (mCorrectionSlow) {
         float ly, lz;
-        getGeometry().convUVtoLocal(slice, u, v, ly, lz);
+        getGeometry().convUVtoLocal(roc, u, v, ly, lz);
         float gx, gy, gz;
-        getGeometry().convLocalToGlobal(slice, x, ly, lz, gx, gy, gz);
+        getGeometry().convLocalToGlobal(roc, x, ly, lz, gx, gy, gz);
 
         float gdxC, gdyC, gdzC;
-        mCorrectionSlow->getCorrections(gx, gy, gz, slice, gdxC, gdyC, gdzC);
-        getGeometry().convGlobalToLocal(slice, gdxC, gdyC, gdzC, dx, du, dv);
+        mCorrectionSlow->getCorrections(gx, gy, gz, roc, gdxC, gdyC, gdzC);
+        getGeometry().convGlobalToLocal(roc, gdxC, gdyC, gdzC, dx, du, dv);
 
-        if (slice >= 18) {
+        if (roc >= 18) {
           du = -du; // mirror for c-Side
         } else {
           dv = -dv; // mirror z for A-Side
@@ -487,17 +487,17 @@ GPUdi() void TPCFastTransform::TransformInternal(int32_t slice, int32_t row, flo
       } else
 #endif // GPUCA_GPUCODE
       {
-        mCorrection.getCorrection(slice, row, u, v, dx, du, dv);
+        mCorrection.getCorrection(roc, row, u, v, dx, du, dv);
         if (ref) {
           if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
             float dxRef, duRef, dvRef;
-            ref->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
+            ref->mCorrection.getCorrection(roc, row, u, v, dxRef, duRef, dvRef);
             dx = (dx - dxRef) * scale + dxRef;
             du = (du - duRef) * scale + duRef;
             dv = (dv - dvRef) * scale + dvRef;
           } else if ((scale != 0.f) && ((scaleMode == 1) || (scaleMode == 2))) {
             float dxRef, duRef, dvRef;
-            ref->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
+            ref->mCorrection.getCorrection(roc, row, u, v, dxRef, duRef, dvRef);
             dx = dxRef * scale + dx;
             du = duRef * scale + du;
             dv = dvRef * scale + dv;
@@ -505,7 +505,7 @@ GPUdi() void TPCFastTransform::TransformInternal(int32_t slice, int32_t row, flo
         }
         if (ref2 && (scale2 != 0)) {
           float dxRef, duRef, dvRef;
-          ref2->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
+          ref2->mCorrection.getCorrection(roc, row, u, v, dxRef, duRef, dvRef);
           dx = dxRef * scale2 + dx;
           du = duRef * scale2 + du;
           dv = dvRef * scale2 + dv;
@@ -514,43 +514,43 @@ GPUdi() void TPCFastTransform::TransformInternal(int32_t slice, int32_t row, flo
     }
     GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
       float ly, lz;
-      getGeometry().convUVtoLocal(slice, u, v, ly, lz);
+      getGeometry().convUVtoLocal(roc, u, v, ly, lz);
 
       float gx, gy, gz;
-      getGeometry().convLocalToGlobal(slice, x, ly, lz, gx, gy, gz);
+      getGeometry().convLocalToGlobal(roc, x, ly, lz, gx, gy, gz);
 
       float lyT, lzT;
       float uCorr = u + du;
       float vCorr = v + dv;
       float lxT = x + dx;
-      getGeometry().convUVtoLocal(slice, uCorr, vCorr, lyT, lzT);
+      getGeometry().convUVtoLocal(roc, uCorr, vCorr, lyT, lzT);
 
       float invYZtoXScaled;
-      InverseTransformYZtoX(slice, row, lyT, lzT, invYZtoXScaled, ref, ref2, scale, scale2, scaleMode);
+      InverseTransformYZtoX(roc, row, lyT, lzT, invYZtoXScaled, ref, ref2, scale, scale2, scaleMode);
 
       float invYZtoX;
-      InverseTransformYZtoX(slice, row, lyT, lzT, invYZtoX);
+      InverseTransformYZtoX(roc, row, lyT, lzT, invYZtoX);
 
       float YZtoNominalY;
       float YZtoNominalZ;
-      InverseTransformYZtoNominalYZ(slice, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
+      InverseTransformYZtoNominalYZ(roc, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
 
       float YZtoNominalYScaled;
       float YZtoNominalZScaled;
-      InverseTransformYZtoNominalYZ(slice, row, lyT, lzT, YZtoNominalYScaled, YZtoNominalZScaled, ref, ref2, scale, scale2, scaleMode);
+      InverseTransformYZtoNominalYZ(roc, row, lyT, lzT, YZtoNominalYScaled, YZtoNominalZScaled, ref, ref2, scale, scale2, scaleMode);
 
       float dxRef, duRef, dvRef;
       if (ref) {
-        ref->mCorrection.getCorrection(slice, row, u, v, dxRef, duRef, dvRef);
+        ref->mCorrection.getCorrection(roc, row, u, v, dxRef, duRef, dvRef);
       }
 
       float dxRef2, duRef2, dvRef2;
       if (ref2) {
-        ref2->mCorrection.getCorrection(slice, row, u, v, dxRef2, duRef2, dvRef2);
+        ref2->mCorrection.getCorrection(roc, row, u, v, dxRef2, duRef2, dvRef2);
       }
 
       float dxOrig, duOrig, dvOrig;
-      mCorrection.getCorrection(slice, row, u, v, dxOrig, duOrig, dvOrig);
+      mCorrection.getCorrection(roc, row, u, v, dxOrig, duOrig, dvOrig);
 
       o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
                                                                                          // corrections in x, u, v
@@ -569,7 +569,7 @@ GPUdi() void TPCFastTransform::TransformInternal(int32_t slice, int32_t row, flo
                                                                                          << "v=" << v
                                                                                          << "u=" << u
                                                                                          << "row=" << row
-                                                                                         << "slice=" << slice
+                                                                                         << "roc=" << roc
                                                                                          << "scale=" << scale
                                                                                          << "scale2=" << scale2
                                                                                          // original local coordinates
@@ -601,51 +601,51 @@ GPUdi() void TPCFastTransform::TransformInternal(int32_t slice, int32_t row, flo
   }
 }
 
-GPUdi() void TPCFastTransform::TransformXYZ(int32_t slice, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::TransformXYZ(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   float u, v;
-  getGeometry().convLocalToUV(slice, y, z, u, v);
-  TransformInternal(slice, row, u, v, x, ref, ref2, scale, scale2, scaleMode);
-  getGeometry().convUVtoLocal(slice, u, v, y, z);
+  getGeometry().convLocalToUV(roc, y, z, u, v);
+  TransformInternal(roc, row, u, v, x, ref, ref2, scale, scale2, scaleMode);
+  getGeometry().convUVtoLocal(roc, u, v, y, z);
   float dzTOF = 0;
-  getTOFcorrection(slice, row, x, y, z, dzTOF);
+  getTOFcorrection(roc, row, x, y, z, dzTOF);
   z += dzTOF;
 }
 
-GPUdi() void TPCFastTransform::Transform(int32_t slice, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::Transform(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   /// _______________ The main method: cluster transformation _______________________
   ///
-  /// Transforms raw TPC coordinates to local XYZ withing a slice
+  /// Transforms raw TPC coordinates to local XYZ withing a roc
   /// taking calibration + alignment into account.
   ///
 
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
 
-  // const SliceInfo &sliceInfo = getSliceInfo( slice );
-  // bool sideC = ( slice >= NumberOfSlices / 2 );
+  // const RocInfo &rocInfo = getRocInfo( roc );
+  // bool sideC = ( roc >= NumberOfRocs / 2 );
 
   x = rowInfo.x;
   float u = 0, v = 0;
-  convPadTimeToUV(slice, row, pad, time, u, v, vertexTime);
+  convPadTimeToUV(roc, row, pad, time, u, v, vertexTime);
 
-  TransformInternal(slice, row, u, v, x, ref, ref2, scale, scale2, scaleMode);
+  TransformInternal(roc, row, u, v, x, ref, ref2, scale, scale2, scaleMode);
 
-  getGeometry().convUVtoLocal(slice, u, v, y, z);
+  getGeometry().convUVtoLocal(roc, u, v, y, z);
 
   float dzTOF = 0;
-  getTOFcorrection(slice, row, x, y, z, dzTOF);
+  getTOFcorrection(roc, row, x, y, z, dzTOF);
   z += dzTOF;
 }
 
-GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t slice, float time, float& z, float maxTimeBin) const
+GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t roc, float time, float& z, float maxTimeBin) const
 {
   float v = 0;
-  convTimeToVinTimeFrame(slice, time, v, maxTimeBin);
-  getGeometry().convVtoLocal(slice, v, z);
+  convTimeToVinTimeFrame(roc, time, v, maxTimeBin);
+  getGeometry().convVtoLocal(roc, v, z);
 }
 
-GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t slice, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
+GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
 {
   /// _______________ Special cluster transformation for a time frame _______________________
   ///
@@ -656,43 +656,43 @@ GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t slice, int32_t row,
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
   x = rowInfo.x;
   float u = 0, v = 0;
-  convPadTimeToUVinTimeFrame(slice, row, pad, time, u, v, maxTimeBin);
-  getGeometry().convUVtoLocal(slice, u, v, y, z);
+  convPadTimeToUVinTimeFrame(roc, row, pad, time, u, v, maxTimeBin);
+  getGeometry().convUVtoLocal(roc, u, v, y, z);
 }
 
-GPUdi() void TPCFastTransform::InverseTransformInTimeFrame(int32_t slice, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const
+GPUdi() void TPCFastTransform::InverseTransformInTimeFrame(int32_t roc, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const
 {
   /// Inverse transformation to TransformInTimeFrame
   float u = 0, v = 0;
-  getGeometry().convLocalToUV(slice, y, z, u, v);
-  convUVtoPadTimeInTimeFrame(slice, row, u, v, pad, time, maxTimeBin);
+  getGeometry().convLocalToUV(roc, y, z, u, v);
+  convUVtoPadTimeInTimeFrame(roc, row, u, v, pad, time, maxTimeBin);
 }
 
-GPUdi() float TPCFastTransform::InverseTransformInTimeFrame(int32_t slice, float z, float maxTimeBin) const
+GPUdi() float TPCFastTransform::InverseTransformInTimeFrame(int32_t roc, float z, float maxTimeBin) const
 {
   float pad, time;
-  InverseTransformInTimeFrame(slice, 0, 0, 0, z, pad, time, maxTimeBin);
+  InverseTransformInTimeFrame(roc, 0, 0, 0, z, pad, time, maxTimeBin);
   return time;
 }
 
-GPUdi() void TPCFastTransform::TransformIdealZ(int32_t slice, float time, float& z, float vertexTime) const
+GPUdi() void TPCFastTransform::TransformIdealZ(int32_t roc, float time, float& z, float vertexTime) const
 {
   /// _______________ The main method: cluster transformation _______________________
   ///
-  /// Transforms time TPC coordinates to local Z withing a slice
+  /// Transforms time TPC coordinates to local Z withing a roc
   /// Ideal transformation: only Vdrift from DCS.
   /// No space charge corrections, no time of flight correction
   ///
 
   float v = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  getGeometry().convVtoLocal(slice, v, z);
+  getGeometry().convVtoLocal(roc, v, z);
 }
 
-GPUdi() void TPCFastTransform::TransformIdeal(int32_t slice, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
+GPUdi() void TPCFastTransform::TransformIdeal(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
 {
   /// _______________ The main method: cluster transformation _______________________
   ///
-  /// Transforms raw TPC coordinates to local XYZ withing a slice
+  /// Transforms raw TPC coordinates to local XYZ withing a roc
   /// Ideal transformation: only Vdrift from DCS.
   /// No space charge corrections, no time of flight correction
   ///
@@ -703,10 +703,10 @@ GPUdi() void TPCFastTransform::TransformIdeal(int32_t slice, int32_t row, float
   float u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
   float v = (time - mT0 - vertexTime) * mVdrift; // drift length cm
 
-  getGeometry().convUVtoLocal(slice, u, v, y, z);
+  getGeometry().convUVtoLocal(roc, u, v, y, z);
 }
 
-GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t slice, float time, float maxTimeBin) const
+GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t roc, float time, float maxTimeBin) const
 {
   /// _______________ Special cluster transformation for a time frame _______________________
   ///
@@ -717,7 +717,7 @@ GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t slice, float time
 
   float v = (time - mT0 - maxTimeBin) * mVdrift + mLdriftCorr; // drift length cm
   float z = getGeometry().getTPCalignmentZ();                  // global TPC alignment
-  if (slice < getGeometry().getNumberOfSlicesA()) {
+  if (roc < getGeometry().getNumberOfRocsA()) {
     z -= v;
   } else {
     z += v;
@@ -725,11 +725,11 @@ GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t slice, float time
   return z;
 }
 
-GPUdi() float TPCFastTransform::convZtoTimeInTimeFrame(int32_t slice, float z, float maxTimeBin) const
+GPUdi() float TPCFastTransform::convZtoTimeInTimeFrame(int32_t roc, float z, float maxTimeBin) const
 {
   /// Inverse transformation of convTimeToZinTimeFrame()
   float v;
-  if (slice < getGeometry().getNumberOfSlicesA()) {
+  if (roc < getGeometry().getNumberOfRocsA()) {
     v = getGeometry().getTPCalignmentZ() - z;
   } else {
     v = z - getGeometry().getTPCalignmentZ();
@@ -737,10 +737,10 @@ GPUdi() float TPCFastTransform::convZtoTimeInTimeFrame(int32_t slice, float z, f
   return mT0 + maxTimeBin + (v - mLdriftCorr) / mVdrift;
 }
 
-GPUdi() float TPCFastTransform::convDeltaTimeToDeltaZinTimeFrame(int32_t slice, float deltaTime) const
+GPUdi() float TPCFastTransform::convDeltaTimeToDeltaZinTimeFrame(int32_t roc, float deltaTime) const
 {
   float deltaZ = deltaTime * mVdrift;
-  return slice < getGeometry().getNumberOfSlicesA() ? -deltaZ : deltaZ;
+  return roc < getGeometry().getNumberOfRocsA() ? -deltaZ : deltaZ;
 }
 
 GPUdi() float TPCFastTransform::convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const
@@ -748,80 +748,80 @@ GPUdi() float TPCFastTransform::convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ
   return deltaZ / mVdrift;
 }
 
-GPUdi() float TPCFastTransform::convDeltaZtoDeltaTimeInTimeFrame(int32_t slice, float deltaZ) const
+GPUdi() float TPCFastTransform::convDeltaZtoDeltaTimeInTimeFrame(int32_t roc, float deltaZ) const
 {
   float deltaT = deltaZ / mVdrift;
-  return slice < getGeometry().getNumberOfSlicesA() ? -deltaT : deltaT;
+  return roc < getGeometry().getNumberOfRocsA() ? -deltaT : deltaT;
 }
 
 /*
-GPUdi() float TPCFastTransform::getLastCalibratedTimeBin(int32_t slice) const
+GPUdi() float TPCFastTransform::getLastCalibratedTimeBin(int32_t roc) const
 {
   /// Return a value of the last timebin where correction map is valid
   float u, v, pad, time;
-  getGeometry().convScaledUVtoUV(slice, 0, 0.f, 1.f, u, v);
-  convUVtoPadTime(slice, 0, u, v, pad, time, 0);
+  getGeometry().convScaledUVtoUV(roc, 0, 0.f, 1.f, u, v);
+  convUVtoPadTime(roc, 0, u, v, pad, time, 0);
   return time;
 }
 */
 
-GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t slice, int32_t row, float pad) const
+GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t roc, int32_t row, float pad) const
 {
   /// maximal possible drift time of the active area
-  float maxL = mCorrection.getMaxDriftLength(slice, row, pad);
+  float maxL = mCorrection.getMaxDriftLength(roc, row, pad);
 
-  bool sideC = (slice >= getGeometry().getNumberOfSlicesA());
+  bool sideC = (roc >= getGeometry().getNumberOfRocsA());
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  const TPCFastTransformGeo::SliceInfo& sliceInfo = getGeometry().getSliceInfo(slice);
+  const TPCFastTransformGeo::RocInfo& rocInfo = getGeometry().getRocInfo(roc);
 
   float x = rowInfo.x;
   float u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
 
   float y = sideC ? -u : u; // pads are mirrorred on C-side
-  float yLab = y * sliceInfo.cosAlpha + x * sliceInfo.sinAlpha;
+  float yLab = y * rocInfo.cosAlpha + x * rocInfo.sinAlpha;
   return mT0 + (maxL - mLdriftCorr) / (mVdrift + mVdriftCorrY * yLab);
 }
 
-GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t slice, int32_t row) const
+GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t roc, int32_t row) const
 {
   /// maximal possible drift time of the active area
-  float maxL = mCorrection.getMaxDriftLength(slice, row);
+  float maxL = mCorrection.getMaxDriftLength(roc, row);
   float maxTime = 0.f;
   convVtoTime(maxL, maxTime, 0.f);
   return maxTime;
 }
 
-GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t slice) const
+GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t roc) const
 {
   /// maximal possible drift time of the active area
-  float maxL = mCorrection.getMaxDriftLength(slice);
+  float maxL = mCorrection.getMaxDriftLength(roc);
   float maxTime = 0.f;
   convVtoTime(maxL, maxTime, 0.f);
   return maxTime;
 }
 
-GPUdi() void TPCFastTransform::InverseTransformYZtoX(int32_t slice, int32_t row, float y, float z, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformYZtoX(int32_t roc, int32_t row, float y, float z, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
   /// Transformation y,z -> x
   float u = 0, v = 0;
-  getGeometry().convLocalToUV(slice, y, z, u, v);
+  getGeometry().convLocalToUV(roc, y, z, u, v);
   if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, x);
+    mCorrection.getCorrectionInvCorrectedX(roc, row, u, v, x);
     if (ref) { // scaling was requested
       if (scaleMode == 0 && scale > 0.f) {
         float xr;
-        ref->mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, xr);
+        ref->mCorrection.getCorrectionInvCorrectedX(roc, row, u, v, xr);
         x = (x - xr) * scale + xr;
       } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
         float xr;
-        ref->mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, xr);
+        ref->mCorrection.getCorrectionInvCorrectedX(roc, row, u, v, xr);
         x = (xr - getGeometry().getRowInfo(row).x) * scale + x; // xr=mGeo.getRowInfo(row).x + dx;
       }
     }
     if (ref2 && (scale2 != 0)) {
       float xr;
-      ref2->mCorrection.getCorrectionInvCorrectedX(slice, row, u, v, xr);
+      ref2->mCorrection.getCorrectionInvCorrectedX(roc, row, u, v, xr);
       x = (xr - getGeometry().getRowInfo(row).x) * scale2 + x; // xr=mGeo.getRowInfo(row).x + dx;
     }
   } else {
@@ -829,7 +829,7 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoX(int32_t slice, int32_t row,
   }
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoX").data()
-                                                                                       << "slice=" << slice
+                                                                                       << "roc=" << roc
                                                                                        << "row=" << row
                                                                                        << "scale=" << scale
                                                                                        << "y=" << y
@@ -841,29 +841,29 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoX(int32_t slice, int32_t row,
   })
 }
 
-GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t slice, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t roc, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
   /// Transformation y,z -> x
   float u = 0, v = 0, un = 0, vn = 0;
-  getGeometry().convLocalToUV(slice, y, z, u, v);
+  getGeometry().convLocalToUV(roc, y, z, u, v);
   if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    mCorrection.getCorrectionInvUV(slice, row, u, v, un, vn);
+    mCorrection.getCorrectionInvUV(roc, row, u, v, un, vn);
     if (ref) { // scaling was requested
       if (scaleMode == 0 && scale > 0.f) {
         float unr = 0, vnr = 0;
-        ref->mCorrection.getCorrectionInvUV(slice, row, u, v, unr, vnr);
+        ref->mCorrection.getCorrectionInvUV(roc, row, u, v, unr, vnr);
         un = (un - unr) * scale + unr;
         vn = (vn - vnr) * scale + vnr;
       } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
         float unr = 0, vnr = 0;
-        ref->mCorrection.getCorrectionInvUV(slice, row, u, v, unr, vnr);
+        ref->mCorrection.getCorrectionInvUV(roc, row, u, v, unr, vnr);
         un = (unr - u) * scale + un; // unr = u - duv[0];
         vn = (vnr - v) * scale + vn;
       }
       if (ref2 && (scale2 != 0)) {
         float unr = 0, vnr = 0;
-        ref2->mCorrection.getCorrectionInvUV(slice, row, u, v, unr, vnr);
+        ref2->mCorrection.getCorrectionInvUV(roc, row, u, v, unr, vnr);
         un = (unr - u) * scale2 + un; // unr = u - duv[0];
         vn = (vnr - v) * scale2 + vn;
       }
@@ -872,11 +872,11 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t slice, int3
     un = u;
     vn = v;
   }
-  getGeometry().convUVtoLocal(slice, un, vn, ny, nz);
+  getGeometry().convUVtoLocal(roc, un, vn, ny, nz);
 
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoNominalYZ").data()
-                                                                                       << "slice=" << slice
+                                                                                       << "roc=" << roc
                                                                                        << "row=" << row
                                                                                        << "scale=" << scale
                                                                                        << "y=" << y
@@ -891,7 +891,7 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t slice, int3
   })
 }
 
-GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int32_t slice, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int32_t roc, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
   int32_t row2 = row + 1;
@@ -902,8 +902,8 @@ GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int32_t slice, in
   float nx2, ny2, nz2; // nominal coordinates for row2
   nx1 = getGeometry().getRowInfo(row).x;
   nx2 = getGeometry().getRowInfo(row2).x;
-  InverseTransformYZtoNominalYZ(slice, row, y, z, ny1, nz1, ref, ref2, scale, scale2, scaleMode);
-  InverseTransformYZtoNominalYZ(slice, row2, y, z, ny2, nz2, ref, ref2, scale, scale2, scaleMode);
+  InverseTransformYZtoNominalYZ(roc, row, y, z, ny1, nz1, ref, ref2, scale, scale2, scaleMode);
+  InverseTransformYZtoNominalYZ(roc, row2, y, z, ny2, nz2, ref, ref2, scale, scale2, scaleMode);
   float c1 = (nx2 - nx) / (nx2 - nx1);
   float c2 = (nx - nx1) / (nx2 - nx1);
   nx = x;
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
index 3c624b3222d77..b472868fa1071 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
@@ -28,14 +28,14 @@ using namespace o2::gpu;
 TPCFastTransformGeo::TPCFastTransformGeo()
 {
   // Default Constructor: creates an empty uninitialized object
-  double dAlpha = 2. * M_PI / (NumberOfSlicesA);
-  for (int32_t i = 0; i < NumberOfSlices; i++) {
-    SliceInfo& s = mSliceInfos[i];
+  double dAlpha = 2. * M_PI / (NumberOfRocsA);
+  for (int32_t i = 0; i < NumberOfRocs; i++) {
+    RocInfo& s = mRocInfos[i];
     double alpha = dAlpha * (i + 0.5);
     s.sinAlpha = sin(alpha);
     s.cosAlpha = cos(alpha);
   }
-  mSliceInfos[NumberOfSlices] = SliceInfo{0.f, 0.f};
+  mRocInfos[NumberOfRocs] = RocInfo{0.f, 0.f};
 
   for (int32_t i = 0; i < MaxNumberOfRows + 1; i++) {
     mRowInfos[i] = RowInfo{0.f, -1, 0.f, 0.f, 0.f, 0.f};
@@ -104,7 +104,7 @@ void TPCFastTransformGeo::setTPCrow(int32_t iRow, float x, int32_t nPads, float
 
   // Make scaled U = area between the geometrical sector borders
 
-  const double sectorAngle = 2. * M_PI / NumberOfSlicesA;
+  const double sectorAngle = 2. * M_PI / NumberOfRocsA;
   const double scaleXtoRowWidth = 2. * tan(0.5 * sectorAngle);
   double uWidth = x * scaleXtoRowWidth; // distance to the sector border
 
@@ -148,7 +148,7 @@ void TPCFastTransformGeo::print() const
 #endif
 }
 
-int32_t TPCFastTransformGeo::test(int32_t slice, int32_t row, float ly, float lz) const
+int32_t TPCFastTransformGeo::test(int32_t roc, int32_t row, float ly, float lz) const
 {
   /// Check consistency of the class
 
@@ -164,16 +164,16 @@ int32_t TPCFastTransformGeo::test(int32_t slice, int32_t row, float ly, float lz
   float lx1 = 0.f, ly1 = 0.f, lz1 = 0.f;
   float gx = 0.f, gy = 0.f, gz = 0.f;
 
-  convLocalToGlobal(slice, lx, ly, lz, gx, gy, gz);
-  convGlobalToLocal(slice, gx, gy, gz, lx1, ly1, lz1);
+  convLocalToGlobal(roc, lx, ly, lz, gx, gy, gz);
+  convGlobalToLocal(roc, gx, gy, gz, lx1, ly1, lz1);
 
   if (fabs(lx1 - lx) > 1.e-4 || fabs(ly1 - ly) > 1.e-4 || fabs(lz1 - lz) > 1.e-7) {
     LOG(info) << "Error local <-> global: x " << lx << " dx " << lx1 - lx << " y " << ly << " dy " << ly1 - ly << " z " << lz << " dz " << lz1 - lz;
     error = -3;
   }
   float u = 0.f, v = 0.f;
-  convLocalToUV(slice, ly, lz, u, v);
-  convUVtoLocal(slice, u, v, ly1, lz1);
+  convLocalToUV(roc, ly, lz, u, v);
+  convUVtoLocal(roc, u, v, ly1, lz1);
 
   if (fabs(ly1 - ly) + fabs(lz1 - lz) > 1.e-6) {
     LOG(info) << "Error local <-> UV: y " << ly << " dy " << ly1 - ly << " z " << lz << " dz " << lz1 - lz;
@@ -182,7 +182,7 @@ int32_t TPCFastTransformGeo::test(int32_t slice, int32_t row, float ly, float lz
 
   float su = 0.f, sv = 0.f;
 
-  convUVtoScaledUV(slice, row, u, v, su, sv);
+  convUVtoScaledUV(roc, row, u, v, su, sv);
 
   if (su < 0.f || su > 1.f) {
     LOG(info) << "Error scaled U range: u " << u << " su " << su;
@@ -190,7 +190,7 @@ int32_t TPCFastTransformGeo::test(int32_t slice, int32_t row, float ly, float lz
   }
 
   float u1 = 0.f, v1 = 0.f;
-  convScaledUVtoUV(slice, row, su, sv, u1, v1);
+  convScaledUVtoUV(roc, row, su, sv, u1, v1);
 
   if (fabs(u1 - u) > 1.e-4 || fabs(v1 - v) > 1.e-4) {
     LOG(info) << "Error UV<->scaled UV: u " << u << " du " << u1 - u << " v " << v << " dv " << v1 - v;
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index d20331ba6ab0f..3382d1d926ce2 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -34,11 +34,11 @@ namespace gpu
 class TPCFastTransformGeo
 {
  public:
-  /// The struct contains necessary info for TPC slice
-  struct SliceInfo {
+  /// The struct contains necessary info for TPC ROC
+  struct RocInfo {
     float sinAlpha;
     float cosAlpha;
-    ClassDefNV(SliceInfo, 1);
+    ClassDefNV(RocInfo, 1);
   };
 
   /// The struct contains necessary info about TPC padrow
@@ -58,6 +58,7 @@ class TPCFastTransformGeo
 
     /// get width in U
     GPUd() float getUwidth() const { return -2.f * u0; }
+
     ClassDefNV(RowInfo, 1);
   };
 
@@ -107,11 +108,11 @@ class TPCFastTransformGeo
 
   /// _______________  Getters _________________________________
 
-  /// Gives number of TPC slices
-  GPUd() static constexpr int32_t getNumberOfSlices() { return NumberOfSlices; }
+  /// Gives number of TPC ROCs
+  GPUd() static constexpr int32_t getNumberOfRocs() { return NumberOfRocs; }
 
-  /// Gives number of TPC slices in A side
-  GPUd() static constexpr int32_t getNumberOfSlicesA() { return NumberOfSlicesA; }
+  /// Gives number of TPC ROCs on the A side
+  GPUd() static constexpr int32_t getNumberOfRocsA() { return NumberOfRocsA; }
 
   /// Gives number of TPC rows
   GPUd() int32_t getNumberOfRows() const { return mNumberOfRows; }
@@ -119,8 +120,8 @@ class TPCFastTransformGeo
   /// Gives number of TPC rows
   GPUd() static constexpr int getMaxNumberOfRows() { return MaxNumberOfRows; }
 
-  /// Gives slice info
-  GPUd() const SliceInfo& getSliceInfo(int32_t slice) const;
+  /// Gives roc info
+  GPUd() const RocInfo& getRocInfo(int32_t roc) const;
 
   /// Gives TPC row info
   GPUd() const RowInfo& getRowInfo(int32_t row) const;
@@ -131,11 +132,11 @@ class TPCFastTransformGeo
   /// Gives Z length of the TPC, side C
   GPUd() float getTPCzLengthC() const { return mTPCzLengthC; }
 
-  /// Gives Z length of the TPC, depending on the slice
-  GPUd() float getTPCzLength(int32_t slice) const
+  /// Gives Z length of the TPC, depending on the roc
+  GPUd() float getTPCzLength(int32_t roc) const
   {
-    return (slice < NumberOfSlicesA) ? mTPCzLengthA
-                                     : mTPCzLengthC;
+    return (roc < NumberOfRocsA) ? mTPCzLengthA
+                                 : mTPCzLengthC;
   }
 
   /// Gives TPC alignment in Z
@@ -144,26 +145,26 @@ class TPCFastTransformGeo
   /// _______________  Conversion of coordinate systems __________
 
   /// convert Local -> Global c.s.
-  GPUd() void convLocalToGlobal(int32_t slice, float lx, float ly, float lz, float& gx, float& gy, float& gz) const;
+  GPUd() void convLocalToGlobal(int32_t roc, float lx, float ly, float lz, float& gx, float& gy, float& gz) const;
 
   /// convert Global->Local c.s.
-  GPUd() void convGlobalToLocal(int32_t slice, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
+  GPUd() void convGlobalToLocal(int32_t roc, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
 
   /// convert UV -> Local c.s.
-  GPUd() void convUVtoLocal(int32_t slice, float u, float v, float& y, float& z) const;
-  GPUd() void convVtoLocal(int32_t slice, float v, float& z) const;
+  GPUd() void convUVtoLocal(int32_t roc, float u, float v, float& y, float& z) const;
+  GPUd() void convVtoLocal(int32_t roc, float v, float& z) const;
 
   /// convert Local-> UV c.s.
-  GPUd() void convLocalToUV(int32_t slice, float y, float z, float& u, float& v) const;
+  GPUd() void convLocalToUV(int32_t roc, float y, float z, float& u, float& v) const;
 
   /// convert UV -> Scaled UV
-  GPUd() void convUVtoScaledUV(int32_t slice, int32_t row, float u, float v, float& su, float& sv) const;
+  GPUd() void convUVtoScaledUV(int32_t roc, int32_t row, float u, float v, float& su, float& sv) const;
 
   /// convert Scaled UV -> UV
-  GPUd() void convScaledUVtoUV(int32_t slice, int32_t row, float su, float sv, float& u, float& v) const;
+  GPUd() void convScaledUVtoUV(int32_t roc, int32_t row, float su, float sv, float& u, float& v) const;
 
   /// convert Scaled UV -> Local c.s.
-  GPUd() void convScaledUVtoLocal(int32_t slice, int32_t row, float su, float sv, float& ly, float& lz) const;
+  GPUd() void convScaledUVtoLocal(int32_t roc, int32_t row, float su, float sv, float& ly, float& lz) const;
 
   /// convert Pad coordinate -> U
   GPUd() float convPadToU(int32_t row, float pad) const;
@@ -175,7 +176,7 @@ class TPCFastTransformGeo
   void print() const;
 
   /// Method for testing consistency
-  int32_t test(int32_t slice, int32_t row, float ly, float lz) const;
+  int32_t test(int32_t roc, int32_t row, float ly, float lz) const;
 
   /// Method for testing consistency
   int32_t test() const;
@@ -183,9 +184,9 @@ class TPCFastTransformGeo
  private:
   /// _______________  Data members  _______________________________________________
 
-  static constexpr int32_t NumberOfSlices = 36;                  ///< Number of TPC slices ( slice = inner + outer sector )
-  static constexpr int32_t NumberOfSlicesA = NumberOfSlices / 2; ///< Number of TPC slices side A
-  static constexpr int32_t MaxNumberOfRows = 160;                ///< Max Number of TPC rows in a slice
+  static constexpr int32_t NumberOfRocs = 36;                ///< Number of TPC rocs ( roc = inner + outer sector )
+  static constexpr int32_t NumberOfRocsA = NumberOfRocs / 2; ///< Number of TPC rocs side A
+  static constexpr int32_t MaxNumberOfRows = 160;            ///< Max Number of TPC rows in a roc
 
   /// _______________  Construction control  _______________________________________________
 
@@ -211,23 +212,23 @@ class TPCFastTransformGeo
   float mScaleSVtoVsideA = 0.f; ///< scale for sv->v for TPC side A
   float mScaleSVtoVsideC = 0.f; ///< scale for sv->v for TPC side C
 
-  SliceInfo mSliceInfos[NumberOfSlices + 1]; ///< array of slice information [fixed size]
+  RocInfo mRocInfos[NumberOfRocs + 1];       ///< array of roc information [fixed size]
   RowInfo mRowInfos[MaxNumberOfRows + 1];    ///< array of row information [fixed size]
 
-  ClassDefNV(TPCFastTransformGeo, 1);
+  ClassDefNV(TPCFastTransformGeo, 2);
 };
 
 // =======================================================================
 //              Inline implementations of some methods
 // =======================================================================
 
-GPUdi() const TPCFastTransformGeo::SliceInfo& TPCFastTransformGeo::getSliceInfo(int32_t slice) const
+GPUdi() const TPCFastTransformGeo::RocInfo& TPCFastTransformGeo::getRocInfo(int32_t roc) const
 {
-  /// Gives slice info
-  if (slice < 0 || slice >= NumberOfSlices) { // return zero object
-    slice = NumberOfSlices;
+  /// Gives roc info
+  if (roc < 0 || roc >= NumberOfRocs) { // return zero object
+    roc = NumberOfRocs;
   }
-  return mSliceInfos[slice];
+  return mRocInfos[roc];
 }
 
 GPUdi() const TPCFastTransformGeo::RowInfo& TPCFastTransformGeo::getRowInfo(int32_t row) const
@@ -239,28 +240,28 @@ GPUdi() const TPCFastTransformGeo::RowInfo& TPCFastTransformGeo::getRowInfo(int3
   return mRowInfos[row];
 }
 
-GPUdi() void TPCFastTransformGeo::convLocalToGlobal(int32_t slice, float lx, float ly, float lz, float& gx, float& gy, float& gz) const
+GPUdi() void TPCFastTransformGeo::convLocalToGlobal(int32_t roc, float lx, float ly, float lz, float& gx, float& gy, float& gz) const
 {
   /// convert Local -> Global c.s.
-  const SliceInfo& sliceInfo = getSliceInfo(slice);
-  gx = lx * sliceInfo.cosAlpha - ly * sliceInfo.sinAlpha;
-  gy = lx * sliceInfo.sinAlpha + ly * sliceInfo.cosAlpha;
+  const RocInfo& rocInfo = getRocInfo(roc);
+  gx = lx * rocInfo.cosAlpha - ly * rocInfo.sinAlpha;
+  gy = lx * rocInfo.sinAlpha + ly * rocInfo.cosAlpha;
   gz = lz;
 }
 
-GPUdi() void TPCFastTransformGeo::convGlobalToLocal(int32_t slice, float gx, float gy, float gz, float& lx, float& ly, float& lz) const
+GPUdi() void TPCFastTransformGeo::convGlobalToLocal(int32_t roc, float gx, float gy, float gz, float& lx, float& ly, float& lz) const
 {
   /// convert Global -> Local c.s.
-  const SliceInfo& sliceInfo = getSliceInfo(slice);
-  lx = gx * sliceInfo.cosAlpha + gy * sliceInfo.sinAlpha;
-  ly = -gx * sliceInfo.sinAlpha + gy * sliceInfo.cosAlpha;
+  const RocInfo& rocInfo = getRocInfo(roc);
+  lx = gx * rocInfo.cosAlpha + gy * rocInfo.sinAlpha;
+  ly = -gx * rocInfo.sinAlpha + gy * rocInfo.cosAlpha;
   lz = gz;
 }
 
-GPUdi() void TPCFastTransformGeo::convVtoLocal(int32_t slice, float v, float& lz) const
+GPUdi() void TPCFastTransformGeo::convVtoLocal(int32_t roc, float v, float& lz) const
 {
   /// convert UV -> Local c.s.
-  if (slice < NumberOfSlicesA) { // TPC side A
+  if (roc < NumberOfRocsA) { // TPC side A
     lz = mTPCzLengthA - v;
   } else {                 // TPC side C
     lz = v - mTPCzLengthC; // drift direction is mirrored on C-side
@@ -268,10 +269,10 @@ GPUdi() void TPCFastTransformGeo::convVtoLocal(int32_t slice, float v, float& lz
   lz += mTPCalignmentZ; // global TPC alignment
 }
 
-GPUdi() void TPCFastTransformGeo::convUVtoLocal(int32_t slice, float u, float v, float& ly, float& lz) const
+GPUdi() void TPCFastTransformGeo::convUVtoLocal(int32_t roc, float u, float v, float& ly, float& lz) const
 {
   /// convert UV -> Local c.s.
-  if (slice < NumberOfSlicesA) { // TPC side A
+  if (roc < NumberOfRocsA) { // TPC side A
     ly = u;
     lz = mTPCzLengthA - v;
   } else {                 // TPC side C
@@ -281,11 +282,11 @@ GPUdi() void TPCFastTransformGeo::convUVtoLocal(int32_t slice, float u, float v,
   lz += mTPCalignmentZ; // global TPC alignment
 }
 
-GPUdi() void TPCFastTransformGeo::convLocalToUV(int32_t slice, float ly, float lz, float& u, float& v) const
+GPUdi() void TPCFastTransformGeo::convLocalToUV(int32_t roc, float ly, float lz, float& u, float& v) const
 {
   /// convert Local-> UV c.s.
   lz = lz - mTPCalignmentZ;      // global TPC alignment
-  if (slice < NumberOfSlicesA) { // TPC side A
+  if (roc < NumberOfRocsA) {     // TPC side A
     u = ly;
     v = mTPCzLengthA - lz;
   } else {                 // TPC side C
@@ -294,36 +295,36 @@ GPUdi() void TPCFastTransformGeo::convLocalToUV(int32_t slice, float ly, float l
   }
 }
 
-GPUdi() void TPCFastTransformGeo::convUVtoScaledUV(int32_t slice, int32_t row, float u, float v, float& su, float& sv) const
+GPUdi() void TPCFastTransformGeo::convUVtoScaledUV(int32_t roc, int32_t row, float u, float v, float& su, float& sv) const
 {
   /// convert UV -> Scaled UV
   const RowInfo& rowInfo = getRowInfo(row);
   su = (u - rowInfo.u0) * rowInfo.scaleUtoSU;
-  if (slice < NumberOfSlicesA) {
+  if (roc < NumberOfRocsA) {
     sv = v * mScaleVtoSVsideA;
   } else {
     sv = v * mScaleVtoSVsideC;
   }
 }
 
-GPUdi() void TPCFastTransformGeo::convScaledUVtoUV(int32_t slice, int32_t row, float su, float sv, float& u, float& v) const
+GPUdi() void TPCFastTransformGeo::convScaledUVtoUV(int32_t roc, int32_t row, float su, float sv, float& u, float& v) const
 {
   /// convert Scaled UV -> UV
   const RowInfo& rowInfo = getRowInfo(row);
   u = rowInfo.u0 + su * rowInfo.scaleSUtoU;
-  if (slice < NumberOfSlicesA) {
+  if (roc < NumberOfRocsA) {
     v = sv * mScaleSVtoVsideA;
   } else {
     v = sv * mScaleSVtoVsideC;
   }
 }
 
-GPUdi() void TPCFastTransformGeo::convScaledUVtoLocal(int32_t slice, int32_t row, float su, float sv, float& ly, float& lz) const
+GPUdi() void TPCFastTransformGeo::convScaledUVtoLocal(int32_t roc, int32_t row, float su, float sv, float& ly, float& lz) const
 {
   /// convert Scaled UV -> Local c.s.
   float u, v;
-  convScaledUVtoUV(slice, row, su, sv, u, v);
-  convUVtoLocal(slice, u, v, ly, lz);
+  convScaledUVtoUV(roc, row, su, sv, u, v);
+  convUVtoLocal(roc, u, v, ly, lz);
 }
 
 GPUdi() float TPCFastTransformGeo::convPadToU(int32_t row, float pad) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransformManager.cxx b/GPU/TPCFastTransformation/TPCFastTransformManager.cxx
index 7d0aa29545578..aa28b6a414876 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformManager.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformManager.cxx
@@ -87,14 +87,14 @@ int32_t TPCFastTransformManager::create(TPCFastTransform& fastTransform,
 
     float tpcZlengthSideA = tpcParam->GetZLength(0);
     float tpcZlengthSideC =
-      tpcParam->GetZLength(TPCFastTransformGeo::getNumberOfSlices() / 2);
+      tpcParam->GetZLength(TPCFastTransformGeo::getNumberOfRocs() / 2);
 
     geo.setTPCzLength(tpcZlengthSideA, tpcZlengthSideC);
     geo.setTPCalignmentZ(-mOrigTransform->GetDeltaZCorrTime());
 
     for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
-      int32_t slice = 0, sector = 0, secrow = 0;
-      AliHLTTPCGeometry::Slice2Sector(slice, row, sector, secrow);
+      int32_t roc = 0, sector = 0, secrow = 0;
+      AliHLTTPCGeometry::Slice2Sector(roc, row, sector, secrow);
       Int_t nPads = tpcParam->GetNPads(sector, secrow);
       float xRow = tpcParam->GetPadRowRadii(sector, secrow);
       float padWidth = tpcParam->GetInnerPadPitchWidth();
@@ -272,40 +272,40 @@ int32_t TPCFastTransformManager::updateCalibration(TPCFastTransform& fastTransfo
 
   recoParam->SetUseTOFCorrection(kFALSE);
 
-  for (int32_t slice = 0; slice < geo.getNumberOfSlices(); slice++) {
+  for (int32_t roc = 0; roc < geo.getNumberOfRocs(); roc++) {
 
     for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
 
       const TPCFastTransformGeo::RowInfo& rowInfo = geo.getRowInfo(row);
 
-      const TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSpline(slice, row);
-      float* data = correction.getSplineData(slice, row);
+      const TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSpline(roc, row);
+      float* data = correction.getSplineData(roc, row);
 
       Spline2DHelper<float> helper;
       helper.setSpline(spline, 4, 4);
       auto F = [&](double su, double sv, double dxuv[3]) {
         float x = rowInfo.x;
-        // x, u, v cordinates of the knot (local cartesian coord. of slice
+        // x, u, v cordinates of the knot (local cartesian coord. of roc
         // towards central electrode )
         float u = 0, v = 0;
-        geo.convScaledUVtoUV(slice, row, su, sv, u, v);
+        geo.convScaledUVtoUV(roc, row, su, sv, u, v);
 
         // row, pad, time coordinates of the knot
         float vertexTime = 0.f;
         float pad = 0.f, time = 0.f;
-        fastTransform.convUVtoPadTime(slice, row, u, v, pad, time, vertexTime);
+        fastTransform.convUVtoPadTime(roc, row, u, v, pad, time, vertexTime);
 
         // nominal x,y,z coordinates of the knot (without corrections and
         // time-of-flight correction)
         float y = 0, z = 0;
-        geo.convUVtoLocal(slice, u, v, y, z);
+        geo.convUVtoLocal(roc, u, v, y, z);
 
         // original TPC transformation (row,pad,time) -> (x,y,z) without
         // time-of-flight correction
         float ox = 0, oy = 0, oz = 0;
         {
           int32_t sector = 0, secrow = 0;
-          AliHLTTPCGeometry::Slice2Sector(slice, row, sector, secrow);
+          AliHLTTPCGeometry::Slice2Sector(roc, row, sector, secrow);
           int32_t is[] = {sector};
           double xx[] = {static_cast<double>(secrow), pad, time};
           mOrigTransform->Transform(xx, is, 0, 1);
@@ -315,7 +315,7 @@ int32_t TPCFastTransformManager::updateCalibration(TPCFastTransform& fastTransfo
         }
         // convert to u,v
         float ou = 0, ov = 0;
-        geo.convLocalToUV(slice, oy, oz, ou, ov);
+        geo.convLocalToUV(roc, oy, oz, ou, ov);
 
         // corrections in x,u,v:
         dxuv[0] = ox - x;
@@ -325,7 +325,7 @@ int32_t TPCFastTransformManager::updateCalibration(TPCFastTransform& fastTransfo
 
       helper.approximateFunction(data, 0., 1., 0., 1., F);
     } // row
-  } // slice
+  } // roc
 
   // set back the time-of-flight correction;
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index 4421d44aab0c8..7c1ae8fd56800 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -59,7 +59,7 @@
 #pragma link C++ class o2::gpu::IrregularSpline2D3DCalibrator + ;
 
 #pragma link C++ class o2::gpu::TPCFastTransformGeo + ;
-#pragma link C++ class o2::gpu::TPCFastTransformGeo::SliceInfo + ;
+#pragma link C++ class o2::gpu::TPCFastTransformGeo::RocInfo + ;
 #pragma link C++ class o2::gpu::TPCFastTransformGeo::RowInfo + ;
 
 #pragma link C++ class o2::gpu::TPCFastTransform + ;
@@ -68,9 +68,9 @@
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RowInfo + ;
 
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection + ;
-#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo + ;
+#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RocInfo + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RowActiveArea + ;
-#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SliceRowInfo + ;
+#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RocRowInfo + ;
 
 #pragma link C++ class o2::gpu::CorrectionMapsHelper + ;
 #pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
diff --git a/GPU/TPCFastTransformation/macro/generateTPCCorrectionNTuple.C b/GPU/TPCFastTransformation/macro/generateTPCCorrectionNTuple.C
index 67a0f09522f60..69b7909cda683 100644
--- a/GPU/TPCFastTransformation/macro/generateTPCCorrectionNTuple.C
+++ b/GPU/TPCFastTransformation/macro/generateTPCCorrectionNTuple.C
@@ -82,12 +82,12 @@ void generateTPCCorrectionNTuple(const char* path = "InputSCDensityHistograms.ro
   const o2::gpu::TPCFastTransformGeo& geo = fastTransform->getGeometry();
 
   TFile* f = new TFile("tpcCorrection.root", "RECREATE");
-  TNtuple* nt = new TNtuple("dist", "dist", "slice:row:su:sv:dx:du:dv");
+  TNtuple* nt = new TNtuple("dist", "dist", "sector:row:su:sv:dx:du:dv");
 
-  int32_t nSlices = 1; // fastTransform->getNumberOfSlices();
-  // for( int32_t slice=0; slice<nSlices; slice++){
-  for (int32_t slice = 0; slice < 1; slice++) {
-    const o2::gpu::TPCFastTransformGeo::SliceInfo& sliceInfo = geo.getSliceInfo(slice);
+  int32_t nSectors = 1; // fastTransform->getNumberOfSectors();
+  // for( int32_t sector=0; sector<nSectors; sector++){
+  for (int32_t sector = 0; sector < 1; sector++) {
+    const o2::gpu::TPCFastTransformGeo::SectorInfo& sectorInfo = geo.getSectorInfo(sector);
 
     for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
 
@@ -96,12 +96,12 @@ void generateTPCCorrectionNTuple(const char* path = "InputSCDensityHistograms.ro
       for (float su = 0.; su <= 1.; su += 0.01) {
         for (float sv = 0.; sv <= 1.; sv += 0.01) {
           float u, v, y = 0, z = 0;
-          geo.convScaledUVtoUV(slice, row, su, sv, u, v);
-          geo.convUVtoLocal(slice, u, v, y, z);
+          geo.convScaledUVtoUV(sector, row, su, sv, u, v);
+          geo.convUVtoLocal(sector, u, v, y, z);
 
           // local 2 global
           float gx, gy, gz;
-          geo.convLocalToGlobal(slice, x, y, z, gx, gy, gz);
+          geo.convLocalToGlobal(sector, x, y, z, gx, gy, gz);
 
           o2::tpc::GlobalPosition3D positionCorrected(gx, gy, gz);
           sc->correctElectron(positionCorrected);
@@ -111,15 +111,15 @@ void generateTPCCorrectionNTuple(const char* path = "InputSCDensityHistograms.ro
 
           // global to local
           float x1, y1, z1;
-          geo.convGlobalToLocal(slice, gx, gy, gz, x1, y1, z1);
+          geo.convGlobalToLocal(sector, gx, gy, gz, x1, y1, z1);
           float u1 = 0, v1 = 0;
-          geo.convLocalToUV(slice, y1, z1, u1, v1);
+          geo.convLocalToUV(sector, y1, z1, u1, v1);
 
           float dx = x1 - x;
           float du = u1 - u;
           float dv = v1 - v;
-          std::cout << slice << " " << row << " " << su << " " << sv << " " << dx << " " << du << " " << dv << std::endl;
-          nt->Fill(slice, row, su, sv, dx, du, dv);
+          std::cout << sector << " " << row << " " << su << " " << sv << " " << dx << " " << du << " " << dv << std::endl;
+          nt->Fill(sector, row, su, sv, dx, du, dv);
         }
       }
     }

From 45105a91fc28e811998b96ce64a6ebbe581b83f8 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Wed, 5 Feb 2025 16:19:23 +0000
Subject: [PATCH 1568/1764] TPC Splines: minimise the amount of transformations

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    |  20 +-
 .../src/TPCFastTransformHelperO2.cxx          |  25 +-
 .../test/testTPCFastTransform.cxx             |   6 +-
 .../TPCFastSpaceChargeCorrection.cxx          |  16 +-
 .../TPCFastSpaceChargeCorrection.h            |  52 ++-
 .../TPCFastTransform.cxx                      |  16 +-
 GPU/TPCFastTransformation/TPCFastTransform.h  | 413 +++++++-----------
 .../TPCFastTransformGeo.cxx                   |  71 +--
 .../TPCFastTransformGeo.h                     | 116 +----
 .../TPCFastTransformManager.cxx               |   1 +
 10 files changed, 262 insertions(+), 474 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index bac332a837c55..710a4356dd457 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -63,12 +63,8 @@ void TPCFastSpaceChargeCorrectionHelper::initGeometry()
   mGeo.startConstruction(nRows);
 
   auto& detParam = ParameterDetector::Instance();
-  float tpcZlengthSideA = detParam.TPClength;
-  float tpcZlengthSideC = detParam.TPClength;
 
-  mGeo.setTPCzLength(tpcZlengthSideA, tpcZlengthSideC);
-
-  mGeo.setTPCalignmentZ(0.);
+  mGeo.setTPCzLength(detParam.TPClength);
 
   for (int iRow = 0; iRow < mGeo.getNumberOfRows(); iRow++) {
     Sector sector = 0;
@@ -295,7 +291,7 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
       auto myThread = [&](int iThread) {
         for (int iRow = iThread; iRow < nRows; iRow += mNthreads) {
           const auto& info = mGeo.getRowInfo(iRow);
-          double vMax = mGeo.getTPCzLength(iRoc);
+          double vMax = mGeo.getTPCzLength();
           double dv = vMax / (6. * (nKnotsZ - 1));
 
           double dpad = info.maxPad / (6. * (nKnotsY - 1));
@@ -512,8 +508,8 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       double zMax = rowInfo.x * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
       double uMin = yMin;
       double uMax = yMax;
-      double vMin = geo.getTPCzLength(iRoc) - zMax;
-      double vMax = geo.getTPCzLength(iRoc) - zMin;
+      double vMin = geo.getTPCzLength() - zMax;
+      double vMax = geo.getTPCzLength() - zMin;
       info.gridU0 = uMin;
       info.scaleUtoGrid = spline.getGridX1().getUmax() / (uMax - uMin);
       info.gridV0 = vMin;
@@ -822,7 +818,7 @@ void TPCFastSpaceChargeCorrectionHelper::initMaxDriftLength(o2::gpu::TPCFastSpac
     if (prn) {
       LOG(info) << "init MaxDriftLength for roc " << roc;
     }
-    double vLength = (roc < mGeo.getNumberOfRocsA()) ? mGeo.getTPCzLengthA() : mGeo.getTPCzLengthC();
+    double vLength = mGeo.getTPCzLength();
     TPCFastSpaceChargeCorrection::RocInfo& rocInfo = correction.getRocInfo(roc);
     rocInfo.vMax = 0.f;
 
@@ -843,7 +839,7 @@ void TPCFastSpaceChargeCorrectionHelper::initMaxDriftLength(o2::gpu::TPCFastSpac
         while (v1 - v0 > 0.1) {
           float v = 0.5 * (v0 + v1);
           float dx, du, dv;
-          correction.getCorrection(roc, row, u, v, dx, du, dv);
+          correction.getCorrectionInternal(roc, row, u, v, dx, du, dv);
           double cx = x + dx;
           double cu = u + du;
           double cv = v + dv;
@@ -962,14 +958,14 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
             correction.convGridToUV(roc, row, gridU[iu], gridV[iv], u, v);
 
             float dx, du, dv;
-            correction.getCorrection(roc, row, u, v, dx, du, dv);
+            correction.getCorrectionInternal(roc, row, u, v, dx, du, dv);
             dx *= scaling[0];
             du *= scaling[0];
             dv *= scaling[0];
             // add remaining corrections
             for (int i = 1; i < corrections.size(); ++i) {
               float dxTmp, duTmp, dvTmp;
-              corrections[i]->getCorrection(roc, row, u, v, dxTmp, duTmp, dvTmp);
+              corrections[i]->getCorrectionInternal(roc, row, u, v, dxTmp, duTmp, dvTmp);
               dx += dxTmp * scaling[i];
               du += duTmp * scaling[i];
               dv += dvTmp * scaling[i];
diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index cfa54a12f9f42..c83ee6d0cfa19 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -56,12 +56,7 @@ void TPCFastTransformHelperO2::init()
   mGeo.startConstruction(nRows);
 
   auto& detParam = ParameterDetector::Instance();
-  float tpcZlengthSideA = detParam.TPClength;
-  float tpcZlengthSideC = detParam.TPClength;
-
-  mGeo.setTPCzLength(tpcZlengthSideA, tpcZlengthSideC);
-
-  mGeo.setTPCalignmentZ(0.);
+  mGeo.setTPCzLength(detParam.TPClength);
 
   for (int iRow = 0; iRow < mGeo.getNumberOfRows(); iRow++) {
     Sector sector = 0;
@@ -114,12 +109,8 @@ std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(Long_t TimeSt
     // set some initial calibration values, will be reinitialised later int updateCalibration()
     const float t0 = 0.;
     const float vDrift = 0.f;
-    const float vdCorrY = 0.;
-    const float ldCorr = 0.;
-    const float tofCorr = 0.;
-    const float primVtxZ = 0.;
     const long int initTimeStamp = -1;
-    fastTransform.setCalibration(initTimeStamp, t0, vDrift, vdCorrY, ldCorr, tofCorr, primVtxZ);
+    fastTransform.setCalibration1(initTimeStamp, t0, vDrift);
 
     fastTransform.finishConstruction();
   }
@@ -171,19 +162,13 @@ int TPCFastTransformHelperO2::updateCalibration(TPCFastTransform& fastTransform,
   const double vDrift = elParam.ZbinWidth * vDriftRef * vDriftFactor; // cm/timebin
 
   // fast transform formula:
-  // L = (t-t0)*(mVdrift + mVdriftCorrY*yLab ) + mLdriftCorr
-  // Z = Z(L) +  tpcAlignmentZ
+  // L = (t-t0)*mVdrift
+  // Z = Z(L)
   // spline corrections for xyz
-  // Time-of-flight correction: ldrift += dist-to-vtx*tofCorr
 
   const double t0 = (driftTimeOffset + elParam.getAverageShapingTime()) / elParam.ZbinWidth;
 
-  const double vdCorrY = 0.;
-  const double ldCorr = 0.;
-  const double tofCorr = 0.;
-  const double primVtxZ = 0.;
-
-  fastTransform.setCalibration(TimeStamp, t0, vDrift, vdCorrY, ldCorr, tofCorr, primVtxZ);
+  fastTransform.setCalibration1(TimeStamp, t0, vDrift);
 
   return 0;
 }
diff --git a/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx b/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
index 0141b80819b64..53cfe08f3a7f4 100644
--- a/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
+++ b/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
@@ -72,7 +72,7 @@ BOOST_AUTO_TEST_CASE(FastTransform_test1)
       const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
       const PadCentre& c = mapper.padCentre(p);
       float u = 0, v = 0;
-      fastTransform.convPadTimeToUV(0, row, pad, 0, u, v, 0.);
+      fastTransform.convPadTimeToUV(row, pad, 0, u, v, 0.);
 
       double dx = x - c.X();
       double dy = u - (-c.Y()); // diferent sign convention for Y coordinate in the map
@@ -192,8 +192,8 @@ BOOST_AUTO_TEST_CASE(FastTransform_test_setSpaceChargeCorrection)
           correctionUV(roc, row, u0, v0, dx, du, dv);
           statDiff += fabs((x1 - x0) - dx) + fabs((u1 - u0) - du) + fabs((v1 - v0) - dv);
           statN += 3;
-          //std::cout << (x1 - x0) - dx << " " << (u1 - u0) - du << " " << (v1 - v0) - dv << std::endl; //": v0 " << v0 <<" z0 "<<z0<<" v1 "<< v1<<" z1 "<<z1 << std::endl;
-          //BOOST_CHECK_MESSAGE(0, "SG");
+          // std::cout << (x1 - x0) - dx << " " << (u1 - u0) - du << " " << (v1 - v0) - dv << std::endl; //": v0 " << v0 <<" z0 "<<z0<<" v1 "<< v1<<" z1 "<<z1 << std::endl;
+          // BOOST_CHECK_MESSAGE(0, "SG");
 
           float x1f, y1f, z1f;
           fromFile->Transform(roc, row, pad, time, x1f, y1f, z1f);
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 5d3c186a06d42..111e70072c58e 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -225,7 +225,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
         info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
 
         info.gridV0 = infoOld.gridV0;
-        info.scaleVtoGrid = spline.getGridX2().getUmax() / (mGeo.getTPCzLength(roc) + 3. - info.gridV0);
+        info.scaleVtoGrid = spline.getGridX2().getUmax() / (mGeo.getTPCzLength() + 3. - info.gridV0);
 
         info.gridCorrU0 = infoOld.gridCorrU0;
         info.scaleCorrUtoGrid = infoOld.scaleCorrUtoGrid;
@@ -440,7 +440,7 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
 {
   // initialise all corrections to 0.
   for (int32_t roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
-    double vLength = (roc < mGeo.getNumberOfRocsA()) ? mGeo.getTPCzLengthA() : mGeo.getTPCzLengthC();
+    double vLength = mGeo.getTPCzLength();
     RocInfo& rocInfo = getRocInfo(roc);
     rocInfo.vMax = vLength;
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
@@ -548,12 +548,14 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
     if (prn) {
       LOG(info) << "check inverse transform for roc " << roc;
     }
-    double vLength = mGeo.getTPCzLength(roc);
+    double vLength = mGeo.getTPCzLength();
     MaxValue maxDroc[3];
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
-      float u0, u1, v0, v1;
-      mGeo.convScaledUVtoUV(roc, row, 0., 0., u0, v0);
-      mGeo.convScaledUVtoUV(roc, row, 1., 1., u1, v1);
+      float u0 = mGeo.getRowInfo(row).getUmin();
+      float u1 = mGeo.getRowInfo(row).getUmax();
+      float v0 = 0.;
+      float v1 = vLength;
+
       double x = mGeo.getRowInfo(row).x;
       double stepU = (u1 - u0) / 100.;
       double stepV = (v1 - v0) / 100.;
@@ -564,7 +566,7 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
             continue;
           }
           float dx, du, dv;
-          getCorrection(roc, row, u, v, dx, du, dv);
+          getCorrectionInternal(roc, row, u, v, dx, du, dv);
           double cx = x + dx;
           double cu = u + du;
           double cv = v + dv;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index b6244bfee1e0f..fa5cf7a1736bd 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -180,7 +180,9 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   /// _______________ The main method: cluster correction  _______________________
   ///
-  GPUd() int32_t getCorrection(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
+  GPUd() int32_t getCorrectionInternal(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
+
+  GPUdi() std::tuple<float, float, float> getCorrectionLocal(int32_t roc, int32_t row, float y, float z) const;
 
   /// inverse correction: Corrected U and V -> coorrected X
   GPUd() void getCorrectionInvCorrectedX(int32_t roc, int32_t row, float corrU, float corrV, float& corrX) const;
@@ -199,6 +201,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   /// _______________  Utilities  _______________________________________________
 
+  /// convert local y, z to internal grid coordinates u,v
+  /// return values: u, v, scaling factor
+  GPUd() std::tuple<float, float, float> convLocalToGrid(int32_t roc, int32_t row, float y, float z) const;
+
   /// convert u,v to internal grid coordinates
   GPUd() void convUVtoGrid(int32_t roc, int32_t row, float u, float v, float& gridU, float& gridV) const;
 
@@ -259,9 +265,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// release temporary memory used during construction
   void releaseConstructionMemory();
 
-  /// temporary method with the an way of calculating 2D spline
-  GPUd() int32_t getCorrectionOld(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
-
   /// _______________  Data members  _______________________________________________
 
   /// _______________  Construction control  _______________________________________________
@@ -354,7 +357,7 @@ GPUdi() void TPCFastSpaceChargeCorrection::convCorrectedUVtoGrid(int32_t roc, in
   gridV = (corrV - info.gridCorrV0) * info.scaleCorrVtoGrid;
 }
 
-GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrection(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const
+GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionInternal(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const
 {
   const auto& info = getRocRowInfo(roc, row);
   const SplineType& spline = getSpline(roc, row);
@@ -382,26 +385,41 @@ GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrection(int32_t roc, int32_t
   return 0;
 }
 
-GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionOld(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const
+GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t roc, int32_t row, float y, float z) const
 {
+  const auto& info = getRocRowInfo(roc, row);
   const SplineType& spline = getSpline(roc, row);
   const float* splineData = getSplineData(roc, row);
+
+  float u, v;
+
+  mGeo.convLocalToUV(roc, y, z, u, v);
+
   float gridU = 0, gridV = 0;
   convUVtoGrid(roc, row, u, v, gridU, gridV);
+  // shrink to the grid area
+  gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
+  gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
+
   float dxuv[3];
-  spline.interpolateUold(splineData, gridU, gridV, dxuv);
-  const auto& info = getRocRowInfo(roc, row);
+  spline.interpolateU(splineData, gridU, gridV, dxuv);
+
   float s = v / info.gridV0;
-  if (s < 0.) {
-    s = 0.;
-  }
-  if (s > 1.) {
-    s = 1.;
+
+  if (v >= info.gridV0) {
+    s = 1.f;
+  } else if (v <= 0.f) {
+    s = 0.f;
   }
-  dx = GPUCommonMath::Max(info.minCorr[0], GPUCommonMath::Min(info.maxCorr[0], s * dxuv[0]));
-  du = GPUCommonMath::Max(info.minCorr[1], GPUCommonMath::Min(info.maxCorr[1], s * dxuv[1]));
-  dv = GPUCommonMath::Max(info.minCorr[2], GPUCommonMath::Min(info.maxCorr[2], s * dxuv[2]));
-  return 0;
+
+  float dx = GPUCommonMath::Clamp(s * dxuv[0], info.minCorr[0], info.maxCorr[0]);
+  float du = GPUCommonMath::Clamp(s * dxuv[1], info.minCorr[1], info.maxCorr[1]);
+  float dv = GPUCommonMath::Clamp(s * dxuv[2], info.minCorr[2], info.maxCorr[2]);
+
+  float dy, dz;
+  mGeo.convUVtoLocal(roc, du, dv, dy, dz);
+
+  return {dx, dy, dz};
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvCorrectedX(
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.cxx b/GPU/TPCFastTransformation/TPCFastTransform.cxx
index bd29a760615ad..625f70c1710a1 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransform.cxx
@@ -37,7 +37,7 @@
 using namespace o2::gpu;
 
 TPCFastTransform::TPCFastTransform()
-  : FlatObject(), mTimeStamp(0), mCorrection(), mApplyCorrection(1), mT0(0.f), mVdrift(0.f), mVdriftCorrY(0.f), mLdriftCorr(0.f), mTOFcorr(0.f), mPrimVtxZ(0.f), mLumi(TPCFastTransform::DEFLUMI), mLumiError(0.f), mLumiScaleFactor(1.0f), mIDC(TPCFastTransform::DEFIDC), mIDCError(0.f), mCTP2IDCFallBackThreshold(30.f)
+  : FlatObject(), mTimeStamp(0), mCorrection(), mApplyCorrection(1), mT0(0.f), mVdrift(0.f), mLumi(TPCFastTransform::DEFLUMI), mLumiError(0.f), mLumiScaleFactor(1.0f), mIDC(TPCFastTransform::DEFIDC), mIDCError(0.f), mCTP2IDCFallBackThreshold(30.f)
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -54,10 +54,6 @@ void TPCFastTransform::cloneFromObject(const TPCFastTransform& obj, char* newFla
   mApplyCorrection = obj.mApplyCorrection;
   mT0 = obj.mT0;
   mVdrift = obj.mVdrift;
-  mVdriftCorrY = obj.mVdriftCorrY;
-  mLdriftCorr = obj.mLdriftCorr;
-  mTOFcorr = obj.mTOFcorr;
-  mPrimVtxZ = obj.mPrimVtxZ;
   mLumi = obj.mLumi;
   mLumiError = obj.mLumiError;
   mIDC = obj.mIDC;
@@ -123,7 +119,7 @@ void TPCFastTransform::startConstruction(const TPCFastSpaceChargeCorrection& cor
   mCorrection.cloneFromObject(correction, nullptr);
 }
 
-void TPCFastTransform::setCalibration(int64_t timeStamp, float t0, float vDrift, float vDriftCorrY, float lDriftCorr, float tofCorr, float primVtxZ)
+void TPCFastTransform::setCalibration1(int64_t timeStamp, float t0, float vDrift)
 {
   /// Sets all drift calibration parameters and the time stamp
   ///
@@ -133,10 +129,6 @@ void TPCFastTransform::setCalibration(int64_t timeStamp, float t0, float vDrift,
   mTimeStamp = timeStamp;
   mT0 = t0;
   mVdrift = vDrift;
-  mVdriftCorrY = vDriftCorrY;
-  mLdriftCorr = lDriftCorr;
-  mTOFcorr = tofCorr;
-  mPrimVtxZ = primVtxZ;
   mConstructionMask |= ConstructionExtraState::CalibrationIsSet;
 }
 
@@ -160,10 +152,6 @@ void TPCFastTransform::print() const
   LOG(info) << "mApplyCorrection = " << mApplyCorrection;
   LOG(info) << "mT0 = " << mT0;
   LOG(info) << "mVdrift = " << mVdrift;
-  LOG(info) << "mVdriftCorrY = " << mVdriftCorrY;
-  LOG(info) << "mLdriftCorr = " << mLdriftCorr;
-  LOG(info) << "mTOFcorr = " << mTOFcorr;
-  LOG(info) << "mPrimVtxZ = " << mPrimVtxZ;
   LOG(info) << "mLumi = " << mLumi;
   LOG(info) << "mLumiError = " << mLumiError;
   LOG(info) << "mIDC = " << mIDC;
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 8aef1748ebf62..1ecd577eb7dac 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -159,7 +159,7 @@ class TPCFastTransform : public FlatObject
   ///
   /// It must be called once during construction,
   /// but also may be called afterwards to reset these parameters.
-  void setCalibration(int64_t timeStamp, float t0, float vDrift, float vDriftCorrY, float lDriftCorr, float tofCorr, float primVtxZ);
+  void setCalibration1(int64_t timeStamp, float t0, float vDrift);
 
   /// Set Lumi info
   void setLumi(float l) { mLumi = l; }
@@ -183,7 +183,7 @@ class TPCFastTransform : public FlatObject
   /// _______________ The main method: cluster transformation _______________________
   ///
   /// Transforms raw TPC coordinates to local XYZ withing a roc
-  /// taking calibration + alignment into account.
+  /// taking calibration into account.
   ///
   GPUd() void Transform(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
   GPUd() void TransformXYZ(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
@@ -209,12 +209,12 @@ class TPCFastTransform : public FlatObject
   GPUd() void TransformIdeal(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;
   GPUd() void TransformIdealZ(int32_t roc, float time, float& z, float vertexTime) const;
 
-  GPUd() void convPadTimeToUV(int32_t roc, int32_t row, float pad, float time, float& u, float& v, float vertexTime) const;
-  GPUd() void convPadTimeToUVinTimeFrame(int32_t roc, int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const;
-  GPUd() void convTimeToVinTimeFrame(int32_t roc, float time, float& v, float maxTimeBin) const;
+  GPUd() void convPadTimeToUV(int32_t row, float pad, float time, float& u, float& v, float vertexTime) const;
+  GPUd() void convPadTimeToUVinTimeFrame(int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const;
+  GPUd() void convTimeToVinTimeFrame(float time, float& v, float maxTimeBin) const;
 
-  GPUd() void convUVtoPadTime(int32_t roc, int32_t row, float u, float v, float& pad, float& time, float vertexTime) const;
-  GPUd() void convUVtoPadTimeInTimeFrame(int32_t roc, int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const;
+  GPUd() void convUVtoPadTime(int32_t row, float u, float v, float& pad, float& time, float vertexTime) const;
+  GPUd() void convUVtoPadTimeInTimeFrame(int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const;
   GPUd() void convVtoTime(float v, float& time, float vertexTime) const;
 
   GPUd() float convTimeToZinTimeFrame(int32_t roc, float time, float maxTimeBin) const;
@@ -222,10 +222,8 @@ class TPCFastTransform : public FlatObject
   GPUd() float convDeltaTimeToDeltaZinTimeFrame(int32_t roc, float deltaTime) const;
   GPUd() float convDeltaZtoDeltaTimeInTimeFrame(int32_t roc, float deltaZ) const;
   GPUd() float convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const;
-  GPUd() float convZOffsetToVertexTime(int32_t roc, float zOffset, float maxTimeBin) const;
-  GPUd() float convVertexTimeToZOffset(int32_t roc, float vertexTime, float maxTimeBin) const;
-
-  GPUd() void getTOFcorrection(int32_t roc, int32_t row, float x, float y, float z, float& dz) const;
+  GPUd() float convZOffsetToVertexTime(int32_t sector, float zOffset, float maxTimeBin) const;
+  GPUd() float convVertexTimeToZOffset(int32_t sector, float vertexTime, float maxTimeBin) const;
 
   void setApplyCorrectionOn() { mApplyCorrection = 1; }
   void setApplyCorrectionOff() { mApplyCorrection = 0; }
@@ -245,15 +243,6 @@ class TPCFastTransform : public FlatObject
   /// Return T0 in time bin units
   GPUd() float getT0() const { return mT0; }
 
-  /// Return VdriftCorrY in time_bin / cn
-  GPUd() float getVdriftCorrY() const { return mVdriftCorrY; }
-
-  /// Return LdriftCorr offset in cm
-  GPUd() float getLdriftCorr() const { return mLdriftCorr; }
-
-  /// Return TOF correction (vdrift / C)
-  GPUd() float getTOFCorr() const { return mLdriftCorr; }
-
   /// Return map lumi
   GPUd() float getLumi() const { return mLumi; }
 
@@ -330,23 +319,10 @@ class TPCFastTransform : public FlatObject
   ///
   /// t = (float) time bin, y = global y
   ///
-  /// L(t,y) = (t-mT0)*(mVdrift + mVdriftCorrY*y ) + mLdriftCorr  ____
+  /// L(t,y) = (t-mT0)*mVdrift  ____
   ///
-  float mT0;          ///< T0 in [time bin]
-  float mVdrift;      ///< VDrift in  [cm/time bin]
-  float mVdriftCorrY; ///< VDrift correction for global Y[cm] in [1/time bin]
-  float mLdriftCorr;  ///< drift length correction in [cm]
-
-  /// A coefficient for Time-Of-Flight correction: drift length -= EstimatedDistanceToVtx[cm]*mTOFcorr
-  ///
-  /// Since this correction requires a knowledge of the spatial position, it is appied after mCorrection,
-  /// not on the drift length but directly on V coordinate.
-  ///
-  /// mTOFcorr == mVdrift/(speed of light)
-  ///
-  float mTOFcorr;
-
-  float mPrimVtxZ; ///< Z of the primary vertex, needed for the Time-Of-Flight correction
+  float mT0;     ///< T0 in [time bin]
+  float mVdrift; ///< VDrift in  [cm/time bin]
 
   float mLumi;            ///< luminosity estimator
   float mLumiError;       ///< error on luminosity
@@ -359,7 +335,7 @@ class TPCFastTransform : public FlatObject
   /// Correction of (x,u,v) with tricubic interpolator on a regular grid
   TPCSlowSpaceChargeCorrection* mCorrectionSlow{nullptr}; ///< reference space charge corrections
 
-  GPUd() void TransformInternal(int32_t roc, int32_t row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const;
+  GPUd() void TransformLocal(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const;
 
   ClassDefNV(TPCFastTransform, 4);
 };
@@ -368,248 +344,195 @@ class TPCFastTransform : public FlatObject
 //              Inline implementations of some methods
 // =======================================================================
 
-GPUdi() void TPCFastTransform::convPadTimeToUV(int32_t roc, int32_t row, float pad, float time, float& u, float& v, float vertexTime) const
+GPUdi() void TPCFastTransform::convPadTimeToUV(int32_t row, float pad, float time, float& u, float& v, float vertexTime) const
 {
-  bool sideC = (roc >= getGeometry().getNumberOfRocsA());
-
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  const TPCFastTransformGeo::RocInfo& rocInfo = getGeometry().getRocInfo(roc);
-
   float x = rowInfo.x;
   u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-
-  float y = sideC ? -u : u; // pads are mirrorred on C-side
-  float yLab = y * rocInfo.cosAlpha + x * rocInfo.sinAlpha;
-
-  v = (time - mT0 - vertexTime) * (mVdrift + mVdriftCorrY * yLab) + mLdriftCorr; // drift length cm
+  v = (time - mT0 - vertexTime) * (mVdrift); // drift length cm
 }
 
-GPUdi() void TPCFastTransform::convTimeToVinTimeFrame(int32_t roc, float time, float& v, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convTimeToVinTimeFrame(float time, float& v, float maxTimeBin) const
 {
-  v = (time - mT0 - maxTimeBin) * mVdrift + mLdriftCorr; // drift length cm
-  if (roc < getGeometry().getNumberOfRocsA()) {
-    v += getGeometry().getTPCzLengthA();
-  } else {
-    v += getGeometry().getTPCzLengthC();
-  }
+  v = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
+  v += getGeometry().getTPCzLength();
 }
 
-GPUdi() void TPCFastTransform::convPadTimeToUVinTimeFrame(int32_t roc, int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convPadTimeToUVinTimeFrame(int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const
 {
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
   u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-  convTimeToVinTimeFrame(roc, time, v, maxTimeBin);
+  convTimeToVinTimeFrame(time, v, maxTimeBin);
 }
 
-GPUdi() float TPCFastTransform::convZOffsetToVertexTime(int32_t roc, float zOffset, float maxTimeBin) const
+GPUdi() float TPCFastTransform::convZOffsetToVertexTime(int32_t sector, float zOffset, float maxTimeBin) const
 {
-  if (roc < getGeometry().getNumberOfRocsA()) {
-    return maxTimeBin - (getGeometry().getTPCzLengthA() + zOffset) / mVdrift;
+  if (sector < getGeometry().getNumberOfSectorsA()) {
+    return maxTimeBin - (getGeometry().getTPCzLength() + zOffset) / mVdrift;
   } else {
-    return maxTimeBin - (getGeometry().getTPCzLengthC() - zOffset) / mVdrift;
+    return maxTimeBin - (getGeometry().getTPCzLength() - zOffset) / mVdrift;
   }
 }
 
-GPUdi() float TPCFastTransform::convVertexTimeToZOffset(int32_t roc, float vertexTime, float maxTimeBin) const
+GPUdi() float TPCFastTransform::convVertexTimeToZOffset(int32_t sector, float vertexTime, float maxTimeBin) const
 {
-  if (roc < getGeometry().getNumberOfRocsA()) {
-    return (maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLengthA();
+  if (sector < getGeometry().getNumberOfSectorsA()) {
+    return (maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLength();
   } else {
-    return -((maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLengthC());
+    return -((maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLength());
   }
 }
 
-GPUdi() void TPCFastTransform::convUVtoPadTime(int32_t roc, int32_t row, float u, float v, float& pad, float& time, float vertexTime) const
+GPUdi() void TPCFastTransform::convUVtoPadTime(int32_t row, float u, float v, float& pad, float& time, float vertexTime) const
 {
-  bool sideC = (roc >= getGeometry().getNumberOfRocsA());
-
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  const TPCFastTransformGeo::RocInfo& rocInfo = getGeometry().getRocInfo(roc);
-
   pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
-
-  float x = rowInfo.x;
-  float y = sideC ? -u : u; // pads are mirrorred on C-side
-  float yLab = y * rocInfo.cosAlpha + x * rocInfo.sinAlpha;
-  time = mT0 + vertexTime + (v - mLdriftCorr) / (mVdrift + mVdriftCorrY * yLab);
+  time = mT0 + vertexTime + v / mVdrift;
 }
 
 GPUdi() void TPCFastTransform::convVtoTime(float v, float& time, float vertexTime) const
 {
-  float yLab = 0.f;
-  time = mT0 + vertexTime + (v - mLdriftCorr) / (mVdrift + mVdriftCorrY * yLab);
+  time = mT0 + vertexTime + v / mVdrift;
 }
 
-GPUdi() void TPCFastTransform::convUVtoPadTimeInTimeFrame(int32_t roc, int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convUVtoPadTimeInTimeFrame(int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const
 {
-  if (roc < getGeometry().getNumberOfRocsA()) {
-    v -= getGeometry().getTPCzLengthA();
-  } else {
-    v -= getGeometry().getTPCzLengthC();
-  }
+  v -= getGeometry().getTPCzLength();
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
   pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
-  time = mT0 + maxTimeBin + (v - mLdriftCorr) / mVdrift;
+  time = mT0 + maxTimeBin + v / mVdrift;
 }
 
-GPUdi() void TPCFastTransform::getTOFcorrection(int32_t roc, int32_t /*row*/, float x, float y, float z, float& dz) const
+GPUdi() void TPCFastTransform::TransformLocal(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
-  // calculate time of flight correction for  z coordinate
+  GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
 
-  bool sideC = (roc >= getGeometry().getNumberOfRocsA());
-  float distZ = z - mPrimVtxZ;
-  float dv = -GPUCommonMath::Sqrt(x * x + y * y + distZ * distZ) * mTOFcorr;
-  dz = sideC ? dv : -dv;
-}
+  if (!mApplyCorrection) {
+    return;
+  }
 
-GPUdi() void TPCFastTransform::TransformInternal(int32_t roc, int32_t row, float& u, float& v, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
-{
-  GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
-  if (mApplyCorrection) {
-    float dx = 0.f, du = 0.f, dv = 0.f;
-    if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
+  float dx = 0.f, dy = 0.f, dz = 0.f;
+
+  if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
 #ifndef GPUCA_GPUCODE
-      if (mCorrectionSlow) {
-        float ly, lz;
-        getGeometry().convUVtoLocal(roc, u, v, ly, lz);
-        float gx, gy, gz;
-        getGeometry().convLocalToGlobal(roc, x, ly, lz, gx, gy, gz);
-
-        float gdxC, gdyC, gdzC;
-        mCorrectionSlow->getCorrections(gx, gy, gz, roc, gdxC, gdyC, gdzC);
-        getGeometry().convGlobalToLocal(roc, gdxC, gdyC, gdzC, dx, du, dv);
-
-        if (roc >= 18) {
-          du = -du; // mirror for c-Side
-        } else {
-          dv = -dv; // mirror z for A-Side
-        }
-      } else
+    if (mCorrectionSlow) {
+      float gx, gy, gz;
+      getGeometry().convLocalToGlobal(roc, x, y, z, gx, gy, gz);
+      float gdxC, gdyC, gdzC;
+      mCorrectionSlow->getCorrections(gx, gy, gz, roc, gdxC, gdyC, gdzC);
+      getGeometry().convGlobalToLocal(roc, gdxC, gdyC, gdzC, dx, dy, dz);
+    } else
 #endif // GPUCA_GPUCODE
-      {
-        mCorrection.getCorrection(roc, row, u, v, dx, du, dv);
-        if (ref) {
-          if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
-            float dxRef, duRef, dvRef;
-            ref->mCorrection.getCorrection(roc, row, u, v, dxRef, duRef, dvRef);
-            dx = (dx - dxRef) * scale + dxRef;
-            du = (du - duRef) * scale + duRef;
-            dv = (dv - dvRef) * scale + dvRef;
-          } else if ((scale != 0.f) && ((scaleMode == 1) || (scaleMode == 2))) {
-            float dxRef, duRef, dvRef;
-            ref->mCorrection.getCorrection(roc, row, u, v, dxRef, duRef, dvRef);
-            dx = dxRef * scale + dx;
-            du = duRef * scale + du;
-            dv = dvRef * scale + dv;
-          }
-        }
-        if (ref2 && (scale2 != 0)) {
-          float dxRef, duRef, dvRef;
-          ref2->mCorrection.getCorrection(roc, row, u, v, dxRef, duRef, dvRef);
-          dx = dxRef * scale2 + dx;
-          du = duRef * scale2 + du;
-          dv = dvRef * scale2 + dv;
+    {
+      std::tie(dx, dy, dz) = mCorrection.getCorrectionLocal(roc, row, y, z);
+      if (ref) {
+        if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
+          auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(roc, row, y, z);
+          dx = (dx - dxRef) * scale + dxRef;
+          dy = (dy - dyRef) * scale + dyRef;
+          dz = (dz - dzRef) * scale + dzRef;
+        } else if ((scale != 0.f) && ((scaleMode == 1) || (scaleMode == 2))) {
+          auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(roc, row, y, z);
+          dx = dxRef * scale + dx;
+          dy = dyRef * scale + dy;
+          dz = dzRef * scale + dz;
         }
       }
+      if (ref2 && (scale2 != 0)) {
+        auto [dxRef, dyRef, dzRef] = ref2->mCorrection.getCorrectionLocal(roc, row, y, z);
+        dx = dxRef * scale2 + dx;
+        dy = dyRef * scale2 + dy;
+        dz = dzRef * scale2 + dz;
+      }
     }
-    GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
-      float ly, lz;
-      getGeometry().convUVtoLocal(roc, u, v, ly, lz);
+  }
 
-      float gx, gy, gz;
-      getGeometry().convLocalToGlobal(roc, x, ly, lz, gx, gy, gz);
+  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
+    float lx = x, ly = y, lz = z;
 
-      float lyT, lzT;
-      float uCorr = u + du;
-      float vCorr = v + dv;
-      float lxT = x + dx;
-      getGeometry().convUVtoLocal(roc, uCorr, vCorr, lyT, lzT);
+    float gx, gy, gz;
+    getGeometry().convLocalToGlobal(roc, lx, ly, lz, gx, gy, gz);
 
-      float invYZtoXScaled;
-      InverseTransformYZtoX(roc, row, lyT, lzT, invYZtoXScaled, ref, ref2, scale, scale2, scaleMode);
+    float lxT = lx + dx;
+    float lyT = ly + dy;
+    float lzT = lz + dz;
 
-      float invYZtoX;
-      InverseTransformYZtoX(roc, row, lyT, lzT, invYZtoX);
+    float invYZtoXScaled;
+    InverseTransformYZtoX(roc, row, lyT, lzT, invYZtoXScaled, ref, ref2, scale, scale2, scaleMode);
 
-      float YZtoNominalY;
-      float YZtoNominalZ;
-      InverseTransformYZtoNominalYZ(roc, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
+    float invYZtoX;
+    InverseTransformYZtoX(roc, row, lyT, lzT, invYZtoX);
 
-      float YZtoNominalYScaled;
-      float YZtoNominalZScaled;
-      InverseTransformYZtoNominalYZ(roc, row, lyT, lzT, YZtoNominalYScaled, YZtoNominalZScaled, ref, ref2, scale, scale2, scaleMode);
+    float YZtoNominalY;
+    float YZtoNominalZ;
+    InverseTransformYZtoNominalYZ(roc, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
 
-      float dxRef, duRef, dvRef;
-      if (ref) {
-        ref->mCorrection.getCorrection(roc, row, u, v, dxRef, duRef, dvRef);
-      }
+    float YZtoNominalYScaled;
+    float YZtoNominalZScaled;
+    InverseTransformYZtoNominalYZ(roc, row, lyT, lzT, YZtoNominalYScaled, YZtoNominalZScaled, ref, ref2, scale, scale2, scaleMode);
 
-      float dxRef2, duRef2, dvRef2;
-      if (ref2) {
-        ref2->mCorrection.getCorrection(roc, row, u, v, dxRef2, duRef2, dvRef2);
-      }
+    float dxRef = 0.f, dyRef = 0.f, dzRef = 0.f;
+    if (ref) {
+      std::tie(dxRef, dyRef, dzRef) = ref->mCorrection.getCorrectionLocal(roc, row, y, z);
+    }
 
-      float dxOrig, duOrig, dvOrig;
-      mCorrection.getCorrection(roc, row, u, v, dxOrig, duOrig, dvOrig);
-
-      o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
-                                                                                         // corrections in x, u, v
-                                                                                         << "dxOrig=" << dxOrig
-                                                                                         << "duOrig=" << duOrig
-                                                                                         << "dvOrig=" << dvOrig
-                                                                                         << "dxRef=" << dxRef
-                                                                                         << "duRef=" << duRef
-                                                                                         << "dvRef=" << dvRef
-                                                                                         << "dxRef2=" << dxRef2
-                                                                                         << "duRef2=" << duRef2
-                                                                                         << "dvRef2=" << dvRef2
-                                                                                         << "dx=" << dx
-                                                                                         << "du=" << du
-                                                                                         << "dv=" << dv
-                                                                                         << "v=" << v
-                                                                                         << "u=" << u
-                                                                                         << "row=" << row
-                                                                                         << "roc=" << roc
-                                                                                         << "scale=" << scale
-                                                                                         << "scale2=" << scale2
-                                                                                         // original local coordinates
-                                                                                         << "ly=" << ly
-                                                                                         << "lz=" << lz
-                                                                                         << "lx=" << x
-                                                                                         // corrected local coordinated
-                                                                                         << "lxT=" << lxT
-                                                                                         << "lyT=" << lyT
-                                                                                         << "lzT=" << lzT
-                                                                                         // global uncorrected coordinates
-                                                                                         << "gx=" << gx
-                                                                                         << "gy=" << gy
-                                                                                         << "gz=" << gz
-                                                                                         // some transformations which are applied
-                                                                                         << "invYZtoX=" << invYZtoX
-                                                                                         << "invYZtoXScaled=" << invYZtoXScaled
-                                                                                         << "YZtoNominalY=" << YZtoNominalY
-                                                                                         << "YZtoNominalYScaled=" << YZtoNominalYScaled
-                                                                                         << "YZtoNominalZ=" << YZtoNominalZ
-                                                                                         << "YZtoNominalZScaled=" << YZtoNominalZScaled
-                                                                                         << "scaleMode=" << scaleMode
-                                                                                         << "\n";
-    })
-
-    x += dx;
-    u += du;
-    v += dv;
-  }
+    float dxRef2 = 0.f, duRef2 = 0.f, dvRef2 = 0.f;
+    if (ref2) {
+      std::tie(dxRef2, duRef2, dvRef2) = ref2->mCorrection.getCorrectionLocal(roc, row, y, z);
+    }
+
+    auto [dxOrig, dyOrig, dzOrig] = mCorrection.getCorrectionLocal(roc, row, y, z);
+
+    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
+                                                                                       // corrections in x, u, v
+                                                                                       << "dxOrig=" << dxOrig
+                                                                                       << "dyOrig=" << dyOrig
+                                                                                       << "dzOrig=" << dzOrig
+                                                                                       << "dxRef=" << dxRef
+                                                                                       << "dyRef=" << dyRef
+                                                                                       << "dzRef=" << dzRef
+                                                                                       << "dxRef2=" << dxRef2
+                                                                                       << "dyRef2=" << dyRef2
+                                                                                       << "dzRef2=" << dzRef2
+                                                                                       << "dx=" << dx
+                                                                                       << "dy=" << dy
+                                                                                       << "dz=" << dz
+                                                                                       << "row=" << row
+                                                                                       << "roc=" << roc
+                                                                                       << "scale=" << scale
+                                                                                       << "scale2=" << scale2
+                                                                                       // original local coordinates
+                                                                                       << "ly=" << ly
+                                                                                       << "lz=" << lz
+                                                                                       << "lx=" << lx
+                                                                                       // corrected local coordinated
+                                                                                       << "lxT=" << lxT
+                                                                                       << "lyT=" << lyT
+                                                                                       << "lzT=" << lzT
+                                                                                       // global uncorrected coordinates
+                                                                                       << "gx=" << gx
+                                                                                       << "gy=" << gy
+                                                                                       << "gz=" << gz
+                                                                                       // some transformations which are applied
+                                                                                       << "invYZtoX=" << invYZtoX
+                                                                                       << "invYZtoXScaled=" << invYZtoXScaled
+                                                                                       << "YZtoNominalY=" << YZtoNominalY
+                                                                                       << "YZtoNominalYScaled=" << YZtoNominalYScaled
+                                                                                       << "YZtoNominalZ=" << YZtoNominalZ
+                                                                                       << "YZtoNominalZScaled=" << YZtoNominalZScaled
+                                                                                       << "scaleMode=" << scaleMode
+                                                                                       << "\n";
+  })
+
+  x += dx;
+  y += dy;
+  z += dz;
 }
 
 GPUdi() void TPCFastTransform::TransformXYZ(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
-  float u, v;
-  getGeometry().convLocalToUV(roc, y, z, u, v);
-  TransformInternal(roc, row, u, v, x, ref, ref2, scale, scale2, scaleMode);
-  getGeometry().convUVtoLocal(roc, u, v, y, z);
-  float dzTOF = 0;
-  getTOFcorrection(roc, row, x, y, z, dzTOF);
-  z += dzTOF;
+
+  TransformLocal(roc, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
 }
 
 GPUdi() void TPCFastTransform::Transform(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
@@ -617,31 +540,23 @@ GPUdi() void TPCFastTransform::Transform(int32_t roc, int32_t row, float pad, fl
   /// _______________ The main method: cluster transformation _______________________
   ///
   /// Transforms raw TPC coordinates to local XYZ withing a roc
-  /// taking calibration + alignment into account.
+  /// taking calibration into account.
   ///
 
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
 
-  // const RocInfo &rocInfo = getRocInfo( roc );
-  // bool sideC = ( roc >= NumberOfRocs / 2 );
-
   x = rowInfo.x;
   float u = 0, v = 0;
-  convPadTimeToUV(roc, row, pad, time, u, v, vertexTime);
-
-  TransformInternal(roc, row, u, v, x, ref, ref2, scale, scale2, scaleMode);
-
+  convPadTimeToUV(row, pad, time, u, v, vertexTime);
   getGeometry().convUVtoLocal(roc, u, v, y, z);
 
-  float dzTOF = 0;
-  getTOFcorrection(roc, row, x, y, z, dzTOF);
-  z += dzTOF;
+  TransformLocal(roc, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
 }
 
 GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t roc, float time, float& z, float maxTimeBin) const
 {
   float v = 0;
-  convTimeToVinTimeFrame(roc, time, v, maxTimeBin);
+  convTimeToVinTimeFrame(time, v, maxTimeBin);
   getGeometry().convVtoLocal(roc, v, z);
 }
 
@@ -656,7 +571,7 @@ GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t roc, int32_t row, fl
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
   x = rowInfo.x;
   float u = 0, v = 0;
-  convPadTimeToUVinTimeFrame(roc, row, pad, time, u, v, maxTimeBin);
+  convPadTimeToUVinTimeFrame(row, pad, time, u, v, maxTimeBin);
   getGeometry().convUVtoLocal(roc, u, v, y, z);
 }
 
@@ -665,7 +580,7 @@ GPUdi() void TPCFastTransform::InverseTransformInTimeFrame(int32_t roc, int32_t
   /// Inverse transformation to TransformInTimeFrame
   float u = 0, v = 0;
   getGeometry().convLocalToUV(roc, y, z, u, v);
-  convUVtoPadTimeInTimeFrame(roc, row, u, v, pad, time, maxTimeBin);
+  convUVtoPadTimeInTimeFrame(row, u, v, pad, time, maxTimeBin);
 }
 
 GPUdi() float TPCFastTransform::InverseTransformInTimeFrame(int32_t roc, float z, float maxTimeBin) const
@@ -715,26 +630,16 @@ GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t roc, float time,
   /// Only Z coordinate.
   ///
 
-  float v = (time - mT0 - maxTimeBin) * mVdrift + mLdriftCorr; // drift length cm
-  float z = getGeometry().getTPCalignmentZ();                  // global TPC alignment
-  if (roc < getGeometry().getNumberOfRocsA()) {
-    z -= v;
-  } else {
-    z += v;
-  }
+  float v = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
+  float z = (roc < getGeometry().getNumberOfRocsA()) ? -v : v;
   return z;
 }
 
 GPUdi() float TPCFastTransform::convZtoTimeInTimeFrame(int32_t roc, float z, float maxTimeBin) const
 {
   /// Inverse transformation of convTimeToZinTimeFrame()
-  float v;
-  if (roc < getGeometry().getNumberOfRocsA()) {
-    v = getGeometry().getTPCalignmentZ() - z;
-  } else {
-    v = z - getGeometry().getTPCalignmentZ();
-  }
-  return mT0 + maxTimeBin + (v - mLdriftCorr) / mVdrift;
+  float v = (roc < getGeometry().getNumberOfRocsA()) ? -z : z;
+  return mT0 + maxTimeBin + v / mVdrift;
 }
 
 GPUdi() float TPCFastTransform::convDeltaTimeToDeltaZinTimeFrame(int32_t roc, float deltaTime) const
@@ -769,17 +674,7 @@ GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t roc, int32_t row, float
 {
   /// maximal possible drift time of the active area
   float maxL = mCorrection.getMaxDriftLength(roc, row, pad);
-
-  bool sideC = (roc >= getGeometry().getNumberOfRocsA());
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  const TPCFastTransformGeo::RocInfo& rocInfo = getGeometry().getRocInfo(roc);
-
-  float x = rowInfo.x;
-  float u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-
-  float y = sideC ? -u : u; // pads are mirrorred on C-side
-  float yLab = y * rocInfo.cosAlpha + x * rocInfo.sinAlpha;
-  return mT0 + (maxL - mLdriftCorr) / (mVdrift + mVdriftCorrY * yLab);
+  return mT0 + maxL / mVdrift;
 }
 
 GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t roc, int32_t row) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
index b472868fa1071..c8982f05d4730 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
@@ -35,10 +35,10 @@ TPCFastTransformGeo::TPCFastTransformGeo()
     s.sinAlpha = sin(alpha);
     s.cosAlpha = cos(alpha);
   }
-  mRocInfos[NumberOfRocs] = RocInfo{0.f, 0.f};
+  mRocInfos[NumberOfRocs] = RocInfo{};
 
   for (int32_t i = 0; i < MaxNumberOfRows + 1; i++) {
-    mRowInfos[i] = RowInfo{0.f, -1, 0.f, 0.f, 0.f, 0.f};
+    mRowInfos[i] = RowInfo{};
   }
 }
 
@@ -51,45 +51,25 @@ void TPCFastTransformGeo::startConstruction(int32_t numberOfRows)
   mConstructionMask = ConstructionState::InProgress;
   mNumberOfRows = numberOfRows;
 
-  mTPCzLengthA = 0.f;
-  mTPCzLengthC = 0.f;
-  mTPCalignmentZ = 0.f;
-  mScaleVtoSVsideA = 0.f;
-  mScaleVtoSVsideC = 0.f;
-  mScaleSVtoVsideA = 0.f;
-  mScaleSVtoVsideC = 0.f;
+  mTPCzLength = 0.f;
 
   for (int32_t i = 0; i < MaxNumberOfRows; i++) {
-    mRowInfos[i] = RowInfo{0.f, -1, 0.f, 0.f, 0.f, 0.f};
+    mRowInfos[i] = RowInfo{};
   }
 }
 
-void TPCFastTransformGeo::setTPCzLength(float tpcZlengthSideA, float tpcZlengthSideC)
+void TPCFastTransformGeo::setTPCzLength(float tpcZlength)
 {
   /// Sets TPC z length for both sides
 
   assert(mConstructionMask & ConstructionState::InProgress);
-  assert((tpcZlengthSideA > 0.f) && (tpcZlengthSideC > 0.f));
+  assert(tpcZlength > 0.f);
 
-  mTPCzLengthA = tpcZlengthSideA;
-  mTPCzLengthC = tpcZlengthSideC;
-  mScaleSVtoVsideA = tpcZlengthSideA + 3.; // add some extra possible drift length due to the space charge distortions
-  mScaleSVtoVsideC = tpcZlengthSideC + 3.;
-  mScaleVtoSVsideA = 1. / mScaleSVtoVsideA;
-  mScaleVtoSVsideC = 1. / mScaleSVtoVsideC;
+  mTPCzLength = tpcZlength;
 
   mConstructionMask |= ConstructionState::GeometryIsSet;
 }
 
-void TPCFastTransformGeo::setTPCalignmentZ(float tpcAlignmentZ)
-{
-  /// Sets the TPC alignment
-  assert(mConstructionMask & ConstructionState::InProgress);
-
-  mTPCalignmentZ = tpcAlignmentZ;
-  mConstructionMask |= ConstructionState::AlignmentIsSet;
-}
-
 void TPCFastTransformGeo::setTPCrow(int32_t iRow, float x, int32_t nPads, float padWidth)
 {
   /// Initializes a TPC row
@@ -113,8 +93,6 @@ void TPCFastTransformGeo::setTPCrow(int32_t iRow, float x, int32_t nPads, float
   row.maxPad = nPads - 1;
   row.padWidth = padWidth;
   row.u0 = -uWidth / 2.;
-  row.scaleUtoSU = 1. / uWidth;
-  row.scaleSUtoU = uWidth;
 }
 
 void TPCFastTransformGeo::finishConstruction()
@@ -123,7 +101,6 @@ void TPCFastTransformGeo::finishConstruction()
 
   assert(mConstructionMask & ConstructionState::InProgress);     // construction in process
   assert(mConstructionMask & ConstructionState::GeometryIsSet);  // geometry is  set
-  assert(mConstructionMask & ConstructionState::AlignmentIsSet); // alignment is  set
 
   for (int32_t i = 0; i < mNumberOfRows; i++) { // all TPC rows are initialized
     assert(getRowInfo(i).maxPad > 0);
@@ -138,9 +115,7 @@ void TPCFastTransformGeo::print() const
 #if !defined(GPUCA_GPUCODE)
   LOG(info) << "TPC Fast Transformation Geometry: ";
   LOG(info) << "mNumberOfRows = " << mNumberOfRows;
-  LOG(info) << "mTPCzLengthA = " << mTPCzLengthA;
-  LOG(info) << "mTPCzLengthC = " << mTPCzLengthC;
-  LOG(info) << "mTPCalignmentZ = " << mTPCalignmentZ;
+  LOG(info) << "mTPCzLength = " << mTPCzLength;
   LOG(info) << "TPC Rows : ";
   for (int32_t i = 0; i < mNumberOfRows; i++) {
     LOG(info) << " tpc row " << i << ": x = " << mRowInfos[i].x << " maxPad = " << mRowInfos[i].maxPad << " padWidth = " << mRowInfos[i].padWidth;
@@ -179,26 +154,26 @@ int32_t TPCFastTransformGeo::test(int32_t roc, int32_t row, float ly, float lz)
     LOG(info) << "Error local <-> UV: y " << ly << " dy " << ly1 - ly << " z " << lz << " dz " << lz1 - lz;
     error = -4;
   }
+  /*
+    float su = 0.f, sv = 0.f;
 
-  float su = 0.f, sv = 0.f;
+    convUVtoScaledUV(roc, row, u, v, su, sv);
 
-  convUVtoScaledUV(roc, row, u, v, su, sv);
+    if (su < 0.f || su > 1.f) {
+      LOG(info) << "Error scaled U range: u " << u << " su " << su;
+      error = -5;
+    }
 
-  if (su < 0.f || su > 1.f) {
-    LOG(info) << "Error scaled U range: u " << u << " su " << su;
-    error = -5;
-  }
-
-  float u1 = 0.f, v1 = 0.f;
-  convScaledUVtoUV(roc, row, su, sv, u1, v1);
-
-  if (fabs(u1 - u) > 1.e-4 || fabs(v1 - v) > 1.e-4) {
-    LOG(info) << "Error UV<->scaled UV: u " << u << " du " << u1 - u << " v " << v << " dv " << v1 - v;
-    error = -6;
-  }
+    float u1 = 0.f, v1 = 0.f;
+    convScaledUVtoUV(roc, row, su, sv, u1, v1);
 
+    if (fabs(u1 - u) > 1.e-4 || fabs(v1 - v) > 1.e-4) {
+      LOG(info) << "Error UV<->scaled UV: u " << u << " du " << u1 - u << " v " << v << " dv " << v1 - v;
+      error = -6;
+    }
+  */
   float pad = convUtoPad(row, u);
-  u1 = convPadToU(row, pad);
+  float u1 = convPadToU(row, pad);
 
   if (fabs(u1 - u) > 1.e-5) {
     LOG(info) << "Error U<->Pad: u " << u << " pad " << pad << " du " << u1 - u;
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 3382d1d926ce2..a5d642158cd8f 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -36,19 +36,17 @@ class TPCFastTransformGeo
  public:
   /// The struct contains necessary info for TPC ROC
   struct RocInfo {
-    float sinAlpha;
-    float cosAlpha;
+    float sinAlpha{0.f}; ///< sin of the angle between the local x and the global x
+    float cosAlpha{0.f}; ///< cos of the angle between the local x and the global x
     ClassDefNV(RocInfo, 1);
   };
 
   /// The struct contains necessary info about TPC padrow
   struct RowInfo {
-    float x;          ///< nominal X coordinate of the row [cm]
-    int32_t maxPad;   ///< maximal pad number = n pads - 1
-    float padWidth;   ///< width of pads [cm]
-    float u0;         ///< min. u coordinate
-    float scaleUtoSU; ///< scale for su (scaled u ) coordinate
-    float scaleSUtoU; ///< scale for u coordinate
+    float x{0.f};        ///< nominal X coordinate of the padrow [cm]
+    int32_t maxPad{0};   ///< maximal pad number = n pads - 1
+    float padWidth{0.f}; ///< width of pads [cm]
+    float u0{0.f};       ///< min. u coordinate
 
     /// get U min
     GPUd() float getUmin() const { return u0; }
@@ -92,13 +90,7 @@ class TPCFastTransformGeo
   /// Sets TPC geometry
   ///
   /// It must be called once during initialization
-  void setTPCzLength(float tpcZlengthSideA, float tpcZlengthSideC);
-
-  /// Sets all drift calibration parameters and the time stamp
-  ///
-  /// It must be called once during construction,
-  /// but also may be called afterwards to reset these parameters.
-  void setTPCalignmentZ(float tpcAlignmentZ);
+  void setTPCzLength(float tpcZlength);
 
   /// Finishes initialization: puts everything to the flat buffer, releases temporary memory
   void finishConstruction();
@@ -126,21 +118,8 @@ class TPCFastTransformGeo
   /// Gives TPC row info
   GPUd() const RowInfo& getRowInfo(int32_t row) const;
 
-  /// Gives Z length of the TPC, side A
-  GPUd() float getTPCzLengthA() const { return mTPCzLengthA; }
-
-  /// Gives Z length of the TPC, side C
-  GPUd() float getTPCzLengthC() const { return mTPCzLengthC; }
-
-  /// Gives Z length of the TPC, depending on the roc
-  GPUd() float getTPCzLength(int32_t roc) const
-  {
-    return (roc < NumberOfRocsA) ? mTPCzLengthA
-                                 : mTPCzLengthC;
-  }
-
-  /// Gives TPC alignment in Z
-  GPUd() float getTPCalignmentZ() const { return mTPCalignmentZ; }
+  /// Gives Z length of the TPC, one Z side
+  GPUd() float getTPCzLength() const { return mTPCzLength; }
 
   /// _______________  Conversion of coordinate systems __________
 
@@ -157,15 +136,6 @@ class TPCFastTransformGeo
   /// convert Local-> UV c.s.
   GPUd() void convLocalToUV(int32_t roc, float y, float z, float& u, float& v) const;
 
-  /// convert UV -> Scaled UV
-  GPUd() void convUVtoScaledUV(int32_t roc, int32_t row, float u, float v, float& su, float& sv) const;
-
-  /// convert Scaled UV -> UV
-  GPUd() void convScaledUVtoUV(int32_t roc, int32_t row, float su, float sv, float& u, float& v) const;
-
-  /// convert Scaled UV -> Local c.s.
-  GPUd() void convScaledUVtoLocal(int32_t roc, int32_t row, float su, float sv, float& ly, float& lz) const;
-
   /// convert Pad coordinate -> U
   GPUd() float convPadToU(int32_t row, float pad) const;
 
@@ -196,7 +166,6 @@ class TPCFastTransformGeo
     Constructed = 0x1,    ///< the object is constructed, temporary memory is released
     InProgress = 0x2,     ///< construction started: temporary  memory is reserved
     GeometryIsSet = 0x4,  ///< the TPC geometry is set
-    AlignmentIsSet = 0x8  ///< the TPC alignment is set
   };
 
   uint32_t mConstructionMask = ConstructionState::NotConstructed; ///< mask for constructed object members, first two bytes are used by this class
@@ -204,18 +173,12 @@ class TPCFastTransformGeo
   /// _______________  Geometry  _______________________________________________
 
   int32_t mNumberOfRows = 0;    ///< Number of TPC rows. It is different for the Run2 and the Run3 setups
-  float mTPCzLengthA = 0.f;     ///< Z length of the TPC, side A
-  float mTPCzLengthC = 0.f;     ///< Z length of the TPC, side C
-  float mTPCalignmentZ = 0.f;   ///< Global Z shift of the TPC detector. It is applied at the end of the transformation.
-  float mScaleVtoSVsideA = 0.f; ///< scale for v->sv for TPC side A
-  float mScaleVtoSVsideC = 0.f; ///< scale for v->sv for TPC side C
-  float mScaleSVtoVsideA = 0.f; ///< scale for sv->v for TPC side A
-  float mScaleSVtoVsideC = 0.f; ///< scale for sv->v for TPC side C
-
-  RocInfo mRocInfos[NumberOfRocs + 1];       ///< array of roc information [fixed size]
-  RowInfo mRowInfos[MaxNumberOfRows + 1];    ///< array of row information [fixed size]
-
-  ClassDefNV(TPCFastTransformGeo, 2);
+  float mTPCzLength = 0.f;      ///< Z length of one TPC side (A or C)
+
+  RocInfo mRocInfos[NumberOfRocs + 1];    ///< array of roc information [fixed size]
+  RowInfo mRowInfos[MaxNumberOfRows + 1]; ///< array of row information [fixed size]
+
+  ClassDefNV(TPCFastTransformGeo, 3);
 };
 
 // =======================================================================
@@ -262,11 +225,10 @@ GPUdi() void TPCFastTransformGeo::convVtoLocal(int32_t roc, float v, float& lz)
 {
   /// convert UV -> Local c.s.
   if (roc < NumberOfRocsA) { // TPC side A
-    lz = mTPCzLengthA - v;
+    lz = mTPCzLength - v;
   } else {                 // TPC side C
-    lz = v - mTPCzLengthC; // drift direction is mirrored on C-side
+    lz = v - mTPCzLength;  // drift direction is mirrored on C-side
   }
-  lz += mTPCalignmentZ; // global TPC alignment
 }
 
 GPUdi() void TPCFastTransformGeo::convUVtoLocal(int32_t roc, float u, float v, float& ly, float& lz) const
@@ -274,59 +236,25 @@ GPUdi() void TPCFastTransformGeo::convUVtoLocal(int32_t roc, float u, float v, f
   /// convert UV -> Local c.s.
   if (roc < NumberOfRocsA) { // TPC side A
     ly = u;
-    lz = mTPCzLengthA - v;
+    lz = mTPCzLength - v;
   } else {                 // TPC side C
     ly = -u;               // pads are mirrorred on C-side
-    lz = v - mTPCzLengthC; // drift direction is mirrored on C-side
+    lz = v - mTPCzLength;  // drift direction is mirrored on C-side
   }
-  lz += mTPCalignmentZ; // global TPC alignment
 }
 
 GPUdi() void TPCFastTransformGeo::convLocalToUV(int32_t roc, float ly, float lz, float& u, float& v) const
 {
   /// convert Local-> UV c.s.
-  lz = lz - mTPCalignmentZ;      // global TPC alignment
-  if (roc < NumberOfRocsA) {     // TPC side A
+  if (roc < NumberOfRocsA) { // TPC side A
     u = ly;
-    v = mTPCzLengthA - lz;
+    v = mTPCzLength - lz;
   } else {                 // TPC side C
     u = -ly;               // pads are mirrorred on C-side
-    v = lz + mTPCzLengthC; // drift direction is mirrored on C-side
+    v = lz + mTPCzLength;  // drift direction is mirrored on C-side
   }
 }
 
-GPUdi() void TPCFastTransformGeo::convUVtoScaledUV(int32_t roc, int32_t row, float u, float v, float& su, float& sv) const
-{
-  /// convert UV -> Scaled UV
-  const RowInfo& rowInfo = getRowInfo(row);
-  su = (u - rowInfo.u0) * rowInfo.scaleUtoSU;
-  if (roc < NumberOfRocsA) {
-    sv = v * mScaleVtoSVsideA;
-  } else {
-    sv = v * mScaleVtoSVsideC;
-  }
-}
-
-GPUdi() void TPCFastTransformGeo::convScaledUVtoUV(int32_t roc, int32_t row, float su, float sv, float& u, float& v) const
-{
-  /// convert Scaled UV -> UV
-  const RowInfo& rowInfo = getRowInfo(row);
-  u = rowInfo.u0 + su * rowInfo.scaleSUtoU;
-  if (roc < NumberOfRocsA) {
-    v = sv * mScaleSVtoVsideA;
-  } else {
-    v = sv * mScaleSVtoVsideC;
-  }
-}
-
-GPUdi() void TPCFastTransformGeo::convScaledUVtoLocal(int32_t roc, int32_t row, float su, float sv, float& ly, float& lz) const
-{
-  /// convert Scaled UV -> Local c.s.
-  float u, v;
-  convScaledUVtoUV(roc, row, su, sv, u, v);
-  convUVtoLocal(roc, u, v, ly, lz);
-}
-
 GPUdi() float TPCFastTransformGeo::convPadToU(int32_t row, float pad) const
 {
   /// convert Pad coordinate -> U
diff --git a/GPU/TPCFastTransformation/TPCFastTransformManager.cxx b/GPU/TPCFastTransformation/TPCFastTransformManager.cxx
index aa28b6a414876..c553d9cc6dac1 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformManager.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformManager.cxx
@@ -22,6 +22,7 @@
 #include "AliTPCcalibDB.h"
 #include "TPCFastTransform.h"
 #include "Spline2DHelper.h"
+blabla
 
 using namespace o2::gpu;
 

From 6e876d178f27aa1c8683b14006562317137a5060 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Thu, 6 Mar 2025 23:58:56 +0000
Subject: [PATCH 1569/1764] TPC Splines: init inverse from the inverse voxel
 map; rebase

---
 .../TPCFastSpaceChargeCorrectionHelper.h      |  13 +-
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 921 +++++++++---------
 .../src/TPCFastTransformHelperO2.cxx          |   4 +-
 .../test/testTPCFastTransform.cxx             |  61 +-
 GPU/TPCFastTransformation/Spline1DSpec.h      |  36 +-
 .../TPCFastSpaceChargeCorrection.cxx          | 201 ++--
 .../TPCFastSpaceChargeCorrection.h            | 334 +++----
 .../TPCFastSpaceChargeCorrectionMap.h         |  24 +-
 GPU/TPCFastTransformation/TPCFastTransform.h  | 347 +++----
 .../TPCFastTransformGeo.cxx                   |  55 +-
 .../TPCFastTransformGeo.h                     | 160 ++-
 .../TPCFastTransformManager.cxx               | 336 -------
 .../TPCFastTransformManager.h                 |  86 --
 .../TPCFastTransformationLinkDef_O2.h         |   7 +-
 .../macro/TPCFastTransformInit.C              | 211 ++--
 15 files changed, 1159 insertions(+), 1637 deletions(-)
 delete mode 100644 GPU/TPCFastTransformation/TPCFastTransformManager.cxx
 delete mode 100644 GPU/TPCFastTransformation/TPCFastTransformManager.h

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
index eff4972679ed8..abbc5b7116b2d 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
@@ -86,15 +86,14 @@ class TPCFastSpaceChargeCorrectionHelper
 
   /// Create SpaceCharge correction out of the voxel tree
   std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> createFromTrackResiduals(
-    const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, bool useSmoothed = false, bool invertSigns = false);
+    const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, TTree* voxResTreeInverse, bool useSmoothed, bool invertSigns);
+
   /// _______________  Utilities   ________________________
 
   const TPCFastTransformGeo& getGeometry() { return mGeo; }
 
   TPCFastSpaceChargeCorrectionMap& getCorrectionMap() { return mCorrectionMap; }
 
-  void fillSpaceChargeCorrectionFromMap(TPCFastSpaceChargeCorrection& correction);
-
   void testGeometry(const TPCFastTransformGeo& geo) const;
 
   /// initialise inverse transformation
@@ -103,15 +102,13 @@ class TPCFastSpaceChargeCorrectionHelper
   /// initialise inverse transformation from linear combination of several input corrections
   void initInverse(std::vector<o2::gpu::TPCFastSpaceChargeCorrection*>& corrections, const std::vector<float>& scaling, bool prn);
 
+  void MergeCorrections(std::vector<o2::gpu::TPCFastSpaceChargeCorrection*>& corrections, const std::vector<float>& scaling, bool prn);
+
  private:
   /// geometry initialization
   void initGeometry();
 
-  /// get space charge correction in internal TPCFastTransform coordinates u,v->dx,du,dv
-  void getSpaceChargeCorrection(const TPCFastSpaceChargeCorrection& correction, int slice, int row, o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p, double& su, double& sv, double& dx, double& du, double& dv);
-
-  /// initialise max drift length
-  void initMaxDriftLength(o2::gpu::TPCFastSpaceChargeCorrection& correction, bool prn);
+  void fillSpaceChargeCorrectionFromMap(TPCFastSpaceChargeCorrection& correction, bool processingInverseCorrection);
 
   static TPCFastSpaceChargeCorrectionHelper* sInstance; ///< singleton instance
   bool mIsInitialized = 0;                              ///< initialization flag
diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 710a4356dd457..92817063831f6 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -32,6 +32,7 @@
 #include "TTreeReader.h"
 #include "TTreeReaderValue.h"
 #include "ROOT/TTreeProcessorMT.hxx"
+#include <algorithm>
 
 using namespace o2::gpu;
 
@@ -112,7 +113,7 @@ void TPCFastSpaceChargeCorrectionHelper::setNthreadsToMaximum()
   }
 }
 
-void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFastSpaceChargeCorrection& correction)
+void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFastSpaceChargeCorrection& correction, bool processingInverseCorrection)
 {
   // calculate correction map: dx,du,dv = ( origTransform() -> x,u,v) - fastTransformNominal:x,u,v
   // for the future: switch TOF correction off for a while
@@ -130,39 +131,64 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
 
   LOG(info) << "fast space charge correction helper: init from data points";
 
-  for (int roc = 0; roc < correction.getGeometry().getNumberOfRocs(); roc++) {
+  for (int sector = 0; sector < correction.getGeometry().getNumberOfSectors(); sector++) {
 
     auto myThread = [&](int iThread) {
       for (int row = iThread; row < correction.getGeometry().getNumberOfRows(); row += mNthreads) {
 
-        TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSpline(roc, row);
+        TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSpline(sector, row);
         Spline2DHelper<float> helper;
-        float* splineParameters = correction.getSplineData(roc, row);
-        const std::vector<o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint>& data = mCorrectionMap.getPoints(roc, row);
+        std::vector<float> splineParameters;
+        splineParameters.resize(spline.getNumberOfParameters());
+
+        const std::vector<o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint>& data = mCorrectionMap.getPoints(sector, row);
         int nDataPoints = data.size();
-        auto& info = correction.getRocRowInfo(roc, row);
-        info.resetMaxValues();
+        auto& info = correction.getSectorRowInfo(sector, row);
+        if (!processingInverseCorrection) {
+          info.resetMaxValues();
+        }
         if (nDataPoints >= 4) {
-          std::vector<double> pointSU(nDataPoints);
-          std::vector<double> pointSV(nDataPoints);
+          std::vector<double> pointGU(nDataPoints);
+          std::vector<double> pointGV(nDataPoints);
           std::vector<double> pointCorr(3 * nDataPoints); // 3 dimensions
           for (int i = 0; i < nDataPoints; ++i) {
-            double su, sv, dx, du, dv;
-            getSpaceChargeCorrection(correction, roc, row, data[i], su, sv, dx, du, dv);
-            pointSU[i] = su;
-            pointSV[i] = sv;
-            pointCorr[3 * i + 0] = dx;
-            pointCorr[3 * i + 1] = du;
-            pointCorr[3 * i + 2] = dv;
-            info.updateMaxValues(20. * dx, 20. * du, 20. * dv);
+            o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p = data[i];
+            // not corrected grid coordinates
+            auto [gu, gv, scale] = correction.convLocalToGrid(sector, row, p.mY, p.mZ);
+            if (scale - 1.f > 1.e-6) { // point is outside the grid
+              continue;
+            }
+            pointGU[i] = gu;
+            pointGV[i] = gv;
+            pointCorr[3 * i + 0] = p.mDx;
+            pointCorr[3 * i + 1] = p.mDy;
+            pointCorr[3 * i + 2] = p.mDz;
+            if (!processingInverseCorrection) {
+              info.updateMaxValues(20. * p.mDx, 20. * p.mDy, 20. * p.mDz);
+            }
           }
-          helper.approximateDataPoints(spline, splineParameters, 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), &pointSU[0],
-                                       &pointSV[0], &pointCorr[0], nDataPoints);
+          helper.approximateDataPoints(spline, splineParameters.data(), 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), &pointGU[0],
+                                       &pointGV[0], &pointCorr[0], nDataPoints);
         } else {
           for (int i = 0; i < spline.getNumberOfParameters(); i++) {
             splineParameters[i] = 0.f;
           }
         }
+
+        if (processingInverseCorrection) {
+          float* splineX = correction.getSplineData(sector, row, 1);
+          float* splineYZ = correction.getSplineData(sector, row, 2);
+          for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
+            splineX[i] = splineParameters[3 * i + 0];
+            splineYZ[2 * i + 0] = splineParameters[3 * i + 1];
+            splineYZ[2 * i + 1] = splineParameters[3 * i + 2];
+          }
+        } else {
+          float* splineXYZ = correction.getSplineData(sector, row);
+          for (int i = 0; i < spline.getNumberOfParameters(); i++) {
+            splineXYZ[i] = splineParameters[i];
+          }
+        }
       } // row
     };  // thread
 
@@ -178,57 +204,30 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
       th.join();
     }
 
-  } // roc
+  } // sector
 
   watch.Stop();
 
   LOGP(info, "Space charge correction tooks: {}s", watch.RealTime());
-
-  initInverse(correction, 0);
-}
-
-void TPCFastSpaceChargeCorrectionHelper::getSpaceChargeCorrection(const TPCFastSpaceChargeCorrection& correction, int roc, int row, o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p,
-                                                                  double& su, double& sv, double& dx, double& du, double& dv)
-{
-  // get space charge correction in internal TPCFastTransform coordinates su,sv->dx,du,dv
-
-  if (!mIsInitialized) {
-    initGeometry();
-  }
-
-  // not corrected coordinates in u,v
-  float u = 0.f, v = 0.f, fsu = 0.f, fsv = 0.f;
-  mGeo.convLocalToUV(roc, p.mY, p.mZ, u, v);
-  correction.convUVtoGrid(roc, row, u, v, fsu, fsv);
-  // mGeo.convUVtoScaledUV(roc, row, u, v, fsu, fsv);
-  su = fsu;
-  sv = fsv;
-  // corrected coordinates in u,v
-  float u1 = 0.f, v1 = 0.f;
-  mGeo.convLocalToUV(roc, p.mY + p.mDy, p.mZ + p.mDz, u1, v1);
-
-  dx = p.mDx;
-  du = u1 - u;
-  dv = v1 - v;
-}
+} // fillSpaceChargeCorrectionFromMap
 
 std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper::createFromGlobalCorrection(
-  std::function<void(int roc, double gx, double gy, double gz,
+  std::function<void(int sector, double gx, double gy, double gz,
                      double& dgx, double& dgy, double& dgz)>
     correctionGlobal,
   const int nKnotsY, const int nKnotsZ)
 {
   /// creates TPCFastSpaceChargeCorrection object from a continious space charge correction in global coordinates
 
-  auto correctionLocal = [&](int roc, int irow, double ly, double lz,
+  auto correctionLocal = [&](int sector, int irow, double ly, double lz,
                              double& dlx, double& dly, double& dlz) {
     double lx = mGeo.getRowInfo(irow).x;
     float gx, gy, gz;
-    mGeo.convLocalToGlobal(roc, lx, ly, lz, gx, gy, gz);
+    mGeo.convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);
     double dgx, dgy, dgz;
-    correctionGlobal(roc, gx, gy, gz, dgx, dgy, dgz);
+    correctionGlobal(sector, gx, gy, gz, dgx, dgy, dgz);
     float lx1, ly1, lz1;
-    mGeo.convGlobalToLocal(roc, gx + dgx, gy + dgy, gz + dgz, lx1, ly1, lz1);
+    mGeo.convGlobalToLocal(sector, gx + dgx, gy + dgy, gz + dgz, lx1, ly1, lz1);
     dlx = lx1 - lx;
     dly = ly1 - ly;
     dlz = lz1 - lz;
@@ -237,7 +236,7 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
 }
 
 std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper::createFromLocalCorrection(
-  std::function<void(int roc, int irow, double y, double z, double& dx, double& dy, double& dz)> correctionLocal,
+  std::function<void(int sector, int irow, double y, double z, double& dx, double& dy, double& dz)> correctionLocal,
   const int nKnotsY, const int nKnotsZ)
 {
   /// creates TPCFastSpaceChargeCorrection object from a continious space charge correction in local coordinates
@@ -282,28 +281,24 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
     /// set space charge correction in the local coordinates
     /// as a continious function
 
-    int nRocs = mGeo.getNumberOfRocs();
+    int nSectors = mGeo.getNumberOfSectors();
     int nRows = mGeo.getNumberOfRows();
-    mCorrectionMap.init(nRocs, nRows);
+    mCorrectionMap.init(nSectors, nRows);
 
-    for (int iRoc = 0; iRoc < nRocs; iRoc++) {
+    for (int iSector = 0; iSector < nSectors; iSector++) {
 
       auto myThread = [&](int iThread) {
         for (int iRow = iThread; iRow < nRows; iRow += mNthreads) {
           const auto& info = mGeo.getRowInfo(iRow);
-          double vMax = mGeo.getTPCzLength();
-          double dv = vMax / (6. * (nKnotsZ - 1));
-
+          double dl = mGeo.getTPCzLength() / (6. * (nKnotsZ - 1));
           double dpad = info.maxPad / (6. * (nKnotsY - 1));
           for (double pad = 0; pad < info.maxPad + .5 * dpad; pad += dpad) {
-            float u = mGeo.convPadToU(iRow, pad);
-            for (double v = 0.; v < vMax + .5 * dv; v += dv) {
-              float ly, lz;
-              mGeo.convUVtoLocal(iRoc, u, v, ly, lz);
+            for (double l = 0.; l < mGeo.getTPCzLength() + .5 * dl; l += dl) {
+              auto [y, z] = mGeo.convPadDriftLengthToLocal(iSector, iRow, pad, l);
               double dx, dy, dz;
-              correctionLocal(iRoc, iRow, ly, lz, dx, dy, dz);
-              mCorrectionMap.addCorrectionPoint(iRoc, iRow,
-                                                ly, lz, dx, dy, dz);
+              correctionLocal(iSector, iRow, y, z, dx, dy, dz);
+              mCorrectionMap.addCorrectionPoint(iSector, iRow,
+                                                y, z, dx, dy, dz);
             }
           }
         } // row
@@ -321,20 +316,21 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
         th.join();
       }
 
-    } // roc
+    } // sector
 
-    fillSpaceChargeCorrectionFromMap(correction);
+    fillSpaceChargeCorrectionFromMap(correction, false);
+    initInverse(correction, false);
   }
 
   return std::move(correctionPtr);
-}
+} // createFromLocalCorrection
 
 void TPCFastSpaceChargeCorrectionHelper::testGeometry(const TPCFastTransformGeo& geo) const
 {
   const Mapper& mapper = Mapper::instance();
 
-  if (geo.getNumberOfRocs() != Sector::MAXSECTOR) {
-    LOG(fatal) << "Wrong number of sectors :" << geo.getNumberOfRocs() << " instead of " << Sector::MAXSECTOR << std::endl;
+  if (geo.getNumberOfSectors() != Sector::MAXSECTOR) {
+    LOG(fatal) << "Wrong number of sectors :" << geo.getNumberOfSectors() << " instead of " << Sector::MAXSECTOR << std::endl;
   }
 
   if (geo.getNumberOfRows() != mapper.getNumberOfRows()) {
@@ -384,7 +380,7 @@ void TPCFastSpaceChargeCorrectionHelper::testGeometry(const TPCFastTransformGeo&
 }
 
 std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper::createFromTrackResiduals(
-  const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, bool useSmoothed, bool invertSigns)
+  const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, TTree* voxResTreeInverse, bool useSmoothed, bool invertSigns)
 {
   // create o2::gpu::TPCFastSpaceChargeCorrection  from o2::tpc::TrackResiduals::VoxRes voxel tree
 
@@ -399,9 +395,6 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   auto* helper = o2::tpc::TPCFastSpaceChargeCorrectionHelper::instance();
   const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
-  o2::gpu::TPCFastSpaceChargeCorrectionMap& map = helper->getCorrectionMap();
-  map.init(geo.getNumberOfRocs(), geo.getNumberOfRows());
-
   int nY2Xbins = trackResiduals.getNY2XBins();
   int nZ2Xbins = trackResiduals.getNZ2XBins();
 
@@ -476,7 +469,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   // std::cout << "n knots Z: " << nKnotsZ << std::endl;
 
   const int nRows = geo.getNumberOfRows();
-  const int nROCs = geo.getNumberOfRocs();
+  const int nSectors = geo.getNumberOfSectors();
 
   { // create the correction object
 
@@ -497,11 +490,11 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   } // .. create the correction object
 
   // set the grid borders
-  for (int iRoc = 0; iRoc < geo.getNumberOfRocs(); iRoc++) {
+  for (int iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
     for (int iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
       const auto& rowInfo = geo.getRowInfo(iRow);
-      auto& info = correction.getRocRowInfo(iRoc, iRow);
-      const auto& spline = correction.getSpline(iRoc, iRow);
+      auto& info = correction.getSectorRowInfo(iSector, iRow);
+      const auto& spline = correction.getSpline(iSector, iRow);
       double yMin = rowInfo.x * trackResiduals.getY2X(iRow, 0);
       double yMax = rowInfo.x * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
       double zMin = rowInfo.x * trackResiduals.getZ2X(0);
@@ -514,366 +507,319 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       info.scaleUtoGrid = spline.getGridX1().getUmax() / (uMax - uMin);
       info.gridV0 = vMin;
       info.scaleVtoGrid = spline.getGridX2().getUmax() / (vMax - vMin);
-      // std::cout << " iRoc " << iRoc << " iRow " << iRow << " uMin: " << uMin << " uMax: " << uMax << " vMin: " << vMin << " vMax: " << vMax
+      info.gridCorrU0 = info.gridU0;
+      info.gridCorrV0 = info.gridV0;
+      info.scaleCorrUtoGrid = info.scaleUtoGrid;
+      info.scaleCorrVtoGrid = info.scaleVtoGrid;
+
+      // std::cout << " iSector " << iSector << " iRow " << iRow << " uMin: " << uMin << " uMax: " << uMax << " vMin: " << vMin << " vMax: " << vMax
       //<< " grid scale u "<< info.scaleUtoGrid << " grid scale v "<< info.scaleVtoGrid<< std::endl;
     }
   }
 
   LOG(info) << "fast space charge correction helper: preparation took " << watch1.RealTime() << "s";
 
-  LOG(info) << "fast space charge correction helper: fill data points from track residuals.. ";
-
-  TStopwatch watch3;
+  for (int processingInverseCorrection = 0; processingInverseCorrection < 2; processingInverseCorrection++) {
 
-  // read the data ROC by ROC
+    TTree* currentTree = (processingInverseCorrection) ? voxResTreeInverse : voxResTree;
 
-  // data in the tree is not sorted by row
-  // first find which data belong to which row
+    if (!currentTree) {
+      continue;
+    }
 
-  struct VoxelData {
-    int mNentries{0};    // number of entries
-    float mX, mY, mZ;    // mean position in the local coordinates
-    float mCx, mCy, mCz; // corrections to the local coordinates
-  };
+    LOG(info) << "fast space charge correction helper: " << ((processingInverseCorrection) ? "inverse" : "direct")
+              << " : fill data points from track residuals.. ";
 
-  std::vector<VoxelData> vRocData[nRows * nROCs];
-  for (int ir = 0; ir < nRows * nROCs; ir++) {
-    vRocData[ir].resize(nY2Xbins * nZ2Xbins);
-  }
+    TStopwatch watch3;
+    o2::gpu::TPCFastSpaceChargeCorrectionMap& map = helper->getCorrectionMap();
+    map.init(geo.getNumberOfSectors(), geo.getNumberOfRows());
 
-  { // read data from the tree to vRocData
+    // read the data Sector by Sector
 
-    ROOT::TTreeProcessorMT processor(*voxResTree, mNthreads);
+    // data in the tree is not sorted by row
+    // first find which data belong to which row
 
-    auto myThread = [&](TTreeReader& readerSubRange) {
-      TTreeReaderValue<o2::tpc::TrackResiduals::VoxRes> v(readerSubRange, "voxRes");
-      while (readerSubRange.Next()) {
-        int iRoc = (int)v->bsec;
-        if (iRoc < 0 || iRoc >= nROCs) {
-          LOG(fatal) << "Error reading voxels: voxel ROC number " << iRoc << " is out of range";
-          continue;
-        }
-        int iRow = (int)v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
-        if (iRow < 0 || iRow >= nRows) {
-          LOG(fatal) << "Row number " << iRow << " is out of range";
-        }
-        int iy = v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
-        int iz = v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
-        auto& data = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
-        data.mNentries = (int)v->stat[o2::tpc::TrackResiduals::VoxV];
-        data.mX = v->stat[o2::tpc::TrackResiduals::VoxX];
-        data.mY = v->stat[o2::tpc::TrackResiduals::VoxF];
-        data.mZ = v->stat[o2::tpc::TrackResiduals::VoxZ];
-        data.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
-        data.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
-        data.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
-        if (0 && data.mNentries < 1) {
-          data.mCx = 0.;
-          data.mCy = 0.;
-          data.mCz = 0.;
-          data.mNentries = 1;
-        }
-      }
+    struct VoxelData {
+      int mNentries{0};    // number of entries
+      float mX, mY, mZ;    // mean position in the local coordinates
+      float mCx, mCy, mCz; // corrections to the local coordinates
     };
-    processor.Process(myThread);
-  }
 
-  for (int iRoc = 0; iRoc < nROCs; iRoc++) {
+    std::vector<VoxelData> vSectorData[nRows * nSectors];
+    for (int ir = 0; ir < nRows * nSectors; ir++) {
+      vSectorData[ir].resize(nY2Xbins * nZ2Xbins);
+    }
 
-    // now process the data row-by-row
+    { // read data from the tree to vSectorData
 
-    auto myThread = [&](int iThread, int nTreads) {
-      struct Voxel {
-        float mY, mZ;            // not-distorted local coordinates
-        float mDy, mDz;          // bin size
-        int mSmoothingStep{100}; // is the voxel data original or smoothed at this step
+      ROOT::TTreeProcessorMT processor(*currentTree, mNthreads);
+
+      auto myThread = [&](TTreeReader& readerSubRange) {
+        TTreeReaderValue<o2::tpc::TrackResiduals::VoxRes> v(readerSubRange, "voxRes");
+        while (readerSubRange.Next()) {
+          int iSector = (int)v->bsec;
+          if (iSector < 0 || iSector >= nSectors) {
+            LOG(fatal) << "Error reading voxels: voxel Sector number " << iSector << " is out of range";
+            continue;
+          }
+          int iRow = (int)v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
+          if (iRow < 0 || iRow >= nRows) {
+            LOG(fatal) << "Row number " << iRow << " is out of range";
+          }
+          int iy = v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
+          int iz = v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
+          auto& data = vSectorData[iSector * nRows + iRow][iy * nZ2Xbins + iz];
+          data.mNentries = (int)v->stat[o2::tpc::TrackResiduals::VoxV];
+          data.mX = v->stat[o2::tpc::TrackResiduals::VoxX];
+          data.mY = v->stat[o2::tpc::TrackResiduals::VoxF];
+          data.mZ = v->stat[o2::tpc::TrackResiduals::VoxZ];
+          data.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
+          data.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
+          data.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
+          if (0 && data.mNentries < 1) {
+            data.mCx = 0.;
+            data.mCy = 0.;
+            data.mCz = 0.;
+            data.mNentries = 1;
+          }
+        }
       };
+      processor.Process(myThread);
+    }
 
-      std::vector<Voxel> vRowVoxels(nY2Xbins * nZ2Xbins);
+    for (int iSector = 0; iSector < nSectors; iSector++) {
 
-      for (int iRow = iThread; iRow < nRows; iRow += nTreads) {
-        // LOG(info) << "Processing ROC " << iRoc << " row " << iRow;
+      // now process the data row-by-row
 
-        // complete the voxel data
+      auto myThread = [&](int iThread, int nTreads) {
+        struct Voxel {
+          float mY, mZ;            // not-distorted local coordinates
+          float mDy, mDz;          // bin size
+          int mSmoothingStep{100}; // is the voxel data original or smoothed at this step
+        };
 
-        {
-          int xBin = iRow;
-          double x = trackResiduals.getX(xBin); // radius of the pad row
-          bool isDataFound = false;
-          for (int iy = 0; iy < nY2Xbins; iy++) {
-            for (int iz = 0; iz < nZ2Xbins; iz++) {
-              auto& data = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
-              auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
-              // y/x coordinate of the bin ~-0.15 ... 0.15
-              double y2x = trackResiduals.getY2X(xBin, iy);
-              // z/x coordinate of the bin 0.1 .. 0.9
-              double z2x = trackResiduals.getZ2X(iz);
-              vox.mY = x * y2x;
-              vox.mZ = x * z2x;
-              vox.mDy = x / trackResiduals.getDY2XI(xBin, iy);
-              vox.mDz = x * trackResiduals.getDZ2X(iz);
-              if (iRoc >= geo.getNumberOfRocsA()) {
-                vox.mZ = -vox.mZ;
-              }
-              data.mY *= x;
-              data.mZ *= x;
-              /*
-              if ( fabs(x - data.mX) > 0.01 || fabs(vox.mY - data.mY) > 5. || fabs(vox.mZ - data.mZ) > 5.) {
-                std::cout
-                  << " roc " << iRoc << " row " << iRow
-                  << " voxel x " << x << " y " << vox.mY << " z " << vox.mZ
-                  << " data x " << data.mX << " y " << data.mY << " z " << data.mZ
-                  << std::endl;
-              }
-              */
-              if (0) { // debug: always use voxel center instead of the mean position
-                data.mY = vox.mY;
-                data.mZ = vox.mZ;
-              }
-              if (data.mNentries < 1) { // no data
-                data.mCx = 0.;
-                data.mCy = 0.;
-                data.mCz = 0.;
-                data.mY = vox.mY;
-                data.mZ = vox.mZ;
-                vox.mSmoothingStep = 100;
-              } else { // voxel contains data
-                if (invertSigns) {
-                  data.mCx *= -1.;
-                  data.mCy *= -1.;
-                  data.mCz *= -1.;
-                }
-                vox.mSmoothingStep = 0; // original data
-                isDataFound = true;
-              }
-            }
-          }
+        std::vector<Voxel> vRowVoxels(nY2Xbins * nZ2Xbins);
+
+        for (int iRow = iThread; iRow < nRows; iRow += nTreads) {
+          // LOG(info) << "Processing Sector " << iSector << " row " << iRow;
 
-          if (!isDataFound) { // fill everything with 0
+          // complete the voxel data
+
+          {
+            int xBin = iRow;
+            double x = trackResiduals.getX(xBin); // radius of the pad row
+            bool isDataFound = false;
             for (int iy = 0; iy < nY2Xbins; iy++) {
               for (int iz = 0; iz < nZ2Xbins; iz++) {
-                vRowVoxels[iy * nZ2Xbins + iz].mSmoothingStep = 0;
+                auto& data = vSectorData[iSector * nRows + iRow][iy * nZ2Xbins + iz];
+                auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+                // y/x coordinate of the bin ~-0.15 ... 0.15
+                double y2x = trackResiduals.getY2X(xBin, iy);
+                // z/x coordinate of the bin 0.1 .. 0.9
+                double z2x = trackResiduals.getZ2X(iz);
+                vox.mY = x * y2x;
+                vox.mZ = x * z2x;
+                vox.mDy = x / trackResiduals.getDY2XI(xBin, iy);
+                vox.mDz = x * trackResiduals.getDZ2X(iz);
+                if (iSector >= geo.getNumberOfSectorsA()) {
+                  vox.mZ = -vox.mZ;
+                }
+                data.mY *= x;
+                data.mZ *= x;
+                /*
+                if ( fabs(x - data.mX) > 0.01 || fabs(vox.mY - data.mY) > 5. || fabs(vox.mZ - data.mZ) > 5.) {
+                  std::cout
+                    << " sector " << iSector << " row " << iRow
+                    << " voxel x " << x << " y " << vox.mY << " z " << vox.mZ
+                    << " data x " << data.mX << " y " << data.mY << " z " << data.mZ
+                    << std::endl;
+                }
+                */
+                if (0) { // debug: always use voxel center instead of the mean position
+                  data.mY = vox.mY;
+                  data.mZ = vox.mZ;
+                }
+                if (data.mNentries < 1) { // no data
+                  data.mCx = 0.;
+                  data.mCy = 0.;
+                  data.mCz = 0.;
+                  data.mY = vox.mY;
+                  data.mZ = vox.mZ;
+                  vox.mSmoothingStep = 100;
+                } else { // voxel contains data
+                  if (invertSigns) {
+                    data.mCx *= -1.;
+                    data.mCy *= -1.;
+                    data.mCz *= -1.;
+                  }
+                  vox.mSmoothingStep = 0; // original data
+                  isDataFound = true;
+                }
               }
             }
-          }
-        } // complete the voxel data
 
-        // repare the voxel data: fill empty voxels
-
-        int nRepairs = 0;
-
-        for (int ismooth = 1; ismooth <= 2; ismooth++) {
-          for (int iy = 0; iy < nY2Xbins; iy++) {
-            for (int iz = 0; iz < nZ2Xbins; iz++) {
-              auto& data = vRocData[iRoc * nRows + iRow][iy * nZ2Xbins + iz];
-              auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
-              if (vox.mSmoothingStep <= ismooth) { // already filled
-                continue;
-              }
-              nRepairs++;
-              data.mCx = 0.;
-              data.mCy = 0.;
-              data.mCz = 0.;
-              double w = 0.;
-              bool filled = false;
-              auto update = [&](int iy1, int iz1) {
-                auto& data1 = vRocData[iRoc * nRows + iRow][iy1 * nZ2Xbins + iz1];
-                auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
-                if (vox1.mSmoothingStep >= ismooth) {
-                  return false;
+            if (!isDataFound) { // fill everything with 0
+              for (int iy = 0; iy < nY2Xbins; iy++) {
+                for (int iz = 0; iz < nZ2Xbins; iz++) {
+                  vRowVoxels[iy * nZ2Xbins + iz].mSmoothingStep = 0;
                 }
-                double w1 = 1. / (abs(iy - iy1) + abs(iz - iz1) + 1);
-                data.mCx += w1 * data1.mCx;
-                data.mCy += w1 * data1.mCy;
-                data.mCz += w1 * data1.mCz;
-                w += w1;
-                filled = true;
-                return true;
-              };
-
-              for (int iy1 = iy - 1; iy1 >= 0 && !update(iy1, iz); iy1--) {
-              }
-              for (int iy1 = iy + 1; iy1 < nY2Xbins && !update(iy1, iz); iy1++) {
-              }
-              for (int iz1 = iz - 1; iz1 >= 0 && !update(iy, iz1); iz1--) {
-              }
-              for (int iz1 = iz + 1; iz1 < nZ2Xbins && !update(iy, iz1); iz1++) {
               }
+            }
+          } // complete the voxel data
 
-              if (filled) {
-                data.mCx /= w;
-                data.mCy /= w;
-                data.mCz /= w;
-                vox.mSmoothingStep = ismooth;
-              }
-            } // iz
-          }   // iy
-        }     // ismooth
+          // repare the voxel data: fill empty voxels
 
-        if (nRepairs > 0) {
-          LOG(debug) << "ROC " << iRoc << " row " << iRow << ": " << nRepairs << " voxel repairs for " << nY2Xbins * nZ2Xbins << " voxels";
-        }
+          int nRepairs = 0;
 
-        // feed the row data to the helper
+          for (int ismooth = 1; ismooth <= 2; ismooth++) {
+            for (int iy = 0; iy < nY2Xbins; iy++) {
+              for (int iz = 0; iz < nZ2Xbins; iz++) {
+                auto& data = vSectorData[iSector * nRows + iRow][iy * nZ2Xbins + iz];
+                auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+                if (vox.mSmoothingStep <= ismooth) { // already filled
+                  continue;
+                }
+                nRepairs++;
+                data.mCx = 0.;
+                data.mCy = 0.;
+                data.mCz = 0.;
+                double w = 0.;
+                bool filled = false;
+                auto update = [&](int iy1, int iz1) {
+                  auto& data1 = vSectorData[iSector * nRows + iRow][iy1 * nZ2Xbins + iz1];
+                  auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
+                  if (vox1.mSmoothingStep >= ismooth) {
+                    return false;
+                  }
+                  double w1 = 1. / (abs(iy - iy1) + abs(iz - iz1) + 1);
+                  data.mCx += w1 * data1.mCx;
+                  data.mCy += w1 * data1.mCy;
+                  data.mCz += w1 * data1.mCz;
+                  w += w1;
+                  filled = true;
+                  return true;
+                };
+
+                for (int iy1 = iy - 1; iy1 >= 0 && !update(iy1, iz); iy1--) {
+                }
+                for (int iy1 = iy + 1; iy1 < nY2Xbins && !update(iy1, iz); iy1++) {
+                }
+                for (int iz1 = iz - 1; iz1 >= 0 && !update(iy, iz1); iz1--) {
+                }
+                for (int iz1 = iz + 1; iz1 < nZ2Xbins && !update(iy, iz1); iz1++) {
+                }
 
-        auto& info = correction.getRocRowInfo(iRoc, iRow);
-        const auto& spline = correction.getSpline(iRoc, iRow);
+                if (filled) {
+                  data.mCx /= w;
+                  data.mCy /= w;
+                  data.mCz /= w;
+                  vox.mSmoothingStep = ismooth;
+                }
+              } // iz
+            } // iy
+          } // ismooth
 
-        auto addEdge = [&](int iy1, int iz1, int iy2, int iz2, int nSteps) {
-          auto& data1 = vRocData[iRoc * nRows + iRow][iy1 * nZ2Xbins + iz1];
-          auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
-          auto& data2 = vRocData[iRoc * nRows + iRow][iy2 * nZ2Xbins + iz2];
-          auto& vox2 = vRowVoxels[iy2 * nZ2Xbins + iz2];
-          if (vox1.mSmoothingStep > 2) {
-            LOG(fatal) << "empty voxel is not repared: y " << iy1 << " z " << iz1;
-          }
-          if (vox2.mSmoothingStep > 2) {
-            LOG(fatal) << "empty voxel is not repared: y " << iy2 << " z " << iz2;
-          }
-          double y1 = vox1.mY;
-          double z1 = vox1.mZ;
-          double cx1 = data1.mCx;
-          double cy1 = data1.mCy;
-          double cz1 = data1.mCz;
-          double y2 = vox2.mY;
-          double z2 = vox2.mZ;
-          double cx2 = data2.mCx;
-          double cy2 = data2.mCy;
-          double cz2 = data2.mCz;
-
-          for (int is = 0; is < nSteps; is++) {
-            double s2 = is / (double)nSteps;
-            double s1 = 1. - s2;
-            double y = s1 * y1 + s2 * y2;
-            double z = s1 * z1 + s2 * z2;
-            double cx = s1 * cx1 + s2 * cx2;
-            double cy = s1 * cy1 + s2 * cy2;
-            double cz = s1 * cz1 + s2 * cz2;
-            map.addCorrectionPoint(iRoc, iRow, y, z, cx, cy, cz);
+          if (nRepairs > 0) {
+            LOG(debug) << "Sector " << iSector << " row " << iRow << ": " << nRepairs << " voxel repairs for " << nY2Xbins * nZ2Xbins << " voxels";
           }
-        };
 
-        for (int iy = 0; iy < nY2Xbins; iy++) {
-          for (int iz = 0; iz < nZ2Xbins - 1; iz++) {
-            addEdge(iy, iz, iy, iz + 1, 3);
-          }
-          addEdge(iy, nZ2Xbins - 1, iy, nZ2Xbins - 1, 1);
-        }
+          // feed the row data to the helper
 
-        for (int iz = 0; iz < nZ2Xbins; iz++) {
-          for (int iy = 0; iy < nY2Xbins - 1; iy++) {
-            addEdge(iy, iz, iy + 1, iz, 3);
-          }
-          addEdge(nY2Xbins - 1, iz, nY2Xbins - 1, iz, 1);
-        } // iy
+          auto& info = correction.getSectorRowInfo(iSector, iRow);
+          const auto& spline = correction.getSpline(iSector, iRow);
 
-      } // iRow
-    };  // myThread
+          auto addEdge = [&](int iy1, int iz1, int iy2, int iz2, int nSteps) {
+            auto& data1 = vSectorData[iSector * nRows + iRow][iy1 * nZ2Xbins + iz1];
+            auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
+            auto& data2 = vSectorData[iSector * nRows + iRow][iy2 * nZ2Xbins + iz2];
+            auto& vox2 = vRowVoxels[iy2 * nZ2Xbins + iz2];
+            if (vox1.mSmoothingStep > 2) {
+              LOG(fatal) << "empty voxel is not repared: y " << iy1 << " z " << iz1;
+            }
+            if (vox2.mSmoothingStep > 2) {
+              LOG(fatal) << "empty voxel is not repared: y " << iy2 << " z " << iz2;
+            }
+            double y1 = vox1.mY;
+            double z1 = vox1.mZ;
+            double cx1 = data1.mCx;
+            double cy1 = data1.mCy;
+            double cz1 = data1.mCz;
+            double y2 = vox2.mY;
+            double z2 = vox2.mZ;
+            double cx2 = data2.mCx;
+            double cy2 = data2.mCy;
+            double cz2 = data2.mCz;
+
+            for (int is = 0; is < nSteps; is++) {
+              double s2 = is / (double)nSteps;
+              double s1 = 1. - s2;
+              double y = s1 * y1 + s2 * y2;
+              double z = s1 * z1 + s2 * z2;
+              double cx = s1 * cx1 + s2 * cx2;
+              double cy = s1 * cy1 + s2 * cy2;
+              double cz = s1 * cz1 + s2 * cz2;
+              map.addCorrectionPoint(iSector, iRow, y, z, cx, cy, cz);
+            }
+          };
 
-    // run n threads
+          for (int iy = 0; iy < nY2Xbins; iy++) {
+            for (int iz = 0; iz < nZ2Xbins - 1; iz++) {
+              addEdge(iy, iz, iy, iz + 1, 3);
+            }
+            addEdge(iy, nZ2Xbins - 1, iy, nZ2Xbins - 1, 1);
+          }
 
-    int nThreads = mNthreads;
-    // nThreads = 1;
+          for (int iz = 0; iz < nZ2Xbins; iz++) {
+            for (int iy = 0; iy < nY2Xbins - 1; iy++) {
+              addEdge(iy, iz, iy + 1, iz, 3);
+            }
+            addEdge(nY2Xbins - 1, iz, nY2Xbins - 1, iz, 1);
+          } // iy
 
-    std::vector<std::thread> threads(nThreads);
+        } // iRow
+      }; // myThread
 
-    for (int i = 0; i < nThreads; i++) {
-      threads[i] = std::thread(myThread, i, nThreads);
-    }
+      // run n threads
 
-    // wait for the threads to finish
-    for (auto& th : threads) {
-      th.join();
-    }
-  } // iRoc
+      int nThreads = mNthreads;
+      // nThreads = 1;
 
-  LOGP(info, "Reading & reparing of the track residuals tooks: {}s", watch3.RealTime());
+      std::vector<std::thread> threads(nThreads);
 
-  LOG(info) << "fast space charge correction helper: create space charge from the map of data points..";
+      for (int i = 0; i < nThreads; i++) {
+        threads[i] = std::thread(myThread, i, nThreads);
+      }
 
-  TStopwatch watch4;
+      // wait for the threads to finish
+      for (auto& th : threads) {
+        th.join();
+      }
+    } // iSector
 
-  helper->fillSpaceChargeCorrectionFromMap(correction);
+    LOGP(info, "Reading & reparing of the track residuals tooks: {}s", watch3.RealTime());
 
-  LOG(info) << "fast space charge correction helper: creation from the data map took " << watch4.RealTime() << "s";
+    LOG(info) << "fast space charge correction helper: create space charge from the map of data points..";
 
-  LOGP(info, "Creation from track residuals tooks in total: {}s", watch.RealTime());
+    TStopwatch watch4;
 
-  return std::move(correctionPtr);
-}
+    helper->fillSpaceChargeCorrectionFromMap(correction, processingInverseCorrection);
 
-void TPCFastSpaceChargeCorrectionHelper::initMaxDriftLength(o2::gpu::TPCFastSpaceChargeCorrection& correction, bool prn)
-{
-  /// initialise max drift length
+    LOG(info) << "fast space charge correction helper: creation from the data map took " << watch4.RealTime() << "s";
 
-  double tpcR2min = mGeo.getRowInfo(0).x - 1.;
-  tpcR2min = tpcR2min * tpcR2min;
-  double tpcR2max = mGeo.getRowInfo(mGeo.getNumberOfRows() - 1).x;
-  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfRocsA() / 2) + 1.;
-  tpcR2max = tpcR2max * tpcR2max;
+  } // processingInverseCorrection
 
-  ChebyshevFit1D chebFitter;
+  if (voxResTree && !voxResTreeInverse) {
+    LOG(info) << "fast space charge correction helper: init inverse correction from direct correction..";
+    TStopwatch watch4;
+    helper->initInverse(correction, false);
+    LOG(info) << "fast space charge correction helper: init inverse correction took " << watch4.RealTime() << "s";
+  }
 
-  for (int roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
-    if (prn) {
-      LOG(info) << "init MaxDriftLength for roc " << roc;
-    }
-    double vLength = mGeo.getTPCzLength();
-    TPCFastSpaceChargeCorrection::RocInfo& rocInfo = correction.getRocInfo(roc);
-    rocInfo.vMax = 0.f;
+  LOGP(info, "Creation from track residuals tooks in total: {}s", watch.RealTime());
 
-    for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
-      TPCFastSpaceChargeCorrection::RowActiveArea& area = correction.getRocRowInfo(roc, row).activeArea;
-      area.cvMax = 0;
-      area.vMax = 0;
-      area.cuMin = mGeo.convPadToU(row, 0.f);
-      area.cuMax = -area.cuMin;
-      chebFitter.reset(4, 0., mGeo.getRowInfo(row).maxPad);
-      double x = mGeo.getRowInfo(row).x;
-      for (int pad = 0; pad < mGeo.getRowInfo(row).maxPad; pad++) {
-        float u = mGeo.convPadToU(row, (float)pad);
-        float v0 = 0;
-        float v1 = 1.1 * vLength;
-        float vLastValid = -1;
-        float cvLastValid = -1;
-        while (v1 - v0 > 0.1) {
-          float v = 0.5 * (v0 + v1);
-          float dx, du, dv;
-          correction.getCorrectionInternal(roc, row, u, v, dx, du, dv);
-          double cx = x + dx;
-          double cu = u + du;
-          double cv = v + dv;
-          double r2 = cx * cx + cu * cu;
-          if (cv < 0) {
-            v0 = v;
-          } else if (cv <= vLength && r2 >= tpcR2min && r2 <= tpcR2max) {
-            v0 = v;
-            vLastValid = v;
-            cvLastValid = cv;
-          } else {
-            v1 = v;
-          }
-        }
-        if (vLastValid > 0.) {
-          chebFitter.addMeasurement(pad, vLastValid);
-        }
-        if (area.vMax < vLastValid) {
-          area.vMax = vLastValid;
-        }
-        if (area.cvMax < cvLastValid) {
-          area.cvMax = cvLastValid;
-        }
-      }
-      chebFitter.fit();
-      for (int i = 0; i < 5; i++) {
-        area.maxDriftLengthCheb[i] = chebFitter.getCoefficients()[i];
-      }
-      if (rocInfo.vMax < area.vMax) {
-        rocInfo.vMax = area.vMax;
-      }
-    } // row
-  } // roc
-}
+  return std::move(correctionPtr);
+
+} // createFromTrackResiduals
 
 void TPCFastSpaceChargeCorrectionHelper::initInverse(o2::gpu::TPCFastSpaceChargeCorrection& correction, bool prn)
 {
@@ -893,28 +839,24 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
   }
 
   auto& correction = *(corrections.front());
-  initMaxDriftLength(correction, prn);
 
   double tpcR2min = mGeo.getRowInfo(0).x - 1.;
   tpcR2min = tpcR2min * tpcR2min;
   double tpcR2max = mGeo.getRowInfo(mGeo.getNumberOfRows() - 1).x;
-  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfRocsA() / 2) + 1.;
+  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfSectorsA() / 2) + 1.;
   tpcR2max = tpcR2max * tpcR2max;
 
-  for (int roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
-    // LOG(info) << "inverse transform for roc " << roc ;
+  for (int sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
+    // LOG(info) << "inverse transform for sector " << sector ;
 
     auto myThread = [&](int iThread) {
       Spline2DHelper<float> helper;
       std::vector<float> splineParameters;
 
       for (int row = iThread; row < mGeo.getNumberOfRows(); row += mNthreads) {
-        TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(roc, row);
+        TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(sector, row);
         helper.setSpline(spline, 10, 10);
 
-        double x = mGeo.getRowInfo(row).x;
-        auto& rocRowInfo = correction.getRocRowInfo(roc, row);
-
         std::vector<double> gridU;
         {
           const auto& grid = spline.getGridX1();
@@ -942,95 +884,64 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
           }
         }
 
-        std::vector<double> dataPointCU, dataPointCV, dataPointF;
-        dataPointCU.reserve(gridU.size() * gridV.size());
-        dataPointCV.reserve(gridU.size() * gridV.size());
-        dataPointF.reserve(gridU.size() * gridV.size());
-
-        TPCFastSpaceChargeCorrection::RowActiveArea& area = rocRowInfo.activeArea;
-        area.cuMin = 1.e10;
-        area.cuMax = -1.e10;
-        double cvMin = 1.e10;
+        std::vector<double> dataPointGridU, dataPointGridV, dataPointF;
+        dataPointGridU.reserve(gridU.size() * gridV.size());
+        dataPointGridV.reserve(gridU.size() * gridV.size());
+        dataPointF.reserve(3 * gridU.size() * gridV.size());
 
         for (int iu = 0; iu < gridU.size(); iu++) {
           for (int iv = 0; iv < gridV.size(); iv++) {
-            float u, v;
-            correction.convGridToUV(roc, row, gridU[iu], gridV[iv], u, v);
-
-            float dx, du, dv;
-            correction.getCorrectionInternal(roc, row, u, v, dx, du, dv);
-            dx *= scaling[0];
-            du *= scaling[0];
-            dv *= scaling[0];
-            // add remaining corrections
-            for (int i = 1; i < corrections.size(); ++i) {
-              float dxTmp, duTmp, dvTmp;
-              corrections[i]->getCorrectionInternal(roc, row, u, v, dxTmp, duTmp, dvTmp);
+
+            auto [y, z] = correction.convGridToLocal(sector, row, gridU[iu], gridV[iv]);
+            double dx = 0, dy = 0, dz = 0;
+
+            // add corrections
+            for (int i = 0; i < corrections.size(); ++i) {
+              auto [dxTmp, dyTmp, dzTmp] = corrections[i]->getCorrectionLocal(sector, row, y, z);
               dx += dxTmp * scaling[i];
-              du += duTmp * scaling[i];
-              dv += dvTmp * scaling[i];
-            }
-            double cx = x + dx;
-            double cu = u + du;
-            double cv = v + dv;
-            if (cu < area.cuMin) {
-              area.cuMin = cu;
-            }
-            if (cu > area.cuMax) {
-              area.cuMax = cu;
+              dy += dyTmp * scaling[i];
+              dz += dzTmp * scaling[i];
             }
 
-            dataPointCU.push_back(cu);
-            dataPointCV.push_back(cv);
+            double realY = y + dy;
+            double realZ = z + dz;
+            float realU, realV;
+            mGeo.convLocalToUV1(sector, realY, realZ, realU, realV);
+
+            dataPointGridU.push_back(realU);
+            dataPointGridV.push_back(realV);
             dataPointF.push_back(dx);
-            dataPointF.push_back(du);
-            dataPointF.push_back(dv);
+            dataPointF.push_back(dy);
+            dataPointF.push_back(dz);
           }
         }
 
-        if (area.cuMax - area.cuMin < 0.2) {
-          area.cuMax = .1;
-          area.cuMin = -.1;
-        }
-        if (area.cvMax - cvMin < 0.2) {
-          area.cvMax = .1;
-          cvMin = -.1;
-        }
-
-        if (prn) {
-          LOG(info) << "roc " << roc << " row " << row << " max drift L = " << correction.getMaxDriftLength(roc, row)
-                    << " active area: cuMin " << area.cuMin << " cuMax " << area.cuMax << " vMax " << area.vMax << " cvMax " << area.cvMax;
-        }
-
         // define the grid for the inverse correction
 
-        rocRowInfo.gridCorrU0 = area.cuMin;
-        rocRowInfo.gridCorrV0 = cvMin;
-        rocRowInfo.scaleCorrUtoGrid = spline.getGridX1().getUmax() / (area.cuMax - area.cuMin);
-        rocRowInfo.scaleCorrVtoGrid = spline.getGridX2().getUmax() / area.cvMax;
+        auto& sectorRowInfo = correction.getSectorRowInfo(sector, row);
+
+        sectorRowInfo.gridCorrU0 = sectorRowInfo.gridU0;
+        sectorRowInfo.gridCorrV0 = sectorRowInfo.gridV0;
+        sectorRowInfo.scaleCorrUtoGrid = sectorRowInfo.scaleUtoGrid;
+        sectorRowInfo.scaleCorrVtoGrid = sectorRowInfo.scaleVtoGrid;
 
-        /*
-        rocRowInfo.gridCorrU0 = rocRowInfo.gridU0;
-        rocRowInfo.gridCorrV0 = rocRowInfo.gridV0;
-        rocRowInfo.scaleCorrUtoGrid = rocRowInfo.scaleUtoGrid;
-        rocRowInfo.scaleCorrVtoGrid = rocRowInfo.scaleVtoGrid;
-        */
+        int nDataPoints = dataPointGridU.size();
 
-        int nDataPoints = dataPointCU.size();
+        // convert real Y,Z to grid U,V
         for (int i = 0; i < nDataPoints; i++) {
-          dataPointCU[i] = (dataPointCU[i] - rocRowInfo.gridCorrU0) * rocRowInfo.scaleCorrUtoGrid;
-          dataPointCV[i] = (dataPointCV[i] - rocRowInfo.gridCorrV0) * rocRowInfo.scaleCorrVtoGrid;
+          dataPointGridU[i] = (dataPointGridU[i] - sectorRowInfo.gridCorrU0) * sectorRowInfo.scaleCorrUtoGrid;
+          dataPointGridV[i] = (dataPointGridV[i] - sectorRowInfo.gridCorrV0) * sectorRowInfo.scaleCorrVtoGrid;
         }
 
         splineParameters.resize(spline.getNumberOfParameters());
 
         helper.approximateDataPoints(spline, splineParameters.data(), 0., spline.getGridX1().getUmax(),
                                      0., spline.getGridX2().getUmax(),
-                                     dataPointCU.data(), dataPointCV.data(),
-                                     dataPointF.data(), dataPointCU.size());
+                                     dataPointGridU.data(), dataPointGridV.data(),
+                                     dataPointF.data(), nDataPoints);
 
-        float* splineX = correction.getSplineData(roc, row, 1);
-        float* splineUV = correction.getSplineData(roc, row, 2);
+        float* splineX = correction.getSplineData(sector, row, 1);
+        float* splineUV = correction.getSplineData(sector, row, 2);
         for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
           splineX[i] = splineParameters[3 * i + 0];
           splineUV[2 * i + 0] = splineParameters[3 * i + 1];
@@ -1051,10 +962,100 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
       th.join();
     }
 
-  } // roc
+  } // sector
   float duration = watch.RealTime();
   LOGP(info, "Inverse tooks: {}s", duration);
 }
 
+void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(std::vector<o2::gpu::TPCFastSpaceChargeCorrection*>& corrections, const std::vector<float>& scaling, bool prn)
+{
+  /// merge several corrections
+  /*
+  TStopwatch watch;
+  LOG(info) << "fast space charge correction helper: Merge corrections";
+
+  if (corrections.size() != scaling.size()) {
+    LOGP(error, "Input corrections and scaling values have different size");
+    return;
+  }
+
+  auto& correction = *(corrections.front());
+
+  for (int sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
+
+    auto myThread = [&](int iThread) {
+      for (int row = iThread; row < mGeo.getNumberOfRows(); row += mNthreads) {
+        TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(sector, row);
+
+        std::vector<float> splineParameters(spline.getNumberOfParameters());
+        std::vector<float> splineParametersInvX(spline.getNumberOfParameters());
+        std::vector<float> splineParametersInvYZ(spline.getNumberOfParameters());
+
+        const auto& gridU = spline.getGridX1();
+        const auto& gridV = spline.getGridX2();
+
+        for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
+          double u = gridU.getKnot(iu).u;
+          for (int iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
+            int knotIndex = spline.getKnotIndex(iu, iv);
+
+            double v = gridV.getKnot(iu).u;
+            auto [y, z] = correction.convGridToLocal(sector, row, u, v);
+            constexpr int nKnotPar1d = 4;
+            constexpr int nKnotPar2d = nKnotPar1d * 2;
+            constexpr int nKnotPar3d = nKnotPar1d * 3;
+
+            for (int i = 0; i < corrections.size(); ++i) {
+              double s = scaling[i];
+              auto p = corrections[i]->getCorrectionParameters(sector, row, y, z);
+              for (int j = 0; j < nKnotPar3d; ++j) {
+                splineParameters[knotIndex * nKnotPar3d + j] += s * p[j];
+              }
+              auto pInvX = corrections[i]->getCorrectionParametersInvX(sector, row, y, z);
+              for (int j = 0; j < nKnotPar1d; ++j) {
+                splineParametersInvX[knotIndex * nKnotPar1d + j] += s * pInvX[j];
+              }
+              auto pInvYZ = corrections[i]->getCorrectionParametersInvYZ(sector, row, y, z);
+              for (int j = 0; j < nKnotPar2d; ++j) {
+                splineParametersInvYZ[knotIndex * nKnotPar2d + j] += s * pInvYZ[j];
+              }
+            }
+          } // iv
+        }   // iu
+
+        float* splineXYZ = correction.getSplineData(sector, row, 0);
+        float* splineInvX = correction.getSplineData(sector, row, 1);
+        float* splineInvYZ = correction.getSplineData(sector, row, 2);
+
+        for (int i = 0; i < spline.getNumberOfParameters(); i++) {
+          splineXYZ[i] = splineParameters[i];
+        }
+        for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
+          splineX[i] = splineParametersInvX[i];
+          splineYZ[2 * i + 0] = splineParametersInvYZ[2 * i + 0];
+          splineYZ[2 * i + 1] = splineParametersInvYZ[2 * i + 1];
+        }
+
+      } // row
+    };  // thread
+
+    std::vector<std::thread> threads(mNthreads);
+
+    // run n threads
+    for (int i = 0; i < mNthreads; i++) {
+      threads[i] = std::thread(myThread, i);
+    }
+
+    // wait for the threads to finish
+    for (auto& th : threads) {
+      th.join();
+    }
+
+  } // sector
+  float duration = watch.RealTime();
+  LOGP(info, "Merge of corrections tooks: {}s", duration);
+  */
+}
+
 } // namespace tpc
 } // namespace o2
diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index c83ee6d0cfa19..a6a2c9722caeb 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -177,8 +177,8 @@ void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) cons
 {
   const Mapper& mapper = Mapper::instance();
 
-  if (geo.getNumberOfRocs() != Sector::MAXSECTOR) {
-    LOG(fatal) << "Wrong number of sectors :" << geo.getNumberOfRocs() << " instead of " << Sector::MAXSECTOR << std::endl;
+  if (geo.getNumberOfSectors() != Sector::MAXSECTOR) {
+    LOG(fatal) << "Wrong number of sectors :" << geo.getNumberOfSectors() << " instead of " << Sector::MAXSECTOR << std::endl;
   }
 
   if (geo.getNumberOfRows() != mapper.getNumberOfRows()) {
diff --git a/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx b/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
index 53cfe08f3a7f4..fee63e9e38bc2 100644
--- a/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
+++ b/Detectors/TPC/reconstruction/test/testTPCFastTransform.cxx
@@ -53,7 +53,7 @@ BOOST_AUTO_TEST_CASE(FastTransform_test1)
 
   BOOST_CHECK_EQUAL(geo.test(), 0);
 
-  BOOST_CHECK_EQUAL(geo.getNumberOfRocs(), Sector::MAXSECTOR);
+  BOOST_CHECK_EQUAL(geo.getNumberOfSectors(), Sector::MAXSECTOR);
   BOOST_CHECK_EQUAL(geo.getNumberOfRows(), mapper.getNumberOfRows());
 
   double maxDx = 0, maxDy = 0;
@@ -71,15 +71,16 @@ BOOST_AUTO_TEST_CASE(FastTransform_test1)
     for (int pad = 0; pad < nPads; pad++) {
       const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
       const PadCentre& c = mapper.padCentre(p);
-      float u = 0, v = 0;
-      fastTransform.convPadTimeToUV(row, pad, 0, u, v, 0.);
-
+      float y = 0, z = 0;
+      int sector = 0;
+      float time = 0.;
+      fastTransform.convPadTimeToLocal(sector, row, pad, time, y, z, 0.);
       double dx = x - c.X();
-      double dy = u - (-c.Y()); // diferent sign convention for Y coordinate in the map
+      double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map
       BOOST_CHECK(fabs(dx) < 1.e-6);
       BOOST_CHECK(fabs(dy) < 1.e-5);
       if (fabs(dy) >= 1.e-5) {
-        std::cout << "row " << row << " pad " << pad << " y calc " << u << " y in map " << -c.Y() << " dy " << dy << std::endl;
+        std::cout << "row " << row << " pad " << pad << " y calc " << y << " y in map " << -c.Y() << " dy " << dy << std::endl;
       }
       if (fabs(maxDx) < fabs(dx)) {
         maxDx = dx;
@@ -104,46 +105,46 @@ BOOST_AUTO_TEST_CASE(FastTransform_test_setSpaceChargeCorrection)
   std::unique_ptr<TPCFastTransform> fastTransform0(TPCFastTransformHelperO2::instance()->create(0));
   const TPCFastTransformGeo& geo = fastTransform0->getGeometry();
 
-  auto correctionUV = [&](int roc, int /*row*/, const double u, const double v, double& dX, double& dU, double& dV) {
+  auto correctionUV = [&](int sector, int /*row*/, const double u, const double v, double& dX, double& dU, double& dV) {
     // float lx = geo.getRowInfo(row).x;
     dX = 1. + 1 * u + 0.1 * u * u;
     dU = 2. + 0.2 * u + 0.002 * u * u; // + 0.001 * u * u * u;
     dV = 3. + 0.1 * v + 0.01 * v * v;  //+ 0.0001 * v * v * v;
   };
 
-  auto correctionLocal = [&](int roc, int row, double ly, double lz,
+  auto correctionLocal = [&](int sector, int row, double ly, double lz,
                              double& dx, double& dly, double& dlz) {
     float u, v;
-    geo.convLocalToUV(roc, ly, lz, u, v);
+    geo.convLocalToUV(sector, ly, lz, u, v);
     double du, dv;
-    correctionUV(roc, row, u, v, dx, du, dv);
+    correctionUV(sector, row, u, v, dx, du, dv);
     float ly1, lz1;
-    geo.convUVtoLocal(roc, u + du, v + dv, ly1, lz1);
+    geo.convUVtoLocal(sector, u + du, v + dv, ly1, lz1);
     dly = ly1 - ly;
     dlz = lz1 - lz;
   };
 
-  int nRocs = geo.getNumberOfRocs();
+  int nSectors = geo.getNumberOfSectors();
   int nRows = geo.getNumberOfRows();
   TPCFastSpaceChargeCorrectionMap& scData = TPCFastTransformHelperO2::instance()->getCorrectionMap();
-  scData.init(nRocs, nRows);
+  scData.init(nSectors, nRows);
 
-  for (int iRoc = 0; iRoc < nRocs; iRoc++) {
+  for (int iSector = 0; iSector < nSectors; iSector++) {
     for (int iRow = 0; iRow < nRows; iRow++) {
       double dsu = 1. / (3 * 8 - 3);
       double dsv = 1. / (3 * 20 - 3);
       for (double su = 0.f; su < 1.f + .5 * dsu; su += dsv) {
         for (double sv = 0.f; sv < 1.f + .5 * dsv; sv += dsv) {
           float ly = 0.f, lz = 0.f;
-          geo.convScaledUVtoLocal(iRoc, iRow, su, sv, ly, lz);
+          geo.convScaledUVtoLocal(iSector, iRow, su, sv, ly, lz);
           double dx, dy, dz;
-          correctionLocal(iRoc, iRow, ly, lz, dx, dy, dz);
-          scData.addCorrectionPoint(iRoc, iRow,
+          correctionLocal(iSector, iRow, ly, lz, dx, dy, dz);
+          scData.addCorrectionPoint(iSector, iRow,
                                     ly, lz, dx, dy, dz);
         }
       }
     } // row
-  } // roc
+  } // sector
 
   std::unique_ptr<TPCFastTransform> fastTransform(TPCFastTransformHelperO2::instance()->create(0));
 
@@ -158,12 +159,12 @@ BOOST_AUTO_TEST_CASE(FastTransform_test_setSpaceChargeCorrection)
   double statDiff = 0., statN = 0.;
   double statDiffFile = 0., statNFile = 0.;
 
-  for (int roc = 0; roc < geo.getNumberOfRocs(); roc += 1) {
-    // std::cout << "roc " << roc << " ... " << std::endl;
+  for (int sector = 0; sector < geo.getNumberOfSectors(); sector += 1) {
+    // std::cout << "sector " << sector << " ... " << std::endl;
 
-    const TPCFastTransformGeo::RocInfo& rocInfo = geo.getRocInfo(roc);
+    const TPCFastTransformGeo::SectorInfo& sectorInfo = geo.getSectorInfo(sector);
 
-    float lastTimeBin = fastTransform->getMaxDriftTime(roc, 0.f);
+    float lastTimeBin = fastTransform->getMaxDriftTime(sector, 0.f);
 
     for (int row = 0; row < geo.getNumberOfRows(); row++) {
 
@@ -172,31 +173,31 @@ BOOST_AUTO_TEST_CASE(FastTransform_test_setSpaceChargeCorrection)
       for (int pad = 0; pad < nPads; pad += 10) {
 
         for (float time = 0; time < lastTimeBin; time += 30) {
-          // std::cout<<"roc "<<roc<<" row "<<row<<" pad "<<pad<<" time "<<time<<std::endl;
+          // std::cout<<"sector "<<sector<<" row "<<row<<" pad "<<pad<<" time "<<time<<std::endl;
 
           fastTransform->setApplyCorrectionOff();
           float x0, y0, z0;
-          fastTransform->Transform(roc, row, pad, time, x0, y0, z0);
+          fastTransform->Transform(sector, row, pad, time, x0, y0, z0);
 
-          BOOST_CHECK_EQUAL(geo.test(roc, row, y0, z0), 0);
+          BOOST_CHECK_EQUAL(geo.test(sector, row, y0, z0), 0);
 
           fastTransform->setApplyCorrectionOn();
           float x1, y1, z1;
-          fastTransform->Transform(roc, row, pad, time, x1, y1, z1);
+          fastTransform->Transform(sector, row, pad, time, x1, y1, z1);
 
           // local to UV
           float u0, v0, u1, v1;
-          geo.convLocalToUV(roc, y0, z0, u0, v0);
-          geo.convLocalToUV(roc, y1, z1, u1, v1);
+          geo.convLocalToUV(sector, y0, z0, u0, v0);
+          geo.convLocalToUV(sector, y1, z1, u1, v1);
           double dx, du, dv;
-          correctionUV(roc, row, u0, v0, dx, du, dv);
+          correctionUV(sector, row, u0, v0, dx, du, dv);
           statDiff += fabs((x1 - x0) - dx) + fabs((u1 - u0) - du) + fabs((v1 - v0) - dv);
           statN += 3;
           // std::cout << (x1 - x0) - dx << " " << (u1 - u0) - du << " " << (v1 - v0) - dv << std::endl; //": v0 " << v0 <<" z0 "<<z0<<" v1 "<< v1<<" z1 "<<z1 << std::endl;
           // BOOST_CHECK_MESSAGE(0, "SG");
 
           float x1f, y1f, z1f;
-          fromFile->Transform(roc, row, pad, time, x1f, y1f, z1f);
+          fromFile->Transform(sector, row, pad, time, x1f, y1f, z1f);
           statDiffFile += fabs(x1f - x1) + fabs(y1f - y1) + fabs(z1f - z1);
           statNFile += 3;
         }
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index dc59e77e308a1..2cc95ebdcab9f 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -369,7 +369,41 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     dDr = v * a;
     // F(u) = dSl * Sl + dSr * Sr + dDl * Dl + dDr * Dr;
   }
-
+  /*
+    template <typename T>
+    GPUd() void getUsecondDerivatives(const Knot& knotL, DataT u,
+                                      T& dSl, T& dDl, T& dSr, T& dDr,
+                                      T& dSl2, T& dDl2, T& dSr2, T& dDr2) const
+    {
+      /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
+      /// over the spline values Sl, Sr and the slopes Dl, Dr
+
+      if (u < (DataT)0) {
+        u = (DataT)0;
+      }
+      if (u > (DataT)TBase::getUmax()) {
+        u = (DataT)TBase::getUmax();
+      }
+
+      u = u - knotL.u;
+      T v = u * T(knotL.Li); // scaled u
+      T vm1 = v - 1.;
+      T a = u * vm1;
+      T v2 = v * v;
+      dSr = v2 * (3. - 2 * v);
+      dSl = 1. - dSr;
+      dDl = vm1 * a;
+      dDr = v * a;
+      T dv = T(knotL.Li);
+      dSr2 = 6. * v * (1. - v) * dv;
+      dSl2 = -dSr2;
+      dDl2 = (v - 1) * (3 * v - 1);
+      dDr = u * (v * v - v);
+      dDr2 = 3.f * v * v - 2.f * v;
+      // F(u) = dSl * Sl + dSr * Sr + dDl * Dl + dDr * Dr;
+      // dF(u)/du = dSl2 * Sl + dSr2 * Sr + dDl2 * Dl + dDr2 * Dr;
+    }
+  */
   using TBase::convXtoU;
   using TBase::getKnot;
   using TBase::getKnots;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 111e70072c58e..2921a74b025ce 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -35,7 +35,7 @@ TPCFastSpaceChargeCorrection::TPCFastSpaceChargeCorrection()
     mScenarioPtr(nullptr),
     mTimeStamp(-1),
     mSplineData{nullptr, nullptr, nullptr},
-    mRocDataSizeBytes{0, 0, 0}
+    mSectorDataSizeBytes{0, 0, 0}
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -64,7 +64,7 @@ void TPCFastSpaceChargeCorrection::destroy()
   mTimeStamp = -1;
   for (int32_t is = 0; is < 3; is++) {
     mSplineData[is] = nullptr;
-    mRocDataSizeBytes[is] = 0;
+    mSectorDataSizeBytes[is] = 0;
   }
   FlatObject::destroy();
 }
@@ -101,13 +101,13 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
 
   mTimeStamp = obj.mTimeStamp;
 
-  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfRocs(); ++i) {
-    mRocInfo[i] = obj.mRocInfo[i];
+  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfSectors(); ++i) {
+    mSectorInfo[i] = obj.mSectorInfo[i];
   }
 
-  mRocDataSizeBytes[0] = obj.mRocDataSizeBytes[0];
-  mRocDataSizeBytes[1] = obj.mRocDataSizeBytes[1];
-  mRocDataSizeBytes[2] = obj.mRocDataSizeBytes[2];
+  mSectorDataSizeBytes[0] = obj.mSectorDataSizeBytes[0];
+  mSectorDataSizeBytes[1] = obj.mSectorDataSizeBytes[1];
+  mSectorDataSizeBytes[2] = obj.mSectorDataSizeBytes[2];
 
   // variable-size data
   mScenarioPtr = obj.mScenarioPtr;
@@ -121,8 +121,8 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
     mRowInfos[i] = obj.mRowInfos[i];
   }
 
-  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfRocs() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
-    mRocRowInfos[i] = obj.mRocRowInfos[i];
+  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfSectors() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
+    mSectorRowInfos[i] = obj.mSectorRowInfos[i];
   }
 
   relocateBufferPointers(oldFlatBufferPtr, mFlatBufferPtr);
@@ -143,7 +143,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
 
   struct RowInfoVersion3 {
     int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
-    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC roc
+    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC sector
   };
 
   struct RowActiveAreaVersion3 {
@@ -154,7 +154,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     float cvMax{0.f};
   };
 
-  struct RocRowInfoVersion3 {
+  struct SectorRowInfoVersion3 {
     float gridV0{0.f};           ///< V coordinate of the V-grid start
     float gridCorrU0{0.f};       ///< U coordinate of the U-grid start for corrected U
     float gridCorrV0{0.f};       ///< V coordinate of the V-grid start for corrected V
@@ -171,13 +171,13 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     rowsSize = sizeof(RowInfoVersion3) * mGeo.getNumberOfRows();
   }
 
-  size_t rocRowsOffset = rowsOffset + rowsSize;
-  size_t rocRowsSize = 0;
-  if (mClassVersion == 3) { // copy old-format rocrow data from the buffer to the arrays
-    rocRowsSize = sizeof(RocRowInfoVersion3) * mGeo.getNumberOfRows() * mGeo.getNumberOfRocs();
+  size_t sectorRowsOffset = rowsOffset + rowsSize;
+  size_t sectorRowsSize = 0;
+  if (mClassVersion == 3) { // copy old-format sectorrow data from the buffer to the arrays
+    sectorRowsSize = sizeof(SectorRowInfoVersion3) * mGeo.getNumberOfRows() * mGeo.getNumberOfSectors();
   }
 
-  size_t scOffset = alignSize(rocRowsOffset + rocRowsSize, SplineType::getClassAlignmentBytes());
+  size_t scOffset = alignSize(sectorRowsOffset + sectorRowsSize, SplineType::getClassAlignmentBytes());
   size_t scSize = sizeof(SplineType) * mNumberOfScenarios;
 
   mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr + scOffset);
@@ -192,12 +192,12 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
   }
   size_t bufferSize = scBufferOffset + scBufferSize;
   for (int32_t is = 0; is < 3; is++) {
-    size_t rocDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + rocDataOffset);
-    bufferSize = rocDataOffset + mRocDataSizeBytes[is] * mGeo.getNumberOfRocs();
+    size_t sectorDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + sectorDataOffset);
+    bufferSize = sectorDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
   }
 
-  if (mClassVersion == 3) { // copy old-format rocrow data from the buffer to the arrays
+  if (mClassVersion == 3) { // copy old-format sectorrow data from the buffer to the arrays
 
     auto* rowInfosOld = reinterpret_cast<RowInfoVersion3*>(mFlatBufferPtr + rowsOffset);
     for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
@@ -214,13 +214,13 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
       spline.setXrange(0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax());
     }
 
-    auto* rocRowInfosOld = reinterpret_cast<RocRowInfoVersion3*>(mFlatBufferPtr + rocRowsOffset);
+    auto* sectorRowInfosOld = reinterpret_cast<SectorRowInfoVersion3*>(mFlatBufferPtr + sectorRowsOffset);
 
-    for (int32_t roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
+    for (int32_t sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
       for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
-        RocRowInfoVersion3& infoOld = rocRowInfosOld[mGeo.getNumberOfRows() * roc + row];
-        RocRowInfo& info = getRocRowInfo(roc, row);
-        const auto& spline = getSpline(roc, row);
+        SectorRowInfoVersion3& infoOld = sectorRowInfosOld[mGeo.getNumberOfRows() * sector + row];
+        SectorRowInfo& info = getSectorRowInfo(sector, row);
+        const auto& spline = getSpline(sector, row);
         info.gridU0 = mGeo.getRowInfo(row).u0;
         info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
 
@@ -232,14 +232,6 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
 
         info.gridCorrV0 = infoOld.gridCorrV0;
         info.scaleCorrVtoGrid = infoOld.scaleCorrVtoGrid;
-
-        info.activeArea.vMax = infoOld.activeArea.vMax;
-        info.activeArea.cuMin = infoOld.activeArea.cuMin;
-        info.activeArea.cuMax = infoOld.activeArea.cuMax;
-        info.activeArea.cvMax = infoOld.activeArea.cvMax;
-        for (int32_t i = 0; i < 5; i++) {
-          info.activeArea.maxDriftLengthCheb[i] = infoOld.activeArea.maxDriftLengthCheb[i];
-        }
       }
     }
   }
@@ -276,7 +268,7 @@ void TPCFastSpaceChargeCorrection::print() const
   mGeo.print();
   LOG(info) << "  mNumberOfScenarios = " << mNumberOfScenarios;
   LOG(info) << "  mTimeStamp = " << mTimeStamp;
-  LOG(info) << "  mRocDataSizeBytes = " << mRocDataSizeBytes[0] << " " << mRocDataSizeBytes[1] << " " << mRocDataSizeBytes[2];
+  LOG(info) << "  mSectorDataSizeBytes = " << mSectorDataSizeBytes[0] << " " << mSectorDataSizeBytes[1] << " " << mSectorDataSizeBytes[2];
   {
     LOG(info) << "  TPC rows: ";
     for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
@@ -292,9 +284,9 @@ void TPCFastSpaceChargeCorrection::print() const
   }
   if (mScenarioPtr) {
     LOG(info) << " Spline Data: ";
-    for (int32_t is = 0; is < mGeo.getNumberOfRocs(); is++) {
+    for (int32_t is = 0; is < mGeo.getNumberOfSectors(); is++) {
       for (int32_t ir = 0; ir < mGeo.getNumberOfRows(); ir++) {
-        LOG(info) << "roc " << is << " row " << ir << ": ";
+        LOG(info) << "sector " << is << " row " << ir << ": ";
         const SplineType& spline = getSpline(is, ir);
         const float* d = getSplineData(is, ir);
         int32_t k = 0;
@@ -305,8 +297,8 @@ void TPCFastSpaceChargeCorrection::print() const
           LOG(info) << "";
         }
       }
-      //    LOG(info) << "inverse correction: roc " << roc
-      //            << " dx " << maxDroc[0] << " du " << maxDroc[1] << " dv " << maxDroc[2] ;
+      //    LOG(info) << "inverse correction: sector " << sector
+      //            << " dx " << maxDsector[0] << " du " << maxDsector[1] << " dv " << maxDsector[2] ;
     }
   }
 }
@@ -345,7 +337,7 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
   mScenarioPtr = nullptr;
   for (int32_t s = 0; s < 3; s++) {
     mSplineData[s] = nullptr;
-    mRocDataSizeBytes[s] = 0;
+    mSectorDataSizeBytes[s] = 0;
   }
   mClassVersion = 4;
 }
@@ -401,18 +393,18 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
     scBufferSize = alignSize(scBufferSize + sp.getFlatBufferSize(), sp.getBufferAlignmentBytes());
   }
   size_t bufferSize = scBufferOffsets[0] + scBufferSize;
-  size_t rocDataOffset[3];
+  size_t sectorDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
-    rocDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mRocDataSizeBytes[is] = 0;
+    sectorDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mSectorDataSizeBytes[is] = 0;
     for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
       RowInfo& row = mRowInfos[i];
       SplineType& spline = mConstructionScenarios[row.splineScenarioID];
-      row.dataOffsetBytes[is] = alignSize(mRocDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-      mRocDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
+      row.dataOffsetBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
+      mSectorDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
     }
-    mRocDataSizeBytes[is] = alignSize(mRocDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-    bufferSize = rocDataOffset[is] + mRocDataSizeBytes[is] * mGeo.getNumberOfRocs();
+    mSectorDataSizeBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
+    bufferSize = sectorDataOffset[is] + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
   }
 
   FlatObject::finishConstruction(bufferSize);
@@ -427,7 +419,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   }
 
   for (int32_t is = 0; is < 3; is++) {
-    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + rocDataOffset[is]);
+    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + sectorDataOffset[is]);
   }
   releaseConstructionMemory();
 
@@ -439,15 +431,15 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
 {
   // initialise all corrections to 0.
-  for (int32_t roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
+  for (int32_t sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
     double vLength = mGeo.getTPCzLength();
-    RocInfo& rocInfo = getRocInfo(roc);
-    rocInfo.vMax = vLength;
+    SectorInfo& sectorInfo = getSectorInfo(sector);
+    sectorInfo.vMax = vLength;
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
-      const SplineType& spline = getSpline(roc, row);
+      const SplineType& spline = getSpline(sector, row);
 
       for (int32_t is = 0; is < 3; is++) {
-        float* data = getSplineData(roc, row, is);
+        float* data = getSplineData(sector, row, is);
         int32_t nPar = spline.getNumberOfParameters();
         if (is == 1) {
           nPar = nPar / 3;
@@ -460,7 +452,7 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
         }
       }
 
-      RocRowInfo& info = getRocRowInfo(roc, row);
+      SectorRowInfo& info = getSectorRowInfo(sector, row);
 
       info.gridU0 = mGeo.getRowInfo(row).u0;
       info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
@@ -473,18 +465,8 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
       info.scaleCorrUtoGrid = info.scaleUtoGrid;
       info.scaleCorrVtoGrid = info.scaleVtoGrid;
 
-      RowActiveArea& area = info.activeArea;
-      for (int32_t i = 1; i < 5; i++) {
-        area.maxDriftLengthCheb[i] = 0;
-      }
-      area.maxDriftLengthCheb[0] = vLength;
-      area.cuMin = info.gridCorrU0;
-      area.cuMax = -area.cuMin;
-      area.vMax = vLength;
-      area.cvMax = vLength;
-
     } // row
-  } // roc
+  } // sector
 }
 
 void TPCFastSpaceChargeCorrection::constructWithNoCorrection(const TPCFastTransformGeo& geo)
@@ -512,31 +494,31 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
   double tpcR2min = mGeo.getRowInfo(0).x - 1.;
   tpcR2min = tpcR2min * tpcR2min;
   double tpcR2max = mGeo.getRowInfo(mGeo.getNumberOfRows() - 1).x;
-  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfRocsA() / 2) + 1.;
+  tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfSectorsA() / 2) + 1.;
   tpcR2max = tpcR2max * tpcR2max;
 
   struct MaxValue {
     double V{0.};
-    int Roc{-1};
+    int Sector{-1};
     int Row{-1};
 
-    void update(double v, int roc, int row)
+    void update(double v, int sector, int row)
     {
       if (fabs(v) > fabs(V)) {
         V = v;
-        Roc = roc;
+        Sector = sector;
         Row = row;
       }
     }
     void update(const MaxValue& other)
     {
-      update(other.V, other.Roc, other.Row);
+      update(other.V, other.Sector, other.Row);
     }
 
     std::string toString()
     {
       std::stringstream ss;
-      ss << V << "(" << Roc << "," << Row << ")";
+      ss << V << "(" << Sector << "," << Row << ")";
       return ss.str();
     }
   };
@@ -544,70 +526,75 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
   MaxValue maxDtpc[3];
   MaxValue maxD;
 
-  for (int32_t roc = 0; roc < mGeo.getNumberOfRocs(); roc++) {
+  for (int32_t sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
     if (prn) {
-      LOG(info) << "check inverse transform for roc " << roc;
+      LOG(info) << "check inverse transform for sector " << sector;
     }
     double vLength = mGeo.getTPCzLength();
-    MaxValue maxDroc[3];
+    MaxValue maxDsector[3];
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
-      float u0 = mGeo.getRowInfo(row).getUmin();
-      float u1 = mGeo.getRowInfo(row).getUmax();
-      float v0 = 0.;
-      float v1 = vLength;
-
       double x = mGeo.getRowInfo(row).x;
-      double stepU = (u1 - u0) / 100.;
-      double stepV = (v1 - v0) / 100.;
+      auto [y0, y1] = mGeo.getRowInfo(row).getYrange();
+      auto [z0, z1] = mGeo.getZrange(sector);
+
+      // grid borders
+      if (sector < mGeo.getNumberOfSectorsA()) {
+        z1 = vLength - getSectorRowInfo(sector, row).gridV0;
+      } else {
+        z0 = getSectorRowInfo(sector, row).gridV0 - vLength;
+      }
+
+      double stepY = (y1 - y0) / 100.;
+      double stepZ = (z1 - z0) / 100.;
       MaxValue maxDrow[3];
-      for (double u = u0; u < u1; u += stepU) {
-        for (double v = v0; v < v1; v += stepV) {
-          if (v < getRocRowInfo(roc, row).gridV0) {
+      for (double y = y0; y < y1; y += stepY) {
+        for (double z = z0; z < z1; z += stepZ) {
+          auto [dx, dy, dz] = getCorrectionLocal(sector, row, y, z);
+          double realX = x + dx;
+          double realY = y + dy;
+          double realZ = z + dz;
+          if (!isLocalInsideGrid(sector, row, y, z) || !isLocalInsideGrid(sector, row, realY, realZ)) {
             continue;
           }
-          float dx, du, dv;
-          getCorrectionInternal(roc, row, u, v, dx, du, dv);
-          double cx = x + dx;
-          double cu = u + du;
-          double cv = v + dv;
-          double r2 = cx * cx + cu * cu;
-          if (cv < 0 || cv > vLength || r2 < tpcR2min || r2 > tpcR2max) {
+          double r2 = realX * realX + realY * realY;
+          if (realY < y0 || realY > y1 ||
+              realZ < z0 || realZ > z1 ||
+              r2 < tpcR2min || r2 > tpcR2max) {
             continue;
           }
-          float nx, nu, nv;
-          getCorrectionInvCorrectedX(roc, row, cu, cv, nx);
-          getCorrectionInvUV(roc, row, cu, cv, nu, nv);
-          double d[3] = {(cx - nx) - dx, (cu - nu) - du, (cv - nv) - dv};
+          float dxr = getCorrectionXatRealYZ(sector, row, realY, realZ);
+          auto [dyr, dzr] = getCorrectionYZatRealYZ(sector, row, realY, realZ);
+          double d[3] = {dxr - dx, dyr - dy, dzr - dz};
           for (int32_t i = 0; i < 3; i++) {
-            maxDrow[i].update(d[i], roc, row);
+            maxDrow[i].update(d[i], sector, row);
           }
 
           if (0 && prn && fabs(d[0]) + fabs(d[1]) + fabs(d[2]) > 0.1) {
-            LOG(info) << nx - cx << " " << nu - u << " " << nv - v
-                      << " x,u,v " << x << ", " << u << ", " << v
-                      << " dx,du,dv " << cx - x << ", " << cu - u << ", " << cv - v
-                      << " nx,nu,nv " << nx - x << ", " << cu - nu << ", " << cv - nv;
+            LOG(info) << dxr - dx << " " << dyr - dy << " " << dzr - dz
+                      << " measured xyz " << x << ", " << y << ", " << z
+                      << " dx,dy,dz from measured point " << dx << ", " << dy << ", " << dz
+                      << " dx,dy,dz from real point " << dxr << ", " << dyr << ", " << dzr;
           }
         }
       }
-      if (1 && prn) {
-        LOG(info) << "roc " << roc << " row " << row
-                  << " dx " << maxDrow[0].V << " du " << maxDrow[1].V << " dv " << maxDrow[2].V;
+      if (0 && prn) {
+        LOG(info) << "sector " << sector << " row " << row
+                  << " dx " << maxDrow[0].V << " dy " << maxDrow[1].V << " dz " << maxDrow[2].V;
       }
       for (int32_t i = 0; i < 3; i++) {
-        maxDroc[i].update(maxDrow[i]);
+        maxDsector[i].update(maxDrow[i]);
         maxDtpc[i].update(maxDrow[i]);
         maxD.update(maxDrow[i]);
       }
     }
     if (prn) {
-      LOG(info) << "inverse correction: roc " << roc << ". Max deviations: "
-                << " dx " << maxDroc[0].toString() << " du " << maxDroc[1].toString() << " dv " << maxDroc[2].toString();
+      LOG(info) << "inverse correction: sector " << sector << ". Max deviations: "
+                << " dx " << maxDsector[0].toString() << " dy " << maxDsector[1].toString() << " dz " << maxDsector[2].toString();
     }
-  } // roc
+  } // sector
 
   LOG(info) << "Test inverse TPC correction. max deviations: "
-            << " dx " << maxDtpc[0].toString() << " du " << maxDtpc[1].toString() << " dv " << maxDtpc[2].toString() << " cm";
+            << " dx " << maxDtpc[0].toString() << " dy " << maxDtpc[1].toString() << " dz " << maxDtpc[2].toString() << " cm";
 
   return maxD.V;
 }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index fa5cf7a1736bd..f84fde4fffd8c 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -44,20 +44,11 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   ///
   struct RowInfo {
     int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
-    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing the TPC roc
+    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing the TPC sector
     ClassDefNV(RowInfo, 1);
   };
 
-  struct RowActiveArea {
-    float maxDriftLengthCheb[5]{0.f};
-    float vMax{0.f};
-    float cuMin{0.f};
-    float cuMax{0.f};
-    float cvMax{0.f};
-    ClassDefNV(RowActiveArea, 1);
-  };
-
-  struct RocRowInfo {
+  struct SectorRowInfo {
     float gridU0{0.f};                     //< U coordinate of the U-grid start
     float scaleUtoGrid{0.f};               //< scale U to U-grid coordinate
     float gridV0{0.f};                     ///< V coordinate of the V-grid start
@@ -66,38 +57,37 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     float scaleCorrUtoGrid{0.f};           ///< scale corrected U to U-grid coordinate
     float gridCorrV0{0.f};                 ///< V coordinate of the V-grid start for corrected V
     float scaleCorrVtoGrid{0.f};           ///< scale corrected V to V-grid coordinate
-    float maxCorr[3]{10.f, 10.f, 10.f};    ///< max correction for dX, dU, dV
     float minCorr[3]{-10.f, -10.f, -10.f}; ///< min correction for dX, dU, dV
-    RowActiveArea activeArea;
+    float maxCorr[3]{10.f, 10.f, 10.f};    ///< max correction for dX, dU, dV
 
     void resetMaxValues()
     {
-      maxCorr[0] = 1.f;
       minCorr[0] = -1.f;
-      maxCorr[1] = 1.f;
+      maxCorr[0] = 1.f;
       minCorr[1] = -1.f;
-      maxCorr[2] = 1.f;
+      maxCorr[1] = 1.f;
       minCorr[2] = -1.f;
+      maxCorr[2] = 1.f;
     }
 
     void updateMaxValues(float dx, float du, float dv)
     {
-      maxCorr[0] = GPUCommonMath::Max(maxCorr[0], dx);
       minCorr[0] = GPUCommonMath::Min(minCorr[0], dx);
+      maxCorr[0] = GPUCommonMath::Max(maxCorr[0], dx);
 
-      maxCorr[1] = GPUCommonMath::Max(maxCorr[1], du);
       minCorr[1] = GPUCommonMath::Min(minCorr[1], du);
+      maxCorr[1] = GPUCommonMath::Max(maxCorr[1], du);
 
-      maxCorr[2] = GPUCommonMath::Max(maxCorr[2], dv);
       minCorr[2] = GPUCommonMath::Min(minCorr[2], dv);
+      maxCorr[2] = GPUCommonMath::Max(maxCorr[2], dv);
     }
 
-    ClassDefNV(RocRowInfo, 2);
+    ClassDefNV(SectorRowInfo, 2);
   };
 
-  struct RocInfo {
+  struct SectorInfo {
     float vMax{0.f}; ///< Max value of V coordinate
-    ClassDefNV(RocInfo, 1);
+    ClassDefNV(SectorInfo, 1);
   };
 
   typedef Spline2D<float, 3> SplineType;
@@ -167,52 +157,43 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() void setInterpolationSafetyMargin(float val) { fInterpolationSafetyMargin = val; }
 
   /// Gives const pointer to a spline
-  GPUd() const SplineType& getSpline(int32_t roc, int32_t row) const;
+  GPUd() const SplineType& getSpline(int32_t sector, int32_t row) const;
 
   /// Gives pointer to a spline
-  GPUd() SplineType& getSpline(int32_t roc, int32_t row);
+  GPUd() SplineType& getSpline(int32_t sector, int32_t row);
 
   /// Gives pointer to spline data
-  GPUd() float* getSplineData(int32_t roc, int32_t row, int32_t iSpline = 0);
+  GPUd() float* getSplineData(int32_t sector, int32_t row, int32_t iSpline = 0);
 
   /// Gives pointer to spline data
-  GPUd() const float* getSplineData(int32_t roc, int32_t row, int32_t iSpline = 0) const;
+  GPUd() const float* getSplineData(int32_t sector, int32_t row, int32_t iSpline = 0) const;
 
   /// _______________ The main method: cluster correction  _______________________
   ///
-  GPUd() int32_t getCorrectionInternal(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
+  // GPUd() int32_t getCorrectionInternal(int32_t sector, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
 
-  GPUdi() std::tuple<float, float, float> getCorrectionLocal(int32_t roc, int32_t row, float y, float z) const;
+  GPUdi() std::tuple<float, float, float> getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const;
 
   /// inverse correction: Corrected U and V -> coorrected X
-  GPUd() void getCorrectionInvCorrectedX(int32_t roc, int32_t row, float corrU, float corrV, float& corrX) const;
+  GPUd() float getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
 
   /// inverse correction: Corrected U and V -> uncorrected U and V
-  GPUd() void getCorrectionInvUV(int32_t roc, int32_t row, float corrU, float corrV, float& nomU, float& nomV) const;
-
-  /// maximal possible drift length of the active area
-  GPUd() float getMaxDriftLength(int32_t roc, int32_t row, float pad) const;
-
-  /// maximal possible drift length of the active area
-  GPUd() float getMaxDriftLength(int32_t roc, int32_t row) const;
-
-  /// maximal possible drift length of the active area
-  GPUd() float getMaxDriftLength(int32_t roc) const;
+  GPUd() std::tuple<float, float> getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
 
   /// _______________  Utilities  _______________________________________________
 
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
-  GPUd() std::tuple<float, float, float> convLocalToGrid(int32_t roc, int32_t row, float y, float z) const;
-
-  /// convert u,v to internal grid coordinates
-  GPUd() void convUVtoGrid(int32_t roc, int32_t row, float u, float v, float& gridU, float& gridV) const;
+  GPUd() std::tuple<float, float, float> convLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
 
-  /// convert u,v to internal grid coordinates
-  GPUd() void convGridToUV(int32_t roc, int32_t row, float gridU, float gridV, float& u, float& v) const;
+  /// convert internal grid coordinates u,v to local y, z
+  /// return values: y, z, scaling factor
+  GPUd() std::tuple<float, float> convGridToLocal(int32_t sector, int32_t row, float u, float v) const;
 
   /// convert corrected u,v to internal grid coordinates
-  GPUd() void convCorrectedUVtoGrid(int32_t roc, int32_t row, float cu, float cv, float& gridU, float& gridV) const;
+  GPUd() std::tuple<float, float, float> convCorrectedLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
+
+  GPUd() bool isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
 
   /// TPC geometry information
   GPUd() const TPCFastTransformGeo& getGeometry() const
@@ -229,28 +210,28 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// Gives TPC row info
   GPUd() const RowInfo& getRowInfo(int32_t row) const { return mRowInfos[row]; }
 
-  /// Gives TPC roc info
-  GPUd() const RocInfo& getRocInfo(int32_t roc) const
+  /// Gives TPC sector info
+  GPUd() const SectorInfo& getSectorInfo(int32_t sector) const
   {
-    return mRocInfo[roc];
+    return mSectorInfo[sector];
   }
 
-  /// Gives TPC roc info
-  GPUd() RocInfo& getRocInfo(int32_t roc)
+  /// Gives TPC sector info
+  GPUd() SectorInfo& getSectorInfo(int32_t sector)
   {
-    return mRocInfo[roc];
+    return mSectorInfo[sector];
   }
 
-  /// Gives TPC roc & row info
-  GPUd() const RocRowInfo& getRocRowInfo(int32_t roc, int32_t row) const
+  /// Gives TPC sector & row info
+  GPUd() const SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) const
   {
-    return mRocRowInfos[mGeo.getMaxNumberOfRows() * roc + row];
+    return mSectorRowInfos[mGeo.getMaxNumberOfRows() * sector + row];
   }
 
-  /// Gives TPC roc & row info
-  GPUd() RocRowInfo& getRocRowInfo(int32_t roc, int32_t row)
+  /// Gives TPC sector & row info
+  GPUd() SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row)
   {
-    return mRocRowInfos[mGeo.getMaxNumberOfRows() * roc + row];
+    return mSectorRowInfos[mGeo.getMaxNumberOfRows() * sector + row];
   }
 
 #if !defined(GPUCA_GPUCODE)
@@ -277,7 +258,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   int32_t mNumberOfScenarios; ///< Number of approximation spline scenarios
 
-  RocInfo mRocInfo[TPCFastTransformGeo::getNumberOfRocs()]; ///< RocInfo array
+  SectorInfo mSectorInfo[TPCFastTransformGeo::getNumberOfSectors()]; ///< SectorInfo array
 
   SplineType* mScenarioPtr; //! (transient!!) pointer to spline scenarios
 
@@ -287,7 +268,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   char* mSplineData[3]; //! (transient!!) pointer to the spline data in the flat buffer
 
-  size_t mRocDataSizeBytes[3]; ///< size of the data for one roc in the flat buffer
+  size_t mSectorDataSizeBytes[3]; ///< size of the data for one sector in the flat buffer
 
   float fInterpolationSafetyMargin{0.1f}; // 10% area around the TPC row. Outside of this area the interpolation returns the boundary values.
 
@@ -298,7 +279,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   RowInfo mRowInfos[TPCFastTransformGeo::getMaxNumberOfRows()]; ///< RowInfo array
 
-  RocRowInfo mRocRowInfos[TPCFastTransformGeo::getNumberOfRocs() * TPCFastTransformGeo::getMaxNumberOfRows()]; ///< RocRowInfo array
+  SectorRowInfo mSectorRowInfos[TPCFastTransformGeo::getNumberOfSectors() * TPCFastTransformGeo::getMaxNumberOfRows()]; ///< SectorRowInfo array
 
   ClassDefNV(TPCFastSpaceChargeCorrection, 5);
 };
@@ -307,206 +288,167 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 ///       Inline implementations of some methods
 /// ====================================================
 
-GPUdi() const TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t roc, int32_t row) const
+GPUdi() const TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t sector, int32_t row) const
 {
   /// Gives const pointer to spline
   const RowInfo& rowInfo = mRowInfos[row];
   return mScenarioPtr[rowInfo.splineScenarioID];
 }
 
-GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t roc, int32_t row)
+GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t sector, int32_t row)
 {
   /// Gives pointer to spline
   const RowInfo& rowInfo = mRowInfos[row];
   return mScenarioPtr[rowInfo.splineScenarioID];
 }
 
-GPUdi() float* TPCFastSpaceChargeCorrection::getSplineData(int32_t roc, int32_t row, int32_t iSpline)
+GPUdi() float* TPCFastSpaceChargeCorrection::getSplineData(int32_t sector, int32_t row, int32_t iSpline)
 {
   /// Gives pointer to spline data
   const RowInfo& rowInfo = mRowInfos[row];
-  return reinterpret_cast<float*>(mSplineData[iSpline] + mRocDataSizeBytes[iSpline] * roc + rowInfo.dataOffsetBytes[iSpline]);
+  return reinterpret_cast<float*>(mSplineData[iSpline] + mSectorDataSizeBytes[iSpline] * sector + rowInfo.dataOffsetBytes[iSpline]);
 }
 
-GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t roc, int32_t row, int32_t iSpline) const
+GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t sector, int32_t row, int32_t iSpline) const
 {
   /// Gives pointer to spline data
   const RowInfo& rowInfo = mRowInfos[row];
-  return reinterpret_cast<float*>(mSplineData[iSpline] + mRocDataSizeBytes[iSpline] * roc + rowInfo.dataOffsetBytes[iSpline]);
+  return reinterpret_cast<float*>(mSplineData[iSpline] + mSectorDataSizeBytes[iSpline] * sector + rowInfo.dataOffsetBytes[iSpline]);
 }
 
-GPUdi() void TPCFastSpaceChargeCorrection::convUVtoGrid(int32_t roc, int32_t row, float u, float v, float& gu, float& gv) const
+GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32_t row, float y, float z) const
 {
-  const auto& info = getRocRowInfo(roc, row);
-  gu = (u - info.gridU0) * info.scaleUtoGrid;
-  gv = (v - info.gridV0) * info.scaleVtoGrid;
-}
+  /// convert local y, z to internal grid coordinates u,v
+  /// return values: u, v, scaling factor
+  const auto& info = getSectorRowInfo(sector, row);
+  const SplineType& spline = getSpline(sector, row);
 
-GPUdi() void TPCFastSpaceChargeCorrection::convGridToUV(int32_t roc, int32_t row, float gridU, float gridV, float& u, float& v) const
-{
-  /// convert internal grid coordinates to u,v
-  const RocRowInfo& info = getRocRowInfo(roc, row);
-  u = info.gridU0 + gridU / info.scaleUtoGrid;
-  v = info.gridV0 + gridV / info.scaleVtoGrid;
-}
+  float u, v;
+  mGeo.convLocalToUV1(sector, y, z, u, v);
 
-GPUdi() void TPCFastSpaceChargeCorrection::convCorrectedUVtoGrid(int32_t roc, int32_t row, float corrU, float corrV, float& gridU, float& gridV) const
-{
-  const RocRowInfo& info = getRocRowInfo(roc, row);
-  gridU = (corrU - info.gridCorrU0) * info.scaleCorrUtoGrid;
-  gridV = (corrV - info.gridCorrV0) * info.scaleCorrVtoGrid;
-}
+  float scale = 1.f;
+  if (v < 0.f) {
+    scale = 0.f;
+  } else if (v < info.gridV0) {
+    scale = v / info.gridV0;
+  }
+
+  float gridU = (u - info.gridU0) * info.scaleUtoGrid;
+  float gridV = (v - info.gridV0) * info.scaleVtoGrid;
 
-GPUdi() int32_t TPCFastSpaceChargeCorrection::getCorrectionInternal(int32_t roc, int32_t row, float u, float v, float& dx, float& du, float& dv) const
-{
-  const auto& info = getRocRowInfo(roc, row);
-  const SplineType& spline = getSpline(roc, row);
-  const float* splineData = getSplineData(roc, row);
-  float gridU = 0, gridV = 0;
-  convUVtoGrid(roc, row, u, v, gridU, gridV);
   // shrink to the grid area
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
   gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
 
-  float dxuv[3];
-  spline.interpolateU(splineData, gridU, gridV, dxuv);
+  return {gridU, gridV, scale};
+}
 
-  float s = v / info.gridV0;
+GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
+{
+  /// ccheck if local y, z are inside the grid
 
-  if (v >= info.gridV0) {
-    s = 1.f;
-  } else if (v <= 0.f) {
-    s = 0.f;
-  }
+  const auto& info = getSectorRowInfo(sector, row);
+  const SplineType& spline = getSpline(sector, row);
 
-  dx = GPUCommonMath::Clamp(s * dxuv[0], info.minCorr[0], info.maxCorr[0]);
-  du = GPUCommonMath::Clamp(s * dxuv[1], info.minCorr[1], info.maxCorr[1]);
-  dv = GPUCommonMath::Clamp(s * dxuv[2], info.minCorr[2], info.maxCorr[2]);
-  return 0;
+  float u, v;
+  mGeo.convLocalToUV1(sector, y, z, u, v);
+
+  float gridU = (u - info.gridU0) * info.scaleUtoGrid;
+  float gridV = (v - info.gridV0) * info.scaleVtoGrid;
+
+  // shrink to the grid area
+  if (gridU < 0.f || gridU > (float)spline.getGridX1().getUmax())
+    return false;
+  if (gridV < 0.f || gridV > (float)spline.getGridX2().getUmax())
+    return false;
+  return true;
 }
 
-GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t roc, int32_t row, float y, float z) const
+GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV) const
 {
-  const auto& info = getRocRowInfo(roc, row);
-  const SplineType& spline = getSpline(roc, row);
-  const float* splineData = getSplineData(roc, row);
+  /// convert internal grid coordinates u,v to local y, z
+  const SectorRowInfo& info = getSectorRowInfo(sector, row);
+  float u = info.gridU0 + gridU / info.scaleUtoGrid;
+  float v = info.gridV0 + gridV / info.scaleVtoGrid;
+  float y, z;
+  mGeo.convUVtoLocal1(sector, u, v, y, z);
+  return {y, z};
+}
+
+GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convCorrectedLocalToGrid(int32_t sector, int32_t row, float y, float z) const
+{
+  /// convert corrected y, z to the internal grid coordinates
+  const auto& info = getSectorRowInfo(sector, row);
+  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(sector, row));
 
   float u, v;
+  mGeo.convLocalToUV1(sector, y, z, u, v);
+
+  float scale = 1.f;
+  if (v < 0.f) {
+    scale = 0.f;
+  } else if (v < info.gridCorrV0) {
+    scale = v / info.gridCorrV0;
+  }
 
-  mGeo.convLocalToUV(roc, y, z, u, v);
+  float gridU = (u - info.gridCorrU0) * info.scaleCorrUtoGrid;
+  float gridV = (v - info.gridCorrV0) * info.scaleCorrVtoGrid;
 
-  float gridU = 0, gridV = 0;
-  convUVtoGrid(roc, row, u, v, gridU, gridV);
   // shrink to the grid area
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
   gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
 
-  float dxuv[3];
-  spline.interpolateU(splineData, gridU, gridV, dxuv);
-
-  float s = v / info.gridV0;
+  return {gridU, gridV, scale};
+}
 
-  if (v >= info.gridV0) {
-    s = 1.f;
-  } else if (v <= 0.f) {
-    s = 0.f;
-  }
+GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const
+{
+  const auto& info = getSectorRowInfo(sector, row);
+  const SplineType& spline = getSpline(sector, row);
+  const float* splineData = getSplineData(sector, row);
 
-  float dx = GPUCommonMath::Clamp(s * dxuv[0], info.minCorr[0], info.maxCorr[0]);
-  float du = GPUCommonMath::Clamp(s * dxuv[1], info.minCorr[1], info.maxCorr[1]);
-  float dv = GPUCommonMath::Clamp(s * dxuv[2], info.minCorr[2], info.maxCorr[2]);
+  auto [gridU, gridV, scale] = convLocalToGrid(sector, row, y, z);
 
-  float dy, dz;
-  mGeo.convUVtoLocal(roc, du, dv, dy, dz);
+  float dxyz[3];
+  spline.interpolateU(splineData, gridU, gridV, dxyz);
 
+  float dx = scale * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
+  float dy = scale * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
+  float dz = scale * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
   return {dx, dy, dz};
 }
 
-GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvCorrectedX(
-  int32_t roc, int32_t row, float corrU, float corrV, float& x) const
+GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
-  const auto& info = getRocRowInfo(roc, row);
-  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(roc, row));
-  const float* splineData = getSplineData(roc, row, 1);
+  const auto& info = getSectorRowInfo(sector, row);
+  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(sector, row));
+  const float* splineData = getSplineData(sector, row, 1);
 
-  float gridU, gridV;
-  convCorrectedUVtoGrid(roc, row, corrU, corrV, gridU, gridV);
-
-  // shrink to the grid area
-  gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
-  gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
+  auto [gridU, gridV, scale] = convCorrectedLocalToGrid(sector, row, realY, realZ);
 
   float dx = 0;
   spline.interpolateU(splineData, gridU, gridV, &dx);
 
-  float s = corrV / info.gridCorrV0;
-
-  if (corrV >= info.gridCorrV0) {
-    s = 1.f;
-  } else if (corrV <= 0.f) {
-    s = 0.f;
-  }
-
-  dx = GPUCommonMath::Clamp(s * dx, info.minCorr[0], info.maxCorr[0]);
-  x = mGeo.getRowInfo(row).x + dx;
+  dx = scale * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
+  return dx;
 }
 
-GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionInvUV(
-  int32_t roc, int32_t row, float corrU, float corrV, float& nomU, float& nomV) const
+GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
-  const Spline2D<float, 2>& spline = reinterpret_cast<const Spline2D<float, 2>&>(getSpline(roc, row));
-  const float* splineData = getSplineData(roc, row, 2);
 
-  float gridU, gridV;
-  convCorrectedUVtoGrid(roc, row, corrU, corrV, gridU, gridV);
+  auto [gridU, gridV, scale] = convCorrectedLocalToGrid(sector, row, realY, realZ);
 
-  // shrink to the grid area
-  gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
-  gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
-
-  float duv[2];
-  spline.interpolateU(splineData, gridU, gridV, duv);
-  const auto& info = getRocRowInfo(roc, row);
-  float s = corrV / info.gridCorrV0;
+  const auto& info = getSectorRowInfo(sector, row);
+  const Spline2D<float, 2>& spline = reinterpret_cast<const Spline2D<float, 2>&>(getSpline(sector, row));
+  const float* splineData = getSplineData(sector, row, 2);
 
-  if (corrV >= info.gridCorrV0) {
-    s = 1.f;
-  } else if (corrV <= 0.f) {
-    s = 0.f;
-  }
+  float dyz[2];
+  spline.interpolateU(splineData, gridU, gridV, dyz);
 
-  duv[0] = GPUCommonMath::Clamp(s * duv[0], info.minCorr[1], info.maxCorr[1]);
-  duv[1] = GPUCommonMath::Clamp(s * duv[1], info.minCorr[2], info.maxCorr[2]);
-  nomU = corrU - duv[0];
-  nomV = corrV - duv[1];
-}
+  dyz[0] = scale * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
+  dyz[1] = scale * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
 
-GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t roc, int32_t row, float pad) const
-{
-  const RowActiveArea& area = getRocRowInfo(roc, row).activeArea;
-  const float* c = area.maxDriftLengthCheb;
-  float x = -1.f + 2.f * pad / mGeo.getRowInfo(row).maxPad;
-  float y = c[0] + c[1] * x;
-  float f0 = 1.f;
-  float f1 = x;
-  x *= 2.f;
-  for (int32_t i = 2; i < 5; i++) {
-    double f = x * f1 - f0;
-    y += c[i] * f;
-    f0 = f1;
-    f1 = f;
-  }
-  return y;
-}
-
-GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t roc, int32_t row) const
-{
-  return getRocRowInfo(roc, row).activeArea.vMax;
-}
-
-GPUdi() float TPCFastSpaceChargeCorrection::getMaxDriftLength(int32_t roc) const
-{
-  return getRocInfo(roc).vMax;
+  return {dyz[0], dyz[1]};
 }
 
 } // namespace gpu
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
index 97b824aa6da32..fcee61ff09425 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
@@ -49,20 +49,20 @@ class TPCFastSpaceChargeCorrectionMap
   /// _____________  Constructors / destructors __________________________
 
   /// Default constructor: creates an empty uninitialized object
-  TPCFastSpaceChargeCorrectionMap(int32_t nRocs, int32_t nRows)
+  TPCFastSpaceChargeCorrectionMap(int32_t nSectors, int32_t nRows)
   {
-    init(nRocs, nRows);
+    init(nSectors, nRows);
   }
 
   /// Destructor
   ~TPCFastSpaceChargeCorrectionMap() = default;
 
   /// (re-)init the map
-  void init(int32_t nRocs, int32_t nRows)
+  void init(int32_t nSectors, int32_t nRows)
   {
-    mNrocs = nRocs;
+    mNsectors = nSectors;
     mNrows = nRows;
-    int32_t n = mNrocs * mNrows;
+    int32_t n = mNsectors * mNrows;
     fDataPoints.resize(n);
     for (uint32_t i = 0; i < fDataPoints.size(); ++i) {
       fDataPoints[i].clear();
@@ -70,30 +70,30 @@ class TPCFastSpaceChargeCorrectionMap
   }
 
   /// Starts the construction procedure, reserves temporary memory
-  void addCorrectionPoint(int32_t iRoc, int32_t iRow,
+  void addCorrectionPoint(int32_t iSector, int32_t iRow,
                           double y, double z,
                           double dx, double dy, double dz)
   {
-    int32_t ind = mNrows * iRoc + iRow;
+    int32_t ind = mNrows * iSector + iRow;
     fDataPoints.at(ind).push_back(CorrectionPoint{y, z,
                                                   dx, dy, dz});
   }
 
-  const std::vector<CorrectionPoint>& getPoints(int32_t iRoc, int32_t iRow) const
+  const std::vector<CorrectionPoint>& getPoints(int32_t iSector, int32_t iRow) const
   {
-    int32_t ind = mNrows * iRoc + iRow;
+    int32_t ind = mNrows * iSector + iRow;
     return fDataPoints.at(ind);
   }
 
-  int32_t getNrocs() const { return mNrocs; }
+  int32_t getNsectors() const { return mNsectors; }
 
   int32_t getNrows() const { return mNrows; }
 
-  bool isInitialized() const { return mNrocs > 0 && mNrows > 0; }
+  bool isInitialized() const { return mNsectors > 0 && mNrows > 0; }
 
  private:
   /// _______________  Data members  _______________________________________________
-  int32_t mNrocs{0};
+  int32_t mNsectors{0};
   int32_t mNrows{0};
   std::vector<std::vector<CorrectionPoint>> fDataPoints; //! (transient!!) points with space charge correction
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 1ecd577eb7dac..03d9eaf43ce9b 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -46,14 +46,14 @@ struct TPCSlowSpaceChargeCorrection {
   ~TPCSlowSpaceChargeCorrection();
 
   /// getting the corrections for global coordinates
-  void getCorrections(const float gx, const float gy, const float gz, const int32_t roc, float& gdxC, float& gdyC, float& gdzC) const;
+  void getCorrections(const float gx, const float gy, const float gz, const int32_t sector, float& gdxC, float& gdyC, float& gdzC) const;
 
   o2::tpc::SpaceCharge<float>* mCorr{nullptr}; ///< reference space charge corrections
 #else
   ~TPCSlowSpaceChargeCorrection() = default;
 
   /// setting dummy corrections for GPU
-  GPUd() void getCorrections(const float gx, const float gy, const float gz, const int32_t roc, float& gdxC, float& gdyC, float& gdzC) const
+  GPUd() void getCorrections(const float gx, const float gy, const float gz, const int32_t sector, float& gdxC, float& gdyC, float& gdzC) const
   {
     gdxC = 0;
     gdyC = 0;
@@ -182,45 +182,43 @@ class TPCFastTransform : public FlatObject
 
   /// _______________ The main method: cluster transformation _______________________
   ///
-  /// Transforms raw TPC coordinates to local XYZ withing a roc
+  /// Transforms raw TPC coordinates to local XYZ withing a sector
   /// taking calibration into account.
   ///
-  GPUd() void Transform(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
-  GPUd() void TransformXYZ(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
 
   /// Transformation in the time frame
-  GPUd() void TransformInTimeFrame(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const;
-  GPUd() void TransformInTimeFrame(int32_t roc, float time, float& z, float maxTimeBin) const;
+  GPUd() void TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const;
+  GPUd() void TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const;
 
   /// Inverse transformation
-  GPUd() void InverseTransformInTimeFrame(int32_t roc, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const;
-  GPUd() float InverseTransformInTimeFrame(int32_t roc, float z, float maxTimeBin) const;
+  GPUd() void InverseTransformInTimeFrame(int32_t sector, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const;
+  GPUd() float InverseTransformInTimeFrame(int32_t sector, float z, float maxTimeBin) const;
 
   /// Inverse transformation: Transformed Y and Z -> transformed X
-  GPUd() void InverseTransformYZtoX(int32_t roc, int32_t row, float y, float z, float& x, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformYZtoX(int32_t sector, int32_t row, float y, float z, float& x, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
 
   /// Inverse transformation: Transformed Y and Z -> Y and Z, transformed w/o space charge correction
-  GPUd() void InverseTransformYZtoNominalYZ(int32_t roc, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
 
   /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
-  GPUd() void InverseTransformXYZtoNominalXYZ(int32_t roc, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref = nullptr, const TPCFastTransform* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
 
   /// Ideal transformation with Vdrift only - without calibration
-  GPUd() void TransformIdeal(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;
-  GPUd() void TransformIdealZ(int32_t roc, float time, float& z, float vertexTime) const;
+  GPUd() void TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;
+  GPUd() void TransformIdealZ(int32_t sector, float time, float& z, float vertexTime) const;
 
-  GPUd() void convPadTimeToUV(int32_t row, float pad, float time, float& u, float& v, float vertexTime) const;
-  GPUd() void convPadTimeToUVinTimeFrame(int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const;
-  GPUd() void convTimeToVinTimeFrame(float time, float& v, float maxTimeBin) const;
+  GPUd() void convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const;
+  GPUd() void convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const;
 
-  GPUd() void convUVtoPadTime(int32_t row, float u, float v, float& pad, float& time, float vertexTime) const;
-  GPUd() void convUVtoPadTimeInTimeFrame(int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const;
-  GPUd() void convVtoTime(float v, float& time, float vertexTime) const;
+  GPUd() void convLocalToPadTime(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float vertexTime) const;
+  GPUd() void convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const;
 
-  GPUd() float convTimeToZinTimeFrame(int32_t roc, float time, float maxTimeBin) const;
-  GPUd() float convZtoTimeInTimeFrame(int32_t roc, float z, float maxTimeBin) const;
-  GPUd() float convDeltaTimeToDeltaZinTimeFrame(int32_t roc, float deltaTime) const;
-  GPUd() float convDeltaZtoDeltaTimeInTimeFrame(int32_t roc, float deltaZ) const;
+  GPUd() float convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const;
+  GPUd() float convZtoTimeInTimeFrame(int32_t sector, float z, float maxTimeBin) const;
+  GPUd() float convDeltaTimeToDeltaZinTimeFrame(int32_t sector, float deltaTime) const;
+  GPUd() float convDeltaZtoDeltaTimeInTimeFrame(int32_t sector, float deltaZ) const;
   GPUd() float convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const;
   GPUd() float convZOffsetToVertexTime(int32_t sector, float zOffset, float maxTimeBin) const;
   GPUd() float convVertexTimeToZOffset(int32_t sector, float vertexTime, float maxTimeBin) const;
@@ -265,13 +263,13 @@ class TPCFastTransform : public FlatObject
   GPUd() float getLumiScaleFactor() const { return mLumiScaleFactor; }
 
   /// maximal possible drift time of the active area
-  GPUd() float getMaxDriftTime(int32_t roc, int32_t row, float pad) const;
+  GPUd() float getMaxDriftTime(int32_t sector, int32_t row, float pad) const;
 
   /// maximal possible drift time of the active area
-  GPUd() float getMaxDriftTime(int32_t roc, int32_t row) const;
+  GPUd() float getMaxDriftTime(int32_t sector, int32_t row) const;
 
   /// maximal possible drift time of the active area
-  GPUd() float getMaxDriftTime(int32_t roc) const;
+  GPUd() float getMaxDriftTime(int32_t sector) const;
 
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 
@@ -292,6 +290,8 @@ class TPCFastTransform : public FlatObject
   /// Print method
   void print() const;
 
+  GPUd() float convDriftLengthToTime(float driftLength, float vertexTime) const;
+
  private:
   /// Enumeration of possible initialization states
   enum ConstructionExtraState : uint32_t {
@@ -335,7 +335,7 @@ class TPCFastTransform : public FlatObject
   /// Correction of (x,u,v) with tricubic interpolator on a regular grid
   TPCSlowSpaceChargeCorrection* mCorrectionSlow{nullptr}; ///< reference space charge corrections
 
-  GPUd() void TransformLocal(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const;
+  GPUd() void TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const;
 
   ClassDefNV(TPCFastTransform, 4);
 };
@@ -344,27 +344,22 @@ class TPCFastTransform : public FlatObject
 //              Inline implementations of some methods
 // =======================================================================
 
-GPUdi() void TPCFastTransform::convPadTimeToUV(int32_t row, float pad, float time, float& u, float& v, float vertexTime) const
-{
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  float x = rowInfo.x;
-  u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-  v = (time - mT0 - vertexTime) * (mVdrift); // drift length cm
-}
+// ----------------------------------------------------------------------
 
-GPUdi() void TPCFastTransform::convTimeToVinTimeFrame(float time, float& v, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const
 {
-  v = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
-  v += getGeometry().getTPCzLength();
+  float l = (time - mT0 - vertexTime) * mVdrift; // drift length [cm]
+  std::tie(y, z) = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
 }
 
-GPUdi() void TPCFastTransform::convPadTimeToUVinTimeFrame(int32_t row, float pad, float time, float& u, float& v, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const
 {
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-  convTimeToVinTimeFrame(time, v, maxTimeBin);
+  float l = getGeometry().getTPCzLength() + (time - mT0 - maxTimeBin) * mVdrift; // drift length [cm]
+  std::tie(y, z) = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
 }
 
+// ----------------------------------------------------------------------
+
 GPUdi() float TPCFastTransform::convZOffsetToVertexTime(int32_t sector, float zOffset, float maxTimeBin) const
 {
   if (sector < getGeometry().getNumberOfSectorsA()) {
@@ -383,27 +378,30 @@ GPUdi() float TPCFastTransform::convVertexTimeToZOffset(int32_t sector, float ve
   }
 }
 
-GPUdi() void TPCFastTransform::convUVtoPadTime(int32_t row, float u, float v, float& pad, float& time, float vertexTime) const
+GPUdi() float TPCFastTransform::convDriftLengthToTime(float driftLength, float vertexTime) const
 {
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
-  time = mT0 + vertexTime + v / mVdrift;
+  return (mT0 + vertexTime + driftLength / mVdrift);
 }
 
-GPUdi() void TPCFastTransform::convVtoTime(float v, float& time, float vertexTime) const
+// ----------------------------------------------------------------------
+
+GPUdi() void TPCFastTransform::convLocalToPadTime(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float vertexTime) const
 {
-  time = mT0 + vertexTime + v / mVdrift;
+  float l;
+  std::tie(pad, l) = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
+  time = convDriftLengthToTime(l, vertexTime);
 }
 
-GPUdi() void TPCFastTransform::convUVtoPadTimeInTimeFrame(int32_t row, float u, float v, float& pad, float& time, float maxTimeBin) const
+GPUdi() void TPCFastTransform::convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const
 {
-  v -= getGeometry().getTPCzLength();
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
-  time = mT0 + maxTimeBin + v / mVdrift;
+  float l;
+  std::tie(pad, l) = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
+  time = convDriftLengthToTime(l, maxTimeBin);
 }
 
-GPUdi() void TPCFastTransform::TransformLocal(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+// ----------------------------------------------------------------------
+
+GPUdi() void TPCFastTransform::TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
 
@@ -417,29 +415,29 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t roc, int32_t row, float& x
 #ifndef GPUCA_GPUCODE
     if (mCorrectionSlow) {
       float gx, gy, gz;
-      getGeometry().convLocalToGlobal(roc, x, y, z, gx, gy, gz);
+      getGeometry().convLocalToGlobal(sector, x, y, z, gx, gy, gz);
       float gdxC, gdyC, gdzC;
-      mCorrectionSlow->getCorrections(gx, gy, gz, roc, gdxC, gdyC, gdzC);
-      getGeometry().convGlobalToLocal(roc, gdxC, gdyC, gdzC, dx, dy, dz);
+      mCorrectionSlow->getCorrections(gx, gy, gz, sector, gdxC, gdyC, gdzC);
+      getGeometry().convGlobalToLocal(sector, gdxC, gdyC, gdzC, dx, dy, dz);
     } else
 #endif // GPUCA_GPUCODE
     {
-      std::tie(dx, dy, dz) = mCorrection.getCorrectionLocal(roc, row, y, z);
+      std::tie(dx, dy, dz) = mCorrection.getCorrectionLocal(sector, row, y, z);
       if (ref) {
         if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
-          auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(roc, row, y, z);
+          auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
           dx = (dx - dxRef) * scale + dxRef;
           dy = (dy - dyRef) * scale + dyRef;
           dz = (dz - dzRef) * scale + dzRef;
         } else if ((scale != 0.f) && ((scaleMode == 1) || (scaleMode == 2))) {
-          auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(roc, row, y, z);
+          auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
           dx = dxRef * scale + dx;
           dy = dyRef * scale + dy;
           dz = dzRef * scale + dz;
         }
       }
       if (ref2 && (scale2 != 0)) {
-        auto [dxRef, dyRef, dzRef] = ref2->mCorrection.getCorrectionLocal(roc, row, y, z);
+        auto [dxRef, dyRef, dzRef] = ref2->mCorrection.getCorrectionLocal(sector, row, y, z);
         dx = dxRef * scale2 + dx;
         dy = dyRef * scale2 + dy;
         dz = dzRef * scale2 + dz;
@@ -451,37 +449,37 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t roc, int32_t row, float& x
     float lx = x, ly = y, lz = z;
 
     float gx, gy, gz;
-    getGeometry().convLocalToGlobal(roc, lx, ly, lz, gx, gy, gz);
+    getGeometry().convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);
 
     float lxT = lx + dx;
     float lyT = ly + dy;
     float lzT = lz + dz;
 
     float invYZtoXScaled;
-    InverseTransformYZtoX(roc, row, lyT, lzT, invYZtoXScaled, ref, ref2, scale, scale2, scaleMode);
+    InverseTransformYZtoX(sector, row, lyT, lzT, invYZtoXScaled, ref, ref2, scale, scale2, scaleMode);
 
     float invYZtoX;
-    InverseTransformYZtoX(roc, row, lyT, lzT, invYZtoX);
+    InverseTransformYZtoX(sector, row, lyT, lzT, invYZtoX);
 
     float YZtoNominalY;
     float YZtoNominalZ;
-    InverseTransformYZtoNominalYZ(roc, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
+    InverseTransformYZtoNominalYZ(sector, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
 
     float YZtoNominalYScaled;
     float YZtoNominalZScaled;
-    InverseTransformYZtoNominalYZ(roc, row, lyT, lzT, YZtoNominalYScaled, YZtoNominalZScaled, ref, ref2, scale, scale2, scaleMode);
+    InverseTransformYZtoNominalYZ(sector, row, lyT, lzT, YZtoNominalYScaled, YZtoNominalZScaled, ref, ref2, scale, scale2, scaleMode);
 
     float dxRef = 0.f, dyRef = 0.f, dzRef = 0.f;
     if (ref) {
-      std::tie(dxRef, dyRef, dzRef) = ref->mCorrection.getCorrectionLocal(roc, row, y, z);
+      std::tie(dxRef, dyRef, dzRef) = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
     }
 
-    float dxRef2 = 0.f, duRef2 = 0.f, dvRef2 = 0.f;
+    float dxRef2 = 0.f, dyRef2 = 0.f, dzRef2 = 0.f;
     if (ref2) {
-      std::tie(dxRef2, duRef2, dvRef2) = ref2->mCorrection.getCorrectionLocal(roc, row, y, z);
+      std::tie(dxRef2, dyRef2, dzRef2) = ref2->mCorrection.getCorrectionLocal(sector, row, y, z);
     }
 
-    auto [dxOrig, dyOrig, dzOrig] = mCorrection.getCorrectionLocal(roc, row, y, z);
+    auto [dxOrig, dyOrig, dzOrig] = mCorrection.getCorrectionLocal(sector, row, y, z);
 
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
                                                                                        // corrections in x, u, v
@@ -498,7 +496,7 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t roc, int32_t row, float& x
                                                                                        << "dy=" << dy
                                                                                        << "dz=" << dz
                                                                                        << "row=" << row
-                                                                                       << "roc=" << roc
+                                                                                       << "sector=" << sector
                                                                                        << "scale=" << scale
                                                                                        << "scale2=" << scale2
                                                                                        // original local coordinates
@@ -529,38 +527,34 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t roc, int32_t row, float& x
   z += dz;
 }
 
-GPUdi() void TPCFastTransform::TransformXYZ(int32_t roc, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
 
-  TransformLocal(roc, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
+  TransformLocal(sector, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
 }
 
-GPUdi() void TPCFastTransform::Transform(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   /// _______________ The main method: cluster transformation _______________________
   ///
-  /// Transforms raw TPC coordinates to local XYZ withing a roc
+  /// Transforms raw TPC coordinates to local XYZ withing a sector
   /// taking calibration into account.
   ///
 
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
 
   x = rowInfo.x;
-  float u = 0, v = 0;
-  convPadTimeToUV(row, pad, time, u, v, vertexTime);
-  getGeometry().convUVtoLocal(roc, u, v, y, z);
-
-  TransformLocal(roc, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
+  convPadTimeToLocal(sector, row, pad, time, y, z, vertexTime);
+  TransformLocal(sector, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
 }
 
-GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t roc, float time, float& z, float maxTimeBin) const
+GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const
 {
-  float v = 0;
-  convTimeToVinTimeFrame(time, v, maxTimeBin);
-  getGeometry().convVtoLocal(roc, v, z);
+  float l = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
+  z = getGeometry().convDriftLengthToLocal(sector, l);
 }
 
-GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
+GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
 {
   /// _______________ Special cluster transformation for a time frame _______________________
   ///
@@ -570,58 +564,50 @@ GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t roc, int32_t row, fl
 
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
   x = rowInfo.x;
-  float u = 0, v = 0;
-  convPadTimeToUVinTimeFrame(row, pad, time, u, v, maxTimeBin);
-  getGeometry().convUVtoLocal(roc, u, v, y, z);
+  convPadTimeToLocalInTimeFrame(sector, row, pad, time, y, z, maxTimeBin);
 }
 
-GPUdi() void TPCFastTransform::InverseTransformInTimeFrame(int32_t roc, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const
+GPUdi() void TPCFastTransform::InverseTransformInTimeFrame(int32_t sector, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const
 {
   /// Inverse transformation to TransformInTimeFrame
-  float u = 0, v = 0;
-  getGeometry().convLocalToUV(roc, y, z, u, v);
-  convUVtoPadTimeInTimeFrame(row, u, v, pad, time, maxTimeBin);
+  convLocalToPadTimeInTimeFrame(sector, row, y, z, pad, time, maxTimeBin);
 }
 
-GPUdi() float TPCFastTransform::InverseTransformInTimeFrame(int32_t roc, float z, float maxTimeBin) const
+GPUdi() float TPCFastTransform::InverseTransformInTimeFrame(int32_t sector, float z, float maxTimeBin) const
 {
   float pad, time;
-  InverseTransformInTimeFrame(roc, 0, 0, 0, z, pad, time, maxTimeBin);
+  InverseTransformInTimeFrame(sector, 0, 0, 0, z, pad, time, maxTimeBin);
   return time;
 }
 
-GPUdi() void TPCFastTransform::TransformIdealZ(int32_t roc, float time, float& z, float vertexTime) const
+GPUdi() void TPCFastTransform::TransformIdealZ(int32_t sector, float time, float& z, float vertexTime) const
 {
   /// _______________ The main method: cluster transformation _______________________
   ///
-  /// Transforms time TPC coordinates to local Z withing a roc
+  /// Transforms time TPC coordinates to local Z withing a sector
   /// Ideal transformation: only Vdrift from DCS.
   /// No space charge corrections, no time of flight correction
   ///
 
-  float v = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  getGeometry().convVtoLocal(roc, v, z);
+  float l = (time - mT0 - vertexTime) * mVdrift; // drift length cm
+  z = getGeometry().convDriftLengthToLocal(sector, l);
 }
 
-GPUdi() void TPCFastTransform::TransformIdeal(int32_t roc, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
+GPUdi() void TPCFastTransform::TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
 {
   /// _______________ The main method: cluster transformation _______________________
   ///
-  /// Transforms raw TPC coordinates to local XYZ withing a roc
+  /// Transforms raw TPC coordinates to local XYZ withing a sector
   /// Ideal transformation: only Vdrift from DCS.
   /// No space charge corrections, no time of flight correction
   ///
 
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-
-  x = rowInfo.x;
-  float u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-  float v = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-
-  getGeometry().convUVtoLocal(roc, u, v, y, z);
+  x = getGeometry().getRowInfo(row).x;
+  float driftLength = (time - mT0 - vertexTime) * mVdrift; // drift length cm
+  std::tie(y, z) = getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength);
 }
 
-GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t roc, float time, float maxTimeBin) const
+GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const
 {
   /// _______________ Special cluster transformation for a time frame _______________________
   ///
@@ -631,21 +617,21 @@ GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t roc, float time,
   ///
 
   float v = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
-  float z = (roc < getGeometry().getNumberOfRocsA()) ? -v : v;
+  float z = (sector < getGeometry().getNumberOfSectorsA()) ? -v : v;
   return z;
 }
 
-GPUdi() float TPCFastTransform::convZtoTimeInTimeFrame(int32_t roc, float z, float maxTimeBin) const
+GPUdi() float TPCFastTransform::convZtoTimeInTimeFrame(int32_t sector, float z, float maxTimeBin) const
 {
   /// Inverse transformation of convTimeToZinTimeFrame()
-  float v = (roc < getGeometry().getNumberOfRocsA()) ? -z : z;
+  float v = (sector < getGeometry().getNumberOfSectorsA()) ? -z : z;
   return mT0 + maxTimeBin + v / mVdrift;
 }
 
-GPUdi() float TPCFastTransform::convDeltaTimeToDeltaZinTimeFrame(int32_t roc, float deltaTime) const
+GPUdi() float TPCFastTransform::convDeltaTimeToDeltaZinTimeFrame(int32_t sector, float deltaTime) const
 {
   float deltaZ = deltaTime * mVdrift;
-  return roc < getGeometry().getNumberOfRocsA() ? -deltaZ : deltaZ;
+  return sector < getGeometry().getNumberOfSectorsA() ? -deltaZ : deltaZ;
 }
 
 GPUdi() float TPCFastTransform::convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const
@@ -653,140 +639,115 @@ GPUdi() float TPCFastTransform::convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ
   return deltaZ / mVdrift;
 }
 
-GPUdi() float TPCFastTransform::convDeltaZtoDeltaTimeInTimeFrame(int32_t roc, float deltaZ) const
+GPUdi() float TPCFastTransform::convDeltaZtoDeltaTimeInTimeFrame(int32_t sector, float deltaZ) const
 {
   float deltaT = deltaZ / mVdrift;
-  return roc < getGeometry().getNumberOfRocsA() ? -deltaT : deltaT;
+  return sector < getGeometry().getNumberOfSectorsA() ? -deltaT : deltaT;
 }
 
-/*
-GPUdi() float TPCFastTransform::getLastCalibratedTimeBin(int32_t roc) const
-{
-  /// Return a value of the last timebin where correction map is valid
-  float u, v, pad, time;
-  getGeometry().convScaledUVtoUV(roc, 0, 0.f, 1.f, u, v);
-  convUVtoPadTime(roc, 0, u, v, pad, time, 0);
-  return time;
-}
-*/
-
-GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t roc, int32_t row, float pad) const
+GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t sector, int32_t row, float pad) const
 {
   /// maximal possible drift time of the active area
-  float maxL = mCorrection.getMaxDriftLength(roc, row, pad);
-  return mT0 + maxL / mVdrift;
+  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);
 }
 
-GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t roc, int32_t row) const
+GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t sector, int32_t row) const
 {
   /// maximal possible drift time of the active area
-  float maxL = mCorrection.getMaxDriftLength(roc, row);
-  float maxTime = 0.f;
-  convVtoTime(maxL, maxTime, 0.f);
-  return maxTime;
+  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);
 }
 
-GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t roc) const
+GPUdi() float TPCFastTransform::getMaxDriftTime(int32_t sector) const
 {
   /// maximal possible drift time of the active area
-  float maxL = mCorrection.getMaxDriftLength(roc);
-  float maxTime = 0.f;
-  convVtoTime(maxL, maxTime, 0.f);
-  return maxTime;
+  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);
 }
 
-GPUdi() void TPCFastTransform::InverseTransformYZtoX(int32_t roc, int32_t row, float y, float z, float& x, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformYZtoX(int32_t sector, int32_t row, float realY, float realZ, float& realX, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
   /// Transformation y,z -> x
-  float u = 0, v = 0;
-  getGeometry().convLocalToUV(roc, y, z, u, v);
+
+  float dx = 0.f;
+
   if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    mCorrection.getCorrectionInvCorrectedX(roc, row, u, v, x);
+    dx = mCorrection.getCorrectionXatRealYZ(sector, row, realY, realZ);
     if (ref) { // scaling was requested
       if (scaleMode == 0 && scale > 0.f) {
-        float xr;
-        ref->mCorrection.getCorrectionInvCorrectedX(roc, row, u, v, xr);
-        x = (x - xr) * scale + xr;
+        float dxref = ref->mCorrection.getCorrectionXatRealYZ(sector, row, realY, realZ);
+        dx = (dx - dxref) * scale + dxref;
       } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
-        float xr;
-        ref->mCorrection.getCorrectionInvCorrectedX(roc, row, u, v, xr);
-        x = (xr - getGeometry().getRowInfo(row).x) * scale + x; // xr=mGeo.getRowInfo(row).x + dx;
+        float dxref = ref->mCorrection.getCorrectionXatRealYZ(sector, row, realY, realZ);
+        dx = dxref * scale + dx;
       }
     }
     if (ref2 && (scale2 != 0)) {
-      float xr;
-      ref2->mCorrection.getCorrectionInvCorrectedX(roc, row, u, v, xr);
-      x = (xr - getGeometry().getRowInfo(row).x) * scale2 + x; // xr=mGeo.getRowInfo(row).x + dx;
+      float dxref = ref2->mCorrection.getCorrectionXatRealYZ(sector, row, realY, realZ);
+      dx = dxref * scale2 + dx;
     }
-  } else {
-    x = mCorrection.getGeometry().getRowInfo(row).x; // corrections are disabled
   }
+
+  realX = mCorrection.getGeometry().getRowInfo(row).x + dx;
+
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoX").data()
-                                                                                       << "roc=" << roc
+                                                                                       << "sector=" << sector
                                                                                        << "row=" << row
                                                                                        << "scale=" << scale
-                                                                                       << "y=" << y
-                                                                                       << "z=" << z
-                                                                                       << "x=" << x
-                                                                                       << "v=" << v
-                                                                                       << "u=" << u
+                                                                                       << "y=" << realY
+                                                                                       << "z=" << realZ
+                                                                                       << "x=" << realX
                                                                                        << "\n";
   })
 }
 
-GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t roc, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
+  /// Transformation real y,z -> measured y,z
+
   GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
-  /// Transformation y,z -> x
-  float u = 0, v = 0, un = 0, vn = 0;
-  getGeometry().convLocalToUV(roc, y, z, u, v);
+
+  float dy = 0;
+  float dz = 0;
+
   if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    mCorrection.getCorrectionInvUV(roc, row, u, v, un, vn);
+    std::tie(dy, dz) = mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+
     if (ref) { // scaling was requested
       if (scaleMode == 0 && scale > 0.f) {
-        float unr = 0, vnr = 0;
-        ref->mCorrection.getCorrectionInvUV(roc, row, u, v, unr, vnr);
-        un = (un - unr) * scale + unr;
-        vn = (vn - vnr) * scale + vnr;
+        auto [dyRef, dzRef] = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        dy = (dy - dyRef) * scale + dyRef;
+        dz = (dz - dzRef) * scale + dzRef;
       } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
-        float unr = 0, vnr = 0;
-        ref->mCorrection.getCorrectionInvUV(roc, row, u, v, unr, vnr);
-        un = (unr - u) * scale + un; // unr = u - duv[0];
-        vn = (vnr - v) * scale + vn;
+        auto [dyRef, dzRef] = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        dy = dyRef * scale + dy;
+        dz = dzRef * scale + dz;
       }
       if (ref2 && (scale2 != 0)) {
-        float unr = 0, vnr = 0;
-        ref2->mCorrection.getCorrectionInvUV(roc, row, u, v, unr, vnr);
-        un = (unr - u) * scale2 + un; // unr = u - duv[0];
-        vn = (vnr - v) * scale2 + vn;
+        auto [dyRef, dzRef] = ref2->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        dy = dyRef * scale2 + dy;
+        dz = dzRef * scale2 + dz;
       }
     }
-  } else {
-    un = u;
-    vn = v;
   }
-  getGeometry().convUVtoLocal(roc, un, vn, ny, nz);
+
+  measuredY = realY - dy;
+  measuredZ = realZ - dz;
 
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoNominalYZ").data()
-                                                                                       << "roc=" << roc
+                                                                                       << "sector=" << sector
                                                                                        << "row=" << row
                                                                                        << "scale=" << scale
-                                                                                       << "y=" << y
-                                                                                       << "z=" << z
-                                                                                       << "ny=" << ny
-                                                                                       << "nz=" << nz
-                                                                                       << "u=" << u
-                                                                                       << "v=" << v
-                                                                                       << "un=" << un
-                                                                                       << "vn=" << vn
+                                                                                       << "real y=" << realY
+                                                                                       << "real z=" << realZ
+                                                                                       << "measured y=" << measuredY
+                                                                                       << "measured z=" << measuredZ
                                                                                        << "\n";
   })
 }
 
-GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int32_t roc, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const
 {
   /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
   int32_t row2 = row + 1;
@@ -797,8 +758,8 @@ GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int32_t roc, int3
   float nx2, ny2, nz2; // nominal coordinates for row2
   nx1 = getGeometry().getRowInfo(row).x;
   nx2 = getGeometry().getRowInfo(row2).x;
-  InverseTransformYZtoNominalYZ(roc, row, y, z, ny1, nz1, ref, ref2, scale, scale2, scaleMode);
-  InverseTransformYZtoNominalYZ(roc, row2, y, z, ny2, nz2, ref, ref2, scale, scale2, scaleMode);
+  InverseTransformYZtoNominalYZ(sector, row, y, z, ny1, nz1, ref, ref2, scale, scale2, scaleMode);
+  InverseTransformYZtoNominalYZ(sector, row2, y, z, ny2, nz2, ref, ref2, scale, scale2, scaleMode);
   float c1 = (nx2 - nx) / (nx2 - nx1);
   float c2 = (nx - nx1) / (nx2 - nx1);
   nx = x;
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
index c8982f05d4730..e7e026f464818 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
@@ -28,14 +28,14 @@ using namespace o2::gpu;
 TPCFastTransformGeo::TPCFastTransformGeo()
 {
   // Default Constructor: creates an empty uninitialized object
-  double dAlpha = 2. * M_PI / (NumberOfRocsA);
-  for (int32_t i = 0; i < NumberOfRocs; i++) {
-    RocInfo& s = mRocInfos[i];
+  double dAlpha = 2. * M_PI / (NumberOfSectorsA);
+  for (int32_t i = 0; i < NumberOfSectors; i++) {
+    SectorInfo& s = mSectorInfos[i];
     double alpha = dAlpha * (i + 0.5);
     s.sinAlpha = sin(alpha);
     s.cosAlpha = cos(alpha);
   }
-  mRocInfos[NumberOfRocs] = RocInfo{};
+  mSectorInfos[NumberOfSectors] = SectorInfo{};
 
   for (int32_t i = 0; i < MaxNumberOfRows + 1; i++) {
     mRowInfos[i] = RowInfo{};
@@ -84,7 +84,7 @@ void TPCFastTransformGeo::setTPCrow(int32_t iRow, float x, int32_t nPads, float
 
   // Make scaled U = area between the geometrical sector borders
 
-  const double sectorAngle = 2. * M_PI / NumberOfRocsA;
+  const double sectorAngle = 2. * M_PI / NumberOfSectorsA;
   const double scaleXtoRowWidth = 2. * tan(0.5 * sectorAngle);
   double uWidth = x * scaleXtoRowWidth; // distance to the sector border
 
@@ -99,8 +99,8 @@ void TPCFastTransformGeo::finishConstruction()
 {
   /// Finishes initialization: puts everything to the flat buffer, releases temporary memory
 
-  assert(mConstructionMask & ConstructionState::InProgress);     // construction in process
-  assert(mConstructionMask & ConstructionState::GeometryIsSet);  // geometry is  set
+  assert(mConstructionMask & ConstructionState::InProgress);    // construction in process
+  assert(mConstructionMask & ConstructionState::GeometryIsSet); // geometry is  set
 
   for (int32_t i = 0; i < mNumberOfRows; i++) { // all TPC rows are initialized
     assert(getRowInfo(i).maxPad > 0);
@@ -123,7 +123,7 @@ void TPCFastTransformGeo::print() const
 #endif
 }
 
-int32_t TPCFastTransformGeo::test(int32_t roc, int32_t row, float ly, float lz) const
+int32_t TPCFastTransformGeo::test(int32_t sector, int32_t row, float ly, float lz) const
 {
   /// Check consistency of the class
 
@@ -139,46 +139,21 @@ int32_t TPCFastTransformGeo::test(int32_t roc, int32_t row, float ly, float lz)
   float lx1 = 0.f, ly1 = 0.f, lz1 = 0.f;
   float gx = 0.f, gy = 0.f, gz = 0.f;
 
-  convLocalToGlobal(roc, lx, ly, lz, gx, gy, gz);
-  convGlobalToLocal(roc, gx, gy, gz, lx1, ly1, lz1);
+  convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);
+  convGlobalToLocal(sector, gx, gy, gz, lx1, ly1, lz1);
 
   if (fabs(lx1 - lx) > 1.e-4 || fabs(ly1 - ly) > 1.e-4 || fabs(lz1 - lz) > 1.e-7) {
     LOG(info) << "Error local <-> global: x " << lx << " dx " << lx1 - lx << " y " << ly << " dy " << ly1 - ly << " z " << lz << " dz " << lz1 - lz;
     error = -3;
   }
-  float u = 0.f, v = 0.f;
-  convLocalToUV(roc, ly, lz, u, v);
-  convUVtoLocal(roc, u, v, ly1, lz1);
 
-  if (fabs(ly1 - ly) + fabs(lz1 - lz) > 1.e-6) {
-    LOG(info) << "Error local <-> UV: y " << ly << " dy " << ly1 - ly << " z " << lz << " dz " << lz1 - lz;
+  auto [pad, length] = convLocalToPadDriftLength(sector, 10, ly, lz);
+  auto [ly2, lz2] = convPadDriftLengthToLocal(sector, 10, pad, length);
+
+  if (fabs(ly2 - ly) + fabs(lz2 - lz) > 1.e-6) {
+    LOG(info) << "Error local <-> UV: y " << ly << " dy " << ly2 - ly << " z " << lz << " dz " << lz2 - lz;
     error = -4;
   }
-  /*
-    float su = 0.f, sv = 0.f;
-
-    convUVtoScaledUV(roc, row, u, v, su, sv);
-
-    if (su < 0.f || su > 1.f) {
-      LOG(info) << "Error scaled U range: u " << u << " su " << su;
-      error = -5;
-    }
-
-    float u1 = 0.f, v1 = 0.f;
-    convScaledUVtoUV(roc, row, su, sv, u1, v1);
-
-    if (fabs(u1 - u) > 1.e-4 || fabs(v1 - v) > 1.e-4) {
-      LOG(info) << "Error UV<->scaled UV: u " << u << " du " << u1 - u << " v " << v << " dv " << v1 - v;
-      error = -6;
-    }
-  */
-  float pad = convUtoPad(row, u);
-  float u1 = convPadToU(row, pad);
-
-  if (fabs(u1 - u) > 1.e-5) {
-    LOG(info) << "Error U<->Pad: u " << u << " pad " << pad << " du " << u1 - u;
-    error = -7;
-  }
 
 #if !defined(GPUCA_GPUCODE)
   if (error != 0) {
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index a5d642158cd8f..4072435e948a5 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -34,11 +34,11 @@ namespace gpu
 class TPCFastTransformGeo
 {
  public:
-  /// The struct contains necessary info for TPC ROC
-  struct RocInfo {
+  /// The struct contains necessary info for TPC sector
+  struct SectorInfo {
     float sinAlpha{0.f}; ///< sin of the angle between the local x and the global x
     float cosAlpha{0.f}; ///< cos of the angle between the local x and the global x
-    ClassDefNV(RocInfo, 1);
+    ClassDefNV(SectorInfo, 1);
   };
 
   /// The struct contains necessary info about TPC padrow
@@ -54,6 +54,15 @@ class TPCFastTransformGeo
     /// get U max
     GPUd() float getUmax() const { return -u0; }
 
+    /// get Y min
+    GPUd() float getYmin() const { return u0; }
+
+    /// get Y max
+    GPUd() float getYmax() const { return -u0; }
+
+    /// get Y range
+    GPUd() std::tuple<float, float> getYrange() const { return {getYmin(), getYmax()}; }
+
     /// get width in U
     GPUd() float getUwidth() const { return -2.f * u0; }
 
@@ -81,7 +90,7 @@ class TPCFastTransformGeo
 
   /// _______________  Construction interface  ________________________
 
-  /// Starts the initialization procedure, reserves temporary memory
+  /// Starts the initialization psectoredure, reserves temporary memory
   void startConstruction(int32_t numberOfRows);
 
   /// Initializes a TPC row
@@ -100,11 +109,11 @@ class TPCFastTransformGeo
 
   /// _______________  Getters _________________________________
 
-  /// Gives number of TPC ROCs
-  GPUd() static constexpr int32_t getNumberOfRocs() { return NumberOfRocs; }
+  /// Gives number of TPC sectors
+  GPUd() static constexpr int32_t getNumberOfSectors() { return NumberOfSectors; }
 
-  /// Gives number of TPC ROCs on the A side
-  GPUd() static constexpr int32_t getNumberOfRocsA() { return NumberOfRocsA; }
+  /// Gives number of TPC sectors on the A side
+  GPUd() static constexpr int32_t getNumberOfSectorsA() { return NumberOfSectorsA; }
 
   /// Gives number of TPC rows
   GPUd() int32_t getNumberOfRows() const { return mNumberOfRows; }
@@ -112,8 +121,8 @@ class TPCFastTransformGeo
   /// Gives number of TPC rows
   GPUd() static constexpr int getMaxNumberOfRows() { return MaxNumberOfRows; }
 
-  /// Gives roc info
-  GPUd() const RocInfo& getRocInfo(int32_t roc) const;
+  /// Gives sector info
+  GPUd() const SectorInfo& getSectorInfo(int32_t sector) const;
 
   /// Gives TPC row info
   GPUd() const RowInfo& getRowInfo(int32_t row) const;
@@ -121,20 +130,31 @@ class TPCFastTransformGeo
   /// Gives Z length of the TPC, one Z side
   GPUd() float getTPCzLength() const { return mTPCzLength; }
 
+  /// Gives Z range for the corresponding TPC side
+  GPUd() std::tuple<float, float> getZrange(int32_t sector) const;
+
   /// _______________  Conversion of coordinate systems __________
 
   /// convert Local -> Global c.s.
-  GPUd() void convLocalToGlobal(int32_t roc, float lx, float ly, float lz, float& gx, float& gy, float& gz) const;
+  GPUd() void convLocalToGlobal(int32_t sector, float lx, float ly, float lz, float& gx, float& gy, float& gz) const;
 
   /// convert Global->Local c.s.
-  GPUd() void convGlobalToLocal(int32_t roc, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
+  GPUd() void convGlobalToLocal(int32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
+
+  /// convert Pad, DriftLength -> Local c.s.
+  GPUd() std::tuple<float, float> convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const;
+
+  /// convert DriftLength -> Local c.s.
+  GPUd() float convDriftLengthToLocal(int32_t sector, float driftLength) const;
+
+  /// convert Local c.s. -> Pad, DriftLength
+  GPUd() std::tuple<float, float> convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const;
 
   /// convert UV -> Local c.s.
-  GPUd() void convUVtoLocal(int32_t roc, float u, float v, float& y, float& z) const;
-  GPUd() void convVtoLocal(int32_t roc, float v, float& z) const;
+  GPUd() void convUVtoLocal1(int32_t sector, float u, float v, float& y, float& z) const;
 
   /// convert Local-> UV c.s.
-  GPUd() void convLocalToUV(int32_t roc, float y, float z, float& u, float& v) const;
+  GPUd() void convLocalToUV1(int32_t sector, float y, float z, float& u, float& v) const;
 
   /// convert Pad coordinate -> U
   GPUd() float convPadToU(int32_t row, float pad) const;
@@ -146,7 +166,7 @@ class TPCFastTransformGeo
   void print() const;
 
   /// Method for testing consistency
-  int32_t test(int32_t roc, int32_t row, float ly, float lz) const;
+  int32_t test(int32_t sector, int32_t row, float ly, float lz) const;
 
   /// Method for testing consistency
   int32_t test() const;
@@ -154,9 +174,9 @@ class TPCFastTransformGeo
  private:
   /// _______________  Data members  _______________________________________________
 
-  static constexpr int32_t NumberOfRocs = 36;                ///< Number of TPC rocs ( roc = inner + outer sector )
-  static constexpr int32_t NumberOfRocsA = NumberOfRocs / 2; ///< Number of TPC rocs side A
-  static constexpr int32_t MaxNumberOfRows = 160;            ///< Max Number of TPC rows in a roc
+  static constexpr int32_t NumberOfSectors = 36;                   ///< Number of TPC sectors ( sector = inner + outer sector )
+  static constexpr int32_t NumberOfSectorsA = NumberOfSectors / 2; ///< Number of TPC sectors side A
+  static constexpr int32_t MaxNumberOfRows = 160;                  ///< Max Number of TPC rows in a sector
 
   /// _______________  Construction control  _______________________________________________
 
@@ -172,10 +192,10 @@ class TPCFastTransformGeo
 
   /// _______________  Geometry  _______________________________________________
 
-  int32_t mNumberOfRows = 0;    ///< Number of TPC rows. It is different for the Run2 and the Run3 setups
-  float mTPCzLength = 0.f;      ///< Z length of one TPC side (A or C)
+  int32_t mNumberOfRows = 0; ///< Number of TPC rows. It is different for the Run2 and the Run3 setups
+  float mTPCzLength = 0.f;   ///< Z length of one TPC side (A or C)
 
-  RocInfo mRocInfos[NumberOfRocs + 1];    ///< array of roc information [fixed size]
+  SectorInfo mSectorInfos[NumberOfSectors + 1]; ///< array of sector information [fixed size]
   RowInfo mRowInfos[MaxNumberOfRows + 1]; ///< array of row information [fixed size]
 
   ClassDefNV(TPCFastTransformGeo, 3);
@@ -185,13 +205,13 @@ class TPCFastTransformGeo
 //              Inline implementations of some methods
 // =======================================================================
 
-GPUdi() const TPCFastTransformGeo::RocInfo& TPCFastTransformGeo::getRocInfo(int32_t roc) const
+GPUdi() const TPCFastTransformGeo::SectorInfo& TPCFastTransformGeo::getSectorInfo(int32_t sector) const
 {
-  /// Gives roc info
-  if (roc < 0 || roc >= NumberOfRocs) { // return zero object
-    roc = NumberOfRocs;
+  /// Gives sector info
+  if (sector < 0 || sector >= NumberOfSectors) { // return zero object
+    sector = NumberOfSectors;
   }
-  return mRocInfos[roc];
+  return mSectorInfos[sector];
 }
 
 GPUdi() const TPCFastTransformGeo::RowInfo& TPCFastTransformGeo::getRowInfo(int32_t row) const
@@ -203,55 +223,93 @@ GPUdi() const TPCFastTransformGeo::RowInfo& TPCFastTransformGeo::getRowInfo(int3
   return mRowInfos[row];
 }
 
-GPUdi() void TPCFastTransformGeo::convLocalToGlobal(int32_t roc, float lx, float ly, float lz, float& gx, float& gy, float& gz) const
+GPUdi() void TPCFastTransformGeo::convLocalToGlobal(int32_t sector, float lx, float ly, float lz, float& gx, float& gy, float& gz) const
 {
   /// convert Local -> Global c.s.
-  const RocInfo& rocInfo = getRocInfo(roc);
-  gx = lx * rocInfo.cosAlpha - ly * rocInfo.sinAlpha;
-  gy = lx * rocInfo.sinAlpha + ly * rocInfo.cosAlpha;
+  const SectorInfo& sectorInfo = getSectorInfo(sector);
+  gx = lx * sectorInfo.cosAlpha - ly * sectorInfo.sinAlpha;
+  gy = lx * sectorInfo.sinAlpha + ly * sectorInfo.cosAlpha;
   gz = lz;
 }
 
-GPUdi() void TPCFastTransformGeo::convGlobalToLocal(int32_t roc, float gx, float gy, float gz, float& lx, float& ly, float& lz) const
+GPUdi() void TPCFastTransformGeo::convGlobalToLocal(int32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const
 {
   /// convert Global -> Local c.s.
-  const RocInfo& rocInfo = getRocInfo(roc);
-  lx = gx * rocInfo.cosAlpha + gy * rocInfo.sinAlpha;
-  ly = -gx * rocInfo.sinAlpha + gy * rocInfo.cosAlpha;
+  const SectorInfo& sectorInfo = getSectorInfo(sector);
+  lx = gx * sectorInfo.cosAlpha + gy * sectorInfo.sinAlpha;
+  ly = -gx * sectorInfo.sinAlpha + gy * sectorInfo.cosAlpha;
   lz = gz;
 }
 
-GPUdi() void TPCFastTransformGeo::convVtoLocal(int32_t roc, float v, float& lz) const
+GPUdi() std::tuple<float, float> TPCFastTransformGeo::convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const
 {
-  /// convert UV -> Local c.s.
-  if (roc < NumberOfRocsA) { // TPC side A
-    lz = mTPCzLength - v;
-  } else {                 // TPC side C
-    lz = v - mTPCzLength;  // drift direction is mirrored on C-side
+  /// convert Pad, DriftLength -> Local c.s.
+  const RowInfo& rowInfo = getRowInfo(row);
+  float u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
+  float y, z;
+  if (sector < NumberOfSectorsA) { // TPC side A
+    y = u;
+    z = mTPCzLength - driftLength;
+  } else {                         // TPC side C
+    y = -u;                        // pads are mirrorred on C-side
+    z = driftLength - mTPCzLength; // drift direction is mirrored on C-side
   }
+  return {y, z};
 }
 
-GPUdi() void TPCFastTransformGeo::convUVtoLocal(int32_t roc, float u, float v, float& ly, float& lz) const
+GPUdi() float TPCFastTransformGeo::convDriftLengthToLocal(int32_t sector, float driftLength) const
+{
+  /// convert DriftLength -> Local c.s.
+  return (sector < NumberOfSectorsA) ? (mTPCzLength - driftLength) : (driftLength - mTPCzLength);
+}
+
+GPUdi() void TPCFastTransformGeo::convUVtoLocal1(int32_t sector, float u, float v, float& ly, float& lz) const
 {
   /// convert UV -> Local c.s.
-  if (roc < NumberOfRocsA) { // TPC side A
+  if (sector < NumberOfSectorsA) { // TPC side A
     ly = u;
     lz = mTPCzLength - v;
-  } else {                 // TPC side C
-    ly = -u;               // pads are mirrorred on C-side
-    lz = v - mTPCzLength;  // drift direction is mirrored on C-side
+  } else {                // TPC side C
+    ly = -u;              // pads are mirrorred on C-side
+    lz = v - mTPCzLength; // drift direction is mirrored on C-side
+  }
+}
+
+GPUdi() std::tuple<float, float> TPCFastTransformGeo::getZrange(int32_t sector) const
+{
+  /// z range for the sector
+  if (sector < NumberOfSectorsA) { // TPC side A
+    return {0.f, mTPCzLength};
+  } else { // TPC side C
+    return {-mTPCzLength, 0.f};
+  }
+}
+
+GPUdi() std::tuple<float, float> TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const
+{
+  /// convert Local c.s. -> Pad, DriftLength
+  float u, l;
+  if (sector < NumberOfSectorsA) { // TPC side A
+    u = y;
+    l = mTPCzLength - z;
+  } else {               // TPC side C
+    u = -y;              // pads are mirrorred on C-side
+    l = z + mTPCzLength; // drift direction is mirrored on C-side
   }
+  const TPCFastTransformGeo::RowInfo& rowInfo = getRowInfo(row);
+  float pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
+  return {pad, l};
 }
 
-GPUdi() void TPCFastTransformGeo::convLocalToUV(int32_t roc, float ly, float lz, float& u, float& v) const
+GPUdi() void TPCFastTransformGeo::convLocalToUV1(int32_t sector, float ly, float lz, float& u, float& v) const
 {
   /// convert Local-> UV c.s.
-  if (roc < NumberOfRocsA) { // TPC side A
+  if (sector < NumberOfSectorsA) { // TPC side A
     u = ly;
     v = mTPCzLength - lz;
-  } else {                 // TPC side C
-    u = -ly;               // pads are mirrorred on C-side
-    v = lz + mTPCzLength;  // drift direction is mirrored on C-side
+  } else {                // TPC side C
+    u = -ly;              // pads are mirrorred on C-side
+    v = lz + mTPCzLength; // drift direction is mirrored on C-side
   }
 }
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransformManager.cxx b/GPU/TPCFastTransformation/TPCFastTransformManager.cxx
deleted file mode 100644
index c553d9cc6dac1..0000000000000
--- a/GPU/TPCFastTransformation/TPCFastTransformManager.cxx
+++ /dev/null
@@ -1,336 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file  TPCFastTransformManager.cxx
-/// \brief Implementation of TPCFastTransformManager class
-///
-/// \author  Sergey Gorbunov <sergey.gorbunov@cern.ch>
-
-#include "TPCFastTransformManager.h"
-#include "AliHLTTPCGeometry.h"
-#include "AliTPCParam.h"
-#include "AliTPCRecoParam.h"
-#include "AliTPCTransform.h"
-#include "AliTPCcalibDB.h"
-#include "TPCFastTransform.h"
-#include "Spline2DHelper.h"
-blabla
-
-using namespace o2::gpu;
-
-TPCFastTransformManager::TPCFastTransformManager()
-  : mError(), mOrigTransform(nullptr), fLastTimeBin(0) {}
-
-int32_t TPCFastTransformManager::create(TPCFastTransform& fastTransform,
-                                        AliTPCTransform* transform,
-                                        long TimeStamp)
-{
-  /// Initializes TPCFastTransform object
-
-  AliTPCcalibDB* pCalib = AliTPCcalibDB::Instance();
-  if (!pCalib) {
-    return storeError(
-      -1, "TPCFastTransformManager::Init: No TPC calibration instance found");
-  }
-
-  AliTPCParam* tpcParam = pCalib->GetParameters();
-  if (!tpcParam) {
-    return storeError(
-      -2, "TPCFastTransformManager::Init: No TPCParam object found");
-  }
-
-  if (!transform) {
-    transform = pCalib->GetTransform();
-  }
-  if (!transform) {
-    return storeError(
-      -3, "TPCFastTransformManager::Init: No TPC transformation found");
-  }
-
-  mOrigTransform = transform;
-
-  tpcParam->Update();
-  tpcParam->ReadGeoMatrices();
-
-  const AliTPCRecoParam* rec = transform->GetCurrentRecoParam();
-  if (!rec) {
-    return storeError(-5,
-                      "TPCFastTransformManager::Init: No TPC Reco Param "
-                      "set in transformation");
-  }
-
-  bool useCorrectionMap = rec->GetUseCorrectionMap();
-
-  if (useCorrectionMap) {
-    transform->SetCorrectionMapMode(kTRUE); // If the simulation set this to
-                                            // false to simulate corrections, we
-                                            // need to reverse it for the
-                                            // transformation
-  }
-  // find last calibrated time bin
-
-  fLastTimeBin = rec->GetLastBin();
-
-  const int32_t nRows = tpcParam->GetNRowLow() + tpcParam->GetNRowUp();
-
-  TPCFastTransformGeo geo;
-
-  { // construct the geometry
-    geo.startConstruction(nRows);
-
-    float tpcZlengthSideA = tpcParam->GetZLength(0);
-    float tpcZlengthSideC =
-      tpcParam->GetZLength(TPCFastTransformGeo::getNumberOfRocs() / 2);
-
-    geo.setTPCzLength(tpcZlengthSideA, tpcZlengthSideC);
-    geo.setTPCalignmentZ(-mOrigTransform->GetDeltaZCorrTime());
-
-    for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
-      int32_t roc = 0, sector = 0, secrow = 0;
-      AliHLTTPCGeometry::Slice2Sector(roc, row, sector, secrow);
-      Int_t nPads = tpcParam->GetNPads(sector, secrow);
-      float xRow = tpcParam->GetPadRowRadii(sector, secrow);
-      float padWidth = tpcParam->GetInnerPadPitchWidth();
-      if (row >= tpcParam->GetNRowLow()) {
-        padWidth = tpcParam->GetOuterPadPitchWidth();
-      }
-      geo.setTPCrow(row, xRow, nPads, padWidth);
-    }
-    geo.finishConstruction();
-  }
-
-  TPCFastSpaceChargeCorrection correction;
-
-  { // create the correction map
-
-    const int32_t nDistortionScenarios = 1;
-
-    correction.startConstruction(geo, nDistortionScenarios);
-
-    TPCFastSpaceChargeCorrection::SplineType spline;
-    spline.recreate(8, 20);
-
-    int32_t scenario = 0;
-    correction.setSplineScenario(scenario, spline);
-
-    for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
-      correction.setRowScenarioID(row, scenario);
-    }
-
-    correction.finishConstruction();
-  } // .. create the correction map
-
-  { // create the fast transform object
-
-    fastTransform.startConstruction(correction);
-
-    // tell the transformation to apply the space charge corrections
-    fastTransform.setApplyCorrectionOn();
-
-    // set some initial calibration values, will be reinitialised later int32_t
-    // updateCalibration()
-    const float t0 = 0.;
-    const float vDrift = 0.f;
-    const float vdCorrY = 0.;
-    const float ldCorr = 0.;
-    const float tofCorr = 0.;
-    const float primVtxZ = 0.;
-    const int64_t initTimeStamp = -1;
-    fastTransform.setCalibration(initTimeStamp, t0, vDrift, vdCorrY, ldCorr,
-                                 tofCorr, primVtxZ);
-
-    fastTransform.finishConstruction();
-  }
-
-  return updateCalibration(fastTransform, TimeStamp);
-}
-
-int32_t TPCFastTransformManager::updateCalibration(TPCFastTransform& fastTransform,
-                                                   long TimeStamp)
-{
-  // Update the calibration with the new time stamp
-
-  long lastTS = fastTransform.getTimeStamp();
-
-  // deinitialize
-
-  fastTransform.setTimeStamp(-1);
-
-  if (TimeStamp < 0) {
-    return 0;
-  }
-
-  // search for the calibration database
-
-  if (!mOrigTransform) {
-    return storeError(-1,
-                      "TPCFastTransformManager::SetCurrentTimeStamp: TPC "
-                      "transformation has not been set properly");
-  }
-
-  AliTPCcalibDB* pCalib = AliTPCcalibDB::Instance();
-  if (!pCalib) {
-    return storeError(-2,
-                      "TPCFastTransformManager::SetCurrentTimeStamp: No "
-                      "TPC calibration found");
-  }
-
-  AliTPCParam* tpcParam = pCalib->GetParameters();
-  if (!tpcParam) {
-    return storeError(-3,
-                      "TPCFastTransformManager::SetCurrentTimeStamp: No "
-                      "TPCParam object found");
-  }
-
-  AliTPCRecoParam* recoParam = mOrigTransform->GetCurrentRecoParamNonConst();
-  if (!recoParam) {
-    return storeError(-5,
-                      "TPCFastTransformManager::Init: No TPC Reco Param "
-                      "set in transformation");
-  }
-
-  // calibration found, set the initialized status back
-
-  fastTransform.setTimeStamp(lastTS);
-
-  // less than 60 seconds from the previois time stamp, don't do anything
-
-  if (lastTS >= 0 && TMath::Abs(lastTS - TimeStamp) < 60) {
-    return 0;
-  }
-
-  // start the initialization
-
-  bool useCorrectionMap = recoParam->GetUseCorrectionMap();
-
-  if (useCorrectionMap) {
-    // If the simulation set this to false to simulate corrections, we need to
-    // reverse it for the transformation This is a design feature. Historically
-    // HLT code runs as a part of simulation, not reconstruction.
-    mOrigTransform->SetCorrectionMapMode(kTRUE);
-  }
-
-  // set the current time stamp
-
-  mOrigTransform->SetCurrentTimeStamp(static_cast<uint32_t>(TimeStamp));
-  fastTransform.setTimeStamp(TimeStamp);
-
-  // find last calibrated time bin
-
-  fLastTimeBin = recoParam->GetLastBin();
-
-  double t0 = mOrigTransform->GetTBinOffset();
-  double driftCorrPT = mOrigTransform->GetDriftCorrPT();
-  double vdCorrectionTime = mOrigTransform->GetVDCorrectionTime();
-  double vdCorrectionTimeGY = mOrigTransform->GetVDCorrectionTimeGY();
-  double time0CorrTime = mOrigTransform->GetTime0CorrTime();
-
-  // original formula:
-  // L = (t-t0)*ZWidth*driftCorrPT*vdCorrectionTime*( 1 +
-  // yLab*vdCorrectionTimeGY )  -  time0CorrTime + 3.*tpcParam->GetZSigma(); Z =
-  // Z(L) - fDeltaZCorrTime chebyshev corrections for xyz Time-of-flight
-  // correction: ldrift += dist-to-vtx*tofCorr
-
-  // fast transform formula:
-  // L = (t-t0)*(mVdrift + mVdriftCorrY*yLab ) + mLdriftCorr
-  // Z = Z(L) +  tpcAlignmentZ
-  // spline corrections for xyz
-  // Time-of-flight correction: ldrift += dist-to-vtx*tofCorr
-
-  double vDrift = tpcParam->GetZWidth() * driftCorrPT * vdCorrectionTime;
-  double vdCorrY = vDrift * vdCorrectionTimeGY;
-  double ldCorr = -time0CorrTime + 3 * tpcParam->GetZSigma();
-
-  double tofCorr = (0.01 * tpcParam->GetDriftV()) / TMath::C();
-  double primVtxZ = mOrigTransform->GetPrimVertex()[2];
-
-  bool useTOFcorrection = recoParam->GetUseTOFCorrection();
-
-  if (!useTOFcorrection) {
-    tofCorr = 0;
-  }
-
-  fastTransform.setCalibration(TimeStamp, t0, vDrift, vdCorrY, ldCorr, tofCorr,
-                               primVtxZ);
-
-  // now calculate the correction map: dx,du,dv = ( origTransform() -> x,u,v) -
-  // fastTransformNominal:x,u,v
-
-  const TPCFastTransformGeo& geo = fastTransform.getGeometry();
-
-  TPCFastSpaceChargeCorrection& correction =
-    fastTransform.getCorrection();
-
-  // switch TOF correction off for a while
-
-  recoParam->SetUseTOFCorrection(kFALSE);
-
-  for (int32_t roc = 0; roc < geo.getNumberOfRocs(); roc++) {
-
-    for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
-
-      const TPCFastTransformGeo::RowInfo& rowInfo = geo.getRowInfo(row);
-
-      const TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSpline(roc, row);
-      float* data = correction.getSplineData(roc, row);
-
-      Spline2DHelper<float> helper;
-      helper.setSpline(spline, 4, 4);
-      auto F = [&](double su, double sv, double dxuv[3]) {
-        float x = rowInfo.x;
-        // x, u, v cordinates of the knot (local cartesian coord. of roc
-        // towards central electrode )
-        float u = 0, v = 0;
-        geo.convScaledUVtoUV(roc, row, su, sv, u, v);
-
-        // row, pad, time coordinates of the knot
-        float vertexTime = 0.f;
-        float pad = 0.f, time = 0.f;
-        fastTransform.convUVtoPadTime(roc, row, u, v, pad, time, vertexTime);
-
-        // nominal x,y,z coordinates of the knot (without corrections and
-        // time-of-flight correction)
-        float y = 0, z = 0;
-        geo.convUVtoLocal(roc, u, v, y, z);
-
-        // original TPC transformation (row,pad,time) -> (x,y,z) without
-        // time-of-flight correction
-        float ox = 0, oy = 0, oz = 0;
-        {
-          int32_t sector = 0, secrow = 0;
-          AliHLTTPCGeometry::Slice2Sector(roc, row, sector, secrow);
-          int32_t is[] = {sector};
-          double xx[] = {static_cast<double>(secrow), pad, time};
-          mOrigTransform->Transform(xx, is, 0, 1);
-          ox = xx[0];
-          oy = xx[1];
-          oz = xx[2];
-        }
-        // convert to u,v
-        float ou = 0, ov = 0;
-        geo.convLocalToUV(roc, oy, oz, ou, ov);
-
-        // corrections in x,u,v:
-        dxuv[0] = ox - x;
-        dxuv[1] = ou - u;
-        dxuv[2] = ov - v;
-      };
-
-      helper.approximateFunction(data, 0., 1., 0., 1., F);
-    } // row
-  } // roc
-
-  // set back the time-of-flight correction;
-
-  recoParam->SetUseTOFCorrection(useTOFcorrection);
-
-  return 0;
-}
diff --git a/GPU/TPCFastTransformation/TPCFastTransformManager.h b/GPU/TPCFastTransformation/TPCFastTransformManager.h
deleted file mode 100644
index f981b05bec241..0000000000000
--- a/GPU/TPCFastTransformation/TPCFastTransformManager.h
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file  TPCFastTransformManager.h
-/// \brief Definition of TPCFastTransformManager class
-///
-/// \author  Sergey Gorbunov <sergey.gorbunov@cern.ch>
-
-#ifndef ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTTRANSFORMMANAGER_H
-#define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTTRANSFORMMANAGER_H
-
-#include <cmath>
-
-#include "GPUCommonDef.h"
-#include "Rtypes.h"
-#include "TString.h"
-#include "AliTPCTransform.h"
-
-namespace o2
-{
-namespace gpu
-{
-class TPCFastTransform;
-
-///
-/// The TPCFastTransformManager class is to initialize TPCFastTransformation object
-///
-
-class TPCFastTransformManager
-{
- public:
-  /// _____________  Constructors / destructors __________________________
-
-  /// Default constructor
-  TPCFastTransformManager();
-
-  /// Copy constructor: disabled
-  TPCFastTransformManager(const TPCFastTransformManager&) = delete;
-
-  /// Assignment operator: disabled
-  TPCFastTransformManager& operator=(const TPCFastTransformManager&) = delete;
-
-  /// Destructor
-  ~TPCFastTransformManager() = default;
-
-  /// _______________  Main functionality  ________________________
-
-  /// Initializes TPCFastTransform object
-  int32_t create(TPCFastTransform& spline, AliTPCTransform* transform, long TimeStamp);
-
-  /// Updates the transformation with the new time stamp
-  Int_t updateCalibration(TPCFastTransform& spline, long TimeStamp);
-
-  /// _______________  Utilities   ________________________
-
-  AliTPCTransform* getOriginalTransform() { return mOrigTransform; }
-
-  ///  Gives error string
-  const char* getLastError() const { return mError.Data(); }
-
- private:
-  /// Stores an error message
-  int32_t storeError(Int_t code, const char* msg);
-
-  TString mError;                  ///< error string
-  AliTPCTransform* mOrigTransform; ///< transient
-  int32_t fLastTimeBin;            ///< last calibrated time bin
-};
-
-inline int32_t TPCFastTransformManager::storeError(int32_t code, const char* msg)
-{
-  mError = msg;
-  return code;
-}
-} // namespace gpu
-} // namespace o2
-
-#endif
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index 7c1ae8fd56800..fc15506d5397c 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -59,7 +59,7 @@
 #pragma link C++ class o2::gpu::IrregularSpline2D3DCalibrator + ;
 
 #pragma link C++ class o2::gpu::TPCFastTransformGeo + ;
-#pragma link C++ class o2::gpu::TPCFastTransformGeo::RocInfo + ;
+#pragma link C++ class o2::gpu::TPCFastTransformGeo::SectorInfo + ;
 #pragma link C++ class o2::gpu::TPCFastTransformGeo::RowInfo + ;
 
 #pragma link C++ class o2::gpu::TPCFastTransform + ;
@@ -68,9 +68,8 @@
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RowInfo + ;
 
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection + ;
-#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RocInfo + ;
-#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RowActiveArea + ;
-#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RocRowInfo + ;
+#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SectorInfo + ;
+#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SectorRowInfo + ;
 
 #pragma link C++ class o2::gpu::CorrectionMapsHelper + ;
 #pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 7e889d5a9e7db..bee1f9107ddd2 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -44,7 +44,7 @@
 using namespace o2::tpc;
 using namespace o2::gpu;
 
-void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
+void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char* fileNameInv = "debugVoxResInv.root",
                           const char* outFileName = "TPCFastTransform_VoxRes.root", bool useSmoothed = false, bool invertSigns = false)
 {
 
@@ -56,11 +56,11 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     To visiualise the results:
 
     root -l transformDebug.root
-    corr->Draw("cx:y:z","iRoc==0&&iRow==10","")
-    grid->Draw("cx:y:z","iRoc==0&&iRow==10","same")
-    vox->Draw("vx:y:z","iRoc==0&&iRow==10","same")
-    corrvox->Draw("cx:y:z","iRoc==0&&iRow==10","same")
-    points->Draw("px:y:z","iRoc==0&&iRow==10","same")
+    corr->Draw("cx:y:z","iSector==0&&iRow==10","")
+    grid->Draw("cx:y:z","iSector==0&&iRow==10","same")
+    vox->Draw("vx:y:z","iSector==0&&iRow==10","same")
+    corrvox->Draw("cx:y:z","iSector==0&&iRow==10","same")
+    points->Draw("px:y:z","iSector==0&&iRow==10","same")
   */
 
   if (gSystem->AccessPathName(fileName)) {
@@ -82,6 +82,18 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     return;
   }
 
+  TTree* voxResTreeInverse = nullptr;
+  std::unique_ptr<TFile> fileInv;
+  if (fileNameInv && !std::string(fileNameInv).empty()) {
+    fileInv = std::unique_ptr<TFile>(TFile::Open(fileNameInv, "READ"));
+    if (!fileInv || !fileInv->IsOpen()) {
+      std::cout << " input file " << fileNameInv << " does not exist!" << std::endl;
+      return;
+    }
+    fileInv->cd();
+    gDirectory->GetObject("voxResTree", voxResTreeInverse);
+  }
+
   auto userInfo = voxResTree->GetUserInfo();
 
   if (!userInfo->FindObject("y2xBinning") || !userInfo->FindObject("z2xBinning")) {
@@ -140,7 +152,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   corrHelper->setNthreadsToMaximum();
   // corrHelper->setNthreads(1);
 
-  auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, useSmoothed, invertSigns);
+  auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, voxResTreeInverse, useSmoothed, invertSigns);
 
   std::unique_ptr<o2::gpu::TPCFastTransform> fastTransform(
     helper->create(0, *corrPtr));
@@ -168,11 +180,11 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
 
       const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
-      // for (int32_t iRoc = 0; iRoc < geo.getNumberOfSlices(); iRoc++) {
-      for (int32_t iRoc = 0; iRoc < 1; iRoc++) {
+      // for (int32_t iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
+      for (int32_t iSector = 0; iSector < 1; iSector++) {
         for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
-          auto& info = corr.getSliceRowInfo(iRoc, iRow);
-          std::cout << "roc " << iRoc << " row " << iRow
+          auto& info = corr.getSectorRowInfo(iSector, iRow);
+          std::cout << "sector " << iSector << " row " << iRow
                     << " gridV0 " << info.gridV0 << " gridCorrU0 " << info.gridCorrU0 << " gridCorrV0 " << info.gridCorrV0
                     << " scaleCorrUtoGrid " << info.scaleCorrUtoGrid << " scaleCorrVtoGrid " << info.scaleCorrVtoGrid
                     << " gridU0 " << info.gridU0 << " scaleUtoGrid " << info.scaleUtoGrid << " scaleVtoGrid " << info.scaleVtoGrid
@@ -189,7 +201,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   // the difference
 
   double maxDiff[3] = {0., 0., 0.};
-  int32_t maxDiffRoc[3] = {0, 0, 0};
+  int32_t maxDiffSector[3] = {0, 0, 0};
   int32_t maxDiffRow[3] = {0, 0, 0};
 
   double sumDiff[3] = {0., 0., 0.};
@@ -207,7 +219,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   // measured x,y,z; corrections cx,cy,cz from the measured to the real x,y,z;
   // inverse corrections ix,iy,iz at the real position (x+cx,y+cy,z+cz)
   // ideally, ix = cx, iy = cy, iz = cz
-  TNtuple* debugCorr = new TNtuple("corr", "corr", "iRoc:iRow:x:y:z:cx:cy:cz:ix:iy:iz");
+  TNtuple* debugCorr = new TNtuple("corr", "corr", "iSector:iRow:x:y:z:cx:cy:cz:ix:iy:iz");
 
   debugCorr->SetMarkerStyle(8);
   debugCorr->SetMarkerSize(0.1);
@@ -216,7 +228,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   // ntuple with the input data: voxels and corrections
   debugFile->cd();
   TNtuple* debugVox =
-    new TNtuple("vox", "vox", "iRoc:iRow:n:x:y:z:vx:vy:vz");
+    new TNtuple("vox", "vox", "iSector:iRow:n:x:y:z:vx:vy:vz");
 
   debugVox->SetMarkerStyle(8);
   debugVox->SetMarkerSize(0.8);
@@ -225,7 +237,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   // duplicate of debugVox + the spline data at voxels in a different color
   debugFile->cd();
   TNtuple* debugCorrVox =
-    new TNtuple("corrvox", "corrvox", "iRoc:iRow:n:x:y:z:vx:vy:vz:cx:cy:cz:ix:iy:iz");
+    new TNtuple("corrvox", "corrvox", "iSector:iRow:n:x:y:z:vx:vy:vz:cx:cy:cz:ix:iy:iz");
 
   debugCorrVox->SetMarkerStyle(8);
   debugCorrVox->SetMarkerSize(0.8);
@@ -233,7 +245,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
 
   // corrections at the spline grid points
   debugFile->cd();
-  TNtuple* debugGrid = new TNtuple("grid", "grid", "iRoc:iRow:x:y:z:cx:cy:cz:ix:iy:iz");
+  TNtuple* debugGrid = new TNtuple("grid", "grid", "iSector:iRow:x:y:z:cx:cy:cz:ix:iy:iz");
 
   debugGrid->SetMarkerStyle(8);
   debugGrid->SetMarkerSize(1.2);
@@ -242,7 +254,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   // ntuple with data points created from voxels (with the data smearing, extension to the edges etc.)
   debugFile->cd();
   TNtuple* debugPoints =
-    new TNtuple("points", "points", "iRoc:iRow:x:y:z:px:py:pz:cx:cy:cz");
+    new TNtuple("points", "points", "iSector:iRow:x:y:z:px:py:pz:cx:cy:cz");
 
   debugPoints->SetMarkerStyle(8);
   debugPoints->SetMarkerSize(0.4);
@@ -256,32 +268,13 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
 
   const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
-  auto getAllCorrections = [&](int iRoc, int iRow, float u, float v, float& x, float& y, float& z, float& cx, float& cy, float& cz, float& ix, float& iy, float& iz) {
-    // define x,y,z
-
-    x = geo.getRowInfo(iRow).x;
-    geo.convUVtoLocal(iRoc, u, v, y, z);
-
+  auto getAllCorrections = [&](int iSector, int iRow, float y, float z, float& cx, float& cy, float& cz, float& ix, float& iy, float& iz) {
     // get the corrections cx,cy,cz at x,y,z
-    float cu, cv;
-    corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
-    geo.convUVtoLocal(iRoc, cu, cv, cy, cz);
-
-    float corrected_u = u + cu;
-    float corrected_v = v + cv;
-    float corrected_x = x + cx;
-    float corrected_y, corrected_z;
-    geo.convUVtoLocal(iRoc, corrected_u, corrected_v, corrected_y, corrected_z);
-
-    // get the inverse corrections ix,iy,iz at the corrected x,y,z
-    float inverted_x, inverted_u, inverted_v, inverted_y, inverted_z;
-    corr.getCorrectionInvCorrectedX(iRoc, iRow, corrected_u, corrected_v, inverted_x);
-    corr.getCorrectionInvUV(iRoc, iRow, corrected_u, corrected_v, inverted_u, inverted_v);
-    geo.convUVtoLocal(iRoc, inverted_u, inverted_v, inverted_y, inverted_z);
-
-    ix = corrected_x - inverted_x;
-    iy = corrected_y - inverted_y;
-    iz = corrected_z - inverted_z;
+    std::tie(cx, cy, cz) = corr.getCorrectionLocal(iSector, iRow, y, z);
+    float realY = y + cy;
+    float realZ = z + cz;
+    ix = corr.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);
+    std::tie(iy, iz) = corr.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ);
   };
 
   o2::tpc::TrackResiduals::VoxRes* v = nullptr;
@@ -289,7 +282,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
   branch->SetAddress(&v);
   branch->SetAutoDelete(kTRUE);
 
-  int32_t iRocLast = -1;
+  int32_t iSectorLast = -1;
   int32_t iRowLast = -1;
 
   std::cout << "fill debug ntuples at voxels ..." << std::endl;
@@ -309,10 +302,10 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     int32_t z2xBin =
       v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
 
-    int32_t iRoc = (int32_t)v->bsec;
+    int32_t iSector = (int32_t)v->bsec;
     int32_t iRow = (int32_t)xBin;
 
-    iRocLast = iRoc;
+    iSectorLast = iSector;
     iRowLast = iRow;
 
     double x = trackResiduals.getX(xBin); // radius of the pad row
@@ -326,7 +319,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     double y = x * y2x;
     double z = x * z2x;
 
-    if (iRoc >= geo.getNumberOfSlicesA()) {
+    if (iSector >= geo.getNumberOfSectorsA()) {
       z = -z;
     }
 
@@ -345,19 +338,18 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
       z = x * v->stat[o2::tpc::TrackResiduals::VoxZ];
     }
 
-    float u, v;
-    geo.convLocalToUV(iRoc, y, z, u, v);
-    float x1, y1, z1, cx, cy, cz, ix, iy, iz;
-    getAllCorrections(iRoc, iRow, u, v, x1, y1, z1, cx, cy, cz, ix, iy, iz);
+    float cx, cy, cz, ix, iy, iz;
+    getAllCorrections(iSector, iRow, y, z, cx, cy, cz, ix, iy, iz);
 
-    double d[3] = {cx - correctionX, cy - correctionY, cz - correctionZ};
     if (voxEntries >= 1.) {
+      double d[3] = {cx - correctionX, cy - correctionY, cz - correctionZ};
+
       for (int32_t i = 0; i < 3; i++) {
         if (fabs(maxDiff[i]) < fabs(d[i])) {
           maxDiff[i] = d[i];
-          maxDiffRoc[i] = iRoc;
+          maxDiffSector[i] = iSector;
           maxDiffRow[i] = iRow;
-          // std::cout << " roc " << iRoc << " row " << iRow << " xyz " << i
+          // std::cout << " sector " << iSector << " row " << iRow << " xyz " << i
           //  << " diff " << d[i] << " entries " << voxEntries << " y " << y2xBin << " z " << z2xBin << std::endl;
         }
         sumDiff[i] += d[i] * d[i];
@@ -365,80 +357,81 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
       nDiff++;
     }
 
-    debugVox->Fill(iRoc, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ);
+    debugVox->Fill(iSector, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ);
 
-    debugCorrVox->Fill(iRoc, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ,
+    debugCorrVox->Fill(iSector, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ,
                        cx, cy, cz, ix, iy, iz);
   }
 
   std::cout
     << "fill debug ntuples everywhere .." << std::endl;
 
-  for (int32_t iRoc = 0; iRoc < geo.getNumberOfSlices(); iRoc++) {
-    // for (int32_t iRoc = 0; iRoc < 1; iRoc++) {
-    std::cout << "debug ntules for roc " << iRoc << std::endl;
+  for (int32_t iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
+    // for (int32_t iSector = 0; iSector < 1; iSector++) {
+    std::cout << "debug ntules for sector " << iSector << std::endl;
     for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
 
       double x = geo.getRowInfo(iRow).x;
 
       // the spline grid
 
-      const auto& gridU = corr.getSpline(iRoc, iRow).getGridX1();
-      const auto& gridV = corr.getSpline(iRoc, iRow).getGridX2();
-      if (iRoc == 0 && iRow == 0) {
+      const auto& gridY = corr.getSpline(iSector, iRow).getGridX1();
+      const auto& gridZ = corr.getSpline(iSector, iRow).getGridX2();
+      if (iSector == 0 && iRow == 0) {
         std::cout << "spline scenario " << corr.getRowInfo(iRow).splineScenarioID << std::endl;
-        std::cout << "spline grid U: u = " << 0 << ".." << gridU.getUmax() << ", x = " << gridU.getXmin() << ".." << gridU.getXmax() << std::endl;
-        std::cout << "spline grid V: u = " << 0 << ".." << gridV.getUmax() << ", x = " << gridV.getXmin() << ".." << gridV.getXmax() << std::endl;
+        std::cout << "spline grid Y: u = " << 0 << ".." << gridY.getUmax() << ", x = " << gridY.getXmin() << ".." << gridY.getXmax() << std::endl;
+        std::cout << "spline grid Z: u = " << 0 << ".." << gridZ.getUmax() << ", x = " << gridZ.getXmin() << ".." << gridZ.getXmax() << std::endl;
       }
 
       // the correction
       {
-        std::vector<double> p[2], g[2];
-
-        p[0].push_back(geo.getRowInfo(iRow).getUmin());
-        for (int32_t iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
-          float u, v;
-          corr.convGridToUV(iRoc, iRow, gridU.getKnot(iu).getU(), 0., u, v);
-          g[0].push_back(u);
-          p[0].push_back(u);
+        std::vector<double> points[2], knots[2];
+
+        auto [yMin, yMax] = geo.getRowInfo(iRow).getYrange();
+        auto [zMin, zMax] = geo.getZrange(iSector);
+
+        points[0].push_back(yMin);
+        points[0].push_back(yMax);
+        points[1].push_back(zMin);
+        points[1].push_back(zMax);
+
+        for (int32_t iu = 0; iu < gridY.getNumberOfKnots(); iu++) {
+          auto [y, z] = corr.convGridToLocal(iSector, iRow, gridY.getKnot(iu).getU(), 0.);
+          knots[0].push_back(y);
+          points[0].push_back(y);
         }
-        p[0].push_back(geo.getRowInfo(iRow).getUmax());
-
-        p[1].push_back(0.);
-        for (int32_t iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
-          float u, v;
-          corr.convGridToUV(iRoc, iRow, 0., gridV.getKnot(iv).getU(), u, v);
-          g[1].push_back(v);
-          p[1].push_back(v);
+        for (int32_t iv = 0; iv < gridZ.getNumberOfKnots(); iv++) {
+          auto [y, z] = corr.convGridToLocal(iSector, iRow, 0., gridZ.getKnot(iv).getU());
+          knots[1].push_back(z);
+          points[1].push_back(z);
         }
-        p[1].push_back(geo.getTPCzLength(iRoc));
 
-        for (int32_t iuv = 0; iuv < 2; iuv++) {
-          int32_t n = p[iuv].size();
+        for (int32_t iyz = 0; iyz <= 1; iyz++) {
+          std::sort(knots[iyz].begin(), knots[iyz].end());
+          std::sort(points[iyz].begin(), points[iyz].end());
+          int32_t n = points[iyz].size();
           for (int32_t i = 0; i < n - 1; i++) {
-            double d = (p[iuv][i + 1] - p[iuv][i]) / 10.;
+            double d = (points[iyz][i + 1] - points[iyz][i]) / 10.;
             for (int32_t ii = 1; ii < 10; ii++) {
-              p[iuv].push_back(p[iuv][i] + d * ii);
+              points[iyz].push_back(points[iyz][i] + d * ii);
             }
           }
-          std::sort(p[iuv].begin(), p[iuv].end());
+          std::sort(points[iyz].begin(), points[iyz].end());
         }
 
         for (int32_t iter = 0; iter < 2; iter++) {
-          std::vector<double>& pu = ((iter == 0) ? g[0] : p[0]);
-          std::vector<double>& pv = ((iter == 0) ? g[1] : p[1]);
-          for (uint32_t iu = 0; iu < pu.size(); iu++) {
-            for (uint32_t iv = 0; iv < pv.size(); iv++) {
-              float u = pu[iu];
-              float v = pv[iv];
-
-              float x, y, z, cx, cy, cz, ix, iy, iz;
-              getAllCorrections(iRoc, iRow, u, v, x, y, z, cx, cy, cz, ix, iy, iz);
-
+          std::vector<double>& py = ((iter == 0) ? knots[0] : points[0]);
+          std::vector<double>& pz = ((iter == 0) ? knots[1] : points[1]);
+          for (uint32_t iu = 0; iu < py.size(); iu++) {
+            for (uint32_t iv = 0; iv < pz.size(); iv++) {
+              float y = py[iu];
+              float z = pz[iv];
+              float cx, cy, cz, ix, iy, iz;
+              getAllCorrections(iSector, iRow, y, z, cx, cy, cz, ix, iy, iz);
               if (iter == 0) {
-                debugGrid->Fill(iRoc, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
+                debugGrid->Fill(iSector, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
               } else {
-                debugCorr->Fill(iRoc, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
+                debugCorr->Fill(iSector, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
               }
             }
           }
@@ -451,7 +444,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
 
       o2::gpu::TPCFastSpaceChargeCorrectionMap& map =
         corrHelper->getCorrectionMap();
-      auto& points = map.getPoints(iRoc, iRow);
+      auto& points = map.getPoints(iSector, iRow);
 
       for (uint32_t ip = 0; ip < points.size(); ip++) {
         auto point = points[ip];
@@ -461,14 +454,10 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
         float correctionY = point.mDy;
         float correctionZ = point.mDz;
 
-        float u, v, cx, cu, cv, cy, cz;
-        geo.convLocalToUV(iRoc, y, z, u, v);
-        corr.getCorrection(iRoc, iRow, u, v, cx, cu, cv);
-        geo.convUVtoLocal(iRoc, u + cu, v + cv, cy, cz);
-        cy -= y;
-        cz -= z;
+        auto [cx, cy, cz] =
+          corr.getCorrectionLocal(iSector, iRow, y, z);
 
-        debugPoints->Fill(iRoc, iRow, x, y, z, correctionX, correctionY,
+        debugPoints->Fill(iSector, iRow, x, y, z, correctionX, correctionY,
                           correctionZ, cx, cy, cz);
       }
     }
@@ -478,14 +467,14 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root",
     sumDiff[i] = sqrt(sumDiff[i]) / nDiff;
   }
 
-  std::cout << "Max difference in x :  " << maxDiff[0] << " at ROC "
-            << maxDiffRoc[0] << " row " << maxDiffRow[0] << std::endl;
+  std::cout << "Max difference in x :  " << maxDiff[0] << " at Sector "
+            << maxDiffSector[0] << " row " << maxDiffRow[0] << std::endl;
 
-  std::cout << "Max difference in y :  " << maxDiff[1] << " at ROC "
-            << maxDiffRoc[1] << " row " << maxDiffRow[1] << std::endl;
+  std::cout << "Max difference in y :  " << maxDiff[1] << " at Sector "
+            << maxDiffSector[1] << " row " << maxDiffRow[1] << std::endl;
 
-  std::cout << "Max difference in z :  " << maxDiff[2] << " at ROC "
-            << maxDiffRoc[2] << " row " << maxDiffRow[2] << std::endl;
+  std::cout << "Max difference in z :  " << maxDiff[2] << " at Sector "
+            << maxDiffSector[2] << " row " << maxDiffRow[2] << std::endl;
 
   std::cout << "Mean difference in x,y,z : " << sumDiff[0] << " " << sumDiff[1]
             << " " << sumDiff[2] << std::endl;

From 458532fa7e75ee72a887b2fbb892e22b1f6d320b Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Sun, 6 Apr 2025 18:43:55 +0000
Subject: [PATCH 1570/1764] TPC Splines: cleanup

---
 GPU/TPCFastTransformation/Spline1D.h          |  2 +-
 GPU/TPCFastTransformation/Spline1DSpec.h      | 58 ++++++++++---------
 GPU/TPCFastTransformation/Spline2DHelper.cxx  |  2 +-
 GPU/TPCFastTransformation/Spline2DSpec.h      | 36 ++++++------
 GPU/TPCFastTransformation/SplineHelper.cxx    |  4 +-
 GPU/TPCFastTransformation/SplineSpec.h        | 20 +++----
 .../TPCFastSpaceChargeCorrection.h            |  6 +-
 7 files changed, 66 insertions(+), 62 deletions(-)

diff --git a/GPU/TPCFastTransformation/Spline1D.h b/GPU/TPCFastTransformation/Spline1D.h
index ccadaeed23b79..c7a4d927dec1d 100644
--- a/GPU/TPCFastTransformation/Spline1D.h
+++ b/GPU/TPCFastTransformation/Spline1D.h
@@ -77,7 +77,7 @@ namespace gpu
 /// One can store all F-dependent spline parameters outside of the spline object
 /// and provide them at each interpolation call.
 /// To do so, create a spline with nYdimensions=0; create spline parameters for F via Spline1DHelper class;
-/// then use special interpolateU(..) methods for the interpolation.
+/// then use special interpolateAtU(..) methods for the interpolation.
 ///
 /// This feature allows one to use the same spline object for the approximation of different functions
 /// on the same grid of knots.
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 2cc95ebdcab9f..fcabbbad12098 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -287,33 +287,38 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
   /// Get interpolated value S(x)
   GPUd() void interpolate(DataT x, GPUgeneric() DataT S[/*mYdim*/]) const
   {
-    interpolateU<SafetyLevel::kSafe>(mYdim, mParameters, convXtoU(x), S);
+    interpolateAtU<SafetyLevel::kSafe>(mYdim, mParameters, convXtoU(x), S);
   }
 
   /// Get interpolated value for an nYdim-dimensional S(u) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
-                           DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
+  GPUd() void interpolateAtU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
+                             DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
   {
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
     const auto nYdim = nYdimTmp.get();
     int32_t iknot = TBase::template getLeftKnotIndexForU<SafeT>(u);
     const DataT* d = Parameters + (2 * nYdim) * iknot;
-    interpolateU(nYdim, getKnots()[iknot], &(d[0]), &(d[nYdim]), &(d[2 * nYdim]), &(d[3 * nYdim]), u, S);
+    interpolateAtU(nYdim, getKnots()[iknot], &(d[0]), &(d[nYdim]), &(d[2 * nYdim]), &(d[3 * nYdim]), u, S);
   }
 
   /// The main mathematical utility.
   /// Get interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
   /// using the spline values Sl, Sr and the slopes Dl, Dr
   template <typename T>
-  GPUd() void interpolateU(int32_t inpYdim, const Knot& knotL,
-                           GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
-                           GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
-                           DataT u, GPUgeneric() T S[/*mYdim*/]) const
+  GPUd() void interpolateAtU(int32_t inpYdim, const Knot& knotL,
+                             GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
+                             GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
+                             DataT u, GPUgeneric() T S[/*mYdim*/]) const
   {
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
     const auto nYdim = nYdimTmp.get();
 
+    auto [dSdSl, dSdDl, dSdSr, dSdDr] = getSderivativesOverParsAtU<T>(knotL, u);
+    for (int32_t dim = 0; dim < nYdim; ++dim) {
+      S[dim] = dSdSr * Sr[dim] + dSdSl * Sl[dim] + dSdDl * Dl[dim] + dSdDr * Dr[dim];
+    }
+    /*
     if (u < (DataT)0) {
       u = (DataT)0;
     }
@@ -330,6 +335,7 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
       T b = df - Dl[dim] - a;
       S[dim] = ((a * v + b) * v + Dl[dim]) * uu + Sl[dim];
     }
+    */
     /*
      another way to calculate f(u):
      T uu = T(u - knotL.u);
@@ -345,11 +351,10 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
   }
 
   template <typename T>
-  GPUd() void getUderivatives(const Knot& knotL, DataT u,
-                              T& dSl, T& dDl, T& dSr, T& dDr) const
+  GPUd() std::tuple<T, T, T, T> getSderivativesOverParsAtU(const Knot& knotL, DataT u) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
-    /// over the spline values Sl, Sr and the slopes Dl, Dr
+    /// over the spline parameters Sl(eft), Sr(ight) and the slopes Dl, Dr
 
     if (u < (DataT)0) {
       u = (DataT)0;
@@ -363,11 +368,12 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     T vm1 = v - 1.;
     T a = u * vm1;
     T v2 = v * v;
-    dSr = v2 * (3. - 2 * v);
-    dSl = 1. - dSr;
-    dDl = vm1 * a;
-    dDr = v * a;
-    // F(u) = dSl * Sl + dSr * Sr + dDl * Dl + dDr * Dr;
+    T dSdSr = v2 * (3. - 2 * v);
+    T dSdSl = 1. - dSdSr;
+    T dSdDl = vm1 * a;
+    T dSdDr = v * a;
+    // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
+    return std::make_tuple(dSdSl, dSdDl, dSdSr, dSdDr);
   }
   /*
     template <typename T>
@@ -480,21 +486,21 @@ class Spline1DSpec<DataT, YdimT, 1>
 
   /// Get interpolated value for an YdimT-dimensional S(u) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateU(GPUgeneric() const DataT Parameters[],
-                           DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
+  GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
+                             DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
   {
-    TBase::template interpolateU<SafeT>(YdimT, Parameters, u, S);
+    TBase::template interpolateAtU<SafeT>(YdimT, Parameters, u, S);
   }
 
   /// Get interpolated value for an YdimT-dimensional S(u) at the segment [knotL, next knotR]
   /// using the spline values Sl, Sr and the slopes Dl, Dr
   template <typename T>
-  GPUd() void interpolateU(const typename TBase::Knot& knotL,
-                           GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
-                           GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
-                           DataT u, GPUgeneric() T S[/*mYdim*/]) const
+  GPUd() void interpolateAtU(const typename TBase::Knot& knotL,
+                             GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
+                             GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
+                             DataT u, GPUgeneric() T S[/*mYdim*/]) const
   {
-    TBase::interpolateU(YdimT, knotL, Sl, Dl, Sr, Dr, u, S);
+    TBase::interpolateAtU(YdimT, knotL, Sl, Dl, Sr, Dr, u, S);
   }
 
   using TBase::getNumberOfKnots;
@@ -504,7 +510,7 @@ class Spline1DSpec<DataT, YdimT, 1>
 #if !defined(GPUCA_GPUCODE)
   using TBase::recreate;
 #endif
-  using TBase::interpolateU;
+  using TBase::interpolateAtU;
 };
 
 /// ==================================================================================================
@@ -552,7 +558,7 @@ class Spline1DSpec<DataT, YdimT, 2>
 
   ///  _______  Expert tools: interpolation with given nYdim and external Parameters _______
 
-  using TBase::interpolateU;
+  using TBase::interpolateAtU;
   ClassDefNV(Spline1DSpec, 0);
 };
 
diff --git a/GPU/TPCFastTransformation/Spline2DHelper.cxx b/GPU/TPCFastTransformation/Spline2DHelper.cxx
index 03ecf4a3f1707..bec6fc58ff8d7 100644
--- a/GPU/TPCFastTransformation/Spline2DHelper.cxx
+++ b/GPU/TPCFastTransformation/Spline2DHelper.cxx
@@ -194,7 +194,7 @@ void Spline2DHelper<DataT>::approximateFunction(
     for (int32_t ipu = 0; ipu < nDataPointsU; ipu++) {
       double splineF[Ndim];
       double u = mHelperU1.getDataPoint(ipu).u;
-      mHelperU1.getSpline().interpolateU(Ndim, parUdbl.get(), u, splineF);
+      mHelperU1.getSpline().interpolateAtU(Ndim, parUdbl.get(), u, splineF);
       for (int32_t dim = 0; dim < Ndim; dim++) {
         rotDataPointF[(ipu * nDataPointsV + ipv) * Ndim + dim] = splineF[dim];
       }
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index b4d351e8d0407..d235b7ddfde07 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -239,13 +239,13 @@ class Spline2DSpec<DataT, YdimT, 0>
   /// Get interpolated value S(x)
   GPUd() void interpolate(DataT x1, DataT x2, GPUgeneric() DataT S[/*mYdim*/]) const
   {
-    interpolateU<SafetyLevel::kSafe>(mYdim, mParameters, mGridX1.convXtoU(x1), mGridX2.convXtoU(x2), S);
+    interpolateAtU<SafetyLevel::kSafe>(mYdim, mParameters, mGridX1.convXtoU(x1), mGridX2.convXtoU(x2), S);
   }
 
   /// Get interpolated value for an inpYdim-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateUold(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
-                              DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
+  GPUd() void interpolateAtUold(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
+                                DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
   {
 
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
@@ -295,7 +295,7 @@ class Spline2DSpec<DataT, YdimT, 0>
     typedef Spline1DSpec<DataT, 4 * YdimT, 0> TGridX1;
     const TGridX1& gridX1 = reinterpret_cast<const TGridX1&>(mGridX1);
 
-    gridX1.interpolateU(nYdim4, knotU, Su0, Du0, Su1, Du1, u, parU);
+    gridX1.interpolateAtU(nYdim4, knotU, Su0, Du0, Su1, Du1, u, parU);
 
     const DataT* Sv0 = parU + 0;
     const DataT* Dv0 = parU + nYdim;
@@ -304,13 +304,13 @@ class Spline2DSpec<DataT, YdimT, 0>
 
     typedef Spline1DSpec<DataT, YdimT, 0> TGridX2;
     const TGridX2& gridX2 = reinterpret_cast<const TGridX2&>(mGridX2);
-    gridX2.interpolateU(nYdim, knotV, Sv0, Dv0, Sv1, Dv1, v, S);
+    gridX2.interpolateAtU(nYdim, knotV, Sv0, Dv0, Sv1, Dv1, v, S);
   }
 
   /// Get interpolated value for an inpYdim-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
-                           DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
+  GPUd() void interpolateAtU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
+                             DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
   {
 
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
@@ -334,10 +334,8 @@ class Spline2DSpec<DataT, YdimT, 0>
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
 
-    DataT dSl, dDl, dSr, dDr;
-    mGridX1.getUderivatives(knotU, u, dSl, dDl, dSr, dDr);
-    DataT dSd, dDd, dSu, dDu;
-    mGridX2.getUderivatives(knotV, v, dSd, dDd, dSu, dDu);
+    auto [dSl, dDl, dSr, dDr] = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
+    auto [dSd, dDd, dSu, dDu] = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
 
     // when nYdim == 1:
     // S = dSl * (dSd * A[0] + dDd * A[1]) + dDl * (dSd * A[2] + dDd * A[3]) +
@@ -430,18 +428,18 @@ class Spline2DSpec<DataT, YdimT, 1>
 
   /// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateU(GPUgeneric() const DataT Parameters[],
-                           DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
+  GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
+                             DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
   {
-    TBase::template interpolateU<SafeT>(YdimT, Parameters, u1, u2, S);
+    TBase::template interpolateAtU<SafeT>(YdimT, Parameters, u1, u2, S);
   }
 
   /// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateUold(GPUgeneric() const DataT Parameters[],
-                              DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
+  GPUd() void interpolateAtUold(GPUgeneric() const DataT Parameters[],
+                                DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
   {
-    TBase::template interpolateUold<SafeT>(YdimT, Parameters, u1, u2, S);
+    TBase::template interpolateAtUold<SafeT>(YdimT, Parameters, u1, u2, S);
   }
 
   using TBase::getNumberOfKnots;
@@ -451,7 +449,7 @@ class Spline2DSpec<DataT, YdimT, 1>
 #if !defined(GPUCA_GPUCODE)
   using TBase::recreate;
 #endif
-  using TBase::interpolateU;
+  using TBase::interpolateAtU;
 };
 
 /// ==================================================================================================
@@ -507,7 +505,7 @@ class Spline2DSpec<DataT, YdimT, 2>
 
   ///  _______  Expert tools: interpolation with given nYdim and external Parameters _______
 
-  using TBase::interpolateU;
+  using TBase::interpolateAtU;
 };
 
 /// ==================================================================================================
diff --git a/GPU/TPCFastTransformation/SplineHelper.cxx b/GPU/TPCFastTransformation/SplineHelper.cxx
index 6e1b53510e0d0..af3efb1c4817d 100644
--- a/GPU/TPCFastTransformation/SplineHelper.cxx
+++ b/GPU/TPCFastTransformation/SplineHelper.cxx
@@ -410,8 +410,8 @@ void SplineHelper<DataT>::approximateFunction(
         }
         double splineF[mFdimensions];
         double u = mHelpers[dimension].getDataPoint(i).u;
-        mHelpers[dimension].getSpline().interpolateU(mFdimensions, parD[dimension].get(), u, splineF); // recalculate at all datapoints of dimension
-        for (int32_t dim = 0; dim < mFdimensions; dim++) {                                             // writing it in allParameters
+        mHelpers[dimension].getSpline().interpolateAtU(mFdimensions, parD[dimension].get(), u, splineF); // recalculate at all datapoints of dimension
+        for (int32_t dim = 0; dim < mFdimensions; dim++) {                                               // writing it in allParameters
           // LOG(info)<<allParameters [p-(int32_t)(pow(2.0, dimension))] [(int32_t)(startdatapoint*mFdimensions + i*distance + dim)]<<", ";
           allParameters[p - (int32_t)(pow(2.0, dimension))][(int32_t)(startdatapoint * mFdimensions + i * distance + dim)] = splineF[dim]; // write it in the array.
           // LOG(info)<<allParameters [p-(int32_t)(pow(2.0, dimension))] [(int32_t)(startdatapoint*mFdimensions + i*distance + dim)]<<",   ";
diff --git a/GPU/TPCFastTransformation/SplineSpec.h b/GPU/TPCFastTransformation/SplineSpec.h
index 744be943181db..2102b73e72900 100644
--- a/GPU/TPCFastTransformation/SplineSpec.h
+++ b/GPU/TPCFastTransformation/SplineSpec.h
@@ -276,13 +276,13 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
     for (int32_t i = 0; i < nXdim; i++) {
       u[i] = mGrid[i].convXtoU(x[i]);
     }
-    interpolateU<SafetyLevel::kSafe>(mXdim, mYdim, mParameters, u, S);
+    interpolateAtU<SafetyLevel::kSafe>(mXdim, mYdim, mParameters, u, S);
   }
 
   /// Get interpolated value for S(u):inpXdim->inpYdim using spline parameters Parameters
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateU(int32_t inpXdim, int32_t inpYdim, GPUgeneric() const DataT Parameters[],
-                           const DataT u[/*inpXdim*/], GPUgeneric() DataT S[/*inpYdim*/]) const
+  GPUd() void interpolateAtU(int32_t inpXdim, int32_t inpYdim, GPUgeneric() const DataT Parameters[],
+                             const DataT u[/*inpXdim*/], GPUgeneric() DataT S[/*inpYdim*/]) const
   {
     const auto nXdimTmp = SplineUtil::getNdim<XdimT>(mXdim);
     const auto nXdim = nXdimTmp.get();
@@ -345,7 +345,7 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
       DataT coordinate = u[d];
       typedef Spline1DSpec<DataT, 0, 0> TGridX;
       const TGridX& gridX = *((const TGridX*)&(mGrid[d]));
-      gridX.interpolateU(nInterpolations, knotL, S0, D0, S1, D1, coordinate, iParameters);
+      gridX.interpolateAtU(nInterpolations, knotL, S0, D0, S1, D1, coordinate, iParameters);
       nInterpolations /= 4;
       nKnots /= 2;
     } // end d (every dimension)
@@ -354,7 +354,7 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
       S[i] = iParameters[i]; // write into result-array
       // LOG(info)<<iParameters[i] <<", ";
     }
-  } // end interpolateU
+  } // end interpolateAtU
 
  protected:
   using TBase::mGrid;
@@ -421,10 +421,10 @@ class SplineSpec<DataT, XdimT, YdimT, 1>
 
   /// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateU(GPUgeneric() const DataT Parameters[],
-                           const DataT u[/*XdimT*/], GPUgeneric() DataT S[/*YdimT*/]) const
+  GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
+                             const DataT u[/*XdimT*/], GPUgeneric() DataT S[/*YdimT*/]) const
   {
-    TBase::template interpolateU<SafeT>(XdimT, YdimT, Parameters, u, S);
+    TBase::template interpolateAtU<SafeT>(XdimT, YdimT, Parameters, u, S);
   }
 
   /// _______________  Suppress some parent class methods   ________________________
@@ -432,7 +432,7 @@ class SplineSpec<DataT, XdimT, YdimT, 1>
 #if !defined(GPUCA_GPUCODE)
   using TBase::recreate;
 #endif
-  using TBase::interpolateU;
+  using TBase::interpolateAtU;
 };
 
 /// ==================================================================================================
@@ -490,7 +490,7 @@ class SplineSpec<DataT, XdimT, YdimT, 2>
 
   ///  _______  Expert tools: interpolation with given nYdim and external Parameters _______
 
-  using TBase::interpolateU;
+  using TBase::interpolateAtU;
 
   /// Check dimensions
   void checkDimensions(int32_t& nXdim, int32_t& nYdim)
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index f84fde4fffd8c..76368efcd8a4f 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -410,7 +410,7 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrect
   auto [gridU, gridV, scale] = convLocalToGrid(sector, row, y, z);
 
   float dxyz[3];
-  spline.interpolateU(splineData, gridU, gridV, dxyz);
+  spline.interpolateAtU(splineData, gridU, gridV, dxyz);
 
   float dx = scale * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
   float dy = scale * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
@@ -427,7 +427,7 @@ GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t secto
   auto [gridU, gridV, scale] = convCorrectedLocalToGrid(sector, row, realY, realZ);
 
   float dx = 0;
-  spline.interpolateU(splineData, gridU, gridV, &dx);
+  spline.interpolateAtU(splineData, gridU, gridV, &dx);
 
   dx = scale * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
   return dx;
@@ -443,7 +443,7 @@ GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::getCorrectionYZat
   const float* splineData = getSplineData(sector, row, 2);
 
   float dyz[2];
-  spline.interpolateU(splineData, gridU, gridV, dyz);
+  spline.interpolateAtU(splineData, gridU, gridV, dyz);
 
   dyz[0] = scale * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
   dyz[1] = scale * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);

From 47283cd6ac5df3046a2324387b9e776ec54ae367 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Fri, 11 Apr 2025 15:06:35 +0000
Subject: [PATCH 1571/1764] TPC Splines: fast merge of SC corrections

---
 .../TPCFastSpaceChargeCorrectionHelper.h      |  10 +-
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 163 ++++++++++++------
 GPU/TPCFastTransformation/Spline1DSpec.h      |  88 +++++-----
 GPU/TPCFastTransformation/Spline2DSpec.h      | 135 ++++++++++++++-
 .../TPCFastSpaceChargeCorrection.h            | 127 ++++++++++++--
 5 files changed, 401 insertions(+), 122 deletions(-)

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
index abbc5b7116b2d..747ed74c9bcad 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
@@ -102,7 +102,15 @@ class TPCFastSpaceChargeCorrectionHelper
   /// initialise inverse transformation from linear combination of several input corrections
   void initInverse(std::vector<o2::gpu::TPCFastSpaceChargeCorrection*>& corrections, const std::vector<float>& scaling, bool prn);
 
-  void MergeCorrections(std::vector<o2::gpu::TPCFastSpaceChargeCorrection*>& corrections, const std::vector<float>& scaling, bool prn);
+  /// merge several corrections
+  /// \param mainCorrection main correction
+  /// \param scale scaling factor for the main correction
+  /// \param additionalCorrections vector of pairs of additional corrections and their scaling factors
+  /// \param prn printout flag
+  /// \return main correction merged with additional corrections
+  void MergeCorrections(
+    o2::gpu::TPCFastSpaceChargeCorrection& mainCorrection, float scale,
+    const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>>& additionalCorrections, bool prn);
 
  private:
   /// geometry initialization
diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 92817063831f6..6ba3d6e12dd9e 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -176,8 +176,8 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
         }
 
         if (processingInverseCorrection) {
-          float* splineX = correction.getSplineData(sector, row, 1);
-          float* splineYZ = correction.getSplineData(sector, row, 2);
+          float* splineX = correction.getSplineDataInvX(sector, row);
+          float* splineYZ = correction.getSplineDataInvYZ(sector, row);
           for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
             splineX[i] = splineParameters[3 * i + 0];
             splineYZ[2 * i + 0] = splineParameters[3 * i + 1];
@@ -940,8 +940,8 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
                                      dataPointGridU.data(), dataPointGridV.data(),
                                      dataPointF.data(), nDataPoints);
 
-        float* splineX = correction.getSplineData(sector, row, 1);
-        float* splineUV = correction.getSplineData(sector, row, 2);
+        float* splineX = correction.getSplineDataInvX(sector, row);
+        float* splineUV = correction.getSplineDataInvYZ(sector, row);
         for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
           splineX[i] = splineParameters[3 * i + 0];
           splineUV[2 * i + 0] = splineParameters[3 * i + 1];
@@ -967,77 +967,129 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
   LOGP(info, "Inverse tooks: {}s", duration);
 }
 
-void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(std::vector<o2::gpu::TPCFastSpaceChargeCorrection*>& corrections, const std::vector<float>& scaling, bool prn)
+void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(
+  o2::gpu::TPCFastSpaceChargeCorrection& mainCorrection, float mainScale,
+  const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>>& additionalCorrections, bool /*prn*/)
 {
   /// merge several corrections
-  /*
+
   TStopwatch watch;
   LOG(info) << "fast space charge correction helper: Merge corrections";
 
-  if (corrections.size() != scaling.size()) {
-    LOGP(error, "Input corrections and scaling values have different size");
-    return;
-  }
-
-  auto& correction = *(corrections.front());
+  const auto& geo = mainCorrection.getGeometry();
 
-  for (int sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
+  for (int sector = 0; sector < geo.getNumberOfSectors(); sector++) {
 
     auto myThread = [&](int iThread) {
-      for (int row = iThread; row < mGeo.getNumberOfRows(); row += mNthreads) {
-        TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(sector, row);
+      for (int row = iThread; row < geo.getNumberOfRows(); row += mNthreads) {
+        const auto& spline = mainCorrection.getSpline(sector, row);
 
-        std::vector<float> splineParameters(spline.getNumberOfParameters());
-        std::vector<float> splineParametersInvX(spline.getNumberOfParameters());
-        std::vector<float> splineParametersInvYZ(spline.getNumberOfParameters());
+        float* splineParameters = mainCorrection.getSplineData(sector, row);
+        float* splineParametersInvX = mainCorrection.getSplineDataInvX(sector, row);
+        float* splineParametersInvYZ = mainCorrection.getSplineDataInvYZ(sector, row);
 
-        const auto& gridU = spline.getGridX1();
-        const auto& gridV = spline.getGridX2();
-
-        for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
-          double u = gridU.getKnot(iu).u;
-          for (int iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
-            int knotIndex = spline.getKnotIndex(iu, iv);
+        auto& secRowInfo = mainCorrection.getSectorRowInfo(sector, row);
 
-            double v = gridV.getKnot(iu).u;
-            auto [y, z] = correction.convGridToLocal(sector, row, u, v);
-            constexpr int nKnotPar1d = 4;
-            constexpr int nKnotPar2d = nKnotPar1d * 2;
-            constexpr int nKnotPar3d = nKnotPar1d * 3;
+        constexpr int nKnotPar1d = 4;
+        constexpr int nKnotPar2d = nKnotPar1d * 2;
+        constexpr int nKnotPar3d = nKnotPar1d * 3;
 
-            for (int i = 0; i < corrections.size(); ++i) {
-              double s = scaling[i];
-              auto p = corrections[i]->getCorrectionParameters(sector, row, y, z);
-              for (int j = 0; j < nKnotPar3d; ++j) {
-                splineParameters[knotIndex * nKnotPar3d + j] += s * p[j];
+        { // scale the main correction
+          for (int i = 0; i < 3; i++) {
+            secRowInfo.maxCorr[i] *= mainScale;
+            secRowInfo.minCorr[i] *= mainScale;
+          }
+          double parscale[4] = {mainScale, mainScale, mainScale, mainScale * mainScale};
+          for (int iknot = 0, ind = 0; iknot < spline.getNumberOfKnots(); iknot++) {
+            for (int ipar = 0; ipar < nKnotPar1d; ++ipar) {
+              for (int idim = 0; idim < 3; idim++, ind++) {
+                splineParameters[ind] *= parscale[ipar];
               }
-              auto pInvX = corrections[i]->getCorrectionParametersInvX(sector, row, y, z);
-              for (int j = 0; j < nKnotPar1d; ++j) {
-                splineParametersInvX[knotIndex * nKnotPar1d + j] += s * pInvX[j];
+            }
+          }
+          for (int iknot = 0, ind = 0; iknot < spline.getNumberOfKnots(); iknot++) {
+            for (int ipar = 0; ipar < nKnotPar1d; ++ipar) {
+              for (int idim = 0; idim < 1; idim++, ind++) {
+                splineParametersInvX[ind] *= parscale[ipar];
               }
-              auto pInvYZ = corrections[i]->getCorrectionParametersInvYZ(sector, row, y, z);
-              for (int j = 0; j < nKnotPar2d; ++j) {
-                splineParametersInvYZ[knotIndex * nKnotPar2d + j] += s * pInvYZ[j];
+            }
+          }
+          for (int iknot = 0, ind = 0; iknot < spline.getNumberOfKnots(); iknot++) {
+            for (int ipar = 0; ipar < nKnotPar1d; ++ipar) {
+              for (int idim = 0; idim < 2; idim++, ind++) {
+                splineParametersInvYZ[ind] *= parscale[ipar];
               }
             }
-          } // iv
-        }   // iu
+          }
+        }
 
-        float* splineXYZ = correction.getSplineData(sector, row, 0);
-        float* splineInvX = correction.getSplineData(sector, row, 1);
-        float* splineInvYZ = correction.getSplineData(sector, row, 2);
+        // add the other corrections
 
-        for (int i = 0; i < spline.getNumberOfParameters(); i++) {
-          splineXYZ[i] = splineParameters[i];
-        }
-        for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
-          splineX[i] = splineParametersInvX[i];
-          splineYZ[2 * i + 0] = splineParametersInvYZ[2 * i + 0];
-          splineYZ[2 * i + 1] = splineParametersInvYZ[2 * i + 1];
-        }
+        const auto& gridU = spline.getGridX1();
+        const auto& gridV = spline.getGridX2();
+
+        for (int icorr = 0; icorr < additionalCorrections.size(); ++icorr) {
+          const auto& corr = *(additionalCorrections[icorr].first);
+          double scale = additionalCorrections[icorr].second;
+          auto& linfo = corr.getSectorRowInfo(sector, row);
+          secRowInfo.updateMaxValues(linfo.getMaxValues(), scale);
+          secRowInfo.updateMaxValues(linfo.getMinValues(), scale);
+
+          double scaleU = secRowInfo.scaleUtoGrid / linfo.scaleUtoGrid;
+          double scaleV = secRowInfo.scaleVtoGrid / linfo.scaleVtoGrid;
+
+          for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
+            double u = gridU.getKnot(iu).u;
+            for (int iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
+              double v = gridV.getKnot(iu).u;
+              int knotIndex = spline.getKnotIndex(iu, iv);
+              float P[nKnotPar3d];
+
+              { // direct correction
+                auto [y, z] = mainCorrection.convGridToLocal(sector, row, u, v);
+                // return values: u, v, scaling factor
+                auto [lu, lv, ls] = corr.convLocalToGrid(sector, row, y, z);
+                ls *= scale;
+                double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * ls * scaleU * scaleV};
+                const auto& spl = corr.getSpline(sector, row);
+                spl.interpolateParametersAtU(corr.getSplineData(sector, row), lu, lv, P);
+                for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
+                  for (int idim = 0; idim < 3; idim++, ind++) {
+                    splineParameters[knotIndex * nKnotPar3d + ind] += parscale[ipar] * P[ind];
+                  }
+                }
+              }
+
+              auto [y, z] = mainCorrection.convGridToCorrectedLocal(sector, row, u, v);
+              // return values: u, v, scaling factor
+              auto [lu, lv, ls] = corr.convCorrectedLocalToGrid(sector, row, y, z);
+              ls *= scale;
+              double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * ls * scaleU * scaleV};
+
+              { // inverse X correction
+                corr.getSplineInvX(sector, row).interpolateParametersAtU(corr.getSplineDataInvX(sector, row), lu, lv, P);
+                for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
+                  for (int idim = 0; idim < 1; idim++, ind++) {
+                    splineParametersInvX[knotIndex * nKnotPar1d + ind] += parscale[ipar] * P[ind];
+                  }
+                }
+              }
+
+              { // inverse YZ correction
+                corr.getSplineInvYZ(sector, row).interpolateParametersAtU(corr.getSplineDataInvYZ(sector, row), lu, lv, P);
+                for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
+                  for (int idim = 0; idim < 2; idim++, ind++) {
+                    splineParametersInvYZ[knotIndex * nKnotPar2d + ind] += parscale[ipar] * P[ind];
+                  }
+                }
+              }
+
+            } // iv
+          } // iu
+        } // corrections
 
       } // row
-    };  // thread
+    }; // thread
 
     std::vector<std::thread> threads(mNthreads);
 
@@ -1054,7 +1106,6 @@ void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(std::vector<o2::gpu::T
   } // sector
   float duration = watch.RealTime();
   LOGP(info, "Merge of corrections tooks: {}s", duration);
-  */
 }
 
 } // namespace tpc
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index fcabbbad12098..1c591a957847d 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -318,7 +318,10 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     for (int32_t dim = 0; dim < nYdim; ++dim) {
       S[dim] = dSdSr * Sr[dim] + dSdSl * Sl[dim] + dSdDl * Dl[dim] + dSdDr * Dr[dim];
     }
+
     /*
+    another way to calculate f(u):
+
     if (u < (DataT)0) {
       u = (DataT)0;
     }
@@ -336,18 +339,6 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
       S[dim] = ((a * v + b) * v + Dl[dim]) * uu + Sl[dim];
     }
     */
-    /*
-     another way to calculate f(u):
-     T uu = T(u - knotL.u);
-     T v = uu * T(knotL.Li); // scaled u
-     T vm1 = v-1;
-     T v2 = v * v;
-     float cSr = v2*(3-2*v);
-     float cSl = 1-cSr;
-     float cDl = v*vm1*vm1*knotL.L;
-     float cDr = v2*vm1*knotL.L;
-     return cSl*Sl + cSr*Sr + cDl*Dl + cDr*Dr;
-    */
   }
 
   template <typename T>
@@ -365,51 +356,50 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
 
     u = u - knotL.u;
     T v = u * T(knotL.Li); // scaled u
-    T vm1 = v - 1.;
+    T vm1 = v - T(1.);
     T a = u * vm1;
     T v2 = v * v;
-    T dSdSr = v2 * (3. - 2 * v);
-    T dSdSl = 1. - dSdSr;
+    T dSdSr = v2 * (T(3.) - v - v);
+    T dSdSl = T(1.) - dSdSr;
     T dSdDl = vm1 * a;
     T dSdDr = v * a;
     // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
     return std::make_tuple(dSdSl, dSdDl, dSdSr, dSdDr);
   }
-  /*
-    template <typename T>
-    GPUd() void getUsecondDerivatives(const Knot& knotL, DataT u,
-                                      T& dSl, T& dDl, T& dSr, T& dDr,
-                                      T& dSl2, T& dDl2, T& dSr2, T& dDr2) const
-    {
-      /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
-      /// over the spline values Sl, Sr and the slopes Dl, Dr
-
-      if (u < (DataT)0) {
-        u = (DataT)0;
-      }
-      if (u > (DataT)TBase::getUmax()) {
-        u = (DataT)TBase::getUmax();
-      }
-
-      u = u - knotL.u;
-      T v = u * T(knotL.Li); // scaled u
-      T vm1 = v - 1.;
-      T a = u * vm1;
-      T v2 = v * v;
-      dSr = v2 * (3. - 2 * v);
-      dSl = 1. - dSr;
-      dDl = vm1 * a;
-      dDr = v * a;
-      T dv = T(knotL.Li);
-      dSr2 = 6. * v * (1. - v) * dv;
-      dSl2 = -dSr2;
-      dDl2 = (v - 1) * (3 * v - 1);
-      dDr = u * (v * v - v);
-      dDr2 = 3.f * v * v - 2.f * v;
-      // F(u) = dSl * Sl + dSr * Sr + dDl * Dl + dDr * Dr;
-      // dF(u)/du = dSl2 * Sl + dSr2 * Sr + dDl2 * Dl + dDr2 * Dr;
+
+  template <typename T>
+  GPUd() std::tuple<T, T, T, T, T, T, T, T> getSDderivativesOverParsAtU(const Knot& knotL, DataT u) const
+  {
+    /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
+    /// over the spline values Sl, Sr and the slopes Dl, Dr
+
+    if (u < (DataT)0) {
+      u = (DataT)0;
     }
-  */
+    if (u > (DataT)TBase::getUmax()) {
+      u = (DataT)TBase::getUmax();
+    }
+
+    u = u - knotL.u;
+    T v = u * T(knotL.Li); // scaled u
+    T vm1 = v - T(1.);
+    T a = u * vm1;
+    T v2 = v * v;
+    T dSdSr = v2 * (T(3.) - v - v);
+    T dSdSl = T(1.) - dSdSr;
+    T dSdDl = vm1 * a;
+    T dSdDr = v * a;
+
+    T dv = T(knotL.Li);
+    T dDdSr = 6. * v * (T(1.) - v) * dv;
+    T dDdSl = -dDdSr;
+    T dDdDl = vm1 * (v + v + vm1);
+    T dDdDr = v * (v + vm1 + vm1);
+    // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
+    // D(u) = dS(u)/du = dDdSl * Sl + dDdSr * Sr + dDdDl * Dl + dDdDr * Dr;
+    return std::make_tuple(dSdSl, dSdDl, dSdSr, dSdDr, dDdSl, dDdDl, dDdSr, dDdDr);
+  }
+
   using TBase::convXtoU;
   using TBase::getKnot;
   using TBase::getKnots;
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index d235b7ddfde07..987ce1ad5d256 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -358,6 +358,132 @@ class Spline2DSpec<DataT, YdimT, 0>
     }
   }
 
+  /// Get interpolated parameters (like parameters stored at knots) for an inpYdim-dimensional S(u1,u2) using spline parameters Parameters.
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() void interpolateParametersAtU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
+                                       DataT u1, DataT u2, GPUgeneric() DataT P[/* 4*inpYdim */]) const
+  {
+
+    const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
+    const int32_t nYdim = nYdimTmp.get();
+
+    // const auto maxYdim = SplineUtil::getMaxNdim<YdimT>(inpYdim);
+    // const int32_t maxYdim4 = 4 * maxYdim.get();
+
+    // const auto nYdim2 = nYdim * 2;
+    const auto nYdim4 = nYdim * 4;
+
+    DataT *S = P,
+          *R = P + nYdim,
+          *Q = P + nYdim * 2,
+          *W = P + nYdim * 3;
+
+    const DataT& u = u1;
+    const DataT& v = u2;
+    int32_t nu = mGridX1.getNumberOfKnots();
+    int32_t iu = mGridX1.template getLeftKnotIndexForU<SafeT>(u);
+    int32_t iv = mGridX2.template getLeftKnotIndexForU<SafeT>(v);
+
+    const typename TBase::Knot& knotU = mGridX1.template getKnot<SafetyLevel::kNotSafe>(iu);
+    const typename TBase::Knot& knotV = mGridX2.template getKnot<SafetyLevel::kNotSafe>(iv);
+
+    const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
+    const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
+
+    auto [dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr] = mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u);
+    auto [dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu] = mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v);
+
+    // when nYdim == 1:
+
+    // Function value S
+    // S = dSdSl * (dSdSd * A[0] + dSdDd * A[1]) + dSdDl * (dSdSd * A[2] + dSdDd * A[3]) +
+    //     dSdSr * (dSdSd * A[4] + dSdDd * A[5]) + dSdDr * (dSdSd * A[6] + dSdDd * A[7]) +
+    //     dSdSl * (dSdSu * B[0] + dSdDu * B[1]) + dSdDl * (dSdSu * B[2] + dSdDu * B[3]) +
+    //     dSdSr * (dSdSu * B[4] + dSdDu * B[5]) + dSdDr * (dSdSu * B[6] + dSdDu * B[7]);
+
+    {
+      DataT a[8] = {dSdSl * dSdSd, dSdSl * dSdDd, dSdDl * dSdSd, dSdDl * dSdDd,
+                    dSdSr * dSdSd, dSdSr * dSdDd, dSdDr * dSdSd, dSdDr * dSdDd};
+      DataT b[8] = {dSdSl * dSdSu, dSdSl * dSdDu, dSdDl * dSdSu, dSdDl * dSdDu,
+                    dSdSr * dSdSu, dSdSr * dSdDu, dSdDr * dSdSu, dSdDr * dSdDu};
+
+      // S = sum a[i]*A[i] + b[i]*B[i]
+
+      for (int32_t dim = 0; dim < nYdim; dim++) {
+        S[dim] = 0;
+        for (int32_t i = 0; i < 8; i++) {
+          S[dim] += a[i] * A[nYdim * i + dim] + b[i] * B[nYdim * i + dim];
+        }
+      }
+    }
+
+    // Derivative R = dS / du
+    // R = dRdSl * (dSdSd * A[0] + dSdDd * A[1]) + dRdDl * (dSdSd * A[2] + dSdDd * A[3]) +
+    //     dRdSr * (dSdSd * A[4] + dSdDd * A[5]) + dRdDr * (dSdSd * A[6] + dSdDd * A[7]) +
+    //     dRdSl * (dSdSu * B[0] + dSdDu * B[1]) + dRdDl * (dSdSu * B[2] + dSdDu * B[3]) +
+    //     dRdSr * (dSdSu * B[4] + dSdDu * B[5]) + dRdDr * (dSdSu * B[6] + dSdDu * B[7]);
+
+    {
+      DataT a[8] = {dRdSl * dSdSd, dRdSl * dSdDd, dRdDl * dSdSd, dRdDl * dSdDd,
+                    dRdSr * dSdSd, dRdSr * dSdDd, dRdDr * dSdSd, dRdDr * dSdDd};
+      DataT b[8] = {dRdSl * dSdSu, dRdSl * dSdDu, dRdDl * dSdSu, dRdDl * dSdDu,
+                    dRdSr * dSdSu, dRdSr * dSdDu, dRdDr * dSdSu, dRdDr * dSdDu};
+
+      // R = sum a[i]*A[i] + b[i]*B[i]
+
+      for (int32_t dim = 0; dim < nYdim; dim++) {
+        R[dim] = 0;
+        for (int32_t i = 0; i < 8; i++) {
+          R[dim] += a[i] * A[nYdim * i + dim] + b[i] * B[nYdim * i + dim];
+        }
+      }
+    }
+
+    // Derivative Q = dS / dv
+    // Q = dSdSl * (dQdSd * A[0] + dQdDd * A[1]) + dSdDl * (dQdSd * A[2] + dQdDd * A[3]) +
+    //     dSdSr * (dQdSd * A[4] + dQdDd * A[5]) + dSdDr * (dQdSd * A[6] + dQdDd * A[7]) +
+    //     dSdSl * (dQdSu * B[0] + dQdDu * B[1]) + dSdDl * (dQdSu * B[2] + dQdDu * B[3]) +
+    //     dSdSr * (dQdSu * B[4] + dQdDu * B[5]) + dSdDr * (dQdSu * B[6] + dQdDu * B[7]);
+
+    {
+      DataT a[8] = {dSdSl * dQdSd, dSdSl * dQdDd, dSdDl * dQdSd, dSdDl * dQdDd,
+                    dSdSr * dQdSd, dSdSr * dQdDd, dSdDr * dQdSd, dSdDr * dQdDd};
+      DataT b[8] = {dSdSl * dQdSu, dSdSl * dQdDu, dSdDl * dQdSu, dSdDl * dQdDu,
+                    dSdSr * dQdSu, dSdSr * dQdDu, dSdDr * dQdSu, dSdDr * dQdDu};
+
+      // Q = sum a[i]*A[i] + b[i]*B[i]
+
+      for (int32_t dim = 0; dim < nYdim; dim++) {
+        Q[dim] = 0;
+        for (int32_t i = 0; i < 8; i++) {
+          Q[dim] += a[i] * A[nYdim * i + dim] + b[i] * B[nYdim * i + dim];
+        }
+      }
+    }
+
+    // cross-derivative W = (dS)^2 / du / dv
+    // W = dRdSl * (dQdSd * A[0] + dQdDd * A[1]) + dRdDl * (dQdSd * A[2] + dQdDd * A[3]) +
+    //     dRdSr * (dQdSd * A[4] + dQdDd * A[5]) + dRdDr * (dQdSd * A[6] + dQdDd * A[7]) +
+    //     dRdSl * (dQdSu * B[0] + dQdDu * B[1]) + dRdDl * (dQdSu * B[2] + dQdDu * B[3]) +
+    //     dRdSr * (dQdSu * B[4] + dQdDu * B[5]) + dRdDr * (dQdSu * B[6] + dQdDu * B[7]);
+
+    {
+      DataT a[8] = {dRdSl * dQdSd, dRdSl * dQdDd, dRdDl * dQdSd, dRdDl * dQdDd,
+                    dRdSr * dQdSd, dRdSr * dQdDd, dRdDr * dQdSd, dRdDr * dQdDd};
+      DataT b[8] = {dRdSl * dQdSu, dRdSl * dQdDu, dRdDl * dQdSu, dRdDl * dQdDu,
+                    dRdSr * dQdSu, dRdSr * dQdDu, dRdDr * dQdSu, dRdDr * dQdDu};
+
+      // W = sum a[i]*A[i] + b[i]*B[i]
+
+      for (int32_t dim = 0; dim < nYdim; dim++) {
+        W[dim] = 0;
+        for (int32_t i = 0; i < 8; i++) {
+          W[dim] += a[i] * A[nYdim * i + dim] + b[i] * B[nYdim * i + dim];
+        }
+      }
+    }
+  }
+
  protected:
   using TBase::mGridX1;
   using TBase::mGridX2;
@@ -429,11 +555,18 @@ class Spline2DSpec<DataT, YdimT, 1>
   /// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
   GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
-                             DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
+                             DataT u1, DataT u2, GPUgeneric() DataT S[/*YdimT*/]) const
   {
     TBase::template interpolateAtU<SafeT>(YdimT, Parameters, u1, u2, S);
   }
 
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() void interpolateParametersAtU(GPUgeneric() const DataT Parameters[],
+                                       DataT u1, DataT u2, GPUgeneric() DataT P[/* 4*YdimT */]) const
+  {
+    TBase::template interpolateParametersAtU<SafeT>(YdimT, Parameters, u1, u2, P);
+  }
+
   /// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
   GPUd() void interpolateAtUold(GPUgeneric() const DataT Parameters[],
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 76368efcd8a4f..da37409221d6c 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -82,6 +82,24 @@ class TPCFastSpaceChargeCorrection : public FlatObject
       maxCorr[2] = GPUCommonMath::Max(maxCorr[2], dv);
     }
 
+    void updateMaxValues(std::tuple<float, float, float> dxdudv, float scale)
+    {
+      float dx = std::get<0>(dxdudv) * scale;
+      float du = std::get<1>(dxdudv) * scale;
+      float dv = std::get<2>(dxdudv) * scale;
+      updateMaxValues(dx, du, dv);
+    }
+
+    std::tuple<float, float, float> getMaxValues() const
+    {
+      return std::make_tuple(maxCorr[0], maxCorr[1], maxCorr[2]);
+    }
+
+    std::tuple<float, float, float> getMinValues() const
+    {
+      return std::make_tuple(minCorr[0], minCorr[1], minCorr[2]);
+    }
+
     ClassDefNV(SectorRowInfo, 2);
   };
 
@@ -90,7 +108,11 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     ClassDefNV(SectorInfo, 1);
   };
 
-  typedef Spline2D<float, 3> SplineType;
+  typedef Spline2D<float, 3> SplineTypeXYZ;
+  typedef Spline2D<float, 1> SplineTypeInvX;
+  typedef Spline2D<float, 2> SplineTypeInvYZ;
+
+  typedef SplineTypeXYZ SplineType;
 
   /// _____________  Constructors / destructors __________________________
 
@@ -168,6 +190,30 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// Gives pointer to spline data
   GPUd() const float* getSplineData(int32_t sector, int32_t row, int32_t iSpline = 0) const;
 
+  /// Gives const pointer to a spline for the inverse X correction
+  GPUd() const SplineTypeInvX& getSplineInvX(int32_t sector, int32_t row) const;
+
+  /// Gives pointer to a spline for the inverse X correction
+  GPUd() SplineTypeInvX& getSplineInvX(int32_t sector, int32_t row);
+
+  /// Gives pointer to spline data for the inverse X correction
+  GPUd() float* getSplineDataInvX(int32_t sector, int32_t row);
+
+  /// Gives pointer to spline data for the inverse X correction
+  GPUd() const float* getSplineDataInvX(int32_t sector, int32_t row) const;
+
+  /// Gives const pointer to a spline for the inverse YZ correction
+  GPUd() const SplineTypeInvYZ& getSplineInvYZ(int32_t sector, int32_t row) const;
+
+  /// Gives pointer to a spline for the inverse YZ correction
+  GPUd() SplineTypeInvYZ& getSplineInvYZ(int32_t sector, int32_t row);
+
+  /// Gives pointer to spline data for the inverse YZ correction
+  GPUd() float* getSplineDataInvYZ(int32_t sector, int32_t row);
+
+  /// Gives pointer to spline data for the inverse YZ correction
+  GPUd() const float* getSplineDataInvYZ(int32_t sector, int32_t row) const;
+
   /// _______________ The main method: cluster correction  _______________________
   ///
   // GPUd() int32_t getCorrectionInternal(int32_t sector, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
@@ -193,6 +239,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// convert corrected u,v to internal grid coordinates
   GPUd() std::tuple<float, float, float> convCorrectedLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
 
+  /// convert internal grid coordinates to corrected u,v
+  /// return values: u, v, scaling factor
+  GPUd() std::tuple<float, float> convGridToCorrectedLocal(int32_t sector, int32_t row, float u, float v) const;
+
   GPUd() bool isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
 
   /// TPC geometry information
@@ -316,6 +366,54 @@ GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t sector,
   return reinterpret_cast<float*>(mSplineData[iSpline] + mSectorDataSizeBytes[iSpline] * sector + rowInfo.dataOffsetBytes[iSpline]);
 }
 
+GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCorrection::getSplineInvX(int32_t sector, int32_t row)
+{
+  /// Gives pointer to spline for the inverse X correction
+  return reinterpret_cast<SplineTypeInvX&>(getSpline(sector, row));
+}
+
+GPUdi() const TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCorrection::getSplineInvX(int32_t sector, int32_t row) const
+{
+  /// Gives const pointer to spline for the inverse X correction
+  return reinterpret_cast<const SplineTypeInvX&>(getSpline(sector, row));
+}
+
+GPUdi() float* TPCFastSpaceChargeCorrection::getSplineDataInvX(int32_t sector, int32_t row)
+{
+  /// Gives pointer to spline data for the inverse X correction
+  return getSplineData(sector, row, 1);
+}
+
+GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineDataInvX(int32_t sector, int32_t row) const
+{
+  /// Gives pointer to spline data for the inverse X correction
+  return getSplineData(sector, row, 1);
+}
+
+GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvYZ& TPCFastSpaceChargeCorrection::getSplineInvYZ(int32_t sector, int32_t row)
+{
+  /// Gives pointer to spline for the inverse YZ correction
+  return reinterpret_cast<SplineTypeInvYZ&>(getSpline(sector, row));
+}
+
+GPUdi() const TPCFastSpaceChargeCorrection::SplineTypeInvYZ& TPCFastSpaceChargeCorrection::getSplineInvYZ(int32_t sector, int32_t row) const
+{
+  /// Gives const pointer to spline for the inverse YZ correction
+  return reinterpret_cast<const SplineTypeInvYZ&>(getSpline(sector, row));
+}
+
+GPUdi() float* TPCFastSpaceChargeCorrection::getSplineDataInvYZ(int32_t sector, int32_t row)
+{
+  /// Gives pointer to spline data for the inverse YZ correction
+  return getSplineData(sector, row, 2);
+}
+
+GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineDataInvYZ(int32_t sector, int32_t row) const
+{
+  /// Gives pointer to spline data for the inverse YZ correction
+  return getSplineData(sector, row, 2);
+}
+
 GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// convert local y, z to internal grid coordinates u,v
@@ -401,6 +499,17 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convCorrec
   return {gridU, gridV, scale};
 }
 
+GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToCorrectedLocal(int32_t sector, int32_t row, float gridU, float gridV) const
+{
+  /// convert internal grid coordinates u,v to corrected y, z
+  const SectorRowInfo& info = getSectorRowInfo(sector, row);
+  float u = info.gridCorrU0 + gridU / info.scaleCorrUtoGrid;
+  float v = info.gridCorrV0 + gridV / info.scaleCorrVtoGrid;
+  float y, z;
+  mGeo.convUVtoLocal1(sector, u, v, y, z);
+  return {y, z};
+}
+
 GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const
 {
   const auto& info = getSectorRowInfo(sector, row);
@@ -421,33 +530,21 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrect
 GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
   const auto& info = getSectorRowInfo(sector, row);
-  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(sector, row));
-  const float* splineData = getSplineData(sector, row, 1);
-
   auto [gridU, gridV, scale] = convCorrectedLocalToGrid(sector, row, realY, realZ);
-
   float dx = 0;
-  spline.interpolateAtU(splineData, gridU, gridV, &dx);
-
+  getSplineInvX(sector, row).interpolateAtU(getSplineDataInvX(sector, row), gridU, gridV, &dx);
   dx = scale * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
   return dx;
 }
 
 GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
-
   auto [gridU, gridV, scale] = convCorrectedLocalToGrid(sector, row, realY, realZ);
-
   const auto& info = getSectorRowInfo(sector, row);
-  const Spline2D<float, 2>& spline = reinterpret_cast<const Spline2D<float, 2>&>(getSpline(sector, row));
-  const float* splineData = getSplineData(sector, row, 2);
-
   float dyz[2];
-  spline.interpolateAtU(splineData, gridU, gridV, dyz);
-
+  getSplineInvYZ(sector, row).interpolateAtU(getSplineDataInvYZ(sector, row), gridU, gridV, dyz);
   dyz[0] = scale * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
   dyz[1] = scale * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
-
   return {dyz[0], dyz[1]};
 }
 

From 98e7ac28070839a7985ee342af2d39824729a627 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Sat, 12 Apr 2025 16:10:13 +0000
Subject: [PATCH 1572/1764] TPC Splines: get rid of internal UV coordinates

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    |  59 ++++-----
 .../src/TPCFastTransformHelperO2.cxx          |   7 +-
 .../TPCFastSpaceChargeCorrection.cxx          | 100 ++------------
 .../TPCFastSpaceChargeCorrection.h            | 125 +++++++++---------
 GPU/TPCFastTransformation/TPCFastTransform.h  |   4 +-
 .../TPCFastTransformGeo.cxx                   |   2 +-
 .../TPCFastTransformGeo.h                     |  73 ++--------
 .../macro/TPCFastTransformInit.C              |   7 +-
 8 files changed, 124 insertions(+), 253 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 6ba3d6e12dd9e..021074c49f21a 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -354,15 +354,14 @@ void TPCFastSpaceChargeCorrectionHelper::testGeometry(const TPCFastTransformGeo&
     for (int pad = 0; pad < nPads; pad++) {
       const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
       const PadCentre& c = mapper.padCentre(p);
-      double u = geo.convPadToU(row, pad);
-
+      auto [y, z] = geo.convPadDriftLengthToLocal(0, row, pad, 0.);
       const double dx = x - c.X();
-      const double dy = u - (-c.Y()); // diferent sign convention for Y coordinate in the map
+      const double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map
 
       if (fabs(dx) >= 1.e-6 || fabs(dy) >= 1.e-5) {
         LOG(warning) << "wrong calculated pad position:"
                      << " row " << row << " pad " << pad << " x calc " << x << " x in map " << c.X() << " dx " << (x - c.X())
-                     << " y calc " << u << " y in map " << -c.Y() << " dy " << dy << std::endl;
+                     << " y calc " << y << " y in map " << -c.Y() << " dy " << dy << std::endl;
       }
       if (fabs(maxDx) < fabs(dx)) {
         maxDx = dx;
@@ -499,18 +498,14 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       double yMax = rowInfo.x * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
       double zMin = rowInfo.x * trackResiduals.getZ2X(0);
       double zMax = rowInfo.x * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
-      double uMin = yMin;
-      double uMax = yMax;
-      double vMin = geo.getTPCzLength() - zMax;
-      double vMax = geo.getTPCzLength() - zMin;
-      info.gridU0 = uMin;
-      info.scaleUtoGrid = spline.getGridX1().getUmax() / (uMax - uMin);
-      info.gridV0 = vMin;
-      info.scaleVtoGrid = spline.getGridX2().getUmax() / (vMax - vMin);
-      info.gridCorrU0 = info.gridU0;
-      info.gridCorrV0 = info.gridV0;
-      info.scaleCorrUtoGrid = info.scaleUtoGrid;
-      info.scaleCorrVtoGrid = info.scaleVtoGrid;
+      double lMin = geo.getTPCzLength() - zMax;
+      double lMax = geo.getTPCzLength() - zMin;
+      info.gridMeasured.y0 = yMin;
+      info.gridMeasured.yScale = spline.getGridX1().getUmax() / (yMax - yMin);
+      info.gridMeasured.l0 = lMin;
+      info.gridMeasured.lScale = spline.getGridX2().getUmax() / (lMax - lMin);
+
+      info.gridReal = info.gridMeasured;
 
       // std::cout << " iSector " << iSector << " iRow " << iRow << " uMin: " << uMin << " uMax: " << uMax << " vMin: " << vMin << " vMax: " << vMax
       //<< " grid scale u "<< info.scaleUtoGrid << " grid scale v "<< info.scaleVtoGrid<< std::endl;
@@ -593,8 +588,8 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
       auto myThread = [&](int iThread, int nTreads) {
         struct Voxel {
-          float mY, mZ;            // not-distorted local coordinates
-          float mDy, mDz;          // bin size
+          float mY, mZ;            // non-distorted local coordinates
+          float mDy, mDz;          // voxel size
           int mSmoothingStep{100}; // is the voxel data original or smoothed at this step
         };
 
@@ -905,11 +900,10 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
 
             double realY = y + dy;
             double realZ = z + dz;
-            float realU, realV;
-            mGeo.convLocalToUV1(sector, realY, realZ, realU, realV);
+            double realL = mGeo.convZtoDriftLength(sector, realZ);
 
-            dataPointGridU.push_back(realU);
-            dataPointGridV.push_back(realV);
+            dataPointGridU.push_back(realY);
+            dataPointGridV.push_back(realL);
             dataPointF.push_back(dx);
             dataPointF.push_back(dy);
             dataPointF.push_back(dz);
@@ -920,17 +914,14 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
 
         auto& sectorRowInfo = correction.getSectorRowInfo(sector, row);
 
-        sectorRowInfo.gridCorrU0 = sectorRowInfo.gridU0;
-        sectorRowInfo.gridCorrV0 = sectorRowInfo.gridV0;
-        sectorRowInfo.scaleCorrUtoGrid = sectorRowInfo.scaleUtoGrid;
-        sectorRowInfo.scaleCorrVtoGrid = sectorRowInfo.scaleVtoGrid;
+        sectorRowInfo.gridReal = sectorRowInfo.gridMeasured;
 
         int nDataPoints = dataPointGridU.size();
 
         // convert real Y,Z to grid U,V
         for (int i = 0; i < nDataPoints; i++) {
-          dataPointGridU[i] = (dataPointGridU[i] - sectorRowInfo.gridCorrU0) * sectorRowInfo.scaleCorrUtoGrid;
-          dataPointGridV[i] = (dataPointGridV[i] - sectorRowInfo.gridCorrV0) * sectorRowInfo.scaleCorrVtoGrid;
+          dataPointGridU[i] = (dataPointGridU[i] - sectorRowInfo.gridReal.y0) * sectorRowInfo.gridReal.yScale;
+          dataPointGridV[i] = (dataPointGridV[i] - sectorRowInfo.gridReal.l0) * sectorRowInfo.gridReal.lScale;
         }
 
         splineParameters.resize(spline.getNumberOfParameters());
@@ -1035,8 +1026,10 @@ void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(
           secRowInfo.updateMaxValues(linfo.getMaxValues(), scale);
           secRowInfo.updateMaxValues(linfo.getMinValues(), scale);
 
-          double scaleU = secRowInfo.scaleUtoGrid / linfo.scaleUtoGrid;
-          double scaleV = secRowInfo.scaleVtoGrid / linfo.scaleVtoGrid;
+          double scaleU = secRowInfo.gridMeasured.yScale / linfo.gridMeasured.yScale;
+          double scaleV = secRowInfo.gridMeasured.lScale / linfo.gridMeasured.lScale;
+          double scaleRealU = secRowInfo.gridReal.yScale / linfo.gridReal.yScale;
+          double scaleRealV = secRowInfo.gridReal.lScale / linfo.gridReal.lScale;
 
           for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
             double u = gridU.getKnot(iu).u;
@@ -1060,11 +1053,11 @@ void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(
                 }
               }
 
-              auto [y, z] = mainCorrection.convGridToCorrectedLocal(sector, row, u, v);
+              auto [y, z] = mainCorrection.convGridToRealLocal(sector, row, u, v);
               // return values: u, v, scaling factor
-              auto [lu, lv, ls] = corr.convCorrectedLocalToGrid(sector, row, y, z);
+              auto [lu, lv, ls] = corr.convRealLocalToGrid(sector, row, y, z);
               ls *= scale;
-              double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * ls * scaleU * scaleV};
+              double parscale[4] = {ls, ls * scaleRealU, ls * scaleRealV, ls * ls * scaleRealU * scaleRealV};
 
               { // inverse X correction
                 corr.getSplineInvX(sector, row).interpolateParametersAtU(corr.getSplineDataInvX(sector, row), lu, lv, P);
diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index a6a2c9722caeb..687d4ce707f11 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -202,15 +202,16 @@ void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) cons
     for (int pad = 0; pad < nPads; pad++) {
       const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
       const PadCentre& c = mapper.padCentre(p);
-      double u = geo.convPadToU(row, pad);
+
+      auto [y, z] = geo.convPadDriftLengthToLocal(0, row, pad, 0.);
 
       const double dx = x - c.X();
-      const double dy = u - (-c.Y()); // diferent sign convention for Y coordinate in the map
+      const double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map
 
       if (fabs(dx) >= 1.e-6 || fabs(dy) >= 1.e-5) {
         LOG(warning) << "wrong calculated pad position:"
                      << " row " << row << " pad " << pad << " x calc " << x << " x in map " << c.X() << " dx " << (x - c.X())
-                     << " y calc " << u << " y in map " << -c.Y() << " dy " << dy << std::endl;
+                     << " y calc " << y << " y in map " << -c.Y() << " dy " << dy << std::endl;
       }
       if (fabs(maxDx) < fabs(dx)) {
         maxDx = dx;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 2921a74b025ce..1e6d84b7f8dd9 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -141,48 +141,18 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
 {
   /// Sets the actual location of the external flat buffer after it has been moved (e.g. to another maschine)
 
-  struct RowInfoVersion3 {
-    int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
-    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC sector
-  };
-
-  struct RowActiveAreaVersion3 {
-    float maxDriftLengthCheb[5]{0.f};
-    float vMax{0.f};
-    float cuMin{0.f};
-    float cuMax{0.f};
-    float cvMax{0.f};
-  };
-
-  struct SectorRowInfoVersion3 {
-    float gridV0{0.f};           ///< V coordinate of the V-grid start
-    float gridCorrU0{0.f};       ///< U coordinate of the U-grid start for corrected U
-    float gridCorrV0{0.f};       ///< V coordinate of the V-grid start for corrected V
-    float scaleCorrUtoGrid{0.f}; ///< scale corrected U to U-grid coordinate
-    float scaleCorrVtoGrid{0.f}; ///< scale corrected V to V-grid coordinate
-    RowActiveAreaVersion3 activeArea;
-  };
-
-  FlatObject::setActualBufferAddress(actualFlatBufferPtr);
-
-  size_t rowsOffset = 0;
-  size_t rowsSize = 0;
-  if (mClassVersion == 3) {
-    rowsSize = sizeof(RowInfoVersion3) * mGeo.getNumberOfRows();
+  if (mClassVersion != 4) {
+    LOG(error) << "TPCFastSpaceChargeCorrection::setActualBufferAddress() called with class version " << mClassVersion << ". This is not supported.";
+    return;
   }
 
-  size_t sectorRowsOffset = rowsOffset + rowsSize;
-  size_t sectorRowsSize = 0;
-  if (mClassVersion == 3) { // copy old-format sectorrow data from the buffer to the arrays
-    sectorRowsSize = sizeof(SectorRowInfoVersion3) * mGeo.getNumberOfRows() * mGeo.getNumberOfSectors();
-  }
+  FlatObject::setActualBufferAddress(actualFlatBufferPtr);
 
-  size_t scOffset = alignSize(sectorRowsOffset + sectorRowsSize, SplineType::getClassAlignmentBytes());
   size_t scSize = sizeof(SplineType) * mNumberOfScenarios;
 
-  mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr + scOffset);
+  mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr);
 
-  size_t scBufferOffset = alignSize(scOffset + scSize, SplineType::getBufferAlignmentBytes());
+  size_t scBufferOffset = alignSize(scSize, SplineType::getBufferAlignmentBytes());
   size_t scBufferSize = 0;
 
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -196,45 +166,6 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + sectorDataOffset);
     bufferSize = sectorDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
   }
-
-  if (mClassVersion == 3) { // copy old-format sectorrow data from the buffer to the arrays
-
-    auto* rowInfosOld = reinterpret_cast<RowInfoVersion3*>(mFlatBufferPtr + rowsOffset);
-    for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-      RowInfoVersion3& infoOld = rowInfosOld[i];
-      RowInfo& info = mRowInfos[i];
-      info.splineScenarioID = infoOld.splineScenarioID;
-      for (int32_t is = 0; is < 3; is++) {
-        info.dataOffsetBytes[is] = infoOld.dataOffsetBytes[is];
-      }
-    }
-
-    for (int32_t is = 0; is < mNumberOfScenarios; is++) {
-      auto& spline = mScenarioPtr[is];
-      spline.setXrange(0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax());
-    }
-
-    auto* sectorRowInfosOld = reinterpret_cast<SectorRowInfoVersion3*>(mFlatBufferPtr + sectorRowsOffset);
-
-    for (int32_t sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
-      for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
-        SectorRowInfoVersion3& infoOld = sectorRowInfosOld[mGeo.getNumberOfRows() * sector + row];
-        SectorRowInfo& info = getSectorRowInfo(sector, row);
-        const auto& spline = getSpline(sector, row);
-        info.gridU0 = mGeo.getRowInfo(row).u0;
-        info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
-
-        info.gridV0 = infoOld.gridV0;
-        info.scaleVtoGrid = spline.getGridX2().getUmax() / (mGeo.getTPCzLength() + 3. - info.gridV0);
-
-        info.gridCorrU0 = infoOld.gridCorrU0;
-        info.scaleCorrUtoGrid = infoOld.scaleCorrUtoGrid;
-
-        info.gridCorrV0 = infoOld.gridCorrV0;
-        info.scaleCorrVtoGrid = infoOld.scaleCorrVtoGrid;
-      }
-    }
-  }
 }
 
 void TPCFastSpaceChargeCorrection::setFutureBufferAddress(char* futureFlatBufferPtr)
@@ -454,17 +385,12 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
 
       SectorRowInfo& info = getSectorRowInfo(sector, row);
 
-      info.gridU0 = mGeo.getRowInfo(row).u0;
-      info.scaleUtoGrid = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getUwidth();
-
-      info.gridV0 = 0.f;
-      info.scaleVtoGrid = spline.getGridX2().getUmax() / vLength;
-
-      info.gridCorrU0 = info.gridU0;
-      info.gridCorrV0 = info.gridV0;
-      info.scaleCorrUtoGrid = info.scaleUtoGrid;
-      info.scaleCorrVtoGrid = info.scaleVtoGrid;
+      info.gridMeasured.y0 = mGeo.getRowInfo(row).getYmin();
+      info.gridMeasured.yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getYwidth();
+      info.gridMeasured.l0 = 0.f;
+      info.gridMeasured.lScale = spline.getGridX2().getUmax() / vLength;
 
+      info.gridReal = info.gridMeasured;
     } // row
   } // sector
 }
@@ -539,9 +465,9 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
 
       // grid borders
       if (sector < mGeo.getNumberOfSectorsA()) {
-        z1 = vLength - getSectorRowInfo(sector, row).gridV0;
+        z1 = vLength - getSectorRowInfo(sector, row).gridMeasured.l0;
       } else {
-        z0 = getSectorRowInfo(sector, row).gridV0 - vLength;
+        z0 = getSectorRowInfo(sector, row).gridMeasured.l0 - vLength;
       }
 
       double stepY = (y1 - y0) / 100.;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index da37409221d6c..4564d584c8dce 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -48,17 +48,31 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     ClassDefNV(RowInfo, 1);
   };
 
+  struct GridInfo {
+    float y0{0.f};     ///< Y coordinate of the U-grid start
+    float yScale{0.f}; //< scale Y to U-grid coordinate
+    float l0{0.f};     ///< Drift Length coordinate of the V-grid start
+    float lScale{0.f}; //< scale Drift Length to V-grid coordinate
+
+    float getScale(float l) const
+    {
+      if (l < 0.f) { // outside of the TPC
+        return 0.f;
+      }
+      if (l < l0) { // between the grid and the readout
+        return l / l0;
+      }
+      return 1.f; // inside the grid
+    }
+    ClassDefNV(GridInfo, 1);
+  };
+
   struct SectorRowInfo {
-    float gridU0{0.f};                     //< U coordinate of the U-grid start
-    float scaleUtoGrid{0.f};               //< scale U to U-grid coordinate
-    float gridV0{0.f};                     ///< V coordinate of the V-grid start
-    float scaleVtoGrid{0.f};               //< scale V to V-grid coordinate
-    float gridCorrU0{0.f};                 ///< U coordinate of the U-grid start for corrected U
-    float scaleCorrUtoGrid{0.f};           ///< scale corrected U to U-grid coordinate
-    float gridCorrV0{0.f};                 ///< V coordinate of the V-grid start for corrected V
-    float scaleCorrVtoGrid{0.f};           ///< scale corrected V to V-grid coordinate
-    float minCorr[3]{-10.f, -10.f, -10.f}; ///< min correction for dX, dU, dV
-    float maxCorr[3]{10.f, 10.f, 10.f};    ///< max correction for dX, dU, dV
+    GridInfo gridMeasured; ///< grid info for measured coordinates
+    GridInfo gridReal;     ///< grid info for real coordinates
+
+    float minCorr[3]{-10.f, -10.f, -10.f}; ///< min correction for dX, dY, dZ
+    float maxCorr[3]{10.f, 10.f, 10.f};    ///< max correction for dX, dY, dZ
 
     void resetMaxValues()
     {
@@ -220,10 +234,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   GPUdi() std::tuple<float, float, float> getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const;
 
-  /// inverse correction: Corrected U and V -> coorrected X
+  /// inverse correction: Real Y and Z -> Real X
   GPUd() float getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
 
-  /// inverse correction: Corrected U and V -> uncorrected U and V
+  /// inverse correction: Real Y and Z -> measred Y and Z
   GPUd() std::tuple<float, float> getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
 
   /// _______________  Utilities  _______________________________________________
@@ -236,12 +250,13 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// return values: y, z, scaling factor
   GPUd() std::tuple<float, float> convGridToLocal(int32_t sector, int32_t row, float u, float v) const;
 
-  /// convert corrected u,v to internal grid coordinates
-  GPUd() std::tuple<float, float, float> convCorrectedLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
-
-  /// convert internal grid coordinates to corrected u,v
+  /// convert real Y, Z to the internal grid coordinates
   /// return values: u, v, scaling factor
-  GPUd() std::tuple<float, float> convGridToCorrectedLocal(int32_t sector, int32_t row, float u, float v) const;
+  GPUd() std::tuple<float, float, float> convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
+
+  /// convert internal grid coordinates to the real Y, Z
+  /// return values: y, z
+  GPUd() std::tuple<float, float> convGridToRealLocal(int32_t sector, int32_t row, float u, float v) const;
 
   GPUd() bool isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
 
@@ -421,18 +436,10 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convLocalT
   const auto& info = getSectorRowInfo(sector, row);
   const SplineType& spline = getSpline(sector, row);
 
-  float u, v;
-  mGeo.convLocalToUV1(sector, y, z, u, v);
-
-  float scale = 1.f;
-  if (v < 0.f) {
-    scale = 0.f;
-  } else if (v < info.gridV0) {
-    scale = v / info.gridV0;
-  }
-
-  float gridU = (u - info.gridU0) * info.scaleUtoGrid;
-  float gridV = (v - info.gridV0) * info.scaleVtoGrid;
+  float l = mGeo.convZtoDriftLength(sector, z);
+  float scale = info.gridMeasured.getScale(l);
+  float gridU = (y - info.gridMeasured.y0) * info.gridMeasured.yScale;
+  float gridV = (l - info.gridMeasured.l0) * info.gridMeasured.lScale;
 
   // shrink to the grid area
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
@@ -446,19 +453,19 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int
   /// ccheck if local y, z are inside the grid
 
   const auto& info = getSectorRowInfo(sector, row);
-  const SplineType& spline = getSpline(sector, row);
+  const auto& spline = getSpline(sector, row);
+  float l = mGeo.convZtoDriftLength(sector, z);
 
-  float u, v;
-  mGeo.convLocalToUV1(sector, y, z, u, v);
-
-  float gridU = (u - info.gridU0) * info.scaleUtoGrid;
-  float gridV = (v - info.gridV0) * info.scaleVtoGrid;
+  float gridU = (y - info.gridMeasured.y0) * info.gridMeasured.yScale;
+  float gridV = (l - info.gridMeasured.l0) * info.gridMeasured.lScale;
 
   // shrink to the grid area
-  if (gridU < 0.f || gridU > (float)spline.getGridX1().getUmax())
+  if (gridU < 0.f || gridU > (float)spline.getGridX1().getUmax()) {
     return false;
-  if (gridV < 0.f || gridV > (float)spline.getGridX2().getUmax())
+  }
+  if (gridV < 0.f || gridV > (float)spline.getGridX2().getUmax()) {
     return false;
+  }
   return true;
 }
 
@@ -466,31 +473,22 @@ GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToLocal(i
 {
   /// convert internal grid coordinates u,v to local y, z
   const SectorRowInfo& info = getSectorRowInfo(sector, row);
-  float u = info.gridU0 + gridU / info.scaleUtoGrid;
-  float v = info.gridV0 + gridV / info.scaleVtoGrid;
-  float y, z;
-  mGeo.convUVtoLocal1(sector, u, v, y, z);
+  float y = info.gridMeasured.y0 + gridU / info.gridMeasured.yScale;
+  float l = info.gridMeasured.l0 + gridV / info.gridMeasured.lScale;
+  float z = mGeo.convDriftLengthToZ(sector, l);
   return {y, z};
 }
 
-GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convCorrectedLocalToGrid(int32_t sector, int32_t row, float y, float z) const
+GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const
 {
-  /// convert corrected y, z to the internal grid coordinates
+  /// convert real y, z to the internal grid coordinates + scale
   const auto& info = getSectorRowInfo(sector, row);
-  const Spline2D<float, 1>& spline = reinterpret_cast<const Spline2D<float, 1>&>(getSpline(sector, row));
-
-  float u, v;
-  mGeo.convLocalToUV1(sector, y, z, u, v);
-
-  float scale = 1.f;
-  if (v < 0.f) {
-    scale = 0.f;
-  } else if (v < info.gridCorrV0) {
-    scale = v / info.gridCorrV0;
-  }
+  const auto& spline = getSpline(sector, row);
 
-  float gridU = (u - info.gridCorrU0) * info.scaleCorrUtoGrid;
-  float gridV = (v - info.gridCorrV0) * info.scaleCorrVtoGrid;
+  float l = mGeo.convZtoDriftLength(sector, z);
+  float scale = info.gridReal.getScale(l);
+  float gridU = (y - info.gridReal.y0) * info.gridReal.yScale;
+  float gridV = (l - info.gridReal.l0) * info.gridReal.lScale;
 
   // shrink to the grid area
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
@@ -499,14 +497,13 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convCorrec
   return {gridU, gridV, scale};
 }
 
-GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToCorrectedLocal(int32_t sector, int32_t row, float gridU, float gridV) const
+GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV) const
 {
-  /// convert internal grid coordinates u,v to corrected y, z
+  /// convert internal grid coordinates u,v to the real y, z
   const SectorRowInfo& info = getSectorRowInfo(sector, row);
-  float u = info.gridCorrU0 + gridU / info.scaleCorrUtoGrid;
-  float v = info.gridCorrV0 + gridV / info.scaleCorrVtoGrid;
-  float y, z;
-  mGeo.convUVtoLocal1(sector, u, v, y, z);
+  float y = info.gridReal.y0 + gridU / info.gridReal.yScale;
+  float l = info.gridReal.l0 + gridV / info.gridReal.lScale;
+  float z = mGeo.convDriftLengthToZ(sector, l);
   return {y, z};
 }
 
@@ -530,7 +527,7 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrect
 GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
   const auto& info = getSectorRowInfo(sector, row);
-  auto [gridU, gridV, scale] = convCorrectedLocalToGrid(sector, row, realY, realZ);
+  auto [gridU, gridV, scale] = convRealLocalToGrid(sector, row, realY, realZ);
   float dx = 0;
   getSplineInvX(sector, row).interpolateAtU(getSplineDataInvX(sector, row), gridU, gridV, &dx);
   dx = scale * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
@@ -539,7 +536,7 @@ GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t secto
 
 GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
-  auto [gridU, gridV, scale] = convCorrectedLocalToGrid(sector, row, realY, realZ);
+  auto [gridU, gridV, scale] = convRealLocalToGrid(sector, row, realY, realZ);
   const auto& info = getSectorRowInfo(sector, row);
   float dyz[2];
   getSplineInvYZ(sector, row).interpolateAtU(getSplineDataInvYZ(sector, row), gridU, gridV, dyz);
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 03d9eaf43ce9b..8807c0e3206f4 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -551,7 +551,7 @@ GPUdi() void TPCFastTransform::Transform(int32_t sector, int32_t row, float pad,
 GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const
 {
   float l = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
-  z = getGeometry().convDriftLengthToLocal(sector, l);
+  z = getGeometry().convDriftLengthToZ(sector, l);
 }
 
 GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
@@ -590,7 +590,7 @@ GPUdi() void TPCFastTransform::TransformIdealZ(int32_t sector, float time, float
   ///
 
   float l = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  z = getGeometry().convDriftLengthToLocal(sector, l);
+  z = getGeometry().convDriftLengthToZ(sector, l);
 }
 
 GPUdi() void TPCFastTransform::TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
index e7e026f464818..5b2dcc8da82d5 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
@@ -92,7 +92,7 @@ void TPCFastTransformGeo::setTPCrow(int32_t iRow, float x, int32_t nPads, float
   row.x = x;
   row.maxPad = nPads - 1;
   row.padWidth = padWidth;
-  row.u0 = -uWidth / 2.;
+  row.yMin = -uWidth / 2.;
 }
 
 void TPCFastTransformGeo::finishConstruction()
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 4072435e948a5..bbb94dcb8bedd 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -46,25 +46,19 @@ class TPCFastTransformGeo
     float x{0.f};        ///< nominal X coordinate of the padrow [cm]
     int32_t maxPad{0};   ///< maximal pad number = n pads - 1
     float padWidth{0.f}; ///< width of pads [cm]
-    float u0{0.f};       ///< min. u coordinate
-
-    /// get U min
-    GPUd() float getUmin() const { return u0; }
-
-    /// get U max
-    GPUd() float getUmax() const { return -u0; }
+    float yMin{0.f};     ///< min. y coordinate
 
     /// get Y min
-    GPUd() float getYmin() const { return u0; }
+    GPUd() float getYmin() const { return yMin; }
 
     /// get Y max
-    GPUd() float getYmax() const { return -u0; }
+    GPUd() float getYmax() const { return -yMin; }
 
     /// get Y range
     GPUd() std::tuple<float, float> getYrange() const { return {getYmin(), getYmax()}; }
 
-    /// get width in U
-    GPUd() float getUwidth() const { return -2.f * u0; }
+    /// get width in Y
+    GPUd() float getYwidth() const { return -2.f * yMin; }
 
     ClassDefNV(RowInfo, 1);
   };
@@ -145,23 +139,14 @@ class TPCFastTransformGeo
   GPUd() std::tuple<float, float> convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const;
 
   /// convert DriftLength -> Local c.s.
-  GPUd() float convDriftLengthToLocal(int32_t sector, float driftLength) const;
+  GPUd() float convDriftLengthToZ(int32_t sector, float driftLength) const;
+
+  /// convert Z to DriftLength
+  GPUd() float convZtoDriftLength(int32_t sector, float z) const;
 
   /// convert Local c.s. -> Pad, DriftLength
   GPUd() std::tuple<float, float> convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const;
 
-  /// convert UV -> Local c.s.
-  GPUd() void convUVtoLocal1(int32_t sector, float u, float v, float& y, float& z) const;
-
-  /// convert Local-> UV c.s.
-  GPUd() void convLocalToUV1(int32_t sector, float y, float z, float& u, float& v) const;
-
-  /// convert Pad coordinate -> U
-  GPUd() float convPadToU(int32_t row, float pad) const;
-
-  /// convert U -> Pad coordinate
-  GPUd() float convUtoPad(int32_t row, float u) const;
-
   /// Print method
   void print() const;
 
@@ -257,22 +242,16 @@ GPUdi() std::tuple<float, float> TPCFastTransformGeo::convPadDriftLengthToLocal(
   return {y, z};
 }
 
-GPUdi() float TPCFastTransformGeo::convDriftLengthToLocal(int32_t sector, float driftLength) const
+GPUdi() float TPCFastTransformGeo::convDriftLengthToZ(int32_t sector, float driftLength) const
 {
   /// convert DriftLength -> Local c.s.
   return (sector < NumberOfSectorsA) ? (mTPCzLength - driftLength) : (driftLength - mTPCzLength);
 }
 
-GPUdi() void TPCFastTransformGeo::convUVtoLocal1(int32_t sector, float u, float v, float& ly, float& lz) const
+GPUdi() float TPCFastTransformGeo::convZtoDriftLength(int32_t sector, float z) const
 {
-  /// convert UV -> Local c.s.
-  if (sector < NumberOfSectorsA) { // TPC side A
-    ly = u;
-    lz = mTPCzLength - v;
-  } else {                // TPC side C
-    ly = -u;              // pads are mirrorred on C-side
-    lz = v - mTPCzLength; // drift direction is mirrored on C-side
-  }
+  /// convert Z to DriftLength
+  return (sector < NumberOfSectorsA) ? (mTPCzLength - z) : (z + mTPCzLength);
 }
 
 GPUdi() std::tuple<float, float> TPCFastTransformGeo::getZrange(int32_t sector) const
@@ -301,32 +280,6 @@ GPUdi() std::tuple<float, float> TPCFastTransformGeo::convLocalToPadDriftLength(
   return {pad, l};
 }
 
-GPUdi() void TPCFastTransformGeo::convLocalToUV1(int32_t sector, float ly, float lz, float& u, float& v) const
-{
-  /// convert Local-> UV c.s.
-  if (sector < NumberOfSectorsA) { // TPC side A
-    u = ly;
-    v = mTPCzLength - lz;
-  } else {                // TPC side C
-    u = -ly;              // pads are mirrorred on C-side
-    v = lz + mTPCzLength; // drift direction is mirrored on C-side
-  }
-}
-
-GPUdi() float TPCFastTransformGeo::convPadToU(int32_t row, float pad) const
-{
-  /// convert Pad coordinate -> U
-  const RowInfo& rowInfo = getRowInfo(row);
-  return (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-}
-
-GPUdi() float TPCFastTransformGeo::convUtoPad(int32_t row, float u) const
-{
-  /// convert U -> Pad coordinate
-  const RowInfo& rowInfo = getRowInfo(row);
-  return u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
-}
-
 } // namespace gpu
 } // namespace o2
 
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index bee1f9107ddd2..f0c03d9f5f081 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -185,9 +185,10 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
         for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
           auto& info = corr.getSectorRowInfo(iSector, iRow);
           std::cout << "sector " << iSector << " row " << iRow
-                    << " gridV0 " << info.gridV0 << " gridCorrU0 " << info.gridCorrU0 << " gridCorrV0 " << info.gridCorrV0
-                    << " scaleCorrUtoGrid " << info.scaleCorrUtoGrid << " scaleCorrVtoGrid " << info.scaleCorrVtoGrid
-                    << " gridU0 " << info.gridU0 << " scaleUtoGrid " << info.scaleUtoGrid << " scaleVtoGrid " << info.scaleVtoGrid
+                    << " gridY0 " << info.gridMeasured.y0 << " gridL0 " << info.gridMeasured.l0
+                    << " scaleYtoGrid " << info.gridMeasured.yScale << " scaleLtoGrid " << info.gridMeasured.lScale
+                    << " gridRealY0 " << info.gridReal.y0 << " gridRealL0 " << info.gridReal.l0
+                    << " scaleRealYtoGrid " << info.gridReal.yScale << " scaleRealLtoGrid " << info.gridReal.lScale
                     << std::endl;
         }
       }

From 0e98f2942391c7977494fa58f384fa3708489ee9 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <sergey.gorbunov@fias.uni-frankfurt.de>
Date: Mon, 14 Apr 2025 19:01:36 +0000
Subject: [PATCH 1573/1764] TPC Splines: completely switch to local TPC
 coordinates in the grid

---
 .../TPCFastSpaceChargeCorrectionHelper.h      |  10 +-
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 270 +++++++++---------
 .../TPCFastSpaceChargeCorrection.cxx          | 119 ++++----
 .../TPCFastSpaceChargeCorrection.h            | 137 ++++-----
 .../TPCFastTransform.cxx                      |   4 -
 GPU/TPCFastTransformation/TPCFastTransform.h  |   4 +-
 .../TPCFastTransformGeo.h                     |  43 ++-
 .../TPCFastTransformationLinkDef_O2.h         |   1 +
 .../macro/TPCFastTransformInit.C              |  12 +-
 9 files changed, 328 insertions(+), 272 deletions(-)

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
index 747ed74c9bcad..e8afd9be97d5f 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
@@ -85,8 +85,16 @@ class TPCFastSpaceChargeCorrectionHelper
     const int nKnotsY = 10, const int nKnotsZ = 20);
 
   /// Create SpaceCharge correction out of the voxel tree
+  /// \param trackResiduals TrackResiduals object
+  /// \param voxResTree TTree with voxel residuals
+  /// \param voxResTreeInverse TTree with inverse voxel residuals
+  /// \param useSmoothed if true, use smoothed residuals
+  /// \param invertSigns if true, invert the signs of the residuals
+  /// \return pointer to the created TPCFastSpaceChargeCorrection object
+  /// \note voxel trees wont be changed. They are read as non-const because of the ROOT::TTreeProcessorMT interface
   std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> createFromTrackResiduals(
-    const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, TTree* voxResTreeInverse, bool useSmoothed, bool invertSigns);
+    const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, TTree* voxResTreeInverse, //
+    bool useSmoothed, bool invertSigns);
 
   /// _______________  Utilities   ________________________
 
diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 021074c49f21a..d2f6cf57b0de7 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -258,12 +258,14 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
     correction.startConstruction(mGeo, nCorrectionScenarios);
 
     // assign spline type for TPC rows
-    for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
-      int scenario = row / 10;
-      if (scenario >= nCorrectionScenarios) {
-        scenario = nCorrectionScenarios - 1;
+    for (int sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
+      for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
+        int scenario = row / 10;
+        if (scenario >= nCorrectionScenarios) {
+          scenario = nCorrectionScenarios - 1;
+        }
+        correction.setRowScenarioID(sector, row, scenario);
       }
-      correction.setRowScenarioID(row, scenario);
     }
 
     for (int scenario = 0; scenario < nCorrectionScenarios; scenario++) {
@@ -397,93 +399,100 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   int nY2Xbins = trackResiduals.getNY2XBins();
   int nZ2Xbins = trackResiduals.getNZ2XBins();
 
-  std::vector<double> uvBinsDouble[2];
+  std::vector<double> knotsDouble[3];
+
+  knotsDouble[0].reserve(nY2Xbins);
+  knotsDouble[1].reserve(nZ2Xbins);
+  knotsDouble[2].reserve(nZ2Xbins);
 
-  uvBinsDouble[0].reserve(nY2Xbins);
-  uvBinsDouble[1].reserve(nZ2Xbins);
+  // to get enouth measurements, make a spline knot at every second bin. Boundary bins are always included.
 
   for (int i = 0, j = nY2Xbins - 1; i <= j; i += 2, j -= 2) {
-    uvBinsDouble[0].push_back(trackResiduals.getY2X(0, i));
+    knotsDouble[0].push_back(trackResiduals.getY2X(0, i));
     if (j >= i + 1) {
-      uvBinsDouble[0].push_back(trackResiduals.getY2X(0, j));
+      knotsDouble[0].push_back(trackResiduals.getY2X(0, j));
     }
   }
 
   for (int i = 0, j = nZ2Xbins - 1; i <= j; i += 2, j -= 2) {
-    uvBinsDouble[1].push_back(-trackResiduals.getZ2X(i));
+    knotsDouble[1].push_back(trackResiduals.getZ2X(i));
+    knotsDouble[2].push_back(-trackResiduals.getZ2X(i));
     if (j >= i + 1) {
-      uvBinsDouble[1].push_back(-trackResiduals.getZ2X(j));
+      knotsDouble[1].push_back(trackResiduals.getZ2X(j));
+      knotsDouble[2].push_back(-trackResiduals.getZ2X(j));
     }
   }
 
-  std::vector<int> uvBinsInt[2];
-
-  for (int iuv = 0; iuv < 2; iuv++) {
-    auto& bins = uvBinsDouble[iuv];
-    std::sort(bins.begin(), bins.end());
+  std::vector<int> knotsInt[3];
 
-    auto& binsInt = uvBinsInt[iuv];
-    binsInt.reserve(bins.size());
+  for (int dim = 0; dim < 3; dim++) {
+    auto& knotsD = knotsDouble[dim];
+    std::sort(knotsD.begin(), knotsD.end());
 
-    double dy = bins[1] - bins[0];
-    for (int i = 2; i < bins.size(); i++) {
-      double dd = bins[i] - bins[i - 1];
-      if (dd < dy) {
-        dy = dd;
+    double pitch = knotsD[1] - knotsD[0]; // min distance between the knots
+    for (int i = 2; i < knotsD.size(); i++) {
+      double d = knotsD[i] - knotsD[i - 1];
+      if (d < pitch) {
+        pitch = d;
       }
     }
-    // spline knots must be positioned on the grid with integer internal coordinate
-    // take the knot position accuracy of 0.1*dy
-    dy = dy / 10.;
-    double y0 = bins[0];
-    double y1 = bins[bins.size() - 1];
-    for (auto& y : bins) {
-      y -= y0;
-      int iy = int(y / dy + 0.5);
-      binsInt.push_back(iy);
-      double yold = y / (y1 - y0) * 2 - 1.;
-      y = iy * dy;
-      y = y / (y1 - y0) * 2 - 1.;
-      if (iuv == 0) {
-        LOG(info) << "TPC SC splines: convert y bin: " << yold << " -> " << y << " -> " << iy;
-      } else {
-        LOG(info) << "TPC SC splines: convert z bin: " << yold << " -> " << y << " -> " << iy;
-      }
+    // spline knots must be positioned on the grid with an integer internal coordinate
+    // we set the knot positioning accuracy to 0.1*pitch
+    pitch = 0.1 * pitch;
+    auto& knotsI = knotsInt[dim];
+    knotsI.reserve(knotsD.size());
+    double u0 = knotsD[0];
+    double u1 = knotsD[knotsD.size() - 1];
+    for (auto& u : knotsD) {
+      u -= u0;
+      int iu = int(u / pitch + 0.5);
+      knotsI.push_back(iu);
+      // debug printout: corrected vs original knot positions, scaled to [-1,1] interval
+      double uorig = u / (u1 - u0) * 2 - 1.;
+      u = (iu * pitch) / (u1 - u0) * 2 - 1.;
+      LOG(info) << "TPC SC splines: convert " << (dim == 0 ? "y" : (dim == 1 ? "z" : "-z")) << " bin to the knot: " << uorig << " -> " << u << " -> " << iu;
     }
 
-    if (binsInt.size() < 2) {
-      binsInt.clear();
-      binsInt.push_back(0);
-      binsInt.push_back(1);
+    if (knotsI.size() < 2) { // minimum 2 knots
+      knotsI.clear();
+      knotsI.push_back(0);
+      knotsI.push_back(1);
     }
   }
 
-  auto& yBinsInt = uvBinsInt[0];
-  auto& zBinsInt = uvBinsInt[1];
+  auto& yKnotsInt = knotsInt[0];
+  auto& zKnotsIntA = knotsInt[1];
+  auto& zKnotsIntC = knotsInt[2];
 
-  int nKnotsY = yBinsInt.size();
-  int nKnotsZ = zBinsInt.size();
+  int nKnotsY = yKnotsInt.size();
+  int nKnotsZA = zKnotsIntA.size();
+  int nKnotsZC = zKnotsIntC.size();
 
   // std::cout << "n knots Y: " << nKnotsY << std::endl;
-  // std::cout << "n knots Z: " << nKnotsZ << std::endl;
+  // std::cout << "n knots Z: " << nKnotsZA << ",  " << nKnotsZC << std::endl;
 
   const int nRows = geo.getNumberOfRows();
   const int nSectors = geo.getNumberOfSectors();
 
   { // create the correction object
 
-    const int nCorrectionScenarios = 1;
+    const int nCorrectionScenarios = 2; // different grids for TPC A and TPC C sides
 
     correction.startConstruction(geo, nCorrectionScenarios);
 
     // init rows
-    for (int row = 0; row < geo.getNumberOfRows(); row++) {
-      correction.setRowScenarioID(row, 0);
+    for (int iSector = 0; iSector < nSectors; iSector++) {
+      int id = iSector < geo.getNumberOfSectorsA() ? 0 : 1;
+      for (int row = 0; row < geo.getNumberOfRows(); row++) {
+        correction.setRowScenarioID(iSector, row, id);
+      }
     }
     { // init spline scenario
       TPCFastSpaceChargeCorrection::SplineType spline;
-      spline.recreate(nKnotsY, &yBinsInt[0], nKnotsZ, &zBinsInt[0]);
+      spline.recreate(nKnotsY, &yKnotsInt[0], nKnotsZA, &zKnotsIntA[0]);
       correction.setSplineScenario(0, spline);
+      spline.recreate(nKnotsY, &yKnotsInt[0], nKnotsZC, &zKnotsIntC[0]);
+      correction.setSplineScenario(1, spline);
     }
     correction.finishConstruction();
   } // .. create the correction object
@@ -491,19 +500,23 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   // set the grid borders
   for (int iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
     for (int iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
-      const auto& rowInfo = geo.getRowInfo(iRow);
       auto& info = correction.getSectorRowInfo(iSector, iRow);
       const auto& spline = correction.getSpline(iSector, iRow);
-      double yMin = rowInfo.x * trackResiduals.getY2X(iRow, 0);
-      double yMax = rowInfo.x * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
-      double zMin = rowInfo.x * trackResiduals.getZ2X(0);
-      double zMax = rowInfo.x * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
-      double lMin = geo.getTPCzLength() - zMax;
-      double lMax = geo.getTPCzLength() - zMin;
-      info.gridMeasured.y0 = yMin;
-      info.gridMeasured.yScale = spline.getGridX1().getUmax() / (yMax - yMin);
-      info.gridMeasured.l0 = lMin;
-      info.gridMeasured.lScale = spline.getGridX2().getUmax() / (lMax - lMin);
+      double rowX = geo.getRowInfo(iRow).x;
+      double yMin = rowX * trackResiduals.getY2X(iRow, 0);
+      double yMax = rowX * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
+      double zMin = rowX * trackResiduals.getZ2X(0);
+      double zMax = rowX * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
+      double zOut = zMax;
+      if (iSector >= geo.getNumberOfSectorsA()) {
+        // TPC C side
+        zOut = -zOut;
+        zMax = -zMin;
+        zMin = zOut;
+      }
+      info.gridMeasured.set(yMin, spline.getGridX1().getUmax() / (yMax - yMin), // y
+                            zMin, spline.getGridX2().getUmax() / (zMax - zMin), // z
+                            zOut, geo.getZreadout(iSector));                    // correction scaling region
 
       info.gridReal = info.gridMeasured;
 
@@ -514,16 +527,16 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
   LOG(info) << "fast space charge correction helper: preparation took " << watch1.RealTime() << "s";
 
-  for (int processingInverseCorrection = 0; processingInverseCorrection < 2; processingInverseCorrection++) {
+  for (int processingInverseCorrection = 0; processingInverseCorrection <= 1; processingInverseCorrection++) {
 
     TTree* currentTree = (processingInverseCorrection) ? voxResTreeInverse : voxResTree;
 
     if (!currentTree) {
       continue;
     }
-
-    LOG(info) << "fast space charge correction helper: " << ((processingInverseCorrection) ? "inverse" : "direct")
-              << " : fill data points from track residuals.. ";
+    const char* directionName = (processingInverseCorrection) ? "inverse" : "direct";
+    LOG(info) << "\n fast space charge correction helper: Process " << directionName
+              << " correction: fill data points from track residuals.. ";
 
     TStopwatch watch3;
     o2::gpu::TPCFastSpaceChargeCorrectionMap& map = helper->getCorrectionMap();
@@ -548,34 +561,42 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
     { // read data from the tree to vSectorData
 
       ROOT::TTreeProcessorMT processor(*currentTree, mNthreads);
-
+      std::string errMsg = std::string("Error reading ") + directionName + " track residuals: ";
       auto myThread = [&](TTreeReader& readerSubRange) {
         TTreeReaderValue<o2::tpc::TrackResiduals::VoxRes> v(readerSubRange, "voxRes");
         while (readerSubRange.Next()) {
           int iSector = (int)v->bsec;
           if (iSector < 0 || iSector >= nSectors) {
-            LOG(fatal) << "Error reading voxels: voxel Sector number " << iSector << " is out of range";
+            LOG(fatal) << errMsg << "Sector number " << iSector << " is out of range";
             continue;
           }
           int iRow = (int)v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
           if (iRow < 0 || iRow >= nRows) {
-            LOG(fatal) << "Row number " << iRow << " is out of range";
+            LOG(fatal) << errMsg << "Row number " << iRow << " is out of range";
           }
+          double rowX = trackResiduals.getX(iRow);         // X of the pad row
           int iy = v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
           int iz = v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
           auto& data = vSectorData[iSector * nRows + iRow][iy * nZ2Xbins + iz];
           data.mNentries = (int)v->stat[o2::tpc::TrackResiduals::VoxV];
           data.mX = v->stat[o2::tpc::TrackResiduals::VoxX];
-          data.mY = v->stat[o2::tpc::TrackResiduals::VoxF];
-          data.mZ = v->stat[o2::tpc::TrackResiduals::VoxZ];
+          data.mY = v->stat[o2::tpc::TrackResiduals::VoxF] * rowX;
+          data.mZ = v->stat[o2::tpc::TrackResiduals::VoxZ] * rowX;
           data.mCx = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
           data.mCy = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
           data.mCz = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
-          if (0 && data.mNentries < 1) {
-            data.mCx = 0.;
-            data.mCy = 0.;
-            data.mCz = 0.;
-            data.mNentries = 1;
+          if (invertSigns) {
+            data.mCx *= -1.;
+            data.mCy *= -1.;
+            data.mCz *= -1.;
+          }
+          if (data.mNentries > 0) {
+            if (iSector < geo.getNumberOfSectorsA() && data.mZ < 0) {
+              LOG(error) << errMsg << "fitted Z coordinate " << data.mZ << " is negative for sector " << iSector;
+            }
+            if (iSector >= geo.getNumberOfSectorsA() && data.mZ > 0) {
+              LOG(error) << errMsg << "fitted Z coordinate " << data.mZ << " is positive for sector " << iSector;
+            }
           }
         }
       };
@@ -599,7 +620,6 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
           // LOG(info) << "Processing Sector " << iSector << " row " << iRow;
 
           // complete the voxel data
-
           {
             int xBin = iRow;
             double x = trackResiduals.getX(xBin); // radius of the pad row
@@ -619,36 +639,28 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
                 if (iSector >= geo.getNumberOfSectorsA()) {
                   vox.mZ = -vox.mZ;
                 }
-                data.mY *= x;
-                data.mZ *= x;
-                /*
-                if ( fabs(x - data.mX) > 0.01 || fabs(vox.mY - data.mY) > 5. || fabs(vox.mZ - data.mZ) > 5.) {
-                  std::cout
-                    << " sector " << iSector << " row " << iRow
-                    << " voxel x " << x << " y " << vox.mY << " z " << vox.mZ
-                    << " data x " << data.mX << " y " << data.mY << " z " << data.mZ
-                    << std::endl;
-                }
-                */
-                if (0) { // debug: always use voxel center instead of the mean position
-                  data.mY = vox.mY;
-                  data.mZ = vox.mZ;
-                }
-                if (data.mNentries < 1) { // no data
+                if (data.mNentries > 0) { // voxel contains data
+                  vox.mSmoothingStep = 0; // take original data
+                  isDataFound = true;
+                  if (fabs(x - data.mX) > 1. || fabs(vox.mY - data.mY) > 5. || fabs(vox.mZ - data.mZ) > 5.) {
+                    std::cout << directionName << ": fitted voxel is too far from the nominal position: "
+                              << " sector " << iSector << " row " << iRow
+                              << " center x " << x << " y " << vox.mY << " z " << vox.mZ
+                              << " fitted x " << data.mX << " y " << data.mY << " z " << data.mZ
+                              << std::endl;
+                  }
+                } else { // no data, take voxel center position
                   data.mCx = 0.;
                   data.mCy = 0.;
                   data.mCz = 0.;
+                  data.mX = x;
+                  data.mY = vox.mY;
+                  data.mZ = vox.mZ;
+                  vox.mSmoothingStep = 100; // fill this data point with smoothed values from the neighbours
+                }
+                if (0) { // debug: always use voxel center instead of the mean position
                   data.mY = vox.mY;
                   data.mZ = vox.mZ;
-                  vox.mSmoothingStep = 100;
-                } else { // voxel contains data
-                  if (invertSigns) {
-                    data.mCx *= -1.;
-                    data.mCy *= -1.;
-                    data.mCz *= -1.;
-                  }
-                  vox.mSmoothingStep = 0; // original data
-                  isDataFound = true;
                 }
               }
             }
@@ -734,13 +746,13 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
             if (vox2.mSmoothingStep > 2) {
               LOG(fatal) << "empty voxel is not repared: y " << iy2 << " z " << iz2;
             }
-            double y1 = vox1.mY;
-            double z1 = vox1.mZ;
+            double y1 = data1.mY;
+            double z1 = data1.mZ;
             double cx1 = data1.mCx;
             double cy1 = data1.mCy;
             double cz1 = data1.mCz;
-            double y2 = vox2.mY;
-            double z2 = vox2.mZ;
+            double y2 = data2.mY;
+            double z2 = data2.mZ;
             double cx2 = data2.mCx;
             double cy2 = data2.mCy;
             double cz2 = data2.mCz;
@@ -849,6 +861,9 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
       std::vector<float> splineParameters;
 
       for (int row = iThread; row < mGeo.getNumberOfRows(); row += mNthreads) {
+        auto& sectorRowInfo = correction.getSectorRowInfo(sector, row);
+        sectorRowInfo.gridReal = sectorRowInfo.gridMeasured;
+
         TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(sector, row);
         helper.setSpline(spline, 10, 10);
 
@@ -897,33 +912,16 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
               dy += dyTmp * scaling[i];
               dz += dzTmp * scaling[i];
             }
-
-            double realY = y + dy;
-            double realZ = z + dz;
-            double realL = mGeo.convZtoDriftLength(sector, realZ);
-
-            dataPointGridU.push_back(realY);
-            dataPointGridV.push_back(realL);
-            dataPointF.push_back(dx);
-            dataPointF.push_back(dy);
-            dataPointF.push_back(dz);
+            auto [gridU, gridV, scale] = correction.convRealLocalToGrid(sector, row, y + dy, z + dz);
+            dataPointGridU.push_back(gridU);
+            dataPointGridV.push_back(gridV);
+            dataPointF.push_back(scale * dx);
+            dataPointF.push_back(scale * dy);
+            dataPointF.push_back(scale * dz);
           }
         }
 
-        // define the grid for the inverse correction
-
-        auto& sectorRowInfo = correction.getSectorRowInfo(sector, row);
-
-        sectorRowInfo.gridReal = sectorRowInfo.gridMeasured;
-
         int nDataPoints = dataPointGridU.size();
-
-        // convert real Y,Z to grid U,V
-        for (int i = 0; i < nDataPoints; i++) {
-          dataPointGridU[i] = (dataPointGridU[i] - sectorRowInfo.gridReal.y0) * sectorRowInfo.gridReal.yScale;
-          dataPointGridV[i] = (dataPointGridV[i] - sectorRowInfo.gridReal.l0) * sectorRowInfo.gridReal.lScale;
-        }
-
         splineParameters.resize(spline.getNumberOfParameters());
 
         helper.approximateDataPoints(spline, splineParameters.data(), 0., spline.getGridX1().getUmax(),
@@ -1026,10 +1024,10 @@ void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(
           secRowInfo.updateMaxValues(linfo.getMaxValues(), scale);
           secRowInfo.updateMaxValues(linfo.getMinValues(), scale);
 
-          double scaleU = secRowInfo.gridMeasured.yScale / linfo.gridMeasured.yScale;
-          double scaleV = secRowInfo.gridMeasured.lScale / linfo.gridMeasured.lScale;
-          double scaleRealU = secRowInfo.gridReal.yScale / linfo.gridReal.yScale;
-          double scaleRealV = secRowInfo.gridReal.lScale / linfo.gridReal.lScale;
+          double scaleU = secRowInfo.gridMeasured.getYscale() / linfo.gridMeasured.getYscale();
+          double scaleV = secRowInfo.gridMeasured.getZscale() / linfo.gridMeasured.getZscale();
+          double scaleRealU = secRowInfo.gridReal.getYscale() / linfo.gridReal.getYscale();
+          double scaleRealV = secRowInfo.gridReal.getZscale() / linfo.gridReal.getZscale();
 
           for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
             double u = gridU.getKnot(iu).u;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 1e6d84b7f8dd9..eb5fe8669a52f 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -35,7 +35,7 @@ TPCFastSpaceChargeCorrection::TPCFastSpaceChargeCorrection()
     mScenarioPtr(nullptr),
     mTimeStamp(-1),
     mSplineData{nullptr, nullptr, nullptr},
-    mSectorDataSizeBytes{0, 0, 0}
+    mDataSizeBytes{0, 0, 0}
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -64,7 +64,7 @@ void TPCFastSpaceChargeCorrection::destroy()
   mTimeStamp = -1;
   for (int32_t is = 0; is < 3; is++) {
     mSplineData[is] = nullptr;
-    mSectorDataSizeBytes[is] = 0;
+    mDataSizeBytes[is] = 0;
   }
   FlatObject::destroy();
 }
@@ -105,9 +105,9 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
     mSectorInfo[i] = obj.mSectorInfo[i];
   }
 
-  mSectorDataSizeBytes[0] = obj.mSectorDataSizeBytes[0];
-  mSectorDataSizeBytes[1] = obj.mSectorDataSizeBytes[1];
-  mSectorDataSizeBytes[2] = obj.mSectorDataSizeBytes[2];
+  mDataSizeBytes[0] = obj.mDataSizeBytes[0];
+  mDataSizeBytes[1] = obj.mDataSizeBytes[1];
+  mDataSizeBytes[2] = obj.mDataSizeBytes[2];
 
   // variable-size data
   mScenarioPtr = obj.mScenarioPtr;
@@ -162,9 +162,9 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
   }
   size_t bufferSize = scBufferOffset + scBufferSize;
   for (int32_t is = 0; is < 3; is++) {
-    size_t sectorDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + sectorDataOffset);
-    bufferSize = sectorDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
+    size_t splineDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + splineDataOffset);
+    bufferSize = splineDataOffset + mDataSizeBytes[is];
   }
 }
 
@@ -199,14 +199,8 @@ void TPCFastSpaceChargeCorrection::print() const
   mGeo.print();
   LOG(info) << "  mNumberOfScenarios = " << mNumberOfScenarios;
   LOG(info) << "  mTimeStamp = " << mTimeStamp;
-  LOG(info) << "  mSectorDataSizeBytes = " << mSectorDataSizeBytes[0] << " " << mSectorDataSizeBytes[1] << " " << mSectorDataSizeBytes[2];
-  {
-    LOG(info) << "  TPC rows: ";
-    for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-      const RowInfo& r = mRowInfos[i];
-      LOG(info) << " tpc row " << i << ": splineScenarioID = " << r.splineScenarioID << " dataOffsetBytes = " << r.dataOffsetBytes;
-    }
-  }
+  LOG(info) << "  mDataSizeBytes = " << mDataSizeBytes[0] << " " << mDataSizeBytes[1] << " " << mDataSizeBytes[2];
+
   if (mScenarioPtr) {
     for (int32_t i = 0; i < mNumberOfScenarios; i++) {
       LOG(info) << " SplineScenario " << i << ": ";
@@ -255,8 +249,23 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
 
   assert(mConstructionScenarios != nullptr);
 
-  for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-    mRowInfos[i].splineScenarioID = -1;
+  for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
+    mSectorInfo[i].vMax1 = 0.;
+    for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
+      auto& row = mSectorRowInfos[mGeo.getMaxNumberOfRows() * i + j];
+      row.splineScenarioID = -1;
+      row.gridReal = {};
+      row.gridMeasured = {};
+      row.dataOffsetBytes[0] = 0;
+      row.dataOffsetBytes[1] = 0;
+      row.dataOffsetBytes[2] = 0;
+      row.minCorr[0] = 0;
+      row.minCorr[1] = 0;
+      row.minCorr[2] = 0;
+      row.maxCorr[0] = 0;
+      row.maxCorr[1] = 0;
+      row.maxCorr[2] = 0;
+    }
   }
 
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -268,18 +277,18 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
   mScenarioPtr = nullptr;
   for (int32_t s = 0; s < 3; s++) {
     mSplineData[s] = nullptr;
-    mSectorDataSizeBytes[s] = 0;
+    mDataSizeBytes[s] = 0;
   }
   mClassVersion = 4;
 }
 
-void TPCFastSpaceChargeCorrection::setRowScenarioID(int32_t iRow, int32_t iScenario)
+void TPCFastSpaceChargeCorrection::setRowScenarioID(int32_t iSector, int32_t iRow, int32_t iScenario)
 {
   /// Initializes a TPC row
   assert(mConstructionMask & ConstructionState::InProgress);
+  assert(iSector >= 0 && iSector < mGeo.getNumberOfSectors());
   assert(iRow >= 0 && iRow < mGeo.getNumberOfRows() && iScenario >= 0 && iScenario < mNumberOfScenarios);
-
-  RowInfo& row = mRowInfos[iRow];
+  auto& row = getSectorRowInfo(iSector, iRow);
   row.splineScenarioID = iScenario;
   for (int32_t s = 0; s < 3; s++) {
     row.dataOffsetBytes[s] = 0;
@@ -302,9 +311,14 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 
   assert(mConstructionMask & ConstructionState::InProgress);
 
-  for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-    assert(mRowInfos[i].splineScenarioID >= 0);
+  for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
+    for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
+      SectorRowInfo& row = getSectorRowInfo(i, j);
+      assert(row.splineScenarioID >= 0);
+      assert(row.splineScenarioID < mNumberOfScenarios);
+    }
   }
+
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
     assert(mConstructionScenarios[i].isConstructed());
   }
@@ -324,18 +338,20 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
     scBufferSize = alignSize(scBufferSize + sp.getFlatBufferSize(), sp.getBufferAlignmentBytes());
   }
   size_t bufferSize = scBufferOffsets[0] + scBufferSize;
-  size_t sectorDataOffset[3];
+  size_t splineDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
-    sectorDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mSectorDataSizeBytes[is] = 0;
-    for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
-      RowInfo& row = mRowInfos[i];
-      SplineType& spline = mConstructionScenarios[row.splineScenarioID];
-      row.dataOffsetBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-      mSectorDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
+    splineDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mDataSizeBytes[is] = 0;
+    for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
+      for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
+        SectorRowInfo& row = getSectorRowInfo(i, j);
+        SplineType& spline = mConstructionScenarios[row.splineScenarioID];
+        row.dataOffsetBytes[is] = alignSize(mDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
+        mDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
+      }
     }
-    mSectorDataSizeBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-    bufferSize = sectorDataOffset[is] + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
+    mDataSizeBytes[is] = alignSize(mDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
+    bufferSize = splineDataOffset[is] + mDataSizeBytes[is];
   }
 
   FlatObject::finishConstruction(bufferSize);
@@ -350,7 +366,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   }
 
   for (int32_t is = 0; is < 3; is++) {
-    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + sectorDataOffset[is]);
+    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + splineDataOffset[is]);
   }
   releaseConstructionMemory();
 
@@ -363,9 +379,9 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
 {
   // initialise all corrections to 0.
   for (int32_t sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
-    double vLength = mGeo.getTPCzLength();
-    SectorInfo& sectorInfo = getSectorInfo(sector);
-    sectorInfo.vMax = vLength;
+
+    getSectorInfo(sector).vMax1 = mGeo.getTPCzLength();
+
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
       const SplineType& spline = getSpline(sector, row);
 
@@ -385,10 +401,12 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
 
       SectorRowInfo& info = getSectorRowInfo(sector, row);
 
-      info.gridMeasured.y0 = mGeo.getRowInfo(row).getYmin();
-      info.gridMeasured.yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getYwidth();
-      info.gridMeasured.l0 = 0.f;
-      info.gridMeasured.lScale = spline.getGridX2().getUmax() / vLength;
+      float y0 = mGeo.getRowInfo(row).getYmin();
+      float yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getYwidth();
+      float z0 = mGeo.getZmin(sector);
+      float zScale = spline.getGridX2().getUmax() / mGeo.getTPCzLength();
+      float zReadout = mGeo.getZreadout(sector);
+      info.gridMeasured.set(y0, yScale, z0, zScale, zReadout, zReadout);
 
       info.gridReal = info.gridMeasured;
     } // row
@@ -399,8 +417,10 @@ void TPCFastSpaceChargeCorrection::constructWithNoCorrection(const TPCFastTransf
 {
   const int32_t nCorrectionScenarios = 1;
   startConstruction(geo, nCorrectionScenarios);
-  for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
-    setRowScenarioID(row, 0);
+  for (int32_t sector = 0; sector < geo.getNumberOfSectors(); sector++) {
+    for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
+      setRowScenarioID(sector, row, 0);
+    }
   }
   {
     TPCFastSpaceChargeCorrection::SplineType spline;
@@ -456,20 +476,13 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
     if (prn) {
       LOG(info) << "check inverse transform for sector " << sector;
     }
-    double vLength = mGeo.getTPCzLength();
+
     MaxValue maxDsector[3];
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
       double x = mGeo.getRowInfo(row).x;
       auto [y0, y1] = mGeo.getRowInfo(row).getYrange();
       auto [z0, z1] = mGeo.getZrange(sector);
 
-      // grid borders
-      if (sector < mGeo.getNumberOfSectorsA()) {
-        z1 = vLength - getSectorRowInfo(sector, row).gridMeasured.l0;
-      } else {
-        z0 = getSectorRowInfo(sector, row).gridMeasured.l0 - vLength;
-      }
-
       double stepY = (y1 - y0) / 100.;
       double stepZ = (z1 - z0) / 100.;
       MaxValue maxDrow[3];
@@ -479,7 +492,7 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
           double realX = x + dx;
           double realY = y + dy;
           double realZ = z + dz;
-          if (!isLocalInsideGrid(sector, row, y, z) || !isLocalInsideGrid(sector, row, realY, realZ)) {
+          if (!isLocalInsideGrid(sector, row, y, z) || !isRealLocalInsideGrid(sector, row, realY, realZ)) {
             continue;
           }
           double r2 = realX * realX + realY * realY;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 4564d584c8dce..7112a04b364c6 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -43,31 +43,58 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// \brief The struct contains necessary info for TPC padrow
   ///
   struct RowInfo {
-    int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
-    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing the TPC sector
     ClassDefNV(RowInfo, 1);
   };
 
   struct GridInfo {
-    float y0{0.f};     ///< Y coordinate of the U-grid start
-    float yScale{0.f}; //< scale Y to U-grid coordinate
-    float l0{0.f};     ///< Drift Length coordinate of the V-grid start
-    float lScale{0.f}; //< scale Drift Length to V-grid coordinate
+   private:
+    float y0{0.f};                 ///< Y coordinate of the U-grid start
+    float yScale{0.f};             //< scale Y to U-grid coordinate
+    float z0{0.f};                 ///< Z coordinate of the V-grid start
+    float zScale{0.f};             //< scale Z to V-grid coordinate
+    float zOut{0.f};               // outer z of the grid;
+    float splineScalingWithZ{0.f}; ///< spline scaling factor in the Z region between the zOut and the readout plane
+
+   public:
+    void set(float y0, float yScale, float z0, float zScale, float zOut, float zReadout)
+    {
+      this->y0 = y0;
+      this->yScale = yScale;
+      this->z0 = z0;
+      this->zScale = zScale;
+      this->zOut = zOut;
+      // no scaling when the distance to the readout is too small
+      this->splineScalingWithZ = fabs(zReadout - zOut) > 1. ? 1. / (zReadout - zOut) : 0.;
+    }
+
+    float getY0() const { return y0; }
+    float getYscale() const { return yScale; }
+    float getZ0() const { return z0; }
+    float getZscale() const { return zScale; }
+
+    float getSpineScaleForZ(float z) const
+    {
+      return 1.f - GPUCommonMath::Clamp((z - zOut) * splineScalingWithZ, 0.f, 1.f);
+    }
+
+    /// convert local y, z to internal grid coordinates u,v, and spline scale
+    std::tuple<float, float, float> convLocalToGridUntruncated(float y, float z) const
+    {
+      return {(y - y0) * yScale, (z - z0) * zScale, getSpineScaleForZ(z)};
+    }
 
-    float getScale(float l) const
+    /// convert internal grid coordinates u,v to local y, z
+    std::tuple<float, float> convGridToLocal(float gridU, float gridV) const
     {
-      if (l < 0.f) { // outside of the TPC
-        return 0.f;
-      }
-      if (l < l0) { // between the grid and the readout
-        return l / l0;
-      }
-      return 1.f; // inside the grid
+      return {y0 + gridU / yScale, z0 + gridV / zScale};
     }
     ClassDefNV(GridInfo, 1);
   };
 
   struct SectorRowInfo {
+    int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
+    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC sector
+
     GridInfo gridMeasured; ///< grid info for measured coordinates
     GridInfo gridReal;     ///< grid info for real coordinates
 
@@ -118,7 +145,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   };
 
   struct SectorInfo {
-    float vMax{0.f}; ///< Max value of V coordinate
+    float vMax1{0.f}; ///< Max value of V coordinate
     ClassDefNV(SectorInfo, 1);
   };
 
@@ -170,7 +197,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   void startConstruction(const TPCFastTransformGeo& geo, int32_t numberOfSplineScenarios);
 
   /// Initializes a TPC row
-  void setRowScenarioID(int32_t iRow, int32_t iScenario);
+  void setRowScenarioID(int32_t iSector, int32_t iRow, int32_t iScenario);
 
   /// Sets approximation scenario
   void setSplineScenario(int32_t scenarioIndex, const SplineType& spline);
@@ -259,6 +286,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() std::tuple<float, float> convGridToRealLocal(int32_t sector, int32_t row, float u, float v) const;
 
   GPUd() bool isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
+  GPUd() bool isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
 
   /// TPC geometry information
   GPUd() const TPCFastTransformGeo& getGeometry() const
@@ -333,7 +361,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   char* mSplineData[3]; //! (transient!!) pointer to the spline data in the flat buffer
 
-  size_t mSectorDataSizeBytes[3]; ///< size of the data for one sector in the flat buffer
+  size_t mDataSizeBytes[3]; ///< size of the data for one sector in the flat buffer
 
   float fInterpolationSafetyMargin{0.1f}; // 10% area around the TPC row. Outside of this area the interpolation returns the boundary values.
 
@@ -356,29 +384,25 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 GPUdi() const TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t sector, int32_t row) const
 {
   /// Gives const pointer to spline
-  const RowInfo& rowInfo = mRowInfos[row];
-  return mScenarioPtr[rowInfo.splineScenarioID];
+  return mScenarioPtr[getSectorRowInfo(sector, row).splineScenarioID];
 }
 
 GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t sector, int32_t row)
 {
   /// Gives pointer to spline
-  const RowInfo& rowInfo = mRowInfos[row];
-  return mScenarioPtr[rowInfo.splineScenarioID];
+  return mScenarioPtr[getSectorRowInfo(sector, row).splineScenarioID];
 }
 
 GPUdi() float* TPCFastSpaceChargeCorrection::getSplineData(int32_t sector, int32_t row, int32_t iSpline)
 {
   /// Gives pointer to spline data
-  const RowInfo& rowInfo = mRowInfos[row];
-  return reinterpret_cast<float*>(mSplineData[iSpline] + mSectorDataSizeBytes[iSpline] * sector + rowInfo.dataOffsetBytes[iSpline]);
+  return reinterpret_cast<float*>(mSplineData[iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]);
 }
 
 GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t sector, int32_t row, int32_t iSpline) const
 {
   /// Gives pointer to spline data
-  const RowInfo& rowInfo = mRowInfos[row];
-  return reinterpret_cast<float*>(mSplineData[iSpline] + mSectorDataSizeBytes[iSpline] * sector + rowInfo.dataOffsetBytes[iSpline]);
+  return reinterpret_cast<const float*>(mSplineData[iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]);
 }
 
 GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCorrection::getSplineInvX(int32_t sector, int32_t row)
@@ -433,37 +457,35 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convLocalT
 {
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
-  const auto& info = getSectorRowInfo(sector, row);
   const SplineType& spline = getSpline(sector, row);
-
-  float l = mGeo.convZtoDriftLength(sector, z);
-  float scale = info.gridMeasured.getScale(l);
-  float gridU = (y - info.gridMeasured.y0) * info.gridMeasured.yScale;
-  float gridV = (l - info.gridMeasured.l0) * info.gridMeasured.lScale;
-
-  // shrink to the grid area
+  auto [gridU, gridV, scale] = getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z);
+  // shrink to the grid
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
   gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
-
   return {gridU, gridV, scale};
 }
 
 GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
 {
-  /// ccheck if local y, z are inside the grid
-
-  const auto& info = getSectorRowInfo(sector, row);
+  /// check if local y, z are inside the grid
+  auto [gridU, gridV, scale] = getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z);
   const auto& spline = getSpline(sector, row);
-  float l = mGeo.convZtoDriftLength(sector, z);
-
-  float gridU = (y - info.gridMeasured.y0) * info.gridMeasured.yScale;
-  float gridV = (l - info.gridMeasured.l0) * info.gridMeasured.lScale;
-
-  // shrink to the grid area
-  if (gridU < 0.f || gridU > (float)spline.getGridX1().getUmax()) {
+  // shrink to the grid
+  if (gridU < 0.f || gridU > (float)spline.getGridX1().getUmax() || //
+      gridV < 0.f || gridV > (float)spline.getGridX2().getUmax()) {
     return false;
   }
-  if (gridV < 0.f || gridV > (float)spline.getGridX2().getUmax()) {
+  return true;
+}
+
+GPUdi() bool TPCFastSpaceChargeCorrection::isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
+{
+  /// check if local y, z are inside the grid
+  auto [gridU, gridV, scale] = getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z);
+  const auto& spline = getSpline(sector, row);
+  // shrink to the grid
+  if (gridU < 0.f || gridU > (float)spline.getGridX1().getUmax() || //
+      gridV < 0.f || gridV > (float)spline.getGridX2().getUmax()) {
     return false;
   }
   return true;
@@ -472,39 +494,24 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int
 GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV) const
 {
   /// convert internal grid coordinates u,v to local y, z
-  const SectorRowInfo& info = getSectorRowInfo(sector, row);
-  float y = info.gridMeasured.y0 + gridU / info.gridMeasured.yScale;
-  float l = info.gridMeasured.l0 + gridV / info.gridMeasured.lScale;
-  float z = mGeo.convDriftLengthToZ(sector, l);
-  return {y, z};
+  return getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(gridU, gridV);
 }
 
 GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// convert real y, z to the internal grid coordinates + scale
-  const auto& info = getSectorRowInfo(sector, row);
-  const auto& spline = getSpline(sector, row);
-
-  float l = mGeo.convZtoDriftLength(sector, z);
-  float scale = info.gridReal.getScale(l);
-  float gridU = (y - info.gridReal.y0) * info.gridReal.yScale;
-  float gridV = (l - info.gridReal.l0) * info.gridReal.lScale;
-
-  // shrink to the grid area
+  const SplineType& spline = getSpline(sector, row);
+  auto [gridU, gridV, scale] = getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z);
+  // shrink to the grid
   gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
   gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
-
   return {gridU, gridV, scale};
 }
 
 GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV) const
 {
   /// convert internal grid coordinates u,v to the real y, z
-  const SectorRowInfo& info = getSectorRowInfo(sector, row);
-  float y = info.gridReal.y0 + gridU / info.gridReal.yScale;
-  float l = info.gridReal.l0 + gridV / info.gridReal.lScale;
-  float z = mGeo.convDriftLengthToZ(sector, l);
-  return {y, z};
+  return getSectorRowInfo(sector, row).gridReal.convGridToLocal(gridU, gridV);
 }
 
 GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.cxx b/GPU/TPCFastTransformation/TPCFastTransform.cxx
index 625f70c1710a1..42c4c57ffa086 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransform.cxx
@@ -103,10 +103,6 @@ void TPCFastTransform::startConstruction(const TPCFastSpaceChargeCorrection& cor
   mApplyCorrection = 1;
   mT0 = 0.f;
   mVdrift = 0.f;
-  mVdriftCorrY = 0.f;
-  mLdriftCorr = 0.f;
-  mTOFcorr = 0.f;
-  mPrimVtxZ = 0.f;
   mLumi = DEFLUMI;
   mLumiError = 0.f;
   mIDC = DEFIDC;
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 8807c0e3206f4..3b08296525fc7 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -551,7 +551,7 @@ GPUdi() void TPCFastTransform::Transform(int32_t sector, int32_t row, float pad,
 GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const
 {
   float l = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
-  z = getGeometry().convDriftLengthToZ(sector, l);
+  z = getGeometry().convDriftLengthToZ1(sector, l);
 }
 
 GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
@@ -590,7 +590,7 @@ GPUdi() void TPCFastTransform::TransformIdealZ(int32_t sector, float time, float
   ///
 
   float l = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  z = getGeometry().convDriftLengthToZ(sector, l);
+  z = getGeometry().convDriftLengthToZ1(sector, l);
 }
 
 GPUdi() void TPCFastTransform::TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index bbb94dcb8bedd..89b099ec63127 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -126,6 +126,9 @@ class TPCFastTransformGeo
 
   /// Gives Z range for the corresponding TPC side
   GPUd() std::tuple<float, float> getZrange(int32_t sector) const;
+  GPUd() float getZmin(int32_t sector) const;
+  GPUd() float getZmax(int32_t sector) const;
+  GPUd() float getZreadout(int32_t sector) const;
 
   /// _______________  Conversion of coordinate systems __________
 
@@ -139,10 +142,10 @@ class TPCFastTransformGeo
   GPUd() std::tuple<float, float> convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const;
 
   /// convert DriftLength -> Local c.s.
-  GPUd() float convDriftLengthToZ(int32_t sector, float driftLength) const;
+  GPUd() float convDriftLengthToZ1(int32_t sector, float driftLength) const;
 
   /// convert Z to DriftLength
-  GPUd() float convZtoDriftLength(int32_t sector, float z) const;
+  GPUd() float convZtoDriftLength1(int32_t sector, float z) const;
 
   /// convert Local c.s. -> Pad, DriftLength
   GPUd() std::tuple<float, float> convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const;
@@ -181,7 +184,7 @@ class TPCFastTransformGeo
   float mTPCzLength = 0.f;   ///< Z length of one TPC side (A or C)
 
   SectorInfo mSectorInfos[NumberOfSectors + 1]; ///< array of sector information [fixed size]
-  RowInfo mRowInfos[MaxNumberOfRows + 1]; ///< array of row information [fixed size]
+  RowInfo mRowInfos[MaxNumberOfRows + 1];       ///< array of row information [fixed size]
 
   ClassDefNV(TPCFastTransformGeo, 3);
 };
@@ -242,13 +245,13 @@ GPUdi() std::tuple<float, float> TPCFastTransformGeo::convPadDriftLengthToLocal(
   return {y, z};
 }
 
-GPUdi() float TPCFastTransformGeo::convDriftLengthToZ(int32_t sector, float driftLength) const
+GPUdi() float TPCFastTransformGeo::convDriftLengthToZ1(int32_t sector, float driftLength) const
 {
   /// convert DriftLength -> Local c.s.
   return (sector < NumberOfSectorsA) ? (mTPCzLength - driftLength) : (driftLength - mTPCzLength);
 }
 
-GPUdi() float TPCFastTransformGeo::convZtoDriftLength(int32_t sector, float z) const
+GPUdi() float TPCFastTransformGeo::convZtoDriftLength1(int32_t sector, float z) const
 {
   /// convert Z to DriftLength
   return (sector < NumberOfSectorsA) ? (mTPCzLength - z) : (z + mTPCzLength);
@@ -264,6 +267,36 @@ GPUdi() std::tuple<float, float> TPCFastTransformGeo::getZrange(int32_t sector)
   }
 }
 
+GPUdi() float TPCFastTransformGeo::getZmin(int32_t sector) const
+{
+  /// z min for the sector
+  if (sector < NumberOfSectorsA) { // TPC side A
+    return 0.f;
+  } else { // TPC side C
+    return -mTPCzLength;
+  }
+}
+
+GPUdi() float TPCFastTransformGeo::getZmax(int32_t sector) const
+{
+  /// z max for the sector
+  if (sector < NumberOfSectorsA) { // TPC side A
+    return mTPCzLength;
+  } else { // TPC side C
+    return 0.f;
+  }
+}
+
+GPUdi() float TPCFastTransformGeo::getZreadout(int32_t sector) const
+{
+  /// z readout for the sector
+  if (sector < NumberOfSectorsA) { // TPC side A
+    return mTPCzLength;
+  } else { // TPC side C
+    return -mTPCzLength;
+  }
+}
+
 GPUdi() std::tuple<float, float> TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const
 {
   /// convert Local c.s. -> Pad, DriftLength
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index fc15506d5397c..916695a3be1c7 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -70,6 +70,7 @@
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SectorInfo + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SectorRowInfo + ;
+#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::GridInfo + ;
 
 #pragma link C++ class o2::gpu::CorrectionMapsHelper + ;
 #pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index f0c03d9f5f081..974582792266b 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -150,7 +150,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
   o2::tpc::TPCFastSpaceChargeCorrectionHelper* corrHelper = o2::tpc::TPCFastSpaceChargeCorrectionHelper::instance();
 
   corrHelper->setNthreadsToMaximum();
-  // corrHelper->setNthreads(1);
+  corrHelper->setNthreads(1);
 
   auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, voxResTreeInverse, useSmoothed, invertSigns);
 
@@ -185,10 +185,10 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
         for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
           auto& info = corr.getSectorRowInfo(iSector, iRow);
           std::cout << "sector " << iSector << " row " << iRow
-                    << " gridY0 " << info.gridMeasured.y0 << " gridL0 " << info.gridMeasured.l0
-                    << " scaleYtoGrid " << info.gridMeasured.yScale << " scaleLtoGrid " << info.gridMeasured.lScale
-                    << " gridRealY0 " << info.gridReal.y0 << " gridRealL0 " << info.gridReal.l0
-                    << " scaleRealYtoGrid " << info.gridReal.yScale << " scaleRealLtoGrid " << info.gridReal.lScale
+                    << " gridY0 " << info.gridMeasured.getY0() << " gridZ0 " << info.gridMeasured.getZ0()
+                    << " scaleYtoGrid " << info.gridMeasured.getYscale() << " scaleLtoGrid " << info.gridMeasured.getZscale()
+                    << " gridRealY0 " << info.gridReal.getY0() << " gridRealZ0 " << info.gridReal.getZ0()
+                    << " scaleRealYtoGrid " << info.gridReal.getYscale() << " scaleRealLtoGrid " << info.gridReal.getZscale()
                     << std::endl;
         }
       }
@@ -379,7 +379,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
       const auto& gridY = corr.getSpline(iSector, iRow).getGridX1();
       const auto& gridZ = corr.getSpline(iSector, iRow).getGridX2();
       if (iSector == 0 && iRow == 0) {
-        std::cout << "spline scenario " << corr.getRowInfo(iRow).splineScenarioID << std::endl;
+        std::cout << "spline scenario " << corr.getSectorRowInfo(iSector, iRow).splineScenarioID << std::endl;
         std::cout << "spline grid Y: u = " << 0 << ".." << gridY.getUmax() << ", x = " << gridY.getXmin() << ".." << gridY.getXmax() << std::endl;
         std::cout << "spline grid Z: u = " << 0 << ".." << gridZ.getUmax() << ", x = " << gridZ.getXmin() << ".." << gridZ.getXmax() << std::endl;
       }

From 19120c81ab88c5be50b5e32acfde98500a602ab7 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <se.gorbunov@gsi.de>
Date: Wed, 20 Aug 2025 07:50:56 +0000
Subject: [PATCH 1574/1764] TPC Splines: correct biased voxels; features for
 debugging

---
 .../TPCFastSpaceChargeCorrectionHelper.h      |  32 +-
 .../TPCFastSpaceChargeCorrectionHelper.cxx    |  75 ++-
 .../macro/TPCFastTransformInit.C              | 521 +++++++++++-------
 3 files changed, 419 insertions(+), 209 deletions(-)

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
index e8afd9be97d5f..40c5634b4f1e8 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h
@@ -90,11 +90,16 @@ class TPCFastSpaceChargeCorrectionHelper
   /// \param voxResTreeInverse TTree with inverse voxel residuals
   /// \param useSmoothed if true, use smoothed residuals
   /// \param invertSigns if true, invert the signs of the residuals
+  /// \param fitPointsDirect debug: pointer to the data used for the direct correction
+  /// \param fitPointsInverse debug: pointer to the data used for the inverse correction
   /// \return pointer to the created TPCFastSpaceChargeCorrection object
   /// \note voxel trees wont be changed. They are read as non-const because of the ROOT::TTreeProcessorMT interface
+  ///
   std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> createFromTrackResiduals(
     const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, TTree* voxResTreeInverse, //
-    bool useSmoothed, bool invertSigns);
+    bool useSmoothed, bool invertSigns,                                                         //
+    TPCFastSpaceChargeCorrectionMap* fitPointsDirect = nullptr,
+    TPCFastSpaceChargeCorrectionMap* fitPointsInverse = nullptr);
 
   /// _______________  Utilities   ________________________
 
@@ -116,10 +121,28 @@ class TPCFastSpaceChargeCorrectionHelper
   /// \param additionalCorrections vector of pairs of additional corrections and their scaling factors
   /// \param prn printout flag
   /// \return main correction merged with additional corrections
-  void MergeCorrections(
+  void mergeCorrections(
     o2::gpu::TPCFastSpaceChargeCorrection& mainCorrection, float scale,
     const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>>& additionalCorrections, bool prn);
 
+  /// how far the voxel mean is allowed to be outside of the voxel (1.1 means 10%)
+  void setVoxelMeanValidityRange(double range)
+  {
+    mVoxelMeanValidityRange = range;
+  }
+
+  double getVoxelMeanValidityRange() const { return mVoxelMeanValidityRange; }
+
+  /// debug: if true, use voxel centers instead of the fitted positions for correction
+  void setDebugUseVoxelCenters();
+
+  bool isDebugUseVoxelCenters() const { return mDebugUseVoxelCenters; }
+
+  /// debug: if true, mirror the data from the A side to the C side of the TPC
+  void setDebugMirrorAdata2C();
+
+  bool isDebugMirrorAdata2C() const { return mDebugMirrorAdata2C; }
+
  private:
   /// geometry initialization
   void initGeometry();
@@ -133,6 +156,11 @@ class TPCFastSpaceChargeCorrectionHelper
 
   TPCFastSpaceChargeCorrectionMap mCorrectionMap{0, 0};
 
+  double mVoxelMeanValidityRange{1.1}; ///< debug: how far the voxel mean is allowed to be outside of the voxel (1.1 means 10%)
+
+  bool mDebugUseVoxelCenters{false}; ///< debug: if true, use voxel centers instead of the fitted positions for correction
+  bool mDebugMirrorAdata2C{false};   ///< debug: if true, mirror the data from the A side to the C side of the TPC
+
   ClassDefNV(TPCFastSpaceChargeCorrectionHelper, 0);
 };
 
diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index d2f6cf57b0de7..6122c5717fcbb 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -33,6 +33,7 @@
 #include "TTreeReaderValue.h"
 #include "ROOT/TTreeProcessorMT.hxx"
 #include <algorithm>
+#include <sstream>
 
 using namespace o2::gpu;
 
@@ -381,7 +382,9 @@ void TPCFastSpaceChargeCorrectionHelper::testGeometry(const TPCFastTransformGeo&
 }
 
 std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper::createFromTrackResiduals(
-  const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, TTree* voxResTreeInverse, bool useSmoothed, bool invertSigns)
+  const o2::tpc::TrackResiduals& trackResiduals, TTree* voxResTree, TTree* voxResTreeInverse, bool useSmoothed, bool invertSigns,
+  TPCFastSpaceChargeCorrectionMap* fitPointsDirect,
+  TPCFastSpaceChargeCorrectionMap* fitPointsInverse)
 {
   // create o2::gpu::TPCFastSpaceChargeCorrection  from o2::tpc::TrackResiduals::VoxRes voxel tree
 
@@ -603,6 +606,24 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       processor.Process(myThread);
     }
 
+    // debug: mirror the data for TPC C side
+
+    if (mDebugMirrorAdata2C) {
+      for (int iSector = 0; iSector < geo.getNumberOfSectorsA(); iSector++) {
+        for (int iRow = 0; iRow < nRows; iRow++) {
+          for (int iy = 0; iy < nY2Xbins; iy++) {
+            for (int iz = 0; iz < nZ2Xbins; iz++) {
+              auto& dataA = vSectorData[iSector * nRows + iRow][iy * nZ2Xbins + iz];
+              auto& dataC = vSectorData[(iSector + geo.getNumberOfSectorsA()) * nRows + iRow][iy * nZ2Xbins + iz];
+              dataC = dataA;          // copy the data
+              dataC.mZ = -dataC.mZ;   // mirror the Z coordinate
+              dataC.mCz = -dataC.mCz; // mirror the Z correction
+            }
+          }
+        }
+      }
+    }
+
     for (int iSector = 0; iSector < nSectors; iSector++) {
 
       // now process the data row-by-row
@@ -623,6 +644,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
           {
             int xBin = iRow;
             double x = trackResiduals.getX(xBin); // radius of the pad row
+            double dx = 1. / trackResiduals.getDXI(xBin);
             bool isDataFound = false;
             for (int iy = 0; iy < nY2Xbins; iy++) {
               for (int iz = 0; iz < nZ2Xbins; iz++) {
@@ -642,13 +664,29 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
                 if (data.mNentries > 0) { // voxel contains data
                   vox.mSmoothingStep = 0; // take original data
                   isDataFound = true;
-                  if (fabs(x - data.mX) > 1. || fabs(vox.mY - data.mY) > 5. || fabs(vox.mZ - data.mZ) > 5.) {
-                    std::cout << directionName << ": fitted voxel is too far from the nominal position: "
-                              << " sector " << iSector << " row " << iRow
-                              << " center x " << x << " y " << vox.mY << " z " << vox.mZ
-                              << " fitted x " << data.mX << " y " << data.mY << " z " << data.mZ
-                              << std::endl;
+
+                  // correct the mean position if it is outside the voxel
+                  std::stringstream msg;
+                  if (fabs(x - data.mX) > mVoxelMeanValidityRange * dx / 2.) {
+                    msg << "\n     x: center " << x << " dx " << data.mX - x << " half bin size: " << dx / 2;
+                  }
+
+                  if (fabs(vox.mY - data.mY) > mVoxelMeanValidityRange * vox.mDy / 2.) {
+                    msg << "\n     y: center " << vox.mY << " dy " << data.mY - vox.mY << " half bin size: " << vox.mDy / 2;
+                    data.mY = vox.mY;
+                  }
+
+                  if (fabs(vox.mZ - data.mZ) > mVoxelMeanValidityRange * vox.mDz / 2.) {
+                    msg << "\n     z: center " << vox.mZ << " dz " << data.mZ - vox.mZ << " half bin size: " << vox.mDz / 2;
+                    data.mZ = vox.mZ;
                   }
+
+                  if (!msg.str().empty()) {
+                    LOG(warning) << directionName << " correction: fitted voxel position is outside the voxel: "
+                                 << " sector " << iSector << " row " << iRow << " bin: " << iy << " " << iz
+                                 << msg.str();
+                  }
+
                 } else { // no data, take voxel center position
                   data.mCx = 0.;
                   data.mCy = 0.;
@@ -658,7 +696,7 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
                   data.mZ = vox.mZ;
                   vox.mSmoothingStep = 100; // fill this data point with smoothed values from the neighbours
                 }
-                if (0) { // debug: always use voxel center instead of the mean position
+                if (mDebugUseVoxelCenters) { // debug: always use voxel center instead of the mean position
                   data.mY = vox.mY;
                   data.mZ = vox.mZ;
                 }
@@ -809,6 +847,13 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
     TStopwatch watch4;
 
+    if (!processingInverseCorrection && fitPointsDirect) {
+      *fitPointsDirect = helper->getCorrectionMap();
+    }
+    if (processingInverseCorrection && fitPointsInverse) {
+      *fitPointsInverse = helper->getCorrectionMap();
+    }
+
     helper->fillSpaceChargeCorrectionFromMap(correction, processingInverseCorrection);
 
     LOG(info) << "fast space charge correction helper: creation from the data map took " << watch4.RealTime() << "s";
@@ -956,7 +1001,7 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
   LOGP(info, "Inverse tooks: {}s", duration);
 }
 
-void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(
+void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
   o2::gpu::TPCFastSpaceChargeCorrection& mainCorrection, float mainScale,
   const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>>& additionalCorrections, bool /*prn*/)
 {
@@ -1099,5 +1144,17 @@ void TPCFastSpaceChargeCorrectionHelper::MergeCorrections(
   LOGP(info, "Merge of corrections tooks: {}s", duration);
 }
 
+void TPCFastSpaceChargeCorrectionHelper::setDebugUseVoxelCenters()
+{
+  LOG(info) << "fast space charge correction helper: use voxel centers for correction";
+  mDebugUseVoxelCenters = true;
+}
+
+void TPCFastSpaceChargeCorrectionHelper::setDebugMirrorAdata2C()
+{
+  LOG(info) << "fast space charge correction helper: mirror A data to C data";
+  mDebugMirrorAdata2C = true;
+}
+
 } // namespace tpc
 } // namespace o2
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 974582792266b..50b667bb3e023 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -56,13 +56,14 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
     To visiualise the results:
 
     root -l transformDebug.root
-    corr->Draw("cx:y:z","iSector==0&&iRow==10","")
-    grid->Draw("cx:y:z","iSector==0&&iRow==10","same")
-    vox->Draw("vx:y:z","iSector==0&&iRow==10","same")
-    corrvox->Draw("cx:y:z","iSector==0&&iRow==10","same")
-    points->Draw("px:y:z","iSector==0&&iRow==10","same")
+    all->Draw("cx:y:z","sec==0&&iRow==10","")
+    grid->Draw("cx:y:z","sec==0&&iRow==10","same")
+    vox->Draw("vx:y:z","sec==0&&iRow==10","same")
+    points->Draw("px:y:z","sec==0&&row==10","same")
   */
 
+  const bool debugMirrorAdata2C = 0;
+
   if (gSystem->AccessPathName(fileName)) {
     std::cout << " input file " << fileName << " does not exist!" << std::endl;
     return;
@@ -152,7 +153,15 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
   corrHelper->setNthreadsToMaximum();
   corrHelper->setNthreads(1);
 
-  auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, voxResTreeInverse, useSmoothed, invertSigns);
+  if (debugMirrorAdata2C) {
+    corrHelper->setDebugMirrorAdata2C();
+  }
+  // corrHelper->setDebugUseVoxelCenters();
+
+  o2::gpu::TPCFastSpaceChargeCorrectionMap mapDirect(0, 0), mapInverse(0, 0);
+
+  auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, voxResTreeInverse, useSmoothed, invertSigns,
+                                                      &mapDirect, &mapInverse);
 
   std::unique_ptr<o2::gpu::TPCFastTransform> fastTransform(
     helper->create(0, *corrPtr));
@@ -199,15 +208,6 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
   o2::gpu::TPCFastSpaceChargeCorrection& corr = fastTransform->getCorrection();
 
-  // the difference
-
-  double maxDiff[3] = {0., 0., 0.};
-  int32_t maxDiffSector[3] = {0, 0, 0};
-  int32_t maxDiffRow[3] = {0, 0, 0};
-
-  double sumDiff[3] = {0., 0., 0.};
-  int64_t nDiff = 0;
-
   // a debug file with some NTuples
 
   TDirectory* currDir = gDirectory;
@@ -220,46 +220,77 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
   // measured x,y,z; corrections cx,cy,cz from the measured to the real x,y,z;
   // inverse corrections ix,iy,iz at the real position (x+cx,y+cy,z+cz)
   // ideally, ix = cx, iy = cy, iz = cz
-  TNtuple* debugCorr = new TNtuple("corr", "corr", "iSector:iRow:x:y:z:cx:cy:cz:ix:iy:iz");
+  TNtuple* ntAll = new TNtuple("all", "all",
+                               debugMirrorAdata2C ? "sec:row:x:y:z:cx:cy:cz:ix:iy:iz:cxC:cyC:czC:ixC:iyC:izC"
+                                                  : "sec:row:x:y:z:cx:cy:cz:ix:iy:iz");
 
-  debugCorr->SetMarkerStyle(8);
-  debugCorr->SetMarkerSize(0.1);
-  debugCorr->SetMarkerColor(kBlack);
+  ntAll->SetMarkerStyle(8);
+  ntAll->SetMarkerSize(0.1);
+  ntAll->SetMarkerColor(kBlack);
 
-  // ntuple with the input data: voxels and corrections
   debugFile->cd();
-  TNtuple* debugVox =
-    new TNtuple("vox", "vox", "iSector:iRow:n:x:y:z:vx:vy:vz");
+  TNtuple* ntInvAll = new TNtuple("invall", "invall",
+                                  debugMirrorAdata2C ? "sec:row:x:y:z:cx:cy:cz:cxC:cyC:czC"
+                                                     : "sec:row:x:y:z:cx:cy:cz");
 
-  debugVox->SetMarkerStyle(8);
-  debugVox->SetMarkerSize(0.8);
-  debugVox->SetMarkerColor(kBlue);
+  ntInvAll->SetMarkerStyle(8);
+  ntInvAll->SetMarkerSize(0.1);
+  ntInvAll->SetMarkerColor(kBlack);
 
   // duplicate of debugVox + the spline data at voxels in a different color
   debugFile->cd();
-  TNtuple* debugCorrVox =
-    new TNtuple("corrvox", "corrvox", "iSector:iRow:n:x:y:z:vx:vy:vz:cx:cy:cz:ix:iy:iz");
+  TNtuple* ntVox =
+    new TNtuple("vox", "vox",
+                debugMirrorAdata2C ? "sec:row:n:x:y:z:vx:vy:vz:cx:cy:cz:ix:iy:iz:cxC:cyC:czC:ixC:iyC:izC"
+                                   : "sec:row:n:x:y:z:vx:vy:vz:cx:cy:cz:ix:iy:iz");
 
-  debugCorrVox->SetMarkerStyle(8);
-  debugCorrVox->SetMarkerSize(0.8);
-  debugCorrVox->SetMarkerColor(kMagenta);
+  ntVox->SetMarkerStyle(8);
+  ntVox->SetMarkerSize(0.8);
+  ntVox->SetMarkerColor(kMagenta);
+
+  // duplicate of debugVox + the spline data at voxels in a different color
+  debugFile->cd();
+  TNtuple* ntInvVox =
+    new TNtuple("invvox", "invvox",
+                debugMirrorAdata2C ? "sec:row:n:x:y:z:vx:vy:vz:cx:cy:cz:cxC:cyC:czC"
+                                   : "sec:row:n:x:y:z:vx:vy:vz:cx:cy:cz");
+
+  ntInvVox->SetMarkerStyle(8);
+  ntInvVox->SetMarkerSize(0.8);
+  ntInvVox->SetMarkerColor(kMagenta);
+
+  // corrections at the spline grid points
+  debugFile->cd();
+  TNtuple* ntGrid = new TNtuple("grid", "grid", "sec:row:x:y:z:cx:cy:cz:ix:iy:iz");
+
+  ntGrid->SetMarkerStyle(8);
+  ntGrid->SetMarkerSize(1.2);
+  ntGrid->SetMarkerColor(kBlack);
 
   // corrections at the spline grid points
   debugFile->cd();
-  TNtuple* debugGrid = new TNtuple("grid", "grid", "iSector:iRow:x:y:z:cx:cy:cz:ix:iy:iz");
+  TNtuple* ntInvGrid = new TNtuple("invgrid", "invgrid", "sec:row:x:y:z:cx:cy:cz");
 
-  debugGrid->SetMarkerStyle(8);
-  debugGrid->SetMarkerSize(1.2);
-  debugGrid->SetMarkerColor(kBlack);
+  ntInvGrid->SetMarkerStyle(8);
+  ntInvGrid->SetMarkerSize(1.2);
+  ntGrid->SetMarkerColor(kBlack);
 
   // ntuple with data points created from voxels (with the data smearing, extension to the edges etc.)
   debugFile->cd();
-  TNtuple* debugPoints =
-    new TNtuple("points", "points", "iSector:iRow:x:y:z:px:py:pz:cx:cy:cz");
+  TNtuple* ntFitPoints =
+    new TNtuple("fitpoints", "fit points", "sec:row:x:y:z:px:py:pz:cx:cy:cz");
 
-  debugPoints->SetMarkerStyle(8);
-  debugPoints->SetMarkerSize(0.4);
-  debugPoints->SetMarkerColor(kRed);
+  ntFitPoints->SetMarkerStyle(8);
+  ntFitPoints->SetMarkerSize(0.4);
+  ntFitPoints->SetMarkerColor(kRed);
+
+  debugFile->cd();
+  TNtuple* ntInvFitPoints =
+    new TNtuple("invfitpoints", "fit points", "sec:row:x:y:z:px:py:pz:cx:cy:cz");
+
+  ntInvFitPoints->SetMarkerStyle(8);
+  ntInvFitPoints->SetMarkerSize(0.4);
+  ntInvFitPoints->SetMarkerColor(kRed);
 
   currDir->cd();
 
@@ -269,224 +300,318 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
   const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
+  auto getInvCorrections = [&](int iSector, int iRow, float realY, float realZ, float& ix, float& iy, float& iz) {
+    // get the inverse corrections ix, iy, iz at x,y,z
+    ix = corr.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);
+    std::tie(iy, iz) = corr.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ);
+  };
+
   auto getAllCorrections = [&](int iSector, int iRow, float y, float z, float& cx, float& cy, float& cz, float& ix, float& iy, float& iz) {
     // get the corrections cx,cy,cz at x,y,z
     std::tie(cx, cy, cz) = corr.getCorrectionLocal(iSector, iRow, y, z);
-    float realY = y + cy;
-    float realZ = z + cz;
-    ix = corr.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);
-    std::tie(iy, iz) = corr.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ);
+    getInvCorrections(iSector, iRow, y + cy, z + cz, ix, iy, iz);
   };
 
-  o2::tpc::TrackResiduals::VoxRes* v = nullptr;
-  TBranch* branch = voxResTree->GetBranch("voxRes");
-  branch->SetAddress(&v);
-  branch->SetAutoDelete(kTRUE);
+  for (int direction = 0; direction < 2; direction++) { // 0 - normal, 1 - inverse
+
+    TTree* currentTree = (direction == 0) ? voxResTree : voxResTreeInverse;
+    if (!currentTree) {
+      std::cout << "tree voxResTree does not exist!" << std::endl;
+      return;
+    }
 
-  int32_t iSectorLast = -1;
-  int32_t iRowLast = -1;
+    o2::tpc::TrackResiduals::VoxRes* v = nullptr;
+    TBranch* branch = currentTree->GetBranch("voxRes");
+    branch->SetAddress(&v);
+    branch->SetAutoDelete(kTRUE);
 
-  std::cout << "fill debug ntuples at voxels ..." << std::endl;
+    int32_t iSectorLast = -1;
+    int32_t iRowLast = -1;
 
-  for (int32_t iVox = 0; iVox < voxResTree->GetEntriesFast(); iVox++) {
+    // the difference
 
-    voxResTree->GetEntry(iVox);
+    double maxDiff[3] = {0., 0., 0.};
+    int32_t maxDiffSector[3] = {0, 0, 0};
+    int32_t maxDiffRow[3] = {0, 0, 0};
 
-    float voxEntries = v->stat[o2::tpc::TrackResiduals::VoxV];
+    double sumDiff[3] = {0., 0., 0.};
+    int64_t nDiff = 0;
 
-    int32_t xBin =
-      v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
+    std::cout << "fill debug ntuples at voxels ..." << std::endl;
 
-    int32_t y2xBin =
-      v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
+    for (int32_t iVox = 0; iVox < currentTree->GetEntriesFast(); iVox++) {
 
-    int32_t z2xBin =
-      v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
+      currentTree->GetEntry(iVox);
 
-    int32_t iSector = (int32_t)v->bsec;
-    int32_t iRow = (int32_t)xBin;
+      float voxEntries = v->stat[o2::tpc::TrackResiduals::VoxV];
 
-    iSectorLast = iSector;
-    iRowLast = iRow;
+      int32_t xBin =
+        v->bvox[o2::tpc::TrackResiduals::VoxX]; // bin number in x (= pad row)
 
-    double x = trackResiduals.getX(xBin); // radius of the pad row
+      int32_t y2xBin =
+        v->bvox[o2::tpc::TrackResiduals::VoxF]; // bin number in y/x 0..14
 
-    double y2x = trackResiduals.getY2X(
-      xBin, y2xBin); // y/x coordinate of the bin ~-0.15 ... 0.15
+      int32_t z2xBin =
+        v->bvox[o2::tpc::TrackResiduals::VoxZ]; // bin number in z/x 0..4
 
-    double z2x =
-      trackResiduals.getZ2X(z2xBin); // z/x coordinate of the bin 0.1 .. 0.9
+      int32_t iSector = (int32_t)v->bsec;
+      int32_t iRow = (int32_t)xBin;
 
-    double y = x * y2x;
-    double z = x * z2x;
+      iSectorLast = iSector;
+      iRowLast = iRow;
 
-    if (iSector >= geo.getNumberOfSectorsA()) {
-      z = -z;
-    }
+      double x = trackResiduals.getX(xBin); // radius of the pad row
 
-    double correctionX = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
-    double correctionY = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
-    double correctionZ = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
+      double y2x = trackResiduals.getY2X(
+        xBin, y2xBin); // y/x coordinate of the bin ~-0.15 ... 0.15
 
-    if (invertSigns) {
-      correctionX *= -1.;
-      correctionY *= -1.;
-      correctionZ *= -1.;
-    }
+      double z2x =
+        trackResiduals.getZ2X(z2xBin); // z/x coordinate of the bin 0.1 .. 0.9
 
-    if (voxEntries > 0.) { // use mean statistical positions instead of the bin centers:
-      y = x * v->stat[o2::tpc::TrackResiduals::VoxF];
-      z = x * v->stat[o2::tpc::TrackResiduals::VoxZ];
-    }
+      double y = x * y2x;
+      double z = x * z2x;
+
+      double correctionX = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResX] : v->D[o2::tpc::TrackResiduals::ResX];
+      double correctionY = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResY] : v->D[o2::tpc::TrackResiduals::ResY];
+      double correctionZ = useSmoothed ? v->DS[o2::tpc::TrackResiduals::ResZ] : v->D[o2::tpc::TrackResiduals::ResZ];
+
+      double voxelSizeY = x / trackResiduals.getDY2XI(xBin, y2xBin);
+      double voxelSizeZ = x * trackResiduals.getDZ2X(z2xBin);
+
+      if (invertSigns) {
+        correctionX *= -1.;
+        correctionY *= -1.;
+        correctionZ *= -1.;
+      }
 
-    float cx, cy, cz, ix, iy, iz;
-    getAllCorrections(iSector, iRow, y, z, cx, cy, cz, ix, iy, iz);
+      if (!corrHelper->isDebugUseVoxelCenters()) {
+        if (voxEntries > 0.) {
+          // use mean statistical positions instead of the bin centers, unless they are wrong
+          double yFit = x * v->stat[o2::tpc::TrackResiduals::VoxF];
+          if (fabs(yFit - y) <= corrHelper->getVoxelMeanValidityRange() * voxelSizeY / 2.) {
+            y = yFit;
+          }
+          double zFit = x * v->stat[o2::tpc::TrackResiduals::VoxZ];
+          if (fabs(zFit - z) <= corrHelper->getVoxelMeanValidityRange() * voxelSizeZ / 2.) {
+            z = zFit;
+          }
+        }
+      }
 
-    if (voxEntries >= 1.) {
-      double d[3] = {cx - correctionX, cy - correctionY, cz - correctionZ};
+      int mirrorSector = iSector + geo.getNumberOfSectorsA();
 
-      for (int32_t i = 0; i < 3; i++) {
-        if (fabs(maxDiff[i]) < fabs(d[i])) {
-          maxDiff[i] = d[i];
-          maxDiffSector[i] = iSector;
-          maxDiffRow[i] = iRow;
-          // std::cout << " sector " << iSector << " row " << iRow << " xyz " << i
-          //  << " diff " << d[i] << " entries " << voxEntries << " y " << y2xBin << " z " << z2xBin << std::endl;
+      if (iSector >= geo.getNumberOfSectorsA()) {
+        z = -z;
+        mirrorSector = iSector - geo.getNumberOfSectorsA();
+      }
+
+      float cx{0.f}, cy{0.f}, cz{0.f}, ix{0.f}, iy{0.f}, iz{0.f};
+      float cxC{0.f}, cyC{0.f}, czC{0.f}, ixC{0.f}, iyC{0.f}, izC{0.f};
+      if (direction == 0) {
+        getAllCorrections(iSector, iRow, y, z, cx, cy, cz, ix, iy, iz);
+        if (debugMirrorAdata2C) {
+          getAllCorrections(mirrorSector, iRow, y, -z, cxC, cyC, czC, ixC, iyC, izC);
         }
-        sumDiff[i] += d[i] * d[i];
+        float ntEntry[] = {(float)iSector, (float)iRow, voxEntries,
+                           (float)x, (float)y, (float)z,
+                           (float)correctionX, (float)correctionY, (float)correctionZ,
+                           (float)cx, (float)cy, (float)cz,
+                           (float)ix, (float)iy, (float)iz,
+                           (float)cxC, (float)cyC, (float)czC, (float)ixC, (float)iyC, (float)izC};
+
+        // fill the ntuple with the correction at the voxel
+        ntVox->Fill(ntEntry);
+      } else {
+        getInvCorrections(iSector, iRow, y, z, cx, cy, cz);
+        if (debugMirrorAdata2C) {
+          getInvCorrections(mirrorSector, iRow, y, -z, cxC, cyC, czC);
+        }
+        float ntEntry[] = {(float)iSector, (float)iRow, voxEntries,
+                           (float)x, (float)y, (float)z,
+                           (float)correctionX, (float)correctionY, (float)correctionZ,
+                           (float)cx, (float)cy, (float)cz,
+                           (float)cxC, (float)cyC, (float)czC};
+        // fill the ntuple with the correction at the voxel
+        ntInvVox->Fill(ntEntry);
+      }
+
+      if (voxEntries >= 1.) {
+        double d[3] = {cx - correctionX, cy - correctionY, cz - correctionZ};
+
+        for (int32_t i = 0; i < 3; i++) {
+          if (fabs(maxDiff[i]) < fabs(d[i])) {
+            maxDiff[i] = d[i];
+            maxDiffSector[i] = iSector;
+            maxDiffRow[i] = iRow;
+            // std::cout << " sector " << iSector << " row " << iRow << " xyz " << i
+            //  << " diff " << d[i] << " entries " << voxEntries << " y " << y2xBin << " z " << z2xBin << std::endl;
+          }
+          sumDiff[i] += d[i] * d[i];
+        }
+        nDiff++;
       }
-      nDiff++;
     }
 
-    debugVox->Fill(iSector, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ);
+    std::cout
+      << "fill debug ntuples everywhere .." << std::endl;
 
-    debugCorrVox->Fill(iSector, iRow, voxEntries, x, y, z, correctionX, correctionY, correctionZ,
-                       cx, cy, cz, ix, iy, iz);
-  }
+    for (int32_t iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
+      // for (int32_t iSector = 0; iSector < 1; iSector++) {
+      std::cout << "debug ntules for sector " << iSector << std::endl;
 
-  std::cout
-    << "fill debug ntuples everywhere .." << std::endl;
+      int mirrorSector = (iSector >= geo.getNumberOfSectorsA()) ? iSector - geo.getNumberOfSectorsA() : iSector + geo.getNumberOfSectorsA();
 
-  for (int32_t iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
-    // for (int32_t iSector = 0; iSector < 1; iSector++) {
-    std::cout << "debug ntules for sector " << iSector << std::endl;
-    for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
+      for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
 
-      double x = geo.getRowInfo(iRow).x;
+        double x = geo.getRowInfo(iRow).x;
 
-      // the spline grid
+        // the spline grid
 
-      const auto& gridY = corr.getSpline(iSector, iRow).getGridX1();
-      const auto& gridZ = corr.getSpline(iSector, iRow).getGridX2();
-      if (iSector == 0 && iRow == 0) {
-        std::cout << "spline scenario " << corr.getSectorRowInfo(iSector, iRow).splineScenarioID << std::endl;
-        std::cout << "spline grid Y: u = " << 0 << ".." << gridY.getUmax() << ", x = " << gridY.getXmin() << ".." << gridY.getXmax() << std::endl;
-        std::cout << "spline grid Z: u = " << 0 << ".." << gridZ.getUmax() << ", x = " << gridZ.getXmin() << ".." << gridZ.getXmax() << std::endl;
-      }
+        const auto& gridY = corr.getSpline(iSector, iRow).getGridX1();
+        const auto& gridZ = corr.getSpline(iSector, iRow).getGridX2();
+        if (iSector == 0 && iRow == 0) {
+          std::cout << "spline scenario " << corr.getSectorRowInfo(iSector, iRow).splineScenarioID << std::endl;
+          std::cout << "spline grid Y: u = " << 0 << ".." << gridY.getUmax() << ", x = " << gridY.getXmin() << ".." << gridY.getXmax() << std::endl;
+          std::cout << "spline grid Z: u = " << 0 << ".." << gridZ.getUmax() << ", x = " << gridZ.getXmin() << ".." << gridZ.getXmax() << std::endl;
+        }
 
-      // the correction
-      {
-        std::vector<double> points[2], knots[2];
+        // the correction
+        {
+          std::vector<double> points[2], knots[2];
 
-        auto [yMin, yMax] = geo.getRowInfo(iRow).getYrange();
-        auto [zMin, zMax] = geo.getZrange(iSector);
+          auto [yMin, yMax] = geo.getRowInfo(iRow).getYrange();
+          auto [zMin, zMax] = geo.getZrange(iSector);
 
-        points[0].push_back(yMin);
-        points[0].push_back(yMax);
-        points[1].push_back(zMin);
-        points[1].push_back(zMax);
+          points[0].push_back(yMin);
+          points[0].push_back(yMax);
+          points[1].push_back(zMin);
+          points[1].push_back(zMax);
 
-        for (int32_t iu = 0; iu < gridY.getNumberOfKnots(); iu++) {
-          auto [y, z] = corr.convGridToLocal(iSector, iRow, gridY.getKnot(iu).getU(), 0.);
-          knots[0].push_back(y);
-          points[0].push_back(y);
-        }
-        for (int32_t iv = 0; iv < gridZ.getNumberOfKnots(); iv++) {
-          auto [y, z] = corr.convGridToLocal(iSector, iRow, 0., gridZ.getKnot(iv).getU());
-          knots[1].push_back(z);
-          points[1].push_back(z);
-        }
+          for (int32_t iu = 0; iu < gridY.getNumberOfKnots(); iu++) {
+            auto [y, z] = corr.convGridToLocal(iSector, iRow, gridY.getKnot(iu).getU(), 0.);
+            knots[0].push_back(y);
+            points[0].push_back(y);
+          }
+          for (int32_t iv = 0; iv < gridZ.getNumberOfKnots(); iv++) {
+            auto [y, z] = corr.convGridToLocal(iSector, iRow, 0., gridZ.getKnot(iv).getU());
+            knots[1].push_back(z);
+            points[1].push_back(z);
+          }
 
-        for (int32_t iyz = 0; iyz <= 1; iyz++) {
-          std::sort(knots[iyz].begin(), knots[iyz].end());
-          std::sort(points[iyz].begin(), points[iyz].end());
-          int32_t n = points[iyz].size();
-          for (int32_t i = 0; i < n - 1; i++) {
-            double d = (points[iyz][i + 1] - points[iyz][i]) / 10.;
-            for (int32_t ii = 1; ii < 10; ii++) {
-              points[iyz].push_back(points[iyz][i] + d * ii);
+          for (int32_t iyz = 0; iyz <= 1; iyz++) {
+            std::sort(knots[iyz].begin(), knots[iyz].end());
+            std::sort(points[iyz].begin(), points[iyz].end());
+            int32_t n = points[iyz].size();
+            for (int32_t i = 0; i < n - 1; i++) {
+              double d = (points[iyz][i + 1] - points[iyz][i]) / 10.;
+              for (int32_t ii = 1; ii < 10; ii++) {
+                points[iyz].push_back(points[iyz][i] + d * ii);
+              }
             }
+            std::sort(points[iyz].begin(), points[iyz].end());
           }
-          std::sort(points[iyz].begin(), points[iyz].end());
-        }
 
-        for (int32_t iter = 0; iter < 2; iter++) {
-          std::vector<double>& py = ((iter == 0) ? knots[0] : points[0]);
-          std::vector<double>& pz = ((iter == 0) ? knots[1] : points[1]);
-          for (uint32_t iu = 0; iu < py.size(); iu++) {
-            for (uint32_t iv = 0; iv < pz.size(); iv++) {
-              float y = py[iu];
-              float z = pz[iv];
-              float cx, cy, cz, ix, iy, iz;
-              getAllCorrections(iSector, iRow, y, z, cx, cy, cz, ix, iy, iz);
-              if (iter == 0) {
-                debugGrid->Fill(iSector, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
-              } else {
-                debugCorr->Fill(iSector, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
+          for (int32_t iter = 0; iter < 2; iter++) {
+            std::vector<double>& py = ((iter == 0) ? knots[0] : points[0]);
+            std::vector<double>& pz = ((iter == 0) ? knots[1] : points[1]);
+            for (uint32_t iu = 0; iu < py.size(); iu++) {
+              for (uint32_t iv = 0; iv < pz.size(); iv++) {
+                float y = py[iu];
+                float z = pz[iv];
+                float cx{0}, cy{0}, cz{0}, ix{0}, iy{0}, iz{0};
+                float cxC{0}, cyC{0}, czC{0}, ixC{0}, iyC{0}, izC{0};
+                if (direction == 0) {
+                  getAllCorrections(iSector, iRow, y, z, cx, cy, cz, ix, iy, iz);
+                  if (debugMirrorAdata2C) {
+                    getAllCorrections(mirrorSector, iRow, y, -z, cxC, cyC, czC, ixC, iyC, izC);
+                  }
+                  if (iter == 0) {
+                    ntGrid->Fill(iSector, iRow, x, y, z, cx, cy, cz, ix, iy, iz);
+                  } else {
+                    float ntEntry[] = {(float)iSector, (float)iRow, (float)x, y, z,
+                                       cx, cy, cz, ix, iy, iz,
+                                       cxC, cyC, czC, ixC, iyC, izC};
+                    ntAll->Fill(ntEntry);
+                  }
+                } else {
+                  getInvCorrections(iSector, iRow, y, z, cx, cy, cz);
+                  if (debugMirrorAdata2C) {
+                    getInvCorrections(mirrorSector, iRow, y, -z, cxC, cyC, czC);
+                  }
+                  if (iter == 0) {
+                    ntInvGrid->Fill(iSector, iRow, x, y, z, cx, cy, cz);
+                  } else {
+                    float ntEntry[] = {(float)iSector, (float)iRow, (float)x, y, z,
+                                       cx, cy, cz,
+                                       cxC, cyC, czC};
+                    ntInvAll->Fill(ntEntry);
+                  }
+                }
               }
             }
           }
         }
-      }
-
-      // the data points used in spline fit
-      // (they are kept in
-      // TPCFastTransformHelperO2::instance()->getCorrectionMap() )
-
-      o2::gpu::TPCFastSpaceChargeCorrectionMap& map =
-        corrHelper->getCorrectionMap();
-      auto& points = map.getPoints(iSector, iRow);
 
-      for (uint32_t ip = 0; ip < points.size(); ip++) {
-        auto point = points[ip];
-        float y = point.mY;
-        float z = point.mZ;
-        float correctionX = point.mDx;
-        float correctionY = point.mDy;
-        float correctionZ = point.mDz;
-
-        auto [cx, cy, cz] =
-          corr.getCorrectionLocal(iSector, iRow, y, z);
-
-        debugPoints->Fill(iSector, iRow, x, y, z, correctionX, correctionY,
-                          correctionZ, cx, cy, cz);
+        // the data points used in spline fit
+        // (they are kept in
+        // TPCFastTransformHelperO2::instance()->getCorrectionMap() )
+
+        o2::gpu::TPCFastSpaceChargeCorrectionMap& map = (direction == 0 ? mapDirect : mapInverse);
+
+        auto& points = map.getPoints(iSector, iRow);
+
+        for (uint32_t ip = 0; ip < points.size(); ip++) {
+          auto point = points[ip];
+          float y = point.mY;
+          float z = point.mZ;
+          float correctionX = point.mDx;
+          float correctionY = point.mDy;
+          float correctionZ = point.mDz;
+          if (direction == 0) {
+            auto [cx, cy, cz] =
+              corr.getCorrectionLocal(iSector, iRow, y, z);
+            ntFitPoints->Fill(iSector, iRow, x, y, z, correctionX, correctionY,
+                              correctionZ, cx, cy, cz);
+          } else {
+            float cx =
+              corr.getCorrectionXatRealYZ(iSector, iRow, y, z);
+            auto [cy, cz] =
+              corr.getCorrectionYZatRealYZ(iSector, iRow, y, z);
+            ntInvFitPoints->Fill(iSector, iRow, x, y, z, correctionX, correctionY,
+                                 correctionZ, cx, cy, cz);
+          }
+        }
       }
     }
-  }
 
-  for (int32_t i = 0; i < 3; i++) {
-    sumDiff[i] = sqrt(sumDiff[i]) / nDiff;
-  }
+    for (int32_t i = 0; i < 3; i++) {
+      sumDiff[i] = sqrt(sumDiff[i]) / nDiff;
+    }
 
-  std::cout << "Max difference in x :  " << maxDiff[0] << " at Sector "
-            << maxDiffSector[0] << " row " << maxDiffRow[0] << std::endl;
+    std::cout << "Max difference in x :  " << maxDiff[0] << " at Sector "
+              << maxDiffSector[0] << " row " << maxDiffRow[0] << std::endl;
 
-  std::cout << "Max difference in y :  " << maxDiff[1] << " at Sector "
-            << maxDiffSector[1] << " row " << maxDiffRow[1] << std::endl;
+    std::cout << "Max difference in y :  " << maxDiff[1] << " at Sector "
+              << maxDiffSector[1] << " row " << maxDiffRow[1] << std::endl;
 
-  std::cout << "Max difference in z :  " << maxDiff[2] << " at Sector "
-            << maxDiffSector[2] << " row " << maxDiffRow[2] << std::endl;
+    std::cout << "Max difference in z :  " << maxDiff[2] << " at Sector "
+              << maxDiffSector[2] << " row " << maxDiffRow[2] << std::endl;
 
-  std::cout << "Mean difference in x,y,z : " << sumDiff[0] << " " << sumDiff[1]
-            << " " << sumDiff[2] << std::endl;
+    std::cout << "Mean difference in x,y,z : " << sumDiff[0] << " " << sumDiff[1]
+              << " " << sumDiff[2] << std::endl;
+  } // direction
 
   corr.testInverse(true);
 
   debugFile->cd();
-  debugCorr->Write();
-  debugVox->Write();
-  debugCorrVox->Write();
-  debugGrid->Write();
-  debugPoints->Write();
+  ntAll->Write();
+  ntVox->Write();
+  ntGrid->Write();
+  ntFitPoints->Write();
+  ntInvAll->Write();
+  ntInvVox->Write();
+  ntInvGrid->Write();
+  ntInvFitPoints->Write();
+
   debugFile->Close();
 }

From 954b28c2823ac6017a38e5e7489f792585e04d14 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <se.gorbunov@gsi.de>
Date: Wed, 27 Aug 2025 17:04:52 +0000
Subject: [PATCH 1575/1764] TPC Splines: replace std::tuple by std::array

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    |  8 +--
 GPU/TPCFastTransformation/Spline1DSpec.h      |  8 +--
 GPU/TPCFastTransformation/Spline2DSpec.cxx    |  2 -
 .../TPCFastSpaceChargeCorrection.h            | 44 ++++++++---------
 GPU/TPCFastTransformation/TPCFastTransform.h  | 49 +++++++++++++------
 .../TPCFastTransformGeo.h                     | 15 +++---
 .../macro/TPCFastTransformInit.C              |  9 +++-
 7 files changed, 78 insertions(+), 57 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 6122c5717fcbb..9232598e6a35e 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -668,22 +668,22 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
                   // correct the mean position if it is outside the voxel
                   std::stringstream msg;
                   if (fabs(x - data.mX) > mVoxelMeanValidityRange * dx / 2.) {
-                    msg << "\n     x: center " << x << " dx " << data.mX - x << " half bin size: " << dx / 2;
+                    msg << "\n         x: center " << x << " dx " << data.mX - x << " half bin size " << dx / 2;
                   }
 
                   if (fabs(vox.mY - data.mY) > mVoxelMeanValidityRange * vox.mDy / 2.) {
-                    msg << "\n     y: center " << vox.mY << " dy " << data.mY - vox.mY << " half bin size: " << vox.mDy / 2;
+                    msg << "\n         y: center " << vox.mY << " dy " << data.mY - vox.mY << " half bin size " << vox.mDy / 2;
                     data.mY = vox.mY;
                   }
 
                   if (fabs(vox.mZ - data.mZ) > mVoxelMeanValidityRange * vox.mDz / 2.) {
-                    msg << "\n     z: center " << vox.mZ << " dz " << data.mZ - vox.mZ << " half bin size: " << vox.mDz / 2;
+                    msg << "\n         z: center " << vox.mZ << " dz " << data.mZ - vox.mZ << " half bin size " << vox.mDz / 2;
                     data.mZ = vox.mZ;
                   }
 
                   if (!msg.str().empty()) {
                     LOG(warning) << directionName << " correction: fitted voxel position is outside the voxel: "
-                                 << " sector " << iSector << " row " << iRow << " bin: " << iy << " " << iz
+                                 << " sector " << iSector << " row " << iRow << " bin y " << iy << " bin z " << iz
                                  << msg.str();
                   }
 
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 1c591a957847d..28be5dd20e235 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -342,7 +342,7 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
   }
 
   template <typename T>
-  GPUd() std::tuple<T, T, T, T> getSderivativesOverParsAtU(const Knot& knotL, DataT u) const
+  GPUd() std::array<T, 4> getSderivativesOverParsAtU(const Knot& knotL, DataT u) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline parameters Sl(eft), Sr(ight) and the slopes Dl, Dr
@@ -364,11 +364,11 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     T dSdDl = vm1 * a;
     T dSdDr = v * a;
     // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
-    return std::make_tuple(dSdSl, dSdDl, dSdSr, dSdDr);
+    return {dSdSl, dSdDl, dSdSr, dSdDr};
   }
 
   template <typename T>
-  GPUd() std::tuple<T, T, T, T, T, T, T, T> getSDderivativesOverParsAtU(const Knot& knotL, DataT u) const
+  GPUd() std::array<T, 8> getSDderivativesOverParsAtU(const Knot& knotL, DataT u) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline values Sl, Sr and the slopes Dl, Dr
@@ -397,7 +397,7 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     T dDdDr = v * (v + vm1 + vm1);
     // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
     // D(u) = dS(u)/du = dDdSl * Sl + dDdSr * Sr + dDdDl * Dl + dDdDr * Dr;
-    return std::make_tuple(dSdSl, dSdDl, dSdSr, dSdDr, dDdSl, dDdDl, dDdSr, dDdDr);
+    return {dSdSl, dSdDl, dSdSr, dSdDr, dDdSl, dDdDl, dDdSr, dDdDr};
   }
 
   using TBase::convXtoU;
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.cxx b/GPU/TPCFastTransformation/Spline2DSpec.cxx
index 055530b9314c2..4fbd4dc3d0110 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline2DSpec.cxx
@@ -29,8 +29,6 @@
 #include "Riostream.h"
 #include "TMath.h"
 #include "Spline2DHelper.h"
-#include "TCanvas.h"
-#include "TNtuple.h"
 #include "TFile.h"
 #include "GPUCommonMath.h"
 
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 7112a04b364c6..4ca5b74025743 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -78,13 +78,13 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     }
 
     /// convert local y, z to internal grid coordinates u,v, and spline scale
-    std::tuple<float, float, float> convLocalToGridUntruncated(float y, float z) const
+    std::array<float, 3> convLocalToGridUntruncated(float y, float z) const
     {
       return {(y - y0) * yScale, (z - z0) * zScale, getSpineScaleForZ(z)};
     }
 
     /// convert internal grid coordinates u,v to local y, z
-    std::tuple<float, float> convGridToLocal(float gridU, float gridV) const
+    std::array<float, 2> convGridToLocal(float gridU, float gridV) const
     {
       return {y0 + gridU / yScale, z0 + gridV / zScale};
     }
@@ -123,22 +123,22 @@ class TPCFastSpaceChargeCorrection : public FlatObject
       maxCorr[2] = GPUCommonMath::Max(maxCorr[2], dv);
     }
 
-    void updateMaxValues(std::tuple<float, float, float> dxdudv, float scale)
+    void updateMaxValues(std::array<float, 3> dxdudv, float scale)
     {
-      float dx = std::get<0>(dxdudv) * scale;
-      float du = std::get<1>(dxdudv) * scale;
-      float dv = std::get<2>(dxdudv) * scale;
+      float dx = dxdudv[0] * scale;
+      float du = dxdudv[1] * scale;
+      float dv = dxdudv[2] * scale;
       updateMaxValues(dx, du, dv);
     }
 
-    std::tuple<float, float, float> getMaxValues() const
+    std::array<float, 3> getMaxValues() const
     {
-      return std::make_tuple(maxCorr[0], maxCorr[1], maxCorr[2]);
+      return {maxCorr[0], maxCorr[1], maxCorr[2]};
     }
 
-    std::tuple<float, float, float> getMinValues() const
+    std::array<float, 3> getMinValues() const
     {
-      return std::make_tuple(minCorr[0], minCorr[1], minCorr[2]);
+      return {minCorr[0], minCorr[1], minCorr[2]};
     }
 
     ClassDefNV(SectorRowInfo, 2);
@@ -259,31 +259,31 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   ///
   // GPUd() int32_t getCorrectionInternal(int32_t sector, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
 
-  GPUdi() std::tuple<float, float, float> getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const;
+  GPUdi() std::array<float, 3> getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const;
 
   /// inverse correction: Real Y and Z -> Real X
   GPUd() float getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
 
   /// inverse correction: Real Y and Z -> measred Y and Z
-  GPUd() std::tuple<float, float> getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
+  GPUd() std::array<float, 2> getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
 
   /// _______________  Utilities  _______________________________________________
 
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
-  GPUd() std::tuple<float, float, float> convLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
+  GPUd() std::array<float, 3> convLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
 
   /// convert internal grid coordinates u,v to local y, z
   /// return values: y, z, scaling factor
-  GPUd() std::tuple<float, float> convGridToLocal(int32_t sector, int32_t row, float u, float v) const;
+  GPUd() std::array<float, 2> convGridToLocal(int32_t sector, int32_t row, float u, float v) const;
 
   /// convert real Y, Z to the internal grid coordinates
   /// return values: u, v, scaling factor
-  GPUd() std::tuple<float, float, float> convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
+  GPUd() std::array<float, 3> convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
 
   /// convert internal grid coordinates to the real Y, Z
   /// return values: y, z
-  GPUd() std::tuple<float, float> convGridToRealLocal(int32_t sector, int32_t row, float u, float v) const;
+  GPUd() std::array<float, 2> convGridToRealLocal(int32_t sector, int32_t row, float u, float v) const;
 
   GPUd() bool isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
   GPUd() bool isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
@@ -453,7 +453,7 @@ GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineDataInvYZ(int32_t se
   return getSplineData(sector, row, 2);
 }
 
-GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32_t row, float y, float z) const
+GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
@@ -491,13 +491,13 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isRealLocalInsideGrid(int32_t sector,
   return true;
 }
 
-GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV) const
+GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV) const
 {
   /// convert internal grid coordinates u,v to local y, z
   return getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(gridU, gridV);
 }
 
-GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const
+GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// convert real y, z to the internal grid coordinates + scale
   const SplineType& spline = getSpline(sector, row);
@@ -508,13 +508,13 @@ GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::convRealLo
   return {gridU, gridV, scale};
 }
 
-GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV) const
+GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV) const
 {
   /// convert internal grid coordinates u,v to the real y, z
   return getSectorRowInfo(sector, row).gridReal.convGridToLocal(gridU, gridV);
 }
 
-GPUdi() std::tuple<float, float, float> TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const
+GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const
 {
   const auto& info = getSectorRowInfo(sector, row);
   const SplineType& spline = getSpline(sector, row);
@@ -541,7 +541,7 @@ GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t secto
   return dx;
 }
 
-GPUdi() std::tuple<float, float> TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
+GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
   auto [gridU, gridV, scale] = convRealLocalToGrid(sector, row, realY, realZ);
   const auto& info = getSectorRowInfo(sector, row);
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 3b08296525fc7..35b94446ce088 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -349,13 +349,17 @@ class TPCFastTransform : public FlatObject
 GPUdi() void TPCFastTransform::convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const
 {
   float l = (time - mT0 - vertexTime) * mVdrift; // drift length [cm]
-  std::tie(y, z) = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
+  const auto local = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
+  y = local[0];
+  z = local[1];
 }
 
 GPUdi() void TPCFastTransform::convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const
 {
   float l = getGeometry().getTPCzLength() + (time - mT0 - maxTimeBin) * mVdrift; // drift length [cm]
-  std::tie(y, z) = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
+  const auto local = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
+  y = local[0];
+  z = local[1];
 }
 
 // ----------------------------------------------------------------------
@@ -387,16 +391,16 @@ GPUdi() float TPCFastTransform::convDriftLengthToTime(float driftLength, float v
 
 GPUdi() void TPCFastTransform::convLocalToPadTime(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float vertexTime) const
 {
-  float l;
-  std::tie(pad, l) = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
-  time = convDriftLengthToTime(l, vertexTime);
+  const auto padLength = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
+  pad = padLength[0];
+  time = convDriftLengthToTime(padLength[1], vertexTime);
 }
 
 GPUdi() void TPCFastTransform::convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const
 {
-  float l;
-  std::tie(pad, l) = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
-  time = convDriftLengthToTime(l, maxTimeBin);
+  const auto padLength = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
+  pad = padLength[0];
+  time = convDriftLengthToTime(padLength[1], maxTimeBin);
 }
 
 // ----------------------------------------------------------------------
@@ -422,7 +426,10 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t sector, int32_t row, float
     } else
 #endif // GPUCA_GPUCODE
     {
-      std::tie(dx, dy, dz) = mCorrection.getCorrectionLocal(sector, row, y, z);
+      const auto corrLocal = mCorrection.getCorrectionLocal(sector, row, y, z);
+      dx = corrLocal[0];
+      dy = corrLocal[1];
+      dz = corrLocal[2];
       if (ref) {
         if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
           auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
@@ -471,12 +478,18 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t sector, int32_t row, float
 
     float dxRef = 0.f, dyRef = 0.f, dzRef = 0.f;
     if (ref) {
-      std::tie(dxRef, dyRef, dzRef) = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
+      const auto corr = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
+      dxRef = corr[0];
+      dyRef = corr[1];
+      dzRef = corr[2];
     }
 
     float dxRef2 = 0.f, dyRef2 = 0.f, dzRef2 = 0.f;
     if (ref2) {
-      std::tie(dxRef2, dyRef2, dzRef2) = ref2->mCorrection.getCorrectionLocal(sector, row, y, z);
+      const auto corr = ref2->mCorrection.getCorrectionLocal(sector, row, y, z);
+      dxRef2 = corr[0];
+      dyRef2 = corr[1];
+      dzRef2 = corr[2];
     }
 
     auto [dxOrig, dyOrig, dzOrig] = mCorrection.getCorrectionLocal(sector, row, y, z);
@@ -604,7 +617,9 @@ GPUdi() void TPCFastTransform::TransformIdeal(int32_t sector, int32_t row, float
 
   x = getGeometry().getRowInfo(row).x;
   float driftLength = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  std::tie(y, z) = getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength);
+  const auto local = getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength);
+  y = local[0];
+  z = local[1];
 }
 
 GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const
@@ -711,20 +726,22 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t sector, int
   float dz = 0;
 
   if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    std::tie(dy, dz) = mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+    const auto corrYZ = mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+    dy = corrYZ[0];
+    dz = corrYZ[1];
 
     if (ref) { // scaling was requested
       if (scaleMode == 0 && scale > 0.f) {
-        auto [dyRef, dzRef] = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        const auto [dyRef, dzRef] = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
         dy = (dy - dyRef) * scale + dyRef;
         dz = (dz - dzRef) * scale + dzRef;
       } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
-        auto [dyRef, dzRef] = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        const auto [dyRef, dzRef] = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
         dy = dyRef * scale + dy;
         dz = dzRef * scale + dz;
       }
       if (ref2 && (scale2 != 0)) {
-        auto [dyRef, dzRef] = ref2->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        const auto [dyRef, dzRef] = ref2->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
         dy = dyRef * scale2 + dy;
         dz = dzRef * scale2 + dz;
       }
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 89b099ec63127..fc28bbef33602 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -18,6 +18,7 @@
 #define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTTRANSFORMGEO_H
 
 #include "GPUCommonDef.h"
+#include "GPUCommonArray.h"
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <memory>
 #include "GPUCommonRtypes.h"
@@ -55,7 +56,7 @@ class TPCFastTransformGeo
     GPUd() float getYmax() const { return -yMin; }
 
     /// get Y range
-    GPUd() std::tuple<float, float> getYrange() const { return {getYmin(), getYmax()}; }
+    GPUd() std::array<float, 2> getYrange() const { return {getYmin(), getYmax()}; }
 
     /// get width in Y
     GPUd() float getYwidth() const { return -2.f * yMin; }
@@ -125,7 +126,7 @@ class TPCFastTransformGeo
   GPUd() float getTPCzLength() const { return mTPCzLength; }
 
   /// Gives Z range for the corresponding TPC side
-  GPUd() std::tuple<float, float> getZrange(int32_t sector) const;
+  GPUd() std::array<float, 2> getZrange(int32_t sector) const;
   GPUd() float getZmin(int32_t sector) const;
   GPUd() float getZmax(int32_t sector) const;
   GPUd() float getZreadout(int32_t sector) const;
@@ -139,7 +140,7 @@ class TPCFastTransformGeo
   GPUd() void convGlobalToLocal(int32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
 
   /// convert Pad, DriftLength -> Local c.s.
-  GPUd() std::tuple<float, float> convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const;
+  GPUd() std::array<float, 2> convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const;
 
   /// convert DriftLength -> Local c.s.
   GPUd() float convDriftLengthToZ1(int32_t sector, float driftLength) const;
@@ -148,7 +149,7 @@ class TPCFastTransformGeo
   GPUd() float convZtoDriftLength1(int32_t sector, float z) const;
 
   /// convert Local c.s. -> Pad, DriftLength
-  GPUd() std::tuple<float, float> convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const;
+  GPUd() std::array<float, 2> convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const;
 
   /// Print method
   void print() const;
@@ -229,7 +230,7 @@ GPUdi() void TPCFastTransformGeo::convGlobalToLocal(int32_t sector, float gx, fl
   lz = gz;
 }
 
-GPUdi() std::tuple<float, float> TPCFastTransformGeo::convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const
+GPUdi() std::array<float, 2> TPCFastTransformGeo::convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const
 {
   /// convert Pad, DriftLength -> Local c.s.
   const RowInfo& rowInfo = getRowInfo(row);
@@ -257,7 +258,7 @@ GPUdi() float TPCFastTransformGeo::convZtoDriftLength1(int32_t sector, float z)
   return (sector < NumberOfSectorsA) ? (mTPCzLength - z) : (z + mTPCzLength);
 }
 
-GPUdi() std::tuple<float, float> TPCFastTransformGeo::getZrange(int32_t sector) const
+GPUdi() std::array<float, 2> TPCFastTransformGeo::getZrange(int32_t sector) const
 {
   /// z range for the sector
   if (sector < NumberOfSectorsA) { // TPC side A
@@ -297,7 +298,7 @@ GPUdi() float TPCFastTransformGeo::getZreadout(int32_t sector) const
   }
 }
 
-GPUdi() std::tuple<float, float> TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const
+GPUdi() std::array<float, 2> TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const
 {
   /// convert Local c.s. -> Pad, DriftLength
   float u, l;
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 50b667bb3e023..3cf3b697d2da9 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -303,12 +303,17 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
   auto getInvCorrections = [&](int iSector, int iRow, float realY, float realZ, float& ix, float& iy, float& iz) {
     // get the inverse corrections ix, iy, iz at x,y,z
     ix = corr.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);
-    std::tie(iy, iz) = corr.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ);
+    const auto c = corr.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ);
+    iy = c[0];
+    iz = c[1];
   };
 
   auto getAllCorrections = [&](int iSector, int iRow, float y, float z, float& cx, float& cy, float& cz, float& ix, float& iy, float& iz) {
     // get the corrections cx,cy,cz at x,y,z
-    std::tie(cx, cy, cz) = corr.getCorrectionLocal(iSector, iRow, y, z);
+    const auto c = corr.getCorrectionLocal(iSector, iRow, y, z);
+    cx = c[0];
+    cy = c[1];
+    cz = c[2];
     getInvCorrections(iSector, iRow, y + cy, z + cz, ix, iy, iz);
   };
 

From 4f9c0338ea02e35a3ca915c901765c3b8e5517c2 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <se.gorbunov@gsi.de>
Date: Wed, 27 Aug 2025 18:28:46 +0000
Subject: [PATCH 1576/1764] TPC Splines: better smoothing between the voxels

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 104 +++++++++++-------
 GPU/TPCFastTransformation/Spline2DHelper.cxx  |  14 ++-
 GPU/TPCFastTransformation/Spline2DHelper.h    |   2 +-
 .../TPCFastSpaceChargeCorrectionMap.h         |   9 +-
 .../macro/TPCFastTransformInit.C              |  25 +++--
 5 files changed, 94 insertions(+), 60 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 9232598e6a35e..02cdefa85e119 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -148,9 +148,13 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
         if (!processingInverseCorrection) {
           info.resetMaxValues();
         }
+        info.updateMaxValues(1., 1., 1.);
+        info.updateMaxValues(-1., -1., -1.);
+
         if (nDataPoints >= 4) {
           std::vector<double> pointGU(nDataPoints);
           std::vector<double> pointGV(nDataPoints);
+          std::vector<double> pointWeight(nDataPoints);
           std::vector<double> pointCorr(3 * nDataPoints); // 3 dimensions
           for (int i = 0; i < nDataPoints; ++i) {
             o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p = data[i];
@@ -161,15 +165,14 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
             }
             pointGU[i] = gu;
             pointGV[i] = gv;
+            pointWeight[i] = p.mWeight;
             pointCorr[3 * i + 0] = p.mDx;
             pointCorr[3 * i + 1] = p.mDy;
             pointCorr[3 * i + 2] = p.mDz;
-            if (!processingInverseCorrection) {
-              info.updateMaxValues(20. * p.mDx, 20. * p.mDy, 20. * p.mDz);
-            }
+            info.updateMaxValues(5. * p.mDx, 5. * p.mDy, 5. * p.mDz);
           }
-          helper.approximateDataPoints(spline, splineParameters.data(), 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), &pointGU[0],
-                                       &pointGV[0], &pointCorr[0], nDataPoints);
+          helper.approximateDataPoints(spline, splineParameters.data(), 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), pointGU.data(),
+                                       pointGV.data(), pointCorr.data(), pointWeight.data(), nDataPoints);
         } else {
           for (int i = 0; i < spline.getNumberOfParameters(); i++) {
             splineParameters[i] = 0.f;
@@ -301,7 +304,7 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
               double dx, dy, dz;
               correctionLocal(iSector, iRow, y, z, dx, dy, dz);
               mCorrectionMap.addCorrectionPoint(iSector, iRow,
-                                                y, z, dx, dy, dz);
+                                                y, z, dx, dy, dz, 1.);
             }
           }
         } // row
@@ -593,14 +596,6 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
             data.mCy *= -1.;
             data.mCz *= -1.;
           }
-          if (data.mNentries > 0) {
-            if (iSector < geo.getNumberOfSectorsA() && data.mZ < 0) {
-              LOG(error) << errMsg << "fitted Z coordinate " << data.mZ << " is negative for sector " << iSector;
-            }
-            if (iSector >= geo.getNumberOfSectorsA() && data.mZ > 0) {
-              LOG(error) << errMsg << "fitted Z coordinate " << data.mZ << " is positive for sector " << iSector;
-            }
-          }
         }
       };
       processor.Process(myThread);
@@ -624,6 +619,9 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       }
     }
 
+    double maxError[3] = {0., 0., 0.};
+    int nErrors = 0;
+
     for (int iSector = 0; iSector < nSectors; iSector++) {
 
       // now process the data row-by-row
@@ -682,9 +680,21 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
                   }
 
                   if (!msg.str().empty()) {
-                    LOG(warning) << directionName << " correction: fitted voxel position is outside the voxel: "
-                                 << " sector " << iSector << " row " << iRow << " bin y " << iy << " bin z " << iz
-                                 << msg.str();
+                    bool isMaxErrorExceeded = (fabs(data.mX - x) / dx > maxError[0]) ||
+                                              (fabs(data.mY - vox.mY) / vox.mDy > maxError[1]) ||
+                                              (fabs(data.mZ - vox.mZ) / vox.mDz > maxError[2]);
+                    static std::mutex mutex;
+                    mutex.lock();
+                    nErrors++;
+                    if (nErrors < 20 || isMaxErrorExceeded) {
+                      LOG(warning) << directionName << " correction: error N " << nErrors << "fitted voxel position is outside the voxel: "
+                                   << " sector " << iSector << " row " << iRow << " bin y " << iy << " bin z " << iz
+                                   << msg.str();
+                      maxError[0] = GPUCommonMath::Max(maxError[0], fabs(data.mX - x) / dx);
+                      maxError[1] = GPUCommonMath::Max(maxError[1], fabs(data.mY - vox.mY) / vox.mDy);
+                      maxError[2] = GPUCommonMath::Max(maxError[2], fabs(data.mZ - vox.mZ) / vox.mDz);
+                    }
+                    mutex.unlock();
                   }
 
                 } else { // no data, take voxel center position
@@ -773,17 +783,27 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
           auto& info = correction.getSectorRowInfo(iSector, iRow);
           const auto& spline = correction.getSpline(iSector, iRow);
 
-          auto addEdge = [&](int iy1, int iz1, int iy2, int iz2, int nSteps) {
+          auto addVoxel = [&](int iy, int iz, double weight) {
+            auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
+            if (vox.mSmoothingStep > 2) {
+              LOG(fatal) << "empty voxel is not repared: y " << iy << " z " << iz;
+            }
+            auto& data = vSectorData[iSector * nRows + iRow][iy * nZ2Xbins + iz];
+            map.addCorrectionPoint(iSector, iRow, data.mY, data.mZ, data.mCx, data.mCy, data.mCz, weight);
+          };
+
+          auto addEdge = [&](int iy1, int iz1, int iy2, int iz2, int nPoints) {
+            // add n points on the edge between two voxels excluding the voxel points
+            if (nPoints < 1)
+              return;
+            if (iy1 < 0 || iy1 >= nY2Xbins || iz1 < 0 || iz1 >= nZ2Xbins)
+              return;
+            if (iy2 < 0 || iy2 >= nY2Xbins || iz2 < 0 || iz2 >= nZ2Xbins)
+              return;
             auto& data1 = vSectorData[iSector * nRows + iRow][iy1 * nZ2Xbins + iz1];
             auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
             auto& data2 = vSectorData[iSector * nRows + iRow][iy2 * nZ2Xbins + iz2];
             auto& vox2 = vRowVoxels[iy2 * nZ2Xbins + iz2];
-            if (vox1.mSmoothingStep > 2) {
-              LOG(fatal) << "empty voxel is not repared: y " << iy1 << " z " << iz1;
-            }
-            if (vox2.mSmoothingStep > 2) {
-              LOG(fatal) << "empty voxel is not repared: y " << iy2 << " z " << iz2;
-            }
             double y1 = data1.mY;
             double z1 = data1.mZ;
             double cx1 = data1.mCx;
@@ -795,32 +815,36 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
             double cy2 = data2.mCy;
             double cz2 = data2.mCz;
 
-            for (int is = 0; is < nSteps; is++) {
-              double s2 = is / (double)nSteps;
+            for (int is = 1; is <= nPoints; is++) {
+              double s2 = is / (double)(nPoints + 1);
               double s1 = 1. - s2;
               double y = s1 * y1 + s2 * y2;
               double z = s1 * z1 + s2 * z2;
               double cx = s1 * cx1 + s2 * cx2;
               double cy = s1 * cy1 + s2 * cy2;
               double cz = s1 * cz1 + s2 * cz2;
-              map.addCorrectionPoint(iSector, iRow, y, z, cx, cy, cz);
+              map.addCorrectionPoint(iSector, iRow, y, z, cx, cy, cz, 1.);
             }
           };
 
+          // original measurements weighted by 8 at each voxel and 8 additional artificial measurements around each voxel
+          //
+          // (y+1, z) 8 1 1 8 (y+1, z+1)
+          //          1 1 1 1 1
+          //          1 1 1 1 1
+          //    (y,z) 8 1 1 8 1
+          //          1 1 1 1 1
+
           for (int iy = 0; iy < nY2Xbins; iy++) {
-            for (int iz = 0; iz < nZ2Xbins - 1; iz++) {
-              addEdge(iy, iz, iy, iz + 1, 3);
+            for (int iz = 0; iz < nZ2Xbins; iz++) {
+              addVoxel(iy, iz, 8);
+              addEdge(iy, iz, iy, iz + 1, 2);
+              addEdge(iy, iz, iy + 1, iz, 2);
+              addEdge(iy, iz, iy + 1, iz + 1, 2);
+              addEdge(iy + 1, iz, iy, iz + 1, 2);
             }
-            addEdge(iy, nZ2Xbins - 1, iy, nZ2Xbins - 1, 1);
           }
 
-          for (int iz = 0; iz < nZ2Xbins; iz++) {
-            for (int iy = 0; iy < nY2Xbins - 1; iy++) {
-              addEdge(iy, iz, iy + 1, iz, 3);
-            }
-            addEdge(nY2Xbins - 1, iz, nY2Xbins - 1, iz, 1);
-          } // iy
-
         } // iRow
       }; // myThread
 
@@ -939,10 +963,11 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
           }
         }
 
-        std::vector<double> dataPointGridU, dataPointGridV, dataPointF;
+        std::vector<double> dataPointGridU, dataPointGridV, dataPointF, dataPointWeight;
         dataPointGridU.reserve(gridU.size() * gridV.size());
         dataPointGridV.reserve(gridU.size() * gridV.size());
         dataPointF.reserve(3 * gridU.size() * gridV.size());
+        dataPointWeight.reserve(gridU.size() * gridV.size());
 
         for (int iu = 0; iu < gridU.size(); iu++) {
           for (int iv = 0; iv < gridV.size(); iv++) {
@@ -963,6 +988,7 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
             dataPointF.push_back(scale * dx);
             dataPointF.push_back(scale * dy);
             dataPointF.push_back(scale * dz);
+            dataPointWeight.push_back(1.);
           }
         }
 
@@ -972,7 +998,7 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
         helper.approximateDataPoints(spline, splineParameters.data(), 0., spline.getGridX1().getUmax(),
                                      0., spline.getGridX2().getUmax(),
                                      dataPointGridU.data(), dataPointGridV.data(),
-                                     dataPointF.data(), nDataPoints);
+                                     dataPointF.data(), dataPointWeight.data(), nDataPoints);
 
         float* splineX = correction.getSplineDataInvX(sector, row);
         float* splineUV = correction.getSplineDataInvYZ(sector, row);
diff --git a/GPU/TPCFastTransformation/Spline2DHelper.cxx b/GPU/TPCFastTransformation/Spline2DHelper.cxx
index bec6fc58ff8d7..a93e753942dce 100644
--- a/GPU/TPCFastTransformation/Spline2DHelper.cxx
+++ b/GPU/TPCFastTransformation/Spline2DHelper.cxx
@@ -241,6 +241,7 @@ void Spline2DHelper<DataT>::approximateFunctionViaDataPoints(
   mFdimensions = spline.getYdimensions();
   std::vector<double> dataPointX1(getNumberOfDataPoints());
   std::vector<double> dataPointX2(getNumberOfDataPoints());
+  std::vector<double> dataPointWeight(getNumberOfDataPoints(), 1.);
   std::vector<double> dataPointF(getNumberOfDataPoints() * mFdimensions);
 
   double scaleX1 = (x1Max - x1Min) / ((double)mHelperU1.getSpline().getUmax());
@@ -256,7 +257,8 @@ void Spline2DHelper<DataT>::approximateFunctionViaDataPoints(
       F(x1, x2, &dataPointF[ind * mFdimensions]);
     }
   }
-  approximateDataPoints(spline, spline.getParameters(), x1Min, x1Max, x2Min, x2Max, &dataPointX1[0], &dataPointX2[0], &dataPointF[0], getNumberOfDataPoints());
+  approximateDataPoints(spline, spline.getParameters(), x1Min, x1Max, x2Min, x2Max, dataPointX1.data(), dataPointX2.data(), dataPointF.data(),
+                        dataPointWeight.data(), getNumberOfDataPoints());
 }
 
 template <typename DataT>
@@ -326,7 +328,7 @@ template <typename DataT>
 void Spline2DHelper<DataT>::approximateDataPoints(
   Spline2DContainer<DataT>& spline, DataT* splineParameters, double x1Min, double x1Max, double x2Min, double x2Max,
   const double dataPointX1[], const double dataPointX2[], const double dataPointF[/*getNumberOfDataPoints() x nFdim*/],
-  int32_t nDataPoints)
+  const double dataPointWeight[], int32_t nDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
 
@@ -343,6 +345,10 @@ void Spline2DHelper<DataT>::approximateDataPoints(
   for (int32_t iPoint = 0; iPoint < nDataPoints; ++iPoint) {
     double u = fGridU.convXtoU(dataPointX1[iPoint]);
     double v = fGridV.convXtoU(dataPointX2[iPoint]);
+    double weight = dataPointWeight[iPoint];
+    if (!(weight > 0.)) {
+      continue;
+    }
     int32_t iu = fGridU.getLeftKnotIndexForU(u);
     int32_t iv = fGridV.getLeftKnotIndexForU(v);
     double c[16];
@@ -353,14 +359,14 @@ void Spline2DHelper<DataT>::approximateDataPoints(
 
     for (int32_t i = 0; i < 16; i++) {
       for (int32_t j = i; j < 16; j++) {
-        solver.A(ind[i], ind[j]) += c[i] * c[j];
+        solver.A(ind[i], ind[j]) += weight * c[i] * c[j];
       }
     }
 
     for (int32_t iDim = 0; iDim < nFdim; iDim++) {
       double f = (double)dataPointF[iPoint * nFdim + iDim];
       for (int32_t i = 0; i < 16; i++) {
-        solver.B(ind[i], iDim) += f * c[i];
+        solver.B(ind[i], iDim) += weight * f * c[i];
       }
     }
   } // data points
diff --git a/GPU/TPCFastTransformation/Spline2DHelper.h b/GPU/TPCFastTransformation/Spline2DHelper.h
index 7195bab925f85..aa52c306a1a53 100644
--- a/GPU/TPCFastTransformation/Spline2DHelper.h
+++ b/GPU/TPCFastTransformation/Spline2DHelper.h
@@ -74,7 +74,7 @@ class Spline2DHelper
   void approximateDataPoints(
     Spline2DContainer<DataT>& spline, DataT* splineParameters, double x1Min, double x1Max, double x2Min, double x2Max,
     const double dataPointX1[/*nDataPoints*/], const double dataPointX2[/*nDataPoints*/],
-    const double dataPointF[/*nDataPoints x spline.getYdimensions*/], int32_t nDataPoints);
+    const double dataPointF[/*nDataPoints x spline.getYdimensions*/], const double dataPointWeight[/*nDataPoints*/], int32_t nDataPoints);
 
   /// _______________   Interface for a step-wise construction of the best-fit spline   ________________________
 
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
index fcee61ff09425..e54cf878ee2ff 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
@@ -42,8 +42,9 @@ class TPCFastSpaceChargeCorrectionMap
   /// \brief The struct contains necessary info for TPC padrow
   ///
   struct CorrectionPoint {
-    double mY, mZ;        // not-distorted local coordinates
-    double mDx, mDy, mDz; // corrections to the local coordinates
+    double mY{0.}, mZ{0.};            // not-distorted local coordinates
+    double mDx{0.}, mDy{0.}, mDz{0.}; // corrections to the local coordinates
+    double mWeight{0.};               // weight of the point
   };
 
   /// _____________  Constructors / destructors __________________________
@@ -72,11 +73,11 @@ class TPCFastSpaceChargeCorrectionMap
   /// Starts the construction procedure, reserves temporary memory
   void addCorrectionPoint(int32_t iSector, int32_t iRow,
                           double y, double z,
-                          double dx, double dy, double dz)
+                          double dx, double dy, double dz, double weight)
   {
     int32_t ind = mNrows * iSector + iRow;
     fDataPoints.at(ind).push_back(CorrectionPoint{y, z,
-                                                  dx, dy, dz});
+                                                  dx, dy, dz, weight});
   }
 
   const std::vector<CorrectionPoint>& getPoints(int32_t iSector, int32_t iRow) const
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 3cf3b697d2da9..3cb4812abafc1 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -319,6 +319,8 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
   for (int direction = 0; direction < 2; direction++) { // 0 - normal, 1 - inverse
 
+    std::string directionName = (direction == 0) ? "direct" : "inverse";
+
     TTree* currentTree = (direction == 0) ? voxResTree : voxResTreeInverse;
     if (!currentTree) {
       std::cout << "tree voxResTree does not exist!" << std::endl;
@@ -342,7 +344,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
     double sumDiff[3] = {0., 0., 0.};
     int64_t nDiff = 0;
 
-    std::cout << "fill debug ntuples at voxels ..." << std::endl;
+    LOG(info) << directionName << " correction: fill debug ntuples at voxels ...";
 
     for (int32_t iVox = 0; iVox < currentTree->GetEntriesFast(); iVox++) {
 
@@ -457,12 +459,11 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
       }
     }
 
-    std::cout
-      << "fill debug ntuples everywhere .." << std::endl;
+    LOG(info) << directionName << " correction: fill debug ntuples everywhere ..";
 
     for (int32_t iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
       // for (int32_t iSector = 0; iSector < 1; iSector++) {
-      std::cout << "debug ntules for sector " << iSector << std::endl;
+      LOG(info) << directionName << " correction: fill debug ntuples everywhere in sector " << iSector;
 
       int mirrorSector = (iSector >= geo.getNumberOfSectorsA()) ? iSector - geo.getNumberOfSectorsA() : iSector + geo.getNumberOfSectorsA();
 
@@ -592,17 +593,17 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
     for (int32_t i = 0; i < 3; i++) {
       sumDiff[i] = sqrt(sumDiff[i]) / nDiff;
     }
+    LOG(info) << directionName << " correction: max and mean differences between spline and voxel corrections:";
+    LOG(info) << "Max difference in x :  " << maxDiff[0] << " at Sector "
+              << maxDiffSector[0] << " row " << maxDiffRow[0];
 
-    std::cout << "Max difference in x :  " << maxDiff[0] << " at Sector "
-              << maxDiffSector[0] << " row " << maxDiffRow[0] << std::endl;
-
-    std::cout << "Max difference in y :  " << maxDiff[1] << " at Sector "
-              << maxDiffSector[1] << " row " << maxDiffRow[1] << std::endl;
+    LOG(info) << "Max difference in y :  " << maxDiff[1] << " at Sector "
+              << maxDiffSector[1] << " row " << maxDiffRow[1];
 
-    std::cout << "Max difference in z :  " << maxDiff[2] << " at Sector "
-              << maxDiffSector[2] << " row " << maxDiffRow[2] << std::endl;
+    LOG(info) << "Max difference in z :  " << maxDiff[2] << " at Sector "
+              << maxDiffSector[2] << " row " << maxDiffRow[2];
 
-    std::cout << "Mean difference in x,y,z : " << sumDiff[0] << " " << sumDiff[1]
+    LOG(info) << "Mean difference in x,y,z : " << sumDiff[0] << " " << sumDiff[1]
               << " " << sumDiff[2] << std::endl;
   } // direction
 

From 29a87bf2e97952bfb30a0fdb0fa4f9c1b9e15d6a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 1 Sep 2025 15:52:24 +0200
Subject: [PATCH 1577/1764] TPCFastTransform: fix compilation on GPU with the
 new splines

---
 GPU/TPCFastTransformation/Spline1DSpec.h      |  6 +-
 GPU/TPCFastTransformation/Spline2DSpec.h      | 12 +++-
 .../TPCFastSpaceChargeCorrection.h            | 70 +++++++++----------
 GPU/TPCFastTransformation/TPCFastTransform.h  | 60 ++++++++--------
 4 files changed, 80 insertions(+), 68 deletions(-)

diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 28be5dd20e235..d72de5a446718 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -314,7 +314,11 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
     const auto nYdim = nYdimTmp.get();
 
-    auto [dSdSl, dSdDl, dSdSr, dSdDr] = getSderivativesOverParsAtU<T>(knotL, u);
+    auto val = getSderivativesOverParsAtU<T>(knotL, u);
+    const auto& dSdSl = val[0];
+    const auto& dSdDl = val[1];
+    const auto& dSdSr = val[2];
+    const auto& dSdDr = val[3];
     for (int32_t dim = 0; dim < nYdim; ++dim) {
       S[dim] = dSdSr * Sr[dim] + dSdSl * Sl[dim] + dSdDl * Dl[dim] + dSdDr * Dr[dim];
     }
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index 987ce1ad5d256..7c34b0890ce50 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -334,8 +334,16 @@ class Spline2DSpec<DataT, YdimT, 0>
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
 
-    auto [dSl, dDl, dSr, dDr] = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
-    auto [dSd, dDd, dSu, dDu] = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
+    auto val1 = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
+    auto val2 = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
+    const auto& dSl = val1[0];
+    const auto& dDl = val1[1];
+    const auto& dSr = val1[2];
+    const auto& dDr = val1[3];
+    const auto& dSd = val2[0];
+    const auto& dDd = val2[1];
+    const auto& dSu = val2[2];
+    const auto& dDu = val2[3];
 
     // when nYdim == 1:
     // S = dSl * (dSd * A[0] + dDd * A[1]) + dDl * (dSd * A[2] + dDd * A[3]) +
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 4ca5b74025743..ffbc8691ea268 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -56,15 +56,15 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     float splineScalingWithZ{0.f}; ///< spline scaling factor in the Z region between the zOut and the readout plane
 
    public:
-    void set(float y0, float yScale, float z0, float zScale, float zOut, float zReadout)
+    void set(float y0_, float yScale_, float z0_, float zScale_, float zOut_, float zReadout_)
     {
-      this->y0 = y0;
-      this->yScale = yScale;
-      this->z0 = z0;
-      this->zScale = zScale;
-      this->zOut = zOut;
+      this->y0 = y0_;
+      this->yScale = yScale_;
+      this->z0 = z0_;
+      this->zScale = zScale_;
+      this->zOut = zOut_;
       // no scaling when the distance to the readout is too small
-      this->splineScalingWithZ = fabs(zReadout - zOut) > 1. ? 1. / (zReadout - zOut) : 0.;
+      this->splineScalingWithZ = fabs(zReadout_ - zOut_) > 1. ? 1. / (zReadout_ - zOut_) : 0.;
     }
 
     float getY0() const { return y0; }
@@ -72,13 +72,13 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     float getZ0() const { return z0; }
     float getZscale() const { return zScale; }
 
-    float getSpineScaleForZ(float z) const
+    GPUd() float getSpineScaleForZ(float z) const
     {
       return 1.f - GPUCommonMath::Clamp((z - zOut) * splineScalingWithZ, 0.f, 1.f);
     }
 
     /// convert local y, z to internal grid coordinates u,v, and spline scale
-    std::array<float, 3> convLocalToGridUntruncated(float y, float z) const
+    GPUd() std::array<float, 3> convLocalToGridUntruncated(float y, float z) const
     {
       return {(y - y0) * yScale, (z - z0) * zScale, getSpineScaleForZ(z)};
     }
@@ -458,21 +458,21 @@ GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::convLocalToGrid(int32
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
   const SplineType& spline = getSpline(sector, row);
-  auto [gridU, gridV, scale] = getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z);
+  auto val = getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z);
   // shrink to the grid
-  gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
-  gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
-  return {gridU, gridV, scale};
+  val[0] = GPUCommonMath::Clamp(val[0], 0.f, (float)spline.getGridX1().getUmax());
+  val[1] = GPUCommonMath::Clamp(val[1], 0.f, (float)spline.getGridX2().getUmax());
+  return val;
 }
 
 GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// check if local y, z are inside the grid
-  auto [gridU, gridV, scale] = getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z);
+  auto val = getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z);
   const auto& spline = getSpline(sector, row);
   // shrink to the grid
-  if (gridU < 0.f || gridU > (float)spline.getGridX1().getUmax() || //
-      gridV < 0.f || gridV > (float)spline.getGridX2().getUmax()) {
+  if (val[0] < 0.f || val[0] > (float)spline.getGridX1().getUmax() || //
+      val[1] < 0.f || val[1] > (float)spline.getGridX2().getUmax()) {
     return false;
   }
   return true;
@@ -481,11 +481,11 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int
 GPUdi() bool TPCFastSpaceChargeCorrection::isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// check if local y, z are inside the grid
-  auto [gridU, gridV, scale] = getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z);
+  auto val = getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z);
   const auto& spline = getSpline(sector, row);
   // shrink to the grid
-  if (gridU < 0.f || gridU > (float)spline.getGridX1().getUmax() || //
-      gridV < 0.f || gridV > (float)spline.getGridX2().getUmax()) {
+  if (val[0] < 0.f || val[0] > (float)spline.getGridX1().getUmax() || //
+      val[1] < 0.f || val[1] > (float)spline.getGridX2().getUmax()) {
     return false;
   }
   return true;
@@ -501,11 +501,11 @@ GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::convRealLocalToGrid(i
 {
   /// convert real y, z to the internal grid coordinates + scale
   const SplineType& spline = getSpline(sector, row);
-  auto [gridU, gridV, scale] = getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z);
+  auto val = getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z);
   // shrink to the grid
-  gridU = GPUCommonMath::Clamp(gridU, 0.f, (float)spline.getGridX1().getUmax());
-  gridV = GPUCommonMath::Clamp(gridV, 0.f, (float)spline.getGridX2().getUmax());
-  return {gridU, gridV, scale};
+  val[0] = GPUCommonMath::Clamp(val[0], 0.f, (float)spline.getGridX1().getUmax());
+  val[1] = GPUCommonMath::Clamp(val[1], 0.f, (float)spline.getGridX2().getUmax());
+  return val;
 }
 
 GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV) const
@@ -520,35 +520,35 @@ GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::getCorrectionLocal(in
   const SplineType& spline = getSpline(sector, row);
   const float* splineData = getSplineData(sector, row);
 
-  auto [gridU, gridV, scale] = convLocalToGrid(sector, row, y, z);
+  auto val = convLocalToGrid(sector, row, y, z);
 
   float dxyz[3];
-  spline.interpolateAtU(splineData, gridU, gridV, dxyz);
+  spline.interpolateAtU(splineData, val[0], val[1], dxyz);
 
-  float dx = scale * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
-  float dy = scale * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
-  float dz = scale * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
+  float dx = val[2] * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
+  float dy = val[2] * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
+  float dz = val[2] * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
   return {dx, dy, dz};
 }
 
 GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
   const auto& info = getSectorRowInfo(sector, row);
-  auto [gridU, gridV, scale] = convRealLocalToGrid(sector, row, realY, realZ);
+  auto val = convRealLocalToGrid(sector, row, realY, realZ);
   float dx = 0;
-  getSplineInvX(sector, row).interpolateAtU(getSplineDataInvX(sector, row), gridU, gridV, &dx);
-  dx = scale * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
+  getSplineInvX(sector, row).interpolateAtU(getSplineDataInvX(sector, row), val[0], val[1], &dx);
+  dx = val[2] * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
   return dx;
 }
 
 GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
-  auto [gridU, gridV, scale] = convRealLocalToGrid(sector, row, realY, realZ);
+  auto val = convRealLocalToGrid(sector, row, realY, realZ);
   const auto& info = getSectorRowInfo(sector, row);
   float dyz[2];
-  getSplineInvYZ(sector, row).interpolateAtU(getSplineDataInvYZ(sector, row), gridU, gridV, dyz);
-  dyz[0] = scale * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
-  dyz[1] = scale * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
+  getSplineInvYZ(sector, row).interpolateAtU(getSplineDataInvYZ(sector, row), val[0], val[1], dyz);
+  dyz[0] = val[2] * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
+  dyz[1] = val[2] * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
   return {dyz[0], dyz[1]};
 }
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 35b94446ce088..60f5952e6a1fc 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -349,17 +349,17 @@ class TPCFastTransform : public FlatObject
 GPUdi() void TPCFastTransform::convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const
 {
   float l = (time - mT0 - vertexTime) * mVdrift; // drift length [cm]
-  const auto local = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
-  y = local[0];
-  z = local[1];
+  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
+  y = localval[0];
+  z = localval[1];
 }
 
 GPUdi() void TPCFastTransform::convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const
 {
   float l = getGeometry().getTPCzLength() + (time - mT0 - maxTimeBin) * mVdrift; // drift length [cm]
-  const auto local = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
-  y = local[0];
-  z = local[1];
+  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
+  y = localval[0];
+  z = localval[1];
 }
 
 // ----------------------------------------------------------------------
@@ -432,22 +432,22 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t sector, int32_t row, float
       dz = corrLocal[2];
       if (ref) {
         if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
-          auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
-          dx = (dx - dxRef) * scale + dxRef;
-          dy = (dy - dyRef) * scale + dyRef;
-          dz = (dz - dzRef) * scale + dzRef;
+          auto val = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
+          dx = (dx - val[0]) * scale + val[0];
+          dy = (dy - val[1]) * scale + val[1];
+          dz = (dz - val[2]) * scale + val[2];
         } else if ((scale != 0.f) && ((scaleMode == 1) || (scaleMode == 2))) {
-          auto [dxRef, dyRef, dzRef] = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
-          dx = dxRef * scale + dx;
-          dy = dyRef * scale + dy;
-          dz = dzRef * scale + dz;
+          auto val = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
+          dx = val[0] * scale + dx;
+          dy = val[1] * scale + dy;
+          dz = val[2] * scale + dz;
         }
       }
       if (ref2 && (scale2 != 0)) {
-        auto [dxRef, dyRef, dzRef] = ref2->mCorrection.getCorrectionLocal(sector, row, y, z);
-        dx = dxRef * scale2 + dx;
-        dy = dyRef * scale2 + dy;
-        dz = dzRef * scale2 + dz;
+        auto val = ref2->mCorrection.getCorrectionLocal(sector, row, y, z);
+        dx = val[0] * scale2 + dx;
+        dy = val[1] * scale2 + dy;
+        dz = val[2] * scale2 + dz;
       }
     }
   }
@@ -617,9 +617,9 @@ GPUdi() void TPCFastTransform::TransformIdeal(int32_t sector, int32_t row, float
 
   x = getGeometry().getRowInfo(row).x;
   float driftLength = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  const auto local = getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength);
-  y = local[0];
-  z = local[1];
+  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength);
+  y = localval[0];
+  z = localval[1];
 }
 
 GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const
@@ -732,18 +732,18 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t sector, int
 
     if (ref) { // scaling was requested
       if (scaleMode == 0 && scale > 0.f) {
-        const auto [dyRef, dzRef] = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
-        dy = (dy - dyRef) * scale + dyRef;
-        dz = (dz - dzRef) * scale + dzRef;
+        const auto val = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        dy = (dy - val[0]) * scale + val[0];
+        dz = (dz - val[1]) * scale + val[1];
       } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
-        const auto [dyRef, dzRef] = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
-        dy = dyRef * scale + dy;
-        dz = dzRef * scale + dz;
+        const auto val = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        dy = val[0] * scale + dy;
+        dz = val[1] * scale + dz;
       }
       if (ref2 && (scale2 != 0)) {
-        const auto [dyRef, dzRef] = ref2->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
-        dy = dyRef * scale2 + dy;
-        dz = dzRef * scale2 + dz;
+        const auto val = ref2->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
+        dy = val[0] * scale2 + dy;
+        dz = val[1] * scale2 + dz;
       }
     }
   }

From 4879ec57b1f38f4d3bea73be08e3a457a191ee92 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <se.gorbunov@gsi.de>
Date: Wed, 17 Sep 2025 17:49:29 +0000
Subject: [PATCH 1578/1764] TPC Splines: bugfixes in spline merging

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    |  2 +-
 GPU/TPCFastTransformation/Spline2DSpec.h      | 48 +++++++++----------
 2 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 02cdefa85e119..eb7620c358774 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -1103,7 +1103,7 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
           for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
             double u = gridU.getKnot(iu).u;
             for (int iv = 0; iv < gridV.getNumberOfKnots(); iv++) {
-              double v = gridV.getKnot(iu).u;
+              double v = gridV.getKnot(iv).u;
               int knotIndex = spline.getKnotIndex(iu, iv);
               float P[nKnotPar3d];
 
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index 7c34b0890ce50..5681de2dc5fe9 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -382,8 +382,8 @@ class Spline2DSpec<DataT, YdimT, 0>
     const auto nYdim4 = nYdim * 4;
 
     DataT *S = P,
-          *R = P + nYdim,
-          *Q = P + nYdim * 2,
+          *Q = P + nYdim,
+          *R = P + nYdim * 2,
           *W = P + nYdim * 3;
 
     const DataT& u = u1;
@@ -425,28 +425,6 @@ class Spline2DSpec<DataT, YdimT, 0>
       }
     }
 
-    // Derivative R = dS / du
-    // R = dRdSl * (dSdSd * A[0] + dSdDd * A[1]) + dRdDl * (dSdSd * A[2] + dSdDd * A[3]) +
-    //     dRdSr * (dSdSd * A[4] + dSdDd * A[5]) + dRdDr * (dSdSd * A[6] + dSdDd * A[7]) +
-    //     dRdSl * (dSdSu * B[0] + dSdDu * B[1]) + dRdDl * (dSdSu * B[2] + dSdDu * B[3]) +
-    //     dRdSr * (dSdSu * B[4] + dSdDu * B[5]) + dRdDr * (dSdSu * B[6] + dSdDu * B[7]);
-
-    {
-      DataT a[8] = {dRdSl * dSdSd, dRdSl * dSdDd, dRdDl * dSdSd, dRdDl * dSdDd,
-                    dRdSr * dSdSd, dRdSr * dSdDd, dRdDr * dSdSd, dRdDr * dSdDd};
-      DataT b[8] = {dRdSl * dSdSu, dRdSl * dSdDu, dRdDl * dSdSu, dRdDl * dSdDu,
-                    dRdSr * dSdSu, dRdSr * dSdDu, dRdDr * dSdSu, dRdDr * dSdDu};
-
-      // R = sum a[i]*A[i] + b[i]*B[i]
-
-      for (int32_t dim = 0; dim < nYdim; dim++) {
-        R[dim] = 0;
-        for (int32_t i = 0; i < 8; i++) {
-          R[dim] += a[i] * A[nYdim * i + dim] + b[i] * B[nYdim * i + dim];
-        }
-      }
-    }
-
     // Derivative Q = dS / dv
     // Q = dSdSl * (dQdSd * A[0] + dQdDd * A[1]) + dSdDl * (dQdSd * A[2] + dQdDd * A[3]) +
     //     dSdSr * (dQdSd * A[4] + dQdDd * A[5]) + dSdDr * (dQdSd * A[6] + dQdDd * A[7]) +
@@ -469,6 +447,28 @@ class Spline2DSpec<DataT, YdimT, 0>
       }
     }
 
+    // Derivative R = dS / du
+    // R = dRdSl * (dSdSd * A[0] + dSdDd * A[1]) + dRdDl * (dSdSd * A[2] + dSdDd * A[3]) +
+    //     dRdSr * (dSdSd * A[4] + dSdDd * A[5]) + dRdDr * (dSdSd * A[6] + dSdDd * A[7]) +
+    //     dRdSl * (dSdSu * B[0] + dSdDu * B[1]) + dRdDl * (dSdSu * B[2] + dSdDu * B[3]) +
+    //     dRdSr * (dSdSu * B[4] + dSdDu * B[5]) + dRdDr * (dSdSu * B[6] + dSdDu * B[7]);
+
+    {
+      DataT a[8] = {dRdSl * dSdSd, dRdSl * dSdDd, dRdDl * dSdSd, dRdDl * dSdDd,
+                    dRdSr * dSdSd, dRdSr * dSdDd, dRdDr * dSdSd, dRdDr * dSdDd};
+      DataT b[8] = {dRdSl * dSdSu, dRdSl * dSdDu, dRdDl * dSdSu, dRdDl * dSdDu,
+                    dRdSr * dSdSu, dRdSr * dSdDu, dRdDr * dSdSu, dRdDr * dSdDu};
+
+      // R = sum a[i]*A[i] + b[i]*B[i]
+
+      for (int32_t dim = 0; dim < nYdim; dim++) {
+        R[dim] = 0;
+        for (int32_t i = 0; i < 8; i++) {
+          R[dim] += a[i] * A[nYdim * i + dim] + b[i] * B[nYdim * i + dim];
+        }
+      }
+    }
+
     // cross-derivative W = (dS)^2 / du / dv
     // W = dRdSl * (dQdSd * A[0] + dQdDd * A[1]) + dRdDl * (dQdSd * A[2] + dQdDd * A[3]) +
     //     dRdSr * (dQdSd * A[4] + dQdDd * A[5]) + dRdDr * (dQdSd * A[6] + dQdDd * A[7]) +

From a4c73037924841e964da679408d1e66fcca2340e Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <se.gorbunov@gsi.de>
Date: Mon, 6 Oct 2025 21:19:19 +0000
Subject: [PATCH 1579/1764] TPC Splines: add backward compatibility

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    |  22 +-
 .../TPCFastSpaceChargeCorrection.cxx          | 331 +++++++++++++++---
 .../TPCFastSpaceChargeCorrection.h            |  90 ++---
 GPU/TPCFastTransformation/TPCFastTransform.h  |   2 +-
 .../TPCFastTransformGeo.cxx                   |   8 +-
 .../TPCFastTransformGeo.h                     |  10 +-
 .../TPCFastTransformationLinkDef_O2.h         |  23 +-
 .../macro/TPCFastTransformInit.C              |  92 ++---
 8 files changed, 408 insertions(+), 170 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index eb7620c358774..faba4f2ce065e 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -180,15 +180,15 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
         }
 
         if (processingInverseCorrection) {
-          float* splineX = correction.getSplineDataInvX(sector, row);
-          float* splineYZ = correction.getSplineDataInvYZ(sector, row);
+          float* splineX = correction.getCorrectionDataInvX(sector, row);
+          float* splineYZ = correction.getCorrectionDataInvYZ(sector, row);
           for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
             splineX[i] = splineParameters[3 * i + 0];
             splineYZ[2 * i + 0] = splineParameters[3 * i + 1];
             splineYZ[2 * i + 1] = splineParameters[3 * i + 2];
           }
         } else {
-          float* splineXYZ = correction.getSplineData(sector, row);
+          float* splineXYZ = correction.getCorrectionData(sector, row);
           for (int i = 0; i < spline.getNumberOfParameters(); i++) {
             splineXYZ[i] = splineParameters[i];
           }
@@ -1000,8 +1000,8 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
                                      dataPointGridU.data(), dataPointGridV.data(),
                                      dataPointF.data(), dataPointWeight.data(), nDataPoints);
 
-        float* splineX = correction.getSplineDataInvX(sector, row);
-        float* splineUV = correction.getSplineDataInvYZ(sector, row);
+        float* splineX = correction.getCorrectionDataInvX(sector, row);
+        float* splineUV = correction.getCorrectionDataInvYZ(sector, row);
         for (int i = 0; i < spline.getNumberOfParameters() / 3; i++) {
           splineX[i] = splineParameters[3 * i + 0];
           splineUV[2 * i + 0] = splineParameters[3 * i + 1];
@@ -1044,9 +1044,9 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
       for (int row = iThread; row < geo.getNumberOfRows(); row += mNthreads) {
         const auto& spline = mainCorrection.getSpline(sector, row);
 
-        float* splineParameters = mainCorrection.getSplineData(sector, row);
-        float* splineParametersInvX = mainCorrection.getSplineDataInvX(sector, row);
-        float* splineParametersInvYZ = mainCorrection.getSplineDataInvYZ(sector, row);
+        float* splineParameters = mainCorrection.getCorrectionData(sector, row);
+        float* splineParametersInvX = mainCorrection.getCorrectionDataInvX(sector, row);
+        float* splineParametersInvYZ = mainCorrection.getCorrectionDataInvYZ(sector, row);
 
         auto& secRowInfo = mainCorrection.getSectorRowInfo(sector, row);
 
@@ -1114,7 +1114,7 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
                 ls *= scale;
                 double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * ls * scaleU * scaleV};
                 const auto& spl = corr.getSpline(sector, row);
-                spl.interpolateParametersAtU(corr.getSplineData(sector, row), lu, lv, P);
+                spl.interpolateParametersAtU(corr.getCorrectionData(sector, row), lu, lv, P);
                 for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
                   for (int idim = 0; idim < 3; idim++, ind++) {
                     splineParameters[knotIndex * nKnotPar3d + ind] += parscale[ipar] * P[ind];
@@ -1129,7 +1129,7 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
               double parscale[4] = {ls, ls * scaleRealU, ls * scaleRealV, ls * ls * scaleRealU * scaleRealV};
 
               { // inverse X correction
-                corr.getSplineInvX(sector, row).interpolateParametersAtU(corr.getSplineDataInvX(sector, row), lu, lv, P);
+                corr.getSplineInvX(sector, row).interpolateParametersAtU(corr.getCorrectionDataInvX(sector, row), lu, lv, P);
                 for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
                   for (int idim = 0; idim < 1; idim++, ind++) {
                     splineParametersInvX[knotIndex * nKnotPar1d + ind] += parscale[ipar] * P[ind];
@@ -1138,7 +1138,7 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
               }
 
               { // inverse YZ correction
-                corr.getSplineInvYZ(sector, row).interpolateParametersAtU(corr.getSplineDataInvYZ(sector, row), lu, lv, P);
+                corr.getSplineInvYZ(sector, row).interpolateParametersAtU(corr.getCorrectionDataInvYZ(sector, row), lu, lv, P);
                 for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
                   for (int idim = 0; idim < 2; idim++, ind++) {
                     splineParametersInvYZ[knotIndex * nKnotPar2d + ind] += parscale[ipar] * P[ind];
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index eb5fe8669a52f..5a2cd21deeb2b 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -34,8 +34,8 @@ TPCFastSpaceChargeCorrection::TPCFastSpaceChargeCorrection()
     mNumberOfScenarios(0),
     mScenarioPtr(nullptr),
     mTimeStamp(-1),
-    mSplineData{nullptr, nullptr, nullptr},
-    mDataSizeBytes{0, 0, 0}
+    mCorrectionData{nullptr, nullptr, nullptr},
+    mCorrectionDataSize{0, 0, 0}
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -63,8 +63,8 @@ void TPCFastSpaceChargeCorrection::destroy()
   mScenarioPtr = nullptr;
   mTimeStamp = -1;
   for (int32_t is = 0; is < 3; is++) {
-    mSplineData[is] = nullptr;
-    mDataSizeBytes[is] = 0;
+    mCorrectionData[is] = nullptr;
+    mCorrectionDataSize[is] = 0;
   }
   FlatObject::destroy();
 }
@@ -78,9 +78,9 @@ void TPCFastSpaceChargeCorrection::relocateBufferPointers(const char* oldBuffer,
     char* newSplineBuf = relocatePointer(oldBuffer, newBuffer, sp.getFlatBufferPtr());
     sp.setActualBufferAddress(newSplineBuf);
   }
-  mSplineData[0] = relocatePointer(oldBuffer, newBuffer, mSplineData[0]);
-  mSplineData[1] = relocatePointer(oldBuffer, newBuffer, mSplineData[1]);
-  mSplineData[2] = relocatePointer(oldBuffer, newBuffer, mSplineData[2]);
+  mCorrectionData[0] = relocatePointer(oldBuffer, newBuffer, mCorrectionData[0]);
+  mCorrectionData[1] = relocatePointer(oldBuffer, newBuffer, mCorrectionData[1]);
+  mCorrectionData[2] = relocatePointer(oldBuffer, newBuffer, mCorrectionData[2]);
 }
 
 void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorrection& obj, char* newFlatBufferPtr)
@@ -101,26 +101,18 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
 
   mTimeStamp = obj.mTimeStamp;
 
-  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfSectors(); ++i) {
-    mSectorInfo[i] = obj.mSectorInfo[i];
-  }
-
-  mDataSizeBytes[0] = obj.mDataSizeBytes[0];
-  mDataSizeBytes[1] = obj.mDataSizeBytes[1];
-  mDataSizeBytes[2] = obj.mDataSizeBytes[2];
+  mCorrectionDataSize[0] = obj.mCorrectionDataSize[0];
+  mCorrectionDataSize[1] = obj.mCorrectionDataSize[1];
+  mCorrectionDataSize[2] = obj.mCorrectionDataSize[2];
 
   // variable-size data
   mScenarioPtr = obj.mScenarioPtr;
-  mSplineData[0] = obj.mSplineData[0];
-  mSplineData[1] = obj.mSplineData[1];
-  mSplineData[2] = obj.mSplineData[2];
+  mCorrectionData[0] = obj.mCorrectionData[0];
+  mCorrectionData[1] = obj.mCorrectionData[1];
+  mCorrectionData[2] = obj.mCorrectionData[2];
 
   mClassVersion = obj.mClassVersion;
 
-  for (int32_t i = 0; i < TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
-    mRowInfos[i] = obj.mRowInfos[i];
-  }
-
   for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfSectors() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
     mSectorRowInfos[i] = obj.mSectorRowInfos[i];
   }
@@ -137,7 +129,7 @@ void TPCFastSpaceChargeCorrection::moveBufferTo(char* newFlatBufferPtr)
   relocateBufferPointers(oldFlatBufferPtr, mFlatBufferPtr);
 }
 
-void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBufferPtr)
+void TPCFastSpaceChargeCorrection::setActualBufferAddressOld(char* actualFlatBufferPtr)
 {
   /// Sets the actual location of the external flat buffer after it has been moved (e.g. to another maschine)
 
@@ -162,12 +154,266 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
   }
   size_t bufferSize = scBufferOffset + scBufferSize;
   for (int32_t is = 0; is < 3; is++) {
-    size_t splineDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + splineDataOffset);
-    bufferSize = splineDataOffset + mDataSizeBytes[is];
+    size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
+    bufferSize = correctionDataOffset + mCorrectionDataSize[is];
   }
 }
 
+void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBufferPtr)
+{
+  /// Sets the actual location of the external flat buffer after it has been moved (e.g. to another maschine)
+
+  if (mClassVersion == 4) {
+    FlatObject::setActualBufferAddress(actualFlatBufferPtr);
+
+    size_t scSize = sizeof(SplineType) * mNumberOfScenarios;
+
+    mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr);
+
+    size_t scBufferOffset = alignSize(scSize, SplineType::getBufferAlignmentBytes());
+    size_t scBufferSize = 0;
+
+    for (int32_t i = 0; i < mNumberOfScenarios; i++) {
+      SplineType& sp = mScenarioPtr[i];
+      sp.setActualBufferAddress(mFlatBufferPtr + scBufferOffset + scBufferSize);
+      scBufferSize = alignSize(scBufferSize + sp.getFlatBufferSize(), sp.getBufferAlignmentBytes());
+    }
+    size_t bufferSize = scBufferOffset + scBufferSize;
+    for (int32_t is = 0; is < 3; is++) {
+      size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+      mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
+      bufferSize = correctionDataOffset + mCorrectionDataSize[is];
+    }
+    return;
+  }
+
+  if (mClassVersion != 3) {
+    LOG(fatal) << "TPCFastSpaceChargeCorrection::setActualBufferAddress() called with class version " << mClassVersion << ". This is not supported.";
+    return;
+  }
+
+  // Class version 3
+
+  struct RowInfoVersion3 {
+    int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
+    size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC sector
+  };
+
+  struct RowActiveAreaVersion3 {
+    float maxDriftLengthCheb[5]{0.f};
+    float vMax{0.f};
+    float cuMin{0.f};
+    float cuMax{0.f};
+    float cvMax{0.f};
+  };
+
+  struct SectorRowInfoVersion3 {
+    float gridV0{0.f};           ///< V coordinate of the V-grid start
+    float gridCorrU0{0.f};       ///< U coordinate of the U-grid start for corrected U
+    float gridCorrV0{0.f};       ///< V coordinate of the V-grid start for corrected V
+    float scaleCorrUtoGrid{0.f}; ///< scale corrected U to U-grid coordinate
+    float scaleCorrVtoGrid{0.f}; ///< scale corrected V to V-grid coordinate
+    RowActiveAreaVersion3 activeArea;
+  };
+
+  FlatObject::setActualBufferAddress(actualFlatBufferPtr);
+
+  size_t oldRowsOffset = 0;
+  size_t oldRowsSize = sizeof(RowInfoVersion3) * mGeo.getNumberOfRows();
+
+  size_t oldSectorRowsOffset = oldRowsOffset + oldRowsSize;
+  size_t oldSectorRowsSize = sizeof(SectorRowInfoVersion3) * mGeo.getNumberOfRows() * mGeo.getNumberOfSectors();
+
+  size_t oldScenariosOffset = alignSize(oldSectorRowsOffset + oldSectorRowsSize, SplineType::getClassAlignmentBytes());
+  size_t scenariosSize = sizeof(SplineType) * mNumberOfScenarios;
+
+  SplineType* oldScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr + oldScenariosOffset);
+
+  { // copy old-format sector and row parameters from the buffer to the arrays
+
+    auto* oldRowInfos = reinterpret_cast<RowInfoVersion3*>(mFlatBufferPtr + oldRowsOffset);
+    auto* oldSectorRowInfos = reinterpret_cast<SectorRowInfoVersion3*>(mFlatBufferPtr + oldSectorRowsOffset);
+
+    size_t sectorDataSize[3];
+    for (int32_t is = 0; is < 3; is++) {
+      sectorDataSize[is] = mCorrectionDataSize[is] / mGeo.getNumberOfSectors();
+    }
+
+    for (int32_t iSector = 0; iSector < mGeo.getNumberOfSectors(); iSector++) {
+
+      for (int32_t iRow = 0; iRow < mGeo.getNumberOfRows(); iRow++) {
+        RowInfoVersion3& oldRowInfo = oldRowInfos[iRow];
+        SectorRowInfoVersion3& oldSectorRowInfo = oldSectorRowInfos[mGeo.getNumberOfRows() * iSector + iRow];
+
+        // the spline buffer is not yet initialised, don't try to access knot positions etc
+        const auto& spline = oldScenarioPtr[oldRowInfo.splineScenarioID];
+
+        SectorRowInfo& newSectorRow = getSectorRowInfo(iSector, iRow);
+
+        newSectorRow.splineScenarioID = oldRowInfo.splineScenarioID;
+        for (int32_t is = 0; is < 3; is++) {
+          newSectorRow.dataOffsetBytes[is] = sectorDataSize[is] * iSector + oldRowInfo.dataOffsetBytes[is];
+        }
+
+        { // grid for the measured coordinates
+          float y0 = mGeo.getRowInfo(iRow).yMin;
+          float yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(iRow).getYwidth();
+          float zReadout = mGeo.getZreadout(iSector);
+          float zOut = mGeo.getTPCzLength() - oldSectorRowInfo.gridV0;
+          float z0 = -3.;
+          float zScale = spline.getGridX2().getUmax() / (zOut - z0);
+          if (iSector >= mGeo.getNumberOfSectorsA()) {
+            zOut = -zOut;
+            z0 = zOut;
+          }
+          newSectorRow.gridMeasured.set(y0, yScale, z0, zScale, zOut, zReadout);
+        }
+
+        { // grid for the real coordinates
+          float y0 = oldSectorRowInfo.gridCorrU0;
+          float yScale = oldSectorRowInfo.scaleCorrUtoGrid;
+          float zReadout = mGeo.getZreadout(iSector);
+          float zOut = mGeo.getTPCzLength() - oldSectorRowInfo.gridCorrV0;
+          float zScale = oldSectorRowInfo.scaleCorrVtoGrid;
+          float z0 = zOut - spline.getGridX2().getUmax() / zScale;
+          if (iSector >= mGeo.getNumberOfSectorsA()) {
+            zOut = -zOut;
+            z0 = zOut;
+          }
+          newSectorRow.gridReal.set(y0, yScale, z0, zScale, zOut, zReadout);
+        }
+
+        newSectorRow.resetMaxValues();
+        newSectorRow.updateMaxValues(-50.f, -50.f, -50.f);
+        newSectorRow.updateMaxValues(50.f, 50.f, 50.f);
+      }
+    }
+  }
+
+  // move spline scenarios to the new place in the buffer
+
+  mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr);
+  memmove(mScenarioPtr, oldScenarioPtr, scenariosSize);
+
+  size_t oldScenariosBufferOffset = alignSize(oldScenariosOffset + scenariosSize, SplineType::getBufferAlignmentBytes());
+  size_t scenariosBufferOffset = alignSize(scenariosSize, SplineType::getBufferAlignmentBytes());
+
+  size_t oldScenariosBufferSize = 0;
+  size_t scenariosBufferSize = 0;
+  for (int32_t i = 0; i < mNumberOfScenarios; i++) {
+    SplineType& sp = mScenarioPtr[i];
+    char* oldAddress = mFlatBufferPtr + oldScenariosBufferOffset + oldScenariosBufferSize;
+    char* newAddress = mFlatBufferPtr + scenariosBufferOffset + scenariosBufferSize;
+    memmove(newAddress, oldAddress, sp.getFlatBufferSize());
+    sp.setActualBufferAddress(newAddress);
+    oldScenariosBufferSize = alignSize(oldScenariosBufferSize + sp.getFlatBufferSize(), sp.getBufferAlignmentBytes());
+    scenariosBufferSize = alignSize(scenariosBufferSize + sp.getFlatBufferSize(), sp.getBufferAlignmentBytes());
+  }
+
+  size_t oldBufferSize = oldScenariosBufferOffset + oldScenariosBufferSize;
+  size_t bufferSize = scenariosBufferOffset + scenariosBufferSize;
+
+  // move spline data to the new place in the buffer
+
+  for (int32_t is = 0; is < 3; is++) {
+    size_t oldCorrectionDataOffset = alignSize(oldBufferSize, SplineType::getParameterAlignmentBytes());
+    size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
+    memmove(mCorrectionData[is], mFlatBufferPtr + oldCorrectionDataOffset, mCorrectionDataSize[is]);
+    oldBufferSize = oldCorrectionDataOffset + mCorrectionDataSize[is];
+    bufferSize = correctionDataOffset + mCorrectionDataSize[is];
+  }
+
+  mFlatBufferSize = bufferSize;
+
+  // now convert the spline data to the new format
+  for (int32_t iSector = 0; iSector < mGeo.getNumberOfSectors(); iSector++) {
+    bool isAside = (iSector < mGeo.getNumberOfSectorsA());
+    for (int32_t iRow = 0; iRow < mGeo.getNumberOfRows(); iRow++) {
+
+      SectorRowInfo& sectorRow = getSectorRowInfo(iSector, iRow);
+      const auto& spline = mScenarioPtr[sectorRow.splineScenarioID];
+
+      int nSplineDimensions[3] = {3, 1, 2};
+
+      for (int iSpline = 0; iSpline < 3; iSpline++) {
+        int nDim = nSplineDimensions[iSpline];
+        int nKnotParameters = 4 * nDim;
+        auto* data = getCorrectionData(iSector, iRow, iSpline);
+
+        // lambda to swap parameters at two knots
+        auto swapKnots = [&](int i1, int j1, int i2, int j2) {
+          auto k1 = spline.getKnotIndex(i1, j1);
+          auto k2 = spline.getKnotIndex(i2, j2);
+          for (int ipar = 0; ipar < nKnotParameters; ipar++) {
+            std::swap(data[nKnotParameters * k1 + ipar], data[nKnotParameters * k2 + ipar]);
+          }
+        };
+
+        // reorder knots for the A side Y == old U, Z == - old V
+        if (isAside) {
+          for (int32_t i = 0; i < spline.getGridX1().getNumberOfKnots(); i++) {
+            for (int32_t j = 0; j < spline.getGridX2().getNumberOfKnots() / 2; j++) {
+              swapKnots(i, j, i, spline.getGridX2().getNumberOfKnots() - 1 - j);
+            }
+          }
+        } else { // reorder knots for the C side Y == - old U, Z == old V
+          for (int32_t i = 0; i < spline.getGridX1().getNumberOfKnots() / 2; i++) {
+            for (int32_t j = 0; j < spline.getGridX2().getNumberOfKnots(); j++) {
+              swapKnots(i, j, spline.getGridX1().getNumberOfKnots() - 1 - i, j);
+            }
+          }
+        }
+
+        // correct sign of the parameters due to the coordinate swaps
+
+        for (int32_t iKnot = 0; iKnot < spline.getNumberOfKnots(); iKnot++) {
+          // new grid directions for all corrections
+          for (int iDim = 0; iDim < nDim; iDim++) {
+            if (isAside) {
+              data[nKnotParameters * iKnot + nDim * 1 + iDim] *= -1; // invert Z derivatives on A side
+            } else {
+              data[nKnotParameters * iKnot + nDim * 2 + iDim] *= -1; // invert Y derivatives on C side
+            }
+            data[nKnotParameters * iKnot + nDim * 3 + iDim] *= -1; // invert cross derivatives on both sides
+          }
+          // new correction directions
+          if (iSpline == 0) { // dX,dU,dV -> dX,dY,dZ
+            if (isAside) {
+              data[nKnotParameters * iKnot + nDim * 0 + 2] *= -1; // invert correction in Z
+              data[nKnotParameters * iKnot + nDim * 1 + 2] *= -1; // invert correction in Z Z-derivative
+              data[nKnotParameters * iKnot + nDim * 2 + 2] *= -1; // invert correction in Z Y-derivative
+              data[nKnotParameters * iKnot + nDim * 3 + 2] *= -1; // invert correction in Z cross derivative
+            } else {
+              data[nKnotParameters * iKnot + nDim * 0 + 1] *= -1; // invert correction in Y
+              data[nKnotParameters * iKnot + nDim * 1 + 1] *= -1; // invert correction in Y Z-derivative
+              data[nKnotParameters * iKnot + nDim * 2 + 1] *= -1; // invert correction in Y Y-derivative
+              data[nKnotParameters * iKnot + nDim * 3 + 1] *= -1; // invert correction in Y cross derivative
+            }
+          } else if (iSpline == 2) { // dU,dV at real U,V -> dY,dZ at real Y,Z
+            if (isAside) {
+              data[nKnotParameters * iKnot + nDim * 0 + 1] *= -1; // invert correction in Z
+              data[nKnotParameters * iKnot + nDim * 1 + 1] *= -1; // invert correction in Z Z-derivative
+              data[nKnotParameters * iKnot + nDim * 2 + 1] *= -1; // invert correction in Z Y-derivative
+              data[nKnotParameters * iKnot + nDim * 3 + 1] *= -1; // invert correction in Z cross derivative
+            } else {
+              data[nKnotParameters * iKnot + nDim * 0 + 0] *= -1; // invert correction in Y
+              data[nKnotParameters * iKnot + nDim * 1 + 0] *= -1; // invert correction in Y Z-derivative
+              data[nKnotParameters * iKnot + nDim * 2 + 0] *= -1; // invert correction in Y Y-derivative
+              data[nKnotParameters * iKnot + nDim * 3 + 0] *= -1; // invert correction in Y cross derivative
+            }
+          }
+        }
+
+      } // iSpline
+    } // iRow
+  } // iSector
+
+  // set the class version to the current one
+  mClassVersion = 4;
+}
+
 void TPCFastSpaceChargeCorrection::setFutureBufferAddress(char* futureFlatBufferPtr)
 {
   /// Sets a future location of the external flat buffer before moving it to this location (i.e. when copying to GPU).
@@ -186,9 +432,9 @@ void TPCFastSpaceChargeCorrection::setFutureBufferAddress(char* futureFlatBuffer
     sp.setFutureBufferAddress(newSplineBuf);
   }
   mScenarioPtr = relocatePointer(oldBuffer, newBuffer, mScenarioPtr);
-  mSplineData[0] = relocatePointer(oldBuffer, newBuffer, mSplineData[0]);
-  mSplineData[1] = relocatePointer(oldBuffer, newBuffer, mSplineData[1]);
-  mSplineData[2] = relocatePointer(oldBuffer, newBuffer, mSplineData[2]);
+  mCorrectionData[0] = relocatePointer(oldBuffer, newBuffer, mCorrectionData[0]);
+  mCorrectionData[1] = relocatePointer(oldBuffer, newBuffer, mCorrectionData[1]);
+  mCorrectionData[2] = relocatePointer(oldBuffer, newBuffer, mCorrectionData[2]);
 
   FlatObject::setFutureBufferAddress(futureFlatBufferPtr);
 }
@@ -199,7 +445,7 @@ void TPCFastSpaceChargeCorrection::print() const
   mGeo.print();
   LOG(info) << "  mNumberOfScenarios = " << mNumberOfScenarios;
   LOG(info) << "  mTimeStamp = " << mTimeStamp;
-  LOG(info) << "  mDataSizeBytes = " << mDataSizeBytes[0] << " " << mDataSizeBytes[1] << " " << mDataSizeBytes[2];
+  LOG(info) << "  mCorrectionDataSize = " << mCorrectionDataSize[0] << " " << mCorrectionDataSize[1] << " " << mCorrectionDataSize[2];
 
   if (mScenarioPtr) {
     for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -213,7 +459,7 @@ void TPCFastSpaceChargeCorrection::print() const
       for (int32_t ir = 0; ir < mGeo.getNumberOfRows(); ir++) {
         LOG(info) << "sector " << is << " row " << ir << ": ";
         const SplineType& spline = getSpline(is, ir);
-        const float* d = getSplineData(is, ir);
+        const float* d = getCorrectionData(is, ir);
         int32_t k = 0;
         for (int32_t i = 0; i < spline.getGridX1().getNumberOfKnots(); i++) {
           for (int32_t j = 0; j < spline.getGridX2().getNumberOfKnots(); j++, k++) {
@@ -250,7 +496,6 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
   assert(mConstructionScenarios != nullptr);
 
   for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
-    mSectorInfo[i].vMax1 = 0.;
     for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
       auto& row = mSectorRowInfos[mGeo.getMaxNumberOfRows() * i + j];
       row.splineScenarioID = -1;
@@ -276,8 +521,8 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
 
   mScenarioPtr = nullptr;
   for (int32_t s = 0; s < 3; s++) {
-    mSplineData[s] = nullptr;
-    mDataSizeBytes[s] = 0;
+    mCorrectionData[s] = nullptr;
+    mCorrectionDataSize[s] = 0;
   }
   mClassVersion = 4;
 }
@@ -338,20 +583,20 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
     scBufferSize = alignSize(scBufferSize + sp.getFlatBufferSize(), sp.getBufferAlignmentBytes());
   }
   size_t bufferSize = scBufferOffsets[0] + scBufferSize;
-  size_t splineDataOffset[3];
+  size_t correctionDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
-    splineDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mDataSizeBytes[is] = 0;
+    correctionDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    mCorrectionDataSize[is] = 0;
     for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
       for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
         SectorRowInfo& row = getSectorRowInfo(i, j);
         SplineType& spline = mConstructionScenarios[row.splineScenarioID];
-        row.dataOffsetBytes[is] = alignSize(mDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-        mDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
+        row.dataOffsetBytes[is] = alignSize(mCorrectionDataSize[is], SplineType::getParameterAlignmentBytes());
+        mCorrectionDataSize[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
       }
     }
-    mDataSizeBytes[is] = alignSize(mDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-    bufferSize = splineDataOffset[is] + mDataSizeBytes[is];
+    mCorrectionDataSize[is] = alignSize(mCorrectionDataSize[is], SplineType::getParameterAlignmentBytes());
+    bufferSize = correctionDataOffset[is] + mCorrectionDataSize[is];
   }
 
   FlatObject::finishConstruction(bufferSize);
@@ -366,7 +611,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   }
 
   for (int32_t is = 0; is < 3; is++) {
-    mSplineData[is] = reinterpret_cast<char*>(mFlatBufferPtr + splineDataOffset[is]);
+    mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset[is]);
   }
   releaseConstructionMemory();
 
@@ -380,13 +625,11 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
   // initialise all corrections to 0.
   for (int32_t sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
 
-    getSectorInfo(sector).vMax1 = mGeo.getTPCzLength();
-
     for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
       const SplineType& spline = getSpline(sector, row);
 
       for (int32_t is = 0; is < 3; is++) {
-        float* data = getSplineData(sector, row, is);
+        float* data = getCorrectionData(sector, row, is);
         int32_t nPar = spline.getNumberOfParameters();
         if (is == 1) {
           nPar = nPar / 3;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index ffbc8691ea268..b4fab68b91542 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -39,11 +39,9 @@ namespace gpu
 class TPCFastSpaceChargeCorrection : public FlatObject
 {
  public:
-  ///
-  /// \brief The struct contains necessary info for TPC padrow
-  ///
-  struct RowInfo {
-    ClassDefNV(RowInfo, 1);
+  // obsolete structure, declared here only for backward compatibility
+  struct SliceInfo {
+    ClassDefNV(SliceInfo, 2);
   };
 
   struct GridInfo {
@@ -144,11 +142,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     ClassDefNV(SectorRowInfo, 2);
   };
 
-  struct SectorInfo {
-    float vMax1{0.f}; ///< Max value of V coordinate
-    ClassDefNV(SectorInfo, 1);
-  };
-
   typedef Spline2D<float, 3> SplineTypeXYZ;
   typedef Spline2D<float, 1> SplineTypeInvX;
   typedef Spline2D<float, 2> SplineTypeInvYZ;
@@ -188,6 +181,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   /// Moving the class with its external buffer to another location
 
+  void setActualBufferAddressOld(char* actualFlatBufferPtr);
   void setActualBufferAddress(char* actualFlatBufferPtr);
   void setFutureBufferAddress(char* futureFlatBufferPtr);
 
@@ -215,10 +209,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// Sets the time stamp of the current calibaration
   GPUd() void setTimeStamp(int64_t v) { mTimeStamp = v; }
 
-  /// Set safety marging for the interpolation around the TPC row.
-  /// Outside of this area the interpolation returns the boundary values.
-  GPUd() void setInterpolationSafetyMargin(float val) { fInterpolationSafetyMargin = val; }
-
   /// Gives const pointer to a spline
   GPUd() const SplineType& getSpline(int32_t sector, int32_t row) const;
 
@@ -226,10 +216,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() SplineType& getSpline(int32_t sector, int32_t row);
 
   /// Gives pointer to spline data
-  GPUd() float* getSplineData(int32_t sector, int32_t row, int32_t iSpline = 0);
+  GPUd() float* getCorrectionData(int32_t sector, int32_t row, int32_t iSpline = 0);
 
   /// Gives pointer to spline data
-  GPUd() const float* getSplineData(int32_t sector, int32_t row, int32_t iSpline = 0) const;
+  GPUd() const float* getCorrectionData(int32_t sector, int32_t row, int32_t iSpline = 0) const;
 
   /// Gives const pointer to a spline for the inverse X correction
   GPUd() const SplineTypeInvX& getSplineInvX(int32_t sector, int32_t row) const;
@@ -238,10 +228,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() SplineTypeInvX& getSplineInvX(int32_t sector, int32_t row);
 
   /// Gives pointer to spline data for the inverse X correction
-  GPUd() float* getSplineDataInvX(int32_t sector, int32_t row);
+  GPUd() float* getCorrectionDataInvX(int32_t sector, int32_t row);
 
   /// Gives pointer to spline data for the inverse X correction
-  GPUd() const float* getSplineDataInvX(int32_t sector, int32_t row) const;
+  GPUd() const float* getCorrectionDataInvX(int32_t sector, int32_t row) const;
 
   /// Gives const pointer to a spline for the inverse YZ correction
   GPUd() const SplineTypeInvYZ& getSplineInvYZ(int32_t sector, int32_t row) const;
@@ -250,10 +240,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() SplineTypeInvYZ& getSplineInvYZ(int32_t sector, int32_t row);
 
   /// Gives pointer to spline data for the inverse YZ correction
-  GPUd() float* getSplineDataInvYZ(int32_t sector, int32_t row);
+  GPUd() float* getCorrectionDataInvYZ(int32_t sector, int32_t row);
 
   /// Gives pointer to spline data for the inverse YZ correction
-  GPUd() const float* getSplineDataInvYZ(int32_t sector, int32_t row) const;
+  GPUd() const float* getCorrectionDataInvYZ(int32_t sector, int32_t row) const;
 
   /// _______________ The main method: cluster correction  _______________________
   ///
@@ -297,24 +287,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// Gives the time stamp of the current calibaration parameters
   int64_t getTimeStamp() const { return mTimeStamp; }
 
-  /// Gives the interpolation safety marging  around the TPC row.
-  GPUd() float getInterpolationSafetyMargin() const { return fInterpolationSafetyMargin; }
-
-  /// Gives TPC row info
-  GPUd() const RowInfo& getRowInfo(int32_t row) const { return mRowInfos[row]; }
-
-  /// Gives TPC sector info
-  GPUd() const SectorInfo& getSectorInfo(int32_t sector) const
-  {
-    return mSectorInfo[sector];
-  }
-
-  /// Gives TPC sector info
-  GPUd() SectorInfo& getSectorInfo(int32_t sector)
-  {
-    return mSectorInfo[sector];
-  }
-
   /// Gives TPC sector & row info
   GPUd() const SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) const
   {
@@ -351,30 +323,24 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   int32_t mNumberOfScenarios; ///< Number of approximation spline scenarios
 
-  SectorInfo mSectorInfo[TPCFastTransformGeo::getNumberOfSectors()]; ///< SectorInfo array
-
   SplineType* mScenarioPtr; //! (transient!!) pointer to spline scenarios
 
   /// _______________  Calibration data  _______________________________________________
 
   int64_t mTimeStamp; ///< time stamp of the current calibration
 
-  char* mSplineData[3]; //! (transient!!) pointer to the spline data in the flat buffer
+  char* mCorrectionData[3]; //! (transient!!) pointer to the spline data in the flat buffer
 
-  size_t mDataSizeBytes[3]; ///< size of the data for one sector in the flat buffer
-
-  float fInterpolationSafetyMargin{0.1f}; // 10% area around the TPC row. Outside of this area the interpolation returns the boundary values.
+  size_t mCorrectionDataSize[3]; ///< size of the data per transformation (direct, inverseX, inverse YZ) in the flat buffer
 
   /// Class version. It is used to read older versions from disc.
   /// The default version 3 is the one before this field was introduced.
   /// The actual version must be set in startConstruction().
   int32_t mClassVersion{3};
 
-  RowInfo mRowInfos[TPCFastTransformGeo::getMaxNumberOfRows()]; ///< RowInfo array
-
   SectorRowInfo mSectorRowInfos[TPCFastTransformGeo::getNumberOfSectors() * TPCFastTransformGeo::getMaxNumberOfRows()]; ///< SectorRowInfo array
 
-  ClassDefNV(TPCFastSpaceChargeCorrection, 5);
+  ClassDefNV(TPCFastSpaceChargeCorrection, 4);
 };
 
 /// ====================================================
@@ -393,16 +359,16 @@ GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::
   return mScenarioPtr[getSectorRowInfo(sector, row).splineScenarioID];
 }
 
-GPUdi() float* TPCFastSpaceChargeCorrection::getSplineData(int32_t sector, int32_t row, int32_t iSpline)
+GPUdi() float* TPCFastSpaceChargeCorrection::getCorrectionData(int32_t sector, int32_t row, int32_t iSpline)
 {
   /// Gives pointer to spline data
-  return reinterpret_cast<float*>(mSplineData[iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]);
+  return reinterpret_cast<float*>(mCorrectionData[iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]);
 }
 
-GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineData(int32_t sector, int32_t row, int32_t iSpline) const
+GPUdi() const float* TPCFastSpaceChargeCorrection::getCorrectionData(int32_t sector, int32_t row, int32_t iSpline) const
 {
   /// Gives pointer to spline data
-  return reinterpret_cast<const float*>(mSplineData[iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]);
+  return reinterpret_cast<const float*>(mCorrectionData[iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]);
 }
 
 GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCorrection::getSplineInvX(int32_t sector, int32_t row)
@@ -417,16 +383,16 @@ GPUdi() const TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCo
   return reinterpret_cast<const SplineTypeInvX&>(getSpline(sector, row));
 }
 
-GPUdi() float* TPCFastSpaceChargeCorrection::getSplineDataInvX(int32_t sector, int32_t row)
+GPUdi() float* TPCFastSpaceChargeCorrection::getCorrectionDataInvX(int32_t sector, int32_t row)
 {
   /// Gives pointer to spline data for the inverse X correction
-  return getSplineData(sector, row, 1);
+  return getCorrectionData(sector, row, 1);
 }
 
-GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineDataInvX(int32_t sector, int32_t row) const
+GPUdi() const float* TPCFastSpaceChargeCorrection::getCorrectionDataInvX(int32_t sector, int32_t row) const
 {
   /// Gives pointer to spline data for the inverse X correction
-  return getSplineData(sector, row, 1);
+  return getCorrectionData(sector, row, 1);
 }
 
 GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvYZ& TPCFastSpaceChargeCorrection::getSplineInvYZ(int32_t sector, int32_t row)
@@ -441,16 +407,16 @@ GPUdi() const TPCFastSpaceChargeCorrection::SplineTypeInvYZ& TPCFastSpaceChargeC
   return reinterpret_cast<const SplineTypeInvYZ&>(getSpline(sector, row));
 }
 
-GPUdi() float* TPCFastSpaceChargeCorrection::getSplineDataInvYZ(int32_t sector, int32_t row)
+GPUdi() float* TPCFastSpaceChargeCorrection::getCorrectionDataInvYZ(int32_t sector, int32_t row)
 {
   /// Gives pointer to spline data for the inverse YZ correction
-  return getSplineData(sector, row, 2);
+  return getCorrectionData(sector, row, 2);
 }
 
-GPUdi() const float* TPCFastSpaceChargeCorrection::getSplineDataInvYZ(int32_t sector, int32_t row) const
+GPUdi() const float* TPCFastSpaceChargeCorrection::getCorrectionDataInvYZ(int32_t sector, int32_t row) const
 {
   /// Gives pointer to spline data for the inverse YZ correction
-  return getSplineData(sector, row, 2);
+  return getCorrectionData(sector, row, 2);
 }
 
 GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32_t row, float y, float z) const
@@ -518,7 +484,7 @@ GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::getCorrectionLocal(in
 {
   const auto& info = getSectorRowInfo(sector, row);
   const SplineType& spline = getSpline(sector, row);
-  const float* splineData = getSplineData(sector, row);
+  const float* splineData = getCorrectionData(sector, row);
 
   auto val = convLocalToGrid(sector, row, y, z);
 
@@ -536,7 +502,7 @@ GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t secto
   const auto& info = getSectorRowInfo(sector, row);
   auto val = convRealLocalToGrid(sector, row, realY, realZ);
   float dx = 0;
-  getSplineInvX(sector, row).interpolateAtU(getSplineDataInvX(sector, row), val[0], val[1], &dx);
+  getSplineInvX(sector, row).interpolateAtU(getCorrectionDataInvX(sector, row), val[0], val[1], &dx);
   dx = val[2] * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
   return dx;
 }
@@ -546,7 +512,7 @@ GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::getCorrectionYZatReal
   auto val = convRealLocalToGrid(sector, row, realY, realZ);
   const auto& info = getSectorRowInfo(sector, row);
   float dyz[2];
-  getSplineInvYZ(sector, row).interpolateAtU(getSplineDataInvYZ(sector, row), val[0], val[1], dyz);
+  getSplineInvYZ(sector, row).interpolateAtU(getCorrectionDataInvYZ(sector, row), val[0], val[1], dyz);
   dyz[0] = val[2] * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
   dyz[1] = val[2] * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
   return {dyz[0], dyz[1]};
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 60f5952e6a1fc..64fdba9d94bd3 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -337,7 +337,7 @@ class TPCFastTransform : public FlatObject
 
   GPUd() void TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransform* ref, const TPCFastTransform* ref2, float scale, float scale2, int32_t scaleMode) const;
 
-  ClassDefNV(TPCFastTransform, 4);
+  ClassDefNV(TPCFastTransform, 5);
 };
 
 // =======================================================================
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
index 5b2dcc8da82d5..2fe773a76e4d3 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
@@ -28,12 +28,10 @@ using namespace o2::gpu;
 TPCFastTransformGeo::TPCFastTransformGeo()
 {
   // Default Constructor: creates an empty uninitialized object
-  double dAlpha = 2. * M_PI / (NumberOfSectorsA);
   for (int32_t i = 0; i < NumberOfSectors; i++) {
-    SectorInfo& s = mSectorInfos[i];
-    double alpha = dAlpha * (i + 0.5);
-    s.sinAlpha = sin(alpha);
-    s.cosAlpha = cos(alpha);
+    double angle = (i + 0.5) * 2. * M_PI / NumberOfSectorsA;
+    mSectorInfos[i].sinAlpha = sin(angle);
+    mSectorInfos[i].cosAlpha = cos(angle);
   }
   mSectorInfos[NumberOfSectors] = SectorInfo{};
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index fc28bbef33602..09793b6677d83 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -19,6 +19,8 @@
 
 #include "GPUCommonDef.h"
 #include "GPUCommonArray.h"
+#include "GPUCommonMath.h"
+
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <memory>
 #include "GPUCommonRtypes.h"
@@ -34,6 +36,7 @@ namespace gpu
 ///
 class TPCFastTransformGeo
 {
+
  public:
   /// The struct contains necessary info for TPC sector
   struct SectorInfo {
@@ -61,7 +64,7 @@ class TPCFastTransformGeo
     /// get width in Y
     GPUd() float getYwidth() const { return -2.f * yMin; }
 
-    ClassDefNV(RowInfo, 1);
+    ClassDefNV(RowInfo, 2);
   };
 
   /// _____________  Constructors / destructors __________________________
@@ -187,6 +190,11 @@ class TPCFastTransformGeo
   SectorInfo mSectorInfos[NumberOfSectors + 1]; ///< array of sector information [fixed size]
   RowInfo mRowInfos[MaxNumberOfRows + 1];       ///< array of row information [fixed size]
 
+ public:
+  struct SliceInfo { // legacy, needed only for schema evolution
+    ClassDefNV(SliceInfo, 2);
+  };
+
   ClassDefNV(TPCFastTransformGeo, 3);
 };
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index 916695a3be1c7..284d5f229d5e0 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -58,19 +58,36 @@
 #pragma link C++ class o2::gpu::SemiregularSpline2D3D + ;
 #pragma link C++ class o2::gpu::IrregularSpline2D3DCalibrator + ;
 
-#pragma link C++ class o2::gpu::TPCFastTransformGeo + ;
+#pragma link C++ class o2::gpu::TPCFastTransformGeo::SliceInfo + ;
 #pragma link C++ class o2::gpu::TPCFastTransformGeo::SectorInfo + ;
+
+#pragma link C++ class o2::gpu::TPCFastTransformGeo + ;
+#pragma read \
+  sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "float mTPCzLengthA; float mTPCzLengthC; float mTPCalignmentZ; float mScaleVtoSVsideA; float mScaleVtoSVsideC; float mScaleSVtoVsideA; float mScaleSVtoVsideC;" version = "[-1]" target = "mTPCzLength" code = "{ mTPCzLength = onfile.mTPCzLengthA; }";
+
+#pragma read \
+  sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "o2::gpu::TPCFastTransformGeo::SliceInfo mSliceInfos[37]" version = "[1-]" target = "" code = "{}";
+
 #pragma link C++ class o2::gpu::TPCFastTransformGeo::RowInfo + ;
+#pragma read \
+  sourceClass = "o2::gpu::TPCFastTransformGeo::RowInfo" targetClass = "o2::gpu::TPCFastTransformGeo::RowInfo" source = "float u0; float scaleUtoSU; float scaleSUtoU" version = "[-2]" target = "yMin" code = "{ yMin = onfile.u0; }"
 
 #pragma link C++ class o2::gpu::TPCFastTransform + ;
 
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrectionMap + ;
-#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RowInfo + ;
 
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection + ;
-#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SectorInfo + ;
+#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SectorRowInfo + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::GridInfo + ;
+#pragma read \
+  sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo mSliceInfo[36]" version = "[-3]" target = "" code = "{}";
+
+#pragma read \
+  sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "size_t mSliceDataSizeBytes[3]" version = "[-3]" target = "mCorrectionDataSize" code = "{ for (int i=0; i<3; i++) mCorrectionDataSize[i] = onfile.mSliceDataSizeBytes[i] * 36; }";
+
+#pragma read \
+  sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "float fInterpolationSafetyMargin" version = "[-3]" target = "" code = "{}";
 
 #pragma link C++ class o2::gpu::CorrectionMapsHelper + ;
 #pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 3cb4812abafc1..baaeca90202d5 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -18,7 +18,7 @@
 
 /// how to run the macro:
 ///
-/// root -l TPCFastTransformInit.C'("debugVoxRes.root")'
+/// root -l TPCFastTransformInit.C'("VoxRes.root", "VoxResInv.root")'
 ///
 
 #if !defined(__CLING__) || defined(__ROOTCLING__)
@@ -45,7 +45,7 @@ using namespace o2::tpc;
 using namespace o2::gpu;
 
 void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char* fileNameInv = "debugVoxResInv.root",
-                          const char* outFileName = "TPCFastTransform_VoxRes.root", bool useSmoothed = false, bool invertSigns = false)
+                          const char* outFileName = "TPCFastTransform_VoxRes.root", bool useSmoothed = false, bool invertSigns = false, bool doDebug = true)
 {
 
   // Initialise TPCFastTransform object from "voxRes" tree of
@@ -56,9 +56,9 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
     To visiualise the results:
 
     root -l transformDebug.root
-    all->Draw("cx:y:z","sec==0&&iRow==10","")
-    grid->Draw("cx:y:z","sec==0&&iRow==10","same")
-    vox->Draw("vx:y:z","sec==0&&iRow==10","same")
+    all->Draw("cx:y:z","sec==0&&row==10","")
+    grid->Draw("cx:y:z","sec==0&&row==10","same")
+    vox->Draw("vx:y:z","sec==0&&row==10","same")
     points->Draw("px:y:z","sec==0&&row==10","same")
   */
 
@@ -112,6 +112,38 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
   trackResiduals.setZ2XBinning(z2xBins);
   trackResiduals.init();
 
+  std::cout << "create fast transformation ... " << std::endl;
+
+  auto* helper = o2::tpc::TPCFastTransformHelperO2::instance();
+
+  o2::tpc::TPCFastSpaceChargeCorrectionHelper* corrHelper = o2::tpc::TPCFastSpaceChargeCorrectionHelper::instance();
+
+  corrHelper->setNthreadsToMaximum();
+  // corrHelper->setNthreads(1);
+
+  if (debugMirrorAdata2C) {
+    corrHelper->setDebugMirrorAdata2C();
+  }
+  // corrHelper->setDebugUseVoxelCenters();
+
+  o2::gpu::TPCFastSpaceChargeCorrectionMap mapDirect(0, 0), mapInverse(0, 0);
+
+  auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, voxResTreeInverse, useSmoothed, invertSigns,
+                                                      &mapDirect, &mapInverse);
+
+  std::unique_ptr<o2::gpu::TPCFastTransform> fastTransform(
+    helper->create(0, *corrPtr));
+
+  std::cout << "... create fast transformation completed " << std::endl;
+
+  if (*outFileName) {
+    fastTransform->writeToFile(outFileName, "ccdb_object");
+  }
+
+  if (!doDebug) {
+    return;
+  }
+
   { // debug output
 
     std::cout << " ===== input track residuals ==== " << std::endl;
@@ -144,40 +176,12 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
     std::cout << " ==================================== " << std::endl;
   }
 
-  std::cout << "create fast transformation ... " << std::endl;
-
-  auto* helper = o2::tpc::TPCFastTransformHelperO2::instance();
-
-  o2::tpc::TPCFastSpaceChargeCorrectionHelper* corrHelper = o2::tpc::TPCFastSpaceChargeCorrectionHelper::instance();
-
-  corrHelper->setNthreadsToMaximum();
-  corrHelper->setNthreads(1);
-
-  if (debugMirrorAdata2C) {
-    corrHelper->setDebugMirrorAdata2C();
-  }
-  // corrHelper->setDebugUseVoxelCenters();
-
-  o2::gpu::TPCFastSpaceChargeCorrectionMap mapDirect(0, 0), mapInverse(0, 0);
-
-  auto corrPtr = corrHelper->createFromTrackResiduals(trackResiduals, voxResTree, voxResTreeInverse, useSmoothed, invertSigns,
-                                                      &mapDirect, &mapInverse);
-
-  std::unique_ptr<o2::gpu::TPCFastTransform> fastTransform(
-    helper->create(0, *corrPtr));
-
-  std::cout << "... create fast transformation completed " << std::endl;
-
-  if (*outFileName) {
-    fastTransform->writeToFile(outFileName, "ccdb_object");
-  }
-
-  if (1) { // read transformation from the file
-
-    // const char* fileName = "master/out.root";
+  if (1) { // read transformation from the output file to verify the io
 
     const char* fileName = outFileName;
 
+    // fileName = "~/test/master/TPCFastTransform_VoxRes.root";
+
     std::cout << "load corrections from file " << fileName << std::endl;
 
     fastTransform->cloneFromObject(*TPCFastTransform::loadFromFile(fileName, "ccdb_object"), nullptr);
@@ -488,11 +492,6 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
           auto [yMin, yMax] = geo.getRowInfo(iRow).getYrange();
           auto [zMin, zMax] = geo.getZrange(iSector);
 
-          points[0].push_back(yMin);
-          points[0].push_back(yMax);
-          points[1].push_back(zMin);
-          points[1].push_back(zMax);
-
           for (int32_t iu = 0; iu < gridY.getNumberOfKnots(); iu++) {
             auto [y, z] = corr.convGridToLocal(iSector, iRow, gridY.getKnot(iu).getU(), 0.);
             knots[0].push_back(y);
@@ -508,12 +507,19 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
             std::sort(knots[iyz].begin(), knots[iyz].end());
             std::sort(points[iyz].begin(), points[iyz].end());
             int32_t n = points[iyz].size();
+            int nsteps = (iyz == 0) ? 10 : 5;
             for (int32_t i = 0; i < n - 1; i++) {
-              double d = (points[iyz][i + 1] - points[iyz][i]) / 10.;
-              for (int32_t ii = 1; ii < 10; ii++) {
+              double d = (points[iyz][i + 1] - points[iyz][i]) / nsteps;
+              for (int32_t ii = 1; ii < nsteps; ii++) {
                 points[iyz].push_back(points[iyz][i] + d * ii);
               }
             }
+          }
+          points[0].push_back(yMin);
+          points[0].push_back(yMax);
+          points[1].push_back(zMin);
+          points[1].push_back(zMax);
+          for (int32_t iyz = 0; iyz <= 1; iyz++) {
             std::sort(points[iyz].begin(), points[iyz].end());
           }
 

From ec3f6ac5a5c209d0167dd68651e57dc6d07f5f03 Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <se.gorbunov@gsi.de>
Date: Wed, 15 Oct 2025 16:36:51 +0200
Subject: [PATCH 1580/1764] Fix compiler-warnings, codechecker violations and
 compilation

Fix compiler warnings on MacOS

Fix compiler warning, memmove must only operate on trivial types

Fix coding rule violations

TPC Splines: compilation fix
---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 15 ++++----
 .../macro/createTPCSpaceChargeCorrection.C    | 34 +++++++++----------
 .../TPCFastSpaceChargeCorrection.cxx          |  2 +-
 .../TPCFastTransformationLinkDef_O2.h         |  4 +--
 .../macro/generateTPCCorrectionNTuple.C       | 21 +++++-------
 5 files changed, 36 insertions(+), 40 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index faba4f2ce065e..7622c40001e1d 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -690,9 +690,9 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
                       LOG(warning) << directionName << " correction: error N " << nErrors << "fitted voxel position is outside the voxel: "
                                    << " sector " << iSector << " row " << iRow << " bin y " << iy << " bin z " << iz
                                    << msg.str();
-                      maxError[0] = GPUCommonMath::Max(maxError[0], fabs(data.mX - x) / dx);
-                      maxError[1] = GPUCommonMath::Max(maxError[1], fabs(data.mY - vox.mY) / vox.mDy);
-                      maxError[2] = GPUCommonMath::Max(maxError[2], fabs(data.mZ - vox.mZ) / vox.mDz);
+                      maxError[0] = GPUCommonMath::Max<double>(maxError[0], fabs(data.mX - x) / dx);
+                      maxError[1] = GPUCommonMath::Max<double>(maxError[1], fabs(data.mY - vox.mY) / vox.mDy);
+                      maxError[2] = GPUCommonMath::Max<double>(maxError[2], fabs(data.mZ - vox.mZ) / vox.mDz);
                     }
                     mutex.unlock();
                   }
@@ -794,12 +794,15 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
           auto addEdge = [&](int iy1, int iz1, int iy2, int iz2, int nPoints) {
             // add n points on the edge between two voxels excluding the voxel points
-            if (nPoints < 1)
+            if (nPoints < 1) {
               return;
-            if (iy1 < 0 || iy1 >= nY2Xbins || iz1 < 0 || iz1 >= nZ2Xbins)
+            }
+            if (iy1 < 0 || iy1 >= nY2Xbins || iz1 < 0 || iz1 >= nZ2Xbins) {
               return;
-            if (iy2 < 0 || iy2 >= nY2Xbins || iz2 < 0 || iz2 >= nZ2Xbins)
+            }
+            if (iy2 < 0 || iy2 >= nY2Xbins || iz2 < 0 || iz2 >= nZ2Xbins) {
               return;
+            }
             auto& data1 = vSectorData[iSector * nRows + iRow][iy1 * nZ2Xbins + iz1];
             auto& vox1 = vRowVoxels[iy1 * nZ2Xbins + iz1];
             auto& data2 = vSectorData[iSector * nRows + iRow][iy2 * nZ2Xbins + iz2];
diff --git a/Detectors/TPC/reconstruction/macro/createTPCSpaceChargeCorrection.C b/Detectors/TPC/reconstruction/macro/createTPCSpaceChargeCorrection.C
index 723cf2ee30491..af066598d1317 100644
--- a/Detectors/TPC/reconstruction/macro/createTPCSpaceChargeCorrection.C
+++ b/Detectors/TPC/reconstruction/macro/createTPCSpaceChargeCorrection.C
@@ -397,10 +397,9 @@ void debugInterpolation(utils::TreeStreamRedirector& pcstream,
                         const o2::gpu::TPCFastTransformGeo& geo,
                         TPCFastTransform* fastTransform)
 {
-  for (int slice = 0; slice < geo.getNumberOfSlices(); slice += 1) {
-    // for (int slice = 21; slice < 22; slice += 1) {
-    std::cout << "debug slice " << slice << " ... " << std::endl;
-    const o2::gpu::TPCFastTransformGeo::SliceInfo& sliceInfo = geo.getSliceInfo(slice);
+  for (int sector = 0; sector < geo.getNumberOfSectors(); sector += 1) {
+    // for (int sector = 21; sector < 22; sector += 1) {
+    std::cout << "debug sector " << sector << " ... " << std::endl;
 
     for (int row = 0; row < geo.getNumberOfRows(); row++) {
       int nPads = geo.getRowInfo(row).maxPad + 1;
@@ -411,28 +410,28 @@ void debugInterpolation(utils::TreeStreamRedirector& pcstream,
           // non-corrected point
           fastTransform->setApplyCorrectionOff();
           float lx, ly, lz;
-          fastTransform->Transform(slice, row, pad, time, lx, ly, lz);
+          fastTransform->Transform(sector, row, pad, time, lx, ly, lz);
           float gx, gy, gz, r, phi;
-          geo.convLocalToGlobal(slice, lx, ly, lz, gx, gy, gz);
+          geo.convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);
           r = std::sqrt(lx * lx + ly * ly);
           phi = std::atan2(gy, gx);
           fastTransform->setApplyCorrectionOn();
 
           // fast transformation
           float lxT, lyT, lzT;
-          fastTransform->Transform(slice, row, pad, time, lxT, lyT, lzT);
+          fastTransform->Transform(sector, row, pad, time, lxT, lyT, lzT);
           float gxT, gyT, gzT, rT;
-          geo.convLocalToGlobal(slice, lxT, lyT, lzT, gxT, gyT, gzT);
+          geo.convLocalToGlobal(sector, lxT, lyT, lzT, gxT, gyT, gzT);
           rT = std::sqrt(lxT * lxT + lyT * lyT);
 
           // the original correction
           double gdC[3] = {0, 0, 0};
-          Side side = slice < geo.getNumberOfSlicesA() ? Side::A : Side::C;
+          Side side = sector < geo.getNumberOfSectorsA() ? Side::A : Side::C;
           if (spaceCharge) {
             spaceCharge->getCorrections(gx, gy, gz, side, gdC[0], gdC[1], gdC[2]);
           }
           float ldxC, ldyC, ldzC;
-          geo.convGlobalToLocal(slice, gdC[0], gdC[1], gdC[2], ldxC, ldyC, ldzC);
+          geo.convGlobalToLocal(sector, gdC[0], gdC[1], gdC[2], ldxC, ldyC, ldzC);
 
           double rC = std::sqrt((gx + gdC[0]) * (gx + gdC[0]) + (gy + gdC[1]) * (gy + gdC[1]));
 
@@ -466,7 +465,7 @@ void debugInterpolation(utils::TreeStreamRedirector& pcstream,
           if (spaceChargeExB) {
             double gdC_ExB[3] = {0, 0, 0};
             spaceChargeExB->getCorrections(gx, gy, gz, side, gdC_ExB[0], gdC_ExB[1], gdC_ExB[2]);
-            geo.convGlobalToLocal(slice, gdC_ExB[0], gdC_ExB[1], gdC_ExB[2], ldxC_ExB, ldyC_ExB, ldzC_ExB);
+            geo.convGlobalToLocal(sector, gdC_ExB[0], gdC_ExB[1], gdC_ExB[2], ldxC_ExB, ldyC_ExB, ldzC_ExB);
           }
 
           // static distortions
@@ -474,18 +473,18 @@ void debugInterpolation(utils::TreeStreamRedirector& pcstream,
           if (spaceChargeStack) {
             double gdC_static[3] = {0, 0, 0};
             spaceChargeStack->getCorrections(gx, gy, gz, side, gdC_static[0], gdC_static[1], gdC_static[2]);
-            geo.convGlobalToLocal(slice, gdC_static[0], gdC_static[1], gdC_static[2], ldxC_static, ldyC_static, ldzC_static);
+            geo.convGlobalToLocal(sector, gdC_static[0], gdC_static[1], gdC_static[2], ldxC_static, ldyC_static, ldzC_static);
           }
 
           // get combined corrections
           double dx_comb = 0, dy_comb = 0, dz_comb = 0;
-          getGlobalSpaceChargeCorrectionLinearCombination(slice, gx, gy, gz, dx_comb, dy_comb, dz_comb);
+          getGlobalSpaceChargeCorrectionLinearCombination(sector, gx, gy, gz, dx_comb, dy_comb, dz_comb);
           float ldxC_comb, ldyC_comb, ldzC_comb;
-          geo.convGlobalToLocal(slice, dx_comb, dy_comb, dz_comb, ldxC_comb, ldyC_comb, ldzC_comb);
+          geo.convGlobalToLocal(sector, dx_comb, dy_comb, dz_comb, ldxC_comb, ldyC_comb, ldzC_comb);
 
           pcstream << "fastTransform"
                    // internal coordinates
-                   << "slice=" << slice
+                   << "sector=" << sector
                    << "row=" << row
                    << "pad=" << pad
                    << "time=" << time
@@ -613,10 +612,9 @@ void debugGridpoints(utils::TreeStreamRedirector& pcstream, const o2::gpu::TPCFa
               break;
             }
           }
-          float u = 0.f, v = 0.f;
-          geo.convLocalToUV(sector, y0, z0, u, v);
+
           float pad = 0.f, time = 0.f;
-          fastTransform->convUVtoPadTime(sector, row, u, v, pad, time, 0.f);
+          fastTransform->convLocalToPadTime(sector, row, y0, z0, pad, time, 0.f);
           if (pad < 0) {
             continue;
           }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 5a2cd21deeb2b..5f39e749f73d9 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -294,7 +294,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
   // move spline scenarios to the new place in the buffer
 
   mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr);
-  memmove(mScenarioPtr, oldScenarioPtr, scenariosSize);
+  memmove((void*)mScenarioPtr, (const void*)oldScenarioPtr, scenariosSize);
 
   size_t oldScenariosBufferOffset = alignSize(oldScenariosOffset + scenariosSize, SplineType::getBufferAlignmentBytes());
   size_t scenariosBufferOffset = alignSize(scenariosSize, SplineType::getBufferAlignmentBytes());
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index 284d5f229d5e0..f1872549a46aa 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -66,11 +66,11 @@
   sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "float mTPCzLengthA; float mTPCzLengthC; float mTPCalignmentZ; float mScaleVtoSVsideA; float mScaleVtoSVsideC; float mScaleSVtoVsideA; float mScaleSVtoVsideC;" version = "[-1]" target = "mTPCzLength" code = "{ mTPCzLength = onfile.mTPCzLengthA; }";
 
 #pragma read \
-  sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "o2::gpu::TPCFastTransformGeo::SliceInfo mSliceInfos[37]" version = "[1-]" target = "" code = "{}";
+  sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "o2::gpu::TPCFastTransformGeo::SliceInfo mSliceInfos[37]" version = "[-2]" target = "" code = "{}";
 
 #pragma link C++ class o2::gpu::TPCFastTransformGeo::RowInfo + ;
 #pragma read \
-  sourceClass = "o2::gpu::TPCFastTransformGeo::RowInfo" targetClass = "o2::gpu::TPCFastTransformGeo::RowInfo" source = "float u0; float scaleUtoSU; float scaleSUtoU" version = "[-2]" target = "yMin" code = "{ yMin = onfile.u0; }"
+  sourceClass = "o2::gpu::TPCFastTransformGeo::RowInfo" targetClass = "o2::gpu::TPCFastTransformGeo::RowInfo" source = "float u0; float scaleUtoSU; float scaleSUtoU" version = "[-1]" target = "yMin" code = "{ yMin = onfile.u0; }"
 
 #pragma link C++ class o2::gpu::TPCFastTransform + ;
 
diff --git a/GPU/TPCFastTransformation/macro/generateTPCCorrectionNTuple.C b/GPU/TPCFastTransformation/macro/generateTPCCorrectionNTuple.C
index 69b7909cda683..2c8f22e4a3f3b 100644
--- a/GPU/TPCFastTransformation/macro/generateTPCCorrectionNTuple.C
+++ b/GPU/TPCFastTransformation/macro/generateTPCCorrectionNTuple.C
@@ -82,7 +82,7 @@ void generateTPCCorrectionNTuple(const char* path = "InputSCDensityHistograms.ro
   const o2::gpu::TPCFastTransformGeo& geo = fastTransform->getGeometry();
 
   TFile* f = new TFile("tpcCorrection.root", "RECREATE");
-  TNtuple* nt = new TNtuple("dist", "dist", "sector:row:su:sv:dx:du:dv");
+  TNtuple* nt = new TNtuple("dist", "dist", "sector:row:x:y:z:dx:dy:dz");
 
   int32_t nSectors = 1; // fastTransform->getNumberOfSectors();
   // for( int32_t sector=0; sector<nSectors; sector++){
@@ -91,13 +91,11 @@ void generateTPCCorrectionNTuple(const char* path = "InputSCDensityHistograms.ro
 
     for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
 
-      float x = geo.getRowInfo(row).x;
+      const auto& rowInfo = geo.getRowInfo(row);
+      float x = rowInfo.x;
 
-      for (float su = 0.; su <= 1.; su += 0.01) {
-        for (float sv = 0.; sv <= 1.; sv += 0.01) {
-          float u, v, y = 0, z = 0;
-          geo.convScaledUVtoUV(sector, row, su, sv, u, v);
-          geo.convUVtoLocal(sector, u, v, y, z);
+      for (float y = rowInfo.getYmin(); y <= rowInfo.getYmax(); y += rowInfo.getYwidth() / 100.) {
+        for (float z = geo.getZmin(sector); z <= geo.getZmax(sector); z += geo.getTPCzLength() / 100.) {
 
           // local 2 global
           float gx, gy, gz;
@@ -112,14 +110,11 @@ void generateTPCCorrectionNTuple(const char* path = "InputSCDensityHistograms.ro
           // global to local
           float x1, y1, z1;
           geo.convGlobalToLocal(sector, gx, gy, gz, x1, y1, z1);
-          float u1 = 0, v1 = 0;
-          geo.convLocalToUV(sector, y1, z1, u1, v1);
 
           float dx = x1 - x;
-          float du = u1 - u;
-          float dv = v1 - v;
-          std::cout << sector << " " << row << " " << su << " " << sv << " " << dx << " " << du << " " << dv << std::endl;
-          nt->Fill(sector, row, su, sv, dx, du, dv);
+          float dy = y1 - y;
+          float dz = z1 - z;
+          nt->Fill(sector, row, x, y, z, dx, dy, dz);
         }
       }
     }

From 1ee89e2ef471b8fa18177ae0873e2185bcff633d Mon Sep 17 00:00:00 2001
From: Sergey Gorbunov <se.gorbunov@gsi.de>
Date: Thu, 5 Feb 2026 09:38:08 +0000
Subject: [PATCH 1581/1764] TPC Splines: keep old cropping scheme

---
 .../TPCFastSpaceChargeCorrection.cxx                  |  4 ++--
 .../TPCFastSpaceChargeCorrection.h                    | 11 +++++++++++
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 5f39e749f73d9..241a1fcfc795b 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -285,8 +285,8 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
         }
 
         newSectorRow.resetMaxValues();
-        newSectorRow.updateMaxValues(-50.f, -50.f, -50.f);
-        newSectorRow.updateMaxValues(50.f, 50.f, 50.f);
+        newSectorRow.updateMaxValues(-100.f, -100.f, -100.f);
+        newSectorRow.updateMaxValues(100.f, 100.f, 100.f);
       }
     }
   }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index b4fab68b91542..b1a3d0c35da7c 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -491,9 +491,14 @@ GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::getCorrectionLocal(in
   float dxyz[3];
   spline.interpolateAtU(splineData, val[0], val[1], dxyz);
 
+  if (CAMath::Abs(dxyz[0]) > 100.f || CAMath::Abs(dxyz[1]) > 100.f || CAMath::Abs(dxyz[2]) > 100.f) {
+    val[2] = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+  }
+
   float dx = val[2] * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
   float dy = val[2] * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
   float dz = val[2] * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
+
   return {dx, dy, dz};
 }
 
@@ -503,6 +508,9 @@ GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t secto
   auto val = convRealLocalToGrid(sector, row, realY, realZ);
   float dx = 0;
   getSplineInvX(sector, row).interpolateAtU(getCorrectionDataInvX(sector, row), val[0], val[1], &dx);
+  if (CAMath::Abs(dx) > 100.f) {
+    val[2] = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+  }
   dx = val[2] * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
   return dx;
 }
@@ -513,6 +521,9 @@ GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::getCorrectionYZatReal
   const auto& info = getSectorRowInfo(sector, row);
   float dyz[2];
   getSplineInvYZ(sector, row).interpolateAtU(getCorrectionDataInvYZ(sector, row), val[0], val[1], dyz);
+  if (CAMath::Abs(dyz[0]) > 100.f || CAMath::Abs(dyz[1]) > 100.f) {
+    val[2] = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+  }
   dyz[0] = val[2] * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
   dyz[1] = val[2] * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
   return {dyz[0], dyz[1]};

From 5627eef4497518181f5bb66188602fd717a06740 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 29 Mar 2026 19:10:08 +0200
Subject: [PATCH 1582/1764] GPU TPC FastTransformation: Do not use std::array

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    |  31 +++--
 .../src/TPCFastTransformHelperO2.cxx          |   3 +-
 GPU/TPCFastTransformation/Spline1DSpec.h      |  38 +++---
 GPU/TPCFastTransformation/Spline2DSpec.h      |  19 ++-
 .../TPCFastSpaceChargeCorrection.cxx          |   6 +-
 .../TPCFastSpaceChargeCorrection.h            | 108 ++++++++++--------
 GPU/TPCFastTransformation/TPCFastTransform.h  |  94 +++++++--------
 .../TPCFastTransformGeo.cxx                   |   6 +-
 .../TPCFastTransformGeo.h                     |  41 ++++---
 .../macro/TPCFastTransformInit.C              |   6 +-
 10 files changed, 178 insertions(+), 174 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 7622c40001e1d..783c1837590b9 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -159,7 +159,8 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
           for (int i = 0; i < nDataPoints; ++i) {
             o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint p = data[i];
             // not corrected grid coordinates
-            auto [gu, gv, scale] = correction.convLocalToGrid(sector, row, p.mY, p.mZ);
+            float gu, gv, scale;
+            correction.convLocalToGrid(sector, row, p.mY, p.mZ, gu, gv, scale);
             if (scale - 1.f > 1.e-6) { // point is outside the grid
               continue;
             }
@@ -300,7 +301,8 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
           double dpad = info.maxPad / (6. * (nKnotsY - 1));
           for (double pad = 0; pad < info.maxPad + .5 * dpad; pad += dpad) {
             for (double l = 0.; l < mGeo.getTPCzLength() + .5 * dl; l += dl) {
-              auto [y, z] = mGeo.convPadDriftLengthToLocal(iSector, iRow, pad, l);
+              float y, z;
+              mGeo.convPadDriftLengthToLocal(iSector, iRow, pad, l, y, z);
               double dx, dy, dz;
               correctionLocal(iSector, iRow, y, z, dx, dy, dz);
               mCorrectionMap.addCorrectionPoint(iSector, iRow,
@@ -360,7 +362,8 @@ void TPCFastSpaceChargeCorrectionHelper::testGeometry(const TPCFastTransformGeo&
     for (int pad = 0; pad < nPads; pad++) {
       const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
       const PadCentre& c = mapper.padCentre(p);
-      auto [y, z] = geo.convPadDriftLengthToLocal(0, row, pad, 0.);
+      float y, z;
+      geo.convPadDriftLengthToLocal(0, row, pad, 0., y, z);
       const double dx = x - c.X();
       const double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map
 
@@ -974,18 +977,20 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
 
         for (int iu = 0; iu < gridU.size(); iu++) {
           for (int iv = 0; iv < gridV.size(); iv++) {
-
-            auto [y, z] = correction.convGridToLocal(sector, row, gridU[iu], gridV[iv]);
+            float y, z;
+            correction.convGridToLocal(sector, row, gridU[iu], gridV[iv], y, z);
             double dx = 0, dy = 0, dz = 0;
 
             // add corrections
             for (int i = 0; i < corrections.size(); ++i) {
-              auto [dxTmp, dyTmp, dzTmp] = corrections[i]->getCorrectionLocal(sector, row, y, z);
+              float dxTmp, dyTmp, dzTmp;
+              corrections[i]->getCorrectionLocal(sector, row, y, z, dxTmp, dyTmp, dzTmp);
               dx += dxTmp * scaling[i];
               dy += dyTmp * scaling[i];
               dz += dzTmp * scaling[i];
             }
-            auto [gridU, gridV, scale] = correction.convRealLocalToGrid(sector, row, y + dy, z + dz);
+            float gridU, gridV, scale;
+            correction.convRealLocalToGrid(sector, row, y + dy, z + dz, gridU, gridV, scale);
             dataPointGridU.push_back(gridU);
             dataPointGridV.push_back(gridV);
             dataPointF.push_back(scale * dx);
@@ -1111,9 +1116,11 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
               float P[nKnotPar3d];
 
               { // direct correction
-                auto [y, z] = mainCorrection.convGridToLocal(sector, row, u, v);
+                float y, z;
+                mainCorrection.convGridToLocal(sector, row, u, v, y, z);
                 // return values: u, v, scaling factor
-                auto [lu, lv, ls] = corr.convLocalToGrid(sector, row, y, z);
+                float lu, lv, ls;
+                corr.convLocalToGrid(sector, row, y, z, lu, lv, ls);
                 ls *= scale;
                 double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * ls * scaleU * scaleV};
                 const auto& spl = corr.getSpline(sector, row);
@@ -1125,9 +1132,11 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
                 }
               }
 
-              auto [y, z] = mainCorrection.convGridToRealLocal(sector, row, u, v);
+              float y, z;
+              mainCorrection.convGridToRealLocal(sector, row, u, v, y, z);
               // return values: u, v, scaling factor
-              auto [lu, lv, ls] = corr.convRealLocalToGrid(sector, row, y, z);
+              float lu, lv, ls;
+              corr.convRealLocalToGrid(sector, row, y, z, lu, lv, ls);
               ls *= scale;
               double parscale[4] = {ls, ls * scaleRealU, ls * scaleRealV, ls * ls * scaleRealU * scaleRealV};
 
diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index 687d4ce707f11..419ced9fa978e 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -203,7 +203,8 @@ void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) cons
       const GlobalPadNumber p = mapper.globalPadNumber(PadPos(row, pad));
       const PadCentre& c = mapper.padCentre(p);
 
-      auto [y, z] = geo.convPadDriftLengthToLocal(0, row, pad, 0.);
+      float y, z;
+      geo.convPadDriftLengthToLocal(0, row, pad, 0., y, z);
 
       const double dx = x - c.X();
       const double dy = y - (-c.Y()); // diferent sign convention for Y coordinate in the map
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index d72de5a446718..56349ba6f454a 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -314,11 +314,9 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
     const auto nYdim = nYdimTmp.get();
 
-    auto val = getSderivativesOverParsAtU<T>(knotL, u);
-    const auto& dSdSl = val[0];
-    const auto& dSdDl = val[1];
-    const auto& dSdSr = val[2];
-    const auto& dSdDr = val[3];
+    T dSdSl, dSdDl, dSdSr, dSdDr;
+    getSderivativesOverParsAtU<T>(knotL, u, dSdSl, dSdDl, dSdSr, dSdDr);
+
     for (int32_t dim = 0; dim < nYdim; ++dim) {
       S[dim] = dSdSr * Sr[dim] + dSdSl * Sl[dim] + dSdDl * Dl[dim] + dSdDr * Dr[dim];
     }
@@ -346,7 +344,7 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
   }
 
   template <typename T>
-  GPUd() std::array<T, 4> getSderivativesOverParsAtU(const Knot& knotL, DataT u) const
+  GPUd() void getSderivativesOverParsAtU(const Knot& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline parameters Sl(eft), Sr(ight) and the slopes Dl, Dr
@@ -363,16 +361,15 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     T vm1 = v - T(1.);
     T a = u * vm1;
     T v2 = v * v;
-    T dSdSr = v2 * (T(3.) - v - v);
-    T dSdSl = T(1.) - dSdSr;
-    T dSdDl = vm1 * a;
-    T dSdDr = v * a;
+    dSdSr = v2 * (T(3.) - v - v);
+    dSdSl = T(1.) - dSdSr;
+    dSdDl = vm1 * a;
+    dSdDr = v * a;
     // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
-    return {dSdSl, dSdDl, dSdSr, dSdDr};
   }
 
   template <typename T>
-  GPUd() std::array<T, 8> getSDderivativesOverParsAtU(const Knot& knotL, DataT u) const
+  GPUd() void getSDderivativesOverParsAtU(const Knot& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr, T& dDdSl, T& dDdDl, T& dDdSr, T& dDdDr) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline values Sl, Sr and the slopes Dl, Dr
@@ -389,19 +386,18 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     T vm1 = v - T(1.);
     T a = u * vm1;
     T v2 = v * v;
-    T dSdSr = v2 * (T(3.) - v - v);
-    T dSdSl = T(1.) - dSdSr;
-    T dSdDl = vm1 * a;
-    T dSdDr = v * a;
+    dSdSr = v2 * (T(3.) - v - v);
+    dSdSl = T(1.) - dSdSr;
+    dSdDl = vm1 * a;
+    dSdDr = v * a;
 
     T dv = T(knotL.Li);
-    T dDdSr = 6. * v * (T(1.) - v) * dv;
-    T dDdSl = -dDdSr;
-    T dDdDl = vm1 * (v + v + vm1);
-    T dDdDr = v * (v + vm1 + vm1);
+    dDdSr = 6. * v * (T(1.) - v) * dv;
+    dDdSl = -dDdSr;
+    dDdDl = vm1 * (v + v + vm1);
+    dDdDr = v * (v + vm1 + vm1);
     // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
     // D(u) = dS(u)/du = dDdSl * Sl + dDdSr * Sr + dDdDl * Dl + dDdDr * Dr;
-    return {dSdSl, dSdDl, dSdSr, dSdDr, dDdSl, dDdDl, dDdSr, dDdDr};
   }
 
   using TBase::convXtoU;
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index 5681de2dc5fe9..fc53767ed6d07 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -334,16 +334,9 @@ class Spline2DSpec<DataT, YdimT, 0>
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
 
-    auto val1 = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
-    auto val2 = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
-    const auto& dSl = val1[0];
-    const auto& dDl = val1[1];
-    const auto& dSr = val1[2];
-    const auto& dDr = val1[3];
-    const auto& dSd = val2[0];
-    const auto& dDd = val2[1];
-    const auto& dSu = val2[2];
-    const auto& dDu = val2[3];
+    DataT dSl, dDl, dSr, dDr, dSd, dDd, dSu, dDu;
+    mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u, dSl, dDl, dSr, dDr);
+    mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v, dSd, dDd, dSu, dDu);
 
     // when nYdim == 1:
     // S = dSl * (dSd * A[0] + dDd * A[1]) + dDl * (dSd * A[2] + dDd * A[3]) +
@@ -398,8 +391,10 @@ class Spline2DSpec<DataT, YdimT, 0>
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
 
-    auto [dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr] = mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u);
-    auto [dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu] = mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v);
+    DataT dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr;
+    mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u, dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr);
+    DataT dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu;
+    mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v, dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu);
 
     // when nYdim == 1:
 
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 241a1fcfc795b..5f5943a00372e 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -731,7 +731,8 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
       MaxValue maxDrow[3];
       for (double y = y0; y < y1; y += stepY) {
         for (double z = z0; z < z1; z += stepZ) {
-          auto [dx, dy, dz] = getCorrectionLocal(sector, row, y, z);
+          float dx, dy, dz;
+          getCorrectionLocal(sector, row, y, z, dx, dy, dz);
           double realX = x + dx;
           double realY = y + dy;
           double realZ = z + dz;
@@ -745,7 +746,8 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
             continue;
           }
           float dxr = getCorrectionXatRealYZ(sector, row, realY, realZ);
-          auto [dyr, dzr] = getCorrectionYZatRealYZ(sector, row, realY, realZ);
+          float dyr, dzr;
+          getCorrectionYZatRealYZ(sector, row, realY, realZ, dyr, dzr);
           double d[3] = {dxr - dx, dyr - dy, dzr - dz};
           for (int32_t i = 0; i < 3; i++) {
             maxDrow[i].update(d[i], sector, row);
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index b1a3d0c35da7c..2a94154591533 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -22,6 +22,9 @@
 #include "FlatObject.h"
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include "GPUCommonArray.h" // Would work on GPU, but yields performance regressions
+#endif
 
 namespace o2
 {
@@ -76,15 +79,18 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     }
 
     /// convert local y, z to internal grid coordinates u,v, and spline scale
-    GPUd() std::array<float, 3> convLocalToGridUntruncated(float y, float z) const
+    GPUd() void convLocalToGridUntruncated(float y, float z, float& u, float& v, float& s) const
     {
-      return {(y - y0) * yScale, (z - z0) * zScale, getSpineScaleForZ(z)};
+      u = (y - y0) * yScale;
+      v = (z - z0) * zScale;
+      s = getSpineScaleForZ(z);
     }
 
     /// convert internal grid coordinates u,v to local y, z
-    std::array<float, 2> convGridToLocal(float gridU, float gridV) const
+    GPUd() void convGridToLocal(float gridU, float gridV, float& y, float& z) const
     {
-      return {y0 + gridU / yScale, z0 + gridV / zScale};
+      y = y0 + gridU / yScale;
+      z = z0 + gridV / zScale;
     }
     ClassDefNV(GridInfo, 1);
   };
@@ -121,6 +127,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
       maxCorr[2] = GPUCommonMath::Max(maxCorr[2], dv);
     }
 
+#ifndef GPUCA_GPUCODE_DEVICE
     void updateMaxValues(std::array<float, 3> dxdudv, float scale)
     {
       float dx = dxdudv[0] * scale;
@@ -138,6 +145,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     {
       return {minCorr[0], minCorr[1], minCorr[2]};
     }
+#endif
 
     ClassDefNV(SectorRowInfo, 2);
   };
@@ -249,31 +257,31 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   ///
   // GPUd() int32_t getCorrectionInternal(int32_t sector, int32_t row, float u, float v, float& dx, float& du, float& dv) const;
 
-  GPUdi() std::array<float, 3> getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const;
+  GPUdi() void getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const;
 
   /// inverse correction: Real Y and Z -> Real X
   GPUd() float getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
 
   /// inverse correction: Real Y and Z -> measred Y and Z
-  GPUd() std::array<float, 2> getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
+  GPUd() void getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ, float& y, float& z) const;
 
   /// _______________  Utilities  _______________________________________________
 
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
-  GPUd() std::array<float, 3> convLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
+  GPUd() void convLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const;
 
   /// convert internal grid coordinates u,v to local y, z
   /// return values: y, z, scaling factor
-  GPUd() std::array<float, 2> convGridToLocal(int32_t sector, int32_t row, float u, float v) const;
+  GPUd() void convGridToLocal(int32_t sector, int32_t row, float u, float v, float& y, float& z) const;
 
   /// convert real Y, Z to the internal grid coordinates
   /// return values: u, v, scaling factor
-  GPUd() std::array<float, 3> convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const;
+  GPUd() void convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const;
 
   /// convert internal grid coordinates to the real Y, Z
   /// return values: y, z
-  GPUd() std::array<float, 2> convGridToRealLocal(int32_t sector, int32_t row, float u, float v) const;
+  GPUd() void convGridToRealLocal(int32_t sector, int32_t row, float u, float v, float& y, float& z) const;
 
   GPUd() bool isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
   GPUd() bool isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
@@ -419,26 +427,26 @@ GPUdi() const float* TPCFastSpaceChargeCorrection::getCorrectionDataInvYZ(int32_
   return getCorrectionData(sector, row, 2);
 }
 
-GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32_t row, float y, float z) const
+GPUdi() void TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const
 {
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
   const SplineType& spline = getSpline(sector, row);
-  auto val = getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z);
+  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z, u, v, s);
   // shrink to the grid
-  val[0] = GPUCommonMath::Clamp(val[0], 0.f, (float)spline.getGridX1().getUmax());
-  val[1] = GPUCommonMath::Clamp(val[1], 0.f, (float)spline.getGridX2().getUmax());
-  return val;
+  u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
+  v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
 }
 
 GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// check if local y, z are inside the grid
-  auto val = getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z);
+  float u, v, s;
+  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z, u, v, s);
   const auto& spline = getSpline(sector, row);
   // shrink to the grid
-  if (val[0] < 0.f || val[0] > (float)spline.getGridX1().getUmax() || //
-      val[1] < 0.f || val[1] > (float)spline.getGridX2().getUmax()) {
+  if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
+      v < 0.f || v > (float)spline.getGridX2().getUmax()) {
     return false;
   }
   return true;
@@ -447,86 +455,86 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int
 GPUdi() bool TPCFastSpaceChargeCorrection::isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// check if local y, z are inside the grid
-  auto val = getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z);
+  float u, v, s;
+  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z, u, v, s);
   const auto& spline = getSpline(sector, row);
   // shrink to the grid
-  if (val[0] < 0.f || val[0] > (float)spline.getGridX1().getUmax() || //
-      val[1] < 0.f || val[1] > (float)spline.getGridX2().getUmax()) {
+  if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
+      v < 0.f || v > (float)spline.getGridX2().getUmax()) {
     return false;
   }
   return true;
 }
 
-GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV) const
+GPUdi() void TPCFastSpaceChargeCorrection::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to local y, z
-  return getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(gridU, gridV);
+  getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(gridU, gridV, y, z);
 }
 
-GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z) const
+GPUdi() void TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const
 {
   /// convert real y, z to the internal grid coordinates + scale
   const SplineType& spline = getSpline(sector, row);
-  auto val = getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z);
+  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z, u, v, s);
   // shrink to the grid
-  val[0] = GPUCommonMath::Clamp(val[0], 0.f, (float)spline.getGridX1().getUmax());
-  val[1] = GPUCommonMath::Clamp(val[1], 0.f, (float)spline.getGridX2().getUmax());
-  return val;
+  u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
+  v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
 }
 
-GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV) const
+GPUdi() void TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to the real y, z
-  return getSectorRowInfo(sector, row).gridReal.convGridToLocal(gridU, gridV);
+  getSectorRowInfo(sector, row).gridReal.convGridToLocal(gridU, gridV, y, z);
 }
 
-GPUdi() std::array<float, 3> TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z) const
+GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const
 {
   const auto& info = getSectorRowInfo(sector, row);
   const SplineType& spline = getSpline(sector, row);
   const float* splineData = getCorrectionData(sector, row);
 
-  auto val = convLocalToGrid(sector, row, y, z);
+  float u, v, s;
+  convLocalToGrid(sector, row, y, z, u, v, s);
 
   float dxyz[3];
-  spline.interpolateAtU(splineData, val[0], val[1], dxyz);
+  spline.interpolateAtU(splineData, u, v, dxyz);
 
   if (CAMath::Abs(dxyz[0]) > 100.f || CAMath::Abs(dxyz[1]) > 100.f || CAMath::Abs(dxyz[2]) > 100.f) {
-    val[2] = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
 
-  float dx = val[2] * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
-  float dy = val[2] * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
-  float dz = val[2] * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
-
-  return {dx, dy, dz};
+  dx = s * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
+  dy = s * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
+  dz = s * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
 }
 
 GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
   const auto& info = getSectorRowInfo(sector, row);
-  auto val = convRealLocalToGrid(sector, row, realY, realZ);
+  float u, v, s;
+  convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
   float dx = 0;
-  getSplineInvX(sector, row).interpolateAtU(getCorrectionDataInvX(sector, row), val[0], val[1], &dx);
+  getSplineInvX(sector, row).interpolateAtU(getCorrectionDataInvX(sector, row), u, v, &dx);
   if (CAMath::Abs(dx) > 100.f) {
-    val[2] = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
-  dx = val[2] * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
+  dx = s * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
   return dx;
 }
 
-GPUdi() std::array<float, 2> TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
+GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ, float& y, float& z) const
 {
-  auto val = convRealLocalToGrid(sector, row, realY, realZ);
+  float u, v, s;
+  convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
   const auto& info = getSectorRowInfo(sector, row);
   float dyz[2];
-  getSplineInvYZ(sector, row).interpolateAtU(getCorrectionDataInvYZ(sector, row), val[0], val[1], dyz);
+  getSplineInvYZ(sector, row).interpolateAtU(getCorrectionDataInvYZ(sector, row), u, v, dyz);
   if (CAMath::Abs(dyz[0]) > 100.f || CAMath::Abs(dyz[1]) > 100.f) {
-    val[2] = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
-  dyz[0] = val[2] * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
-  dyz[1] = val[2] * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
-  return {dyz[0], dyz[1]};
+  y = s * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
+  z = s * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
 }
 
 } // namespace gpu
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 64fdba9d94bd3..532ec855c77b0 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -349,17 +349,13 @@ class TPCFastTransform : public FlatObject
 GPUdi() void TPCFastTransform::convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const
 {
   float l = (time - mT0 - vertexTime) * mVdrift; // drift length [cm]
-  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
-  y = localval[0];
-  z = localval[1];
+  getGeometry().convPadDriftLengthToLocal(sector, row, pad, l, y, z);
 }
 
 GPUdi() void TPCFastTransform::convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const
 {
   float l = getGeometry().getTPCzLength() + (time - mT0 - maxTimeBin) * mVdrift; // drift length [cm]
-  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
-  y = localval[0];
-  z = localval[1];
+  getGeometry().convPadDriftLengthToLocal(sector, row, pad, l, y, z);
 }
 
 // ----------------------------------------------------------------------
@@ -391,16 +387,16 @@ GPUdi() float TPCFastTransform::convDriftLengthToTime(float driftLength, float v
 
 GPUdi() void TPCFastTransform::convLocalToPadTime(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float vertexTime) const
 {
-  const auto padLength = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
-  pad = padLength[0];
-  time = convDriftLengthToTime(padLength[1], vertexTime);
+  float l;
+  getGeometry().convLocalToPadDriftLength(sector, row, y, z, pad, l);
+  time = convDriftLengthToTime(l, vertexTime);
 }
 
 GPUdi() void TPCFastTransform::convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const
 {
-  const auto padLength = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
-  pad = padLength[0];
-  time = convDriftLengthToTime(padLength[1], maxTimeBin);
+  float l;
+  getGeometry().convLocalToPadDriftLength(sector, row, y, z, pad, l);
+  time = convDriftLengthToTime(l, maxTimeBin);
 }
 
 // ----------------------------------------------------------------------
@@ -426,28 +422,28 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t sector, int32_t row, float
     } else
 #endif // GPUCA_GPUCODE
     {
-      const auto corrLocal = mCorrection.getCorrectionLocal(sector, row, y, z);
-      dx = corrLocal[0];
-      dy = corrLocal[1];
-      dz = corrLocal[2];
+      mCorrection.getCorrectionLocal(sector, row, y, z, dx, dy, dz);
       if (ref) {
         if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
-          auto val = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
-          dx = (dx - val[0]) * scale + val[0];
-          dy = (dy - val[1]) * scale + val[1];
-          dz = (dz - val[2]) * scale + val[2];
+          float dx1, dy1, dz1;
+          ref->mCorrection.getCorrectionLocal(sector, row, y, z, dx1, dy1, dz1);
+          dx = (dx - dx1) * scale + dx1;
+          dy = (dy - dy1) * scale + dy1;
+          dz = (dz - dz1) * scale + dz1;
         } else if ((scale != 0.f) && ((scaleMode == 1) || (scaleMode == 2))) {
-          auto val = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
-          dx = val[0] * scale + dx;
-          dy = val[1] * scale + dy;
-          dz = val[2] * scale + dz;
+          float dx1, dy1, dz1;
+          ref->mCorrection.getCorrectionLocal(sector, row, y, z, dx1, dy1, dz1);
+          dx = dx1 * scale + dx;
+          dy = dy1 * scale + dy;
+          dz = dz1 * scale + dz;
         }
       }
       if (ref2 && (scale2 != 0)) {
-        auto val = ref2->mCorrection.getCorrectionLocal(sector, row, y, z);
-        dx = val[0] * scale2 + dx;
-        dy = val[1] * scale2 + dy;
-        dz = val[2] * scale2 + dz;
+        float dx1, dy1, dz1;
+        ref2->mCorrection.getCorrectionLocal(sector, row, y, z, dx1, dy1, dz1);
+        dx = dx1 * scale2 + dx;
+        dy = dy1 * scale2 + dy;
+        dz = dz1 * scale2 + dz;
       }
     }
   }
@@ -478,21 +474,16 @@ GPUdi() void TPCFastTransform::TransformLocal(int32_t sector, int32_t row, float
 
     float dxRef = 0.f, dyRef = 0.f, dzRef = 0.f;
     if (ref) {
-      const auto corr = ref->mCorrection.getCorrectionLocal(sector, row, y, z);
-      dxRef = corr[0];
-      dyRef = corr[1];
-      dzRef = corr[2];
+      ref->mCorrection.getCorrectionLocal(sector, row, y, z, dxRef, dyRef, dzRef);
     }
 
     float dxRef2 = 0.f, dyRef2 = 0.f, dzRef2 = 0.f;
     if (ref2) {
-      const auto corr = ref2->mCorrection.getCorrectionLocal(sector, row, y, z);
-      dxRef2 = corr[0];
-      dyRef2 = corr[1];
-      dzRef2 = corr[2];
+      ref2->mCorrection.getCorrectionLocal(sector, row, y, z, dxRef2, dyRef2, dzRef2);
     }
 
-    auto [dxOrig, dyOrig, dzOrig] = mCorrection.getCorrectionLocal(sector, row, y, z);
+    float dxOrig, dyOrig, dzOrig;
+    mCorrection.getCorrectionLocal(sector, row, y, z, dxOrig, dyOrig, dzOrig);
 
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
                                                                                        // corrections in x, u, v
@@ -617,9 +608,7 @@ GPUdi() void TPCFastTransform::TransformIdeal(int32_t sector, int32_t row, float
 
   x = getGeometry().getRowInfo(row).x;
   float driftLength = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength);
-  y = localval[0];
-  z = localval[1];
+  getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength, y, z);
 }
 
 GPUdi() float TPCFastTransform::convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const
@@ -726,24 +715,25 @@ GPUdi() void TPCFastTransform::InverseTransformYZtoNominalYZ(int32_t sector, int
   float dz = 0;
 
   if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    const auto corrYZ = mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
-    dy = corrYZ[0];
-    dz = corrYZ[1];
+    mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ, dy, dz);
 
     if (ref) { // scaling was requested
       if (scaleMode == 0 && scale > 0.f) {
-        const auto val = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
-        dy = (dy - val[0]) * scale + val[0];
-        dz = (dz - val[1]) * scale + val[1];
+        float dy1, dz1;
+        ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ, dy1, dz1);
+        dy = (dy - dy1) * scale + dy1;
+        dz = (dz - dz1) * scale + dz1;
       } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
-        const auto val = ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
-        dy = val[0] * scale + dy;
-        dz = val[1] * scale + dz;
+        float dy1, dz1;
+        ref->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ, dy1, dz1);
+        dy = dy1 * scale + dy;
+        dz = dz1 * scale + dz;
       }
       if (ref2 && (scale2 != 0)) {
-        const auto val = ref2->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ);
-        dy = val[0] * scale2 + dy;
-        dz = val[1] * scale2 + dz;
+        float dy1, dz1;
+        ref2->mCorrection.getCorrectionYZatRealYZ(sector, row, realY, realZ, dy1, dz1);
+        dy = dy1 * scale2 + dy;
+        dz = dz1 * scale2 + dz;
       }
     }
   }
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
index 2fe773a76e4d3..c7ed4243d7396 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
@@ -145,8 +145,10 @@ int32_t TPCFastTransformGeo::test(int32_t sector, int32_t row, float ly, float l
     error = -3;
   }
 
-  auto [pad, length] = convLocalToPadDriftLength(sector, 10, ly, lz);
-  auto [ly2, lz2] = convPadDriftLengthToLocal(sector, 10, pad, length);
+  float pad, length;
+  convLocalToPadDriftLength(sector, 10, ly, lz, pad, length);
+  float ly2, lz2;
+  convPadDriftLengthToLocal(sector, 10, pad, length, ly2, lz2);
 
   if (fabs(ly2 - ly) + fabs(lz2 - lz) > 1.e-6) {
     LOG(info) << "Error local <-> UV: y " << ly << " dy " << ly2 - ly << " z " << lz << " dz " << lz2 - lz;
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 09793b6677d83..55e36cf6efef7 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -18,12 +18,12 @@
 #define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTTRANSFORMGEO_H
 
 #include "GPUCommonDef.h"
-#include "GPUCommonArray.h"
 #include "GPUCommonMath.h"
 
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <memory>
 #include "GPUCommonRtypes.h"
+#include "GPUCommonArray.h" // Would work on GPU, but yields performance regressions
 #endif
 
 namespace o2
@@ -59,7 +59,9 @@ class TPCFastTransformGeo
     GPUd() float getYmax() const { return -yMin; }
 
     /// get Y range
+#ifndef GPUCA_GPUCODE_DEVICE
     GPUd() std::array<float, 2> getYrange() const { return {getYmin(), getYmax()}; }
+#endif
 
     /// get width in Y
     GPUd() float getYwidth() const { return -2.f * yMin; }
@@ -129,7 +131,17 @@ class TPCFastTransformGeo
   GPUd() float getTPCzLength() const { return mTPCzLength; }
 
   /// Gives Z range for the corresponding TPC side
-  GPUd() std::array<float, 2> getZrange(int32_t sector) const;
+#ifndef GPUCA_GPUCODE_DEVICE
+  GPUdi() std::array<float, 2> getZrange(int32_t sector) const
+  {
+    /// z range for the sector
+    if (sector < NumberOfSectorsA) { // TPC side A
+      return {0.f, mTPCzLength};
+    } else { // TPC side C
+      return {-mTPCzLength, 0.f};
+    }
+  }
+#endif
   GPUd() float getZmin(int32_t sector) const;
   GPUd() float getZmax(int32_t sector) const;
   GPUd() float getZreadout(int32_t sector) const;
@@ -143,7 +155,7 @@ class TPCFastTransformGeo
   GPUd() void convGlobalToLocal(int32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
 
   /// convert Pad, DriftLength -> Local c.s.
-  GPUd() std::array<float, 2> convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const;
+  GPUd() void convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength, float& y, float& z) const;
 
   /// convert DriftLength -> Local c.s.
   GPUd() float convDriftLengthToZ1(int32_t sector, float driftLength) const;
@@ -152,7 +164,7 @@ class TPCFastTransformGeo
   GPUd() float convZtoDriftLength1(int32_t sector, float z) const;
 
   /// convert Local c.s. -> Pad, DriftLength
-  GPUd() std::array<float, 2> convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const;
+  GPUd() void convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z, float& pad, float& l) const;
 
   /// Print method
   void print() const;
@@ -238,12 +250,11 @@ GPUdi() void TPCFastTransformGeo::convGlobalToLocal(int32_t sector, float gx, fl
   lz = gz;
 }
 
-GPUdi() std::array<float, 2> TPCFastTransformGeo::convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength) const
+GPUdi() void TPCFastTransformGeo::convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength, float& y, float& z) const
 {
   /// convert Pad, DriftLength -> Local c.s.
   const RowInfo& rowInfo = getRowInfo(row);
   float u = (pad - 0.5f * rowInfo.maxPad) * rowInfo.padWidth;
-  float y, z;
   if (sector < NumberOfSectorsA) { // TPC side A
     y = u;
     z = mTPCzLength - driftLength;
@@ -251,7 +262,6 @@ GPUdi() std::array<float, 2> TPCFastTransformGeo::convPadDriftLengthToLocal(int3
     y = -u;                        // pads are mirrorred on C-side
     z = driftLength - mTPCzLength; // drift direction is mirrored on C-side
   }
-  return {y, z};
 }
 
 GPUdi() float TPCFastTransformGeo::convDriftLengthToZ1(int32_t sector, float driftLength) const
@@ -266,16 +276,6 @@ GPUdi() float TPCFastTransformGeo::convZtoDriftLength1(int32_t sector, float z)
   return (sector < NumberOfSectorsA) ? (mTPCzLength - z) : (z + mTPCzLength);
 }
 
-GPUdi() std::array<float, 2> TPCFastTransformGeo::getZrange(int32_t sector) const
-{
-  /// z range for the sector
-  if (sector < NumberOfSectorsA) { // TPC side A
-    return {0.f, mTPCzLength};
-  } else { // TPC side C
-    return {-mTPCzLength, 0.f};
-  }
-}
-
 GPUdi() float TPCFastTransformGeo::getZmin(int32_t sector) const
 {
   /// z min for the sector
@@ -306,10 +306,10 @@ GPUdi() float TPCFastTransformGeo::getZreadout(int32_t sector) const
   }
 }
 
-GPUdi() std::array<float, 2> TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z) const
+GPUdi() void TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z, float& pad, float& l) const
 {
   /// convert Local c.s. -> Pad, DriftLength
-  float u, l;
+  float u;
   if (sector < NumberOfSectorsA) { // TPC side A
     u = y;
     l = mTPCzLength - z;
@@ -318,8 +318,7 @@ GPUdi() std::array<float, 2> TPCFastTransformGeo::convLocalToPadDriftLength(int3
     l = z + mTPCzLength; // drift direction is mirrored on C-side
   }
   const TPCFastTransformGeo::RowInfo& rowInfo = getRowInfo(row);
-  float pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
-  return {pad, l};
+  pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
 }
 
 } // namespace gpu
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index baaeca90202d5..bc6fafbaa8bd0 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -493,12 +493,14 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
           auto [zMin, zMax] = geo.getZrange(iSector);
 
           for (int32_t iu = 0; iu < gridY.getNumberOfKnots(); iu++) {
-            auto [y, z] = corr.convGridToLocal(iSector, iRow, gridY.getKnot(iu).getU(), 0.);
+            float y, z;
+            corr.convGridToLocal(iSector, iRow, gridY.getKnot(iu).getU(), 0., y, z);
             knots[0].push_back(y);
             points[0].push_back(y);
           }
           for (int32_t iv = 0; iv < gridZ.getNumberOfKnots(); iv++) {
-            auto [y, z] = corr.convGridToLocal(iSector, iRow, 0., gridZ.getKnot(iv).getU());
+            float y, z;
+            corr.convGridToLocal(iSector, iRow, 0., gridZ.getKnot(iv).getU(), y, z);
             knots[1].push_back(z);
             points[1].push_back(z);
           }

From 124fd41b563e455f82b45daee47c064d87a5d5f8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 31 Mar 2026 11:56:27 +0200
Subject: [PATCH 1583/1764] GPU TPCFastTransformation: Do not use double

---
 GPU/TPCFastTransformation/Spline1DSpec.h                 | 4 ++--
 GPU/TPCFastTransformation/Spline2DSpec.h                 | 2 +-
 GPU/TPCFastTransformation/SplineSpec.h                   | 2 +-
 GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 56349ba6f454a..3a2b5d0c4ee32 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -392,7 +392,7 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
     dSdDr = v * a;
 
     T dv = T(knotL.Li);
-    dDdSr = 6. * v * (T(1.) - v) * dv;
+    dDdSr = T(6.) * v * (T(1.) - v) * dv;
     dDdSl = -dDdSr;
     dDdDl = vm1 * (v + v + vm1);
     dDdDr = v * (v + vm1 + vm1);
@@ -567,7 +567,7 @@ class Spline1DSpec<DataT, 1, 3>
   /// Simplified interface for 1D: return the interpolated value
   GPUd() DataT interpolate(DataT x) const
   {
-    DataT S = 0.;
+    DataT S = 0;
     TBase::interpolate(x, &S);
     return S;
   }
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index fc53767ed6d07..d0648f2afa22b 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -659,7 +659,7 @@ class Spline2DSpec<DataT, 1, 3>
   /// Simplified interface for 1D: return the interpolated value
   GPUd() DataT interpolate(DataT x1, DataT x2) const
   {
-    DataT S = 0.;
+    DataT S = 0;
     TBase::interpolate(x1, x2, &S);
     return S;
   }
diff --git a/GPU/TPCFastTransformation/SplineSpec.h b/GPU/TPCFastTransformation/SplineSpec.h
index 2102b73e72900..31b6bef22103c 100644
--- a/GPU/TPCFastTransformation/SplineSpec.h
+++ b/GPU/TPCFastTransformation/SplineSpec.h
@@ -537,7 +537,7 @@ class SplineSpec<DataT, XdimT, 1, 3>
   /// Simplified interface for 1D: return the interpolated value
   GPUd() DataT interpolate(const DataT x[]) const
   {
-    DataT S = 0.;
+    DataT S = 0;
     TBase::interpolate(x, &S);
     return S;
   }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 2a94154591533..12dc5c2fdee54 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -65,7 +65,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
       this->zScale = zScale_;
       this->zOut = zOut_;
       // no scaling when the distance to the readout is too small
-      this->splineScalingWithZ = fabs(zReadout_ - zOut_) > 1. ? 1. / (zReadout_ - zOut_) : 0.;
+      this->splineScalingWithZ = fabs(zReadout_ - zOut_) > 1.f ? 1.f / (zReadout_ - zOut_) : 0.f;
     }
 
     float getY0() const { return y0; }

From 8b79a844836b0bc779424a6fa08f36e93432523e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 1 Apr 2026 12:02:34 +0200
Subject: [PATCH 1584/1764] GPU TPCFastTransfomration: Add missing inline
 keywords

---
 .../TPCFastSpaceChargeCorrection.h            | 14 +++++-----
 GPU/TPCFastTransformation/TPCFastTransform.h  | 26 +++++++++----------
 .../TPCFastTransformGeo.h                     | 16 ++++++------
 3 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 12dc5c2fdee54..6dcf30b2991ba 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -73,13 +73,13 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     float getZ0() const { return z0; }
     float getZscale() const { return zScale; }
 
-    GPUd() float getSpineScaleForZ(float z) const
+    GPUdi() float getSpineScaleForZ(float z) const
     {
       return 1.f - GPUCommonMath::Clamp((z - zOut) * splineScalingWithZ, 0.f, 1.f);
     }
 
     /// convert local y, z to internal grid coordinates u,v, and spline scale
-    GPUd() void convLocalToGridUntruncated(float y, float z, float& u, float& v, float& s) const
+    GPUdi() void convLocalToGridUntruncated(float y, float z, float& u, float& v, float& s) const
     {
       u = (y - y0) * yScale;
       v = (z - z0) * zScale;
@@ -87,7 +87,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     }
 
     /// convert internal grid coordinates u,v to local y, z
-    GPUd() void convGridToLocal(float gridU, float gridV, float& y, float& z) const
+    GPUdi() void convGridToLocal(float gridU, float gridV, float& y, float& z) const
     {
       y = y0 + gridU / yScale;
       z = z0 + gridV / zScale;
@@ -215,7 +215,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() void setNoCorrection();
 
   /// Sets the time stamp of the current calibaration
-  GPUd() void setTimeStamp(int64_t v) { mTimeStamp = v; }
+  GPUdi() void setTimeStamp(int64_t v) { mTimeStamp = v; }
 
   /// Gives const pointer to a spline
   GPUd() const SplineType& getSpline(int32_t sector, int32_t row) const;
@@ -287,7 +287,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() bool isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
 
   /// TPC geometry information
-  GPUd() const TPCFastTransformGeo& getGeometry() const
+  GPUdi() const TPCFastTransformGeo& getGeometry() const
   {
     return mGeo;
   }
@@ -296,13 +296,13 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   int64_t getTimeStamp() const { return mTimeStamp; }
 
   /// Gives TPC sector & row info
-  GPUd() const SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) const
+  GPUdi() const SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) const
   {
     return mSectorRowInfos[mGeo.getMaxNumberOfRows() * sector + row];
   }
 
   /// Gives TPC sector & row info
-  GPUd() SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row)
+  GPUdi() SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row)
   {
     return mSectorRowInfos[mGeo.getMaxNumberOfRows() * sector + row];
   }
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 532ec855c77b0..068c85b13836a 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -53,7 +53,7 @@ struct TPCSlowSpaceChargeCorrection {
   ~TPCSlowSpaceChargeCorrection() = default;
 
   /// setting dummy corrections for GPU
-  GPUd() void getCorrections(const float gx, const float gy, const float gz, const int32_t sector, float& gdxC, float& gdyC, float& gdzC) const
+  GPUdi() void getCorrections(const float gx, const float gy, const float gz, const int32_t sector, float& gdxC, float& gdyC, float& gdzC) const
   {
     gdxC = 0;
     gdyC = 0;
@@ -172,7 +172,7 @@ class TPCFastTransform : public FlatObject
   void setTimeStamp(int64_t v) { mTimeStamp = v; }
 
   /// Gives a reference for external initialization of TPC corrections
-  GPUd() const TPCFastSpaceChargeCorrection& getCorrection() const { return mCorrection; }
+  GPUdi() const TPCFastSpaceChargeCorrection& getCorrection() const { return mCorrection; }
 
   /// Gives a reference for external initialization of TPC corrections
   TPCFastSpaceChargeCorrection& getCorrection() { return mCorrection; }
@@ -230,37 +230,37 @@ class TPCFastTransform : public FlatObject
   /// _______________  Utilities  _______________________________________________
 
   /// TPC geometry information
-  GPUd() const TPCFastTransformGeo& getGeometry() const { return mCorrection.getGeometry(); }
+  GPUdi() const TPCFastTransformGeo& getGeometry() const { return mCorrection.getGeometry(); }
 
   /// Gives the time stamp of the current calibaration parameters
-  GPUd() int64_t getTimeStamp() const { return mTimeStamp; }
+  GPUdi() int64_t getTimeStamp() const { return mTimeStamp; }
 
   /// Return mVDrift in cm / time bin
-  GPUd() float getVDrift() const { return mVdrift; }
+  GPUdi() float getVDrift() const { return mVdrift; }
 
   /// Return T0 in time bin units
-  GPUd() float getT0() const { return mT0; }
+  GPUdi() float getT0() const { return mT0; }
 
   /// Return map lumi
-  GPUd() float getLumi() const { return mLumi; }
+  GPUdi() float getLumi() const { return mLumi; }
 
-  GPUd() float isLumiSet() const { return mLumi != DEFLUMI; }
+  GPUdi() float isLumiSet() const { return mLumi != DEFLUMI; }
 
   /// Return map lumi error
-  GPUd() float getLumiError() const { return mLumiError; }
+  GPUdi() float getLumiError() const { return mLumiError; }
 
   /// Return map lumi
   GPUd() float getIDC() const;
 
-  GPUd() bool isIDCSet() const { return mIDC != DEFIDC; }
+  GPUdi() bool isIDCSet() const { return mIDC != DEFIDC; }
 
   /// Return map lumi error
-  GPUd() float getIDCError() const { return mIDCError; }
+  GPUdi() float getIDCError() const { return mIDCError; }
 
-  GPUd() float getCTP2IDCFallBackThreshold() const { return mCTP2IDCFallBackThreshold; }
+  GPUdi() float getCTP2IDCFallBackThreshold() const { return mCTP2IDCFallBackThreshold; }
 
   /// Return map user defined lumi scale factor
-  GPUd() float getLumiScaleFactor() const { return mLumiScaleFactor; }
+  GPUdi() float getLumiScaleFactor() const { return mLumiScaleFactor; }
 
   /// maximal possible drift time of the active area
   GPUd() float getMaxDriftTime(int32_t sector, int32_t row, float pad) const;
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 55e36cf6efef7..31b81e02c2d4c 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -53,10 +53,10 @@ class TPCFastTransformGeo
     float yMin{0.f};     ///< min. y coordinate
 
     /// get Y min
-    GPUd() float getYmin() const { return yMin; }
+    GPUdi() float getYmin() const { return yMin; }
 
     /// get Y max
-    GPUd() float getYmax() const { return -yMin; }
+    GPUdi() float getYmax() const { return -yMin; }
 
     /// get Y range
 #ifndef GPUCA_GPUCODE_DEVICE
@@ -64,7 +64,7 @@ class TPCFastTransformGeo
 #endif
 
     /// get width in Y
-    GPUd() float getYwidth() const { return -2.f * yMin; }
+    GPUdi() float getYwidth() const { return -2.f * yMin; }
 
     ClassDefNV(RowInfo, 2);
   };
@@ -110,16 +110,16 @@ class TPCFastTransformGeo
   /// _______________  Getters _________________________________
 
   /// Gives number of TPC sectors
-  GPUd() static constexpr int32_t getNumberOfSectors() { return NumberOfSectors; }
+  GPUdi() static constexpr int32_t getNumberOfSectors() { return NumberOfSectors; }
 
   /// Gives number of TPC sectors on the A side
-  GPUd() static constexpr int32_t getNumberOfSectorsA() { return NumberOfSectorsA; }
+  GPUdi() static constexpr int32_t getNumberOfSectorsA() { return NumberOfSectorsA; }
 
   /// Gives number of TPC rows
-  GPUd() int32_t getNumberOfRows() const { return mNumberOfRows; }
+  GPUdi() int32_t getNumberOfRows() const { return mNumberOfRows; }
 
   /// Gives number of TPC rows
-  GPUd() static constexpr int getMaxNumberOfRows() { return MaxNumberOfRows; }
+  GPUdi() static constexpr int getMaxNumberOfRows() { return MaxNumberOfRows; }
 
   /// Gives sector info
   GPUd() const SectorInfo& getSectorInfo(int32_t sector) const;
@@ -128,7 +128,7 @@ class TPCFastTransformGeo
   GPUd() const RowInfo& getRowInfo(int32_t row) const;
 
   /// Gives Z length of the TPC, one Z side
-  GPUd() float getTPCzLength() const { return mTPCzLength; }
+  GPUdi() float getTPCzLength() const { return mTPCzLength; }
 
   /// Gives Z range for the corresponding TPC side
 #ifndef GPUCA_GPUCODE_DEVICE

From bf2d88e5138b05643788eae70492559220995bea Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sun, 22 Feb 2026 12:43:33 +0100
Subject: [PATCH 1585/1764] Add POD version of TPCFastTransform

The TPCFastTransformPOD is a pointerless version of the TPCFastTransform. It can be created from the
original TPCFastTransform as e.g.
auto lold = o2::gpu::TPCFastTransform::loadFromFile("o2-gpu-TPCFastTransform.root","ccdb_object"); // load original transform
std::vector<char> v; // one has to provide a vector (could be a std or pmr), which later can be messaged via DPL
auto* pod = o2::gpu::TPCFastTransformPOD::create(v, *lold); // pointer pod is just v.data() cast to TPCFastTransformPOD*

// run test:
pod->test(*lold);
[INFO]  (ns per call)              original        this     Nmissmatch
[INFO] getCorrection               1.330e+02    1.400e+02   0
[INFO] getCorrectionInvCorrectedX  8.856e+01    8.434e+01   0
[INFO] getCorrectionInvUV          6.266e+01    6.142e+01   0

It can be also created directly from the TPCFastSpaceChargeCorrection as
TPCFastSpaceChargeCorrection& oldCorr = lold->getCorrection();
auto* pod = o2::gpu::TPCFastTransformPOD::create(v, oldCorr);
but in this case one should afterwards set the vdrift and t0 using provided getters.

TPCFastTransformPOD replicates all the methods of the TPCFastTransform (and of the TPCFastSpaceChargeCorrection), including
those which allow to query rescaled corrections (by providing refernce maps and scaling coefficients).
Since the idea of this class is to create a final correction map as a weighted sum of different contribution and to distribute
it to consumer processes via shared memory, also the query methods w/o rescaling are added, they have the suffix _new added.
Eventually, the scalable legacy methods can be suppressed and the suffix new can be dropped.
---
 GPU/TPCFastTransformation/CMakeLists.txt      |   1 +
 .../TPCFastSpaceChargeCorrection.h            |   2 +
 .../TPCFastTransformPOD.cxx                   | 245 +++++
 .../TPCFastTransformPOD.h                     | 916 ++++++++++++++++++
 .../TPCFastTransformationLinkDef_O2.h         |   1 +
 5 files changed, 1165 insertions(+)
 create mode 100644 GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
 create mode 100644 GPU/TPCFastTransformation/TPCFastTransformPOD.h

diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index 182a66fb28296..769e9981102ef 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -26,6 +26,7 @@ set(SRCS
     TPCFastSpaceChargeCorrectionMap.cxx
     TPCFastTransform.cxx
     CorrectionMapsHelper.cxx
+    TPCFastTransformPOD.cxx
 )
 
 if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 6dcf30b2991ba..aedb2531470fc 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -41,6 +41,8 @@ namespace gpu
 ///
 class TPCFastSpaceChargeCorrection : public FlatObject
 {
+  friend class TPCFastTransformPOD;
+
  public:
   // obsolete structure, declared here only for backward compatibility
   struct SliceInfo {
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
new file mode 100644
index 0000000000000..016eed2e6beb4
--- /dev/null
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -0,0 +1,245 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  TPCFastTransformPOD.cxx
+/// \brief Implementation of POD correction map
+///
+/// \author  ruben.shahoayn@cern.ch
+
+/// \brief Implementation of POD correction map
+///
+/// \author  ruben.shahoayn@cern.ch
+
+#if !defined(GPUCA_NO_ROOT) && !defined(GPUCA_NO_FMT) && !defined(GPUCA_STANDALONE)
+#include <TRandom.h>
+#endif
+#include "TPCFastTransformPOD.h"
+#include "GPUDebugStreamer.h"
+
+namespace o2
+{
+namespace gpu
+{
+
+#if !defined(GPUCA_NO_ROOT) && !defined(GPUCA_NO_FMT) && !defined(GPUCA_STANDALONE)
+
+size_t TPCFastTransformPOD::estimateSize(const TPCFastSpaceChargeCorrection& origCorr)
+{
+  // estimate size of own buffer
+  const size_t selfSizeFix = sizeof(TPCFastTransformPOD);
+  size_t nextDynOffs = alignOffset(selfSizeFix);
+  nextDynOffs = alignOffset(nextDynOffs + origCorr.mNumberOfScenarios * sizeof(size_t)); // spline scenarios start here
+  // space for splines
+  for (int isc = 0; isc < origCorr.mNumberOfScenarios; isc++) {
+    const auto& spline = origCorr.mScenarioPtr[isc];
+    nextDynOffs = alignOffset(nextDynOffs + sizeof(spline));
+  }
+  // space for splines data
+  for (int is = 0; is < 3; is++) {
+    for (int sector = 0; sector < origCorr.mGeo.getNumberOfSectors(); sector++) {
+      for (int row = 0; row < NROWS; row++) {
+        const auto& spline = origCorr.getSpline(sector, row);
+        int nPar = spline.getNumberOfParameters();
+        if (is == 1) {
+          nPar = nPar / 3;
+        }
+        if (is == 2) {
+          nPar = nPar * 2 / 3;
+        }
+        nextDynOffs += nPar * sizeof(float);
+      }
+    }
+  }
+  nextDynOffs = alignOffset(nextDynOffs);
+  return nextDynOffs;
+}
+
+TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, const TPCFastSpaceChargeCorrection& origCorr)
+{
+  // instantiate object to already created buffer of the right size
+  assert(buffSize > sizeof(TPCFastTransformPOD));
+  auto& podMap = getNonConst(buff);
+  podMap.mApplyCorrection = true; // by default always apply corrections
+
+  // copy fixed size data --- start
+  podMap.mNumberOfScenarios = origCorr.mNumberOfScenarios;
+  std::memcpy(&podMap.mGeo, &origCorr.mGeo, sizeof(TPCFastTransformGeo)); // copy geometry (fixed size)
+  for (int sector = 0; sector < TPCFastTransformGeo::getNumberOfSectors(); sector++) {
+    for (int row = 0; row < NROWS; row++) {
+      podMap.mSectorRowInfos[NROWS * sector + row] = origCorr.getSectorRowInfo(sector, row);
+    }
+  }
+  podMap.mTimeStamp = origCorr.mTimeStamp;
+  //
+  // init data members coming from the TPCFastTrasform
+  podMap.mVdrift = 0.;
+  podMap.mT0 = 0.;
+  // copy fixed size data --- end
+
+  size_t nextDynOffs = alignOffset(sizeof(TPCFastTransformPOD));
+
+  // copy sector scenarios
+  podMap.mOffsScenariosOffsets = nextDynOffs; // spline scenarios offsets start here
+  LOGP(debug, "Set mOffsScenariosOffsets = {}", podMap.mOffsScenariosOffsets);
+  nextDynOffs = alignOffset(nextDynOffs + podMap.mNumberOfScenarios * sizeof(size_t)); // spline scenarios start here
+
+  // copy spline objects
+  size_t* scenOffs = reinterpret_cast<size_t*>(buff + podMap.mOffsScenariosOffsets);
+  for (int isc = 0; isc < origCorr.mNumberOfScenarios; isc++) {
+    scenOffs[isc] = nextDynOffs;
+    const auto& spline = origCorr.mScenarioPtr[isc];
+    if (buffSize < nextDynOffs + sizeof(spline)) {
+      throw std::runtime_error(fmt::format("attempt to copy {} bytes for spline for scenario {} to {}, overflowing the buffer of size {}", sizeof(spline), isc, nextDynOffs + sizeof(spline), buffSize));
+    }
+    std::memcpy(buff + scenOffs[isc], &spline, sizeof(spline));
+    nextDynOffs = alignOffset(nextDynOffs + sizeof(spline));
+    LOGP(debug, "Copy {} bytes for spline scenario {} (ptr:{}) to offsset {}", sizeof(spline), isc, (void*)&spline, scenOffs[isc]);
+  }
+
+  // copy splines data
+  for (int is = 0; is < 3; is++) {
+    float* data = reinterpret_cast<float*>(buff + nextDynOffs);
+    LOGP(debug, "splinID={} start offset {} -> {}", is, nextDynOffs, (void*)data);
+    for (int sector = 0; sector < origCorr.mGeo.getNumberOfSectors(); sector++) {
+      podMap.mSplineDataOffsets[sector][is] = nextDynOffs;
+      size_t rowDataOffs = 0;
+      for (int row = 0; row < NROWS; row++) {
+        const auto& spline = origCorr.getSpline(sector, row);
+        const float* dataOr = origCorr.getCorrectionData(sector, row, is);
+        int nPar = spline.getNumberOfParameters();
+        if (is == 1) {
+          nPar = nPar / 3;
+        }
+        if (is == 2) {
+          nPar = nPar * 2 / 3;
+        }
+        LOGP(debug, "Copying {} floats for spline{} of sector:{} row:{} to offset {}", nPar, is, sector, row, nextDynOffs);
+        size_t nbcopy = nPar * sizeof(float);
+        if (buffSize < nextDynOffs + nbcopy) {
+          throw std::runtime_error(fmt::format("attempt to copy {} bytes of data for spline{} of sector{}/row{} to {}, overflowing the buffer of size {}", nbcopy, is, sector, row, nextDynOffs, buffSize));
+        }
+        std::memcpy(data, dataOr, nbcopy);
+        podMap.getSectorRowInfo(sector, row).dataOffsetBytes[is] = rowDataOffs;
+        rowDataOffs += nbcopy;
+        data += nPar;
+        nextDynOffs += nbcopy;
+      }
+    }
+  }
+  podMap.mTotalSize = alignOffset(nextDynOffs);
+  if (buffSize != podMap.mTotalSize) {
+    throw std::runtime_error(fmt::format("Estimated buffer size {} differs from filled one {}", buffSize, podMap.mTotalSize));
+  }
+  return &getNonConst(buff);
+}
+
+TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, const TPCFastTransform& src)
+{
+  // instantiate objec to already created buffer of the right size
+  auto podMap = create(buff, buffSize, src.getCorrection());
+  // set data members of TPCFastTransform
+  podMap->mVdrift = src.getVDrift();
+  podMap->mT0 = src.getT0();
+  // copy fixed size data --- end
+  return podMap;
+}
+
+bool TPCFastTransformPOD::test(const TPCFastSpaceChargeCorrection& origCorr, int npoints) const
+{
+  if (npoints < 1) {
+    return false;
+  }
+  std::vector<unsigned char> sector, row;
+  std::vector<float> y, z;
+  std::vector<std::array<float, 3>> corr0, corr1;
+  std::vector<std::array<float, 2>> corrInv0, corrInv1;
+  std::vector<float> corrInvX0, corrInvX1;
+
+  sector.reserve(npoints);
+  row.reserve(npoints);
+  y.reserve(npoints);
+  z.reserve(npoints);
+  corr0.reserve(npoints);
+  corr1.reserve(npoints);
+  corrInv0.reserve(npoints);
+  corrInv1.reserve(npoints);
+  corrInvX0.reserve(npoints);
+  corrInvX1.reserve(npoints);
+
+  for (int i = 0; i < npoints; i++) {
+    sector.push_back(gRandom->Integer(NSECTORS));
+    row.push_back(gRandom->Integer(NROWS));
+    y.push_back(2 * (gRandom->Rndm() - 0.5) * mGeo.getRowInfo(row.back()).getYmax());
+    z.push_back((sector.back() < NSECTORS / 2 ? 1.f : -1.f) * gRandom->Rndm() * 240);
+  }
+  long origStart[3], origEnd[3], thisStart[3], thisEnd[3];
+  origStart[0] = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+  for (int i = 0; i < npoints; i++) {
+    std::array<float, 3> val;
+    origCorr.getCorrectionLocal(sector[i], row[i], y[i], z[i], val[0], val[1], val[2]);
+    corr0.push_back(val);
+  }
+
+  origEnd[0] = origStart[1] = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+  for (int i = 0; i < npoints; i++) {
+    std::array<float, 2> val;
+    origCorr.getCorrectionYZatRealYZ(sector[i], row[i], y[i], z[i], val[0], val[1]);
+    corrInv0.push_back(val);
+  }
+
+  origEnd[1] = origStart[2] = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+  for (int i = 0; i < npoints; i++) {
+    corrInvX0.push_back(origCorr.getCorrectionXatRealYZ(sector[i], row[i], y[i], z[i]));
+  }
+  //
+  origEnd[2] = thisStart[0] = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+  for (int i = 0; i < npoints; i++) {
+    std::array<float, 3> val;
+    this->getCorrectionLocal(sector[i], row[i], y[i], z[i], val[0], val[1], val[2]);
+    corr1.push_back(val);
+  }
+  thisEnd[0] = thisStart[1] = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+  for (int i = 0; i < npoints; i++) {
+    std::array<float, 2> val;
+    this->getCorrectionYZatRealYZ(sector[i], row[i], y[i], z[i], val[0], val[1]);
+    corrInv1.push_back(val);
+  }
+
+  thisEnd[1] = thisStart[2] = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+  for (int i = 0; i < npoints; i++) {
+    corrInvX1.push_back(this->getCorrectionXatRealYZ(sector[i], row[i], y[i], z[i]));
+  }
+  thisEnd[2] = std::chrono::time_point_cast<std::chrono::microseconds>(std::chrono::system_clock::now()).time_since_epoch().count();
+  //
+  size_t ndiff[3] = {};
+  for (int i = 0; i < npoints; i++) {
+    if (corr0[i][0] != corr1[i][0] || corr0[i][1] != corr1[i][1] || corr0[i][2] != corr1[i][2]) {
+      ndiff[0]++;
+    }
+    if (corrInv0[i][0] != corrInv1[i][0] || corrInv0[i][1] != corrInv1[i][1]) {
+      ndiff[1]++;
+    }
+    if (corrInvX0[i] != corrInvX1[i]) {
+      ndiff[2]++;
+    }
+  }
+  //
+  LOGP(info, " (ns per call)              original        this     Nmissmatch");
+  LOGP(info, "getCorrection               {:.3e}    {:.3e}   {}", double(origEnd[0] - origStart[0]) / npoints * 1000., double(thisEnd[0] - thisStart[0]) / npoints * 1000., ndiff[0]);
+  LOGP(info, "getCorrectionInvCorrectedX  {:.3e}    {:.3e}   {}", double(origEnd[1] - origStart[1]) / npoints * 1000., double(thisEnd[1] - thisStart[1]) / npoints * 1000., ndiff[1]);
+  LOGP(info, "getCorrectionInvUV          {:.3e}    {:.3e}   {}", double(origEnd[2] - origStart[2]) / npoints * 1000., double(thisEnd[2] - thisStart[2]) / npoints * 1000., ndiff[2]);
+  return ndiff[0] == 0 && ndiff[1] == 0 && ndiff[2] == 0;
+}
+
+#endif
+
+} // namespace gpu
+} // namespace o2
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
new file mode 100644
index 0000000000000..ca54a74115068
--- /dev/null
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -0,0 +1,916 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  TPCFastTransformPOD.h
+/// \brief POD correction map
+///
+/// \author  ruben.shahoayn@cern.ch
+
+#ifndef ALICEO2_GPU_TPCFastTransformPOD_H
+#define ALICEO2_GPU_TPCFastTransformPOD_H
+
+#include "GPUCommonRtypes.h"
+#include "TPCFastTransform.h"
+
+/*
+Binary buffer should be cast to TPCFastTransformPOD class using static TPCFastTransformPOD& t = get(buffer); method,
+so that its head becomes `this` pointer of the object.
+
+First we have all the fixed size data members mentioned explicitly. Part of them is duplicating fixed size
+data members of TPCFastSpaceChargeCorrection but those starting with mOffs... provide the offset in bytes
+(wrt this) for dynamic data which cannot be declared as data member explicitly (since we cannot have any
+pointer except `this`) but obtained via getters using stored offsets wrt `this`.
+This is followed dynamic part itself.
+
+dynamic part layout:
+1) size_t[ mNumberOfScenarios ] array starting at offset mOffsScenariosOffsets, each element is the offset
+of distict spline object (scenario in TPCFastSpaceChargeCorrection)
+2) size_t[ mNSplineIDs ] array starting at offset mOffsSplineDataOffsets, each element is the offset of the
+beginning of splines data for give splineID
+
+*/
+
+namespace o2
+{
+namespace gpu
+{
+class TPCFastTransformPOD
+{
+ public:
+  using SliceInfo = TPCFastSpaceChargeCorrection::SliceInfo; // obsolete
+  using GridInfo = TPCFastSpaceChargeCorrection::GridInfo;
+  using SectorRowInfo = TPCFastSpaceChargeCorrection::SectorRowInfo;
+
+  using SplineTypeXYZ = TPCFastSpaceChargeCorrection::SplineTypeXYZ;
+  using SplineTypeInvX = TPCFastSpaceChargeCorrection::SplineTypeInvX;
+  using SplineTypeInvYZ = TPCFastSpaceChargeCorrection::SplineTypeInvYZ;
+  using SplineType = TPCFastSpaceChargeCorrection::SplineType;
+
+  /// convert prefilled buffer to TPCFastTransformPOD
+  GPUd() static const TPCFastTransformPOD& get(const char* head) { return *reinterpret_cast<const TPCFastTransformPOD*>(head); }
+
+  /// _______________ high level methods a la TPCFastTransform  _______________________
+  ///
+  // Methods taking extra reference transform are legacy compound transforms used to scale corrections.
+  GPUd() void Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+
+  GPUd() void Transform_new(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0) const;
+  GPUd() void TransformXYZ_new(int32_t sector, int32_t row, float& x, float& y, float& z) const;
+
+  /// Transformation in the time frame
+  GPUd() void TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const;
+  GPUd() void TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const;
+
+  /// Inverse transformation
+  GPUd() void InverseTransformInTimeFrame(int32_t sector, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const;
+  GPUd() float InverseTransformInTimeFrame(int32_t sector, float z, float maxTimeBin) const;
+
+  /// Inverse transformation: Transformed Y and Z -> transformed X
+  GPUd() void InverseTransformYZtoX(int32_t sector, int32_t row, float y, float z, float& x, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformYZtoX_new(int32_t sector, int32_t row, float y, float z, float& x) const;
+
+  /// Inverse transformation: Transformed Y and Z -> Y and Z, transformed w/o space charge correction
+  GPUd() void InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformYZtoNominalYZ_new(int32_t sector, int32_t row, float y, float z, float& ny, float& nz) const;
+
+  /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
+  GPUd() void InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
+  GPUd() void InverseTransformXYZtoNominalXYZ_new(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz) const;
+
+  /// Ideal transformation with Vdrift only - without calibration
+  GPUd() void TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;
+  GPUd() void TransformIdealZ(int32_t sector, float time, float& z, float vertexTime) const;
+
+  GPUd() void convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const;
+  GPUd() void convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const;
+
+  GPUd() void convLocalToPadTime(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float vertexTime) const;
+  GPUd() void convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const;
+
+  GPUd() float convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const;
+  GPUd() float convZtoTimeInTimeFrame(int32_t sector, float z, float maxTimeBin) const;
+  GPUd() float convDeltaTimeToDeltaZinTimeFrame(int32_t sector, float deltaTime) const;
+  GPUd() float convDeltaZtoDeltaTimeInTimeFrame(int32_t sector, float deltaZ) const;
+  GPUd() float convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const;
+  GPUd() float convZOffsetToVertexTime(int32_t sector, float zOffset, float maxTimeBin) const;
+  GPUd() float convVertexTimeToZOffset(int32_t sector, float vertexTime, float maxTimeBin) const;
+
+  /// _______________ methods a la TPCFastSpaceChargeCorrection: cluster correction  _______________________
+  void setApplyCorrectionOn() { mApplyCorrection = 1; }
+  void setApplyCorrectionOff() { mApplyCorrection = 0; }
+  bool isCorrectionApplied() { return mApplyCorrection; }
+
+  /// TPC geometry information
+  GPUd() const TPCFastTransformGeo& getGeometry() const { return mGeo; }
+
+  /// Gives TPC sector & row info
+  GPUd() const SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) const { return mSectorRowInfos[NROWS * sector + row]; }
+
+  /// Gives TPC sector & row info
+  GPUd() SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) { return mSectorRowInfos[NROWS * sector + row]; }
+
+  /// Gives its own size including dynamic part
+  GPUd() size_t size() const { return mTotalSize; }
+
+  /// Gives the time stamp of the current calibaration parameters
+  GPUd() long int getTimeStamp() const { return mTimeStamp; }
+
+  /// Return mVDrift in cm / time bin
+  GPUd() float getVDrift() const { return mVdrift; }
+
+  /// Return T0 in time bin units
+  GPUd() float getT0() const { return mT0; }
+
+  /// Return IDC estimator
+  GPUd() float getIDC() const { return mIDC; }
+
+  /// Return Lumi estimator
+  GPUd() float getLumi() const { return mLumi; }
+
+  /// maximal possible drift time of the active area
+  GPUd() float getMaxDriftTime(int32_t sector, int32_t row, float pad) const;
+
+  /// maximal possible drift time of the active area
+  GPUd() float getMaxDriftTime(int32_t sector, int32_t row) const;
+
+  /// maximal possible drift time of the active area
+  GPUd() float getMaxDriftTime(int32_t sector) const;
+
+  /// Sets the time stamp of the current calibaration
+  GPUd() void setTimeStamp(long int v) { mTimeStamp = v; }
+
+  /// Sets current vdrift
+  GPUd() void setVDrift(float v) { mVdrift = v; }
+
+  /// Sets current T0
+  GPUd() void setT0(float v) { mT0 = v; }
+
+  /// Sets IDC estimator
+  GPUd() void setIDC(float v) { mIDC = v; }
+
+  /// Sets CTP Lumi estimator
+  GPUd() void setLumi(float v) { mLumi = v; }
+
+  /// Gives a reference to a spline
+  GPUd() const SplineType& getSpline(int32_t sector, int32_t row) const { return *reinterpret_cast<const SplineType*>(getThis() + getScenarioOffset(getSectorRowInfo(sector, row).splineScenarioID)); }
+
+  /// Gives pointer to spline data
+  GPUd() const float* getCorrectionData(int32_t sector, int32_t row, int32_t iSpline = 0) const { return reinterpret_cast<const float*>(getThis() + mSplineDataOffsets[sector][iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]); }
+
+  /// Gives const pointer to a spline for the inverse X correction
+  GPUd() const SplineTypeInvX& getSplineInvX(int32_t sector, int32_t row) const { return reinterpret_cast<const SplineTypeInvX&>(getSpline(sector, row)); }
+
+  /// Gives pointer to spline data for the inverse X correction
+  GPUd() const float* getCorrectionDataInvX(int32_t sector, int32_t row) const { return getCorrectionData(sector, row, 1); }
+
+  /// Gives const pointer to a spline for the inverse YZ correction
+  GPUd() const SplineTypeInvYZ& getSplineInvYZ(int32_t sector, int32_t row) const { return reinterpret_cast<const SplineTypeInvYZ&>(getSpline(sector, row)); }
+
+  /// Gives pointer to spline data for the inverse YZ correction
+  GPUd() const float* getCorrectionDataInvYZ(int32_t sector, int32_t row) const { return getCorrectionData(sector, row, 2); }
+
+  /// _______________ The main method: cluster correction  _______________________
+  GPUdi() void getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const;
+
+  /// inverse correction: Real Y and Z -> Real X
+  GPUd() float getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const;
+
+  /// inverse correction: Real Y and Z -> measred Y and Z
+  GPUd() void getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ) const;
+
+  /// transformation in the sector local frame
+  GPUd() void TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const;
+  GPUd() void TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z) const;
+
+  /// _______________  Utilities  _______________________________________________
+
+  /// convert local y, z to internal grid coordinates u,v
+  /// return values: u, v, scaling factor
+  GPUd() void convLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const;
+
+  /// convert internal grid coordinates u,v to local y, z
+  /// return values: y, z, scaling factor
+  GPUd() void convGridToLocal(int32_t sector, int32_t row, float u, float v, float& y, float& z) const;
+
+  /// convert real Y, Z to the internal grid coordinates
+  /// return values: u, v, scaling factor
+  GPUd() void convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const;
+
+  /// convert internal grid coordinates to the real Y, Z
+  /// return values: y, z
+  GPUd() void convGridToRealLocal(int32_t sector, int32_t row, float u, float v, float& y, float& z) const;
+
+  GPUd() bool isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
+  GPUd() bool isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const;
+
+#if !defined(GPUCA_GPUCODE)
+  /// Create POD transform from old flat-buffer one. Provided vector will serve as a buffer
+  template <typename V>
+  static TPCFastTransformPOD* create(V& destVector, const TPCFastTransform& src);
+
+  /// create filling only part corresponding to TPCFastSpaceChargeCorrection. Data members coming from TPCFastTransform (e.g. VDrift, T0..) are not set
+  template <typename V>
+  static TPCFastTransformPOD* create(V& destVector, const TPCFastSpaceChargeCorrection& src);
+
+  bool test(const TPCFastTransform& src, int32_t npoints = 100000) const { return test(src.getCorrection(), npoints); }
+  bool test(const TPCFastSpaceChargeCorrection& origCorr, int32_t npoints = 100000) const;
+#endif
+
+  /// Print method
+  void print() const;
+
+  GPUd() float convDriftLengthToTime(float driftLength, float vertexTime) const;
+
+  static constexpr int NROWS = 152;
+  static constexpr int NSECTORS = TPCFastTransformGeo::getNumberOfSectors();
+  static constexpr int NSplineIDs = 3; ///< number of spline data sets for each sector/row
+
+ private:
+#if !defined(GPUCA_GPUCODE)
+  static constexpr size_t AlignmentBytes = 8;
+  static size_t alignOffset(size_t offs)
+  {
+    auto res = offs % AlignmentBytes;
+    return res ? offs + (AlignmentBytes - res) : offs;
+  }
+  static size_t estimateSize(const TPCFastTransform& src) { return estimateSize(src.getCorrection()); }
+  static size_t estimateSize(const TPCFastSpaceChargeCorrection& origCorr);
+  static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastTransform& src);
+  static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastSpaceChargeCorrection& src);
+  ///< get address to which the offset in bytes must be added to arrive to particular dynamic part
+  GPUd() const char* getThis() const { return reinterpret_cast<const char*>(this); }
+  GPUd() static TPCFastTransformPOD& getNonConst(char* head) { return *reinterpret_cast<TPCFastTransformPOD*>(head); }
+#endif
+
+  ///< return offset of the spline object start (equivalent of mScenarioPtr in the TPCFastSpaceChargeCorrection)
+  GPUd() size_t getScenarioOffset(int s) const { return (reinterpret_cast<const size_t*>(getThis() + mOffsScenariosOffsets))[s]; }
+
+  bool mApplyCorrection{};                                                          ///< flag to apply corrections
+  int mNumberOfScenarios{};                                                         ///< Number of approximation spline scenarios
+  size_t mTotalSize{};                                                              ///< total size of the buffer
+  size_t mOffsScenariosOffsets{};                                                   ///< start of the array of mNumberOfScenarios offsets for each type of spline
+  size_t mSplineDataOffsets[TPCFastTransformGeo::getNumberOfSectors()][NSplineIDs]; ///< start of data for each sector and iSpline data
+  long int mTimeStamp{};                                                            ///< time stamp of the current calibration
+  float mT0;                                                                        ///< T0 in [time bin]
+  float mVdrift;                                                                    ///< VDrift in  [cm/time bin]
+  float mLumi;                                                                      ///< luminosity estimator (for info only)
+  float mIDC;                                                                       ///< IDC estimator (for info only)
+
+  TPCFastTransformGeo mGeo; ///< TPC geometry information
+  SectorRowInfo mSectorRowInfos[NROWS * TPCFastTransformGeo::getNumberOfSectors()];
+
+  ClassDefNV(TPCFastTransformPOD, 0);
+};
+
+GPUdi() void TPCFastTransformPOD::getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const
+{
+  const auto& info = getSectorRowInfo(sector, row);
+  const SplineType& spline = getSpline(sector, row);
+  const float* splineData = getCorrectionData(sector, row);
+
+  float u, v, s;
+  convLocalToGrid(sector, row, y, z, u, v, s);
+
+  float dxyz[3];
+  spline.interpolateAtU(splineData, u, v, dxyz);
+
+  if (CAMath::Abs(dxyz[0]) > 100.f || CAMath::Abs(dxyz[1]) > 100.f || CAMath::Abs(dxyz[2]) > 100.f) {
+    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+  }
+
+  dx = s * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
+  dy = s * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
+  dz = s * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
+}
+
+GPUdi() float TPCFastTransformPOD::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
+{
+  const auto& info = getSectorRowInfo(sector, row);
+  float u, v, s;
+  convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
+  float dx = 0;
+  getSplineInvX(sector, row).interpolateAtU(getCorrectionDataInvX(sector, row), u, v, &dx);
+  if (CAMath::Abs(dx) > 100.f) {
+    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+  }
+  dx = s * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
+  return dx;
+}
+
+GPUdi() void TPCFastTransformPOD::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ, float& y, float& z) const
+{
+  float u, v, s;
+  convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
+  const auto& info = getSectorRowInfo(sector, row);
+  float dyz[2];
+  getSplineInvYZ(sector, row).interpolateAtU(getCorrectionDataInvYZ(sector, row), u, v, dyz);
+  if (CAMath::Abs(dyz[0]) > 100.f || CAMath::Abs(dyz[1]) > 100.f) {
+    s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
+  }
+  y = s * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
+  z = s * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
+}
+
+GPUdi() void TPCFastTransformPOD::convLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const
+{
+  /// convert local y, z to internal grid coordinates u,v
+  /// return values: u, v, scaling factor
+  const SplineType& spline = getSpline(sector, row);
+  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z, u, v, s);
+  // shrink to the grid
+  u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
+  v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
+}
+
+GPUdi() void TPCFastTransformPOD::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
+{
+  /// convert internal grid coordinates u,v to local y, z
+  getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(gridU, gridV, y, z);
+}
+
+GPUdi() void TPCFastTransformPOD::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const
+{
+  /// convert real y, z to the internal grid coordinates + scale
+  const SplineType& spline = getSpline(sector, row);
+  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z, u, v, s);
+  // shrink to the grid
+  u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
+  v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
+}
+
+GPUdi() void TPCFastTransformPOD::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
+{
+  /// convert internal grid coordinates u,v to the real y, z
+  getSectorRowInfo(sector, row).gridReal.convGridToLocal(gridU, gridV, y, z);
+}
+
+GPUdi() bool TPCFastTransformPOD::isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
+{
+  /// check if local y, z are inside the grid
+  float u, v, s;
+  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z, u, v, s);
+  const auto& spline = getSpline(sector, row);
+  // shrink to the grid
+  if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
+      v < 0.f || v > (float)spline.getGridX2().getUmax()) {
+    return false;
+  }
+  return true;
+}
+
+GPUdi() bool TPCFastTransformPOD::isRealLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
+{
+  /// check if local y, z are inside the grid
+  float u, v, s;
+  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z, u, v, s);
+  const auto& spline = getSpline(sector, row);
+  // shrink to the grid
+  if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
+      v < 0.f || v > (float)spline.getGridX2().getUmax()) {
+    return false;
+  }
+  return true;
+}
+
+#if !defined(GPUCA_GPUCODE)
+/// Create POD transform from old flat-buffer one. Provided vector will serve as a buffer
+template <typename V>
+TPCFastTransformPOD* TPCFastTransformPOD::create(V& destVector, const TPCFastTransform& src)
+{
+  const auto& origCorr = src.getCorrection();
+  size_t estSize = estimateSize(src);
+  destVector.resize(estSize); // allocate exact size
+  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POS size: {}", src.getCorrection().getFlatBufferSize(), sizeof(TPCFastTransformPOD), estSize);
+  char* base = destVector.data();
+  auto res = create(destVector.data(), destVector.size(), src);
+  res->setTimeStamp(src.getTimeStamp());
+  res->setVDrift(src.getVDrift());
+  res->setT0(src.getT0());
+  res->setLumi(src.getLumi());
+  if (src.isIDCSet()) {
+    res->setIDC(src.getIDC());
+  }
+  return res;
+}
+
+template <typename V>
+TPCFastTransformPOD* TPCFastTransformPOD::create(V& destVector, const TPCFastSpaceChargeCorrection& origCorr)
+{
+  // create filling only part corresponding to TPCFastSpaceChargeCorrection. Data members coming from TPCFastTransform (e.g. VDrift, T0..) are not set
+  size_t estSize = estimateSize(origCorr);
+  destVector.resize(estSize); // allocate exact size
+  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POS size: {}", origCorr.getFlatBufferSize(), sizeof(TPCFastTransformPOD), estSize);
+  char* base = destVector.data();
+  return create(destVector.data(), destVector.size(), origCorr);
+}
+#endif
+
+GPUdi() void TPCFastTransformPOD::TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+{
+  GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
+
+  if (!mApplyCorrection) {
+    return;
+  }
+
+  float dx = 0.f, dy = 0.f, dz = 0.f;
+
+  if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
+    getCorrectionLocal(sector, row, y, z, dx, dy, dz);
+    if (ref) {
+      if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
+        float val[3];
+        ref->getCorrectionLocal(sector, row, y, z, val[0], val[1], val[2]);
+        dx = (dx - val[0]) * scale + val[0];
+        dy = (dy - val[1]) * scale + val[1];
+        dz = (dz - val[2]) * scale + val[2];
+      } else if ((scale != 0.f) && ((scaleMode == 1) || (scaleMode == 2))) {
+        float val[3];
+        ref->getCorrectionLocal(sector, row, y, z, val[0], val[1], val[2]);
+        dx = val[0] * scale + dx;
+        dy = val[1] * scale + dy;
+        dz = val[2] * scale + dz;
+      }
+    }
+    if (ref2 && (scale2 != 0)) {
+      float val[3];
+      ref2->getCorrectionLocal(sector, row, y, z, val[0], val[1], val[2]);
+      dx = val[0] * scale2 + dx;
+      dy = val[1] * scale2 + dy;
+      dz = val[2] * scale2 + dz;
+    }
+  }
+
+  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
+    float lx = x, ly = y, lz = z;
+
+    float gx, gy, gz;
+    getGeometry().convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);
+
+    float lxT = lx + dx;
+    float lyT = ly + dy;
+    float lzT = lz + dz;
+
+    float invYZtoXScaled;
+    InverseTransformYZtoX(sector, row, lyT, lzT, invYZtoXScaled, ref, ref2, scale, scale2, scaleMode);
+
+    float invYZtoX;
+    InverseTransformYZtoX(sector, row, lyT, lzT, invYZtoX);
+
+    float YZtoNominalY;
+    float YZtoNominalZ;
+    InverseTransformYZtoNominalYZ(sector, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
+
+    float YZtoNominalYScaled;
+    float YZtoNominalZScaled;
+    InverseTransformYZtoNominalYZ(sector, row, lyT, lzT, YZtoNominalYScaled, YZtoNominalZScaled, ref, ref2, scale, scale2, scaleMode);
+
+    float dxRef = 0.f, dyRef = 0.f, dzRef = 0.f;
+    if (ref) {
+      ref->getCorrectionLocal(sector, row, y, z, dxRef, dyRef, dzRef);
+    }
+
+    float dxRef2 = 0.f, dyRef2 = 0.f, dzRef2 = 0.f;
+    if (ref2) {
+      ref2->getCorrectionLocal(sector, row, y, z, dxRef2, dyRef2, dzRef2);
+    }
+
+    float dxOrig, dyOrig, dzOrig;
+    getCorrectionLocal(sector, row, y, z, dyOrig, dyOrig, dzOrig);
+
+    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
+                                                                                       // corrections in x, u, v
+                                                                                       << "dxOrig=" << dxOrig
+                                                                                       << "dyOrig=" << dyOrig
+                                                                                       << "dzOrig=" << dzOrig
+                                                                                       << "dxRef=" << dxRef
+                                                                                       << "dyRef=" << dyRef
+                                                                                       << "dzRef=" << dzRef
+                                                                                       << "dxRef2=" << dxRef2
+                                                                                       << "dyRef2=" << dyRef2
+                                                                                       << "dzRef2=" << dzRef2
+                                                                                       << "dx=" << dx
+                                                                                       << "dy=" << dy
+                                                                                       << "dz=" << dz
+                                                                                       << "row=" << row
+                                                                                       << "sector=" << sector
+                                                                                       << "scale=" << scale
+                                                                                       << "scale2=" << scale2
+                                                                                       // original local coordinates
+                                                                                       << "ly=" << ly
+                                                                                       << "lz=" << lz
+                                                                                       << "lx=" << lx
+                                                                                       // corrected local coordinated
+                                                                                       << "lxT=" << lxT
+                                                                                       << "lyT=" << lyT
+                                                                                       << "lzT=" << lzT
+                                                                                       // global uncorrected coordinates
+                                                                                       << "gx=" << gx
+                                                                                       << "gy=" << gy
+                                                                                       << "gz=" << gz
+                                                                                       // some transformations which are applied
+                                                                                       << "invYZtoX=" << invYZtoX
+                                                                                       << "invYZtoXScaled=" << invYZtoXScaled
+                                                                                       << "YZtoNominalY=" << YZtoNominalY
+                                                                                       << "YZtoNominalYScaled=" << YZtoNominalYScaled
+                                                                                       << "YZtoNominalZ=" << YZtoNominalZ
+                                                                                       << "YZtoNominalZScaled=" << YZtoNominalZScaled
+                                                                                       << "scaleMode=" << scaleMode
+                                                                                       << "\n";
+  })
+
+  x += dx;
+  y += dy;
+  z += dz;
+}
+
+GPUdi() void TPCFastTransformPOD::TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z) const
+{
+  if (!mApplyCorrection) {
+    return;
+  }
+  float dx, dy, dz;
+  getCorrectionLocal(sector, row, y, z, dx, dy, dz);
+
+  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
+    float lx = x, ly = y, lz = z;
+    float gx, gy, gz;
+    getGeometry().convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);
+    float lxT = lx + dx;
+    float lyT = ly + dy;
+    float lzT = lz + dz;
+    float invYZtoX;
+    InverseTransformYZtoX_new(sector, row, lyT, lzT, invYZtoX);
+
+    float YZtoNominalY;
+    float YZtoNominalZ;
+    InverseTransformYZtoNominalYZ_new(sector, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
+
+    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
+                                                                                       // corrections in x, u, v
+                                                                                       << "dx=" << dx
+                                                                                       << "dy=" << dy
+                                                                                       << "dz=" << dz
+                                                                                       << "row=" << row
+                                                                                       << "sector=" << sector
+                                                                                       // original local coordinates
+                                                                                       << "ly=" << ly
+                                                                                       << "lz=" << lz
+                                                                                       << "lx=" << lx
+                                                                                       // corrected local coordinated
+                                                                                       << "lxT=" << lxT
+                                                                                       << "lyT=" << lyT
+                                                                                       << "lzT=" << lzT
+                                                                                       // global uncorrected coordinates
+                                                                                       << "gx=" << gx
+                                                                                       << "gy=" << gy
+                                                                                       << "gz=" << gz
+                                                                                       // some transformations which are applied
+                                                                                       << "invYZtoX=" << invYZtoX
+                                                                                       << "YZtoNominalY=" << YZtoNominalY
+                                                                                       << "YZtoNominalZ=" << YZtoNominalZ
+                                                                                       << "\n";
+  })
+
+  x += dx;
+  y += dy;
+  z += dz;
+}
+
+GPUdi() void TPCFastTransformPOD::Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+{
+  /// _______________ The main method: cluster transformation _______________________
+  ///
+  /// Transforms raw TPC coordinates to local XYZ withing a sector
+  /// taking calibration into account.
+  ///
+
+  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
+
+  x = rowInfo.x;
+  convPadTimeToLocal(sector, row, pad, time, y, z, vertexTime);
+  TransformLocal(sector, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
+}
+
+GPUdi() void TPCFastTransformPOD::Transform_new(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
+{
+  /// _______________ The main method: cluster transformation _______________________
+  ///
+  /// Transforms raw TPC coordinates to local XYZ withing a sector
+  /// taking calibration into account.
+  ///
+
+  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
+
+  x = rowInfo.x;
+  convPadTimeToLocal(sector, row, pad, time, y, z, vertexTime);
+  TransformLocal(sector, row, x, y, z);
+}
+
+GPUdi() void TPCFastTransformPOD::TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+{
+
+  TransformLocal(sector, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
+}
+
+GPUdi() void TPCFastTransformPOD::TransformXYZ_new(int32_t sector, int32_t row, float& x, float& y, float& z) const
+{
+
+  TransformLocal(sector, row, x, y, z);
+}
+
+GPUdi() void TPCFastTransformPOD::TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const
+{
+  float l = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
+  z = getGeometry().convDriftLengthToZ1(sector, l);
+}
+
+GPUdi() void TPCFastTransformPOD::TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
+{
+  /// _______________ Special cluster transformation for a time frame _______________________
+  ///
+  /// Same as Transform(), but clusters are shifted in z such, that Z(maxTimeBin)==0
+  /// Corrections and Time-Of-Flight correction are not alpplied.
+  ///
+
+  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
+  x = rowInfo.x;
+  convPadTimeToLocalInTimeFrame(sector, row, pad, time, y, z, maxTimeBin);
+}
+
+GPUdi() void TPCFastTransformPOD::InverseTransformInTimeFrame(int32_t sector, int32_t row, float /*x*/, float y, float z, float& pad, float& time, float maxTimeBin) const
+{
+  /// Inverse transformation to TransformInTimeFrame
+  convLocalToPadTimeInTimeFrame(sector, row, y, z, pad, time, maxTimeBin);
+}
+
+GPUdi() float TPCFastTransformPOD::InverseTransformInTimeFrame(int32_t sector, float z, float maxTimeBin) const
+{
+  float pad, time;
+  InverseTransformInTimeFrame(sector, 0, 0, 0, z, pad, time, maxTimeBin);
+  return time;
+}
+
+GPUdi() void TPCFastTransformPOD::TransformIdealZ(int32_t sector, float time, float& z, float vertexTime) const
+{
+  /// _______________ The main method: cluster transformation _______________________
+  ///
+  /// Transforms time TPC coordinates to local Z withing a sector
+  /// Ideal transformation: only Vdrift from DCS.
+  /// No space charge corrections, no time of flight correction
+  ///
+
+  float l = (time - mT0 - vertexTime) * mVdrift; // drift length cm
+  z = getGeometry().convDriftLengthToZ1(sector, l);
+}
+
+GPUdi() void TPCFastTransformPOD::TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
+{
+  /// _______________ The main method: cluster transformation _______________________
+  ///
+  /// Transforms raw TPC coordinates to local XYZ withing a sector
+  /// Ideal transformation: only Vdrift from DCS.
+  /// No space charge corrections, no time of flight correction
+  ///
+
+  x = getGeometry().getRowInfo(row).x;
+  float driftLength = (time - mT0 - vertexTime) * mVdrift; // drift length cm
+  getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength, y, z);
+}
+
+GPUdi() float TPCFastTransformPOD::convTimeToZinTimeFrame(int32_t sector, float time, float maxTimeBin) const
+{
+  /// _______________ Special cluster transformation for a time frame _______________________
+  ///
+  /// Same as Transform(), but clusters are shifted in z such, that Z(maxTimeBin)==0
+  /// Corrections and Time-Of-Flight correction are not alpplied.
+  /// Only Z coordinate.
+  ///
+
+  float v = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
+  float z = (sector < getGeometry().getNumberOfSectorsA()) ? -v : v;
+  return z;
+}
+
+GPUdi() float TPCFastTransformPOD::convZtoTimeInTimeFrame(int32_t sector, float z, float maxTimeBin) const
+{
+  /// Inverse transformation of convTimeToZinTimeFrame()
+  float v = (sector < getGeometry().getNumberOfSectorsA()) ? -z : z;
+  return mT0 + maxTimeBin + v / mVdrift;
+}
+
+GPUdi() float TPCFastTransformPOD::convDeltaTimeToDeltaZinTimeFrame(int32_t sector, float deltaTime) const
+{
+  float deltaZ = deltaTime * mVdrift;
+  return sector < getGeometry().getNumberOfSectorsA() ? -deltaZ : deltaZ;
+}
+
+GPUdi() float TPCFastTransformPOD::convDeltaZtoDeltaTimeInTimeFrameAbs(float deltaZ) const
+{
+  return deltaZ / mVdrift;
+}
+
+GPUdi() float TPCFastTransformPOD::convDeltaZtoDeltaTimeInTimeFrame(int32_t sector, float deltaZ) const
+{
+  float deltaT = deltaZ / mVdrift;
+  return sector < getGeometry().getNumberOfSectorsA() ? -deltaT : deltaT;
+}
+
+GPUdi() float TPCFastTransformPOD::getMaxDriftTime(int32_t sector, int32_t row, float pad) const
+{
+  /// maximal possible drift time of the active area
+  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);
+}
+
+GPUdi() float TPCFastTransformPOD::getMaxDriftTime(int32_t sector, int32_t row) const
+{
+  /// maximal possible drift time of the active area
+  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);
+}
+
+GPUdi() float TPCFastTransformPOD::getMaxDriftTime(int32_t sector) const
+{
+  /// maximal possible drift time of the active area
+  return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);
+}
+
+GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX(int32_t sector, int32_t row, float realY, float realZ, float& realX, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+{
+  GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
+  /// Transformation y,z -> x
+
+  float dx = 0.f;
+
+  if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
+    dx = getCorrectionXatRealYZ(sector, row, realY, realZ);
+    if (ref) { // scaling was requested
+      if (scaleMode == 0 && scale > 0.f) {
+        float dxref = ref->getCorrectionXatRealYZ(sector, row, realY, realZ);
+        dx = (dx - dxref) * scale + dxref;
+      } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
+        float dxref = ref->getCorrectionXatRealYZ(sector, row, realY, realZ);
+        dx = dxref * scale + dx;
+      }
+    }
+    if (ref2 && (scale2 != 0)) {
+      float dxref = ref2->getCorrectionXatRealYZ(sector, row, realY, realZ);
+      dx = dxref * scale2 + dx;
+    }
+  }
+
+  realX = getGeometry().getRowInfo(row).x + dx;
+
+  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
+    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoX").data()
+                                                                                       << "sector=" << sector
+                                                                                       << "row=" << row
+                                                                                       << "scale=" << scale
+                                                                                       << "y=" << realY
+                                                                                       << "z=" << realZ
+                                                                                       << "x=" << realX
+                                                                                       << "\n";
+  })
+}
+
+GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX_new(int32_t sector, int32_t row, float realY, float realZ, float& realX) const
+{
+  /// Transformation y,z -> x
+
+  float dx = 0.f;
+
+  dx = getCorrectionXatRealYZ(sector, row, realY, realZ);
+  realX = getGeometry().getRowInfo(row).x + dx;
+
+  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
+    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoX").data()
+                                                                                       << "sector=" << sector
+                                                                                       << "row=" << row
+                                                                                       << "y=" << realY
+                                                                                       << "z=" << realZ
+                                                                                       << "x=" << realX
+                                                                                       << "\n";
+  })
+}
+
+GPUdi() void TPCFastTransformPOD::InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+{
+  /// Transformation real y,z -> measured y,z
+
+  GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
+
+  float dy = 0;
+  float dz = 0;
+
+  if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
+    getCorrectionYZatRealYZ(sector, row, realY, realZ, dy, dz);
+
+    if (ref) { // scaling was requested
+      if (scaleMode == 0 && scale > 0.f) {
+        float val[2];
+        ref->getCorrectionYZatRealYZ(sector, row, realY, realZ, val[0], val[1]);
+        dy = (dy - val[0]) * scale + val[0];
+        dz = (dz - val[1]) * scale + val[1];
+      } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
+        float val[2];
+        ref->getCorrectionYZatRealYZ(sector, row, realY, realZ, val[0], val[1]);
+        dy = val[0] * scale + dy;
+        dz = val[1] * scale + dz;
+      }
+      if (ref2 && (scale2 != 0)) {
+        float val[2];
+        ref2->getCorrectionYZatRealYZ(sector, row, realY, realZ, val[0], val[1]);
+        dy = val[0] * scale2 + dy;
+        dz = val[1] * scale2 + dz;
+      }
+    }
+  }
+
+  measuredY = realY - dy;
+  measuredZ = realZ - dz;
+
+  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
+    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoNominalYZ").data()
+                                                                                       << "sector=" << sector
+                                                                                       << "row=" << row
+                                                                                       << "scale=" << scale
+                                                                                       << "real y=" << realY
+                                                                                       << "real z=" << realZ
+                                                                                       << "measured y=" << measuredY
+                                                                                       << "measured z=" << measuredZ
+                                                                                       << "\n";
+  })
+}
+
+GPUdi() void TPCFastTransformPOD::InverseTransformYZtoNominalYZ_new(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ) const
+{
+  /// Transformation real y,z -> measured y,z
+  float corrY, corrZ;
+  getCorrectionYZatRealYZ(sector, row, realY, realZ, corrY, corrZ);
+  measuredY = realY - corrY;
+  measuredZ = realZ - corrZ;
+
+  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
+    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoNominalYZ").data()
+                                                                                       << "sector=" << sector
+                                                                                       << "row=" << row
+                                                                                       << "real y=" << realY
+                                                                                       << "real z=" << realZ
+                                                                                       << "measured y=" << measuredY
+                                                                                       << "measured z=" << measuredZ
+                                                                                       << "\n";
+  })
+}
+
+GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+{
+  /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
+  int32_t row2 = row + 1;
+  if (row2 >= getGeometry().getNumberOfRows()) {
+    row2 = row - 1;
+  }
+  float nx1, ny1, nz1; // nominal coordinates for row
+  float nx2, ny2, nz2; // nominal coordinates for row2
+  nx1 = getGeometry().getRowInfo(row).x;
+  nx2 = getGeometry().getRowInfo(row2).x;
+  InverseTransformYZtoNominalYZ(sector, row, y, z, ny1, nz1, ref, ref2, scale, scale2, scaleMode);
+  InverseTransformYZtoNominalYZ(sector, row2, y, z, ny2, nz2, ref, ref2, scale, scale2, scaleMode);
+  float c1 = (nx2 - nx) / (nx2 - nx1);
+  float c2 = (nx - nx1) / (nx2 - nx1);
+  nx = x;
+  ny = (ny1 * c1 + ny2 * c2);
+  nz = (nz1 * c1 + nz2 * c2);
+}
+
+GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ_new(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz) const
+{
+  /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
+  int32_t row2 = row + 1;
+  if (row2 >= getGeometry().getNumberOfRows()) {
+    row2 = row - 1;
+  }
+  float nx1, ny1, nz1; // nominal coordinates for row
+  float nx2, ny2, nz2; // nominal coordinates for row2
+  nx1 = getGeometry().getRowInfo(row).x;
+  nx2 = getGeometry().getRowInfo(row2).x;
+  InverseTransformYZtoNominalYZ_new(sector, row, y, z, ny1, nz1);
+  InverseTransformYZtoNominalYZ_new(sector, row2, y, z, ny2, nz2);
+  float c1 = (nx2 - nx) / (nx2 - nx1);
+  float c2 = (nx - nx1) / (nx2 - nx1);
+  nx = x;
+  ny = (ny1 * c1 + ny2 * c2);
+  nz = (nz1 * c1 + nz2 * c2);
+}
+
+} // namespace gpu
+} // namespace o2
+
+#endif
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index f1872549a46aa..0247bbbfbb65b 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -93,5 +93,6 @@
 #pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
 #pragma link C++ struct o2::gpu::NDPiecewisePolynomialContainer + ;
 #pragma link C++ struct o2::gpu::TPCSlowSpaceChargeCorrection + ;
+#pragma link C++ class o2::gpu::TPCFastTransformPOD + ;
 
 #endif

From 19d6617a61ce56f268cf373b608f6ff71eef43e2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 3 Apr 2026 10:29:35 +0200
Subject: [PATCH 1586/1764] GPU FlatObject: Make some more functions accessible
 on GPU

---
 GPU/TPCFastTransformation/TPCFastTransformGeo.h | 8 ++++----
 GPU/Utils/FlatObject.h                          | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 31b81e02c2d4c..6dd0e716c833b 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -86,7 +86,7 @@ class TPCFastTransformGeo
   /// _____________  FlatObject functionality, see FlatObject class for description  ____________
 
   /// Gives minimal alignment in bytes required for an object of the class
-  static constexpr size_t getClassAlignmentBytes() { return 8; }
+  inline static constexpr size_t getClassAlignmentBytes() { return 8; }
 
   /// _______________  Construction interface  ________________________
 
@@ -110,16 +110,16 @@ class TPCFastTransformGeo
   /// _______________  Getters _________________________________
 
   /// Gives number of TPC sectors
-  GPUdi() static constexpr int32_t getNumberOfSectors() { return NumberOfSectors; }
+  inline static constexpr int32_t getNumberOfSectors() { return NumberOfSectors; }
 
   /// Gives number of TPC sectors on the A side
-  GPUdi() static constexpr int32_t getNumberOfSectorsA() { return NumberOfSectorsA; }
+  inline static constexpr int32_t getNumberOfSectorsA() { return NumberOfSectorsA; }
 
   /// Gives number of TPC rows
   GPUdi() int32_t getNumberOfRows() const { return mNumberOfRows; }
 
   /// Gives number of TPC rows
-  GPUdi() static constexpr int getMaxNumberOfRows() { return MaxNumberOfRows; }
+  inline static constexpr int getMaxNumberOfRows() { return MaxNumberOfRows; }
 
   /// Gives sector info
   GPUd() const SectorInfo& getSectorInfo(int32_t sector) const;
diff --git a/GPU/Utils/FlatObject.h b/GPU/Utils/FlatObject.h
index 8e13a8dedb868..46fdec7703823 100644
--- a/GPU/Utils/FlatObject.h
+++ b/GPU/Utils/FlatObject.h
@@ -253,10 +253,10 @@ class FlatObject
   void destroy();
 
   /// Gives size of the flat buffer
-  size_t getFlatBufferSize() const { return mFlatBufferSize; }
+  GPUdi() size_t getFlatBufferSize() const { return mFlatBufferSize; }
 
   /// Gives pointer to the flat buffer
-  const char* getFlatBufferPtr() const { return mFlatBufferPtr; }
+  GPUdi() const char* getFlatBufferPtr() const { return mFlatBufferPtr; }
 
   /// Tells if the object is constructed
   bool isConstructed() const { return (mConstructionMask & (uint32_t)ConstructionState::Constructed); }
@@ -274,7 +274,7 @@ class FlatObject
 
  public:
   /// Increases given size to achieve required alignment
-  static size_t alignSize(size_t sizeBytes, size_t alignmentBytes)
+  static constexpr size_t alignSize(size_t sizeBytes, size_t alignmentBytes)
   {
     auto res = sizeBytes % alignmentBytes;
     return res ? sizeBytes + (alignmentBytes - res) : sizeBytes;

From a5b24a599e45470b60b3c94b085e752c3060459d Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Mon, 27 Oct 2025 11:11:59 +0100
Subject: [PATCH 1587/1764] TPC: centralize correction map building in
 TPCScalerSpec

`TPCScalerSpec` now owns the full correction map pipeline: loads maps from CCDB, applies luminosity scaling and M-shape corrections, applies VDrift into the final map, and publishes a single merged `TPCFastTransformPOD` (`TPC/TPCCORRMAP`) plus instantaneous CTP lumi (`CTP/LUMICTP`) each TF.

Downstream consumers (ITS-TPC matcher, TRD, TOF, secondary vertexing, GPU reco, etc.) are simplified: lumi scale options removed from constructors, `corrMapsLoader.updateVDrift()` / `corrMapsLoader.accountCCDBInputs()` / `corrMapsLoader.init()` calls dropped, and `requestCCDBInputs()` replaced by `requestInputs()` subscribing only to the two new outputs.

`TPCScalerSpec` is now always added unconditionally.

`CorrectionMapsHelper` is reduced to a thin wrapper around `TPCFastTransformPOD*`; full lumi-scaling state moves to the new `CorrectionMapsHelperFull` / `CorrectionMapsLoaderFull` used only inside `TPCScalerSpec`. `TPCFastTransformPOD` gains a flat buffer offset table and `interpolateAtUZeroCopy()` for correct spline evaluation on zero-copy shared memory paths.
---
 .../AlignmentWorkflow/BarrelAlignmentSpec.h   |   2 +-
 .../Workflow/src/BarrelAlignmentSpec.cxx      |  26 +-
 .../src/barrel-alignment-workflow.cxx         |   7 +-
 Detectors/GlobalTracking/src/MatchTOF.cxx     |   1 +
 Detectors/GlobalTracking/src/MatchTPCITS.cxx  |   1 +
 .../CosmicsMatchingSpec.h                     |   2 +-
 .../SecondaryVertexingSpec.h                  |   2 +-
 .../GlobalTrackingWorkflow/TOFMatcherSpec.h   |   2 +-
 .../TPCITSMatchingSpec.h                      |   2 +-
 .../src/CosmicsMatchingSpec.cxx               |  23 +-
 .../src/SecondaryVertexingSpec.cxx            |  26 +-
 .../src/TOFMatcherSpec.cxx                    |  25 +-
 .../src/TPCITSMatchingSpec.cxx                |  25 +-
 .../src/cosmics-match-workflow.cxx            |   6 +-
 .../src/secondary-vertexing-workflow.cxx      |   6 +-
 .../src/tof-matcher-workflow.cxx              |   6 +-
 .../src/tpcits-match-workflow.cxx             |   6 +-
 .../GlobalTrackingStudy/TPCTrackStudy.h       |   2 +-
 .../GlobalTrackingStudy/TrackMCStudy.h        |   2 +-
 .../GlobalTrackingStudy/TrackingStudy.h       |   2 +-
 .../study/src/TPCTrackStudy.cxx               |  30 +-
 .../study/src/TrackMCStudy.cxx                |  30 +-
 .../study/src/TrackingStudy.cxx               |  30 +-
 .../study/src/tpc-track-study-workflow.cxx    |   6 +-
 .../study/src/trackMCStudy-workflow.cxx       |   6 +-
 .../study/src/tracking-study-workflow.cxx     |   6 +-
 Detectors/TPC/calibration/CMakeLists.txt      |   2 +
 .../TPCCalibration/CorrectionMapsLoader.h     |  32 +-
 .../TPCCalibration/CorrectionMapsLoaderFull.h |  64 +++
 .../TPC/calibration/src/CalculatedEdx.cxx     |   5 +-
 .../calibration/src/CorrectionMapsLoader.cxx  | 369 ++----------------
 .../src/CorrectionMapsLoaderFull.cxx          | 253 ++++++++++++
 Detectors/TPC/calibration/src/TrackDump.cxx   |   9 +-
 .../TPCFastTransformHelperO2.h                |  16 +-
 .../src/TPCFastTransformHelperO2.cxx          |  10 +-
 .../reconstruction/test/testGPUCATracking.cxx |  11 +-
 .../TPCWorkflow/TPCCalibPadGainTracksSpec.h   |  37 +-
 .../include/TPCWorkflow/TPCRefitter.h         |   2 +-
 .../include/TPCWorkflow/TPCScalerSpec.h       |   3 +-
 Detectors/TPC/workflow/src/RecoWorkflow.cxx   |  13 +-
 Detectors/TPC/workflow/src/TPCRefitter.cxx    |  32 +-
 Detectors/TPC/workflow/src/TPCScalerSpec.cxx  | 102 ++++-
 .../workflow/src/tpc-calib-gainmap-tracks.cxx |   6 +-
 .../TPC/workflow/src/tpc-reco-workflow.cxx    |   3 +-
 .../workflow/src/tpc-refitter-workflow.cxx    |  10 +-
 Detectors/TPC/workflow/src/tpc-scaler.cxx     |   6 +-
 .../TRDWorkflow/TRDGlobalTrackingSpec.h       |  11 +-
 .../workflow/src/TRDGlobalTrackingSpec.cxx    |  14 +-
 .../workflow/src/trd-tracking-workflow.cxx    |   6 +-
 .../Base/GPUReconstructionConvert.cxx         |   4 +-
 .../Base/GPUReconstructionConvert.h           |   4 +-
 .../Base/GPUReconstructionTimeframe.cxx       |   2 +-
 GPU/GPUTracking/DataTypes/GPUDataTypesIO.h    |   6 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  42 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |  10 +-
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  26 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |   2 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |   2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |   2 +-
 .../TPCConvert/GPUTPCConvertImpl.h            |   4 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  |   2 +-
 .../CorrectionMapsHelper.cxx                  | 120 ++----
 .../CorrectionMapsHelper.h                    | 192 +++------
 .../CorrectionMapsHelperFull.cxx              |  60 +++
 .../CorrectionMapsHelperFull.h                | 161 ++++++++
 GPU/TPCFastTransformation/Spline1DSpec.h      |  37 ++
 GPU/TPCFastTransformation/Spline2DSpec.h      |  96 +++++
 .../TPCFastTransformPOD.cxx                   |  53 ++-
 .../TPCFastTransformPOD.h                     | 111 +++++-
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |  12 +-
 .../include/GPUWorkflow/O2GPUDPLDisplay.h     |   3 -
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |   8 +-
 GPU/Workflow/src/GPUWorkflowTPC.cxx           |  77 ++--
 GPU/Workflow/src/O2GPUDPLDisplay.cxx          |  13 +-
 GPU/Workflow/src/gpu-reco-workflow.cxx        |   8 -
 prodtests/full-system-test/dpl-workflow.sh    |  30 +-
 76 files changed, 1260 insertions(+), 1125 deletions(-)
 create mode 100644 Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoaderFull.h
 create mode 100644 Detectors/TPC/calibration/src/CorrectionMapsLoaderFull.cxx
 create mode 100644 GPU/TPCFastTransformation/CorrectionMapsHelperFull.cxx
 create mode 100644 GPU/TPCFastTransformation/CorrectionMapsHelperFull.h

diff --git a/Detectors/Align/Workflow/include/AlignmentWorkflow/BarrelAlignmentSpec.h b/Detectors/Align/Workflow/include/AlignmentWorkflow/BarrelAlignmentSpec.h
index 197ace2bd9d20..fd5697a20bc2b 100644
--- a/Detectors/Align/Workflow/include/AlignmentWorkflow/BarrelAlignmentSpec.h
+++ b/Detectors/Align/Workflow/include/AlignmentWorkflow/BarrelAlignmentSpec.h
@@ -31,7 +31,7 @@ namespace align
 
 /// create a processor spec
 framework::DataProcessorSpec getBarrelAlignmentSpec(o2::dataformats::GlobalTrackID::mask_t srcMP, o2::dataformats::GlobalTrackID::mask_t src,
-                                                    o2::detectors::DetID::mask_t dets, o2::detectors::DetID::mask_t skipDetClusters, bool enableCosmic, int postproc, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
+                                                    o2::detectors::DetID::mask_t dets, o2::detectors::DetID::mask_t skipDetClusters, bool enableCosmic, int postproc, bool useMC);
 
 } // namespace align
 } // namespace o2
diff --git a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
index 2e63a1a65483c..dc952b26e52f0 100644
--- a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
+++ b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
@@ -86,14 +86,9 @@ class BarrelAlignmentSpec : public Task
                   CheckConstaints = 0x1 << 1,
                   GenPedeFiles = 0x1 << 2,
                   LabelPedeResults = 0x1 << 3 };
-  BarrelAlignmentSpec(GTrackID::mask_t srcMP, std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> ggrec, const o2::tpc::CorrectionMapsLoaderGloOpts& tpcOpt,
+  BarrelAlignmentSpec(GTrackID::mask_t srcMP, std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> ggrec,
                       DetID::mask_t detmask, bool cosmic, int postprocess, bool useMC, bool loadTPCCalib)
-    : mDataRequest(dr), mGRPGeomRequest(ggrec), mMPsrc{srcMP}, mDetMask{detmask}, mCosmic(cosmic), mPostProcessing(postprocess), mUseMC(useMC), mLoadTPCCalib(loadTPCCalib)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(tpcOpt.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(tpcOpt.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(tpcOpt.checkCTPIDCconsistency);
-  }
+    : mDataRequest(dr), mGRPGeomRequest(ggrec), mMPsrc{srcMP}, mDetMask{detmask}, mCosmic(cosmic), mPostProcessing(postprocess), mUseMC(useMC), mLoadTPCCalib(loadTPCCalib) {}
   ~BarrelAlignmentSpec() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -184,9 +179,6 @@ void BarrelAlignmentSpec::init(InitContext& ic)
   }
   mIgnoreCCDBAlignment = ic.options().get<bool>("ignore-ccdb-alignment");
   if (!mPostProcessing) {
-    if (mLoadTPCCalib) {
-      mTPCCorrMapsLoader.init(ic);
-    }
     if (GTrackID::includesDet(DetID::TRD, mMPsrc)) {
       mTRDTransformer.reset(new o2::trd::TrackletTransformer);
       if (ic.options().get<bool>("apply-xor")) {
@@ -278,7 +270,7 @@ void BarrelAlignmentSpec::updateTimeDependentParams(ProcessingContext& pc)
       mTPCCorrMapsLoader.acknowledgeUpdate();
       updateMaps = true;
     }
-    mController->setTPCCorrMaps(&mTPCCorrMapsLoader);
+    // mController->setTPCCorrMaps(&mTPCCorrMapsLoader);
     if (mTPCVDriftHelper.isUpdated()) {
       LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
            mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
@@ -288,9 +280,6 @@ void BarrelAlignmentSpec::updateTimeDependentParams(ProcessingContext& pc)
       mTPCVDriftHelper.acknowledgeUpdate();
       updateMaps = true;
     }
-    if (updateMaps) {
-      mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
-    }
   }
 }
 
@@ -314,9 +303,6 @@ void BarrelAlignmentSpec::finaliseCCDB(o2::framework::ConcreteDataMatcher& match
 
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
 }
 
 void BarrelAlignmentSpec::run(ProcessingContext& pc)
@@ -374,7 +360,7 @@ void BarrelAlignmentSpec::endOfStream(EndOfStreamContext& ec)
   mDBGOut.reset();
 }
 
-DataProcessorSpec getBarrelAlignmentSpec(GTrackID::mask_t srcMP, GTrackID::mask_t src, DetID::mask_t dets, DetID::mask_t skipDetClusters, bool enableCosmic, int postprocess, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+DataProcessorSpec getBarrelAlignmentSpec(GTrackID::mask_t srcMP, GTrackID::mask_t src, DetID::mask_t dets, DetID::mask_t skipDetClusters, bool enableCosmic, int postprocess, bool useMC)
 {
   std::vector<OutputSpec> outputs;
   auto dataRequest = std::make_shared<DataRequest>();
@@ -399,7 +385,7 @@ DataProcessorSpec getBarrelAlignmentSpec(GTrackID::mask_t srcMP, GTrackID::mask_
     }
     if (src[DetID::TPC] && !skipDetClusters[DetID::TPC]) {
       o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-      o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+      o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
       loadTPCCalib = true;
     }
   }
@@ -417,7 +403,7 @@ DataProcessorSpec getBarrelAlignmentSpec(GTrackID::mask_t srcMP, GTrackID::mask_
     "barrel-alignment",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<BarrelAlignmentSpec>(srcMP, dataRequest, ccdbRequest, sclOpts, dets, enableCosmic, postprocess, useMC, loadTPCCalib)},
+    AlgorithmSpec{adaptFromTask<BarrelAlignmentSpec>(srcMP, dataRequest, ccdbRequest, dets, enableCosmic, postprocess, useMC, loadTPCCalib)},
     opts};
 }
 
diff --git a/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx b/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
index cdd0620affec9..03fc414113114 100644
--- a/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
+++ b/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
@@ -20,7 +20,6 @@
 #include "TPCReaderWorkflow/ClusterReaderSpec.h"
 #include "TPCWorkflow/ClusterSharingMapSpec.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TOFWorkflowIO/ClusterReaderSpec.h"
 #include "TOFWorkflowIO/TOFMatchedReaderSpec.h"
 #include "TOFWorkflowIO/ClusterReaderSpec.h"
@@ -150,11 +149,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     o2::conf::ConfigurableParam::writeINI("o2_barrel_alignment_configuration.ini");
   }
 
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
 
-  specs.emplace_back(o2::align::getBarrelAlignmentSpec(srcMP, src, dets, skipDetClusters, enableCosmic, postprocess, useMC, sclOpt));
+  specs.emplace_back(o2::align::getBarrelAlignmentSpec(srcMP, src, dets, skipDetClusters, enableCosmic, postprocess, useMC));
   // RS FIXME: check which clusters are really needed
   if (!postprocess) {
     GID::mask_t dummy;
diff --git a/Detectors/GlobalTracking/src/MatchTOF.cxx b/Detectors/GlobalTracking/src/MatchTOF.cxx
index 6a3486dd12044..ad050309fe030 100644
--- a/Detectors/GlobalTracking/src/MatchTOF.cxx
+++ b/Detectors/GlobalTracking/src/MatchTOF.cxx
@@ -2087,6 +2087,7 @@ void MatchTOF::updateTimeDependentParams()
   const auto& trackTune = TrackTuneParams::Instance();
   float scale = mTPCCorrMapsHelper->getInstLumiCTP();
   if (scale < 0.f) {
+    LOGP(warning, "Negative scale factor for TPC covariance correction, setting it to zero");
     scale = 0.f;
   }
   mCovDiagInner = trackTune.getCovInnerTotal(scale);
diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index 73216c8ce1eac..9b69397e1f9f6 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -288,6 +288,7 @@ void MatchTPCITS::updateTimeDependentParams()
   const auto& trackTune = TrackTuneParams::Instance();
   float scale = mTPCCorrMapsHelper->getInstLumiCTP();
   if (scale < 0.f) {
+    LOGP(warning, "Negative scale factor for TPC covariance correction, setting it to zero");
     scale = 0.f;
   }
   mCovDiagInner = trackTune.getCovInnerTotal(scale);
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h
index e0e74c3058086..0633bb6a64a22 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h
@@ -29,7 +29,7 @@ namespace globaltracking
 {
 
 /// create a processor spec
-framework::DataProcessorSpec getCosmicsMatchingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
+framework::DataProcessorSpec getCosmicsMatchingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC);
 
 } // namespace globaltracking
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h
index b8071ae83d347..9de5f158a0608 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h
@@ -29,7 +29,7 @@ namespace vertexing
 {
 
 /// create a processor spec
-o2::framework::DataProcessorSpec getSecondaryVertexingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool enableCasc, bool enable3body, bool enableStrangenesTracking, bool enableCCDBParams, bool useMC, bool useGeom, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
+o2::framework::DataProcessorSpec getSecondaryVertexingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool enableCasc, bool enable3body, bool enableStrangenesTracking, bool enableCCDBParams, bool useMC, bool useGeom);
 
 } // namespace vertexing
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
index 79a4ee0ce0360..afc70f688a0b5 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
@@ -29,7 +29,7 @@ namespace globaltracking
 {
 
 /// create a processor spec
-framework::DataProcessorSpec getTOFMatcherSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC, bool useFIT, bool tpcRefit, bool strict, float extratolerancetrd, bool pushMatchable, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, int nlanes = 1);
+framework::DataProcessorSpec getTOFMatcherSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC, bool useFIT, bool tpcRefit, bool strict, float extratolerancetrd, bool pushMatchable, int nlanes = 1);
 
 } // namespace globaltracking
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
index 4aaed7d64eec5..4f4f13cde72b1 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
@@ -27,7 +27,7 @@ struct CorrectionMapsLoaderGloOpts;
 namespace globaltracking
 {
 /// create a processor spec
-framework::DataProcessorSpec getTPCITSMatchingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useFT0, bool calib, bool skipTPCOnly, bool useGeom, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
+framework::DataProcessorSpec getTPCITSMatchingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useFT0, bool calib, bool skipTPCOnly, bool useGeom, bool useMC);
 
 } // namespace globaltracking
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
index 5bcdded0e1223..cf148d47b3d10 100644
--- a/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
@@ -62,12 +62,7 @@ namespace globaltracking
 class CosmicsMatchingSpec : public Task
 {
  public:
-  CosmicsMatchingSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool useMC) : mDataRequest(dr), mGGCCDBRequest(gr), mUseMC(useMC)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-  }
+  CosmicsMatchingSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC) : mDataRequest(dr), mGGCCDBRequest(gr), mUseMC(useMC) {}
   ~CosmicsMatchingSpec() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -92,7 +87,6 @@ void CosmicsMatchingSpec::init(InitContext& ic)
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
   mMatching.setDebugFlag(ic.options().get<int>("debug-tree-flags"));
   mMatching.setUseMC(mUseMC);
-  mTPCCorrMapsLoader.init(ic);
   //
 }
 
@@ -132,10 +126,8 @@ void CosmicsMatchingSpec::updateTimeDependentParams(ProcessingContext& pc)
     }
     mMatching.init();
   }
-  bool updateMaps = false;
   if (mTPCCorrMapsLoader.isUpdated()) {
     mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateMaps = true;
   }
   mMatching.setTPCCorrMaps(&mTPCCorrMapsLoader);
   if (mTPCVDriftHelper.isUpdated()) {
@@ -145,10 +137,6 @@ void CosmicsMatchingSpec::updateTimeDependentParams(ProcessingContext& pc)
          mTPCVDriftHelper.getSourceName());
     mMatching.setTPCVDrift(mTPCVDriftHelper.getVDriftObject());
     mTPCVDriftHelper.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (updateMaps) {
-    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
   }
 }
 
@@ -160,9 +148,6 @@ void CosmicsMatchingSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
   if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
     LOG(info) << "cluster dictionary updated";
     mMatching.setITSDict((const o2::itsmft::TopologyDictionary*)obj);
@@ -177,7 +162,7 @@ void CosmicsMatchingSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool useMC)
 {
   std::vector<OutputSpec> outputs;
   Options opts{
@@ -203,13 +188,13 @@ DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool useMC, const
                                                               dataRequest->inputs,
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
 
   return DataProcessorSpec{
     "cosmics-matcher",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<CosmicsMatchingSpec>(dataRequest, ggRequest, sclOpts, useMC)},
+    AlgorithmSpec{adaptFromTask<CosmicsMatchingSpec>(dataRequest, ggRequest, useMC)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
index 6dfd1cb770d7f..fb9fc328175ea 100644
--- a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
@@ -58,14 +58,7 @@ namespace o2d = o2::dataformats;
 class SecondaryVertexingSpec : public Task
 {
  public:
-  SecondaryVertexingSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, GTrackID::mask_t src, bool enabCasc, bool enable3body, bool enableStrangenessTracking, bool enableCCDBParams, bool useMC) : mDataRequest(dr), mGGCCDBRequest(gr), mSrc(src), mEnableCascades(enabCasc), mEnable3BodyVertices(enable3body), mEnableStrangenessTracking(enableStrangenessTracking), mEnableCCDBParams(enableCCDBParams), mUseMC(useMC)
-  {
-    if (mSrc[GTrackID::TPC]) {
-      mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-      mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-      mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-    }
-  }
+  SecondaryVertexingSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool enabCasc, bool enable3body, bool enableStrangenessTracking, bool enableCCDBParams, bool useMC) : mDataRequest(dr), mGGCCDBRequest(gr), mSrc(src), mEnableCascades(enabCasc), mEnable3BodyVertices(enable3body), mEnableStrangenessTracking(enableStrangenessTracking), mEnableCCDBParams(enableCCDBParams), mUseMC(useMC) {}
   ~SecondaryVertexingSpec() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -107,9 +100,6 @@ void SecondaryVertexingSpec::init(InitContext& ic)
     mStrTracker.setMCTruthOn(mUseMC);
     mVertexer.setStrangenessTracker(&mStrTracker);
   }
-  if (mSrc[GTrackID::TPC]) {
-    mTPCCorrMapsLoader.init(ic);
-  }
 }
 
 void SecondaryVertexingSpec::run(ProcessingContext& pc)
@@ -157,9 +147,6 @@ void SecondaryVertexingSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* ob
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
   if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
     LOG(info) << "cluster dictionary updated";
     mStrTracker.setClusterDictionaryITS((const o2::itsmft::TopologyDictionary*)obj);
@@ -229,6 +216,7 @@ void SecondaryVertexingSpec::updateTimeDependentParams(ProcessingContext& pc)
       updateMaps = true;
     }
     mVertexer.setTPCCorrMaps(&mTPCCorrMapsLoader);
+
     if (mTPCVDriftHelper.isUpdated()) {
       LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
            mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
@@ -236,10 +224,6 @@ void SecondaryVertexingSpec::updateTimeDependentParams(ProcessingContext& pc)
            mTPCVDriftHelper.getSourceName());
       mVertexer.setTPCVDrift(mTPCVDriftHelper.getVDriftObject());
       mTPCVDriftHelper.acknowledgeUpdate();
-      updateMaps = true;
-    }
-    if (updateMaps) {
-      mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
     }
   }
   if (mEnableStrangenessTracking) {
@@ -253,7 +237,7 @@ void SecondaryVertexingSpec::updateTimeDependentParams(ProcessingContext& pc)
 }
 
 DataProcessorSpec getSecondaryVertexingSpec(GTrackID::mask_t src, bool enableCasc, bool enable3body, bool enableStrangenesTracking, bool enableCCDBParams,
-                                            bool useMC, bool useGeom, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+                                            bool useMC, bool useGeom)
 {
   std::vector<OutputSpec> outputs;
   Options opts{
@@ -297,7 +281,7 @@ DataProcessorSpec getSecondaryVertexingSpec(GTrackID::mask_t src, bool enableCas
   }
   if (src[GTrackID::TPC]) {
     o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-    o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+    o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
   }
   outputs.emplace_back("GLO", "V0S_IDX", 0, Lifetime::Timeframe);     // found V0s indices
   outputs.emplace_back("GLO", "V0S", 0, Lifetime::Timeframe);         // found V0s
@@ -324,7 +308,7 @@ DataProcessorSpec getSecondaryVertexingSpec(GTrackID::mask_t src, bool enableCas
     "secondary-vertexing",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<SecondaryVertexingSpec>(dataRequest, ggRequest, sclOpts, src, enableCasc, enable3body, enableStrangenesTracking, enableCCDBParams, useMC)},
+    AlgorithmSpec{adaptFromTask<SecondaryVertexingSpec>(dataRequest, ggRequest, src, enableCasc, enable3body, enableStrangenesTracking, enableCCDBParams, useMC)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
index 8081c48e390d3..ede3026647b1e 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
@@ -59,12 +59,7 @@ namespace globaltracking
 class TOFMatcherSpec : public Task
 {
  public:
-  TOFMatcherSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool useMC, bool useFIT, bool tpcRefit, bool strict, bool pushMatchable, int lanes = 1) : mDataRequest(dr), mGGCCDBRequest(gr), mUseMC(useMC), mUseFIT(useFIT), mDoTPCRefit(tpcRefit), mStrict(strict), mPushMatchable(pushMatchable), mNlanes(lanes)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-  }
+  TOFMatcherSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool useFIT, bool tpcRefit, bool strict, bool pushMatchable, int lanes = 1) : mDataRequest(dr), mGGCCDBRequest(gr), mUseMC(useMC), mUseFIT(useFIT), mDoTPCRefit(tpcRefit), mStrict(strict), mPushMatchable(pushMatchable), mNlanes(lanes) {}
   ~TOFMatcherSpec() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -96,7 +91,6 @@ void TOFMatcherSpec::init(InitContext& ic)
   if (mStrict) {
     mMatcher.setHighPurity();
   }
-  mTPCCorrMapsLoader.init(ic);
   mMatcher.storeMatchable(mPushMatchable);
   mMatcher.setExtraTimeToleranceTRD(mExtraTolTRD);
   mMatcher.setNlanes(mNlanes);
@@ -117,23 +111,17 @@ void TOFMatcherSpec::updateTimeDependentParams(ProcessingContext& pc)
     // put here init-once stuff
   }
   // we may have other params which need to be queried regularly
-  bool updateMaps = false;
   if (mTPCCorrMapsLoader.isUpdated()) {
     mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateMaps = true;
   }
   mMatcher.setTPCCorrMaps(&mTPCCorrMapsLoader);
-  if (mTPCVDriftHelper.isUpdated()) {
+    if (mTPCVDriftHelper.isUpdated()) {
     LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
          mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
          mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
          mTPCVDriftHelper.getSourceName());
     mMatcher.setTPCVDrift(mTPCVDriftHelper.getVDriftObject());
     mTPCVDriftHelper.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (updateMaps) {
-    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
   }
 }
 
@@ -145,9 +133,6 @@ void TOFMatcherSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
 }
 
 void TOFMatcherSpec::run(ProcessingContext& pc)
@@ -247,7 +232,7 @@ void TOFMatcherSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bool tpcRefit, bool strict, float extratolerancetrd, bool pushMatchable, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, int nlanes)
+DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bool tpcRefit, bool strict, float extratolerancetrd, bool pushMatchable, int nlanes)
 {
   uint32_t ss = o2::globaltracking::getSubSpec(strict ? o2::globaltracking::MatchingType::Strict : o2::globaltracking::MatchingType::Standard);
   Options opts;
@@ -273,7 +258,7 @@ DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bo
                                                               dataRequest->inputs,
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
   std::vector<OutputSpec> outputs;
   if (GID::includesSource(GID::TPC, src)) {
     outputs.emplace_back(o2::header::gDataOriginTOF, "MTC_TPC", ss, Lifetime::Timeframe);
@@ -327,7 +312,7 @@ DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bo
     "tof-matcher",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TOFMatcherSpec>(dataRequest, ggRequest, sclOpts, useMC, useFIT, tpcRefit, strict, pushMatchable, nlanes)},
+    AlgorithmSpec{adaptFromTask<TOFMatcherSpec>(dataRequest, ggRequest, useMC, useFIT, tpcRefit, strict, pushMatchable, nlanes)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
index cb3384b0631c2..38b6d6c1efb6e 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
@@ -69,14 +69,9 @@ namespace globaltracking
 class TPCITSMatchingDPL : public Task
 {
  public:
-  TPCITSMatchingDPL(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts,
+  TPCITSMatchingDPL(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr,
                     bool useFT0, bool calib, bool skipTPCOnly, bool useMC)
-    : mDataRequest(dr), mGGCCDBRequest(gr), mUseFT0(useFT0), mCalibMode(calib), mSkipTPCOnly(skipTPCOnly), mUseMC(useMC)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-  }
+    : mDataRequest(dr), mGGCCDBRequest(gr), mUseFT0(useFT0), mCalibMode(calib), mSkipTPCOnly(skipTPCOnly), mUseMC(useMC) {}
   ~TPCITSMatchingDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -108,7 +103,6 @@ void TPCITSMatchingDPL::init(InitContext& ic)
   mMatching.setNThreads(std::max(1, ic.options().get<int>("nthreads")));
   mMatching.setUseBCFilling(!ic.options().get<bool>("ignore-bc-check"));
   mMatching.setDebugFlag(ic.options().get<int>("debug-tree-flags"));
-  mTPCCorrMapsLoader.init(ic);
 }
 
 void TPCITSMatchingDPL::run(ProcessingContext& pc)
@@ -157,9 +151,6 @@ void TPCITSMatchingDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
   if (matcher == ConcreteDataMatcher("GLO", "ITSTPCPARAM", 0)) {
     LOG(info) << "ITS-TPC Matching params updated from ccdb";
     return;
@@ -236,20 +227,16 @@ void TPCITSMatchingDPL::updateTimeDependentParams(ProcessingContext& pc)
   mMatching.setTPCCorrMaps(&mTPCCorrMapsLoader);
 
   if (mTPCVDriftHelper.isUpdated()) {
-    LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
+    LOGP(info, "Updating TPC VDrift: corrFact {} wrt refVDrift {} and DriftTimeOffset correction {} wrt {} from source {}",
          mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
          mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
          mTPCVDriftHelper.getSourceName());
     mMatching.setTPCVDrift(mTPCVDriftHelper.getVDriftObject());
     mTPCVDriftHelper.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (updateMaps) {
-    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
   }
 }
 
-DataProcessorSpec getTPCITSMatchingSpec(GTrackID::mask_t src, bool useFT0, bool calib, bool skipTPCOnly, bool useGeom, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+DataProcessorSpec getTPCITSMatchingSpec(GTrackID::mask_t src, bool useFT0, bool calib, bool skipTPCOnly, bool useGeom, bool useMC)
 {
   std::vector<OutputSpec> outputs;
   auto dataRequest = std::make_shared<DataRequest>();
@@ -305,13 +292,13 @@ DataProcessorSpec getTPCITSMatchingSpec(GTrackID::mask_t src, bool useFT0, bool
     {"debug-tree-flags", VariantType::Int, 0, {"DebugFlagTypes bit-pattern for debug tree"}}};
 
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
 
   return DataProcessorSpec{
     "itstpc-track-matcher",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TPCITSMatchingDPL>(dataRequest, ggRequest, sclOpts, useFT0, calib, skipTPCOnly, useMC)},
+    AlgorithmSpec{adaptFromTask<TPCITSMatchingDPL>(dataRequest, ggRequest, useFT0, calib, skipTPCOnly, useMC)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
index 3f7ecfbbea809..db0e4253a7a51 100644
--- a/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
@@ -104,10 +104,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   }
   GID::mask_t srcCl = src;
   GID::mask_t dummy;
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::globaltracking::getCosmicsMatchingSpec(src, useMC, sclOpt));
+  specs.emplace_back(o2::globaltracking::getCosmicsMatchingSpec(src, useMC));
 
   o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, src, src, src, useMC, dummy); // clusters MC is not needed
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
index 5bc80f527d4d0..6d10fa786b0c9 100644
--- a/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
@@ -101,10 +101,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     }
   }
   WorkflowSpec specs;
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::vertexing::getSecondaryVertexingSpec(src, enableCasc, enable3body, enableStrTr, enableCCDBParams, useMC, useGeom, sclOpt));
+  specs.emplace_back(o2::vertexing::getSecondaryVertexingSpec(src, enableCasc, enable3body, enableStrTr, enableCCDBParams, useMC, useGeom));
 
   // only TOF clusters are needed if TOF is involved, no clusters MC needed
   WorkflowSpec inputspecs;
diff --git a/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
index 9a95c83617210..27adab7d50439 100644
--- a/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
@@ -168,10 +168,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
       specs.push_back(s);
     }
   }
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::globaltracking::getTOFMatcherSpec(src, useMC, useFIT, refitTPCTOF, strict, extratolerancetrd, writeMatchable, sclOpt, nLanes)); // doTPCrefit not yet supported (need to load TPC clusters?)
+  specs.emplace_back(o2::globaltracking::getTOFMatcherSpec(src, useMC, useFIT, refitTPCTOF, strict, extratolerancetrd, writeMatchable, nLanes)); // doTPCrefit not yet supported (need to load TPC clusters?)
 
   if (!disableRootOut) {
     std::vector<DataProcessorSpec> writers;
diff --git a/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
index 17ab2191f0e1e..0168c3076261e 100644
--- a/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
@@ -93,10 +93,10 @@ WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& configcont
   }
 
   o2::framework::WorkflowSpec specs;
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::globaltracking::getTPCITSMatchingSpec(srcL, useFT0, calib, !GID::includesSource(GID::TPC, src), useGeom, useMC, sclOpt));
+  specs.emplace_back(o2::globaltracking::getTPCITSMatchingSpec(srcL, useFT0, calib, !GID::includesSource(GID::TPC, src), useGeom, useMC));
 
   if (!configcontext.options().get<bool>("disable-root-output")) {
     specs.emplace_back(o2::globaltracking::getTrackWriterTPCITSSpec(useMC));
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCTrackStudy.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCTrackStudy.h
index 47385f400ec01..8f95203b52ffd 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCTrackStudy.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCTrackStudy.h
@@ -27,7 +27,7 @@ struct CorrectionMapsLoaderGloOpts;
 namespace o2::trackstudy
 {
 /// create a processor spec
-o2::framework::DataProcessorSpec getTPCTrackStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
+o2::framework::DataProcessorSpec getTPCTrackStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC);
 
 } // namespace o2::trackstudy
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudy.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudy.h
index d1326a47ac909..2fc21c6d7cd1c 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudy.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudy.h
@@ -21,7 +21,7 @@ namespace o2::trackstudy
 {
 
 /// create a processor spec
-o2::framework::DataProcessorSpec getTrackMCStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool checkSV);
+o2::framework::DataProcessorSpec getTrackMCStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool checkSV);
 
 } // namespace o2::trackstudy
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackingStudy.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackingStudy.h
index 7a15c191cbeed..caa50dc1d481a 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackingStudy.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackingStudy.h
@@ -23,7 +23,7 @@
 namespace o2::trackstudy
 {
 /// create a processor spec
-o2::framework::DataProcessorSpec getTrackingStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
+o2::framework::DataProcessorSpec getTrackingStudySpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC);
 
 } // namespace o2::trackstudy
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
index ee475acbbcf70..072993edfec4a 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
@@ -50,13 +50,8 @@ using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 class TPCTrackStudySpec final : public Task
 {
  public:
-  TPCTrackStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, GTrackID::mask_t src, bool useMC)
-    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-  }
+  TPCTrackStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC) {}
   ~TPCTrackStudySpec() final = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -108,7 +103,6 @@ void TPCTrackStudySpec::init(InitContext& ic)
   if (mXRef < 0.) {
     mXRef = 0.;
   }
-  mTPCCorrMapsLoader.init(ic);
   mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>("tpc-trackStudy.root", "recreate");
   if (ic.options().get<bool>("dump-clusters")) {
     mDBGOutCl = std::make_unique<o2::utils::TreeStreamRedirector>("tpc-trackStudy-cl.root", "recreate");
@@ -151,17 +145,6 @@ void TPCTrackStudySpec::updateTimeDependentParams(ProcessingContext& pc)
     mTPCCorrMapsLoader.acknowledgeUpdate();
     updateMaps = true;
   }
-  if (mTPCVDriftHelper.isUpdated()) {
-    LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
-         mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
-         mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
-         mTPCVDriftHelper.getSourceName());
-    mTPCVDriftHelper.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (updateMaps) {
-    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
-  }
 }
 
 void TPCTrackStudySpec::process(o2::globaltracking::RecoContainer& recoData)
@@ -415,12 +398,9 @@ void TPCTrackStudySpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
 }
 
-DataProcessorSpec getTPCTrackStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+DataProcessorSpec getTPCTrackStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC)
 {
   std::vector<OutputSpec> outputs;
   Options opts{
@@ -445,13 +425,13 @@ DataProcessorSpec getTPCTrackStudySpec(GTrackID::mask_t srcTracks, GTrackID::mas
                                                               dataRequest->inputs,
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
 
   return DataProcessorSpec{
     "tpc-track-study",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TPCTrackStudySpec>(dataRequest, ggRequest, sclOpts, srcTracks, useMC)},
+    AlgorithmSpec{adaptFromTask<TPCTrackStudySpec>(dataRequest, ggRequest, srcTracks, useMC)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 1db303d20e5d9..01d127c6511bd 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -86,13 +86,8 @@ using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 class TrackMCStudy final : public Task
 {
  public:
-  TrackMCStudy(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool checkSV)
-    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mCheckSV(checkSV)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-  }
+  TrackMCStudy(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool checkSV)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mCheckSV(checkSV) {}
   ~TrackMCStudy() final = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -179,7 +174,6 @@ void TrackMCStudy::init(InitContext& ic)
     mNCheckDecays++;
   }
   mDecaysMaps.resize(mNCheckDecays);
-  mTPCCorrMapsLoader.init(ic);
 }
 
 void TrackMCStudy::run(ProcessingContext& pc)
@@ -208,17 +202,6 @@ void TrackMCStudy::updateTimeDependentParams(ProcessingContext& pc)
     mTPCCorrMapsLoader.acknowledgeUpdate();
     updateMaps = true;
   }
-  if (mTPCVDriftHelper.isUpdated()) {
-    LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
-         mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
-         mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
-         mTPCVDriftHelper.getSourceName());
-    mTPCVDriftHelper.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (updateMaps) {
-    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
-  }
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
@@ -1023,9 +1006,6 @@ void TrackMCStudy::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
   if (matcher == ConcreteDataMatcher("ITS", "ALPIDEPARAM", 0)) {
     LOG(info) << "ITS Alpide param updated";
     const auto& par = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
@@ -1371,7 +1351,7 @@ void TrackMCStudy::processITSTracks(const o2::globaltracking::RecoContainer& rec
   }
 }
 
-DataProcessorSpec getTrackMCStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool checkSV)
+DataProcessorSpec getTrackMCStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool checkSV)
 {
   std::vector<OutputSpec> outputs;
   Options opts{
@@ -1390,7 +1370,7 @@ DataProcessorSpec getTrackMCStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask
     dataRequest->requestSecondaryVertices(useMC);
   }
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
                                                               true,                              // GRPECS=true
                                                               true,                              // GRPLHCIF
@@ -1404,7 +1384,7 @@ DataProcessorSpec getTrackMCStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask
     "track-mc-study",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TrackMCStudy>(dataRequest, ggRequest, srcTracks, sclOpts, checkSV)},
+    AlgorithmSpec{adaptFromTask<TrackMCStudy>(dataRequest, ggRequest, srcTracks, checkSV)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index a184058a1bfd6..042e884824274 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -70,13 +70,8 @@ using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 class TrackingStudySpec final : public Task
 {
  public:
-  TrackingStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
-    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-  }
+  TrackingStudySpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC) {}
   ~TrackingStudySpec() final = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -125,7 +120,6 @@ class TrackingStudySpec final : public Task
 void TrackingStudySpec::init(InitContext& ic)
 {
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
-  mTPCCorrMapsLoader.init(ic);
   int lane = ic.services().get<const o2::framework::DeviceSpec>().inputTimesliceId;
   int maxLanes = ic.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices;
   std::string dbgnm = maxLanes == 1 ? "trackStudy.root" : fmt::format("trackStudy_{}.root", lane);
@@ -232,17 +226,6 @@ void TrackingStudySpec::updateTimeDependentParams(ProcessingContext& pc)
     mTPCCorrMapsLoader.acknowledgeUpdate();
     updateMaps = true;
   }
-  if (mTPCVDriftHelper.isUpdated()) {
-    LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
-         mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
-         mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
-         mTPCVDriftHelper.getSourceName());
-    mTPCVDriftHelper.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (updateMaps) {
-    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
-  }
 }
 
 void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
@@ -724,9 +707,6 @@ void TrackingStudySpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
   if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
     LOG(info) << "Imposing new MeanVertex: " << ((const o2::dataformats::MeanVertexObject*)obj)->asString();
     mMeanVtx = *(const o2::dataformats::MeanVertexObject*)obj;
@@ -746,7 +726,7 @@ float TrackingStudySpec::getDCAZCut(float pt) const
   return fun.Eval(pt);
 }
 
-DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC)
 {
   std::vector<OutputSpec> outputs;
   auto dataRequest = std::make_shared<DataRequest>();
@@ -781,13 +761,13 @@ DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mas
     {"min-x-prop", VariantType::Float, 100.f, {"track should be propagated to this X at least"}},
   };
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
 
   return DataProcessorSpec{
     "track-study",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TrackingStudySpec>(dataRequest, ggRequest, srcTracks, useMC, sclOpts)},
+    AlgorithmSpec{adaptFromTask<TrackingStudySpec>(dataRequest, ggRequest, srcTracks, useMC)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/tpc-track-study-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/tpc-track-study-workflow.cxx
index 3e92178c81b7d..457ff034fa991 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/tpc-track-study-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/tpc-track-study-workflow.cxx
@@ -71,10 +71,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   }
   o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC);
   o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); // P-vertex is always needed
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::trackstudy::getTPCTrackStudySpec(srcTrc, srcCls, useMC, sclOpt));
+  specs.emplace_back(o2::trackstudy::getTPCTrackStudySpec(srcTrc, srcCls, useMC));
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
index 9e0055a389bfe..74add7dfebb51 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
@@ -82,11 +82,11 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   if (checkSV) {
     o2::globaltracking::InputHelper::addInputSpecsSVertex(configcontext, specs);
   }
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
 
-  specs.emplace_back(o2::trackstudy::getTrackMCStudySpec(srcTrc, srcCls, sclOpt, checkSV));
+  specs.emplace_back(o2::trackstudy::getTrackMCStudySpec(srcTrc, srcCls, checkSV));
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
index ae2e3b5301a14..932a21b6a902e 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
@@ -71,13 +71,13 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   if (sclOpt.requestCTPLumi) {
     srcCls = srcCls | GID::getSourcesMask("CTP");
   }
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
   o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC);
   o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); // P-vertex is always needed
 
-  specs.emplace_back(o2::trackstudy::getTrackingStudySpec(srcTrc, srcCls, useMC, sclOpt));
+  specs.emplace_back(o2::trackstudy::getTrackingStudySpec(srcTrc, srcCls, useMC));
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
diff --git a/Detectors/TPC/calibration/CMakeLists.txt b/Detectors/TPC/calibration/CMakeLists.txt
index a1068b928780d..905aa22e90e3b 100644
--- a/Detectors/TPC/calibration/CMakeLists.txt
+++ b/Detectors/TPC/calibration/CMakeLists.txt
@@ -59,6 +59,7 @@ o2_add_library(TPCCalibration
                        src/CorrectdEdxDistortions.cxx
                        src/PressureTemperatureHelper.cxx
                        src/CMVContainer.cxx
+                       src/CorrectionMapsLoaderFull.cxx
                PUBLIC_LINK_LIBRARIES O2::DataFormatsTPC O2::TPCBaseRecSim
                                      O2::TPCReconstruction ROOT::Minuit
                                      Microsoft.GSL::GSL
@@ -118,6 +119,7 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/CorrectdEdxDistortions.h
                                   include/TPCCalibration/PressureTemperatureHelper.h
                                   include/TPCCalibration/CMVContainer.h)
+                                  include/TPCCalibration/CorrectionMapsLoaderFull.h)
 
 o2_add_test_root_macro(macro/comparePedestalsAndNoise.C
                        PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
index 5a11ce3ea24e5..5524c1ed1f59c 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
@@ -27,29 +27,13 @@ namespace o2
 namespace framework
 {
 class ProcessingContext;
-class ConcreteDataMatcher;
 class InputSpec;
 class ConfigParamSpec;
-class ConfigParamRegistry;
-class InitContext;
 } // namespace framework
 
 namespace tpc
 {
 
-struct CorrectionMapsLoaderGloOpts {
-  int lumiType = 0; ///< what estimator to used for corrections scaling: 0: no scaling, 1: CTP, 2: IDC
-  int lumiMode = 0; ///< what corrections method to use: 0: classical scaling, 1: Using of the derivative map, 2: Using of the derivative map for MC
-  bool enableMShapeCorrection = false;
-  bool requestCTPLumi = true; //< request CTP Lumi regardless of what is used for corrections scaling
-  bool checkCTPIDCconsistency = true; //< check the selected CTP or IDC scaling source being consistent with mean scaler of the map
-
-  bool needTPCScalersWorkflow() const
-  {
-    return lumiType == 2 || enableMShapeCorrection;
-  }
-};
-
 class CorrectionMapsLoader : public o2::gpu::CorrectionMapsHelper
 {
  public:
@@ -58,27 +42,15 @@ class CorrectionMapsLoader : public o2::gpu::CorrectionMapsHelper
   CorrectionMapsLoader(const CorrectionMapsLoader&) = delete;
 
 #ifndef GPUCA_GPUCODE_DEVICE
-  bool accountCCDBInputs(const o2::framework::ConcreteDataMatcher& matcher, void* obj);
   void extractCCDBInputs(o2::framework::ProcessingContext& pc);
-  void updateVDrift(float vdriftCorr, float vdrifRef, float driftTimeOffset = 0);
-  void init(o2::framework::InitContext& ic);
-  void copySettings(const CorrectionMapsLoader& src);
-  void updateInverse(); /// recalculate inverse correction
-  void checkMeanScaleConsistency(float meanLumi, float threshold) const;
-  float getMapMeanRate(const o2::gpu::TPCFastTransform* mp, bool lumiOverridden) const;
 
-  static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, const CorrectionMapsLoaderGloOpts& gloOpts);
+  static void requestInputs(std::vector<o2::framework::InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options);
+  // static CorrectionMapsLoaderGloOpts parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts);
   static void addGlobalOptions(std::vector<o2::framework::ConfigParamSpec>& options);
-  static void addOptions(std::vector<o2::framework::ConfigParamSpec>& options);
-  static CorrectionMapsLoaderGloOpts parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts);
 
  protected:
   static void addOption(std::vector<o2::framework::ConfigParamSpec>& options, o2::framework::ConfigParamSpec&& osp);
   static void addInput(std::vector<o2::framework::InputSpec>& inputs, o2::framework::InputSpec&& isp);
-
-  float mInstLumiCTPFactor = 1.0; // multiplicative factor for inst. lumi
-  int mLumiCTPSource = 0;         // 0: main, 1: alternative CTP lumi source
-  std::unique_ptr<o2::gpu::TPCFastTransform> mCorrMapMShape{nullptr};
   bool mIDC2CTPFallbackActive = false; // flag indicating that fallback from IDC to CTP scaling is active
 #endif
 };
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoaderFull.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoaderFull.h
new file mode 100644
index 0000000000000..e60fa874c6d9f
--- /dev/null
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoaderFull.h
@@ -0,0 +1,64 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CorrectionMapsLoaderFull.h
+/// \brief Helper class to access load maps from CCDB
+/// \author matthias.kleiner@cern.ch
+
+#ifndef TPC_CORRECTION_MAPS_LOADERFULL_H_
+#define TPC_CORRECTION_MAPS_LOADERFULL_H_
+
+#include <vector>
+#include "CorrectionMapsHelperFull.h"
+#include "CorrectionMapsHelper.h"
+
+namespace o2
+{
+namespace framework
+{
+class ProcessingContext;
+class ConcreteDataMatcher;
+class InputSpec;
+class ConfigParamSpec;
+class InitContext;
+} // namespace framework
+
+namespace tpc
+{
+
+class CorrectionMapsLoaderFull : public o2::gpu::CorrectionMapsHelperFull
+{
+ public:
+  CorrectionMapsLoaderFull() = default;
+  ~CorrectionMapsLoaderFull() = default;
+  CorrectionMapsLoaderFull(const CorrectionMapsLoaderFull&) = delete;
+
+  bool accountCCDBInputs(const o2::framework::ConcreteDataMatcher& matcher, void* obj);
+  void extractCCDBInputs(o2::framework::ProcessingContext& pc, float tpcScaler = -1.f);
+  void init(o2::framework::InitContext& ic, bool idcsAvailable);
+  void checkMeanScaleConsistency(float meanLumi, float threshold) const;
+
+  static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, const o2::tpc::CorrectionMapsLoaderGloOpts& gloOpts);
+
+ protected:
+  static void addOption(std::vector<o2::framework::ConfigParamSpec>& options, o2::framework::ConfigParamSpec&& osp);
+  static void addInput(std::vector<o2::framework::InputSpec>& inputs, o2::framework::InputSpec&& isp);
+
+  float mInstLumiCTPFactor = 1.0; // multiplicative factor for inst. lumi
+  int mLumiCTPSource = 0;         // 0: main, 1: alternative CTP lumi source
+  bool mIDC2CTPFallbackActive = false; // flag indicating that fallback from IDC to CTP scaling is active
+};
+
+} // namespace tpc
+
+} // namespace o2
+
+#endif
diff --git a/Detectors/TPC/calibration/src/CalculatedEdx.cxx b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
index 478acda1189c2..c0f836e6b8452 100644
--- a/Detectors/TPC/calibration/src/CalculatedEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
@@ -32,8 +32,9 @@ using namespace o2::tpc;
 
 CalculatedEdx::CalculatedEdx()
 {
-  mTPCCorrMapsHelper.setOwner(true);
-  mTPCCorrMapsHelper.setCorrMap(TPCFastTransformHelperO2::instance()->create(0));
+  std::vector<char> buffer;
+  gpu::TPCFastTransformPOD::create(buffer, *TPCFastTransformHelperO2::instance()->create(0));
+  mTPCCorrMapsHelper.setCorrMap(std::move(buffer));
 }
 
 void CalculatedEdx::setMembers(std::vector<o2::tpc::TPCClRefElem>* tpcTrackClIdxVecInput, const o2::tpc::ClusterNativeAccess& clIndex, std::vector<o2::tpc::TrackTPC>* vTPCTracksArrayInp)
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index 038fe3c34e140..f20967f29b9f8 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -10,155 +10,74 @@
 // or submit itself to any jurisdiction.
 
 #include "TPCCalibration/CorrectionMapsLoader.h"
-#include "TPCCalibration/CorrMapParam.h"
-#include "TPCReconstruction/TPCFastTransformHelperO2.h"
-#include "TPCBaseRecSim/CDBInterface.h"
 #include "Framework/Logger.h"
 #include "Framework/ProcessingContext.h"
-#include "Framework/CCDBParamSpec.h"
 #include "Framework/InputRecord.h"
 #include "Framework/ConfigParamSpec.h"
-#include "Framework/ConcreteDataMatcher.h"
-#include "Framework/InitContext.h"
-#include "Framework/DeviceSpec.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "DataFormatsCTP/LumiInfo.h"
-#include "TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h"
-
+#include "TPCFastTransformPOD.h"
 using namespace o2::tpc;
 using namespace o2::framework;
 
 #ifndef GPUCA_GPUCODE_DEVICE
 
-//________________________________________________________
-void CorrectionMapsLoader::updateVDrift(float vdriftCorr, float vdrifRef, float driftTimeOffset)
-{
-  o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCorrMap, 0, vdriftCorr, vdrifRef, driftTimeOffset);
-  if (mCorrMapRef) {
-    o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCorrMapRef, 0, vdriftCorr, vdrifRef, driftTimeOffset);
-  }
-  if (mCorrMapMShape) {
-    o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCorrMapMShape, 0, vdriftCorr, vdrifRef, driftTimeOffset);
-  }
-}
-
 //________________________________________________________
 void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
 {
-  pc.inputs().get<o2::tpc::CorrMapParam*>("tpcCorrPar");
-  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMap");
-  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapRef");
-  const int maxDumRep = 5;
-  int dumRep = 0;
-  o2::ctp::LumiInfo lumiObj;
-  static o2::ctp::LumiInfo lumiPrev;
-
-  if (getLumiScaleType() == 2 || mIDC2CTPFallbackActive) {
-    float tpcScaler = pc.inputs().get<float>("tpcscaler");
-    // check if tpcScaler is valid and CTP fallback is allowed
-    if (tpcScaler == -1.f) {
-      const bool canUseCTPScaling = mCorrMap && mCorrMapRef && mCorrMap->isIDCSet() && mCorrMapRef->isIDCSet() && mCorrMap->isLumiSet() && mCorrMapRef->isLumiSet();
-      if (canUseCTPScaling) {
-        LOGP(info, "Invalid TPC scaler value {} received for IDC-based scaling! Using CTP fallback", tpcScaler);
-        mIDC2CTPFallbackActive = true;
-        setMeanLumi(mCorrMap->getLumi(), false);
-        setMeanLumiRef(mCorrMapRef->getLumi());
-        setLumiScaleType(1);
-      } else if (mCorrMap) {
-        // CTP scaling is not possible, dont do any scaling to avoid applying wrong corrections
-        const float storedIDC = mCorrMap->getIDC();
-        LOGP(warning, "Invalid TPC scaler value {} received for IDC-based scaling! CTP fallback not possible, using stored IDC of {} from the map to avoid applying wrong corrections", tpcScaler, storedIDC);
-        setInstLumi(storedIDC);
-      }
-    } else {
-      if (mIDC2CTPFallbackActive) {
-        // reset back to normal operation
-        LOGP(info, "Valid TPC scaler value {} received, switching back to IDC-based scaling", tpcScaler);
-        mIDC2CTPFallbackActive = false;
-        setMeanLumi(mCorrMap->getIDC(), false);
-        setMeanLumiRef(mCorrMapRef->getIDC());
-        setLumiScaleType(2);
-      }
-      // correct IDC received
-      setInstLumi(tpcScaler);
-    }
-  }
-
-  if (getLumiCTPAvailable() && mInstCTPLumiOverride <= 0.) {
-    if (pc.inputs().get<gsl::span<char>>("CTPLumi").size() == sizeof(o2::ctp::LumiInfo)) {
-      lumiPrev = lumiObj = pc.inputs().get<o2::ctp::LumiInfo>("CTPLumi");
-    } else {
-      if (dumRep < maxDumRep && lumiPrev.nHBFCounted == 0 && lumiPrev.nHBFCountedFV0 == 0) {
-        LOGP(alarm, "Previous TF lumi used to substitute dummy input is empty, warning {} of {}", ++dumRep, maxDumRep);
-      }
-      lumiObj = lumiPrev;
-    }
-    setInstLumiCTP(mInstLumiCTPFactor * (mLumiCTPSource == 0 ? lumiObj.getLumi() : lumiObj.getLumiAlt()));
-    if (getLumiScaleType() == 1) {
-      setInstLumi(getInstLumiCTP());
-    }
+  const bool lumiValid = pc.inputs().isValid("lumiCTP");
+  if(lumiValid) {
+    mInstLumiCTP = pc.inputs().get<float>("lumiCTP");
   }
 
-  if (getUseMShapeCorrection()) {
-    LOGP(info, "Setting M-Shape map");
-    const auto mapMShape = pc.inputs().get<o2::gpu::TPCFastTransform*>("mshape");
-    const_cast<o2::gpu::TPCFastTransform*>(mapMShape.get())->rectifyAfterReadingFromFile();
-    mCorrMapMShape = std::unique_ptr<TPCFastTransform>(new TPCFastTransform);
-    mCorrMapMShape->cloneFromObject(*(mapMShape.get()), nullptr);
-    setCorrMapMShape(mCorrMapMShape.get());
-    setUpdatedMapMShape();
+  const bool mapValid = pc.inputs().isValid("corrMap");
+  if(!mapValid) {
+    LOGP(info, "No correction map found in the input record!");
+    return;
   }
 
-  // update inverse in case it is requested
-  if (!mScaleInverse) {
-    updateInverse();
-  }
-  reportScaling();
+  // get the raw buffer and reinterpret as TPCFastTransformPOD
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  setCorrMap(&gpu::TPCFastTransformPOD::get(raw));
+  setUpdatedMap();
 }
 
 //________________________________________________________
-void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options, const CorrectionMapsLoaderGloOpts& gloOpts)
+void CorrectionMapsLoader::requestInputs(std::vector<InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options)
 {
-  if (gloOpts.lumiMode == 0) {
-    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});          // time-dependent
-    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
-  } else if (gloOpts.lumiMode == 1) {
-    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});            // time-dependent
-    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMap), {}, 1)}); // time-dependent
-  } else if (gloOpts.lumiMode == 2) {
-    // for MC corrections
-    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapMC), {}, 1)});            // time-dependent
-    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMapMC), {}, 1)}); // time-dependent
-  } else {
-    LOG(fatal) << "Correction mode unknown! Choose either 0 (default) or 1 (derivative map) for flag corrmap-lumi-mode.";
-  }
-
-  if (gloOpts.requestCTPLumi) {
-    addInput(inputs, {"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe});
-  }
-
-  if (gloOpts.lumiType == 2) {
-    addInput(inputs, {"tpcscaler", o2::header::gDataOriginTPC, "TPCSCALER", 0, Lifetime::Timeframe});
-  }
-
-  addInput(inputs, {"tpcCorrPar", "TPC", "CorrMapParam", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CorrMapParam), {}, 0)}); // load once
-
-  if (gloOpts.enableMShapeCorrection) {
-    addInput(inputs, {"mshape", o2::header::gDataOriginTPC, "TPCMSHAPE", 0, Lifetime::Timeframe});
-  }
-  addOptions(options);
+    addInput(inputs, {"corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe});
+    addInput(inputs, {"lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe});
 }
 
-//________________________________________________________
-void CorrectionMapsLoader::addOptions(std::vector<ConfigParamSpec>& options)
+void CorrectionMapsLoader::addInput(std::vector<InputSpec>& inputs, InputSpec&& isp)
 {
-  // these are options which should be added at the level of device using TPC corrections
-  // At the moment - nothing, all options are moved to configurable param CorrMapParam
-  addOption(options, ConfigParamSpec{"recalculate-inverse-correction", o2::framework::VariantType::Bool, false, {"recalculate the inverse correction in case lumi mode 1 or 2 is used"}});
-  addOption(options, ConfigParamSpec{"nthreads-inverse-correction", o2::framework::VariantType::Int, 4, {"Number of threads used for calculating the inverse correction (-1=all threads)"}});
+  if (std::find(inputs.begin(), inputs.end(), isp) == inputs.end()) {
+    inputs.emplace_back(isp);
+  }
 }
 
-//________________________________________________________
+// CorrectionMapsLoaderGloOpts CorrectionMapsLoader::parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts)
+// {
+//   CorrectionMapsLoaderGloOpts tpcopt;
+//   auto lumiTypeVal = opts.get<int>("lumi-type");
+//   if (lumiTypeVal < -1 || lumiTypeVal > 2) {
+//     LOGP(fatal, "Invalid lumi-type value: {}", lumiTypeVal);
+//   }
+//   tpcopt.lumiType = static_cast<LumiScaleType>(lumiTypeVal);
+
+//   auto lumiModeVal = opts.get<int>("corrmap-lumi-mode");
+//   if (lumiModeVal < -1 || lumiModeVal > 2) {
+//     LOGP(fatal, "Invalid corrmap-lumi-mode value: {}", lumiModeVal);
+//   }
+//   tpcopt.lumiMode = static_cast<LumiScaleMode>(lumiModeVal);
+
+//   tpcopt.enableMShapeCorrection = opts.get<bool>("enable-M-shape-correction");
+//   tpcopt.requestCTPLumi = !opts.get<bool>("disable-ctp-lumi-request");
+//   tpcopt.checkCTPIDCconsistency = !opts.get<bool>("disable-lumi-type-consistency-check");
+//   if (!tpcopt.requestCTPLumi && tpcopt.lumiType == LumiScaleType::CTPLumi) {
+//     LOGP(fatal, "Scaling with CTP Lumi is requested but this input is disabled");
+//   }
+//   return tpcopt;
+// }
+
 void CorrectionMapsLoader::addGlobalOptions(std::vector<ConfigParamSpec>& options)
 {
   // these are options which should be added at the workflow level, since they modify the inputs of the devices
@@ -169,30 +88,6 @@ void CorrectionMapsLoader::addGlobalOptions(std::vector<ConfigParamSpec>& option
   addOption(options, ConfigParamSpec{"disable-lumi-type-consistency-check", o2::framework::VariantType::Bool, false, {"disable check of selected CTP or IDC scaling source being consistent with the map"}});
 }
 
-//________________________________________________________
-CorrectionMapsLoaderGloOpts CorrectionMapsLoader::parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts)
-{
-  CorrectionMapsLoaderGloOpts tpcopt;
-  tpcopt.lumiType = opts.get<int>("lumi-type");
-  tpcopt.lumiMode = opts.get<int>("corrmap-lumi-mode");
-  tpcopt.enableMShapeCorrection = opts.get<bool>("enable-M-shape-correction");
-  tpcopt.requestCTPLumi = !opts.get<bool>("disable-ctp-lumi-request");
-  tpcopt.checkCTPIDCconsistency = !opts.get<bool>("disable-lumi-type-consistency-check");
-  if (!tpcopt.requestCTPLumi && tpcopt.lumiType == 1) {
-    LOGP(fatal, "Scaling with CTP Lumi is requested but this input is disabled");
-  }
-  return tpcopt;
-}
-
-//________________________________________________________
-void CorrectionMapsLoader::addInput(std::vector<InputSpec>& inputs, InputSpec&& isp)
-{
-  if (std::find(inputs.begin(), inputs.end(), isp) == inputs.end()) {
-    inputs.emplace_back(isp);
-  }
-}
-
-//________________________________________________________
 void CorrectionMapsLoader::addOption(std::vector<ConfigParamSpec>& options, ConfigParamSpec&& osp)
 {
   if (std::find(options.begin(), options.end(), osp) == options.end()) {
@@ -200,182 +95,4 @@ void CorrectionMapsLoader::addOption(std::vector<ConfigParamSpec>& options, Conf
   }
 }
 
-//________________________________________________________
-bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher, void* obj)
-{
-  if (matcher == ConcreteDataMatcher("TPC", "CorrMap", 0)) {
-    setCorrMap((o2::gpu::TPCFastTransform*)obj);
-    mCorrMap->rectifyAfterReadingFromFile();
-    mCorrMap->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
-    if (getMeanLumiOverride() != 0) {
-      if (getLumiScaleType() == 1) {
-        mCorrMap->setLumi(getMeanLumiOverride());
-        LOGP(info, "CorrMap mean lumi rate is overridden to {}", mCorrMap->getLumi());
-      } else if (getLumiScaleType() == 2) {
-        mCorrMap->setIDC(getMeanLumiOverride());
-        LOGP(info, "CorrMap mean IDC rate is overridden to {}", mCorrMap->getIDC());
-      }
-    }
-    float mapMeanRate = 0;
-    if (getLumiScaleType() == 1) {
-      mapMeanRate = mCorrMap->getLumi();
-    } else if (getLumiScaleType() == 2) {
-      mapMeanRate = mCorrMap->getIDC();
-    }
-    if (mCheckCTPIDCConsistency) {
-      checkMeanScaleConsistency(mapMeanRate, mCorrMap->getCTP2IDCFallBackThreshold());
-    }
-    if (getMeanLumiOverride() == 0 && mapMeanRate > 0.) {
-      setMeanLumi(mapMeanRate, false);
-    }
-    LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mapMeanRate, getMeanLumi());
-    setUpdatedMap();
-    return true;
-  }
-  if (matcher == ConcreteDataMatcher("TPC", "CorrMapRef", 0)) {
-    setCorrMapRef((o2::gpu::TPCFastTransform*)obj);
-    mCorrMapRef->rectifyAfterReadingFromFile();
-    mCorrMapRef->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
-    if (getMeanLumiRefOverride() != 0) {
-      if (getLumiScaleType() == 1) {
-        mCorrMapRef->setLumi(getMeanLumiRefOverride());
-        LOGP(info, "CorrMapRef mean lumi rate is overridden to {}", mCorrMapRef->getLumi());
-      } else if (getLumiScaleType() == 2) {
-        mCorrMapRef->setIDC(getMeanLumiRefOverride());
-        LOGP(info, "CorrMapRef mean IDC rate is overridden to {}", mCorrMapRef->getIDC());
-      }
-    }
-    float mapRefMeanRate = 0;
-    if (getLumiScaleType() == 1) {
-      mapRefMeanRate = mCorrMapRef->getLumi();
-    } else if (getLumiScaleType() == 2) {
-      mapRefMeanRate = mCorrMapRef->getIDC();
-    }
-    if (mCheckCTPIDCConsistency) {
-      checkMeanScaleConsistency(mapRefMeanRate, mCorrMapRef->getCTP2IDCFallBackThreshold());
-    }
-    if (getMeanLumiRefOverride() == 0) {
-      setMeanLumiRef(mapRefMeanRate);
-    }
-    LOGP(debug, "MeanLumiRefOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiRefOverride(), mapRefMeanRate, getMeanLumiRef());
-    setUpdatedMapRef();
-    return true;
-  }
-  if (matcher == ConcreteDataMatcher("TPC", "CorrMapParam", 0)) {
-    const auto& par = o2::tpc::CorrMapParam::Instance();
-    mMeanLumiOverride = par.lumiMean; // negative value switches off corrections !!!
-    mMeanLumiRefOverride = par.lumiMeanRef;
-    mInstCTPLumiOverride = par.lumiInst;
-    mInstLumiCTPFactor = par.lumiInstFactor;
-    mLumiCTPSource = par.ctpLumiSource;
-
-    if (mMeanLumiOverride != 0.) {
-      setMeanLumi(mMeanLumiOverride, false);
-    }
-    if (mMeanLumiRefOverride != 0.) {
-      setMeanLumiRef(mMeanLumiRefOverride);
-    }
-    if (mInstCTPLumiOverride != 0.) {
-      setInstLumiCTP(mInstCTPLumiOverride * mInstLumiCTPFactor);
-      if (getLumiScaleType() == 1) {
-        setInstLumi(getInstLumiCTP(), false);
-      }
-    }
-    setUpdatedLumi();
-    int scaleType = getLumiScaleType();
-    const std::array<std::string, 3> lumiS{"OFF", "CTP", "TPC scaler"};
-    if (scaleType >= lumiS.size()) {
-      LOGP(fatal, "Wrong corrmap-lumi-mode provided!");
-    }
-
-    LOGP(info, "TPC correction map params updated: SP corrections: {} (corr.map scaling type={}, override values: lumiMean={} lumiRefMean={} lumiScaleMode={}), CTP Lumi: source={} lumiInstOverride={} , LumiInst scale={} ",
-         canUseCorrections() ? "ON" : "OFF",
-         lumiS[scaleType], mMeanLumiOverride, mMeanLumiRefOverride, mLumiScaleMode, mLumiCTPSource, mInstCTPLumiOverride, mInstLumiCTPFactor);
-  }
-  return false;
-}
-
-//________________________________________________________
-void CorrectionMapsLoader::init(o2::framework::InitContext& ic)
-{
-  if (getLumiScaleMode() < 0) {
-    LOGP(fatal, "TPC correction lumi scaling mode is not set");
-  }
-  const auto& inputRouts = ic.services().get<const o2::framework::DeviceSpec>().inputs;
-  bool foundCTP = false, foundTPCScl = false, foundMShape = false;
-  for (const auto& route : inputRouts) {
-    if (route.matcher == InputSpec{"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe}) {
-      foundCTP = true;
-    } else if (route.matcher == InputSpec{"tpcscaler", o2::header::gDataOriginTPC, "TPCSCALER", 0, Lifetime::Timeframe}) {
-      foundTPCScl = true;
-    } else if (route.matcher == InputSpec{"mshape", o2::header::gDataOriginTPC, "TPCMSHAPE", 0, Lifetime::Timeframe}) {
-      foundMShape = true;
-    }
-  }
-  setLumiCTPAvailable(foundCTP);
-  enableMShapeCorrection(foundMShape);
-  if ((getLumiScaleType() == 1 && !foundCTP) || (getLumiScaleType() == 2 && !foundTPCScl)) {
-    LOGP(fatal, "Lumi scaling source {}({}) is not available for TPC correction", getLumiScaleType(), getLumiScaleType() == 1 ? "CTP" : "TPCScaler");
-  }
-
-  if ((getLumiScaleMode() == 1) || (getLumiScaleMode() == 2)) {
-    mScaleInverse = !(ic.options().get<bool>("recalculate-inverse-correction"));
-  } else {
-    mScaleInverse = true;
-  }
-  const int nthreadsInv = (ic.options().get<int>("nthreads-inverse-correction"));
-  (nthreadsInv < 0) ? TPCFastSpaceChargeCorrectionHelper::instance()->setNthreadsToMaximum() : TPCFastSpaceChargeCorrectionHelper::instance()->setNthreads(nthreadsInv);
-}
-
-//________________________________________________________
-void CorrectionMapsLoader::copySettings(const CorrectionMapsLoader& src)
-{
-  setInstLumi(src.getInstLumi(), false);
-  setInstLumiCTP(src.getInstLumiCTP());
-  setMeanLumi(src.getMeanLumi(), false);
-  setLumiCTPAvailable(src.getLumiCTPAvailable());
-  setMeanLumiRef(src.getMeanLumiRef());
-  setLumiScaleType(src.getLumiScaleType());
-  setMeanLumiOverride(src.getMeanLumiOverride());
-  setMeanLumiRefOverride(src.getMeanLumiRefOverride());
-  setInstCTPLumiOverride(src.getInstCTPLumiOverride());
-  setLumiScaleMode(src.getLumiScaleMode());
-  enableMShapeCorrection(src.getUseMShapeCorrection());
-  mInstLumiCTPFactor = src.mInstLumiCTPFactor;
-  mLumiCTPSource = src.mLumiCTPSource;
-  mLumiScaleMode = src.mLumiScaleMode;
-  mScaleInverse = src.getScaleInverse();
-  mIDC2CTPFallbackActive = src.mIDC2CTPFallbackActive;
-}
-
-void CorrectionMapsLoader::updateInverse()
-{
-  if (mLumiScaleMode == 1 || mLumiScaleMode == 2) {
-    LOGP(info, "Recalculating the inverse correction");
-    setUpdatedMap();
-    std::vector<float> scaling{1, mLumiScale};
-    std::vector<o2::gpu::TPCFastSpaceChargeCorrection*> corr{&(mCorrMap->getCorrection()), &(mCorrMapRef->getCorrection())};
-    if (mCorrMapMShape) {
-      scaling.emplace_back(1);
-      corr.emplace_back(&(mCorrMapMShape->getCorrection()));
-    }
-    TPCFastSpaceChargeCorrectionHelper::instance()->initInverse(corr, scaling, false);
-  } else {
-    LOGP(info, "Reinitializing inverse correction with lumi scale mode {} not supported for now", mLumiScaleMode);
-  }
-}
-
-void CorrectionMapsLoader::checkMeanScaleConsistency(float meanLumi, float threshold) const
-{
-  if (getLumiScaleType() == 1) {
-    if (meanLumi < threshold) {
-      LOGP(fatal, "CTP Lumi scaling source is requested, but the map mean scale {} is below the threshold {}", meanLumi, threshold);
-    }
-  } else if (getLumiScaleType() == 2) {
-    if (meanLumi > threshold) {
-      LOGP(fatal, "IDC scaling source is requested, but the map mean scale {} is above the threshold {}", meanLumi, threshold);
-    }
-  }
-}
-
 #endif // #ifndef GPUCA_GPUCODE_DEVICE
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoaderFull.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoaderFull.cxx
new file mode 100644
index 0000000000000..717dcaf62779a
--- /dev/null
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoaderFull.cxx
@@ -0,0 +1,253 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TPCCalibration/CorrectionMapsLoaderFull.h"
+#include "TPCCalibration/CorrMapParam.h"
+#include "TPCBaseRecSim/CDBTypes.h"
+#include "Framework/Logger.h"
+#include "Framework/ProcessingContext.h"
+#include "Framework/CCDBParamSpec.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/InitContext.h"
+#include "Framework/DeviceSpec.h"
+#include "DataFormatsCTP/LumiInfo.h"
+
+using namespace o2::tpc;
+using namespace o2::framework;
+// using namespace o2::gpu;
+
+//________________________________________________________
+void CorrectionMapsLoaderFull::extractCCDBInputs(ProcessingContext& pc, float tpcScaler)
+{
+  pc.inputs().get<o2::tpc::CorrMapParam*>("tpcCorrPar");
+  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMap");
+  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapRef");
+  const int maxDumRep = 5;
+  int dumRep = 0;
+  o2::ctp::LumiInfo lumiObj;
+  static o2::ctp::LumiInfo lumiPrev;
+
+  if (getLumiScaleType() == LumiScaleType::TPCScaler || mIDC2CTPFallbackActive) {
+    // check if tpcScaler is valid and CTP fallback is allowed
+    if (tpcScaler == -1.f) {
+      const bool canUseCTPScaling = mCorrMap && mCorrMapRef && mCorrMap->isIDCSet() && mCorrMapRef->isIDCSet() && mCorrMap->isLumiSet() && mCorrMapRef->isLumiSet();
+      if (canUseCTPScaling) {
+        LOGP(info, "Invalid TPC scaler value {} received for IDC-based scaling! Using CTP fallback", tpcScaler);
+        mIDC2CTPFallbackActive = true;
+        setMeanLumi(mCorrMap->getLumi(), false);
+        setMeanLumiRef(mCorrMapRef->getLumi());
+        setLumiScaleType(LumiScaleType::CTPLumi);
+      } else if (mCorrMap) {
+        // CTP scaling is not possible, dont do any scaling to avoid applying wrong corrections
+        const float storedIDC = mCorrMap->getIDC();
+        LOGP(warning, "Invalid TPC scaler value {} received for IDC-based scaling! CTP fallback not possible, using stored IDC of {} from the map to avoid applying wrong corrections", tpcScaler, storedIDC);
+        setInstLumi(storedIDC);
+      }
+    } else {
+      if (mIDC2CTPFallbackActive) {
+        // reset back to normal operation
+        LOGP(info, "Valid TPC scaler value {} received, switching back to IDC-based scaling", tpcScaler);
+        mIDC2CTPFallbackActive = false;
+        setMeanLumi(mCorrMap->getIDC(), false);
+        setMeanLumiRef(mCorrMapRef->getIDC());
+        setLumiScaleType(LumiScaleType::TPCScaler);
+      }
+      // correct IDC received
+      setInstLumi(tpcScaler);
+    }
+  }
+
+  if (getLumiCTPAvailable() && mInstCTPLumiOverride <= 0.) {
+    if (pc.inputs().get<gsl::span<char>>("CTPLumi").size() == sizeof(o2::ctp::LumiInfo)) {
+      lumiPrev = lumiObj = pc.inputs().get<o2::ctp::LumiInfo>("CTPLumi");
+    } else {
+      if (dumRep < maxDumRep && lumiPrev.nHBFCounted == 0 && lumiPrev.nHBFCountedFV0 == 0) {
+        LOGP(alarm, "Previous TF lumi used to substitute dummy input is empty, warning {} of {}", ++dumRep, maxDumRep);
+      }
+      lumiObj = lumiPrev;
+    }
+    setInstLumiCTP(mInstLumiCTPFactor * (mLumiCTPSource == 0 ? lumiObj.getLumi() : lumiObj.getLumiAlt()));
+    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+      setInstLumi(getInstLumiCTP());
+    }
+  }
+
+  reportScaling();
+}
+
+//________________________________________________________
+void CorrectionMapsLoaderFull::requestCCDBInputs(std::vector<InputSpec>& inputs, const CorrectionMapsLoaderGloOpts& gloOpts)
+{
+  LOGP(info, "Requesting CCDB inputs for TPC correction maps with lumiType={} and lumiMode={}", static_cast<int>(gloOpts.lumiType), static_cast<int>(gloOpts.lumiMode));
+  if (gloOpts.lumiMode == LumiScaleMode::Linear) {
+    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});          // time-dependent
+    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
+  } else if (gloOpts.lumiMode == LumiScaleMode::DerivativeMap) {
+    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});            // time-dependent
+    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMap), {}, 1)}); // time-dependent
+  } else if (gloOpts.lumiMode == LumiScaleMode::DerivativeMapMC) {
+    // for MC corrections
+    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapMC), {}, 1)});            // time-dependent
+    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMapMC), {}, 1)}); // time-dependent
+  } else {
+    LOG(fatal) << "Correction mode unknown! Choose either 0 (default) or 1 (derivative map) for flag corrmap-lumi-mode.";
+  }
+
+  if (gloOpts.requestCTPLumi) {
+    addInput(inputs, {"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe});
+  }
+
+  addInput(inputs, {"tpcCorrPar", "TPC", "CorrMapParam", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CorrMapParam), {}, 0)}); // load once
+}
+
+//________________________________________________________
+void CorrectionMapsLoaderFull::addInput(std::vector<InputSpec>& inputs, InputSpec&& isp)
+{
+  if (std::find(inputs.begin(), inputs.end(), isp) == inputs.end()) {
+    inputs.emplace_back(isp);
+  }
+}
+
+//________________________________________________________
+void CorrectionMapsLoaderFull::addOption(std::vector<ConfigParamSpec>& options, ConfigParamSpec&& osp)
+{
+  if (std::find(options.begin(), options.end(), osp) == options.end()) {
+    options.emplace_back(osp);
+  }
+}
+
+//________________________________________________________
+bool CorrectionMapsLoaderFull::accountCCDBInputs(const ConcreteDataMatcher& matcher, void* obj)
+{
+  if (matcher == ConcreteDataMatcher("TPC", "CorrMap", 0)) {
+    setCorrMap((o2::gpu::TPCFastTransform*)obj);
+    mCorrMap->rectifyAfterReadingFromFile();
+    mCorrMap->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
+    if (getMeanLumiOverride() != 0) {
+      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+        mCorrMap->setLumi(getMeanLumiOverride());
+        LOGP(info, "CorrMap mean lumi rate is overridden to {}", mCorrMap->getLumi());
+      } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+        mCorrMap->setIDC(getMeanLumiOverride());
+        LOGP(info, "CorrMap mean IDC rate is overridden to {}", mCorrMap->getIDC());
+      }
+    }
+    float mapMeanRate = 0;
+    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+      mapMeanRate = mCorrMap->getLumi();
+    } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+      mapMeanRate = mCorrMap->getIDC();
+    }
+    if (mCheckCTPIDCConsistency) {
+      checkMeanScaleConsistency(mapMeanRate, mCorrMap->getCTP2IDCFallBackThreshold());
+    }
+    if (getMeanLumiOverride() == 0 && mapMeanRate > 0.) {
+      setMeanLumi(mapMeanRate, false);
+    }
+    LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mapMeanRate, getMeanLumi());
+    setUpdatedMap();
+    return true;
+  }
+  if (matcher == ConcreteDataMatcher("TPC", "CorrMapRef", 0)) {
+    setCorrMapRef((o2::gpu::TPCFastTransform*)obj);
+    mCorrMapRef->rectifyAfterReadingFromFile();
+    mCorrMapRef->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
+    if (getMeanLumiRefOverride() != 0) {
+      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+        mCorrMapRef->setLumi(getMeanLumiRefOverride());
+        LOGP(info, "CorrMapRef mean lumi rate is overridden to {}", mCorrMapRef->getLumi());
+      } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+        mCorrMapRef->setIDC(getMeanLumiRefOverride());
+        LOGP(info, "CorrMapRef mean IDC rate is overridden to {}", mCorrMapRef->getIDC());
+      }
+    }
+    float mapRefMeanRate = 0;
+    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+      mapRefMeanRate = mCorrMapRef->getLumi();
+    } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+      mapRefMeanRate = mCorrMapRef->getIDC();
+    }
+    if (mCheckCTPIDCConsistency) {
+      checkMeanScaleConsistency(mapRefMeanRate, mCorrMapRef->getCTP2IDCFallBackThreshold());
+    }
+    if (getMeanLumiRefOverride() == 0) {
+      setMeanLumiRef(mapRefMeanRate);
+    }
+    LOGP(debug, "MeanLumiRefOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiRefOverride(), mapRefMeanRate, getMeanLumiRef());
+    setUpdatedMapRef();
+    return true;
+  }
+  if (matcher == ConcreteDataMatcher("TPC", "CorrMapParam", 0)) {
+    const auto& par = o2::tpc::CorrMapParam::Instance();
+    mMeanLumiOverride = par.lumiMean; // negative value switches off corrections !!!
+    mMeanLumiRefOverride = par.lumiMeanRef;
+    mInstCTPLumiOverride = par.lumiInst;
+    mInstLumiCTPFactor = par.lumiInstFactor;
+    mLumiCTPSource = par.ctpLumiSource;
+
+    if (mMeanLumiOverride != 0.) {
+      setMeanLumi(mMeanLumiOverride, false);
+    }
+    if (mMeanLumiRefOverride != 0.) {
+      setMeanLumiRef(mMeanLumiRefOverride);
+    }
+    if (mInstCTPLumiOverride != 0.) {
+      setInstLumiCTP(mInstCTPLumiOverride * mInstLumiCTPFactor);
+      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+        setInstLumi(getInstLumiCTP(), false);
+      }
+    }
+    setUpdatedLumi();
+    int scaleType = static_cast<int>(getLumiScaleType());
+    const std::array<std::string, 3> lumiS{"OFF", "CTP", "TPC scaler"};
+    if (scaleType >= lumiS.size()) {
+      LOGP(fatal, "Wrong corrmap-lumi-mode provided!");
+    }
+
+    LOGP(info, "TPC correction map params updated: SP corrections: {} (corr.map scaling type={}, override values: lumiMean={} lumiRefMean={} lumiScaleMode={}), CTP Lumi: source={} lumiInstOverride={} , LumiInst scale={} ",
+         canUseCorrections() ? "ON" : "OFF",
+         lumiS[scaleType], mMeanLumiOverride, mMeanLumiRefOverride, static_cast<int>(getLumiScaleMode()), mLumiCTPSource, mInstCTPLumiOverride, mInstLumiCTPFactor);
+  }
+  return false;
+}
+
+//________________________________________________________
+void CorrectionMapsLoaderFull::init(o2::framework::InitContext& ic, bool idcsAvailable)
+{
+  if (getLumiScaleMode() == LumiScaleMode::Unset) {
+    LOGP(fatal, "TPC correction lumi scaling mode is not set");
+  }
+  const auto& inputRouts = ic.services().get<const o2::framework::DeviceSpec>().inputs;
+  bool foundCTP = false;
+  for (const auto& route : inputRouts) {
+    if (route.matcher == InputSpec{"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe}) {
+      foundCTP = true;
+    } 
+  }
+  setLumiCTPAvailable(foundCTP);
+  if ((getLumiScaleType() == LumiScaleType::CTPLumi && !foundCTP) || (getLumiScaleType() == LumiScaleType::TPCScaler && !idcsAvailable)) {
+    LOGP(fatal, "Lumi scaling source {}({}) is not available for TPC correction", static_cast<int>(getLumiScaleType()), getLumiScaleType() == LumiScaleType::CTPLumi ? "CTP" : "TPCScaler");
+  }
+}
+
+void CorrectionMapsLoaderFull::checkMeanScaleConsistency(float meanLumi, float threshold) const
+{
+  if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+    if (meanLumi < threshold) {
+      LOGP(fatal, "CTP Lumi scaling source is requested, but the map mean scale {} is below the threshold {}", meanLumi, threshold);
+    }
+  } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+    if (meanLumi > threshold) {
+      LOGP(fatal, "IDC scaling source is requested, but the map mean scale {} is above the threshold {}", meanLumi, threshold);
+    }
+  }
+}
diff --git a/Detectors/TPC/calibration/src/TrackDump.cxx b/Detectors/TPC/calibration/src/TrackDump.cxx
index 421750a5cb22b..f78d958a54bd3 100644
--- a/Detectors/TPC/calibration/src/TrackDump.cxx
+++ b/Detectors/TPC/calibration/src/TrackDump.cxx
@@ -237,9 +237,8 @@ float TrackDump::ClusterNativeAdd::zc(float vertexTime) const
 
 void TrackDump::ClusterNativeAdd::loadCorrMaps(std::string_view corrMapFile, std::string_view corrMapFileRef)
 {
-  sCorrHelper.setOwner(true);
-  sCorrHelper.setCorrMap(gpu::TPCFastTransform::loadFromFile(corrMapFile.data()));
-  if (!corrMapFileRef.empty()) {
-    sCorrHelper.setCorrMapRef(gpu::TPCFastTransform::loadFromFile(corrMapFileRef.data()));
-  }
+  auto fastTransformTmp = gpu::TPCFastTransform::loadFromFile(corrMapFile.data());
+  std::vector<char> buffer;
+  gpu::TPCFastTransformPOD::create(buffer, *fastTransformTmp);
+  sCorrHelper.setCorrMap(std::move(buffer));
 }
diff --git a/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h b/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
index f94bff0acc076..aa042ab16b627 100644
--- a/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
+++ b/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
@@ -21,9 +21,8 @@
 #ifndef ALICEO2_TPC_TPCFASTTRANSFORMHELPERO2_H_
 #define ALICEO2_TPC_TPCFASTTRANSFORMHELPERO2_H_
 
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "Rtypes.h"
-#include <functional>
 
 namespace o2
 {
@@ -61,7 +60,15 @@ class TPCFastTransformHelperO2
   std::unique_ptr<TPCFastTransform> create(Long_t TimeStamp, const TPCFastSpaceChargeCorrection& correction);
 
   /// Updates the transformation with the new time stamp
-  int updateCalibration(TPCFastTransform& transform, Long_t TimeStamp, float vDriftFactor = 1.f, float vDriftRef = 0.f, float driftTimeOffset = 0.f);
+  int updateCalibration(TPCFastTransform& fastTransform, Long_t TimeStamp, float vDriftFactor = 1.f, float vDriftRef = 0.f, float driftTimeOffset = 0.f)
+  {
+    return updateCalibrationImpl(fastTransform, TimeStamp, vDriftFactor, vDriftRef, driftTimeOffset);
+  }
+
+  int updateCalibration(TPCFastTransformPOD& fastTransform, Long_t TimeStamp, float vDriftFactor = 1.f, float vDriftRef = 0.f, float driftTimeOffset = 0.f)
+  {
+    return updateCalibrationImpl(fastTransform, TimeStamp, vDriftFactor, vDriftRef, driftTimeOffset);
+  }
 
   /// _______________  Utilities   ________________________
 
@@ -73,6 +80,9 @@ class TPCFastTransformHelperO2
   /// initialization
   void init();
 
+  template <typename T>
+  int updateCalibrationImpl(T& transform, Long_t TimeStamp, float vDriftFactor, float vDriftRef, float driftTimeOffset);
+
   static TPCFastTransformHelperO2* sInstance; ///< singleton instance
   bool mIsInitialized = 0;                    ///< initialization flag
   TPCFastTransformGeo mGeo;                   ///< geometry parameters
diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index 419ced9fa978e..6e0bccbdc40fe 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -22,8 +22,6 @@
 #include "TPCBase/Sector.h"
 #include "DataFormatsTPC/Defs.h"
 #include "TPCFastTransform.h"
-#include "Spline2DHelper.h"
-#include "Riostream.h"
 #include <fairlogger/Logger.h>
 
 using namespace o2::gpu;
@@ -136,7 +134,8 @@ std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(Long_t TimeSt
   return create(TimeStamp, correction);
 }
 
-int TPCFastTransformHelperO2::updateCalibration(TPCFastTransform& fastTransform, Long_t TimeStamp, float vDriftFactor, float vDriftRef, float driftTimeOffset)
+template <typename T>
+int TPCFastTransformHelperO2::updateCalibrationImpl(T& fastTransform, Long_t TimeStamp, float vDriftFactor, float vDriftRef, float driftTimeOffset)
 {
   // Update the calibration with the new time stamp
   LOGP(debug, "Updating calibration: timestamp:{} vdriftFactor:{} vdriftRef:{}", TimeStamp, vDriftFactor, vDriftRef);
@@ -150,7 +149,6 @@ int TPCFastTransformHelperO2::updateCalibration(TPCFastTransform& fastTransform,
 
   // search for the calibration database ...
 
-  auto& detParam = ParameterDetector::Instance();
   auto& gasParam = ParameterGas::Instance();
   auto& elParam = ParameterElectronics::Instance();
   // start the initialization
@@ -228,5 +226,9 @@ void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) cons
                << " max Dx " << maxDx << " max Dy " << maxDy << std::endl;
   }
 }
+
+template int TPCFastTransformHelperO2::updateCalibrationImpl(TPCFastTransform&, Long_t, float, float, float);
+template int TPCFastTransformHelperO2::updateCalibrationImpl(TPCFastTransformPOD&, Long_t, float, float, float);
+
 } // namespace tpc
 } // namespace o2
diff --git a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
index 0debfa72dd7fa..2b21053bda1ff 100644
--- a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
+++ b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
@@ -25,7 +25,7 @@
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 
 #include "CorrectionMapsHelper.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "GPUO2Interface.h"
 #include "GPUO2InterfaceUtils.h"
 #include "GPUO2InterfaceConfiguration.h"
@@ -74,10 +74,13 @@ BOOST_AUTO_TEST_CASE(CATracking_test1)
   config.configWorkflow.inputs.set(gpudatatypes::InOutType::TPCClusters);
   config.configWorkflow.outputs.set(gpudatatypes::InOutType::TPCMergedTracks);
 
-  std::unique_ptr<TPCFastTransform> fastTransform(TPCFastTransformHelperO2::instance()->create(0));
+  auto fastTransformTmp = TPCFastTransformHelperO2::instance()->create(0);
+  std::vector<char> fastTransformBuf;
+  TPCFastTransformPOD::create(fastTransformBuf, *fastTransformTmp);
+
   std::unique_ptr<CorrectionMapsHelper> fastTransformHelper(new CorrectionMapsHelper());
-  fastTransformHelper->setCorrMap(fastTransform.get());
-  config.configCalib.fastTransform = fastTransform.get();
+  fastTransformHelper->setCorrMap(std::move(fastTransformBuf));
+  config.configCalib.fastTransform = fastTransformHelper->getCorrMap();
   config.configCalib.fastTransformHelper = fastTransformHelper.get();
   auto dEdxCalibContainer = GPUO2InterfaceUtils::getCalibdEdxContainerDefault();
   config.configCalib.dEdxCalibContainer = dEdxCalibContainer.get();
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
index 516ea128acfe7..8e88a27d51e7f 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
@@ -26,7 +26,6 @@
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "Framework/CCDBParamSpec.h"
 #include "TPCBaseRecSim/CDBInterface.h"
-#include "TPCCalibration/VDriftHelper.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "GPUO2InterfaceUtils.h"
@@ -45,22 +44,18 @@ namespace tpc
 class TPCCalibPadGainTracksDevice : public o2::framework::Task
 {
  public:
-  TPCCalibPadGainTracksDevice(std::shared_ptr<o2::globaltracking::DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> req, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, const uint32_t publishAfterTFs, const bool debug, const bool useLastExtractedMapAsReference, const std::string polynomialsFile, const bool disablePolynomialsCCDB) : mDataRequest(dr), mPublishAfter(publishAfterTFs), mDebug(debug), mUseLastExtractedMapAsReference(useLastExtractedMapAsReference), mDisablePolynomialsCCDB(disablePolynomialsCCDB), mCCDBRequest(req)
+  TPCCalibPadGainTracksDevice(std::shared_ptr<o2::globaltracking::DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> req, const uint32_t publishAfterTFs, const bool debug, const bool useLastExtractedMapAsReference, const std::string polynomialsFile, const bool disablePolynomialsCCDB) : mDataRequest(dr), mPublishAfter(publishAfterTFs), mDebug(debug), mUseLastExtractedMapAsReference(useLastExtractedMapAsReference), mDisablePolynomialsCCDB(disablePolynomialsCCDB), mCCDBRequest(req)
   {
     if (!polynomialsFile.empty()) {
       LOGP(info, "Loading polynomials from file {}", polynomialsFile);
       mPadGainTracks.loadPolTopologyCorrectionFromFile(polynomialsFile.data());
       mDisablePolynomialsCCDB = true;
     }
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
   }
 
   void init(o2::framework::InitContext& ic) final
   {
     o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
-    mTPCCorrMapsLoader.init(ic);
     // setting up the histogram ranges
     const auto nBins = ic.options().get<int>("nBins");
     auto reldEdxMin = ic.options().get<float>("reldEdxMin");
@@ -151,8 +146,6 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
       LOGP(info, "Updating Q topology correction from CCDB");
       const auto* topologyCorr = static_cast<o2::tpc::CalibdEdxTrackTopologyPolContainer*>(obj);
       mPadGainTracks.setPolTopologyCorrectionFromContainer(*topologyCorr);
-    } else if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
-    } else if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
     } else if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
       const auto field = o2::gpu::GPUO2InterfaceUtils::getNominalGPUBz(*o2::base::GRPGeomHelper::instance().getGRPMagField());
       LOGP(info, "Setting magnetic field to {} kG", field);
@@ -188,7 +181,6 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
       LOGP(info, "fetching residual gain map");
       pc.inputs().get<std::unordered_map<std::string, o2::tpc::CalDet<float>>*>("tpcresidualgainmap");
     }
-    mTPCVDriftHelper.extractCCDBInputs(pc);
     mTPCCorrMapsLoader.extractCCDBInputs(pc);
     bool updateMaps = false;
     if (mTPCCorrMapsLoader.isUpdated()) {
@@ -196,19 +188,6 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
       updateMaps = true;
     }
     mPadGainTracks.setTPCCorrMaps(&mTPCCorrMapsLoader);
-    if (mTPCVDriftHelper.isUpdated()) {
-      LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
-           mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
-           mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
-           mTPCVDriftHelper.getSourceName());
-      mPadGainTracks.setTPCVDrift(mTPCVDriftHelper.getVDriftObject());
-      mTPCVDriftHelper.acknowledgeUpdate();
-      updateMaps = true;
-    }
-    if (updateMaps) {
-      mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
-    }
-
     mPadGainTracks.setMembers(&tracks, &clRefs, clusters->clusterIndex, recoData.clusterShMapTPC, recoData.occupancyMapTPC);
     mPadGainTracks.processTracks(mMaxTracksPerTF);
     ++mProcessedTFs;
@@ -237,7 +216,6 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
   unsigned int mUseEveryNthTF{1};                         ///< process every Nth TF only
   unsigned int mFirstTFSend{1};                           ///< first TF for which the data will be send (initialized randomly)
   int mMaxTracksPerTF{-1};                                ///< max number of tracks processed per TF
-  o2::tpc::VDriftHelper mTPCVDriftHelper{};
   o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
 
   void sendOutput(DataAllocator& output)
@@ -247,16 +225,16 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
   }
 };
 
-DataProcessorSpec getTPCCalibPadGainTracksSpec(const uint32_t publishAfterTFs, const bool debug, const bool useLastExtractedMapAsReference, const std::string polynomialsFile, bool disablePolynomialsCCDB, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+DataProcessorSpec getTPCCalibPadGainTracksSpec(const uint32_t publishAfterTFs, const bool debug, const bool useLastExtractedMapAsReference, const std::string polynomialsFile, bool disablePolynomialsCCDB)
 {
   std::vector<InputSpec> inputs;
   auto dataRequest = std::make_shared<o2::globaltracking::DataRequest>();
   dataRequest->requestTracks(o2::dataformats::GlobalTrackID::getSourceMask(o2::dataformats::GlobalTrackID::TPC), false);
   dataRequest->requestClusters(o2::dataformats::GlobalTrackID::getSourceMask(o2::dataformats::GlobalTrackID::TPC), false);
 
-  if (sclOpts.lumiType == 1) {
-    dataRequest->inputs.emplace_back("CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe);
-  }
+  // if (sclOpts.lumiType == 1) {
+  //   dataRequest->inputs.emplace_back("CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe);
+  // }
 
   if (!polynomialsFile.empty()) {
     disablePolynomialsCCDB = true;
@@ -270,7 +248,6 @@ DataProcessorSpec getTPCCalibPadGainTracksSpec(const uint32_t publishAfterTFs, c
     dataRequest->inputs.emplace_back("tpcresidualgainmap", gDataOriginTPC, "RESIDUALGAINMAP", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalPadGainResidual)));
   }
 
-  o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
   Options opts{
     {"nBins", VariantType::Int, 20, {"Number of bins per histogram"}},
     {"reldEdxMin", VariantType::Int, 0, {"Minimum x coordinate of the histogram for Q/(dE/dx)"}},
@@ -293,7 +270,7 @@ DataProcessorSpec getTPCCalibPadGainTracksSpec(const uint32_t publishAfterTFs, c
     {"useEveryNthTF", VariantType::Int, 10, {"Using only a fraction of the data: 1: Use every TF, 10: Use only every tenth TF."}},
     {"maxTracksPerTF", VariantType::Int, 10000, {"Maximum number of processed tracks per TF (-1 for processing all tracks)"}},
   };
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
 
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
                                                                 false,                          // GRPECS=true
@@ -310,7 +287,7 @@ DataProcessorSpec getTPCCalibPadGainTracksSpec(const uint32_t publishAfterTFs, c
     "calib-tpc-gainmap-tracks",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TPCCalibPadGainTracksDevice>(dataRequest, ccdbRequest, sclOpts, publishAfterTFs, debug, useLastExtractedMapAsReference, polynomialsFile, disablePolynomialsCCDB)},
+    AlgorithmSpec{adaptFromTask<TPCCalibPadGainTracksDevice>(dataRequest, ccdbRequest, publishAfterTFs, debug, useLastExtractedMapAsReference, polynomialsFile, disablePolynomialsCCDB)},
     opts}; // end DataProcessorSpec
 }
 
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCRefitter.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCRefitter.h
index 31a5ce756142a..e2d8a2de3912d 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCRefitter.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCRefitter.h
@@ -23,7 +23,7 @@ struct CorrectionMapsLoaderGloOpts;
 namespace o2::trackstudy
 {
 /// create a processor spec
-o2::framework::DataProcessorSpec getTPCRefitterSpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool requestCosmics = false);
+o2::framework::DataProcessorSpec getTPCRefitterSpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC, bool requestCosmics = false);
 
 } // namespace o2::trackstudy
 
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCScalerSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCScalerSpec.h
index b85a882870ecb..950ef9a248443 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCScalerSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCScalerSpec.h
@@ -13,13 +13,14 @@
 #define O2_TPC_TPCSCALER_SPEC
 
 #include "Framework/DataProcessorSpec.h"
+#include "TPCCalibration/CorrectionMapsLoader.h"
 
 namespace o2
 {
 namespace tpc
 {
 
-o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMShape);
+o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMShape, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
 
 } // end namespace tpc
 } // end namespace o2
diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index 3054dd5d61519..fb9b09329bfab 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -201,9 +201,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
                                                            laneConfiguration,
                                                            &hook},
                                                          propagateMC));
-      if (sclOpts.needTPCScalersWorkflow()) { // for standalone tpc-reco workflow
-        specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpts.lumiType == 2, sclOpts.enableMShapeCorrection));
-      }
+      specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpts.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpts.enableMShapeCorrection, sclOpts));
       if (produceTracks && sclOpts.requestCTPLumi) { // need CTP digits (lumi) reader
         specs.emplace_back(o2::ctp::getDigitsReaderSpec(false));
       }
@@ -225,9 +223,7 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
       if (!getenv("DPL_DISABLE_TPC_TRIGGER_READER") || atoi(getenv("DPL_DISABLE_TPC_TRIGGER_READER")) != 1) {
         specs.emplace_back(o2::tpc::getTPCTriggerReaderSpec());
       }
-      if (sclOpts.needTPCScalersWorkflow()) { // for standalone tpc-reco workflow
-        specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpts.lumiType == 2, sclOpts.enableMShapeCorrection));
-      }
+      specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpts.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpts.enableMShapeCorrection, sclOpts));
       if (sclOpts.requestCTPLumi) { // need CTP digits (lumi) reader
         specs.emplace_back(o2::ctp::getDigitsReaderSpec(false));
       }
@@ -461,11 +457,6 @@ framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vecto
   if (runGPUReco) {
     o2::gpu::GPURecoWorkflowSpec::Config cfg;
     cfg.runTPCTracking = true;
-    cfg.lumiScaleType = sclOpts.lumiType;
-    cfg.lumiScaleMode = sclOpts.lumiMode;
-    cfg.checkCTPIDCconsistency = sclOpts.checkCTPIDCconsistency;
-    cfg.enableMShape = sclOpts.enableMShapeCorrection;
-    cfg.enableCTPLumi = sclOpts.requestCTPLumi;
     cfg.decompressTPC = decompressTPC;
     cfg.decompressTPCFromROOT = decompressTPC && inputType == InputType::CompClustersRoot;
     cfg.caClusterer = caClusterer;
diff --git a/Detectors/TPC/workflow/src/TPCRefitter.cxx b/Detectors/TPC/workflow/src/TPCRefitter.cxx
index 43a55526246fe..0db87bc8edbae 100644
--- a/Detectors/TPC/workflow/src/TPCRefitter.cxx
+++ b/Detectors/TPC/workflow/src/TPCRefitter.cxx
@@ -63,13 +63,8 @@ class TPCRefitterSpec final : public Task
     Streamer = 0x1,  ///< Write per track streamer information
     TFVectors = 0x2, ///< Writer vectors per TF
   };
-  TPCRefitterSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, GTrackID::mask_t src, bool useMC)
-    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-  }
+  TPCRefitterSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC) {}
   ~TPCRefitterSpec() final = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -184,7 +179,6 @@ void TPCRefitterSpec::init(InitContext& ic)
     mXRef = 0.;
   }
   mGenerator = std::mt19937(std::random_device{}());
-  mTPCCorrMapsLoader.init(ic);
 }
 
 void TPCRefitterSpec::run(ProcessingContext& pc)
@@ -219,21 +213,8 @@ void TPCRefitterSpec::updateTimeDependentParams(ProcessingContext& pc)
     // none at the moment
   }
   // we may have other params which need to be queried regularly
-  bool updateMaps = false;
   if (mTPCCorrMapsLoader.isUpdated()) {
     mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (mTPCVDriftHelper.isUpdated()) {
-    LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
-         mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
-         mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
-         mTPCVDriftHelper.getSourceName());
-    mTPCVDriftHelper.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (updateMaps) {
-    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
   }
 }
 
@@ -413,9 +394,6 @@ void TPCRefitterSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
 }
 
 bool TPCRefitterSpec::getDCAs(const o2::track::TrackPar& track, float& dcar, float& dcaz)
@@ -740,7 +718,7 @@ void TPCRefitterSpec::processCosmics(o2::globaltracking::RecoContainer& recoData
   }
 }
 
-DataProcessorSpec getTPCRefitterSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool requestCosmics)
+DataProcessorSpec getTPCRefitterSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC, bool requestCosmics)
 {
   std::vector<OutputSpec> outputs;
   Options opts{
@@ -778,13 +756,13 @@ DataProcessorSpec getTPCRefitterSpec(GTrackID::mask_t srcTracks, GTrackID::mask_
                                                               dataRequest->inputs,
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
 
   return DataProcessorSpec{
     "tpc-refitter",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TPCRefitterSpec>(dataRequest, ggRequest, sclOpts, srcTracks, useMC)},
+    AlgorithmSpec{adaptFromTask<TPCRefitterSpec>(dataRequest, ggRequest, srcTracks, useMC)},
     opts};
 }
 
diff --git a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
index f185b5e08c7e7..61cbb988d672e 100644
--- a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
@@ -27,6 +27,8 @@
 #include "TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h"
 #include "TPCSpaceCharge/SpaceCharge.h"
 #include "CommonUtils/TreeStreamRedirector.h"
+#include "TPCCalibration/CorrectionMapsLoaderFull.h"
+#include "TPCCalibration/VDriftHelper.h"
 
 using namespace o2::framework;
 
@@ -38,7 +40,12 @@ namespace tpc
 class TPCScalerSpec : public Task
 {
  public:
-  TPCScalerSpec(std::shared_ptr<o2::base::GRPGeomRequest> req, bool enableIDCs, bool enableMShape) : mCCDBRequest(req), mEnableIDCs(enableIDCs), mEnableMShape(enableMShape){};
+  TPCScalerSpec(std::shared_ptr<o2::base::GRPGeomRequest> req, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool enableIDCs, bool enableMShape) : mCCDBRequest(req), mEnableIDCs(enableIDCs), mEnableMShape(enableMShape), mGlobOpts(sclOpts)
+  {
+    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
+    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
+    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
+  };
 
   void init(framework::InitContext& ic) final
   {
@@ -57,6 +64,7 @@ class TPCScalerSpec : public Task
     if (enableStreamer) {
       mStreamer = std::make_unique<o2::utils::TreeStreamRedirector>("M_Shape.root", "recreate");
     }
+    mTPCCorrMapsLoader.init(ic, mEnableIDCs);
   }
 
   void endOfStream(EndOfStreamContext& eos) final
@@ -69,6 +77,11 @@ class TPCScalerSpec : public Task
   void run(ProcessingContext& pc) final
   {
     o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+    mTPCVDriftHelper.extractCCDBInputs(pc);
+    if (mTPCVDriftHelper.isUpdated()) {
+      mTPCVDriftHelper.acknowledgeUpdate();
+    }
+
     if (mEnableIDCs && pc.inputs().isValid("tpcscaler")) {
       pc.inputs().get<TTree*>("tpcscaler");
     }
@@ -122,12 +135,7 @@ class TPCScalerSpec : public Task
 
         std::unique_ptr<TPCFastSpaceChargeCorrection> spCorrection = TPCFastSpaceChargeCorrectionHelper::instance()->createFromGlobalCorrection(getCorrections, mKnotsYMshape, mKnotsZMshape);
         std::unique_ptr<TPCFastTransform> fastTransform(TPCFastTransformHelperO2::instance()->create(0, *spCorrection));
-        pc.outputs().snapshot(Output{header::gDataOriginTPC, "TPCMSHAPE"}, *fastTransform);
-      } else {
-        // send empty dummy object
-        LOGP(info, "Sending default (no) M-shape correction");
-        auto fastTransform = o2::tpc::TPCFastTransformHelperO2::instance()->create(0);
-        pc.outputs().snapshot(Output{header::gDataOriginTPC, "TPCMSHAPE"}, *fastTransform);
+        mTPCCorrMapsLoader.setCorrMapMShape(std::move(fastTransform));
       }
 
       if (mStreamer) {
@@ -140,6 +148,7 @@ class TPCScalerSpec : public Task
       }
     }
 
+    float tpcScaler = -1.f;
     if (mEnableIDCs) {
       static int runWarningIDC = -1;
       if (pc.services().get<o2::framework::TimingInfo>().runNumber != mTPCScaler.getRun() && runWarningIDC != currRun) {
@@ -149,8 +158,7 @@ class TPCScalerSpec : public Task
       float scalerA = mTPCScaler.getMeanScaler(timestamp, o2::tpc::Side::A);
       float scalerC = mTPCScaler.getMeanScaler(timestamp, o2::tpc::Side::C);
       float meanScaler = (scalerA + scalerC) / 2;
-      LOGP(info, "Publishing TPC scaler: {} for timestamp: {}, firstTFOrbit: {}", meanScaler, timestamp, firstTFOrbit);
-      pc.outputs().snapshot(Output{header::gDataOriginTPC, "TPCSCALER"}, meanScaler);
+      tpcScaler = meanScaler;
       if (mStreamer) {
         (*mStreamer) << "treeIDC"
                      << "scalerA=" << scalerA
@@ -160,11 +168,67 @@ class TPCScalerSpec : public Task
                      << "\n";
       }
     }
+    // check for Maps update
+    mTPCCorrMapsLoader.extractCCDBInputs(pc, tpcScaler);
+
+    const float lumiCTP = mTPCCorrMapsLoader.getInstLumiCTP();
+    // if CTP lumi was notrequest - defualt of 0 is published, otherwise the value is scaled with the provided factor
+    LOGP(info, "Publishing CTP Lumi: {} for timestamp: {}, firstTFOrbit: {}", lumiCTP, timestamp, firstTFOrbit);
+    pc.outputs().snapshot(Output{header::gDataOriginCTP, "LUMICTP"}, lumiCTP);
+
+    buildMap(pc);
+  }
+
+  void buildMap(ProcessingContext& pc)
+  {
+    // reference map
+    auto* corrMap = mTPCCorrMapsLoader.getCorrMap();
+
+    // // new correction map
+    o2::gpu::TPCFastTransform finalMap;
+    finalMap.cloneFromObject(*corrMap, nullptr);
+    finalMap.setApplyCorrectionOn();
+
+    const auto* corrMapRef = mTPCCorrMapsLoader.getCorrMapRef();
+    const float lumiScale = mTPCCorrMapsLoader.getLumiScale();
+    std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> additionalCorrections;
+
+    // if standard scaling is used: map(lumi) = (mean_map - ref_map) * lumiScale + ref_map
+    if (mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::Linear) {
+      const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step0{{&(corrMapRef->getCorrection()), -1.f}};
+      // finalMap = (mean_map - finalMap)
+      TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, step0, true);
+
+      // finalMap = finalMap * lumiScale + ref_map
+      const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step1{{&(corrMapRef->getCorrection()), 1.f}};
+      TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), lumiScale, step1, true);
+
+    } else if (mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::DerivativeMap || mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::DerivativeMapMC) {
+      additionalCorrections.emplace_back(&(corrMapRef->getCorrection()), lumiScale);
+    }
+
+    // if mshape map valid
+    if (!mTPCCorrMapsLoader.isCorrMapMShapeDummy()) {
+      LOGP(info, "Adding M-shape correction to the final map with scaling factor {}", mMShapeScalingFac);
+      additionalCorrections.emplace_back(&(mTPCCorrMapsLoader.getCorrMapMShape()->getCorrection()), 1.f);
+    }
+
+    if (!additionalCorrections.empty()) {
+      TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, additionalCorrections, true);
+    }
+
+    Output corrMapOutput{header::gDataOriginTPC, "TPCCORRMAP", 0};
+    auto outputBuffer = o2::pmr::vector<char>(pc.outputs().getMemoryResource(corrMapOutput));
+    auto* pod = TPCFastTransformPOD::create(outputBuffer, finalMap.getCorrection());
+    const auto& vd = mTPCVDriftHelper.getVDriftObject();
+    o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*pod, 0, vd.corrFact, vd.refVDrift, vd.getTimeOffset());
+    pc.outputs().adoptContainer(corrMapOutput, std::move(outputBuffer));
   }
 
   void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
   {
     o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
+    mTPCVDriftHelper.accountCCDBInputs(matcher, obj);
     if (matcher == ConcreteDataMatcher(o2::header::gDataOriginTPC, "TPCSCALERCCDB", 0)) {
       LOGP(info, "Updating TPC scaler");
       mTPCScaler.setFromTree(*((TTree*)obj));
@@ -198,12 +262,16 @@ class TPCScalerSpec : public Task
         LOGP(info, "Loaded default M-Shape correction object from CCDB");
       }
     }
+    if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
+      return;
+    }
   }
 
  private:
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;     ///< info for CCDB request
   const bool mEnableIDCs{true};                               ///< enable IDCs
   const bool mEnableMShape{false};                            ///< enable v shape scalers
+  const o2::tpc::CorrectionMapsLoaderGloOpts mGlobOpts;       ///< global options for the correction map loader, needed to decide which maps to load from CCDB
   bool mEnableWeights{false};                                 ///< use weights for TPC scalers
   TPCScalerWeights mScalerWeights{};                          ///< scaler weights
   float mIonDriftTimeMS{-1};                                  ///< ion drift time
@@ -214,6 +282,8 @@ class TPCScalerSpec : public Task
   int mKnotsYMshape{4};                                       ///< number of knots used for the spline object for M-Shape distortions
   int mKnotsZMshape{4};                                       ///< number of knots used for the spline object for M-Shape distortions
   std::unique_ptr<o2::utils::TreeStreamRedirector> mStreamer; ///< streamer
+  o2::tpc::CorrectionMapsLoaderFull mTPCCorrMapsLoader{};
+  o2::tpc::VDriftHelper mTPCVDriftHelper{}; ///< helper for v-drift
 
   void overWriteIntegrationTime()
   {
@@ -229,7 +299,7 @@ class TPCScalerSpec : public Task
   }
 };
 
-o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMShape)
+o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMShape, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
 {
   std::vector<InputSpec> inputs;
   if (enableIDCs) {
@@ -251,18 +321,16 @@ o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMS
                                                                 inputs);
 
   std::vector<OutputSpec> outputs;
-  if (enableIDCs) {
-    outputs.emplace_back(o2::header::gDataOriginTPC, "TPCSCALER", 0, Lifetime::Timeframe);
-  }
-  if (enableMShape) {
-    outputs.emplace_back(o2::header::gDataOriginTPC, "TPCMSHAPE", 0, Lifetime::Timeframe);
-  }
+  outputs.emplace_back(o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
+  outputs.emplace_back(o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+  o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
+  o2::tpc::CorrectionMapsLoaderFull::requestCCDBInputs(inputs, sclOpts);
 
   return DataProcessorSpec{
     "tpc-scaler",
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TPCScalerSpec>(ccdbRequest, enableIDCs, enableMShape)},
+    AlgorithmSpec{adaptFromTask<TPCScalerSpec>(ccdbRequest, sclOpts, enableIDCs, enableMShape)},
     Options{
       {"ion-drift-time", VariantType::Float, -1.f, {"Overwrite ion drift time if a value >0 is provided"}},
       {"max-time-for-weights", VariantType::Float, 500.f, {"Maximum possible integration time in ms when weights are used"}},
diff --git a/Detectors/TPC/workflow/src/tpc-calib-gainmap-tracks.cxx b/Detectors/TPC/workflow/src/tpc-calib-gainmap-tracks.cxx
index 5475995437113..06f1f2633fb71 100644
--- a/Detectors/TPC/workflow/src/tpc-calib-gainmap-tracks.cxx
+++ b/Detectors/TPC/workflow/src/tpc-calib-gainmap-tracks.cxx
@@ -65,9 +65,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   const auto disablePolynomialsCCDB = config.options().get<bool>("disablePolynomialsCCDB");
   const auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(config.options());
   WorkflowSpec workflow;
-  if (sclOpt.needTPCScalersWorkflow()) {
-    workflow.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
-  }
-  workflow.emplace_back(o2::tpc::getTPCCalibPadGainTracksSpec(publishAfterTFs, debug, useLastExtractedMapAsReference, polynomialsFile, disablePolynomialsCCDB, sclOpt));
+  workflow.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
+  workflow.emplace_back(o2::tpc::getTPCCalibPadGainTracksSpec(publishAfterTFs, debug, useLastExtractedMapAsReference, polynomialsFile, disablePolynomialsCCDB));
   return workflow;
 }
diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index f3d4d639ddfd2..b9c8cde98273b 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -24,6 +24,7 @@
 #include "TPCWorkflow/RecoWorkflow.h"
 #include "TPCReaderWorkflow/TPCSectorCompletionPolicy.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsLoaderFull.h"
 #include "Framework/CustomWorkflowTerminationHook.h"
 #include "DataFormatsTPC/TPCSectorHeader.h"
 #include "Algorithm/RangeTokenizer.h"
@@ -75,8 +76,8 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"tpc-deadMap-sources", VariantType::Int, -1, {"Sources to consider for TPC dead channel map creation; -1=all, 0=deactivated"}},
     {"tpc-mc-time-gain", VariantType::Bool, false, {"use time gain calibration for MC (true) or for data (false)"}},
   };
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
+  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   std::swap(workflowOptions, options);
 }
 
diff --git a/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx b/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
index 78bf63a44d60f..1700750f8aa4b 100644
--- a/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
@@ -79,18 +79,16 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     srcCls = srcCls | GID::getSourcesMask("CTP");
   }
 
-  if (sclOpt.lumiType == 2) {
-    const auto enableMShape = configcontext.options().get<bool>("enable-M-shape-correction");
-    const auto enableIDCs = !configcontext.options().get<bool>("disable-IDC-scalers");
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(enableIDCs, enableMShape));
-  }
+  const auto enableMShape = configcontext.options().get<bool>("enable-M-shape-correction");
+  const auto enableIDCs = !configcontext.options().get<bool>("disable-IDC-scalers");
+  specs.emplace_back(o2::tpc::getTPCScalerSpec(enableIDCs, enableMShape, sclOpt));
 
   o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC);
   o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); // P-vertex is always needed
   if (enableCosmics) {
     o2::globaltracking::InputHelper::addInputSpecsCosmics(configcontext, specs, useMC);
   }
-  specs.emplace_back(o2::trackstudy::getTPCRefitterSpec(srcTrc, srcCls, useMC, sclOpt, enableCosmics));
+  specs.emplace_back(o2::trackstudy::getTPCRefitterSpec(srcTrc, srcCls, useMC, enableCosmics));
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
diff --git a/Detectors/TPC/workflow/src/tpc-scaler.cxx b/Detectors/TPC/workflow/src/tpc-scaler.cxx
index 598687c7dff41..d4b994f6eb275 100644
--- a/Detectors/TPC/workflow/src/tpc-scaler.cxx
+++ b/Detectors/TPC/workflow/src/tpc-scaler.cxx
@@ -15,6 +15,7 @@
 #include "TPCWorkflow/TPCScalerSpec.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "Framework/ConfigParamSpec.h"
+#include "TPCCalibration/CorrectionMapsLoader.h"
 
 using namespace o2::framework;
 
@@ -25,7 +26,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"enable-M-shape-correction", VariantType::Bool, false, {"Enable M-shape distortion correction"}},
     {"disable-IDC-scalers", VariantType::Bool, false, {"Disable TPC scalers for space-charge distortion fluctuation correction"}}};
-
+  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   std::swap(workflowOptions, options);
 }
 
@@ -37,6 +38,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   o2::conf::ConfigurableParam::updateFromString(config.options().get<std::string>("configKeyValues"));
   const auto enableMShape = config.options().get<bool>("enable-M-shape-correction");
   const auto enableIDCs = !config.options().get<bool>("disable-IDC-scalers");
-  workflow.emplace_back(o2::tpc::getTPCScalerSpec(enableIDCs, enableMShape));
+  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(config.options());
+  workflow.emplace_back(o2::tpc::getTPCScalerSpec(enableIDCs, enableMShape, sclOpt));
   return workflow;
 }
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
index 93f07dd58445e..9a7ac5a161694 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
@@ -52,13 +52,8 @@ namespace trd
 class TRDGlobalTracking : public o2::framework::Task
 {
  public:
-  TRDGlobalTracking(bool useMC, bool withPID, PIDPolicy policy, std::shared_ptr<o2::globaltracking::DataRequest> dataRequest, std::shared_ptr<o2::base::GRPGeomRequest> gr, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts,
-                    o2::dataformats::GlobalTrackID::mask_t src, bool trigRecFilterActive, bool strict) : mUseMC(useMC), mWithPID(withPID), mDataRequest(dataRequest), mGGCCDBRequest(gr), mTrkMask(src), mTrigRecFilter(trigRecFilterActive), mStrict(strict), mPolicy(policy)
-  {
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-  }
+  TRDGlobalTracking(bool useMC, bool withPID, PIDPolicy policy, std::shared_ptr<o2::globaltracking::DataRequest> dataRequest, std::shared_ptr<o2::base::GRPGeomRequest> gr,
+                    o2::dataformats::GlobalTrackID::mask_t src, bool trigRecFilterActive, bool strict) : mUseMC(useMC), mWithPID(withPID), mDataRequest(dataRequest), mGGCCDBRequest(gr), mTrkMask(src), mTrigRecFilter(trigRecFilterActive), mStrict(strict), mPolicy(policy) {}
   ~TRDGlobalTracking() override = default;
   void init(o2::framework::InitContext& ic) final;
   void fillMCTruthInfo(const TrackTRD& trk, o2::MCCompLabel lblSeed, std::vector<o2::MCCompLabel>& lblContainerTrd, std::vector<o2::MCCompLabel>& lblContainerMatch, const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* trkltLabels) const;
@@ -115,7 +110,7 @@ class TRDGlobalTracking : public o2::framework::Task
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t src, bool trigRecFilterActive, bool strict /* = false*/, bool withPID /* = false*/, PIDPolicy policy /* = PIDPolicy::DEFAULT*/, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
+framework::DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t src, bool trigRecFilterActive, bool strict /* = false*/, bool withPID /* = false*/, PIDPolicy policy /* = PIDPolicy::DEFAULT*/);
 
 } // namespace trd
 } // namespace o2
diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index 0f578efd3aa5b..a080f85524684 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -82,7 +82,6 @@ using TrackTunePar = o2::globaltracking::TrackTuneParams;
 void TRDGlobalTracking::init(InitContext& ic)
 {
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
-  mTPCCorrMapsLoader.init(ic);
   mTimer.Stop();
   mTimer.Reset();
 }
@@ -175,10 +174,6 @@ void TRDGlobalTracking::updateTimeDependentParams(ProcessingContext& pc)
     mTPCVDriftHelper.acknowledgeUpdate();
     updateCalib = true;
   }
-  if (updateCalib) {
-    auto& vd = mTPCVDriftHelper.getVDriftObject();
-    mTPCCorrMapsLoader.updateVDrift(vd.corrFact, vd.refVDrift, vd.getTimeOffset());
-  }
 }
 
 void TRDGlobalTracking::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
@@ -189,9 +184,6 @@ void TRDGlobalTracking::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
     return;
   }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
   if (matcher == ConcreteDataMatcher("ITS", "CLUSDICT", 0)) {
     LOG(info) << "cluster dictionary updated";
     mITSDict = (const o2::itsmft::TopologyDictionary*)obj;
@@ -862,7 +854,7 @@ void TRDGlobalTracking::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, bool trigRecFilterActive, bool strict, bool withPID, PIDPolicy policy, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, bool trigRecFilterActive, bool strict, bool withPID, PIDPolicy policy)
 {
   std::vector<OutputSpec> outputs;
   uint32_t ss = o2::globaltracking::getSubSpec(strict ? o2::globaltracking::MatchingType::Strict : o2::globaltracking::MatchingType::Standard);
@@ -899,7 +891,7 @@ DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, boo
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
   Options opts;
-  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(inputs, opts, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestInputs(inputs, opts);
 
   // Request PID policy data
   if (withPID) {
@@ -962,7 +954,7 @@ DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, boo
     processorName,
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TRDGlobalTracking>(useMC, withPID, policy, dataRequest, ggRequest, sclOpts, src, trigRecFilterActive, strict)},
+    AlgorithmSpec{adaptFromTask<TRDGlobalTracking>(useMC, withPID, policy, dataRequest, ggRequest, src, trigRecFilterActive, strict)},
     opts};
 }
 
diff --git a/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx b/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
index 7781b5ed187cb..0bff7dd94d8a2 100644
--- a/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
+++ b/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
@@ -115,10 +115,10 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   // processing devices
   o2::framework::WorkflowSpec specs;
-  if (sclOpt.needTPCScalersWorkflow() && !configcontext.options().get<bool>("disable-root-input")) {
-    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == 2, sclOpt.enableMShapeCorrection));
+  if (!configcontext.options().get<bool>("disable-root-input")) {
+    specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::trd::getTRDGlobalTrackingSpec(useMC, srcTRD, trigRecFilterActive, strict, pid, policy, sclOpt));
+  specs.emplace_back(o2::trd::getTRDGlobalTrackingSpec(useMC, srcTRD, trigRecFilterActive, strict, pid, policy));
   if (vdexb || gain) {
     specs.emplace_back(o2::trd::getTRDTrackBasedCalibSpec(srcTRD, vdexb, gain));
   }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
index a4b17b81bf5ac..0aabb30f60e1a 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
@@ -20,7 +20,7 @@
 #endif
 
 #include "GPUReconstructionConvert.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "GPUTPCClusterData.h"
 #include "GPUO2DataTypes.h"
 #include "GPUDataTypesIO.h"
@@ -48,7 +48,7 @@ using namespace o2::tpc;
 using namespace o2::tpc::constants;
 using namespace std::string_literals;
 
-void GPUReconstructionConvert::ConvertNativeToClusterData(o2::tpc::ClusterNativeAccess* native, std::unique_ptr<GPUTPCClusterData[]>* clusters, uint32_t* nClusters, const TPCFastTransform* transform, int32_t continuousMaxTimeBin)
+void GPUReconstructionConvert::ConvertNativeToClusterData(o2::tpc::ClusterNativeAccess* native, std::unique_ptr<GPUTPCClusterData[]>* clusters, uint32_t* nClusters, const TPCFastTransformPOD* transform, int32_t continuousMaxTimeBin)
 {
   memset(nClusters, 0, NSECTORS * sizeof(nClusters[0]));
   uint32_t offset = 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.h b/GPU/GPUTracking/Base/GPUReconstructionConvert.h
index a24eb52a3a47c..3bb8a2b3df3c2 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.h
@@ -41,7 +41,7 @@ namespace o2::gpu
 {
 struct GPUParam;
 struct GPUTPCClusterData;
-class TPCFastTransform;
+class TPCFastTransformPOD;
 struct GPUTrackingInOutDigits;
 struct GPUTrackingInOutZS;
 
@@ -49,7 +49,7 @@ class GPUReconstructionConvert
 {
  public:
   constexpr static uint32_t NSECTORS = GPUCA_NSECTORS;
-  static void ConvertNativeToClusterData(o2::tpc::ClusterNativeAccess* native, std::unique_ptr<GPUTPCClusterData[]>* clusters, uint32_t* nClusters, const TPCFastTransform* transform, int32_t continuousMaxTimeBin = 0);
+  static void ConvertNativeToClusterData(o2::tpc::ClusterNativeAccess* native, std::unique_ptr<GPUTPCClusterData[]>* clusters, uint32_t* nClusters, const TPCFastTransformPOD* transform, int32_t continuousMaxTimeBin = 0);
   static void ConvertRun2RawToNative(o2::tpc::ClusterNativeAccess& native, std::unique_ptr<o2::tpc::ClusterNative[]>& nativeBuffer, const AliHLTTPCRawCluster** rawClusters, uint32_t* nRawClusters);
   template <class S>
   static void RunZSEncoder(const S& in, std::unique_ptr<uint64_t[]>* outBuffer, uint32_t* outSizes, o2::raw::RawFileWriter* raw, const o2::InteractionRecord* ir, const GPUParam& param, int32_t version, bool verify, float threshold = 0.f, bool padding = false, std::function<void(std::vector<o2::tpc::Digit>&)> digitsFilter = nullptr);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
index fefcd0ac925fe..b605c99e393b1 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
@@ -22,7 +22,7 @@
 #include "GPUTPCMCInfo.h"
 #include "GPUTPCClusterData.h"
 #include "AliHLTTPCRawCluster.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "CorrectionMapsHelper.h"
 #include "GPUO2DataTypes.h"
 #include "GPUSettings.h"
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
index 76fa569a16824..acd91939245d0 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
@@ -91,7 +91,7 @@ class ORTRootSerializer;
 namespace o2::gpu
 {
 class CorrectionMapsHelper;
-class TPCFastTransform;
+class TPCFastTransformPOD;
 struct TPCPadGainCalib;
 struct TPCZSLinkMapping;
 
@@ -125,9 +125,7 @@ struct ConstPtr {
 
 template <template <typename T> class S>
 struct GPUCalibObjectsTemplate { // use only pointers on PODs or flat objects here
-  typename S<TPCFastTransform>::type* fastTransform = nullptr;
-  typename S<TPCFastTransform>::type* fastTransformRef = nullptr;
-  typename S<TPCFastTransform>::type* fastTransformMShape = nullptr;
+  typename S<TPCFastTransformPOD>::type* fastTransform = nullptr;
   typename S<CorrectionMapsHelper>::type* fastTransformHelper = nullptr;
   typename S<o2::base::MatLayerCylSet>::type* matLUT = nullptr;
   typename S<o2::trd::GeometryFlat>::type* trdGeometry = nullptr;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 7216de0535329..0fd2335fe7863 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -50,7 +50,7 @@
 #include "GPUTrackingRefit.h"
 #include "CalibdEdxContainer.h"
 
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "CorrectionMapsHelper.h"
 
 #include "utils/linux_helpers.h"
@@ -391,32 +391,14 @@ int32_t GPUChainTracking::Init()
 
 void GPUChainTracking::UpdateGPUCalibObjects(int32_t stream, const GPUCalibObjectsConst* ptrMask)
 {
+  // TODO: Is this correct?
   if (processors()->calibObjects.fastTransform && (ptrMask == nullptr || ptrMask->fastTransform)) {
-    memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransform, (const void*)processors()->calibObjects.fastTransform, sizeof(*processors()->calibObjects.fastTransform));
-    memcpy((void*)mFlatObjectsShadow.mTpcTransformBuffer, (const void*)processors()->calibObjects.fastTransform->getFlatBufferPtr(), processors()->calibObjects.fastTransform->getFlatBufferSize());
-    mFlatObjectsShadow.mCalibObjects.fastTransform->clearInternalBufferPtr();
-    mFlatObjectsShadow.mCalibObjects.fastTransform->setActualBufferAddress(mFlatObjectsShadow.mTpcTransformBuffer);
-    mFlatObjectsShadow.mCalibObjects.fastTransform->setFutureBufferAddress(mFlatObjectsDevice.mTpcTransformBuffer);
-  }
-  if (processors()->calibObjects.fastTransformMShape && (ptrMask == nullptr || ptrMask->fastTransformMShape)) {
-    memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformMShape, (const void*)processors()->calibObjects.fastTransformMShape, sizeof(*processors()->calibObjects.fastTransformMShape));
-    memcpy((void*)mFlatObjectsShadow.mTpcTransformMShapeBuffer, (const void*)processors()->calibObjects.fastTransformMShape->getFlatBufferPtr(), processors()->calibObjects.fastTransformMShape->getFlatBufferSize());
-    mFlatObjectsShadow.mCalibObjects.fastTransformMShape->clearInternalBufferPtr();
-    mFlatObjectsShadow.mCalibObjects.fastTransformMShape->setActualBufferAddress(mFlatObjectsShadow.mTpcTransformMShapeBuffer);
-    mFlatObjectsShadow.mCalibObjects.fastTransformMShape->setFutureBufferAddress(mFlatObjectsDevice.mTpcTransformMShapeBuffer);
-  }
-  if (processors()->calibObjects.fastTransformRef && (ptrMask == nullptr || ptrMask->fastTransformRef)) {
-    memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformRef, (const void*)processors()->calibObjects.fastTransformRef, sizeof(*processors()->calibObjects.fastTransformRef));
-    memcpy((void*)mFlatObjectsShadow.mTpcTransformRefBuffer, (const void*)processors()->calibObjects.fastTransformRef->getFlatBufferPtr(), processors()->calibObjects.fastTransformRef->getFlatBufferSize());
-    mFlatObjectsShadow.mCalibObjects.fastTransformRef->clearInternalBufferPtr();
-    mFlatObjectsShadow.mCalibObjects.fastTransformRef->setActualBufferAddress(mFlatObjectsShadow.mTpcTransformRefBuffer);
-    mFlatObjectsShadow.mCalibObjects.fastTransformRef->setFutureBufferAddress(mFlatObjectsDevice.mTpcTransformRefBuffer);
+    memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransform, (const void*)processors()->calibObjects.fastTransform, processors()->calibObjects.fastTransform->size());
   }
+
   if (processors()->calibObjects.fastTransformHelper && (ptrMask == nullptr || ptrMask->fastTransformHelper)) {
     memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformHelper, (const void*)processors()->calibObjects.fastTransformHelper, sizeof(*processors()->calibObjects.fastTransformHelper));
     mFlatObjectsShadow.mCalibObjects.fastTransformHelper->setCorrMap(mFlatObjectsShadow.mCalibObjects.fastTransform);
-    mFlatObjectsShadow.mCalibObjects.fastTransformHelper->setCorrMapRef(mFlatObjectsShadow.mCalibObjects.fastTransformRef);
-    mFlatObjectsShadow.mCalibObjects.fastTransformHelper->setCorrMapMShape(mFlatObjectsShadow.mCalibObjects.fastTransformMShape);
   }
   if (processors()->calibObjects.dEdxCalibContainer && (ptrMask == nullptr || ptrMask->dEdxCalibContainer)) {
     memcpy((void*)mFlatObjectsShadow.mCalibObjects.dEdxCalibContainer, (const void*)processors()->calibObjects.dEdxCalibContainer, sizeof(*processors()->calibObjects.dEdxCalibContainer));
@@ -503,16 +485,10 @@ void* GPUChainTracking::GPUTrackingFlatObjects::SetPointersFlatObjects(void* mem
 {
   char* fastTransformBase = (char*)mem;
   if (mChainTracking->processors()->calibObjects.fastTransform) {
-    computePointerWithAlignment(mem, mCalibObjects.fastTransform, 1);
-    computePointerWithAlignment(mem, mTpcTransformBuffer, mChainTracking->processors()->calibObjects.fastTransform->getFlatBufferSize());
-  }
-  if (mChainTracking->processors()->calibObjects.fastTransformRef) {
-    computePointerWithAlignment(mem, mCalibObjects.fastTransformRef, 1);
-    computePointerWithAlignment(mem, mTpcTransformRefBuffer, mChainTracking->processors()->calibObjects.fastTransformRef->getFlatBufferSize());
-  }
-  if (mChainTracking->processors()->calibObjects.fastTransformMShape) {
-    computePointerWithAlignment(mem, mCalibObjects.fastTransformMShape, 1);
-    computePointerWithAlignment(mem, mTpcTransformMShapeBuffer, mChainTracking->processors()->calibObjects.fastTransformMShape->getFlatBufferSize());
+    // TODO: Is this correct?!
+    char* podBuf = nullptr;
+    computePointerWithAlignment(mem, podBuf, mChainTracking->processors()->calibObjects.fastTransform->size()); // raw bytes
+    mCalibObjects.fastTransform = reinterpret_cast<TPCFastTransformPOD*>(podBuf);
   }
   if (mChainTracking->processors()->calibObjects.fastTransformHelper) {
     computePointerWithAlignment(mem, mCalibObjects.fastTransformHelper, 1);
@@ -589,7 +565,7 @@ void GPUChainTracking::AllocateIOMemory()
   AllocateIOMemoryHelper(mIOPtrs.nTRDTriggerRecords, mIOPtrs.trdTrackletIdxFirst, mIOMem.trdTrackletIdxFirst);
 }
 
-void GPUChainTracking::SetTPCFastTransform(std::unique_ptr<TPCFastTransform>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper)
+void GPUChainTracking::SetTPCFastTransform(std::unique_ptr<TPCFastTransformPOD>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper)
 {
   mTPCFastTransformU = std::move(tpcFastTransform);
   mTPCFastTransformHelperU = std::move(tpcTransformHelper);
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index fd75136f51d76..a7dfcb9c73a3e 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -60,7 +60,7 @@ class GPUQA;
 class GPUTPCClusterStatistics;
 class GPUTRDGeometry;
 class GPUTRDRecoParam;
-class TPCFastTransform;
+class TPCFastTransformPOD;
 class GPUTrackingInputProvider;
 struct GPUChainTrackingFinalContext;
 struct GPUTPCCFChainContext;
@@ -182,7 +182,7 @@ class GPUChainTracking : public GPUChain
   const GPUTRDRecoParam* GetTRDRecoParam() const;
   const o2::base::Propagator* GetO2Propagator() const;
   const o2::base::Propagator* GetDeviceO2Propagator();
-  void SetTPCFastTransform(std::unique_ptr<TPCFastTransform>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper);
+  void SetTPCFastTransform(std::unique_ptr<TPCFastTransformPOD>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper);
   void SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut);
   void SetTRDGeometry(std::unique_ptr<o2::trd::GeometryFlat>&& geo);
   void SetTRDRecoParam(std::unique_ptr<GPUTRDRecoParam>&& par);
@@ -205,8 +205,6 @@ class GPUChainTracking : public GPUChain
     GPUChainTracking* mChainTracking = nullptr;
     GPUCalibObjects mCalibObjects;
     char* mTpcTransformBuffer = nullptr;
-    char* mTpcTransformRefBuffer = nullptr;
-    char* mTpcTransformMShapeBuffer = nullptr;
     char* mdEdxSplinesBuffer = nullptr;
     char* mMatLUTBuffer = nullptr;
     int16_t mMemoryResFlat = -1;
@@ -262,9 +260,7 @@ class GPUChainTracking : public GPUChain
   std::unique_ptr<GPUTPCClusterStatistics> mCompressionStatistics;
 
   // Ptr to detector / calibration objects
-  std::unique_ptr<TPCFastTransform> mTPCFastTransformU;              // Global TPC fast transformation object
-  std::unique_ptr<TPCFastTransform> mTPCFastTransformRefU;           // Global TPC fast transformation ref object
-  std::unique_ptr<TPCFastTransform> mTPCFastTransformMShapeU;        // Global TPC fast transformation for M-shape object
+  std::unique_ptr<TPCFastTransformPOD> mTPCFastTransformU;              // Global TPC fast transformation object
   std::unique_ptr<CorrectionMapsHelper> mTPCFastTransformHelperU;    // Global TPC fast transformation helper object
   std::unique_ptr<TPCPadGainCalib> mTPCPadGainCalibU;                // TPC gain calibration and cluster finder parameters
   std::unique_ptr<TPCZSLinkMapping> mTPCZSLinkMappingU;              // TPC Mapping data required by ZS Link decoder
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 6f24415564a8c..89d208b33f327 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -44,7 +44,7 @@
 #include "DataFormatsTPC/Digit.h"
 #include "CalibdEdxContainer.h"
 
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "CorrectionMapsHelper.h"
 
 using namespace o2::gpu;
@@ -296,17 +296,7 @@ void GPUChainTracking::DumpSettings(const char* dir)
   if (processors()->calibObjects.fastTransform != nullptr) {
     f = dir;
     f += "tpctransform.dump";
-    DumpFlatObjectToFile(processors()->calibObjects.fastTransform, f.c_str());
-  }
-  if (processors()->calibObjects.fastTransformRef != nullptr) {
-    f = dir;
-    f += "tpctransformref.dump";
-    DumpFlatObjectToFile(processors()->calibObjects.fastTransformRef, f.c_str());
-  }
-  if (processors()->calibObjects.fastTransformMShape != nullptr) {
-    f = dir;
-    f += "tpctransformmshape.dump";
-    DumpFlatObjectToFile(processors()->calibObjects.fastTransformMShape, f.c_str());
+    DumpStructToFile(processors()->calibObjects.fastTransform, f.c_str());
   }
   if (processors()->calibObjects.fastTransformHelper != nullptr) {
     f = dir;
@@ -350,23 +340,13 @@ void GPUChainTracking::ReadSettings(const char* dir)
   std::string f;
   f = dir;
   f += "tpctransform.dump";
-  mTPCFastTransformU = ReadFlatObjectFromFile<TPCFastTransform>(f.c_str());
+  mTPCFastTransformU = ReadStructFromFile<TPCFastTransformPOD>(f.c_str());
   processors()->calibObjects.fastTransform = mTPCFastTransformU.get();
   f = dir;
-  f += "tpctransformref.dump";
-  mTPCFastTransformRefU = ReadFlatObjectFromFile<TPCFastTransform>(f.c_str());
-  processors()->calibObjects.fastTransformRef = mTPCFastTransformRefU.get();
-  f = dir;
-  f += "tpctransformmshape.dump";
-  mTPCFastTransformMShapeU = ReadFlatObjectFromFile<TPCFastTransform>(f.c_str());
-  processors()->calibObjects.fastTransformMShape = mTPCFastTransformMShapeU.get();
-  f = dir;
   f += "tpctransformhelper.dump";
   mTPCFastTransformHelperU = ReadStructFromFile<CorrectionMapsHelper>(f.c_str());
   if ((processors()->calibObjects.fastTransformHelper = mTPCFastTransformHelperU.get())) {
     mTPCFastTransformHelperU->setCorrMap(mTPCFastTransformU.get());
-    mTPCFastTransformHelperU->setCorrMapRef(mTPCFastTransformRefU.get());
-    mTPCFastTransformHelperU->setCorrMapMShape(mTPCFastTransformMShapeU.get());
   }
   f = dir;
   f += "tpcpadgaincalib.dump";
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 3622e51bd663f..8358e98883aca 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -34,7 +34,7 @@
 #include "GPUTPCTrackParam.h"
 #include "GPUTPCGMMerger.h"
 #include "GPUO2DataTypes.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "GPUTPCConvertImpl.h"
 #include "GPUTPCGeometry.h"
 #include "GPUDefParametersRuntime.h"
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 9224904e104c1..523bfa7df73e0 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -18,7 +18,7 @@
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTPC/Constants.h"
 #include "DataFormatsTPC/PIDResponse.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "CorrectionMapsHelper.h"
 #include "GPUGetConstexpr.h"
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 70fb9cd1a769e..f5dce94906cc2 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -28,7 +28,7 @@
 #include "GPUParam.h"
 #include "GPUO2DataTypes.h"
 #include "GPUConstantMem.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "CorrectionMapsHelper.h"
 #include "GPUTPCConvertImpl.h"
 #include "GPUTPCGMMergerTypes.h"
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h b/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
index b185a01a3f392..5f989fafe9558 100644
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
+++ b/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
@@ -17,7 +17,7 @@
 
 #include "GPUCommonDef.h"
 #include "GPUConstantMem.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "CorrectionMapsHelper.h"
 
 namespace o2::gpu
@@ -34,7 +34,7 @@ class GPUTPCConvertImpl
       cm.calibObjects.fastTransformHelper->Transform(sector, row, pad, time, x, y, z);
     }
   }
-  GPUd() static void convert(const TPCFastTransform& GPUrestrict() transform, const GPUParam& GPUrestrict() param, int32_t sector, int32_t row, float pad, float time, float& GPUrestrict() x, float& GPUrestrict() y, float& GPUrestrict() z)
+  GPUd() static void convert(const TPCFastTransformPOD& GPUrestrict() transform, const GPUParam& GPUrestrict() param, int32_t sector, int32_t row, float pad, float time, float& GPUrestrict() x, float& GPUrestrict() y, float& GPUrestrict() z)
   {
     if (param.par.continuousTracking) {
       transform.TransformInTimeFrame(sector, row, pad, time, x, y, z, param.continuousMaxTimeBin);
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index b58209efff744..05db68a6e0bc2 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -49,7 +49,7 @@
 #include "GPUParam.inc"
 #include "GPUTPCClusterRejection.h"
 #include "GPUTPCConvertImpl.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 #include "CorrectionMapsHelper.h"
 #include "GPUROOTDump.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
index e12c98a8a400b..71477f8dce718 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
@@ -10,113 +10,45 @@
 // or submit itself to any jurisdiction.
 
 #include "CorrectionMapsHelper.h"
-#include "GPUCommonLogger.h"
-
+#include "Framework/ConfigParamRegistry.h"
 using namespace o2::gpu;
+using namespace o2::tpc;
 
-//________________________________________________________
-void CorrectionMapsHelper::clear()
-{
-  if (mOwner) {
-    delete mCorrMap;
-    delete mCorrMapRef;
-    delete mCorrMapMShape;
-  }
-  mLumiCTPAvailable = false;
-  mCorrMap = nullptr;
-  mCorrMapRef = nullptr;
-  mCorrMapMShape = nullptr;
-  mUpdatedFlags = 0;
-  mInstLumiCTP = 0.f;
-  mInstLumi = 0.f;
-  mMeanLumi = 0.f;
-  mMeanLumiRef = 0.f;
-  mScaleInverse = false;
-}
-
-void CorrectionMapsHelper::setOwner(bool v)
-{
-  if (mCorrMap || mCorrMapRef) {
-    throw std::runtime_error("Must not change ownership while we contain objects");
-  }
-  mOwner = v;
-}
-
-//________________________________________________________
-void CorrectionMapsHelper::setCorrMap(TPCFastTransform* m)
+void CorrectionMapsHelper::setCorrMap(const TPCFastTransformPOD* m)
 {
-  if (mOwner) {
-    delete mCorrMap;
-  }
+  // non-owning: just store the pointer, clear any previously owned buffer
+#if !defined(GPUCA_GPUCODE_DEVICE)
+  mCorrMapBuffer.clear();
+#endif
   mCorrMap = m;
 }
 
-//________________________________________________________
-void CorrectionMapsHelper::setCorrMapRef(TPCFastTransform* m)
+void CorrectionMapsHelper::setCorrMap(std::vector<char>&& buffer)
 {
-  if (mOwner) {
-    delete mCorrMapRef;
-  }
-  mCorrMapRef = m;
+  mCorrMapBuffer = std::move(buffer);
+  mCorrMap = &TPCFastTransformPOD::get(mCorrMapBuffer.data());
 }
 
-void CorrectionMapsHelper::setCorrMapMShape(TPCFastTransform* m)
+CorrectionMapsLoaderGloOpts CorrectionMapsHelper::parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts)
 {
-  if (mOwner) {
-    delete mCorrMapMShape;
+  CorrectionMapsLoaderGloOpts tpcopt;
+  auto lumiTypeVal = opts.get<int>("lumi-type");
+  if (lumiTypeVal < -1 || lumiTypeVal > 2) {
+    LOGP(fatal, "Invalid lumi-type value: {}", lumiTypeVal);
   }
-  mCorrMapMShape = m;
-}
+  tpcopt.lumiType = static_cast<LumiScaleType>(lumiTypeVal);
 
-//________________________________________________________
-void CorrectionMapsHelper::setCorrMap(std::unique_ptr<TPCFastTransform>&& m)
-{
-  if (!mOwner) {
-    throw std::runtime_error("we must not take the ownership from a unique ptr if mOwner is not set");
+  auto lumiModeVal = opts.get<int>("corrmap-lumi-mode");
+  if (lumiModeVal < -1 || lumiModeVal > 2) {
+    LOGP(fatal, "Invalid corrmap-lumi-mode value: {}", lumiModeVal);
   }
-  delete mCorrMap;
-  mCorrMap = m.release();
-}
+  tpcopt.lumiMode = static_cast<LumiScaleMode>(lumiModeVal);
 
-//________________________________________________________
-void CorrectionMapsHelper::setCorrMapRef(std::unique_ptr<TPCFastTransform>&& m)
-{
-  if (!mOwner) {
-    throw std::runtime_error("we must not take the ownership from a unique ptr if mOwner is not set");
+  tpcopt.enableMShapeCorrection = opts.get<bool>("enable-M-shape-correction");
+  tpcopt.requestCTPLumi = !opts.get<bool>("disable-ctp-lumi-request");
+  tpcopt.checkCTPIDCconsistency = !opts.get<bool>("disable-lumi-type-consistency-check");
+  if (!tpcopt.requestCTPLumi && tpcopt.lumiType == LumiScaleType::CTPLumi) {
+    LOGP(fatal, "Scaling with CTP Lumi is requested but this input is disabled");
   }
-  delete mCorrMapRef;
-  mCorrMapRef = m.release();
-}
-
-void CorrectionMapsHelper::setCorrMapMShape(std::unique_ptr<TPCFastTransform>&& m)
-{
-  if (!mOwner) {
-    throw std::runtime_error("we must not take the ownership from a unique ptr if mOwnerMShape is not set");
-  }
-  delete mCorrMapMShape;
-  mCorrMapMShape = m.release();
-}
-
-void CorrectionMapsHelper::updateLumiScale(bool report)
-{
-  if (!canUseCorrections()) {
-    mLumiScale = -1.f;
-  } else if ((mLumiScaleMode == 1) || (mLumiScaleMode == 2)) {
-    mLumiScale = mMeanLumiRef ? (mInstLumi - mMeanLumi) / mMeanLumiRef : 0.f;
-    LOGP(debug, "mInstLumi: {}  mMeanLumi: {} mMeanLumiRef: {}", mInstLumi, mMeanLumi, mMeanLumiRef);
-  } else {
-    mLumiScale = mMeanLumi ? mInstLumi / mMeanLumi : 0.f;
-  }
-  setUpdatedLumi();
-  if (report) {
-    reportScaling();
-  }
-}
-
-//________________________________________________________
-void CorrectionMapsHelper::reportScaling()
-{
-  LOGP(info, "Map scaling update: LumiScaleType={} instLumi(CTP)={} instLumi(scaling)={} meanLumiRef={}, meanLumi={} -> LumiScale={} lumiScaleMode={}, M-Shape map valid: {}, M-Shape default: {}",
-       mLumiScaleType == 0 ? "NoScaling" : (mLumiScaleType == 1 ? "LumiCTP" : "TPCScaler"), getInstLumiCTP(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(),
-       mLumiScaleMode == 0 ? "Linear" : "Derivative", (mCorrMapMShape != nullptr), isCorrMapMShapeDummy());
+  return tpcopt;
 }
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
index 42d55adfcc3d0..ce88321fa4fc8 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -17,14 +17,44 @@
 #define TPC_CORRECTION_MAPS_HELPER_H_
 
 #ifndef GPUCA_GPUCODE_DEVICE
-#include <memory>
 #include <vector>
 #endif
 #include "GPUCommonDef.h"
-#include "TPCFastTransform.h"
+#include "TPCFastTransformPOD.h"
 
 namespace o2
 {
+
+namespace framework
+{
+class ConfigParamRegistry;
+} // namespace framework
+
+namespace tpc
+{
+enum class LumiScaleType : int32_t {
+  Unset = -1, ///< init value
+  NoScaling = 0, ///< no scaling, use map as is
+  CTPLumi = 1, ///< use CTP luminosity for scaling
+  TPCScaler = 2 ///< use TPC scaler for scaling
+};
+
+enum class LumiScaleMode : int32_t {
+    Unset = -1, ///< init value
+    Linear = 0, ///< map(lumi) = (mean_map - referenceMap) * lumiScale + referenceMap
+    DerivativeMap = 1, ///< map(lumi) = mean_map + lumiScale * (derivativeMap) where derivativeMap = (mean_map_A - mean_map_B)
+    DerivativeMapMC = 2  ///< same DerivativeMap, but for MC
+};
+
+struct CorrectionMapsLoaderGloOpts {
+  LumiScaleType lumiType = LumiScaleType::Unset; ///< what estimator to used for corrections scaling: 0: no scaling, 1: CTP, 2: IDC
+  LumiScaleMode lumiMode = LumiScaleMode::Unset; ///< what corrections method to use: 0: classical scaling, 1: Using of the derivative map, 2: Using of the derivative map for MC
+  bool enableMShapeCorrection = false;
+  bool requestCTPLumi = true; ///< request CTP Lumi regardless of what is used for corrections scaling
+  bool checkCTPIDCconsistency = true; ///< check the selected CTP or IDC scaling source being consistent with mean scaler of the map
+};
+}
+
 namespace gpu
 {
 
@@ -34,161 +64,55 @@ class CorrectionMapsHelper
   CorrectionMapsHelper() = default;
   ~CorrectionMapsHelper() { clear(); }
   CorrectionMapsHelper(const CorrectionMapsHelper&) = delete;
-  void updateLumiScale(bool report = false);
-  void clear();
+  static tpc::CorrectionMapsLoaderGloOpts parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts);
+  void setUpdatedMap() { mUpdated = true; }
+  void clear()
+  {
+    mCorrMap = nullptr;
+#if !defined(GPUCA_GPUCODE_DEVICE)
+    mCorrMapBuffer.clear();
+#endif
+  }
 
   GPUd() void Transform(int32_t slice, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0) const
   {
-    mCorrMap->Transform(slice, row, pad, time, x, y, z, vertexTime, mCorrMapRef, mCorrMapMShape, mLumiScale, 1, mLumiScaleMode);
+    mCorrMap->Transform(slice, row, pad, time, x, y, z, vertexTime);
   }
 
   GPUd() void TransformXYZ(int32_t slice, int32_t row, float& x, float& y, float& z) const
   {
-    mCorrMap->TransformXYZ(slice, row, x, y, z, mCorrMapRef, mCorrMapMShape, mLumiScale, 1, mLumiScaleMode);
+    mCorrMap->TransformXYZ(slice, row, x, y, z);
   }
 
   GPUd() void InverseTransformYZtoX(int32_t slice, int32_t row, float y, float z, float& x) const
   {
-    mCorrMap->InverseTransformYZtoX(slice, row, y, z, x, mCorrMapRef, mCorrMapMShape, (mScaleInverse ? mLumiScale : 0), (mScaleInverse ? 1 : 0), mLumiScaleMode);
+    mCorrMap->InverseTransformYZtoX(slice, row, y, z, x);
   }
 
   GPUd() void InverseTransformYZtoNominalYZ(int32_t slice, int32_t row, float y, float z, float& ny, float& nz) const
   {
-    mCorrMap->InverseTransformYZtoNominalYZ(slice, row, y, z, ny, nz, mCorrMapRef, mCorrMapMShape, (mScaleInverse ? mLumiScale : 0), (mScaleInverse ? 1 : 0), mLumiScaleMode);
+    mCorrMap->InverseTransformYZtoNominalYZ(slice, row, y, z, ny, nz);
   }
 
-  GPUd() const o2::gpu::TPCFastTransform* getCorrMap() const { return mCorrMap; }
-  GPUd() const o2::gpu::TPCFastTransform* getCorrMapRef() const { return mCorrMapRef; }
-  GPUd() const o2::gpu::TPCFastTransform* getCorrMapMShape() const { return mCorrMapMShape; }
+  GPUd() const o2::gpu::TPCFastTransformPOD* getCorrMap() const { return mCorrMap; }
 
-  bool getOwner() const { return mOwner; }
-
-  void setCorrMap(o2::gpu::TPCFastTransform* m);
-  void setCorrMapRef(o2::gpu::TPCFastTransform* m);
-  void setCorrMapMShape(o2::gpu::TPCFastTransform* m);
-  void reportScaling();
-  void setInstLumiCTP(float v)
-  {
-    if (v != mInstLumiCTP) {
-      mInstLumiCTP = v;
-    }
-  }
-
-  void setInstLumi(float v, bool report = false)
-  {
-    if (v != mInstLumi) {
-      mInstLumi = v;
-      updateLumiScale(report);
-    }
-  }
-
-  void setMeanLumi(float v, bool report = false)
-  {
-    if (v != mMeanLumi) {
-      mMeanLumi = v;
-      updateLumiScale(report);
-    }
-  }
-
-  void setMeanLumiRef(float v, bool report = false)
-  {
-    if (v != mMeanLumiRef) {
-      mMeanLumiRef = v;
-      updateLumiScale(report);
-    }
-  }
-
-  void setLumiScaleMode(int32_t v)
-  {
-    if (v != mLumiScaleMode) {
-      mLumiScaleMode = v;
-      updateLumiScale(false);
-    }
-  }
-
-  void setCheckCTPIDCConsistency(bool v) { mCheckCTPIDCConsistency = v; }
-  bool getCheckCTPIDCConsistency() const { return mCheckCTPIDCConsistency; }
-
-  GPUd() float getInstLumiCTP() const { return mInstLumiCTP; }
-  GPUd() float getInstLumi() const { return mInstLumi; }
-  GPUd() float getMeanLumi() const { return mMeanLumi; }
-  GPUd() float getMeanLumiRef() const { return mMeanLumiRef; }
-
-  GPUd() float getLumiScale() const { return mLumiScale; }
-  GPUd() int32_t getLumiScaleMode() const { return mLumiScaleMode; }
-
-  bool isUpdated() const { return mUpdatedFlags != 0; }
-  bool isUpdatedMap() const { return (mUpdatedFlags & UpdateFlags::MapBit) != 0; }
-  bool isUpdatedMapRef() const { return (mUpdatedFlags & UpdateFlags::MapRefBit) != 0; }
-  bool isUpdatedMapMShape() const { return (mUpdatedFlags & UpdateFlags::MapMShapeBit) != 0; }
-  bool isUpdatedLumi() const { return (mUpdatedFlags & UpdateFlags::LumiBit) != 0; }
-  void setUpdatedMap() { mUpdatedFlags |= UpdateFlags::MapBit; }
-  void setUpdatedMapRef() { mUpdatedFlags |= UpdateFlags::MapRefBit; }
-  void setUpdatedMapMShape() { mUpdatedFlags |= UpdateFlags::MapMShapeBit; }
-  void setUpdatedLumi() { mUpdatedFlags |= UpdateFlags::LumiBit; }
+  float getInstLumiCTP() const { return mInstLumiCTP; }
 
+  bool isUpdated() const { return mUpdated; }
+  void acknowledgeUpdate() { mUpdated = false; }
+  void setCorrMap(const o2::gpu::TPCFastTransformPOD* m); // always non-owning
 #if !defined(GPUCA_GPUCODE_DEVICE)
-  void setCorrMap(std::unique_ptr<o2::gpu::TPCFastTransform>&& m);
-  void setCorrMapRef(std::unique_ptr<o2::gpu::TPCFastTransform>&& m);
-  void setCorrMapMShape(std::unique_ptr<o2::gpu::TPCFastTransform>&& m);
+  void setCorrMap(std::vector<char>&& buffer); // owning
 #endif
-  void setOwner(bool v);
-  void acknowledgeUpdate() { mUpdatedFlags = 0; }
-  void setLumiCTPAvailable(bool v) { mLumiCTPAvailable = v; }
-  bool getLumiCTPAvailable() const { return mLumiCTPAvailable; }
-  void setLumiScaleType(int32_t v) { mLumiScaleType = v; }
-  int32_t getLumiScaleType() const { return mLumiScaleType; }
-  void enableMShapeCorrection(bool v) { mEnableMShape = v; }
-  bool getUseMShapeCorrection() const { return mEnableMShape; }
-  bool canUseCorrections() const { return mMeanLumi >= 0.; }
-  void setMeanLumiOverride(float f) { mMeanLumiOverride = f; }
-  void setMeanLumiRefOverride(float f) { mMeanLumiRefOverride = f; }
-  float getMeanLumiOverride() const { return mMeanLumiOverride; }
-  float getMeanLumiRefOverride() const { return mMeanLumiRefOverride; }
-
-  void setInstCTPLumiOverride(float f) { mInstCTPLumiOverride = f; }
-  float getInstCTPLumiOverride() const { return mInstCTPLumiOverride; }
-
-  int32_t getUpdateFlags() const { return mUpdatedFlags; }
-
-  bool getScaleInverse() const { return mScaleInverse; }
-
-  /// return returns if the correction map for the M-shape correction is a dummy spline object
-  GPUd() bool isCorrMapMShapeDummy() const
-  {
-    if (mCorrMapMShape) {
-      // just check for the first spline the number of knots which are 4 in case of default spline object
-      return mCorrMapMShape->getCorrection().getSpline(0, 0).getNumberOfKnots() == 4;
-    }
-    return true;
-  }
 
  protected:
-  enum UpdateFlags { MapBit = 0x1,
-                     MapRefBit = 0x2,
-                     LumiBit = 0x4,
-                     MapMShapeBit = 0x10 };
-  bool mOwner = false;            // is content of pointers owned by the helper
-  bool mLumiCTPAvailable = false; // is CTP Lumi available
-  // these 2 are global options, must be set by the workflow global options
-  int32_t mLumiScaleType = -1; // use CTP Lumi (1) or TPCScaler (2) for the correction scaling, 0 - no scaling
-  int32_t mLumiScaleMode = -1; // scaling-mode of the correciton maps
-  int32_t mUpdatedFlags = 0;
-  float mInstLumiCTP = 0.;                            // instanteneous luminosity from CTP (a.u)
-  float mInstLumi = 0.;                               // instanteneous luminosity (a.u) used for TPC corrections scaling
-  float mMeanLumi = 0.;                               // mean luminosity of the map (a.u) used for TPC corrections scaling
-  float mMeanLumiRef = 0.;                            // mean luminosity of the ref map (a.u) used for TPC corrections scaling reference
-  float mLumiScale = 0.;                              // precalculated mInstLumi/mMeanLumi
-  float mMeanLumiOverride = -1.f;                     // optional value to override mean lumi
-  float mMeanLumiRefOverride = -1.f;                  // optional value to override ref mean lumi
-  float mInstCTPLumiOverride = -1.f;                  // optional value to override inst lumi from CTP
-  bool mEnableMShape = false;                         ///< use v shape correction
-  bool mScaleInverse{false};                          // if set to false the inverse correction is already scaled and will not scaled again
-  bool mCheckCTPIDCConsistency{true};                 // check of selected CTP or IDC scaling source being consistent with the map
-  o2::gpu::TPCFastTransform* mCorrMap{nullptr};       // current transform
-  o2::gpu::TPCFastTransform* mCorrMapRef{nullptr};    // reference transform
-  o2::gpu::TPCFastTransform* mCorrMapMShape{nullptr}; // correction map for v-shape distortions on A-side
-  ClassDefNV(CorrectionMapsHelper, 6);
+  bool mUpdated = false;                                 // flag indicating whether the map was updated
+  float mInstLumiCTP{-1.f};                              // current CTP luminosity - used for track covariance tuning in downstream devices
+  const o2::gpu::TPCFastTransformPOD* mCorrMap{nullptr}; // current transform
+#if !defined(GPUCA_GPUCODE_DEVICE)
+  std::vector<char> mCorrMapBuffer;
+#endif
+  ClassDefNV(CorrectionMapsHelper, 1);
 };
 
 } // namespace gpu
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelperFull.cxx b/GPU/TPCFastTransformation/CorrectionMapsHelperFull.cxx
new file mode 100644
index 0000000000000..93b0e9185351e
--- /dev/null
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelperFull.cxx
@@ -0,0 +1,60 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "CorrectionMapsHelperFull.h"
+#include "Framework/Logger.h"
+
+using namespace o2::gpu;
+using namespace o2::tpc;
+
+//________________________________________________________
+void CorrectionMapsHelperFull::clear()
+{
+  mLumiCTPAvailable = false;
+  mCorrMap = nullptr;
+  mCorrMapRef = nullptr;
+  mCorrMapMShape.reset();
+  mUpdatedFlags = 0;
+  mInstLumiCTP = 0.f;
+  mInstLumi = 0.f;
+  mMeanLumi = 0.f;
+  mMeanLumiRef = 0.f;
+}
+
+void CorrectionMapsHelperFull::setCorrMapMShape(std::unique_ptr<TPCFastTransform>&& m)
+{
+  setUpdatedMapMShape();
+  mCorrMapMShape = std::move(m);
+}
+
+void CorrectionMapsHelperFull::updateLumiScale(bool report)
+{
+  if (!canUseCorrections()) {
+    mLumiScale = -1.f;
+  } else if ((mLumiScaleMode == LumiScaleMode::DerivativeMap) || (mLumiScaleMode == LumiScaleMode::DerivativeMapMC)) {
+    mLumiScale = mMeanLumiRef ? (mInstLumi - mMeanLumi) / mMeanLumiRef : 0.f;
+    LOGP(debug, "mInstLumi: {}  mMeanLumi: {} mMeanLumiRef: {}", mInstLumi, mMeanLumi, mMeanLumiRef);
+  } else {
+    mLumiScale = mMeanLumi ? mInstLumi / mMeanLumi : 0.f;
+  }
+  setUpdatedLumi();
+  if (report) {
+    reportScaling();
+  }
+}
+
+//________________________________________________________
+void CorrectionMapsHelperFull::reportScaling()
+{
+  LOGP(info, "Map scaling update: LumiScaleType={} instLumi(CTP)={} instLumi(scaling)={} meanLumiRef={}, meanLumi={} -> LumiScale={} lumiScaleMode={}, M-Shape map valid: {}, M-Shape default: {}",
+       mLumiScaleType == LumiScaleType::NoScaling ? "NoScaling" : (mLumiScaleType == LumiScaleType::CTPLumi ? "LumiCTP" : "TPCScaler"), getInstLumiCTP(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(),
+       mLumiScaleMode == LumiScaleMode::Linear ? "Linear" : "Derivative", (mCorrMapMShape != nullptr), isCorrMapMShapeDummy());
+}
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelperFull.h b/GPU/TPCFastTransformation/CorrectionMapsHelperFull.h
new file mode 100644
index 0000000000000..090b567bb2407
--- /dev/null
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelperFull.h
@@ -0,0 +1,161 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CorrectionMapsHelperFull.h
+/// \brief Helper class to access correction maps
+/// \author ruben.shahoian@cern.ch matthias.kleiner@cern.ch
+
+#ifndef TPC_CORRECTION_MAPS_HELPERFULL_H_
+#define TPC_CORRECTION_MAPS_HELPERFULL_H_
+
+#include "TPCFastTransform.h"
+#include "CorrectionMapsHelper.h"
+
+namespace o2
+{
+namespace gpu
+{
+
+class CorrectionMapsHelperFull
+{
+ public:
+  CorrectionMapsHelperFull() = default;
+  ~CorrectionMapsHelperFull() { clear(); }
+  CorrectionMapsHelperFull(const CorrectionMapsHelperFull&) = delete;
+  void updateLumiScale(bool report = false);
+  void clear();
+
+  const o2::gpu::TPCFastTransform* getCorrMap() const { return mCorrMap; }
+  const o2::gpu::TPCFastTransform* getCorrMapRef() const { return mCorrMapRef; }
+  const o2::gpu::TPCFastTransform* getCorrMapMShape() const { return mCorrMapMShape.get(); }
+
+  void setCorrMap(o2::gpu::TPCFastTransform* m) { mCorrMap = m; }
+  void setCorrMapRef(o2::gpu::TPCFastTransform* m) { mCorrMapRef = m; }
+  void setCorrMapMShape(std::unique_ptr<o2::gpu::TPCFastTransform>&& m);
+
+  void reportScaling();
+  void setInstLumiCTP(float v)
+  {
+    if (v != mInstLumiCTP) {
+      mInstLumiCTP = v;
+    }
+  }
+
+  void setInstLumi(float v, bool report = false)
+  {
+    if (v != mInstLumi) {
+      mInstLumi = v;
+      updateLumiScale(report);
+    }
+  }
+
+  void setMeanLumi(float v, bool report = false)
+  {
+    if (v != mMeanLumi) {
+      mMeanLumi = v;
+      updateLumiScale(report);
+    }
+  }
+
+  void setMeanLumiRef(float v, bool report = false)
+  {
+    if (v != mMeanLumiRef) {
+      mMeanLumiRef = v;
+      updateLumiScale(report);
+    }
+  }
+
+  void setLumiScaleMode(tpc::LumiScaleMode v)
+  {
+    if (v != mLumiScaleMode) {
+      mLumiScaleMode = v;
+      updateLumiScale(false);
+    }
+  }
+
+  void setCheckCTPIDCConsistency(bool v) { mCheckCTPIDCConsistency = v; }
+  bool getCheckCTPIDCConsistency() const { return mCheckCTPIDCConsistency; }
+
+  float getInstLumiCTP() const { return mInstLumiCTP; }
+  float getInstLumi() const { return mInstLumi; }
+  float getMeanLumi() const { return mMeanLumi; }
+  float getMeanLumiRef() const { return mMeanLumiRef; }
+
+  float getLumiScale() const { return mLumiScale; }
+  tpc::LumiScaleMode getLumiScaleMode() const { return mLumiScaleMode; }
+
+  bool isUpdated() const { return mUpdatedFlags != 0; }
+  bool isUpdatedMap() const { return (mUpdatedFlags & UpdateFlags::MapBit) != 0; }
+  bool isUpdatedMapRef() const { return (mUpdatedFlags & UpdateFlags::MapRefBit) != 0; }
+  bool isUpdatedMapMShape() const { return (mUpdatedFlags & UpdateFlags::MapMShapeBit) != 0; }
+  bool isUpdatedLumi() const { return (mUpdatedFlags & UpdateFlags::LumiBit) != 0; }
+  void setUpdatedMap() { mUpdatedFlags |= UpdateFlags::MapBit; }
+  void setUpdatedMapRef() { mUpdatedFlags |= UpdateFlags::MapRefBit; }
+  void setUpdatedMapMShape() { mUpdatedFlags |= UpdateFlags::MapMShapeBit; }
+  void setUpdatedLumi() { mUpdatedFlags |= UpdateFlags::LumiBit; }
+  void acknowledgeUpdate() { mUpdatedFlags = 0; }
+  void setLumiCTPAvailable(bool v) { mLumiCTPAvailable = v; }
+  bool getLumiCTPAvailable() const { return mLumiCTPAvailable; }
+  void setLumiScaleType(tpc::LumiScaleType v) { mLumiScaleType = v; }
+  tpc::LumiScaleType getLumiScaleType() const { return mLumiScaleType; }
+  void enableMShapeCorrection(bool v) { mEnableMShape = v; }
+  bool getUseMShapeCorrection() const { return mEnableMShape; }
+  bool canUseCorrections() const { return mMeanLumi >= 0.; }
+  void setMeanLumiOverride(float f) { mMeanLumiOverride = f; }
+  void setMeanLumiRefOverride(float f) { mMeanLumiRefOverride = f; }
+  float getMeanLumiOverride() const { return mMeanLumiOverride; }
+  float getMeanLumiRefOverride() const { return mMeanLumiRefOverride; }
+
+  void setInstCTPLumiOverride(float f) { mInstCTPLumiOverride = f; }
+  float getInstCTPLumiOverride() const { return mInstCTPLumiOverride; }
+
+  int32_t getUpdateFlags() const { return mUpdatedFlags; }
+
+  /// return returns if the correction map for the M-shape correction is a dummy spline object
+  bool isCorrMapMShapeDummy() const
+  {
+    if (mCorrMapMShape) {
+      // just check for the first spline the number of knots which are 4 in case of default spline object
+      return mCorrMapMShape->getCorrection().getSpline(0, 0).getNumberOfKnots() == 4;
+    }
+    return true;
+  }
+
+ protected:
+  enum UpdateFlags { MapBit = 0x1,
+                     MapRefBit = 0x2,
+                     LumiBit = 0x4,
+                     MapMShapeBit = 0x10 };
+  bool mLumiCTPAvailable = false; // is CTP Lumi available
+  // these 2 are global options, must be set by the workflow global options
+  tpc::LumiScaleType mLumiScaleType = tpc::LumiScaleType::Unset; // use CTP Lumi (1) or TPCScaler (2) for the correction scaling, 0 - no scaling
+  tpc::LumiScaleMode mLumiScaleMode = tpc::LumiScaleMode::Unset; // scaling-mode of the correction maps: 0 = linear scaling, 1 = using the derivative map, 2 = using the derivative map for MC (i.e. only apply the scaled derivative on top of the reference map)
+  int32_t mUpdatedFlags = 0;
+  float mInstLumiCTP = 0.;                            // instanteneous luminosity from CTP (a.u)
+  float mInstLumi = 0.;                               // instanteneous luminosity (a.u) used for TPC corrections scaling
+  float mMeanLumi = 0.;                               // mean luminosity of the map (a.u) used for TPC corrections scaling
+  float mMeanLumiRef = 0.;                            // mean luminosity of the ref map (a.u) used for TPC corrections scaling reference
+  float mLumiScale = 0.;                              // precalculated mInstLumi/mMeanLumi
+  float mMeanLumiOverride = -1.f;                     // optional value to override mean lumi
+  float mMeanLumiRefOverride = -1.f;                  // optional value to override ref mean lumi
+  float mInstCTPLumiOverride = -1.f;                  // optional value to override inst lumi from CTP
+  bool mEnableMShape = false;                         ///< use v shape correction
+  bool mCheckCTPIDCConsistency{true};                 // check of selected CTP or IDC scaling source being consistent with the map
+  o2::gpu::TPCFastTransform* mCorrMap{nullptr};       // current transform
+  o2::gpu::TPCFastTransform* mCorrMapRef{nullptr};    // reference transform
+  std::unique_ptr<o2::gpu::TPCFastTransform> mCorrMapMShape{nullptr}; // correction map for M-shape distortions on A-side
+  ClassDefNV(CorrectionMapsHelperFull, 6);
+};
+
+} // namespace gpu
+} // namespace o2
+
+#endif
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 3a2b5d0c4ee32..48706bcc2a830 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -145,6 +145,43 @@ class Spline1DContainer : public FlatObject
   /// Get a map (integer U -> corresponding knot index)
   GPUd() const int32_t* getUtoKnotMap() const { return mUtoKnotMap; }
 
+  /// Get the knot array from an explicit flat buffer pointer.
+  /// Use this instead of getKnots() when the object was copied across process
+  /// boundaries and mFlatBufferPtr has not been fixed up (zero-copy path).
+  GPUd() const Knot* getKnotsFromBuffer(const char* flatBuf) const
+  {
+    return reinterpret_cast<const Knot*>(flatBuf);
+  }
+
+  /// Get i-th knot from an explicit flat buffer pointer.
+  /// Use this instead of getKnot() on the zero-copy path.
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() const Knot& getKnotFromBuffer(const char* flatBuf, int32_t i) const
+  {
+    if (SafeT == SafetyLevel::kSafe) {
+      i = (i < 0) ? 0 : (i >= mNumberOfKnots ? mNumberOfKnots - 1 : i);
+    }
+    return getKnotsFromBuffer(flatBuf)[i];
+  }
+
+  /// Get the U->knot-index map from an explicit flat buffer pointer.
+  GPUd() const int32_t* getUtoKnotMapFromBuffer(const char* flatBuf) const
+  {
+    return reinterpret_cast<const int32_t*>(flatBuf + mNumberOfKnots * sizeof(Knot));
+  }
+
+  /// Map a U coordinate to its left knot index, using an explicit flat buffer pointer.
+  /// Use this instead of getLeftKnotIndexForU() on the zero-copy path.
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() int32_t getLeftKnotIndexForUFromBuffer(const char* flatBuf, DataT u) const
+  {
+    int32_t iu = u < 0 ? 0 : (u > (float)mUmax ? mUmax : (int32_t)u);
+    if (SafeT == SafetyLevel::kSafe) {
+      iu = (iu < 0) ? 0 : (iu > mUmax ? mUmax : iu);
+    }
+    return getUtoKnotMapFromBuffer(flatBuf)[iu];
+  }
+
   /// Convert X coordinate to U
   GPUd() DataT convXtoU(DataT x) const { return (x - mXmin) * mXtoUscale; }
 
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index d0648f2afa22b..d06fd8921b60a 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -487,6 +487,88 @@ class Spline2DSpec<DataT, YdimT, 0>
     }
   }
 
+  /// Zero-copy-safe interpolation.
+  ///
+  /// Identical to interpolateAtU() but takes explicit flat buffer pointers for
+  /// the two 1-D grids instead of relying on the internal (potentially stale)
+  /// mFlatBufferPtr inside mGridX1 / mGridX2.
+  ///
+  /// Use this overload when the spline object was transported across DPL/FairMQ
+  /// process boundaries via shared memory
+  /// called (zero-copy, read-only buffer).
+  ///
+  /// How to obtain the buffer pointers from TPCFastTransformPOD:
+  ///
+  ///   const char* splineFlatBuf = podBuf + pod.getFlatBufferOffset(scenarioID);
+  ///   // gridX1 is always at offset 0 of the spline flat buffer:
+  ///   const char* gridX1FlatBuf = splineFlatBuf;
+  ///   // gridX2 comes after gridX1 (use the offset stored in the spline object):
+  ///   const char* gridX2FlatBuf = splineFlatBuf + spline.getGridX2Offset();
+  ///
+  /// \param gridX1FlatBuf  Pointer to the flat buffer of mGridX1
+  /// \param gridX2FlatBuf  Pointer to the flat buffer of mGridX2
+  /// \param inpYdim        Number of Y dimensions
+  /// \param Parameters     Spline correction data for this (sector, row, splineID)
+  /// \param u1, u2         Interpolation coordinates
+  /// \param S              Output array of length inpYdim
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() void interpolateAtUZeroCopy(const char* gridX1FlatBuf,
+                                     const char* gridX2FlatBuf,
+                                     int32_t inpYdim,
+                                     GPUgeneric() const DataT Parameters[],
+                                     DataT u1, DataT u2,
+                                     GPUgeneric() DataT S[/*inpYdim*/]) const
+  {
+    const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
+    const int32_t nYdim = nYdimTmp.get();
+    const auto nYdim4 = nYdim * 4;
+
+    const DataT& u = u1;
+    const DataT& v = u2;
+
+    // getNumberOfKnots() is safe: mNumberOfKnots is a plain int stored directly
+    // in the Spline1DContainer struct, not behind mFlatBufferPtr.
+    int32_t nu = mGridX1.getNumberOfKnots();
+
+    // Use buffer-aware accessors instead of mGridX1.getLeftKnotIndexForU() and
+    // mGridX1.getKnot(). Both of the standard versions dereference mFlatBufferPtr
+    // (via mUtoKnotMap and the knot array), which is stale after cross-process copy.
+    int32_t iu = mGridX1.template getLeftKnotIndexForUFromBuffer<SafeT>(gridX1FlatBuf, u);
+    int32_t iv = mGridX2.template getLeftKnotIndexForUFromBuffer<SafeT>(gridX2FlatBuf, v);
+
+    const typename TBase::Knot& knotU = mGridX1.template getKnotFromBuffer<SafetyLevel::kNotSafe>(gridX1FlatBuf, iu);
+    const typename TBase::Knot& knotV = mGridX2.template getKnotFromBuffer<SafetyLevel::kNotSafe>(gridX2FlatBuf, iv);
+
+    const DataT* A = Parameters + (nu * iv + iu) * nYdim4;
+    const DataT* B = A + nYdim4 * nu;
+
+    // getSderivativesOverParsAtU() is pure math on the Knot struct fields {u, Li}.
+    // It does NOT touch mFlatBufferPtr, so it is safe on the zero-copy path.
+    auto val1 = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
+    auto val2 = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
+
+    const auto& dSl = val1[0];
+    const auto& dDl = val1[1];
+    const auto& dSr = val1[2];
+    const auto& dDr = val1[3];
+    const auto& dSd = val2[0];
+    const auto& dDd = val2[1];
+    const auto& dSu = val2[2];
+    const auto& dDu = val2[3];
+
+    DataT a[8] = {dSl * dSd, dSl * dDd, dDl * dSd, dDl * dDd,
+                  dSr * dSd, dSr * dDd, dDr * dSd, dDr * dDd};
+    DataT b[8] = {dSl * dSu, dSl * dDu, dDl * dSu, dDl * dDu,
+                  dSr * dSu, dSr * dDu, dDr * dSu, dDr * dDu};
+
+    for (int32_t dim = 0; dim < nYdim; dim++) {
+      S[dim] = 0;
+      for (int32_t i = 0; i < 8; i++) {
+        S[dim] += a[i] * A[nYdim * i + dim] + b[i] * B[nYdim * i + dim];
+      }
+    }
+  }
+
  protected:
   using TBase::mGridX1;
   using TBase::mGridX2;
@@ -563,6 +645,19 @@ class Spline2DSpec<DataT, YdimT, 1>
     TBase::template interpolateAtU<SafeT>(YdimT, Parameters, u1, u2, S);
   }
 
+  /// Forwarding overload for Spec 1 (compile-time YdimT).
+  /// Passes YdimT as inpYdim directly to the Spec 0 implementation.
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() void interpolateAtUZeroCopy(const char* gridX1FlatBuf,
+                                     const char* gridX2FlatBuf,
+                                     GPUgeneric() const DataT Parameters[],
+                                     DataT u1, DataT u2,
+                                     GPUgeneric() DataT S[/*YdimT*/]) const
+  {
+    TBase::template interpolateAtUZeroCopy<SafeT>(gridX1FlatBuf, gridX2FlatBuf,
+                                                  YdimT, Parameters, u1, u2, S);
+  }
+
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
   GPUd() void interpolateParametersAtU(GPUgeneric() const DataT Parameters[],
                                        DataT u1, DataT u2, GPUgeneric() DataT P[/* 4*YdimT */]) const
@@ -642,6 +737,7 @@ class Spline2DSpec<DataT, YdimT, 2>
   ///  _______  Expert tools: interpolation with given nYdim and external Parameters _______
 
   using TBase::interpolateAtU;
+  using TBase::interpolateAtUZeroCopy;
 };
 
 /// ==================================================================================================
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index 016eed2e6beb4..295b3bb19431e 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -8,15 +8,11 @@
 // In applying this license CERN does not waive the privileges and immunities
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
-
-/// \file  TPCFastTransformPOD.cxx
-/// \brief Implementation of POD correction map
-///
+//
 /// \author  ruben.shahoayn@cern.ch
-
+/// \file  TPCFastTransformPOD.cxx
 /// \brief Implementation of POD correction map
 ///
-/// \author  ruben.shahoayn@cern.ch
 
 #if !defined(GPUCA_NO_ROOT) && !defined(GPUCA_NO_FMT) && !defined(GPUCA_STANDALONE)
 #include <TRandom.h>
@@ -37,10 +33,12 @@ size_t TPCFastTransformPOD::estimateSize(const TPCFastSpaceChargeCorrection& ori
   const size_t selfSizeFix = sizeof(TPCFastTransformPOD);
   size_t nextDynOffs = alignOffset(selfSizeFix);
   nextDynOffs = alignOffset(nextDynOffs + origCorr.mNumberOfScenarios * sizeof(size_t)); // spline scenarios start here
+  nextDynOffs = alignOffset(nextDynOffs + origCorr.mNumberOfScenarios * sizeof(size_t)); // flatBufOffs array
   // space for splines
   for (int isc = 0; isc < origCorr.mNumberOfScenarios; isc++) {
     const auto& spline = origCorr.mScenarioPtr[isc];
     nextDynOffs = alignOffset(nextDynOffs + sizeof(spline));
+    nextDynOffs = alignOffset(nextDynOffs + spline.getFlatBufferSize());
   }
   // space for splines data
   for (int is = 0; is < 3; is++) {
@@ -62,6 +60,32 @@ size_t TPCFastTransformPOD::estimateSize(const TPCFastSpaceChargeCorrection& ori
   return nextDynOffs;
 }
 
+void TPCFastTransformPOD::print() const
+{
+  LOGP(info, "TPCFastTransformPOD: this={:p} sizeof={} mApplyCorrection={} mNumberOfScenarios={} mTotalSize={} mOffsScenariosOffsets={} mT0={} mVdrift={} mLumi={} mIDC={}",
+       (void*)this, sizeof(*this), mApplyCorrection, mNumberOfScenarios, mTotalSize, mOffsScenariosOffsets, mT0, mVdrift, mLumi, mIDC);
+
+  for (int s = 0; s < TPCFastTransformGeo::getNumberOfSectors(); s++) {
+    for (int i = 0; i < NSplineIDs; i++) {
+      LOGP(info, "mSplineDataOffsets[{}][{}]={}", s, i, mSplineDataOffsets[s][i]);
+    }
+  }
+  const size_t scenOffset = getScenarioOffset(0);
+  const auto& spline = getSpline(0, 0);
+  LOGP(info, "scenOffset={} spline_addr={:p} expected={:p}", scenOffset, (void*)&spline, (void*)(getThis() + scenOffset));
+
+  const float* splineData = getCorrectionData(0, 0);
+  LOGP(info, "spline internal check: &spline={:p} splineData={:p} buf_start={:p} buf_end={:p}",
+       (void*)&spline, (void*)splineData,
+       (void*)getThis(), (void*)(getThis() + mTotalSize));
+
+  // check if splineData is within buffer
+  bool dataInBuf = (splineData >= (float*)getThis()) && (splineData < (float*)(getThis() + mTotalSize));
+  LOGP(info, "splineData in buffer: {}", dataInBuf);
+
+  LOGP(info, "splineData offset from buf_start = {}", (size_t)((const char*)splineData - getThis()));
+}
+
 TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, const TPCFastSpaceChargeCorrection& origCorr)
 {
   // instantiate object to already created buffer of the right size
@@ -91,17 +115,34 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
   LOGP(debug, "Set mOffsScenariosOffsets = {}", podMap.mOffsScenariosOffsets);
   nextDynOffs = alignOffset(nextDynOffs + podMap.mNumberOfScenarios * sizeof(size_t)); // spline scenarios start here
 
+  podMap.mOffsFlatBufferOffsets = nextDynOffs; // <-- add this
+  nextDynOffs = alignOffset(nextDynOffs + podMap.mNumberOfScenarios * sizeof(size_t));
+
   // copy spline objects
   size_t* scenOffs = reinterpret_cast<size_t*>(buff + podMap.mOffsScenariosOffsets);
+  size_t* flatBufOffs = reinterpret_cast<size_t*>(buff + podMap.mOffsFlatBufferOffsets);
+
   for (int isc = 0; isc < origCorr.mNumberOfScenarios; isc++) {
     scenOffs[isc] = nextDynOffs;
     const auto& spline = origCorr.mScenarioPtr[isc];
     if (buffSize < nextDynOffs + sizeof(spline)) {
       throw std::runtime_error(fmt::format("attempt to copy {} bytes for spline for scenario {} to {}, overflowing the buffer of size {}", sizeof(spline), isc, nextDynOffs + sizeof(spline), buffSize));
     }
+
+    // copy spline object
     std::memcpy(buff + scenOffs[isc], &spline, sizeof(spline));
     nextDynOffs = alignOffset(nextDynOffs + sizeof(spline));
     LOGP(debug, "Copy {} bytes for spline scenario {} (ptr:{}) to offsset {}", sizeof(spline), isc, (void*)&spline, scenOffs[isc]);
+
+    // copy spline flat buffer
+    flatBufOffs[isc] = nextDynOffs; // store flat buffer offset
+    std::memcpy(buff + nextDynOffs, spline.getFlatBufferPtr(), spline.getFlatBufferSize());
+
+    // fix up internal pointer
+    auto* splineInBuf = reinterpret_cast<SplineType*>(buff + scenOffs[isc]);
+    splineInBuf->setActualBufferAddress(buff + nextDynOffs);
+
+    nextDynOffs = alignOffset(nextDynOffs + spline.getFlatBufferSize());
   }
 
   // copy splines data
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index ca54a74115068..1a6a695e68dcf 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -160,6 +160,8 @@ class TPCFastTransformPOD
   /// Sets CTP Lumi estimator
   GPUd() void setLumi(float v) { mLumi = v; }
 
+  GPUd() void setCalibration1(int64_t timeStamp, float t0, float vDrift);
+
   /// Gives a reference to a spline
   GPUd() const SplineType& getSpline(int32_t sector, int32_t row) const { return *reinterpret_cast<const SplineType*>(getThis() + getScenarioOffset(getSectorRowInfo(sector, row).splineScenarioID)); }
 
@@ -221,6 +223,13 @@ class TPCFastTransformPOD
   template <typename V>
   static TPCFastTransformPOD* create(V& destVector, const TPCFastSpaceChargeCorrection& src);
 
+  static TPCFastTransformPOD* create(std::vector<char>& buf, const TPCFastTransformPOD& src)
+  {
+    buf.resize(src.size());
+    std::memcpy(buf.data(), &src, src.size());
+    return reinterpret_cast<TPCFastTransformPOD*>(buf.data());
+  }
+
   bool test(const TPCFastTransform& src, int32_t npoints = 100000) const { return test(src.getCorrection(), npoints); }
   bool test(const TPCFastSpaceChargeCorrection& origCorr, int32_t npoints = 100000) const;
 #endif
@@ -246,18 +255,40 @@ class TPCFastTransformPOD
   static size_t estimateSize(const TPCFastSpaceChargeCorrection& origCorr);
   static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastTransform& src);
   static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastSpaceChargeCorrection& src);
-  ///< get address to which the offset in bytes must be added to arrive to particular dynamic part
-  GPUd() const char* getThis() const { return reinterpret_cast<const char*>(this); }
-  GPUd() static TPCFastTransformPOD& getNonConst(char* head) { return *reinterpret_cast<TPCFastTransformPOD*>(head); }
+  static TPCFastTransformPOD& getNonConst(char* head) { return *reinterpret_cast<TPCFastTransformPOD*>(head); }
 #endif
 
+  GPUd() const char* getThis() const { return reinterpret_cast<const char*>(this); }
+
   ///< return offset of the spline object start (equivalent of mScenarioPtr in the TPCFastSpaceChargeCorrection)
   GPUd() size_t getScenarioOffset(int s) const { return (reinterpret_cast<const size_t*>(getThis() + mOffsScenariosOffsets))[s]; }
 
+  GPUd() size_t getFlatBufferOffset(int s) const { return (reinterpret_cast<const size_t*>(getThis() + mOffsFlatBufferOffsets))[s]; }
+
+  // Returns a pointer to the flat buffer of scenario isc, using only the
+  // stored offset array (mOffsFlatBufferOffsets). No stale pointer involved.
+  GPUd() const char* getSplineFlatBuffer(int32_t isc) const
+  {
+    const size_t* offs = reinterpret_cast<const size_t*>(getThis() + mOffsFlatBufferOffsets);
+    return getThis() + offs[isc];
+  }
+
+  // Returns a pointer to mGridX2's flat buffer inside the spline flat buffer.
+  // Reproduces the layout from Spline2DContainer::setActualBufferAddress using
+  // only safe values: getFlatBufferSize() reads mNumberOfKnots/mUmax (plain ints).
+  template <typename SplineT>
+  GPUd() const char* getGridX2FlatBuffer(const SplineT& spline, int32_t isc) const
+  {
+    const size_t g1sz = spline.getGridX1().getFlatBufferSize();
+    const size_t g2align = spline.getGridX2().getBufferAlignmentBytes();
+    return getSplineFlatBuffer(isc) + FlatObject::alignSize(g1sz, g2align);
+  }
+
   bool mApplyCorrection{};                                                          ///< flag to apply corrections
   int mNumberOfScenarios{};                                                         ///< Number of approximation spline scenarios
   size_t mTotalSize{};                                                              ///< total size of the buffer
   size_t mOffsScenariosOffsets{};                                                   ///< start of the array of mNumberOfScenarios offsets for each type of spline
+  size_t mOffsFlatBufferOffsets{};                                                  ///< offset to array of mNumberOfScenarios flat buffer offsets
   size_t mSplineDataOffsets[TPCFastTransformGeo::getNumberOfSectors()][NSplineIDs]; ///< start of data for each sector and iSpline data
   long int mTimeStamp{};                                                            ///< time stamp of the current calibration
   float mT0;                                                                        ///< T0 in [time bin]
@@ -274,14 +305,18 @@ class TPCFastTransformPOD
 GPUdi() void TPCFastTransformPOD::getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const
 {
   const auto& info = getSectorRowInfo(sector, row);
+  const int32_t isc = info.splineScenarioID;
   const SplineType& spline = getSpline(sector, row);
   const float* splineData = getCorrectionData(sector, row);
 
   float u, v, s;
   convLocalToGrid(sector, row, y, z, u, v, s);
 
+  const char* g1buf = getSplineFlatBuffer(isc);
+  const char* g2buf = getGridX2FlatBuffer(spline, isc);
+
   float dxyz[3];
-  spline.interpolateAtU(splineData, u, v, dxyz);
+  spline.interpolateAtUZeroCopy(g1buf, g2buf, splineData, val[0], val[1], dxyz);
 
   if (CAMath::Abs(dxyz[0]) > 100.f || CAMath::Abs(dxyz[1]) > 100.f || CAMath::Abs(dxyz[2]) > 100.f) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
@@ -297,8 +332,14 @@ GPUdi() float TPCFastTransformPOD::getCorrectionXatRealYZ(int32_t sector, int32_
   const auto& info = getSectorRowInfo(sector, row);
   float u, v, s;
   convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
+
+  const int32_t isc = info.splineScenarioID;
+  const auto& spline = getSplineInvX(sector, row);
+  const char* g1buf = getSplineFlatBuffer(isc);
+  const char* g2buf = getGridX2FlatBuffer(spline, isc);
+
   float dx = 0;
-  getSplineInvX(sector, row).interpolateAtU(getCorrectionDataInvX(sector, row), u, v, &dx);
+  spline.interpolateAtUZeroCopy(g1buf, g2buf, getCorrectionDataInvX(sector, row), u, v, &dx);
   if (CAMath::Abs(dx) > 100.f) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
@@ -311,8 +352,13 @@ GPUdi() void TPCFastTransformPOD::getCorrectionYZatRealYZ(int32_t sector, int32_
   float u, v, s;
   convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
   const auto& info = getSectorRowInfo(sector, row);
+  const int32_t isc = info.splineScenarioID;
+  const auto& spline = getSplineInvYZ(sector, row);
+  const char* g1buf = getSplineFlatBuffer(isc);
+  const char* g2buf = getGridX2FlatBuffer(spline, isc);
+
   float dyz[2];
-  getSplineInvYZ(sector, row).interpolateAtU(getCorrectionDataInvYZ(sector, row), u, v, dyz);
+  spline.interpolateAtUZeroCopy(g1buf, g2buf, getCorrectionDataInvYZ(sector, row), u, v, dyz);
   if (CAMath::Abs(dyz[0]) > 100.f || CAMath::Abs(dyz[1]) > 100.f) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
@@ -910,6 +956,59 @@ GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ_new(int32_t se
   nz = (nz1 * c1 + nz2 * c2);
 }
 
+GPUdi() void TPCFastTransformPOD::convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const
+{
+  float l = (time - mT0 - vertexTime) * mVdrift;
+  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
+  y = localval[0];
+  z = localval[1];
+}
+
+GPUdi() void TPCFastTransformPOD::convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const
+{
+  float l = getGeometry().getTPCzLength() + (time - mT0 - maxTimeBin) * mVdrift;
+  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
+  y = localval[0];
+  z = localval[1];
+}
+
+GPUdi() void TPCFastTransformPOD::convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const
+{
+  const auto padLength = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
+  pad = padLength[0];
+  time = convDriftLengthToTime(padLength[1], maxTimeBin);
+}
+
+GPUdi() float TPCFastTransformPOD::convDriftLengthToTime(float driftLength, float vertexTime) const
+{
+  return (mT0 + vertexTime + driftLength / mVdrift);
+}
+
+GPUdi() float TPCFastTransformPOD::convZOffsetToVertexTime(int32_t sector, float zOffset, float maxTimeBin) const
+{
+  if (sector < getGeometry().getNumberOfSectorsA()) {
+    return maxTimeBin - (getGeometry().getTPCzLength() + zOffset) / mVdrift;
+  } else {
+    return maxTimeBin - (getGeometry().getTPCzLength() - zOffset) / mVdrift;
+  }
+}
+
+GPUdi() float TPCFastTransformPOD::convVertexTimeToZOffset(int32_t sector, float vertexTime, float maxTimeBin) const
+{
+  if (sector < getGeometry().getNumberOfSectorsA()) {
+    return (maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLength();
+  } else {
+    return -((maxTimeBin - vertexTime) * mVdrift - getGeometry().getTPCzLength());
+  }
+}
+
+GPUdi() void TPCFastTransformPOD::setCalibration1(int64_t timeStamp, float t0, float vDrift)
+{
+  mTimeStamp = timeStamp;
+  mT0 = t0;
+  mVdrift = vDrift;
+}
+
 } // namespace gpu
 } // namespace o2
 
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index c5e4124c41650..b492b1c84a11a 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -78,7 +78,7 @@ namespace gpu
 struct GPUO2InterfaceConfiguration;
 class GPUDisplayFrontendInterface;
 class CorrectionMapsHelper;
-class TPCFastTransform;
+class TPCFastTransformPOD;
 struct GPUSettingsTF;
 class GPUO2Interface;
 struct TPCPadGainCalib;
@@ -105,10 +105,6 @@ class GPURecoWorkflowSpec : public o2::framework::Task
 
   struct Config {
     int32_t itsTriggerType = 0;
-    int32_t lumiScaleMode = 0;
-    bool checkCTPIDCconsistency = true;
-    bool enableMShape = false;
-    bool enableCTPLumi = false;
     int32_t enableDoublePipeline = 0;
     int32_t tpcDeadMapSources = -1;
     bool tpcUseMCTimeGain = false; // use time gain calibration for MC (true) or from data (false)
@@ -129,7 +125,6 @@ class GPURecoWorkflowSpec : public o2::framework::Task
     bool runTPCTracking = false;
     bool runTRDTracking = false;
     bool readTRDtracklets = false;
-    int32_t lumiScaleType = 0; // 0=off, 1=CTP, 2=TPC scalers
     bool outputErrorQA = false;
     bool runITSTracking = false;
     bool itsStaggered = false;
@@ -159,9 +154,8 @@ class GPURecoWorkflowSpec : public o2::framework::Task
 
  private:
   struct calibObjectStruct {
-    std::unique_ptr<TPCFastTransform> mFastTransform;
-    std::unique_ptr<TPCFastTransform> mFastTransformRef;
-    std::unique_ptr<TPCFastTransform> mFastTransformMShape;
+    std::vector<char> mUpdatedTransformBuffer;
+    std::unique_ptr<TPCFastTransformPOD> mFastTransform;
     std::unique_ptr<o2::tpc::CorrectionMapsLoader> mFastTransformHelper;
     std::unique_ptr<TPCPadGainCalib> mTPCPadGainCalib;
     std::unique_ptr<o2::tpc::CalibdEdxContainer> mdEdxCalibContainer;
diff --git a/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h b/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
index 9ffcfc7a206f1..31e9520f3ae1f 100644
--- a/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
+++ b/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
@@ -68,9 +68,6 @@ class O2GPUDPLDisplaySpec : public o2::framework::Task
   std::unique_ptr<GPUO2InterfaceDisplay> mDisplay;
   std::unique_ptr<GPUO2InterfaceConfiguration> mConfig;
   std::unique_ptr<GPUSettingsO2> mConfParam;
-  std::unique_ptr<TPCFastTransform> mFastTransform;
-  std::unique_ptr<TPCFastTransform> mFastTransformRef;
-  std::unique_ptr<TPCFastTransform> mFastTransformMShape;
   std::unique_ptr<o2::tpc::CorrectionMapsLoader> mFastTransformHelper;
   std::unique_ptr<o2::trd::GeometryFlat> mTrdGeo;
   std::unique_ptr<o2::itsmft::TopologyDictionary> mITSDict;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 4b1aa7fd58bd5..dbc8f229829a0 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -254,8 +254,6 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     initFunctionTPCCalib(ic);
 
     mConfig->configCalib.fastTransform = mCalibObjects.mFastTransformHelper->getCorrMap();
-    mConfig->configCalib.fastTransformRef = mCalibObjects.mFastTransformHelper->getCorrMapRef();
-    mConfig->configCalib.fastTransformMShape = mCalibObjects.mFastTransformHelper->getCorrMapMShape();
     mConfig->configCalib.fastTransformHelper = mCalibObjects.mFastTransformHelper.get();
     if (mConfig->configCalib.fastTransform == nullptr) {
       throw std::invalid_argument("GPU workflow: initialization of the TPC transformation failed");
@@ -1137,9 +1135,6 @@ Options GPURecoWorkflowSpec::options()
   if (mSpecConfig.enableDoublePipeline == 2) {
     return opts;
   }
-  if (mSpecConfig.outputTracks) {
-    o2::tpc::CorrectionMapsLoader::addOptions(opts);
-  }
   return opts;
 }
 
@@ -1190,8 +1185,7 @@ Inputs GPURecoWorkflowSpec::inputs()
     inputs.emplace_back("tpcthreshold", gDataOriginTPC, "PADTHRESHOLD", 0, Lifetime::Condition, ccdbParamSpec("TPC/Config/FEEPad"));
     o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
     Options optsDummy;
-    o2::tpc::CorrectionMapsLoaderGloOpts gloOpts{mSpecConfig.lumiScaleType, mSpecConfig.lumiScaleMode, mSpecConfig.enableMShape, mSpecConfig.enableCTPLumi};
-    mCalibObjects.mFastTransformHelper->requestCCDBInputs(inputs, optsDummy, gloOpts); // option filled here is lost
+    mCalibObjects.mFastTransformHelper->requestInputs(inputs, optsDummy); // option filled here is lost
   }
   if (mSpecConfig.decompressTPC) {
     inputs.emplace_back(InputSpec{"input", ConcreteDataTypeMatcher{gDataOriginTPC, mSpecConfig.decompressTPCFromROOT ? o2::header::DataDescription("COMPCLUSTERS") : o2::header::DataDescription("COMPCLUSTERSFLAT")}, Lifetime::Timeframe});
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index 2b2f81246fc04..5188554cc9be8 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -107,19 +107,11 @@ void GPURecoWorkflowSpec::initFunctionTPCCalib(InitContext& ic)
   mCalibObjects.mdEdxCalibContainer.reset(new o2::tpc::CalibdEdxContainer());
   mTPCVDriftHelper.reset(new o2::tpc::VDriftHelper());
   mCalibObjects.mFastTransformHelper.reset(new o2::tpc::CorrectionMapsLoader());
-  mCalibObjects.mFastTransform = std::move(o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
-  mCalibObjects.mFastTransformRef = std::move(o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
-  mCalibObjects.mFastTransformMShape = std::move(o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
-  mCalibObjects.mFastTransformHelper->setCorrMap(mCalibObjects.mFastTransform.get()); // just to reserve the space
-  mCalibObjects.mFastTransformHelper->setCorrMapRef(mCalibObjects.mFastTransformRef.get());
-  mCalibObjects.mFastTransformHelper->setLumiScaleType(mSpecConfig.lumiScaleType);
-  mCalibObjects.mFastTransformHelper->setCorrMapMShape(mCalibObjects.mFastTransformMShape.get());
-  mCalibObjects.mFastTransformHelper->setLumiScaleMode(mSpecConfig.lumiScaleMode);
-  mCalibObjects.mFastTransformHelper->setCheckCTPIDCConsistency(mSpecConfig.checkCTPIDCconsistency);
-  mCalibObjects.mFastTransformHelper->enableMShapeCorrection(mSpecConfig.enableMShape);
-  if (mSpecConfig.outputTracks) {
-    mCalibObjects.mFastTransformHelper->init(ic);
-  }
+
+  std::vector<char> buffer;
+  gpu::TPCFastTransformPOD::create(buffer, *o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
+  mCalibObjects.mFastTransformHelper->setCorrMap(std::move(buffer));
+
   if (mConfParam->dEdxDisableTopologyPol) {
     LOGP(info, "Disabling loading of track topology correction using polynomials from CCDB");
     mCalibObjects.mdEdxCalibContainer->disableCorrectionCCDB(o2::tpc::CalibsdEdx::CalTopologyPol);
@@ -293,7 +285,6 @@ void GPURecoWorkflowSpec::finaliseCCDBTPC(ConcreteDataMatcher& matcher, void* ob
          std::underlying_type_t<o2::tpc::FEEConfig::Tags>(fee->tag), mCreationForCalib,
          mTPCDeadChannelMapCreator->getDeadChannelMapFEE().getSum<int32_t>(), mTPCDeadChannelMapCreator->getDeadChannelMap().getSum<int32_t>());
   } else if (mTPCVDriftHelper->accountCCDBInputs(matcher, obj)) {
-  } else if (mCalibObjects.mFastTransformHelper->accountCCDBInputs(matcher, obj)) {
   } else if (matcher == ConcreteDataMatcher(gDataOriginTPC, "NNCLUSTERIZER_C1", 0)) {
     mConfig->configCalib.nnClusterizerNetworks[0] = static_cast<o2::tpc::ORTRootSerializer*>(obj);
     LOG(info) << "(NN CLUS) " << (mConfig->configCalib.nnClusterizerNetworks[0])->getONNXModelSize() << " bytes loaded for NN clusterizer: classification_c1";
@@ -358,50 +349,27 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
         mTPCVDriftHelper->extractCCDBInputs(pc);
         mCalibObjects.mFastTransformHelper->extractCCDBInputs(pc);
       }
-      if (mTPCVDriftHelper->isUpdated() || mCalibObjects.mFastTransformHelper->isUpdated()) {
-        const auto& vd = mTPCVDriftHelper->getVDriftObject();
-        LOGP(info, "Updating{}TPC fast transform map and/or VDrift factor of {} wrt reference {} and TDrift offset {} wrt reference {} from source {}",
-             mCalibObjects.mFastTransformHelper->isUpdated() ? " new " : " old ",
-             vd.corrFact, vd.refVDrift, vd.timeOffsetCorr, vd.refTimeOffset, mTPCVDriftHelper->getSourceName());
-
-        bool mustUpdateHelper = false;
-        if (mTPCVDriftHelper->isUpdated() || mCalibObjects.mFastTransformHelper->isUpdatedMap()) {
-          oldCalibObjects.mFastTransform = std::move(mCalibObjects.mFastTransform);
-          mCalibObjects.mFastTransform.reset(new TPCFastTransform);
-          mCalibObjects.mFastTransform->cloneFromObject(*mCalibObjects.mFastTransformHelper->getCorrMap(), nullptr);
-          o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCalibObjects.mFastTransform, 0, vd.corrFact, vd.refVDrift, vd.getTimeOffset());
-          newCalibObjects.fastTransform = mCalibObjects.mFastTransform.get();
-          mustUpdateHelper = true;
-        }
-        if (mTPCVDriftHelper->isUpdated() || mCalibObjects.mFastTransformHelper->isUpdatedMapRef()) {
-          oldCalibObjects.mFastTransformRef = std::move(mCalibObjects.mFastTransformRef);
-          mCalibObjects.mFastTransformRef.reset(new TPCFastTransform);
-          mCalibObjects.mFastTransformRef->cloneFromObject(*mCalibObjects.mFastTransformHelper->getCorrMapRef(), nullptr);
-          o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCalibObjects.mFastTransformRef, 0, vd.corrFact, vd.refVDrift, vd.getTimeOffset());
-          newCalibObjects.fastTransformRef = mCalibObjects.mFastTransformRef.get();
-          mustUpdateHelper = true;
-        }
-        if (mTPCVDriftHelper->isUpdated() || mCalibObjects.mFastTransformHelper->isUpdatedMapMShape()) {
-          oldCalibObjects.mFastTransformMShape = std::move(mCalibObjects.mFastTransformMShape);
-          mCalibObjects.mFastTransformMShape.reset(new TPCFastTransform);
-          mCalibObjects.mFastTransformMShape->cloneFromObject(*mCalibObjects.mFastTransformHelper->getCorrMapMShape(), nullptr);
-          o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*mCalibObjects.mFastTransformMShape, 0, vd.corrFact, vd.refVDrift, vd.getTimeOffset());
-          newCalibObjects.fastTransformMShape = mCalibObjects.mFastTransformMShape.get();
-          mustUpdateHelper = true;
-        }
-        if (mustUpdateHelper || mCalibObjects.mFastTransformHelper->isUpdatedLumi()) {
+      if (mCalibObjects.mFastTransformHelper->isUpdated()) {
+          // New map arrived from TPCScalerSpec — VDrift already baked in, just swap it
+          const auto& vd = mTPCVDriftHelper->getVDriftObject();
+          LOGP(info, "Updating new TPC fast transform map, VDrift factor {} wrt reference {} and TDrift offset {} wrt reference {} from source {}",
+              vd.corrFact, vd.refVDrift, vd.timeOffsetCorr, vd.refTimeOffset, mTPCVDriftHelper->getSourceName());
+
           oldCalibObjects.mFastTransformHelper = std::move(mCalibObjects.mFastTransformHelper);
           mCalibObjects.mFastTransformHelper.reset(new o2::tpc::CorrectionMapsLoader);
-          mCalibObjects.mFastTransformHelper->copySettings(*oldCalibObjects.mFastTransformHelper);
-          mCalibObjects.mFastTransformHelper->setCorrMap(mCalibObjects.mFastTransform.get());
-          mCalibObjects.mFastTransformHelper->setCorrMapRef(mCalibObjects.mFastTransformRef.get());
-          mCalibObjects.mFastTransformHelper->setCorrMapMShape(mCalibObjects.mFastTransformMShape.get());
+          // copy buffer as-is — no updateCalibration, VDrift already embedded
+          std::vector<char> buf(oldCalibObjects.mFastTransformHelper->getCorrMap()->size());
+          std::memcpy(buf.data(), oldCalibObjects.mFastTransformHelper->getCorrMap(), buf.size());
+          mCalibObjects.mFastTransformHelper->setCorrMap(std::move(buf));
           mCalibObjects.mFastTransformHelper->acknowledgeUpdate();
+          newCalibObjects.fastTransform = mCalibObjects.mFastTransformHelper->getCorrMap();
           newCalibObjects.fastTransformHelper = mCalibObjects.mFastTransformHelper.get();
-        }
-        mustUpdate = true;
-        mTPCVDriftHelper->acknowledgeUpdate();
-        mCalibObjects.mFastTransformHelper->acknowledgeUpdate();
+          mustUpdate = true;
+      }
+      if (mTPCVDriftHelper->isUpdated()) {
+          // VDrift updated but no new map — just acknowledge, map already has correct VDrift
+          LOGP(info, "VDrift updated (factor {} wrt reference {} from source {}) but map already up to date", mTPCVDriftHelper->getVDriftObject().corrFact, mTPCVDriftHelper->getVDriftObject().refVDrift, mTPCVDriftHelper->getSourceName());
+          mTPCVDriftHelper->acknowledgeUpdate();
       }
     }
 
@@ -450,6 +418,7 @@ void GPURecoWorkflowSpec::doTrackTuneTPC(GPUTrackingInOutPointers& ptrs, char* b
     o2::tpc::TrackTPC* tpcTracks = reinterpret_cast<o2::tpc::TrackTPC*>(buffout);
     float scale = mCalibObjects.mFastTransformHelper->getInstLumiCTP();
     if (scale < 0.f) {
+      LOGP(warning, "Negative scale factor for TPC covariance correction, setting it to zero");
       scale = 0.f;
     }
     auto diagInner = trackTune.getCovInnerTotal(scale);
diff --git a/GPU/Workflow/src/O2GPUDPLDisplay.cxx b/GPU/Workflow/src/O2GPUDPLDisplay.cxx
index ed0d522b4d7ea..7cfe83a5f5dde 100644
--- a/GPU/Workflow/src/O2GPUDPLDisplay.cxx
+++ b/GPU/Workflow/src/O2GPUDPLDisplay.cxx
@@ -68,15 +68,12 @@ void O2GPUDPLDisplaySpec::init(InitContext& ic)
   mConfParam.reset(new GPUSettingsO2(mConfig->ReadConfigurableParam()));
 
   mFastTransformHelper.reset(new o2::tpc::CorrectionMapsLoader());
-  mFastTransform = std::move(TPCFastTransformHelperO2::instance()->create(0));
-  mFastTransformRef = std::move(TPCFastTransformHelperO2::instance()->create(0));
-  mFastTransformMShape = std::move(TPCFastTransformHelperO2::instance()->create(0));
-  mFastTransformHelper->setCorrMap(mFastTransform.get());
-  mFastTransformHelper->setCorrMapRef(mFastTransformRef.get());
-  mFastTransformHelper->setCorrMapMShape(mFastTransformMShape.get());
+
+  std::vector<char> buffer;
+  gpu::TPCFastTransformPOD::create(buffer, *TPCFastTransformHelperO2::instance()->create(0));
+  mFastTransformHelper->setCorrMap(std::move(buffer));
+
   mConfig->configCalib.fastTransform = mFastTransformHelper->getCorrMap();
-  mConfig->configCalib.fastTransformRef = mFastTransformHelper->getCorrMapRef();
-  mConfig->configCalib.fastTransformMShape = mFastTransformHelper->getCorrMapMShape();
   mConfig->configCalib.fastTransformHelper = mFastTransformHelper.get();
 
   mTrdGeo.reset(new o2::trd::GeometryFlat());
diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index 13e28a1c341b3..f12c8fa78e763 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -28,7 +28,6 @@
 #include "Algorithm/RangeTokenizer.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 #include <unordered_map>
@@ -54,7 +53,6 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   std::vector<ConfigParamSpec> options{
     {"input-type", VariantType::String, "digits", {"digits, zsraw, zsonthefly, clusters, compressed-clusters-root, compressed-clusters-flat, trd-tracklets, its-clusters, its-mean-vertex"}},
     {"output-type", VariantType::String, "tracks", {"cluster, tracks, compressed-clusters-root, compressed-clusters-flat, qa, error-qa, no-shared-cluster-map, send-clusters-per-sector, trd-tracks, tpc-triggers, its-tracks"}},
-    {"corrmap-lumi-mode", VariantType::Int, 0, {"scaling mode: (default) 0 = static + scale * full; 1 = full + scale * derivative"}},
     {"disable-root-input", VariantType::Bool, true, {"disable root-files input reader"}},
     {"disable-mc", VariantType::Bool, false, {"disable sending of MC information"}},
     {"ignore-dist-stf", VariantType::Bool, false, {"do not subscribe to FLP/DISTSUBTIMEFRAME/0 message (no lost TF recovery)"}},
@@ -65,7 +63,6 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"tpc-mc-time-gain", VariantType::Bool, false, {"use time gain calibration for MC (true) or for data (false)"}},
     {"filtered-output-specs", VariantType::Bool, false, {"use filtered output specs for output DataDescriptions"}},
   };
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   std::swap(workflowOptions, options);
@@ -147,7 +144,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 
   auto inputType = cfgc.options().get<std::string>("input-type");
   bool doMC = !cfgc.options().get<bool>("disable-mc");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(cfgc.options());
   o2::conf::ConfigurableParam::updateFromFile(cfgc.options().get<std::string>("configFile"));
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
   o2::conf::ConfigurableParam::writeINI("o2gpurecoworkflow_configuration.ini");
@@ -166,10 +162,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 
   GPURecoWorkflowSpec::Config cfg;
   cfg.runTPCTracking = true;
-  cfg.lumiScaleType = sclOpt.lumiType;
-  cfg.lumiScaleMode = sclOpt.lumiMode;
-  cfg.enableMShape = sclOpt.enableMShapeCorrection;
-  cfg.enableCTPLumi = sclOpt.requestCTPLumi;
   cfg.decompressTPCFromROOT = isEnabled(inputTypes, ioType::CompClustROOT);
   cfg.decompressTPC = isEnabled(inputTypes, ioType::CompClustFlat) || cfg.decompressTPCFromROOT;
   cfg.zsDecoder = isEnabled(inputTypes, ioType::ZSRaw);
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 52407cc3a4073..3c5cb2286c0f2 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -323,17 +323,18 @@ local IGNOREIDC=1
 local CTPLUMY_DISABLED=0
 while [[ $# -gt 0 ]]; do
   case "$1" in
-    --lumi-type=*) TPC_CORR_OPT+=" --lumi-type ${1#*=}"; [[ ${1#*=} == "2" ]] && { NEED_TPC_SCALERS_WF=1; IGNOREIDC=0; }; shift 1;;
-    --lumi-type) TPC_CORR_OPT+=" --lumi-type ${2}"; [[ ${2} == "2" ]] && { NEED_TPC_SCALERS_WF=1; IGNOREIDC=0; }; shift 2;;
-    --enable-M-shape-correction) TPC_CORR_OPT+=" --enable-M-shape-correction"; NEED_TPC_SCALERS_WF=1; TPC_SCALERS_CONF+=" --enable-M-shape-correction" ; shift 1;;
+    --lumi-type=*) TPC_CORR_OPT+=" --lumi-type ${1#*=}"; [[ ${1#*=} == "2" ]] && { IGNOREIDC=0; }; shift 1;;
+    --lumi-type) TPC_CORR_OPT+=" --lumi-type ${2}"; [[ ${2} == "2" ]] && { IGNOREIDC=0; }; shift 2;;
+    --enable-M-shape-correction) TPC_CORR_OPT+=" --enable-M-shape-correction"; TPC_SCALERS_CONF+=" --enable-M-shape-correction" ; shift 1;;
     --corrmap-lumi-mode=*) TPC_CORR_OPT+=" --corrmap-lumi-mode ${1#*=}"; shift 1;;
     --corrmap-lumi-mode) TPC_CORR_OPT+=" --corrmap-lumi-mode ${2}"; shift 2;;
     --disable-ctp-lumi-request) TPC_CORR_OPT+=" --disable-ctp-lumi-request"; CTPLUMY_DISABLED=1; shift 1;;
     *) TPC_CORR_KEY+="$1;"; shift 1;;
   esac
 done
-[[ ${NEED_TPC_SCALERS_WF:-} == 1 ]] && [[ $IGNOREIDC == 1 ]] && TPC_SCALERS_CONF+=" --disable-IDC-scalers"
+[[ $IGNOREIDC == 1 ]] && TPC_SCALERS_CONF+=" --disable-IDC-scalers"
 ! has_detector CTP && [[ ${CTPLUMY_DISABLED:-} != 1 ]] && TPC_CORR_OPT+=" --disable-ctp-lumi-request"
+TPC_SCALERS_CONF+=" ${TPC_CORR_OPT}"
 }
 
 if has_detector TPC; then
@@ -542,12 +543,6 @@ if [[ -z ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS} ]] && [[ -z ${WORKFLOW_D
   [[ -z "$DISABLE_ROOT_OUTPUT" ]] || [[ -n $ROOT_OUTPUT_ASKED ]] && add_W o2-tfidinfo-writer-workflow
 fi
 
-# if TPC correction with IDC from CCDB was requested
-has_detector TPC && [[ ${NEED_TPC_SCALERS_WF:-} == 1 ]] && add_W o2-tpc-scaler-workflow " ${TPC_SCALERS_CONF:-} "
-
-# if ITS+TPC GPU: pass ITS CKVs to the GPU WF
-has_detectors_gpu TPC ITS && GPU_CONFIG_KEY+=$ITS_CONFIG_KEY
-
 # ---------------------------------------------------------------------------------------------------------------------
 # Raw decoder workflows - disabled in async mode
 if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
@@ -577,6 +572,11 @@ if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
   has_detector EMC && ! has_detector_from_global_reader EMC && ! has_detector_flp_processing EMC && add_W o2-emcal-reco-workflow "--input-type raw --output-type cells ${RAW_EMC_SUBSPEC:-} $EMCRAW2C_CONFIG --disable-root-output $DISABLE_MC --pipeline $(get_N EMCALRawToCellConverterSpec EMC REST 1 EMCREC)"
 fi
 
+# if TPC correction with IDC from CCDB was requested
+has_detector TPC && add_W o2-tpc-scaler-workflow " ${TPC_SCALERS_CONF:-} " "$TPC_CORR_KEY"
+# if ITS+TPC GPU: pass ITS CKVs to the GPU WF
+has_detectors_gpu TPC ITS && GPU_CONFIG_KEY+=$ITS_CONFIG_KEY
+
 has_detector_gpu ITS && GPU_INPUT+=",its-clusters"
 if [[ $BEAMTYPE != "cosmic" && $SYNCMODE != 1 ]]; then
   has_detector_gpu ITS && GPU_INPUT+=",its-mean-vertex"
@@ -587,13 +587,13 @@ has_detector_gpu ITS && GPU_OUTPUT+=",its-tracks"
 # Common reconstruction workflows
 (has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "$ITS_CONFIG $ITS_STAGGERED $DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
 [[ ${DISABLE_DIGIT_CLUSTER_INPUT:-} =~ "--digits-from-upstream" ]]  && has_detector_gpu ITS && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--disable-tracking ${DISABLE_DIGIT_CLUSTER_INPUT:-} $ITS_STAGGERED $DISABLE_MC $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
-(has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $TPC_CORR_OPT $ITS_STAGGERED --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;$TPC_CORR_KEY"
+(has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $ITS_STAGGERED --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;"
 (has_detector_reco TOF || has_detector_ctf TOF) && ! has_detector_from_global_reader TOF && add_W o2-tof-reco-workflow "$TOF_CONFIG --input-type $TOF_INPUT --output-type $TOF_OUTPUT $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N tof-compressed-decoder TOF RAW 1),$(get_N TOFClusterer TOF REST 1)"
 has_detector_reco FT0 && ! has_detector_from_global_reader FT0 && add_W o2-ft0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N ft0-reconstructor FT0 REST 1)"
 has_detector_reco TRD && ! has_detector_from_global_reader TRD && add_W o2-trd-tracklet-transformer "--disable-irframe-reader $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_FILTER_CONFIG --pipeline $(get_N TRDTRACKLETTRANSFORMER TRD REST 1 TRDTRKTRANS)"
-has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $ITS_STAGGERED $SEND_ITSTPC_DTGL  $TPC_CORR_OPT --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
-has_detector_reco TRD && [[ -n "$TRD_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-global-tracking "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_CONFIG $TRD_FILTER_CONFIG $TPC_CORR_OPT --track-sources $TRD_SOURCES --pipeline $(get_N trd-globaltracking_TPC_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_CTP_ TRD REST 1 TRDTRK)" "$TRD_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY"
-has_detector_reco TOF && [[ -n "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TPC_CORR_OPT ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY;$INTERACTION_TAG_CONFIG_KEY"
+has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $ITS_STAGGERED $SEND_ITSTPC_DTGL --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;"
+has_detector_reco TRD && [[ -n "$TRD_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-global-tracking "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_CONFIG $TRD_FILTER_CONFIG --track-sources $TRD_SOURCES --pipeline $(get_N trd-globaltracking_TPC_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_CTP_ TRD REST 1 TRDTRK)" "$TRD_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;"
+has_detector_reco TOF && [[ -n "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$INTERACTION_TAG_CONFIG_KEY"
 has_detectors TPC && [[ -z "$DISABLE_ROOT_OUTPUT" && "${SKIP_TPC_CLUSTERSTRACKS_OUTPUT:-}" != 1 ]] && ! has_detector_from_global_reader TPC && add_W o2-tpc-reco-workflow "--input-type pass-through --output-type clusters,tpc-triggers,tracks,send-clusters-per-sector $DISABLE_MC"
 
 # ---------------------------------------------------------------------------------------------------------------------
@@ -652,7 +652,7 @@ if [[ $BEAMTYPE != "cosmic" ]] && has_detectors_reco ITS && has_detector_matchin
     : ${REDUCESV_OPT:=" --disable-cascade-finder --disable-3body-finder "}
     : ${REDUCESV_CONF:="svertexer.pidCutsPhoton[0]=-1;svertexer.pidCutsLambda[0]=-1;svertexer.pidCutsHTriton[0]=-1;svertexer.pidCutsHhydrog4[0]=-1;"}
   fi
-  [[ $GLOBAL_READER_NEEDS_SV != 1 ]] && add_W o2-secondary-vertexing-workflow "$DISABLE_MC $STRTRACKING $REDUCESV_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $TPC_CORR_OPT --vertexing-sources $SVERTEXING_SOURCES --threads $SVERTEX_THREADS --pipeline $(get_N secondary-vertexing MATCH REST $SVERTEX_THREADS SECVTX)" "$TPC_CORR_KEY;$REDUCESV_CONF"
+  [[ $GLOBAL_READER_NEEDS_SV != 1 ]] && add_W o2-secondary-vertexing-workflow "$DISABLE_MC $STRTRACKING $REDUCESV_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT --vertexing-sources $SVERTEXING_SOURCES --threads $SVERTEX_THREADS --pipeline $(get_N secondary-vertexing MATCH REST $SVERTEX_THREADS SECVTX)" "$REDUCESV_CONF"
   SECTVTX_ON="1"
 else
   SECTVTX_ON="0"

From db8279dcf77102bd422637ced45196cba9c0706b Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Thu, 2 Apr 2026 16:17:30 +0200
Subject: [PATCH 1588/1764] TPC: remove CorrectionMaps helper/loader classes

Replace CorrectionMapsLoader/Helper with their Full variants,
renaming CorrectionMapsLoaderFull -> CorrectionMapsLoader and
CorrectionMapsHelperFull -> CorrectionMapsHelper.
Use TPCFastTransformPOD directly without the intermediate helper class.
---
 .../Workflow/src/BarrelAlignmentSpec.cxx      |  19 +-
 .../src/barrel-alignment-workflow.cxx         |   5 +-
 Detectors/Align/include/Align/Controller.h    |   8 +-
 Detectors/Align/src/Controller.cxx            |   4 +-
 .../include/GlobalTracking/MatchCosmics.h     |  17 +-
 .../include/GlobalTracking/MatchHMP.h         |   1 -
 .../include/GlobalTracking/MatchTOF.h         |   7 +-
 .../include/GlobalTracking/MatchTPCITS.h      |   8 +-
 Detectors/GlobalTracking/src/MatchCosmics.cxx |   8 +-
 Detectors/GlobalTracking/src/MatchTOF.cxx     |   9 +-
 Detectors/GlobalTracking/src/MatchTPCITS.cxx  |   9 +-
 .../CosmicsMatchingSpec.h                     |   5 -
 .../SecondaryVertexingSpec.h                  |   4 -
 .../GlobalTrackingWorkflow/TOFMatcherSpec.h   |   4 -
 .../TPCITSMatchingSpec.h                      |   4 -
 .../src/CosmicsMatchingSpec.cxx               |  14 +-
 .../src/SecondaryVertexingSpec.cxx            |  17 +-
 .../src/TOFMatcherSpec.cxx                    |  19 +-
 .../src/TPCITSMatchingSpec.cxx                |  22 +-
 .../src/cosmics-match-workflow.cxx            |   6 +-
 .../src/secondary-vertexing-workflow.cxx      |   6 +-
 .../src/tof-matcher-workflow.cxx              |   6 +-
 .../src/tpcits-match-workflow.cxx             |   6 +-
 .../include/GlobalTrackingStudy/CheckResid.h  |   1 -
 .../GlobalTrackingStudy/TPCTrackStudy.h       |   5 -
 .../GlobalTrackingStudy/TrackMCStudy.h        |   1 -
 .../GlobalTrackingStudy/TrackingStudy.h       |   1 -
 .../study/src/TPCTrackStudy.cxx               |  21 +-
 .../study/src/TrackMCStudy.cxx                |  40 ++-
 .../study/src/TrackingStudy.cxx               |  22 +-
 .../study/src/check-resid-workflow.cxx        |   5 +-
 .../study/src/tpc-track-study-workflow.cxx    |   6 +-
 .../study/src/trackMCStudy-workflow.cxx       |   6 +-
 .../study/src/tracking-study-workflow.cxx     |   6 +-
 Detectors/TPC/calibration/CMakeLists.txt      |   8 +-
 .../include/TPCCalibration/CalculatedEdx.h    |  12 +-
 .../TPCCalibration/CalibPadGainTracks.h       |   9 +-
 .../TPCCalibration/CorrectionMapsLoader.h     |  22 +-
 .../TPCCalibration/CorrectionMapsLoaderFull.h |  64 -----
 .../TPCCalibration/CorrectionMapsOptions.h    |  56 ++++
 .../include/TPCCalibration/TrackDump.h        |   7 +-
 .../TPC/calibration/src/CalculatedEdx.cxx     |   5 +-
 .../calibration/src/CalibPadGainTracks.cxx    |   8 +-
 .../calibration/src/CorrectionMapsLoader.cxx  | 262 ++++++++++++++----
 .../src/CorrectionMapsLoaderFull.cxx          | 253 -----------------
 .../calibration/src/CorrectionMapsOptions.cxx |  63 +++++
 Detectors/TPC/calibration/src/TrackDump.cxx   |  17 +-
 .../reconstruction/test/testGPUCATracking.cxx |   6 +-
 .../include/TPCWorkflow/RecoWorkflow.h        |  22 +-
 .../TPCWorkflow/TPCCalibPadGainTracksSpec.h   |  41 ++-
 .../include/TPCWorkflow/TPCRefitter.h         |   5 -
 .../include/TPCWorkflow/TPCScalerSpec.h       |   2 +-
 Detectors/TPC/workflow/src/RecoWorkflow.cxx   |   2 +-
 Detectors/TPC/workflow/src/TPCRefitter.cxx    |  27 +-
 Detectors/TPC/workflow/src/TPCScalerSpec.cxx  |  12 +-
 .../workflow/src/tpc-calib-gainmap-tracks.cxx |   6 +-
 .../TPC/workflow/src/tpc-reco-workflow.cxx    |   6 +-
 .../workflow/src/tpc-refitter-workflow.cxx    |   6 +-
 Detectors/TPC/workflow/src/tpc-scaler.cxx     |   6 +-
 .../TRDWorkflow/TRDGlobalTrackingSpec.h       |   5 +-
 .../workflow/src/TRDGlobalTrackingSpec.cxx    |  21 +-
 .../workflow/src/trd-tracking-workflow.cxx    |   6 +-
 .../include/DetectorsVertexing/SVertexer.h    |   7 +-
 Detectors/Vertexing/src/SVertexer.cxx         |  10 +-
 .../Workflow/src/O2DPLDisplay.cxx             |   1 -
 .../Base/GPUReconstructionTimeframe.cxx       |   5 +-
 GPU/GPUTracking/DataTypes/GPUDataTypesIO.h    |   1 -
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  12 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |   7 +-
 .../Global/GPUChainTrackingGetters.inc        |   2 +-
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  12 -
 .../Interface/GPUO2InterfaceRefit.cxx         |  10 +-
 .../Interface/GPUO2InterfaceRefit.h           |   6 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  12 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |   4 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |   7 +-
 .../Merger/GPUTPCGMSectorTrack.cxx            |   6 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx |  25 +-
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |   8 +-
 GPU/GPUTracking/Refit/GPUTrackingRefit.h      |   6 +-
 .../SectorTracker/GPUTPCTrackingData.cxx      |   2 +-
 .../GPUTPCTrackletConstructor.cxx             |  12 +-
 .../Standalone/Benchmark/standalone.cxx       |   7 +-
 .../TPCConvert/GPUTPCConvertImpl.h            |   5 +-
 .../display/render/GPUDisplayDraw.cxx         |   6 +-
 .../display/render/GPUDisplayImportEvent.cxx  |   6 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  |  15 +-
 GPU/TPCFastTransformation/CMakeLists.txt      |   2 +-
 .../CorrectionMapsHelper.cxx                  |  62 +++--
 .../CorrectionMapsHelper.h                    | 174 +++++++-----
 .../CorrectionMapsHelperFull.cxx              |  60 ----
 .../CorrectionMapsHelperFull.h                | 161 -----------
 .../CorrectionMapsTypes.h                     |  48 ++++
 GPU/TPCFastTransformation/Spline2DSpec.h      |  14 +-
 .../TPCFastTransformPOD.h                     |  21 +-
 .../TPCFastTransformationLinkDef_O2.h         |   1 -
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |   7 +-
 .../include/GPUWorkflow/O2GPUDPLDisplay.h     |   9 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |  11 +-
 GPU/Workflow/src/GPUWorkflowTPC.cxx           |  47 ++--
 GPU/Workflow/src/O2GPUDPLDisplay.cxx          |  13 +-
 macro/runTPCRefit.C                           |   9 +-
 102 files changed, 907 insertions(+), 1207 deletions(-)
 delete mode 100644 Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoaderFull.h
 create mode 100644 Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsOptions.h
 delete mode 100644 Detectors/TPC/calibration/src/CorrectionMapsLoaderFull.cxx
 create mode 100644 Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
 delete mode 100644 GPU/TPCFastTransformation/CorrectionMapsHelperFull.cxx
 delete mode 100644 GPU/TPCFastTransformation/CorrectionMapsHelperFull.h
 create mode 100644 GPU/TPCFastTransformation/CorrectionMapsTypes.h

diff --git a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
index dc952b26e52f0..3e42c19f535f8 100644
--- a/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
+++ b/Detectors/Align/Workflow/src/BarrelAlignmentSpec.cxx
@@ -36,7 +36,7 @@
 #include "TRDBase/TrackletTransformer.h"
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 #include "GPUO2ExternalUser.h"
 #include "GPUO2InterfaceUtils.h"
 #include "GPUParam.h"
@@ -117,7 +117,8 @@ class BarrelAlignmentSpec : public Task
   std::unique_ptr<o2::gpu::GPUParam> mTPCParam;
 
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{};
 
   //
   TStopwatch mTimer;
@@ -264,13 +265,10 @@ void BarrelAlignmentSpec::updateTimeDependentParams(ProcessingContext& pc)
     }
 
     mTPCVDriftHelper.extractCCDBInputs(pc);
-    mTPCCorrMapsLoader.extractCCDBInputs(pc);
-    bool updateMaps = false;
-    if (mTPCCorrMapsLoader.isUpdated()) {
-      mTPCCorrMapsLoader.acknowledgeUpdate();
-      updateMaps = true;
-    }
-    // mController->setTPCCorrMaps(&mTPCCorrMapsLoader);
+
+    auto const& raw = pc.inputs().get<const char*>("corrMap");
+    mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
+    mController->setTPCCorrMaps(mTPCCorrMaps);
     if (mTPCVDriftHelper.isUpdated()) {
       LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
            mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
@@ -278,7 +276,6 @@ void BarrelAlignmentSpec::updateTimeDependentParams(ProcessingContext& pc)
            mTPCVDriftHelper.getSourceName());
       mController->setTPCVDrift(mTPCVDriftHelper.getVDriftObject());
       mTPCVDriftHelper.acknowledgeUpdate();
-      updateMaps = true;
     }
   }
 }
@@ -385,7 +382,7 @@ DataProcessorSpec getBarrelAlignmentSpec(GTrackID::mask_t srcMP, GTrackID::mask_
     }
     if (src[DetID::TPC] && !skipDetClusters[DetID::TPC]) {
       o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-      o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
+      dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
       loadTPCCalib = true;
     }
   }
diff --git a/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx b/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
index 03fc414113114..07224702b1be1 100644
--- a/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
+++ b/Detectors/Align/Workflow/src/barrel-alignment-workflow.cxx
@@ -27,6 +27,7 @@
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "GlobalTrackingWorkflowReaders/TrackTPCITSReaderSpec.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 
 #include "Algorithm/RangeTokenizer.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
@@ -60,7 +61,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"postprocessing", VariantType::Int, 0, {"postprocessing bits: 1 - extract alignment objects, 2 - check constraints, 4 - print mpParams/Constraints, 8 - relabel pede results"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -103,7 +104,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   if (dets[DetID::TPC]) {
     loadTPCClusters = loadTPCTracks = true;
   }
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   if (!postprocess) { // this part is needed only if the data should be read
     if (GID::includesDet(DetID::ITS, src)) {
       src |= GID::getSourceMask(GID::ITS);
diff --git a/Detectors/Align/include/Align/Controller.h b/Detectors/Align/include/Align/Controller.h
index 90abf2025d1c3..a9c4eac734535 100644
--- a/Detectors/Align/include/Align/Controller.h
+++ b/Detectors/Align/include/Align/Controller.h
@@ -30,7 +30,7 @@
 #include "ReconstructionDataFormats/PrimaryVertex.h"
 #include "ReconstructionDataFormats/TrackCosmics.h"
 #include "DataFormatsTPC/VDriftCorrFact.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 
 #include "Align/Millepede2Record.h"
 #include "Align/ResidualsController.h"
@@ -272,8 +272,8 @@ class Controller final : public TObject
   bool getAllowAfterburnerTracks() const { return mAllowAfterburnerTracks; }
 
   void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
-  void setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph);
-  o2::gpu::CorrectionMapsHelper* getTPCCorrMaps() { return mTPCCorrMapsHelper; }
+  void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph);
+  const o2::gpu::TPCFastTransformPOD* getTPCCorrMaps() { return mTPCCorrMaps; }
   const o2::tpc::VDriftCorrFact& getTPCVDrift() const { return mTPCDrift; }
 
   int getInstanceID() const { return mInstanceID; }
@@ -359,7 +359,7 @@ class Controller final : public TObject
   bool mUseRecoOCDB = true; // flag to preload reco-time calib objects
 
   o2::tpc::VDriftCorrFact mTPCDrift{};
-  o2::gpu::CorrectionMapsHelper* mTPCCorrMapsHelper = nullptr;
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr;
 
   //
   static const int sSkipLayers[kNLrSkip];          // detector layers for which we don't need module matrices
diff --git a/Detectors/Align/src/Controller.cxx b/Detectors/Align/src/Controller.cxx
index 5cfbbf9f3a4ae..5f55d07893d33 100644
--- a/Detectors/Align/src/Controller.cxx
+++ b/Detectors/Align/src/Controller.cxx
@@ -1882,9 +1882,9 @@ void Controller::setTPCVDrift(const o2::tpc::VDriftCorrFact& v)
 }
 
 //______________________________________________
-void Controller::setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph)
+void Controller::setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph)
 {
-  mTPCCorrMapsHelper = maph;
+  mTPCCorrMaps = maph;
 }
 
 } // namespace align
diff --git a/Detectors/GlobalTracking/include/GlobalTracking/MatchCosmics.h b/Detectors/GlobalTracking/include/GlobalTracking/MatchCosmics.h
index 7720d75590475..9aad1a820d08b 100644
--- a/Detectors/GlobalTracking/include/GlobalTracking/MatchCosmics.h
+++ b/Detectors/GlobalTracking/include/GlobalTracking/MatchCosmics.h
@@ -26,7 +26,6 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "GlobalTracking/MatchCosmicsParams.h"
 #include "CommonUtils/TreeStreamRedirector.h"
-#include "TPCFastTransform.h"
 
 #define _ALLOW_DEBUG_TREES_COSM // to allow debug and control tree output
 
@@ -38,7 +37,7 @@ class VDriftCorrFact;
 }
 namespace gpu
 {
-class CorrectionMapsHelper;
+class TPCFastTransformPOD;
 }
 namespace globaltracking
 {
@@ -85,7 +84,7 @@ class MatchCosmics
     GTrackID origID;        ///< track origin id
     int matchID = MinusOne; ///< entry (none if MinusOne) of its match in the vector of matches
   };
-  void setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph);
+  void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph);
   void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
   void setITSROFrameLengthMUS(float fums) { mITSROFrameLengthMUS = fums; }
   void setITSDict(const o2::itsmft::TopologyDictionary* dict) { mITSDict = dict; }
@@ -138,14 +137,14 @@ class MatchCosmics
   std::vector<MatchRecord> mRecords;
   std::vector<int> mWinners;
   const o2::itsmft::TopologyDictionary* mITSDict = nullptr; // cluster patterns dictionary
-  o2::gpu::CorrectionMapsHelper* mTPCCorrMapsHelper = nullptr;
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr;
   int mTFCount = 0;
-  float mTPCVDriftRef = -1.; ///< TPC nominal drift speed in cm/microseconds
-  float mTPCVDriftCorrFact = 1.; ///< TPC nominal correction factort (wrt ref)
-  float mTPCVDrift = -1.;    ///< TPC drift speed in cm/microseconds
+  float mTPCVDriftRef = -1.;      ///< TPC nominal drift speed in cm/microseconds
+  float mTPCVDriftCorrFact = 1.;  ///< TPC nominal correction factort (wrt ref)
+  float mTPCVDrift = -1.;         ///< TPC drift speed in cm/microseconds
   float mTPCDriftTimeOffset = 0.; ///< drift time offset in mus
-  float mTPCTBinMUS = 0.; ///< TPC time bin duration in microseconds
-  float mBz = 0;          ///< nominal Bz
+  float mTPCTBinMUS = 0.;         ///< TPC time bin duration in microseconds
+  float mBz = 0;                  ///< nominal Bz
   bool mFieldON = true;
   bool mUseMC = true;
   float mITSROFrameLengthMUS = 0.;
diff --git a/Detectors/GlobalTracking/include/GlobalTracking/MatchHMP.h b/Detectors/GlobalTracking/include/GlobalTracking/MatchHMP.h
index fbbadc1820ee8..308ba9e61f794 100644
--- a/Detectors/GlobalTracking/include/GlobalTracking/MatchHMP.h
+++ b/Detectors/GlobalTracking/include/GlobalTracking/MatchHMP.h
@@ -41,7 +41,6 @@
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTRD/TrackTRD.h"
 #include "ReconstructionDataFormats/PID.h"
-#include "TPCFastTransform.h"
 #include "CommonDataFormat/InteractionRecord.h"
 #include "ReconstructionDataFormats/MatchInfoHMP.h"
 #include "ReconstructionDataFormats/TrackHMP.h"
diff --git a/Detectors/GlobalTracking/include/GlobalTracking/MatchTOF.h b/Detectors/GlobalTracking/include/GlobalTracking/MatchTOF.h
index b66e5b143a898..8447fbc42cdce 100644
--- a/Detectors/GlobalTracking/include/GlobalTracking/MatchTOF.h
+++ b/Detectors/GlobalTracking/include/GlobalTracking/MatchTOF.h
@@ -37,9 +37,7 @@
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTRD/TrackTRD.h"
 #include "ReconstructionDataFormats/PID.h"
-#include "TPCFastTransform.h"
 #include "CommonDataFormat/InteractionRecord.h"
-#include "CorrectionMapsHelper.h"
 #include "GlobalTracking/MatchTOFParams.h"
 
 // from FIT
@@ -152,7 +150,7 @@ class MatchTOF
   std::vector<o2::MCCompLabel>& getMatchedTOFLabelsVector(trkType index) { return mOutTOFLabels[index]; } ///< get vector of TOF labels of matched tracks
 
   void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
-  void setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph);
+  void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph, float lumi);
 
   void setFIT(bool value = true) { mIsFIT = value; }
   static int findFITIndex(int bc, const gsl::span<const o2::ft0::RecPoints>& FITRecPoints, unsigned long firstOrbit);
@@ -292,7 +290,8 @@ class MatchTOF
   gsl::span<const unsigned int> mTPCRefitterOccMap;                   ///< externally set TPC clusters occupancy map
   const o2::tpc::ClusterNativeAccess* mTPCClusterIdxStruct = nullptr; ///< struct holding the TPC cluster indices
 
-  o2::gpu::CorrectionMapsHelper* mTPCCorrMapsHelper = nullptr;        ///< TPC cluster transformation
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr; ///< TPC cluster transformation
+  float mCTPLumi = {-1};
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter;         ///< TPC refitter used for TPC tracks refit during the reconstruction
 
   const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mTOFClusLabels; ///< input TOF clusters MC labels (pointer to read from tree)
diff --git a/Detectors/GlobalTracking/include/GlobalTracking/MatchTPCITS.h b/Detectors/GlobalTracking/include/GlobalTracking/MatchTPCITS.h
index 00f2fc157a5ec..e736f0c9c8a42 100644
--- a/Detectors/GlobalTracking/include/GlobalTracking/MatchTPCITS.h
+++ b/Detectors/GlobalTracking/include/GlobalTracking/MatchTPCITS.h
@@ -48,14 +48,13 @@
 #include "DataFormatsTPC/ClusterNativeHelper.h"
 #include "DataFormatsTPC/VDriftCorrFact.h"
 #include "ITSReconstruction/RecoGeomHelper.h"
-#include "TPCFastTransform.h"
 #include "GPUO2InterfaceRefit.h"
 #include "GPUTPCGeometry.h"
 #include "GlobalTracking/MatchTPCITSParams.h"
 #include "DataFormatsITSMFT/TopologyDictionary.h"
 #include "DataFormatsITSMFT/TrkClusRef.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 #if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__ROOTCLING__) && !defined(__CLING__)
 #include "MemoryResources/MemoryResources.h"
 #endif
@@ -434,7 +433,7 @@ class MatchTPCITS
     mVDriftCalibOn = v;
   }
   void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
-  void setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph);
+  void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph, float lumi);
 
   ///< print settings
   void print() const;
@@ -641,7 +640,8 @@ class MatchTPCITS
   float mMinITSTrackPtInv = 999.; ///< cutoff on ITS track inverse pT
   bool mVDriftCalibOn = false;    ///< flag to produce VDrift calibration data
   o2::tpc::VDriftCorrFact mTPCDrift{};
-  o2::gpu::CorrectionMapsHelper* mTPCCorrMapsHelper = nullptr;
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr;
+  float mLumiCTP{-1};
 
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter; ///< TPC refitter used for TPC tracks refit during the reconstruction
 
diff --git a/Detectors/GlobalTracking/src/MatchCosmics.cxx b/Detectors/GlobalTracking/src/MatchCosmics.cxx
index 3c20ecad2f36c..615cfcb84819b 100644
--- a/Detectors/GlobalTracking/src/MatchCosmics.cxx
+++ b/Detectors/GlobalTracking/src/MatchCosmics.cxx
@@ -32,7 +32,7 @@
 #include "CommonConstants/GeomConstants.h"
 #include "DataFormatsTPC/WorkflowHelper.h"
 #include "DataFormatsTPC/VDriftCorrFact.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 #include <algorithm>
 #include <numeric>
 
@@ -93,7 +93,7 @@ void MatchCosmics::refitWinners(const o2::globaltracking::RecoContainer& data)
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> tpcRefitter;
   if (data.inputsTPCclusters) {
     tpcRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(&data.inputsTPCclusters->clusterIndex,
-                                                                 mTPCCorrMapsHelper, mBz,
+                                                                 mTPCCorrMaps, mBz,
                                                                  tpcClusRefs.data(), 0, tpcClusShMap.data(),
                                                                  tpcClusOccMap.data(), tpcClusOccMap.size(), nullptr, o2::base::Propagator::Instance());
   }
@@ -597,9 +597,9 @@ void MatchCosmics::setTPCVDrift(const o2::tpc::VDriftCorrFact& v)
 }
 
 //______________________________________________
-void MatchCosmics::setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph)
+void MatchCosmics::setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph)
 {
-  mTPCCorrMapsHelper = maph;
+  mTPCCorrMaps = maph;
 }
 
 #endif
diff --git a/Detectors/GlobalTracking/src/MatchTOF.cxx b/Detectors/GlobalTracking/src/MatchTOF.cxx
index ad050309fe030..5416a612ad1f3 100644
--- a/Detectors/GlobalTracking/src/MatchTOF.cxx
+++ b/Detectors/GlobalTracking/src/MatchTOF.cxx
@@ -255,9 +255,10 @@ void MatchTOF::setTPCVDrift(const o2::tpc::VDriftCorrFact& v)
 }
 
 //______________________________________________
-void MatchTOF::setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph)
+void MatchTOF::setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph, float lumi)
 {
-  mTPCCorrMapsHelper = maph;
+  mTPCCorrMaps = maph;
+  mCTPLumi = lumi;
 }
 
 //______________________________________________
@@ -2085,7 +2086,7 @@ void MatchTOF::updateTimeDependentParams()
   mMaxInvPt = std::abs(mBz) > 0.1 ? 1. / (std::abs(mBz) * 0.05) : 999.;
 
   const auto& trackTune = TrackTuneParams::Instance();
-  float scale = mTPCCorrMapsHelper->getInstLumiCTP();
+  float scale = mCTPLumi;
   if (scale < 0.f) {
     LOGP(warning, "Negative scale factor for TPC covariance correction, setting it to zero");
     scale = 0.f;
@@ -2167,7 +2168,7 @@ bool MatchTOF::makeConstrainedTPCTrack(int matchedID, o2::dataformats::TrackTPCT
 void MatchTOF::checkRefitter()
 {
   if (mTPCClusterIdxStruct) {
-    mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMapsHelper, mBz,
+    mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMaps, mBz,
                                                                   mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(),
                                                                   mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
   }
diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index 9b69397e1f9f6..29c45edd6eb96 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -205,9 +205,10 @@ void MatchTPCITS::setTPCVDrift(const o2::tpc::VDriftCorrFact& v)
 }
 
 //______________________________________________
-void MatchTPCITS::setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph)
+void MatchTPCITS::setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph, float lumi)
 {
-  mTPCCorrMapsHelper = maph;
+  mTPCCorrMaps = maph;
+  mLumiCTP = lumi;
 }
 
 //______________________________________________
@@ -286,7 +287,7 @@ void MatchTPCITS::updateTimeDependentParams()
   mTPCmeanX0Inv = matbd.meanX2X0 / matbd.length;
 
   const auto& trackTune = TrackTuneParams::Instance();
-  float scale = mTPCCorrMapsHelper->getInstLumiCTP();
+  float scale = mLumiCTP;
   if (scale < 0.f) {
     LOGP(warning, "Negative scale factor for TPC covariance correction, setting it to zero");
     scale = 0.f;
@@ -505,7 +506,7 @@ bool MatchTPCITS::prepareTPCData()
     mTPCSectIndexCache[sec].reserve(100 + 1.2 * ntrW / o2::constants::math::NSectors);
   }
 
-  mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMapsHelper, mBz, mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
+  mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMaps, mBz, mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
   mNTPCOccBinLength = mTPCRefitter->getParam()->rec.tpc.occupancyMapTimeBins;
   mTBinClOcc.clear();
   if (mNTPCOccBinLength > 1 && mTPCRefitterOccMap.size()) {
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h
index 0633bb6a64a22..25553c5d56d33 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/CosmicsMatchingSpec.h
@@ -20,11 +20,6 @@ using namespace o2::framework;
 
 namespace o2
 {
-namespace tpc
-{
-struct CorrectionMapsLoaderGloOpts;
-}
-
 namespace globaltracking
 {
 
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h
index 9de5f158a0608..9211a9cb0c264 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/SecondaryVertexingSpec.h
@@ -20,10 +20,6 @@
 
 namespace o2
 {
-namespace tpc
-{
-struct CorrectionMapsLoaderGloOpts;
-}
 
 namespace vertexing
 {
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
index afc70f688a0b5..6fd0bcac902d2 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
@@ -21,10 +21,6 @@ using namespace o2::framework;
 
 namespace o2
 {
-namespace tpc
-{
-struct CorrectionMapsLoaderGloOpts;
-}
 namespace globaltracking
 {
 
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
index 4f4f13cde72b1..d4f26283416e6 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
@@ -20,10 +20,6 @@ using namespace o2::framework;
 
 namespace o2
 {
-namespace tpc
-{
-struct CorrectionMapsLoaderGloOpts;
-}
 namespace globaltracking
 {
 /// create a processor spec
diff --git a/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
index cf148d47b3d10..095ede4f6581d 100644
--- a/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/CosmicsMatchingSpec.cxx
@@ -47,7 +47,7 @@
 #include "ITSMFTReconstruction/ClustererParam.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 
 using namespace o2::framework;
 using MCLabelsTr = gsl::span<const o2::MCCompLabel>;
@@ -74,7 +74,7 @@ class CosmicsMatchingSpec : public Task
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mCorrMap{nullptr};
   o2::globaltracking::MatchCosmics mMatching; // matching engine
   bool mUseMC = true;
   TStopwatch mTimer;
@@ -109,7 +109,8 @@ void CosmicsMatchingSpec::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   mTPCVDriftHelper.extractCCDBInputs(pc);
-  mTPCCorrMapsLoader.extractCCDBInputs(pc);
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  mCorrMap = &gpu::TPCFastTransformPOD::get(raw);
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
@@ -126,10 +127,7 @@ void CosmicsMatchingSpec::updateTimeDependentParams(ProcessingContext& pc)
     }
     mMatching.init();
   }
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-  }
-  mMatching.setTPCCorrMaps(&mTPCCorrMapsLoader);
+  mMatching.setTPCCorrMaps(mCorrMap);
   if (mTPCVDriftHelper.isUpdated()) {
     LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
          mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
@@ -188,7 +186,7 @@ DataProcessorSpec getCosmicsMatchingSpec(GTrackID::mask_t src, bool useMC)
                                                               dataRequest->inputs,
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
 
   return DataProcessorSpec{
     "cosmics-matcher",
diff --git a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
index fb9fc328175ea..afce2861be2fb 100644
--- a/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/SecondaryVertexingSpec.cxx
@@ -31,10 +31,9 @@
 #include "DetectorsBase/GlobalParams.h"
 #include "TStopwatch.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/DeviceSpec.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 
 using namespace o2::framework;
 
@@ -70,7 +69,7 @@ class SecondaryVertexingSpec : public Task
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{nullptr};
   GTrackID::mask_t mSrc{};
   bool mEnableCCDBParams = false;
   bool mEnableCascades = false;
@@ -180,7 +179,8 @@ void SecondaryVertexingSpec::updateTimeDependentParams(ProcessingContext& pc)
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   if (mSrc[GTrackID::TPC]) {
     mTPCVDriftHelper.extractCCDBInputs(pc);
-    mTPCCorrMapsLoader.extractCCDBInputs(pc);
+    auto const& raw = pc.inputs().get<const char*>("corrMap");
+    mTPCCorrMaps = &gpu::TPCFastTransformPOD::get(raw);
   }
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
@@ -210,12 +210,7 @@ void SecondaryVertexingSpec::updateTimeDependentParams(ProcessingContext& pc)
   }
   // we may have other params which need to be queried regularly
   if (mSrc[GTrackID::TPC]) {
-    bool updateMaps = false;
-    if (mTPCCorrMapsLoader.isUpdated()) {
-      mTPCCorrMapsLoader.acknowledgeUpdate();
-      updateMaps = true;
-    }
-    mVertexer.setTPCCorrMaps(&mTPCCorrMapsLoader);
+    mVertexer.setTPCCorrMaps(mTPCCorrMaps);
 
     if (mTPCVDriftHelper.isUpdated()) {
       LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
@@ -281,7 +276,7 @@ DataProcessorSpec getSecondaryVertexingSpec(GTrackID::mask_t src, bool enableCas
   }
   if (src[GTrackID::TPC]) {
     o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-    o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
+    dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
   }
   outputs.emplace_back("GLO", "V0S_IDX", 0, Lifetime::Timeframe);     // found V0s indices
   outputs.emplace_back("GLO", "V0S", 0, Lifetime::Timeframe);         // found V0s
diff --git a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
index ede3026647b1e..6440d75360a2f 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
@@ -24,7 +24,7 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/DeviceSpec.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 
 // from Tracks
 #include "ReconstructionDataFormats/GlobalTrackID.h"
@@ -71,7 +71,7 @@ class TOFMatcherSpec : public Task
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr;
   bool mUseMC = true;
   bool mUseFIT = false;
   bool mDoTPCRefit = false;
@@ -100,7 +100,9 @@ void TOFMatcherSpec::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   mTPCVDriftHelper.extractCCDBInputs(pc);
-  mTPCCorrMapsLoader.extractCCDBInputs(pc);
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
+  float lumiCTP = pc.inputs().get<float>("lumiCTP");
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     const auto bcs = o2::base::GRPGeomHelper::instance().getGRPLHCIF()->getBunchFilling().getFilledBCs();
@@ -110,12 +112,8 @@ void TOFMatcherSpec::updateTimeDependentParams(ProcessingContext& pc)
     initOnceDone = true;
     // put here init-once stuff
   }
-  // we may have other params which need to be queried regularly
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-  }
-  mMatcher.setTPCCorrMaps(&mTPCCorrMapsLoader);
-    if (mTPCVDriftHelper.isUpdated()) {
+  mMatcher.setTPCCorrMaps(mTPCCorrMaps, lumiCTP);
+  if (mTPCVDriftHelper.isUpdated()) {
     LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
          mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
          mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
@@ -258,7 +256,8 @@ DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bo
                                                               dataRequest->inputs,
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
+  dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
   std::vector<OutputSpec> outputs;
   if (GID::includesSource(GID::TPC, src)) {
     outputs.emplace_back(o2::header::gDataOriginTOF, "MTC_TPC", ss, Lifetime::Timeframe);
diff --git a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
index 38b6d6c1efb6e..5b3132c1c3282 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
@@ -50,7 +50,7 @@
 #include "ITSMFTReconstruction/ClustererParam.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 
 #ifdef ENABLE_UPGRADES
 #include "ITS3Reconstruction/TopologyDictionary.h"
@@ -83,7 +83,7 @@ class TPCITSMatchingDPL : public Task
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{};
   o2::globaltracking::MatchTPCITS mMatching; // matching engine
   bool mUseFT0 = false;
   bool mCalibMode = false;
@@ -184,7 +184,10 @@ void TPCITSMatchingDPL::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   mTPCVDriftHelper.extractCCDBInputs(pc);
-  mTPCCorrMapsLoader.extractCCDBInputs(pc);
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
+  float lumiCTP = pc.inputs().get<float>("lumiCTP");
+
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
@@ -218,13 +221,8 @@ void TPCITSMatchingDPL::updateTimeDependentParams(ProcessingContext& pc)
       LOGP(fatal, "USEMatCorrTGeo cannot work w/o  full geometry request in the GRPGeomHelper");
     }
   }
-  // we may have other params which need to be queried regularly
-  bool updateMaps = false;
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  mMatching.setTPCCorrMaps(&mTPCCorrMapsLoader);
+
+  mMatching.setTPCCorrMaps(mTPCCorrMaps, lumiCTP);
 
   if (mTPCVDriftHelper.isUpdated()) {
     LOGP(info, "Updating TPC VDrift: corrFact {} wrt refVDrift {} and DriftTimeOffset correction {} wrt {} from source {}",
@@ -292,8 +290,8 @@ DataProcessorSpec getTPCITSMatchingSpec(GTrackID::mask_t src, bool useFT0, bool
     {"debug-tree-flags", VariantType::Int, 0, {"DebugFlagTypes bit-pattern for debug tree"}}};
 
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
-
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
+  dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
   return DataProcessorSpec{
     "itstpc-track-matcher",
     dataRequest->inputs,
diff --git a/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
index db0e4253a7a51..14812ac25cce1 100644
--- a/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/cosmics-match-workflow.cxx
@@ -31,8 +31,8 @@
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 
 using namespace o2::framework;
 using DetID = o2::detectors::DetID;
@@ -54,7 +54,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of sources to use"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -85,7 +85,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
   // write the configuration used for the workflow
   o2::conf::ConfigurableParam::writeINI("o2match-cosmics-workflow_configuration.ini");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   auto disableRootOut = configcontext.options().get<bool>("disable-root-output");
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
index 6d10fa786b0c9..e630a8dad72dd 100644
--- a/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/secondary-vertexing-workflow.cxx
@@ -29,8 +29,8 @@
 #include "Framework/ConfigParamSpec.h"
 #include "Framework/CompletionPolicyHelpers.h"
 #include "DetectorsBase/DPLWorkflowUtils.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -64,7 +64,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}},
     {"combine-source-devices", o2::framework::VariantType::Bool, false, {"merge DPL source devices"}}};
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -88,7 +88,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto enable3body = !configcontext.options().get<bool>("disable-3body-finder");
   auto enableStrTr = !configcontext.options().get<bool>("disable-strangeness-tracker");
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   GID::mask_t src = allowedSources & GID::getSourcesMask(configcontext.options().get<std::string>("vertexing-sources"));
   GID::mask_t dummy, srcClus = GID::includesDet(DetID::TOF, src) ? GID::getSourceMask(GID::TOF) : dummy; // eventually, TPC clusters will be needed for refit
   if (enableStrTr) {
diff --git a/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
index 27adab7d50439..31d2fbbd4fc35 100644
--- a/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
@@ -32,7 +32,7 @@
 #include "Steer/MCKinematicsReader.h"
 #include "TSystem.h"
 #include "DetectorsBase/DPLWorkflowUtils.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 
 using namespace o2::framework;
@@ -70,7 +70,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"write-matchable", o2::framework::VariantType::Bool, false, {"write all matchable pairs in a file (o2matchable_tof.root)"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}},
     {"combine-devices", o2::framework::VariantType::Bool, false, {"merge DPL source/writer devices"}}};
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -97,7 +97,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto diagnostic = configcontext.options().get<bool>("enable-dia");
   auto extratolerancetrd = configcontext.options().get<float>("trd-extra-tolerance");
   auto writeMatchable = configcontext.options().get<bool>("write-matchable");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   bool writematching = 0;
   bool writecalib = 0;
   bool refitTPCTOF = configcontext.options().get<bool>("refit-tpc-tof");
diff --git a/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
index 0168c3076261e..77a6de82139ab 100644
--- a/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
@@ -24,8 +24,8 @@
 #include "Framework/CallbacksPolicy.h"
 #include "Framework/ConfigContext.h"
 #include "Framework/CompletionPolicyHelpers.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -48,7 +48,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight ITS part"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -79,7 +79,7 @@ WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& configcont
   GID::mask_t src = alowedSources & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
   bool needStrictTRDTOF = (src & GID::getSourcesMask("TPC-TRD,TPC-TOF,TPC-TRD-TOF")).any();
   auto doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext); // RS at the moment is not passed to the matching w-flow
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
   auto useFT0 = configcontext.options().get<bool>("use-ft0");
   if (useFT0) {
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h
index a78fa5e8d41da..baba1a1d4d765 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h
@@ -15,7 +15,6 @@
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "Framework/Task.h"
 #include "Framework/DataProcessorSpec.h"
-// #include "TPCCalibration/CorrectionMapsLoader.h"
 
 namespace o2::checkresid
 {
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCTrackStudy.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCTrackStudy.h
index 8f95203b52ffd..f6396f682ac3b 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCTrackStudy.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TPCTrackStudy.h
@@ -19,11 +19,6 @@
 #include "MathUtils/detail/Bracket.h"
 #include "DataFormatsTPC/ClusterNative.h"
 
-namespace o2::tpc
-{
-struct CorrectionMapsLoaderGloOpts;
-}
-
 namespace o2::trackstudy
 {
 /// create a processor spec
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudy.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudy.h
index 2fc21c6d7cd1c..18ce3dbf8ab87 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudy.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackMCStudy.h
@@ -15,7 +15,6 @@
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 
 namespace o2::trackstudy
 {
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackingStudy.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackingStudy.h
index caa50dc1d481a..b3a55416f4818 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackingStudy.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/TrackingStudy.h
@@ -18,7 +18,6 @@
 #include "ReconstructionDataFormats/Track.h"
 #include "MathUtils/detail/Bracket.h"
 #include "DataFormatsTPC/ClusterNative.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 
 namespace o2::trackstudy
 {
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
index 072993edfec4a..f9ba67319e18a 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TPCTrackStudy.cxx
@@ -14,7 +14,7 @@
 #include "DataFormatsGlobalTracking/RecoContainer.h"
 #include "DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DetectorsBase/Propagator.h"
 #include "DetectorsBase/GeometryManager.h"
@@ -64,7 +64,7 @@ class TPCTrackStudySpec final : public Task
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{nullptr};
   bool mUseMC{false}; ///< MC flag
   bool mUseGPUModel{false};
   float mXRef = 0.;
@@ -133,18 +133,13 @@ void TPCTrackStudySpec::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   mTPCVDriftHelper.extractCCDBInputs(pc);
-  mTPCCorrMapsLoader.extractCCDBInputs(pc);
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
     // none at the moment
   }
-  // we may have other params which need to be queried regularly
-  bool updateMaps = false;
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateMaps = true;
-  }
 }
 
 void TPCTrackStudySpec::process(o2::globaltracking::RecoContainer& recoData)
@@ -170,7 +165,7 @@ void TPCTrackStudySpec::process(o2::globaltracking::RecoContainer& recoData)
   }
   if (mTPCTracksArray.size()) {
     LOGP(info, "Found {} TPC tracks", mTPCTracksArray.size());
-    mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, &mTPCCorrMapsLoader, prop->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
+    mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMaps, prop->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
   }
   float vdriftTB = mTPCVDriftHelper.getVDriftObject().getVDrift() * o2::tpc::ParameterElectronics::Instance().ZbinWidth; // VDrift expressed in cm/TimeBin
   float tpcTBBias = mTPCVDriftHelper.getVDriftObject().getTimeOffset() / (8 * o2::constants::lhc::LHCBunchSpacingMUS);
@@ -179,7 +174,7 @@ void TPCTrackStudySpec::process(o2::globaltracking::RecoContainer& recoData)
 
   auto dumpClusters = [this] {
     static int tf = 0;
-    const auto* corrMap = this->mTPCCorrMapsLoader.getCorrMap();
+    const auto* corrMap = this->mTPCCorrMaps;
     for (int sector = 0; sector < 36; sector++) {
       float alp = ((sector % 18) * 20 + 10) * TMath::DegToRad();
       float sn = TMath::Sin(alp), cs = TMath::Cos(alp);
@@ -256,7 +251,7 @@ void TPCTrackStudySpec::process(o2::globaltracking::RecoContainer& recoData)
         clSector.push_back(sector);
         clRow.push_back(row);
         float x, y, z;
-        mTPCCorrMapsLoader.Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, t); // nominal time of the track
+        mTPCCorrMaps->Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, t); // nominal time of the track
         clX.push_back(x);
         clY.push_back(y);
         clZ.push_back(z);
@@ -425,7 +420,7 @@ DataProcessorSpec getTPCTrackStudySpec(GTrackID::mask_t srcTracks, GTrackID::mas
                                                               dataRequest->inputs,
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
 
   return DataProcessorSpec{
     "tpc-track-study",
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
index 01d127c6511bd..9637c72589196 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackMCStudy.cxx
@@ -17,7 +17,6 @@
 #include "ReconstructionDataFormats/TrackTPCITS.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "ITSMFTReconstruction/ChipMappingITS.h"
 #include "ITStracking/IOUtils.h"
 #include "DetectorsBase/Propagator.h"
@@ -57,6 +56,7 @@
 #include "GPUParam.h"
 #include "GPUParam.inc"
 #include "MathUtils/fit.h"
+#include "TPCFastTransformPOD.h"
 #include <TRandom.h>
 #include <map>
 #include <unordered_map>
@@ -112,21 +112,21 @@ class TrackMCStudy final : public Task
   const std::vector<o2::MCTrack>* mCurrMCTracks = nullptr;
   TVector3 mCurrMCVertex;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{nullptr};
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
-  std::vector<float> mTBinClOcc; ///< TPC occupancy histo: i-th entry is the integrated occupancy for ~1 orbit starting from the TB = i*mNTPCOccBinLength
-  std::vector<float> mTBinClOccHist; //< original occupancy
-  std::vector<long> mIntBC;      ///< interaction global BC wrt TF start
-  std::vector<float> mTPCOcc;    ///< TPC occupancy for this interaction time
-  std::vector<int> mITSOcc;      //< N ITS clusters in the ROF containing collision
+  std::vector<float> mTBinClOcc;                            ///< TPC occupancy histo: i-th entry is the integrated occupancy for ~1 orbit starting from the TB = i*mNTPCOccBinLength
+  std::vector<float> mTBinClOccHist;                        //< original occupancy
+  std::vector<long> mIntBC;                                 ///< interaction global BC wrt TF start
+  std::vector<float> mTPCOcc;                               ///< TPC occupancy for this interaction time
+  std::vector<int> mITSOcc;                                 //< N ITS clusters in the ROF containing collision
   std::vector<o2::BaseCluster<float>> mITSClustersArray;    ///< ITS clusters created in run() method from compact clusters
   const o2::itsmft::TopologyDictionary* mITSDict = nullptr; ///< cluster patterns dictionary
 
-  bool mCheckSV = false;         //< check SV binding (apart from prongs availability)
-  bool mRecProcStage = false;    //< flag that the MC particle was added only at the stage of reco tracks processing
-  int mNTPCOccBinLength = 0;     ///< TPC occ. histo bin length in TBs
+  bool mCheckSV = false;      //< check SV binding (apart from prongs availability)
+  bool mRecProcStage = false; //< flag that the MC particle was added only at the stage of reco tracks processing
+  int mNTPCOccBinLength = 0;  ///< TPC occ. histo bin length in TBs
   float mNTPCOccBinLengthInv = -1.f;
   int mVerbose = 0;
   float mITSTimeBiasMUS = 0.f;
@@ -196,12 +196,8 @@ void TrackMCStudy::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   mTPCVDriftHelper.extractCCDBInputs(pc);
-  mTPCCorrMapsLoader.extractCCDBInputs(pc);
-  bool updateMaps = false;
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateMaps = true;
-  }
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
@@ -243,8 +239,8 @@ void TrackMCStudy::process(const o2::globaltracking::RecoContainer& recoData)
   auto vtxRefs = recoData.getPrimaryVertexMatchedTrackRefs(); // references from vertex to these track IDs
   auto prop = o2::base::Propagator::Instance();
   int nv = vtxRefs.size();
-  float vdriftTB = mTPCVDriftHelper.getVDriftObject().getVDrift() * o2::tpc::ParameterElectronics::Instance().ZbinWidth;                                                         // VDrift expressed in cm/TimeBin
-  float itsBias = 0.5 * mITSROFrameLengthMUS + o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC * o2::constants::lhc::LHCBunchSpacingMUS;       // ITS time is supplied in \mus as beginning of ROF
+  float vdriftTB = mTPCVDriftHelper.getVDriftObject().getVDrift() * o2::tpc::ParameterElectronics::Instance().ZbinWidth;                                                   // VDrift expressed in cm/TimeBin
+  float itsBias = 0.5 * mITSROFrameLengthMUS + o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance().roFrameBiasInBC * o2::constants::lhc::LHCBunchSpacingMUS; // ITS time is supplied in \mus as beginning of ROF
 
   prepareITSData(recoData);
   loadTPCOccMap(recoData);
@@ -854,7 +850,7 @@ void TrackMCStudy::fillMCClusterInfo(const o2::globaltracking::RecoContainer& re
               continue;
             }
             float xc, yc, zc;
-            mTPCCorrMapsLoader.Transform(sector, row, clus.getPad(), clus.getTime(), xc, yc, zc, mctr.bcInTF / 8.); // nominal time of the track
+            mTPCCorrMaps->Transform(sector, row, clus.getPad(), clus.getTime(), xc, yc, zc, mctr.bcInTF / 8.); // nominal time of the track
 
             const auto& entTRefIDs = entTRefIDsIt->second;
             // find bracketing TRef params
@@ -1066,7 +1062,7 @@ bool TrackMCStudy::processMCParticle(int src, int ev, int trid)
           break;
         }
       }
-      if (decay >= 0) {                                                                      // check if decay and kinematics is acceptable
+      if (decay >= 0) { // check if decay and kinematics is acceptable
         auto& decayPool = mDecaysMaps[decay];
         int idd0 = mcPart.getFirstDaughterTrackId(), idd1 = mcPart.getLastDaughterTrackId(); // we want only charged and trackable daughters
         int dtStart = mDecProdLblPool.size(), dtEnd = -1;
@@ -1244,7 +1240,7 @@ void TrackMCStudy::loadTPCOccMap(const o2::globaltracking::RecoContainer& recoDa
   auto NHBPerTF = o2::base::GRPGeomHelper::instance().getGRPECS()->getNHBFPerTF();
   const auto& TPCOccMap = recoData.occupancyMapTPC;
   auto prop = o2::base::Propagator::Instance();
-  auto TPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(&recoData.inputsTPCclusters->clusterIndex, &mTPCCorrMapsLoader, prop->getNominalBz(),
+  auto TPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(&recoData.inputsTPCclusters->clusterIndex, mTPCCorrMaps, prop->getNominalBz(),
                                                                     recoData.getTPCTracksClusterRefs().data(), 0, recoData.clusterShMapTPC.data(), TPCOccMap.data(), TPCOccMap.size(), nullptr, prop);
   mNTPCOccBinLength = TPCRefitter->getParam()->rec.tpc.occupancyMapTimeBins;
   mTBinClOcc.clear();
@@ -1370,7 +1366,7 @@ DataProcessorSpec getTrackMCStudySpec(GTrackID::mask_t srcTracks, GTrackID::mask
     dataRequest->requestSecondaryVertices(useMC);
   }
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
   auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
                                                               true,                              // GRPECS=true
                                                               true,                              // GRPLHCIF
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
index 042e884824274..881ce9041ae04 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/TrackingStudy.cxx
@@ -42,7 +42,6 @@
 #include "ReconstructionDataFormats/VtxTrackRef.h"
 #include "ReconstructionDataFormats/DCA.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "GPUO2InterfaceRefit.h"
 #include "GPUO2ExternalUser.h" // Needed for propper settings in GPUParam.h
 #include "GPUParam.h"
@@ -50,6 +49,7 @@
 #include "GPUTPCGeometry.h"
 #include "Steer/MCKinematicsReader.h"
 #include "MathUtils/fit.h"
+#include "TPCFastTransformPOD.h"
 #include <TF1.h>
 
 namespace o2::trackstudy
@@ -86,11 +86,11 @@ class TrackingStudySpec final : public Task
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{nullptr};
   bool mUseMC{false}; ///< MC flag
   std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
   std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOutVtx;
-  std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter; ///< TPC refitter used for TPC tracks refit during the reconstruction
+  std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter;                 ///< TPC refitter used for TPC tracks refit during the reconstruction
   std::vector<float> mMltHistTB, mTBinClOccAft, mTBinClOccBef, mTBinClOccWgh; ///< TPC occupancy histo: i-th entry is the integrated occupancy for ~1 orbit starting/preceding from the TB = i*mNTPCOccBinLength
   std::unique_ptr<TF1> mOccWghFun;
   float mITSROFrameLengthMUS = 0.f;
@@ -154,7 +154,7 @@ void TrackingStudySpec::run(ProcessingContext& pc)
   recoData.collectData(pc, *mDataRequest.get()); // select tracks of needed type, with minimal cuts, the real selected will be done in the vertexer
   updateTimeDependentParams(pc);                 // Make sure this is called after recoData.collectData, which may load some conditions
   if (recoData.inputsTPCclusters) {
-    mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(&recoData.inputsTPCclusters->clusterIndex, &mTPCCorrMapsLoader, o2::base::Propagator::Instance()->getNominalBz(),
+    mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(&recoData.inputsTPCclusters->clusterIndex, mTPCCorrMaps, o2::base::Propagator::Instance()->getNominalBz(),
                                                                   recoData.getTPCTracksClusterRefs().data(), 0, recoData.clusterShMapTPC.data(), recoData.occupancyMapTPC.data(),
                                                                   recoData.occupancyMapTPC.size(), nullptr, o2::base::Propagator::Instance());
     mNTPCOccBinLength = mTPCRefitter->getParam()->rec.tpc.occupancyMapTimeBins;
@@ -203,7 +203,8 @@ void TrackingStudySpec::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   mTPCVDriftHelper.extractCCDBInputs(pc);
-  mTPCCorrMapsLoader.extractCCDBInputs(pc);
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
@@ -221,11 +222,6 @@ void TrackingStudySpec::updateTimeDependentParams(ProcessingContext& pc)
     mTPCTBinMUS = elParam.ZbinWidth; // TPC bin in microseconds
     mTPCTBinMUSInv = 1. / mTPCTBinMUS;
   }
-  bool updateMaps = false;
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateMaps = true;
-  }
 }
 
 void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
@@ -279,9 +275,9 @@ void TrackingStudySpec::process(o2::globaltracking::RecoContainer& recoData)
       if (trExt.padFromEdge > npads / 2) {
         trExt.padFromEdge = npads - 1 - trExt.padFromEdge;
       }
-      this->mTPCCorrMapsLoader.Transform(clSect, clRow, clus.getPad(), clus.getTime(), trExt.innerTPCPos0[0], trExt.innerTPCPos0[1], trExt.innerTPCPos0[2], trc.getTime0()); // nominal time of the track
+      this->mTPCCorrMaps->Transform(clSect, clRow, clus.getPad(), clus.getTime(), trExt.innerTPCPos0[0], trExt.innerTPCPos0[1], trExt.innerTPCPos0[2], trc.getTime0()); // nominal time of the track
       if (timestampTB > -1e8) {
-        this->mTPCCorrMapsLoader.Transform(clSect, clRow, clus.getPad(), clus.getTime(), trExt.innerTPCPos[0], trExt.innerTPCPos[1], trExt.innerTPCPos[2], timestampTB); // time assigned from the global track track
+        this->mTPCCorrMaps->Transform(clSect, clRow, clus.getPad(), clus.getTime(), trExt.innerTPCPos[0], trExt.innerTPCPos[1], trExt.innerTPCPos[2], timestampTB); // time assigned from the global track track
       } else {
         trExt.innerTPCPos = trExt.innerTPCPos0;
       }
@@ -761,7 +757,7 @@ DataProcessorSpec getTrackingStudySpec(GTrackID::mask_t srcTracks, GTrackID::mas
     {"min-x-prop", VariantType::Float, 100.f, {"track should be propagated to this X at least"}},
   };
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
 
   return DataProcessorSpec{
     "track-study",
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
index fd4485585103c..86e4bb9ca234a 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
@@ -20,7 +20,7 @@
 #include "DetectorsBase/DPLWorkflowUtils.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
@@ -46,6 +46,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   //  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -63,7 +64,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
-  //  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   auto useMC = configcontext.options().get<bool>("enable-mc");
 
   GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/tpc-track-study-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/tpc-track-study-workflow.cxx
index 457ff034fa991..e255295d7665f 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/tpc-track-study-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/tpc-track-study-workflow.cxx
@@ -20,7 +20,7 @@
 #include "DetectorsBase/DPLWorkflowUtils.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 
 using namespace o2::framework;
@@ -43,7 +43,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"cluster-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of cluster sources to use"}},
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -62,7 +62,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
   auto useMC = !configcontext.options().get<bool>("disable-mc");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
   GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(configcontext.options().get<std::string>("cluster-sources"));
   if (sclOpt.requestCTPLumi) {
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
index 74add7dfebb51..50cc768bdc98d 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/trackMCStudy-workflow.cxx
@@ -19,7 +19,7 @@
 #include "Framework/CallbacksPolicy.h"
 #include "DetectorsBase/DPLWorkflowUtils.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
@@ -46,7 +46,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation, never use it"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -63,7 +63,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   if (!useMC) {
     throw std::runtime_error("MC cannot be disabled for this workflow");
   }
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   GID::mask_t allowedSourcesTrc = GID::getSourcesMask("ITS,TPC,ITS-TPC,TPC-TOF,TPC-TRD,ITS-TPC-TRD,TPC-TRD-TOF,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
   GID::mask_t allowedSourcesClus = GID::getSourcesMask("ITS,TPC");
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
index 932a21b6a902e..fa69d9f2808e0 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/tracking-study-workflow.cxx
@@ -20,7 +20,7 @@
 #include "DetectorsBase/DPLWorkflowUtils.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
@@ -45,7 +45,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -63,7 +63,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   auto useMC = !configcontext.options().get<bool>("disable-mc");
 
   GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
diff --git a/Detectors/TPC/calibration/CMakeLists.txt b/Detectors/TPC/calibration/CMakeLists.txt
index 905aa22e90e3b..675f15e89258b 100644
--- a/Detectors/TPC/calibration/CMakeLists.txt
+++ b/Detectors/TPC/calibration/CMakeLists.txt
@@ -48,7 +48,7 @@ o2_add_library(TPCCalibration
                        src/SACParameter.cxx
                        src/SACDrawHelper.cxx
                        src/VDriftHelper.cxx
-                       src/CorrectionMapsLoader.cxx
+                       src/CorrectionMapsOptions.cxx
                        src/SACCCDBHelper.cxx
                        src/TPCFastSpaceChargeCorrectionHelper.cxx
                        src/CalculatedEdx.cxx
@@ -59,7 +59,7 @@ o2_add_library(TPCCalibration
                        src/CorrectdEdxDistortions.cxx
                        src/PressureTemperatureHelper.cxx
                        src/CMVContainer.cxx
-                       src/CorrectionMapsLoaderFull.cxx
+                       src/CorrectionMapsLoader.cxx
                PUBLIC_LINK_LIBRARIES O2::DataFormatsTPC O2::TPCBaseRecSim
                                      O2::TPCReconstruction ROOT::Minuit
                                      Microsoft.GSL::GSL
@@ -118,8 +118,8 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/DigitAdd.h
                                   include/TPCCalibration/CorrectdEdxDistortions.h
                                   include/TPCCalibration/PressureTemperatureHelper.h
-                                  include/TPCCalibration/CMVContainer.h)
-                                  include/TPCCalibration/CorrectionMapsLoaderFull.h)
+                                  include/TPCCalibration/CMVContainer.h
+                                  include/TPCCalibration/CorrectionMapsLoader.h)
 
 o2_add_test_root_macro(macro/comparePedestalsAndNoise.C
                        PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CalculatedEdx.h b/Detectors/TPC/calibration/include/TPCCalibration/CalculatedEdx.h
index 3a744d2b1cfb4..d62eb8a1ab868 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CalculatedEdx.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CalculatedEdx.h
@@ -22,10 +22,9 @@
 #include "DataFormatsTPC/dEdxInfo.h"
 #include "GPUO2InterfaceRefit.h"
 #include "CalibdEdxContainer.h"
-#include "CorrectionMapsHelper.h"
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "TPCCalibration/CorrectdEdxDistortions.h"
-
+#include "TPCFastTransformPOD.h"
 #include <vector>
 
 namespace o2::tpc
@@ -225,10 +224,11 @@ class CalculatedEdx
   unsigned int getOccupancy(const o2::tpc::ClusterNative& cl) const;
 
  private:
-  std::vector<TrackTPC>* mTracks{nullptr};                       ///< vector containing the tpc tracks which will be processed
-  std::vector<TPCClRefElem>* mTPCTrackClIdxVecInput{nullptr};    ///< input vector with TPC tracks cluster indicies
-  const o2::tpc::ClusterNativeAccess* mClusterIndex{nullptr};    ///< needed to access clusternative with tpctracks
-  o2::gpu::CorrectionMapsHelper mTPCCorrMapsHelper;              ///< cluster correction maps helper
+  std::vector<TrackTPC>* mTracks{nullptr};                    ///< vector containing the tpc tracks which will be processed
+  std::vector<TPCClRefElem>* mTPCTrackClIdxVecInput{nullptr}; ///< input vector with TPC tracks cluster indicies
+  const o2::tpc::ClusterNativeAccess* mClusterIndex{nullptr}; ///< needed to access clusternative with tpctracks
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMap{nullptr};   ///< cluster correction maps helper
+  std::vector<char> mTPCCorrMapBuffer;
   std::vector<unsigned char> mTPCRefitterShMap;                  ///< externally set TPC clusters sharing map
   std::vector<unsigned int> mTPCRefitterOccMap;                  ///< externally set TPC clusters occupancy map
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mRefit{nullptr}; ///< TPC refitter used for TPC tracks refit during the reconstruction
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CalibPadGainTracks.h b/Detectors/TPC/calibration/include/TPCCalibration/CalibPadGainTracks.h
index b3fd532c06b8e..f8c7a4e1894b1 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CalibPadGainTracks.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CalibPadGainTracks.h
@@ -22,7 +22,6 @@
 #include "TPCBase/CalDet.h"
 #include "TPCCalibration/CalibPadGainTracksBase.h"
 #include "CalibdEdxTrackTopologyPol.h"
-#include "TPCFastTransform.h"
 
 #include <vector>
 #include <gsl/span>
@@ -36,8 +35,8 @@ namespace o2
 namespace gpu
 {
 class GPUO2InterfaceRefit;
-class CorrectionMapsHelper;
-}
+class TPCFastTransformPOD;
+} // namespace gpu
 
 namespace tpc
 {
@@ -214,7 +213,7 @@ class CalibPadGainTracks : public CalibPadGainTracksBase
   void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
 
   /// set cluster correction maps helper
-  void setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph);
+  void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph);
 
  private:
   gsl::span<const TrackTPC>* mTracks{nullptr};                                        ///<! vector containing the tpc tracks which will be processed. Cant be const due to the propagate function
@@ -239,7 +238,7 @@ class CalibPadGainTracks : public CalibPadGainTracksBase
   bool mPropagateTrack{false};                                                        ///< propagating the track instead of performing a refit
   bool mDoNotNormCharge{false};                                                       ///< do not normalize the cluster charge to the dE/dx
   ChargeType mChargeType{ChargeType::Max};                                            ///< charge type which is used for calculating the dE/dx and filling the pad-by-pad histograms
-  o2::gpu::CorrectionMapsHelper* mTPCCorrMapsHelper = nullptr;                        ///< cluster corrections map helper
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr;                         ///< cluster corrections map helper
   std::vector<std::vector<float>> mDEdxBuffer{};                                      ///<! memory for dE/dx
   std::vector<std::tuple<unsigned char, unsigned char, unsigned char, float>> mClTrk; ///<! memory for cluster informations
   std::vector<float> mDedxTmp{};                                                      ///<! memory for dE/dx calculation
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
index 5524c1ed1f59c..32a61225fe82f 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoader.h
@@ -11,24 +11,24 @@
 
 /// \file CorrectionMapsLoader.h
 /// \brief Helper class to access load maps from CCDB
-/// \author ruben.shahoian@cern.ch
+/// \author matthias.kleiner@cern.ch
 
 #ifndef TPC_CORRECTION_MAPS_LOADER_H_
 #define TPC_CORRECTION_MAPS_LOADER_H_
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <memory>
 #include <vector>
-#endif
 #include "CorrectionMapsHelper.h"
+#include "CorrectionMapsTypes.h"
 
 namespace o2
 {
 namespace framework
 {
 class ProcessingContext;
+class ConcreteDataMatcher;
 class InputSpec;
 class ConfigParamSpec;
+class InitContext;
 } // namespace framework
 
 namespace tpc
@@ -41,18 +41,20 @@ class CorrectionMapsLoader : public o2::gpu::CorrectionMapsHelper
   ~CorrectionMapsLoader() = default;
   CorrectionMapsLoader(const CorrectionMapsLoader&) = delete;
 
-#ifndef GPUCA_GPUCODE_DEVICE
-  void extractCCDBInputs(o2::framework::ProcessingContext& pc);
+  bool accountCCDBInputs(const o2::framework::ConcreteDataMatcher& matcher, void* obj);
+  void extractCCDBInputs(o2::framework::ProcessingContext& pc, float tpcScaler = -1.f);
+  void init(o2::framework::InitContext& ic, bool idcsAvailable);
+  void checkMeanScaleConsistency(float meanLumi, float threshold) const;
 
-  static void requestInputs(std::vector<o2::framework::InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options);
-  // static CorrectionMapsLoaderGloOpts parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts);
-  static void addGlobalOptions(std::vector<o2::framework::ConfigParamSpec>& options);
+  static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, const o2::tpc::CorrectionMapsGloOpts& gloOpts);
 
  protected:
   static void addOption(std::vector<o2::framework::ConfigParamSpec>& options, o2::framework::ConfigParamSpec&& osp);
   static void addInput(std::vector<o2::framework::InputSpec>& inputs, o2::framework::InputSpec&& isp);
+
+  float mInstLumiCTPFactor = 1.0;      // multiplicative factor for inst. lumi
+  int mLumiCTPSource = 0;              // 0: main, 1: alternative CTP lumi source
   bool mIDC2CTPFallbackActive = false; // flag indicating that fallback from IDC to CTP scaling is active
-#endif
 };
 
 } // namespace tpc
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoaderFull.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoaderFull.h
deleted file mode 100644
index e60fa874c6d9f..0000000000000
--- a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsLoaderFull.h
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file CorrectionMapsLoaderFull.h
-/// \brief Helper class to access load maps from CCDB
-/// \author matthias.kleiner@cern.ch
-
-#ifndef TPC_CORRECTION_MAPS_LOADERFULL_H_
-#define TPC_CORRECTION_MAPS_LOADERFULL_H_
-
-#include <vector>
-#include "CorrectionMapsHelperFull.h"
-#include "CorrectionMapsHelper.h"
-
-namespace o2
-{
-namespace framework
-{
-class ProcessingContext;
-class ConcreteDataMatcher;
-class InputSpec;
-class ConfigParamSpec;
-class InitContext;
-} // namespace framework
-
-namespace tpc
-{
-
-class CorrectionMapsLoaderFull : public o2::gpu::CorrectionMapsHelperFull
-{
- public:
-  CorrectionMapsLoaderFull() = default;
-  ~CorrectionMapsLoaderFull() = default;
-  CorrectionMapsLoaderFull(const CorrectionMapsLoaderFull&) = delete;
-
-  bool accountCCDBInputs(const o2::framework::ConcreteDataMatcher& matcher, void* obj);
-  void extractCCDBInputs(o2::framework::ProcessingContext& pc, float tpcScaler = -1.f);
-  void init(o2::framework::InitContext& ic, bool idcsAvailable);
-  void checkMeanScaleConsistency(float meanLumi, float threshold) const;
-
-  static void requestCCDBInputs(std::vector<o2::framework::InputSpec>& inputs, const o2::tpc::CorrectionMapsLoaderGloOpts& gloOpts);
-
- protected:
-  static void addOption(std::vector<o2::framework::ConfigParamSpec>& options, o2::framework::ConfigParamSpec&& osp);
-  static void addInput(std::vector<o2::framework::InputSpec>& inputs, o2::framework::InputSpec&& isp);
-
-  float mInstLumiCTPFactor = 1.0; // multiplicative factor for inst. lumi
-  int mLumiCTPSource = 0;         // 0: main, 1: alternative CTP lumi source
-  bool mIDC2CTPFallbackActive = false; // flag indicating that fallback from IDC to CTP scaling is active
-};
-
-} // namespace tpc
-
-} // namespace o2
-
-#endif
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsOptions.h b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsOptions.h
new file mode 100644
index 0000000000000..18bde0174a939
--- /dev/null
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CorrectionMapsOptions.h
@@ -0,0 +1,56 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CorrectionMapsOptions.h
+/// \brief Helper class to parse options for correction maps
+/// \author matthias.kleiner@cern.ch
+
+#ifndef TPC_CORRECTION_MAPS_OPTIONS_H_
+#define TPC_CORRECTION_MAPS_OPTIONS_H_
+
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <memory>
+#include <vector>
+#endif
+#include "CorrectionMapsTypes.h"
+
+namespace o2
+{
+namespace framework
+{
+class ConfigParamRegistry;
+class ConfigParamSpec;
+} // namespace framework
+
+namespace tpc
+{
+
+class CorrectionMapsOptions
+{
+ public:
+  CorrectionMapsOptions() = default;
+  ~CorrectionMapsOptions() = default;
+  CorrectionMapsOptions(const CorrectionMapsOptions&) = delete;
+
+#ifndef GPUCA_GPUCODE_DEVICE
+  static CorrectionMapsGloOpts parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts);
+  static void addGlobalOptions(std::vector<o2::framework::ConfigParamSpec>& options);
+
+ protected:
+  static void addOption(std::vector<o2::framework::ConfigParamSpec>& options, o2::framework::ConfigParamSpec&& osp);
+#endif
+};
+
+} // namespace tpc
+
+} // namespace o2
+
+#endif
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h b/Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h
index 34ad5b85a1eed..3f60b165e4167 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h
@@ -24,7 +24,7 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "DataFormatsTPC/Constants.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 
 /// \file TrackDump.h
 /// \author Jens Wiechula (Jens.Wiechula@ikf.uni-frankfurt.de)
@@ -77,14 +77,15 @@ class TrackDump
     float gyc(float vertexTime = 0) const;
     float zc(float vertexTime = 0) const;
 
-    static gpu::CorrectionMapsHelper sCorrHelper;
+    inline static std::vector<char> corrMapBuffer;                      // buffer for owning the correction map in case of update during runtime
+    inline static const o2::gpu::TPCFastTransformPOD* corrMap{nullptr}; // local copy of the correction map for quick access to the transform functions
     static void loadCorrMaps(std::string_view corrMapFile, std::string_view corrMapFileRef = "");
     ClassDefNV(ClusterNativeAdd, 1);
   };
 
   struct TrackInfo : public TrackTPC {
     TrackInfo() = default;
-    TrackInfo(const TrackTPC& track) : TrackTPC(track){};
+    TrackInfo(const TrackTPC& track) : TrackTPC(track) {};
     TrackInfo(const TrackInfo&) = default;
     ~TrackInfo() = default;
 
diff --git a/Detectors/TPC/calibration/src/CalculatedEdx.cxx b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
index c0f836e6b8452..bbf5b0ca93128 100644
--- a/Detectors/TPC/calibration/src/CalculatedEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
@@ -34,7 +34,8 @@ CalculatedEdx::CalculatedEdx()
 {
   std::vector<char> buffer;
   gpu::TPCFastTransformPOD::create(buffer, *TPCFastTransformHelperO2::instance()->create(0));
-  mTPCCorrMapsHelper.setCorrMap(std::move(buffer));
+  mTPCCorrMapBuffer = std::move(buffer);
+  mTPCCorrMap = &gpu::TPCFastTransformPOD::get(mTPCCorrMapBuffer.data());
 }
 
 void CalculatedEdx::setMembers(std::vector<o2::tpc::TPCClRefElem>* tpcTrackClIdxVecInput, const o2::tpc::ClusterNativeAccess& clIndex, std::vector<o2::tpc::TrackTPC>* vTPCTracksArrayInp)
@@ -51,7 +52,7 @@ void CalculatedEdx::setRefit(const unsigned int nHbfPerTf)
   mTPCRefitterOccMap.resize(sizeOcc);
   std::fill(mTPCRefitterOccMap.begin(), mTPCRefitterOccMap.end(), 0);
   o2::gpu::GPUO2InterfaceRefit::fillSharedClustersAndOccupancyMap(mClusterIndex, *mTracks, mTPCTrackClIdxVecInput->data(), mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), nHbfPerTf);
-  mRefit = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mClusterIndex, &mTPCCorrMapsHelper, mFieldNominalGPUBz, mTPCTrackClIdxVecInput->data(), nHbfPerTf, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size());
+  mRefit = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mClusterIndex, mTPCCorrMap, mFieldNominalGPUBz, mTPCTrackClIdxVecInput->data(), nHbfPerTf, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size());
 }
 
 void CalculatedEdx::fillMissingClusters(int missingClusters[4], float minChargeTot, float minChargeMax, int method, std::array<std::vector<float>, 5>& chargeTotROC, std::array<std::vector<float>, 5>& chargeMaxROC)
diff --git a/Detectors/TPC/calibration/src/CalibPadGainTracks.cxx b/Detectors/TPC/calibration/src/CalibPadGainTracks.cxx
index 094de6b830272..37400a28e4670 100644
--- a/Detectors/TPC/calibration/src/CalibPadGainTracks.cxx
+++ b/Detectors/TPC/calibration/src/CalibPadGainTracks.cxx
@@ -19,7 +19,7 @@
 #include "TPCBase/ROC.h"
 #include "TPCBase/Mapper.h"
 #include "TPCCalibration/IDCDrawHelper.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "GPUO2InterfaceRefit.h"
 #include "GPUO2ExternalUser.h"
@@ -37,7 +37,7 @@ void CalibPadGainTracks::processTracks(const int nMaxTracks)
 {
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> refit;
   if (!mPropagateTrack) {
-    refit = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mClusterIndex, mTPCCorrMapsHelper, mFieldNominalGPUBz, mTPCTrackClIdxVecInput->data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size());
+    refit = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mClusterIndex, mTPCCorrMaps, mFieldNominalGPUBz, mTPCTrackClIdxVecInput->data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size());
   }
 
   const size_t loopEnd = (nMaxTracks < 0) ? mTracks->size() : ((nMaxTracks > mTracks->size()) ? mTracks->size() : size_t(nMaxTracks));
@@ -407,7 +407,7 @@ void CalibPadGainTracks::setTPCVDrift(const o2::tpc::VDriftCorrFact& v)
 }
 
 //______________________________________________
-void CalibPadGainTracks::setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph)
+void CalibPadGainTracks::setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph)
 {
-  mTPCCorrMapsHelper = maph;
+  mTPCCorrMaps = maph;
 }
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index f20967f29b9f8..9569e0eb8abd2 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -10,43 +10,105 @@
 // or submit itself to any jurisdiction.
 
 #include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrMapParam.h"
+#include "TPCBaseRecSim/CDBTypes.h"
 #include "Framework/Logger.h"
 #include "Framework/ProcessingContext.h"
-#include "Framework/InputRecord.h"
+#include "Framework/CCDBParamSpec.h"
 #include "Framework/ConfigParamSpec.h"
-#include "TPCFastTransformPOD.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/InitContext.h"
+#include "Framework/DeviceSpec.h"
+#include "DataFormatsCTP/LumiInfo.h"
+
 using namespace o2::tpc;
 using namespace o2::framework;
 
-#ifndef GPUCA_GPUCODE_DEVICE
-
 //________________________________________________________
-void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc)
+void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc, float tpcScaler)
 {
-  const bool lumiValid = pc.inputs().isValid("lumiCTP");
-  if(lumiValid) {
-    mInstLumiCTP = pc.inputs().get<float>("lumiCTP");
+  pc.inputs().get<o2::tpc::CorrMapParam*>("tpcCorrPar");
+  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMap");
+  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapRef");
+  const int maxDumRep = 5;
+  int dumRep = 0;
+  o2::ctp::LumiInfo lumiObj;
+  static o2::ctp::LumiInfo lumiPrev;
+
+  if (getLumiScaleType() == LumiScaleType::TPCScaler || mIDC2CTPFallbackActive) {
+    // check if tpcScaler is valid and CTP fallback is allowed
+    if (tpcScaler == -1.f) {
+      const bool canUseCTPScaling = mCorrMap && mCorrMapRef && mCorrMap->isIDCSet() && mCorrMapRef->isIDCSet() && mCorrMap->isLumiSet() && mCorrMapRef->isLumiSet();
+      if (canUseCTPScaling) {
+        LOGP(info, "Invalid TPC scaler value {} received for IDC-based scaling! Using CTP fallback", tpcScaler);
+        mIDC2CTPFallbackActive = true;
+        setMeanLumi(mCorrMap->getLumi(), false);
+        setMeanLumiRef(mCorrMapRef->getLumi());
+        setLumiScaleType(LumiScaleType::CTPLumi);
+      } else if (mCorrMap) {
+        // CTP scaling is not possible, dont do any scaling to avoid applying wrong corrections
+        const float storedIDC = mCorrMap->getIDC();
+        LOGP(warning, "Invalid TPC scaler value {} received for IDC-based scaling! CTP fallback not possible, using stored IDC of {} from the map to avoid applying wrong corrections", tpcScaler, storedIDC);
+        setInstLumi(storedIDC);
+      }
+    } else {
+      if (mIDC2CTPFallbackActive) {
+        // reset back to normal operation
+        LOGP(info, "Valid TPC scaler value {} received, switching back to IDC-based scaling", tpcScaler);
+        mIDC2CTPFallbackActive = false;
+        setMeanLumi(mCorrMap->getIDC(), false);
+        setMeanLumiRef(mCorrMapRef->getIDC());
+        setLumiScaleType(LumiScaleType::TPCScaler);
+      }
+      // correct IDC received
+      setInstLumi(tpcScaler);
+    }
   }
 
-  const bool mapValid = pc.inputs().isValid("corrMap");
-  if(!mapValid) {
-    LOGP(info, "No correction map found in the input record!");
-    return;
+  if (getLumiCTPAvailable() && mInstCTPLumiOverride <= 0.) {
+    if (pc.inputs().get<gsl::span<char>>("CTPLumi").size() == sizeof(o2::ctp::LumiInfo)) {
+      lumiPrev = lumiObj = pc.inputs().get<o2::ctp::LumiInfo>("CTPLumi");
+    } else {
+      if (dumRep < maxDumRep && lumiPrev.nHBFCounted == 0 && lumiPrev.nHBFCountedFV0 == 0) {
+        LOGP(alarm, "Previous TF lumi used to substitute dummy input is empty, warning {} of {}", ++dumRep, maxDumRep);
+      }
+      lumiObj = lumiPrev;
+    }
+    setInstLumiCTP(mInstLumiCTPFactor * (mLumiCTPSource == 0 ? lumiObj.getLumi() : lumiObj.getLumiAlt()));
+    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+      setInstLumi(getInstLumiCTP());
+    }
   }
 
-  // get the raw buffer and reinterpret as TPCFastTransformPOD
-  auto const& raw = pc.inputs().get<const char*>("corrMap");
-  setCorrMap(&gpu::TPCFastTransformPOD::get(raw));
-  setUpdatedMap();
+  reportScaling();
 }
 
 //________________________________________________________
-void CorrectionMapsLoader::requestInputs(std::vector<InputSpec>& inputs, std::vector<o2::framework::ConfigParamSpec>& options)
+void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, const CorrectionMapsGloOpts& gloOpts)
 {
-    addInput(inputs, {"corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe});
-    addInput(inputs, {"lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe});
+  LOGP(info, "Requesting CCDB inputs for TPC correction maps with lumiType={} and lumiMode={}", static_cast<int>(gloOpts.lumiType), static_cast<int>(gloOpts.lumiMode));
+  if (gloOpts.lumiMode == LumiScaleMode::Linear) {
+    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});          // time-dependent
+    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
+  } else if (gloOpts.lumiMode == LumiScaleMode::DerivativeMap) {
+    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});            // time-dependent
+    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMap), {}, 1)}); // time-dependent
+  } else if (gloOpts.lumiMode == LumiScaleMode::DerivativeMapMC) {
+    // for MC corrections
+    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapMC), {}, 1)});            // time-dependent
+    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMapMC), {}, 1)}); // time-dependent
+  } else {
+    LOG(fatal) << "Correction mode unknown! Choose either 0 (default) or 1 (derivative map) for flag corrmap-lumi-mode.";
+  }
+
+  if (gloOpts.requestCTPLumi) {
+    addInput(inputs, {"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe});
+  }
+
+  addInput(inputs, {"tpcCorrPar", "TPC", "CorrMapParam", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CorrMapParam), {}, 0)}); // load once
 }
 
+//________________________________________________________
 void CorrectionMapsLoader::addInput(std::vector<InputSpec>& inputs, InputSpec&& isp)
 {
   if (std::find(inputs.begin(), inputs.end(), isp) == inputs.end()) {
@@ -54,40 +116,7 @@ void CorrectionMapsLoader::addInput(std::vector<InputSpec>& inputs, InputSpec&&
   }
 }
 
-// CorrectionMapsLoaderGloOpts CorrectionMapsLoader::parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts)
-// {
-//   CorrectionMapsLoaderGloOpts tpcopt;
-//   auto lumiTypeVal = opts.get<int>("lumi-type");
-//   if (lumiTypeVal < -1 || lumiTypeVal > 2) {
-//     LOGP(fatal, "Invalid lumi-type value: {}", lumiTypeVal);
-//   }
-//   tpcopt.lumiType = static_cast<LumiScaleType>(lumiTypeVal);
-
-//   auto lumiModeVal = opts.get<int>("corrmap-lumi-mode");
-//   if (lumiModeVal < -1 || lumiModeVal > 2) {
-//     LOGP(fatal, "Invalid corrmap-lumi-mode value: {}", lumiModeVal);
-//   }
-//   tpcopt.lumiMode = static_cast<LumiScaleMode>(lumiModeVal);
-
-//   tpcopt.enableMShapeCorrection = opts.get<bool>("enable-M-shape-correction");
-//   tpcopt.requestCTPLumi = !opts.get<bool>("disable-ctp-lumi-request");
-//   tpcopt.checkCTPIDCconsistency = !opts.get<bool>("disable-lumi-type-consistency-check");
-//   if (!tpcopt.requestCTPLumi && tpcopt.lumiType == LumiScaleType::CTPLumi) {
-//     LOGP(fatal, "Scaling with CTP Lumi is requested but this input is disabled");
-//   }
-//   return tpcopt;
-// }
-
-void CorrectionMapsLoader::addGlobalOptions(std::vector<ConfigParamSpec>& options)
-{
-  // these are options which should be added at the workflow level, since they modify the inputs of the devices
-  addOption(options, ConfigParamSpec{"lumi-type", o2::framework::VariantType::Int, 0, {"1 = use CTP lumi for TPC correction scaling, 2 = use TPC scalers for TPC correction scaling"}});
-  addOption(options, ConfigParamSpec{"corrmap-lumi-mode", o2::framework::VariantType::Int, 0, {"scaling mode: (default) 0 = static + scale * full; 1 = full + scale * derivative; 2 = full + scale * derivative (for MC)"}});
-  addOption(options, ConfigParamSpec{"enable-M-shape-correction", o2::framework::VariantType::Bool, false, {"Enable M-shape distortion correction"}});
-  addOption(options, ConfigParamSpec{"disable-ctp-lumi-request", o2::framework::VariantType::Bool, false, {"do not request CTP lumi (regardless what is used for corrections)"}});
-  addOption(options, ConfigParamSpec{"disable-lumi-type-consistency-check", o2::framework::VariantType::Bool, false, {"disable check of selected CTP or IDC scaling source being consistent with the map"}});
-}
-
+//________________________________________________________
 void CorrectionMapsLoader::addOption(std::vector<ConfigParamSpec>& options, ConfigParamSpec&& osp)
 {
   if (std::find(options.begin(), options.end(), osp) == options.end()) {
@@ -95,4 +124,129 @@ void CorrectionMapsLoader::addOption(std::vector<ConfigParamSpec>& options, Conf
   }
 }
 
-#endif // #ifndef GPUCA_GPUCODE_DEVICE
+//________________________________________________________
+bool CorrectionMapsLoader::accountCCDBInputs(const ConcreteDataMatcher& matcher, void* obj)
+{
+  if (matcher == ConcreteDataMatcher("TPC", "CorrMap", 0)) {
+    setCorrMap((o2::gpu::TPCFastTransform*)obj);
+    mCorrMap->rectifyAfterReadingFromFile();
+    mCorrMap->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
+    if (getMeanLumiOverride() != 0) {
+      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+        mCorrMap->setLumi(getMeanLumiOverride());
+        LOGP(info, "CorrMap mean lumi rate is overridden to {}", mCorrMap->getLumi());
+      } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+        mCorrMap->setIDC(getMeanLumiOverride());
+        LOGP(info, "CorrMap mean IDC rate is overridden to {}", mCorrMap->getIDC());
+      }
+    }
+    float mapMeanRate = 0;
+    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+      mapMeanRate = mCorrMap->getLumi();
+    } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+      mapMeanRate = mCorrMap->getIDC();
+    }
+    if (mCheckCTPIDCConsistency) {
+      checkMeanScaleConsistency(mapMeanRate, mCorrMap->getCTP2IDCFallBackThreshold());
+    }
+    if (getMeanLumiOverride() == 0 && mapMeanRate > 0.) {
+      setMeanLumi(mapMeanRate, false);
+    }
+    LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mapMeanRate, getMeanLumi());
+    setUpdatedMap();
+    return true;
+  }
+  if (matcher == ConcreteDataMatcher("TPC", "CorrMapRef", 0)) {
+    setCorrMapRef((o2::gpu::TPCFastTransform*)obj);
+    mCorrMapRef->rectifyAfterReadingFromFile();
+    mCorrMapRef->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
+    if (getMeanLumiRefOverride() != 0) {
+      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+        mCorrMapRef->setLumi(getMeanLumiRefOverride());
+        LOGP(info, "CorrMapRef mean lumi rate is overridden to {}", mCorrMapRef->getLumi());
+      } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+        mCorrMapRef->setIDC(getMeanLumiRefOverride());
+        LOGP(info, "CorrMapRef mean IDC rate is overridden to {}", mCorrMapRef->getIDC());
+      }
+    }
+    float mapRefMeanRate = 0;
+    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+      mapRefMeanRate = mCorrMapRef->getLumi();
+    } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+      mapRefMeanRate = mCorrMapRef->getIDC();
+    }
+    if (mCheckCTPIDCConsistency) {
+      checkMeanScaleConsistency(mapRefMeanRate, mCorrMapRef->getCTP2IDCFallBackThreshold());
+    }
+    if (getMeanLumiRefOverride() == 0) {
+      setMeanLumiRef(mapRefMeanRate);
+    }
+    LOGP(debug, "MeanLumiRefOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiRefOverride(), mapRefMeanRate, getMeanLumiRef());
+    setUpdatedMapRef();
+    return true;
+  }
+  if (matcher == ConcreteDataMatcher("TPC", "CorrMapParam", 0)) {
+    const auto& par = o2::tpc::CorrMapParam::Instance();
+    mMeanLumiOverride = par.lumiMean; // negative value switches off corrections !!!
+    mMeanLumiRefOverride = par.lumiMeanRef;
+    mInstCTPLumiOverride = par.lumiInst;
+    mInstLumiCTPFactor = par.lumiInstFactor;
+    mLumiCTPSource = par.ctpLumiSource;
+
+    if (mMeanLumiOverride != 0.) {
+      setMeanLumi(mMeanLumiOverride, false);
+    }
+    if (mMeanLumiRefOverride != 0.) {
+      setMeanLumiRef(mMeanLumiRefOverride);
+    }
+    if (mInstCTPLumiOverride != 0.) {
+      setInstLumiCTP(mInstCTPLumiOverride * mInstLumiCTPFactor);
+      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+        setInstLumi(getInstLumiCTP(), false);
+      }
+    }
+    setUpdatedLumi();
+    int scaleType = static_cast<int>(getLumiScaleType());
+    const std::array<std::string, 3> lumiS{"OFF", "CTP", "TPC scaler"};
+    if (scaleType >= lumiS.size()) {
+      LOGP(fatal, "Wrong corrmap-lumi-mode provided!");
+    }
+
+    LOGP(info, "TPC correction map params updated: SP corrections: {} (corr.map scaling type={}, override values: lumiMean={} lumiRefMean={} lumiScaleMode={}), CTP Lumi: source={} lumiInstOverride={} , LumiInst scale={} ",
+         canUseCorrections() ? "ON" : "OFF",
+         lumiS[scaleType], mMeanLumiOverride, mMeanLumiRefOverride, static_cast<int>(getLumiScaleMode()), mLumiCTPSource, mInstCTPLumiOverride, mInstLumiCTPFactor);
+  }
+  return false;
+}
+
+//________________________________________________________
+void CorrectionMapsLoader::init(o2::framework::InitContext& ic, bool idcsAvailable)
+{
+  if (getLumiScaleMode() == LumiScaleMode::Unset) {
+    LOGP(fatal, "TPC correction lumi scaling mode is not set");
+  }
+  const auto& inputRouts = ic.services().get<const o2::framework::DeviceSpec>().inputs;
+  bool foundCTP = false;
+  for (const auto& route : inputRouts) {
+    if (route.matcher == InputSpec{"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe}) {
+      foundCTP = true;
+    }
+  }
+  setLumiCTPAvailable(foundCTP);
+  if ((getLumiScaleType() == LumiScaleType::CTPLumi && !foundCTP) || (getLumiScaleType() == LumiScaleType::TPCScaler && !idcsAvailable)) {
+    LOGP(fatal, "Lumi scaling source {}({}) is not available for TPC correction", static_cast<int>(getLumiScaleType()), getLumiScaleType() == LumiScaleType::CTPLumi ? "CTP" : "TPCScaler");
+  }
+}
+
+void CorrectionMapsLoader::checkMeanScaleConsistency(float meanLumi, float threshold) const
+{
+  if (getLumiScaleType() == LumiScaleType::CTPLumi) {
+    if (meanLumi < threshold) {
+      LOGP(fatal, "CTP Lumi scaling source is requested, but the map mean scale {} is below the threshold {}", meanLumi, threshold);
+    }
+  } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
+    if (meanLumi > threshold) {
+      LOGP(fatal, "IDC scaling source is requested, but the map mean scale {} is above the threshold {}", meanLumi, threshold);
+    }
+  }
+}
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoaderFull.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoaderFull.cxx
deleted file mode 100644
index 717dcaf62779a..0000000000000
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoaderFull.cxx
+++ /dev/null
@@ -1,253 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "TPCCalibration/CorrectionMapsLoaderFull.h"
-#include "TPCCalibration/CorrMapParam.h"
-#include "TPCBaseRecSim/CDBTypes.h"
-#include "Framework/Logger.h"
-#include "Framework/ProcessingContext.h"
-#include "Framework/CCDBParamSpec.h"
-#include "Framework/ConfigParamSpec.h"
-#include "Framework/ConcreteDataMatcher.h"
-#include "Framework/InitContext.h"
-#include "Framework/DeviceSpec.h"
-#include "DataFormatsCTP/LumiInfo.h"
-
-using namespace o2::tpc;
-using namespace o2::framework;
-// using namespace o2::gpu;
-
-//________________________________________________________
-void CorrectionMapsLoaderFull::extractCCDBInputs(ProcessingContext& pc, float tpcScaler)
-{
-  pc.inputs().get<o2::tpc::CorrMapParam*>("tpcCorrPar");
-  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMap");
-  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapRef");
-  const int maxDumRep = 5;
-  int dumRep = 0;
-  o2::ctp::LumiInfo lumiObj;
-  static o2::ctp::LumiInfo lumiPrev;
-
-  if (getLumiScaleType() == LumiScaleType::TPCScaler || mIDC2CTPFallbackActive) {
-    // check if tpcScaler is valid and CTP fallback is allowed
-    if (tpcScaler == -1.f) {
-      const bool canUseCTPScaling = mCorrMap && mCorrMapRef && mCorrMap->isIDCSet() && mCorrMapRef->isIDCSet() && mCorrMap->isLumiSet() && mCorrMapRef->isLumiSet();
-      if (canUseCTPScaling) {
-        LOGP(info, "Invalid TPC scaler value {} received for IDC-based scaling! Using CTP fallback", tpcScaler);
-        mIDC2CTPFallbackActive = true;
-        setMeanLumi(mCorrMap->getLumi(), false);
-        setMeanLumiRef(mCorrMapRef->getLumi());
-        setLumiScaleType(LumiScaleType::CTPLumi);
-      } else if (mCorrMap) {
-        // CTP scaling is not possible, dont do any scaling to avoid applying wrong corrections
-        const float storedIDC = mCorrMap->getIDC();
-        LOGP(warning, "Invalid TPC scaler value {} received for IDC-based scaling! CTP fallback not possible, using stored IDC of {} from the map to avoid applying wrong corrections", tpcScaler, storedIDC);
-        setInstLumi(storedIDC);
-      }
-    } else {
-      if (mIDC2CTPFallbackActive) {
-        // reset back to normal operation
-        LOGP(info, "Valid TPC scaler value {} received, switching back to IDC-based scaling", tpcScaler);
-        mIDC2CTPFallbackActive = false;
-        setMeanLumi(mCorrMap->getIDC(), false);
-        setMeanLumiRef(mCorrMapRef->getIDC());
-        setLumiScaleType(LumiScaleType::TPCScaler);
-      }
-      // correct IDC received
-      setInstLumi(tpcScaler);
-    }
-  }
-
-  if (getLumiCTPAvailable() && mInstCTPLumiOverride <= 0.) {
-    if (pc.inputs().get<gsl::span<char>>("CTPLumi").size() == sizeof(o2::ctp::LumiInfo)) {
-      lumiPrev = lumiObj = pc.inputs().get<o2::ctp::LumiInfo>("CTPLumi");
-    } else {
-      if (dumRep < maxDumRep && lumiPrev.nHBFCounted == 0 && lumiPrev.nHBFCountedFV0 == 0) {
-        LOGP(alarm, "Previous TF lumi used to substitute dummy input is empty, warning {} of {}", ++dumRep, maxDumRep);
-      }
-      lumiObj = lumiPrev;
-    }
-    setInstLumiCTP(mInstLumiCTPFactor * (mLumiCTPSource == 0 ? lumiObj.getLumi() : lumiObj.getLumiAlt()));
-    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
-      setInstLumi(getInstLumiCTP());
-    }
-  }
-
-  reportScaling();
-}
-
-//________________________________________________________
-void CorrectionMapsLoaderFull::requestCCDBInputs(std::vector<InputSpec>& inputs, const CorrectionMapsLoaderGloOpts& gloOpts)
-{
-  LOGP(info, "Requesting CCDB inputs for TPC correction maps with lumiType={} and lumiMode={}", static_cast<int>(gloOpts.lumiType), static_cast<int>(gloOpts.lumiMode));
-  if (gloOpts.lumiMode == LumiScaleMode::Linear) {
-    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});          // time-dependent
-    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
-  } else if (gloOpts.lumiMode == LumiScaleMode::DerivativeMap) {
-    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMap), {}, 1)});            // time-dependent
-    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMap), {}, 1)}); // time-dependent
-  } else if (gloOpts.lumiMode == LumiScaleMode::DerivativeMapMC) {
-    // for MC corrections
-    addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapMC), {}, 1)});            // time-dependent
-    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMapMC), {}, 1)}); // time-dependent
-  } else {
-    LOG(fatal) << "Correction mode unknown! Choose either 0 (default) or 1 (derivative map) for flag corrmap-lumi-mode.";
-  }
-
-  if (gloOpts.requestCTPLumi) {
-    addInput(inputs, {"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe});
-  }
-
-  addInput(inputs, {"tpcCorrPar", "TPC", "CorrMapParam", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CorrMapParam), {}, 0)}); // load once
-}
-
-//________________________________________________________
-void CorrectionMapsLoaderFull::addInput(std::vector<InputSpec>& inputs, InputSpec&& isp)
-{
-  if (std::find(inputs.begin(), inputs.end(), isp) == inputs.end()) {
-    inputs.emplace_back(isp);
-  }
-}
-
-//________________________________________________________
-void CorrectionMapsLoaderFull::addOption(std::vector<ConfigParamSpec>& options, ConfigParamSpec&& osp)
-{
-  if (std::find(options.begin(), options.end(), osp) == options.end()) {
-    options.emplace_back(osp);
-  }
-}
-
-//________________________________________________________
-bool CorrectionMapsLoaderFull::accountCCDBInputs(const ConcreteDataMatcher& matcher, void* obj)
-{
-  if (matcher == ConcreteDataMatcher("TPC", "CorrMap", 0)) {
-    setCorrMap((o2::gpu::TPCFastTransform*)obj);
-    mCorrMap->rectifyAfterReadingFromFile();
-    mCorrMap->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
-    if (getMeanLumiOverride() != 0) {
-      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
-        mCorrMap->setLumi(getMeanLumiOverride());
-        LOGP(info, "CorrMap mean lumi rate is overridden to {}", mCorrMap->getLumi());
-      } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
-        mCorrMap->setIDC(getMeanLumiOverride());
-        LOGP(info, "CorrMap mean IDC rate is overridden to {}", mCorrMap->getIDC());
-      }
-    }
-    float mapMeanRate = 0;
-    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
-      mapMeanRate = mCorrMap->getLumi();
-    } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
-      mapMeanRate = mCorrMap->getIDC();
-    }
-    if (mCheckCTPIDCConsistency) {
-      checkMeanScaleConsistency(mapMeanRate, mCorrMap->getCTP2IDCFallBackThreshold());
-    }
-    if (getMeanLumiOverride() == 0 && mapMeanRate > 0.) {
-      setMeanLumi(mapMeanRate, false);
-    }
-    LOGP(debug, "MeanLumiOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiOverride(), mapMeanRate, getMeanLumi());
-    setUpdatedMap();
-    return true;
-  }
-  if (matcher == ConcreteDataMatcher("TPC", "CorrMapRef", 0)) {
-    setCorrMapRef((o2::gpu::TPCFastTransform*)obj);
-    mCorrMapRef->rectifyAfterReadingFromFile();
-    mCorrMapRef->setCTP2IDCFallBackThreshold(o2::tpc::CorrMapParam::Instance().CTP2IDCFallBackThreshold);
-    if (getMeanLumiRefOverride() != 0) {
-      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
-        mCorrMapRef->setLumi(getMeanLumiRefOverride());
-        LOGP(info, "CorrMapRef mean lumi rate is overridden to {}", mCorrMapRef->getLumi());
-      } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
-        mCorrMapRef->setIDC(getMeanLumiRefOverride());
-        LOGP(info, "CorrMapRef mean IDC rate is overridden to {}", mCorrMapRef->getIDC());
-      }
-    }
-    float mapRefMeanRate = 0;
-    if (getLumiScaleType() == LumiScaleType::CTPLumi) {
-      mapRefMeanRate = mCorrMapRef->getLumi();
-    } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
-      mapRefMeanRate = mCorrMapRef->getIDC();
-    }
-    if (mCheckCTPIDCConsistency) {
-      checkMeanScaleConsistency(mapRefMeanRate, mCorrMapRef->getCTP2IDCFallBackThreshold());
-    }
-    if (getMeanLumiRefOverride() == 0) {
-      setMeanLumiRef(mapRefMeanRate);
-    }
-    LOGP(debug, "MeanLumiRefOverride={} MeanLumiMap={} -> meanLumi = {}", getMeanLumiRefOverride(), mapRefMeanRate, getMeanLumiRef());
-    setUpdatedMapRef();
-    return true;
-  }
-  if (matcher == ConcreteDataMatcher("TPC", "CorrMapParam", 0)) {
-    const auto& par = o2::tpc::CorrMapParam::Instance();
-    mMeanLumiOverride = par.lumiMean; // negative value switches off corrections !!!
-    mMeanLumiRefOverride = par.lumiMeanRef;
-    mInstCTPLumiOverride = par.lumiInst;
-    mInstLumiCTPFactor = par.lumiInstFactor;
-    mLumiCTPSource = par.ctpLumiSource;
-
-    if (mMeanLumiOverride != 0.) {
-      setMeanLumi(mMeanLumiOverride, false);
-    }
-    if (mMeanLumiRefOverride != 0.) {
-      setMeanLumiRef(mMeanLumiRefOverride);
-    }
-    if (mInstCTPLumiOverride != 0.) {
-      setInstLumiCTP(mInstCTPLumiOverride * mInstLumiCTPFactor);
-      if (getLumiScaleType() == LumiScaleType::CTPLumi) {
-        setInstLumi(getInstLumiCTP(), false);
-      }
-    }
-    setUpdatedLumi();
-    int scaleType = static_cast<int>(getLumiScaleType());
-    const std::array<std::string, 3> lumiS{"OFF", "CTP", "TPC scaler"};
-    if (scaleType >= lumiS.size()) {
-      LOGP(fatal, "Wrong corrmap-lumi-mode provided!");
-    }
-
-    LOGP(info, "TPC correction map params updated: SP corrections: {} (corr.map scaling type={}, override values: lumiMean={} lumiRefMean={} lumiScaleMode={}), CTP Lumi: source={} lumiInstOverride={} , LumiInst scale={} ",
-         canUseCorrections() ? "ON" : "OFF",
-         lumiS[scaleType], mMeanLumiOverride, mMeanLumiRefOverride, static_cast<int>(getLumiScaleMode()), mLumiCTPSource, mInstCTPLumiOverride, mInstLumiCTPFactor);
-  }
-  return false;
-}
-
-//________________________________________________________
-void CorrectionMapsLoaderFull::init(o2::framework::InitContext& ic, bool idcsAvailable)
-{
-  if (getLumiScaleMode() == LumiScaleMode::Unset) {
-    LOGP(fatal, "TPC correction lumi scaling mode is not set");
-  }
-  const auto& inputRouts = ic.services().get<const o2::framework::DeviceSpec>().inputs;
-  bool foundCTP = false;
-  for (const auto& route : inputRouts) {
-    if (route.matcher == InputSpec{"CTPLumi", "CTP", "LUMI", 0, Lifetime::Timeframe}) {
-      foundCTP = true;
-    } 
-  }
-  setLumiCTPAvailable(foundCTP);
-  if ((getLumiScaleType() == LumiScaleType::CTPLumi && !foundCTP) || (getLumiScaleType() == LumiScaleType::TPCScaler && !idcsAvailable)) {
-    LOGP(fatal, "Lumi scaling source {}({}) is not available for TPC correction", static_cast<int>(getLumiScaleType()), getLumiScaleType() == LumiScaleType::CTPLumi ? "CTP" : "TPCScaler");
-  }
-}
-
-void CorrectionMapsLoaderFull::checkMeanScaleConsistency(float meanLumi, float threshold) const
-{
-  if (getLumiScaleType() == LumiScaleType::CTPLumi) {
-    if (meanLumi < threshold) {
-      LOGP(fatal, "CTP Lumi scaling source is requested, but the map mean scale {} is below the threshold {}", meanLumi, threshold);
-    }
-  } else if (getLumiScaleType() == LumiScaleType::TPCScaler) {
-    if (meanLumi > threshold) {
-      LOGP(fatal, "IDC scaling source is requested, but the map mean scale {} is above the threshold {}", meanLumi, threshold);
-    }
-  }
-}
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx b/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
new file mode 100644
index 0000000000000..de7e587ba95eb
--- /dev/null
+++ b/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
@@ -0,0 +1,63 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "TPCCalibration/CorrectionMapsOptions.h"
+#include "Framework/Logger.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/ConfigParamRegistry.h"
+using namespace o2::tpc;
+using namespace o2::framework;
+
+#ifndef GPUCA_GPUCODE_DEVICE
+
+//________________________________________________________
+CorrectionMapsGloOpts CorrectionMapsOptions::parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts)
+{
+  CorrectionMapsGloOpts tpcopt;
+  auto lumiTypeVal = opts.get<int>("lumi-type");
+  if (lumiTypeVal < -1 || lumiTypeVal > 2) {
+    LOGP(fatal, "Invalid lumi-type value: {}", lumiTypeVal);
+  }
+  tpcopt.lumiType = static_cast<LumiScaleType>(lumiTypeVal);
+
+  auto lumiModeVal = opts.get<int>("corrmap-lumi-mode");
+  if (lumiModeVal < -1 || lumiModeVal > 2) {
+    LOGP(fatal, "Invalid corrmap-lumi-mode value: {}", lumiModeVal);
+  }
+  tpcopt.lumiMode = static_cast<LumiScaleMode>(lumiModeVal);
+
+  tpcopt.enableMShapeCorrection = opts.get<bool>("enable-M-shape-correction");
+  tpcopt.requestCTPLumi = !opts.get<bool>("disable-ctp-lumi-request");
+  tpcopt.checkCTPIDCconsistency = !opts.get<bool>("disable-lumi-type-consistency-check");
+  if (!tpcopt.requestCTPLumi && tpcopt.lumiType == LumiScaleType::CTPLumi) {
+    LOGP(fatal, "Scaling with CTP Lumi is requested but this input is disabled");
+  }
+  return tpcopt;
+}
+
+void CorrectionMapsOptions::addGlobalOptions(std::vector<ConfigParamSpec>& options)
+{
+  // these are options which should be added at the workflow level, since they modify the inputs of the devices
+  addOption(options, ConfigParamSpec{"lumi-type", o2::framework::VariantType::Int, 0, {"1 = use CTP lumi for TPC correction scaling, 2 = use TPC scalers for TPC correction scaling"}});
+  addOption(options, ConfigParamSpec{"corrmap-lumi-mode", o2::framework::VariantType::Int, 0, {"scaling mode: (default) 0 = static + scale * full; 1 = full + scale * derivative; 2 = full + scale * derivative (for MC)"}});
+  addOption(options, ConfigParamSpec{"enable-M-shape-correction", o2::framework::VariantType::Bool, false, {"Enable M-shape distortion correction"}});
+  addOption(options, ConfigParamSpec{"disable-ctp-lumi-request", o2::framework::VariantType::Bool, false, {"do not request CTP lumi (regardless what is used for corrections)"}});
+  addOption(options, ConfigParamSpec{"disable-lumi-type-consistency-check", o2::framework::VariantType::Bool, false, {"disable check of selected CTP or IDC scaling source being consistent with the map"}});
+}
+
+void CorrectionMapsOptions::addOption(std::vector<ConfigParamSpec>& options, ConfigParamSpec&& osp)
+{
+  if (std::find(options.begin(), options.end(), osp) == options.end()) {
+    options.emplace_back(osp);
+  }
+}
+
+#endif // #ifndef GPUCA_GPUCODE_DEVICE
diff --git a/Detectors/TPC/calibration/src/TrackDump.cxx b/Detectors/TPC/calibration/src/TrackDump.cxx
index f78d958a54bd3..52cf7a4e3c7e3 100644
--- a/Detectors/TPC/calibration/src/TrackDump.cxx
+++ b/Detectors/TPC/calibration/src/TrackDump.cxx
@@ -24,8 +24,6 @@ using namespace o2::tpc;
 using namespace o2::tpc::constants;
 namespace fs = std::filesystem;
 
-o2::gpu::CorrectionMapsHelper o2::tpc::TrackDump::ClusterNativeAdd::sCorrHelper{};
-
 void TrackDump::filter(const gsl::span<const TrackTPC> tracks, ClusterNativeAccess const& clusterIndex, const gsl::span<const o2::tpc::TPCClRefElem> clRefs, const gsl::span<const o2::MCCompLabel> mcLabels)
 {
   if (!mTreeDump && outputFileName.size()) {
@@ -197,8 +195,8 @@ float TrackDump::ClusterNativeAdd::gy() const
 float TrackDump::ClusterNativeAdd::lxc(float vertexTime) const
 {
   float x{0.f}, y{0.f}, z{0.f};
-  if (sCorrHelper.getCorrMap()) {
-    sCorrHelper.Transform(sector, padrow, getPad(), getTime(), x, y, z, vertexTime);
+  if (corrMap) {
+    corrMap->Transform(sector, padrow, getPad(), getTime(), x, y, z, vertexTime);
   }
   return x;
 }
@@ -206,8 +204,8 @@ float TrackDump::ClusterNativeAdd::lxc(float vertexTime) const
 float TrackDump::ClusterNativeAdd::lyc(float vertexTime) const
 {
   float x{0.f}, y{0.f}, z{0.f};
-  if (sCorrHelper.getCorrMap()) {
-    sCorrHelper.Transform(sector, padrow, getPad(), getTime(), x, y, z, vertexTime);
+  if (corrMap) {
+    corrMap->Transform(sector, padrow, getPad(), getTime(), x, y, z, vertexTime);
   }
   return y;
 }
@@ -229,8 +227,8 @@ float TrackDump::ClusterNativeAdd::gyc(float vertexTime) const
 float TrackDump::ClusterNativeAdd::zc(float vertexTime) const
 {
   float x{0.f}, y{0.f}, z{0.f};
-  if (sCorrHelper.getCorrMap()) {
-    sCorrHelper.Transform(sector, padrow, getPad(), getTime(), x, y, z, vertexTime);
+  if (corrMap) {
+    corrMap->Transform(sector, padrow, getPad(), getTime(), x, y, z, vertexTime);
   }
   return z;
 }
@@ -240,5 +238,6 @@ void TrackDump::ClusterNativeAdd::loadCorrMaps(std::string_view corrMapFile, std
   auto fastTransformTmp = gpu::TPCFastTransform::loadFromFile(corrMapFile.data());
   std::vector<char> buffer;
   gpu::TPCFastTransformPOD::create(buffer, *fastTransformTmp);
-  sCorrHelper.setCorrMap(std::move(buffer));
+  corrMapBuffer = std::move(buffer);
+  corrMap = &gpu::TPCFastTransformPOD::get(corrMapBuffer.data());
 }
diff --git a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
index 2b21053bda1ff..811f474d8491d 100644
--- a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
+++ b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
@@ -24,7 +24,6 @@
 #include "DataFormatsTPC/ClusterNativeHelper.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 
-#include "CorrectionMapsHelper.h"
 #include "TPCFastTransformPOD.h"
 #include "GPUO2Interface.h"
 #include "GPUO2InterfaceUtils.h"
@@ -77,11 +76,8 @@ BOOST_AUTO_TEST_CASE(CATracking_test1)
   auto fastTransformTmp = TPCFastTransformHelperO2::instance()->create(0);
   std::vector<char> fastTransformBuf;
   TPCFastTransformPOD::create(fastTransformBuf, *fastTransformTmp);
+  config.configCalib.fastTransform = &TPCFastTransformPOD::get(fastTransformBuf.data());
 
-  std::unique_ptr<CorrectionMapsHelper> fastTransformHelper(new CorrectionMapsHelper());
-  fastTransformHelper->setCorrMap(std::move(fastTransformBuf));
-  config.configCalib.fastTransform = fastTransformHelper->getCorrMap();
-  config.configCalib.fastTransformHelper = fastTransformHelper.get();
   auto dEdxCalibContainer = GPUO2InterfaceUtils::getCalibdEdxContainerDefault();
   config.configCalib.dEdxCalibContainer = dEdxCalibContainer.get();
   std::unique_ptr<TPCPadGainCalib> gainCalib = GPUO2InterfaceUtils::getPadGainCalibDefault();
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h b/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
index 8e8a6a96eed63..3526e9622b83c 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/RecoWorkflow.h
@@ -30,7 +30,7 @@ struct InputSpec;
 }
 namespace tpc
 {
-struct CorrectionMapsLoaderGloOpts;
+struct CorrectionMapsGloOpts;
 
 namespace reco_workflow
 {
@@ -73,16 +73,16 @@ enum struct OutputType { Digits,
 using CompletionPolicyData = std::vector<framework::InputSpec>;
 
 /// create the workflow for TPC reconstruction
-framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData,                    //
-                                    std::vector<int> const& tpcSectors,                  //
-                                    unsigned long tpcSectorMask,                         //
-                                    std::vector<int> const& laneConfiguration,           //
-                                    const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, //
-                                    bool propagateMC = true, unsigned nLanes = 1,        //
-                                    std::string const& cfgInput = "digitizer",           //
-                                    std::string const& cfgOutput = "tracks",             //
-                                    bool disableRootInput = false,                       //
-                                    int caClusterer = 0,                                 //
+framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData,              //
+                                    std::vector<int> const& tpcSectors,            //
+                                    unsigned long tpcSectorMask,                   //
+                                    std::vector<int> const& laneConfiguration,     //
+                                    const o2::tpc::CorrectionMapsGloOpts& sclOpts, //
+                                    bool propagateMC = true, unsigned nLanes = 1,  //
+                                    std::string const& cfgInput = "digitizer",     //
+                                    std::string const& cfgOutput = "tracks",       //
+                                    bool disableRootInput = false,                 //
+                                    int caClusterer = 0,                           //
                                     int zsOnTheFly = 0,
                                     bool askDISTSTF = true,
                                     const std::string& ctfdictOpt = "none",
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
index 8e88a27d51e7f..34f29f94dff4d 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCCalibPadGainTracksSpec.h
@@ -26,7 +26,7 @@
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "Framework/CCDBParamSpec.h"
 #include "TPCBaseRecSim/CDBInterface.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "GPUO2InterfaceUtils.h"
 #include "DataFormatsGlobalTracking/RecoContainer.h"
@@ -181,13 +181,10 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
       LOGP(info, "fetching residual gain map");
       pc.inputs().get<std::unordered_map<std::string, o2::tpc::CalDet<float>>*>("tpcresidualgainmap");
     }
-    mTPCCorrMapsLoader.extractCCDBInputs(pc);
-    bool updateMaps = false;
-    if (mTPCCorrMapsLoader.isUpdated()) {
-      mTPCCorrMapsLoader.acknowledgeUpdate();
-      updateMaps = true;
-    }
-    mPadGainTracks.setTPCCorrMaps(&mTPCCorrMapsLoader);
+
+    auto const& raw = pc.inputs().get<const char*>("corrMap");
+    mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
+    mPadGainTracks.setTPCCorrMaps(mTPCCorrMaps);
     mPadGainTracks.setMembers(&tracks, &clRefs, clusters->clusterIndex, recoData.clusterShMapTPC, recoData.occupancyMapTPC);
     mPadGainTracks.processTracks(mMaxTracksPerTF);
     ++mProcessedTFs;
@@ -203,20 +200,20 @@ class TPCCalibPadGainTracksDevice : public o2::framework::Task
   }
 
  private:
-  const uint32_t mPublishAfter{0};                        ///< number of TFs after which to dump the calibration
-  const bool mDebug{false};                               ///< create debug output
-  const bool mUseLastExtractedMapAsReference{false};      ///< using the last extracted gain map as the reference map which will be applied
-  bool mDisablePolynomialsCCDB{false};                    ///< do not load the polynomials from the CCDB
+  const uint32_t mPublishAfter{0};                               ///< number of TFs after which to dump the calibration
+  const bool mDebug{false};                                      ///< create debug output
+  const bool mUseLastExtractedMapAsReference{false};             ///< using the last extracted gain map as the reference map which will be applied
+  bool mDisablePolynomialsCCDB{false};                           ///< do not load the polynomials from the CCDB
   std::shared_ptr<o2::globaltracking::DataRequest> mDataRequest; ///< reco container data request
-  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest; ///< for accessing the b-field
-  uint32_t mProcessedTFs{0};                              ///< counter to keep track of the processed TFs
-  uint32_t mTFCounter{0};                                 ///< counter to keep track of the TFs
-  CalibPadGainTracks mPadGainTracks{false};               ///< class for creating the pad-by-pad gain map
-  bool mUsingDefaultGainMapForFirstIter{true};            ///< using no reference gain map for the first iteration
-  unsigned int mUseEveryNthTF{1};                         ///< process every Nth TF only
-  unsigned int mFirstTFSend{1};                           ///< first TF for which the data will be send (initialized randomly)
-  int mMaxTracksPerTF{-1};                                ///< max number of tracks processed per TF
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;        ///< for accessing the b-field
+  uint32_t mProcessedTFs{0};                                     ///< counter to keep track of the processed TFs
+  uint32_t mTFCounter{0};                                        ///< counter to keep track of the TFs
+  CalibPadGainTracks mPadGainTracks{false};                      ///< class for creating the pad-by-pad gain map
+  bool mUsingDefaultGainMapForFirstIter{true};                   ///< using no reference gain map for the first iteration
+  unsigned int mUseEveryNthTF{1};                                ///< process every Nth TF only
+  unsigned int mFirstTFSend{1};                                  ///< first TF for which the data will be send (initialized randomly)
+  int mMaxTracksPerTF{-1};                                       ///< max number of tracks processed per TF
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{nullptr};
 
   void sendOutput(DataAllocator& output)
   {
@@ -270,7 +267,7 @@ DataProcessorSpec getTPCCalibPadGainTracksSpec(const uint32_t publishAfterTFs, c
     {"useEveryNthTF", VariantType::Int, 10, {"Using only a fraction of the data: 1: Use every TF, 10: Use only every tenth TF."}},
     {"maxTracksPerTF", VariantType::Int, 10000, {"Maximum number of processed tracks per TF (-1 for processing all tracks)"}},
   };
-  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
 
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
                                                                 false,                          // GRPECS=true
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCRefitter.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCRefitter.h
index e2d8a2de3912d..7add8aecbb85a 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCRefitter.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCRefitter.h
@@ -15,11 +15,6 @@
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "Framework/DataProcessorSpec.h"
 
-namespace o2::tpc
-{
-struct CorrectionMapsLoaderGloOpts;
-}
-
 namespace o2::trackstudy
 {
 /// create a processor spec
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCScalerSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCScalerSpec.h
index 950ef9a248443..1208ae4cd2144 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCScalerSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCScalerSpec.h
@@ -20,7 +20,7 @@ namespace o2
 namespace tpc
 {
 
-o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMShape, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts);
+o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMShape, const o2::tpc::CorrectionMapsGloOpts& sclOpts);
 
 } // end namespace tpc
 } // end namespace o2
diff --git a/Detectors/TPC/workflow/src/RecoWorkflow.cxx b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
index fb9b09329bfab..355bd0cb290f7 100644
--- a/Detectors/TPC/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/TPC/workflow/src/RecoWorkflow.cxx
@@ -100,7 +100,7 @@ const std::unordered_map<std::string, OutputType> OutputMap{
   {"tpc-triggers", OutputType::TPCTriggers}};
 
 framework::WorkflowSpec getWorkflow(CompletionPolicyData* policyData, std::vector<int> const& tpcSectors, unsigned long tpcSectorMask, std::vector<int> const& laneConfiguration,
-                                    const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool propagateMC, unsigned nLanes, std::string const& cfgInput, std::string const& cfgOutput, bool disableRootInput,
+                                    const o2::tpc::CorrectionMapsGloOpts& sclOpts, bool propagateMC, unsigned nLanes, std::string const& cfgInput, std::string const& cfgOutput, bool disableRootInput,
                                     int caClusterer, int zsOnTheFly, bool askDISTSTF, const std::string& ctfdictOpt, bool selIR, bool filteredInp, int deadMapSources, bool useMCTimeGain)
 {
   InputType inputType;
diff --git a/Detectors/TPC/workflow/src/TPCRefitter.cxx b/Detectors/TPC/workflow/src/TPCRefitter.cxx
index 0db87bc8edbae..fbab4500fde5c 100644
--- a/Detectors/TPC/workflow/src/TPCRefitter.cxx
+++ b/Detectors/TPC/workflow/src/TPCRefitter.cxx
@@ -17,7 +17,7 @@
 #include "DataFormatsGlobalTracking/RecoContainerCreateTracksVariadic.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DetectorsBase/Propagator.h"
 #include "Framework/ConfigParamRegistry.h"
@@ -78,7 +78,7 @@ class TPCRefitterSpec final : public Task
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{nullptr};
   bool mUseMC{false}; ///< MC flag
   bool mUseGPUModel{false};
   float mXRef = 83.;
@@ -206,16 +206,8 @@ void TPCRefitterSpec::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   mTPCVDriftHelper.extractCCDBInputs(pc);
-  mTPCCorrMapsLoader.extractCCDBInputs(pc);
-  static bool initOnceDone = false;
-  if (!initOnceDone) { // this params need to be queried only once
-    initOnceDone = true;
-    // none at the moment
-  }
-  // we may have other params which need to be queried regularly
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-  }
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
 }
 
 void TPCRefitterSpec::fillOccupancyVectors(o2::globaltracking::RecoContainer& recoData)
@@ -316,14 +308,14 @@ void TPCRefitterSpec::process(o2::globaltracking::RecoContainer& recoData)
     mTPCTrkLabels = recoData.getTPCTracksMCLabels();
   }
 
-  mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, &mTPCCorrMapsLoader, prop->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, prop);
+  mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMaps, prop->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, prop);
 
   mVdriftTB = mTPCVDriftHelper.getVDriftObject().getVDrift() * o2::tpc::ParameterElectronics::Instance().ZbinWidth; // VDrift expressed in cm/TimeBin
   mTPCTBBias = mTPCVDriftHelper.getVDriftObject().getTimeOffset() / (8 * o2::constants::lhc::LHCBunchSpacingMUS);
 
   auto dumpClusters = [this] {
     static int tf = 0;
-    const auto* corrMap = this->mTPCCorrMapsLoader.getCorrMap();
+    const auto* corrMap = this->mTPCCorrMaps;
     for (int sector = 0; sector < 36; sector++) {
       float alp = ((sector % 18) * 20 + 10) * TMath::DegToRad();
       float sn = TMath::Sin(alp), cs = TMath::Cos(alp);
@@ -478,7 +470,7 @@ bool TPCRefitterSpec::processTPCTrack(o2::tpc::TrackTPC tr, o2::MCCompLabel lbl,
   // auto prepClus = [this, &tr, &clSector, &clRow, &clX, &clY, &clZ, &clXI, &clYI, &clZI, &clNative](float t) { // extract cluster info
   auto prepClus = [this, &tr, &clData](float t) { // extract cluster info
     int count = tr.getNClusters();
-    const auto* corrMap = this->mTPCCorrMapsLoader.getCorrMap();
+    const auto* corrMap = this->mTPCCorrMaps;
     const o2::tpc::ClusterNative* cl = nullptr;
     for (int ic = count; ic--;) {
       uint8_t sector, row;
@@ -503,7 +495,7 @@ bool TPCRefitterSpec::processTPCTrack(o2::tpc::TrackTPC tr, o2::MCCompLabel lbl,
       clData.clZI.emplace_back(z);
 
       // transformation without distortions
-      mTPCCorrMapsLoader.Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, t); // nominal time of the track
+      mTPCCorrMaps->Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, t); // nominal time of the track
       clData.clX.emplace_back(x);
       clData.clY.emplace_back(y);
       clData.clZ.emplace_back(z);
@@ -756,8 +748,7 @@ DataProcessorSpec getTPCRefitterSpec(GTrackID::mask_t srcTracks, GTrackID::mask_
                                                               dataRequest->inputs,
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  o2::tpc::CorrectionMapsLoader::requestInputs(dataRequest->inputs, opts);
-
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
   return DataProcessorSpec{
     "tpc-refitter",
     dataRequest->inputs,
diff --git a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
index 61cbb988d672e..461963fcb261d 100644
--- a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
@@ -27,7 +27,7 @@
 #include "TPCCalibration/TPCFastSpaceChargeCorrectionHelper.h"
 #include "TPCSpaceCharge/SpaceCharge.h"
 #include "CommonUtils/TreeStreamRedirector.h"
-#include "TPCCalibration/CorrectionMapsLoaderFull.h"
+#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCCalibration/VDriftHelper.h"
 
 using namespace o2::framework;
@@ -40,7 +40,7 @@ namespace tpc
 class TPCScalerSpec : public Task
 {
  public:
-  TPCScalerSpec(std::shared_ptr<o2::base::GRPGeomRequest> req, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts, bool enableIDCs, bool enableMShape) : mCCDBRequest(req), mEnableIDCs(enableIDCs), mEnableMShape(enableMShape), mGlobOpts(sclOpts)
+  TPCScalerSpec(std::shared_ptr<o2::base::GRPGeomRequest> req, const o2::tpc::CorrectionMapsGloOpts& sclOpts, bool enableIDCs, bool enableMShape) : mCCDBRequest(req), mEnableIDCs(enableIDCs), mEnableMShape(enableMShape), mGlobOpts(sclOpts)
   {
     mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
     mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
@@ -271,7 +271,7 @@ class TPCScalerSpec : public Task
   std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;     ///< info for CCDB request
   const bool mEnableIDCs{true};                               ///< enable IDCs
   const bool mEnableMShape{false};                            ///< enable v shape scalers
-  const o2::tpc::CorrectionMapsLoaderGloOpts mGlobOpts;       ///< global options for the correction map loader, needed to decide which maps to load from CCDB
+  const o2::tpc::CorrectionMapsGloOpts mGlobOpts;             ///< global options for the correction map loader, needed to decide which maps to load from CCDB
   bool mEnableWeights{false};                                 ///< use weights for TPC scalers
   TPCScalerWeights mScalerWeights{};                          ///< scaler weights
   float mIonDriftTimeMS{-1};                                  ///< ion drift time
@@ -282,7 +282,7 @@ class TPCScalerSpec : public Task
   int mKnotsYMshape{4};                                       ///< number of knots used for the spline object for M-Shape distortions
   int mKnotsZMshape{4};                                       ///< number of knots used for the spline object for M-Shape distortions
   std::unique_ptr<o2::utils::TreeStreamRedirector> mStreamer; ///< streamer
-  o2::tpc::CorrectionMapsLoaderFull mTPCCorrMapsLoader{};
+  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
   o2::tpc::VDriftHelper mTPCVDriftHelper{}; ///< helper for v-drift
 
   void overWriteIntegrationTime()
@@ -299,7 +299,7 @@ class TPCScalerSpec : public Task
   }
 };
 
-o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMShape, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts)
+o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMShape, const o2::tpc::CorrectionMapsGloOpts& sclOpts)
 {
   std::vector<InputSpec> inputs;
   if (enableIDCs) {
@@ -324,7 +324,7 @@ o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMS
   outputs.emplace_back(o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
   outputs.emplace_back(o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
   o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
-  o2::tpc::CorrectionMapsLoaderFull::requestCCDBInputs(inputs, sclOpts);
+  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(inputs, sclOpts);
 
   return DataProcessorSpec{
     "tpc-scaler",
diff --git a/Detectors/TPC/workflow/src/tpc-calib-gainmap-tracks.cxx b/Detectors/TPC/workflow/src/tpc-calib-gainmap-tracks.cxx
index 06f1f2633fb71..138968cd6b517 100644
--- a/Detectors/TPC/workflow/src/tpc-calib-gainmap-tracks.cxx
+++ b/Detectors/TPC/workflow/src/tpc-calib-gainmap-tracks.cxx
@@ -20,7 +20,7 @@
 #include "CommonUtils/ConfigurableParam.h"
 #include "TPCWorkflow/TPCCalibPadGainTracksSpec.h"
 #include "TPCReaderWorkflow/TPCSectorCompletionPolicy.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 
 using namespace o2::framework;
@@ -44,7 +44,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"polynomialsFile", VariantType::String, "", {"file containing the polynomials for the track topology correction"}},
     {"disablePolynomialsCCDB", VariantType::Bool, false, {"Do not load the polynomials from the CCDB"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   std::swap(workflowOptions, options);
 }
 
@@ -63,7 +63,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   const bool useLastExtractedMapAsReference = config.options().get<bool>("useLastExtractedMapAsReference");
   const std::string polynomialsFile = config.options().get<std::string>("polynomialsFile");
   const auto disablePolynomialsCCDB = config.options().get<bool>("disablePolynomialsCCDB");
-  const auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(config.options());
+  const auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(config.options());
   WorkflowSpec workflow;
   workflow.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   workflow.emplace_back(o2::tpc::getTPCCalibPadGainTracksSpec(publishAfterTFs, debug, useLastExtractedMapAsReference, polynomialsFile, disablePolynomialsCCDB));
diff --git a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
index b9c8cde98273b..318c8372e7ad5 100644
--- a/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-reco-workflow.cxx
@@ -23,8 +23,8 @@
 #include "Framework/ConcreteDataMatcher.h"
 #include "TPCWorkflow/RecoWorkflow.h"
 #include "TPCReaderWorkflow/TPCSectorCompletionPolicy.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 #include "TPCCalibration/CorrectionMapsLoader.h"
-#include "TPCCalibration/CorrectionMapsLoaderFull.h"
 #include "Framework/CustomWorkflowTerminationHook.h"
 #include "DataFormatsTPC/TPCSectorHeader.h"
 #include "Algorithm/RangeTokenizer.h"
@@ -77,7 +77,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"tpc-mc-time-gain", VariantType::Bool, false, {"use time gain calibration for MC (true) or for data (false)"}},
   };
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   std::swap(workflowOptions, options);
 }
 
@@ -170,7 +170,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     gTpcSectorMask |= (1ul << s);
   }
   bool doMC = not cfgc.options().get<bool>("disable-mc");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(cfgc.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(cfgc.options());
   auto wf = o2::tpc::reco_workflow::getWorkflow(&gPolicyData,                                      //
                                                 tpcSectors,                                        // sector configuration
                                                 gTpcSectorMask,                                    // same as bitmask
diff --git a/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx b/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
index 1700750f8aa4b..61c589512d1ce 100644
--- a/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
@@ -18,10 +18,10 @@
 #include "Framework/ConfigParamSpec.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCWorkflow/TPCRefitter.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 #include "DetectorsBase/DPLWorkflowUtils.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 
 using namespace o2::framework;
 using GID = o2::dataformats::GlobalTrackID;
@@ -47,7 +47,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"enable-M-shape-correction", VariantType::Bool, false, {"Enable M-shape distortion correction"}},
     {"disable-IDC-scalers", VariantType::Bool, false, {"Disable TPC scalers for space-charge distortion fluctuation correction"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -63,7 +63,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
   auto useMC = configcontext.options().get<bool>("use-mc");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   const auto enableCosmics = configcontext.options().get<bool>("enable-cosmics");
 
   GID::mask_t allowedSourcesTrc = GID::getSourcesMask("ITS,TPC,ITS-TPC,TPC-TOF");
diff --git a/Detectors/TPC/workflow/src/tpc-scaler.cxx b/Detectors/TPC/workflow/src/tpc-scaler.cxx
index d4b994f6eb275..d3893c0eafe84 100644
--- a/Detectors/TPC/workflow/src/tpc-scaler.cxx
+++ b/Detectors/TPC/workflow/src/tpc-scaler.cxx
@@ -15,7 +15,7 @@
 #include "TPCWorkflow/TPCScalerSpec.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "Framework/ConfigParamSpec.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 
 using namespace o2::framework;
 
@@ -26,7 +26,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     ConfigParamSpec{"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"enable-M-shape-correction", VariantType::Bool, false, {"Enable M-shape distortion correction"}},
     {"disable-IDC-scalers", VariantType::Bool, false, {"Disable TPC scalers for space-charge distortion fluctuation correction"}}};
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   std::swap(workflowOptions, options);
 }
 
@@ -38,7 +38,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   o2::conf::ConfigurableParam::updateFromString(config.options().get<std::string>("configKeyValues"));
   const auto enableMShape = config.options().get<bool>("enable-M-shape-correction");
   const auto enableIDCs = !config.options().get<bool>("disable-IDC-scalers");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(config.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(config.options());
   workflow.emplace_back(o2::tpc::getTPCScalerSpec(enableIDCs, enableMShape, sclOpt));
   return workflow;
 }
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
index 9a7ac5a161694..be75beb4c5b51 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
@@ -32,9 +32,8 @@
 #include <memory>
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 #include "GPUO2InterfaceRefit.h"
-#include "TPCFastTransform.h"
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsITS/TrackITS.h"
 #include "DataFormatsITSMFT/TrkClusRef.h"
@@ -81,7 +80,7 @@ class TRDGlobalTracking : public o2::framework::Task
   std::shared_ptr<o2::globaltracking::DataRequest> mDataRequest; ///< seeding input (TPC-only, ITS-TPC or both)
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   o2::tpc::VDriftHelper mTPCVDriftHelper{};
-  o2::tpc::CorrectionMapsLoader mTPCCorrMapsLoader{};
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps{nullptr};
   o2::dataformats::GlobalTrackID::mask_t mTrkMask; ///< seeding track sources (TPC, ITS-TPC)
   bool mTrigRecFilter{false};                      ///< if true, TRD trigger records without matching ITS IR are filtered out
   bool mStrict{false};                             ///< preliminary matching in strict mode
diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index a080f85524684..752309153ac80 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -90,7 +90,11 @@ void TRDGlobalTracking::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   mTPCVDriftHelper.extractCCDBInputs(pc);
-  mTPCCorrMapsLoader.extractCCDBInputs(pc);
+
+  auto const& raw = pc.inputs().get<const char*>("corrMap");
+  mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
+  float lumiCTP = pc.inputs().get<float>("lumiCTP");
+
   // pc.inputs().get<TopologyDictionary*>("cldict"); // called by the RecoContainer to trigger finaliseCCDB
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
@@ -147,13 +151,9 @@ void TRDGlobalTracking::updateTimeDependentParams(ProcessingContext& pc)
       mBase->setLocalGainFactors(pc.inputs().get<o2::trd::LocalGainFactor*>("localgainfactors").get());
     }
   }
-  bool updateCalib = false;
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateCalib = true;
-  }
+
   const auto& trackTune = TrackTuneParams::Instance();
-  float scale = mTPCCorrMapsLoader.getInstLumiCTP();
+  float scale = lumiCTP;
   if (scale < 0.f) {
     scale = 0.f;
   }
@@ -172,7 +172,6 @@ void TRDGlobalTracking::updateTimeDependentParams(ProcessingContext& pc)
     mTracker->SetTPCVdrift(mTPCVdrift);
     mTracker->SetTPCTDriftOffset(mTPCTDriftOffset);
     mTPCVDriftHelper.acknowledgeUpdate();
-    updateCalib = true;
   }
 }
 
@@ -285,7 +284,7 @@ void TRDGlobalTracking::run(ProcessingContext& pc)
   mChainTracking->ClearIOPointers();
 
   mTPCClusterIdxStruct = &inputTracks.inputsTPCclusters->clusterIndex;
-  mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, &mTPCCorrMapsLoader, o2::base::Propagator::Instance()->getNominalBz(), inputTracks.getTPCTracksClusterRefs().data(), 0, inputTracks.clusterShMapTPC.data(), inputTracks.occupancyMapTPC.data(), inputTracks.occupancyMapTPC.size(), nullptr, o2::base::Propagator::Instance());
+  mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMaps, o2::base::Propagator::Instance()->getNominalBz(), inputTracks.getTPCTracksClusterRefs().data(), 0, inputTracks.clusterShMapTPC.data(), inputTracks.occupancyMapTPC.data(), inputTracks.occupancyMapTPC.size(), nullptr, o2::base::Propagator::Instance());
   auto tmpInputContainer = getRecoInputContainer(pc, &mChainTracking->mIOPtrs, &inputTracks, mUseMC);
   auto tmpContainer = GPUWorkflowHelper::fillIOPtr(mChainTracking->mIOPtrs, inputTracks, mUseMC, nullptr, GTrackID::getSourcesMask("TRD"), mTrkMask, GTrackID::mask_t{GTrackID::MASK_NONE});
   mTrackletsRaw = inputTracks.getTRDTracklets();
@@ -891,7 +890,9 @@ DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, boo
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
   Options opts;
-  o2::tpc::CorrectionMapsLoader::requestInputs(inputs, opts);
+
+  dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
+  dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
 
   // Request PID policy data
   if (withPID) {
diff --git a/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx b/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
index 0bff7dd94d8a2..85c7857d3d23c 100644
--- a/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
+++ b/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
@@ -24,7 +24,7 @@
 #include "TRDWorkflow/TRDGlobalTrackingQCSpec.h"
 #include "TRDWorkflow/TRDPulseHeightSpec.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCCalibration/CorrectionMapsOptions.h"
 #include "TPCWorkflow/TPCScalerSpec.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
@@ -64,7 +64,7 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"policy", VariantType::String, "default", {"Pick PID policy (=default)"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
-  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -88,7 +88,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto gain = configcontext.options().get<bool>("enable-gain-calib");
   auto pulseHeight = configcontext.options().get<bool>("enable-ph");
   auto digitsSpec = configcontext.options().get<int>("trd-digits-spec");
-  auto sclOpt = o2::tpc::CorrectionMapsLoader::parseGlobalOptions(configcontext.options());
+  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   bool rootInput = !configcontext.options().get<bool>("disable-root-input");
   GTrackID::mask_t srcTRD = allowedSources & GTrackID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
   if (strict && (srcTRD & ~GTrackID::getSourcesMask("TPC")).any()) {
diff --git a/Detectors/Vertexing/include/DetectorsVertexing/SVertexer.h b/Detectors/Vertexing/include/DetectorsVertexing/SVertexer.h
index b933363bb352d..4d783b0018fc3 100644
--- a/Detectors/Vertexing/include/DetectorsVertexing/SVertexer.h
+++ b/Detectors/Vertexing/include/DetectorsVertexing/SVertexer.h
@@ -35,7 +35,6 @@
 #include <numeric>
 #include <algorithm>
 #include "GPUO2InterfaceRefit.h"
-#include "TPCFastTransform.h"
 #include "DataFormatsTPC/PIDResponse.h"
 
 namespace o2
@@ -46,7 +45,7 @@ class VDriftCorrFact;
 }
 namespace gpu
 {
-class CorrectionMapsHelper;
+class TPCFastTransformPOD;
 }
 
 namespace vertexing
@@ -143,7 +142,7 @@ class SVertexer
     mMUS2TPCBin = 1.f / (nbc * o2::constants::lhc::LHCBunchSpacingMUS);
   }
   void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
-  void setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph);
+  void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph);
   void setStrangenessTracker(o2::strangeness_tracking::StrangenessTracker* tracker) { mStrTracker = tracker; }
   o2::strangeness_tracking::StrangenessTracker* getStrangenessTracker() { return mStrTracker; }
 
@@ -175,7 +174,7 @@ class SVertexer
   gsl::span<const o2::tpc::TPCClRefElem> mTPCTrackClusIdx;            ///< input TPC track cluster indices span
   gsl::span<const unsigned char> mTPCRefitterShMap;                   ///< externally set TPC clusters sharing map
   gsl::span<const unsigned int> mTPCRefitterOccMap;                   ///< externally set TPC clusters occupancy map
-  o2::gpu::CorrectionMapsHelper* mTPCCorrMapsHelper = nullptr;
+  const o2::gpu::TPCFastTransformPOD* mTPCCorrMaps = nullptr;
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mTPCRefitter; ///< TPC refitter used for TPC tracks refit during the reconstruction
   o2::strangeness_tracking::StrangenessTracker* mStrTracker = nullptr;
   gsl::span<const PVertex> mPVertices;
diff --git a/Detectors/Vertexing/src/SVertexer.cxx b/Detectors/Vertexing/src/SVertexer.cxx
index 2c625c9cfaf0a..bf7d436ca150c 100644
--- a/Detectors/Vertexing/src/SVertexer.cxx
+++ b/Detectors/Vertexing/src/SVertexer.cxx
@@ -18,7 +18,7 @@
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "DataFormatsTPC/WorkflowHelper.h"
 #include "DataFormatsTPC/VDriftCorrFact.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 #include "Framework/ProcessingContext.h"
 #include "Framework/DataProcessorSpec.h"
 #include "ReconstructionDataFormats/StrangeTrack.h"
@@ -331,9 +331,9 @@ void SVertexer::setTPCVDrift(const o2::tpc::VDriftCorrFact& v)
   mTPCBin2Z = mTPCVDrift / mMUS2TPCBin;
 }
 //______________________________________________
-void SVertexer::setTPCCorrMaps(o2::gpu::CorrectionMapsHelper* maph)
+void SVertexer::setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph)
 {
-  mTPCCorrMapsHelper = maph;
+  mTPCCorrMaps = maph;
 }
 
 //__________________________________________________________________
@@ -458,7 +458,7 @@ void SVertexer::buildT2V(const o2::globaltracking::RecoContainer& recoData) // a
     mTPCClusterIdxStruct = &recoData.inputsTPCclusters->clusterIndex;
     mTPCRefitterShMap = recoData.clusterShMapTPC;
     mTPCRefitterOccMap = mRecoCont->occupancyMapTPC;
-    mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMapsHelper, o2::base::Propagator::Instance()->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
+    mTPCRefitter = std::make_unique<o2::gpu::GPUO2InterfaceRefit>(mTPCClusterIdxStruct, mTPCCorrMaps, o2::base::Propagator::Instance()->getNominalBz(), mTPCTrackClusIdx.data(), 0, mTPCRefitterShMap.data(), mTPCRefitterOccMap.data(), mTPCRefitterOccMap.size(), nullptr, o2::base::Propagator::Instance());
   }
 
   std::unordered_map<GIndex, std::pair<int, int>> tmap;
@@ -1360,7 +1360,7 @@ float SVertexer::correctTPCTrack(SVertexer::TrackCand& trc, const o2::tpc::Track
   uint8_t sector, row;
   auto cl = &tTPC.getCluster(mTPCTrackClusIdx, tTPC.getNClusters() - 1, *mTPCClusterIdxStruct, sector, row);
   float x = 0, y = 0, z = 0;
-  mTPCCorrMapsHelper->Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, tTB);
+  mTPCCorrMaps->Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, tTB);
   if (x < o2::constants::geom::XTPCInnerRef) {
     x = o2::constants::geom::XTPCInnerRef;
   }
diff --git a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
index 828892ea97406..946602d8c4802 100644
--- a/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
+++ b/EventVisualisation/Workflow/src/O2DPLDisplay.cxx
@@ -25,7 +25,6 @@
 #include "CommonUtils/NameConf.h"
 #include "TRDBase/GeometryFlat.h"
 #include "TOFBase/Geo.h"
-#include "TPCFastTransform.h"
 #include "TRDBase/Geometry.h"
 #include "EMCALCalib/CellRecalibrator.h"
 #include "EMCALWorkflow/CalibLoader.h"
diff --git a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
index b605c99e393b1..4570d4da5d000 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionTimeframe.cxx
@@ -23,7 +23,6 @@
 #include "GPUTPCClusterData.h"
 #include "AliHLTTPCRawCluster.h"
 #include "TPCFastTransformPOD.h"
-#include "CorrectionMapsHelper.h"
 #include "GPUO2DataTypes.h"
 #include "GPUSettings.h"
 
@@ -45,7 +44,7 @@ GPUReconstructionTimeframe::GPUReconstructionTimeframe(GPUChainTracking* chain,
   mMaxBunchesFull = TIME_ORBIT / config.bunchSpacing;
   mMaxBunches = (TIME_ORBIT - config.abortGapTime) / config.bunchSpacing;
 
-  if (config.overlayRaw && chain->GetTPCTransformHelper() == nullptr) {
+  if (config.overlayRaw && chain->GetTPCTransform() == nullptr) {
     GPUInfo("Overlay Raw Events requires TPC Fast Transform");
     throw std::exception();
   }
@@ -72,7 +71,7 @@ int32_t GPUReconstructionTimeframe::ReadEventShifted(int32_t iEvent, float shift
 {
   mReadEvent(iEvent);
   if (config.overlayRaw) {
-    float shiftTTotal = (((double)config.timeFrameLen - DRIFT_TIME) * ((double)TPCZ / (double)DRIFT_TIME) - shiftZ) / mChain->GetTPCTransformHelper()->getCorrMap()->getVDrift();
+    float shiftTTotal = (((double)config.timeFrameLen - DRIFT_TIME) * ((double)TPCZ / (double)DRIFT_TIME) - shiftZ) / mChain->GetTPCTransform()->getVDrift();
     for (uint32_t iSector = 0; iSector < NSECTORS; iSector++) {
       for (uint32_t j = 0; j < mChain->mIOPtrs.nRawClusters[iSector]; j++) {
         auto& tmp = mChain->mIOMem.rawClusters[iSector][j];
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
index acd91939245d0..3dc0223194353 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
@@ -126,7 +126,6 @@ struct ConstPtr {
 template <template <typename T> class S>
 struct GPUCalibObjectsTemplate { // use only pointers on PODs or flat objects here
   typename S<TPCFastTransformPOD>::type* fastTransform = nullptr;
-  typename S<CorrectionMapsHelper>::type* fastTransformHelper = nullptr;
   typename S<o2::base::MatLayerCylSet>::type* matLUT = nullptr;
   typename S<o2::trd::GeometryFlat>::type* trdGeometry = nullptr;
   typename S<TPCPadGainCalib>::type* tpcPadGain = nullptr;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 0fd2335fe7863..d669f60356101 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -51,7 +51,6 @@
 #include "CalibdEdxContainer.h"
 
 #include "TPCFastTransformPOD.h"
-#include "CorrectionMapsHelper.h"
 
 #include "utils/linux_helpers.h"
 #include "utils/strtag.h"
@@ -396,10 +395,6 @@ void GPUChainTracking::UpdateGPUCalibObjects(int32_t stream, const GPUCalibObjec
     memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransform, (const void*)processors()->calibObjects.fastTransform, processors()->calibObjects.fastTransform->size());
   }
 
-  if (processors()->calibObjects.fastTransformHelper && (ptrMask == nullptr || ptrMask->fastTransformHelper)) {
-    memcpy((void*)mFlatObjectsShadow.mCalibObjects.fastTransformHelper, (const void*)processors()->calibObjects.fastTransformHelper, sizeof(*processors()->calibObjects.fastTransformHelper));
-    mFlatObjectsShadow.mCalibObjects.fastTransformHelper->setCorrMap(mFlatObjectsShadow.mCalibObjects.fastTransform);
-  }
   if (processors()->calibObjects.dEdxCalibContainer && (ptrMask == nullptr || ptrMask->dEdxCalibContainer)) {
     memcpy((void*)mFlatObjectsShadow.mCalibObjects.dEdxCalibContainer, (const void*)processors()->calibObjects.dEdxCalibContainer, sizeof(*processors()->calibObjects.dEdxCalibContainer));
     memcpy((void*)mFlatObjectsShadow.mdEdxSplinesBuffer, (const void*)processors()->calibObjects.dEdxCalibContainer->getFlatBufferPtr(), processors()->calibObjects.dEdxCalibContainer->getFlatBufferSize());
@@ -490,9 +485,6 @@ void* GPUChainTracking::GPUTrackingFlatObjects::SetPointersFlatObjects(void* mem
     computePointerWithAlignment(mem, podBuf, mChainTracking->processors()->calibObjects.fastTransform->size()); // raw bytes
     mCalibObjects.fastTransform = reinterpret_cast<TPCFastTransformPOD*>(podBuf);
   }
-  if (mChainTracking->processors()->calibObjects.fastTransformHelper) {
-    computePointerWithAlignment(mem, mCalibObjects.fastTransformHelper, 1);
-  }
   if ((char*)mem - fastTransformBase < mChainTracking->GetProcessingSettings().fastTransformObjectsMinMemorySize) {
     mem = fastTransformBase + mChainTracking->GetProcessingSettings().fastTransformObjectsMinMemorySize; // TODO: Fixme and do proper dynamic allocation
   }
@@ -565,12 +557,10 @@ void GPUChainTracking::AllocateIOMemory()
   AllocateIOMemoryHelper(mIOPtrs.nTRDTriggerRecords, mIOPtrs.trdTrackletIdxFirst, mIOMem.trdTrackletIdxFirst);
 }
 
-void GPUChainTracking::SetTPCFastTransform(std::unique_ptr<TPCFastTransformPOD>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper)
+void GPUChainTracking::SetTPCFastTransform(std::unique_ptr<TPCFastTransformPOD>&& tpcFastTransform)
 {
   mTPCFastTransformU = std::move(tpcFastTransform);
-  mTPCFastTransformHelperU = std::move(tpcTransformHelper);
   processors()->calibObjects.fastTransform = mTPCFastTransformU.get();
-  processors()->calibObjects.fastTransformHelper = mTPCFastTransformHelperU.get();
 }
 
 void GPUChainTracking::SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut)
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index a7dfcb9c73a3e..2af33f86ab0d7 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -173,7 +173,7 @@ class GPUChainTracking : public GPUChain
   int32_t RunRefit();
 
   // Getters / setters for parameters
-  const CorrectionMapsHelper* GetTPCTransformHelper() const;
+  const TPCFastTransformPOD* GetTPCTransform() const;
   const TPCPadGainCalib* GetTPCPadGainCalib() const;
   const TPCZSLinkMapping* GetTPCZSLinkMapping() const;
   const o2::tpc::CalibdEdxContainer* GetdEdxCalibContainer() const;
@@ -182,7 +182,7 @@ class GPUChainTracking : public GPUChain
   const GPUTRDRecoParam* GetTRDRecoParam() const;
   const o2::base::Propagator* GetO2Propagator() const;
   const o2::base::Propagator* GetDeviceO2Propagator();
-  void SetTPCFastTransform(std::unique_ptr<TPCFastTransformPOD>&& tpcFastTransform, std::unique_ptr<CorrectionMapsHelper>&& tpcTransformHelper);
+  void SetTPCFastTransform(std::unique_ptr<TPCFastTransformPOD>&& tpcFastTransform);
   void SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut);
   void SetTRDGeometry(std::unique_ptr<o2::trd::GeometryFlat>&& geo);
   void SetTRDRecoParam(std::unique_ptr<GPUTRDRecoParam>&& par);
@@ -260,8 +260,7 @@ class GPUChainTracking : public GPUChain
   std::unique_ptr<GPUTPCClusterStatistics> mCompressionStatistics;
 
   // Ptr to detector / calibration objects
-  std::unique_ptr<TPCFastTransformPOD> mTPCFastTransformU;              // Global TPC fast transformation object
-  std::unique_ptr<CorrectionMapsHelper> mTPCFastTransformHelperU;    // Global TPC fast transformation helper object
+  std::unique_ptr<TPCFastTransformPOD> mTPCFastTransformU;           // Global TPC fast transformation object
   std::unique_ptr<TPCPadGainCalib> mTPCPadGainCalibU;                // TPC gain calibration and cluster finder parameters
   std::unique_ptr<TPCZSLinkMapping> mTPCZSLinkMappingU;              // TPC Mapping data required by ZS Link decoder
   std::unique_ptr<o2::tpc::CalibdEdxContainer> mdEdxCalibContainerU; // TPC dEdx calibration container
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc b/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
index b3b1773ec664e..37c6956c01ee4 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
+++ b/GPU/GPUTracking/Global/GPUChainTrackingGetters.inc
@@ -20,7 +20,7 @@
 
 namespace o2::gpu
 {
-inline const CorrectionMapsHelper* GPUChainTracking::GetTPCTransformHelper() const { return processors()->calibObjects.fastTransformHelper; }
+inline const TPCFastTransformPOD* GPUChainTracking::GetTPCTransform() const { return processors()->calibObjects.fastTransform; }
 inline const TPCPadGainCalib* GPUChainTracking::GetTPCPadGainCalib() const { return processors()->calibObjects.tpcPadGain; }
 inline const TPCZSLinkMapping* GPUChainTracking::GetTPCZSLinkMapping() const { return processors()->calibObjects.tpcZSLinkMapping; }
 inline const o2::tpc::CalibdEdxContainer* GPUChainTracking::GetdEdxCalibContainer() const { return processors()->calibObjects.dEdxCalibContainer; }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 89d208b33f327..21bc9a66eac0c 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -45,7 +45,6 @@
 #include "CalibdEdxContainer.h"
 
 #include "TPCFastTransformPOD.h"
-#include "CorrectionMapsHelper.h"
 
 using namespace o2::gpu;
 
@@ -298,11 +297,6 @@ void GPUChainTracking::DumpSettings(const char* dir)
     f += "tpctransform.dump";
     DumpStructToFile(processors()->calibObjects.fastTransform, f.c_str());
   }
-  if (processors()->calibObjects.fastTransformHelper != nullptr) {
-    f = dir;
-    f += "tpctransformhelper.dump";
-    DumpStructToFile(processors()->calibObjects.fastTransformHelper, f.c_str());
-  }
   if (processors()->calibObjects.tpcPadGain != nullptr) {
     f = dir;
     f += "tpcpadgaincalib.dump";
@@ -343,12 +337,6 @@ void GPUChainTracking::ReadSettings(const char* dir)
   mTPCFastTransformU = ReadStructFromFile<TPCFastTransformPOD>(f.c_str());
   processors()->calibObjects.fastTransform = mTPCFastTransformU.get();
   f = dir;
-  f += "tpctransformhelper.dump";
-  mTPCFastTransformHelperU = ReadStructFromFile<CorrectionMapsHelper>(f.c_str());
-  if ((processors()->calibObjects.fastTransformHelper = mTPCFastTransformHelperU.get())) {
-    mTPCFastTransformHelperU->setCorrMap(mTPCFastTransformU.get());
-  }
-  f = dir;
   f += "tpcpadgaincalib.dump";
   mTPCPadGainCalibU = ReadStructFromFile<TPCPadGainCalib>(f.c_str());
   processors()->calibObjects.tpcPadGain = mTPCPadGainCalibU.get();
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
index 10a1a75368c96..cd184b3820533 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.cxx
@@ -19,7 +19,7 @@
 #include "GPUParam.h"
 #include "GPUTPCGMMergedTrackHit.h"
 #include "GPUTrackingRefit.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 #include "GPUTPCClusterOccupancyMap.h"
 
 using namespace o2::gpu;
@@ -96,7 +96,7 @@ size_t GPUO2InterfaceRefit::fillOccupancyMapGetSize(uint32_t nHbfPerTf, const GP
   }
 }
 
-GPUO2InterfaceRefit::GPUO2InterfaceRefit(const ClusterNativeAccess* cl, const CorrectionMapsHelper* trans, float bzNominalGPU, const TPCClRefElem* trackRef, uint32_t nHbfPerTf, const uint8_t* sharedmap, const uint32_t* occupancymap, int32_t occupancyMapSize, const std::vector<TrackTPC>* trks, o2::base::Propagator* p)
+GPUO2InterfaceRefit::GPUO2InterfaceRefit(const ClusterNativeAccess* cl, const TPCFastTransformPOD* trans, float bzNominalGPU, const TPCClRefElem* trackRef, uint32_t nHbfPerTf, const uint8_t* sharedmap, const uint32_t* occupancymap, int32_t occupancyMapSize, const std::vector<TrackTPC>* trks, o2::base::Propagator* p)
 {
   mParam = GPUO2InterfaceUtils::getFullParam(bzNominalGPU, nHbfPerTf);
   size_t expectedOccMapSize = nHbfPerTf ? fillOccupancyMapGetSize(nHbfPerTf, mParam.get()) : 0;
@@ -124,13 +124,13 @@ GPUO2InterfaceRefit::GPUO2InterfaceRefit(const ClusterNativeAccess* cl, const Co
   mRefit->SetPropagator(p);
   mRefit->SetClusterNative(cl);
   mRefit->SetTrackHitReferences(trackRef);
-  mRefit->SetFastTransformHelper(trans);
+  mRefit->SetFastTransform(trans);
 }
 
-void GPUO2InterfaceRefit::updateCalib(const CorrectionMapsHelper* trans, float bzNominalGPU)
+void GPUO2InterfaceRefit::updateCalib(const TPCFastTransformPOD* trans, float bzNominalGPU)
 {
   mParam->UpdateBzOnly(bzNominalGPU);
-  mRefit->SetFastTransformHelper(trans);
+  mRefit->SetFastTransform(trans);
 }
 
 int32_t GPUO2InterfaceRefit::RefitTrackAsGPU(o2::tpc::TrackTPC& trk, bool outward, bool resetCov) { return mRefit->RefitTrackAsGPU(trk, outward, resetCov); }
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
index d4aa6900e308a..0af10dbe4f388 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
@@ -50,7 +50,7 @@ namespace o2::gpu
 {
 class GPUParam;
 class GPUTrackingRefit;
-class CorrectionMapsHelper;
+class TPCFastTransformPOD;
 class GPUO2InterfaceRefit
 {
  public:
@@ -60,7 +60,7 @@ class GPUO2InterfaceRefit
   // - o2::base::Propagator (p) in case RefitTrackAsTrackParCov is to be used
   // - In case the --configKeyValues defining GPUParam settings require an occupancy map for TPC error estimation, the map must either be provided as occupancymap, or nHbfPerTf must be set non-zero
 
-  GPUO2InterfaceRefit(const o2::tpc::ClusterNativeAccess* cl, const o2::gpu::CorrectionMapsHelper* trans, float bzNominalGPU, const o2::tpc::TPCClRefElem* trackRef, uint32_t nHbfPerTf = 0, const uint8_t* sharedmap = nullptr, const uint32_t* occupancymap = nullptr, int32_t occupancyMapSize = -1, const std::vector<o2::tpc::TrackTPC>* trks = nullptr, o2::base::Propagator* p = nullptr);
+  GPUO2InterfaceRefit(const o2::tpc::ClusterNativeAccess* cl, const o2::gpu::TPCFastTransformPOD* trans, float bzNominalGPU, const o2::tpc::TPCClRefElem* trackRef, uint32_t nHbfPerTf = 0, const uint8_t* sharedmap = nullptr, const uint32_t* occupancymap = nullptr, int32_t occupancyMapSize = -1, const std::vector<o2::tpc::TrackTPC>* trks = nullptr, o2::base::Propagator* p = nullptr);
   ~GPUO2InterfaceRefit();
 
   int32_t RefitTrackAsGPU(o2::tpc::TrackTPC& trk, bool outward = false, bool resetCov = false);
@@ -69,7 +69,7 @@ class GPUO2InterfaceRefit
   int32_t RefitTrackAsTrackParCov(o2::track::TrackParCov& trk, const o2::tpc::TrackTPCClusRef& clusRef, float time0, float* chi2 = nullptr, bool outward = false, bool resetCov = false);
   void setTrackReferenceX(float v);
   void setIgnoreErrorsAtTrackEnds(bool v);
-  void updateCalib(const o2::gpu::CorrectionMapsHelper* trans, float bzNominalGPU);
+  void updateCalib(const o2::gpu::TPCFastTransformPOD* trans, float bzNominalGPU);
   auto getParam() const { return mParam.get(); }
 
   // To create shared cluster maps and occupancy maps.
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 8358e98883aca..0a6db295632fd 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -564,7 +564,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
   trk.SinPhi() = inTrack->Param().GetSinPhi();
   trk.DzDs() = inTrack->Param().GetDzDs();
   trk.QPt() = inTrack->Param().GetQPt();
-  trk.TOffset() = Param().par.continuousTracking ? GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin) : 0;
+  trk.TOffset() = Param().par.continuousTracking ? GetConstantMem()->calibObjects.fastTransform->convZOffsetToVertexTime(sector, inTrack->Param().GetZOffset(), Param().continuousMaxTimeBin) : 0;
   const auto tmp = sectorTrack.ClusterTN() > sectorTrack.ClusterT0() ? std::array<float, 2>{sectorTrack.ClusterTN(), sectorTrack.ClusterT0()} : std::array<float, 2>{sectorTrack.ClusterT0(), sectorTrack.ClusterTN()};
   trk.ShiftZ(this, sector, tmp[0], tmp[1], inTrack->Param().GetX()); // We do not store the inner / outer cluster X, so we just use the track X instead
   sectorTrack.SetX2(0.f);
@@ -587,7 +587,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
       row = ic.RowIndex();
       const ClusterNative& cl = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[GetConstantMem()->ioPtrs.clustersNative->clusterOffset[sector][0] + clusterIndex];
       flags = cl.getFlags();
-      GetConstantMem()->calibObjects.fastTransformHelper->Transform(sector, row, cl.getPad(), cl.getTime(), x, y, z, trk.TOffset());
+      GetConstantMem()->calibObjects.fastTransform->Transform(sector, row, cl.getPad(), cl.getTime(), x, y, z, trk.TOffset());
       if (prop.PropagateToXAlpha(x, alpha, way == 0)) {
         return way == 0;
       }
@@ -1413,11 +1413,11 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
                                               cls[mClusters[trk[1]->FirstClusterRef()].num].getTime(), cls[mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1].num].getTime(),
                                               &mClusters[trk[0]->FirstClusterRef()], &mClusters[trk[0]->FirstClusterRef() + trk[0]->NClusters() - 1],
                                               &mClusters[trk[1]->FirstClusterRef()], &mClusters[trk[1]->FirstClusterRef() + trk[1]->NClusters() - 1], clsmax);
-        const float offset = CAMath::Max(tmax - mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(clsmax->sector, clsmax->row, cls[clsmax->num].getPad()), 0.f);
-        trk[1]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[1]->CSide() * NSECTORS / 2, trk[1]->Param().TOffset() - offset);
+        const float offset = CAMath::Max(tmax - mConstantMem->calibObjects.fastTransform->getMaxDriftTime(clsmax->sector, clsmax->row, cls[clsmax->num].getPad()), 0.f);
+        trk[1]->Param().Z() += mConstantMem->calibObjects.fastTransform->convDeltaTimeToDeltaZinTimeFrame(trk[1]->CSide() * NSECTORS / 2, trk[1]->Param().TOffset() - offset);
         trk[1]->Param().TOffset() = offset;
         if (celooper) {
-          trk[0]->Param().Z() += mConstantMem->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trk[0]->CSide() * NSECTORS / 2, trk[0]->Param().TOffset() - offset);
+          trk[0]->Param().Z() += mConstantMem->calibObjects.fastTransform->convDeltaTimeToDeltaZinTimeFrame(trk[0]->CSide() * NSECTORS / 2, trk[0]->Param().TOffset() - offset);
           trk[0]->Param().TOffset() = offset;
         }
       }
@@ -1948,7 +1948,7 @@ GPUd() void GPUTPCGMMerger::MergeLoopersInit(int32_t nBlocks, int32_t nThreads,
     const float qptabs = CAMath::Abs(p.GetQPt());
     if (trk.OK() && trk.NClusters() && trk.Leg() == 0 && qptabs * Param().qptB5Scaler > 5.f && qptabs * Param().qptB5Scaler <= lowPtThresh) {
       const int32_t sector = mClusters[trk.FirstClusterRef() + trk.NClusters() - 1].sector;
-      const float refz = p.GetZ() + (Param().par.continuousTracking ? GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, p.GetTOffset(), Param().continuousMaxTimeBin) : 0) + (trk.CSide() ? -100 : 100);
+      const float refz = p.GetZ() + (Param().par.continuousTracking ? GetConstantMem()->calibObjects.fastTransform->convVertexTimeToZOffset(sector, p.GetTOffset(), Param().continuousMaxTimeBin) : 0) + (trk.CSide() ? -100 : 100);
       float sinA, cosA;
       CAMath::SinCos(trk.GetAlpha(), sinA, cosA);
       float gx = cosA * p.GetX() - sinA * p.GetY();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index f6afc46609a11..93fae97a4bd54 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -34,8 +34,8 @@
 #include "GPUDebugStreamer.h"
 #include "GPUTPCClusterOccupancyMap.h"
 #include "GPUTrackingRefit.h"
-#include "CorrectionMapsHelper.h"
 #include "GPUConstantMem.h"
+#include "TPCFastTransformPOD.h"
 
 using namespace o2::gpu;
 using namespace gputpcgmmergertypes;
@@ -355,7 +355,7 @@ std::vector<float> GPUTPCGMMerger::StreamerUncorrectedZY(int32_t iSector, int32_
 {
   std::vector<float> retVal(2);
 #ifdef DEBUG_STREAMER
-  GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(iSector, iRow, track.GetY(), track.GetZ(), retVal[0], retVal[1]);
+  GetConstantMem()->calibObjects.fastTransform->InverseTransformYZtoNominalYZ(iSector, iRow, track.GetY(), track.GetZ(), retVal[0], retVal[1]);
 #endif
   return retVal;
 }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 523bfa7df73e0..483bc6279c716 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -19,7 +19,6 @@
 #include "DataFormatsTPC/Constants.h"
 #include "DataFormatsTPC/PIDResponse.h"
 #include "TPCFastTransformPOD.h"
-#include "CorrectionMapsHelper.h"
 #include "GPUGetConstexpr.h"
 
 #ifndef GPUCA_GPUCODE
@@ -238,8 +237,8 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
       } else {
         // estimate max/min time increments which still keep track in the physical limits of the TPC
         const float tmin = CAMath::Min(t1, t2);
-        const float maxDriftTime = merger.GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(t1 > t2 ? sector1 : sector2);
-        const float clusterT0 = merger.GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getT0();
+        const float maxDriftTime = merger.GetConstantMem()->calibObjects.fastTransform->getMaxDriftTime(t1 > t2 ? sector1 : sector2);
+        const float clusterT0 = merger.GetConstantMem()->calibObjects.fastTransform->getT0();
         const float tmax = CAMath::Min(tmin + maxDriftTime, CAMath::Max(t1, t2));
         float delta = 0.f;
         if (time0 + maxDriftTime < tmax) {
@@ -250,7 +249,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::output>(int32_t nBlocks
         }
         if (delta != 0.f) {
           time0 += delta;
-          const float deltaZ = merger.GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(sector2, delta);
+          const float deltaZ = merger.GetConstantMem()->calibObjects.fastTransform->convDeltaTimeToDeltaZinTimeFrame(sector2, delta);
           oTrack.setZ(oTrack.getZ() + deltaZ);
         }
         tFwd = tmin - clusterT0 - time0;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index 6042dec7d4931..fe2029e5563f4 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -37,7 +37,7 @@ GPUd() void GPUTPCGMSectorTrack::Set(const GPUTPCGMMerger* merger, const GPUTPCT
   mParam.mSecPhi = 1.f / mParam.mCosPhi;
   mAlpha = alpha;
   mSector = sector;
-  mTOffset = merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convZOffsetToVertexTime(sector, t.GetZOffset(), merger->Param().continuousMaxTimeBin) : 0;
+  mTOffset = merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransform->convZOffsetToVertexTime(sector, t.GetZOffset(), merger->Param().continuousMaxTimeBin) : 0;
   mNClusters = sectorTr->NHits();
 }
 
@@ -323,7 +323,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToX(GPUTPCGMMerger* merger, float x, f
   b.SetPar(2, ey1);
   b.SetPar(3, param.mDzDs);
   b.SetPar(4, param.mQPt);
-  b.SetZOffsetLinear(merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin) : 0);
+  b.SetZOffsetLinear(merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransform->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin) : 0);
 
   if (!doCov) {
     return (1);
@@ -478,7 +478,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToXAlpha(GPUTPCGMMerger* merger, float
   b.SetPar(2, ey1);
   b.SetPar(3, dzds);
   b.SetPar(4, qpt);
-  b.SetZOffsetLinear(merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin) : 0);
+  b.SetZOffsetLinear(merger->Param().par.continuousTracking ? merger->GetConstantMem()->calibObjects.fastTransform->convVertexTimeToZOffset(mSector, mTOffset, merger->Param().continuousMaxTimeBin) : 0);
 
   b.SetCov(0, c00 + h2 * h2c22 + h4 * h4c44 + 2.f * (h2 * c20ph4c42 + h4 * c40));
   b.SetCov(1, c11 + dS * (c31 + n7));
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index f5dce94906cc2..ffc9ba7bbe9f8 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -29,7 +29,6 @@
 #include "GPUO2DataTypes.h"
 #include "GPUConstantMem.h"
 #include "TPCFastTransformPOD.h"
-#include "CorrectionMapsHelper.h"
 #include "GPUTPCConvertImpl.h"
 #include "GPUTPCGMMergerTypes.h"
 #include "GPUParam.inc"
@@ -128,7 +127,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       float xx, yy, zz;
       {
         const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
-        merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), xx, yy, zz, mTOffset);
+        merger->GetConstantMem()->calibObjects.fastTransform->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), xx, yy, zz, mTOffset);
       }
       // clang-format off
       CADEBUG(printf("\tHit %3d/%3d Row %3d: Cluster Alpha %8.3f %3d, X %8.3f - Y %8.3f, Z %8.3f (Missed %d)\n", ihit, maxN, (int32_t)clusters[ihit].row, clAlpha, (int32_t)clusters[ihit].sector, xx, yy, zz, nMissed));
@@ -444,7 +443,7 @@ GPUd() int32_t GPUTPCGMTrackParam::MergeDoubleRowClusters(int32_t& ihit, int32_t
       const ClusterNative& GPUrestrict() cl = merger->GetConstantMem()->ioPtrs.clustersNative->clustersLinear[clusters[ihit].num];
       float clamp = cl.qTot;
       float clx, cly, clz;
-      merger->GetConstantMem()->calibObjects.fastTransformHelper->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), clx, cly, clz, mTOffset);
+      merger->GetConstantMem()->calibObjects.fastTransform->Transform(clusters[ihit].sector, clusters[ihit].row, cl.getPad(), cl.getTime(), clx, cly, clz, mTOffset);
       float dy = cly - projY;
       float dz = clz - projZ;
       if (noReject == 0 && (dy * dy > maxDistY || dz * dz > maxDistZ)) {
@@ -480,7 +479,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
 {
   float Y, Z;
   float X = 0;
-  Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoX(sector, iRow, mP[0], mP[1], X);
+  Merger->GetConstantMem()->calibObjects.fastTransform->InverseTransformYZtoX(sector, iRow, mP[0], mP[1], X);
   if (prop.GetPropagatedYZ(X, Y, Z)) {
     Y = mP[0];
     Z = mP[1];
@@ -502,7 +501,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
     return -1e6f;
   }
 
-  const float zOffset = param.par.continuousTracking ? Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, param.continuousMaxTimeBin) : 0; // TODO: do some validatiomns for the transform conv functions...
+  const float zOffset = param.par.continuousTracking ? Merger->GetConstantMem()->calibObjects.fastTransform->convVertexTimeToZOffset(sector, mTOffset, param.continuousMaxTimeBin) : 0; // TODO: do some validatiomns for the transform conv functions...
   const float y0 = row.Grid().YMin();
   const float stepY = row.HstepY();
   const float z0 = row.Grid().ZMin() - zOffset; // We can use our own ZOffset, since this is only used temporarily anyway
@@ -510,7 +509,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   int32_t bin, ny, nz;
 
   float uncorrectedY, uncorrectedZ;
-  Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(sector, iRow, Y, Z, uncorrectedY, uncorrectedZ);
+  Merger->GetConstantMem()->calibObjects.fastTransform->InverseTransformYZtoNominalYZ(sector, iRow, Y, Z, uncorrectedY, uncorrectedZ);
   if (CAMath::Abs(uncorrectedY) > row.getTPCMaxY()) {
     return uncorrectedY;
   }
@@ -522,7 +521,7 @@ GPUd() float GPUTPCGMTrackParam::AttachClusters(const GPUTPCGMMerger* GPUrestric
   const float tubeMinSize2 = protect ? param.rec.tpc.tubeProtectMinSize2 : 0.f;
   float tubeSigma2 = protect ? param.rec.tpc.tubeProtectSigma2 : param.rec.tpc.tubeRemoveSigma2;
   uint32_t pad = CAMath::Float2UIntRn(GPUTPCGeometry::LinearY2Pad(sector, iRow, uncorrectedY));
-  float time = Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->InverseTransformInTimeFrame(sector, uncorrectedZ + (param.par.continuousTracking ? Merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, mTOffset, param.continuousMaxTimeBin) : 0), param.continuousMaxTimeBin); // TODO: Simplify this call in TPCFastTransform
+  float time = Merger->GetConstantMem()->calibObjects.fastTransform->InverseTransformInTimeFrame(sector, uncorrectedZ + (param.par.continuousTracking ? Merger->GetConstantMem()->calibObjects.fastTransform->convVertexTimeToZOffset(sector, mTOffset, param.continuousMaxTimeBin) : 0), param.continuousMaxTimeBin); // TODO: Simplify this call in TPCFastTransform
   if (iRow < param.rec.tpc.tubeExtraProtectMinRow ||
       pad < param.rec.tpc.tubeExtraProtectEdgePads || pad >= (uint32_t)(GPUTPCGeometry::NPads(iRow) - param.rec.tpc.tubeExtraProtectEdgePads) ||
       param.GetUnscaledMult(time) / GPUTPCGeometry::Row2X(iRow) > param.rec.tpc.tubeExtraProtectMinOccupancy) {
@@ -598,7 +597,7 @@ GPUd() bool GPUTPCGMTrackParam::AttachClustersPropagate(const GPUTPCGMMerger* GP
     }
     if (dodEdx && iRow + step == toRow) {
       float yUncorrected, zUncorrected;
-      Merger->GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(sector, iRow, mP[0], mP[1], yUncorrected, zUncorrected);
+      Merger->GetConstantMem()->calibObjects.fastTransform->InverseTransformYZtoNominalYZ(sector, iRow, mP[0], mP[1], yUncorrected, zUncorrected);
       uint32_t pad = CAMath::Float2UIntRn(GPUTPCGeometry::LinearY2Pad(sector, iRow, yUncorrected));
       if (pad >= GPUTPCGeometry::NPads(iRow) || (Merger->GetConstantMem()->calibObjects.dEdxCalibContainer && Merger->GetConstantMem()->calibObjects.dEdxCalibContainer->isDead(sector, iRow, pad))) {
         dodEdx = false;
@@ -846,14 +845,14 @@ GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merg
   if (!beamlineReached) {
     float refZ = ((sector < GPUCA_NSECTORS / 2) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * clx;
     float basez;
-    merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->TransformIdealZ(sector, cltmax, basez, mTOffset);
+    merger->GetConstantMem()->calibObjects.fastTransform->TransformIdealZ(sector, cltmax, basez, mTOffset);
     deltaZ = basez - refZ;
   }
   {
-    float deltaT = merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaZtoDeltaTimeInTimeFrame(sector, deltaZ);
+    float deltaT = merger->GetConstantMem()->calibObjects.fastTransform->convDeltaZtoDeltaTimeInTimeFrame(sector, deltaZ);
     mTOffset += deltaT;
-    const float maxT = cltmin - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getT0();
-    const float minT = cltmax - merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->getMaxDriftTime(sector);
+    const float maxT = cltmin - merger->GetConstantMem()->calibObjects.fastTransform->getT0();
+    const float minT = cltmax - merger->GetConstantMem()->calibObjects.fastTransform->getMaxDriftTime(sector);
     // printf("T Check: Clusters %f %f, min %f max %f vtx %f\n", tz1, tz2, minT, maxT, mTOffset);
     deltaT = 0.f;
     if (mTOffset < minT) {
@@ -863,7 +862,7 @@ GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merg
       deltaT = maxT - mTOffset;
     }
     if (deltaT != 0.f) {
-      deltaZ += merger->GetConstantMem()->calibObjects.fastTransformHelper->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(sector, deltaT);
+      deltaZ += merger->GetConstantMem()->calibObjects.fastTransform->convDeltaTimeToDeltaZinTimeFrame(sector, deltaT);
       // printf("Moving clusters to TPC Range: QPt %f, New mTOffset %f, t1 %f, t2 %f, Shift %f in Z: %f to %f --> %f to %f in T\n", mP[4], mTOffset + deltaT, tz1, tz2, deltaZ, tz2 - mTOffset, tz1 - mTOffset, tz2 - mTOffset - deltaT, tz1 - mTOffset - deltaT);
       mTOffset += deltaT;
     }
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index 4f9d848f2b703..e5ff9424b722d 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -21,7 +21,7 @@
 #include "GPUTPCGMPropagator.h"
 #include "GPUConstantMem.h"
 #include "ReconstructionDataFormats/Track.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 #include "DetectorsBase/Propagator.h"
 #include "DataFormatsTPC/TrackTPC.h"
 #include "GPUParam.inc"
@@ -286,7 +286,7 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
           z *= charge;
         }
         if (clusters == 0) {
-          mPfastTransformHelper->Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, tOffset);
+          mPfastTransform->Transform(sector, row, cl->getPad(), cl->getTime(), x, y, z, tOffset);
           CADEBUG(printf("\tHit %3d/%3d Row %3d: Cluster Alpha %8.3f %3d, X %8.3f - Y %8.3f, Z %8.3f - State %d\n", ii, count, row, mPparam->Alpha(sector), (int32_t)sector, x, y, z, (int32_t)nextState));
           currentRow = row;
           currentSector = sector;
@@ -297,7 +297,7 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
           invCharge = (1.f / cl->qMax);
         } else {
           float xx, yy, zz;
-          mPfastTransformHelper->Transform(sector, row, cl->getPad(), cl->getTime(), xx, yy, zz, tOffset);
+          mPfastTransform->Transform(sector, row, cl->getPad(), cl->getTime(), xx, yy, zz, tOffset);
           CADEBUG(printf("\tHit %3d/%3d Row %3d: Cluster Alpha %8.3f %3d, X %8.3f - Y %8.3f, Z %8.3f - State %d\n", ii, count, row, mPparam->Alpha(sector), (int32_t)sector, xx, yy, zz, (int32_t)nextState));
           x += xx * cl->qTot;
           y += yy * cl->qTot;
@@ -432,7 +432,7 @@ void GPUTrackingRefit::SetPtrsFromGPUConstantMem(const GPUConstantMem* v, GPUPar
   mPclusterState = v->ioPtrs.mergedTrackHitStates;
   mPclusterNative = v->ioPtrs.clustersNative;
   mPtrackHits = v->ioPtrs.mergedTrackHits;
-  mPfastTransformHelper = v->calibObjects.fastTransformHelper;
+  mPfastTransform = v->calibObjects.fastTransform;
   mPmatLUT = v->calibObjects.matLUT;
   mPparam = p ? p : &v->param;
 }
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.h b/GPU/GPUTracking/Refit/GPUTrackingRefit.h
index bb45709d08165..70c9fd47d90f6 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.h
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.h
@@ -45,7 +45,7 @@ using TrackTPCClusRef = o2::dataformats::RangeReference<uint32_t, uint16_t>;
 
 namespace o2::gpu
 {
-class CorrectionMapsHelper;
+class TPCFastTransformPOD;
 class GPUTPCGMTrackParam;
 class GPUTPCGMMergedTrack;
 struct GPUConstantMem;
@@ -61,7 +61,7 @@ class GPUTrackingRefit
   void SetClusterNative(const o2::tpc::ClusterNativeAccess* v) { mPclusterNative = v; }
   void SetTrackHits(const GPUTPCGMMergedTrackHit* v) { mPtrackHits = v; }
   void SetTrackHitReferences(const uint32_t* v) { mPtrackHitReferences = v; }
-  void SetFastTransformHelper(const CorrectionMapsHelper* v) { mPfastTransformHelper = v; }
+  void SetFastTransform(const TPCFastTransformPOD* v) { mPfastTransform = v; }
   void SetGPUParam(const GPUParam* v) { mPparam = v; }
   GPUd() int32_t RefitTrackAsGPU(GPUTPCGMMergedTrack& trk, bool outward = false, bool resetCov = false) { return RefitTrack<GPUTPCGMMergedTrack, GPUTPCGMTrackParam>(trk, outward, resetCov); }
   GPUd() int32_t RefitTrackAsTrackParCov(GPUTPCGMMergedTrack& trk, bool outward = false, bool resetCov = false) { return RefitTrack<GPUTPCGMMergedTrack, o2::track::TrackParCov>(trk, outward, resetCov); }
@@ -94,7 +94,7 @@ class GPUTrackingRefit
   const o2::tpc::ClusterNativeAccess* mPclusterNative = nullptr; // Ptr to cluster native access structure
   const GPUTPCGMMergedTrackHit* mPtrackHits = nullptr;           // Ptr to hits for GPUTPCGMMergedTrack tracks
   const uint32_t* mPtrackHitReferences = nullptr;                // Ptr to hits for TrackTPC tracks
-  const CorrectionMapsHelper* mPfastTransformHelper = nullptr;   // Ptr to TPC fast transform object helper
+  const TPCFastTransformPOD* mPfastTransform = nullptr;          // Ptr to TPC fast transform object helper
   const GPUParam* mPparam = nullptr;                             // Ptr to GPUParam
   template <class T, class S>
   GPUd() int32_t RefitTrack(T& trk, bool outward, bool resetCov);
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
index 7ebe13e8bfb9e..4d719e6d80576 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
@@ -100,7 +100,7 @@ void* GPUTPCTrackingData::SetPointersRows(void* mem)
 GPUd() void GPUTPCTrackingData::GetMaxNBins(GPUconstantref() const GPUConstantMem* mem, GPUTPCRow* GPUrestrict() row, int32_t& maxY, int32_t& maxZ)
 {
   maxY = row->mMaxY * 2.f / GPUCA_MIN_BIN_SIZE + 1;
-  maxZ = (mem->param.continuousMaxTimeBin > 0 ? (mem->calibObjects.fastTransformHelper->getCorrMap()->convTimeToZinTimeFrame(0, 0, mem->param.continuousMaxTimeBin)) : GPUTPCGeometry::TPCLength()) + 50;
+  maxZ = (mem->param.continuousMaxTimeBin > 0 ? (mem->calibObjects.fastTransform->convTimeToZinTimeFrame(0, 0, mem->param.continuousMaxTimeBin)) : GPUTPCGeometry::TPCLength()) + 50;
   maxZ = maxZ / GPUCA_MIN_BIN_SIZE + 1;
 }
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
index 567e4e93cc524..15a3d4667db47 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
@@ -22,7 +22,7 @@
 #include "GPUTPCTracklet.h"
 #include "GPUTPCTrackletConstructor.h"
 #include "GPUTPCExtrapolationTracking.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 #include "CalibdEdxContainer.h"
 #include "GPUParam.inc"
 #include "GPUCommonMath.h"
@@ -135,13 +135,13 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
         if (tracker.Param().par.continuousTracking) {
           tParam.ConstrainZ(z, tracker.ISector(), z0, r.mLastZ);
         }
-        tracker.GetConstantMem()->calibObjects.fastTransformHelper->TransformXYZ(tracker.ISector(), iRow, x, y, z);
+        tracker.GetConstantMem()->calibObjects.fastTransform->TransformXYZ(tracker.ISector(), iRow, x, y, z);
       }
       if (iRow == r.mStartRow) {
         if (tracker.Param().par.continuousTracking) {
           float refZ = ((z > 0) ? tracker.Param().rec.tpc.defaultZOffsetOverR : -tracker.Param().rec.tpc.defaultZOffsetOverR) * x;
           float zTmp = refZ;
-          tracker.GetConstantMem()->calibObjects.fastTransformHelper->TransformXYZ(tracker.ISector(), iRow, x, y, zTmp);
+          tracker.GetConstantMem()->calibObjects.fastTransform->TransformXYZ(tracker.ISector(), iRow, x, y, zTmp);
           z += zTmp - refZ; // Add zCorrection (=zTmp - refZ) to z, such that zOffset is set such, that transformed (z - zOffset) becomes refZ
           tParam.SetZOffset(z - refZ);
           tParam.SetZ(refZ);
@@ -267,7 +267,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
         if (tracker.Param().par.continuousTracking) {
           tParam.ConstrainZ(tmpZ, tracker.ISector(), z0, r.mLastZ);
         }
-        tracker.GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoX(tracker.ISector(), iRow, tmpY, tmpZ, x);
+        tracker.GetConstantMem()->calibObjects.fastTransform->InverseTransformYZtoX(tracker.ISector(), iRow, tmpY, tmpZ, x);
       }
 
       CADEBUG(printf("%14s: SEA TRACK ROW %3d X %8.3f -", "", iRow, tParam.X()); for (int32_t i = 0; i < 5; i++) { printf(" %8.3f", tParam.Par()[i]); } printf(" -"); for (int32_t i = 0; i < 15; i++) { printf(" %8.3f", tParam.Cov()[i]); } printf("\n"));
@@ -288,7 +288,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
 
         GPUglobalref() const cahit2* hits = tracker.HitData(row);
         GPUglobalref() const calink* firsthit = tracker.FirstHitInBin(row);
-        tracker.GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoNominalYZ(tracker.ISector(), iRow, yUncorrected, zUncorrected, yUncorrected, zUncorrected);
+        tracker.GetConstantMem()->calibObjects.fastTransform->InverseTransformYZtoNominalYZ(tracker.ISector(), iRow, yUncorrected, zUncorrected, yUncorrected, zUncorrected);
 
         if (tracker.Param().rec.tpc.rejectEdgeClustersInSeeding && tracker.Param().rejectEdgeClusterByY(yUncorrected, iRow, CAMath::Sqrt(tParam.Err2Y()))) {
           rowHit = CALINK_INVAL;
@@ -452,7 +452,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::DoTracklet(GPUconstantref() GPUTPCT
           } else if (tracker.ISector() < GPUCA_NSECTORS / 2 ? (tmpZ > GPUTPCGeometry::TPCLength()) : (tmpZ < -GPUTPCGeometry::TPCLength())) {
             tmpZ = tracker.ISector() < GPUCA_NSECTORS / 2 ? GPUTPCGeometry::TPCLength() : -GPUTPCGeometry::TPCLength();
           }
-          tracker.GetConstantMem()->calibObjects.fastTransformHelper->InverseTransformYZtoX(tracker.ISector(), iRow, tmpY, tmpZ, x);
+          tracker.GetConstantMem()->calibObjects.fastTransform->InverseTransformYZtoX(tracker.ISector(), iRow, tmpY, tmpZ, x);
         } else {
           r.mGo = 0;
           continue;
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 2a2f7adea8cb9..1e6c25ed66202 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -24,8 +24,7 @@
 #include "display/GPUDisplayInterface.h"
 #include "genEvents.h"
 
-#include "TPCFastTransform.h"
-#include "CorrectionMapsHelper.h"
+#include "TPCFastTransformPOD.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUSettings.h"
 #include "GPUConstantMem.h"
@@ -336,8 +335,8 @@ int32_t SetupReconstruction()
       printf("Continuous mode forced\n");
       configStandalone.cont = true;
     }
-    if (chainTracking->GetTPCTransformHelper()) {
-      grp.grpContinuousMaxTimeBin = configStandalone.TF.timeFrameLen * ((double)GPUReconstructionTimeframe::TPCZ / (double)GPUReconstructionTimeframe::DRIFT_TIME) / chainTracking->GetTPCTransformHelper()->getCorrMap()->getVDrift();
+    if (chainTracking->GetTPCTransform()) {
+      grp.grpContinuousMaxTimeBin = configStandalone.TF.timeFrameLen * ((double)GPUReconstructionTimeframe::TPCZ / (double)GPUReconstructionTimeframe::DRIFT_TIME) / chainTracking->GetTPCTransform()->getVDrift();
     }
   }
   if (configStandalone.setMaxTimeBin != -2) {
diff --git a/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h b/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
index 5f989fafe9558..efca7ceefa345 100644
--- a/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
+++ b/GPU/GPUTracking/TPCConvert/GPUTPCConvertImpl.h
@@ -18,7 +18,6 @@
 #include "GPUCommonDef.h"
 #include "GPUConstantMem.h"
 #include "TPCFastTransformPOD.h"
-#include "CorrectionMapsHelper.h"
 
 namespace o2::gpu
 {
@@ -29,9 +28,9 @@ class GPUTPCConvertImpl
   GPUd() static void convert(const GPUConstantMem& GPUrestrict() cm, int32_t sector, int32_t row, float pad, float time, float& GPUrestrict() x, float& GPUrestrict() y, float& GPUrestrict() z)
   {
     if (cm.param.par.continuousTracking) { // TODO: This might be wrong, don't we just need to do TransformInTimeframe always
-      cm.calibObjects.fastTransformHelper->getCorrMap()->TransformInTimeFrame(sector, row, pad, time, x, y, z, cm.param.continuousMaxTimeBin);
+      cm.calibObjects.fastTransform->TransformInTimeFrame(sector, row, pad, time, x, y, z, cm.param.continuousMaxTimeBin);
     } else {
-      cm.calibObjects.fastTransformHelper->Transform(sector, row, pad, time, x, y, z);
+      cm.calibObjects.fastTransform->Transform(sector, row, pad, time, x, y, z);
     }
   }
   GPUd() static void convert(const TPCFastTransformPOD& GPUrestrict() transform, const GPUParam& GPUrestrict() param, int32_t sector, int32_t row, float pad, float time, float& GPUrestrict() x, float& GPUrestrict() y, float& GPUrestrict() z)
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 6447d30daefe3..415d54e742b65 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -556,12 +556,12 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
             auto cl = mIOPtrs->mergedTrackHits[track->FirstClusterRef() + lastCluster];
             const auto& cln = mIOPtrs->clustersNative->clustersLinear[cl.num];
             GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, cl.sector, cl.row, cln.getPad(), cln.getTime(), x, y, z);
-            ZOffset = mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(iSector, track->GetParam().GetTOffset(), mParam->continuousMaxTimeBin);
+            ZOffset = mCalib->fastTransform->convVertexTimeToZOffset(iSector, track->GetParam().GetTOffset(), mParam->continuousMaxTimeBin);
           } else {
             uint8_t sector, row;
             auto cln = track->getCluster(mIOPtrs->outputClusRefsTPCO2, lastCluster, *mIOPtrs->clustersNative, sector, row);
             GPUTPCConvertImpl::convert(*mCalib->fastTransform, *mParam, sector, row, cln.getPad(), cln.getTime(), x, y, z);
-            ZOffset = mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(sector, track->getTime0(), mParam->continuousMaxTimeBin);
+            ZOffset = mCalib->fastTransform->convVertexTimeToZOffset(sector, track->getTime0(), mParam->continuousMaxTimeBin);
           }
         } else {
           const GPUTPCMCInfo& mc = mIOPtrs->mcInfosTPC[i];
@@ -593,7 +593,7 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
 #ifdef GPUCA_TPC_GEOMETRY_O2
           trkParam.Set(mclocal[0], mclocal[1], mc.z, mclocal[2], mclocal[3], mc.pZ, -charge); // TODO: DR: unclear to me why we need -charge here
           if (mParam->par.continuousTracking) {
-            ZOffset = fabsf(mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(0, mc.t0, mParam->continuousMaxTimeBin)) * (mc.z < 0 ? -1 : 1);
+            ZOffset = fabsf(mCalib->fastTransform->convVertexTimeToZOffset(0, mc.t0, mParam->continuousMaxTimeBin)) * (mc.z < 0 ? -1 : 1);
           }
 #else
           if (fabsf(mc.z) > GPUTPCGeometry::TPCLength()) {
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index 658cdc46cb6cb..db340389452dc 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -180,7 +180,7 @@ void GPUDisplay::DrawGLScene_updateEventData()
       while (mParam->par.continuousTracking && trdTriggerRecord < (int32_t)mIOPtrs->nTRDTriggerRecords - 1 && mIOPtrs->trdTrackletIdxFirst[trdTriggerRecord + 1] <= i) {
         trdTriggerRecord++; // This requires to go through the data in order I believe
         float trdTime = mIOPtrs->trdTriggerTimes[trdTriggerRecord] * 1e3 / o2::constants::lhc::LHCBunchSpacingNS / o2::tpc::constants::LHCBCPERTIMEBIN;
-        trdZoffset = fabsf(mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(0, trdTime, mParam->continuousMaxTimeBin));
+        trdZoffset = fabsf(mCalib->fastTransform->convVertexTimeToZOffset(0, trdTime, mParam->continuousMaxTimeBin));
       }
       const auto& sp = mIOPtrs->trdSpacePoints[i];
       int32_t iSec = trdGeometry()->GetSector(mIOPtrs->trdTracklets[i].GetDetector());
@@ -218,7 +218,7 @@ void GPUDisplay::DrawGLScene_updateEventData()
       float ZOffset = 0;
       if (mParam->par.continuousTracking) {
         float tofTime = mIOPtrs->tofClusters[i].getTime() * 1e-3 / o2::constants::lhc::LHCBunchSpacingNS / o2::tpc::constants::LHCBCPERTIMEBIN;
-        ZOffset = fabsf(mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(0, tofTime, mParam->continuousMaxTimeBin));
+        ZOffset = fabsf(mCalib->fastTransform->convVertexTimeToZOffset(0, tofTime, mParam->continuousMaxTimeBin));
         ptr->z += ptr->z > 0 ? ZOffset : -ZOffset;
       }
       if (fabsf(ptr->z) > maxClusterZ) {
@@ -249,7 +249,7 @@ void GPUDisplay::DrawGLScene_updateEventData()
       if (mParam->par.continuousTracking) {
         o2::InteractionRecord startIR = o2::InteractionRecord(0, mIOPtrs->settingsTF && mIOPtrs->settingsTF->hasTfStartOrbit ? mIOPtrs->settingsTF->tfStartOrbit : 0);
         float itsROFtime = mIOPtrs->itsClusterROF[j].getBCData().differenceInBC(startIR) / (float)o2::tpc::constants::LHCBCPERTIMEBIN;
-        ZOffset = fabsf(mCalib->fastTransformHelper->getCorrMap()->convVertexTimeToZOffset(0, itsROFtime + itsROFhalfLen, mParam->continuousMaxTimeBin));
+        ZOffset = fabsf(mCalib->fastTransform->convVertexTimeToZOffset(0, itsROFtime + itsROFhalfLen, mParam->continuousMaxTimeBin));
       }
       if (i != mIOPtrs->itsClusterROF[j].getFirstEntry()) {
         throw std::runtime_error("Inconsistent ITS data, number of clusters does not match ROF content");
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 05db68a6e0bc2..143a6f94d17a6 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -50,7 +50,6 @@
 #include "GPUTPCClusterRejection.h"
 #include "GPUTPCConvertImpl.h"
 #include "TPCFastTransformPOD.h"
-#include "CorrectionMapsHelper.h"
 #include "GPUROOTDump.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "SimulationDataFormat/MCCompLabel.h"
@@ -1062,8 +1061,8 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             if (revLabel == -1) {
               comp = true;
             } else {
-              float shift1 = mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trks[i].CSide() * GPUChainTracking::NSECTORS / 2, trks[i].GetParam().GetTOffset());
-              float shift2 = mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(trks[revLabel].CSide() * GPUChainTracking::NSECTORS / 2, trks[revLabel].GetParam().GetTOffset());
+              float shift1 = mTracking->GetTPCTransform()->convDeltaTimeToDeltaZinTimeFrame(trks[i].CSide() * GPUChainTracking::NSECTORS / 2, trks[i].GetParam().GetTOffset());
+              float shift2 = mTracking->GetTPCTransform()->convDeltaTimeToDeltaZinTimeFrame(trks[revLabel].CSide() * GPUChainTracking::NSECTORS / 2, trks[revLabel].GetParam().GetTOffset());
               comp = fabsf(trks[i].GetParam().GetZ() + shift1) < fabsf(trks[revLabel].GetParam().GetZ() + shift2);
             }
             if (revLabel == -1 || !trks[revLabel].OK() || (trks[i].OK() && comp)) {
@@ -1125,7 +1124,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
             if (lowestPadRow[i] < 10 && lowestRow > lowestPadRow[i] + 3) {
               const auto& cl = clNative->clustersLinear[lowestCl.num];
               float x, y, z;
-              mTracking->GetTPCTransformHelper()->Transform(lowestCl.sector, lowestCl.row, cl.getPad(), cl.getTime(), x, y, z, trk.GetParam().GetTOffset());
+              mTracking->GetTPCTransform()->Transform(lowestCl.sector, lowestCl.row, cl.getPad(), cl.getTime(), x, y, z, trk.GetParam().GetTOffset());
               float phi = CAMath::ATan2(y, x);
               mPadRow[2]->Fill(phi, lowestRow, 1.f);
               if (CAMath::Abs(phi) < 0.15) {
@@ -1440,7 +1439,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           if (!mParam->continuousMaxTimeBin) {
             return param.GetZ() - mc1.z;
           }
-          float shift = side == 2 ? 0 : mTracking->GetTPCTransformHelper()->getCorrMap()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSECTORS / 2, param.GetTOffset() - mc1.t0);
+          float shift = side == 2 ? 0 : mTracking->GetTPCTransform()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSECTORS / 2, param.GetTOffset() - mc1.t0);
           return param.GetZ() + shift - mc1.z;
         };
 
@@ -1792,13 +1791,13 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         }
       }
     }
-    if (mClNative && mTracking && mTracking->GetTPCTransformHelper()) {
+    if (mClNative && mTracking && mTracking->GetTPCTransform()) {
       for (uint32_t i = 0; i < GPUChainTracking::NSECTORS; i++) {
         for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
           for (uint32_t k = 0; k < mClNative->nClusters[i][j]; k++) {
             const auto& cl = mClNative->clusters[i][j][k];
             float x, y, z;
-            GPUTPCConvertImpl::convert(*mTracking->GetTPCTransformHelper()->getCorrMap(), mTracking->GetParam(), i, j, cl.getPad(), cl.getTime(), x, y, z);
+            GPUTPCConvertImpl::convert(*mTracking->GetTPCTransform(), mTracking->GetParam(), i, j, cl.getPad(), cl.getTime(), x, y, z);
             mTracking->GetParam().Sector2Global(i, x, y, z, &x, &y, &z);
             mClXY->Fill(x, y);
           }
@@ -1926,7 +1925,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           if (attach & gputpcgmmergertypes::attachFlagMask) {
             uint32_t track = attach & gputpcgmmergertypes::attachTrackMask;
             const auto& trk = mTracking->mIOPtrs.mergedTracks[track];
-            mTracking->GetTPCTransformHelper()->Transform(i, j, cl.getPad(), cl.getTime(), x, y, z, trk.GetParam().GetTOffset());
+            mTracking->GetTPCTransform()->Transform(i, j, cl.getPad(), cl.getTime(), x, y, z, trk.GetParam().GetTOffset());
             mTracking->GetParam().Sector2Global(i, x, y, z, &x, &y, &z);
           }
           uint32_t extState = mTracking->mIOPtrs.mergedTrackHitStates ? mTracking->mIOPtrs.mergedTrackHitStates[clid] : 0;
diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index 769e9981102ef..df33fdeb62354 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -46,7 +46,7 @@ if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
 endif()
 
 string(REPLACE ".cxx" ".h" HDRS_CINT_O2 "${SRCS}")
-set(HDRS_CINT_O2 ${HDRS_CINT_O2} SplineUtil.h devtools/RegularSpline1D.h)
+set(HDRS_CINT_O2 ${HDRS_CINT_O2} SplineUtil.h devtools/RegularSpline1D.h CorrectionMapsTypes.h)
 
 if(${ALIGPU_BUILD_TYPE} STREQUAL "O2")
   o2_add_library(${MODULE}
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
index 71477f8dce718..7f7deddafe1c8 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
@@ -10,45 +10,51 @@
 // or submit itself to any jurisdiction.
 
 #include "CorrectionMapsHelper.h"
-#include "Framework/ConfigParamRegistry.h"
+#include "GPUCommonLogger.h"
+
 using namespace o2::gpu;
 using namespace o2::tpc;
 
-void CorrectionMapsHelper::setCorrMap(const TPCFastTransformPOD* m)
+//________________________________________________________
+void CorrectionMapsHelper::clear()
 {
-  // non-owning: just store the pointer, clear any previously owned buffer
-#if !defined(GPUCA_GPUCODE_DEVICE)
-  mCorrMapBuffer.clear();
-#endif
-  mCorrMap = m;
+  mLumiCTPAvailable = false;
+  mCorrMap = nullptr;
+  mCorrMapRef = nullptr;
+  mCorrMapMShape.reset();
+  mUpdatedFlags = 0;
+  mInstLumiCTP = 0.f;
+  mInstLumi = 0.f;
+  mMeanLumi = 0.f;
+  mMeanLumiRef = 0.f;
 }
 
-void CorrectionMapsHelper::setCorrMap(std::vector<char>&& buffer)
+void CorrectionMapsHelper::setCorrMapMShape(std::unique_ptr<TPCFastTransform>&& m)
 {
-  mCorrMapBuffer = std::move(buffer);
-  mCorrMap = &TPCFastTransformPOD::get(mCorrMapBuffer.data());
+  setUpdatedMapMShape();
+  mCorrMapMShape = std::move(m);
 }
 
-CorrectionMapsLoaderGloOpts CorrectionMapsHelper::parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts)
+void CorrectionMapsHelper::updateLumiScale(bool report)
 {
-  CorrectionMapsLoaderGloOpts tpcopt;
-  auto lumiTypeVal = opts.get<int>("lumi-type");
-  if (lumiTypeVal < -1 || lumiTypeVal > 2) {
-    LOGP(fatal, "Invalid lumi-type value: {}", lumiTypeVal);
+  if (!canUseCorrections()) {
+    mLumiScale = -1.f;
+  } else if ((mLumiScaleMode == LumiScaleMode::DerivativeMap) || (mLumiScaleMode == LumiScaleMode::DerivativeMapMC)) {
+    mLumiScale = mMeanLumiRef ? (mInstLumi - mMeanLumi) / mMeanLumiRef : 0.f;
+    LOGP(debug, "mInstLumi: {}  mMeanLumi: {} mMeanLumiRef: {}", mInstLumi, mMeanLumi, mMeanLumiRef);
+  } else {
+    mLumiScale = mMeanLumi ? mInstLumi / mMeanLumi : 0.f;
   }
-  tpcopt.lumiType = static_cast<LumiScaleType>(lumiTypeVal);
-
-  auto lumiModeVal = opts.get<int>("corrmap-lumi-mode");
-  if (lumiModeVal < -1 || lumiModeVal > 2) {
-    LOGP(fatal, "Invalid corrmap-lumi-mode value: {}", lumiModeVal);
+  setUpdatedLumi();
+  if (report) {
+    reportScaling();
   }
-  tpcopt.lumiMode = static_cast<LumiScaleMode>(lumiModeVal);
+}
 
-  tpcopt.enableMShapeCorrection = opts.get<bool>("enable-M-shape-correction");
-  tpcopt.requestCTPLumi = !opts.get<bool>("disable-ctp-lumi-request");
-  tpcopt.checkCTPIDCconsistency = !opts.get<bool>("disable-lumi-type-consistency-check");
-  if (!tpcopt.requestCTPLumi && tpcopt.lumiType == LumiScaleType::CTPLumi) {
-    LOGP(fatal, "Scaling with CTP Lumi is requested but this input is disabled");
-  }
-  return tpcopt;
+//________________________________________________________
+void CorrectionMapsHelper::reportScaling()
+{
+  LOGP(info, "Map scaling update: LumiScaleType={} instLumi(CTP)={} instLumi(scaling)={} meanLumiRef={}, meanLumi={} -> LumiScale={} lumiScaleMode={}, M-Shape map valid: {}, M-Shape default: {}",
+       mLumiScaleType == LumiScaleType::NoScaling ? "NoScaling" : (mLumiScaleType == LumiScaleType::CTPLumi ? "LumiCTP" : "TPCScaler"), getInstLumiCTP(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(),
+       mLumiScaleMode == LumiScaleMode::Linear ? "Linear" : "Derivative", (mCorrMapMShape != nullptr), isCorrMapMShapeDummy());
 }
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
index ce88321fa4fc8..2ddd4bc6b3004 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -11,50 +11,16 @@
 
 /// \file CorrectionMapsHelper.h
 /// \brief Helper class to access correction maps
-/// \author ruben.shahoian@cern.ch
+/// \author ruben.shahoian@cern.ch matthias.kleiner@cern.ch
 
 #ifndef TPC_CORRECTION_MAPS_HELPER_H_
 #define TPC_CORRECTION_MAPS_HELPER_H_
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#include <vector>
-#endif
-#include "GPUCommonDef.h"
-#include "TPCFastTransformPOD.h"
+#include "TPCFastTransform.h"
+#include "CorrectionMapsTypes.h"
 
 namespace o2
 {
-
-namespace framework
-{
-class ConfigParamRegistry;
-} // namespace framework
-
-namespace tpc
-{
-enum class LumiScaleType : int32_t {
-  Unset = -1, ///< init value
-  NoScaling = 0, ///< no scaling, use map as is
-  CTPLumi = 1, ///< use CTP luminosity for scaling
-  TPCScaler = 2 ///< use TPC scaler for scaling
-};
-
-enum class LumiScaleMode : int32_t {
-    Unset = -1, ///< init value
-    Linear = 0, ///< map(lumi) = (mean_map - referenceMap) * lumiScale + referenceMap
-    DerivativeMap = 1, ///< map(lumi) = mean_map + lumiScale * (derivativeMap) where derivativeMap = (mean_map_A - mean_map_B)
-    DerivativeMapMC = 2  ///< same DerivativeMap, but for MC
-};
-
-struct CorrectionMapsLoaderGloOpts {
-  LumiScaleType lumiType = LumiScaleType::Unset; ///< what estimator to used for corrections scaling: 0: no scaling, 1: CTP, 2: IDC
-  LumiScaleMode lumiMode = LumiScaleMode::Unset; ///< what corrections method to use: 0: classical scaling, 1: Using of the derivative map, 2: Using of the derivative map for MC
-  bool enableMShapeCorrection = false;
-  bool requestCTPLumi = true; ///< request CTP Lumi regardless of what is used for corrections scaling
-  bool checkCTPIDCconsistency = true; ///< check the selected CTP or IDC scaling source being consistent with mean scaler of the map
-};
-}
-
 namespace gpu
 {
 
@@ -64,55 +30,129 @@ class CorrectionMapsHelper
   CorrectionMapsHelper() = default;
   ~CorrectionMapsHelper() { clear(); }
   CorrectionMapsHelper(const CorrectionMapsHelper&) = delete;
-  static tpc::CorrectionMapsLoaderGloOpts parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts);
-  void setUpdatedMap() { mUpdated = true; }
-  void clear()
+  void updateLumiScale(bool report = false);
+  void clear();
+
+  const o2::gpu::TPCFastTransform* getCorrMap() const { return mCorrMap; }
+  const o2::gpu::TPCFastTransform* getCorrMapRef() const { return mCorrMapRef; }
+  const o2::gpu::TPCFastTransform* getCorrMapMShape() const { return mCorrMapMShape.get(); }
+
+  void setCorrMap(o2::gpu::TPCFastTransform* m) { mCorrMap = m; }
+  void setCorrMapRef(o2::gpu::TPCFastTransform* m) { mCorrMapRef = m; }
+  void setCorrMapMShape(std::unique_ptr<o2::gpu::TPCFastTransform>&& m);
+
+  void reportScaling();
+  void setInstLumiCTP(float v)
   {
-    mCorrMap = nullptr;
-#if !defined(GPUCA_GPUCODE_DEVICE)
-    mCorrMapBuffer.clear();
-#endif
+    if (v != mInstLumiCTP) {
+      mInstLumiCTP = v;
+    }
   }
 
-  GPUd() void Transform(int32_t slice, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0) const
+  void setInstLumi(float v, bool report = false)
   {
-    mCorrMap->Transform(slice, row, pad, time, x, y, z, vertexTime);
+    if (v != mInstLumi) {
+      mInstLumi = v;
+      updateLumiScale(report);
+    }
   }
 
-  GPUd() void TransformXYZ(int32_t slice, int32_t row, float& x, float& y, float& z) const
+  void setMeanLumi(float v, bool report = false)
   {
-    mCorrMap->TransformXYZ(slice, row, x, y, z);
+    if (v != mMeanLumi) {
+      mMeanLumi = v;
+      updateLumiScale(report);
+    }
   }
 
-  GPUd() void InverseTransformYZtoX(int32_t slice, int32_t row, float y, float z, float& x) const
+  void setMeanLumiRef(float v, bool report = false)
   {
-    mCorrMap->InverseTransformYZtoX(slice, row, y, z, x);
+    if (v != mMeanLumiRef) {
+      mMeanLumiRef = v;
+      updateLumiScale(report);
+    }
   }
 
-  GPUd() void InverseTransformYZtoNominalYZ(int32_t slice, int32_t row, float y, float z, float& ny, float& nz) const
+  void setLumiScaleMode(tpc::LumiScaleMode v)
   {
-    mCorrMap->InverseTransformYZtoNominalYZ(slice, row, y, z, ny, nz);
+    if (v != mLumiScaleMode) {
+      mLumiScaleMode = v;
+      updateLumiScale(false);
+    }
   }
 
-  GPUd() const o2::gpu::TPCFastTransformPOD* getCorrMap() const { return mCorrMap; }
+  void setCheckCTPIDCConsistency(bool v) { mCheckCTPIDCConsistency = v; }
+  bool getCheckCTPIDCConsistency() const { return mCheckCTPIDCConsistency; }
 
   float getInstLumiCTP() const { return mInstLumiCTP; }
-
-  bool isUpdated() const { return mUpdated; }
-  void acknowledgeUpdate() { mUpdated = false; }
-  void setCorrMap(const o2::gpu::TPCFastTransformPOD* m); // always non-owning
-#if !defined(GPUCA_GPUCODE_DEVICE)
-  void setCorrMap(std::vector<char>&& buffer); // owning
-#endif
+  float getInstLumi() const { return mInstLumi; }
+  float getMeanLumi() const { return mMeanLumi; }
+  float getMeanLumiRef() const { return mMeanLumiRef; }
+
+  float getLumiScale() const { return mLumiScale; }
+  tpc::LumiScaleMode getLumiScaleMode() const { return mLumiScaleMode; }
+
+  bool isUpdated() const { return mUpdatedFlags != 0; }
+  bool isUpdatedMap() const { return (mUpdatedFlags & UpdateFlags::MapBit) != 0; }
+  bool isUpdatedMapRef() const { return (mUpdatedFlags & UpdateFlags::MapRefBit) != 0; }
+  bool isUpdatedMapMShape() const { return (mUpdatedFlags & UpdateFlags::MapMShapeBit) != 0; }
+  bool isUpdatedLumi() const { return (mUpdatedFlags & UpdateFlags::LumiBit) != 0; }
+  void setUpdatedMap() { mUpdatedFlags |= UpdateFlags::MapBit; }
+  void setUpdatedMapRef() { mUpdatedFlags |= UpdateFlags::MapRefBit; }
+  void setUpdatedMapMShape() { mUpdatedFlags |= UpdateFlags::MapMShapeBit; }
+  void setUpdatedLumi() { mUpdatedFlags |= UpdateFlags::LumiBit; }
+  void acknowledgeUpdate() { mUpdatedFlags = 0; }
+  void setLumiCTPAvailable(bool v) { mLumiCTPAvailable = v; }
+  bool getLumiCTPAvailable() const { return mLumiCTPAvailable; }
+  void setLumiScaleType(tpc::LumiScaleType v) { mLumiScaleType = v; }
+  tpc::LumiScaleType getLumiScaleType() const { return mLumiScaleType; }
+  void enableMShapeCorrection(bool v) { mEnableMShape = v; }
+  bool getUseMShapeCorrection() const { return mEnableMShape; }
+  bool canUseCorrections() const { return mMeanLumi >= 0.; }
+  void setMeanLumiOverride(float f) { mMeanLumiOverride = f; }
+  void setMeanLumiRefOverride(float f) { mMeanLumiRefOverride = f; }
+  float getMeanLumiOverride() const { return mMeanLumiOverride; }
+  float getMeanLumiRefOverride() const { return mMeanLumiRefOverride; }
+
+  void setInstCTPLumiOverride(float f) { mInstCTPLumiOverride = f; }
+  float getInstCTPLumiOverride() const { return mInstCTPLumiOverride; }
+
+  int32_t getUpdateFlags() const { return mUpdatedFlags; }
+
+  /// return returns if the correction map for the M-shape correction is a dummy spline object
+  bool isCorrMapMShapeDummy() const
+  {
+    if (mCorrMapMShape) {
+      // just check for the first spline the number of knots which are 4 in case of default spline object
+      return mCorrMapMShape->getCorrection().getSpline(0, 0).getNumberOfKnots() == 4;
+    }
+    return true;
+  }
 
  protected:
-  bool mUpdated = false;                                 // flag indicating whether the map was updated
-  float mInstLumiCTP{-1.f};                              // current CTP luminosity - used for track covariance tuning in downstream devices
-  const o2::gpu::TPCFastTransformPOD* mCorrMap{nullptr}; // current transform
-#if !defined(GPUCA_GPUCODE_DEVICE)
-  std::vector<char> mCorrMapBuffer;
-#endif
-  ClassDefNV(CorrectionMapsHelper, 1);
+  enum UpdateFlags { MapBit = 0x1,
+                     MapRefBit = 0x2,
+                     LumiBit = 0x4,
+                     MapMShapeBit = 0x10 };
+  bool mLumiCTPAvailable = false; // is CTP Lumi available
+  // these 2 are global options, must be set by the workflow global options
+  tpc::LumiScaleType mLumiScaleType = tpc::LumiScaleType::Unset; // use CTP Lumi (1) or TPCScaler (2) for the correction scaling, 0 - no scaling
+  tpc::LumiScaleMode mLumiScaleMode = tpc::LumiScaleMode::Unset; // scaling-mode of the correction maps: 0 = linear scaling, 1 = using the derivative map, 2 = using the derivative map for MC (i.e. only apply the scaled derivative on top of the reference map)
+  int32_t mUpdatedFlags = 0;
+  float mInstLumiCTP = 0.;                                            // instanteneous luminosity from CTP (a.u)
+  float mInstLumi = 0.;                                               // instanteneous luminosity (a.u) used for TPC corrections scaling
+  float mMeanLumi = 0.;                                               // mean luminosity of the map (a.u) used for TPC corrections scaling
+  float mMeanLumiRef = 0.;                                            // mean luminosity of the ref map (a.u) used for TPC corrections scaling reference
+  float mLumiScale = 0.;                                              // precalculated mInstLumi/mMeanLumi
+  float mMeanLumiOverride = -1.f;                                     // optional value to override mean lumi
+  float mMeanLumiRefOverride = -1.f;                                  // optional value to override ref mean lumi
+  float mInstCTPLumiOverride = -1.f;                                  // optional value to override inst lumi from CTP
+  bool mEnableMShape = false;                                         ///< use v shape correction
+  bool mCheckCTPIDCConsistency{true};                                 // check of selected CTP or IDC scaling source being consistent with the map
+  o2::gpu::TPCFastTransform* mCorrMap{nullptr};                       // current transform
+  o2::gpu::TPCFastTransform* mCorrMapRef{nullptr};                    // reference transform
+  std::unique_ptr<o2::gpu::TPCFastTransform> mCorrMapMShape{nullptr}; // correction map for M-shape distortions on A-side
+  ClassDefNV(CorrectionMapsHelper, 6);
 };
 
 } // namespace gpu
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelperFull.cxx b/GPU/TPCFastTransformation/CorrectionMapsHelperFull.cxx
deleted file mode 100644
index 93b0e9185351e..0000000000000
--- a/GPU/TPCFastTransformation/CorrectionMapsHelperFull.cxx
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include "CorrectionMapsHelperFull.h"
-#include "Framework/Logger.h"
-
-using namespace o2::gpu;
-using namespace o2::tpc;
-
-//________________________________________________________
-void CorrectionMapsHelperFull::clear()
-{
-  mLumiCTPAvailable = false;
-  mCorrMap = nullptr;
-  mCorrMapRef = nullptr;
-  mCorrMapMShape.reset();
-  mUpdatedFlags = 0;
-  mInstLumiCTP = 0.f;
-  mInstLumi = 0.f;
-  mMeanLumi = 0.f;
-  mMeanLumiRef = 0.f;
-}
-
-void CorrectionMapsHelperFull::setCorrMapMShape(std::unique_ptr<TPCFastTransform>&& m)
-{
-  setUpdatedMapMShape();
-  mCorrMapMShape = std::move(m);
-}
-
-void CorrectionMapsHelperFull::updateLumiScale(bool report)
-{
-  if (!canUseCorrections()) {
-    mLumiScale = -1.f;
-  } else if ((mLumiScaleMode == LumiScaleMode::DerivativeMap) || (mLumiScaleMode == LumiScaleMode::DerivativeMapMC)) {
-    mLumiScale = mMeanLumiRef ? (mInstLumi - mMeanLumi) / mMeanLumiRef : 0.f;
-    LOGP(debug, "mInstLumi: {}  mMeanLumi: {} mMeanLumiRef: {}", mInstLumi, mMeanLumi, mMeanLumiRef);
-  } else {
-    mLumiScale = mMeanLumi ? mInstLumi / mMeanLumi : 0.f;
-  }
-  setUpdatedLumi();
-  if (report) {
-    reportScaling();
-  }
-}
-
-//________________________________________________________
-void CorrectionMapsHelperFull::reportScaling()
-{
-  LOGP(info, "Map scaling update: LumiScaleType={} instLumi(CTP)={} instLumi(scaling)={} meanLumiRef={}, meanLumi={} -> LumiScale={} lumiScaleMode={}, M-Shape map valid: {}, M-Shape default: {}",
-       mLumiScaleType == LumiScaleType::NoScaling ? "NoScaling" : (mLumiScaleType == LumiScaleType::CTPLumi ? "LumiCTP" : "TPCScaler"), getInstLumiCTP(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(),
-       mLumiScaleMode == LumiScaleMode::Linear ? "Linear" : "Derivative", (mCorrMapMShape != nullptr), isCorrMapMShapeDummy());
-}
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelperFull.h b/GPU/TPCFastTransformation/CorrectionMapsHelperFull.h
deleted file mode 100644
index 090b567bb2407..0000000000000
--- a/GPU/TPCFastTransformation/CorrectionMapsHelperFull.h
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file CorrectionMapsHelperFull.h
-/// \brief Helper class to access correction maps
-/// \author ruben.shahoian@cern.ch matthias.kleiner@cern.ch
-
-#ifndef TPC_CORRECTION_MAPS_HELPERFULL_H_
-#define TPC_CORRECTION_MAPS_HELPERFULL_H_
-
-#include "TPCFastTransform.h"
-#include "CorrectionMapsHelper.h"
-
-namespace o2
-{
-namespace gpu
-{
-
-class CorrectionMapsHelperFull
-{
- public:
-  CorrectionMapsHelperFull() = default;
-  ~CorrectionMapsHelperFull() { clear(); }
-  CorrectionMapsHelperFull(const CorrectionMapsHelperFull&) = delete;
-  void updateLumiScale(bool report = false);
-  void clear();
-
-  const o2::gpu::TPCFastTransform* getCorrMap() const { return mCorrMap; }
-  const o2::gpu::TPCFastTransform* getCorrMapRef() const { return mCorrMapRef; }
-  const o2::gpu::TPCFastTransform* getCorrMapMShape() const { return mCorrMapMShape.get(); }
-
-  void setCorrMap(o2::gpu::TPCFastTransform* m) { mCorrMap = m; }
-  void setCorrMapRef(o2::gpu::TPCFastTransform* m) { mCorrMapRef = m; }
-  void setCorrMapMShape(std::unique_ptr<o2::gpu::TPCFastTransform>&& m);
-
-  void reportScaling();
-  void setInstLumiCTP(float v)
-  {
-    if (v != mInstLumiCTP) {
-      mInstLumiCTP = v;
-    }
-  }
-
-  void setInstLumi(float v, bool report = false)
-  {
-    if (v != mInstLumi) {
-      mInstLumi = v;
-      updateLumiScale(report);
-    }
-  }
-
-  void setMeanLumi(float v, bool report = false)
-  {
-    if (v != mMeanLumi) {
-      mMeanLumi = v;
-      updateLumiScale(report);
-    }
-  }
-
-  void setMeanLumiRef(float v, bool report = false)
-  {
-    if (v != mMeanLumiRef) {
-      mMeanLumiRef = v;
-      updateLumiScale(report);
-    }
-  }
-
-  void setLumiScaleMode(tpc::LumiScaleMode v)
-  {
-    if (v != mLumiScaleMode) {
-      mLumiScaleMode = v;
-      updateLumiScale(false);
-    }
-  }
-
-  void setCheckCTPIDCConsistency(bool v) { mCheckCTPIDCConsistency = v; }
-  bool getCheckCTPIDCConsistency() const { return mCheckCTPIDCConsistency; }
-
-  float getInstLumiCTP() const { return mInstLumiCTP; }
-  float getInstLumi() const { return mInstLumi; }
-  float getMeanLumi() const { return mMeanLumi; }
-  float getMeanLumiRef() const { return mMeanLumiRef; }
-
-  float getLumiScale() const { return mLumiScale; }
-  tpc::LumiScaleMode getLumiScaleMode() const { return mLumiScaleMode; }
-
-  bool isUpdated() const { return mUpdatedFlags != 0; }
-  bool isUpdatedMap() const { return (mUpdatedFlags & UpdateFlags::MapBit) != 0; }
-  bool isUpdatedMapRef() const { return (mUpdatedFlags & UpdateFlags::MapRefBit) != 0; }
-  bool isUpdatedMapMShape() const { return (mUpdatedFlags & UpdateFlags::MapMShapeBit) != 0; }
-  bool isUpdatedLumi() const { return (mUpdatedFlags & UpdateFlags::LumiBit) != 0; }
-  void setUpdatedMap() { mUpdatedFlags |= UpdateFlags::MapBit; }
-  void setUpdatedMapRef() { mUpdatedFlags |= UpdateFlags::MapRefBit; }
-  void setUpdatedMapMShape() { mUpdatedFlags |= UpdateFlags::MapMShapeBit; }
-  void setUpdatedLumi() { mUpdatedFlags |= UpdateFlags::LumiBit; }
-  void acknowledgeUpdate() { mUpdatedFlags = 0; }
-  void setLumiCTPAvailable(bool v) { mLumiCTPAvailable = v; }
-  bool getLumiCTPAvailable() const { return mLumiCTPAvailable; }
-  void setLumiScaleType(tpc::LumiScaleType v) { mLumiScaleType = v; }
-  tpc::LumiScaleType getLumiScaleType() const { return mLumiScaleType; }
-  void enableMShapeCorrection(bool v) { mEnableMShape = v; }
-  bool getUseMShapeCorrection() const { return mEnableMShape; }
-  bool canUseCorrections() const { return mMeanLumi >= 0.; }
-  void setMeanLumiOverride(float f) { mMeanLumiOverride = f; }
-  void setMeanLumiRefOverride(float f) { mMeanLumiRefOverride = f; }
-  float getMeanLumiOverride() const { return mMeanLumiOverride; }
-  float getMeanLumiRefOverride() const { return mMeanLumiRefOverride; }
-
-  void setInstCTPLumiOverride(float f) { mInstCTPLumiOverride = f; }
-  float getInstCTPLumiOverride() const { return mInstCTPLumiOverride; }
-
-  int32_t getUpdateFlags() const { return mUpdatedFlags; }
-
-  /// return returns if the correction map for the M-shape correction is a dummy spline object
-  bool isCorrMapMShapeDummy() const
-  {
-    if (mCorrMapMShape) {
-      // just check for the first spline the number of knots which are 4 in case of default spline object
-      return mCorrMapMShape->getCorrection().getSpline(0, 0).getNumberOfKnots() == 4;
-    }
-    return true;
-  }
-
- protected:
-  enum UpdateFlags { MapBit = 0x1,
-                     MapRefBit = 0x2,
-                     LumiBit = 0x4,
-                     MapMShapeBit = 0x10 };
-  bool mLumiCTPAvailable = false; // is CTP Lumi available
-  // these 2 are global options, must be set by the workflow global options
-  tpc::LumiScaleType mLumiScaleType = tpc::LumiScaleType::Unset; // use CTP Lumi (1) or TPCScaler (2) for the correction scaling, 0 - no scaling
-  tpc::LumiScaleMode mLumiScaleMode = tpc::LumiScaleMode::Unset; // scaling-mode of the correction maps: 0 = linear scaling, 1 = using the derivative map, 2 = using the derivative map for MC (i.e. only apply the scaled derivative on top of the reference map)
-  int32_t mUpdatedFlags = 0;
-  float mInstLumiCTP = 0.;                            // instanteneous luminosity from CTP (a.u)
-  float mInstLumi = 0.;                               // instanteneous luminosity (a.u) used for TPC corrections scaling
-  float mMeanLumi = 0.;                               // mean luminosity of the map (a.u) used for TPC corrections scaling
-  float mMeanLumiRef = 0.;                            // mean luminosity of the ref map (a.u) used for TPC corrections scaling reference
-  float mLumiScale = 0.;                              // precalculated mInstLumi/mMeanLumi
-  float mMeanLumiOverride = -1.f;                     // optional value to override mean lumi
-  float mMeanLumiRefOverride = -1.f;                  // optional value to override ref mean lumi
-  float mInstCTPLumiOverride = -1.f;                  // optional value to override inst lumi from CTP
-  bool mEnableMShape = false;                         ///< use v shape correction
-  bool mCheckCTPIDCConsistency{true};                 // check of selected CTP or IDC scaling source being consistent with the map
-  o2::gpu::TPCFastTransform* mCorrMap{nullptr};       // current transform
-  o2::gpu::TPCFastTransform* mCorrMapRef{nullptr};    // reference transform
-  std::unique_ptr<o2::gpu::TPCFastTransform> mCorrMapMShape{nullptr}; // correction map for M-shape distortions on A-side
-  ClassDefNV(CorrectionMapsHelperFull, 6);
-};
-
-} // namespace gpu
-} // namespace o2
-
-#endif
diff --git a/GPU/TPCFastTransformation/CorrectionMapsTypes.h b/GPU/TPCFastTransformation/CorrectionMapsTypes.h
new file mode 100644
index 0000000000000..1ebb40c45c1a4
--- /dev/null
+++ b/GPU/TPCFastTransformation/CorrectionMapsTypes.h
@@ -0,0 +1,48 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CorrectionMapsTypes.h
+/// \brief Helper class for enums and structs related to the correction maps
+/// \author matthias.kleiner@cern.ch
+
+#ifndef TPC_CORRECTION_MAPS_TYPES_H_
+#define TPC_CORRECTION_MAPS_TYPES_H_
+
+namespace o2
+{
+
+namespace tpc
+{
+enum class LumiScaleType : int {
+  Unset = -1,    ///< init value
+  NoScaling = 0, ///< no scaling, use map as is
+  CTPLumi = 1,   ///< use CTP luminosity for scaling
+  TPCScaler = 2  ///< use TPC scaler for scaling
+};
+
+enum class LumiScaleMode : int {
+  Unset = -1,         ///< init value
+  Linear = 0,         ///< map(lumi) = (mean_map - referenceMap) * lumiScale + referenceMap
+  DerivativeMap = 1,  ///< map(lumi) = mean_map + lumiScale * (derivativeMap) where derivativeMap = (mean_map_A - mean_map_B)
+  DerivativeMapMC = 2 ///< same DerivativeMap, but for MC
+};
+
+struct CorrectionMapsGloOpts {
+  LumiScaleType lumiType = LumiScaleType::Unset; ///< what estimator to used for corrections scaling: 0: no scaling, 1: CTP, 2: IDC
+  LumiScaleMode lumiMode = LumiScaleMode::Unset; ///< what corrections method to use: 0: classical scaling, 1: Using of the derivative map, 2: Using of the derivative map for MC
+  bool enableMShapeCorrection = false;
+  bool requestCTPLumi = true;         ///< request CTP Lumi regardless of what is used for corrections scaling
+  bool checkCTPIDCconsistency = true; ///< check the selected CTP or IDC scaling source being consistent with mean scaler of the map
+};
+} // namespace tpc
+} // namespace o2
+
+#endif
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index d06fd8921b60a..26147ef926df0 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -544,17 +544,9 @@ class Spline2DSpec<DataT, YdimT, 0>
 
     // getSderivativesOverParsAtU() is pure math on the Knot struct fields {u, Li}.
     // It does NOT touch mFlatBufferPtr, so it is safe on the zero-copy path.
-    auto val1 = mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u);
-    auto val2 = mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v);
-
-    const auto& dSl = val1[0];
-    const auto& dDl = val1[1];
-    const auto& dSr = val1[2];
-    const auto& dDr = val1[3];
-    const auto& dSd = val2[0];
-    const auto& dDd = val2[1];
-    const auto& dSu = val2[2];
-    const auto& dDu = val2[3];
+    DataT dSl, dDl, dSr, dDr, dSd, dDd, dSu, dDu;
+    mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u, dSl, dDl, dSr, dDr);
+    mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v, dSd, dDd, dSu, dDu);
 
     DataT a[8] = {dSl * dSd, dSl * dDd, dDl * dSd, dDl * dDd,
                   dSr * dSd, dSr * dDd, dDr * dSd, dDr * dDd};
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index 1a6a695e68dcf..578dc31410d3c 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -255,9 +255,10 @@ class TPCFastTransformPOD
   static size_t estimateSize(const TPCFastSpaceChargeCorrection& origCorr);
   static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastTransform& src);
   static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastSpaceChargeCorrection& src);
-  static TPCFastTransformPOD& getNonConst(char* head) { return *reinterpret_cast<TPCFastTransformPOD*>(head); }
+  GPUd() static TPCFastTransformPOD& getNonConst(char* head) { return *reinterpret_cast<TPCFastTransformPOD*>(head); }
 #endif
 
+  ///< get address to which the offset in bytes must be added to arrive to particular dynamic part
   GPUd() const char* getThis() const { return reinterpret_cast<const char*>(this); }
 
   ///< return offset of the spline object start (equivalent of mScenarioPtr in the TPCFastSpaceChargeCorrection)
@@ -316,7 +317,7 @@ GPUdi() void TPCFastTransformPOD::getCorrectionLocal(int32_t sector, int32_t row
   const char* g2buf = getGridX2FlatBuffer(spline, isc);
 
   float dxyz[3];
-  spline.interpolateAtUZeroCopy(g1buf, g2buf, splineData, val[0], val[1], dxyz);
+  spline.interpolateAtUZeroCopy(g1buf, g2buf, splineData, u, v, dxyz);
 
   if (CAMath::Abs(dxyz[0]) > 100.f || CAMath::Abs(dxyz[1]) > 100.f || CAMath::Abs(dxyz[2]) > 100.f) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
@@ -819,7 +820,6 @@ GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX(int32_t sector, int32_t
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoX").data()
                                                                                        << "sector=" << sector
                                                                                        << "row=" << row
-                                                                                       << "scale=" << scale
                                                                                        << "y=" << realY
                                                                                        << "z=" << realZ
                                                                                        << "x=" << realX
@@ -887,7 +887,6 @@ GPUdi() void TPCFastTransformPOD::InverseTransformYZtoNominalYZ(int32_t sector,
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoNominalYZ").data()
                                                                                        << "sector=" << sector
                                                                                        << "row=" << row
-                                                                                       << "scale=" << scale
                                                                                        << "real y=" << realY
                                                                                        << "real z=" << realZ
                                                                                        << "measured y=" << measuredY
@@ -959,24 +958,20 @@ GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ_new(int32_t se
 GPUdi() void TPCFastTransformPOD::convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const
 {
   float l = (time - mT0 - vertexTime) * mVdrift;
-  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
-  y = localval[0];
-  z = localval[1];
+  getGeometry().convPadDriftLengthToLocal(sector, row, pad, l, y, z);
 }
 
 GPUdi() void TPCFastTransformPOD::convPadTimeToLocalInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float maxTimeBin) const
 {
   float l = getGeometry().getTPCzLength() + (time - mT0 - maxTimeBin) * mVdrift;
-  const auto localval = getGeometry().convPadDriftLengthToLocal(sector, row, pad, l);
-  y = localval[0];
-  z = localval[1];
+  getGeometry().convPadDriftLengthToLocal(sector, row, pad, l, y, z);
 }
 
 GPUdi() void TPCFastTransformPOD::convLocalToPadTimeInTimeFrame(int32_t sector, int32_t row, float y, float z, float& pad, float& time, float maxTimeBin) const
 {
-  const auto padLength = getGeometry().convLocalToPadDriftLength(sector, row, y, z);
-  pad = padLength[0];
-  time = convDriftLengthToTime(padLength[1], maxTimeBin);
+  float length = 0;
+  getGeometry().convLocalToPadDriftLength(sector, row, y, z, pad, length);
+  time = convDriftLengthToTime(length, maxTimeBin);
 }
 
 GPUdi() float TPCFastTransformPOD::convDriftLengthToTime(float driftLength, float vertexTime) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index 0247bbbfbb65b..8b0a07c28ea6c 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -89,7 +89,6 @@
 #pragma read \
   sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "float fInterpolationSafetyMargin" version = "[-3]" target = "" code = "{}";
 
-#pragma link C++ class o2::gpu::CorrectionMapsHelper + ;
 #pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
 #pragma link C++ struct o2::gpu::NDPiecewisePolynomialContainer + ;
 #pragma link C++ struct o2::gpu::TPCSlowSpaceChargeCorrection + ;
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index b492b1c84a11a..d53787212bb9a 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -155,10 +155,13 @@ class GPURecoWorkflowSpec : public o2::framework::Task
  private:
   struct calibObjectStruct {
     std::vector<char> mUpdatedTransformBuffer;
-    std::unique_ptr<TPCFastTransformPOD> mFastTransform;
-    std::unique_ptr<o2::tpc::CorrectionMapsLoader> mFastTransformHelper;
+    const TPCFastTransformPOD* mFastTransform{nullptr};
     std::unique_ptr<TPCPadGainCalib> mTPCPadGainCalib;
     std::unique_ptr<o2::tpc::CalibdEdxContainer> mdEdxCalibContainer;
+    float mInstLumiCTP{-1};
+    // #if !defined(GPUCA_GPUCODE_DEVICE)
+    std::vector<char> mCorrMapBuffer;
+    // #endif
   };
 
   /// initialize TPC options from command line
diff --git a/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h b/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
index 31e9520f3ae1f..cd9752053d7bb 100644
--- a/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
+++ b/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
@@ -32,16 +32,12 @@ namespace o2::itsmft
 {
 class TopologyDictionary;
 }
-namespace o2::tpc
-{
-class CorrectionMapsLoader;
-}
 
 namespace o2::gpu
 {
 class GPUO2InterfaceDisplay;
 struct GPUO2InterfaceConfiguration;
-class TPCFastTransform;
+class TPCFastTransformPOD;
 struct GPUSettingsTF;
 struct GPUSettingsO2;
 
@@ -63,12 +59,13 @@ class O2GPUDPLDisplaySpec : public o2::framework::Task
   bool mGRPGeomUpdated = false;
   bool mAutoContinuousMaxTimeBin = false;
   bool mGeometryCreated = false;
+  std::vector<char> mBufferFastTransform;
   o2::dataformats::GlobalTrackID::mask_t mTrkMask;
   o2::dataformats::GlobalTrackID::mask_t mClMask;
   std::unique_ptr<GPUO2InterfaceDisplay> mDisplay;
   std::unique_ptr<GPUO2InterfaceConfiguration> mConfig;
   std::unique_ptr<GPUSettingsO2> mConfParam;
-  std::unique_ptr<o2::tpc::CorrectionMapsLoader> mFastTransformHelper;
+  const o2::gpu::TPCFastTransformPOD* mFastTransform = nullptr;
   std::unique_ptr<o2::trd::GeometryFlat> mTrdGeo;
   std::unique_ptr<o2::itsmft::TopologyDictionary> mITSDict;
   std::shared_ptr<o2::globaltracking::DataRequest> mDataRequest;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index dbc8f229829a0..dda471ae05b38 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -39,7 +39,6 @@
 #include "TPCReconstruction/TPCTrackingDigitsPreCheck.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "DataFormatsTPC/Digit.h"
-#include "TPCFastTransform.h"
 #include "DPLUtils/DPLRawParser.h"
 #include "DPLUtils/DPLRawPageSequencer.h"
 #include "DetectorsBase/MatLayerCylSet.h"
@@ -63,8 +62,6 @@
 #include "TPCBase/Utils.h"
 #include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "CorrectionMapsHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCBaseRecSim/DeadChannelMapCreator.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 #include "SimulationDataFormat/MCCompLabel.h"
@@ -253,8 +250,8 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     // initialize TPC calib objects
     initFunctionTPCCalib(ic);
 
-    mConfig->configCalib.fastTransform = mCalibObjects.mFastTransformHelper->getCorrMap();
-    mConfig->configCalib.fastTransformHelper = mCalibObjects.mFastTransformHelper.get();
+    mConfig->configCalib.fastTransform = mCalibObjects.mFastTransform;
+    // mConfig->configCalib.buffer = mCalibObjects.mBuffer; // TODO WRONG
     if (mConfig->configCalib.fastTransform == nullptr) {
       throw std::invalid_argument("GPU workflow: initialization of the TPC transformation failed");
     }
@@ -1184,8 +1181,8 @@ Inputs GPURecoWorkflowSpec::inputs()
     inputs.emplace_back("tpctopologygain", gDataOriginTPC, "TOPOLOGYGAIN", 0, Lifetime::Condition, ccdbParamSpec(o2::tpc::CDBTypeMap.at(o2::tpc::CDBType::CalTopologyGain)));
     inputs.emplace_back("tpcthreshold", gDataOriginTPC, "PADTHRESHOLD", 0, Lifetime::Condition, ccdbParamSpec("TPC/Config/FEEPad"));
     o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
-    Options optsDummy;
-    mCalibObjects.mFastTransformHelper->requestInputs(inputs, optsDummy); // option filled here is lost
+    inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
+    inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
   }
   if (mSpecConfig.decompressTPC) {
     inputs.emplace_back(InputSpec{"input", ConcreteDataTypeMatcher{gDataOriginTPC, mSpecConfig.decompressTPCFromROOT ? o2::header::DataDescription("COMPCLUSTERS") : o2::header::DataDescription("COMPCLUSTERSFLAT")}, Lifetime::Timeframe});
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index 5188554cc9be8..9614f588338d7 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -36,7 +36,6 @@
 #include "TPCReconstruction/TPCTrackingDigitsPreCheck.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "DataFormatsTPC/Digit.h"
-#include "TPCFastTransform.h"
 #include "DetectorsBase/MatLayerCylSet.h"
 #include "DetectorsBase/Propagator.h"
 #include "DetectorsBase/GeometryManager.h"
@@ -58,8 +57,6 @@
 #include "TPCBase/Utils.h"
 #include "TPCBaseRecSim/CDBInterface.h"
 #include "TPCCalibration/VDriftHelper.h"
-#include "CorrectionMapsHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
 #include "TPCCalibration/IDCContainer.h"
 #include "TPCBaseRecSim/DeadChannelMapCreator.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
@@ -106,11 +103,11 @@ void GPURecoWorkflowSpec::initFunctionTPCCalib(InitContext& ic)
 
   mCalibObjects.mdEdxCalibContainer.reset(new o2::tpc::CalibdEdxContainer());
   mTPCVDriftHelper.reset(new o2::tpc::VDriftHelper());
-  mCalibObjects.mFastTransformHelper.reset(new o2::tpc::CorrectionMapsLoader());
 
   std::vector<char> buffer;
   gpu::TPCFastTransformPOD::create(buffer, *o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
-  mCalibObjects.mFastTransformHelper->setCorrMap(std::move(buffer));
+  mCalibObjects.mCorrMapBuffer = std::move(buffer);
+  mCalibObjects.mFastTransform = &TPCFastTransformPOD::get(mCalibObjects.mCorrMapBuffer.data());
 
   if (mConfParam->dEdxDisableTopologyPol) {
     LOGP(info, "Disabling loading of track topology correction using polynomials from CCDB");
@@ -347,29 +344,25 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
 
       if (mSpecConfig.outputTracks) {
         mTPCVDriftHelper->extractCCDBInputs(pc);
-        mCalibObjects.mFastTransformHelper->extractCCDBInputs(pc);
-      }
-      if (mCalibObjects.mFastTransformHelper->isUpdated()) {
-          // New map arrived from TPCScalerSpec — VDrift already baked in, just swap it
-          const auto& vd = mTPCVDriftHelper->getVDriftObject();
-          LOGP(info, "Updating new TPC fast transform map, VDrift factor {} wrt reference {} and TDrift offset {} wrt reference {} from source {}",
-              vd.corrFact, vd.refVDrift, vd.timeOffsetCorr, vd.refTimeOffset, mTPCVDriftHelper->getSourceName());
-
-          oldCalibObjects.mFastTransformHelper = std::move(mCalibObjects.mFastTransformHelper);
-          mCalibObjects.mFastTransformHelper.reset(new o2::tpc::CorrectionMapsLoader);
-          // copy buffer as-is — no updateCalibration, VDrift already embedded
-          std::vector<char> buf(oldCalibObjects.mFastTransformHelper->getCorrMap()->size());
-          std::memcpy(buf.data(), oldCalibObjects.mFastTransformHelper->getCorrMap(), buf.size());
-          mCalibObjects.mFastTransformHelper->setCorrMap(std::move(buf));
-          mCalibObjects.mFastTransformHelper->acknowledgeUpdate();
-          newCalibObjects.fastTransform = mCalibObjects.mFastTransformHelper->getCorrMap();
-          newCalibObjects.fastTransformHelper = mCalibObjects.mFastTransformHelper.get();
-          mustUpdate = true;
+        mCalibObjects.mInstLumiCTP = pc.inputs().get<float>("lumiCTP");
+
+        // get the raw buffer and reinterpret as TPCFastTransformPOD
+        oldCalibObjects.mFastTransform = mCalibObjects.mFastTransform;            // save OLD pointer ✓
+        oldCalibObjects.mCorrMapBuffer = std::move(mCalibObjects.mCorrMapBuffer); // OLD buffer alive ✓
+
+        auto const& raw = pc.inputs().get<const char*>("corrMap");
+        const auto* newMap = &gpu::TPCFastTransformPOD::get(raw); // NEW map from DPL
+        std::vector<char> buffer(newMap->size());
+        std::memcpy(buffer.data(), newMap, buffer.size()); // copy NEW map ✓
+        mCalibObjects.mCorrMapBuffer = std::move(buffer);
+        mCalibObjects.mFastTransform = &TPCFastTransformPOD::get(mCalibObjects.mCorrMapBuffer.data());
+        newCalibObjects.fastTransform = mCalibObjects.mFastTransform;
+        mustUpdate = true;
       }
       if (mTPCVDriftHelper->isUpdated()) {
-          // VDrift updated but no new map — just acknowledge, map already has correct VDrift
-          LOGP(info, "VDrift updated (factor {} wrt reference {} from source {}) but map already up to date", mTPCVDriftHelper->getVDriftObject().corrFact, mTPCVDriftHelper->getVDriftObject().refVDrift, mTPCVDriftHelper->getSourceName());
-          mTPCVDriftHelper->acknowledgeUpdate();
+        // VDrift updated but no new map — just acknowledge, map already has correct VDrift
+        LOGP(info, "VDrift updated (factor {} wrt reference {} from source {}) but map already up to date", mTPCVDriftHelper->getVDriftObject().corrFact, mTPCVDriftHelper->getVDriftObject().refVDrift, mTPCVDriftHelper->getSourceName());
+        mTPCVDriftHelper->acknowledgeUpdate();
       }
     }
 
@@ -416,7 +409,7 @@ void GPURecoWorkflowSpec::doTrackTuneTPC(GPUTrackingInOutPointers& ptrs, char* b
       throw std::runtime_error("Buffer does not match span");
     }
     o2::tpc::TrackTPC* tpcTracks = reinterpret_cast<o2::tpc::TrackTPC*>(buffout);
-    float scale = mCalibObjects.mFastTransformHelper->getInstLumiCTP();
+    float scale = mCalibObjects.mInstLumiCTP;
     if (scale < 0.f) {
       LOGP(warning, "Negative scale factor for TPC covariance correction, setting it to zero");
       scale = 0.f;
diff --git a/GPU/Workflow/src/O2GPUDPLDisplay.cxx b/GPU/Workflow/src/O2GPUDPLDisplay.cxx
index 7cfe83a5f5dde..b4f5b5abe48ed 100644
--- a/GPU/Workflow/src/O2GPUDPLDisplay.cxx
+++ b/GPU/Workflow/src/O2GPUDPLDisplay.cxx
@@ -24,10 +24,8 @@
 #include "GPUO2InterfaceDisplay.h"
 #include "GPUO2InterfaceUtils.h"
 #include "GPUO2InterfaceConfiguration.h"
-#include "TPCFastTransform.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
-#include "CorrectionMapsHelper.h"
-#include "TPCCalibration/CorrectionMapsLoader.h"
+#include "TPCFastTransformPOD.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "DataFormatsTPC/WorkflowHelper.h"
 #include "DataFormatsTRD/RecoInputContainer.h"
@@ -67,14 +65,11 @@ void O2GPUDPLDisplaySpec::init(InitContext& ic)
   mConfig->configGRP.solenoidBzNominalGPU = 0;
   mConfParam.reset(new GPUSettingsO2(mConfig->ReadConfigurableParam()));
 
-  mFastTransformHelper.reset(new o2::tpc::CorrectionMapsLoader());
-
   std::vector<char> buffer;
   gpu::TPCFastTransformPOD::create(buffer, *TPCFastTransformHelperO2::instance()->create(0));
-  mFastTransformHelper->setCorrMap(std::move(buffer));
-
-  mConfig->configCalib.fastTransform = mFastTransformHelper->getCorrMap();
-  mConfig->configCalib.fastTransformHelper = mFastTransformHelper.get();
+  mBufferFastTransform = std::move(buffer);
+  mFastTransform = &TPCFastTransformPOD::get(mBufferFastTransform.data());
+  mConfig->configCalib.fastTransform = mFastTransform;
 
   mTrdGeo.reset(new o2::trd::GeometryFlat());
   mConfig->configCalib.trdGeometry = mTrdGeo.get();
diff --git a/macro/runTPCRefit.C b/macro/runTPCRefit.C
index 02c79a8b369ed..a495ffe5987e3 100644
--- a/macro/runTPCRefit.C
+++ b/macro/runTPCRefit.C
@@ -17,7 +17,6 @@
 
 #include "TROOT.h"
 
-#include "CorrectionMapsHelper.h"
 #include "GPUO2InterfaceRefit.h"
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 #include "DataFormatsParameters/GRPObject.h"
@@ -30,6 +29,7 @@
 #include "DetectorsBase/GeometryManager.h"
 #include "DetectorsBase/Propagator.h"
 #include "CommonUtils/NameConf.h"
+#include "TPCFastTransformPOD.h"
 #else
 #pragma cling load("libO2TPCReconstruction")
 #pragma cling load("libO2DataFormatsTPC")
@@ -51,8 +51,9 @@ int runTPCRefit(TString trackFile = "tpctracks.root", TString clusterFile = "tpc
   Propagator::initFieldFromGRP(NameConf::getGRPFileName());
   const auto grp = o2::parameters::GRPObject::loadFrom("o2sim_grp.root");
   float bz = 5.00668f * grp->getL3Current() / 30000.;
-  o2::gpu::CorrectionMapsHelper transHelper;
-  transHelper.setCorrMap(TPCFastTransformHelperO2::instance()->create(0));
+  std::vector<char> buffer;
+  o2::gpu::TPCFastTransformPOD::create(buffer, *TPCFastTransformHelperO2::instance()->create(0));
+  const TPCFastTransformPOD corrMap = o2::gpu::TPCFastTransformPOD::get(buffer.data());
   auto* prop = Propagator::Instance();
 
   ClusterNativeAccess clusterIndex;
@@ -87,7 +88,7 @@ int runTPCRefit(TString trackFile = "tpctracks.root", TString clusterFile = "tpc
       std::cout << "Error reading clusters (code " << retVal << ")\n";
       return 1;
     }
-    GPUO2InterfaceRefit refit(&clusterIndex, &transHelper, bz, trackHitRefs->data(), 0, nullptr, nullptr, -1, tracks, prop);
+    GPUO2InterfaceRefit refit(&clusterIndex, corrMap, bz, trackHitRefs->data(), 0, nullptr, nullptr, -1, tracks, prop);
     //refit.setGPUTrackFitInProjections(false); // Enable full 3D fit without assuming y and Z are uncorrelated
     for (unsigned int i = 0; i < tracks->size(); i++) {
       TrackTPC trk = (*tracks)[i];

From 372298e3a4ff2af0383947be87e2ad0181f8a1c2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 3 Apr 2026 10:30:17 +0200
Subject: [PATCH 1589/1764] GPU TPCTransform: new POD transform does not need
 support for applying multiple maps at once, simplify and remove _new
 functions

---
 .../TPCFastTransformPOD.h                     | 323 ++----------------
 1 file changed, 35 insertions(+), 288 deletions(-)

diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index 578dc31410d3c..396a6608c695d 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -60,11 +60,8 @@ class TPCFastTransformPOD
   /// _______________ high level methods a la TPCFastTransform  _______________________
   ///
   // Methods taking extra reference transform are legacy compound transforms used to scale corrections.
-  GPUd() void Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
-  GPUd() void TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
-
-  GPUd() void Transform_new(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0) const;
-  GPUd() void TransformXYZ_new(int32_t sector, int32_t row, float& x, float& y, float& z) const;
+  GPUd() void Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime = 0) const;
+  GPUd() void TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z) const;
 
   /// Transformation in the time frame
   GPUd() void TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const;
@@ -75,16 +72,13 @@ class TPCFastTransformPOD
   GPUd() float InverseTransformInTimeFrame(int32_t sector, float z, float maxTimeBin) const;
 
   /// Inverse transformation: Transformed Y and Z -> transformed X
-  GPUd() void InverseTransformYZtoX(int32_t sector, int32_t row, float y, float z, float& x, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
-  GPUd() void InverseTransformYZtoX_new(int32_t sector, int32_t row, float y, float z, float& x) const;
+  GPUd() void InverseTransformYZtoX(int32_t sector, int32_t row, float y, float z, float& x) const;
 
   /// Inverse transformation: Transformed Y and Z -> Y and Z, transformed w/o space charge correction
-  GPUd() void InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float y, float z, float& ny, float& nz, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
-  GPUd() void InverseTransformYZtoNominalYZ_new(int32_t sector, int32_t row, float y, float z, float& ny, float& nz) const;
+  GPUd() void InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float y, float z, float& ny, float& nz) const;
 
   /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
-  GPUd() void InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransformPOD* ref = nullptr, const TPCFastTransformPOD* ref2 = nullptr, float scale = 0.f, float scale2 = 0.f, int32_t scaleMode = 0) const;
-  GPUd() void InverseTransformXYZtoNominalXYZ_new(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz) const;
+  GPUd() void InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz) const;
 
   /// Ideal transformation with Vdrift only - without calibration
   GPUd() void TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const;
@@ -190,7 +184,6 @@ class TPCFastTransformPOD
   GPUd() void getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ) const;
 
   /// transformation in the sector local frame
-  GPUd() void TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const;
   GPUd() void TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z) const;
 
   /// _______________  Utilities  _______________________________________________
@@ -461,125 +454,6 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(V& destVector, const TPCFastSpa
 }
 #endif
 
-GPUdi() void TPCFastTransformPOD::TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
-{
-  GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
-
-  if (!mApplyCorrection) {
-    return;
-  }
-
-  float dx = 0.f, dy = 0.f, dz = 0.f;
-
-  if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    getCorrectionLocal(sector, row, y, z, dx, dy, dz);
-    if (ref) {
-      if ((scale > 0.f) && (scaleMode == 0)) { // scaling was requested
-        float val[3];
-        ref->getCorrectionLocal(sector, row, y, z, val[0], val[1], val[2]);
-        dx = (dx - val[0]) * scale + val[0];
-        dy = (dy - val[1]) * scale + val[1];
-        dz = (dz - val[2]) * scale + val[2];
-      } else if ((scale != 0.f) && ((scaleMode == 1) || (scaleMode == 2))) {
-        float val[3];
-        ref->getCorrectionLocal(sector, row, y, z, val[0], val[1], val[2]);
-        dx = val[0] * scale + dx;
-        dy = val[1] * scale + dy;
-        dz = val[2] * scale + dz;
-      }
-    }
-    if (ref2 && (scale2 != 0)) {
-      float val[3];
-      ref2->getCorrectionLocal(sector, row, y, z, val[0], val[1], val[2]);
-      dx = val[0] * scale2 + dx;
-      dy = val[1] * scale2 + dy;
-      dz = val[2] * scale2 + dz;
-    }
-  }
-
-  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
-    float lx = x, ly = y, lz = z;
-
-    float gx, gy, gz;
-    getGeometry().convLocalToGlobal(sector, lx, ly, lz, gx, gy, gz);
-
-    float lxT = lx + dx;
-    float lyT = ly + dy;
-    float lzT = lz + dz;
-
-    float invYZtoXScaled;
-    InverseTransformYZtoX(sector, row, lyT, lzT, invYZtoXScaled, ref, ref2, scale, scale2, scaleMode);
-
-    float invYZtoX;
-    InverseTransformYZtoX(sector, row, lyT, lzT, invYZtoX);
-
-    float YZtoNominalY;
-    float YZtoNominalZ;
-    InverseTransformYZtoNominalYZ(sector, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
-
-    float YZtoNominalYScaled;
-    float YZtoNominalZScaled;
-    InverseTransformYZtoNominalYZ(sector, row, lyT, lzT, YZtoNominalYScaled, YZtoNominalZScaled, ref, ref2, scale, scale2, scaleMode);
-
-    float dxRef = 0.f, dyRef = 0.f, dzRef = 0.f;
-    if (ref) {
-      ref->getCorrectionLocal(sector, row, y, z, dxRef, dyRef, dzRef);
-    }
-
-    float dxRef2 = 0.f, dyRef2 = 0.f, dzRef2 = 0.f;
-    if (ref2) {
-      ref2->getCorrectionLocal(sector, row, y, z, dxRef2, dyRef2, dzRef2);
-    }
-
-    float dxOrig, dyOrig, dzOrig;
-    getCorrectionLocal(sector, row, y, z, dyOrig, dyOrig, dzOrig);
-
-    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
-                                                                                       // corrections in x, u, v
-                                                                                       << "dxOrig=" << dxOrig
-                                                                                       << "dyOrig=" << dyOrig
-                                                                                       << "dzOrig=" << dzOrig
-                                                                                       << "dxRef=" << dxRef
-                                                                                       << "dyRef=" << dyRef
-                                                                                       << "dzRef=" << dzRef
-                                                                                       << "dxRef2=" << dxRef2
-                                                                                       << "dyRef2=" << dyRef2
-                                                                                       << "dzRef2=" << dzRef2
-                                                                                       << "dx=" << dx
-                                                                                       << "dy=" << dy
-                                                                                       << "dz=" << dz
-                                                                                       << "row=" << row
-                                                                                       << "sector=" << sector
-                                                                                       << "scale=" << scale
-                                                                                       << "scale2=" << scale2
-                                                                                       // original local coordinates
-                                                                                       << "ly=" << ly
-                                                                                       << "lz=" << lz
-                                                                                       << "lx=" << lx
-                                                                                       // corrected local coordinated
-                                                                                       << "lxT=" << lxT
-                                                                                       << "lyT=" << lyT
-                                                                                       << "lzT=" << lzT
-                                                                                       // global uncorrected coordinates
-                                                                                       << "gx=" << gx
-                                                                                       << "gy=" << gy
-                                                                                       << "gz=" << gz
-                                                                                       // some transformations which are applied
-                                                                                       << "invYZtoX=" << invYZtoX
-                                                                                       << "invYZtoXScaled=" << invYZtoXScaled
-                                                                                       << "YZtoNominalY=" << YZtoNominalY
-                                                                                       << "YZtoNominalYScaled=" << YZtoNominalYScaled
-                                                                                       << "YZtoNominalZ=" << YZtoNominalZ
-                                                                                       << "YZtoNominalZScaled=" << YZtoNominalZScaled
-                                                                                       << "scaleMode=" << scaleMode
-                                                                                       << "\n";
-  })
-
-  x += dx;
-  y += dy;
-  z += dz;
-}
-
 GPUdi() void TPCFastTransformPOD::TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z) const
 {
   if (!mApplyCorrection) {
@@ -596,11 +470,11 @@ GPUdi() void TPCFastTransformPOD::TransformLocal(int32_t sector, int32_t row, fl
     float lyT = ly + dy;
     float lzT = lz + dz;
     float invYZtoX;
-    InverseTransformYZtoX_new(sector, row, lyT, lzT, invYZtoX);
+    InverseTransformYZtoX(sector, row, lyT, lzT, invYZtoX);
 
     float YZtoNominalY;
     float YZtoNominalZ;
-    InverseTransformYZtoNominalYZ_new(sector, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
+    InverseTransformYZtoNominalYZ(sector, row, lyT, lzT, YZtoNominalY, YZtoNominalZ);
 
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_Transform").data()
                                                                                        // corrections in x, u, v
@@ -633,7 +507,7 @@ GPUdi() void TPCFastTransformPOD::TransformLocal(int32_t sector, int32_t row, fl
   z += dz;
 }
 
-GPUdi() void TPCFastTransformPOD::Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransformPOD::Transform(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
 {
   /// _______________ The main method: cluster transformation _______________________
   ///
@@ -642,34 +516,12 @@ GPUdi() void TPCFastTransformPOD::Transform(int32_t sector, int32_t row, float p
   ///
 
   const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-
-  x = rowInfo.x;
-  convPadTimeToLocal(sector, row, pad, time, y, z, vertexTime);
-  TransformLocal(sector, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
-}
-
-GPUdi() void TPCFastTransformPOD::Transform_new(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
-{
-  /// _______________ The main method: cluster transformation _______________________
-  ///
-  /// Transforms raw TPC coordinates to local XYZ withing a sector
-  /// taking calibration into account.
-  ///
-
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-
   x = rowInfo.x;
   convPadTimeToLocal(sector, row, pad, time, y, z, vertexTime);
   TransformLocal(sector, row, x, y, z);
 }
 
-GPUdi() void TPCFastTransformPOD::TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
-{
-
-  TransformLocal(sector, row, x, y, z, ref, ref2, scale, scale2, scaleMode);
-}
-
-GPUdi() void TPCFastTransformPOD::TransformXYZ_new(int32_t sector, int32_t row, float& x, float& y, float& z) const
+GPUdi() void TPCFastTransformPOD::TransformXYZ(int32_t sector, int32_t row, float& x, float& y, float& z) const
 {
 
   TransformLocal(sector, row, x, y, z);
@@ -790,49 +642,10 @@ GPUdi() float TPCFastTransformPOD::getMaxDriftTime(int32_t sector) const
   return convDriftLengthToTime(getGeometry().getTPCzLength(), 0.f);
 }
 
-GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX(int32_t sector, int32_t row, float realY, float realZ, float& realX, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX(int32_t sector, int32_t row, float realY, float realZ, float& realX) const
 {
-  GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
   /// Transformation y,z -> x
-
   float dx = 0.f;
-
-  if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    dx = getCorrectionXatRealYZ(sector, row, realY, realZ);
-    if (ref) { // scaling was requested
-      if (scaleMode == 0 && scale > 0.f) {
-        float dxref = ref->getCorrectionXatRealYZ(sector, row, realY, realZ);
-        dx = (dx - dxref) * scale + dxref;
-      } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
-        float dxref = ref->getCorrectionXatRealYZ(sector, row, realY, realZ);
-        dx = dxref * scale + dx;
-      }
-    }
-    if (ref2 && (scale2 != 0)) {
-      float dxref = ref2->getCorrectionXatRealYZ(sector, row, realY, realZ);
-      dx = dxref * scale2 + dx;
-    }
-  }
-
-  realX = getGeometry().getRowInfo(row).x + dx;
-
-  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
-    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoX").data()
-                                                                                       << "sector=" << sector
-                                                                                       << "row=" << row
-                                                                                       << "y=" << realY
-                                                                                       << "z=" << realZ
-                                                                                       << "x=" << realX
-                                                                                       << "\n";
-  })
-}
-
-GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX_new(int32_t sector, int32_t row, float realY, float realZ, float& realX) const
-{
-  /// Transformation y,z -> x
-
-  float dx = 0.f;
-
   dx = getCorrectionXatRealYZ(sector, row, realY, realZ);
   realX = getGeometry().getRowInfo(row).x + dx;
 
@@ -847,39 +660,11 @@ GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX_new(int32_t sector, int3
   })
 }
 
-GPUdi() void TPCFastTransformPOD::InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
+GPUdi() void TPCFastTransformPOD::InverseTransformYZtoNominalYZ(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ) const
 {
   /// Transformation real y,z -> measured y,z
-
-  GPUCA_RTC_SPECIAL_CODE(ref2 = nullptr; scale2 = 0.f;);
-
-  float dy = 0;
-  float dz = 0;
-
-  if ((scale >= 0.f) || (scaleMode == 1) || (scaleMode == 2)) {
-    getCorrectionYZatRealYZ(sector, row, realY, realZ, dy, dz);
-
-    if (ref) { // scaling was requested
-      if (scaleMode == 0 && scale > 0.f) {
-        float val[2];
-        ref->getCorrectionYZatRealYZ(sector, row, realY, realZ, val[0], val[1]);
-        dy = (dy - val[0]) * scale + val[0];
-        dz = (dz - val[1]) * scale + val[1];
-      } else if ((scale != 0) && ((scaleMode == 1) || (scaleMode == 2))) {
-        float val[2];
-        ref->getCorrectionYZatRealYZ(sector, row, realY, realZ, val[0], val[1]);
-        dy = val[0] * scale + dy;
-        dz = val[1] * scale + dz;
-      }
-      if (ref2 && (scale2 != 0)) {
-        float val[2];
-        ref2->getCorrectionYZatRealYZ(sector, row, realY, realZ, val[0], val[1]);
-        dy = val[0] * scale2 + dy;
-        dz = val[1] * scale2 + dz;
-      }
-    }
-  }
-
+  float dy, dz;
+  getCorrectionYZatRealYZ(sector, row, realY, realZ, dy, dz);
   measuredY = realY - dy;
   measuredZ = realZ - dz;
 
@@ -895,66 +680,6 @@ GPUdi() void TPCFastTransformPOD::InverseTransformYZtoNominalYZ(int32_t sector,
   })
 }
 
-GPUdi() void TPCFastTransformPOD::InverseTransformYZtoNominalYZ_new(int32_t sector, int32_t row, float realY, float realZ, float& measuredY, float& measuredZ) const
-{
-  /// Transformation real y,z -> measured y,z
-  float corrY, corrZ;
-  getCorrectionYZatRealYZ(sector, row, realY, realZ, corrY, corrZ);
-  measuredY = realY - corrY;
-  measuredZ = realZ - corrZ;
-
-  GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
-    o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoNominalYZ").data()
-                                                                                       << "sector=" << sector
-                                                                                       << "row=" << row
-                                                                                       << "real y=" << realY
-                                                                                       << "real z=" << realZ
-                                                                                       << "measured y=" << measuredY
-                                                                                       << "measured z=" << measuredZ
-                                                                                       << "\n";
-  })
-}
-
-GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz, const TPCFastTransformPOD* ref, const TPCFastTransformPOD* ref2, float scale, float scale2, int32_t scaleMode) const
-{
-  /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
-  int32_t row2 = row + 1;
-  if (row2 >= getGeometry().getNumberOfRows()) {
-    row2 = row - 1;
-  }
-  float nx1, ny1, nz1; // nominal coordinates for row
-  float nx2, ny2, nz2; // nominal coordinates for row2
-  nx1 = getGeometry().getRowInfo(row).x;
-  nx2 = getGeometry().getRowInfo(row2).x;
-  InverseTransformYZtoNominalYZ(sector, row, y, z, ny1, nz1, ref, ref2, scale, scale2, scaleMode);
-  InverseTransformYZtoNominalYZ(sector, row2, y, z, ny2, nz2, ref, ref2, scale, scale2, scaleMode);
-  float c1 = (nx2 - nx) / (nx2 - nx1);
-  float c2 = (nx - nx1) / (nx2 - nx1);
-  nx = x;
-  ny = (ny1 * c1 + ny2 * c2);
-  nz = (nz1 * c1 + nz2 * c2);
-}
-
-GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ_new(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz) const
-{
-  /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
-  int32_t row2 = row + 1;
-  if (row2 >= getGeometry().getNumberOfRows()) {
-    row2 = row - 1;
-  }
-  float nx1, ny1, nz1; // nominal coordinates for row
-  float nx2, ny2, nz2; // nominal coordinates for row2
-  nx1 = getGeometry().getRowInfo(row).x;
-  nx2 = getGeometry().getRowInfo(row2).x;
-  InverseTransformYZtoNominalYZ_new(sector, row, y, z, ny1, nz1);
-  InverseTransformYZtoNominalYZ_new(sector, row2, y, z, ny2, nz2);
-  float c1 = (nx2 - nx) / (nx2 - nx1);
-  float c2 = (nx - nx1) / (nx2 - nx1);
-  nx = x;
-  ny = (ny1 * c1 + ny2 * c2);
-  nz = (nz1 * c1 + nz2 * c2);
-}
-
 GPUdi() void TPCFastTransformPOD::convPadTimeToLocal(int32_t sector, int32_t row, float pad, float time, float& y, float& z, float vertexTime) const
 {
   float l = (time - mT0 - vertexTime) * mVdrift;
@@ -997,6 +722,7 @@ GPUdi() float TPCFastTransformPOD::convVertexTimeToZOffset(int32_t sector, float
   }
 }
 
+#ifndef GPUCA_GPUCODE_DEVICE // Functions not needed during GPU processing
 GPUdi() void TPCFastTransformPOD::setCalibration1(int64_t timeStamp, float t0, float vDrift)
 {
   mTimeStamp = timeStamp;
@@ -1004,6 +730,27 @@ GPUdi() void TPCFastTransformPOD::setCalibration1(int64_t timeStamp, float t0, f
   mVdrift = vDrift;
 }
 
+GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ(int32_t sector, int32_t row, float x, float y, float z, float& nx, float& ny, float& nz) const
+{
+  /// Inverse transformation: Transformed X, Y and Z -> X, Y and Z, transformed w/o space charge correction
+  int32_t row2 = row + 1;
+  if (row2 >= getGeometry().getNumberOfRows()) {
+    row2 = row - 1;
+  }
+  float nx1, ny1, nz1; // nominal coordinates for row
+  float nx2, ny2, nz2; // nominal coordinates for row2
+  nx1 = getGeometry().getRowInfo(row).x;
+  nx2 = getGeometry().getRowInfo(row2).x;
+  InverseTransformYZtoNominalYZ(sector, row, y, z, ny1, nz1);
+  InverseTransformYZtoNominalYZ(sector, row2, y, z, ny2, nz2);
+  float c1 = (nx2 - nx) / (nx2 - nx1);
+  float c2 = (nx - nx1) / (nx2 - nx1);
+  nx = x;
+  ny = (ny1 * c1 + ny2 * c2);
+  nz = (nz1 * c1 + nz2 * c2);
+}
+#endif // GPUCA_GPUCODE_DEVICE
+
 } // namespace gpu
 } // namespace o2
 

From 6656132d88c7fd6417ecc67900ab23e70672a6a1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 3 Apr 2026 23:26:09 +0200
Subject: [PATCH 1590/1764] GPU: Add GPUCommonAlignedAlloc.h for aligned
 buffers, and use it for TPCFastTransformPOD

---
 .../include/TPCCalibration/CalculatedEdx.h    |  4 +-
 .../include/TPCCalibration/TrackDump.h        |  4 +-
 .../TPC/calibration/src/CalculatedEdx.cxx     |  4 +-
 Detectors/TPC/calibration/src/TrackDump.cxx   |  4 +-
 .../reconstruction/test/testGPUCATracking.cxx |  4 +-
 Detectors/TPC/workflow/src/TPCScalerSpec.cxx  |  3 +-
 GPU/Common/CMakeLists.txt                     |  1 +
 GPU/Common/GPUCommonAlignedAlloc.h            | 61 +++++++++++++++++++
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 16 ++---
 GPU/GPUTracking/Base/GPUReconstruction.h      | 11 ++--
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  4 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  4 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |  5 +-
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  2 +-
 .../Standalone/Benchmark/standalone.cxx       |  8 +--
 .../TPCFastTransformPOD.cxx                   | 28 ++++++++-
 .../TPCFastTransformPOD.h                     | 61 +++++--------------
 .../include/GPUWorkflow/GPUWorkflowSpec.h     |  6 +-
 .../include/GPUWorkflow/O2GPUDPLDisplay.h     |  3 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |  2 +-
 GPU/Workflow/src/GPUWorkflowTPC.cxx           | 18 ++----
 GPU/Workflow/src/O2GPUDPLDisplay.cxx          |  4 +-
 macro/runTPCRefit.C                           |  4 +-
 23 files changed, 157 insertions(+), 104 deletions(-)
 create mode 100644 GPU/Common/GPUCommonAlignedAlloc.h

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CalculatedEdx.h b/Detectors/TPC/calibration/include/TPCCalibration/CalculatedEdx.h
index d62eb8a1ab868..4d8c4e89322a8 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CalculatedEdx.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CalculatedEdx.h
@@ -228,7 +228,7 @@ class CalculatedEdx
   std::vector<TPCClRefElem>* mTPCTrackClIdxVecInput{nullptr}; ///< input vector with TPC tracks cluster indicies
   const o2::tpc::ClusterNativeAccess* mClusterIndex{nullptr}; ///< needed to access clusternative with tpctracks
   const o2::gpu::TPCFastTransformPOD* mTPCCorrMap{nullptr};   ///< cluster correction maps helper
-  std::vector<char> mTPCCorrMapBuffer;
+  o2::gpu::aligned_unique_buffer_ptr<o2::gpu::TPCFastTransformPOD> mTPCCorrMapBuffer;
   std::vector<unsigned char> mTPCRefitterShMap;                  ///< externally set TPC clusters sharing map
   std::vector<unsigned int> mTPCRefitterOccMap;                  ///< externally set TPC clusters occupancy map
   std::unique_ptr<o2::gpu::GPUO2InterfaceRefit> mRefit{nullptr}; ///< TPC refitter used for TPC tracks refit during the reconstruction
@@ -247,4 +247,4 @@ class CalculatedEdx
 
 } // namespace o2::tpc
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h b/Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h
index 3f60b165e4167..adbf3ecf5a299 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/TrackDump.h
@@ -77,8 +77,8 @@ class TrackDump
     float gyc(float vertexTime = 0) const;
     float zc(float vertexTime = 0) const;
 
-    inline static std::vector<char> corrMapBuffer;                      // buffer for owning the correction map in case of update during runtime
-    inline static const o2::gpu::TPCFastTransformPOD* corrMap{nullptr}; // local copy of the correction map for quick access to the transform functions
+    inline static o2::gpu::aligned_unique_buffer_ptr<o2::gpu::TPCFastTransformPOD> corrMapBuffer; // buffer for owning the correction map in case of update during runtime
+    inline static const o2::gpu::TPCFastTransformPOD* corrMap{nullptr};                           // local copy of the correction map for quick access to the transform functions
     static void loadCorrMaps(std::string_view corrMapFile, std::string_view corrMapFileRef = "");
     ClassDefNV(ClusterNativeAdd, 1);
   };
diff --git a/Detectors/TPC/calibration/src/CalculatedEdx.cxx b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
index bbf5b0ca93128..396214775eb76 100644
--- a/Detectors/TPC/calibration/src/CalculatedEdx.cxx
+++ b/Detectors/TPC/calibration/src/CalculatedEdx.cxx
@@ -32,10 +32,10 @@ using namespace o2::tpc;
 
 CalculatedEdx::CalculatedEdx()
 {
-  std::vector<char> buffer;
+  gpu::aligned_unique_buffer_ptr<gpu::TPCFastTransformPOD> buffer;
   gpu::TPCFastTransformPOD::create(buffer, *TPCFastTransformHelperO2::instance()->create(0));
   mTPCCorrMapBuffer = std::move(buffer);
-  mTPCCorrMap = &gpu::TPCFastTransformPOD::get(mTPCCorrMapBuffer.data());
+  mTPCCorrMap = mTPCCorrMapBuffer.get();
 }
 
 void CalculatedEdx::setMembers(std::vector<o2::tpc::TPCClRefElem>* tpcTrackClIdxVecInput, const o2::tpc::ClusterNativeAccess& clIndex, std::vector<o2::tpc::TrackTPC>* vTPCTracksArrayInp)
diff --git a/Detectors/TPC/calibration/src/TrackDump.cxx b/Detectors/TPC/calibration/src/TrackDump.cxx
index 52cf7a4e3c7e3..72042a537dc5f 100644
--- a/Detectors/TPC/calibration/src/TrackDump.cxx
+++ b/Detectors/TPC/calibration/src/TrackDump.cxx
@@ -236,8 +236,8 @@ float TrackDump::ClusterNativeAdd::zc(float vertexTime) const
 void TrackDump::ClusterNativeAdd::loadCorrMaps(std::string_view corrMapFile, std::string_view corrMapFileRef)
 {
   auto fastTransformTmp = gpu::TPCFastTransform::loadFromFile(corrMapFile.data());
-  std::vector<char> buffer;
+  o2::gpu::aligned_unique_buffer_ptr<o2::gpu::TPCFastTransformPOD> buffer;
   gpu::TPCFastTransformPOD::create(buffer, *fastTransformTmp);
   corrMapBuffer = std::move(buffer);
-  corrMap = &gpu::TPCFastTransformPOD::get(corrMapBuffer.data());
+  corrMap = corrMapBuffer.get();
 }
diff --git a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
index 811f474d8491d..20660473f4c37 100644
--- a/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
+++ b/Detectors/TPC/reconstruction/test/testGPUCATracking.cxx
@@ -74,9 +74,9 @@ BOOST_AUTO_TEST_CASE(CATracking_test1)
   config.configWorkflow.outputs.set(gpudatatypes::InOutType::TPCMergedTracks);
 
   auto fastTransformTmp = TPCFastTransformHelperO2::instance()->create(0);
-  std::vector<char> fastTransformBuf;
+  aligned_unique_buffer_ptr<TPCFastTransformPOD> fastTransformBuf;
   TPCFastTransformPOD::create(fastTransformBuf, *fastTransformTmp);
-  config.configCalib.fastTransform = &TPCFastTransformPOD::get(fastTransformBuf.data());
+  config.configCalib.fastTransform = fastTransformBuf.get();
 
   auto dEdxCalibContainer = GPUO2InterfaceUtils::getCalibdEdxContainerDefault();
   config.configCalib.dEdxCalibContainer = dEdxCalibContainer.get();
diff --git a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
index 461963fcb261d..09ffa644520cf 100644
--- a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
@@ -219,7 +219,8 @@ class TPCScalerSpec : public Task
 
     Output corrMapOutput{header::gDataOriginTPC, "TPCCORRMAP", 0};
     auto outputBuffer = o2::pmr::vector<char>(pc.outputs().getMemoryResource(corrMapOutput));
-    auto* pod = TPCFastTransformPOD::create(outputBuffer, finalMap.getCorrection());
+    outputBuffer.resize(TPCFastTransformPOD::estimateSize(finalMap.getCorrection()));
+    auto* pod = TPCFastTransformPOD::create(outputBuffer.data(), outputBuffer.size(), finalMap.getCorrection());
     const auto& vd = mTPCVDriftHelper.getVDriftObject();
     o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*pod, 0, vd.corrFact, vd.refVDrift, vd.getTimeOffset());
     pc.outputs().adoptContainer(corrMapOutput, std::move(outputBuffer));
diff --git a/GPU/Common/CMakeLists.txt b/GPU/Common/CMakeLists.txt
index 8f7a7c2e169ed..45ca83a3033f0 100644
--- a/GPU/Common/CMakeLists.txt
+++ b/GPU/Common/CMakeLists.txt
@@ -13,6 +13,7 @@ set(MODULE GPUCommon)
 
 set(HDRS_INSTALL
     GPUCommonAlgorithm.h
+    GPUCommonAlignedAlloc.h
     GPUCommonDef.h
     GPUCommonDefAPI.h
     GPUCommonHelpers.h
diff --git a/GPU/Common/GPUCommonAlignedAlloc.h b/GPU/Common/GPUCommonAlignedAlloc.h
new file mode 100644
index 0000000000000..8e028399f4910
--- /dev/null
+++ b/GPU/Common/GPUCommonAlignedAlloc.h
@@ -0,0 +1,61 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUCommonAlignedAlloc.h
+/// \author David Rohr
+
+#ifndef GPUCOMMONAKUGBEDALLOC_H
+#define GPUCOMMONAKUGBEDALLOC_H
+
+#include <memory>
+
+namespace o2::gpu
+{
+
+template <typename T, std::size_t MIN_ALIGN = 0>
+struct alignedDeleter {
+  void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(std::max(MIN_ALIGN, alignof(T)))); };
+};
+
+template <typename T, std::size_t MIN_ALIGN = 0>
+struct alignedAllocator {
+  using value_type = T;
+  T* allocate(std::size_t n)
+  {
+    return (T*)::operator new(n, std::align_val_t(std::max(MIN_ALIGN, alignof(T))));
+  }
+  void deallocate(T* ptr, std::size_t)
+  {
+    alignedDeleter<T, MIN_ALIGN>()(ptr);
+  }
+};
+
+template <typename T>
+struct aligned_unique_buffer_ptr : public std::unique_ptr<char[], alignedDeleter<T>> {
+  aligned_unique_buffer_ptr() = default;
+  aligned_unique_buffer_ptr(size_t n) { alloc(n); }
+  aligned_unique_buffer_ptr(T* ptr) { std::unique_ptr<char[], alignedDeleter<T>>::reset((char*)ptr); }
+  char* getraw() { return std::unique_ptr<char[], alignedDeleter<T>>::get(); }
+  const char* getraw() const { return std::unique_ptr<char[], alignedDeleter<T>>::get(); }
+  T* get() { return (T*)std::unique_ptr<char[], alignedDeleter<T>>::get(); }
+  const T* get() const { return (T*)std::unique_ptr<char[], alignedDeleter<T>>::get(); }
+  T* operator->() { return get(); }
+  const T* operator->() const { return get(); }
+  T* alloc(std::size_t n)
+  {
+    std::unique_ptr<char[], alignedDeleter<T>>::reset((char*)alignedAllocator<T>().allocate(n));
+    return get();
+  }
+};
+
+} // namespace o2::gpu
+
+#endif // GPUCOMMONAKUGBEDALLOC_H
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index f6aa62778a061..37468477c3b7d 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -467,7 +467,7 @@ int32_t GPUReconstruction::Exit()
       if (mMemoryResources[i].mReuse >= 0) {
         continue;
       }
-      operator delete(mMemoryResources[i].mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+      ::operator delete(mMemoryResources[i].mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
       mMemoryResources[i].mPtr = mMemoryResources[i].mPtrDevice = nullptr;
     }
   }
@@ -630,7 +630,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && (control == nullptr || control->useInternal())) {
     if (!(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) {
       if (res->mPtrDevice && res->mReuse < 0) {
-        operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+        ::operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
       }
       res->mSize = std::max((size_t)res->SetPointers((void*)1) - 1, res->mOverrideSize);
       if (res->mReuse >= 0) {
@@ -640,7 +640,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         }
         res->mPtrDevice = mMemoryResources[res->mReuse].mPtrDevice;
       } else {
-        res->mPtrDevice = operator new(res->mSize + GPUCA_BUFFER_ALIGNMENT, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+        res->mPtrDevice = ::operator new(res->mSize + GPUCA_BUFFER_ALIGNMENT, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
       }
       res->mPtr = GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(res->mPtrDevice);
       res->SetPointers(res->mPtr);
@@ -733,9 +733,9 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
     char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
     if ((type & GPUMemoryResource::MEMORY_STACK)) {
-      mNonPersistentIndividualDirectAllocations.emplace_back(retVal, alignedDeleter());
+      mNonPersistentIndividualDirectAllocations.emplace_back(retVal, alignedDefaultBufferDeleter());
     } else {
-      mDirectMemoryChunks.emplace_back(retVal, alignedDeleter());
+      mDirectMemoryChunks.emplace_back(retVal, alignedDefaultBufferDeleter());
     }
     return retVal;
   }
@@ -798,7 +798,7 @@ void* GPUReconstruction::AllocateVolatileMemory(size_t size, bool device)
   }
   char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
   stdspinlock spinlock(mMemoryMutex);
-  mVolatileChunks.emplace_back(retVal, alignedDeleter());
+  mVolatileChunks.emplace_back(retVal, alignedDefaultBufferDeleter());
   return retVal;
 }
 
@@ -876,7 +876,7 @@ void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)
     std::cout << "Freeing " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
   }
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && res->mReuse < 0) {
-    operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+    ::operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
   }
   res->mPtr = nullptr;
   res->mPtrDevice = nullptr;
@@ -916,7 +916,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag, cons
       std::cout << "Freeing NonPersistent " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
     }
     if (res->mReuse < 0) {
-      operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+      ::operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
     }
     res->mPtr = nullptr;
     res->mPtrDevice = nullptr;
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 9a337c02ad26d..21195af1d4a89 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -32,6 +32,7 @@
 #include "GPUOutputControl.h"
 #include "GPUParam.h"
 #include "GPUConstantMem.h"
+#include "GPUCommonAlignedAlloc.h"
 #include "GPUDef.h"
 
 namespace o2::its
@@ -381,15 +382,13 @@ class GPUReconstruction
     GPUProcessor* proc = nullptr;
     std::vector<uint16_t> res;
   };
-  struct alignedDeleter {
-    void operator()(void* ptr) { ::operator delete[](ptr, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)); };
-  };
   std::unordered_map<GPUMemoryReuse::ID, MemoryReuseMeta> mMemoryReuse1to1;
   std::vector<std::tuple<void*, void*, size_t, size_t, uint64_t>> mNonPersistentMemoryStack; // hostPoolAddress, devicePoolAddress, individualAllocationCount, directIndividualAllocationCound, tag
   std::vector<GPUMemoryResource*> mNonPersistentIndividualAllocations;
-  std::vector<std::unique_ptr<char[], alignedDeleter>> mNonPersistentIndividualDirectAllocations;
-  std::vector<std::unique_ptr<char[], alignedDeleter>> mDirectMemoryChunks;
-  std::vector<std::unique_ptr<char[], alignedDeleter>> mVolatileChunks;
+  using alignedDefaultBufferDeleter = alignedDeleter<char, GPUCA_BUFFER_ALIGNMENT>;
+  std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mNonPersistentIndividualDirectAllocations;
+  std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mDirectMemoryChunks;
+  std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mVolatileChunks;
   std::atomic_flag mMemoryMutex = ATOMIC_FLAG_INIT;
 
   std::unique_ptr<GPUReconstructionPipelineContext> mPipelineContext;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 752b5f27ded3f..6dd38c4c4d6b7 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -189,7 +189,7 @@ int32_t GPUReconstructionCPU::InitDevice()
       if (mDeviceMemorySize > mHostMemorySize) {
         mHostMemorySize = mDeviceMemorySize;
       }
-      mHostMemoryBase = operator new(mHostMemorySize, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+      mHostMemoryBase = ::operator new(mHostMemorySize, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
     }
     mHostMemoryPermanent = mHostMemoryBase;
     ClearAllocatedMemory();
@@ -205,7 +205,7 @@ int32_t GPUReconstructionCPU::ExitDevice()
 {
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     if (mMaster == nullptr) {
-      operator delete(mHostMemoryBase, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+      ::operator delete(mHostMemoryBase, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
     }
     mHostMemoryPool = mHostMemoryBase = mHostMemoryPoolEnd = mHostMemoryPermanent = nullptr;
     mHostMemorySize = 0;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index d669f60356101..c5e9fd7630295 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -557,10 +557,10 @@ void GPUChainTracking::AllocateIOMemory()
   AllocateIOMemoryHelper(mIOPtrs.nTRDTriggerRecords, mIOPtrs.trdTrackletIdxFirst, mIOMem.trdTrackletIdxFirst);
 }
 
-void GPUChainTracking::SetTPCFastTransform(std::unique_ptr<TPCFastTransformPOD>&& tpcFastTransform)
+void GPUChainTracking::SetTPCFastTransform(aligned_unique_buffer_ptr<TPCFastTransformPOD>&& tpcFastTransform)
 {
   mTPCFastTransformU = std::move(tpcFastTransform);
-  processors()->calibObjects.fastTransform = mTPCFastTransformU.get();
+  processors()->calibObjects.fastTransform = (TPCFastTransformPOD*)mTPCFastTransformU.get();
 }
 
 void GPUChainTracking::SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut)
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 2af33f86ab0d7..ccc864e422065 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -18,6 +18,7 @@
 #include "GPUChain.h"
 #include "GPUDataTypesIO.h"
 #include "GPUDataTypesConfig.h"
+#include "GPUCommonAlignedAlloc.h"
 #include <atomic>
 #include <mutex>
 #include <functional>
@@ -182,7 +183,7 @@ class GPUChainTracking : public GPUChain
   const GPUTRDRecoParam* GetTRDRecoParam() const;
   const o2::base::Propagator* GetO2Propagator() const;
   const o2::base::Propagator* GetDeviceO2Propagator();
-  void SetTPCFastTransform(std::unique_ptr<TPCFastTransformPOD>&& tpcFastTransform);
+  void SetTPCFastTransform(aligned_unique_buffer_ptr<TPCFastTransformPOD>&& tpcFastTransform);
   void SetMatLUT(std::unique_ptr<o2::base::MatLayerCylSet>&& lut);
   void SetTRDGeometry(std::unique_ptr<o2::trd::GeometryFlat>&& geo);
   void SetTRDRecoParam(std::unique_ptr<GPUTRDRecoParam>&& par);
@@ -260,7 +261,7 @@ class GPUChainTracking : public GPUChain
   std::unique_ptr<GPUTPCClusterStatistics> mCompressionStatistics;
 
   // Ptr to detector / calibration objects
-  std::unique_ptr<TPCFastTransformPOD> mTPCFastTransformU;           // Global TPC fast transformation object
+  aligned_unique_buffer_ptr<TPCFastTransformPOD> mTPCFastTransformU; // Global TPC fast transformation object
   std::unique_ptr<TPCPadGainCalib> mTPCPadGainCalibU;                // TPC gain calibration and cluster finder parameters
   std::unique_ptr<TPCZSLinkMapping> mTPCZSLinkMappingU;              // TPC Mapping data required by ZS Link decoder
   std::unique_ptr<o2::tpc::CalibdEdxContainer> mdEdxCalibContainerU; // TPC dEdx calibration container
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 21bc9a66eac0c..0a879db818c8f 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -335,7 +335,7 @@ void GPUChainTracking::ReadSettings(const char* dir)
   f = dir;
   f += "tpctransform.dump";
   mTPCFastTransformU = ReadStructFromFile<TPCFastTransformPOD>(f.c_str());
-  processors()->calibObjects.fastTransform = mTPCFastTransformU.get();
+  processors()->calibObjects.fastTransform = (TPCFastTransformPOD*)mTPCFastTransformU.get();
   f = dir;
   f += "tpcpadgaincalib.dump";
   mTPCPadGainCalibU = ReadStructFromFile<TPCPadGainCalib>(f.c_str());
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 1e6c25ed66202..023e7a2b0b142 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -77,7 +77,7 @@ GPUChainITS *chainITS, *chainITSAsync, *chainITSPipeline;
 std::string eventsDir;
 void unique_ptr_aligned_delete(char* v)
 {
-  operator delete(v, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+  ::operator delete(v, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
 }
 std::unique_ptr<char, void (*)(char*)> outputmemory(nullptr, unique_ptr_aligned_delete), outputmemoryPipeline(nullptr, unique_ptr_aligned_delete), inputmemory(nullptr, unique_ptr_aligned_delete);
 std::unique_ptr<GPUDisplayFrontendInterface> eventDisplay;
@@ -238,20 +238,20 @@ int32_t ReadConfiguration(int argc, char** argv)
 
   if (configStandalone.outputcontrolmem) {
     bool forceEmptyMemory = getenv("LD_PRELOAD") && strstr(getenv("LD_PRELOAD"), "valgrind") != nullptr;
-    outputmemory.reset((char*)operator new(configStandalone.outputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
+    outputmemory.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
     if (forceEmptyMemory) {
       printf("Valgrind detected, emptying GPU output memory to avoid false positive undefined reads");
       memset(outputmemory.get(), 0, configStandalone.outputcontrolmem);
     }
     if (configStandalone.proc.doublePipeline) {
-      outputmemoryPipeline.reset((char*)operator new(configStandalone.outputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
+      outputmemoryPipeline.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
       if (forceEmptyMemory) {
         memset(outputmemoryPipeline.get(), 0, configStandalone.outputcontrolmem);
       }
     }
   }
   if (configStandalone.inputcontrolmem) {
-    inputmemory.reset((char*)operator new(configStandalone.inputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
+    inputmemory.reset((char*)::operator new(configStandalone.inputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
   }
 
   configStandalone.proc.showOutputStat = true;
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index 295b3bb19431e..e22c47f1337e7 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -25,7 +25,33 @@ namespace o2
 namespace gpu
 {
 
-#if !defined(GPUCA_NO_ROOT) && !defined(GPUCA_NO_FMT) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_NO_ROOT) && !defined(GPUCA_NO_FMT) && !defined(GPUCA_STANDALONE) && !defined(GPUCA_GPUCODE)
+
+/// Create POD transform from old flat-buffer one. Provided vector will serve as a buffer
+TPCFastTransformPOD* TPCFastTransformPOD::create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastTransform& src)
+{
+  size_t size = estimateSize(src);
+  destVector.alloc(size); // allocate exact size
+  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POS size: {}", src.getCorrection().getFlatBufferSize(), sizeof(TPCFastTransformPOD), size);
+  auto res = create(destVector.getraw(), size, src);
+  res->setTimeStamp(src.getTimeStamp());
+  res->setVDrift(src.getVDrift());
+  res->setT0(src.getT0());
+  res->setLumi(src.getLumi());
+  if (src.isIDCSet()) {
+    res->setIDC(src.getIDC());
+  }
+  return res;
+}
+
+TPCFastTransformPOD* TPCFastTransformPOD::create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastSpaceChargeCorrection& origCorr)
+{
+  // create filling only part corresponding to TPCFastSpaceChargeCorrection. Data members coming from TPCFastTransform (e.g. VDrift, T0..) are not set
+  size_t size = estimateSize(origCorr);
+  destVector.alloc(size);
+  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POS size: {}", origCorr.getFlatBufferSize(), sizeof(TPCFastTransformPOD), size);
+  return create(destVector.getraw(), size, origCorr);
+}
 
 size_t TPCFastTransformPOD::estimateSize(const TPCFastSpaceChargeCorrection& origCorr)
 {
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index 396a6608c695d..6d7ca4d485fc6 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -19,6 +19,11 @@
 
 #include "GPUCommonRtypes.h"
 #include "TPCFastTransform.h"
+#ifndef GPUCA_GPUCODE
+#include <memory>
+#include <cstdlib>
+#include "GPUCommonAlignedAlloc.h"
+#endif
 
 /*
 Binary buffer should be cast to TPCFastTransformPOD class using static TPCFastTransformPOD& t = get(buffer); method,
@@ -209,20 +214,23 @@ class TPCFastTransformPOD
 
 #if !defined(GPUCA_GPUCODE)
   /// Create POD transform from old flat-buffer one. Provided vector will serve as a buffer
-  template <typename V>
-  static TPCFastTransformPOD* create(V& destVector, const TPCFastTransform& src);
+  static TPCFastTransformPOD* create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastTransform& src);
 
   /// create filling only part corresponding to TPCFastSpaceChargeCorrection. Data members coming from TPCFastTransform (e.g. VDrift, T0..) are not set
-  template <typename V>
-  static TPCFastTransformPOD* create(V& destVector, const TPCFastSpaceChargeCorrection& src);
+  static TPCFastTransformPOD* create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastSpaceChargeCorrection& src);
 
-  static TPCFastTransformPOD* create(std::vector<char>& buf, const TPCFastTransformPOD& src)
+  static TPCFastTransformPOD* create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastTransformPOD& src)
   {
-    buf.resize(src.size());
-    std::memcpy(buf.data(), &src, src.size());
-    return reinterpret_cast<TPCFastTransformPOD*>(buf.data());
+    destVector.alloc(src.size());
+    std::memcpy(destVector.get(), &src, src.size());
+    return destVector.get();
   }
 
+  static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastTransform& src);
+  static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastSpaceChargeCorrection& src);
+  static size_t estimateSize(const TPCFastTransform& src) { return estimateSize(src.getCorrection()); }
+  static size_t estimateSize(const TPCFastSpaceChargeCorrection& origCorr);
+
   bool test(const TPCFastTransform& src, int32_t npoints = 100000) const { return test(src.getCorrection(), npoints); }
   bool test(const TPCFastSpaceChargeCorrection& origCorr, int32_t npoints = 100000) const;
 #endif
@@ -244,10 +252,6 @@ class TPCFastTransformPOD
     auto res = offs % AlignmentBytes;
     return res ? offs + (AlignmentBytes - res) : offs;
   }
-  static size_t estimateSize(const TPCFastTransform& src) { return estimateSize(src.getCorrection()); }
-  static size_t estimateSize(const TPCFastSpaceChargeCorrection& origCorr);
-  static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastTransform& src);
-  static TPCFastTransformPOD* create(char* buff, size_t buffSize, const TPCFastSpaceChargeCorrection& src);
   GPUd() static TPCFastTransformPOD& getNonConst(char* head) { return *reinterpret_cast<TPCFastTransformPOD*>(head); }
 #endif
 
@@ -421,39 +425,6 @@ GPUdi() bool TPCFastTransformPOD::isRealLocalInsideGrid(int32_t sector, int32_t
   return true;
 }
 
-#if !defined(GPUCA_GPUCODE)
-/// Create POD transform from old flat-buffer one. Provided vector will serve as a buffer
-template <typename V>
-TPCFastTransformPOD* TPCFastTransformPOD::create(V& destVector, const TPCFastTransform& src)
-{
-  const auto& origCorr = src.getCorrection();
-  size_t estSize = estimateSize(src);
-  destVector.resize(estSize); // allocate exact size
-  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POS size: {}", src.getCorrection().getFlatBufferSize(), sizeof(TPCFastTransformPOD), estSize);
-  char* base = destVector.data();
-  auto res = create(destVector.data(), destVector.size(), src);
-  res->setTimeStamp(src.getTimeStamp());
-  res->setVDrift(src.getVDrift());
-  res->setT0(src.getT0());
-  res->setLumi(src.getLumi());
-  if (src.isIDCSet()) {
-    res->setIDC(src.getIDC());
-  }
-  return res;
-}
-
-template <typename V>
-TPCFastTransformPOD* TPCFastTransformPOD::create(V& destVector, const TPCFastSpaceChargeCorrection& origCorr)
-{
-  // create filling only part corresponding to TPCFastSpaceChargeCorrection. Data members coming from TPCFastTransform (e.g. VDrift, T0..) are not set
-  size_t estSize = estimateSize(origCorr);
-  destVector.resize(estSize); // allocate exact size
-  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POS size: {}", origCorr.getFlatBufferSize(), sizeof(TPCFastTransformPOD), estSize);
-  char* base = destVector.data();
-  return create(destVector.data(), destVector.size(), origCorr);
-}
-#endif
-
 GPUdi() void TPCFastTransformPOD::TransformLocal(int32_t sector, int32_t row, float& x, float& y, float& z) const
 {
   if (!mApplyCorrection) {
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index d53787212bb9a..7fbe16296d868 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -22,6 +22,7 @@
 #include "Framework/ConcreteDataMatcher.h"
 #include "Framework/InitContext.h"
 #include "Framework/CompletionPolicy.h"
+#include "GPUCommonAlignedAlloc.h"
 #include "Algorithm/Parser.h"
 #include <string>
 #include <array>
@@ -155,13 +156,10 @@ class GPURecoWorkflowSpec : public o2::framework::Task
  private:
   struct calibObjectStruct {
     std::vector<char> mUpdatedTransformBuffer;
-    const TPCFastTransformPOD* mFastTransform{nullptr};
     std::unique_ptr<TPCPadGainCalib> mTPCPadGainCalib;
     std::unique_ptr<o2::tpc::CalibdEdxContainer> mdEdxCalibContainer;
     float mInstLumiCTP{-1};
-    // #if !defined(GPUCA_GPUCODE_DEVICE)
-    std::vector<char> mCorrMapBuffer;
-    // #endif
+    aligned_unique_buffer_ptr<TPCFastTransformPOD> mFastTransformBuffer;
   };
 
   /// initialize TPC options from command line
diff --git a/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h b/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
index cd9752053d7bb..517e82480565b 100644
--- a/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
+++ b/GPU/Workflow/include/GPUWorkflow/O2GPUDPLDisplay.h
@@ -12,6 +12,7 @@
 #ifndef O2_GPU_DPL_DISPLAY_H
 #define O2_GPU_DPL_DISPLAY_H
 
+#include "GPUCommonAlignedAlloc.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "Framework/Task.h"
 #include <memory>
@@ -59,7 +60,7 @@ class O2GPUDPLDisplaySpec : public o2::framework::Task
   bool mGRPGeomUpdated = false;
   bool mAutoContinuousMaxTimeBin = false;
   bool mGeometryCreated = false;
-  std::vector<char> mBufferFastTransform;
+  aligned_unique_buffer_ptr<TPCFastTransformPOD> mBufferFastTransform;
   o2::dataformats::GlobalTrackID::mask_t mTrkMask;
   o2::dataformats::GlobalTrackID::mask_t mClMask;
   std::unique_ptr<GPUO2InterfaceDisplay> mDisplay;
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index dda471ae05b38..7a96a48e5a994 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -250,7 +250,7 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     // initialize TPC calib objects
     initFunctionTPCCalib(ic);
 
-    mConfig->configCalib.fastTransform = mCalibObjects.mFastTransform;
+    mConfig->configCalib.fastTransform = mCalibObjects.mFastTransformBuffer.get();
     // mConfig->configCalib.buffer = mCalibObjects.mBuffer; // TODO WRONG
     if (mConfig->configCalib.fastTransform == nullptr) {
       throw std::invalid_argument("GPU workflow: initialization of the TPC transformation failed");
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index 9614f588338d7..db1f55620a279 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -104,10 +104,7 @@ void GPURecoWorkflowSpec::initFunctionTPCCalib(InitContext& ic)
   mCalibObjects.mdEdxCalibContainer.reset(new o2::tpc::CalibdEdxContainer());
   mTPCVDriftHelper.reset(new o2::tpc::VDriftHelper());
 
-  std::vector<char> buffer;
-  gpu::TPCFastTransformPOD::create(buffer, *o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
-  mCalibObjects.mCorrMapBuffer = std::move(buffer);
-  mCalibObjects.mFastTransform = &TPCFastTransformPOD::get(mCalibObjects.mCorrMapBuffer.data());
+  gpu::TPCFastTransformPOD::create(mCalibObjects.mFastTransformBuffer, *o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
 
   if (mConfParam->dEdxDisableTopologyPol) {
     LOGP(info, "Disabling loading of track topology correction using polynomials from CCDB");
@@ -347,16 +344,13 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
         mCalibObjects.mInstLumiCTP = pc.inputs().get<float>("lumiCTP");
 
         // get the raw buffer and reinterpret as TPCFastTransformPOD
-        oldCalibObjects.mFastTransform = mCalibObjects.mFastTransform;            // save OLD pointer ✓
-        oldCalibObjects.mCorrMapBuffer = std::move(mCalibObjects.mCorrMapBuffer); // OLD buffer alive ✓
-
+        oldCalibObjects.mFastTransformBuffer = std::move(mCalibObjects.mFastTransformBuffer); // OLD buffer alive ✓
         auto const& raw = pc.inputs().get<const char*>("corrMap");
         const auto* newMap = &gpu::TPCFastTransformPOD::get(raw); // NEW map from DPL
-        std::vector<char> buffer(newMap->size());
-        std::memcpy(buffer.data(), newMap, buffer.size()); // copy NEW map ✓
-        mCalibObjects.mCorrMapBuffer = std::move(buffer);
-        mCalibObjects.mFastTransform = &TPCFastTransformPOD::get(mCalibObjects.mCorrMapBuffer.data());
-        newCalibObjects.fastTransform = mCalibObjects.mFastTransform;
+        aligned_unique_buffer_ptr<TPCFastTransformPOD> buffer(newMap->size());
+        std::memcpy(buffer.get(), newMap, newMap->size()); // copy NEW map ✓
+        mCalibObjects.mFastTransformBuffer = std::move(buffer);
+        newCalibObjects.fastTransform = mCalibObjects.mFastTransformBuffer.get();
         mustUpdate = true;
       }
       if (mTPCVDriftHelper->isUpdated()) {
diff --git a/GPU/Workflow/src/O2GPUDPLDisplay.cxx b/GPU/Workflow/src/O2GPUDPLDisplay.cxx
index b4f5b5abe48ed..4788eb207a344 100644
--- a/GPU/Workflow/src/O2GPUDPLDisplay.cxx
+++ b/GPU/Workflow/src/O2GPUDPLDisplay.cxx
@@ -65,10 +65,10 @@ void O2GPUDPLDisplaySpec::init(InitContext& ic)
   mConfig->configGRP.solenoidBzNominalGPU = 0;
   mConfParam.reset(new GPUSettingsO2(mConfig->ReadConfigurableParam()));
 
-  std::vector<char> buffer;
+  aligned_unique_buffer_ptr<TPCFastTransformPOD> buffer;
   gpu::TPCFastTransformPOD::create(buffer, *TPCFastTransformHelperO2::instance()->create(0));
   mBufferFastTransform = std::move(buffer);
-  mFastTransform = &TPCFastTransformPOD::get(mBufferFastTransform.data());
+  mFastTransform = mBufferFastTransform.get();
   mConfig->configCalib.fastTransform = mFastTransform;
 
   mTrdGeo.reset(new o2::trd::GeometryFlat());
diff --git a/macro/runTPCRefit.C b/macro/runTPCRefit.C
index a495ffe5987e3..bca4a97b62542 100644
--- a/macro/runTPCRefit.C
+++ b/macro/runTPCRefit.C
@@ -51,9 +51,9 @@ int runTPCRefit(TString trackFile = "tpctracks.root", TString clusterFile = "tpc
   Propagator::initFieldFromGRP(NameConf::getGRPFileName());
   const auto grp = o2::parameters::GRPObject::loadFrom("o2sim_grp.root");
   float bz = 5.00668f * grp->getL3Current() / 30000.;
-  std::vector<char> buffer;
+  aligned_unique_buffer_ptr<TPCFastTransformPOD> buffer;
   o2::gpu::TPCFastTransformPOD::create(buffer, *TPCFastTransformHelperO2::instance()->create(0));
-  const TPCFastTransformPOD corrMap = o2::gpu::TPCFastTransformPOD::get(buffer.data());
+  const TPCFastTransformPOD* corrMap = buffer.get();
   auto* prop = Propagator::Instance();
 
   ClusterNativeAccess clusterIndex;

From faadbe1ae03468ca673c6a936fafa95476f57d24 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 3 Apr 2026 23:26:32 +0200
Subject: [PATCH 1591/1764] GPU Standalone: Add dumping and reading of dynamic
 structs with larger buffer than sizeof(struct)

---
 GPU/GPUTracking/Base/GPUReconstruction.h      |  4 ++
 GPU/GPUTracking/Base/GPUReconstructionIO.h    | 51 +++++++++++++++++++
 GPU/GPUTracking/Global/GPUChain.h             | 10 ++++
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  6 +--
 4 files changed, 68 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 21195af1d4a89..c8e162a14c870 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -300,9 +300,13 @@ class GPUReconstruction
   template <class T>
   void DumpStructToFile(const T* obj, const char* file);
   template <class T>
+  void DumpDynamicStructToFile(const T* obj, size_t dynamicSize, const char* file);
+  template <class T>
   std::unique_ptr<T> ReadStructFromFile(const char* file);
   template <class T>
   int32_t ReadStructFromFile(const char* file, T* obj);
+  template <class T, auto F>
+  aligned_unique_buffer_ptr<T> ReadDynamicStructFromFile(const char* file);
 
   // Others
   virtual RecoStepField AvailableGPURecoSteps() { return RecoStep::AllRecoSteps; }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIO.h b/GPU/GPUTracking/Base/GPUReconstructionIO.h
index 810ebfffe1703..c6c15462bc29e 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIO.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIO.h
@@ -208,6 +208,57 @@ inline int32_t GPUReconstruction::ReadStructFromFile(const char* file, T* obj)
   return 0;
 }
 
+template <class T>
+inline void GPUReconstruction::DumpDynamicStructToFile(const T* obj, size_t dynamicSize, const char* file)
+{
+  FILE* fp = fopen(file, "w+b");
+  if (fp == nullptr) {
+    return;
+  }
+  size_t size = sizeof(*obj);
+  fwrite(&size, sizeof(size), 1, fp);
+  fwrite(&dynamicSize, sizeof(dynamicSize), 1, fp);
+  fwrite(obj, 1, dynamicSize, fp);
+  fclose(fp);
+}
+
+template <class T, auto F>
+inline aligned_unique_buffer_ptr<T> GPUReconstruction::ReadDynamicStructFromFile(const char* file)
+{
+  FILE* fp = fopen(file, "rb");
+  if (fp == nullptr) {
+    return nullptr;
+  }
+  size_t size, dynsize, r, r2;
+  r = fread(&size, sizeof(size), 1, fp);
+  r2 = fread(&dynsize, sizeof(dynsize), 1, fp);
+  if (r == 0 || r2 == 0 || size != sizeof(T) || dynsize < size) {
+    fclose(fp);
+    GPUError("ERROR reading %s, invalid size: %ld (%ld buffer size, %ld object size expected)", file, (int64_t)size, (int64_t)dynsize, (int64_t)sizeof(T));
+    throw std::runtime_error("invalid size");
+  }
+  std::unique_ptr<T> tmp = std::make_unique<T>();
+  r = fread(tmp.get(), sizeof(T), 1, fp);
+  if (r == 0) {
+    fclose(fp);
+    GPUError("ERROR reading %s", file, (int64_t)size, (int64_t)sizeof(T));
+    throw std::runtime_error("read error");
+  }
+  if ((tmp.get()->*F)() != dynsize) {
+    fclose(fp);
+    GPUError("ERROR: invalid size: %ld (%ld expected)", file, (int64_t)dynsize, (int64_t)(tmp.get()->*F)());
+    throw std::runtime_error("invalid size");
+  }
+  aligned_unique_buffer_ptr<T> newObj(dynsize);
+  memcpy(newObj.get(), tmp.get(), sizeof(T));
+  r = fread(newObj.getraw() + sizeof(T), 1, dynsize - sizeof(T), fp);
+  fclose(fp);
+  if (GetProcessingSettings().debugLevel >= 2) {
+    GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
+  }
+  return newObj;
+}
+
 } // namespace o2::gpu
 
 #endif
diff --git a/GPU/GPUTracking/Global/GPUChain.h b/GPU/GPUTracking/Global/GPUChain.h
index a524fd9ec3992..61107f7893e9c 100644
--- a/GPU/GPUTracking/Global/GPUChain.h
+++ b/GPU/GPUTracking/Global/GPUChain.h
@@ -176,6 +176,16 @@ class GPUChain
   {
     mRec->ReadStructFromFile<T>(file, obj);
   }
+  template <class T>
+  void DumpDynamicStructToFile(const T* obj, size_t dynamicSize, const char* file)
+  {
+    mRec->DumpDynamicStructToFile<T>(obj, dynamicSize, file);
+  }
+  template <class T, auto F>
+  aligned_unique_buffer_ptr<T> ReadDynamicStructFromFile(const char* file)
+  {
+    return mRec->ReadDynamicStructFromFile<T, F>(file);
+  }
 
   template <class S, int32_t I = 0, typename... Args>
     requires(sizeof(S) >= 0) // Yields better incomplete type errors than calling runKernelCallInterface directly
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 0a879db818c8f..f81f29b45c317 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -295,7 +295,7 @@ void GPUChainTracking::DumpSettings(const char* dir)
   if (processors()->calibObjects.fastTransform != nullptr) {
     f = dir;
     f += "tpctransform.dump";
-    DumpStructToFile(processors()->calibObjects.fastTransform, f.c_str());
+    DumpDynamicStructToFile(processors()->calibObjects.fastTransform, processors()->calibObjects.fastTransform->size(), f.c_str());
   }
   if (processors()->calibObjects.tpcPadGain != nullptr) {
     f = dir;
@@ -334,8 +334,8 @@ void GPUChainTracking::ReadSettings(const char* dir)
   std::string f;
   f = dir;
   f += "tpctransform.dump";
-  mTPCFastTransformU = ReadStructFromFile<TPCFastTransformPOD>(f.c_str());
-  processors()->calibObjects.fastTransform = (TPCFastTransformPOD*)mTPCFastTransformU.get();
+  mTPCFastTransformU = ReadDynamicStructFromFile<TPCFastTransformPOD, &TPCFastTransformPOD::size>(f.c_str());
+  processors()->calibObjects.fastTransform = mTPCFastTransformU.get();
   f = dir;
   f += "tpcpadgaincalib.dump";
   mTPCPadGainCalibU = ReadStructFromFile<TPCPadGainCalib>(f.c_str());

From a3cb3ba78be4ddfcb3f9b1f2a0ba70e1b4c0c52a Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 7 Apr 2026 19:47:00 +0200
Subject: [PATCH 1592/1764] Revert "GPU Display: temporarily disable imgui text
 rendering, for imgui bump"

This reverts commit 05498e8dcae160b9be89f8170f693325c6ccd6ee.
---
 GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
index ba22f92660fd0..75160f064d155 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
@@ -17,10 +17,6 @@
 #include "GPUDisplayGUIWrapper.h"
 #include "GPULogging.h"
 
-#ifdef GPUCA_O2_LIB
-#undef GPUCA_O2_LIB
-#endif
-
 #if defined(GPUCA_O2_LIB) && !defined(GPUCA_DISPLAY_GL3W) // Hack: we have to define this in order to initialize gl3w, cannot include the header as it clashes with glew
 extern "C" int32_t gl3wInit();
 #endif

From c134883bc919950e59e5ae331f06bfc55169c1f7 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 7 Apr 2026 19:44:31 +0200
Subject: [PATCH 1593/1764] GPU OpenGL Display: remove broken functionality to
 draw text via ImGui

---
 .../frontend/GPUDisplayFrontendGlfw.cxx       | 57 +++----------------
 .../display/frontend/GPUDisplayFrontendGlfw.h |  1 -
 2 files changed, 9 insertions(+), 49 deletions(-)

diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
index 75160f064d155..e18ecfb6f083e 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
@@ -31,13 +31,7 @@ extern "C" int32_t gl3wInit();
 #include <unistd.h>
 
 #ifdef GPUCA_O2_LIB
-#if __has_include("../src/imgui.h")
-#include "../src/imgui.h"
-#include "../src/imgui_impl_glfw_gl3.h"
-#else
-#include "DebugGUI/imgui.h"
-#include "DebugGUI/imgui_impl_glfw_gl3.h"
-#endif
+#include <DebugGUI/imgui.h>
 #include <DebugGUI/DebugGUI.h>
 #endif
 
@@ -270,9 +264,6 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, GL_MIN_VERSION_MINOR);
     glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, 0);
     glfwWindowHint(GLFW_OPENGL_PROFILE, mBackend->CoreProfile() ? GLFW_OPENGL_CORE_PROFILE : GLFW_OPENGL_COMPAT_PROFILE);
-#ifdef GPUCA_O2_LIB
-    mUseIMGui = true;
-#endif
   }
   mWindow = glfwCreateWindow(INIT_WIDTH, INIT_HEIGHT, DISPLAY_WINDOW_NAME, nullptr, nullptr);
   if (!mWindow) {
@@ -303,56 +294,26 @@ int32_t GPUDisplayFrontendGlfw::FrontendMain()
     return (-1);
   }
 
-#if defined(GPUCA_O2_LIB) && !defined(GPUCA_DISPLAY_GL3W)
-  if (mUseIMGui && gl3wInit()) {
-    fprintf(stderr, "Error initializing gl3w (2)\n");
-    return (-1); // Hack: We have to initialize gl3w as well, as the DebugGUI uses it.
-  }
-#endif
-
-#ifdef GPUCA_O2_LIB
-  if (mUseIMGui) {
-    mCanDrawText = 2;
-    if (drawTextFontSize() == 0) {
-      drawTextFontSize() = 12;
-    }
-  }
-#endif
-
   if (InitDisplay()) {
     fprintf(stderr, "Error in GLFW display initialization\n");
     return (1);
   }
 
-#ifdef GPUCA_O2_LIB
-  if (mUseIMGui) {
-    ImGui_ImplGlfwGL3_Init(mWindow, false);
-    while (o2::framework::pollGUI(mWindow, DisplayLoop)) {
+  while (!glfwWindowShouldClose(mWindow)) {
+    HandleSendKey();
+    if (DrawGLScene()) {
+      fprintf(stderr, "Error drawing GL scene\n");
+      return (1);
     }
-  } else
-#endif
-  {
-    while (!glfwWindowShouldClose(mWindow)) {
-      HandleSendKey();
-      if (DrawGLScene()) {
-        fprintf(stderr, "Error drawing GL scene\n");
-        return (1);
-      }
-      if (backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL) {
-        glfwSwapBuffers(mWindow);
-      }
-      glfwPollEvents();
+    if (backend()->backendType() == GPUDisplayBackend::TYPE_OPENGL) {
+      glfwSwapBuffers(mWindow);
     }
+    glfwPollEvents();
   }
 
   ExitDisplay();
   mDisplayControl = 2;
   pthread_mutex_lock(&mSemLockExit);
-#ifdef GPUCA_O2_LIB
-  if (mUseIMGui) {
-    ImGui_ImplGlfwGL3_Shutdown();
-  }
-#endif
   glfwDestroyWindow(mWindow);
   glfwTerminate();
   mGlfwRunning = false;
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h
index 43dd3d65531dd..540514a606145 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.h
@@ -62,7 +62,6 @@ class GPUDisplayFrontendGlfw : public GPUDisplayFrontend
   int32_t mWindowHeight = INIT_HEIGHT;
   uint8_t mKeyDownMap[256] = {0};
   uint8_t mLastKeyDown = 0;
-  bool mUseIMGui = false;
 };
 } // namespace o2::gpu
 

From 02c4e153e126d18bc542a133f0f52520d67887f9 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 7 Apr 2026 20:12:18 +0200
Subject: [PATCH 1594/1764] GPU: Renaming and removal of obsolete macros /
 defines

---
 .../TPC/include/DataFormatsTPC/Constants.h    |  2 +-
 .../src/CorrectdEdxDistortions.cxx            |  4 +-
 .../TPC/workflow/src/EntropyEncoderSpec.cxx   | 16 ++--
 GPU/GPUTracking/Base/GPUParam.cxx             |  4 +-
 GPU/GPUTracking/Base/GPUParam.h               |  2 +-
 GPU/GPUTracking/Base/GPUParam.inc             |  6 +-
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 12 +--
 GPU/GPUTracking/Base/GPUReconstruction.h      |  6 +-
 .../Base/GPUReconstructionConvert.cxx         | 40 +++++-----
 GPU/GPUTracking/CMakeLists.txt                |  4 +-
 .../GPUTPCClusterStatistics.cxx               |  4 +-
 .../DataCompression/GPUTPCClusterStatistics.h |  6 +-
 .../DataCompression/GPUTPCCompression.cxx     | 12 +--
 .../GPUTPCCompressionKernels.cxx              | 36 ++++-----
 .../DataCompression/GPUTPCDecompression.cxx   | 10 +--
 .../GPUTPCDecompressionKernels.cxx            | 26 +++----
 .../GPUTPCDecompressionKernels.h              |  2 +-
 .../TPCClusterDecompressionCore.inc           | 14 ++--
 .../TPCClusterDecompressor.cxx                | 18 ++---
 .../DataTypes/GPUMemorySizeScalers.cxx        |  2 +-
 GPU/GPUTracking/DataTypes/GPUO2ExternalUser.h |  3 -
 .../DataTypes/GPUTPCClusterOccupancyMap.h     |  2 +-
 GPU/GPUTracking/DataTypes/GPUTPCGeometry.h    | 73 +++++++++----------
 GPU/GPUTracking/DataTypes/GPUTRDTrack.cxx     |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx    |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadBitMap.h      |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadGainCalib.h   |  2 +-
 .../DataTypes/TPCZSLinkMapping.cxx            |  2 +-
 GPU/GPUTracking/DataTypes/TPCZSLinkMapping.h  |  4 +-
 GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx |  2 +-
 .../Definitions/GPUDefConstantsAndSettings.h  | 16 ++--
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  4 +-
 .../Definitions/clusterFinderDefs.h           |  4 +-
 .../GPUTrackingLinkDef_O2_DataTypes.h         |  2 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  2 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |  2 +-
 .../Global/GPUChainTrackingClusterizer.cxx    | 20 ++---
 .../Global/GPUChainTrackingCompression.cxx    | 42 +++++------
 .../GPUChainTrackingDebugAndProfiling.cxx     | 10 +--
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  4 +-
 .../Global/GPUChainTrackingMerger.cxx         |  2 +-
 .../Global/GPUChainTrackingSectorTracker.cxx  | 12 +--
 .../Global/GPUChainTrackingTransformation.cxx |  4 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     |  6 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx |  2 +-
 .../Merger/GPUTPCGMSectorTrack.cxx            |  4 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 10 +--
 .../GPUTPCCreateOccupancyMap.cxx              |  8 +-
 GPU/GPUTracking/SectorTracker/GPUTPCDef.h     |  5 --
 .../GPUTPCExtrapolationTracking.cxx           |  6 +-
 .../GPUTPCExtrapolationTracking.h             |  2 +-
 GPU/GPUTracking/SectorTracker/GPUTPCMCInfo.h  |  2 +-
 .../SectorTracker/GPUTPCNeighboursCleaner.cxx |  4 +-
 .../SectorTracker/GPUTPCNeighboursFinder.cxx  |  8 +-
 .../SectorTracker/GPUTPCStartHitsFinder.cxx   |  2 +-
 .../SectorTracker/GPUTPCStartHitsSorter.cxx   |  4 +-
 .../SectorTracker/GPUTPCTracker.cxx           | 14 ++--
 .../SectorTracker/GPUTPCTrackerDump.cxx       | 10 +--
 .../SectorTracker/GPUTPCTrackingData.cxx      | 12 +--
 .../GPUTPCTrackletConstructor.cxx             | 12 +--
 .../SectorTracker/GPUTPCTrackletConstructor.h |  2 +-
 .../SectorTracker/GPUTPCTrackletSelector.cxx  |  4 +-
 .../SectorTracker/GPUTPCTrackletSelector.h    |  2 +-
 .../Standalone/Benchmark/standalone.cxx       |  4 +-
 GPU/GPUTracking/Standalone/CMakeLists.txt     |  4 +-
 .../GPUTPCCFCheckPadBaseline.cxx              |  2 +-
 .../GPUTPCCFCheckPadBaseline.h                |  2 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     |  4 +-
 .../GPUTPCCFMCLabelFlattener.cxx              |  2 +-
 .../TPCClusterFinder/GPUTPCClusterFinder.cxx  |  8 +-
 .../GPUTPCClusterFinderDump.cxx               |  2 +-
 .../TRDTracking/GPUTRDSpacePoint.h            |  4 +-
 .../TRDTracking/GPUTRDTrackletWord.cxx        |  4 +-
 .../TRDTracking/GPUTRDTrackletWord.h          |  4 +-
 GPU/GPUTracking/dEdx/GPUdEdx.h                |  2 +-
 .../backend/GPUDisplayBackendOpenGL.cxx       |  7 +-
 .../frontend/GPUDisplayFrontendGlfw.cxx       | 24 ++----
 .../GPUDisplayBackendOpenGLMagneticField.cxx  |  7 --
 .../helpers/GPUDisplayMagneticField.cxx       | 10 +--
 .../display/helpers/GPUDisplayMagneticField.h |  6 +-
 .../display/render/GPUDisplayDraw.cxx         | 14 ++--
 .../display/render/GPUDisplayImportEvent.cxx  |  6 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  | 40 +++++-----
 GPU/GPUTracking/qa/GPUQA.h                    |  8 +-
 GPU/GPUTracking/qa/GPUQAHelper.h              |  2 +-
 GPU/GPUTracking/qa/genEvents.cxx              |  2 +-
 GPU/GPUTracking/utils/qlibload.h              |  2 +-
 GPU/TPCFastTransformation/TPCFastTransform.h  |  2 +-
 90 files changed, 352 insertions(+), 387 deletions(-)

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/Constants.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/Constants.h
index 6f6201b7de8df..0ddf7281be866 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/Constants.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/Constants.h
@@ -28,7 +28,7 @@ namespace constants
 constexpr int MAXSECTOR = 36;
 
 // the number of global pad rows
-#if defined(GPUCA_STANDALONE) && !defined(GPUCA_O2_LIB) && !defined(GPUCA_TPC_GEOMETRY_O2)
+#if defined(GPUCA_STANDALONE) && defined(GPUCA_RUN2)
 constexpr int MAXGLOBALPADROW = 159; // Number of pad rows in Run 2, used for GPU TPC tests with Run 2 data
 #else
 constexpr int MAXGLOBALPADROW = 152; // Correct number of pad rows in Run 3
diff --git a/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx b/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
index 73599e744483c..8398bdca71836 100644
--- a/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
+++ b/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
@@ -87,7 +87,7 @@ float o2::tpc::CorrectdEdxDistortions::getCorrection(const float time, unsigned
   const float ly = mTPCGeometry.LinearPad2Y(sector, padrow, pad);
 
   // get correction at "pad + 0.5*padlength" pos1 and dont extrapolate/interpolate across GEM gaps
-  const int row1 = ((padrow == mTPCGeometry.EndIROC() - 1) || (padrow == mTPCGeometry.EndOROC1() - 1) || (padrow == mTPCGeometry.EndOROC2() - 1)) ? padrow : std::clamp(padrow + 1, 0, GPUCA_ROW_COUNT - 1);
+  const int row1 = ((padrow == mTPCGeometry.EndIROC() - 1) || (padrow == mTPCGeometry.EndOROC1() - 1) || (padrow == mTPCGeometry.EndOROC2() - 1)) ? padrow : std::clamp(padrow + 1, 0, GPUCA_NROWS - 1);
 
   float lxT_1 = 0;
   float lyT_1 = 0;
@@ -101,7 +101,7 @@ float o2::tpc::CorrectdEdxDistortions::getCorrection(const float time, unsigned
   const float r_1_f = std::sqrt(lxT_1 * lxT_1 + lyT_1 * lyT_1);
 
   // get correction at "pad - 0.5*padlength" pos0 and dont extrapolate/interpolate across GEM gaps
-  const int row0 = ((padrow == mTPCGeometry.EndIROC()) || (padrow == mTPCGeometry.EndOROC1()) || (padrow == mTPCGeometry.EndOROC2())) ? padrow : std::clamp(padrow - 1, 0, GPUCA_ROW_COUNT - 1);
+  const int row0 = ((padrow == mTPCGeometry.EndIROC()) || (padrow == mTPCGeometry.EndOROC1()) || (padrow == mTPCGeometry.EndOROC2())) ? padrow : std::clamp(padrow - 1, 0, GPUCA_NROWS - 1);
 
   // check if previous pad row has enough pads
   const unsigned char pad0 = std::clamp(static_cast<int>(pad), 0, mTPCGeometry.NPads(row0) - 1);
diff --git a/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx b/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
index 73bdfa1905f3b..7847919275531 100644
--- a/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
@@ -205,14 +205,14 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
       }
     }
     offset = 0;
-    unsigned int offsets[GPUCA_NSECTORS][GPUCA_ROW_COUNT];
+    unsigned int offsets[GPUCA_NSECTORS][GPUCA_NROWS];
     for (unsigned int i = 0; i < GPUCA_NSECTORS; i++) {
-      for (unsigned int j = 0; j < GPUCA_ROW_COUNT; j++) {
-        if (i * GPUCA_ROW_COUNT + j >= clusters.nSliceRows) {
+      for (unsigned int j = 0; j < GPUCA_NROWS; j++) {
+        if (i * GPUCA_NROWS + j >= clusters.nSliceRows) {
           break;
         }
         offsets[i][j] = offset;
-        offset += (i * GPUCA_ROW_COUNT + j >= clusters.nSliceRows) ? 0 : clusters.nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
+        offset += (i * GPUCA_NROWS + j >= clusters.nSliceRows) ? 0 : clusters.nSliceRowClusters[i * GPUCA_NROWS + j];
       }
     }
 
@@ -220,8 +220,8 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
 #pragma omp parallel for num_threads(mNThreads) schedule(static, (GPUCA_NSECTORS + mNThreads - 1) / mNThreads) // Static round-robin scheduling with one chunk per thread to ensure correct order of the final vector
 #endif
     for (unsigned int ii = 0; ii < clusters.nSliceRows; ii++) {
-      unsigned int i = ii / GPUCA_ROW_COUNT;
-      unsigned int j = ii % GPUCA_ROW_COUNT;
+      unsigned int i = ii / GPUCA_NROWS;
+      unsigned int j = ii % GPUCA_NROWS;
       o2::tpc::ClusterNative preCl;
 #ifdef WITH_OPENMP
       int myThread = omp_get_thread_num();
@@ -240,7 +240,7 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
         const bool reject = mCTFCoder.getIRFramesSelector().check(o2::dataformats::IRFrame(chkVal, chkVal + 1), chkExt, 0) < 0;
         if (reject) {
           rejectHits[k] = true;
-          clustersFiltered.nSliceRowClusters[i * GPUCA_ROW_COUNT + j]--;
+          clustersFiltered.nSliceRowClusters[i * GPUCA_NROWS + j]--;
           static std::atomic_flag lock = ATOMIC_FLAG_INIT;
           while (lock.test_and_set(std::memory_order_acquire)) {
           }
@@ -253,7 +253,7 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
           preCl = cl;
         }
       };
-      unsigned int end = offsets[i][j] + clusters.nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
+      unsigned int end = offsets[i][j] + clusters.nSliceRowClusters[i * GPUCA_NROWS + j];
       o2::gpu::TPCClusterDecompressionCore::decompressHits(clusters, offsets[i][j], end, checker);
     }
     tmpBuffer[0].first.reserve(clustersFiltered.nUnattachedClusters);
diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index aa4c3c7671c93..db086eae40df3 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -38,7 +38,7 @@ void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
   occupancyMapSize = 0;
   occupancyTotal = 0;
 
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   const float kErrorsY[4] = {0.06, 0.24, 0.12, 0.1};
   const float kErrorsZ[4] = {0.06, 0.24, 0.15, 0.1};
 
@@ -161,7 +161,7 @@ void GPUParam::SetDefaults(const GPUSettingsGRP* g, const GPUSettingsRec* r, con
 
 void GPUParam::UpdateRun3ClusterErrors(const float* yErrorParam, const float* zErrorParam)
 {
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   for (int32_t yz = 0; yz < 2; yz++) {
     const float* param = yz ? zErrorParam : yErrorParam;
     for (int32_t rowType = 0; rowType < 4; rowType++) {
diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 0716274c5e198..9dc9d2eeafc7f 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -68,7 +68,7 @@ struct GPUParam_t {
   GPUParamSector SectorParam[GPUCA_NSECTORS];
 
  protected:
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   float ParamErrors[2][4][4]; // cluster error parameterization used during seeding and fit
 #else
   float ParamErrorsSeeding0[2][3][4]; // cluster error parameterization used during seeding
diff --git a/GPU/GPUTracking/Base/GPUParam.inc b/GPU/GPUTracking/Base/GPUParam.inc
index dbccca4d7c46b..8e8c77b931942 100644
--- a/GPU/GPUTracking/Base/GPUParam.inc
+++ b/GPU/GPUTracking/Base/GPUParam.inc
@@ -39,7 +39,7 @@ GPUdi() void GPUParam::Global2Sector(int32_t iSector, float X, float Y, float Z,
   *z = Z;
 }
 
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
 
 GPUdi() void GPUParam::GetClusterErrorsSeeding2(uint8_t sector, int32_t iRow, float z, float sinPhi, float DzDs, float time, float& ErrY2, float& ErrZ2) const
 {
@@ -121,7 +121,7 @@ GPUdi() float GPUParam::GetSystematicClusterErrorC122(float x, float y, uint8_t
   return errC12 * errC12;
 }
 
-#else // GPUCA_TPC_GEOMETRY_O2
+#else // !GPUCA_RUN2
 
 GPUdi() float GPUParam::GetClusterErrorSeeding(int32_t yz, int32_t type, float zDiff, float angle2, float scaledMult) const
 {
@@ -169,7 +169,7 @@ GPUdi() float GPUParam::GetSystematicClusterErrorC122(float trackX, float trackY
   return 0;
 }
 
-#endif // !GPUCA_TPC_GEOMETRY_O2
+#endif // GPUCA_RUN2
 
 GPUdi() void GPUParam::GetClusterErrors2(uint8_t sector, int32_t iRow, float z, float sinPhi, float DzDs, float time, float avgInvCharge, float invCharge, float& ErrY2, float& ErrZ2) const
 {
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 37468477c3b7d..f3449eda6b1a5 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -42,7 +42,7 @@
 #include "utils/strtag.h"
 #include "utils/stdspinlock.h"
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 #include "GPUO2InterfaceConfiguration.h"
 #endif
 
@@ -1249,15 +1249,15 @@ int32_t GPUReconstruction::ReadSettings(const char* dir)
 
 void GPUReconstruction::SetSettings(float solenoidBzNominalGPU, const GPURecoStepConfiguration* workflow)
 {
-#ifdef GPUCA_O2_LIB
+#ifdef GPUCA_STANDALONE
+  GPUSettingsGRP grp;
+  grp.solenoidBzNominalGPU = solenoidBzNominalGPU;
+  SetSettings(&grp, nullptr, nullptr, workflow);
+#else
   GPUO2InterfaceConfiguration config;
   config.ReadConfigurableParam(config);
   config.configGRP.solenoidBzNominalGPU = solenoidBzNominalGPU;
   SetSettings(&config.configGRP, &config.configReconstruction, &config.configProcessing, workflow);
-#else
-  GPUSettingsGRP grp;
-  grp.solenoidBzNominalGPU = solenoidBzNominalGPU;
-  SetSettings(&grp, nullptr, nullptr, workflow);
 #endif
 }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index c8e162a14c870..fe04c62b59b7a 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -92,10 +92,10 @@ class GPUReconstruction
   using InOutTypeField = gpudatatypes::InOutTypeField;
 
   static constexpr const char* const GEOMETRY_TYPE_NAMES[] = {"INVALID", "ALIROOT", "O2"};
-#ifdef GPUCA_TPC_GEOMETRY_O2
-  static constexpr GeometryType geometryType = GeometryType::O2;
-#else
+#ifdef GPUCA_RUN2
   static constexpr GeometryType geometryType = GeometryType::ALIROOT;
+#else
+  static constexpr GeometryType geometryType = GeometryType::O2;
 #endif
 
   static DeviceType GetDeviceType(const char* type);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
index 0aabb30f60e1a..54784d0e1a5dc 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
@@ -12,7 +12,7 @@
 /// \file GPUReconstructionConvert.cxx
 /// \author David Rohr
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 #include "DetectorsRaw/RawFileWriter.h"
 #include "TPCBase/Sector.h"
 #include "DataFormatsTPC/Digit.h"
@@ -54,13 +54,13 @@ void GPUReconstructionConvert::ConvertNativeToClusterData(o2::tpc::ClusterNative
   uint32_t offset = 0;
   for (uint32_t i = 0; i < NSECTORS; i++) {
     uint32_t nClSector = 0;
-    for (int32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+    for (int32_t j = 0; j < GPUCA_NROWS; j++) {
       nClSector += native->nClusters[i][j];
     }
     nClusters[i] = nClSector;
     clusters[i].reset(new GPUTPCClusterData[nClSector]);
     nClSector = 0;
-    for (int32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+    for (int32_t j = 0; j < GPUCA_NROWS; j++) {
       for (uint32_t k = 0; k < native->nClusters[i][j]; k++) {
         const auto& clin = native->clusters[i][j][k];
         float x = 0, y = 0, z = 0;
@@ -98,7 +98,7 @@ void GPUReconstructionConvert::ConvertRun2RawToNative(o2::tpc::ClusterNativeAcce
   native.clustersLinear = nativeBuffer.get();
   native.setOffsetPtrs();
   for (uint32_t i = 0; i < NSECTORS; i++) {
-    for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
       native.nClusters[i][j] = 0;
     }
     for (uint32_t j = 0; j < nRawClusters[i]; j++) {
@@ -119,7 +119,7 @@ int32_t GPUReconstructionConvert::GetMaxTimeBin(const ClusterNativeAccess& nativ
 {
   float retVal = 0;
   for (uint32_t i = 0; i < NSECTORS; i++) {
-    for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
       for (uint32_t k = 0; k < native.nClusters[i][j]; k++) {
         if (native.clusters[i][j][k].getTime() > retVal) {
           retVal = native.clusters[i][j][k].getTime();
@@ -174,7 +174,7 @@ int32_t GPUReconstructionConvert::GetMaxTimeBin(const GPUTrackingInOutZS& zspage
 
 // ------------------------------------------------- TPC ZS -------------------------------------------------
 
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
 namespace o2::gpu
 {
 namespace // anonymous
@@ -193,7 +193,7 @@ struct zsEncoder {
   const o2::InteractionRecord* ir = nullptr;
   const GPUParam* param = nullptr;
   bool padding = false;
-  int32_t lastEndpoint = -2, lastTime = -1, lastRow = GPUCA_ROW_COUNT;
+  int32_t lastEndpoint = -2, lastTime = -1, lastRow = GPUCA_NROWS;
   int32_t endpoint = 0, outputEndpoint = 0;
   int64_t hbf = -1, nexthbf = 0;
   zsPage* page = nullptr;
@@ -244,11 +244,11 @@ inline void zsEncoder::ZSstreamOut(uint16_t* bufIn, uint32_t& lenIn, uint8_t* bu
 
 static inline auto ZSEncoderGetDigits(const GPUTrackingInOutDigits& in, int32_t i) { return in.tpcDigits[i]; }
 static inline auto ZSEncoderGetNDigits(const GPUTrackingInOutDigits& in, int32_t i) { return in.nTPCDigits[i]; }
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 using DigitArray = std::array<gsl::span<const o2::tpc::Digit>, o2::tpc::Sector::MAXSECTOR>;
 static inline auto ZSEncoderGetDigits(const DigitArray& in, int32_t i) { return in[i].data(); }
 static inline auto ZSEncoderGetNDigits(const DigitArray& in, int32_t i) { return in[i].size(); }
-#endif // GPUCA_O2_LIB
+#endif
 
 // ------------------------------------------------- TPC ZS Original Row-based ZS -------------------------------------------------
 
@@ -364,7 +364,7 @@ uint32_t zsEncoderRow::encodeSequence(std::vector<o2::tpc::Digit>& tmpBuffer, ui
     curTBHdr = reinterpret_cast<TPCZSTBHDR*>(pagePtr);
     curTBHdr->rowMask |= (endpoint & 1) << 15;
     nRowsInTB = 0;
-    lastRow = GPUCA_ROW_COUNT;
+    lastRow = GPUCA_NROWS;
   }
   if (tmpBuffer[k].getRow() != lastRow) {
     curTBHdr->rowMask |= 1 << (tmpBuffer[k].getRow() - endpointStart);
@@ -460,7 +460,7 @@ void zsEncoderRow::decodePage(std::vector<o2::tpc::Digit>& outputBuffer, const z
 
 // ------------------------------------------------- TPC ZS Link Based ZS -------------------------------------------------
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 struct zsEncoderLinkBased : public zsEncoder {
   TPCZSHDRV2* hdr = nullptr;
   TPCZSHDRV2 hdrBuffer;
@@ -1045,7 +1045,7 @@ void zsEncoderDenseLinkBased::amendPageErrorMessage(std::ostringstream& oss, con
   oss << "Meta header of page: " << dumpBuffer << "\n";
 }
 
-#endif // GPUCA_O2_LIB
+#endif // !GPUCA_STANDALONE
 
 // ------------------------------------------------- TPC ZS Main Encoder -------------------------------------------------
 
@@ -1095,7 +1095,7 @@ inline uint32_t zsEncoderRun<T>::run(std::vector<zsPage>* buffer, std::vector<o2
 {
   uint32_t totalPages = 0;
   zsPage singleBuffer;
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
   int32_t maxhbf = 0;
   int32_t minhbf = o2::constants::lhc::LHCMaxBunches;
 #endif
@@ -1178,7 +1178,7 @@ inline uint32_t zsEncoderRun<T>::run(std::vector<zsPage>* buffer, std::vector<o2
         }
         size_t size = !std::is_same_v<T, struct zsEncoderDenseLinkBased> && (padding || lastEndpoint == -1 || hbf == nexthbf) ? TPCZSHDR::TPC_ZS_PAGE_SIZE : (pagePtr - (uint8_t*)page);
         size = CAMath::nextMultipleOf<o2::raw::RDHUtils::GBTWord128>(size);
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
         if (raw) {
           raw->addData(rawfeeid, rawcru, 0, rawendpoint, *ir + hbf * o2::constants::lhc::LHCMaxBunches, gsl::span<char>((char*)page + sizeof(o2::header::RAWDataHeader), (char*)page + size), true, 0, 2);
           maxhbf = std::max<int32_t>(maxhbf, hbf);
@@ -1257,7 +1257,7 @@ inline uint32_t zsEncoderRun<T>::run(std::vector<zsPage>* buffer, std::vector<o2
     k += nEncoded;
   }
   if (raw) {
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
     if (iSector == 0) {
       for (int32_t i = minhbf; i <= maxhbf; i++) {
         raw->addData(46208, 360, rdh_utils::SACLinkID, 0, *ir + i * o2::constants::lhc::LHCMaxBunches, gsl::span<char>((char*)&singleBuffer, (char*)&singleBuffer), true, 0, 4);
@@ -1310,7 +1310,7 @@ size_t zsEncoderRun<T>::compare(std::vector<zsPage>* buffer, std::vector<o2::tpc
 
 } // anonymous namespace
 } // namespace o2::gpu
-#endif // GPUCA_TPC_GEOMETRY_O2
+#endif // !GPUCA_RUN2
 
 template <class S>
 void GPUReconstructionConvert::RunZSEncoder(const S& in, std::unique_ptr<uint64_t[]>* outBuffer, uint32_t* outSizes, o2::raw::RawFileWriter* raw, const o2::InteractionRecord* ir, const GPUParam& param, int32_t version, bool verify, float threshold, bool padding, std::function<void(std::vector<o2::tpc::Digit>&)> digitsFilter)
@@ -1320,7 +1320,7 @@ void GPUReconstructionConvert::RunZSEncoder(const S& in, std::unique_ptr<uint64_
   if (((outBuffer == nullptr) ^ (outSizes == nullptr)) || ((raw != nullptr) && (ir == nullptr)) || !((outBuffer == nullptr) ^ (raw == nullptr)) || (raw && verify)) {
     throw std::runtime_error("Invalid parameters");
   }
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   std::vector<zsPage> buffer[NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
   struct tmpReductionResult {
     uint32_t totalPages = 0;
@@ -1365,7 +1365,7 @@ void GPUReconstructionConvert::RunZSEncoder(const S& in, std::unique_ptr<uint64_
         zsEncoderRun<zsEncoderRow> enc{{{.iSector = i, .raw = raw, .ir = ir, .param = &param, .padding = padding}}};
         runZS(enc);
       } else if (version >= ZSVersion::ZSVersionLinkBasedWithMeta && version <= ZSVersion::ZSVersionDenseLinkBasedV2) {
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
         if (version == ZSVersion::ZSVersionLinkBasedWithMeta) {
           zsEncoderRun<zsEncoderImprovedLinkBased> enc{{{{.iSector = i, .raw = raw, .ir = ir, .param = &param, .padding = padding}}}};
           runZS(enc);
@@ -1410,7 +1410,7 @@ void GPUReconstructionConvert::RunZSEncoder(const S& in, std::unique_ptr<uint64_
 }
 
 template void GPUReconstructionConvert::RunZSEncoder<GPUTrackingInOutDigits>(const GPUTrackingInOutDigits&, std::unique_ptr<uint64_t[]>*, uint32_t*, o2::raw::RawFileWriter*, const o2::InteractionRecord*, const GPUParam&, int32_t, bool, float, bool, std::function<void(std::vector<o2::tpc::Digit>&)> digitsFilter);
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 template void GPUReconstructionConvert::RunZSEncoder<DigitArray>(const DigitArray&, std::unique_ptr<uint64_t[]>*, uint32_t*, o2::raw::RawFileWriter*, const o2::InteractionRecord*, const GPUParam&, int32_t, bool, float, bool, std::function<void(std::vector<o2::tpc::Digit>&)> digitsFilter);
 #endif
 
@@ -1454,7 +1454,7 @@ void GPUReconstructionConvert::RunZSFilter(std::unique_ptr<o2::tpc::Digit[]>* bu
   }
 }
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 namespace o2::gpu::internal
 {
 template <class T>
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index c276bf59af40b..47e4bd2cc1b25 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -355,7 +355,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                                        O2::TPCFastTransformation
                  PRIVATE_LINK_LIBRARIES O2::DataFormatsTPC
                  SOURCES ${SRCS_DATATYPES})
-  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2)
+  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB)
 
   o2_target_root_dictionary(GPUDataTypes
                             HEADERS ${HDRS_CINT_DATATYPES} ${HDRS_CINT_O2_ADDITIONAL}
@@ -384,7 +384,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     ${targetName}
     PRIVATE $<TARGET_PROPERTY:O2::Framework,INTERFACE_INCLUDE_DIRECTORIES>)
 
-  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB GPUCA_TPC_GEOMETRY_O2)
+  target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB)
 
   o2_target_root_dictionary(${MODULE}
                             HEADERS ${HDRS_CINT_O2} ${HDRS_CINT_O2_ADDITIONAL}
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
index b11a3b13d7132..968e88e3a274c 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
@@ -117,7 +117,7 @@ void GPUTPCClusterStatistics::RunStatistics(const o2::tpc::ClusterNativeAccess*
   std::vector<o2::tpc::ClusterNative> tmpClusters;
   if (param.rec.tpc.rejectionStrategy == GPUSettings::RejectionNone) { // verification does not make sense if we reject clusters during compression
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
         if (clustersNative->nClusters[i][j] != clustersNativeDecoded.nClusters[i][j]) {
           GPUError("Number of clusters mismatch sector %u row %u: expected %d v.s. decoded %d", i, j, clustersNative->nClusters[i][j], clustersNativeDecoded.nClusters[i][j]);
           decodingErrors++;
@@ -181,7 +181,7 @@ void GPUTPCClusterStatistics::RunStatistics(const o2::tpc::ClusterNativeAccess*
   FillStatisticCombined(mPsigmaU, clustersCompressed->sigmaPadU, clustersCompressed->sigmaTimeU, clustersCompressed->nUnattachedClusters, P_MAX_SIGMA);
   FillStatisticCombined(mPQA, clustersCompressed->qMaxA, clustersCompressed->qTotA, clustersCompressed->nAttachedClusters, P_MAX_QMAX);
   FillStatisticCombined(mPQU, clustersCompressed->qMaxU, clustersCompressed->qTotU, clustersCompressed->nUnattachedClusters, P_MAX_QMAX);
-  FillStatisticCombined(mProwSectorA, clustersCompressed->rowDiffA, clustersCompressed->sliceLegDiffA, clustersCompressed->nAttachedClustersReduced, GPUCA_ROW_COUNT);
+  FillStatisticCombined(mProwSectorA, clustersCompressed->rowDiffA, clustersCompressed->sliceLegDiffA, clustersCompressed->nAttachedClustersReduced, GPUCA_NROWS);
   mNTotalClusters += clustersCompressed->nAttachedClusters + clustersCompressed->nUnattachedClusters;
 }
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h
index 1dfb958750bef..5b66ca54fe591 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h
@@ -54,14 +54,14 @@ class GPUTPCClusterStatistics
   std::vector<int32_t> mPqTotA = std::vector<int32_t>(P_MAX_QTOT, 0);
   std::vector<int32_t> mPqMaxA = std::vector<int32_t>(P_MAX_QMAX, 0);
   std::vector<int32_t> mPflagsA = std::vector<int32_t>(P_MAX_FLAGS, 0);
-  std::vector<int32_t> mProwDiffA = std::vector<int32_t>(GPUCA_ROW_COUNT, 0);
+  std::vector<int32_t> mProwDiffA = std::vector<int32_t>(GPUCA_NROWS, 0);
   std::vector<int32_t> mPsectorLegDiffA = std::vector<int32_t>(GPUCA_NSECTORS * 2, 0);
   std::vector<int32_t> mPpadResA = std::vector<int32_t>(P_MAX_PAD, 0);
   std::vector<int32_t> mPtimeResA = std::vector<int32_t>(P_MAX_TIME, 0);
   std::vector<int32_t> mPsigmaPadA = std::vector<int32_t>(P_MAX_SIGMA, 0);
   std::vector<int32_t> mPsigmaTimeA = std::vector<int32_t>(P_MAX_SIGMA, 0);
   std::vector<int32_t> mPqPtA = std::vector<int32_t>(P_MAX_QPT, 0);
-  std::vector<int32_t> mProwA = std::vector<int32_t>(GPUCA_ROW_COUNT, 0);
+  std::vector<int32_t> mProwA = std::vector<int32_t>(GPUCA_NROWS, 0);
   std::vector<int32_t> mPsectorA = std::vector<int32_t>(GPUCA_NSECTORS, 0);
   std::vector<int32_t> mPtimeA = std::vector<int32_t>(P_MAX_TIME, 0);
   std::vector<int32_t> mPpadA = std::vector<int32_t>(P_MAX_PAD, 0);
@@ -78,7 +78,7 @@ class GPUTPCClusterStatistics
   std::vector<int32_t> mPsigmaA = std::vector<int32_t>(P_MAX_SIGMA * P_MAX_SIGMA, 0);
   std::vector<int32_t> mPQU = std::vector<int32_t>(P_MAX_QMAX * P_MAX_QTOT, 0);
   std::vector<int32_t> mPQA = std::vector<int32_t>(P_MAX_QMAX * P_MAX_QTOT, 0);
-  std::vector<int32_t> mProwSectorA = std::vector<int32_t>(GPUCA_ROW_COUNT * GPUCA_NSECTORS * 2, 0);
+  std::vector<int32_t> mProwSectorA = std::vector<int32_t>(GPUCA_NROWS * GPUCA_NSECTORS * 2, 0);
 
   double mEntropy = 0;
   double mHuffman = 0;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index efb7a4af3f323..1b52a891ef6b1 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -69,7 +69,7 @@ void GPUTPCCompression::SetPointersCompressedClusters(void*& mem, T& c, uint32_t
   computePointerWithAlignment(mem, c.timeDiffU, nClU);
   computePointerWithAlignment(mem, c.sigmaPadU, nClU);
   computePointerWithAlignment(mem, c.sigmaTimeU, nClU);
-  computePointerWithAlignment(mem, c.nSliceRowClusters, GPUCA_ROW_COUNT * NSECTORS);
+  computePointerWithAlignment(mem, c.nSliceRowClusters, GPUCA_NROWS * NSECTORS);
 
   uint32_t nClAreduced = reducedClA ? nClA - nTr : nClA;
 
@@ -139,8 +139,8 @@ void GPUTPCCompression::DumpCompressedClusters(std::ostream& out)
   out << "Slice Row Clusters:\n";
   for (uint32_t i = 0; i < NSECTORS; i++) {
     out << "Sector " << i << ": ";
-    for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-      out << (O.nSliceRowClusters ? O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j] : 0) << ", ";
+    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+      out << (O.nSliceRowClusters ? O.nSliceRowClusters[i * GPUCA_NROWS + j] : 0) << ", ";
     }
     out << "\n";
   }
@@ -155,16 +155,16 @@ void GPUTPCCompression::DumpCompressedClusters(std::ostream& out)
   uint32_t offset = 0;
   if (O.nSliceRowClusters) {
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
         out << "Sector " << i << " Row " << j << ": ";
-        for (uint32_t k = 0; k < O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j]; k++) {
+        for (uint32_t k = 0; k < O.nSliceRowClusters[i * GPUCA_NROWS + j]; k++) {
           if (k && k % 10 == 0) {
             out << "\n    ";
           }
           const uint32_t l = k + offset;
           out << "[" << (uint32_t)O.qTotU[l] << ", " << (uint32_t)O.qMaxU[l] << ", " << (uint32_t)O.flagsU[l] << ", " << (int32_t)O.padDiffU[l] << ", " << (int32_t)O.timeDiffU[l] << ", " << (uint32_t)O.sigmaPadU[l] << ", " << (uint32_t)O.sigmaTimeU[l] << "] ";
         }
-        offset += O.nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
+        offset += O.nSliceRowClusters[i * GPUCA_NROWS + j];
         out << "\n";
       }
     }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 1cd44e221f203..92b367f7858b9 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -102,7 +102,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
 
         if (param.rec.tpc.compressionTypeMask & GPUSettings::CompressionDifferences) {
           if (lastRow > row) {
-            row += GPUCA_ROW_COUNT;
+            row += GPUCA_NROWS;
           }
           row -= lastRow;
           if (lastSector > sector) {
@@ -112,7 +112,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
         }
         c.rowDiffA[cidx] = row;
         c.sliceLegDiffA[cidx] = sector;
-        float pad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_ROW_COUNT - 1), track.LinearY2Pad(hit.sector, track.Y(), geo.PadWidth(hit.row), geo.NPads(hit.row))));
+        float pad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_NROWS - 1), track.LinearY2Pad(hit.sector, track.Y(), geo.PadWidth(hit.row), geo.NPads(hit.row))));
         c.padResA[cidx] = orgCl.padPacked - orgCl.packPad(pad);
         float time = CAMath::Max(0.f, geo.LinearZ2Time(hit.sector, track.Z() + zOffset));
         c.timeResA[cidx] = (orgCl.getTimePacked() - orgCl.packTime(time)) & 0xFFFFFF;
@@ -221,9 +221,9 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
   GPUTPCCompression& GPUrestrict() compressor = processors.tpcCompressor;
   GPUParam& GPUrestrict() param = processors.param;
   uint32_t* sortBuffer = smem.sortBuffer;
-  for (int32_t iSectorRow = iBlock; iSectorRow < GPUCA_NSECTORS * GPUCA_ROW_COUNT; iSectorRow += nBlocks) {
-    const uint32_t iSector = iSectorRow / GPUCA_ROW_COUNT;
-    const uint32_t iRow = iSectorRow % GPUCA_ROW_COUNT;
+  for (int32_t iSectorRow = iBlock; iSectorRow < GPUCA_NSECTORS * GPUCA_NROWS; iSectorRow += nBlocks) {
+    const uint32_t iSector = iSectorRow / GPUCA_NROWS;
+    const uint32_t iRow = iSectorRow % GPUCA_NROWS;
     const uint32_t idOffset = clusters->clusterOffset[iSector][iRow];
     const uint32_t idOffsetOut = clusters->clusterOffset[iSector][iRow] * compressor.mMaxClusterFactorBase1024 / 1024;                           // 32 bit enough for number of clusters per row * 1024
     const uint32_t idOffsetOutMax = ((const uint32_t*)clusters->clusterOffset[iSector])[iRow + 1] * compressor.mMaxClusterFactorBase1024 / 1024; // Array out of bounds access is ok, since it goes to the correct nClustersTotal
@@ -321,7 +321,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
     }
 
     if (iThread == nThreads - 1) {
-      c.nSliceRowClusters[iSector * GPUCA_ROW_COUNT + iRow] = totalCount;
+      c.nSliceRowClusters[iSector * GPUCA_NROWS + iRow] = totalCount;
       CAMath::AtomicAdd(&compressor.mMemory->nStoredUnattachedClusters, totalCount);
     }
     GPUbarrier();
@@ -547,7 +547,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::Thread<GPUTPCCompressionGatherKern
 
   if (iBlock == 0) {
 
-    uint32_t nRows = compressor.NSECTORS * GPUCA_ROW_COUNT;
+    uint32_t nRows = compressor.NSECTORS * GPUCA_NROWS;
     uint32_t rowsPerWarp = (nRows + nWarps - 1) / nWarps;
     uint32_t rowStart = rowsPerWarp * iWarp;
     uint32_t rowEnd = CAMath::Min(nRows, rowStart + rowsPerWarp);
@@ -558,7 +558,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::Thread<GPUTPCCompressionGatherKern
 
     uint32_t rowsOffset = calculateWarpOffsets(smem, compressor.mPtrs.nSliceRowClusters, rowStart, rowEnd, nWarps, iWarp, nLanes, iLane);
 
-    compressorMemcpy(compressor.mOutput->nSliceRowClusters, compressor.mPtrs.nSliceRowClusters, compressor.NSECTORS * GPUCA_ROW_COUNT, nThreads, iThread);
+    compressorMemcpy(compressor.mOutput->nSliceRowClusters, compressor.mPtrs.nSliceRowClusters, compressor.NSECTORS * GPUCA_NROWS, nThreads, iThread);
     compressorMemcpy(compressor.mOutput->nTrackClusters, compressor.mPtrs.nTrackClusters, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpy(compressor.mOutput->qPtA, compressor.mPtrs.qPtA, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpy(compressor.mOutput->rowA, compressor.mPtrs.rowA, compressor.mMemory->nStoredTracks, nThreads, iThread);
@@ -566,15 +566,15 @@ GPUdii() void GPUTPCCompressionGatherKernels::Thread<GPUTPCCompressionGatherKern
     compressorMemcpy(compressor.mOutput->timeA, compressor.mPtrs.timeA, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpy(compressor.mOutput->padA, compressor.mPtrs.padA, compressor.mMemory->nStoredTracks, nThreads, iThread);
 
-    uint32_t sectorStart = rowStart / GPUCA_ROW_COUNT;
-    uint32_t sectorEnd = rowEnd / GPUCA_ROW_COUNT;
+    uint32_t sectorStart = rowStart / GPUCA_NROWS;
+    uint32_t sectorEnd = rowEnd / GPUCA_NROWS;
 
-    uint32_t sectorRowStart = rowStart % GPUCA_ROW_COUNT;
-    uint32_t sectorRowEnd = rowEnd % GPUCA_ROW_COUNT;
+    uint32_t sectorRowStart = rowStart % GPUCA_NROWS;
+    uint32_t sectorRowEnd = rowEnd % GPUCA_NROWS;
 
     for (uint32_t i = sectorStart; i <= sectorEnd && i < compressor.NSECTORS; i++) {
-      for (uint32_t j = ((i == sectorStart) ? sectorRowStart : 0); j < ((i == sectorEnd) ? sectorRowEnd : GPUCA_ROW_COUNT); j++) {
-        uint32_t nClusters = compressor.mPtrs.nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
+      for (uint32_t j = ((i == sectorStart) ? sectorRowStart : 0); j < ((i == sectorEnd) ? sectorRowEnd : GPUCA_NROWS); j++) {
+        uint32_t nClusters = compressor.mPtrs.nSliceRowClusters[i * GPUCA_NROWS + j];
         uint32_t clusterOffsetInCache = clusters->clusterOffset[i][j] * compressor.mMaxClusterFactorBase1024 / 1024;
         compressorMemcpy(compressor.mOutput->qTotU + rowsOffset, compressor.mPtrs.qTotU + clusterOffsetInCache, nClusters, nLanes, iLane);
         compressorMemcpy(compressor.mOutput->qMaxU + rowsOffset, compressor.mPtrs.qMaxU + clusterOffsetInCache, nClusters, nLanes, iLane);
@@ -653,7 +653,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::gatherBuffered(int32_t nBlocks, in
   auto& input = compressor.mPtrs;
   auto* output = compressor.mOutput;
 
-  uint32_t nRows = compressor.NSECTORS * GPUCA_ROW_COUNT;
+  uint32_t nRows = compressor.NSECTORS * GPUCA_NROWS;
   uint32_t rowsPerWarp = (nRows + nGlobalWarps - 1) / nGlobalWarps;
   uint32_t rowStart = rowsPerWarp * iGlobalWarp;
   uint32_t rowEnd = CAMath::Min(nRows, rowStart + rowsPerWarp);
@@ -678,7 +678,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::gatherBuffered(int32_t nBlocks, in
   uint32_t tracksOffset = calculateWarpOffsets(smem, input.nTrackClusters, trackStart, trackEnd, nWarps, iWarp, nLanes, iLane);
 
   if (iBlock == 0) {
-    compressorMemcpyBasic(output->nSliceRowClusters, input.nSliceRowClusters, compressor.NSECTORS * GPUCA_ROW_COUNT, nThreads, iThread);
+    compressorMemcpyBasic(output->nSliceRowClusters, input.nSliceRowClusters, compressor.NSECTORS * GPUCA_NROWS, nThreads, iThread);
     compressorMemcpyBasic(output->nTrackClusters, input.nTrackClusters, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpyBasic(output->qPtA, input.qPtA, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpyBasic(output->rowA, input.rowA, compressor.mMemory->nStoredTracks, nThreads, iThread);
@@ -731,7 +731,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::gatherMulti(int32_t nBlocks, int32
   auto* buf = smem.getBuffer<Vec128>(iWarp);
 
   if (iBlock == 0) {
-    compressorMemcpyBasic(output->nSliceRowClusters, input.nSliceRowClusters, compressor.NSECTORS * GPUCA_ROW_COUNT, nThreads, iThread);
+    compressorMemcpyBasic(output->nSliceRowClusters, input.nSliceRowClusters, compressor.NSECTORS * GPUCA_NROWS, nThreads, iThread);
     compressorMemcpyBasic(output->nTrackClusters, input.nTrackClusters, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpyBasic(output->qPtA, input.qPtA, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpyBasic(output->rowA, input.rowA, compressor.mMemory->nStoredTracks, nThreads, iThread);
@@ -742,7 +742,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::gatherMulti(int32_t nBlocks, int32
     const uint32_t nGlobalWarps = nWarps * (nBlocks - 1) / 2;
     const uint32_t iGlobalWarp = nWarps * (iBlock - 1) / 2 + iWarp;
 
-    const uint32_t nRows = compressor.NSECTORS * GPUCA_ROW_COUNT;
+    const uint32_t nRows = compressor.NSECTORS * GPUCA_NROWS;
     uint32_t rowsPerWarp = (nRows + nGlobalWarps - 1) / nGlobalWarps;
     uint32_t rowStart = rowsPerWarp * iGlobalWarp;
     uint32_t rowEnd = CAMath::Min(nRows, rowStart + rowsPerWarp);
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
index b2949b5a98fd2..52fd4858820b3 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
@@ -40,7 +40,7 @@ void GPUTPCDecompression::SetPointersCompressedClusters(void*& mem, T& c, uint32
   computePointerWithAlignment(mem, c.timeDiffU, nClU);
   computePointerWithAlignment(mem, c.sigmaPadU, nClU);
   computePointerWithAlignment(mem, c.sigmaTimeU, nClU);
-  computePointerWithAlignment(mem, c.nSliceRowClusters, GPUCA_ROW_COUNT * NSECTORS);
+  computePointerWithAlignment(mem, c.nSliceRowClusters, GPUCA_NROWS * NSECTORS);
 
   uint32_t nClAreduced = reducedClA ? nClA - nTr : nClA;
 
@@ -68,19 +68,19 @@ void GPUTPCDecompression::SetPointersCompressedClusters(void*& mem, T& c, uint32
 
 void* GPUTPCDecompression::SetPointersTmpNativeBuffersGPU(void* mem)
 {
-  computePointerWithAlignment(mem, mTmpNativeClusters, NSECTORS * GPUCA_ROW_COUNT * mMaxNativeClustersPerBuffer);
+  computePointerWithAlignment(mem, mTmpNativeClusters, NSECTORS * GPUCA_NROWS * mMaxNativeClustersPerBuffer);
   return mem;
 }
 
 void* GPUTPCDecompression::SetPointersTmpNativeBuffersOutput(void* mem)
 {
-  computePointerWithAlignment(mem, mNativeClustersIndex, NSECTORS * GPUCA_ROW_COUNT);
+  computePointerWithAlignment(mem, mNativeClustersIndex, NSECTORS * GPUCA_NROWS);
   return mem;
 }
 
 void* GPUTPCDecompression::SetPointersTmpNativeBuffersInput(void* mem)
 {
-  computePointerWithAlignment(mem, mUnattachedClustersOffsets, NSECTORS * GPUCA_ROW_COUNT);
+  computePointerWithAlignment(mem, mUnattachedClustersOffsets, NSECTORS * GPUCA_NROWS);
   computePointerWithAlignment(mem, mAttachedClustersOffsets, mInputGPU.nTracks);
   return mem;
 }
@@ -99,7 +99,7 @@ void* GPUTPCDecompression::SetPointersInputClusterNativeAccess(void* mem)
 
 void* GPUTPCDecompression::SetPointersNClusterPerSectorRow(void* mem)
 {
-  computePointerWithAlignment(mem, mNClusterPerSectorRow, NSECTORS * GPUCA_ROW_COUNT);
+  computePointerWithAlignment(mem, mNClusterPerSectorRow, NSECTORS * GPUCA_NROWS);
   return mem;
 }
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
index 68e45f0c08c32..f15bc8d4f3406 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
@@ -45,10 +45,10 @@ GPUdii() void GPUTPCDecompressionKernels::Thread<GPUTPCDecompressionKernels::ste
   ClusterNative* GPUrestrict() clusterBuffer = decompressor.mNativeClustersBuffer;
   const ClusterNativeAccess* outputAccess = decompressor.mClusterNativeAccess;
   uint32_t* offsets = decompressor.mUnattachedClustersOffsets;
-  for (int32_t i = get_global_id(0); i < GPUCA_ROW_COUNT * nSectors; i += get_global_size(0)) {
-    uint32_t iRow = i % GPUCA_ROW_COUNT;
-    uint32_t iSector = sectorStart + (i / GPUCA_ROW_COUNT);
-    const uint32_t linearIndex = iSector * GPUCA_ROW_COUNT + iRow;
+  for (int32_t i = get_global_id(0); i < GPUCA_NROWS * nSectors; i += get_global_size(0)) {
+    uint32_t iRow = i % GPUCA_NROWS;
+    uint32_t iSector = sectorStart + (i / GPUCA_NROWS);
+    const uint32_t linearIndex = iSector * GPUCA_NROWS + iRow;
     uint32_t tmpBufferIndex = computeLinearTmpBufferIndex(iSector, iRow, decompressor.mMaxNativeClustersPerBuffer);
     ClusterNative* buffer = clusterBuffer + outputAccess->clusterOffset[iSector][iRow];
     if (decompressor.mNativeClustersIndex[linearIndex] != 0) {
@@ -105,9 +105,9 @@ GPUdii() void GPUTPCDecompressionUtilKernels::Thread<GPUTPCDecompressionUtilKern
   const GPUParam& GPUrestrict() param = processors.param;
   GPUTPCDecompression& GPUrestrict() decompressor = processors.tpcDecompressor;
   const ClusterNativeAccess* clusterAccess = decompressor.mClusterNativeAccess;
-  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_ROW_COUNT; i += get_global_size(0)) {
-    uint32_t sector = i / GPUCA_ROW_COUNT;
-    uint32_t row = i % GPUCA_ROW_COUNT;
+  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_NROWS; i += get_global_size(0)) {
+    uint32_t sector = i / GPUCA_NROWS;
+    uint32_t row = i % GPUCA_NROWS;
     for (uint32_t k = 0; k < clusterAccess->nClusters[sector][row]; k++) {
       ClusterNative cl = clusterAccess->clusters[sector][row][k];
       if (isClusterKept(cl, param)) {
@@ -125,9 +125,9 @@ GPUdii() void GPUTPCDecompressionUtilKernels::Thread<GPUTPCDecompressionUtilKern
   ClusterNative* GPUrestrict() clusterBuffer = decompressor.mNativeClustersBuffer;
   const ClusterNativeAccess* clusterAccess = decompressor.mClusterNativeAccess;
   const ClusterNativeAccess* outputAccess = processors.ioPtrs.clustersNative;
-  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_ROW_COUNT; i += get_global_size(0)) {
-    uint32_t sector = i / GPUCA_ROW_COUNT;
-    uint32_t row = i % GPUCA_ROW_COUNT;
+  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_NROWS; i += get_global_size(0)) {
+    uint32_t sector = i / GPUCA_NROWS;
+    uint32_t row = i % GPUCA_NROWS;
     uint32_t count = 0;
     for (uint32_t k = 0; k < clusterAccess->nClusters[sector][row]; k++) {
       const ClusterNative cl = clusterAccess->clusters[sector][row][k];
@@ -144,9 +144,9 @@ GPUdii() void GPUTPCDecompressionUtilKernels::Thread<GPUTPCDecompressionUtilKern
 {
   ClusterNative* GPUrestrict() clusterBuffer = processors.tpcDecompressor.mNativeClustersBuffer;
   const ClusterNativeAccess* outputAccess = processors.ioPtrs.clustersNative;
-  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_ROW_COUNT; i += get_global_size(0)) {
-    uint32_t sector = i / GPUCA_ROW_COUNT;
-    uint32_t row = i % GPUCA_ROW_COUNT;
+  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_NROWS; i += get_global_size(0)) {
+    uint32_t sector = i / GPUCA_NROWS;
+    uint32_t row = i % GPUCA_NROWS;
     ClusterNative* buffer = clusterBuffer + outputAccess->clusterOffset[sector][row];
     GPUCommonAlgorithm::sort(buffer, buffer + outputAccess->nClusters[sector][row]);
   }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
index 2140cfbe5166d..48d92f1b2a69a 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
@@ -39,7 +39,7 @@ class GPUTPCDecompressionKernels : public GPUKernelTemplate
 
   GPUd() static uint32_t computeLinearTmpBufferIndex(uint32_t sector, uint32_t row, uint32_t maxClustersPerBuffer)
   {
-    return sector * (GPUCA_ROW_COUNT * maxClustersPerBuffer) + row * maxClustersPerBuffer;
+    return sector * (GPUCA_NROWS * maxClustersPerBuffer) + row * maxClustersPerBuffer;
   }
 
   template <typename T>
diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc b/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
index e4de5a503e52d..1ed04269c2cc9 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
@@ -48,7 +48,7 @@ class TPCClusterDecompressionCore
     return clusterVector.back();
   }
 
-  GPUhi() static auto decompressTrackStore(const CompressedClusters& clustersCompressed, const uint32_t offset, uint32_t slice, uint32_t row, uint32_t pad, uint32_t time, std::vector<ClusterNative> (&clusters)[GPUCA_NSECTORS][GPUCA_ROW_COUNT], std::atomic_flag (&locks)[GPUCA_NSECTORS][GPUCA_ROW_COUNT])
+  GPUhi() static auto decompressTrackStore(const CompressedClusters& clustersCompressed, const uint32_t offset, uint32_t slice, uint32_t row, uint32_t pad, uint32_t time, std::vector<ClusterNative> (&clusters)[GPUCA_NSECTORS][GPUCA_NROWS], std::atomic_flag (&locks)[GPUCA_NSECTORS][GPUCA_NROWS])
   {
     std::vector<ClusterNative>& clusterVector = clusters[slice][row];
     auto& lock = locks[slice][row];
@@ -62,14 +62,14 @@ class TPCClusterDecompressionCore
 
   GPUdi() static ClusterNative decompressTrackStore(const CompressedClusters& cmprClusters, const uint32_t clusterOffset, uint32_t slice, uint32_t row, uint32_t pad, uint32_t time, GPUTPCDecompression& decompressor)
   {
-    uint32_t tmpBufferIndex = slice * (GPUCA_ROW_COUNT * decompressor.mMaxNativeClustersPerBuffer) + row * decompressor.mMaxNativeClustersPerBuffer;
-    uint32_t currentClusterIndex = CAMath::AtomicAdd(decompressor.mNativeClustersIndex + (slice * GPUCA_ROW_COUNT + row), 1u);
+    uint32_t tmpBufferIndex = slice * (GPUCA_NROWS * decompressor.mMaxNativeClustersPerBuffer) + row * decompressor.mMaxNativeClustersPerBuffer;
+    uint32_t currentClusterIndex = CAMath::AtomicAdd(decompressor.mNativeClustersIndex + (slice * GPUCA_NROWS + row), 1u);
     const ClusterNative c(time, cmprClusters.flagsA[clusterOffset], pad, cmprClusters.sigmaTimeA[clusterOffset], cmprClusters.sigmaPadA[clusterOffset], cmprClusters.qMaxA[clusterOffset], cmprClusters.qTotA[clusterOffset]);
     if (currentClusterIndex < decompressor.mMaxNativeClustersPerBuffer) {
       decompressor.mTmpNativeClusters[tmpBufferIndex + currentClusterIndex] = c;
     } else {
       decompressor.raiseError(GPUErrors::ERROR_DECOMPRESSION_ATTACHED_CLUSTER_OVERFLOW, slice * 1000 + row, currentClusterIndex, decompressor.mMaxNativeClustersPerBuffer);
-      CAMath::AtomicExch(decompressor.mNativeClustersIndex + (slice * GPUCA_ROW_COUNT + row), decompressor.mMaxNativeClustersPerBuffer);
+      CAMath::AtomicExch(decompressor.mNativeClustersIndex + (slice * GPUCA_NROWS + row), decompressor.mMaxNativeClustersPerBuffer);
     }
     return c;
   }
@@ -97,8 +97,8 @@ class TPCClusterDecompressionCore
             slice -= GPUCA_NSECTORS;
           }
           row += cmprClusters.rowDiffA[clusterOffset - trackIndex - 1];
-          if (row >= GPUCA_ROW_COUNT) {
-            row -= GPUCA_ROW_COUNT;
+          if (row >= GPUCA_NROWS) {
+            row -= GPUCA_NROWS;
           }
         } else {
           slice = tmpSlice;
@@ -115,7 +115,7 @@ class TPCClusterDecompressionCore
           timeTmp |= 0xFF000000;
         }
         time = timeTmp + ClusterNative::packTime(CAMath::Max(0.f, geo.LinearZ2Time(slice, track.Z() + zOffset)));
-        float tmpPad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_ROW_COUNT - 1), track.LinearY2Pad(slice, track.Y(), geo.PadWidth(row), geo.NPads(row))));
+        float tmpPad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_NROWS - 1), track.LinearY2Pad(slice, track.Y(), geo.PadWidth(row), geo.NPads(row))));
         pad = cmprClusters.padResA[clusterOffset - trackIndex - 1] + ClusterNative::packPad(tmpPad);
         time = time & 0xFFFFFF;
         pad = (uint16_t)pad;
diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
index 51a896c2baf6a..747d7f6904be3 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
@@ -48,9 +48,9 @@ int32_t TPCClusterDecompressor::decompress(const CompressedClusters* clustersCom
   if (clustersCompressed->nTracks && clustersCompressed->maxTimeBin != -1e6 && clustersCompressed->maxTimeBin != param.continuousMaxTimeBin) {
     throw std::runtime_error("Configured max time bin " + std::to_string(param.continuousMaxTimeBin) + " does not match value used for track model encoding " + std::to_string(clustersCompressed->maxTimeBin));
   }
-  std::vector<ClusterNative> clusters[NSECTORS][GPUCA_ROW_COUNT];
-  std::atomic_flag locks[NSECTORS][GPUCA_ROW_COUNT];
-  for (uint32_t i = 0; i < NSECTORS * GPUCA_ROW_COUNT; i++) {
+  std::vector<ClusterNative> clusters[NSECTORS][GPUCA_NROWS];
+  std::atomic_flag locks[NSECTORS][GPUCA_NROWS];
+  for (uint32_t i = 0; i < NSECTORS * GPUCA_NROWS; i++) {
     (&locks[0][0])[i].clear();
   }
   const uint32_t maxTime = param.continuousMaxTimeBin > 0 ? ((param.continuousMaxTimeBin + 1) * ClusterNative::scaleTimePacked - 1) : TPC_MAX_TIME_BIN_TRIGGERED;
@@ -69,14 +69,14 @@ int32_t TPCClusterDecompressor::decompress(const CompressedClusters* clustersCom
   });
   size_t nTotalClusters = clustersCompressed->nAttachedClusters + clustersCompressed->nUnattachedClusters;
   ClusterNative* clusterBuffer = allocator(nTotalClusters);
-  uint32_t offsets[NSECTORS][GPUCA_ROW_COUNT];
+  uint32_t offsets[NSECTORS][GPUCA_NROWS];
   uint32_t offset = 0;
   uint32_t decodedAttachedClusters = 0;
   for (uint32_t i = 0; i < NSECTORS; i++) {
-    for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-      clustersNative.nClusters[i][j] = clusters[i][j].size() + ((i * GPUCA_ROW_COUNT + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_ROW_COUNT + j]);
+    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+      clustersNative.nClusters[i][j] = clusters[i][j].size() + ((i * GPUCA_NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_NROWS + j]);
       offsets[i][j] = offset;
-      offset += (i * GPUCA_ROW_COUNT + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
+      offset += (i * GPUCA_NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_NROWS + j];
       decodedAttachedClusters += clusters[i][j].size();
     }
   }
@@ -86,13 +86,13 @@ int32_t TPCClusterDecompressor::decompress(const CompressedClusters* clustersCom
   clustersNative.clustersLinear = clusterBuffer;
   clustersNative.setOffsetPtrs();
   tbb::parallel_for<uint32_t>(0, NSECTORS, [&](auto i) {
-    for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
       ClusterNative* buffer = &clusterBuffer[clustersNative.clusterOffset[i][j]];
       if (clusters[i][j].size()) {
         memcpy((void*)buffer, (const void*)clusters[i][j].data(), clusters[i][j].size() * sizeof(clusterBuffer[0]));
       }
       ClusterNative* clout = buffer + clusters[i][j].size();
-      uint32_t end = offsets[i][j] + ((i * GPUCA_ROW_COUNT + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_ROW_COUNT + j]);
+      uint32_t end = offsets[i][j] + ((i * GPUCA_NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_NROWS + j]);
       TPCClusterDecompressionCore::decompressHits(*clustersCompressed, offsets[i][j], end, clout);
       if (param.rec.tpc.clustersEdgeFixDistance > 0.f) {
         constexpr GPUTPCGeometry geo;
diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
index e9e1484249399..6cbfe9e1cd402 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
@@ -71,7 +71,7 @@ size_t GPUMemorySizeScalers::getValue(size_t maxVal, size_t val)
 size_t GPUMemorySizeScalers::NTPCPeaks(size_t tpcDigits, bool perSector) { return getValue(perSector ? tpcMaxPeaks : (GPUCA_NSECTORS * tpcMaxPeaks), hitOffset + tpcDigits * tpcPeaksPerDigit); }
 size_t GPUMemorySizeScalers::NTPCClusters(size_t tpcDigits, bool perSector) { return getValue(perSector ? tpcMaxSectorClusters : tpcMaxClusters, (conservativeMemoryEstimate ? 1.0 : tpcClustersPerPeak) * NTPCPeaks(tpcDigits, perSector)); }
 size_t GPUMemorySizeScalers::NTPCStartHits(size_t tpcHits) { return getValue(tpcMaxStartHits, tpcHits * tpcStartHitsPerHit); }
-size_t GPUMemorySizeScalers::NTPCRowStartHits(size_t tpcHits) { return getValue(tpcMaxRowStartHits, std::max<size_t>(NTPCStartHits(tpcHits) * (tpcHits < 30000000 ? 20 : 12) / GPUCA_ROW_COUNT, tpcMinRowStartHits)); }
+size_t GPUMemorySizeScalers::NTPCRowStartHits(size_t tpcHits) { return getValue(tpcMaxRowStartHits, std::max<size_t>(NTPCStartHits(tpcHits) * (tpcHits < 30000000 ? 20 : 12) / GPUCA_NROWS, tpcMinRowStartHits)); }
 size_t GPUMemorySizeScalers::NTPCTracklets(size_t tpcHits, bool lowField) { return getValue(tpcMaxTracklets, NTPCStartHits(tpcHits) * (lowField ? tpcTrackletsPerStartHitLowField : tpcTrackletsPerStartHit)); }
 size_t GPUMemorySizeScalers::NTPCTrackletHits(size_t tpcHits, bool lowField) { return getValue(tpcMaxTrackletHits, hitOffset + tpcHits * (lowField ? tpcTrackletHitsPerHitLowField : tpcTrackletHitsPerHit)); }
 size_t GPUMemorySizeScalers::NTPCSectorTracks(size_t tpcHits) { return getValue(tpcMaxSectorTracks, tpcHits * tpcSectorTracksPerHit); }
diff --git a/GPU/GPUTracking/DataTypes/GPUO2ExternalUser.h b/GPU/GPUTracking/DataTypes/GPUO2ExternalUser.h
index 1e5261e0065a6..7d09423cc78fe 100644
--- a/GPU/GPUTracking/DataTypes/GPUO2ExternalUser.h
+++ b/GPU/GPUTracking/DataTypes/GPUO2ExternalUser.h
@@ -16,9 +16,6 @@
 #define GPUO2EXTERNALUSER_H
 
 // Some defines denoting that we are compiling for O2
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
 #ifndef GPUCA_O2_INTERFACE
 #define GPUCA_O2_INTERFACE
 #endif
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h b/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
index a1dd54bbba02b..84334f1807493 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
@@ -22,7 +22,7 @@ namespace o2::gpu
 {
 struct GPUParam;
 struct GPUTPCClusterOccupancyMapBin {
-  uint16_t bin[GPUCA_NSECTORS][GPUCA_ROW_COUNT];
+  uint16_t bin[GPUCA_NSECTORS][GPUCA_NROWS];
 
   GPUd() static uint32_t getNBins(const GPUParam& param);
   GPUd() static uint32_t getTotalSize(const GPUParam& param);
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
index 13cec6c752fbe..47f8ba42373b5 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
@@ -17,13 +17,10 @@
 
 #include "GPUCommonDef.h"
 
-#if !defined(GPUCA_NSECTORS) && !defined(GPUCA_ROW_COUNT)
+#if !defined(GPUCA_NSECTORS) && !defined(GPUCA_NROWS)
 #include "DataFormatsTPC/Constants.h"
 #define GPUCA_NSECTORS o2::tpc::constants::MAXSECTOR
-#define GPUCA_ROW_COUNT o2::tpc::constants::MAXGLOBALPADROW
-#ifndef GPUCA_TPC_GEOMETRY_O2
-#define GPUCA_TPC_GEOMETRY_O2
-#endif
+#define GPUCA_NROWS o2::tpc::constants::MAXGLOBALPADROW
 #endif
 
 namespace o2::gpu
@@ -32,22 +29,22 @@ namespace o2::gpu
 
 namespace gputpcgeometry_internal
 {
-#ifdef GPUCA_TPC_GEOMETRY_O2
-GPUconstexpr() float mX[GPUCA_ROW_COUNT] = {85.225f, 85.975f, 86.725f, 87.475f, 88.225f, 88.975f, 89.725f, 90.475f, 91.225f, 91.975f, 92.725f, 93.475f, 94.225f, 94.975f, 95.725f, 96.475f, 97.225f, 97.975f, 98.725f, 99.475f, 100.225f, 100.975f,
-                                            101.725f, 102.475f, 103.225f, 103.975f, 104.725f, 105.475f, 106.225f, 106.975f, 107.725f, 108.475f, 109.225f, 109.975f, 110.725f, 111.475f, 112.225f, 112.975f, 113.725f, 114.475f, 115.225f, 115.975f, 116.725f, 117.475f,
-                                            118.225f, 118.975f, 119.725f, 120.475f, 121.225f, 121.975f, 122.725f, 123.475f, 124.225f, 124.975f, 125.725f, 126.475f, 127.225f, 127.975f, 128.725f, 129.475f, 130.225f, 130.975f, 131.725f, 135.2f, 136.2f, 137.2f,
-                                            138.2f, 139.2f, 140.2f, 141.2f, 142.2f, 143.2f, 144.2f, 145.2f, 146.2f, 147.2f, 148.2f, 149.2f, 150.2f, 151.2f, 152.2f, 153.2f, 154.2f, 155.2f, 156.2f, 157.2f, 158.2f, 159.2f,
-                                            160.2f, 161.2f, 162.2f, 163.2f, 164.2f, 165.2f, 166.2f, 167.2f, 168.2f, 171.4f, 172.6f, 173.8f, 175.f, 176.2f, 177.4f, 178.6f, 179.8f, 181.f, 182.2f, 183.4f, 184.6f, 185.8f,
-                                            187.f, 188.2f, 189.4f, 190.6f, 191.8f, 193.f, 194.2f, 195.4f, 196.6f, 197.8f, 199.f, 200.2f, 201.4f, 202.6f, 203.8f, 205.f, 206.2f, 209.65f, 211.15f, 212.65f, 214.15f, 215.65f,
-                                            217.15f, 218.65f, 220.15f, 221.65f, 223.15f, 224.65f, 226.15f, 227.65f, 229.15f, 230.65f, 232.15f, 233.65f, 235.15f, 236.65f, 238.15f, 239.65f, 241.15f, 242.65f, 244.15f, 245.65f};
-
-GPUconstexpr() uint8_t mNPads[GPUCA_ROW_COUNT] = {66, 66, 66, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88,
-                                                  90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 92, 92, 92, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82,
-                                                  82, 84, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 102, 102, 102, 104, 104, 104, 106, 110,
-                                                  110, 112, 112, 112, 114, 114, 114, 116, 116, 116, 118, 118, 118, 118, 118, 120, 120, 122, 122, 124, 124, 124, 126, 126, 128, 128, 128, 130, 130, 132, 132, 132, 134, 134, 136, 136, 138, 138};
-
-GPUconstexpr() uint8_t mRegion[GPUCA_ROW_COUNT] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-                                                   4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+#ifndef GPUCA_RUN2 // clang-format: off
+GPUconstexpr() float mX[GPUCA_NROWS] = {85.225f, 85.975f, 86.725f, 87.475f, 88.225f, 88.975f, 89.725f, 90.475f, 91.225f, 91.975f, 92.725f, 93.475f, 94.225f, 94.975f, 95.725f, 96.475f, 97.225f, 97.975f, 98.725f, 99.475f, 100.225f, 100.975f,
+                                        101.725f, 102.475f, 103.225f, 103.975f, 104.725f, 105.475f, 106.225f, 106.975f, 107.725f, 108.475f, 109.225f, 109.975f, 110.725f, 111.475f, 112.225f, 112.975f, 113.725f, 114.475f, 115.225f, 115.975f, 116.725f, 117.475f,
+                                        118.225f, 118.975f, 119.725f, 120.475f, 121.225f, 121.975f, 122.725f, 123.475f, 124.225f, 124.975f, 125.725f, 126.475f, 127.225f, 127.975f, 128.725f, 129.475f, 130.225f, 130.975f, 131.725f, 135.2f, 136.2f, 137.2f,
+                                        138.2f, 139.2f, 140.2f, 141.2f, 142.2f, 143.2f, 144.2f, 145.2f, 146.2f, 147.2f, 148.2f, 149.2f, 150.2f, 151.2f, 152.2f, 153.2f, 154.2f, 155.2f, 156.2f, 157.2f, 158.2f, 159.2f,
+                                        160.2f, 161.2f, 162.2f, 163.2f, 164.2f, 165.2f, 166.2f, 167.2f, 168.2f, 171.4f, 172.6f, 173.8f, 175.f, 176.2f, 177.4f, 178.6f, 179.8f, 181.f, 182.2f, 183.4f, 184.6f, 185.8f,
+                                        187.f, 188.2f, 189.4f, 190.6f, 191.8f, 193.f, 194.2f, 195.4f, 196.6f, 197.8f, 199.f, 200.2f, 201.4f, 202.6f, 203.8f, 205.f, 206.2f, 209.65f, 211.15f, 212.65f, 214.15f, 215.65f,
+                                        217.15f, 218.65f, 220.15f, 221.65f, 223.15f, 224.65f, 226.15f, 227.65f, 229.15f, 230.65f, 232.15f, 233.65f, 235.15f, 236.65f, 238.15f, 239.65f, 241.15f, 242.65f, 244.15f, 245.65f};
+
+GPUconstexpr() uint8_t mNPads[GPUCA_NROWS] = {66, 66, 66, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88,
+                                              90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 92, 92, 92, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82,
+                                              82, 84, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 102, 102, 102, 104, 104, 104, 106, 110,
+                                              110, 112, 112, 112, 114, 114, 114, 116, 116, 116, 118, 118, 118, 118, 118, 120, 120, 122, 122, 124, 124, 124, 126, 126, 128, 128, 128, 130, 130, 132, 132, 132, 134, 134, 136, 136, 138, 138};
+
+GPUconstexpr() uint8_t mRegion[GPUCA_NROWS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+                                               4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
 GPUconstexpr() uint8_t mRegionRows[10] = {17, 15, 16, 15, 18, 16, 16, 14, 13, 12};
 GPUconstexpr() uint8_t mRegionStart[10] = {0, 17, 32, 48, 63, 81, 97, 113, 127, 140};
 
@@ -60,24 +57,24 @@ GPUconstexpr() float mPadWidth[10] = {.416f, .420f, .420f, .436f, .6f, .6f, .608
 
 constexpr float FACTOR_T2Z = 250.f / 512.f; // Used in compression, must remain constant at 250cm, 512 time bins!
 #else
-GPUconstexpr() float mX[GPUCA_ROW_COUNT] = {85.195f, 85.945f, 86.695f, 87.445f, 88.195f, 88.945f, 89.695f, 90.445f, 91.195f, 91.945f, 92.695f, 93.445f, 94.195f, 94.945f, 95.695f, 96.445f, 97.195f, 97.945f, 98.695f, 99.445f, 100.195f, 100.945f, 101.695f,
-                                            102.445f, 103.195f, 103.945f, 104.695f, 105.445f, 106.195f, 106.945f, 107.695f, 108.445f, 109.195f, 109.945f, 110.695f, 111.445f, 112.195f, 112.945f, 113.695f, 114.445f, 115.195f, 115.945f, 116.695f, 117.445f, 118.195f, 118.945f,
-                                            119.695f, 120.445f, 121.195f, 121.945f, 122.695f, 123.445f, 124.195f, 124.945f, 125.695f, 126.445f, 127.195f, 127.945f, 128.695f, 129.445f, 130.195f, 130.945f, 131.695f, 135.180f, 136.180f, 137.180f, 138.180f, 139.180f, 140.180f,
-                                            141.180f, 142.180f, 143.180f, 144.180f, 145.180f, 146.180f, 147.180f, 148.180f, 149.180f, 150.180f, 151.180f, 152.180f, 153.180f, 154.180f, 155.180f, 156.180f, 157.180f, 158.180f, 159.180f, 160.180f, 161.180f, 162.180f, 163.180f,
-                                            164.180f, 165.180f, 166.180f, 167.180f, 168.180f, 169.180f, 170.180f, 171.180f, 172.180f, 173.180f, 174.180f, 175.180f, 176.180f, 177.180f, 178.180f, 179.180f, 180.180f, 181.180f, 182.180f, 183.180f, 184.180f, 185.180f, 186.180f,
-                                            187.180f, 188.180f, 189.180f, 190.180f, 191.180f, 192.180f, 193.180f, 194.180f, 195.180f, 196.180f, 197.180f, 198.180f, 199.430f, 200.930f, 202.430f, 203.930f, 205.430f, 206.930f, 208.430f, 209.930f, 211.430f, 212.930f, 214.430f,
-                                            215.930f, 217.430f, 218.930f, 220.430f, 221.930f, 223.430f, 224.930f, 226.430f, 227.930f, 229.430f, 230.930f, 232.430f, 233.930f, 235.430f, 236.930f, 238.430f, 239.930f, 241.430f, 242.930f, 244.430f, 245.930f};
-
-GPUconstexpr() uint8_t mNPads[GPUCA_ROW_COUNT] = {68, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 92, 92, 92,
-                                                  94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 108, 108, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82, 82, 84, 84,
-                                                  84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108,
-                                                  108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
+GPUconstexpr() float mX[GPUCA_NROWS] = {85.195f, 85.945f, 86.695f, 87.445f, 88.195f, 88.945f, 89.695f, 90.445f, 91.195f, 91.945f, 92.695f, 93.445f, 94.195f, 94.945f, 95.695f, 96.445f, 97.195f, 97.945f, 98.695f, 99.445f, 100.195f, 100.945f, 101.695f,
+                                        102.445f, 103.195f, 103.945f, 104.695f, 105.445f, 106.195f, 106.945f, 107.695f, 108.445f, 109.195f, 109.945f, 110.695f, 111.445f, 112.195f, 112.945f, 113.695f, 114.445f, 115.195f, 115.945f, 116.695f, 117.445f, 118.195f, 118.945f,
+                                        119.695f, 120.445f, 121.195f, 121.945f, 122.695f, 123.445f, 124.195f, 124.945f, 125.695f, 126.445f, 127.195f, 127.945f, 128.695f, 129.445f, 130.195f, 130.945f, 131.695f, 135.180f, 136.180f, 137.180f, 138.180f, 139.180f, 140.180f,
+                                        141.180f, 142.180f, 143.180f, 144.180f, 145.180f, 146.180f, 147.180f, 148.180f, 149.180f, 150.180f, 151.180f, 152.180f, 153.180f, 154.180f, 155.180f, 156.180f, 157.180f, 158.180f, 159.180f, 160.180f, 161.180f, 162.180f, 163.180f,
+                                        164.180f, 165.180f, 166.180f, 167.180f, 168.180f, 169.180f, 170.180f, 171.180f, 172.180f, 173.180f, 174.180f, 175.180f, 176.180f, 177.180f, 178.180f, 179.180f, 180.180f, 181.180f, 182.180f, 183.180f, 184.180f, 185.180f, 186.180f,
+                                        187.180f, 188.180f, 189.180f, 190.180f, 191.180f, 192.180f, 193.180f, 194.180f, 195.180f, 196.180f, 197.180f, 198.180f, 199.430f, 200.930f, 202.430f, 203.930f, 205.430f, 206.930f, 208.430f, 209.930f, 211.430f, 212.930f, 214.430f,
+                                        215.930f, 217.430f, 218.930f, 220.430f, 221.930f, 223.430f, 224.930f, 226.430f, 227.930f, 229.430f, 230.930f, 232.430f, 233.930f, 235.430f, 236.930f, 238.430f, 239.930f, 241.430f, 242.930f, 244.430f, 245.930f};
+
+GPUconstexpr() uint8_t mNPads[GPUCA_NROWS] = {68, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 92, 92, 92,
+                                              94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 108, 108, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82, 82, 84, 84,
+                                              84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108,
+                                              108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
 
 GPUconstexpr() float mPadHeight[3] = {.75f, 1.f, 1.5f};
 GPUconstexpr() float mPadWidth[3] = {.4f, .6f, .6f};
 
 constexpr float FACTOR_T2Z = 250.f / 1024.f; // Used in compression, must remain constant at 250cm, 1024 time bins!
-#endif
+#endif // clang-format: on
 } // namespace gputpcgeometry_internal
 
 class GPUTPCGeometry // TODO: Make values constexpr
@@ -85,7 +82,7 @@ class GPUTPCGeometry // TODO: Make values constexpr
   static constexpr float FACTOR_Z2T = 1.f / gputpcgeometry_internal::FACTOR_T2Z;
 
  public:
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   GPUd() static constexpr int32_t GetRegion(int32_t row) { return gputpcgeometry_internal::mRegion[row]; }
   GPUd() static constexpr int32_t GetRegionRows(int32_t region) { return gputpcgeometry_internal::mRegionRows[region]; }
   GPUd() static constexpr int32_t GetRegionStart(int32_t region) { return gputpcgeometry_internal::mRegionStart[region]; }
@@ -104,7 +101,7 @@ class GPUTPCGeometry // TODO: Make values constexpr
   GPUd() static constexpr int32_t GetROC(int32_t row) { return GetRegion(row); }
   GPUd() static constexpr int32_t EndIROC() { return 63; }
   GPUd() static constexpr int32_t EndOROC1() { return 63 + 64; }
-  GPUd() static constexpr int32_t EndOROC2() { return GPUCA_ROW_COUNT; }
+  GPUd() static constexpr int32_t EndOROC2() { return GPUCA_NROWS; }
   GPUd() static constexpr int32_t MaxNPadsPerRow() { return 140; }
 #endif
 
@@ -117,7 +114,7 @@ class GPUTPCGeometry // TODO: Make values constexpr
 
   GPUd() static constexpr float LinearPad2Y(int32_t sector, int32_t row, float pad)
   {
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
     const float u = (pad - 0.5f * (gputpcgeometry_internal::mNPads[row] - 1)) * PadWidth(row);
 #else
     const float u = (pad - 0.5f * gputpcgeometry_internal::mNPads[row]) * PadWidth(row);
@@ -134,7 +131,7 @@ class GPUTPCGeometry // TODO: Make values constexpr
   GPUd() static constexpr float LinearY2Pad(int32_t sector, int32_t row, float y)
   {
     const float u = (sector >= GPUCA_NSECTORS / 2) ? -y : y;
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
     return u / PadWidth(row) + 0.5f * (gputpcgeometry_internal::mNPads[row] - 1);
 #else
     return u / PadWidth(row) + 0.5f * gputpcgeometry_internal::mNPads[row];
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDTrack.cxx b/GPU/GPUTracking/DataTypes/GPUTRDTrack.cxx
index 369d3838b646f..d0d43491a1e33 100644
--- a/GPU/GPUTracking/DataTypes/GPUTRDTrack.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUTRDTrack.cxx
@@ -21,7 +21,7 @@ using namespace o2::gpu;
 #if !defined(GPUCA_GPUCODE)
 namespace o2::gpu
 {
-#if !defined(GPUCA_O2_LIB) // Instantiate O2 track version, for O2 this happens in GPUTRDTrackO2.cxx
+#if defined(GPUCA_STANDALONE) // Instantiate O2 track version, for O2 this happens in GPUTRDTrackO2.cxx
 template class GPUTRDTrack_t<trackInterface<o2::track::TrackParCov>>;
 #endif
 template class GPUTRDTrack_t<trackInterface<GPUTPCGMTrackParam>>; // Always instatiate GM track version
diff --git a/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx b/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
index 2d12f98b8cf16..683bf958dfd12 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
@@ -23,7 +23,7 @@ TPCPadBitMap::TPCPadBitMap()
 {
   constexpr GPUTPCGeometry geo;
   int32_t offset = 0;
-  for (int32_t r = 0; r < GPUCA_ROW_COUNT; r++) {
+  for (int32_t r = 0; r < GPUCA_NROWS; r++) {
     mPadOffsetPerRow[r] = offset;
     offset += geo.NPads(r);
   }
diff --git a/GPU/GPUTracking/DataTypes/TPCPadBitMap.h b/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
index 299b880fcbcc6..072d3101a4537 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
+++ b/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
@@ -101,7 +101,7 @@ struct TPCPadBitMap {
     T mDeadChannelMap[NWORDS];
   };
 
-  uint16_t mPadOffsetPerRow[GPUCA_ROW_COUNT];
+  uint16_t mPadOffsetPerRow[GPUCA_NROWS];
   SectorBitMap mBitMap[GPUCA_NSECTORS];
 };
 
diff --git a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
index 6cc70c7afa7e1..9c6f956a954e8 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
@@ -23,7 +23,7 @@ TPCPadGainCalib::TPCPadGainCalib()
 {
   constexpr GPUTPCGeometry geo{};
   int32_t offset = 0;
-  for (int32_t r = 0; r < GPUCA_ROW_COUNT; r++) {
+  for (int32_t r = 0; r < GPUCA_NROWS; r++) {
     mPadOffsetPerRow[r] = offset;
     offset += geo.NPads(r);
   }
diff --git a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
index dbea56ee5ea6b..d261ec84e37d8 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
+++ b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
@@ -153,7 +153,7 @@ struct TPCPadGainCalib {
     }
   };
 
-  uint16_t mPadOffsetPerRow[GPUCA_ROW_COUNT];
+  uint16_t mPadOffsetPerRow[GPUCA_NROWS];
   SectorPadGainCorrection<uint16_t> mGainCorrection[GPUCA_NSECTORS];
 };
 
diff --git a/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx b/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
index f520282bfa35b..e794ce82f8043 100644
--- a/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
@@ -22,7 +22,7 @@ using namespace o2::gpu;
 
 TPCZSLinkMapping::TPCZSLinkMapping(o2::tpc::Mapper& mapper)
 {
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   const auto& fecToGlobalPad = mapper.getMapFECIDGlobalPad();
   assert(fecToGlobalPad.size() == TPC_FEC_IDS_IN_SECTOR);
 
diff --git a/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.h b/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.h
index 9f7862cef726d..b698c93d9d87f 100644
--- a/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.h
+++ b/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.h
@@ -16,7 +16,7 @@
 #define O2_GPU_TPC_ZS_LINK_MAPPING_H
 
 #include "clusterFinderDefs.h"
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
 #include "TPCBase/PadPos.h"
 #endif
 
@@ -33,7 +33,7 @@ struct TPCZSLinkMapping {
   TPCZSLinkMapping() = default;
   TPCZSLinkMapping(o2::tpc::Mapper& mapper);
 #endif
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   o2::tpc::PadPos FECIDToPadPos[TPC_FEC_IDS_IN_SECTOR];
 #endif
 };
diff --git a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
index 92adcbd9c14d7..919d124d6d354 100644
--- a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
+++ b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
@@ -34,7 +34,7 @@ GPUTPCClusterFilter::GPUTPCClusterFilter(const o2::tpc::ClusterNativeAccess& clu
     }
 
     for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-      for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+      for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
         const uint32_t globalStack = getGlobalStack(iSector, iRow);
         mClusterStats[globalStack].resize(MaxTimeBin);
 
diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index 0644e533e9d64..9c2d04ca280f2 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -30,7 +30,7 @@
   #error Invalid Compile Definitions, need to build for either O2 or Standalone!
 #endif
 
-#define GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(QPTB5) (CAMath::Abs(QPTB5) > 10 ? 10 : (CAMath::Abs(QPTB5) > 5 ? 15 : 29)) // Minimum hits should depend on Pt, low Pt tracks can have few hits. 29 Hits default, 15 for < 200 mev, 10 for < 100 mev
+#define GPUCA_TPC_MIN_HITS_B5(QPTB5) (CAMath::Abs(QPTB5) > 10 ? 10 : (CAMath::Abs(QPTB5) > 5 ? 15 : 29)) // Minimum hits should depend on Pt, low Pt tracks can have few hits. 29 Hits default, 15 for < 200 mev, 10 for < 100 mev
 
 #define GPUCA_MERGER_MAX_TRACK_CLUSTERS 1024          // Maximum number of clusters a track may have after merging
 
@@ -46,21 +46,21 @@
 
 #define TPC_MAX_TIME_BIN_TRIGGERED 600
 
-#if defined(GPUCA_NSECTORS) || defined(GPUCA_ROW_COUNT)
-  #error GPUCA_NSECTORS or GPUCA_ROW_COUNT already defined, do not include GPUTPCGeometry.h before!
+#if defined(GPUCA_NSECTORS) || defined(GPUCA_NROWS)
+  #error GPUCA_NSECTORS or GPUCA_NROWS already defined, do not include GPUTPCGeometry.h before!
 #endif
-#if defined(GPUCA_TPC_GEOMETRY_O2) && !(defined(ROOT_VERSION_CODE) && ROOT_VERSION_CODE < 393216)
+#if !defined(GPUCA_RUN2) && !(defined(ROOT_VERSION_CODE) && ROOT_VERSION_CODE < 393216)
   //Use definitions from the O2 headers if available for nicer code and type safety
   #include "DataFormatsTPC/Constants.h"
   #define GPUCA_NSECTORS o2::tpc::constants::MAXSECTOR
-  #define GPUCA_ROW_COUNT o2::tpc::constants::MAXGLOBALPADROW
+  #define GPUCA_NROWS o2::tpc::constants::MAXGLOBALPADROW
 #else
   //Define it manually, if O2 headers not available, ROOT5, and OpenCL 1.2, which do not know C++11.
   #define GPUCA_NSECTORS 36
-  #ifdef GPUCA_TPC_GEOMETRY_O2
-    #define GPUCA_ROW_COUNT 152
+  #ifndef GPUCA_RUN2
+    #define GPUCA_NROWS 152
   #else
-    #define GPUCA_ROW_COUNT 159
+    #define GPUCA_NROWS 159
   #endif
 #endif
 
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 606deb44d9528..e693f5e1814b7 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -650,7 +650,7 @@ EndConfig()
 #endif // BeginConfig
 
 //Settings for the O2 workflow
-#if !defined(QCONFIG_PARSER_CXX) && (defined(GPUCA_O2_LIB) || defined(GPUCA_O2_INTERFACE))
+#if !defined(QCONFIG_PARSER_CXX) && !defined(GPUCA_STANDALONE)
 BeginSubConfig(GPUSettingsO2, global, configStandalone, "O2", 0, "O2 workflow settings", global)
 AddOption(solenoidBzNominalGPU, float, -1e6f, "", 0, "Field strength of solenoid Bz in kGaus")
 AddOption(constBz, bool, false, "", 0, "force constant Bz for tests")
@@ -696,7 +696,7 @@ AddOption(zsOnTheFlyDigitsFilter, bool, false, "", 0, "Run on the fly digits fil
 AddOption(dumpBadTFs, int32_t, 0, "", 0, "Number of bad timeframes (with decoding / processing) errors to decode at max")
 AddOption(dumpBadTFMode, int32_t, 0, "", 0, "Type of dump to create: 0 = raw-reader compatible raw file, 1 = buffer-wise dump, 2 = standalone-benchmark compatible dump")
 EndConfig()
-#endif // GPUCA_O2_LIB
+#endif // !GPUCA_STANDALONE
 #endif // !GPUCA_GPUCODE_DEVICE
 
 // Derrived parameters used in GPUParam
diff --git a/GPU/GPUTracking/Definitions/clusterFinderDefs.h b/GPU/GPUTracking/Definitions/clusterFinderDefs.h
index 8d9ec60e551b9..79bcf773d5bd9 100644
--- a/GPU/GPUTracking/Definitions/clusterFinderDefs.h
+++ b/GPU/GPUTracking/Definitions/clusterFinderDefs.h
@@ -20,7 +20,7 @@
 /* #define CHARGEMAP_TIME_MAJOR_LAYOUT */
 #define CHARGEMAP_TILING_LAYOUT
 
-#define SCRATCH_PAD_SEARCH_N 8
+#define SCRATCH_PAD_SEARCH_N 8 // TODO: Change all this to constexpr where possible, like in GPUDefParametersConstants.h
 #define SCRATCH_PAD_COUNT_N 16
 #if defined(GPUCA_GPUCODE)
 #define SCRATCH_PAD_BUILD_N 8
@@ -42,7 +42,7 @@
 #define TPC_CLUSTERER_ROW_STRIDE (TPC_CLUSTERER_ROW_PAD_CAPACITY + GPUCF_PADDING_PAD)
 // Number of pads in a sector as stored internally by the clusterizer.
 // This includes fake pads for constant strides between rows
-#define TPC_CLUSTERER_STRIDED_PAD_COUNT (GPUCA_ROW_COUNT * TPC_CLUSTERER_ROW_STRIDE + GPUCF_PADDING_PAD)
+#define TPC_CLUSTERER_STRIDED_PAD_COUNT (GPUCA_NROWS * TPC_CLUSTERER_ROW_STRIDE + GPUCF_PADDING_PAD)
 // Real of number of pads in a sector
 #define TPC_REAL_PADS_IN_SECTOR 14560
 #define TPC_FEC_IDS_IN_SECTOR 23296
diff --git a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
index 9265c86f26ec9..98be3dd72baba 100644
--- a/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
+++ b/GPU/GPUTracking/GPUTrackingLinkDef_O2_DataTypes.h
@@ -21,7 +21,7 @@
 #pragma link C++ class o2::gpu::trackInterface < o2::track::TrackParCov> + ;
 #pragma link C++ class o2::gpu::GPUTRDTrack_t < o2::gpu::trackInterface < o2::track::TrackParCov>> + ;
 #pragma link C++ class std::vector < o2::gpu::GPUTRDTrack_t < o2::gpu::trackInterface < o2::track::TrackParCov>>> + ;
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsO2 + ;
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsRec + ;
 #pragma link C++ class o2::gpu::internal::GPUConfigurableParamGPUSettingsRecTPC + ;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index c5e9fd7630295..7ccf6b7329fe6 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -193,7 +193,7 @@ bool GPUChainTracking::ValidateSteps()
     GPUError("Invalid Inputs for track merging, TPC Clusters required");
     return false;
   }
-#ifndef GPUCA_TPC_GEOMETRY_O2
+#ifdef GPUCA_RUN2
   if (GetRecoSteps() & gpudatatypes::RecoStep::TPCClusterFinding) {
     GPUError("Can not run TPC GPU Cluster Finding with Run 2 Data");
     return false;
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index ccc864e422065..fdcdb064bc78a 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -299,7 +299,7 @@ class GPUChainTracking : public GPUChain
   void OutputSanityCheck();
   int32_t RunTPCTrackingSectors_internal();
   int32_t RunTPCClusterizer_prepare(bool restorePointers);
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   std::pair<uint32_t, uint32_t> RunTPCClusterizer_transferZS(int32_t iSector, const CfFragment& fragment, int32_t lane);
   void RunTPCClusterizer_compactPeaks(GPUTPCClusterFinder& clusterer, GPUTPCClusterFinder& clustererShadow, int32_t stage, bool doGPU, int32_t lane);
   std::pair<uint32_t, uint32_t> TPCClusterizerDecodeZSCount(uint32_t iSector, const CfFragment& fragment);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 12a12d4c47585..9e2a476ce024b 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -50,7 +50,7 @@
 #include "ORTRootSerializer.h"
 #endif
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 #include "CommonDataFormat/InteractionRecord.h"
 #endif
 
@@ -65,7 +65,7 @@ using namespace o2::tpc;
 using namespace o2::tpc::constants;
 using namespace o2::dataformats;
 
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
 std::pair<uint32_t, uint32_t> GPUChainTracking::TPCClusterizerDecodeZSCountUpdate(uint32_t iSector, const CfFragment& fragment)
 {
   bool doGPU = mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding;
@@ -589,7 +589,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
   if (param().rec.fwdTPCDigitsAsClusters) {
     return ForwardTPCDigits();
   }
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   int32_t tpcTimeBinCut = (mUpdateNewCalibObjects && mNewCalibValues->newTPCTimeBinCut) ? mNewCalibValues->tpcTimeBinCut : param().tpcCutTimeBin;
 
   mRec->PushNonPersistentMemory(qStr2Tag("TPCCLUST"));
@@ -1012,7 +1012,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             waitEvent = &mEvents->stream[lane];
             transferRunning[lane] = 2;
           }
-          runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding), krnlRunRangeNone, {nullptr, waitEvent}}, clustererShadow.mPclusterInRow, GPUCA_ROW_COUNT * sizeof(*clustererShadow.mPclusterInRow));
+          runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding), krnlRunRangeNone, {nullptr, waitEvent}}, clustererShadow.mPclusterInRow, GPUCA_NROWS * sizeof(*clustererShadow.mPclusterInRow));
         }
 
         if (clusterer.mPmemory->counters.nClusters == 0) {
@@ -1193,9 +1193,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
       if (laneHasData[lane]) {
         anyLaneHasData = true;
         if (buildNativeGPU && GetProcessingSettings().tpccfGatherKernel) {
-          runKernel<GPUTPCCFGather>({GetGridBlk(GPUCA_ROW_COUNT, mRec->NStreams() - 1), {iSector}}, &mInputsShadow->mPclusterNativeBuffer[nClsTotal]);
+          runKernel<GPUTPCCFGather>({GetGridBlk(GPUCA_NROWS, mRec->NStreams() - 1), {iSector}}, &mInputsShadow->mPclusterNativeBuffer[nClsTotal]);
         }
-        for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+        for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
           if (nClsTotal + clusterer.mPclusterInRow[j] > mInputsHost->mNClusterNative) {
             clusterer.raiseError(GPUErrors::ERROR_CF_GLOBAL_CLUSTER_OVERFLOW, iSector * 1000 + j, nClsTotal + clusterer.mPclusterInRow[j], mInputsHost->mNClusterNative);
             continue;
@@ -1222,9 +1222,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         continue;
       }
 
-      runKernel<GPUTPCCFMCLabelFlattener, GPUTPCCFMCLabelFlattener::setRowOffsets>({GetGrid(GPUCA_ROW_COUNT, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}});
+      runKernel<GPUTPCCFMCLabelFlattener, GPUTPCCFMCLabelFlattener::setRowOffsets>({GetGrid(GPUCA_NROWS, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}});
       GPUTPCCFMCLabelFlattener::setGlobalOffsetsAndAllocate(clusterer, mcLinearLabels);
-      runKernel<GPUTPCCFMCLabelFlattener, GPUTPCCFMCLabelFlattener::flatten>({GetGrid(GPUCA_ROW_COUNT, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}}, &mcLinearLabels);
+      runKernel<GPUTPCCFMCLabelFlattener, GPUTPCCFMCLabelFlattener::flatten>({GetGrid(GPUCA_NROWS, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}}, &mcLinearLabels);
       clusterer.clearMCMemory();
       assert(propagateMCLabels ? mcLinearLabels.header.size() == nClsTotal : true);
     }
@@ -1375,7 +1375,7 @@ void GPUChainTracking::SortClusters(bool buildNativeGPU, bool propagateMCLabels,
     std::iota(clsOrder.begin(), clsOrder.end(), 0);
     std::vector<ClusterNative> tmpClusters;
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
         const uint32_t offset = clusterAccess->clusterOffset[i][j];
         std::sort(&clsOrder[offset], &clsOrder[offset + clusterAccess->nClusters[i][j]], [&clusters](const uint32_t a, const uint32_t b) {
           return clusters[a] < clusters[b];
@@ -1415,7 +1415,7 @@ void GPUChainTracking::SortClusters(bool buildNativeGPU, bool propagateMCLabels,
     clusterAccess->clustersMCTruth = labelBuffer.second;
   } else {
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
         std::sort(&clusters[clusterAccess->clusterOffset[i][j]], &clusters[clusterAccess->clusterOffset[i][j] + clusterAccess->nClusters[i][j]]);
       }
     }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index f185348ed9169..ae5038f9c8a6f 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -59,7 +59,7 @@ int32_t GPUChainTracking::RunTPCCompression()
   }
   runKernel<GPUTPCCompressionKernels, GPUTPCCompressionKernels::step1unattached>(GetGridAuto(0));
   TransferMemoryResourcesToHost(myStep, &Compressor, 0);
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   if (mPipelineFinalizationCtx && GetProcessingSettings().doublePipelineClusterizer) {
     SynchronizeEventAndRelease(mEvents->single);
     auto* foreignChain = (GPUChainTracking*)GetNextChainInQueue();
@@ -74,7 +74,7 @@ int32_t GPUChainTracking::RunTPCCompression()
   O->nAttachedClusters = Compressor.mMemory->nStoredAttachedClusters;
   O->nUnattachedClusters = Compressor.mMemory->nStoredUnattachedClusters;
   O->nAttachedClustersReduced = O->nAttachedClusters - O->nTracks;
-  O->nSliceRows = NSECTORS * GPUCA_ROW_COUNT;
+  O->nSliceRows = NSECTORS * GPUCA_NROWS;
   O->nComppressionModes = param().rec.tpc.compressionTypeMask;
   O->solenoidBz = param().bzkG;
   O->maxTimeBin = param().continuousMaxTimeBin;
@@ -156,21 +156,21 @@ int32_t GPUChainTracking::RunTPCCompression()
       gatherTimer = &getTimer<GPUTPCCompressionKernels>("GPUTPCCompression_GatherOnCPU", 0);
       gatherTimer->Start();
     }
-    GPUMemCpyAlways(myStep, O->nSliceRowClusters, P->nSliceRowClusters, NSECTORS * GPUCA_ROW_COUNT * sizeof(O->nSliceRowClusters[0]), outputStream, direction);
+    GPUMemCpyAlways(myStep, O->nSliceRowClusters, P->nSliceRowClusters, NSECTORS * GPUCA_NROWS * sizeof(O->nSliceRowClusters[0]), outputStream, direction);
     GPUMemCpyAlways(myStep, O->nTrackClusters, P->nTrackClusters, O->nTracks * sizeof(O->nTrackClusters[0]), outputStream, direction);
     SynchronizeStream(outputStream);
     uint32_t offset = 0;
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
         uint32_t srcOffset = mIOPtrs.clustersNative->clusterOffset[i][j] * Compressor.mMaxClusterFactorBase1024 / 1024;
-        GPUMemCpyAlways(myStep, O->qTotU + offset, P->qTotU + srcOffset, O->nSliceRowClusters[i * GPUCA_ROW_COUNT + j] * sizeof(O->qTotU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->qMaxU + offset, P->qMaxU + srcOffset, O->nSliceRowClusters[i * GPUCA_ROW_COUNT + j] * sizeof(O->qMaxU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->flagsU + offset, P->flagsU + srcOffset, O->nSliceRowClusters[i * GPUCA_ROW_COUNT + j] * sizeof(O->flagsU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->padDiffU + offset, P->padDiffU + srcOffset, O->nSliceRowClusters[i * GPUCA_ROW_COUNT + j] * sizeof(O->padDiffU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->timeDiffU + offset, P->timeDiffU + srcOffset, O->nSliceRowClusters[i * GPUCA_ROW_COUNT + j] * sizeof(O->timeDiffU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->sigmaPadU + offset, P->sigmaPadU + srcOffset, O->nSliceRowClusters[i * GPUCA_ROW_COUNT + j] * sizeof(O->sigmaPadU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->sigmaTimeU + offset, P->sigmaTimeU + srcOffset, O->nSliceRowClusters[i * GPUCA_ROW_COUNT + j] * sizeof(O->sigmaTimeU[0]), outputStream, direction);
-        offset += O->nSliceRowClusters[i * GPUCA_ROW_COUNT + j];
+        GPUMemCpyAlways(myStep, O->qTotU + offset, P->qTotU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->qTotU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->qMaxU + offset, P->qMaxU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->qMaxU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->flagsU + offset, P->flagsU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->flagsU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->padDiffU + offset, P->padDiffU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->padDiffU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->timeDiffU + offset, P->timeDiffU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->timeDiffU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->sigmaPadU + offset, P->sigmaPadU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->sigmaPadU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->sigmaTimeU + offset, P->sigmaTimeU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->sigmaTimeU[0]), outputStream, direction);
+        offset += O->nSliceRowClusters[i * GPUCA_NROWS + j];
       }
     }
     offset = 0;
@@ -296,7 +296,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
     inputGPU = cmprClsHost;
 
     bool toGPU = true;
-    runKernel<GPUMemClean16>({GetGridAutoStep(inputStream, RecoStep::TPCDecompression), krnlRunRangeNone, &mEvents->init}, DecompressorShadow.mNativeClustersIndex, NSECTORS * GPUCA_ROW_COUNT * sizeof(DecompressorShadow.mNativeClustersIndex[0]));
+    runKernel<GPUMemClean16>({GetGridAutoStep(inputStream, RecoStep::TPCDecompression), krnlRunRangeNone, &mEvents->init}, DecompressorShadow.mNativeClustersIndex, NSECTORS * GPUCA_NROWS * sizeof(DecompressorShadow.mNativeClustersIndex[0]));
     int32_t nStreams = doGPU ? mRec->NStreams() - 1 : 1;
     if (cmprClsHost.nAttachedClusters != 0) {
       std::exclusive_scan(cmprClsHost.nTrackClusters, cmprClsHost.nTrackClusters + cmprClsHost.nTracks, Decompressor.mAttachedClustersOffsets, 0u); // computing clusters offsets for first kernel
@@ -326,7 +326,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
         runKernel<GPUTPCDecompressionKernels, GPUTPCDecompressionKernels::step0attached>({GetGridAuto(iStream), krnlRunRangeNone, {&mEvents->stream[iStream], &mEvents->init}}, startTrack, endTrack);
       }
     }
-    GPUMemCpy(myStep, inputGPUShadow.nSliceRowClusters, cmprClsHost.nSliceRowClusters, NSECTORS * GPUCA_ROW_COUNT * sizeof(cmprClsHost.nSliceRowClusters[0]), unattachedStream, toGPU);
+    GPUMemCpy(myStep, inputGPUShadow.nSliceRowClusters, cmprClsHost.nSliceRowClusters, NSECTORS * GPUCA_NROWS * sizeof(cmprClsHost.nSliceRowClusters[0]), unattachedStream, toGPU);
     GPUMemCpy(myStep, inputGPUShadow.qTotU, cmprClsHost.qTotU, cmprClsHost.nUnattachedClusters * sizeof(cmprClsHost.qTotU[0]), unattachedStream, toGPU);
     GPUMemCpy(myStep, inputGPUShadow.qMaxU, cmprClsHost.qMaxU, cmprClsHost.nUnattachedClusters * sizeof(cmprClsHost.qMaxU[0]), unattachedStream, toGPU);
     GPUMemCpy(myStep, inputGPUShadow.flagsU, cmprClsHost.flagsU, cmprClsHost.nUnattachedClusters * sizeof(cmprClsHost.flagsU[0]), unattachedStream, toGPU);
@@ -340,8 +340,8 @@ int32_t GPUChainTracking::RunTPCDecompression()
     uint32_t offset = 0;
     uint32_t decodedAttachedClusters = 0;
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-        uint32_t linearIndex = i * GPUCA_ROW_COUNT + j;
+      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+        uint32_t linearIndex = i * GPUCA_NROWS + j;
         uint32_t unattachedOffset = (linearIndex >= cmprClsHost.nSliceRows) ? 0 : cmprClsHost.nSliceRowClusters[linearIndex];
         (mClusterNativeAccess->nClusters)[i][j] = Decompressor.mNativeClustersIndex[linearIndex] + unattachedOffset;
         Decompressor.mUnattachedClustersOffsets[linearIndex] = offset;
@@ -399,7 +399,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
     if (runTimeBinCutFiltering) { // If filtering is applied, count how many clusters will remain after filtering and allocate final buffers accordingly
       AllocateRegisteredMemory(Decompressor.mResourceNClusterPerSectorRow);
       WriteToConstantMemory(myStep, (char*)&processors()->tpcDecompressor - (char*)processors(), &DecompressorShadow, sizeof(DecompressorShadow), unattachedStream);
-      runKernel<GPUMemClean16>({GetGridAutoStep(unattachedStream, RecoStep::TPCDecompression), krnlRunRangeNone}, DecompressorShadow.mNClusterPerSectorRow, NSECTORS * GPUCA_ROW_COUNT * sizeof(DecompressorShadow.mNClusterPerSectorRow[0]));
+      runKernel<GPUMemClean16>({GetGridAutoStep(unattachedStream, RecoStep::TPCDecompression), krnlRunRangeNone}, DecompressorShadow.mNClusterPerSectorRow, NSECTORS * GPUCA_NROWS * sizeof(DecompressorShadow.mNClusterPerSectorRow[0]));
       runKernel<GPUTPCDecompressionUtilKernels, GPUTPCDecompressionUtilKernels::countFilteredClusters>(GetGridAutoStep(unattachedStream, RecoStep::TPCDecompression));
       TransferMemoryResourceLinkToHost(RecoStep::TPCDecompression, Decompressor.mResourceNClusterPerSectorRow, unattachedStream);
       SynchronizeStream(unattachedStream);
@@ -411,8 +411,8 @@ int32_t GPUChainTracking::RunTPCDecompression()
       Decompressor.mNativeClustersBuffer = mInputsHost->mPclusterNativeOutput;
       WriteToConstantMemory(myStep, (char*)&processors()->tpcDecompressor - (char*)processors(), &DecompressorShadow, sizeof(DecompressorShadow), unattachedStream);
       for (uint32_t i = 0; i < NSECTORS; i++) {
-        for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
-          mClusterNativeAccess->nClusters[i][j] = Decompressor.mNClusterPerSectorRow[i * GPUCA_ROW_COUNT + j];
+        for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+          mClusterNativeAccess->nClusters[i][j] = Decompressor.mNClusterPerSectorRow[i * GPUCA_NROWS + j];
         }
       }
       if (doGPU) {
@@ -435,7 +435,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
       const ClusterNativeAccess* decoded = mIOPtrs.clustersNative;
       if (doGPU) {
         for (uint32_t i = 0; i < NSECTORS; i++) {
-          for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+          for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
             ClusterNative* begin = mInputsHost->mPclusterNativeOutput + decoded->clusterOffset[i][j];
             ClusterNative* end = begin + decoded->nClusters[i][j];
             std::sort(begin, end);
@@ -462,7 +462,7 @@ void GPUChainTracking::WriteReducedClusters()
   mClusterNativeAccessReduced = std::make_unique<ClusterNativeAccess>();
   uint32_t nOutput = 0;
   for (uint32_t iSec = 0; iSec < GPUCA_NSECTORS; iSec++) {
-    for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+    for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
       mClusterNativeAccessReduced->nClusters[iSec][iRow] = 0;
       for (uint32_t i = 0; i < mIOPtrs.clustersNative->nClusters[iSec][iRow]; i++) {
         mClusterNativeAccessReduced->nClusters[iSec][iRow] += !Compressor.rejectCluster(mIOPtrs.clustersNative->clusterOffset[iSec][iRow] + i, param(), mIOPtrs);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index fd3c03a8b29ec..7f954e854007a 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -141,7 +141,7 @@ void GPUChainTracking::PrintMemoryStatistics()
 {
   std::map<std::string, GPUChainTrackingMemUsage> usageMap;
   for (int32_t i = 0; i < NSECTORS; i++) {
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
     if (processors()->tpcClusterer[i].mPmemory) {
       addToMap("TPC Clusterer Sector Peaks", usageMap, processors()->tpcClusterer[i].mPmemory->counters.nPeaks, processors()->tpcClusterer[i].mNMaxPeaks);
       addToMap("TPC Clusterer Sector Clusters", usageMap, processors()->tpcClusterer[i].mPmemory->counters.nClusters, processors()->tpcClusterer[i].mNMaxClusters);
@@ -164,7 +164,7 @@ void GPUChainTracking::PrintMemoryStatistics()
     addToMap("TPC O2 ClusRefs", usageMap, processors()->tpcMerger.NOutputClusRefsTPCO2(), processors()->tpcMerger.NOutputClusRefsTPCO2());
   }
 
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   if (processors()->tpcCompressor.mOutput) {
     addToMap("TPC ComprCache HitsAttached", usageMap, processors()->tpcCompressor.mOutput->nAttachedClusters, processors()->tpcCompressor.mMaxTrackClusters);
     addToMap("TPC ComprCache HitsUnattached", usageMap, processors()->tpcCompressor.mOutput->nUnattachedClusters, processors()->tpcCompressor.mMaxClustersInCache);
@@ -282,7 +282,7 @@ void GPUChainTracking::OutputSanityCheck()
       uint8_t sector, row;
       uint32_t cl;
       trk.getClusterReference(mIOPtrs.outputClusRefsTPCO2, j, sector, row, cl);
-      if (sector >= GPUCA_NSECTORS || row >= GPUCA_ROW_COUNT) {
+      if (sector >= GPUCA_NSECTORS || row >= GPUCA_NROWS) {
         if (nErrors++ < 1000) {
           GPUError("Invalid sector / row %d / %d", (int32_t)sector, (int32_t)row);
           continue;
@@ -311,7 +311,7 @@ void GPUChainTracking::RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* cluster
   for (int32_t iPhase = 0; iPhase < 2; iPhase++) {
     uint32_t countTotal = 0;
     for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-      for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+      for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
         uint32_t count = 0;
         for (uint32_t k = 0; k < clusters->nClusters[iSector][iRow]; k++) {
           o2::tpc::ClusterNative cl = clusters->clusters[iSector][iRow][k];
@@ -349,7 +349,7 @@ void GPUChainTracking::DumpClusters(std::ostream& out, const o2::tpc::ClusterNat
   out << "\nTPC Clusters:\n";
   for (uint32_t iSec = 0; iSec < GPUCA_NSECTORS; iSec++) {
     out << "TPCClusters - Sector " << iSec << "\n";
-    for (uint32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+    for (uint32_t i = 0; i < GPUCA_NROWS; i++) {
       out << "  Row: " << i << ": " << clusters->nClusters[iSec][i] << " clusters:\n";
       for (uint32_t j = 0; j < clusters->nClusters[iSec][i]; j++) {
         const auto& cl = clusters->clusters[iSec][i][j];
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index f81f29b45c317..4ae1725444386 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -77,7 +77,7 @@ void GPUChainTracking::DumpData(const char* filename, const GPUTrackingInOutPoin
   DumpData(fp, ioPtrs->rawClusters, ioPtrs->nRawClusters, InOutPointerType::RAW_CLUSTERS);
   if (ioPtrs->clustersNative) {
     if (DumpData(fp, &ioPtrs->clustersNative->clustersLinear, &ioPtrs->clustersNative->nClustersTotal, InOutPointerType::CLUSTERS_NATIVE)) {
-      fwrite(&ioPtrs->clustersNative->nClusters[0][0], sizeof(ioPtrs->clustersNative->nClusters[0][0]), NSECTORS * GPUCA_ROW_COUNT, fp);
+      fwrite(&ioPtrs->clustersNative->nClusters[0][0], sizeof(ioPtrs->clustersNative->nClusters[0][0]), NSECTORS * GPUCA_NROWS, fp);
       if (ioPtrs->clustersNative->clustersMCTruth) {
         const auto& buffer = ioPtrs->clustersNative->clustersMCTruth->getBuffer();
         std::pair<const char*, size_t> tmp = {buffer.data(), buffer.size()};
@@ -188,7 +188,7 @@ int32_t GPUChainTracking::ReadData(const char* filename)
   int32_t nClustersTotal = 0;
   mIOMem.clusterNativeAccess.reset(new ClusterNativeAccess);
   if (ReadData<ClusterNative>(fp, &mIOMem.clusterNativeAccess->clustersLinear, &mIOMem.clusterNativeAccess->nClustersTotal, &mIOMem.clustersNative, InOutPointerType::CLUSTERS_NATIVE)) {
-    r = fread(&mIOMem.clusterNativeAccess->nClusters[0][0], sizeof(mIOMem.clusterNativeAccess->nClusters[0][0]), NSECTORS * GPUCA_ROW_COUNT, fp);
+    r = fread(&mIOMem.clusterNativeAccess->nClusters[0][0], sizeof(mIOMem.clusterNativeAccess->nClusters[0][0]), NSECTORS * GPUCA_NROWS, fp);
     mIOMem.clusterNativeAccess->setOffsetPtrs();
     mIOPtrs.clustersNative = mIOMem.clusterNativeAccess.get();
     std::pair<const char*, size_t> tmp = {nullptr, 0};
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 5ab4b963d7330..2919cb05280a2 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -283,7 +283,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   mRec->ReturnVolatileDeviceMemory();
   mRec->PopNonPersistentMemory(RecoStep::TPCMerging, qStr2Tag("TPCMERGE"));
 
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   if (GetProcessingSettings().createO2Output) {
     if (mTPCSectorScratchOnStack) {
       mRec->PopNonPersistentMemory(RecoStep::TPCSectorTracking, qStr2Tag("TPCSLCD1")); // Return the sector data memory early
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index e2d68f10819fb..475809e8d88f2 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -126,7 +126,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     uint32_t* ptr = doGPU ? mInputsShadow->mTPCClusterOccupancyMap : mInputsHost->mTPCClusterOccupancyMap;
     auto* ptrTmp = (GPUTPCClusterOccupancyMapBin*)mRec->AllocateVolatileMemory(GPUTPCClusterOccupancyMapBin::getTotalSize(param()), doGPU);
     runKernel<GPUMemClean16>(GetGridAutoStep(streamInitAndOccMap, RecoStep::TPCSectorTracking), ptrTmp, GPUTPCClusterOccupancyMapBin::getTotalSize(param()));
-    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fill>(GetGridBlk(GPUCA_NSECTORS * GPUCA_ROW_COUNT, streamInitAndOccMap), ptrTmp);
+    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fill>(GetGridBlk(GPUCA_NSECTORS * GPUCA_NROWS, streamInitAndOccMap), ptrTmp);
     runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fold>(GetGridBlk(mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap), ptrTmp, ptr + 2);
     mRec->ReturnVolatileMemory();
     mInputsHost->mTPCClusterOccupancyMap[1] = param().rec.tpc.occupancyMapTimeBins * 0x10000 + param().rec.tpc.occupancyMapTimeBinsAverage;
@@ -154,10 +154,10 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       GPUInfo("Creating Sector Data (Sector %d)", iSector);
     }
     TransferMemoryResourcesToGPU(RecoStep::TPCSectorTracking, &trk, useStream);
-    runKernel<GPUTPCCreateTrackingData>({doGPU ? GetGridBlk(GPUCA_ROW_COUNT, useStream) : GetGridAuto(0), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}}); // TODO: Check why GetGridAuto(0) is much fast on CPU
+    runKernel<GPUTPCCreateTrackingData>({doGPU ? GetGridBlk(GPUCA_NROWS, useStream) : GetGridAuto(0), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}}); // TODO: Check why GetGridAuto(0) is much fast on CPU
     streamInit[useStream] = true;
     if (GetProcessingSettings().deterministicGPUReconstruction) {
-      runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::hitData>({GetGridBlk(GPUCA_ROW_COUNT, useStream), {iSector}});
+      runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::hitData>({GetGridBlk(GPUCA_NROWS, useStream), {iSector}});
     }
     if (!doGPU && trk.CheckEmptySector() && GetProcessingSettings().debugLevel == 0) {
       return;
@@ -176,7 +176,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     }
 
     runKernel<GPUMemClean16>(GetGridAutoStep(useStream, RecoStep::TPCSectorTracking), trkShadow.Data().HitWeights(), trkShadow.Data().NumberOfHitsPlusAlign() * sizeof(*trkShadow.Data().HitWeights()));
-    runKernel<GPUTPCNeighboursFinder>({GetGridBlk(GPUCA_ROW_COUNT, useStream), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}});
+    runKernel<GPUTPCNeighboursFinder>({GetGridBlk(GPUCA_NROWS, useStream), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}});
     streamInit[useStream] = true;
 
     if (GetProcessingSettings().keepDisplayMemory) {
@@ -187,10 +187,10 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       }
     }
 
-    runKernel<GPUTPCNeighboursCleaner>({GetGridBlk(GPUCA_ROW_COUNT - 2, useStream), {iSector}});
+    runKernel<GPUTPCNeighboursCleaner>({GetGridBlk(GPUCA_NROWS - 2, useStream), {iSector}});
     DoDebugAndDump(RecoStep::TPCSectorTracking, GPUChainTrackingDebugFlags::TPCLinks, trk, &GPUTPCTracker::DumpLinks, *mDebugFile, 1);
 
-    runKernel<GPUTPCStartHitsFinder>({GetGridBlk(GPUCA_ROW_COUNT - 6, useStream), {iSector}});
+    runKernel<GPUTPCStartHitsFinder>({GetGridBlk(GPUCA_NROWS - 6, useStream), {iSector}});
     if (mRec->getGPUParameters(doGPU).par_SORT_STARTHITS) {
       runKernel<GPUTPCStartHitsSorter>({GetGridAuto(useStream), {iSector}});
     }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
index 8b36c9520659e..3616ee593069f 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
@@ -131,7 +131,7 @@ int32_t GPUChainTracking::ForwardTPCDigits()
   if (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) {
     throw std::runtime_error("Cannot forward TPC digits with Clusterizer on GPU");
   }
-  std::vector<ClusterNative> tmp[NSECTORS][GPUCA_ROW_COUNT];
+  std::vector<ClusterNative> tmp[NSECTORS][GPUCA_NROWS];
   uint32_t nTotal = 0;
   const float zsThreshold = param().rec.tpc.zsThreshold;
   for (int32_t i = 0; i < NSECTORS; i++) {
@@ -153,7 +153,7 @@ int32_t GPUChainTracking::ForwardTPCDigits()
   nTotal = 0;
   mClusterNativeAccess->clustersLinear = mIOMem.clustersNative.get();
   for (int32_t i = 0; i < NSECTORS; i++) {
-    for (int32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+    for (int32_t j = 0; j < GPUCA_NROWS; j++) {
       mClusterNativeAccess->nClusters[i][j] = tmp[i][j].size();
       memcpy(&mIOMem.clustersNative[nTotal], tmp[i][j].data(), tmp[i][j].size() * sizeof(*mClusterNativeAccess->clustersLinear));
       nTotal += tmp[i][j].size();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 0a6db295632fd..d476d28b3fb7b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -207,7 +207,7 @@ int64_t GPUTPCGMMerger::GetTrackLabelA(const S& trk) const
 template <class S>
 int64_t GPUTPCGMMerger::GetTrackLabel(const S& trk) const
 {
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   if (GetConstantMem()->ioPtrs.clustersNative->clustersMCTruth) {
     return GetTrackLabelA<o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>, S>(trk);
   } else
@@ -1333,7 +1333,7 @@ GPUd() void GPUTPCGMMerger::ResolveMergeSectors(GPUResolveSharedMemory& smem, in
 
 GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, int32_t itr)
 {
-  if (Param().rec.tpc.mergerCERowLimit > 0 && CAMath::Abs(track->QPt()) * Param().qptB5Scaler < 0.3f && (cls.row < Param().rec.tpc.mergerCERowLimit || cls.row >= GPUCA_ROW_COUNT - Param().rec.tpc.mergerCERowLimit)) {
+  if (Param().rec.tpc.mergerCERowLimit > 0 && CAMath::Abs(track->QPt()) * Param().qptB5Scaler < 0.3f && (cls.row < Param().rec.tpc.mergerCERowLimit || cls.row >= GPUCA_NROWS - Param().rec.tpc.mergerCERowLimit)) {
     return;
   }
 
@@ -1668,7 +1668,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         }
         nHits += nTrackHits;
       }
-      if (nHits < GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(trbase->QPt() * Param().qptB5Scaler)) {
+      if (nHits < GPUCA_TPC_MIN_HITS_B5(trbase->QPt() * Param().qptB5Scaler)) {
         break;
       }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 483bc6279c716..44915ec4ab6e9 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -76,7 +76,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
     if (nCl == 0) {
       continue;
     }
-    if (nCl + 2 < GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tracks[i].GetParam().GetQPt() * merger.Param().qptB5Scaler)) { // Give 2 hits tolerance in the primary leg, compared to the full fit of the looper
+    if (nCl + 2 < GPUCA_TPC_MIN_HITS_B5(tracks[i].GetParam().GetQPt() * merger.Param().qptB5Scaler)) { // Give 2 hits tolerance in the primary leg, compared to the full fit of the looper
       continue;
     }
     if (merger.Param().rec.tpc.minNClustersFinalTrack != -1 && nCl < (uint32_t)merger.Param().rec.tpc.minNClustersFinalTrack) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index e91426b51e5c4..f8f1269acac3a 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -557,7 +557,7 @@ GPUd() void GPUTPCGMPropagator::GetErr2(float& GPUrestrict() err2Y, float& GPUre
 
 GPUd() void GPUTPCGMPropagator::GetErr2(float& GPUrestrict() err2Y, float& GPUrestrict() err2Z, const GPUParam& GPUrestrict() param, float snp, float tgl, float posZ, float trackX, float trackY, int32_t iRow, int16_t clusterState, int8_t sector, float time, float avgCharge, float charge, bool seedingErrors)
 {
-#ifndef GPUCA_TPC_GEOMETRY_O2
+#ifdef GPUCA_RUN2
   if (seedingErrors) {
     param.GetClusterErrorsSeeding2(sector, iRow, posZ, snp, tgl, time, err2Y, err2Z);
   } else
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index fe2029e5563f4..f5731a532e7f3 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -113,7 +113,7 @@ GPUd() bool GPUTPCGMSectorTrack::FilterErrors(const GPUTPCGMMerger* merger, int3
 
   {
     merger->Param().GetClusterErrors2(iSector, 0, mParam.mZ, mParam.mSinPhi, mParam.mDzDs, -1.f, 0.f, 0.f, mParam.mC0, mParam.mC2); // TODO: provide correct time and row
-#ifndef GPUCA_TPC_GEOMETRY_O2
+#ifdef GPUCA_RUN2
     float C0a, C2a;
     merger->Param().GetClusterErrorsSeeding2(iSector, 0, mParam.mZ, mParam.mSinPhi, mParam.mDzDs, -1.f, C0a, C2a);
     if (C0a > mParam.mC0) {
@@ -173,7 +173,7 @@ GPUd() bool GPUTPCGMSectorTrack::FilterErrors(const GPUTPCGMMerger* merger, int3
       float ex1i = 1.f / ex1;
       {
         merger->Param().GetClusterErrors2(iSector, 0, mParam.mZ, mParam.mSinPhi, mParam.mDzDs, -1.f, 0.f, 0.f, err2Y, err2Z); // TODO: Provide correct time / row
-#ifndef GPUCA_TPC_GEOMETRY_O2
+#ifdef GPUCA_RUN2
         float C0a, C2a;
         merger->Param().GetClusterErrorsSeeding2(iSector, 0, mParam.mZ, mParam.mSinPhi, mParam.mDzDs, -1.f, C0a, C2a);
         if (C0a > err2Y) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index ffc9ba7bbe9f8..5cbc12b4895f4 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -344,7 +344,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     o2::utils::DebugStreamer::instance()->getStreamer("debug_accept_track", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("debug_accept_track").data() << "iTrk=" << iTrk << "outerParam=" << track.OuterParam() << "track=" << this << "ihitStart=" << ihitStart << "\n";
   })
 
-  if (!(N + NTolerated >= GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(mP[4] * param.qptB5Scaler) && 2 * NTolerated <= CAMath::Max(10, N) && CheckNumericalQuality(covYYUpd))) {
+  if (!(N + NTolerated >= GPUCA_TPC_MIN_HITS_B5(mP[4] * param.qptB5Scaler) && 2 * NTolerated <= CAMath::Max(10, N) && CheckNumericalQuality(covYYUpd))) {
     return false; // TODO: NTolerated should never become that large, check what is going wrong!
   }
   if (param.rec.tpc.minNClustersFinalTrack != -1 && N + NTolerated < param.rec.tpc.minNClustersFinalTrack) {
@@ -624,7 +624,7 @@ GPUdii() void GPUTPCGMTrackParam::StoreOuter(gputpcgmmergertypes::GPUTPCOuterPar
 
 GPUdic(0, 1) void GPUTPCGMTrackParam::StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, float alpha)
 {
-  if (iRow == 0 || iRow == GPUCA_ROW_COUNT - 1) {
+  if (iRow == 0 || iRow == GPUCA_NROWS - 1) {
     return;
   }
   if (CAMath::Abs(mP[2]) >= GPUCA_MAX_SIN_PHI) { // TODO: How can we avoid this?
@@ -700,7 +700,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooperFollow(const GPUTPCGMMerger
       if (CAMath::Abs(mP[2]) > 0.7f) {
         return;
       }
-      if (up ? (-mP[0] * lrFactor > GPUTPCGeometry::Row2X(GPUCA_ROW_COUNT - 1)) : (-mP[0] * lrFactor < GPUTPCGeometry::Row2X(0))) {
+      if (up ? (-mP[0] * lrFactor > GPUTPCGeometry::Row2X(GPUCA_NROWS - 1)) : (-mP[0] * lrFactor < GPUTPCGeometry::Row2X(0))) {
         return;
       }
       if (!((up ? (-mP[0] * lrFactor >= toX) : (-mP[0] * lrFactor <= toX)) || (right ^ (mP[2] > 0)))) {
@@ -712,7 +712,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooperFollow(const GPUTPCGMMerger
         return;
       }
       CADEBUG(printf("\tPropagated to y = %f: X %f Z %f SinPhi %f\n", mX, mP[0], mP[1], mP[2]));
-      for (int32_t j = 0; j < GPUCA_ROW_COUNT; j++) { // TODO: Avoid iterating over all rows
+      for (int32_t j = 0; j < GPUCA_NROWS; j++) { // TODO: Avoid iterating over all rows
         float rowX = GPUTPCGeometry::Row2X(j);
         if (CAMath::Abs(rowX - (-mP[0] * lrFactor)) < 1.5f) {
           CADEBUG(printf("\t\tAttempt row %d (X %f Y %f Z %f)\n", j, rowX, mX * lrFactor, mP[1]));
@@ -788,7 +788,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUr
     float paramX = mP[2] > 0 ? -Y : Y;
     int32_t step = outwards ? 1 : -1;
     int32_t found = 0;
-    for (int32_t j = iRow; j >= 0 && j < GPUCA_ROW_COUNT && found < 3; j += step) {
+    for (int32_t j = iRow; j >= 0 && j < GPUCA_NROWS && found < 3; j += step) {
       float rowX = mX + GPUTPCGeometry::Row2X(j) - myRowX;
       if (CAMath::Abs(rowX - paramX) < 1.5f) {
         // printf("Attempt row %d at y %f\n", j, X);
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.cxx
index ae71bcdb541ca..7a825defaa176 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.cxx
@@ -24,11 +24,11 @@ GPUdii() void GPUTPCCreateOccupancyMap::Thread<GPUTPCCreateOccupancyMap::fill>(i
   const o2::tpc::ClusterNativeAccess* GPUrestrict() clusters = ioPtrs.clustersNative;
   GPUParam& GPUrestrict() param = processors.param;
   const int32_t iSectorRow = iBlock * nThreads + iThread;
-  if (iSectorRow >= GPUCA_ROW_COUNT * GPUCA_NSECTORS) {
+  if (iSectorRow >= GPUCA_NROWS * GPUCA_NSECTORS) {
     return;
   }
-  const uint32_t iSector = iSectorRow / GPUCA_ROW_COUNT;
-  const uint32_t iRow = iSectorRow % GPUCA_ROW_COUNT;
+  const uint32_t iSector = iSectorRow / GPUCA_NROWS;
+  const uint32_t iRow = iSectorRow % GPUCA_NROWS;
   for (uint32_t i = 0; i < clusters->nClusters[iSector][iRow]; i++) {
     const uint32_t bin = clusters->clusters[iSector][iRow][i].getTime() / param.rec.tpc.occupancyMapTimeBins;
     map[bin].bin[iSector][iRow]++;
@@ -47,7 +47,7 @@ GPUdii() void GPUTPCCreateOccupancyMap::Thread<GPUTPCCreateOccupancyMap::fold>(i
   int32_t binmax = CAMath::Min<int32_t>(GPUTPCClusterOccupancyMapBin::getNBins(param), bin + param.rec.tpc.occupancyMapTimeBinsAverage + 1);
   uint32_t sum = 0;
   for (int32_t i = binmin; i < binmax; i++) {
-    for (int32_t iSectorRow = 0; iSectorRow < GPUCA_NSECTORS * GPUCA_ROW_COUNT; iSectorRow++) {
+    for (int32_t iSectorRow = 0; iSectorRow < GPUCA_NSECTORS * GPUCA_NROWS; iSectorRow++) {
       sum += (&map[i].bin[0][0])[iSectorRow];
     }
   }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCDef.h b/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
index e64937eec0ede..d2b3cc1b9632d 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCDef.h
@@ -23,13 +23,8 @@
 
 namespace o2::gpu
 {
-#if defined(GPUCA_O2_LIB) || defined(GPUCA_O2_INTERFACE)
 typedef uint32_t calink;
 typedef uint32_t cahit;
-#else
-typedef uint32_t calink;
-typedef uint32_t cahit;
-#endif
 struct cahit2 { cahit x, y; };
 } // namespace o2::GPU
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
index ee403116cc6da..3c54afac16ee2 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
@@ -67,7 +67,7 @@ GPUd() int32_t GPUTPCExtrapolationTracking::PerformExtrapolationTrackingRun(GPUT
     tParam.SetCov(2, err2Z);
   }
 
-  calink rowHits[GPUCA_ROW_COUNT];
+  calink rowHits[GPUCA_NROWS];
   int32_t nHits = GPUTPCTrackletConstructor::GPUTPCTrackletConstructorExtrapolationTracking(tracker, smem, tParam, rowIndex, direction, 0, rowHits);
   if (nHits >= tracker.Param().rec.tpc.extrapolationTrackingMinHits) {
     // GPUInfo("%d hits found", nHits);
@@ -140,7 +140,7 @@ GPUd() void GPUTPCExtrapolationTracking::PerformExtrapolationTracking(int32_t nB
 
     {
       const int32_t tmpHit = tracker.Tracks()[i].FirstHitID() + tracker.Tracks()[i].NHits() - 1;
-      if (tracker.TrackHits()[tmpHit].RowIndex() < GPUCA_ROW_COUNT - tracker.Param().rec.tpc.extrapolationTrackingMinRows && tracker.TrackHits()[tmpHit].RowIndex() >= GPUCA_ROW_COUNT - tracker.Param().rec.tpc.extrapolationTrackingRowRange) {
+      if (tracker.TrackHits()[tmpHit].RowIndex() < GPUCA_NROWS - tracker.Param().rec.tpc.extrapolationTrackingMinRows && tracker.TrackHits()[tmpHit].RowIndex() >= GPUCA_NROWS - tracker.Param().rec.tpc.extrapolationTrackingRowRange) {
         int32_t rowIndex = tracker.TrackHits()[tmpHit].RowIndex();
         const GPUTPCRow& GPUrestrict() row = tracker.Row(rowIndex);
         float Y = (float)tracker.Data().HitDataY(row, tracker.TrackHits()[tmpHit].HitIndex()) * row.HstepY() + row.Grid().YMin();
@@ -160,7 +160,7 @@ GPUd() void GPUTPCExtrapolationTracking::PerformExtrapolationTracking(int32_t nB
 template <>
 GPUdii() void GPUTPCExtrapolationTracking::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() tracker)
 {
-  CA_SHARED_CACHE(&smem.mRows[0], tracker.TrackingDataRows(), GPUCA_ROW_COUNT * sizeof(GPUTPCRow));
+  CA_SHARED_CACHE(&smem.mRows[0], tracker.TrackingDataRows(), GPUCA_NROWS * sizeof(GPUTPCRow));
   GPUbarrier();
 
   if (tracker.NHitsTotal() == 0) {
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
index 9e39ba0ce258d..c3364d6bedef4 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
@@ -26,7 +26,7 @@ class GPUTPCExtrapolationTracking : public GPUKernelTemplate
 {
  public:
   struct GPUSharedMemory {
-    CA_SHARED_STORAGE(GPUTPCRow mRows[GPUCA_ROW_COUNT]);
+    CA_SHARED_STORAGE(GPUTPCRow mRows[GPUCA_NROWS]);
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCMCInfo.h b/GPU/GPUTracking/SectorTracker/GPUTPCMCInfo.h
index ffd95cd807413..07032660c211c 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCMCInfo.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCMCInfo.h
@@ -29,7 +29,7 @@ struct GPUTPCMCInfo {
   float pY;
   float pZ;
   float genRadius;
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   float t0;
 #endif
 };
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.cxx
index 04b303949e9f4..eb4093d9a1876 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.cxx
@@ -26,7 +26,7 @@ GPUdii() void GPUTPCNeighboursCleaner::Thread<0>(int32_t /*nBlocks*/, int32_t nT
 
   if (iThread == 0) {
     s.mIRow = iBlock + 2;
-    if (s.mIRow <= GPUCA_ROW_COUNT - 3) {
+    if (s.mIRow <= GPUCA_NROWS - 3) {
       s.mIRowUp = s.mIRow + 2;
       s.mIRowDn = s.mIRow - 2;
       s.mNHits = tracker.Row(s.mIRow).NHits();
@@ -34,7 +34,7 @@ GPUdii() void GPUTPCNeighboursCleaner::Thread<0>(int32_t /*nBlocks*/, int32_t nT
   }
   GPUbarrier();
 
-  if (s.mIRow <= GPUCA_ROW_COUNT - 3) {
+  if (s.mIRow <= GPUCA_NROWS - 3) {
 #ifdef GPUCA_GPUCODE
     int32_t Up = s.mIRowUp;
     int32_t Dn = s.mIRowDn;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
index 54ce7f12c655f..4fef9f585b625 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
@@ -27,7 +27,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
 #ifdef GPUCA_GPUCODE
   for (uint32_t i = iThread; i < sizeof(GPUTPCRow) / sizeof(int32_t); i += nThreads) {
     reinterpret_cast<GPUsharedref() int32_t*>(&s.mRow)[i] = reinterpret_cast<GPUglobalref() int32_t*>(&tracker.TrackingDataRows()[iBlock])[i];
-    if (iBlock >= 2 && iBlock < GPUCA_ROW_COUNT - 2) {
+    if (iBlock >= 2 && iBlock < GPUCA_NROWS - 2) {
       reinterpret_cast<GPUsharedref() int32_t*>(&s.mRowUp)[i] = reinterpret_cast<GPUglobalref() int32_t*>(&tracker.TrackingDataRows()[iBlock + 2])[i];
       reinterpret_cast<GPUsharedref() int32_t*>(&s.mRowDown)[i] = reinterpret_cast<GPUglobalref() int32_t*>(&tracker.TrackingDataRows()[iBlock - 2])[i];
     }
@@ -46,9 +46,9 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
     s.mIRow = iBlock;
     s.mIRowUp = iBlock + 2;
     s.mIRowDn = iBlock - 2;
-    if (s.mIRow < GPUCA_ROW_COUNT) {
+    if (s.mIRow < GPUCA_NROWS) {
       s.mNHits = row.mNHits;
-      if ((s.mIRow >= 2) && (s.mIRow <= GPUCA_ROW_COUNT - 3)) {
+      if ((s.mIRow >= 2) && (s.mIRow <= GPUCA_NROWS - 3)) {
         // the axis perpendicular to the rows
         const float xDn = rowDn.mX;
         const float x = row.mX;
@@ -66,7 +66,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
 
   // local copies
 
-  if ((s.mIRow <= 1) || (s.mIRow >= GPUCA_ROW_COUNT - 2) || (rowUp.mNHits <= 0) || (rowDn.mNHits <= 0)) {
+  if ((s.mIRow <= 1) || (s.mIRow >= GPUCA_NROWS - 2) || (rowUp.mNHits <= 0) || (rowDn.mNHits <= 0)) {
     const int32_t lHitNumberOffset = row.mHitNumberOffset;
     for (int32_t ih = iThread; ih < s.mNHits; ih += nThreads) {
       tracker.mData.mLinkUpData[lHitNumberOffset + ih] = CALINK_INVAL;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
index 06dac4a68c540..ef5ae8c040934 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
@@ -25,7 +25,7 @@ GPUdii() void GPUTPCStartHitsFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nThr
   if (iThread == 0) {
     s.mIRow = iBlock + 1;
     s.mNRowStartHits = 0;
-    if (s.mIRow <= GPUCA_ROW_COUNT - 4) {
+    if (s.mIRow <= GPUCA_NROWS - 4) {
       s.mNHits = tracker.mData.mRows[s.mIRow].mNHits;
     } else {
       s.mNHits = -1;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.cxx
index 034fa8f053f42..9a9b19ef045b5 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.cxx
@@ -25,12 +25,12 @@ GPUdii() void GPUTPCStartHitsSorter::Thread<0>(int32_t nBlocks, int32_t nThreads
 {
   // Sorts the Start Hits by Row Index
   if (iThread == 0) {
-    const int32_t tmpNRows = GPUCA_ROW_COUNT - 6;
+    const int32_t tmpNRows = GPUCA_NROWS - 6;
     const int32_t nRows = iBlock == (nBlocks - 1) ? (tmpNRows - (tmpNRows / nBlocks) * (nBlocks - 1)) : (tmpNRows / nBlocks);
     const int32_t nStartRow = (tmpNRows / nBlocks) * iBlock + 1;
     int32_t startOffset2 = 0;
     GPUCA_UNROLL(, U())
-    for (int32_t ir = 1; ir < GPUCA_ROW_COUNT - 5; ir++) {
+    for (int32_t ir = 1; ir < GPUCA_NROWS - 5; ir++) {
       if (ir < nStartRow) {
         startOffset2 += tracker.mRowStartHitCountOffset[ir];
       }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index 506f90c55abf3..aec75d449730e 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -63,8 +63,8 @@ void* GPUTPCTracker::SetPointersScratch(void* mem)
     mem = SetPointersTracklets(mem);
   }
   if (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCSectorTracking) {
-    computePointerWithAlignment(mem, mTrackletTmpStartHits, GPUCA_ROW_COUNT * mNMaxRowStartHits);
-    computePointerWithAlignment(mem, mRowStartHitCountOffset, GPUCA_ROW_COUNT);
+    computePointerWithAlignment(mem, mTrackletTmpStartHits, GPUCA_NROWS * mNMaxRowStartHits);
+    computePointerWithAlignment(mem, mRowStartHitCountOffset, GPUCA_NROWS);
   }
   return mem;
 }
@@ -135,12 +135,12 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   }
   if (io.clustersNative) {
     uint32_t maxRowHits = 0;
-    for (uint32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+    for (uint32_t i = 0; i < GPUCA_NROWS; i++) {
       if (io.clustersNative->nClusters[mISector][i] > maxRowHits) {
         maxRowHits = io.clustersNative->nClusters[mISector][i];
       }
     }
-    mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(maxRowHits * GPUCA_ROW_COUNT);
+    mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(maxRowHits * GPUCA_NROWS);
   } else {
     mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(mData.NumberOfHits());
   }
@@ -160,8 +160,8 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   mNMaxTrackHits = mRec->MemoryScalers()->NTPCSectorTrackHits(mData.NumberOfHits(), mRec->GetProcessingSettings().tpcInputWithClusterRejection);
 
   if (mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCSectorTracking).par_SORT_STARTHITS) {
-    if (mNMaxStartHits > mNMaxRowStartHits * GPUCA_ROW_COUNT) {
-      mNMaxStartHits = mNMaxRowStartHits * GPUCA_ROW_COUNT;
+    if (mNMaxStartHits > mNMaxRowStartHits * GPUCA_NROWS) {
+      mNMaxStartHits = mNMaxRowStartHits * GPUCA_NROWS;
     }
   }
   mData.SetMaxData();
@@ -171,7 +171,7 @@ void GPUTPCTracker::UpdateMaxData()
 {
   mNMaxTracklets = mCommonMem->nStartHits;
   mNMaxTracks = mNMaxTracklets * 2 + 50;
-  mNMaxRowHits = mNMaxTracklets * GPUCA_ROW_COUNT;
+  mNMaxRowHits = mNMaxTracklets * GPUCA_NROWS;
 }
 
 void GPUTPCTracker::SetupCommonMemory() { new (mCommonMem) commonMemoryStruct; }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
index e66ad71783dbd..91a97a9056a1c 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
@@ -30,7 +30,7 @@ void GPUTPCTracker::DumpTrackingData(std::ostream& out)
 {
   // Dump Sector Input Data to File
   out << "\nSector Data (Sector" << mISector << "):" << std::endl;
-  for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
     if (Row(i).NHits() == 0) {
       continue;
     }
@@ -49,7 +49,7 @@ void GPUTPCTracker::DumpLinks(std::ostream& out, int32_t phase)
 {
   // Dump Links (after Neighbours Finder / Cleaner) to file
   out << "\nHit Links (Phase " << phase << ", Sector" << mISector << "):" << std::endl;
-  for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
     if (Row(i).NHits() == 0) {
       continue;
     }
@@ -68,7 +68,7 @@ void GPUTPCTracker::DumpHitWeights(std::ostream& out)
 {
   // dump hit weights to file
   out << "\nHit Weights(Sector" << mISector << "):" << std::endl;
-  for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
     if (Row(i).NHits() == 0) {
       continue;
     }
@@ -145,10 +145,10 @@ void GPUTPCTracker::DumpTrackletHits(std::ostream& out)
     const int32_t j = Ids[jj];
     const auto& tracklet = Tracklets()[j];
     out << "Tracklet " << std::setw(4) << jj << " (Rows: " << Tracklets()[j].FirstRow() << " - " << tracklet.LastRow() << ", Weight " << Tracklets()[j].HitWeight() << ") ";
-    if (tracklet.LastRow() > tracklet.FirstRow() && (tracklet.FirstRow() >= GPUCA_ROW_COUNT || tracklet.LastRow() >= GPUCA_ROW_COUNT)) {
+    if (tracklet.LastRow() > tracklet.FirstRow() && (tracklet.FirstRow() >= GPUCA_NROWS || tracklet.LastRow() >= GPUCA_NROWS)) {
       GPUError("Error: Tracklet %d First %d Last %d", j, tracklet.FirstRow(), tracklet.LastRow());
       out << " (Error: Tracklet " << j << " First " << tracklet.FirstRow() << " Last " << tracklet.LastRow() << ") ";
-      for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+      for (int32_t i = 0; i < GPUCA_NROWS; i++) {
         // if (tracklet.RowHit(i) != CALINK_INVAL)
         out << i << "-" << mTrackletRowHits[tracklet.FirstHit() + (i - tracklet.FirstRow())] << ", ";
       }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
index 4d719e6d80576..dfb97402c1b1d 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
@@ -35,10 +35,10 @@ using namespace o2::gpu;
 void GPUTPCTrackingData::InitializeRows(const GPUParam& p)
 {
   // initialisation of rows
-  for (int32_t i = 0; i < GPUCA_ROW_COUNT + 1; i++) {
+  for (int32_t i = 0; i < GPUCA_NROWS + 1; i++) {
     new (&mRows[i]) GPUTPCRow;
   }
-  for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
     mRows[i].mX = GPUTPCGeometry::Row2X(i);
     mRows[i].mMaxY = CAMath::Tan(p.dAlpha / 2.f) * mRows[i].mX;
   }
@@ -52,7 +52,7 @@ void GPUTPCTrackingData::SetClusterData(int32_t nClusters, int32_t clusterIdOffs
 
 void GPUTPCTrackingData::SetMaxData()
 {
-  int32_t hitMemCount = GPUCA_ROW_COUNT * GPUCA_ROWALIGNMENT + mNumberOfHits;
+  int32_t hitMemCount = GPUCA_NROWS * GPUCA_ROWALIGNMENT + mNumberOfHits;
   const uint32_t kVectorAlignment = 256;
   mNumberOfHitsPlusAlign = GPUProcessor::nextMultipleOf<(kVectorAlignment > GPUCA_ROWALIGNMENT ? kVectorAlignment : GPUCA_ROWALIGNMENT) / sizeof(int32_t)>(hitMemCount);
 }
@@ -72,7 +72,7 @@ void* GPUTPCTrackingData::SetPointersWeights(void* mem)
 
 void* GPUTPCTrackingData::SetPointersScratch(void* mem, bool idsOnGPU)
 {
-  const int32_t firstHitInBinSize = GetGridSize(mNumberOfHits, GPUCA_ROW_COUNT) + GPUCA_ROW_COUNT * GPUCA_ROWALIGNMENT / sizeof(int32_t);
+  const int32_t firstHitInBinSize = GetGridSize(mNumberOfHits, GPUCA_NROWS) + GPUCA_NROWS * GPUCA_ROWALIGNMENT / sizeof(int32_t);
   GPUProcessor::computePointerWithAlignment(mem, mHitData, mNumberOfHitsPlusAlign);
   GPUProcessor::computePointerWithAlignment(mem, mFirstHitInBin, firstHitInBinSize);
   if (idsOnGPU) {
@@ -91,7 +91,7 @@ void* GPUTPCTrackingData::SetPointersClusterIds(void* mem, bool idsOnGPU)
 
 void* GPUTPCTrackingData::SetPointersRows(void* mem)
 {
-  GPUProcessor::computePointerWithAlignment(mem, mRows, GPUCA_ROW_COUNT + 1);
+  GPUProcessor::computePointerWithAlignment(mem, mRows, GPUCA_NROWS + 1);
   return mem;
 }
 
@@ -173,7 +173,7 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
   static_assert(sizeof(*binMemory) <= sizeof(*mHitWeights), "Cannot reuse memory");
 #endif
 
-  for (int32_t rowIndex = iBlock; rowIndex < GPUCA_ROW_COUNT; rowIndex += nBlocks) {
+  for (int32_t rowIndex = iBlock; rowIndex < GPUCA_NROWS; rowIndex += nBlocks) {
     float yMin = 1.e6f;
     float yMax = -1.e6f;
     float zMin = 1.e6f;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
index 15a3d4667db47..4c932a1c01bd2 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
@@ -56,8 +56,8 @@ GPUd() void GPUTPCTrackletConstructor::StoreTracklet(int32_t /*nBlocks*/, int32_
 {
   // reconstruction of tracklets, tracklet store step
   const uint32_t nHits = r.mLastRow + 1 - r.mFirstRow;
-  if (nHits == 0 || r.mNHits == 0 || (r.mNHits < GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tParam.QPt() * tracker.Param().qptB5Scaler) || !CheckCov(tParam) || CAMath::Abs(tParam.GetQPt() * tracker.Param().qptB5Scaler) > tracker.Param().rec.maxTrackQPtB5)) {
-    CADEBUG(printf("    Rejected: nHits %d QPt %f MinHits %d MaxQPt %f CheckCov %d\n", r.mNHits, tParam.QPt(), GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tParam.QPt() * tracker.Param().qptB5Scaler), tracker.Param().rec.maxTrackQPtB5, (int32_t)CheckCov(tParam)));
+  if (nHits == 0 || r.mNHits == 0 || (r.mNHits < GPUCA_TPC_MIN_HITS_B5(tParam.QPt() * tracker.Param().qptB5Scaler) || !CheckCov(tParam) || CAMath::Abs(tParam.GetQPt() * tracker.Param().qptB5Scaler) > tracker.Param().rec.maxTrackQPtB5)) {
+    CADEBUG(printf("    Rejected: nHits %d QPt %f MinHits %d MaxQPt %f CheckCov %d\n", r.mNHits, tParam.QPt(), GPUCA_TPC_MIN_HITS_B5(tParam.QPt() * tracker.Param().qptB5Scaler), tracker.Param().rec.maxTrackQPtB5, (int32_t)CheckCov(tParam)));
     return;
   }
 
@@ -404,9 +404,9 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
 
 GPUdic(2, 1) void GPUTPCTrackletConstructor::DoTracklet(GPUconstantref() GPUTPCTracker& GPUrestrict() tracker, GPUsharedref() GPUTPCTrackletConstructor::GPUSharedMemory& s, GPUTPCThreadMemory& GPUrestrict() r)
 {
-  int32_t iRow = 0, iRowEnd = GPUCA_ROW_COUNT;
+  int32_t iRow = 0, iRowEnd = GPUCA_NROWS;
   GPUTPCTrackParam tParam;
-  calink rowHits[GPUCA_ROW_COUNT];
+  calink rowHits[GPUCA_NROWS];
   if (r.mGo) {
     GPUTPCHitId id = tracker.TrackletStartHits()[r.mISH];
 
@@ -482,7 +482,7 @@ GPUdii() void GPUTPCTrackletConstructor::Thread(int32_t nBlocks, int32_t nThread
   if (get_local_id(0) == 0) {
     sMem.mNStartHits = *tracker.NStartHits();
   }
-  CA_SHARED_CACHE(&sMem.mRows[0], tracker.TrackingDataRows(), GPUCA_ROW_COUNT * sizeof(GPUTPCRow));
+  CA_SHARED_CACHE(&sMem.mRows[0], tracker.TrackingDataRows(), GPUCA_NROWS * sizeof(GPUTPCRow));
   GPUbarrier();
 
   GPUTPCThreadMemory rMem;
@@ -500,7 +500,7 @@ GPUd() int32_t GPUTPCTrackletConstructor::GPUTPCTrackletConstructorExtrapolation
   rMem.mStage = 3;
   rMem.mNHits = rMem.mNMissed = 0;
   rMem.mGo = 1;
-  while (rMem.mGo && row >= 0 && row < GPUCA_ROW_COUNT) {
+  while (rMem.mGo && row >= 0 && row < GPUCA_NROWS) {
     UpdateTracklet(1, 1, 0, 0, sMem, rMem, tracker, tParam, row, rowHits[row], nullptr);
     row += increment;
   }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
index 120797ad4f1eb..40db8d557a73f 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
@@ -62,7 +62,7 @@ class GPUTPCTrackletConstructor : public GPUKernelTemplate
   };
 
   struct GPUSharedMemory {
-    CA_SHARED_STORAGE(GPUTPCRow mRows[GPUCA_ROW_COUNT]); // rows
+    CA_SHARED_STORAGE(GPUTPCRow mRows[GPUCA_NROWS]);     // rows
     int32_t mNStartHits;                                 // Total number of start hits
 
 #ifdef GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
index 3049136c98f1d..d3c679c2a88e8 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
@@ -33,7 +33,7 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
   }
   GPUbarrier();
 
-  GPUTPCHitId trackHits[GPUCA_ROW_COUNT - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
+  GPUTPCHitId trackHits[GPUCA_NROWS - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
   const float maxSharedFrac = tracker.Param().rec.tpc.trackletMaxSharedFraction;
 
   for (int32_t itr = s.mItr0 + iThread; itr < s.mNTracklets; itr += s.mNThreadsTotal) {
@@ -51,7 +51,7 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
     uint32_t gap = 0;
     uint32_t nShared = 0;
     uint32_t nHits = 0;
-    const uint32_t minHits = tracker.Param().rec.tpc.minNClustersTrackSeed == -1 ? GPUCA_TRACKLET_SELECTOR_MIN_HITS_B5(tracklet.Param().QPt() * tracker.Param().qptB5Scaler) : tracker.Param().rec.tpc.minNClustersTrackSeed;
+    const uint32_t minHits = tracker.Param().rec.tpc.minNClustersTrackSeed == -1 ? GPUCA_TPC_MIN_HITS_B5(tracklet.Param().QPt() * tracker.Param().qptB5Scaler) : tracker.Param().rec.tpc.minNClustersTrackSeed;
     const uint32_t sharingMinNorm = minHits * tracker.Param().rec.tpc.trackletMinSharedNormFactor;
     const float maxSharedNorm = maxSharedFrac * sharingMinNorm;
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
index 6a4a7d9013e5a..8974b788015f5 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
@@ -36,7 +36,7 @@ class GPUTPCTrackletSelector : public GPUKernelTemplate
     int32_t mNThreadsTotal; // total n threads
     int32_t mNTracklets;    // n of tracklets
     int32_t mReserved;      // for alignment reasons
-    static_assert(GPUCA_ROW_COUNT >= GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE);
+    static_assert(GPUCA_NROWS >= GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE);
     GPUTPCHitId mHits[GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletSelector)];
   };
 
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 023e7a2b0b142..d786bf8cbdf67 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -153,7 +153,7 @@ int32_t ReadConfiguration(int argc, char** argv)
     return 1;
   }
 #endif
-#ifndef GPUCA_TPC_GEOMETRY_O2
+#ifdef GPUCA_RUN2
 #error Why was configStandalone.rec.tpc.mergerReadFromTrackerDirectly = 0 needed?
   configStandalone.proc.inKernelParallel = false;
   configStandalone.proc.createO2Output = 0;
@@ -522,7 +522,7 @@ int32_t ReadEvent(int32_t n)
   if (r) {
     return r;
   }
-#if defined(GPUCA_TPC_GEOMETRY_O2) && defined(GPUCA_BUILD_QA) && !defined(GPUCA_O2_LIB)
+#if !defined(GPUCA_RUN2) && defined(GPUCA_BUILD_QA) && defined(GPUCA_STANDALONE)
   if ((configStandalone.proc.runQA || configStandalone.eventDisplay) && !configStandalone.QA.noMC) {
     chainTracking->ForceInitQA();
     chainTracking->GetQA()->UpdateChain(chainTracking);
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 0cf72fd2b4c3e..a6f9147e39679 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -204,8 +204,8 @@ target_link_libraries(standalone_support PUBLIC#
 target_link_libraries(GPUTracking PUBLIC standalone_support)
 target_link_libraries(TPCFastTransformation PUBLIC standalone_support)
 
-if(GPUCA_CONFIG_O2)
-  target_compile_definitions(GPUTracking PRIVATE GPUCA_TPC_GEOMETRY_O2)
+if(NOT GPUCA_CONFIG_O2)
+  target_compile_definitions(GPUTracking PRIVATE GPUCA_RUN2)
 endif()
 
 if(GPUCA_CONFIG_FMT)
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
index 8cbcf320e2547..3bc431babcc74 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
@@ -43,7 +43,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
 GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineGPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
 #ifdef GPUCA_GPUCODE
-  if (iBlock >= GPUCA_ROW_COUNT) {
+  if (iBlock >= GPUCA_NROWS) {
     return;
   }
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
index bb44e5e69a9e1..367bcf73a0af8 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
@@ -64,7 +64,7 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
   static int32_t GetNBlocks(bool isGPU)
   {
     const int32_t nBlocks = TPC_CLUSTERER_STRIDED_PAD_COUNT / PadsPerCacheline;
-    return isGPU ? GPUCA_ROW_COUNT : nBlocks;
+    return isGPU ? GPUCA_NROWS : nBlocks;
   }
 
   template <int32_t iKernel = defaultKernel>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index e20f5d8b0f074..8ab6ab407a9ed 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -435,7 +435,7 @@ GPUd() void GPUTPCCFDecodeZSLinkBase::Decode(int32_t nBlocks, int32_t nThreads,
 
 GPUd() o2::tpc::PadPos GPUTPCCFDecodeZSLinkBase::GetPadAndRowFromFEC(processorType& clusterer, int32_t cru, int32_t rawFECChannel, int32_t fecInPartition)
 {
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   // Ported from tpc::Mapper (Not available on GPU...)
   constexpr GPUTPCGeometry geo;
 
@@ -466,7 +466,7 @@ GPUd() void GPUTPCCFDecodeZSLinkBase::WriteCharge(processorType& clusterer, floa
   const uint32_t sector = clusterer.mISector;
   CfChargePos* positions = clusterer.mPpositions;
 #ifdef GPUCA_CHECK_TPCZS_CORRUPTION
-  if (padAndRow.getRow() >= GPUCA_ROW_COUNT) {
+  if (padAndRow.getRow() >= GPUCA_NROWS) {
     positions[positionOffset] = INVALID_CHARGE_POS;
     clusterer.raiseError(GPUErrors::ERROR_TPCZS_INVALID_ROW, clusterer.mISector * 1000 + padAndRow.getRow());
     return;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.cxx
index f7488821d545f..b39ee87bc4fa5 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.cxx
@@ -32,7 +32,7 @@ void GPUTPCCFMCLabelFlattener::setGlobalOffsetsAndAllocate(
   cls.mPlabelsHeaderGlobalOffset = headerOffset;
   cls.mPlabelsDataGlobalOffset = dataOffset;
 
-  for (Row row = 0; row < GPUCA_ROW_COUNT; row++) {
+  for (Row row = 0; row < GPUCA_NROWS; row++) {
     headerOffset += cls.mPclusterInRow[row];
     dataOffset += cls.mPlabelsInRow[row];
   }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
index 979980f32a479..a16c627344820 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
@@ -73,7 +73,7 @@ void* GPUTPCClusterFinder::SetPointersZS(void* mem)
 
 void* GPUTPCClusterFinder::SetPointersOutput(void* mem)
 {
-  computePointerWithAlignment(mem, mPclusterInRow, GPUCA_ROW_COUNT);
+  computePointerWithAlignment(mem, mPclusterInRow, GPUCA_NROWS);
   return mem;
 }
 
@@ -91,7 +91,7 @@ void* GPUTPCClusterFinder::SetPointersScratch(void* mem)
   computePointerWithAlignment(mem, mPisPeak, mNMaxDigitsFragment);
   computePointerWithAlignment(mem, mPchargeMap, TPCMapMemoryLayout<decltype(*mPchargeMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen));
   computePointerWithAlignment(mem, mPpeakMap, TPCMapMemoryLayout<decltype(*mPpeakMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen));
-  computePointerWithAlignment(mem, mPclusterByRow, GPUCA_ROW_COUNT * mNMaxClusterPerRow);
+  computePointerWithAlignment(mem, mPclusterByRow, GPUCA_NROWS * mNMaxClusterPerRow);
   if ((mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding)) {
     computePointerWithAlignment(mem, mPscanBuf, mBufSize * mNBufs);
   }
@@ -166,8 +166,8 @@ void GPUTPCClusterFinder::PrepareMC()
 
   clearMCMemory();
   mPindexMap = new uint32_t[TPCMapMemoryLayout<decltype(*mPindexMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen)];
-  mPlabelsByRow = new GPUTPCClusterMCInterimArray[GPUCA_ROW_COUNT];
-  mPlabelsInRow = new uint32_t[GPUCA_ROW_COUNT];
+  mPlabelsByRow = new GPUTPCClusterMCInterimArray[GPUCA_NROWS];
+  mPlabelsInRow = new uint32_t[GPUCA_NROWS];
 }
 
 void GPUTPCClusterFinder::clearMCMemory()
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
index 242f6963a0b50..404aab04221a7 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
@@ -157,7 +157,7 @@ void GPUTPCClusterFinder::DumpClusters(std::ostream& out)
 {
   out << "\nClusterer - Clusters - Sector " << mISector << " - Fragment " << mPmemory->fragment.index << "\n";
 
-  for (uint32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+  for (uint32_t i = 0; i < GPUCA_NROWS; i++) {
     size_t N = mPclusterInRow[i];
     const tpc::ClusterNative* row = &mPclusterByRow[i * mNMaxClusterPerRow];
 
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDSpacePoint.h b/GPU/GPUTracking/TRDTracking/GPUTRDSpacePoint.h
index c11e60bed26db..33c4adefbd2c4 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDSpacePoint.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDSpacePoint.h
@@ -16,7 +16,7 @@
 #ifndef GPUTRDSPACEPOINT_H
 #define GPUTRDSPACEPOINT_H
 
-#ifndef GPUCA_TPC_GEOMETRY_O2 // compatibility to Run 2 data types
+#ifdef GPUCA_RUN2 // compatibility to Run 2 data types
 
 namespace o2::gpu
 {
@@ -59,6 +59,6 @@ static_assert(sizeof(GPUTRDSpacePoint) == sizeof(o2::trd::CalibratedTracklet), "
 
 } // namespace o2::gpu
 
-#endif // GPUCA_TPC_GEOMETRY_O2
+#endif // GPUCA_RUN2
 
 #endif // GPUTRDSPACEPOINT_H
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.cxx b/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.cxx
index c14f80ed2d8e0..6671fe25109b9 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.cxx
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.cxx
@@ -15,7 +15,7 @@
 #include "GPUTRDTrackletWord.h"
 using namespace o2::gpu;
 
-#ifndef GPUCA_TPC_GEOMETRY_O2
+#ifdef GPUCA_RUN2
 
 GPUd() GPUTRDTrackletWord::GPUTRDTrackletWord(uint32_t trackletWord) : mHCId(-1), mTrackletWord(trackletWord)
 {
@@ -42,4 +42,4 @@ GPUd() int32_t GPUTRDTrackletWord::GetdYbin() const
   }
 }
 
-#endif // !GPUCA_TPC_GEOMETRY_O2
+#endif // GPUCA_RUN2
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.h b/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.h
index cd7dfb9432b93..8d3b8553a460c 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDTrackletWord.h
@@ -19,7 +19,7 @@
 
 #include "GPUDef.h"
 
-#ifndef GPUCA_TPC_GEOMETRY_O2 // compatibility to Run 2 data types
+#ifdef GPUCA_RUN2 // compatibility to Run 2 data types
 
 class AliTRDtrackletWord;
 class AliTRDtrackletMCM;
@@ -105,6 +105,6 @@ static_assert(sizeof(GPUTRDTrackletWord) == sizeof(o2::trd::Tracklet64), "Incorr
 
 } // namespace o2::gpu
 
-#endif // GPUCA_TPC_GEOMETRY_O2
+#endif // !GPUCA_RUN2
 
 #endif // GPUTRDTRACKLETWORD_H
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index e64e2b37945c8..791bd9989c284 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -37,7 +37,7 @@ class GPUdEdx
   GPUd() void fillSubThreshold(int32_t padRow);
   GPUd() void computedEdx(GPUdEdxInfo& output, const GPUParam& param);
 
-  static constexpr size_t MAX_NCL = GPUCA_ROW_COUNT;
+  static constexpr size_t MAX_NCL = GPUCA_NROWS;
 
  private:
   GPUd() float GetSortTruncMean(GPUCA_PAR_DEDX_STORAGE_TYPE_A* array, int32_t count, int32_t trunclow, int32_t trunchigh);
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
index 0d9a6f052d617..69cfdaca55379 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
@@ -44,11 +44,10 @@ QGET_LD_BINARY_SYMBOLS(shaders_shaders_fragmentUniform_frag_spv);
 #define GPUCA_BUILD_EVENT_DISPLAY_OPENGL
 #if !defined(GL_VERSION_4_5) || GL_VERSION_4_5 != 1
 #ifdef GPUCA_STANDALONE
-// #error Unsupported OpenGL version < 4.5
-#elif defined(GPUCA_O2_LIB)
-#pragma message "Unsupported OpenGL version < 4.5, disabling standalone event display"
-#else
 #warning Unsupported OpenGL version < 4.5, disabling standalone event display
+#error Unsupported OpenGL version < 4.5
+#else
+#pragma message "Unsupported OpenGL version < 4.5, disabling standalone event display"
 #endif
 #undef GPUCA_BUILD_EVENT_DISPLAY_OPENGL
 #endif
diff --git a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
index e18ecfb6f083e..232a9065355a6 100644
--- a/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
+++ b/GPU/GPUTracking/display/frontend/GPUDisplayFrontendGlfw.cxx
@@ -17,10 +17,6 @@
 #include "GPUDisplayGUIWrapper.h"
 #include "GPULogging.h"
 
-#if defined(GPUCA_O2_LIB) && !defined(GPUCA_DISPLAY_GL3W) // Hack: we have to define this in order to initialize gl3w, cannot include the header as it clashes with glew
-extern "C" int32_t gl3wInit();
-#endif
-
 #ifdef GPUCA_BUILD_EVENT_DISPLAY_VULKAN
 #define GLFW_INCLUDE_VULKAN
 #endif
@@ -30,7 +26,7 @@ extern "C" int32_t gl3wInit();
 #include <cstring>
 #include <unistd.h>
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 #include <DebugGUI/imgui.h>
 #include <DebugGUI/DebugGUI.h>
 #endif
@@ -233,7 +229,7 @@ void GPUDisplayFrontendGlfw::cursorPos_callback(GLFWwindow* window, double x, do
 
 void GPUDisplayFrontendGlfw::resize_callback(GLFWwindow* window, int32_t width, int32_t height) { me->ResizeScene(width, height); }
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 void GPUDisplayFrontendGlfw::DisplayLoop()
 {
   ImGui::SetNextWindowPos(ImVec2(0, 0));
@@ -336,16 +332,6 @@ void GPUDisplayFrontendGlfw::DisplayExit()
 
 void GPUDisplayFrontendGlfw::OpenGLPrint(const char* s, float x, float y, float r, float g, float b, float a, bool fromBotton)
 {
-#ifdef GPUCA_O2_LIB
-  if (mUseIMGui) {
-    if (fromBotton) {
-      y = ImGui::GetWindowHeight() - y;
-    }
-    y -= 20;
-    ImGui::SetCursorPos(ImVec2(x, y));
-    ImGui::TextColored(ImVec4(r, g, b, a), "%s", s);
-  }
-#endif
 }
 
 void GPUDisplayFrontendGlfw::SwitchFullscreen(bool set)
@@ -375,10 +361,10 @@ void GPUDisplayFrontendGlfw::SetVSync(bool enable) { glfwSwapInterval(enable); }
 
 bool GPUDisplayFrontendGlfw::EnableSendKey()
 {
-#ifdef GPUCA_O2_LIB
-  return false;
-#else
+#ifdef GPUCA_STANDALONE
   return true;
+#else
+  return false;
 #endif
 }
 
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayBackendOpenGLMagneticField.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayBackendOpenGLMagneticField.cxx
index ef94628baeb38..4472fcd087708 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayBackendOpenGLMagneticField.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayBackendOpenGLMagneticField.cxx
@@ -38,13 +38,6 @@ using namespace o2::gpu;
 // Runtime minimum version defined in GPUDisplayFrontend.h, keep in sync!
 #define GPUCA_BUILD_EVENT_DISPLAY_OPENGL
 #if !defined(GL_VERSION_4_5) || GL_VERSION_4_5 != 1
-#ifdef GPUCA_STANDALONE
-// #error Unsupported OpenGL version < 4.5
-#elif defined(GPUCA_O2_LIB)
-#pragma message "Unsupported OpenGL version < 4.5, disabling standalone event display"
-#else
-#warning Unsupported OpenGL version < 4.5, disabling standalone event display
-#endif
 #undef GPUCA_BUILD_EVENT_DISPLAY_OPENGL
 #endif
 
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayMagneticField.cxx b/GPU/GPUTracking/display/helpers/GPUDisplayMagneticField.cxx
index 7e23e6694d377..adfbc62ec47e1 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayMagneticField.cxx
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayMagneticField.cxx
@@ -22,7 +22,7 @@
 #ifndef GPUCA_NO_ROOT
 #include <TGeoGlobalMagField.h>
 #endif
-#if !defined(GPUCA_NO_ROOT) && defined(GPUCA_O2_LIB)
+#if !defined(GPUCA_NO_ROOT) && !defined(GPUCA_STANDALONE)
 #include "DetectorsBase/GeometryManager.h"
 #include "DataFormatsParameters/GRPObject.h"
 #include "DetectorsBase/Propagator.h"
@@ -35,7 +35,7 @@ GPUDisplayMagneticField::GPUDisplayMagneticField()
   initializeUniforms();
 }
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 GPUDisplayMagneticField::GPUDisplayMagneticField(o2::field::MagneticField* field)
 {
   initializeUniformsFromField(field);
@@ -130,7 +130,7 @@ std::tuple<std::size_t, std::size_t, std::size_t, std::size_t> loadParams(std::i
   return std::make_tuple(NParams, NRows, NColumns, NCoefficients);
 }
 
-#ifndef GPUCA_O2_LIB
+#ifdef GPUCA_STANDALONE
 int32_t GPUDisplayMagneticField::initializeUniforms()
 {
   mSolenoidSegments = std::make_unique<SolenoidSegmentsUniform>();
@@ -174,9 +174,7 @@ int32_t GPUDisplayMagneticField::initializeUniforms()
 
   return 0;
 }
-#endif
-
-#if !defined(GPUCA_NO_ROOT) && defined(GPUCA_O2_LIB)
+#else
 int32_t GPUDisplayMagneticField::initializeUniforms()
 {
   mRenderConstantsUniform = std::make_unique<RenderConstantsUniform>();
diff --git a/GPU/GPUTracking/display/helpers/GPUDisplayMagneticField.h b/GPU/GPUTracking/display/helpers/GPUDisplayMagneticField.h
index d4eb5b571fdc0..72ac83280d29c 100644
--- a/GPU/GPUTracking/display/helpers/GPUDisplayMagneticField.h
+++ b/GPU/GPUTracking/display/helpers/GPUDisplayMagneticField.h
@@ -19,7 +19,7 @@
 #include <memory>
 #include <vector>
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 #include <Field/MagneticField.h>
 #endif
 
@@ -29,7 +29,7 @@ class GPUDisplayMagneticField
 {
  public:
   GPUDisplayMagneticField();
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
   GPUDisplayMagneticField(o2::field::MagneticField* field);
 #endif
 
@@ -111,7 +111,7 @@ class GPUDisplayMagneticField
   };
 
   int32_t initializeUniforms();
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
   int32_t initializeUniformsFromField(o2::field::MagneticField* field);
 #endif
   void generateSeedPoints(std::size_t count);
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 415d54e742b65..16f9939d6257a 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -138,7 +138,7 @@ void GPUDisplay::DrawClusters(int32_t iSector)
   [[maybe_unused]] const bool checkClusterCollision = mQA && mNCollissions && mOverlayTFClusters.size() == 0 && mIOPtrs->clustersNative && mIOPtrs->clustersNative->clustersMCTruth;
   for (int32_t cidInSector = 0; cidInSector < nClustersInSector; cidInSector++) {
     const int32_t cid = GET_CID(iSector, cidInSector);
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
     if (checkClusterCollision) {
       const auto& labels = mIOPtrs->clustersNative->clustersMCTruth->getLabels(cid);
       col = labels.size() ? mQA->GetMCLabelCol(labels[0]) : 0;
@@ -212,10 +212,10 @@ GPUDisplay::vboList GPUDisplay::DrawLinks(const GPUTPCTracker& tracker, int32_t
   }
   size_t startCount = mVertexBufferStart[iSector].size();
   size_t startCountInner = mVertexBuffer[iSector].size();
-  for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
     const GPUTPCRow& row = tracker.Data().Row(i);
 
-    if (i < GPUCA_ROW_COUNT - 2) {
+    if (i < GPUCA_NROWS - 2) {
       const GPUTPCRow& rowUp = tracker.Data().Row(i + 2);
       for (int32_t j = 0; j < row.NHits(); j++) {
         if (tracker.Data().HitLinkUpData(row, j) != CALINK_INVAL) {
@@ -590,7 +590,7 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
           float charge = mc.charge > 0 ? 1.f : -1.f;
 
           x = mclocal[0];
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
           trkParam.Set(mclocal[0], mclocal[1], mc.z, mclocal[2], mclocal[3], mc.pZ, -charge); // TODO: DR: unclear to me why we need -charge here
           if (mParam->par.continuousTracking) {
             ZOffset = fabsf(mCalib->fastTransform->convVertexTimeToZOffset(0, mc.t0, mParam->continuousMaxTimeBin)) * (mc.z < 0 ? -1 : 1);
@@ -677,7 +677,7 @@ GPUDisplay::vboList GPUDisplay::DrawGrid(const GPUTPCTracker& tracker)
   int32_t iSector = tracker.ISector();
   size_t startCount = mVertexBufferStart[iSector].size();
   size_t startCountInner = mVertexBuffer[iSector].size();
-  for (int32_t i = 0; i < GPUCA_ROW_COUNT; i++) {
+  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
     const GPUTPCRow& row = tracker.Data().Row(i);
     for (int32_t j = 0; j <= (signed)row.Grid().Ny(); j++) {
       float z1 = row.Grid().ZMin();
@@ -863,7 +863,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
       } // clang-format off
     }, tbb::simple_partitioner()); // clang-format on
     if (mConfig.showTPCTracksFromO2Format) {
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
       uint32_t col = 0;
       tbb::parallel_for<uint32_t>(0, mIOPtrs->nOutputTracksTPCO2, [&](auto i) {
         uint8_t sector, row;
@@ -891,7 +891,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
         uint32_t col = 0;
         if (mQA) {
           const auto& label = mQA->GetMCTrackLabel(i);
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
           col = mQA->GetMCLabelCol(label);
 #else
           while (label.isValid() && col < mOverlayTFClusters.size() && mOverlayTFClusters[col][NSECTORS] < label.track) {
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index db340389452dc..b5bd275d4499b 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -30,7 +30,7 @@
 #include "DataFormatsTPC/TrackTPC.h"
 #include "TOFBase/Geo.h"
 #include "ITSBase/GeometryTGeo.h"
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 #include "DataFormatsITSMFT/DPLAlpideParam.h"
 #endif
 
@@ -142,7 +142,7 @@ void GPUDisplay::DrawGLScene_updateEventData()
       for (uint32_t i = 0; i < nCls; i++) {
         int32_t cid;
         cid = mIOPtrs->clustersNative->clusterOffset[iSector][0] + i;
-        while (row < GPUCA_ROW_COUNT - 1 && mIOPtrs->clustersNative->clusterOffset[iSector][row + 1] <= (uint32_t)cid) {
+        while (row < GPUCA_NROWS - 1 && mIOPtrs->clustersNative->clusterOffset[iSector][row + 1] <= (uint32_t)cid) {
           row++;
         }
         if (cid >= mNMaxClusters) {
@@ -237,7 +237,7 @@ void GPUDisplay::DrawGLScene_updateEventData()
 
   if (mCurrentClustersITS) {
     float itsROFhalfLen = 0;
-#ifdef GPUCA_O2_LIB // Not available in standalone benchmark
+#ifndef GPUCA_STANDALONE // Not available in standalone benchmark
     if (mParam->par.continuousTracking) {
       const auto& alpParams = o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>::Instance();
       itsROFhalfLen = alpParams.roFrameLengthInBC / (float)o2::tpc::constants::LHCBCPERTIMEBIN / 2;
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 143a6f94d17a6..7a3803401980f 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -55,7 +55,7 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "GPUSettings.h"
 #include "GPUDefMacros.h"
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
 #include "DetectorsRaw/HBFUtils.h"
 #include "DataFormatsTPC/TrackTPC.h"
 #include "DataFormatsTPC/Constants.h"
@@ -204,7 +204,7 @@ int32_t GPUQA::initColors()
 static constexpr Color_t defaultColorNums[COLORCOUNT] = {kRed, kBlue, kGreen, kMagenta, kOrange, kAzure, kBlack, kYellow, kGray, kTeal, kSpring, kPink};
 
 #define TRACK_EXPECTED_REFERENCE_X_DEFAULT 81
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
 static inline int32_t GPUQA_O2_ConvertFakeLabel(int32_t label) { return label >= 0x7FFFFFFE ? -1 : label; }
 inline uint32_t GPUQA::GetNMCCollissions() const { return mMCInfosCol.size(); }
 inline uint32_t GPUQA::GetNMCTracks(int32_t iCol) const { return mMCInfosCol[iCol].num; }
@@ -526,10 +526,10 @@ int32_t GPUQA::InitQACreateHistograms()
       createHist(mClusters[i], name, name, AXIS_BINS[4], binsPt.get());
     }
 
-    createHist(mPadRow[0], "padrow0", "padrow0", GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS, GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS);
-    createHist(mPadRow[1], "padrow1", "padrow1", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS);
-    createHist(mPadRow[2], "padrow2", "padrow2", 100.f, -0.2f, 0.2f, GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS);
-    createHist(mPadRow[3], "padrow3", "padrow3", 100.f, 0, 300000, GPUCA_ROW_COUNT - PADROW_CHECK_MINCLS, 0, GPUCA_ROW_COUNT - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[0], "padrow0", "padrow0", GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS, GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[1], "padrow1", "padrow1", 100.f, -0.2f, 0.2f, GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[2], "padrow2", "padrow2", 100.f, -0.2f, 0.2f, GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[3], "padrow3", "padrow3", 100.f, 0, 300000, GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS);
   }
 
   if (mQATasks & taskTrackStatistics) {
@@ -546,12 +546,12 @@ int32_t GPUQA::InitQACreateHistograms()
     createHist(mClXY, "clXY", "clXY", 1000, -250, 250, 1000, -250, 250); // TODO: Pass name only once
   }
   if (mQATasks & taskClusterRejection) {
-    const int padCount = GPUTPCGeometry::NPads(GPUCA_ROW_COUNT - 1);
+    const int padCount = GPUTPCGeometry::NPads(GPUCA_NROWS - 1);
     for (int32_t i = 0; i < 3; i++) {
       snprintf(name, 2048, "clrej_%d", i);
-      createHist(mClRej[i], name, name, 2 * padCount, -padCount / 2 + 0.5f, padCount / 2 - 0.5f, GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
+      createHist(mClRej[i], name, name, 2 * padCount, -padCount / 2 + 0.5f, padCount / 2 - 0.5f, GPUCA_NROWS, 0, GPUCA_NROWS - 1);
     }
-    createHist(mClRejP, "clrejp", "clrejp", GPUCA_ROW_COUNT, 0, GPUCA_ROW_COUNT - 1);
+    createHist(mClRejP, "clrejp", "clrejp", GPUCA_NROWS, 0, GPUCA_NROWS - 1);
   }
 
   if ((mQATasks & taskClusterCounts) && mConfig.clusterRejectionHistograms) {
@@ -677,7 +677,7 @@ void GPUQA::CopyO2MCtoIOPtr(GPUTrackingInOutPointers* ptr)
 
 void GPUQA::InitO2MCData(GPUTrackingInOutPointers* updateIOPtr)
 {
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
   if (!mO2MCDataLoaded) {
     HighResTimer timer(mTracking && mTracking->GetProcessingSettings().debugLevel);
     if (mTracking && mTracking->GetProcessingSettings().debugLevel) {
@@ -836,7 +836,7 @@ int32_t GPUQA::InitQA(int32_t tasks)
     mkdir(mConfig.plotsDir.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
   }
 
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
   if (!mConfig.noMC) {
     InitO2MCData(mTracking ? &mTracking->mIOPtrs : nullptr);
   }
@@ -896,7 +896,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
   }
   mClNative = clNative;
 
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   uint32_t nSimEvents = GetNMCCollissions();
   if (mTrackMCLabelsReverse.size() < nSimEvents) {
     mTrackMCLabelsReverse.resize(nSimEvents);
@@ -915,7 +915,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
   // Initialize Arrays
   uint32_t nReconstructedTracks = 0;
   if (tracksExternal) {
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
     nReconstructedTracks = tracksExternal->size();
 #endif
   } else {
@@ -951,7 +951,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
 
   if (mcAvail) { // Assign Track MC Labels
     if (tracksExternal) {
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
       for (uint32_t i = 0; i < tracksExternal->size(); i++) {
         mTrackMCLabels[i] = (*tracksExtMC)[i];
       }
@@ -1050,7 +1050,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         if (mMCTrackMin == -1 || (label.getTrackID() >= mMCTrackMin && label.getTrackID() < mMCTrackMax)) {
           int32_t& revLabel = GetMCTrackObj(mTrackMCLabelsReverse, label);
           if (tracksExternal) {
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
             if (revLabel == -1 || fabsf((*tracksExternal)[i].getZ()) < fabsf((*tracksExternal)[revLabel].getZ())) {
               revLabel = i;
             }
@@ -1102,7 +1102,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       if (mTracking->mIOPtrs.nMergedTracks && clNative) {
         std::fill(lowestPadRow.begin(), lowestPadRow.end(), 255);
         for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-          for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+          for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
             for (uint32_t iCl = 0; iCl < clNative->nClusters[iSector][iRow]; iCl++) {
               int32_t i = clNative->clusterOffset[iSector][iRow] + iCl;
               for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
@@ -1392,7 +1392,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         float alpha = 0.f;
         int32_t side;
         if (tracksExternal) {
-#ifdef GPUCA_O2_LIB
+#ifndef GPUCA_STANDALONE
           for (int32_t k = 0; k < 5; k++) {
             param.Par()[k] = (*tracksExternal)[i].getParams()[k];
           }
@@ -1793,7 +1793,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     }
     if (mClNative && mTracking && mTracking->GetTPCTransform()) {
       for (uint32_t i = 0; i < GPUChainTracking::NSECTORS; i++) {
-        for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+        for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
           for (uint32_t k = 0; k < mClNative->nClusters[i][j]; k++) {
             const auto& cl = mClNative->clusters[i][j][k];
             float x, y, z;
@@ -1826,7 +1826,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
   mClusterCounts.nTotal += nCl;
   if (mQATasks & (taskClusterCounts | taskClusterRejection)) {
     for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-      for (uint32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+      for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
         for (uint32_t iCl = 0; iCl < clNative->nClusters[iSector][iRow]; iCl++) {
           uint32_t i = clNative->clusterOffset[iSector][iRow] + iCl;
           int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
@@ -1917,7 +1917,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     }
     uint32_t clid = 0;
     for (uint32_t i = 0; i < GPUChainTracking::NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_ROW_COUNT; j++) {
+      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
         for (uint32_t k = 0; k < mClNative->nClusters[i][j]; k++) {
           const auto& cl = mClNative->clusters[i][j][k];
           uint32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[clid];
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index bd3c9be3a9aa5..172a768729803 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -68,7 +68,7 @@ class GPUQA
 #include <cmath>
 #include <vector>
 #include <memory>
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
 #include <gsl/span>
 #endif
 
@@ -102,7 +102,7 @@ class GPUQA
   GPUQA(GPUChainTracking* chain, const GPUSettingsQA* config = nullptr, const GPUParam* param = nullptr);
   ~GPUQA();
 
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   using mcLabels_t = gsl::span<const o2::MCCompLabel>;
   using mcLabel_t = o2::MCCompLabel;
   using mcLabelI_t = mcLabel_t;
@@ -176,7 +176,7 @@ class GPUQA
   T* GetHist(T*& ee, std::vector<std::unique_ptr<TFile>>& tin, int32_t k, int32_t nNewInput);
 
   using mcInfo_t = GPUTPCMCInfo;
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   mcLabels_t GetMCLabel(uint32_t i);
   mcLabel_t GetMCLabel(uint32_t i, uint32_t j);
 #else
@@ -234,7 +234,7 @@ class GPUQA
   //-------------------------
 
   std::vector<mcLabelI_t> mTrackMCLabels;
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   std::vector<std::vector<int32_t>> mTrackMCLabelsReverse;
   std::vector<std::vector<int32_t>> mRecTracks;
   std::vector<std::vector<int32_t>> mFakeTracks;
diff --git a/GPU/GPUTracking/qa/GPUQAHelper.h b/GPU/GPUTracking/qa/GPUQAHelper.h
index e9d98f3e4e305..dcbe7a94711aa 100644
--- a/GPU/GPUTracking/qa/GPUQAHelper.h
+++ b/GPU/GPUTracking/qa/GPUQAHelper.h
@@ -128,7 +128,7 @@ struct GPUTPCTrkLbl_ret {
   GPUTPCTrkLbl_ret() = default;
   template <class T>
   GPUTPCTrkLbl_ret(T){};
-#ifdef GPUCA_TPC_GEOMETRY_O2
+#ifndef GPUCA_RUN2
   GPUTPCTrkLbl_ret(const MCCompLabel& a) : id(a.getTrackEventSourceID()) {};
 #endif
 #ifdef GPUCA_STANDALONE
diff --git a/GPU/GPUTracking/qa/genEvents.cxx b/GPU/GPUTracking/qa/genEvents.cxx
index 6832e48fe17da..49b4c2ca6b12b 100644
--- a/GPU/GPUTracking/qa/genEvents.cxx
+++ b/GPU/GPUTracking/qa/genEvents.cxx
@@ -219,7 +219,7 @@ int32_t genEvents::GenerateEvent(const GPUParam& param, const char* filename)
       // exit(0);
     }
 
-    for (int32_t iRow = 0; iRow < GPUCA_ROW_COUNT; iRow++) {
+    for (int32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
       // if( iRow>=50 ) break; //SG!!!
       float xRow = GPUTPCGeometry::Row2X(iRow);
       // transport to row
diff --git a/GPU/GPUTracking/utils/qlibload.h b/GPU/GPUTracking/utils/qlibload.h
index a0dfca8ef3f1e..248557aa7767f 100644
--- a/GPU/GPUTracking/utils/qlibload.h
+++ b/GPU/GPUTracking/utils/qlibload.h
@@ -29,7 +29,7 @@
 #define LIBRARY_FUNCTION dlsym
 #endif
 
-#if defined(GPUCA_O2_LIB)
+#if !defined(GPUCA_STANDALONE)
 #define LIBRARY_PREFIX "O2"
 #else
 #define LIBRARY_PREFIX ""
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 068c85b13836a..d6cadc0b7428f 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -117,7 +117,7 @@ class TPCFastTransform : public FlatObject
   }
 
 /// Destructor
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) && defined(GPUCA_O2_LIB)
+#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
   ~TPCFastTransform()
   {
     delete mCorrectionSlow;

From 16b2d26219f1be02a3d84f83eb869c94c8dab23c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 8 Apr 2026 10:24:48 +0200
Subject: [PATCH 1595/1764] GPU: Remove obsolete file

---
 ...andalone-cluster-dump-entropy-analysed.cxx | 709 ------------------
 1 file changed, 709 deletions(-)
 delete mode 100644 GPU/GPUTracking/DataCompression/standalone-cluster-dump-entropy-analysed.cxx

diff --git a/GPU/GPUTracking/DataCompression/standalone-cluster-dump-entropy-analysed.cxx b/GPU/GPUTracking/DataCompression/standalone-cluster-dump-entropy-analysed.cxx
deleted file mode 100644
index b23d19c3c9cd4..0000000000000
--- a/GPU/GPUTracking/DataCompression/standalone-cluster-dump-entropy-analysed.cxx
+++ /dev/null
@@ -1,709 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file standalone-cluster-dump-entropy-analysed.cxx
-/// \author David Rohr
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <memory.h>
-#include <math.h>
-#include <queue>
-#include <map>
-#include <iterator>
-#include <algorithm>
-#include <iostream>
-
-const int32_t sort_method = 1; // 0 No sorting, 1 sort after pad, 2 sort after time, 3/4 mixed methods favoring pad / time
-const int32_t sector_diff = 1;
-const int32_t row_diff = 1;
-const int32_t pad_diff = 1;
-const int32_t time_diff = 1;
-const int32_t res_diff = 0;
-const int32_t approximate_qtot = 0;
-const int32_t combine_maxtot = 1;
-const int32_t combine_sigmapadtime = 1;
-const int32_t track_based = 1;
-const int32_t track_avgtot = track_based && 0;
-const int32_t track_avgmax = track_based && 0;
-const int32_t track_diffqtot = track_based && 0;
-const int32_t track_diffqmax = track_based && 0;
-const int32_t track_separate_q = track_based && 1;
-const int32_t track_diffsigma = track_based && 0;
-const int32_t track_separate_sigma = track_based && 1;
-const int32_t truncate_bits = 1;
-const int32_t separate_sectors = 0;
-const int32_t separate_patches = 0;
-const int32_t separate_sides = 0;
-const int32_t full_row_numbers = 1;
-const int32_t distinguish_rows = 0;
-const int32_t optimized_negative_values = 1;
-
-const int32_t print_clusters = 0;
-
-const char* file = "clusters-pbpb.dump";
-const int32_t max_clusters = 2000000;
-
-const int32_t truncate_sigma = 3;
-const int32_t truncate_charge = 4;
-
-const int32_t sort_pad_mixed_bins = 100;
-const int32_t sort_time_mixed_bins = 400;
-
-#define EVENT 0
-#define SECTOR 1
-#define PATCH 2
-#define ROW 3
-#define PAD 4
-#define TIME 5
-#define SIGMA_PAD 6
-#define SIGMA_TIME 7
-#define QMAX 8
-#define QTOT 9
-#define FLAG_PADTIME 10
-#define CLUSTER_ID 11
-#define RES_PAD 12
-#define RES_TIME 13
-#define AVG_TOT 14
-#define AVG_MAX 15
-#define QMAX_QTOT 16
-#define SIGMA_PAD_TIME 17
-#define DIFF_SIGMA_PAD 18
-#define DIFF_SIGMA_TIME 19
-#define DIFF_SIGMA_PAD_TIME 20
-#define AVG_TOT_MAX 21
-#define ROW_TRACK_FIRST 22
-#define ROW_TRACK 23
-
-#define PAD_80 24
-#define PAD_92 25
-#define PAD_104 26
-#define PAD_116 27
-#define PAD_128 28
-#define PAD_140 29
-
-const int32_t rr = optimized_negative_values && 0 ? 13 : 14; // We can make them all 14 for convenience, the encoding will handle it
-
-const uint32_t field_bits[] = {0, 6, 0, 8, 14, 15, 8, 8, 10, 16, 2, 0, 14, 15, 16, 10, 26, 16, 8, 8, 16, 26, 8, 8, rr, rr, rr, rr, rr, 14};
-const uint32_t significant_bits[] = {0, 6, 0, 8, 14, 15, truncate_sigma, truncate_sigma, truncate_charge, truncate_charge, 2, 0, 14, 15, truncate_charge, truncate_charge, 26, 16, truncate_sigma, truncate_sigma, 16, 26, 8, 8, rr, rr, rr, rr, rr, 14};
-const int32_t nFields = sizeof(field_bits) / sizeof(field_bits[0]);
-const char* field_names[] = {"event", "sector", "patch", "row", "pad", "time", "sigmaPad", "sigmaTime", "qmax", "qtot", "flagPadTime", "trackID", "resTrackPad",
-                             "resTrackTime", "trackQTot", "trackQMax", "qmaxtot", "sigmapadtime", "diffsigmapad", "diffsigmatime", "diffsigmapadtime", "tracktotmax", "trackfirstrow", "trackrow", "pad_80", "pad_92",
-                             "pad_104", "pad_116", "pad_128", "pad_140"};
-
-union cluster_struct {
-  struct
-  {
-    uint32_t event, sector, patch, row, pad, time, sigmaPad, sigmaTime, qmax, qtot, splitPadTime;
-    int32_t trackID;
-    uint32_t resPad, resTime, avgtot, avgmax;
-  };
-  uint32_t vals[16];
-};
-
-int32_t fgRows[6][2] = {{0, 30}, {30, 62}, {63, 90}, {90, 116}, {117, 139}, {139, 158}};
-int32_t fgNRows[6] = {31, 33, 28, 27, 23, 20};
-
-int32_t fgNPads[159] = {68, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 102,
-                        102, 102, 104, 104, 104, 106, 106, 106, 108, 108, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100,
-                        100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108, 108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
-
-int32_t fgNPadsMod[159] = {80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
-                           104, 104, 104, 104, 104, 116, 116, 116, 116, 116, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 92, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104,
-                           104, 104, 104, 104, 104, 104, 104, 104, 104, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 128, 128, 128, 128, 128, 128, 128, 128, 128, 126, 126, 128, 128, 140, 140, 140, 140, 140, 134, 134, 140, 140, 140, 140, 140, 140};
-
-// ---------------------------------- HUFFMAN TREE
-
-typedef std::vector<bool> HuffCode;
-typedef std::map<uint32_t, HuffCode> HuffCodeMap;
-
-class INode
-{
- public:
-  const double f;
-
-  virtual ~INode() {}
-
- protected:
-  INode(double f) : f(f) {}
-};
-
-class InternalNode : public INode
-{
- public:
-  INode* const left;
-  INode* const right;
-
-  InternalNode(INode* c0, INode* c1) : INode(c0->f + c1->f), left(c0), right(c1) {}
-  ~InternalNode()
-  {
-    delete left;
-    delete right;
-  }
-};
-
-class LeafNode : public INode
-{
- public:
-  const uint32_t c;
-
-  LeafNode(double f, uint32_t c) : INode(f), c(c) {}
-};
-
-struct NodeCmp {
-  bool operator()(const INode* lhs, const INode* rhs) const { return lhs->f > rhs->f; }
-};
-
-INode* BuildTree(const double* frequencies, uint32_t UniqueSymbols)
-{
-  std::priority_queue<INode*, std::vector<INode*>, NodeCmp> trees;
-
-  for (int32_t i = 0; i < UniqueSymbols; i++) {
-    if (frequencies[i] != 0) {
-      trees.push(new LeafNode(frequencies[i], i));
-    }
-  }
-  while (trees.size() > 1) {
-    INode* childR = trees.top();
-    trees.pop();
-
-    INode* childL = trees.top();
-    trees.pop();
-
-    INode* parent = new InternalNode(childR, childL);
-    trees.push(parent);
-  }
-  return trees.top();
-}
-
-void GenerateCodes(const INode* node, const HuffCode& prefix, HuffCodeMap& outCodes)
-{
-  if (const LeafNode* lf = dynamic_cast<const LeafNode*>(node)) {
-    outCodes[lf->c] = prefix;
-  } else if (const InternalNode* in = dynamic_cast<const InternalNode*>(node)) {
-    HuffCode leftPrefix = prefix;
-    leftPrefix.push_back(false);
-    GenerateCodes(in->left, leftPrefix, outCodes);
-
-    HuffCode rightPrefix = prefix;
-    rightPrefix.push_back(true);
-    GenerateCodes(in->right, rightPrefix, outCodes);
-  }
-}
-
-//--------------------------------------------- END HUFFMAN
-
-bool clustercompare_padtime(cluster_struct a, cluster_struct b) { return (a.pad < b.pad || (a.pad == b.pad && a.time < b.time)); }
-
-bool clustercompare_timepad(cluster_struct a, cluster_struct b) { return (a.time < b.time || (a.time == b.time && a.pad < b.pad)); }
-
-bool clustercompare_padtime_mixed(cluster_struct a, cluster_struct b) { return (a.pad / sort_pad_mixed_bins < b.pad / sort_pad_mixed_bins || (a.pad / sort_pad_mixed_bins == b.pad / sort_pad_mixed_bins && a.time < b.time)); }
-
-bool clustercompare_timepad_mixed(cluster_struct a, cluster_struct b) { return (a.time / sort_time_mixed_bins < b.time / sort_time_mixed_bins || (a.time / sort_time_mixed_bins == b.time / sort_time_mixed_bins && a.pad < b.pad)); }
-
-bool clustercompare_inevent(cluster_struct a, cluster_struct b) { return (a.sector < b.sector || (a.sector == b.sector && a.patch < b.patch) || (a.sector == b.sector && a.patch == b.patch && a.row < b.row)); }
-
-void do_diff(uint32_t& val, int32_t& last, uint32_t bits, uint32_t maxval = 0)
-{
-  int32_t tmp = val;
-  val -= last;
-  if (maxval && optimized_negative_values) {
-    while ((signed)val < 0) {
-      val += maxval;
-    }
-  } else {
-    val &= (1 << bits) - 1;
-  }
-  last = tmp;
-}
-
-uint32_t truncate(int32_t j, uint32_t val)
-{
-  if (truncate_bits && field_bits[j] != significant_bits[j] && val) {
-    int32_t ldz = sizeof(uint32_t) * 8 - __builtin_clz(val);
-    if (ldz > significant_bits[j]) {
-      val &= ((1 << ldz) - 1) ^ ((1 << (ldz - significant_bits[j])) - 1);
-    }
-  }
-  return (val);
-}
-
-int32_t main(int argc, char** argv)
-{
-  FILE* fp;
-
-  if (truncate_bits && (track_avgmax || track_diffqmax || track_diffqtot)) {
-    printf("Cannot use truncate bits with differential qmax / qtot");
-    return (1);
-  }
-  if (truncate_bits && (track_diffsigma)) {
-    printf("Cannot use truncate bits with differential sigma");
-    return (1);
-  }
-
-  if (!(fp = fopen(file, "rb"))) {
-    printf("Error opening file\n");
-    return (1);
-  }
-
-  fseek(fp, 0, SEEK_END);
-  size_t nFileSize = ftell(fp);
-  fseek(fp, 0, SEEK_SET);
-
-  size_t nClusters = nFileSize / sizeof(cluster_struct);
-  if (max_clusters && nClusters > max_clusters) {
-    nClusters = max_clusters;
-  }
-
-  cluster_struct* clusters = new cluster_struct[nClusters];
-  if (clusters == NULL) {
-    printf("Memory allocation error\n");
-    return (1);
-  }
-
-  fprintf(stderr, "Reading %d clusters...", (int32_t)nClusters);
-  fread(clusters, sizeof(cluster_struct), nClusters, fp);
-
-  fprintf(stderr, "Done\nSorting clusters...");
-
-  if (sort_method) {
-    int32_t starti = 0;
-    if (!track_based) {
-      fprintf(stderr, " (removing track ordering)...");
-      int32_t last_event = 0;
-      for (int32_t i = 0; i <= nClusters; i++) {
-        int32_t event = (i == nClusters ? -1 : clusters[i].event);
-        if (last_event != event) {
-          if (i - 1 > starti) {
-            std::sort(clusters + starti, clusters + i - 1, clustercompare_inevent);
-          }
-          starti = i;
-        }
-        last_event = event;
-      }
-    }
-
-    starti = 0;
-    int32_t startrow = -1;
-    for (int32_t i = 0; i <= nClusters; i++) {
-      int32_t currow;
-      if (i == nClusters) {
-        currow = -1;
-      } else if (track_based && clusters[i].trackID != -1) {
-        currow = -2;
-      } else {
-        currow = clusters[i].row;
-      }
-      if (currow != startrow && startrow != -2) {
-        if (i - 1 > starti) {
-          if (sort_method == 1) {
-            std::sort(clusters + starti, clusters + i - 1, clustercompare_padtime);
-          } else if (sort_method == 2) {
-            std::sort(clusters + starti, clusters + i - 1, clustercompare_timepad);
-          } else if (sort_method == 3) {
-            std::sort(clusters + starti, clusters + i - 1, clustercompare_padtime_mixed);
-          } else if (sort_method == 4) {
-            std::sort(clusters + starti, clusters + i - 1, clustercompare_timepad_mixed);
-          }
-        }
-        starti = i;
-        startrow = currow;
-      }
-    }
-  }
-  fprintf(stderr, "Done\n");
-
-  fclose(fp);
-
-  int64_t* histograms[nFields];
-  double* probabilities[nFields];
-  int64_t counts[nFields];
-  int32_t used[nFields];
-  for (int32_t i = SECTOR; i < nFields; i++) {
-    if (i == CLUSTER_ID) {
-      continue;
-    }
-    histograms[i] = new int64_t[1 << field_bits[i]];
-    probabilities[i] = new double[1 << field_bits[i]];
-  }
-
-  double rawtotalbytes = 0;
-  double entrototalbytes = 0;
-  for (int32_t isector = 0; isector < 36; isector++) {
-    for (int32_t ipatch = 0; ipatch < 6; ipatch++) {
-      if (separate_sectors) {
-        printf("SECTOR %d ", isector);
-      }
-      if (separate_patches) {
-        printf("PATCH %d", ipatch);
-      }
-      if (separate_sectors || separate_patches) {
-        printf("\n");
-      }
-      for (int32_t i = SECTOR; i < nFields; i++) {
-        if (i == CLUSTER_ID || i == PATCH) {
-          continue;
-        }
-        memset(histograms[i], 0, sizeof(int64_t) * (1 << field_bits[i]));
-        counts[i] = 0;
-        used[i] = 0;
-      }
-
-      size_t nClustersUsed = 0;
-
-      int32_t lastRow = 0, lastPad = 0, lastTime = 0, lastSector = 0, lastResPad = 0, lastResTime = 0, lastQTot = 0, lastQMax = 0, lastSigmaPad = 0, lastSigmaTime = 0, lastTrack = -1, lastEvent = 0;
-
-      for (size_t i = 0; i < nClusters; i++) {
-        const cluster_struct& cluster_org = clusters[i];
-        cluster_struct cluster = clusters[i];
-        if (cluster.pad >= 32768) {
-          printf("%d\n", cluster.pad);
-        }
-
-        if ((separate_sectors && cluster.sector != isector) || (separate_patches && cluster.patch != ipatch)) {
-          continue;
-        }
-        if (separate_sides && !(cluster.sector < 18 ^ isector < 18)) {
-          continue;
-        }
-
-        bool newTrack = lastTrack != cluster.trackID;
-        uint32_t dSigmaPad, dSigmaTime;
-
-        if (cluster.event != lastEvent) {
-          lastRow = lastPad = lastTime = lastSector = 0;
-          lastTrack = -1;
-        }
-
-        if (full_row_numbers) {
-          cluster.row += fgRows[cluster.patch][0];
-        }
-
-        if ((sector_diff || res_diff || track_diffqtot || track_diffqmax) && cluster.trackID != -1 && track_based) {
-          if (lastTrack != cluster.trackID) {
-            lastSector = lastResPad = lastResTime = lastQTot = lastQMax = lastSigmaPad = lastSigmaTime = 0;
-          }
-
-          if (sector_diff) {
-            do_diff(cluster.sector, lastSector, field_bits[SECTOR]);
-          }
-
-          if (res_diff) {
-            do_diff(cluster.resPad, lastResPad, field_bits[RES_PAD]);
-            do_diff(cluster.resTime, lastResTime, field_bits[RES_TIME]);
-          }
-
-          if (track_diffqtot) {
-            cluster.avgtot = cluster.qtot;
-            do_diff(cluster.avgtot, lastQTot, field_bits[QTOT]);
-          }
-          if (track_diffqmax) {
-            cluster.avgmax = cluster.qmax;
-            do_diff(cluster.avgmax, lastQMax, field_bits[QMAX]);
-          }
-          if (track_diffsigma) {
-            dSigmaPad = cluster.sigmaPad;
-            dSigmaTime = cluster.sigmaTime;
-            do_diff(dSigmaPad, lastSigmaPad, field_bits[SIGMA_PAD]);
-            do_diff(dSigmaTime, lastSigmaTime, field_bits[SIGMA_TIME]);
-          } else if (track_separate_sigma) {
-            dSigmaPad = truncate(SIGMA_PAD, cluster.sigmaPad);
-            dSigmaTime = truncate(SIGMA_TIME, cluster.sigmaTime);
-          }
-        }
-
-        if (cluster.row != lastRow) {
-          lastPad = lastTime = 0;
-        }
-        if (row_diff) {
-          do_diff(cluster.row, lastRow, field_bits[ROW]);
-        } else {
-          lastRow = cluster.row;
-        }
-
-        if (pad_diff && (cluster.trackID == -1 || !track_based)) {
-          do_diff(cluster.pad, lastPad, field_bits[PAD], (distinguish_rows ? fgNPadsMod[cluster_org.row + fgRows[cluster.patch][0]] : 140) * 60);
-        }
-        if (time_diff && (cluster.trackID == -1 || !track_based)) {
-          do_diff(cluster.time, lastTime, field_bits[TIME], 1024 * 25);
-        }
-
-        if (approximate_qtot && (!track_based || cluster.trackID == -1 || (track_avgtot == 0 && track_diffqtot == 0))) {
-          cluster.qtot -= cluster.sigmaPad * cluster.qmax / 3;
-          if (cluster.qtot < 0) {
-            cluster.qtot = -truncate(QTOT, -cluster.qtot);
-          } else {
-            cluster.qtot = truncate(QTOT, cluster.qtot);
-          }
-          cluster.qtot &= (1 << field_bits[QTOT]) - 1;
-        }
-
-        if (track_avgtot && cluster.trackID != -1) {
-          int32_t tmp = truncate(QTOT, cluster.qtot) - truncate(QTOT, cluster.avgtot);
-          if (newTrack) {
-            cluster.qtot = truncate(QTOT, cluster.avgtot);
-          }
-          cluster.avgtot = tmp & ((1 << field_bits[QTOT]) - 1);
-        }
-        if (track_avgmax && cluster.trackID != -1) {
-          int32_t tmp = cluster.qmax - cluster.avgmax;
-          if (newTrack) {
-            cluster.qmax = cluster.avgmax;
-          }
-          cluster.avgmax = tmp & ((1 << field_bits[QMAX]) - 1);
-        }
-
-        // Copy qmax / qtot to combined track avg... slot, to use for combine_maxtot
-        if ((((combine_maxtot && (track_avgtot || track_diffqtot)) || track_separate_q) && track_avgmax == 0 && track_diffqmax == 0) && cluster.trackID != -1) {
-          cluster.avgmax = cluster.qmax;
-        }
-        if ((((combine_maxtot && (track_avgmax || track_diffqmax)) || track_separate_q) && track_avgtot == 0 && track_diffqtot == 0) && cluster.trackID != -1) {
-          cluster.avgtot = cluster.qtot;
-        }
-
-        for (int32_t j = 0; j < sizeof(cluster_struct) / sizeof(uint32_t); j++) {
-          if (approximate_qtot && (j == QTOT || j == AVG_TOT)) {
-            continue;
-          }
-          if (track_avgtot && (j == QTOT || j == AVG_TOT)) {
-            continue;
-          }
-          cluster.vals[j] = truncate(j, cluster.vals[j]);
-        }
-
-        lastEvent = cluster.event;
-        lastTrack = cluster.trackID;
-
-        if (print_clusters > 0 || (print_clusters < 0 && i < -print_clusters)) {
-          printf("Event %u Track %d Sector %u Patch %u Row %u Pad %u Time %u sigmaPad %u sigmaTime %u qTot %u qMax %u Flag %u resPad %u resTime %u avgTot %u avgMax %u\n", cluster.event, cluster.trackID, cluster.sector, cluster.patch, cluster.row, cluster.pad, cluster.time, cluster.sigmaPad,
-                 cluster.sigmaTime, cluster.qtot, cluster.qmax, cluster.splitPadTime, cluster.resPad, cluster.resTime, cluster.avgtot, cluster.avgmax);
-        }
-
-        for (int32_t j = SECTOR; j < nFields; j++) {
-          bool forceStore = false;
-          if (j == CLUSTER_ID || j == PATCH) {
-            continue;
-          }
-
-          if (j == SECTOR && (track_based == 0 || cluster.trackID == -1)) {
-            continue;
-          }
-
-          if (track_based && cluster.trackID != -1 && !newTrack) {
-            if (j == PAD || j == TIME || (j >= PAD_80 && j <= PAD_140)) {
-              continue;
-            }
-            if (j == RES_PAD || j == RES_TIME) {
-              cluster.vals[j] &= (1 << field_bits[j]) - 1;
-              forceStore = true;
-            }
-          }
-
-          if ((track_avgtot || track_diffqtot || track_separate_q) && cluster.trackID != -1) {
-            if (j == QTOT && (!newTrack || (track_avgtot == 0 && track_diffqtot == 0))) {
-              continue;
-            }
-            if (j == AVG_TOT && (track_diffqtot == 0 || !newTrack)) {
-              forceStore = true;
-            }
-          }
-          if ((track_avgmax || track_diffqmax || track_separate_q) && cluster.trackID != -1) {
-            if (j == QMAX && (!newTrack || (track_avgmax == 0 && track_diffqmax == 0))) {
-              continue;
-            }
-            if (j == AVG_MAX && (track_diffqmax == 0 || !newTrack)) {
-              forceStore = true;
-            }
-          }
-
-          if ((track_diffsigma || track_separate_sigma) && cluster.trackID != -1) {
-            if (j == SIGMA_PAD || j == SIGMA_TIME) {
-              continue;
-            }
-            if (j == DIFF_SIGMA_PAD) {
-              histograms[j][dSigmaPad]++;
-              counts[j]++;
-            }
-            if (j == DIFF_SIGMA_TIME) {
-              histograms[j][dSigmaTime]++;
-              counts[j]++;
-            }
-          }
-
-          if (track_based && row_diff && cluster.trackID != -1) {
-            if (j == ROW) {
-              continue;
-            }
-            int32_t myj = newTrack ? ROW_TRACK_FIRST : ROW_TRACK;
-            if (j == myj) {
-              histograms[myj][cluster.vals[ROW]]++;
-              counts[myj]++;
-            }
-          }
-
-          if (j <= FLAG_PADTIME || forceStore) {
-            if (cluster.vals[j] >= (1 << field_bits[j])) {
-              printf("Cluster value %d/%s out of bit range %d > %d\n", j, field_names[j], cluster.vals[j], (1 << field_bits[j]));
-            } else {
-              histograms[j][cluster.vals[j]]++;
-              counts[j]++;
-            }
-          } else if (j == QMAX_QTOT && (!track_based || cluster.trackID == -1 || (((track_avgmax == 0 && track_avgtot == 0 && track_diffqmax == 0 && track_diffqtot == 0) || newTrack) && track_separate_q == 0))) {
-            int32_t val = (cluster.qtot << field_bits[QMAX]) | cluster.qmax;
-            histograms[j][val]++;
-            counts[j]++;
-          } else if (((track_avgmax || track_avgtot || track_diffqmax || track_diffqtot) && !newTrack || track_separate_q) && cluster.trackID != -1 && j == AVG_TOT_MAX) {
-            int32_t val = (cluster.avgtot << field_bits[QMAX]) | cluster.avgmax;
-            histograms[j][val]++;
-            counts[j]++;
-          } else if (j == SIGMA_PAD_TIME && (!track_based || cluster.trackID == -1 || (track_diffsigma == 0 && track_separate_sigma == 0))) {
-            int32_t val = (cluster.sigmaTime << field_bits[SIGMA_PAD]) | cluster.sigmaPad;
-            histograms[j][val]++;
-            counts[j]++;
-          } else if ((track_diffsigma || track_separate_sigma) && cluster.trackID != -1 && j == DIFF_SIGMA_PAD_TIME) {
-            int32_t val = (dSigmaPad << field_bits[SIGMA_PAD]) | dSigmaTime;
-            histograms[j][val]++;
-            counts[j]++;
-          } else if (distinguish_rows && j >= PAD_80 && j <= PAD_140) {
-            int32_t myj = fgNPads[cluster_org.row + fgRows[cluster.patch][0]];
-            myj = (myj - (80 - 11)) / 12;
-            myj += PAD_80;
-            if (myj == j) {
-              if (cluster.pad >= (1 << field_bits[j])) {
-                printf("Cluster value %d/%s out of bit range %d > %d\n", j, field_names[j], cluster.vals[j], (1 << field_bits[j]));
-              } else {
-                histograms[j][cluster.pad]++;
-                counts[j]++;
-              }
-            }
-          }
-        }
-        nClustersUsed++;
-      }
-
-      printf("Clusters in block: %ld / %ld\n", nClustersUsed, nClusters);
-
-      double log2 = log(2.);
-      double entropies[nFields];
-      double huffmanSizes[nFields];
-      for (int32_t i = SECTOR; i < nFields; i++) {
-        if (i == CLUSTER_ID || i == PATCH) {
-          continue;
-        }
-        double entropy = 0.;
-        double huffmanSize = 0;
-
-        if (counts[i]) {
-          for (int32_t j = 0; j < (1 << field_bits[i]); j++) {
-            // printf("Field %d/%s Value %d Entries %ld\n", i, field_names[i], j, histograms[i][j]);
-
-            probabilities[i][j] = (double)histograms[i][j] / (double)counts[i];
-            if (probabilities[i][j]) {
-              double I = -log(probabilities[i][j]) / log2;
-              double H = I * probabilities[i][j];
-              // printf("Field %d/%s Value %d I prob %f I %f H %f\n", i, field_names[i], probabilities[i][j], I, H);
-
-              entropy += H;
-            }
-          }
-
-          INode* root = BuildTree(probabilities[i], 1 << field_bits[i]);
-
-          HuffCodeMap codes;
-          GenerateCodes(root, HuffCode(), codes);
-          delete root;
-
-          for (HuffCodeMap::const_iterator it = codes.begin(); it != codes.end(); it++) {
-            huffmanSize += it->second.size() * probabilities[i][it->first];
-          }
-        }
-        entropies[i] = entropy;
-        huffmanSizes[i] = huffmanSize;
-      }
-
-      int32_t rawBits = 0;
-      double entroTotal = 0., huffmanTotal = 0.;
-      for (int32_t i = SECTOR; i < nFields; i++) {
-        if (i == CLUSTER_ID || i == PATCH) {
-          continue;
-        }
-
-        if (i <= FLAG_PADTIME) {
-          rawBits += field_bits[i];
-        }
-
-        if (combine_maxtot && (i == QMAX || i == QTOT)) {
-          continue;
-        }
-        if (combine_sigmapadtime && (i == SIGMA_PAD || i == SIGMA_TIME)) {
-          continue;
-        }
-        if ((track_diffsigma || track_separate_sigma) && combine_sigmapadtime && (i == DIFF_SIGMA_PAD || i == DIFF_SIGMA_TIME)) {
-          continue;
-        }
-
-        if (distinguish_rows && i == PAD) {
-          continue;
-        }
-
-        if (i <= FLAG_PADTIME || (combine_maxtot && i == QMAX_QTOT) || (combine_maxtot && (track_avgmax || track_avgtot || track_diffqmax || track_diffqtot || track_separate_q) && combine_maxtot && i == AVG_TOT_MAX) || (combine_sigmapadtime && i == SIGMA_PAD_TIME) ||
-            (combine_sigmapadtime && (track_diffsigma || track_separate_sigma) && i == DIFF_SIGMA_PAD_TIME) || (track_based && (i == RES_PAD || i == RES_TIME)) || ((track_avgtot || track_diffqtot || track_separate_q) && !combine_maxtot && i == AVG_TOT) ||
-            ((track_avgmax || track_diffqmax || track_separate_q) && !combine_maxtot && i == AVG_MAX) || ((track_diffsigma || track_separate_sigma) && (i == DIFF_SIGMA_PAD || i == DIFF_SIGMA_TIME)) || (track_based && row_diff && (i == ROW_TRACK || i == ROW_TRACK_FIRST)) ||
-            (distinguish_rows && i >= PAD_80 && i <= PAD_140)) {
-          entroTotal += entropies[i] * counts[i];
-          huffmanTotal += huffmanSizes[i] * counts[i];
-          used[i] = 1;
-        }
-      }
-      for (int32_t i = SECTOR; i < nFields; i++) {
-        if (field_bits[i] == 0) {
-          continue;
-        }
-        if (counts[i] == 0) {
-          continue;
-        }
-        printf("Field %2d/%16s (count %10ld / used %1d) rawBits %2d huffman %9.6f entropy %9.6f\n", i, field_names[i], counts[i], used[i], field_bits[i], huffmanSizes[i], entropies[i]);
-      }
-      rawBits = 79; // Override incorrect calculation: Row is only 6 bit in raw format, and sector is not needed!
-      printf("Raw Bits: %d - Total Size %f MB Clusters %d\n", rawBits, (double)rawBits * (double)nClustersUsed / 8. / 1.e6, nClustersUsed);
-      printf("Huffman Bits: %f - Total Size %f MB\n", huffmanTotal / (double)nClustersUsed, huffmanTotal / 8. / 1.e6);
-      printf("Entropy Bits: %f - Total Size %f MB\n", entroTotal / (double)nClustersUsed, entroTotal / 8. / 1.e6);
-      printf("Maximum Compression Ratio: %f (Huffman %f)\n", (double)rawBits * (double)nClustersUsed / entroTotal, (double)rawBits * (double)nClustersUsed / huffmanTotal);
-      entrototalbytes += entroTotal;
-      rawtotalbytes += (double)rawBits * (double)nClustersUsed;
-
-      if (separate_sides && !separate_sectors && isector == 0) {
-        isector = 17;
-      } else if (!separate_sectors) {
-        isector = 9999999;
-      }
-
-      if (!separate_patches) {
-        ipatch = 9999999;
-      }
-    }
-  }
-
-  if (separate_sectors || separate_patches || separate_sides) {
-    printf("Total Compression: %f\n", rawtotalbytes / entrototalbytes);
-  }
-
-  printf("Exiting\n");
-  for (int32_t i = SECTOR; i < nFields; i++) {
-    if (i == CLUSTER_ID || i == PATCH) {
-      continue;
-    }
-    delete[] histograms[i];
-    delete[] probabilities[i];
-  }
-  delete[] clusters;
-  return (0);
-}

From 98c8b430614f79f8a89bd8f7160c4d20dfcfab6e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 7 Apr 2026 23:04:50 +0200
Subject: [PATCH 1596/1764] GPU: Change some defines to constexpr variables,
 some renaming

---
 .../src/CorrectdEdxDistortions.cxx            |  4 +-
 .../TPC/monitor/src/SimpleEventDisplayGUI.cxx |  2 +-
 .../TPC/workflow/src/EntropyEncoderSpec.cxx   | 22 +++----
 GPU/GPUTracking/Base/GPUConstantMem.h         |  6 +-
 GPU/GPUTracking/Base/GPUParam.cxx             | 12 ++--
 GPU/GPUTracking/Base/GPUParam.h               | 14 +++--
 GPU/GPUTracking/Base/GPUParam.inc             |  2 +-
 GPU/GPUTracking/Base/GPUProcessor.h           | 22 +++----
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 46 +++++++--------
 GPU/GPUTracking/Base/GPUReconstruction.h      |  4 +-
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx |  4 +-
 .../Base/GPUReconstructionCPUKernels.h        |  4 +-
 .../Base/GPUReconstructionConvert.cxx         | 12 ++--
 .../Base/GPUReconstructionConvert.h           |  2 +-
 .../Base/GPUReconstructionDeviceBase.cxx      |  4 +-
 .../Base/GPUReconstructionProcessing.h        |  2 +-
 .../Base/cuda/GPUReconstructionCUDA.cu        |  6 +-
 .../cuda/GPUReconstructionCUDAInternals.h     |  2 +-
 .../opencl/GPUReconstructionOCLIncludesHost.h |  2 +-
 .../GPUTPCClusterStatistics.cxx               |  4 +-
 .../DataCompression/GPUTPCClusterStatistics.h | 12 ++--
 .../DataCompression/GPUTPCCompression.cxx     | 12 ++--
 .../DataCompression/GPUTPCCompression.h       |  2 +-
 .../GPUTPCCompressionKernels.cxx              | 48 +++++++--------
 .../GPUTPCCompressionKernels.h                |  2 +-
 .../GPUTPCCompressionTrackModel.cxx           |  8 +--
 .../GPUTPCCompressionTrackModel.h             |  8 +--
 .../DataCompression/GPUTPCDecompression.cxx   | 10 ++--
 .../DataCompression/GPUTPCDecompression.h     |  2 +-
 .../GPUTPCDecompressionKernels.cxx            | 26 ++++-----
 .../GPUTPCDecompressionKernels.h              |  2 +-
 .../TPCClusterDecompressionCore.inc           | 22 +++----
 .../TPCClusterDecompressor.cxx                | 20 +++----
 .../DataCompression/TPCClusterDecompressor.h  |  2 +-
 .../DataTypes/GPUMemorySizeScalers.cxx        |  4 +-
 .../DataTypes/GPUTPCClusterOccupancyMap.cxx   |  2 +-
 .../DataTypes/GPUTPCClusterOccupancyMap.h     |  4 +-
 GPU/GPUTracking/DataTypes/GPUTPCGeometry.h    | 42 +++++++-------
 GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx    |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadBitMap.h      |  4 +-
 GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx |  2 +-
 GPU/GPUTracking/DataTypes/TPCPadGainCalib.h   |  8 +--
 GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx |  4 +-
 GPU/GPUTracking/Debug/GPUTPCClusterFilter.h   |  4 +-
 GPU/GPUTracking/Definitions/GPUDef.h          | 19 +++---
 .../Definitions/GPUDefConstantsAndSettings.h  | 44 ++++----------
 .../Definitions/GPUDefParametersConstants.h   | 38 +++++++-----
 .../Definitions/clusterFinderDefs.h           |  2 +-
 GPU/GPUTracking/Global/GPUChainTracking.cxx   |  4 +-
 GPU/GPUTracking/Global/GPUChainTracking.h     |  4 +-
 .../Global/GPUChainTrackingClusterizer.cxx    | 20 +++----
 .../Global/GPUChainTrackingCompression.cxx    | 42 +++++++-------
 .../GPUChainTrackingDebugAndProfiling.cxx     | 10 ++--
 GPU/GPUTracking/Global/GPUChainTrackingIO.cxx |  4 +-
 .../Global/GPUChainTrackingMerger.cxx         |  6 +-
 .../Global/GPUChainTrackingSectorTracker.cxx  | 14 ++---
 .../Global/GPUChainTrackingTransformation.cxx |  6 +-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 32 +++++-----
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h  |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx   |  2 +-
 .../Merger/GPUTPCGMPhysicalTrackModel.cxx     | 10 ++--
 .../Merger/GPUTPCGMPhysicalTrackModel.h       |  8 +--
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx | 14 ++---
 GPU/GPUTracking/Merger/GPUTPCGMPropagator.h   |  8 +--
 .../Merger/GPUTPCGMSectorTrack.cxx            |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h  |  2 +-
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx | 36 ++++++------
 GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h   |  8 +--
 .../Merger/GPUTPCGlobalDebugSortKernels.cxx   |  8 +--
 GPU/GPUTracking/Refit/GPUTrackingRefit.cxx    |  4 +-
 .../GPUTPCCreateOccupancyMap.cxx              | 10 ++--
 .../GPUTPCExtrapolationTracking.cxx           | 18 +++---
 .../GPUTPCExtrapolationTracking.h             |  2 +-
 GPU/GPUTracking/SectorTracker/GPUTPCGrid.cxx  |  4 +-
 GPU/GPUTracking/SectorTracker/GPUTPCHitId.h   |  8 +--
 .../SectorTracker/GPUTPCNeighboursCleaner.cxx | 58 +++++++++----------
 .../SectorTracker/GPUTPCNeighboursCleaner.h   |  8 +--
 .../SectorTracker/GPUTPCNeighboursFinder.cxx  | 34 +++++------
 .../SectorTracker/GPUTPCNeighboursFinder.h    |  8 +--
 GPU/GPUTracking/SectorTracker/GPUTPCRow.h     |  8 +--
 .../SectorTracker/GPUTPCStartHitsFinder.cxx   |  8 +--
 .../SectorTracker/GPUTPCStartHitsFinder.h     |  4 +-
 .../SectorTracker/GPUTPCStartHitsSorter.cxx   | 14 ++---
 .../SectorTracker/GPUTPCStartHitsSorter.h     |  6 +-
 .../SectorTracker/GPUTPCTrackLinearisation.h  |  8 +--
 .../SectorTracker/GPUTPCTrackParam.cxx        |  8 +--
 .../SectorTracker/GPUTPCTrackParam.h          | 22 +++----
 .../SectorTracker/GPUTPCTracker.cxx           | 23 ++++----
 GPU/GPUTracking/SectorTracker/GPUTPCTracker.h |  4 +-
 .../SectorTracker/GPUTPCTrackerDump.cxx       | 18 +++---
 .../SectorTracker/GPUTPCTrackingData.cxx      | 30 +++++-----
 .../SectorTracker/GPUTPCTracklet.h            |  8 +--
 .../GPUTPCTrackletConstructor.cxx             | 54 ++++++++---------
 .../SectorTracker/GPUTPCTrackletConstructor.h | 22 +++----
 .../SectorTracker/GPUTPCTrackletSelector.cxx  |  4 +-
 .../SectorTracker/GPUTPCTrackletSelector.h    |  2 +-
 .../Standalone/Benchmark/standalone.cxx       |  8 +--
 .../TPCClusterFinder/GPUTPCCFChainContext.h   | 20 +++----
 .../GPUTPCCFCheckPadBaseline.cxx              |  2 +-
 .../GPUTPCCFCheckPadBaseline.h                |  2 +-
 .../TPCClusterFinder/GPUTPCCFDecodeZS.cxx     |  8 +--
 .../TPCClusterFinder/GPUTPCCFDecodeZS.h       |  6 +-
 .../GPUTPCCFMCLabelFlattener.cxx              |  2 +-
 .../TPCClusterFinder/GPUTPCClusterFinder.cxx  | 12 ++--
 .../TPCClusterFinder/GPUTPCClusterFinder.h    |  2 +-
 .../GPUTPCClusterFinderDump.cxx               |  6 +-
 .../TRDTracking/GPUTRDInterfaces.h            |  2 +-
 GPU/GPUTracking/dEdx/GPUdEdx.h                |  6 +-
 GPU/GPUTracking/display/GPUDisplay.h          |  4 +-
 .../display/backend/GPUDisplayBackend.cxx     |  4 +-
 .../backend/GPUDisplayBackendOpenGL.cxx       |  4 +-
 .../display/render/GPUDisplayDraw.cxx         | 26 ++++-----
 .../display/render/GPUDisplayImportEvent.cxx  |  4 +-
 GPU/GPUTracking/qa/GPUQA.cxx                  | 28 ++++-----
 GPU/GPUTracking/qa/genEvents.cxx              |  2 +-
 117 files changed, 649 insertions(+), 673 deletions(-)

diff --git a/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx b/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
index 8398bdca71836..fc60c422d83f4 100644
--- a/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
+++ b/Detectors/TPC/calibration/src/CorrectdEdxDistortions.cxx
@@ -87,7 +87,7 @@ float o2::tpc::CorrectdEdxDistortions::getCorrection(const float time, unsigned
   const float ly = mTPCGeometry.LinearPad2Y(sector, padrow, pad);
 
   // get correction at "pad + 0.5*padlength" pos1 and dont extrapolate/interpolate across GEM gaps
-  const int row1 = ((padrow == mTPCGeometry.EndIROC() - 1) || (padrow == mTPCGeometry.EndOROC1() - 1) || (padrow == mTPCGeometry.EndOROC2() - 1)) ? padrow : std::clamp(padrow + 1, 0, GPUCA_NROWS - 1);
+  const int row1 = ((padrow == mTPCGeometry.EndIROC() - 1) || (padrow == mTPCGeometry.EndOROC1() - 1) || (padrow == mTPCGeometry.EndOROC2() - 1)) ? padrow : std::clamp(padrow + 1, 0, o2::tpc::constants::MAXGLOBALPADROW - 1);
 
   float lxT_1 = 0;
   float lyT_1 = 0;
@@ -101,7 +101,7 @@ float o2::tpc::CorrectdEdxDistortions::getCorrection(const float time, unsigned
   const float r_1_f = std::sqrt(lxT_1 * lxT_1 + lyT_1 * lyT_1);
 
   // get correction at "pad - 0.5*padlength" pos0 and dont extrapolate/interpolate across GEM gaps
-  const int row0 = ((padrow == mTPCGeometry.EndIROC()) || (padrow == mTPCGeometry.EndOROC1()) || (padrow == mTPCGeometry.EndOROC2())) ? padrow : std::clamp(padrow - 1, 0, GPUCA_NROWS - 1);
+  const int row0 = ((padrow == mTPCGeometry.EndIROC()) || (padrow == mTPCGeometry.EndOROC1()) || (padrow == mTPCGeometry.EndOROC2())) ? padrow : std::clamp(padrow - 1, 0, o2::tpc::constants::MAXGLOBALPADROW - 1);
 
   // check if previous pad row has enough pads
   const unsigned char pad0 = std::clamp(static_cast<int>(pad), 0, mTPCGeometry.NPads(row0) - 1);
diff --git a/Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx b/Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx
index 5509aa7473fc8..0d032443c9754 100644
--- a/Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx
+++ b/Detectors/TPC/monitor/src/SimpleEventDisplayGUI.cxx
@@ -1227,7 +1227,7 @@ void SimpleEventDisplayGUI::showClusters(int roc, int row)
         }
         if (fillSingleTB && std::abs(cl.getTime() - timeBin) < 2) {
           const auto ly = gpuGeom.LinearPad2Y(sector, irow, cl.getPad() + 0.5);
-          mClustersRowPad->SetNextPoint(gpuGeom.Row2X(irow), (sector >= GPUCA_NSECTORS / 2) ? -ly : ly);
+          mClustersRowPad->SetNextPoint(gpuGeom.Row2X(irow), (sector >= gpuGeom.NSECTORS / 2) ? -ly : ly);
         }
       }
       // fmt::print("\n");
diff --git a/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx b/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
index 7847919275531..4de5665f1b9a0 100644
--- a/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
+++ b/Detectors/TPC/workflow/src/EntropyEncoderSpec.cxx
@@ -158,7 +158,7 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
 
     const auto& tinfo = pc.services().get<o2::framework::TimingInfo>();
     const auto firstIR = o2::InteractionRecord(0, tinfo.firstTForbit);
-    const float totalT = std::max(mFastTransform->getMaxDriftTime(0), mFastTransform->getMaxDriftTime(GPUCA_NSECTORS / 2));
+    const float totalT = std::max(mFastTransform->getMaxDriftTime(0), mFastTransform->getMaxDriftTime(GPUTPCGeometry::NSECTORS / 2));
 
     unsigned int offset = 0, lasti = 0;
     const unsigned int maxTime = (mParam->continuousMaxTimeBin + 1) * o2::tpc::ClusterNative::scaleTimePacked - 1;
@@ -205,23 +205,23 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
       }
     }
     offset = 0;
-    unsigned int offsets[GPUCA_NSECTORS][GPUCA_NROWS];
-    for (unsigned int i = 0; i < GPUCA_NSECTORS; i++) {
-      for (unsigned int j = 0; j < GPUCA_NROWS; j++) {
-        if (i * GPUCA_NROWS + j >= clusters.nSliceRows) {
+    unsigned int offsets[GPUTPCGeometry::NSECTORS][GPUTPCGeometry::NROWS];
+    for (unsigned int i = 0; i < GPUTPCGeometry::NSECTORS; i++) {
+      for (unsigned int j = 0; j < GPUTPCGeometry::NROWS; j++) {
+        if (i * GPUTPCGeometry::NROWS + j >= clusters.nSliceRows) {
           break;
         }
         offsets[i][j] = offset;
-        offset += (i * GPUCA_NROWS + j >= clusters.nSliceRows) ? 0 : clusters.nSliceRowClusters[i * GPUCA_NROWS + j];
+        offset += (i * GPUTPCGeometry::NROWS + j >= clusters.nSliceRows) ? 0 : clusters.nSliceRowClusters[i * GPUTPCGeometry::NROWS + j];
       }
     }
 
 #ifdef WITH_OPENMP
-#pragma omp parallel for num_threads(mNThreads) schedule(static, (GPUCA_NSECTORS + mNThreads - 1) / mNThreads) // Static round-robin scheduling with one chunk per thread to ensure correct order of the final vector
+#pragma omp parallel for num_threads(mNThreads) schedule(static, (GPUTPCGeometry::NSECTORS + mNThreads - 1) / mNThreads) // Static round-robin scheduling with one chunk per thread to ensure correct order of the final vector
 #endif
     for (unsigned int ii = 0; ii < clusters.nSliceRows; ii++) {
-      unsigned int i = ii / GPUCA_NROWS;
-      unsigned int j = ii % GPUCA_NROWS;
+      unsigned int i = ii / GPUTPCGeometry::NROWS;
+      unsigned int j = ii % GPUTPCGeometry::NROWS;
       o2::tpc::ClusterNative preCl;
 #ifdef WITH_OPENMP
       int myThread = omp_get_thread_num();
@@ -240,7 +240,7 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
         const bool reject = mCTFCoder.getIRFramesSelector().check(o2::dataformats::IRFrame(chkVal, chkVal + 1), chkExt, 0) < 0;
         if (reject) {
           rejectHits[k] = true;
-          clustersFiltered.nSliceRowClusters[i * GPUCA_NROWS + j]--;
+          clustersFiltered.nSliceRowClusters[i * GPUTPCGeometry::NROWS + j]--;
           static std::atomic_flag lock = ATOMIC_FLAG_INIT;
           while (lock.test_and_set(std::memory_order_acquire)) {
           }
@@ -253,7 +253,7 @@ void EntropyEncoderSpec::run(ProcessingContext& pc)
           preCl = cl;
         }
       };
-      unsigned int end = offsets[i][j] + clusters.nSliceRowClusters[i * GPUCA_NROWS + j];
+      unsigned int end = offsets[i][j] + clusters.nSliceRowClusters[i * GPUTPCGeometry::NROWS + j];
       o2::gpu::TPCClusterDecompressionCore::decompressHits(clusters, offsets[i][j], end, checker);
     }
     tmpBuffer[0].first.reserve(clustersFiltered.nUnattachedClusters);
diff --git a/GPU/GPUTracking/Base/GPUConstantMem.h b/GPU/GPUTracking/Base/GPUConstantMem.h
index 94ccfa7fa6db9..14c388e450d73 100644
--- a/GPU/GPUTracking/Base/GPUConstantMem.h
+++ b/GPU/GPUTracking/Base/GPUConstantMem.h
@@ -40,13 +40,13 @@ namespace o2::gpu
 {
 struct GPUConstantMem {
   GPUParam param;
-  GPUTPCTracker tpcTrackers[GPUCA_NSECTORS];
+  GPUTPCTracker tpcTrackers[GPUTPCGeometry::NSECTORS];
   GPUTPCCompression tpcCompressor;
   GPUTPCDecompression tpcDecompressor;
   GPUTPCGMMerger tpcMerger;
   GPUTRDTrackerGPU trdTrackerGPU;
   GPUTRDTracker trdTrackerO2;
-  GPUTPCClusterFinder tpcClusterer[GPUCA_NSECTORS];
+  GPUTPCClusterFinder tpcClusterer[GPUTPCGeometry::NSECTORS];
   GPUTrackingRefitProcessor trackingRefit;
   GPUTrackingInOutPointers ioPtrs;
   GPUCalibObjectsConst calibObjects;
@@ -55,7 +55,7 @@ struct GPUConstantMem {
   GPUKernelDebugOutput debugOutput;
 #endif
 #ifdef GPUCA_HAS_ONNX
-  GPUTPCNNClusterizer tpcNNClusterer[GPUCA_NSECTORS];
+  GPUTPCNNClusterizer tpcNNClusterer[GPUTPCGeometry::NSECTORS];
 #endif
   template <int32_t I>
   GPUd() auto& getTRDTracker();
diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index db086eae40df3..3f6c08e9f53fe 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -91,16 +91,16 @@ void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
   constexpr float plusZmax = 249.778;
   constexpr float minusZmin = -249.645;
   constexpr float minusZmax = -0.0799937;
-  for (int32_t i = 0; i < GPUCA_NSECTORS; i++) {
-    const bool zPlus = (i < GPUCA_NSECTORS / 2);
+  for (uint32_t i = 0; i < GPUTPCGeometry::NSECTORS; i++) {
+    const bool zPlus = (i < GPUTPCGeometry::NSECTORS / 2);
     SectorParam[i].ZMin = zPlus ? plusZmin : minusZmin;
     SectorParam[i].ZMax = zPlus ? plusZmax : minusZmax;
     int32_t tmp = i;
-    if (tmp >= GPUCA_NSECTORS / 2) {
-      tmp -= GPUCA_NSECTORS / 2;
+    if (tmp >= (int32_t)GPUTPCGeometry::NSECTORS / 2) {
+      tmp -= GPUTPCGeometry::NSECTORS / 2;
     }
-    if (tmp >= GPUCA_NSECTORS / 4) {
-      tmp -= GPUCA_NSECTORS / 2;
+    if (tmp >= (int32_t)GPUTPCGeometry::NSECTORS / 4) {
+      tmp -= GPUTPCGeometry::NSECTORS / 2;
     }
     SectorParam[i].Alpha = 0.174533f + dAlpha * tmp;
     SectorParam[i].CosAlpha = CAMath::Cos(SectorParam[i].Alpha);
diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 9dc9d2eeafc7f..82af34df7d633 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -20,6 +20,7 @@
 #include "GPUDef.h"
 #include "GPUSettings.h"
 #include "GPUTPCGMPolynomialField.h"
+#include "GPUTPCGeometry.h"
 
 #if !defined(GPUCA_GPUCODE)
 namespace o2::base
@@ -65,7 +66,7 @@ struct GPUParam_t {
   uint32_t occupancyTotal;                 // Total occupancy in the TPC (nCl / nHbf)
   uint32_t occupancyMapSize;               // Size of occupancy map
 
-  GPUParamSector SectorParam[GPUCA_NSECTORS];
+  GPUParamSector SectorParam[GPUTPCGeometry::NSECTORS];
 
  protected:
 #ifndef GPUCA_RUN2
@@ -87,13 +88,14 @@ struct GPUParam : public internal::GPUParam_t<GPUSettingsRec, GPUSettingsParam>
   void UpdateRun3ClusterErrors(const float* yErrorParam, const float* zErrorParam);
 #endif
 
-  GPUd() float Alpha(int32_t iSector) const
+  GPUd() constexpr uint32_t tpcMinHitsB5(float qPtB5) const { return CAMath::Abs(qPtB5) > 10 ? 10 : (CAMath::Abs(qPtB5) > 5 ? 15 : 29); } // Minimum hits should depend on Pt, low Pt tracks can have few hits. 29 Hits default, 15 for < 200 mev, 10 for < 100 mev
+  GPUd() constexpr float Alpha(int32_t iSector) const
   {
-    if (iSector >= GPUCA_NSECTORS / 2) {
-      iSector -= GPUCA_NSECTORS / 2;
+    if (iSector >= (int32_t)GPUTPCGeometry::NSECTORS / 2) {
+      iSector -= GPUTPCGeometry::NSECTORS / 2;
     }
-    if (iSector >= GPUCA_NSECTORS / 4) {
-      iSector -= GPUCA_NSECTORS / 2;
+    if (iSector >= (int32_t)GPUTPCGeometry::NSECTORS / 4) {
+      iSector -= GPUTPCGeometry::NSECTORS / 2;
     }
     return 0.174533f + dAlpha * iSector;
   }
diff --git a/GPU/GPUTracking/Base/GPUParam.inc b/GPU/GPUTracking/Base/GPUParam.inc
index 8e8c77b931942..8ed6160af361d 100644
--- a/GPU/GPUTracking/Base/GPUParam.inc
+++ b/GPU/GPUTracking/Base/GPUParam.inc
@@ -116,7 +116,7 @@ GPUdi() float GPUParam::GetSystematicClusterErrorC122(float x, float y, uint8_t
     return 0.f;
   }
   constexpr float dEdgeInv = 18.f / CAMath::Pi();
-  const float dy = (sector == (GPUCA_NSECTORS / 2 + 1) ? 0.5f : -0.5f) * (y / x) * dEdgeInv + 0.5f;
+  const float dy = (sector == (GPUTPCGeometry::NSECTORS / 2 + 1) ? 0.5f : -0.5f) * (y / x) * dEdgeInv + 0.5f;
   const float errC12 = rec.tpc.sysClusErrorC12Norm * occupancyTotal * dy;
   return errC12 * errC12;
 }
diff --git a/GPU/GPUTracking/Base/GPUProcessor.h b/GPU/GPUTracking/Base/GPUProcessor.h
index df551c9f0330d..337ecfc61f79d 100644
--- a/GPU/GPUTracking/Base/GPUProcessor.h
+++ b/GPU/GPUTracking/Base/GPUProcessor.h
@@ -62,7 +62,7 @@ class GPUProcessor
     return *(T*)(mGPUProcessorType == PROCESSOR_TYPE_DEVICE ? mLinkedProcessor : this);
   }
 
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT>
   static constexpr inline size_t getAlignmentMod(size_t addr)
   {
     static_assert((alignment & (alignment - 1)) == 0, "Invalid alignment, not power of 2");
@@ -71,7 +71,7 @@ class GPUProcessor
     }
     return addr & (alignment - 1);
   }
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT>
   static constexpr inline size_t getAlignment(size_t addr)
   {
     size_t mod = getAlignmentMod<alignment>(addr);
@@ -80,7 +80,7 @@ class GPUProcessor
     }
     return (alignment - mod);
   }
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT>
   static constexpr inline size_t nextMultipleOf(size_t size)
   {
     return size + getAlignment<alignment>(size);
@@ -97,22 +97,22 @@ class GPUProcessor
       return (size + alignment - 1) & ~(alignment - 1);
     }
   }
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT>
   static inline void* alignPointer(void* ptr)
   {
     return (reinterpret_cast<void*>(nextMultipleOf<alignment>(reinterpret_cast<size_t>(ptr))));
   }
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT>
   static inline size_t getAlignmentMod(void* addr)
   {
     return (getAlignmentMod<alignment>(reinterpret_cast<size_t>(addr)));
   }
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT>
   static inline size_t getAlignment(void* addr)
   {
     return (getAlignment<alignment>(reinterpret_cast<size_t>(addr)));
   }
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT, class S>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT, class S>
   static inline S* getPointerWithAlignment(size_t& basePtr, size_t nEntries = 1)
   {
     if (basePtr == 0) {
@@ -125,7 +125,7 @@ class GPUProcessor
     return retVal;
   }
 
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT, class S>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT, class S>
   static inline S* getPointerWithAlignment(void*& basePtr, size_t nEntries = 1)
   {
     size_t tmp = (size_t)basePtr;
@@ -134,7 +134,7 @@ class GPUProcessor
     return retVal;
   }
 
-  template <size_t alignment = GPUCA_BUFFER_ALIGNMENT, class T, class S>
+  template <size_t alignment = constants::GPU_BUFFER_ALIGNMENT, class T, class S>
   static inline void computePointerWithAlignment(T*& basePtr, S*& objPtr, size_t nEntries = 1)
   {
     size_t tmp = (size_t)basePtr;
@@ -145,8 +145,8 @@ class GPUProcessor
   template <class T, class S>
   static inline void computePointerWithoutAlignment(T*& basePtr, S*& objPtr, size_t nEntries = 1)
   {
-    if ((size_t)basePtr < GPUCA_BUFFER_ALIGNMENT) {
-      basePtr = (T*)GPUCA_BUFFER_ALIGNMENT;
+    if ((size_t)basePtr < constants::GPU_BUFFER_ALIGNMENT) {
+      basePtr = (T*)constants::GPU_BUFFER_ALIGNMENT;
     }
     size_t tmp = (size_t)basePtr;
     objPtr = reinterpret_cast<S*>(getPointerWithAlignment<1, char>(tmp, nEntries * sizeof(S)));
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index f3449eda6b1a5..e21ac694fbfff 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -343,14 +343,14 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
   }
 
   if (GetProcessingSettings().nTPCClustererLanes == -1) {
-    mProcessingSettings->nTPCClustererLanes = (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) ? 3 : std::max<int32_t>(1, std::min<int32_t>(GPUCA_NSECTORS, GetProcessingSettings().inKernelParallel ? (mMaxHostThreads >= 4 ? std::min<int32_t>(mMaxHostThreads / 2, mMaxHostThreads >= 32 ? GPUCA_NSECTORS : 4) : 1) : mMaxHostThreads));
+    mProcessingSettings->nTPCClustererLanes = (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) ? 3 : std::max<int32_t>(1, std::min<int32_t>(GPUTPCGeometry::NSECTORS, GetProcessingSettings().inKernelParallel ? (mMaxHostThreads >= 4 ? std::min<int32_t>(mMaxHostThreads / 2, mMaxHostThreads >= 32 ? GPUTPCGeometry::NSECTORS : 4) : 1) : mMaxHostThreads));
   }
   if (GetProcessingSettings().overrideClusterizerFragmentLen == -1) {
     mProcessingSettings->overrideClusterizerFragmentLen = ((GetRecoStepsGPU() & RecoStep::TPCClusterFinding) || (mMaxHostThreads / GetProcessingSettings().nTPCClustererLanes >= 3)) ? TPC_MAX_FRAGMENT_LEN_GPU : TPC_MAX_FRAGMENT_LEN_HOST;
   }
-  if (GetProcessingSettings().nTPCClustererLanes > GPUCA_NSECTORS) {
+  if ((uint32_t)GetProcessingSettings().nTPCClustererLanes > GPUTPCGeometry::NSECTORS) {
     GPUError("Invalid value for nTPCClustererLanes: %d", GetProcessingSettings().nTPCClustererLanes);
-    mProcessingSettings->nTPCClustererLanes = GPUCA_NSECTORS;
+    mProcessingSettings->nTPCClustererLanes = GPUTPCGeometry::NSECTORS;
   }
 
   if (GetProcessingSettings().doublePipeline) {
@@ -467,7 +467,7 @@ int32_t GPUReconstruction::Exit()
       if (mMemoryResources[i].mReuse >= 0) {
         continue;
       }
-      ::operator delete(mMemoryResources[i].mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+      ::operator delete(mMemoryResources[i].mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
       mMemoryResources[i].mPtr = mMemoryResources[i].mPtrDevice = nullptr;
     }
   }
@@ -597,11 +597,11 @@ size_t GPUReconstruction::AllocateRegisteredMemoryHelper(GPUMemoryResource* res,
   stdspinlock spinlock(mMemoryMutex);
   if ((res->mType & GPUMemoryResource::MEMORY_STACK) && memorypoolend) {
     retVal = ptrDiff((res->*setPtr)((char*)1), (char*)(1));
-    memorypoolend = (void*)((char*)memorypoolend - GPUProcessor::getAlignmentMod<GPUCA_MEMALIGN>(memorypoolend));
+    memorypoolend = (void*)((char*)memorypoolend - GPUProcessor::getAlignmentMod<constants::GPU_MEMALIGN>(memorypoolend));
     if (retVal < res->mOverrideSize) {
       retVal = res->mOverrideSize;
     }
-    retVal += GPUProcessor::getAlignment<GPUCA_MEMALIGN>(retVal);
+    retVal += GPUProcessor::getAlignment<constants::GPU_MEMALIGN>(retVal);
     memorypoolend = (char*)memorypoolend - retVal;
     ptr = memorypoolend;
     retVal = std::max<size_t>(ptrDiff((res->*setPtr)(ptr), ptr), res->mOverrideSize);
@@ -613,7 +613,7 @@ size_t GPUReconstruction::AllocateRegisteredMemoryHelper(GPUMemoryResource* res,
       retVal = res->mOverrideSize;
       memorypool = (char*)ptr + res->mOverrideSize;
     }
-    memorypool = (void*)((char*)memorypool + GPUProcessor::getAlignment<GPUCA_MEMALIGN>(memorypool));
+    memorypool = (void*)((char*)memorypool + GPUProcessor::getAlignment<constants::GPU_MEMALIGN>(memorypool));
   }
   if (memorypoolend ? (memorypool > memorypoolend) : ((size_t)ptrDiff(memorypool, memorybase) > memorysize)) {
     std::cerr << "Memory pool size exceeded (" << device << ") (" << res->mName << ": " << (memorypoolend ? (memorysize + ptrDiff(memorypool, memorypoolend)) : ptrDiff(memorypool, memorybase)) << " > " << memorysize << "\n";
@@ -630,7 +630,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && (control == nullptr || control->useInternal())) {
     if (!(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) {
       if (res->mPtrDevice && res->mReuse < 0) {
-        ::operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+        ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
       }
       res->mSize = std::max((size_t)res->SetPointers((void*)1) - 1, res->mOverrideSize);
       if (res->mReuse >= 0) {
@@ -640,9 +640,9 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         }
         res->mPtrDevice = mMemoryResources[res->mReuse].mPtrDevice;
       } else {
-        res->mPtrDevice = ::operator new(res->mSize + GPUCA_BUFFER_ALIGNMENT, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+        res->mPtrDevice = ::operator new(res->mSize + constants::GPU_BUFFER_ALIGNMENT, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
       }
-      res->mPtr = GPUProcessor::alignPointer<GPUCA_BUFFER_ALIGNMENT>(res->mPtrDevice);
+      res->mPtr = GPUProcessor::alignPointer<constants::GPU_BUFFER_ALIGNMENT>(res->mPtrDevice);
       res->SetPointers(res->mPtr);
       if (GetProcessingSettings().allocDebugLevel >= 2) {
         std::cout << (res->mReuse >= 0 ? "Reused " : "Allocated ") << res->mName << ": " << res->mSize << " (individual" << ((res->mType & GPUMemoryResource::MEMORY_STACK) ? " stack" : "") << ")\n";
@@ -651,7 +651,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         stdspinlock spinlock(mMemoryMutex);
         mNonPersistentIndividualAllocations.emplace_back(res);
       }
-      if ((size_t)res->mPtr % GPUCA_BUFFER_ALIGNMENT) {
+      if ((size_t)res->mPtr % constants::GPU_BUFFER_ALIGNMENT) {
         GPUError("Got buffer with insufficient alignment");
         throw std::bad_alloc();
       }
@@ -661,14 +661,14 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
       GPUError("Double allocation! (%s)", res->mName);
       throw std::bad_alloc();
     }
-    if (IsGPU() && res->mOverrideSize < GPUCA_BUFFER_ALIGNMENT) {
-      res->mOverrideSize = GPUCA_BUFFER_ALIGNMENT;
+    if (IsGPU() && res->mOverrideSize < constants::GPU_BUFFER_ALIGNMENT) {
+      res->mOverrideSize = constants::GPU_BUFFER_ALIGNMENT;
     }
     if ((!IsGPU() || (res->mType & GPUMemoryResource::MEMORY_HOST) || GetProcessingSettings().keepDisplayMemory) && !(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) { // keepAllMemory --> keepDisplayMemory
       if (control && control->useExternal()) {
         if (control->allocator) {
           res->mSize = std::max((size_t)res->SetPointers((void*)1) - 1, res->mOverrideSize);
-          res->mPtr = control->allocator(CAMath::nextMultipleOf<GPUCA_BUFFER_ALIGNMENT>(res->mSize));
+          res->mPtr = control->allocator(CAMath::nextMultipleOf<constants::GPU_BUFFER_ALIGNMENT>(res->mSize));
           res->mSize = std::max<size_t>(ptrDiff(res->SetPointers(res->mPtr), res->mPtr), res->mOverrideSize);
           if (GetProcessingSettings().allocDebugLevel >= 2) {
             std::cout << "Allocated (from callback) " << res->mName << ": " << res->mSize << "\n";
@@ -680,7 +680,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
       } else {
         res->mSize = AllocateRegisteredMemoryHelper(res, res->mPtr, recPool->mHostMemoryPool, recPool->mHostMemoryBase, recPool->mHostMemorySize, &GPUMemoryResource::SetPointers, recPool->mHostMemoryPoolEnd, "host");
       }
-      if ((size_t)res->mPtr % GPUCA_BUFFER_ALIGNMENT) {
+      if ((size_t)res->mPtr % constants::GPU_BUFFER_ALIGNMENT) {
         GPUError("Got buffer with insufficient alignment");
         throw std::bad_alloc();
       }
@@ -702,7 +702,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         GPUError("Inconsistent device memory allocation (%s: device %lu vs %lu)", res->mName, size, res->mSize);
         throw std::bad_alloc();
       }
-      if ((size_t)res->mPtrDevice % GPUCA_BUFFER_ALIGNMENT) {
+      if ((size_t)res->mPtrDevice % constants::GPU_BUFFER_ALIGNMENT) {
         GPUError("Got buffer with insufficient alignment");
         throw std::bad_alloc();
       }
@@ -731,7 +731,7 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
 {
   stdspinlock spinlock(mMemoryMutex);
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
-    char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
+    char* retVal = new (std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)) char[size];
     if ((type & GPUMemoryResource::MEMORY_STACK)) {
       mNonPersistentIndividualDirectAllocations.emplace_back(retVal, alignedDefaultBufferDeleter());
     } else {
@@ -753,7 +753,7 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
   char* retVal;
   if ((type & GPUMemoryResource::MEMORY_STACK)) {
     poolend = (char*)poolend - size; // TODO: Implement overflow check
-    poolend = (char*)poolend - GPUProcessor::getAlignmentMod<GPUCA_MEMALIGN>(poolend);
+    poolend = (char*)poolend - GPUProcessor::getAlignmentMod<constants::GPU_MEMALIGN>(poolend);
     retVal = (char*)poolend;
   } else {
     GPUProcessor::computePointerWithAlignment(pool, retVal, size);
@@ -796,7 +796,7 @@ void* GPUReconstruction::AllocateVolatileMemory(size_t size, bool device)
   if (device) {
     return AllocateVolatileDeviceMemory(size);
   }
-  char* retVal = new (std::align_val_t(GPUCA_BUFFER_ALIGNMENT)) char[size];
+  char* retVal = new (std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)) char[size];
   stdspinlock spinlock(mMemoryMutex);
   mVolatileChunks.emplace_back(retVal, alignedDefaultBufferDeleter());
   return retVal;
@@ -876,7 +876,7 @@ void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)
     std::cout << "Freeing " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
   }
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && res->mReuse < 0) {
-    ::operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+    ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
   }
   res->mPtr = nullptr;
   res->mPtrDevice = nullptr;
@@ -916,7 +916,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag, cons
       std::cout << "Freeing NonPersistent " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
     }
     if (res->mReuse < 0) {
-      ::operator delete(res->mPtrDevice, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+      ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
     }
     res->mPtr = nullptr;
     res->mPtrDevice = nullptr;
@@ -970,8 +970,8 @@ void GPUReconstruction::ClearAllocatedMemory(bool clearOutputs)
   mVolatileChunks.clear();
   mVolatileMemoryStart = nullptr;
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
-    mHostMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mHostMemoryPermanent);
-    mDeviceMemoryPool = GPUProcessor::alignPointer<GPUCA_MEMALIGN>(mDeviceMemoryPermanent);
+    mHostMemoryPool = GPUProcessor::alignPointer<constants::GPU_MEMALIGN>(mHostMemoryPermanent);
+    mDeviceMemoryPool = GPUProcessor::alignPointer<constants::GPU_MEMALIGN>(mDeviceMemoryPermanent);
     mHostMemoryPoolEnd = mHostMemoryPoolBlocked ? mHostMemoryPoolBlocked : ((char*)mHostMemoryBase + mHostMemorySize);
     mDeviceMemoryPoolEnd = mDeviceMemoryPoolBlocked ? mDeviceMemoryPoolBlocked : ((char*)mDeviceMemoryBase + mDeviceMemorySize);
   } else {
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index fe04c62b59b7a..d5c30f8ccb711 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -82,7 +82,7 @@ class GPUReconstruction
   GPUReconstruction& operator=(const GPUReconstruction&) = delete;
 
   // General definitions
-  constexpr static uint32_t NSECTORS = GPUCA_NSECTORS;
+  constexpr static uint32_t NSECTORS = GPUTPCGeometry::NSECTORS;
 
   using GeometryType = gpudatatypes::GeometryType;
   using DeviceType = gpudatatypes::DeviceType;
@@ -389,7 +389,7 @@ class GPUReconstruction
   std::unordered_map<GPUMemoryReuse::ID, MemoryReuseMeta> mMemoryReuse1to1;
   std::vector<std::tuple<void*, void*, size_t, size_t, uint64_t>> mNonPersistentMemoryStack; // hostPoolAddress, devicePoolAddress, individualAllocationCount, directIndividualAllocationCound, tag
   std::vector<GPUMemoryResource*> mNonPersistentIndividualAllocations;
-  using alignedDefaultBufferDeleter = alignedDeleter<char, GPUCA_BUFFER_ALIGNMENT>;
+  using alignedDefaultBufferDeleter = alignedDeleter<char, constants::GPU_BUFFER_ALIGNMENT>;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mNonPersistentIndividualDirectAllocations;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mDirectMemoryChunks;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mVolatileChunks;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 6dd38c4c4d6b7..1aa54ae56b67b 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -189,7 +189,7 @@ int32_t GPUReconstructionCPU::InitDevice()
       if (mDeviceMemorySize > mHostMemorySize) {
         mHostMemorySize = mDeviceMemorySize;
       }
-      mHostMemoryBase = ::operator new(mHostMemorySize, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+      mHostMemoryBase = ::operator new(mHostMemorySize, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
     }
     mHostMemoryPermanent = mHostMemoryBase;
     ClearAllocatedMemory();
@@ -205,7 +205,7 @@ int32_t GPUReconstructionCPU::ExitDevice()
 {
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     if (mMaster == nullptr) {
-      ::operator delete(mHostMemoryBase, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+      ::operator delete(mHostMemoryBase, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
     }
     mHostMemoryPool = mHostMemoryBase = mHostMemoryPoolEnd = mHostMemoryPermanent = nullptr;
     mHostMemorySize = 0;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h b/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
index 0c19941c40ea4..7970fbe753ec8 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPUKernels.h
@@ -49,8 +49,8 @@ inline void GPUReconstructionCPU::runKernelInterface(krnlSetup&& setup, Args con
   } else if ((int32_t)nThreads < 0) {
     nThreads = cpuFallback ? 1 : -nThreads;
   }
-  if (nThreads > GPUCA_MAX_THREADS) {
-    throw std::runtime_error("GPUCA_MAX_THREADS exceeded");
+  if (nThreads > constants::GPU_MAX_THREADS) {
+    throw std::runtime_error("GPU_MAX_THREADS exceeded");
   }
   if (GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("Running kernel %s (Stream %d, Index %d, Grid %d/%d) on %s", GetKernelName<S, I>(), stream, setup.y.index, nBlocks, nThreads, cpuFallback == 2 ? "CPU (forced)" : (cpuFallback ? "CPU (fallback)" : mDeviceName.c_str()));
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
index 54784d0e1a5dc..9ec1af55a7a62 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.cxx
@@ -54,13 +54,13 @@ void GPUReconstructionConvert::ConvertNativeToClusterData(o2::tpc::ClusterNative
   uint32_t offset = 0;
   for (uint32_t i = 0; i < NSECTORS; i++) {
     uint32_t nClSector = 0;
-    for (int32_t j = 0; j < GPUCA_NROWS; j++) {
+    for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
       nClSector += native->nClusters[i][j];
     }
     nClusters[i] = nClSector;
     clusters[i].reset(new GPUTPCClusterData[nClSector]);
     nClSector = 0;
-    for (int32_t j = 0; j < GPUCA_NROWS; j++) {
+    for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
       for (uint32_t k = 0; k < native->nClusters[i][j]; k++) {
         const auto& clin = native->clusters[i][j][k];
         float x = 0, y = 0, z = 0;
@@ -98,7 +98,7 @@ void GPUReconstructionConvert::ConvertRun2RawToNative(o2::tpc::ClusterNativeAcce
   native.clustersLinear = nativeBuffer.get();
   native.setOffsetPtrs();
   for (uint32_t i = 0; i < NSECTORS; i++) {
-    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+    for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
       native.nClusters[i][j] = 0;
     }
     for (uint32_t j = 0; j < nRawClusters[i]; j++) {
@@ -119,7 +119,7 @@ int32_t GPUReconstructionConvert::GetMaxTimeBin(const ClusterNativeAccess& nativ
 {
   float retVal = 0;
   for (uint32_t i = 0; i < NSECTORS; i++) {
-    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+    for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
       for (uint32_t k = 0; k < native.nClusters[i][j]; k++) {
         if (native.clusters[i][j][k].getTime() > retVal) {
           retVal = native.clusters[i][j][k].getTime();
@@ -193,7 +193,7 @@ struct zsEncoder {
   const o2::InteractionRecord* ir = nullptr;
   const GPUParam* param = nullptr;
   bool padding = false;
-  int32_t lastEndpoint = -2, lastTime = -1, lastRow = GPUCA_NROWS;
+  int32_t lastEndpoint = -2, lastTime = -1, lastRow = GPUTPCGeometry::NROWS;
   int32_t endpoint = 0, outputEndpoint = 0;
   int64_t hbf = -1, nexthbf = 0;
   zsPage* page = nullptr;
@@ -364,7 +364,7 @@ uint32_t zsEncoderRow::encodeSequence(std::vector<o2::tpc::Digit>& tmpBuffer, ui
     curTBHdr = reinterpret_cast<TPCZSTBHDR*>(pagePtr);
     curTBHdr->rowMask |= (endpoint & 1) << 15;
     nRowsInTB = 0;
-    lastRow = GPUCA_NROWS;
+    lastRow = GPUTPCGeometry::NROWS;
   }
   if (tmpBuffer[k].getRow() != lastRow) {
     curTBHdr->rowMask |= 1 << (tmpBuffer[k].getRow() - endpointStart);
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.h b/GPU/GPUTracking/Base/GPUReconstructionConvert.h
index 3bb8a2b3df3c2..a2fa42fff74cb 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.h
@@ -48,7 +48,7 @@ struct GPUTrackingInOutZS;
 class GPUReconstructionConvert
 {
  public:
-  constexpr static uint32_t NSECTORS = GPUCA_NSECTORS;
+  constexpr static uint32_t NSECTORS = GPUTPCGeometry::NSECTORS;
   static void ConvertNativeToClusterData(o2::tpc::ClusterNativeAccess* native, std::unique_ptr<GPUTPCClusterData[]>* clusters, uint32_t* nClusters, const TPCFastTransformPOD* transform, int32_t continuousMaxTimeBin = 0);
   static void ConvertRun2RawToNative(o2::tpc::ClusterNativeAccess& native, std::unique_ptr<o2::tpc::ClusterNative[]>& nativeBuffer, const AliHLTTPCRawCluster** rawClusters, uint32_t* nRawClusters);
   template <class S>
diff --git a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
index 9962bdf3922c1..dba1e85aad3d6 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionDeviceBase.cxx
@@ -98,8 +98,8 @@ int32_t GPUReconstructionDeviceBase::InitDevice()
     GPUError("Individual memory allocation strategy unsupported for device\n");
     return (1);
   }
-  if (GetProcessingSettings().nStreams > GPUCA_MAX_STREAMS) {
-    GPUError("Too many straems requested %d > %d\n", GetProcessingSettings().nStreams, GPUCA_MAX_STREAMS);
+  if ((size_t)GetProcessingSettings().nStreams > constants::GPU_MAX_STREAMS) {
+    GPUError("Too many straems requested %d > %d\n", GetProcessingSettings().nStreams, constants::GPU_MAX_STREAMS);
     return (1);
   }
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index f582610b57973..746ecdf083691 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -249,7 +249,7 @@ HighResTimer& GPUReconstructionProcessing::getTimer(const char* name, int32_t nu
   static int32_t id = getNextTimerId();
   timerMeta* timer = getTimerById(id);
   if (timer == nullptr) {
-    int32_t max = std::max<int32_t>({mMaxHostThreads, GPUCA_MAX_STREAMS});
+    int32_t max = std::max<int32_t>({mMaxHostThreads, constants::GPU_MAX_STREAMS});
     timer = insertTimer(id, name, J, max, 1, RecoStep::NoRecoStep);
   }
   if (num == -1) {
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
index eb49a02fbb946..040a4b84a0f64 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDA.cu
@@ -268,12 +268,12 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
 #endif
 
 #ifndef __HIPCC__ // CUDA
-    if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitStackSize, GPUCA_GPU_STACK_SIZE))) {
+    if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitStackSize, constants::GPU_STACK_SIZE))) {
       GPUError("Error setting CUDA stack size");
       GPUChkErrI(cudaDeviceReset());
       return (1);
     }
-    if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitMallocHeapSize, GetProcessingSettings().deterministicGPUReconstruction ? std::max<size_t>(1024 * 1024 * 1024, GPUCA_GPU_HEAP_SIZE) : GPUCA_GPU_HEAP_SIZE))) {
+    if (GPUChkErrI(cudaDeviceSetLimit(cudaLimitMallocHeapSize, GetProcessingSettings().deterministicGPUReconstruction ? std::max<size_t>(1024 * 1024 * 1024, constants::GPU_HEAP_SIZE) : constants::GPU_HEAP_SIZE))) {
       GPUError("Error setting CUDA stack size");
       GPUChkErrI(cudaDeviceReset());
       return (1);
@@ -372,7 +372,7 @@ int32_t GPUReconstructionCUDA::InitDevice_Runtime()
 #endif
     mDeviceConstantMem = (GPUConstantMem*)devPtrConstantMem;
 
-    GPUInfo("CUDA Initialisation successfull (Device %d: %s (Frequency %d, Cores %d), %ld / %ld bytes host / global memory, Stack frame %d, Constant memory %ld)", mDeviceId, deviceProp.name, deviceClockRate, deviceProp.multiProcessorCount, (int64_t)mHostMemorySize, (int64_t)mDeviceMemorySize, (int32_t)GPUCA_GPU_STACK_SIZE, (int64_t)gGPUConstantMemBufferSize);
+    GPUInfo("CUDA Initialisation successfull (Device %d: %s (Frequency %d, Cores %d), %ld / %ld bytes host / global memory, Stack frame %d, Constant memory %ld)", mDeviceId, deviceProp.name, deviceClockRate, deviceProp.multiProcessorCount, (int64_t)mHostMemorySize, (int64_t)mDeviceMemorySize, (int32_t)constants::GPU_STACK_SIZE, (int64_t)gGPUConstantMemBufferSize);
   } else {
     GPUReconstructionCUDA* master = dynamic_cast<GPUReconstructionCUDA*>(mMaster);
     mDeviceId = master->mDeviceId;
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
index 493c09e448e5e..8ce21652247fc 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAInternals.h
@@ -30,7 +30,7 @@ namespace o2::gpu
 struct GPUReconstructionCUDAInternals {
   std::vector<std::unique_ptr<CUmodule>> kernelModules;     // module for RTC compilation
   std::vector<std::unique_ptr<CUfunction>> kernelFunctions; // vector of ptrs to RTC kernels
-  cudaStream_t Streams[GPUCA_MAX_STREAMS];                  // Pointer to array of CUDA Streams
+  cudaStream_t Streams[constants::GPU_MAX_STREAMS];         // Pointer to array of CUDA Streams
 
   static void getArgPtrs(const void** pArgs) {}
   template <typename T, typename... Args>
diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
index 919791948d6c3..ed0234f273338 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
@@ -43,7 +43,7 @@ struct GPUReconstructionOCLInternals {
   cl_platform_id platform;
   cl_device_id device;
   cl_context context;
-  cl_command_queue command_queue[GPUCA_MAX_STREAMS];
+  cl_command_queue command_queue[constants::GPU_MAX_STREAMS];
   cl_mem mem_gpu;
   cl_mem mem_constant;
   cl_mem mem_host;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
index 968e88e3a274c..d51d306acb827 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
@@ -117,7 +117,7 @@ void GPUTPCClusterStatistics::RunStatistics(const o2::tpc::ClusterNativeAccess*
   std::vector<o2::tpc::ClusterNative> tmpClusters;
   if (param.rec.tpc.rejectionStrategy == GPUSettings::RejectionNone) { // verification does not make sense if we reject clusters during compression
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+      for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
         if (clustersNative->nClusters[i][j] != clustersNativeDecoded.nClusters[i][j]) {
           GPUError("Number of clusters mismatch sector %u row %u: expected %d v.s. decoded %d", i, j, clustersNative->nClusters[i][j], clustersNativeDecoded.nClusters[i][j]);
           decodingErrors++;
@@ -181,7 +181,7 @@ void GPUTPCClusterStatistics::RunStatistics(const o2::tpc::ClusterNativeAccess*
   FillStatisticCombined(mPsigmaU, clustersCompressed->sigmaPadU, clustersCompressed->sigmaTimeU, clustersCompressed->nUnattachedClusters, P_MAX_SIGMA);
   FillStatisticCombined(mPQA, clustersCompressed->qMaxA, clustersCompressed->qTotA, clustersCompressed->nAttachedClusters, P_MAX_QMAX);
   FillStatisticCombined(mPQU, clustersCompressed->qMaxU, clustersCompressed->qTotU, clustersCompressed->nUnattachedClusters, P_MAX_QMAX);
-  FillStatisticCombined(mProwSectorA, clustersCompressed->rowDiffA, clustersCompressed->sliceLegDiffA, clustersCompressed->nAttachedClustersReduced, GPUCA_NROWS);
+  FillStatisticCombined(mProwSectorA, clustersCompressed->rowDiffA, clustersCompressed->sliceLegDiffA, clustersCompressed->nAttachedClustersReduced, GPUTPCGeometry::NROWS);
   mNTotalClusters += clustersCompressed->nAttachedClusters + clustersCompressed->nUnattachedClusters;
 }
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h
index 5b66ca54fe591..4efaa7f33257c 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.h
@@ -29,7 +29,7 @@ namespace o2::gpu
 class GPUTPCClusterStatistics
 {
  public:
-  static constexpr uint32_t NSECTORS = GPUCA_NSECTORS;
+  static constexpr uint32_t NSECTORS = GPUTPCGeometry::NSECTORS;
   void RunStatistics(const o2::tpc::ClusterNativeAccess* clustersNative, const o2::tpc::CompressedClusters* clustersCompressed, const GPUParam& param);
   void Finish();
 
@@ -54,15 +54,15 @@ class GPUTPCClusterStatistics
   std::vector<int32_t> mPqTotA = std::vector<int32_t>(P_MAX_QTOT, 0);
   std::vector<int32_t> mPqMaxA = std::vector<int32_t>(P_MAX_QMAX, 0);
   std::vector<int32_t> mPflagsA = std::vector<int32_t>(P_MAX_FLAGS, 0);
-  std::vector<int32_t> mProwDiffA = std::vector<int32_t>(GPUCA_NROWS, 0);
-  std::vector<int32_t> mPsectorLegDiffA = std::vector<int32_t>(GPUCA_NSECTORS * 2, 0);
+  std::vector<int32_t> mProwDiffA = std::vector<int32_t>(GPUTPCGeometry::NROWS, 0);
+  std::vector<int32_t> mPsectorLegDiffA = std::vector<int32_t>(GPUTPCGeometry::NSECTORS * 2, 0);
   std::vector<int32_t> mPpadResA = std::vector<int32_t>(P_MAX_PAD, 0);
   std::vector<int32_t> mPtimeResA = std::vector<int32_t>(P_MAX_TIME, 0);
   std::vector<int32_t> mPsigmaPadA = std::vector<int32_t>(P_MAX_SIGMA, 0);
   std::vector<int32_t> mPsigmaTimeA = std::vector<int32_t>(P_MAX_SIGMA, 0);
   std::vector<int32_t> mPqPtA = std::vector<int32_t>(P_MAX_QPT, 0);
-  std::vector<int32_t> mProwA = std::vector<int32_t>(GPUCA_NROWS, 0);
-  std::vector<int32_t> mPsectorA = std::vector<int32_t>(GPUCA_NSECTORS, 0);
+  std::vector<int32_t> mProwA = std::vector<int32_t>(GPUTPCGeometry::NROWS, 0);
+  std::vector<int32_t> mPsectorA = std::vector<int32_t>(GPUTPCGeometry::NSECTORS, 0);
   std::vector<int32_t> mPtimeA = std::vector<int32_t>(P_MAX_TIME, 0);
   std::vector<int32_t> mPpadA = std::vector<int32_t>(P_MAX_PAD, 0);
   std::vector<int32_t> mPqTotU = std::vector<int32_t>(P_MAX_QTOT, 0);
@@ -78,7 +78,7 @@ class GPUTPCClusterStatistics
   std::vector<int32_t> mPsigmaA = std::vector<int32_t>(P_MAX_SIGMA * P_MAX_SIGMA, 0);
   std::vector<int32_t> mPQU = std::vector<int32_t>(P_MAX_QMAX * P_MAX_QTOT, 0);
   std::vector<int32_t> mPQA = std::vector<int32_t>(P_MAX_QMAX * P_MAX_QTOT, 0);
-  std::vector<int32_t> mProwSectorA = std::vector<int32_t>(GPUCA_NROWS * GPUCA_NSECTORS * 2, 0);
+  std::vector<int32_t> mProwSectorA = std::vector<int32_t>(GPUTPCGeometry::NROWS * GPUTPCGeometry::NSECTORS * 2, 0);
 
   double mEntropy = 0;
   double mHuffman = 0;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
index 1b52a891ef6b1..00f1f6500e9f0 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.cxx
@@ -69,7 +69,7 @@ void GPUTPCCompression::SetPointersCompressedClusters(void*& mem, T& c, uint32_t
   computePointerWithAlignment(mem, c.timeDiffU, nClU);
   computePointerWithAlignment(mem, c.sigmaPadU, nClU);
   computePointerWithAlignment(mem, c.sigmaTimeU, nClU);
-  computePointerWithAlignment(mem, c.nSliceRowClusters, GPUCA_NROWS * NSECTORS);
+  computePointerWithAlignment(mem, c.nSliceRowClusters, GPUTPCGeometry::NROWS * NSECTORS);
 
   uint32_t nClAreduced = reducedClA ? nClA - nTr : nClA;
 
@@ -139,8 +139,8 @@ void GPUTPCCompression::DumpCompressedClusters(std::ostream& out)
   out << "Slice Row Clusters:\n";
   for (uint32_t i = 0; i < NSECTORS; i++) {
     out << "Sector " << i << ": ";
-    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
-      out << (O.nSliceRowClusters ? O.nSliceRowClusters[i * GPUCA_NROWS + j] : 0) << ", ";
+    for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
+      out << (O.nSliceRowClusters ? O.nSliceRowClusters[i * GPUTPCGeometry::NROWS + j] : 0) << ", ";
     }
     out << "\n";
   }
@@ -155,16 +155,16 @@ void GPUTPCCompression::DumpCompressedClusters(std::ostream& out)
   uint32_t offset = 0;
   if (O.nSliceRowClusters) {
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+      for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
         out << "Sector " << i << " Row " << j << ": ";
-        for (uint32_t k = 0; k < O.nSliceRowClusters[i * GPUCA_NROWS + j]; k++) {
+        for (uint32_t k = 0; k < O.nSliceRowClusters[i * GPUTPCGeometry::NROWS + j]; k++) {
           if (k && k % 10 == 0) {
             out << "\n    ";
           }
           const uint32_t l = k + offset;
           out << "[" << (uint32_t)O.qTotU[l] << ", " << (uint32_t)O.qMaxU[l] << ", " << (uint32_t)O.flagsU[l] << ", " << (int32_t)O.padDiffU[l] << ", " << (int32_t)O.timeDiffU[l] << ", " << (uint32_t)O.sigmaPadU[l] << ", " << (uint32_t)O.sigmaTimeU[l] << "] ";
         }
-        offset += O.nSliceRowClusters[i * GPUCA_NROWS + j];
+        offset += O.nSliceRowClusters[i * GPUTPCGeometry::NROWS + j];
         out << "\n";
       }
     }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
index 95173dad7257f..e84e2d65e1fc7 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
@@ -69,7 +69,7 @@ class GPUTPCCompression : public GPUProcessor
     uint32_t nStoredUnattachedClusters = 0;
   };
 
-  constexpr static uint32_t NSECTORS = GPUCA_NSECTORS;
+  constexpr static uint32_t NSECTORS = GPUTPCGeometry::NSECTORS;
 
   o2::tpc::CompressedClustersPtrs mPtrs;
   o2::tpc::CompressedClusters* mOutput = nullptr;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 92b367f7858b9..abf94746f5a72 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -73,7 +73,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
       float y = track.LinearPad2Y(hit.sector, orgCl.getPad(), geo.PadWidth(hit.row), geo.NPads(hit.row));
       float z = geo.LinearTime2Z(hit.sector, orgCl.getTime());
       if (nClustersStored) {
-        if ((hit.sector < GPUCA_NSECTORS) ^ (lastSector < GPUCA_NSECTORS)) {
+        if ((hit.sector < GPUTPCGeometry::NSECTORS) ^ (lastSector < GPUTPCGeometry::NSECTORS)) {
           break;
         }
         if (track.Propagate(geo.Row2X(hit.row), param.SectorParam[hit.sector].Alpha)) {
@@ -102,7 +102,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
 
         if (param.rec.tpc.compressionTypeMask & GPUSettings::CompressionDifferences) {
           if (lastRow > row) {
-            row += GPUCA_NROWS;
+            row += GPUTPCGeometry::NROWS;
           }
           row -= lastRow;
           if (lastSector > sector) {
@@ -112,7 +112,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
         }
         c.rowDiffA[cidx] = row;
         c.sliceLegDiffA[cidx] = sector;
-        float pad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_NROWS - 1), track.LinearY2Pad(hit.sector, track.Y(), geo.PadWidth(hit.row), geo.NPads(hit.row))));
+        float pad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUTPCGeometry::NROWS - 1), track.LinearY2Pad(hit.sector, track.Y(), geo.PadWidth(hit.row), geo.NPads(hit.row))));
         c.padResA[cidx] = orgCl.padPacked - orgCl.packPad(pad);
         float time = CAMath::Max(0.f, geo.LinearZ2Time(hit.sector, track.Z() + zOffset));
         c.timeResA[cidx] = (orgCl.getTimePacked() - orgCl.packTime(time)) & 0xFFFFFF;
@@ -221,9 +221,9 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
   GPUTPCCompression& GPUrestrict() compressor = processors.tpcCompressor;
   GPUParam& GPUrestrict() param = processors.param;
   uint32_t* sortBuffer = smem.sortBuffer;
-  for (int32_t iSectorRow = iBlock; iSectorRow < GPUCA_NSECTORS * GPUCA_NROWS; iSectorRow += nBlocks) {
-    const uint32_t iSector = iSectorRow / GPUCA_NROWS;
-    const uint32_t iRow = iSectorRow % GPUCA_NROWS;
+  for (uint32_t iSectorRow = iBlock; iSectorRow < GPUTPCGeometry::NSECTORS * GPUTPCGeometry::NROWS; iSectorRow += nBlocks) {
+    const uint32_t iSector = iSectorRow / GPUTPCGeometry::NROWS;
+    const uint32_t iRow = iSectorRow % GPUTPCGeometry::NROWS;
     const uint32_t idOffset = clusters->clusterOffset[iSector][iRow];
     const uint32_t idOffsetOut = clusters->clusterOffset[iSector][iRow] * compressor.mMaxClusterFactorBase1024 / 1024;                           // 32 bit enough for number of clusters per row * 1024
     const uint32_t idOffsetOutMax = ((const uint32_t*)clusters->clusterOffset[iSector])[iRow + 1] * compressor.mMaxClusterFactorBase1024 / 1024; // Array out of bounds access is ok, since it goes to the correct nClustersTotal
@@ -244,10 +244,10 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
       int32_t myIndex = work_group_scan_inclusive_add(storeCluster);
       int32_t storeLater = -1;
       if (storeCluster) {
-        if (smem.nCount + myIndex <= GPUCA_TPC_COMP_CHUNK_SIZE) {
+        if (smem.nCount + myIndex <= constants::TPC_COMP_CHUNK_SIZE) {
           sortBuffer[smem.nCount + myIndex - 1] = i;
         } else {
-          storeLater = smem.nCount + myIndex - 1 - GPUCA_TPC_COMP_CHUNK_SIZE;
+          storeLater = smem.nCount + myIndex - 1 - constants::TPC_COMP_CHUNK_SIZE;
         }
       }
       GPUbarrier();
@@ -256,11 +256,11 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
       }
       GPUbarrier();
 
-      if (smem.nCount < GPUCA_TPC_COMP_CHUNK_SIZE && i < nn) {
+      if (smem.nCount < constants::TPC_COMP_CHUNK_SIZE && i < nn) {
         continue;
       }
 
-      uint32_t count = CAMath::Min(smem.nCount, (uint32_t)GPUCA_TPC_COMP_CHUNK_SIZE);
+      uint32_t count = CAMath::Min(smem.nCount, (uint32_t)constants::TPC_COMP_CHUNK_SIZE);
       if (idOffsetOut + totalCount + count > idOffsetOutMax) {
         if (iThread == nThreads - 1) {
           compressor.raiseError(GPUErrors::ERROR_COMPRESSION_ROW_HIT_OVERFLOW, iSector * 1000 + iRow, idOffsetOut + totalCount + count, idOffsetOutMax);
@@ -269,7 +269,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
       }
       if (param.rec.tpc.compressionTypeMask & GPUSettings::CompressionDifferences) {
 #ifdef GPUCA_GPUCODE
-        static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= GPUCA_TPC_COMP_CHUNK_SIZE);
+        static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= constants::TPC_COMP_CHUNK_SIZE);
 #endif
 #ifdef GPUCA_DETERMINISTIC_MODE // Not using GPUCA_DETERMINISTIC_CODE, which is enforced in TPC compression
         CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>(clusters->clusters[iSector][iRow]));
@@ -321,7 +321,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
     }
 
     if (iThread == nThreads - 1) {
-      c.nSliceRowClusters[iSector * GPUCA_NROWS + iRow] = totalCount;
+      c.nSliceRowClusters[iSector * GPUTPCGeometry::NROWS + iRow] = totalCount;
       CAMath::AtomicAdd(&compressor.mMemory->nStoredUnattachedClusters, totalCount);
     }
     GPUbarrier();
@@ -547,7 +547,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::Thread<GPUTPCCompressionGatherKern
 
   if (iBlock == 0) {
 
-    uint32_t nRows = compressor.NSECTORS * GPUCA_NROWS;
+    uint32_t nRows = compressor.NSECTORS * GPUTPCGeometry::NROWS;
     uint32_t rowsPerWarp = (nRows + nWarps - 1) / nWarps;
     uint32_t rowStart = rowsPerWarp * iWarp;
     uint32_t rowEnd = CAMath::Min(nRows, rowStart + rowsPerWarp);
@@ -558,7 +558,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::Thread<GPUTPCCompressionGatherKern
 
     uint32_t rowsOffset = calculateWarpOffsets(smem, compressor.mPtrs.nSliceRowClusters, rowStart, rowEnd, nWarps, iWarp, nLanes, iLane);
 
-    compressorMemcpy(compressor.mOutput->nSliceRowClusters, compressor.mPtrs.nSliceRowClusters, compressor.NSECTORS * GPUCA_NROWS, nThreads, iThread);
+    compressorMemcpy(compressor.mOutput->nSliceRowClusters, compressor.mPtrs.nSliceRowClusters, compressor.NSECTORS * GPUTPCGeometry::NROWS, nThreads, iThread);
     compressorMemcpy(compressor.mOutput->nTrackClusters, compressor.mPtrs.nTrackClusters, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpy(compressor.mOutput->qPtA, compressor.mPtrs.qPtA, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpy(compressor.mOutput->rowA, compressor.mPtrs.rowA, compressor.mMemory->nStoredTracks, nThreads, iThread);
@@ -566,15 +566,15 @@ GPUdii() void GPUTPCCompressionGatherKernels::Thread<GPUTPCCompressionGatherKern
     compressorMemcpy(compressor.mOutput->timeA, compressor.mPtrs.timeA, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpy(compressor.mOutput->padA, compressor.mPtrs.padA, compressor.mMemory->nStoredTracks, nThreads, iThread);
 
-    uint32_t sectorStart = rowStart / GPUCA_NROWS;
-    uint32_t sectorEnd = rowEnd / GPUCA_NROWS;
+    uint32_t sectorStart = rowStart / GPUTPCGeometry::NROWS;
+    uint32_t sectorEnd = rowEnd / GPUTPCGeometry::NROWS;
 
-    uint32_t sectorRowStart = rowStart % GPUCA_NROWS;
-    uint32_t sectorRowEnd = rowEnd % GPUCA_NROWS;
+    uint32_t sectorRowStart = rowStart % GPUTPCGeometry::NROWS;
+    uint32_t sectorRowEnd = rowEnd % GPUTPCGeometry::NROWS;
 
     for (uint32_t i = sectorStart; i <= sectorEnd && i < compressor.NSECTORS; i++) {
-      for (uint32_t j = ((i == sectorStart) ? sectorRowStart : 0); j < ((i == sectorEnd) ? sectorRowEnd : GPUCA_NROWS); j++) {
-        uint32_t nClusters = compressor.mPtrs.nSliceRowClusters[i * GPUCA_NROWS + j];
+      for (uint32_t j = ((i == sectorStart) ? sectorRowStart : 0); j < ((i == sectorEnd) ? sectorRowEnd : GPUTPCGeometry::NROWS); j++) {
+        uint32_t nClusters = compressor.mPtrs.nSliceRowClusters[i * GPUTPCGeometry::NROWS + j];
         uint32_t clusterOffsetInCache = clusters->clusterOffset[i][j] * compressor.mMaxClusterFactorBase1024 / 1024;
         compressorMemcpy(compressor.mOutput->qTotU + rowsOffset, compressor.mPtrs.qTotU + clusterOffsetInCache, nClusters, nLanes, iLane);
         compressorMemcpy(compressor.mOutput->qMaxU + rowsOffset, compressor.mPtrs.qMaxU + clusterOffsetInCache, nClusters, nLanes, iLane);
@@ -653,7 +653,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::gatherBuffered(int32_t nBlocks, in
   auto& input = compressor.mPtrs;
   auto* output = compressor.mOutput;
 
-  uint32_t nRows = compressor.NSECTORS * GPUCA_NROWS;
+  uint32_t nRows = compressor.NSECTORS * GPUTPCGeometry::NROWS;
   uint32_t rowsPerWarp = (nRows + nGlobalWarps - 1) / nGlobalWarps;
   uint32_t rowStart = rowsPerWarp * iGlobalWarp;
   uint32_t rowEnd = CAMath::Min(nRows, rowStart + rowsPerWarp);
@@ -678,7 +678,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::gatherBuffered(int32_t nBlocks, in
   uint32_t tracksOffset = calculateWarpOffsets(smem, input.nTrackClusters, trackStart, trackEnd, nWarps, iWarp, nLanes, iLane);
 
   if (iBlock == 0) {
-    compressorMemcpyBasic(output->nSliceRowClusters, input.nSliceRowClusters, compressor.NSECTORS * GPUCA_NROWS, nThreads, iThread);
+    compressorMemcpyBasic(output->nSliceRowClusters, input.nSliceRowClusters, compressor.NSECTORS * GPUTPCGeometry::NROWS, nThreads, iThread);
     compressorMemcpyBasic(output->nTrackClusters, input.nTrackClusters, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpyBasic(output->qPtA, input.qPtA, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpyBasic(output->rowA, input.rowA, compressor.mMemory->nStoredTracks, nThreads, iThread);
@@ -731,7 +731,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::gatherMulti(int32_t nBlocks, int32
   auto* buf = smem.getBuffer<Vec128>(iWarp);
 
   if (iBlock == 0) {
-    compressorMemcpyBasic(output->nSliceRowClusters, input.nSliceRowClusters, compressor.NSECTORS * GPUCA_NROWS, nThreads, iThread);
+    compressorMemcpyBasic(output->nSliceRowClusters, input.nSliceRowClusters, compressor.NSECTORS * GPUTPCGeometry::NROWS, nThreads, iThread);
     compressorMemcpyBasic(output->nTrackClusters, input.nTrackClusters, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpyBasic(output->qPtA, input.qPtA, compressor.mMemory->nStoredTracks, nThreads, iThread);
     compressorMemcpyBasic(output->rowA, input.rowA, compressor.mMemory->nStoredTracks, nThreads, iThread);
@@ -742,7 +742,7 @@ GPUdii() void GPUTPCCompressionGatherKernels::gatherMulti(int32_t nBlocks, int32
     const uint32_t nGlobalWarps = nWarps * (nBlocks - 1) / 2;
     const uint32_t iGlobalWarp = nWarps * (iBlock - 1) / 2 + iWarp;
 
-    const uint32_t nRows = compressor.NSECTORS * GPUCA_NROWS;
+    const uint32_t nRows = compressor.NSECTORS * GPUTPCGeometry::NROWS;
     uint32_t rowsPerWarp = (nRows + nGlobalWarps - 1) / nGlobalWarps;
     uint32_t rowStart = rowsPerWarp * iGlobalWarp;
     uint32_t rowEnd = CAMath::Min(nRows, rowStart + rowsPerWarp);
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
index 2236f15af9725..1edf718de8128 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.h
@@ -37,7 +37,7 @@ class GPUTPCCompressionKernels : public GPUKernelTemplate
   struct GPUSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<int32_t, GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached)> {
     GPUAtomic(uint32_t) nCount;
     uint32_t lastIndex;
-    uint32_t sortBuffer[GPUCA_TPC_COMP_CHUNK_SIZE];
+    uint32_t sortBuffer[constants::TPC_COMP_CHUNK_SIZE];
   };
 
   template <int32_t iKernel = defaultKernel>
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.cxx
index ab7b0c99e09df..1fe22e0e88137 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.cxx
@@ -26,7 +26,7 @@ using namespace o2::gpu;
 GPUd() void GPUTPCCompressionTrackModel::Init(float x, float y, float z, float alpha, uint8_t qPt, const GPUParam& GPUrestrict() param)
 {
   mProp.SetMaterialTPC();
-  mProp.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
+  mProp.SetMaxSinPhi(constants::MAX_SIN_PHI);
   mProp.SetSeedingErrors(true); // Larger errors for seeds, better since we don't start with good hypothesis
   mProp.SetFitInProjections(true);
   mProp.SetPropagateBzOnly(true);
@@ -87,10 +87,10 @@ GPUd() void GPUTPCCompressionTrackModel::Init(float x, float y, float z, float a
 GPUd() int32_t GPUTPCCompressionTrackModel::Propagate(float x, float alpha)
 {
   GPUTPCTrackLinearisation t0(mTrk);
-  if (alpha != mAlpha && !mTrk.Rotate(alpha, t0, GPUCA_MAX_SIN_PHI)) {
+  if (alpha != mAlpha && !mTrk.Rotate(alpha, t0, constants::MAX_SIN_PHI)) {
     return 2;
   }
-  int32_t retVal = !mTrk.TransportToX(x, t0, mParam->bzCLight, GPUCA_MAX_SIN_PHI);
+  int32_t retVal = !mTrk.TransportToX(x, t0, mParam->bzCLight, constants::MAX_SIN_PHI);
   // GPUInfo("Propagated to: x %f y %f z %f alpha %f qPt %f", x, mTrk.Y(), mTrk.Z(), alpha, mTrk.QPt());
   return retVal;
 }
@@ -100,7 +100,7 @@ GPUd() int32_t GPUTPCCompressionTrackModel::Filter(float y, float z, int32_t iRo
   mTrk.ConstrainSinPhi();
   float err2Y, err2Z;
   GPUTPCTracker::GetErrors2Seeding(*mParam, iRow, mTrk, -1.f, err2Y, err2Z);
-  int32_t retVal = !mTrk.Filter(y, z, err2Y, err2Z, GPUCA_MAX_SIN_PHI, false);
+  int32_t retVal = !mTrk.Filter(y, z, err2Y, err2Z, constants::MAX_SIN_PHI, false);
   // GPUInfo("Filtered with %f %f: y %f z %f qPt %f", y, z, mTrk.Y(), mTrk.Z(), mTrk.QPt());
   return retVal;
 }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.h b/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.h
index b3b4da27e625b..d919baa6f75b3 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.h
@@ -100,15 +100,15 @@ class GPUTPCCompressionTrackModel
   GPUd() void getClusterErrors2(int32_t iRow, float z, float sinPhi, float DzDs, float& ErrY2, float& ErrZ2) const;
   GPUd() void resetCovariance();
 
-  GPUd() float LinearPad2Y(int32_t sector, float pad, float padWidth, uint8_t npads) const
+  GPUd() float LinearPad2Y(uint32_t sector, float pad, float padWidth, uint8_t npads) const
   {
     const float u = (pad - 0.5f * npads) * padWidth;
-    return (sector >= GPUCA_NSECTORS / 2) ? -u : u;
+    return (sector >= GPUTPCGeometry::NSECTORS / 2) ? -u : u;
   }
 
-  GPUd() float LinearY2Pad(int32_t sector, float y, float padWidth, uint8_t npads) const
+  GPUd() float LinearY2Pad(uint32_t sector, float y, float padWidth, uint8_t npads) const
   {
-    const float u = (sector >= GPUCA_NSECTORS / 2) ? -y : y;
+    const float u = (sector >= GPUTPCGeometry::NSECTORS / 2) ? -y : y;
     return u / padWidth + 0.5f * npads;
   }
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
index 52fd4858820b3..e28718e6b6755 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
@@ -40,7 +40,7 @@ void GPUTPCDecompression::SetPointersCompressedClusters(void*& mem, T& c, uint32
   computePointerWithAlignment(mem, c.timeDiffU, nClU);
   computePointerWithAlignment(mem, c.sigmaPadU, nClU);
   computePointerWithAlignment(mem, c.sigmaTimeU, nClU);
-  computePointerWithAlignment(mem, c.nSliceRowClusters, GPUCA_NROWS * NSECTORS);
+  computePointerWithAlignment(mem, c.nSliceRowClusters, GPUTPCGeometry::NROWS * NSECTORS);
 
   uint32_t nClAreduced = reducedClA ? nClA - nTr : nClA;
 
@@ -68,19 +68,19 @@ void GPUTPCDecompression::SetPointersCompressedClusters(void*& mem, T& c, uint32
 
 void* GPUTPCDecompression::SetPointersTmpNativeBuffersGPU(void* mem)
 {
-  computePointerWithAlignment(mem, mTmpNativeClusters, NSECTORS * GPUCA_NROWS * mMaxNativeClustersPerBuffer);
+  computePointerWithAlignment(mem, mTmpNativeClusters, NSECTORS * GPUTPCGeometry::NROWS * mMaxNativeClustersPerBuffer);
   return mem;
 }
 
 void* GPUTPCDecompression::SetPointersTmpNativeBuffersOutput(void* mem)
 {
-  computePointerWithAlignment(mem, mNativeClustersIndex, NSECTORS * GPUCA_NROWS);
+  computePointerWithAlignment(mem, mNativeClustersIndex, NSECTORS * GPUTPCGeometry::NROWS);
   return mem;
 }
 
 void* GPUTPCDecompression::SetPointersTmpNativeBuffersInput(void* mem)
 {
-  computePointerWithAlignment(mem, mUnattachedClustersOffsets, NSECTORS * GPUCA_NROWS);
+  computePointerWithAlignment(mem, mUnattachedClustersOffsets, NSECTORS * GPUTPCGeometry::NROWS);
   computePointerWithAlignment(mem, mAttachedClustersOffsets, mInputGPU.nTracks);
   return mem;
 }
@@ -99,7 +99,7 @@ void* GPUTPCDecompression::SetPointersInputClusterNativeAccess(void* mem)
 
 void* GPUTPCDecompression::SetPointersNClusterPerSectorRow(void* mem)
 {
-  computePointerWithAlignment(mem, mNClusterPerSectorRow, NSECTORS * GPUCA_NROWS);
+  computePointerWithAlignment(mem, mNClusterPerSectorRow, NSECTORS * GPUTPCGeometry::NROWS);
   return mem;
 }
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.h b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.h
index e6f8377a246e2..f99fdc8b8c9c0 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.h
@@ -49,7 +49,7 @@ class GPUTPCDecompression : public GPUProcessor
 #endif
 
  protected:
-  constexpr static uint32_t NSECTORS = GPUCA_NSECTORS;
+  constexpr static uint32_t NSECTORS = GPUTPCGeometry::NSECTORS;
   o2::tpc::CompressedClusters mInputGPU;
 
   uint32_t mMaxNativeClustersPerBuffer;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
index f15bc8d4f3406..0d2140c32e4a9 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.cxx
@@ -45,10 +45,10 @@ GPUdii() void GPUTPCDecompressionKernels::Thread<GPUTPCDecompressionKernels::ste
   ClusterNative* GPUrestrict() clusterBuffer = decompressor.mNativeClustersBuffer;
   const ClusterNativeAccess* outputAccess = decompressor.mClusterNativeAccess;
   uint32_t* offsets = decompressor.mUnattachedClustersOffsets;
-  for (int32_t i = get_global_id(0); i < GPUCA_NROWS * nSectors; i += get_global_size(0)) {
-    uint32_t iRow = i % GPUCA_NROWS;
-    uint32_t iSector = sectorStart + (i / GPUCA_NROWS);
-    const uint32_t linearIndex = iSector * GPUCA_NROWS + iRow;
+  for (uint32_t i = get_global_id(0); i < GPUTPCGeometry::NROWS * nSectors; i += get_global_size(0)) {
+    uint32_t iRow = i % GPUTPCGeometry::NROWS;
+    uint32_t iSector = sectorStart + (i / GPUTPCGeometry::NROWS);
+    const uint32_t linearIndex = iSector * GPUTPCGeometry::NROWS + iRow;
     uint32_t tmpBufferIndex = computeLinearTmpBufferIndex(iSector, iRow, decompressor.mMaxNativeClustersPerBuffer);
     ClusterNative* buffer = clusterBuffer + outputAccess->clusterOffset[iSector][iRow];
     if (decompressor.mNativeClustersIndex[linearIndex] != 0) {
@@ -105,9 +105,9 @@ GPUdii() void GPUTPCDecompressionUtilKernels::Thread<GPUTPCDecompressionUtilKern
   const GPUParam& GPUrestrict() param = processors.param;
   GPUTPCDecompression& GPUrestrict() decompressor = processors.tpcDecompressor;
   const ClusterNativeAccess* clusterAccess = decompressor.mClusterNativeAccess;
-  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_NROWS; i += get_global_size(0)) {
-    uint32_t sector = i / GPUCA_NROWS;
-    uint32_t row = i % GPUCA_NROWS;
+  for (uint32_t i = get_global_id(0); i < GPUTPCGeometry::NSECTORS * GPUTPCGeometry::NROWS; i += get_global_size(0)) {
+    uint32_t sector = i / GPUTPCGeometry::NROWS;
+    uint32_t row = i % GPUTPCGeometry::NROWS;
     for (uint32_t k = 0; k < clusterAccess->nClusters[sector][row]; k++) {
       ClusterNative cl = clusterAccess->clusters[sector][row][k];
       if (isClusterKept(cl, param)) {
@@ -125,9 +125,9 @@ GPUdii() void GPUTPCDecompressionUtilKernels::Thread<GPUTPCDecompressionUtilKern
   ClusterNative* GPUrestrict() clusterBuffer = decompressor.mNativeClustersBuffer;
   const ClusterNativeAccess* clusterAccess = decompressor.mClusterNativeAccess;
   const ClusterNativeAccess* outputAccess = processors.ioPtrs.clustersNative;
-  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_NROWS; i += get_global_size(0)) {
-    uint32_t sector = i / GPUCA_NROWS;
-    uint32_t row = i % GPUCA_NROWS;
+  for (uint32_t i = get_global_id(0); i < GPUTPCGeometry::NSECTORS * GPUTPCGeometry::NROWS; i += get_global_size(0)) {
+    uint32_t sector = i / GPUTPCGeometry::NROWS;
+    uint32_t row = i % GPUTPCGeometry::NROWS;
     uint32_t count = 0;
     for (uint32_t k = 0; k < clusterAccess->nClusters[sector][row]; k++) {
       const ClusterNative cl = clusterAccess->clusters[sector][row][k];
@@ -144,9 +144,9 @@ GPUdii() void GPUTPCDecompressionUtilKernels::Thread<GPUTPCDecompressionUtilKern
 {
   ClusterNative* GPUrestrict() clusterBuffer = processors.tpcDecompressor.mNativeClustersBuffer;
   const ClusterNativeAccess* outputAccess = processors.ioPtrs.clustersNative;
-  for (uint32_t i = get_global_id(0); i < GPUCA_NSECTORS * GPUCA_NROWS; i += get_global_size(0)) {
-    uint32_t sector = i / GPUCA_NROWS;
-    uint32_t row = i % GPUCA_NROWS;
+  for (uint32_t i = get_global_id(0); i < GPUTPCGeometry::NSECTORS * GPUTPCGeometry::NROWS; i += get_global_size(0)) {
+    uint32_t sector = i / GPUTPCGeometry::NROWS;
+    uint32_t row = i % GPUTPCGeometry::NROWS;
     ClusterNative* buffer = clusterBuffer + outputAccess->clusterOffset[sector][row];
     GPUCommonAlgorithm::sort(buffer, buffer + outputAccess->nClusters[sector][row]);
   }
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
index 48d92f1b2a69a..03fcfebacdaa9 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompressionKernels.h
@@ -39,7 +39,7 @@ class GPUTPCDecompressionKernels : public GPUKernelTemplate
 
   GPUd() static uint32_t computeLinearTmpBufferIndex(uint32_t sector, uint32_t row, uint32_t maxClustersPerBuffer)
   {
-    return sector * (GPUCA_NROWS * maxClustersPerBuffer) + row * maxClustersPerBuffer;
+    return sector * (GPUTPCGeometry::NROWS * maxClustersPerBuffer) + row * maxClustersPerBuffer;
   }
 
   template <typename T>
diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc b/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
index 1ed04269c2cc9..3089a454c048b 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
@@ -48,7 +48,7 @@ class TPCClusterDecompressionCore
     return clusterVector.back();
   }
 
-  GPUhi() static auto decompressTrackStore(const CompressedClusters& clustersCompressed, const uint32_t offset, uint32_t slice, uint32_t row, uint32_t pad, uint32_t time, std::vector<ClusterNative> (&clusters)[GPUCA_NSECTORS][GPUCA_NROWS], std::atomic_flag (&locks)[GPUCA_NSECTORS][GPUCA_NROWS])
+  GPUhi() static auto decompressTrackStore(const CompressedClusters& clustersCompressed, const uint32_t offset, uint32_t slice, uint32_t row, uint32_t pad, uint32_t time, std::vector<ClusterNative> (&clusters)[GPUTPCGeometry::NSECTORS][GPUTPCGeometry::NROWS], std::atomic_flag (&locks)[GPUTPCGeometry::NSECTORS][GPUTPCGeometry::NROWS])
   {
     std::vector<ClusterNative>& clusterVector = clusters[slice][row];
     auto& lock = locks[slice][row];
@@ -62,14 +62,14 @@ class TPCClusterDecompressionCore
 
   GPUdi() static ClusterNative decompressTrackStore(const CompressedClusters& cmprClusters, const uint32_t clusterOffset, uint32_t slice, uint32_t row, uint32_t pad, uint32_t time, GPUTPCDecompression& decompressor)
   {
-    uint32_t tmpBufferIndex = slice * (GPUCA_NROWS * decompressor.mMaxNativeClustersPerBuffer) + row * decompressor.mMaxNativeClustersPerBuffer;
-    uint32_t currentClusterIndex = CAMath::AtomicAdd(decompressor.mNativeClustersIndex + (slice * GPUCA_NROWS + row), 1u);
+    uint32_t tmpBufferIndex = slice * (GPUTPCGeometry::NROWS * decompressor.mMaxNativeClustersPerBuffer) + row * decompressor.mMaxNativeClustersPerBuffer;
+    uint32_t currentClusterIndex = CAMath::AtomicAdd(decompressor.mNativeClustersIndex + (slice * GPUTPCGeometry::NROWS + row), 1u);
     const ClusterNative c(time, cmprClusters.flagsA[clusterOffset], pad, cmprClusters.sigmaTimeA[clusterOffset], cmprClusters.sigmaPadA[clusterOffset], cmprClusters.qMaxA[clusterOffset], cmprClusters.qTotA[clusterOffset]);
     if (currentClusterIndex < decompressor.mMaxNativeClustersPerBuffer) {
       decompressor.mTmpNativeClusters[tmpBufferIndex + currentClusterIndex] = c;
     } else {
       decompressor.raiseError(GPUErrors::ERROR_DECOMPRESSION_ATTACHED_CLUSTER_OVERFLOW, slice * 1000 + row, currentClusterIndex, decompressor.mMaxNativeClustersPerBuffer);
-      CAMath::AtomicExch(decompressor.mNativeClustersIndex + (slice * GPUCA_NROWS + row), decompressor.mMaxNativeClustersPerBuffer);
+      CAMath::AtomicExch(decompressor.mNativeClustersIndex + (slice * GPUTPCGeometry::NROWS + row), decompressor.mMaxNativeClustersPerBuffer);
     }
     return c;
   }
@@ -87,18 +87,18 @@ class TPCClusterDecompressionCore
       uint32_t pad = 0, time = 0;
       if (clusterIndex != 0) {
         uint8_t tmpSlice = cmprClusters.sliceLegDiffA[clusterOffset - trackIndex - 1];
-        bool changeLeg = (tmpSlice >= GPUCA_NSECTORS);
+        bool changeLeg = (tmpSlice >= GPUTPCGeometry::NSECTORS);
         if (changeLeg) {
-          tmpSlice -= GPUCA_NSECTORS;
+          tmpSlice -= GPUTPCGeometry::NSECTORS;
         }
         if (cmprClusters.nComppressionModes & GPUSettings::CompressionDifferences) {
           slice += tmpSlice;
-          if (slice >= GPUCA_NSECTORS) {
-            slice -= GPUCA_NSECTORS;
+          if (slice >= GPUTPCGeometry::NSECTORS) {
+            slice -= GPUTPCGeometry::NSECTORS;
           }
           row += cmprClusters.rowDiffA[clusterOffset - trackIndex - 1];
-          if (row >= GPUCA_NROWS) {
-            row -= GPUCA_NROWS;
+          if (row >= GPUTPCGeometry::NROWS) {
+            row -= GPUTPCGeometry::NROWS;
           }
         } else {
           slice = tmpSlice;
@@ -115,7 +115,7 @@ class TPCClusterDecompressionCore
           timeTmp |= 0xFF000000;
         }
         time = timeTmp + ClusterNative::packTime(CAMath::Max(0.f, geo.LinearZ2Time(slice, track.Z() + zOffset)));
-        float tmpPad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUCA_NROWS - 1), track.LinearY2Pad(slice, track.Y(), geo.PadWidth(row), geo.NPads(row))));
+        float tmpPad = CAMath::Max(0.f, CAMath::Min((float)geo.NPads(GPUTPCGeometry::NROWS - 1), track.LinearY2Pad(slice, track.Y(), geo.PadWidth(row), geo.NPads(row))));
         pad = cmprClusters.padResA[clusterOffset - trackIndex - 1] + ClusterNative::packPad(tmpPad);
         time = time & 0xFFFFFF;
         pad = (uint16_t)pad;
diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
index 747d7f6904be3..e28b4c476f815 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.cxx
@@ -48,12 +48,12 @@ int32_t TPCClusterDecompressor::decompress(const CompressedClusters* clustersCom
   if (clustersCompressed->nTracks && clustersCompressed->maxTimeBin != -1e6 && clustersCompressed->maxTimeBin != param.continuousMaxTimeBin) {
     throw std::runtime_error("Configured max time bin " + std::to_string(param.continuousMaxTimeBin) + " does not match value used for track model encoding " + std::to_string(clustersCompressed->maxTimeBin));
   }
-  std::vector<ClusterNative> clusters[NSECTORS][GPUCA_NROWS];
-  std::atomic_flag locks[NSECTORS][GPUCA_NROWS];
-  for (uint32_t i = 0; i < NSECTORS * GPUCA_NROWS; i++) {
+  std::vector<ClusterNative> clusters[NSECTORS][GPUTPCGeometry::NROWS];
+  std::atomic_flag locks[NSECTORS][GPUTPCGeometry::NROWS];
+  for (uint32_t i = 0; i < NSECTORS * GPUTPCGeometry::NROWS; i++) {
     (&locks[0][0])[i].clear();
   }
-  const uint32_t maxTime = param.continuousMaxTimeBin > 0 ? ((param.continuousMaxTimeBin + 1) * ClusterNative::scaleTimePacked - 1) : TPC_MAX_TIME_BIN_TRIGGERED;
+  const uint32_t maxTime = param.continuousMaxTimeBin > 0 ? ((param.continuousMaxTimeBin + 1) * ClusterNative::scaleTimePacked - 1) : constants::TPC_MAX_TIME_BIN_TRIGGERED;
   tbb::parallel_for(tbb::blocked_range<uint32_t>(0, clustersCompressed->nTracks), [&](const tbb::blocked_range<uint32_t>& range) {
     uint32_t offset = 0, lasti = 0;
     for (uint32_t i = range.begin(); i < range.end(); i++) {
@@ -69,14 +69,14 @@ int32_t TPCClusterDecompressor::decompress(const CompressedClusters* clustersCom
   });
   size_t nTotalClusters = clustersCompressed->nAttachedClusters + clustersCompressed->nUnattachedClusters;
   ClusterNative* clusterBuffer = allocator(nTotalClusters);
-  uint32_t offsets[NSECTORS][GPUCA_NROWS];
+  uint32_t offsets[NSECTORS][GPUTPCGeometry::NROWS];
   uint32_t offset = 0;
   uint32_t decodedAttachedClusters = 0;
   for (uint32_t i = 0; i < NSECTORS; i++) {
-    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
-      clustersNative.nClusters[i][j] = clusters[i][j].size() + ((i * GPUCA_NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_NROWS + j]);
+    for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
+      clustersNative.nClusters[i][j] = clusters[i][j].size() + ((i * GPUTPCGeometry::NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j]);
       offsets[i][j] = offset;
-      offset += (i * GPUCA_NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_NROWS + j];
+      offset += (i * GPUTPCGeometry::NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j];
       decodedAttachedClusters += clusters[i][j].size();
     }
   }
@@ -86,13 +86,13 @@ int32_t TPCClusterDecompressor::decompress(const CompressedClusters* clustersCom
   clustersNative.clustersLinear = clusterBuffer;
   clustersNative.setOffsetPtrs();
   tbb::parallel_for<uint32_t>(0, NSECTORS, [&](auto i) {
-    for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+    for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
       ClusterNative* buffer = &clusterBuffer[clustersNative.clusterOffset[i][j]];
       if (clusters[i][j].size()) {
         memcpy((void*)buffer, (const void*)clusters[i][j].data(), clusters[i][j].size() * sizeof(clusterBuffer[0]));
       }
       ClusterNative* clout = buffer + clusters[i][j].size();
-      uint32_t end = offsets[i][j] + ((i * GPUCA_NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUCA_NROWS + j]);
+      uint32_t end = offsets[i][j] + ((i * GPUTPCGeometry::NROWS + j >= clustersCompressed->nSliceRows) ? 0 : clustersCompressed->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j]);
       TPCClusterDecompressionCore::decompressHits(*clustersCompressed, offsets[i][j], end, clout);
       if (param.rec.tpc.clustersEdgeFixDistance > 0.f) {
         constexpr GPUTPCGeometry geo;
diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.h b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.h
index 0c54f34c0237a..723a97341a53b 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.h
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressor.h
@@ -32,7 +32,7 @@ struct GPUParam;
 class TPCClusterDecompressor
 {
  public:
-  static constexpr uint32_t NSECTORS = GPUCA_NSECTORS;
+  static constexpr uint32_t NSECTORS = GPUTPCGeometry::NSECTORS;
   static int32_t decompress(const o2::tpc::CompressedClustersFlat* clustersCompressed, o2::tpc::ClusterNativeAccess& clustersNative, std::function<o2::tpc::ClusterNative*(size_t)> allocator, const GPUParam& param, bool deterministicRec);
   static int32_t decompress(const o2::tpc::CompressedClusters* clustersCompressed, o2::tpc::ClusterNativeAccess& clustersNative, std::function<o2::tpc::ClusterNative*(size_t)> allocator, const GPUParam& param, bool deterministicRec);
 };
diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
index 6cbfe9e1cd402..5c908529fdde9 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
@@ -68,10 +68,10 @@ size_t GPUMemorySizeScalers::getValue(size_t maxVal, size_t val)
   return returnMaxVal ? maxVal : (std::min<size_t>(maxVal, offset + val) * (doFuzzing == 0 ? scalingFactor : getScalingFactor()) * temporaryFactor);
 }
 
-size_t GPUMemorySizeScalers::NTPCPeaks(size_t tpcDigits, bool perSector) { return getValue(perSector ? tpcMaxPeaks : (GPUCA_NSECTORS * tpcMaxPeaks), hitOffset + tpcDigits * tpcPeaksPerDigit); }
+size_t GPUMemorySizeScalers::NTPCPeaks(size_t tpcDigits, bool perSector) { return getValue(perSector ? tpcMaxPeaks : (GPUTPCGeometry::NSECTORS * tpcMaxPeaks), hitOffset + tpcDigits * tpcPeaksPerDigit); }
 size_t GPUMemorySizeScalers::NTPCClusters(size_t tpcDigits, bool perSector) { return getValue(perSector ? tpcMaxSectorClusters : tpcMaxClusters, (conservativeMemoryEstimate ? 1.0 : tpcClustersPerPeak) * NTPCPeaks(tpcDigits, perSector)); }
 size_t GPUMemorySizeScalers::NTPCStartHits(size_t tpcHits) { return getValue(tpcMaxStartHits, tpcHits * tpcStartHitsPerHit); }
-size_t GPUMemorySizeScalers::NTPCRowStartHits(size_t tpcHits) { return getValue(tpcMaxRowStartHits, std::max<size_t>(NTPCStartHits(tpcHits) * (tpcHits < 30000000 ? 20 : 12) / GPUCA_NROWS, tpcMinRowStartHits)); }
+size_t GPUMemorySizeScalers::NTPCRowStartHits(size_t tpcHits) { return getValue(tpcMaxRowStartHits, std::max<size_t>(NTPCStartHits(tpcHits) * (tpcHits < 30000000 ? 20 : 12) / GPUTPCGeometry::NROWS, tpcMinRowStartHits)); }
 size_t GPUMemorySizeScalers::NTPCTracklets(size_t tpcHits, bool lowField) { return getValue(tpcMaxTracklets, NTPCStartHits(tpcHits) * (lowField ? tpcTrackletsPerStartHitLowField : tpcTrackletsPerStartHit)); }
 size_t GPUMemorySizeScalers::NTPCTrackletHits(size_t tpcHits, bool lowField) { return getValue(tpcMaxTrackletHits, hitOffset + tpcHits * (lowField ? tpcTrackletHitsPerHitLowField : tpcTrackletHitsPerHit)); }
 size_t GPUMemorySizeScalers::NTPCSectorTracks(size_t tpcHits) { return getValue(tpcMaxSectorTracks, tpcHits * tpcSectorTracksPerHit); }
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.cxx b/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.cxx
index 58a52589404d8..21ed94844e130 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.cxx
@@ -22,7 +22,7 @@ GPUd() uint32_t GPUTPCClusterOccupancyMapBin::getNBins(const GPUParam& param)
   if (param.rec.tpc.occupancyMapTimeBins == 0) {
     return 0;
   }
-  uint32_t maxTimeBin = param.par.continuousTracking ? param.continuousMaxTimeBin : TPC_MAX_TIME_BIN_TRIGGERED;
+  uint32_t maxTimeBin = param.par.continuousTracking ? param.continuousMaxTimeBin : constants::TPC_MAX_TIME_BIN_TRIGGERED;
   return (maxTimeBin + param.rec.tpc.occupancyMapTimeBins) / param.rec.tpc.occupancyMapTimeBins; // Not -1, since maxTimeBin is allowed
 }
 
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h b/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
index 84334f1807493..b45d1ed43622f 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
@@ -16,13 +16,13 @@
 #define GPUTPCCLUSTEROCCUPANCYMAP_H
 
 #include "GPUCommonDef.h"
-#include "GPUDefConstantsAndSettings.h"
+#include "GPUTPCGeometry.h"
 
 namespace o2::gpu
 {
 struct GPUParam;
 struct GPUTPCClusterOccupancyMapBin {
-  uint16_t bin[GPUCA_NSECTORS][GPUCA_NROWS];
+  uint16_t bin[GPUTPCGeometry::NSECTORS][GPUTPCGeometry::NROWS];
 
   GPUd() static uint32_t getNBins(const GPUParam& param);
   GPUd() static uint32_t getTotalSize(const GPUParam& param);
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
index 47f8ba42373b5..a203b55157401 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
@@ -16,12 +16,7 @@
 #define GPUTPCGEOMETRY_H
 
 #include "GPUCommonDef.h"
-
-#if !defined(GPUCA_NSECTORS) && !defined(GPUCA_NROWS)
 #include "DataFormatsTPC/Constants.h"
-#define GPUCA_NSECTORS o2::tpc::constants::MAXSECTOR
-#define GPUCA_NROWS o2::tpc::constants::MAXGLOBALPADROW
-#endif
 
 namespace o2::gpu
 {
@@ -29,8 +24,8 @@ namespace o2::gpu
 
 namespace gputpcgeometry_internal
 {
-#ifndef GPUCA_RUN2 // clang-format: off
-GPUconstexpr() float mX[GPUCA_NROWS] = {85.225f, 85.975f, 86.725f, 87.475f, 88.225f, 88.975f, 89.725f, 90.475f, 91.225f, 91.975f, 92.725f, 93.475f, 94.225f, 94.975f, 95.725f, 96.475f, 97.225f, 97.975f, 98.725f, 99.475f, 100.225f, 100.975f,
+#ifndef GPUCA_RUN2 // clang-format off
+GPUconstexpr() float mX[o2::tpc::constants::MAXGLOBALPADROW] = {85.225f, 85.975f, 86.725f, 87.475f, 88.225f, 88.975f, 89.725f, 90.475f, 91.225f, 91.975f, 92.725f, 93.475f, 94.225f, 94.975f, 95.725f, 96.475f, 97.225f, 97.975f, 98.725f, 99.475f, 100.225f, 100.975f,
                                         101.725f, 102.475f, 103.225f, 103.975f, 104.725f, 105.475f, 106.225f, 106.975f, 107.725f, 108.475f, 109.225f, 109.975f, 110.725f, 111.475f, 112.225f, 112.975f, 113.725f, 114.475f, 115.225f, 115.975f, 116.725f, 117.475f,
                                         118.225f, 118.975f, 119.725f, 120.475f, 121.225f, 121.975f, 122.725f, 123.475f, 124.225f, 124.975f, 125.725f, 126.475f, 127.225f, 127.975f, 128.725f, 129.475f, 130.225f, 130.975f, 131.725f, 135.2f, 136.2f, 137.2f,
                                         138.2f, 139.2f, 140.2f, 141.2f, 142.2f, 143.2f, 144.2f, 145.2f, 146.2f, 147.2f, 148.2f, 149.2f, 150.2f, 151.2f, 152.2f, 153.2f, 154.2f, 155.2f, 156.2f, 157.2f, 158.2f, 159.2f,
@@ -38,12 +33,12 @@ GPUconstexpr() float mX[GPUCA_NROWS] = {85.225f, 85.975f, 86.725f, 87.475f, 88.2
                                         187.f, 188.2f, 189.4f, 190.6f, 191.8f, 193.f, 194.2f, 195.4f, 196.6f, 197.8f, 199.f, 200.2f, 201.4f, 202.6f, 203.8f, 205.f, 206.2f, 209.65f, 211.15f, 212.65f, 214.15f, 215.65f,
                                         217.15f, 218.65f, 220.15f, 221.65f, 223.15f, 224.65f, 226.15f, 227.65f, 229.15f, 230.65f, 232.15f, 233.65f, 235.15f, 236.65f, 238.15f, 239.65f, 241.15f, 242.65f, 244.15f, 245.65f};
 
-GPUconstexpr() uint8_t mNPads[GPUCA_NROWS] = {66, 66, 66, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88,
+GPUconstexpr() uint8_t mNPads[o2::tpc::constants::MAXGLOBALPADROW] = {66, 66, 66, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88,
                                               90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 92, 92, 92, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82,
                                               82, 84, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 102, 102, 102, 104, 104, 104, 106, 110,
                                               110, 112, 112, 112, 114, 114, 114, 116, 116, 116, 118, 118, 118, 118, 118, 120, 120, 122, 122, 124, 124, 124, 126, 126, 128, 128, 128, 130, 130, 132, 132, 132, 134, 134, 136, 136, 138, 138};
 
-GPUconstexpr() uint8_t mRegion[GPUCA_NROWS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+GPUconstexpr() uint8_t mRegion[o2::tpc::constants::MAXGLOBALPADROW] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
                                                4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
 GPUconstexpr() uint8_t mRegionRows[10] = {17, 15, 16, 15, 18, 16, 16, 14, 13, 12};
 GPUconstexpr() uint8_t mRegionStart[10] = {0, 17, 32, 48, 63, 81, 97, 113, 127, 140};
@@ -57,7 +52,7 @@ GPUconstexpr() float mPadWidth[10] = {.416f, .420f, .420f, .436f, .6f, .6f, .608
 
 constexpr float FACTOR_T2Z = 250.f / 512.f; // Used in compression, must remain constant at 250cm, 512 time bins!
 #else
-GPUconstexpr() float mX[GPUCA_NROWS] = {85.195f, 85.945f, 86.695f, 87.445f, 88.195f, 88.945f, 89.695f, 90.445f, 91.195f, 91.945f, 92.695f, 93.445f, 94.195f, 94.945f, 95.695f, 96.445f, 97.195f, 97.945f, 98.695f, 99.445f, 100.195f, 100.945f, 101.695f,
+GPUconstexpr() float mX[o2::tpc::constants::MAXGLOBALPADROW] = {85.195f, 85.945f, 86.695f, 87.445f, 88.195f, 88.945f, 89.695f, 90.445f, 91.195f, 91.945f, 92.695f, 93.445f, 94.195f, 94.945f, 95.695f, 96.445f, 97.195f, 97.945f, 98.695f, 99.445f, 100.195f, 100.945f, 101.695f,
                                         102.445f, 103.195f, 103.945f, 104.695f, 105.445f, 106.195f, 106.945f, 107.695f, 108.445f, 109.195f, 109.945f, 110.695f, 111.445f, 112.195f, 112.945f, 113.695f, 114.445f, 115.195f, 115.945f, 116.695f, 117.445f, 118.195f, 118.945f,
                                         119.695f, 120.445f, 121.195f, 121.945f, 122.695f, 123.445f, 124.195f, 124.945f, 125.695f, 126.445f, 127.195f, 127.945f, 128.695f, 129.445f, 130.195f, 130.945f, 131.695f, 135.180f, 136.180f, 137.180f, 138.180f, 139.180f, 140.180f,
                                         141.180f, 142.180f, 143.180f, 144.180f, 145.180f, 146.180f, 147.180f, 148.180f, 149.180f, 150.180f, 151.180f, 152.180f, 153.180f, 154.180f, 155.180f, 156.180f, 157.180f, 158.180f, 159.180f, 160.180f, 161.180f, 162.180f, 163.180f,
@@ -65,7 +60,7 @@ GPUconstexpr() float mX[GPUCA_NROWS] = {85.195f, 85.945f, 86.695f, 87.445f, 88.1
                                         187.180f, 188.180f, 189.180f, 190.180f, 191.180f, 192.180f, 193.180f, 194.180f, 195.180f, 196.180f, 197.180f, 198.180f, 199.430f, 200.930f, 202.430f, 203.930f, 205.430f, 206.930f, 208.430f, 209.930f, 211.430f, 212.930f, 214.430f,
                                         215.930f, 217.430f, 218.930f, 220.430f, 221.930f, 223.430f, 224.930f, 226.430f, 227.930f, 229.430f, 230.930f, 232.430f, 233.930f, 235.430f, 236.930f, 238.430f, 239.930f, 241.430f, 242.930f, 244.430f, 245.930f};
 
-GPUconstexpr() uint8_t mNPads[GPUCA_NROWS] = {68, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 92, 92, 92,
+GPUconstexpr() uint8_t mNPads[o2::tpc::constants::MAXGLOBALPADROW] = {68, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 92, 92, 92,
                                               94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 108, 108, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82, 82, 84, 84,
                                               84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108,
                                               108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
@@ -74,14 +69,17 @@ GPUconstexpr() float mPadHeight[3] = {.75f, 1.f, 1.5f};
 GPUconstexpr() float mPadWidth[3] = {.4f, .6f, .6f};
 
 constexpr float FACTOR_T2Z = 250.f / 1024.f; // Used in compression, must remain constant at 250cm, 1024 time bins!
-#endif // clang-format: on
+#endif // clang-format on
 } // namespace gputpcgeometry_internal
 
-class GPUTPCGeometry // TODO: Make values constexpr
+class GPUTPCGeometry
 {
   static constexpr float FACTOR_Z2T = 1.f / gputpcgeometry_internal::FACTOR_T2Z;
 
  public:
+  static constexpr uint32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
+  static constexpr uint32_t NROWS = o2::tpc::constants::MAXGLOBALPADROW;
+
 #ifndef GPUCA_RUN2
   GPUd() static constexpr int32_t GetRegion(int32_t row) { return gputpcgeometry_internal::mRegion[row]; }
   GPUd() static constexpr int32_t GetRegionRows(int32_t region) { return gputpcgeometry_internal::mRegionRows[region]; }
@@ -101,7 +99,7 @@ class GPUTPCGeometry // TODO: Make values constexpr
   GPUd() static constexpr int32_t GetROC(int32_t row) { return GetRegion(row); }
   GPUd() static constexpr int32_t EndIROC() { return 63; }
   GPUd() static constexpr int32_t EndOROC1() { return 63 + 64; }
-  GPUd() static constexpr int32_t EndOROC2() { return GPUCA_NROWS; }
+  GPUd() static constexpr int32_t EndOROC2() { return GPUTPCGeometry::NROWS; }
   GPUd() static constexpr int32_t MaxNPadsPerRow() { return 140; }
 #endif
 
@@ -112,25 +110,25 @@ class GPUTPCGeometry // TODO: Make values constexpr
   GPUd() static constexpr float PadWidth(int32_t row) { return (gputpcgeometry_internal::mPadWidth[GetRegion(row)]); }
   GPUd() static constexpr uint8_t NPads(int32_t row) { return gputpcgeometry_internal::mNPads[row]; }
 
-  GPUd() static constexpr float LinearPad2Y(int32_t sector, int32_t row, float pad)
+  GPUd() static constexpr float LinearPad2Y(uint32_t sector, uint32_t row, float pad)
   {
 #ifndef GPUCA_RUN2
     const float u = (pad - 0.5f * (gputpcgeometry_internal::mNPads[row] - 1)) * PadWidth(row);
 #else
     const float u = (pad - 0.5f * gputpcgeometry_internal::mNPads[row]) * PadWidth(row);
 #endif
-    return (sector >= GPUCA_NSECTORS / 2) ? -u : u;
+    return (sector >= NSECTORS / 2) ? -u : u;
   }
 
-  GPUd() static constexpr float LinearTime2Z(int32_t sector, float time)
+  GPUd() static constexpr float LinearTime2Z(uint32_t sector, float time)
   {
     const float v = 250.f - time * gputpcgeometry_internal::FACTOR_T2Z; // Used in compression, must remain constant at 250cm!
-    return (sector >= GPUCA_NSECTORS / 2) ? -v : v;
+    return (sector >= NSECTORS / 2) ? -v : v;
   }
 
-  GPUd() static constexpr float LinearY2Pad(int32_t sector, int32_t row, float y)
+  GPUd() static constexpr float LinearY2Pad(uint32_t sector, uint32_t row, float y)
   {
-    const float u = (sector >= GPUCA_NSECTORS / 2) ? -y : y;
+    const float u = (sector >= NSECTORS / 2) ? -y : y;
 #ifndef GPUCA_RUN2
     return u / PadWidth(row) + 0.5f * (gputpcgeometry_internal::mNPads[row] - 1);
 #else
@@ -138,9 +136,9 @@ class GPUTPCGeometry // TODO: Make values constexpr
 #endif
   }
 
-  GPUd() static constexpr float LinearZ2Time(int32_t sector, float z)
+  GPUd() static constexpr float LinearZ2Time(uint32_t sector, float z)
   {
-    const float v = (sector >= GPUCA_NSECTORS / 2) ? -z : z;
+    const float v = (sector >= NSECTORS / 2) ? -z : z;
     return (250.f - v) * FACTOR_Z2T; // Used in compression, must remain constant at 250cm
   }
 };
diff --git a/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx b/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
index 683bf958dfd12..6ebc5db8e7e06 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCPadBitMap.cxx
@@ -23,7 +23,7 @@ TPCPadBitMap::TPCPadBitMap()
 {
   constexpr GPUTPCGeometry geo;
   int32_t offset = 0;
-  for (int32_t r = 0; r < GPUCA_NROWS; r++) {
+  for (uint32_t r = 0; r < GPUTPCGeometry::NROWS; r++) {
     mPadOffsetPerRow[r] = offset;
     offset += geo.NPads(r);
   }
diff --git a/GPU/GPUTracking/DataTypes/TPCPadBitMap.h b/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
index 072d3101a4537..fdc1e5b598402 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
+++ b/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
@@ -101,8 +101,8 @@ struct TPCPadBitMap {
     T mDeadChannelMap[NWORDS];
   };
 
-  uint16_t mPadOffsetPerRow[GPUCA_NROWS];
-  SectorBitMap mBitMap[GPUCA_NSECTORS];
+  uint16_t mPadOffsetPerRow[GPUTPCGeometry::NROWS];
+  SectorBitMap mBitMap[GPUTPCGeometry::NSECTORS];
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
index 9c6f956a954e8..54125eb324bd1 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.cxx
@@ -23,7 +23,7 @@ TPCPadGainCalib::TPCPadGainCalib()
 {
   constexpr GPUTPCGeometry geo{};
   int32_t offset = 0;
-  for (int32_t r = 0; r < GPUCA_NROWS; r++) {
+  for (uint32_t r = 0; r < GPUTPCGeometry::NROWS; r++) {
     mPadOffsetPerRow[r] = offset;
     offset += geo.NPads(r);
   }
diff --git a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
index d261ec84e37d8..ebb81fbb69f6f 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
+++ b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
@@ -81,14 +81,14 @@ struct TPCPadGainCalib {
 
   GPUdi() void setMinCorrectionFactor(const float minCorrectionFactor)
   {
-    for (int32_t sector = 0; sector < GPUCA_NSECTORS; sector++) {
+    for (uint32_t sector = 0; sector < GPUTPCGeometry::NSECTORS; sector++) {
       mGainCorrection[sector].mMinCorrectionFactor = minCorrectionFactor;
     }
   }
 
   GPUdi() void setMaxCorrectionFactor(const float maxCorrectionFactor)
   {
-    for (int32_t sector = 0; sector < GPUCA_NSECTORS; sector++) {
+    for (uint32_t sector = 0; sector < GPUTPCGeometry::NSECTORS; sector++) {
       mGainCorrection[sector].mMaxCorrectionFactor = maxCorrectionFactor;
     }
   }
@@ -153,8 +153,8 @@ struct TPCPadGainCalib {
     }
   };
 
-  uint16_t mPadOffsetPerRow[GPUCA_NROWS];
-  SectorPadGainCorrection<uint16_t> mGainCorrection[GPUCA_NSECTORS];
+  uint16_t mPadOffsetPerRow[GPUTPCGeometry::NROWS];
+  SectorPadGainCorrection<uint16_t> mGainCorrection[GPUTPCGeometry::NSECTORS];
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
index 919d124d6d354..4f1fcc14ea600 100644
--- a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
+++ b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.cxx
@@ -33,8 +33,8 @@ GPUTPCClusterFilter::GPUTPCClusterFilter(const o2::tpc::ClusterNativeAccess& clu
       called = true;
     }
 
-    for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-      for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
+    for (uint32_t iSector = 0; iSector < GPUTPCGeometry::NSECTORS; iSector++) {
+      for (uint32_t iRow = 0; iRow < GPUTPCGeometry::NROWS; iRow++) {
         const uint32_t globalStack = getGlobalStack(iSector, iRow);
         mClusterStats[globalStack].resize(MaxTimeBin);
 
diff --git a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.h b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.h
index b39237757de53..debd550b48050 100644
--- a/GPU/GPUTracking/Debug/GPUTPCClusterFilter.h
+++ b/GPU/GPUTracking/Debug/GPUTPCClusterFilter.h
@@ -18,7 +18,7 @@
 #include <memory>
 #include <cstdint>
 #include <vector>
-#include "GPUDefConstantsAndSettings.h"
+#include "GPUTPCGeometry.h"
 
 namespace o2::tpc
 {
@@ -36,7 +36,7 @@ class GPUTPCClusterFilter
 
  private:
   static constexpr uint32_t MaxTimeBin = 14256;
-  static constexpr uint32_t MaxStacks = GPUCA_NSECTORS * 4;
+  static constexpr uint32_t MaxStacks = GPUTPCGeometry::NSECTORS * 4;
   uint8_t mFilterType = 0; //< 0: off, 1: custom, 2: PbPb23
 
   std::unique_ptr<std::vector<int>[]> mClusterStats; //< Number of clusters per stack and time bin
diff --git a/GPU/GPUTracking/Definitions/GPUDef.h b/GPU/GPUTracking/Definitions/GPUDef.h
index d684cd42f8262..6bc91e9fef19e 100644
--- a/GPU/GPUTracking/Definitions/GPUDef.h
+++ b/GPU/GPUTracking/Definitions/GPUDef.h
@@ -20,6 +20,7 @@
 #include "GPUDefConstantsAndSettings.h"
 #include "GPUDefParametersWrapper.h"
 #include "GPUCommonRtypes.h"
+#include "GPUTPCGeometry.h"
 
 // Macros for masking ptrs in OpenCL kernel calls as uint64_t (The API only allows us to pass buffer objects)
 #ifdef __OPENCL__
@@ -37,21 +38,21 @@
 #define GPUCA_EVDUMP_FILE "event"
 
 #ifdef GPUCA_GPUCODE
-  #define CA_MAKE_SHARED_REF(vartype, varname, varglobal, varshared) const GPUsharedref() vartype& __restrict__ varname = varshared;
-  #define CA_SHARED_STORAGE(storage) storage
-  #define CA_SHARED_CACHE(target, src, size) \
+  #define GPUCA_MAKE_SHARED_REF(vartype, varname, varglobal, varshared) const GPUsharedref() vartype& __restrict__ varname = varshared;
+  #define GPUCA_SHARED_STORAGE(storage) storage
+  #define GPUCA_SHARED_CACHE(target, src, size) \
     static_assert((size) % sizeof(int32_t) == 0, "Invalid shared cache size"); \
     for (uint32_t i_shared_cache = get_local_id(0); i_shared_cache < (size) / sizeof(int32_t); i_shared_cache += get_local_size(0)) { \
       reinterpret_cast<GPUsharedref() int32_t*>(target)[i_shared_cache] = reinterpret_cast<GPUglobalref() const int32_t*>(src)[i_shared_cache]; \
     }
-  #define CA_SHARED_CACHE_REF(target, src, size, reftype, ref) \
-    CA_SHARED_CACHE(target, src, size) \
+  #define GPUCA_SHARED_CACHE_REF(target, src, size, reftype, ref) \
+    GPUCA_SHARED_CACHE(target, src, size) \
     GPUsharedref() const reftype* __restrict__ ref = (target)
 #else
-  #define CA_MAKE_SHARED_REF(vartype, varname, varglobal, varshared) const GPUglobalref() vartype & __restrict__ varname = varglobal;
-  #define CA_SHARED_STORAGE(storage)
-  #define CA_SHARED_CACHE(target, src, size)
-  #define CA_SHARED_CACHE_REF(target, src, size, reftype, ref) GPUglobalref() const reftype* __restrict__ ref = src
+  #define GPUCA_MAKE_SHARED_REF(vartype, varname, varglobal, varshared) const GPUglobalref() vartype & __restrict__ varname = varglobal;
+  #define GPUCA_SHARED_STORAGE(storage)
+  #define GPUCA_SHARED_CACHE(target, src, size)
+  #define GPUCA_SHARED_CACHE_REF(target, src, size, reftype, ref) GPUglobalref() const reftype* __restrict__ ref = src
 #endif
 
 #endif //GPUTPCDEF_H
diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index 9c2d04ca280f2..2e15fbd3e002e 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -30,39 +30,17 @@
   #error Invalid Compile Definitions, need to build for either O2 or Standalone!
 #endif
 
-#define GPUCA_TPC_MIN_HITS_B5(QPTB5) (CAMath::Abs(QPTB5) > 10 ? 10 : (CAMath::Abs(QPTB5) > 5 ? 15 : 29)) // Minimum hits should depend on Pt, low Pt tracks can have few hits. 29 Hits default, 15 for < 200 mev, 10 for < 100 mev
-
-#define GPUCA_MERGER_MAX_TRACK_CLUSTERS 1024          // Maximum number of clusters a track may have after merging
-
-#define GPUCA_MAXN 40                                 // Maximum number of neighbor hits to consider in one row in neightbors finder
-
-#define GPUCA_MAX_SIN_PHI_LOW 0.99f                   // Limits for maximum sin phi during fit
-#define GPUCA_MAX_SIN_PHI 0.999f                      // Must be preprocessor define because c++ pre 11 cannot use static constexpr for initializes
-
-#define GPUCA_MIN_BIN_SIZE 2.f                        // Minimum bin size in TPC fast access grid
-#define GPUCA_MAX_BIN_SIZE 1000.f                     // Maximum bin size in TPC fast access grid
-
-#define GPUCA_TPC_COMP_CHUNK_SIZE 1024                // Chunk size of sorted unattached TPC cluster in compression
-
-#define TPC_MAX_TIME_BIN_TRIGGERED 600
-
-#if defined(GPUCA_NSECTORS) || defined(GPUCA_NROWS)
-  #error GPUCA_NSECTORS or GPUCA_NROWS already defined, do not include GPUTPCGeometry.h before!
-#endif
-#if !defined(GPUCA_RUN2) && !(defined(ROOT_VERSION_CODE) && ROOT_VERSION_CODE < 393216)
-  //Use definitions from the O2 headers if available for nicer code and type safety
-  #include "DataFormatsTPC/Constants.h"
-  #define GPUCA_NSECTORS o2::tpc::constants::MAXSECTOR
-  #define GPUCA_NROWS o2::tpc::constants::MAXGLOBALPADROW
-#else
-  //Define it manually, if O2 headers not available, ROOT5, and OpenCL 1.2, which do not know C++11.
-  #define GPUCA_NSECTORS 36
-  #ifndef GPUCA_RUN2
-    #define GPUCA_NROWS 152
-  #else
-    #define GPUCA_NROWS 159
-  #endif
-#endif
+namespace o2::gpu::constants
+{
+static constexpr uint32_t MERGER_MAX_TRACK_CLUSTERS = 1024; // Maximum number of clusters a track may have after merging
+static constexpr uint32_t NEIGHBOURS_MAX_N = 40;            // Maximum number of neighbor hits to consider in one row in neightbors finder
+static constexpr float MAX_SIN_PHI_LOW = 0.99f;             // Limits for maximum sin phi during fit
+static constexpr float MAX_SIN_PHI = 0.999f;                // Must be preprocessor define because c++ pre 11 cannot use static constexpr for initializes
+static constexpr float GRID_MIN_BIN_SIZE = 2.f;             // Minimum bin size in TPC fast access grid
+static constexpr float GRID_MAX_BIN_SIZE = 1000.f;          // Maximum bin size in TPC fast access grid
+static constexpr uint32_t TPC_COMP_CHUNK_SIZE = 1024;       // Chunk size of sorted unattached TPC cluster in compression
+static constexpr uint32_t TPC_MAX_TIME_BIN_TRIGGERED = 600;
+} // namespace o2::gpu::constants
 
 //#define GPUCA_MERGER_BY_MC_LABEL                    // Use MC labels for TPC track merging - for performance studies // TODO: Cleanup unneeded options
 
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
index 747ee84a906a6..41f9faaabc86a 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
@@ -16,26 +16,36 @@
 
 #ifndef GPUDEFPARAMETERSCONSTANTS_H
 #define GPUDEFPARAMETERSCONSTANTS_H
+
+#include "GPUCommonDef.h"
+#include "DataFormatsTPC/Constants.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <cstddef>
+#endif
+
 // clang-format off
 
 #if defined(__CUDACC__) || defined(__HIPCC__)
   #define GPUCA_SPECIALIZE_THRUST_SORTS // Not compiled with RTC, so must be compile-time constant
 #endif
 
-#define GPUCA_MAX_THREADS 1024
-#define GPUCA_MAX_STREAMS 36
-
-#define GPUCA_ROWALIGNMENT 16                                          // Align of Row Hits and Grid
-#define GPUCA_BUFFER_ALIGNMENT 64                                      // Alignment of buffers obtained from SetPointers
-#define GPUCA_MEMALIGN (64 * 1024)                                     // Alignment of allocated memory blocks
-
-// Default maximum numbers
-#define GPUCA_MAX_CLUSTERS           ((size_t)     1024 * 1024 * 1024) // Maximum number of TPC clusters
-#define GPUCA_MAX_TRD_TRACKLETS      ((size_t)             128 * 1024) // Maximum number of TRD tracklets
-#define GPUCA_MEMORY_SIZE            ((size_t) 6 * 1024 * 1024 * 1024) // Size of memory allocated on Device
-#define GPUCA_HOST_MEMORY_SIZE       ((size_t) 1 * 1024 * 1024 * 1024) // Size of memory allocated on Host
-#define GPUCA_GPU_STACK_SIZE         ((size_t)               8 * 1024) // Stack size per GPU thread
-#define GPUCA_GPU_HEAP_SIZE          ((size_t)       16 * 1025 * 1024) // Stack size per GPU thread
+namespace o2::gpu::constants
+{
+static constexpr size_t GPU_MAX_THREADS = 1024;
+static constexpr size_t GPU_MAX_STREAMS = 36;
+
+static constexpr size_t GPU_ROWALIGNMENT =  16;      // Align of Row Hits and Grid
+static constexpr size_t GPU_BUFFER_ALIGNMENT =  64;  // Alignment of buffers obtained from SetPointers
+static constexpr size_t GPU_MEMALIGN =  (64 * 1024); // Alignment of allocated memory blocks
+
+//; Default maximum numbers
+static constexpr size_t GPU_MEM_MAX_TPC_CLUSTERS =         1024 * 1024 * 1024ull; // Maximum number of TPC clusters
+static constexpr size_t GPU_MEM_MAX_TRD_TRACKLETS =                128 * 1024ull; // Maximum number of TRD tracklets
+static constexpr size_t GPU_DEFAULT_MEMORY_SIZE =      6 * 1024 * 1024 * 1024ull; // Size of memory allocated on Device
+static constexpr size_t GPU_DEFAULT_HOST_MEMORY_SIZE = 1 * 1024 * 1024 * 1024ull; // Size of memory allocated on Host
+static constexpr size_t GPU_STACK_SIZE =                             8 * 1024ull; // Stack size per GPU thread
+static constexpr size_t GPU_HEAP_SIZE =                      16 * 1025 * 1024ull; // Stack size per GPU thread
+} // namespace o2::gpu::constants
 
 // clang-format on
 #endif // GPUDEFPARAMETERSCONSTANTS_H
diff --git a/GPU/GPUTracking/Definitions/clusterFinderDefs.h b/GPU/GPUTracking/Definitions/clusterFinderDefs.h
index 79bcf773d5bd9..02f26199bbe1c 100644
--- a/GPU/GPUTracking/Definitions/clusterFinderDefs.h
+++ b/GPU/GPUTracking/Definitions/clusterFinderDefs.h
@@ -42,7 +42,7 @@
 #define TPC_CLUSTERER_ROW_STRIDE (TPC_CLUSTERER_ROW_PAD_CAPACITY + GPUCF_PADDING_PAD)
 // Number of pads in a sector as stored internally by the clusterizer.
 // This includes fake pads for constant strides between rows
-#define TPC_CLUSTERER_STRIDED_PAD_COUNT (GPUCA_NROWS * TPC_CLUSTERER_ROW_STRIDE + GPUCF_PADDING_PAD)
+#define TPC_CLUSTERER_STRIDED_PAD_COUNT (GPUTPCGeometry::NROWS * TPC_CLUSTERER_ROW_STRIDE + GPUCF_PADDING_PAD)
 // Real of number of pads in a sector
 #define TPC_REAL_PADS_IN_SECTOR 14560
 #define TPC_FEC_IDS_IN_SECTOR 23296
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 7ccf6b7329fe6..b9822692a65cf 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -162,8 +162,8 @@ void GPUChainTracking::RegisterGPUProcessors()
 
 void GPUChainTracking::MemorySize(size_t& gpuMem, size_t& pageLockedHostMem)
 {
-  gpuMem = GPUCA_MEMORY_SIZE;
-  pageLockedHostMem = GPUCA_HOST_MEMORY_SIZE;
+  gpuMem = constants::GPU_DEFAULT_MEMORY_SIZE;
+  pageLockedHostMem = constants::GPU_DEFAULT_HOST_MEMORY_SIZE;
 }
 
 bool GPUChainTracking::ValidateSteps()
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index fdcdb064bc78a..5ece80eec1841 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -217,7 +217,7 @@ class GPUChainTracking : public GPUChain
   struct eventStruct // Must consist only of void* ptr that will hold the GPU event ptrs!
   {
     deviceEvent sector[NSECTORS];
-    deviceEvent stream[GPUCA_MAX_STREAMS];
+    deviceEvent stream[constants::GPU_MAX_STREAMS];
     deviceEvent init;
     deviceEvent single;
   };
@@ -229,7 +229,7 @@ class GPUChainTracking : public GPUChain
     RecoStep step;
   };
 
-  GPUChainTracking(GPUReconstruction* rec, uint32_t maxTPCHits = GPUCA_MAX_CLUSTERS, uint32_t maxTRDTracklets = GPUCA_MAX_TRD_TRACKLETS);
+  GPUChainTracking(GPUReconstruction* rec, uint32_t maxTPCHits = constants::GPU_MEM_MAX_TPC_CLUSTERS, uint32_t maxTRDTracklets = constants::GPU_MEM_MAX_TRD_TRACKLETS);
 
   int32_t ExtrapolationTracking(uint32_t iSector, bool blocking);
 
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
index 9e2a476ce024b..a2a07be7832ca 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingClusterizer.cxx
@@ -491,7 +491,7 @@ int32_t GPUChainTracking::RunTPCClusterizer_prepare(bool restorePointers)
     mCFContext.reset(new GPUTPCCFChainContext);
   }
   const int16_t maxFragmentLen = GetProcessingSettings().overrideClusterizerFragmentLen;
-  const uint32_t maxAllowedTimebin = param().par.continuousTracking ? std::max<int32_t>(param().continuousMaxTimeBin, maxFragmentLen) : TPC_MAX_TIME_BIN_TRIGGERED;
+  const uint32_t maxAllowedTimebin = param().par.continuousTracking ? std::max<int32_t>(param().continuousMaxTimeBin, maxFragmentLen) : constants::TPC_MAX_TIME_BIN_TRIGGERED;
   mCFContext->tpcMaxTimeBin = maxAllowedTimebin;
   const CfFragment fragmentMax{(tpccf::TPCTime)mCFContext->tpcMaxTimeBin + 1, maxFragmentLen};
   mCFContext->prepare(mIOPtrs.tpcZS, fragmentMax);
@@ -722,7 +722,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
       }
     });
     const int16_t maxFragmentLen = GetProcessingSettings().overrideClusterizerFragmentLen;
-    const uint32_t maxAllowedTimebin = param().par.continuousTracking ? std::max<int32_t>(param().continuousMaxTimeBin, maxFragmentLen) : TPC_MAX_TIME_BIN_TRIGGERED;
+    const uint32_t maxAllowedTimebin = param().par.continuousTracking ? std::max<int32_t>(param().continuousMaxTimeBin, maxFragmentLen) : constants::TPC_MAX_TIME_BIN_TRIGGERED;
     for (int32_t sector = 0; sector < NSECTORS; sector++) {
       GPUTPCNNClusterizer& clustererNN = processors()->tpcNNClusterer[sector];
       GPUTPCNNClusterizer& clustererNNShadow = doGPU ? processorsShadow()->tpcNNClusterer[sector] : clustererNN;
@@ -815,7 +815,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
 
   for (uint32_t iSectorBase = 0; iSectorBase < NSECTORS; iSectorBase += GetProcessingSettings().nTPCClustererLanes) {
     std::vector<bool> laneHasData(GetProcessingSettings().nTPCClustererLanes, false);
-    static_assert(NSECTORS <= GPUCA_MAX_STREAMS, "Stream events must be able to hold all sectors");
+    static_assert(NSECTORS <= constants::GPU_MAX_STREAMS, "Stream events must be able to hold all sectors");
     const int32_t maxLane = std::min<int32_t>(GetProcessingSettings().nTPCClustererLanes, NSECTORS - iSectorBase);
     for (CfFragment fragment = mCFContext->fragmentFirst; !fragment.isEnd(); fragment = fragment.next()) {
       if (GetProcessingSettings().debugLevel >= 3) {
@@ -1012,7 +1012,7 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
             waitEvent = &mEvents->stream[lane];
             transferRunning[lane] = 2;
           }
-          runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding), krnlRunRangeNone, {nullptr, waitEvent}}, clustererShadow.mPclusterInRow, GPUCA_NROWS * sizeof(*clustererShadow.mPclusterInRow));
+          runKernel<GPUMemClean16>({GetGridAutoStep(lane, RecoStep::TPCClusterFinding), krnlRunRangeNone, {nullptr, waitEvent}}, clustererShadow.mPclusterInRow, GPUTPCGeometry::NROWS * sizeof(*clustererShadow.mPclusterInRow));
         }
 
         if (clusterer.mPmemory->counters.nClusters == 0) {
@@ -1193,9 +1193,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
       if (laneHasData[lane]) {
         anyLaneHasData = true;
         if (buildNativeGPU && GetProcessingSettings().tpccfGatherKernel) {
-          runKernel<GPUTPCCFGather>({GetGridBlk(GPUCA_NROWS, mRec->NStreams() - 1), {iSector}}, &mInputsShadow->mPclusterNativeBuffer[nClsTotal]);
+          runKernel<GPUTPCCFGather>({GetGridBlk(GPUTPCGeometry::NROWS, mRec->NStreams() - 1), {iSector}}, &mInputsShadow->mPclusterNativeBuffer[nClsTotal]);
         }
-        for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+        for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
           if (nClsTotal + clusterer.mPclusterInRow[j] > mInputsHost->mNClusterNative) {
             clusterer.raiseError(GPUErrors::ERROR_CF_GLOBAL_CLUSTER_OVERFLOW, iSector * 1000 + j, nClsTotal + clusterer.mPclusterInRow[j], mInputsHost->mNClusterNative);
             continue;
@@ -1222,9 +1222,9 @@ int32_t GPUChainTracking::RunTPCClusterizer(bool synchronizeOutput)
         continue;
       }
 
-      runKernel<GPUTPCCFMCLabelFlattener, GPUTPCCFMCLabelFlattener::setRowOffsets>({GetGrid(GPUCA_NROWS, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}});
+      runKernel<GPUTPCCFMCLabelFlattener, GPUTPCCFMCLabelFlattener::setRowOffsets>({GetGrid(GPUTPCGeometry::NROWS, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}});
       GPUTPCCFMCLabelFlattener::setGlobalOffsetsAndAllocate(clusterer, mcLinearLabels);
-      runKernel<GPUTPCCFMCLabelFlattener, GPUTPCCFMCLabelFlattener::flatten>({GetGrid(GPUCA_NROWS, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}}, &mcLinearLabels);
+      runKernel<GPUTPCCFMCLabelFlattener, GPUTPCCFMCLabelFlattener::flatten>({GetGrid(GPUTPCGeometry::NROWS, lane, GPUReconstruction::krnlDeviceType::CPU), {iSector}}, &mcLinearLabels);
       clusterer.clearMCMemory();
       assert(propagateMCLabels ? mcLinearLabels.header.size() == nClsTotal : true);
     }
@@ -1375,7 +1375,7 @@ void GPUChainTracking::SortClusters(bool buildNativeGPU, bool propagateMCLabels,
     std::iota(clsOrder.begin(), clsOrder.end(), 0);
     std::vector<ClusterNative> tmpClusters;
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+      for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
         const uint32_t offset = clusterAccess->clusterOffset[i][j];
         std::sort(&clsOrder[offset], &clsOrder[offset + clusterAccess->nClusters[i][j]], [&clusters](const uint32_t a, const uint32_t b) {
           return clusters[a] < clusters[b];
@@ -1415,7 +1415,7 @@ void GPUChainTracking::SortClusters(bool buildNativeGPU, bool propagateMCLabels,
     clusterAccess->clustersMCTruth = labelBuffer.second;
   } else {
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+      for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
         std::sort(&clusters[clusterAccess->clusterOffset[i][j]], &clusters[clusterAccess->clusterOffset[i][j] + clusterAccess->nClusters[i][j]]);
       }
     }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
index ae5038f9c8a6f..dda15d403407e 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingCompression.cxx
@@ -74,7 +74,7 @@ int32_t GPUChainTracking::RunTPCCompression()
   O->nAttachedClusters = Compressor.mMemory->nStoredAttachedClusters;
   O->nUnattachedClusters = Compressor.mMemory->nStoredUnattachedClusters;
   O->nAttachedClustersReduced = O->nAttachedClusters - O->nTracks;
-  O->nSliceRows = NSECTORS * GPUCA_NROWS;
+  O->nSliceRows = NSECTORS * GPUTPCGeometry::NROWS;
   O->nComppressionModes = param().rec.tpc.compressionTypeMask;
   O->solenoidBz = param().bzkG;
   O->maxTimeBin = param().continuousMaxTimeBin;
@@ -156,21 +156,21 @@ int32_t GPUChainTracking::RunTPCCompression()
       gatherTimer = &getTimer<GPUTPCCompressionKernels>("GPUTPCCompression_GatherOnCPU", 0);
       gatherTimer->Start();
     }
-    GPUMemCpyAlways(myStep, O->nSliceRowClusters, P->nSliceRowClusters, NSECTORS * GPUCA_NROWS * sizeof(O->nSliceRowClusters[0]), outputStream, direction);
+    GPUMemCpyAlways(myStep, O->nSliceRowClusters, P->nSliceRowClusters, NSECTORS * GPUTPCGeometry::NROWS * sizeof(O->nSliceRowClusters[0]), outputStream, direction);
     GPUMemCpyAlways(myStep, O->nTrackClusters, P->nTrackClusters, O->nTracks * sizeof(O->nTrackClusters[0]), outputStream, direction);
     SynchronizeStream(outputStream);
     uint32_t offset = 0;
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+      for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
         uint32_t srcOffset = mIOPtrs.clustersNative->clusterOffset[i][j] * Compressor.mMaxClusterFactorBase1024 / 1024;
-        GPUMemCpyAlways(myStep, O->qTotU + offset, P->qTotU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->qTotU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->qMaxU + offset, P->qMaxU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->qMaxU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->flagsU + offset, P->flagsU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->flagsU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->padDiffU + offset, P->padDiffU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->padDiffU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->timeDiffU + offset, P->timeDiffU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->timeDiffU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->sigmaPadU + offset, P->sigmaPadU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->sigmaPadU[0]), outputStream, direction);
-        GPUMemCpyAlways(myStep, O->sigmaTimeU + offset, P->sigmaTimeU + srcOffset, O->nSliceRowClusters[i * GPUCA_NROWS + j] * sizeof(O->sigmaTimeU[0]), outputStream, direction);
-        offset += O->nSliceRowClusters[i * GPUCA_NROWS + j];
+        GPUMemCpyAlways(myStep, O->qTotU + offset, P->qTotU + srcOffset, O->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j] * sizeof(O->qTotU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->qMaxU + offset, P->qMaxU + srcOffset, O->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j] * sizeof(O->qMaxU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->flagsU + offset, P->flagsU + srcOffset, O->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j] * sizeof(O->flagsU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->padDiffU + offset, P->padDiffU + srcOffset, O->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j] * sizeof(O->padDiffU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->timeDiffU + offset, P->timeDiffU + srcOffset, O->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j] * sizeof(O->timeDiffU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->sigmaPadU + offset, P->sigmaPadU + srcOffset, O->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j] * sizeof(O->sigmaPadU[0]), outputStream, direction);
+        GPUMemCpyAlways(myStep, O->sigmaTimeU + offset, P->sigmaTimeU + srcOffset, O->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j] * sizeof(O->sigmaTimeU[0]), outputStream, direction);
+        offset += O->nSliceRowClusters[i * GPUTPCGeometry::NROWS + j];
       }
     }
     offset = 0;
@@ -296,7 +296,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
     inputGPU = cmprClsHost;
 
     bool toGPU = true;
-    runKernel<GPUMemClean16>({GetGridAutoStep(inputStream, RecoStep::TPCDecompression), krnlRunRangeNone, &mEvents->init}, DecompressorShadow.mNativeClustersIndex, NSECTORS * GPUCA_NROWS * sizeof(DecompressorShadow.mNativeClustersIndex[0]));
+    runKernel<GPUMemClean16>({GetGridAutoStep(inputStream, RecoStep::TPCDecompression), krnlRunRangeNone, &mEvents->init}, DecompressorShadow.mNativeClustersIndex, NSECTORS * GPUTPCGeometry::NROWS * sizeof(DecompressorShadow.mNativeClustersIndex[0]));
     int32_t nStreams = doGPU ? mRec->NStreams() - 1 : 1;
     if (cmprClsHost.nAttachedClusters != 0) {
       std::exclusive_scan(cmprClsHost.nTrackClusters, cmprClsHost.nTrackClusters + cmprClsHost.nTracks, Decompressor.mAttachedClustersOffsets, 0u); // computing clusters offsets for first kernel
@@ -326,7 +326,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
         runKernel<GPUTPCDecompressionKernels, GPUTPCDecompressionKernels::step0attached>({GetGridAuto(iStream), krnlRunRangeNone, {&mEvents->stream[iStream], &mEvents->init}}, startTrack, endTrack);
       }
     }
-    GPUMemCpy(myStep, inputGPUShadow.nSliceRowClusters, cmprClsHost.nSliceRowClusters, NSECTORS * GPUCA_NROWS * sizeof(cmprClsHost.nSliceRowClusters[0]), unattachedStream, toGPU);
+    GPUMemCpy(myStep, inputGPUShadow.nSliceRowClusters, cmprClsHost.nSliceRowClusters, NSECTORS * GPUTPCGeometry::NROWS * sizeof(cmprClsHost.nSliceRowClusters[0]), unattachedStream, toGPU);
     GPUMemCpy(myStep, inputGPUShadow.qTotU, cmprClsHost.qTotU, cmprClsHost.nUnattachedClusters * sizeof(cmprClsHost.qTotU[0]), unattachedStream, toGPU);
     GPUMemCpy(myStep, inputGPUShadow.qMaxU, cmprClsHost.qMaxU, cmprClsHost.nUnattachedClusters * sizeof(cmprClsHost.qMaxU[0]), unattachedStream, toGPU);
     GPUMemCpy(myStep, inputGPUShadow.flagsU, cmprClsHost.flagsU, cmprClsHost.nUnattachedClusters * sizeof(cmprClsHost.flagsU[0]), unattachedStream, toGPU);
@@ -340,8 +340,8 @@ int32_t GPUChainTracking::RunTPCDecompression()
     uint32_t offset = 0;
     uint32_t decodedAttachedClusters = 0;
     for (uint32_t i = 0; i < NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
-        uint32_t linearIndex = i * GPUCA_NROWS + j;
+      for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
+        uint32_t linearIndex = i * GPUTPCGeometry::NROWS + j;
         uint32_t unattachedOffset = (linearIndex >= cmprClsHost.nSliceRows) ? 0 : cmprClsHost.nSliceRowClusters[linearIndex];
         (mClusterNativeAccess->nClusters)[i][j] = Decompressor.mNativeClustersIndex[linearIndex] + unattachedOffset;
         Decompressor.mUnattachedClustersOffsets[linearIndex] = offset;
@@ -399,7 +399,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
     if (runTimeBinCutFiltering) { // If filtering is applied, count how many clusters will remain after filtering and allocate final buffers accordingly
       AllocateRegisteredMemory(Decompressor.mResourceNClusterPerSectorRow);
       WriteToConstantMemory(myStep, (char*)&processors()->tpcDecompressor - (char*)processors(), &DecompressorShadow, sizeof(DecompressorShadow), unattachedStream);
-      runKernel<GPUMemClean16>({GetGridAutoStep(unattachedStream, RecoStep::TPCDecompression), krnlRunRangeNone}, DecompressorShadow.mNClusterPerSectorRow, NSECTORS * GPUCA_NROWS * sizeof(DecompressorShadow.mNClusterPerSectorRow[0]));
+      runKernel<GPUMemClean16>({GetGridAutoStep(unattachedStream, RecoStep::TPCDecompression), krnlRunRangeNone}, DecompressorShadow.mNClusterPerSectorRow, NSECTORS * GPUTPCGeometry::NROWS * sizeof(DecompressorShadow.mNClusterPerSectorRow[0]));
       runKernel<GPUTPCDecompressionUtilKernels, GPUTPCDecompressionUtilKernels::countFilteredClusters>(GetGridAutoStep(unattachedStream, RecoStep::TPCDecompression));
       TransferMemoryResourceLinkToHost(RecoStep::TPCDecompression, Decompressor.mResourceNClusterPerSectorRow, unattachedStream);
       SynchronizeStream(unattachedStream);
@@ -411,8 +411,8 @@ int32_t GPUChainTracking::RunTPCDecompression()
       Decompressor.mNativeClustersBuffer = mInputsHost->mPclusterNativeOutput;
       WriteToConstantMemory(myStep, (char*)&processors()->tpcDecompressor - (char*)processors(), &DecompressorShadow, sizeof(DecompressorShadow), unattachedStream);
       for (uint32_t i = 0; i < NSECTORS; i++) {
-        for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
-          mClusterNativeAccess->nClusters[i][j] = Decompressor.mNClusterPerSectorRow[i * GPUCA_NROWS + j];
+        for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
+          mClusterNativeAccess->nClusters[i][j] = Decompressor.mNClusterPerSectorRow[i * GPUTPCGeometry::NROWS + j];
         }
       }
       if (doGPU) {
@@ -435,7 +435,7 @@ int32_t GPUChainTracking::RunTPCDecompression()
       const ClusterNativeAccess* decoded = mIOPtrs.clustersNative;
       if (doGPU) {
         for (uint32_t i = 0; i < NSECTORS; i++) {
-          for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+          for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
             ClusterNative* begin = mInputsHost->mPclusterNativeOutput + decoded->clusterOffset[i][j];
             ClusterNative* end = begin + decoded->nClusters[i][j];
             std::sort(begin, end);
@@ -461,8 +461,8 @@ void GPUChainTracking::WriteReducedClusters()
   GPUTPCCompression& Compressor = processors()->tpcCompressor;
   mClusterNativeAccessReduced = std::make_unique<ClusterNativeAccess>();
   uint32_t nOutput = 0;
-  for (uint32_t iSec = 0; iSec < GPUCA_NSECTORS; iSec++) {
-    for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
+  for (uint32_t iSec = 0; iSec < GPUTPCGeometry::NSECTORS; iSec++) {
+    for (uint32_t iRow = 0; iRow < GPUTPCGeometry::NROWS; iRow++) {
       mClusterNativeAccessReduced->nClusters[iSec][iRow] = 0;
       for (uint32_t i = 0; i < mIOPtrs.clustersNative->nClusters[iSec][iRow]; i++) {
         mClusterNativeAccessReduced->nClusters[iSec][iRow] += !Compressor.rejectCluster(mIOPtrs.clustersNative->clusterOffset[iSec][iRow] + i, param(), mIOPtrs);
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
index 7f954e854007a..8f200d2c57a6d 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingDebugAndProfiling.cxx
@@ -282,7 +282,7 @@ void GPUChainTracking::OutputSanityCheck()
       uint8_t sector, row;
       uint32_t cl;
       trk.getClusterReference(mIOPtrs.outputClusRefsTPCO2, j, sector, row, cl);
-      if (sector >= GPUCA_NSECTORS || row >= GPUCA_NROWS) {
+      if (sector >= GPUTPCGeometry::NSECTORS || row >= GPUTPCGeometry::NROWS) {
         if (nErrors++ < 1000) {
           GPUError("Invalid sector / row %d / %d", (int32_t)sector, (int32_t)row);
           continue;
@@ -310,8 +310,8 @@ void GPUChainTracking::RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* cluster
   o2::tpc::ClusterNative* outputBuffer = nullptr;
   for (int32_t iPhase = 0; iPhase < 2; iPhase++) {
     uint32_t countTotal = 0;
-    for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-      for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
+    for (uint32_t iSector = 0; iSector < GPUTPCGeometry::NSECTORS; iSector++) {
+      for (uint32_t iRow = 0; iRow < GPUTPCGeometry::NROWS; iRow++) {
         uint32_t count = 0;
         for (uint32_t k = 0; k < clusters->nClusters[iSector][iRow]; k++) {
           o2::tpc::ClusterNative cl = clusters->clusters[iSector][iRow][k];
@@ -347,9 +347,9 @@ void GPUChainTracking::RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* cluster
 void GPUChainTracking::DumpClusters(std::ostream& out, const o2::tpc::ClusterNativeAccess* clusters)
 {
   out << "\nTPC Clusters:\n";
-  for (uint32_t iSec = 0; iSec < GPUCA_NSECTORS; iSec++) {
+  for (uint32_t iSec = 0; iSec < GPUTPCGeometry::NSECTORS; iSec++) {
     out << "TPCClusters - Sector " << iSec << "\n";
-    for (uint32_t i = 0; i < GPUCA_NROWS; i++) {
+    for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
       out << "  Row: " << i << ": " << clusters->nClusters[iSec][i] << " clusters:\n";
       for (uint32_t j = 0; j < clusters->nClusters[iSec][i]; j++) {
         const auto& cl = clusters->clusters[iSec][i][j];
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
index 4ae1725444386..ac8cb2ba11736 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingIO.cxx
@@ -77,7 +77,7 @@ void GPUChainTracking::DumpData(const char* filename, const GPUTrackingInOutPoin
   DumpData(fp, ioPtrs->rawClusters, ioPtrs->nRawClusters, InOutPointerType::RAW_CLUSTERS);
   if (ioPtrs->clustersNative) {
     if (DumpData(fp, &ioPtrs->clustersNative->clustersLinear, &ioPtrs->clustersNative->nClustersTotal, InOutPointerType::CLUSTERS_NATIVE)) {
-      fwrite(&ioPtrs->clustersNative->nClusters[0][0], sizeof(ioPtrs->clustersNative->nClusters[0][0]), NSECTORS * GPUCA_NROWS, fp);
+      fwrite(&ioPtrs->clustersNative->nClusters[0][0], sizeof(ioPtrs->clustersNative->nClusters[0][0]), NSECTORS * GPUTPCGeometry::NROWS, fp);
       if (ioPtrs->clustersNative->clustersMCTruth) {
         const auto& buffer = ioPtrs->clustersNative->clustersMCTruth->getBuffer();
         std::pair<const char*, size_t> tmp = {buffer.data(), buffer.size()};
@@ -188,7 +188,7 @@ int32_t GPUChainTracking::ReadData(const char* filename)
   int32_t nClustersTotal = 0;
   mIOMem.clusterNativeAccess.reset(new ClusterNativeAccess);
   if (ReadData<ClusterNative>(fp, &mIOMem.clusterNativeAccess->clustersLinear, &mIOMem.clusterNativeAccess->nClustersTotal, &mIOMem.clustersNative, InOutPointerType::CLUSTERS_NATIVE)) {
-    r = fread(&mIOMem.clusterNativeAccess->nClusters[0][0], sizeof(mIOMem.clusterNativeAccess->nClusters[0][0]), NSECTORS * GPUCA_NROWS, fp);
+    r = fread(&mIOMem.clusterNativeAccess->nClusters[0][0], sizeof(mIOMem.clusterNativeAccess->nClusters[0][0]), NSECTORS * GPUTPCGeometry::NROWS, fp);
     mIOMem.clusterNativeAccess->setOffsetPtrs();
     mIOPtrs.clustersNative = mIOMem.clusterNativeAccess.get();
     std::pair<const char*, size_t> tmp = {nullptr, 0};
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 2919cb05280a2..03c7904234f89 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -126,7 +126,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   }
   if (GetProcessingSettings().deterministicGPUReconstruction) {
     runKernel<GPUTPCGMMergerUnpackSaveNumber>({{1, -WarpSize(), 0, deviceType}}, NSECTORS);
-    runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::sectorTracks>({{GPUCA_NSECTORS, -WarpSize(), 0, deviceType}}, 0);
+    runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::sectorTracks>({{GPUTPCGeometry::NSECTORS, -WarpSize(), 0, deviceType}}, 0);
   }
   for (uint32_t i = 0; i < NSECTORS; i++) {
     runKernel<GPUTPCGMMergerUnpackSaveNumber>({{1, -WarpSize(), 0, deviceType}}, NSECTORS + i);
@@ -134,7 +134,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   }
   runKernel<GPUTPCGMMergerUnpackSaveNumber>({{1, -WarpSize(), 0, deviceType}}, 2 * NSECTORS);
   if (GetProcessingSettings().deterministicGPUReconstruction) {
-    runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::sectorTracks>({{GPUCA_NSECTORS, -WarpSize(), 0, deviceType}}, 1);
+    runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::sectorTracks>({{GPUTPCGeometry::NSECTORS, -WarpSize(), 0, deviceType}}, 1);
   }
   DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingSectorTracks, doGPU, Merger, &GPUTPCGMMerger::DumpSectorTracks, *mDebugFile);
 
@@ -253,7 +253,7 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
     auto* waitEvent = &mEvents->single;
     if (GetProcessingSettings().keepDisplayMemory || GetProcessingSettings().createO2Output <= 1 || mFractionalQAEnabled) {
       if (!(GetProcessingSettings().keepDisplayMemory || GetProcessingSettings().createO2Output <= 1)) {
-        size_t size = mRec->Res(Merger.MemoryResOutput()).Size() + GPUCA_MEMALIGN;
+        size_t size = mRec->Res(Merger.MemoryResOutput()).Size() + constants::GPU_MEMALIGN;
         void* buffer = GetQA()->AllocateScratchBuffer(size);
         void* bufferEnd = Merger.SetPointersOutput(buffer);
         if ((size_t)((char*)bufferEnd - (char*)buffer) > size) {
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
index 475809e8d88f2..bcaaa92bddb12 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingSectorTracker.cxx
@@ -97,7 +97,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     processors()->tpcTrackers[iSector].SetupCommonMemory();
   }
 
-  bool streamInit[GPUCA_MAX_STREAMS] = {false};
+  bool streamInit[constants::GPU_MAX_STREAMS] = {false};
   int32_t streamInitAndOccMap = mRec->NStreams() - 1;
 
   bool initializeOccMap = param().rec.tpc.occupancyMapTimeBins || param().rec.tpc.sysClusErrorC12Norm;
@@ -126,7 +126,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     uint32_t* ptr = doGPU ? mInputsShadow->mTPCClusterOccupancyMap : mInputsHost->mTPCClusterOccupancyMap;
     auto* ptrTmp = (GPUTPCClusterOccupancyMapBin*)mRec->AllocateVolatileMemory(GPUTPCClusterOccupancyMapBin::getTotalSize(param()), doGPU);
     runKernel<GPUMemClean16>(GetGridAutoStep(streamInitAndOccMap, RecoStep::TPCSectorTracking), ptrTmp, GPUTPCClusterOccupancyMapBin::getTotalSize(param()));
-    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fill>(GetGridBlk(GPUCA_NSECTORS * GPUCA_NROWS, streamInitAndOccMap), ptrTmp);
+    runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fill>(GetGridBlk(GPUTPCGeometry::NSECTORS * GPUTPCGeometry::NROWS, streamInitAndOccMap), ptrTmp);
     runKernel<GPUTPCCreateOccupancyMap, GPUTPCCreateOccupancyMap::fold>(GetGridBlk(mInputsHost->mTPCClusterOccupancyMapSize, streamInitAndOccMap), ptrTmp, ptr + 2);
     mRec->ReturnVolatileMemory();
     mInputsHost->mTPCClusterOccupancyMap[1] = param().rec.tpc.occupancyMapTimeBins * 0x10000 + param().rec.tpc.occupancyMapTimeBinsAverage;
@@ -154,10 +154,10 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       GPUInfo("Creating Sector Data (Sector %d)", iSector);
     }
     TransferMemoryResourcesToGPU(RecoStep::TPCSectorTracking, &trk, useStream);
-    runKernel<GPUTPCCreateTrackingData>({doGPU ? GetGridBlk(GPUCA_NROWS, useStream) : GetGridAuto(0), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}}); // TODO: Check why GetGridAuto(0) is much fast on CPU
+    runKernel<GPUTPCCreateTrackingData>({doGPU ? GetGridBlk(GPUTPCGeometry::NROWS, useStream) : GetGridAuto(0), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}}); // TODO: Check why GetGridAuto(0) is much fast on CPU
     streamInit[useStream] = true;
     if (GetProcessingSettings().deterministicGPUReconstruction) {
-      runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::hitData>({GetGridBlk(GPUCA_NROWS, useStream), {iSector}});
+      runKernel<GPUTPCSectorDebugSortKernels, GPUTPCSectorDebugSortKernels::hitData>({GetGridBlk(GPUTPCGeometry::NROWS, useStream), {iSector}});
     }
     if (!doGPU && trk.CheckEmptySector() && GetProcessingSettings().debugLevel == 0) {
       return;
@@ -176,7 +176,7 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
     }
 
     runKernel<GPUMemClean16>(GetGridAutoStep(useStream, RecoStep::TPCSectorTracking), trkShadow.Data().HitWeights(), trkShadow.Data().NumberOfHitsPlusAlign() * sizeof(*trkShadow.Data().HitWeights()));
-    runKernel<GPUTPCNeighboursFinder>({GetGridBlk(GPUCA_NROWS, useStream), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}});
+    runKernel<GPUTPCNeighboursFinder>({GetGridBlk(GPUTPCGeometry::NROWS, useStream), {iSector}, {nullptr, streamInit[useStream] ? nullptr : &mEvents->init}});
     streamInit[useStream] = true;
 
     if (GetProcessingSettings().keepDisplayMemory) {
@@ -187,10 +187,10 @@ int32_t GPUChainTracking::RunTPCTrackingSectors_internal()
       }
     }
 
-    runKernel<GPUTPCNeighboursCleaner>({GetGridBlk(GPUCA_NROWS - 2, useStream), {iSector}});
+    runKernel<GPUTPCNeighboursCleaner>({GetGridBlk(GPUTPCGeometry::NROWS - 2, useStream), {iSector}});
     DoDebugAndDump(RecoStep::TPCSectorTracking, GPUChainTrackingDebugFlags::TPCLinks, trk, &GPUTPCTracker::DumpLinks, *mDebugFile, 1);
 
-    runKernel<GPUTPCStartHitsFinder>({GetGridBlk(GPUCA_NROWS - 6, useStream), {iSector}});
+    runKernel<GPUTPCStartHitsFinder>({GetGridBlk(GPUTPCGeometry::NROWS - 6, useStream), {iSector}});
     if (mRec->getGPUParameters(doGPU).par_SORT_STARTHITS) {
       runKernel<GPUTPCStartHitsSorter>({GetGridAuto(useStream), {iSector}});
     }
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
index 3616ee593069f..770997333aa23 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingTransformation.cxx
@@ -131,7 +131,7 @@ int32_t GPUChainTracking::ForwardTPCDigits()
   if (GetRecoStepsGPU() & RecoStep::TPCClusterFinding) {
     throw std::runtime_error("Cannot forward TPC digits with Clusterizer on GPU");
   }
-  std::vector<ClusterNative> tmp[NSECTORS][GPUCA_NROWS];
+  std::vector<ClusterNative> tmp[NSECTORS][GPUTPCGeometry::NROWS];
   uint32_t nTotal = 0;
   const float zsThreshold = param().rec.tpc.zsThreshold;
   for (int32_t i = 0; i < NSECTORS; i++) {
@@ -152,8 +152,8 @@ int32_t GPUChainTracking::ForwardTPCDigits()
   mIOMem.clustersNative.reset(new ClusterNative[nTotal]);
   nTotal = 0;
   mClusterNativeAccess->clustersLinear = mIOMem.clustersNative.get();
-  for (int32_t i = 0; i < NSECTORS; i++) {
-    for (int32_t j = 0; j < GPUCA_NROWS; j++) {
+  for (uint32_t i = 0; i < NSECTORS; i++) {
+    for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
       mClusterNativeAccess->nClusters[i][j] = tmp[i][j].size();
       memcpy(&mIOMem.clustersNative[nTotal], tmp[i][j].data(), tmp[i][j].size() * sizeof(*mClusterNativeAccess->clustersLinear));
       nTotal += tmp[i][j].size();
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index d476d28b3fb7b..b9b9a14b82b98 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -395,7 +395,7 @@ void* GPUTPCGMMerger::SetPointersMerger(void* mem)
   computePointerWithAlignment(mem, mTrackCCRoots, mNTotalSectorTracks);
   void* memMax = mem;
   mem = memBase;
-  computePointerWithAlignment(mem, mTrackIDs, GPUCA_NSECTORS * mNMaxSingleSectorTracks); // UnpackResetIds - RefitSectorTracks - UnpackSectorGlobal
+  computePointerWithAlignment(mem, mTrackIDs, GPUTPCGeometry::NSECTORS * mNMaxSingleSectorTracks); // UnpackResetIds - RefitSectorTracks - UnpackSectorGlobal
   memMax = (void*)std::max((size_t)mem, (size_t)memMax);
   mem = memBase;
   computePointerWithAlignment(mem, mTrackSort, mNMaxTracks); // PrepareForFit0 - SortTracksQPt - PrepareForFit1 - PrepareForFit1 / Finalize0 - Finalize2
@@ -553,7 +553,7 @@ GPUd() int32_t GPUTPCGMMerger::RefitSectorTrack(GPUTPCGMSectorTrack& sectorTrack
 {
   GPUTPCGMPropagator prop;
   prop.SetMaterialTPC();
-  prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
+  prop.SetMaxSinPhi(constants::MAX_SIN_PHI);
   prop.SetSeedingErrors(true); // Larger errors for seeds, better since we don't start with good hypothesis
   prop.SetFitInProjections(true); // TODO: Was false, consider reenabling after fitInProjection is fixed
   prop.SetPolynomialField(&Param().polynomialField);
@@ -671,7 +671,7 @@ GPUd() void GPUTPCGMMerger::RefitSectorTracks(int32_t nBlocks, int32_t nThreads,
     SetTrackClusterT(track, iSector, sectorTr);
     if (RefitSectorTrack(track, sectorTr, alpha, iSector)) {
       track.Set(this, sectorTr, alpha, iSector); // TODO: Why does the refit fail, it shouldn't, this workaround should be removed
-      if (!track.FilterErrors(this, iSector, GPUCA_MAX_SIN_PHI, 0.1f)) {
+      if (!track.FilterErrors(this, iSector, constants::MAX_SIN_PHI, 0.1f)) {
         continue;
       }
     }
@@ -1333,7 +1333,7 @@ GPUd() void GPUTPCGMMerger::ResolveMergeSectors(GPUResolveSharedMemory& smem, in
 
 GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, int32_t itr)
 {
-  if (Param().rec.tpc.mergerCERowLimit > 0 && CAMath::Abs(track->QPt()) * Param().qptB5Scaler < 0.3f && (cls.row < Param().rec.tpc.mergerCERowLimit || cls.row >= GPUCA_NROWS - Param().rec.tpc.mergerCERowLimit)) {
+  if (Param().rec.tpc.mergerCERowLimit > 0 && CAMath::Abs(track->QPt()) * Param().qptB5Scaler < 0.3f && (cls.row < Param().rec.tpc.mergerCERowLimit || cls.row >= GPUTPCGeometry::NROWS - Param().rec.tpc.mergerCERowLimit)) {
     return;
   }
 
@@ -1351,7 +1351,7 @@ GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const
   for (int32_t attempt = 0; attempt < 2; attempt++) {
     GPUTPCGMBorderTrack b;
     const float x0 = GPUTPCGeometry::Row2X(attempt == 0 ? 63 : cls.row);
-    if (track->TransportToX(this, x0, Param().bzCLight, b, GPUCA_MAX_SIN_PHI_LOW)) {
+    if (track->TransportToX(this, x0, Param().bzCLight, b, constants::MAX_SIN_PHI_LOW)) {
       b.SetTrackID(itr);
       b.SetNClusters(mMergedTracks[itr].NClusters());
       if (CAMath::Abs(b.Cov()[4]) >= 0.5f) {
@@ -1452,9 +1452,9 @@ GPUd() void GPUTPCGMMerger::MergeCE(int32_t nBlocks, int32_t nThreads, int32_t i
       }
       trk[1]->SetFirstClusterRef(newRef);
       trk[1]->SetNClusters(trk[0]->NClusters() + trk[1]->NClusters());
-      if (trk[1]->NClusters() > GPUCA_MERGER_MAX_TRACK_CLUSTERS) {
-        trk[1]->SetFirstClusterRef(trk[1]->FirstClusterRef() + trk[1]->NClusters() - GPUCA_MERGER_MAX_TRACK_CLUSTERS);
-        trk[1]->SetNClusters(GPUCA_MERGER_MAX_TRACK_CLUSTERS);
+      if (trk[1]->NClusters() > constants::MERGER_MAX_TRACK_CLUSTERS) {
+        trk[1]->SetFirstClusterRef(trk[1]->FirstClusterRef() + trk[1]->NClusters() - constants::MERGER_MAX_TRACK_CLUSTERS);
+        trk[1]->SetNClusters(constants::MERGER_MAX_TRACK_CLUSTERS);
       }
       trk[1]->SetCCE(true);
       trk[0]->SetNClusters(0);
@@ -1489,7 +1489,7 @@ struct GPUTPCGMMerger_CompareClusterIds {
 GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
 {
   static constexpr int32_t kMaxParts = 16;
-  static constexpr int32_t kMaxClusters = GPUCA_MERGER_MAX_TRACK_CLUSTERS;
+  static constexpr int32_t kMaxClusters = constants::MERGER_MAX_TRACK_CLUSTERS;
 
   GPUTPCGMSectorTrack* trackParts[kMaxParts];
 
@@ -1597,7 +1597,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
 
     do {
       int32_t nParts = 0;
-      int32_t nHits = 0;
+      uint32_t nHits = 0;
 
       GPUTPCGMSectorTrack* tr = trbase;
       while (true) {
@@ -1668,14 +1668,14 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         }
         nHits += nTrackHits;
       }
-      if (nHits < GPUCA_TPC_MIN_HITS_B5(trbase->QPt() * Param().qptB5Scaler)) {
+      if (nHits < Param().tpcMinHitsB5(trbase->QPt() * Param().qptB5Scaler)) {
         break;
       }
 
       const bool mustReverse = revertInSegment ^ (leg & 1);
       bool ordered = !mustReverse;
       if (ordered) {
-        for (int32_t i = 1; i < nHits; i++) {
+        for (uint32_t i = 1; i < nHits; i++) {
           if ((trackClusters[i].row > trackClusters[i - 1].row) ^ mustReverse || trackClusters[i].id == trackClusters[i - 1].id) {
             ordered = false;
             break;
@@ -1688,7 +1688,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
         int32_t nTmpHits = 0;
         trackCluster trackClustersUnsorted[kMaxClusters];
         int16_t clusterIndices[kMaxClusters];
-        for (int32_t i = 0; i < nHits; i++) {
+        for (uint32_t i = 0; i < nHits; i++) {
           trackClustersUnsorted[i] = trackClusters[i];
           clusterIndices[i] = i;
         }
@@ -1709,7 +1709,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
 
         int32_t nFilteredHits = 0;
         int32_t indPrev = -1;
-        for (int32_t i = 0; i < nHits; i++) {
+        for (uint32_t i = 0; i < nHits; i++) {
           int32_t ind = clusterIndices[i];
           if (indPrev >= 0 && trackClustersUnsorted[ind].id == trackClustersUnsorted[indPrev].id) {
             continue;
@@ -1730,7 +1730,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
 
       GPUTPCGMMergedTrackHit* const cl = mClusters + iMergedTrackFirstCluster;
 
-      for (int32_t i = 0; i < nHits; i++) {
+      for (uint32_t i = 0; i < nHits; i++) {
         uint8_t state;
         const ClusterNative& c = GetConstantMem()->ioPtrs.clustersNative->clustersLinear[trackClusters[i].id];
         state = c.getFlags();
@@ -1770,7 +1770,7 @@ GPUd() void GPUTPCGMMerger::CollectMergedTracks(int32_t nBlocks, int32_t nThread
 
       GPUTPCGMBorderTrack b;
       const float toX = GPUTPCGeometry::Row2X(cl[0].row);
-      if (p2.TransportToX<2>(this, toX, Param().bzCLight, b, GPUCA_MAX_SIN_PHI, false)) {
+      if (p2.TransportToX<2>(this, toX, Param().bzCLight, b, constants::MAX_SIN_PHI, false)) {
         p1.X() = toX;
         p1.Y() = b.Par()[0];
         p1.Z() = b.Par()[1];
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 8f554c24c1d8c..3ff9969365121 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -63,7 +63,7 @@ class GPUTPCGMMerger : public GPUProcessor
   ~GPUTPCGMMerger() = default;
   GPUTPCGMMerger(const GPUTPCGMMerger&) = delete;
   const GPUTPCGMMerger& operator=(const GPUTPCGMMerger&) const = delete;
-  static constexpr const int32_t NSECTORS = GPUCA_NSECTORS; //* N sectors
+  static constexpr const int32_t NSECTORS = GPUTPCGeometry::NSECTORS; //* N sectors
 
   struct memory {
     GPUAtomic(uint32_t) nRetryRefit;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 93fae97a4bd54..9dcf2cb3e2fe7 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -319,7 +319,7 @@ void GPUTPCGMMerger::DebugRefitMergedTrack(const GPUTPCGMMergedTrack& track) con
     GPUTPCGMPropagator prop;
     prop.SetMaterialTPC();
     prop.SetPolynomialField(&Param().polynomialField);
-    prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
+    prop.SetMaxSinPhi(constants::MAX_SIN_PHI);
     prop.SetPropagateBzOnly(false);
     prop.SetMatLUT(Param().rec.useMatLUT ? GetConstantMem()->calibObjects.matLUT : nullptr);
     prop.SetTrack(&trk.Param(), trk.GetAlpha());
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h b/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
index 731439aab0be2..99c47b6228889 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerTypes.h
@@ -37,7 +37,7 @@ struct InterpolationErrorHit {
 };
 
 struct InterpolationErrors {
-  InterpolationErrorHit hit[GPUCA_MERGER_MAX_TRACK_CLUSTERS];
+  InterpolationErrorHit hit[constants::MERGER_MAX_TRACK_CLUSTERS];
 };
 
 struct GPUResolveSharedMemory : public GPUKernelTemplate::GPUSharedMemoryScan64<int16_t, GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCGMMergerResolve_step3)> {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
index 44915ec4ab6e9..d7c8eb9c44aab 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMO2Output.cxx
@@ -76,7 +76,7 @@ GPUdii() void GPUTPCGMO2Output::Thread<GPUTPCGMO2Output::prepare>(int32_t nBlock
     if (nCl == 0) {
       continue;
     }
-    if (nCl + 2 < GPUCA_TPC_MIN_HITS_B5(tracks[i].GetParam().GetQPt() * merger.Param().qptB5Scaler)) { // Give 2 hits tolerance in the primary leg, compared to the full fit of the looper
+    if (nCl + 2 < merger.Param().tpcMinHitsB5(tracks[i].GetParam().GetQPt() * merger.Param().qptB5Scaler)) { // Give 2 hits tolerance in the primary leg, compared to the full fit of the looper
       continue;
     }
     if (merger.Param().rec.tpc.minNClustersFinalTrack != -1 && nCl < (uint32_t)merger.Param().rec.tpc.minNClustersFinalTrack) {
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPhysicalTrackModel.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPhysicalTrackModel.cxx
index f237d1d18057e..ed60f2d86f63c 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPhysicalTrackModel.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPhysicalTrackModel.cxx
@@ -47,7 +47,7 @@ GPUd() int32_t GPUTPCGMPhysicalTrackModel::PropagateToXBzLightNoUpdate(float x,
   float pye = mPy - dx * b; // extrapolated py
   float pxe2 = pt2 - pye * pye;
 
-  if (mPx < (1.f - GPUCA_MAX_SIN_PHI) || pxe2 < (1.f - GPUCA_MAX_SIN_PHI) * (1.f - GPUCA_MAX_SIN_PHI)) {
+  if (mPx < (1.f - constants::MAX_SIN_PHI) || pxe2 < (1.f - constants::MAX_SIN_PHI) * (1.f - constants::MAX_SIN_PHI)) {
     return -1; // can not transport to x=x
   }
   float pxe = CAMath::Sqrt(pxe2); // extrapolated px
@@ -148,8 +148,8 @@ GPUd() int32_t GPUTPCGMPhysicalTrackModel::PropagateToXBxByBz(float x, float Bx,
 
   // transport in rotated coordinate system to X''=xe:
 
-  if (t.Px() < (1.f - GPUCA_MAX_SIN_PHI)) {
-    t.Px() = 1.f - GPUCA_MAX_SIN_PHI;
+  if (t.Px() < (1.f - constants::MAX_SIN_PHI)) {
+    t.Px() = 1.f - constants::MAX_SIN_PHI;
   }
   if (t.PropagateToXBzLightNoUpdate(xe, bb, dLp) != 0) {
     return -1;
@@ -171,8 +171,8 @@ GPUd() int32_t GPUTPCGMPhysicalTrackModel::PropagateToXBxByBz(float x, float Bx,
   // a small (hopefully) additional step to X=x. Perhaps it may be replaced by linear extrapolation.
 
   float ddLp = 0;
-  if (t.Px() < (1.f - GPUCA_MAX_SIN_PHI)) {
-    t.Px() = 1.f - GPUCA_MAX_SIN_PHI;
+  if (t.Px() < (1.f - constants::MAX_SIN_PHI)) {
+    t.Px() = 1.f - constants::MAX_SIN_PHI;
   }
   if (t.PropagateToXBzLightNoUpdate(x, Bz, ddLp) != 0) {
     return -1;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPhysicalTrackModel.h b/GPU/GPUTracking/Merger/GPUTPCGMPhysicalTrackModel.h
index eac86a5598644..50c277c07b8f4 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPhysicalTrackModel.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPhysicalTrackModel.h
@@ -176,11 +176,11 @@ GPUdi() void GPUTPCGMPhysicalTrackModel::Set(const GPUTPCGMTrackParam& GPUrestri
 
   mPt = 1.f / pti;
   mSinPhi = t.GetSinPhi();
-  if (mSinPhi > GPUCA_MAX_SIN_PHI) {
-    mSinPhi = GPUCA_MAX_SIN_PHI;
+  if (mSinPhi > constants::MAX_SIN_PHI) {
+    mSinPhi = constants::MAX_SIN_PHI;
   }
-  if (mSinPhi < -GPUCA_MAX_SIN_PHI) {
-    mSinPhi = -GPUCA_MAX_SIN_PHI;
+  if (mSinPhi < -constants::MAX_SIN_PHI) {
+    mSinPhi = -constants::MAX_SIN_PHI;
   }
   mCosPhi = CAMath::Sqrt((1.f - mSinPhi) * (1.f + mSinPhi));
   mSecPhi = 1.f / mCosPhi;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
index f8f1269acac3a..974a0b3ea2074 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.cxx
@@ -348,7 +348,7 @@ GPUd() int32_t GPUTPCGMPropagator::FollowLinearization(const GPUTPCGMPhysicalTra
   float d4 = p[4] - mT0.QPt();
 
   float newSinPhi = ey1 + d2 + j24 * d4;
-  if (mT->NDF() >= 15 && CAMath::Abs(newSinPhi) > GPUCA_MAX_SIN_PHI) {
+  if (mT->NDF() >= 15 && CAMath::Abs(newSinPhi) > constants::MAX_SIN_PHI) {
     return -4;
   }
 
@@ -523,7 +523,7 @@ GPUd() int32_t GPUTPCGMPropagator::GetPropagatedYZ(float x, float& GPUrestrict()
   float ex = mT0.CosPhi();
   float ey = mT0.SinPhi();
   float ey1 = ey - k * dx;
-  if (CAMath::Abs(ey1) > GPUCA_MAX_SIN_PHI) {
+  if (CAMath::Abs(ey1) > constants::MAX_SIN_PHI) {
     return 1;
   }
   float ss = ey + ey1;
@@ -550,12 +550,12 @@ GPUd() int32_t GPUTPCGMPropagator::GetPropagatedYZ(float x, float& GPUrestrict()
   return 0;
 }
 
-GPUd() void GPUTPCGMPropagator::GetErr2(float& GPUrestrict() err2Y, float& GPUrestrict() err2Z, const GPUParam& GPUrestrict() param, float posZ, int32_t iRow, int16_t clusterState, int8_t sector, float time, float avgCharge, float charge) const
+GPUd() void GPUTPCGMPropagator::GetErr2(float& GPUrestrict() err2Y, float& GPUrestrict() err2Z, const GPUParam& GPUrestrict() param, float posZ, int32_t iRow, int16_t clusterState, uint8_t sector, float time, float avgCharge, float charge) const
 {
   GetErr2(err2Y, err2Z, param, mT0.GetSinPhi(), mT0.DzDs(), posZ, mT->GetX(), mT->GetY(), iRow, clusterState, sector, time, avgCharge, charge, mSeedingErrors);
 }
 
-GPUd() void GPUTPCGMPropagator::GetErr2(float& GPUrestrict() err2Y, float& GPUrestrict() err2Z, const GPUParam& GPUrestrict() param, float snp, float tgl, float posZ, float trackX, float trackY, int32_t iRow, int16_t clusterState, int8_t sector, float time, float avgCharge, float charge, bool seedingErrors)
+GPUd() void GPUTPCGMPropagator::GetErr2(float& GPUrestrict() err2Y, float& GPUrestrict() err2Z, const GPUParam& GPUrestrict() param, float snp, float tgl, float posZ, float trackX, float trackY, int32_t iRow, int16_t clusterState, uint8_t sector, float time, float avgCharge, float charge, bool seedingErrors)
 {
 #ifdef GPUCA_RUN2
   if (seedingErrors) {
@@ -566,15 +566,15 @@ GPUd() void GPUTPCGMPropagator::GetErr2(float& GPUrestrict() err2Y, float& GPUre
     param.GetClusterErrors2(sector, iRow, posZ, snp, tgl, time, avgCharge, charge, err2Y, err2Z);
   }
   param.UpdateClusterError2ByState(clusterState, err2Y, err2Z);
-  float statErr2 = param.GetSystematicClusterErrorIFC2(trackX, trackY, posZ, sector >= (GPUCA_NSECTORS / 2));
-  if (sector >= GPUCA_NSECTORS / 2 + 1 && sector <= GPUCA_NSECTORS / 2 + 2) {
+  float statErr2 = param.GetSystematicClusterErrorIFC2(trackX, trackY, posZ, sector >= (GPUTPCGeometry::NSECTORS / 2));
+  if (sector >= GPUTPCGeometry::NSECTORS / 2 + 1 && sector <= GPUTPCGeometry::NSECTORS / 2 + 2) {
     statErr2 += param.GetSystematicClusterErrorC122(trackX, trackY, sector);
   }
   err2Y += statErr2;
   err2Z += statErr2;
 }
 
-GPUd() float GPUTPCGMPropagator::PredictChi2(float posY, float posZ, int32_t iRow, const GPUParam& GPUrestrict() param, int16_t clusterState, int8_t sector, float time, float avgCharge, float charge) const
+GPUd() float GPUTPCGMPropagator::PredictChi2(float posY, float posZ, int32_t iRow, const GPUParam& GPUrestrict() param, int16_t clusterState, uint8_t sector, float time, float avgCharge, float charge) const
 {
   float err2Y, err2Z;
   GetErr2(err2Y, err2Z, param, posZ, iRow, clusterState, sector, time, avgCharge, charge);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
index 47e6c870dac25..c3f7aac84a1a5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMPropagator.h
@@ -108,7 +108,7 @@ class GPUTPCGMPropagator
   GPUd() int32_t Update(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t rejectChi2, bool refit, float err2Y, float err2Z);
   GPUd() int32_t Update(float posY, float posZ, int16_t clusterState, bool rejectChi2, float err2Y, float err2Z, const GPUParam* param = nullptr);
   GPUd() int32_t InterpolateReject(const GPUParam& param, float posY, float posZ, int16_t clusterState, int8_t rejectChi2, gputpcgmmergertypes::InterpolationErrorHit* inter, float err2Y, float err2Z, float deltaZ);
-  GPUd() float PredictChi2(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, int8_t sideC, float time, float avgCharge, float charge) const;
+  GPUd() float PredictChi2(float posY, float posZ, int32_t iRow, const GPUParam& param, int16_t clusterState, uint8_t sector, float time, float avgCharge, float charge) const;
   GPUd() float PredictChi2(float posY, float posZ, float err2Y, float err2Z) const;
   GPUd() static int32_t RejectCluster(float chiY, float chiZ, uint8_t clusterState)
   {
@@ -134,8 +134,8 @@ class GPUTPCGMPropagator
   /// Bx,By,Bz in local coordinates rotated to Alpha
   GPUd() void GetBxByBz(float Alpha, float X, float Y, float Z, float B[3]) const;
 
-  GPUd() void GetErr2(float& err2Y, float& err2Z, const GPUParam& param, float posZ, int32_t iRow, int16_t clusterState, int8_t sector, float time, float avgCharge, float charge) const;
-  GPUd() static void GetErr2(float& err2Y, float& err2Z, const GPUParam& param, float snp, float tgl, float posZ, float trackX, float trackY, int32_t iRow, int16_t clusterState, int8_t sector, float time, float avgCharge, float charge, bool seedingErrors);
+  GPUd() void GetErr2(float& err2Y, float& err2Z, const GPUParam& param, float posZ, int32_t iRow, int16_t clusterState, uint8_t sector, float time, float avgCharge, float charge) const;
+  GPUd() static void GetErr2(float& err2Y, float& err2Z, const GPUParam& param, float snp, float tgl, float posZ, float trackX, float trackY, int32_t iRow, int16_t clusterState, uint8_t sector, float time, float avgCharge, float charge, bool seedingErrors);
 
   GPUd() float GetAlpha() const { return mAlpha; }
   GPUd() void SetAlpha(float v) { mAlpha = v; }
@@ -179,7 +179,7 @@ class GPUTPCGMPropagator
   float mAlpha = 0.f;    // rotation angle of the track coordinate system
   float mCosAlpha = 1.f; // cos of the rotation angle
   float mSinAlpha = 0.f; // sin of the rotation angle
-  float mMaxSinPhi = GPUCA_MAX_SIN_PHI;
+  float mMaxSinPhi = constants::MAX_SIN_PHI;
   GPUTPCGMPhysicalTrackModel mT0;
   MaterialCorrection mMaterial;
   FieldRegion mFieldRegion = TPC;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
index f5731a532e7f3..e84d037c936f5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.cxx
@@ -401,7 +401,7 @@ GPUd() bool GPUTPCGMSectorTrack::TransportToXAlpha(GPUTPCGMMerger* merger, float
     cosPhi = cP * cosAlpha + sP * sinAlpha;
     sinPhi = -cP * sinAlpha + sP * cosAlpha;
 
-    if (CAMath::Abs(sinPhi) > GPUCA_MAX_SIN_PHI || CAMath::Abs(cP) < 1.e-2f) {
+    if (CAMath::Abs(sinPhi) > constants::MAX_SIN_PHI || CAMath::Abs(cP) < 1.e-2f) {
       return 0;
     }
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
index 84102cd14ce5c..2c340bf9ad49b 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMSectorTrack.h
@@ -113,7 +113,7 @@ class GPUTPCGMSectorTrack
     mAlpha = t.mAlpha;
   }
 
-  GPUd() bool FilterErrors(const GPUTPCGMMerger* merger, int32_t iSector, float maxSinPhi = GPUCA_MAX_SIN_PHI, float sinPhiMargin = 0.f);
+  GPUd() bool FilterErrors(const GPUTPCGMMerger* merger, int32_t iSector, float maxSinPhi = constants::MAX_SIN_PHI, float sinPhiMargin = 0.f);
   template <int I = 0>
   GPUd() bool TransportToX(GPUTPCGMMerger* merger, float x, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi, bool doCov = true) const;
   GPUd() bool TransportToXAlpha(GPUTPCGMMerger* merger, float x, float sinAlpha, float cosAlpha, float Bz, GPUTPCGMBorderTrack& b, float maxSinPhi) const;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
index 5cbc12b4895f4..53e7f6c918309 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.cxx
@@ -96,7 +96,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     prop.SetPropagateBzOnly(param.rec.fitPropagateBzOnly == -1 ? !finalFit : param.rec.fitPropagateBzOnly);
     prop.SetMatLUT((param.rec.useMatLUT && finalFit) ? merger->GetConstantMem()->calibObjects.matLUT : nullptr);
     prop.SetTrack(this, iWay ? prop.GetAlpha() : Alpha);
-    ConstrainSinPhi(iWay == 0 ? 0.95f : GPUCA_MAX_SIN_PHI_LOW);
+    ConstrainSinPhi(iWay == 0 ? 0.95f : constants::MAX_SIN_PHI_LOW);
     CADEBUG(printf("Fitting track %d way %d (sector %d, alpha %f) !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", iTrk, iWay, CAMath::Float2IntRn(prop.GetAlpha() / kSectAngle) + (mP[1] < 0 ? 18 : 0), prop.GetAlpha()));
 
     N = 0;
@@ -157,7 +157,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
       if (allowChangeClusters && lastRow != 255 && CAMath::Abs(cluster.row - lastRow) > 1) {
         if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.par, dodEdx)) {
           bool dodEdx = param.dodEdxEnabled && param.rec.tpc.adddEdxSubThresholdClusters && finalFit && CAMath::Abs(cluster.row - lastRow) == 2;
-          dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, track.Leg() == 0, prop, inFlyDirection, GPUCA_MAX_SIN_PHI, dodEdx);
+          dodEdx = AttachClustersPropagate(merger, cluster.sector, lastRow, cluster.row, iTrk, track.Leg() == 0, prop, inFlyDirection, constants::MAX_SIN_PHI, dodEdx);
           if (dodEdx) {
             dEdx.fillSubThreshold(lastRow - wayDirection);
             if GPUCA_RTC_CONSTEXPR (GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMask) != GPUCA_GET_CONSTEXPR(param.rec.tpc, dEdxClusterRejectionFlagMaskAlt)) {
@@ -344,7 +344,7 @@ GPUd() bool GPUTPCGMTrackParam::Fit(GPUTPCGMMerger* GPUrestrict() merger, int32_
     o2::utils::DebugStreamer::instance()->getStreamer("debug_accept_track", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("debug_accept_track").data() << "iTrk=" << iTrk << "outerParam=" << track.OuterParam() << "track=" << this << "ihitStart=" << ihitStart << "\n";
   })
 
-  if (!(N + NTolerated >= GPUCA_TPC_MIN_HITS_B5(mP[4] * param.qptB5Scaler) && 2 * NTolerated <= CAMath::Max(10, N) && CheckNumericalQuality(covYYUpd))) {
+  if (!(N + NTolerated >= (int32_t)param.tpcMinHitsB5(mP[4] * param.qptB5Scaler) && 2 * NTolerated <= CAMath::Max(10, N) && CheckNumericalQuality(covYYUpd))) {
     return false; // TODO: NTolerated should never become that large, check what is going wrong!
   }
   if (param.rec.tpc.minNClustersFinalTrack != -1 && N + NTolerated < param.rec.tpc.minNClustersFinalTrack) {
@@ -624,10 +624,10 @@ GPUdii() void GPUTPCGMTrackParam::StoreOuter(gputpcgmmergertypes::GPUTPCOuterPar
 
 GPUdic(0, 1) void GPUTPCGMTrackParam::StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, float alpha)
 {
-  if (iRow == 0 || iRow == GPUCA_NROWS - 1) {
+  if (iRow == 0 || iRow == GPUTPCGeometry::NROWS - 1) {
     return;
   }
-  if (CAMath::Abs(mP[2]) >= GPUCA_MAX_SIN_PHI) { // TODO: How can we avoid this?
+  if (CAMath::Abs(mP[2]) >= constants::MAX_SIN_PHI) { // TODO: How can we avoid this?
     return;
   }
   if (CAMath::Abs(mP[2]) < 0.75) {
@@ -658,7 +658,7 @@ GPUdii() void GPUTPCGMTrackParam::PropagateLooper(const GPUTPCGMMerger* GPUrestr
   GPUTPCGMPropagator prop;
   prop.SetMaterialTPC();
   prop.SetPolynomialField(&Merger->Param().polynomialField);
-  prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
+  prop.SetMaxSinPhi(constants::MAX_SIN_PHI);
   prop.SetMatLUT(Merger->Param().rec.useMatLUT ? Merger->GetConstantMem()->calibObjects.matLUT : nullptr);
   prop.SetSeedingErrors(false);
   prop.SetFitInProjections(true);
@@ -669,11 +669,11 @@ GPUdii() void GPUTPCGMTrackParam::PropagateLooper(const GPUTPCGMMerger* GPUrestr
   if (false) {
     data.param.AttachClustersLooper(Merger, data.sector, data.row, data.track, data.outwards, prop);
   } else {
-    data.param.AttachClustersLooperFollow(Merger, prop, data.sector, data.row, data.track, data.outwards);
+    data.param.AttachClustersLooperFollow(Merger, prop, data.sector, data.track, data.outwards);
   }
 }
 
-GPUdi() void GPUTPCGMTrackParam::AttachClustersLooperFollow(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& GPUrestrict() prop, int32_t sector, int32_t iRow, int32_t iTrack, bool up)
+GPUdi() void GPUTPCGMTrackParam::AttachClustersLooperFollow(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& GPUrestrict() prop, int32_t sector, int32_t iTrack, bool up)
 {
   float toX = mX;
   bool inFlyDirection = (Merger->MergedTracks()[iTrack].Leg() & 1) ^ up;
@@ -681,7 +681,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooperFollow(const GPUTPCGMMerger
   static constexpr float kSectAngle = 2 * M_PI / 18.f;
   const GPUParam& GPUrestrict() param = Merger->Param();
   bool right = (mP[2] < 0) ^ up;
-  const int32_t sectorSide = sector >= (GPUCA_NSECTORS / 2) ? (GPUCA_NSECTORS / 2) : 0;
+  const int32_t sectorSide = sector >= (int32_t)(GPUTPCGeometry::NSECTORS / 2) ? (GPUTPCGeometry::NSECTORS / 2) : 0;
   float lrFactor = right ^ !up ? 1.f : -1.f;
   // clang-format off
   CADEBUG(printf("\nCIRCLE Track %d: Sector %d Alpha %f X %f Y %f Z %f SinPhi %f DzDs %f QPt %f - Right %d Up %d lrFactor %f\n", iTrack, sector, prop.GetAlpha(), mX, mP[0], mP[1], mP[2], mP[3], mP[4], (int32_t)right, (int32_t)up, lrFactor));
@@ -700,7 +700,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooperFollow(const GPUTPCGMMerger
       if (CAMath::Abs(mP[2]) > 0.7f) {
         return;
       }
-      if (up ? (-mP[0] * lrFactor > GPUTPCGeometry::Row2X(GPUCA_NROWS - 1)) : (-mP[0] * lrFactor < GPUTPCGeometry::Row2X(0))) {
+      if (up ? (-mP[0] * lrFactor > GPUTPCGeometry::Row2X(GPUTPCGeometry::NROWS - 1)) : (-mP[0] * lrFactor < GPUTPCGeometry::Row2X(0))) {
         return;
       }
       if (!((up ? (-mP[0] * lrFactor >= toX) : (-mP[0] * lrFactor <= toX)) || (right ^ (mP[2] > 0)))) {
@@ -712,7 +712,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooperFollow(const GPUTPCGMMerger
         return;
       }
       CADEBUG(printf("\tPropagated to y = %f: X %f Z %f SinPhi %f\n", mX, mP[0], mP[1], mP[2]));
-      for (int32_t j = 0; j < GPUCA_NROWS; j++) { // TODO: Avoid iterating over all rows
+      for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) { // TODO: Avoid iterating over all rows
         float rowX = GPUTPCGeometry::Row2X(j);
         if (CAMath::Abs(rowX - (-mP[0] * lrFactor)) < 1.5f) {
           CADEBUG(printf("\t\tAttempt row %d (X %f Y %f Z %f)\n", j, rowX, mX * lrFactor, mP[1]));
@@ -763,7 +763,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUr
     float exi = 1.f / ex;
     float dxBzQ = dx * -b * mP[4];
     float newSinPhi = SinPhi + dxBzQ;
-    if (CAMath::Abs(newSinPhi) > GPUCA_MAX_SIN_PHI_LOW) {
+    if (CAMath::Abs(newSinPhi) > constants::MAX_SIN_PHI_LOW) {
       // printf("Abort, newSinPhi %f\n", newSinPhi);
       return;
     }
@@ -788,7 +788,7 @@ GPUdi() void GPUTPCGMTrackParam::AttachClustersLooper(const GPUTPCGMMerger* GPUr
     float paramX = mP[2] > 0 ? -Y : Y;
     int32_t step = outwards ? 1 : -1;
     int32_t found = 0;
-    for (int32_t j = iRow; j >= 0 && j < GPUCA_NROWS && found < 3; j += step) {
+    for (int32_t j = iRow; j >= 0 && j < (int32_t)GPUTPCGeometry::NROWS && found < 3; j += step) {
       float rowX = mX + GPUTPCGeometry::Row2X(j) - myRowX;
       if (CAMath::Abs(rowX - paramX) < 1.5f) {
         // printf("Attempt row %d at y %f\n", j, X);
@@ -809,7 +809,7 @@ GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMergedTrackHit* clusters,
   return ShiftZ(merger, clusters[0].sector, tmp[0], tmp[1], tmp[2]);
 }
 
-GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merger, int32_t sector, float cltmax, float cltmin, float clx)
+GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merger, uint32_t sector, float cltmax, float cltmin, float clx)
 {
   if (!merger->Param().par.continuousTracking) {
     return 0.f;
@@ -843,7 +843,7 @@ GPUd() float GPUTPCGMTrackParam::ShiftZ(const GPUTPCGMMerger* GPUrestrict() merg
   }
 
   if (!beamlineReached) {
-    float refZ = ((sector < GPUCA_NSECTORS / 2) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * clx;
+    float refZ = ((sector < GPUTPCGeometry::NSECTORS / 2) ? merger->Param().rec.tpc.defaultZOffsetOverR : -merger->Param().rec.tpc.defaultZOffsetOverR) * clx;
     float basez;
     merger->GetConstantMem()->calibObjects.fastTransform->TransformIdealZ(sector, cltmax, basez, mTOffset);
     deltaZ = basez - refZ;
@@ -895,7 +895,7 @@ GPUd() bool GPUTPCGMTrackParam::CheckNumericalQuality(float overrideCovYY) const
   if ((overrideCovYY > 0 ? overrideCovYY : c[0]) > 4.f * 4.f || c[2] > 4.f * 4.f || c[5] > 2.f * 2.f || c[9] > 2.f * 2.f) {
     ok = 0;
   }
-  if (CAMath::Abs(mP[2]) > GPUCA_MAX_SIN_PHI) {
+  if (CAMath::Abs(mP[2]) > constants::MAX_SIN_PHI) {
     ok = 0;
   }
   if (!CheckCov()) {
@@ -919,7 +919,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
   GPUTPCGMTrackParam t = track.Param();
   float Alpha = track.Alpha();
   CADEBUG(int32_t nTrackHitsOld = nTrackHits; float ptOld = t.QPt());
-  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, attempt, GPUCA_MAX_SIN_PHI, track);
+  bool ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, attempt, constants::MAX_SIN_PHI, track);
   CADEBUG(printf("Finished Fit Track %d\n", iTrk));
   CADEBUG(printf("OUTPUT hits %d -> %d+%d = %d, QPt %f -> %f, SP %f, OK %d chi2 %f chi2ndf %f\n", nTrackHitsOld, nTrackHits, NTolerated, nTrackHits + NTolerated, ptOld, t.QPt(), t.SinPhi(), (int32_t)ok, t.Chi2(), t.Chi2() / CAMath::Max(1, nTrackHits)));
 
@@ -933,7 +933,7 @@ GPUdii() void GPUTPCGMTrackParam::RefitTrack(GPUTPCGMMergedTrack& GPUrestrict()
       NTolerated = 0; // Clusters not fit but tollerated for track length cut
       t = track.Param();
       Alpha = track.Alpha();
-      ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, 1, GPUCA_MAX_SIN_PHI, track);
+      ok = t.Fit(merger, iTrk, merger->Clusters() + track.FirstClusterRef(), nTrackHits, NTolerated, Alpha, 1, constants::MAX_SIN_PHI, track);
     } else {
       uint32_t nRefit = CAMath::AtomicAdd(&merger->Memory()->nRetryRefit, 1u);
       merger->RetryRefitIds()[nRefit] = iTrk;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
index f38ea4d320c14..51689753f1ca5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMTrackParam.h
@@ -146,11 +146,11 @@ class GPUTPCGMTrackParam
   GPUd() void MirrorTo(GPUTPCGMPropagator& prop, float toY, float toZ, bool inFlyDirection, const GPUParam& param, uint8_t row, uint8_t clusterState, bool mirrorParameters, int8_t sector);
   GPUd() int32_t MergeDoubleRowClusters(int32_t& ihit, int32_t wayDirection, GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, GPUTPCGMPropagator& prop, float& xx, float& yy, float& zz, int32_t maxN, float clAlpha, uint8_t& clusterState, bool rejectChi2);
 
-  GPUd() bool AttachClustersPropagate(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t lastRow, int32_t toRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop, bool inFlyDirection, float maxSinPhi = GPUCA_MAX_SIN_PHI, bool checkdEdx = false);
+  GPUd() bool AttachClustersPropagate(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t lastRow, int32_t toRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop, bool inFlyDirection, float maxSinPhi = constants::MAX_SIN_PHI, bool checkdEdx = false);
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, GPUTPCGMPropagator& prop); // Returns uncorrectedY for later use
   GPUd() float AttachClusters(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool goodLeg, float Y, float Z);
   GPUd() void AttachClustersLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, GPUTPCGMPropagator& prop);
-  GPUd() void AttachClustersLooperFollow(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards);
+  GPUd() void AttachClustersLooperFollow(const GPUTPCGMMerger* GPUrestrict() Merger, GPUTPCGMPropagator& prop, int32_t sector, int32_t iTrack, bool outwards);
   GPUd() void StoreLoopPropagation(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t sector, int32_t iRow, int32_t iTrack, bool outwards, float alpha);
   GPUd() void StoreOuter(gputpcgmmergertypes::GPUTPCOuterParam* outerParam, float alpha);
   GPUd() static void PropagateLooper(const GPUTPCGMMerger* GPUrestrict() Merger, int32_t loopIdx);
@@ -182,7 +182,7 @@ class GPUTPCGMTrackParam
   }
 
   GPUd() void Rotate(float alpha);
-  GPUd() float ShiftZ(const GPUTPCGMMerger* merger, int32_t sector, float cltmax, float cltmin, float clx);
+  GPUd() float ShiftZ(const GPUTPCGMMerger* merger, uint32_t sector, float cltmax, float cltmin, float clx);
   GPUd() float ShiftZ(const GPUTPCGMMergedTrackHit* clusters, const GPUTPCGMMerger* merger, int32_t N);
 
   GPUd() static float Reciprocal(float x) { return 1.f / x; }
@@ -202,7 +202,7 @@ class GPUTPCGMTrackParam
 
   GPUd() static void RefitTrack(GPUTPCGMMergedTrack& track, int32_t iTrk, GPUTPCGMMerger* merger, int32_t attempt);
 
-  GPUdi() void ConstrainSinPhi(float limit = GPUCA_MAX_SIN_PHI)
+  GPUdi() void ConstrainSinPhi(float limit = constants::MAX_SIN_PHI)
   {
     if (mP[2] > limit) {
       mP[2] = limit;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
index 6f5e000ddcc7b..70665bbe743d6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGlobalDebugSortKernels.cxx
@@ -26,7 +26,7 @@ using namespace o2::gpu;
 template <>
 GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels::clearIds>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int8_t)
 {
-  for (int32_t i = iBlock * nThreads + iThread; i < GPUCA_NSECTORS * merger.NMaxSingleSectorTracks(); i++) {
+  for (uint32_t i = iBlock * nThreads + iThread; i < GPUTPCGeometry::NSECTORS * merger.NMaxSingleSectorTracks(); i++) {
     merger.TrackIDs()[i] = -1;
   }
 }
@@ -37,8 +37,8 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
   if (iThread) {
     return;
   }
-  int32_t iStart = parameter ? GPUCA_NSECTORS : 0;
-  int32_t iEnd = iStart + GPUCA_NSECTORS;
+  int32_t iStart = parameter ? GPUTPCGeometry::NSECTORS : 0;
+  int32_t iEnd = iStart + GPUTPCGeometry::NSECTORS;
   for (int32_t i = iStart + iBlock; i < iEnd; i += nBlocks) {
     const int32_t offset = merger.SectorTrackInfoFirst(i);
     int32_t* GPUrestrict() tmp = merger.TmpSortMemory() + offset;
@@ -148,7 +148,7 @@ GPUdii() void GPUTPCGlobalDebugSortKernels::Thread<GPUTPCGlobalDebugSortKernels:
     }
   }
   GPUbarrier();
-  for (int32_t i = 0; i < 2 * GPUCA_NSECTORS; i++) {
+  for (uint32_t i = 0; i < 2 * GPUTPCGeometry::NSECTORS; i++) {
     for (uint32_t k = iThread; k < merger.TmpCounter()[i]; k += nThreads) {
       merger.BorderTracks(i)[k].SetTrackID(tmp2[merger.BorderTracks(i)[k].TrackID()]);
     }
diff --git a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
index e5ff9424b722d..f8bac8ce83718 100644
--- a/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
+++ b/GPU/GPUTracking/Refit/GPUTrackingRefit.cxx
@@ -87,7 +87,7 @@ template <>
 GPUd() void GPUTrackingRefit::initProp<GPUgeneric() GPUTPCGMPropagator>(GPUTPCGMPropagator& prop) // FIXME: GPUgeneric() needed to make the clang spirv output link correctly
 {
   prop.SetMaterialTPC();
-  prop.SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
+  prop.SetMaxSinPhi(constants::MAX_SIN_PHI);
   prop.SetSeedingErrors(false);
   prop.SetFitInProjections(mPparam->rec.fitInProjections != 0);
   prop.SetPropagateBzOnly(false);
@@ -357,7 +357,7 @@ GPUd() int32_t GPUTrackingRefit::RefitTrack(T& trkX, bool outward, bool resetCov
         IgnoreErrors(trk.getSnp());
         return -1;
       }
-      if (!prop->PropagateToXBxByBz(trk, x, GPUCA_MAX_SIN_PHI_LOW)) {
+      if (!prop->PropagateToXBxByBz(trk, x, constants::MAX_SIN_PHI_LOW)) {
         IgnoreErrors(trk.getSnp());
         return -2;
       }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.cxx
index 7a825defaa176..350ef7c23cfd2 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCCreateOccupancyMap.cxx
@@ -23,12 +23,12 @@ GPUdii() void GPUTPCCreateOccupancyMap::Thread<GPUTPCCreateOccupancyMap::fill>(i
   const GPUTrackingInOutPointers& GPUrestrict() ioPtrs = processors.ioPtrs;
   const o2::tpc::ClusterNativeAccess* GPUrestrict() clusters = ioPtrs.clustersNative;
   GPUParam& GPUrestrict() param = processors.param;
-  const int32_t iSectorRow = iBlock * nThreads + iThread;
-  if (iSectorRow >= GPUCA_NROWS * GPUCA_NSECTORS) {
+  const uint32_t iSectorRow = iBlock * nThreads + iThread;
+  if (iSectorRow >= GPUTPCGeometry::NROWS * GPUTPCGeometry::NSECTORS) {
     return;
   }
-  const uint32_t iSector = iSectorRow / GPUCA_NROWS;
-  const uint32_t iRow = iSectorRow % GPUCA_NROWS;
+  const uint32_t iSector = iSectorRow / GPUTPCGeometry::NROWS;
+  const uint32_t iRow = iSectorRow % GPUTPCGeometry::NROWS;
   for (uint32_t i = 0; i < clusters->nClusters[iSector][iRow]; i++) {
     const uint32_t bin = clusters->clusters[iSector][iRow][i].getTime() / param.rec.tpc.occupancyMapTimeBins;
     map[bin].bin[iSector][iRow]++;
@@ -47,7 +47,7 @@ GPUdii() void GPUTPCCreateOccupancyMap::Thread<GPUTPCCreateOccupancyMap::fold>(i
   int32_t binmax = CAMath::Min<int32_t>(GPUTPCClusterOccupancyMapBin::getNBins(param), bin + param.rec.tpc.occupancyMapTimeBinsAverage + 1);
   uint32_t sum = 0;
   for (int32_t i = binmin; i < binmax; i++) {
-    for (int32_t iSectorRow = 0; iSectorRow < GPUCA_NSECTORS * GPUCA_NROWS; iSectorRow++) {
+    for (uint32_t iSectorRow = 0; iSectorRow < GPUTPCGeometry::NSECTORS * GPUTPCGeometry::NROWS; iSectorRow++) {
       sum += (&map[i].bin[0][0])[iSectorRow];
     }
   }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
index 3c54afac16ee2..1710f460f01e5 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
@@ -40,7 +40,7 @@ GPUd() int32_t GPUTPCExtrapolationTracking::PerformExtrapolationTrackingRun(GPUT
   tParam.SetParam(sectorSource.Tracks()[iTrack].Param());
 
   // GPUInfo("Parameters X %f Y %f Z %f SinPhi %f DzDs %f QPt %f SignCosPhi %f", tParam.X(), tParam.Y(), tParam.Z(), tParam.SinPhi(), tParam.DzDs(), tParam.QPt(), tParam.SignCosPhi());
-  if (!tParam.Rotate(angle, GPUCA_MAX_SIN_PHI)) {
+  if (!tParam.Rotate(angle, constants::MAX_SIN_PHI)) {
     return 0;
   }
   // GPUInfo("Rotated X %f Y %f Z %f SinPhi %f DzDs %f QPt %f SignCosPhi %f", tParam.X(), tParam.Y(), tParam.Z(), tParam.SinPhi(), tParam.DzDs(), tParam.QPt(), tParam.SignCosPhi());
@@ -49,7 +49,7 @@ GPUd() int32_t GPUTPCExtrapolationTracking::PerformExtrapolationTrackingRun(GPUT
   GPUTPCTrackLinearisation t0(tParam);
   do {
     rowIndex += direction;
-    if (!tParam.TransportToX(tracker.Row(rowIndex).X(), t0, tracker.Param().bzCLight, GPUCA_MAX_SIN_PHI)) {
+    if (!tParam.TransportToX(tracker.Row(rowIndex).X(), t0, tracker.Param().bzCLight, constants::MAX_SIN_PHI)) {
       return 0; // Reuse t0 linearization until we are in the next sector
     }
     // GPUInfo("Transported X %f Y %f Z %f SinPhi %f DzDs %f QPt %f SignCosPhi %f (MaxY %f)", tParam.X(), tParam.Y(), tParam.Z(), tParam.SinPhi(), tParam.DzDs(), tParam.QPt(), tParam.SignCosPhi(), Row(rowIndex).MaxY());
@@ -67,7 +67,7 @@ GPUd() int32_t GPUTPCExtrapolationTracking::PerformExtrapolationTrackingRun(GPUT
     tParam.SetCov(2, err2Z);
   }
 
-  calink rowHits[GPUCA_NROWS];
+  calink rowHits[GPUTPCGeometry::NROWS];
   int32_t nHits = GPUTPCTrackletConstructor::GPUTPCTrackletConstructorExtrapolationTracking(tracker, smem, tParam, rowIndex, direction, 0, rowHits);
   if (nHits >= tracker.Param().rec.tpc.extrapolationTrackingMinHits) {
     // GPUInfo("%d hits found", nHits);
@@ -91,7 +91,7 @@ GPUd() int32_t GPUTPCExtrapolationTracking::PerformExtrapolationTrackingRun(GPUT
         if (rowHit != CALINK_INVAL && rowHit != CALINK_DEAD_CHANNEL) {
           // GPUInfo("New track: entry %d, row %d, hitindex %d", i, rowIndex, mTrackletRowHits[rowIndex * tracker.CommonMemory()->nTracklets]);
           tracker.TrackHits()[hitId + i].Set(rowIndex, rowHit);
-          // if (i == 0) tParam.TransportToX(Row(rowIndex).X(), Param().bzCLight(), GPUCA_MAX_SIN_PHI); //Use transport with new linearisation, we have changed the track in between - NOT needed, fitting will always start at outer end of the extrapolated track!
+          // if (i == 0) tParam.TransportToX(Row(rowIndex).X(), Param().bzCLight(), constants::MAX_SIN_PHI); //Use transport with new linearisation, we have changed the track in between - NOT needed, fitting will always start at outer end of the extrapolated track!
           i++;
         }
         rowIndex++;
@@ -140,7 +140,7 @@ GPUd() void GPUTPCExtrapolationTracking::PerformExtrapolationTracking(int32_t nB
 
     {
       const int32_t tmpHit = tracker.Tracks()[i].FirstHitID() + tracker.Tracks()[i].NHits() - 1;
-      if (tracker.TrackHits()[tmpHit].RowIndex() < GPUCA_NROWS - tracker.Param().rec.tpc.extrapolationTrackingMinRows && tracker.TrackHits()[tmpHit].RowIndex() >= GPUCA_NROWS - tracker.Param().rec.tpc.extrapolationTrackingRowRange) {
+      if (tracker.TrackHits()[tmpHit].RowIndex() < GPUTPCGeometry::NROWS - tracker.Param().rec.tpc.extrapolationTrackingMinRows && tracker.TrackHits()[tmpHit].RowIndex() >= GPUTPCGeometry::NROWS - tracker.Param().rec.tpc.extrapolationTrackingRowRange) {
         int32_t rowIndex = tracker.TrackHits()[tmpHit].RowIndex();
         const GPUTPCRow& GPUrestrict() row = tracker.Row(rowIndex);
         float Y = (float)tracker.Data().HitDataY(row, tracker.TrackHits()[tmpHit].HitIndex()) * row.HstepY() + row.Grid().YMin();
@@ -160,15 +160,15 @@ GPUd() void GPUTPCExtrapolationTracking::PerformExtrapolationTracking(int32_t nB
 template <>
 GPUdii() void GPUTPCExtrapolationTracking::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() tracker)
 {
-  CA_SHARED_CACHE(&smem.mRows[0], tracker.TrackingDataRows(), GPUCA_NROWS * sizeof(GPUTPCRow));
+  GPUCA_SHARED_CACHE(&smem.mRows[0], tracker.TrackingDataRows(), GPUTPCGeometry::NROWS * sizeof(GPUTPCRow));
   GPUbarrier();
 
   if (tracker.NHitsTotal() == 0) {
     return;
   }
-  const int32_t iSector = tracker.ISector();
-  int32_t sectorLeft = (iSector + (gpudatatypes::NSECTORS / 2 - 1)) % (gpudatatypes::NSECTORS / 2);
-  int32_t sectorRight = (iSector + 1) % (gpudatatypes::NSECTORS / 2);
+  const uint32_t iSector = tracker.ISector();
+  uint32_t sectorLeft = (iSector + (gpudatatypes::NSECTORS / 2 - 1)) % (gpudatatypes::NSECTORS / 2);
+  uint32_t sectorRight = (iSector + 1) % (gpudatatypes::NSECTORS / 2);
   if (iSector >= (int32_t)gpudatatypes::NSECTORS / 2) {
     sectorLeft += gpudatatypes::NSECTORS / 2;
     sectorRight += gpudatatypes::NSECTORS / 2;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
index c3364d6bedef4..d7b012653c75f 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.h
@@ -26,7 +26,7 @@ class GPUTPCExtrapolationTracking : public GPUKernelTemplate
 {
  public:
   struct GPUSharedMemory {
-    CA_SHARED_STORAGE(GPUTPCRow mRows[GPUCA_NROWS]);
+    GPUCA_SHARED_STORAGE(GPUTPCRow mRows[GPUTPCGeometry::NROWS]);
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCGrid.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCGrid.cxx
index 367a447b25a89..6c753f8bdd77a 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCGrid.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCGrid.cxx
@@ -42,8 +42,8 @@ GPUd() void GPUTPCGrid::Create(float yMin, float yMax, float zMin, float zMax, i
   mYMin = yMin;
   mZMin = zMin;
 
-  float sy = CAMath::Max((yMax + 0.1f - yMin) / ny, GPUCA_MIN_BIN_SIZE);
-  float sz = CAMath::Max((zMax + 0.1f - zMin) / nz, GPUCA_MIN_BIN_SIZE);
+  float sy = CAMath::Max((yMax + 0.1f - yMin) / ny, constants::GRID_MIN_BIN_SIZE);
+  float sz = CAMath::Max((zMax + 0.1f - zMin) / nz, constants::GRID_MIN_BIN_SIZE);
 
   mStepYInv = 1.f / sy;
   mStepZInv = 1.f / sz;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCHitId.h b/GPU/GPUTracking/SectorTracker/GPUTPCHitId.h
index 51c72969da8ae..352ecab6fb0a0 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCHitId.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCHitId.h
@@ -20,12 +20,12 @@ namespace o2::gpu
 class GPUTPCHitId
 {
  public:
-  GPUhd() void Set(int32_t row, int32_t hit) { mId = (hit << 8) | row; }
-  GPUhd() int32_t RowIndex() const { return mId & 0xff; }
-  GPUhd() int32_t HitIndex() const { return mId >> 8; }
+  GPUhd() void Set(uint32_t row, uint32_t hit) { mId = (hit << 8) | row; }
+  GPUhd() uint32_t RowIndex() const { return mId & 0xff; }
+  GPUhd() uint32_t HitIndex() const { return mId >> 8; }
 
  private:
-  int32_t mId;
+  uint32_t mId;
 };
 } // namespace o2::gpu
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.cxx
index eb4093d9a1876..49eacb8201a31 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.cxx
@@ -26,45 +26,41 @@ GPUdii() void GPUTPCNeighboursCleaner::Thread<0>(int32_t /*nBlocks*/, int32_t nT
 
   if (iThread == 0) {
     s.mIRow = iBlock + 2;
-    if (s.mIRow <= GPUCA_NROWS - 3) {
-      s.mIRowUp = s.mIRow + 2;
-      s.mIRowDn = s.mIRow - 2;
-      s.mNHits = tracker.Row(s.mIRow).NHits();
-    }
+    s.mIRowUp = s.mIRow + 2;
+    s.mIRowDn = s.mIRow - 2;
+    s.mNHits = tracker.Row(s.mIRow).NHits();
   }
   GPUbarrier();
 
-  if (s.mIRow <= GPUCA_NROWS - 3) {
 #ifdef GPUCA_GPUCODE
-    int32_t Up = s.mIRowUp;
-    int32_t Dn = s.mIRowDn;
-    GPUglobalref() const GPUTPCRow& GPUrestrict() row = tracker.Row(s.mIRow);
-    GPUglobalref() const GPUTPCRow& GPUrestrict() rowUp = tracker.Row(Up);
-    GPUglobalref() const GPUTPCRow& GPUrestrict() rowDn = tracker.Row(Dn);
+  int32_t Up = s.mIRowUp;
+  int32_t Dn = s.mIRowDn;
+  GPUglobalref() const GPUTPCRow& GPUrestrict() row = tracker.Row(s.mIRow);
+  GPUglobalref() const GPUTPCRow& GPUrestrict() rowUp = tracker.Row(Up);
+  GPUglobalref() const GPUTPCRow& GPUrestrict() rowDn = tracker.Row(Dn);
 #else
-    const GPUTPCRow& GPUrestrict() row = tracker.Row(s.mIRow);
-    const GPUTPCRow& GPUrestrict() rowUp = tracker.Row(s.mIRowUp);
-    const GPUTPCRow& GPUrestrict() rowDn = tracker.Row(s.mIRowDn);
+  const GPUTPCRow& GPUrestrict() row = tracker.Row(s.mIRow);
+  const GPUTPCRow& GPUrestrict() rowUp = tracker.Row(s.mIRowUp);
+  const GPUTPCRow& GPUrestrict() rowDn = tracker.Row(s.mIRowDn);
 #endif
 
-    // - look at up link, if it's valid but the down link in the row above doesn't link to us remove
-    //   the link
-    // - look at down link, if it's valid but the up link in the row below doesn't link to us remove
-    //   the link
-    for (int32_t ih = iThread; ih < s.mNHits; ih += nThreads) {
-      calink up = tracker.HitLinkUpData(row, ih);
-      if (up != CALINK_INVAL) {
-        calink upDn = tracker.HitLinkDownData(rowUp, up);
-        if ((upDn != (calink)ih)) {
-          tracker.SetHitLinkUpData(row, ih, CALINK_INVAL);
-        }
+  // - look at up link, if it's valid but the down link in the row above doesn't link to us remove
+  //   the link
+  // - look at down link, if it's valid but the up link in the row below doesn't link to us remove
+  //   the link
+  for (uint32_t ih = iThread; ih < s.mNHits; ih += nThreads) {
+    calink up = tracker.HitLinkUpData(row, ih);
+    if (up != CALINK_INVAL) {
+      calink upDn = tracker.HitLinkDownData(rowUp, up);
+      if ((upDn != (calink)ih)) {
+        tracker.SetHitLinkUpData(row, ih, CALINK_INVAL);
       }
-      calink dn = tracker.HitLinkDownData(row, ih);
-      if (dn != CALINK_INVAL) {
-        calink dnUp = tracker.HitLinkUpData(rowDn, dn);
-        if (dnUp != (calink)ih) {
-          tracker.SetHitLinkDownData(row, ih, CALINK_INVAL);
-        }
+    }
+    calink dn = tracker.HitLinkDownData(row, ih);
+    if (dn != CALINK_INVAL) {
+      calink dnUp = tracker.HitLinkUpData(rowDn, dn);
+      if (dnUp != (calink)ih) {
+        tracker.SetHitLinkDownData(row, ih, CALINK_INVAL);
       }
     }
   }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
index 2caf09e4886df..ad28ad75f7d4b 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursCleaner.h
@@ -31,10 +31,10 @@ class GPUTPCNeighboursCleaner : public GPUKernelTemplate
 {
  public:
   struct GPUSharedMemory {
-    int32_t mIRow;   // current row index
-    int32_t mIRowUp; // current row index
-    int32_t mIRowDn; // current row index
-    int32_t mNHits;  // number of hits
+    uint32_t mIRow;   // current row index
+    uint32_t mIRowUp; // current row index
+    uint32_t mIRowDn; // current row index
+    uint32_t mNHits;  // number of hits
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
index 4fef9f585b625..3ebd0367b8f6c 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
@@ -27,7 +27,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
 #ifdef GPUCA_GPUCODE
   for (uint32_t i = iThread; i < sizeof(GPUTPCRow) / sizeof(int32_t); i += nThreads) {
     reinterpret_cast<GPUsharedref() int32_t*>(&s.mRow)[i] = reinterpret_cast<GPUglobalref() int32_t*>(&tracker.TrackingDataRows()[iBlock])[i];
-    if (iBlock >= 2 && iBlock < GPUCA_NROWS - 2) {
+    if (iBlock >= 2 && iBlock < (int32_t)GPUTPCGeometry::NROWS - 2) {
       reinterpret_cast<GPUsharedref() int32_t*>(&s.mRowUp)[i] = reinterpret_cast<GPUglobalref() int32_t*>(&tracker.TrackingDataRows()[iBlock + 2])[i];
       reinterpret_cast<GPUsharedref() int32_t*>(&s.mRowDown)[i] = reinterpret_cast<GPUglobalref() int32_t*>(&tracker.TrackingDataRows()[iBlock - 2])[i];
     }
@@ -46,27 +46,25 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
     s.mIRow = iBlock;
     s.mIRowUp = iBlock + 2;
     s.mIRowDn = iBlock - 2;
-    if (s.mIRow < GPUCA_NROWS) {
-      s.mNHits = row.mNHits;
-      if ((s.mIRow >= 2) && (s.mIRow <= GPUCA_NROWS - 3)) {
-        // the axis perpendicular to the rows
-        const float xDn = rowDn.mX;
-        const float x = row.mX;
-        const float xUp = rowUp.mX;
-
-        // distance of the rows (absolute and relative)
-        s.mUpDx = xUp - x;
-        s.mDnDx = xDn - x;
-        s.mUpTx = xUp / x;
-        s.mDnTx = xDn / x;
-      }
+    s.mNHits = row.mNHits;
+    if ((s.mIRow >= 2) && (s.mIRow < GPUTPCGeometry::NROWS - 2)) {
+      // the axis perpendicular to the rows
+      const float xDn = rowDn.mX;
+      const float x = row.mX;
+      const float xUp = rowUp.mX;
+
+      // distance of the rows (absolute and relative)
+      s.mUpDx = xUp - x;
+      s.mDnDx = xDn - x;
+      s.mUpTx = xUp / x;
+      s.mDnTx = xDn / x;
     }
   }
   GPUbarrier();
 
   // local copies
 
-  if ((s.mIRow <= 1) || (s.mIRow >= GPUCA_NROWS - 2) || (rowUp.mNHits <= 0) || (rowDn.mNHits <= 0)) {
+  if ((s.mIRow <= 1) || (s.mIRow >= GPUTPCGeometry::NROWS - 2) || (rowUp.mNHits <= 0) || (rowDn.mNHits <= 0)) {
     const int32_t lHitNumberOffset = row.mHitNumberOffset;
     for (int32_t ih = iThread; ih < s.mNHits; ih += nThreads) {
       tracker.mData.mLinkUpData[lHitNumberOffset + ih] = CALINK_INVAL;
@@ -76,9 +74,9 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
   }
 
   static constexpr uint32_t UNROLL_GLOBAL = GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL > 1 ? GPUCA_PAR_NEIGHBOURS_FINDER_UNROLL_GLOBAL : 1;
-  static_assert(GPUCA_MAXN % UNROLL_GLOBAL == 0);
+  static_assert(constants::NEIGHBOURS_MAX_N % UNROLL_GLOBAL == 0);
   static constexpr uint32_t MAX_SHARED = GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP;
-  static constexpr uint32_t MAX_GLOBAL = (MAX_SHARED < GPUCA_MAXN) ? (((GPUCA_MAXN - MAX_SHARED - 1) / UNROLL_GLOBAL + 1) * UNROLL_GLOBAL) : 0;
+  static constexpr uint32_t MAX_GLOBAL = (MAX_SHARED < constants::NEIGHBOURS_MAX_N) ? (((constants::NEIGHBOURS_MAX_N - MAX_SHARED - 1) / UNROLL_GLOBAL + 1) * UNROLL_GLOBAL) : 0;
   static constexpr uint32_t MAX_TOTAL = MAX_SHARED + MAX_GLOBAL;
 
   const float chi2Cut = 3.f * 3.f * 4 * (s.mUpDx * s.mUpDx + s.mDnDx * s.mDnDx);
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
index ea574b5576d37..a719f6f3e6061 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.h
@@ -37,10 +37,10 @@ class GPUTPCNeighboursFinder : public GPUKernelTemplate
     float mDnDx;     // x distance to the previous row
     float mUpTx;     // normalized x distance to the next row
     float mDnTx;     // normalized x distance to the previous row
-    int32_t mIRow;   // row number
-    int32_t mIRowUp; // next row number
-    int32_t mIRowDn; // previous row number
-    static_assert(GPUCA_MAXN >= GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP);
+    uint32_t mIRow;  // row number
+    uint32_t mIRowUp; // next row number
+    uint32_t mIRowDn; // previous row number
+    static_assert(constants::NEIGHBOURS_MAX_N >= GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP);
     float mA1[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
     float mA2[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
     calink mB[GPUCA_PAR_NEIGHBOURS_FINDER_MAX_NNEIGHUP][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCNeighboursFinder)];
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCRow.h b/GPU/GPUTracking/SectorTracker/GPUTPCRow.h
index eb787f99ea336..21730a7673ccb 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCRow.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCRow.h
@@ -32,7 +32,7 @@ class GPUTPCRow
   friend class GPUTPCTrackingData;
 
  public:
-  GPUhd() int32_t NHits() const
+  GPUhd() uint32_t NHits() const
   {
     return mNHits;
   }
@@ -46,7 +46,7 @@ class GPUTPCRow
   GPUhd() float HstepZ() const { return mHstepZ; }
   GPUhd() float HstepYi() const { return mHstepYi; }
   GPUhd() float HstepZi() const { return mHstepZi; }
-  GPUhd() int32_t HitNumberOffset() const { return mHitNumberOffset; }
+  GPUhd() uint32_t HitNumberOffset() const { return mHitNumberOffset; }
   GPUhd() uint32_t FirstHitInBinOffset() const { return mFirstHitInBinOffset; }
   GPUhd() static float getTPCMaxY1X() { return 0.1763269f; } // 0.1763269 = tan(2Pi / (2 * 18))
   GPUhd() float getTPCMaxY() const { return getTPCMaxY1X() * mX; }
@@ -55,7 +55,7 @@ class GPUTPCRow
   friend class GPUTPCNeighboursFinder;
   friend class GPUTPCStartHitsFinder;
 
-  int32_t mNHits;   // number of hits
+  uint32_t mNHits;  // number of hits
   float mX;         // X coordinate of the row
   float mMaxY;      // maximal Y coordinate of the row
   GPUTPCGrid mGrid; // grid of hits
@@ -68,7 +68,7 @@ class GPUTPCRow
   float mHstepYi; // inverse step size
   float mHstepZi; // inverse step size
 
-  int32_t mHitNumberOffset;      // index of the first hit in the hit array, used as offset in GPUTPCTrackingData::LinkUp/DownData/HitDataY/...
+  uint32_t mHitNumberOffset;     // index of the first hit in the hit array, used as offset in GPUTPCTrackingData::LinkUp/DownData/HitDataY/...
   uint32_t mFirstHitInBinOffset; // offset in Tracker::mRowData to find the FirstHitInBin
 };
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
index ef5ae8c040934..5743ce1ebdcc9 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.cxx
@@ -25,16 +25,12 @@ GPUdii() void GPUTPCStartHitsFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nThr
   if (iThread == 0) {
     s.mIRow = iBlock + 1;
     s.mNRowStartHits = 0;
-    if (s.mIRow <= GPUCA_NROWS - 4) {
-      s.mNHits = tracker.mData.mRows[s.mIRow].mNHits;
-    } else {
-      s.mNHits = -1;
-    }
+    s.mNHits = tracker.mData.mRows[s.mIRow].mNHits;
   }
   GPUbarrier();
   GPUglobalref() const GPUTPCRow& GPUrestrict() row = tracker.mData.mRows[s.mIRow];
   GPUglobalref() const GPUTPCRow& GPUrestrict() rowUp = tracker.mData.mRows[s.mIRow + 2];
-  for (int32_t ih = iThread; ih < s.mNHits; ih += nThreads) {
+  for (uint32_t ih = iThread; ih < s.mNHits; ih += nThreads) {
     int64_t lHitNumberOffset = row.mHitNumberOffset;
     uint32_t linkUpData = tracker.mData.mLinkUpData[lHitNumberOffset + ih];
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
index c62eeb315b1f8..4a7ec8869766b 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsFinder.h
@@ -32,8 +32,8 @@ class GPUTPCStartHitsFinder : public GPUKernelTemplate
 {
  public:
   struct GPUSharedMemory {
-    int32_t mIRow;                      // row index
-    int32_t mNHits;                     // n hits in the row
+    uint32_t mIRow;                     // row index
+    uint32_t mNHits;                    // n hits in the row
     GPUAtomic(uint32_t) mNRowStartHits; // start hits found in the row
   };
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.cxx
index 9a9b19ef045b5..8918c6cab5604 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.cxx
@@ -25,12 +25,12 @@ GPUdii() void GPUTPCStartHitsSorter::Thread<0>(int32_t nBlocks, int32_t nThreads
 {
   // Sorts the Start Hits by Row Index
   if (iThread == 0) {
-    const int32_t tmpNRows = GPUCA_NROWS - 6;
-    const int32_t nRows = iBlock == (nBlocks - 1) ? (tmpNRows - (tmpNRows / nBlocks) * (nBlocks - 1)) : (tmpNRows / nBlocks);
-    const int32_t nStartRow = (tmpNRows / nBlocks) * iBlock + 1;
-    int32_t startOffset2 = 0;
+    const uint32_t tmpNRows = GPUTPCGeometry::NROWS - 6;
+    const uint32_t nRows = iBlock == (nBlocks - 1) ? (tmpNRows - (tmpNRows / nBlocks) * (nBlocks - 1)) : (tmpNRows / nBlocks);
+    const uint32_t nStartRow = (tmpNRows / nBlocks) * iBlock + 1;
+    uint32_t startOffset2 = 0;
     GPUCA_UNROLL(, U())
-    for (int32_t ir = 1; ir < GPUCA_NROWS - 5; ir++) {
+    for (uint32_t ir = 1; ir < GPUTPCGeometry::NROWS - 5; ir++) {
       if (ir < nStartRow) {
         startOffset2 += tracker.mRowStartHitCountOffset[ir];
       }
@@ -43,9 +43,9 @@ GPUdii() void GPUTPCStartHitsSorter::Thread<0>(int32_t nBlocks, int32_t nThreads
 
   int32_t startOffset = s.mStartOffset;
 #ifdef __HIPCC__ // TODO: Fixme
-  for (int32_t ir = -1; ++ir < s.mNRows;) {
+  for (int32_t ir = -1; ++ir < (int32_t)s.mNRows;) {
 #else
-  for (int32_t ir = 0; ir < s.mNRows; ir++) {
+  for (uint32_t ir = 0; ir < s.mNRows; ir++) {
 #endif
     GPUglobalref() GPUTPCHitId* const GPUrestrict() startHits = tracker.mTrackletStartHits;
     GPUglobalref() GPUTPCHitId* const GPUrestrict() tmpStartHits = tracker.mTrackletTmpStartHits + (s.mStartRow + ir) * tracker.mNMaxRowStartHits;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
index 1cee79d292b84..4b7ee6f20dee3 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCStartHitsSorter.h
@@ -32,9 +32,9 @@ class GPUTPCStartHitsSorter : public GPUKernelTemplate
 {
  public:
   struct GPUSharedMemory {
-    int32_t mStartRow;    // start row index
-    int32_t mNRows;       // number of rows to process
-    int32_t mStartOffset; // start offset for hits sorted by this block
+    uint32_t mStartRow;    // start row index
+    uint32_t mNRows;       // number of rows to process
+    uint32_t mStartOffset; // start offset for hits sorted by this block
   };
 
   typedef GPUconstantref() GPUTPCTracker processorType;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackLinearisation.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackLinearisation.h
index 06ead3ce00f6c..0e3454f5e3fe0 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackLinearisation.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackLinearisation.h
@@ -67,10 +67,10 @@ class GPUTPCTrackLinearisation
 
 GPUdi() GPUTPCTrackLinearisation::GPUTPCTrackLinearisation(const GPUTPCTrackParam& GPUrestrict() t) : mSinPhi(t.SinPhi()), mCosPhi(0), mDzDs(t.DzDs()), mQPt(t.QPt())
 {
-  if (mSinPhi > GPUCA_MAX_SIN_PHI) {
-    mSinPhi = GPUCA_MAX_SIN_PHI;
-  } else if (mSinPhi < -GPUCA_MAX_SIN_PHI) {
-    mSinPhi = -GPUCA_MAX_SIN_PHI;
+  if (mSinPhi > constants::MAX_SIN_PHI) {
+    mSinPhi = constants::MAX_SIN_PHI;
+  } else if (mSinPhi < -constants::MAX_SIN_PHI) {
+    mSinPhi = -constants::MAX_SIN_PHI;
   }
   mCosPhi = CAMath::Sqrt(1 - mSinPhi * mSinPhi);
   if (t.SignCosPhi() < 0) {
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.cxx
index a4d9265cf800e..6ce031882caec 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.cxx
@@ -694,7 +694,7 @@ GPUd() bool GPUTPCTrackParam::CheckNumericalQuality() const
     ok = 0;
   }
 
-  if (CAMath::Abs(SinPhi()) > GPUCA_MAX_SIN_PHI) {
+  if (CAMath::Abs(SinPhi()) > constants::MAX_SIN_PHI) {
     ok = 0;
   }
   if (CAMath::Abs(QPt()) > 1.f / 0.05f) {
@@ -707,9 +707,9 @@ GPUd() bool GPUTPCTrackParam::CheckNumericalQuality() const
   return ok;
 }
 
-GPUd() void GPUTPCTrackParam::ConstrainZ(float& z, int32_t sector, float& z0, float& lastZ)
+GPUd() void GPUTPCTrackParam::ConstrainZ(float& z, uint32_t sector, float& z0, float& lastZ)
 {
-  if (sector < GPUCA_NSECTORS / 2) {
+  if (sector < GPUTPCGeometry::NSECTORS / 2) {
     if (z < 0) {
       mParam.mZOffset += z;
       mParam.mP[1] -= z;
@@ -826,7 +826,7 @@ GPUd() int32_t GPUTPCTrackParam::GetPropagatedYZ(float bz, float x, float& projY
     ex = -ex;
   }
   float ey1 = ey - k * dx;
-  if (CAMath::Abs(ey1) > GPUCA_MAX_SIN_PHI) {
+  if (CAMath::Abs(ey1) > constants::MAX_SIN_PHI) {
     return 0;
   }
   float ss = ey + ey1;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.h
index e31abe338d2b8..95542144351bd 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackParam.h
@@ -99,16 +99,16 @@ class GPUTPCTrackParam
 
   GPUd() void GetDCAPoint(float x, float y, float z, float& px, float& py, float& pz, float Bz) const;
 
-  GPUd() bool TransportToX(float x, float Bz, float maxSinPhi = GPUCA_MAX_SIN_PHI);
-  GPUd() bool TransportToXWithMaterial(float x, float Bz, float maxSinPhi = GPUCA_MAX_SIN_PHI);
+  GPUd() bool TransportToX(float x, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
+  GPUd() bool TransportToXWithMaterial(float x, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
 
-  GPUd() bool TransportToX(float x, GPUTPCTrackLinearisation& t0, float Bz, float maxSinPhi = GPUCA_MAX_SIN_PHI, float* DL = nullptr);
+  GPUd() bool TransportToX(float x, GPUTPCTrackLinearisation& t0, float Bz, float maxSinPhi = constants::MAX_SIN_PHI, float* DL = nullptr);
 
-  GPUd() bool TransportToX(float x, float sinPhi0, float cosPhi0, float Bz, float maxSinPhi = GPUCA_MAX_SIN_PHI);
+  GPUd() bool TransportToX(float x, float sinPhi0, float cosPhi0, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
 
-  GPUd() bool TransportToXWithMaterial(float x, GPUTPCTrackLinearisation& t0, GPUTPCTrackFitParam& par, float Bz, float maxSinPhi = GPUCA_MAX_SIN_PHI);
+  GPUd() bool TransportToXWithMaterial(float x, GPUTPCTrackLinearisation& t0, GPUTPCTrackFitParam& par, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
 
-  GPUd() bool TransportToXWithMaterial(float x, GPUTPCTrackFitParam& par, float Bz, float maxSinPhi = GPUCA_MAX_SIN_PHI);
+  GPUd() bool TransportToXWithMaterial(float x, GPUTPCTrackFitParam& par, float Bz, float maxSinPhi = constants::MAX_SIN_PHI);
 
   GPUd() static float ApproximateBetheBloch(float beta2);
   GPUd() static float BetheBlochGeant(float bg, float kp0 = 2.33f, float kp1 = 0.20f, float kp2 = 3.00f, float kp3 = 173e-9f, float kp4 = 0.49848f);
@@ -118,17 +118,17 @@ class GPUTPCTrackParam
   GPUd() void CalculateFitParameters(GPUTPCTrackFitParam& par, float mass = 0.13957f);
   GPUd() bool CorrectForMeanMaterial(float xOverX0, float xTimesRho, const GPUTPCTrackFitParam& par);
 
-  GPUd() bool Rotate(float alpha, float maxSinPhi = GPUCA_MAX_SIN_PHI);
-  GPUd() bool Rotate(float alpha, GPUTPCTrackLinearisation& t0, float maxSinPhi = GPUCA_MAX_SIN_PHI);
-  GPUd() bool Filter(float y, float z, float err2Y, float err2Z, float maxSinPhi = GPUCA_MAX_SIN_PHI, bool paramOnly = false);
+  GPUd() bool Rotate(float alpha, float maxSinPhi = constants::MAX_SIN_PHI);
+  GPUd() bool Rotate(float alpha, GPUTPCTrackLinearisation& t0, float maxSinPhi = constants::MAX_SIN_PHI);
+  GPUd() bool Filter(float y, float z, float err2Y, float err2Z, float maxSinPhi = constants::MAX_SIN_PHI, bool paramOnly = false);
 
   GPUd() bool CheckNumericalQuality() const;
 
   GPUd() void ShiftZ(float z1, float z2, float x1, float x2, float bz, float defaultZOffsetOverR);
-  GPUd() void ConstrainZ(float& z, int32_t sector, float& z0, float& lastZ);
+  GPUd() void ConstrainZ(float& z, uint32_t sector, float& z0, float& lastZ);
   GPUd() int32_t GetPropagatedYZ(float bz, float x, float& projY, float& projZ) const;
 
-  GPUdi() void ConstrainSinPhi(float limit = GPUCA_MAX_SIN_PHI)
+  GPUdi() void ConstrainSinPhi(float limit = constants::MAX_SIN_PHI)
   {
     if (GetSinPhi() > limit) {
       SetSinPhi(limit);
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
index aec75d449730e..5d61a595a83e5 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.cxx
@@ -44,9 +44,6 @@ GPUTPCTracker::~GPUTPCTracker() = default;
 void GPUTPCTracker::SetSector(int32_t iSector) { mISector = iSector; }
 void GPUTPCTracker::InitializeProcessor()
 {
-  if (mISector < 0) {
-    throw std::runtime_error("Sector not set");
-  }
   InitializeRows(&Param());
   SetupCommonMemory();
 }
@@ -63,8 +60,8 @@ void* GPUTPCTracker::SetPointersScratch(void* mem)
     mem = SetPointersTracklets(mem);
   }
   if (mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCSectorTracking) {
-    computePointerWithAlignment(mem, mTrackletTmpStartHits, GPUCA_NROWS * mNMaxRowStartHits);
-    computePointerWithAlignment(mem, mRowStartHitCountOffset, GPUCA_NROWS);
+    computePointerWithAlignment(mem, mTrackletTmpStartHits, GPUTPCGeometry::NROWS * mNMaxRowStartHits);
+    computePointerWithAlignment(mem, mRowStartHitCountOffset, GPUTPCGeometry::NROWS);
   }
   return mem;
 }
@@ -135,12 +132,12 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   }
   if (io.clustersNative) {
     uint32_t maxRowHits = 0;
-    for (uint32_t i = 0; i < GPUCA_NROWS; i++) {
+    for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
       if (io.clustersNative->nClusters[mISector][i] > maxRowHits) {
         maxRowHits = io.clustersNative->nClusters[mISector][i];
       }
     }
-    mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(maxRowHits * GPUCA_NROWS);
+    mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(maxRowHits * GPUTPCGeometry::NROWS);
   } else {
     mNMaxRowStartHits = mRec->MemoryScalers()->NTPCRowStartHits(mData.NumberOfHits());
   }
@@ -149,9 +146,9 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   mNMaxRowHits = mRec->MemoryScalers()->NTPCTrackletHits(mData.NumberOfHits(), lowField);
   mNMaxTracks = mRec->MemoryScalers()->NTPCSectorTracks(mData.NumberOfHits());
   if (io.clustersNative) {
-    uint32_t sectorOffset = mISector >= GPUCA_NSECTORS / 2 ? GPUCA_NSECTORS / 2 : 0;
-    uint32_t nextSector = (mISector + 1) % (GPUCA_NSECTORS / 2) + sectorOffset;
-    uint32_t prevSector = (mISector + GPUCA_NSECTORS - 1) % (GPUCA_NSECTORS / 2) + sectorOffset;
+    uint32_t sectorOffset = mISector >= GPUTPCGeometry::NSECTORS / 2 ? GPUTPCGeometry::NSECTORS / 2 : 0;
+    uint32_t nextSector = (mISector + 1) % (GPUTPCGeometry::NSECTORS / 2) + sectorOffset;
+    uint32_t prevSector = (mISector + GPUTPCGeometry::NSECTORS - 1) % (GPUTPCGeometry::NSECTORS / 2) + sectorOffset;
     uint32_t nExtrapolationTracks = mRec->MemoryScalers()->NTPCSectorTracks((io.clustersNative->nClustersSector[nextSector] + io.clustersNative->nClustersSector[prevSector]) / 2) / 2;
     if (nExtrapolationTracks > mNMaxTracks) {
       mNMaxTracks = nExtrapolationTracks;
@@ -160,8 +157,8 @@ void GPUTPCTracker::SetMaxData(const GPUTrackingInOutPointers& io)
   mNMaxTrackHits = mRec->MemoryScalers()->NTPCSectorTrackHits(mData.NumberOfHits(), mRec->GetProcessingSettings().tpcInputWithClusterRejection);
 
   if (mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCSectorTracking).par_SORT_STARTHITS) {
-    if (mNMaxStartHits > mNMaxRowStartHits * GPUCA_NROWS) {
-      mNMaxStartHits = mNMaxRowStartHits * GPUCA_NROWS;
+    if (mNMaxStartHits > mNMaxRowStartHits * GPUTPCGeometry::NROWS) {
+      mNMaxStartHits = mNMaxRowStartHits * GPUTPCGeometry::NROWS;
     }
   }
   mData.SetMaxData();
@@ -171,7 +168,7 @@ void GPUTPCTracker::UpdateMaxData()
 {
   mNMaxTracklets = mCommonMem->nStartHits;
   mNMaxTracks = mNMaxTracklets * 2 + 50;
-  mNMaxRowHits = mNMaxTracklets * GPUCA_NROWS;
+  mNMaxRowHits = mNMaxTracklets * GPUTPCGeometry::NROWS;
 }
 
 void GPUTPCTracker::SetupCommonMemory() { new (mCommonMem) commonMemoryStruct; }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
index 5efd3ca845410..cb0c8d4a76fdb 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracker.h
@@ -115,7 +115,7 @@ class GPUTPCTracker : public GPUProcessor
   void SetMaxData(const GPUTrackingInOutPointers& io);
   void UpdateMaxData();
 
-  GPUhd() int32_t ISector() const { return mISector; }
+  GPUhd() uint32_t ISector() const { return mISector; }
 
   GPUhd() GPUconstantref() const GPUTPCTrackingData& Data() const { return mData; }
   GPUhdi() GPUconstantref() GPUTPCTrackingData& Data()
@@ -208,7 +208,7 @@ class GPUTPCTracker : public GPUProcessor
   friend class GPUTPCStartHitsFinder;
   char* mLinkTmpMemory = nullptr; // tmp memory for hits after neighbours finder
 
-  int32_t mISector = -1; // Number of sector
+  uint32_t mISector = (uint32_t)-1; // Number of sector
 
   GPUTPCTrackingData mData; // The TrackingData object. It is used to encapsulate the storage in memory from the access
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
index 91a97a9056a1c..98537f0f1a1b4 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackerDump.cxx
@@ -30,12 +30,12 @@ void GPUTPCTracker::DumpTrackingData(std::ostream& out)
 {
   // Dump Sector Input Data to File
   out << "\nSector Data (Sector" << mISector << "):" << std::endl;
-  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
+  for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
     if (Row(i).NHits() == 0) {
       continue;
     }
     out << "Row: " << i << std::endl;
-    for (int32_t j = 0; j < Row(i).NHits(); j++) {
+    for (uint32_t j = 0; j < Row(i).NHits(); j++) {
       if (j && j % 16 == 0) {
         out << std::endl;
       }
@@ -49,12 +49,12 @@ void GPUTPCTracker::DumpLinks(std::ostream& out, int32_t phase)
 {
   // Dump Links (after Neighbours Finder / Cleaner) to file
   out << "\nHit Links (Phase " << phase << ", Sector" << mISector << "):" << std::endl;
-  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
+  for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
     if (Row(i).NHits() == 0) {
       continue;
     }
     out << "Row: " << i << std::endl;
-    for (int32_t j = 0; j < Row(i).NHits(); j++) {
+    for (uint32_t j = 0; j < Row(i).NHits(); j++) {
       if (j && j % 32 == 0) {
         out << std::endl;
       }
@@ -68,12 +68,12 @@ void GPUTPCTracker::DumpHitWeights(std::ostream& out)
 {
   // dump hit weights to file
   out << "\nHit Weights(Sector" << mISector << "):" << std::endl;
-  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
+  for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
     if (Row(i).NHits() == 0) {
       continue;
     }
     out << "Row: " << i << ":" << std::endl;
-    for (int32_t j = 0; j < Row(i).NHits(); j++) {
+    for (uint32_t j = 0; j < Row(i).NHits(); j++) {
       if (j && j % 32 == 0) {
         out << std::endl;
       }
@@ -145,15 +145,15 @@ void GPUTPCTracker::DumpTrackletHits(std::ostream& out)
     const int32_t j = Ids[jj];
     const auto& tracklet = Tracklets()[j];
     out << "Tracklet " << std::setw(4) << jj << " (Rows: " << Tracklets()[j].FirstRow() << " - " << tracklet.LastRow() << ", Weight " << Tracklets()[j].HitWeight() << ") ";
-    if (tracklet.LastRow() > tracklet.FirstRow() && (tracklet.FirstRow() >= GPUCA_NROWS || tracklet.LastRow() >= GPUCA_NROWS)) {
+    if (tracklet.LastRow() > tracklet.FirstRow() && (tracklet.FirstRow() >= GPUTPCGeometry::NROWS || tracklet.LastRow() >= GPUTPCGeometry::NROWS)) {
       GPUError("Error: Tracklet %d First %d Last %d", j, tracklet.FirstRow(), tracklet.LastRow());
       out << " (Error: Tracklet " << j << " First " << tracklet.FirstRow() << " Last " << tracklet.LastRow() << ") ";
-      for (int32_t i = 0; i < GPUCA_NROWS; i++) {
+      for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
         // if (tracklet.RowHit(i) != CALINK_INVAL)
         out << i << "-" << mTrackletRowHits[tracklet.FirstHit() + (i - tracklet.FirstRow())] << ", ";
       }
     } else if (tracklet.LastRow() >= tracklet.FirstRow()) {
-      for (int32_t i = tracklet.FirstRow(); i <= tracklet.LastRow(); i++) {
+      for (uint32_t i = tracklet.FirstRow(); i <= tracklet.LastRow(); i++) {
         out << i << "-" << mTrackletRowHits[tracklet.FirstHit() + (i - tracklet.FirstRow())] << ", ";
       }
     }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
index dfb97402c1b1d..9324198753a44 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackingData.cxx
@@ -35,10 +35,10 @@ using namespace o2::gpu;
 void GPUTPCTrackingData::InitializeRows(const GPUParam& p)
 {
   // initialisation of rows
-  for (int32_t i = 0; i < GPUCA_NROWS + 1; i++) {
+  for (uint32_t i = 0; i < GPUTPCGeometry::NROWS + 1; i++) {
     new (&mRows[i]) GPUTPCRow;
   }
-  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
+  for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
     mRows[i].mX = GPUTPCGeometry::Row2X(i);
     mRows[i].mMaxY = CAMath::Tan(p.dAlpha / 2.f) * mRows[i].mX;
   }
@@ -52,9 +52,9 @@ void GPUTPCTrackingData::SetClusterData(int32_t nClusters, int32_t clusterIdOffs
 
 void GPUTPCTrackingData::SetMaxData()
 {
-  int32_t hitMemCount = GPUCA_NROWS * GPUCA_ROWALIGNMENT + mNumberOfHits;
+  int32_t hitMemCount = GPUTPCGeometry::NROWS * constants::GPU_ROWALIGNMENT + mNumberOfHits;
   const uint32_t kVectorAlignment = 256;
-  mNumberOfHitsPlusAlign = GPUProcessor::nextMultipleOf<(kVectorAlignment > GPUCA_ROWALIGNMENT ? kVectorAlignment : GPUCA_ROWALIGNMENT) / sizeof(int32_t)>(hitMemCount);
+  mNumberOfHitsPlusAlign = GPUProcessor::nextMultipleOf<(kVectorAlignment > constants::GPU_ROWALIGNMENT ? kVectorAlignment : constants::GPU_ROWALIGNMENT) / sizeof(int32_t)>(hitMemCount);
 }
 
 void* GPUTPCTrackingData::SetPointersLinks(void* mem)
@@ -72,7 +72,7 @@ void* GPUTPCTrackingData::SetPointersWeights(void* mem)
 
 void* GPUTPCTrackingData::SetPointersScratch(void* mem, bool idsOnGPU)
 {
-  const int32_t firstHitInBinSize = GetGridSize(mNumberOfHits, GPUCA_NROWS) + GPUCA_NROWS * GPUCA_ROWALIGNMENT / sizeof(int32_t);
+  const int32_t firstHitInBinSize = GetGridSize(mNumberOfHits, GPUTPCGeometry::NROWS) + GPUTPCGeometry::NROWS * constants::GPU_ROWALIGNMENT / sizeof(int32_t);
   GPUProcessor::computePointerWithAlignment(mem, mHitData, mNumberOfHitsPlusAlign);
   GPUProcessor::computePointerWithAlignment(mem, mFirstHitInBin, firstHitInBinSize);
   if (idsOnGPU) {
@@ -91,7 +91,7 @@ void* GPUTPCTrackingData::SetPointersClusterIds(void* mem, bool idsOnGPU)
 
 void* GPUTPCTrackingData::SetPointersRows(void* mem)
 {
-  GPUProcessor::computePointerWithAlignment(mem, mRows, GPUCA_NROWS + 1);
+  GPUProcessor::computePointerWithAlignment(mem, mRows, GPUTPCGeometry::NROWS + 1);
   return mem;
 }
 
@@ -99,9 +99,9 @@ void* GPUTPCTrackingData::SetPointersRows(void* mem)
 
 GPUd() void GPUTPCTrackingData::GetMaxNBins(GPUconstantref() const GPUConstantMem* mem, GPUTPCRow* GPUrestrict() row, int32_t& maxY, int32_t& maxZ)
 {
-  maxY = row->mMaxY * 2.f / GPUCA_MIN_BIN_SIZE + 1;
+  maxY = row->mMaxY * 2.f / constants::GRID_MIN_BIN_SIZE + 1;
   maxZ = (mem->param.continuousMaxTimeBin > 0 ? (mem->calibObjects.fastTransform->convTimeToZinTimeFrame(0, 0, mem->param.continuousMaxTimeBin)) : GPUTPCGeometry::TPCLength()) + 50;
-  maxZ = maxZ / GPUCA_MIN_BIN_SIZE + 1;
+  maxZ = maxZ / constants::GRID_MIN_BIN_SIZE + 1;
 }
 
 GPUd() uint32_t GPUTPCTrackingData::GetGridSize(uint32_t nHits, uint32_t nRows)
@@ -118,8 +118,8 @@ GPUdi() void GPUTPCTrackingData::CreateGrid(GPUconstantref() const GPUConstantMe
     dz = GPUTPCGeometry::TPCLength();
   }
   const float norm = CAMath::InvSqrt(row->mNHits / tfFactor);
-  float sy = CAMath::Min(CAMath::Max((yMax - yMin) * norm, GPUCA_MIN_BIN_SIZE), GPUCA_MAX_BIN_SIZE);
-  float sz = CAMath::Min(CAMath::Max(dz * norm, GPUCA_MIN_BIN_SIZE), GPUCA_MAX_BIN_SIZE);
+  float sy = CAMath::Min(CAMath::Max((yMax - yMin) * norm, constants::GRID_MIN_BIN_SIZE), constants::GRID_MAX_BIN_SIZE);
+  float sz = CAMath::Min(CAMath::Max(dz * norm, constants::GRID_MIN_BIN_SIZE), constants::GRID_MAX_BIN_SIZE);
   int32_t maxy, maxz;
   GetMaxNBins(mem, row, maxy, maxz);
   int32_t ny = CAMath::Max(1, CAMath::Min<int32_t>(maxy, (yMax - yMin) / sy + 1));
@@ -173,7 +173,7 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
   static_assert(sizeof(*binMemory) <= sizeof(*mHitWeights), "Cannot reuse memory");
 #endif
 
-  for (int32_t rowIndex = iBlock; rowIndex < GPUCA_NROWS; rowIndex += nBlocks) {
+  for (uint32_t rowIndex = iBlock; rowIndex < GPUTPCGeometry::NROWS; rowIndex += nBlocks) {
     float yMin = 1.e6f;
     float yMax = -1.e6f;
     float zMin = 1.e6f;
@@ -184,7 +184,7 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
     constexpr const uint32_t maxN = 1u << (sizeof(calink) < 3 ? (sizeof(calink) * 8) : 24);
     GPUTPCRow& row = mRows[rowIndex];
     if (iThread == 0) {
-      row.mFirstHitInBinOffset = CAMath::nextMultipleOf<GPUCA_ROWALIGNMENT / sizeof(calink)>(GetGridSize(RowOffset, rowIndex) + rowIndex * GPUCA_ROWALIGNMENT / sizeof(int32_t));
+      row.mFirstHitInBinOffset = CAMath::nextMultipleOf<constants::GPU_ROWALIGNMENT / sizeof(calink)>(GetGridSize(RowOffset, rowIndex) + rowIndex * constants::GPU_ROWALIGNMENT / sizeof(int32_t));
     }
     if (NumberOfClusters >= maxN) {
       if (iThread == 0) {
@@ -218,7 +218,7 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
 
     if (iThread == 0) {
       row.mNHits = NumberOfClusters;
-      row.mHitNumberOffset = CAMath::nextMultipleOf<GPUCA_ROWALIGNMENT / sizeof(calink)>(RowOffset + rowIndex * GPUCA_ROWALIGNMENT / sizeof(calink));
+      row.mHitNumberOffset = CAMath::nextMultipleOf<constants::GPU_ROWALIGNMENT / sizeof(calink)>(RowOffset + rowIndex * constants::GPU_ROWALIGNMENT / sizeof(calink));
     }
 
 #ifdef GPUCA_HAVE_ATOMIC_MINMAX_FLOAT
@@ -276,7 +276,7 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
       c[bin] = 0; // initialize to 0
     }
     GPUbarrier();
-    for (int32_t hitIndex = iThread; hitIndex < row.mNHits; hitIndex += nThreads) {
+    for (uint32_t hitIndex = iThread; hitIndex < row.mNHits; hitIndex += nThreads) {
       const int32_t globalHitIndex = RowOffset + hitIndex;
       const calink bin = row.mGrid.GetBin(YZData[globalHitIndex].x, YZData[globalHitIndex].y);
 
@@ -317,7 +317,7 @@ GPUdii() int32_t GPUTPCTrackingData::InitFromClusterData(int32_t nBlocks, int32_
 
     GPUbarrier();
 
-    for (int32_t hitIndex = iThread; hitIndex < row.mNHits; hitIndex += nThreads) {
+    for (uint32_t hitIndex = iThread; hitIndex < row.mNHits; hitIndex += nThreads) {
       const calink bin = bins[hitIndex];
       const calink ind = CAMath::AtomicAdd(&c[bin], (calink)-1) - 1; // generate an index for this hit that is >= c[bin] and < c[bin + 1]
       const int32_t globalBinsortedIndex = row.mHitNumberOffset + ind;
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h b/GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h
index 5bb63d6a10254..d614b98ecb81f 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTracklet.h
@@ -33,8 +33,8 @@ class GPUTPCTracklet
   GPUTPCTracklet() : mFirstRow(0), mLastRow(0), mParam(), mHitWeight(0), mFirstHit(0) {};
 #endif //! GPUCA_GPUCODE
 
-  GPUhd() int32_t FirstRow() const { return mFirstRow; }
-  GPUhd() int32_t LastRow() const { return mLastRow; }
+  GPUhd() uint32_t FirstRow() const { return mFirstRow; }
+  GPUhd() uint32_t LastRow() const { return mLastRow; }
   GPUhd() int32_t HitWeight() const { return mHitWeight; }
   GPUhd() uint32_t FirstHit() const { return mFirstHit; }
   GPUhd() const GPUTPCBaseTrackParam& Param() const { return mParam; }
@@ -46,8 +46,8 @@ class GPUTPCTracklet
   GPUhd() void SetHitWeight(const int32_t w) { mHitWeight = w; }
 
  private:
-  int32_t mFirstRow;           // first TPC row // TODO: We can use smaller data format here!
-  int32_t mLastRow;            // last TPC row
+  uint32_t mFirstRow;          // first TPC row // TODO: We can use smaller data format here!
+  uint32_t mLastRow;           // last TPC row
   GPUTPCBaseTrackParam mParam; // tracklet parameters
   int32_t mHitWeight;          // Hit Weight of Tracklet
   uint32_t mFirstHit;          // first hit in row hit array
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
index 4c932a1c01bd2..33a3264a87ab3 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.cxx
@@ -56,8 +56,8 @@ GPUd() void GPUTPCTrackletConstructor::StoreTracklet(int32_t /*nBlocks*/, int32_
 {
   // reconstruction of tracklets, tracklet store step
   const uint32_t nHits = r.mLastRow + 1 - r.mFirstRow;
-  if (nHits == 0 || r.mNHits == 0 || (r.mNHits < GPUCA_TPC_MIN_HITS_B5(tParam.QPt() * tracker.Param().qptB5Scaler) || !CheckCov(tParam) || CAMath::Abs(tParam.GetQPt() * tracker.Param().qptB5Scaler) > tracker.Param().rec.maxTrackQPtB5)) {
-    CADEBUG(printf("    Rejected: nHits %d QPt %f MinHits %d MaxQPt %f CheckCov %d\n", r.mNHits, tParam.QPt(), GPUCA_TPC_MIN_HITS_B5(tParam.QPt() * tracker.Param().qptB5Scaler), tracker.Param().rec.maxTrackQPtB5, (int32_t)CheckCov(tParam)));
+  if (nHits == 0 || r.mNHits == 0 || (r.mNHits < tracker.Param().tpcMinHitsB5(tParam.QPt() * tracker.Param().qptB5Scaler) || !CheckCov(tParam) || CAMath::Abs(tParam.GetQPt() * tracker.Param().qptB5Scaler) > tracker.Param().rec.maxTrackQPtB5)) {
+    CADEBUG(printf("    Rejected: nHits %d QPt %f MinHits %d MaxQPt %f CheckCov %d\n", r.mNHits, tParam.QPt(), tracker.Param().tpcMinHitsB5(tParam.QPt() * tracker.Param().qptB5Scaler), tracker.Param().rec.maxTrackQPtB5, (int32_t)CheckCov(tParam)));
     return;
   }
 
@@ -89,14 +89,14 @@ GPUd() void GPUTPCTrackletConstructor::StoreTracklet(int32_t /*nBlocks*/, int32_
   int32_t w = tracker.CalculateHitWeight(r.mNHits, tParam.GetChi2());
   tracklet.SetHitWeight(w);
 #ifdef __HIPCC__ // Todo: fixme!
-  for (int32_t iRow = r.mFirstRow - 1; ++iRow <= r.mLastRow; /*iRow++*/) {
+  for (int32_t iRow = r.mFirstRow - 1; ++iRow <= (int32_t)r.mLastRow; /*iRow++*/) {
 #else
-  for (int32_t iRow = r.mFirstRow; iRow <= r.mLastRow; iRow++) {
+  for (uint32_t iRow = r.mFirstRow; iRow <= r.mLastRow; iRow++) {
 #endif
     calink ih = rowHits[iRow];
     tracker.TrackletRowHits()[hitout + (iRow - r.mFirstRow)] = ih;
     if (ih != CALINK_INVAL && ih != CALINK_DEAD_CHANNEL) {
-      CA_MAKE_SHARED_REF(GPUTPCRow, row, tracker.Row(iRow), s.mRows[iRow]);
+      GPUCA_MAKE_SHARED_REF(GPUTPCRow, row, tracker.Row(iRow), s.mRows[iRow]);
       tracker.MaximizeHitWeight(row, ih, w);
     }
   }
@@ -106,7 +106,7 @@ template <class T>
 GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/, int32_t /*nThreads*/, int32_t /*iBlock*/, int32_t /*iThread*/, GPUsharedref() T& s, GPUTPCThreadMemory& GPUrestrict() r, GPUconstantref() GPUTPCTracker& GPUrestrict() tracker, GPUTPCTrackParam& GPUrestrict() tParam, int32_t iRow, calink& rowHit, calink* rowHits)
 {
   // reconstruction of tracklets, tracklets update step
-  CA_MAKE_SHARED_REF(GPUTPCRow, row, tracker.Row(iRow), s.mRows[iRow]);
+  GPUCA_MAKE_SHARED_REF(GPUTPCRow, row, tracker.Row(iRow), s.mRows[iRow]);
 
   float y0 = row.Grid().YMin();
   float stepY = row.HstepY();
@@ -115,7 +115,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
 
   if (r.mStage == 0) { // fitting part
     do {
-      if (iRow < r.mStartRow || r.mCurrIH == CALINK_INVAL) {
+      if (iRow < (int32_t)r.mStartRow || r.mCurrIH == CALINK_INVAL) {
         break;
       }
       if ((iRow - r.mStartRow) & 1) {
@@ -131,13 +131,13 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
       float x = row.X();
       float y = y0 + hh.x * stepY;
       float z = z0 + hh.y * stepZ;
-      if (iRow != r.mStartRow) {
+      if (iRow != (int32_t)r.mStartRow) {
         if (tracker.Param().par.continuousTracking) {
           tParam.ConstrainZ(z, tracker.ISector(), z0, r.mLastZ);
         }
         tracker.GetConstantMem()->calibObjects.fastTransform->TransformXYZ(tracker.ISector(), iRow, x, y, z);
       }
-      if (iRow == r.mStartRow) {
+      if (iRow == (int32_t)r.mStartRow) {
         if (tracker.Param().par.continuousTracking) {
           float refZ = ((z > 0) ? tracker.Param().rec.tpc.defaultZOffsetOverR : -tracker.Param().rec.tpc.defaultZOffsetOverR) * x;
           float zTmp = refZ;
@@ -169,7 +169,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
         r.mLastZ = z;
 
         float ri = 1.f / CAMath::Sqrt(dx * dx + dy * dy);
-        if (iRow == r.mStartRow + 2) {
+        if (iRow == (int32_t)r.mStartRow + 2) {
           tParam.SetSinPhi(dy * ri);
           tParam.SetSignCosPhi(dx);
           tParam.SetDzDs(dz * ri);
@@ -179,7 +179,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
           tParam.SetCov(2, err2Z);
         }
         float sinPhi, cosPhi;
-        if (r.mNHits >= 10 && CAMath::Abs(tParam.SinPhi()) < GPUCA_MAX_SIN_PHI_LOW) {
+        if (r.mNHits >= 10 && CAMath::Abs(tParam.SinPhi()) < constants::MAX_SIN_PHI_LOW) {
           sinPhi = tParam.SinPhi();
           cosPhi = CAMath::Sqrt(1 - sinPhi * sinPhi);
         } else {
@@ -187,7 +187,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
           cosPhi = dx * ri;
         }
         CADEBUG(printf("%14s: FIT TRACK ROW %3d X %8.3f -", "", iRow, tParam.X()); for (int32_t i = 0; i < 5; i++) { printf(" %8.3f", tParam.Par()[i]); } printf(" -"); for (int32_t i = 0; i < 15; i++) { printf(" %8.3f", tParam.Cov()[i]); } printf("\n"));
-        if (!tParam.TransportToX(x, sinPhi, cosPhi, tracker.Param().bzCLight, GPUCA_MAX_SIN_PHI)) {
+        if (!tParam.TransportToX(x, sinPhi, cosPhi, tracker.Param().bzCLight, constants::MAX_SIN_PHI)) {
           rowHit = CALINK_INVAL;
           break;
         }
@@ -219,7 +219,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
           }
         }
 
-        if (!tParam.Filter(y, z, err2Y, err2Z, GPUCA_MAX_SIN_PHI_LOW)) {
+        if (!tParam.Filter(y, z, err2Y, err2Z, constants::MAX_SIN_PHI_LOW)) {
           rowHit = CALINK_INVAL;
           break;
         }
@@ -240,13 +240,13 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
       r.mStage = 1;
       r.mLastY = tParam.Y(); // Store last spatial position here to start inward following from here
       r.mLastZ = tParam.Z();
-      if (CAMath::Abs(tParam.SinPhi()) > GPUCA_MAX_SIN_PHI) {
+      if (CAMath::Abs(tParam.SinPhi()) > constants::MAX_SIN_PHI) {
         r.mGo = 0;
       }
     }
   } else { // forward/backward searching part
     do {
-      if (r.mStage == 2 && iRow > r.mEndRow) {
+      if (r.mStage == 2 && iRow > (int32_t)r.mEndRow) {
         break;
       }
       if (r.mNMissed > tracker.Param().rec.tpc.trackFollowingMaxRowGap) {
@@ -271,7 +271,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
       }
 
       CADEBUG(printf("%14s: SEA TRACK ROW %3d X %8.3f -", "", iRow, tParam.X()); for (int32_t i = 0; i < 5; i++) { printf(" %8.3f", tParam.Par()[i]); } printf(" -"); for (int32_t i = 0; i < 15; i++) { printf(" %8.3f", tParam.Cov()[i]); } printf("\n"));
-      if (!tParam.TransportToX(x, tParam.SinPhi(), tParam.GetCosPhi(), tracker.Param().bzCLight, GPUCA_MAX_SIN_PHI_LOW)) {
+      if (!tParam.TransportToX(x, tParam.SinPhi(), tParam.GetCosPhi(), tracker.Param().bzCLight, constants::MAX_SIN_PHI_LOW)) {
         r.mGo = 0;
         rowHit = CALINK_INVAL;
         break;
@@ -361,8 +361,8 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
 
         CADEBUG(printf("%14s: SEA Hit %5d (%8.3f %8.3f), Res %f %f\n", "", best, y, z, tParam.Y() - y, tParam.Z() - z));
 
-        calink oldHit = (r.mStage == 2 && iRow >= r.mStartRow) ? rowHit : CALINK_INVAL;
-        if (oldHit != best && !tParam.Filter(y, z, err2Y, err2Z, GPUCA_MAX_SIN_PHI_LOW, oldHit != CALINK_INVAL) && r.mNHits != 0) {
+        calink oldHit = (r.mStage == 2 && iRow >= (int32_t)r.mStartRow) ? rowHit : CALINK_INVAL;
+        if (oldHit != best && !tParam.Filter(y, z, err2Y, err2Z, constants::MAX_SIN_PHI_LOW, oldHit != CALINK_INVAL) && r.mNHits != 0) {
           rowHit = CALINK_INVAL;
           break;
         }
@@ -404,9 +404,9 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::UpdateTracklet(int32_t /*nBlocks*/,
 
 GPUdic(2, 1) void GPUTPCTrackletConstructor::DoTracklet(GPUconstantref() GPUTPCTracker& GPUrestrict() tracker, GPUsharedref() GPUTPCTrackletConstructor::GPUSharedMemory& s, GPUTPCThreadMemory& GPUrestrict() r)
 {
-  int32_t iRow = 0, iRowEnd = GPUCA_NROWS;
+  int32_t iRow = 0, iRowEnd = GPUTPCGeometry::NROWS;
   GPUTPCTrackParam tParam;
-  calink rowHits[GPUCA_NROWS];
+  calink rowHits[GPUTPCGeometry::NROWS];
   if (r.mGo) {
     GPUTPCHitId id = tracker.TrackletStartHits()[r.mISH];
 
@@ -432,7 +432,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::DoTracklet(GPUconstantref() GPUTPCT
       UpdateTracklet(0, 0, 0, 0, s, r, tracker, tParam, iRow, rowHits[iRow], rowHits);
     }
     if (!r.mGo && r.mStage == 2) {
-      for (; iRow >= r.mStartRow; iRow--) {
+      for (; iRow >= (int32_t)r.mStartRow; iRow--) {
         rowHits[iRow] = CALINK_INVAL;
       }
     }
@@ -447,10 +447,10 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::DoTracklet(GPUconstantref() GPUTPCT
       {
         float tmpY, tmpZ;
         if (tParam.GetPropagatedYZ(tracker.Param().bzCLight, x, tmpY, tmpZ)) {
-          if (tracker.ISector() < GPUCA_NSECTORS / 2 ? (tmpZ < 0) : (tmpZ > 0)) {
+          if (tracker.ISector() < GPUTPCGeometry::NSECTORS / 2 ? (tmpZ < 0) : (tmpZ > 0)) {
             tmpZ = 0;
-          } else if (tracker.ISector() < GPUCA_NSECTORS / 2 ? (tmpZ > GPUTPCGeometry::TPCLength()) : (tmpZ < -GPUTPCGeometry::TPCLength())) {
-            tmpZ = tracker.ISector() < GPUCA_NSECTORS / 2 ? GPUTPCGeometry::TPCLength() : -GPUTPCGeometry::TPCLength();
+          } else if (tracker.ISector() < GPUTPCGeometry::NSECTORS / 2 ? (tmpZ > GPUTPCGeometry::TPCLength()) : (tmpZ < -GPUTPCGeometry::TPCLength())) {
+            tmpZ = tracker.ISector() < GPUTPCGeometry::NSECTORS / 2 ? GPUTPCGeometry::TPCLength() : -GPUTPCGeometry::TPCLength();
           }
           tracker.GetConstantMem()->calibObjects.fastTransform->InverseTransformYZtoX(tracker.ISector(), iRow, tmpY, tmpZ, x);
         } else {
@@ -458,7 +458,7 @@ GPUdic(2, 1) void GPUTPCTrackletConstructor::DoTracklet(GPUconstantref() GPUTPCT
           continue;
         }
       }
-      if ((r.mGo = (tParam.TransportToX(x, tracker.Param().bzCLight, GPUCA_MAX_SIN_PHI) && tParam.Filter(r.mLastY, r.mLastZ, tParam.Err2Y() * 0.5f, tParam.Err2Z() * 0.5f, GPUCA_MAX_SIN_PHI_LOW, true)))) {
+      if ((r.mGo = (tParam.TransportToX(x, tracker.Param().bzCLight, constants::MAX_SIN_PHI) && tParam.Filter(r.mLastY, r.mLastZ, tParam.Err2Y() * 0.5f, tParam.Err2Z() * 0.5f, constants::MAX_SIN_PHI_LOW, true)))) {
         CADEBUG(printf("%14s: SEA BACK  ROW %3d X %8.3f -", "", iRow, tParam.X()); for (int32_t i = 0; i < 5; i++) { printf(" %8.3f", tParam.Par()[i]); } printf(" -"); for (int32_t i = 0; i < 15; i++) { printf(" %8.3f", tParam.Cov()[i]); } printf("\n"));
         float err2Y, err2Z;
         tracker.GetErrors2Seeding(r.mEndRow, tParam, -1.f, err2Y, err2Z); // TODO: Use correct time
@@ -482,7 +482,7 @@ GPUdii() void GPUTPCTrackletConstructor::Thread(int32_t nBlocks, int32_t nThread
   if (get_local_id(0) == 0) {
     sMem.mNStartHits = *tracker.NStartHits();
   }
-  CA_SHARED_CACHE(&sMem.mRows[0], tracker.TrackingDataRows(), GPUCA_NROWS * sizeof(GPUTPCRow));
+  GPUCA_SHARED_CACHE(&sMem.mRows[0], tracker.TrackingDataRows(), GPUTPCGeometry::NROWS * sizeof(GPUTPCRow));
   GPUbarrier();
 
   GPUTPCThreadMemory rMem;
@@ -500,7 +500,7 @@ GPUd() int32_t GPUTPCTrackletConstructor::GPUTPCTrackletConstructorExtrapolation
   rMem.mStage = 3;
   rMem.mNHits = rMem.mNMissed = 0;
   rMem.mGo = 1;
-  while (rMem.mGo && row >= 0 && row < GPUCA_NROWS) {
+  while (rMem.mGo && row >= 0 && row < (int32_t)GPUTPCGeometry::NROWS) {
     UpdateTracklet(1, 1, 0, 0, sMem, rMem, tracker, tParam, row, rowHits[row], nullptr);
     row += increment;
   }
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
index 40db8d557a73f..a2ffc900d3d1e 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
@@ -46,24 +46,24 @@ class GPUTPCTrackletConstructor : public GPUKernelTemplate
 
    protected:
     // WARNING: This data is copied element by element in CopyTrackletTempData. Changes to members of this class must be reflected in CopyTrackletTempData!!!
-    int32_t mISH;         // track index
-    int32_t mFirstRow;    // first row index
-    int32_t mLastRow;     // last row index
-    int32_t mStartRow;    // row index of first hit in seed
-    int32_t mEndRow;      // row index of last hit in seed
+    uint32_t mISH;        // track index
+    uint32_t mFirstRow;   // first row index
+    uint32_t mLastRow;    // last row index
+    uint32_t mStartRow;   // row index of first hit in seed
+    uint32_t mEndRow;     // row index of last hit in seed
     calink mCurrIH;       // indef of the current hit
     int8_t mGo;           // do fit/searching flag
-    int32_t mStage;       // reco stage
-    int32_t mNHits;       // n track hits
-    int32_t mNHitsEndRow; // n hits at end row
-    int32_t mNMissed;     // n missed hits during search
+    uint8_t mStage;       // reco stage
+    uint32_t mNHits;      // n track hits
+    uint32_t mNHitsEndRow; // n hits at end row
+    uint32_t mNMissed;     // n missed hits during search
     float mLastY;         // Y of the last fitted cluster
     float mLastZ;         // Z of the last fitted cluster
   };
 
   struct GPUSharedMemory {
-    CA_SHARED_STORAGE(GPUTPCRow mRows[GPUCA_NROWS]);     // rows
-    int32_t mNStartHits;                                 // Total number of start hits
+    GPUCA_SHARED_STORAGE(GPUTPCRow mRows[GPUTPCGeometry::NROWS]); // rows
+    uint32_t mNStartHits;                                      // Total number of start hits
 
 #ifdef GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE
     int32_t fMaxSync; // temporary shared variable during profile creation
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
index d3c679c2a88e8..1f85718de6fa5 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.cxx
@@ -33,7 +33,7 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
   }
   GPUbarrier();
 
-  GPUTPCHitId trackHits[GPUCA_NROWS - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
+  GPUTPCHitId trackHits[GPUTPCGeometry::NROWS - GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE];
   const float maxSharedFrac = tracker.Param().rec.tpc.trackletMaxSharedFraction;
 
   for (int32_t itr = s.mItr0 + iThread; itr < s.mNTracklets; itr += s.mNThreadsTotal) {
@@ -51,7 +51,7 @@ GPUdii() void GPUTPCTrackletSelector::Thread<0>(int32_t nBlocks, int32_t nThread
     uint32_t gap = 0;
     uint32_t nShared = 0;
     uint32_t nHits = 0;
-    const uint32_t minHits = tracker.Param().rec.tpc.minNClustersTrackSeed == -1 ? GPUCA_TPC_MIN_HITS_B5(tracklet.Param().QPt() * tracker.Param().qptB5Scaler) : tracker.Param().rec.tpc.minNClustersTrackSeed;
+    const uint32_t minHits = tracker.Param().rec.tpc.minNClustersTrackSeed == -1 ? tracker.Param().tpcMinHitsB5(tracklet.Param().QPt() * tracker.Param().qptB5Scaler) : tracker.Param().rec.tpc.minNClustersTrackSeed;
     const uint32_t sharingMinNorm = minHits * tracker.Param().rec.tpc.trackletMinSharedNormFactor;
     const float maxSharedNorm = maxSharedFrac * sharingMinNorm;
 
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
index 8974b788015f5..95cb2f987a14d 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletSelector.h
@@ -36,7 +36,7 @@ class GPUTPCTrackletSelector : public GPUKernelTemplate
     int32_t mNThreadsTotal; // total n threads
     int32_t mNTracklets;    // n of tracklets
     int32_t mReserved;      // for alignment reasons
-    static_assert(GPUCA_NROWS >= GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE);
+    static_assert(GPUTPCGeometry::NROWS >= GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE);
     GPUTPCHitId mHits[GPUCA_PAR_TRACKLET_SELECTOR_HITS_REG_SIZE][GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCTrackletSelector)];
   };
 
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index d786bf8cbdf67..07373ad29d402 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -77,7 +77,7 @@ GPUChainITS *chainITS, *chainITSAsync, *chainITSPipeline;
 std::string eventsDir;
 void unique_ptr_aligned_delete(char* v)
 {
-  ::operator delete(v, std::align_val_t(GPUCA_BUFFER_ALIGNMENT));
+  ::operator delete(v, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
 }
 std::unique_ptr<char, void (*)(char*)> outputmemory(nullptr, unique_ptr_aligned_delete), outputmemoryPipeline(nullptr, unique_ptr_aligned_delete), inputmemory(nullptr, unique_ptr_aligned_delete);
 std::unique_ptr<GPUDisplayFrontendInterface> eventDisplay;
@@ -238,20 +238,20 @@ int32_t ReadConfiguration(int argc, char** argv)
 
   if (configStandalone.outputcontrolmem) {
     bool forceEmptyMemory = getenv("LD_PRELOAD") && strstr(getenv("LD_PRELOAD"), "valgrind") != nullptr;
-    outputmemory.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
+    outputmemory.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
     if (forceEmptyMemory) {
       printf("Valgrind detected, emptying GPU output memory to avoid false positive undefined reads");
       memset(outputmemory.get(), 0, configStandalone.outputcontrolmem);
     }
     if (configStandalone.proc.doublePipeline) {
-      outputmemoryPipeline.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
+      outputmemoryPipeline.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
       if (forceEmptyMemory) {
         memset(outputmemoryPipeline.get(), 0, configStandalone.outputcontrolmem);
       }
     }
   }
   if (configStandalone.inputcontrolmem) {
-    inputmemory.reset((char*)::operator new(configStandalone.inputcontrolmem, std::align_val_t(GPUCA_BUFFER_ALIGNMENT)));
+    inputmemory.reset((char*)::operator new(configStandalone.inputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
   }
 
   configStandalone.proc.showOutputStat = true;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChainContext.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChainContext.h
index 40dd379eae30a..63ca8c7c79ba0 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChainContext.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFChainContext.h
@@ -27,10 +27,10 @@ namespace o2::gpu
 
 struct GPUTPCCFChainContext {
   struct FragmentData {
-    uint32_t nDigits[GPUCA_NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
-    uint32_t nPages[GPUCA_NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
-    std::vector<uint16_t> pageDigits[GPUCA_NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
-    GPUTPCClusterFinder::MinMaxCN minMaxCN[GPUCA_NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
+    uint32_t nDigits[GPUTPCGeometry::NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
+    uint32_t nPages[GPUTPCGeometry::NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
+    std::vector<uint16_t> pageDigits[GPUTPCGeometry::NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
+    GPUTPCClusterFinder::MinMaxCN minMaxCN[GPUTPCGeometry::NSECTORS][GPUTrackingInOutZS::NENDPOINTS];
   };
 
   struct PtrSave {
@@ -43,21 +43,21 @@ struct GPUTPCCFChainContext {
   std::vector<FragmentData> fragmentData;
   uint32_t nPagesTotal;
   uint32_t nPagesFragmentMax;
-  uint32_t nPagesSector[GPUCA_NSECTORS];
-  uint32_t nDigitsEndpointMax[GPUCA_NSECTORS];
+  uint32_t nPagesSector[GPUTPCGeometry::NSECTORS];
+  uint32_t nDigitsEndpointMax[GPUTPCGeometry::NSECTORS];
   uint32_t tpcMaxTimeBin;
   bool abandonTimeframe;
   uint32_t nFragments;
   CfFragment fragmentFirst;
-  std::pair<uint32_t, uint32_t> nextPos[GPUCA_NSECTORS];
-  PtrSave ptrSave[GPUCA_NSECTORS];
+  std::pair<uint32_t, uint32_t> nextPos[GPUTPCGeometry::NSECTORS];
+  PtrSave ptrSave[GPUTPCGeometry::NSECTORS];
   const o2::tpc::ClusterNativeAccess* ptrClusterNativeSave;
 
   void prepare(bool tpcZS, const CfFragment& fragmentMax)
   {
     abandonTimeframe = false;
     nPagesTotal = nPagesFragmentMax = 0;
-    for (uint32_t i = 0; i < GPUCA_NSECTORS; i++) {
+    for (uint32_t i = 0; i < GPUTPCGeometry::NSECTORS; i++) {
       nPagesSector[i] = 0;
       nDigitsEndpointMax[i] = 0;
     }
@@ -70,7 +70,7 @@ struct GPUTPCCFChainContext {
       }
 
       for (uint32_t i = 0; i < nFragments; i++) {
-        for (uint32_t j = 0; j < GPUCA_NSECTORS; j++) {
+        for (uint32_t j = 0; j < GPUTPCGeometry::NSECTORS; j++) {
           for (uint32_t k = 0; k < GPUTrackingInOutZS::NENDPOINTS; k++) {
             fragmentData[i].nDigits[j][k] = fragmentData[i].nPages[j][k] = 0;
             fragmentData[i].pageDigits[j][k].clear();
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
index 3bc431babcc74..9c797bc73c987 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
@@ -43,7 +43,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
 GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineGPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
 #ifdef GPUCA_GPUCODE
-  if (iBlock >= GPUCA_NROWS) {
+  if (iBlock >= (int32_t)GPUTPCGeometry::NROWS) {
     return;
   }
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
index 367bcf73a0af8..c47de7f79d424 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
@@ -64,7 +64,7 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
   static int32_t GetNBlocks(bool isGPU)
   {
     const int32_t nBlocks = TPC_CLUSTERER_STRIDED_PAD_COUNT / PadsPerCacheline;
-    return isGPU ? GPUCA_NROWS : nBlocks;
+    return isGPU ? GPUTPCGeometry::NROWS : nBlocks;
   }
 
   template <int32_t iKernel = defaultKernel>
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
index 8ab6ab407a9ed..7fef277138632 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.cxx
@@ -80,7 +80,7 @@ GPUdii() void GPUTPCCFDecodeZS::decode(GPUTPCClusterFinder& clusterer, GPUShared
     for (uint32_t j = minJ; j < maxJ; j++) {
 #endif
       const uint32_t* pageSrc = (const uint32_t*)(((const uint8_t*)zs.zsPtr[endpoint][i]) + j * TPCZSHDR::TPC_ZS_PAGE_SIZE);
-      CA_SHARED_CACHE_REF(&s.ZSPage[0], pageSrc, TPCZSHDR::TPC_ZS_PAGE_SIZE, uint32_t, pageCache);
+      GPUCA_SHARED_CACHE_REF(&s.ZSPage[0], pageSrc, TPCZSHDR::TPC_ZS_PAGE_SIZE, uint32_t, pageCache);
       GPUbarrier();
       const uint8_t* page = (const uint8_t*)pageCache;
       const o2::header::RAWDataHeader* rdh = (const o2::header::RAWDataHeader*)page;
@@ -393,7 +393,7 @@ GPUd() void GPUTPCCFDecodeZSLinkBase::Decode(int32_t nBlocks, int32_t nThreads,
 #endif
       const uint32_t* pageSrc = (const uint32_t*)(((const uint8_t*)zs.zsPtr[endpoint][i]) + j * TPCZSHDR::TPC_ZS_PAGE_SIZE);
       // Cache zs page in shared memory. Curiously this actually degrades performance...
-      // CA_SHARED_CACHE_REF(&smem.ZSPage[0], pageSrc, TPCZSHDR::TPC_ZS_PAGE_SIZE, uint32_t, pageCache);
+      // GPUCA_SHARED_CACHE_REF(&smem.ZSPage[0], pageSrc, TPCZSHDR::TPC_ZS_PAGE_SIZE, uint32_t, pageCache);
       // GPUbarrier();
       // const uint8_t* page = (const uint8_t*)pageCache;
       const uint8_t* page = (const uint8_t*)pageSrc;
@@ -466,7 +466,7 @@ GPUd() void GPUTPCCFDecodeZSLinkBase::WriteCharge(processorType& clusterer, floa
   const uint32_t sector = clusterer.mISector;
   CfChargePos* positions = clusterer.mPpositions;
 #ifdef GPUCA_CHECK_TPCZS_CORRUPTION
-  if (padAndRow.getRow() >= GPUCA_NROWS) {
+  if (padAndRow.getRow() >= GPUTPCGeometry::NROWS) {
     positions[positionOffset] = INVALID_CHARGE_POS;
     clusterer.raiseError(GPUErrors::ERROR_TPCZS_INVALID_ROW, clusterer.mISector * 1000 + padAndRow.getRow());
     return;
@@ -652,7 +652,7 @@ GPUd() int16_t GPUTPCCFDecodeZSDenseLink::DecodeTB(
 
   uint8_t nLinksInTimebin = tbbHdr & 0x000F;
   uint16_t linkBC = (tbbHdr & 0xFFF0) >> 4;
-  int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - ctx.firstHBF) * constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
+  int32_t timeBin = (linkBC + (uint64_t)(raw::RDHUtils::getHeartBeatOrbit(*rawDataHeader) - ctx.firstHBF) * o2::constants::lhc::LHCMaxBunches) / LHCBCPERTIMEBIN;
 
   int16_t nSamplesInTB = 0;
 
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
index b8ff90f511057..3ad463f469cd6 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFDecodeZS.h
@@ -32,7 +32,7 @@ class GPUTPCCFDecodeZS : public GPUKernelTemplate
 {
  public:
   struct GPUSharedMemory /*: public GPUKernelTemplate::GPUSharedMemoryScan64<int32_t, GPUCA_WARP_SIZE>*/ {
-    CA_SHARED_STORAGE(uint32_t ZSPage[o2::tpc::TPCZSHDR::TPC_ZS_PAGE_SIZE / sizeof(uint32_t)]);
+    GPUCA_SHARED_STORAGE(uint32_t ZSPage[o2::tpc::TPCZSHDR::TPC_ZS_PAGE_SIZE / sizeof(uint32_t)]);
     uint32_t RowClusterOffset[o2::tpc::TPCZSHDR::TPC_MAX_ZS_ROW_IN_ENDPOINT];
     uint32_t nRowsRegion;
     uint32_t regionStartRow;
@@ -137,7 +137,7 @@ class GPUTPCCFDecodeZSLink : public GPUTPCCFDecodeZSLinkBase
   static inline constexpr uint32_t DECODE_MASK = (1 << DECODE_BITS) - 1;
 
   struct GPUSharedMemory : GPUKernelTemplate::GPUSharedMemoryWarpScan64<uint8_t, GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFDecodeZSLink)> {
-    // CA_SHARED_STORAGE(uint32_t ZSPage[o2::tpc::TPCZSHDR::TPC_ZS_PAGE_SIZE / sizeof(uint32_t)]);
+    // GPUCA_SHARED_STORAGE(uint32_t ZSPage[o2::tpc::TPCZSHDR::TPC_ZS_PAGE_SIZE / sizeof(uint32_t)]);
   };
 
   template <int32_t iKernel = defaultKernel, typename... Args>
@@ -162,7 +162,7 @@ class GPUTPCCFDecodeZSDenseLink : public GPUTPCCFDecodeZSLinkBase
   static inline constexpr int32_t MaxNLinksPerTimebin = 16;
 
   struct GPUSharedMemory : GPUKernelTemplate::GPUSharedMemoryWarpScan64<uint8_t, GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFDecodeZSDenseLink)> {
-    // CA_SHARED_STORAGE(uint32_t ZSPage[o2::tpc::TPCZSHDR::TPC_ZS_PAGE_SIZE / sizeof(uint32_t)]);
+    // GPUCA_SHARED_STORAGE(uint32_t ZSPage[o2::tpc::TPCZSHDR::TPC_ZS_PAGE_SIZE / sizeof(uint32_t)]);
     uint16_t samplesPerLinkEnd[MaxNLinksPerTimebin]; // Offset from end of TB link header to first sample not in this link
     uint8_t linkIds[MaxNLinksPerTimebin];
     uint8_t rawFECChannels[MaxNLinksPerTimebin * 80];
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.cxx
index b39ee87bc4fa5..d79cdc2333b76 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFMCLabelFlattener.cxx
@@ -32,7 +32,7 @@ void GPUTPCCFMCLabelFlattener::setGlobalOffsetsAndAllocate(
   cls.mPlabelsHeaderGlobalOffset = headerOffset;
   cls.mPlabelsDataGlobalOffset = dataOffset;
 
-  for (Row row = 0; row < GPUCA_NROWS; row++) {
+  for (Row row = 0; row < GPUTPCGeometry::NROWS; row++) {
     headerOffset += cls.mPclusterInRow[row];
     dataOffset += cls.mPlabelsInRow[row];
   }
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
index a16c627344820..e34163d3803fe 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.cxx
@@ -73,7 +73,7 @@ void* GPUTPCClusterFinder::SetPointersZS(void* mem)
 
 void* GPUTPCClusterFinder::SetPointersOutput(void* mem)
 {
-  computePointerWithAlignment(mem, mPclusterInRow, GPUCA_NROWS);
+  computePointerWithAlignment(mem, mPclusterInRow, GPUTPCGeometry::NROWS);
   return mem;
 }
 
@@ -91,7 +91,7 @@ void* GPUTPCClusterFinder::SetPointersScratch(void* mem)
   computePointerWithAlignment(mem, mPisPeak, mNMaxDigitsFragment);
   computePointerWithAlignment(mem, mPchargeMap, TPCMapMemoryLayout<decltype(*mPchargeMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen));
   computePointerWithAlignment(mem, mPpeakMap, TPCMapMemoryLayout<decltype(*mPpeakMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen));
-  computePointerWithAlignment(mem, mPclusterByRow, GPUCA_NROWS * mNMaxClusterPerRow);
+  computePointerWithAlignment(mem, mPclusterByRow, GPUTPCGeometry::NROWS * mNMaxClusterPerRow);
   if ((mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding)) {
     computePointerWithAlignment(mem, mPscanBuf, mBufSize * mNBufs);
   }
@@ -132,14 +132,14 @@ void GPUTPCClusterFinder::SetMaxData(const GPUTrackingInOutPointers& io)
     mNMaxClusterPerRow = std::max<uint32_t>(mNMaxClusterPerRow, mRec->GetProcessingSettings().tpcIncreasedMinClustersPerRow);
   }
   if ((mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding)) {
-    mBufSize = nextMultipleOf(mNMaxDigitsFragment, std::max<int32_t>(GPUCA_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
+    mBufSize = nextMultipleOf(mNMaxDigitsFragment, std::max<int32_t>(constants::GPU_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
     mNBufs = getNSteps(mBufSize);
   }
 }
 
 void GPUTPCClusterFinder::SetNMaxDigits(size_t nDigits, size_t nPages, size_t nDigitsFragment, size_t nDigitsEndpointMax)
 {
-  mNMaxDigits = nextMultipleOf(nDigits, std::max<int32_t>(GPUCA_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
+  mNMaxDigits = nextMultipleOf(nDigits, std::max<int32_t>(constants::GPU_MEMALIGN, mRec->getGPUParameters(mRec->GetRecoStepsGPU() & gpudatatypes::RecoStep::TPCClusterFinding).par_CF_SCAN_WORKGROUP_SIZE));
   mNMaxPages = nPages;
   mNMaxDigitsFragment = nDigitsFragment;
   mNMaxDigitsEndpoint = nDigitsEndpointMax;
@@ -166,8 +166,8 @@ void GPUTPCClusterFinder::PrepareMC()
 
   clearMCMemory();
   mPindexMap = new uint32_t[TPCMapMemoryLayout<decltype(*mPindexMap)>::items(mRec->GetProcessingSettings().overrideClusterizerFragmentLen)];
-  mPlabelsByRow = new GPUTPCClusterMCInterimArray[GPUCA_NROWS];
-  mPlabelsInRow = new uint32_t[GPUCA_NROWS];
+  mPlabelsByRow = new GPUTPCClusterMCInterimArray[GPUTPCGeometry::NROWS];
+  mPlabelsInRow = new uint32_t[GPUTPCGeometry::NROWS];
 }
 
 void GPUTPCClusterFinder::clearMCMemory()
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
index 6958134d7d716..4d036c2056cc5 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinder.h
@@ -122,7 +122,7 @@ class GPUTPCClusterFinder : public GPUProcessor
   uint32_t mPlabelsHeaderGlobalOffset = 0;
   uint32_t mPlabelsDataGlobalOffset = 0;
 
-  int32_t mISector = 0;
+  uint32_t mISector = 0;
   uint32_t mNMaxClusterPerRow = 0;
   uint32_t mNMaxClusters = 0;
   uint32_t mNMaxPages = 0;
diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
index 404aab04221a7..1e5030956df01 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCClusterFinderDump.cxx
@@ -48,7 +48,7 @@ void GPUTPCClusterFinder::DumpChargeMap(std::ostream& out, std::string_view titl
 
   for (TPCFragmentTime i = start; i < end; i++) {
     int32_t zeros = 0;
-    for (GlobalPad j = 0; j < TPC_CLUSTERER_STRIDED_PAD_COUNT; j++) {
+    for (GlobalPad j = 0; j < (int32_t)TPC_CLUSTERER_STRIDED_PAD_COUNT; j++) {
       uint16_t q = map[{j, i}];
       zeros += (q == 0);
       if (q != 0) {
@@ -84,7 +84,7 @@ void GPUTPCClusterFinder::DumpPeakMap(std::ostream& out, std::string_view title)
     int32_t zeros = 0;
 
     out << i << ":";
-    for (GlobalPad j = 0; j < TPC_CLUSTERER_STRIDED_PAD_COUNT; j++) {
+    for (GlobalPad j = 0; j < (int32_t)TPC_CLUSTERER_STRIDED_PAD_COUNT; j++) {
       uint8_t q = map[{j, i}];
       zeros += (q == 0);
       if (q != 0) {
@@ -157,7 +157,7 @@ void GPUTPCClusterFinder::DumpClusters(std::ostream& out)
 {
   out << "\nClusterer - Clusters - Sector " << mISector << " - Fragment " << mPmemory->fragment.index << "\n";
 
-  for (uint32_t i = 0; i < GPUCA_NROWS; i++) {
+  for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
     size_t N = mPclusterInRow[i];
     const tpc::ClusterNative* row = &mPclusterByRow[i * mNMaxClusterPerRow];
 
diff --git a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
index a7b0166122c1b..2b847e20de6fb 100644
--- a/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
+++ b/GPU/GPUTracking/TRDTracking/GPUTRDInterfaces.h
@@ -187,7 +187,7 @@ class propagatorInterface<GPUTPCGMPropagator> : public GPUTPCGMPropagator
   {
     this->SetMaterialTPC();
     this->SetPolynomialField(pField);
-    this->SetMaxSinPhi(GPUCA_MAX_SIN_PHI);
+    this->SetMaxSinPhi(constants::MAX_SIN_PHI);
     this->SetFitInProjections(0);
     this->SelectFieldRegion(GPUTPCGMPropagator::TRD);
   };
diff --git a/GPU/GPUTracking/dEdx/GPUdEdx.h b/GPU/GPUTracking/dEdx/GPUdEdx.h
index 791bd9989c284..c665b1a6bf02e 100644
--- a/GPU/GPUTracking/dEdx/GPUdEdx.h
+++ b/GPU/GPUTracking/dEdx/GPUdEdx.h
@@ -37,7 +37,7 @@ class GPUdEdx
   GPUd() void fillSubThreshold(int32_t padRow);
   GPUd() void computedEdx(GPUdEdxInfo& output, const GPUParam& param);
 
-  static constexpr size_t MAX_NCL = GPUCA_NROWS;
+  static constexpr size_t MAX_NCL = GPUTPCGeometry::NROWS;
 
  private:
   GPUd() float GetSortTruncMean(GPUCA_PAR_DEDX_STORAGE_TYPE_A* array, int32_t count, int32_t trunclow, int32_t trunchigh);
@@ -105,8 +105,8 @@ GPUdnii() void GPUdEdx::fillCluster(float qtot, float qmax, int32_t padRow, uint
     return;
   }
   float snp2 = trackSnp * trackSnp;
-  if (snp2 > GPUCA_MAX_SIN_PHI_LOW) {
-    snp2 = GPUCA_MAX_SIN_PHI_LOW;
+  if (snp2 > constants::MAX_SIN_PHI_LOW) {
+    snp2 = constants::MAX_SIN_PHI_LOW;
   }
 
   // setting maximum for snp for which the calibration object was created
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index b0c1c1d11f2cf..e9082e7e77634 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -19,7 +19,7 @@
 #include "backend/GPUDisplayBackend.h"
 #include "GPUDisplayInterface.h"
 #include "GPUSettings.h"
-#include "GPUDefConstantsAndSettings.h"
+#include "GPUTPCGeometry.h"
 
 #include <array>
 #include <mutex>
@@ -83,7 +83,7 @@ class GPUDisplay : public GPUDisplayInterface
   int32_t& drawTextFontSize() { return mDrawTextFontSize; }
 
  private:
-  static constexpr int32_t NSECTORS = GPUCA_NSECTORS;
+  static constexpr int32_t NSECTORS = GPUTPCGeometry::NSECTORS;
   static constexpr float GL_SCALE_FACTOR = (1.f / 100.f);
 
   static constexpr const int32_t N_POINTS_TYPE = 15;
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
index 3694ab93398cc..9914fbad20ea3 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
@@ -141,9 +141,9 @@ std::vector<char> GPUDisplayBackend::getPixels()
 void GPUDisplayBackend::fillIndirectCmdBuffer()
 {
   mCmdBuffer.clear();
-  mIndirectSectorOffset.resize(GPUCA_NSECTORS);
+  mIndirectSectorOffset.resize(GPUTPCGeometry::NSECTORS);
   // TODO: Check if this can be parallelized
-  for (int32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
+  for (uint32_t iSector = 0; iSector < GPUTPCGeometry::NSECTORS; iSector++) {
     mIndirectSectorOffset[iSector] = mCmdBuffer.size();
     for (uint32_t k = 0; k < mDisplay->vertexBufferStart()[iSector].size(); k++) {
       mCmdBuffer.emplace_back(mDisplay->vertexBufferCount()[iSector][k], 1, mDisplay->vertexBufferStart()[iSector][k], 0);
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
index 69cfdaca55379..606372be84a86 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
@@ -311,7 +311,7 @@ int32_t GPUDisplayBackendOpenGL::InitBackendA()
     GPUError("Unsupported OpenGL runtime %d.%d < %d.%d", glVersion[0], glVersion[1], GPUDisplayFrontend::GL_MIN_VERSION_MAJOR, GPUDisplayFrontend::GL_MIN_VERSION_MINOR);
     return (1);
   }
-  mVBOId.resize(GPUCA_NSECTORS);
+  mVBOId.resize(GPUTPCGeometry::NSECTORS);
   CHKERR(glCreateBuffers(mVBOId.size(), mVBOId.data()));
   CHKERR(glBindBuffer(GL_ARRAY_BUFFER, mVBOId[0]));
   CHKERR(glGenBuffers(1, &mIndirectId));
@@ -453,7 +453,7 @@ void GPUDisplayBackendOpenGL::loadDataToGPU(size_t totalVertizes)
 {
   // TODO: Check if this can be parallelized
   if (mDisplay->useMultiVBO()) {
-    for (int32_t i = 0; i < GPUCA_NSECTORS; i++) {
+    for (uint32_t i = 0; i < GPUTPCGeometry::NSECTORS; i++) {
       CHKERR(glNamedBufferData(mVBOId[i], mDisplay->vertexBuffer()[i].size() * sizeof(mDisplay->vertexBuffer()[i][0]), mDisplay->vertexBuffer()[i].data(), GL_STATIC_DRAW));
     }
   } else {
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 16f9939d6257a..1ebf35a83f7c6 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -206,18 +206,18 @@ void GPUDisplay::DrawClusters(int32_t iSector)
 
 GPUDisplay::vboList GPUDisplay::DrawLinks(const GPUTPCTracker& tracker, int32_t id, bool dodown)
 {
-  int32_t iSector = tracker.ISector();
+  uint32_t iSector = tracker.ISector();
   if (mCfgH.clustersOnly) {
     return (vboList(0, 0, iSector));
   }
   size_t startCount = mVertexBufferStart[iSector].size();
   size_t startCountInner = mVertexBuffer[iSector].size();
-  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
+  for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
     const GPUTPCRow& row = tracker.Data().Row(i);
 
-    if (i < GPUCA_NROWS - 2) {
+    if (i < GPUTPCGeometry::NROWS - 2) {
       const GPUTPCRow& rowUp = tracker.Data().Row(i + 2);
-      for (int32_t j = 0; j < row.NHits(); j++) {
+      for (uint32_t j = 0; j < row.NHits(); j++) {
         if (tracker.Data().HitLinkUpData(row, j) != CALINK_INVAL) {
           const int32_t cid1 = GET_CID(iSector, tracker.Data().ClusterDataIndex(row, j));
           const int32_t cid2 = GET_CID(iSector, tracker.Data().ClusterDataIndex(rowUp, tracker.Data().HitLinkUpData(row, j)));
@@ -229,7 +229,7 @@ GPUDisplay::vboList GPUDisplay::DrawLinks(const GPUTPCTracker& tracker, int32_t
 
     if (dodown && i >= 2) {
       const GPUTPCRow& rowDown = tracker.Data().Row(i - 2);
-      for (int32_t j = 0; j < row.NHits(); j++) {
+      for (uint32_t j = 0; j < row.NHits(); j++) {
         if (tracker.Data().HitLinkDownData(row, j) != CALINK_INVAL) {
           const int32_t cid1 = GET_CID(iSector, tracker.Data().ClusterDataIndex(row, j));
           const int32_t cid2 = GET_CID(iSector, tracker.Data().ClusterDataIndex(rowDown, tracker.Data().HitLinkDownData(row, j)));
@@ -245,7 +245,7 @@ GPUDisplay::vboList GPUDisplay::DrawLinks(const GPUTPCTracker& tracker, int32_t
 
 GPUDisplay::vboList GPUDisplay::DrawSeeds(const GPUTPCTracker& tracker)
 {
-  int32_t iSector = tracker.ISector();
+  uint32_t iSector = tracker.ISector();
   if (mCfgH.clustersOnly) {
     return (vboList(0, 0, iSector));
   }
@@ -269,7 +269,7 @@ GPUDisplay::vboList GPUDisplay::DrawSeeds(const GPUTPCTracker& tracker)
 
 GPUDisplay::vboList GPUDisplay::DrawTracklets(const GPUTPCTracker& tracker)
 {
-  int32_t iSector = tracker.ISector();
+  uint32_t iSector = tracker.ISector();
   if (mCfgH.clustersOnly) {
     return (vboList(0, 0, iSector));
   }
@@ -278,7 +278,7 @@ GPUDisplay::vboList GPUDisplay::DrawTracklets(const GPUTPCTracker& tracker)
     const GPUTPCTracklet& tracklet = tracker.Tracklet(i);
     size_t startCountInner = mVertexBuffer[iSector].size();
     float4 oldpos;
-    for (int32_t j = tracklet.FirstRow(); j <= tracklet.LastRow(); j++) {
+    for (uint32_t j = tracklet.FirstRow(); j <= tracklet.LastRow(); j++) {
       const calink rowHit = tracker.TrackletRowHits()[tracklet.FirstHit() + (j - tracklet.FirstRow())];
       if (rowHit != CALINK_INVAL && rowHit != CALINK_DEAD_CHANNEL) {
         const GPUTPCRow& row = tracker.Data().Row(j);
@@ -294,7 +294,7 @@ GPUDisplay::vboList GPUDisplay::DrawTracklets(const GPUTPCTracker& tracker)
 
 GPUDisplay::vboList GPUDisplay::DrawTracks(const GPUTPCTracker& tracker, int32_t global)
 {
-  int32_t iSector = tracker.ISector();
+  uint32_t iSector = tracker.ISector();
   if (mCfgH.clustersOnly) {
     return (vboList(0, 0, iSector));
   }
@@ -674,10 +674,10 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
 
 GPUDisplay::vboList GPUDisplay::DrawGrid(const GPUTPCTracker& tracker)
 {
-  int32_t iSector = tracker.ISector();
+  uint32_t iSector = tracker.ISector();
   size_t startCount = mVertexBufferStart[iSector].size();
   size_t startCountInner = mVertexBuffer[iSector].size();
-  for (int32_t i = 0; i < GPUCA_NROWS; i++) {
+  for (uint32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
     const GPUTPCRow& row = tracker.Data().Row(i);
     for (int32_t j = 0; j <= (signed)row.Grid().Ny(); j++) {
       float z1 = row.Grid().ZMin();
@@ -1018,7 +1018,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
   if (!mUseMultiVBO) {
     size_t totalYet = mVertexBuffer[0].size();
     mVertexBuffer[0].resize(totalVertizes);
-    for (int32_t i = 1; i < GPUCA_NSECTORS; i++) {
+    for (uint32_t i = 1; i < GPUTPCGeometry::NSECTORS; i++) {
       for (uint32_t j = 0; j < mVertexBufferStart[i].size(); j++) {
         mVertexBufferStart[i][j] += totalYet;
       }
@@ -1028,7 +1028,7 @@ size_t GPUDisplay::DrawGLScene_updateVertexList()
     }
   }
   mBackend->loadDataToGPU(totalVertizes);
-  for (int32_t i = 0; i < (mUseMultiVBO ? GPUCA_NSECTORS : 1); i++) {
+  for (uint32_t i = 0; i < (mUseMultiVBO ? GPUTPCGeometry::NSECTORS : 1); i++) {
     mVertexBuffer[i].clear();
   }
   if (timer.IsRunning()) {
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index b5bd275d4499b..b8259b974a44d 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -137,12 +137,12 @@ void GPUDisplay::DrawGLScene_updateEventData()
 
   mMaxClusterZ = tbb::parallel_reduce(tbb::blocked_range<int32_t>(0, NSECTORS, 1), float(0.f), [&](const tbb::blocked_range<int32_t>& r, float maxClusterZ) {
     for (int32_t iSector = r.begin(); iSector < r.end(); iSector++) {
-      int32_t row = 0;
+      uint32_t row = 0;
       uint32_t nCls = mIOPtrs->clustersNative ? mIOPtrs->clustersNative->nClustersSector[iSector] : 0;
       for (uint32_t i = 0; i < nCls; i++) {
         int32_t cid;
         cid = mIOPtrs->clustersNative->clusterOffset[iSector][0] + i;
-        while (row < GPUCA_NROWS - 1 && mIOPtrs->clustersNative->clusterOffset[iSector][row + 1] <= (uint32_t)cid) {
+        while (row < GPUTPCGeometry::NROWS - 1 && mIOPtrs->clustersNative->clusterOffset[iSector][row + 1] <= (uint32_t)cid) {
           row++;
         }
         if (cid >= mNMaxClusters) {
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 7a3803401980f..9f5b0f81f836a 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -526,10 +526,10 @@ int32_t GPUQA::InitQACreateHistograms()
       createHist(mClusters[i], name, name, AXIS_BINS[4], binsPt.get());
     }
 
-    createHist(mPadRow[0], "padrow0", "padrow0", GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS, GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS);
-    createHist(mPadRow[1], "padrow1", "padrow1", 100.f, -0.2f, 0.2f, GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS);
-    createHist(mPadRow[2], "padrow2", "padrow2", 100.f, -0.2f, 0.2f, GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS);
-    createHist(mPadRow[3], "padrow3", "padrow3", 100.f, 0, 300000, GPUCA_NROWS - PADROW_CHECK_MINCLS, 0, GPUCA_NROWS - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[0], "padrow0", "padrow0", GPUTPCGeometry::NROWS - PADROW_CHECK_MINCLS, 0, GPUTPCGeometry::NROWS - 1 - PADROW_CHECK_MINCLS, GPUTPCGeometry::NROWS - PADROW_CHECK_MINCLS, 0, GPUTPCGeometry::NROWS - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[1], "padrow1", "padrow1", 100.f, -0.2f, 0.2f, GPUTPCGeometry::NROWS - PADROW_CHECK_MINCLS, 0, GPUTPCGeometry::NROWS - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[2], "padrow2", "padrow2", 100.f, -0.2f, 0.2f, GPUTPCGeometry::NROWS - PADROW_CHECK_MINCLS, 0, GPUTPCGeometry::NROWS - 1 - PADROW_CHECK_MINCLS);
+    createHist(mPadRow[3], "padrow3", "padrow3", 100.f, 0, 300000, GPUTPCGeometry::NROWS - PADROW_CHECK_MINCLS, 0, GPUTPCGeometry::NROWS - 1 - PADROW_CHECK_MINCLS);
   }
 
   if (mQATasks & taskTrackStatistics) {
@@ -540,18 +540,18 @@ int32_t GPUQA::InitQACreateHistograms()
     }
     std::unique_ptr<double[]> binsPt{CreateLogAxis(AXIS_BINS[4], PT_MIN_CLUST, PT_MAX)};
     createHist(mTrackPt, "tracks_pt", "tracks_pt", AXIS_BINS[4], binsPt.get());
-    const uint32_t maxTime = (mTracking && mTracking->GetParam().continuousMaxTimeBin > 0) ? mTracking->GetParam().continuousMaxTimeBin : TPC_MAX_TIME_BIN_TRIGGERED;
+    const uint32_t maxTime = (mTracking && mTracking->GetParam().continuousMaxTimeBin > 0) ? mTracking->GetParam().continuousMaxTimeBin : constants::TPC_MAX_TIME_BIN_TRIGGERED;
     createHist(mT0[0], "tracks_t0", "tracks_t0", (maxTime + 1) / 10, 0, maxTime);
     createHist(mT0[1], "tracks_t0_res", "tracks_t0_res", 1000, -100, 100);
     createHist(mClXY, "clXY", "clXY", 1000, -250, 250, 1000, -250, 250); // TODO: Pass name only once
   }
   if (mQATasks & taskClusterRejection) {
-    const int padCount = GPUTPCGeometry::NPads(GPUCA_NROWS - 1);
+    const int padCount = GPUTPCGeometry::NPads(GPUTPCGeometry::NROWS - 1);
     for (int32_t i = 0; i < 3; i++) {
       snprintf(name, 2048, "clrej_%d", i);
-      createHist(mClRej[i], name, name, 2 * padCount, -padCount / 2 + 0.5f, padCount / 2 - 0.5f, GPUCA_NROWS, 0, GPUCA_NROWS - 1);
+      createHist(mClRej[i], name, name, 2 * padCount, -padCount / 2 + 0.5f, padCount / 2 - 0.5f, GPUTPCGeometry::NROWS, 0, GPUTPCGeometry::NROWS - 1);
     }
-    createHist(mClRejP, "clrejp", "clrejp", GPUCA_NROWS, 0, GPUCA_NROWS - 1);
+    createHist(mClRejP, "clrejp", "clrejp", GPUTPCGeometry::NROWS, 0, GPUTPCGeometry::NROWS - 1);
   }
 
   if ((mQATasks & taskClusterCounts) && mConfig.clusterRejectionHistograms) {
@@ -1101,8 +1101,8 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
       }
       if (mTracking->mIOPtrs.nMergedTracks && clNative) {
         std::fill(lowestPadRow.begin(), lowestPadRow.end(), 255);
-        for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-          for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
+        for (uint32_t iSector = 0; iSector < GPUTPCGeometry::NSECTORS; iSector++) {
+          for (uint32_t iRow = 0; iRow < GPUTPCGeometry::NROWS; iRow++) {
             for (uint32_t iCl = 0; iCl < clNative->nClusters[iSector][iRow]; iCl++) {
               int32_t i = clNative->clusterOffset[iSector][iRow] + iCl;
               for (int32_t j = 0; j < GetMCLabelNID(i); j++) {
@@ -1793,7 +1793,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     }
     if (mClNative && mTracking && mTracking->GetTPCTransform()) {
       for (uint32_t i = 0; i < GPUChainTracking::NSECTORS; i++) {
-        for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+        for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
           for (uint32_t k = 0; k < mClNative->nClusters[i][j]; k++) {
             const auto& cl = mClNative->clusters[i][j][k];
             float x, y, z;
@@ -1825,8 +1825,8 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
   uint32_t nCl = clNative ? clNative->nClustersTotal : mTracking->GetProcessors()->tpcMerger.NMaxClusters();
   mClusterCounts.nTotal += nCl;
   if (mQATasks & (taskClusterCounts | taskClusterRejection)) {
-    for (uint32_t iSector = 0; iSector < GPUCA_NSECTORS; iSector++) {
-      for (uint32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
+    for (uint32_t iSector = 0; iSector < GPUTPCGeometry::NSECTORS; iSector++) {
+      for (uint32_t iRow = 0; iRow < GPUTPCGeometry::NROWS; iRow++) {
         for (uint32_t iCl = 0; iCl < clNative->nClusters[iSector][iRow]; iCl++) {
           uint32_t i = clNative->clusterOffset[iSector][iRow] + iCl;
           int32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[i];
@@ -1917,7 +1917,7 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
     }
     uint32_t clid = 0;
     for (uint32_t i = 0; i < GPUChainTracking::NSECTORS; i++) {
-      for (uint32_t j = 0; j < GPUCA_NROWS; j++) {
+      for (uint32_t j = 0; j < GPUTPCGeometry::NROWS; j++) {
         for (uint32_t k = 0; k < mClNative->nClusters[i][j]; k++) {
           const auto& cl = mClNative->clusters[i][j][k];
           uint32_t attach = mTracking->mIOPtrs.mergedTrackHitAttachment[clid];
diff --git a/GPU/GPUTracking/qa/genEvents.cxx b/GPU/GPUTracking/qa/genEvents.cxx
index 49b4c2ca6b12b..09c85a05db68a 100644
--- a/GPU/GPUTracking/qa/genEvents.cxx
+++ b/GPU/GPUTracking/qa/genEvents.cxx
@@ -219,7 +219,7 @@ int32_t genEvents::GenerateEvent(const GPUParam& param, const char* filename)
       // exit(0);
     }
 
-    for (int32_t iRow = 0; iRow < GPUCA_NROWS; iRow++) {
+    for (uint32_t iRow = 0; iRow < GPUTPCGeometry::NROWS; iRow++) {
       // if( iRow>=50 ) break; //SG!!!
       float xRow = GPUTPCGeometry::Row2X(iRow);
       // transport to row

From 3bc472e40eb6c333ae3b24d64041ba7b70c48ca1 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 8 Apr 2026 10:29:47 +0200
Subject: [PATCH 1597/1764] GPU: Unify some constants

---
 GPU/GPUTracking/Base/GPUParam.h               | 12 ++++-----
 .../Base/GPUReconstructionConvert.h           |  3 ++-
 .../DataCompression/GPUTPCCompression.h       |  1 +
 .../GPUTPCCompressionTrackModel.h             |  5 ++--
 .../DataCompression/GPUTPCDecompression.h     |  1 +
 GPU/GPUTracking/DataTypes/GPUDataTypesIO.h    | 12 +++------
 .../DataTypes/GPUMemorySizeScalers.cxx        |  1 +
 .../DataTypes/GPUTPCClusterOccupancyMap.h     |  4 +--
 GPU/GPUTracking/DataTypes/TPCPadBitMap.h      |  5 ++--
 GPU/GPUTracking/DataTypes/TPCPadGainCalib.h   |  9 ++++---
 GPU/GPUTracking/Definitions/GPUDef.h          |  1 -
 .../Definitions/GPUDefParametersConstants.h   |  2 +-
 .../Definitions/clusterFinderDefs.h           |  3 ++-
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       |  1 +
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx |  4 +--
 .../GPUTPCExtrapolationTracking.cxx           | 26 +++++++++----------
 GPU/GPUTracking/display/GPUDisplay.h          |  4 +--
 .../display/backend/GPUDisplayBackend.cxx     |  1 +
 .../backend/GPUDisplayBackendOpenGL.cxx       |  1 +
 GPU/GPUTracking/qa/GPUQA.cxx                  |  2 +-
 GPU/GPUTracking/qa/genEvents.cxx              |  3 +--
 .../TPCFastTransformGeo.h                     |  8 +++---
 .../TPCFastTransformPOD.h                     |  5 ++--
 .../TPCFastTransformationLinkDef_O2.h         | 21 +++++----------
 24 files changed, 66 insertions(+), 69 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 82af34df7d633..27d23fd49920a 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -20,7 +20,7 @@
 #include "GPUDef.h"
 #include "GPUSettings.h"
 #include "GPUTPCGMPolynomialField.h"
-#include "GPUTPCGeometry.h"
+#include "DataFormatsTPC/Constants.h"
 
 #if !defined(GPUCA_GPUCODE)
 namespace o2::base
@@ -66,7 +66,7 @@ struct GPUParam_t {
   uint32_t occupancyTotal;                 // Total occupancy in the TPC (nCl / nHbf)
   uint32_t occupancyMapSize;               // Size of occupancy map
 
-  GPUParamSector SectorParam[GPUTPCGeometry::NSECTORS];
+  GPUParamSector SectorParam[o2::tpc::constants::MAXSECTOR];
 
  protected:
 #ifndef GPUCA_RUN2
@@ -91,11 +91,11 @@ struct GPUParam : public internal::GPUParam_t<GPUSettingsRec, GPUSettingsParam>
   GPUd() constexpr uint32_t tpcMinHitsB5(float qPtB5) const { return CAMath::Abs(qPtB5) > 10 ? 10 : (CAMath::Abs(qPtB5) > 5 ? 15 : 29); } // Minimum hits should depend on Pt, low Pt tracks can have few hits. 29 Hits default, 15 for < 200 mev, 10 for < 100 mev
   GPUd() constexpr float Alpha(int32_t iSector) const
   {
-    if (iSector >= (int32_t)GPUTPCGeometry::NSECTORS / 2) {
-      iSector -= GPUTPCGeometry::NSECTORS / 2;
+    if (iSector >= (int32_t)o2::tpc::constants::MAXSECTOR / 2) {
+      iSector -= o2::tpc::constants::MAXSECTOR / 2;
     }
-    if (iSector >= (int32_t)GPUTPCGeometry::NSECTORS / 4) {
-      iSector -= GPUTPCGeometry::NSECTORS / 2;
+    if (iSector >= (int32_t)o2::tpc::constants::MAXSECTOR / 4) {
+      iSector -= o2::tpc::constants::MAXSECTOR / 2;
     }
     return 0.174533f + dAlpha * iSector;
   }
diff --git a/GPU/GPUTracking/Base/GPUReconstructionConvert.h b/GPU/GPUTracking/Base/GPUReconstructionConvert.h
index a2fa42fff74cb..17958303103a0 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionConvert.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionConvert.h
@@ -19,6 +19,7 @@
 #include <functional>
 #include <vector>
 #include "GPUDef.h"
+#include "DataFormatsTPC/Constants.h"
 
 namespace o2
 {
@@ -48,7 +49,7 @@ struct GPUTrackingInOutZS;
 class GPUReconstructionConvert
 {
  public:
-  constexpr static uint32_t NSECTORS = GPUTPCGeometry::NSECTORS;
+  constexpr static uint32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
   static void ConvertNativeToClusterData(o2::tpc::ClusterNativeAccess* native, std::unique_ptr<GPUTPCClusterData[]>* clusters, uint32_t* nClusters, const TPCFastTransformPOD* transform, int32_t continuousMaxTimeBin = 0);
   static void ConvertRun2RawToNative(o2::tpc::ClusterNativeAccess& native, std::unique_ptr<o2::tpc::ClusterNative[]>& nativeBuffer, const AliHLTTPCRawCluster** rawClusters, uint32_t* nRawClusters);
   template <class S>
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
index e84e2d65e1fc7..82e44eda6f3cc 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompression.h
@@ -20,6 +20,7 @@
 #include "GPUCommonMath.h"
 #include "GPUParam.h"
 #include "DataFormatsTPC/CompressedClusters.h"
+#include "GPUTPCGeometry.h"
 
 namespace o2::gpu
 {
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.h b/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.h
index d919baa6f75b3..0021f3331cb2e 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionTrackModel.h
@@ -20,6 +20,7 @@
 // #define GPUCA_COMPRESSION_TRACK_MODEL_SECTORTRACKER
 
 #include "GPUDef.h"
+#include "DataFormatsTPC/Constants.h"
 
 #ifdef GPUCA_COMPRESSION_TRACK_MODEL_MERGER
 #include "GPUTPCGMPropagator.h"
@@ -103,12 +104,12 @@ class GPUTPCCompressionTrackModel
   GPUd() float LinearPad2Y(uint32_t sector, float pad, float padWidth, uint8_t npads) const
   {
     const float u = (pad - 0.5f * npads) * padWidth;
-    return (sector >= GPUTPCGeometry::NSECTORS / 2) ? -u : u;
+    return (sector >= o2::tpc::constants::MAXSECTOR / 2) ? -u : u;
   }
 
   GPUd() float LinearY2Pad(uint32_t sector, float y, float padWidth, uint8_t npads) const
   {
-    const float u = (sector >= GPUTPCGeometry::NSECTORS / 2) ? -y : y;
+    const float u = (sector >= o2::tpc::constants::MAXSECTOR / 2) ? -y : y;
     return u / padWidth + 0.5f * npads;
   }
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.h b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.h
index f99fdc8b8c9c0..59b1c564bff02 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.h
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.h
@@ -21,6 +21,7 @@
 #include "GPUParam.h"
 #include "GPUO2DataTypes.h"
 #include "DataFormatsTPC/CompressedClusters.h"
+#include "GPUTPCGeometry.h"
 
 namespace o2::gpu
 {
diff --git a/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
index 3dc0223194353..f3172aa18d387 100644
--- a/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
+++ b/GPU/GPUTracking/DataTypes/GPUDataTypesIO.h
@@ -23,6 +23,7 @@
 #include <cstddef>
 #endif
 #include "GPUTRDDef.h"
+#include "DataFormatsTPC/Constants.h"
 
 struct AliHLTTPCClusterMCLabel;
 struct AliHLTTPCRawCluster;
@@ -109,11 +110,6 @@ struct GPUTRDTrackletLabels;
 struct GPUTPCDigitsMCInput;
 struct GPUSettingsTF;
 
-namespace gpudatatypes
-{
-static constexpr uint32_t NSECTORS = 36;
-} // namespace gpudatatypes
-
 template <class T>
 struct DefaultPtr {
   typedef T type;
@@ -141,7 +137,7 @@ typedef GPUCalibObjectsTemplate<DefaultPtr> GPUCalibObjects; // NOTE: These 2 mu
 typedef GPUCalibObjectsTemplate<ConstPtr> GPUCalibObjectsConst;
 
 struct GPUTrackingInOutZS {
-  static constexpr uint32_t NSECTORS = gpudatatypes::NSECTORS;
+  static constexpr uint32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
   static constexpr uint32_t NENDPOINTS = 20;
   struct GPUTrackingInOutZSSector {
     const void* const* zsPtr[NENDPOINTS];
@@ -159,7 +155,7 @@ struct GPUTrackingInOutZS {
 };
 
 struct GPUTrackingInOutDigits {
-  static constexpr uint32_t NSECTORS = gpudatatypes::NSECTORS;
+  static constexpr uint32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
   const o2::tpc::Digit* tpcDigits[NSECTORS] = {nullptr};
   size_t nTPCDigits[NSECTORS] = {0};
   const GPUTPCDigitsMCInput* tpcDigitsMC = nullptr;
@@ -169,7 +165,7 @@ struct GPUTrackingInOutPointers {
   GPUTrackingInOutPointers() = default;
 
   // TPC
-  static constexpr uint32_t NSECTORS = gpudatatypes::NSECTORS;
+  static constexpr uint32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
   const GPUTrackingInOutZS* tpcZS = nullptr;
   const GPUTrackingInOutDigits* tpcPackedDigits = nullptr;
   const GPUTPCClusterData* clusterData[NSECTORS] = {nullptr};
diff --git a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
index 5c908529fdde9..024fd9bbeb6fe 100644
--- a/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUMemorySizeScalers.cxx
@@ -13,6 +13,7 @@
 /// \author David Rohr
 
 #include "GPUMemorySizeScalers.h"
+#include "GPUTPCGeometry.h"
 #include "GPULogging.h"
 
 #include <random>
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h b/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
index b45d1ed43622f..28699870cfdfb 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCClusterOccupancyMap.h
@@ -16,13 +16,13 @@
 #define GPUTPCCLUSTEROCCUPANCYMAP_H
 
 #include "GPUCommonDef.h"
-#include "GPUTPCGeometry.h"
+#include "DataFormatsTPC/Constants.h"
 
 namespace o2::gpu
 {
 struct GPUParam;
 struct GPUTPCClusterOccupancyMapBin {
-  uint16_t bin[GPUTPCGeometry::NSECTORS][GPUTPCGeometry::NROWS];
+  uint16_t bin[o2::tpc::constants::MAXSECTOR][o2::tpc::constants::MAXGLOBALPADROW];
 
   GPUd() static uint32_t getNBins(const GPUParam& param);
   GPUd() static uint32_t getTotalSize(const GPUParam& param);
diff --git a/GPU/GPUTracking/DataTypes/TPCPadBitMap.h b/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
index fdc1e5b598402..6cbdffdc55a52 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
+++ b/GPU/GPUTracking/DataTypes/TPCPadBitMap.h
@@ -17,6 +17,7 @@
 
 #include "clusterFinderDefs.h"
 #include "GPUCommonMath.h"
+#include "DataFormatsTPC/Constants.h"
 
 namespace o2::tpc
 {
@@ -101,8 +102,8 @@ struct TPCPadBitMap {
     T mDeadChannelMap[NWORDS];
   };
 
-  uint16_t mPadOffsetPerRow[GPUTPCGeometry::NROWS];
-  SectorBitMap mBitMap[GPUTPCGeometry::NSECTORS];
+  uint16_t mPadOffsetPerRow[o2::tpc::constants::MAXGLOBALPADROW];
+  SectorBitMap mBitMap[o2::tpc::constants::MAXSECTOR];
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
index ebb81fbb69f6f..4295b75b6d2b2 100644
--- a/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
+++ b/GPU/GPUTracking/DataTypes/TPCPadGainCalib.h
@@ -17,6 +17,7 @@
 
 #include "clusterFinderDefs.h"
 #include "GPUCommonMath.h"
+#include "DataFormatsTPC/Constants.h"
 
 namespace o2::tpc
 {
@@ -81,14 +82,14 @@ struct TPCPadGainCalib {
 
   GPUdi() void setMinCorrectionFactor(const float minCorrectionFactor)
   {
-    for (uint32_t sector = 0; sector < GPUTPCGeometry::NSECTORS; sector++) {
+    for (uint32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; sector++) {
       mGainCorrection[sector].mMinCorrectionFactor = minCorrectionFactor;
     }
   }
 
   GPUdi() void setMaxCorrectionFactor(const float maxCorrectionFactor)
   {
-    for (uint32_t sector = 0; sector < GPUTPCGeometry::NSECTORS; sector++) {
+    for (uint32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; sector++) {
       mGainCorrection[sector].mMaxCorrectionFactor = maxCorrectionFactor;
     }
   }
@@ -153,8 +154,8 @@ struct TPCPadGainCalib {
     }
   };
 
-  uint16_t mPadOffsetPerRow[GPUTPCGeometry::NROWS];
-  SectorPadGainCorrection<uint16_t> mGainCorrection[GPUTPCGeometry::NSECTORS];
+  uint16_t mPadOffsetPerRow[o2::tpc::constants::MAXGLOBALPADROW];
+  SectorPadGainCorrection<uint16_t> mGainCorrection[o2::tpc::constants::MAXSECTOR];
 };
 
 } // namespace o2::gpu
diff --git a/GPU/GPUTracking/Definitions/GPUDef.h b/GPU/GPUTracking/Definitions/GPUDef.h
index 6bc91e9fef19e..692e0c5ebe231 100644
--- a/GPU/GPUTracking/Definitions/GPUDef.h
+++ b/GPU/GPUTracking/Definitions/GPUDef.h
@@ -20,7 +20,6 @@
 #include "GPUDefConstantsAndSettings.h"
 #include "GPUDefParametersWrapper.h"
 #include "GPUCommonRtypes.h"
-#include "GPUTPCGeometry.h"
 
 // Macros for masking ptrs in OpenCL kernel calls as uint64_t (The API only allows us to pass buffer objects)
 #ifdef __OPENCL__
diff --git a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
index 41f9faaabc86a..751d4a035ac85 100644
--- a/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
+++ b/GPU/GPUTracking/Definitions/GPUDefParametersConstants.h
@@ -32,7 +32,7 @@
 namespace o2::gpu::constants
 {
 static constexpr size_t GPU_MAX_THREADS = 1024;
-static constexpr size_t GPU_MAX_STREAMS = 36;
+static constexpr size_t GPU_MAX_STREAMS = o2::tpc::constants::MAXSECTOR;
 
 static constexpr size_t GPU_ROWALIGNMENT =  16;      // Align of Row Hits and Grid
 static constexpr size_t GPU_BUFFER_ALIGNMENT =  64;  // Alignment of buffers obtained from SetPointers
diff --git a/GPU/GPUTracking/Definitions/clusterFinderDefs.h b/GPU/GPUTracking/Definitions/clusterFinderDefs.h
index 02f26199bbe1c..e0b080b1abc08 100644
--- a/GPU/GPUTracking/Definitions/clusterFinderDefs.h
+++ b/GPU/GPUTracking/Definitions/clusterFinderDefs.h
@@ -16,6 +16,7 @@
 #define O2_GPU_CLUSTERFINDERDEFS_H
 
 #include "GPUDef.h"
+#include "DataFormatsTPC/Constants.h"
 
 /* #define CHARGEMAP_TIME_MAJOR_LAYOUT */
 #define CHARGEMAP_TILING_LAYOUT
@@ -42,7 +43,7 @@
 #define TPC_CLUSTERER_ROW_STRIDE (TPC_CLUSTERER_ROW_PAD_CAPACITY + GPUCF_PADDING_PAD)
 // Number of pads in a sector as stored internally by the clusterizer.
 // This includes fake pads for constant strides between rows
-#define TPC_CLUSTERER_STRIDED_PAD_COUNT (GPUTPCGeometry::NROWS * TPC_CLUSTERER_ROW_STRIDE + GPUCF_PADDING_PAD)
+#define TPC_CLUSTERER_STRIDED_PAD_COUNT (o2::tpc::constants::MAXGLOBALPADROW * TPC_CLUSTERER_ROW_STRIDE + GPUCF_PADDING_PAD)
 // Real of number of pads in a sector
 #define TPC_REAL_PADS_IN_SECTOR 14560
 #define TPC_FEC_IDS_IN_SECTOR 23296
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index 3ff9969365121..aad3f6560490f 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -24,6 +24,7 @@
 #include "GPUProcessor.h"
 #include "GPUTPCGMMergerTypes.h"
 #include "GPUGeneralKernels.h"
+#include "GPUTPCGeometry.h"
 
 #if !defined(GPUCA_GPUCODE)
 #include <cmath>
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 9dcf2cb3e2fe7..8b9baac4f54b0 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -259,8 +259,8 @@ template <int32_t mergeType>
 inline void GPUTPCGMMerger::MergedTrackStreamerInternal(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, int32_t mergeMode, float weight, float frac) const
 {
 #ifdef DEBUG_STREAMER
-  std::vector<int32_t> hits1(152), hits2(152);
-  for (int32_t i = 0; i < 152; i++) {
+  std::vector<int32_t> hits1(GPUTPCGeometry::NROWS), hits2(GPUTPCGeometry::NROWS);
+  for (int32_t i = 0; i < GPUTPCGeometry::NROWS; i++) {
     hits1[i] = hits2[i] = -1;
   }
   const GPUTPCTracker& tracker1 = GetConstantMem()->tpcTrackers[sector1];
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
index 1710f460f01e5..784b60baec3d6 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCExtrapolationTracking.cxx
@@ -167,11 +167,11 @@ GPUdii() void GPUTPCExtrapolationTracking::Thread<0>(int32_t nBlocks, int32_t nT
     return;
   }
   const uint32_t iSector = tracker.ISector();
-  uint32_t sectorLeft = (iSector + (gpudatatypes::NSECTORS / 2 - 1)) % (gpudatatypes::NSECTORS / 2);
-  uint32_t sectorRight = (iSector + 1) % (gpudatatypes::NSECTORS / 2);
-  if (iSector >= (int32_t)gpudatatypes::NSECTORS / 2) {
-    sectorLeft += gpudatatypes::NSECTORS / 2;
-    sectorRight += gpudatatypes::NSECTORS / 2;
+  uint32_t sectorLeft = (iSector + (GPUTPCGeometry::NSECTORS / 2 - 1)) % (GPUTPCGeometry::NSECTORS / 2);
+  uint32_t sectorRight = (iSector + 1) % (GPUTPCGeometry::NSECTORS / 2);
+  if (iSector >= (int32_t)GPUTPCGeometry::NSECTORS / 2) {
+    sectorLeft += GPUTPCGeometry::NSECTORS / 2;
+    sectorRight += GPUTPCGeometry::NSECTORS / 2;
   }
   PerformExtrapolationTracking(nBlocks, nThreads, iBlock, iThread, tracker.GetConstantMem()->tpcTrackers[sectorLeft], smem, tracker, true);
   PerformExtrapolationTracking(nBlocks, nThreads, iBlock, iThread, tracker.GetConstantMem()->tpcTrackers[sectorRight], smem, tracker, false);
@@ -180,22 +180,22 @@ GPUdii() void GPUTPCExtrapolationTracking::Thread<0>(int32_t nBlocks, int32_t nT
 GPUd() int32_t GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorOrder(int32_t iSector)
 {
   iSector++;
-  if (iSector == gpudatatypes::NSECTORS / 2) {
+  if (iSector == GPUTPCGeometry::NSECTORS / 2) {
     iSector = 0;
   }
-  if (iSector == gpudatatypes::NSECTORS) {
-    iSector = gpudatatypes::NSECTORS / 2;
+  if (iSector == GPUTPCGeometry::NSECTORS) {
+    iSector = GPUTPCGeometry::NSECTORS / 2;
   }
   return iSector;
 }
 
 GPUd() void GPUTPCExtrapolationTracking::ExtrapolationTrackingSectorLeftRight(uint32_t iSector, uint32_t& left, uint32_t& right)
 {
-  left = (iSector + (gpudatatypes::NSECTORS / 2 - 1)) % (gpudatatypes::NSECTORS / 2);
-  right = (iSector + 1) % (gpudatatypes::NSECTORS / 2);
-  if (iSector >= (int32_t)gpudatatypes::NSECTORS / 2) {
-    left += gpudatatypes::NSECTORS / 2;
-    right += gpudatatypes::NSECTORS / 2;
+  left = (iSector + (GPUTPCGeometry::NSECTORS / 2 - 1)) % (GPUTPCGeometry::NSECTORS / 2);
+  right = (iSector + 1) % (GPUTPCGeometry::NSECTORS / 2);
+  if (iSector >= (int32_t)GPUTPCGeometry::NSECTORS / 2) {
+    left += GPUTPCGeometry::NSECTORS / 2;
+    right += GPUTPCGeometry::NSECTORS / 2;
   }
 }
 
diff --git a/GPU/GPUTracking/display/GPUDisplay.h b/GPU/GPUTracking/display/GPUDisplay.h
index e9082e7e77634..b450ac1c18060 100644
--- a/GPU/GPUTracking/display/GPUDisplay.h
+++ b/GPU/GPUTracking/display/GPUDisplay.h
@@ -19,7 +19,7 @@
 #include "backend/GPUDisplayBackend.h"
 #include "GPUDisplayInterface.h"
 #include "GPUSettings.h"
-#include "GPUTPCGeometry.h"
+#include "DataFormatsTPC/Constants.h"
 
 #include <array>
 #include <mutex>
@@ -83,7 +83,7 @@ class GPUDisplay : public GPUDisplayInterface
   int32_t& drawTextFontSize() { return mDrawTextFontSize; }
 
  private:
-  static constexpr int32_t NSECTORS = GPUTPCGeometry::NSECTORS;
+  static constexpr int32_t NSECTORS = o2::tpc::constants::MAXSECTOR;
   static constexpr float GL_SCALE_FACTOR = (1.f / 100.f);
 
   static constexpr const int32_t N_POINTS_TYPE = 15;
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
index 9914fbad20ea3..a459a8e290ef6 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackend.cxx
@@ -35,6 +35,7 @@
 
 #include "GPUDisplay.h"
 #include "GPULogging.h"
+#include "GPUTPCGeometry.h"
 #include <string>
 
 using namespace o2::gpu;
diff --git a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
index 606372be84a86..effe59588da24 100644
--- a/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
+++ b/GPU/GPUTracking/display/backend/GPUDisplayBackendOpenGL.cxx
@@ -29,6 +29,7 @@
 #include "GPUDisplay.h"
 #include "GPULogging.h"
 #include "GPUParam.h"
+#include "GPUTPCGeometry.h"
 
 #define OPENGL_EMULATE_MULTI_DRAW 0
 
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 9f5b0f81f836a..5c1ef7747113a 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -536,7 +536,7 @@ int32_t GPUQA::InitQACreateHistograms()
     // Create Tracks Histograms
     for (int32_t i = 0; i < 2; i++) {
       snprintf(name, 2048, i ? "nrows_with_cluster" : "nclusters");
-      createHist(mNCl[i], name, name, 160, 0, 159);
+      createHist(mNCl[i], name, name, GPUTPCGeometry::NROWS + 1, 0, GPUTPCGeometry::NROWS);
     }
     std::unique_ptr<double[]> binsPt{CreateLogAxis(AXIS_BINS[4], PT_MIN_CLUST, PT_MAX)};
     createHist(mTrackPt, "tracks_pt", "tracks_pt", AXIS_BINS[4], binsPt.get());
diff --git a/GPU/GPUTracking/qa/genEvents.cxx b/GPU/GPUTracking/qa/genEvents.cxx
index 09c85a05db68a..5af7698fdb4dc 100644
--- a/GPU/GPUTracking/qa/genEvents.cxx
+++ b/GPU/GPUTracking/qa/genEvents.cxx
@@ -101,14 +101,13 @@ double genEvents::GetGaus(double sigma)
 
 void genEvents::InitEventGenerator()
 {
-  const char* rows[3] = {"0-63", "128-159", "64-127"};
   for (int32_t i = 0; i < 3; i++) {
     for (int32_t j = 0; j < 2; j++) {
       char name[1024], title[1024];
 
       snprintf(name, 1024, "clError%s%d", (j == 0 ? "Y" : "Z"), i);
 
-      snprintf(title, 1024, "Cluster %s Error for rows %s", (j == 0 ? "Y" : "Z"), rows[i]);
+      snprintf(title, 1024, "Cluster %s Error for row region %d", (j == 0 ? "Y" : "Z"), i);
 
       mClusterError[i][j] = new TH1F(name, title, 1000, 0., .7);
       mClusterError[i][j]->GetXaxis()->SetTitle("Cluster Error [cm]");
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 6dd0e716c833b..8521bee99daa6 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -19,7 +19,7 @@
 
 #include "GPUCommonDef.h"
 #include "GPUCommonMath.h"
-
+#include "DataFormatsTPC/Constants.h"
 #ifndef GPUCA_GPUCODE_DEVICE
 #include <memory>
 #include "GPUCommonRtypes.h"
@@ -178,9 +178,9 @@ class TPCFastTransformGeo
  private:
   /// _______________  Data members  _______________________________________________
 
-  static constexpr int32_t NumberOfSectors = 36;                   ///< Number of TPC sectors ( sector = inner + outer sector )
-  static constexpr int32_t NumberOfSectorsA = NumberOfSectors / 2; ///< Number of TPC sectors side A
-  static constexpr int32_t MaxNumberOfRows = 160;                  ///< Max Number of TPC rows in a sector
+  static constexpr int32_t NumberOfSectors = o2::tpc::constants::MAXSECTOR; ///< Number of TPC sectors ( sector = inner + outer sector )
+  static constexpr int32_t NumberOfSectorsA = NumberOfSectors / 2;          ///< Number of TPC sectors side A
+  static constexpr int32_t MaxNumberOfRows = 160;                           ///< Max Number of TPC rows in a sector - MUST NOT CHANGE THIS due to on-disk format of stored maps
 
   /// _______________  Construction control  _______________________________________________
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index 6d7ca4d485fc6..d345d2f75d608 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -19,6 +19,7 @@
 
 #include "GPUCommonRtypes.h"
 #include "TPCFastTransform.h"
+#include "DataFormatsTPC/Constants.h"
 #ifndef GPUCA_GPUCODE
 #include <memory>
 #include <cstdlib>
@@ -240,8 +241,8 @@ class TPCFastTransformPOD
 
   GPUd() float convDriftLengthToTime(float driftLength, float vertexTime) const;
 
-  static constexpr int NROWS = 152;
-  static constexpr int NSECTORS = TPCFastTransformGeo::getNumberOfSectors();
+  static constexpr int NROWS = o2::tpc::constants::MAXGLOBALPADROW;
+  static constexpr int NSECTORS = o2::tpc::constants::MAXSECTOR;
   static constexpr int NSplineIDs = 3; ///< number of spline data sets for each sector/row
 
  private:
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index 8b0a07c28ea6c..98e587102f875 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -62,15 +62,11 @@
 #pragma link C++ class o2::gpu::TPCFastTransformGeo::SectorInfo + ;
 
 #pragma link C++ class o2::gpu::TPCFastTransformGeo + ;
-#pragma read \
-  sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "float mTPCzLengthA; float mTPCzLengthC; float mTPCalignmentZ; float mScaleVtoSVsideA; float mScaleVtoSVsideC; float mScaleSVtoVsideA; float mScaleSVtoVsideC;" version = "[-1]" target = "mTPCzLength" code = "{ mTPCzLength = onfile.mTPCzLengthA; }";
-
-#pragma read \
-  sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "o2::gpu::TPCFastTransformGeo::SliceInfo mSliceInfos[37]" version = "[-2]" target = "" code = "{}";
+#pragma read sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "float mTPCzLengthA; float mTPCzLengthC; float mTPCalignmentZ; float mScaleVtoSVsideA; float mScaleVtoSVsideC; float mScaleSVtoVsideA; float mScaleSVtoVsideC;" version = "[-1]" target = "mTPCzLength" code = "{ mTPCzLength = onfile.mTPCzLengthA; }";
+#pragma read sourceClass = "o2::gpu::TPCFastTransformGeo" targetClass = "o2::gpu::TPCFastTransformGeo" source = "o2::gpu::TPCFastTransformGeo::SliceInfo mSliceInfos[37]" version = "[-2]" target = "" code = "{}";
 
 #pragma link C++ class o2::gpu::TPCFastTransformGeo::RowInfo + ;
-#pragma read \
-  sourceClass = "o2::gpu::TPCFastTransformGeo::RowInfo" targetClass = "o2::gpu::TPCFastTransformGeo::RowInfo" source = "float u0; float scaleUtoSU; float scaleSUtoU" version = "[-1]" target = "yMin" code = "{ yMin = onfile.u0; }"
+#pragma read sourceClass = "o2::gpu::TPCFastTransformGeo::RowInfo" targetClass = "o2::gpu::TPCFastTransformGeo::RowInfo" source = "float u0; float scaleUtoSU; float scaleSUtoU" version = "[-1]" target = "yMin" code = "{ yMin = onfile.u0; }"
 
 #pragma link C++ class o2::gpu::TPCFastTransform + ;
 
@@ -80,14 +76,9 @@
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SectorRowInfo + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::GridInfo + ;
-#pragma read \
-  sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo mSliceInfo[36]" version = "[-3]" target = "" code = "{}";
-
-#pragma read \
-  sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "size_t mSliceDataSizeBytes[3]" version = "[-3]" target = "mCorrectionDataSize" code = "{ for (int i=0; i<3; i++) mCorrectionDataSize[i] = onfile.mSliceDataSizeBytes[i] * 36; }";
-
-#pragma read \
-  sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "float fInterpolationSafetyMargin" version = "[-3]" target = "" code = "{}";
+#pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo mSliceInfo[36]" version = "[-3]" target = "" code = "{}";
+#pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "size_t mSliceDataSizeBytes[3]" version = "[-3]" target = "mCorrectionDataSize" code = "{ for (int i=0; i<3; i++) mCorrectionDataSize[i] = onfile.mSliceDataSizeBytes[i] * o2::tpc::constants::MAXSECTOR; }";
+#pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "float fInterpolationSafetyMargin" version = "[-3]" target = "" code = "{}";
 
 #pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
 #pragma link C++ struct o2::gpu::NDPiecewisePolynomialContainer + ;

From b6b6016c69e3f5274066fbf83f7d4ea2d7a1579b Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 8 Apr 2026 11:09:57 +0200
Subject: [PATCH 1598/1764] Fix compiler warning

---
 Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
index a13a3402eb260..6ceb04b3c4df6 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/TrackerSpec.cxx
@@ -255,7 +255,7 @@ void TrackerDPL::run(ProcessingContext& pc)
 
         rof->setFirstEntry(firstROFTrackEntry);
         rof->setNEntries(ntracksROF);
-        *rof++;
+        rof++;
         roFrameId++;
       }
     }
@@ -313,7 +313,7 @@ void TrackerDPL::run(ProcessingContext& pc)
         copyTracks(tracksL, allTracksMFT, allClusIdx);
         rof->setFirstEntry(firstROFTrackEntry);
         rof->setNEntries(ntracksROF);
-        *rof++;
+        rof++;
         roFrameId++;
       }
     }

From 3619ffc93edd7330ff13c05aa30d9e9eccd7e97e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 8 Apr 2026 11:25:22 +0200
Subject: [PATCH 1599/1764] GPU: Fix compilation in Run2 mode

---
 .../Standalone/Benchmark/standalone.cxx        |  2 +-
 .../display/render/GPUDisplayDraw.cxx          |  3 ++-
 GPU/GPUTracking/qa/GPUQA.cxx                   | 18 +++++++++++++-----
 GPU/GPUTracking/qa/GPUQA.h                     |  5 +++--
 4 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 07373ad29d402..a882473cff92f 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -154,7 +154,7 @@ int32_t ReadConfiguration(int argc, char** argv)
   }
 #endif
 #ifdef GPUCA_RUN2
-#error Why was configStandalone.rec.tpc.mergerReadFromTrackerDirectly = 0 needed?
+#warning Why was configStandalone.rec.tpc.mergerReadFromTrackerDirectly = 0 needed?
   configStandalone.proc.inKernelParallel = false;
   configStandalone.proc.createO2Output = 0;
   if (configStandalone.rundEdx == -1) {
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 1ebf35a83f7c6..8b3ab92c0b334 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -571,10 +571,11 @@ void GPUDisplay::DrawFinal(int32_t iSector, int32_t /*iCol*/, const GPUTPCGMProp
           if (mc.pid < 0) {
             break;
           }
+#ifndef GPUCA_RUN2
           if (mc.t0 == -100.f) {
             break;
           }
-
+#endif
           alphaOrg = mParam->Alpha(iSector);
           float c = cosf(alphaOrg);
           float s = sinf(alphaOrg);
diff --git a/GPU/GPUTracking/qa/GPUQA.cxx b/GPU/GPUTracking/qa/GPUQA.cxx
index 5c1ef7747113a..5bbb0e2546a13 100644
--- a/GPU/GPUTracking/qa/GPUQA.cxx
+++ b/GPU/GPUTracking/qa/GPUQA.cxx
@@ -204,7 +204,7 @@ int32_t GPUQA::initColors()
 static constexpr Color_t defaultColorNums[COLORCOUNT] = {kRed, kBlue, kGreen, kMagenta, kOrange, kAzure, kBlack, kYellow, kGray, kTeal, kSpring, kPink};
 
 #define TRACK_EXPECTED_REFERENCE_X_DEFAULT 81
-#ifndef GPUCA_RUN2
+#ifndef GPUCA_RUN2 // Run 3 implementation
 static inline int32_t GPUQA_O2_ConvertFakeLabel(int32_t label) { return label >= 0x7FFFFFFE ? -1 : label; }
 inline uint32_t GPUQA::GetNMCCollissions() const { return mMCInfosCol.size(); }
 inline uint32_t GPUQA::GetNMCTracks(int32_t iCol) const { return mMCInfosCol[iCol].num; }
@@ -229,7 +229,7 @@ uint32_t GPUQA::GetMCLabelCol(const mcLabel_t& label) const { return !label.isVa
 GPUQA::mcLabelI_t GPUQA::GetMCTrackLabel(uint32_t trackId) const { return trackId >= mTrackMCLabels.size() ? MCCompLabel() : mTrackMCLabels[trackId]; }
 bool GPUQA::CompareIgnoreFake(const mcLabelI_t& l1, const mcLabelI_t& l2) { return l1.compare(l2) >= 0; }
 #define TRACK_EXPECTED_REFERENCE_X 78
-#else
+#else // Run 2 implementation
 inline GPUQA::mcLabelI_t::mcLabelI_t(const GPUQA::mcLabel_t& l) : track(l.fMCID) {}
 inline bool GPUQA::mcLabelI_t::operator==(const GPUQA::mcLabel_t& l) { return AbsLabelID(track) == l.fMCID; }
 inline uint32_t GPUQA::GetNMCCollissions() const { return 1; }
@@ -247,7 +247,6 @@ inline int32_t GPUQA::GetMCLabelID(uint32_t i, uint32_t j) { return mTracking->m
 inline int32_t GPUQA::GetMCLabelID(const mcLabels_t& label, uint32_t j) { return label.fClusterID[j].fMCID; }
 inline int32_t GPUQA::GetMCLabelID(const mcLabel_t& label) { return label.fMCID; }
 inline uint32_t GPUQA::GetMCLabelCol(uint32_t i, uint32_t j) { return 0; }
-
 inline const auto& GPUQA::GetClusterLabels() { return mTracking->mIOPtrs.mcLabelsTPC; }
 inline float GPUQA::GetMCLabelWeight(uint32_t i, uint32_t j) { return mTracking->mIOPtrs.mcLabelsTPC[i].fClusterID[j].fWeight; }
 inline float GPUQA::GetMCLabelWeight(const mcLabels_t& label, uint32_t j) { return label.fClusterID[j].fWeight; }
@@ -257,7 +256,7 @@ inline int32_t GPUQA::AbsLabelID(int32_t id) { return id >= 0 ? id : (-id - 2);
 inline bool GPUQA::mcPresent() { return !mConfig.noMC && mTracking && GetNMCLabels() && GetNMCTracks(0); }
 uint32_t GPUQA::GetMCLabelCol(const mcLabel_t& label) const { return 0; }
 GPUQA::mcLabelI_t GPUQA::GetMCTrackLabel(uint32_t trackId) const { return trackId >= mTrackMCLabels.size() ? mcLabelI_t() : mTrackMCLabels[trackId]; }
-bool GPUQA::CompareIgnoreFake(const mcLabelI_t& l1, const mcLabelI_t& l2) { return AbsLabelID(l1) == AbsLabelID(l2); }
+bool GPUQA::CompareIgnoreFake(const mcLabelI_t& l1, const mcLabelI_t& l2) { return AbsLabelID(l1.track) == AbsLabelID(l2.track); }
 #define TRACK_EXPECTED_REFERENCE_X TRACK_EXPECTED_REFERENCE_X_DEFAULT
 #endif
 template <class T>
@@ -1367,9 +1366,11 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         if (mc1.pid < 0) {
           continue;
         }
+#ifndef GPUCA_RUN2
         if (mc1.t0 == -100.f) {
           continue;
         }
+#endif
         if (mConfig.filterCharge && mc1.charge * mConfig.filterCharge < 0) {
           continue;
         }
@@ -1439,7 +1440,12 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
           if (!mParam->continuousMaxTimeBin) {
             return param.GetZ() - mc1.z;
           }
-          float shift = side == 2 ? 0 : mTracking->GetTPCTransform()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSECTORS / 2, param.GetTOffset() - mc1.t0);
+          float shift = 0;
+#ifndef GPUCA_RUN2
+          if (side != 2) {
+            shift = mTracking->GetTPCTransform()->convDeltaTimeToDeltaZinTimeFrame(side * GPUChainTracking::NSECTORS / 2, param.GetTOffset() - mc1.t0);
+          }
+#endif
           return param.GetZ() + shift - mc1.z;
         };
 
@@ -1784,12 +1790,14 @@ void GPUQA::RunQA(bool matchOnly, const std::vector<o2::tpc::TrackTPC>* tracksEx
         mNCl[1]->Fill(nClCorrected);
       }
       mT0[0]->Fill(track.GetParam().GetTOffset());
+#ifndef GPUCA_RUN2
       if (mTrackMCLabels.size() && !mTrackMCLabels[i].isFake() && !track.MergedLooper() && !track.CCE()) {
         const auto& info = GetMCTrack(mTrackMCLabels[i]);
         if (info.t0 != -100.f) {
           mT0[1]->Fill(track.GetParam().GetTOffset() - info.t0);
         }
       }
+#endif
     }
     if (mClNative && mTracking && mTracking->GetTPCTransform()) {
       for (uint32_t i = 0; i < GPUChainTracking::NSECTORS; i++) {
diff --git a/GPU/GPUTracking/qa/GPUQA.h b/GPU/GPUTracking/qa/GPUQA.h
index 172a768729803..4f4f69125942f 100644
--- a/GPU/GPUTracking/qa/GPUQA.h
+++ b/GPU/GPUTracking/qa/GPUQA.h
@@ -176,10 +176,10 @@ class GPUQA
   T* GetHist(T*& ee, std::vector<std::unique_ptr<TFile>>& tin, int32_t k, int32_t nNewInput);
 
   using mcInfo_t = GPUTPCMCInfo;
-#ifndef GPUCA_RUN2
+#ifndef GPUCA_RUN2 // Run 3 implementation
   mcLabels_t GetMCLabel(uint32_t i);
   mcLabel_t GetMCLabel(uint32_t i, uint32_t j);
-#else
+#else              // Run 2 implementation
   struct mcLabelI_t {
     int32_t getTrackID() const { return AbsLabelID(track); }
     int32_t getEventID() const { return 0; }
@@ -187,6 +187,7 @@ class GPUQA
     int64_t getTrackEventSourceID() const { return getTrackID(); }
     bool isFake() const { return track < 0; }
     bool isValid() const { return track != MC_LABEL_INVALID; }
+    bool isNoise() const { return false; }
     void invalidate() { track = MC_LABEL_INVALID; }
     void setFakeFlag(bool v = true) { track = v ? FakeLabelID(track) : AbsLabelID(track); }
     void setNoise() { track = MC_LABEL_INVALID; }

From a683a1dbde1b28e76f1c759c494eae956231fb0f Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 09:19:33 +0200
Subject: [PATCH 1600/1764] GPU: Add ctest for GPUTPCGeometry

---
 Detectors/TPC/reconstruction/CMakeLists.txt   |  7 ++
 .../reconstruction/test/testGPUGeometry.cxx   | 68 +++++++++++++++++++
 GPU/GPUTracking/DataTypes/GPUTPCGeometry.h    | 24 ++++---
 3 files changed, 90 insertions(+), 9 deletions(-)
 create mode 100644 Detectors/TPC/reconstruction/test/testGPUGeometry.cxx

diff --git a/Detectors/TPC/reconstruction/CMakeLists.txt b/Detectors/TPC/reconstruction/CMakeLists.txt
index 29e6d692968b7..0045aad7aa4c7 100644
--- a/Detectors/TPC/reconstruction/CMakeLists.txt
+++ b/Detectors/TPC/reconstruction/CMakeLists.txt
@@ -96,6 +96,13 @@ o2_add_test(GPUCATracking
             SOURCES test/testGPUCATracking.cxx
             ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage)
 
+o2_add_test(GPUTPCGeometry
+            COMPONENT_NAME tpc
+            LABELS tpc
+            PUBLIC_LINK_LIBRARIES O2::TPCBase O2::GPUDataTypes
+            SOURCES test/testGPUGeometry.cxx
+            ENVIRONMENT O2_ROOT=${CMAKE_BINARY_DIR}/stage)
+
 o2_add_test(HwClusterer
             COMPONENT_NAME tpc
             LABELS tpc
diff --git a/Detectors/TPC/reconstruction/test/testGPUGeometry.cxx b/Detectors/TPC/reconstruction/test/testGPUGeometry.cxx
new file mode 100644
index 0000000000000..e7cfb25c56087
--- /dev/null
+++ b/Detectors/TPC/reconstruction/test/testGPUGeometry.cxx
@@ -0,0 +1,68 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file testGPUGeometry.cxx
+/// \brief Compare GPUTPCGeometry.h to o2::tpc::Mapper
+/// \author David Rohr
+
+#define BOOST_TEST_MODULE Test TPC GPUTPCGeometry
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_DYN_LINK
+#include <boost/test/unit_test.hpp>
+#include "DataFormatsTPC/Constants.h"
+#include "TPCBase/Mapper.h"
+#include "TPCBase/PadRegionInfo.h"
+#include "TPCBase/ParameterDetector.h"
+#include "GPUTPCGeometry.h"
+
+using namespace o2::gpu;
+
+namespace o2
+{
+namespace tpc
+{
+/// @brief Test 1 basic class IO tests
+BOOST_AUTO_TEST_CASE(GPUTPCGeometry_test1)
+{
+  const Mapper& mapper = Mapper::instance();
+  const GPUTPCGeometry geo;
+  const auto regions = mapper.getMapPadRegionInfo();
+
+  BOOST_CHECK_EQUAL(mapper.getNumberOfPadRegions(), geo.NRegions());
+  BOOST_CHECK_EQUAL(mapper.NSECTORS, geo.NSECTORS);
+  BOOST_CHECK_EQUAL(mapper.PADROWS, geo.NROWS);
+
+  auto& detParam = ParameterDetector::Instance();
+  BOOST_CHECK_EQUAL(detParam.TPClength, geo.TPCLength());
+
+  /*for (unsigned int i = 0; i < mapper.NPARTITIONS; i++) {
+    BOOST_CHECK_EQUAL(???, geo.GetSectorFECOffset(i)); // TODO: Get value from mapper and compare!
+  }*/
+
+  for (unsigned int i = 0; i < mapper.getNumberOfPadRegions(); i++) {
+    BOOST_CHECK_EQUAL(mapper.ROWSPERREGION[i], geo.GetRegionRows(i));
+    BOOST_CHECK_EQUAL(mapper.ROWOFFSET[i], geo.GetRegionStart(i));
+    // BOOST_CHECK_EQUAL(???, geo.GetSampaMapping(i)); // TODO: Get value from mapper and compare!
+    // BOOST_CHECK_EQUAL(???, geo.GetChannelOffset(i)); // TODO: Get value from mapper and compare!
+    BOOST_CHECK_EQUAL(regions[i].getPadHeight(), geo.PadHeightByRegion(i));
+    BOOST_CHECK_EQUAL(regions[i].getPadWidth(), geo.PadWidthByRegion(i));
+  }
+
+  for (unsigned int i = 0; i < mapper.PADROWS; i++) {
+    BOOST_CHECK_EQUAL(mapper.REGION[i], geo.GetRegion(i));
+    unsigned int region = mapper.REGION[i];
+    BOOST_CHECK_EQUAL(regions[region].getPadsInRowRegion(mapper.getLocalRowFromGlobalRow(i)), geo.NPads(i));
+    const auto& pos = mapper.padCentre(mapper.getGlobalPadNumber(mapper.getLocalRowFromGlobalRow(i), 0, region));
+    BOOST_CHECK_EQUAL(pos.x(), geo.Row2X(i));
+  }
+}
+} // namespace tpc
+} // namespace o2
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
index a203b55157401..5ff022d520214 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
@@ -25,6 +25,7 @@ namespace o2::gpu
 namespace gputpcgeometry_internal
 {
 #ifndef GPUCA_RUN2 // clang-format off
+constexpr uint32_t NREGIONS = 10;
 GPUconstexpr() float mX[o2::tpc::constants::MAXGLOBALPADROW] = {85.225f, 85.975f, 86.725f, 87.475f, 88.225f, 88.975f, 89.725f, 90.475f, 91.225f, 91.975f, 92.725f, 93.475f, 94.225f, 94.975f, 95.725f, 96.475f, 97.225f, 97.975f, 98.725f, 99.475f, 100.225f, 100.975f,
                                         101.725f, 102.475f, 103.225f, 103.975f, 104.725f, 105.475f, 106.225f, 106.975f, 107.725f, 108.475f, 109.225f, 109.975f, 110.725f, 111.475f, 112.225f, 112.975f, 113.725f, 114.475f, 115.225f, 115.975f, 116.725f, 117.475f,
                                         118.225f, 118.975f, 119.725f, 120.475f, 121.225f, 121.975f, 122.725f, 123.475f, 124.225f, 124.975f, 125.725f, 126.475f, 127.225f, 127.975f, 128.725f, 129.475f, 130.225f, 130.975f, 131.725f, 135.2f, 136.2f, 137.2f,
@@ -40,18 +41,20 @@ GPUconstexpr() uint8_t mNPads[o2::tpc::constants::MAXGLOBALPADROW] = {66, 66, 66
 
 GPUconstexpr() uint8_t mRegion[o2::tpc::constants::MAXGLOBALPADROW] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
                                                4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
-GPUconstexpr() uint8_t mRegionRows[10] = {17, 15, 16, 15, 18, 16, 16, 14, 13, 12};
-GPUconstexpr() uint8_t mRegionStart[10] = {0, 17, 32, 48, 63, 81, 97, 113, 127, 140};
+GPUconstexpr() uint8_t mRegionRows[NREGIONS] = {17, 15, 16, 15, 18, 16, 16, 14, 13, 12};
+GPUconstexpr() uint8_t mRegionStart[NREGIONS] = {0, 17, 32, 48, 63, 81, 97, 113, 127, 140};
 
-GPUconstexpr() uint8_t mSampaMapping[10] = {0, 0, 1, 1, 2, 3, 3, 4, 4, 2};
-GPUconstexpr() uint8_t mChannelOffset[10] = {0, 16, 0, 16, 0, 0, 16, 0, 16, 16};
+GPUconstexpr() uint8_t mSampaMapping[NREGIONS] = {0, 0, 1, 1, 2, 3, 3, 4, 4, 2};
+GPUconstexpr() uint8_t mChannelOffset[NREGIONS] = {0, 16, 0, 16, 0, 0, 16, 0, 16, 16};
 GPUconstexpr() uint8_t mSectorFECOffset[5] = {0, 15, 15 + 18, 15 + 18 + 18, 15 + 18 + 18 + 20};
 
-GPUconstexpr() float mPadHeight[10] = {.75f, .75f, .75f, .75f, 1.f, 1.f, 1.2f, 1.2f, 1.5f, 1.5f};
-GPUconstexpr() float mPadWidth[10] = {.416f, .420f, .420f, .436f, .6f, .6f, .608f, .588f, .604f, .607f};
+GPUconstexpr() float mPadHeight[NREGIONS] = {.75f, .75f, .75f, .75f, 1.f, 1.f, 1.2f, 1.2f, 1.5f, 1.5f};
+GPUconstexpr() float mPadWidth[NREGIONS] = {.416f, .420f, .420f, .436f, .6f, .6f, .608f, .588f, .604f, .607f};
 
+constexpr float TPC_LENGTH = 250.f;
 constexpr float FACTOR_T2Z = 250.f / 512.f; // Used in compression, must remain constant at 250cm, 512 time bins!
 #else
+constexpr uint32_t NREGIONS = 3;
 GPUconstexpr() float mX[o2::tpc::constants::MAXGLOBALPADROW] = {85.195f, 85.945f, 86.695f, 87.445f, 88.195f, 88.945f, 89.695f, 90.445f, 91.195f, 91.945f, 92.695f, 93.445f, 94.195f, 94.945f, 95.695f, 96.445f, 97.195f, 97.945f, 98.695f, 99.445f, 100.195f, 100.945f, 101.695f,
                                         102.445f, 103.195f, 103.945f, 104.695f, 105.445f, 106.195f, 106.945f, 107.695f, 108.445f, 109.195f, 109.945f, 110.695f, 111.445f, 112.195f, 112.945f, 113.695f, 114.445f, 115.195f, 115.945f, 116.695f, 117.445f, 118.195f, 118.945f,
                                         119.695f, 120.445f, 121.195f, 121.945f, 122.695f, 123.445f, 124.195f, 124.945f, 125.695f, 126.445f, 127.195f, 127.945f, 128.695f, 129.445f, 130.195f, 130.945f, 131.695f, 135.180f, 136.180f, 137.180f, 138.180f, 139.180f, 140.180f,
@@ -65,9 +68,10 @@ GPUconstexpr() uint8_t mNPads[o2::tpc::constants::MAXGLOBALPADROW] = {68, 68, 68
                                               84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108,
                                               108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
 
-GPUconstexpr() float mPadHeight[3] = {.75f, 1.f, 1.5f};
-GPUconstexpr() float mPadWidth[3] = {.4f, .6f, .6f};
+GPUconstexpr() float mPadHeight[NREGIONS] = {.75f, 1.f, 1.5f};
+GPUconstexpr() float mPadWidth[NREGIONS] = {.4f, .6f, .6f};
 
+constexpr float TPC_LENGTH = 250.f - 0.275f;
 constexpr float FACTOR_T2Z = 250.f / 1024.f; // Used in compression, must remain constant at 250cm, 1024 time bins!
 #endif // clang-format on
 } // namespace gputpcgeometry_internal
@@ -103,11 +107,13 @@ class GPUTPCGeometry
   GPUd() static constexpr int32_t MaxNPadsPerRow() { return 140; }
 #endif
 
-  GPUd() static constexpr float TPCLength() { return 250.f - 0.275f; }
+  GPUd() static constexpr float NRegions() { return gputpcgeometry_internal::NREGIONS; }
+  GPUd() static constexpr float TPCLength() { return gputpcgeometry_internal::TPC_LENGTH; }
   GPUd() static constexpr float Row2X(int32_t row) { return (gputpcgeometry_internal::mX[row]); }
   GPUd() static constexpr float PadHeight(int32_t row) { return (gputpcgeometry_internal::mPadHeight[GetRegion(row)]); }
   GPUd() static constexpr float PadHeightByRegion(int32_t region) { return (gputpcgeometry_internal::mPadHeight[region]); }
   GPUd() static constexpr float PadWidth(int32_t row) { return (gputpcgeometry_internal::mPadWidth[GetRegion(row)]); }
+  GPUd() static constexpr float PadWidthByRegion(int32_t region) { return (gputpcgeometry_internal::mPadWidth[region]); }
   GPUd() static constexpr uint8_t NPads(int32_t row) { return gputpcgeometry_internal::mNPads[row]; }
 
   GPUd() static constexpr float LinearPad2Y(uint32_t sector, uint32_t row, float pad)

From 4bfb3015d5af37fcb9feb0edf0803dd00d5edb75 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 13:38:39 +0200
Subject: [PATCH 1601/1764] GPU Common: Add GPUCommonConfigurableParam to
 support ConfigurableParam classes in GPU code

---
 .../base/include/TPCBase/ParameterDetector.h  |  3 +-
 .../include/TPCBase/ParameterElectronics.h    |  3 +-
 .../TPC/base/include/TPCBase/ParameterGas.h   |  3 +-
 GPU/Common/GPUCommonConfigurableParam.h       | 42 +++++++++++++++++++
 4 files changed, 45 insertions(+), 6 deletions(-)
 create mode 100644 GPU/Common/GPUCommonConfigurableParam.h

diff --git a/Detectors/TPC/base/include/TPCBase/ParameterDetector.h b/Detectors/TPC/base/include/TPCBase/ParameterDetector.h
index 2762f6ff67d31..e557a174ec70a 100644
--- a/Detectors/TPC/base/include/TPCBase/ParameterDetector.h
+++ b/Detectors/TPC/base/include/TPCBase/ParameterDetector.h
@@ -18,8 +18,7 @@
 
 #include <array>
 #include "DataFormatsTPC/Defs.h"
-#include "CommonUtils/ConfigurableParam.h"
-#include "CommonUtils/ConfigurableParamHelper.h"
+#include "GPUCommonConfigurableParam.h"
 
 namespace o2
 {
diff --git a/Detectors/TPC/base/include/TPCBase/ParameterElectronics.h b/Detectors/TPC/base/include/TPCBase/ParameterElectronics.h
index a44410d29ae15..8ada729f36103 100644
--- a/Detectors/TPC/base/include/TPCBase/ParameterElectronics.h
+++ b/Detectors/TPC/base/include/TPCBase/ParameterElectronics.h
@@ -17,9 +17,8 @@
 #define ALICEO2_TPC_ParameterElectronics_H_
 
 #include <array>
-#include "CommonUtils/ConfigurableParam.h"
-#include "CommonUtils/ConfigurableParamHelper.h"
 #include "CommonConstants/LHCConstants.h"
+#include "GPUCommonConfigurableParam.h"
 
 namespace o2::tpc
 {
diff --git a/Detectors/TPC/base/include/TPCBase/ParameterGas.h b/Detectors/TPC/base/include/TPCBase/ParameterGas.h
index d9bc65a08173a..210d8dbd14867 100644
--- a/Detectors/TPC/base/include/TPCBase/ParameterGas.h
+++ b/Detectors/TPC/base/include/TPCBase/ParameterGas.h
@@ -17,8 +17,7 @@
 #define ALICEO2_TPC_ParameterGas_H_
 
 #include <array>
-#include "CommonUtils/ConfigurableParam.h"
-#include "CommonUtils/ConfigurableParamHelper.h"
+#include "GPUCommonConfigurableParam.h"
 
 namespace o2
 {
diff --git a/GPU/Common/GPUCommonConfigurableParam.h b/GPU/Common/GPUCommonConfigurableParam.h
new file mode 100644
index 0000000000000..475679df270e3
--- /dev/null
+++ b/GPU/Common/GPUCommonConfigurableParam.h
@@ -0,0 +1,42 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file GPUCommonConfigurableParam.h
+/// \author David Rohr
+
+#ifndef GPUCOMMONCONFIGURABLEPARAM_H
+#define GPUCOMMONCONFIGURABLEPARAM_H
+
+#include "GPUCommonDef.h"
+
+#if defined(GPUCA_STANDALONE)
+
+namespace o2::conf
+{
+template <class T>
+struct ConfigurableParamHelper {
+  static const T& Instance()
+  {
+    static T instance;
+    return instance;
+  }
+};
+#define O2ParamDef(...)
+} // namespace o2::conf
+
+#else
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "CommonUtils/ConfigurableParamHelper.h"
+
+#endif
+
+#endif

From d4d7f8ea7e95a2c0b14c2c78959e53b9bed92d95 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 10:51:03 +0200
Subject: [PATCH 1602/1764] TPC FastTransform: Get Geometry from GPUTPCGeometry
 not from o2::tpc::mapper

---
 .../src/TPCFastTransformHelperO2.cxx          | 30 +++++--------------
 1 file changed, 7 insertions(+), 23 deletions(-)

diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index 6e0bccbdc40fe..f778bfda07cd6 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -22,7 +22,8 @@
 #include "TPCBase/Sector.h"
 #include "DataFormatsTPC/Defs.h"
 #include "TPCFastTransform.h"
-#include <fairlogger/Logger.h>
+#include "GPUTPCGeometry.h"
+#include <GPUCommonLogger.h>
 
 using namespace o2::gpu;
 
@@ -47,32 +48,15 @@ void TPCFastTransformHelperO2::init()
 {
   // initialize geometry
 
-  const Mapper& mapper = Mapper::instance();
+  const GPUTPCGeometry geo;
 
-  const int nRows = mapper.getNumberOfRows();
+  const int nRows = geo.NROWS;
 
   mGeo.startConstruction(nRows);
+  mGeo.setTPCzLength(geo.TPCLength());
 
-  auto& detParam = ParameterDetector::Instance();
-  mGeo.setTPCzLength(detParam.TPClength);
-
-  for (int iRow = 0; iRow < mGeo.getNumberOfRows(); iRow++) {
-    Sector sector = 0;
-    int regionNumber = 0;
-    while (iRow >= mapper.getGlobalRowOffsetRegion(regionNumber) + mapper.getNumberOfRowsRegion(regionNumber)) {
-      regionNumber++;
-    }
-
-    const PadRegionInfo& region = mapper.getPadRegionInfo(regionNumber);
-
-    int nPads = mapper.getNumberOfPadsInRowSector(iRow);
-    float padWidth = region.getPadWidth();
-
-    const GlobalPadNumber pad = mapper.globalPadNumber(PadPos(iRow, nPads / 2));
-    const PadCentre& padCentre = mapper.padCentre(pad);
-    float xRow = padCentre.X();
-
-    mGeo.setTPCrow(iRow, xRow, nPads, padWidth);
+  for (int iRow = 0; iRow < nRows; iRow++) {
+    mGeo.setTPCrow(iRow, geo.Row2X(iRow), geo.NPads(iRow), geo.PadWidth(iRow));
   }
 
   mGeo.finishConstruction();

From 980e4583859b431c0fbfa4849c6b338936e54305 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 11:37:35 +0200
Subject: [PATCH 1603/1764] GPU: Add workaround if fmt not available to
 GPUCommonLogger

---
 GPU/Common/GPUCommonLogger.h | 60 ++++++++++++++++++++++++++----------
 1 file changed, 44 insertions(+), 16 deletions(-)

diff --git a/GPU/Common/GPUCommonLogger.h b/GPU/Common/GPUCommonLogger.h
index a70710e9ae744..296cf9c562088 100644
--- a/GPU/Common/GPUCommonLogger.h
+++ b/GPU/Common/GPUCommonLogger.h
@@ -16,10 +16,13 @@
 #define GPUCOMMONFAIRLOGGER_H
 
 #include "GPUCommonDef.h"
+#ifndef GPUCA_GPUCODE_DEVICE
+#include <cstdio>
+#endif
 
-#if defined(GPUCA_GPUCODE_DEVICE)
-namespace o2::gpu::detail
+namespace o2::gpu::internal
 {
+#if defined(GPUCA_GPUCODE_DEVICE)
 struct DummyLogger {
   template <typename... Args>
   GPUd() DummyLogger& operator<<(Args... args)
@@ -27,16 +30,25 @@ struct DummyLogger {
     return *this;
   }
 };
-} // namespace o2::gpu::detail
+#else
+template <typename... Args>
+void LOGP_internal(const char* str, Args... args)
+{
+  printf("%s\n", str);
+}
 #endif
+} // namespace o2::gpu::internal
 
-#if defined(__OPENCL__) || (defined(GPUCA_GPUCODE_DEVICE) && !defined(GPUCA_GPU_DEBUG_PRINT))
-#define LOG(...) o2::gpu::detail::DummyLogger()
+#ifdef GPUCA_GPUCODE_DEVICE
+// ---------- begin GPUCA_GPUCODE_DEVICE ----------
+
+#if defined(__OPENCL__) || !defined(GPUCA_GPU_DEBUG_PRINT)
+#define LOG(...) o2::gpu::internal::DummyLogger()
 #define LOGF(...)
 #define LOGP(...)
 
-#elif defined(GPUCA_GPUCODE_DEVICE)
-#define LOG(...) o2::gpu::detail::DummyLogger()
+#else
+#define LOG(...) o2::gpu::internal::DummyLogger()
 // #define LOG(...) static_assert(false, "LOG(...) << ... unsupported in GPU code");
 #define LOGF(type, string, ...)         \
   {                                     \
@@ -44,23 +56,39 @@ struct DummyLogger {
   }
 #define LOGP(...)
 // #define LOGP(...) static_assert(false, "LOGP(...) unsupported in GPU code");
+#endif
 
+// ---------- end GPUCA_GPUCODE_DEVICE ----------
 #elif defined(GPUCA_STANDALONE) || defined(GPUCA_GPUCODE_COMPILEKERNELS) || defined(GPUCA_COMPILEKERNELS)
+// ---------- begin GPUCA_STANDALONE / COMPILEKERNELS ----------
+
 #include <iostream>
 #include <cstdio>
 #define LOG(type) std::cout
-#define LOGF(type, string, ...)         \
-  {                                     \
-    printf(string "\n", ##__VA_ARGS__); \
-  }
-#define LOGP(type, string, ...) \
-  {                             \
-    printf("%s\n", string);     \
-  }
+#define LOGF(type, string, ...) printf(string "\n", ##__VA_ARGS__);
+#if !defined(GPUCA_NO_FMT) && !defined(GPUCA_GPUCODE)
+#define LOGP(type, string, ...) fmt::print(string, ##__VA_ARGS__)
+#else
+#define LOGP(type, string, ...) o2::gpu::internal::LOGP_internal(string, ##__VA_ARGS__)
+#endif
+#if defined(GPUCA_STANDALONE) && !defined(GPUCA_GPUCODE)
+#if !defined(GPUCA_NO_FMT)
+#include <fmt/format.h>
+#else
+namespace fmt
+{
+template <typename... Args>
+static const char* format(Args... args)
+{
+  return "";
+}
+} // namespace fmt
+#endif
+#endif
 
+// ---------- end GPUCA_STANDALONE / COMPILEKERNELS ----------
 #else
 #include <Framework/Logger.h>
-
 #endif
 
 #endif

From a6000dbdec1f8afe40b6b460a299fc432d15b143 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 09:20:18 +0200
Subject: [PATCH 1604/1764] TPC: Make TPC calibration objects constructible
 from standalone benchmark

---
 .../include/MathUtils/detail/Bracket.h        |   6 +-
 .../DataFormatsTPC/CalibdEdxCorrection.h      |   4 +-
 .../Detectors/TPC/src/CalibdEdxCorrection.cxx |   6 +
 .../ReconstructionDataFormats/PrimaryVertex.h |   4 +-
 .../PrimaryVertexExt.h                        |   4 +-
 .../TrackParametrizationWithError.h           |   2 +-
 .../Reconstruction/src/PrimaryVertex.cxx      |   4 -
 .../Reconstruction/src/PrimaryVertexExt.cxx   |   4 -
 .../CommonDataFormat/InteractionRecord.h      |   2 +-
 DataFormats/common/src/InteractionRecord.cxx  |   4 -
 Detectors/Base/test/buildMatBudLUT.C          |   4 -
 Detectors/Base/test/testMatBudLUT.cxx         |   6 +-
 Detectors/TPC/base/include/TPCBase/Mapper.h   |   4 +
 Detectors/TPC/base/src/Mapper.cxx             |   2 +-
 .../TPCFastTransformHelperO2.h                |  12 +-
 .../src/TPCFastTransformHelperO2.cxx          |  19 ++--
 .../ITS3/macros/test/buildMatBudLUT.C         |   4 -
 .../DataTypes/CalibdEdxContainer.cxx          | 105 +++++++++---------
 .../DataTypes/CalibdEdxContainer.h            |   4 +-
 .../DataTypes/CalibdEdxTrackTopologyPol.cxx   |  68 ++++++------
 .../DataTypes/CalibdEdxTrackTopologyPol.h     |  10 +-
 .../DataTypes/TPCZSLinkMapping.cxx            |   6 +-
 GPU/GPUTracking/Standalone/CMakeLists.txt     |   1 +
 .../NDPiecewisePolynomials.h                  |  29 +++--
 .../TPCFastSpaceChargeCorrection.cxx          |  15 +--
 .../TPCFastTransformPOD.cxx                   |   5 +-
 GPU/Workflow/src/GPUWorkflowSpec.cxx          |   1 -
 GPU/Workflow/src/GPUWorkflowTPC.cxx           |   1 +
 28 files changed, 160 insertions(+), 176 deletions(-)

diff --git a/Common/MathUtils/include/MathUtils/detail/Bracket.h b/Common/MathUtils/include/MathUtils/detail/Bracket.h
index 25d0dbd1d0a6e..2da6949c4a6f8 100644
--- a/Common/MathUtils/include/MathUtils/detail/Bracket.h
+++ b/Common/MathUtils/include/MathUtils/detail/Bracket.h
@@ -17,7 +17,7 @@
 #define ALICEO2_BRACKET_H
 
 #include <GPUCommonRtypes.h>
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
 #include <string>
 #include <sstream>
 #endif
@@ -76,7 +76,7 @@ class Bracket
   Relation isOutside(T t, T tErr) const;
   Relation isOutside(T t) const;
 
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
   std::string asString() const;
 #endif
 
@@ -247,7 +247,7 @@ inline typename Bracket<T>::Relation Bracket<T>::isOutside(T t) const
   return t < mMin ? Below : (t > mMax ? Above : Inside);
 }
 
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
 template <typename T>
 std::string Bracket<T>::asString() const
 {
diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/CalibdEdxCorrection.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/CalibdEdxCorrection.h
index 024d6189593e9..f5088959edcf8 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/CalibdEdxCorrection.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/CalibdEdxCorrection.h
@@ -42,14 +42,12 @@ class CalibdEdxCorrection
   static constexpr int FitSize = 288; ///< Number of fitted corrections
   static constexpr int ParamSize = 8; ///< Number of params per fit
 
-#if !defined(GPUCA_ALIGPUCODE)
+#if !defined(GPUCA_GPUCODE)
   CalibdEdxCorrection()
   {
     clear();
   }
   CalibdEdxCorrection(std::string_view fileName) { loadFromFile(fileName); }
-#else
-  CalibdEdxCorrection() = default;
 #endif
   ~CalibdEdxCorrection() = default;
 
diff --git a/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx b/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx
index 152feacb41937..635b0e0817d6e 100644
--- a/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx
+++ b/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx
@@ -14,6 +14,7 @@
 #include <algorithm>
 #include <string_view>
 
+#ifndef GPUCA_STANDALONE
 // o2 includes
 #include "Framework/Logger.h"
 #include "DataFormatsTPC/Defs.h"
@@ -21,6 +22,7 @@
 
 // root includes
 #include "TFile.h"
+#endif
 
 using namespace o2::tpc;
 
@@ -37,6 +39,8 @@ void CalibdEdxCorrection::clear()
   mDims = -1;
 }
 
+#ifndef GPUCA_STANDALONE
+
 void CalibdEdxCorrection::writeToFile(std::string_view fileName, std::string_view objName) const
 {
   std::unique_ptr<TFile> file(TFile::Open(fileName.data(), "recreate"));
@@ -181,3 +185,5 @@ void CalibdEdxCorrection::setUnity()
   }
   mDims = 0;
 }
+
+#endif // GPUCA_STANDALONE
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/PrimaryVertex.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/PrimaryVertex.h
index 5343d26ec5ce5..62de31d335e80 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/PrimaryVertex.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/PrimaryVertex.h
@@ -42,7 +42,7 @@ class PrimaryVertex : public Vertex<TimeStampWithError<float, float>>
   float getZMAD() const { return mZMAD; }
   void setZMAD(float v) { mZMAD = v; }
 
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
   void print() const;
   std::string asString() const;
 #endif
@@ -56,7 +56,7 @@ class PrimaryVertex : public Vertex<TimeStampWithError<float, float>>
   ClassDefNV(PrimaryVertex, 2);
 };
 
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
 std::ostream& operator<<(std::ostream& os, const o2::dataformats::PrimaryVertex& v);
 #endif
 
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/PrimaryVertexExt.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/PrimaryVertexExt.h
index bf47ed03f3b39..a228984f2ae5d 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/PrimaryVertexExt.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/PrimaryVertexExt.h
@@ -36,7 +36,7 @@ struct PrimaryVertexExt : public PrimaryVertex {
   int getNSrcA(int i) const { return nSrcA[i]; }
   int getNSrcAU(int i) const { return nSrcAU[i]; }
 
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
   void print() const;
   std::string asString() const;
 #endif
@@ -44,7 +44,7 @@ struct PrimaryVertexExt : public PrimaryVertex {
   ClassDefNV(PrimaryVertexExt, 6);
 };
 
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
 std::ostream& operator<<(std::ostream& os, const o2::dataformats::PrimaryVertexExt& v);
 #endif
 
diff --git a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
index 7f7e1e33144b1..436dc42cff749 100644
--- a/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
+++ b/DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrizationWithError.h
@@ -83,7 +83,7 @@ class TrackParametrizationWithError : public TrackParametrization<value_T>
 
   GPUd() void print() const;
   GPUd() void printHexadecimal();
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
   bool toFwdTrackParCov(TrackParCovFwd& t) const;
   std::string asString() const;
   std::string asStringHexadecimal();
diff --git a/DataFormats/Reconstruction/src/PrimaryVertex.cxx b/DataFormats/Reconstruction/src/PrimaryVertex.cxx
index f1b1a8ff01181..f6f589fcb038a 100644
--- a/DataFormats/Reconstruction/src/PrimaryVertex.cxx
+++ b/DataFormats/Reconstruction/src/PrimaryVertex.cxx
@@ -19,8 +19,6 @@ namespace o2
 namespace dataformats
 {
 
-#ifndef GPUCA_ALIGPUCODE
-
 std::string PrimaryVertex::asString() const
 {
   auto str = o2::utils::Str::concat_string(VertexBase::asString(),
@@ -44,7 +42,5 @@ void PrimaryVertex::print() const
   std::cout << *this << std::endl;
 }
 
-#endif
-
 } // namespace dataformats
 } // namespace o2
diff --git a/DataFormats/Reconstruction/src/PrimaryVertexExt.cxx b/DataFormats/Reconstruction/src/PrimaryVertexExt.cxx
index 6065f04a3bc1a..31f0eff191591 100644
--- a/DataFormats/Reconstruction/src/PrimaryVertexExt.cxx
+++ b/DataFormats/Reconstruction/src/PrimaryVertexExt.cxx
@@ -18,8 +18,6 @@ namespace o2
 {
 namespace dataformats
 {
-
-#ifndef GPUCA_ALIGPUCODE
 using GTrackID = o2::dataformats::GlobalTrackID;
 
 std::string PrimaryVertexExt::asString() const
@@ -45,7 +43,5 @@ void PrimaryVertexExt::print() const
   std::cout << *this << std::endl;
 }
 
-#endif
-
 } // namespace dataformats
 } // namespace o2
diff --git a/DataFormats/common/include/CommonDataFormat/InteractionRecord.h b/DataFormats/common/include/CommonDataFormat/InteractionRecord.h
index e99f338a16343..c22b24ad03aac 100644
--- a/DataFormats/common/include/CommonDataFormat/InteractionRecord.h
+++ b/DataFormats/common/include/CommonDataFormat/InteractionRecord.h
@@ -15,7 +15,7 @@
 #define ALICEO2_INTERACTIONRECORD_H
 
 #include "GPUCommonRtypes.h"
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
 #include <iosfwd>
 #include <cstdint>
 #endif
diff --git a/DataFormats/common/src/InteractionRecord.cxx b/DataFormats/common/src/InteractionRecord.cxx
index f15c8c8e85328..213ed600e1c57 100644
--- a/DataFormats/common/src/InteractionRecord.cxx
+++ b/DataFormats/common/src/InteractionRecord.cxx
@@ -15,8 +15,6 @@
 namespace o2
 {
 
-#ifndef GPUCA_ALIGPUCODE
-
 std::string InteractionRecord::asString() const
 {
   return isDummy() ? std::string{"NotSet"} : fmt::format("BCid: {:4d} Orbit: {:6d}", bc, orbit);
@@ -49,6 +47,4 @@ void InteractionTimeRecord::print() const
   std::cout << (*this) << std::endl;
 }
 
-#endif
-
 } // namespace o2
diff --git a/Detectors/Base/test/buildMatBudLUT.C b/Detectors/Base/test/buildMatBudLUT.C
index 14f6d078aee90..860fcbd5da940 100644
--- a/Detectors/Base/test/buildMatBudLUT.C
+++ b/Detectors/Base/test/buildMatBudLUT.C
@@ -23,8 +23,6 @@
 #include <TStopwatch.h>
 #endif
 
-#ifndef GPUCA_ALIGPUCODE // this part is invisible on GPU version
-
 o2::base::MatLayerCylSet mbLUT;
 
 bool testMBLUT(const std::string& lutFile = "matbud.root");
@@ -399,5 +397,3 @@ void configLayers()
     lrData.emplace_back(LrData(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin));
   } while (lrData.back().rMax < 500);
 }
-
-#endif //!_COMPILED_ON_GPU_
diff --git a/Detectors/Base/test/testMatBudLUT.cxx b/Detectors/Base/test/testMatBudLUT.cxx
index 4daa992368dba..33c3498995c90 100644
--- a/Detectors/Base/test/testMatBudLUT.cxx
+++ b/Detectors/Base/test/testMatBudLUT.cxx
@@ -21,16 +21,12 @@ namespace o2
 {
 BOOST_AUTO_TEST_CASE(MatBudLUT)
 {
-#ifndef GPUCA_ALIGPUCODE // this part is unvisible on GPU version
-
   // using process specific geometry names in order
   // to avoid race/conditions with other tests accessing geometry
   std::string geomPrefix("matBudGeom");
   std::string matBudFile("matbud");
   matBudFile += std::to_string(getpid()) + ".root";
   BOOST_CHECK(buildMatBudLUT(2, 20, matBudFile, geomPrefix + std::to_string(getpid()), "align-geom.mDetectors=none")); // generate LUT
-  BOOST_CHECK(testMBLUT(matBudFile));                                                    // test LUT manipulations
-
-#endif //!GPUCA_ALIGPUCODE
+  BOOST_CHECK(testMBLUT(matBudFile));                                                                                  // test LUT manipulations
 }
 } // namespace o2
diff --git a/Detectors/TPC/base/include/TPCBase/Mapper.h b/Detectors/TPC/base/include/TPCBase/Mapper.h
index f2ff425675df6..6731637e2a08c 100644
--- a/Detectors/TPC/base/include/TPCBase/Mapper.h
+++ b/Detectors/TPC/base/include/TPCBase/Mapper.h
@@ -755,4 +755,8 @@ inline bool Mapper::isOutOfSector(GlobalPosition3D posEle, const Sector& sector,
 } // namespace tpc
 } // namespace o2
 
+#ifdef GPUCA_STANDALONE
+#error TPC Mapper must not be used for Run2 Data
+#endif
+
 #endif
diff --git a/Detectors/TPC/base/src/Mapper.cxx b/Detectors/TPC/base/src/Mapper.cxx
index 2796d488f014d..75db269ee85f4 100644
--- a/Detectors/TPC/base/src/Mapper.cxx
+++ b/Detectors/TPC/base/src/Mapper.cxx
@@ -17,7 +17,7 @@
 #include <cmath>
 
 #include "TPCBase/Mapper.h"
-#include "Framework/Logger.h"
+#include "GPUCommonLogger.h"
 
 namespace o2
 {
diff --git a/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h b/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
index aa042ab16b627..795e09eee42cf 100644
--- a/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
+++ b/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
@@ -22,7 +22,7 @@
 #define ALICEO2_TPC_TPCFASTTRANSFORMHELPERO2_H_
 
 #include "TPCFastTransformPOD.h"
-#include "Rtypes.h"
+#include "GPUCommonRtypes.h"
 
 namespace o2
 {
@@ -54,18 +54,18 @@ class TPCFastTransformHelperO2
   /// _______________  Main functionality  ________________________
 
   /// creates TPCFastTransform object
-  std::unique_ptr<TPCFastTransform> create(Long_t TimeStamp);
+  std::unique_ptr<TPCFastTransform> create(int64_t TimeStamp);
 
   /// creates TPCFastTransform object
-  std::unique_ptr<TPCFastTransform> create(Long_t TimeStamp, const TPCFastSpaceChargeCorrection& correction);
+  std::unique_ptr<TPCFastTransform> create(int64_t TimeStamp, const TPCFastSpaceChargeCorrection& correction);
 
   /// Updates the transformation with the new time stamp
-  int updateCalibration(TPCFastTransform& fastTransform, Long_t TimeStamp, float vDriftFactor = 1.f, float vDriftRef = 0.f, float driftTimeOffset = 0.f)
+  int updateCalibration(TPCFastTransform& fastTransform, int64_t TimeStamp, float vDriftFactor = 1.f, float vDriftRef = 0.f, float driftTimeOffset = 0.f)
   {
     return updateCalibrationImpl(fastTransform, TimeStamp, vDriftFactor, vDriftRef, driftTimeOffset);
   }
 
-  int updateCalibration(TPCFastTransformPOD& fastTransform, Long_t TimeStamp, float vDriftFactor = 1.f, float vDriftRef = 0.f, float driftTimeOffset = 0.f)
+  int updateCalibration(TPCFastTransformPOD& fastTransform, int64_t TimeStamp, float vDriftFactor = 1.f, float vDriftRef = 0.f, float driftTimeOffset = 0.f)
   {
     return updateCalibrationImpl(fastTransform, TimeStamp, vDriftFactor, vDriftRef, driftTimeOffset);
   }
@@ -81,7 +81,7 @@ class TPCFastTransformHelperO2
   void init();
 
   template <typename T>
-  int updateCalibrationImpl(T& transform, Long_t TimeStamp, float vDriftFactor, float vDriftRef, float driftTimeOffset);
+  int updateCalibrationImpl(T& transform, int64_t TimeStamp, float vDriftFactor, float vDriftRef, float driftTimeOffset);
 
   static TPCFastTransformHelperO2* sInstance; ///< singleton instance
   bool mIsInitialized = 0;                    ///< initialization flag
diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index f778bfda07cd6..8ae5cbc5fae4a 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -14,8 +14,10 @@
 
 #include "TPCReconstruction/TPCFastTransformHelperO2.h"
 
+#ifndef GPUCA_STANDALONE
 #include "TPCBase/Mapper.h"
 #include "TPCBase/PadRegionInfo.h"
+#endif
 #include "TPCBase/ParameterDetector.h"
 #include "TPCBase/ParameterElectronics.h"
 #include "TPCBase/ParameterGas.h"
@@ -61,13 +63,15 @@ void TPCFastTransformHelperO2::init()
 
   mGeo.finishConstruction();
 
+#ifndef GPUCA_STANDALONE
   // check if calculated pad geometry is consistent with the map
   testGeometry(mGeo);
+#endif
 
   mIsInitialized = 1;
 }
 
-std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(Long_t TimeStamp, const TPCFastSpaceChargeCorrection& correction)
+std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(int64_t TimeStamp, const TPCFastSpaceChargeCorrection& correction)
 {
   /// initializes TPCFastTransform object
 
@@ -99,10 +103,10 @@ std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(Long_t TimeSt
 
   updateCalibration(fastTransform, TimeStamp);
 
-  return std::move(fastTransformPtr);
+  return fastTransformPtr;
 }
 
-std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(Long_t TimeStamp)
+std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(int64_t TimeStamp)
 {
   /// initializes TPCFastTransform object
 
@@ -119,7 +123,7 @@ std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(Long_t TimeSt
 }
 
 template <typename T>
-int TPCFastTransformHelperO2::updateCalibrationImpl(T& fastTransform, Long_t TimeStamp, float vDriftFactor, float vDriftRef, float driftTimeOffset)
+int TPCFastTransformHelperO2::updateCalibrationImpl(T& fastTransform, int64_t TimeStamp, float vDriftFactor, float vDriftRef, float driftTimeOffset)
 {
   // Update the calibration with the new time stamp
   LOGP(debug, "Updating calibration: timestamp:{} vdriftFactor:{} vdriftRef:{}", TimeStamp, vDriftFactor, vDriftRef);
@@ -133,7 +137,6 @@ int TPCFastTransformHelperO2::updateCalibrationImpl(T& fastTransform, Long_t Tim
 
   // search for the calibration database ...
 
-  auto& gasParam = ParameterGas::Instance();
   auto& elParam = ParameterElectronics::Instance();
   // start the initialization
 
@@ -155,6 +158,7 @@ int TPCFastTransformHelperO2::updateCalibrationImpl(T& fastTransform, Long_t Tim
   return 0;
 }
 
+#ifndef GPUCA_STANDALONE
 void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) const
 {
   const Mapper& mapper = Mapper::instance();
@@ -210,9 +214,10 @@ void TPCFastTransformHelperO2::testGeometry(const TPCFastTransformGeo& geo) cons
                << " max Dx " << maxDx << " max Dy " << maxDy << std::endl;
   }
 }
+#endif
 
-template int TPCFastTransformHelperO2::updateCalibrationImpl(TPCFastTransform&, Long_t, float, float, float);
-template int TPCFastTransformHelperO2::updateCalibrationImpl(TPCFastTransformPOD&, Long_t, float, float, float);
+template int TPCFastTransformHelperO2::updateCalibrationImpl(TPCFastTransform&, int64_t, float, float, float);
+template int TPCFastTransformHelperO2::updateCalibrationImpl(TPCFastTransformPOD&, int64_t, float, float, float);
 
 } // namespace tpc
 } // namespace o2
diff --git a/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C b/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
index fa4f7e3910b99..4af1aa64a8ab2 100644
--- a/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
+++ b/Detectors/Upgrades/ITS3/macros/test/buildMatBudLUT.C
@@ -25,8 +25,6 @@
 #include <TStopwatch.h>
 #endif
 
-#ifndef GPUCA_ALIGPUCODE // this part is invisible on GPU version
-
 o2::base::MatLayerCylSet mbLUT;
 
 bool testMBLUT(const std::string& lutFile = "matbud.root");
@@ -405,5 +403,3 @@ void configLayers()
     lrData.emplace_back(lrData.back().rMax, lrData.back().rMax + drStep, zSpanH, zBin, rphiBin);
   } while (lrData.back().rMax < 500);
 }
-
-#endif //!_COMPILED_ON_GPU_
diff --git a/GPU/GPUTracking/DataTypes/CalibdEdxContainer.cxx b/GPU/GPUTracking/DataTypes/CalibdEdxContainer.cxx
index ba4b230e1f6f2..3f6a7b3257d26 100644
--- a/GPU/GPUTracking/DataTypes/CalibdEdxContainer.cxx
+++ b/GPU/GPUTracking/DataTypes/CalibdEdxContainer.cxx
@@ -12,18 +12,18 @@
 /// \file  CalibdEdxContainer.cxx
 /// \author Matthias Kleiner <mkleiner@ikf.uni-frankfurt.de>
 
-#if !defined(GPUCA_STANDALONE)
+#ifndef GPUCA_STANDALONE
 #include "TFile.h"
 #include "TPCBase/CalDet.h"
-#include "Framework/Logger.h"
-#include "clusterFinderDefs.h"
 #endif
+
+#include "GPUCommonLogger.h"
+#include "clusterFinderDefs.h"
 #include "CalibdEdxContainer.h"
 
 using namespace o2::gpu;
 using namespace o2::tpc;
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 void CalibdEdxContainer::cloneFromObject(const CalibdEdxContainer& obj, char* newFlatBufferPtr)
 {
   FlatObject::cloneFromObject(obj, newFlatBufferPtr);
@@ -49,7 +49,6 @@ void CalibdEdxContainer::subobjectCloneFromObject(Type*& obj, const Type* objOld
   memset((void*)obj, 0, sizeof(*obj));
   obj->cloneFromObject(*objOld, mFlatBufferPtr + sizeOfCalibdEdxTrackTopologyObj<Type>());
 }
-#endif
 
 void CalibdEdxContainer::moveBufferTo(char* newFlatBufferPtr)
 {
@@ -120,8 +119,6 @@ void CalibdEdxContainer::setFutureBufferAddress(Type*& obj, char* futureFlatBuff
   obj = FlatObject::relocatePointer(mFlatBufferPtr, futureFlatBufferPtr, obj);
 }
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
-
 float CalibdEdxContainer::getMinZeroSupresssionThreshold() const
 {
   if (mCalibTrackTopologyPol) {
@@ -144,16 +141,6 @@ float CalibdEdxContainer::getMaxZeroSupresssionThreshold() const
   }
 }
 
-void CalibdEdxContainer::loadPolTopologyCorrectionFromFile(std::string_view fileName)
-{
-  loadTopologyCorrectionFromFile(fileName, mCalibTrackTopologyPol);
-}
-
-void CalibdEdxContainer::loadSplineTopologyCorrectionFromFile(std::string_view fileName)
-{
-  loadTopologyCorrectionFromFile(fileName, mCalibTrackTopologySpline);
-}
-
 void CalibdEdxContainer::setPolTopologyCorrection(const CalibdEdxTrackTopologyPol& calibTrackTopology)
 {
   setTopologyCorrection(calibTrackTopology, mCalibTrackTopologyPol);
@@ -174,6 +161,45 @@ void CalibdEdxContainer::setSplineTopologyCorrection(const CalibdEdxTrackTopolog
   mCalibTrackTopologyPol = nullptr;
 }
 
+void CalibdEdxContainer::setDefaultZeroSupresssionThreshold()
+{
+  const float defaultVal = getMinZeroSupresssionThreshold() + (getMaxZeroSupresssionThreshold() - getMinZeroSupresssionThreshold()) / 2;
+  mThresholdMap.setMinCorrectionFactor(defaultVal - 0.1f);
+  mThresholdMap.setMaxCorrectionFactor(defaultVal + 0.1f);
+  for (int32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; ++sector) {
+    for (uint16_t globPad = 0; globPad < TPC_REAL_PADS_IN_SECTOR; ++globPad) {
+      mThresholdMap.setGainCorrection(sector, globPad, defaultVal);
+    }
+  }
+}
+
+template <class Type>
+void CalibdEdxContainer::setTopologyCorrection(const Type& calibTrackTopologyTmp, Type*& obj)
+{
+  FlatObject::startConstruction();
+
+  // get size of the flat buffer of the splines
+  const std::size_t flatbufferSize = calibTrackTopologyTmp.getFlatBufferSize();
+
+  // size of the dEdx container without taking flat buffer into account
+  const std::size_t objSize = sizeOfCalibdEdxTrackTopologyObj<Type>();
+
+  // create mFlatBuffer with correct size
+  const std::size_t totalSize = flatbufferSize + objSize;
+  FlatObject::finishConstruction(totalSize);
+
+  // setting member of CalibdEdxTrackTopologyPol to correct buffer address
+  obj = reinterpret_cast<Type*>(mFlatBufferPtr);
+
+  // deep copy of CalibdEdxTrackTopologyPol to buffer without moving the flat buffer to correct address
+  obj->cloneFromObject(calibTrackTopologyTmp, nullptr);
+
+  // seting the buffer of the splines to current buffer
+  obj->moveBufferTo(objSize + mFlatBufferPtr);
+}
+
+#ifndef GPUCA_STANDALONE
+
 void CalibdEdxContainer::loadZeroSupresssionThresholdFromFile(std::string_view fileName, std::string_view objName, const float minCorrectionFactor, const float maxCorrectionFactor)
 {
   TFile fInp(fileName.data(), "READ");
@@ -219,7 +245,7 @@ CalDet<float> CalibdEdxContainer::processThresholdMap(const CalDet<float>& thres
             for (int32_t padCl = padStart; padCl <= padEnd; ++padCl) {
               const int32_t globalPad = Mapper::getGlobalPadNumber(rowCl, padCl, region);
               // skip for current cluster position as the charge there is not effected from the thresold
-              if (padCl == pad && rowCl == lrow) {
+              if (padCl == (int32_t)pad && rowCl == lrow) {
                 continue;
               }
 
@@ -259,16 +285,14 @@ void CalibdEdxContainer::setGainMapResidual(const CalDet<float>& gainMapResidual
   mGainMapResidual = gainMapResTmp;
 }
 
-void CalibdEdxContainer::setDefaultZeroSupresssionThreshold()
+void CalibdEdxContainer::loadPolTopologyCorrectionFromFile(std::string_view fileName)
 {
-  const float defaultVal = getMinZeroSupresssionThreshold() + (getMaxZeroSupresssionThreshold() - getMinZeroSupresssionThreshold()) / 2;
-  mThresholdMap.setMinCorrectionFactor(defaultVal - 0.1f);
-  mThresholdMap.setMaxCorrectionFactor(defaultVal + 0.1f);
-  for (int32_t sector = 0; sector < o2::tpc::constants::MAXSECTOR; ++sector) {
-    for (uint16_t globPad = 0; globPad < TPC_REAL_PADS_IN_SECTOR; ++globPad) {
-      mThresholdMap.setGainCorrection(sector, globPad, defaultVal);
-    }
-  }
+  loadTopologyCorrectionFromFile(fileName, mCalibTrackTopologyPol);
+}
+
+void CalibdEdxContainer::loadSplineTopologyCorrectionFromFile(std::string_view fileName)
+{
+  loadTopologyCorrectionFromFile(fileName, mCalibTrackTopologySpline);
 }
 
 template <class Type>
@@ -279,29 +303,4 @@ void CalibdEdxContainer::loadTopologyCorrectionFromFile(std::string_view fileNam
   setTopologyCorrection(calibTrackTopologyTmp, obj);
 }
 
-template <class Type>
-void CalibdEdxContainer::setTopologyCorrection(const Type& calibTrackTopologyTmp, Type*& obj)
-{
-  FlatObject::startConstruction();
-
-  // get size of the flat buffer of the splines
-  const std::size_t flatbufferSize = calibTrackTopologyTmp.getFlatBufferSize();
-
-  // size of the dEdx container without taking flat buffer into account
-  const std::size_t objSize = sizeOfCalibdEdxTrackTopologyObj<Type>();
-
-  // create mFlatBuffer with correct size
-  const std::size_t totalSize = flatbufferSize + objSize;
-  FlatObject::finishConstruction(totalSize);
-
-  // setting member of CalibdEdxTrackTopologyPol to correct buffer address
-  obj = reinterpret_cast<Type*>(mFlatBufferPtr);
-
-  // deep copy of CalibdEdxTrackTopologyPol to buffer without moving the flat buffer to correct address
-  obj->cloneFromObject(calibTrackTopologyTmp, nullptr);
-
-  // seting the buffer of the splines to current buffer
-  obj->moveBufferTo(objSize + mFlatBufferPtr);
-}
-
-#endif
+#endif // GPUCA_STANDALONE
diff --git a/GPU/GPUTracking/DataTypes/CalibdEdxContainer.h b/GPU/GPUTracking/DataTypes/CalibdEdxContainer.h
index 33089ff301d06..4e7c47b25d86c 100644
--- a/GPU/GPUTracking/DataTypes/CalibdEdxContainer.h
+++ b/GPU/GPUTracking/DataTypes/CalibdEdxContainer.h
@@ -26,7 +26,7 @@
 #include "TPCPadGainCalib.h"
 #include "TPCPadBitMap.h"
 
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
 #include <string_view>
 #endif
 
@@ -159,7 +159,7 @@ class CalibdEdxContainer : public o2::gpu::FlatObject
   void setFutureBufferAddress(char* futureFlatBufferPtr);
   /// ================================================================================================
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_GPUCODE)
   // loading the polynomial track topology correction from a file
   /// \param fileName input file containing the correction
   void loadPolTopologyCorrectionFromFile(std::string_view fileName);
diff --git a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
index 1f6d6709e0ab0..527f775c68365 100644
--- a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
+++ b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
@@ -104,8 +104,6 @@ void CalibdEdxTrackTopologyPol::setFutureBufferAddress(char* futureFlatBufferPtr
   FlatObject::setFutureBufferAddress(futureFlatBufferPtr);
 }
 
-#if !defined(GPUCA_STANDALONE)
-
 void CalibdEdxTrackTopologyPol::construct()
 {
   FlatObject::startConstruction();
@@ -155,30 +153,6 @@ void CalibdEdxTrackTopologyPol::setDefaultPolynomials()
   construct();
 }
 
-void CalibdEdxTrackTopologyPol::writeToFile(TFile& outf, const char* name) const
-{
-  CalibdEdxTrackTopologyPolContainer cont;
-  cont.mCalibPols.reserve(FFits);
-
-  for (const auto& par : mCalibPolsqTot) {
-    cont.mCalibPols.emplace_back(par.getContainer());
-  }
-
-  for (const auto& par : mCalibPolsqMax) {
-    cont.mCalibPols.emplace_back(par.getContainer());
-  }
-
-  for (const auto par : mScalingFactorsqTot) {
-    cont.mScalingFactorsqTot.emplace_back(par);
-  }
-
-  for (const auto par : mScalingFactorsqMax) {
-    cont.mScalingFactorsqMax.emplace_back(par);
-  }
-
-  outf.WriteObject(&cont, name);
-}
-
 void CalibdEdxTrackTopologyPol::setFromContainer(const CalibdEdxTrackTopologyPolContainer& container)
 {
   if (2 * FFits != container.mCalibPols.size()) {
@@ -207,6 +181,39 @@ void CalibdEdxTrackTopologyPol::setFromContainer(const CalibdEdxTrackTopologyPol
   construct();
 }
 
+std::string CalibdEdxTrackTopologyPol::getPolyName(const int32_t region, const ChargeType charge)
+{
+  const std::string typeName[2] = {"qMax", "qTot"};
+  const std::string polname = fmt::format("polynomial_{}_region{}", typeName[charge], region).data();
+  return polname;
+}
+
+#ifndef GPUCA_STANDALONE
+
+void CalibdEdxTrackTopologyPol::writeToFile(TFile& outf, const char* name) const
+{
+  CalibdEdxTrackTopologyPolContainer cont;
+  cont.mCalibPols.reserve(FFits);
+
+  for (const auto& par : mCalibPolsqTot) {
+    cont.mCalibPols.emplace_back(par.getContainer());
+  }
+
+  for (const auto& par : mCalibPolsqMax) {
+    cont.mCalibPols.emplace_back(par.getContainer());
+  }
+
+  for (const auto par : mScalingFactorsqTot) {
+    cont.mScalingFactorsqTot.emplace_back(par);
+  }
+
+  for (const auto par : mScalingFactorsqMax) {
+    cont.mScalingFactorsqMax.emplace_back(par);
+  }
+
+  outf.WriteObject(&cont, name);
+}
+
 void CalibdEdxTrackTopologyPol::loadFromFile(const char* fileName, const char* name)
 {
   TFile inpf(fileName, "READ");
@@ -231,11 +238,4 @@ void CalibdEdxTrackTopologyPol::setPolynomialsFromFile(TFile& inpf)
   construct();
 }
 
-std::string CalibdEdxTrackTopologyPol::getPolyName(const int32_t region, const ChargeType charge)
-{
-  const std::string typeName[2] = {"qMax", "qTot"};
-  const std::string polname = fmt::format("polynomial_{}_region{}", typeName[charge], region).data();
-  return polname;
-}
-
-#endif
+#endif // GPUCA_STANDALONE
diff --git a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.h b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.h
index 0a3816f9ddbd2..939d3daf73b24 100644
--- a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.h
+++ b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.h
@@ -20,7 +20,7 @@
 #include "GPUCommonDef.h"
 #include "FlatObject.h"
 #include "DataFormatsTPC/Defs.h"
-#ifndef GPUCA_ALIGPUCODE
+#ifndef GPUCA_GPUCODE_DEVICE
 #include <string_view>
 #endif
 
@@ -127,7 +127,7 @@ class CalibdEdxTrackTopologyPol : public o2::gpu::FlatObject
   /// \param region region of the scaling factor
   GPUd() float getScalingFactorqMax(const int32_t region) const { return mScalingFactorsqMax[region]; };
 
-#if !defined(GPUCA_GPUCODE)
+#ifndef GPUCA_GPUCODE
   /// \return returns polynomial for qTot
   /// \param region region of the TPC
   const auto& getPolyqTot(const int32_t region) const { return mCalibPolsqTot[region]; }
@@ -136,7 +136,6 @@ class CalibdEdxTrackTopologyPol : public o2::gpu::FlatObject
   /// \param region region of the TPC
   const auto& getPolyqMax(const int32_t region) const { return mCalibPolsqMax[region]; }
 
-#ifndef GPUCA_STANDALONE
   /// set the the scaling factors for the polynomials for qTot
   /// \param factor scaling factor
   /// \param region region of the scaling factor
@@ -172,16 +171,13 @@ class CalibdEdxTrackTopologyPol : public o2::gpu::FlatObject
 
   /// setting a default topology correction which just returns 1
   void setDefaultPolynomials();
-#endif
 
   /// \return returns the name of the polynomial object which can be read in with the setPolynomialsFromFile() function
   /// \param region region of the TPC
   /// \param charge correction for maximum or total charge
   static std::string getPolyName(const int32_t region, const ChargeType charge);
-#endif
 
-/// ========== FlatObject functionality, see FlatObject class for description  =================
-#if !defined(GPUCA_GPUCODE)
+  /// ========== FlatObject functionality, see FlatObject class for description  =================
   /// cloning a container object (use newFlatBufferPtr=nullptr for simple copy)
   void cloneFromObject(const CalibdEdxTrackTopologyPol& obj, char* newFlatBufferPtr);
 
diff --git a/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx b/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
index e794ce82f8043..b8349b2cd137f 100644
--- a/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
+++ b/GPU/GPUTracking/DataTypes/TPCZSLinkMapping.cxx
@@ -13,7 +13,9 @@
 /// \author Felix Weiglhofer
 
 #include "TPCZSLinkMapping.h"
+#ifndef GPUCA_STANDALONE
 #include "TPCBase/Mapper.h"
+#endif
 
 #include <algorithm>
 #include <cassert>
@@ -22,8 +24,8 @@ using namespace o2::gpu;
 
 TPCZSLinkMapping::TPCZSLinkMapping(o2::tpc::Mapper& mapper)
 {
-#ifndef GPUCA_RUN2
-  const auto& fecToGlobalPad = mapper.getMapFECIDGlobalPad();
+#ifndef GPUCA_STANDALONE
+  const auto& fecToGlobalPad = mapper.getMapFECIDGlobalPad(); // TODO: Can we get this from TPUTPCGeometry?
   assert(fecToGlobalPad.size() == TPC_FEC_IDS_IN_SECTOR);
 
   const auto& globalPadToPadPos = mapper.getMapGlobalPadToPadPos();
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index a6f9147e39679..acbba2eb6f2c1 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -146,6 +146,7 @@ add_library(standalone_support SHARED
             ${O2_DIR}/Common/Field/src/MagFieldFast.cxx
             ${O2_DIR}/Common/Utils/src/StringUtils.cxx
             ${O2_DIR}/DataFormats/Detectors/TPC/src/CompressedClusters.cxx
+            ${O2_DIR}/DataFormats/Detectors/TPC/src/CalibdEdxCorrection.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrization.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx
             ${O2_DIR}/DataFormats/Reconstruction/src/Vertex.cxx
diff --git a/GPU/TPCFastTransformation/NDPiecewisePolynomials.h b/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
index 0d56b65aa89b8..8a629c64affbb 100644
--- a/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
+++ b/GPU/TPCFastTransformation/NDPiecewisePolynomials.h
@@ -170,10 +170,15 @@ class NDPiecewisePolynomials : public FlatObject
   /// \param n number of vertices: defines number of fits per dimension: nFits = n - 1. n should be at least 2 to perform one fit
   void init(const float min[/* Dim */], const float max[/* Dim */], const uint32_t n[/* Dim */]);
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+  /// setting default polynomials which just returns 1
+  void setDefault();
+
+#ifndef GPUCA_GPUCODE
   /// Setting directly the parameters of the polynomials
   void setParams(const float params[/* getNParameters() */]) { std::copy(params, params + getNParameters(), mParams); }
+#endif
 
+#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
   /// perform the polynomial fits on the grid
   /// \param func function which returns for every input x on the defined grid the true value
   /// \param nAuxiliaryPoints number of points which will be used for the fits (should be at least 2)
@@ -196,9 +201,6 @@ class NDPiecewisePolynomials : public FlatObject
   /// \param name name of the output object
   void writeToFile(TFile& outf, const char* name) const;
 
-  /// setting default polynomials which just returns 1
-  void setDefault();
-
   /// dump the polynomials to tree for visualisation
   /// \param nSamplingPoints number of sampling points per dimension
   /// \param outName name of the output file
@@ -206,16 +208,19 @@ class NDPiecewisePolynomials : public FlatObject
   /// \param recreateFile create new output file or update the output file
   void dumpToTree(const uint32_t nSamplingPoints[/* Dim */], const char* outName = "debug.root", const char* treeName = "tree", const bool recreateFile = true) const;
 
+#endif // !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#ifndef GPUCA_GPUCODE
+
+  /// set the parameters from NDPiecewisePolynomialContainer
+  /// \param container container for the parameters
+  void setFromContainer(const NDPiecewisePolynomialContainer& container);
+
   /// \return returns total number of polynomial fits
   uint32_t getNPolynomials() const;
 
   /// converts the class to a container which can be written to a root file
   NDPiecewisePolynomialContainer getContainer() const { return NDPiecewisePolynomialContainer{Dim, Degree, getNParameters(), mParams, InteractionOnly, mMin, mMax, mN}; }
-
-  /// set the parameters from NDPiecewisePolynomialContainer
-  /// \param container container for the parameters
-  void setFromContainer(const NDPiecewisePolynomialContainer& container);
-#endif // !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#endif
 
   /// \return returns the total number of stored parameters
   uint32_t getNParameters() const { return getNPolynomials() * MultivariatePolynomialParametersHelper::getNParameters<Degree, Dim, InteractionOnly>(); }
@@ -283,6 +288,7 @@ class NDPiecewisePolynomials : public FlatObject
   /// \param xCords buffer for x-coordinates
   /// \param response buffer for y-coordinates
   void fitInnerGrid(const std::function<double(const double x[/* Dim */])>& func, const uint32_t nAuxiliaryPoints[/* Dim */], const int32_t currentIndex[/* Dim */], TLinearFitter& fitter, std::vector<double>& xCords, std::vector<double>& response);
+#endif
 
   /// heler function to loop over all dimensions
   void checkPos(const uint32_t iMax[/* Dim */], int32_t pos[/* Dim */]) const;
@@ -296,7 +302,6 @@ class NDPiecewisePolynomials : public FlatObject
   /// \param ix index
   /// \param dim dimension
   double getVertexPosition(const uint32_t ix, const int32_t dim) const { return ix / static_cast<double>(mInvSpacing[dim]) + mMin[dim]; }
-#endif // !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 
 #if !defined(GPUCA_GPUCODE)
   /// \return returns the size of the parameters
@@ -313,7 +318,7 @@ class NDPiecewisePolynomials : public FlatObject
 //============================ inline implementations =============================
 //=================================================================================
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_GPUCODE)
 template <uint32_t Dim, uint32_t Degree, bool InteractionOnly>
 void NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::setFromContainer(const NDPiecewisePolynomialContainer& container)
 {
@@ -340,7 +345,7 @@ void NDPiecewisePolynomials<Dim, Degree, InteractionOnly>::setDefault()
   const auto nPols = getNPolynomials();
   std::vector<float> params(nParamsPerPol);
   params.front() = 1;
-  for (auto i = 0; i < nPols; ++i) {
+  for (unsigned int i = 0; i < nPols; ++i) {
     std::copy(params.begin(), params.end(), &mParams[i * nParamsPerPol]);
   }
 }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 5f5943a00372e..49305e3ed7909 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -17,12 +17,11 @@
 #include "TPCFastSpaceChargeCorrection.h"
 #include "GPUCommonLogger.h"
 
-#if !defined(GPUCA_GPUCODE)
 #include <iostream>
 #include <string>
 #include <cmath>
+#include <sstream>
 #include "Spline2DHelper.h"
-#endif
 
 using namespace o2::gpu;
 
@@ -48,10 +47,8 @@ TPCFastSpaceChargeCorrection::~TPCFastSpaceChargeCorrection()
 
 void TPCFastSpaceChargeCorrection::releaseConstructionMemory()
 {
-// release temporary arrays
-#if !defined(GPUCA_GPUCODE)
+  // release temporary arrays
   delete[] mConstructionScenarios;
-#endif
   mConstructionScenarios = nullptr;
 }
 
@@ -474,8 +471,6 @@ void TPCFastSpaceChargeCorrection::print() const
   }
 }
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
-
 void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo& geo, int32_t numberOfSplineScenarios)
 {
   /// Starts the construction procedure, reserves temporary memory
@@ -489,9 +484,7 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
 
   releaseConstructionMemory();
 
-#if !defined(GPUCA_GPUCODE)
   mConstructionScenarios = new SplineType[mNumberOfScenarios];
-#endif
 
   assert(mConstructionScenarios != nullptr);
 
@@ -558,7 +551,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 
   for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
     for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
-      SectorRowInfo& row = getSectorRowInfo(i, j);
+      [[maybe_unused]] SectorRowInfo& row = getSectorRowInfo(i, j);
       assert(row.splineScenarioID >= 0);
       assert(row.splineScenarioID < mNumberOfScenarios);
     }
@@ -782,5 +775,3 @@ double TPCFastSpaceChargeCorrection::testInverse(bool prn)
 
   return maxD.V;
 }
-
-#endif // GPUCA_GPUCODE
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index e22c47f1337e7..ab0c7c2be82ed 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -19,14 +19,13 @@
 #endif
 #include "TPCFastTransformPOD.h"
 #include "GPUDebugStreamer.h"
+#include "GPUCommonLogger.h"
 
 namespace o2
 {
 namespace gpu
 {
 
-#if !defined(GPUCA_NO_ROOT) && !defined(GPUCA_NO_FMT) && !defined(GPUCA_STANDALONE) && !defined(GPUCA_GPUCODE)
-
 /// Create POD transform from old flat-buffer one. Provided vector will serve as a buffer
 TPCFastTransformPOD* TPCFastTransformPOD::create(aligned_unique_buffer_ptr<TPCFastTransformPOD>& destVector, const TPCFastTransform& src)
 {
@@ -219,6 +218,8 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
   return podMap;
 }
 
+#ifndef GPUCA_STANDALONE
+
 bool TPCFastTransformPOD::test(const TPCFastSpaceChargeCorrection& origCorr, int npoints) const
 {
   if (npoints < 1) {
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 7a96a48e5a994..95752c486eae1 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -250,7 +250,6 @@ void GPURecoWorkflowSpec::init(InitContext& ic)
     // initialize TPC calib objects
     initFunctionTPCCalib(ic);
 
-    mConfig->configCalib.fastTransform = mCalibObjects.mFastTransformBuffer.get();
     // mConfig->configCalib.buffer = mCalibObjects.mBuffer; // TODO WRONG
     if (mConfig->configCalib.fastTransform == nullptr) {
       throw std::invalid_argument("GPU workflow: initialization of the TPC transformation failed");
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index db1f55620a279..d92942c5ed2f5 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -105,6 +105,7 @@ void GPURecoWorkflowSpec::initFunctionTPCCalib(InitContext& ic)
   mTPCVDriftHelper.reset(new o2::tpc::VDriftHelper());
 
   gpu::TPCFastTransformPOD::create(mCalibObjects.mFastTransformBuffer, *o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
+  mConfig->configCalib.fastTransform = mCalibObjects.mFastTransformBuffer.get();
 
   if (mConfParam->dEdxDisableTopologyPol) {
     LOGP(info, "Disabling loading of track topology correction using polynomials from CCDB");

From 7fdbed4ac614f6fa45b89ad1b1f8bad86a63a99c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 14:01:53 +0200
Subject: [PATCH 1605/1764] GPU Standalone: Add recreateTrivialCalibObjects
 option

---
 .../TPCFastTransformHelperO2.h                |  1 -
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  1 +
 .../Standalone/Benchmark/CMakeLists.txt       |  5 ++-
 .../Standalone/Benchmark/standalone.cxx       | 38 ++++++++++++++++++-
 GPU/GPUTracking/Standalone/CMakeLists.txt     | 12 +++++-
 GPU/TPCFastTransformation/CMakeLists.txt      |  1 +
 6 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h b/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
index 795e09eee42cf..943521e3b11ec 100644
--- a/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
+++ b/Detectors/TPC/reconstruction/include/TPCReconstruction/TPCFastTransformHelperO2.h
@@ -69,7 +69,6 @@ class TPCFastTransformHelperO2
   {
     return updateCalibrationImpl(fastTransform, TimeStamp, vDriftFactor, vDriftRef, driftTimeOffset);
   }
-
   /// _______________  Utilities   ________________________
 
   const TPCFastTransformGeo& getGeometry() { return mGeo; }
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index e693f5e1814b7..20e445264797c 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -638,6 +638,7 @@ AddOption(runCompression, int32_t, 1, "", 0, "Enable TPC Compression")
 AddOption(runTransformation, int32_t, 1, "", 0, "Enable TPC Transformation")
 AddOption(runRefit, bool, false, "", 0, "Enable final track refit")
 AddOption(setO2Settings, bool, false, "", 0, "Set O2 defaults for output of shared cluster map, referenceX")
+AddOption(recreateTrivialCalibObjects, bool, false, "", 0, "Recreate trivial calibration objects (TPCTransform, dEdxCorrection) from scratch")
 AddHelp("help", 'h')
 AddHelpAll("helpall", 'H')
 AddSubConfig(GPUSettingsRec, rec)
diff --git a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
index 9f28fd8cc6fe9..3e453b21b8104 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
@@ -20,14 +20,15 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
     o2_add_executable(standalone-benchmark
                       COMPONENT_NAME gpu
                       TARGETVARNAME targetName
-                      PUBLIC_LINK_LIBRARIES O2::GPUO2Interface O2::GPUTracking
+                      PUBLIC_LINK_LIBRARIES O2::GPUO2Interface O2::GPUTracking O2::TPCReconstruction
                       SOURCES ${SRCS})
 endif()
 
 if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
     add_executable(ca ${SRCS})
     set(targetName ca)
-    target_link_libraries(${targetName} PUBLIC GPUTracking)
+    target_link_libraries(${targetName} PUBLIC GPUTracking standalone_support2)
+    install(TARGETS ca)
 endif()
 
 install(DIRECTORY ../tools DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU)
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index a882473cff92f..114889fddca33 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -24,7 +24,6 @@
 #include "display/GPUDisplayInterface.h"
 #include "genEvents.h"
 
-#include "TPCFastTransformPOD.h"
 #include "GPUTPCGMMergedTrack.h"
 #include "GPUSettings.h"
 #include "GPUConstantMem.h"
@@ -32,6 +31,13 @@
 #include "GPUO2DataTypes.h"
 #include "GPUChainITS.h"
 
+// For creating default objects
+#include "TPCReconstruction/TPCFastTransformHelperO2.h"
+#include "CalibdEdxContainer.h"
+#include "TPCFastTransformPOD.h"
+#include "GPUTRDRecoParam.h"
+#include "TPCZSLinkMapping.h"
+
 #include "DataFormatsTPC/CompressedClusters.h"
 
 #include <iostream>
@@ -286,6 +292,31 @@ int32_t ReadConfiguration(int argc, char** argv)
   return (0);
 }
 
+void CreateTrivialCalibObjects()
+{
+  GPUCalibObjectsConst calib;
+
+  aligned_unique_buffer_ptr<TPCFastTransformPOD> tmpFastTransformBuffer;
+  TPCFastTransformPOD::create(tmpFastTransformBuffer, *o2::tpc::TPCFastTransformHelperO2::instance()->create(0));
+  calib.fastTransform = tmpFastTransformBuffer.get();
+  auto tmpTRDGeometry = std::make_unique<o2::trd::GeometryFlat>();
+  calib.trdGeometry = tmpTRDGeometry.get();
+  auto tmpTRDRecoParam = std::make_unique<GPUTRDRecoParam>();
+  calib.trdRecoParam = tmpTRDRecoParam.get();
+  auto tmpdEdxCalibContainer = std::make_unique<o2::tpc::CalibdEdxContainer>();
+  tmpdEdxCalibContainer->setDefaultZeroSupresssionThreshold();
+  tmpdEdxCalibContainer->setDefaultPolTopologyCorrection();
+  calib.dEdxCalibContainer = tmpdEdxCalibContainer.get();
+  auto tmpTPCPadGainCalib = std::make_unique<TPCPadGainCalib>();
+  calib.tpcPadGain = tmpTPCPadGainCalib.get();
+  auto tmpTPCZSLinkMapping = std::make_unique<TPCZSLinkMapping>();
+  calib.tpcZSLinkMapping = tmpTPCZSLinkMapping.get();
+
+  chainTracking->SetCalibObjects(calib);
+  rec->DumpSettings("./");
+  printf("Wrote trivial calibration objects to current folder\n");
+}
+
 int32_t SetupReconstruction()
 {
   if (!configStandalone.eventGenerator) {
@@ -770,6 +801,11 @@ int32_t main(int argc, char** argv)
     }
   }
 
+  if (configStandalone.recreateTrivialCalibObjects) {
+    CreateTrivialCalibObjects();
+    return 0;
+  }
+
   if (SetupReconstruction()) {
     return 1;
   }
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index acbba2eb6f2c1..682ca914b6097 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -159,6 +159,9 @@ add_library(standalone_support SHARED
             ${O2_DIR}/Detectors/Base/src/Ray.cxx
             ${O2_DIR}/Detectors/Base/src/Propagator.cxx)
 
+add_library(standalone_support2 SHARED
+            ${O2_DIR}/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx)
+
 target_compile_definitions(standalone_support PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 target_include_directories(standalone_support PUBLIC $<TARGET_PROPERTY:O2::GPUTracking,INCLUDE_DIRECTORIES>)
 
@@ -196,8 +199,11 @@ target_include_directories(standalone_support PUBLIC
                            ${O2_DIR}/Detectors/TRD/base/include
                            ${O2_DIR}/Detectors/TRD/base/src
                            ${O2_DIR}/Framework/Foundation/3rdparty/include)
+target_include_directories(standalone_support2 PUBLIC
+                           ${O2_DIR}/Detectors/TPC/reconstruction/include)
+
 
-target_link_libraries(standalone_support PUBLIC#
+target_link_libraries(standalone_support PUBLIC
                       dl
                       pthread
                       Microsoft.GSL::GSL)
@@ -205,6 +211,8 @@ target_link_libraries(standalone_support PUBLIC#
 target_link_libraries(GPUTracking PUBLIC standalone_support)
 target_link_libraries(TPCFastTransformation PUBLIC standalone_support)
 
+target_link_libraries(standalone_support2 PUBLIC GPUTracking TPCFastTransformation standalone_support)
+
 if(NOT GPUCA_CONFIG_O2)
   target_compile_definitions(GPUTracking PRIVATE GPUCA_RUN2)
 endif()
@@ -243,7 +251,7 @@ if (GPUCA_BUILD_DEBUG_SANITIZE AND CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
 endif()
 
 # Installation
-install(TARGETS ca TPCFastTransformation standalone_support)
+install(TARGETS standalone_support standalone_support2)
 install(FILES "cmake/makefile" DESTINATION "${CMAKE_INSTALL_PREFIX}")
 install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${O2_DIR} ${CMAKE_INSTALL_PREFIX}/src)")
 install(CODE "execute_process(COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_BINARY_DIR}/config.cmake ${CMAKE_INSTALL_PREFIX}/config.cmake)")
diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index df33fdeb62354..0d9d9a866162a 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -123,6 +123,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   add_library(${MODULE} SHARED ${SRCS})
   set(targetName ${MODULE})
   target_include_directories(${targetName} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+  install(TARGETS TPCFastTransformation)
 endif()
 
 install(FILES ${HDRS_CINT_O2} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)

From 8cdbc9af8621f518139b85e89d89f7a4af4d0a1c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 14:28:05 +0200
Subject: [PATCH 1606/1764] Remove unnecessary GPUCA_GPUCODE protection in
 non-GPU code

---
 Common/Field/src/MagFieldFast.cxx              |  2 --
 Common/Utils/src/DebugStreamer.cxx             |  4 +---
 DataFormats/Detectors/TRD/src/Tracklet64.cxx   |  3 ---
 DataFormats/Reconstruction/src/DCA.cxx         |  4 ----
 DataFormats/Reconstruction/src/Vertex.cxx      |  5 -----
 Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx  |  4 ----
 .../calibration/src/CorrectionMapsOptions.cxx  |  4 ----
 .../DataTypes/CalibdEdxTrackTopologyPol.cxx    |  2 +-
 .../DataTypes/GPUTPCGMPolynomialField.cxx      | 11 -----------
 GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx      |  2 +-
 GPU/TPCFastTransformation/CMakeLists.txt       |  8 ++++----
 GPU/TPCFastTransformation/ChebyshevFit1D.cxx   |  2 +-
 .../MultivariatePolynomialHelper.cxx           | 11 -----------
 GPU/TPCFastTransformation/Spline.cxx           |  2 +-
 GPU/TPCFastTransformation/Spline1D.cxx         |  4 ++--
 .../Spline1DHelperOld.cxx                      |  4 ----
 GPU/TPCFastTransformation/Spline1DSpec.cxx     | 17 ++++-------------
 GPU/TPCFastTransformation/Spline2D.cxx         |  2 +-
 GPU/TPCFastTransformation/Spline2DSpec.cxx     | 14 ++++----------
 GPU/TPCFastTransformation/SplineHelper.cxx     |  2 +-
 GPU/TPCFastTransformation/SplineSpec.cxx       | 14 ++++----------
 GPU/TPCFastTransformation/TPCFastTransform.cxx | 18 ++++++------------
 .../TPCFastTransformGeo.cxx                    |  8 +-------
 .../devtools/IrregularSpline1D.cxx             |  4 ----
 .../devtools/IrregularSpline2D3D.cxx           |  4 ----
 25 files changed, 32 insertions(+), 123 deletions(-)

diff --git a/Common/Field/src/MagFieldFast.cxx b/Common/Field/src/MagFieldFast.cxx
index 02ef9c153d189..9735d0c711fa3 100644
--- a/Common/Field/src/MagFieldFast.cxx
+++ b/Common/Field/src/MagFieldFast.cxx
@@ -16,12 +16,10 @@
 #include "Field/MagFieldFast.h"
 #include <GPUCommonLogger.h>
 
-#ifndef GPUCA_GPUCODE_DEVICE
 #include <cmath>
 #include <fstream>
 #include <sstream>
 using namespace std;
-#endif
 
 using namespace o2::field;
 
diff --git a/Common/Utils/src/DebugStreamer.cxx b/Common/Utils/src/DebugStreamer.cxx
index 46ff9be83d415..3a5401ca9b382 100644
--- a/Common/Utils/src/DebugStreamer.cxx
+++ b/Common/Utils/src/DebugStreamer.cxx
@@ -10,18 +10,16 @@
 // or submit itself to any jurisdiction.
 
 #include "CommonUtils/DebugStreamer.h"
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 #include <thread>
 #include <fmt/format.h>
 #include "TROOT.h"
 #include "TKey.h"
 #include <random>
 #include "Framework/Logger.h"
-#endif
 
 O2ParamImpl(o2::utils::ParameterDebugStreamer);
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) && defined(DEBUG_STREAMER)
+#if defined(DEBUG_STREAMER)
 
 o2::utils::DebugStreamer::DebugStreamer()
 {
diff --git a/DataFormats/Detectors/TRD/src/Tracklet64.cxx b/DataFormats/Detectors/TRD/src/Tracklet64.cxx
index d7b63cae45354..0458dad92e678 100644
--- a/DataFormats/Detectors/TRD/src/Tracklet64.cxx
+++ b/DataFormats/Detectors/TRD/src/Tracklet64.cxx
@@ -25,7 +25,6 @@ void Tracklet64::print() const
        HelperMethods::getSector(getDetector()), HelperMethods::getStack(getDetector()), HelperMethods::getLayer(getDetector()), getROB(), getMCM(), getPadRow(), getPadCol(), getPosition(), getSlope(), getPID(), getQ0(), getQ1(), getQ2(), getFormat());
 }
 
-#ifndef GPUCA_GPUCODE_DEVICE
 void Tracklet64::printStream(std::ostream& stream) const
 {
   stream << "Tracklet64 : 0x" << std::hex << getTrackletWord();
@@ -50,7 +49,5 @@ bool operator<(const Tracklet64& lhs, const Tracklet64& rhs)
          (lhs.getDetector() == rhs.getDetector() && lhs.getROB() == rhs.getROB() && lhs.getMCM() == rhs.getMCM() && lhs.getPadRow() == rhs.getPadRow() && lhs.getPadCol() < rhs.getPadCol());
 }
 
-#endif // GPUCA_GPUCODE_DEVICE
-
 } // namespace trd
 } // namespace o2
diff --git a/DataFormats/Reconstruction/src/DCA.cxx b/DataFormats/Reconstruction/src/DCA.cxx
index 9bb324c8df3a9..dd7c959add253 100644
--- a/DataFormats/Reconstruction/src/DCA.cxx
+++ b/DataFormats/Reconstruction/src/DCA.cxx
@@ -20,20 +20,16 @@ namespace o2
 namespace dataformats
 {
 
-#ifndef GPUCA_GPUCODE_DEVICE
 std::ostream& operator<<(std::ostream& os, const o2::dataformats::DCA& d)
 {
   // stream itself
   os << "DCA YZ {" << d.getY() << ", " << d.getZ() << "} Cov {" << d.getSigmaY2() << ", " << d.getSigmaYZ() << ", " << d.getSigmaZ2() << "}";
   return os;
 }
-#endif
 
 void DCA::print() const
 {
-#ifndef GPUCA_GPUCODE_DEVICE
   std::cout << *this << '\n';
-#endif
 }
 
 } // namespace dataformats
diff --git a/DataFormats/Reconstruction/src/Vertex.cxx b/DataFormats/Reconstruction/src/Vertex.cxx
index 85145683ddd97..9294aeb655803 100644
--- a/DataFormats/Reconstruction/src/Vertex.cxx
+++ b/DataFormats/Reconstruction/src/Vertex.cxx
@@ -20,8 +20,6 @@ namespace o2
 namespace dataformats
 {
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#ifndef GPUCA_NO_FMT
 std::string VertexBase::asString() const
 {
   return fmt::format("Vtx {{{:+.4e},{:+.4e},{:+.4e}}} Cov.:{{{{{:.3e}..}},{{{:.3e},{:.3e}..}},{{{:.3e},{:.3e},{:.3e}}}}}",
@@ -39,7 +37,6 @@ void VertexBase::print() const
 {
   std::cout << *this << std::endl;
 }
-#endif
 
 bool VertexBase::operator==(const VertexBase& other) const
 {
@@ -54,8 +51,6 @@ bool VertexBase::operator==(const VertexBase& other) const
   return true;
 }
 
-#endif
-
 template class o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 template class o2::dataformats::Vertex<o2::dataformats::TimeStampWithError<float, float>>;
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
index c4d288bd61777..8c01fb25c545e 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Cluster.cxx
@@ -69,9 +69,7 @@ Cluster::Cluster(const int layerIndex, const float3& primaryVertex, const IndexT
 
 GPUhd() void Cluster::print() const
 {
-#if !defined(GPUCA_GPUCODE_DEVICE) || (!defined(__OPENCL__) && defined(GPUCA_GPU_DEBUG_PRINT))
   printf("Cluster: %f %f %f %f %f %d %d\n", xCoordinate, yCoordinate, zCoordinate, phi, radius, clusterId, indexTableBinIndex);
-#endif
 }
 
 TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float alpha, std::array<float, 2>&& posTF,
@@ -83,10 +81,8 @@ TrackingFrameInfo::TrackingFrameInfo(float x, float y, float z, float xTF, float
 
 GPUhd() void TrackingFrameInfo::print() const
 {
-#if !defined(GPUCA_GPUCODE_DEVICE) || (!defined(__OPENCL__) && defined(GPUCA_GPU_DEBUG_PRINT))
   printf("x: %f y: %f z: %f xTF: %f alphaTF: %f posTF: %f %f covTF: %f %f %f\n",
          xCoordinate, yCoordinate, zCoordinate, xTrackingFrame, alphaTrackingFrame,
          positionTrackingFrame[0], positionTrackingFrame[1],
          covarianceTrackingFrame[0], covarianceTrackingFrame[1], covarianceTrackingFrame[2]);
-#endif
 }
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx b/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
index de7e587ba95eb..604b7c680385b 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
@@ -16,8 +16,6 @@
 using namespace o2::tpc;
 using namespace o2::framework;
 
-#ifndef GPUCA_GPUCODE_DEVICE
-
 //________________________________________________________
 CorrectionMapsGloOpts CorrectionMapsOptions::parseGlobalOptions(const o2::framework::ConfigParamRegistry& opts)
 {
@@ -59,5 +57,3 @@ void CorrectionMapsOptions::addOption(std::vector<ConfigParamSpec>& options, Con
     options.emplace_back(osp);
   }
 }
-
-#endif // #ifndef GPUCA_GPUCODE_DEVICE
diff --git a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
index 527f775c68365..dd61598f2de7e 100644
--- a/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
+++ b/GPU/GPUTracking/DataTypes/CalibdEdxTrackTopologyPol.cxx
@@ -20,7 +20,7 @@
 
 using namespace o2::tpc;
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
 #include "NDPiecewisePolynomials.inc"
 void CalibdEdxTrackTopologyPol::dumpToTree(const uint32_t nSamplingPoints[/* Dim */], const char* outName) const
 {
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGMPolynomialField.cxx b/GPU/GPUTracking/DataTypes/GPUTPCGMPolynomialField.cxx
index f26d7c5e0c45d..d29d310d5f04c 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGMPolynomialField.cxx
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGMPolynomialField.cxx
@@ -15,8 +15,6 @@
 #include "GPUTPCGMPolynomialField.h"
 using namespace o2::gpu;
 
-#if !defined(GPUCA_GPUCODE)
-
 #include "GPUCommonConstants.h"
 #include <iostream>
 #include <iomanip>
@@ -129,12 +127,3 @@ void GPUTPCGMPolynomialField::Print() const
     }
   }
 }
-
-#else
-
-void GPUTPCGMPolynomialField::Print() const
-{
-  // do nothing
-}
-
-#endif
diff --git a/GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx b/GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx
index 7155b783e725e..5c93fcfa0e6c1 100644
--- a/GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx
+++ b/GPU/GPUTracking/Debug/GPUROOTDumpCore.cxx
@@ -14,7 +14,7 @@
 
 #include "GPUROOTDumpCore.h"
 
-#if (!defined(GPUCA_STANDALONE) || defined(GPUCA_BUILD_QA)) && !defined(GPUCA_GPUCODE)
+#if (!defined(GPUCA_STANDALONE) || defined(GPUCA_BUILD_QA))
 #include <atomic>
 #include <memory>
 #include <TFile.h>
diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index 0d9d9a866162a..a270ba3050925 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -14,25 +14,25 @@ set(MODULE TPCFastTransformation)
 set(SRCS
     SplineSpec.cxx
     Spline.cxx
-    SplineHelper.cxx
     Spline1DSpec.cxx
     Spline1D.cxx
-    Spline1DHelperOld.cxx
     Spline2DSpec.cxx
     Spline2D.cxx
-    ChebyshevFit1D.cxx
     TPCFastTransformGeo.cxx
     TPCFastSpaceChargeCorrection.cxx
     TPCFastSpaceChargeCorrectionMap.cxx
     TPCFastTransform.cxx
-    CorrectionMapsHelper.cxx
     TPCFastTransformPOD.cxx
 )
 
 if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   set(SRCS ${SRCS}
+      CorrectionMapsHelper.cxx
+      ChebyshevFit1D.cxx
+      SplineHelper.cxx
       Spline1DHelper.cxx
       Spline2DHelper.cxx
+      Spline1DHelperOld.cxx
       SymMatrixSolver.cxx
       BandMatrixSolver.cxx
       MultivariatePolynomial.cxx
diff --git a/GPU/TPCFastTransformation/ChebyshevFit1D.cxx b/GPU/TPCFastTransformation/ChebyshevFit1D.cxx
index 3edd8f8f22e55..aeab00e7f86b2 100644
--- a/GPU/TPCFastTransformation/ChebyshevFit1D.cxx
+++ b/GPU/TPCFastTransformation/ChebyshevFit1D.cxx
@@ -14,7 +14,7 @@
 ///
 /// \author  Sergey Gorbunov <sergey.gorbunov@cern.ch>
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
 
 #include "ChebyshevFit1D.h"
 #include "GPUCommonLogger.h"
diff --git a/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx b/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx
index 6a17377ae5d01..d7bd6ff8bc90c 100644
--- a/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx
+++ b/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx
@@ -15,19 +15,14 @@
 #include "MultivariatePolynomialHelper.h"
 #include "GPUCommonLogger.h"
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 #include "TLinearFitter.h"
 #include <algorithm>
-#endif
 
 using namespace o2::gpu;
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
 void MultivariatePolynomialHelper<0, 0, false>::print() const
 {
-#ifndef GPUCA_NO_FMT
   LOGP(info, fmt::runtime(getFormula().c_str()));
-#endif
 }
 
 std::string MultivariatePolynomialHelper<0, 0, false>::getTLinearFitterFormula() const
@@ -49,13 +44,11 @@ std::string MultivariatePolynomialHelper<0, 0, false>::getTLinearFitterFormula()
 std::string MultivariatePolynomialHelper<0, 0, false>::getFormula() const
 {
   std::string formula = "";
-#ifndef GPUCA_NO_FMT
   const auto terms = getTerms();
   for (int32_t i = 0; i < (int32_t)terms.size() - 1; ++i) {
     formula += fmt::format("{} + ", terms[i]);
   }
   formula += terms.back();
-#endif
   return formula;
 }
 
@@ -86,9 +79,7 @@ std::vector<float> MultivariatePolynomialHelper<0, 0, false>::fit(TLinearFitter&
 
   const int32_t status = fitter.Eval();
   if (status != 0) {
-#ifndef GPUCA_NO_FMT
     LOGP(info, "Fitting failed with status: {}", status);
-#endif
     return std::vector<float>();
   }
 
@@ -180,5 +171,3 @@ float MultivariatePolynomialHelper<0, 0, false>::evalPol(const float par[], cons
   }
   return val;
 }
-
-#endif
diff --git a/GPU/TPCFastTransformation/Spline.cxx b/GPU/TPCFastTransformation/Spline.cxx
index 70d69c465dd9e..eb5ccce3f3ac0 100644
--- a/GPU/TPCFastTransformation/Spline.cxx
+++ b/GPU/TPCFastTransformation/Spline.cxx
@@ -16,7 +16,7 @@
 
 #include "Spline.h"
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 templateClassImp(o2::gpu::Spline);
 #endif
 
diff --git a/GPU/TPCFastTransformation/Spline1D.cxx b/GPU/TPCFastTransformation/Spline1D.cxx
index 1ac8df93ab263..9e4e5d6b2d92f 100644
--- a/GPU/TPCFastTransformation/Spline1D.cxx
+++ b/GPU/TPCFastTransformation/Spline1D.cxx
@@ -16,9 +16,9 @@
 
 #include "Spline1D.h"
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 templateClassImp(o2::gpu::Spline1D);
 #endif
 
 template class o2::gpu::Spline1D<float>;
-template class o2::gpu::Spline1D<double>;
\ No newline at end of file
+template class o2::gpu::Spline1D<double>;
diff --git a/GPU/TPCFastTransformation/Spline1DHelperOld.cxx b/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
index 2ace188aa57f1..d220693b424e2 100644
--- a/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
+++ b/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
@@ -14,8 +14,6 @@
 ///
 /// \author  Sergey Gorbunov <sergey.gorbunov@cern.ch>
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
-
 #include "Spline1DHelperOld.h"
 #include "GPUCommonLogger.h"
 #include "TMath.h"
@@ -1110,5 +1108,3 @@ int32_t Spline1DHelperOld<DataT>::test(const bool draw, const bool drawDataPoint
 
 template class o2::gpu::Spline1DHelperOld<float>;
 template class o2::gpu::Spline1DHelperOld<double>;
-
-#endif
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.cxx b/GPU/TPCFastTransformation/Spline1DSpec.cxx
index 0d33cdc88010a..f16b6ce7a539b 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline1DSpec.cxx
@@ -16,12 +16,10 @@
 
 #include "Spline1DSpec.h"
 
-#if !defined(GPUCA_GPUCODE)
 #include <iostream>
 #include <algorithm>
-#endif
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
 #include "Spline1DHelper.h"
 #include "TFile.h"
 #include "GPUCommonMath.h"
@@ -32,8 +30,6 @@ templateClassImp(o2::gpu::Spline1DSpec);
 using namespace std;
 using namespace o2::gpu;
 
-#if !defined(GPUCA_GPUCODE)
-
 template <class DataT>
 void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots)
 {
@@ -144,8 +140,6 @@ void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots, co
   }
 }
 
-#endif // GPUCA_GPUCODE
-
 template <class DataT>
 void Spline1DContainer<DataT>::print() const
 {
@@ -160,7 +154,7 @@ void Spline1DContainer<DataT>::print() const
   printf("\n");
 }
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
 
 template <class DataT>
 void Spline1DContainer<DataT>::approximateFunction(
@@ -190,8 +184,6 @@ Spline1DContainer<DataT>* Spline1DContainer<DataT>::readFromFile(
 
 #endif
 
-#if !defined(GPUCA_GPUCODE)
-
 template <class DataT>
 void Spline1DContainer<DataT>::cloneFromObject(const Spline1DContainer<DataT>& obj, char* newFlatBufferPtr)
 {
@@ -218,7 +210,6 @@ void Spline1DContainer<DataT>::moveBufferTo(char* newFlatBufferPtr)
   mFlatBufferPtr = oldFlatBufferPtr;
   setActualBufferAddress(currFlatBufferPtr);
 }
-#endif // GPUCA_GPUCODE
 
 template <class DataT>
 void Spline1DContainer<DataT>::destroy()
@@ -259,13 +250,13 @@ void Spline1DContainer<DataT>::setFutureBufferAddress(char* futureFlatBufferPtr)
   FlatObject::setFutureBufferAddress(futureFlatBufferPtr);
 }
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
 template <class DataT>
 int32_t Spline1DContainer<DataT>::test(const bool draw, const bool drawDataPoints)
 {
   return Spline1DHelper<DataT>::test(draw, drawDataPoints);
 }
-#endif // GPUCA_GPUCODE
+#endif // GPUCA_STANDALONE
 
 template class o2::gpu::Spline1DContainer<float>;
 template class o2::gpu::Spline1DContainer<double>;
diff --git a/GPU/TPCFastTransformation/Spline2D.cxx b/GPU/TPCFastTransformation/Spline2D.cxx
index 70e9f85a6f6e3..ac0ddefedb8c4 100644
--- a/GPU/TPCFastTransformation/Spline2D.cxx
+++ b/GPU/TPCFastTransformation/Spline2D.cxx
@@ -16,7 +16,7 @@
 
 #include "Spline2D.h"
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 templateClassImp(o2::gpu::Spline2D);
 #endif
 
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.cxx b/GPU/TPCFastTransformation/Spline2DSpec.cxx
index 4fbd4dc3d0110..87d09ef26aa93 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline2DSpec.cxx
@@ -14,17 +14,15 @@
 ///
 /// \author  Sergey Gorbunov <sergey.gorbunov@cern.ch>
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 #include "Rtypes.h"
 #endif
 
 #include "Spline2DSpec.h"
 
-#if !defined(GPUCA_GPUCODE)
 #include <iostream>
-#endif
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 #include "TRandom.h"
 #include "Riostream.h"
 #include "TMath.h"
@@ -93,8 +91,6 @@ void Spline2DContainer<DataT>::print() const
   mGridX2.print();
 }
 
-#if !defined(GPUCA_GPUCODE)
-
 template <typename DataT>
 void Spline2DContainer<DataT>::cloneFromObject(const Spline2DContainer<DataT>& obj, char* newFlatBufferPtr)
 {
@@ -187,9 +183,7 @@ void Spline2DContainer<DataT>::recreate(int32_t nYdim,
   }
 }
 
-#endif // GPUCA_GPUCODE
-
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 
 template <typename DataT>
 void Spline2DContainer<DataT>::approximateFunction(
@@ -234,7 +228,7 @@ int32_t Spline2DContainer<DataT>::test(const bool draw, const bool drawDataPoint
   return Spline2DHelper<DataT>::test(draw, drawDataPoints);
 }
 
-#endif // GPUCA_GPUCODE && !GPUCA_STANDALONE
+#endif // !GPUCA_STANDALONE
 
 template class o2::gpu::Spline2DContainer<float>;
 template class o2::gpu::Spline2DContainer<double>;
diff --git a/GPU/TPCFastTransformation/SplineHelper.cxx b/GPU/TPCFastTransformation/SplineHelper.cxx
index af3efb1c4817d..642c6817064a1 100644
--- a/GPU/TPCFastTransformation/SplineHelper.cxx
+++ b/GPU/TPCFastTransformation/SplineHelper.cxx
@@ -14,7 +14,7 @@
 ///
 /// \author  Sergey Gorbunov <sergey.gorbunov@cern.ch>
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
 
 #include "SplineHelper.h"
 #include "Spline2D.h"
diff --git a/GPU/TPCFastTransformation/SplineSpec.cxx b/GPU/TPCFastTransformation/SplineSpec.cxx
index aa1af8ad30ba5..373c6005f643a 100644
--- a/GPU/TPCFastTransformation/SplineSpec.cxx
+++ b/GPU/TPCFastTransformation/SplineSpec.cxx
@@ -14,17 +14,15 @@
 ///
 /// \author  Sergey Gorbunov <sergey.gorbunov@cern.ch>
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 #include "Rtypes.h"
 #endif
 
 #include "SplineSpec.h"
 
-#if !defined(GPUCA_GPUCODE)
 #include <iostream>
-#endif
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 #include "TRandom.h"
 #include "Riostream.h"
 #include "TMath.h"
@@ -94,8 +92,6 @@ void SplineContainer<DataT>::print() const
   }
 }
 
-#if !defined(GPUCA_GPUCODE)
-
 template <typename DataT>
 void SplineContainer<DataT>::cloneFromObject(const SplineContainer<DataT>& obj, char* newFlatBufferPtr)
 {
@@ -191,9 +187,7 @@ void SplineContainer<DataT>::recreate(
   recreate(nXdim, nYdim, numberOfKnots, nullptr);
 }
 
-#endif // GPUCA_GPUCODE
-
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
+#if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 
 template <typename DataT>
 void SplineContainer<DataT>::
@@ -227,7 +221,7 @@ int32_t SplineContainer<DataT>::test(const bool draw, const bool drawDataPoints)
   return SplineHelper<DataT>::test(draw, drawDataPoints);
 }
 
-#endif // GPUCA_GPUCODE && !GPUCA_STANDALONE
+#endif //! GPUCA_STANDALONE
 
 template class o2::gpu::SplineContainer<float>;
 template class o2::gpu::SplineContainer<double>;
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.cxx b/GPU/TPCFastTransformation/TPCFastTransform.cxx
index 42c4c57ffa086..2a829cfcd5471 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransform.cxx
@@ -14,23 +14,21 @@
 ///
 /// \author  Sergey Gorbunov <sergey.gorbunov@cern.ch>
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
 #include "Rtypes.h"
 #endif
 
 #include "TPCFastTransform.h"
 #include "GPUCommonLogger.h"
 
-#if !defined(GPUCA_GPUCODE)
 #include <iostream>
-#endif
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
 #include "TFile.h"
 #include "GPUCommonLogger.h"
 #endif
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
 #include "TPCSpaceCharge/SpaceCharge.h"
 #endif
 
@@ -142,7 +140,6 @@ void TPCFastTransform::finishConstruction()
 
 void TPCFastTransform::print() const
 {
-#if !defined(GPUCA_GPUCODE)
   LOG(info) << "TPC Fast Transformation: ";
   LOG(info) << "mTimeStamp = " << mTimeStamp;
   LOG(info) << "mApplyCorrection = " << mApplyCorrection;
@@ -155,10 +152,9 @@ void TPCFastTransform::print() const
   LOG(info) << "mCTP2IDCFallBackThreshold = " << mCTP2IDCFallBackThreshold;
   LOG(info) << "mLumiScaleFactor = " << mLumiScaleFactor;
   mCorrection.print();
-#endif
 }
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
 
 int32_t TPCFastTransform::writeToFile(std::string outFName, std::string name)
 {
@@ -224,7 +220,7 @@ TPCFastTransform* TPCFastTransform::loadFromFile(std::string inpFName, std::stri
 
 #endif
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
 TPCSlowSpaceChargeCorrection::~TPCSlowSpaceChargeCorrection()
 {
   delete mCorr;
@@ -250,16 +246,14 @@ float TPCFastTransform::getIDC() const
   auto val = mIDC;
   if (!isIDCSet()) {
     if (mLumi < mCTP2IDCFallBackThreshold) {
-#if !defined(GPUCA_GPUCODE)
       bool static report = true;
       if (report) {
         report = false;
         LOG(warn) << "IDC scaling is requested but map IDC record is empty. Since map Lumi " << mLumi << " is less than fall-back threshold " << mCTP2IDCFallBackThreshold << ", interpret Lumi record as IDC";
       }
-#endif
       val = mLumi;
     } else {
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_STANDALONE)
       LOG(fatal) << "IDC scaling is requested but map IDC record is empty. The map Lumi " << mLumi << " exceeds Lumi->IDC fall-back threshold " << mCTP2IDCFallBackThreshold;
 #endif
     }
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
index c7ed4243d7396..289f2a2d3c8c0 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.cxx
@@ -19,9 +19,7 @@
 #include "GPUCommonMath.h"
 #include "GPUCommonLogger.h"
 
-#if !defined(GPUCA_GPUCODE)
 #include <iostream>
-#endif
 
 using namespace o2::gpu;
 
@@ -109,8 +107,7 @@ void TPCFastTransformGeo::finishConstruction()
 
 void TPCFastTransformGeo::print() const
 {
-/// Prints the geometry
-#if !defined(GPUCA_GPUCODE)
+  /// Prints the geometry
   LOG(info) << "TPC Fast Transformation Geometry: ";
   LOG(info) << "mNumberOfRows = " << mNumberOfRows;
   LOG(info) << "mTPCzLength = " << mTPCzLength;
@@ -118,7 +115,6 @@ void TPCFastTransformGeo::print() const
   for (int32_t i = 0; i < mNumberOfRows; i++) {
     LOG(info) << " tpc row " << i << ": x = " << mRowInfos[i].x << " maxPad = " << mRowInfos[i].maxPad << " padWidth = " << mRowInfos[i].padWidth;
   }
-#endif
 }
 
 int32_t TPCFastTransformGeo::test(int32_t sector, int32_t row, float ly, float lz) const
@@ -155,11 +151,9 @@ int32_t TPCFastTransformGeo::test(int32_t sector, int32_t row, float ly, float l
     error = -4;
   }
 
-#if !defined(GPUCA_GPUCODE)
   if (error != 0) {
     LOG(info) << "TPC Fast Transformation Geometry: Internal ERROR " << error;
   }
-#endif
   return error;
 }
 
diff --git a/GPU/TPCFastTransformation/devtools/IrregularSpline1D.cxx b/GPU/TPCFastTransformation/devtools/IrregularSpline1D.cxx
index 456447720b2c1..e793ea3af8966 100644
--- a/GPU/TPCFastTransformation/devtools/IrregularSpline1D.cxx
+++ b/GPU/TPCFastTransformation/devtools/IrregularSpline1D.cxx
@@ -20,9 +20,7 @@
 #include <cmath>
 #include <vector>
 
-#if !defined(GPUCA_GPUCODE)
 #include <iostream>
-#endif
 
 using namespace o2::gpu;
 
@@ -206,7 +204,6 @@ void IrregularSpline1D::constructRegular(int32_t numberOfKnots)
 
 void IrregularSpline1D::print() const
 {
-#if !defined(GPUCA_GPUCODE)
   LOG(info) << " Irregular Spline 1D: ";
   LOG(info) << "  mNumberOfKnots = " << mNumberOfKnots;
   LOG(info) << "  mNumberOfAxisBins = " << mNumberOfAxisBins;
@@ -216,5 +213,4 @@ void IrregularSpline1D::print() const
     LOG(info) << getKnot(i).u << " ";
   }
   LOG(info);
-#endif
 }
diff --git a/GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.cxx b/GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.cxx
index 1e5a7f7cd80f7..23fb5b290541b 100644
--- a/GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.cxx
+++ b/GPU/TPCFastTransformation/devtools/IrregularSpline2D3D.cxx
@@ -17,9 +17,7 @@
 #include "IrregularSpline2D3D.h"
 #include "GPUCommonLogger.h"
 
-#if !defined(GPUCA_GPUCODE)
 #include <iostream>
-#endif
 
 using namespace o2::gpu;
 
@@ -139,11 +137,9 @@ void IrregularSpline2D3D::constructRegular(int32_t numberOfKnotsU, int32_t numbe
 
 void IrregularSpline2D3D::print() const
 {
-#if !defined(GPUCA_GPUCODE)
   LOG(info) << " Irregular Spline 2D3D: ";
   LOG(info) << " grid U: ";
   mGridU.print();
   LOG(info) << " grid V: ";
   mGridV.print();
-#endif
 }

From 1b2bfc14afa7fdcd507cc46bc02f9cd0e33b309d Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Tue, 7 Apr 2026 18:57:04 +0200
Subject: [PATCH 1607/1764] make TPCFastTransformPOD fully independent of
 FlatObject and root

---
 GPU/TPCFastTransformation/Spline1D.h          |  58 +++++--
 GPU/TPCFastTransformation/Spline1DHelper.cxx  |  14 +-
 GPU/TPCFastTransformation/Spline1DHelper.h    |  14 +-
 .../Spline1DHelperOld.cxx                     |  12 +-
 GPU/TPCFastTransformation/Spline1DHelperOld.h |  12 +-
 GPU/TPCFastTransformation/Spline1DSpec.cxx    | 134 +++++++++------
 GPU/TPCFastTransformation/Spline1DSpec.h      | 105 +++++++-----
 GPU/TPCFastTransformation/Spline2D.h          |  52 ++++--
 GPU/TPCFastTransformation/Spline2DHelper.cxx  |   6 +-
 GPU/TPCFastTransformation/Spline2DHelper.h    |  14 +-
 GPU/TPCFastTransformation/Spline2DSpec.cxx    | 161 ++++++++++--------
 GPU/TPCFastTransformation/Spline2DSpec.h      | 121 ++++++++-----
 .../TPCFastSpaceChargeCorrection.h            |   6 +
 .../TPCFastTransformPOD.cxx                   |  26 +--
 .../TPCFastTransformPOD.h                     |   8 +-
 .../TPCFastTransformationLinkDef_O2.h         |  16 +-
 GPU/Utils/FlatObject.h                        |  39 +++++
 17 files changed, 502 insertions(+), 296 deletions(-)

diff --git a/GPU/TPCFastTransformation/Spline1D.h b/GPU/TPCFastTransformation/Spline1D.h
index c7a4d927dec1d..1835892298032 100644
--- a/GPU/TPCFastTransformation/Spline1D.h
+++ b/GPU/TPCFastTransformation/Spline1D.h
@@ -134,12 +134,14 @@ namespace gpu
 ///    YdimT = 0 : the number of Y dimensions will be set in the runtime
 ///    YdimT < 0 : the number of Y dimensions will be set in the runtime, and it will not exceed abs(YdimT)
 ///
-template <typename DataT, int32_t YdimT = 0>
-class Spline1D
-  : public Spline1DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT)>
+/// Common implementation (no ClassDefNV — ROOT dictionary is in the FlatObject specialization below)
+template <typename DataT, int32_t YdimT, class FlatBase>
+class Spline1DBase
+  : public Spline1DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase>
 {
-  typedef Spline1DContainer<DataT> TVeryBase;
-  typedef Spline1DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT)> TBase;
+ protected:
+  typedef Spline1DContainerBase<DataT, FlatBase> TVeryBase;
+  typedef Spline1DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase> TBase;
 
  public:
   typedef typename TVeryBase::SafetyLevel SafetyLevel;
@@ -148,34 +150,56 @@ class Spline1D
 #if !defined(GPUCA_GPUCODE)
   using TBase::TBase; // inherit constructors
 
-  /// Assignment operator
-  Spline1D() = default;
-  Spline1D(const Spline1D& v) : TBase(v)
+  Spline1DBase() = default;
+  Spline1DBase(const Spline1DBase& v) : TBase(v)
   {
-    TVeryBase::cloneFromObject(v, nullptr);
+    static_cast<TVeryBase*>(this)->cloneFromObject(v, nullptr);
   }
-  Spline1D& operator=(const Spline1D& v)
+  Spline1DBase& operator=(const Spline1DBase& v)
   {
-    TVeryBase::cloneFromObject(v, nullptr);
+    static_cast<TVeryBase*>(this)->cloneFromObject(v, nullptr);
     return *this;
   }
 #else
-  /// Disable constructors for the GPU implementation
-  Spline1D() = delete;
-  Spline1D(const Spline1D&) = delete;
+  Spline1DBase() = delete;
+  Spline1DBase(const Spline1DBase&) = delete;
 #endif
 
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
-  /// read a class object from the file
-  static Spline1D* readFromFile(TFile& inpf, const char* name)
+  static Spline1DBase* readFromFile(TFile& inpf, const char* name)
   {
-    return (Spline1D*)TVeryBase::readFromFile(inpf, name);
+    return (Spline1DBase*)TVeryBase::readFromFile(inpf, name);
   }
 #endif
+};
 
+/// Forward declaration — specializations below select ClassDefNV based on FlatBase
+template <typename DataT, int32_t YdimT = 0, class FlatBase = FlatObject>
+class Spline1D;
+
+/// FlatObject specialization — carries ClassDefNV for ROOT I/O
+template <typename DataT, int32_t YdimT>
+class Spline1D<DataT, YdimT, FlatObject> : public Spline1DBase<DataT, YdimT, FlatObject>
+{
+ public:
+  using Spline1DBase<DataT, YdimT, FlatObject>::Spline1DBase;
+#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+  static Spline1D* readFromFile(TFile& inpf, const char* name)
+  {
+    return (Spline1D*)Spline1DContainerBase<DataT, FlatObject>::readFromFile(inpf, name);
+  }
+#endif
   ClassDefNV(Spline1D, 0);
 };
 
+/// NoFlatObject specialization — no ROOT ClassDef overhead
+template <typename DataT, int32_t YdimT>
+class Spline1D<DataT, YdimT, NoFlatObject> : public Spline1DBase<DataT, YdimT, NoFlatObject>
+{
+ public:
+  using Spline1DBase<DataT, YdimT, NoFlatObject>::Spline1DBase;
+};
+
 } // namespace gpu
 } // namespace o2
 
diff --git a/GPU/TPCFastTransformation/Spline1DHelper.cxx b/GPU/TPCFastTransformation/Spline1DHelper.cxx
index 9177c67d8b87b..e2243d9c9a8a9 100644
--- a/GPU/TPCFastTransformation/Spline1DHelper.cxx
+++ b/GPU/TPCFastTransformation/Spline1DHelper.cxx
@@ -133,7 +133,7 @@ void Spline1DHelper<DataT>::getDDDScoefficients(const typename Spline1D<double>:
 
 template <typename DataT>
 void Spline1DHelper<DataT>::approximateDataPoints(
-  Spline1DContainer<DataT>& spline,
+  Spline1DContainerBase<DataT, FlatObject>& spline,
   double xMin, double xMax,
   const double vx[], const double vf[], int32_t nDataPoints)
 {
@@ -246,7 +246,7 @@ void Spline1DHelper<DataT>::approximateDataPoints(
 
 template <typename DataT>
 void Spline1DHelper<DataT>::approximateDerivatives(
-  Spline1DContainer<DataT>& spline,
+  Spline1DContainerBase<DataT, FlatObject>& spline,
   const double vx[], const double vf[], int32_t nDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -298,7 +298,7 @@ void Spline1DHelper<DataT>::approximateDerivatives(
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainer<DataT>& spline,
+void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<DataT, FlatObject>& spline,
                                                        double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F)
 {
   /// Create classic spline parameters for a given input function F
@@ -422,7 +422,7 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainer<DataT>&
 
 template <typename DataT>
 void Spline1DHelper<DataT>::makeDataPoints(
-  Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints, std::vector<double>& vx, std::vector<double>& vf)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -451,7 +451,7 @@ void Spline1DHelper<DataT>::makeDataPoints(
 
 template <typename DataT>
 void Spline1DHelper<DataT>::approximateFunction(
-  Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -463,7 +463,7 @@ void Spline1DHelper<DataT>::approximateFunction(
 
 template <typename DataT>
 void Spline1DHelper<DataT>::approximateFunctionGradually(
-  Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -491,7 +491,7 @@ void Spline1DHelper<DataT>::approximateFunctionGradually(
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::setSpline(const Spline1DContainer<DataT>& spline)
+void Spline1DHelper<DataT>::setSpline(const Spline1DContainerBase<DataT, FlatObject>& spline)
 {
   const int32_t nKnots = spline.getNumberOfKnots();
   std::vector<int32_t> knots(nKnots);
diff --git a/GPU/TPCFastTransformation/Spline1DHelper.h b/GPU/TPCFastTransformation/Spline1DHelper.h
index 61a3e648ccc01..9c88cf61470a5 100644
--- a/GPU/TPCFastTransformation/Spline1DHelper.h
+++ b/GPU/TPCFastTransformation/Spline1DHelper.h
@@ -52,25 +52,25 @@ class Spline1DHelper
   /// _______________  Main functionality  ________________________
 
   /// Create best-fit spline parameters for a set of data points
-  void approximateDataPoints(Spline1DContainer<DataT>& spline,
+  void approximateDataPoints(Spline1DContainerBase<DataT, FlatObject>& spline,
                              double xMin, double xMax,
                              const double vx[], const double vf[], int32_t nDataPoints);
 
   /// Create best-fit spline parameters for a function F
   void approximateFunction(
-    Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+    Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
     int32_t nAuxiliaryDataPoints = 4);
 
   /// Approximate only derivatives assuming the spline values at knozts are already set
-  void approximateDerivatives(Spline1DContainer<DataT>& spline,
+  void approximateDerivatives(Spline1DContainerBase<DataT, FlatObject>& spline,
                               const double vx[], const double vf[], int32_t nDataPoints);
 
   void approximateFunctionGradually(
-    Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+    Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
     int32_t nAuxiliaryDataPoints);
 
   /// Create classic spline parameters for a given input function F
-  void approximateFunctionClassic(Spline1DContainer<DataT>& spline,
+  void approximateFunctionClassic(Spline1DContainerBase<DataT, FlatObject>& spline,
                                   double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F);
 
   /// _______________  Utilities   ________________________
@@ -110,9 +110,9 @@ class Spline1DHelper
 
   std::string mError = ""; ///< error string
 
-  void setSpline(const Spline1DContainer<DataT>& spline);
+  void setSpline(const Spline1DContainerBase<DataT, FlatObject>& spline);
 
-  void makeDataPoints(Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  void makeDataPoints(Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
                       int32_t nAuxiliaryDataPoints, std::vector<double>& vx, std::vector<double>& vf);
 
   /// helpers for the construction of 1D spline
diff --git a/GPU/TPCFastTransformation/Spline1DHelperOld.cxx b/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
index d220693b424e2..2427cb6ff37e4 100644
--- a/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
+++ b/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
@@ -129,7 +129,7 @@ void Spline1DHelperOld<DataT>::getDDDScoefficients(const typename Spline1D<doubl
 }
 
 template <typename DataT>
-void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainer<DataT>& spline,
+void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<DataT, FlatObject>& spline,
                                                           double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F)
 {
   /// Create classic spline parameters for a given input function F
@@ -253,7 +253,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainer<Data
 
 template <typename DataT>
 void Spline1DHelperOld<DataT>::approximateDataPoints(
-  Spline1DContainer<DataT>& spline,
+  Spline1DContainerBase<DataT, FlatObject>& spline,
   double xMin, double xMax,
   double vx[], double vf[], int32_t nDataPoints)
 {
@@ -266,7 +266,7 @@ void Spline1DHelperOld<DataT>::approximateDataPoints(
 
 template <typename DataT>
 void Spline1DHelperOld<DataT>::approximateFunction(
-  Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -277,7 +277,7 @@ void Spline1DHelperOld<DataT>::approximateFunction(
 
 template <typename DataT>
 void Spline1DHelperOld<DataT>::approximateFunctionGradually(
-  Spline1DContainer<DataT>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints)
 {
   /// Create best-fit spline parameters gradually for a given input function F
@@ -316,7 +316,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionGradually(
 
 template <typename DataT>
 int32_t Spline1DHelperOld<DataT>::setSpline(
-  const Spline1DContainer<DataT>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints)
+  const Spline1DContainerBase<DataT, FlatObject>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints)
 {
   // Prepare creation of a best-fit spline
   //
@@ -463,7 +463,7 @@ int32_t Spline1DHelperOld<DataT>::setSpline(
 
 template <typename DataT>
 int32_t Spline1DHelperOld<DataT>::setSpline(
-  const Spline1DContainer<DataT>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints)
+  const Spline1DContainerBase<DataT, FlatObject>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints)
 {
   // Prepare creation of a best-fit spline
   //
diff --git a/GPU/TPCFastTransformation/Spline1DHelperOld.h b/GPU/TPCFastTransformation/Spline1DHelperOld.h
index 971541e03258e..8ab36d5f57641 100644
--- a/GPU/TPCFastTransformation/Spline1DHelperOld.h
+++ b/GPU/TPCFastTransformation/Spline1DHelperOld.h
@@ -69,31 +69,31 @@ class Spline1DHelperOld
   void bandGauss(double A[], double b[], int32_t n);
 
   /// Create best-fit spline parameters for a given input function F
-  void approximateDataPoints(Spline1DContainer<DataT>& spline,
+  void approximateDataPoints(Spline1DContainerBase<DataT, FlatObject>& spline,
                              double xMin, double xMax,
                              double x[], double f[], int32_t nDataPoints);
 
   /// Create best-fit spline parameters for a given input function F
-  void approximateFunction(Spline1DContainer<DataT>& spline,
+  void approximateFunction(Spline1DContainerBase<DataT, FlatObject>& spline,
                            double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
                            int32_t nAuxiliaryDataPoints = 4);
 
   /// Create best-fit spline parameters gradually for a given input function F
-  void approximateFunctionGradually(Spline1DContainer<DataT>& spline,
+  void approximateFunctionGradually(Spline1DContainerBase<DataT, FlatObject>& spline,
                                     double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
                                     int32_t nAuxiliaryDataPoints = 4);
 
   /// Create classic spline parameters for a given input function F
-  void approximateFunctionClassic(Spline1DContainer<DataT>& spline,
+  void approximateFunctionClassic(Spline1DContainerBase<DataT, FlatObject>& spline,
                                   double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F);
 
   /// _______________   Interface for a step-wise construction of the best-fit spline   ________________________
 
   /// precompute everything needed for the construction
-  int32_t setSpline(const Spline1DContainer<DataT>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints);
+  int32_t setSpline(const Spline1DContainerBase<DataT, FlatObject>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints);
 
   /// precompute everything needed for the construction
-  int32_t setSpline(const Spline1DContainer<DataT>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints);
+  int32_t setSpline(const Spline1DContainerBase<DataT, FlatObject>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints);
 
   /// approximate std::function, output in Fparameters
   void approximateFunction(DataT* Fparameters, double xMin, double xMax, std::function<void(double x, double f[])> F) const;
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.cxx b/GPU/TPCFastTransformation/Spline1DSpec.cxx
index f16b6ce7a539b..0ff694957e94c 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline1DSpec.cxx
@@ -30,8 +30,8 @@ templateClassImp(o2::gpu::Spline1DSpec);
 using namespace std;
 using namespace o2::gpu;
 
-template <class DataT>
-void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots)
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t numberOfKnots)
 {
   /// Constructor for a regular spline
   /// \param numberOfKnots     Number of knots
@@ -47,8 +47,8 @@ void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots)
   recreate(nYdim, numberOfKnots, knots.data());
 }
 
-template <class DataT>
-void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots, const int32_t inputKnots[])
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t numberOfKnots, const int32_t inputKnots[])
 {
   /// Main constructor for an irregular spline
   ///
@@ -60,7 +60,7 @@ void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots, co
   /// \param knots             Array of relative knot positions (integer values)
   ///
 
-  FlatObject::startConstruction();
+  FlatBase::startConstruction();
 
   mYdim = (nYdim >= 0) ? nYdim : 0;
 
@@ -95,14 +95,14 @@ void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots, co
   int32_t parametersOffset = uToKnotMapOffset + (mUmax + 1) * sizeof(int32_t);
   int32_t bufferSize = parametersOffset;
   if (mYdim > 0) {
-    parametersOffset = alignSize(bufferSize, getParameterAlignmentBytes());
+    parametersOffset = this->alignSize(bufferSize, getParameterAlignmentBytes());
     bufferSize = parametersOffset + getSizeOfParameters();
   }
 
-  FlatObject::finishConstruction(bufferSize);
+  FlatBase::finishConstruction(bufferSize);
 
-  mUtoKnotMap = reinterpret_cast<int32_t*>(mFlatBufferPtr + uToKnotMapOffset);
-  mParameters = reinterpret_cast<DataT*>(mFlatBufferPtr + parametersOffset);
+  mUtoKnotMap = reinterpret_cast<int32_t*>(this->mFlatBufferPtr + uToKnotMapOffset);
+  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
 
   for (int32_t i = 0; i < getNumberOfParameters(); i++) {
     mParameters[i] = 0;
@@ -140,8 +140,8 @@ void Spline1DContainer<DataT>::recreate(int32_t nYdim, int32_t numberOfKnots, co
   }
 }
 
-template <class DataT>
-void Spline1DContainer<DataT>::print() const
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::print() const
 {
   printf(" Spline 1D: \n");
   printf("  mNumberOfKnots = %d \n", mNumberOfKnots);
@@ -156,63 +156,88 @@ void Spline1DContainer<DataT>::print() const
 
 #if !defined(GPUCA_STANDALONE)
 
-template <class DataT>
-void Spline1DContainer<DataT>::approximateFunction(
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::approximateFunction(
   double xMin, double xMax,
   std::function<void(double x, double f[])> F,
   int32_t nAxiliaryDataPoints)
 {
   /// approximate a function F with this spline
-  Spline1DHelper<DataT> helper;
-  helper.approximateFunction(*reinterpret_cast<Spline1D<DataT>*>(this), xMin, xMax, F, nAxiliaryDataPoints);
+  if constexpr (std::is_same_v<FlatBase, FlatObject>) {
+    Spline1DHelper<DataT> helper;
+    helper.approximateFunction(*this, xMin, xMax, F, nAxiliaryDataPoints);
+  }
 }
 
-template <class DataT>
-int32_t Spline1DContainer<DataT>::writeToFile(TFile& outf, const char* name)
+template <class DataT, class FlatBase>
+int32_t Spline1DContainerBase<DataT, FlatBase>::writeToFile(TFile& outf, const char* name)
 {
   /// write a class object to the file
-  return FlatObject::writeToFile(*this, outf, name);
+  if constexpr (std::is_same_v<FlatBase, FlatObject>) {
+    return FlatObject::writeToFile(*this, outf, name);
+  } else {
+    return -1;
+  }
 }
 
-template <class DataT>
-Spline1DContainer<DataT>* Spline1DContainer<DataT>::readFromFile(
-  TFile& inpf, const char* name)
+template <class DataT, class FlatBase>
+Spline1DContainerBase<DataT, FlatBase>* Spline1DContainerBase<DataT, FlatBase>::readFromFile(TFile& inpf, const char* name)
 {
   /// read a class object from the file
-  return FlatObject::readFromFile<Spline1DContainer<DataT>>(inpf, name);
+  if constexpr (std::is_same_v<FlatBase, FlatObject>) {
+    return FlatObject::readFromFile<Spline1DContainerBase<DataT, FlatBase>>(inpf, name);
+  } else {
+    return nullptr;
+  }
 }
 
 #endif
 
-template <class DataT>
-void Spline1DContainer<DataT>::cloneFromObject(const Spline1DContainer<DataT>& obj, char* newFlatBufferPtr)
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::cloneFromObject(const Spline1DContainerBase<DataT, FlatBase>& obj, char* newFlatBufferPtr)
 {
   /// See FlatObject for description
 
   const char* oldFlatBufferPtr = obj.mFlatBufferPtr;
-  FlatObject::cloneFromObject(obj, newFlatBufferPtr);
+  FlatBase::cloneFromObject(obj, newFlatBufferPtr);
   mYdim = obj.mYdim;
   mNumberOfKnots = obj.mNumberOfKnots;
   mUmax = obj.mUmax;
   mXmin = obj.mXmin;
   mXtoUscale = obj.mXtoUscale;
-  mUtoKnotMap = FlatObject::relocatePointer(oldFlatBufferPtr, mFlatBufferPtr, obj.mUtoKnotMap);
-  mParameters = FlatObject::relocatePointer(oldFlatBufferPtr, mFlatBufferPtr, obj.mParameters);
+  mUtoKnotMap = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mUtoKnotMap);
+  mParameters = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mParameters);
 }
 
-template <class DataT>
-void Spline1DContainer<DataT>::moveBufferTo(char* newFlatBufferPtr)
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::moveBufferTo(char* newFlatBufferPtr)
 {
   /// See FlatObject for description
-  char* oldFlatBufferPtr = mFlatBufferPtr;
-  FlatObject::moveBufferTo(newFlatBufferPtr);
-  char* currFlatBufferPtr = mFlatBufferPtr;
-  mFlatBufferPtr = oldFlatBufferPtr;
+  char* oldFlatBufferPtr = this->mFlatBufferPtr;
+  FlatBase::moveBufferTo(newFlatBufferPtr);
+  char* currFlatBufferPtr = this->mFlatBufferPtr;
+  this->mFlatBufferPtr = oldFlatBufferPtr;
   setActualBufferAddress(currFlatBufferPtr);
 }
 
-template <class DataT>
-void Spline1DContainer<DataT>::destroy()
+template <class DataT, class FlatBase>
+template <class OtherFlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::importFrom(const Spline1DContainerBase<DataT, OtherFlatBase>& src)
+{
+  /// Copy schema fields from a spline with a different FlatBase (e.g. FlatObject -> NoFlatObject).
+  /// Pointers (mUtoKnotMap, mParameters) are set to nullptr; call setActualBufferAddress() afterward.
+  mYdim = src.getYdimensions();
+  mNumberOfKnots = src.getNumberOfKnots();
+  mUmax = src.getUmax();
+  mXmin = src.getXmin();
+  mXtoUscale = src.getXtoUscale();
+  this->mFlatBufferSize = src.getFlatBufferSize();
+  mUtoKnotMap = nullptr;
+  mParameters = nullptr;
+}
+
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::destroy()
 {
   /// See FlatObject for description
   mNumberOfKnots = 0;
@@ -222,43 +247,54 @@ void Spline1DContainer<DataT>::destroy()
   mXtoUscale = 1.;
   mUtoKnotMap = nullptr;
   mParameters = nullptr;
-  FlatObject::destroy();
+  FlatBase::destroy();
 }
 
-template <class DataT>
-void Spline1DContainer<DataT>::setActualBufferAddress(char* actualFlatBufferPtr)
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::setActualBufferAddress(char* actualFlatBufferPtr)
 {
   /// See FlatObject for description
 
-  FlatObject::setActualBufferAddress(actualFlatBufferPtr);
+  FlatBase::setActualBufferAddress(actualFlatBufferPtr);
 
   const int32_t uToKnotMapOffset = mNumberOfKnots * sizeof(Knot);
-  mUtoKnotMap = reinterpret_cast<int32_t*>(mFlatBufferPtr + uToKnotMapOffset);
+  mUtoKnotMap = reinterpret_cast<int32_t*>(this->mFlatBufferPtr + uToKnotMapOffset);
   int32_t parametersOffset = uToKnotMapOffset + (mUmax + 1) * sizeof(int32_t);
   if (mYdim > 0) {
-    parametersOffset = alignSize(parametersOffset, getParameterAlignmentBytes());
+    parametersOffset = this->alignSize(parametersOffset, getParameterAlignmentBytes());
   }
-  mParameters = reinterpret_cast<DataT*>(mFlatBufferPtr + parametersOffset);
+  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
 }
 
-template <class DataT>
-void Spline1DContainer<DataT>::setFutureBufferAddress(char* futureFlatBufferPtr)
+template <class DataT, class FlatBase>
+void Spline1DContainerBase<DataT, FlatBase>::setFutureBufferAddress(char* futureFlatBufferPtr)
 {
   /// See FlatObject for description
-  mUtoKnotMap = FlatObject::relocatePointer(mFlatBufferPtr, futureFlatBufferPtr, mUtoKnotMap);
-  mParameters = relocatePointer(mFlatBufferPtr, futureFlatBufferPtr, mParameters);
-  FlatObject::setFutureBufferAddress(futureFlatBufferPtr);
+  mUtoKnotMap = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mUtoKnotMap);
+  mParameters = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mParameters);
+  FlatBase::setFutureBufferAddress(futureFlatBufferPtr);
 }
 
 #if !defined(GPUCA_STANDALONE)
-template <class DataT>
-int32_t Spline1DContainer<DataT>::test(const bool draw, const bool drawDataPoints)
+template <class DataT, class FlatBase>
+int32_t Spline1DContainerBase<DataT, FlatBase>::test(const bool draw, const bool drawDataPoints)
 {
   return Spline1DHelper<DataT>::test(draw, drawDataPoints);
 }
 #endif // GPUCA_STANDALONE
 
+template class o2::gpu::Spline1DContainerBase<float>;
+template class o2::gpu::Spline1DContainerBase<double>;
 template class o2::gpu::Spline1DContainer<float>;
 template class o2::gpu::Spline1DContainer<double>;
 template class o2::gpu::Spline1DSpec<float, 0, 2>;
 template class o2::gpu::Spline1DSpec<double, 0, 2>;
+
+// Explicit instantiations for NoFlatObject (used by TPCFastTransformPOD)
+template class o2::gpu::Spline1DContainerBase<float, o2::gpu::NoFlatObject>;
+template class o2::gpu::Spline1DContainerBase<double, o2::gpu::NoFlatObject>;
+template class o2::gpu::Spline1DContainer<float, o2::gpu::NoFlatObject>;
+template class o2::gpu::Spline1DContainer<double, o2::gpu::NoFlatObject>;
+// importFrom instantiation for the FlatObject -> NoFlatObject conversion used in create()
+template void o2::gpu::Spline1DContainerBase<float, o2::gpu::NoFlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline1DContainerBase<float, o2::gpu::FlatObject>&);
+template void o2::gpu::Spline1DContainerBase<double, o2::gpu::NoFlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline1DContainerBase<double, o2::gpu::FlatObject>&);
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 48706bcc2a830..63508950e68b4 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -23,6 +23,7 @@
 
 #if !defined(GPUCA_GPUCODE)
 #include <functional>
+#include <type_traits>
 #endif
 
 class TFile;
@@ -33,7 +34,7 @@ namespace gpu
 {
 
 /// ==================================================================================================
-/// The class Spline1DContainer is a base class of Spline1D.
+/// The class Spline1DContainerBase is a base class of Spline1D.
 /// It contains all the class members and those methods which only depends on the DataT data type.
 /// It also contains all non-inlined methods with the implementation in Spline1DSpec.cxx file.
 ///
@@ -41,8 +42,8 @@ namespace gpu
 /// For other possible data types one has to add the corresponding instantiation line
 /// at the end of the Spline1DSpec.cxx file
 ///
-template <typename DataT>
-class Spline1DContainer : public FlatObject
+template <typename DataT, class FlatBase = FlatObject>
+class Spline1DContainerBase : public FlatBase
 {
  public:
   /// Named enumeration for the safety level used by some methods
@@ -66,13 +67,13 @@ class Spline1DContainer : public FlatObject
   /// _____________  C++ constructors / destructors __________________________
 
   /// Default constructor, required by the Root IO
-  Spline1DContainer() = default;
+  Spline1DContainerBase() = default;
 
   /// Disable all other constructors
-  Spline1DContainer(const Spline1DContainer&) = delete;
+  Spline1DContainerBase(const Spline1DContainerBase&) = delete;
 
   /// Destructor
-  ~Spline1DContainer() = default;
+  ~Spline1DContainerBase() = default;
 
   /// _______________  Construction interface  ________________________
 
@@ -90,7 +91,7 @@ class Spline1DContainer : public FlatObject
   int32_t writeToFile(TFile& outf, const char* name);
 
   /// read a class object from the file
-  static Spline1DContainer* readFromFile(TFile& inpf, const char* name);
+  static Spline1DContainerBase* readFromFile(TFile& inpf, const char* name);
 #endif
 
   /// _______________  Getters   ________________________
@@ -118,7 +119,7 @@ class Spline1DContainer : public FlatObject
   GPUd() int32_t getNumberOfKnots() const { return mNumberOfKnots; }
 
   /// Get the array of knots
-  GPUd() const Knot* getKnots() const { return reinterpret_cast<const Knot*>(mFlatBufferPtr); }
+  GPUd() const Knot* getKnots() const { return reinterpret_cast<const Knot*>(this->mFlatBufferPtr); }
 
   /// Get i-th knot
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
@@ -217,15 +218,20 @@ class Spline1DContainer : public FlatObject
 
   /// _____________  FlatObject functionality, see FlatObject class for description  ____________
 
-  using FlatObject::getBufferAlignmentBytes;
-  using FlatObject::getClassAlignmentBytes;
+  using FlatBase::getBufferAlignmentBytes;
+  using FlatBase::getClassAlignmentBytes;
 
 #if !defined(GPUCA_GPUCODE)
-  void cloneFromObject(const Spline1DContainer& obj, char* newFlatBufferPtr);
+  void cloneFromObject(const Spline1DContainerBase& obj, char* newFlatBufferPtr);
   void moveBufferTo(char* newBufferPtr);
+
+  /// Copy schema fields from a spline with a different FlatBase (e.g. FlatObject -> NoFlatObject).
+  /// Pointer members (mUtoKnotMap, mParameters) are set to nullptr; call setActualBufferAddress() afterward.
+  template <class OtherFlatBase>
+  void importFrom(const Spline1DContainerBase<DataT, OtherFlatBase>& src);
 #endif
 
-  using FlatObject::releaseInternalBuffer;
+  using FlatBase::releaseInternalBuffer;
 
   void destroy();
   void setActualBufferAddress(char* actualFlatBufferPtr);
@@ -233,7 +239,7 @@ class Spline1DContainer : public FlatObject
 
  protected:
   /// Non-const accessor to the knots array
-  Knot* getKnots() { return reinterpret_cast<Knot*>(mFlatBufferPtr); }
+  Knot* getKnots() { return reinterpret_cast<Knot*>(this->mFlatBufferPtr); }
 
   /// Non-const accessor to U->knots map
   int32_t* getUtoKnotMap() { return mUtoKnotMap; }
@@ -255,13 +261,32 @@ class Spline1DContainer : public FlatObject
   DataT mXtoUscale = 0;           ///< a scaling factor to convert X to U
   int32_t* mUtoKnotMap = nullptr; //! (transient!!) pointer to (integer U -> knot index) map inside the mFlatBufferPtr array
   DataT* mParameters = nullptr;   //! (transient!!) pointer to F-dependent parameters inside the mFlatBufferPtr array
+};
+
+template <typename DataT, typename FlatBase = FlatObject>
+class Spline1DContainer; // forward declaration
+
+template <typename DataT>
+class Spline1DContainer<DataT, FlatObject> : public Spline1DContainerBase<DataT, FlatObject>
+{
+public:
+    using Base = Spline1DContainerBase<DataT, FlatObject>;
+    using Base::Base;
 
-  ClassDefNV(Spline1DContainer, 1);
+    ClassDefNV(Spline1DContainer, 1);
 };
 
 template <typename DataT>
-template <typename Spline1DContainer<DataT>::SafetyLevel SafeT>
-GPUdi() int32_t Spline1DContainer<DataT>::getLeftKnotIndexForU(DataT u) const
+class Spline1DContainer<DataT, NoFlatObject> : public Spline1DContainerBase<DataT, NoFlatObject>
+{
+public:
+    using Base = Spline1DContainerBase<DataT, NoFlatObject>;
+    using Base::Base;
+};
+
+template <typename DataT, class FlatBase>
+template <typename Spline1DContainerBase<DataT, FlatBase>::SafetyLevel SafeT>
+GPUdi() int32_t Spline1DContainerBase<DataT, FlatBase>::getLeftKnotIndexForU(DataT u) const
 {
   /// Get i: u is in [knot_i, knot_{i+1}) segment
   /// when u is otside of [0, mUmax], return a corresponding edge segment
@@ -272,8 +297,8 @@ GPUdi() int32_t Spline1DContainer<DataT>::getLeftKnotIndexForU(DataT u) const
   return getUtoKnotMap()[iu];
 }
 
-template <typename DataT>
-GPUdi() void Spline1DContainer<DataT>::setXrange(DataT xMin, DataT xMax)
+template <typename DataT, class FlatBase>
+GPUdi() void Spline1DContainerBase<DataT, FlatBase>::setXrange(DataT xMin, DataT xMax)
 {
   mXmin = xMin;
   double l = ((double)xMax) - xMin;
@@ -303,17 +328,17 @@ GPUdi() void Spline1DContainer<DataT>::setXrange(DataT xMin, DataT xMax)
 ///  2 - nYdim<0: nYdim must be set during runtime
 ///  3 - specialization where nYdim==1 (a small add-on on top of the other specs)
 ///
-template <typename DataT, int32_t YdimT, int32_t SpecT>
+template <typename DataT, int32_t YdimT, int32_t SpecT, class FlatBase = FlatObject>
 class Spline1DSpec;
 
 /// ==================================================================================================
 /// Specialization 0 declares common methods for all other Spline2D specializations.
 /// Implementations of the methods may depend on the YdimT value.
 ///
-template <typename DataT, int32_t YdimT>
-class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
+template <typename DataT, int32_t YdimT, class FlatBase>
+class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<DataT, FlatBase>
 {
-  typedef Spline1DContainer<DataT> TBase;
+  typedef Spline1DContainerBase<DataT, FlatBase> TBase;
 
  public:
   typedef typename TBase::SafetyLevel SafetyLevel;
@@ -453,19 +478,19 @@ class Spline1DSpec<DataT, YdimT, 0> : public Spline1DContainer<DataT>
 /// Specialization 1: YdimT>0 where the number of Y dimensions is taken from template parameters
 /// at the compile time
 ///
-template <typename DataT, int32_t YdimT>
-class Spline1DSpec<DataT, YdimT, 1>
-  : public Spline1DSpec<DataT, YdimT, 0>
+template <typename DataT, int32_t YdimT, class FlatBase>
+class Spline1DSpec<DataT, YdimT, 1, FlatBase>
+  : public Spline1DSpec<DataT, YdimT, 0, FlatBase>
 {
-  typedef Spline1DContainer<DataT> TVeryBase;
-  typedef Spline1DSpec<DataT, YdimT, 0> TBase;
+  typedef Spline1DContainerBase<DataT, FlatBase> TVeryBase;
+  typedef Spline1DSpec<DataT, YdimT, 0, FlatBase> TBase;
 
  public:
   typedef typename TVeryBase::SafetyLevel SafetyLevel;
 
 #if !defined(GPUCA_GPUCODE)
-  /// Default constructor
-  Spline1DSpec() : Spline1DSpec(2) {}
+  /// Default constructor — skips recreate for NoFlatObject (no owned buffer)
+  Spline1DSpec() : TBase() { if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) { recreate(2); } }
 
   /// Constructor for a regular spline
   Spline1DSpec(int32_t numberOfKnots) : TBase()
@@ -544,19 +569,19 @@ class Spline1DSpec<DataT, YdimT, 1>
 /// Specialization 2 (YdimT<=0) where the numbaer of Y dimensions
 /// must be set in the runtime via a constructor parameter
 ///
-template <typename DataT, int32_t YdimT>
-class Spline1DSpec<DataT, YdimT, 2>
-  : public Spline1DSpec<DataT, YdimT, 0>
+template <typename DataT, int32_t YdimT, class FlatBase>
+class Spline1DSpec<DataT, YdimT, 2, FlatBase>
+  : public Spline1DSpec<DataT, YdimT, 0, FlatBase>
 {
-  typedef Spline1DContainer<DataT> TVeryBase;
-  typedef Spline1DSpec<DataT, YdimT, 0> TBase;
+  typedef Spline1DContainerBase<DataT, FlatBase> TVeryBase;
+  typedef Spline1DSpec<DataT, YdimT, 0, FlatBase> TBase;
 
  public:
   typedef typename TVeryBase::SafetyLevel SafetyLevel;
 
 #if !defined(GPUCA_GPUCODE)
-  /// Default constructor
-  Spline1DSpec() : Spline1DSpec(0, 2) {}
+  /// Default constructor — skips recreate for NoFlatObject (no owned buffer)
+  Spline1DSpec() : TBase() { if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) { TBase::recreate(0, 2); } }
 
   /// Constructor for a regular spline
   Spline1DSpec(int32_t nYdim, int32_t numberOfKnots) : TBase()
@@ -592,11 +617,11 @@ class Spline1DSpec<DataT, YdimT, 2>
 /// ==================================================================================================
 /// Specialization 3, where the number of Y dimensions is 1.
 ///
-template <typename DataT>
-class Spline1DSpec<DataT, 1, 3>
-  : public Spline1DSpec<DataT, 1, SplineUtil::getSpec(999)>
+template <typename DataT, class FlatBase>
+class Spline1DSpec<DataT, 1, 3, FlatBase>
+  : public Spline1DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase>
 {
-  typedef Spline1DSpec<DataT, 1, SplineUtil::getSpec(999)> TBase;
+  typedef Spline1DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase> TBase;
 
  public:
   using TBase::TBase; // inherit constructors
diff --git a/GPU/TPCFastTransformation/Spline2D.h b/GPU/TPCFastTransformation/Spline2D.h
index 19f9fc7b55b91..fdd7d1a65d3f9 100644
--- a/GPU/TPCFastTransformation/Spline2D.h
+++ b/GPU/TPCFastTransformation/Spline2D.h
@@ -70,12 +70,14 @@ namespace gpu
 ///    YdimT = 0 : the number of Y dimensions will be set in the runtime
 ///    YdimT < 0 : the number of Y dimensions will be set in the runtime, and it will not exceed abs(YdimT)
 ///
-template <typename DataT, int32_t YdimT = 0>
-class Spline2D
-  : public Spline2DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT)>
+/// Common implementation (no ClassDefNV — ROOT dictionary is in the FlatObject specialization below)
+template <typename DataT, int32_t YdimT, class FlatBase>
+class Spline2DBase
+  : public Spline2DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase>
 {
-  typedef Spline2DContainer<DataT> TVeryBase;
-  typedef Spline2DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT)> TBase;
+ protected:
+  typedef Spline2DContainerBase<DataT, FlatBase> TVeryBase;
+  typedef Spline2DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase> TBase;
 
  public:
   typedef typename TVeryBase::SafetyLevel SafetyLevel;
@@ -84,29 +86,51 @@ class Spline2D
 #if !defined(GPUCA_GPUCODE)
   using TBase::TBase; // inherit constructors
 
-  /// Assignment operator
-  Spline2D& operator=(const Spline2D& v)
+  Spline2DBase& operator=(const Spline2DBase& v)
   {
-    TVeryBase::cloneFromObject(v, nullptr);
+    static_cast<TVeryBase*>(this)->cloneFromObject(v, nullptr);
     return *this;
   }
 #else
-  /// Disable constructors for the GPU implementation
-  Spline2D() = delete;
-  Spline2D(const Spline2D&) = delete;
+  Spline2DBase() = delete;
+  Spline2DBase(const Spline2DBase&) = delete;
 #endif
 
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
-  /// read a class object from the file
-  static Spline2D* readFromFile(TFile& inpf, const char* name)
+  static Spline2DBase* readFromFile(TFile& inpf, const char* name)
   {
-    return (Spline2D*)TVeryBase::readFromFile(inpf, name);
+    return (Spline2DBase*)TVeryBase::readFromFile(inpf, name);
   }
 #endif
+};
 
+/// Forward declaration — specializations below select ClassDefNV based on FlatBase
+template <typename DataT, int32_t YdimT = 0, class FlatBase = FlatObject>
+class Spline2D;
+
+/// FlatObject specialization — carries ClassDefNV for ROOT I/O
+template <typename DataT, int32_t YdimT>
+class Spline2D<DataT, YdimT, FlatObject> : public Spline2DBase<DataT, YdimT, FlatObject>
+{
+ public:
+  using Spline2DBase<DataT, YdimT, FlatObject>::Spline2DBase;
+#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+  static Spline2D* readFromFile(TFile& inpf, const char* name)
+  {
+    return (Spline2D*)Spline2DContainerBase<DataT, FlatObject>::readFromFile(inpf, name);
+  }
+#endif
   ClassDefNV(Spline2D, 0);
 };
 
+/// NoFlatObject specialization — no ROOT ClassDef overhead
+template <typename DataT, int32_t YdimT>
+class Spline2D<DataT, YdimT, NoFlatObject> : public Spline2DBase<DataT, YdimT, NoFlatObject>
+{
+ public:
+  using Spline2DBase<DataT, YdimT, NoFlatObject>::Spline2DBase;
+};
+
 } // namespace gpu
 } // namespace o2
 
diff --git a/GPU/TPCFastTransformation/Spline2DHelper.cxx b/GPU/TPCFastTransformation/Spline2DHelper.cxx
index a93e753942dce..113ee4cd37370 100644
--- a/GPU/TPCFastTransformation/Spline2DHelper.cxx
+++ b/GPU/TPCFastTransformation/Spline2DHelper.cxx
@@ -230,7 +230,7 @@ void Spline2DHelper<DataT>::approximateFunction(
 
 template <typename DataT>
 void Spline2DHelper<DataT>::approximateFunctionViaDataPoints(
-  Spline2DContainer<DataT>& spline,
+  Spline2DContainerBase<DataT, FlatObject>& spline,
   double x1Min, double x1Max, double x2Min, double x2Max,
   std::function<void(double x1, double x2, double f[/*spline.getYdimensions()*/])> F,
   int32_t nAuxiliaryDataPointsU1, int32_t nAuxiliaryDataPointsU2)
@@ -262,7 +262,7 @@ void Spline2DHelper<DataT>::approximateFunctionViaDataPoints(
 }
 
 template <typename DataT>
-void Spline2DHelper<DataT>::setGrid(Spline2DContainer<DataT>& spline, double x1Min, double x1Max, double x2Min, double x2Max)
+void Spline2DHelper<DataT>::setGrid(Spline2DContainerBase<DataT, FlatObject>& spline, double x1Min, double x1Max, double x2Min, double x2Max)
 {
   mFdimensions = spline.getYdimensions();
   spline.setXrange(x1Min, x1Max, x2Min, x2Max);
@@ -326,7 +326,7 @@ void Spline2DHelper<DataT>::getScoefficients(int32_t iu, int32_t iv, double u, d
 
 template <typename DataT>
 void Spline2DHelper<DataT>::approximateDataPoints(
-  Spline2DContainer<DataT>& spline, DataT* splineParameters, double x1Min, double x1Max, double x2Min, double x2Max,
+  Spline2DContainerBase<DataT, FlatObject>& spline, DataT* splineParameters, double x1Min, double x1Max, double x2Min, double x2Max,
   const double dataPointX1[], const double dataPointX2[], const double dataPointF[/*getNumberOfDataPoints() x nFdim*/],
   const double dataPointWeight[], int32_t nDataPoints)
 {
diff --git a/GPU/TPCFastTransformation/Spline2DHelper.h b/GPU/TPCFastTransformation/Spline2DHelper.h
index aa52c306a1a53..ff3adb4831c28 100644
--- a/GPU/TPCFastTransformation/Spline2DHelper.h
+++ b/GPU/TPCFastTransformation/Spline2DHelper.h
@@ -58,28 +58,28 @@ class Spline2DHelper
 
   /// Create best-fit spline parameters for a given input function F
   void approximateFunction(
-    Spline2DContainer<DataT>& spline,
+    Spline2DContainerBase<DataT, FlatObject>& spline,
     double x1Min, double x1Max, double x2Min, double x2Max,
     std::function<void(double x1, double x2, double f[/*spline.getYdimensions()*/])> F,
     int32_t nAuxiliaryDataPointsU1 = 4, int32_t nAuxiliaryDataPointsU2 = 4);
 
   // A wrapper around approximateDataPoints()
   void approximateFunctionViaDataPoints(
-    Spline2DContainer<DataT>& spline,
+    Spline2DContainerBase<DataT, FlatObject>& spline,
     double x1Min, double x1Max, double x2Min, double x2Max,
     std::function<void(double x1, double x2, double f[/*spline.getYdimensions()*/])> F,
     int32_t nAuxiliaryDataPointsU1 = 4, int32_t nAuxiliaryDataPointsU2 = 4);
 
   /// Create best-fit spline parameters for a given set of data points
   void approximateDataPoints(
-    Spline2DContainer<DataT>& spline, DataT* splineParameters, double x1Min, double x1Max, double x2Min, double x2Max,
+    Spline2DContainerBase<DataT, FlatObject>& spline, DataT* splineParameters, double x1Min, double x1Max, double x2Min, double x2Max,
     const double dataPointX1[/*nDataPoints*/], const double dataPointX2[/*nDataPoints*/],
     const double dataPointF[/*nDataPoints x spline.getYdimensions*/], const double dataPointWeight[/*nDataPoints*/], int32_t nDataPoints);
 
   /// _______________   Interface for a step-wise construction of the best-fit spline   ________________________
 
   /// precompute everything needed for the construction
-  int32_t setSpline(const Spline2DContainer<DataT>& spline, int32_t nAuxiliaryPointsU1, int32_t nAuxiliaryPointsU2);
+  int32_t setSpline(const Spline2DContainerBase<DataT, FlatObject>& spline, int32_t nAuxiliaryPointsU1, int32_t nAuxiliaryPointsU2);
 
   /// approximate std::function, output in Fparameters
   void approximateFunction(
@@ -116,7 +116,7 @@ class Spline2DHelper
 #endif
 
  private:
-  void setGrid(Spline2DContainer<DataT>& spline, double x1Min, double x1Max, double x2Min, double x2Max);
+  void setGrid(Spline2DContainerBase<DataT, FlatObject>& spline, double x1Min, double x1Max, double x2Min, double x2Max);
   void getScoefficients(int32_t iu, int32_t iv, double u, double v,
                         double c[16], int32_t indices[16]);
 
@@ -135,7 +135,7 @@ class Spline2DHelper
 
 template <typename DataT>
 void Spline2DHelper<DataT>::approximateFunction(
-  Spline2DContainer<DataT>& spline,
+  Spline2DContainerBase<DataT, FlatObject>& spline,
   double x1Min, double x1Max, double x2Min, double x2Max,
   std::function<void(double x1, double x2, double f[/*spline.getYdimensions()*/])> F,
   int32_t nAuxiliaryDataPointsU1, int32_t nAuxiliaryDataPointsU2)
@@ -148,7 +148,7 @@ void Spline2DHelper<DataT>::approximateFunction(
 
 template <typename DataT>
 int32_t Spline2DHelper<DataT>::setSpline(
-  const Spline2DContainer<DataT>& spline, int32_t nAuxiliaryPointsU, int32_t nAuxiliaryPointsV)
+  const Spline2DContainerBase<DataT, FlatObject>& spline, int32_t nAuxiliaryPointsU, int32_t nAuxiliaryPointsV)
 {
   // Prepare creation of 2D irregular spline
   // The should be at least one (better, two) Auxiliary measurements on each segnment between two knots and at least 2*nKnots measurements in total
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.cxx b/GPU/TPCFastTransformation/Spline2DSpec.cxx
index 87d09ef26aa93..9dbaa71f0c365 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline2DSpec.cxx
@@ -30,7 +30,7 @@
 #include "TFile.h"
 #include "GPUCommonMath.h"
 
-templateClassImp(o2::gpu::Spline2DContainer);
+templateClassImp(o2::gpu::Spline2DContainerBase);
 templateClassImp(o2::gpu::Spline2DSpec);
 
 #endif
@@ -38,51 +38,49 @@ templateClassImp(o2::gpu::Spline2DSpec);
 using namespace std;
 using namespace o2::gpu;
 
-template <typename DataT>
-void Spline2DContainer<DataT>::destroy()
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::destroy()
 {
   /// See FlatObject for description
   mGridX1.destroy();
   mGridX2.destroy();
   mYdim = 0;
   mParameters = nullptr;
-  FlatObject::destroy();
+  FlatBase::destroy();
 }
 
-template <typename DataT>
-void Spline2DContainer<DataT>::setActualBufferAddress(char* actualFlatBufferPtr)
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::setActualBufferAddress(char* actualFlatBufferPtr)
 {
   /// See FlatObject for description
 
-  FlatObject::setActualBufferAddress(actualFlatBufferPtr);
+  FlatBase::setActualBufferAddress(actualFlatBufferPtr);
 
-  const size_t u2Offset = alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
+  const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
   int32_t parametersOffset = u2Offset;
-  // int32_t bufferSize = parametersOffset;
   mParameters = nullptr;
 
-  parametersOffset = alignSize(u2Offset + mGridX2.getFlatBufferSize(), getParameterAlignmentBytes());
-  // bufferSize = parametersOffset + getSizeOfParameters();
-  mParameters = reinterpret_cast<DataT*>(mFlatBufferPtr + parametersOffset);
+  parametersOffset = this->alignSize(u2Offset + mGridX2.getFlatBufferSize(), getParameterAlignmentBytes());
+  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
 
-  mGridX1.setActualBufferAddress(mFlatBufferPtr);
-  mGridX2.setActualBufferAddress(mFlatBufferPtr + u2Offset);
+  mGridX1.setActualBufferAddress(this->mFlatBufferPtr);
+  mGridX2.setActualBufferAddress(this->mFlatBufferPtr + u2Offset);
 }
 
-template <typename DataT>
-void Spline2DContainer<DataT>::setFutureBufferAddress(char* futureFlatBufferPtr)
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::setFutureBufferAddress(char* futureFlatBufferPtr)
 {
   /// See FlatObject for description
-  char* bufferU = relocatePointer(mFlatBufferPtr, futureFlatBufferPtr, mGridX1.getFlatBufferPtr());
-  char* bufferV = relocatePointer(mFlatBufferPtr, futureFlatBufferPtr, mGridX2.getFlatBufferPtr());
+  char* bufferU = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mGridX1.getFlatBufferPtr());
+  char* bufferV = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mGridX2.getFlatBufferPtr());
   mGridX1.setFutureBufferAddress(bufferU);
   mGridX2.setFutureBufferAddress(bufferV);
-  mParameters = relocatePointer(mFlatBufferPtr, futureFlatBufferPtr, mParameters);
-  FlatObject::setFutureBufferAddress(futureFlatBufferPtr);
+  mParameters = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mParameters);
+  FlatBase::setFutureBufferAddress(futureFlatBufferPtr);
 }
 
-template <typename DataT>
-void Spline2DContainer<DataT>::print() const
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::print() const
 {
   printf(" Irregular Spline 2D: \n");
   printf(" grid U1: \n");
@@ -91,93 +89,106 @@ void Spline2DContainer<DataT>::print() const
   mGridX2.print();
 }
 
-template <typename DataT>
-void Spline2DContainer<DataT>::cloneFromObject(const Spline2DContainer<DataT>& obj, char* newFlatBufferPtr)
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::cloneFromObject(const Spline2DContainerBase<DataT, FlatBase>& obj, char* newFlatBufferPtr)
 {
   /// See FlatObject for description
 
   const char* oldFlatBufferPtr = obj.mFlatBufferPtr;
 
-  FlatObject::cloneFromObject(obj, newFlatBufferPtr);
+  FlatBase::cloneFromObject(obj, newFlatBufferPtr);
 
   mYdim = obj.mYdim;
-  char* bufferU = FlatObject::relocatePointer(oldFlatBufferPtr, mFlatBufferPtr, obj.mGridX1.getFlatBufferPtr());
-  char* bufferV = FlatObject::relocatePointer(oldFlatBufferPtr, mFlatBufferPtr, obj.mGridX2.getFlatBufferPtr());
+  char* bufferU = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mGridX1.getFlatBufferPtr());
+  char* bufferV = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mGridX2.getFlatBufferPtr());
 
   mGridX1.cloneFromObject(obj.mGridX1, bufferU);
   mGridX2.cloneFromObject(obj.mGridX2, bufferV);
-  mParameters = FlatObject::relocatePointer(oldFlatBufferPtr, mFlatBufferPtr, obj.mParameters);
+  mParameters = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mParameters);
 }
 
-template <typename DataT>
-void Spline2DContainer<DataT>::moveBufferTo(char* newFlatBufferPtr)
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::moveBufferTo(char* newFlatBufferPtr)
 {
   /// See FlatObject for description
-  char* oldFlatBufferPtr = mFlatBufferPtr;
-  FlatObject::moveBufferTo(newFlatBufferPtr);
-  char* currFlatBufferPtr = mFlatBufferPtr;
-  mFlatBufferPtr = oldFlatBufferPtr;
+  char* oldFlatBufferPtr = this->mFlatBufferPtr;
+  FlatBase::moveBufferTo(newFlatBufferPtr);
+  char* currFlatBufferPtr = this->mFlatBufferPtr;
+  this->mFlatBufferPtr = oldFlatBufferPtr;
   setActualBufferAddress(currFlatBufferPtr);
 }
 
-template <typename DataT>
-void Spline2DContainer<DataT>::recreate(
+template <typename DataT, class FlatBase>
+template <class OtherFlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::importFrom(const Spline2DContainerBase<DataT, OtherFlatBase>& src)
+{
+  /// Copy schema fields from a spline with a different FlatBase (e.g. FlatObject -> NoFlatObject).
+  /// Grid pointers (mKnots, mUtoKnotMap) and mParameters are left null; call setActualBufferAddress() afterward.
+  mYdim = src.getYdimensions();
+  this->mFlatBufferSize = src.getFlatBufferSize();
+  mGridX1.importFrom(src.getGridX1());
+  mGridX2.importFrom(src.getGridX2());
+  mParameters = nullptr;
+}
+
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::recreate(
   int32_t nYdim,
   int32_t numberOfKnotsU1, const int32_t knotsU1[], int32_t numberOfKnotsU2, const int32_t knotsU2[])
 {
   /// Constructor for an irregular spline
 
   mYdim = nYdim;
-  FlatObject::startConstruction();
+  FlatBase::startConstruction();
 
   mGridX1.recreate(0, numberOfKnotsU1, knotsU1);
   mGridX2.recreate(0, numberOfKnotsU2, knotsU2);
 
-  const size_t u2Offset = alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
+  const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
   int32_t parametersOffset = u2Offset + mGridX2.getFlatBufferSize();
   int32_t bufferSize = parametersOffset;
   mParameters = nullptr;
 
-  parametersOffset = alignSize(bufferSize, getParameterAlignmentBytes());
+  parametersOffset = this->alignSize(bufferSize, getParameterAlignmentBytes());
   bufferSize = parametersOffset + getSizeOfParameters();
 
-  FlatObject::finishConstruction(bufferSize);
+  FlatBase::finishConstruction(bufferSize);
 
-  mGridX1.moveBufferTo(mFlatBufferPtr);
-  mGridX2.moveBufferTo(mFlatBufferPtr + u2Offset);
+  mGridX1.moveBufferTo(this->mFlatBufferPtr);
+  mGridX2.moveBufferTo(this->mFlatBufferPtr + u2Offset);
 
-  mParameters = reinterpret_cast<DataT*>(mFlatBufferPtr + parametersOffset);
+  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
   for (int32_t i = 0; i < getNumberOfParameters(); i++) {
     mParameters[i] = 0;
   }
 }
 
-template <typename DataT>
-void Spline2DContainer<DataT>::recreate(int32_t nYdim,
-                                        int32_t numberOfKnotsU1, int32_t numberOfKnotsU2)
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim,
+                                                  int32_t numberOfKnotsU1, int32_t numberOfKnotsU2)
 {
   /// Constructor for a regular spline
 
   mYdim = nYdim;
-  FlatObject::startConstruction();
+  FlatBase::startConstruction();
 
   mGridX1.recreate(0, numberOfKnotsU1);
   mGridX2.recreate(0, numberOfKnotsU2);
 
-  const size_t u2Offset = alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
+  const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
   int32_t parametersOffset = u2Offset + mGridX2.getFlatBufferSize();
   int32_t bufferSize = parametersOffset;
   mParameters = nullptr;
 
-  parametersOffset = alignSize(bufferSize, getParameterAlignmentBytes());
+  parametersOffset = this->alignSize(bufferSize, getParameterAlignmentBytes());
   bufferSize = parametersOffset + getSizeOfParameters();
 
-  FlatObject::finishConstruction(bufferSize);
+  FlatBase::finishConstruction(bufferSize);
 
-  mGridX1.moveBufferTo(mFlatBufferPtr);
-  mGridX2.moveBufferTo(mFlatBufferPtr + u2Offset);
+  mGridX1.moveBufferTo(this->mFlatBufferPtr);
+  mGridX2.moveBufferTo(this->mFlatBufferPtr + u2Offset);
 
-  mParameters = reinterpret_cast<DataT*>(mFlatBufferPtr + parametersOffset);
+  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
   for (int32_t i = 0; i < getNumberOfParameters(); i++) {
     mParameters[i] = 0;
   }
@@ -185,8 +196,8 @@ void Spline2DContainer<DataT>::recreate(int32_t nYdim,
 
 #if !defined(GPUCA_STANDALONE) // code invisible in the standalone compilation
 
-template <typename DataT>
-void Spline2DContainer<DataT>::approximateFunction(
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::approximateFunction(
   double x1Min, double x1Max, double x2Min, double x2Max,
   std::function<void(double x1, double x2, double f[])> F,
   int32_t nAuxiliaryDataPointsX1, int32_t nAuxiliaryDataPointsX2)
@@ -196,8 +207,8 @@ void Spline2DContainer<DataT>::approximateFunction(
   helper.approximateFunction(*reinterpret_cast<Spline2D<DataT>*>(this), x1Min, x1Max, x2Min, x2Max, F, nAuxiliaryDataPointsX1, nAuxiliaryDataPointsX2);
 }
 
-template <typename DataT>
-void Spline2DContainer<DataT>::approximateFunctionViaDataPoints(
+template <typename DataT, class FlatBase>
+void Spline2DContainerBase<DataT, FlatBase>::approximateFunctionViaDataPoints(
   double x1Min, double x1Max, double x2Min, double x2Max,
   std::function<void(double x1, double x2, double f[])> F,
   int32_t nAuxiliaryDataPointsX1, int32_t nAuxiliaryDataPointsX2)
@@ -207,28 +218,42 @@ void Spline2DContainer<DataT>::approximateFunctionViaDataPoints(
   helper.approximateFunctionViaDataPoints(*reinterpret_cast<Spline2D<DataT>*>(this), x1Min, x1Max, x2Min, x2Max, F, nAuxiliaryDataPointsX1, nAuxiliaryDataPointsX2);
 }
 
-template <typename DataT>
-int32_t Spline2DContainer<DataT>::writeToFile(TFile& outf, const char* name)
+template <typename DataT, class FlatBase>
+int32_t Spline2DContainerBase<DataT, FlatBase>::writeToFile(TFile& outf, const char* name)
 {
   /// write a class object to the file
-  return FlatObject::writeToFile(*this, outf, name);
+  if constexpr (std::is_same_v<FlatBase, FlatObject>) {
+    return FlatObject::writeToFile(*this, outf, name);
+  } else {
+    return -1;
+  }
 }
 
-template <typename DataT>
-Spline2DContainer<DataT>* Spline2DContainer<DataT>::readFromFile(
-  TFile& inpf, const char* name)
+template <typename DataT, class FlatBase>
+Spline2DContainerBase<DataT, FlatBase>* Spline2DContainerBase<DataT, FlatBase>::readFromFile(TFile& inpf, const char* name)
 {
   /// read a class object from the file
-  return FlatObject::readFromFile<Spline2DContainer<DataT>>(inpf, name);
+  if constexpr (std::is_same_v<FlatBase, FlatObject>) {
+    return FlatObject::readFromFile<Spline2DContainerBase<DataT, FlatBase>>(inpf, name);
+  } else {
+    return nullptr;
+  }
 }
 
-template <typename DataT>
-int32_t Spline2DContainer<DataT>::test(const bool draw, const bool drawDataPoints)
+template <typename DataT, class FlatBase>
+int32_t Spline2DContainerBase<DataT, FlatBase>::test(const bool draw, const bool drawDataPoints)
 {
   return Spline2DHelper<DataT>::test(draw, drawDataPoints);
 }
 
 #endif // !GPUCA_STANDALONE
 
-template class o2::gpu::Spline2DContainer<float>;
-template class o2::gpu::Spline2DContainer<double>;
+template class o2::gpu::Spline2DContainerBase<float>;
+template class o2::gpu::Spline2DContainerBase<double>;
+
+// Explicit instantiations for NoFlatObject (used by TPCFastTransformPOD)
+template class o2::gpu::Spline2DContainerBase<float, o2::gpu::NoFlatObject>;
+template class o2::gpu::Spline2DContainerBase<double, o2::gpu::NoFlatObject>;
+// importFrom instantiation for the FlatObject -> NoFlatObject conversion used in create()
+template void o2::gpu::Spline2DContainerBase<float, o2::gpu::NoFlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline2DContainerBase<float, o2::gpu::FlatObject>&);
+template void o2::gpu::Spline2DContainerBase<double, o2::gpu::NoFlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline2DContainerBase<double, o2::gpu::FlatObject>&);
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index 26147ef926df0..3ce8affd4062e 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -21,6 +21,9 @@
 #include "FlatObject.h"
 #include "GPUCommonDef.h"
 #include "SplineUtil.h"
+#if !defined(GPUCA_GPUCODE)
+#include <type_traits>
+#endif
 
 #if !defined(__CLING__) && !defined(G__ROOT) && !defined(GPUCA_GPUCODE) && !defined(GPUCA_NO_VC)
 #include <Vc/Vc>
@@ -35,7 +38,7 @@ namespace gpu
 {
 
 /// ==================================================================================================
-/// The class Spline2DContainer is a base Spline2D class.
+/// The class Spline2DContainerBase is a base Spline2D class.
 /// It contains all the class members and those methods which only depends on the DataT data type.
 /// It also contains all non-inlined methods with the implementation in SplineSpec.cxx file.
 ///
@@ -43,8 +46,8 @@ namespace gpu
 /// For other possible data types one has to add the corresponding instantiation line
 /// at the end of the Spline2DSpec.cxx file
 ///
-template <typename DataT>
-class Spline2DContainer : public FlatObject
+template <typename DataT, class FlatBase = FlatObject>
+class Spline2DContainerBase : public FlatBase
 {
  public:
   typedef typename Spline1D<DataT>::SafetyLevel SafetyLevel;
@@ -58,13 +61,13 @@ class Spline2DContainer : public FlatObject
   /// _____________  C++ constructors / destructors __________________________
 
   /// Default constructor
-  Spline2DContainer() = default;
+  Spline2DContainerBase() = default;
 
   /// Disable all other constructors
-  Spline2DContainer(const Spline2DContainer&) = delete;
+  Spline2DContainerBase(const Spline2DContainerBase&) = delete;
 
   /// Destructor
-  ~Spline2DContainer() = default;
+  ~Spline2DContainerBase() = default;
 
   /// _______________  Construction interface  ________________________
 
@@ -86,7 +89,7 @@ class Spline2DContainer : public FlatObject
   int32_t writeToFile(TFile& outf, const char* name);
 
   /// read a class object from the file
-  static Spline2DContainer* readFromFile(TFile& inpf, const char* name);
+  static Spline2DContainerBase* readFromFile(TFile& inpf, const char* name);
 #endif
 
   /// _______________  Getters   ________________________
@@ -107,13 +110,13 @@ class Spline2DContainer : public FlatObject
   GPUd() int32_t getNumberOfKnots() const { return mGridX1.getNumberOfKnots() * mGridX2.getNumberOfKnots(); }
 
   /// Get 1-D grid for the X1 coordinate
-  GPUd() const Spline1D<DataT>& getGridX1() const { return mGridX1; }
+  GPUd() const Spline1D<DataT, 0, FlatBase>& getGridX1() const { return mGridX1; }
 
   /// Get 1-D grid for the X2 coordinate
-  GPUd() const Spline1D<DataT>& getGridX2() const { return mGridX2; }
+  GPUd() const Spline1D<DataT, 0, FlatBase>& getGridX2() const { return mGridX2; }
 
   /// Get 1-D grid for X1 or X2 coordinate
-  GPUd() const Spline1D<DataT>& getGrid(int32_t ix) const { return (ix == 0) ? mGridX1 : mGridX2; }
+  GPUd() const Spline1D<DataT, 0, FlatBase>& getGrid(int32_t ix) const { return (ix == 0) ? mGridX1 : mGridX2; }
 
   /// Get (u1,u2) of i-th knot
   GPUd() void getKnotU(int32_t iKnot, int32_t& u1, int32_t& u2) const
@@ -137,10 +140,10 @@ class Spline2DContainer : public FlatObject
   /// _______________  Technical stuff  ________________________
 
   /// Get offset of GridX1 flat data in the flat buffer
-  GPUd() size_t getGridX1Offset() const { return mGridX1.getFlatBufferPtr() - mFlatBufferPtr; }
+  GPUd() size_t getGridX1Offset() const { return mGridX1.getFlatBufferPtr() - this->mFlatBufferPtr; }
 
   /// Get offset of GridX2 flat data in the flat buffer
-  GPUd() size_t getGridX2Offset() const { return mGridX2.getFlatBufferPtr() - mFlatBufferPtr; }
+  GPUd() size_t getGridX2Offset() const { return mGridX2.getFlatBufferPtr() - this->mFlatBufferPtr; }
 
   /// Set X range
   GPUd() void setXrange(DataT x1Min, DataT x1Max, DataT x2Min, DataT x2Max)
@@ -166,15 +169,20 @@ class Spline2DContainer : public FlatObject
 
   /// _____________  FlatObject functionality, see FlatObject class for description  ____________
 
-  using FlatObject::getBufferAlignmentBytes;
-  using FlatObject::getClassAlignmentBytes;
+  using FlatBase::getBufferAlignmentBytes;
+  using FlatBase::getClassAlignmentBytes;
 
 #if !defined(GPUCA_GPUCODE)
-  void cloneFromObject(const Spline2DContainer& obj, char* newFlatBufferPtr);
+  void cloneFromObject(const Spline2DContainerBase& obj, char* newFlatBufferPtr);
   void moveBufferTo(char* newBufferPtr);
+
+  /// Copy schema fields (ydim, grid dimensions) from a spline with a different FlatBase.
+  /// Used by TPCFastTransformPOD::create() to populate NoFlatObject-based splines.
+  template <class OtherFlatBase>
+  void importFrom(const Spline2DContainerBase<DataT, OtherFlatBase>& src);
 #endif
 
-  using FlatObject::releaseInternalBuffer;
+  using FlatBase::releaseInternalBuffer;
 
   void destroy();
   void setActualBufferAddress(char* actualFlatBufferPtr);
@@ -191,12 +199,31 @@ class Spline2DContainer : public FlatObject
 
   /// _____________  Data members  ____________
 
-  int32_t mYdim = 0;            ///< dimentionality of F
-  Spline1D<DataT> mGridX1;      ///< grid for U axis
-  Spline1D<DataT> mGridX2;      ///< grid for V axis
+  int32_t mYdim = 0;                      ///< dimentionality of F
+  Spline1D<DataT, 0, FlatBase> mGridX1;   ///< grid for U axis
+  Spline1D<DataT, 0, FlatBase> mGridX2;   ///< grid for V axis
   DataT* mParameters = nullptr; //! (transient!!) F-dependent parameters of the spline
+};
+
+template <typename DataT, typename FlatBase = FlatObject>
+class Spline2DContainer; // forward declaration
+
+template <typename DataT>
+class Spline2DContainer<DataT, FlatObject> : public Spline2DContainerBase<DataT, FlatObject>
+{
+public:
+    using Base = Spline2DContainerBase<DataT, FlatObject>;
+    using Base::Base;
+
+    ClassDefNV(Spline2DContainer, 1);
+};
 
-  ClassDefNV(Spline2DContainer, 1);
+template <typename DataT>
+class Spline2DContainer<DataT, NoFlatObject> : public Spline2DContainerBase<DataT, NoFlatObject>
+{
+public:
+    using Base = Spline2DContainerBase<DataT, NoFlatObject>;
+    using Base::Base;
 };
 
 /// ==================================================================================================
@@ -217,18 +244,18 @@ class Spline2DContainer : public FlatObject
 ///  2 - nYdim<0: nYdim must be set during runtime
 ///  3 - specialization where nYdim==1 (a small add-on on top of the other specs)
 ///
-template <typename DataT, int32_t YdimT, int32_t SpecT>
+template <typename DataT, int32_t YdimT, int32_t SpecT, class FlatBase = FlatObject>
 class Spline2DSpec;
 
 /// ==================================================================================================
 /// Specialization 0 declares common methods for all other Spline2D specializations.
 /// Implementations of the methods may depend on the YdimT value.
 ///
-template <typename DataT, int32_t YdimT>
-class Spline2DSpec<DataT, YdimT, 0>
-  : public Spline2DContainer<DataT>
+template <typename DataT, int32_t YdimT, class FlatBase>
+class Spline2DSpec<DataT, YdimT, 0, FlatBase>
+  : public Spline2DContainerBase<DataT, FlatBase>
 {
-  typedef Spline2DContainer<DataT> TBase;
+  typedef Spline2DContainerBase<DataT, FlatBase> TBase;
 
  public:
   typedef typename TBase::SafetyLevel SafetyLevel;
@@ -533,11 +560,11 @@ class Spline2DSpec<DataT, YdimT, 0>
     // Use buffer-aware accessors instead of mGridX1.getLeftKnotIndexForU() and
     // mGridX1.getKnot(). Both of the standard versions dereference mFlatBufferPtr
     // (via mUtoKnotMap and the knot array), which is stale after cross-process copy.
-    int32_t iu = mGridX1.template getLeftKnotIndexForUFromBuffer<SafeT>(gridX1FlatBuf, u);
-    int32_t iv = mGridX2.template getLeftKnotIndexForUFromBuffer<SafeT>(gridX2FlatBuf, v);
+    int32_t iu = mGridX1.getLeftKnotIndexForUFromBuffer(gridX1FlatBuf, u);
+    int32_t iv = mGridX2.getLeftKnotIndexForUFromBuffer(gridX2FlatBuf, v);
 
-    const typename TBase::Knot& knotU = mGridX1.template getKnotFromBuffer<SafetyLevel::kNotSafe>(gridX1FlatBuf, iu);
-    const typename TBase::Knot& knotV = mGridX2.template getKnotFromBuffer<SafetyLevel::kNotSafe>(gridX2FlatBuf, iv);
+    const auto& knotU = mGridX1.template getKnotFromBuffer<decltype(mGridX1)::kNotSafe>(gridX1FlatBuf, iu);
+    const auto& knotV = mGridX2.template getKnotFromBuffer<decltype(mGridX2)::kNotSafe>(gridX2FlatBuf, iv);
 
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4;
     const DataT* B = A + nYdim4 * nu;
@@ -573,19 +600,19 @@ class Spline2DSpec<DataT, YdimT, 0>
 /// Specialization 1: YdimT>0 where the number of Y dimensions is taken from template parameters
 /// at the compile time
 ///
-template <typename DataT, int32_t YdimT>
-class Spline2DSpec<DataT, YdimT, 1>
-  : public Spline2DSpec<DataT, YdimT, 0>
+template <typename DataT, int32_t YdimT, class FlatBase>
+class Spline2DSpec<DataT, YdimT, 1, FlatBase>
+  : public Spline2DSpec<DataT, YdimT, 0, FlatBase>
 {
-  typedef Spline2DContainer<DataT> TVeryBase;
-  typedef Spline2DSpec<DataT, YdimT, 0> TBase;
+  typedef Spline2DContainerBase<DataT, FlatBase> TVeryBase;
+  typedef Spline2DSpec<DataT, YdimT, 0, FlatBase> TBase;
 
  public:
   typedef typename TVeryBase::SafetyLevel SafetyLevel;
 
 #if !defined(GPUCA_GPUCODE)
-  /// Default constructor
-  Spline2DSpec() : Spline2DSpec(2, 2) {}
+  /// Default constructor — skips recreate for NoFlatObject (no owned buffer)
+  Spline2DSpec() : TBase() { if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) { recreate(2, 2); } }
 
   /// Constructor for a regular spline
   Spline2DSpec(int32_t nKnotsX1, int32_t nKnotsX2) : TBase()
@@ -679,19 +706,19 @@ class Spline2DSpec<DataT, YdimT, 1>
 /// Specialization 2 (YdimT<=0) where the numbaer of Y dimensions
 /// must be set in the runtime via a constructor parameter
 ///
-template <typename DataT, int32_t YdimT>
-class Spline2DSpec<DataT, YdimT, 2>
-  : public Spline2DSpec<DataT, YdimT, 0>
+template <typename DataT, int32_t YdimT, class FlatBase>
+class Spline2DSpec<DataT, YdimT, 2, FlatBase>
+  : public Spline2DSpec<DataT, YdimT, 0, FlatBase>
 {
-  typedef Spline2DContainer<DataT> TVeryBase;
-  typedef Spline2DSpec<DataT, YdimT, 0> TBase;
+  typedef Spline2DContainerBase<DataT, FlatBase> TVeryBase;
+  typedef Spline2DSpec<DataT, YdimT, 0, FlatBase> TBase;
 
  public:
   typedef typename TVeryBase::SafetyLevel SafetyLevel;
 
 #if !defined(GPUCA_GPUCODE)
-  /// Default constructor
-  Spline2DSpec() : Spline2DSpec(0, 2, 2) {}
+  /// Default constructor — skips recreate for NoFlatObject (no owned buffer)
+  Spline2DSpec() : TBase() { if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) { TBase::recreate(0, 2, 2); } }
 
   /// Constructor for a regular spline
   Spline2DSpec(int32_t nYdim, int32_t nKnotsX1, int32_t nKnotsX2) : TBase()
@@ -735,11 +762,11 @@ class Spline2DSpec<DataT, YdimT, 2>
 /// ==================================================================================================
 /// Specialization 3, where the number of Y dimensions is 1.
 ///
-template <typename DataT>
-class Spline2DSpec<DataT, 1, 3>
-  : public Spline2DSpec<DataT, 1, SplineUtil::getSpec(999)>
+template <typename DataT, class FlatBase>
+class Spline2DSpec<DataT, 1, 3, FlatBase>
+  : public Spline2DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase>
 {
-  typedef Spline2DSpec<DataT, 1, SplineUtil::getSpec(999)> TBase;
+  typedef Spline2DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase> TBase;
 
  public:
   using TBase::TBase; // inherit constructors
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index aedb2531470fc..6ae8d4d01eaff 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -158,6 +158,12 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   typedef SplineTypeXYZ SplineType;
 
+  /// Slim variants (NoFlatObject base) for use in TPCFastTransformPOD
+  using SlimSplineTypeXYZ = Spline2D<float, 3, NoFlatObject>;
+  using SlimSplineTypeInvX = Spline2D<float, 1, NoFlatObject>;
+  using SlimSplineTypeInvYZ = Spline2D<float, 2, NoFlatObject>;
+  using SlimSplineType = SlimSplineTypeXYZ;
+
   /// _____________  Constructors / destructors __________________________
 
   /// Default constructor: creates an empty uninitialized object
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index ab0c7c2be82ed..a087b5259e351 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -59,10 +59,10 @@ size_t TPCFastTransformPOD::estimateSize(const TPCFastSpaceChargeCorrection& ori
   size_t nextDynOffs = alignOffset(selfSizeFix);
   nextDynOffs = alignOffset(nextDynOffs + origCorr.mNumberOfScenarios * sizeof(size_t)); // spline scenarios start here
   nextDynOffs = alignOffset(nextDynOffs + origCorr.mNumberOfScenarios * sizeof(size_t)); // flatBufOffs array
-  // space for splines
+  // space for splines (use sizeof(SplineType) = slim size, not the origCorr spline size)
   for (int isc = 0; isc < origCorr.mNumberOfScenarios; isc++) {
     const auto& spline = origCorr.mScenarioPtr[isc];
-    nextDynOffs = alignOffset(nextDynOffs + sizeof(spline));
+    nextDynOffs = alignOffset(nextDynOffs + sizeof(SplineType));
     nextDynOffs = alignOffset(nextDynOffs + spline.getFlatBufferSize());
   }
   // space for splines data
@@ -150,22 +150,22 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
   for (int isc = 0; isc < origCorr.mNumberOfScenarios; isc++) {
     scenOffs[isc] = nextDynOffs;
     const auto& spline = origCorr.mScenarioPtr[isc];
-    if (buffSize < nextDynOffs + sizeof(spline)) {
-      throw std::runtime_error(fmt::format("attempt to copy {} bytes for spline for scenario {} to {}, overflowing the buffer of size {}", sizeof(spline), isc, nextDynOffs + sizeof(spline), buffSize));
+    if (buffSize < nextDynOffs + sizeof(SplineType)) {
+      throw std::runtime_error(fmt::format("attempt to write {} bytes for slim spline for scenario {} to {}, overflowing the buffer of size {}", sizeof(SplineType), isc, nextDynOffs + sizeof(SplineType), buffSize));
     }
 
-    // copy spline object
-    std::memcpy(buff + scenOffs[isc], &spline, sizeof(spline));
-    nextDynOffs = alignOffset(nextDynOffs + sizeof(spline));
-    LOGP(debug, "Copy {} bytes for spline scenario {} (ptr:{}) to offsset {}", sizeof(spline), isc, (void*)&spline, scenOffs[isc]);
+    // Placement-new a slim (NoFlatObject) spline and populate its schema from the source
+    auto* slimSpline = new (buff + scenOffs[isc]) SplineType();
+    slimSpline->importFrom(spline);
+    nextDynOffs = alignOffset(nextDynOffs + sizeof(SplineType));
+    LOGP(debug, "Write {} bytes for slim spline scenario {} to offset {}", sizeof(SplineType), isc, scenOffs[isc]);
 
-    // copy spline flat buffer
-    flatBufOffs[isc] = nextDynOffs; // store flat buffer offset
+    // copy spline flat buffer (layout identical regardless of FlatBase)
+    flatBufOffs[isc] = nextDynOffs;
     std::memcpy(buff + nextDynOffs, spline.getFlatBufferPtr(), spline.getFlatBufferSize());
 
-    // fix up internal pointer
-    auto* splineInBuf = reinterpret_cast<SplineType*>(buff + scenOffs[isc]);
-    splineInBuf->setActualBufferAddress(buff + nextDynOffs);
+    // fix up internal pointers (mParameters, mGridX1.mKnots, mGridX2.mKnots)
+    slimSpline->setActualBufferAddress(buff + nextDynOffs);
 
     nextDynOffs = alignOffset(nextDynOffs + spline.getFlatBufferSize());
   }
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index d345d2f75d608..f89504212b2eb 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -55,10 +55,10 @@ class TPCFastTransformPOD
   using GridInfo = TPCFastSpaceChargeCorrection::GridInfo;
   using SectorRowInfo = TPCFastSpaceChargeCorrection::SectorRowInfo;
 
-  using SplineTypeXYZ = TPCFastSpaceChargeCorrection::SplineTypeXYZ;
-  using SplineTypeInvX = TPCFastSpaceChargeCorrection::SplineTypeInvX;
-  using SplineTypeInvYZ = TPCFastSpaceChargeCorrection::SplineTypeInvYZ;
-  using SplineType = TPCFastSpaceChargeCorrection::SplineType;
+  using SplineTypeXYZ = TPCFastSpaceChargeCorrection::SlimSplineTypeXYZ;
+  using SplineTypeInvX = TPCFastSpaceChargeCorrection::SlimSplineTypeInvX;
+  using SplineTypeInvYZ = TPCFastSpaceChargeCorrection::SlimSplineTypeInvYZ;
+  using SplineType = TPCFastSpaceChargeCorrection::SlimSplineType;
 
   /// convert prefilled buffer to TPCFastTransformPOD
   GPUd() static const TPCFastTransformPOD& get(const char* head) { return *reinterpret_cast<const TPCFastTransformPOD*>(head); }
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index 98e587102f875..e8afef4128874 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -23,10 +23,10 @@
 
 #pragma link C++ namespace o2::gpu;
 
-#pragma link C++ class o2::gpu::Spline1DContainer < float> + ;
-#pragma link C++ class o2::gpu::Spline1DContainer < double> + ;
-#pragma link C++ class o2::gpu::Spline1D < float> + ;
-#pragma link C++ class o2::gpu::Spline1D < double> + ;
+#pragma link C++ class o2::gpu::Spline1DContainer < float, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline1DContainer < double, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline1D < float, 0, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline1D < double, 0, o2::gpu::FlatObject> + ;
 #pragma link C++ class o2::gpu::Spline1DHelperOld < float> + ;
 #pragma link C++ class o2::gpu::Spline1DHelperOld < double> + ;
 #pragma link C++ class o2::gpu::Spline1DHelper < float> + ;
@@ -34,10 +34,10 @@
 #pragma link C++ class o2::gpu::Spline1DSpec < float, 0, 2> + ;
 #pragma link C++ class o2::gpu::Spline1DSpec < double, 0, 2> + ;
 
-#pragma link C++ class o2::gpu::Spline2DContainer < float> + ;
-#pragma link C++ class o2::gpu::Spline2DContainer < double> + ;
-#pragma link C++ class o2::gpu::Spline2D < float> + ;
-#pragma link C++ class o2::gpu::Spline2D < double> + ;
+#pragma link C++ class o2::gpu::Spline2DContainer < float, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline2DContainer < double, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline2D < float, 0, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline2D < double, 0, o2::gpu::FlatObject> + ;
 #pragma link C++ class o2::gpu::Spline2DHelper < float> + ;
 #pragma link C++ class o2::gpu::Spline2DHelper < double> + ;
 
diff --git a/GPU/Utils/FlatObject.h b/GPU/Utils/FlatObject.h
index 46fdec7703823..9cb7b7888a069 100644
--- a/GPU/Utils/FlatObject.h
+++ b/GPU/Utils/FlatObject.h
@@ -327,6 +327,45 @@ class FlatObject
   ClassDefNV(FlatObject, 1);
 };
 
+/// ==================================================================================================
+/// NoFlatObject: minimal drop-in base for use in POD / read-only contexts (e.g. TPCFastTransformPOD).
+/// Provides only the data and methods that are genuinely needed at runtime.
+/// No construction lifecycle, no owned buffer, no ROOT ClassDef.
+/// Use as the FlatBase template parameter: Spline2D<float, 3, NoFlatObject>
+class NoFlatObject
+{
+ public:
+  int32_t mFlatBufferSize = 0;
+  char* mFlatBufferPtr = nullptr;
+
+  static constexpr size_t getClassAlignmentBytes() { return 8; }
+  static constexpr size_t getBufferAlignmentBytes() { return 8; }
+
+  GPUdi() const char* getFlatBufferPtr() const { return mFlatBufferPtr; }
+  GPUdi() size_t getFlatBufferSize() const { return mFlatBufferSize; }
+  GPUdi() void setActualBufferAddress(char* ptr) { mFlatBufferPtr = ptr; }
+  GPUdi() void setFutureBufferAddress(char* ptr) { mFlatBufferPtr = ptr; }
+
+  // No-ops for lifecycle methods (never called in POD context, but needed for compilation)
+  void startConstruction() {}
+  void finishConstruction(int32_t sz) { mFlatBufferSize = sz; }
+  void cloneFromObject(const NoFlatObject& o, char* p) { mFlatBufferSize = o.mFlatBufferSize; mFlatBufferPtr = p; }
+  void moveBufferTo(char*) {}
+  void destroy() {}
+  char* releaseInternalBuffer() { char* p = mFlatBufferPtr; mFlatBufferPtr = nullptr; return p; }
+
+  template <class T>
+  GPUdi() static T* relocatePointer(const char* oldBase, char* newBase, const T* ptr)
+  {
+    return (ptr != nullptr) ? reinterpret_cast<T*>(newBase + (reinterpret_cast<const char*>(ptr) - oldBase)) : nullptr;
+  }
+  static constexpr size_t alignSize(size_t sizeBytes, size_t alignmentBytes)
+  {
+    auto res = sizeBytes % alignmentBytes;
+    return res ? sizeBytes + (alignmentBytes - res) : sizeBytes;
+  }
+};
+
 /// ========================================================================================================
 ///
 ///       Inline implementations of methods

From 796d60db5b80e29c1c9d722a22c47299459556f6 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Wed, 8 Apr 2026 13:11:48 +0200
Subject: [PATCH 1608/1764] removing remaining pointers and classdef from
 TPCFastTransformPOD

---
 Detectors/TPC/workflow/src/TPCScalerSpec.cxx  |   2 +-
 .../SectorTracker/GPUTPCTrackletConstructor.h |   2 +-
 GPU/TPCFastTransformation/Spline.h            |   3 +-
 GPU/TPCFastTransformation/Spline1D.h          |  22 +-
 GPU/TPCFastTransformation/Spline1DHelper.cxx  |  60 +--
 GPU/TPCFastTransformation/Spline1DHelper.h    |  26 +-
 .../Spline1DHelperOld.cxx                     |  60 +--
 GPU/TPCFastTransformation/Spline1DHelperOld.h |  24 +-
 GPU/TPCFastTransformation/Spline1DSpec.cxx    | 209 ++++----
 GPU/TPCFastTransformation/Spline1DSpec.h      | 459 ++++++++----------
 GPU/TPCFastTransformation/Spline2D.h          |  13 +-
 GPU/TPCFastTransformation/Spline2DHelper.cxx  |   4 +-
 GPU/TPCFastTransformation/Spline2DSpec.cxx    | 155 +++---
 GPU/TPCFastTransformation/Spline2DSpec.h      | 258 ++++------
 GPU/TPCFastTransformation/SplineSpec.h        |  16 +-
 .../TPCFastTransformPOD.cxx                   |   5 +
 GPU/Utils/FlatObject.h                        |  25 -
 17 files changed, 605 insertions(+), 738 deletions(-)

diff --git a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
index 09ffa644520cf..8db4399524662 100644
--- a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
@@ -220,7 +220,7 @@ class TPCScalerSpec : public Task
     Output corrMapOutput{header::gDataOriginTPC, "TPCCORRMAP", 0};
     auto outputBuffer = o2::pmr::vector<char>(pc.outputs().getMemoryResource(corrMapOutput));
     outputBuffer.resize(TPCFastTransformPOD::estimateSize(finalMap.getCorrection()));
-    auto* pod = TPCFastTransformPOD::create(outputBuffer.data(), outputBuffer.size(), finalMap.getCorrection());
+    auto* pod = TPCFastTransformPOD::create(outputBuffer.data(), outputBuffer.size(), finalMap);
     const auto& vd = mTPCVDriftHelper.getVDriftObject();
     o2::tpc::TPCFastTransformHelperO2::instance()->updateCalibration(*pod, 0, vd.corrFact, vd.refVDrift, vd.getTimeOffset());
     pc.outputs().adoptContainer(corrMapOutput, std::move(outputBuffer));
diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
index a2ffc900d3d1e..b52574e39a738 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCTrackletConstructor.h
@@ -63,7 +63,7 @@ class GPUTPCTrackletConstructor : public GPUKernelTemplate
 
   struct GPUSharedMemory {
     GPUCA_SHARED_STORAGE(GPUTPCRow mRows[GPUTPCGeometry::NROWS]); // rows
-    uint32_t mNStartHits;                                      // Total number of start hits
+    uint32_t mNStartHits;                                         // Total number of start hits
 
 #ifdef GPUCA_TRACKLET_CONSTRUCTOR_DO_PROFILE
     int32_t fMaxSync; // temporary shared variable during profile creation
diff --git a/GPU/TPCFastTransformation/Spline.h b/GPU/TPCFastTransformation/Spline.h
index ee3625a3793c1..477ba618999db 100644
--- a/GPU/TPCFastTransformation/Spline.h
+++ b/GPU/TPCFastTransformation/Spline.h
@@ -81,8 +81,7 @@ class Spline
   typedef SplineSpec<DataT, XdimT, YdimT, SplineUtil::getSpec(XdimT, YdimT)> TBase;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-  typedef typename TVeryBase::Knot Knot;
+  using KnotType = Knot<DataT>;
 
 #if !defined(GPUCA_GPUCODE)
   using TBase::TBase; // inherit constructors
diff --git a/GPU/TPCFastTransformation/Spline1D.h b/GPU/TPCFastTransformation/Spline1D.h
index 1835892298032..074cc7a8ffa56 100644
--- a/GPU/TPCFastTransformation/Spline1D.h
+++ b/GPU/TPCFastTransformation/Spline1D.h
@@ -140,24 +140,19 @@ class Spline1DBase
   : public Spline1DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase>
 {
  protected:
-  typedef Spline1DContainerBase<DataT, FlatBase> TVeryBase;
-  typedef Spline1DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase> TBase;
+  using Container = Spline1DContainer<DataT, FlatBase>;
+  using ParentSpec = Spline1DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase>;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-  typedef typename TVeryBase::Knot Knot;
-
 #if !defined(GPUCA_GPUCODE)
-  using TBase::TBase; // inherit constructors
-
   Spline1DBase() = default;
-  Spline1DBase(const Spline1DBase& v) : TBase(v)
+  Spline1DBase(const Spline1DBase& v) : ParentSpec(v)
   {
-    static_cast<TVeryBase*>(this)->cloneFromObject(v, nullptr);
+    static_cast<Container*>(this)->cloneFromObject(v, nullptr);
   }
   Spline1DBase& operator=(const Spline1DBase& v)
   {
-    static_cast<TVeryBase*>(this)->cloneFromObject(v, nullptr);
+    static_cast<Container*>(this)->cloneFromObject(v, nullptr);
     return *this;
   }
 #else
@@ -168,7 +163,7 @@ class Spline1DBase
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
   static Spline1DBase* readFromFile(TFile& inpf, const char* name)
   {
-    return (Spline1DBase*)TVeryBase::readFromFile(inpf, name);
+    return (Spline1DBase*)Container::readFromFile(inpf, name);
   }
 #endif
 };
@@ -182,11 +177,10 @@ template <typename DataT, int32_t YdimT>
 class Spline1D<DataT, YdimT, FlatObject> : public Spline1DBase<DataT, YdimT, FlatObject>
 {
  public:
-  using Spline1DBase<DataT, YdimT, FlatObject>::Spline1DBase;
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
   static Spline1D* readFromFile(TFile& inpf, const char* name)
   {
-    return (Spline1D*)Spline1DContainerBase<DataT, FlatObject>::readFromFile(inpf, name);
+    return (Spline1D*)Spline1DContainer<DataT, FlatObject>::readFromFile(inpf, name);
   }
 #endif
   ClassDefNV(Spline1D, 0);
@@ -196,8 +190,6 @@ class Spline1D<DataT, YdimT, FlatObject> : public Spline1DBase<DataT, YdimT, Fla
 template <typename DataT, int32_t YdimT>
 class Spline1D<DataT, YdimT, NoFlatObject> : public Spline1DBase<DataT, YdimT, NoFlatObject>
 {
- public:
-  using Spline1DBase<DataT, YdimT, NoFlatObject>::Spline1DBase;
 };
 
 } // namespace gpu
diff --git a/GPU/TPCFastTransformation/Spline1DHelper.cxx b/GPU/TPCFastTransformation/Spline1DHelper.cxx
index e2243d9c9a8a9..8afe907ff3631 100644
--- a/GPU/TPCFastTransformation/Spline1DHelper.cxx
+++ b/GPU/TPCFastTransformation/Spline1DHelper.cxx
@@ -50,7 +50,7 @@ int32_t Spline1DHelper<DataT>::storeError(int32_t code, const char* msg)
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::getScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+void Spline1DHelper<DataT>::getScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                              double& cSl, double& cDl, double& cSr, double& cDr)
 {
   /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
@@ -70,7 +70,7 @@ void Spline1DHelper<DataT>::getScoefficients(const typename Spline1D<double>::Kn
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::getDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+void Spline1DHelper<DataT>::getDScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                               double& cSl, double& cDl, double& cSr, double& cDr)
 {
   u = u - knotL.u;
@@ -86,7 +86,7 @@ void Spline1DHelper<DataT>::getDScoefficients(const typename Spline1D<double>::K
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::getDDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+void Spline1DHelper<DataT>::getDDScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                                double& cSl, double& cDl, double& cSr, double& cDr)
 {
   u = u - knotL.u;
@@ -99,7 +99,7 @@ void Spline1DHelper<DataT>::getDDScoefficients(const typename Spline1D<double>::
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::getDDScoefficientsLeft(const typename Spline1D<double>::Knot& knotL,
+void Spline1DHelper<DataT>::getDDScoefficientsLeft(const typename Spline1D<double>::KnotType& knotL,
                                                    double& cSl, double& cDl, double& cSr, double& cDr)
 {
   double dv = double(knotL.Li);
@@ -110,7 +110,7 @@ void Spline1DHelper<DataT>::getDDScoefficientsLeft(const typename Spline1D<doubl
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::getDDScoefficientsRight(const typename Spline1D<double>::Knot& knotL,
+void Spline1DHelper<DataT>::getDDScoefficientsRight(const typename Spline1D<double>::KnotType& knotL,
                                                     double& cSl, double& cDl, double& cSr, double& cDr)
 {
   double dv = double(knotL.Li);
@@ -121,7 +121,7 @@ void Spline1DHelper<DataT>::getDDScoefficientsRight(const typename Spline1D<doub
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::getDDDScoefficients(const typename Spline1D<double>::Knot& knotL,
+void Spline1DHelper<DataT>::getDDDScoefficients(const typename Spline1D<double>::KnotType& knotL,
                                                 double& cSl, double& cDl, double& cSr, double& cDr)
 {
   double dv = double(knotL.Li);
@@ -133,7 +133,7 @@ void Spline1DHelper<DataT>::getDDDScoefficients(const typename Spline1D<double>:
 
 template <typename DataT>
 void Spline1DHelper<DataT>::approximateDataPoints(
-  Spline1DContainerBase<DataT, FlatObject>& spline,
+  Spline1DContainer<DataT, FlatObject>& spline,
   double xMin, double xMax,
   const double vx[], const double vf[], int32_t nDataPoints)
 {
@@ -155,7 +155,7 @@ void Spline1DHelper<DataT>::approximateDataPoints(
   for (int32_t iPoint = 0; iPoint < nDataPoints; ++iPoint) {
     double u = mSpline.convXtoU(vx[iPoint]);
     int32_t iKnot = mSpline.getLeftKnotIndexForU(u);
-    const typename Spline1D<double>::Knot& knot0 = mSpline.getKnot(iKnot);
+    const typename Spline1D<double>::KnotType& knot0 = mSpline.getKnot(iKnot);
     double cS0, cZ0, cS1, cZ1;
     getScoefficients(knot0, u, cS0, cZ0, cS1, cZ1);
     double c[4] = {cS0, cZ0, cS1, cZ1};
@@ -177,9 +177,9 @@ void Spline1DHelper<DataT>::approximateDataPoints(
   }
 
   for (int32_t iKnot = 0; iKnot < spline.getNumberOfKnots() - 2; ++iKnot) {
-    const typename Spline1D<double>::Knot& knot0 = mSpline.getKnot(iKnot);
-    const typename Spline1D<double>::Knot& knot1 = mSpline.getKnot(iKnot + 1);
-    // const typename Spline1D<double>::Knot& knot2 = mSpline.getKnot(iKnot + 2);
+    const typename Spline1D<double>::KnotType& knot0 = mSpline.getKnot(iKnot);
+    const typename Spline1D<double>::KnotType& knot1 = mSpline.getKnot(iKnot + 1);
+    // const typename Spline1D<double>::KnotType& knot2 = mSpline.getKnot(iKnot + 2);
 
     // set S'' and S''' at knot1 equal at both sides
     // chi2 += w^2*(S''from the left - S'' from the right)^2
@@ -215,8 +215,8 @@ void Spline1DHelper<DataT>::approximateDataPoints(
   // experimental: set slopes at neighbouring knots equal - doesn't work
   /*
     for (int32_t iKnot = 0; iKnot < spline.getNumberOfKnots() - 2; ++iKnot) {
-      const typename Spline1D<double>::Knot& knot0 = mSpline.getKnot(iKnot);
-      const typename Spline1D<double>::Knot& knot1 = mSpline.getKnot(iKnot + 1);
+      const typename Spline1D<double>::KnotType& knot0 = mSpline.getKnot(iKnot);
+      const typename Spline1D<double>::KnotType& knot1 = mSpline.getKnot(iKnot + 1);
       double w = 1.;
       int32_t i = 2 * iKnot; // index of parameter S0
       double d = knot1.u - knot0.u;
@@ -246,7 +246,7 @@ void Spline1DHelper<DataT>::approximateDataPoints(
 
 template <typename DataT>
 void Spline1DHelper<DataT>::approximateDerivatives(
-  Spline1DContainerBase<DataT, FlatObject>& spline,
+  Spline1DContainer<DataT, FlatObject>& spline,
   const double vx[], const double vf[], int32_t nDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -265,7 +265,7 @@ void Spline1DHelper<DataT>::approximateDerivatives(
   for (int32_t iPoint = 0; iPoint < nDataPoints; ++iPoint) {
     double u = mSpline.convXtoU(vx[iPoint]);
     int32_t iKnot = mSpline.getLeftKnotIndexForU(u);
-    const typename Spline1D<double>::Knot& knot0 = mSpline.getKnot(iKnot);
+    const typename Spline1D<double>::KnotType& knot0 = mSpline.getKnot(iKnot);
     double cS0, cZ0, cS1, cZ1;
     getScoefficients(knot0, u, cS0, cZ0, cS1, cZ1);
     double c[2] = {cZ0, cZ1};
@@ -298,7 +298,7 @@ void Spline1DHelper<DataT>::approximateDerivatives(
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<DataT, FlatObject>& spline,
+void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainer<DataT, FlatObject>& spline,
                                                        double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F)
 {
   /// Create classic spline parameters for a given input function F
@@ -322,7 +322,7 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<Dat
 
   // second derivative at knot0 is 0
   {
-    const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(0);
+    const typename Spline1D<DataT>::KnotType& knot0 = spline.getKnot(0);
     double cZ0 = (-4) * knot0.Li;
     double cZ1 = (-2) * knot0.Li;
     // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
@@ -332,7 +332,7 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<Dat
 
   // second derivative at knot nKnots-1  is 0
   {
-    const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(nKnots - 2);
+    const typename Spline1D<DataT>::KnotType& knot0 = spline.getKnot(nKnots - 2);
     double cZ0 = (6 - 4) * knot0.Li;
     double cZ1 = (6 - 2) * knot0.Li;
     // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
@@ -342,12 +342,12 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<Dat
 
   // second derivative at other knots is same from the left and from the right
   for (int32_t i = 1; i < nKnots - 1; i++) {
-    const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(i - 1);
+    const typename Spline1D<DataT>::KnotType& knot0 = spline.getKnot(i - 1);
     double cZ0 = (6 - 4) * knot0.Li;
     double cZ1_0 = (6 - 2) * knot0.Li;
     // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
 
-    const typename Spline1D<DataT>::Knot& knot1 = spline.getKnot(i);
+    const typename Spline1D<DataT>::KnotType& knot1 = spline.getKnot(i);
     double cZ1_1 = (-4) * knot1.Li;
     double cZ2 = (-2) * knot1.Li;
     // f''(u) = cS2*(f2-f1) + cZ1_1*z1 + cZ2*z2;
@@ -367,7 +367,7 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<Dat
   double uToXscale = (((double)xMax) - xMin) / spline.getUmax();
 
   for (int32_t i = 0; i < nKnots; ++i) {
-    const typename Spline1D<DataT>::Knot& knot = spline.getKnot(i);
+    const typename Spline1D<DataT>::KnotType& knot = spline.getKnot(i);
     double u = knot.u;
     double f[Ndim];
     F(xMin + u * uToXscale, f);
@@ -382,7 +382,7 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<Dat
     {
       double f0 = parameters[(2 * 0) * Ndim + dim];
       double f1 = parameters[(2 * 1) * Ndim + dim];
-      const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(0);
+      const typename Spline1D<DataT>::KnotType& knot0 = spline.getKnot(0);
       double cS1 = (6) * knot0.Li * knot0.Li;
       // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
       b(0) = -cS1 * (f1 - f0);
@@ -392,7 +392,7 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<Dat
     {
       double f0 = parameters[2 * (nKnots - 2) * Ndim + dim];
       double f1 = parameters[2 * (nKnots - 1) * Ndim + dim];
-      const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(nKnots - 2);
+      const typename Spline1D<DataT>::KnotType& knot0 = spline.getKnot(nKnots - 2);
       double cS1 = (6 - 12) * knot0.Li * knot0.Li;
       // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
       b(nKnots - 1) = -cS1 * (f1 - f0);
@@ -403,11 +403,11 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<Dat
       double f0 = parameters[2 * (i - 1) * Ndim + dim];
       double f1 = parameters[2 * (i)*Ndim + dim];
       double f2 = parameters[2 * (i + 1) * Ndim + dim];
-      const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(i - 1);
+      const typename Spline1D<DataT>::KnotType& knot0 = spline.getKnot(i - 1);
       double cS1 = (6 - 12) * knot0.Li * knot0.Li;
       // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
 
-      const typename Spline1D<DataT>::Knot& knot1 = spline.getKnot(i);
+      const typename Spline1D<DataT>::KnotType& knot1 = spline.getKnot(i);
       double cS2 = (6) * knot1.Li * knot1.Li;
       // f''(u) = cS2*(f2-f1) + cZ1_1*z1 + cZ2*z2;
       b(i) = -cS1 * (f1 - f0) + cS2 * (f2 - f1);
@@ -422,7 +422,7 @@ void Spline1DHelper<DataT>::approximateFunctionClassic(Spline1DContainerBase<Dat
 
 template <typename DataT>
 void Spline1DHelper<DataT>::makeDataPoints(
-  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainer<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints, std::vector<double>& vx, std::vector<double>& vf)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -451,7 +451,7 @@ void Spline1DHelper<DataT>::makeDataPoints(
 
 template <typename DataT>
 void Spline1DHelper<DataT>::approximateFunction(
-  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainer<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -463,7 +463,7 @@ void Spline1DHelper<DataT>::approximateFunction(
 
 template <typename DataT>
 void Spline1DHelper<DataT>::approximateFunctionGradually(
-  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainer<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -479,7 +479,7 @@ void Spline1DHelper<DataT>::approximateFunctionGradually(
 
   // set F values at knots
   for (int32_t iKnot = 0; iKnot < mSpline.getNumberOfKnots(); ++iKnot) {
-    const typename Spline1D<double>::Knot& knot = mSpline.getKnot(iKnot);
+    const typename Spline1D<double>::KnotType& knot = mSpline.getKnot(iKnot);
     double x = mSpline.convUtoX(knot.u);
     double s[nFdimensions];
     F(x, s);
@@ -491,7 +491,7 @@ void Spline1DHelper<DataT>::approximateFunctionGradually(
 }
 
 template <typename DataT>
-void Spline1DHelper<DataT>::setSpline(const Spline1DContainerBase<DataT, FlatObject>& spline)
+void Spline1DHelper<DataT>::setSpline(const Spline1DContainer<DataT, FlatObject>& spline)
 {
   const int32_t nKnots = spline.getNumberOfKnots();
   std::vector<int32_t> knots(nKnots);
diff --git a/GPU/TPCFastTransformation/Spline1DHelper.h b/GPU/TPCFastTransformation/Spline1DHelper.h
index 9c88cf61470a5..41aadfb92defa 100644
--- a/GPU/TPCFastTransformation/Spline1DHelper.h
+++ b/GPU/TPCFastTransformation/Spline1DHelper.h
@@ -52,25 +52,25 @@ class Spline1DHelper
   /// _______________  Main functionality  ________________________
 
   /// Create best-fit spline parameters for a set of data points
-  void approximateDataPoints(Spline1DContainerBase<DataT, FlatObject>& spline,
+  void approximateDataPoints(Spline1DContainer<DataT, FlatObject>& spline,
                              double xMin, double xMax,
                              const double vx[], const double vf[], int32_t nDataPoints);
 
   /// Create best-fit spline parameters for a function F
   void approximateFunction(
-    Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+    Spline1DContainer<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
     int32_t nAuxiliaryDataPoints = 4);
 
   /// Approximate only derivatives assuming the spline values at knozts are already set
-  void approximateDerivatives(Spline1DContainerBase<DataT, FlatObject>& spline,
+  void approximateDerivatives(Spline1DContainer<DataT, FlatObject>& spline,
                               const double vx[], const double vf[], int32_t nDataPoints);
 
   void approximateFunctionGradually(
-    Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+    Spline1DContainer<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
     int32_t nAuxiliaryDataPoints);
 
   /// Create classic spline parameters for a given input function F
-  void approximateFunctionClassic(Spline1DContainerBase<DataT, FlatObject>& spline,
+  void approximateFunctionClassic(Spline1DContainer<DataT, FlatObject>& spline,
                                   double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F);
 
   /// _______________  Utilities   ________________________
@@ -79,21 +79,21 @@ class Spline1DHelper
 
   /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
   /// over the spline values Sl, Sr and the slopes Dl, Dr
-  static void getScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+  static void getScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                double& cSl, double& cDl, double& cSr, double& cDr);
 
-  static void getDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+  static void getDScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                 double& cSl, double& cDl, double& cSr, double& cDr);
 
-  static void getDDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+  static void getDDScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                  double& cSl, double& cDl, double& cSr, double& cDr);
 
-  static void getDDScoefficientsLeft(const typename Spline1D<double>::Knot& knotL,
+  static void getDDScoefficientsLeft(const typename Spline1D<double>::KnotType& knotL,
                                      double& cSl, double& cDl, double& cSr, double& cDr);
 
-  static void getDDScoefficientsRight(const typename Spline1D<double>::Knot& knotL,
+  static void getDDScoefficientsRight(const typename Spline1D<double>::KnotType& knotL,
                                       double& cSl, double& cDl, double& cSr, double& cDr);
-  static void getDDDScoefficients(const typename Spline1D<double>::Knot& knotL,
+  static void getDDDScoefficients(const typename Spline1D<double>::KnotType& knotL,
                                   double& cSl, double& cDl, double& cSr, double& cDr);
 
   ///  Gives error string
@@ -110,9 +110,9 @@ class Spline1DHelper
 
   std::string mError = ""; ///< error string
 
-  void setSpline(const Spline1DContainerBase<DataT, FlatObject>& spline);
+  void setSpline(const Spline1DContainer<DataT, FlatObject>& spline);
 
-  void makeDataPoints(Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  void makeDataPoints(Spline1DContainer<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
                       int32_t nAuxiliaryDataPoints, std::vector<double>& vx, std::vector<double>& vf);
 
   /// helpers for the construction of 1D spline
diff --git a/GPU/TPCFastTransformation/Spline1DHelperOld.cxx b/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
index 2427cb6ff37e4..96ba46c66c791 100644
--- a/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
+++ b/GPU/TPCFastTransformation/Spline1DHelperOld.cxx
@@ -47,7 +47,7 @@ int32_t Spline1DHelperOld<DataT>::storeError(int32_t code, const char* msg)
 }
 
 template <typename DataT>
-void Spline1DHelperOld<DataT>::getScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+void Spline1DHelperOld<DataT>::getScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                                 double& cSl, double& cDl, double& cSr, double& cDr)
 {
   /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
@@ -67,7 +67,7 @@ void Spline1DHelperOld<DataT>::getScoefficients(const typename Spline1D<double>:
 }
 
 template <typename DataT>
-void Spline1DHelperOld<DataT>::getDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+void Spline1DHelperOld<DataT>::getDScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                                  double& cSl, double& cDl, double& cSr, double& cDr)
 {
   u = u - knotL.u;
@@ -83,7 +83,7 @@ void Spline1DHelperOld<DataT>::getDScoefficients(const typename Spline1D<double>
 }
 
 template <typename DataT>
-void Spline1DHelperOld<DataT>::getDDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+void Spline1DHelperOld<DataT>::getDDScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                                   double& cSl, double& cDl, double& cSr, double& cDr)
 {
   u = u - knotL.u;
@@ -96,7 +96,7 @@ void Spline1DHelperOld<DataT>::getDDScoefficients(const typename Spline1D<double
 }
 
 template <typename DataT>
-void Spline1DHelperOld<DataT>::getDDScoefficientsLeft(const typename Spline1D<double>::Knot& knotL,
+void Spline1DHelperOld<DataT>::getDDScoefficientsLeft(const typename Spline1D<double>::KnotType& knotL,
                                                       double& cSl, double& cDl, double& cSr, double& cDr)
 {
   double dv = double(knotL.Li);
@@ -107,7 +107,7 @@ void Spline1DHelperOld<DataT>::getDDScoefficientsLeft(const typename Spline1D<do
 }
 
 template <typename DataT>
-void Spline1DHelperOld<DataT>::getDDScoefficientsRight(const typename Spline1D<double>::Knot& knotL,
+void Spline1DHelperOld<DataT>::getDDScoefficientsRight(const typename Spline1D<double>::KnotType& knotL,
                                                        double& cSl, double& cDl, double& cSr, double& cDr)
 {
   double dv = double(knotL.Li);
@@ -118,7 +118,7 @@ void Spline1DHelperOld<DataT>::getDDScoefficientsRight(const typename Spline1D<d
 }
 
 template <typename DataT>
-void Spline1DHelperOld<DataT>::getDDDScoefficients(const typename Spline1D<double>::Knot& knotL,
+void Spline1DHelperOld<DataT>::getDDDScoefficients(const typename Spline1D<double>::KnotType& knotL,
                                                    double& cSl, double& cDl, double& cSr, double& cDr)
 {
   double dv = double(knotL.Li);
@@ -129,7 +129,7 @@ void Spline1DHelperOld<DataT>::getDDDScoefficients(const typename Spline1D<doubl
 }
 
 template <typename DataT>
-void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<DataT, FlatObject>& spline,
+void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainer<DataT, FlatObject>& spline,
                                                           double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F)
 {
   /// Create classic spline parameters for a given input function F
@@ -153,7 +153,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<
 
   // second derivative at knot0 is 0
   {
-    const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(0);
+    const Knot<DataT>& knot0 = spline.getKnot(0);
     double cZ0 = (-4) * knot0.Li;
     double cZ1 = (-2) * knot0.Li;
     // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
@@ -163,7 +163,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<
 
   // second derivative at knot nKnots-1  is 0
   {
-    const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(nKnots - 2);
+    const Knot<DataT>& knot0 = spline.getKnot(nKnots - 2);
     double cZ0 = (6 - 4) * knot0.Li;
     double cZ1 = (6 - 2) * knot0.Li;
     // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
@@ -173,12 +173,12 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<
 
   // second derivative at other knots is same from the left and from the right
   for (int32_t i = 1; i < nKnots - 1; i++) {
-    const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(i - 1);
+    const Knot<DataT>& knot0 = spline.getKnot(i - 1);
     double cZ0 = (6 - 4) * knot0.Li;
     double cZ1_0 = (6 - 2) * knot0.Li;
     // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
 
-    const typename Spline1D<DataT>::Knot& knot1 = spline.getKnot(i);
+    const Knot<DataT>& knot1 = spline.getKnot(i);
     double cZ1_1 = (-4) * knot1.Li;
     double cZ2 = (-2) * knot1.Li;
     // f''(u) = cS2*(f2-f1) + cZ1_1*z1 + cZ2*z2;
@@ -198,7 +198,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<
   double uToXscale = (((double)xMax) - xMin) / spline.getUmax();
 
   for (int32_t i = 0; i < nKnots; ++i) {
-    const typename Spline1D<DataT>::Knot& knot = spline.getKnot(i);
+    const Knot<DataT>& knot = spline.getKnot(i);
     double u = knot.u;
     double f[Ndim];
     F(xMin + u * uToXscale, f);
@@ -213,7 +213,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<
     {
       double f0 = parameters[(2 * 0) * Ndim + dim];
       double f1 = parameters[(2 * 1) * Ndim + dim];
-      const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(0);
+      const Knot<DataT>& knot0 = spline.getKnot(0);
       double cS1 = (6) * knot0.Li * knot0.Li;
       // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
       b(0) = -cS1 * (f1 - f0);
@@ -223,7 +223,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<
     {
       double f0 = parameters[2 * (nKnots - 2) * Ndim + dim];
       double f1 = parameters[2 * (nKnots - 1) * Ndim + dim];
-      const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(nKnots - 2);
+      const Knot<DataT>& knot0 = spline.getKnot(nKnots - 2);
       double cS1 = (6 - 12) * knot0.Li * knot0.Li;
       // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
       b(nKnots - 1) = -cS1 * (f1 - f0);
@@ -234,11 +234,11 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<
       double f0 = parameters[2 * (i - 1) * Ndim + dim];
       double f1 = parameters[2 * (i)*Ndim + dim];
       double f2 = parameters[2 * (i + 1) * Ndim + dim];
-      const typename Spline1D<DataT>::Knot& knot0 = spline.getKnot(i - 1);
+      const Knot<DataT>& knot0 = spline.getKnot(i - 1);
       double cS1 = (6 - 12) * knot0.Li * knot0.Li;
       // f''(u) = cS1*(f1-f0) + cZ0*z0 + cZ1*z1;
 
-      const typename Spline1D<DataT>::Knot& knot1 = spline.getKnot(i);
+      const Knot<DataT>& knot1 = spline.getKnot(i);
       double cS2 = (6) * knot1.Li * knot1.Li;
       // f''(u) = cS2*(f2-f1) + cZ1_1*z1 + cZ2*z2;
       b(i) = -cS1 * (f1 - f0) + cS2 * (f2 - f1);
@@ -253,7 +253,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionClassic(Spline1DContainerBase<
 
 template <typename DataT>
 void Spline1DHelperOld<DataT>::approximateDataPoints(
-  Spline1DContainerBase<DataT, FlatObject>& spline,
+  Spline1DContainer<DataT, FlatObject>& spline,
   double xMin, double xMax,
   double vx[], double vf[], int32_t nDataPoints)
 {
@@ -266,7 +266,7 @@ void Spline1DHelperOld<DataT>::approximateDataPoints(
 
 template <typename DataT>
 void Spline1DHelperOld<DataT>::approximateFunction(
-  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainer<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints)
 {
   /// Create best-fit spline parameters for a given input function F
@@ -277,7 +277,7 @@ void Spline1DHelperOld<DataT>::approximateFunction(
 
 template <typename DataT>
 void Spline1DHelperOld<DataT>::approximateFunctionGradually(
-  Spline1DContainerBase<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
+  Spline1DContainer<DataT, FlatObject>& spline, double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
   int32_t nAuxiliaryDataPoints)
 {
   /// Create best-fit spline parameters gradually for a given input function F
@@ -316,7 +316,7 @@ void Spline1DHelperOld<DataT>::approximateFunctionGradually(
 
 template <typename DataT>
 int32_t Spline1DHelperOld<DataT>::setSpline(
-  const Spline1DContainerBase<DataT, FlatObject>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints)
+  const Spline1DContainer<DataT, FlatObject>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints)
 {
   // Prepare creation of a best-fit spline
   //
@@ -363,8 +363,8 @@ int32_t Spline1DHelperOld<DataT>::setSpline(
     DataPoint& p = mDataPoints[i];
     double u = i * scalePoints2Knots;
     int32_t iKnot = mSpline.getLeftKnotIndexForU(u);
-    const typename Spline1D<double>::Knot& knot0 = mSpline.getKnot(iKnot);
-    const typename Spline1D<double>::Knot& knot1 = mSpline.getKnot(iKnot + 1);
+    const typename Spline1D<double>::KnotType& knot0 = mSpline.getKnot(iKnot);
+    const typename Spline1D<double>::KnotType& knot1 = mSpline.getKnot(iKnot + 1);
     double l = knot1.u - knot0.u;
     double s = (u - knot0.u) * knot0.Li; // scaled u
     double s2 = s * s;
@@ -384,7 +384,7 @@ int32_t Spline1DHelperOld<DataT>::setSpline(
   mKnotDataPoints.resize(nKnots);
 
   for (int32_t i = 0; i < nKnots; ++i) {
-    const typename Spline1D<double>::Knot& knot = mSpline.getKnot(i);
+    const typename Spline1D<double>::KnotType& knot = mSpline.getKnot(i);
     int32_t iu = (int32_t)(knot.u + 0.1f);
     mKnotDataPoints[i] = iu * (1 + nAuxiliaryDataPoints);
     mDataPoints[mKnotDataPoints[i]].isKnot = 1;
@@ -463,7 +463,7 @@ int32_t Spline1DHelperOld<DataT>::setSpline(
 
 template <typename DataT>
 int32_t Spline1DHelperOld<DataT>::setSpline(
-  const Spline1DContainerBase<DataT, FlatObject>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints)
+  const Spline1DContainer<DataT, FlatObject>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints)
 {
   // Prepare creation of a best-fit spline
   //
@@ -505,7 +505,7 @@ int32_t Spline1DHelperOld<DataT>::setSpline(
     p.iKnot = iKnot;
     p.isKnot = 0;
     p.u = u;
-    const typename Spline1D<double>::Knot& knot0 = mSpline.getKnot(iKnot);
+    const typename Spline1D<double>::KnotType& knot0 = mSpline.getKnot(iKnot);
     getScoefficients(knot0, u, p.cS0, p.cZ0, p.cS1, p.cZ1);
   }
 
@@ -533,9 +533,9 @@ int32_t Spline1DHelperOld<DataT>::setSpline(
   }
 
   for (int32_t iKnot = 0; iKnot < nKnots - 2; ++iKnot) {
-    const typename Spline1D<double>::Knot& knot0 = mSpline.getKnot(iKnot);
-    const typename Spline1D<double>::Knot& knot1 = mSpline.getKnot(iKnot + 1);
-    // const typename Spline1D<double>::Knot& knot2 = mSpline.getKnot(iKnot + 2);
+    const typename Spline1D<double>::KnotType& knot0 = mSpline.getKnot(iKnot);
+    const typename Spline1D<double>::KnotType& knot1 = mSpline.getKnot(iKnot + 1);
+    // const typename Spline1D<double>::KnotType& knot2 = mSpline.getKnot(iKnot + 2);
     /*
     another way to calculate f(u):
      T uu = T(u - knotL.u);
@@ -612,7 +612,7 @@ int32_t Spline1DHelperOld<DataT>::setSpline(
 
   for (int32_t iKnot = -1; iKnot < nKnots - 2; ++iKnot) {
 
-    const typename Spline1D<double>::Knot& knot1 = mSpline.getKnot(iKnot + 1);
+    const typename Spline1D<double>::KnotType& knot1 = mSpline.getKnot(iKnot + 1);
     /*
      ()''u
      dSr = (3 - 6*v)*knotL.Li*knotL.Li;
@@ -650,7 +650,7 @@ int32_t Spline1DHelperOld<DataT>::setSpline(
 
   {
     int32_t iKnot = nKnots - 2;
-    const typename Spline1D<double>::Knot& knot0 = mSpline.getKnot(iKnot);
+    const typename Spline1D<double>::KnotType& knot0 = mSpline.getKnot(iKnot);
     /*
      ()''u
      dSr = (3 - 6*v)*knotL.Li*knotL.Li;
diff --git a/GPU/TPCFastTransformation/Spline1DHelperOld.h b/GPU/TPCFastTransformation/Spline1DHelperOld.h
index 8ab36d5f57641..857b8ed0ec89d 100644
--- a/GPU/TPCFastTransformation/Spline1DHelperOld.h
+++ b/GPU/TPCFastTransformation/Spline1DHelperOld.h
@@ -69,31 +69,31 @@ class Spline1DHelperOld
   void bandGauss(double A[], double b[], int32_t n);
 
   /// Create best-fit spline parameters for a given input function F
-  void approximateDataPoints(Spline1DContainerBase<DataT, FlatObject>& spline,
+  void approximateDataPoints(Spline1DContainer<DataT, FlatObject>& spline,
                              double xMin, double xMax,
                              double x[], double f[], int32_t nDataPoints);
 
   /// Create best-fit spline parameters for a given input function F
-  void approximateFunction(Spline1DContainerBase<DataT, FlatObject>& spline,
+  void approximateFunction(Spline1DContainer<DataT, FlatObject>& spline,
                            double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
                            int32_t nAuxiliaryDataPoints = 4);
 
   /// Create best-fit spline parameters gradually for a given input function F
-  void approximateFunctionGradually(Spline1DContainerBase<DataT, FlatObject>& spline,
+  void approximateFunctionGradually(Spline1DContainer<DataT, FlatObject>& spline,
                                     double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F,
                                     int32_t nAuxiliaryDataPoints = 4);
 
   /// Create classic spline parameters for a given input function F
-  void approximateFunctionClassic(Spline1DContainerBase<DataT, FlatObject>& spline,
+  void approximateFunctionClassic(Spline1DContainer<DataT, FlatObject>& spline,
                                   double xMin, double xMax, std::function<void(double x, double f[/*spline.getFdimensions()*/])> F);
 
   /// _______________   Interface for a step-wise construction of the best-fit spline   ________________________
 
   /// precompute everything needed for the construction
-  int32_t setSpline(const Spline1DContainerBase<DataT, FlatObject>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints);
+  int32_t setSpline(const Spline1DContainer<DataT, FlatObject>& spline, int32_t nFdimensions, int32_t nAuxiliaryDataPoints);
 
   /// precompute everything needed for the construction
-  int32_t setSpline(const Spline1DContainerBase<DataT, FlatObject>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints);
+  int32_t setSpline(const Spline1DContainer<DataT, FlatObject>& spline, int32_t nFdimensions, double xMin, double xMax, double vx[], int32_t nDataPoints);
 
   /// approximate std::function, output in Fparameters
   void approximateFunction(DataT* Fparameters, double xMin, double xMax, std::function<void(double x, double f[])> F) const;
@@ -127,21 +127,21 @@ class Spline1DHelperOld
 
   /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
   /// over the spline values Sl, Sr and the slopes Dl, Dr
-  static void getScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+  static void getScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                double& cSl, double& cDl, double& cSr, double& cDr);
 
-  static void getDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+  static void getDScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                 double& cSl, double& cDl, double& cSr, double& cDr);
 
-  static void getDDScoefficients(const typename Spline1D<double>::Knot& knotL, double u,
+  static void getDDScoefficients(const typename Spline1D<double>::KnotType& knotL, double u,
                                  double& cSl, double& cDl, double& cSr, double& cDr);
 
-  static void getDDScoefficientsLeft(const typename Spline1D<double>::Knot& knotL,
+  static void getDDScoefficientsLeft(const typename Spline1D<double>::KnotType& knotL,
                                      double& cSl, double& cDl, double& cSr, double& cDr);
 
-  static void getDDScoefficientsRight(const typename Spline1D<double>::Knot& knotL,
+  static void getDDScoefficientsRight(const typename Spline1D<double>::KnotType& knotL,
                                       double& cSl, double& cDl, double& cSr, double& cDr);
-  static void getDDDScoefficients(const typename Spline1D<double>::Knot& knotL,
+  static void getDDDScoefficients(const typename Spline1D<double>::KnotType& knotL,
                                   double& cSl, double& cDl, double& cSr, double& cDr);
 
   ///  Gives error string
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.cxx b/GPU/TPCFastTransformation/Spline1DSpec.cxx
index 0ff694957e94c..374849177a0f8 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline1DSpec.cxx
@@ -24,14 +24,13 @@
 #include "TFile.h"
 #include "GPUCommonMath.h"
 templateClassImp(o2::gpu::Spline1DContainer);
-templateClassImp(o2::gpu::Spline1DSpec);
 #endif
 
 using namespace std;
 using namespace o2::gpu;
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t numberOfKnots)
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::recreate(int32_t nYdim, int32_t numberOfKnots)
 {
   /// Constructor for a regular spline
   /// \param numberOfKnots     Number of knots
@@ -47,8 +46,8 @@ void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t num
   recreate(nYdim, numberOfKnots, knots.data());
 }
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t numberOfKnots, const int32_t inputKnots[])
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::recreate(int32_t nYdim, int32_t numberOfKnots, const int32_t inputKnots[])
 {
   /// Main constructor for an irregular spline
   ///
@@ -59,10 +58,9 @@ void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t num
   /// \param numberOfKnots     Number of knots in knots[] array
   /// \param knots             Array of relative knot positions (integer values)
   ///
+  FlatObject::startConstruction();
 
-  FlatBase::startConstruction();
-
-  mYdim = (nYdim >= 0) ? nYdim : 0;
+  this->mYdim = (nYdim >= 0) ? nYdim : 0;
 
   std::vector<int32_t> knotU;
 
@@ -86,45 +84,45 @@ void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t num
     }
   }
 
-  mNumberOfKnots = knotU.size();
-  mUmax = knotU.back();
-  mXmin = 0.;
-  mXtoUscale = 1.;
+  this->mNumberOfKnots = knotU.size();
+  this->mUmax = knotU.back();
+  this->mXmin = 0.;
+  this->mXtoUscale = 1.;
 
-  const int32_t uToKnotMapOffset = mNumberOfKnots * sizeof(Knot);
-  int32_t parametersOffset = uToKnotMapOffset + (mUmax + 1) * sizeof(int32_t);
+  const int32_t uToKnotMapOffset = this->mNumberOfKnots * sizeof(Knot<DataT>);
+  int32_t parametersOffset = uToKnotMapOffset + (this->mUmax + 1) * sizeof(int32_t);
   int32_t bufferSize = parametersOffset;
-  if (mYdim > 0) {
-    parametersOffset = this->alignSize(bufferSize, getParameterAlignmentBytes());
-    bufferSize = parametersOffset + getSizeOfParameters();
+  if (this->mYdim > 0) {
+    parametersOffset = this->alignSize(bufferSize, this->getParameterAlignmentBytes());
+    bufferSize = parametersOffset + this->getSizeOfParameters();
   }
 
-  FlatBase::finishConstruction(bufferSize);
+  FlatObject::finishConstruction(bufferSize);
 
-  mUtoKnotMap = reinterpret_cast<int32_t*>(this->mFlatBufferPtr + uToKnotMapOffset);
-  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
+  this->mUtoKnotMap = reinterpret_cast<int32_t*>(this->mFlatBufferPtr + uToKnotMapOffset);
+  this->mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
 
-  for (int32_t i = 0; i < getNumberOfParameters(); i++) {
-    mParameters[i] = 0;
+  for (int32_t i = 0; i < this->getNumberOfParameters(); i++) {
+    this->mParameters[i] = 0;
   }
 
-  Knot* s = getKnots();
+  Knot<DataT>* s = getKnots();
 
-  for (int32_t i = 0; i < mNumberOfKnots; i++) {
+  for (int32_t i = 0; i < this->mNumberOfKnots; i++) {
     s[i].u = knotU[i];
   }
 
-  for (int32_t i = 0; i < mNumberOfKnots - 1; i++) {
+  for (int32_t i = 0; i < this->mNumberOfKnots - 1; i++) {
     s[i].Li = 1. / (s[i + 1].u - s[i].u); // do division in double
   }
 
-  s[mNumberOfKnots - 1].Li = 0.; // the value will not be used, we define it for consistency
+  s[this->mNumberOfKnots - 1].Li = 0.; // the value will not be used, we define it for consistency
 
   // Set up the map (integer U) -> (knot index)
 
   int32_t* map = getUtoKnotMap();
 
-  const int32_t iKnotMax = mNumberOfKnots - 2;
+  const int32_t iKnotMax = this->mNumberOfKnots - 2;
 
   //
   // With iKnotMax=nKnots-2 we map the U==Umax coordinate to the last [nKnots-2, nKnots-1] segment.
@@ -132,7 +130,7 @@ void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t num
   // Any U from [0,Umax] is mapped to some knot_i such, that the next knot_i+1 always exist
   //
 
-  for (int32_t u = 0, iKnot = 0; u <= mUmax; u++) {
+  for (int32_t u = 0, iKnot = 0; u <= this->mUmax; u++) {
     if ((knotU[iKnot + 1] == u) && (iKnot < iKnotMax)) {
       iKnot = iKnot + 1;
     }
@@ -140,15 +138,15 @@ void Spline1DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim, int32_t num
   }
 }
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::print() const
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::print() const
 {
   printf(" Spline 1D: \n");
-  printf("  mNumberOfKnots = %d \n", mNumberOfKnots);
-  printf("  mUmax = %d\n", mUmax);
-  printf("  mUtoKnotMap = %p \n", (void*)mUtoKnotMap);
+  printf("  mNumberOfKnots = %d \n", this->mNumberOfKnots);
+  printf("  mUmax = %d\n", this->mUmax);
+  printf("  mUtoKnotMap = %p \n", (void*)this->mUtoKnotMap);
   printf("  knots: ");
-  for (int32_t i = 0; i < mNumberOfKnots; i++) {
+  for (int32_t i = 0; i < this->mNumberOfKnots; i++) {
     printf("%d ", (int32_t)getKnot(i).u);
   }
   printf("\n");
@@ -156,132 +154,117 @@ void Spline1DContainerBase<DataT, FlatBase>::print() const
 
 #if !defined(GPUCA_STANDALONE)
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::approximateFunction(
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::approximateFunction(
   double xMin, double xMax,
   std::function<void(double x, double f[])> F,
   int32_t nAxiliaryDataPoints)
 {
   /// approximate a function F with this spline
-  if constexpr (std::is_same_v<FlatBase, FlatObject>) {
-    Spline1DHelper<DataT> helper;
-    helper.approximateFunction(*this, xMin, xMax, F, nAxiliaryDataPoints);
-  }
+  Spline1DHelper<DataT> helper;
+  helper.approximateFunction(*this, xMin, xMax, F, nAxiliaryDataPoints);
 }
 
-template <class DataT, class FlatBase>
-int32_t Spline1DContainerBase<DataT, FlatBase>::writeToFile(TFile& outf, const char* name)
+template <class DataT>
+int32_t Spline1DContainer<DataT, FlatObject>::writeToFile(TFile& outf, const char* name)
 {
   /// write a class object to the file
-  if constexpr (std::is_same_v<FlatBase, FlatObject>) {
-    return FlatObject::writeToFile(*this, outf, name);
-  } else {
-    return -1;
-  }
+  return FlatObject::writeToFile(*this, outf, name);
 }
 
-template <class DataT, class FlatBase>
-Spline1DContainerBase<DataT, FlatBase>* Spline1DContainerBase<DataT, FlatBase>::readFromFile(TFile& inpf, const char* name)
+template <class DataT>
+Spline1DContainer<DataT, FlatObject>* Spline1DContainer<DataT, FlatObject>::readFromFile(TFile& inpf, const char* name)
 {
   /// read a class object from the file
-  if constexpr (std::is_same_v<FlatBase, FlatObject>) {
-    return FlatObject::readFromFile<Spline1DContainerBase<DataT, FlatBase>>(inpf, name);
-  } else {
-    return nullptr;
-  }
+  return FlatObject::readFromFile<Spline1DContainer<DataT, FlatObject>>(inpf, name);
+}
+
+template <class DataT>
+int32_t Spline1DContainer<DataT, FlatObject>::test(const bool draw, const bool drawDataPoints)
+{
+  return Spline1DHelper<DataT>::test(draw, drawDataPoints);
 }
 
 #endif
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::cloneFromObject(const Spline1DContainerBase<DataT, FlatBase>& obj, char* newFlatBufferPtr)
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::cloneFromObject(const Spline1DContainer<DataT, FlatObject>& obj, char* newFlatBufferPtr)
 {
   /// See FlatObject for description
-
   const char* oldFlatBufferPtr = obj.mFlatBufferPtr;
-  FlatBase::cloneFromObject(obj, newFlatBufferPtr);
-  mYdim = obj.mYdim;
-  mNumberOfKnots = obj.mNumberOfKnots;
-  mUmax = obj.mUmax;
-  mXmin = obj.mXmin;
-  mXtoUscale = obj.mXtoUscale;
-  mUtoKnotMap = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mUtoKnotMap);
-  mParameters = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mParameters);
+  FlatObject::cloneFromObject(obj, newFlatBufferPtr);
+  this->mYdim = obj.mYdim;
+  this->mNumberOfKnots = obj.mNumberOfKnots;
+  this->mUmax = obj.mUmax;
+  this->mXmin = obj.mXmin;
+  this->mXtoUscale = obj.mXtoUscale;
+  this->mUtoKnotMap = FlatObject::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mUtoKnotMap);
+  this->mParameters = FlatObject::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mParameters);
 }
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::moveBufferTo(char* newFlatBufferPtr)
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::moveBufferTo(char* newFlatBufferPtr)
 {
   /// See FlatObject for description
   char* oldFlatBufferPtr = this->mFlatBufferPtr;
-  FlatBase::moveBufferTo(newFlatBufferPtr);
+  FlatObject::moveBufferTo(newFlatBufferPtr);
   char* currFlatBufferPtr = this->mFlatBufferPtr;
   this->mFlatBufferPtr = oldFlatBufferPtr;
   setActualBufferAddress(currFlatBufferPtr);
 }
 
-template <class DataT, class FlatBase>
+template <class DataT>
 template <class OtherFlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::importFrom(const Spline1DContainerBase<DataT, OtherFlatBase>& src)
+void Spline1DContainer<DataT, FlatObject>::importFrom(const Spline1DContainerBase<DataT, OtherFlatBase>& src)
 {
   /// Copy schema fields from a spline with a different FlatBase (e.g. FlatObject -> NoFlatObject).
   /// Pointers (mUtoKnotMap, mParameters) are set to nullptr; call setActualBufferAddress() afterward.
-  mYdim = src.getYdimensions();
-  mNumberOfKnots = src.getNumberOfKnots();
-  mUmax = src.getUmax();
-  mXmin = src.getXmin();
-  mXtoUscale = src.getXtoUscale();
+  this->mYdim = src.getYdimensions();
+  this->mNumberOfKnots = src.getNumberOfKnots();
+  this->mUmax = src.getUmax();
+  this->mXmin = src.getXmin();
+  this->mXtoUscale = src.getXtoUscale();
   this->mFlatBufferSize = src.getFlatBufferSize();
-  mUtoKnotMap = nullptr;
-  mParameters = nullptr;
+  this->mUtoKnotMap = nullptr;
+  this->mParameters = nullptr;
 }
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::destroy()
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::destroy()
 {
-  /// See FlatObject for description
-  mNumberOfKnots = 0;
-  mUmax = 0;
-  mYdim = 0;
-  mXmin = 0.;
-  mXtoUscale = 1.;
-  mUtoKnotMap = nullptr;
-  mParameters = nullptr;
-  FlatBase::destroy();
+  this->mNumberOfKnots = 0;
+  this->mUmax = 0;
+  this->mYdim = 0;
+  this->mXmin = 0.;
+  this->mXtoUscale = 1.;
+  this->mUtoKnotMap = nullptr;
+  this->mParameters = nullptr;
+  FlatObject::destroy();
 }
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::setActualBufferAddress(char* actualFlatBufferPtr)
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::setActualBufferAddress(char* actualFlatBufferPtr)
 {
   /// See FlatObject for description
+  FlatObject::setActualBufferAddress(actualFlatBufferPtr);
 
-  FlatBase::setActualBufferAddress(actualFlatBufferPtr);
-
-  const int32_t uToKnotMapOffset = mNumberOfKnots * sizeof(Knot);
-  mUtoKnotMap = reinterpret_cast<int32_t*>(this->mFlatBufferPtr + uToKnotMapOffset);
-  int32_t parametersOffset = uToKnotMapOffset + (mUmax + 1) * sizeof(int32_t);
-  if (mYdim > 0) {
-    parametersOffset = this->alignSize(parametersOffset, getParameterAlignmentBytes());
+  const int32_t uToKnotMapOffset = this->mNumberOfKnots * sizeof(Knot<DataT>);
+  this->mUtoKnotMap = reinterpret_cast<int32_t*>(this->mFlatBufferPtr + uToKnotMapOffset);
+  int32_t parametersOffset = uToKnotMapOffset + (this->mUmax + 1) * sizeof(int32_t);
+  if (this->mYdim > 0) {
+    parametersOffset = this->alignSize(parametersOffset, this->getParameterAlignmentBytes());
   }
   mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
 }
 
-template <class DataT, class FlatBase>
-void Spline1DContainerBase<DataT, FlatBase>::setFutureBufferAddress(char* futureFlatBufferPtr)
+template <class DataT>
+void Spline1DContainer<DataT, FlatObject>::setFutureBufferAddress(char* futureFlatBufferPtr)
 {
   /// See FlatObject for description
-  mUtoKnotMap = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mUtoKnotMap);
-  mParameters = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mParameters);
-  FlatBase::setFutureBufferAddress(futureFlatBufferPtr);
-}
-
-#if !defined(GPUCA_STANDALONE)
-template <class DataT, class FlatBase>
-int32_t Spline1DContainerBase<DataT, FlatBase>::test(const bool draw, const bool drawDataPoints)
-{
-  return Spline1DHelper<DataT>::test(draw, drawDataPoints);
+  this->mUtoKnotMap = FlatObject::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, this->mUtoKnotMap);
+  this->mParameters = FlatObject::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, this->mParameters);
+  FlatObject::setFutureBufferAddress(futureFlatBufferPtr);
 }
-#endif // GPUCA_STANDALONE
 
 template class o2::gpu::Spline1DContainerBase<float>;
 template class o2::gpu::Spline1DContainerBase<double>;
@@ -296,5 +279,7 @@ template class o2::gpu::Spline1DContainerBase<double, o2::gpu::NoFlatObject>;
 template class o2::gpu::Spline1DContainer<float, o2::gpu::NoFlatObject>;
 template class o2::gpu::Spline1DContainer<double, o2::gpu::NoFlatObject>;
 // importFrom instantiation for the FlatObject -> NoFlatObject conversion used in create()
-template void o2::gpu::Spline1DContainerBase<float, o2::gpu::NoFlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline1DContainerBase<float, o2::gpu::FlatObject>&);
-template void o2::gpu::Spline1DContainerBase<double, o2::gpu::NoFlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline1DContainerBase<double, o2::gpu::FlatObject>&);
+template void o2::gpu::Spline1DContainer<float, o2::gpu::NoFlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline1DContainerBase<float, o2::gpu::FlatObject>&);
+template void o2::gpu::Spline1DContainer<double, o2::gpu::NoFlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline1DContainerBase<double, o2::gpu::FlatObject>&);
+// importFrom for FlatObject container (FlatObject -> FlatObject, e.g. when using as a copy tool)
+template void o2::gpu::Spline1DContainer<float, o2::gpu::FlatObject>::importFrom<o2::gpu::FlatObject>(const o2::gpu::Spline1DContainerBase<float, o2::gpu::FlatObject>&);
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/TPCFastTransformation/Spline1DSpec.h
index 63508950e68b4..1b0fd17b5eb5b 100644
--- a/GPU/TPCFastTransformation/Spline1DSpec.h
+++ b/GPU/TPCFastTransformation/Spline1DSpec.h
@@ -33,6 +33,20 @@ namespace o2
 namespace gpu
 {
 
+/// The struct Knot represents the i-th knot and the segment [knot_i, knot_i+1]
+///
+template <typename DataT>
+struct Knot {
+  DataT u;  ///< u coordinate of the knot i (an integer number in float format)
+  DataT Li; ///< inverse length of the [knot_i, knot_{i+1}] segment ( == 1./ a (small) integer )
+  /// Get u as an integer
+  GPUd() int32_t getU() const { return (int32_t)(u + 0.1f); }
+};
+
+/// Named enumeration for the safety level used by some methods
+enum SafetyLevel { kNotSafe,
+                   kSafe };
+
 /// ==================================================================================================
 /// The class Spline1DContainerBase is a base class of Spline1D.
 /// It contains all the class members and those methods which only depends on the DataT data type.
@@ -46,19 +60,6 @@ template <typename DataT, class FlatBase = FlatObject>
 class Spline1DContainerBase : public FlatBase
 {
  public:
-  /// Named enumeration for the safety level used by some methods
-  enum SafetyLevel { kNotSafe,
-                     kSafe };
-
-  /// The struct Knot represents the i-th knot and the segment [knot_i, knot_i+1]
-  ///
-  struct Knot {
-    DataT u;  ///< u coordinate of the knot i (an integer number in float format)
-    DataT Li; ///< inverse length of the [knot_i, knot_{i+1}] segment ( == 1./ a (small) integer )
-    /// Get u as an integer
-    GPUd() int32_t getU() const { return (int32_t)(u + 0.1f); }
-  };
-
   /// _____________  Version control __________________________
 
   /// Version control
@@ -75,25 +76,6 @@ class Spline1DContainerBase : public FlatBase
   /// Destructor
   ~Spline1DContainerBase() = default;
 
-  /// _______________  Construction interface  ________________________
-
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
-  /// approximate a function F with this spline
-  void approximateFunction(double xMin, double xMax,
-                           std::function<void(double x, double f[/*mYdim*/])> F,
-                           int32_t nAuxiliaryDataPoints = 4);
-#endif
-
-  /// _______________  IO   ________________________
-
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
-  /// write a class object to the file
-  int32_t writeToFile(TFile& outf, const char* name);
-
-  /// read a class object from the file
-  static Spline1DContainerBase* readFromFile(TFile& inpf, const char* name);
-#endif
-
   /// _______________  Getters   ________________________
 
   /// Get U coordinate of the last knot
@@ -118,71 +100,8 @@ class Spline1DContainerBase : public FlatBase
   /// Get a number of knots
   GPUd() int32_t getNumberOfKnots() const { return mNumberOfKnots; }
 
-  /// Get the array of knots
-  GPUd() const Knot* getKnots() const { return reinterpret_cast<const Knot*>(this->mFlatBufferPtr); }
-
-  /// Get i-th knot
-  template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() const Knot& getKnot(int32_t i) const
-  {
-    if (SafeT == SafetyLevel::kSafe) {
-      i = (i < 0) ? 0 : (i >= mNumberOfKnots ? mNumberOfKnots - 1 : i);
-    }
-    return getKnots()[i];
-  }
-
-  /// Get index of an associated knot for a given U coordinate. Performs a boundary check.
-  template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() int32_t getLeftKnotIndexForU(DataT u) const;
-
-  /// Get spline parameters
-  GPUd() DataT* getParameters() { return mParameters; }
-
-  /// Get spline parameters const
-  GPUd() const DataT* getParameters() const { return mParameters; }
-
   /// _______________  Technical stuff  ________________________
 
-  /// Get a map (integer U -> corresponding knot index)
-  GPUd() const int32_t* getUtoKnotMap() const { return mUtoKnotMap; }
-
-  /// Get the knot array from an explicit flat buffer pointer.
-  /// Use this instead of getKnots() when the object was copied across process
-  /// boundaries and mFlatBufferPtr has not been fixed up (zero-copy path).
-  GPUd() const Knot* getKnotsFromBuffer(const char* flatBuf) const
-  {
-    return reinterpret_cast<const Knot*>(flatBuf);
-  }
-
-  /// Get i-th knot from an explicit flat buffer pointer.
-  /// Use this instead of getKnot() on the zero-copy path.
-  template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() const Knot& getKnotFromBuffer(const char* flatBuf, int32_t i) const
-  {
-    if (SafeT == SafetyLevel::kSafe) {
-      i = (i < 0) ? 0 : (i >= mNumberOfKnots ? mNumberOfKnots - 1 : i);
-    }
-    return getKnotsFromBuffer(flatBuf)[i];
-  }
-
-  /// Get the U->knot-index map from an explicit flat buffer pointer.
-  GPUd() const int32_t* getUtoKnotMapFromBuffer(const char* flatBuf) const
-  {
-    return reinterpret_cast<const int32_t*>(flatBuf + mNumberOfKnots * sizeof(Knot));
-  }
-
-  /// Map a U coordinate to its left knot index, using an explicit flat buffer pointer.
-  /// Use this instead of getLeftKnotIndexForU() on the zero-copy path.
-  template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() int32_t getLeftKnotIndexForUFromBuffer(const char* flatBuf, DataT u) const
-  {
-    int32_t iu = u < 0 ? 0 : (u > (float)mUmax ? mUmax : (int32_t)u);
-    if (SafeT == SafetyLevel::kSafe) {
-      iu = (iu < 0) ? 0 : (iu > mUmax ? mUmax : iu);
-    }
-    return getUtoKnotMapFromBuffer(flatBuf)[iu];
-  }
-
   /// Convert X coordinate to U
   GPUd() DataT convXtoU(DataT x) const { return (x - mXmin) * mXtoUscale; }
 
@@ -201,98 +120,176 @@ class Spline1DContainerBase : public FlatBase
   /// Set X range
   GPUd() void setXrange(DataT xMin, DataT xMax);
 
-  /// Print method
-  void print() const;
-
   ///  _______________  Expert tools  _______________
 
   /// Number of parameters for given Y dimensions
   GPUd() int32_t calcNumberOfParameters(int32_t nYdim) const { return (2 * nYdim) * getNumberOfKnots(); }
 
-  ///_______________  Test tools  _______________
+  /// _____________  Data members  ____________
+  int32_t mYdim = 0;          ///< dimentionality of F
+  int32_t mNumberOfKnots = 0; ///< n knots on the grid
+  int32_t mUmax = 0;          ///< U of the last knot
+  DataT mXmin = 0;            ///< X of the first knot
+  DataT mXtoUscale = 0;       ///< a scaling factor to convert X to U
+};
+
+template <typename DataT, typename FlatBase = FlatObject>
+class Spline1DContainer; // forward declaration
+
+template <typename DataT>
+class Spline1DContainer<DataT, FlatObject> : public Spline1DContainerBase<DataT, FlatObject>
+{
+ public:
+  /// Get a map (integer U -> corresponding knot index)
+  GPUd() const int32_t* getUtoKnotMap() const { return mUtoKnotMap; }
+
+  /// Get the array of knots
+  GPUd() const Knot<DataT>* getKnots() const { return reinterpret_cast<const Knot<DataT>*>(this->mFlatBufferPtr); }
+
+  /// Get i-th knot
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() const Knot<DataT>& getKnot(int32_t i) const
+  {
+    if (SafeT == SafetyLevel::kSafe) {
+      i = (i < 0) ? 0 : (i >= this->getNumberOfKnots() ? this->getNumberOfKnots() - 1 : i);
+    }
+    return getKnots()[i];
+  }
+
+  /// Get index of an associated knot for a given U coordinate. Performs a boundary check.
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() int32_t getLeftKnotIndexForU(DataT u) const;
+
+  /// Get spline parameters
+  GPUd() DataT* getParameters() { return mParameters; }
+
+  /// Get spline parameters const
+  GPUd() const DataT* getParameters() const { return mParameters; }
+
+#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+  /// approximate a function F with this spline
+  void approximateFunction(double xMin, double xMax, std::function<void(double x, double f[])> F, int32_t nAuxiliaryDataPoints = 4);
+
+  /// write a class object to the file
+  int32_t writeToFile(TFile& outf, const char* name);
+
+  /// read a class object from the file
+  static Spline1DContainer* readFromFile(TFile& inpf, const char* name);
 
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE) // code invisible on GPU and in the standalone compilation
   /// Test the class functionality
   static int32_t test(const bool draw = 0, const bool drawDataPoints = 1);
 #endif
 
-  /// _____________  FlatObject functionality, see FlatObject class for description  ____________
-
-  using FlatBase::getBufferAlignmentBytes;
-  using FlatBase::getClassAlignmentBytes;
+  /// Print method
+  void print() const;
 
 #if !defined(GPUCA_GPUCODE)
-  void cloneFromObject(const Spline1DContainerBase& obj, char* newFlatBufferPtr);
+  void cloneFromObject(const Spline1DContainer& obj, char* newFlatBufferPtr);
   void moveBufferTo(char* newBufferPtr);
 
-  /// Copy schema fields from a spline with a different FlatBase (e.g. FlatObject -> NoFlatObject).
-  /// Pointer members (mUtoKnotMap, mParameters) are set to nullptr; call setActualBufferAddress() afterward.
+  /// Copy schema fields from a spline with a different FlatBase.
+  /// mUtoKnotMap and mParameters are set to nullptr; call setActualBufferAddress() afterward.
   template <class OtherFlatBase>
   void importFrom(const Spline1DContainerBase<DataT, OtherFlatBase>& src);
 #endif
 
-  using FlatBase::releaseInternalBuffer;
-
   void destroy();
   void setActualBufferAddress(char* actualFlatBufferPtr);
   void setFutureBufferAddress(char* futureFlatBufferPtr);
 
  protected:
-  /// Non-const accessor to the knots array
-  Knot* getKnots() { return reinterpret_cast<Knot*>(this->mFlatBufferPtr); }
-
-  /// Non-const accessor to U->knots map
-  int32_t* getUtoKnotMap() { return mUtoKnotMap; }
-
 #if !defined(GPUCA_GPUCODE)
-  /// Constructor for a regular spline
   void recreate(int32_t nYdim, int32_t numberOfKnots);
-
-  /// Constructor for an irregular spline
   void recreate(int32_t nYdim, int32_t numberOfKnots, const int32_t knotU[]);
 #endif
 
-  /// _____________  Data members  ____________
+  /// Non-const accessor to U->knots map
+  int32_t* getUtoKnotMap() { return mUtoKnotMap; }
+
+  /// Non-const accessor to the knots array
+  Knot<DataT>* getKnots() { return reinterpret_cast<Knot<DataT>*>(this->mFlatBufferPtr); }
 
-  int32_t mYdim = 0;              ///< dimentionality of F
-  int32_t mNumberOfKnots = 0;     ///< n knots on the grid
-  int32_t mUmax = 0;              ///< U of the last knot
-  DataT mXmin = 0;                ///< X of the first knot
-  DataT mXtoUscale = 0;           ///< a scaling factor to convert X to U
   int32_t* mUtoKnotMap = nullptr; //! (transient!!) pointer to (integer U -> knot index) map inside the mFlatBufferPtr array
   DataT* mParameters = nullptr;   //! (transient!!) pointer to F-dependent parameters inside the mFlatBufferPtr array
-};
 
-template <typename DataT, typename FlatBase = FlatObject>
-class Spline1DContainer; // forward declaration
-
-template <typename DataT>
-class Spline1DContainer<DataT, FlatObject> : public Spline1DContainerBase<DataT, FlatObject>
-{
-public:
-    using Base = Spline1DContainerBase<DataT, FlatObject>;
-    using Base::Base;
-
-    ClassDefNV(Spline1DContainer, 1);
+  ClassDefNV(Spline1DContainer, 1);
 };
 
 template <typename DataT>
 class Spline1DContainer<DataT, NoFlatObject> : public Spline1DContainerBase<DataT, NoFlatObject>
 {
-public:
-    using Base = Spline1DContainerBase<DataT, NoFlatObject>;
-    using Base::Base;
+ public:
+  /// Get the U->knot-index map from an explicit flat buffer pointer.
+  GPUd() const int32_t* getUtoKnotMapFromBuffer(const char* flatBuf) const
+  {
+    return reinterpret_cast<const int32_t*>(flatBuf + this->getNumberOfKnots() * sizeof(Knot<DataT>));
+  }
+
+  /// Map a U coordinate to its left knot index, using an explicit flat buffer pointer.
+  /// Use this instead of getLeftKnotIndexForU() on the zero-copy path.
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() int32_t getLeftKnotIndexForUFromBuffer(const char* flatBuf, DataT u) const
+  {
+    int32_t iu = u < 0 ? 0 : (u > (float)this->mUmax ? this->mUmax : (int32_t)u);
+    if (SafeT == SafetyLevel::kSafe) {
+      iu = (iu < 0) ? 0 : (iu > this->mUmax ? this->mUmax : iu);
+    }
+    return getUtoKnotMapFromBuffer(flatBuf)[iu];
+  }
+
+  /// Get the knot array from an explicit flat buffer pointer.
+  /// Use this instead of getKnots() when the object was copied across process
+  /// boundaries and mFlatBufferPtr has not been fixed up (zero-copy path).
+  GPUd() const Knot<DataT>* getKnotsFromBuffer(const char* flatBuf) const { return reinterpret_cast<const Knot<DataT>*>(flatBuf); }
+
+  /// Get i-th knot from an explicit flat buffer pointer.
+  /// Use this instead of getKnot() on the zero-copy path.
+  template <SafetyLevel SafeT = SafetyLevel::kSafe>
+  GPUd() const Knot<DataT>& getKnotFromBuffer(const char* flatBuf, int32_t i) const
+  {
+    if (SafeT == SafetyLevel::kSafe) {
+      i = (i < 0) ? 0 : (i >= this->getNumberOfKnots() ? this->getNumberOfKnots() - 1 : i);
+    }
+    return getKnotsFromBuffer(flatBuf)[i];
+  }
+
+  // Lifecycle no-ops: NoFlatObject splines have no owned buffer.
+  void destroy()
+  {
+    this->mNumberOfKnots = 0;
+    this->mUmax = 0;
+    this->mYdim = 0;
+    this->mXmin = 0.;
+    this->mXtoUscale = 1.;
+    this->mFlatBufferSize = 0;
+  }
+  GPUdi() void setActualBufferAddress(char*) {}
+  GPUdi() void setFutureBufferAddress(char*) {}
+
+#if !defined(GPUCA_GPUCODE)
+  /// Copy schema fields from a spline with a different FlatBase (no pointer members to copy).
+  template <class OtherFlatBase>
+  void importFrom(const Spline1DContainerBase<DataT, OtherFlatBase>& src)
+  {
+    this->mYdim = src.getYdimensions();
+    this->mNumberOfKnots = src.getNumberOfKnots();
+    this->mUmax = src.getUmax();
+    this->mXmin = src.getXmin();
+    this->mXtoUscale = src.getXtoUscale();
+    this->mFlatBufferSize = src.getFlatBufferSize();
+  }
+#endif
 };
 
-template <typename DataT, class FlatBase>
-template <typename Spline1DContainerBase<DataT, FlatBase>::SafetyLevel SafeT>
-GPUdi() int32_t Spline1DContainerBase<DataT, FlatBase>::getLeftKnotIndexForU(DataT u) const
+template <typename DataT>
+template <SafetyLevel SafeT>
+GPUdi() int32_t Spline1DContainer<DataT, FlatObject>::getLeftKnotIndexForU(DataT u) const
 {
   /// Get i: u is in [knot_i, knot_{i+1}) segment
   /// when u is otside of [0, mUmax], return a corresponding edge segment
-  int32_t iu = u < 0 ? 0 : (u > (float)mUmax ? mUmax : (int32_t)u);
+  int32_t iu = u < 0 ? 0 : (u > (float)this->mUmax ? this->mUmax : (int32_t)u);
   if (SafeT == SafetyLevel::kSafe) {
-    iu = (iu < 0) ? 0 : (iu > mUmax ? mUmax : iu);
+    iu = (iu < 0) ? 0 : (iu > this->mUmax ? this->mUmax : iu);
   }
   return getUtoKnotMap()[iu];
 }
@@ -305,7 +302,7 @@ GPUdi() void Spline1DContainerBase<DataT, FlatBase>::setXrange(DataT xMin, DataT
   if (l < 1.e-8) {
     l = 1.e-8;
   }
-  mXtoUscale = mUmax / l;
+  mXtoUscale = this->mUmax / l;
 }
 
 /// ==================================================================================================
@@ -336,39 +333,41 @@ class Spline1DSpec;
 /// Implementations of the methods may depend on the YdimT value.
 ///
 template <typename DataT, int32_t YdimT, class FlatBase>
-class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<DataT, FlatBase>
+class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainer<DataT, FlatBase>
 {
-  typedef Spline1DContainerBase<DataT, FlatBase> TBase;
+  using Container = Spline1DContainer<DataT, FlatBase>;
 
  public:
-  typedef typename TBase::SafetyLevel SafetyLevel;
-  typedef typename TBase::Knot Knot;
+  using KnotType = Knot<DataT>;
 
   /// _______________  Interpolation math   ________________________
 
-  /// Get interpolated value S(x)
+  /// Get interpolated value S(x)  [FlatObject path only]
   GPUd() void interpolate(DataT x, GPUgeneric() DataT S[/*mYdim*/]) const
   {
-    interpolateAtU<SafetyLevel::kSafe>(mYdim, mParameters, convXtoU(x), S);
+    if constexpr (std::is_same_v<FlatBase, FlatObject>) {
+      interpolateAtU<SafetyLevel::kSafe>(this->mYdim, this->mParameters, this->convXtoU(x), S);
+    }
   }
 
   /// Get interpolated value for an nYdim-dimensional S(u) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateAtU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
-                             DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
+  GPUd() void interpolateAtU(int32_t inpYdim, GPUgeneric() const DataT Parameters[], DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
   {
-    const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
-    const auto nYdim = nYdimTmp.get();
-    int32_t iknot = TBase::template getLeftKnotIndexForU<SafeT>(u);
-    const DataT* d = Parameters + (2 * nYdim) * iknot;
-    interpolateAtU(nYdim, getKnots()[iknot], &(d[0]), &(d[nYdim]), &(d[2 * nYdim]), &(d[3 * nYdim]), u, S);
+    if constexpr (std::is_same_v<FlatBase, FlatObject>) {
+      const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
+      const auto nYdim = nYdimTmp.get();
+      int32_t iknot = this->template getLeftKnotIndexForU<SafeT>(u);
+      const DataT* d = Parameters + (2 * nYdim) * iknot;
+      interpolateAtU(nYdim, this->getKnots()[iknot], &(d[0]), &(d[nYdim]), &(d[2 * nYdim]), &(d[3 * nYdim]), u, S);
+    }
   }
 
   /// The main mathematical utility.
   /// Get interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
   /// using the spline values Sl, Sr and the slopes Dl, Dr
   template <typename T>
-  GPUd() void interpolateAtU(int32_t inpYdim, const Knot& knotL,
+  GPUd() void interpolateAtU(int32_t inpYdim, const KnotType& knotL,
                              GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
                              GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
                              DataT u, GPUgeneric() T S[/*mYdim*/]) const
@@ -389,8 +388,8 @@ class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<Dat
     if (u < (DataT)0) {
       u = (DataT)0;
     }
-    if (u > (DataT)TBase::getUmax()) {
-      u = (DataT)TBase::getUmax();
+    if (u > (DataT)ParentSpec::getUmax()) {
+      u = (DataT)ParentSpec::getUmax();
     }
 
     T uu = T(u - knotL.u);
@@ -406,7 +405,7 @@ class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<Dat
   }
 
   template <typename T>
-  GPUd() void getSderivativesOverParsAtU(const Knot& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr) const
+  GPUd() void getSderivativesOverParsAtU(const KnotType& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline parameters Sl(eft), Sr(ight) and the slopes Dl, Dr
@@ -414,8 +413,8 @@ class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<Dat
     if (u < (DataT)0) {
       u = (DataT)0;
     }
-    if (u > (DataT)TBase::getUmax()) {
-      u = (DataT)TBase::getUmax();
+    if (u > (DataT)Container::getUmax()) {
+      u = (DataT)Container::getUmax();
     }
 
     u = u - knotL.u;
@@ -431,7 +430,7 @@ class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<Dat
   }
 
   template <typename T>
-  GPUd() void getSDderivativesOverParsAtU(const Knot& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr, T& dDdSl, T& dDdDl, T& dDdSr, T& dDdDr) const
+  GPUd() void getSDderivativesOverParsAtU(const KnotType& knotL, DataT u, T& dSdSl, T& dSdDl, T& dSdSr, T& dSdDr, T& dDdSl, T& dDdDl, T& dDdSr, T& dDdDr) const
   {
     /// Get derivatives of the interpolated value {S(u): 1D -> nYdim} at the segment [knotL, next knotR]
     /// over the spline values Sl, Sr and the slopes Dl, Dr
@@ -439,8 +438,8 @@ class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<Dat
     if (u < (DataT)0) {
       u = (DataT)0;
     }
-    if (u > (DataT)TBase::getUmax()) {
-      u = (DataT)TBase::getUmax();
+    if (u > (DataT)Container::getUmax()) {
+      u = (DataT)Container::getUmax();
     }
 
     u = u - knotL.u;
@@ -461,17 +460,6 @@ class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<Dat
     // S(u) = dSdSl * Sl + dSdSr * Sr + dSdDl * Dl + dSdDr * Dr;
     // D(u) = dS(u)/du = dDdSl * Sl + dDdSr * Sr + dDdDl * Dl + dDdDr * Dr;
   }
-
-  using TBase::convXtoU;
-  using TBase::getKnot;
-  using TBase::getKnots;
-  using TBase::getNumberOfKnots;
-
- protected:
-  using TBase::mParameters;
-  using TBase::mYdim;
-  using TBase::TBase; // inherit constructors and hide them
-  ClassDefNV(Spline1DSpec, 0);
 };
 
 /// ==================================================================================================
@@ -479,43 +467,34 @@ class Spline1DSpec<DataT, YdimT, 0, FlatBase> : public Spline1DContainerBase<Dat
 /// at the compile time
 ///
 template <typename DataT, int32_t YdimT, class FlatBase>
-class Spline1DSpec<DataT, YdimT, 1, FlatBase>
-  : public Spline1DSpec<DataT, YdimT, 0, FlatBase>
+class Spline1DSpec<DataT, YdimT, 1, FlatBase> : public Spline1DSpec<DataT, YdimT, 0, FlatBase>
 {
-  typedef Spline1DContainerBase<DataT, FlatBase> TVeryBase;
-  typedef Spline1DSpec<DataT, YdimT, 0, FlatBase> TBase;
+  using ParentSpec = Spline1DSpec<DataT, YdimT, 0, FlatBase>;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-
 #if !defined(GPUCA_GPUCODE)
   /// Default constructor — skips recreate for NoFlatObject (no owned buffer)
-  Spline1DSpec() : TBase() { if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) { recreate(2); } }
-
-  /// Constructor for a regular spline
-  Spline1DSpec(int32_t numberOfKnots) : TBase()
+  Spline1DSpec() : ParentSpec()
   {
-    recreate(numberOfKnots);
+    if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+      recreate(2);
+    }
   }
+
+  /// Constructor for a regular spline
+  Spline1DSpec(int32_t numberOfKnots) : ParentSpec() { recreate(numberOfKnots); }
+
   /// Constructor for an irregular spline
-  Spline1DSpec(int32_t numberOfKnots, const int32_t knotU[])
-    : TBase()
-  {
-    recreate(numberOfKnots, knotU);
-  }
+  Spline1DSpec(int32_t numberOfKnots, const int32_t knotU[]) : ParentSpec() { recreate(numberOfKnots, knotU); }
+
   /// Copy constructor
-  Spline1DSpec(const Spline1DSpec& v) : TBase()
-  {
-    TBase::cloneFromObject(v, nullptr);
-  }
+  Spline1DSpec(const Spline1DSpec& v) : ParentSpec() { ParentSpec::cloneFromObject(v, nullptr); }
+
   /// Constructor for a regular spline
-  void recreate(int32_t numberOfKnots) { TBase::recreate(YdimT, numberOfKnots); }
+  void recreate(int32_t numberOfKnots) { ParentSpec::recreate(YdimT, numberOfKnots); }
 
   /// Constructor for an irregular spline
-  void recreate(int32_t numberOfKnots, const int32_t knotU[])
-  {
-    TBase::recreate(YdimT, numberOfKnots, knotU);
-  }
+  void recreate(int32_t numberOfKnots, const int32_t knotU[]) { ParentSpec::recreate(YdimT, numberOfKnots, knotU); }
 #endif
 
   /// Get number of Y dimensions
@@ -529,40 +508,30 @@ class Spline1DSpec<DataT, YdimT, 1, FlatBase>
   }
 
   /// Number of parameters
-  GPUd() int32_t getNumberOfParameters() const { return (2 * YdimT) * getNumberOfKnots(); }
+  GPUd() int32_t getNumberOfParameters() const { return (2 * YdimT) * this->getNumberOfKnots(); }
 
   /// Size of the parameter array in bytes
-  GPUd() size_t getSizeOfParameters() const { return (sizeof(DataT) * 2 * YdimT) * getNumberOfKnots(); }
+  GPUd() size_t getSizeOfParameters() const { return (sizeof(DataT) * 2 * YdimT) * this->getNumberOfKnots(); }
 
   ///  _______  Expert tools: interpolation with given nYdim and external Parameters _______
 
   /// Get interpolated value for an YdimT-dimensional S(u) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
-                             DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
+  GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[], DataT u, GPUgeneric() DataT S[/*nYdim*/]) const
   {
-    TBase::template interpolateAtU<SafeT>(YdimT, Parameters, u, S);
+    ParentSpec::template interpolateAtU<SafeT>(YdimT, Parameters, u, S);
   }
 
   /// Get interpolated value for an YdimT-dimensional S(u) at the segment [knotL, next knotR]
   /// using the spline values Sl, Sr and the slopes Dl, Dr
   template <typename T>
-  GPUd() void interpolateAtU(const typename TBase::Knot& knotL,
+  GPUd() void interpolateAtU(const typename ParentSpec::KnotType& knotL,
                              GPUgeneric() const T Sl[/*mYdim*/], GPUgeneric() const T Dl[/*mYdim*/],
                              GPUgeneric() const T Sr[/*mYdim*/], GPUgeneric() const T Dr[/*mYdim*/],
                              DataT u, GPUgeneric() T S[/*mYdim*/]) const
   {
-    TBase::interpolateAtU(YdimT, knotL, Sl, Dl, Sr, Dr, u, S);
+    ParentSpec::interpolateAtU(YdimT, knotL, Sl, Dl, Sr, Dr, u, S);
   }
-
-  using TBase::getNumberOfKnots;
-
-  /// _______________  Suppress some parent class methods   ________________________
- private:
-#if !defined(GPUCA_GPUCODE)
-  using TBase::recreate;
-#endif
-  using TBase::interpolateAtU;
 };
 
 /// ==================================================================================================
@@ -570,67 +539,61 @@ class Spline1DSpec<DataT, YdimT, 1, FlatBase>
 /// must be set in the runtime via a constructor parameter
 ///
 template <typename DataT, int32_t YdimT, class FlatBase>
-class Spline1DSpec<DataT, YdimT, 2, FlatBase>
-  : public Spline1DSpec<DataT, YdimT, 0, FlatBase>
+class Spline1DSpec<DataT, YdimT, 2, FlatBase> : public Spline1DSpec<DataT, YdimT, 0, FlatBase>
 {
-  typedef Spline1DContainerBase<DataT, FlatBase> TVeryBase;
-  typedef Spline1DSpec<DataT, YdimT, 0, FlatBase> TBase;
+  using ParentSpec = Spline1DSpec<DataT, YdimT, 0, FlatBase>;
+  using Container = Spline1DContainer<DataT, FlatBase>;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-
 #if !defined(GPUCA_GPUCODE)
   /// Default constructor — skips recreate for NoFlatObject (no owned buffer)
-  Spline1DSpec() : TBase() { if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) { TBase::recreate(0, 2); } }
+  Spline1DSpec() : ParentSpec()
+  {
+    if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+      ParentSpec::recreate(0, 2);
+    }
+  }
 
   /// Constructor for a regular spline
-  Spline1DSpec(int32_t nYdim, int32_t numberOfKnots) : TBase()
+  Spline1DSpec(int32_t nYdim, int32_t numberOfKnots) : ParentSpec()
   {
-    TBase::recreate(nYdim, numberOfKnots);
+    ParentSpec::recreate(nYdim, numberOfKnots);
   }
+
   /// Constructor for an irregular spline
-  Spline1DSpec(int32_t nYdim, int32_t numberOfKnots, const int32_t knotU[]) : TBase()
+  Spline1DSpec(int32_t nYdim, int32_t numberOfKnots, const int32_t knotU[]) : ParentSpec()
   {
-    TBase::recreate(nYdim, numberOfKnots, knotU);
+    ParentSpec::recreate(nYdim, numberOfKnots, knotU);
   }
+
   /// Copy constructor
-  Spline1DSpec(const Spline1DSpec& v) : TBase()
+  Spline1DSpec(const Spline1DSpec& v) : ParentSpec()
   {
-    TVeryBase::cloneFromObject(v, nullptr);
+    Container::cloneFromObject(v, nullptr);
   }
+
   /// Constructor for a regular spline
-  void recreate(int32_t nYdim, int32_t numberOfKnots) { TBase::recreate(nYdim, numberOfKnots); }
+  void recreate(int32_t nYdim, int32_t numberOfKnots) { ParentSpec::recreate(nYdim, numberOfKnots); }
 
   /// Constructor for an irregular spline
-  void recreate(int32_t nYdim, int32_t numberOfKnots, const int32_t knotU[])
-  {
-    TBase::recreate(nYdim, numberOfKnots, knotU);
-  }
+  void recreate(int32_t nYdim, int32_t numberOfKnots, const int32_t knotU[]) { ParentSpec::recreate(nYdim, numberOfKnots, knotU); }
 #endif
-
-  ///  _______  Expert tools: interpolation with given nYdim and external Parameters _______
-
-  using TBase::interpolateAtU;
-  ClassDefNV(Spline1DSpec, 0);
 };
 
 /// ==================================================================================================
 /// Specialization 3, where the number of Y dimensions is 1.
 ///
 template <typename DataT, class FlatBase>
-class Spline1DSpec<DataT, 1, 3, FlatBase>
-  : public Spline1DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase>
+class Spline1DSpec<DataT, 1, 3, FlatBase> : public Spline1DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase>
 {
-  typedef Spline1DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase> TBase;
+  using ParentSpec = Spline1DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase>;
 
  public:
-  using TBase::TBase; // inherit constructors
-
   /// Simplified interface for 1D: return the interpolated value
   GPUd() DataT interpolate(DataT x) const
   {
     DataT S = 0;
-    TBase::interpolate(x, &S);
+    ParentSpec::interpolate(x, &S);
     return S;
   }
 };
diff --git a/GPU/TPCFastTransformation/Spline2D.h b/GPU/TPCFastTransformation/Spline2D.h
index fdd7d1a65d3f9..1564e52114131 100644
--- a/GPU/TPCFastTransformation/Spline2D.h
+++ b/GPU/TPCFastTransformation/Spline2D.h
@@ -76,19 +76,16 @@ class Spline2DBase
   : public Spline2DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase>
 {
  protected:
-  typedef Spline2DContainerBase<DataT, FlatBase> TVeryBase;
-  typedef Spline2DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase> TBase;
+  using Container = Spline2DContainerBase<DataT, FlatBase>;
+  using ParentSpec = Spline2DSpec<DataT, YdimT, SplineUtil::getSpec(YdimT), FlatBase>;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-  typedef typename TVeryBase::Knot Knot;
-
 #if !defined(GPUCA_GPUCODE)
-  using TBase::TBase; // inherit constructors
+  using ParentSpec::ParentSpec; // inherit constructors
 
   Spline2DBase& operator=(const Spline2DBase& v)
   {
-    static_cast<TVeryBase*>(this)->cloneFromObject(v, nullptr);
+    static_cast<Container*>(this)->cloneFromObject(v, nullptr);
     return *this;
   }
 #else
@@ -99,7 +96,7 @@ class Spline2DBase
 #if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
   static Spline2DBase* readFromFile(TFile& inpf, const char* name)
   {
-    return (Spline2DBase*)TVeryBase::readFromFile(inpf, name);
+    return (Spline2DBase*)Container::readFromFile(inpf, name);
   }
 #endif
 };
diff --git a/GPU/TPCFastTransformation/Spline2DHelper.cxx b/GPU/TPCFastTransformation/Spline2DHelper.cxx
index 113ee4cd37370..9934704481001 100644
--- a/GPU/TPCFastTransformation/Spline2DHelper.cxx
+++ b/GPU/TPCFastTransformation/Spline2DHelper.cxx
@@ -288,8 +288,8 @@ template <typename DataT>
 void Spline2DHelper<DataT>::getScoefficients(int32_t iu, int32_t iv, double u, double v,
                                              double coeff[16], int32_t indices[16])
 {
-  const typename Spline1D<double>::Knot& knotU = fGridU.getKnot(iu);
-  const typename Spline1D<double>::Knot& knotV = fGridV.getKnot(iv);
+  const Knot<double>& knotU = fGridU.getKnot(iu);
+  const Knot<double>& knotV = fGridV.getKnot(iv);
   int32_t nu = fGridU.getNumberOfKnots();
 
   // indices of parameters that are involved in spline calculation, 1D case
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.cxx b/GPU/TPCFastTransformation/Spline2DSpec.cxx
index 9dbaa71f0c365..6622c45e3ffed 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.cxx
+++ b/GPU/TPCFastTransformation/Spline2DSpec.cxx
@@ -46,76 +46,85 @@ void Spline2DContainerBase<DataT, FlatBase>::destroy()
   mGridX2.destroy();
   mYdim = 0;
   mParameters = nullptr;
-  FlatBase::destroy();
+  if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+    FlatBase::destroy();
+  }
 }
 
 template <typename DataT, class FlatBase>
 void Spline2DContainerBase<DataT, FlatBase>::setActualBufferAddress(char* actualFlatBufferPtr)
 {
   /// See FlatObject for description
+  if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+    FlatBase::setActualBufferAddress(actualFlatBufferPtr);
 
-  FlatBase::setActualBufferAddress(actualFlatBufferPtr);
-
-  const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
-  int32_t parametersOffset = u2Offset;
-  mParameters = nullptr;
+    const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
+    mParameters = nullptr;
 
-  parametersOffset = this->alignSize(u2Offset + mGridX2.getFlatBufferSize(), getParameterAlignmentBytes());
-  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
+    const int32_t parametersOffset = this->alignSize(u2Offset + mGridX2.getFlatBufferSize(), getParameterAlignmentBytes());
+    mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
 
-  mGridX1.setActualBufferAddress(this->mFlatBufferPtr);
-  mGridX2.setActualBufferAddress(this->mFlatBufferPtr + u2Offset);
+    mGridX1.setActualBufferAddress(this->mFlatBufferPtr);
+    mGridX2.setActualBufferAddress(this->mFlatBufferPtr + u2Offset);
+  }
 }
 
 template <typename DataT, class FlatBase>
 void Spline2DContainerBase<DataT, FlatBase>::setFutureBufferAddress(char* futureFlatBufferPtr)
 {
   /// See FlatObject for description
-  char* bufferU = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mGridX1.getFlatBufferPtr());
-  char* bufferV = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mGridX2.getFlatBufferPtr());
-  mGridX1.setFutureBufferAddress(bufferU);
-  mGridX2.setFutureBufferAddress(bufferV);
-  mParameters = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mParameters);
-  FlatBase::setFutureBufferAddress(futureFlatBufferPtr);
+  if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+    char* bufferU = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mGridX1.getFlatBufferPtr());
+    char* bufferV = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mGridX2.getFlatBufferPtr());
+    mGridX1.setFutureBufferAddress(bufferU);
+    mGridX2.setFutureBufferAddress(bufferV);
+    mParameters = FlatBase::relocatePointer(this->mFlatBufferPtr, futureFlatBufferPtr, mParameters);
+    FlatBase::setFutureBufferAddress(futureFlatBufferPtr);
+  }
 }
 
 template <typename DataT, class FlatBase>
 void Spline2DContainerBase<DataT, FlatBase>::print() const
 {
-  printf(" Irregular Spline 2D: \n");
-  printf(" grid U1: \n");
-  mGridX1.print();
-  printf(" grid U2: \n");
-  mGridX2.print();
+  if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+    printf(" Irregular Spline 2D: \n");
+    printf(" grid U1: \n");
+    mGridX1.print();
+    printf(" grid U2: \n");
+    mGridX2.print();
+  }
 }
 
 template <typename DataT, class FlatBase>
 void Spline2DContainerBase<DataT, FlatBase>::cloneFromObject(const Spline2DContainerBase<DataT, FlatBase>& obj, char* newFlatBufferPtr)
 {
   /// See FlatObject for description
+  if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+    const char* oldFlatBufferPtr = obj.mFlatBufferPtr;
 
-  const char* oldFlatBufferPtr = obj.mFlatBufferPtr;
-
-  FlatBase::cloneFromObject(obj, newFlatBufferPtr);
+    FlatBase::cloneFromObject(obj, newFlatBufferPtr);
 
-  mYdim = obj.mYdim;
-  char* bufferU = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mGridX1.getFlatBufferPtr());
-  char* bufferV = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mGridX2.getFlatBufferPtr());
+    mYdim = obj.mYdim;
+    char* bufferU = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mGridX1.getFlatBufferPtr());
+    char* bufferV = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mGridX2.getFlatBufferPtr());
 
-  mGridX1.cloneFromObject(obj.mGridX1, bufferU);
-  mGridX2.cloneFromObject(obj.mGridX2, bufferV);
-  mParameters = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mParameters);
+    mGridX1.cloneFromObject(obj.mGridX1, bufferU);
+    mGridX2.cloneFromObject(obj.mGridX2, bufferV);
+    mParameters = FlatBase::relocatePointer(oldFlatBufferPtr, this->mFlatBufferPtr, obj.mParameters);
+  }
 }
 
 template <typename DataT, class FlatBase>
 void Spline2DContainerBase<DataT, FlatBase>::moveBufferTo(char* newFlatBufferPtr)
 {
   /// See FlatObject for description
-  char* oldFlatBufferPtr = this->mFlatBufferPtr;
-  FlatBase::moveBufferTo(newFlatBufferPtr);
-  char* currFlatBufferPtr = this->mFlatBufferPtr;
-  this->mFlatBufferPtr = oldFlatBufferPtr;
-  setActualBufferAddress(currFlatBufferPtr);
+  if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+    char* oldFlatBufferPtr = this->mFlatBufferPtr;
+    FlatBase::moveBufferTo(newFlatBufferPtr);
+    char* currFlatBufferPtr = this->mFlatBufferPtr;
+    this->mFlatBufferPtr = oldFlatBufferPtr;
+    setActualBufferAddress(currFlatBufferPtr);
+  }
 }
 
 template <typename DataT, class FlatBase>
@@ -136,61 +145,63 @@ void Spline2DContainerBase<DataT, FlatBase>::recreate(
   int32_t nYdim,
   int32_t numberOfKnotsU1, const int32_t knotsU1[], int32_t numberOfKnotsU2, const int32_t knotsU2[])
 {
-  /// Constructor for an irregular spline
-
-  mYdim = nYdim;
-  FlatBase::startConstruction();
+  /// Constructor for an irregular spline — only valid for FlatObject.
+  if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+    mYdim = nYdim;
+    FlatBase::startConstruction();
 
-  mGridX1.recreate(0, numberOfKnotsU1, knotsU1);
-  mGridX2.recreate(0, numberOfKnotsU2, knotsU2);
+    mGridX1.recreate(0, numberOfKnotsU1, knotsU1);
+    mGridX2.recreate(0, numberOfKnotsU2, knotsU2);
 
-  const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
-  int32_t parametersOffset = u2Offset + mGridX2.getFlatBufferSize();
-  int32_t bufferSize = parametersOffset;
-  mParameters = nullptr;
+    const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
+    int32_t parametersOffset = u2Offset + mGridX2.getFlatBufferSize();
+    int32_t bufferSize = parametersOffset;
+    mParameters = nullptr;
 
-  parametersOffset = this->alignSize(bufferSize, getParameterAlignmentBytes());
-  bufferSize = parametersOffset + getSizeOfParameters();
+    parametersOffset = this->alignSize(bufferSize, getParameterAlignmentBytes());
+    bufferSize = parametersOffset + getSizeOfParameters();
 
-  FlatBase::finishConstruction(bufferSize);
+    FlatBase::finishConstruction(bufferSize);
 
-  mGridX1.moveBufferTo(this->mFlatBufferPtr);
-  mGridX2.moveBufferTo(this->mFlatBufferPtr + u2Offset);
+    mGridX1.moveBufferTo(this->mFlatBufferPtr);
+    mGridX2.moveBufferTo(this->mFlatBufferPtr + u2Offset);
 
-  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
-  for (int32_t i = 0; i < getNumberOfParameters(); i++) {
-    mParameters[i] = 0;
+    mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
+    for (int32_t i = 0; i < getNumberOfParameters(); i++) {
+      mParameters[i] = 0;
+    }
   }
 }
 
 template <typename DataT, class FlatBase>
 void Spline2DContainerBase<DataT, FlatBase>::recreate(int32_t nYdim,
-                                                  int32_t numberOfKnotsU1, int32_t numberOfKnotsU2)
+                                                      int32_t numberOfKnotsU1, int32_t numberOfKnotsU2)
 {
-  /// Constructor for a regular spline
-
-  mYdim = nYdim;
-  FlatBase::startConstruction();
+  /// Constructor for a regular spline — only valid for FlatObject.
+  if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+    mYdim = nYdim;
+    FlatBase::startConstruction();
 
-  mGridX1.recreate(0, numberOfKnotsU1);
-  mGridX2.recreate(0, numberOfKnotsU2);
+    mGridX1.recreate(0, numberOfKnotsU1);
+    mGridX2.recreate(0, numberOfKnotsU2);
 
-  const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
-  int32_t parametersOffset = u2Offset + mGridX2.getFlatBufferSize();
-  int32_t bufferSize = parametersOffset;
-  mParameters = nullptr;
+    const size_t u2Offset = this->alignSize(mGridX1.getFlatBufferSize(), mGridX2.getBufferAlignmentBytes());
+    int32_t parametersOffset = u2Offset + mGridX2.getFlatBufferSize();
+    int32_t bufferSize = parametersOffset;
+    mParameters = nullptr;
 
-  parametersOffset = this->alignSize(bufferSize, getParameterAlignmentBytes());
-  bufferSize = parametersOffset + getSizeOfParameters();
+    parametersOffset = this->alignSize(bufferSize, getParameterAlignmentBytes());
+    bufferSize = parametersOffset + getSizeOfParameters();
 
-  FlatBase::finishConstruction(bufferSize);
+    FlatBase::finishConstruction(bufferSize);
 
-  mGridX1.moveBufferTo(this->mFlatBufferPtr);
-  mGridX2.moveBufferTo(this->mFlatBufferPtr + u2Offset);
+    mGridX1.moveBufferTo(this->mFlatBufferPtr);
+    mGridX2.moveBufferTo(this->mFlatBufferPtr + u2Offset);
 
-  mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
-  for (int32_t i = 0; i < getNumberOfParameters(); i++) {
-    mParameters[i] = 0;
+    mParameters = reinterpret_cast<DataT*>(this->mFlatBufferPtr + parametersOffset);
+    for (int32_t i = 0; i < getNumberOfParameters(); i++) {
+      mParameters[i] = 0;
+    }
   }
 }
 
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/TPCFastTransformation/Spline2DSpec.h
index 3ce8affd4062e..2c50343d98063 100644
--- a/GPU/TPCFastTransformation/Spline2DSpec.h
+++ b/GPU/TPCFastTransformation/Spline2DSpec.h
@@ -50,9 +50,6 @@ template <typename DataT, class FlatBase = FlatObject>
 class Spline2DContainerBase : public FlatBase
 {
  public:
-  typedef typename Spline1D<DataT>::SafetyLevel SafetyLevel;
-  typedef typename Spline1D<DataT>::Knot Knot;
-
   /// _____________  Version control __________________________
 
   /// Version control
@@ -121,8 +118,10 @@ class Spline2DContainerBase : public FlatBase
   /// Get (u1,u2) of i-th knot
   GPUd() void getKnotU(int32_t iKnot, int32_t& u1, int32_t& u2) const
   {
-    u1 = mGridX1.getKnot(iKnot % mGridX1.getNumberOfKnots()).getU();
-    u2 = mGridX2.getKnot(iKnot / mGridX1.getNumberOfKnots()).getU();
+    if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+      u1 = mGridX1.getKnot(iKnot % mGridX1.getNumberOfKnots()).getU();
+      u2 = mGridX2.getKnot(iKnot / mGridX1.getNumberOfKnots()).getU();
+    }
   }
 
   /// Get index of a knot (iKnotX1,iKnotX2)
@@ -139,11 +138,23 @@ class Spline2DContainerBase : public FlatBase
 
   /// _______________  Technical stuff  ________________________
 
-  /// Get offset of GridX1 flat data in the flat buffer
-  GPUd() size_t getGridX1Offset() const { return mGridX1.getFlatBufferPtr() - this->mFlatBufferPtr; }
+  /// Get offset of GridX1 flat data in the flat buffer (only valid for FlatObject-based splines)
+  GPUd() size_t getGridX1Offset() const
+  {
+    if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+      return mGridX1.getFlatBufferPtr() - this->mFlatBufferPtr;
+    }
+    return 0;
+  }
 
-  /// Get offset of GridX2 flat data in the flat buffer
-  GPUd() size_t getGridX2Offset() const { return mGridX2.getFlatBufferPtr() - this->mFlatBufferPtr; }
+  /// Get offset of GridX2 flat data in the flat buffer (only valid for FlatObject-based splines)
+  GPUd() size_t getGridX2Offset() const
+  {
+    if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+      return mGridX2.getFlatBufferPtr() - this->mFlatBufferPtr;
+    }
+    return 0;
+  }
 
   /// Set X range
   GPUd() void setXrange(DataT x1Min, DataT x1Max, DataT x2Min, DataT x2Max)
@@ -168,10 +179,6 @@ class Spline2DContainerBase : public FlatBase
 #endif
 
   /// _____________  FlatObject functionality, see FlatObject class for description  ____________
-
-  using FlatBase::getBufferAlignmentBytes;
-  using FlatBase::getClassAlignmentBytes;
-
 #if !defined(GPUCA_GPUCODE)
   void cloneFromObject(const Spline2DContainerBase& obj, char* newFlatBufferPtr);
   void moveBufferTo(char* newBufferPtr);
@@ -182,8 +189,6 @@ class Spline2DContainerBase : public FlatBase
   void importFrom(const Spline2DContainerBase<DataT, OtherFlatBase>& src);
 #endif
 
-  using FlatBase::releaseInternalBuffer;
-
   void destroy();
   void setActualBufferAddress(char* actualFlatBufferPtr);
   void setFutureBufferAddress(char* futureFlatBufferPtr);
@@ -199,10 +204,10 @@ class Spline2DContainerBase : public FlatBase
 
   /// _____________  Data members  ____________
 
-  int32_t mYdim = 0;                      ///< dimentionality of F
-  Spline1D<DataT, 0, FlatBase> mGridX1;   ///< grid for U axis
-  Spline1D<DataT, 0, FlatBase> mGridX2;   ///< grid for V axis
-  DataT* mParameters = nullptr; //! (transient!!) F-dependent parameters of the spline
+  int32_t mYdim = 0;                    ///< dimentionality of F
+  Spline1D<DataT, 0, FlatBase> mGridX1; ///< grid for U axis
+  Spline1D<DataT, 0, FlatBase> mGridX2; ///< grid for V axis
+  DataT* mParameters = nullptr;         //! (transient!!) F-dependent parameters of the spline
 };
 
 template <typename DataT, typename FlatBase = FlatObject>
@@ -211,19 +216,13 @@ class Spline2DContainer; // forward declaration
 template <typename DataT>
 class Spline2DContainer<DataT, FlatObject> : public Spline2DContainerBase<DataT, FlatObject>
 {
-public:
-    using Base = Spline2DContainerBase<DataT, FlatObject>;
-    using Base::Base;
-
-    ClassDefNV(Spline2DContainer, 1);
+ public:
+  ClassDefNV(Spline2DContainer, 1);
 };
 
 template <typename DataT>
 class Spline2DContainer<DataT, NoFlatObject> : public Spline2DContainerBase<DataT, NoFlatObject>
 {
-public:
-    using Base = Spline2DContainerBase<DataT, NoFlatObject>;
-    using Base::Base;
 };
 
 /// ==================================================================================================
@@ -255,18 +254,13 @@ template <typename DataT, int32_t YdimT, class FlatBase>
 class Spline2DSpec<DataT, YdimT, 0, FlatBase>
   : public Spline2DContainerBase<DataT, FlatBase>
 {
-  typedef Spline2DContainerBase<DataT, FlatBase> TBase;
-
  public:
-  typedef typename TBase::SafetyLevel SafetyLevel;
-  typedef typename TBase::Knot Knot;
-
   /// _______________  Interpolation math   ________________________
 
   /// Get interpolated value S(x)
   GPUd() void interpolate(DataT x1, DataT x2, GPUgeneric() DataT S[/*mYdim*/]) const
   {
-    interpolateAtU<SafetyLevel::kSafe>(mYdim, mParameters, mGridX1.convXtoU(x1), mGridX2.convXtoU(x2), S);
+    interpolateAtU<SafetyLevel::kSafe>(this->mYdim, this->mParameters, this->mGridX1.convXtoU(x1), this->mGridX2.convXtoU(x2), S);
   }
 
   /// Get interpolated value for an inpYdim-dimensional S(u1,u2) using spline parameters Parameters.
@@ -286,12 +280,12 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
 
     const DataT& u = u1;
     const DataT& v = u2;
-    int32_t nu = mGridX1.getNumberOfKnots();
-    int32_t iu = mGridX1.template getLeftKnotIndexForU<SafeT>(u);
-    int32_t iv = mGridX2.template getLeftKnotIndexForU<SafeT>(v);
+    int32_t nu = this->mGridX1.getNumberOfKnots();
+    int32_t iu = this->mGridX1.template getLeftKnotIndexForU<SafeT>(u);
+    int32_t iv = this->mGridX2.template getLeftKnotIndexForU<SafeT>(v);
 
-    const typename TBase::Knot& knotU = mGridX1.template getKnot<SafetyLevel::kNotSafe>(iu);
-    const typename TBase::Knot& knotV = mGridX2.template getKnot<SafetyLevel::kNotSafe>(iv);
+    const auto& knotU = this->mGridX1.template getKnot<SafetyLevel::kNotSafe>(iu);
+    const auto& knotV = this->mGridX2.template getKnot<SafetyLevel::kNotSafe>(iv);
 
     const DataT* par00 = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* par10 = par00 + nYdim4;                       // values { ... } at {u1, v0}
@@ -319,8 +313,8 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
 
     DataT parU[maxYdim4]; // interpolated values { {Y1,Y2,Y3,Y1'v,Y2'v,Y3'v}(v0), {Y1,Y2,Y3,Y1'v,Y2'v,Y3'v}(v1) } at u
 
-    typedef Spline1DSpec<DataT, 4 * YdimT, 0> TGridX1;
-    const TGridX1& gridX1 = reinterpret_cast<const TGridX1&>(mGridX1);
+    using GridX1Base = Spline1DSpec<DataT, 4 * YdimT, 0>;
+    const GridX1Base& gridX1 = reinterpret_cast<const GridX1Base&>(this->mGridX1);
 
     gridX1.interpolateAtU(nYdim4, knotU, Su0, Du0, Su1, Du1, u, parU);
 
@@ -329,8 +323,8 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
     const DataT* Sv1 = parU + nYdim2;
     const DataT* Dv1 = parU + nYdim2 + nYdim;
 
-    typedef Spline1DSpec<DataT, YdimT, 0> TGridX2;
-    const TGridX2& gridX2 = reinterpret_cast<const TGridX2&>(mGridX2);
+    using GridX2Base = Spline1DSpec<DataT, YdimT, 0>;
+    const GridX2Base& gridX2 = reinterpret_cast<const GridX2Base&>(this->mGridX2);
     gridX2.interpolateAtU(nYdim, knotV, Sv0, Dv0, Sv1, Dv1, v, S);
   }
 
@@ -339,6 +333,9 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
   GPUd() void interpolateAtU(int32_t inpYdim, GPUgeneric() const DataT Parameters[],
                              DataT u1, DataT u2, GPUgeneric() DataT S[/*inpYdim*/]) const
   {
+    if constexpr (!std::is_same_v<FlatBase, FlatObject>) {
+      return;
+    }
 
     const auto nYdimTmp = SplineUtil::getNdim<YdimT>(inpYdim);
     const int32_t nYdim = nYdimTmp.get();
@@ -351,19 +348,19 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
 
     const DataT& u = u1;
     const DataT& v = u2;
-    int32_t nu = mGridX1.getNumberOfKnots();
-    int32_t iu = mGridX1.template getLeftKnotIndexForU<SafeT>(u);
-    int32_t iv = mGridX2.template getLeftKnotIndexForU<SafeT>(v);
+    int32_t nu = this->mGridX1.getNumberOfKnots();
+    int32_t iu = this->mGridX1.template getLeftKnotIndexForU<SafeT>(u);
+    int32_t iv = this->mGridX2.template getLeftKnotIndexForU<SafeT>(v);
 
-    const typename TBase::Knot& knotU = mGridX1.template getKnot<SafetyLevel::kNotSafe>(iu);
-    const typename TBase::Knot& knotV = mGridX2.template getKnot<SafetyLevel::kNotSafe>(iv);
+    const auto& knotU = this->mGridX1.template getKnot<SafetyLevel::kNotSafe>(iu);
+    const auto& knotV = this->mGridX2.template getKnot<SafetyLevel::kNotSafe>(iv);
 
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
 
     DataT dSl, dDl, dSr, dDr, dSd, dDd, dSu, dDu;
-    mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u, dSl, dDl, dSr, dDr);
-    mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v, dSd, dDd, dSu, dDu);
+    this->mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u, dSl, dDl, dSr, dDr);
+    this->mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v, dSd, dDd, dSu, dDu);
 
     // when nYdim == 1:
     // S = dSl * (dSd * A[0] + dDd * A[1]) + dDl * (dSd * A[2] + dDd * A[3]) +
@@ -408,20 +405,20 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
 
     const DataT& u = u1;
     const DataT& v = u2;
-    int32_t nu = mGridX1.getNumberOfKnots();
-    int32_t iu = mGridX1.template getLeftKnotIndexForU<SafeT>(u);
-    int32_t iv = mGridX2.template getLeftKnotIndexForU<SafeT>(v);
+    int32_t nu = this->mGridX1.getNumberOfKnots();
+    int32_t iu = this->mGridX1.template getLeftKnotIndexForU<SafeT>(u);
+    int32_t iv = this->mGridX2.template getLeftKnotIndexForU<SafeT>(v);
 
-    const typename TBase::Knot& knotU = mGridX1.template getKnot<SafetyLevel::kNotSafe>(iu);
-    const typename TBase::Knot& knotV = mGridX2.template getKnot<SafetyLevel::kNotSafe>(iv);
+    const auto& knotU = this->mGridX1.template getKnot<SafetyLevel::kNotSafe>(iu);
+    const auto& knotV = this->mGridX2.template getKnot<SafetyLevel::kNotSafe>(iv);
 
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4; // values { {Y1,Y2,Y3}, {Y1,Y2,Y3}'v, {Y1,Y2,Y3}'u, {Y1,Y2,Y3}''vu } at {u0, v0}
     const DataT* B = A + nYdim4 * nu;                      // values { ... } at {u0, v1}
 
     DataT dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr;
-    mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u, dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr);
+    this->mGridX1.template getSDderivativesOverParsAtU<DataT>(knotU, u, dSdSl, dSdDl, dSdSr, dSdDr, dRdSl, dRdDl, dRdSr, dRdDr);
     DataT dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu;
-    mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v, dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu);
+    this->mGridX2.template getSDderivativesOverParsAtU<DataT>(knotV, v, dSdSd, dSdDd, dSdSu, dSdDu, dQdSd, dQdDd, dQdSu, dQdDu);
 
     // when nYdim == 1:
 
@@ -555,16 +552,16 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
 
     // getNumberOfKnots() is safe: mNumberOfKnots is a plain int stored directly
     // in the Spline1DContainer struct, not behind mFlatBufferPtr.
-    int32_t nu = mGridX1.getNumberOfKnots();
+    int32_t nu = this->mGridX1.getNumberOfKnots();
 
     // Use buffer-aware accessors instead of mGridX1.getLeftKnotIndexForU() and
     // mGridX1.getKnot(). Both of the standard versions dereference mFlatBufferPtr
     // (via mUtoKnotMap and the knot array), which is stale after cross-process copy.
-    int32_t iu = mGridX1.getLeftKnotIndexForUFromBuffer(gridX1FlatBuf, u);
-    int32_t iv = mGridX2.getLeftKnotIndexForUFromBuffer(gridX2FlatBuf, v);
+    int32_t iu = this->mGridX1.getLeftKnotIndexForUFromBuffer(gridX1FlatBuf, u);
+    int32_t iv = this->mGridX2.getLeftKnotIndexForUFromBuffer(gridX2FlatBuf, v);
 
-    const auto& knotU = mGridX1.template getKnotFromBuffer<decltype(mGridX1)::kNotSafe>(gridX1FlatBuf, iu);
-    const auto& knotV = mGridX2.template getKnotFromBuffer<decltype(mGridX2)::kNotSafe>(gridX2FlatBuf, iv);
+    const auto& knotU = this->mGridX1.template getKnotFromBuffer<kNotSafe>(gridX1FlatBuf, iu);
+    const auto& knotV = this->mGridX2.template getKnotFromBuffer<kNotSafe>(gridX2FlatBuf, iv);
 
     const DataT* A = Parameters + (nu * iv + iu) * nYdim4;
     const DataT* B = A + nYdim4 * nu;
@@ -572,8 +569,8 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
     // getSderivativesOverParsAtU() is pure math on the Knot struct fields {u, Li}.
     // It does NOT touch mFlatBufferPtr, so it is safe on the zero-copy path.
     DataT dSl, dDl, dSr, dDr, dSd, dDd, dSu, dDu;
-    mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u, dSl, dDl, dSr, dDr);
-    mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v, dSd, dDd, dSu, dDu);
+    this->mGridX1.template getSderivativesOverParsAtU<DataT>(knotU, u, dSl, dDl, dSr, dDr);
+    this->mGridX2.template getSderivativesOverParsAtU<DataT>(knotV, v, dSd, dDd, dSu, dDu);
 
     DataT a[8] = {dSl * dSd, dSl * dDd, dDl * dSd, dDl * dDd,
                   dSr * dSd, dSr * dDd, dDr * dSd, dDr * dDd};
@@ -587,13 +584,6 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
       }
     }
   }
-
- protected:
-  using TBase::mGridX1;
-  using TBase::mGridX2;
-  using TBase::mParameters;
-  using TBase::mYdim;
-  using TBase::TBase; // inherit constructors and hide them
 };
 
 /// ==================================================================================================
@@ -601,105 +591,80 @@ class Spline2DSpec<DataT, YdimT, 0, FlatBase>
 /// at the compile time
 ///
 template <typename DataT, int32_t YdimT, class FlatBase>
-class Spline2DSpec<DataT, YdimT, 1, FlatBase>
-  : public Spline2DSpec<DataT, YdimT, 0, FlatBase>
+class Spline2DSpec<DataT, YdimT, 1, FlatBase> : public Spline2DSpec<DataT, YdimT, 0, FlatBase>
 {
-  typedef Spline2DContainerBase<DataT, FlatBase> TVeryBase;
-  typedef Spline2DSpec<DataT, YdimT, 0, FlatBase> TBase;
+  using ParentSpec = Spline2DSpec<DataT, YdimT, 0, FlatBase>;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-
 #if !defined(GPUCA_GPUCODE)
   /// Default constructor — skips recreate for NoFlatObject (no owned buffer)
-  Spline2DSpec() : TBase() { if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) { recreate(2, 2); } }
+  Spline2DSpec() : ParentSpec()
+  {
+    if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+      recreate(2, 2);
+    }
+  }
 
   /// Constructor for a regular spline
-  Spline2DSpec(int32_t nKnotsX1, int32_t nKnotsX2) : TBase()
+  Spline2DSpec(int32_t nKnotsX1, int32_t nKnotsX2) : ParentSpec()
   {
     recreate(nKnotsX1, nKnotsX2);
   }
   /// Constructor for an irregular spline
-  Spline2DSpec(int32_t nKnotsX1, const int32_t knotU1[],
-               int32_t nKnotsX2, const int32_t knotU2[])
-    : TBase()
+  Spline2DSpec(int32_t nKnotsX1, const int32_t knotU1[], int32_t nKnotsX2, const int32_t knotU2[]) : ParentSpec()
   {
     recreate(nKnotsX1, knotU1, nKnotsX2, knotU2);
   }
   /// Copy constructor
-  Spline2DSpec(const Spline2DSpec& v) : TBase()
+  Spline2DSpec(const Spline2DSpec& v) : ParentSpec()
   {
-    TBase::cloneFromObject(v, nullptr);
+    ParentSpec::cloneFromObject(v, nullptr);
   }
   /// Constructor for a regular spline
-  void recreate(int32_t nKnotsX1, int32_t nKnotsX2)
-  {
-    TBase::recreate(YdimT, nKnotsX1, nKnotsX2);
-  }
+  void recreate(int32_t nKnotsX1, int32_t nKnotsX2) { ParentSpec::recreate(YdimT, nKnotsX1, nKnotsX2); }
 
   /// Constructor for an irregular spline
-  void recreate(int32_t nKnotsX1, const int32_t knotU1[],
-                int32_t nKnotsX2, const int32_t knotU2[])
-  {
-    TBase::recreate(YdimT, nKnotsX1, knotU1, nKnotsX2, knotU2);
-  }
+  void recreate(int32_t nKnotsX1, const int32_t knotU1[], int32_t nKnotsX2, const int32_t knotU2[]) { ParentSpec::recreate(YdimT, nKnotsX1, knotU1, nKnotsX2, knotU2); }
 #endif
 
   /// Get number of Y dimensions
   GPUd() constexpr int32_t getYdimensions() const { return YdimT; }
 
   /// Number of parameters
-  GPUd() int32_t getNumberOfParameters() const { return (4 * YdimT) * getNumberOfKnots(); }
+  GPUd() int32_t getNumberOfParameters() const { return (4 * YdimT) * this->getNumberOfKnots(); }
 
   /// Size of the parameter array in bytes
-  GPUd() size_t getSizeOfParameters() const { return (sizeof(DataT) * 4 * YdimT) * getNumberOfKnots(); }
+  GPUd() size_t getSizeOfParameters() const { return (sizeof(DataT) * 4 * YdimT) * this->getNumberOfKnots(); }
 
   ///  _______  Expert tools: interpolation with given nYdim and external Parameters _______
 
   /// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[],
-                             DataT u1, DataT u2, GPUgeneric() DataT S[/*YdimT*/]) const
+  GPUd() void interpolateAtU(GPUgeneric() const DataT Parameters[], DataT u1, DataT u2, GPUgeneric() DataT S[/*YdimT*/]) const
   {
-    TBase::template interpolateAtU<SafeT>(YdimT, Parameters, u1, u2, S);
+    ParentSpec::template interpolateAtU<SafeT>(YdimT, Parameters, u1, u2, S);
   }
 
   /// Forwarding overload for Spec 1 (compile-time YdimT).
   /// Passes YdimT as inpYdim directly to the Spec 0 implementation.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateAtUZeroCopy(const char* gridX1FlatBuf,
-                                     const char* gridX2FlatBuf,
-                                     GPUgeneric() const DataT Parameters[],
-                                     DataT u1, DataT u2,
-                                     GPUgeneric() DataT S[/*YdimT*/]) const
+  GPUd() void interpolateAtUZeroCopy(const char* gridX1FlatBuf, const char* gridX2FlatBuf, GPUgeneric() const DataT Parameters[], DataT u1, DataT u2, GPUgeneric() DataT S[/*YdimT*/]) const
   {
-    TBase::template interpolateAtUZeroCopy<SafeT>(gridX1FlatBuf, gridX2FlatBuf,
-                                                  YdimT, Parameters, u1, u2, S);
+    ParentSpec::template interpolateAtUZeroCopy<SafeT>(gridX1FlatBuf, gridX2FlatBuf, YdimT, Parameters, u1, u2, S);
   }
 
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateParametersAtU(GPUgeneric() const DataT Parameters[],
-                                       DataT u1, DataT u2, GPUgeneric() DataT P[/* 4*YdimT */]) const
+  GPUd() void interpolateParametersAtU(GPUgeneric() const DataT Parameters[], DataT u1, DataT u2, GPUgeneric() DataT P[/* 4*YdimT */]) const
   {
-    TBase::template interpolateParametersAtU<SafeT>(YdimT, Parameters, u1, u2, P);
+    ParentSpec::template interpolateParametersAtU<SafeT>(YdimT, Parameters, u1, u2, P);
   }
 
   /// Get interpolated value for an YdimT-dimensional S(u1,u2) using spline parameters Parameters.
   template <SafetyLevel SafeT = SafetyLevel::kSafe>
-  GPUd() void interpolateAtUold(GPUgeneric() const DataT Parameters[],
-                                DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
+  GPUd() void interpolateAtUold(GPUgeneric() const DataT Parameters[], DataT u1, DataT u2, GPUgeneric() DataT S[/*nYdim*/]) const
   {
-    TBase::template interpolateAtUold<SafeT>(YdimT, Parameters, u1, u2, S);
+    ParentSpec::template interpolateAtUold<SafeT>(YdimT, Parameters, u1, u2, S);
   }
-
-  using TBase::getNumberOfKnots;
-
-  /// _______________  Suppress some parent class methods   ________________________
- private:
-#if !defined(GPUCA_GPUCODE)
-  using TBase::recreate;
-#endif
-  using TBase::interpolateAtU;
 };
 
 /// ==================================================================================================
@@ -707,81 +672,62 @@ class Spline2DSpec<DataT, YdimT, 1, FlatBase>
 /// must be set in the runtime via a constructor parameter
 ///
 template <typename DataT, int32_t YdimT, class FlatBase>
-class Spline2DSpec<DataT, YdimT, 2, FlatBase>
-  : public Spline2DSpec<DataT, YdimT, 0, FlatBase>
+class Spline2DSpec<DataT, YdimT, 2, FlatBase> : public Spline2DSpec<DataT, YdimT, 0, FlatBase>
 {
-  typedef Spline2DContainerBase<DataT, FlatBase> TVeryBase;
-  typedef Spline2DSpec<DataT, YdimT, 0, FlatBase> TBase;
+  using ParentSpec = Spline2DSpec<DataT, YdimT, 0, FlatBase>;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-
 #if !defined(GPUCA_GPUCODE)
   /// Default constructor — skips recreate for NoFlatObject (no owned buffer)
-  Spline2DSpec() : TBase() { if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) { TBase::recreate(0, 2, 2); } }
+  Spline2DSpec() : ParentSpec()
+  {
+    if constexpr (!std::is_same_v<FlatBase, NoFlatObject>) {
+      ParentSpec::recreate(0, 2, 2);
+    }
+  }
 
   /// Constructor for a regular spline
-  Spline2DSpec(int32_t nYdim, int32_t nKnotsX1, int32_t nKnotsX2) : TBase()
+  Spline2DSpec(int32_t nYdim, int32_t nKnotsX1, int32_t nKnotsX2) : ParentSpec()
   {
-    TBase::recreate(nYdim, nKnotsX1, nKnotsX2);
+    ParentSpec::recreate(nYdim, nKnotsX1, nKnotsX2);
   }
 
   /// Constructor for an irregular spline
-  Spline2DSpec(int32_t nYdim, int32_t nKnotsX1, const int32_t knotU1[],
-               int32_t nKnotsX2, const int32_t knotU2[]) : TBase()
+  Spline2DSpec(int32_t nYdim, int32_t nKnotsX1, const int32_t knotU1[], int32_t nKnotsX2, const int32_t knotU2[]) : ParentSpec()
   {
-    TBase::recreate(nYdim, nKnotsX1, knotU1, nKnotsX2, knotU2);
+    ParentSpec::recreate(nYdim, nKnotsX1, knotU1, nKnotsX2, knotU2);
   }
 
   /// Copy constructor
-  Spline2DSpec(const Spline2DSpec& v) : TBase()
+  Spline2DSpec(const Spline2DSpec& v) : ParentSpec()
   {
     cloneFromObject(v, nullptr);
   }
 
   /// Constructor for a regular spline
-  void recreate(int32_t nYdim, int32_t nKnotsX1, int32_t nKnotsX2)
-  {
-    TBase::recreate(nYdim, nKnotsX1, nKnotsX2);
-  }
+  void recreate(int32_t nYdim, int32_t nKnotsX1, int32_t nKnotsX2) { ParentSpec::recreate(nYdim, nKnotsX1, nKnotsX2); }
 
   /// Constructor for an irregular spline
-  void recreate(int32_t nYdim, int32_t nKnotsX1, const int32_t knotU1[],
-                int32_t nKnotsX2, const int32_t knotU2[])
-  {
-    TBase::recreate(nYdim, nKnotsX1, knotU1, nKnotsX2, knotU2);
-  }
+  void recreate(int32_t nYdim, int32_t nKnotsX1, const int32_t knotU1[], int32_t nKnotsX2, const int32_t knotU2[]) { ParentSpec::recreate(nYdim, nKnotsX1, knotU1, nKnotsX2, knotU2); }
 #endif
-
-  ///  _______  Expert tools: interpolation with given nYdim and external Parameters _______
-
-  using TBase::interpolateAtU;
-  using TBase::interpolateAtUZeroCopy;
 };
 
 /// ==================================================================================================
 /// Specialization 3, where the number of Y dimensions is 1.
 ///
 template <typename DataT, class FlatBase>
-class Spline2DSpec<DataT, 1, 3, FlatBase>
-  : public Spline2DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase>
+class Spline2DSpec<DataT, 1, 3, FlatBase> : public Spline2DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase>
 {
-  typedef Spline2DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase> TBase;
+  using ParentSpec = Spline2DSpec<DataT, 1, SplineUtil::getSpec(999), FlatBase>;
 
  public:
-  using TBase::TBase; // inherit constructors
-
   /// Simplified interface for 1D: return the interpolated value
   GPUd() DataT interpolate(DataT x1, DataT x2) const
   {
     DataT S = 0;
-    TBase::interpolate(x1, x2, &S);
+    ParentSpec::interpolate(x1, x2, &S);
     return S;
   }
-
-  // this parent method should be public anyhow,
-  // but w/o this extra declaration compiler gets confused
-  using TBase::interpolate;
 };
 } // namespace gpu
 } // namespace o2
diff --git a/GPU/TPCFastTransformation/SplineSpec.h b/GPU/TPCFastTransformation/SplineSpec.h
index 31b6bef22103c..f9193fa51eaec 100644
--- a/GPU/TPCFastTransformation/SplineSpec.h
+++ b/GPU/TPCFastTransformation/SplineSpec.h
@@ -47,8 +47,7 @@ template <typename DataT>
 class SplineContainer : public FlatObject
 {
  public:
-  typedef typename Spline1D<DataT>::SafetyLevel SafetyLevel;
-  typedef typename Spline1D<DataT>::Knot Knot;
+  using KnotType = Knot<DataT>;
 
   /// _____________  Version control __________________________
 
@@ -261,8 +260,7 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
   typedef SplineContainer<DataT> TBase;
 
  public:
-  typedef typename TBase::SafetyLevel SafetyLevel;
-  typedef typename TBase::Knot Knot;
+  using KnotType = Knot<DataT>;
 
   /// _______________  Interpolation math   ________________________
 
@@ -341,10 +339,10 @@ class SplineSpec<DataT, XdimT, YdimT, 0> : public SplineContainer<DataT>
         } // end for j (every parametertype)
       } // end for i (every knot)
 
-      const typename Spline1D<DataT>::Knot& knotL = mGrid[d].getKnot(indices[d]);
+      const typename Spline1D<DataT>::KnotType& knotL = mGrid[d].getKnot(indices[d]);
       DataT coordinate = u[d];
-      typedef Spline1DSpec<DataT, 0, 0> TGridX;
-      const TGridX& gridX = *((const TGridX*)&(mGrid[d]));
+      using GridXBase = Spline1DSpec<DataT, 0, 0>;
+      const GridXBase& gridX = *((const GridXBase*)&(mGrid[d]));
       gridX.interpolateAtU(nInterpolations, knotL, S0, D0, S1, D1, coordinate, iParameters);
       nInterpolations /= 4;
       nKnots /= 2;
@@ -376,8 +374,6 @@ class SplineSpec<DataT, XdimT, YdimT, 1>
   typedef SplineSpec<DataT, XdimT, YdimT, 0> TBase;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-
 #if !defined(GPUCA_GPUCODE)
   /// Default constructor
   SplineSpec() : SplineSpec(nullptr) {}
@@ -447,8 +443,6 @@ class SplineSpec<DataT, XdimT, YdimT, 2>
   typedef SplineSpec<DataT, XdimT, YdimT, 0> TBase;
 
  public:
-  typedef typename TVeryBase::SafetyLevel SafetyLevel;
-
 #if !defined(GPUCA_GPUCODE)
   /// Default constructor
   SplineSpec() : SplineSpec((XdimT > 0 ? XdimT : 0), (YdimT > 0 ? YdimT : 0), nullptr) {}
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index a087b5259e351..b463f6c36c406 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -214,6 +214,11 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
   // set data members of TPCFastTransform
   podMap->mVdrift = src.getVDrift();
   podMap->mT0 = src.getT0();
+  podMap->mLumi = src.getLumi();
+  if (src.isIDCSet()) {
+    podMap->mIDC = src.getIDC();
+  }
+  podMap->mTimeStamp = src.getTimeStamp();
   // copy fixed size data --- end
   return podMap;
 }
diff --git a/GPU/Utils/FlatObject.h b/GPU/Utils/FlatObject.h
index 9cb7b7888a069..df31688fcd8bd 100644
--- a/GPU/Utils/FlatObject.h
+++ b/GPU/Utils/FlatObject.h
@@ -336,34 +336,9 @@ class NoFlatObject
 {
  public:
   int32_t mFlatBufferSize = 0;
-  char* mFlatBufferPtr = nullptr;
-
   static constexpr size_t getClassAlignmentBytes() { return 8; }
   static constexpr size_t getBufferAlignmentBytes() { return 8; }
-
-  GPUdi() const char* getFlatBufferPtr() const { return mFlatBufferPtr; }
   GPUdi() size_t getFlatBufferSize() const { return mFlatBufferSize; }
-  GPUdi() void setActualBufferAddress(char* ptr) { mFlatBufferPtr = ptr; }
-  GPUdi() void setFutureBufferAddress(char* ptr) { mFlatBufferPtr = ptr; }
-
-  // No-ops for lifecycle methods (never called in POD context, but needed for compilation)
-  void startConstruction() {}
-  void finishConstruction(int32_t sz) { mFlatBufferSize = sz; }
-  void cloneFromObject(const NoFlatObject& o, char* p) { mFlatBufferSize = o.mFlatBufferSize; mFlatBufferPtr = p; }
-  void moveBufferTo(char*) {}
-  void destroy() {}
-  char* releaseInternalBuffer() { char* p = mFlatBufferPtr; mFlatBufferPtr = nullptr; return p; }
-
-  template <class T>
-  GPUdi() static T* relocatePointer(const char* oldBase, char* newBase, const T* ptr)
-  {
-    return (ptr != nullptr) ? reinterpret_cast<T*>(newBase + (reinterpret_cast<const char*>(ptr) - oldBase)) : nullptr;
-  }
-  static constexpr size_t alignSize(size_t sizeBytes, size_t alignmentBytes)
-  {
-    auto res = sizeBytes % alignmentBytes;
-    return res ? sizeBytes + (alignmentBytes - res) : sizeBytes;
-  }
 };
 
 /// ========================================================================================================

From fb8e98f9d1ef3b68953c2de2549e0f6e1ec87197 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Thu, 9 Apr 2026 13:11:23 +0200
Subject: [PATCH 1609/1764] handle disable-ctp-lumi-request properly in all
 workflows

---
 .../AlignmentWorkflow/BarrelAlignmentSpec.h       |  4 ----
 .../GlobalTrackingWorkflow/TOFMatcherSpec.h       |  2 +-
 .../GlobalTrackingWorkflow/TPCITSMatchingSpec.h   |  2 +-
 .../GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx | 13 ++++++++-----
 .../src/TPCITSMatchingSpec.cxx                    | 15 +++++++++------
 .../src/tof-matcher-workflow.cxx                  |  2 +-
 .../src/tpcits-match-workflow.cxx                 |  2 +-
 Detectors/TPC/workflow/src/TPCScalerSpec.cxx      | 14 +++++++++-----
 .../include/TRDWorkflow/TRDGlobalTrackingSpec.h   |  5 +++--
 .../TRD/workflow/src/TRDGlobalTrackingSpec.cxx    | 11 +++++++----
 .../TRD/workflow/src/trd-tracking-workflow.cxx    |  2 +-
 .../include/GPUWorkflow/GPUWorkflowSpec.h         |  1 +
 GPU/Workflow/src/GPUWorkflowSpec.cxx              |  4 +++-
 GPU/Workflow/src/GPUWorkflowTPC.cxx               |  3 ++-
 GPU/Workflow/src/gpu-reco-workflow.cxx            |  3 +++
 prodtests/full-system-test/dpl-workflow.sh        | 11 ++++++-----
 16 files changed, 56 insertions(+), 38 deletions(-)

diff --git a/Detectors/Align/Workflow/include/AlignmentWorkflow/BarrelAlignmentSpec.h b/Detectors/Align/Workflow/include/AlignmentWorkflow/BarrelAlignmentSpec.h
index fd5697a20bc2b..9793b8609874f 100644
--- a/Detectors/Align/Workflow/include/AlignmentWorkflow/BarrelAlignmentSpec.h
+++ b/Detectors/Align/Workflow/include/AlignmentWorkflow/BarrelAlignmentSpec.h
@@ -21,10 +21,6 @@ using namespace o2::framework;
 
 namespace o2
 {
-namespace tpc
-{
-struct CorrectionMapsLoaderGloOpts;
-}
 
 namespace align
 {
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
index 6fd0bcac902d2..a1102af6a1f75 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TOFMatcherSpec.h
@@ -25,7 +25,7 @@ namespace globaltracking
 {
 
 /// create a processor spec
-framework::DataProcessorSpec getTOFMatcherSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC, bool useFIT, bool tpcRefit, bool strict, float extratolerancetrd, bool pushMatchable, int nlanes = 1);
+framework::DataProcessorSpec getTOFMatcherSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useMC, bool useFIT, bool tpcRefit, bool strict, float extratolerancetrd, bool pushMatchable, bool requestCTPLumi, int nlanes = 1);
 
 } // namespace globaltracking
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
index d4f26283416e6..56240fd2c8f98 100644
--- a/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/include/GlobalTrackingWorkflow/TPCITSMatchingSpec.h
@@ -23,7 +23,7 @@ namespace o2
 namespace globaltracking
 {
 /// create a processor spec
-framework::DataProcessorSpec getTPCITSMatchingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useFT0, bool calib, bool skipTPCOnly, bool useGeom, bool useMC);
+framework::DataProcessorSpec getTPCITSMatchingSpec(o2::dataformats::GlobalTrackID::mask_t src, bool useFT0, bool calib, bool skipTPCOnly, bool useGeom, bool useMC, bool requestCTPLumi);
 
 } // namespace globaltracking
 } // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
index 6440d75360a2f..746e572c506b8 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TOFMatcherSpec.cxx
@@ -59,7 +59,7 @@ namespace globaltracking
 class TOFMatcherSpec : public Task
 {
  public:
-  TOFMatcherSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool useFIT, bool tpcRefit, bool strict, bool pushMatchable, int lanes = 1) : mDataRequest(dr), mGGCCDBRequest(gr), mUseMC(useMC), mUseFIT(useFIT), mDoTPCRefit(tpcRefit), mStrict(strict), mPushMatchable(pushMatchable), mNlanes(lanes) {}
+  TOFMatcherSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, bool useMC, bool useFIT, bool tpcRefit, bool strict, bool pushMatchable, int lanes = 1, bool requestCTPLumi = false) : mDataRequest(dr), mGGCCDBRequest(gr), mUseMC(useMC), mUseFIT(useFIT), mDoTPCRefit(tpcRefit), mStrict(strict), mPushMatchable(pushMatchable), mNlanes(lanes), mRequestCTPLumi(requestCTPLumi) {}
   ~TOFMatcherSpec() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -79,6 +79,7 @@ class TOFMatcherSpec : public Task
   bool mPushMatchable = false;
   float mExtraTolTRD = 0.;
   int mNlanes = 1;
+  bool mRequestCTPLumi = false;
   MatchTOF mMatcher; ///< Cluster finder
   TStopwatch mTimer;
 };
@@ -102,7 +103,7 @@ void TOFMatcherSpec::updateTimeDependentParams(ProcessingContext& pc)
   mTPCVDriftHelper.extractCCDBInputs(pc);
   auto const& raw = pc.inputs().get<const char*>("corrMap");
   mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
-  float lumiCTP = pc.inputs().get<float>("lumiCTP");
+  float lumiCTP = mRequestCTPLumi ? pc.inputs().get<float>("lumiCTP") : 0;
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     const auto bcs = o2::base::GRPGeomHelper::instance().getGRPLHCIF()->getBunchFilling().getFilledBCs();
@@ -230,7 +231,7 @@ void TOFMatcherSpec::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bool tpcRefit, bool strict, float extratolerancetrd, bool pushMatchable, int nlanes)
+DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bool tpcRefit, bool strict, float extratolerancetrd, bool pushMatchable, bool requestCTPLumi, int nlanes)
 {
   uint32_t ss = o2::globaltracking::getSubSpec(strict ? o2::globaltracking::MatchingType::Strict : o2::globaltracking::MatchingType::Standard);
   Options opts;
@@ -257,7 +258,9 @@ DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bo
                                                               true);
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
   dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
-  dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+  if (requestCTPLumi) {
+    dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+  }
   std::vector<OutputSpec> outputs;
   if (GID::includesSource(GID::TPC, src)) {
     outputs.emplace_back(o2::header::gDataOriginTOF, "MTC_TPC", ss, Lifetime::Timeframe);
@@ -311,7 +314,7 @@ DataProcessorSpec getTOFMatcherSpec(GID::mask_t src, bool useMC, bool useFIT, bo
     "tof-matcher",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TOFMatcherSpec>(dataRequest, ggRequest, useMC, useFIT, tpcRefit, strict, pushMatchable, nlanes)},
+    AlgorithmSpec{adaptFromTask<TOFMatcherSpec>(dataRequest, ggRequest, useMC, useFIT, tpcRefit, strict, pushMatchable, nlanes, requestCTPLumi)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
index 5b3132c1c3282..079fe5455fd4a 100644
--- a/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/TPCITSMatchingSpec.cxx
@@ -70,8 +70,8 @@ class TPCITSMatchingDPL : public Task
 {
  public:
   TPCITSMatchingDPL(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr,
-                    bool useFT0, bool calib, bool skipTPCOnly, bool useMC)
-    : mDataRequest(dr), mGGCCDBRequest(gr), mUseFT0(useFT0), mCalibMode(calib), mSkipTPCOnly(skipTPCOnly), mUseMC(useMC) {}
+                    bool useFT0, bool calib, bool skipTPCOnly, bool useMC, bool requestCTPLumi)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mUseFT0(useFT0), mCalibMode(calib), mSkipTPCOnly(skipTPCOnly), mUseMC(useMC), mRequestCTPLumi(requestCTPLumi) {}
   ~TPCITSMatchingDPL() override = default;
   void init(InitContext& ic) final;
   void run(ProcessingContext& pc) final;
@@ -89,6 +89,7 @@ class TPCITSMatchingDPL : public Task
   bool mCalibMode = false;
   bool mSkipTPCOnly = false; // to use only externally constrained tracks (for test only)
   bool mUseMC = true;
+  bool mRequestCTPLumi = false;
   TStopwatch mTimer;
 };
 
@@ -186,7 +187,7 @@ void TPCITSMatchingDPL::updateTimeDependentParams(ProcessingContext& pc)
   mTPCVDriftHelper.extractCCDBInputs(pc);
   auto const& raw = pc.inputs().get<const char*>("corrMap");
   mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
-  float lumiCTP = pc.inputs().get<float>("lumiCTP");
+  float lumiCTP = mRequestCTPLumi ? pc.inputs().get<float>("lumiCTP") : 0;
 
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
@@ -234,7 +235,7 @@ void TPCITSMatchingDPL::updateTimeDependentParams(ProcessingContext& pc)
   }
 }
 
-DataProcessorSpec getTPCITSMatchingSpec(GTrackID::mask_t src, bool useFT0, bool calib, bool skipTPCOnly, bool useGeom, bool useMC)
+DataProcessorSpec getTPCITSMatchingSpec(GTrackID::mask_t src, bool useFT0, bool calib, bool skipTPCOnly, bool useGeom, bool useMC, bool requestCTPLumi)
 {
   std::vector<OutputSpec> outputs;
   auto dataRequest = std::make_shared<DataRequest>();
@@ -291,12 +292,14 @@ DataProcessorSpec getTPCITSMatchingSpec(GTrackID::mask_t src, bool useFT0, bool
 
   o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
   dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
-  dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+  if (requestCTPLumi) {
+    dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+  }
   return DataProcessorSpec{
     "itstpc-track-matcher",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TPCITSMatchingDPL>(dataRequest, ggRequest, useFT0, calib, skipTPCOnly, useMC)},
+    AlgorithmSpec{adaptFromTask<TPCITSMatchingDPL>(dataRequest, ggRequest, useFT0, calib, skipTPCOnly, useMC, requestCTPLumi)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
index 31d2fbbd4fc35..96d7c783022c3 100644
--- a/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/tof-matcher-workflow.cxx
@@ -171,7 +171,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   if (!configcontext.options().get<bool>("disable-root-input")) {
     specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::globaltracking::getTOFMatcherSpec(src, useMC, useFIT, refitTPCTOF, strict, extratolerancetrd, writeMatchable, nLanes)); // doTPCrefit not yet supported (need to load TPC clusters?)
+  specs.emplace_back(o2::globaltracking::getTOFMatcherSpec(src, useMC, useFIT, refitTPCTOF, strict, extratolerancetrd, writeMatchable, sclOpt.requestCTPLumi, nLanes)); // doTPCrefit not yet supported (need to load TPC clusters?)
 
   if (!disableRootOut) {
     std::vector<DataProcessorSpec> writers;
diff --git a/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx b/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
index 77a6de82139ab..78e5db9e4b391 100644
--- a/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/src/tpcits-match-workflow.cxx
@@ -96,7 +96,7 @@ WorkflowSpec defineDataProcessing(o2::framework::ConfigContext const& configcont
   if (!configcontext.options().get<bool>("disable-root-input")) {
     specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::globaltracking::getTPCITSMatchingSpec(srcL, useFT0, calib, !GID::includesSource(GID::TPC, src), useGeom, useMC));
+  specs.emplace_back(o2::globaltracking::getTPCITSMatchingSpec(srcL, useFT0, calib, !GID::includesSource(GID::TPC, src), useGeom, useMC, sclOpt.requestCTPLumi));
 
   if (!configcontext.options().get<bool>("disable-root-output")) {
     specs.emplace_back(o2::globaltracking::getTrackWriterTPCITSSpec(useMC));
diff --git a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
index 8db4399524662..8e2a78d69757b 100644
--- a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
@@ -171,10 +171,12 @@ class TPCScalerSpec : public Task
     // check for Maps update
     mTPCCorrMapsLoader.extractCCDBInputs(pc, tpcScaler);
 
-    const float lumiCTP = mTPCCorrMapsLoader.getInstLumiCTP();
-    // if CTP lumi was notrequest - defualt of 0 is published, otherwise the value is scaled with the provided factor
-    LOGP(info, "Publishing CTP Lumi: {} for timestamp: {}, firstTFOrbit: {}", lumiCTP, timestamp, firstTFOrbit);
-    pc.outputs().snapshot(Output{header::gDataOriginCTP, "LUMICTP"}, lumiCTP);
+    if (mGlobOpts.requestCTPLumi) {
+      const float lumiCTP = mTPCCorrMapsLoader.getInstLumiCTP();
+      // if CTP lumi was notrequest - defualt of 0 is published, otherwise the value is scaled with the provided factor
+      LOGP(info, "Publishing CTP Lumi: {} for timestamp: {}, firstTFOrbit: {}", lumiCTP, timestamp, firstTFOrbit);
+      pc.outputs().snapshot(Output{header::gDataOriginCTP, "LUMICTP"}, lumiCTP);
+    }
 
     buildMap(pc);
   }
@@ -323,7 +325,9 @@ o2::framework::DataProcessorSpec getTPCScalerSpec(bool enableIDCs, bool enableMS
 
   std::vector<OutputSpec> outputs;
   outputs.emplace_back(o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
-  outputs.emplace_back(o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+  if (sclOpts.requestCTPLumi) {
+    outputs.emplace_back(o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+  }
   o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
   o2::tpc::CorrectionMapsLoader::requestCCDBInputs(inputs, sclOpts);
 
diff --git a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
index be75beb4c5b51..92c33d8c316b5 100644
--- a/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
+++ b/Detectors/TRD/workflow/include/TRDWorkflow/TRDGlobalTrackingSpec.h
@@ -52,7 +52,7 @@ class TRDGlobalTracking : public o2::framework::Task
 {
  public:
   TRDGlobalTracking(bool useMC, bool withPID, PIDPolicy policy, std::shared_ptr<o2::globaltracking::DataRequest> dataRequest, std::shared_ptr<o2::base::GRPGeomRequest> gr,
-                    o2::dataformats::GlobalTrackID::mask_t src, bool trigRecFilterActive, bool strict) : mUseMC(useMC), mWithPID(withPID), mDataRequest(dataRequest), mGGCCDBRequest(gr), mTrkMask(src), mTrigRecFilter(trigRecFilterActive), mStrict(strict), mPolicy(policy) {}
+                    o2::dataformats::GlobalTrackID::mask_t src, bool trigRecFilterActive, bool strict, bool requestCTPLumi) : mUseMC(useMC), mWithPID(withPID), mDataRequest(dataRequest), mGGCCDBRequest(gr), mTrkMask(src), mTrigRecFilter(trigRecFilterActive), mStrict(strict), mPolicy(policy), mRequestCTPLumi(requestCTPLumi) {}
   ~TRDGlobalTracking() override = default;
   void init(o2::framework::InitContext& ic) final;
   void fillMCTruthInfo(const TrackTRD& trk, o2::MCCompLabel lblSeed, std::vector<o2::MCCompLabel>& lblContainerTrd, std::vector<o2::MCCompLabel>& lblContainerMatch, const o2::dataformats::MCTruthContainer<o2::MCCompLabel>* trkltLabels) const;
@@ -105,11 +105,12 @@ class TRDGlobalTracking : public o2::framework::Task
   std::array<float, 5> mCovDiagOuter{}; ///< total cov.matrix extra diagonal error from TrackTuneParams
   // PID
   PIDPolicy mPolicy{PIDPolicy::DEFAULT}; ///< Model to load an evaluate
+  bool mRequestCTPLumi{false};           ///< whether to request CTP lumi
   std::unique_ptr<PIDBase> mBase;        ///< PID engine
 };
 
 /// create a processor spec
-framework::DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t src, bool trigRecFilterActive, bool strict /* = false*/, bool withPID /* = false*/, PIDPolicy policy /* = PIDPolicy::DEFAULT*/);
+framework::DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, o2::dataformats::GlobalTrackID::mask_t src, bool trigRecFilterActive, bool strict /* = false*/, bool withPID /* = false*/, PIDPolicy policy /* = PIDPolicy::DEFAULT*/, bool requestCTPLumi);
 
 } // namespace trd
 } // namespace o2
diff --git a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
index 752309153ac80..40521c5fd5ee9 100644
--- a/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
+++ b/Detectors/TRD/workflow/src/TRDGlobalTrackingSpec.cxx
@@ -93,7 +93,7 @@ void TRDGlobalTracking::updateTimeDependentParams(ProcessingContext& pc)
 
   auto const& raw = pc.inputs().get<const char*>("corrMap");
   mTPCCorrMaps = &o2::gpu::TPCFastTransformPOD::get(raw);
-  float lumiCTP = pc.inputs().get<float>("lumiCTP");
+  float lumiCTP = mRequestCTPLumi ? pc.inputs().get<float>("lumiCTP") : 0;
 
   // pc.inputs().get<TopologyDictionary*>("cldict"); // called by the RecoContainer to trigger finaliseCCDB
   static bool initOnceDone = false;
@@ -853,7 +853,7 @@ void TRDGlobalTracking::endOfStream(EndOfStreamContext& ec)
        mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
 }
 
-DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, bool trigRecFilterActive, bool strict, bool withPID, PIDPolicy policy)
+DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, bool trigRecFilterActive, bool strict, bool withPID, PIDPolicy policy, bool requestCTPLumi)
 {
   std::vector<OutputSpec> outputs;
   uint32_t ss = o2::globaltracking::getSubSpec(strict ? o2::globaltracking::MatchingType::Strict : o2::globaltracking::MatchingType::Standard);
@@ -892,7 +892,10 @@ DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, boo
   Options opts;
 
   dataRequest->inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
-  dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+
+  if (requestCTPLumi) {
+    dataRequest->inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+  }
 
   // Request PID policy data
   if (withPID) {
@@ -955,7 +958,7 @@ DataProcessorSpec getTRDGlobalTrackingSpec(bool useMC, GTrackID::mask_t src, boo
     processorName,
     inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<TRDGlobalTracking>(useMC, withPID, policy, dataRequest, ggRequest, src, trigRecFilterActive, strict)},
+    AlgorithmSpec{adaptFromTask<TRDGlobalTracking>(useMC, withPID, policy, dataRequest, ggRequest, src, trigRecFilterActive, strict, requestCTPLumi)},
     opts};
 }
 
diff --git a/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx b/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
index 85c7857d3d23c..a3e57e67dbf8f 100644
--- a/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
+++ b/Detectors/TRD/workflow/src/trd-tracking-workflow.cxx
@@ -118,7 +118,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   if (!configcontext.options().get<bool>("disable-root-input")) {
     specs.emplace_back(o2::tpc::getTPCScalerSpec(sclOpt.lumiType == o2::tpc::LumiScaleType::TPCScaler, sclOpt.enableMShapeCorrection, sclOpt));
   }
-  specs.emplace_back(o2::trd::getTRDGlobalTrackingSpec(useMC, srcTRD, trigRecFilterActive, strict, pid, policy));
+  specs.emplace_back(o2::trd::getTRDGlobalTrackingSpec(useMC, srcTRD, trigRecFilterActive, strict, pid, policy, sclOpt.requestCTPLumi));
   if (vdexb || gain) {
     specs.emplace_back(o2::trd::getTRDTrackBasedCalibSpec(srcTRD, vdexb, gain));
   }
diff --git a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
index 7fbe16296d868..b8fc08831cd09 100644
--- a/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
+++ b/GPU/Workflow/include/GPUWorkflow/GPUWorkflowSpec.h
@@ -106,6 +106,7 @@ class GPURecoWorkflowSpec : public o2::framework::Task
 
   struct Config {
     int32_t itsTriggerType = 0;
+    bool enableCTPLumi = false;
     int32_t enableDoublePipeline = 0;
     int32_t tpcDeadMapSources = -1;
     bool tpcUseMCTimeGain = false; // use time gain calibration for MC (true) or from data (false)
diff --git a/GPU/Workflow/src/GPUWorkflowSpec.cxx b/GPU/Workflow/src/GPUWorkflowSpec.cxx
index 95752c486eae1..18409ac68e29f 100644
--- a/GPU/Workflow/src/GPUWorkflowSpec.cxx
+++ b/GPU/Workflow/src/GPUWorkflowSpec.cxx
@@ -1181,7 +1181,9 @@ Inputs GPURecoWorkflowSpec::inputs()
     inputs.emplace_back("tpcthreshold", gDataOriginTPC, "PADTHRESHOLD", 0, Lifetime::Condition, ccdbParamSpec("TPC/Config/FEEPad"));
     o2::tpc::VDriftHelper::requestCCDBInputs(inputs);
     inputs.emplace_back("corrMap", o2::header::gDataOriginTPC, "TPCCORRMAP", 0, Lifetime::Timeframe);
-    inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+    if (mSpecConfig.enableCTPLumi) {
+      inputs.emplace_back("lumiCTP", o2::header::gDataOriginCTP, "LUMICTP", 0, Lifetime::Timeframe);
+    }
   }
   if (mSpecConfig.decompressTPC) {
     inputs.emplace_back(InputSpec{"input", ConcreteDataTypeMatcher{gDataOriginTPC, mSpecConfig.decompressTPCFromROOT ? o2::header::DataDescription("COMPCLUSTERS") : o2::header::DataDescription("COMPCLUSTERSFLAT")}, Lifetime::Timeframe});
diff --git a/GPU/Workflow/src/GPUWorkflowTPC.cxx b/GPU/Workflow/src/GPUWorkflowTPC.cxx
index d92942c5ed2f5..e9b379168b118 100644
--- a/GPU/Workflow/src/GPUWorkflowTPC.cxx
+++ b/GPU/Workflow/src/GPUWorkflowTPC.cxx
@@ -342,7 +342,8 @@ bool GPURecoWorkflowSpec::fetchCalibsCCDBTPC<GPUCalibObjectsConst>(ProcessingCon
 
       if (mSpecConfig.outputTracks) {
         mTPCVDriftHelper->extractCCDBInputs(pc);
-        mCalibObjects.mInstLumiCTP = pc.inputs().get<float>("lumiCTP");
+        float lumiCTP = (mSpecConfig.enableCTPLumi) ? pc.inputs().get<float>("lumiCTP") : 0;
+        mCalibObjects.mInstLumiCTP = lumiCTP;
 
         // get the raw buffer and reinterpret as TPCFastTransformPOD
         oldCalibObjects.mFastTransformBuffer = std::move(mCalibObjects.mFastTransformBuffer); // OLD buffer alive ✓
diff --git a/GPU/Workflow/src/gpu-reco-workflow.cxx b/GPU/Workflow/src/gpu-reco-workflow.cxx
index f12c8fa78e763..847ddf95b3da9 100644
--- a/GPU/Workflow/src/gpu-reco-workflow.cxx
+++ b/GPU/Workflow/src/gpu-reco-workflow.cxx
@@ -62,6 +62,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"tpc-deadMap-sources", VariantType::Int, -1, {"Sources to consider for TPC dead channel map creation; -1=all, 0=deactivated"}},
     {"tpc-mc-time-gain", VariantType::Bool, false, {"use time gain calibration for MC (true) or for data (false)"}},
     {"filtered-output-specs", VariantType::Bool, false, {"use filtered output specs for output DataDescriptions"}},
+    {"disable-ctp-lumi-request", o2::framework::VariantType::Bool, false, {"do not request CTP lumi"}},
   };
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
@@ -144,6 +145,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 
   auto inputType = cfgc.options().get<std::string>("input-type");
   bool doMC = !cfgc.options().get<bool>("disable-mc");
+  auto requestCTPLumi = !cfgc.options().get<bool>("disable-ctp-lumi-request");
   o2::conf::ConfigurableParam::updateFromFile(cfgc.options().get<std::string>("configFile"));
   o2::conf::ConfigurableParam::updateFromString(cfgc.options().get<std::string>("configKeyValues"));
   o2::conf::ConfigurableParam::writeINI("o2gpurecoworkflow_configuration.ini");
@@ -162,6 +164,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 
   GPURecoWorkflowSpec::Config cfg;
   cfg.runTPCTracking = true;
+  cfg.enableCTPLumi = requestCTPLumi;
   cfg.decompressTPCFromROOT = isEnabled(inputTypes, ioType::CompClustROOT);
   cfg.decompressTPC = isEnabled(inputTypes, ioType::CompClustFlat) || cfg.decompressTPCFromROOT;
   cfg.zsDecoder = isEnabled(inputTypes, ioType::ZSRaw);
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 3c5cb2286c0f2..b7cd4a233bb5d 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -574,6 +574,7 @@ fi
 
 # if TPC correction with IDC from CCDB was requested
 has_detector TPC && add_W o2-tpc-scaler-workflow " ${TPC_SCALERS_CONF:-} " "$TPC_CORR_KEY"
+
 # if ITS+TPC GPU: pass ITS CKVs to the GPU WF
 has_detectors_gpu TPC ITS && GPU_CONFIG_KEY+=$ITS_CONFIG_KEY
 
@@ -587,13 +588,13 @@ has_detector_gpu ITS && GPU_OUTPUT+=",its-tracks"
 # Common reconstruction workflows
 (has_detector_reco ITS && ! has_detector_gpu ITS) && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "$ITS_CONFIG $ITS_STAGGERED $DISABLE_MC ${DISABLE_DIGIT_CLUSTER_INPUT:-} $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-tracker ITS REST 1 ITSTRK),$(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
 [[ ${DISABLE_DIGIT_CLUSTER_INPUT:-} =~ "--digits-from-upstream" ]]  && has_detector_gpu ITS && ! has_detector_from_global_reader ITS && add_W o2-its-reco-workflow "--disable-tracking ${DISABLE_DIGIT_CLUSTER_INPUT:-} $ITS_STAGGERED $DISABLE_MC $DISABLE_ROOT_OUTPUT --pipeline $(get_N its-clusterer ITS REST 1 ITSCL)" "$ITS_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR"
-(has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $ITS_STAGGERED --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;"
+(has_detector_reco TPC || has_detector_ctf TPC) && ! has_detector_from_global_reader TPC && add_W o2-gpu-reco-workflow "--gpu-reconstruction \"$GPU_CONFIG_SELF\" --input-type=$GPU_INPUT $DISABLE_MC --output-type $GPU_OUTPUT $([[ $TPC_CORR_OPT == *--disable-ctp-lumi-request* ]] && echo --disable-ctp-lumi-request) $ITS_STAGGERED --pipeline gpu-reconstruction:${N_TPCTRK:-1},gpu-reconstruction-prepare:${N_TPCTRK:-1} $GPU_CONFIG" "GPU_global.deviceType=$GPUTYPE;GPU_proc.debugLevel=0;$GPU_CONFIG_KEY;$TRACKTUNETPCINNER;"
 (has_detector_reco TOF || has_detector_ctf TOF) && ! has_detector_from_global_reader TOF && add_W o2-tof-reco-workflow "$TOF_CONFIG --input-type $TOF_INPUT --output-type $TOF_OUTPUT $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N tof-compressed-decoder TOF RAW 1),$(get_N TOFClusterer TOF REST 1)"
 has_detector_reco FT0 && ! has_detector_from_global_reader FT0 && add_W o2-ft0-reco-workflow "$DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC --pipeline $(get_N ft0-reconstructor FT0 REST 1)"
 has_detector_reco TRD && ! has_detector_from_global_reader TRD && add_W o2-trd-tracklet-transformer "--disable-irframe-reader $DISABLE_DIGIT_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_FILTER_CONFIG --pipeline $(get_N TRDTRACKLETTRANSFORMER TRD REST 1 TRDTRKTRANS)"
-has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $ITS_STAGGERED $SEND_ITSTPC_DTGL --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;"
-has_detector_reco TRD && [[ -n "$TRD_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-global-tracking "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_CONFIG $TRD_FILTER_CONFIG --track-sources $TRD_SOURCES --pipeline $(get_N trd-globaltracking_TPC_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_CTP_ TRD REST 1 TRDTRK)" "$TRD_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;"
-has_detector_reco TOF && [[ -n "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$INTERACTION_TAG_CONFIG_KEY"
+has_detectors_reco ITS TPC && ! has_detector_from_global_reader_tracks ITS-TPC && has_detector_matching ITSTPC && add_W o2-tpcits-match-workflow "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $ITS_STAGGERED $SEND_ITSTPC_DTGL $TPC_CORR_OPT --nthreads $ITSTPC_THREADS --pipeline $(get_N itstpc-track-matcher MATCH REST $ITSTPC_THREADS TPCITS)" "$ITSTPC_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY;"
+has_detector_reco TRD && [[ -n "$TRD_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TRD_SOURCES" | cut -d',' -f1)-TRD" && add_W o2-trd-global-tracking "$DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TRD_CONFIG $TRD_FILTER_CONFIG $TPC_CORR_OPT --track-sources $TRD_SOURCES --pipeline $(get_N trd-globaltracking_TPC_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_ TRD REST 1 TRDTRK),$(get_N trd-globaltracking_TPC_FT0_ITS-TPC_CTP_ TRD REST 1 TRDTRK)" "$TRD_CONFIG_KEY;$INTERACTION_TAG_CONFIG_KEY;$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY;"
+has_detector_reco TOF && [[ -n "$TOF_SOURCES" ]] && ! has_detector_from_global_reader_tracks "$(echo "$TOF_SOURCES" | cut -d',' -f1)-TOF" && add_W o2-tof-matcher-workflow "$TOF_MATCH_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $DISABLE_MC $TPC_CORR_OPT ${TOFMATCH_THREADS:+--tof-lanes ${TOFMATCH_THREADS}} --track-sources $TOF_SOURCES --pipeline $(get_N tof-matcher TOF REST 1 TOFMATCH)" "$ITSMFT_STROBES;$ITSEXTRAERR;$TPC_CORR_KEY;$INTERACTION_TAG_CONFIG_KEY"
 has_detectors TPC && [[ -z "$DISABLE_ROOT_OUTPUT" && "${SKIP_TPC_CLUSTERSTRACKS_OUTPUT:-}" != 1 ]] && ! has_detector_from_global_reader TPC && add_W o2-tpc-reco-workflow "--input-type pass-through --output-type clusters,tpc-triggers,tracks,send-clusters-per-sector $DISABLE_MC"
 
 # ---------------------------------------------------------------------------------------------------------------------
@@ -652,7 +653,7 @@ if [[ $BEAMTYPE != "cosmic" ]] && has_detectors_reco ITS && has_detector_matchin
     : ${REDUCESV_OPT:=" --disable-cascade-finder --disable-3body-finder "}
     : ${REDUCESV_CONF:="svertexer.pidCutsPhoton[0]=-1;svertexer.pidCutsLambda[0]=-1;svertexer.pidCutsHTriton[0]=-1;svertexer.pidCutsHhydrog4[0]=-1;"}
   fi
-  [[ $GLOBAL_READER_NEEDS_SV != 1 ]] && add_W o2-secondary-vertexing-workflow "$DISABLE_MC $STRTRACKING $REDUCESV_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT --vertexing-sources $SVERTEXING_SOURCES --threads $SVERTEX_THREADS --pipeline $(get_N secondary-vertexing MATCH REST $SVERTEX_THREADS SECVTX)" "$REDUCESV_CONF"
+  [[ $GLOBAL_READER_NEEDS_SV != 1 ]] && add_W o2-secondary-vertexing-workflow "$DISABLE_MC $STRTRACKING $REDUCESV_OPT $DISABLE_ROOT_INPUT $DISABLE_ROOT_OUTPUT $TPC_CORR_OPT --vertexing-sources $SVERTEXING_SOURCES --threads $SVERTEX_THREADS --pipeline $(get_N secondary-vertexing MATCH REST $SVERTEX_THREADS SECVTX)" "$TPC_CORR_KEY;$REDUCESV_CONF"
   SECTVTX_ON="1"
 else
   SECTVTX_ON="0"

From 66d856e4c77de96fdcc9707bd1942601cd59dab8 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 17:38:01 +0200
Subject: [PATCH 1610/1764] GPU: Add check that struct was read correctly from
 file

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx |  4 +-
 GPU/GPUTracking/Base/GPUReconstruction.h   |  4 +-
 GPU/GPUTracking/Base/GPUReconstructionIO.h | 67 +++++++++++-----------
 3 files changed, 36 insertions(+), 39 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index e21ac694fbfff..8eef9ad65ee49 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -1237,7 +1237,9 @@ int32_t GPUReconstruction::ReadSettings(const char* dir)
   f = dir;
   f += "settings.dump";
   new (mGRPSettings.get()) GPUSettingsGRP;
-  if (ReadStructFromFile(f.c_str(), mGRPSettings.get())) {
+  bool error;
+  ReadStructFromFile(f.c_str(), mGRPSettings.get(), &error, true);
+  if (error) {
     return 1;
   }
   param().UpdateSettings(mGRPSettings.get());
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index d5c30f8ccb711..825dbdc24aebe 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -302,9 +302,7 @@ class GPUReconstruction
   template <class T>
   void DumpDynamicStructToFile(const T* obj, size_t dynamicSize, const char* file);
   template <class T>
-  std::unique_ptr<T> ReadStructFromFile(const char* file);
-  template <class T>
-  int32_t ReadStructFromFile(const char* file, T* obj);
+  std::unique_ptr<T> ReadStructFromFile(const char* file, T* obj = nullptr, bool* errorOnMissing = nullptr, bool allowSmaller = false);
   template <class T, auto F>
   aligned_unique_buffer_ptr<T> ReadDynamicStructFromFile(const char* file);
 
diff --git a/GPU/GPUTracking/Base/GPUReconstructionIO.h b/GPU/GPUTracking/Base/GPUReconstructionIO.h
index c6c15462bc29e..fb771ec3639a9 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionIO.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionIO.h
@@ -41,7 +41,7 @@ inline T* GPUReconstruction::AllocateIOMemoryHelper(size_t n, const T*& ptr, std
     retVal = u.get();
     if (GetProcessingSettings().registerStandaloneInputMemory) {
       if (registerMemoryForGPU(u.get(), n * sizeof(T))) {
-        GPUError("Error registering memory for GPU: %p - %ld bytes\n", (void*)u.get(), (int64_t)(n * sizeof(T)));
+        GPUError("Error registering memory for GPU: %p - %zu bytes\n", (void*)u.get(), n * sizeof(T));
         throw std::bad_alloc();
       }
     }
@@ -69,7 +69,7 @@ inline uint32_t GPUReconstruction::DumpData(FILE* fp, const T* const* entries, c
     }
   }
   if (GetProcessingSettings().debugLevel >= 2) {
-    GPUInfo("Dumped %ld %s", (int64_t)numTotal, IOTYPENAMES[type]);
+    GPUInfo("Dumped %zu %s", numTotal, IOTYPENAMES[type]);
   }
   return numTotal;
 }
@@ -103,7 +103,7 @@ inline size_t GPUReconstruction::ReadData(FILE* fp, const T** entries, S* num, s
   }
   (void)r;
   if (GetProcessingSettings().debugLevel >= 2) {
-    GPUInfo("Read %ld %s", (int64_t)numTotal, IOTYPENAMES[type]);
+    GPUInfo("Read %zu %s", numTotal, IOTYPENAMES[type]);
   }
   return numTotal;
 }
@@ -133,7 +133,7 @@ inline std::unique_ptr<T> GPUReconstruction::ReadFlatObjectFromFile(const char*
   r = fread(size, sizeof(size[0]), 2, fp);
   if (r == 0 || size[0] != sizeof(T)) {
     fclose(fp);
-    GPUError("ERROR reading %s, invalid size: %ld (%ld expected)", file, (int64_t)size[0], (int64_t)sizeof(T));
+    GPUError("ERROR reading %s, invalid size: %zu (%zu expected)", file, size[0], sizeof(T));
     throw std::runtime_error("invalid size");
   }
   std::unique_ptr<T> retVal(new T);
@@ -143,7 +143,7 @@ inline std::unique_ptr<T> GPUReconstruction::ReadFlatObjectFromFile(const char*
   r = fread(buf, 1, size[1], fp);
   fclose(fp);
   if (GetProcessingSettings().debugLevel >= 2) {
-    GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
+    GPUInfo("Read %zu bytes from %s", r, file);
   }
   retVal->clearInternalBufferPtr();
   retVal->setActualBufferAddress(buf);
@@ -165,47 +165,40 @@ inline void GPUReconstruction::DumpStructToFile(const T* obj, const char* file)
 }
 
 template <class T>
-inline std::unique_ptr<T> GPUReconstruction::ReadStructFromFile(const char* file)
+inline std::unique_ptr<T> GPUReconstruction::ReadStructFromFile(const char* file, T* obj, bool* errorOnMissing, bool allowSmaller)
 {
   FILE* fp = fopen(file, "rb");
   if (fp == nullptr) {
+    if (errorOnMissing) {
+      *errorOnMissing = true;
+    }
     return nullptr;
   }
   size_t size, r;
   r = fread(&size, sizeof(size), 1, fp);
-  if (r == 0 || size != sizeof(T)) {
+  if (r == 0 || (!allowSmaller && size != sizeof(T))) {
     fclose(fp);
-    GPUError("ERROR reading %s, invalid size: %ld (%ld expected)", file, (int64_t)size, (int64_t)sizeof(T));
+    GPUError("ERROR reading %s, invalid size: %zu (%zu expected)", file, size, sizeof(T));
     throw std::runtime_error("invalid size");
   }
-  std::unique_ptr<T> newObj(new T);
-  r = fread(newObj.get(), 1, size, fp);
-  fclose(fp);
-  if (GetProcessingSettings().debugLevel >= 2) {
-    GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
-  }
-  return newObj;
-}
-
-template <class T>
-inline int32_t GPUReconstruction::ReadStructFromFile(const char* file, T* obj)
-{
-  FILE* fp = fopen(file, "rb");
-  if (fp == nullptr) {
-    return 1;
-  }
-  size_t size, r;
-  r = fread(&size, sizeof(size), 1, fp);
-  if (r == 0) {
-    fclose(fp);
-    return 1;
+  std::unique_ptr<T> retVal(nullptr);
+  if (obj == nullptr) {
+    retVal = std::make_unique<T>();
+    obj = retVal.get();
   }
   r = fread(obj, 1, size, fp);
   fclose(fp);
+  if (r != size) {
+    GPUError("ERROR reading %s, read %zu (%zu expected)", file, r, size);
+    throw std::runtime_error("invalid size");
+  }
   if (GetProcessingSettings().debugLevel >= 2) {
-    GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
+    GPUInfo("Read %zu bytes from %s", r, file);
+  }
+  if (errorOnMissing) {
+    *errorOnMissing = false;
   }
-  return 0;
+  return retVal;
 }
 
 template <class T>
@@ -234,27 +227,31 @@ inline aligned_unique_buffer_ptr<T> GPUReconstruction::ReadDynamicStructFromFile
   r2 = fread(&dynsize, sizeof(dynsize), 1, fp);
   if (r == 0 || r2 == 0 || size != sizeof(T) || dynsize < size) {
     fclose(fp);
-    GPUError("ERROR reading %s, invalid size: %ld (%ld buffer size, %ld object size expected)", file, (int64_t)size, (int64_t)dynsize, (int64_t)sizeof(T));
+    GPUError("ERROR reading %s, invalid size: %zu (%zu buffer size, %zu object size expected)", file, size, dynsize, sizeof(T));
     throw std::runtime_error("invalid size");
   }
   std::unique_ptr<T> tmp = std::make_unique<T>();
   r = fread(tmp.get(), sizeof(T), 1, fp);
   if (r == 0) {
     fclose(fp);
-    GPUError("ERROR reading %s", file, (int64_t)size, (int64_t)sizeof(T));
+    GPUError("ERROR reading %s %zu (%zu expected)", file, size, sizeof(T));
     throw std::runtime_error("read error");
   }
   if ((tmp.get()->*F)() != dynsize) {
     fclose(fp);
-    GPUError("ERROR: invalid size: %ld (%ld expected)", file, (int64_t)dynsize, (int64_t)(tmp.get()->*F)());
+    GPUError("ERROR in %s: invalid size: %zu (%zu expected)", file, dynsize, (tmp.get()->*F)());
     throw std::runtime_error("invalid size");
   }
   aligned_unique_buffer_ptr<T> newObj(dynsize);
   memcpy(newObj.get(), tmp.get(), sizeof(T));
   r = fread(newObj.getraw() + sizeof(T), 1, dynsize - sizeof(T), fp);
   fclose(fp);
+  if (r != dynsize - sizeof(T)) {
+    GPUError("ERROR in %s: File Read error in %s: %zu (%zu expected)", file, r, dynsize);
+    throw std::runtime_error("invalid size");
+  }
   if (GetProcessingSettings().debugLevel >= 2) {
-    GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
+    GPUInfo("Read %zu bytes from %s", r + dynsize, file);
   }
   return newObj;
 }

From bc57538b4e04b800938e355ebb8c948fbaece58c Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 10 Apr 2026 10:30:53 +0200
Subject: [PATCH 1611/1764] GPU TRD: Reduce headers included in interface class

---
 .../TRD/include/DataFormatsTRD/TrackTRD.h     |  1 +
 Detectors/TPC/dcs/CMakeLists.txt              |  3 ++-
 .../TRD/calibration/src/TrackBasedCalib.cxx   |  2 ++
 Detectors/TRD/pid/include/TRDPID/LQND.h       |  2 ++
 Detectors/TRD/workflow/io/CMakeLists.txt      |  2 +-
 GPU/GPUTracking/CMakeLists.txt                |  1 +
 .../DataTypes/GPUTRDInterfaceO2Track.h        | 20 ++++++++++++++-----
 GPU/GPUTracking/DataTypes/GPUTRDTrack.inc     |  6 +++---
 Generators/CMakeLists.txt                     |  2 +-
 9 files changed, 28 insertions(+), 11 deletions(-)

diff --git a/DataFormats/Detectors/TRD/include/DataFormatsTRD/TrackTRD.h b/DataFormats/Detectors/TRD/include/DataFormatsTRD/TrackTRD.h
index 9dcbde05fb743..b2182636d4591 100644
--- a/DataFormats/Detectors/TRD/include/DataFormatsTRD/TrackTRD.h
+++ b/DataFormats/Detectors/TRD/include/DataFormatsTRD/TrackTRD.h
@@ -16,6 +16,7 @@
 #define O2_DATAFORMATS_TRACK_TRD_H
 
 #include "GPUTRDTrack.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
 
 namespace o2
 {
diff --git a/Detectors/TPC/dcs/CMakeLists.txt b/Detectors/TPC/dcs/CMakeLists.txt
index 31524dd5f2c2f..278b60f9965e0 100644
--- a/Detectors/TPC/dcs/CMakeLists.txt
+++ b/Detectors/TPC/dcs/CMakeLists.txt
@@ -18,7 +18,8 @@ o2_add_library(TPCdcs
                PUBLIC_LINK_LIBRARIES O2::Framework
                                      O2::DetectorsDCS
                                      O2::DataFormatsTPC
-                                     O2::TPCBase)
+                                     O2::TPCBase
+                                     O2::TPCBaseRecSim)
 
 o2_target_root_dictionary(TPCdcs
                           HEADERS include/TPCdcs/DCSProcessor.h)
diff --git a/Detectors/TRD/calibration/src/TrackBasedCalib.cxx b/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
index 0d551e7b5f33d..a0cbab6ac8bfa 100644
--- a/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
+++ b/Detectors/TRD/calibration/src/TrackBasedCalib.cxx
@@ -22,6 +22,8 @@
 #include "TRDBase/Geometry.h"
 #include "TRDBase/PadPlane.h"
 #include "CommonUtils/NameConf.h"
+#include "DataFormatsTPC/TrackTPC.h"
+#include "ReconstructionDataFormats/TrackTPCITS.h"
 #include <fairlogger/Logger.h>
 
 using namespace o2::trd;
diff --git a/Detectors/TRD/pid/include/TRDPID/LQND.h b/Detectors/TRD/pid/include/TRDPID/LQND.h
index 7a898b25829c5..ca49a6c196186 100644
--- a/Detectors/TRD/pid/include/TRDPID/LQND.h
+++ b/Detectors/TRD/pid/include/TRDPID/LQND.h
@@ -27,6 +27,8 @@
 #include "DetectorsBase/Propagator.h"
 #include "Framework/Logger.h"
 #include "ReconstructionDataFormats/TrackParametrization.h"
+#include "DataFormatsTPC/TrackTPC.h"
+#include "ReconstructionDataFormats/TrackTPCITS.h"
 
 #include <memory>
 #include <vector>
diff --git a/Detectors/TRD/workflow/io/CMakeLists.txt b/Detectors/TRD/workflow/io/CMakeLists.txt
index e91b5f5a30375..baf607a4a3ab3 100644
--- a/Detectors/TRD/workflow/io/CMakeLists.txt
+++ b/Detectors/TRD/workflow/io/CMakeLists.txt
@@ -23,7 +23,7 @@ o2_add_library(TRDWorkflowIO
                        src/TRDCalibWriterSpec.cxx
                        src/TRDPHReaderSpec.cxx
                        include/TRDWorkflowIO/KrClusterWriterSpec.h
-               PUBLIC_LINK_LIBRARIES O2::DataFormatsTRD O2::SimulationDataFormat O2::DPLUtils O2::GPUDataTypes O2::DataFormatsTPC)
+               PUBLIC_LINK_LIBRARIES O2::DataFormatsTRD O2::SimulationDataFormat O2::DPLUtils O2::GPUDataTypes O2::DataFormatsTPC O2::DetectorsRaw)
 
 
 o2_add_executable(digit-reader-workflow
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index 47e4bd2cc1b25..a75aff4a3a752 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -354,6 +354,7 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                                        O2::ReconstructionDataFormats
                                        O2::TPCFastTransformation
                  PRIVATE_LINK_LIBRARIES O2::DataFormatsTPC
+                                        O2::TPCBase
                  SOURCES ${SRCS_DATATYPES})
   target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB)
 
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDInterfaceO2Track.h b/GPU/GPUTracking/DataTypes/GPUTRDInterfaceO2Track.h
index 0a269c05869e4..955bc61e9e0b6 100644
--- a/GPU/GPUTracking/DataTypes/GPUTRDInterfaceO2Track.h
+++ b/GPU/GPUTracking/DataTypes/GPUTRDInterfaceO2Track.h
@@ -21,17 +21,24 @@ namespace o2::gpu
 {
 template <typename T>
 class trackInterface;
+template <typename T>
+class GPUTRDTrack_t;
 class GPUTPCGMMergedTrack;
 namespace gputpcgmmergertypes
 {
 struct GPUTPCOuterParam;
 } // namespace gputpcgmmergertypes
 } // namespace o2::gpu
+namespace o2::tpc
+{
+class TrackTPC;
+}
+namespace o2::dataformats
+{
+class TrackTPCITS;
+}
 
 #include "ReconstructionDataFormats/Track.h"
-#include "ReconstructionDataFormats/TrackTPCITS.h"
-#include "DataFormatsTPC/TrackTPC.h"
-#include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "ReconstructionDataFormats/TrackLTIntegral.h"
 #include "CommonConstants/LHCConstants.h"
 
@@ -44,8 +51,11 @@ class trackInterface<o2::track::TrackParCov> : public o2::track::TrackParCov
  public:
   GPUdDefault() trackInterface() = default;
   trackInterface(const o2::track::TrackParCov& param) = delete;
-  GPUd() trackInterface(const o2::dataformats::TrackTPCITS& trkItsTpc) : o2::track::TrackParCov(trkItsTpc.getParamOut()) {}
-  GPUd() trackInterface(const o2::tpc::TrackTPC& trkTpc) : o2::track::TrackParCov(trkTpc.getParamOut()) {}
+  trackInterface(const GPUTRDTrack_t<o2::gpu::trackInterface<o2::track::TrackParCov>>& param) = delete;
+  template <class T>
+  GPUd() trackInterface(const T& trkSrc) : o2::track::TrackParCov(trkSrc.getParamOut())
+  {
+  }
 
   GPUd() void set(float x, float alpha, const float* param, const float* cov)
   {
diff --git a/GPU/GPUTracking/DataTypes/GPUTRDTrack.inc b/GPU/GPUTracking/DataTypes/GPUTRDTrack.inc
index d7109620eba29..b0d54f05aaa25 100644
--- a/GPU/GPUTracking/DataTypes/GPUTRDTrack.inc
+++ b/GPU/GPUTracking/DataTypes/GPUTRDTrack.inc
@@ -43,20 +43,20 @@ GPUd() void GPUTRDTrack_t<T>::initialize()
 #include "DataFormatsTPC/TrackTPC.h"
 
 template <typename T>
-GPUd() GPUTRDTrack_t<T>::GPUTRDTrack_t(const o2::dataformats::TrackTPCITS& t) : T(t)
+GPUd() GPUTRDTrack_t<T>::GPUTRDTrack_t(const o2::dataformats::TrackTPCITS& t) : T(static_cast<const T&>(t))
 {
   initialize();
 }
 
 template <typename T>
-GPUd() GPUTRDTrack_t<T>::GPUTRDTrack_t(const o2::tpc::TrackTPC& t) : T(t)
+GPUd() GPUTRDTrack_t<T>::GPUTRDTrack_t(const o2::tpc::TrackTPC& t) : T(static_cast<const T&>(t))
 {
   initialize();
 }
 
 template <typename T>
 GPUd() GPUTRDTrack_t<T>::GPUTRDTrack_t(const GPUTRDTrack_t<T>& t)
-  : T(t), mChi2(t.mChi2), mSignal(t.mSignal), mRefGlobalTrackId(t.mRefGlobalTrackId), mCollisionId(t.mCollisionId), mFlags(t.mFlags), mIsCrossingNeighbor(t.mIsCrossingNeighbor)
+  : T(static_cast<const T&>(t)), mChi2(t.mChi2), mSignal(t.mSignal), mRefGlobalTrackId(t.mRefGlobalTrackId), mCollisionId(t.mCollisionId), mFlags(t.mFlags), mIsCrossingNeighbor(t.mIsCrossingNeighbor)
 {
   // copy constructor
   for (int32_t i = 0; i < kNLayers; ++i) {
diff --git a/Generators/CMakeLists.txt b/Generators/CMakeLists.txt
index 287536ff118f7..5624ce7df5f07 100644
--- a/Generators/CMakeLists.txt
+++ b/Generators/CMakeLists.txt
@@ -52,7 +52,7 @@ o2_add_library(Generators
                        $<$<BOOL:${HepMC3_FOUND}>:src/AODToHepMC.cxx>
                        $<$<AND:$<BOOL:${pythia_FOUND}>,$<BOOL:${HepMC3_FOUND}>>:src/GeneratorHybrid.cxx>
                        $<$<AND:$<BOOL:${pythia_FOUND}>,$<BOOL:${HepMC3_FOUND}>>:src/GeneratorHybridParam.cxx>
-               PUBLIC_LINK_LIBRARIES FairRoot::Base O2::SimConfig O2::CommonUtils O2::DetectorsBase O2::ZDCBase
+               PUBLIC_LINK_LIBRARIES FairRoot::Base O2::SimConfig O2::CommonUtils O2::DetectorsBase O2::ZDCBase O2::DetectorsRaw
                                      O2::SimulationDataFormat ${pythiaTarget} ${hepmcTarget}
                                      FairRoot::Gen
                                      onnxruntime::onnxruntime

From 8724c34f13fb3e8c2069eda0dd1ab004e5ca3a75 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 10 Apr 2026 13:44:05 +0200
Subject: [PATCH 1612/1764] GPU: Move some files such that GPUDataTypes does
 not depend on TPCFastTransformation

---
 GPU/GPUTracking/CMakeLists.txt                |  2 +-
 GPU/GPUTracking/Standalone/CMakeLists.txt     |  1 +
 GPU/TPCFastTransformation/CMakeLists.txt      | 31 ++++-------
 .../MultivariatePolynomial.cxx                | 15 ------
 .../NDPiecewisePolynomials.cxx                | 15 ------
 .../TPCFastTransformationLinkDef_O2.h         | 29 -----------
 .../BandMatrixSolver.cxx                      |  0
 .../BandMatrixSolver.h                        |  0
 GPU/Utils/CMakeLists.txt                      | 51 ++++++++++++++++---
 GPU/Utils/GPUUtilsLinkDef.h                   | 32 ++++++++++++
 .../MultivariatePolynomial.h                  |  0
 .../MultivariatePolynomialHelper.cxx          |  0
 .../MultivariatePolynomialHelper.h            |  0
 .../NDPiecewisePolynomials.h                  |  0
 .../NDPiecewisePolynomials.inc                |  0
 .../Spline.cxx                                |  0
 GPU/{TPCFastTransformation => Utils}/Spline.h |  0
 .../Spline1D.cxx                              |  0
 .../Spline1D.h                                |  0
 .../Spline1DHelper.cxx                        |  0
 .../Spline1DHelper.h                          |  0
 .../Spline1DHelperOld.cxx                     |  0
 .../Spline1DHelperOld.h                       |  0
 .../Spline1DSpec.cxx                          |  0
 .../Spline1DSpec.h                            |  0
 .../Spline2D.cxx                              |  0
 .../Spline2D.h                                |  0
 .../Spline2DHelper.cxx                        |  0
 .../Spline2DHelper.h                          |  0
 .../Spline2DSpec.cxx                          |  0
 .../Spline2DSpec.h                            |  0
 .../SplineHelper.cxx                          |  0
 .../SplineHelper.h                            |  0
 .../SplineSpec.cxx                            |  0
 .../SplineSpec.h                              |  0
 .../SplineUtil.h                              |  0
 .../SymMatrixSolver.cxx                       |  0
 .../SymMatrixSolver.h                         |  0
 38 files changed, 89 insertions(+), 87 deletions(-)
 delete mode 100644 GPU/TPCFastTransformation/MultivariatePolynomial.cxx
 delete mode 100644 GPU/TPCFastTransformation/NDPiecewisePolynomials.cxx
 rename GPU/{TPCFastTransformation => Utils}/BandMatrixSolver.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/BandMatrixSolver.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/MultivariatePolynomial.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/MultivariatePolynomialHelper.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/MultivariatePolynomialHelper.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/NDPiecewisePolynomials.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/NDPiecewisePolynomials.inc (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline1D.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline1D.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline1DHelper.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline1DHelper.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline1DHelperOld.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline1DHelperOld.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline1DSpec.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline1DSpec.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline2D.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline2D.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline2DHelper.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline2DHelper.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline2DSpec.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/Spline2DSpec.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/SplineHelper.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/SplineHelper.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/SplineSpec.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/SplineSpec.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/SplineUtil.h (100%)
 rename GPU/{TPCFastTransformation => Utils}/SymMatrixSolver.cxx (100%)
 rename GPU/{TPCFastTransformation => Utils}/SymMatrixSolver.h (100%)

diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index a75aff4a3a752..ffabc4c9b78fb 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -352,9 +352,9 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
                  PUBLIC_LINK_LIBRARIES O2::GPUUtils
                                        O2::GPUCommon
                                        O2::ReconstructionDataFormats
-                                       O2::TPCFastTransformation
                  PRIVATE_LINK_LIBRARIES O2::DataFormatsTPC
                                         O2::TPCBase
+                                        ROOT::RIO
                  SOURCES ${SRCS_DATATYPES})
   target_compile_definitions(${targetName} PRIVATE GPUCA_O2_LIB)
 
diff --git a/GPU/GPUTracking/Standalone/CMakeLists.txt b/GPU/GPUTracking/Standalone/CMakeLists.txt
index 682ca914b6097..0c04f5e562fef 100644
--- a/GPU/GPUTracking/Standalone/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/CMakeLists.txt
@@ -208,6 +208,7 @@ target_link_libraries(standalone_support PUBLIC
                       pthread
                       Microsoft.GSL::GSL)
 
+target_link_libraries(GPUUtils PUBLIC standalone_support)
 target_link_libraries(GPUTracking PUBLIC standalone_support)
 target_link_libraries(TPCFastTransformation PUBLIC standalone_support)
 
diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index a270ba3050925..5535828d4cbbe 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -12,12 +12,6 @@
 set(MODULE TPCFastTransformation)
 
 set(SRCS
-    SplineSpec.cxx
-    Spline.cxx
-    Spline1DSpec.cxx
-    Spline1D.cxx
-    Spline2DSpec.cxx
-    Spline2D.cxx
     TPCFastTransformGeo.cxx
     TPCFastSpaceChargeCorrection.cxx
     TPCFastSpaceChargeCorrectionMap.cxx
@@ -29,15 +23,6 @@ if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   set(SRCS ${SRCS}
       CorrectionMapsHelper.cxx
       ChebyshevFit1D.cxx
-      SplineHelper.cxx
-      Spline1DHelper.cxx
-      Spline2DHelper.cxx
-      Spline1DHelperOld.cxx
-      SymMatrixSolver.cxx
-      BandMatrixSolver.cxx
-      MultivariatePolynomial.cxx
-      MultivariatePolynomialHelper.cxx
-      NDPiecewisePolynomials.cxx
       devtools/IrregularSpline1D.cxx
       devtools/IrregularSpline2D3D.cxx
       devtools/SemiregularSpline2D3D.cxx
@@ -45,8 +30,11 @@ if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   )
 endif()
 
-string(REPLACE ".cxx" ".h" HDRS_CINT_O2 "${SRCS}")
-set(HDRS_CINT_O2 ${HDRS_CINT_O2} SplineUtil.h devtools/RegularSpline1D.h CorrectionMapsTypes.h)
+string(REPLACE ".cxx" ".h" HDRS_CINT "${SRCS}")
+set(HDRS_CINT ${HDRS_CINT}
+              devtools/RegularSpline1D.h
+              CorrectionMapsTypes.h
+)
 
 if(${ALIGPU_BUILD_TYPE} STREQUAL "O2")
   o2_add_library(${MODULE}
@@ -62,10 +50,10 @@ if(${ALIGPU_BUILD_TYPE} STREQUAL "O2")
                                        ROOT::Core ROOT::Matrix ROOT::Tree ROOT::Gpad ROOT::Minuit
                              )
   o2_target_root_dictionary(${MODULE}
-                            HEADERS ${HDRS_CINT_O2}
+                            HEADERS ${HDRS_CINT}
                             LINKDEF TPCFastTransformationLinkDef_O2.h)
 
-  file(COPY ${HDRS_CINT_O2} DESTINATION ${CMAKE_BINARY_DIR}/stage/include/GPU)
+  file(COPY ${HDRS_CINT} DESTINATION ${CMAKE_BINARY_DIR}/stage/include/GPU)
 
   o2_add_test(${MODULE}
               PUBLIC_LINK_LIBRARIES O2::${MODULE}
@@ -123,10 +111,11 @@ if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
   add_library(${MODULE} SHARED ${SRCS})
   set(targetName ${MODULE})
   target_include_directories(${targetName} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
-  install(TARGETS TPCFastTransformation)
+  target_link_libraries(${targetName} PUBLIC GPUUtils)
+  install(TARGETS ${MODULE})
 endif()
 
-install(FILES ${HDRS_CINT_O2} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+install(FILES ${HDRS_CINT} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
 
 #
 # FIXME: this one is misplaced : it depends (at least) on TPCSimulation which is
diff --git a/GPU/TPCFastTransformation/MultivariatePolynomial.cxx b/GPU/TPCFastTransformation/MultivariatePolynomial.cxx
deleted file mode 100644
index b1ffe616fb65e..0000000000000
--- a/GPU/TPCFastTransformation/MultivariatePolynomial.cxx
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file  MultivariatePolynomial.cxx
-/// \author Matthias Kleiner <mkleiner@ikf.uni-frankfurt.de>
-
-#include "MultivariatePolynomial.h"
diff --git a/GPU/TPCFastTransformation/NDPiecewisePolynomials.cxx b/GPU/TPCFastTransformation/NDPiecewisePolynomials.cxx
deleted file mode 100644
index 1e2e540bdfdc8..0000000000000
--- a/GPU/TPCFastTransformation/NDPiecewisePolynomials.cxx
+++ /dev/null
@@ -1,15 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-/// \file  NDPiecewisePolynomials.cxx
-/// \author Matthias Kleiner <mkleiner@ikf.uni-frankfurt.de>
-
-#include "NDPiecewisePolynomials.h"
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index e8afef4128874..cc12badb1e654 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -23,34 +23,7 @@
 
 #pragma link C++ namespace o2::gpu;
 
-#pragma link C++ class o2::gpu::Spline1DContainer < float, o2::gpu::FlatObject> + ;
-#pragma link C++ class o2::gpu::Spline1DContainer < double, o2::gpu::FlatObject> + ;
-#pragma link C++ class o2::gpu::Spline1D < float, 0, o2::gpu::FlatObject> + ;
-#pragma link C++ class o2::gpu::Spline1D < double, 0, o2::gpu::FlatObject> + ;
-#pragma link C++ class o2::gpu::Spline1DHelperOld < float> + ;
-#pragma link C++ class o2::gpu::Spline1DHelperOld < double> + ;
-#pragma link C++ class o2::gpu::Spline1DHelper < float> + ;
-#pragma link C++ class o2::gpu::Spline1DHelper < double> + ;
-#pragma link C++ class o2::gpu::Spline1DSpec < float, 0, 2> + ;
-#pragma link C++ class o2::gpu::Spline1DSpec < double, 0, 2> + ;
-
-#pragma link C++ class o2::gpu::Spline2DContainer < float, o2::gpu::FlatObject> + ;
-#pragma link C++ class o2::gpu::Spline2DContainer < double, o2::gpu::FlatObject> + ;
-#pragma link C++ class o2::gpu::Spline2D < float, 0, o2::gpu::FlatObject> + ;
-#pragma link C++ class o2::gpu::Spline2D < double, 0, o2::gpu::FlatObject> + ;
-#pragma link C++ class o2::gpu::Spline2DHelper < float> + ;
-#pragma link C++ class o2::gpu::Spline2DHelper < double> + ;
-
-#pragma link C++ class o2::gpu::SplineContainer < float> + ;
-#pragma link C++ class o2::gpu::SplineContainer < double> + ;
-#pragma link C++ class o2::gpu::Spline < float> + ;
-#pragma link C++ class o2::gpu::Spline < double> + ;
-#pragma link C++ class o2::gpu::SplineHelper < float> + ;
-#pragma link C++ class o2::gpu::SplineHelper < double> + ;
-
 #pragma link C++ class o2::gpu::ChebyshevFit1D + ;
-#pragma link C++ class o2::gpu::SymMatrixSolver + ;
-#pragma link C++ class o2::gpu::BandMatrixSolver < 0> + ;
 
 #pragma link C++ class o2::gpu::RegularSpline1D + ;
 #pragma link C++ class o2::gpu::IrregularSpline1D + ;
@@ -80,8 +53,6 @@
 #pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "size_t mSliceDataSizeBytes[3]" version = "[-3]" target = "mCorrectionDataSize" code = "{ for (int i=0; i<3; i++) mCorrectionDataSize[i] = onfile.mSliceDataSizeBytes[i] * o2::tpc::constants::MAXSECTOR; }";
 #pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "float fInterpolationSafetyMargin" version = "[-3]" target = "" code = "{}";
 
-#pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
-#pragma link C++ struct o2::gpu::NDPiecewisePolynomialContainer + ;
 #pragma link C++ struct o2::gpu::TPCSlowSpaceChargeCorrection + ;
 #pragma link C++ class o2::gpu::TPCFastTransformPOD + ;
 
diff --git a/GPU/TPCFastTransformation/BandMatrixSolver.cxx b/GPU/Utils/BandMatrixSolver.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/BandMatrixSolver.cxx
rename to GPU/Utils/BandMatrixSolver.cxx
diff --git a/GPU/TPCFastTransformation/BandMatrixSolver.h b/GPU/Utils/BandMatrixSolver.h
similarity index 100%
rename from GPU/TPCFastTransformation/BandMatrixSolver.h
rename to GPU/Utils/BandMatrixSolver.h
diff --git a/GPU/Utils/CMakeLists.txt b/GPU/Utils/CMakeLists.txt
index 5ea8b59db5cad..48605ae26a852 100644
--- a/GPU/Utils/CMakeLists.txt
+++ b/GPU/Utils/CMakeLists.txt
@@ -11,18 +11,49 @@
 
 set(MODULE GPUUtils)
 
-set(HDRS_CINT FlatObject.h
-              GPUCommonBitSet.h
+set(SRCS
+    Spline.cxx
+    SplineSpec.cxx
+    Spline1DSpec.cxx
+    Spline1D.cxx
+    Spline2DSpec.cxx
+    Spline2D.cxx
 )
 
-set(HDRS_INSTALL
+if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
+  set(SRCS ${SRCS}
+      MultivariatePolynomialHelper.cxx
+      SplineHelper.cxx
+      Spline1DHelper.cxx
+      Spline2DHelper.cxx
+      Spline1DHelperOld.cxx
+      SymMatrixSolver.cxx
+      BandMatrixSolver.cxx
+  )
+endif()
+
+string(REPLACE ".cxx" ".h" HDRS_CINT "${SRCS}")
+set(HDRS_CINT ${HDRS_CINT}
+              FlatObject.h
+              GPUCommonBitSet.h
+              SplineUtil.h
 )
 
+if(NOT ALIGPU_BUILD_TYPE STREQUAL "Standalone")
+  set(HDRS_CINT ${HDRS_CINT}
+                MultivariatePolynomial.h
+                NDPiecewisePolynomials.h
+  )
+endif()
+
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   o2_add_library(${MODULE}
-                 SOURCES ../GPUTracking/utils/EmptyFile.cxx
+                 SOURCES ${SRCS}
                  TARGETVARNAME targetName
-                 PUBLIC_LINK_LIBRARIES O2::GPUCommon ROOT::RIO)
+                 PUBLIC_LINK_LIBRARIES O2::GPUCommon
+                                       Vc::Vc
+                                       ROOT::RIO ROOT::Core ROOT::Matrix ROOT::Tree ROOT::Gpad ROOT::Minuit
+  )
   target_include_directories(${targetName}
                              PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}>
                                     $<INSTALL_INTERFACE:include/GPU>)
@@ -33,4 +64,12 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
 
 endif()
 
-install(FILES ${HDRS_CINT} ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+if(ALIGPU_BUILD_TYPE STREQUAL "Standalone")
+  add_library(${MODULE} SHARED ${SRCS})
+  set(targetName ${MODULE})
+  target_include_directories(${targetName} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+  install(TARGETS ${MODULE})
+endif()
+
+
+install(FILES ${HDRS_CINT} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
diff --git a/GPU/Utils/GPUUtilsLinkDef.h b/GPU/Utils/GPUUtilsLinkDef.h
index ab235192ce4c5..1b20e356f7098 100644
--- a/GPU/Utils/GPUUtilsLinkDef.h
+++ b/GPU/Utils/GPUUtilsLinkDef.h
@@ -52,4 +52,36 @@
 #pragma link C++ class o2::gpu::gpustd::bitset < 31> + ;
 #pragma link C++ class o2::gpu::gpustd::bitset < 32> + ;
 
+#pragma link C++ class o2::gpu::Spline1DContainer < float, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline1DContainer < double, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline1D < float, 0, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline1D < double, 0, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline1DHelperOld < float> + ;
+#pragma link C++ class o2::gpu::Spline1DHelperOld < double> + ;
+#pragma link C++ class o2::gpu::Spline1DHelper < float> + ;
+#pragma link C++ class o2::gpu::Spline1DHelper < double> + ;
+#pragma link C++ class o2::gpu::Spline1DSpec < float, 0, 2> + ;
+#pragma link C++ class o2::gpu::Spline1DSpec < double, 0, 2> + ;
+
+#pragma link C++ class o2::gpu::Spline2DContainer < float, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline2DContainer < double, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline2D < float, 0, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline2D < double, 0, o2::gpu::FlatObject> + ;
+#pragma link C++ class o2::gpu::Spline2DHelper < float> + ;
+#pragma link C++ class o2::gpu::Spline2DHelper < double> + ;
+
+#pragma link C++ class o2::gpu::SplineContainer < float> + ;
+#pragma link C++ class o2::gpu::SplineContainer < double> + ;
+#pragma link C++ class o2::gpu::SplineHelper < float> + ;
+#pragma link C++ class o2::gpu::SplineHelper < double> + ;
+
+#pragma link C++ class o2::gpu::Spline < float> + ;
+#pragma link C++ class o2::gpu::Spline < double> + ;
+
+#pragma link C++ struct o2::gpu::MultivariatePolynomialContainer + ;
+#pragma link C++ struct o2::gpu::NDPiecewisePolynomialContainer + ;
+
+#pragma link C++ class o2::gpu::SymMatrixSolver + ;
+#pragma link C++ class o2::gpu::BandMatrixSolver < 0> + ;
+
 #endif
diff --git a/GPU/TPCFastTransformation/MultivariatePolynomial.h b/GPU/Utils/MultivariatePolynomial.h
similarity index 100%
rename from GPU/TPCFastTransformation/MultivariatePolynomial.h
rename to GPU/Utils/MultivariatePolynomial.h
diff --git a/GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx b/GPU/Utils/MultivariatePolynomialHelper.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/MultivariatePolynomialHelper.cxx
rename to GPU/Utils/MultivariatePolynomialHelper.cxx
diff --git a/GPU/TPCFastTransformation/MultivariatePolynomialHelper.h b/GPU/Utils/MultivariatePolynomialHelper.h
similarity index 100%
rename from GPU/TPCFastTransformation/MultivariatePolynomialHelper.h
rename to GPU/Utils/MultivariatePolynomialHelper.h
diff --git a/GPU/TPCFastTransformation/NDPiecewisePolynomials.h b/GPU/Utils/NDPiecewisePolynomials.h
similarity index 100%
rename from GPU/TPCFastTransformation/NDPiecewisePolynomials.h
rename to GPU/Utils/NDPiecewisePolynomials.h
diff --git a/GPU/TPCFastTransformation/NDPiecewisePolynomials.inc b/GPU/Utils/NDPiecewisePolynomials.inc
similarity index 100%
rename from GPU/TPCFastTransformation/NDPiecewisePolynomials.inc
rename to GPU/Utils/NDPiecewisePolynomials.inc
diff --git a/GPU/TPCFastTransformation/Spline.cxx b/GPU/Utils/Spline.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/Spline.cxx
rename to GPU/Utils/Spline.cxx
diff --git a/GPU/TPCFastTransformation/Spline.h b/GPU/Utils/Spline.h
similarity index 100%
rename from GPU/TPCFastTransformation/Spline.h
rename to GPU/Utils/Spline.h
diff --git a/GPU/TPCFastTransformation/Spline1D.cxx b/GPU/Utils/Spline1D.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/Spline1D.cxx
rename to GPU/Utils/Spline1D.cxx
diff --git a/GPU/TPCFastTransformation/Spline1D.h b/GPU/Utils/Spline1D.h
similarity index 100%
rename from GPU/TPCFastTransformation/Spline1D.h
rename to GPU/Utils/Spline1D.h
diff --git a/GPU/TPCFastTransformation/Spline1DHelper.cxx b/GPU/Utils/Spline1DHelper.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/Spline1DHelper.cxx
rename to GPU/Utils/Spline1DHelper.cxx
diff --git a/GPU/TPCFastTransformation/Spline1DHelper.h b/GPU/Utils/Spline1DHelper.h
similarity index 100%
rename from GPU/TPCFastTransformation/Spline1DHelper.h
rename to GPU/Utils/Spline1DHelper.h
diff --git a/GPU/TPCFastTransformation/Spline1DHelperOld.cxx b/GPU/Utils/Spline1DHelperOld.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/Spline1DHelperOld.cxx
rename to GPU/Utils/Spline1DHelperOld.cxx
diff --git a/GPU/TPCFastTransformation/Spline1DHelperOld.h b/GPU/Utils/Spline1DHelperOld.h
similarity index 100%
rename from GPU/TPCFastTransformation/Spline1DHelperOld.h
rename to GPU/Utils/Spline1DHelperOld.h
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.cxx b/GPU/Utils/Spline1DSpec.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/Spline1DSpec.cxx
rename to GPU/Utils/Spline1DSpec.cxx
diff --git a/GPU/TPCFastTransformation/Spline1DSpec.h b/GPU/Utils/Spline1DSpec.h
similarity index 100%
rename from GPU/TPCFastTransformation/Spline1DSpec.h
rename to GPU/Utils/Spline1DSpec.h
diff --git a/GPU/TPCFastTransformation/Spline2D.cxx b/GPU/Utils/Spline2D.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/Spline2D.cxx
rename to GPU/Utils/Spline2D.cxx
diff --git a/GPU/TPCFastTransformation/Spline2D.h b/GPU/Utils/Spline2D.h
similarity index 100%
rename from GPU/TPCFastTransformation/Spline2D.h
rename to GPU/Utils/Spline2D.h
diff --git a/GPU/TPCFastTransformation/Spline2DHelper.cxx b/GPU/Utils/Spline2DHelper.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/Spline2DHelper.cxx
rename to GPU/Utils/Spline2DHelper.cxx
diff --git a/GPU/TPCFastTransformation/Spline2DHelper.h b/GPU/Utils/Spline2DHelper.h
similarity index 100%
rename from GPU/TPCFastTransformation/Spline2DHelper.h
rename to GPU/Utils/Spline2DHelper.h
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.cxx b/GPU/Utils/Spline2DSpec.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/Spline2DSpec.cxx
rename to GPU/Utils/Spline2DSpec.cxx
diff --git a/GPU/TPCFastTransformation/Spline2DSpec.h b/GPU/Utils/Spline2DSpec.h
similarity index 100%
rename from GPU/TPCFastTransformation/Spline2DSpec.h
rename to GPU/Utils/Spline2DSpec.h
diff --git a/GPU/TPCFastTransformation/SplineHelper.cxx b/GPU/Utils/SplineHelper.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/SplineHelper.cxx
rename to GPU/Utils/SplineHelper.cxx
diff --git a/GPU/TPCFastTransformation/SplineHelper.h b/GPU/Utils/SplineHelper.h
similarity index 100%
rename from GPU/TPCFastTransformation/SplineHelper.h
rename to GPU/Utils/SplineHelper.h
diff --git a/GPU/TPCFastTransformation/SplineSpec.cxx b/GPU/Utils/SplineSpec.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/SplineSpec.cxx
rename to GPU/Utils/SplineSpec.cxx
diff --git a/GPU/TPCFastTransformation/SplineSpec.h b/GPU/Utils/SplineSpec.h
similarity index 100%
rename from GPU/TPCFastTransformation/SplineSpec.h
rename to GPU/Utils/SplineSpec.h
diff --git a/GPU/TPCFastTransformation/SplineUtil.h b/GPU/Utils/SplineUtil.h
similarity index 100%
rename from GPU/TPCFastTransformation/SplineUtil.h
rename to GPU/Utils/SplineUtil.h
diff --git a/GPU/TPCFastTransformation/SymMatrixSolver.cxx b/GPU/Utils/SymMatrixSolver.cxx
similarity index 100%
rename from GPU/TPCFastTransformation/SymMatrixSolver.cxx
rename to GPU/Utils/SymMatrixSolver.cxx
diff --git a/GPU/TPCFastTransformation/SymMatrixSolver.h b/GPU/Utils/SymMatrixSolver.h
similarity index 100%
rename from GPU/TPCFastTransformation/SymMatrixSolver.h
rename to GPU/Utils/SymMatrixSolver.h

From 81f60b63ffa14a508f6747a11cc56a89b99fb1ad Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 21:46:30 +0200
Subject: [PATCH 1613/1764] GPU TPCFastTransform: Use constexpr GPUTPCGeometry
 where possible

---
 GPU/TPCFastTransformation/CMakeLists.txt      |   2 +
 GPU/TPCFastTransformation/ChebyshevFit1D.h    |   7 +-
 .../CorrectionMapsHelper.h                    |   7 +-
 .../CorrectionMapsTypes.h                     |   9 +-
 .../TPCFastSpaceChargeCorrection.h            |   7 +-
 .../TPCFastSpaceChargeCorrectionMap.h         |   7 +-
 GPU/TPCFastTransformation/TPCFastTransform.h  |   7 +-
 .../TPCFastTransformGeo.h                     |   7 +-
 .../TPCFastTransformGeoPOD.h                  | 215 ++++++++++++++++++
 .../TPCFastTransformPOD.cxx                   |   5 +-
 .../TPCFastTransformPOD.h                     |  26 +--
 .../TPCFastTransformQA.h                      |   7 +-
 GPU/Utils/BandMatrixSolver.h                  |   7 +-
 GPU/Utils/Spline.h                            |   7 +-
 GPU/Utils/Spline1D.h                          |   7 +-
 GPU/Utils/Spline1DHelper.h                    |   7 +-
 GPU/Utils/Spline1DHelperOld.h                 |   7 +-
 GPU/Utils/Spline1DSpec.h                      |   7 +-
 GPU/Utils/Spline2D.h                          |   7 +-
 GPU/Utils/Spline2DHelper.h                    |   7 +-
 GPU/Utils/Spline2DSpec.h                      |   7 +-
 GPU/Utils/SplineHelper.h                      |   7 +-
 GPU/Utils/SplineSpec.h                        |   7 +-
 GPU/Utils/SplineUtil.h                        |   7 +-
 GPU/Utils/SymMatrixSolver.h                   |   7 +-
 25 files changed, 273 insertions(+), 124 deletions(-)
 create mode 100644 GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h

diff --git a/GPU/TPCFastTransformation/CMakeLists.txt b/GPU/TPCFastTransformation/CMakeLists.txt
index 5535828d4cbbe..c4fb7c04796f2 100644
--- a/GPU/TPCFastTransformation/CMakeLists.txt
+++ b/GPU/TPCFastTransformation/CMakeLists.txt
@@ -34,6 +34,7 @@ string(REPLACE ".cxx" ".h" HDRS_CINT "${SRCS}")
 set(HDRS_CINT ${HDRS_CINT}
               devtools/RegularSpline1D.h
               CorrectionMapsTypes.h
+              TPCFastTransformGeoPOD.h
 )
 
 if(${ALIGPU_BUILD_TYPE} STREQUAL "O2")
@@ -45,6 +46,7 @@ if(${ALIGPU_BUILD_TYPE} STREQUAL "O2")
                                             ${CMAKE_SOURCE_DIR}/GPU/Common
                  PUBLIC_LINK_LIBRARIES O2::GPUCommon
                                        O2::GPUUtils
+                                       O2::GPUDataTypes
                                        O2::TPCSpaceCharge
                                        Vc::Vc
                                        ROOT::Core ROOT::Matrix ROOT::Tree ROOT::Gpad ROOT::Minuit
diff --git a/GPU/TPCFastTransformation/ChebyshevFit1D.h b/GPU/TPCFastTransformation/ChebyshevFit1D.h
index 591641839dd20..49969004fbe43 100644
--- a/GPU/TPCFastTransformation/ChebyshevFit1D.h
+++ b/GPU/TPCFastTransformation/ChebyshevFit1D.h
@@ -20,9 +20,7 @@
 #include "GPUCommonDef.h"
 #include <vector>
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 ///
 ///  The class ChebyshevFit1D allows one to fit a function with chebyshev polynomials
@@ -105,7 +103,6 @@ inline double ChebyshevFit1D::eval(double x)
   return y;
 }
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
index 2ddd4bc6b3004..39c5ffc73b1da 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -19,9 +19,7 @@
 #include "TPCFastTransform.h"
 #include "CorrectionMapsTypes.h"
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 class CorrectionMapsHelper
@@ -155,7 +153,6 @@ class CorrectionMapsHelper
   ClassDefNV(CorrectionMapsHelper, 6);
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/TPCFastTransformation/CorrectionMapsTypes.h b/GPU/TPCFastTransformation/CorrectionMapsTypes.h
index 1ebb40c45c1a4..e239b668ab751 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsTypes.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsTypes.h
@@ -16,10 +16,7 @@
 #ifndef TPC_CORRECTION_MAPS_TYPES_H_
 #define TPC_CORRECTION_MAPS_TYPES_H_
 
-namespace o2
-{
-
-namespace tpc
+namespace o2::tpc
 {
 enum class LumiScaleType : int {
   Unset = -1,    ///< init value
@@ -42,7 +39,5 @@ struct CorrectionMapsGloOpts {
   bool requestCTPLumi = true;         ///< request CTP Lumi regardless of what is used for corrections scaling
   bool checkCTPIDCconsistency = true; ///< check the selected CTP or IDC scaling source being consistent with mean scaler of the map
 };
-} // namespace tpc
-} // namespace o2
-
+} // namespace o2::tpc
 #endif
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 6ae8d4d01eaff..a32c835ad7731 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -26,9 +26,7 @@
 #include "GPUCommonArray.h" // Would work on GPU, but yields performance regressions
 #endif
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 ///
@@ -545,7 +543,6 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t secto
   z = s * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
 }
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
index e54cf878ee2ff..0c389ea8d3655 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrectionMap.h
@@ -21,9 +21,7 @@
 #include "GPUCommonRtypes.h"
 #include <vector>
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 ///
@@ -101,7 +99,6 @@ class TPCFastSpaceChargeCorrectionMap
   ClassDefNV(TPCFastSpaceChargeCorrectionMap, 0);
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index d6cadc0b7428f..17a6447289bd0 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -33,9 +33,7 @@ template <class T>
 class SpaceCharge;
 }
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 /// simple struct to hold the space charge object which can be used for CPU reconstruction only
@@ -774,7 +772,6 @@ GPUdi() void TPCFastTransform::InverseTransformXYZtoNominalXYZ(int32_t sector, i
   nz = (nz1 * c1 + nz2 * c2);
 }
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 8521bee99daa6..23092c57b7e49 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -26,9 +26,7 @@
 #include "GPUCommonArray.h" // Would work on GPU, but yields performance regressions
 #endif
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 ///
@@ -321,7 +319,6 @@ GPUdi() void TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int3
   pad = u / rowInfo.padWidth + 0.5f * rowInfo.maxPad;
 }
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h b/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h
new file mode 100644
index 0000000000000..ee9a7ad2ffa70
--- /dev/null
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h
@@ -0,0 +1,215 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file  TPCFastTransformGeoPOD.h
+/// \brief Version using constexpr GPUTPCGeometry to be used for TPCFastTransformationPOD
+///
+/// \author David Rohr <drohr@cern.ch>
+
+#ifndef ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTTRANSFORMGEOPOD_H
+#define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_TPCFASTTRANSFORMGEOPOD_H
+
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
+#include "GPUTPCGeometry.h"
+
+namespace o2::gpu
+{
+
+///
+/// The TPCFastTransformGeoPOD class contains TPC geometry needed for the TPCFastTransform
+///
+struct TPCFastTransformGeoPOD {
+  /// The struct contains necessary info for TPC sector
+  struct SectorInfo {
+    float sinAlpha{0.f}; ///< sin of the angle between the local x and the global x
+    float cosAlpha{0.f}; ///< cos of the angle between the local x and the global x
+  };
+
+  /// The struct contains necessary info about TPC padrow
+  struct RowInfo {
+    float x{0.f};        ///< nominal X coordinate of the padrow [cm]
+    int32_t maxPad{0};   ///< maximal pad number = n pads - 1
+    float padWidth{0.f}; ///< width of pads [cm]
+    float yMin{0.f};     ///< min. y coordinate
+
+    /// get Y min
+    GPUdi() float getYmin() const { return yMin; }
+
+    /// get Y max
+    GPUdi() float getYmax() const { return -yMin; }
+
+    /// get width in Y
+    GPUdi() float getYwidth() const { return -2.f * yMin; }
+  };
+
+  /// Gives number of TPC sectors
+  inline static constexpr int32_t getNumberOfSectors() { return GPUTPCGeometry::NSECTORS; }
+
+  /// Gives number of TPC sectors on the A side
+  inline static constexpr int32_t getNumberOfSectorsA() { return GPUTPCGeometry::NSECTORS / 2; }
+
+  /// Gives number of TPC rows
+  GPUdi() int32_t getNumberOfRows() const { return GPUTPCGeometry::NROWS; }
+
+  /// Gives sector info
+  GPUd() const SectorInfo& getSectorInfo(uint32_t sector) const;
+
+  /// Gives TPC row info
+  GPUd() float getRowInfoX(uint32_t row) const { return GPUTPCGeometry::Row2X(row); }
+  GPUd() int32_t getRowInfoMaxPad(uint32_t row) const { return GPUTPCGeometry::NPads(row) - 1; }
+  GPUd() float getRowInfoPadWidth(uint32_t row) const { return GPUTPCGeometry::PadWidth(row); }
+
+  /// Gives Z length of the TPC, one Z side
+  GPUdi() float getTPCzLength() const { return GPUTPCGeometry::TPCLength(); }
+
+  /// Gives Z range for the corresponding TPC side
+  GPUd() float getZmin(uint32_t sector) const;
+  GPUd() float getZmax(uint32_t sector) const;
+  GPUd() float getZreadout(uint32_t sector) const;
+
+  /// _______________  Conversion of coordinate systems __________
+
+  /// convert Local -> Global c.s.
+  GPUd() void convLocalToGlobal(uint32_t sector, float lx, float ly, float lz, float& gx, float& gy, float& gz) const;
+
+  /// convert Global->Local c.s.
+  GPUd() void convGlobalToLocal(uint32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
+
+  /// convert Pad, DriftLength -> Local c.s.
+  GPUd() void convPadDriftLengthToLocal(uint32_t sector, uint32_t row, float pad, float driftLength, float& y, float& z) const;
+
+  /// convert DriftLength -> Local c.s.
+  GPUd() float convDriftLengthToZ1(uint32_t sector, float driftLength) const;
+
+  /// convert Z to DriftLength
+  GPUd() float convZtoDriftLength1(uint32_t sector, float z) const;
+
+  /// convert Local c.s. -> Pad, DriftLength
+  GPUd() void convLocalToPadDriftLength(uint32_t sector, uint32_t row, float y, float z, float& pad, float& l) const;
+
+ private:
+  /// _______________  Data members  _______________________________________________
+
+  uint32_t mConstructionMask = 0;
+
+  /// _______________  Geometry  _______________________________________________
+
+  int32_t mNumberOfRows = 0; ///< Number of TPC rows. It is different for the Run2 and the Run3 setups
+  float mTPCzLength = 0.f;   ///< Z length of one TPC side (A or C)
+
+  SectorInfo mSectorInfos[GPUTPCGeometry::NSECTORS + 1]; ///< array of sector information [fixed size]
+  RowInfo mRowInfos[160 + 1];                            ///< array of row information [fixed size]
+};
+
+// =======================================================================
+//              Inline implementations of some methods
+// =======================================================================
+
+GPUdi() const TPCFastTransformGeoPOD::SectorInfo& TPCFastTransformGeoPOD::getSectorInfo(uint32_t sector) const
+{
+  return mSectorInfos[sector];
+}
+
+GPUdi() void TPCFastTransformGeoPOD::convLocalToGlobal(uint32_t sector, float lx, float ly, float lz, float& gx, float& gy, float& gz) const
+{
+  /// convert Local -> Global c.s.
+  const SectorInfo& sectorInfo = getSectorInfo(sector);
+  gx = lx * sectorInfo.cosAlpha - ly * sectorInfo.sinAlpha;
+  gy = lx * sectorInfo.sinAlpha + ly * sectorInfo.cosAlpha;
+  gz = lz;
+}
+
+GPUdi() void TPCFastTransformGeoPOD::convGlobalToLocal(uint32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const
+{
+  /// convert Global -> Local c.s.
+  const SectorInfo& sectorInfo = getSectorInfo(sector);
+  lx = gx * sectorInfo.cosAlpha + gy * sectorInfo.sinAlpha;
+  ly = -gx * sectorInfo.sinAlpha + gy * sectorInfo.cosAlpha;
+  lz = gz;
+}
+
+GPUdi() void TPCFastTransformGeoPOD::convPadDriftLengthToLocal(uint32_t sector, uint32_t row, float pad, float driftLength, float& y, float& z) const
+{
+  /// convert Pad, DriftLength -> Local c.s.
+  const float maxPad = getRowInfoMaxPad(row);
+  const float padWidth = getRowInfoPadWidth(row);
+  const float u = (pad - 0.5f * maxPad) * padWidth;
+  if (sector < getNumberOfSectorsA()) { // TPC side A
+    y = u;
+    z = getTPCzLength() - driftLength;
+  } else {                             // TPC side C
+    y = -u;                            // pads are mirrorred on C-side
+    z = driftLength - getTPCzLength(); // drift direction is mirrored on C-side
+  }
+}
+
+GPUdi() float TPCFastTransformGeoPOD::convDriftLengthToZ1(uint32_t sector, float driftLength) const
+{
+  /// convert DriftLength -> Local c.s.
+  return (sector < getNumberOfSectorsA()) ? (getTPCzLength() - driftLength) : (driftLength - getTPCzLength());
+}
+
+GPUdi() float TPCFastTransformGeoPOD::convZtoDriftLength1(uint32_t sector, float z) const
+{
+  /// convert Z to DriftLength
+  return (sector < getNumberOfSectorsA()) ? (getTPCzLength() - z) : (z + getTPCzLength());
+}
+
+GPUdi() float TPCFastTransformGeoPOD::getZmin(uint32_t sector) const
+{
+  /// z min for the sector
+  if (sector < getNumberOfSectorsA()) { // TPC side A
+    return 0.f;
+  } else { // TPC side C
+    return -getTPCzLength();
+  }
+}
+
+GPUdi() float TPCFastTransformGeoPOD::getZmax(uint32_t sector) const
+{
+  /// z max for the sector
+  if (sector < getNumberOfSectorsA()) { // TPC side A
+    return getTPCzLength();
+  } else { // TPC side C
+    return 0.f;
+  }
+}
+
+GPUdi() float TPCFastTransformGeoPOD::getZreadout(uint32_t sector) const
+{
+  /// z readout for the sector
+  if (sector < getNumberOfSectorsA()) { // TPC side A
+    return getTPCzLength();
+  } else { // TPC side C
+    return -getTPCzLength();
+  }
+}
+
+GPUdi() void TPCFastTransformGeoPOD::convLocalToPadDriftLength(uint32_t sector, uint32_t row, float y, float z, float& pad, float& l) const
+{
+  /// convert Local c.s. -> Pad, DriftLength
+  float u;
+  if (sector < getNumberOfSectorsA()) { // TPC side A
+    u = y;
+    l = getTPCzLength() - z;
+  } else {                   // TPC side C
+    u = -y;                  // pads are mirrorred on C-side
+    l = z + getTPCzLength(); // drift direction is mirrored on C-side
+  }
+  const float maxPad = getRowInfoMaxPad(row);
+  const float padWidth = getRowInfoPadWidth(row);
+  pad = u / padWidth + 0.5f * maxPad;
+}
+
+} // namespace o2::gpu
+
+#endif
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index b463f6c36c406..747bb37787ff4 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -120,7 +120,8 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
 
   // copy fixed size data --- start
   podMap.mNumberOfScenarios = origCorr.mNumberOfScenarios;
-  std::memcpy(&podMap.mGeo, &origCorr.mGeo, sizeof(TPCFastTransformGeo)); // copy geometry (fixed size)
+  std::memcpy((void*)&podMap.mGeo, (const void*)&origCorr.mGeo, sizeof(TPCFastTransformGeo)); // copy geometry (fixed size)
+  static_assert(sizeof(podMap.mGeo) == sizeof(origCorr.mGeo));
   for (int sector = 0; sector < TPCFastTransformGeo::getNumberOfSectors(); sector++) {
     for (int row = 0; row < NROWS; row++) {
       podMap.mSectorRowInfos[NROWS * sector + row] = origCorr.getSectorRowInfo(sector, row);
@@ -250,7 +251,7 @@ bool TPCFastTransformPOD::test(const TPCFastSpaceChargeCorrection& origCorr, int
   for (int i = 0; i < npoints; i++) {
     sector.push_back(gRandom->Integer(NSECTORS));
     row.push_back(gRandom->Integer(NROWS));
-    y.push_back(2 * (gRandom->Rndm() - 0.5) * mGeo.getRowInfo(row.back()).getYmax());
+    y.push_back((gRandom->Rndm() - 0.5) * mGeo.getRowInfoMaxPad(row.back()) * mGeo.getRowInfoPadWidth(row.back()));
     z.push_back((sector.back() < NSECTORS / 2 ? 1.f : -1.f) * gRandom->Rndm() * 240);
   }
   long origStart[3], origEnd[3], thisStart[3], thisEnd[3];
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index f89504212b2eb..b30a3d52ec696 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -19,6 +19,7 @@
 
 #include "GPUCommonRtypes.h"
 #include "TPCFastTransform.h"
+#include "TPCFastTransformGeoPOD.h"
 #include "DataFormatsTPC/Constants.h"
 #ifndef GPUCA_GPUCODE
 #include <memory>
@@ -44,9 +45,7 @@ beginning of splines data for give splineID
 
 */
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 class TPCFastTransformPOD
 {
@@ -110,7 +109,7 @@ class TPCFastTransformPOD
   bool isCorrectionApplied() { return mApplyCorrection; }
 
   /// TPC geometry information
-  GPUd() const TPCFastTransformGeo& getGeometry() const { return mGeo; }
+  GPUd() const TPCFastTransformGeoPOD& getGeometry() const { return mGeo; }
 
   /// Gives TPC sector & row info
   GPUd() const SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) const { return mSectorRowInfos[NROWS * sector + row]; }
@@ -295,7 +294,7 @@ class TPCFastTransformPOD
   float mLumi;                                                                      ///< luminosity estimator (for info only)
   float mIDC;                                                                       ///< IDC estimator (for info only)
 
-  TPCFastTransformGeo mGeo; ///< TPC geometry information
+  TPCFastTransformGeoPOD mGeo; ///< TPC geometry information
   SectorRowInfo mSectorRowInfos[NROWS * TPCFastTransformGeo::getNumberOfSectors()];
 
   ClassDefNV(TPCFastTransformPOD, 0);
@@ -487,8 +486,7 @@ GPUdi() void TPCFastTransformPOD::Transform(int32_t sector, int32_t row, float p
   /// taking calibration into account.
   ///
 
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  x = rowInfo.x;
+  x = getGeometry().getRowInfoX(row);
   convPadTimeToLocal(sector, row, pad, time, y, z, vertexTime);
   TransformLocal(sector, row, x, y, z);
 }
@@ -513,8 +511,7 @@ GPUdi() void TPCFastTransformPOD::TransformInTimeFrame(int32_t sector, int32_t r
   /// Corrections and Time-Of-Flight correction are not alpplied.
   ///
 
-  const TPCFastTransformGeo::RowInfo& rowInfo = getGeometry().getRowInfo(row);
-  x = rowInfo.x;
+  x = getGeometry().getRowInfoX(row);
   convPadTimeToLocalInTimeFrame(sector, row, pad, time, y, z, maxTimeBin);
 }
 
@@ -553,7 +550,7 @@ GPUdi() void TPCFastTransformPOD::TransformIdeal(int32_t sector, int32_t row, fl
   /// No space charge corrections, no time of flight correction
   ///
 
-  x = getGeometry().getRowInfo(row).x;
+  x = getGeometry().getRowInfoX(row);
   float driftLength = (time - mT0 - vertexTime) * mVdrift; // drift length cm
   getGeometry().convPadDriftLengthToLocal(sector, row, pad, driftLength, y, z);
 }
@@ -619,7 +616,7 @@ GPUdi() void TPCFastTransformPOD::InverseTransformYZtoX(int32_t sector, int32_t
   /// Transformation y,z -> x
   float dx = 0.f;
   dx = getCorrectionXatRealYZ(sector, row, realY, realZ);
-  realX = getGeometry().getRowInfo(row).x + dx;
+  realX = getGeometry().getRowInfoX(row) + dx;
 
   GPUCA_DEBUG_STREAMER_CHECK(if (o2::utils::DebugStreamer::checkStream(o2::utils::StreamFlags::streamFastTransform)) {
     o2::utils::DebugStreamer::instance()->getStreamer("debug_fasttransform", "UPDATE") << o2::utils::DebugStreamer::instance()->getUniqueTreeName("tree_InverseTransformYZtoX").data()
@@ -711,8 +708,8 @@ GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ(int32_t sector
   }
   float nx1, ny1, nz1; // nominal coordinates for row
   float nx2, ny2, nz2; // nominal coordinates for row2
-  nx1 = getGeometry().getRowInfo(row).x;
-  nx2 = getGeometry().getRowInfo(row2).x;
+  nx1 = getGeometry().getRowInfoX(row);
+  nx2 = getGeometry().getRowInfoX(row2);
   InverseTransformYZtoNominalYZ(sector, row, y, z, ny1, nz1);
   InverseTransformYZtoNominalYZ(sector, row2, y, z, ny2, nz2);
   float c1 = (nx2 - nx) / (nx2 - nx1);
@@ -723,7 +720,6 @@ GPUdi() void TPCFastTransformPOD::InverseTransformXYZtoNominalXYZ(int32_t sector
 }
 #endif // GPUCA_GPUCODE_DEVICE
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/TPCFastTransformation/TPCFastTransformQA.h b/GPU/TPCFastTransformation/TPCFastTransformQA.h
index 727a8a87dbbc0..6f9e0e3d11753 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformQA.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformQA.h
@@ -28,9 +28,7 @@
 #include "TString.h"
 #include "AliTPCTransform.h"
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 ///
@@ -74,7 +72,6 @@ inline int32_t TPCFastTransformQA::storeError(int32_t code, const char* msg)
   LOG(info) << msg;
   return code;
 }
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/BandMatrixSolver.h b/GPU/Utils/BandMatrixSolver.h
index 7de44fe4b85e2..d2e5eed693a48 100644
--- a/GPU/Utils/BandMatrixSolver.h
+++ b/GPU/Utils/BandMatrixSolver.h
@@ -25,9 +25,7 @@
 #include <algorithm>
 #include <limits>
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 /// Linear Equation Solver for a symmetric positive-definite band matrix A[n x n].
@@ -257,7 +255,6 @@ inline void BandMatrixSolver<BandWidthT>::solveType1()
   }
 }
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/Spline.h b/GPU/Utils/Spline.h
index 477ba618999db..a35b882824cd8 100644
--- a/GPU/Utils/Spline.h
+++ b/GPU/Utils/Spline.h
@@ -19,9 +19,7 @@
 
 #include "SplineSpec.h"
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 ///
 /// The Spline class performs a cubic spline interpolation on an two-dimensional nonunifom grid.
@@ -109,7 +107,6 @@ class Spline
   ClassDefNV(Spline, 0);
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/Spline1D.h b/GPU/Utils/Spline1D.h
index 074cc7a8ffa56..8f9849ee5439d 100644
--- a/GPU/Utils/Spline1D.h
+++ b/GPU/Utils/Spline1D.h
@@ -19,9 +19,7 @@
 
 #include "Spline1DSpec.h"
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 /// The Spline1D class performs a cubic spline interpolation on a one-dimensional non-uniform grid.
 ///
@@ -192,7 +190,6 @@ class Spline1D<DataT, YdimT, NoFlatObject> : public Spline1DBase<DataT, YdimT, N
 {
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/Spline1DHelper.h b/GPU/Utils/Spline1DHelper.h
index 41aadfb92defa..d2997936cad81 100644
--- a/GPU/Utils/Spline1DHelper.h
+++ b/GPU/Utils/Spline1DHelper.h
@@ -24,9 +24,7 @@
 #include <vector>
 #include <string>
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 ///
 /// The Spline1DHelper class is to initialize parameters for Spline1D class
@@ -122,7 +120,6 @@ class Spline1DHelper
   ClassDefNV(Spline1DHelper, 0);
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/Spline1DHelperOld.h b/GPU/Utils/Spline1DHelperOld.h
index 857b8ed0ec89d..c9f4d1ba42e7d 100644
--- a/GPU/Utils/Spline1DHelperOld.h
+++ b/GPU/Utils/Spline1DHelperOld.h
@@ -26,9 +26,7 @@
 #include <functional>
 #include <string>
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 ///
 /// The Spline1DHelperOld class is to initialize parameters for Spline1D class
@@ -171,7 +169,6 @@ class Spline1DHelperOld
   ClassDefNV(Spline1DHelperOld, 0);
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/Spline1DSpec.h b/GPU/Utils/Spline1DSpec.h
index 1b0fd17b5eb5b..b3f895cbde4ed 100644
--- a/GPU/Utils/Spline1DSpec.h
+++ b/GPU/Utils/Spline1DSpec.h
@@ -28,9 +28,7 @@
 
 class TFile;
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 /// The struct Knot represents the i-th knot and the segment [knot_i, knot_i+1]
@@ -598,7 +596,6 @@ class Spline1DSpec<DataT, 1, 3, FlatBase> : public Spline1DSpec<DataT, 1, Spline
   }
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/Spline2D.h b/GPU/Utils/Spline2D.h
index 1564e52114131..f80a577401d0b 100644
--- a/GPU/Utils/Spline2D.h
+++ b/GPU/Utils/Spline2D.h
@@ -29,9 +29,7 @@
 
 class TFile;
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 ///
 /// The Spline2D class performs a cubic spline interpolation on an two-dimensional nonunifom grid.
@@ -128,7 +126,6 @@ class Spline2D<DataT, YdimT, NoFlatObject> : public Spline2DBase<DataT, YdimT, N
   using Spline2DBase<DataT, YdimT, NoFlatObject>::Spline2DBase;
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/Spline2DHelper.h b/GPU/Utils/Spline2DHelper.h
index ff3adb4831c28..1eada3146bfbb 100644
--- a/GPU/Utils/Spline2DHelper.h
+++ b/GPU/Utils/Spline2DHelper.h
@@ -28,9 +28,7 @@
 #include <functional>
 #include <string>
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 ///
@@ -165,7 +163,6 @@ int32_t Spline2DHelper<DataT>::setSpline(
   return ret;
 }
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/Spline2DSpec.h b/GPU/Utils/Spline2DSpec.h
index 2c50343d98063..6f369b56722d0 100644
--- a/GPU/Utils/Spline2DSpec.h
+++ b/GPU/Utils/Spline2DSpec.h
@@ -32,9 +32,7 @@
 
 class TFile;
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 /// ==================================================================================================
@@ -729,7 +727,6 @@ class Spline2DSpec<DataT, 1, 3, FlatBase> : public Spline2DSpec<DataT, 1, Spline
     return S;
   }
 };
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/SplineHelper.h b/GPU/Utils/SplineHelper.h
index 8c99e8113864f..7e54fa4eb676d 100644
--- a/GPU/Utils/SplineHelper.h
+++ b/GPU/Utils/SplineHelper.h
@@ -28,9 +28,7 @@
 #include "Spline1DHelperOld.h"
 #include <functional>
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 ///
@@ -159,7 +157,6 @@ int32_t SplineHelper<DataT>::setSpline(
   return ret;
 }
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/SplineSpec.h b/GPU/Utils/SplineSpec.h
index f9193fa51eaec..a8f7a885f2aa1 100644
--- a/GPU/Utils/SplineSpec.h
+++ b/GPU/Utils/SplineSpec.h
@@ -29,9 +29,7 @@
 
 class TFile;
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 /// ==================================================================================================
@@ -541,7 +539,6 @@ class SplineSpec<DataT, XdimT, 1, 3>
   using TBase::interpolate;
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/SplineUtil.h b/GPU/Utils/SplineUtil.h
index 23c786f33dc6f..35b109c548d69 100644
--- a/GPU/Utils/SplineUtil.h
+++ b/GPU/Utils/SplineUtil.h
@@ -17,9 +17,7 @@
 #ifndef ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_SPLINEUTIL_H
 #define ALICEO2_GPUCOMMON_TPCFASTTRANSFORMATION_SPLINEUTIL_H
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 /// ==================================================================================================
@@ -109,7 +107,6 @@ class SplineUtil::Switch<false, ValTrueT>
   int32_t mValFalse;
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif
diff --git a/GPU/Utils/SymMatrixSolver.h b/GPU/Utils/SymMatrixSolver.h
index 4ccb75bfa6888..e98166a3228b0 100644
--- a/GPU/Utils/SymMatrixSolver.h
+++ b/GPU/Utils/SymMatrixSolver.h
@@ -23,9 +23,7 @@
 #include <cassert>
 #include <algorithm>
 
-namespace o2
-{
-namespace gpu
+namespace o2::gpu
 {
 
 /// Linear Equation Solver for a symmetric positive-definite matrix A[n x n].
@@ -78,7 +76,6 @@ class SymMatrixSolver
   ClassDefNV(SymMatrixSolver, 0);
 };
 
-} // namespace gpu
-} // namespace o2
+} // namespace o2::gpu
 
 #endif

From e79a62a4eb4ff5a0545cd8a29d603410c119f5c4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 22:26:36 +0200
Subject: [PATCH 1614/1764] GPU: Add unfolded padWidthPerRow to GPUTPCGeometry

---
 GPU/GPUTracking/DataTypes/GPUTPCGeometry.h | 45 ++++++++++++++--------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
index 5ff022d520214..25a653ce2ecec 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
@@ -27,12 +27,12 @@ namespace gputpcgeometry_internal
 #ifndef GPUCA_RUN2 // clang-format off
 constexpr uint32_t NREGIONS = 10;
 GPUconstexpr() float mX[o2::tpc::constants::MAXGLOBALPADROW] = {85.225f, 85.975f, 86.725f, 87.475f, 88.225f, 88.975f, 89.725f, 90.475f, 91.225f, 91.975f, 92.725f, 93.475f, 94.225f, 94.975f, 95.725f, 96.475f, 97.225f, 97.975f, 98.725f, 99.475f, 100.225f, 100.975f,
-                                        101.725f, 102.475f, 103.225f, 103.975f, 104.725f, 105.475f, 106.225f, 106.975f, 107.725f, 108.475f, 109.225f, 109.975f, 110.725f, 111.475f, 112.225f, 112.975f, 113.725f, 114.475f, 115.225f, 115.975f, 116.725f, 117.475f,
-                                        118.225f, 118.975f, 119.725f, 120.475f, 121.225f, 121.975f, 122.725f, 123.475f, 124.225f, 124.975f, 125.725f, 126.475f, 127.225f, 127.975f, 128.725f, 129.475f, 130.225f, 130.975f, 131.725f, 135.2f, 136.2f, 137.2f,
-                                        138.2f, 139.2f, 140.2f, 141.2f, 142.2f, 143.2f, 144.2f, 145.2f, 146.2f, 147.2f, 148.2f, 149.2f, 150.2f, 151.2f, 152.2f, 153.2f, 154.2f, 155.2f, 156.2f, 157.2f, 158.2f, 159.2f,
-                                        160.2f, 161.2f, 162.2f, 163.2f, 164.2f, 165.2f, 166.2f, 167.2f, 168.2f, 171.4f, 172.6f, 173.8f, 175.f, 176.2f, 177.4f, 178.6f, 179.8f, 181.f, 182.2f, 183.4f, 184.6f, 185.8f,
-                                        187.f, 188.2f, 189.4f, 190.6f, 191.8f, 193.f, 194.2f, 195.4f, 196.6f, 197.8f, 199.f, 200.2f, 201.4f, 202.6f, 203.8f, 205.f, 206.2f, 209.65f, 211.15f, 212.65f, 214.15f, 215.65f,
-                                        217.15f, 218.65f, 220.15f, 221.65f, 223.15f, 224.65f, 226.15f, 227.65f, 229.15f, 230.65f, 232.15f, 233.65f, 235.15f, 236.65f, 238.15f, 239.65f, 241.15f, 242.65f, 244.15f, 245.65f};
+                                                                101.725f, 102.475f, 103.225f, 103.975f, 104.725f, 105.475f, 106.225f, 106.975f, 107.725f, 108.475f, 109.225f, 109.975f, 110.725f, 111.475f, 112.225f, 112.975f, 113.725f, 114.475f, 115.225f, 115.975f, 116.725f, 117.475f,
+                                                                118.225f, 118.975f, 119.725f, 120.475f, 121.225f, 121.975f, 122.725f, 123.475f, 124.225f, 124.975f, 125.725f, 126.475f, 127.225f, 127.975f, 128.725f, 129.475f, 130.225f, 130.975f, 131.725f, 135.2f, 136.2f, 137.2f,
+                                                                138.2f, 139.2f, 140.2f, 141.2f, 142.2f, 143.2f, 144.2f, 145.2f, 146.2f, 147.2f, 148.2f, 149.2f, 150.2f, 151.2f, 152.2f, 153.2f, 154.2f, 155.2f, 156.2f, 157.2f, 158.2f, 159.2f,
+                                                                160.2f, 161.2f, 162.2f, 163.2f, 164.2f, 165.2f, 166.2f, 167.2f, 168.2f, 171.4f, 172.6f, 173.8f, 175.f, 176.2f, 177.4f, 178.6f, 179.8f, 181.f, 182.2f, 183.4f, 184.6f, 185.8f,
+                                                                187.f, 188.2f, 189.4f, 190.6f, 191.8f, 193.f, 194.2f, 195.4f, 196.6f, 197.8f, 199.f, 200.2f, 201.4f, 202.6f, 203.8f, 205.f, 206.2f, 209.65f, 211.15f, 212.65f, 214.15f, 215.65f,
+                                                                217.15f, 218.65f, 220.15f, 221.65f, 223.15f, 224.65f, 226.15f, 227.65f, 229.15f, 230.65f, 232.15f, 233.65f, 235.15f, 236.65f, 238.15f, 239.65f, 241.15f, 242.65f, 244.15f, 245.65f};
 
 GPUconstexpr() uint8_t mNPads[o2::tpc::constants::MAXGLOBALPADROW] = {66, 66, 66, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88,
                                               90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 92, 92, 92, 94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82,
@@ -40,7 +40,7 @@ GPUconstexpr() uint8_t mNPads[o2::tpc::constants::MAXGLOBALPADROW] = {66, 66, 66
                                               110, 112, 112, 112, 114, 114, 114, 116, 116, 116, 118, 118, 118, 118, 118, 120, 120, 122, 122, 124, 124, 124, 126, 126, 128, 128, 128, 130, 130, 132, 132, 132, 134, 134, 136, 136, 138, 138};
 
 GPUconstexpr() uint8_t mRegion[o2::tpc::constants::MAXGLOBALPADROW] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-                                               4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
+                                                                       4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9};
 GPUconstexpr() uint8_t mRegionRows[NREGIONS] = {17, 15, 16, 15, 18, 16, 16, 14, 13, 12};
 GPUconstexpr() uint8_t mRegionStart[NREGIONS] = {0, 17, 32, 48, 63, 81, 97, 113, 127, 140};
 
@@ -50,23 +50,33 @@ GPUconstexpr() uint8_t mSectorFECOffset[5] = {0, 15, 15 + 18, 15 + 18 + 18, 15 +
 
 GPUconstexpr() float mPadHeight[NREGIONS] = {.75f, .75f, .75f, .75f, 1.f, 1.f, 1.2f, 1.2f, 1.5f, 1.5f};
 GPUconstexpr() float mPadWidth[NREGIONS] = {.416f, .420f, .420f, .436f, .6f, .6f, .608f, .588f, .604f, .607f};
+GPUconstexpr() float mPadWidthRow[o2::tpc::constants::MAXGLOBALPADROW] = {.416, .416, .416, .416, .416, .416, .416, .416, .416, .416, .416, .416, .416, .416, .416, .416, .416,
+                                                                          .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420,
+                                                                          .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420, .420,
+                                                                          .436, .436, .436, .436, .436, .436, .436, .436, .436, .436, .436, .436, .436, .436, .436,
+                                                                          .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600,
+                                                                          .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600, .600,
+                                                                          .608, .608, .608, .608, .608, .608, .608, .608, .608, .608, .608, .608, .608, .608, .608, .608,
+                                                                          .588, .588, .588, .588, .588, .588, .588, .588, .588, .588, .588, .588, .588, .588,
+                                                                          .604, .604, .604, .604, .604, .604, .604, .604, .604, .604, .604, .604, .604,
+                                                                          .607, .607, .607, .607, .607, .607, .607, .607, .607, .607, .607, .607};
 
 constexpr float TPC_LENGTH = 250.f;
 constexpr float FACTOR_T2Z = 250.f / 512.f; // Used in compression, must remain constant at 250cm, 512 time bins!
 #else
 constexpr uint32_t NREGIONS = 3;
 GPUconstexpr() float mX[o2::tpc::constants::MAXGLOBALPADROW] = {85.195f, 85.945f, 86.695f, 87.445f, 88.195f, 88.945f, 89.695f, 90.445f, 91.195f, 91.945f, 92.695f, 93.445f, 94.195f, 94.945f, 95.695f, 96.445f, 97.195f, 97.945f, 98.695f, 99.445f, 100.195f, 100.945f, 101.695f,
-                                        102.445f, 103.195f, 103.945f, 104.695f, 105.445f, 106.195f, 106.945f, 107.695f, 108.445f, 109.195f, 109.945f, 110.695f, 111.445f, 112.195f, 112.945f, 113.695f, 114.445f, 115.195f, 115.945f, 116.695f, 117.445f, 118.195f, 118.945f,
-                                        119.695f, 120.445f, 121.195f, 121.945f, 122.695f, 123.445f, 124.195f, 124.945f, 125.695f, 126.445f, 127.195f, 127.945f, 128.695f, 129.445f, 130.195f, 130.945f, 131.695f, 135.180f, 136.180f, 137.180f, 138.180f, 139.180f, 140.180f,
-                                        141.180f, 142.180f, 143.180f, 144.180f, 145.180f, 146.180f, 147.180f, 148.180f, 149.180f, 150.180f, 151.180f, 152.180f, 153.180f, 154.180f, 155.180f, 156.180f, 157.180f, 158.180f, 159.180f, 160.180f, 161.180f, 162.180f, 163.180f,
-                                        164.180f, 165.180f, 166.180f, 167.180f, 168.180f, 169.180f, 170.180f, 171.180f, 172.180f, 173.180f, 174.180f, 175.180f, 176.180f, 177.180f, 178.180f, 179.180f, 180.180f, 181.180f, 182.180f, 183.180f, 184.180f, 185.180f, 186.180f,
-                                        187.180f, 188.180f, 189.180f, 190.180f, 191.180f, 192.180f, 193.180f, 194.180f, 195.180f, 196.180f, 197.180f, 198.180f, 199.430f, 200.930f, 202.430f, 203.930f, 205.430f, 206.930f, 208.430f, 209.930f, 211.430f, 212.930f, 214.430f,
-                                        215.930f, 217.430f, 218.930f, 220.430f, 221.930f, 223.430f, 224.930f, 226.430f, 227.930f, 229.430f, 230.930f, 232.430f, 233.930f, 235.430f, 236.930f, 238.430f, 239.930f, 241.430f, 242.930f, 244.430f, 245.930f};
+                                                               102.445f, 103.195f, 103.945f, 104.695f, 105.445f, 106.195f, 106.945f, 107.695f, 108.445f, 109.195f, 109.945f, 110.695f, 111.445f, 112.195f, 112.945f, 113.695f, 114.445f, 115.195f, 115.945f, 116.695f, 117.445f, 118.195f, 118.945f,
+                                                               119.695f, 120.445f, 121.195f, 121.945f, 122.695f, 123.445f, 124.195f, 124.945f, 125.695f, 126.445f, 127.195f, 127.945f, 128.695f, 129.445f, 130.195f, 130.945f, 131.695f, 135.180f, 136.180f, 137.180f, 138.180f, 139.180f, 140.180f,
+                                                               141.180f, 142.180f, 143.180f, 144.180f, 145.180f, 146.180f, 147.180f, 148.180f, 149.180f, 150.180f, 151.180f, 152.180f, 153.180f, 154.180f, 155.180f, 156.180f, 157.180f, 158.180f, 159.180f, 160.180f, 161.180f, 162.180f, 163.180f,
+                                                               164.180f, 165.180f, 166.180f, 167.180f, 168.180f, 169.180f, 170.180f, 171.180f, 172.180f, 173.180f, 174.180f, 175.180f, 176.180f, 177.180f, 178.180f, 179.180f, 180.180f, 181.180f, 182.180f, 183.180f, 184.180f, 185.180f, 186.180f,
+                                                               187.180f, 188.180f, 189.180f, 190.180f, 191.180f, 192.180f, 193.180f, 194.180f, 195.180f, 196.180f, 197.180f, 198.180f, 199.430f, 200.930f, 202.430f, 203.930f, 205.430f, 206.930f, 208.430f, 209.930f, 211.430f, 212.930f, 214.430f,
+                                                               215.930f, 217.430f, 218.930f, 220.430f, 221.930f, 223.430f, 224.930f, 226.430f, 227.930f, 229.430f, 230.930f, 232.430f, 233.930f, 235.430f, 236.930f, 238.430f, 239.930f, 241.430f, 242.930f, 244.430f, 245.930f};
 
 GPUconstexpr() uint8_t mNPads[o2::tpc::constants::MAXGLOBALPADROW] = {68, 68, 68, 68, 70, 70, 70, 72, 72, 72, 74, 74, 74, 76, 76, 76, 78, 78, 78, 80, 80, 80, 82, 82, 82, 84, 84, 84, 86, 86, 86, 88, 88, 88, 90, 90, 90, 92, 92, 92,
-                                              94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 108, 108, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82, 82, 84, 84,
-                                              84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108,
-                                              108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
+                                                                      94, 94, 94, 96, 96, 96, 98, 98, 98, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 108, 108, 74, 76, 76, 76, 76, 78, 78, 78, 80, 80, 80, 80, 82, 82, 82, 84, 84,
+                                                                      84, 86, 86, 86, 86, 88, 88, 88, 90, 90, 90, 90, 92, 92, 92, 94, 94, 94, 96, 96, 96, 96, 98, 98, 98, 100, 100, 100, 100, 102, 102, 102, 104, 104, 104, 106, 106, 106, 106, 108,
+                                                                      108, 108, 110, 110, 110, 110, 112, 112, 114, 114, 114, 116, 116, 118, 118, 120, 120, 122, 122, 122, 124, 124, 126, 126, 128, 128, 130, 130, 130, 132, 132, 134, 134, 136, 136, 138, 138, 138, 140};
 
 GPUconstexpr() float mPadHeight[NREGIONS] = {.75f, 1.f, 1.5f};
 GPUconstexpr() float mPadWidth[NREGIONS] = {.4f, .6f, .6f};
@@ -96,6 +106,7 @@ class GPUTPCGeometry
   GPUd() static constexpr int32_t EndOROC1() { return 97; }
   GPUd() static constexpr int32_t EndOROC2() { return 127; }
   GPUd() static constexpr int32_t MaxNPadsPerRow() { return 138; }
+  GPUd() static constexpr float PadWidth(int32_t row) { return (gputpcgeometry_internal::mPadWidthRow[row]); }
 #else
   GPUd() static constexpr int32_t GetRegion(int32_t row) { return (row < 63 ? 0 : row < 63 + 64 ? 1 : 2); }
   GPUd() static constexpr int32_t GetRegionRows(int32_t region) { return 0; }  // dummy
@@ -105,6 +116,7 @@ class GPUTPCGeometry
   GPUd() static constexpr int32_t EndOROC1() { return 63 + 64; }
   GPUd() static constexpr int32_t EndOROC2() { return GPUTPCGeometry::NROWS; }
   GPUd() static constexpr int32_t MaxNPadsPerRow() { return 140; }
+  GPUd() static constexpr float PadWidth(int32_t row) { return (gputpcgeometry_internal::mPadWidth[GetRegion(row)]); }
 #endif
 
   GPUd() static constexpr float NRegions() { return gputpcgeometry_internal::NREGIONS; }
@@ -112,7 +124,6 @@ class GPUTPCGeometry
   GPUd() static constexpr float Row2X(int32_t row) { return (gputpcgeometry_internal::mX[row]); }
   GPUd() static constexpr float PadHeight(int32_t row) { return (gputpcgeometry_internal::mPadHeight[GetRegion(row)]); }
   GPUd() static constexpr float PadHeightByRegion(int32_t region) { return (gputpcgeometry_internal::mPadHeight[region]); }
-  GPUd() static constexpr float PadWidth(int32_t row) { return (gputpcgeometry_internal::mPadWidth[GetRegion(row)]); }
   GPUd() static constexpr float PadWidthByRegion(int32_t region) { return (gputpcgeometry_internal::mPadWidth[region]); }
   GPUd() static constexpr uint8_t NPads(int32_t row) { return gputpcgeometry_internal::mNPads[row]; }
 

From b8e2750be5a7330b9aa3218003dfbfc294806180 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Thu, 9 Apr 2026 22:42:07 +0200
Subject: [PATCH 1615/1764] GPU: Add sector angles to GPUTPCGeometry

---
 GPU/GPUTracking/Base/GPUParam.cxx             |  22 --
 GPU/GPUTracking/Base/GPUParam.h               |  11 +-
 GPU/GPUTracking/Base/GPUParam.inc             |   8 +-
 .../GPUTPCCompressionKernels.cxx              |   4 +-
 .../TPCClusterDecompressionCore.inc           |   4 +-
 GPU/GPUTracking/DataTypes/GPUTPCGeometry.h    |  28 ++-
 .../TPCFastTransformGeoPOD.h                  | 212 +++++-------------
 .../TPCFastTransformPOD.cxx                   |   2 -
 8 files changed, 92 insertions(+), 199 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUParam.cxx b/GPU/GPUTracking/Base/GPUParam.cxx
index 3f6c08e9f53fe..7edfa8ffd41d5 100644
--- a/GPU/GPUTracking/Base/GPUParam.cxx
+++ b/GPU/GPUTracking/Base/GPUParam.cxx
@@ -87,28 +87,6 @@ void GPUParam::SetDefaults(float solenoidBz, bool assumeConstantBz)
   UpdateBzOnly(solenoidBz, assumeConstantBz);
   par.dodEdx = 0;
 
-  constexpr float plusZmin = 0.0529937;
-  constexpr float plusZmax = 249.778;
-  constexpr float minusZmin = -249.645;
-  constexpr float minusZmax = -0.0799937;
-  for (uint32_t i = 0; i < GPUTPCGeometry::NSECTORS; i++) {
-    const bool zPlus = (i < GPUTPCGeometry::NSECTORS / 2);
-    SectorParam[i].ZMin = zPlus ? plusZmin : minusZmin;
-    SectorParam[i].ZMax = zPlus ? plusZmax : minusZmax;
-    int32_t tmp = i;
-    if (tmp >= (int32_t)GPUTPCGeometry::NSECTORS / 2) {
-      tmp -= GPUTPCGeometry::NSECTORS / 2;
-    }
-    if (tmp >= (int32_t)GPUTPCGeometry::NSECTORS / 4) {
-      tmp -= GPUTPCGeometry::NSECTORS / 2;
-    }
-    SectorParam[i].Alpha = 0.174533f + dAlpha * tmp;
-    SectorParam[i].CosAlpha = CAMath::Cos(SectorParam[i].Alpha);
-    SectorParam[i].SinAlpha = CAMath::Sin(SectorParam[i].Alpha);
-    SectorParam[i].AngleMin = SectorParam[i].Alpha - dAlpha / 2.f;
-    SectorParam[i].AngleMax = SectorParam[i].Alpha + dAlpha / 2.f;
-  }
-
   par.continuousTracking = false;
   continuousMaxTimeBin = 0;
   tpcCutTimeBin = 0;
diff --git a/GPU/GPUTracking/Base/GPUParam.h b/GPU/GPUTracking/Base/GPUParam.h
index 27d23fd49920a..11c48f5aadc70 100644
--- a/GPU/GPUTracking/Base/GPUParam.h
+++ b/GPU/GPUTracking/Base/GPUParam.h
@@ -37,13 +37,6 @@ struct GPUSettingsRec;
 struct GPUSettingsGTP;
 struct GPURecoStepConfiguration;
 
-struct GPUParamSector {
-  float Alpha;              // sector angle
-  float CosAlpha, SinAlpha; // sign and cosine of the sector angle
-  float AngleMin, AngleMax; // minimal and maximal angle
-  float ZMin, ZMax;         // sector Z range
-};
-
 namespace internal
 {
 template <class T, class S>
@@ -66,8 +59,6 @@ struct GPUParam_t {
   uint32_t occupancyTotal;                 // Total occupancy in the TPC (nCl / nHbf)
   uint32_t occupancyMapSize;               // Size of occupancy map
 
-  GPUParamSector SectorParam[o2::tpc::constants::MAXSECTOR];
-
  protected:
 #ifndef GPUCA_RUN2
   float ParamErrors[2][4][4]; // cluster error parameterization used during seeding and fit
@@ -89,7 +80,7 @@ struct GPUParam : public internal::GPUParam_t<GPUSettingsRec, GPUSettingsParam>
 #endif
 
   GPUd() constexpr uint32_t tpcMinHitsB5(float qPtB5) const { return CAMath::Abs(qPtB5) > 10 ? 10 : (CAMath::Abs(qPtB5) > 5 ? 15 : 29); } // Minimum hits should depend on Pt, low Pt tracks can have few hits. 29 Hits default, 15 for < 200 mev, 10 for < 100 mev
-  GPUd() constexpr float Alpha(int32_t iSector) const
+  GPUd() constexpr float Alpha(int32_t iSector) const                                                                                     // TODO: Check if this is faster, or the lookup from GPUTPCGeometry
   {
     if (iSector >= (int32_t)o2::tpc::constants::MAXSECTOR / 2) {
       iSector -= o2::tpc::constants::MAXSECTOR / 2;
diff --git a/GPU/GPUTracking/Base/GPUParam.inc b/GPU/GPUTracking/Base/GPUParam.inc
index 8ed6160af361d..566592bdd8d61 100644
--- a/GPU/GPUTracking/Base/GPUParam.inc
+++ b/GPU/GPUTracking/Base/GPUParam.inc
@@ -26,16 +26,16 @@ namespace o2::gpu
 GPUdi() void GPUParam::Sector2Global(int32_t iSector, float x, float y, float z, float* X, float* Y, float* Z) const
 {
   // conversion of coordinates sector->global
-  *X = x * SectorParam[iSector].CosAlpha - y * SectorParam[iSector].SinAlpha;
-  *Y = y * SectorParam[iSector].CosAlpha + x * SectorParam[iSector].SinAlpha;
+  *X = x * GPUTPCGeometry::SectorCos(iSector) - y * GPUTPCGeometry::SectorSin(iSector);
+  *Y = y * GPUTPCGeometry::SectorCos(iSector) + x * GPUTPCGeometry::SectorSin(iSector);
   *Z = z;
 }
 
 GPUdi() void GPUParam::Global2Sector(int32_t iSector, float X, float Y, float Z, float* x, float* y, float* z) const
 {
   // conversion of coordinates global->sector
-  *x = X * SectorParam[iSector].CosAlpha + Y * SectorParam[iSector].SinAlpha;
-  *y = Y * SectorParam[iSector].CosAlpha - X * SectorParam[iSector].SinAlpha;
+  *x = X * GPUTPCGeometry::SectorCos(iSector) + Y * GPUTPCGeometry::SectorSin(iSector);
+  *y = Y * GPUTPCGeometry::SectorCos(iSector) - X * GPUTPCGeometry::SectorSin(iSector);
   *z = Z;
 }
 
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index abf94746f5a72..35f4e0d931c22 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -76,7 +76,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
         if ((hit.sector < GPUTPCGeometry::NSECTORS) ^ (lastSector < GPUTPCGeometry::NSECTORS)) {
           break;
         }
-        if (track.Propagate(geo.Row2X(hit.row), param.SectorParam[hit.sector].Alpha)) {
+        if (track.Propagate(geo.Row2X(hit.row), GPUTPCGeometry::SectorAlpha(hit.sector))) {
           break;
         }
       }
@@ -87,7 +87,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step0at
       if (nClustersStored == 1) {
         uint8_t qpt = fabs(trk.GetParam().GetQPt()) < 20.f ? (trk.GetParam().GetQPt() * (127.f / 20.f) + 127.5f) : (trk.GetParam().GetQPt() > 0 ? 254 : 0);
         zOffset = z;
-        track.Init(x, y, z - zOffset, param.SectorParam[hit.sector].Alpha, qpt, param);
+        track.Init(x, y, z - zOffset, GPUTPCGeometry::SectorAlpha(hit.sector), qpt, param);
 
         myTrack = CAMath::AtomicAdd(&compressor.mMemory->nStoredTracks, 1u);
         compressor.mAttachedClusterFirstIndex[myTrack] = trk.FirstClusterRef();
diff --git a/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc b/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
index 3089a454c048b..02054887ab82c 100644
--- a/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
+++ b/GPU/GPUTracking/DataCompression/TPCClusterDecompressionCore.inc
@@ -107,7 +107,7 @@ class TPCClusterDecompressionCore
         if (changeLeg && track.Mirror()) {
           break;
         }
-        if (track.Propagate(geo.Row2X(row), param.SectorParam[slice].Alpha)) {
+        if (track.Propagate(geo.Row2X(row), GPUTPCGeometry::SectorAlpha(slice))) {
           break;
         }
         uint32_t timeTmp = cmprClusters.timeResA[clusterOffset - trackIndex - 1];
@@ -142,7 +142,7 @@ class TPCClusterDecompressionCore
       float z = geo.LinearTime2Z(slice, cluster.getTime());
       if (clusterIndex == 0) {
         zOffset = z;
-        track.Init(geo.Row2X(row), y, z - zOffset, param.SectorParam[slice].Alpha, cmprClusters.qPtA[trackIndex], param);
+        track.Init(geo.Row2X(row), y, z - zOffset, GPUTPCGeometry::SectorAlpha(slice), cmprClusters.qPtA[trackIndex], param);
       }
       if (clusterIndex + 1 < cmprClusters.nTrackClusters[trackIndex] && track.Filter(y, z - zOffset, row)) {
         break;
diff --git a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
index 25a653ce2ecec..164f768d646ff 100644
--- a/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
+++ b/GPU/GPUTracking/DataTypes/GPUTPCGeometry.h
@@ -83,7 +83,20 @@ GPUconstexpr() float mPadWidth[NREGIONS] = {.4f, .6f, .6f};
 
 constexpr float TPC_LENGTH = 250.f - 0.275f;
 constexpr float FACTOR_T2Z = 250.f / 1024.f; // Used in compression, must remain constant at 250cm, 1024 time bins!
-#endif // clang-format on
+#endif
+
+GPUconstexpr() float mSectorAngle[o2::tpc::constants::MAXSECTOR][2] = {{0x1.63a1a8p-3f, 0x1.f838b8p-1f}, {0x1p-1f, 0x1.bb67aep-1f}, {0x1.8836fap-1f, 0x1.491b76p-1f}, {0x1.e11f64p-1f, 0x1.5e3a88p-2f}, {0x1p+0f, 0x1.1a6264p-54f}, {0x1.e11f64p-1f, -0x1.5e3a88p-2f},
+                                                                       {0x1.8836fap-1f, -0x1.491b76p-1f}, {0x1p-1f, -0x1.bb67aep-1f}, {0x1.63a1a8p-3f, -0x1.f838b8p-1f}, {-0x1.63a1a8p-3f, -0x1.f838b8p-1f}, {-0x1p-1f, -0x1.bb67aep-1f}, {-0x1.8836fap-1f, -0x1.491b76p-1f},
+                                                                       {-0x1.e11f64p-1f, -0x1.5e3a88p-2f}, {-0x1p+0f, -0x1.a79394p-53f}, {-0x1.e11f64p-1f, 0x1.5e3a88p-2f}, {-0x1.8836fap-1f, 0x1.491b76p-1f}, {-0x1p-1f, 0x1.bb67aep-1f}, {-0x1.63a1a8p-3f, 0x1.f838b8p-1f},
+                                                                       {0x1.63a1a8p-3f, 0x1.f838b8p-1f}, {0x1p-1f, 0x1.bb67aep-1f}, {0x1.8836fap-1f, 0x1.491b76p-1f}, {0x1.e11f64p-1f, 0x1.5e3a88p-2f}, {0x1p+0f, 0x1.60fafcp-52f}, {0x1.e11f64p-1f, -0x1.5e3a88p-2f},
+                                                                       {0x1.8836fap-1f, -0x1.491b76p-1f}, {0x1p-1f, -0x1.bb67aep-1f}, {0x1.63a1a8p-3f, -0x1.f838b8p-1f}, {-0x1.63a1a8p-3f, -0x1.f838b8p-1f}, {-0x1p-1f, -0x1.bb67aep-1f}, {-0x1.8836fap-1f, -0x1.491b76p-1f},
+                                                                       {-0x1.e11f64p-1f, -0x1.5e3a88p-2f}, {-0x1p+0f, -0x1.ee2c2ep-52f}, {-0x1.e11f64p-1f, 0x1.5e3a88p-2f}, {-0x1.8836fap-1f, 0x1.491b76p-1f}, {-0x1p-1f, 0x1.bb67aep-1f}, {-0x1.63a1a8p-3f, 0x1.f838b8p-1f}};
+
+GPUconstexpr() float mSectorAlpha[o2::tpc::constants::MAXSECTOR] = {0x1.65718ep-3f, 0x1.0c152ap-1f, 0x1.becdf2p-1f, 0x1.38c35cp+0f, 0x1.921fcp+0f, 0x1.eb7c24p+0f, 0x1.226c44p+1f, 0x1.4f1a76p+1f, 0x1.7bc8a6p+1f,
+                                                                    -0x1.7bc8a6p+1f, -0x1.4f1a76p+1f, -0x1.226c44p+1f, -0x1.eb7c24p+0f, -0x1.921fcp+0f, -0x1.38c35cp+0f, -0x1.becdf2p-1f, -0x1.0c152ap-1f, -0x1.65718ep-3f,
+                                                                    0x1.65718ep-3f, 0x1.0c152ap-1f, 0x1.becdf2p-1f, 0x1.38c35cp+0f, 0x1.921fcp+0f, 0x1.eb7c24p+0f, 0x1.226c44p+1f, 0x1.4f1a76p+1f, 0x1.7bc8a6p+1f,
+                                                                    -0x1.7bc8a6p+1f, -0x1.4f1a76p+1f, -0x1.226c44p+1f, -0x1.eb7c24p+0f, -0x1.921fcp+0f, -0x1.38c35cp+0f, -0x1.becdf2p-1f, -0x1.0c152ap-1f, -0x1.65718ep-3f};
+// clang-format on
 } // namespace gputpcgeometry_internal
 
 class GPUTPCGeometry
@@ -119,13 +132,16 @@ class GPUTPCGeometry
   GPUd() static constexpr float PadWidth(int32_t row) { return (gputpcgeometry_internal::mPadWidth[GetRegion(row)]); }
 #endif
 
+  GPUd() static constexpr float Row2X(uint32_t row) { return (gputpcgeometry_internal::mX[row]); }
   GPUd() static constexpr float NRegions() { return gputpcgeometry_internal::NREGIONS; }
   GPUd() static constexpr float TPCLength() { return gputpcgeometry_internal::TPC_LENGTH; }
-  GPUd() static constexpr float Row2X(int32_t row) { return (gputpcgeometry_internal::mX[row]); }
-  GPUd() static constexpr float PadHeight(int32_t row) { return (gputpcgeometry_internal::mPadHeight[GetRegion(row)]); }
-  GPUd() static constexpr float PadHeightByRegion(int32_t region) { return (gputpcgeometry_internal::mPadHeight[region]); }
-  GPUd() static constexpr float PadWidthByRegion(int32_t region) { return (gputpcgeometry_internal::mPadWidth[region]); }
-  GPUd() static constexpr uint8_t NPads(int32_t row) { return gputpcgeometry_internal::mNPads[row]; }
+  GPUd() static constexpr float PadHeight(uint32_t row) { return (gputpcgeometry_internal::mPadHeight[GetRegion(row)]); }
+  GPUd() static constexpr float PadHeightByRegion(uint32_t region) { return (gputpcgeometry_internal::mPadHeight[region]); }
+  GPUd() static constexpr float PadWidthByRegion(uint32_t region) { return (gputpcgeometry_internal::mPadWidth[region]); }
+  GPUd() static constexpr uint8_t NPads(uint32_t row) { return gputpcgeometry_internal::mNPads[row]; }
+  GPUd() static constexpr float SectorSin(uint32_t sector) { return gputpcgeometry_internal::mSectorAngle[sector][0]; }
+  GPUd() static constexpr float SectorCos(uint32_t sector) { return gputpcgeometry_internal::mSectorAngle[sector][1]; }
+  GPUd() static constexpr float SectorAlpha(uint32_t sector) { return gputpcgeometry_internal::mSectorAlpha[sector]; }
 
   GPUd() static constexpr float LinearPad2Y(uint32_t sector, uint32_t row, float pad)
   {
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h b/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h
index ee9a7ad2ffa70..dbb6176dd47b9 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h
@@ -23,34 +23,10 @@
 
 namespace o2::gpu
 {
-
 ///
-/// The TPCFastTransformGeoPOD class contains TPC geometry needed for the TPCFastTransform
+/// The TPCFastTransformGeoPOD class contains TPC geometry needed for the TPCFastTransformPOD
 ///
 struct TPCFastTransformGeoPOD {
-  /// The struct contains necessary info for TPC sector
-  struct SectorInfo {
-    float sinAlpha{0.f}; ///< sin of the angle between the local x and the global x
-    float cosAlpha{0.f}; ///< cos of the angle between the local x and the global x
-  };
-
-  /// The struct contains necessary info about TPC padrow
-  struct RowInfo {
-    float x{0.f};        ///< nominal X coordinate of the padrow [cm]
-    int32_t maxPad{0};   ///< maximal pad number = n pads - 1
-    float padWidth{0.f}; ///< width of pads [cm]
-    float yMin{0.f};     ///< min. y coordinate
-
-    /// get Y min
-    GPUdi() float getYmin() const { return yMin; }
-
-    /// get Y max
-    GPUdi() float getYmax() const { return -yMin; }
-
-    /// get width in Y
-    GPUdi() float getYwidth() const { return -2.f * yMin; }
-  };
-
   /// Gives number of TPC sectors
   inline static constexpr int32_t getNumberOfSectors() { return GPUTPCGeometry::NSECTORS; }
 
@@ -58,157 +34,91 @@ struct TPCFastTransformGeoPOD {
   inline static constexpr int32_t getNumberOfSectorsA() { return GPUTPCGeometry::NSECTORS / 2; }
 
   /// Gives number of TPC rows
-  GPUdi() int32_t getNumberOfRows() const { return GPUTPCGeometry::NROWS; }
+  inline static constexpr int32_t getNumberOfRows() { return GPUTPCGeometry::NROWS; }
 
   /// Gives sector info
-  GPUd() const SectorInfo& getSectorInfo(uint32_t sector) const;
+  inline static constexpr float getSectorSin(uint32_t sector) { return GPUTPCGeometry::SectorSin(sector); }
+  inline static constexpr float getSectorCos(uint32_t sector) { return GPUTPCGeometry::SectorCos(sector); }
 
   /// Gives TPC row info
-  GPUd() float getRowInfoX(uint32_t row) const { return GPUTPCGeometry::Row2X(row); }
-  GPUd() int32_t getRowInfoMaxPad(uint32_t row) const { return GPUTPCGeometry::NPads(row) - 1; }
-  GPUd() float getRowInfoPadWidth(uint32_t row) const { return GPUTPCGeometry::PadWidth(row); }
+  inline static constexpr float getRowInfoX(uint32_t row) { return GPUTPCGeometry::Row2X(row); }
+  inline static constexpr int32_t getRowInfoMaxPad(uint32_t row) { return GPUTPCGeometry::NPads(row) - 1; }
+  inline static constexpr float getRowInfoPadWidth(uint32_t row) { return GPUTPCGeometry::PadWidth(row); }
 
   /// Gives Z length of the TPC, one Z side
-  GPUdi() float getTPCzLength() const { return GPUTPCGeometry::TPCLength(); }
+  inline static constexpr float getTPCzLength() { return GPUTPCGeometry::TPCLength(); }
 
   /// Gives Z range for the corresponding TPC side
-  GPUd() float getZmin(uint32_t sector) const;
-  GPUd() float getZmax(uint32_t sector) const;
-  GPUd() float getZreadout(uint32_t sector) const;
+  inline static constexpr float getZmin(uint32_t sector) { return sector < getNumberOfSectorsA() ? 0.f : -getTPCzLength(); }
+  inline static constexpr float getZmax(uint32_t sector) { return sector < getNumberOfSectorsA() ? getTPCzLength() : 0.f; }
+  inline static constexpr float getZreadout(uint32_t sector) { return sector < getNumberOfSectorsA() ? getTPCzLength() : -getTPCzLength(); }
 
   /// _______________  Conversion of coordinate systems __________
 
   /// convert Local -> Global c.s.
-  GPUd() void convLocalToGlobal(uint32_t sector, float lx, float ly, float lz, float& gx, float& gy, float& gz) const;
+  inline static constexpr void convLocalToGlobal(uint32_t sector, float lx, float ly, float lz, float& gx, float& gy, float& gz)
+  {
+    const float sinAlpha = getSectorSin(sector);
+    const float cosAlpha = getSectorCos(sector);
+    gx = lx * cosAlpha - ly * sinAlpha;
+    gy = lx * sinAlpha + ly * cosAlpha;
+    gz = lz;
+  }
 
   /// convert Global->Local c.s.
-  GPUd() void convGlobalToLocal(uint32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const;
-
-  /// convert Pad, DriftLength -> Local c.s.
-  GPUd() void convPadDriftLengthToLocal(uint32_t sector, uint32_t row, float pad, float driftLength, float& y, float& z) const;
-
-  /// convert DriftLength -> Local c.s.
-  GPUd() float convDriftLengthToZ1(uint32_t sector, float driftLength) const;
-
-  /// convert Z to DriftLength
-  GPUd() float convZtoDriftLength1(uint32_t sector, float z) const;
-
-  /// convert Local c.s. -> Pad, DriftLength
-  GPUd() void convLocalToPadDriftLength(uint32_t sector, uint32_t row, float y, float z, float& pad, float& l) const;
-
- private:
-  /// _______________  Data members  _______________________________________________
-
-  uint32_t mConstructionMask = 0;
-
-  /// _______________  Geometry  _______________________________________________
-
-  int32_t mNumberOfRows = 0; ///< Number of TPC rows. It is different for the Run2 and the Run3 setups
-  float mTPCzLength = 0.f;   ///< Z length of one TPC side (A or C)
-
-  SectorInfo mSectorInfos[GPUTPCGeometry::NSECTORS + 1]; ///< array of sector information [fixed size]
-  RowInfo mRowInfos[160 + 1];                            ///< array of row information [fixed size]
-};
-
-// =======================================================================
-//              Inline implementations of some methods
-// =======================================================================
-
-GPUdi() const TPCFastTransformGeoPOD::SectorInfo& TPCFastTransformGeoPOD::getSectorInfo(uint32_t sector) const
-{
-  return mSectorInfos[sector];
-}
-
-GPUdi() void TPCFastTransformGeoPOD::convLocalToGlobal(uint32_t sector, float lx, float ly, float lz, float& gx, float& gy, float& gz) const
-{
-  /// convert Local -> Global c.s.
-  const SectorInfo& sectorInfo = getSectorInfo(sector);
-  gx = lx * sectorInfo.cosAlpha - ly * sectorInfo.sinAlpha;
-  gy = lx * sectorInfo.sinAlpha + ly * sectorInfo.cosAlpha;
-  gz = lz;
-}
+  inline static constexpr void convGlobalToLocal(uint32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz)
+  {
+    const float sinAlpha = getSectorSin(sector);
+    const float cosAlpha = getSectorCos(sector);
+    lx = gx * cosAlpha + gy * sinAlpha;
+    ly = -gx * sinAlpha + gy * cosAlpha;
+    lz = gz;
+  }
 
-GPUdi() void TPCFastTransformGeoPOD::convGlobalToLocal(uint32_t sector, float gx, float gy, float gz, float& lx, float& ly, float& lz) const
-{
-  /// convert Global -> Local c.s.
-  const SectorInfo& sectorInfo = getSectorInfo(sector);
-  lx = gx * sectorInfo.cosAlpha + gy * sectorInfo.sinAlpha;
-  ly = -gx * sectorInfo.sinAlpha + gy * sectorInfo.cosAlpha;
-  lz = gz;
-}
-
-GPUdi() void TPCFastTransformGeoPOD::convPadDriftLengthToLocal(uint32_t sector, uint32_t row, float pad, float driftLength, float& y, float& z) const
-{
   /// convert Pad, DriftLength -> Local c.s.
-  const float maxPad = getRowInfoMaxPad(row);
-  const float padWidth = getRowInfoPadWidth(row);
-  const float u = (pad - 0.5f * maxPad) * padWidth;
-  if (sector < getNumberOfSectorsA()) { // TPC side A
-    y = u;
-    z = getTPCzLength() - driftLength;
-  } else {                             // TPC side C
-    y = -u;                            // pads are mirrorred on C-side
-    z = driftLength - getTPCzLength(); // drift direction is mirrored on C-side
+  inline static constexpr void convPadDriftLengthToLocal(uint32_t sector, uint32_t row, float pad, float driftLength, float& y, float& z)
+  {
+    const float maxPad = getRowInfoMaxPad(row);
+    const float padWidth = getRowInfoPadWidth(row);
+    const float u = (pad - 0.5f * maxPad) * padWidth;
+    if (sector < getNumberOfSectorsA()) { // TPC side A
+      y = u;
+      z = getTPCzLength() - driftLength;
+    } else {                             // TPC side C
+      y = -u;                            // pads are mirrorred on C-side
+      z = driftLength - getTPCzLength(); // drift direction is mirrored on C-side
+    }
   }
-}
 
-GPUdi() float TPCFastTransformGeoPOD::convDriftLengthToZ1(uint32_t sector, float driftLength) const
-{
   /// convert DriftLength -> Local c.s.
-  return (sector < getNumberOfSectorsA()) ? (getTPCzLength() - driftLength) : (driftLength - getTPCzLength());
-}
-
-GPUdi() float TPCFastTransformGeoPOD::convZtoDriftLength1(uint32_t sector, float z) const
-{
-  /// convert Z to DriftLength
-  return (sector < getNumberOfSectorsA()) ? (getTPCzLength() - z) : (z + getTPCzLength());
-}
-
-GPUdi() float TPCFastTransformGeoPOD::getZmin(uint32_t sector) const
-{
-  /// z min for the sector
-  if (sector < getNumberOfSectorsA()) { // TPC side A
-    return 0.f;
-  } else { // TPC side C
-    return -getTPCzLength();
-  }
-}
-
-GPUdi() float TPCFastTransformGeoPOD::getZmax(uint32_t sector) const
-{
-  /// z max for the sector
-  if (sector < getNumberOfSectorsA()) { // TPC side A
-    return getTPCzLength();
-  } else { // TPC side C
-    return 0.f;
+  inline static constexpr float convDriftLengthToZ1(uint32_t sector, float driftLength)
+  {
+    return (sector < getNumberOfSectorsA()) ? (getTPCzLength() - driftLength) : (driftLength - getTPCzLength());
   }
-}
 
-GPUdi() float TPCFastTransformGeoPOD::getZreadout(uint32_t sector) const
-{
-  /// z readout for the sector
-  if (sector < getNumberOfSectorsA()) { // TPC side A
-    return getTPCzLength();
-  } else { // TPC side C
-    return -getTPCzLength();
+  /// convert Z to DriftLength
+  inline static constexpr float convZtoDriftLength1(uint32_t sector, float z)
+  {
+    return (sector < getNumberOfSectorsA()) ? (getTPCzLength() - z) : (z + getTPCzLength());
   }
-}
 
-GPUdi() void TPCFastTransformGeoPOD::convLocalToPadDriftLength(uint32_t sector, uint32_t row, float y, float z, float& pad, float& l) const
-{
   /// convert Local c.s. -> Pad, DriftLength
-  float u;
-  if (sector < getNumberOfSectorsA()) { // TPC side A
-    u = y;
-    l = getTPCzLength() - z;
-  } else {                   // TPC side C
-    u = -y;                  // pads are mirrorred on C-side
-    l = z + getTPCzLength(); // drift direction is mirrored on C-side
+  inline static constexpr void convLocalToPadDriftLength(uint32_t sector, uint32_t row, float y, float z, float& pad, float& l)
+  {
+    /// convert Local c.s. -> Pad, DriftLength
+    float u = 0;
+    if (sector < getNumberOfSectorsA()) { // TPC side A
+      u = y;
+      l = getTPCzLength() - z;
+    } else {                   // TPC side C
+      u = -y;                  // pads are mirrorred on C-side
+      l = z + getTPCzLength(); // drift direction is mirrored on C-side
+    }
+    const float maxPad = getRowInfoMaxPad(row);
+    const float padWidth = getRowInfoPadWidth(row);
+    pad = u / padWidth + 0.5f * maxPad;
   }
-  const float maxPad = getRowInfoMaxPad(row);
-  const float padWidth = getRowInfoPadWidth(row);
-  pad = u / padWidth + 0.5f * maxPad;
-}
+};
 
 } // namespace o2::gpu
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index 747bb37787ff4..58635995a99c1 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -120,8 +120,6 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
 
   // copy fixed size data --- start
   podMap.mNumberOfScenarios = origCorr.mNumberOfScenarios;
-  std::memcpy((void*)&podMap.mGeo, (const void*)&origCorr.mGeo, sizeof(TPCFastTransformGeo)); // copy geometry (fixed size)
-  static_assert(sizeof(podMap.mGeo) == sizeof(origCorr.mGeo));
   for (int sector = 0; sector < TPCFastTransformGeo::getNumberOfSectors(); sector++) {
     for (int row = 0; row < NROWS; row++) {
       podMap.mSectorRowInfos[NROWS * sector + row] = origCorr.getSectorRowInfo(sector, row);

From d2e2c17b6ee4f59a5d0aa6ef9f66d3220706d868 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 11 Apr 2026 18:29:50 +0200
Subject: [PATCH 1616/1764] GPU: Add GPUCA_DETERMINISTIC_NO_FTC

---
 GPU/GPUTracking/Base/GPUReconstruction.cxx    | 20 ++++----
 .../GPUTPCCompressionKernels.cxx              |  2 +-
 GPU/GPUTracking/Definitions/GPUSettingsList.h |  2 +-
 .../Standalone/Benchmark/CMakeLists.txt       |  4 ++
 .../Standalone/Benchmark/standalone.cxx       |  9 +++-
 GPU/GPUTracking/Standalone/cmake/config.cmake | 47 ++++++++++---------
 GPU/GPUTracking/utils/qmaths_helpers.h        |  2 +-
 GPU/documentation/deterministic-mode.md       |  6 +++
 dependencies/FindO2GPU.cmake                  | 21 ++++++---
 9 files changed, 69 insertions(+), 44 deletions(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index 8eef9ad65ee49..b4cea1b9ccc6e 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -263,17 +263,17 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
   if (GetProcessingSettings().debugLevel > 0) {
     mProcessingSettings->recoTaskTiming = true;
   }
-  if (GetProcessingSettings().deterministicGPUReconstruction == -1) {
+  bool detMode = false;
 #ifdef GPUCA_DETERMINISTIC_MODE
-    mProcessingSettings->deterministicGPUReconstruction = 1;
-#else
-    mProcessingSettings->deterministicGPUReconstruction = GetProcessingSettings().debugLevel >= 6;
+  detMode = true;
 #endif
+  if (GetProcessingSettings().deterministicGPUReconstruction == -1) {
+    mProcessingSettings->deterministicGPUReconstruction = detMode ? 1 : (GetProcessingSettings().debugLevel >= 6);
   }
   if (GetProcessingSettings().deterministicGPUReconstruction) {
-#ifndef GPUCA_DETERMINISTIC_MODE
-    GPUError("WARNING, deterministicGPUReconstruction needs GPUCA_DETERMINISTIC_MODE for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
-#endif
+    if (!detMode) {
+      GPUError("WARNING, deterministicGPUReconstruction needs GPUCA_DETERMINISTIC_MODE for being fully deterministic, without only most indeterminism by concurrency is removed, but floating point effects remain!");
+    }
     if (mProcessingSettings->debugLevel >= 6 && ((mProcessingSettings->debugMask + 1) & mProcessingSettings->debugMask)) {
       GPUError("WARNING: debugMask %d - debug output might not be deterministic with intermediate steps missing", mProcessingSettings->debugMask);
     }
@@ -283,9 +283,9 @@ int32_t GPUReconstruction::InitPhaseBeforeDevice()
     }
     mProcessingSettings->rtc.deterministic = 1;
   } else {
-#ifdef GPUCA_DETERMINISTIC_MODE
-    GPUError("WARNING, compiled with GPUCA_DETERMINISTIC_MODE but deterministicGPUReconstruction not set, only compile-time determinism and deterministic math enforced, not fully deterministic!");
-#endif
+    if (detMode) {
+      GPUError("WARNING, compiled with GPUCA_DETERMINISTIC_MODE but deterministicGPUReconstruction not set, only compile-time determinism and deterministic math enforced, not fully deterministic!");
+    }
   }
   if (GetProcessingSettings().deterministicGPUReconstruction && GetProcessingSettings().debugLevel >= 6) {
     mProcessingSettings->nTPCClustererLanes = 1;
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
index 35f4e0d931c22..b98f5c28f57b0 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCCompressionKernels.cxx
@@ -271,7 +271,7 @@ GPUdii() void GPUTPCCompressionKernels::Thread<GPUTPCCompressionKernels::step1un
 #ifdef GPUCA_GPUCODE
         static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCompressionKernels_step1unattached) * 2 <= constants::TPC_COMP_CHUNK_SIZE);
 #endif
-#ifdef GPUCA_DETERMINISTIC_MODE // Not using GPUCA_DETERMINISTIC_CODE, which is enforced in TPC compression
+#ifdef GPUCA_DETERMINISTIC_MODE
         CAAlgo::sortInBlock(sortBuffer, sortBuffer + count, GPUTPCCompressionKernels_Compare<GPUSettings::SortZPadTime>(clusters->clusters[iSector][iRow]));
 #else  // GPUCA_DETERMINISTIC_MODE
         if (param.rec.tpc.compressionSortOrder == GPUSettings::SortZPadTime) {
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 20e445264797c..6c49d08f2b8e8 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -613,7 +613,7 @@ AddOption(inputcontrolmem, uint64_t, 0, "inputMemory", 0, "Use predefined input
 AddOption(cpuAffinity, int32_t, -1, "", 0, "Pin CPU affinity to this CPU core", min(-1))
 AddOption(fifoScheduler, bool, false, "", 0, "Use FIFO realtime scheduler", message("Setting FIFO scheduler: %s"))
 AddOption(fpe, int8_t, -1, "", 0, "Trap on floating point exceptions (-1 = if no ffast-math)")
-AddOption(flushDenormals, bool, true, "", 0, "Enable FTZ and DAZ (Flush all denormals to zero)")
+AddOption(flushDenormals, int8_t, -1, "", 0, "Enable FTZ and DAZ (Flush all denormals to zero), -1 = enable automatically if not prevented by deterministic mode")
 AddOption(solenoidBzNominalGPU, float, -1e6f, "", 0, "Field strength of solenoid Bz in kGaus")
 AddOption(constBz, bool, false, "", 0, "Force constand Bz")
 AddOption(overrideMaxTimebin, bool, false, "", 0, "Override max time bin setting for continuous data with max time bin in time frame")
diff --git a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
index 3e453b21b8104..c2cdfd08ee7a0 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
+++ b/GPU/GPUTracking/Standalone/Benchmark/CMakeLists.txt
@@ -35,6 +35,10 @@ install(DIRECTORY ../tools DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU)
 install(DIRECTORY ../../Definitions/Parameters/ DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/GPU/tools FILES_MATCHING REGEX "\\.(python|sh|cmake)")
 target_compile_definitions(${targetName} PRIVATE $<TARGET_PROPERTY:O2::GPUTracking,COMPILE_DEFINITIONS>)
 
+if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_NO_FAST_MATH} AND GPUCA_DETERMINISTIC_NO_FTZ)
+target_compile_definitions(${targetName} PRIVATE GPUCA_DETERMINISTIC_NO_FTZ)
+endif()
+
 if(ROOT_FOUND)
   target_sources(${targetName} PRIVATE ../../qa/genEvents.cxx)
 endif()
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index 114889fddca33..d54b883ee7983 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -141,7 +141,14 @@ int32_t ReadConfiguration(int argc, char** argv)
 #endif
     feenableexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW);
   }
-  if (configStandalone.flushDenormals) {
+  bool detMode = false, noFTZMode = false;
+#ifdef GPUCA_DETERMINISTIC_MODE
+  detMode = true;
+#endif
+#ifdef GPUCA_DETERMINISTIC_NO_FTZ
+  noFTZMode = true;
+#endif
+  if (configStandalone.flushDenormals >= 1 || (configStandalone.flushDenormals == -1 && (configStandalone.proc.deterministicGPUReconstruction >= 1 || (configStandalone.proc.deterministicGPUReconstruction == -1 && detMode)) && !noFTZMode)) {
     disable_denormals();
   }
 
diff --git a/GPU/GPUTracking/Standalone/cmake/config.cmake b/GPU/GPUTracking/Standalone/cmake/config.cmake
index 9355311db617c..5a899945dac0a 100644
--- a/GPU/GPUTracking/Standalone/cmake/config.cmake
+++ b/GPU/GPUTracking/Standalone/cmake/config.cmake
@@ -19,26 +19,27 @@ set(GPUCA_CONFIG_VC 1)
 set(GPUCA_CONFIG_FMT 1)
 set(GPUCA_CONFIG_ROOT 1)
 set(GPUCA_CONFIG_ONNX 0)
-set(GPUCA_BUILD_EVENT_DISPLAY 1)
-set(GPUCA_BUILD_EVENT_DISPLAY_FREETYPE 1)
-set(GPUCA_BUILD_EVENT_DISPLAY_VULKAN 1)
-set(GPUCA_BUILD_EVENT_DISPLAY_WAYLAND 1)
-set(GPUCA_BUILD_EVENT_DISPLAY_QT 1)
-set(GPUCA_CONFIG_GL3W 0)
-set(GPUCA_CONFIG_O2 1)
-set(GPUCA_BUILD_DEBUG 0)
-set(GPUCA_BUILD_DEBUG_SANITIZE 0)
-set(GPUCA_BUILD_DEBUG_HOSTONLY 0)
-set(GPUCA_DETERMINISTIC_MODE 0)             # OFF / NO_FAST_MATH / OPTO2 / GPU / WHOLEO2
-#set(GPUCA_CUDA_GCCBIN c++-14)
-#set(GPUCA_OPENCL_CLANGBIN clang-20)
-set(HIP_AMDGPUTARGET "default")             # "gfx906;gfx908;gfx90a"
-set(CUDA_COMPUTETARGET "default")           # 86 89
-#set(GPUCA_CUDA_COMPILE_MODE perkernel)     # onefile / perkernel / rtc
-#set(GPUCA_HIP_COMPILE_MODE perkernel)
-#set(GPUCA_RTC_NO_COMPILED_KERNELS 1)
-#set(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE 1)
-#set(GPUCA_CONFIG_COMPILER gcc)             # gcc / clang
-#set(GPUCA_CONFIG_WERROR 1)
-#add_definitions(-DGPUCA_GPU_DEBUG_PRINT)
-#set(GPUCA_OVERRIDE_PARAMETER_FILE "foo.csv")
+set(GPUCA_BUILD_EVENT_DISPLAY 1)              # Enable compilation of event display
+set(GPUCA_BUILD_EVENT_DISPLAY_FREETYPE 1)     # Use FreeType library to render fonts for event display
+set(GPUCA_BUILD_EVENT_DISPLAY_VULKAN 1)       # Enable Vulkan backend for event display (otherwise only OpenGL / Win32)
+set(GPUCA_BUILD_EVENT_DISPLAY_WAYLAND 1)      # Enable native wayland frontend for event display
+set(GPUCA_BUILD_EVENT_DISPLAY_QT 1)           # Use QT for Event Display GUI
+set(GPUCA_CONFIG_GL3W 0)                      # Use GL3W instead of glew
+set(GPUCA_CONFIG_O2 1)                        # Compile for O2 data, 0 for Run 2 data
+set(GPUCA_BUILD_DEBUG 0)                      # Enable debug mode (-O0, -ggdb, enable asserts)
+set(GPUCA_BUILD_DEBUG_SANITIZE 0)             # Enable undefined behavior and address sanitizers
+set(GPUCA_BUILD_DEBUG_HOSTONLY 0)             # Only compile host code in debug mode, GPU code compiled normally
+set(GPUCA_DETERMINISTIC_MODE 0)               # OFF / NO_FAST_MATH / OPTO2 / GPU / WHOLEO2
+set(GPUCA_DETERMINISTIC_NO_FTZ 0)             # If 1 and deterministic mode active, do not apply flush denormals to zero
+#set(GPUCA_CUDA_GCCBIN c++-14)                # Override which GCC to use for CUDA
+#set(GPUCA_OPENCL_CLANGBIN clang-20)          # Override which clang to use for OpenCL
+set(HIP_AMDGPUTARGET "default")               # Set AMD GPU tragets to compile for: e.g. "gfx906;gfx908;gfx90a"
+set(CUDA_COMPUTETARGET "default")             # Set NVIDIA GPU targets to compile for: e.g. "89;120"
+#set(GPUCA_CUDA_COMPILE_MODE perkernel)       # Mode to compile kernels for CUDA: onefile / perkernel / rtc
+#set(GPUCA_HIP_COMPILE_MODE perkernel)        # Mode to compile kernels for HIP:  onefile / perkernel / rtc
+#set(GPUCA_RTC_NO_COMPILED_KERNELS 1)         # Do not compile "perkernel" kernels at compile time, support only RTC
+#set(GPUCA_KERNEL_RESOURCE_USAGE_VERBOSE 1)   # Verbose resource usage output during kernel compilation
+#set(GPUCA_CONFIG_COMPILER gcc)               # Compiler to use for standalone compilation: gcc / clang
+#set(GPUCA_CONFIG_WERROR 1)                   # Enforce Werror
+#add_definitions(-DGPUCA_GPU_DEBUG_PRINT)     # Enable LOG(...) macros and GPUInfo(...) etc. in GPU code
+#set(GPUCA_OVERRIDE_PARAMETER_FILE "foo.csv") # Override the CSV or JSON file that contains GPU parameters
diff --git a/GPU/GPUTracking/utils/qmaths_helpers.h b/GPU/GPUTracking/utils/qmaths_helpers.h
index 5eb3ce4fb2483..a6dbacdbd77a7 100644
--- a/GPU/GPUTracking/utils/qmaths_helpers.h
+++ b/GPU/GPUTracking/utils/qmaths_helpers.h
@@ -26,7 +26,7 @@
 
 static void disable_denormals()
 {
-#if !(defined(__ARM_NEON) || defined(__aarch64__)) && __has_include(<xmmintrin.h>) // clang-format off
+#if !(defined(__ARM_NEON) || defined(__aarch64__)) && __has_include(<xmmintrin.h>)
   #if defined(_MM_FLUSH_ZERO_OFF) && defined(_MM_DENORMALS_ZERO_ON)
     _MM_SET_FLUSH_ZERO_MODE(_MM_FLUSH_ZERO_ON);
     _MM_SET_DENORMALS_ZERO_MODE(_MM_DENORMALS_ZERO_ON);
diff --git a/GPU/documentation/deterministic-mode.md b/GPU/documentation/deterministic-mode.md
index 53f8a1eb27711..4a9647a4d3bc1 100644
--- a/GPU/documentation/deterministic-mode.md
+++ b/GPU/documentation/deterministic-mode.md
@@ -30,3 +30,9 @@ Beyond comparing only the number of clusters and number of tracks, it is also po
 It will create a dump container all (most) intermediate results in text form, which can be compared. The output files is called `CPU.out` if using the CPU backend, and `GPU.out` for the GPU backend.
 Note that the dump files will be huge and the processing will be slow and consume much more memory than normal with `--debug 6 . It has been tested with datasets containing up to 50 Pb-Pb collisions, and might fail for larger data.
 The dump files (if the deterministic mode is used with both compile- and runtime-activation), the files should be 100% identical and can just be compared with `diff`.
+
+By default, the deterministic mode will apply flush-to-zero and denormals-are-zero to denormal floats.
+This can be disabled bia `-DDGPUCA_DETERMINISTIC_MODE`.
+Note that some GPUs cannot do precise float computation with denormals flushed to zero, while other GPUs do not support denormals at all.
+Thus, comparison between CPU and GPU deterministic results might require that this setting is either set or not set.
+CPU results for the 2 cases will always differ, since the floating point math will be slightly different.
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index ad9cc11d56b40..7ff05a79feb8b 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 14
+# FindO2GPU.cmake Version 15
 
 set(CUDA_COMPUTETARGET_DEFAULT_FULL 80-real 86-real 89-real 120-real 75-virtual)
 set(HIP_AMDGPUTARGET_DEFAULT_FULL gfx906;gfx908)
@@ -137,16 +137,23 @@ elseif(NOT GPUCA_DETERMINISTIC_MODE MATCHES "^[0-9]+$")
   endif()
   set(GPUCA_DETERMINISTIC_MODE ${GPUCA_DETERMINISTIC_MODE_MAP_${GPUCA_DETERMINISTIC_MODE}})
 endif()
-if (CMAKE_SYSTEM_NAME MATCHES Darwin OR NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
+if(GPUCA_DETERMINISTIC_NO_FTZ)
   set(GPUCA_CXX_DENORMALS_FLAGS "")
+  set(GPUCA_CUDA_DENORMALS_FLAGS "--ftz=false")
+  set(GPUCA_OCL_DENORMALS_FLAGS "")
+  set(GPUCA_HIP_DENORMALS_FLAGS "-fno-gpu-flush-denormals-to-zero")
 else()
-  set(GPUCA_CXX_DENORMALS_FLAGS "-mdaz-ftz")
+  if (CMAKE_SYSTEM_NAME MATCHES Darwin OR NOT CMAKE_SYSTEM_PROCESSOR MATCHES "(x86)|(X86)|(amd64)|(AMD64)")
+    set(GPUCA_CXX_DENORMALS_FLAGS "")
+  else()
+    set(GPUCA_CXX_DENORMALS_FLAGS "-mdaz-ftz")
+  endif()
+  set(GPUCA_CUDA_DENORMALS_FLAGS "--ftz=true")
+  set(GPUCA_OCL_DENORMALS_FLAGS "-cl-denorms-are-zero")
+  set(GPUCA_HIP_DENORMALS_FLAGS "-fgpu-flush-denormals-to-zero")
 endif()
-set(GPUCA_CUDA_DENORMALS_FLAGS "--ftz=true")
-set(GPUCA_OCL_DENORMALS_FLAGS "-cl-denorms-are-zero")
-set(GPUCA_HIP_DENORMALS_FLAGS "-fgpu-flush-denormals-to-zero")
 set(GPUCA_CXX_NO_FAST_MATH_FLAGS "-fno-fast-math -ffp-contract=off")
-set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--prec-div=true --prec-sqrt=true --fmad false")
+set(GPUCA_CUDA_NO_FAST_MATH_FLAGS "--prec-div=true --prec-sqrt=true --fmad false -Xcompiler -fno-fast-math -Xcompiler -ffp-contract=off")
 set(GPUCA_OCL_NO_FAST_MATH_FLAGS -cl-fp32-correctly-rounded-divide-sqrt )
 if(GPUCA_DETERMINISTIC_MODE GREATER_EQUAL ${GPUCA_DETERMINISTIC_MODE_MAP_WHOLEO2})
   add_definitions(-DGPUCA_DETERMINISTIC_MODE)

From 50eed64a5f57f3d08f9510ef5a6b4e312e5de507 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 11 Apr 2026 19:08:02 +0200
Subject: [PATCH 1617/1764] GPU: GPULooger should suppress messages below info
 level in standalone benchmark

---
 GPU/Common/GPUCommonLogger.h | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/GPU/Common/GPUCommonLogger.h b/GPU/Common/GPUCommonLogger.h
index 296cf9c562088..d07c672a1eda9 100644
--- a/GPU/Common/GPUCommonLogger.h
+++ b/GPU/Common/GPUCommonLogger.h
@@ -37,9 +37,18 @@ void LOGP_internal(const char* str, Args... args)
   printf("%s\n", str);
 }
 #endif
+enum class loglevel : int32_t {
+  debug = 0,
+  info = 1,
+  warning = 2,
+  important = 3,
+  alarm = 4,
+  error = 5,
+  fatal = 6
+};
 } // namespace o2::gpu::internal
 
-#ifdef GPUCA_GPUCODE_DEVICE
+#ifdef GPUCA_GPUCODE_DEVICE // clang-format off
 // ---------- begin GPUCA_GPUCODE_DEVICE ----------
 
 #if defined(__OPENCL__) || !defined(GPUCA_GPU_DEBUG_PRINT)
@@ -50,10 +59,7 @@ void LOGP_internal(const char* str, Args... args)
 #else
 #define LOG(...) o2::gpu::internal::DummyLogger()
 // #define LOG(...) static_assert(false, "LOG(...) << ... unsupported in GPU code");
-#define LOGF(type, string, ...)         \
-  {                                     \
-    printf(string "\n", ##__VA_ARGS__); \
-  }
+#define LOGF(type, string, ...) do { if (o2::gpu::internal::loglevel::type >= o2::gpu::internal::loglevel::info) { printf(string "\n", ##__VA_ARGS__); }} while (false);
 #define LOGP(...)
 // #define LOGP(...) static_assert(false, "LOGP(...) unsupported in GPU code");
 #endif
@@ -65,11 +71,11 @@ void LOGP_internal(const char* str, Args... args)
 #include <iostream>
 #include <cstdio>
 #define LOG(type) std::cout
-#define LOGF(type, string, ...) printf(string "\n", ##__VA_ARGS__);
+#define LOGF(type, string, ...) do { if (o2::gpu::internal::loglevel::type >= o2::gpu::internal::loglevel::info) { printf(string "\n", ##__VA_ARGS__); }} while (false);
 #if !defined(GPUCA_NO_FMT) && !defined(GPUCA_GPUCODE)
-#define LOGP(type, string, ...) fmt::print(string, ##__VA_ARGS__)
+#define LOGP(type, string, ...) do { if (o2::gpu::internal::loglevel::type >= o2::gpu::internal::loglevel::info) { fmt::print(string, ##__VA_ARGS__); printf("\n"); }} while (false);
 #else
-#define LOGP(type, string, ...) o2::gpu::internal::LOGP_internal(string, ##__VA_ARGS__)
+#define LOGP(type, string, ...) do { if (o2::gpu::internal::loglevel::type >= o2::gpu::internal::loglevel::info) { o2::gpu::internal::LOGP_internal(string, ##__VA_ARGS__); }} while (false);
 #endif
 #if defined(GPUCA_STANDALONE) && !defined(GPUCA_GPUCODE)
 #if !defined(GPUCA_NO_FMT)
@@ -89,6 +95,6 @@ static const char* format(Args... args)
 // ---------- end GPUCA_STANDALONE / COMPILEKERNELS ----------
 #else
 #include <Framework/Logger.h>
-#endif
+#endif // clang-format on
 
 #endif

From adc418b1a881a3d8f0a18103dd1b1f9c92577ee4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sat, 11 Apr 2026 19:08:27 +0200
Subject: [PATCH 1618/1764] GPU: Write floats in hex format to debug dump when
 in deterministic mode

---
 GPU/GPUTracking/Definitions/GPUSettingsList.h | 1 +
 GPU/GPUTracking/Global/GPUChainTracking.cxx   | 3 +++
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx | 6 +++---
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 6c49d08f2b8e8..239e63a3fafac 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -329,6 +329,7 @@ AddOption(debugLevel, int32_t, -1, "debug", 'd', "Set debug level (-2 = silent,
 AddOption(allocDebugLevel, int32_t, 0, "allocDebug", 0, "Some debug output for memory allocations (without messing with normal debug level)")
 AddOption(debugMask, uint32_t, (1 << 18) - 1, "debugMask", 0, "Mask for debug output dumps to file")
 AddOption(debugLogSuffix, std::string, "", "debugSuffix", 0, "Suffix for debug log files with --debug 6")
+AddOption(debugFileHexFloat, int32_t, -1, "", 0, "Use hex format to print floats to debug dump file")
 AddOption(debugCSV, std::string, "", "", 0, "CSV filename to append the benchmark results. Verbosity determined by parameter --debug.")
 AddOption(debugMarkdown, bool, false, "", 0, "Print the results of standlaone benchmarks in markdown format")
 AddOption(serializeGPU, int8_t, 0, "", 0, "Synchronize after each kernel call (bit 1) and DMA transfer (bit 2) and identify failures")
diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index b9822692a65cf..5c74d9e949269 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -383,6 +383,9 @@ int32_t GPUChainTracking::Init()
   if (GetProcessingSettings().debugLevel >= 6) {
     std::string filename = std::string(mRec->IsGPU() ? "GPU" : "CPU") + (mRec->slaveId() != -1 ? (std::string("_slave") + std::to_string(mRec->slaveId())) : std::string(mRec->slavesExist() ? "_master" : "")) + GetProcessingSettings().debugLogSuffix + ".out";
     mDebugFile->open(filename.c_str());
+    if (GetProcessingSettings().debugFileHexFloat >= 1 || (GetProcessingSettings().debugFileHexFloat == -1 && GetProcessingSettings().deterministicGPUReconstruction)) {
+      *mDebugFile << std::hexfloat;
+    }
   }
 
   return 0;
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 8b9baac4f54b0..6569ff77566f3 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -43,7 +43,7 @@ using namespace gputpcgmmergertypes;
 void GPUTPCGMMerger::DumpSectorTracks(std::ostream& out) const
 {
   std::streamsize ss = out.precision();
-  out << std::setprecision(10);
+  out << std::setprecision(6);
   out << "\nTPC Merger Sector Tracks\n";
   for (int32_t iSector = 0; iSector < NSECTORS; iSector++) {
     out << "Sector Track Info Sector " << iSector << " Index " << (mSectorTrackInfoIndex[iSector + 1] - mSectorTrackInfoIndex[iSector]) << " / " << (mSectorTrackInfoIndex[NSECTORS + iSector + 1] - mSectorTrackInfoIndex[NSECTORS + iSector]) << "\n";
@@ -141,7 +141,7 @@ void GPUTPCGMMerger::DumpCollected(std::ostream& out) const
 void GPUTPCGMMerger::DumpTrackParam(std::ostream& out) const
 {
   std::streamsize ss = out.precision();
-  out << std::setprecision(10);
+  out << std::setprecision(6);
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mMergedTracks[i];
     const auto& p = trk.GetParam();
@@ -206,7 +206,7 @@ void GPUTPCGMMerger::DumpFitPrepare(std::ostream& out) const
 void GPUTPCGMMerger::DumpRefit(std::ostream& out) const
 {
   std::streamsize ss = out.precision();
-  out << std::setprecision(10);
+  out << std::setprecision(6);
   out << "\nTPC Merger Refit\n";
   for (uint32_t i = 0; i < mMemory->nMergedTracks; i++) {
     const auto& trk = mMergedTracks[i];

From 8bf6eb2aa825bc1112a27134ac2dcc6cae1aa5a4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 12 Apr 2026 11:17:37 +0200
Subject: [PATCH 1619/1764] GPU: Restructure parameters for TPC track merging,
 simplifying and working around an NVIDIA compiler bug for blackwell

---
 GPU/GPUTracking/Global/GPUChainTracking.h     |  2 +-
 .../Global/GPUChainTrackingMerger.cxx         | 38 ++++++++-------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx     | 48 ++++++++-----------
 GPU/GPUTracking/Merger/GPUTPCGMMerger.h       | 21 +++++---
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx | 22 ++++-----
 GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx  |  8 ++--
 GPU/GPUTracking/kernels.cmake                 |  6 +--
 7 files changed, 75 insertions(+), 70 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.h b/GPU/GPUTracking/Global/GPUChainTracking.h
index 5ece80eec1841..9913762ae34df 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.h
+++ b/GPU/GPUTracking/Global/GPUChainTracking.h
@@ -306,7 +306,7 @@ class GPUChainTracking : public GPUChain
   std::pair<uint32_t, uint32_t> TPCClusterizerDecodeZSCountUpdate(uint32_t iSector, const CfFragment& fragment);
   void TPCClusterizerEnsureZSOffsets(uint32_t iSector, const CfFragment& fragment);
 #endif
-  void RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSector, int8_t mergeMode, GPUReconstruction::krnlDeviceType deviceType);
+  void RunTPCTrackingMerger_MergeBorderTracks(uint8_t mergeMode, GPUReconstruction::krnlDeviceType deviceType);
   void RunTPCTrackingMerger_Resolve(int8_t useOrigTrackParam, int8_t mergeAll, GPUReconstruction::krnlDeviceType deviceType);
   void RunTPCClusterFilter(o2::tpc::ClusterNativeAccess* clusters, std::function<o2::tpc::ClusterNative*(size_t)> allocator, bool applyClusterCuts);
   bool NeedTPCClustersOnGPU();
diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index 03c7904234f89..aa29e884f3f6d 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -28,22 +28,22 @@
 
 using namespace o2::gpu;
 
-void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSector, int8_t mergeMode, GPUReconstruction::krnlDeviceType deviceType)
+void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(uint8_t mergeMode, GPUReconstruction::krnlDeviceType deviceType)
 {
   GPUTPCGMMerger& Merger = processors()->tpcMerger;
   bool doGPU = GetRecoStepsGPU() & RecoStep::TPCMerging;
   GPUTPCGMMerger& MergerShadow = doGPU ? processorsShadow()->tpcMerger : Merger;
   if (GetProcessingSettings().deterministicGPUReconstruction) {
-    uint32_t nBorderTracks = withinSector == 1 ? NSECTORS : (2 * NSECTORS);
+    uint32_t nBorderTracks = (mergeMode & GPUTPCGMMerger::mergeModes::mergeWithinSector) ? NSECTORS : (2 * NSECTORS);
     runKernel<GPUTPCGlobalDebugSortKernels, GPUTPCGlobalDebugSortKernels::borderTracks>({{nBorderTracks, -WarpSize(), 0, deviceType}}, 0);
   }
-  uint32_t n = withinSector == -1 ? NSECTORS / 2 : NSECTORS;
+  uint32_t n = (mergeMode & GPUTPCGMMerger::mergeModes::mergeAcrossCE) ? NSECTORS / 2 : NSECTORS;
   if (GetProcessingSettings().alternateBorderSort == -1 ? mRec->getGPUParameters(doGPU).par_ALTERNATE_BORDER_SORT : GetProcessingSettings().alternateBorderSort) {
     RecordMarker(&mEvents->single, 0);
     TransferMemoryResourceLinkToHost(RecoStep::TPCMerging, Merger.MemoryResMemory(), 0, &mEvents->init);
     for (uint32_t i = 0; i < n; i++) {
       int32_t stream = i % mRec->NStreams();
-      runKernel<GPUTPCGMMergerMergeBorders, 0>({GetGridAuto(stream, deviceType), krnlRunRangeNone, {nullptr, stream && i < (uint32_t)mRec->NStreams() ? &mEvents->single : nullptr}}, i, withinSector, mergeMode);
+      runKernel<GPUTPCGMMergerMergeBorders, 0>({GetGridAuto(stream, deviceType), krnlRunRangeNone, {nullptr, stream && i < (uint32_t)mRec->NStreams() ? &mEvents->single : nullptr}}, i, mergeMode);
     }
     ReleaseEvent(mEvents->single);
     SynchronizeEventAndRelease(mEvents->init);
@@ -52,12 +52,12 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSecto
       int32_t n1, n2;
       GPUTPCGMBorderTrack *b1, *b2;
       int32_t jSector;
-      Merger.MergeBorderTracksSetup(n1, n2, b1, b2, jSector, i, withinSector, mergeMode);
+      Merger.MergeBorderTracksSetup(n1, n2, b1, b2, jSector, i, mergeMode);
       gputpcgmmergertypes::GPUTPCGMBorderRange* range1 = MergerShadow.BorderRange(i);
       gputpcgmmergertypes::GPUTPCGMBorderRange* range2 = MergerShadow.BorderRange(jSector) + *processors()->tpcTrackers[jSector].NTracks();
       runKernel<GPUTPCGMMergerMergeBorders, 3>({{1, -WarpSize(), stream, deviceType}}, range1, n1, 0);
       runKernel<GPUTPCGMMergerMergeBorders, 3>({{1, -WarpSize(), stream, deviceType}}, range2, n2, 1);
-      runKernel<GPUTPCGMMergerMergeBorders, 2>({GetGridAuto(stream, deviceType)}, i, withinSector, mergeMode);
+      runKernel<GPUTPCGMMergerMergeBorders, 2>({GetGridAuto(stream, deviceType)}, i, mergeMode);
     }
     int32_t ne = std::min<int32_t>(n, mRec->NStreams()) - 1; // Stream 0 must wait for all streams, Note n > 1
     for (int32_t j = 0; j < ne; j++) {
@@ -66,14 +66,14 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(int8_t withinSecto
     StreamWaitForEvents(0, &mEvents->sector[0], ne);
   } else {
     for (uint32_t i = 0; i < n; i++) {
-      runKernel<GPUTPCGMMergerMergeBorders, 0>(GetGridAuto(0, deviceType), i, withinSector, mergeMode);
+      runKernel<GPUTPCGMMergerMergeBorders, 0>(GetGridAuto(0, deviceType), i, mergeMode);
     }
-    runKernel<GPUTPCGMMergerMergeBorders, 1>({{2 * n, -WarpSize(), 0, deviceType}}, 0, withinSector, mergeMode);
+    runKernel<GPUTPCGMMergerMergeBorders, 1>({{2 * n, -WarpSize(), 0, deviceType}}, 0, mergeMode);
     for (uint32_t i = 0; i < n; i++) {
-      runKernel<GPUTPCGMMergerMergeBorders, 2>(GetGridAuto(0, deviceType), i, withinSector, mergeMode);
+      runKernel<GPUTPCGMMergerMergeBorders, 2>(GetGridAuto(0, deviceType), i, mergeMode);
     }
   }
-  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRanges, doGPU, Merger, &GPUTPCGMMerger::DumpMergeRanges, *mDebugFile, withinSector, mergeMode);
+  DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingRanges, doGPU, Merger, &GPUTPCGMMerger::DumpMergeRanges, *mDebugFile, mergeMode);
   mRec->ReturnVolatileDeviceMemory();
 }
 
@@ -138,25 +138,29 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
   }
   DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingSectorTracks, doGPU, Merger, &GPUTPCGMMerger::DumpSectorTracks, *mDebugFile);
 
+  // Merge within Sectors
   runKernel<GPUTPCGMMergerClearLinks>(GetGridAuto(0, deviceType), false);
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
   runKernel<GPUTPCGMMergerMergeWithinPrepare>(GetGridAuto(0, deviceType));
-  RunTPCTrackingMerger_MergeBorderTracks(1, 0, deviceType);
+  RunTPCTrackingMerger_MergeBorderTracks(GPUTPCGMMerger::mergeModes::mergeWithinSector, deviceType);
   RunTPCTrackingMerger_Resolve(0, 1, deviceType);
   DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingMatching, doGPU, Merger, &GPUTPCGMMerger::DumpMergedWithinSectors, *mDebugFile);
 
+  // Merge between sectors - transport to the middle of the sector and rotate vertically to the border on the left / right
   runKernel<GPUTPCGMMergerClearLinks>(GetGridAuto(0, deviceType), false);
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), 2 * NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
   runKernel<GPUTPCGMMergerMergeSectorsPrepare>(GetGridBlk(std::max(2u, numBlocks), 0, deviceType), 2, 3, 0);
-  RunTPCTrackingMerger_MergeBorderTracks(0, 0, deviceType);
+  RunTPCTrackingMerger_MergeBorderTracks(GPUTPCGMMerger::mergeModes::mergeBetweenSector | GPUTPCGMMerger::mergeModes::mergeAtMidRow, deviceType);
   RunTPCTrackingMerger_Resolve(0, 1, deviceType);
+  // Merge between sectors - transport to the left / right edge of the sector and rotate horizontally
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), 2 * NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
   runKernel<GPUTPCGMMergerMergeSectorsPrepare>(GetGridBlk(std::max(2u, numBlocks), 0, deviceType), 0, 1, 0);
-  RunTPCTrackingMerger_MergeBorderTracks(0, 0, deviceType);
+  RunTPCTrackingMerger_MergeBorderTracks(GPUTPCGMMerger::mergeModes::mergeBetweenSector, deviceType);
   RunTPCTrackingMerger_Resolve(0, 1, deviceType);
+  // Merge between sectors - use original track param
   runKernel<GPUMemClean16>({{1, -WarpSize(), 0, deviceType, RecoStep::TPCMerging}}, MergerShadowAll.TmpCounter(), 2 * NSECTORS * sizeof(*MergerShadowAll.TmpCounter()));
   runKernel<GPUTPCGMMergerMergeSectorsPrepare>(GetGridBlk(std::max(2u, numBlocks), 0, deviceType), 0, 1, 1);
-  RunTPCTrackingMerger_MergeBorderTracks(0, -1, deviceType);
+  RunTPCTrackingMerger_MergeBorderTracks(GPUTPCGMMerger::mergeModes::mergeBetweenSector | GPUTPCGMMerger::mergeModes::mergeWithOriginalParameters, deviceType);
   RunTPCTrackingMerger_Resolve(0, 1, deviceType);
   DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingMatching, doGPU, Merger, &GPUTPCGMMerger::DumpMergedBetweenSectors, *mDebugFile);
 
@@ -175,8 +179,10 @@ int32_t GPUChainTracking::RunTPCTrackingMerger(bool synchronizeOutput)
 
   if (param().rec.tpc.mergeCE) {
     runKernel<GPUTPCGMMergerClearLinks>(GetGridAuto(0, deviceType), true);
-    RunTPCTrackingMerger_MergeBorderTracks(-1, 1, deviceType);
-    RunTPCTrackingMerger_MergeBorderTracks(-1, 2, deviceType);
+    // Merge across CE - compare at row 63
+    RunTPCTrackingMerger_MergeBorderTracks(GPUTPCGMMerger::mergeModes::mergeAcrossCE, deviceType);
+    // Merge across CE - compare at row of cluster
+    RunTPCTrackingMerger_MergeBorderTracks(GPUTPCGMMerger::mergeModes::mergeAcrossCE | GPUTPCGMMerger::mergeModes::mergeAtCluster, deviceType);
     runKernel<GPUTPCGMMergerMergeCE>(GetGridAuto(0, deviceType));
     DoDebugAndDump(RecoStep::TPCMerging, GPUChainTrackingDebugFlags::TPCMergingCE, doGPU, Merger, &GPUTPCGMMerger::DumpMergeCE, *mDebugFile);
   }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index b9b9a14b82b98..4b0b6f583bbf6 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -780,12 +780,11 @@ GPUd() void GPUTPCGMMerger::MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nT
 }
 
 template <>
-GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
+GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, uint8_t mergeMode)
 {
   CADEBUG(GPUInfo("\nMERGING Sectors %d %d NTracks %d %d CROSS %d", iSector1, iSector2, N1, N2, mergeMode));
   GPUTPCGMBorderRange* range1 = mBorderRange[iSector1];
   GPUTPCGMBorderRange* range2 = mBorderRange[iSector2] + *GetConstantMem()->tpcTrackers[iSector2].NTracks();
-  bool sameSector = (iSector1 == iSector2);
   for (int32_t itr = iBlock * nThreads + iThread; itr < N1; itr += nThreads * nBlocks) {
     const GPUTPCGMBorderTrack& b = B1[itr];
     float d = CAMath::Max(0.5f, 3.5f * CAMath::Sqrt(b.Cov()[1]));
@@ -795,16 +794,13 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThrea
       d = 3;
     }
     CADEBUG(printf("  Input Sector 1 %d Track %d: ", iSector1, itr); for (int32_t i = 0; i < 5; i++) { printf("%8.3f ", b.Par()[i]); } printf(" - "); for (int32_t i = 0; i < 5; i++) { printf("%8.3f ", b.Cov()[i]); } printf(" - D %8.3f\n", d));
-    GPUTPCGMBorderRange range;
-    range.fId = itr;
-    range.fMin = b.Par()[1] + b.ZOffsetLinear() - d;
-    range.fMax = b.Par()[1] + b.ZOffsetLinear() + d;
+    const GPUTPCGMBorderRange range = {.fId = itr, .fMin = b.Par()[1] + b.ZOffsetLinear() - d, .fMax = b.Par()[1] + b.ZOffsetLinear() + d};
     range1[itr] = range;
-    if (sameSector) {
+    if (iSector1 == iSector2) {
       range2[itr] = range;
     }
   }
-  if (!sameSector) {
+  if (iSector1 != iSector2) {
     for (int32_t itr = iBlock * nThreads + iThread; itr < N2; itr += nThreads * nBlocks) {
       const GPUTPCGMBorderTrack& b = B2[itr];
       float d = CAMath::Max(0.5f, 3.5f * CAMath::Sqrt(b.Cov()[1]));
@@ -814,17 +810,13 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThrea
         d = 3;
       }
       CADEBUG(printf("  Input Sector 2 %d Track %d: ", iSector2, itr); for (int32_t i = 0; i < 5; i++) { printf("%8.3f ", b.Par()[i]); } printf(" - "); for (int32_t i = 0; i < 5; i++) { printf("%8.3f ", b.Cov()[i]); } printf(" - D %8.3f\n", d));
-      GPUTPCGMBorderRange range;
-      range.fId = itr;
-      range.fMin = b.Par()[1] + b.ZOffsetLinear() - d;
-      range.fMax = b.Par()[1] + b.ZOffsetLinear() + d;
-      range2[itr] = range;
+      range2[itr] = {.fId = itr, .fMin = b.Par()[1] + b.ZOffsetLinear() - d, .fMax = b.Par()[1] + b.ZOffsetLinear() + d};
     }
   }
 }
 
 template <>
-GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
+GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, uint8_t mergeMode)
 {
 #if !defined(GPUCA_GPUCODE_COMPILEKERNELS)
   GPUTPCGMBorderRange* range1 = mBorderRange[iSector1];
@@ -857,7 +849,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<3>(int32_t nBlocks, int32_t nThrea
 }
 
 template <>
-GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode)
+GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, uint8_t mergeMode)
 {
   // int32_t statAll = 0, statMerged = 0;
   float factor2ys = Param().rec.tpc.trackMergerFactor2YS;
@@ -913,9 +905,9 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThrea
         if (b2.NClusters() < lBest2) {
           CADEBUG2(continue, printf("!NCl1\n"));
         }
-        if (mergeMode > 0) {
+        if (mergeMode & mergeModes::mergeAcrossCE) {
           // Merging CE tracks
-          int32_t maxRowDiff = mergeMode == 2 ? 1 : 3; // TODO: check cut
+          int32_t maxRowDiff = (mergeMode & mergeModes::mergeAtCluster) ? 1 : 3; // TODO: check cut
           if (CAMath::Abs(b1.Row() - b2.Row()) > maxRowDiff) {
             CADEBUG2(continue, printf("!ROW\n"));
           }
@@ -965,22 +957,22 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThrea
     CADEBUG(GPUInfo("Found match %d %d", b1.TrackID(), iBest2));
 
     mTrackLinks[b1.TrackID()] = iBest2;
-    if (mergeMode > 0) {
+    if (mergeMode & mergeModes::mergeAcrossCE) {
       GPUCA_DETERMINISTIC_CODE(CAMath::AtomicMax(&mTrackLinks[iBest2], b1.TrackID()), mTrackLinks[iBest2] = b1.TrackID());
     }
   }
   // GPUInfo("STAT: sectors %d, %d: all %d merged %d", iSector1, iSector2, statAll, statMerged);
 }
 
-GPUdii() void GPUTPCGMMerger::MergeBorderTracksSetup(int32_t& n1, int32_t& n2, GPUTPCGMBorderTrack*& b1, GPUTPCGMBorderTrack*& b2, int32_t& jSector, int32_t iSector, int8_t withinSector, int8_t mergeMode) const
+GPUdii() void GPUTPCGMMerger::MergeBorderTracksSetup(int32_t& n1, int32_t& n2, GPUTPCGMBorderTrack*& b1, GPUTPCGMBorderTrack*& b2, int32_t& jSector, int32_t iSector, uint8_t mergeMode) const
 {
-  if (withinSector == 1) { // Merge tracks within the same sector
+  if (mergeMode & mergeModes::mergeWithinSector) { // Merge tracks within the same sector
     jSector = iSector;
     n1 = n2 = mMemory->tmpCounter[iSector];
     b1 = b2 = mBorder[iSector];
-  } else if (withinSector == -1) { // Merge tracks accross the central electrode
+  } else if (mergeMode & mergeModes::mergeAcrossCE) { // Merge tracks accross the central electrode
     jSector = (iSector + NSECTORS / 2);
-    const int32_t offset = mergeMode == 2 ? NSECTORS : 0;
+    const int32_t offset = (mergeMode & mergeModes::mergeAtCluster) ? NSECTORS : 0;
     n1 = mMemory->tmpCounter[iSector + offset];
     n2 = mMemory->tmpCounter[jSector + offset];
     b1 = mBorder[iSector + offset];
@@ -995,19 +987,19 @@ GPUdii() void GPUTPCGMMerger::MergeBorderTracksSetup(int32_t& n1, int32_t& n2, G
 }
 
 template <int32_t I>
-GPUd() void GPUTPCGMMerger::MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, int8_t withinSector, int8_t mergeMode)
+GPUd() void GPUTPCGMMerger::MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, uint8_t mergeMode)
 {
   int32_t n1, n2;
   GPUTPCGMBorderTrack *b1, *b2;
   int32_t jSector;
-  MergeBorderTracksSetup(n1, n2, b1, b2, jSector, iSector, withinSector, mergeMode);
+  MergeBorderTracksSetup(n1, n2, b1, b2, jSector, iSector, mergeMode);
   MergeBorderTracks<I>(nBlocks, nThreads, iBlock, iThread, iSector, b1, n1, jSector, b2, n2, mergeMode);
 }
 
 #if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.
-template GPUdni() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, int8_t withinSector, int8_t mergeMode);
-template GPUdni() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, int8_t withinSector, int8_t mergeMode);
-template GPUdni() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, int8_t withinSector, int8_t mergeMode);
+template GPUdni() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, uint8_t mergeMode);
+template GPUdni() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, uint8_t mergeMode);
+template GPUdni() void GPUTPCGMMerger::MergeBorderTracks<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, uint8_t mergeMode);
 #endif
 
 GPUd() void GPUTPCGMMerger::MergeWithinSectorsPrepare(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread)
@@ -1350,7 +1342,7 @@ GPUd() void GPUTPCGMMerger::MergeCEFill(const GPUTPCGMSectorTrack* track, const
   int32_t sector = track->Sector();
   for (int32_t attempt = 0; attempt < 2; attempt++) {
     GPUTPCGMBorderTrack b;
-    const float x0 = GPUTPCGeometry::Row2X(attempt == 0 ? 63 : cls.row);
+    const float x0 = GPUTPCGeometry::Row2X(attempt == 0 ? 63 : cls.row); // TODO: Fix 63
     if (track->TransportToX(this, x0, Param().bzCLight, b, constants::MAX_SIN_PHI_LOW)) {
       b.SetTrackID(itr);
       b.SetNClusters(mMergedTracks[itr].NClusters());
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
index aad3f6560490f..bf587454ab20e 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.h
@@ -90,6 +90,15 @@ class GPUTPCGMMerger : public GPUProcessor
     float y;
   };
 
+  enum mergeModes : int8_t {
+    mergeWithinSector = 1,
+    mergeBetweenSector = 2,
+    mergeAcrossCE = 4,
+    mergeAtMidRow = 8,
+    mergeAtCluster = 16,
+    mergeWithOriginalParameters = 32
+  };
+
   void InitializeProcessor();
   void RegisterMemoryAllocation();
   void SetMaxData(const GPUTrackingInOutPointers& io);
@@ -164,8 +173,8 @@ class GPUTPCGMMerger : public GPUProcessor
   GPUd() void MergeWithinSectorsPrepare(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
   GPUd() void MergeSectorsPrepare(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t border0, int32_t border1, int8_t useOrigTrackParam);
   template <int32_t I>
-  GPUd() void MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, int8_t withinSector, int8_t mergeMode);
-  GPUd() void MergeBorderTracksSetup(int32_t& n1, int32_t& n2, GPUTPCGMBorderTrack*& b1, GPUTPCGMBorderTrack*& b2, int32_t& jSector, int32_t iSector, int8_t withinSector, int8_t mergeMode) const;
+  GPUd() void MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector, uint8_t mergeMode);
+  GPUd() void MergeBorderTracksSetup(int32_t& n1, int32_t& n2, GPUTPCGMBorderTrack*& b1, GPUTPCGMBorderTrack*& b2, int32_t& jSector, int32_t iSector, uint8_t mergeMode) const;
   template <int32_t I>
   GPUd() void MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, gputpcgmmergertypes::GPUTPCGMBorderRange* range, int32_t N, int32_t cmpMax);
   GPUd() void SortTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread);
@@ -190,7 +199,7 @@ class GPUTPCGMMerger : public GPUProcessor
 
 #ifndef GPUCA_GPUCODE
   void DumpSectorTracks(std::ostream& out) const;
-  void DumpMergeRanges(std::ostream& out, int32_t withinSector, int32_t mergeMode) const;
+  void DumpMergeRanges(std::ostream& out, uint8_t mergeMode) const;
   void DumpTrackLinks(std::ostream& out, bool output, const char* type) const;
   void DumpMergedWithinSectors(std::ostream& out) const;
   void DumpMergedBetweenSectors(std::ostream& out) const;
@@ -204,8 +213,8 @@ class GPUTPCGMMerger : public GPUProcessor
   void DumpTrackClusters(std::ostream& out, bool non0StateOnly = false, bool noNDF0 = false) const;
 
   template <int32_t mergeType>
-  void MergedTrackStreamerInternal(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, int32_t mergeMode, float weight, float frac) const;
-  void MergedTrackStreamer(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, int32_t mergeMode, float weight, float frac) const;
+  void MergedTrackStreamerInternal(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, uint8_t mergeMode, float weight, float frac) const;
+  void MergedTrackStreamer(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, uint8_t mergeMode, float weight, float frac) const;
   const GPUTPCGMBorderTrack& MergedTrackStreamerFindBorderTrack(const GPUTPCGMBorderTrack* tracks, int32_t N, int32_t trackId) const;
   void DebugRefitMergedTrack(const GPUTPCGMMergedTrack& track) const;
   std::vector<uint32_t> StreamerOccupancyBin(int32_t iSector, int32_t iRow, float time) const;
@@ -227,7 +236,7 @@ class GPUTPCGMMerger : public GPUProcessor
  private:
   GPUd() void MergeSectorsPrepareStep2(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iBorder, GPUTPCGMBorderTrack** B, GPUAtomic(uint32_t) * nB, bool useOrigTrackParam = false);
   template <int32_t I>
-  GPUd() void MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, int32_t mergeMode = 0);
+  GPUd() void MergeBorderTracks(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, uint8_t mergeMode = 0);
 
   GPUd() void MergeCEFill(const GPUTPCGMSectorTrack* track, const GPUTPCGMMergedTrackHit& cls, int32_t itr);
 
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 6569ff77566f3..9ee2bcf4eb6b5 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -58,29 +58,29 @@ void GPUTPCGMMerger::DumpSectorTracks(std::ostream& out) const
   out << std::setprecision(ss);
 }
 
-void GPUTPCGMMerger::DumpMergeRanges(std::ostream& out, int32_t withinSector, int32_t mergeMode) const
+void GPUTPCGMMerger::DumpMergeRanges(std::ostream& out, uint8_t mergeMode) const
 {
-  int32_t n = withinSector == -1 ? NSECTORS / 2 : NSECTORS;
+  int32_t n = (mergeMode & mergeModes::mergeAcrossCE) ? NSECTORS / 2 : NSECTORS;
   for (int32_t i = 0; i < n; i++) {
     int32_t n1, n2;
     GPUTPCGMBorderTrack *b1, *b2;
     int32_t jSector;
-    MergeBorderTracksSetup(n1, n2, b1, b2, jSector, i, withinSector, mergeMode);
+    MergeBorderTracksSetup(n1, n2, b1, b2, jSector, i, mergeMode);
     const int32_t nTrk = *mRec->GetConstantMem().tpcTrackers[jSector].NTracks();
     const gputpcgmmergertypes::GPUTPCGMBorderRange* range1 = BorderRange(i);
     const gputpcgmmergertypes::GPUTPCGMBorderRange* range2 = BorderRange(jSector) + nTrk;
-    out << "\nBorder Tracks : i " << i << " withinSector " << withinSector << " mergeMode " << mergeMode << "\n";
+    out << "\nBorder Tracks : i " << i << " mergeMode " << (uint32_t)mergeMode << "\n";
     for (int32_t k = 0; k < n1; k++) {
-      out << "  " << k << ": t " << b1[k].TrackID() << " ncl " << b1[k].NClusters() << " row " << (mergeMode > 0 ? b1[k].Row() : -1) << " par " << b1[k].Par()[0] << " " << b1[k].Par()[1] << " " << b1[k].Par()[2] << " " << b1[k].Par()[3] << " " << b1[k].Par()[4]
+      out << "  " << k << ": t " << b1[k].TrackID() << " ncl " << b1[k].NClusters() << " row " << ((mergeMode & mergeModes::mergeAcrossCE) ? b1[k].Row() : -1) << " par " << b1[k].Par()[0] << " " << b1[k].Par()[1] << " " << b1[k].Par()[2] << " " << b1[k].Par()[3] << " " << b1[k].Par()[4]
           << " offset " << b1[k].ZOffsetLinear() << " cov " << b1[k].Cov()[0] << " " << b1[k].Cov()[1] << " " << b1[k].Cov()[2] << " " << b1[k].Cov()[3] << " " << b1[k].Cov()[4] << " covd " << b1[k].CovD()[0] << " " << b1[k].CovD()[1] << "\n";
     }
     if (i != jSector) {
       for (int32_t k = 0; k < n2; k++) {
-        out << "  " << k << ": t " << b2[k].TrackID() << " ncl " << b2[k].NClusters() << " row " << (mergeMode > 0 ? b2[k].Row() : -1) << " par " << b2[k].Par()[0] << " " << b2[k].Par()[1] << " " << b2[k].Par()[2] << " " << b2[k].Par()[3] << " " << b2[k].Par()[4]
+        out << "  " << k << ": t " << b2[k].TrackID() << " ncl " << b2[k].NClusters() << " row " << ((mergeMode & mergeModes::mergeAcrossCE) ? b2[k].Row() : -1) << " par " << b2[k].Par()[0] << " " << b2[k].Par()[1] << " " << b2[k].Par()[2] << " " << b2[k].Par()[3] << " " << b2[k].Par()[4]
             << " offset " << b2[k].ZOffsetLinear() << " cov " << b2[k].Cov()[0] << " " << b2[k].Cov()[1] << " " << b2[k].Cov()[2] << " " << b2[k].Cov()[3] << " " << b2[k].Cov()[4] << " covd " << b2[k].CovD()[0] << " " << b2[k].CovD()[1] << "\n";
       }
     }
-    out << "\nBorder Range : i " << i << " withinSector " << withinSector << " mergeMode " << mergeMode << "\n";
+    out << "\nBorder Range : i " << i << " mergeMode " << (uint32_t)mergeMode << "\n";
     for (int32_t k = 0; k < n1; k++) {
       out << "  " << k << ": " << range1[k].fId << " " << range1[k].fMin << " " << range1[k].fMax << "\n";
     }
@@ -256,7 +256,7 @@ void GPUTPCGMMerger::DumpFinal(std::ostream& out) const
 }
 
 template <int32_t mergeType>
-inline void GPUTPCGMMerger::MergedTrackStreamerInternal(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, int32_t mergeMode, float weight, float frac) const
+inline void GPUTPCGMMerger::MergedTrackStreamerInternal(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, uint8_t mergeMode, float weight, float frac) const
 {
 #ifdef DEBUG_STREAMER
   std::vector<int32_t> hits1(GPUTPCGeometry::NROWS), hits2(GPUTPCGeometry::NROWS);
@@ -286,13 +286,11 @@ inline void GPUTPCGMMerger::MergedTrackStreamerInternal(const GPUTPCGMBorderTrac
 #endif
 }
 
-void GPUTPCGMMerger::MergedTrackStreamer(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, int32_t mergeMode, float weight, float frac) const
+void GPUTPCGMMerger::MergedTrackStreamer(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, uint8_t mergeMode, float weight, float frac) const
 {
 #ifdef DEBUG_STREAMER
-  if (mergeMode == 0) {
+  if (!(mergeMode & mergeModes::mergeAcrossCE0)) {
     MergedTrackStreamerInternal<0>(b1, b2, name, sector1, sector2, mergeMode, weight, frac);
-  } else if (mergeMode >= 1 && mergeMode <= 0) {
-    // MergedTrackStreamerInternal<1>(b1, b2, name, sector1, sector2, mergeMode, weight, frac); Not yet working
   }
 #endif
 }
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
index 3cb937d4f7abc..2a111b8ce89af 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerGPU.cxx
@@ -116,14 +116,14 @@ GPUdii() void GPUTPCGMMergerMergeBorders::Thread(int32_t nBlocks, int32_t nThrea
   merger.MergeBorderTracks<I>(nBlocks, nThreads, iBlock, iThread, args...);
 }
 #if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.
-template GPUdni() void GPUTPCGMMergerMergeBorders::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int32_t iSector, int8_t withinSector, int8_t mergeMode);
-template GPUdni() void GPUTPCGMMergerMergeBorders::Thread<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int32_t iSector, int8_t withinSector, int8_t mergeMode);
+template GPUdni() void GPUTPCGMMergerMergeBorders::Thread<0>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int32_t iSector, uint8_t mergeMode);
+template GPUdni() void GPUTPCGMMergerMergeBorders::Thread<2>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int32_t iSector, uint8_t mergeMode);
 template GPUdni() void GPUTPCGMMergerMergeBorders::Thread<3>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, gputpcgmmergertypes::GPUTPCGMBorderRange* range, int32_t N, int32_t cmpMax);
 #endif
 template <>
-GPUdii() void GPUTPCGMMergerMergeBorders::Thread<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int32_t iSector, int8_t withinSector, int8_t mergeMode)
+GPUdii() void GPUTPCGMMergerMergeBorders::Thread<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUsharedref() GPUSharedMemory& smem, processorType& GPUrestrict() merger, int32_t iSector, uint8_t mergeMode)
 {
-  merger.MergeBorderTracks<1>(2, nThreads, iBlock & 1, iThread, iBlock / 2, withinSector, mergeMode);
+  merger.MergeBorderTracks<1>(2, nThreads, iBlock & 1, iThread, iBlock / 2, mergeMode);
 }
 
 template <>
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 4d1abe9f5b064..4b366218ed711 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -65,9 +65,9 @@ o2_gpu_add_kernel("GPUTPCGMMergerResolve, step4"                          "GPUTP
 o2_gpu_add_kernel("GPUTPCGMMergerClearLinks"                              "GPUTPCGMMergerGPU TPCMERGER"                           LB int8_t output)
 o2_gpu_add_kernel("GPUTPCGMMergerMergeWithinPrepare"                      "GPUTPCGMMergerGPU TPCMERGER"                           LB)
 o2_gpu_add_kernel("GPUTPCGMMergerMergeSectorsPrepare"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t border0 int32_t border1 int8_t useOrigTrackParam)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step0"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector int8_t withinSector int8_t mergeMode)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step1"                     "GPUTPCGMMergerGPU TPCMERGER"                           NO int32_t iSector int8_t withinSector int8_t mergeMode)
-o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step2"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector int8_t withinSector int8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step0"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector uint8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step1"                     "GPUTPCGMMergerGPU TPCMERGER"                           NO int32_t iSector uint8_t mergeMode)
+o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, step2"                     "GPUTPCGMMergerGPU TPCMERGER"                           LB int32_t iSector uint8_t mergeMode)
 o2_gpu_add_kernel("GPUTPCGMMergerMergeBorders, variant"                   "GPUTPCGMMergerGPU TPCMERGER"                           NO gputpcgmmergertypes::GPUTPCGMBorderRange* range int32_t N int32_t cmpMax)
 o2_gpu_add_kernel("GPUTPCGMMergerMergeCE"                                 "GPUTPCGMMergerGPU TPCMERGER"                           LB)
 o2_gpu_add_kernel("GPUTPCGMMergerLinkExtrapolatedTracks"                  "GPUTPCGMMergerGPU TPCMERGER"                           LB)

From f027d273c56a59f4cba1bc6959c91a91f6b40aad Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 12 Apr 2026 16:48:51 +0200
Subject: [PATCH 1620/1764] GPU: Fix compiler warning

---
 GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
index 3ebd0367b8f6c..5151427377b05 100644
--- a/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
+++ b/GPU/GPUTracking/SectorTracker/GPUTPCNeighboursFinder.cxx
@@ -184,7 +184,7 @@ GPUdii() void GPUTPCNeighboursFinder::Thread<0>(int32_t /*nBlocks*/, int32_t nTh
     if constexpr (MAX_GLOBAL > 1) { // init the rest of the UNROLL_GLOBAL chunk of the global array
       if (nNeighUp > MAX_SHARED && nRestUnrolled < nRest) {
         nRestUnrolled += UNROLL_GLOBAL;
-        GPUCA_UNROLL(U(UNROLL_GLOBAL - 1), U(UNROLL_GLOBAL - 1))
+        GPUCA_UNROLL(U(std::max<int32_t>(UNROLL_GLOBAL - 1, 1)), U(std::max<int32_t>(UNROLL_GLOBAL - 1, 1)))
         for (uint32_t k = 0; k + 1 < UNROLL_GLOBAL; k++) {
           if (nRest + k < nRestUnrolled) {
             yzUp[2 * (nRest + k)] = -1.e10f;

From 740e242b46f387032f44bdf930faa1cd691c435d Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Apr 2026 13:20:05 +0200
Subject: [PATCH 1621/1764] GPU CMake: Fix should fail when no parameters for
 architecture exist

---
 .../Definitions/Parameters/GPUParameters.csv  | 226 +++++++++---------
 .../gpu_param_header_generator.cmake          |   9 +-
 2 files changed, 121 insertions(+), 114 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
index fc27de72ea2f1..87270ec7beee0 100644
--- a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
+++ b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
@@ -1,113 +1,113 @@
-Architecture,default,default_cpu,MI100,VEGA,TAHITI,TESLA,FERMI,PASCAL,KEPLER,AMPERE,TURING
-,,,,,,,,,,,
-CORE:,,,,,,,,,,,
-WARP_SIZE,32,,64,64,32,32,32,32,32,32,32
-THREAD_COUNT_DEFAULT,256,,256,256,,,,,,512,512
-,,,,,,,,,,,
-LB:,,,,,,,,,,,
-GPUTPCCreateTrackingData,256,,"[256, 7]","[192, 2]",,,,,,384,256
-GPUTPCTrackletConstructor,256,,"[768, 8]","[512, 10]","[256, 2]","[256, 1]","[256, 2]","[1024, 2]","[512, 4]","[256, 2]","[256, 2]"
-GPUTPCTrackletSelector,256,,"[384, 5]","[192, 10]","[256, 3]","[256, 1]","[256, 3]","[512, 4]","[256, 3]","[192, 3]","[192, 3]"
-GPUTPCNeighboursFinder,256,,"[192, 8]","[960, 8]",256,256,256,512,256,"[640, 1]","[640, 1]"
-GPUTPCNeighboursCleaner,256,,"[128, 5]","[384, 9]",256,256,256,256,256,512,512
-GPUTPCExtrapolationTracking,256,,"[256, 7]","[256, 2]",,,,,,"[128, 4]","[192, 2]"
-GPUTRDTrackerKernels_gpuVersion,512,,,,,,,,,,
-GPUTPCCreateOccupancyMap_fill,256,,,,,,,,,,
-GPUTPCCreateOccupancyMap_fold,256,,,,,,,,,,
-GPUTRDTrackerKernels_o2Version,512,,,,,,,,,,
-GPUTPCCompressionKernels_step0attached,256,,"[128, 1]","[64, 2]",,,,,,"[64, 2]",128
-GPUTPCCompressionKernels_step1unattached,256,,"[512, 2]","[512, 2]",,,,,,"[512, 3]","[512, 2]"
-GPUTPCDecompressionKernels_step0attached,256,,"[128, 2]","[128, 2]",,,,,,"[32, 1]","[32, 1]"
-GPUTPCDecompressionKernels_step1unattached,256,,"[64, 2]","[64, 2]",,,,,,"[32, 1]","[32, 1]"
-GPUTPCDecompressionUtilKernels_sortPerSectorRow,256,,,,,,,,,,
-GPUTPCDecompressionUtilKernels_countFilteredClusters,256,,,,,,,,,,
-GPUTPCDecompressionUtilKernels_storeFilteredClusters,256,,,,,,,,,,
-GPUTPCCFDecodeZS,"[128, 4]",,"[64, 4]","[64, 1]",,,,,,"[64, 10]","[64, 8]"
-GPUTPCCFDecodeZSLink,"""GPUCA_WARP_SIZE""",,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE"""
-GPUTPCCFDecodeZSDenseLink,"""GPUCA_WARP_SIZE""",,"[""GPUCA_WARP_SIZE"", 4]","[""GPUCA_WARP_SIZE"", 14]",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE"""
-GPUTPCCFGather,"[1024, 1]",,"[1024, 5]","[1024, 1]",,,,,,"[1024, 1]","[1024, 1]"
-COMPRESSION_GATHER,1024,,1024,1024,,,,,,1024,1024
-GPUTPCGMMergerTrackFit,256,,"[192, 2]","[64, 7]",,,,,,"[64, 4]","[32, 8]"
-GPUTPCGMMergerFollowLoopers,256,,"[256, 5]","[256, 4]",,,,,,"[64, 12]","[128, 4]"
-GPUTPCGMMergerSectorRefit,256,,"[64, 4]","[256, 2]",,,,,,"[32, 6]","[64, 5]"
-GPUTPCGMMergerUnpackResetIds,256,,256,256,,,,,,256,256
-GPUTPCGMMergerUnpackGlobal,256,,256,256,,,,,,256,256
-GPUTPCGMMergerResolve_step0,256,,512,256,,,,,,256,256
-GPUTPCGMMergerResolve_step1,256,,512,256,,,,,,256,256
-GPUTPCGMMergerResolve_step2,256,,512,256,,,,,,256,256
-GPUTPCGMMergerResolve_step3,256,,512,256,,,,,,256,256
-GPUTPCGMMergerResolve_step4,256,,512,256,,,,,,"[256, 4]","[256, 4]"
-GPUTPCGMMergerClearLinks,256,,256,256,,,,,,256,256
-GPUTPCGMMergerMergeWithinPrepare,256,,256,256,,,,,,256,256
-GPUTPCGMMergerMergeSectorsPrepare,256,,256,256,,,,,,"[256, 2]","[256, 2]"
-GPUTPCGMMergerMergeBorders_step0,256,,512,256,,,,,,192,192
-GPUTPCGMMergerMergeBorders_step2,256,,512,256,,,,,,"[64, 2]",256
-GPUTPCGMMergerMergeCE,256,,512,256,,,,,,256,256
-GPUTPCGMMergerLinkExtrapolatedTracks,256,,256,256,,,,,,256,256
-GPUTPCGMMergerCollect,256,,"[768, 1]","[1024, 1]",,,,,,"[256, 2]","[128, 2]"
-GPUTPCGMMergerSortTracksPrepare,256,,256,256,,,,,,256,256
-GPUTPCGMMergerPrepareForFit_step0,256,,256,256,,,,,,256,256
-GPUTPCGMMergerPrepareForFit_step1,256,,256,256,,,,,,256,256
-GPUTPCGMMergerPrepareForFit_step2,256,,256,256,,,,,,256,256
-GPUTPCGMMergerFinalize_step0,256,,,256,,,,,,,
-GPUTPCGMMergerFinalize_step1,256,,,256,,,,,,,
-GPUTPCGMMergerFinalize_step2,256,,,256,,,,,,,
-GPUTPCGMMergerMergeLoopers_step0,256,,,,,,,,,,
-GPUTPCGMMergerMergeLoopers_step1,256,,,,,,,,,,
-GPUTPCGMMergerMergeLoopers_step2,256,,,,,,,,,,
-GPUTPCGMO2Output_prepare,256,,,,,,,,,,
-GPUTPCGMO2Output_output,256,,,,,,,,,,
-GPUTPCStartHitsFinder,256,,"[1024, 2]","[1024, 7]",256,256,256,256,256,512,512
-GPUTPCStartHitsSorter,256,,"[1024, 5]","[512, 7]",256,256,256,256,256,"[512, 1]","[512, 1]"
-GPUTPCCFCheckPadBaseline,576,,"[576, 2]","[576, 2]",,,,,,"[576, 2]",
-GPUTPCCFChargeMapFiller_fillIndexMap,512,,512,512,,,,,,448,
-GPUTPCCFChargeMapFiller_fillFromDigits,512,,512,512,,,,,,448,
-GPUTPCCFChargeMapFiller_findFragmentStart,512,,512,512,,,,,,448,
-GPUTPCCFPeakFinder,512,,"[512, 9]","[512, 4]",,,,,,128,
-GPUTPCCFNoiseSuppression,512,,512,512,,,,,,448,
-GPUTPCCFDeconvolution,512,,"[512, 5]","[512, 5]",,,,,,384,
-GPUTPCCFClusterizer,512,,"[448, 3]","[512, 2]",,,,,,448,
-GPUTPCNNClusterizerKernels,512,,,,,,,,,,
-GPUTrackingRefitKernel_mode0asGPU,256,,,,,,,,,,
-GPUTrackingRefitKernel_mode1asTrackParCov,256,,,,,,,,,,
-GPUMemClean16,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,
-GPUitoa,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,
-GPUTPCCFNoiseSuppression_noiseSuppression,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,
-GPUTPCCFNoiseSuppression_updatePeaks,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,
-GPUTPCNNClusterizerKernels_runCfClusterizer,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
-GPUTPCNNClusterizerKernels_fillInputNNCPU,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
-GPUTPCNNClusterizerKernels_fillInputNNGPU,1024,,,,,,,,,,
-GPUTPCNNClusterizerKernels_determineClass1Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
-GPUTPCNNClusterizerKernels_determineClass2Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
-GPUTPCNNClusterizerKernels_publishClass1Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
-GPUTPCNNClusterizerKernels_publishClass2Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
-GPUTPCNNClusterizerKernels_publishDeconvolutionFlags,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,
-GPUTPCCFStreamCompaction_scanStart,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
-GPUTPCCFStreamCompaction_scanUp,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
-GPUTPCCFStreamCompaction_scanTop,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
-GPUTPCCFStreamCompaction_scanDown,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
-GPUTPCCFStreamCompaction_compactDigits,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,
-GPUTPCCompressionGatherKernels_unbuffered,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
-GPUTPCCompressionGatherKernels_buffered32,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
-GPUTPCCompressionGatherKernels_buffered64,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
-GPUTPCCompressionGatherKernels_buffered128,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
-GPUTPCCompressionGatherKernels_multiBlock,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,
-GPUTPCGMMergerFinalize_0,256,,256,,,,,,,256,256
-GPUTPCGMMergerFinalize_1,256,,256,,,,,,,256,256
-GPUTPCGMMergerFinalize_2,256,,256,,,,,,,256,256
-,,,,,,,,,,,
-PAR:,,,,,,,,,,,
-AMD_EUS_PER_CU,0,0,4,4,,,,,,,
-SORT_STARTHITS,1,0,,,,,,,,,
-NEIGHBOURS_FINDER_MAX_NNEIGHUP,6,0,10,4,,,,,,4,4
-NEIGHBOURS_FINDER_UNROLL_GLOBAL,4,0,4,2,,,,,,,
-NEIGHBOURS_FINDER_UNROLL_SHARED,1,0,0,0,,,,,,,
-TRACKLET_SELECTOR_HITS_REG_SIZE,12,0,9,27,,,,,,20,20
-ALTERNATE_BORDER_SORT,0,0,1,1,,,,,,1,1
-SORT_BEFORE_FIT,0,0,1,1,,,,,,1,1
-NO_ATOMIC_PRECHECK,0,0,1,1,,,,,,1,1
-DEDX_STORAGE_TYPE,"""float""","""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t"""
-MERGER_INTERPOLATION_ERROR_TYPE,"""float""","""float""","""half""","""half""",,,,,,"""half""","""half"""
-COMP_GATHER_KERNEL,0,0,4,4,,,,,,4,4
-COMP_GATHER_MODE,2,0,3,3,,,,,,3,3
-CF_SCAN_WORKGROUP_SIZE,512,0,,,,,,,,,
+Architecture,default,default_cpu,MI100,VEGA,TAHITI,TESLA,FERMI,PASCAL,KEPLER,AMPERE,TURING,ADA,OPENCL,RDNA,MI210
+,,,,,,,,,,,,,,,
+CORE:,,,,,,,,,,,,,,,
+WARP_SIZE,0,,64,64,32,32,32,32,32,32,32,32,32,32,64
+THREAD_COUNT_DEFAULT,256,,256,256,,,,,,512,512,512,256,512,512
+,,,,,,,,,,,,,,,
+LB:,,,,,,,,,,,,,,,
+GPUTPCCreateTrackingData,256,,"[256, 7]","[192, 2]",,,,,,384,256,256,,,
+GPUTPCTrackletConstructor,256,,"[768, 8]","[512, 10]","[256, 2]","[256, 1]","[256, 2]","[1024, 2]","[512, 4]","[256, 2]","[256, 2]","[256, 2]",,,
+GPUTPCTrackletSelector,256,,"[384, 5]","[192, 10]","[256, 3]","[256, 1]","[256, 3]","[512, 4]","[256, 3]","[192, 3]","[192, 3]","[192, 3]",,,
+GPUTPCNeighboursFinder,256,,"[192, 8]","[960, 8]",256,256,256,512,256,"[640, 1]","[640, 1]","[640, 1]",,,
+GPUTPCNeighboursCleaner,256,,"[128, 5]","[384, 9]",256,256,256,256,256,512,512,512,,,
+GPUTPCExtrapolationTracking,256,,"[256, 7]","[256, 2]",,,,,,"[128, 4]","[192, 2]","[192, 2]",,,
+GPUTRDTrackerKernels_gpuVersion,512,,,,,,,,,,,,,,
+GPUTPCCreateOccupancyMap_fill,256,,,,,,,,,,,,,,
+GPUTPCCreateOccupancyMap_fold,256,,,,,,,,,,,,,,
+GPUTRDTrackerKernels_o2Version,512,,,,,,,,,,,,,,
+GPUTPCCompressionKernels_step0attached,256,,"[128, 1]","[64, 2]",,,,,,"[64, 2]",128,128,,,
+GPUTPCCompressionKernels_step1unattached,256,,"[512, 2]","[512, 2]",,,,,,"[512, 3]","[512, 2]","[512, 2]",,,
+GPUTPCDecompressionKernels_step0attached,256,,"[128, 2]","[128, 2]",,,,,,"[32, 1]","[32, 1]","[32, 1]",,,
+GPUTPCDecompressionKernels_step1unattached,256,,"[64, 2]","[64, 2]",,,,,,"[32, 1]","[32, 1]","[32, 1]",,,
+GPUTPCDecompressionUtilKernels_sortPerSectorRow,256,,,,,,,,,,,,,,
+GPUTPCDecompressionUtilKernels_countFilteredClusters,256,,,,,,,,,,,,,,
+GPUTPCDecompressionUtilKernels_storeFilteredClusters,256,,,,,,,,,,,,,,
+GPUTPCCFDecodeZS,"[128, 4]",,"[64, 4]","[64, 1]",,,,,,"[64, 10]","[64, 8]","[64, 8]",,,
+GPUTPCCFDecodeZSLink,"""GPUCA_WARP_SIZE""",,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,
+GPUTPCCFDecodeZSDenseLink,"""GPUCA_WARP_SIZE""",,"[""GPUCA_WARP_SIZE"", 4]","[""GPUCA_WARP_SIZE"", 14]",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,
+GPUTPCCFGather,"[1024, 1]",,"[1024, 5]","[1024, 1]",,,,,,"[1024, 1]","[1024, 1]","[1024, 1]",,,
+COMPRESSION_GATHER,1024,,1024,1024,,,,,,1024,1024,1024,,,
+GPUTPCGMMergerTrackFit,256,,"[192, 2]","[64, 7]",,,,,,"[64, 4]","[32, 8]","[32, 8]",,,
+GPUTPCGMMergerFollowLoopers,256,,"[256, 5]","[256, 4]",,,,,,"[64, 12]","[128, 4]","[128, 4]",,,
+GPUTPCGMMergerSectorRefit,256,,"[64, 4]","[256, 2]",,,,,,"[32, 6]","[64, 5]","[64, 5]",,,
+GPUTPCGMMergerUnpackResetIds,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerUnpackGlobal,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerResolve_step0,256,,512,256,,,,,,256,256,256,,,
+GPUTPCGMMergerResolve_step1,256,,512,256,,,,,,256,256,256,,,
+GPUTPCGMMergerResolve_step2,256,,512,256,,,,,,256,256,256,,,
+GPUTPCGMMergerResolve_step3,256,,512,256,,,,,,256,256,256,,,
+GPUTPCGMMergerResolve_step4,256,,512,256,,,,,,"[256, 4]","[256, 4]","[256, 4]",,,
+GPUTPCGMMergerClearLinks,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerMergeWithinPrepare,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerMergeSectorsPrepare,256,,256,256,,,,,,"[256, 2]","[256, 2]","[256, 2]",,,
+GPUTPCGMMergerMergeBorders_step0,256,,512,256,,,,,,192,192,192,,,
+GPUTPCGMMergerMergeBorders_step2,256,,512,256,,,,,,"[64, 2]",256,256,,,
+GPUTPCGMMergerMergeCE,256,,512,256,,,,,,256,256,256,,,
+GPUTPCGMMergerLinkExtrapolatedTracks,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerCollect,256,,"[768, 1]","[1024, 1]",,,,,,"[256, 2]","[128, 2]","[128, 2]",,,
+GPUTPCGMMergerSortTracksPrepare,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerPrepareForFit_step0,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerPrepareForFit_step1,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerPrepareForFit_step2,256,,256,256,,,,,,256,256,256,,,
+GPUTPCGMMergerFinalize_step0,256,,,256,,,,,,,,,,,
+GPUTPCGMMergerFinalize_step1,256,,,256,,,,,,,,,,,
+GPUTPCGMMergerFinalize_step2,256,,,256,,,,,,,,,,,
+GPUTPCGMMergerMergeLoopers_step0,256,,,,,,,,,,,,,,
+GPUTPCGMMergerMergeLoopers_step1,256,,,,,,,,,,,,,,
+GPUTPCGMMergerMergeLoopers_step2,256,,,,,,,,,,,,,,
+GPUTPCGMO2Output_prepare,256,,,,,,,,,,,,,,
+GPUTPCGMO2Output_output,256,,,,,,,,,,,,,,
+GPUTPCStartHitsFinder,256,,"[1024, 2]","[1024, 7]",256,256,256,256,256,512,512,512,,,
+GPUTPCStartHitsSorter,256,,"[1024, 5]","[512, 7]",256,256,256,256,256,"[512, 1]","[512, 1]","[512, 1]",,,
+GPUTPCCFCheckPadBaseline,576,,"[576, 2]","[576, 2]",,,,,,"[576, 2]",,,,,
+GPUTPCCFChargeMapFiller_fillIndexMap,512,,512,512,,,,,,448,,,,,
+GPUTPCCFChargeMapFiller_fillFromDigits,512,,512,512,,,,,,448,,,,,
+GPUTPCCFChargeMapFiller_findFragmentStart,512,,512,512,,,,,,448,,,,,
+GPUTPCCFPeakFinder,512,,"[512, 9]","[512, 4]",,,,,,128,,,,,
+GPUTPCCFNoiseSuppression,512,,512,512,,,,,,448,,,,,
+GPUTPCCFDeconvolution,512,,"[512, 5]","[512, 5]",,,,,,384,,,,,
+GPUTPCCFClusterizer,512,,"[448, 3]","[512, 2]",,,,,,448,,,,,
+GPUTPCNNClusterizerKernels,512,,,,,,,,,,,,,,
+GPUTrackingRefitKernel_mode0asGPU,256,,,,,,,,,,,,,,
+GPUTrackingRefitKernel_mode1asTrackParCov,256,,,,,,,,,,,,,,
+GPUMemClean16,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,,,,,
+GPUitoa,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,,,,,
+GPUTPCCFNoiseSuppression_noiseSuppression,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,,,,,
+GPUTPCCFNoiseSuppression_updatePeaks,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_runCfClusterizer,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_fillInputNNCPU,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_fillInputNNGPU,1024,,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_determineClass1Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_determineClass2Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishClass1Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishClass2Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishDeconvolutionFlags,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
+GPUTPCCFStreamCompaction_scanStart,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
+GPUTPCCFStreamCompaction_scanUp,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
+GPUTPCCFStreamCompaction_scanTop,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
+GPUTPCCFStreamCompaction_scanDown,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
+GPUTPCCFStreamCompaction_compactDigits,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_unbuffered,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered32,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered64,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered128,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_multiBlock,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
+GPUTPCGMMergerFinalize_0,256,,256,,,,,,,256,256,256,,,
+GPUTPCGMMergerFinalize_1,256,,256,,,,,,,256,256,256,,,
+GPUTPCGMMergerFinalize_2,256,,256,,,,,,,256,256,256,,,
+,,,,,,,,,,,,,,,
+PAR:,,,,,,,,,,,,,,,
+AMD_EUS_PER_CU,0,0,4,4,,,,,,,,,,,
+SORT_STARTHITS,1,0,,,,,,,,,,,,,
+NEIGHBOURS_FINDER_MAX_NNEIGHUP,6,0,10,4,,,,,,4,4,4,,,
+NEIGHBOURS_FINDER_UNROLL_GLOBAL,4,0,4,2,,,,,,,,,,,
+NEIGHBOURS_FINDER_UNROLL_SHARED,1,0,0,0,,,,,,,,,,,
+TRACKLET_SELECTOR_HITS_REG_SIZE,12,0,9,27,,,,,,20,20,20,,,
+ALTERNATE_BORDER_SORT,0,0,1,1,,,,,,1,1,1,,,
+SORT_BEFORE_FIT,0,0,1,1,,,,,,1,1,1,,,
+NO_ATOMIC_PRECHECK,0,0,1,1,,,,,,1,1,1,,,
+DEDX_STORAGE_TYPE,"""float""","""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t""","""uint16_t""",,,
+MERGER_INTERPOLATION_ERROR_TYPE,"""float""","""float""","""half""","""half""",,,,,,"""half""","""half""","""half""",,,
+COMP_GATHER_KERNEL,0,0,4,4,,,,,,4,4,4,,,
+COMP_GATHER_MODE,2,0,3,3,,,,,,3,3,3,,,
+CF_SCAN_WORKGROUP_SIZE,512,0,,,,,,,,,,,,,
diff --git a/GPU/GPUTracking/Definitions/Parameters/gpu_param_header_generator.cmake b/GPU/GPUTracking/Definitions/Parameters/gpu_param_header_generator.cmake
index d0e36e7f15026..b43ee846a0635 100644
--- a/GPU/GPUTracking/Definitions/Parameters/gpu_param_header_generator.cmake
+++ b/GPU/GPUTracking/Definitions/Parameters/gpu_param_header_generator.cmake
@@ -91,8 +91,15 @@ function(generate_gpu_param_header GPU_PARAM_JSON_FILES ARCH_LIST OUT_HEADER OUT
     if(ARGC GREATER 4)
         set(${ARGV4} "${JSON_ARCHITECTURES}" PARENT_SCOPE)
     endif()
+    list(REMOVE_ITEM ARCH_LIST "ALL")
+    if(NOT GPUCA_UNKNOWN_ARCHITECTURES_ARE_DEFAULT)
+        foreach(item IN LISTS ARCH_LIST)
+            if(NOT item IN_LIST JSON_ARCHITECTURES)
+                message(FATAL_ERROR "Missing architecture parameters for ${item}")
+            endif()
+        endforeach()
+    endif()
     if(do_all_architectures GREATER -1)
-        list(REMOVE_ITEM ARCH_LIST "ALL")
         list(APPEND ARCH_LIST ${JSON_ARCHITECTURES})
     endif()
     list(REMOVE_DUPLICATES ARCH_LIST)

From ef9f9e8988cdd6c8e010e8d7fb06f29fbb88f9af Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 10 Apr 2026 18:06:19 +0200
Subject: [PATCH 1622/1764] GPU: Add tuned parameters for NVIDIA Blackwell

---
 .../Definitions/Parameters/GPUParameters.csv  | 226 +++++++++---------
 dependencies/FindO2GPU.cmake                  |   8 +-
 2 files changed, 119 insertions(+), 115 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
index 87270ec7beee0..ce9ee4af8e024 100644
--- a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
+++ b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
@@ -1,113 +1,113 @@
-Architecture,default,default_cpu,MI100,VEGA,TAHITI,TESLA,FERMI,PASCAL,KEPLER,AMPERE,TURING,ADA,OPENCL,RDNA,MI210
-,,,,,,,,,,,,,,,
-CORE:,,,,,,,,,,,,,,,
-WARP_SIZE,0,,64,64,32,32,32,32,32,32,32,32,32,32,64
-THREAD_COUNT_DEFAULT,256,,256,256,,,,,,512,512,512,256,512,512
-,,,,,,,,,,,,,,,
-LB:,,,,,,,,,,,,,,,
-GPUTPCCreateTrackingData,256,,"[256, 7]","[192, 2]",,,,,,384,256,256,,,
-GPUTPCTrackletConstructor,256,,"[768, 8]","[512, 10]","[256, 2]","[256, 1]","[256, 2]","[1024, 2]","[512, 4]","[256, 2]","[256, 2]","[256, 2]",,,
-GPUTPCTrackletSelector,256,,"[384, 5]","[192, 10]","[256, 3]","[256, 1]","[256, 3]","[512, 4]","[256, 3]","[192, 3]","[192, 3]","[192, 3]",,,
-GPUTPCNeighboursFinder,256,,"[192, 8]","[960, 8]",256,256,256,512,256,"[640, 1]","[640, 1]","[640, 1]",,,
-GPUTPCNeighboursCleaner,256,,"[128, 5]","[384, 9]",256,256,256,256,256,512,512,512,,,
-GPUTPCExtrapolationTracking,256,,"[256, 7]","[256, 2]",,,,,,"[128, 4]","[192, 2]","[192, 2]",,,
-GPUTRDTrackerKernels_gpuVersion,512,,,,,,,,,,,,,,
-GPUTPCCreateOccupancyMap_fill,256,,,,,,,,,,,,,,
-GPUTPCCreateOccupancyMap_fold,256,,,,,,,,,,,,,,
-GPUTRDTrackerKernels_o2Version,512,,,,,,,,,,,,,,
-GPUTPCCompressionKernels_step0attached,256,,"[128, 1]","[64, 2]",,,,,,"[64, 2]",128,128,,,
-GPUTPCCompressionKernels_step1unattached,256,,"[512, 2]","[512, 2]",,,,,,"[512, 3]","[512, 2]","[512, 2]",,,
-GPUTPCDecompressionKernels_step0attached,256,,"[128, 2]","[128, 2]",,,,,,"[32, 1]","[32, 1]","[32, 1]",,,
-GPUTPCDecompressionKernels_step1unattached,256,,"[64, 2]","[64, 2]",,,,,,"[32, 1]","[32, 1]","[32, 1]",,,
-GPUTPCDecompressionUtilKernels_sortPerSectorRow,256,,,,,,,,,,,,,,
-GPUTPCDecompressionUtilKernels_countFilteredClusters,256,,,,,,,,,,,,,,
-GPUTPCDecompressionUtilKernels_storeFilteredClusters,256,,,,,,,,,,,,,,
-GPUTPCCFDecodeZS,"[128, 4]",,"[64, 4]","[64, 1]",,,,,,"[64, 10]","[64, 8]","[64, 8]",,,
-GPUTPCCFDecodeZSLink,"""GPUCA_WARP_SIZE""",,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,
-GPUTPCCFDecodeZSDenseLink,"""GPUCA_WARP_SIZE""",,"[""GPUCA_WARP_SIZE"", 4]","[""GPUCA_WARP_SIZE"", 14]",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,
-GPUTPCCFGather,"[1024, 1]",,"[1024, 5]","[1024, 1]",,,,,,"[1024, 1]","[1024, 1]","[1024, 1]",,,
-COMPRESSION_GATHER,1024,,1024,1024,,,,,,1024,1024,1024,,,
-GPUTPCGMMergerTrackFit,256,,"[192, 2]","[64, 7]",,,,,,"[64, 4]","[32, 8]","[32, 8]",,,
-GPUTPCGMMergerFollowLoopers,256,,"[256, 5]","[256, 4]",,,,,,"[64, 12]","[128, 4]","[128, 4]",,,
-GPUTPCGMMergerSectorRefit,256,,"[64, 4]","[256, 2]",,,,,,"[32, 6]","[64, 5]","[64, 5]",,,
-GPUTPCGMMergerUnpackResetIds,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerUnpackGlobal,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerResolve_step0,256,,512,256,,,,,,256,256,256,,,
-GPUTPCGMMergerResolve_step1,256,,512,256,,,,,,256,256,256,,,
-GPUTPCGMMergerResolve_step2,256,,512,256,,,,,,256,256,256,,,
-GPUTPCGMMergerResolve_step3,256,,512,256,,,,,,256,256,256,,,
-GPUTPCGMMergerResolve_step4,256,,512,256,,,,,,"[256, 4]","[256, 4]","[256, 4]",,,
-GPUTPCGMMergerClearLinks,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerMergeWithinPrepare,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerMergeSectorsPrepare,256,,256,256,,,,,,"[256, 2]","[256, 2]","[256, 2]",,,
-GPUTPCGMMergerMergeBorders_step0,256,,512,256,,,,,,192,192,192,,,
-GPUTPCGMMergerMergeBorders_step2,256,,512,256,,,,,,"[64, 2]",256,256,,,
-GPUTPCGMMergerMergeCE,256,,512,256,,,,,,256,256,256,,,
-GPUTPCGMMergerLinkExtrapolatedTracks,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerCollect,256,,"[768, 1]","[1024, 1]",,,,,,"[256, 2]","[128, 2]","[128, 2]",,,
-GPUTPCGMMergerSortTracksPrepare,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerPrepareForFit_step0,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerPrepareForFit_step1,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerPrepareForFit_step2,256,,256,256,,,,,,256,256,256,,,
-GPUTPCGMMergerFinalize_step0,256,,,256,,,,,,,,,,,
-GPUTPCGMMergerFinalize_step1,256,,,256,,,,,,,,,,,
-GPUTPCGMMergerFinalize_step2,256,,,256,,,,,,,,,,,
-GPUTPCGMMergerMergeLoopers_step0,256,,,,,,,,,,,,,,
-GPUTPCGMMergerMergeLoopers_step1,256,,,,,,,,,,,,,,
-GPUTPCGMMergerMergeLoopers_step2,256,,,,,,,,,,,,,,
-GPUTPCGMO2Output_prepare,256,,,,,,,,,,,,,,
-GPUTPCGMO2Output_output,256,,,,,,,,,,,,,,
-GPUTPCStartHitsFinder,256,,"[1024, 2]","[1024, 7]",256,256,256,256,256,512,512,512,,,
-GPUTPCStartHitsSorter,256,,"[1024, 5]","[512, 7]",256,256,256,256,256,"[512, 1]","[512, 1]","[512, 1]",,,
-GPUTPCCFCheckPadBaseline,576,,"[576, 2]","[576, 2]",,,,,,"[576, 2]",,,,,
-GPUTPCCFChargeMapFiller_fillIndexMap,512,,512,512,,,,,,448,,,,,
-GPUTPCCFChargeMapFiller_fillFromDigits,512,,512,512,,,,,,448,,,,,
-GPUTPCCFChargeMapFiller_findFragmentStart,512,,512,512,,,,,,448,,,,,
-GPUTPCCFPeakFinder,512,,"[512, 9]","[512, 4]",,,,,,128,,,,,
-GPUTPCCFNoiseSuppression,512,,512,512,,,,,,448,,,,,
-GPUTPCCFDeconvolution,512,,"[512, 5]","[512, 5]",,,,,,384,,,,,
-GPUTPCCFClusterizer,512,,"[448, 3]","[512, 2]",,,,,,448,,,,,
-GPUTPCNNClusterizerKernels,512,,,,,,,,,,,,,,
-GPUTrackingRefitKernel_mode0asGPU,256,,,,,,,,,,,,,,
-GPUTrackingRefitKernel_mode1asTrackParCov,256,,,,,,,,,,,,,,
-GPUMemClean16,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,,,,,
-GPUitoa,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,,,,,
-GPUTPCCFNoiseSuppression_noiseSuppression,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,,,,,
-GPUTPCCFNoiseSuppression_updatePeaks,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,,,,,
-GPUTPCNNClusterizerKernels_runCfClusterizer,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
-GPUTPCNNClusterizerKernels_fillInputNNCPU,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
-GPUTPCNNClusterizerKernels_fillInputNNGPU,1024,,,,,,,,,,,,,,
-GPUTPCNNClusterizerKernels_determineClass1Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
-GPUTPCNNClusterizerKernels_determineClass2Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
-GPUTPCNNClusterizerKernels_publishClass1Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
-GPUTPCNNClusterizerKernels_publishClass2Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
-GPUTPCNNClusterizerKernels_publishDeconvolutionFlags,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,
-GPUTPCCFStreamCompaction_scanStart,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
-GPUTPCCFStreamCompaction_scanUp,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
-GPUTPCCFStreamCompaction_scanTop,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
-GPUTPCCFStreamCompaction_scanDown,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
-GPUTPCCFStreamCompaction_compactDigits,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,
-GPUTPCCompressionGatherKernels_unbuffered,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
-GPUTPCCompressionGatherKernels_buffered32,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
-GPUTPCCompressionGatherKernels_buffered64,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
-GPUTPCCompressionGatherKernels_buffered128,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
-GPUTPCCompressionGatherKernels_multiBlock,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,
-GPUTPCGMMergerFinalize_0,256,,256,,,,,,,256,256,256,,,
-GPUTPCGMMergerFinalize_1,256,,256,,,,,,,256,256,256,,,
-GPUTPCGMMergerFinalize_2,256,,256,,,,,,,256,256,256,,,
-,,,,,,,,,,,,,,,
-PAR:,,,,,,,,,,,,,,,
-AMD_EUS_PER_CU,0,0,4,4,,,,,,,,,,,
-SORT_STARTHITS,1,0,,,,,,,,,,,,,
-NEIGHBOURS_FINDER_MAX_NNEIGHUP,6,0,10,4,,,,,,4,4,4,,,
-NEIGHBOURS_FINDER_UNROLL_GLOBAL,4,0,4,2,,,,,,,,,,,
-NEIGHBOURS_FINDER_UNROLL_SHARED,1,0,0,0,,,,,,,,,,,
-TRACKLET_SELECTOR_HITS_REG_SIZE,12,0,9,27,,,,,,20,20,20,,,
-ALTERNATE_BORDER_SORT,0,0,1,1,,,,,,1,1,1,,,
-SORT_BEFORE_FIT,0,0,1,1,,,,,,1,1,1,,,
-NO_ATOMIC_PRECHECK,0,0,1,1,,,,,,1,1,1,,,
-DEDX_STORAGE_TYPE,"""float""","""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t""","""uint16_t""",,,
-MERGER_INTERPOLATION_ERROR_TYPE,"""float""","""float""","""half""","""half""",,,,,,"""half""","""half""","""half""",,,
-COMP_GATHER_KERNEL,0,0,4,4,,,,,,4,4,4,,,
-COMP_GATHER_MODE,2,0,3,3,,,,,,3,3,3,,,
-CF_SCAN_WORKGROUP_SIZE,512,0,,,,,,,,,,,,,
+Architecture,default,default_cpu,MI100,VEGA,TAHITI,TESLA,FERMI,PASCAL,KEPLER,AMPERE,TURING,ADA,OPENCL,RDNA,MI210,BLACKWELL
+,,,,,,,,,,,,,,,,
+CORE:,,,,,,,,,,,,,,,,
+WARP_SIZE,0,,64,64,32,32,32,32,32,32,32,32,32,32,64,32
+THREAD_COUNT_DEFAULT,256,,256,256,,,,,,512,512,512,256,512,512,512
+,,,,,,,,,,,,,,,,
+LB:,,,,,,,,,,,,,,,,
+GPUTPCCreateTrackingData,256,,"[256, 7]","[192, 2]",,,,,,384,256,256,,,,384
+GPUTPCTrackletConstructor,256,,"[768, 8]","[512, 10]","[256, 2]","[256, 1]","[256, 2]","[1024, 2]","[512, 4]","[256, 2]","[256, 2]","[256, 2]",,,,768
+GPUTPCTrackletSelector,256,,"[384, 5]","[192, 10]","[256, 3]","[256, 1]","[256, 3]","[512, 4]","[256, 3]","[192, 3]","[192, 3]","[192, 3]",,,,992
+GPUTPCNeighboursFinder,256,,"[192, 8]","[960, 8]",256,256,256,512,256,"[640, 1]","[640, 1]","[640, 1]",,,,992
+GPUTPCNeighboursCleaner,256,,"[128, 5]","[384, 9]",256,256,256,256,256,512,512,512,,,,672
+GPUTPCExtrapolationTracking,256,,"[256, 7]","[256, 2]",,,,,,"[128, 4]","[192, 2]","[192, 2]",,,,896
+GPUTRDTrackerKernels_gpuVersion,512,,,,,,,,,,,,,,,
+GPUTPCCreateOccupancyMap_fill,256,,,,,,,,,,,,,,,
+GPUTPCCreateOccupancyMap_fold,256,,,,,,,,,,,,,,,
+GPUTRDTrackerKernels_o2Version,512,,,,,,,,,,,,,,,
+GPUTPCCompressionKernels_step0attached,256,,"[128, 1]","[64, 2]",,,,,,"[64, 2]",128,128,,,,"[96, 3]"
+GPUTPCCompressionKernels_step1unattached,256,,"[512, 2]","[512, 2]",,,,,,"[512, 3]","[512, 2]","[512, 2]",,,,"[512, 2]"
+GPUTPCDecompressionKernels_step0attached,256,,"[128, 2]","[128, 2]",,,,,,"[32, 1]","[32, 1]","[32, 1]",,,,"[32, 1]"
+GPUTPCDecompressionKernels_step1unattached,256,,"[64, 2]","[64, 2]",,,,,,"[32, 1]","[32, 1]","[32, 1]",,,,"[32, 1]"
+GPUTPCDecompressionUtilKernels_sortPerSectorRow,256,,,,,,,,,,,,,,,
+GPUTPCDecompressionUtilKernels_countFilteredClusters,256,,,,,,,,,,,,,,,
+GPUTPCDecompressionUtilKernels_storeFilteredClusters,256,,,,,,,,,,,,,,,
+GPUTPCCFDecodeZS,"[128, 4]",,"[64, 4]","[64, 1]",,,,,,"[64, 10]","[64, 8]","[64, 8]",,,,"[64, 10]"
+GPUTPCCFDecodeZSLink,"""GPUCA_WARP_SIZE""",,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,"""GPUCA_WARP_SIZE"""
+GPUTPCCFDecodeZSDenseLink,"""GPUCA_WARP_SIZE""",,"[""GPUCA_WARP_SIZE"", 4]","[""GPUCA_WARP_SIZE"", 14]",,,,,,"""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""","""GPUCA_WARP_SIZE""",,,,"[""GPUCA_WARP_SIZE"", 8]"
+GPUTPCCFGather,"[1024, 1]",,"[1024, 5]","[1024, 1]",,,,,,"[1024, 1]","[1024, 1]","[1024, 1]",,,,"[1024, 1]"
+COMPRESSION_GATHER,1024,,1024,1024,,,,,,1024,1024,1024,,,,
+GPUTPCGMMergerTrackFit,256,,"[192, 2]","[64, 7]",,,,,,"[64, 4]","[32, 8]","[32, 8]",,,,"[64, 8]"
+GPUTPCGMMergerFollowLoopers,256,,"[256, 5]","[256, 4]",,,,,,"[64, 12]","[128, 4]","[128, 4]",,,,"[224, 3]"
+GPUTPCGMMergerSectorRefit,256,,"[64, 4]","[256, 2]",,,,,,"[32, 6]","[64, 5]","[64, 5]",,,,"[32, 10]"
+GPUTPCGMMergerUnpackResetIds,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerUnpackGlobal,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerResolve_step0,256,,512,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerResolve_step1,256,,512,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerResolve_step2,256,,512,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerResolve_step3,256,,512,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerResolve_step4,256,,512,256,,,,,,"[256, 4]","[256, 4]","[256, 4]",,,,"[256, 4]"
+GPUTPCGMMergerClearLinks,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerMergeWithinPrepare,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerMergeSectorsPrepare,256,,256,256,,,,,,"[256, 2]","[256, 2]","[256, 2]",,,,"[256, 2]"
+GPUTPCGMMergerMergeBorders_step0,256,,512,256,,,,,,192,192,192,,,,192
+GPUTPCGMMergerMergeBorders_step2,256,,512,256,,,,,,"[64, 2]",256,256,,,,"[64, 2]"
+GPUTPCGMMergerMergeCE,256,,512,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerLinkExtrapolatedTracks,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerCollect,256,,"[768, 1]","[1024, 1]",,,,,,"[256, 2]","[128, 2]","[128, 2]",,,,"[288, 1]"
+GPUTPCGMMergerSortTracksPrepare,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerPrepareForFit_step0,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerPrepareForFit_step1,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerPrepareForFit_step2,256,,256,256,,,,,,256,256,256,,,,256
+GPUTPCGMMergerFinalize_step0,256,,,256,,,,,,,,,,,,256
+GPUTPCGMMergerFinalize_step1,256,,,256,,,,,,,,,,,,256
+GPUTPCGMMergerFinalize_step2,256,,,256,,,,,,,,,,,,256
+GPUTPCGMMergerMergeLoopers_step0,256,,,,,,,,,,,,,,,256
+GPUTPCGMMergerMergeLoopers_step1,256,,,,,,,,,,,,,,,256
+GPUTPCGMMergerMergeLoopers_step2,256,,,,,,,,,,,,,,,256
+GPUTPCGMO2Output_prepare,256,,,,,,,,,,,,,,,256
+GPUTPCGMO2Output_output,256,,,,,,,,,,,,,,,256
+GPUTPCStartHitsFinder,256,,"[1024, 2]","[1024, 7]",256,256,256,256,256,512,512,512,,,,608
+GPUTPCStartHitsSorter,256,,"[1024, 5]","[512, 7]",256,256,256,256,256,"[512, 1]","[512, 1]","[512, 1]",,,,608
+GPUTPCCFCheckPadBaseline,576,,"[576, 2]","[576, 2]",,,,,,"[576, 2]",,,,,,"[576, 2]"
+GPUTPCCFChargeMapFiller_fillIndexMap,512,,512,512,,,,,,448,,,,,,448
+GPUTPCCFChargeMapFiller_fillFromDigits,512,,512,512,,,,,,448,,,,,,448
+GPUTPCCFChargeMapFiller_findFragmentStart,512,,512,512,,,,,,448,,,,,,448
+GPUTPCCFPeakFinder,512,,"[512, 9]","[512, 4]",,,,,,128,,,,,,"[128, 5]"
+GPUTPCCFNoiseSuppression,512,,512,512,,,,,,448,,,,,,
+GPUTPCCFDeconvolution,512,,"[512, 5]","[512, 5]",,,,,,384,,,,,,384
+GPUTPCCFClusterizer,512,,"[448, 3]","[512, 2]",,,,,,448,,,,,,"[160, 5]"
+GPUTPCNNClusterizerKernels,512,,,,,,,,,,,,,,,
+GPUTrackingRefitKernel_mode0asGPU,256,,,,,,,,,,,,,,,256
+GPUTrackingRefitKernel_mode1asTrackParCov,256,,,,,,,,,,,,,,,256
+GPUMemClean16,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,,,,,,
+GPUitoa,"[""GPUCA_THREAD_COUNT_DEFAULT"", 1]",,,,,,,,,,,,,,,
+GPUTPCCFNoiseSuppression_noiseSuppression,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,,,,,,448
+GPUTPCCFNoiseSuppression_updatePeaks,"""GPUCA_LB_GPUTPCCFNoiseSuppression""",,,,,,,,,,,,,,,448
+GPUTPCNNClusterizerKernels_runCfClusterizer,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_fillInputNNCPU,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_fillInputNNGPU,1024,,,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_determineClass1Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_determineClass2Labels,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishClass1Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishClass2Regression,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,,
+GPUTPCNNClusterizerKernels_publishDeconvolutionFlags,"""GPUCA_LB_GPUTPCNNClusterizerKernels""",,,,,,,,,,,,,,,
+GPUTPCCFStreamCompaction_scanStart,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"""
+GPUTPCCFStreamCompaction_scanUp,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"""
+GPUTPCCFStreamCompaction_scanTop,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"""
+GPUTPCCFStreamCompaction_scanDown,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"""
+GPUTPCCFStreamCompaction_compactDigits,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE""",,,,,,,,,,,,,,,"""GPUCA_PAR_CF_SCAN_WORKGROUP_SIZE"""
+GPUTPCCompressionGatherKernels_unbuffered,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered32,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered64,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_buffered128,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,,
+GPUTPCCompressionGatherKernels_multiBlock,"""GPUCA_LB_COMPRESSION_GATHER""",,,,,,,,,,,,,,,
+GPUTPCGMMergerFinalize_0,256,,256,,,,,,,256,256,256,,,,256
+GPUTPCGMMergerFinalize_1,256,,256,,,,,,,256,256,256,,,,256
+GPUTPCGMMergerFinalize_2,256,,256,,,,,,,256,256,256,,,,256
+,,,,,,,,,,,,,,,,
+PAR:,,,,,,,,,,,,,,,,
+AMD_EUS_PER_CU,0,0,4,4,,,,,,,,,,,,0
+SORT_STARTHITS,1,0,,,,,,,,,,,,,,1
+NEIGHBOURS_FINDER_MAX_NNEIGHUP,6,0,10,4,,,,,,4,4,4,,,,2
+NEIGHBOURS_FINDER_UNROLL_GLOBAL,4,0,4,2,,,,,,,,,,,,2
+NEIGHBOURS_FINDER_UNROLL_SHARED,1,0,0,0,,,,,,,,,,,,1
+TRACKLET_SELECTOR_HITS_REG_SIZE,12,0,9,27,,,,,,20,20,20,,,,2
+ALTERNATE_BORDER_SORT,0,0,1,1,,,,,,1,1,1,,,,1
+SORT_BEFORE_FIT,0,0,1,1,,,,,,1,1,1,,,,1
+NO_ATOMIC_PRECHECK,0,0,1,1,,,,,,1,1,1,,,,1
+DEDX_STORAGE_TYPE,"""float""","""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t""","""uint16_t""",,,,"""uint16_t"""
+MERGER_INTERPOLATION_ERROR_TYPE,"""float""","""float""","""half""","""half""",,,,,,"""half""","""half""","""half""",,,,"""half"""
+COMP_GATHER_KERNEL,0,0,4,4,,,,,,4,4,4,,,,4
+COMP_GATHER_MODE,2,0,3,3,,,,,,3,3,3,,,,3
+CF_SCAN_WORKGROUP_SIZE,512,0,,,,,,,,,,,,,,
diff --git a/dependencies/FindO2GPU.cmake b/dependencies/FindO2GPU.cmake
index 7ff05a79feb8b..b229f46422eb8 100644
--- a/dependencies/FindO2GPU.cmake
+++ b/dependencies/FindO2GPU.cmake
@@ -10,7 +10,7 @@
 # or submit itself to any jurisdiction.
 
 # NOTE!!!! - Whenever this file is changed, move it over to alidist/resources
-# FindO2GPU.cmake Version 15
+# FindO2GPU.cmake Version 16
 
 set(CUDA_COMPUTETARGET_DEFAULT_FULL 80-real 86-real 89-real 120-real 75-virtual)
 set(HIP_AMDGPUTARGET_DEFAULT_FULL gfx906;gfx908)
@@ -52,7 +52,11 @@ function(detect_gpu_arch backend) # Detect GPU architecture, optionally filterri
     set(CUDA_FIRST_TARGET 86)
     message(STATUS "CUDA_COMPUTETARGET not set, defaulting CUDA optimization for architecture ${CUDA_FIRST_TARGET}")
   endif()
-  if(CUDA_FIRST_TARGET GREATER_EQUAL 86)
+  if(CUDA_FIRST_TARGET GREATER_EQUAL 120)
+    set(CUDA_TARGET BLACKWELL)
+  elseif(CUDA_FIRST_TARGET GREATER_EQUAL 89)
+    set(CUDA_TARGET ADA)
+  elseif(CUDA_FIRST_TARGET GREATER_EQUAL 86)
     set(CUDA_TARGET AMPERE)
   elseif(CUDA_FIRST_TARGET GREATER_EQUAL 75)
     set(CUDA_TARGET TURING)

From 34dbd90159e82a94c8bd378f70b107c186b4bcb2 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Sun, 12 Apr 2026 18:19:45 +0200
Subject: [PATCH 1623/1764] GPU TPC Clusterizer: Add static assert to forbit
 invalid thread counts

---
 GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
index 9c797bc73c987..204d9d6a8b81a 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.cxx
@@ -43,6 +43,7 @@ GPUd() void GPUTPCCFCheckPadBaseline::Thread<0>(int32_t nBlocks, int32_t nThread
 GPUd() void GPUTPCCFCheckPadBaseline::CheckBaselineGPU(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, GPUSharedMemory& smem, processorType& clusterer)
 {
 #ifdef GPUCA_GPUCODE
+  static_assert(GPUCA_GET_THREAD_COUNT(GPUCA_LB_GPUTPCCFCheckPadBaseline) == 576);
   if (iBlock >= (int32_t)GPUTPCGeometry::NROWS) {
     return;
   }

From d6f8a32c16869bbd9f186ecc70ab34f633bbd135 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 13 Apr 2026 12:59:13 +0200
Subject: [PATCH 1624/1764] GPU Standalone: Fix TPC_MAX_TIME_BIN_TRIGGERED for
 Run2 data

---
 GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
index 2e15fbd3e002e..d8812bae72aad 100644
--- a/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
+++ b/GPU/GPUTracking/Definitions/GPUDefConstantsAndSettings.h
@@ -39,7 +39,11 @@ static constexpr float MAX_SIN_PHI = 0.999f;                // Must be preproces
 static constexpr float GRID_MIN_BIN_SIZE = 2.f;             // Minimum bin size in TPC fast access grid
 static constexpr float GRID_MAX_BIN_SIZE = 1000.f;          // Maximum bin size in TPC fast access grid
 static constexpr uint32_t TPC_COMP_CHUNK_SIZE = 1024;       // Chunk size of sorted unattached TPC cluster in compression
+#ifdef GPUCA_RUN2
+static constexpr uint32_t TPC_MAX_TIME_BIN_TRIGGERED = 1024;
+#else
 static constexpr uint32_t TPC_MAX_TIME_BIN_TRIGGERED = 600;
+#endif
 } // namespace o2::gpu::constants
 
 //#define GPUCA_MERGER_BY_MC_LABEL                    // Use MC labels for TPC track merging - for performance studies // TODO: Cleanup unneeded options

From 56481156334c68260838c452b22abc60ccfdeb76 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 13 Apr 2026 13:23:06 +0200
Subject: [PATCH 1625/1764] GPU: Use GPUCommonAlignedAlloc.h in more places

---
 GPU/Common/GPUCommonAlignedAlloc.h                 |  6 +++---
 GPU/GPUTracking/Base/GPUReconstruction.cxx         | 14 +++++++-------
 GPU/GPUTracking/Base/GPUReconstruction.h           |  8 +++++++-
 GPU/GPUTracking/Base/GPUReconstructionCPU.cxx      |  4 ++--
 .../Standalone/Benchmark/standalone.cxx            | 12 ++++--------
 5 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/GPU/Common/GPUCommonAlignedAlloc.h b/GPU/Common/GPUCommonAlignedAlloc.h
index 8e028399f4910..8dffcb8e3973e 100644
--- a/GPU/Common/GPUCommonAlignedAlloc.h
+++ b/GPU/Common/GPUCommonAlignedAlloc.h
@@ -22,17 +22,17 @@ namespace o2::gpu
 
 template <typename T, std::size_t MIN_ALIGN = 0>
 struct alignedDeleter {
-  void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(std::max(MIN_ALIGN, alignof(T)))); };
+  void operator()(void* ptr) { ::operator delete(ptr, std::align_val_t(std::max(MIN_ALIGN, alignof(T)))); }; // TODO: Make this static once we go to C++ 23
 };
 
 template <typename T, std::size_t MIN_ALIGN = 0>
 struct alignedAllocator {
   using value_type = T;
-  T* allocate(std::size_t n)
+  static T* allocate(std::size_t n)
   {
     return (T*)::operator new(n, std::align_val_t(std::max(MIN_ALIGN, alignof(T))));
   }
-  void deallocate(T* ptr, std::size_t)
+  static void deallocate(T* ptr, std::size_t)
   {
     alignedDeleter<T, MIN_ALIGN>()(ptr);
   }
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.cxx b/GPU/GPUTracking/Base/GPUReconstruction.cxx
index b4cea1b9ccc6e..7eda10cd31521 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstruction.cxx
@@ -467,7 +467,7 @@ int32_t GPUReconstruction::Exit()
       if (mMemoryResources[i].mReuse >= 0) {
         continue;
       }
-      ::operator delete(mMemoryResources[i].mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+      alignedDefaultBufferDeleter()(mMemoryResources[i].mPtrDevice);
       mMemoryResources[i].mPtr = mMemoryResources[i].mPtrDevice = nullptr;
     }
   }
@@ -630,7 +630,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && (control == nullptr || control->useInternal())) {
     if (!(res->mType & GPUMemoryResource::MEMORY_EXTERNAL)) {
       if (res->mPtrDevice && res->mReuse < 0) {
-        ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+        alignedDefaultBufferDeleter()(res->mPtrDevice);
       }
       res->mSize = std::max((size_t)res->SetPointers((void*)1) - 1, res->mOverrideSize);
       if (res->mReuse >= 0) {
@@ -640,7 +640,7 @@ void GPUReconstruction::AllocateRegisteredMemoryInternal(GPUMemoryResource* res,
         }
         res->mPtrDevice = mMemoryResources[res->mReuse].mPtrDevice;
       } else {
-        res->mPtrDevice = ::operator new(res->mSize + constants::GPU_BUFFER_ALIGNMENT, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+        res->mPtrDevice = alignedDefaultBufferAllocator<char>(res->mSize + constants::GPU_BUFFER_ALIGNMENT);
       }
       res->mPtr = GPUProcessor::alignPointer<constants::GPU_BUFFER_ALIGNMENT>(res->mPtrDevice);
       res->SetPointers(res->mPtr);
@@ -731,7 +731,7 @@ void* GPUReconstruction::AllocateDirectMemory(size_t size, int32_t type)
 {
   stdspinlock spinlock(mMemoryMutex);
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL) {
-    char* retVal = new (std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)) char[size];
+    char* retVal = alignedDefaultBufferAllocator<char>(size);
     if ((type & GPUMemoryResource::MEMORY_STACK)) {
       mNonPersistentIndividualDirectAllocations.emplace_back(retVal, alignedDefaultBufferDeleter());
     } else {
@@ -796,7 +796,7 @@ void* GPUReconstruction::AllocateVolatileMemory(size_t size, bool device)
   if (device) {
     return AllocateVolatileDeviceMemory(size);
   }
-  char* retVal = new (std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)) char[size];
+  char* retVal = alignedDefaultBufferAllocator<char>(size);
   stdspinlock spinlock(mMemoryMutex);
   mVolatileChunks.emplace_back(retVal, alignedDefaultBufferDeleter());
   return retVal;
@@ -876,7 +876,7 @@ void GPUReconstruction::FreeRegisteredMemory(GPUMemoryResource* res)
     std::cout << "Freeing " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
   }
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_INDIVIDUAL && res->mReuse < 0) {
-    ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+    alignedDefaultBufferDeleter()(res->mPtrDevice);
   }
   res->mPtr = nullptr;
   res->mPtrDevice = nullptr;
@@ -916,7 +916,7 @@ void GPUReconstruction::PopNonPersistentMemory(RecoStep step, uint64_t tag, cons
       std::cout << "Freeing NonPersistent " << res->mName << ": size " << res->mSize << " (reused " << res->mReuse << ")\n";
     }
     if (res->mReuse < 0) {
-      ::operator delete(res->mPtrDevice, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+      alignedDefaultBufferDeleter()(res->mPtrDevice);
     }
     res->mPtr = nullptr;
     res->mPtrDevice = nullptr;
diff --git a/GPU/GPUTracking/Base/GPUReconstruction.h b/GPU/GPUTracking/Base/GPUReconstruction.h
index 825dbdc24aebe..4479eb696808e 100644
--- a/GPU/GPUTracking/Base/GPUReconstruction.h
+++ b/GPU/GPUTracking/Base/GPUReconstruction.h
@@ -253,6 +253,13 @@ class GPUReconstruction
   static int32_t getHostThreadIndex();
   int32_t GetMaxBackendThreads() const { return mMaxBackendThreads; }
 
+  using alignedDefaultBufferDeleter = alignedDeleter<char, constants::GPU_BUFFER_ALIGNMENT>;
+  template <typename T>
+  static T* alignedDefaultBufferAllocator(size_t n)
+  {
+    return alignedAllocator<char, constants::GPU_BUFFER_ALIGNMENT>::allocate(n); // Note that char is correct, since the buffer is a char buffer
+  }
+
  protected:
   void AllocateRegisteredMemoryInternal(GPUMemoryResource* res, GPUOutputControl* control, GPUReconstruction* recPool);
   void FreeRegisteredMemory(GPUMemoryResource* res);
@@ -387,7 +394,6 @@ class GPUReconstruction
   std::unordered_map<GPUMemoryReuse::ID, MemoryReuseMeta> mMemoryReuse1to1;
   std::vector<std::tuple<void*, void*, size_t, size_t, uint64_t>> mNonPersistentMemoryStack; // hostPoolAddress, devicePoolAddress, individualAllocationCount, directIndividualAllocationCound, tag
   std::vector<GPUMemoryResource*> mNonPersistentIndividualAllocations;
-  using alignedDefaultBufferDeleter = alignedDeleter<char, constants::GPU_BUFFER_ALIGNMENT>;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mNonPersistentIndividualDirectAllocations;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mDirectMemoryChunks;
   std::vector<std::unique_ptr<char[], alignedDefaultBufferDeleter>> mVolatileChunks;
diff --git a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
index 1aa54ae56b67b..9fbe9e1171af3 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
+++ b/GPU/GPUTracking/Base/GPUReconstructionCPU.cxx
@@ -189,7 +189,7 @@ int32_t GPUReconstructionCPU::InitDevice()
       if (mDeviceMemorySize > mHostMemorySize) {
         mHostMemorySize = mDeviceMemorySize;
       }
-      mHostMemoryBase = ::operator new(mHostMemorySize, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+      mHostMemoryBase = alignedDefaultBufferAllocator<char>(mHostMemorySize);
     }
     mHostMemoryPermanent = mHostMemoryBase;
     ClearAllocatedMemory();
@@ -205,7 +205,7 @@ int32_t GPUReconstructionCPU::ExitDevice()
 {
   if (GetProcessingSettings().memoryAllocationStrategy == GPUMemoryResource::ALLOCATION_GLOBAL) {
     if (mMaster == nullptr) {
-      ::operator delete(mHostMemoryBase, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
+      alignedDefaultBufferDeleter()(mHostMemoryBase);
     }
     mHostMemoryPool = mHostMemoryBase = mHostMemoryPoolEnd = mHostMemoryPermanent = nullptr;
     mHostMemorySize = 0;
diff --git a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
index d54b883ee7983..52df66d9e69af 100644
--- a/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
+++ b/GPU/GPUTracking/Standalone/Benchmark/standalone.cxx
@@ -81,11 +81,7 @@ uint32_t syncAsyncDecodedClusters = 0;
 GPUChainTracking *chainTracking, *chainTrackingAsync, *chainTrackingPipeline;
 GPUChainITS *chainITS, *chainITSAsync, *chainITSPipeline;
 std::string eventsDir;
-void unique_ptr_aligned_delete(char* v)
-{
-  ::operator delete(v, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT));
-}
-std::unique_ptr<char, void (*)(char*)> outputmemory(nullptr, unique_ptr_aligned_delete), outputmemoryPipeline(nullptr, unique_ptr_aligned_delete), inputmemory(nullptr, unique_ptr_aligned_delete);
+std::unique_ptr<char, GPUReconstruction::alignedDefaultBufferDeleter> outputmemory(nullptr, GPUReconstruction::alignedDefaultBufferDeleter()), outputmemoryPipeline(nullptr, GPUReconstruction::alignedDefaultBufferDeleter()), inputmemory(nullptr, GPUReconstruction::alignedDefaultBufferDeleter());
 std::unique_ptr<GPUDisplayFrontendInterface> eventDisplay;
 std::unique_ptr<GPUReconstructionTimeframe> tf;
 int32_t nEventsInDirectory = 0;
@@ -251,20 +247,20 @@ int32_t ReadConfiguration(int argc, char** argv)
 
   if (configStandalone.outputcontrolmem) {
     bool forceEmptyMemory = getenv("LD_PRELOAD") && strstr(getenv("LD_PRELOAD"), "valgrind") != nullptr;
-    outputmemory.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
+    outputmemory.reset(GPUReconstruction::alignedDefaultBufferAllocator<char>(configStandalone.outputcontrolmem));
     if (forceEmptyMemory) {
       printf("Valgrind detected, emptying GPU output memory to avoid false positive undefined reads");
       memset(outputmemory.get(), 0, configStandalone.outputcontrolmem);
     }
     if (configStandalone.proc.doublePipeline) {
-      outputmemoryPipeline.reset((char*)::operator new(configStandalone.outputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
+      outputmemoryPipeline.reset(GPUReconstruction::alignedDefaultBufferAllocator<char>(configStandalone.outputcontrolmem));
       if (forceEmptyMemory) {
         memset(outputmemoryPipeline.get(), 0, configStandalone.outputcontrolmem);
       }
     }
   }
   if (configStandalone.inputcontrolmem) {
-    inputmemory.reset((char*)::operator new(configStandalone.inputcontrolmem, std::align_val_t(constants::GPU_BUFFER_ALIGNMENT)));
+    inputmemory.reset(GPUReconstruction::alignedDefaultBufferAllocator<char>(configStandalone.inputcontrolmem));
   }
 
   configStandalone.proc.showOutputStat = true;

From 6f7a593ddd2bac01a0f3f2cf8f4f6f481123e998 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 13 Apr 2026 17:07:17 +0200
Subject: [PATCH 1626/1764] GPU Standalone: Fix corner cases when no TRD data
 present, TRDRecoParam missing, and address sanitizer warnings

---
 GPU/GPUTracking/Global/GPUChainTracking.cxx              | 4 ++++
 GPU/GPUTracking/display/render/GPUDisplayDraw.cxx        | 4 ++--
 GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTracking.cxx b/GPU/GPUTracking/Global/GPUChainTracking.cxx
index 5c74d9e949269..dc7b23a375cd3 100644
--- a/GPU/GPUTracking/Global/GPUChainTracking.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTracking.cxx
@@ -215,6 +215,10 @@ bool GPUChainTracking::ValidateSteps()
     GPUError("Input for TRD Tracker missing");
     return false;
   }
+  if ((GetRecoSteps() & gpudatatypes::RecoStep::TRDTracking) && (processors()->calibObjects.trdRecoParam == nullptr)) {
+    GPUError("TRD Reco Parameters are missing");
+    return false;
+  }
   if ((GetRecoStepsOutputs() & gpudatatypes::InOutType::TPCRaw) || (GetRecoStepsOutputs() & gpudatatypes::InOutType::TRDTracklets)) {
     GPUError("TPC Raw / TPC Clusters / TRD Tracklets cannot be output");
     return false;
diff --git a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
index 8b3ab92c0b334..523a8d8b71dd7 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayDraw.cxx
@@ -76,7 +76,7 @@ GPUDisplay::vboList GPUDisplay::DrawSpacePointsTRD(int32_t iSector, int32_t sele
   size_t startCount = mVertexBufferStart[iSector].size();
   size_t startCountInner = mVertexBuffer[iSector].size();
 
-  if (iCol == 0) {
+  if (iCol == 0 && mCurrentSpacePointsTRD > 0) {
     for (uint32_t i = 0; i < mIOPtrs->nTRDTracklets; i++) {
       int32_t iSec = trdGeometry()->GetSector(mIOPtrs->trdTracklets[i].GetDetector());
       bool draw = iSector == iSec && mGlobalPosTRD[i].w == select;
@@ -195,7 +195,7 @@ void GPUDisplay::DrawClusters(int32_t iSector)
     for (int32_t i = 0; i < N_POINTS_TYPE_TPC; i++) {
       uint32_t count = vertexCache[iCol][i].size();
       mClusterBufferSizeCache[iSector][iCol][i] = std::max(mClusterBufferSizeCache[iSector][iCol][i], count);
-      memcpy((void*)&mVertexBuffer[iSector][startCountInner], (const void*)vertexCache[iCol][i].data(), count * sizeof(vertexCache[iCol][i][0]));
+      memcpy((void*)(mVertexBuffer[iSector].data() + startCountInner), (const void*)vertexCache[iCol][i].data(), count * sizeof(vertexCache[iCol][i][0]));
       size_t startCount = mVertexBufferStart[iSector].size();
       insertVertexList(iSector, startCountInner, startCountInner + count);
       startCountInner += count;
diff --git a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
index b8259b974a44d..27c9f98f01fa6 100644
--- a/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
+++ b/GPU/GPUTracking/display/render/GPUDisplayImportEvent.cxx
@@ -55,7 +55,7 @@ void GPUDisplay::DrawGLScene_updateEventData()
     mGlobalPos = mGlobalPosPtr.get();
   }
 
-  mCurrentSpacePointsTRD = mIOPtrs->nTRDTracklets;
+  mCurrentSpacePointsTRD = mIOPtrs->trdSpacePoints ? mIOPtrs->nTRDTracklets : 0;
   if (mCurrentSpacePointsTRD > mNMaxSpacePointsTRD) {
     mNMaxSpacePointsTRD = mCurrentSpacePointsTRD;
     mGlobalPosPtrTRD.reset(new float4[mNMaxSpacePointsTRD]);

From 7ca700a7e5b7134776a23cc2d5c94119c00ec295 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Mon, 13 Apr 2026 17:07:39 +0200
Subject: [PATCH 1627/1764] TPCFastTransform: Do not pollute the global
 namespace

---
 Detectors/Base/src/MatLayerCyl.cxx           |  14 +--
 Detectors/Base/src/MatLayerCylSet.cxx        |  20 ++--
 GPU/TPCFastTransformation/TPCFastTransform.h |   2 +-
 GPU/Utils/FlatObject.h                       | 112 +++++++++----------
 4 files changed, 73 insertions(+), 75 deletions(-)

diff --git a/Detectors/Base/src/MatLayerCyl.cxx b/Detectors/Base/src/MatLayerCyl.cxx
index 29bed111b3584..2efe60235b895 100644
--- a/Detectors/Base/src/MatLayerCyl.cxx
+++ b/Detectors/Base/src/MatLayerCyl.cxx
@@ -83,7 +83,7 @@ void MatLayerCyl::initSegmentation(float rMin, float rMax, float zHalfSpan, int
   //
   int offs = 0;
 
-  o2::gpu::resizeArray(mPhiBin2Slice, 0, nphi, reinterpret_cast<short*>(mFlatBufferPtr + offs));
+  o2::gpu::FlatObject::FlatObject::resizeArray(mPhiBin2Slice, 0, nphi, reinterpret_cast<short*>(mFlatBufferPtr + offs));
   mNPhiSlices = mNPhiBins = nphi;
 
   for (int i = nphi; i--;) {
@@ -92,10 +92,10 @@ void MatLayerCyl::initSegmentation(float rMin, float rMax, float zHalfSpan, int
 
   offs = alignSize(offs + nphi * sizeof(short), getBufferAlignmentBytes()); // account for alignment
 
-  o2::gpu::resizeArray(mSliceCos, 0, nphi, reinterpret_cast<float*>(mFlatBufferPtr + offs)); // in the beginning nslice = nphi
+  o2::gpu::FlatObject::resizeArray(mSliceCos, 0, nphi, reinterpret_cast<float*>(mFlatBufferPtr + offs)); // in the beginning nslice = nphi
   offs = alignSize(offs + nphi * sizeof(float), getBufferAlignmentBytes());                  // account for alignment
 
-  o2::gpu::resizeArray(mSliceSin, 0, nphi, reinterpret_cast<float*>(mFlatBufferPtr + offs)); // in the beginning nslice = nphi
+  o2::gpu::FlatObject::resizeArray(mSliceSin, 0, nphi, reinterpret_cast<float*>(mFlatBufferPtr + offs)); // in the beginning nslice = nphi
   offs = alignSize(offs + nphi * sizeof(float), getBufferAlignmentBytes());                  // account for alignment
 
   for (int i = nphi; i--;) {
@@ -103,7 +103,7 @@ void MatLayerCyl::initSegmentation(float rMin, float rMax, float zHalfSpan, int
     mSliceSin[i] = o2::math_utils::sin(getPhiBinMin(i));
   }
 
-  o2::gpu::resizeArray(mCells, 0, getNCells(), reinterpret_cast<MatCell*>(mFlatBufferPtr + offs));
+  o2::gpu::FlatObject::resizeArray(mCells, 0, getNCells(), reinterpret_cast<MatCell*>(mFlatBufferPtr + offs));
 
   mConstructionMask = InProgress;
 }
@@ -245,10 +245,10 @@ void MatLayerCyl::optimizePhiSlices(float maxRelDiff)
   // mSliceCos pointer does not change, but sliceSin needs to be relocated
   auto offs = alignSize(newSl * sizeof(float), getBufferAlignmentBytes());
   char* dst = ((char*)mSliceCos) + offs; // account for alignment
-  o2::gpu::resizeArray(mSliceSin, getNPhiBins(), newSl, reinterpret_cast<float*>(dst));
+  o2::gpu::FlatObject::resizeArray(mSliceSin, getNPhiBins(), newSl, reinterpret_cast<float*>(dst));
   // adjust mCells array
   dst = ((char*)mSliceSin) + offs; // account for alignment
-  o2::gpu::resizeArray(mCells, getNPhiBins() * getNZBins(), newSl * getNZBins(), reinterpret_cast<MatCell*>(dst));
+  o2::gpu::FlatObject::resizeArray(mCells, getNPhiBins() * getNZBins(), newSl * getNZBins(), reinterpret_cast<MatCell*>(dst));
   mFlatBufferSize = estimateFlatBufferSize();
   LOG(info) << "Updated Nslices = " << getNPhiSlices();
 }
@@ -313,7 +313,7 @@ void MatLayerCyl::flatten(char* newPtr)
   // make object flat: move all content to single internally allocated buffer
   assert(mConstructionMask == InProgress);
   fixPointers(mFlatBufferPtr, newPtr);
-  auto old = o2::gpu::resizeArray(mFlatBufferPtr, getFlatBufferSize(), getFlatBufferSize(), newPtr);
+  auto old = o2::gpu::FlatObject::resizeArray(mFlatBufferPtr, getFlatBufferSize(), getFlatBufferSize(), newPtr);
   delete[] old;
   mFlatBufferContainer = nullptr;
   mConstructionMask = Constructed;
diff --git a/Detectors/Base/src/MatLayerCylSet.cxx b/Detectors/Base/src/MatLayerCylSet.cxx
index 1d904ed01e699..c390c8d617326 100644
--- a/Detectors/Base/src/MatLayerCylSet.cxx
+++ b/Detectors/Base/src/MatLayerCylSet.cxx
@@ -39,7 +39,7 @@ void MatLayerCylSet::addLayer(float rmin, float rmax, float zmax, float dz, floa
   if (!nlr) {
     // book local storage
     auto sz = sizeof(MatLayerCylSetLayout);
-    o2::gpu::resizeArray(mFlatBufferContainer, 0, sz);
+    o2::gpu::FlatObject::resizeArray(mFlatBufferContainer, 0, sz);
     mFlatBufferPtr = mFlatBufferContainer;
     mFlatBufferSize = sz;
     //--------------????
@@ -53,7 +53,7 @@ void MatLayerCylSet::addLayer(float rmin, float rmax, float zmax, float dz, floa
       LOG(fatal) << "new layer overlaps with layer " << il;
     }
   }
-  auto* oldLayers = o2::gpu::resizeArray(get()->mLayers, nlr, nlr + 1);
+  auto* oldLayers = o2::gpu::FlatObject::resizeArray(get()->mLayers, nlr, nlr + 1);
   // dynamyc buffers of old layers were used in new ones, detach them
   for (int i = nlr; i--;) {
     oldLayers[i].clearInternalBufferPtr();
@@ -98,8 +98,8 @@ void MatLayerCylSet::finalizeStructures()
   assert(mConstructionMask == InProgress);
   int nlr = getNLayers();
   int nR2Int = 2 * (nlr + 1);
-  o2::gpu::resizeArray(get()->mR2Intervals, 0, nR2Int);
-  o2::gpu::resizeArray(get()->mInterval2LrID, 0, nR2Int);
+  o2::gpu::FlatObject::resizeArray(get()->mR2Intervals, 0, nR2Int);
+  o2::gpu::FlatObject::resizeArray(get()->mInterval2LrID, 0, nR2Int);
   get()->mR2Intervals[0] = get()->mRMin2;
   get()->mR2Intervals[1] = get()->mRMax2;
   get()->mInterval2LrID[0] = 0;
@@ -116,8 +116,8 @@ void MatLayerCylSet::finalizeStructures()
     get()->mInterval2LrID[nRIntervals] = i;
     get()->mR2Intervals[++nRIntervals] = lr.getRMax2();
   }
-  delete[] o2::gpu::resizeArray(get()->mInterval2LrID, nR2Int, nRIntervals); // rebook with precise size
-  delete[] o2::gpu::resizeArray(get()->mR2Intervals, nR2Int, ++nRIntervals); // rebook with precise size
+  delete[] o2::gpu::FlatObject::resizeArray(get()->mInterval2LrID, nR2Int, nRIntervals); // rebook with precise size
+  delete[] o2::gpu::FlatObject::resizeArray(get()->mR2Intervals, nR2Int, ++nRIntervals); // rebook with precise size
   //
 }
 
@@ -508,14 +508,14 @@ void MatLayerCylSet::flatten()
 
   int sz = estimateFlatBufferSize();
   // create new internal buffer with total size and copy data
-  delete[] o2::gpu::resizeArray(mFlatBufferContainer, mFlatBufferSize, sz);
+  delete[] o2::gpu::FlatObject::resizeArray(mFlatBufferContainer, mFlatBufferSize, sz);
   mFlatBufferPtr = mFlatBufferContainer;
   mFlatBufferSize = sz;
   int nLr = getNLayers();
 
   auto offs = alignSize(sizeof(MatLayerCylSetLayout), getBufferAlignmentBytes()); // account for the alignment
   // move array of layer pointers to the flat array
-  auto* oldLayers = o2::gpu::resizeArray(get()->mLayers, nLr, nLr, (MatLayerCyl*)(mFlatBufferPtr + offs));
+  auto* oldLayers = o2::gpu::FlatObject::resizeArray(get()->mLayers, nLr, nLr, (MatLayerCyl*)(mFlatBufferPtr + offs));
   // dynamyc buffers of old layers were used in new ones, detach them
   for (int i = nLr; i--;) {
     oldLayers[i].clearInternalBufferPtr();
@@ -524,11 +524,11 @@ void MatLayerCylSet::flatten()
   offs = alignSize(offs + nLr * sizeof(MatLayerCyl), MatLayerCyl::getClassAlignmentBytes()); // account for the alignment
 
   // move array of R2 boundaries to the flat array
-  delete[] o2::gpu::resizeArray(get()->mR2Intervals, nLr + 1, nLr + 1, (float*)(mFlatBufferPtr + offs));
+  delete[] o2::gpu::FlatObject::resizeArray(get()->mR2Intervals, nLr + 1, nLr + 1, (float*)(mFlatBufferPtr + offs));
   offs = alignSize(offs + (nLr + 1) * sizeof(float), getBufferAlignmentBytes()); // account for the alignment
 
   // move array of R2 boundaries to the flat array
-  delete[] o2::gpu::resizeArray(get()->mInterval2LrID, nLr, nLr, (int*)(mFlatBufferPtr + offs));
+  delete[] o2::gpu::FlatObject::resizeArray(get()->mInterval2LrID, nLr, nLr, (int*)(mFlatBufferPtr + offs));
   offs = alignSize(offs + nLr * sizeof(int), getBufferAlignmentBytes()); // account for the alignment
 
   for (int il = 0; il < nLr; il++) {
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 17a6447289bd0..100c465996e7d 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -115,7 +115,7 @@ class TPCFastTransform : public FlatObject
   }
 
 /// Destructor
-#if !defined(GPUCA_GPUCODE) && !defined(GPUCA_STANDALONE)
+#if !defined(GPUCA_GPUCODE)
   ~TPCFastTransform()
   {
     delete mCorrectionSlow;
diff --git a/GPU/Utils/FlatObject.h b/GPU/Utils/FlatObject.h
index df31688fcd8bd..4c106cf716c3f 100644
--- a/GPU/Utils/FlatObject.h
+++ b/GPU/Utils/FlatObject.h
@@ -115,63 +115,6 @@ namespace gpu
 ///  before the transport. The object will be ready-to-use right after the porting.
 ///
 
-#ifndef GPUCA_GPUCODE // code invisible on GPU
-
-template <typename T>
-T* resizeArray(T*& ptr, int32_t oldSize, int32_t newSize, T* newPtr = nullptr)
-{
-  // Resize array pointed by ptr. T must be a POD class.
-  // If the non-null newPtr is provided, use it instead of allocating a new one.
-  // In this case it is up to the user to ensure that it has at least newSize slots allocated.
-  // Return original array pointer, so that the user can manage previously allocate memory
-  if (oldSize < 0) {
-    oldSize = 0;
-  }
-  if (newSize > 0) {
-    if (!newPtr) {
-      newPtr = new T[newSize];
-    }
-    int32_t mcp = std::min(newSize, oldSize);
-    if (mcp) {
-      assert(ptr);
-      std::memmove(newPtr, ptr, mcp * sizeof(T));
-    }
-    if (newSize > oldSize) {
-      std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T));
-    }
-  }
-  T* oldPtr = ptr;
-  ptr = newPtr;
-  return oldPtr;
-}
-
-template <typename T>
-T** resizeArray(T**& ptr, int32_t oldSize, int32_t newSize, T** newPtr = nullptr)
-{
-  // Resize array of pointers pointed by ptr.
-  // If the non-null newPtr is provided, use it instead of allocating a new one.
-  // In this case it is up to the user to ensure that it has at least newSize slots allocated.
-  // Return original array pointer, so that the user can manage previously allocate memory
-  if (oldSize < 0) {
-    oldSize = 0;
-  }
-  if (newSize > 0) {
-    if (!newPtr) {
-      newPtr = new T*[newSize];
-    }
-    int32_t mcp = std::min(newSize, oldSize);
-    std::memmove(newPtr, ptr, mcp * sizeof(T*));
-    if (newSize > oldSize) {
-      std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T*));
-    }
-  }
-  T** oldPtr = ptr;
-  ptr = newPtr;
-  return oldPtr;
-}
-
-#endif //! GPUCA_GPUCODE
-
 class FlatObject
 {
  public:
@@ -187,6 +130,61 @@ class FlatObject
   FlatObject() = delete;
 #endif
 
+#ifndef GPUCA_GPUCODE // code invisible on GPU
+  template <typename T>
+  T* resizeArray(T*& ptr, int32_t oldSize, int32_t newSize, T* newPtr = nullptr)
+  {
+    // Resize array pointed by ptr. T must be a POD class.
+    // If the non-null newPtr is provided, use it instead of allocating a new one.
+    // In this case it is up to the user to ensure that it has at least newSize slots allocated.
+    // Return original array pointer, so that the user can manage previously allocate memory
+    if (oldSize < 0) {
+      oldSize = 0;
+    }
+    if (newSize > 0) {
+      if (!newPtr) {
+        newPtr = new T[newSize];
+      }
+      int32_t mcp = std::min(newSize, oldSize);
+      if (mcp) {
+        assert(ptr);
+        std::memmove(newPtr, ptr, mcp * sizeof(T));
+      }
+      if (newSize > oldSize) {
+        std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T));
+      }
+    }
+    T* oldPtr = ptr;
+    ptr = newPtr;
+    return oldPtr;
+  }
+
+  template <typename T>
+  T** resizeArray(T**& ptr, int32_t oldSize, int32_t newSize, T** newPtr = nullptr)
+  {
+    // Resize array of pointers pointed by ptr.
+    // If the non-null newPtr is provided, use it instead of allocating a new one.
+    // In this case it is up to the user to ensure that it has at least newSize slots allocated.
+    // Return original array pointer, so that the user can manage previously allocate memory
+    if (oldSize < 0) {
+      oldSize = 0;
+    }
+    if (newSize > 0) {
+      if (!newPtr) {
+        newPtr = new T*[newSize];
+      }
+      int32_t mcp = std::min(newSize, oldSize);
+      std::memmove(newPtr, ptr, mcp * sizeof(T*));
+      if (newSize > oldSize) {
+        std::memset(newPtr + mcp, 0, (newSize - oldSize) * sizeof(T*));
+      }
+    }
+    T** oldPtr = ptr;
+    ptr = newPtr;
+    return oldPtr;
+  }
+#endif //! GPUCA_GPUCODE
+
  protected:
   /// _____________  Memory alignment  __________________________
 

From 23cc7b55ecdeaf7f151d9a0ecd23bf3254ee564e Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 14 Apr 2026 09:34:15 +0200
Subject: [PATCH 1628/1764] GPU CMake: Simplify header install logic for
 GPUCommon

---
 GPU/Common/CMakeLists.txt | 20 +-------------------
 1 file changed, 1 insertion(+), 19 deletions(-)

diff --git a/GPU/Common/CMakeLists.txt b/GPU/Common/CMakeLists.txt
index 45ca83a3033f0..807756f1e2036 100644
--- a/GPU/Common/CMakeLists.txt
+++ b/GPU/Common/CMakeLists.txt
@@ -11,24 +11,6 @@
 
 set(MODULE GPUCommon)
 
-set(HDRS_INSTALL
-    GPUCommonAlgorithm.h
-    GPUCommonAlignedAlloc.h
-    GPUCommonDef.h
-    GPUCommonDefAPI.h
-    GPUCommonHelpers.h
-    GPUCommonDefSettings.h
-    GPUCommonConstants.h
-    GPUCommonLogger.h
-    GPUCommonMath.h
-    GPUCommonRtypes.h
-    GPUCommonArray.h
-    GPUCommonTypeTraits.h
-    GPUCommonTransform3D.h
-    GPUROOTSMatrixFwd.h
-    GPUROOTCartesianFwd.h
-    GPUDebugStreamer.h)
-
 if(ALIGPU_BUILD_TYPE STREQUAL "O2")
   o2_add_library(${MODULE}
                  SOURCES ../GPUTracking/utils/EmptyFile.cxx
@@ -65,4 +47,4 @@ if(ALIGPU_BUILD_TYPE STREQUAL "O2")
 #  endif()
 endif()
 
-install(FILES ${HDRS_INSTALL} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU)
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/GPU FILES_MATCHING PATTERN "*.h" PATTERN "test" EXCLUDE)

From cd5bab6e9e96dad0a8dcb8f97ce3f9ea72412793 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 14 Apr 2026 19:38:54 +0200
Subject: [PATCH 1629/1764] GPU: Improve debug / info messages

---
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx   | 3 +++
 GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx | 2 +-
 GPU/GPUTracking/Definitions/GPUSettingsList.h               | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index c4e1775e445c3..3608c02d3a973 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -85,6 +85,9 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
                                    "#define GPUCA_WARP_SIZE " + std::to_string(mWarpSize) + "\n";
   if (GetProcessingSettings().rtctech.printLaunchBounds || GetProcessingSettings().debugLevel >= 3) {
     GPUInfo("RTC Launch Bounds:\n%s", launchBounds.c_str());
+    if (GetProcessingSettings().rtctech.printLaunchBounds >= 2) {
+      return 1;
+    }
   }
 
   const std::string compilerVersions = getBackendVersions();
diff --git a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
index d51d306acb827..3d8e749e84147 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCClusterStatistics.cxx
@@ -228,7 +228,7 @@ void GPUTPCClusterStatistics::Finish()
   GPUInfo("Combined Sigma: %6.4f --> %6.4f (%6.4f%%)", eSigma, eSigmaCombined, eSigma > 1e-3 ? (100. * (eSigma - eSigmaCombined) / eSigma) : 0.f);
   GPUInfo("Combined Q: %6.4f --> %6.4f (%6.4f%%)", eQ, eQCombined, eQ > 1e-3 ? (100. * (eQ - eQCombined) / eQ) : 0.f);
 
-  printf("\nCombined Entropy: %7.4f   (Size %'13.0f, %'zu clusters)\nCombined Huffman: %7.4f   (Size %'13.0f, %f%%)\n\n", mEntropy / mNTotalClusters, mEntropy, mNTotalClusters, mHuffman / mNTotalClusters, mHuffman, 100. * (mHuffman - mEntropy) / mHuffman);
+  printf("\nCombined Entropy: %7.4f   (Size %'13.0f, %'zu clusters)\nCombined Huffman: %7.4f   (Size %'13.0f, %f%%)\n\n", mEntropy / mNTotalClusters, mEntropy / 8., mNTotalClusters, mHuffman / mNTotalClusters, mHuffman / 8., 100. * (mHuffman - mEntropy) / mHuffman);
 }
 
 float GPUTPCClusterStatistics::Analyze(std::vector<int32_t>& p, const char* name, bool count)
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index 239e63a3fafac..bbf8dbb508b4a 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -233,7 +233,7 @@ BeginSubConfig(GPUSettingsProcessingRTCtechnical, rtctech, configStandalone.proc
 AddOption(runTest, int32_t, 0, "", 0, "Do not run the actual benchmark, but just test RTC compilation (1 full test, 2 test only compilation)")
 AddOption(cacheMutex, bool, true, "", 0, "Use a file lock to serialize access to the cache folder")
 AddOption(ignoreCacheValid, bool, false, "", 0, "If set, allows to use RTC cached code files even if they are not valid for the current source code / parameters")
-AddOption(printLaunchBounds, bool, false, "", 0, "Print launch bounds used for RTC code as debugging option")
+AddOption(printLaunchBounds, int32_t, false, "", 0, "Print launch bounds used for RTC code as debugging option, 2 for exit after printing", def(1))
 AddOption(allowOptimizedSlaveReconstruction, bool, false, "", 0, "Allow RTC with slave GPUReconstruction instances with optConstexpr and optSpecialcode")
 AddOption(cacheFolder, std::string, "./rtccache/", "", 0, "Folder in which the cache file is stored")
 AddOption(prependCommand, std::string, "", "", 0, "Prepend RTC compilation commands by this string")

From ae20788f2e67ba6dd3f22f6a48afec05ad249609 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Tue, 14 Apr 2026 23:01:30 +0200
Subject: [PATCH 1630/1764] GPU: Add python script to convert C++ parameter
 header to csv file

---
 .../Parameters/header_to_csv.python           | 153 ++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100755 GPU/GPUTracking/Definitions/Parameters/header_to_csv.python

diff --git a/GPU/GPUTracking/Definitions/Parameters/header_to_csv.python b/GPU/GPUTracking/Definitions/Parameters/header_to_csv.python
new file mode 100755
index 0000000000000..303655f1daddc
--- /dev/null
+++ b/GPU/GPUTracking/Definitions/Parameters/header_to_csv.python
@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+
+import sys
+import os
+import re
+
+EXCLUDE_PATTERNS = [
+    r"^GPUCA_LB_GPUTPCCompressionGatherKernels_.*",
+    r"^GPUCA_LB_GPUTPCNNClusterizerKernels_.*",
+    r"^GPUCA_LB_GPUTPCDecompressionUtilKernels_.*",
+    r"^GPUCA_LB_GPUTrackingRefitKernel_.*",
+    r"^GPUCA_LB_GPUTRDTrackerKernels_.*",
+    r"^GPUCA_LB_GPUMemClean16",
+    r"^GPUCA_LB_GPUitoa",
+]
+
+def fail(msg):
+    print(f"Error: {msg}", file=sys.stderr)
+    sys.exit(1)
+
+def matches_any_pattern(text: str, patterns):
+    for pattern in patterns:
+        if re.search(pattern, text):
+            return True
+    return False
+
+def parse_header(header_path):
+    defines = {}
+    define_re = re.compile(r"#define\s+(\w+)\s+(.+)")
+
+    with open(header_path, "r") as f:
+        for line in f:
+            line = line.strip()
+            if not line.startswith("#define"):
+                continue
+
+            m = define_re.match(line)
+            if not m:
+                continue
+
+            raw_name, value = m.groups()
+            value = value.strip()
+
+            matched_excluded = matches_any_pattern(raw_name, EXCLUDE_PATTERNS)
+            if matched_excluded:
+                continue
+
+            # Section + stripped name
+            if raw_name.startswith("GPUCA_LB_"):
+                section = "LB"
+                name = raw_name[len("GPUCA_LB_"):]
+            elif raw_name.startswith("GPUCA_PAR_"):
+                section = "PAR"
+                name = raw_name[len("GPUCA_PAR_"):]
+            else:
+                continue
+
+            # Format value EXACTLY as requested
+            if re.match(r"^\d+\s*,\s*\d+$", value):
+                nums = [int(x.strip()) for x in value.split(",")]
+                formatted = f'"[{nums[0]}, {nums[1]}]"'   # exactly one pair of quotes
+            elif re.match(r"^\d+$", value):
+                formatted = value
+            else:
+                formatted = f'"""{value}"""'             # exactly triple quotes
+
+            defines[(section, name)] = {
+                "value": formatted,
+                "matched": False,
+                "raw": raw_name,
+            }
+
+    return defines
+
+def process_csv(csv_path, defines):
+    output_lines = []
+    current_section = None
+
+    with open(csv_path, "r") as f:
+        lines = f.readlines()
+
+    if not lines:
+        return []
+
+    # First row
+    first = lines[0].rstrip("\n").split(",")
+    output_lines.append(f"{first[0]},NEW")
+
+    for line in lines[1:]:
+        stripped = line.rstrip("\n")
+
+        # Completely empty line → keep empty
+        if stripped.strip() == "":
+            output_lines.append("")
+            continue
+
+        parts = stripped.split(",")
+        key = parts[0].strip()
+
+        # Section handling
+        if key.endswith(":"):
+            section_name = key[:-1]
+            if section_name in ("LB", "PAR"):
+                current_section = section_name
+            else:
+                current_section = None
+
+            output_lines.append(f"{key},")
+            continue
+
+        # Empty first column
+        if key == "":
+            output_lines.append("")
+            continue
+
+        match_key = (current_section, key)
+
+        if match_key in defines:
+            defines[match_key]["matched"] = True
+            output_lines.append(f"{key},{defines[match_key]['value']}")
+        else:
+            # Ensure empty second column
+            output_lines.append(f"{key},")
+
+    return output_lines
+
+def validate_all_matched(defines):
+    unmatched = [d["raw"] for d in defines.values() if not d["matched"]]
+    if unmatched:
+        fail("Unmatched defines: " + ", ".join(unmatched))
+
+def main():
+    if len(sys.argv) != 3:
+        fail("Usage: script.py <input.csv> <header.h>")
+
+    csv_path = sys.argv[1]
+    header_path = sys.argv[2]
+
+    if not os.path.isfile(csv_path):
+        fail(f"CSV file does not exist: {csv_path}")
+
+    if not os.path.isfile(header_path):
+        fail(f"Header file does not exist: {header_path}")
+
+    defines = parse_header(header_path)
+    output_lines = process_csv(csv_path, defines)
+    validate_all_matched(defines)
+
+    for line in output_lines:
+        print(line)
+
+if __name__ == "__main__":
+    main()

From e9d304aa4877978782cbae157c81b98c93fff050 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Apr 2026 14:52:34 +0200
Subject: [PATCH 1631/1764] GPU: Enforce some GPU-kernels are RTC-compiled with
 correct WARP_SIZE as launch-bounds

---
 GPU/GPUTracking/Base/GPUReconstructionProcessing.h        | 3 ++-
 GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx | 7 +++++++
 GPU/GPUTracking/CMakeLists.txt                            | 5 +++++
 GPU/GPUTracking/cmake/kernel_helpers.cmake                | 5 +++++
 GPU/GPUTracking/kernels.cmake                             | 3 +++
 5 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
index 746ecdf083691..3d9507e48e292 100644
--- a/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
+++ b/GPU/GPUTracking/Base/GPUReconstructionProcessing.h
@@ -162,9 +162,10 @@ class GPUReconstructionProcessing : public GPUReconstruction
   // Interface to query name of a kernel
   template <class T, int32_t I>
   static const char* GetKernelName();
-  const std::string& GetKernelName(int32_t i) const { return mKernelNames[i]; }
+  static const std::string& GetKernelName(int32_t i) { return mKernelNames[i]; }
   template <class T, int32_t I = 0>
   static uint32_t GetKernelNum();
+  static uint32_t GetNKernels() { return mKernelNames.size(); }
 
   // Public queries for timers
   auto& getRecoStepTimer(RecoStep step) { return mTimersRecoSteps[getRecoStepNum(step)]; }
diff --git a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
index 3608c02d3a973..2081570f8cdb9 100644
--- a/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
+++ b/GPU/GPUTracking/Base/cuda/GPUReconstructionCUDAGenRTC.cxx
@@ -17,11 +17,13 @@
 #include "GPUReconstructionCUDA.h"
 #include "GPUParamRTC.h"
 #include "GPUDefParametersLoad.inc"
+#include "GPUKernelsWith1Warp.inc"
 #include <unistd.h>
 #include "Framework/SHA1.h"
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <filesystem>
+#include <algorithm>
 
 #include <oneapi/tbb.h>
 using namespace o2::gpu;
@@ -81,6 +83,11 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
       GPUFatal("AMD_EUS_PER_CU not set in the parameters provided for the AMD GPU, you can override this via --PROChipOverrideAMDEUSperCU [n]");
     }
   }
+  for (uint32_t i = 0; i < GetNKernels(); i++) {
+    if (std::find(gpuKernelsWith1Warp.begin(), gpuKernelsWith1Warp.end(), GetKernelName(i)) != gpuKernelsWith1Warp.end()) {
+      mParDevice->par_LB_maxThreads[i] = mWarpSize;
+    }
+  }
   const std::string launchBounds = o2::gpu::internal::GPUDefParametersExport(*mParDevice, true, mParDevice->par_AMD_EUS_PER_CU ? (mParDevice->par_AMD_EUS_PER_CU * mWarpSize) : 0) +
                                    "#define GPUCA_WARP_SIZE " + std::to_string(mWarpSize) + "\n";
   if (GetProcessingSettings().rtctech.printLaunchBounds || GetProcessingSettings().debugLevel >= 3) {
diff --git a/GPU/GPUTracking/CMakeLists.txt b/GPU/GPUTracking/CMakeLists.txt
index ffabc4c9b78fb..ca58d91212084 100644
--- a/GPU/GPUTracking/CMakeLists.txt
+++ b/GPU/GPUTracking/CMakeLists.txt
@@ -299,6 +299,11 @@ set(GPU_DEFAULT_PARAMS_HEADER_DEVICE ${ON_THE_FLY_DIR}/GPUDefParametersDefaultsD
 generate_gpu_param_header("${GPU_PARAM_JSON_FILES}" "ALL" "${GPU_DEFAULT_PARAMS_HEADER}" "${GPU_DEFAULT_PARAMS_HEADER_DEVICE}" GPU_CONST_PARAM_ARCHITECTUES) # generate header with default GPU parameters for all architectures
 list(APPEND GENERATED_HEADERS_LIST ${GPU_DEFAULT_PARAMS_HEADER} ${GPU_DEFAULT_PARAMS_HEADER_DEVICE})
 
+file(GENERATE
+    OUTPUT "${ON_THE_FLY_DIR}/GPUKernelsWith1Warp.inc"
+    CONTENT "namespace o2::gpu { static const std::vector<std::string> gpuKernelsWith1Warp = {\"$<JOIN:$<TARGET_PROPERTY:O2_GPU_KERNELS,O2_GPU_KERNELS_FORCE_1_WARP>,\"$<COMMA> \">\"}; }")
+list(APPEND GENERATED_HEADERS_LIST ${GPU_DEFAULT_PARAMS_HEADER} ${ON_THE_FLY_DIR}/GPUKernelsWith1Warp.inc)
+
 set(HDRS_INSTALL ${HDRS_INSTALL} ${GENERATED_HEADERS_LIST})
 include(kernels.cmake)
 
diff --git a/GPU/GPUTracking/cmake/kernel_helpers.cmake b/GPU/GPUTracking/cmake/kernel_helpers.cmake
index e36cb4e2f3149..cc50d28ecef9e 100644
--- a/GPU/GPUTracking/cmake/kernel_helpers.cmake
+++ b/GPU/GPUTracking/cmake/kernel_helpers.cmake
@@ -20,6 +20,7 @@ define_property(TARGET PROPERTY O2_GPU_KERNEL_FILES)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_NO_FAST_MATH)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_PARAMS)
 define_property(TARGET PROPERTY O2_GPU_KERNEL_STRING_PARAMS)
+define_property(TARGET PROPERTY O2_GPU_KERNELS_FORCE_1_WARP)
 set(O2_GPU_KERNEL_WRAPPER_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/GPU/include_gpu_onthefly")
 file(MAKE_DIRECTORY ${O2_GPU_KERNEL_WRAPPER_FOLDER})
 set(O2_GPU_BASE_DIR "${CMAKE_CURRENT_LIST_DIR}/../")
@@ -184,3 +185,7 @@ function(o2_gpu_kernel_add_string_parameter)
     set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNEL_STRING_PARAMS "${ARGV${i}}")
   endforeach()
 endfunction()
+
+function(o2_gpu_kernel_requires_1_warp kernel)
+  set_property(TARGET O2_GPU_KERNELS APPEND PROPERTY O2_GPU_KERNELS_FORCE_1_WARP "${kernel}")
+endfunction()
diff --git a/GPU/GPUTracking/kernels.cmake b/GPU/GPUTracking/kernels.cmake
index 4b366218ed711..2176ea2dc3804 100644
--- a/GPU/GPUTracking/kernels.cmake
+++ b/GPU/GPUTracking/kernels.cmake
@@ -150,3 +150,6 @@ o2_gpu_kernel_add_parameter(NEIGHBOURS_FINDER_MAX_NNEIGHUP  # Number of neighhbo
 
 o2_gpu_kernel_add_string_parameter(DEDX_STORAGE_TYPE                # Data type to use for intermediate storage of dEdx truncated mean inputs
                                    MERGER_INTERPOLATION_ERROR_TYPE) # Data type for storing intermediate track residuals for interpolation
+
+o2_gpu_kernel_requires_1_warp("GPUTPCCFDecodeZSLink")
+o2_gpu_kernel_requires_1_warp("GPUTPCCFDecodeZSDenseLink")

From cdcc48bf4fa067f382f515c1d99ceda2a7083166 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Apr 2026 22:51:43 +0200
Subject: [PATCH 1632/1764] GPU TPC Merging: Fix alternateBorderSort=0 with GPU
 in per-kernel mode

---
 GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx | 2 ++
 GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx         | 4 ++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
index aa29e884f3f6d..7b27bf4b105b5 100644
--- a/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
+++ b/GPU/GPUTracking/Global/GPUChainTrackingMerger.cxx
@@ -64,6 +64,8 @@ void GPUChainTracking::RunTPCTrackingMerger_MergeBorderTracks(uint8_t mergeMode,
       RecordMarker(&mEvents->sector[j], j + 1);
     }
     StreamWaitForEvents(0, &mEvents->sector[0], ne);
+  } else if (doGPU && !GetProcessingSettings().rtc.enable) {
+    GPUFatal("GPU RTC requires alternateBorderSort!");
   } else {
     for (uint32_t i = 0; i < n; i++) {
       runKernel<GPUTPCGMMergerMergeBorders, 0>(GetGridAuto(0, deviceType), i, mergeMode);
diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
index 4b0b6f583bbf6..e89081aa40350 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMerger.cxx
@@ -818,7 +818,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<0>(int32_t nBlocks, int32_t nThrea
 template <>
 GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThreads, int32_t iBlock, int32_t iThread, int32_t iSector1, const GPUTPCGMBorderTrack* B1, int32_t N1, int32_t iSector2, const GPUTPCGMBorderTrack* B2, int32_t N2, uint8_t mergeMode)
 {
-#if !defined(GPUCA_GPUCODE_COMPILEKERNELS)
+#if !defined(GPUCA_GPUCODE_GENRTC)
   GPUTPCGMBorderRange* range1 = mBorderRange[iSector1];
   GPUTPCGMBorderRange* range2 = mBorderRange[iSector2] + *GetConstantMem()->tpcTrackers[iSector2].NTracks();
 
@@ -830,7 +830,7 @@ GPUd() void GPUTPCGMMerger::MergeBorderTracks<1>(int32_t nBlocks, int32_t nThrea
     }
   }
 #else
-  printf("This sorting variant is disabled for RTC");
+  printf("This sorting variant is disabled for RTC\n");
 #endif
 }
 

From 539c1975f88d242c8200314760ef0f4eba253a62 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Fri, 17 Apr 2026 22:44:37 +0200
Subject: [PATCH 1633/1764] GPU OpenCL: Fix support for half precision

---
 GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
index ed0234f273338..4086109fd7441 100644
--- a/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
+++ b/GPU/GPUTracking/Base/opencl/GPUReconstructionOCLIncludesHost.h
@@ -24,6 +24,9 @@
 #include <vector>
 #include <string>
 #include <memory>
+
+typedef cl_half half;
+
 #include "GPULogging.h"
 
 #include "GPUReconstructionOCL.h"

From ce3e0130c7e544acdfa14e77af74dbcd0023e4a4 Mon Sep 17 00:00:00 2001
From: David Rohr <drohr@jwdt.org>
Date: Wed, 15 Apr 2026 22:52:56 +0200
Subject: [PATCH 1634/1764] GPU: Change some default GPU parameters

---
 .../Definitions/Parameters/GPUParameters.csv         | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
index ce9ee4af8e024..ef215ba5ca870 100644
--- a/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
+++ b/GPU/GPUTracking/Definitions/Parameters/GPUParameters.csv
@@ -103,11 +103,11 @@ NEIGHBOURS_FINDER_MAX_NNEIGHUP,6,0,10,4,,,,,,4,4,4,,,,2
 NEIGHBOURS_FINDER_UNROLL_GLOBAL,4,0,4,2,,,,,,,,,,,,2
 NEIGHBOURS_FINDER_UNROLL_SHARED,1,0,0,0,,,,,,,,,,,,1
 TRACKLET_SELECTOR_HITS_REG_SIZE,12,0,9,27,,,,,,20,20,20,,,,2
-ALTERNATE_BORDER_SORT,0,0,1,1,,,,,,1,1,1,,,,1
-SORT_BEFORE_FIT,0,0,1,1,,,,,,1,1,1,,,,1
+ALTERNATE_BORDER_SORT,1,0,1,1,,,,,,1,1,1,,,,1
+SORT_BEFORE_FIT,1,0,1,1,,,,,,1,1,1,,,,1
 NO_ATOMIC_PRECHECK,0,0,1,1,,,,,,1,1,1,,,,1
-DEDX_STORAGE_TYPE,"""float""","""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t""","""uint16_t""",,,,"""uint16_t"""
-MERGER_INTERPOLATION_ERROR_TYPE,"""float""","""float""","""half""","""half""",,,,,,"""half""","""half""","""half""",,,,"""half"""
-COMP_GATHER_KERNEL,0,0,4,4,,,,,,4,4,4,,,,4
-COMP_GATHER_MODE,2,0,3,3,,,,,,3,3,3,,,,3
+DEDX_STORAGE_TYPE,"""uint16_t""","""float""","""uint16_t""","""uint16_t""",,,,,,"""uint16_t""","""uint16_t""","""uint16_t""",,,,"""uint16_t"""
+MERGER_INTERPOLATION_ERROR_TYPE,"""half""","""float""","""half""","""half""",,,,,,"""half""","""half""","""half""",,,,"""half"""
+COMP_GATHER_KERNEL,4,0,4,4,,,,,,4,4,4,,,,4
+COMP_GATHER_MODE,3,0,3,3,,,,,,3,3,3,,,,3
 CF_SCAN_WORKGROUP_SIZE,512,0,,,,,,,,,,,,,,

From 095c45ebf8965b8054261886ef438767212c389e Mon Sep 17 00:00:00 2001
From: "se.gorbunov" <se.gorbunov@gsi.de>
Date: Tue, 14 Apr 2026 19:27:41 +0200
Subject: [PATCH 1635/1764] TPCFastTransform: adjust the test macro to the new
 code and add test for POD version

---
 .../macro/TPCFastTransformInit.C              | 64 ++++++++++++++-----
 1 file changed, 49 insertions(+), 15 deletions(-)

diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index bc6fafbaa8bd0..973fda78f3047 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -180,7 +180,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
     const char* fileName = outFileName;
 
-    // fileName = "~/test/master/TPCFastTransform_VoxRes.root";
+     //fileName = "~/alidock/test/master/TPCFastTransform_VoxRes.root";
 
     std::cout << "load corrections from file " << fileName << std::endl;
 
@@ -212,6 +212,14 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
   o2::gpu::TPCFastSpaceChargeCorrection& corr = fastTransform->getCorrection();
 
+  aligned_unique_buffer_ptr<TPCFastTransformPOD> podBuffer;
+  TPCFastTransformPOD* corrPODptr = TPCFastTransformPOD::create(podBuffer, *fastTransform);
+
+  if (!corrPODptr) {
+    throw std::runtime_error("Failed to create TPCFastTransformPOD");
+  }
+  const TPCFastTransformPOD& corrPOD = *corrPODptr;
+
   // a debug file with some NTuples
 
   TDirectory* currDir = gDirectory;
@@ -304,24 +312,35 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
   const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
+  float maxPodDiff[6] = {0., 0., 0., 0., 0., 0.};
+
   auto getInvCorrections = [&](int iSector, int iRow, float realY, float realZ, float& ix, float& iy, float& iz) {
     // get the inverse corrections ix, iy, iz at x,y,z
-    ix = corr.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);
-    const auto c = corr.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ);
-    iy = c[0];
-    iz = c[1];
+    ix = corr.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);    
+    corr.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ, iy, iz);
+
+    float ixPod = corrPOD.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);
+    float iyPod, izPod;
+    corrPOD.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ, iyPod, izPod);
+
+    maxPodDiff[3] = std::max(maxPodDiff[3], fabs(ix - ixPod));
+    maxPodDiff[4] = std::max(maxPodDiff[4], fabs(iy - iyPod));
+    maxPodDiff[5] = std::max(maxPodDiff[5], fabs(iz - izPod));
   };
 
   auto getAllCorrections = [&](int iSector, int iRow, float y, float z, float& cx, float& cy, float& cz, float& ix, float& iy, float& iz) {
     // get the corrections cx,cy,cz at x,y,z
-    const auto c = corr.getCorrectionLocal(iSector, iRow, y, z);
-    cx = c[0];
-    cy = c[1];
-    cz = c[2];
+    corr.getCorrectionLocal(iSector, iRow, y, z, cx, cy, cz);
     getInvCorrections(iSector, iRow, y + cy, z + cz, ix, iy, iz);
+
+    float cxPod, cyPod, czPod;
+    corrPOD.getCorrectionLocal(iSector, iRow, y, z, cxPod, cyPod, czPod);
+    maxPodDiff[0] = std::max(maxPodDiff[0], fabs(cx - cxPod));
+    maxPodDiff[1] = std::max(maxPodDiff[1], fabs(cy - cyPod));
+    maxPodDiff[2] = std::max(maxPodDiff[2], fabs(cz - czPod));
   };
 
-  for (int direction = 0; direction < 2; direction++) { // 0 - normal, 1 - inverse
+  for (int direction = 0; direction < 2; direction++) { // 0 - direct, 1 - inverse
 
     std::string directionName = (direction == 0) ? "direct" : "inverse";
 
@@ -582,15 +601,15 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
           float correctionY = point.mDy;
           float correctionZ = point.mDz;
           if (direction == 0) {
-            auto [cx, cy, cz] =
-              corr.getCorrectionLocal(iSector, iRow, y, z);
+            float cx, cy, cz;
+            corr.getCorrectionLocal(iSector, iRow, y, z, cx, cy, cz);
             ntFitPoints->Fill(iSector, iRow, x, y, z, correctionX, correctionY,
                               correctionZ, cx, cy, cz);
           } else {
             float cx =
               corr.getCorrectionXatRealYZ(iSector, iRow, y, z);
-            auto [cy, cz] =
-              corr.getCorrectionYZatRealYZ(iSector, iRow, y, z);
+            float cy, cz;
+            corr.getCorrectionYZatRealYZ(iSector, iRow, y, z, cy, cz);
             ntInvFitPoints->Fill(iSector, iRow, x, y, z, correctionX, correctionY,
                                  correctionZ, cx, cy, cz);
           }
@@ -601,7 +620,9 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
     for (int32_t i = 0; i < 3; i++) {
       sumDiff[i] = sqrt(sumDiff[i]) / nDiff;
     }
+
     LOG(info) << directionName << " correction: max and mean differences between spline and voxel corrections:";
+
     LOG(info) << "Max difference in x :  " << maxDiff[0] << " at Sector "
               << maxDiffSector[0] << " row " << maxDiffRow[0];
 
@@ -612,9 +633,22 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
               << maxDiffSector[2] << " row " << maxDiffRow[2];
 
     LOG(info) << "Mean difference in x,y,z : " << sumDiff[0] << " " << sumDiff[1]
-              << " " << sumDiff[2] << std::endl;
+              << " " << sumDiff[2];
+
+    LOG(info) << std::endl;
+
   } // direction
 
+  LOG(info) << " max difference between POD and original corrections: ";
+  LOG(info) << " x " << maxPodDiff[0];
+  LOG(info) << " y " << maxPodDiff[1];
+  LOG(info) << " z " << maxPodDiff[2];
+  LOG(info) << " inverse x " << maxPodDiff[3];
+  LOG(info) << " inverse y " << maxPodDiff[4];
+  LOG(info) << " inverse z " << maxPodDiff[5];
+
+  LOG(info) << std::endl;
+
   corr.testInverse(true);
 
   debugFile->cd();

From 69396eccf08ff8a1b692bd8a80b4389f83411337 Mon Sep 17 00:00:00 2001
From: "se.gorbunov" <se.gorbunov@gsi.de>
Date: Tue, 14 Apr 2026 19:54:03 +0200
Subject: [PATCH 1636/1764] TPCFastTransform: remove row-wise max correction
 values

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 14 +---
 .../TPCFastSpaceChargeCorrection.cxx          | 10 ---
 .../TPCFastSpaceChargeCorrection.h            | 66 ++++---------------
 .../TPCFastTransformPOD.h                     | 18 ++---
 4 files changed, 21 insertions(+), 87 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 783c1837590b9..85d6c8a57149b 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -144,12 +144,6 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
 
         const std::vector<o2::gpu::TPCFastSpaceChargeCorrectionMap::CorrectionPoint>& data = mCorrectionMap.getPoints(sector, row);
         int nDataPoints = data.size();
-        auto& info = correction.getSectorRowInfo(sector, row);
-        if (!processingInverseCorrection) {
-          info.resetMaxValues();
-        }
-        info.updateMaxValues(1., 1., 1.);
-        info.updateMaxValues(-1., -1., -1.);
 
         if (nDataPoints >= 4) {
           std::vector<double> pointGU(nDataPoints);
@@ -170,7 +164,6 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
             pointCorr[3 * i + 0] = p.mDx;
             pointCorr[3 * i + 1] = p.mDy;
             pointCorr[3 * i + 2] = p.mDz;
-            info.updateMaxValues(5. * p.mDx, 5. * p.mDy, 5. * p.mDz);
           }
           helper.approximateDataPoints(spline, splineParameters.data(), 0., spline.getGridX1().getUmax(), 0., spline.getGridX2().getUmax(), pointGU.data(),
                                        pointGV.data(), pointCorr.data(), pointWeight.data(), nDataPoints);
@@ -1063,10 +1056,7 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
         constexpr int nKnotPar3d = nKnotPar1d * 3;
 
         { // scale the main correction
-          for (int i = 0; i < 3; i++) {
-            secRowInfo.maxCorr[i] *= mainScale;
-            secRowInfo.minCorr[i] *= mainScale;
-          }
+
           double parscale[4] = {mainScale, mainScale, mainScale, mainScale * mainScale};
           for (int iknot = 0, ind = 0; iknot < spline.getNumberOfKnots(); iknot++) {
             for (int ipar = 0; ipar < nKnotPar1d; ++ipar) {
@@ -1100,8 +1090,6 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
           const auto& corr = *(additionalCorrections[icorr].first);
           double scale = additionalCorrections[icorr].second;
           auto& linfo = corr.getSectorRowInfo(sector, row);
-          secRowInfo.updateMaxValues(linfo.getMaxValues(), scale);
-          secRowInfo.updateMaxValues(linfo.getMinValues(), scale);
 
           double scaleU = secRowInfo.gridMeasured.getYscale() / linfo.gridMeasured.getYscale();
           double scaleV = secRowInfo.gridMeasured.getZscale() / linfo.gridMeasured.getZscale();
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 49305e3ed7909..f8a03ce982460 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -280,10 +280,6 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
           }
           newSectorRow.gridReal.set(y0, yScale, z0, zScale, zOut, zReadout);
         }
-
-        newSectorRow.resetMaxValues();
-        newSectorRow.updateMaxValues(-100.f, -100.f, -100.f);
-        newSectorRow.updateMaxValues(100.f, 100.f, 100.f);
       }
     }
   }
@@ -497,12 +493,6 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
       row.dataOffsetBytes[0] = 0;
       row.dataOffsetBytes[1] = 0;
       row.dataOffsetBytes[2] = 0;
-      row.minCorr[0] = 0;
-      row.minCorr[1] = 0;
-      row.minCorr[2] = 0;
-      row.maxCorr[0] = 0;
-      row.maxCorr[1] = 0;
-      row.maxCorr[2] = 0;
     }
   }
 
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index a32c835ad7731..c3f8107461305 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -102,51 +102,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     GridInfo gridMeasured; ///< grid info for measured coordinates
     GridInfo gridReal;     ///< grid info for real coordinates
 
-    float minCorr[3]{-10.f, -10.f, -10.f}; ///< min correction for dX, dY, dZ
-    float maxCorr[3]{10.f, 10.f, 10.f};    ///< max correction for dX, dY, dZ
-
-    void resetMaxValues()
-    {
-      minCorr[0] = -1.f;
-      maxCorr[0] = 1.f;
-      minCorr[1] = -1.f;
-      maxCorr[1] = 1.f;
-      minCorr[2] = -1.f;
-      maxCorr[2] = 1.f;
-    }
-
-    void updateMaxValues(float dx, float du, float dv)
-    {
-      minCorr[0] = GPUCommonMath::Min(minCorr[0], dx);
-      maxCorr[0] = GPUCommonMath::Max(maxCorr[0], dx);
-
-      minCorr[1] = GPUCommonMath::Min(minCorr[1], du);
-      maxCorr[1] = GPUCommonMath::Max(maxCorr[1], du);
-
-      minCorr[2] = GPUCommonMath::Min(minCorr[2], dv);
-      maxCorr[2] = GPUCommonMath::Max(maxCorr[2], dv);
-    }
-
-#ifndef GPUCA_GPUCODE_DEVICE
-    void updateMaxValues(std::array<float, 3> dxdudv, float scale)
-    {
-      float dx = dxdudv[0] * scale;
-      float du = dxdudv[1] * scale;
-      float dv = dxdudv[2] * scale;
-      updateMaxValues(dx, du, dv);
-    }
-
-    std::array<float, 3> getMaxValues() const
-    {
-      return {maxCorr[0], maxCorr[1], maxCorr[2]};
-    }
-
-    std::array<float, 3> getMinValues() const
-    {
-      return {minCorr[0], minCorr[1], minCorr[2]};
-    }
-#endif
-
     ClassDefNV(SectorRowInfo, 2);
   };
 
@@ -325,6 +280,8 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// release temporary memory used during construction
   void releaseConstructionMemory();
 
+  static constexpr float kMaxCorrection = 100.f; ///< maximum correction value, used to protect from FPEs
+
   /// _______________  Data members  _______________________________________________
 
   /// _______________  Construction control  _______________________________________________
@@ -506,13 +463,13 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, in
   float dxyz[3];
   spline.interpolateAtU(splineData, u, v, dxyz);
 
-  if (CAMath::Abs(dxyz[0]) > 100.f || CAMath::Abs(dxyz[1]) > 100.f || CAMath::Abs(dxyz[2]) > 100.f) {
+  if (CAMath::Abs(dxyz[0]) > kMaxCorrection || CAMath::Abs(dxyz[1]) > kMaxCorrection || CAMath::Abs(dxyz[2]) > kMaxCorrection) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
 
-  dx = s * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
-  dy = s * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
-  dz = s * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
+  dx = s * dxyz[0];
+  dy = s * dxyz[1];
+  dz = s * dxyz[2];
 }
 
 GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
@@ -522,11 +479,10 @@ GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t secto
   convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
   float dx = 0;
   getSplineInvX(sector, row).interpolateAtU(getCorrectionDataInvX(sector, row), u, v, &dx);
-  if (CAMath::Abs(dx) > 100.f) {
+  if (CAMath::Abs(dx) > kMaxCorrection) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
-  dx = s * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
-  return dx;
+  return s * dx;
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t sector, int32_t row, float realY, float realZ, float& y, float& z) const
@@ -536,11 +492,11 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t secto
   const auto& info = getSectorRowInfo(sector, row);
   float dyz[2];
   getSplineInvYZ(sector, row).interpolateAtU(getCorrectionDataInvYZ(sector, row), u, v, dyz);
-  if (CAMath::Abs(dyz[0]) > 100.f || CAMath::Abs(dyz[1]) > 100.f) {
+  if (CAMath::Abs(dyz[0]) > kMaxCorrection || CAMath::Abs(dyz[1]) > kMaxCorrection) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
-  y = s * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
-  z = s * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
+  y = s * dyz[0];
+  z = s * dyz[1];
 }
 
 } // namespace o2::gpu
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index b30a3d52ec696..8967b94a80780 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -316,13 +316,13 @@ GPUdi() void TPCFastTransformPOD::getCorrectionLocal(int32_t sector, int32_t row
   float dxyz[3];
   spline.interpolateAtUZeroCopy(g1buf, g2buf, splineData, u, v, dxyz);
 
-  if (CAMath::Abs(dxyz[0]) > 100.f || CAMath::Abs(dxyz[1]) > 100.f || CAMath::Abs(dxyz[2]) > 100.f) {
+  if (CAMath::Abs(dxyz[0]) > TPCFastSpaceChargeCorrection::kMaxCorrection || CAMath::Abs(dxyz[1]) > TPCFastSpaceChargeCorrection::kMaxCorrection || CAMath::Abs(dxyz[2]) > TPCFastSpaceChargeCorrection::kMaxCorrection) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
 
-  dx = s * GPUCommonMath::Clamp(dxyz[0], info.minCorr[0], info.maxCorr[0]);
-  dy = s * GPUCommonMath::Clamp(dxyz[1], info.minCorr[1], info.maxCorr[1]);
-  dz = s * GPUCommonMath::Clamp(dxyz[2], info.minCorr[2], info.maxCorr[2]);
+  dx = s * dxyz[0];
+  dy = s * dxyz[1];
+  dz = s * dxyz[2];
 }
 
 GPUdi() float TPCFastTransformPOD::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
@@ -338,10 +338,10 @@ GPUdi() float TPCFastTransformPOD::getCorrectionXatRealYZ(int32_t sector, int32_
 
   float dx = 0;
   spline.interpolateAtUZeroCopy(g1buf, g2buf, getCorrectionDataInvX(sector, row), u, v, &dx);
-  if (CAMath::Abs(dx) > 100.f) {
+  if (CAMath::Abs(dx) > TPCFastSpaceChargeCorrection::kMaxCorrection) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
-  dx = s * GPUCommonMath::Clamp(dx, info.minCorr[0], info.maxCorr[0]);
+  dx = s * dx;
   return dx;
 }
 
@@ -357,11 +357,11 @@ GPUdi() void TPCFastTransformPOD::getCorrectionYZatRealYZ(int32_t sector, int32_
 
   float dyz[2];
   spline.interpolateAtUZeroCopy(g1buf, g2buf, getCorrectionDataInvYZ(sector, row), u, v, dyz);
-  if (CAMath::Abs(dyz[0]) > 100.f || CAMath::Abs(dyz[1]) > 100.f) {
+  if (CAMath::Abs(dyz[0]) > TPCFastSpaceChargeCorrection::kMaxCorrection || CAMath::Abs(dyz[1]) > TPCFastSpaceChargeCorrection::kMaxCorrection) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
-  y = s * GPUCommonMath::Clamp(dyz[0], info.minCorr[1], info.maxCorr[1]);
-  z = s * GPUCommonMath::Clamp(dyz[1], info.minCorr[2], info.maxCorr[2]);
+  y = s * dyz[0];
+  z = s * dyz[1];
 }
 
 GPUdi() void TPCFastTransformPOD::convLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const

From 8fe64f34600c55786c6d1bccf629986f432b90f9 Mon Sep 17 00:00:00 2001
From: "se.gorbunov" <se.gorbunov@gsi.de>
Date: Wed, 15 Apr 2026 22:46:35 +0200
Subject: [PATCH 1637/1764] =?UTF-8?q?TPCFastTransform:=20mirror=20Z-=C2=B4?=
 =?UTF-8?q?of=20the=20spline=20grid=20for=20the=20C=20side?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    | 27 +++++---------
 .../TPCFastSpaceChargeCorrection.cxx          | 35 +++++--------------
 .../TPCFastSpaceChargeCorrection.h            | 22 +++++++-----
 .../TPCFastTransformGeo.h                     | 11 ------
 .../TPCFastTransformPOD.h                     | 13 +++----
 .../macro/TPCFastTransformInit.C              |  3 +-
 6 files changed, 39 insertions(+), 72 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 85d6c8a57149b..40946d55b7de2 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -401,11 +401,10 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   int nY2Xbins = trackResiduals.getNY2XBins();
   int nZ2Xbins = trackResiduals.getNZ2XBins();
 
-  std::vector<double> knotsDouble[3];
+  std::vector<double> knotsDouble[2];
 
   knotsDouble[0].reserve(nY2Xbins);
   knotsDouble[1].reserve(nZ2Xbins);
-  knotsDouble[2].reserve(nZ2Xbins);
 
   // to get enouth measurements, make a spline knot at every second bin. Boundary bins are always included.
 
@@ -418,16 +417,14 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
   for (int i = 0, j = nZ2Xbins - 1; i <= j; i += 2, j -= 2) {
     knotsDouble[1].push_back(trackResiduals.getZ2X(i));
-    knotsDouble[2].push_back(-trackResiduals.getZ2X(i));
     if (j >= i + 1) {
       knotsDouble[1].push_back(trackResiduals.getZ2X(j));
-      knotsDouble[2].push_back(-trackResiduals.getZ2X(j));
     }
   }
 
-  std::vector<int> knotsInt[3];
+  std::vector<int> knotsInt[2];
 
-  for (int dim = 0; dim < 3; dim++) {
+  for (int dim = 0; dim < 2; dim++) {
     auto& knotsD = knotsDouble[dim];
     std::sort(knotsD.begin(), knotsD.end());
 
@@ -463,12 +460,10 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
   }
 
   auto& yKnotsInt = knotsInt[0];
-  auto& zKnotsIntA = knotsInt[1];
-  auto& zKnotsIntC = knotsInt[2];
+  auto& zKnotsInt = knotsInt[1];
 
   int nKnotsY = yKnotsInt.size();
-  int nKnotsZA = zKnotsIntA.size();
-  int nKnotsZC = zKnotsIntC.size();
+  int nKnotsZ = zKnotsInt.size();
 
   // std::cout << "n knots Y: " << nKnotsY << std::endl;
   // std::cout << "n knots Z: " << nKnotsZA << ",  " << nKnotsZC << std::endl;
@@ -491,9 +486,9 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
     }
     { // init spline scenario
       TPCFastSpaceChargeCorrection::SplineType spline;
-      spline.recreate(nKnotsY, &yKnotsInt[0], nKnotsZA, &zKnotsIntA[0]);
+      spline.recreate(nKnotsY, &yKnotsInt[0], nKnotsZ, &zKnotsInt[0]);
       correction.setSplineScenario(0, spline);
-      spline.recreate(nKnotsY, &yKnotsInt[0], nKnotsZC, &zKnotsIntC[0]);
+      spline.recreate(nKnotsY, &yKnotsInt[0], nKnotsZ, &zKnotsInt[0]);
       correction.setSplineScenario(1, spline);
     }
     correction.finishConstruction();
@@ -510,15 +505,9 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
       double zMin = rowX * trackResiduals.getZ2X(0);
       double zMax = rowX * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
       double zOut = zMax;
-      if (iSector >= geo.getNumberOfSectorsA()) {
-        // TPC C side
-        zOut = -zOut;
-        zMax = -zMin;
-        zMin = zOut;
-      }
       info.gridMeasured.set(yMin, spline.getGridX1().getUmax() / (yMax - yMin), // y
                             zMin, spline.getGridX2().getUmax() / (zMax - zMin), // z
-                            zOut, geo.getZreadout(iSector));                    // correction scaling region
+                            zOut, geo.getTPCzLength());                         // correction scaling region
 
       info.gridReal = info.gridMeasured;
 
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index f8a03ce982460..63bedd1143ecb 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -256,30 +256,12 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
         { // grid for the measured coordinates
           float y0 = mGeo.getRowInfo(iRow).yMin;
           float yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(iRow).getYwidth();
-          float zReadout = mGeo.getZreadout(iSector);
           float zOut = mGeo.getTPCzLength() - oldSectorRowInfo.gridV0;
           float z0 = -3.;
           float zScale = spline.getGridX2().getUmax() / (zOut - z0);
-          if (iSector >= mGeo.getNumberOfSectorsA()) {
-            zOut = -zOut;
-            z0 = zOut;
-          }
-          newSectorRow.gridMeasured.set(y0, yScale, z0, zScale, zOut, zReadout);
-        }
-
-        { // grid for the real coordinates
-          float y0 = oldSectorRowInfo.gridCorrU0;
-          float yScale = oldSectorRowInfo.scaleCorrUtoGrid;
-          float zReadout = mGeo.getZreadout(iSector);
-          float zOut = mGeo.getTPCzLength() - oldSectorRowInfo.gridCorrV0;
-          float zScale = oldSectorRowInfo.scaleCorrVtoGrid;
-          float z0 = zOut - spline.getGridX2().getUmax() / zScale;
-          if (iSector >= mGeo.getNumberOfSectorsA()) {
-            zOut = -zOut;
-            z0 = zOut;
-          }
-          newSectorRow.gridReal.set(y0, yScale, z0, zScale, zOut, zReadout);
+          newSectorRow.gridMeasured.set(y0, yScale, z0, zScale, zOut, mGeo.getTPCzLength());
         }
+        newSectorRow.gridReal = newSectorRow.gridMeasured;
       }
     }
   }
@@ -344,17 +326,17 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
           }
         };
 
-        // reorder knots for the A side Y == old U, Z == - old V
+        // reorder knots for the A side U == old U, V == - old V
         if (isAside) {
           for (int32_t i = 0; i < spline.getGridX1().getNumberOfKnots(); i++) {
             for (int32_t j = 0; j < spline.getGridX2().getNumberOfKnots() / 2; j++) {
               swapKnots(i, j, i, spline.getGridX2().getNumberOfKnots() - 1 - j);
             }
           }
-        } else { // reorder knots for the C side Y == - old U, Z == old V
+        } else { // reorder knots for the C side U == - old U, V == - old V
           for (int32_t i = 0; i < spline.getGridX1().getNumberOfKnots() / 2; i++) {
             for (int32_t j = 0; j < spline.getGridX2().getNumberOfKnots(); j++) {
-              swapKnots(i, j, spline.getGridX1().getNumberOfKnots() - 1 - i, j);
+              swapKnots(i, j, spline.getGridX1().getNumberOfKnots() - 1 - i, spline.getGridX2().getNumberOfKnots() - 1 - j);
             }
           }
         }
@@ -366,10 +348,11 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
           for (int iDim = 0; iDim < nDim; iDim++) {
             if (isAside) {
               data[nKnotParameters * iKnot + nDim * 1 + iDim] *= -1; // invert Z derivatives on A side
+              data[nKnotParameters * iKnot + nDim * 3 + iDim] *= -1; // invert cross derivatives on A side
             } else {
+              data[nKnotParameters * iKnot + nDim * 1 + iDim] *= -1; // invert Z derivatives on C side
               data[nKnotParameters * iKnot + nDim * 2 + iDim] *= -1; // invert Y derivatives on C side
             }
-            data[nKnotParameters * iKnot + nDim * 3 + iDim] *= -1; // invert cross derivatives on both sides
           }
           // new correction directions
           if (iSpline == 0) { // dX,dU,dV -> dX,dY,dZ
@@ -631,9 +614,7 @@ GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
       float yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getYwidth();
       float z0 = mGeo.getZmin(sector);
       float zScale = spline.getGridX2().getUmax() / mGeo.getTPCzLength();
-      float zReadout = mGeo.getZreadout(sector);
-      info.gridMeasured.set(y0, yScale, z0, zScale, zReadout, zReadout);
-
+      info.gridMeasured.set(y0, yScale, z0, zScale, mGeo.getTPCzLength(), mGeo.getTPCzLength());
       info.gridReal = info.gridMeasured;
     } // row
   } // sector
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index c3f8107461305..025b0c394e945 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -79,18 +79,24 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     }
 
     /// convert local y, z to internal grid coordinates u,v, and spline scale
-    GPUdi() void convLocalToGridUntruncated(float y, float z, float& u, float& v, float& s) const
+    GPUdi() void convLocalToGridUntruncated(int sector, float y, float z, float& u, float& v, float& s) const
     {
+      if (sector >= TPCFastTransformGeo::getNumberOfSectorsA()) {
+        z = -z;
+      }
       u = (y - y0) * yScale;
       v = (z - z0) * zScale;
       s = getSpineScaleForZ(z);
     }
 
     /// convert internal grid coordinates u,v to local y, z
-    GPUdi() void convGridToLocal(float gridU, float gridV, float& y, float& z) const
+    GPUdi() void convGridToLocal(int sector, float gridU, float gridV, float& y, float& z) const
     {
       y = y0 + gridU / yScale;
       z = z0 + gridV / zScale;
+      if (sector >= TPCFastTransformGeo::getNumberOfSectorsA()) {
+        z = -z;
+      }
     }
     ClassDefNV(GridInfo, 1);
   };
@@ -395,7 +401,7 @@ GPUdi() void TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
   const SplineType& spline = getSpline(sector, row);
-  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z, u, v, s);
+  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
   // shrink to the grid
   u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
   v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
@@ -405,7 +411,7 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int
 {
   /// check if local y, z are inside the grid
   float u, v, s;
-  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z, u, v, s);
+  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
   const auto& spline = getSpline(sector, row);
   // shrink to the grid
   if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
@@ -419,7 +425,7 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isRealLocalInsideGrid(int32_t sector,
 {
   /// check if local y, z are inside the grid
   float u, v, s;
-  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z, u, v, s);
+  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
   const auto& spline = getSpline(sector, row);
   // shrink to the grid
   if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
@@ -432,14 +438,14 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isRealLocalInsideGrid(int32_t sector,
 GPUdi() void TPCFastSpaceChargeCorrection::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to local y, z
-  getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(gridU, gridV, y, z);
+  getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(sector, gridU, gridV, y, z);
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const
 {
   /// convert real y, z to the internal grid coordinates + scale
   const SplineType& spline = getSpline(sector, row);
-  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z, u, v, s);
+  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
   // shrink to the grid
   u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
   v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
@@ -448,7 +454,7 @@ GPUdi() void TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, i
 GPUdi() void TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to the real y, z
-  getSectorRowInfo(sector, row).gridReal.convGridToLocal(gridU, gridV, y, z);
+  getSectorRowInfo(sector, row).gridReal.convGridToLocal(sector, gridU, gridV, y, z);
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 23092c57b7e49..73ac78cdc6e24 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -142,7 +142,6 @@ class TPCFastTransformGeo
 #endif
   GPUd() float getZmin(int32_t sector) const;
   GPUd() float getZmax(int32_t sector) const;
-  GPUd() float getZreadout(int32_t sector) const;
 
   /// _______________  Conversion of coordinate systems __________
 
@@ -294,16 +293,6 @@ GPUdi() float TPCFastTransformGeo::getZmax(int32_t sector) const
   }
 }
 
-GPUdi() float TPCFastTransformGeo::getZreadout(int32_t sector) const
-{
-  /// z readout for the sector
-  if (sector < NumberOfSectorsA) { // TPC side A
-    return mTPCzLength;
-  } else { // TPC side C
-    return -mTPCzLength;
-  }
-}
-
 GPUdi() void TPCFastTransformGeo::convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z, float& pad, float& l) const
 {
   /// convert Local c.s. -> Pad, DriftLength
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index 8967b94a80780..ab9f4f183360e 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -242,6 +242,7 @@ class TPCFastTransformPOD
 
   static constexpr int NROWS = o2::tpc::constants::MAXGLOBALPADROW;
   static constexpr int NSECTORS = o2::tpc::constants::MAXSECTOR;
+  static constexpr int NSECTORSA = o2::tpc::constants::MAXSECTOR / 2;
   static constexpr int NSplineIDs = 3; ///< number of spline data sets for each sector/row
 
  private:
@@ -369,7 +370,7 @@ GPUdi() void TPCFastTransformPOD::convLocalToGrid(int32_t sector, int32_t row, f
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
   const SplineType& spline = getSpline(sector, row);
-  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z, u, v, s);
+  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
   // shrink to the grid
   u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
   v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
@@ -378,14 +379,14 @@ GPUdi() void TPCFastTransformPOD::convLocalToGrid(int32_t sector, int32_t row, f
 GPUdi() void TPCFastTransformPOD::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to local y, z
-  getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(gridU, gridV, y, z);
+  getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(sector, gridU, gridV, y, z);
 }
 
 GPUdi() void TPCFastTransformPOD::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const
 {
   /// convert real y, z to the internal grid coordinates + scale
   const SplineType& spline = getSpline(sector, row);
-  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z, u, v, s);
+  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
   // shrink to the grid
   u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
   v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
@@ -394,14 +395,14 @@ GPUdi() void TPCFastTransformPOD::convRealLocalToGrid(int32_t sector, int32_t ro
 GPUdi() void TPCFastTransformPOD::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to the real y, z
-  getSectorRowInfo(sector, row).gridReal.convGridToLocal(gridU, gridV, y, z);
+  getSectorRowInfo(sector, row).gridReal.convGridToLocal(sector, gridU, gridV, y, z);
 }
 
 GPUdi() bool TPCFastTransformPOD::isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// check if local y, z are inside the grid
   float u, v, s;
-  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(y, z, u, v, s);
+  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
   const auto& spline = getSpline(sector, row);
   // shrink to the grid
   if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
@@ -415,7 +416,7 @@ GPUdi() bool TPCFastTransformPOD::isRealLocalInsideGrid(int32_t sector, int32_t
 {
   /// check if local y, z are inside the grid
   float u, v, s;
-  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(y, z, u, v, s);
+  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
   const auto& spline = getSpline(sector, row);
   // shrink to the grid
   if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 973fda78f3047..583c2f0c812f5 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -180,7 +180,8 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
     const char* fileName = outFileName;
 
-     //fileName = "~/alidock/test/master/TPCFastTransform_VoxRes.root";
+    // file with the old data format
+    // fileName = "~/alidock/test/master/TPCFastTransform_VoxRes.root";
 
     std::cout << "load corrections from file " << fileName << std::endl;
 

From 7d39c1804859b0afddbcba2671dad613b24b1a35 Mon Sep 17 00:00:00 2001
From: "se.gorbunov" <se.gorbunov@gsi.de>
Date: Thu, 16 Apr 2026 00:12:53 +0200
Subject: [PATCH 1638/1764] TPCFastTransform: reduce the metadata: the same
 spline setup for all the sectors

---
 .../TPCFastSpaceChargeCorrectionHelper.cxx    |  97 +++++-----
 .../CorrectionMapsHelper.h                    |   2 +-
 .../TPCFastSpaceChargeCorrection.cxx          | 172 ++++++++----------
 .../TPCFastSpaceChargeCorrection.h            |  99 +++++-----
 .../TPCFastTransformPOD.cxx                   |  71 ++++----
 .../TPCFastTransformPOD.h                     |  48 ++---
 .../TPCFastTransformationLinkDef_O2.h         |   4 +-
 .../macro/TPCFastTransformInit.C              |  27 ++-
 8 files changed, 244 insertions(+), 276 deletions(-)

diff --git a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
index 40946d55b7de2..5a26dabaa2db5 100644
--- a/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
+++ b/Detectors/TPC/calibration/src/TPCFastSpaceChargeCorrectionHelper.cxx
@@ -137,7 +137,7 @@ void TPCFastSpaceChargeCorrectionHelper::fillSpaceChargeCorrectionFromMap(TPCFas
     auto myThread = [&](int iThread) {
       for (int row = iThread; row < correction.getGeometry().getNumberOfRows(); row += mNthreads) {
 
-        TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSpline(sector, row);
+        TPCFastSpaceChargeCorrection::SplineType& spline = correction.getSplineForRow(row);
         Spline2DHelper<float> helper;
         std::vector<float> splineParameters;
         splineParameters.resize(spline.getNumberOfParameters());
@@ -256,14 +256,12 @@ std::unique_ptr<TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrectionHelper
     correction.startConstruction(mGeo, nCorrectionScenarios);
 
     // assign spline type for TPC rows
-    for (int sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
-      for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
-        int scenario = row / 10;
-        if (scenario >= nCorrectionScenarios) {
-          scenario = nCorrectionScenarios - 1;
-        }
-        correction.setRowScenarioID(sector, row, scenario);
+    for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
+      int scenario = row / 10;
+      if (scenario >= nCorrectionScenarios) {
+        scenario = nCorrectionScenarios - 1;
       }
+      correction.setRowScenarioID(row, scenario);
     }
 
     for (int scenario = 0; scenario < nCorrectionScenarios; scenario++) {
@@ -473,47 +471,41 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
   { // create the correction object
 
-    const int nCorrectionScenarios = 2; // different grids for TPC A and TPC C sides
+    const int nCorrectionScenarios = 1;
 
     correction.startConstruction(geo, nCorrectionScenarios);
 
     // init rows
-    for (int iSector = 0; iSector < nSectors; iSector++) {
-      int id = iSector < geo.getNumberOfSectorsA() ? 0 : 1;
-      for (int row = 0; row < geo.getNumberOfRows(); row++) {
-        correction.setRowScenarioID(iSector, row, id);
-      }
+    for (int row = 0; row < geo.getNumberOfRows(); row++) {
+      correction.setRowScenarioID(row, 0);
     }
+
     { // init spline scenario
       TPCFastSpaceChargeCorrection::SplineType spline;
       spline.recreate(nKnotsY, &yKnotsInt[0], nKnotsZ, &zKnotsInt[0]);
       correction.setSplineScenario(0, spline);
-      spline.recreate(nKnotsY, &yKnotsInt[0], nKnotsZ, &zKnotsInt[0]);
-      correction.setSplineScenario(1, spline);
     }
     correction.finishConstruction();
   } // .. create the correction object
 
   // set the grid borders
-  for (int iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
-    for (int iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
-      auto& info = correction.getSectorRowInfo(iSector, iRow);
-      const auto& spline = correction.getSpline(iSector, iRow);
-      double rowX = geo.getRowInfo(iRow).x;
-      double yMin = rowX * trackResiduals.getY2X(iRow, 0);
-      double yMax = rowX * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
-      double zMin = rowX * trackResiduals.getZ2X(0);
-      double zMax = rowX * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
-      double zOut = zMax;
-      info.gridMeasured.set(yMin, spline.getGridX1().getUmax() / (yMax - yMin), // y
-                            zMin, spline.getGridX2().getUmax() / (zMax - zMin), // z
-                            zOut, geo.getTPCzLength());                         // correction scaling region
-
-      info.gridReal = info.gridMeasured;
-
-      // std::cout << " iSector " << iSector << " iRow " << iRow << " uMin: " << uMin << " uMax: " << uMax << " vMin: " << vMin << " vMax: " << vMax
-      //<< " grid scale u "<< info.scaleUtoGrid << " grid scale v "<< info.scaleVtoGrid<< std::endl;
-    }
+  for (int iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
+    auto& info = correction.getRowInfo(iRow);
+    const auto& spline = correction.getSplineForRow(iRow);
+    double rowX = geo.getRowInfo(iRow).x;
+    double yMin = rowX * trackResiduals.getY2X(iRow, 0);
+    double yMax = rowX * trackResiduals.getY2X(iRow, trackResiduals.getNY2XBins() - 1);
+    double zMin = rowX * trackResiduals.getZ2X(0);
+    double zMax = rowX * trackResiduals.getZ2X(trackResiduals.getNZ2XBins() - 1);
+    double zOut = zMax;
+    info.gridMeasured.set(yMin, spline.getGridX1().getUmax() / (yMax - yMin), // y
+                          zMin, spline.getGridX2().getUmax() / (zMax - zMin), // z
+                          zOut, geo.getTPCzLength());                         // correction scaling region
+
+    info.gridReal = info.gridMeasured;
+
+    // std::cout << " iSector " << iSector << " iRow " << iRow << " uMin: " << uMin << " uMax: " << uMax << " vMin: " << vMin << " vMax: " << vMax
+    //<< " grid scale u "<< info.scaleUtoGrid << " grid scale v "<< info.scaleVtoGrid<< std::endl;
   }
 
   LOG(info) << "fast space charge correction helper: preparation took " << watch1.RealTime() << "s";
@@ -765,8 +757,8 @@ std::unique_ptr<o2::gpu::TPCFastSpaceChargeCorrection> TPCFastSpaceChargeCorrect
 
           // feed the row data to the helper
 
-          auto& info = correction.getSectorRowInfo(iSector, iRow);
-          const auto& spline = correction.getSpline(iSector, iRow);
+          auto& info = correction.getRowInfo(iRow);
+          const auto& spline = correction.getSplineForRow(iRow);
 
           auto addVoxel = [&](int iy, int iz, double weight) {
             auto& vox = vRowVoxels[iy * nZ2Xbins + iz];
@@ -910,6 +902,11 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
   tpcR2max = tpcR2max / cos(2 * M_PI / mGeo.getNumberOfSectorsA() / 2) + 1.;
   tpcR2max = tpcR2max * tpcR2max;
 
+  for (int row = 0; row < mGeo.getNumberOfRows(); row++) {
+    auto& rowInfo = correction.getRowInfo(row);
+    rowInfo.gridReal = rowInfo.gridMeasured;
+  }
+
   for (int sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
     // LOG(info) << "inverse transform for sector " << sector ;
 
@@ -918,10 +915,9 @@ void TPCFastSpaceChargeCorrectionHelper::initInverse(std::vector<o2::gpu::TPCFas
       std::vector<float> splineParameters;
 
       for (int row = iThread; row < mGeo.getNumberOfRows(); row += mNthreads) {
-        auto& sectorRowInfo = correction.getSectorRowInfo(sector, row);
-        sectorRowInfo.gridReal = sectorRowInfo.gridMeasured;
+        auto& rowInfo = correction.getRowInfo(row);
 
-        TPCFastSpaceChargeCorrection::SplineType spline = correction.getSpline(sector, row);
+        TPCFastSpaceChargeCorrection::SplineType spline = correction.getSplineForRow(row);
         helper.setSpline(spline, 10, 10);
 
         std::vector<double> gridU;
@@ -1032,14 +1028,13 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
 
     auto myThread = [&](int iThread) {
       for (int row = iThread; row < geo.getNumberOfRows(); row += mNthreads) {
-        const auto& spline = mainCorrection.getSpline(sector, row);
+        auto& rowInfo = mainCorrection.getRowInfo(row);
+        const auto& spline = mainCorrection.getSplineForRow(row);
 
         float* splineParameters = mainCorrection.getCorrectionData(sector, row);
         float* splineParametersInvX = mainCorrection.getCorrectionDataInvX(sector, row);
         float* splineParametersInvYZ = mainCorrection.getCorrectionDataInvYZ(sector, row);
 
-        auto& secRowInfo = mainCorrection.getSectorRowInfo(sector, row);
-
         constexpr int nKnotPar1d = 4;
         constexpr int nKnotPar2d = nKnotPar1d * 2;
         constexpr int nKnotPar3d = nKnotPar1d * 3;
@@ -1078,12 +1073,12 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
         for (int icorr = 0; icorr < additionalCorrections.size(); ++icorr) {
           const auto& corr = *(additionalCorrections[icorr].first);
           double scale = additionalCorrections[icorr].second;
-          auto& linfo = corr.getSectorRowInfo(sector, row);
+          auto& linfo = corr.getRowInfo(row);
 
-          double scaleU = secRowInfo.gridMeasured.getYscale() / linfo.gridMeasured.getYscale();
-          double scaleV = secRowInfo.gridMeasured.getZscale() / linfo.gridMeasured.getZscale();
-          double scaleRealU = secRowInfo.gridReal.getYscale() / linfo.gridReal.getYscale();
-          double scaleRealV = secRowInfo.gridReal.getZscale() / linfo.gridReal.getZscale();
+          double scaleU = rowInfo.gridMeasured.getYscale() / linfo.gridMeasured.getYscale();
+          double scaleV = rowInfo.gridMeasured.getZscale() / linfo.gridMeasured.getZscale();
+          double scaleRealU = rowInfo.gridReal.getYscale() / linfo.gridReal.getYscale();
+          double scaleRealV = rowInfo.gridReal.getZscale() / linfo.gridReal.getZscale();
 
           for (int iu = 0; iu < gridU.getNumberOfKnots(); iu++) {
             double u = gridU.getKnot(iu).u;
@@ -1100,7 +1095,7 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
                 corr.convLocalToGrid(sector, row, y, z, lu, lv, ls);
                 ls *= scale;
                 double parscale[4] = {ls, ls * scaleU, ls * scaleV, ls * ls * scaleU * scaleV};
-                const auto& spl = corr.getSpline(sector, row);
+                const auto& spl = corr.getSplineForRow(row);
                 spl.interpolateParametersAtU(corr.getCorrectionData(sector, row), lu, lv, P);
                 for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
                   for (int idim = 0; idim < 3; idim++, ind++) {
@@ -1118,7 +1113,7 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
               double parscale[4] = {ls, ls * scaleRealU, ls * scaleRealV, ls * ls * scaleRealU * scaleRealV};
 
               { // inverse X correction
-                corr.getSplineInvX(sector, row).interpolateParametersAtU(corr.getCorrectionDataInvX(sector, row), lu, lv, P);
+                corr.getSplineInvXforRow(row).interpolateParametersAtU(corr.getCorrectionDataInvX(sector, row), lu, lv, P);
                 for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
                   for (int idim = 0; idim < 1; idim++, ind++) {
                     splineParametersInvX[knotIndex * nKnotPar1d + ind] += parscale[ipar] * P[ind];
@@ -1127,7 +1122,7 @@ void TPCFastSpaceChargeCorrectionHelper::mergeCorrections(
               }
 
               { // inverse YZ correction
-                corr.getSplineInvYZ(sector, row).interpolateParametersAtU(corr.getCorrectionDataInvYZ(sector, row), lu, lv, P);
+                corr.getSplineInvYZforRow(row).interpolateParametersAtU(corr.getCorrectionDataInvYZ(sector, row), lu, lv, P);
                 for (int ipar = 0, ind = 0; ipar < nKnotPar1d; ++ipar) {
                   for (int idim = 0; idim < 2; idim++, ind++) {
                     splineParametersInvYZ[knotIndex * nKnotPar2d + ind] += parscale[ipar] * P[ind];
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.h b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
index 39c5ffc73b1da..095bb837eaacd 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.h
@@ -122,7 +122,7 @@ class CorrectionMapsHelper
   {
     if (mCorrMapMShape) {
       // just check for the first spline the number of knots which are 4 in case of default spline object
-      return mCorrMapMShape->getCorrection().getSpline(0, 0).getNumberOfKnots() == 4;
+      return mCorrMapMShape->getCorrection().getSplineForRow(0).getNumberOfKnots() == 4;
     }
     return true;
   }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 63bedd1143ecb..bcde0660a5d34 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -34,7 +34,7 @@ TPCFastSpaceChargeCorrection::TPCFastSpaceChargeCorrection()
     mScenarioPtr(nullptr),
     mTimeStamp(-1),
     mCorrectionData{nullptr, nullptr, nullptr},
-    mCorrectionDataSize{0, 0, 0}
+    mSectorDataSize{0, 0, 0}
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -61,7 +61,7 @@ void TPCFastSpaceChargeCorrection::destroy()
   mTimeStamp = -1;
   for (int32_t is = 0; is < 3; is++) {
     mCorrectionData[is] = nullptr;
-    mCorrectionDataSize[is] = 0;
+    mSectorDataSize[is] = 0;
   }
   FlatObject::destroy();
 }
@@ -98,9 +98,9 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
 
   mTimeStamp = obj.mTimeStamp;
 
-  mCorrectionDataSize[0] = obj.mCorrectionDataSize[0];
-  mCorrectionDataSize[1] = obj.mCorrectionDataSize[1];
-  mCorrectionDataSize[2] = obj.mCorrectionDataSize[2];
+  mSectorDataSize[0] = obj.mSectorDataSize[0];
+  mSectorDataSize[1] = obj.mSectorDataSize[1];
+  mSectorDataSize[2] = obj.mSectorDataSize[2];
 
   // variable-size data
   mScenarioPtr = obj.mScenarioPtr;
@@ -110,8 +110,8 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
 
   mClassVersion = obj.mClassVersion;
 
-  for (int32_t i = 0; i < TPCFastTransformGeo::getNumberOfSectors() * TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
-    mSectorRowInfos[i] = obj.mSectorRowInfos[i];
+  for (int32_t i = 0; i < TPCFastTransformGeo::getMaxNumberOfRows(); i++) {
+    mRowInfos[i] = obj.mRowInfos[i];
   }
 
   relocateBufferPointers(oldFlatBufferPtr, mFlatBufferPtr);
@@ -153,7 +153,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddressOld(char* actualFlatBuf
   for (int32_t is = 0; is < 3; is++) {
     size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
     mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
-    bufferSize = correctionDataOffset + mCorrectionDataSize[is];
+    bufferSize = correctionDataOffset + mSectorDataSize[is] * mGeo.getNumberOfSectors();
   }
 }
 
@@ -180,7 +180,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     for (int32_t is = 0; is < 3; is++) {
       size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
       mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
-      bufferSize = correctionDataOffset + mCorrectionDataSize[is];
+      bufferSize = correctionDataOffset + mSectorDataSize[is] * mGeo.getNumberOfSectors();
     }
     return;
   }
@@ -232,37 +232,31 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     auto* oldRowInfos = reinterpret_cast<RowInfoVersion3*>(mFlatBufferPtr + oldRowsOffset);
     auto* oldSectorRowInfos = reinterpret_cast<SectorRowInfoVersion3*>(mFlatBufferPtr + oldSectorRowsOffset);
 
-    size_t sectorDataSize[3];
-    for (int32_t is = 0; is < 3; is++) {
-      sectorDataSize[is] = mCorrectionDataSize[is] / mGeo.getNumberOfSectors();
-    }
-
-    for (int32_t iSector = 0; iSector < mGeo.getNumberOfSectors(); iSector++) {
+    int32_t iSector = 0;
 
-      for (int32_t iRow = 0; iRow < mGeo.getNumberOfRows(); iRow++) {
-        RowInfoVersion3& oldRowInfo = oldRowInfos[iRow];
-        SectorRowInfoVersion3& oldSectorRowInfo = oldSectorRowInfos[mGeo.getNumberOfRows() * iSector + iRow];
+    for (int32_t iRow = 0; iRow < mGeo.getNumberOfRows(); iRow++) {
+      RowInfoVersion3& oldRowInfo = oldRowInfos[iRow];
+      SectorRowInfoVersion3& oldSectorRowInfo = oldSectorRowInfos[mGeo.getNumberOfRows() * iSector + iRow];
 
-        // the spline buffer is not yet initialised, don't try to access knot positions etc
-        const auto& spline = oldScenarioPtr[oldRowInfo.splineScenarioID];
+      // the spline buffer is not yet initialised, don't try to access knot positions etc
+      const auto& spline = oldScenarioPtr[oldRowInfo.splineScenarioID];
 
-        SectorRowInfo& newSectorRow = getSectorRowInfo(iSector, iRow);
+      RowInfo& newRowInfo = getRowInfo(iRow);
 
-        newSectorRow.splineScenarioID = oldRowInfo.splineScenarioID;
-        for (int32_t is = 0; is < 3; is++) {
-          newSectorRow.dataOffsetBytes[is] = sectorDataSize[is] * iSector + oldRowInfo.dataOffsetBytes[is];
-        }
+      newRowInfo.splineScenarioID = oldRowInfo.splineScenarioID;
+      for (int32_t is = 0; is < 3; is++) {
+        newRowInfo.dataOffsetBytes[is] = oldRowInfo.dataOffsetBytes[is];
+      }
 
-        { // grid for the measured coordinates
-          float y0 = mGeo.getRowInfo(iRow).yMin;
-          float yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(iRow).getYwidth();
-          float zOut = mGeo.getTPCzLength() - oldSectorRowInfo.gridV0;
-          float z0 = -3.;
-          float zScale = spline.getGridX2().getUmax() / (zOut - z0);
-          newSectorRow.gridMeasured.set(y0, yScale, z0, zScale, zOut, mGeo.getTPCzLength());
-        }
-        newSectorRow.gridReal = newSectorRow.gridMeasured;
+      { // grid for the measured coordinates
+        float y0 = mGeo.getRowInfo(iRow).yMin;
+        float yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(iRow).getYwidth();
+        float zOut = mGeo.getTPCzLength() - oldSectorRowInfo.gridV0;
+        float z0 = -3.;
+        float zScale = spline.getGridX2().getUmax() / (zOut - z0);
+        newRowInfo.gridMeasured.set(y0, yScale, z0, zScale, zOut, mGeo.getTPCzLength());
       }
+      newRowInfo.gridReal = newRowInfo.gridMeasured;
     }
   }
 
@@ -295,9 +289,9 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     size_t oldCorrectionDataOffset = alignSize(oldBufferSize, SplineType::getParameterAlignmentBytes());
     size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
     mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
-    memmove(mCorrectionData[is], mFlatBufferPtr + oldCorrectionDataOffset, mCorrectionDataSize[is]);
-    oldBufferSize = oldCorrectionDataOffset + mCorrectionDataSize[is];
-    bufferSize = correctionDataOffset + mCorrectionDataSize[is];
+    memmove(mCorrectionData[is], mFlatBufferPtr + oldCorrectionDataOffset, mSectorDataSize[is] * mGeo.getNumberOfSectors());
+    oldBufferSize = oldCorrectionDataOffset + mSectorDataSize[is] * mGeo.getNumberOfSectors();
+    bufferSize = correctionDataOffset + mSectorDataSize[is] * mGeo.getNumberOfSectors();
   }
 
   mFlatBufferSize = bufferSize;
@@ -307,8 +301,8 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     bool isAside = (iSector < mGeo.getNumberOfSectorsA());
     for (int32_t iRow = 0; iRow < mGeo.getNumberOfRows(); iRow++) {
 
-      SectorRowInfo& sectorRow = getSectorRowInfo(iSector, iRow);
-      const auto& spline = mScenarioPtr[sectorRow.splineScenarioID];
+      RowInfo& rowInfo = getRowInfo(iRow);
+      const auto& spline = mScenarioPtr[rowInfo.splineScenarioID];
 
       int nSplineDimensions[3] = {3, 1, 2};
 
@@ -421,7 +415,7 @@ void TPCFastSpaceChargeCorrection::print() const
   mGeo.print();
   LOG(info) << "  mNumberOfScenarios = " << mNumberOfScenarios;
   LOG(info) << "  mTimeStamp = " << mTimeStamp;
-  LOG(info) << "  mCorrectionDataSize = " << mCorrectionDataSize[0] << " " << mCorrectionDataSize[1] << " " << mCorrectionDataSize[2];
+  LOG(info) << "  mSectorDataSize = " << mSectorDataSize[0] << " " << mSectorDataSize[1] << " " << mSectorDataSize[2];
 
   if (mScenarioPtr) {
     for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -434,7 +428,7 @@ void TPCFastSpaceChargeCorrection::print() const
     for (int32_t is = 0; is < mGeo.getNumberOfSectors(); is++) {
       for (int32_t ir = 0; ir < mGeo.getNumberOfRows(); ir++) {
         LOG(info) << "sector " << is << " row " << ir << ": ";
-        const SplineType& spline = getSpline(is, ir);
+        const SplineType& spline = getSplineForRow(ir);
         const float* d = getCorrectionData(is, ir);
         int32_t k = 0;
         for (int32_t i = 0; i < spline.getGridX1().getNumberOfKnots(); i++) {
@@ -467,16 +461,14 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
 
   assert(mConstructionScenarios != nullptr);
 
-  for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
-    for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
-      auto& row = mSectorRowInfos[mGeo.getMaxNumberOfRows() * i + j];
-      row.splineScenarioID = -1;
-      row.gridReal = {};
-      row.gridMeasured = {};
-      row.dataOffsetBytes[0] = 0;
-      row.dataOffsetBytes[1] = 0;
-      row.dataOffsetBytes[2] = 0;
-    }
+  for (int32_t i = 0; i < mGeo.getNumberOfRows(); i++) {
+    auto& row = mRowInfos[i];
+    row.splineScenarioID = -1;
+    row.gridReal = {};
+    row.gridMeasured = {};
+    row.dataOffsetBytes[0] = 0;
+    row.dataOffsetBytes[1] = 0;
+    row.dataOffsetBytes[2] = 0;
   }
 
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -488,18 +480,17 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
   mScenarioPtr = nullptr;
   for (int32_t s = 0; s < 3; s++) {
     mCorrectionData[s] = nullptr;
-    mCorrectionDataSize[s] = 0;
+    mSectorDataSize[s] = 0;
   }
   mClassVersion = 4;
 }
 
-void TPCFastSpaceChargeCorrection::setRowScenarioID(int32_t iSector, int32_t iRow, int32_t iScenario)
+void TPCFastSpaceChargeCorrection::setRowScenarioID(int32_t iRow, int32_t iScenario)
 {
   /// Initializes a TPC row
   assert(mConstructionMask & ConstructionState::InProgress);
-  assert(iSector >= 0 && iSector < mGeo.getNumberOfSectors());
   assert(iRow >= 0 && iRow < mGeo.getNumberOfRows() && iScenario >= 0 && iScenario < mNumberOfScenarios);
-  auto& row = getSectorRowInfo(iSector, iRow);
+  auto& row = getRowInfo(iRow);
   row.splineScenarioID = iScenario;
   for (int32_t s = 0; s < 3; s++) {
     row.dataOffsetBytes[s] = 0;
@@ -522,12 +513,10 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 
   assert(mConstructionMask & ConstructionState::InProgress);
 
-  for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
-    for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
-      [[maybe_unused]] SectorRowInfo& row = getSectorRowInfo(i, j);
-      assert(row.splineScenarioID >= 0);
-      assert(row.splineScenarioID < mNumberOfScenarios);
-    }
+  for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
+    [[maybe_unused]] RowInfo& row = getRowInfo(j);
+    assert(row.splineScenarioID >= 0);
+    assert(row.splineScenarioID < mNumberOfScenarios);
   }
 
   for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -552,17 +541,15 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   size_t correctionDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
     correctionDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mCorrectionDataSize[is] = 0;
-    for (int32_t i = 0; i < mGeo.getNumberOfSectors(); i++) {
-      for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
-        SectorRowInfo& row = getSectorRowInfo(i, j);
-        SplineType& spline = mConstructionScenarios[row.splineScenarioID];
-        row.dataOffsetBytes[is] = alignSize(mCorrectionDataSize[is], SplineType::getParameterAlignmentBytes());
-        mCorrectionDataSize[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
-      }
+    mSectorDataSize[is] = 0;
+    for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
+      RowInfo& row = getRowInfo(j);
+      SplineType& spline = mConstructionScenarios[row.splineScenarioID];
+      row.dataOffsetBytes[is] = alignSize(mSectorDataSize[is], SplineType::getParameterAlignmentBytes());
+      mSectorDataSize[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
     }
-    mCorrectionDataSize[is] = alignSize(mCorrectionDataSize[is], SplineType::getParameterAlignmentBytes());
-    bufferSize = correctionDataOffset[is] + mCorrectionDataSize[is];
+    mSectorDataSize[is] = alignSize(mSectorDataSize[is], SplineType::getParameterAlignmentBytes());
+    bufferSize = correctionDataOffset[is] + mSectorDataSize[is] * mGeo.getNumberOfSectors();
   }
 
   FlatObject::finishConstruction(bufferSize);
@@ -589,33 +576,34 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
 GPUd() void TPCFastSpaceChargeCorrection::setNoCorrection()
 {
   // initialise all corrections to 0.
-  for (int32_t sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
 
-    for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
-      const SplineType& spline = getSpline(sector, row);
+  for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
+    const SplineType& spline = getSplineForRow(row);
+    RowInfo& info = getRowInfo(row);
+    float y0 = mGeo.getRowInfo(row).getYmin();
+    float yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getYwidth();
+    float z0 = 0.;
+    float zScale = spline.getGridX2().getUmax() / mGeo.getTPCzLength();
+    info.gridMeasured.set(y0, yScale, z0, zScale, mGeo.getTPCzLength(), mGeo.getTPCzLength());
+    info.gridReal = info.gridMeasured;
+  } // row
 
+  for (int32_t sector = 0; sector < mGeo.getNumberOfSectors(); sector++) {
+    for (int32_t row = 0; row < mGeo.getNumberOfRows(); row++) {
       for (int32_t is = 0; is < 3; is++) {
         float* data = getCorrectionData(sector, row, is);
-        int32_t nPar = spline.getNumberOfParameters();
-        if (is == 1) {
-          nPar = nPar / 3;
-        }
-        if (is == 2) {
-          nPar = nPar * 2 / 3;
+        int32_t nPar = 0;
+        if (is == 0) {
+          nPar = getSplineForRow(row).getNumberOfParameters();
+        } else if (is == 1) {
+          nPar = getSplineInvXforRow(row).getNumberOfParameters();
+        } else if (is == 2) {
+          nPar = getSplineInvYZforRow(row).getNumberOfParameters();
         }
         for (int32_t i = 0; i < nPar; i++) {
           data[i] = 0.f;
         }
       }
-
-      SectorRowInfo& info = getSectorRowInfo(sector, row);
-
-      float y0 = mGeo.getRowInfo(row).getYmin();
-      float yScale = spline.getGridX1().getUmax() / mGeo.getRowInfo(row).getYwidth();
-      float z0 = mGeo.getZmin(sector);
-      float zScale = spline.getGridX2().getUmax() / mGeo.getTPCzLength();
-      info.gridMeasured.set(y0, yScale, z0, zScale, mGeo.getTPCzLength(), mGeo.getTPCzLength());
-      info.gridReal = info.gridMeasured;
     } // row
   } // sector
 }
@@ -624,10 +612,8 @@ void TPCFastSpaceChargeCorrection::constructWithNoCorrection(const TPCFastTransf
 {
   const int32_t nCorrectionScenarios = 1;
   startConstruction(geo, nCorrectionScenarios);
-  for (int32_t sector = 0; sector < geo.getNumberOfSectors(); sector++) {
-    for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
-      setRowScenarioID(sector, row, 0);
-    }
+  for (int32_t row = 0; row < geo.getNumberOfRows(); row++) {
+    setRowScenarioID(row, 0);
   }
   {
     TPCFastSpaceChargeCorrection::SplineType spline;
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index 025b0c394e945..edb80bc530b9a 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -42,7 +42,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   friend class TPCFastTransformPOD;
 
  public:
-  // obsolete structure, declared here only for backward compatibility
+  // obsolete structure, declared here only for the backward compatibility
   struct SliceInfo {
     ClassDefNV(SliceInfo, 2);
   };
@@ -101,14 +101,14 @@ class TPCFastSpaceChargeCorrection : public FlatObject
     ClassDefNV(GridInfo, 1);
   };
 
-  struct SectorRowInfo {
+  struct RowInfo {
     int32_t splineScenarioID{0};  ///< scenario index (which of Spline2D splines to use)
     size_t dataOffsetBytes[3]{0}; ///< offset for the spline data withing a TPC sector
 
-    GridInfo gridMeasured; ///< grid info for measured coordinates
-    GridInfo gridReal;     ///< grid info for real coordinates
+    GridInfo gridMeasured; ///< grid info for the measured coordinates
+    GridInfo gridReal;     ///< grid info for the real coordinates
 
-    ClassDefNV(SectorRowInfo, 2);
+    ClassDefNV(RowInfo, 2);
   };
 
   typedef Spline2D<float, 3> SplineTypeXYZ;
@@ -166,7 +166,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   void startConstruction(const TPCFastTransformGeo& geo, int32_t numberOfSplineScenarios);
 
   /// Initializes a TPC row
-  void setRowScenarioID(int32_t iSector, int32_t iRow, int32_t iScenario);
+  void setRowScenarioID(int32_t iRow, int32_t iScenario);
 
   /// Sets approximation scenario
   void setSplineScenario(int32_t scenarioIndex, const SplineType& spline);
@@ -185,10 +185,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUdi() void setTimeStamp(int64_t v) { mTimeStamp = v; }
 
   /// Gives const pointer to a spline
-  GPUd() const SplineType& getSpline(int32_t sector, int32_t row) const;
+  GPUd() const SplineType& getSplineForRow(int32_t row) const;
 
   /// Gives pointer to a spline
-  GPUd() SplineType& getSpline(int32_t sector, int32_t row);
+  GPUd() SplineType& getSplineForRow(int32_t row);
 
   /// Gives pointer to spline data
   GPUd() float* getCorrectionData(int32_t sector, int32_t row, int32_t iSpline = 0);
@@ -197,10 +197,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() const float* getCorrectionData(int32_t sector, int32_t row, int32_t iSpline = 0) const;
 
   /// Gives const pointer to a spline for the inverse X correction
-  GPUd() const SplineTypeInvX& getSplineInvX(int32_t sector, int32_t row) const;
+  GPUd() const SplineTypeInvX& getSplineInvXforRow(int32_t row) const;
 
   /// Gives pointer to a spline for the inverse X correction
-  GPUd() SplineTypeInvX& getSplineInvX(int32_t sector, int32_t row);
+  GPUd() SplineTypeInvX& getSplineInvXforRow(int32_t row);
 
   /// Gives pointer to spline data for the inverse X correction
   GPUd() float* getCorrectionDataInvX(int32_t sector, int32_t row);
@@ -209,10 +209,10 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   GPUd() const float* getCorrectionDataInvX(int32_t sector, int32_t row) const;
 
   /// Gives const pointer to a spline for the inverse YZ correction
-  GPUd() const SplineTypeInvYZ& getSplineInvYZ(int32_t sector, int32_t row) const;
+  GPUd() const SplineTypeInvYZ& getSplineInvYZforRow(int32_t row) const;
 
   /// Gives pointer to a spline for the inverse YZ correction
-  GPUd() SplineTypeInvYZ& getSplineInvYZ(int32_t sector, int32_t row);
+  GPUd() SplineTypeInvYZ& getSplineInvYZforRow(int32_t row);
 
   /// Gives pointer to spline data for the inverse YZ correction
   GPUd() float* getCorrectionDataInvYZ(int32_t sector, int32_t row);
@@ -262,16 +262,16 @@ class TPCFastSpaceChargeCorrection : public FlatObject
   /// Gives the time stamp of the current calibaration parameters
   int64_t getTimeStamp() const { return mTimeStamp; }
 
-  /// Gives TPC sector & row info
-  GPUdi() const SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) const
+  /// Gives TPC row info
+  GPUdi() const RowInfo& getRowInfo(int32_t row) const
   {
-    return mSectorRowInfos[mGeo.getMaxNumberOfRows() * sector + row];
+    return mRowInfos[row];
   }
 
-  /// Gives TPC sector & row info
-  GPUdi() SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row)
+  /// Gives TPC row info
+  GPUdi() RowInfo& getRowInfo(int32_t row)
   {
-    return mSectorRowInfos[mGeo.getMaxNumberOfRows() * sector + row];
+    return mRowInfos[row];
   }
 
 #if !defined(GPUCA_GPUCODE)
@@ -308,14 +308,14 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   char* mCorrectionData[3]; //! (transient!!) pointer to the spline data in the flat buffer
 
-  size_t mCorrectionDataSize[3]; ///< size of the data per transformation (direct, inverseX, inverse YZ) in the flat buffer
+  size_t mSectorDataSize[3]; ///< size of the sector data per transformation (direct, inverseX, inverse YZ) in the flat buffer
 
   /// Class version. It is used to read older versions from disc.
   /// The default version 3 is the one before this field was introduced.
   /// The actual version must be set in startConstruction().
   int32_t mClassVersion{3};
 
-  SectorRowInfo mSectorRowInfos[TPCFastTransformGeo::getNumberOfSectors() * TPCFastTransformGeo::getMaxNumberOfRows()]; ///< SectorRowInfo array
+  RowInfo mRowInfos[TPCFastTransformGeo::getMaxNumberOfRows()]; ///< RowInfo array
 
   ClassDefNV(TPCFastSpaceChargeCorrection, 4);
 };
@@ -324,40 +324,42 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 ///       Inline implementations of some methods
 /// ====================================================
 
-GPUdi() const TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t sector, int32_t row) const
+GPUdi() const TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSplineForRow(int32_t row) const
 {
   /// Gives const pointer to spline
-  return mScenarioPtr[getSectorRowInfo(sector, row).splineScenarioID];
+  return mScenarioPtr[getRowInfo(row).splineScenarioID];
 }
 
-GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSpline(int32_t sector, int32_t row)
+GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::getSplineForRow(int32_t row)
 {
   /// Gives pointer to spline
-  return mScenarioPtr[getSectorRowInfo(sector, row).splineScenarioID];
+  return mScenarioPtr[getRowInfo(row).splineScenarioID];
 }
 
 GPUdi() float* TPCFastSpaceChargeCorrection::getCorrectionData(int32_t sector, int32_t row, int32_t iSpline)
 {
   /// Gives pointer to spline data
-  return reinterpret_cast<float*>(mCorrectionData[iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]);
+  size_t offset = sector * mSectorDataSize[iSpline] + getRowInfo(row).dataOffsetBytes[iSpline];
+  return reinterpret_cast<float*>(mCorrectionData[iSpline] + offset);
 }
 
 GPUdi() const float* TPCFastSpaceChargeCorrection::getCorrectionData(int32_t sector, int32_t row, int32_t iSpline) const
 {
   /// Gives pointer to spline data
-  return reinterpret_cast<const float*>(mCorrectionData[iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]);
+  size_t offset = sector * mSectorDataSize[iSpline] + getRowInfo(row).dataOffsetBytes[iSpline];
+  return reinterpret_cast<const float*>(mCorrectionData[iSpline] + offset);
 }
 
-GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCorrection::getSplineInvX(int32_t sector, int32_t row)
+GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCorrection::getSplineInvXforRow(int32_t row)
 {
   /// Gives pointer to spline for the inverse X correction
-  return reinterpret_cast<SplineTypeInvX&>(getSpline(sector, row));
+  return reinterpret_cast<SplineTypeInvX&>(getSplineForRow(row));
 }
 
-GPUdi() const TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCorrection::getSplineInvX(int32_t sector, int32_t row) const
+GPUdi() const TPCFastSpaceChargeCorrection::SplineTypeInvX& TPCFastSpaceChargeCorrection::getSplineInvXforRow(int32_t row) const
 {
   /// Gives const pointer to spline for the inverse X correction
-  return reinterpret_cast<const SplineTypeInvX&>(getSpline(sector, row));
+  return reinterpret_cast<const SplineTypeInvX&>(getSplineForRow(row));
 }
 
 GPUdi() float* TPCFastSpaceChargeCorrection::getCorrectionDataInvX(int32_t sector, int32_t row)
@@ -372,16 +374,16 @@ GPUdi() const float* TPCFastSpaceChargeCorrection::getCorrectionDataInvX(int32_t
   return getCorrectionData(sector, row, 1);
 }
 
-GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvYZ& TPCFastSpaceChargeCorrection::getSplineInvYZ(int32_t sector, int32_t row)
+GPUdi() TPCFastSpaceChargeCorrection::SplineTypeInvYZ& TPCFastSpaceChargeCorrection::getSplineInvYZforRow(int32_t row)
 {
   /// Gives pointer to spline for the inverse YZ correction
-  return reinterpret_cast<SplineTypeInvYZ&>(getSpline(sector, row));
+  return reinterpret_cast<SplineTypeInvYZ&>(getSplineForRow(row));
 }
 
-GPUdi() const TPCFastSpaceChargeCorrection::SplineTypeInvYZ& TPCFastSpaceChargeCorrection::getSplineInvYZ(int32_t sector, int32_t row) const
+GPUdi() const TPCFastSpaceChargeCorrection::SplineTypeInvYZ& TPCFastSpaceChargeCorrection::getSplineInvYZforRow(int32_t row) const
 {
   /// Gives const pointer to spline for the inverse YZ correction
-  return reinterpret_cast<const SplineTypeInvYZ&>(getSpline(sector, row));
+  return reinterpret_cast<const SplineTypeInvYZ&>(getSplineForRow(row));
 }
 
 GPUdi() float* TPCFastSpaceChargeCorrection::getCorrectionDataInvYZ(int32_t sector, int32_t row)
@@ -400,8 +402,8 @@ GPUdi() void TPCFastSpaceChargeCorrection::convLocalToGrid(int32_t sector, int32
 {
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
-  const SplineType& spline = getSpline(sector, row);
-  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
+  const SplineType& spline = getSplineForRow(row);
+  getRowInfo(row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
   // shrink to the grid
   u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
   v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
@@ -411,8 +413,8 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isLocalInsideGrid(int32_t sector, int
 {
   /// check if local y, z are inside the grid
   float u, v, s;
-  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
-  const auto& spline = getSpline(sector, row);
+  getRowInfo(row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
+  const auto& spline = getSplineForRow(row);
   // shrink to the grid
   if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
       v < 0.f || v > (float)spline.getGridX2().getUmax()) {
@@ -425,8 +427,8 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isRealLocalInsideGrid(int32_t sector,
 {
   /// check if local y, z are inside the grid
   float u, v, s;
-  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
-  const auto& spline = getSpline(sector, row);
+  getRowInfo(row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
+  const auto& spline = getSplineForRow(row);
   // shrink to the grid
   if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
       v < 0.f || v > (float)spline.getGridX2().getUmax()) {
@@ -438,14 +440,14 @@ GPUdi() bool TPCFastSpaceChargeCorrection::isRealLocalInsideGrid(int32_t sector,
 GPUdi() void TPCFastSpaceChargeCorrection::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to local y, z
-  getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(sector, gridU, gridV, y, z);
+  getRowInfo(row).gridMeasured.convGridToLocal(sector, gridU, gridV, y, z);
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const
 {
   /// convert real y, z to the internal grid coordinates + scale
-  const SplineType& spline = getSpline(sector, row);
-  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
+  const SplineType& spline = getSplineForRow(row);
+  getRowInfo(row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
   // shrink to the grid
   u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
   v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
@@ -454,13 +456,12 @@ GPUdi() void TPCFastSpaceChargeCorrection::convRealLocalToGrid(int32_t sector, i
 GPUdi() void TPCFastSpaceChargeCorrection::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to the real y, z
-  getSectorRowInfo(sector, row).gridReal.convGridToLocal(sector, gridU, gridV, y, z);
+  getRowInfo(row).gridReal.convGridToLocal(sector, gridU, gridV, y, z);
 }
 
 GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const
 {
-  const auto& info = getSectorRowInfo(sector, row);
-  const SplineType& spline = getSpline(sector, row);
+  const SplineType& spline = getSplineForRow(row);
   const float* splineData = getCorrectionData(sector, row);
 
   float u, v, s;
@@ -480,11 +481,10 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionLocal(int32_t sector, in
 
 GPUdi() float TPCFastSpaceChargeCorrection::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
-  const auto& info = getSectorRowInfo(sector, row);
   float u, v, s;
   convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
   float dx = 0;
-  getSplineInvX(sector, row).interpolateAtU(getCorrectionDataInvX(sector, row), u, v, &dx);
+  getSplineInvXforRow(row).interpolateAtU(getCorrectionDataInvX(sector, row), u, v, &dx);
   if (CAMath::Abs(dx) > kMaxCorrection) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
@@ -495,9 +495,8 @@ GPUdi() void TPCFastSpaceChargeCorrection::getCorrectionYZatRealYZ(int32_t secto
 {
   float u, v, s;
   convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
-  const auto& info = getSectorRowInfo(sector, row);
   float dyz[2];
-  getSplineInvYZ(sector, row).interpolateAtU(getCorrectionDataInvYZ(sector, row), u, v, dyz);
+  getSplineInvYZforRow(row).interpolateAtU(getCorrectionDataInvYZ(sector, row), u, v, dyz);
   if (CAMath::Abs(dyz[0]) > kMaxCorrection || CAMath::Abs(dyz[1]) > kMaxCorrection) {
     s = 0.f; // TODO: DR: Protect from FPEs, fix upstream and remove once guaranteed that it is fixed
   }
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index 58635995a99c1..94420fbfd9152 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -67,19 +67,7 @@ size_t TPCFastTransformPOD::estimateSize(const TPCFastSpaceChargeCorrection& ori
   }
   // space for splines data
   for (int is = 0; is < 3; is++) {
-    for (int sector = 0; sector < origCorr.mGeo.getNumberOfSectors(); sector++) {
-      for (int row = 0; row < NROWS; row++) {
-        const auto& spline = origCorr.getSpline(sector, row);
-        int nPar = spline.getNumberOfParameters();
-        if (is == 1) {
-          nPar = nPar / 3;
-        }
-        if (is == 2) {
-          nPar = nPar * 2 / 3;
-        }
-        nextDynOffs += nPar * sizeof(float);
-      }
-    }
+    nextDynOffs += origCorr.mSectorDataSizeBytes[is] * TPCFastTransformGeo::getNumberOfSectors();
   }
   nextDynOffs = alignOffset(nextDynOffs);
   return nextDynOffs;
@@ -96,7 +84,7 @@ void TPCFastTransformPOD::print() const
     }
   }
   const size_t scenOffset = getScenarioOffset(0);
-  const auto& spline = getSpline(0, 0);
+  const auto& spline = getSplineForRow(0);
   LOGP(info, "scenOffset={} spline_addr={:p} expected={:p}", scenOffset, (void*)&spline, (void*)(getThis() + scenOffset));
 
   const float* splineData = getCorrectionData(0, 0);
@@ -120,11 +108,11 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
 
   // copy fixed size data --- start
   podMap.mNumberOfScenarios = origCorr.mNumberOfScenarios;
-  for (int sector = 0; sector < TPCFastTransformGeo::getNumberOfSectors(); sector++) {
-    for (int row = 0; row < NROWS; row++) {
-      podMap.mSectorRowInfos[NROWS * sector + row] = origCorr.getSectorRowInfo(sector, row);
-    }
+
+  for (int row = 0; row < NROWS; row++) {
+    podMap.mRowInfos[row] = origCorr.getRowInfo(row);
   }
+
   podMap.mTimeStamp = origCorr.mTimeStamp;
   //
   // init data members coming from the TPCFastTrasform
@@ -169,34 +157,37 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
     nextDynOffs = alignOffset(nextDynOffs + spline.getFlatBufferSize());
   }
 
-  // copy splines data
+  // copy spline data w/o memory alignment gaps between the sectors
   for (int is = 0; is < 3; is++) {
     float* data = reinterpret_cast<float*>(buff + nextDynOffs);
     LOGP(debug, "splinID={} start offset {} -> {}", is, nextDynOffs, (void*)data);
+
+    // metadata
+    size_t sectorDataSizeFloats = 0;
+    size_t sectorDataSizeBytes = 0;
+    for (int row = 0; row < NROWS; row++) {
+      podMap.getRowInfo(row).dataOffsetBytes[is] = sectorDataSizeBytes;
+      const auto& spline = origCorr.getSplineForRow(row);
+      int nPar = spline.getNumberOfParameters();
+      if (is == 1) {
+        nPar = nPar / 3;
+      }
+      if (is == 2) {
+        nPar = nPar * 2 / 3;
+      }
+      sectorDataSizeFloats += nPar;
+      sectorDataSizeBytes += nPar * sizeof(float);
+    }
+
     for (int sector = 0; sector < origCorr.mGeo.getNumberOfSectors(); sector++) {
       podMap.mSplineDataOffsets[sector][is] = nextDynOffs;
-      size_t rowDataOffs = 0;
-      for (int row = 0; row < NROWS; row++) {
-        const auto& spline = origCorr.getSpline(sector, row);
-        const float* dataOr = origCorr.getCorrectionData(sector, row, is);
-        int nPar = spline.getNumberOfParameters();
-        if (is == 1) {
-          nPar = nPar / 3;
-        }
-        if (is == 2) {
-          nPar = nPar * 2 / 3;
-        }
-        LOGP(debug, "Copying {} floats for spline{} of sector:{} row:{} to offset {}", nPar, is, sector, row, nextDynOffs);
-        size_t nbcopy = nPar * sizeof(float);
-        if (buffSize < nextDynOffs + nbcopy) {
-          throw std::runtime_error(fmt::format("attempt to copy {} bytes of data for spline{} of sector{}/row{} to {}, overflowing the buffer of size {}", nbcopy, is, sector, row, nextDynOffs, buffSize));
-        }
-        std::memcpy(data, dataOr, nbcopy);
-        podMap.getSectorRowInfo(sector, row).dataOffsetBytes[is] = rowDataOffs;
-        rowDataOffs += nbcopy;
-        data += nPar;
-        nextDynOffs += nbcopy;
+      if (buffSize < nextDynOffs + sectorDataSizeBytes) {
+        throw std::runtime_error(fmt::format("attempt to copy {} bytes of data for spline{} of sector{} to {}, overflowing the buffer of size {}", sectorDataSizeBytes, is, sector, nextDynOffs, buffSize));
       }
+      const float* dataOr = origCorr.getCorrectionData(sector, 0, is);
+      std::memcpy(data, dataOr, sectorDataSizeBytes);
+      data += sectorDataSizeFloats;
+      nextDynOffs += sectorDataSizeBytes;
     }
   }
   podMap.mTotalSize = alignOffset(nextDynOffs);
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index ab9f4f183360e..4d537b778cbb3 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -52,7 +52,7 @@ class TPCFastTransformPOD
  public:
   using SliceInfo = TPCFastSpaceChargeCorrection::SliceInfo; // obsolete
   using GridInfo = TPCFastSpaceChargeCorrection::GridInfo;
-  using SectorRowInfo = TPCFastSpaceChargeCorrection::SectorRowInfo;
+  using RowInfo = TPCFastSpaceChargeCorrection::RowInfo;
 
   using SplineTypeXYZ = TPCFastSpaceChargeCorrection::SlimSplineTypeXYZ;
   using SplineTypeInvX = TPCFastSpaceChargeCorrection::SlimSplineTypeInvX;
@@ -112,10 +112,10 @@ class TPCFastTransformPOD
   GPUd() const TPCFastTransformGeoPOD& getGeometry() const { return mGeo; }
 
   /// Gives TPC sector & row info
-  GPUd() const SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) const { return mSectorRowInfos[NROWS * sector + row]; }
+  GPUd() const RowInfo& getRowInfo(int32_t row) const { return mRowInfos[row]; }
 
   /// Gives TPC sector & row info
-  GPUd() SectorRowInfo& getSectorRowInfo(int32_t sector, int32_t row) { return mSectorRowInfos[NROWS * sector + row]; }
+  GPUd() RowInfo& getRowInfo(int32_t row) { return mRowInfos[row]; }
 
   /// Gives its own size including dynamic part
   GPUd() size_t size() const { return mTotalSize; }
@@ -162,19 +162,19 @@ class TPCFastTransformPOD
   GPUd() void setCalibration1(int64_t timeStamp, float t0, float vDrift);
 
   /// Gives a reference to a spline
-  GPUd() const SplineType& getSpline(int32_t sector, int32_t row) const { return *reinterpret_cast<const SplineType*>(getThis() + getScenarioOffset(getSectorRowInfo(sector, row).splineScenarioID)); }
+  GPUd() const SplineType& getSplineForRow(int32_t row) const { return *reinterpret_cast<const SplineType*>(getThis() + getScenarioOffset(getRowInfo(row).splineScenarioID)); }
 
   /// Gives pointer to spline data
-  GPUd() const float* getCorrectionData(int32_t sector, int32_t row, int32_t iSpline = 0) const { return reinterpret_cast<const float*>(getThis() + mSplineDataOffsets[sector][iSpline] + getSectorRowInfo(sector, row).dataOffsetBytes[iSpline]); }
+  GPUd() const float* getCorrectionData(int32_t sector, int32_t row, int32_t iSpline = 0) const { return reinterpret_cast<const float*>(getThis() + mSplineDataOffsets[sector][iSpline] + getRowInfo(row).dataOffsetBytes[iSpline]); }
 
   /// Gives const pointer to a spline for the inverse X correction
-  GPUd() const SplineTypeInvX& getSplineInvX(int32_t sector, int32_t row) const { return reinterpret_cast<const SplineTypeInvX&>(getSpline(sector, row)); }
+  GPUd() const SplineTypeInvX& getSplineInvXforRow(int32_t row) const { return reinterpret_cast<const SplineTypeInvX&>(getSplineForRow(row)); }
 
   /// Gives pointer to spline data for the inverse X correction
   GPUd() const float* getCorrectionDataInvX(int32_t sector, int32_t row) const { return getCorrectionData(sector, row, 1); }
 
   /// Gives const pointer to a spline for the inverse YZ correction
-  GPUd() const SplineTypeInvYZ& getSplineInvYZ(int32_t sector, int32_t row) const { return reinterpret_cast<const SplineTypeInvYZ&>(getSpline(sector, row)); }
+  GPUd() const SplineTypeInvYZ& getSplineInvYZforRow(int32_t row) const { return reinterpret_cast<const SplineTypeInvYZ&>(getSplineForRow(row)); }
 
   /// Gives pointer to spline data for the inverse YZ correction
   GPUd() const float* getCorrectionDataInvYZ(int32_t sector, int32_t row) const { return getCorrectionData(sector, row, 2); }
@@ -296,16 +296,16 @@ class TPCFastTransformPOD
   float mIDC;                                                                       ///< IDC estimator (for info only)
 
   TPCFastTransformGeoPOD mGeo; ///< TPC geometry information
-  SectorRowInfo mSectorRowInfos[NROWS * TPCFastTransformGeo::getNumberOfSectors()];
+  RowInfo mRowInfos[NROWS];
 
   ClassDefNV(TPCFastTransformPOD, 0);
 };
 
 GPUdi() void TPCFastTransformPOD::getCorrectionLocal(int32_t sector, int32_t row, float y, float z, float& dx, float& dy, float& dz) const
 {
-  const auto& info = getSectorRowInfo(sector, row);
+  const auto& info = getRowInfo(row);
   const int32_t isc = info.splineScenarioID;
-  const SplineType& spline = getSpline(sector, row);
+  const SplineType& spline = getSplineForRow(row);
   const float* splineData = getCorrectionData(sector, row);
 
   float u, v, s;
@@ -328,12 +328,12 @@ GPUdi() void TPCFastTransformPOD::getCorrectionLocal(int32_t sector, int32_t row
 
 GPUdi() float TPCFastTransformPOD::getCorrectionXatRealYZ(int32_t sector, int32_t row, float realY, float realZ) const
 {
-  const auto& info = getSectorRowInfo(sector, row);
+  const auto& info = getRowInfo(row);
   float u, v, s;
   convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
 
   const int32_t isc = info.splineScenarioID;
-  const auto& spline = getSplineInvX(sector, row);
+  const auto& spline = getSplineInvXforRow(row);
   const char* g1buf = getSplineFlatBuffer(isc);
   const char* g2buf = getGridX2FlatBuffer(spline, isc);
 
@@ -350,9 +350,9 @@ GPUdi() void TPCFastTransformPOD::getCorrectionYZatRealYZ(int32_t sector, int32_
 {
   float u, v, s;
   convRealLocalToGrid(sector, row, realY, realZ, u, v, s);
-  const auto& info = getSectorRowInfo(sector, row);
+  const auto& info = getRowInfo(row);
   const int32_t isc = info.splineScenarioID;
-  const auto& spline = getSplineInvYZ(sector, row);
+  const auto& spline = getSplineInvYZforRow(row);
   const char* g1buf = getSplineFlatBuffer(isc);
   const char* g2buf = getGridX2FlatBuffer(spline, isc);
 
@@ -369,8 +369,8 @@ GPUdi() void TPCFastTransformPOD::convLocalToGrid(int32_t sector, int32_t row, f
 {
   /// convert local y, z to internal grid coordinates u,v
   /// return values: u, v, scaling factor
-  const SplineType& spline = getSpline(sector, row);
-  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
+  const SplineType& spline = getSplineForRow(row);
+  getRowInfo(row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
   // shrink to the grid
   u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
   v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
@@ -379,14 +379,14 @@ GPUdi() void TPCFastTransformPOD::convLocalToGrid(int32_t sector, int32_t row, f
 GPUdi() void TPCFastTransformPOD::convGridToLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to local y, z
-  getSectorRowInfo(sector, row).gridMeasured.convGridToLocal(sector, gridU, gridV, y, z);
+  getRowInfo(row).gridMeasured.convGridToLocal(sector, gridU, gridV, y, z);
 }
 
 GPUdi() void TPCFastTransformPOD::convRealLocalToGrid(int32_t sector, int32_t row, float y, float z, float& u, float& v, float& s) const
 {
   /// convert real y, z to the internal grid coordinates + scale
-  const SplineType& spline = getSpline(sector, row);
-  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
+  const SplineType& spline = getSplineForRow(row);
+  getRowInfo(row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
   // shrink to the grid
   u = GPUCommonMath::Clamp(u, 0.f, (float)spline.getGridX1().getUmax());
   v = GPUCommonMath::Clamp(v, 0.f, (float)spline.getGridX2().getUmax());
@@ -395,15 +395,15 @@ GPUdi() void TPCFastTransformPOD::convRealLocalToGrid(int32_t sector, int32_t ro
 GPUdi() void TPCFastTransformPOD::convGridToRealLocal(int32_t sector, int32_t row, float gridU, float gridV, float& y, float& z) const
 {
   /// convert internal grid coordinates u,v to the real y, z
-  getSectorRowInfo(sector, row).gridReal.convGridToLocal(sector, gridU, gridV, y, z);
+  getRowInfo(row).gridReal.convGridToLocal(sector, gridU, gridV, y, z);
 }
 
 GPUdi() bool TPCFastTransformPOD::isLocalInsideGrid(int32_t sector, int32_t row, float y, float z) const
 {
   /// check if local y, z are inside the grid
   float u, v, s;
-  getSectorRowInfo(sector, row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
-  const auto& spline = getSpline(sector, row);
+  getRowInfo(row).gridMeasured.convLocalToGridUntruncated(sector, y, z, u, v, s);
+  const auto& spline = getSplineForRow(row);
   // shrink to the grid
   if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
       v < 0.f || v > (float)spline.getGridX2().getUmax()) {
@@ -416,8 +416,8 @@ GPUdi() bool TPCFastTransformPOD::isRealLocalInsideGrid(int32_t sector, int32_t
 {
   /// check if local y, z are inside the grid
   float u, v, s;
-  getSectorRowInfo(sector, row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
-  const auto& spline = getSpline(sector, row);
+  getRowInfo(row).gridReal.convLocalToGridUntruncated(sector, y, z, u, v, s);
+  const auto& spline = getSplineForRow(row);
   // shrink to the grid
   if (u < 0.f || u > (float)spline.getGridX1().getUmax() || //
       v < 0.f || v > (float)spline.getGridX2().getUmax()) {
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index cc12badb1e654..ba73eaada9c34 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -47,10 +47,10 @@
 
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo + ;
-#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::SectorRowInfo + ;
+#pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RowInfo + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::GridInfo + ;
 #pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo mSliceInfo[36]" version = "[-3]" target = "" code = "{}";
-#pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "size_t mSliceDataSizeBytes[3]" version = "[-3]" target = "mCorrectionDataSize" code = "{ for (int i=0; i<3; i++) mCorrectionDataSize[i] = onfile.mSliceDataSizeBytes[i] * o2::tpc::constants::MAXSECTOR; }";
+#pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "size_t mSliceDataSizeBytes[3]" version = "[-3]" target = "mSectorDataSize" code = "{ for (int i=0; i<3; i++) mSectorDataSize[i] = onfile.mSliceDataSizeBytes[i]; }";
 #pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "float fInterpolationSafetyMargin" version = "[-3]" target = "" code = "{}";
 
 #pragma link C++ struct o2::gpu::TPCSlowSpaceChargeCorrection + ;
diff --git a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
index 583c2f0c812f5..dace124617cac 100644
--- a/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
+++ b/GPU/TPCFastTransformation/macro/TPCFastTransformInit.C
@@ -194,17 +194,14 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
       const o2::gpu::TPCFastTransformGeo& geo = helper->getGeometry();
 
-      // for (int32_t iSector = 0; iSector < geo.getNumberOfSectors(); iSector++) {
-      for (int32_t iSector = 0; iSector < 1; iSector++) {
-        for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
-          auto& info = corr.getSectorRowInfo(iSector, iRow);
-          std::cout << "sector " << iSector << " row " << iRow
-                    << " gridY0 " << info.gridMeasured.getY0() << " gridZ0 " << info.gridMeasured.getZ0()
-                    << " scaleYtoGrid " << info.gridMeasured.getYscale() << " scaleLtoGrid " << info.gridMeasured.getZscale()
-                    << " gridRealY0 " << info.gridReal.getY0() << " gridRealZ0 " << info.gridReal.getZ0()
-                    << " scaleRealYtoGrid " << info.gridReal.getYscale() << " scaleRealLtoGrid " << info.gridReal.getZscale()
-                    << std::endl;
-        }
+      for (int32_t iRow = 0; iRow < geo.getNumberOfRows(); iRow++) {
+        auto& info = corr.getRowInfo(iRow);
+        std::cout << " row " << iRow
+                  << " gridY0 " << info.gridMeasured.getY0() << " gridZ0 " << info.gridMeasured.getZ0()
+                  << " scaleYtoGrid " << info.gridMeasured.getYscale() << " scaleLtoGrid " << info.gridMeasured.getZscale()
+                  << " gridRealY0 " << info.gridReal.getY0() << " gridRealZ0 " << info.gridReal.getZ0()
+                  << " scaleRealYtoGrid " << info.gridReal.getYscale() << " scaleRealLtoGrid " << info.gridReal.getZscale()
+                  << std::endl;
       }
     }
   }
@@ -317,7 +314,7 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
   auto getInvCorrections = [&](int iSector, int iRow, float realY, float realZ, float& ix, float& iy, float& iz) {
     // get the inverse corrections ix, iy, iz at x,y,z
-    ix = corr.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);    
+    ix = corr.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);
     corr.getCorrectionYZatRealYZ(iSector, iRow, realY, realZ, iy, iz);
 
     float ixPod = corrPOD.getCorrectionXatRealYZ(iSector, iRow, realY, realZ);
@@ -497,10 +494,10 @@ void TPCFastTransformInit(const char* fileName = "debugVoxRes.root", const char*
 
         // the spline grid
 
-        const auto& gridY = corr.getSpline(iSector, iRow).getGridX1();
-        const auto& gridZ = corr.getSpline(iSector, iRow).getGridX2();
+        const auto& gridY = corr.getSplineForRow(iRow).getGridX1();
+        const auto& gridZ = corr.getSplineForRow(iRow).getGridX2();
         if (iSector == 0 && iRow == 0) {
-          std::cout << "spline scenario " << corr.getSectorRowInfo(iSector, iRow).splineScenarioID << std::endl;
+          std::cout << "spline scenario " << corr.getRowInfo(iRow).splineScenarioID << std::endl;
           std::cout << "spline grid Y: u = " << 0 << ".." << gridY.getUmax() << ", x = " << gridY.getXmin() << ".." << gridY.getXmax() << std::endl;
           std::cout << "spline grid Z: u = " << 0 << ".." << gridZ.getUmax() << ", x = " << gridZ.getXmin() << ".." << gridZ.getXmax() << std::endl;
         }

From 22f7a9e5d9f5953fb411652ca0968c76e5f1d79d Mon Sep 17 00:00:00 2001
From: "se.gorbunov" <se.gorbunov@gsi.de>
Date: Thu, 16 Apr 2026 15:58:19 +0200
Subject: [PATCH 1639/1764] TPCFastTransform: renaming

---
 .../src/TPCFastTransformHelperO2.cxx          |  4 +-
 .../TPCFastSpaceChargeCorrection.cxx          | 63 +++++--------------
 .../TPCFastSpaceChargeCorrection.h            |  7 +--
 .../TPCFastTransform.cxx                      |  2 +-
 GPU/TPCFastTransformation/TPCFastTransform.h  |  6 +-
 .../TPCFastTransformGeo.h                     |  8 +--
 .../TPCFastTransformGeoPOD.h                  |  4 +-
 .../TPCFastTransformPOD.cxx                   |  4 +-
 .../TPCFastTransformPOD.h                     |  8 +--
 .../TPCFastTransformationLinkDef_O2.h         |  2 +-
 10 files changed, 38 insertions(+), 70 deletions(-)

diff --git a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
index 8ae5cbc5fae4a..c08444e0baab3 100644
--- a/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
+++ b/Detectors/TPC/reconstruction/src/TPCFastTransformHelperO2.cxx
@@ -96,7 +96,7 @@ std::unique_ptr<TPCFastTransform> TPCFastTransformHelperO2::create(int64_t TimeS
     const float t0 = 0.;
     const float vDrift = 0.f;
     const long int initTimeStamp = -1;
-    fastTransform.setCalibration1(initTimeStamp, t0, vDrift);
+    fastTransform.setCalibration(initTimeStamp, t0, vDrift);
 
     fastTransform.finishConstruction();
   }
@@ -153,7 +153,7 @@ int TPCFastTransformHelperO2::updateCalibrationImpl(T& fastTransform, int64_t Ti
 
   const double t0 = (driftTimeOffset + elParam.getAverageShapingTime()) / elParam.ZbinWidth;
 
-  fastTransform.setCalibration1(TimeStamp, t0, vDrift);
+  fastTransform.setCalibration(TimeStamp, t0, vDrift);
 
   return 0;
 }
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index bcde0660a5d34..809b27d982abc 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -34,7 +34,7 @@ TPCFastSpaceChargeCorrection::TPCFastSpaceChargeCorrection()
     mScenarioPtr(nullptr),
     mTimeStamp(-1),
     mCorrectionData{nullptr, nullptr, nullptr},
-    mSectorDataSize{0, 0, 0}
+    mSectorDataSizeBytes{0, 0, 0}
 {
   // Default Constructor: creates an empty uninitialized object
 }
@@ -61,7 +61,7 @@ void TPCFastSpaceChargeCorrection::destroy()
   mTimeStamp = -1;
   for (int32_t is = 0; is < 3; is++) {
     mCorrectionData[is] = nullptr;
-    mSectorDataSize[is] = 0;
+    mSectorDataSizeBytes[is] = 0;
   }
   FlatObject::destroy();
 }
@@ -98,9 +98,9 @@ void TPCFastSpaceChargeCorrection::cloneFromObject(const TPCFastSpaceChargeCorre
 
   mTimeStamp = obj.mTimeStamp;
 
-  mSectorDataSize[0] = obj.mSectorDataSize[0];
-  mSectorDataSize[1] = obj.mSectorDataSize[1];
-  mSectorDataSize[2] = obj.mSectorDataSize[2];
+  mSectorDataSizeBytes[0] = obj.mSectorDataSizeBytes[0];
+  mSectorDataSizeBytes[1] = obj.mSectorDataSizeBytes[1];
+  mSectorDataSizeBytes[2] = obj.mSectorDataSizeBytes[2];
 
   // variable-size data
   mScenarioPtr = obj.mScenarioPtr;
@@ -126,37 +126,6 @@ void TPCFastSpaceChargeCorrection::moveBufferTo(char* newFlatBufferPtr)
   relocateBufferPointers(oldFlatBufferPtr, mFlatBufferPtr);
 }
 
-void TPCFastSpaceChargeCorrection::setActualBufferAddressOld(char* actualFlatBufferPtr)
-{
-  /// Sets the actual location of the external flat buffer after it has been moved (e.g. to another maschine)
-
-  if (mClassVersion != 4) {
-    LOG(error) << "TPCFastSpaceChargeCorrection::setActualBufferAddress() called with class version " << mClassVersion << ". This is not supported.";
-    return;
-  }
-
-  FlatObject::setActualBufferAddress(actualFlatBufferPtr);
-
-  size_t scSize = sizeof(SplineType) * mNumberOfScenarios;
-
-  mScenarioPtr = reinterpret_cast<SplineType*>(mFlatBufferPtr);
-
-  size_t scBufferOffset = alignSize(scSize, SplineType::getBufferAlignmentBytes());
-  size_t scBufferSize = 0;
-
-  for (int32_t i = 0; i < mNumberOfScenarios; i++) {
-    SplineType& sp = mScenarioPtr[i];
-    sp.setActualBufferAddress(mFlatBufferPtr + scBufferOffset + scBufferSize);
-    scBufferSize = alignSize(scBufferSize + sp.getFlatBufferSize(), sp.getBufferAlignmentBytes());
-  }
-  size_t bufferSize = scBufferOffset + scBufferSize;
-  for (int32_t is = 0; is < 3; is++) {
-    size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
-    bufferSize = correctionDataOffset + mSectorDataSize[is] * mGeo.getNumberOfSectors();
-  }
-}
-
 void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBufferPtr)
 {
   /// Sets the actual location of the external flat buffer after it has been moved (e.g. to another maschine)
@@ -180,7 +149,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     for (int32_t is = 0; is < 3; is++) {
       size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
       mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
-      bufferSize = correctionDataOffset + mSectorDataSize[is] * mGeo.getNumberOfSectors();
+      bufferSize = correctionDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
     }
     return;
   }
@@ -289,9 +258,9 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     size_t oldCorrectionDataOffset = alignSize(oldBufferSize, SplineType::getParameterAlignmentBytes());
     size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
     mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
-    memmove(mCorrectionData[is], mFlatBufferPtr + oldCorrectionDataOffset, mSectorDataSize[is] * mGeo.getNumberOfSectors());
-    oldBufferSize = oldCorrectionDataOffset + mSectorDataSize[is] * mGeo.getNumberOfSectors();
-    bufferSize = correctionDataOffset + mSectorDataSize[is] * mGeo.getNumberOfSectors();
+    memmove(mCorrectionData[is], mFlatBufferPtr + oldCorrectionDataOffset, mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors());
+    oldBufferSize = oldCorrectionDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
+    bufferSize = correctionDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
   }
 
   mFlatBufferSize = bufferSize;
@@ -415,7 +384,7 @@ void TPCFastSpaceChargeCorrection::print() const
   mGeo.print();
   LOG(info) << "  mNumberOfScenarios = " << mNumberOfScenarios;
   LOG(info) << "  mTimeStamp = " << mTimeStamp;
-  LOG(info) << "  mSectorDataSize = " << mSectorDataSize[0] << " " << mSectorDataSize[1] << " " << mSectorDataSize[2];
+  LOG(info) << "  mSectorDataSizeBytes = " << mSectorDataSizeBytes[0] << " " << mSectorDataSizeBytes[1] << " " << mSectorDataSizeBytes[2];
 
   if (mScenarioPtr) {
     for (int32_t i = 0; i < mNumberOfScenarios; i++) {
@@ -480,7 +449,7 @@ void TPCFastSpaceChargeCorrection::startConstruction(const TPCFastTransformGeo&
   mScenarioPtr = nullptr;
   for (int32_t s = 0; s < 3; s++) {
     mCorrectionData[s] = nullptr;
-    mSectorDataSize[s] = 0;
+    mSectorDataSizeBytes[s] = 0;
   }
   mClassVersion = 4;
 }
@@ -541,15 +510,15 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   size_t correctionDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
     correctionDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-    mSectorDataSize[is] = 0;
+    mSectorDataSizeBytes[is] = 0;
     for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
       RowInfo& row = getRowInfo(j);
       SplineType& spline = mConstructionScenarios[row.splineScenarioID];
-      row.dataOffsetBytes[is] = alignSize(mSectorDataSize[is], SplineType::getParameterAlignmentBytes());
-      mSectorDataSize[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
+      row.dataOffsetBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
+      mSectorDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
     }
-    mSectorDataSize[is] = alignSize(mSectorDataSize[is], SplineType::getParameterAlignmentBytes());
-    bufferSize = correctionDataOffset[is] + mSectorDataSize[is] * mGeo.getNumberOfSectors();
+    mSectorDataSizeBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
+    bufferSize = correctionDataOffset[is] + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
   }
 
   FlatObject::finishConstruction(bufferSize);
diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
index edb80bc530b9a..09704bb5706e1 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.h
@@ -156,7 +156,6 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   /// Moving the class with its external buffer to another location
 
-  void setActualBufferAddressOld(char* actualFlatBufferPtr);
   void setActualBufferAddress(char* actualFlatBufferPtr);
   void setFutureBufferAddress(char* futureFlatBufferPtr);
 
@@ -308,7 +307,7 @@ class TPCFastSpaceChargeCorrection : public FlatObject
 
   char* mCorrectionData[3]; //! (transient!!) pointer to the spline data in the flat buffer
 
-  size_t mSectorDataSize[3]; ///< size of the sector data per transformation (direct, inverseX, inverse YZ) in the flat buffer
+  size_t mSectorDataSizeBytes[3]; ///< size of the sector data per transformation (direct, inverseX, inverse YZ) in the flat buffer
 
   /// Class version. It is used to read older versions from disc.
   /// The default version 3 is the one before this field was introduced.
@@ -339,14 +338,14 @@ GPUdi() TPCFastSpaceChargeCorrection::SplineType& TPCFastSpaceChargeCorrection::
 GPUdi() float* TPCFastSpaceChargeCorrection::getCorrectionData(int32_t sector, int32_t row, int32_t iSpline)
 {
   /// Gives pointer to spline data
-  size_t offset = sector * mSectorDataSize[iSpline] + getRowInfo(row).dataOffsetBytes[iSpline];
+  size_t offset = sector * mSectorDataSizeBytes[iSpline] + getRowInfo(row).dataOffsetBytes[iSpline];
   return reinterpret_cast<float*>(mCorrectionData[iSpline] + offset);
 }
 
 GPUdi() const float* TPCFastSpaceChargeCorrection::getCorrectionData(int32_t sector, int32_t row, int32_t iSpline) const
 {
   /// Gives pointer to spline data
-  size_t offset = sector * mSectorDataSize[iSpline] + getRowInfo(row).dataOffsetBytes[iSpline];
+  size_t offset = sector * mSectorDataSizeBytes[iSpline] + getRowInfo(row).dataOffsetBytes[iSpline];
   return reinterpret_cast<const float*>(mCorrectionData[iSpline] + offset);
 }
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.cxx b/GPU/TPCFastTransformation/TPCFastTransform.cxx
index 2a829cfcd5471..4435505472991 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransform.cxx
@@ -113,7 +113,7 @@ void TPCFastTransform::startConstruction(const TPCFastSpaceChargeCorrection& cor
   mCorrection.cloneFromObject(correction, nullptr);
 }
 
-void TPCFastTransform::setCalibration1(int64_t timeStamp, float t0, float vDrift)
+void TPCFastTransform::setCalibration(int64_t timeStamp, float t0, float vDrift)
 {
   /// Sets all drift calibration parameters and the time stamp
   ///
diff --git a/GPU/TPCFastTransformation/TPCFastTransform.h b/GPU/TPCFastTransformation/TPCFastTransform.h
index 100c465996e7d..c8afbb57ecab8 100644
--- a/GPU/TPCFastTransformation/TPCFastTransform.h
+++ b/GPU/TPCFastTransformation/TPCFastTransform.h
@@ -157,7 +157,7 @@ class TPCFastTransform : public FlatObject
   ///
   /// It must be called once during construction,
   /// but also may be called afterwards to reset these parameters.
-  void setCalibration1(int64_t timeStamp, float t0, float vDrift);
+  void setCalibration(int64_t timeStamp, float t0, float vDrift);
 
   /// Set Lumi info
   void setLumi(float l) { mLumi = l; }
@@ -553,7 +553,7 @@ GPUdi() void TPCFastTransform::Transform(int32_t sector, int32_t row, float pad,
 GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const
 {
   float l = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
-  z = getGeometry().convDriftLengthToZ1(sector, l);
+  z = getGeometry().convDriftLengthToZ(sector, l);
 }
 
 GPUdi() void TPCFastTransform::TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
@@ -592,7 +592,7 @@ GPUdi() void TPCFastTransform::TransformIdealZ(int32_t sector, float time, float
   ///
 
   float l = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  z = getGeometry().convDriftLengthToZ1(sector, l);
+  z = getGeometry().convDriftLengthToZ(sector, l);
 }
 
 GPUdi() void TPCFastTransform::TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeo.h b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
index 73ac78cdc6e24..2cd145c276ea3 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeo.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeo.h
@@ -155,10 +155,10 @@ class TPCFastTransformGeo
   GPUd() void convPadDriftLengthToLocal(int32_t sector, int32_t row, float pad, float driftLength, float& y, float& z) const;
 
   /// convert DriftLength -> Local c.s.
-  GPUd() float convDriftLengthToZ1(int32_t sector, float driftLength) const;
+  GPUd() float convDriftLengthToZ(int32_t sector, float driftLength) const;
 
   /// convert Z to DriftLength
-  GPUd() float convZtoDriftLength1(int32_t sector, float z) const;
+  GPUd() float convZtoDriftLength(int32_t sector, float z) const;
 
   /// convert Local c.s. -> Pad, DriftLength
   GPUd() void convLocalToPadDriftLength(int32_t sector, int32_t row, float y, float z, float& pad, float& l) const;
@@ -261,13 +261,13 @@ GPUdi() void TPCFastTransformGeo::convPadDriftLengthToLocal(int32_t sector, int3
   }
 }
 
-GPUdi() float TPCFastTransformGeo::convDriftLengthToZ1(int32_t sector, float driftLength) const
+GPUdi() float TPCFastTransformGeo::convDriftLengthToZ(int32_t sector, float driftLength) const
 {
   /// convert DriftLength -> Local c.s.
   return (sector < NumberOfSectorsA) ? (mTPCzLength - driftLength) : (driftLength - mTPCzLength);
 }
 
-GPUdi() float TPCFastTransformGeo::convZtoDriftLength1(int32_t sector, float z) const
+GPUdi() float TPCFastTransformGeo::convZtoDriftLength(int32_t sector, float z) const
 {
   /// convert Z to DriftLength
   return (sector < NumberOfSectorsA) ? (mTPCzLength - z) : (z + mTPCzLength);
diff --git a/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h b/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h
index dbb6176dd47b9..3cbf1dae0c4dd 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformGeoPOD.h
@@ -91,13 +91,13 @@ struct TPCFastTransformGeoPOD {
   }
 
   /// convert DriftLength -> Local c.s.
-  inline static constexpr float convDriftLengthToZ1(uint32_t sector, float driftLength)
+  inline static constexpr float convDriftLengthToZ(uint32_t sector, float driftLength)
   {
     return (sector < getNumberOfSectorsA()) ? (getTPCzLength() - driftLength) : (driftLength - getTPCzLength());
   }
 
   /// convert Z to DriftLength
-  inline static constexpr float convZtoDriftLength1(uint32_t sector, float z)
+  inline static constexpr float convZtoDriftLength(uint32_t sector, float z)
   {
     return (sector < getNumberOfSectorsA()) ? (getTPCzLength() - z) : (z + getTPCzLength());
   }
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index 94420fbfd9152..d93acd8d6c360 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -31,7 +31,7 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(aligned_unique_buffer_ptr<TPCFa
 {
   size_t size = estimateSize(src);
   destVector.alloc(size); // allocate exact size
-  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POS size: {}", src.getCorrection().getFlatBufferSize(), sizeof(TPCFastTransformPOD), size);
+  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POD size: {}", src.getCorrection().getFlatBufferSize(), sizeof(TPCFastTransformPOD), size);
   auto res = create(destVector.getraw(), size, src);
   res->setTimeStamp(src.getTimeStamp());
   res->setVDrift(src.getVDrift());
@@ -48,7 +48,7 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(aligned_unique_buffer_ptr<TPCFa
   // create filling only part corresponding to TPCFastSpaceChargeCorrection. Data members coming from TPCFastTransform (e.g. VDrift, T0..) are not set
   size_t size = estimateSize(origCorr);
   destVector.alloc(size);
-  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POS size: {}", origCorr.getFlatBufferSize(), sizeof(TPCFastTransformPOD), size);
+  LOGP(debug, "OrigCorrSize:{} SelfSize: {} Estimated POD size: {}", origCorr.getFlatBufferSize(), sizeof(TPCFastTransformPOD), size);
   return create(destVector.getraw(), size, origCorr);
 }
 
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.h b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
index 4d537b778cbb3..c7e06d4b47ca4 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.h
@@ -159,7 +159,7 @@ class TPCFastTransformPOD
   /// Sets CTP Lumi estimator
   GPUd() void setLumi(float v) { mLumi = v; }
 
-  GPUd() void setCalibration1(int64_t timeStamp, float t0, float vDrift);
+  GPUd() void setCalibration(int64_t timeStamp, float t0, float vDrift);
 
   /// Gives a reference to a spline
   GPUd() const SplineType& getSplineForRow(int32_t row) const { return *reinterpret_cast<const SplineType*>(getThis() + getScenarioOffset(getRowInfo(row).splineScenarioID)); }
@@ -501,7 +501,7 @@ GPUdi() void TPCFastTransformPOD::TransformXYZ(int32_t sector, int32_t row, floa
 GPUdi() void TPCFastTransformPOD::TransformInTimeFrame(int32_t sector, float time, float& z, float maxTimeBin) const
 {
   float l = (time - mT0 - maxTimeBin) * mVdrift; // drift length cm
-  z = getGeometry().convDriftLengthToZ1(sector, l);
+  z = getGeometry().convDriftLengthToZ(sector, l);
 }
 
 GPUdi() void TPCFastTransformPOD::TransformInTimeFrame(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float maxTimeBin) const
@@ -539,7 +539,7 @@ GPUdi() void TPCFastTransformPOD::TransformIdealZ(int32_t sector, float time, fl
   ///
 
   float l = (time - mT0 - vertexTime) * mVdrift; // drift length cm
-  z = getGeometry().convDriftLengthToZ1(sector, l);
+  z = getGeometry().convDriftLengthToZ(sector, l);
 }
 
 GPUdi() void TPCFastTransformPOD::TransformIdeal(int32_t sector, int32_t row, float pad, float time, float& x, float& y, float& z, float vertexTime) const
@@ -693,7 +693,7 @@ GPUdi() float TPCFastTransformPOD::convVertexTimeToZOffset(int32_t sector, float
 }
 
 #ifndef GPUCA_GPUCODE_DEVICE // Functions not needed during GPU processing
-GPUdi() void TPCFastTransformPOD::setCalibration1(int64_t timeStamp, float t0, float vDrift)
+GPUdi() void TPCFastTransformPOD::setCalibration(int64_t timeStamp, float t0, float vDrift)
 {
   mTimeStamp = timeStamp;
   mT0 = t0;
diff --git a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
index ba73eaada9c34..c9f89f3dcac76 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
+++ b/GPU/TPCFastTransformation/TPCFastTransformationLinkDef_O2.h
@@ -50,7 +50,7 @@
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::RowInfo + ;
 #pragma link C++ class o2::gpu::TPCFastSpaceChargeCorrection::GridInfo + ;
 #pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "o2::gpu::TPCFastSpaceChargeCorrection::SliceInfo mSliceInfo[36]" version = "[-3]" target = "" code = "{}";
-#pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "size_t mSliceDataSizeBytes[3]" version = "[-3]" target = "mSectorDataSize" code = "{ for (int i=0; i<3; i++) mSectorDataSize[i] = onfile.mSliceDataSizeBytes[i]; }";
+#pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "size_t mSliceDataSizeBytes[3]" version = "[-3]" target = "mSectorDataSizeBytes" code = "{ for (int i=0; i<3; i++) mSectorDataSizeBytes[i] = onfile.mSliceDataSizeBytes[i]; }";
 #pragma read sourceClass = "o2::gpu::TPCFastSpaceChargeCorrection" targetClass = "o2::gpu::TPCFastSpaceChargeCorrection" source = "float fInterpolationSafetyMargin" version = "[-3]" target = "" code = "{}";
 
 #pragma link C++ struct o2::gpu::TPCSlowSpaceChargeCorrection + ;

From 3eec9b62bae20f4473d98f08790549b54ee58106 Mon Sep 17 00:00:00 2001
From: "se.gorbunov" <se.gorbunov@gsi.de>
Date: Thu, 16 Apr 2026 19:37:34 +0200
Subject: [PATCH 1640/1764] TPCFastTransform: remove unnecessary memory
 alignment in the spline data

---
 .../TPCFastSpaceChargeCorrection.cxx          | 27 ++++++++-----
 .../TPCFastTransformPOD.cxx                   | 39 +++++++------------
 2 files changed, 30 insertions(+), 36 deletions(-)

diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 809b27d982abc..66029daeea710 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -147,9 +147,8 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     }
     size_t bufferSize = scBufferOffset + scBufferSize;
     for (int32_t is = 0; is < 3; is++) {
-      size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-      mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
-      bufferSize = correctionDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
+      mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + bufferSize);
+      bufferSize += mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
     }
     return;
   }
@@ -256,7 +255,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
 
   for (int32_t is = 0; is < 3; is++) {
     size_t oldCorrectionDataOffset = alignSize(oldBufferSize, SplineType::getParameterAlignmentBytes());
-    size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    size_t correctionDataOffset = bufferSize;
     mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
     memmove(mCorrectionData[is], mFlatBufferPtr + oldCorrectionDataOffset, mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors());
     oldBufferSize = oldCorrectionDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
@@ -509,16 +508,24 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   size_t bufferSize = scBufferOffsets[0] + scBufferSize;
   size_t correctionDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
-    correctionDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    correctionDataOffset[is] = bufferSize;
     mSectorDataSizeBytes[is] = 0;
     for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
       RowInfo& row = getRowInfo(j);
-      SplineType& spline = mConstructionScenarios[row.splineScenarioID];
-      row.dataOffsetBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-      mSectorDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
+      row.dataOffsetBytes[is] = mSectorDataSizeBytes[is];
+      const SplineType& spline = mConstructionScenarios[row.splineScenarioID];
+      if (is == 0) {
+        const SplineTypeXYZ& splineXYZ = reinterpret_cast<const SplineTypeXYZ&>(spline);
+        mSectorDataSizeBytes[is] += splineXYZ.getSizeOfParameters();
+      } else if (is == 1) {
+        const SplineTypeInvX& splineInvX = reinterpret_cast<const SplineTypeInvX&>(spline);
+        mSectorDataSizeBytes[is] += splineInvX.getSizeOfParameters();
+      } else if (is == 2) {
+        const SplineTypeInvYZ& splineInvYZ = reinterpret_cast<const SplineTypeInvYZ&>(spline);
+        mSectorDataSizeBytes[is] += splineInvYZ.getSizeOfParameters();
+      }
     }
-    mSectorDataSizeBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-    bufferSize = correctionDataOffset[is] + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
+    bufferSize += mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
   }
 
   FlatObject::finishConstruction(bufferSize);
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index d93acd8d6c360..f6e61bdbbff70 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -157,40 +157,27 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
     nextDynOffs = alignOffset(nextDynOffs + spline.getFlatBufferSize());
   }
 
-  // copy spline data w/o memory alignment gaps between the sectors
+  // copy spline data
   for (int is = 0; is < 3; is++) {
     float* data = reinterpret_cast<float*>(buff + nextDynOffs);
     LOGP(debug, "splinID={} start offset {} -> {}", is, nextDynOffs, (void*)data);
 
     // metadata
-    size_t sectorDataSizeFloats = 0;
-    size_t sectorDataSizeBytes = 0;
-    for (int row = 0; row < NROWS; row++) {
-      podMap.getRowInfo(row).dataOffsetBytes[is] = sectorDataSizeBytes;
-      const auto& spline = origCorr.getSplineForRow(row);
-      int nPar = spline.getNumberOfParameters();
-      if (is == 1) {
-        nPar = nPar / 3;
-      }
-      if (is == 2) {
-        nPar = nPar * 2 / 3;
-      }
-      sectorDataSizeFloats += nPar;
-      sectorDataSizeBytes += nPar * sizeof(float);
-    }
+    size_t sectorDataSizeBytes = origCorr.mSectorDataSizeBytes[is];
 
-    for (int sector = 0; sector < origCorr.mGeo.getNumberOfSectors(); sector++) {
-      podMap.mSplineDataOffsets[sector][is] = nextDynOffs;
-      if (buffSize < nextDynOffs + sectorDataSizeBytes) {
-        throw std::runtime_error(fmt::format("attempt to copy {} bytes of data for spline{} of sector{} to {}, overflowing the buffer of size {}", sectorDataSizeBytes, is, sector, nextDynOffs, buffSize));
-      }
-      const float* dataOr = origCorr.getCorrectionData(sector, 0, is);
-      std::memcpy(data, dataOr, sectorDataSizeBytes);
-      data += sectorDataSizeFloats;
-      nextDynOffs += sectorDataSizeBytes;
+    for (int sector = 0; sector < TPCFastTransformGeo::getNumberOfSectors(); sector++) {
+      podMap.mSplineDataOffsets[sector][is] = nextDynOffs + sectorDataSizeBytes * sector;
+    }
+    size_t dataSize = TPCFastTransformGeo::getNumberOfSectors() * sectorDataSizeBytes;
+    if (buffSize < nextDynOffs + dataSize) {
+      throw std::runtime_error(fmt::format("attempt to copy {} bytes of data for spline{} to {}, overflowing the buffer of size {}", sectorDataSizeBytes, is, nextDynOffs, buffSize));
     }
+    const char* dataOr = origCorr.mCorrectionData[is];
+    std::memcpy(data, dataOr, dataSize);
+    nextDynOffs += dataSize;
   }
-  podMap.mTotalSize = alignOffset(nextDynOffs);
+  nextDynOffs = alignOffset(nextDynOffs);
+  podMap.mTotalSize = nextDynOffs;
   if (buffSize != podMap.mTotalSize) {
     throw std::runtime_error(fmt::format("Estimated buffer size {} differs from filled one {}", buffSize, podMap.mTotalSize));
   }

From c060a1e58a6940a5f4079db0541b51af6997d9d0 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 20 Apr 2026 21:34:37 +0200
Subject: [PATCH 1641/1764] CCDB: add extra metrics for amount of data
 requested / fetched

---
 CCDB/include/CCDB/BasicCCDBManager.h          | 10 ++++++-
 CCDB/src/BasicCCDBManager.cxx                 |  2 +-
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   |  5 +++-
 .../CCDBSupport/src/CCDBFetcherHelper.cxx     |  4 +++
 Framework/CCDBSupport/src/CCDBFetcherHelper.h |  2 ++
 Framework/CCDBSupport/src/CCDBHelpers.cxx     | 29 ++++++++++++++++---
 .../include/Framework/DataProcessingStats.h   |  2 ++
 Framework/Core/src/CommonServices.cxx         | 16 ++++++++++
 8 files changed, 63 insertions(+), 7 deletions(-)

diff --git a/CCDB/include/CCDB/BasicCCDBManager.h b/CCDB/include/CCDB/BasicCCDBManager.h
index b76beb2576eb3..6ad645a0a893e 100644
--- a/CCDB/include/CCDB/BasicCCDBManager.h
+++ b/CCDB/include/CCDB/BasicCCDBManager.h
@@ -55,6 +55,7 @@ class CCDBManagerInstance
     long endvalidity = -1;
     long cacheValidFrom = 0;   // time for which the object was cached
     long cacheValidUntil = -1; // object is guaranteed to be valid till this time (modulo new updates)
+    size_t size = 0;
     size_t minSize = -1ULL;
     size_t maxSize = 0;
     int queries = 0;
@@ -229,6 +230,7 @@ class CCDBManagerInstance
   long mCreatedNotBefore = 0;                           // lower limit for object creation timestamp (TimeMachine mode) - If-Not-Before HTTP header
   long mTimerMS = 0;                                    // timer for queries
   size_t mFetchedSize = 0;                              // total fetched size
+  size_t mRequestedSize = 0;                            // total requested size (fetched + served from cache)
   int mQueries = 0;                                     // total number of object queries
   int mFetches = 0;                                     // total number of succesful fetches from CCDB
   int mFailures = 0;                                    // total number of failed fetches
@@ -258,6 +260,7 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp,
       if (sh != mHeaders.end()) {
         size_t s = atol(sh->second.c_str());
         mFetchedSize += s;
+        mRequestedSize += s;
       }
     }
 
@@ -272,6 +275,7 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp,
       if (headers) {
         *headers = cached.cacheOfHeaders;
       }
+      mRequestedSize += cached.size;
       return reinterpret_cast<T*>(cached.noCleanupPtr ? cached.noCleanupPtr : cached.objPtr.get());
     }
     ptr = mCCDBAccessor.retrieveFromTFileAny<T>(path, mMetaData, timestamp, &mHeaders, cached.uuid,
@@ -318,6 +322,8 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp,
       if (sh != mHeaders.end()) {
         size_t s = atol(sh->second.c_str());
         mFetchedSize += s;
+        mRequestedSize += s;
+        cached.size = s;
         cached.minSize = std::min(s, cached.minSize);
         cached.maxSize = std::max(s, cached.minSize);
       }
@@ -342,12 +348,14 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp,
   }
   auto end = std::chrono::system_clock::now();
   mTimerMS += std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
-  auto *ref = o2::framework::ServiceRegistryRef::globalDeviceRef();
+  auto* ref = o2::framework::ServiceRegistryRef::globalDeviceRef();
   if (ref && ref->active<framework::DataProcessingStats>()) {
     auto& stats = ref->get<o2::framework::DataProcessingStats>();
     stats.updateStats({(int)o2::framework::ProcessingStatsId::CCDB_CACHE_HIT, o2::framework::DataProcessingStats::Op::Set, (int64_t)mQueries - mFailures - mFetches});
     stats.updateStats({(int)o2::framework::ProcessingStatsId::CCDB_CACHE_MISS, o2::framework::DataProcessingStats::Op::Set, (int64_t)mFetches});
     stats.updateStats({(int)o2::framework::ProcessingStatsId::CCDB_CACHE_FAILURE, o2::framework::DataProcessingStats::Op::Set, (int64_t)mFailures});
+    stats.updateStats({(int)o2::framework::ProcessingStatsId::CCDB_CACHE_FETCHED_BYTES, o2::framework::DataProcessingStats::Op::Set, (int64_t)mFetchedSize});
+    stats.updateStats({(int)o2::framework::ProcessingStatsId::CCDB_CACHE_REQUESTED_BYTES, o2::framework::DataProcessingStats::Op::Set, (int64_t)mRequestedSize});
   }
   return ptr;
 }
diff --git a/CCDB/src/BasicCCDBManager.cxx b/CCDB/src/BasicCCDBManager.cxx
index d55fdad960d3a..53055d0d1231d 100644
--- a/CCDB/src/BasicCCDBManager.cxx
+++ b/CCDB/src/BasicCCDBManager.cxx
@@ -101,7 +101,7 @@ std::pair<int64_t, int64_t> CCDBManagerInstance::getRunDuration(int runnumber, b
 
 std::string CCDBManagerInstance::getSummaryString() const
 {
-  std::string res = fmt::format("{} queries, {} bytes", mQueries, fmt::group_digits(mFetchedSize));
+  std::string res = fmt::format("{} queries, {} fetched / {} requested bytes", mQueries, fmt::group_digits(mFetchedSize), fmt::group_digits(mRequestedSize));
   if (mCachingEnabled) {
     res += fmt::format(" for {} objects", mCache.size());
   }
diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index 413adfddecf04..3892f200645f6 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -11,6 +11,7 @@
 
 #include "AnalysisCCDBHelpers.h"
 #include "CCDBFetcherHelper.h"
+#include "Framework/DataProcessingStats.h"
 #include "Framework/DeviceSpec.h"
 #include "Framework/TimingInfo.h"
 #include "Framework/ConfigParamRegistry.h"
@@ -105,7 +106,7 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
     std::unordered_map<std::string, int> bindings;
     fillValidRoutes(*helper, spec.outputs, bindings);
 
-    return adaptStateless([schemas, bindings, helper](InputRecord& inputs, DataTakingContext& dtc, DataAllocator& allocator, TimingInfo& timingInfo) {
+    return adaptStateless([schemas, bindings, helper](InputRecord& inputs, DataTakingContext& dtc, DataAllocator& allocator, TimingInfo& timingInfo, DataProcessingStats& stats) {
       O2_SIGNPOST_ID_GENERATE(sid, ccdb);
       O2_SIGNPOST_START(ccdb, sid, "fetchFromAnalysisCCDB", "Fetching CCDB objects for analysis%" PRIu64, (uint64_t)timingInfo.timeslice);
       for (auto& schema : schemas) {
@@ -182,6 +183,8 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
         allocator.adopt(Output{concrete.origin, concrete.description, concrete.subSpec}, outTable);
       }
 
+      stats.updateStats({(int)ProcessingStatsId::CCDB_CACHE_FETCHED_BYTES, DataProcessingStats::Op::Set, (int64_t)helper->totalFetchedBytes});
+      stats.updateStats({(int)ProcessingStatsId::CCDB_CACHE_REQUESTED_BYTES, DataProcessingStats::Op::Set, (int64_t)helper->totalRequestedBytes});
       O2_SIGNPOST_END(ccdb, sid, "fetchFromAnalysisCCDB", "Fetching CCDB objects");
     });
   });
diff --git a/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx b/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
index 151703105a1dd..8d50dac63a67b 100644
--- a/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
+++ b/Framework/CCDBSupport/src/CCDBFetcherHelper.cxx
@@ -254,6 +254,8 @@ auto CCDBFetcherHelper::populateCacheWith(std::shared_ptr<CCDBFetcherHelper> con
         helper->mapURL2UUID[path].minSize = std::min(v.size(), helper->mapURL2UUID[path].minSize);
         helper->mapURL2UUID[path].maxSize = std::max(v.size(), helper->mapURL2UUID[path].maxSize);
         auto size = v.size();
+        helper->totalFetchedBytes += size;
+        helper->totalRequestedBytes += size;
         api.appendFlatHeader(v, headers);
         auto cacheId = allocator.adoptContainer(output, std::move(v), DataAllocator::CacheStrategy::Always, header::gSerializationMethodCCDB);
         helper->mapURL2DPLCache[path] = cacheId;
@@ -271,6 +273,8 @@ auto CCDBFetcherHelper::populateCacheWith(std::shared_ptr<CCDBFetcherHelper> con
         helper->mapURL2UUID[path].minSize = std::min(v.size(), helper->mapURL2UUID[path].minSize);
         helper->mapURL2UUID[path].maxSize = std::max(v.size(), helper->mapURL2UUID[path].maxSize);
         auto size = v.size();
+        helper->totalFetchedBytes += size;
+        helper->totalRequestedBytes += size;
         api.appendFlatHeader(v, headers);
         auto cacheId = allocator.adoptContainer(output, std::move(v), DataAllocator::CacheStrategy::Always, header::gSerializationMethodCCDB);
         helper->mapURL2DPLCache[path] = cacheId;
diff --git a/Framework/CCDBSupport/src/CCDBFetcherHelper.h b/Framework/CCDBSupport/src/CCDBFetcherHelper.h
index 1778712f45002..a6cb3f70215af 100644
--- a/Framework/CCDBSupport/src/CCDBFetcherHelper.h
+++ b/Framework/CCDBSupport/src/CCDBFetcherHelper.h
@@ -84,6 +84,8 @@ struct CCDBFetcherHelper {
 
   static ParserResult parseRemappings(char const*);
 
+  size_t totalFetchedBytes = 0;
+  size_t totalRequestedBytes = 0;
   std::unordered_map<std::string, CCDBCacheInfo> mapURL2UUID;
   std::unordered_map<std::string, DataAllocator::CacheId> mapURL2DPLCache;
   std::string createdNotBefore = "0";
diff --git a/Framework/CCDBSupport/src/CCDBHelpers.cxx b/Framework/CCDBSupport/src/CCDBHelpers.cxx
index 80a79796f8c1b..fd78594e365bf 100644
--- a/Framework/CCDBSupport/src/CCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/CCDBHelpers.cxx
@@ -11,6 +11,7 @@
 
 #include "CCDBHelpers.h"
 #include "Framework/DeviceSpec.h"
+#include "Framework/DataProcessingStats.h"
 #include "Framework/Logger.h"
 #include "Framework/TimingInfo.h"
 #include "Framework/ConfigParamRegistry.h"
@@ -28,7 +29,8 @@ O2_DECLARE_DYNAMIC_LOG(ccdb);
 namespace o2::framework
 {
 
-namespace {
+namespace
+{
 struct CCDBFetcherHelper {
   struct CCDBCacheInfo {
     std::string etag;
@@ -36,6 +38,7 @@ struct CCDBFetcherHelper {
     size_t cachePopulatedAt = 0;
     size_t cacheMiss = 0;
     size_t cacheHit = 0;
+    size_t size = 0;
     size_t minSize = -1ULL;
     size_t maxSize = 0;
     int lastCheckedTF = 0;
@@ -50,6 +53,8 @@ struct CCDBFetcherHelper {
     std::string url;
   };
 
+  size_t totalFetchedBytes = 0;
+  size_t totalRequestedBytes = 0;
   std::unordered_map<std::string, CCDBCacheInfo> mapURL2UUID;
   std::unordered_map<std::string, DataAllocator::CacheId> mapURL2DPLCache;
   std::string createdNotBefore = "0";
@@ -80,7 +85,7 @@ struct CCDBFetcherHelper {
     return apis[entry == remappings.end() ? "" : entry->second];
   }
 };
-}
+} // namespace
 
 bool isPrefix(std::string_view prefix, std::string_view full)
 {
@@ -336,8 +341,11 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
         helper->mapURL2UUID[path].etag = headers["ETag"]; // update uuid
         helper->mapURL2UUID[path].cachePopulatedAt = timestampToUse;
         helper->mapURL2UUID[path].cacheMiss++;
+        helper->mapURL2UUID[path].size = v.size();
         helper->mapURL2UUID[path].minSize = std::min(v.size(), helper->mapURL2UUID[path].minSize);
         helper->mapURL2UUID[path].maxSize = std::max(v.size(), helper->mapURL2UUID[path].maxSize);
+        helper->totalFetchedBytes += v.size();
+        helper->totalRequestedBytes += v.size();
         api.appendFlatHeader(v, headers);
         auto cacheId = allocator.adoptContainer(output, std::move(v), DataAllocator::CacheStrategy::Always, header::gSerializationMethodCCDB);
         helper->mapURL2DPLCache[path] = cacheId;
@@ -350,8 +358,11 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
         helper->mapURL2UUID[path].cachePopulatedAt = timestampToUse;
         helper->mapURL2UUID[path].cacheValidUntil = headers["Cache-Valid-Until"].empty() ? 0 : std::stoul(headers["Cache-Valid-Until"]);
         helper->mapURL2UUID[path].cacheMiss++;
+        helper->mapURL2UUID[path].size = v.size();
         helper->mapURL2UUID[path].minSize = std::min(v.size(), helper->mapURL2UUID[path].minSize);
         helper->mapURL2UUID[path].maxSize = std::max(v.size(), helper->mapURL2UUID[path].maxSize);
+        helper->totalFetchedBytes += v.size();
+        helper->totalRequestedBytes += v.size();
         api.appendFlatHeader(v, headers);
         auto cacheId = allocator.adoptContainer(output, std::move(v), DataAllocator::CacheStrategy::Always, header::gSerializationMethodCCDB);
         helper->mapURL2DPLCache[path] = cacheId;
@@ -368,6 +379,7 @@ auto populateCacheWith(std::shared_ptr<CCDBFetcherHelper> const& helper,
     auto cacheId = helper->mapURL2DPLCache[path];
     O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "populateCacheWith", "Reusing %{public}s for %{public}s (DPL id %" PRIu64 ")", path.data(), headers["ETag"].data(), cacheId.value);
     helper->mapURL2UUID[path].cacheHit++;
+    helper->totalRequestedBytes += helper->mapURL2UUID[path].size;
     allocator.adoptFromCache(output, cacheId, header::gSerializationMethodCCDB);
     // the outputBuffer was not used, can we destroy it?
   }
@@ -382,13 +394,13 @@ AlgorithmSpec CCDBHelpers::fetchFromCCDB()
       /// Add a callback on stop which dumps the statistics for the caching per
       /// path
       callbacks.set<CallbackService::Id::Stop>([helper]() {
-        LOGP(info, "CCDB cache miss/hit ratio:");
+        LOGP(info, "CCDB cache miss/hit ratio ({} fetched / {} requested bytes):", helper->totalFetchedBytes, helper->totalRequestedBytes);
         for (auto& entry : helper->mapURL2UUID) {
           LOGP(info, "  {}: {}/{} ({}-{} bytes)", entry.first, entry.second.cacheMiss, entry.second.cacheHit, entry.second.minSize, entry.second.maxSize);
         }
       });
 
-      return adaptStateless([helper](DataTakingContext& dtc, DataAllocator& allocator, TimingInfo& timingInfo) {
+      return adaptStateless([helper](DataTakingContext& dtc, DataAllocator& allocator, TimingInfo& timingInfo, DataProcessingStats& stats) {
         auto sid = _o2_signpost_id_t{(int64_t)timingInfo.timeslice};
         O2_SIGNPOST_START(ccdb, sid, "fetchFromCCDB", "Fetching CCDB objects for timeslice %" PRIu64, (uint64_t)timingInfo.timeslice);
         static Long64_t orbitResetTime = -1;
@@ -429,8 +441,11 @@ AlgorithmSpec CCDBHelpers::fetchFromCCDB()
             if (etag.empty()) {
               helper->mapURL2UUID[path].etag = headers["ETag"]; // update uuid
               helper->mapURL2UUID[path].cacheMiss++;
+              helper->mapURL2UUID[path].size = v.size();
               helper->mapURL2UUID[path].minSize = std::min(v.size(), helper->mapURL2UUID[path].minSize);
               helper->mapURL2UUID[path].maxSize = std::max(v.size(), helper->mapURL2UUID[path].maxSize);
+              helper->totalFetchedBytes += v.size();
+              helper->totalRequestedBytes += v.size();
               newOrbitResetTime = getOrbitResetTime(v);
               api.appendFlatHeader(v, headers);
               auto cacheId = allocator.adoptContainer(output, std::move(v), DataAllocator::CacheStrategy::Always, header::gSerializationMethodNone);
@@ -440,8 +455,11 @@ AlgorithmSpec CCDBHelpers::fetchFromCCDB()
               // somewhere here pruneFromCache should be called
               helper->mapURL2UUID[path].etag = headers["ETag"]; // update uuid
               helper->mapURL2UUID[path].cacheMiss++;
+              helper->mapURL2UUID[path].size = v.size();
               helper->mapURL2UUID[path].minSize = std::min(v.size(), helper->mapURL2UUID[path].minSize);
               helper->mapURL2UUID[path].maxSize = std::max(v.size(), helper->mapURL2UUID[path].maxSize);
+              helper->totalFetchedBytes += v.size();
+              helper->totalRequestedBytes += v.size();
               newOrbitResetTime = getOrbitResetTime(v);
               api.appendFlatHeader(v, headers);
               auto cacheId = allocator.adoptContainer(output, std::move(v), DataAllocator::CacheStrategy::Always, header::gSerializationMethodNone);
@@ -455,6 +473,7 @@ AlgorithmSpec CCDBHelpers::fetchFromCCDB()
           auto cacheId = helper->mapURL2DPLCache[path];
           O2_SIGNPOST_EVENT_EMIT(ccdb, sid, "fetchFromCCDB", "Reusing %{public}s for %{public}s (DPL id %" PRIu64 ")", path.data(), headers["ETag"].data(), cacheId.value);
           helper->mapURL2UUID[path].cacheHit++;
+          helper->totalRequestedBytes += helper->mapURL2UUID[path].size;
           allocator.adoptFromCache(output, cacheId, header::gSerializationMethodNone);
 
           if (newOrbitResetTime != orbitResetTime) {
@@ -480,6 +499,8 @@ AlgorithmSpec CCDBHelpers::fetchFromCCDB()
             dtc.runNumber.data(), orbitResetTime, timingInfo.creation, timestamp, timingInfo.firstTForbit);
 
         populateCacheWith(helper, timestamp, timingInfo, dtc, allocator);
+        stats.updateStats({(int)ProcessingStatsId::CCDB_CACHE_FETCHED_BYTES, DataProcessingStats::Op::Set, (int64_t)helper->totalFetchedBytes});
+        stats.updateStats({(int)ProcessingStatsId::CCDB_CACHE_REQUESTED_BYTES, DataProcessingStats::Op::Set, (int64_t)helper->totalRequestedBytes});
         O2_SIGNPOST_END(ccdb, _o2_signpost_id_t{(int64_t)timingInfo.timeslice}, "fetchFromCCDB", "Fetching CCDB objects");
       }); });
 }
diff --git a/Framework/Core/include/Framework/DataProcessingStats.h b/Framework/Core/include/Framework/DataProcessingStats.h
index a1f5c0eec5568..edb04c4c5f752 100644
--- a/Framework/Core/include/Framework/DataProcessingStats.h
+++ b/Framework/Core/include/Framework/DataProcessingStats.h
@@ -72,6 +72,8 @@ enum struct ProcessingStatsId : short {
   CCDB_CACHE_HIT,
   CCDB_CACHE_MISS,
   CCDB_CACHE_FAILURE,
+  CCDB_CACHE_FETCHED_BYTES,
+  CCDB_CACHE_REQUESTED_BYTES,
   AVAILABLE_MANAGED_SHM_BASE = 512,
 };
 
diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 06bc7969ebf1e..0f53f5a6be5a1 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -1176,6 +1176,22 @@ o2::framework::ServiceSpec CommonServices::dataProcessingStats()
                    .scope = Scope::DPL,
                    .minPublishInterval = 1000,
                    .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
+        MetricSpec{.name = "ccdb-cache-fetched-bytes",
+                   .enabled = true,
+                   .metricId = static_cast<short>(ProcessingStatsId::CCDB_CACHE_FETCHED_BYTES),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 1000,
+                   .maxRefreshLatency = 10000,
+                   .sendInitialValue = true},
+        MetricSpec{.name = "ccdb-cache-requested-bytes",
+                   .enabled = true,
+                   .metricId = static_cast<short>(ProcessingStatsId::CCDB_CACHE_REQUESTED_BYTES),
+                   .kind = Kind::UInt64,
+                   .scope = Scope::DPL,
+                   .minPublishInterval = 1000,
+                   .maxRefreshLatency = 10000,
                    .sendInitialValue = true}};
 
       for (auto& metric : metrics) {

From 5e59fcf9f4241e2baf9a81d92fa15e0d08955819 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 21 Apr 2026 10:45:18 +0200
Subject: [PATCH 1642/1764] Avoid spurious cyclic dependencies

The O2_PCM_DEPS target property should reevaluate correctly when
the dependencies change.
---
 cmake/AddRootDictionary.cmake        | 4 ++--
 cmake/O2SetROOTPCMDependencies.cmake | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/cmake/AddRootDictionary.cmake b/cmake/AddRootDictionary.cmake
index 17fdd2bd286c0..16cbdec222043 100644
--- a/cmake/AddRootDictionary.cmake
+++ b/cmake/AddRootDictionary.cmake
@@ -149,11 +149,11 @@ function(add_root_dictionary target)
       $<$<BOOL:${prop}>:-D$<JOIN:${prop},$<SEMICOLON>-D>>
       $<$<BOOL:${hasExtraPatch}>:--extra-patch>
       $<$<BOOL:${hasExtraPatch}>:${CMAKE_CURRENT_LIST_DIR}/${A_EXTRA_PATCH}>
-      --pcmdeps "$<REMOVE_DUPLICATES:${list_pcm_deps_${target}}>"
+      --pcmdeps "$<REMOVE_DUPLICATES:$<TARGET_PROPERTY:${target},O2_PCM_DEPS>>"
       --headers "${headers}"
     COMMAND
     ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_BINARY_DIR}/${pcmBase} ${pcmFile}
-    DEPENDS ${headers} "$<REMOVE_DUPLICATES:${list_pcm_deps_${target}}>" ${A_EXTRA_PATCH})
+    DEPENDS ${headers} "$<REMOVE_DUPLICATES:$<TARGET_PROPERTY:${target},O2_PCM_DEPS>>" ${A_EXTRA_PATCH})
   # cmake-format: on
 
   # add dictionary source to the target sources
diff --git a/cmake/O2SetROOTPCMDependencies.cmake b/cmake/O2SetROOTPCMDependencies.cmake
index d3f266c9c0337..e12b916c2a559 100644
--- a/cmake/O2SetROOTPCMDependencies.cmake
+++ b/cmake/O2SetROOTPCMDependencies.cmake
@@ -37,7 +37,7 @@ function(set_root_pcm_dependencies)
           endforeach()
         endif()
       endforeach()
-      set(list_pcm_deps_${target} "${pcm_dep_list}" CACHE INTERNAL "List of pcm dependencies for ${target}")
+      set_property(TARGET ${target} PROPERTY O2_PCM_DEPS "${pcm_dep_list}")
     endif()
   endforeach()
 endfunction()

From b40efa1856376489abc9423faf720c34d074c545 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 20 Apr 2026 10:51:18 +0200
Subject: [PATCH 1643/1764] GLO: fix missing wfx option

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/GlobalTrackingWorkflow/helpers/CMakeLists.txt         | 2 +-
 .../helpers/src/GlobalTrackClusterReader.cxx                    | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/helpers/CMakeLists.txt b/Detectors/GlobalTrackingWorkflow/helpers/CMakeLists.txt
index 8ae5378222f5d..357f16bb0c21b 100644
--- a/Detectors/GlobalTrackingWorkflow/helpers/CMakeLists.txt
+++ b/Detectors/GlobalTrackingWorkflow/helpers/CMakeLists.txt
@@ -41,4 +41,4 @@ o2_add_executable(track-cluster-reader
         COMPONENT_NAME global
         TARGETVARNAME targetName
         SOURCES src/GlobalTrackClusterReader.cxx
-        PUBLIC_LINK_LIBRARIES O2::GlobalTrackingWorkflowHelpers O2::DetectorsRaw)
+        PUBLIC_LINK_LIBRARIES O2::GlobalTrackingWorkflowHelpers O2::DetectorsRaw O2::DataFormatsITSMFT)
diff --git a/Detectors/GlobalTrackingWorkflow/helpers/src/GlobalTrackClusterReader.cxx b/Detectors/GlobalTrackingWorkflow/helpers/src/GlobalTrackClusterReader.cxx
index 3fc8df70fdd84..a004432643763 100644
--- a/Detectors/GlobalTrackingWorkflow/helpers/src/GlobalTrackClusterReader.cxx
+++ b/Detectors/GlobalTrackingWorkflow/helpers/src/GlobalTrackClusterReader.cxx
@@ -11,6 +11,7 @@
 
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
+#include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
 #include "Framework/CallbacksPolicy.h"
@@ -37,6 +38,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"ir-frames-its", VariantType::Bool, false, {"read ITS IR frames"}},
     {"disable-root-input", o2::framework::VariantType::Bool, false, {"disable reading root files, essentially making this workflow void, but needed for compatibility"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
+  o2::itsmft::DPLAlpideParamInitializer::addConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }

From 2742e406fc639c3e0ce0b83e18b073dc869c8447 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 20 Apr 2026 10:53:54 +0200
Subject: [PATCH 1644/1764] dpl-workflow fix typo

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index b7cd4a233bb5d..92e93e3977c65 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -115,7 +115,7 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 [[ "0$DISABLE_ROOT_OUTPUT" == "00" ]] && DISABLE_ROOT_OUTPUT=
 
 [[ "0$ITSSTAGGERED" == "01" ]] && ITS_STAGGERED=" --enable-its-staggering " || ITS_STAGGERED=
-[[ "0$MFTSTAGGERED" == "01" ]] && MFT_STAGGERED=" --enable-its-staggering " || MFT_STAGGERED=
+[[ "0$MFTSTAGGERED" == "01" ]] && MFT_STAGGERED=" --enable-mft-staggering " || MFT_STAGGERED=
 
 # ITS vertexing settings
 if [[ $BEAMTYPE == "pp" || $LIGHTNUCLEI == "1" ]]; then

From 5f89a2e1152ffd01b405aa3596f83f3bc49e59ad Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 20 Apr 2026 21:34:37 +0200
Subject: [PATCH 1645/1764] DPL: revamp / remove Endian.h

C++20 (and even more so 23) has understanding of endianess.
No need to have a special wrapper include anymore.
---
 Framework/AnalysisSupport/src/TTreePlugin.cxx |  9 ++-
 .../AnalysisSupport/src/TableTreeHelpers.cxx  |  1 -
 Framework/Core/src/FragmentToBatch.cxx        |  1 -
 Framework/Core/src/HTTPParser.cxx             | 24 +++---
 Framework/Core/src/HTTPParser.h               | 72 ++++++++++--------
 Framework/Foundation/CMakeLists.txt           |  9 ++-
 .../Foundation/include/Framework/BigEndian.h  | 64 ++++++++++++++++
 .../Foundation/include/Framework/Endian.h     | 74 -------------------
 .../Foundation/test/benchmark_BigEndian.cxx   | 65 ++++++++++++++++
 Framework/Foundation/test/test_BigEndian.cxx  | 67 +++++++++++++++++
 10 files changed, 263 insertions(+), 123 deletions(-)
 create mode 100644 Framework/Foundation/include/Framework/BigEndian.h
 delete mode 100644 Framework/Foundation/include/Framework/Endian.h
 create mode 100644 Framework/Foundation/test/benchmark_BigEndian.cxx
 create mode 100644 Framework/Foundation/test/test_BigEndian.cxx

diff --git a/Framework/AnalysisSupport/src/TTreePlugin.cxx b/Framework/AnalysisSupport/src/TTreePlugin.cxx
index 4a51f4eac68f6..1a6f48ebef5b4 100644
--- a/Framework/AnalysisSupport/src/TTreePlugin.cxx
+++ b/Framework/AnalysisSupport/src/TTreePlugin.cxx
@@ -12,7 +12,7 @@
 #include "Framework/RootArrowFilesystem.h"
 #include "Framework/Plugins.h"
 #include "Framework/Signpost.h"
-#include "Framework/Endian.h"
+#include "Framework/BigEndian.h"
 #include <TBufferFile.h>
 #include <TBufferIO.h>
 #include <arrow/buffer.h>
@@ -197,7 +197,7 @@ auto readValues = [](uint8_t* target, ReadOps& op, TBufferFile& rootBuffer) {
     }
     int size = readLast * op.listSize;
     readEntries += readLast;
-    swapCopy(target, rootBuffer.GetCurrent(), size, op.typeSize);
+    bigEndianCopy(target, rootBuffer.GetCurrent(), size, op.typeSize);
     target += (ptrdiff_t)(size * op.typeSize);
   }
 };
@@ -230,7 +230,7 @@ auto readVLAValues = [](uint8_t* target, ReadOps& op, ReadOps const& offsetOp, T
     auto readLast = op.branch->GetBulkRead().GetEntriesSerialized(readEntries, rootBuffer);
     int size = offsets[readEntries + readLast] - offsets[readEntries];
     readEntries += readLast;
-    swapCopy(target, rootBuffer.GetCurrent(), size, op.typeSize);
+    bigEndianCopy(target, rootBuffer.GetCurrent(), size, op.typeSize);
     target += (ptrdiff_t)(size * op.typeSize);
   }
 };
@@ -581,7 +581,8 @@ auto readOffsets = [](ReadOps& op, TBufferFile& rootBuffer) {
     readEntries += readLast;
     for (auto i = 0; i < readLast; ++i) {
       offsets[count++] = (int)offset;
-      offset += swap32_(reinterpret_cast<uint32_t*>(rootBuffer.GetCurrent())[i]);
+      uint32_t raw = reinterpret_cast<uint32_t*>(rootBuffer.GetCurrent())[i];
+      offset += (std::endian::native == std::endian::little) ? __builtin_bswap32(raw) : raw;
     }
   }
   offsets[count] = (int)offset;
diff --git a/Framework/AnalysisSupport/src/TableTreeHelpers.cxx b/Framework/AnalysisSupport/src/TableTreeHelpers.cxx
index 800a31e8ecac3..4cf3d3fce2266 100644
--- a/Framework/AnalysisSupport/src/TableTreeHelpers.cxx
+++ b/Framework/AnalysisSupport/src/TableTreeHelpers.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 #include "Framework/TableTreeHelpers.h"
 #include "Framework/Logger.h"
-#include "Framework/Endian.h"
 #include "Framework/Signpost.h"
 
 #include <arrow/dataset/file_base.h>
diff --git a/Framework/Core/src/FragmentToBatch.cxx b/Framework/Core/src/FragmentToBatch.cxx
index 88b4f42a8f220..1a6c3bca3cc60 100644
--- a/Framework/Core/src/FragmentToBatch.cxx
+++ b/Framework/Core/src/FragmentToBatch.cxx
@@ -10,7 +10,6 @@
 // or submit itself to any jurisdiction.
 #include "Framework/FragmentToBatch.h"
 #include "Framework/Logger.h"
-#include "Framework/Endian.h"
 #include "Framework/Signpost.h"
 
 #include <arrow/dataset/file_base.h>
diff --git a/Framework/Core/src/HTTPParser.cxx b/Framework/Core/src/HTTPParser.cxx
index fa2ba91722eb0..63537423b2708 100644
--- a/Framework/Core/src/HTTPParser.cxx
+++ b/Framework/Core/src/HTTPParser.cxx
@@ -54,7 +54,7 @@ void encode_websocket_frames(std::vector<uv_buf_t>& outputs, char const* src, si
   int maskSize = mask ? 4 : 0;
 
   if (size < 126) {
-    headerSize = sizeof(WebSocketFrameTiny);
+    headerSize = sizeof(WebSocketFrameTiny<std::endian::native>);
     // Allocate a new page if we do not fit in the current one
     if (outputs.empty() || outputs.back().len > WebSocketConstants::MaxChunkSize || (size + maskSize + headerSize) > (WebSocketConstants::MaxChunkSize - outputs.back().len)) {
       char* chunk = (char*)malloc(WebSocketConstants::MaxChunkSize);
@@ -64,11 +64,11 @@ void encode_websocket_frames(std::vector<uv_buf_t>& outputs, char const* src, si
     // Reposition the buffer to the end of the current page
     buffer = buf.base + buf.len;
     buf.len += headerSize + size + maskSize;
-    WebSocketFrameTiny* header = (WebSocketFrameTiny*)buffer;
+    auto* header = (WebSocketFrameTiny<std::endian::native>*)buffer;
     memset(buffer, 0, headerSize);
     header->len = size;
   } else if (size < 1 << 16) {
-    headerSize = sizeof(WebSocketFrameShort);
+    headerSize = sizeof(WebSocketFrameShort<std::endian::native>);
     // Allocate a new page if we do not fit in the current one
     if (outputs.empty() || outputs.back().len > WebSocketConstants::MaxChunkSize || (size + maskSize + headerSize) > (WebSocketConstants::MaxChunkSize - outputs.back().len)) {
       char* chunk = (char*)malloc(WebSocketConstants::MaxChunkSize);
@@ -78,24 +78,24 @@ void encode_websocket_frames(std::vector<uv_buf_t>& outputs, char const* src, si
     // Reposition the buffer to the end of the current page
     buffer = buf.base + buf.len;
     buf.len += headerSize + size + maskSize;
-    WebSocketFrameShort* header = (WebSocketFrameShort*)buffer;
+    auto* header = (WebSocketFrameShort<std::endian::native>*)buffer;
     memset(buffer, 0, headerSize);
     header->len = 126;
     header->len16 = htons(size);
   } else {
     // For larger messages we do standalone allocation
     // so that the message does not need to be sent in multiple chunks
-    headerSize = sizeof(WebSocketFrameHuge);
+    headerSize = sizeof(WebSocketFrameHuge<std::endian::native>);
     buffer = (char*)malloc(headerSize + maskSize + size);
-    WebSocketFrameHuge* header = (WebSocketFrameHuge*)buffer;
+    auto* header = (WebSocketFrameHuge<std::endian::native>*)buffer;
     memset(buffer, 0, headerSize);
     header->len = 127;
-    header->len64 = htonll(size);
+    header->len64 = (std::endian::native == std::endian::little) ? __builtin_bswap64(size) : size;
     outputs.push_back(uv_buf_init(buffer, size + maskSize + headerSize));
   }
   size_t fullHeaderSize = maskSize + headerSize;
   startPayload = buffer + fullHeaderSize;
-  WebSocketFrameTiny* header = (WebSocketFrameTiny*)buffer;
+  auto* header = (WebSocketFrameTiny<std::endian::native>*)buffer;
   header->fin = 1;
   header->opcode = (unsigned char)opcode; // binary or text for now
   // Mask is right before payload.
@@ -143,7 +143,7 @@ void decode_websocket(char* start, size_t size, WebSocketHandler& handler)
   handler.beginChunk();
   // The + 2 is there because we need at least 2 bytes.
   while (cur - start < size) {
-    WebSocketFrameTiny* header = (WebSocketFrameTiny*)cur;
+    auto* header = (WebSocketFrameTiny<std::endian::native>*)cur;
     size_t payloadSize = 0;
     size_t headerSize = 0;
     if ((cur + 2 - start >= size) ||
@@ -160,12 +160,12 @@ void decode_websocket(char* start, size_t size, WebSocketHandler& handler)
       payloadSize = header->len;
       headerSize = 2 + (header->mask ? 4 : 0);
     } else if (header->len == 126) {
-      WebSocketFrameShort* headerSmall = (WebSocketFrameShort*)cur;
+      auto* headerSmall = (WebSocketFrameShort<std::endian::native>*)cur;
       payloadSize = ntohs(headerSmall->len16);
       headerSize = 2 + 2 + (header->mask ? 4 : 0);
     } else if (header->len == 127) {
-      WebSocketFrameHuge* headerSmall = (WebSocketFrameHuge*)cur;
-      payloadSize = ntohll(headerSmall->len64);
+      auto* headerSmall = (WebSocketFrameHuge<std::endian::native>*)cur;
+      payloadSize = (std::endian::native == std::endian::little) ? __builtin_bswap64(headerSmall->len64) : headerSmall->len64;
       headerSize = 2 + 8 + (header->mask ? 4 : 0);
     }
     size_t availableSize = size - (cur - start);
diff --git a/Framework/Core/src/HTTPParser.h b/Framework/Core/src/HTTPParser.h
index a3253c7ca3d39..6e253a4076ff1 100644
--- a/Framework/Core/src/HTTPParser.h
+++ b/Framework/Core/src/HTTPParser.h
@@ -12,7 +12,8 @@
 #ifndef O2_FRAMEWORK_HTTPPARSER_H_
 #define O2_FRAMEWORK_HTTPPARSER_H_
 
-#include "Framework/Endian.h"
+#include <bit>
+#include <cstdint>
 #include <fmt/format.h>
 #include <uv.h>
 #include <string>
@@ -22,8 +23,11 @@
 namespace o2::framework
 {
 
-struct __attribute__((__packed__)) WebSocketFrameTiny {
-#if O2_HOST_BYTE_ORDER == O2_LITTLE_ENDIAN
+template <std::endian E>
+struct __attribute__((__packed__)) WebSocketFrameTiny;
+
+template <>
+struct __attribute__((__packed__)) WebSocketFrameTiny<std::endian::little> {
   unsigned char opcode : 4;
   unsigned char rsv3 : 1;
   unsigned char rsv2 : 1;
@@ -31,7 +35,10 @@ struct __attribute__((__packed__)) WebSocketFrameTiny {
   unsigned char fin : 1;
   unsigned char len : 7;
   unsigned char mask : 1;
-#elif O2_HOST_BYTE_ORDER == O2_BIG_ENDIAN
+};
+
+template <>
+struct __attribute__((__packed__)) WebSocketFrameTiny<std::endian::big> {
   unsigned char fin : 1;
   unsigned char rsv1 : 1;
   unsigned char rsv2 : 1;
@@ -39,13 +46,13 @@ struct __attribute__((__packed__)) WebSocketFrameTiny {
   unsigned char opcode : 4;
   unsigned char mask : 1;
   unsigned char len : 7;
-#else
-#error Uknown endiannes
-#endif
 };
 
-struct __attribute__((__packed__)) WebSocketFrameShort {
-#if O2_HOST_BYTE_ORDER == O2_LITTLE_ENDIAN
+template <std::endian E>
+struct __attribute__((__packed__)) WebSocketFrameShort;
+
+template <>
+struct __attribute__((__packed__)) WebSocketFrameShort<std::endian::little> {
   unsigned char opcode : 4;
   unsigned char rsv3 : 1;
   unsigned char rsv2 : 1;
@@ -53,7 +60,11 @@ struct __attribute__((__packed__)) WebSocketFrameShort {
   unsigned char fin : 1;
   unsigned char len : 7;
   unsigned char mask : 1;
-#elif O2_HOST_BYTE_ORDER == O2_BIG_ENDIAN
+  uint16_t len16;
+};
+
+template <>
+struct __attribute__((__packed__)) WebSocketFrameShort<std::endian::big> {
   unsigned char fin : 1;
   unsigned char rsv1 : 1;
   unsigned char rsv2 : 1;
@@ -61,14 +72,14 @@ struct __attribute__((__packed__)) WebSocketFrameShort {
   unsigned char opcode : 4;
   unsigned char mask : 1;
   unsigned char len : 7;
-#else
-#error Uknown endiannes
-#endif
   uint16_t len16;
 };
 
-struct __attribute__((__packed__)) WebSocketFrameHuge {
-#if O2_HOST_BYTE_ORDER == O2_LITTLE_ENDIAN
+template <std::endian E>
+struct __attribute__((__packed__)) WebSocketFrameHuge;
+
+template <>
+struct __attribute__((__packed__)) WebSocketFrameHuge<std::endian::little> {
   unsigned char opcode : 4;
   unsigned char rsv3 : 1;
   unsigned char rsv2 : 1;
@@ -76,7 +87,11 @@ struct __attribute__((__packed__)) WebSocketFrameHuge {
   unsigned char fin : 1;
   unsigned char len : 7;
   unsigned char mask : 1;
-#elif O2_HOST_BYTE_ORDER == O2_BIG_ENDIAN
+  uint64_t len64;
+};
+
+template <>
+struct __attribute__((__packed__)) WebSocketFrameHuge<std::endian::big> {
   unsigned char fin : 1;
   unsigned char rsv1 : 1;
   unsigned char rsv2 : 1;
@@ -84,9 +99,6 @@ struct __attribute__((__packed__)) WebSocketFrameHuge {
   unsigned char opcode : 4;
   unsigned char mask : 1;
   unsigned char len : 7;
-#else
-#error Uknown endiannes
-#endif
   uint64_t len64;
 };
 
@@ -138,9 +150,9 @@ struct WebSocketHandler {
   virtual ~WebSocketHandler() = default;
 
   /// Invoked when all the headers are received.
-  virtual void headers(std::map<std::string, std::string> const& headers){};
+  virtual void headers(std::map<std::string, std::string> const& headers) {};
   /// FIXME: not implemented
-  virtual void beginFragmentation(){};
+  virtual void beginFragmentation() {};
   /// Invoked when a frame it's parsed. Notice you do not own the data and you must
   /// not free the memory.
   virtual void frame(char const* frame, size_t s) {}
@@ -205,18 +217,18 @@ struct HTTPParser {
   std::string remaining;
   std::string error;
   std::vector<HTTPState> states;
-  virtual void method(std::string_view const& s){};
-  virtual void target(std::string_view const& s){};
-  virtual void version(std::string_view const& s){};
-  virtual void header(std::string_view const& k, std::string_view const& v){};
-  virtual void endHeaders(){};
+  virtual void method(std::string_view const& s) {};
+  virtual void target(std::string_view const& s) {};
+  virtual void version(std::string_view const& s) {};
+  virtual void header(std::string_view const& k, std::string_view const& v) {};
+  virtual void endHeaders() {};
   /// Invoked whenever we are parsing data.
   /// In order to allow for xoring (as required by the websocket standard)
   /// in place, we pass it as a mutable pointer.
-  virtual void body(char* data, size_t s){};
-  virtual void replyVersion(std::string_view const& s){};
-  virtual void replyCode(std::string_view const& s){};
-  virtual void replyMessage(std::string_view const& s){};
+  virtual void body(char* data, size_t s) {};
+  virtual void replyVersion(std::string_view const& s) {};
+  virtual void replyCode(std::string_view const& s) {};
+  virtual void replyMessage(std::string_view const& s) {};
 };
 
 struct HTTPParserHelpers {
diff --git a/Framework/Foundation/CMakeLists.txt b/Framework/Foundation/CMakeLists.txt
index dc6d7238c60ac..ba429e6ecc4e7 100644
--- a/Framework/Foundation/CMakeLists.txt
+++ b/Framework/Foundation/CMakeLists.txt
@@ -32,7 +32,8 @@ add_executable(o2-test-framework-foundation
                test/test_CallbackRegistry.cxx
                test/test_CompilerBuiltins.cxx
                #               test/test_Signpost.cxx
-               test/test_RuntimeError.cxx)
+               test/test_RuntimeError.cxx
+               test/test_BigEndian.cxx)
 target_link_libraries(o2-test-framework-foundation PRIVATE O2::FrameworkFoundation)
 target_link_libraries(o2-test-framework-foundation PRIVATE O2::Catch2)
 
@@ -65,4 +66,10 @@ install(TARGETS o2-log RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
 
 add_test(NAME framework:foundation COMMAND o2-test-framework-foundation)
 
+add_executable(o2-benchmark-framework-BigEndian
+               test/benchmark_BigEndian.cxx)
+target_link_libraries(o2-benchmark-framework-BigEndian
+                      PRIVATE O2::FrameworkFoundation benchmark::benchmark)
+set_property(TARGET o2-benchmark-framework-BigEndian PROPERTY RUNTIME_OUTPUT_DIRECTORY ${outdir})
+
 add_subdirectory(3rdparty)
diff --git a/Framework/Foundation/include/Framework/BigEndian.h b/Framework/Foundation/include/Framework/BigEndian.h
new file mode 100644
index 0000000000000..6ddb4a62a95e7
--- /dev/null
+++ b/Framework/Foundation/include/Framework/BigEndian.h
@@ -0,0 +1,64 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_FRAMEWORK_BIGENDIAN_H_
+#define O2_FRAMEWORK_BIGENDIAN_H_
+
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+namespace o2::framework
+{
+
+/// Copy @a count elements of @a typeSize bytes each from big-endian @a src
+/// into native byte order at @a dest. For typeSize == 1 or on big-endian
+/// platforms this reduces to a plain memcpy. @a dest and @a src must not overlap.
+inline void bigEndianCopy(void* dest, const void* src, int count, size_t typeSize)
+{
+  auto const totalBytes = static_cast<size_t>(count) * typeSize;
+  if constexpr (std::endian::native == std::endian::big) {
+    std::memcpy(dest, src, totalBytes);
+    return;
+  }
+  switch (typeSize) {
+    case 2: {
+      auto* p = static_cast<uint16_t*>(dest);
+      auto* q = static_cast<const uint16_t*>(src);
+      for (int i = 0; i < count; ++i) {
+        p[i] = __builtin_bswap16(q[i]);
+      }
+      return;
+    }
+    case 4: {
+      auto* p = static_cast<uint32_t*>(dest);
+      auto* q = static_cast<const uint32_t*>(src);
+      for (int i = 0; i < count; ++i) {
+        p[i] = __builtin_bswap32(q[i]);
+      }
+      return;
+    }
+    case 8: {
+      auto* p = static_cast<uint64_t*>(dest);
+      auto* q = static_cast<const uint64_t*>(src);
+      for (int i = 0; i < count; ++i) {
+        p[i] = __builtin_bswap64(q[i]);
+      }
+      return;
+    }
+  }
+  std::memcpy(dest, src, totalBytes);
+}
+
+} // namespace o2::framework
+
+#endif // O2_FRAMEWORK_BIGENDIAN_H_
diff --git a/Framework/Foundation/include/Framework/Endian.h b/Framework/Foundation/include/Framework/Endian.h
deleted file mode 100644
index 06474f7b04e6c..0000000000000
--- a/Framework/Foundation/include/Framework/Endian.h
+++ /dev/null
@@ -1,74 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#ifndef O2_FRAMEWORK_ENDIAN_H_
-#define O2_FRAMEWORK_ENDIAN_H_
-
-#include <cstdint>
-#include <concepts>
-#include <cstring>
-// Lookup file for __BYTE_ORDER
-#ifdef __APPLE__
-#include <machine/endian.h>
-#define swap16_ ntohs
-#define swap32_ ntohl
-#define swap64_ ntohll
-#else
-#include <endian.h>
-#define swap16_ be16toh
-#define swap32_ be32toh
-#define ntohll be64toh
-#define htonll htobe64
-#define swap64_ ntohll
-#endif
-#define O2_HOST_BYTE_ORDER __BYTE_ORDER
-#define O2_BIG_ENDIAN __BIG_ENDIAN
-#define O2_LITTLE_ENDIAN __LITTLE_ENDIAN
-
-inline uint16_t doSwap(std::same_as<uint16_t> auto x)
-{
-  return swap16_(x);
-}
-
-inline uint32_t doSwap(std::same_as<uint32_t> auto x)
-{
-  return swap32_(x);
-}
-
-inline uint64_t doSwap(std::same_as<uint64_t> auto x)
-{
-  return swap64_(x);
-}
-
-template <typename T>
-inline void doSwapCopy_(void* dest, void* source, int size) noexcept
-{
-  auto tdest = static_cast<T*>(dest);
-  auto tsrc = static_cast<T*>(source);
-  for (auto i = 0; i < size; ++i) {
-    tdest[i] = doSwap<T>(tsrc[i]);
-  }
-}
-
-inline void swapCopy(unsigned char* dest, char* source, int size, int typeSize) noexcept
-{
-  switch (typeSize) {
-    case 1:
-      return (void)std::memcpy(dest, source, size);
-    case 2:
-      return doSwapCopy_<uint16_t>(dest, source, size);
-    case 4:
-      return doSwapCopy_<uint32_t>(dest, source, size);
-    case 8:
-      return doSwapCopy_<uint64_t>(dest, source, size);
-  }
-}
-#endif // O2_FRAMEWORK_ENDIAN_H_
diff --git a/Framework/Foundation/test/benchmark_BigEndian.cxx b/Framework/Foundation/test/benchmark_BigEndian.cxx
new file mode 100644
index 0000000000000..30ca3160e2dac
--- /dev/null
+++ b/Framework/Foundation/test/benchmark_BigEndian.cxx
@@ -0,0 +1,65 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Framework/BigEndian.h"
+#include <benchmark/benchmark.h>
+#include <cstdint>
+#include <cstdlib>
+#include <vector>
+
+using namespace o2::framework;
+
+static void BM_BigEndianCopyUInt16(benchmark::State& state)
+{
+  auto const bytes = static_cast<size_t>(state.range(0));
+  int const count = bytes / sizeof(uint16_t);
+  std::vector<uint16_t> src(count, 0xCAFE);
+  auto* dest = static_cast<uint16_t*>(std::aligned_alloc(64, bytes));
+  for (auto _ : state) {
+    bigEndianCopy(dest, src.data(), count, sizeof(uint16_t));
+    benchmark::DoNotOptimize(dest);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * bytes);
+  std::free(dest);
+}
+BENCHMARK(BM_BigEndianCopyUInt16)->RangeMultiplier(2)->Range(32000, 512000);
+
+static void BM_BigEndianCopyUInt32(benchmark::State& state)
+{
+  auto const bytes = static_cast<size_t>(state.range(0));
+  int const count = bytes / sizeof(uint32_t);
+  std::vector<uint32_t> src(count, 0xDEADBEEF);
+  auto* dest = static_cast<uint32_t*>(std::aligned_alloc(64, bytes));
+  for (auto _ : state) {
+    bigEndianCopy(dest, src.data(), count, sizeof(uint32_t));
+    benchmark::DoNotOptimize(dest);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * bytes);
+  std::free(dest);
+}
+BENCHMARK(BM_BigEndianCopyUInt32)->RangeMultiplier(2)->Range(32000, 512000);
+
+static void BM_BigEndianCopyUInt64(benchmark::State& state)
+{
+  auto const bytes = static_cast<size_t>(state.range(0));
+  int const count = bytes / sizeof(uint64_t);
+  std::vector<uint64_t> src(count, 0x0123456789ABCDEFULL);
+  auto* dest = static_cast<uint64_t*>(std::aligned_alloc(64, bytes));
+  for (auto _ : state) {
+    bigEndianCopy(dest, src.data(), count, sizeof(uint64_t));
+    benchmark::DoNotOptimize(dest);
+  }
+  state.SetBytesProcessed(static_cast<int64_t>(state.iterations()) * bytes);
+  std::free(dest);
+}
+BENCHMARK(BM_BigEndianCopyUInt64)->RangeMultiplier(2)->Range(32000, 512000);
+
+BENCHMARK_MAIN();
diff --git a/Framework/Foundation/test/test_BigEndian.cxx b/Framework/Foundation/test/test_BigEndian.cxx
new file mode 100644
index 0000000000000..ce52b47e3aea1
--- /dev/null
+++ b/Framework/Foundation/test/test_BigEndian.cxx
@@ -0,0 +1,67 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Framework/BigEndian.h"
+#include <catch_amalgamated.hpp>
+#include <cstdint>
+#include <cstring>
+
+using namespace o2::framework;
+
+TEST_CASE("bigEndianCopy: typeSize 1 is a plain copy")
+{
+  alignas(64) uint8_t dest[64] = {};
+  uint8_t src[4] = {0x01, 0x02, 0x03, 0x04};
+  bigEndianCopy(dest, src, 4, 1);
+  REQUIRE(std::memcmp(dest, src, 4) == 0);
+}
+
+TEST_CASE("bigEndianCopy: uint16 byte swap")
+{
+  alignas(64) uint8_t dest[64] = {};
+  uint8_t src[2] = {0xCA, 0xFE}; // big-endian 0xCAFE
+  bigEndianCopy(dest, src, 1, 2);
+  uint16_t result;
+  std::memcpy(&result, dest, 2);
+  REQUIRE(result == 0xCAFE);
+}
+
+TEST_CASE("bigEndianCopy: uint32 byte swap")
+{
+  alignas(64) uint8_t dest[64] = {};
+  uint8_t src[4] = {0xDE, 0xAD, 0xBE, 0xEF}; // big-endian 0xDEADBEEF
+  bigEndianCopy(dest, src, 1, 4);
+  uint32_t result;
+  std::memcpy(&result, dest, 4);
+  REQUIRE(result == 0xDEADBEEF);
+}
+
+TEST_CASE("bigEndianCopy: uint64 byte swap")
+{
+  alignas(64) uint8_t dest[64] = {};
+  uint8_t src[8] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
+  bigEndianCopy(dest, src, 1, 8);
+  uint64_t result;
+  std::memcpy(&result, dest, 8);
+  REQUIRE(result == 0x0123456789ABCDEFULL);
+}
+
+TEST_CASE("bigEndianCopy: multiple elements")
+{
+  alignas(64) uint8_t dest[64] = {};
+  uint8_t src[8] = {0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04};
+  bigEndianCopy(dest, src, 4, 2);
+  auto* p = reinterpret_cast<uint16_t*>(dest);
+  REQUIRE(p[0] == 1);
+  REQUIRE(p[1] == 2);
+  REQUIRE(p[2] == 3);
+  REQUIRE(p[3] == 4);
+}

From f2e8a236bd1e57ddc28d5b75505164f5790dc890 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 20 Mar 2026 08:39:54 +0100
Subject: [PATCH 1646/1764] DPL Analysis: use Input/OutputSpec metadata to
 detect special tables instead of origins

---
 .../Core/include/Framework/AnalysisHelpers.h  | 37 ++++---
 .../Core/include/Framework/AnalysisManagers.h | 10 +-
 .../include/Framework/DanglingEdgesContext.h  |  9 ++
 .../Core/include/Framework/DataSpecViews.h    | 23 +++++
 Framework/Core/src/AnalysisSupportHelpers.cxx |  7 +-
 Framework/Core/src/ArrowSupport.cxx           | 86 +++++++++-------
 Framework/Core/src/WorkflowHelpers.cxx        | 99 ++++++++++++++-----
 Framework/Core/src/runDataProcessing.cxx      |  6 +-
 8 files changed, 194 insertions(+), 83 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index a01d14b6632a9..9ac78c0933600 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -358,14 +358,14 @@ template <TableRef R>
 constexpr auto tableRef2InputSpec()
 {
   std::vector<framework::ConfigParamSpec> metadata;
-  auto m = getInputMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
-  metadata.insert(metadata.end(), m.begin(), m.end());
-  auto ccdbMetadata = getCCDBMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
-  metadata.insert(metadata.end(), ccdbMetadata.begin(), ccdbMetadata.end());
-  auto p = getExpressionMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
-  metadata.insert(metadata.end(), p.begin(), p.end());
-  auto idx = getIndexMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
-  metadata.insert(metadata.end(), idx.begin(), idx.end());
+  auto sources = getInputMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  metadata.insert(metadata.end(), sources.begin(), sources.end());
+  auto ccdbURLs = getCCDBMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  metadata.insert(metadata.end(), ccdbURLs.begin(), ccdbURLs.end());
+  auto expressions = getExpressionMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  metadata.insert(metadata.end(), expressions.begin(), expressions.end());
+  auto indices = getIndexMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  metadata.insert(metadata.end(), indices.begin(), indices.end());
   if constexpr (!soa::with_ccdb_urls<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>) {
     metadata.emplace_back(framework::ConfigParamSpec{"schema", framework::VariantType::String, framework::serializeSchema(o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata::getSchema()), {"\"\""}});
   }
@@ -382,11 +382,22 @@ constexpr auto tableRef2InputSpec()
 template <TableRef R>
 constexpr auto tableRef2OutputSpec()
 {
+  std::vector<framework::ConfigParamSpec> metadata;
+  using md = typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata;
+  if constexpr (soa::with_ccdb_urls<md>) {
+    metadata.emplace_back("ccdb:", framework::VariantType::Bool, true, framework::ConfigParamSpec::HelpString{"\"\""});
+  } else if constexpr (soa::with_expression_pack<md>) {
+    metadata.emplace_back("projectors", framework::VariantType::Bool, true, framework::ConfigParamSpec::HelpString{"\"\""});
+  } else if constexpr (soa::with_index_pack<md>) {
+    metadata.emplace_back("index-records", framework::VariantType::Bool, true, framework::ConfigParamSpec::HelpString{"\"\""});
+  }
   return framework::OutputSpec{
     framework::OutputLabel{o2::aod::label<R>()},
     o2::aod::origin<R>(),
     o2::aod::description(o2::aod::signature<R>()),
-    R.version};
+    R.version,
+    framework::Lifetime::Timeframe,
+    metadata};
 }
 
 template <TableRef R>
@@ -504,14 +515,14 @@ struct OutputForTable {
   using table_t = decltype(typeWithRef<T>());
   using metadata = aod::MetadataTrait<o2::aod::Hash<table_t::ref.desc_hash>>::metadata;
 
-  static OutputSpec const spec()
+  static constexpr auto spec()
   {
-    return OutputSpec{OutputLabel{aod::label<table_t::ref>()}, o2::aod::origin<table_t::ref>(), o2::aod::description(o2::aod::signature<table_t::ref>()), table_t::ref.version};
+    return soa::tableRef2OutputSpec<table_t::ref>();
   }
 
-  static OutputRef ref()
+  static constexpr auto ref()
   {
-    return OutputRef{aod::label<table_t::ref>(), table_t::ref.version};
+    return soa::tableRef2OutputRef<table_t::ref>();
   }
 };
 
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index 121ce7f4b4a77..a411bd6eefb56 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -183,20 +183,20 @@ bool newDataframeCondition(InputRecord& record, C& conditionGroup)
 
 /// Outputs handling
 template <typename T>
-bool appendOutput(std::vector<OutputSpec>&, T&, uint32_t)
+constexpr bool appendOutput(std::vector<OutputSpec>&, T&, uint32_t)
 {
   return false;
 }
 
 template <is_produces T>
-bool appendOutput(std::vector<OutputSpec>& outputs, T&, uint32_t)
+constexpr bool appendOutput(std::vector<OutputSpec>& outputs, T&, uint32_t)
 {
-  outputs.emplace_back(OutputForTable<typename T::persistent_table_t>::spec());
+  outputs.emplace_back(soa::tableRef2OutputSpec<T::persistent_table_t::ref>());
   return true;
 }
 
 template <is_produces_group T>
-bool appendOutput(std::vector<OutputSpec>& outputs, T& producesGroup, uint32_t hash)
+constexpr bool appendOutput(std::vector<OutputSpec>& outputs, T& producesGroup, uint32_t hash)
 {
   homogeneous_apply_refs<true>([&outputs, hash](auto& produces) { return appendOutput(outputs, produces, hash); }, producesGroup);
   return true;
@@ -261,7 +261,7 @@ bool prepareOutput(ProcessingContext&, T&)
 template <is_produces T>
 bool prepareOutput(ProcessingContext& context, T& produces)
 {
-  produces.resetCursor(std::move(context.outputs().make<TableBuilder>(OutputForTable<typename T::persistent_table_t>::ref())));
+  produces.resetCursor(std::move(context.outputs().make<TableBuilder>(soa::tableRef2OutputRef<T::persistent_table_t::ref>())));
   return true;
 }
 
diff --git a/Framework/Core/include/Framework/DanglingEdgesContext.h b/Framework/Core/include/Framework/DanglingEdgesContext.h
index 90a88974db038..c5f54297ee746 100644
--- a/Framework/Core/include/Framework/DanglingEdgesContext.h
+++ b/Framework/Core/include/Framework/DanglingEdgesContext.h
@@ -33,15 +33,24 @@ struct OutputObjectInfo {
 // been requested and for which we will need to inject
 // some source device.
 struct DanglingEdgesContext {
+  // generic AOD tables
   std::vector<InputSpec> requestedAODs;
   std::vector<OutputSpec> providedAODs;
+  // extension tables
   std::vector<InputSpec> requestedDYNs;
   std::vector<OutputSpec> providedDYNs;
+  // index tables
   std::vector<InputSpec> requestedIDXs;
+  std::vector<OutputSpec> providedIDXs;
+  // ccdb tables
   std::vector<OutputSpec> providedTIMs;
   std::vector<InputSpec> requestedTIMs;
+  // output objects
   std::vector<OutputSpec> providedOutputObjHist;
+  // inputs for the extension spawner
   std::vector<InputSpec> spawnerInputs;
+  // inputs for the index builder
+  std::vector<InputSpec> builderInputs;
 
   // These are the timestamped tables which are required to
   // inject the the CCDB objecs.
diff --git a/Framework/Core/include/Framework/DataSpecViews.h b/Framework/Core/include/Framework/DataSpecViews.h
index b38866d8aa6fd..63da68ab5d53e 100644
--- a/Framework/Core/include/Framework/DataSpecViews.h
+++ b/Framework/Core/include/Framework/DataSpecViews.h
@@ -14,8 +14,31 @@
 #include "Framework/DataSpecUtils.h"
 #include <ranges>
 
+namespace o2::framework::checks
+{
+static auto has_params_with_name(std::string&& name)
+{
+  return [name](ConfigParamSpec const& p) { return p.name.compare(name) == 0; };
+}
+
+static auto has_params_with_name_starting(std::string&& name)
+{
+  return [name](ConfigParamSpec const& p) { return p.name.starts_with(name); };
+}
+} // namespace o2::framework::checks
+
 namespace o2::framework::views
 {
+static auto filter_with_params_by_name(std::string&& name)
+{
+  return std::views::filter([name = std::move(name)](auto const& spec) mutable { return std::ranges::any_of(spec.metadata, checks::has_params_with_name(std::move(name))); });
+}
+
+static auto filter_with_params_by_name_starting(std::string&& name)
+{
+  return std::views::filter([name = std::move(name)](auto const& spec) mutable { return std::ranges::any_of(spec.metadata, checks::has_params_with_name_starting(std::move(name))); });
+}
+
 static auto partial_match_filter(auto what)
 {
   return std::views::filter([what](auto const& t) -> bool { return DataSpecUtils::partialMatch(t, what); });
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index 7453751315626..21f312cd576e0 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -175,9 +175,14 @@ void AnalysisSupportHelpers::addMissingOutputsToBuilder(std::vector<InputSpec> c
   // FIXME: until we have a single list of pairs
   additionalInputs |
     views::partial_match_filter(AODOrigins) |
+    std::ranges::views::filter([](InputSpec const& input) {
+      return std::ranges::none_of(input.metadata, [](ConfigParamSpec const& p) { return (p.name.compare("projectors") == 0) || (p.name.compare("index-records") == 0); });
+    }) |
     sinks::update_input_list{requestedAODs}; // update requestedAODs
   additionalInputs |
-    views::partial_match_filter(header::DataOrigin{"DYN"}) |
+    std::ranges::views::filter([](InputSpec const& input) {
+      return std::ranges::any_of(input.metadata, [](ConfigParamSpec const& p) { return p.name.compare("projectors") == 0; });
+    }) |
     sinks::update_input_list{requestedDYNs}; // update requestedDYNs
 }
 
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index c5cc021a53478..1819307e26806 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -50,7 +50,6 @@ O2_DECLARE_DYNAMIC_LOG(rate_limiting);
 
 namespace o2::framework
 {
-
 class EndOfStreamContext;
 class ProcessingContext;
 
@@ -578,45 +577,80 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        } },
     .adjustTopology = [](WorkflowSpecNode& node, ConfigContext const& ctx) {
       auto& workflow = node.specs;
-      auto spawner = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-spawner"); });
-      auto analysisCCDB = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-ccdb"); });
-      auto builder = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-index-builder"); });
-      auto writer = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-writer"); });
       auto& dec = ctx.services().get<DanglingEdgesContext>();
       dec.requestedAODs.clear();
       dec.requestedDYNs.clear();
-      dec.providedDYNs.clear();
-      dec.providedTIMs.clear();
-      dec.requestedTIMs.clear();
 
       auto inputSpecLessThan = [](InputSpec const& lhs, InputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
       auto outputSpecLessThan = [](OutputSpec const& lhs, OutputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
 
+      auto builder = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-index-builder"); });
       if (builder != workflow.end()) {
         // collect currently requested IDXs
         dec.requestedIDXs.clear();
+        dec.providedIDXs.clear();
         for (auto& d : workflow | views::exclude_by_name(builder->name)) {
           d.inputs |
-            views::partial_match_filter(header::DataOrigin{"IDX"}) |
+            views::filter_with_params_by_name("index-records") |
             sinks::update_input_list{dec.requestedIDXs};
+          d.outputs |
+            views::filter_with_params_by_name("index-records") |
+            sinks::update_output_list{dec.providedIDXs};
         }
+        std::ranges::sort(dec.requestedIDXs, inputSpecLessThan);
+        std::ranges::sort(dec.providedIDXs, outputSpecLessThan);
+        dec.builderInputs.clear();
+        dec.requestedIDXs |
+          views::filter_not_matching(dec.providedIDXs) |
+          sinks::append_to{dec.builderInputs};
         // recreate inputs and outputs
         builder->inputs.clear();
         builder->outputs.clear();
+        AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.builderInputs, dec.requestedAODs, dec.requestedDYNs, *builder);
+        if (!builder->inputs.empty()) {
+          // load real AlgorithmSpec before deployment
+          builder->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx);
+        }
+      }
+
+      auto analysisCCDB = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-ccdb"); });
+      if (analysisCCDB != workflow.end()) {
+        dec.requestedTIMs.clear();
+        dec.providedTIMs.clear();
+        for (auto& d : workflow | views::exclude_by_name(analysisCCDB->name)) {
+          d.inputs |
+            views::filter_with_params_by_name_starting("ccdb:") |
+            sinks::update_input_list{dec.requestedTIMs};
+          d.outputs |
+            views::filter_with_params_by_name_starting("ccdb:") |
+            sinks::append_to{dec.providedTIMs};
+        }
+        std::ranges::sort(dec.requestedTIMs, inputSpecLessThan);
+        std::ranges::sort(dec.providedTIMs, outputSpecLessThan);
+        // Use ranges::to<std::vector<>> in C++23...
+        dec.analysisCCDBInputs.clear();
+        dec.requestedTIMs |
+          views::filter_not_matching(dec.providedTIMs) |
+          sinks::append_to{dec.analysisCCDBInputs};
 
+        // recreate inputs and outputs
+        analysisCCDB->outputs.clear();
+        analysisCCDB->inputs.clear();
+        AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.analysisCCDBInputs, dec.requestedAODs, dec.requestedDYNs, *analysisCCDB);
         // load real AlgorithmSpec before deployment
-        builder->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "IndexTableBuilder", ctx);
-        AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.requestedIDXs, dec.requestedAODs, dec.requestedDYNs, *builder);
+        analysisCCDB->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
       }
 
+      auto spawner = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-spawner"); });
       if (spawner != workflow.end()) {
+        dec.providedDYNs.clear();
         // collect currently requested DYNs
         for (auto& d : workflow | views::exclude_by_name(spawner->name)) {
           d.inputs |
-            views::partial_match_filter(header::DataOrigin{"DYN"}) |
+            views::filter_with_params_by_name("projectors") |
             sinks::update_input_list{dec.requestedDYNs};
           d.outputs |
-            views::partial_match_filter(header::DataOrigin{"DYN"}) |
+            views::filter_with_params_by_name("projectors") |
             sinks::append_to{dec.providedDYNs};
         }
         std::ranges::sort(dec.requestedDYNs, inputSpecLessThan);
@@ -628,32 +662,14 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         // recreate inputs and outputs
         spawner->outputs.clear();
         spawner->inputs.clear();
-
-        // load real AlgorithmSpec before deployment
-        spawner->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx);
         AnalysisSupportHelpers::addMissingOutputsToSpawner({}, dec.spawnerInputs, dec.requestedAODs, *spawner);
-      }
-
-      if (analysisCCDB != workflow.end()) {
-        for (auto& d : workflow | views::exclude_by_name(analysisCCDB->name)) {
-          d.inputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::update_input_list{dec.requestedTIMs};
-          d.outputs | views::partial_match_filter(header::DataOrigin{"ATIM"}) | sinks::append_to{dec.providedTIMs};
+        if (!spawner->inputs.empty()) {
+          // load real AlgorithmSpec before deployment
+          spawner->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkOnDemandTablesSupport", "ExtendedTableSpawner", ctx);
         }
-        std::ranges::sort(dec.requestedTIMs, inputSpecLessThan);
-        std::ranges::sort(dec.providedTIMs, outputSpecLessThan);
-        // Use ranges::to<std::vector<>> in C++23...
-        dec.analysisCCDBInputs.clear();
-        dec.requestedTIMs | views::filter_not_matching(dec.providedTIMs) | sinks::append_to{dec.analysisCCDBInputs};
-
-        // recreate inputs and outputs
-        analysisCCDB->outputs.clear();
-        analysisCCDB->inputs.clear();
-        // load real AlgorithmSpec before deployment
-        // FIXME how can I make the lookup depend on DYN tables as well??
-        analysisCCDB->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
-        AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.analysisCCDBInputs, dec.requestedAODs, dec.requestedDYNs, *analysisCCDB);
       }
 
+      auto writer = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) { return spec.name.starts_with("internal-dpl-aod-writer"); });
       if (writer != workflow.end()) {
         workflow.erase(writer);
       }
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index abe566e239618..03ad3bd4b8829 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -234,6 +234,8 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   ctx.services().registerService(ServiceRegistryHelpers::handleForService<DanglingEdgesContext>(new DanglingEdgesContext));
   auto& dec = ctx.services().get<DanglingEdgesContext>();
 
+  std::vector<OutputSpec> DYNs;
+
   std::vector<InputSpec> requestedCCDBs;
   std::vector<OutputSpec> providedCCDBs;
 
@@ -279,6 +281,24 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     bool hasConditionOption = false;
     for (size_t ii = 0; ii < processor.inputs.size(); ++ii) {
       auto& input = processor.inputs[ii];
+      bool hasProjectors = false;
+      bool hasIndexRecords = false;
+      bool hasCCDBURLs = false;
+      // all three options are exclusive
+      for (auto const& p : input.metadata) {
+        if (p.name.compare("projectors") == 0) {
+          hasProjectors = true;
+          break;
+        }
+        if (p.name.compare("index-records") == 0) {
+          hasIndexRecords = true;
+          break;
+        }
+        if (p.name.starts_with("ccdb:")) {
+          hasCCDBURLs = true;
+          break;
+        }
+      }
       switch (input.lifetime) {
         case Lifetime::Timer: {
           auto concrete = DataSpecUtils::asConcreteDataMatcher(input);
@@ -318,29 +338,49 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
         case Lifetime::Optional:
           break;
       }
-      if (DataSpecUtils::partialMatch(input, AODOrigins)) {
-        DataSpecUtils::updateInputList(dec.requestedAODs, InputSpec{input});
-      }
-      if (DataSpecUtils::partialMatch(input, header::DataOrigin{"DYN"})) {
+      if (hasProjectors) {
         DataSpecUtils::updateInputList(dec.requestedDYNs, InputSpec{input});
-      }
-      if (DataSpecUtils::partialMatch(input, header::DataOrigin{"IDX"})) {
+      } else if (hasIndexRecords) {
         DataSpecUtils::updateInputList(dec.requestedIDXs, InputSpec{input});
-      }
-      if (DataSpecUtils::partialMatch(input, header::DataOrigin{"ATIM"})) {
+      } else if (hasCCDBURLs) {
         DataSpecUtils::updateInputList(dec.requestedTIMs, InputSpec{input});
+      } else if (DataSpecUtils::partialMatch(input, AODOrigins)) {
+        DataSpecUtils::updateInputList(dec.requestedAODs, InputSpec{input});
       }
     }
 
     std::ranges::stable_sort(timer.outputs, [](OutputSpec const& a, OutputSpec const& b) { return *DataSpecUtils::getOptionalSubSpec(a) < *DataSpecUtils::getOptionalSubSpec(b); });
 
     for (auto& output : processor.outputs) {
-      if (DataSpecUtils::partialMatch(output, AODOrigins)) {
-        dec.providedAODs.emplace_back(output);
-      } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"DYN"})) {
+      bool hasProjectors = false;
+      bool hasIndexRecords = false;
+      bool hasCCDBURLs = false;
+      // all three options are exclusive
+      for (auto const& p : output.metadata) {
+        if (p.name.compare("projectors") == 0) {
+          hasProjectors = true;
+          break;
+        }
+        if (p.name.compare("index-records") == 0) {
+          hasIndexRecords = true;
+          break;
+        }
+        if (p.name.starts_with("ccdb:")) {
+          hasCCDBURLs = true;
+          break;
+        }
+      }
+      if (DataSpecUtils::partialMatch(output, header::DataOrigin{"DYN"})) {
+        DYNs.emplace_back(output);
+      }
+      if (hasProjectors) {
         dec.providedDYNs.emplace_back(output);
-      } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"ATIM"})) {
+      } else if (hasCCDBURLs) {
         dec.providedTIMs.emplace_back(output);
+      } else if (hasIndexRecords) {
+        dec.providedIDXs.emplace_back(output);
+      } else if (DataSpecUtils::partialMatch(output, AODOrigins)) {
+        dec.providedAODs.emplace_back(output);
       } else if (DataSpecUtils::partialMatch(output, header::DataOrigin{"ATSK"})) {
         dec.providedOutputObjHist.emplace_back(output);
         auto it = std::ranges::find_if(dec.outObjHistMap, [&](auto&& x) { return x.id == hash; });
@@ -350,6 +390,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
           it->bindings.push_back(output.binding.value);
         }
       }
+
       if (output.lifetime == Lifetime::Condition) {
         providedCCDBs.push_back(output);
       }
@@ -358,10 +399,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   auto inputSpecLessThan = [](InputSpec const& lhs, InputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
   auto outputSpecLessThan = [](OutputSpec const& lhs, OutputSpec const& rhs) { return DataSpecUtils::describe(lhs) < DataSpecUtils::describe(rhs); };
-  std::ranges::sort(dec.requestedDYNs, inputSpecLessThan);
-  std::ranges::sort(dec.requestedTIMs, inputSpecLessThan);
-  std::ranges::sort(dec.providedDYNs, outputSpecLessThan);
-  std::ranges::sort(dec.providedTIMs, outputSpecLessThan);
 
   DataProcessorSpec indexBuilder{
     "internal-dpl-aod-index-builder",
@@ -369,14 +406,18 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     {},
     AlgorithmSpec::dummyAlgorithm(), // real algorithm will be set in adjustTopology
     {}};
-  AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.requestedIDXs, dec.requestedAODs, dec.requestedDYNs, indexBuilder);
+  std::ranges::sort(dec.requestedIDXs, inputSpecLessThan);
+  std::ranges::sort(dec.providedIDXs, outputSpecLessThan);
+  dec.requestedIDXs | views::filter_not_matching(dec.providedIDXs) | sinks::append_to{dec.builderInputs};
+  AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.builderInputs, dec.requestedAODs, dec.requestedDYNs, indexBuilder);
 
+  std::ranges::sort(dec.requestedTIMs, inputSpecLessThan);
+  std::ranges::sort(dec.providedTIMs, outputSpecLessThan);
   dec.requestedTIMs | views::filter_not_matching(dec.providedTIMs) | sinks::append_to{dec.analysisCCDBInputs};
-  DeploymentMode deploymentMode = DefaultsHelpers::deploymentMode();
-  if (deploymentMode != DeploymentMode::OnlineDDS && deploymentMode != DeploymentMode::OnlineECS) {
-    AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.analysisCCDBInputs, dec.requestedAODs, dec.requestedTIMs, analysisCCDBBackend);
-  }
+  AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.analysisCCDBInputs, dec.requestedAODs, dec.requestedDYNs, analysisCCDBBackend);
 
+  std::ranges::sort(dec.requestedDYNs, inputSpecLessThan);
+  std::ranges::sort(dec.providedDYNs, outputSpecLessThan);
   dec.requestedDYNs | views::filter_not_matching(dec.providedDYNs) | sinks::append_to{dec.spawnerInputs};
 
   DataProcessorSpec aodSpawner{
@@ -386,6 +427,9 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     AlgorithmSpec::dummyAlgorithm(), // real algorithm will be set in adjustTopology
     {}};
   AnalysisSupportHelpers::addMissingOutputsToSpawner({}, dec.spawnerInputs, dec.requestedAODs, aodSpawner);
+
+  std::ranges::sort(dec.requestedAODs, inputSpecLessThan);
+  std::ranges::sort(dec.providedAODs, outputSpecLessThan);
   AnalysisSupportHelpers::addMissingOutputsToReader(dec.providedAODs, dec.requestedAODs, aodReader);
 
   std::ranges::sort(requestedCCDBs, inputSpecLessThan);
@@ -409,6 +453,14 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     extraSpecs.push_back(indexBuilder);
   }
 
+  // add the Analysys CCDB backend which reads CCDB objects using a provided table
+  DeploymentMode deploymentMode = DefaultsHelpers::deploymentMode();
+  if (deploymentMode != DeploymentMode::OnlineDDS && deploymentMode != DeploymentMode::OnlineECS) {
+    if (analysisCCDBBackend.outputs.empty() == false) {
+      extraSpecs.push_back(analysisCCDBBackend);
+    }
+  }
+
   // add the reader
   if (aodReader.outputs.empty() == false) {
     auto mctracks2aod = std::ranges::find_if(workflow, [](auto const& x) { return x.name == "mctracks-to-aod"; });
@@ -511,11 +563,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     DataSpecUtils::updateOutputList(workflow[enumCandidate].outputs, OutputSpec{{"ccdb-diststf"}, dstf, Lifetime::Timeframe});
   }
 
-  // add the Analysys CCDB backend which reads CCDB objects using a provided table
-  if (analysisCCDBBackend.outputs.empty() == false) {
-    extraSpecs.push_back(analysisCCDBBackend);
-  }
-
   // add the timer
   if (timer.outputs.empty() == false) {
     extraSpecs.push_back(timer);
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 70f3c8940ef26..03cef9a034144 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1685,15 +1685,15 @@ int runStateMachine(DataProcessorSpecs const& workflow,
               continue;
             }
             // ignore devices with no metadata in inputs
-            auto hasMetadata = std::any_of(device.inputs.begin(), device.inputs.end(), [](InputSpec const& spec) {
+            auto hasMetadata = std::ranges::any_of(device.inputs, [](InputSpec const& spec) {
               return spec.metadata.empty() == false;
             });
             if (!hasMetadata) {
               continue;
             }
             // ignore devices with no control options
-            auto hasControls = std::any_of(device.inputs.begin(), device.inputs.end(), [](InputSpec const& spec) {
-              return std::any_of(spec.metadata.begin(), spec.metadata.end(), [](ConfigParamSpec const& param) {
+            auto hasControls = std::ranges::any_of(device.inputs, [](InputSpec const& spec) {
+              return std::ranges::any_of(spec.metadata, [](ConfigParamSpec const& param) {
                 return param.type == VariantType::Bool && param.name.find("control:") != std::string::npos;
               });
             });

From 2599a8cca7cd7783020d85f932f5868fb85be20f Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 27 Mar 2026 11:42:18 +0100
Subject: [PATCH 1647/1764] DPL Analysis: remove special origins and add From<>
 version for auto-generated tables

---
 .../AnalysisSupport/src/AODWriterHelpers.cxx  |   5 +-
 Framework/Core/include/Framework/ASoA.h       | 262 ++++++++++--------
 .../include/Framework/AnalysisDataModel.h     |  34 ++-
 .../Core/include/Framework/AnalysisHelpers.h  |  67 ++++-
 .../Core/include/Framework/AnalysisManagers.h |  14 +-
 .../Framework/AnalysisSupportHelpers.h        |   6 +-
 Framework/Core/src/AnalysisDataModel.cxx      |  14 +-
 Framework/Core/src/AnalysisSupportHelpers.cxx |   2 +-
 Framework/Core/src/WorkflowHelpers.cxx        |  27 +-
 Framework/Core/test/test_Concepts.cxx         |   2 +-
 Framework/Core/test/test_IndexBuilder.cxx     |   6 +-
 .../TestWorkflows/src/o2TestMultisource.cxx   |   6 +-
 12 files changed, 263 insertions(+), 182 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index b76ffca13977e..19cf7a1ebff7b 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -21,7 +21,6 @@
 #include "Framework/TableConsumer.h"
 #include "Framework/DataOutputDirector.h"
 #include "Framework/TableTreeHelpers.h"
-#include "Framework/Monitoring.h"
 #include "Framework/Signpost.h"
 
 #include <Monitoring/Monitoring.h>
@@ -32,8 +31,6 @@
 #include <TMap.h>
 #include <TObjString.h>
 #include <arrow/table.h>
-#include <chrono>
-#include <ios>
 
 O2_DECLARE_DYNAMIC_LOG(histogram_registry);
 
@@ -157,7 +154,7 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
         }
 
         // skip non-AOD refs
-        if (!DataSpecUtils::partialMatch(*ref.spec, writableAODOrigins)) {
+        if (!DataSpecUtils::partialMatch(*ref.spec, AODOrigins)) {
           continue;
         }
         startTime = DataRefUtils::getHeader<DataProcessingHeader*>(ref)->startTime;
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 96a4fe08cdd61..1628ec2039483 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -395,6 +395,20 @@ static constexpr auto sourceSpec()
 {
   return fmt::format("{}/{}/{}/{}", label<R>(), origin_str<R>(), description_str(signature<R>()), R.version);
 }
+
+/// Replace origins in the TableRef array
+template <size_t N, std::array<soa::TableRef, N> ar, o2::aod::is_origin_hash O>
+consteval auto replaceOrigin()
+{
+  std::array<soa::TableRef, N> res;
+  for (auto i = 0U; i < N; ++i) {
+    res[i].label_hash = ar[i].label_hash;
+    res[i].desc_hash = ar[i].desc_hash;
+    res[i].origin_hash = O::hash;
+    res[i].version = ar[i].version;
+  }
+  return res;
+}
 } // namespace o2::aod
 
 namespace o2::soa
@@ -1311,6 +1325,11 @@ concept with_sources = requires {
   T::sources.size();
 };
 
+template <typename T>
+concept with_sources_generator = requires(T t) {
+  t.template generateSources<o2::aod::Hash<"AOD"_h>>();
+};
+
 template <typename T>
 concept with_ccdb_urls = requires {
   T::ccdb_urls.size();
@@ -1318,7 +1337,7 @@ concept with_ccdb_urls = requires {
 
 template <typename T>
 concept with_base_table = requires {
-  typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t;
+  typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata::base_table_t;
 };
 
 template <typename T>
@@ -1384,9 +1403,10 @@ static constexpr std::string getLabelFromType()
   return getLabelForTable<typename std::decay_t<T>::first_t>();
 }
 template <soa::with_base_table T>
+  requires(!soa::is_iterator<T>)
 static constexpr std::string getLabelFromType()
 {
-  return getLabelForTable<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata::base_table_t>();
+  return getLabelForTable<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata::base_table_t>();
 }
 
 template <typename... C>
@@ -1811,17 +1831,17 @@ consteval auto computeOriginals()
 }
 
 template <TableRef ref, typename... Ts>
-  requires((sizeof...(Ts) > 0) && (!o2::soa::is_column<Ts> || ...))
+  requires((sizeof...(Ts) > 0) && (!(o2::soa::is_column<Ts> && ...)))
 consteval auto computeOriginals()
 {
   return o2::soa::mergeOriginals<Ts...>();
 }
 
-template <size_t N, std::array<TableRef, N> refs>
-consteval auto commonOrigin()
-{
-  return (refs | std::ranges::views::filter([](TableRef const& r) { return (!(r.origin_hash == "DYN"_h || r.origin_hash == "IDX"_h)); })).front().origin_hash;
-}
+// template <size_t N, std::array<TableRef, N> refs>
+// consteval auto commonOrigin()
+// {
+//   return (refs | std::ranges::views::filter([](TableRef const& r) { return (!(r.origin_hash == "DYN"_h || r.origin_hash == "IDX"_h)); })).front().origin_hash;
+// }
 
 /// A Table class which observes an arrow::Table and provides
 /// It is templated on a set of Column / DynamicColumn types.
@@ -1837,7 +1857,8 @@ class Table
   static constexpr const auto originalLabels = []<size_t N, std::array<TableRef, N> refs, size_t... Is>(std::index_sequence<Is...>) {
     return std::array<const char*, N>{o2::aod::label<refs[Is]>()...};
   }.template operator()<originals.size(), originals>(std::make_index_sequence<originals.size()>());
-  static constexpr const uint32_t binding_origin = commonOrigin<originals.size(), originals>();
+  static constexpr const uint32_t binding_origin = originals[0].origin_hash; // commonOrigin<originals.size(), originals>();
+  static constexpr header::DataOrigin binding_origin_ = o2::aod::Hash<binding_origin>::origin;
 
   template <size_t N, std::array<TableRef, N> bindings>
     requires(ref.origin_hash == "CONC"_h)
@@ -1850,10 +1871,10 @@ class Table
     requires(ref.origin_hash == "JOIN"_h)
   static consteval auto isIndexTargetOf()
   {
-    return std::ranges::find_if(self_t::originals,
-                                [](TableRef const& r) {
-                                  return std::ranges::find(bindings, r) != bindings.end();
-                                }) != self_t::originals.end();
+    return std::ranges::any_of(self_t::originals,
+                               [](TableRef const& r) {
+                                 return std::ranges::any_of(bindings, [&r](TableRef const& b) { return b == r; });
+                               });
   }
 
   template <size_t N, std::array<TableRef, N> bindings>
@@ -1866,7 +1887,7 @@ class Table
   template <TableRef r>
   static consteval bool hasOriginal()
   {
-    return std::find_if(originals.begin(), originals.end(), [](TableRef const& o) { return o.desc_hash == r.desc_hash; }) != originals.end();
+    return std::ranges::any_of(originals, [](TableRef const& o) { return o.desc_hash == r.desc_hash; });
   }
 
   using columns_t = decltype(getColumns<ref, Ts...>());
@@ -2389,9 +2410,9 @@ namespace o2::aod
 O2ORIGIN("AOD");
 O2ORIGIN("AOD1");
 O2ORIGIN("AOD2");
-O2ORIGIN("DYN");
-O2ORIGIN("IDX");
-O2ORIGIN("ATIM");
+// O2ORIGIN("DYN");
+// O2ORIGIN("IDX");
+// O2ORIGIN("ATIM");
 O2ORIGIN("JOIN");
 O2HASH("JOIN/0");
 O2ORIGIN("CONC");
@@ -3273,85 +3294,113 @@ consteval auto getIndexTargets()
 #define DECLARE_SOA_TABLE_STAGED(_BaseName_, _Desc_, ...) \
   DECLARE_SOA_TABLE_STAGED_VERSIONED(_BaseName_, _Desc_, 0, __VA_ARGS__);
 
-#define DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, _Label_, _OriginalTable_, _Origin_, _Desc_, _Version_, ...)                     \
+#define DECLARE_SOA_EXTENDED_TABLE_NG(_Name_, _OriginalTable_, _Desc_, _Version_, ...)                                          \
   O2HASH(_Desc_ "/" #_Version_);                                                                                                \
+  O2HASH(#_Name_ "Extension");                                                                                                  \
   template <typename O>                                                                                                         \
-  using _Name_##ExtensionFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>;          \
-  using _Name_##Extension = _Name_##ExtensionFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                \
-  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                          \
-  struct _Name_##ExtensionMetadataFrom : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                \
+  using _Name_##ExtensionFrom = soa::Table<o2::aod::Hash<#_Name_ "Extension"_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>; \
+  using _Name_##Extension = _Name_##ExtensionFrom<o2::aod::Hash<"AOD"_h>>;                                                      \
+  struct _Name_##ExtensionMetadata : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                    \
     using base_table_t = _OriginalTable_;                                                                                       \
-    using extension_table_t = _Name_##ExtensionFrom<O>;                                                                         \
+    template <o2::aod::is_origin_hash O>                                                                                        \
+    using extension_table_t_from = _Name_##ExtensionFrom<O>;                                                                    \
+    using extension_table_t = _Name_##Extension;                                                                                \
     using expression_pack_t = framework::pack<__VA_ARGS__>;                                                                     \
-    static constexpr auto sources = _OriginalTable_::originals;                                                                 \
+    static constexpr auto N = _OriginalTable_::originals.size();                                                                \
+    template <o2::aod::is_origin_hash O = o2::aod::Hash<"AOD"_h>>                                                               \
+    static consteval auto generateSources()                                                                                     \
+    {                                                                                                                           \
+      return _OriginalTable_##From<O>::originals;                                                                               \
+    }                                                                                                                           \
   };                                                                                                                            \
-  using _Name_##ExtensionMetadata = _Name_##ExtensionMetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                                \
   template <>                                                                                                                   \
   struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                             \
     using metadata = _Name_##ExtensionMetadata;                                                                                 \
   };                                                                                                                            \
   template <typename O>                                                                                                         \
-  using _Name_##From = o2::soa::JoinFull<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, _OriginalTable_, _Name_##ExtensionFrom<O>>; \
-  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
+  using _Name_##From = o2::soa::Join<_OriginalTable_##From<O>, _Name_##ExtensionFrom<O>>;                                       \
+  using _Name_ = _Name_##From<o2::aod::Hash<"AOD"_h>>;
 
 #define DECLARE_SOA_EXTENDED_TABLE(_Name_, _Table_, _Description_, _Version_, ...) \
-  O2HASH(#_Name_ "Extension");                                                     \
-  DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, #_Name_ "Extension", _Table_, "DYN", _Description_, _Version_, __VA_ARGS__)
+  DECLARE_SOA_EXTENDED_TABLE_NG(_Name_, _Table_, _Description_, _Version_, __VA_ARGS__)
 
 #define DECLARE_SOA_EXTENDED_TABLE_USER(_Name_, _Table_, _Description_, ...) \
-  O2HASH(#_Name_ "Extension");                                               \
-  DECLARE_SOA_EXTENDED_TABLE_FULL(_Name_, #_Name_ "Extension", _Table_, "AOD", "EX" _Description_, 0, __VA_ARGS__)
-
-#define DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_FULL(_Name_, _Label_, _OriginalTable_, _Origin_, _Desc_, _Version_, ...)           \
-  O2HASH(_Desc_ "/" #_Version_);                                                                                                   \
-  template <typename O>                                                                                                            \
-  using _Name_##CfgExtensionFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>;          \
-  using _Name_##CfgExtension = _Name_##CfgExtensionFrom<o2::aod::Hash<_Origin_ ""_h>>;                                             \
-  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                             \
-  struct _Name_##CfgExtensionMetadataFrom : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                \
-    using base_table_t = _OriginalTable_;                                                                                          \
-    using extension_table_t = _Name_##CfgExtensionFrom<O>;                                                                         \
-    using placeholders_pack_t = framework::pack<__VA_ARGS__>;                                                                      \
-    using configurable_t = std::true_type;                                                                                         \
-    static constexpr auto sources = _OriginalTable_::originals;                                                                    \
-  };                                                                                                                               \
-  using _Name_##CfgExtensionMetadata = _Name_##CfgExtensionMetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                             \
-  template <>                                                                                                                      \
-  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                \
-    using metadata = _Name_##CfgExtensionMetadata;                                                                                 \
-  };                                                                                                                               \
-  template <typename O>                                                                                                            \
-  using _Name_##From = o2::soa::JoinFull<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, _OriginalTable_, _Name_##CfgExtensionFrom<O>>; \
-  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
+  DECLARE_SOA_EXTENDED_TABLE_NG(_Name_, _Table_, "EX" _Description_, 0, __VA_ARGS__)
+
+#define DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_NG(_Name_, _OriginalTable_, _Desc_, _Version_, ...)                                   \
+  O2HASH(_Desc_ "/" #_Version_);                                                                                                      \
+  O2HASH(#_Name_ "CfgExtension");                                                                                                     \
+  template <typename O>                                                                                                               \
+  using _Name_##CfgExtensionFrom = soa::Table<o2::aod::Hash<#_Name_ "CfgExtension"_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>; \
+  using _Name_##CfgExtension = _Name_##CfgExtensionFrom<o2::aod::Hash<"AOD"_h>>;                                                      \
+  struct _Name_##CfgExtensionMetadata : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                       \
+    using base_table_t = _OriginalTable_;                                                                                             \
+    template <o2::aod::is_origin_hash O>                                                                                              \
+    using extension_table_t_from = _Name_##CfgExtensionFrom<O>;                                                                       \
+    using extension_table_t = _Name_##CfgExtension;                                                                                   \
+    using placeholders_pack_t = framework::pack<__VA_ARGS__>;                                                                         \
+    using configurable_t = std::true_type;                                                                                            \
+    static constexpr auto N = _OriginalTable_::originals.size();                                                                      \
+    template <o2::aod::is_origin_hash O = o2::aod::Hash<"AOD"_h>>                                                                     \
+    static consteval auto generateSources()                                                                                           \
+    {                                                                                                                                 \
+      return _OriginalTable_##From<O>::originals;                                                                                     \
+    }                                                                                                                                 \
+  };                                                                                                                                  \
+  template <>                                                                                                                         \
+  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                   \
+    using metadata = _Name_##CfgExtensionMetadata;                                                                                    \
+  };                                                                                                                                  \
+  template <typename O>                                                                                                               \
+  using _Name_##From = o2::soa::Join<_OriginalTable_##From<O>, _Name_##CfgExtensionFrom<O>>;                                          \
+  using _Name_ = _Name_##From<o2::aod::Hash<"AOD"_h>>;
+
+#define DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(_Name_, _OriginalTable_, _Description_, ...) \
+  DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_NG(_Name_, _OriginalTable_, "EX" _Description_, 0, __VA_ARGS__)
+
+#define DECLARE_SOA_INDEX_TABLE_NG(_Name_, _Key_, _Version_, _Desc_, _Exclusive_, ...)                                                              \
+  O2HASH(#_Name_);                                                                                                                                  \
+  O2HASH(_Desc_ "/" #_Version_);                                                                                                                    \
+  struct _Name_##Metadata : o2::aod::TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, soa::Index<>, __VA_ARGS__> {                          \
+    static constexpr bool exclusive = _Exclusive_;                                                                                                  \
+    template <o2::aod::is_origin_hash O>                                                                                                            \
+    using KeyFrom = _Key_##From<O>;                                                                                                                 \
+    using Key = _Key_;                                                                                                                              \
+    using index_pack_t = framework::pack<__VA_ARGS__>;                                                                                              \
+    template <o2::aod::is_origin_hash O = o2::aod::Hash<"AOD"_h>>                                                                                   \
+    static consteval auto generateSources()                                                                                                         \
+    {                                                                                                                                               \
+      return []<soa::is_index_column... Cs>(framework::pack<Cs...>) {                                                                               \
+        constexpr auto first = o2::soa::mergeOriginals<typename Cs::binding_t...>();                                                                \
+        constexpr auto second = o2::aod::filterForKey<first.size(), first, Key>();                                                                  \
+        return o2::aod::replaceOrigin<second.size(), second, O>();                                                                                  \
+      }(framework::pack<__VA_ARGS__>{});                                                                                                            \
+    }                                                                                                                                               \
+    static constexpr auto N = []<typename... Cs>(framework::pack<Cs...>) {                                                                          \
+      constexpr auto a = o2::soa::mergeOriginals<typename Cs::binding_t...>();                                                                      \
+      return o2::aod::filterForKey<a.size(), a, Key>();                                                                                             \
+    }(framework::pack<__VA_ARGS__>{})                                                                                                               \
+                                .size();                                                                                                            \
+  };                                                                                                                                                \
+  template <>                                                                                                                                       \
+  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                                 \
+    using metadata = _Name_##Metadata;                                                                                                              \
+  };                                                                                                                                                \
+  template <o2::aod::is_origin_hash O>                                                                                                              \
+  using _Name_##From = o2::soa::IndexTable<o2::aod::Hash<#_Name_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O, _Key_##From<O>, __VA_ARGS__>; \
+  using _Name_ = _Name_##From<o2::aod::Hash<"AOD"_h>>;
 
-#define DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE(_Name_, _Table_, _Description_, ...) \
-  O2HASH(#_Name_ "CfgExtension");                                                    \
-  DECLARE_SOA_CONFIGURABLE_EXTENDED_TABLE_FULL(_Name_, #_Name_ "CfgExtension", _Table_, "AOD", "EX" _Description_, 0, __VA_ARGS__)
-
-#define DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, _Origin_, _Version_, _Desc_, _Exclusive_, ...)                                                              \
-  O2HASH(#_Name_);                                                                                                                                              \
-  O2HASH(_Desc_ "/" #_Version_);                                                                                                                                \
-  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                                                          \
-  struct _Name_##MetadataFrom : o2::aod::TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, soa::Index<>, __VA_ARGS__> {                                  \
-    static constexpr bool exclusive = _Exclusive_;                                                                                                              \
-    using Key = _Key_;                                                                                                                                          \
-    using index_pack_t = framework::pack<__VA_ARGS__>;                                                                                                          \
-    static constexpr const auto sources = []<typename... Cs>(framework::pack<Cs...>) {                                                                          \
-      constexpr auto a = o2::soa::mergeOriginals<typename Cs::binding_t...>();                                                                                  \
-      return o2::aod::filterForKey<a.size(), a, Key>();                                                                                                         \
-    }(framework::pack<__VA_ARGS__>{});                                                                                                                          \
-    static_assert(sources.size() - Key::originals.size() + 1 == framework::pack_size(index_pack_t{}), "One of the referred tables does not have index to Key"); \
-  };                                                                                                                                                            \
-  using _Name_##Metadata = _Name_##MetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                                                  \
-                                                                                                                                                                \
-  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                                                          \
-  using _Name_##From = o2::soa::IndexTable<o2::aod::Hash<#_Name_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O, _Key_, __VA_ARGS__>;                      \
-  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;                                                                                                    \
-                                                                                                                                                                \
-  template <>                                                                                                                                                   \
-  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                                             \
-    using metadata = _Name_##Metadata;                                                                                                                          \
-  };
+#define DECLARE_SOA_INDEX_TABLE(_Name_, _Key_, _Description_, ...) \
+  DECLARE_SOA_INDEX_TABLE_NG(_Name_, _Key_, 0, _Description_, false, __VA_ARGS__)
+
+#define DECLARE_SOA_INDEX_TABLE_EXCLUSIVE(_Name_, _Key_, _Description_, ...) \
+  DECLARE_SOA_INDEX_TABLE_NG(_Name_, _Key_, 0, _Description_, true, __VA_ARGS__)
+
+#define DECLARE_SOA_INDEX_TABLE_USER(_Name_, _Key_, _Description_, ...) \
+  DECLARE_SOA_INDEX_TABLE_NG(_Name_, _Key_, 0, _Description_, false, __VA_ARGS__)
+
+#define DECLARE_SOA_INDEX_TABLE_EXCLUSIVE_USER(_Name_, _Key_, _Description_, ...) \
+  DECLARE_SOA_INDEX_TABLE_NG(_Name_, _Key_, 0, _Description_, true, __VA_ARGS__)
 
 // Declare were each row is associated to a timestamp column of an _TimestampSource_
 // table.
@@ -3363,9 +3412,10 @@ consteval auto getIndexTargets()
   template <typename O>                                                                                                             \
   using _Name_##TimestampFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>;              \
   using _Name_##Timestamp = _Name_##TimestampFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                    \
-  template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                              \
-  struct _Name_##TimestampMetadataFrom : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                    \
-    using base_table_t = _TimestampSource_;                                                                                         \
+  struct _Name_##TimestampMetadata : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                        \
+    template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                            \
+    using base_table_t = _TimestampSource_##From<O>;                                                                                \
+    template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                            \
     using extension_table_t = _Name_##TimestampFrom<O>;                                                                             \
     static constexpr const auto ccdb_urls = []<typename... Cs>(framework::pack<Cs...>) {                                            \
       return std::array<std::string_view, sizeof...(Cs)>{Cs::query...};                                                             \
@@ -3373,49 +3423,37 @@ consteval auto getIndexTargets()
     static constexpr const auto ccdb_bindings = []<typename... Cs>(framework::pack<Cs...>) {                                        \
       return std::array<std::string_view, sizeof...(Cs)>{Cs::mLabel...};                                                            \
     }(framework::pack<__VA_ARGS__>{});                                                                                              \
-    static constexpr auto sources = _TimestampSource_::originals;                                                                   \
+    template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                            \
+    static constexpr auto sources = _TimestampSource_##From<O>::originals;                                                          \
     static constexpr auto timestamp_column_label = _TimestampColumn_::mLabel;                                                       \
     /*static constexpr auto timestampColumn = _TimestampColumn_;*/                                                                  \
   };                                                                                                                                \
-  using _Name_##TimestampMetadata = _Name_##TimestampMetadataFrom<o2::aod::Hash<_Origin_ ""_h>>;                                    \
   template <>                                                                                                                       \
   struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                 \
     using metadata = _Name_##TimestampMetadata;                                                                                     \
   };                                                                                                                                \
   template <typename O>                                                                                                             \
-  using _Name_##From = o2::soa::JoinFull<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, _TimestampSource_, _Name_##TimestampFrom<O>>;   \
+  using _Name_##From = o2::soa::Join<_TimestampSource_, _Name_##TimestampFrom<O>>;                                                  \
   using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
 
 #define DECLARE_SOA_TIMESTAMPED_TABLE(_Name_, _TimestampSource_, _TimestampColumn_, _Version_, _Desc_, ...) \
   O2HASH(#_Name_ "Timestamped");                                                                            \
-  DECLARE_SOA_TIMESTAMPED_TABLE_FULL(_Name_, #_Name_ "Timestamped", _TimestampSource_, _TimestampColumn_, "ATIM", _Version_, _Desc_, __VA_ARGS__)
-
-#define DECLARE_SOA_INDEX_TABLE(_Name_, _Key_, _Description_, ...) \
-  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", 0, _Description_, false, __VA_ARGS__)
-
-#define DECLARE_SOA_INDEX_TABLE_EXCLUSIVE(_Name_, _Key_, _Description_, ...) \
-  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "IDX", 0, _Description_, true, __VA_ARGS__)
-
-#define DECLARE_SOA_INDEX_TABLE_USER(_Name_, _Key_, _Description_, ...) \
-  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "AOD", 0, _Description_, false, __VA_ARGS__)
-
-#define DECLARE_SOA_INDEX_TABLE_EXCLUSIVE_USER(_Name_, _Key_, _Description_, ...) \
-  DECLARE_SOA_INDEX_TABLE_FULL(_Name_, _Key_, "AOD", 0, _Description_, true, __VA_ARGS__)
+  DECLARE_SOA_TIMESTAMPED_TABLE_FULL(_Name_, #_Name_ "Timestamped", _TimestampSource_, _TimestampColumn_, "AOD", _Version_, _Desc_, __VA_ARGS__)
 
 namespace o2::soa
 {
-template <typename D, typename... Ts>
-struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts...> {
-  using base = Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts...>;
+template <typename... Ts>
+struct Join : Table<o2::aod::Hash<"JOIN"_h>, o2::aod::Hash<"JOIN/0"_h>, o2::aod::Hash<"JOIN"_h>, Ts...> {
+  using base = Table<o2::aod::Hash<"JOIN"_h>, o2::aod::Hash<"JOIN/0"_h>, o2::aod::Hash<"JOIN"_h>, Ts...>;
 
-  JoinFull(std::shared_ptr<arrow::Table>&& table, uint64_t offset = 0)
+  Join(std::shared_ptr<arrow::Table>&& table, uint64_t offset = 0)
     : base{std::move(table), offset}
   {
     if (this->tableSize() != 0) {
       bindInternalIndicesTo(this);
     }
   }
-  JoinFull(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
+  Join(std::vector<std::shared_ptr<arrow::Table>>&& tables, uint64_t offset = 0)
     : base{ArrowHelpers::joinTables(std::move(tables), std::span{base::originalLabels}), offset}
   {
     if (this->tableSize() != 0) {
@@ -3425,6 +3463,7 @@ struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts.
   using base::bindExternalIndices;
   using base::bindInternalIndicesTo;
   static constexpr const uint32_t binding_origin = base::binding_origin;
+  static constexpr const header::DataOrigin binding_origin_ = base::binding_origin_;
 
   template <typename... TA>
   void bindExternalIndices(TA*... current)
@@ -3437,7 +3476,7 @@ struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts.
      ...);
   }
 
-  using self_t = JoinFull<D, Ts...>;
+  using self_t = Join<Ts...>;
   using table_t = base;
   static constexpr const auto originals = base::originals;
   static constexpr const auto originalLabels = base::originalLabels;
@@ -3501,13 +3540,12 @@ struct JoinFull : Table<o2::aod::Hash<"JOIN"_h>, D, o2::aod::Hash<"JOIN"_h>, Ts.
   template <typename T>
   static consteval bool contains()
   {
-    return std::find_if(originals.begin(), originals.end(), [](TableRef const& ref) { return ref.desc_hash == T::ref.desc_hash; }) != originals.end();
+    return []<size_t... Is>(std::index_sequence<Is...>) {
+      return (std::ranges::any_of(originals, [](TableRef const& ref) { return ref.desc_hash == T::originals[Is].desc_hash; }) && ...);
+    }(std::make_index_sequence<T::originals.size()>());
   }
 };
 
-template <typename... Ts>
-using Join = JoinFull<o2::aod::Hash<"JOIN/0"_h>, Ts...>;
-
 template <typename... Ts>
 constexpr auto join(Ts const&... t)
 {
@@ -3515,7 +3553,7 @@ constexpr auto join(Ts const&... t)
 }
 
 template <typename T>
-concept is_join = framework::specialization_of_template<JoinFull, T>;
+concept is_join = framework::specialization_of_template<Join, T>;
 
 template <typename T>
 constexpr bool is_soa_join_v = is_join<T>;
@@ -3566,6 +3604,7 @@ class FilteredBase : public T
   using table_t = typename T::table_t;
   using T::originals;
   static constexpr const uint32_t binding_origin = T::binding_origin;
+  static constexpr const header::DataOrigin binding_origin_ = T::binding_origin_;
   template <typename... TA>
   void bindExternalIndices(TA*... current)
   {
@@ -4181,6 +4220,7 @@ struct IndexTable : Table<L, D, O> {
   using rest_t = framework::pack<typename Ts::binding_t...>;
 
   static constexpr const uint32_t binding_origin = Key::binding_origin;
+  static constexpr const header::DataOrigin binding_origin_ = Key::binding_origin_;
 
   template <typename... TA>
   void bindExternalIndices(TA*... current)
diff --git a/Framework/Core/include/Framework/AnalysisDataModel.h b/Framework/Core/include/Framework/AnalysisDataModel.h
index 2869565454294..c8dd33fba62ee 100644
--- a/Framework/Core/include/Framework/AnalysisDataModel.h
+++ b/Framework/Core/include/Framework/AnalysisDataModel.h
@@ -51,6 +51,8 @@ DECLARE_SOA_TABLE(BCFlags, "AOD", "BCFLAG", //! flag for tagging UPCs, joinable
                   bc::Flags);
 
 using BCs = BCs_001; // current version
+template <aod::is_origin_hash O>
+using BCsFrom = BCs_001From<O>;
 using BC = BCs::iterator;
 
 namespace timestamp
@@ -66,7 +68,7 @@ using BCsWithTimestamps = soa::Join<aod::BCs, aod::Timestamps>;
 
 namespace soa
 {
-extern template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::BCs, aod::Timestamps>;
+extern template struct Join<aod::BCs, aod::Timestamps>;
 }
 namespace aod
 {
@@ -514,11 +516,11 @@ DECLARE_SOA_TABLE_FULL(StoredTracksIU, "Tracks_IU", "AOD", "TRACK_IU", //! On di
                        track::Sign<track::Signed1Pt>,
                        o2::soa::Marker<2>);
 
-DECLARE_SOA_EXTENDED_TABLE(TracksIU, StoredTracksIU, "EXTRACK_IU", 0, //! Track parameters at inner most update (e.g. ITS) as it comes from the tracking
-                           aod::track::Pt,
-                           aod::track::P,
-                           aod::track::Eta,
-                           aod::track::Phi);
+DECLARE_SOA_EXTENDED_TABLE_NG(TracksIU, StoredTracksIU, "EXTRACK_IU", 0, //! Track parameters at inner most update (e.g. ITS) as it comes from the tracking
+                              aod::track::Pt,
+                              aod::track::P,
+                              aod::track::Eta,
+                              aod::track::Phi);
 
 DECLARE_SOA_TABLE_FULL(StoredTracksCov, "TracksCov", "AOD", "TRACKCOV", //! On disk version of the TracksCov table at collision vertex
                        track::SigmaY, track::SigmaZ, track::SigmaSnp, track::SigmaTgl, track::Sigma1Pt,
@@ -680,9 +682,9 @@ using Run2TrackExtra = Run2TrackExtras::iterator;
 } // namespace aod
 namespace soa
 {
-extern template struct soa::JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Tracks, aod::TracksExtra>;
-extern template struct soa::JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Tracks, aod::TracksCov, aod::TracksExtra>;
-extern template struct soa::JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::TracksExtension, aod::StoredTracks>;
+extern template struct soa::Join<aod::Tracks, aod::TracksExtra>;
+extern template struct soa::Join<aod::Tracks, aod::TracksCov, aod::TracksExtra>;
+extern template struct soa::Join<aod::TracksExtension, aod::StoredTracks>;
 } // namespace soa
 namespace aod
 {
@@ -926,6 +928,8 @@ using MFTTracks = MFTTracks_001;
 using StoredMFTTracks = StoredMFTTracks_001;
 
 using MFTTrack = MFTTracks::iterator;
+template <aod::is_origin_hash O>
+using MFTTracksFrom = MFTTracks_001From<O>;
 
 namespace fwdtrack // Index to MFTtrack column must be defined after table definition.
 {
@@ -1005,7 +1009,7 @@ using MFTTrackCovFwd = MFTTracksCov::iterator;
 } // namespace aod
 namespace soa
 {
-extern template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::FwdTracks, aod::FwdTracksCov>;
+extern template struct Join<aod::FwdTracks, aod::FwdTracksCov>;
 }
 namespace aod
 {
@@ -2026,6 +2030,8 @@ DECLARE_SOA_EXTENDED_TABLE(McParticles_001, StoredMcParticles_001, "EXMCPARTICLE
 using StoredMcParticles = StoredMcParticles_001;
 using McParticles = McParticles_001;
 using McParticle = McParticles::iterator;
+template <aod::is_origin_hash O>
+using McParticlesFrom = McParticles_001From<O>;
 } // namespace aod
 namespace soa
 {
@@ -2191,11 +2197,11 @@ DECLARE_SOA_INDEX_COLUMN(FDD, fdd);                    //!
 // First entry: Collision
 #define INDEX_LIST_RUN2 indices::CollisionId, indices::ZdcId, indices::BCId, indices::FT0Id, indices::FV0AId, indices::FV0CId, indices::FDDId
 DECLARE_SOA_INDEX_TABLE_EXCLUSIVE(Run2MatchedExclusive, BCs, "MA_RN2_EX", INDEX_LIST_RUN2); //!
-DECLARE_SOA_INDEX_TABLE(Run2MatchedSparse, BCs, "MA_RN2_SP", INDEX_LIST_RUN2);              //!
+DECLARE_SOA_INDEX_TABLE(Run2MatchedSparse, BCs_001, "MA_RN2_SP", INDEX_LIST_RUN2);          //!
 
 #define INDEX_LIST_RUN3 indices::CollisionId, indices::ZdcId, indices::BCId, indices::FT0Id, indices::FV0AId, indices::FDDId
 DECLARE_SOA_INDEX_TABLE_EXCLUSIVE(Run3MatchedExclusive, BCs, "MA_RN3_EX", INDEX_LIST_RUN3); //!
-DECLARE_SOA_INDEX_TABLE(Run3MatchedSparse, BCs, "MA_RN3_SP", INDEX_LIST_RUN3);              //!
+DECLARE_SOA_INDEX_TABLE(Run3MatchedSparse, BCs_001, "MA_RN3_SP", INDEX_LIST_RUN3);          //!
 
 // First entry: BC
 DECLARE_SOA_INDEX_TABLE_EXCLUSIVE(MatchedBCCollisionsExclusive, BCs, "MA_BCCOL_EX", //!
@@ -2225,8 +2231,8 @@ DECLARE_EQUIVALENT_FOR_INDEX(aod::StoredTracksIU, aod::McTrackLabels);
 DECLARE_EQUIVALENT_FOR_INDEX(aod::Collisions, aod::McCollisionLabels);
 // Joins with collisions (only for sparse ones)
 // NOTE: index table needs to be always last argument
-extern template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Collisions, aod::Run2MatchedSparse>;
-extern template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Collisions, aod::Run3MatchedSparse>;
+extern template struct Join<aod::Collisions, aod::Run2MatchedSparse>;
+extern template struct Join<aod::Collisions, aod::Run3MatchedSparse>;
 } // namespace soa
 namespace aod
 {
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index 9ac78c0933600..bfc5a02891dad 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -79,6 +79,7 @@ auto makeEmptyTable(const char* name)
 }
 
 template <soa::TableRef R>
+  requires(soa::not_void<typename aod::MetadataTrait<aod::Hash<R.desc_hash>>::metadata>)
 auto makeEmptyTable()
 {
   auto schema = std::make_shared<arrow::Schema>(soa::createFieldsFromColumns(typename aod::MetadataTrait<aod::Hash<R.desc_hash>>::metadata::persistent_columns_t{}));
@@ -93,6 +94,7 @@ auto makeEmptyTable(const char* name, framework::pack<Cs...> p)
 }
 
 template <aod::is_aod_hash D>
+  requires(soa::not_void<typename aod::MetadataTrait<D>::metadata>)
 auto makeEmptyTable(const char* name)
 {
   auto schema = std::make_shared<arrow::Schema>(soa::createFieldsFromColumns(typename aod::MetadataTrait<D>::metadata::persistent_columns_t{}));
@@ -216,6 +218,26 @@ inline constexpr auto getSourceSchemas()
   }.template operator()<T::sources.size(), T::sources>();
 }
 
+template <soa::with_sources_generator T, aod::is_origin_hash O = o2::aod::Hash<"AOD"_h>>
+inline constexpr auto getSources()
+{
+  return []<size_t N, std::array<soa::TableRef, N> refs>() {
+    return []<size_t... Is>(std::index_sequence<Is...>) {
+      return std::vector{soa::tableRef2ConfigParamSpec<refs[Is]>()...};
+    }(std::make_index_sequence<N>());
+  }.template operator()<T::N, T::template generateSources<O>()>();
+}
+
+template <soa::with_sources_generator T, aod::is_origin_hash O = o2::aod::Hash<"AOD"_h>>
+inline constexpr auto getSourceSchemas()
+{
+  return []<size_t N, std::array<soa::TableRef, N> refs>() {
+    return []<size_t... Is>(std::index_sequence<Is...>) {
+      return std::vector{soa::tableRef2Schema<refs[Is]>()...};
+    }(std::make_index_sequence<N>());
+  }.template operator()<T::N, T::template generateSources<O>()>();
+}
+
 template <soa::with_ccdb_urls T>
 inline constexpr auto getCCDBUrls()
 {
@@ -257,7 +279,7 @@ inline constexpr auto getIndexMapping()
   using indices = T::index_pack_t;
   using Key = T::Key;
   [&idx]<size_t... Is>(std::index_sequence<Is...>) mutable {
-    constexpr auto refs = T::sources;
+    constexpr auto refs = T::generateSources();
     ([&idx]<TableRef ref, typename C>() mutable {
       constexpr auto pos = o2::aod::MetadataTrait<o2::aod::Hash<ref.desc_hash>>::metadata::template getIndexPosToKey<Key>();
       if constexpr (pos == -1) {
@@ -272,6 +294,26 @@ inline constexpr auto getIndexMapping()
   return idx;
 }
 
+template <soa::with_sources_generator T, aod::is_origin_hash O = o2::aod::Hash<"AOD"_h>>
+constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
+{
+  std::vector<framework::ConfigParamSpec> inputMetadata;
+
+  auto inputSources = getSources<T, O>();
+  std::sort(inputSources.begin(), inputSources.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name < b.name; });
+  auto last = std::unique(inputSources.begin(), inputSources.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name == b.name; });
+  inputSources.erase(last, inputSources.end());
+  inputMetadata.insert(inputMetadata.end(), inputSources.begin(), inputSources.end());
+
+  auto inputSchemas = getSourceSchemas<T, O>();
+  std::sort(inputSchemas.begin(), inputSchemas.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name < b.name; });
+  last = std::unique(inputSchemas.begin(), inputSchemas.end(), [](framework::ConfigParamSpec const& a, framework::ConfigParamSpec const& b) { return a.name == b.name; });
+  inputSchemas.erase(last, inputSchemas.end());
+  inputMetadata.insert(inputMetadata.end(), inputSchemas.begin(), inputSchemas.end());
+
+  return inputMetadata;
+}
+
 template <soa::with_sources T>
 constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
 {
@@ -293,7 +335,7 @@ constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
 }
 
 template <typename T>
-  requires(!soa::with_sources<T>)
+  requires(!(soa::with_sources<T> || soa::with_sources_generator<T>))
 constexpr auto getInputMetadata() -> std::vector<framework::ConfigParamSpec>
 {
   return {};
@@ -358,7 +400,12 @@ template <TableRef R>
 constexpr auto tableRef2InputSpec()
 {
   std::vector<framework::ConfigParamSpec> metadata;
-  auto sources = getInputMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  std::vector<framework::ConfigParamSpec> sources;
+  if constexpr (soa::with_sources<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>) {
+    sources = getInputMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
+  } else if constexpr (soa::with_sources_generator<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>) {
+    sources = getInputMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata, o2::aod::Hash<R.origin_hash>>();
+  }
   metadata.insert(metadata.end(), sources.begin(), sources.end());
   auto ccdbURLs = getCCDBMetadata<typename o2::aod::MetadataTrait<o2::aod::Hash<R.desc_hash>>::metadata>();
   metadata.insert(metadata.end(), ccdbURLs.begin(), ccdbURLs.end());
@@ -555,7 +602,7 @@ concept is_produces_group = std::derived_from<T, ProducesGroup>;
 template <soa::is_metadata M, soa::TableRef Ref>
 struct TableTransform {
   using metadata = M;
-  constexpr static auto sources = M::sources;
+  constexpr static auto sources = M::template generateSources<o2::aod::Hash<Ref.origin_hash>>();
 
   template <soa::TableRef R>
   static auto base_spec()
@@ -589,23 +636,23 @@ struct TableTransform {
 /// This helper struct allows you to declare extended tables which should be
 /// created by the task (as opposed to those pre-defined by data model)
 template <typename T>
-concept is_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>> && soa::has_extension<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata>;
+concept is_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && soa::has_extension<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata>;
 
 template <typename T>
-concept is_dynamically_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>> && soa::has_configurable_extension<typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata>;
+concept is_dynamically_spawnable = soa::has_metadata<aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>> && soa::has_configurable_extension<typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata>;
 
 template <is_spawnable T>
 constexpr auto transformBase()
 {
-  using metadata = typename aod::MetadataTrait<o2::aod::Hash<T::ref.desc_hash>>::metadata;
-  return TableTransform<metadata, metadata::extension_table_t::ref>{};
+  using metadata = typename aod::MetadataTrait<o2::aod::Hash<T::originals[T::originals.size() - 1].desc_hash>>::metadata;
+  return TableTransform<metadata, metadata::template extension_table_t_from<o2::aod::Hash<T::originals[T::originals.size() - 1].origin_hash>>::ref>{};
 }
 
 template <is_spawnable T>
 struct Spawns : decltype(transformBase<T>()) {
   using spawnable_t = T;
   using metadata = decltype(transformBase<T>())::metadata;
-  using extension_t = typename metadata::extension_table_t;
+  using extension_t = typename metadata::template extension_table_t_from<o2::aod::Hash<T::originals[T::originals.size() - 1].origin_hash>>;
   using expression_pack_t = typename metadata::expression_pack_t;
   static constexpr size_t N = framework::pack_size(expression_pack_t{});
 
@@ -655,7 +702,7 @@ struct Defines : decltype(transformBase<T>()) {
   static constexpr bool delayed = DELAYED;
   using spawnable_t = T;
   using metadata = decltype(transformBase<T>())::metadata;
-  using extension_t = typename metadata::extension_table_t;
+  using extension_t = typename metadata::template extension_table_t_from<o2::aod::Hash<T::originals[T::originals.size() - 1].origin_hash>>;
   using placeholders_pack_t = typename metadata::placeholders_pack_t;
   static constexpr size_t N = framework::pack_size(placeholders_pack_t{});
 
diff --git a/Framework/Core/include/Framework/AnalysisManagers.h b/Framework/Core/include/Framework/AnalysisManagers.h
index a411bd6eefb56..1873f33937742 100644
--- a/Framework/Core/include/Framework/AnalysisManagers.h
+++ b/Framework/Core/include/Framework/AnalysisManagers.h
@@ -275,10 +275,10 @@ bool prepareOutput(ProcessingContext& context, T& producesGroup)
 template <is_spawns T>
 bool prepareOutput(ProcessingContext& context, T& spawns)
 {
-  using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
-  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
+  using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::originals[T::spawnable_t::originals.size() - 1].desc_hash>>::metadata;
+  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::N, metadata::template generateSources<o2::aod::Hash<T::spawnable_t::originals[T::spawnable_t::originals.size() - 1].origin_hash>>()>(context), std::span{metadata::base_table_t::originalLabels});
   if (originalTable->num_rows() == 0) {
-    originalTable = makeEmptyTable<metadata::base_table_t::ref>();
+    originalTable = makeEmptyTable("EMPTY", typename metadata::base_table_t::persistent_columns_t{});
   }
   using D = o2::aod::Hash<metadata::extension_table_t::ref.desc_hash>;
 
@@ -295,17 +295,17 @@ template <is_builds T>
 bool prepareOutput(ProcessingContext& context, T& builds)
 {
   using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::buildable_t::ref.desc_hash>>::metadata;
-  return builds.build(extractOriginals<metadata::sources.size(), metadata::sources>(context));
+  return builds.build(extractOriginals<metadata::N, metadata::template generateSources<o2::aod::Hash<T::buildable_t::ref.origin_hash>>()>(context));
 }
 
 template <is_defines T>
 bool prepareOutput(ProcessingContext& context, T& defines)
   requires(T::delayed == false)
 {
-  using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::ref.desc_hash>>::metadata;
-  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::sources.size(), metadata::sources>(context), std::span{metadata::base_table_t::originalLabels});
+  using metadata = o2::aod::MetadataTrait<o2::aod::Hash<T::spawnable_t::originals[T::spawnable_t::originals.size() - 1].desc_hash>>::metadata;
+  auto originalTable = soa::ArrowHelpers::joinTables(extractOriginals<metadata::N, metadata::template generateSources<o2::aod::Hash<T::spawnable_t::originals[T::spawnable_t::originals.size() - 1].origin_hash>>()>(context), std::span{metadata::base_table_t::originalLabels});
   if (originalTable->num_rows() == 0) {
-    originalTable = makeEmptyTable<metadata::base_table_t::ref>();
+    originalTable = makeEmptyTable("EMPTY", typename metadata::base_table_t::persistent_columns_t{});
   }
   if (defines.inputSchema == nullptr) {
     defines.inputSchema = originalTable->schema();
diff --git a/Framework/Core/include/Framework/AnalysisSupportHelpers.h b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
index ef1d056b62f2b..803d8cf9d4685 100644
--- a/Framework/Core/include/Framework/AnalysisSupportHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
@@ -21,11 +21,11 @@
 namespace o2::framework
 {
 static constexpr std::array<header::DataOrigin, 4> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
-static constexpr std::array<header::DataOrigin, 6> extendedAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"DYN"}, header::DataOrigin{"AMD"}, header::DataOrigin{"EMB"}};
-static constexpr std::array<header::DataOrigin, 4> writableAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"DYN"}};
+// static constexpr std::array<header::DataOrigin, 6> extendedAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
+// static constexpr std::array<header::DataOrigin, 4> writableAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
 
 class DataOutputDirector;
-class ConfigContext;
+struct ConfigContext;
 
 // Helper class to be moved in the AnalysisSupport plugin at some point
 struct AnalysisSupportHelpers {
diff --git a/Framework/Core/src/AnalysisDataModel.cxx b/Framework/Core/src/AnalysisDataModel.cxx
index 906772234d608..fbbabc35f0aab 100644
--- a/Framework/Core/src/AnalysisDataModel.cxx
+++ b/Framework/Core/src/AnalysisDataModel.cxx
@@ -12,12 +12,12 @@
 
 namespace o2::soa
 {
-template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::BCs, aod::Timestamps>;
-template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Tracks, aod::TracksExtra>;
-template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Tracks, aod::TracksCov, aod::TracksExtra>;
-template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::FwdTracks, aod::FwdTracksCov>;
-template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Collisions, aod::Run2MatchedSparse>;
-template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::Collisions, aod::Run3MatchedSparse>;
+template struct Join<aod::BCs, aod::Timestamps>;
+template struct Join<aod::Tracks, aod::TracksExtra>;
+template struct Join<aod::Tracks, aod::TracksCov, aod::TracksExtra>;
+template struct Join<aod::FwdTracks, aod::FwdTracksCov>;
+template struct Join<aod::Collisions, aod::Run2MatchedSparse>;
+template struct Join<aod::Collisions, aod::Run3MatchedSparse>;
 
-template struct JoinFull<o2::aod::Hash<"JOIN/0"_h>, aod::TracksExtension, aod::StoredTracks>;
+template struct Join<aod::TracksExtension, aod::StoredTracks>;
 } // namespace o2::soa
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index 21f312cd576e0..9e0f0ac3b778a 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -102,7 +102,7 @@ std::shared_ptr<DataOutputDirector> AnalysisSupportHelpers::getDataOutputDirecto
         // use the dangling outputs
         std::vector<InputSpec> danglingOutputs;
         for (auto ii = 0u; ii < OutputsInputs.size(); ii++) {
-          if (DataSpecUtils::partialMatch(OutputsInputs[ii], writableAODOrigins) && isDangling[ii]) {
+          if (DataSpecUtils::partialMatch(OutputsInputs[ii], AODOrigins) && isDangling[ii]) {
             danglingOutputs.emplace_back(OutputsInputs[ii]);
           }
         }
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 03ad3bd4b8829..a97fcf2897abd 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -234,8 +234,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   ctx.services().registerService(ServiceRegistryHelpers::handleForService<DanglingEdgesContext>(new DanglingEdgesContext));
   auto& dec = ctx.services().get<DanglingEdgesContext>();
 
-  std::vector<OutputSpec> DYNs;
-
   std::vector<InputSpec> requestedCCDBs;
   std::vector<OutputSpec> providedCCDBs;
 
@@ -370,9 +368,6 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
           break;
         }
       }
-      if (DataSpecUtils::partialMatch(output, header::DataOrigin{"DYN"})) {
-        DYNs.emplace_back(output);
-      }
       if (hasProjectors) {
         dec.providedDYNs.emplace_back(output);
       } else if (hasCCDBURLs) {
@@ -592,7 +587,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
       continue;
     }
     // AODs are skipped in any case.
-    if (DataSpecUtils::partialMatch(dec.outputsInputs[ii], extendedAODOrigins)) {
+    if (DataSpecUtils::partialMatch(dec.outputsInputs[ii], AODOrigins)) {
       continue;
     }
     redirectedOutputsInputs.emplace_back(dec.outputsInputs[ii]);
@@ -727,7 +722,7 @@ void WorkflowHelpers::injectAODWriter(WorkflowSpec& workflow, ConfigContext cons
   // select outputs of type AOD which need to be saved
   dec.outputsInputsAOD.clear();
   for (auto ii = 0u; ii < dec.outputsInputs.size(); ii++) {
-    if (DataSpecUtils::partialMatch(dec.outputsInputs[ii], extendedAODOrigins)) {
+    if (DataSpecUtils::partialMatch(dec.outputsInputs[ii], AODOrigins)) {
       auto ds = dod->getDataOutputDescriptors(dec.outputsInputs[ii]);
       if (ds.size() > 0 || dec.isDangling[ii]) {
         dec.outputsInputsAOD.emplace_back(dec.outputsInputs[ii]);
@@ -855,10 +850,8 @@ void WorkflowHelpers::constructGraph(const WorkflowSpec& workflow,
       if (forwards.empty()) {
         errorDueToMissingOutputFor(consumer, input);
       }
-      availableOutputsInfo.erase(std::remove_if(availableOutputsInfo.begin(), availableOutputsInfo.end(), [](auto& info) { return info.enabled == false; }), availableOutputsInfo.end());
-      for (auto& forward : forwards) {
-        availableOutputsInfo.push_back(forward);
-      }
+      availableOutputsInfo.erase(std::remove_if(availableOutputsInfo.begin(), availableOutputsInfo.end(), [](auto const& info) { return info.enabled == false; }), availableOutputsInfo.end());
+      std::ranges::copy(forwards, std::back_inserter(availableOutputsInfo));
     }
     O2_SIGNPOST_END(workflow_helpers, sid, "input matching", "");
   }
@@ -937,14 +930,14 @@ WorkflowParsingState WorkflowHelpers::verifyWorkflow(const o2::framework::Workfl
     return WorkflowParsingState::Empty;
   }
   std::set<std::string> validNames;
-  std::vector<OutputSpec> availableOutputs;
-  std::vector<InputSpec> requiredInputs;
+  // std::vector<OutputSpec> availableOutputs;
+  // std::vector<InputSpec> requiredInputs;
 
   // An index many to one index to go from a given input to the
   // associated spec
-  std::map<size_t, size_t> inputToSpec;
+  // std::map<size_t, size_t> inputToSpec;
   // A one to one index to go from a given output to the Spec emitting it
-  std::map<size_t, size_t> outputToSpec;
+  // std::map<size_t, size_t> outputToSpec;
 
   std::ostringstream ss;
 
@@ -1125,14 +1118,14 @@ void WorkflowHelpers::validateEdges(WorkflowSpec const& workflow,
   // Get the input lifetime and the output lifetime.
   // Output lifetime must be Timeframe if the input lifetime is Timeframe.
   bool hasErrors = false;
-  for (auto& edge : edges) {
+  for (auto const& edge : edges) {
     DataProcessorSpec const& producer = workflow[edge.producer];
     DataProcessorSpec const& consumer = workflow[edge.consumer];
     DataProcessorPoliciesInfo const& producerPolicies = policies[edge.producer];
     DataProcessorPoliciesInfo const& consumerPolicies = policies[edge.consumer];
     OutputSpec const& output = outputs[edge.outputGlobalIndex];
     InputSpec const& input = consumer.inputs[edge.consumerInputIndex];
-    for (auto& validator : defaultValidators) {
+    for (auto const& validator : defaultValidators) {
       hasErrors |= !validator(errors, producer, output, producerPolicies, consumer, input, consumerPolicies);
     }
   }
diff --git a/Framework/Core/test/test_Concepts.cxx b/Framework/Core/test/test_Concepts.cxx
index 982c748e701e4..375e537cfaec0 100644
--- a/Framework/Core/test/test_Concepts.cxx
+++ b/Framework/Core/test/test_Concepts.cxx
@@ -87,7 +87,7 @@ TEST_CASE("IdentificationConcepts")
 
   REQUIRE(with_originals<o2::aod::Collisions>);
 
-  REQUIRE(with_sources<o2::aod::MetadataTrait<o2::aod::Hash<"MA_RN3_SP/0"_h>>::metadata>);
+  REQUIRE(with_sources_generator<o2::aod::MetadataTrait<o2::aod::Hash<"MA_RN3_SP/0"_h>>::metadata>);
 
   REQUIRE(with_base_table<o2::aod::Tracks>);
 
diff --git a/Framework/Core/test/test_IndexBuilder.cxx b/Framework/Core/test/test_IndexBuilder.cxx
index e357b1164af80..2a273db4333fc 100644
--- a/Framework/Core/test/test_IndexBuilder.cxx
+++ b/Framework/Core/test/test_IndexBuilder.cxx
@@ -108,7 +108,7 @@ TEST_CASE("TestIndexBuilder")
   auto t5 = IndexBuilder::materialize(builders1, {t1, t2, t3, t4}, map, schema1, true);
   // auto t5 = IndexBuilder::materialize({t1, t2, t3, t4}, map, schema1, true);
   REQUIRE(t5->num_rows() == 4);
-  IDXs idxt{t5};
+  IDXsFrom<o2::aod::Hash<"TST"_h>> idxt{t5};
   idxt.bindExternalIndices(&st1, &st2, &st3, &st4);
   for (auto& row : idxt) {
     REQUIRE(row.distance().pointId() == row.pointId());
@@ -121,7 +121,7 @@ TEST_CASE("TestIndexBuilder")
   std::vector<o2::framework::IndexColumnBuilder> builders2;
   auto t6 = IndexBuilder::materialize(builders2, {t2, t1, t3, t4}, map, schema2, false);
   REQUIRE(t6->num_rows() == st2.size());
-  IDX2s idxs{t6};
+  IDX2sFrom<o2::aod::Hash<"TST"_h>> idxs{t6};
   std::array<int, 7> fs{0, 1, 2, -1, -1, 4, -1};
   std::array<int, 7> cs{0, 1, 2, -1, 5, 6, -1};
   idxs.bindExternalIndices(&st1, &st2, &st3, &st4);
@@ -222,7 +222,7 @@ TEST_CASE("AdvancedIndexTables")
   std::vector<o2::framework::IndexColumnBuilder> builders3;
   auto t3 = IndexBuilder::materialize(builders3, {t1, t2, tc}, map, schema3, false);
   REQUIRE(t3->num_rows() == st1.size());
-  IDX3s idxs{t3};
+  IDX3sFrom<o2::aod::Hash<"TST"_h>> idxs{t3};
   idxs.bindExternalIndices(&st1, &st2, &st3);
   count = 0;
   for (auto const& row : idxs) {
diff --git a/Framework/TestWorkflows/src/o2TestMultisource.cxx b/Framework/TestWorkflows/src/o2TestMultisource.cxx
index 00bd9ba5093bd..d52a25f67e98f 100644
--- a/Framework/TestWorkflows/src/o2TestMultisource.cxx
+++ b/Framework/TestWorkflows/src/o2TestMultisource.cxx
@@ -25,8 +25,6 @@ using namespace o2::framework::expressions;
 namespace o2::aod
 {
 O2ORIGIN("EMB");
-template <is_aod_hash T>
-using BCsFrom = BCs_001From<T>;
 using TracksPlus = soa::Join<StoredTracksIU, StoredTracksExtra>;
 template <is_aod_hash T>
 using TracksPlusFrom = soa::Join<StoredTracksIUFrom<T>, StoredTracksExtra_002From<T>>;
@@ -34,9 +32,9 @@ using TracksPlusFrom = soa::Join<StoredTracksIUFrom<T>, StoredTracksExtra_002Fro
 
 struct TestEmbeddingSubscription {
   void process(aod::BCs const& bcs, aod::BCsFrom<aod::Hash<"EMB"_h>> const& bcse,
-               aod::TracksPlus const& tracks, aod::TracksPlusFrom<aod::Hash<"EMB"_h>> const& trackse)
+               aod::TracksIU const& tracks, aod::TracksIUFrom<aod::Hash<"EMB"_h>> const& trackse)
   {
-    LOGP(info, "BCs from run {} and {}", bcs.begin().runNumber(), bcse.begin().runNumber());
+    LOGP(info, "BCs from run {} ({}) and {} ({})", bcs.begin().runNumber(), bcs.size(), bcse.begin().runNumber(), bcse.size());
     LOGP(info, "Joined tracks: {} and {}", tracks.size(), trackse.size());
   }
 };

From 1120c99c5780990fbae7dea282d6c8451071e993 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 23 Apr 2026 06:48:39 +0200
Subject: [PATCH 1648/1764] Disable warning about VLAs (#15309)

---
 dependencies/O2CompileFlags.cmake | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dependencies/O2CompileFlags.cmake b/dependencies/O2CompileFlags.cmake
index eeddc189e8897..de9143299e364 100644
--- a/dependencies/O2CompileFlags.cmake
+++ b/dependencies/O2CompileFlags.cmake
@@ -66,8 +66,8 @@ else()
  message(STATUS "Building without compiler warnings enabled.")
 endif()
 
-string(JOIN " " CMAKE_C_WARNINGS "-Wno-unknown-warning-option" ${O2_C_ENABLED_WARNINGS} ${O2_C_ENABLED_WARNINGS_NO_ERROR})
-string(JOIN " " CMAKE_CXX_WARNINGS "-Wno-unknown-warning-option" ${O2_CXX_ENABLED_WARNINGS} ${O2_CXX_ENABLED_WARNINGS_NO_ERROR})
+string(JOIN " " CMAKE_C_WARNINGS "-Wno-unknown-warning-option" "-Wno-vla-cxx-extension" ${O2_C_ENABLED_WARNINGS} ${O2_C_ENABLED_WARNINGS_NO_ERROR})
+string(JOIN " " CMAKE_CXX_WARNINGS "-Wno-unknown-warning-option" "-Wno-vla-cxx-extension" ${O2_CXX_ENABLED_WARNINGS} ${O2_CXX_ENABLED_WARNINGS_NO_ERROR})
 
 string(REGEX MATCH "-O[0-9]+" CMAKE_FLAGS_OPT_VALUE "${CMAKE_CXX_FLAGS}")
 if(NOT CMAKE_FLAGS_OPT_VALUE OR CMAKE_FLAGS_OPT_VALUE STREQUAL "-O0" OR CMAKE_FLAGS_OPT_VALUE STREQUAL "-O1")

From 7a4fd45931179a0010d0c1415656b32a8a3ab6ec Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Thu, 23 Apr 2026 11:34:15 +0200
Subject: [PATCH 1649/1764] GPU/TPC: Fix row overflow in Pad Filter.

---
 GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
index c47de7f79d424..7638b95ee7f0b 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFCheckPadBaseline.h
@@ -63,8 +63,10 @@ class GPUTPCCFCheckPadBaseline : public GPUKernelTemplate
 
   static int32_t GetNBlocks(bool isGPU)
   {
-    const int32_t nBlocks = TPC_CLUSTERER_STRIDED_PAD_COUNT / PadsPerCacheline;
-    return isGPU ? GPUTPCGeometry::NROWS : nBlocks;
+    // Important to exclude rightmost padding from Pad Filter.
+    // There's nothing to filter there and padding is counted as start of a row, so it causes an overflow in the row count.
+    const int32_t nBlocksCPU = (TPC_CLUSTERER_STRIDED_PAD_COUNT - GPUCF_PADDING_PAD) / PadsPerCacheline;
+    return isGPU ? GPUTPCGeometry::NROWS : nBlocksCPU;
   }
 
   template <int32_t iKernel = defaultKernel>

From 34b3d563b7b9e3866effefe67853923744e0b6df Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 23 Apr 2026 14:27:12 +0200
Subject: [PATCH 1650/1764] ITSMFT: ensure backward comptability for MC2ROF

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx  | 4 ++++
 Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx  | 6 ++++++
 Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx      | 4 ++++
 Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx    | 4 ++++
 Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx    | 5 +++++
 .../ITSMFT/common/workflow/src/digit-reader-workflow.cxx    | 2 +-
 Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx         | 4 ++++
 7 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
index bd24c9d2591d5..6174938171336 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClusterReaderSpec.cxx
@@ -69,6 +69,9 @@ void ClusterReader<N>::run(ProcessingContext& pc)
     }
     if (mUseMC) {
       pc.outputs().snapshot(Output{Origin, "CLUSTERSMCTR", iLayer}, *mClusterMCTruth[iLayer]);
+      // read dummy MC2ROF vector to keep writer/readers backward compatible
+      static std::vector<o2::itsmft::MC2ROFRecord> dummyMC2ROF;
+      pc.outputs().snapshot(Output{Origin, "CLUSTERSMC2ROF", iLayer}, dummyMC2ROF);
     }
   }
   if (mTriggerOut) {
@@ -141,6 +144,7 @@ std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mct
     }
     if (mctruth) {
       outputs.emplace_back(detOrig, "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(detOrig, "CLUSTERSMC2ROF", iLayer, Lifetime::Timeframe);
     }
   }
   if (triggerOut) {
diff --git a/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
index e1857cbf2f775..52520194537b8 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
@@ -37,6 +37,7 @@ using CompClusType = std::vector<o2::itsmft::CompClusterExt>;
 using PatternsType = std::vector<unsigned char>;
 using ROFrameRType = std::vector<o2::itsmft::ROFRecord>;
 using LabelsType = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
+using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
 using namespace o2::header;
 
 template <int N>
@@ -105,6 +106,11 @@ DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag)
                                                              (detName + "ClusterMCTruth").c_str(), "cluster-label-branch",
                                                              (useMC ? nLayers : 0),
                                                              getIndex,
+                                                             getName},
+                                BranchDefinition<ROFRecLblT>{InputSpec{"MC2ROframes", ConcreteDataTypeMatcher{Origin, "CLUSTERSMC2ROF"}},
+                                                             (detName + "ClustersMC2ROF").c_str(), "cluster-mc2rof-branch",
+                                                             (useMC ? nLayers : 0),
+                                                             getIndex,
                                                              getName})();
 }
 
diff --git a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
index 0672f7d13bed2..b3954c5c22ad1 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClustererSpec.cxx
@@ -190,6 +190,9 @@ void ClustererDPL<N>::run(ProcessingContext& pc)
 
     if (mUseMC) {
       pc.outputs().snapshot(Output{Origin, "CLUSTERSMCTR", iLayer}, *clusterLabels); // at the moment requires snapshot
+      // write dummy MC2ROF vector to keep writer/readers backward compatible
+      static std::vector<o2::itsmft::MC2ROFRecord> dummyMC2ROF;
+      pc.outputs().snapshot(Output{Origin, "CLUSTERSMC2ROF", iLayer}, dummyMC2ROF);
     }
     reader.reset();
 
@@ -306,6 +309,7 @@ DataProcessorSpec getClustererSpec(bool useMC, bool doStag)
     outputs.emplace_back(Origin, "CLUSTERSROF", iLayer, Lifetime::Timeframe);
     if (useMC) {
       outputs.emplace_back(Origin, "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(Origin, "CLUSTERSMC2ROF", iLayer, Lifetime::Timeframe);
     }
   }
   return DataProcessorSpec{
diff --git a/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
index 6a57933f18048..b6c3ab5386179 100644
--- a/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/DigitReaderSpec.cxx
@@ -112,6 +112,9 @@ void DigitReader<N>::run(ProcessingContext& pc)
         mPLabels[iLayer]->copyandflatten(sharedlabels);
         delete mPLabels[iLayer];
         mPLabels[iLayer] = nullptr;
+        // read dummy MC2ROF vector to keep writer/readers backward compatible
+        static std::vector<o2::itsmft::MC2ROFRecord> dummyMC2ROF;
+        pc.outputs().snapshot(Output{Origin, "DIGITSMC2ROF", iLayer}, dummyMC2ROF);
       }
     }
     if (mUseCalib) {
@@ -267,6 +270,7 @@ std::vector<OutputSpec> makeOutChannels(bool mctruth, bool doStag, bool useCalib
     outputs.emplace_back(Origin, "DIGITS", iLayer, Lifetime::Timeframe);
     outputs.emplace_back(Origin, "DIGITSROF", iLayer, Lifetime::Timeframe);
     if (mctruth) {
+      outputs.emplace_back(Origin, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
       outputs.emplace_back(Origin, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
     }
   }
diff --git a/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx b/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
index d409356c6846f..944432196881e 100644
--- a/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/DigitWriterSpec.cxx
@@ -141,6 +141,11 @@ DataProcessorSpec getDigitWriterSpec(bool mctruth, bool doStag, bool dec, bool c
                                                                     fillLabels,
                                                                     getIndex,
                                                                     getName},
+                                BranchDefinition<std::vector<itsmft::MC2ROFRecord>>{InputSpec{detStr + "_digitsMC2ROF", ConcreteDataTypeMatcher{Origin, "DIGITSMC2ROF"}},
+                                                                                    detStr + "DigitMC2ROF", "digit-mc2rof-branch",
+                                                                                    (mctruth ? mLayers : 0),
+                                                                                    getIndex,
+                                                                                    getName},
                                 BranchDefinition<std::vector<itsmft::GBTCalibData>>{InputSpec{detStr + "calib", ConcreteDataTypeMatcher{Origin, "GBTCALIB"}},
                                                                                     detStr + "Calib", "digit-calib-branch",
                                                                                     (calib ? 1 : 0)})();
diff --git a/Detectors/ITSMFT/common/workflow/src/digit-reader-workflow.cxx b/Detectors/ITSMFT/common/workflow/src/digit-reader-workflow.cxx
index 04453abe464b7..f44a730525016 100644
--- a/Detectors/ITSMFT/common/workflow/src/digit-reader-workflow.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/digit-reader-workflow.cxx
@@ -57,7 +57,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
     bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(cfgc);
     wf.emplace_back(o2::itsmft::getMFTDigitReaderSpec(useMC, doStag, calib, withTriggers));
   } else {
-    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(cfgc);
+    bool doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(cfgc);
     wf.emplace_back(o2::itsmft::getITSDigitReaderSpec(useMC, doStag, calib, withTriggers));
   }
   o2::raw::HBFUtilsInitializer hbfIni(cfgc, wf);
diff --git a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
index a4c401bbf8b42..fbdc74c11d7a4 100644
--- a/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/ITSMFTDigitizerSpec.cxx
@@ -228,6 +228,9 @@ class ITSMFTDPLDigitizerTask : BaseDPLDigitizer
         // free space of existing label containers
         mLabels[iLayer].clear_andfreememory();
         mLabelsAccum[iLayer].clear_andfreememory();
+        // write dummy MC2ROF vector to keep writer/readers backward compatible
+        static std::vector<o2::itsmft::MC2ROFRecord> dummyMC2ROF;
+        pc.outputs().snapshot(Output{Origin, "DIGITSMC2ROF", iLayer}, dummyMC2ROF);
       }
     }
 
@@ -404,6 +407,7 @@ std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mct
     outputs.emplace_back(detOrig, "DIGITS", iLayer, Lifetime::Timeframe);
     outputs.emplace_back(detOrig, "DIGITSROF", iLayer, Lifetime::Timeframe);
     if (mctruth) {
+      outputs.emplace_back(detOrig, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
       outputs.emplace_back(detOrig, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
     }
   }

From 3f9b8d7ff24aad995fc6144e47a02c653026eb26 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Tue, 21 Apr 2026 15:12:49 +0200
Subject: [PATCH 1651/1764] AOD producer: improve MC collision labels for
 embedded events

In embedding scenarios where a single background event is reused across
multiple collisions, e.g.:

  Collision 0: Background 0 + Signal 0
  Collision 1: Background 0 + Signal 1
  Collision 2: Background 0 + Signal 2
  Collision 3: Background 0 + Signal 3
  Collision 4: Background 0 + Signal 4

the primary vertexer may return MC labels all pointing to "Background 0".
This caused an ambiguous lookup in the AOD producer, resulting in all
reconstructed collisions being incorrectly associated to the same
MCCollision entry.

This is addressed by collecting all MCCollision candidates matching a
given (sourceID, eventID) label and disambiguating via bunch-crossing
time, picking the MCCollision whose BC is closest to the reconstructed
vertex time.

Note: a more robust long-term solution would be to extend the primary
vertexer to return the full set of contributing MC labels per found
vertex, enabling simpler and more reliable disambiguation strategies.

This relates to https://its.cern.ch/jira/browse/O2-6840.
---
 .../AODProducerWorkflowSpec.h                 | 10 ++-
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 66 +++++++++++++------
 2 files changed, 56 insertions(+), 20 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index c03c00f977648..8947a50fe42cd 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -48,6 +48,14 @@ using DataRequest = o2::globaltracking::DataRequest;
 
 namespace o2::aodproducer
 {
+/// helper struct to keep mapping of colIndex to MC labels and bunch crossing
+struct MCColInfo {
+  int colIndex;
+  int sourceID;
+  int eventID;
+  int64_t bc; // global bunch crossing
+};
+
 /// A structure or container to organize bunch crossing data of a timeframe
 /// and to facilitate fast lookup and search within bunch crossings.
 class BunchCrossings
@@ -661,7 +669,7 @@ class AODProducerWorkflowDPL : public Task
                             const gsl::span<const o2::dataformats::VtxTrackRef>& primVer2TRefs,
                             const gsl::span<const GIndex>& GIndices,
                             const o2::globaltracking::RecoContainer& data,
-                            const std::vector<std::vector<int>>& mcColToEvSrc);
+                            const std::vector<MCColInfo>& mcColToEvSrc);
 
   template <typename MCTrackLabelCursorType, typename MCMFTTrackLabelCursorType, typename MCFwdTrackLabelCursorType>
   void fillMCTrackLabelsTable(MCTrackLabelCursorType& mcTrackLabelCursor,
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index afff39791e4ec..03f38206b2a47 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -1084,13 +1084,13 @@ void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader&
                                                   const gsl::span<const o2::dataformats::VtxTrackRef>& primVer2TRefs,
                                                   const gsl::span<const GIndex>& GIndices,
                                                   const o2::globaltracking::RecoContainer& data,
-                                                  const std::vector<std::vector<int>>& mcColToEvSrc)
+                                                  const std::vector<MCColInfo>& mcColToEvSrc)
 {
   int NSources = 0;
   int NEvents = 0;
   for (auto& p : mcColToEvSrc) {
-    NSources = std::max(p[1], NSources);
-    NEvents = std::max(p[2], NEvents);
+    NSources = std::max(p.sourceID, NSources);
+    NEvents = std::max(p.eventID, NEvents);
   }
   NSources++; // 0 - indexed
   NEvents++;
@@ -1166,9 +1166,9 @@ void AODProducerWorkflowDPL::fillMCParticlesTable(o2::steer::MCKinematicsReader&
 
   size_t offset = 0;
   for (auto& colInfo : mcColToEvSrc) { // loop over "<eventID, sourceID> <-> combined MC col. ID" key pairs
-    int event = colInfo[2];
-    int source = colInfo[1];
-    int mcColId = colInfo[0];
+    int event = colInfo.eventID;
+    int source = colInfo.sourceID;
+    int mcColId = colInfo.colIndex;
     std::vector<MCTrack> const& mcParticles = mcReader.getTracks(source, event);
     LOG(debug) << "Event=" << event << " source=" << source << " collision=" << mcColId;
     auto& preselect = mToStore[source][event];
@@ -2179,10 +2179,8 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
               zdcChannelsT);
   }
 
-  // keep track event/source id for each mc-collision
-  // using map and not unordered_map to ensure
-  // correct ordering when iterating over container elements
-  std::vector<std::vector<int>> mcColToEvSrc;
+  // keep track of event_id + source_id + bc for each mc-collision
+  std::vector<MCColInfo> mcColToEvSrc;
 
   if (mUseMC) {
     using namespace o2::aodmchelpers;
@@ -2255,13 +2253,13 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
                          0,
                          sourceID);
         }
-        mcColToEvSrc.emplace_back(std::vector<int>{iCol, sourceID, eventID}); // point background and injected signal events to one collision
+        mcColToEvSrc.emplace_back(MCColInfo{iCol, sourceID, eventID, globalBC}); // point background and injected signal events to one collision
       }
     }
   }
 
   std::sort(mcColToEvSrc.begin(), mcColToEvSrc.end(),
-            [](const std::vector<int>& left, const std::vector<int>& right) { return (left[0] < right[0]); });
+            [](const MCColInfo& left, const MCColInfo& right) { return (left.colIndex < right.colIndex); });
 
   // vector of FDD amplitudes
   int16_t aFDDAmplitudesA[8] = {0u}, aFDDAmplitudesC[8] = {0u};
@@ -2360,16 +2358,46 @@ void AODProducerWorkflowDPL::run(ProcessingContext& pc)
   }
 
   if (mUseMC) {
-    // filling MC collision labels
+    // Fill MC collision labels using information from the primary vertexer.
     mcColLabelsCursor.reserve(primVerLabels.size());
-    for (auto& label : primVerLabels) {
-      auto it = std::find_if(mcColToEvSrc.begin(), mcColToEvSrc.end(),
-                             [&label](const auto& mcColInfo) { return mcColInfo[1] == label.getSourceID() && mcColInfo[2] == label.getEventID(); });
+    for (size_t ivert = 0; ivert < primVerLabels.size(); ++ivert) {
+      const auto& label = primVerLabels[ivert];
+
+      // Collect all MC collision candidates matching this (sourceID, eventID) label.
+      // In the non-embedding case there is exactly one candidate. In the embedding
+      // case the same (sourceID, eventID) pair can appear in multiple collisions,
+      // so we need to disambiguate.
+      std::vector<std::pair<int32_t, int64_t>> candidates; // (colIndex, bc)
+      for (const auto& colInfo : mcColToEvSrc) {
+        if (colInfo.sourceID == label.getSourceID() &&
+            colInfo.eventID == label.getEventID()) {
+          candidates.emplace_back(colInfo.colIndex, colInfo.bc);
+        }
+      }
+
       int32_t mcCollisionID = -1;
-      if (it != mcColToEvSrc.end()) {
-        mcCollisionID = it->at(0);
+      if (candidates.size() == 1) {
+        mcCollisionID = candidates[0].first;
+      } else if (candidates.size() > 1) {
+        // Disambiguate by BC: pick the MCCollision whose BC is closest
+        // to the reconstructed collision's BC.
+        // TODO: Consider a complementary strategy using the MC labels of tracks
+        //       associated to the primary vertex, and/or by allowing the primary
+        //       vertexer to return multiple MC collision labels per vertex.
+        const auto& timeStamp = primVertices[ivert].getTimeStamp();
+        const double interactionTime = timeStamp.getTimeStamp() * 1E3; // us -> ns
+        const auto recoBC = relativeTime_to_GlobalBC(interactionTime);
+        int64_t bestDiff = std::numeric_limits<int64_t>::max();
+        for (const auto& [colIndex, bc] : candidates) {
+          const auto bcDiff = std::abs(static_cast<int64_t>(bc) - static_cast<int64_t>(recoBC));
+          if (bcDiff < bestDiff) {
+            bestDiff = bcDiff;
+            mcCollisionID = colIndex;
+          }
+        }
       }
-      uint16_t mcMask = 0; // todo: set mask using normalized weights?
+
+      uint16_t mcMask = 0; // TODO: set mask using normalised weights
       mcColLabelsCursor(mcCollisionID, mcMask);
     }
   }

From e31bd4d907ebe4da3b2299f618aa9b1faa6f4ca1 Mon Sep 17 00:00:00 2001
From: Felix Weiglhofer <felix.weiglhofer@cern.ch>
Date: Thu, 23 Apr 2026 16:36:16 +0200
Subject: [PATCH 1652/1764] GPUTPCClusterFinder: Add protection against
 Out-Of-Bounds read in PeakFinder.

---
 GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
index 5d94e36febc0a..7c93435f8bef8 100644
--- a/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
+++ b/GPU/GPUTracking/TPCClusterFinder/GPUTPCCFPeakFinder.cxx
@@ -108,7 +108,7 @@ GPUd() void GPUTPCCFPeakFinder::findPeaksImpl(int32_t nBlocks, int32_t nThreads,
   CfChargePos pos = positions[CAMath::Min<SizeT>(idx, digitnum - 1)];
   Charge charge = pos.valid() ? chargeMap[pos].unpack() : Charge(0);
 
-  bool hasLostBaseline = padHasLostBaseline[pos.gpad];
+  bool hasLostBaseline = pos.valid() ? padHasLostBaseline[pos.gpad] : true;
   charge = hasLostBaseline ? 0.f : charge;
 
   uint8_t peak = isPeak(smem, charge, pos, SCRATCH_PAD_SEARCH_N, chargeMap, calib, smem.posBcast, smem.buf);

From 9c5fda90f451d0841145e55ed8f537820ce9165b Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 24 Apr 2026 10:25:51 +0200
Subject: [PATCH 1653/1764] DPL Analysis: better detection for injected
 workflows (#15312)

---
 .../Core/include/Framework/TimesliceIndex.h   |  2 +-
 Framework/Core/src/ArrowSupport.cxx           | 18 ++--
 Framework/Core/src/DeviceSpecHelpers.cxx      |  2 +-
 Framework/Core/src/WorkflowHelpers.cxx        | 29 +++++-
 Framework/Core/src/runDataProcessing.cxx      |  2 +-
 run/o2sim_hepmc_publisher.cxx                 | 94 ++++++++++---------
 run/o2sim_kine_publisher.cxx                  |  3 +-
 run/o2sim_mctracks_to_aod.cxx                 | 12 +--
 8 files changed, 94 insertions(+), 68 deletions(-)

diff --git a/Framework/Core/include/Framework/TimesliceIndex.h b/Framework/Core/include/Framework/TimesliceIndex.h
index ac3970bec00ee..ea612f701152c 100644
--- a/Framework/Core/include/Framework/TimesliceIndex.h
+++ b/Framework/Core/include/Framework/TimesliceIndex.h
@@ -126,7 +126,7 @@ class TimesliceIndex
 
   /// Find the lowest value for the timeslices in this instance.
   /// This is the minimum between all the per channel oldest possible timeslices
-  /// and the oldest possible timeslice in-fly which is still dirty.
+  /// and the oldest possible timeslice in flight which is still dirty.
   [[nodiscard]] OldestInputInfo getOldestPossibleInput() const;
   [[nodiscard]] OldestOutputInfo getOldestPossibleOutput() const;
   OldestOutputInfo updateOldestPossibleOutput(bool rewinded);
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 1819307e26806..780c836437c2b 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -310,12 +310,12 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                        static auto totalMessagesDestroyedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-arrow-messages-destroyed");
                        static auto totalTimeframesReadMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-timeframes-read");
                        static auto totalTimeframesConsumedMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "total-timeframes-consumed");
-                       static auto totalTimeframesInFlyMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-timeframes-in-fly");
+                       static auto totalTimeframesInFlightMetric = DeviceMetricsHelper::createNumericMetric<int>(driverMetrics, "total-timeframes-in-flight");
 
                        static auto totalTimeslicesStartedMetric = createUint64DriverMetric("total-timeslices-started");
                        static auto totalTimeslicesExpiredMetric = createUint64DriverMetric("total-timeslices-expired");
                        static auto totalTimeslicesDoneMetric = createUint64DriverMetric("total-timeslices-done");
-                       static auto totalTimeslicesInFlyMetric = createIntDriverMetric("total-timeslices-in-fly");
+                       static auto totalTimeslicesInFlightMetric = createIntDriverMetric("total-timeslices-in-flight");
 
                        static auto totalBytesDeltaMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "arrow-bytes-delta");
                        static auto changedCountMetric = DeviceMetricsHelper::createNumericMetric<uint64_t>(driverMetrics, "changed-metrics-count");
@@ -457,11 +457,11 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
                          totalMessagesDestroyedMetric(driverMetrics, totalMessagesDestroyed, timestamp);
                          totalTimeframesReadMetric(driverMetrics, totalTimeframesRead, timestamp);
                          totalTimeframesConsumedMetric(driverMetrics, totalTimeframesConsumed, timestamp);
-                         totalTimeframesInFlyMetric(driverMetrics, (int)(totalTimeframesRead - totalTimeframesConsumed), timestamp);
+                         totalTimeframesInFlightMetric(driverMetrics, (int)(totalTimeframesRead - totalTimeframesConsumed), timestamp);
                          totalTimeslicesStartedMetric(driverMetrics, totalTimeslicesStarted, timestamp);
                          totalTimeslicesExpiredMetric(driverMetrics, totalTimeslicesExpired, timestamp);
                          totalTimeslicesDoneMetric(driverMetrics, totalTimeslicesDone, timestamp);
-                         totalTimeslicesInFlyMetric(driverMetrics, (int)(totalTimeslicesStarted - totalTimeslicesDone), timestamp);
+                         totalTimeslicesInFlightMetric(driverMetrics, (int)(totalTimeslicesStarted - totalTimeslicesDone), timestamp);
                          totalBytesDeltaMetric(driverMetrics, totalBytesCreated - totalBytesExpired - totalBytesDestroyed, timestamp);
                        } else {
                          unchangedCount++;
@@ -696,10 +696,14 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
           workflow.erase(reader);
         } else {
           // load reader algorithm before deployment
-          auto mctracks2aod = std::find_if(workflow.begin(), workflow.end(), [](auto const& x) { return x.name == "mctracks-to-aod"; });
-          if (mctracks2aod == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
+          auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
+            return !spec.name.starts_with("internal-dpl-aod-reader") && std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
+              return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
+            });
+          });
+          if (tfnsource == workflow.end()) { // add normal reader algorithm only if no on-the-fly generator is injected
             reader->algorithm = CommonDataProcessors::wrapWithTimesliceConsumption(PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTFileReader", ctx));
-          } // otherwise the algorithm was set in injectServiceDevices
+          } // otherwise the algorithm was already set in injectServiceDevices
         }
       }
 
diff --git a/Framework/Core/src/DeviceSpecHelpers.cxx b/Framework/Core/src/DeviceSpecHelpers.cxx
index 88e5269482ebd..011b3aa12162f 100644
--- a/Framework/Core/src/DeviceSpecHelpers.cxx
+++ b/Framework/Core/src/DeviceSpecHelpers.cxx
@@ -1732,7 +1732,7 @@ boost::program_options::options_description DeviceSpecHelpers::getForwardedDevic
     ("error-on-exit-transition-timeout", bpo::value<bool>()->zero_tokens(), "print error instead of warning when exit transition timer expires")                     //
     ("data-processing-timeout", bpo::value<std::string>(), "timeout after which only calibration can happen")                                                        //
     ("expected-region-callbacks", bpo::value<std::string>(), "region callbacks to expect before starting")                                                           //
-    ("timeframes-rate-limit", bpo::value<std::string>()->default_value("0"), "how many timeframes can be in fly")                                                    //
+    ("timeframes-rate-limit", bpo::value<std::string>()->default_value("0"), "how many timeframes can be in flight")                                                 //
     ("shm-monitor", bpo::value<std::string>(), "whether to use the shared memory monitor")                                                                           //
     ("channel-prefix", bpo::value<std::string>()->default_value(""), "prefix to use for multiplexing multiple workflows in the same session")                        //
     ("bad-alloc-max-attempts", bpo::value<std::string>()->default_value("1"), "throw after n attempts to alloc shm")                                                 //
diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index a97fcf2897abd..5f1c1eaee5544 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -456,15 +456,20 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     }
   }
 
+  auto tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
+    return std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
+      return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
+    });
+  });
+
   // add the reader
   if (aodReader.outputs.empty() == false) {
-    auto mctracks2aod = std::ranges::find_if(workflow, [](auto const& x) { return x.name == "mctracks-to-aod"; });
-    if (mctracks2aod == workflow.end()) {
+    if (tfnsource == workflow.end()) {
       // add normal reader
       aodReader.outputs.emplace_back(OutputSpec{"TFN", "TFNumber"});
       aodReader.outputs.emplace_back(OutputSpec{"TFF", "TFFilename"});
     } else {
-      // AODs are being injected on-the-fly, add error-handler reader
+      // AODs are being injected the tfnsource is the entry point, add error-handler reader
       aodReader.algorithm = AlgorithmSpec{
         adaptStateful(
           [](DeviceSpec const& spec) {
@@ -595,6 +600,12 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
   std::vector<InputSpec> unmatched;
   auto forwardingDestination = ctx.options().get<std::string>("forwarding-destination");
+  // update tfnsource iterator (could be aod-reader)
+  tfnsource = std::ranges::find_if(workflow, [](DataProcessorSpec const& spec) {
+    return std::ranges::any_of(spec.outputs, [](OutputSpec const& output) {
+      return DataSpecUtils::match(output, "TFN", "TFNumber", 0);
+    });
+  });
   if (redirectedOutputsInputs.size() > 0 && forwardingDestination == "file") {
     auto fileSink = CommonDataProcessors::getGlobalFileSink(redirectedOutputsInputs, unmatched);
     if (unmatched.size() != redirectedOutputsInputs.size()) {
@@ -606,7 +617,7 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
   } else if (forwardingDestination != "drop") {
     throw runtime_error_f("Unknown forwarding destination %s", forwardingDestination.c_str());
   }
-  if (unmatched.size() > 0 || redirectedOutputsInputs.size() > 0) {
+  if ((unmatched.size() > 0) || (redirectedOutputsInputs.size() > 0) || (tfnsource != workflow.end())) {
     std::vector<InputSpec> ignored = unmatched;
     ignored.insert(ignored.end(), redirectedOutputsInputs.begin(), redirectedOutputsInputs.end());
     for (auto& ignoredInput : ignored) {
@@ -615,8 +626,11 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
 
     // Use the new dummy sink when the AOD reader is there
     O2_SIGNPOST_ID_GENERATE(sid, workflow_helpers);
-    if (aodReader.outputs.empty() == false) {
+    if (tfnsource != workflow.end()) {
       O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting scheduled dummy sink");
+      // if there is a tfnsource, make sure the sink gets TFN/TFF
+      DataSpecUtils::updateInputList(ignored, InputSpec{"tfn", "TFN", "TFNumber", 0, Lifetime::Sporadic});
+      DataSpecUtils::updateInputList(ignored, InputSpec{"tff", "TFF", "TFFilename", 0, Lifetime::Sporadic});
       extraSpecs.push_back(CommonDataProcessors::getScheduledDummySink(ignored));
     } else {
       O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting rate limited dummy sink");
@@ -742,6 +756,11 @@ void WorkflowHelpers::injectAODWriter(WorkflowSpec& workflow, ConfigContext cons
       return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFN"));
     });
     dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
+
+    it = std::find_if(dec.outputsInputs.begin(), dec.outputsInputs.end(), [](InputSpec const& spec) -> bool {
+      return DataSpecUtils::partialMatch(spec, o2::header::DataOrigin("TFF"));
+    });
+    dec.isDangling[std::distance(dec.outputsInputs.begin(), it)] = false;
   }
 }
 
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index 03cef9a034144..d012e1656efc4 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -1063,7 +1063,7 @@ int doChild(int argc, char** argv, ServiceRegistry& serviceRegistry,
       ("exit-transition-timeout", bpo::value<std::string>()->default_value(defaultExitTransitionTimeout), "how many second to wait before switching from RUN to READY")                            //
       ("error-on-exit-transition-timeout", bpo::value<bool>()->zero_tokens()->default_value(false), "print error instead of warning when exit transition timer expires")                           //
       ("data-processing-timeout", bpo::value<std::string>()->default_value(defaultDataProcessingTimeout), "how many second to wait before stopping data processing and allowing data calibration") //
-      ("timeframes-rate-limit", bpo::value<std::string>()->default_value("0"), "how many timeframe can be in fly at the same moment (0 disables)")                                                 //
+      ("timeframes-rate-limit", bpo::value<std::string>()->default_value("0"), "how many timeframe can be in flight at the same moment (0 disables)")                                              //
       ("configuration,cfg", bpo::value<std::string>()->default_value("command-line"), "configuration backend")                                                                                     //
       ("infologger-mode", bpo::value<std::string>()->default_value(defaultInfologgerMode), "O2_INFOLOGGER_MODE override");
     r.fConfig.AddToCmdLineOptions(optsDesc, true);
diff --git a/run/o2sim_hepmc_publisher.cxx b/run/o2sim_hepmc_publisher.cxx
index bf40abacb134f..f255b4a3a4f62 100644
--- a/run/o2sim_hepmc_publisher.cxx
+++ b/run/o2sim_hepmc_publisher.cxx
@@ -37,7 +37,9 @@ struct O2simHepmcPublisher {
   int tfCounter = 0;
   std::shared_ptr<HepMC3::Reader> hepMCReader;
   bool eos = false;
-  std::vector<o2::MCTrack> mcTracks;
+
+  std::vector<o2::pmr::vector<o2::MCTrack>*> mctracks_vector;
+  std::vector<o2::dataformats::MCEventHeader*> mcheader_vector;
 
   void init(o2::framework::InitContext& /*ic*/)
   {
@@ -50,13 +52,19 @@ struct O2simHepmcPublisher {
       LOGP(fatal, "Cannot open HEPMC kine file {}", (std::string)hepmcFileName);
     }
     // allocate the memory upfront to prevent reallocations later
-    mcTracks.reserve(1e3 * aggregate);
+    mctracks_vector.reserve(aggregate);
+    mcheader_vector.reserve(aggregate);
   }
 
   void run(o2::framework::ProcessingContext& pc)
   {
     HepMC3::GenEvent event;
-    for (auto i = 0; i < (int)aggregate; ++i) {
+    auto batch = maxEvents > 0 ? std::min((int)aggregate, (int)maxEvents - eventCounter) : (int)aggregate;
+    for (auto i = 0; i < batch; ++i) {
+      mctracks_vector.push_back(&pc.outputs().make<o2::pmr::vector<o2::MCTrack>>(Output{"MC", "MCTRACKS", 0}));
+      auto& mctracks = mctracks_vector.back();
+      mcheader_vector.push_back(&pc.outputs().make<o2::dataformats::MCEventHeader>(Output{"MC", "MCHEADER", 0}));
+      auto& mcheader = mcheader_vector.back();
       // read next entry
       hepMCReader->read_event(event);
       if (hepMCReader->failed()) {
@@ -66,61 +74,60 @@ struct O2simHepmcPublisher {
       }
 
       // create O2 MCHeader and MCtracks vector out of HEPMC event
-      o2::dataformats::MCEventHeader mcHeader;
-      mcHeader.SetEventID(event.event_number());
-      mcHeader.SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
+      mcheader->SetEventID(event.event_number());
+      mcheader->SetVertex(event.event_pos().px(), event.event_pos().py(), event.event_pos().pz());
       auto xsecInfo = event.cross_section();
       if (xsecInfo != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
-        mcHeader.putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
-        mcHeader.putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
-        mcHeader.putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
+        mcheader->putInfo(MCInfoKeys::acceptedEvents, (uint64_t)xsecInfo->get_accepted_events());
+        mcheader->putInfo(MCInfoKeys::attemptedEvents, (uint64_t)xsecInfo->get_attempted_events());
+        mcheader->putInfo(MCInfoKeys::xSection, (float)xsecInfo->xsec());
+        mcheader->putInfo(MCInfoKeys::xSectionError, (float)xsecInfo->xsec_err());
       }
       auto scale = event.attribute<HepMC3::DoubleAttribute>(MCInfoKeys::eventScale);
       if (scale != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::eventScale, (float)scale->value());
+        mcheader->putInfo(MCInfoKeys::eventScale, (float)scale->value());
       }
       auto nMPI = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::mpi);
       if (nMPI != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::mpi, nMPI->value());
+        mcheader->putInfo(MCInfoKeys::mpi, nMPI->value());
       }
       auto sid = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processCode);
       auto scode = event.attribute<HepMC3::IntAttribute>(MCInfoKeys::processID); // default pythia8 hepmc3 interface uses signal_process_id
       if (sid != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::processCode, sid->value());
+        mcheader->putInfo(MCInfoKeys::processCode, sid->value());
       } else if (scode != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::processCode, scode->value());
+        mcheader->putInfo(MCInfoKeys::processCode, scode->value());
       }
       auto pdfInfo = event.pdf_info();
       if (pdfInfo != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
-        mcHeader.putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
-        mcHeader.putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
-        mcHeader.putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
+        mcheader->putInfo(MCInfoKeys::pdfParton1Id, pdfInfo->parton_id[0]);
+        mcheader->putInfo(MCInfoKeys::pdfParton2Id, pdfInfo->parton_id[1]);
+        mcheader->putInfo(MCInfoKeys::pdfCode1, pdfInfo->pdf_id[0]);
+        mcheader->putInfo(MCInfoKeys::pdfCode2, pdfInfo->pdf_id[1]);
+        mcheader->putInfo(MCInfoKeys::pdfX1, (float)pdfInfo->x[0]);
+        mcheader->putInfo(MCInfoKeys::pdfX2, (float)pdfInfo->x[1]);
+        mcheader->putInfo(MCInfoKeys::pdfScale, (float)pdfInfo->scale);
+        mcheader->putInfo(MCInfoKeys::pdfXF1, (float)pdfInfo->xf[0]);
+        mcheader->putInfo(MCInfoKeys::pdfXF2, (float)pdfInfo->xf[1]);
       }
       auto heavyIon = event.heavy_ion();
       if (heavyIon != nullptr) {
-        mcHeader.putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
-        mcHeader.putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
-        mcHeader.putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
-        mcHeader.putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
-        mcHeader.putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
-        mcHeader.putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
-        mcHeader.putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
-        mcHeader.putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
-        mcHeader.putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
-        mcHeader.putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
-        mcHeader.putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
-        mcHeader.putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
-        mcHeader.putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
-        mcHeader.putInfo("eccentricity", (float)heavyIon->eccentricity);
-        mcHeader.putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
-        mcHeader.putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
+        mcheader->putInfo(MCInfoKeys::nCollHard, heavyIon->Ncoll_hard);
+        mcheader->putInfo(MCInfoKeys::nPartProjectile, heavyIon->Npart_proj);
+        mcheader->putInfo(MCInfoKeys::nPartTarget, heavyIon->Npart_targ);
+        mcheader->putInfo(MCInfoKeys::nColl, heavyIon->Ncoll);
+        mcheader->putInfo(MCInfoKeys::nCollNNWounded, heavyIon->N_Nwounded_collisions);
+        mcheader->putInfo(MCInfoKeys::nCollNWoundedN, heavyIon->Nwounded_N_collisions);
+        mcheader->putInfo(MCInfoKeys::nCollNWoundedNwounded, heavyIon->Nwounded_Nwounded_collisions);
+        mcheader->putInfo(MCInfoKeys::nSpecProjectileNeutron, heavyIon->Nspec_proj_n);
+        mcheader->putInfo(MCInfoKeys::nSpecProjectileProton, heavyIon->Nspec_proj_p);
+        mcheader->putInfo(MCInfoKeys::nSpecTargetNeutron, heavyIon->Nspec_targ_n);
+        mcheader->putInfo(MCInfoKeys::nSpecTargetProton, heavyIon->Nspec_targ_p);
+        mcheader->putInfo(MCInfoKeys::impactParameter, (float)heavyIon->impact_parameter);
+        mcheader->putInfo(MCInfoKeys::planeAngle, (float)heavyIon->event_plane_angle);
+        mcheader->putInfo("eccentricity", (float)heavyIon->eccentricity);
+        mcheader->putInfo(MCInfoKeys::sigmaInelNN, (float)heavyIon->sigma_inel_NN);
+        mcheader->putInfo(MCInfoKeys::centrality, (float)heavyIon->centrality);
       }
 
       auto particles = event.particles();
@@ -131,7 +138,7 @@ struct O2simHepmcPublisher {
         auto has_children = children.size() > 0;
         auto p = particle->momentum();
         auto v = particle->production_vertex();
-        mcTracks.emplace_back(
+        mctracks->emplace_back(
           particle->pid(),
           has_parents ? parents.front()->id() : -1, has_parents ? parents.back()->id() : -1,
           has_children ? children.front()->id() : -1, has_children ? children.back()->id() : -1,
@@ -139,18 +146,13 @@ struct O2simHepmcPublisher {
           v->position().x(), v->position().y(), v->position().z(),
           v->position().t(), 0);
       }
-
-      // add to the message
-      pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcHeader);
-      pc.outputs().snapshot(Output{"MC", "MCTRACKS", 0}, mcTracks);
-      mcTracks.clear();
       ++eventCounter;
     }
 
     // report number of TFs injected for the rate limiter to work
     ++tfCounter;
     pc.services().get<o2::monitoring::Monitoring>().send(o2::monitoring::Metric{(uint64_t)tfCounter, "df-sent"}.addTag(o2::monitoring::tags::Key::Subsystem, o2::monitoring::tags::Value::DPL));
-    if (eos || (maxEvents > 0 && eventCounter == maxEvents)) {
+    if (eos || (maxEvents > 0 && eventCounter >= maxEvents)) {
       pc.services().get<ControlService>().endOfStream();
       pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     }
diff --git a/run/o2sim_kine_publisher.cxx b/run/o2sim_kine_publisher.cxx
index cfbea6ae02a5f..5920743c3fafa 100644
--- a/run/o2sim_kine_publisher.cxx
+++ b/run/o2sim_kine_publisher.cxx
@@ -40,7 +40,8 @@ struct O2simKinePublisher {
 
   void run(o2::framework::ProcessingContext& pc)
   {
-    for (auto i = 0; i < std::min((int)aggregate, nEvents - eventCounter); ++i) {
+    auto batch = std::min((int)aggregate, nEvents - eventCounter);
+    for (auto i = 0; i < batch; ++i) {
       auto mcevent = mcKinReader->getMCEventHeader(0, eventCounter);
       auto mctracks = mcKinReader->getTracks(0, eventCounter);
       pc.outputs().snapshot(Output{"MC", "MCHEADER", 0}, mcevent);
diff --git a/run/o2sim_mctracks_to_aod.cxx b/run/o2sim_mctracks_to_aod.cxx
index 124e8aa7b3e42..d95a3b33cc38f 100644
--- a/run/o2sim_mctracks_to_aod.cxx
+++ b/run/o2sim_mctracks_to_aod.cxx
@@ -70,7 +70,7 @@ struct MctracksToAod {
   /** Run the conversion */
   void run(o2::framework::ProcessingContext& pc)
   {
-    LOG(debug) << "=== Running extended MC AOD exporter ===";
+    LOG(detail) << "=== Running extended MC AOD exporter ===";
     using namespace o2::aodmchelpers;
     using McHeader = o2::dataformats::MCEventHeader;
     using McTrack = o2::MCTrack;
@@ -94,13 +94,13 @@ struct MctracksToAod {
     // TODO: include BC simulation
     auto bcCounter = 0UL;
     size_t offset = 0;
-    LOG(debug) << "--- Loop over " << nParts << " parts ---";
+    LOG(detail) << "--- Loop over " << nParts << " parts ---";
     for (auto i = 0U; i < nParts; ++i) {
       auto record = mSampler.generateCollisionTime();
       auto header = pc.inputs().get<McHeader*>("mcheader", i);
       auto tracks = pc.inputs().get<McTracks>("mctracks", i);
 
-      LOG(debug) << "Updating collision table";
+      LOG(detail) << "Updating collision table";
       auto genID = updateMCCollisions(mCollisions.cursor,
                                       bcCounter,
                                       record.timeInBCNS * 1.e-3,
@@ -108,12 +108,12 @@ struct MctracksToAod {
                                       0,
                                       i);
 
-      LOG(debug) << "Updating HepMC tables";
+      LOG(detail) << "Updating HepMC tables";
       updateHepMCXSection(mXSections.cursor, bcCounter, genID, *header);
       updateHepMCPdfInfo(mPdfInfos.cursor, bcCounter, genID, *header);
       updateHepMCHeavyIon(mHeavyIons.cursor, bcCounter, genID, *header);
 
-      LOG(debug) << "Updating particles table";
+      LOG(detail) << "Updating particles table";
       TrackToIndex preselect;
       offset = updateParticles(mParticles.cursor,
                                bcCounter,
@@ -123,7 +123,7 @@ struct MctracksToAod {
                                (bool)filt,
                                false);
 
-      LOG(debug) << "Increment BC counter";
+      LOG(detail) << "Increment BC counter";
       bcCounter++;
     }
 

From 4791d2ef3f4d85ed754b6168ee6840d81e664ec4 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 24 Apr 2026 10:33:26 +0200
Subject: [PATCH 1654/1764] DPL Analysis: add dummy output to analysis objects
 sink (#15306)

---
 Framework/Core/src/AnalysisSupportHelpers.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index 9e0f0ac3b778a..4dab3b364e04d 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -194,7 +194,7 @@ DataProcessorSpec AnalysisSupportHelpers::getOutputObjHistSink(ConfigContext con
   DataProcessorSpec spec{
     .name = "internal-dpl-aod-global-analysis-file-sink",
     .inputs = {InputSpec("x", DataSpecUtils::dataDescriptorMatcherFrom(header::DataOrigin{"ATSK"}), Lifetime::Sporadic)},
-    .outputs = {},
+    .outputs = {OutputSpec{OutputLabel{"dummy"}, o2::header::DataOrigin{"DUMM"}, o2::header::DataDescription{"DUMMY"}, 0, Lifetime::Sporadic}},
     .algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkAnalysisSupport", "ROOTObjWriter", ctx),
   };
 

From 271f3d77107a7ec59e949779e91b5282d1c947c5 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 24 Apr 2026 10:52:05 +0200
Subject: [PATCH 1655/1764] ITS: Implement early return for missing cluster
 data (#15300)

* Implement early return for missing cluster data

@ehellbar  this fixes the crash you observe running:
```
o2-ctf-reader-workflow --max-tf 10 $GLOSET --ans-version 1.0 --ctf-dict none --delay 0 --loop 0 --ctf-input o2_ctf_run00554701_orbit0029026560_tf0000000001_epn315.root --onlyDet ITS,TPC --pipeline tpc-entropy-decoder:1  --configKeyValues "keyval.input_dir=$PWD;keyval.output_dir=/dev/null;;" | \
o2-gpu-reco-workflow $GLOSET --gpu-reconstruction "--severity info" --input-type=compressed-clusters-flat --disable-mc --output-type tracks,clusters,send-clusters-per-sector  --disable-ctp-lumi-request --pipeline gpu-reconstruction:${TPC_PIPELINES:-1} --configKeyValues "keyval.input_dir=$PWD;keyval.output_dir=/dev/null;;GPU_global.deviceType=CPU;GPU_proc.debugLevel=0;GPU_proc.tpcInputWithClusterRejection=1;GPU_proc.ompThreads=-1;GPU_proc.deviceNum=-2;" | \
o2-its-reco-workflow $GLOSET --trackerCA  --tracking-mode async --disable-mc --clusters-from-upstream  --pipeline its-tracker:${ITS_PIPELINES:-1},its-clusterer:${ITS_PIPELINES:-1}  --configKeyValues "keyval.input_dir=$PWD;keyval.output_dir=/dev/null;;ITSVertexerParam.phiCut=0.5;ITSVertexerParam.phiCut=0.2;ITSVertexerParam.clusterContributorsCut=3;ITSVertexerParam.tanLambdaCut=0.2;;;;ITSClustererParam.maxBCDiffToMaskBias=-1;MFTClustererParam.maxBCDiffToMaskBias=-1" | \
o2-dpl-run $GLOSET  --run -b | tee out_ITS-pipes${ITS_PIPELINES:-1}_ccdb-fetchers${NCCDB}_TPC${TPC_PIPELINES:-1}.log
```

The underlying reason why it crashes is that since the staggering PR the ITS tracking code requires that upstream producers at least provide the correct assumed time-structure, e.g., ROFs. In the this specific case we take the clusters directly from the CTFs, e.g., skipping re-clusterization where we make sure that ROFs are correct. If there is no ITS data recorded in the TF then the ROF vector is empty hand you trigger this exception:
```
[40876:its-tracker]: [13:00:24][FATAL] Received inconsistent number of rofs on layer:-1 expected:576 received:0
```

Now if there is no data to consume be-it no clusters / no rofs the processing is entirely skipped. One could also have made the ctf-reader ensure 'correct' ROF output but I think it is better this way, maybe...

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index fcd9024a74709..fa3339b001ca3 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -160,6 +160,11 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   auto& allVerticesLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTR", 0}) : dummyMCLabVerts;
   auto& allVerticesPurities = mIsMC ? pc.outputs().make<std::vector<float>>(Output{"ITS", "VERTICESMCPUR", 0}) : dummyMCPurVerts;
 
+  if (!hasClusters) {
+    // skip processing if no data is received entirely but still create empty output so consumers do not wait
+    return;
+  }
+
   if (mOverrideBeamEstimation) {
     mTimeFrame->setBeamPosition(mMeanVertex->getX(),
                                 mMeanVertex->getY(),

From 425f555396d4c4db9065d25916bb0afde08d138e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 24 Apr 2026 10:54:13 +0200
Subject: [PATCH 1656/1764] ITS: factor out CPU/GPU common code & separate Cell
 class (#15293)

* ITS: add memory stats

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: clear tracklets after cell finding

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: separate into cell and track seed class

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: factor common functions out

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  16 +-
 .../GPU/ITStrackingGPU/TrackerTraitsGPU.h     |   2 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  36 +-
 .../ITS/tracking/GPU/ITStrackingGPU/Utils.h   |  21 -
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     |  30 +-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  86 ++--
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 440 +++++-------------
 .../include/ITStracking/BoundedAllocator.h    | 158 +++++--
 .../ITS/tracking/include/ITStracking/Cell.h   | 132 ++++--
 .../tracking/include/ITStracking/Constants.h  |  14 +-
 .../include/ITStracking/IndexTableUtils.h     |  28 +-
 .../tracking/include/ITStracking/TimeFrame.h  |   4 +-
 .../include/ITStracking/TrackHelpers.h        | 291 ++++++++++++
 .../tracking/include/ITStracking/Tracker.h    |  11 +-
 .../include/ITStracking/TrackerTraits.h       |  46 +-
 .../tracking/include/ITStracking/Vertexer.h   |   4 +
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |   2 +-
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  26 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 421 +++++++----------
 .../ITS/tracking/src/TrackingInterface.cxx    |  26 +-
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      |  10 +-
 21 files changed, 953 insertions(+), 851 deletions(-)
 create mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index cf1295e08bd76..c87b3d36b9a6a 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -27,11 +27,11 @@ namespace o2::its::gpu
 template <int NLayers>
 class TimeFrameGPU final : public TimeFrame<NLayers>
 {
-  using typename TimeFrame<NLayers>::CellSeedN;
   using typename TimeFrame<NLayers>::IndexTableUtilsN;
   using typename TimeFrame<NLayers>::ROFOverlapTableN;
   using typename TimeFrame<NLayers>::ROFVertexLookupTableN;
   using typename TimeFrame<NLayers>::ROFMaskTableN;
+  using typename TimeFrame<NLayers>::TrackSeedN;
 
  public:
   TimeFrameGPU() = default;
@@ -72,7 +72,7 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
   void loadCellsLUTDevice();
   void loadTrackSeedsDevice();
   void loadTrackSeedsChi2Device();
-  void loadTrackSeedsDevice(bounded_vector<CellSeedN>&);
+  void loadTrackSeedsDevice(bounded_vector<TrackSeedN>&);
   void createTrackletsBuffers(const int);
   void createTrackletsBuffersArray(const int);
   void createCellsBuffers(const int);
@@ -136,8 +136,8 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
   int** getDeviceArrayTrackletsLUT() const { return mTrackletsLUTDeviceArray; }
   int** getDeviceArrayCellsLUT() const { return mCellsLUTDeviceArray; }
   int** getDeviceArrayNeighboursCellLUT() const { return mNeighboursCellLUTDeviceArray; }
-  CellSeedN** getDeviceArrayCells() { return mCellsDeviceArray; }
-  CellSeedN* getDeviceTrackSeeds() { return mTrackSeedsDevice; }
+  CellSeed** getDeviceArrayCells() { return mCellsDeviceArray; }
+  TrackSeedN* getDeviceTrackSeeds() { return mTrackSeedsDevice; }
   int* getDeviceTrackSeedsLUT() { return mTrackSeedsLUTDevice; }
   auto getNTrackSeeds() const { return mNTracks; }
   o2::track::TrackParCovF** getDeviceArrayTrackSeeds() { return mCellSeedsDeviceArray; }
@@ -157,7 +157,7 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
   gsl::span<int*> getDeviceTrackletsLUTs() { return mTrackletsLUTDevice; }
   gsl::span<int*> getDeviceCellLUTs() { return mCellsLUTDevice; }
   gsl::span<Tracklet*> getDeviceTracklets() { return mTrackletsDevice; }
-  gsl::span<CellSeedN*> getDeviceCells() { return mCellsDevice; }
+  gsl::span<CellSeed*> getDeviceCells() { return mCellsDevice; }
 
   // Overridden getters
   size_t getNumberOfTracklets() const final;
@@ -203,10 +203,10 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
   int** mNeighboursCellDeviceArray{nullptr};
   int** mNeighboursCellLUTDeviceArray{nullptr};
   int** mTrackletsLUTDeviceArray{nullptr};
-  std::array<CellSeedN*, NLayers - 2> mCellsDevice;
-  CellSeedN** mCellsDeviceArray;
+  std::array<CellSeed*, NLayers - 2> mCellsDevice;
+  CellSeed** mCellsDeviceArray;
   std::array<int*, NLayers - 3> mNeighboursIndexTablesDevice;
-  CellSeedN* mTrackSeedsDevice{nullptr};
+  TrackSeedN* mTrackSeedsDevice{nullptr};
   int* mTrackSeedsLUTDevice{nullptr};
   unsigned int mNTracks{0};
   std::array<o2::track::TrackParCovF*, NLayers - 2> mCellSeedsDevice;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
index 38d2a8ad5ddc2..81d870c5b46c2 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackerTraitsGPU.h
@@ -19,7 +19,7 @@
 namespace o2::its
 {
 
-template <int NLayers = 7>
+template <int NLayers>
 class TrackerTraitsGPU final : public TrackerTraits<NLayers>
 {
   using typename TrackerTraits<NLayers>::IndexTableUtilsN;
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index 6a977f8fef21a..bf004426f9134 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -24,8 +24,9 @@
 
 namespace o2::its
 {
-template <int>
 class CellSeed;
+template <int>
+class TrackSeed;
 class TrackingFrameInfo;
 class Tracklet;
 template <int>
@@ -34,7 +35,7 @@ class Cluster;
 class TrackITSExt;
 class ExternalAllocator;
 
-template <int NLayers = 7>
+template <int NLayers>
 void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  const typename ROFMaskTable<NLayers>::View& rofMask,
                                  const int layer,
@@ -62,7 +63,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  o2::its::ExternalAllocator* alloc,
                                  gpu::Streams& streams);
 
-template <int NLayers = 7>
+template <int NLayers>
 void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    const typename ROFMaskTable<NLayers>::View& rofMask,
                                    const int layer,
@@ -101,13 +102,14 @@ void countCellsHandler(const Cluster** sortedClusters,
                        int** trackletsLUT,
                        const int nTracklets,
                        const int layer,
-                       CellSeed<NLayers>* cells,
+                       CellSeed* cells,
                        int** cellsLUTsDeviceArray,
                        int* cellsLUTsHost,
                        const float bz,
                        const float maxChi2ClusterAttachment,
                        const float cellDeltaTanLambdaSigma,
                        const float nSigmaCut,
+                       const std::vector<float>& layerxX0Host,
                        o2::its::ExternalAllocator* alloc,
                        gpu::Streams& streams);
 
@@ -119,17 +121,18 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          int** trackletsLUT,
                          const int nTracklets,
                          const int layer,
-                         CellSeed<NLayers>* cells,
+                         CellSeed* cells,
                          int** cellsLUTsDeviceArray,
                          int* cellsLUTsHost,
                          const float bz,
                          const float maxChi2ClusterAttachment,
                          const float cellDeltaTanLambdaSigma,
                          const float nSigmaCut,
+                         const std::vector<float>& layerxX0Host,
                          gpu::Streams& streams);
 
 template <int NLayers>
-void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
+void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                 int* neighboursLUTs,
                                 int** cellsLUTs,
                                 gpuPair<int, int>* cellNeighbours,
@@ -145,7 +148,7 @@ void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                 gpu::Stream& stream);
 
 template <int NLayers>
-void computeCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
+void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   int* neighboursLUTs,
                                   int** cellsLUTs,
                                   gpuPair<int, int>* cellNeighbours,
@@ -165,31 +168,33 @@ int filterCellNeighboursHandler(gpuPair<int, int>*,
                                 gpu::Stream&,
                                 o2::its::ExternalAllocator* = nullptr);
 
-template <int NLayers = 7>
+template <int NLayers>
 void processNeighboursHandler(const int startLayer,
                               const int startLevel,
-                              CellSeed<NLayers>** allCellSeeds,
-                              CellSeed<NLayers>* currentCellSeeds,
+                              CellSeed** allCellSeeds,
+                              CellSeed* currentCellSeeds,
                               std::array<int, NLayers - 2>& nCells,
                               const unsigned char** usedClusters,
                               std::array<int*, NLayers - 2>& neighbours,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                              bounded_vector<CellSeed<NLayers>>& seedsHost,
+                              bounded_vector<TrackSeed<NLayers>>& seedsHost,
                               const float bz,
                               const float MaxChi2ClusterAttachment,
                               const float maxChi2NDF,
+                              const std::vector<float>& layerxX0Host,
                               const o2::base::Propagator* propagator,
                               const o2::base::PropagatorF::MatCorrType matCorrType,
                               o2::its::ExternalAllocator* alloc);
 
-template <int NLayers = 7>
-void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
+template <int NLayers>
+void countTrackSeedHandler(TrackSeed<NLayers>* trackSeeds,
                            const TrackingFrameInfo** foundTrackingFrameInfo,
                            const Cluster** unsortedClusters,
                            int* seedLUT,
                            const std::vector<float>& layerRadiiHost,
                            const std::vector<float>& minPtsHost,
+                           const std::vector<float>& layerxX0Host,
                            const unsigned int nSeeds,
                            const float Bz,
                            const int startLevel,
@@ -202,14 +207,15 @@ void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
                            const o2::base::PropagatorF::MatCorrType matCorrType,
                            o2::its::ExternalAllocator* alloc);
 
-template <int NLayers = 7>
-void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
+template <int NLayers>
+void computeTrackSeedHandler(TrackSeed<NLayers>* trackSeeds,
                              const TrackingFrameInfo** foundTrackingFrameInfo,
                              const Cluster** unsortedClusters,
                              o2::its::TrackITSExt* tracks,
                              const int* seedLUT,
                              const std::vector<float>& layerRadiiHost,
                              const std::vector<float>& minPtsHost,
+                             const std::vector<float>& layerxX0Host,
                              const unsigned int nSeeds,
                              const unsigned int nTracks,
                              const float Bz,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
index 44cd8d7e7492b..bcc20ace7bbc2 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/Utils.h
@@ -343,27 +343,6 @@ struct TypedAllocator {
   ExternalAllocator* mInternalAllocator;
 };
 
-template <int nLayers>
-GPUdii() const int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                                const o2::its::IndexTableUtils<nLayers>* utils,
-                                const float z1, const float z2, float maxdeltaz, float maxdeltaphi)
-{
-  const float zRangeMin = o2::gpu::CAMath::Min(z1, z2) - maxdeltaz;
-  const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : currentCluster.phi - maxdeltaphi;
-  const float zRangeMax = o2::gpu::CAMath::Max(z1, z2) + maxdeltaz;
-  const float phiRangeMax = (maxdeltaphi > o2::constants::math::PI) ? o2::constants::math::TwoPI : currentCluster.phi + maxdeltaphi;
-
-  if (zRangeMax < -utils->getLayerZ(layerIndex) ||
-      zRangeMin > utils->getLayerZ(layerIndex) || zRangeMin > zRangeMax) {
-    return {};
-  }
-
-  return int4{o2::gpu::CAMath::Max(0, utils->getZBinIndex(layerIndex, zRangeMin)),
-              utils->getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
-              o2::gpu::CAMath::Min(utils->getNzBins() - 1, utils->getZBinIndex(layerIndex, zRangeMax)),
-              utils->getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
-}
-
 GPUdii() gpuSpan<const Vertex> getPrimaryVertices(const int rof,
                                                   const int* roframesPV,
                                                   const int nROF,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index bd5e7a8bc59f8..b9091eebde377 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -433,11 +433,11 @@ void TimeFrameGPU<NLayers>::loadCellsDevice()
 {
   GPUTimer timer(mGpuStreams, "loading cell seeds", NLayers - 2);
   for (auto iLayer{0}; iLayer < NLayers - 2; ++iLayer) {
-    GPULog("gpu-transfer: loading {} cell seeds on layer {}, for {:.2f} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeedN) / constants::MB);
-    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeedN), mGpuStreams[iLayer], this->hasFrameworkAllocator());
+    GPULog("gpu-transfer: loading {} cell seeds on layer {}, for {:.2f} MB.", this->mCells[iLayer].size(), iLayer, this->mCells[iLayer].size() * sizeof(CellSeed) / constants::MB);
+    allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[iLayer]), this->mCells[iLayer].size() * sizeof(CellSeed), mGpuStreams[iLayer], this->hasFrameworkAllocator());
     allocMemAsync(reinterpret_cast<void**>(&mNeighboursIndexTablesDevice[iLayer]), (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer], this->hasFrameworkAllocator()); // accessory for the neigh. finding.
     GPUChkErrS(cudaMemsetAsync(mNeighboursIndexTablesDevice[iLayer], 0, (this->mCells[iLayer].size() + 1) * sizeof(int), mGpuStreams[iLayer].get()));
-    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeedN), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
+    GPUChkErrS(cudaMemcpyAsync(mCellsDevice[iLayer], this->mCells[iLayer].data(), this->mCells[iLayer].size() * sizeof(CellSeed), cudaMemcpyHostToDevice, mGpuStreams[iLayer].get()));
   }
 }
 
@@ -465,8 +465,8 @@ void TimeFrameGPU<NLayers>::createCellsBuffersArray(const int iteration)
 {
   if (!iteration) {
     GPUTimer timer("creating cells buffers array");
-    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (NLayers - 2) * sizeof(CellSeedN*), this->hasFrameworkAllocator());
-    GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeedN*), cudaMemcpyHostToDevice));
+    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (NLayers - 2) * sizeof(CellSeed*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeed*), cudaMemcpyHostToDevice));
   }
 }
 
@@ -477,10 +477,10 @@ void TimeFrameGPU<NLayers>::createCellsBuffers(const int layer)
   mNCells[layer] = 0;
   GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of cells is correct
-  GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeedN) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
-  GPUChkErrS(cudaMemsetAsync(mCellsDevice[layer], 0, mNCells[layer] * sizeof(CellSeedN), mGpuStreams[layer].get()));
-  GPUChkErrS(cudaMemcpyAsync(&mCellsDeviceArray[layer], &mCellsDevice[layer], sizeof(CellSeedN*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+  GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / constants::MB);
+  allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  GPUChkErrS(cudaMemsetAsync(mCellsDevice[layer], 0, mNCells[layer] * sizeof(CellSeed), mGpuStreams[layer].get()));
+  GPUChkErrS(cudaMemcpyAsync(&mCellsDeviceArray[layer], &mCellsDevice[layer], sizeof(CellSeed*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
 template <int NLayers>
@@ -495,12 +495,12 @@ void TimeFrameGPU<NLayers>::loadCellsLUTDevice()
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadTrackSeedsDevice(bounded_vector<CellSeedN>& seeds)
+void TimeFrameGPU<NLayers>::loadTrackSeedsDevice(bounded_vector<TrackSeedN>& seeds)
 {
   GPUTimer timer("loading track seeds");
-  GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(CellSeedN) / constants::MB);
-  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(CellSeedN), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
-  GPUChkErrS(cudaMemcpy(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(CellSeedN), cudaMemcpyHostToDevice));
+  GPULog("gpu-transfer: loading {} track seeds, for {:.2f} MB.", seeds.size(), seeds.size() * sizeof(TrackSeedN) / constants::MB);
+  allocMem(reinterpret_cast<void**>(&mTrackSeedsDevice), seeds.size() * sizeof(TrackSeedN), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  GPUChkErrS(cudaMemcpy(mTrackSeedsDevice, seeds.data(), seeds.size() * sizeof(TrackSeedN), cudaMemcpyHostToDevice));
   GPULog("gpu-transfer: creating {} track seeds LUT, for {:.2f} MB.", seeds.size() + 1, (seeds.size() + 1) * sizeof(int) / constants::MB);
   allocMem(reinterpret_cast<void**>(&mTrackSeedsLUTDevice), (seeds.size() + 1) * sizeof(int), this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
   GPUChkErrS(cudaMemset(mTrackSeedsLUTDevice, 0, (seeds.size() + 1) * sizeof(int)));
@@ -537,9 +537,9 @@ void TimeFrameGPU<NLayers>::downloadCellsDevice()
 {
   GPUTimer timer(mGpuStreams, "downloading cells", NLayers - 2);
   for (int iLayer{0}; iLayer < NLayers - 2; ++iLayer) {
-    GPULog("gpu-transfer: downloading {} cells on layer: {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeedN) / constants::MB);
+    GPULog("gpu-transfer: downloading {} cells on layer: {}, for {:.2f} MB.", mNCells[iLayer], iLayer, mNCells[iLayer] * sizeof(CellSeed) / constants::MB);
     this->mCells[iLayer].resize(mNCells[iLayer]);
-    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeedN), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
+    GPUChkErrS(cudaMemcpyAsync(this->mCells[iLayer].data(), this->mCellsDevice[iLayer], mNCells[iLayer] * sizeof(CellSeed), cudaMemcpyDeviceToHost, mGpuStreams[iLayer].get()));
   }
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index f7a416808fec7..0359f2cfb0d03 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -16,6 +16,7 @@
 
 #include "DataFormatsITS/TrackITS.h"
 
+#include "ITStracking/TrackHelpers.h"
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
 #include "ITStrackingGPU/TrackingKernels.h"
 #include "ITStracking/Constants.h"
@@ -184,6 +185,7 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
                                this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                                this->mTrkParams[iteration].NSigmaCut,
+                               this->mTrkParams[iteration].LayerxX0,
                                mTimeFrameGPU->getFrameworkAllocator(),
                                mTimeFrameGPU->getStreams());
     mTimeFrameGPU->createCellsBuffers(iLayer);
@@ -204,6 +206,7 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
                                  this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                  this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                                  this->mTrkParams[iteration].NSigmaCut,
+                                 this->mTrkParams[iteration].LayerxX0,
                                  mTimeFrameGPU->getStreams());
   }
 }
@@ -263,9 +266,13 @@ void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
 {
+  bounded_vector<bounded_vector<int>> firstClusters(this->mTrkParams[iteration].NLayers, bounded_vector<int>(this->getMemoryPool().get()), this->getMemoryPool().get());
+  bounded_vector<bounded_vector<int>> sharedFirstClusters(this->mTrkParams[iteration].NLayers, bounded_vector<int>(this->getMemoryPool().get()), this->getMemoryPool().get());
+  firstClusters.resize(this->mTrkParams[iteration].NLayers);
+  sharedFirstClusters.resize(this->mTrkParams[iteration].NLayers);
   for (int startLevel{this->mTrkParams[iteration].CellsPerRoad()}; startLevel >= this->mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
     const int minimumLayer{startLevel - 1};
-    bounded_vector<CellSeed<NLayers>> trackSeeds(this->getMemoryPool().get());
+    bounded_vector<TrackSeed<NLayers>> trackSeeds(this->getMemoryPool().get());
     for (int startLayer{this->mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= minimumLayer; --startLayer) {
       if ((this->mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
@@ -281,10 +288,11 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
                                         mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                                         trackSeeds,
                                         this->mBz,
-                                        this->mTrkParams[0].MaxChi2ClusterAttachment,
-                                        this->mTrkParams[0].MaxChi2NDF,
+                                        this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                                        this->mTrkParams[iteration].MaxChi2NDF,
+                                        this->mTrkParams[iteration].LayerxX0,
                                         mTimeFrameGPU->getDevicePropagator(),
-                                        this->mTrkParams[0].CorrType,
+                                        this->mTrkParams[iteration].CorrType,
                                         mTimeFrameGPU->getFrameworkAllocator());
     }
     // fixme: I don't want to move tracks back and forth, but I need a way to use a thrust::allocator that is aware of our managed memory.
@@ -302,16 +310,17 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
                           mTimeFrameGPU->getDeviceTrackSeedsLUT(),
                           this->mTrkParams[iteration].LayerRadii,
                           this->mTrkParams[iteration].MinPt,
+                          this->mTrkParams[iteration].LayerxX0,
                           trackSeeds.size(),
                           this->mBz,
                           startLevel,
-                          this->mTrkParams[0].MaxChi2ClusterAttachment,
-                          this->mTrkParams[0].MaxChi2NDF,
-                          this->mTrkParams[0].ReseedIfShorter,
-                          this->mTrkParams[0].RepeatRefitOut,
-                          this->mTrkParams[0].ShiftRefToCluster,
+                          this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                          this->mTrkParams[iteration].MaxChi2NDF,
+                          this->mTrkParams[iteration].ReseedIfShorter,
+                          this->mTrkParams[iteration].RepeatRefitOut,
+                          this->mTrkParams[iteration].ShiftRefToCluster,
                           mTimeFrameGPU->getDevicePropagator(),
-                          this->mTrkParams[0].CorrType,
+                          this->mTrkParams[iteration].CorrType,
                           mTimeFrameGPU->getFrameworkAllocator());
     mTimeFrameGPU->createTrackITSExtDevice(trackSeeds.size());
     computeTrackSeedHandler(mTimeFrameGPU->getDeviceTrackSeeds(),
@@ -321,65 +330,26 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
                             mTimeFrameGPU->getDeviceTrackSeedsLUT(),
                             this->mTrkParams[iteration].LayerRadii,
                             this->mTrkParams[iteration].MinPt,
+                            this->mTrkParams[iteration].LayerxX0,
                             trackSeeds.size(),
                             mTimeFrameGPU->getNTrackSeeds(),
                             this->mBz,
                             startLevel,
-                            this->mTrkParams[0].MaxChi2ClusterAttachment,
-                            this->mTrkParams[0].MaxChi2NDF,
-                            this->mTrkParams[0].ReseedIfShorter,
-                            this->mTrkParams[0].RepeatRefitOut,
-                            this->mTrkParams[0].ShiftRefToCluster,
+                            this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                            this->mTrkParams[iteration].MaxChi2NDF,
+                            this->mTrkParams[iteration].ReseedIfShorter,
+                            this->mTrkParams[iteration].RepeatRefitOut,
+                            this->mTrkParams[iteration].ShiftRefToCluster,
                             mTimeFrameGPU->getDevicePropagator(),
-                            this->mTrkParams[0].CorrType,
+                            this->mTrkParams[iteration].CorrType,
                             mTimeFrameGPU->getFrameworkAllocator());
     mTimeFrameGPU->downloadTrackITSExtDevice();
 
     auto& tracks = mTimeFrameGPU->getTrackITSExt();
-
-    for (auto& track : tracks) {
-      if (!track.getChi2()) {
-        continue; // this is to skip the unset tracks that are put at the beginning of the vector by the sorting. To see if this can be optimised.
-      }
-      int nShared = 0;
-      bool isFirstShared{false};
-      for (int iLayer{0}; iLayer < this->mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
-          continue;
-        }
-        nShared += int(mTimeFrameGPU->isClusterUsed(iLayer, track.getClusterIndex(iLayer)));
-        isFirstShared |= !iLayer && mTimeFrameGPU->isClusterUsed(iLayer, track.getClusterIndex(iLayer));
-      }
-
-      if (nShared > this->mTrkParams[0].ClusterSharing) {
-        continue;
-      }
-
-      bool firstCls{true};
-      TimeEstBC ts;
-      for (int iLayer{0}; iLayer < this->mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
-          continue;
-        }
-        mTimeFrameGPU->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
-        int currentROF = mTimeFrameGPU->getClusterROF(iLayer, track.getClusterIndex(iLayer));
-        auto rofTS = mTimeFrameGPU->getROFOverlapTableView().getLayer(iLayer).getROFTimeBounds(currentROF, true);
-        if (firstCls) {
-          ts = rofTS;
-        } else {
-          if (!ts.isCompatible(rofTS)) {
-            LOGP(fatal, "TS {}+/-{} are incompatible with {}+/-{}, this should not happen!", rofTS.getTimeStamp(), rofTS.getTimeStampError(), ts.getTimeStamp(), ts.getTimeStampError());
-          }
-          ts += rofTS;
-        }
-      }
-      track.getTimeStamp() = ts.makeSymmetrical();
-      track.setUserField(0);
-      track.getParamOut().setUserField(0);
-      mTimeFrameGPU->getTracks().emplace_back(track);
-    }
+    this->acceptTracks(iteration, tracks, firstClusters, sharedFirstClusters);
     mTimeFrameGPU->loadUsedClustersDevice();
   }
+  this->markTracks(iteration, sharedFirstClusters);
   // wipe the artefact memory
   mTimeFrameGPU->popMemoryStack(iteration);
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 54f92411a3df1..4b12583d99c00 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -31,6 +31,7 @@
 #include "ITStracking/Tracklet.h"
 #include "ITStracking/Cluster.h"
 #include "ITStracking/Cell.h"
+#include "ITStracking/TrackHelpers.h"
 #include "DataFormatsITS/TrackITS.h"
 #include "ITStrackingGPU/TrackingKernels.h"
 #include "ITStrackingGPU/Utils.h"
@@ -46,168 +47,6 @@ namespace o2::its
 namespace gpu
 {
 
-GPUdii() bool fitTrack(TrackITSExt& track,
-                       int start,
-                       int end,
-                       int step,
-                       float chi2clcut,
-                       float chi2ndfcut,
-                       float maxQoverPt,
-                       int nCl,
-                       float bz,
-                       const TrackingFrameInfo** tfInfos,
-                       const o2::base::Propagator* prop,
-                       o2::base::PropagatorF::MatCorrType matCorrType,
-                       o2::track::TrackPar* linRef,
-                       const bool shiftRefToCluster)
-{
-  for (int iLayer{start}; iLayer != end; iLayer += step) {
-    if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
-      continue;
-    }
-    const TrackingFrameInfo& trackingHit = tfInfos[iLayer][track.getClusterIndex(iLayer)];
-    if (linRef) {
-      if (!track.o2::track::TrackParCovF::rotate(trackingHit.alphaTrackingFrame, *linRef, bz)) {
-        return false;
-      }
-      if (!prop->propagateToX(track,
-                              *linRef,
-                              trackingHit.xTrackingFrame,
-                              bz,
-                              o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                              o2::base::PropagatorImpl<float>::MAX_STEP,
-                              matCorrType)) {
-
-        return false;
-      }
-      if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-        const float xx0 = (iLayer > 2) ? 1.e-2f : 5.e-3f; // Rough layer thickness
-        if (!track.correctForMaterial(*linRef, xx0, xx0 * constants::Radl * constants::Rho, true)) {
-          return false;
-        }
-      }
-    } else {
-      if (!track.o2::track::TrackParCovF::rotate(trackingHit.alphaTrackingFrame)) {
-        return false;
-      }
-      if (!prop->propagateToX(track,
-                              trackingHit.xTrackingFrame,
-                              bz,
-                              o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
-                              o2::base::PropagatorImpl<float>::MAX_STEP,
-                              matCorrType)) {
-        return false;
-      }
-      if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-        const float xx0 = (iLayer > 2) ? 1.e-2f : 5.e-3f; // Rough layer thickness
-        if (!track.correctForMaterial(xx0, xx0 * constants::Radl * constants::Rho, true)) {
-          return false;
-        }
-      }
-    }
-
-    auto predChi2{track.getPredictedChi2(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
-    if ((nCl >= 3 && predChi2 > chi2clcut) || predChi2 < 0.f) {
-      return false;
-    }
-    track.setChi2(track.getChi2() + predChi2);
-    if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
-      return false;
-    }
-    if (linRef && shiftRefToCluster) { // displace the reference to the last updated cluster
-      linRef->setY(trackingHit.positionTrackingFrame[0]);
-      linRef->setZ(trackingHit.positionTrackingFrame[1]);
-    }
-    nCl++;
-  }
-  return o2::gpu::CAMath::Abs(track.getQ2Pt()) < maxQoverPt && track.getChi2() < chi2ndfcut * (nCl * 2 - 5);
-}
-
-GPUdii() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
-                                               const Cluster& cluster2,
-                                               const TrackingFrameInfo& tf3,
-                                               const float bz,
-                                               const bool reverse = false)
-{
-  const float sign = reverse ? -1.f : 1.f;
-
-  float ca, sa;
-  o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
-
-  const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
-  const float y1 = -cluster1.xCoordinate * sa + cluster1.yCoordinate * ca;
-  const float x2 = cluster2.xCoordinate * ca + cluster2.yCoordinate * sa;
-  const float y2 = -cluster2.xCoordinate * sa + cluster2.yCoordinate * ca;
-  const float x3 = tf3.xTrackingFrame;
-  const float y3 = tf3.positionTrackingFrame[0];
-
-  float snp, q2pt, q2pt2;
-  if (o2::gpu::CAMath::Abs(bz) < 0.01f) {
-    const float dx = x3 - x1;
-    const float dy = y3 - y1;
-    snp = sign * dy / o2::gpu::CAMath::Hypot(dx, dy);
-    q2pt = 1.f / track::kMostProbablePt;
-    q2pt2 = 1.f;
-  } else {
-    const float crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
-    snp = sign * crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
-    q2pt = sign * crv / (bz * o2::constants::math::B2C);
-    q2pt2 = crv * crv;
-  }
-
-  const float tgl = 0.5f * (math_utils::computeTanDipAngle(x1, y1, x2, y2, cluster1.zCoordinate, cluster2.zCoordinate) +
-                            math_utils::computeTanDipAngle(x2, y2, x3, y3, cluster2.zCoordinate, tf3.positionTrackingFrame[1]));
-  const float sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005f ? (q2pt2 < 1.f ? q2pt2 : 1.f) : 0.0005f);
-
-  return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
-}
-
-template <int NLayers>
-GPUdii() TrackITSExt seedTrackForRefit(const CellSeed<NLayers>& seed,
-                                       const TrackingFrameInfo** foundTrackingFrameInfo,
-                                       const Cluster** unsortedClusters,
-                                       const float* layerRadii,
-                                       const float bz,
-                                       const int reseedIfShorter)
-{
-  TrackITSExt temporaryTrack(seed);
-  int lrMin = NLayers, lrMax = 0, lrMid = 0;
-  for (int iL{0}; iL < NLayers; ++iL) {
-    const int idx = seed.getCluster(iL);
-    temporaryTrack.setExternalClusterIndex(iL, idx, idx != constants::UnusedIndex);
-    if (idx != constants::UnusedIndex) {
-      // TODO only works if does not have holes
-      lrMin = o2::gpu::CAMath::Min(lrMin, iL);
-      lrMax = o2::gpu::CAMath::Max(lrMax, iL);
-    }
-  }
-  const int ncl = temporaryTrack.getNClusters();
-  if (ncl < reseedIfShorter && ncl > 0) { // need to check if there are any clusters since we keep invalidate seeeds around
-    if (ncl == NLayers) {
-      lrMin = 0;
-      lrMax = NLayers - 1;
-      lrMid = (lrMin + lrMax) / 2;
-    } else {
-      lrMid = lrMin + 1;
-      float midR = 0.5f * (layerRadii[lrMax] + layerRadii[lrMin]), dstMidR = o2::gpu::CAMath::Abs(midR - layerRadii[lrMid]);
-      for (int iL = lrMid + 1; iL < lrMax; ++iL) { // find the midpoint as closest to the midR
-        auto dst = o2::gpu::GPUCommonMath::Abs(midR - layerRadii[iL]);
-        if (dst < dstMidR) {
-          lrMid = iL;
-          dstMidR = dst;
-        }
-      }
-    }
-    const auto& cluster0_tf = foundTrackingFrameInfo[lrMin][seed.getCluster(lrMin)];
-    const auto& cluster1_gl = unsortedClusters[lrMid][seed.getCluster(lrMid)];
-    const auto& cluster2_gl = unsortedClusters[lrMax][seed.getCluster(lrMax)];
-    temporaryTrack.getParamIn() = buildTrackSeed(cluster2_gl, cluster1_gl, cluster0_tf, bz, true);
-  }
-  temporaryTrack.resetCovariance();
-  temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
-  return temporaryTrack;
-}
-
 struct sort_tracklets {
   GPUhd() bool operator()(const Tracklet& a, const Tracklet& b)
   {
@@ -265,7 +104,7 @@ struct seed_selector {
   float maxChi2;
 
   GPUhd() seed_selector(float maxQ2Pt, float maxChi2) : maxQ2Pt(maxQ2Pt), maxChi2(maxChi2) {}
-  GPUhd() bool operator()(const CellSeed<NLayers>& seed) const
+  GPUhd() bool operator()(const TrackSeed<NLayers>& seed) const
   {
     return !(seed.getQ2Pt() > maxQ2Pt || seed.getChi2() > maxChi2);
   }
@@ -280,13 +119,14 @@ struct compare_track_chi2 {
 
 template <bool initRun, int NLayers>
 GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
-  CellSeed<NLayers>* trackSeeds,
+  TrackSeed<NLayers>* trackSeeds,
   const TrackingFrameInfo** foundTrackingFrameInfo,
   const Cluster** unsortedClusters,
   o2::its::TrackITSExt* tracks,
   maybe_const<!initRun, int>* seedLUT,
   const float* layerRadii,
   const float* minPts,
+  const float* layerxX0,
   const unsigned int nSeeds,
   const float bz,
   const int startLevel,
@@ -294,7 +134,7 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
   const float maxChi2NDF,
   const int reseedIfShorter,
   const bool repeatRefitOut,
-  const bool shifRefToCluster,
+  const bool shiftRefToCluster,
   const o2::base::Propagator* propagator,
   const o2::base::PropagatorF::MatCorrType matCorrType)
 {
@@ -305,88 +145,35 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
         continue;
       }
     }
-
-    TrackITSExt temporaryTrack = seedTrackForRefit<NLayers>(trackSeeds[iCurrentTrackSeedIndex], foundTrackingFrameInfo, unsortedClusters, layerRadii, bz, reseedIfShorter);
-    o2::track::TrackPar linRef{temporaryTrack};
-    bool fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
-                               0,                            // int lastLayer,
-                               NLayers,                      // int firstLayer,
-                               1,                            // int firstCluster,
-                               maxChi2ClusterAttachment,     // float maxChi2ClusterAttachment,
-                               maxChi2NDF,                   // float maxChi2NDF,
-                               o2::constants::math::VeryBig, // float maxQoverPt,
-                               0,                            // nCl,
-                               bz,                           // float bz,
-                               foundTrackingFrameInfo,       // TrackingFrameInfo** trackingFrameInfo,
-                               propagator,                   // const o2::base::Propagator* propagator,
-                               matCorrType,                  // o2::base::PropagatorF::MatCorrType matCorrType
-                               &linRef,
-                               shifRefToCluster);
-    if (!fitSuccess) {
-      continue;
-    }
-    temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
-    linRef = temporaryTrack.getParamOut(); // use refitted track as lin.reference
-    temporaryTrack.resetCovariance();
-    temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
-    temporaryTrack.setChi2(0);
-    fitSuccess = fitTrack(temporaryTrack,           // TrackITSExt& track,
-                          NLayers - 1,              // int lastLayer,
-                          -1,                       // int firstLayer,
-                          -1,                       // int firstCluster,
-                          maxChi2ClusterAttachment, // float maxChi2ClusterAttachment,
-                          maxChi2NDF,               // float maxChi2NDF,
-                          50.f,                     // float maxQoverPt,
-                          0,                        // nCl,
-                          bz,                       // float bz,
-                          foundTrackingFrameInfo,   // TrackingFrameInfo** trackingFrameInfo,
-                          propagator,               // const o2::base::Propagator* propagator,
-                          matCorrType,              // o2::base::PropagatorF::MatCorrType matCorrType
-                          &linRef,
-                          shifRefToCluster);
-    if (!fitSuccess || temporaryTrack.getPt() < minPts[NLayers - temporaryTrack.getNClusters()]) {
-      continue;
-    }
-    if (repeatRefitOut) { // repeat outward refit seeding and linearizing with the stable inward fit result
-      o2::track::TrackParCov saveInw{temporaryTrack};
-      linRef = saveInw; // use refitted track as lin.reference
-      float saveChi2 = temporaryTrack.getChi2();
-      temporaryTrack.resetCovariance();
-      temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
-      temporaryTrack.setChi2(0);
-      fitSuccess = fitTrack(temporaryTrack,               // TrackITSExt& track,
-                            0,                            // int lastLayer,
-                            NLayers,                      // int firstLayer,
-                            1,                            // int firstCluster,
-                            maxChi2ClusterAttachment,     // float maxChi2ClusterAttachment,
-                            maxChi2NDF,                   // float maxChi2NDF,
-                            o2::constants::math::VeryBig, // float maxQoverPt,
-                            0,                            // nCl,
-                            bz,                           // float bz,
-                            foundTrackingFrameInfo,       // TrackingFrameInfo** trackingFrameInfo,
-                            propagator,                   // const o2::base::Propagator* propagator,
-                            matCorrType,                  // o2::base::PropagatorF::MatCorrType matCorrType
-                            &linRef,
-                            shifRefToCluster);
-      if (!fitSuccess) {
-        continue;
+    TrackITSExt temporaryTrack;
+    bool refitSuccess = o2::its::track::refitTrack(trackSeeds[iCurrentTrackSeedIndex],
+                                                   temporaryTrack,
+                                                   maxChi2ClusterAttachment,
+                                                   maxChi2NDF,
+                                                   bz,
+                                                   foundTrackingFrameInfo,
+                                                   unsortedClusters,
+                                                   layerxX0,
+                                                   layerRadii,
+                                                   minPts,
+                                                   propagator,
+                                                   matCorrType,
+                                                   reseedIfShorter,
+                                                   shiftRefToCluster,
+                                                   repeatRefitOut);
+    if (refitSuccess) {
+      if constexpr (initRun) {
+        seedLUT[iCurrentTrackSeedIndex] = 1;
+      } else {
+        tracks[seedLUT[iCurrentTrackSeedIndex]] = temporaryTrack;
       }
-      temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
-      temporaryTrack.getParamIn() = saveInw;
-      temporaryTrack.setChi2(saveChi2);
-    }
-
-    if constexpr (initRun) {
-      seedLUT[iCurrentTrackSeedIndex] = 1;
-    } else {
-      tracks[seedLUT[iCurrentTrackSeedIndex]] = temporaryTrack;
     }
   }
 }
 
-template <bool initRun, int NLayers = 7>
+template <bool initRun, int NLayers>
 GPUg() void __launch_bounds__(256, 1) computeLayerCellNeighboursKernel(
-  CellSeed<NLayers>** cellSeedArray,
+  CellSeed** cellSeedArray,
   int* neighboursLUT,
   int* neighboursIndexTable,
   int** cellsLUTs,
@@ -449,14 +236,14 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
   int** trackletsLUT,
   const int nTrackletsCurrent,
   const int layer,
-  CellSeed<NLayers>* cells,
+  CellSeed* cells,
   int** cellsLUTs,
+  const float* layerxX0,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut)
 {
-  constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // FIXME: Hardcoded here for the moment.
   for (int iCurrentTrackletIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentTrackletIndex < nTrackletsCurrent; iCurrentTrackletIndex += blockDim.x * gridDim.x) {
     if constexpr (!initRun) {
       if (cellsLUTs[layer][iCurrentTrackletIndex] == cellsLUTs[layer][iCurrentTrackletIndex + 1]) {
@@ -490,7 +277,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
         const auto& cluster1_glo = unsortedClusters[layer][clusId[0]];
         const auto& cluster2_glo = unsortedClusters[layer + 1][clusId[1]];
         const auto& cluster3_tf = tfInfo[layer + 2][clusId[2]];
-        auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf, bz)};
+        auto track{o2::its::track::buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf, bz)};
         float chi2{0.f};
         bool good{false};
         for (int iC{2}; iC--;) {
@@ -522,7 +309,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
         if constexpr (!initRun) {
           TimeEstBC ts = currentTracklet.getTimeStamp();
           ts += nextTracklet.getTimeStamp();
-          new (cells + cellsLUTs[layer][iCurrentTrackletIndex] + foundCells) CellSeed<NLayers>{layer, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2, ts};
+          new (cells + cellsLUTs[layer][iCurrentTrackletIndex] + foundCells) CellSeed{layer, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2, ts};
         }
         ++foundCells;
       }
@@ -620,7 +407,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
         const float zAtRmax{tanLambda * (maxR - currentCluster.radius) + currentCluster.zCoordinate};
         const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + constants::Tolerance)}; /// protecting from overflows adding the detector resolution
         const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * MSAngle))};
-        const int4 selectedBinsRect{getBinsRect<NLayers>(currentCluster, layerIndex + 1, utils, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut)};
+        const int4 selectedBinsRect{o2::its::getBinsRect(currentCluster, layerIndex + 1, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut, *utils)};
         if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
           continue;
         }
@@ -631,7 +418,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
         }
 
         for (short targetROF = rofOverlap.getFirstEntry(); targetROF < rofOverlap.getEntriesBound(); ++targetROF) {
-          if (!rofMask.isROFEnabled(layerIndex + 1, pivotROF)) {
+          if (!rofMask.isROFEnabled(layerIndex + 1, targetROF)) {
             continue;
           }
           auto clustersNextLayer = getClustersOnLayer(targetROF, totalROFs1, layerIndex + 1, ROFClusters, clusters);
@@ -687,27 +474,27 @@ GPUg() void __launch_bounds__(256, 1) compileTrackletsLookupTableKernel(
   }
 }
 
-template <bool dryRun, int NLayers = 7>
+template <bool dryRun, int NLayers, typename CurrentSeed>
 GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
   const int layer,
   const int level,
-  CellSeed<NLayers>** allCellSeeds,
-  CellSeed<NLayers>* currentCellSeeds,
+  CellSeed** allCellSeeds,
+  CurrentSeed* currentCellSeeds,
   const int* currentCellIds,
   const unsigned int nCurrentCells,
-  CellSeed<NLayers>* updatedCellSeeds,
+  TrackSeed<NLayers>* updatedCellSeeds,
   int* updatedCellsIds,
   int* foundSeedsTable,               // auxiliary only in GPU code to compute the number of cells per iteration
   const unsigned char** usedClusters, // Used clusters
   int* neighbours,
   int* neighboursLUT,
   const TrackingFrameInfo** foundTrackingFrameInfo,
+  const float* layerxX0,
   const float bz,
   const float maxChi2ClusterAttachment,
   const o2::base::Propagator* propagator,
   const o2::base::PropagatorF::MatCorrType matCorrType)
 {
-  constexpr float layerxX0[7] = {5.e-3f, 5.e-3f, 5.e-3f, 1.e-2f, 1.e-2f, 1.e-2f, 1.e-2f}; // FIXME: Hardcoded here for the moment.
   for (unsigned int iCurrentCell = blockIdx.x * blockDim.x + threadIdx.x; iCurrentCell < nCurrentCells; iCurrentCell += blockDim.x * gridDim.x) {
     if constexpr (!dryRun) {
       if (foundSeedsTable[iCurrentCell] == foundSeedsTable[iCurrentCell + 1]) {
@@ -745,7 +532,7 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
       if (usedClusters[layer - 1][neighbourCell.getFirstClusterIndex()]) {
         continue;
       }
-      auto seed{currentCell};
+      TrackSeed<NLayers> seed{currentCell};
       auto& trHit = foundTrackingFrameInfo[layer - 1][neighbourCell.getFirstClusterIndex()];
 
       if (!seed.rotate(trHit.alphaTrackingFrame)) {
@@ -922,26 +709,29 @@ void countCellsHandler(
   int** trackletsLUT,
   const int nTracklets,
   const int layer,
-  CellSeed<NLayers>* cells,
+  CellSeed* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut,
+  const std::vector<float>& layerxX0Host,
   o2::its::ExternalAllocator* alloc,
   gpu::Streams& streams)
 {
-  gpu::computeLayerCellsKernel<true><<<60, 256, 0, streams[layer].get()>>>(
-    sortedClusters,           // const Cluster**
-    unsortedClusters,         // const Cluster**
-    tfInfo,                   // const TrackingFrameInfo**
-    tracklets,                // const Tracklets**
-    trackletsLUT,             // const int**
-    nTracklets,               // const int
-    layer,                    // const int
-    cells,                    // CellSeed*
-    cellsLUTsArrayDevice,     // int**
+  thrust::device_vector<float> layerxX0(layerxX0Host);
+  gpu::computeLayerCellsKernel<true, NLayers><<<60, 256, 0, streams[layer].get()>>>(
+    sortedClusters,       // const Cluster**
+    unsortedClusters,     // const Cluster**
+    tfInfo,               // const TrackingFrameInfo**
+    tracklets,            // const Tracklets**
+    trackletsLUT,         // const int**
+    nTracklets,           // const int
+    layer,                // const int
+    cells,                // CellSeed*
+    cellsLUTsArrayDevice, // int**
+    thrust::raw_pointer_cast(&layerxX0[0]),
     bz,                       // const float
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
@@ -959,25 +749,28 @@ void computeCellsHandler(
   int** trackletsLUT,
   const int nTracklets,
   const int layer,
-  CellSeed<NLayers>* cells,
+  CellSeed* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
   const float bz,
   const float maxChi2ClusterAttachment,
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut,
+  const std::vector<float>& layerxX0Host,
   gpu::Streams& streams)
 {
-  gpu::computeLayerCellsKernel<false><<<60, 256, 0, streams[layer].get()>>>(
-    sortedClusters,           // const Cluster**
-    unsortedClusters,         // const Cluster**
-    tfInfo,                   // const TrackingFrameInfo**
-    tracklets,                // const Tracklets**
-    trackletsLUT,             // const int**
-    nTracklets,               // const int
-    layer,                    // const int
-    cells,                    // CellSeed*
-    cellsLUTsArrayDevice,     // int**
+  thrust::device_vector<float> layerxX0(layerxX0Host);
+  gpu::computeLayerCellsKernel<false, NLayers><<<60, 256, 0, streams[layer].get()>>>(
+    sortedClusters,       // const Cluster**
+    unsortedClusters,     // const Cluster**
+    tfInfo,               // const TrackingFrameInfo**
+    tracklets,            // const Tracklets**
+    trackletsLUT,         // const int**
+    nTracklets,           // const int
+    layer,                // const int
+    cells,                // CellSeed*
+    cellsLUTsArrayDevice, // int**
+    thrust::raw_pointer_cast(&layerxX0[0]),
     bz,                       // const float
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
@@ -985,7 +778,7 @@ void computeCellsHandler(
 }
 
 template <int NLayers>
-void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
+void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                 int* neighboursLUT,
                                 int** cellsLUTs,
                                 gpuPair<int, int>* cellNeighbours,
@@ -1000,7 +793,7 @@ void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                 o2::its::ExternalAllocator* alloc,
                                 gpu::Stream& stream)
 {
-  gpu::computeLayerCellNeighboursKernel<true><<<60, 256, 0, stream.get()>>>(
+  gpu::computeLayerCellNeighboursKernel<true, NLayers><<<60, 256, 0, stream.get()>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1018,7 +811,7 @@ void countCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
 }
 
 template <int NLayers>
-void computeCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
+void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
                                   int* neighboursLUT,
                                   int** cellsLUTs,
                                   gpuPair<int, int>* cellNeighbours,
@@ -1032,7 +825,7 @@ void computeCellNeighboursHandler(CellSeed<NLayers>** cellsLayersDevice,
                                   const int maxCellNeighbours,
                                   gpu::Stream& stream)
 {
-  gpu::computeLayerCellNeighboursKernel<false><<<60, 256, 0, stream.get()>>>(
+  gpu::computeLayerCellNeighboursKernel<false, NLayers><<<60, 256, 0, stream.get()>>>(
     cellsLayersDevice,
     neighboursLUT,
     neighboursIndexTable,
@@ -1065,17 +858,18 @@ int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
 template <int NLayers>
 void processNeighboursHandler(const int startLayer,
                               const int startLevel,
-                              CellSeed<NLayers>** allCellSeeds,
-                              CellSeed<NLayers>* currentCellSeeds,
+                              CellSeed** allCellSeeds,
+                              CellSeed* currentCellSeeds,
                               std::array<int, NLayers - 2>& nCells,
                               const unsigned char** usedClusters,
                               std::array<int*, NLayers - 2>& neighbours,
                               gsl::span<int*> neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
-                              bounded_vector<CellSeed<NLayers>>& seedsHost,
+                              bounded_vector<TrackSeed<NLayers>>& seedsHost,
                               const float bz,
                               const float maxChi2ClusterAttachment,
                               const float maxChi2NDF,
+                              const std::vector<float>& layerxX0Host,
                               const o2::base::Propagator* propagator,
                               const o2::base::PropagatorF::MatCorrType matCorrType,
                               o2::its::ExternalAllocator* alloc)
@@ -1083,11 +877,12 @@ void processNeighboursHandler(const int startLayer,
   constexpr uint64_t Tag = qStr2Tag("ITS_PNH1");
   alloc->pushTagOnStack(Tag);
   auto allocInt = gpu::TypedAllocator<int>(alloc);
-  auto allocCellSeed = gpu::TypedAllocator<CellSeed<NLayers>>(alloc);
+  auto allocTrackSeed = gpu::TypedAllocator<TrackSeed<NLayers>>(alloc);
+  thrust::device_vector<float> layerxX0(layerxX0Host);
   thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
   auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(gpu::Stream::DefaultStream);
 
-  gpu::processNeighboursKernel<true, NLayers><<<60, 256>>>(
+  gpu::processNeighboursKernel<true, NLayers, CellSeed><<<60, 256>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1101,6 +896,7 @@ void processNeighboursHandler(const int startLayer,
     neighbours[startLayer - 1],
     neighboursDeviceLUTs[startLayer - 1],
     foundTrackingFrameInfo,
+    thrust::raw_pointer_cast(&layerxX0[0]),
     bz,
     maxChi2ClusterAttachment,
     propagator,
@@ -1108,8 +904,8 @@ void processNeighboursHandler(const int startLayer,
   thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
 
   thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
-  thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>> updatedCellSeed(foundSeedsTable.back(), allocCellSeed);
-  gpu::processNeighboursKernel<false, NLayers><<<60, 256>>>(
+  thrust::device_vector<TrackSeed<NLayers>, gpu::TypedAllocator<TrackSeed<NLayers>>> updatedCellSeed(foundSeedsTable.back(), allocTrackSeed);
+  gpu::processNeighboursKernel<false, NLayers, CellSeed><<<60, 256>>>(
     startLayer,
     startLevel,
     allCellSeeds,
@@ -1123,6 +919,7 @@ void processNeighboursHandler(const int startLayer,
     neighbours[startLayer - 1],
     neighboursDeviceLUTs[startLayer - 1],
     foundTrackingFrameInfo,
+    thrust::raw_pointer_cast(&layerxX0[0]),
     bz,
     maxChi2ClusterAttachment,
     propagator,
@@ -1131,17 +928,17 @@ void processNeighboursHandler(const int startLayer,
 
   int level = startLevel;
   thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
-  thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>> lastCellSeed(allocCellSeed);
+  thrust::device_vector<TrackSeed<NLayers>, gpu::TypedAllocator<TrackSeed<NLayers>>> lastCellSeed(allocTrackSeed);
   for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
     lastCellSeed.swap(updatedCellSeed);
     lastCellId.swap(updatedCellId);
-    thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>>(allocCellSeed).swap(updatedCellSeed);
+    thrust::device_vector<TrackSeed<NLayers>, gpu::TypedAllocator<TrackSeed<NLayers>>>(allocTrackSeed).swap(updatedCellSeed);
     thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellId);
     auto lastCellSeedSize{lastCellSeed.size()};
     foundSeedsTable.resize(lastCellSeedSize + 1);
     thrust::fill(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
-    gpu::processNeighboursKernel<true, NLayers><<<60, 256>>>(
+    gpu::processNeighboursKernel<true, NLayers, TrackSeed<NLayers>><<<60, 256>>>(
       iLayer,
       --level,
       allCellSeeds,
@@ -1155,6 +952,7 @@ void processNeighboursHandler(const int startLayer,
       neighbours[iLayer - 1],
       neighboursDeviceLUTs[iLayer - 1],
       foundTrackingFrameInfo,
+      thrust::raw_pointer_cast(&layerxX0[0]),
       bz,
       maxChi2ClusterAttachment,
       propagator,
@@ -1165,9 +963,9 @@ void processNeighboursHandler(const int startLayer,
     updatedCellId.resize(foundSeeds);
     thrust::fill(nosync_policy, updatedCellId.begin(), updatedCellId.end(), 0);
     updatedCellSeed.resize(foundSeeds);
-    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), CellSeed<NLayers>());
+    thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), TrackSeed<NLayers>());
 
-    gpu::processNeighboursKernel<false, NLayers><<<60, 256>>>(
+    gpu::processNeighboursKernel<false, NLayers, TrackSeed<NLayers>><<<60, 256>>>(
       iLayer,
       level,
       allCellSeeds,
@@ -1181,13 +979,14 @@ void processNeighboursHandler(const int startLayer,
       neighbours[iLayer - 1],
       neighboursDeviceLUTs[iLayer - 1],
       foundTrackingFrameInfo,
+      thrust::raw_pointer_cast(&layerxX0[0]),
       bz,
       maxChi2ClusterAttachment,
       propagator,
       matCorrType);
   }
   GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
-  thrust::device_vector<CellSeed<NLayers>, gpu::TypedAllocator<CellSeed<NLayers>>> outSeeds(updatedCellSeed.size(), allocCellSeed);
+  thrust::device_vector<TrackSeed<NLayers>, gpu::TypedAllocator<TrackSeed<NLayers>>> outSeeds(updatedCellSeed.size(), allocTrackSeed);
   auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector<NLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
   auto s{end - outSeeds.begin()};
   seedsHost.reserve(seedsHost.size() + s);
@@ -1196,12 +995,13 @@ void processNeighboursHandler(const int startLayer,
 }
 
 template <int NLayers>
-void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
+void countTrackSeedHandler(TrackSeed<NLayers>* trackSeeds,
                            const TrackingFrameInfo** foundTrackingFrameInfo,
                            const Cluster** unsortedClusters,
                            int* seedLUT,
                            const std::vector<float>& layerRadiiHost,
                            const std::vector<float>& minPtsHost,
+                           const std::vector<float>& layerxX0Host,
                            const unsigned int nSeeds,
                            const float bz,
                            const int startLevel,
@@ -1219,6 +1019,7 @@ void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
   // small transferes!
   thrust::device_vector<float> minPts(minPtsHost);
   thrust::device_vector<float> layerRadii(layerRadiiHost);
+  thrust::device_vector<float> layerxX0(layerxX0Host);
   gpu::fitTrackSeedsKernel<true, NLayers><<<60, 256>>>(
     trackSeeds,                               // CellSeed*
     foundTrackingFrameInfo,                   // TrackingFrameInfo**
@@ -1227,6 +1028,7 @@ void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
     seedLUT,                                  // int*
     thrust::raw_pointer_cast(&layerRadii[0]), // const float*
     thrust::raw_pointer_cast(&minPts[0]),     // const float*
+    thrust::raw_pointer_cast(&layerxX0[0]),   // const float*
     nSeeds,                                   // const unsigned int
     bz,                                       // const float
     startLevel,                               // const int
@@ -1242,13 +1044,14 @@ void countTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
 }
 
 template <int NLayers>
-void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
+void computeTrackSeedHandler(TrackSeed<NLayers>* trackSeeds,
                              const TrackingFrameInfo** foundTrackingFrameInfo,
                              const Cluster** unsortedClusters,
                              o2::its::TrackITSExt* tracks,
                              const int* seedLUT,
                              const std::vector<float>& layerRadiiHost,
                              const std::vector<float>& minPtsHost,
+                             const std::vector<float>& layerxX0Host,
                              const unsigned int nSeeds,
                              const unsigned int nTracks,
                              const float bz,
@@ -1264,6 +1067,7 @@ void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
 {
   thrust::device_vector<float> minPts(minPtsHost);
   thrust::device_vector<float> layerRadii(layerRadiiHost);
+  thrust::device_vector<float> layerxX0(layerxX0Host);
   gpu::fitTrackSeedsKernel<false, NLayers><<<60, 256>>>(
     trackSeeds,                               // CellSeed*
     foundTrackingFrameInfo,                   // TrackingFrameInfo**
@@ -1272,6 +1076,7 @@ void computeTrackSeedHandler(CellSeed<NLayers>* trackSeeds,
     seedLUT,                                  // const int*
     thrust::raw_pointer_cast(&layerRadii[0]), // const float*
     thrust::raw_pointer_cast(&minPts[0]),     // const float*
+    thrust::raw_pointer_cast(&layerxX0[0]),   // const float*
     nSeeds,                                   // const unsigned int
     bz,                                       // const float
     startLevel,                               // const int
@@ -1352,13 +1157,14 @@ template void countCellsHandler<7>(const Cluster** sortedClusters,
                                    int** trackletsLUT,
                                    const int nTracklets,
                                    const int layer,
-                                   CellSeed<7>* cells,
+                                   CellSeed* cells,
                                    int** cellsLUTsArrayDevice,
                                    int* cellsLUTsHost,
                                    const float bz,
                                    const float maxChi2ClusterAttachment,
                                    const float cellDeltaTanLambdaSigma,
                                    const float nSigmaCut,
+                                   const std::vector<float>& layerxX0Host,
                                    o2::its::ExternalAllocator* alloc,
                                    gpu::Streams& streams);
 
@@ -1369,16 +1175,17 @@ template void computeCellsHandler<7>(const Cluster** sortedClusters,
                                      int** trackletsLUT,
                                      const int nTracklets,
                                      const int layer,
-                                     CellSeed<7>* cells,
+                                     CellSeed* cells,
                                      int** cellsLUTsArrayDevice,
                                      int* cellsLUTsHost,
                                      const float bz,
                                      const float maxChi2ClusterAttachment,
                                      const float cellDeltaTanLambdaSigma,
                                      const float nSigmaCut,
+                                     const std::vector<float>& layerxX0Host,
                                      gpu::Streams& streams);
 
-template void countCellNeighboursHandler<7>(CellSeed<7>** cellsLayersDevice,
+template void countCellNeighboursHandler<7>(CellSeed** cellsLayersDevice,
                                             int* neighboursLUT,
                                             int** cellsLUTs,
                                             gpuPair<int, int>* cellNeighbours,
@@ -1393,43 +1200,45 @@ template void countCellNeighboursHandler<7>(CellSeed<7>** cellsLayersDevice,
                                             o2::its::ExternalAllocator* alloc,
                                             gpu::Stream& stream);
 
-template void computeCellNeighboursHandler(CellSeed<7>** cellsLayersDevice,
-                                           int* neighboursLUT,
-                                           int** cellsLUTs,
-                                           gpuPair<int, int>* cellNeighbours,
-                                           int* neighboursIndexTable,
-                                           const Tracklet** tracklets,
-                                           const float maxChi2ClusterAttachment,
-                                           const float bz,
-                                           const int layerIndex,
-                                           const unsigned int nCells,
-                                           const unsigned int nCellsNext,
-                                           const int maxCellNeighbours,
-                                           gpu::Stream& stream);
+template void computeCellNeighboursHandler<7>(CellSeed** cellsLayersDevice,
+                                              int* neighboursLUT,
+                                              int** cellsLUTs,
+                                              gpuPair<int, int>* cellNeighbours,
+                                              int* neighboursIndexTable,
+                                              const Tracklet** tracklets,
+                                              const float maxChi2ClusterAttachment,
+                                              const float bz,
+                                              const int layerIndex,
+                                              const unsigned int nCells,
+                                              const unsigned int nCellsNext,
+                                              const int maxCellNeighbours,
+                                              gpu::Stream& stream);
 
 template void processNeighboursHandler<7>(const int startLayer,
                                           const int startLevel,
-                                          CellSeed<7>** allCellSeeds,
-                                          CellSeed<7>* currentCellSeeds,
+                                          CellSeed** allCellSeeds,
+                                          CellSeed* currentCellSeeds,
                                           std::array<int, 5>& nCells,
                                           const unsigned char** usedClusters,
                                           std::array<int*, 5>& neighbours,
                                           gsl::span<int*> neighboursDeviceLUTs,
                                           const TrackingFrameInfo** foundTrackingFrameInfo,
-                                          bounded_vector<CellSeed<7>>& seedsHost,
+                                          bounded_vector<TrackSeed<7>>& seedsHost,
                                           const float bz,
                                           const float maxChi2ClusterAttachment,
                                           const float maxChi2NDF,
+                                          const std::vector<float>& layerxX0Host,
                                           const o2::base::Propagator* propagator,
                                           const o2::base::PropagatorF::MatCorrType matCorrType,
                                           o2::its::ExternalAllocator* alloc);
 
-template void countTrackSeedHandler(CellSeed<7>* trackSeeds,
+template void countTrackSeedHandler(TrackSeed<7>* trackSeeds,
                                     const TrackingFrameInfo** foundTrackingFrameInfo,
                                     const Cluster** unsortedClusters,
                                     int* seedLUT,
                                     const std::vector<float>& layerRadiiHost,
                                     const std::vector<float>& minPtsHost,
+                                    const std::vector<float>& layerxX0Host,
                                     const unsigned int nSeeds,
                                     const float bz,
                                     const int startLevel,
@@ -1442,13 +1251,14 @@ template void countTrackSeedHandler(CellSeed<7>* trackSeeds,
                                     const o2::base::PropagatorF::MatCorrType matCorrType,
                                     o2::its::ExternalAllocator* alloc);
 
-template void computeTrackSeedHandler(CellSeed<7>* trackSeeds,
+template void computeTrackSeedHandler(TrackSeed<7>* trackSeeds,
                                       const TrackingFrameInfo** foundTrackingFrameInfo,
                                       const Cluster** unsortedClusters,
                                       o2::its::TrackITSExt* tracks,
                                       const int* seedLUT,
                                       const std::vector<float>& layerRadiiHost,
                                       const std::vector<float>& minPtsHost,
+                                      const std::vector<float>& layerxX0Host,
                                       const unsigned int nSeeds,
                                       const unsigned int nTracks,
                                       const float bz,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
index 91d5edeedcdb1..3a03e9d145907 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/BoundedAllocator.h
@@ -22,13 +22,18 @@
 #include <new>
 #include <vector>
 
-#include "ITStracking/ExternalAllocator.h"
-
+#if !defined(__HIPCC__) && !defined(__CUDACC__)
+#include <format>
+#include <string>
 #include "GPUCommonLogger.h"
+#endif
+#include "ITStracking/ExternalAllocator.h"
+#include "ITStracking/Constants.h"
 
 namespace o2::its
 {
 
+// #define BOUNDED_MR_STATS
 class BoundedMemoryResource final : public std::pmr::memory_resource
 {
  public:
@@ -36,49 +41,71 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   {
    public:
     MemoryLimitExceeded(size_t attempted, size_t used, size_t max)
-      : mAttempted(attempted), mUsed(used), mMax(max) {}
-    const char* what() const noexcept final
     {
-      static thread_local char msg[256];
-      if (mAttempted != 0) {
-        snprintf(msg, sizeof(msg),
-                 "Reached set memory limit (attempted: %zu, used: %zu, max: %zu)",
-                 mAttempted, mUsed, mMax);
+      char buf[256];
+      if (attempted != 0) {
+        (void)snprintf(buf, sizeof(buf), "Reached set memory limit (attempted: %zu, used: %zu, max: %zu)", attempted, used, max);
       } else {
-        snprintf(msg, sizeof(msg),
-                 "New set maximum below current used (newMax: %zu, used: %zu)",
-                 mMax, mUsed);
+        (void)snprintf(buf, sizeof(buf), "New set maximum below current used (newMax: %zu, used: %zu)", max, used);
       }
-      return msg;
+      mMsg = buf;
     }
+    const char* what() const noexcept final { return mMsg.c_str(); }
 
    private:
-    size_t mAttempted{0}, mUsed{0}, mMax{0};
+    std::string mMsg;
   };
 
-  BoundedMemoryResource(size_t maxBytes = std::numeric_limits<size_t>::max(), std::pmr::memory_resource* upstream = std::pmr::get_default_resource())
+  BoundedMemoryResource(size_t maxBytes = std::numeric_limits<size_t>::max(),
+                        std::pmr::memory_resource* upstream = std::pmr::get_default_resource())
     : mMaxMemory(maxBytes), mUpstream(upstream) {}
-  BoundedMemoryResource(ExternalAllocator* alloc) : mAdaptor(std::make_unique<ExternalAllocatorAdaptor>(alloc)), mUpstream(mAdaptor.get()) {}
+
+  BoundedMemoryResource(ExternalAllocator* alloc,
+                        size_t maxBytes = std::numeric_limits<size_t>::max())
+    : mMaxMemory(maxBytes),
+      mAdaptor(std::make_unique<ExternalAllocatorAdaptor>(alloc)),
+      mUpstream(mAdaptor.get()) {}
 
   void* do_allocate(size_t bytes, size_t alignment) final
   {
-    size_t new_used{0}, current_used{mUsedMemory.load(std::memory_order_relaxed)};
+    size_t new_used{0};
+    size_t current_used{mUsedMemory.load(std::memory_order_relaxed)};
     do {
       new_used = current_used + bytes;
-      if (new_used > mMaxMemory) {
-        ++mCountThrow;
-        throw MemoryLimitExceeded(new_used, current_used, mMaxMemory);
+      if (new_used > mMaxMemory.load(std::memory_order_relaxed)) {
+        mCountThrow.fetch_add(1, std::memory_order_relaxed);
+        throw MemoryLimitExceeded(new_used, current_used,
+                                  mMaxMemory.load(std::memory_order_relaxed));
       }
     } while (!mUsedMemory.compare_exchange_weak(current_used, new_used,
                                                 std::memory_order_acq_rel,
                                                 std::memory_order_relaxed));
+
     void* p{nullptr};
     try {
       p = mUpstream->allocate(bytes, alignment);
     } catch (...) {
       mUsedMemory.fetch_sub(bytes, std::memory_order_relaxed);
+#ifdef BOUNDED_MR_STATS
+      mStats.upstreamFailures.fetch_add(1, std::memory_order_relaxed);
+#endif
       throw;
     }
+
+#ifdef BOUNDED_MR_STATS
+    size_t peak = mStats.peak.load(std::memory_order_relaxed);
+    while (new_used > peak &&
+           !mStats.peak.compare_exchange_weak(peak, new_used,
+                                              std::memory_order_relaxed)) {
+    }
+    mStats.live.fetch_add(1, std::memory_order_relaxed);
+    mStats.nAlloc.fetch_add(1, std::memory_order_relaxed);
+    mStats.totalAlloc.fetch_add(bytes, std::memory_order_relaxed);
+
+    size_t ma = mStats.maxAlign.load(std::memory_order_relaxed);
+    while (alignment > ma && !mStats.maxAlign.compare_exchange_weak(ma, alignment, std::memory_order_relaxed)) {
+    }
+#endif
     return p;
   }
 
@@ -86,6 +113,11 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
   {
     mUpstream->deallocate(p, bytes, alignment);
     mUsedMemory.fetch_sub(bytes, std::memory_order_relaxed);
+#ifdef BOUNDED_MR_STATS
+    mStats.live.fetch_sub(1, std::memory_order_relaxed);
+    mStats.nFree.fetch_add(1, std::memory_order_relaxed);
+    mStats.totalFreed.fetch_add(bytes, std::memory_order_relaxed);
+#endif
   }
 
   bool do_is_equal(const std::pmr::memory_resource& other) const noexcept final
@@ -93,38 +125,94 @@ class BoundedMemoryResource final : public std::pmr::memory_resource
     return this == &other;
   }
 
-  size_t getUsedMemory() const noexcept { return mUsedMemory.load(); }
-  size_t getMaxMemory() const noexcept { return mMaxMemory; }
+  [[nodiscard]] size_t getUsedMemory() const noexcept
+  {
+    return mUsedMemory.load(std::memory_order_relaxed);
+  }
+  [[nodiscard]] size_t getMaxMemory() const noexcept
+  {
+    return mMaxMemory.load(std::memory_order_relaxed);
+  }
+  [[nodiscard]] size_t getThrowCount() const noexcept
+  {
+    return mCountThrow.load(std::memory_order_relaxed);
+  }
+
   void setMaxMemory(size_t max)
   {
-    if (max == mMaxMemory) {
+    size_t current = mMaxMemory.load(std::memory_order_relaxed);
+    if (max == current) {
       return;
     }
-    size_t used = mUsedMemory.load(std::memory_order_acquire);
-    if (used > max) {
-      ++mCountThrow;
-      throw MemoryLimitExceeded(0, used, max);
+    for (;;) {
+      size_t used = mUsedMemory.load(std::memory_order_acquire);
+      if (used > max) {
+        mCountThrow.fetch_add(1, std::memory_order_relaxed);
+        throw MemoryLimitExceeded(0, used, max);
+      }
+      if (mMaxMemory.compare_exchange_weak(current, max,
+                                           std::memory_order_release,
+                                           std::memory_order_relaxed)) {
+        return;
+      }
+      if (current == max) {
+        return;
+      }
     }
-    mMaxMemory.store(max, std::memory_order_release);
   }
 
-  void print() const
+#if !defined(__HIPCC__) && !defined(__CUDACC__)
+  std::string asString() const
   {
-#if !defined(GPUCA_GPUCODE_DEVICE)
-    constexpr double GB{1024 * 1024 * 1024};
-    auto throw_ = mCountThrow.load(std::memory_order_relaxed);
-    auto used = static_cast<double>(mUsedMemory.load(std::memory_order_relaxed));
-    LOGP(info, "maxthrow={} maxmem={:.2f} GB used={:.2f} ({:.2f}%)",
-         throw_, (double)mMaxMemory / GB, used / GB, 100. * used / (double)mMaxMemory);
+    const auto throw_ = mCountThrow.load(std::memory_order_relaxed);
+    const auto used = static_cast<double>(mUsedMemory.load(std::memory_order_relaxed));
+    const auto maxm = mMaxMemory.load(std::memory_order_relaxed);
+    std::string ret;
+    if (maxm == std::numeric_limits<size_t>::max()) {
+      ret += std::format("maxthrow={} maxmem=unbounded used={:.2f} GB", throw_, used / constants::GB);
+    } else {
+      ret += std::format("maxthrow={} maxmem={:.2f} GB used={:.2f} GB ({:.2f}%)", throw_, (double)maxm / constants::GB, used / constants::GB, 100.0 * used / (double)maxm);
+    }
+#ifdef BOUNDED_MR_STATS
+    ret += std::format("  peak={:.2f} GB live={} nAlloc={} nFree={} totalAlloc={:.2f} GB totalFreed={:.2f} GB maxAlign={} upstreamFail={}",
+                       (float)mStats.peak.load(std::memory_order_relaxed) / constants::GB,
+                       mStats.live.load(std::memory_order_relaxed),
+                       mStats.nAlloc.load(std::memory_order_relaxed),
+                       mStats.nFree.load(std::memory_order_relaxed),
+                       (float)mStats.totalAlloc.load(std::memory_order_relaxed) / constants::GB,
+                       (float)mStats.totalFreed.load(std::memory_order_relaxed) / constants::GB,
+                       mStats.maxAlign.load(std::memory_order_relaxed),
+                       mStats.upstreamFailures.load(std::memory_order_relaxed));
 #endif
+    return ret;
   }
 
+  void print() const
+  {
+    LOGP(info, "{}", asString());
+  }
+#endif
+
  private:
   std::atomic<size_t> mMaxMemory{std::numeric_limits<size_t>::max()};
   std::atomic<size_t> mCountThrow{0};
   std::atomic<size_t> mUsedMemory{0};
   std::unique_ptr<ExternalAllocatorAdaptor> mAdaptor{nullptr};
   std::pmr::memory_resource* mUpstream{nullptr};
+
+#ifdef BOUNDED_MR_STATS
+  struct Stats {
+    std::atomic<size_t> peak{0};
+    std::atomic<size_t> live{0};
+    std::atomic<size_t> nAlloc{0};
+    std::atomic<size_t> nFree{0};
+    std::atomic<size_t> totalAlloc{0};
+    std::atomic<size_t> totalFreed{0};
+    std::atomic<size_t> maxAlign{0};
+    std::atomic<size_t> upstreamFailures{0};
+  };
+  Stats mStats{};
+#endif
 };
 
 template <typename T>
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index d223adcef6214..dce66bdf99415 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -24,30 +24,11 @@
 namespace o2::its
 {
 
-template <int NLayers>
-class CellSeed final : public o2::track::TrackParCovF
+template <int NClusters>
+class SeedBase : public o2::track::TrackParCovF
 {
  public:
-  GPUhdDefault() CellSeed() = default;
-  GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, o2::track::TrackParCovF& tpc, float chi2, const TimeEstBC& time) : o2::track::TrackParCovF(tpc), mChi2(chi2), mLevel(1), mTime(time)
-  {
-    mClusters.fill(constants::UnusedIndex);
-    setUserField(innerL);
-    mClusters[innerL + 0] = cl0;
-    mClusters[innerL + 1] = cl1;
-    mClusters[innerL + 2] = cl2;
-    mTracklets[0] = trkl0;
-    mTracklets[1] = trkl1;
-  }
-  GPUhdDefault() CellSeed(const CellSeed&) = default;
-  GPUhdDefault() ~CellSeed() = default;
-  // GPUhdDefault() CellSeed(CellSeed&&) = default; TODO cannot use this yet since TrackPar only has device
-  GPUhdDefault() CellSeed& operator=(const CellSeed&) = default;
-  GPUhdDefault() CellSeed& operator=(CellSeed&&) = default;
-
-  GPUhd() int getFirstClusterIndex() const { return mClusters[getUserField()]; };
-  GPUhd() int getSecondClusterIndex() const { return mClusters[getUserField() + 1]; };
-  GPUhd() int getThirdClusterIndex() const { return mClusters[getUserField() + 2]; };
+  GPUhd() int getInnerLayer() const { return getUserField(); }
   GPUhd() int getFirstTrackletIndex() const { return mTracklets[0]; };
   GPUhd() void setFirstTrackletIndex(int trkl) { mTracklets[0] = trkl; };
   GPUhd() int getSecondTrackletIndex() const { return mTracklets[1]; };
@@ -57,31 +38,108 @@ class CellSeed final : public o2::track::TrackParCovF
   GPUhd() int getLevel() const { return mLevel; };
   GPUhd() void setLevel(int level) { mLevel = level; };
   GPUhd() int* getLevelPtr() { return &mLevel; }
-  GPUhd() auto& getClusters() { return mClusters; }
-  GPUhd() int getCluster(int i) const { return mClusters[i]; }
-  GPUhd() void printCell() const
-  {
-    printf("cell: %d, %d\t lvl: %d\t chi2: %f\tcls: [", mTracklets[0], mTracklets[1], mLevel, mChi2);
-    for (int i = 0; i < NLayers; ++i) {
-      printf("%d", mClusters[i]);
-      if (i < NLayers - 1) {
-        printf(" | ");
-      }
-    }
-    printf("]");
-    printf(" ts: %u +/- %u\n", mTime.getTimeStamp(), mTime.getTimeStampError());
-  }
   GPUhd() auto& getTimeStamp() noexcept { return mTime; }
   GPUhd() const auto& getTimeStamp() const noexcept { return mTime; }
 
+ protected:
+  GPUhdDefault() SeedBase() = default;
+  GPUhdDefault() SeedBase(const SeedBase&) = default;
+  GPUhdDefault() ~SeedBase() = default;
+  GPUhdDefault() SeedBase(SeedBase&&) = default;
+  GPUhdDefault() SeedBase& operator=(const SeedBase&) = default;
+  GPUhdDefault() SeedBase& operator=(SeedBase&&) = default;
+  GPUhd() SeedBase(const o2::track::TrackParCovF& tpc, float chi2, int level, const TimeEstBC& time)
+    : o2::track::TrackParCovF(tpc), mChi2(chi2), mLevel(level), mTime(time)
+  {
+  }
+  GPUhd() auto& clustersRaw() { return mClusters; }
+  GPUhd() const auto& clustersRaw() const { return mClusters; }
+
  private:
   float mChi2 = -999.f;
   int mLevel = constants::UnusedIndex;
   std::array<int, 2> mTracklets = constants::helpers::initArray<int, 2, constants::UnusedIndex>();
-  std::array<int, NLayers> mClusters = constants::helpers::initArray<int, NLayers, constants::UnusedIndex>();
+  std::array<int, NClusters> mClusters = constants::helpers::initArray<int, NClusters, constants::UnusedIndex>();
   TimeEstBC mTime;
 };
 
+/// CellSeed: connections of three clusters
+class CellSeed final : public SeedBase<3>
+{
+  static constexpr int NStoredClusters = 3;
+  using Base = SeedBase<NStoredClusters>;
+
+ public:
+  GPUhdDefault() CellSeed() = default;
+  GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, const o2::track::TrackParCovF& tpc, float chi2, const TimeEstBC& time)
+    : Base(tpc, chi2, 1, time)
+  {
+    setUserField(innerL);
+    auto& clusters = this->clustersRaw();
+    clusters[0] = cl0;
+    clusters[1] = cl1;
+    clusters[2] = cl2;
+    setFirstTrackletIndex(trkl0);
+    setSecondTrackletIndex(trkl1);
+  }
+  GPUhdDefault() CellSeed(const CellSeed&) = default;
+  GPUhdDefault() ~CellSeed() = default;
+  GPUhdDefault() CellSeed(CellSeed&&) = default;
+  GPUhdDefault() CellSeed& operator=(const CellSeed&) = default;
+  GPUhdDefault() CellSeed& operator=(CellSeed&&) = default;
+
+  GPUhd() int getFirstClusterIndex() const { return this->clustersRaw()[0]; };
+  GPUhd() int getSecondClusterIndex() const { return this->clustersRaw()[1]; };
+  GPUhd() int getThirdClusterIndex() const { return this->clustersRaw()[2]; };
+  GPUhd() auto& getClusters() { return this->clustersRaw(); }
+  GPUhd() const auto& getClusters() const { return this->clustersRaw(); }
+  /// getCluster takes an ABSOLUTE layer index and returns UnusedIndex if the
+  /// layer is outside the 3 stored slots (innerL, innerL+1, innerL+2).
+  GPUhd() int getCluster(int layer) const
+  {
+    const int rel = layer - getInnerLayer();
+    return (rel >= 0 && rel < NStoredClusters) ? this->clustersRaw()[rel] : constants::UnusedIndex;
+  }
+};
+
+/// TrackSeed: full-width working representation used during road finding.
+/// processNeighbours extends the cluster list inward, so we need NLayers
+/// absolute-indexed slots here.
+template <int NLayers>
+class TrackSeed final : public SeedBase<NLayers>
+{
+  using Base = SeedBase<NLayers>;
+
+ public:
+  GPUhdDefault() TrackSeed() = default;
+  GPUhd() TrackSeed(const CellSeed& cs)
+    : Base(static_cast<const o2::track::TrackParCovF&>(cs), cs.getChi2(), cs.getLevel(), cs.getTimeStamp())
+  {
+    this->setUserField(cs.getInnerLayer());
+    this->setFirstTrackletIndex(cs.getFirstTrackletIndex());
+    this->setSecondTrackletIndex(cs.getSecondTrackletIndex());
+    const int innerL = cs.getInnerLayer();
+    auto& clusters = this->clustersRaw();
+    clusters[innerL + 0] = cs.getFirstClusterIndex();
+    clusters[innerL + 1] = cs.getSecondClusterIndex();
+    clusters[innerL + 2] = cs.getThirdClusterIndex();
+  }
+  GPUhdDefault() TrackSeed(const TrackSeed&) = default;
+  GPUhdDefault() ~TrackSeed() = default;
+  GPUhdDefault() TrackSeed(TrackSeed&&) = default;
+  GPUhdDefault() TrackSeed& operator=(const TrackSeed&) = default;
+  GPUhdDefault() TrackSeed& operator=(TrackSeed&&) = default;
+
+  /// Three-cluster view of the original cell — note: innerL (UserField) is not
+  /// updated when processNeighbours extends the cluster list leftward.
+  GPUhd() int getFirstClusterIndex() const { return this->clustersRaw()[this->getUserField()]; }
+  GPUhd() int getSecondClusterIndex() const { return this->clustersRaw()[this->getUserField() + 1]; }
+  GPUhd() int getThirdClusterIndex() const { return this->clustersRaw()[this->getUserField() + 2]; }
+  GPUhd() auto& getClusters() { return this->clustersRaw(); }
+  GPUhd() const auto& getClusters() const { return this->clustersRaw(); }
+  GPUhd() int getCluster(int layer) const { return this->clustersRaw()[layer]; }
+};
+
 } // namespace o2::its
 
 #endif /* TRACKINGITSU_INCLUDE_CACELL_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index f8009e3ce8008..d48e8fb7c5856 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -30,14 +30,12 @@ constexpr float MB = KB * KB;
 constexpr float GB = MB * KB;
 constexpr bool DoTimeBenchmarks = true;
 constexpr bool SaveTimeBenchmarks = false;
-
-GPUconstexpr() float Tolerance = 1e-12; // numerical tolerance
-GPUconstexpr() int ClustersPerCell = 3;
-GPUconstexpr() int UnusedIndex = -1;
-GPUconstexpr() float Resolution = 0.0005f;
-GPUconstexpr() float Radl = 9.36f; // Radiation length of Si [cm]
-GPUconstexpr() float Rho = 2.33f;  // Density of Si [g/cm^3]
-GPUconstexpr() int MaxIter = 4;    // Max. supported iterations
+constexpr float Tolerance = 1e-12; // numerical tolerance
+constexpr int ClustersPerCell = 3;
+constexpr int UnusedIndex = -1;
+constexpr float Radl = 9.36f; // Radiation length of Si [cm]
+constexpr float Rho = 2.33f;  // Density of Si [g/cm^3]
+constexpr int MaxIter = 4;    // Max. supported iterations
 
 namespace helpers
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
index 118557c970c35..e2487208e9453 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
@@ -18,9 +18,8 @@
 
 #include <array>
 
-#include "ITStracking/Constants.h"
-#include "ITStracking/Configuration.h"
-#include "ITStracking/Definitions.h"
+#include "ITStracking/Cluster.h"
+#include "ITStracking/MathUtils.h"
 #include "CommonConstants/MathConstants.h"
 #include "GPUCommonMath.h"
 #include "GPUCommonDef.h"
@@ -91,7 +90,7 @@ GPUhdi() int IndexTableUtils<nLayers>::getPhiBinIndex(const float currentPhi) co
 template <int nLayers>
 GPUhdi() int IndexTableUtils<nLayers>::getBinIndex(const int zIndex, const int phiIndex) const
 {
-  return o2::gpu::GPUCommonMath::Min(phiIndex * mNzBins + zIndex, mNzBins * mNphiBins - 1);
+  return o2::gpu::GPUCommonMath::Min(phiIndex * mNzBins + zIndex, (mNzBins * mNphiBins) - 1);
 }
 
 template <int nLayers>
@@ -113,5 +112,26 @@ GPUhdi() void IndexTableUtils<nLayers>::print() const
   }
 }
 
+template <int nLayers>
+GPUhdi() int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
+                          const float z1, const float z2, const float maxdeltaz, const float maxdeltaphi,
+                          const IndexTableUtils<nLayers>& utils)
+{
+  const float zRangeMin = o2::gpu::GPUCommonMath::Min(z1, z2) - maxdeltaz;
+  const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : currentCluster.phi - maxdeltaphi;
+  const float zRangeMax = o2::gpu::GPUCommonMath::Max(z1, z2) + maxdeltaz;
+  const float phiRangeMax = (maxdeltaphi > o2::constants::math::PI) ? o2::constants::math::TwoPI : currentCluster.phi + maxdeltaphi;
+
+  if (zRangeMax < -utils.getLayerZ(layerIndex) ||
+      zRangeMin > utils.getLayerZ(layerIndex) || zRangeMin > zRangeMax) {
+    return int4{0, 0, 0, 0};
+  }
+
+  return int4{o2::gpu::GPUCommonMath::Max(0, utils.getZBinIndex(layerIndex, zRangeMin)),
+              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
+              o2::gpu::GPUCommonMath::Min(utils.getNzBins() - 1, utils.getZBinIndex(layerIndex, zRangeMax)),
+              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
+}
+
 } // namespace o2::its
 #endif /* TRACKINGITSU_INCLUDE_INDEXTABLEUTILS_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 3dd1b05cf8969..f2506694755c5 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -68,7 +68,7 @@ struct TimeFrame {
   using ROFOverlapTableN = ROFOverlapTable<NLayers>;
   using ROFVertexLookupTableN = ROFVertexLookupTable<NLayers>;
   using ROFMaskTableN = ROFMaskTable<NLayers>;
-  using CellSeedN = CellSeed<NLayers>;
+  using TrackSeedN = TrackSeed<NLayers>;
   friend class gpu::TimeFrameGPU<NLayers>;
 
   TimeFrame() = default;
@@ -271,7 +271,7 @@ struct TimeFrame {
 
   std::array<bounded_vector<Cluster>, NLayers> mUnsortedClusters;
   std::vector<bounded_vector<Tracklet>> mTracklets;
-  std::vector<bounded_vector<CellSeedN>> mCells;
+  std::vector<bounded_vector<CellSeed>> mCells;
   bounded_vector<TrackITSExt> mTracks;
   bounded_vector<MCCompLabel> mTracksLabel;
   std::vector<bounded_vector<int>> mCellsNeighbours;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
new file mode 100644
index 0000000000000..584d28a3cd9a8
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
@@ -0,0 +1,291 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file TrackHelpers.h
+/// \brief Shared host/device helpers for ITS tracker trait implementations
+///
+
+#ifndef O2_ITS_TRACKING_TRACKHELPERS_H_
+#define O2_ITS_TRACKING_TRACKHELPERS_H_
+
+#include <cmath>
+
+#include "DataFormatsITS/TrackITS.h"
+#include "ITStracking/Cell.h"
+#include "ITStracking/Cluster.h"
+#include "ITStracking/Constants.h"
+#include "ITStracking/MathUtils.h"
+#include "DetectorsBase/Propagator.h"
+#include "ReconstructionDataFormats/Track.h"
+
+namespace o2::its::track
+{
+
+GPUdi() int selectReseedMidLayer(int minLayer, int maxLayer, int nLayers, const float* layerRadii)
+{
+  if (maxLayer - minLayer == nLayers - 1) {
+    return (minLayer + maxLayer) / 2;
+  }
+  int midLayer = minLayer + 1;
+  const float midR = 0.5f * (layerRadii[maxLayer] + layerRadii[minLayer]);
+  float distanceToMidR = o2::gpu::CAMath::Abs(midR - layerRadii[midLayer]);
+  for (int iLayer = midLayer + 1; iLayer < maxLayer; ++iLayer) { // find the midpoint as closest to the midR
+    const float distance = o2::gpu::CAMath::Abs(midR - layerRadii[iLayer]);
+    if (distance < distanceToMidR) {
+      midLayer = iLayer;
+      distanceToMidR = distance;
+    }
+  }
+  return midLayer;
+}
+
+GPUdi() void resetTrackCovariance(TrackITSExt& track)
+{
+  track.resetCovariance();
+  track.setCov(track.getQ2Pt() * track.getQ2Pt() * track.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
+}
+
+GPUdi() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
+                                              const Cluster& cluster2,
+                                              const TrackingFrameInfo& tf3,
+                                              const float bz,
+                                              const bool reverse = false)
+{
+  float ca = NAN, sa = NAN, snp = NAN, q2pt = NAN, q2pt2 = NAN;
+  o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
+  const float sign = reverse ? -1.f : 1.f;
+  const float x1 = (cluster1.xCoordinate * ca) + (cluster1.yCoordinate * sa);
+  const float y1 = (-cluster1.xCoordinate * sa) + (cluster1.yCoordinate * ca);
+  const float x2 = (cluster2.xCoordinate * ca) + (cluster2.yCoordinate * sa);
+  const float y2 = (-cluster2.xCoordinate * sa) + (cluster2.yCoordinate * ca);
+  const float x3 = tf3.xTrackingFrame;
+  const float y3 = tf3.positionTrackingFrame[0];
+  if (o2::gpu::CAMath::Abs(bz) < 0.01f) { // zero field
+    const float dx = x3 - x1;
+    const float dy = y3 - y1;
+    snp = sign * dy / o2::gpu::CAMath::Hypot(dx, dy);
+    q2pt = 1.f / o2::track::kMostProbablePt;
+    q2pt2 = 1.f;
+  } else {
+    const float crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
+    snp = sign * crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
+    q2pt = sign * crv / (bz * o2::constants::math::B2C);
+    q2pt2 = crv * crv;
+  }
+  const float tgl = 0.5f * (math_utils::computeTanDipAngle(x1, y1, x2, y2, cluster1.zCoordinate, cluster2.zCoordinate) +
+                            math_utils::computeTanDipAngle(x2, y2, x3, y3, cluster2.zCoordinate, tf3.positionTrackingFrame[1]));
+  const float sg2q2pt = o2::track::kC1Pt2max * o2::gpu::CAMath::Clamp(q2pt2, 0.0005f, 1.0f);
+  return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, o2::track::kCSnp2max, 0.f, 0.f, 0.f, o2::track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
+}
+
+template <int NLayers>
+GPUdi() TrackITSExt seedTrackForRefit(const TrackSeed<NLayers>& seed,
+                                      const TrackingFrameInfo* const* foundTrackingFrameInfo,
+                                      const Cluster* const* unsortedClusters,
+                                      const float* layerRadii,
+                                      const float bz,
+                                      const int reseedIfShorter)
+{
+  TrackITSExt temporaryTrack(seed);
+  int lrMin = NLayers;
+  int lrMax = 0;
+  for (int iL{0}; iL < NLayers; ++iL) {
+    const int idx = seed.getCluster(iL);
+    temporaryTrack.setExternalClusterIndex(iL, idx, idx != constants::UnusedIndex);
+    if (idx != constants::UnusedIndex) {
+      lrMin = o2::gpu::CAMath::Min(lrMin, iL);
+      lrMax = o2::gpu::CAMath::Max(lrMax, iL);
+    }
+  }
+
+  const int ncl = temporaryTrack.getNClusters();
+  if (ncl < reseedIfShorter && ncl > 1) {
+    const int lrMid = selectReseedMidLayer(lrMin, lrMax, NLayers, layerRadii);
+    const auto& cluster0TF = foundTrackingFrameInfo[lrMin][seed.getCluster(lrMin)];
+    const auto& cluster1GL = unsortedClusters[lrMid][seed.getCluster(lrMid)];
+    const auto& cluster2GL = unsortedClusters[lrMax][seed.getCluster(lrMax)];
+    temporaryTrack.getParamIn() = buildTrackSeed(cluster2GL, cluster1GL, cluster0TF, bz, true);
+  }
+
+  resetTrackCovariance(temporaryTrack);
+  return temporaryTrack;
+}
+
+GPUdi() bool fitTrack(TrackITSExt& trk,
+                      int start,
+                      int end,
+                      int step,
+                      float chi2clcut,
+                      float chi2ndfcut,
+                      float maxQoverPt,
+                      int nCl,
+                      const float bz,
+                      const TrackingFrameInfo* const* tfInfos,
+                      const float* layerxX0,
+                      const o2::base::Propagator* propagator,
+                      const o2::base::PropagatorF::MatCorrType matCorrType,
+                      o2::track::TrackPar* linRef = nullptr,
+                      const bool shiftRefToCluster = false)
+{
+  for (int iLayer{start}; iLayer != end; iLayer += step) {
+    if (trk.getClusterIndex(iLayer) == constants::UnusedIndex) {
+      continue;
+    }
+
+    const TrackingFrameInfo& trackingHit = tfInfos[iLayer][trk.getClusterIndex(iLayer)];
+    if (linRef) {
+      if (!trk.o2::track::TrackParCovF::rotate(trackingHit.alphaTrackingFrame, *linRef, bz)) {
+        return false;
+      }
+      if (!propagator->propagateToX(trk, *linRef, trackingHit.xTrackingFrame, bz,
+                                    o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+                                    o2::base::PropagatorImpl<float>::MAX_STEP,
+                                    matCorrType)) {
+        return false;
+      }
+      if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+        if (!trk.correctForMaterial(*linRef, layerxX0[iLayer], layerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
+          continue;
+        }
+      }
+    } else {
+      if (!trk.o2::track::TrackParCovF::rotate(trackingHit.alphaTrackingFrame)) {
+        return false;
+      }
+      if (!propagator->propagateToX(trk, trackingHit.xTrackingFrame, bz,
+                                    o2::base::PropagatorImpl<float>::MAX_SIN_PHI,
+                                    o2::base::PropagatorImpl<float>::MAX_STEP,
+                                    matCorrType)) {
+        return false;
+      }
+      if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+        if (!trk.correctForMaterial(layerxX0[iLayer], layerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
+          continue;
+        }
+      }
+    }
+
+    const auto predChi2{trk.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
+    if ((nCl >= 3 && predChi2 > chi2clcut) || predChi2 < 0.f) {
+      return false;
+    }
+    trk.setChi2(trk.getChi2() + predChi2);
+    if (!trk.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
+      return false;
+    }
+    if (linRef && shiftRefToCluster) {
+      linRef->setY(trackingHit.positionTrackingFrame[0]);
+      linRef->setZ(trackingHit.positionTrackingFrame[1]);
+    }
+    nCl++;
+  }
+
+  return o2::gpu::CAMath::Abs(trk.getQ2Pt()) < maxQoverPt && trk.getChi2() < chi2ndfcut * (float)((nCl * 2) - 5);
+}
+
+template <int NLayers>
+GPUdi() bool refitTrack(const TrackSeed<NLayers>& trackSeed,
+                        TrackITSExt& temporaryTrack,
+                        float chi2clcut,
+                        float chi2ndfcut,
+                        const float bz,
+                        const TrackingFrameInfo* const* tfInfos,
+                        const Cluster* const* clusters,
+                        const float* layerxX0,
+                        const float* layerRadii,
+                        const float* minPt,
+                        const o2::base::Propagator* propagator,
+                        const o2::base::PropagatorF::MatCorrType matCorrType,
+                        const int reseedIfShorter,
+                        const bool shiftRefToCluster,
+                        const bool repeatRefitOut)
+{
+  temporaryTrack = seedTrackForRefit(trackSeed,
+                                     tfInfos,
+                                     clusters,
+                                     layerRadii,
+                                     bz,
+                                     reseedIfShorter);
+  o2::track::TrackPar linRef{temporaryTrack};
+  bool fitSuccess = fitTrack(temporaryTrack,
+                             0,
+                             NLayers,
+                             1,
+                             chi2clcut,
+                             chi2ndfcut,
+                             o2::constants::math::VeryBig,
+                             0,
+                             bz,
+                             tfInfos,
+                             layerxX0,
+                             propagator,
+                             matCorrType,
+                             &linRef,
+                             shiftRefToCluster);
+  if (!fitSuccess) {
+    return false;
+  }
+  temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+  linRef = temporaryTrack.getParamOut(); // use refitted track as lin.reference
+  resetTrackCovariance(temporaryTrack);
+  temporaryTrack.setChi2(0);
+  fitSuccess = fitTrack(temporaryTrack,
+                        NLayers - 1,
+                        -1,
+                        -1,
+                        chi2clcut,
+                        chi2ndfcut,
+                        50.f,
+                        0,
+                        bz,
+                        tfInfos,
+                        layerxX0,
+                        propagator,
+                        matCorrType,
+                        &linRef,
+                        shiftRefToCluster);
+  if (!fitSuccess || temporaryTrack.getPt() < minPt[NLayers - temporaryTrack.getNClusters()]) {
+    return false;
+  }
+  if (repeatRefitOut) { // repeat outward refit seeding and linearizing with the stable inward fit result
+    o2::track::TrackParCov saveInw{temporaryTrack};
+    linRef = saveInw; // use refitted track as lin.reference
+    float saveChi2 = temporaryTrack.getChi2();
+    track::resetTrackCovariance(temporaryTrack);
+    temporaryTrack.setChi2(0);
+    fitSuccess = o2::its::track::fitTrack(temporaryTrack,
+                                          0,
+                                          NLayers,
+                                          1,
+                                          chi2clcut,
+                                          chi2ndfcut,
+                                          o2::constants::math::VeryBig,
+                                          0,
+                                          bz,
+                                          tfInfos,
+                                          layerxX0,
+                                          propagator,
+                                          matCorrType,
+                                          &linRef,
+                                          shiftRefToCluster);
+    if (!fitSuccess) {
+      return false;
+    }
+    temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
+    temporaryTrack.getParamIn() = saveInw;
+    temporaryTrack.setChi2(saveChi2);
+  }
+  return true;
+}
+
+} // namespace o2::its::track
+
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index a1a0bf7249a21..ad8ea5b3b56af 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -18,7 +18,6 @@
 
 #include <array>
 #include <chrono>
-#include <cmath>
 #include <fstream>
 #include <iomanip>
 #include <iosfwd>
@@ -54,7 +53,7 @@ class Tracker
 
   void adoptTimeFrame(TimeFrame<NLayers>& tf);
 
-  void clustersToTracks(
+  float clustersToTracks(
     const LogFunc& = [](const std::string& s) { std::cout << s << '\n'; },
     const LogFunc& = [](const std::string& s) { std::cerr << s << '\n'; });
 
@@ -78,7 +77,7 @@ class Tracker
   void sortTracks();
 
   template <typename... T, typename... F>
-  float evaluateTask(void (Tracker::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args);
+  float evaluateTask(void (Tracker::*task)(T...), std::string_view taskName, int iteration, const LogFunc& logger, F&&... args);
 
   TrackerTraits<NLayers>* mTraits = nullptr; /// Observer pointer, not owned by this class
   TimeFrame<NLayers>* mTimeFrame = nullptr;  /// Observer pointer, not owned by this class
@@ -106,7 +105,7 @@ class Tracker
 
 template <int NLayers>
 template <typename... T, typename... F>
-float Tracker<NLayers>::evaluateTask(void (Tracker<NLayers>::*task)(T...), std::string_view taskName, int iteration, LogFunc logger, F&&... args)
+float Tracker<NLayers>::evaluateTask(void (Tracker<NLayers>::*task)(T...), std::string_view taskName, int iteration, const LogFunc& logger, F&&... args)
 {
   float diff{0.f};
 
@@ -140,6 +139,10 @@ float Tracker<NLayers>::evaluateTask(void (Tracker<NLayers>::*task)(T...), std::
     (this->*task)(std::forward<F>(args)...);
   }
 
+  if (mTrkParams[iteration].PrintMemory) {
+    LOGP(info, "iter:{}:{}: {}", iteration, StateNames[mCurState], mMemoryPool->asString());
+  }
+
   return diff;
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index fd3251a59d835..1c3c642429686 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -20,7 +20,6 @@
 
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Configuration.h"
-#include "ITStracking/MathUtils.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/Cell.h"
@@ -43,7 +42,7 @@ class TrackerTraits
 {
  public:
   using IndexTableUtilsN = IndexTableUtils<NLayers>;
-  using CellSeedN = CellSeed<NLayers>;
+  using TrackSeedN = TrackSeed<NLayers>;
 
   virtual ~TrackerTraits() = default;
   virtual void adoptTimeFrame(TimeFrame<NLayers>* tf) { mTimeFrame = tf; }
@@ -53,9 +52,17 @@ class TrackerTraits
   virtual void computeLayerCells(const int iteration);
   virtual void findCellsNeighbours(const int iteration);
   virtual void findRoads(const int iteration);
-  virtual void processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId);
 
-  void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars) { mTrkParams = trkPars; }
+  template <typename InputSeed>
+  void processNeighbours(int iteration, int iLayer, int iLevel, const bounded_vector<InputSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<TrackSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId);
+
+  void acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters, bounded_vector<bounded_vector<int>>& sharedFirstClusters);
+  void markTracks(int iteration, bounded_vector<bounded_vector<int>>& sharedFirstClusters);
+
+  void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars)
+  {
+    mTrkParams = trkPars;
+  }
   TimeFrame<NLayers>* getTimeFrame() { return mTimeFrame; }
 
   virtual void setBz(float bz);
@@ -66,12 +73,6 @@ class TrackerTraits
   auto getMemoryPool() const noexcept { return mMemoryPool; }
 
   // Others
-  GPUhd() static consteval int4 getEmptyBinsRect() { return int4{0, 0, 0, 0}; }
-  int4 getBinsRect(const int iteration, int layer, float phi, float maxdeltaphi, float z, float maxdeltaz)
-    const noexcept { return getBinsRect(iteration, layer, phi, maxdeltaphi, z, z, maxdeltaz); }
-  int4 getBinsRect(const int iteration, const Cluster& cls, int layer, float z1, float z2, float maxdeltaz, float maxdeltaphi) const noexcept { return getBinsRect(iteration, layer, cls.phi, maxdeltaphi, z1, z2, maxdeltaz); }
-  const int4 getBinsRect(const int iteration, int layer, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept;
-
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena);
   int getNThreads() { return mTaskArena->max_concurrency(); }
 
@@ -81,10 +82,6 @@ class TrackerTraits
   virtual int getTFNumberOfCells() const { return mTimeFrame->getNumberOfCells(); }
 
  private:
-  track::TrackParCov buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse = false);
-  TrackITSExt seedTrackForRefit(const CellSeedN& seed);
-  bool fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut = o2::constants::math::VeryBig, float chi2ndfcut = o2::constants::math::VeryBig, float maxQoverPt = o2::constants::math::VeryBig, int nCl = 0, o2::track::TrackPar* refLin = nullptr);
-
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
 
@@ -94,29 +91,8 @@ class TrackerTraits
   std::vector<TrackingParameters> mTrkParams;
 
   float mBz{-999.f};
-  bool mIsZeroField{false};
 };
 
-template <int NLayers>
-inline const int4 TrackerTraits<NLayers>::getBinsRect(const int iteration, const int layerIndex, float phi, float maxdeltaphi, float z1, float z2, float maxdeltaz) const noexcept
-{
-  const float zRangeMin = o2::gpu::GPUCommonMath::Min(z1, z2) - maxdeltaz;
-  const float phiRangeMin = (maxdeltaphi > o2::constants::math::PI) ? 0.f : phi - maxdeltaphi;
-  const float zRangeMax = o2::gpu::GPUCommonMath::Max(z1, z2) + maxdeltaz;
-  const float phiRangeMax = (maxdeltaphi > o2::constants::math::PI) ? o2::constants::math::TwoPI : phi + maxdeltaphi;
-
-  if (zRangeMax < -mTrkParams[iteration].LayerZ[layerIndex] ||
-      zRangeMin > mTrkParams[iteration].LayerZ[layerIndex] || zRangeMin > zRangeMax) {
-    return getEmptyBinsRect();
-  }
-
-  const IndexTableUtilsN& utils{mTimeFrame->getIndexTableUtils()};
-  return int4{o2::gpu::GPUCommonMath::Max(0, utils.getZBinIndex(layerIndex, zRangeMin)),
-              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
-              o2::gpu::GPUCommonMath::Min(mTrkParams[iteration].ZBins - 1, utils.getZBinIndex(layerIndex, zRangeMax)),
-              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
-}
-
 } // namespace its
 } // namespace o2
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index a045ba1639b13..f1cf081473264 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -152,6 +152,10 @@ float Vertexer<NLayers>::evaluateTask(void (Vertexer<NLayers>::*task)(T...), std
     (this->*task)(std::forward<T>(args)...);
   }
 
+  if (mVertParams[iteration].PrintMemory) {
+    LOGP(info, "iter:{}:{}: {}", iteration, StateNames[mCurState], mMemoryPool->asString());
+  }
+
   return diff;
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index 5b412ea4eea69..cafddfcc41a76 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -351,7 +351,7 @@ unsigned long TimeFrame<NLayers>::getArtefactsMemory() const
     size += sizeof(Tracklet) * trkl.size();
   }
   for (const auto& cells : mCells) {
-    size += sizeof(CellSeedN) * cells.size();
+    size += sizeof(CellSeed) * cells.size();
   }
   for (const auto& cellsN : mCellsNeighbours) {
     size += sizeof(int) * cellsN.size();
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index fa881789af296..3e91788c9881c 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -34,11 +34,11 @@ Tracker<NLayers>::Tracker(TrackerTraits<NLayers>* traits) : mTraits(traits)
 }
 
 template <int NLayers>
-void Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& error)
+float Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& error)
 {
   LogFunc evalLog = [](const std::string&) {};
 
-  double total{0};
+  float total{0};
   mTraits->updateTrackingParameters(mTrkParams);
 
   int maxNvertices{-1};
@@ -71,12 +71,13 @@ void Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
       if (iteration == 3 && mTrkParams[0].DoUPCIteration) {
         mTimeFrame->useUPCMask();
       }
-      float timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
+      float timeFrame{0.}, timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
       size_t nTracklets{0}, nCells{0}, nNeighbours{0};
       int nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
       iVertex = std::min(maxNvertices, 0);
       logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
-      total += evaluateTask(&Tracker::initialiseTimeFrame, StateNames[mCurState = TFInit], iteration, logger, iteration);
+      total += timeFrame = evaluateTask(&Tracker::initialiseTimeFrame, StateNames[mCurState = TFInit], iteration, evalLog, iteration);
+      logger(std::format(" - TimeFrame initialisation completed in {:.2f} ms", timeFrame));
       do {
         timeTracklets += evaluateTask(&Tracker::computeTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration, iVertex);
         nTracklets += mTraits->getTFNumberOfTracklets();
@@ -91,24 +92,18 @@ void Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
       logger(std::format(" - Neighbours finding: {} neighbours found in {:.2f} ms", nNeighbours, timeNeighbours));
       logger(std::format(" - Track finding: {} tracks found in {:.2f} ms", nTracks + mTimeFrame->getNumberOfTracks(), timeRoads));
       total += timeTracklets + timeCells + timeNeighbours + timeRoads;
-      if (mTrkParams[iteration].PrintMemory) {
-        mMemoryPool->print();
-      }
-    }
-    if constexpr (constants::DoTimeBenchmarks) {
-      logger(std::format("=== TimeSlice {} processing completed in: {:.2f} ms using {} thread(s) ===", mTimeSlice, total, mTraits->getNThreads()));
     }
   } catch (const BoundedMemoryResource::MemoryLimitExceeded& err) {
     handleException(err);
-    return;
+    return -1.f;
   } catch (const std::bad_alloc& err) {
     handleException(err);
-    return;
+    return -1.f;
   } catch (const std::exception& err) {
     error(std::format("Uncaught exception, all bets are off... {}", err.what()));
     // clear tracks explicitly since if not fatalising on exception this may contain partial output
     mTimeFrame->getTracks().clear();
-    return;
+    return -1.f;
   }
 
   if (mTimeFrame->hasMCinformation()) {
@@ -120,10 +115,7 @@ void Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& er
   ++mTimeFrameCounter;
   mTotalTime += total;
 
-  if (mTrkParams[0].PrintMemory) {
-    mTimeFrame->printArtefactsMemory();
-    mMemoryPool->print();
-  }
+  return total;
 }
 
 template <int NLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 3cf462206bf94..69ccd8228ad88 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -16,6 +16,7 @@
 #include <algorithm>
 #include <iterator>
 #include <ranges>
+#include <cmath>
 #include <type_traits>
 
 #include <oneapi/tbb/blocked_range.h>
@@ -30,11 +31,10 @@
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/ROFLookupTables.h"
 #include "ITStracking/TrackerTraits.h"
+#include "ITStracking/TrackHelpers.h"
 #include "ITStracking/Tracklet.h"
 #include "ReconstructionDataFormats/Track.h"
 
-using o2::base::PropagatorF;
-
 namespace o2::its
 {
 
@@ -111,7 +111,9 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
           const float sqInvDeltaZ0 = 1.f / (math_utils::Sq(currentCluster.zCoordinate - pv.getZ()) + constants::Tolerance);
           const float sigmaZ = o2::gpu::CAMath::Sqrt(
             math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInvDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)));
-          const auto bins = getBinsRect(iteration, currentCluster, iLayer + 1, zAtRmin, zAtRmax, sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer));
+          const auto bins = o2::its::getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax,
+                                                 sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer),
+                                                 mTimeFrame->getIndexTableUtils());
           if (bins.x == 0 && bins.y == 0 && bins.z == 0 && bins.w == 0) {
             continue;
           }
@@ -207,7 +209,7 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
     tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
       /// Sort tracklets
       auto& trkl{mTimeFrame->getTracklets()[iLayer]};
-      tbb::parallel_sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
+      std::sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
         if (a.firstClusterIndex != b.firstClusterIndex) {
           return a.firstClusterIndex < b.firstClusterIndex;
         }
@@ -269,7 +271,7 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
   }
 
   mTaskArena->execute([&] {
-    auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeedN>& layerCells, int iTracklet, int offset = 0) -> int {
+    auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeed>& layerCells, int iTracklet, int offset = 0) -> int {
       const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
       const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
       const int nextLayerFirstTrackletIndex{mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
@@ -295,7 +297,7 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
           const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer][clusId[0]];
           const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1][clusId[1]];
           const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2)[clusId[2]];
-          auto track{buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf)};
+          auto track{o2::its::track::buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf, mBz)};
 
           float chi2{0.f};
           bool good{false};
@@ -310,7 +312,7 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
               break;
             }
 
-            if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer + iC], mTrkParams[0].LayerxX0[iLayer + iC] * constants::Radl * constants::Rho, true)) {
+            if (!track.correctForMaterial(mTrkParams[iteration].LayerxX0[iLayer + iC], mTrkParams[iteration].LayerxX0[iLayer + iC] * constants::Radl * constants::Rho, true)) {
               break;
             }
 
@@ -330,13 +332,12 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
             TimeEstBC ts = currentTracklet.getTimeStamp();
             ts += nextTracklet.getTimeStamp();
             if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
-              //
               layerCells.emplace_back(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
               ++foundCells;
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
               ++foundCells;
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
-              layerCells[offset++] = CellSeedN(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
+              layerCells[offset++] = CellSeed(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
             } else {
               static_assert(false, "Unknown mode!");
             }
@@ -346,10 +347,14 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
       return foundCells;
     };
 
-    tbb::parallel_for(0, mTrkParams[iteration].CellsPerRoad(), [&](const int iLayer) {
+    for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
       if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
           mTimeFrame->getTracklets()[iLayer].empty()) {
-        return;
+        if (iLayer < mTrkParams[iteration].TrackletsPerRoad()) {
+          deepVectorClear(mTimeFrame->getTracklets()[iLayer]);
+          deepVectorClear(mTimeFrame->getTrackletsLabel(iLayer));
+        }
+        continue;
       }
 
       auto& layerCells = mTimeFrame->getCells()[iLayer];
@@ -368,7 +373,14 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
         std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
         auto totalCells{perTrackletCount.back()};
         if (totalCells == 0) {
-          return;
+          if (iLayer > 0) {
+            auto& lut = mTimeFrame->getCellsLookupTable()[iLayer - 1];
+            lut.resize(currentLayerTrackletsNum + 1);
+            std::fill(lut.begin(), lut.end(), 0);
+          }
+          deepVectorClear(mTimeFrame->getTracklets()[iLayer]);
+          deepVectorClear(mTimeFrame->getTrackletsLabel(iLayer));
+          continue;
         }
         layerCells.resize(totalCells);
 
@@ -386,20 +398,28 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
         lut.resize(currentLayerTrackletsNum + 1);
         std::copy_n(perTrackletCount.begin(), currentLayerTrackletsNum + 1, lut.begin());
       }
-    });
 
-    /// Create cells labels
-    if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
-      tbb::parallel_for(0, mTrkParams[iteration].CellsPerRoad(), [&](const int iLayer) {
-        mTimeFrame->getCellsLabel(iLayer).reserve(mTimeFrame->getCells()[iLayer].size());
-        for (const auto& cell : mTimeFrame->getCells()[iLayer]) {
+      if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
+        auto& labels = mTimeFrame->getCellsLabel(iLayer);
+        labels.reserve(layerCells.size());
+        for (const auto& cell : layerCells) {
           MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
           MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
-          mTimeFrame->getCellsLabel(iLayer).emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
+          labels.emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
         }
-      });
+      }
+
+      // Once layer i cells are built and labelled, the corresponding tracklet artefacts are no longer needed.
+      deepVectorClear(mTimeFrame->getTracklets()[iLayer]);
+      deepVectorClear(mTimeFrame->getTrackletsLabel(iLayer));
     }
   });
+
+  // Clear the trailing tracklet artefacts that are not consumed as the first leg of a cell.
+  for (int iLayer = mTrkParams[iteration].CellsPerRoad(); iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
+    deepVectorClear(mTimeFrame->getTracklets()[iLayer]);
+    deepVectorClear(mTimeFrame->getTrackletsLabel(iLayer));
+  }
 }
 
 template <int NLayers>
@@ -509,12 +529,16 @@ void TrackerTraits<NLayers>::findCellsNeighbours(const int iteration)
         }
         mTimeFrame->getCells()[iLayer + 1][cellIdx].setLevel(maxLvl);
       }
+
+      // clear cells LUT
+      deepVectorClear(mTimeFrame->getCellsLookupTable()[iLayer]);
     }
   });
 }
 
 template <int NLayers>
-void TrackerTraits<NLayers>::processNeighbours(int iLayer, int iLevel, const bounded_vector<CellSeedN>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<CellSeedN>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
+template <typename InputSeed>
+void TrackerTraits<NLayers>::processNeighbours(int iteration, int iLayer, int iLevel, const bounded_vector<InputSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<TrackSeedN>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
 {
   auto propagator = o2::base::Propagator::Instance();
 
@@ -554,7 +578,7 @@ void TrackerTraits<NLayers>::processNeighbours(int iLayer, int iLevel, const bou
         }
 
         /// Let's start the fitting procedure
-        CellSeedN seed{currentCell};
+        TrackSeedN seed{currentCell};
         seed.getTimeStamp() = currentCell.getTimeStamp();
         seed.getTimeStamp() += neighbourCell.getTimeStamp();
         const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
@@ -563,18 +587,18 @@ void TrackerTraits<NLayers>::processNeighbours(int iLayer, int iLevel, const bou
           continue;
         }
 
-        if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
+        if (!propagator->propagateToX(seed, trHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[iteration].CorrType)) {
           continue;
         }
 
-        if (mTrkParams[0].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-          if (!seed.correctForMaterial(mTrkParams[0].LayerxX0[iLayer - 1], mTrkParams[0].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
+        if (mTrkParams[iteration].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
+          if (!seed.correctForMaterial(mTrkParams[iteration].LayerxX0[iLayer - 1], mTrkParams[iteration].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
             continue;
           }
         }
 
         auto predChi2{seed.getPredictedChi2Quiet(trHit.positionTrackingFrame, trHit.covarianceTrackingFrame)};
-        if ((predChi2 > mTrkParams[0].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
+        if ((predChi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) || predChi2 < 0.f) {
           continue;
         }
         seed.setChi2(seed.getChi2() + predChi2);
@@ -641,22 +665,29 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
   bounded_vector<bounded_vector<int>> sharedFirstClusters(mTrkParams[iteration].NLayers, bounded_vector<int>(mMemoryPool.get()), mMemoryPool.get());
   firstClusters.resize(mTrkParams[iteration].NLayers);
   sharedFirstClusters.resize(mTrkParams[iteration].NLayers);
+  const auto propagator = o2::base::Propagator::Instance();
+  const TrackingFrameInfo* tfInfos[NLayers]{};
+  const Cluster* unsortedClusters[NLayers]{};
+  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
+    tfInfos[iLayer] = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer).data();
+    unsortedClusters[iLayer] = mTimeFrame->getUnsortedClusters()[iLayer].data();
+  }
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
 
     auto seedFilter = [&](const auto& seed) {
-      return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[0].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
+      return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[iteration].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
     };
 
-    bounded_vector<CellSeedN> trackSeeds(mMemoryPool.get());
+    bounded_vector<TrackSeedN> trackSeeds(mMemoryPool.get());
     for (int startLayer{mTrkParams[iteration].NeighboursPerRoad()}; startLayer >= startLevel - 1; --startLayer) {
       if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
         continue;
       }
 
       bounded_vector<int> lastCellId(mMemoryPool.get()), updatedCellId(mMemoryPool.get());
-      bounded_vector<CellSeedN> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
+      bounded_vector<TrackSeedN> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
 
-      processNeighbours(startLayer, startLevel, mTimeFrame->getCells()[startLayer], lastCellId, updatedCellSeed, updatedCellId);
+      processNeighbours(iteration, startLayer, startLevel, mTimeFrame->getCells()[startLayer], lastCellId, updatedCellSeed, updatedCellId);
 
       int level = startLevel;
       for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
@@ -664,7 +695,7 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
         lastCellId.swap(updatedCellId);
         deepVectorClear(updatedCellSeed); /// tame the memory peaks
         deepVectorClear(updatedCellId);   /// tame the memory peaks
-        processNeighbours(iLayer, --level, lastCellSeed, lastCellId, updatedCellSeed, updatedCellId);
+        processNeighbours(iteration, iLayer, --level, lastCellSeed, lastCellId, updatedCellSeed, updatedCellId);
       }
       deepVectorClear(lastCellId);   /// tame the memory peaks
       deepVectorClear(lastCellSeed); /// tame the memory peaks
@@ -682,47 +713,36 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
     bounded_vector<TrackITSExt> tracks(mMemoryPool.get());
     mTaskArena->execute([&] {
       auto forSeed = [&](auto Tag, int iSeed, int offset = 0) {
-        TrackITSExt temporaryTrack = seedTrackForRefit(trackSeeds[iSeed]);
-        o2::track::TrackPar linRef{temporaryTrack};
-        bool fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, o2::constants::math::VeryBig, 0, &linRef);
-        if (!fitSuccess) {
-          return 0;
-        }
-        temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
-        linRef = temporaryTrack.getParamOut(); // use refitted track as lin.reference
-        temporaryTrack.resetCovariance();
-        temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
-        temporaryTrack.setChi2(0);
-        fitSuccess = fitTrack(temporaryTrack, mTrkParams[0].NLayers - 1, -1, -1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, 50.f, 0, &linRef);
-        if (!fitSuccess || temporaryTrack.getPt() < mTrkParams[iteration].MinPt[mTrkParams[iteration].NLayers - temporaryTrack.getNClusters()]) {
-          return 0;
-        }
-        if (mTrkParams[0].RepeatRefitOut) { // repeat outward refit seeding and linearizing with the stable inward fit result
-          o2::track::TrackParCov saveInw{temporaryTrack};
-          linRef = saveInw; // use refitted track as lin.reference
-          float saveChi2 = temporaryTrack.getChi2();
-          temporaryTrack.resetCovariance();
-          temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
-          temporaryTrack.setChi2(0);
-          fitSuccess = fitTrack(temporaryTrack, 0, mTrkParams[0].NLayers, 1, mTrkParams[0].MaxChi2ClusterAttachment, mTrkParams[0].MaxChi2NDF, o2::constants::math::VeryBig, 0, &linRef);
-          if (!fitSuccess) {
-            return 0;
+        TrackITSExt temporaryTrack;
+        bool refitSuccess = track::refitTrack<NLayers>(trackSeeds[iSeed],
+                                                       temporaryTrack,
+                                                       mTrkParams[iteration].MaxChi2ClusterAttachment,
+                                                       mTrkParams[iteration].MaxChi2NDF,
+                                                       mBz,
+                                                       tfInfos,
+                                                       unsortedClusters,
+                                                       mTrkParams[iteration].LayerxX0.data(),
+                                                       mTrkParams[iteration].LayerRadii.data(),
+                                                       mTrkParams[iteration].MinPt.data(),
+                                                       propagator,
+                                                       mTrkParams[iteration].CorrType,
+                                                       mTrkParams[iteration].ReseedIfShorter,
+                                                       mTrkParams[iteration].ShiftRefToCluster,
+                                                       mTrkParams[iteration].RepeatRefitOut);
+
+        if (refitSuccess) {
+          if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
+            tracks.push_back(temporaryTrack);
+          } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
+            // nothing to do
+          } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
+            tracks[offset] = temporaryTrack;
+          } else {
+            static_assert(false, "Unknown mode!");
           }
-          temporaryTrack.getParamOut() = temporaryTrack.getParamIn();
-          temporaryTrack.getParamIn() = saveInw;
-          temporaryTrack.setChi2(saveChi2);
-        }
-
-        if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
-          tracks.push_back(temporaryTrack);
-        } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
-          // nothing to do
-        } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
-          tracks[offset] = temporaryTrack;
-        } else {
-          static_assert(false, "Unknown mode!");
+          return 1;
         }
-        return 1;
+        return 0;
       };
 
       const int nSeeds = static_cast<int>(trackSeeds.size());
@@ -731,6 +751,7 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
           forSeed(PassMode::OnePass{}, iSeed);
         }
       } else {
+        // The double-pass allows us to avoid sizeable memory spikes
         bounded_vector<int> perSeedCount(nSeeds + 1, 0, mMemoryPool.get());
         tbb::parallel_for(0, nSeeds, [&](const int iSeed) {
           perSeedCount[iSeed] = forSeed(PassMode::TwoPassCount{}, iSeed);
@@ -752,226 +773,110 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
       }
 
       deepVectorClear(trackSeeds);
-      tbb::parallel_sort(tracks.begin(), tracks.end(), [](const auto& a, const auto& b) {
-        return a.getChi2() < b.getChi2();
-      });
     });
 
-    const float smallestROFHalf = mTimeFrame->getROFOverlapTableView().getClockLayer().mROFLength * 0.5f;
-    for (auto& track : tracks) {
-      int nShared = 0;
-      bool isFirstShared{false};
-      int firstLayer{-1}, firstCluster{-1};
-      for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
-          continue;
-        }
-        bool isShared = mTimeFrame->isClusterUsed(iLayer, track.getClusterIndex(iLayer));
-        nShared += int(isShared);
-        if (firstLayer < 0) {
-          firstCluster = track.getClusterIndex(iLayer);
-          isFirstShared = isShared && mTrkParams[0].AllowSharingFirstCluster && std::find(firstClusters[iLayer].begin(), firstClusters[iLayer].end(), firstCluster) != firstClusters[iLayer].end();
-          firstLayer = iLayer;
-        }
-      }
-
-      /// do not account for the first cluster in the shared clusters number if it is allowed
-      if (nShared - int(isFirstShared && mTrkParams[0].AllowSharingFirstCluster) > mTrkParams[0].ClusterSharing) {
-        continue;
-      }
-
-      bool firstCls{true};
-      TimeEstBC ts;
-      for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
-          continue;
-        }
-        mTimeFrame->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
-        int currentROF = mTimeFrame->getClusterROF(iLayer, track.getClusterIndex(iLayer));
-        auto rofTS = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).getROFTimeBounds(currentROF, true);
-        if (firstCls) {
-          firstCls = false;
-          ts = rofTS;
-        } else {
-          if (!ts.isCompatible(rofTS)) {
-            LOGP(fatal, "TS {}+/-{} are incompatible with {}+/-{}, this should not happen!", rofTS.getTimeStamp(), rofTS.getTimeStampError(), ts.getTimeStamp(), ts.getTimeStampError());
-          }
-          ts += rofTS;
-        }
-      }
-      track.getTimeStamp() = ts.makeSymmetrical();
-      if (track.getTimeStamp().getTimeStampError() > smallestROFHalf) {
-        track.getTimeStamp().setTimeStampError(smallestROFHalf);
-      }
-
-      track.setUserField(0);
-      track.getParamOut().setUserField(0);
-      mTimeFrame->getTracks().emplace_back(track);
-
-      firstClusters[firstLayer].push_back(firstCluster);
-      if (isFirstShared) {
-        sharedFirstClusters[firstLayer].push_back(firstCluster);
-      }
-    }
-  }
+    std::sort(tracks.begin(), tracks.end(), [](const auto& a, const auto& b) {
+      return a.getChi2() < b.getChi2();
+    });
 
-  /// Now we have to set the shared cluster flag
-  for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
-    std::sort(sharedFirstClusters[iLayer].begin(), sharedFirstClusters[iLayer].end());
+    acceptTracks(iteration, tracks, firstClusters, sharedFirstClusters);
   }
+  markTracks(iteration, sharedFirstClusters);
+}
 
-  for (auto& track : mTimeFrame->getTracks()) {
-    int firstLayer{mTrkParams[0].NLayers}, firstCluster{constants::UnusedIndex};
-    for (int iLayer{0}; iLayer < mTrkParams[0].NLayers; ++iLayer) {
+template <int NLayers>
+void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters, bounded_vector<bounded_vector<int>>& sharedFirstClusters)
+{
+  const float smallestROFHalf = mTimeFrame->getROFOverlapTableView().getClockLayer().mROFLength * 0.5f;
+  for (auto& track : tracks) {
+    int nShared = 0;
+    bool isFirstShared{false};
+    int firstLayer{-1}, firstCluster{-1};
+    for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
       if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
         continue;
       }
-      firstLayer = iLayer;
-      firstCluster = track.getClusterIndex(iLayer);
-      break;
-    }
-    if (std::binary_search(sharedFirstClusters[firstLayer].begin(), sharedFirstClusters[firstLayer].end(), firstCluster)) {
-      track.setSharedClusters();
+      bool isShared = mTimeFrame->isClusterUsed(iLayer, track.getClusterIndex(iLayer));
+      nShared += int(isShared);
+      if (firstLayer < 0) {
+        firstCluster = track.getClusterIndex(iLayer);
+        isFirstShared = isShared && mTrkParams[iteration].AllowSharingFirstCluster && std::find(firstClusters[iLayer].begin(), firstClusters[iLayer].end(), firstCluster) != firstClusters[iLayer].end();
+        firstLayer = iLayer;
+      }
     }
-  }
-}
 
-template <int NLayers>
-bool TrackerTraits<NLayers>::fitTrack(TrackITSExt& track, int start, int end, int step, float chi2clcut, float chi2ndfcut, float maxQoverPt, int nCl, o2::track::TrackPar* linRef)
-{
-  auto propInstance = o2::base::Propagator::Instance();
-
-  for (int iLayer{start}; iLayer != end; iLayer += step) {
-    if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
+    /// do not account for the first cluster in the shared clusters number if it is allowed
+    if (nShared - int(isFirstShared && mTrkParams[iteration].AllowSharingFirstCluster) > mTrkParams[iteration].ClusterSharing) {
       continue;
     }
-    const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer)[track.getClusterIndex(iLayer)];
-    if (linRef) {
-      if (!track.rotate(trackingHit.alphaTrackingFrame, *linRef, getBz())) {
-        return false;
-      }
-      if (!propInstance->propagateToX(track, *linRef, trackingHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
-        return false;
-      }
-      if (mTrkParams[0].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-        if (!track.correctForMaterial(*linRef, mTrkParams[0].LayerxX0[iLayer], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
-          continue;
-        }
-      }
-    } else {
-      if (!track.rotate(trackingHit.alphaTrackingFrame)) {
-        return false;
-      }
-      if (!propInstance->propagateToX(track, trackingHit.xTrackingFrame, getBz(), o2::base::PropagatorImpl<float>::MAX_SIN_PHI, o2::base::PropagatorImpl<float>::MAX_STEP, mTrkParams[0].CorrType)) {
-        return false;
+
+    bool firstCls{true};
+    TimeEstBC ts;
+    for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
+      if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
+        continue;
       }
-      if (mTrkParams[0].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-        if (!track.correctForMaterial(mTrkParams[0].LayerxX0[iLayer], mTrkParams[0].LayerxX0[iLayer] * constants::Radl * constants::Rho, true)) {
-          continue;
+      mTimeFrame->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
+      int currentROF = mTimeFrame->getClusterROF(iLayer, track.getClusterIndex(iLayer));
+      auto rofTS = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).getROFTimeBounds(currentROF, true);
+      if (firstCls) {
+        firstCls = false;
+        ts = rofTS;
+      } else {
+        if (!ts.isCompatible(rofTS)) {
+          LOGP(fatal, "TS {}+/-{} are incompatible with {}+/-{}, this should not happen!", rofTS.getTimeStamp(), rofTS.getTimeStampError(), ts.getTimeStamp(), ts.getTimeStampError());
         }
+        ts += rofTS;
       }
     }
-    auto predChi2{track.getPredictedChi2Quiet(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)};
-    if ((nCl >= 3 && predChi2 > chi2clcut) || predChi2 < 0.f) {
-      return false;
+    track.getTimeStamp() = ts.makeSymmetrical();
+    if (track.getTimeStamp().getTimeStampError() > smallestROFHalf) {
+      track.getTimeStamp().setTimeStampError(smallestROFHalf);
     }
-    track.setChi2(track.getChi2() + predChi2);
-    if (!track.o2::track::TrackParCov::update(trackingHit.positionTrackingFrame, trackingHit.covarianceTrackingFrame)) {
-      return false;
-    }
-    if (linRef && mTrkParams[0].ShiftRefToCluster) { // displace the reference to the last updated cluster
-      linRef->setY(trackingHit.positionTrackingFrame[0]);
-      linRef->setZ(trackingHit.positionTrackingFrame[1]);
+
+    track.setUserField(0);
+    track.getParamOut().setUserField(0);
+    mTimeFrame->getTracks().emplace_back(track);
+
+    if (mTrkParams[iteration].AllowSharingFirstCluster) {
+      firstClusters[firstLayer].push_back(firstCluster);
+      if (isFirstShared) {
+        sharedFirstClusters[firstLayer].push_back(firstCluster);
+      }
     }
-    nCl++;
   }
-  return std::abs(track.getQ2Pt()) < maxQoverPt && track.getChi2() < chi2ndfcut * (nCl * 2 - 5);
 }
 
-// create a new seed either from the existing track inner param or reseed from the edgepointd and cluster in the middle
 template <int NLayers>
-TrackITSExt TrackerTraits<NLayers>::seedTrackForRefit(const CellSeedN& seed)
+void TrackerTraits<NLayers>::markTracks(int iteration, bounded_vector<bounded_vector<int>>& sharedFirstClusters)
 {
-  TrackITSExt temporaryTrack(seed);
-  int lrMin = NLayers, lrMax = 0, lrMid = 0;
-  for (int iL = 0; iL < NLayers; ++iL) {
-    const int idx = seed.getCluster(iL);
-    temporaryTrack.setExternalClusterIndex(iL, idx, idx != constants::UnusedIndex);
-    if (idx != constants::UnusedIndex) {
-      lrMin = o2::gpu::CAMath::Min(lrMin, iL);
-      lrMax = o2::gpu::CAMath::Max(lrMax, iL);
+  if (mTrkParams[iteration].AllowSharingFirstCluster) {
+    /// Now we have to set the shared cluster flag
+    for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
+      std::sort(sharedFirstClusters[iLayer].begin(), sharedFirstClusters[iLayer].end());
     }
-  }
-  int ncl = temporaryTrack.getNClusters();
-  if (ncl < mTrkParams[0].ReseedIfShorter) { // reseed with circle passing via edges and the midpoint
-    if (ncl == mTrkParams[0].NLayers) {
-      lrMin = 0;
-      lrMax = mTrkParams[0].NLayers - 1;
-      lrMid = (lrMin + lrMax) / 2;
-    } else {
-      lrMid = lrMin + 1;
-      float midR = 0.5 * (mTrkParams[0].LayerRadii[lrMax] + mTrkParams[0].LayerRadii[lrMin]), dstMidR = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[lrMid]);
-      for (int iL = lrMid + 1; iL < lrMax; ++iL) { // find the midpoint as closest to the midR
-        auto dst = o2::gpu::GPUCommonMath::Abs(midR - mTrkParams[0].LayerRadii[iL]);
-        if (dst < dstMidR) {
-          lrMid = iL;
-          dstMidR = dst;
+
+    for (auto& track : mTimeFrame->getTracks()) {
+      int firstLayer{mTrkParams[iteration].NLayers}, firstCluster{constants::UnusedIndex};
+      for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
+        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
+          continue;
         }
+        firstLayer = iLayer;
+        firstCluster = track.getClusterIndex(iLayer);
+        break;
+      }
+      if (std::binary_search(sharedFirstClusters[firstLayer].begin(), sharedFirstClusters[firstLayer].end(), firstCluster)) {
+        track.setSharedClusters();
       }
     }
-    const auto& cluster0_tf = mTimeFrame->getTrackingFrameInfoOnLayer(lrMin)[seed.getCluster(lrMin)]; // if the sensor frame!
-    const auto& cluster1_gl = mTimeFrame->getUnsortedClusters()[lrMid][seed.getCluster(lrMid)];       // global frame
-    const auto& cluster2_gl = mTimeFrame->getUnsortedClusters()[lrMax][seed.getCluster(lrMax)];       // global frame
-    temporaryTrack.getParamIn() = buildTrackSeed(cluster2_gl, cluster1_gl, cluster0_tf, true);
-  }
-  temporaryTrack.resetCovariance();
-  temporaryTrack.setCov(temporaryTrack.getQ2Pt() * temporaryTrack.getQ2Pt() * temporaryTrack.getCov()[o2::track::CovLabels::kSigQ2Pt2], o2::track::CovLabels::kSigQ2Pt2);
-  return temporaryTrack;
-}
-
-/// Clusters are given from inside outward (cluster3 is the outermost). The outermost cluster is given in the tracking
-/// frame coordinates whereas the others are referred to the global frame.
-template <int NLayers>
-track::TrackParCov TrackerTraits<NLayers>::buildTrackSeed(const Cluster& cluster1, const Cluster& cluster2, const TrackingFrameInfo& tf3, bool reverse)
-{
-  const float sign = reverse ? -1.f : 1.f;
-
-  float ca, sa;
-  o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
-
-  const float x1 = cluster1.xCoordinate * ca + cluster1.yCoordinate * sa;
-  const float y1 = -cluster1.xCoordinate * sa + cluster1.yCoordinate * ca;
-  const float x2 = cluster2.xCoordinate * ca + cluster2.yCoordinate * sa;
-  const float y2 = -cluster2.xCoordinate * sa + cluster2.yCoordinate * ca;
-  const float x3 = tf3.xTrackingFrame;
-  const float y3 = tf3.positionTrackingFrame[0];
-
-  float snp, q2pt, q2pt2;
-  if (mIsZeroField) {
-    const float dx = x3 - x1;
-    const float dy = y3 - y1;
-    snp = sign * dy / o2::gpu::CAMath::Hypot(dx, dy);
-    q2pt = 1.f / track::kMostProbablePt;
-    q2pt2 = 1.f;
-  } else {
-    const float crv = math_utils::computeCurvature(x3, y3, x2, y2, x1, y1);
-    snp = sign * crv * (x3 - math_utils::computeCurvatureCentreX(x3, y3, x2, y2, x1, y1));
-    q2pt = sign * crv / (mBz * o2::constants::math::B2C);
-    q2pt2 = crv * crv;
   }
-
-  const float tgl = 0.5f * (math_utils::computeTanDipAngle(x1, y1, x2, y2, cluster1.zCoordinate, cluster2.zCoordinate) +
-                            math_utils::computeTanDipAngle(x2, y2, x3, y3, cluster2.zCoordinate, tf3.positionTrackingFrame[1]));
-  const float sg2q2pt = track::kC1Pt2max * (q2pt2 > 0.0005f ? (q2pt2 < 1.f ? q2pt2 : 1.f) : 0.0005f);
-
-  return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, track::kCSnp2max, 0.f, 0.f, 0.f, track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
 }
 
 template <int NLayers>
 void TrackerTraits<NLayers>::setBz(float bz)
 {
   mBz = bz;
-  mIsZeroField = std::abs(mBz) < 0.01;
   mTimeFrame->setBz(bz);
 }
 
@@ -991,9 +896,13 @@ void TrackerTraits<NLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>
 }
 
 template class TrackerTraits<7>;
+template void TrackerTraits<7>::processNeighbours<CellSeed>(int, int, int, const bounded_vector<CellSeed>&, const bounded_vector<int>&, bounded_vector<TrackSeed<7>>&, bounded_vector<int>&);
+template void TrackerTraits<7>::processNeighbours<TrackSeed<7>>(int, int, int, const bounded_vector<TrackSeed<7>>&, const bounded_vector<int>&, bounded_vector<TrackSeed<7>>&, bounded_vector<int>&);
 // ALICE3 upgrade
 #ifdef ENABLE_UPGRADES
 template class TrackerTraits<11>;
+template void TrackerTraits<11>::processNeighbours<CellSeed>(int, int, int, const bounded_vector<CellSeed>&, const bounded_vector<int>&, bounded_vector<TrackSeed<11>>&, bounded_vector<int>&);
+template void TrackerTraits<11>::processNeighbours<TrackSeed<11>>(int, int, int, const bounded_vector<TrackSeed<11>>&, const bounded_vector<int>&, bounded_vector<TrackSeed<11>>&, bounded_vector<int>&);
 #endif
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index fa3339b001ca3..cc8731c8b6912 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -193,11 +193,10 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     mTimeFrame->getROFMaskView().print(iLayer);
   }
 
-  float vertexerElapsedTime{0.f};
+  float vertexerElapsedTime{0.f}, trackerElapsedTime{0.f};
   if (mRunVertexer) {
     // Run seeding vertexer
     vertexerElapsedTime = mVertexer->clustersToVertices(logger);
-    // FIXME: this is a temporary stop-gap measure until we figure the rest out
     const auto& vtx = mTimeFrame->getPrimaryVertices();
     vertices.insert(vertices.begin(), vtx.begin(), vtx.end());
     if (mIsMC) {
@@ -237,26 +236,29 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   }
 
   if (mRunVertexer && hasClusters) {
-    LOG(info) << fmt::format(" - Vertex seeding total elapsed time: {} ms for {} vertices found",
-                             vertexerElapsedTime,
-                             mTimeFrame->getPrimaryVerticesNum());
+    LOGP(info, " + Vertex seeding total elapsed time: {} ms for {} vertices found", vertexerElapsedTime, mTimeFrame->getPrimaryVerticesNum());
   }
 
   if (mOverrideBeamEstimation) {
-    LOG(info) << fmt::format(" - Beam position set to: {}, {} from meanvertex object", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
+    LOG(info) << fmt::format(" + Beam position set to: {}, {} from meanvertex object", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
   } else {
-    LOG(info) << fmt::format(" - Beam position computed for the TF: {}, {}", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
+    LOG(info) << fmt::format(" + Beam position computed for the TF: {}, {}", mTimeFrame->getBeamX(), mTimeFrame->getBeamY());
   }
 
   if (hasClusters) {
     mTimeFrame->setMultiplicityCutMask(processMultiplictyMask);
     mTimeFrame->setUPCCutMask(processUPCMask);
-    // Run CA tracker
     if (mMode == o2::its::TrackingMode::Async && o2::its::TrackerParamConfig::Instance().fataliseUponFailure) {
-      mTracker->clustersToTracks(logger, fatalLogger);
+      trackerElapsedTime = mTracker->clustersToTracks(logger, fatalLogger);
     } else {
-      mTracker->clustersToTracks(logger, errorLogger);
+      trackerElapsedTime = mTracker->clustersToTracks(logger, errorLogger);
     }
+    LOGP(info, " + Tracking total elapse time: {} ms for {} tracks found", trackerElapsedTime, mTimeFrame->getNumberOfTracks());
+  }
+  if constexpr (constants::DoTimeBenchmarks) {
+    const auto& trackConf = o2::its::TrackerParamConfig::Instance();
+    const auto& vertConf = o2::its::VertexerParamConfig::Instance();
+    logger(std::format("=== TimeSlice {} processing completed in: {:.2f} ms using {}/{} thread(s) ===", tfInfo.timeslice, trackerElapsedTime + vertexerElapsedTime, vertConf.nThreads, trackConf.nThreads));
   }
 
   size_t totTracks{mTimeFrame->getNumberOfTracks()}, totClusIDs{mTimeFrame->getNumberOfUsedClusters()};
@@ -265,7 +267,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     allClusIdx.reserve(totClusIDs);
 
     if (mTimeFrame->hasBogusClusters()) {
-      LOG(warning) << fmt::format(" - The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
+      LOG(warning) << fmt::format(" + The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
     }
 
     auto& tracks = mTimeFrame->getTracks();
@@ -349,7 +351,7 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     }
   }
 
-  LOGP(info, "ITSTracker pushed {} tracks in {} rofs and {} vertices {}", allTracks.size(), allTrackROFs.size(), vertices.size(), ((mDoStaggering) ? "in staggered-readout mode" : "in normal mode"));
+  LOGP(info, "ITSTracker pushed {} tracks in {} rofs and {} vertices {}", allTracks.size(), allTrackROFs.size(), vertices.size(), ((mDoStaggering) ? "in staggered-readout mode" : ""));
   if (mIsMC) {
     LOGP(info, "ITSTracker pushed {} track labels", allTrackLabels.size());
     LOGP(info, "ITSTracker pushed {} vertex labels", allVerticesLabels.size());
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index cbff174634ec8..556302cb2854f 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -141,13 +141,9 @@ void Vertexer<NLayers>::printEpilog(LogFunc& logger,
                                     const unsigned selectedN, const unsigned int vertexN, const unsigned int totalVertexN,
                                     const float trackletT, const float selecT, const float vertexT)
 {
-  logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
-  logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {} ms", mTraits->getName(), selectedN, selecT));
-  logger(fmt::format(" - {} Vertexer: found {} vertices in: {} ms (total: {})", mTraits->getName(), vertexN, vertexT, totalVertexN));
-  if (mVertParams[0].PrintMemory) {
-    mTimeFrame->printArtefactsMemory();
-    mMemoryPool->print();
-  }
+  logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {:.2f} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
+  logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {:.2f} ms", mTraits->getName(), selectedN, selecT));
+  logger(fmt::format(" - {} Vertexer: found {} vertices (total: {}) in: {:.2f} ms", mTraits->getName(), vertexN, totalVertexN, vertexT));
 }
 
 template class Vertexer<7>;

From 756fb429a6e8e28f7bb097d642e4be0f456ef8ba Mon Sep 17 00:00:00 2001
From: nicolovalle <35177278+nicolovalle@users.noreply.github.com>
Date: Fri, 24 Apr 2026 12:28:16 +0200
Subject: [PATCH 1657/1764] ITS Beam background studies - first workflow
 (#15268)

* ITS Beam background studies - first workflow

* fix clang

* fix CI error

* Fix statements in braces

* leftover...

* Fixing shift 1 bc
---
 .../ITS/postprocessing/studies/CMakeLists.txt |   1 +
 .../ITSStudies/ITSBeamBackgroundStudy.h       |  26 +
 .../studies/src/ITSBeamBackgroundStudy.cxx    | 739 ++++++++++++++++++
 .../standalone-postprocessing-workflow.cxx    |  15 +-
 4 files changed, 780 insertions(+), 1 deletion(-)
 create mode 100644 Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSBeamBackgroundStudy.h
 create mode 100644 Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSBeamBackgroundStudy.cxx

diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt b/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt
index 9794b69631d57..08ced25d0f5dc 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/CMakeLists.txt
@@ -15,6 +15,7 @@ SOURCES src/ImpactParameter.cxx
         src/PIDStudy.cxx
         src/ITSStudiesConfigParam.cxx
         src/AnomalyStudy.cxx
+	src/ITSBeamBackgroundStudy.cxx
         src/TrackCheck.cxx
         src/TrackExtension.cxx
         src/Efficiency.cxx
diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSBeamBackgroundStudy.h b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSBeamBackgroundStudy.h
new file mode 100644
index 0000000000000..cd96a9df8dee6
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/include/ITSStudies/ITSBeamBackgroundStudy.h
@@ -0,0 +1,26 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ITS_BEAMBKG_STUDY_H
+#define O2_ITS_BEAMBKG_STUDY_H
+
+#include "Framework/DataProcessorSpec.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
+
+namespace o2::its::study
+{
+
+using mask_t = o2::dataformats::GlobalTrackID::mask_t;
+
+o2::framework::DataProcessorSpec getITSBeamBackgroundStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC);
+
+} // namespace o2::its::study
+#endif
diff --git a/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSBeamBackgroundStudy.cxx b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSBeamBackgroundStudy.cxx
new file mode 100644
index 0000000000000..fc9e139648672
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/postprocessing/studies/src/ITSBeamBackgroundStudy.cxx
@@ -0,0 +1,739 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ITSStudies/ITSBeamBackgroundStudy.h"
+#include "DataFormatsGlobalTracking/RecoContainer.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "DataFormatsParameters/GRPObject.h"
+
+#include "CCDB/BasicCCDBManager.h"
+#include "CCDB/CCDBTimeStampUtils.h"
+#include "DataFormatsITSMFT/CompCluster.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "DataFormatsITSMFT/TopologyDictionary.h"
+
+#include <set>
+#include <algorithm>
+#include <limits>
+
+#include <TTree.h>
+#include <TH2.h>
+
+#include "Framework/Task.h"
+#include "Framework/Logger.h"
+
+// ZDC
+#include "DataFormatsZDC/RecEventFlat.h"
+
+using namespace o2::framework;
+using namespace o2::globaltracking;
+using GTrackID = o2::dataformats::GlobalTrackID;
+
+namespace o2::its::study
+{
+class ITSBeamBackgroundStudy : public Task
+{
+ public:
+  ITSBeamBackgroundStudy(std::shared_ptr<DataRequest> dr,
+                         std::shared_ptr<o2::base::GRPGeomRequest> gr,
+                         bool isMC) : mDataRequest{dr}, mGGCCDBRequest(gr), mUseMC(isMC) {}
+
+  void init(InitContext& ic) final;
+  void run(ProcessingContext&) final;
+  void endOfStream(EndOfStreamContext&) final;
+  void finaliseCCDB(ConcreteDataMatcher&, void*) final;
+  void save_and_reset();
+
+  // Custom
+  void process(o2::globaltracking::RecoContainer& recoData);
+  void updateTimeDependentParams(ProcessingContext& pc);
+
+ private:
+  void getClusterPatterns(gsl::span<const o2::itsmft::CompClusterExt>&, gsl::span<const unsigned char>&, const o2::itsmft::TopologyDictionary&);
+  std::vector<o2::itsmft::ClusterPattern> mPatterns;
+
+  // ITS layout
+  int NStaves[7] = {12, 16, 20, 24, 30, 42, 48};
+  int N_STAVES_IB = 48;
+  int N_CHIP_IB = 432;
+
+  // Utilities
+  int ChipToLayer(int chip);
+  double ChipToPhi(int chip);
+  bool searchBCfromMap(std::map<long, std::set<int>>& BCperorbit, long target_orbit, int target_bc);
+
+  std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
+  std::shared_ptr<DataRequest> mDataRequest;
+  bool mUseMC;
+  const o2::itsmft::TopologyDictionary* mDict = nullptr;
+
+  int mTFn = 0;
+  int mTF_first_after_dump = 1;
+
+  int mStrobeFallBack = 594;
+  int mStrobe = mStrobeFallBack;
+
+  // TODO: the following should be make configurable
+
+  std::pair<double, double> TimeWindowZDC = std::make_pair(5., 11.);
+  std::pair<double, double> TimeWindowZNAr = std::make_pair(5.64507, 9.64507);
+  std::pair<double, double> TimeWindowZNCr = std::make_pair(4.21299, 8.21299);
+  std::pair<double, double> TimeWindowZNAl = std::make_pair(-11.3549, -8.35493);
+  std::pair<double, double> TimeWindowZNCl = std::make_pair(-12.787, -9.78701);
+
+  int targetClusterMinCol = 128; // definition of anomalous cluster
+  int targetClusterMaxRow = 29;  // definition of anomalous cluster
+
+  int mDumpEveryTF = 10; // use -1 to save only at the end
+  int mSkimmedOnlyAfterTF = 15000;
+  std::string mOutputChip = "chipevents";
+  std::string mOutoutChipSkim = "chipeventstarget";
+
+  TH1F* TimeWindowCut;
+  TH1F* ZNACall;
+  TH1F* ZNCCall;
+  TH1F* ZDCAtagBC;
+  TH1F* ZDCCtagBC;
+  TH1I* Counters;
+  TTree* ITSChipEvtTree;
+  TTree* ITSChipEvtTargetTree;
+
+  // Tree variables
+  int Tbc;
+  long Torbit;
+  int Tchip;
+  double Tphi;
+  int TZDCtag;
+  int Tnhit, Tnclus, Tnhit_no1pix, Tnclus_no1pix;
+  int Tnclus_s20, Tnclus_s100, Tnclus_s150;
+  int Tnclus_c20, Tnclus_c100, Tnclus_c128;
+  int Tnclus_target;
+  double Tnhit1, Tnhit10;
+  int Tmissingafter, Tmissingafter2;
+  int Tmincol, Tmaxcol;
+};
+
+void ITSBeamBackgroundStudy::updateTimeDependentParams(ProcessingContext& pc)
+{
+  // o2::base::GRPGeomHelper::instance().checkUpdates(pc);
+  // static bool initOnceDone = false;
+  // if (!initOnceDone) { // this param need to be queried only once
+  //   initOnceDone = true;
+  //   // mGeom = o2::its::GeometryTGeo::Instance();
+  //   // mGeom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L, o2::math_utils::TransformType::T2GRot, o2::math_utils::TransformType::T2G));
+  // }
+}
+
+void ITSBeamBackgroundStudy::init(InitContext& ic)
+{
+  LOGP(info, "Initializing ITSBeamBackgroundStudy");
+  LOGP(info, "Fetching ClusterDictionary");
+  auto& mgr = o2::ccdb::BasicCCDBManager::instance();
+  mgr.setURL("http://alice-ccdb.cern.ch");
+  mgr.setTimestamp(o2::ccdb::getCurrentTimestamp());
+  mDict = mgr.get<o2::itsmft::TopologyDictionary>("ITS/Calib/ClusterDictionary");
+
+  LOGP(info, "Setting up trees and histograms. They will be dumped on file every {} TFs", mDumpEveryTF);
+
+  TimeWindowCut = new TH1F("ZDC bkg region", "ZNAr, ZNCr, -ZNAl, -ZNCl", 8, 0, 8);
+  TimeWindowCut->SetBinContent(1, TimeWindowZNAr.first);
+  TimeWindowCut->SetBinContent(2, TimeWindowZNAr.second);
+  TimeWindowCut->SetBinContent(3, TimeWindowZNCr.first);
+  TimeWindowCut->SetBinContent(4, TimeWindowZNCr.second);
+  TimeWindowCut->SetBinContent(5, -TimeWindowZNAl.first);
+  TimeWindowCut->SetBinContent(6, -TimeWindowZNAl.second);
+  TimeWindowCut->SetBinContent(7, -TimeWindowZNCl.first);
+  TimeWindowCut->SetBinContent(8, -TimeWindowZNCl.second);
+  ZNACall = new TH1F("ZNACall", "ZNACall", 40, -20, 20);
+  ZNCCall = new TH1F("ZNCCall", "ZNCCall", 40, -20, 20);
+  ZDCAtagBC = new TH1F("ZDCA tagged BC", "ZDCA tagged bc", 3564, 0, 3564);
+  ZDCCtagBC = new TH1F("ZDCC tagged BC", "ZDCC tagged bc", 3564, 0, 3564);
+
+  Counters = new TH1I("Counters", "Counters", 20, 1, 21);
+  Counters->GetXaxis()->SetBinLabel(1, "TF");
+  Counters->GetXaxis()->SetBinLabel(2, "ROF");
+  Counters->GetXaxis()->SetBinLabel(3, "ZDCA evt");
+  Counters->GetXaxis()->SetBinLabel(4, "ROF-ZDCA tagged");
+  Counters->GetXaxis()->SetBinLabel(5, "ITStag any");
+  Counters->GetXaxis()->SetBinLabel(6, "ITStag TO");
+  Counters->GetXaxis()->SetBinLabel(7, "ITStag any + ZDC");
+  Counters->GetXaxis()->SetBinLabel(8, "ITStag TO + ZDC");
+  Counters->GetXaxis()->SetBinLabel(9, "ZDCC evt");
+  Counters->GetXaxis()->SetBinLabel(10, "ROF-ZDCC tagged");
+
+  ITSChipEvtTree = new TTree("chipevt", "chipevt");
+
+  // Chip event branches
+  ITSChipEvtTree->Branch("TFprogress", &mTFn, "TFprogress/I");
+  ITSChipEvtTree->Branch("orbit", &Torbit, "orbit/L");
+  ITSChipEvtTree->Branch("bc", &Tbc, "bc/I");
+  ITSChipEvtTree->Branch("chip", &Tchip, "chip/I");
+  ITSChipEvtTree->Branch("phi", &Tphi, "phi/D");
+  ITSChipEvtTree->Branch("zdctag", &TZDCtag, "zdctag/I");
+  ITSChipEvtTree->Branch("nhit", &Tnhit, "nhit/I");
+  ITSChipEvtTree->Branch("nhit_no1pix", &Tnhit_no1pix, "nhit_no1pix/I");
+  ITSChipEvtTree->Branch("size1", &Tnhit1, "size1/D");
+  ITSChipEvtTree->Branch("size10", &Tnhit10, "size10/D");
+  ITSChipEvtTree->Branch("nclus", &Tnclus, "nclus/I");
+  ITSChipEvtTree->Branch("nclus_no1pix", &Tnclus_no1pix, "nclus_no1pix/I");
+  ITSChipEvtTree->Branch("nclus_target", &Tnclus_target, "nclus_target/I");
+  ITSChipEvtTree->Branch("missingafter", &Tmissingafter, "missingafter/I");
+  ITSChipEvtTree->Branch("missingafter2", &Tmissingafter2, "missingafter2/I");
+  ITSChipEvtTree->Branch("mincol", &Tmincol, "mincol/I");
+  ITSChipEvtTree->Branch("maxcol", &Tmaxcol, "maxcol/I");
+
+  ITSChipEvtTargetTree = ITSChipEvtTree->CloneTree(0);
+  ITSChipEvtTargetTree->SetName("chipevttarget");
+  ITSChipEvtTargetTree->SetTitle("chipevttarget");
+}
+
+void ITSBeamBackgroundStudy::save_and_reset()
+{
+
+  std::string outfile11 = mOutoutChipSkim + "_" + std::to_string(mTF_first_after_dump) + "_" + std::to_string(mTFn) + ".root";
+  LOGP(info, "Writing ROOT file {}", outfile11);
+  TFile* F11 = TFile::Open(outfile11.c_str(), "recreate");
+  TimeWindowCut->Write();
+  ZNACall->Write();
+  ZNCCall->Write();
+  ZDCAtagBC->Write();
+  ZDCCtagBC->Write();
+  Counters->Write();
+  ITSChipEvtTargetTree->Write();
+  F11->Close();
+  delete F11;
+
+  if (mTFn <= mSkimmedOnlyAfterTF) {
+    std::string outfile1 = mOutputChip + "_" + std::to_string(mTF_first_after_dump) + "_" + std::to_string(mTFn) + ".root";
+    LOGP(info, "Writing ROOT file {}", outfile1);
+    TFile* F1 = TFile::Open(outfile1.c_str(), "recreate");
+    TimeWindowCut->Write();
+    ZNACall->Write();
+    ZNCCall->Write();
+    ZDCAtagBC->Write();
+    ZDCCtagBC->Write();
+    Counters->Write();
+    ITSChipEvtTree->Write(); // chip events and the skimmed one
+    ITSChipEvtTargetTree->Write();
+    F1->Close();
+    delete F1;
+  }
+
+  LOGP(info, "Resetting historgrams and trees");
+  // Delete clears data but keep the branch setup intact
+  ITSChipEvtTree->Reset();       // Delete("");
+  ITSChipEvtTargetTree->Reset(); // Delete("");
+  ZNACall->Reset();
+  ZNCCall->Reset();
+  ZDCAtagBC->Reset();
+  ZDCCtagBC->Reset();
+  Counters->Reset();
+
+  mTF_first_after_dump = mTFn + 1;
+}
+
+void ITSBeamBackgroundStudy::endOfStream(EndOfStreamContext&)
+{
+  LOGP(info, "End of stream for ITSBeamBackgroundStudy");
+
+  save_and_reset();
+
+  delete TimeWindowCut;
+  delete ZNACall;
+  delete ZNCCall;
+  delete ZDCAtagBC;
+  delete ZDCCtagBC;
+  delete Counters;
+  delete ITSChipEvtTree;
+  delete ITSChipEvtTargetTree;
+}
+
+void ITSBeamBackgroundStudy::run(ProcessingContext& pc)
+{
+
+  if (mTFn == std::numeric_limits<int>::max()) {
+    LOGP(error, "Max {} TFs exceeded. Skipping all next events", mTFn);
+    return;
+  }
+
+  mTFn++;
+
+  if (mDumpEveryTF > 0 && mTFn > 0 && (mTFn % mDumpEveryTF) == 0) {
+    LOGP(info, "Reached TF #{}. Exporting new root files", mTFn);
+    save_and_reset();
+  }
+
+  o2::globaltracking::RecoContainer recoData;
+  recoData.collectData(pc, *mDataRequest.get());
+  // updateTimeDependentParams(pc);
+  LOGP(info, "Calling process() for TF: {}", mTFn);
+  process(recoData);
+}
+
+void ITSBeamBackgroundStudy::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
+{
+  return;
+}
+
+// Custom area
+void ITSBeamBackgroundStudy::process(o2::globaltracking::RecoContainer& recoData)
+{
+
+  LOGP(info, "Processing RecoContainer");
+  Counters->Fill(1);
+
+  LOGP(info, "Retrieving ZDC data");
+  auto RecBC = recoData.getZDCBCRecData();
+  auto Energy = recoData.getZDCEnergy();
+  auto TDCData = recoData.getZDCTDCData();
+  auto Info2 = recoData.getZDCInfo();
+  LOGP(info, "sizeof ZDC RC: {}, {}, {}, {}", RecBC.size(), Energy.size(), TDCData.size(), Info2.size());
+
+  LOGP(info, "Retrieving ITS clusters");
+  auto rofRecVec = recoData.getITSClustersROFRecords();
+  auto clusArr = recoData.getITSClusters();
+  auto clusPatt = recoData.getITSClustersPatterns();
+  LOGP(info, "sizeof ITS RC: {}, {}, {}", clusArr.size(), clusPatt.size(), rofRecVec.size());
+
+  // TODO: improve this
+  if (rofRecVec.size() == 576 || rofRecVec.size() == 192) {
+    mStrobe = 3564 / (rofRecVec.size() / 32);
+    LOGP(info, "Assuimg TF length = 32 orbits and setting strobe length to {} bc", mStrobe);
+  } else {
+    mStrobe = mStrobeFallBack;
+    LOGP(warning, "Unforeseen number of ROFs in the loop. Using the strobe length fall back value {}", mStrobe);
+  }
+
+  std::map<long, std::set<int>> ZNArtag{}; // ZDCAtag[orbit] = <list of bc...>
+  std::map<long, std::set<int>> ZNCrtag{};
+  std::map<long, std::set<int>> ZNAltag{};
+  std::map<long, std::set<int>> ZNCltag{};
+
+  // ________________________________________________________________
+  // FILLING ZDC ARRAY
+  o2::zdc::RecEventFlat ev;
+
+  ev.init(RecBC, Energy, TDCData, Info2);
+
+  int bkgcounterAr = 0, bkgcounterCr = 0;
+  int bkgcounterAl = 0, bkgcounterCl = 0;
+  while (ev.next()) {
+
+    int32_t itdcA = o2::zdc::TDCZNAC; // should be == 0
+    int32_t itdcC = o2::zdc::TDCZNCC;
+    long zdcorbit = (long)ev.ir.orbit;
+
+    // ZDC - A side
+    int nhitA = ev.NtdcV(itdcA);
+    for (int32_t ipos = 0; ipos < nhitA; ipos++) {
+
+      double mytdc = o2::zdc::FTDCVal * ev.TDCVal[itdcA][ipos];
+
+      ZNACall->Fill(mytdc);
+
+      if (mytdc >= TimeWindowZNAr.first && mytdc <= TimeWindowZNAr.second) {
+
+        // Backgroud event found here!
+        bkgcounterAr++;
+        Counters->Fill(3);
+        ZDCAtagBC->Fill(ev.ir.bc);
+
+        if (ZNArtag.find(zdcorbit) != ZNArtag.end()) {
+          bool double_count_bkg = ZNArtag[zdcorbit].insert((int)ev.ir.bc).second;
+          if (double_count_bkg) {
+            LOGP(warning, "Multiple ZDCAr counts in the same orbit/bc {}/{}", zdcorbit, ev.ir.bc);
+          }
+        } else {
+          std::set<int> zdcbcs{(int)ev.ir.bc};
+          ZNArtag[zdcorbit] = zdcbcs;
+        }
+
+      } // and of ZNAr time window
+
+      if (mytdc >= TimeWindowZNAl.first && mytdc <= TimeWindowZNAl.second) {
+
+        // Backgroud event found here!
+        bkgcounterAl++;
+        Counters->Fill(3);
+        ZDCAtagBC->Fill(ev.ir.bc);
+
+        if (ZNAltag.find(zdcorbit) != ZNAltag.end()) {
+          bool double_count_bkg = ZNAltag[zdcorbit].insert((int)ev.ir.bc).second;
+          if (double_count_bkg) {
+            LOGP(warning, "Multiple ZDCAl counts in the same orbit/bc {}/{}", zdcorbit, ev.ir.bc);
+          }
+        } else {
+          std::set<int> zdcbcs{(int)ev.ir.bc};
+          ZNAltag[zdcorbit] = zdcbcs;
+        }
+
+      } // and of ZNAl time window
+    }
+
+    // ZDC - C side
+    int nhitC = ev.NtdcV(itdcC);
+    for (int32_t ipos = 0; ipos < nhitC; ipos++) {
+
+      double mytdc = o2::zdc::FTDCVal * ev.TDCVal[itdcC][ipos];
+
+      ZNCCall->Fill(mytdc);
+
+      if (mytdc >= TimeWindowZNCr.first && mytdc <= TimeWindowZNCr.second) {
+
+        // Backgroud event found here!
+        bkgcounterCr++;
+        Counters->Fill(9);
+        ZDCCtagBC->Fill(ev.ir.bc);
+
+        if (ZNCrtag.find(zdcorbit) != ZNCrtag.end()) {
+          bool double_count_bkg = ZNCrtag[zdcorbit].insert((int)ev.ir.bc).second;
+          if (double_count_bkg) {
+            LOGP(warning, "Multiple ZNCr counts in the same orbit/bc {}/{}", zdcorbit, ev.ir.bc);
+          }
+        } else {
+          std::set<int> zdcbcs{(int)ev.ir.bc};
+          ZNCrtag[zdcorbit] = zdcbcs;
+        }
+
+      } // end of ZNCr time window
+
+      if (mytdc >= TimeWindowZNCl.first && mytdc <= TimeWindowZNCl.second) {
+
+        // Backgroud event found here!
+        bkgcounterCl++;
+        Counters->Fill(9);
+        ZDCCtagBC->Fill(ev.ir.bc);
+
+        if (ZNCltag.find(zdcorbit) != ZNCltag.end()) {
+          bool double_count_bkg = ZNCltag[zdcorbit].insert((int)ev.ir.bc).second;
+          if (double_count_bkg) {
+            LOGP(warning, "Multiple ZNCl counts in the same orbit/bc {}/{}", zdcorbit, ev.ir.bc);
+          }
+        } else {
+          std::set<int> zdcbcs{(int)ev.ir.bc};
+          ZNCltag[zdcorbit] = zdcbcs;
+        }
+
+      } // end of ZNCl time window
+    }
+  } // end of while ev.next()
+
+  LOGP(info, "Found background envents from ZNAright/left {}/{} -- from ZNCright/left {}/{}", bkgcounterAr, bkgcounterAl, bkgcounterCr, bkgcounterCl);
+  //__________________________________________________________________
+
+  getClusterPatterns(clusArr, clusPatt, *mDict);
+
+  int inTFROFcounter = -1;
+
+  std::vector<bool> ChipSeenInThisROF(N_CHIP_IB, false);  // ChipSeenInThisROF[chipid] = true/false
+  std::vector<bool> ChipSeenInLastROF(N_CHIP_IB, false);  // ChipSeenInLastROF[chipid] = true/false
+  std::vector<bool> ChipSeenInLast2ROF(N_CHIP_IB, false); // ChipSeenInLast2ROF[chipid] = true/false
+
+  // Begin loop over ROFs
+  for (auto it = rofRecVec.rbegin(); it != rofRecVec.rend(); ++it) {
+
+    auto& rofRec = *it;
+
+    inTFROFcounter++;
+
+    Counters->Fill(2);
+
+    ChipSeenInLast2ROF = ChipSeenInLastROF;
+    ChipSeenInLastROF = ChipSeenInThisROF;
+    std::fill(ChipSeenInThisROF.begin(), ChipSeenInThisROF.end(), false);
+
+    auto clustersInRof = rofRec.getROFData(clusArr);
+    auto patternsInRof = rofRec.getROFData(mPatterns);
+
+    Tbc = (int)rofRec.getBCData().bc;
+    Torbit = (long)rofRec.getBCData().orbit;
+
+    if (inTFROFcounter < 1) {
+      LOGP(info, "First of TF: ITS orbit/bc {}/{}", Torbit, Tbc);
+    }
+
+    // shifting by 60 bc
+    int eff_bc = Tbc + 60;
+    long eff_orbit = Torbit;
+    if (eff_bc > 3563) {
+      eff_bc -= 3564;
+      eff_orbit += 1;
+    }
+
+    // Making a bitmask with ZDC tags for this bc
+    bool isZNArtagged = searchBCfromMap(ZNArtag, (long)eff_orbit, eff_bc);
+    if (isZNArtagged) {
+      Counters->Fill(4);
+    }
+
+    bool isZNAltagged = searchBCfromMap(ZNAltag, (long)eff_orbit, eff_bc);
+    if (isZNAltagged) {
+      Counters->Fill(4);
+    }
+
+    bool isZNCrtagged = searchBCfromMap(ZNCrtag, (long)eff_orbit, eff_bc);
+    if (isZNCrtagged) {
+      Counters->Fill(10);
+    }
+
+    bool isZNCltagged = searchBCfromMap(ZNCltag, (long)eff_orbit, eff_bc);
+    if (isZNCltagged) {
+      Counters->Fill(10);
+    }
+
+    TZDCtag = 0;
+    TZDCtag |= (isZNArtagged << 0);
+    TZDCtag |= (isZNAltagged << 1);
+    TZDCtag |= (isZNCrtagged << 2);
+    TZDCtag |= (isZNCltagged << 3);
+
+    if (TZDCtag > 0) {
+      LOGP(info, "ZDC tag with mask {}: ZNAright = {} - ZNAleft = {} - ZNCright = {} - ZNCleft = {}",
+           TZDCtag, (TZDCtag >> 0) & 1, (TZDCtag >> 1) & 1, (TZDCtag >> 2) & 1, (TZDCtag >> 3) & 1);
+    }
+
+    // preparing arrays for clusters analysis
+    std::set<int> AvailableChips{};
+    std::map<int, std::vector<int>> MAPsize{}; // MAP[chip] = {list if sizes}
+    std::map<int, std::vector<int>> MAPcols{}; // MAP[chip] = {list of column span}
+    std::map<int, int> MAPntarget{};           // MAP[chip] = number of bad clusters in chip
+    std::map<int, int> MAPcoo_mincol{};        // MAP[chip] = minimum of column coordinate
+    std::map<int, int> MAPcoo_maxcol{};        // MAP[chip] = maximum of (column coordinate + colspan)
+
+    // Finally loop over clusters
+    int ntarget_in_rof = 0;
+    for (int iclus = 0; iclus < clustersInRof.size(); iclus++) {
+
+      const auto& compClus = clustersInRof[iclus];
+
+      auto chipid = compClus.getSensorID();
+
+      // Analyze only IB
+      if (ChipToLayer(chipid) > 2) {
+        continue;
+      }
+
+      ChipSeenInThisROF[chipid] = true;
+
+      int coo_col = (int)compClus.getCol();
+      int coo_row = (int)compClus.getRow();
+
+      auto patti = patternsInRof[iclus];
+      int npix = patti.getNPixels();
+      int colspan = patti.getColumnSpan();
+      int rowspan = patti.getRowSpan();
+
+      bool newchip = AvailableChips.insert(chipid).second;
+      if (newchip) {
+        MAPsize[chipid] = std::vector<int>{};
+        MAPcols[chipid] = std::vector<int>{};
+        MAPntarget[chipid] = 0;
+        MAPcoo_mincol[chipid] = coo_col;
+        MAPcoo_maxcol[chipid] = coo_col + colspan;
+      }
+
+      MAPsize[chipid].push_back(npix);
+      MAPcols[chipid].push_back(colspan);
+      if (colspan >= targetClusterMinCol && rowspan <= targetClusterMaxRow) {
+        // Anomalous cluster found
+        MAPntarget[chipid] += 1;
+        ntarget_in_rof++;
+      }
+      MAPcoo_mincol[chipid] = TMath::Min(MAPcoo_mincol[chipid], coo_col);
+      MAPcoo_maxcol[chipid] = TMath::Max(MAPcoo_maxcol[chipid], coo_col + colspan);
+
+    } // end of loop over clusters in rof
+
+    if (ntarget_in_rof == 0 && mTFn > mSkimmedOnlyAfterTF + 2) { // extra 2 to avoid edge effects?
+      // do not need extra computations for this rof since it will not be saved in any case
+      continue;
+    }
+
+    for (int ic : AvailableChips) {
+
+      Tchip = ic;
+
+      if (inTFROFcounter < 1) {
+        Tmissingafter = -1;
+      } else if (ChipSeenInLastROF[ic]) {
+        Tmissingafter = 0;
+      } else {
+        Tmissingafter = 1;
+      }
+
+      if (inTFROFcounter < 2) {
+        Tmissingafter2 = -1;
+      } else if (ChipSeenInLast2ROF[ic]) {
+        Tmissingafter2 = 0;
+      } else {
+        Tmissingafter2 = 1;
+      }
+
+      Tphi = ChipToPhi(ic);
+
+      Tnclus = MAPsize[ic].size();
+      Tmincol = MAPcoo_mincol[ic];
+      Tmaxcol = MAPcoo_maxcol[ic];
+
+      std::sort(MAPsize[ic].begin(), MAPsize[ic].end(), std::greater<>());
+
+      Tnhit = Tnclus_s20 = Tnclus_s100 = Tnclus_s150 = 0;
+      Tnhit1 = Tnhit10 = 0.;
+      Tnclus_c20 = Tnclus_c100 = Tnclus_c128 = 0;
+      Tnclus_target = MAPntarget[ic];
+      Tnhit_no1pix = 0;
+      Tnclus_no1pix = 0;
+
+      int nhit_no1pix = 0;
+      int nclus10 = 0, nclus1 = 0;
+
+      for (int nh : MAPsize[ic]) {
+
+        Tnhit += nh;
+
+        if (nh > 1) {
+          Tnhit_no1pix += nh;
+          Tnclus_no1pix += 1;
+        }
+
+        if (nclus10 < 10) {
+          nclus10++;
+          Tnhit10 += 1. * nh;
+        }
+
+        if (nclus1 < 1) {
+          nclus1++;
+          Tnhit1 += 1. * nh;
+        }
+
+        Tnclus_s20 += (nh >= 20);
+        Tnclus_s100 += (nh >= 100);
+        Tnclus_s150 += (nh >= 150);
+      }
+
+      Tnhit10 = (nclus10 == 0) ? 0. : 1. * Tnhit10 / nclus10;
+
+      for (int nc : MAPcols[ic]) {
+        Tnclus_c20 += (nc >= 20);
+        Tnclus_c100 += (nc >= 100);
+        Tnclus_c128 += (nc >= 128);
+      }
+
+      ITSChipEvtTree->Fill();
+      if (Tnclus_target > 0) {
+        ITSChipEvtTargetTree->Fill();
+      }
+
+    } // end of loop over available chips
+  } // end of loop over ROFs
+}
+
+// TODO: To be improved using geometry tools
+int ITSBeamBackgroundStudy::ChipToLayer(int chip)
+{
+  if (chip < 108) {
+    return 0;
+  }
+  if (chip < 252) {
+    return 1;
+  }
+  if (chip < 432) {
+    return 2;
+  }
+  if (chip < 3120) {
+    return 3;
+  }
+  if (chip < 6480) {
+    return 4;
+  }
+  if (chip < 14712) {
+    return 5;
+  }
+  return 6;
+}
+
+// TODO: To be improved using geometry tools
+double ITSBeamBackgroundStudy::ChipToPhi(int chip)
+{
+  int staveinlayer = (int)(chip / 9);
+  for (int il = 0; il < ChipToLayer(chip); il++) {
+    staveinlayer -= NStaves[il];
+  }
+  return 2. * TMath::Pi() * (0.5 + staveinlayer) / NStaves[ChipToLayer(chip)];
+}
+
+bool ITSBeamBackgroundStudy::searchBCfromMap(std::map<long, std::set<int>>& BCperorbit, long its_orbit, int its_bc)
+{
+  auto it = BCperorbit.find(its_orbit);
+  if (it == BCperorbit.end()) {
+    return false;
+  }
+
+  for (auto bc : it->second) {
+    if ((bc / mStrobe) == (its_bc / mStrobe)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void ITSBeamBackgroundStudy::getClusterPatterns(gsl::span<const o2::itsmft::CompClusterExt>& ITSclus, gsl::span<const unsigned char>& ITSpatt, const o2::itsmft::TopologyDictionary& mdict)
+{
+  mPatterns.clear();
+  mPatterns.reserve(ITSclus.size());
+  auto pattIt = ITSpatt.begin();
+
+  for (unsigned int iClus{0}; iClus < ITSclus.size(); ++iClus) {
+    auto& clus = ITSclus[iClus];
+
+    auto pattID = clus.getPatternID();
+    o2::itsmft::ClusterPattern patt;
+
+    if (pattID == o2::itsmft::CompCluster::InvalidPatternID || mdict.isGroup(pattID)) {
+      patt.acquirePattern(pattIt);
+    } else {
+      patt = mdict.getPattern(pattID);
+    }
+
+    mPatterns.push_back(patt);
+  }
+}
+
+// getter
+DataProcessorSpec getITSBeamBackgroundStudy(mask_t srcTracksMask, mask_t srcClustersMask, bool useMC)
+{
+
+  // std::cout<<"DEBBUG track and clus masks "<<srcTracksMask<<" "<<srcClustersMask<<" is ZDC in tracks: "<<(srcTracksMask & GTrackID::getSourcesMask("ZDC"))<<" is ITS in clus: "<<(srcClustersMask & GTrackID::getSourcesMask("ITS"))<<std::endl;
+
+  std::vector<OutputSpec> outputs;
+  auto dataRequest = std::make_shared<DataRequest>();
+  dataRequest->requestClusters(srcClustersMask, useMC);
+  // dataRequest->requestTracks(GTrackID::getSourcesMask("ZDC"), useMC);
+
+  dataRequest->requestTracks(srcTracksMask, useMC);
+
+  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
+                                                              true,                              // GRPECS=true
+                                                              false,                             // GRPLHCIF
+                                                              false,                             // GRPMagField
+                                                              false,                             // askMatLUT
+                                                              o2::base::GRPGeomRequest::Aligned, // geometry
+                                                              dataRequest->inputs,
+                                                              true);
+  return DataProcessorSpec{
+    "its-beambkg-study",
+    dataRequest->inputs,
+    outputs,
+    AlgorithmSpec{adaptFromTask<ITSBeamBackgroundStudy>(dataRequest, ggRequest, useMC)},
+    Options{}};
+}
+
+} // namespace o2::its::study
diff --git a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx
index 8bcb444f650bd..405e80475bd25 100644
--- a/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/postprocessing/workflow/standalone-postprocessing-workflow.cxx
@@ -23,6 +23,7 @@
 #include "ITSStudies/AvgClusSize.h"
 #include "ITSStudies/PIDStudy.h"
 #include "ITSStudies/AnomalyStudy.h"
+#include "ITSStudies/ITSBeamBackgroundStudy.h"
 #include "ITSStudies/Efficiency.h"
 #include "ITSStudies/TrackCheck.h"
 #include "ITSStudies/TrackExtension.h"
@@ -43,7 +44,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<o2::framework::ConfigParamSpec> options{
     {"input-from-upstream", VariantType::Bool, false, {"read clusters from the clusterer"}},
-    {"track-sources", VariantType::String, std::string{"ITS,ITS-TPC-TRD-TOF,ITS-TPC-TOF,ITS-TPC,ITS-TPC-TRD"}, {"comma-separated list of track sources to use"}},
+    {"track-sources", VariantType::String, std::string{"ITS,ITS-TPC-TRD-TOF,ITS-TPC-TOF,ITS-TPC,ITS-TPC-TRD,ZDC"}, {"comma-separated list of track sources to use"}},
     {"cluster-sources", VariantType::String, std::string{"ITS"}, {"comma-separated list of cluster sources to use"}},
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
@@ -52,6 +53,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"track-study", VariantType::Bool, false, {"Perform the track study"}},
     {"impact-parameter-study", VariantType::Bool, false, {"Perform the impact parameter study"}},
     {"anomaly-study", VariantType::Bool, false, {"Perform the anomaly study"}},
+    {"its-beambkg-study", VariantType::Bool, false, {"Perform the ITS beam background study"}},
     {"track-extension-study", VariantType::Bool, false, {"Perform the track extension study"}},
     {"efficiency-study", VariantType::Bool, false, {"Perform the efficiency study"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
@@ -114,6 +116,17 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     }
     specs.emplace_back(o2::its::study::getAnomalyStudy(srcCls, useMC));
   }
+  if (configcontext.options().get<bool>("its-beambkg-study")) {
+    anyStudy = true;
+
+    srcCls = GID::getSourcesMask(configcontext.options().get<std::string>("cluster-sources"));
+    srcTrc = GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
+
+    if (!configcontext.options().get<bool>("input-from-upstream")) {
+      o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC, srcCls, srcTrc);
+    }
+    specs.emplace_back(o2::its::study::getITSBeamBackgroundStudy(srcTrc, srcCls, useMC));
+  }
   if (configcontext.options().get<bool>("track-extension-study")) {
     if (!useMC) {
       LOGP(fatal, "Track Extension Study needs MC!");

From 281f6ceb046bcb1647bb18361046eb7b648f099d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 24 Apr 2026 12:57:07 +0200
Subject: [PATCH 1658/1764] Make sure 16 bytes alignment is still enforced
 (#15302)

Unaligned vectorised accesses on aarch64 are not available and result in
verified sporadic crashes in the CI.
---
 GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx | 5 ++++-
 GPU/TPCFastTransformation/TPCFastTransformPOD.cxx          | 2 ++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
index 66029daeea710..68b8d302d67e4 100644
--- a/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
+++ b/GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx
@@ -147,6 +147,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     }
     size_t bufferSize = scBufferOffset + scBufferSize;
     for (int32_t is = 0; is < 3; is++) {
+      bufferSize = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
       mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + bufferSize);
       bufferSize += mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
     }
@@ -255,7 +256,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
 
   for (int32_t is = 0; is < 3; is++) {
     size_t oldCorrectionDataOffset = alignSize(oldBufferSize, SplineType::getParameterAlignmentBytes());
-    size_t correctionDataOffset = bufferSize;
+    size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
     mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
     memmove(mCorrectionData[is], mFlatBufferPtr + oldCorrectionDataOffset, mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors());
     oldBufferSize = oldCorrectionDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
@@ -508,6 +509,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   size_t bufferSize = scBufferOffsets[0] + scBufferSize;
   size_t correctionDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
+    bufferSize = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
     correctionDataOffset[is] = bufferSize;
     mSectorDataSizeBytes[is] = 0;
     for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
@@ -524,6 +526,7 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
         const SplineTypeInvYZ& splineInvYZ = reinterpret_cast<const SplineTypeInvYZ&>(spline);
         mSectorDataSizeBytes[is] += splineInvYZ.getSizeOfParameters();
       }
+      mSectorDataSizeBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
     }
     bufferSize += mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
   }
diff --git a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
index f6e61bdbbff70..e077c9144d7b4 100644
--- a/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
+++ b/GPU/TPCFastTransformation/TPCFastTransformPOD.cxx
@@ -67,6 +67,7 @@ size_t TPCFastTransformPOD::estimateSize(const TPCFastSpaceChargeCorrection& ori
   }
   // space for splines data
   for (int is = 0; is < 3; is++) {
+    nextDynOffs = FlatObject::alignSize(nextDynOffs, SplineType::getParameterAlignmentBytes());
     nextDynOffs += origCorr.mSectorDataSizeBytes[is] * TPCFastTransformGeo::getNumberOfSectors();
   }
   nextDynOffs = alignOffset(nextDynOffs);
@@ -159,6 +160,7 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
 
   // copy spline data
   for (int is = 0; is < 3; is++) {
+    nextDynOffs = FlatObject::alignSize(nextDynOffs, SplineType::getParameterAlignmentBytes());
     float* data = reinterpret_cast<float*>(buff + nextDynOffs);
     LOGP(debug, "splinID={} start offset {} -> {}", is, nextDynOffs, (void*)data);
 

From 56ddbe25f81b149aeb69495a843ee04e19dc6a2d Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 23 Apr 2026 17:40:17 +0200
Subject: [PATCH 1659/1764] Fixes in processCosmics, allow pipelining

Only cosmic tracks with at least one TRD or TOF contribution will be accepted in the tpc-refitter.

Added options for cosmics processing:
--ignore-legs-wo-outer-det will skip cosmic legs w/o TRD or TOF constraint even if other leg is well constrained
--use-cosmic-leg-timing will prefer the timestamp of each leg to (if available) for the refit, otherwise use cosmic track timestamp.

When the workflow is run with >1 lane, the streamer output XX.root of each lane will appear with suffix: XX_<lane>.root
---
 Detectors/TPC/workflow/src/TPCRefitter.cxx    | 67 +++++++++++--------
 .../workflow/src/tpc-refitter-workflow.cxx    |  7 +-
 2 files changed, 42 insertions(+), 32 deletions(-)

diff --git a/Detectors/TPC/workflow/src/TPCRefitter.cxx b/Detectors/TPC/workflow/src/TPCRefitter.cxx
index fbab4500fde5c..4b877f56c90fd 100644
--- a/Detectors/TPC/workflow/src/TPCRefitter.cxx
+++ b/Detectors/TPC/workflow/src/TPCRefitter.cxx
@@ -22,6 +22,7 @@
 #include "DetectorsBase/Propagator.h"
 #include "Framework/ConfigParamRegistry.h"
 #include "Framework/ControlService.h"
+#include "Framework/DeviceSpec.h"
 #include "Framework/Task.h"
 #include "MathUtils/Tsallis.h"
 #include "DetectorsCommonDataFormats/DetID.h"
@@ -96,6 +97,8 @@ class TPCRefitterSpec final : public Task
   int mWriteTrackClusters = 0;                                      ///< bitmask of which cluster information to dump to the tree: 0x1 = cluster native, 0x2 = corrected cluster positions, 0x4 = uncorrected cluster positions, 0x8 occupancy info
   bool mDoSampling{false};                                          ///< perform sampling of unbinned data
   bool mDoRefit{true};                                              ///< perform refit of TPC track
+  bool mIgnorLegsWOGoodTime{false};                                 ///< ignore cosmic legs w/o TRD or TOF constraint instead of using the time of other constraned leg
+  bool mUseCosmicLegTiming{false};                                  ///< use the timestamp from the cosmic track leg instead of using cosmic track timestamp
   std::vector<size_t> mClusterOccupancy;                            ///< binned occupancy of all clusters
   std::vector<size_t> mITSTPCTrackOccupanyTPCTime;                  ///< binned occupancy for ITS-TPC matched tracks using the TPC track time
   std::vector<size_t> mITSTPCTrackOccupanyCombinedTime;             ///< binned occupancy for ITS-TPC matched tracks using the combined track time
@@ -152,6 +155,9 @@ void TPCRefitterSpec::init(InitContext& ic)
   mStudyType = ic.options().get<int>("study-type");
   mWriterType = ic.options().get<int>("writer-type");
   mWriteTrackClusters = ic.options().get<int>("write-track-clusters");
+  mIgnorLegsWOGoodTime = ic.options().get<bool>("ignore-legs-wo-outer-det");
+  mUseCosmicLegTiming = ic.options().get<bool>("use-cosmic-leg-timing");
+
   const auto occBinsPerDrift = ic.options().get<uint32_t>("occupancy-bins-per-drift");
   mTimeBinsPerTF = (o2::raw::HBFUtils::Instance().nHBFPerTF * o2::constants::lhc::LHCMaxBunches) / 8 + 2 * mTimeBinsPerDrift; // add one drift before and after the TF
   mOccupancyBinsPerTF = static_cast<uint32_t>(std::ceil(float(mTimeBinsPerTF * occBinsPerDrift) / mTimeBinsPerDrift));
@@ -160,19 +166,23 @@ void TPCRefitterSpec::init(InitContext& ic)
   mITSTPCTrackOccupanyCombinedTime.resize(mOccupancyBinsPerTF);
   LOGP(info, "Using {} bins for the occupancy per TF", mOccupancyBinsPerTF);
 
+  int lane = ic.services().get<const o2::framework::DeviceSpec>().inputTimesliceId;
+  int maxLanes = ic.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices;
+  auto composeName = [maxLanes, lane](const std::string& seed) { return maxLanes > 1 ? fmt::format("{}_{}.root", seed, lane) : fmt::format("{}.root", seed); };
+
   if ((mWriterType & WriterType::Streamer) == WriterType::Streamer) {
     if ((mStudyType & StudyType::TPC) == StudyType::TPC) {
-      mDBGOutTPC = std::make_unique<o2::utils::TreeStreamRedirector>("tpctracks-study-streamer.root", "recreate");
+      mDBGOutTPC = std::make_unique<o2::utils::TreeStreamRedirector>(composeName("tpctracks-study-streamer").c_str(), "recreate");
     }
     if ((mStudyType & StudyType::ITSTPC) == StudyType::ITSTPC) {
-      mDBGOutITSTPC = std::make_unique<o2::utils::TreeStreamRedirector>("itstpctracks-study-streamer.root", "recreate");
+      mDBGOutITSTPC = std::make_unique<o2::utils::TreeStreamRedirector>(composeName("itstpctracks-study-streamer").c_str(), "recreate");
     }
     if ((mStudyType & StudyType::Cosmics) == StudyType::Cosmics) {
-      mDBGOutCosmics = std::make_unique<o2::utils::TreeStreamRedirector>("cosmics-study-streamer.root", "recreate");
+      mDBGOutCosmics = std::make_unique<o2::utils::TreeStreamRedirector>(composeName("cosmics-study-streamer").c_str(), "recreate");
     }
   }
   if (ic.options().get<bool>("dump-clusters")) {
-    mDBGOutCl = std::make_unique<o2::utils::TreeStreamRedirector>("tpc-trackStudy-cl.root", "recreate");
+    mDBGOutCl = std::make_unique<o2::utils::TreeStreamRedirector>(composeName("tpc-trackStudy-cl").c_str(), "recreate");
   }
 
   if (mXRef < 0.) {
@@ -677,35 +687,36 @@ bool TPCRefitterSpec::processTPCTrack(o2::tpc::TrackTPC tr, o2::MCCompLabel lbl,
 
 void TPCRefitterSpec::processCosmics(o2::globaltracking::RecoContainer& recoData)
 {
-  auto tof = recoData.getTOFClusters();
   const auto& par = o2::tpc::ParameterElectronics::Instance();
   const auto invBinWidth = 1.f / par.ZbinWidth;
 
   for (const auto& cosmic : mCosmics) {
     //
-    const auto& gidtop = cosmic.getRefTop();
-    const auto& gidbot = cosmic.getRefBottom();
-
-    // LOGP(info, "Sources: {} - {}", o2::dataformats::GlobalTrackID::getSourceName(gidtop.getSource()), o2::dataformats::GlobalTrackID::getSourceName(gidbot.getSource()));
-
-    std::array<GTrackID, GTrackID::NSources> contributorsGID[2] = {recoData.getSingleDetectorRefs(cosmic.getRefTop()), recoData.getSingleDetectorRefs(cosmic.getRefBottom())};
-    const auto trackTime = cosmic.getTimeMUS().getTimeStamp() * invBinWidth;
-
-    // check if track has TPC & TOF for top and bottom part
-    // loop over both parts
-    for (const auto& comsmicInfo : contributorsGID) {
-      auto& tpcGlobal = comsmicInfo[GTrackID::TPC];
-      auto& tofGlobal = comsmicInfo[GTrackID::TOF];
-      if (tpcGlobal.isIndexSet() && tofGlobal.isIndexSet()) {
-        const auto itrTPC = tpcGlobal.getIndex();
-        const auto itrTOF = tofGlobal.getIndex();
-        const auto& tofCl = tof[itrTOF];
-        const auto tofTime = tofCl.getTime() * 1e-6 * invBinWidth;       // ps -> us -> time bins
-        const auto tofTimeRaw = tofCl.getTimeRaw() * 1e-6 * invBinWidth; // ps -> us -> time bins
-        const auto& trackTPC = mTPCTracksArray[itrTPC];
-        // LOGP(info, "Cosmic time: {}, TOF time: {}, TOF time raw: {}, TPC time: {}", trackTime, tofTime, tofTimeRaw, trackTPC.getTime0());
-        processTPCTrack(trackTPC, mUseMC ? mTPCTrkLabels[itrTPC] : o2::MCCompLabel{}, mDBGOutCosmics.get(), nullptr, nullptr, false, tofTime);
+    const GTrackID gidTopBot[] = {cosmic.getRefTop(), cosmic.getRefBottom()};
+    // LOGP(info, "Sources: {} - {}", o2::dataformats::GlobalTrackID::getSourceName(gidTopBot[0].getSource()), o2::dataformats::GlobalTrackID::getSourceName(gidTopBot[1].getSource()));
+    // Wequire at least one TRD of TOF contribution to constrain the timestamp
+    bool hasGoodTime[2] = {false, false};
+    std::array<GTrackID, GTrackID::NSources> contributorsGID[2];
+    for (int i = 0; i < 2; i++) {
+      contributorsGID[i] = recoData.getSingleDetectorRefs(gidTopBot[i]);
+      hasGoodTime[i] = gidTopBot[i].includesDet(DetID::TOF) || gidTopBot[i].includesDet(DetID::TRD);
+    }
+    if (!hasGoodTime[0] && !hasGoodTime[1]) {
+      continue;
+    }
+    float trackTime = cosmic.getTimeMUS().getTimeStamp() * invBinWidth; // this time corresponds to the center of top/bottom legs time-brackers intersection, i.e. should be the most precise one
+
+    for (int i = 0; i < 2; i++) {
+      if (!contributorsGID[i][GTrackID::TPC].isSourceSet() || (mIgnorLegsWOGoodTime && !hasGoodTime[i])) {
+        continue;
+      }
+      const auto& trackTPC = mTPCTracksArray[contributorsGID[i][GTrackID::TPC]];
+      float useTrackTime = trackTime, dummyError = 0.f;
+      if (mUseCosmicLegTiming && hasGoodTime[i]) { // track out time was requested (if available)
+        recoData.getTrackTime(gidTopBot[i], useTrackTime, dummyError);
+        useTrackTime *= invBinWidth;
       }
+      processTPCTrack(trackTPC, mUseMC ? mTPCTrkLabels[contributorsGID[i][GTrackID::TPC]] : o2::MCCompLabel{}, mDBGOutCosmics.get(), nullptr, nullptr, false, useTrackTime);
     }
   }
 }
@@ -731,6 +742,8 @@ DataProcessorSpec getTPCRefitterSpec(GTrackID::mask_t srcTracks, GTrackID::mask_
     {"study-type", VariantType::Int, 1, {"Bitmask of study type: 0x1 = TPC only, 0x2 = TPC + ITS, 0x4 = Cosmics"}},
     {"writer-type", VariantType::Int, 1, {"Bitmask of writer type: 0x1 = per track streamer, 0x2 = per TF vectors"}},
     {"occupancy-bins-per-drift", VariantType::UInt32, 31u, {"number of bin for occupancy histogram per drift time (500tb)"}},
+    {"ignore-legs-wo-outer-det", VariantType::Bool, false, {"Ignore cosmic legs w/o TRD or TOF constraint even if other leg is well constrained"}},
+    {"use-cosmic-leg-timing", VariantType::Bool, false, {"Use leg-specific timestamp instead of cosmic track final timestamp"}},
   };
   auto dataRequest = std::make_shared<DataRequest>();
 
diff --git a/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx b/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
index 61c589512d1ce..567d9caf14bc6 100644
--- a/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
+++ b/Detectors/TPC/workflow/src/tpc-refitter-workflow.cxx
@@ -66,11 +66,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
   const auto enableCosmics = configcontext.options().get<bool>("enable-cosmics");
 
-  GID::mask_t allowedSourcesTrc = GID::getSourcesMask("ITS,TPC,ITS-TPC,TPC-TOF");
-  GID::mask_t allowedSourcesClus = GID::getSourcesMask("TPC,TOF");
-  if (enableCosmics) {
-    allowedSourcesTrc = allowedSourcesTrc | GID::getSourcesMask("ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
-  }
+  GID::mask_t allowedSourcesTrc = GID::getSourcesMask("TPC,ITS-TPC,TPC-TOF,TPC-TRD,ITS-TPC-TRD,TPC-TRD-TOF,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
+  GID::mask_t allowedSourcesClus = GID::getSourcesMask("TPC");
 
   GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
   GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(configcontext.options().get<std::string>("cluster-sources"));

From bda26127c37b2257861a768f1cc0e4851e3f6083 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 24 Apr 2026 15:56:26 +0200
Subject: [PATCH 1660/1764] Put back AMD origin for the metadata message
 (#15322)

---
 Framework/Core/include/Framework/AnalysisSupportHelpers.h | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/Framework/Core/include/Framework/AnalysisSupportHelpers.h b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
index 803d8cf9d4685..1c1f2dcb86a1e 100644
--- a/Framework/Core/include/Framework/AnalysisSupportHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
@@ -20,9 +20,7 @@
 
 namespace o2::framework
 {
-static constexpr std::array<header::DataOrigin, 4> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
-// static constexpr std::array<header::DataOrigin, 6> extendedAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
-// static constexpr std::array<header::DataOrigin, 4> writableAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
+static constexpr std::array<header::DataOrigin, 5> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}, header::DataOrigin{"AMD"}};
 
 class DataOutputDirector;
 struct ConfigContext;

From 40430f9321f76363deb68d9105057e7930974b80 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 24 Apr 2026 23:08:58 +0200
Subject: [PATCH 1661/1764] Revert "Put back AMD origin for the metadata
 message (#15322)" (#15325)

This reverts commit bda26127c37b2257861a768f1cc0e4851e3f6083.
---
 Framework/Core/include/Framework/AnalysisSupportHelpers.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/AnalysisSupportHelpers.h b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
index 1c1f2dcb86a1e..803d8cf9d4685 100644
--- a/Framework/Core/include/Framework/AnalysisSupportHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
@@ -20,7 +20,9 @@
 
 namespace o2::framework
 {
-static constexpr std::array<header::DataOrigin, 5> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}, header::DataOrigin{"AMD"}};
+static constexpr std::array<header::DataOrigin, 4> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
+// static constexpr std::array<header::DataOrigin, 6> extendedAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
+// static constexpr std::array<header::DataOrigin, 4> writableAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
 
 class DataOutputDirector;
 struct ConfigContext;

From 0f6d7bc1612ec326ef2c94fce1b99f75ec31b014 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 24 Apr 2026 23:39:27 +0200
Subject: [PATCH 1662/1764] DPL Analysis: fix metadata writing (#15326)

---
 Framework/AnalysisSupport/src/AODWriterHelpers.cxx        | 2 +-
 Framework/Core/include/Framework/AnalysisSupportHelpers.h | 5 ++---
 Framework/Core/src/AnalysisSupportHelpers.cxx             | 2 +-
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
index 19cf7a1ebff7b..5b5829d96a1de 100644
--- a/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODWriterHelpers.cxx
@@ -154,7 +154,7 @@ AlgorithmSpec AODWriterHelpers::getOutputTTreeWriter(ConfigContext const& ctx)
         }
 
         // skip non-AOD refs
-        if (!DataSpecUtils::partialMatch(*ref.spec, AODOrigins)) {
+        if (!DataSpecUtils::partialMatch(*ref.spec, writableAODOrigins)) {
           continue;
         }
         startTime = DataRefUtils::getHeader<DataProcessingHeader*>(ref)->startTime;
diff --git a/Framework/Core/include/Framework/AnalysisSupportHelpers.h b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
index 803d8cf9d4685..c1968123e765d 100644
--- a/Framework/Core/include/Framework/AnalysisSupportHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisSupportHelpers.h
@@ -20,9 +20,8 @@
 
 namespace o2::framework
 {
-static constexpr std::array<header::DataOrigin, 4> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
-// static constexpr std::array<header::DataOrigin, 6> extendedAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
-// static constexpr std::array<header::DataOrigin, 4> writableAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}};
+static constexpr std::array<header::DataOrigin, 5> AODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}, header::DataOrigin{"EMB"}, header::DataOrigin{"AMD"}};
+static constexpr std::array<header::DataOrigin, 3> writableAODOrigins{header::DataOrigin{"AOD"}, header::DataOrigin{"AOD1"}, header::DataOrigin{"AOD2"}};
 
 class DataOutputDirector;
 struct ConfigContext;
diff --git a/Framework/Core/src/AnalysisSupportHelpers.cxx b/Framework/Core/src/AnalysisSupportHelpers.cxx
index 4dab3b364e04d..35228bba531b0 100644
--- a/Framework/Core/src/AnalysisSupportHelpers.cxx
+++ b/Framework/Core/src/AnalysisSupportHelpers.cxx
@@ -102,7 +102,7 @@ std::shared_ptr<DataOutputDirector> AnalysisSupportHelpers::getDataOutputDirecto
         // use the dangling outputs
         std::vector<InputSpec> danglingOutputs;
         for (auto ii = 0u; ii < OutputsInputs.size(); ii++) {
-          if (DataSpecUtils::partialMatch(OutputsInputs[ii], AODOrigins) && isDangling[ii]) {
+          if (DataSpecUtils::partialMatch(OutputsInputs[ii], writableAODOrigins) && isDangling[ii]) {
             danglingOutputs.emplace_back(OutputsInputs[ii]);
           }
         }

From abdd7f12e61bcc676ec5cd13bf1d7f967458d32e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 26 Apr 2026 08:40:44 +0200
Subject: [PATCH 1663/1764] Make sure metadata exists in the generated test
 AO2D (#15323)

---
 prodtests/full_system_test.sh | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/prodtests/full_system_test.sh b/prodtests/full_system_test.sh
index 8496a31d577bc..ca83911d5fab8 100755
--- a/prodtests/full_system_test.sh
+++ b/prodtests/full_system_test.sh
@@ -340,6 +340,12 @@ for STAGE in $STAGES; do
       if [[ $aod_size -gt 0 ]]; then
         echo "AO2D file produced: AO2D.root (size: ${aod_size} bytes)"
         echo "aod_size_${STAGE},${TAG} value=${aod_size}" >> ${METRICFILE}
+        # Check that the metadata TMap is present
+        if ! root -b -l -q -e 'auto* f = TFile::Open("AO2D.root"); if (!f || f->IsZombie()) { exit(1); } if (!dynamic_cast<TMap*>(f->Get("metaData"))) { std::cerr << "ERROR: metaData TMap missing from AO2D.root" << std::endl; exit(1); }' 2>&1; then
+          echo "ERROR: metaData TMap missing from AO2D.root"
+          exit 1
+        fi
+        echo "AO2D metaData TMap present"
       else
         echo "ERROR: AO2D file (AO2D.root) exists but is empty"
         echo "aod_size_${STAGE},${TAG} value=0" >> ${METRICFILE}

From d91bd52f914c9a12fe4d29ccb0526f7fb7150d57 Mon Sep 17 00:00:00 2001
From: Gabriele Cimador <gab.cima22@gmail.com>
Date: Fri, 24 Apr 2026 21:19:14 +0200
Subject: [PATCH 1664/1764] GPU TPC: Slighly augment dynamic buffer for TPC
 Decoding

---
 GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx | 9 +++++----
 GPU/GPUTracking/Definitions/GPUSettingsList.h           | 5 ++++-
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
index e28718e6b6755..b44cdb420d74b 100644
--- a/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
+++ b/GPU/GPUTracking/DataCompression/GPUTPCDecompression.cxx
@@ -118,9 +118,10 @@ void GPUTPCDecompression::RegisterMemoryAllocation()
 void GPUTPCDecompression::SetMaxData(const GPUTrackingInOutPointers& io)
 {
   uint32_t maxAttachedClsMargin1 = *std::max_element(mInputGPU.nSliceRowClusters, mInputGPU.nSliceRowClusters + mInputGPU.nSliceRows);
-  float clsRatio1 = (mInputGPU.nUnattachedClusters > 0 ? float(mInputGPU.nAttachedClusters) / float(mInputGPU.nUnattachedClusters) : 1.0f) * 1.5f;
+  float clsRatio1 = (mInputGPU.nUnattachedClusters > 0 ? float(mInputGPU.nAttachedClusters) / float(mInputGPU.nUnattachedClusters) : 1.0f) * mRec->MemoryScalers()->tpcDecodingClusterRatioFactor1;
   maxAttachedClsMargin1 *= clsRatio1;
-  uint32_t maxAttachedClsMargin2 = mInputGPU.nSliceRows > 0 ? (mInputGPU.nAttachedClusters / mInputGPU.nSliceRows * 3.5) : 0;            // mean #attached cls per SectorRow multiplied by 3.5 (tuned)
-  mMaxNativeClustersPerBuffer = std::max({maxAttachedClsMargin1, maxAttachedClsMargin2, 1000u});                                         // take biggest margin, 1000 clusters minimum
-  mMaxNativeClustersPerBuffer = std::min(mMaxNativeClustersPerBuffer, mRec->GetProcessingSettings().tpcMaxAttachedClustersPerSectorRow); // upperbound given by configurable param
+  uint32_t maxAttachedClsMargin2 = mInputGPU.nSliceRows > 0 ? (mInputGPU.nAttachedClusters / mInputGPU.nSliceRows * mRec->MemoryScalers()->tpcDecodingClusterRatioFactor2) : 0; // mean #attached cls per SectorRow multiplied by 3.5 (tuned)
+  mMaxNativeClustersPerBuffer = std::max({maxAttachedClsMargin1, maxAttachedClsMargin2, 1000u});                                                                                // take biggest margin, 1000 clusters minimum
+  mMaxNativeClustersPerBuffer = std::min(mMaxNativeClustersPerBuffer, mRec->GetProcessingSettings().tpcMaxAttachedClustersPerSectorRow);                                        // upperbound given by configurable param
+  mMaxNativeClustersPerBuffer += mRec->MemoryScalers()->tpcDecodingSafetyBuffer;
 }
diff --git a/GPU/GPUTracking/Definitions/GPUSettingsList.h b/GPU/GPUTracking/Definitions/GPUSettingsList.h
index bbf8dbb508b4a..43a5f4f79abdc 100644
--- a/GPU/GPUTracking/Definitions/GPUSettingsList.h
+++ b/GPU/GPUTracking/Definitions/GPUSettingsList.h
@@ -297,7 +297,7 @@ AddOption(nnCCDBInteractionRate, std::string, "500", "", 0, "Distinguishes betwe
 AddHelp("help", 'h')
 EndConfig()
 
-// Settings steering the processing of NN Clusterization
+// Scaling factors for gpu buffer size estimation
 BeginSubConfig(GPUSettingsProcessingScaling, scaling, configStandalone.proc, "SCALING", 0, "Processing settings for neural network clusterizer", proc_scaling)
 AddOption(offset, float, 1000., "", 0, "Scaling Factor: offset")
 AddOption(hitOffset, float, 20000, "", 0, "Scaling Factor: hitOffset")
@@ -315,6 +315,9 @@ AddOption(tpcMergedTrackPerSectorTrack, float, 1.0, "", 0, "Scaling Factor: tpcM
 AddOption(tpcMergedTrackHitPerSectorHit, float, 1.1, "", 0, "Scaling Factor: tpcMergedTrackHitPerSectorHit")
 AddOptionArray(tpcCompressedUnattachedHitsBase1024, int32_t, 3, (900, 900, 500), "", 0, "Scaling Factor: tpcCompressedUnattachedHitsBase1024")
 AddOption(conservativeMemoryEstimate, bool, false, "", 0, "Use some more conservative defaults for larger buffers during TPC processing")
+AddOption(tpcDecodingClusterRatioFactor1, float, 1.5, "", 0, "Scaling Factor: for first margin of dynamic buffer allocation for attached clusters in TPC Decoding")
+AddOption(tpcDecodingClusterRatioFactor2, float, 3.5, "", 0, "Scaling Factor: for second margin of dynamic buffer allocation for attached clusters in TPC Decoding")
+AddOption(tpcDecodingSafetyBuffer, uint16_t, 1000, "", 0, "Scaling Factor: safety cluster buffer to add to dynamic buffer allocation for attached clusters in TPC Decoding")
 AddHelp("help", 'h')
 EndConfig()
 

From 5bfa7ec76c43de8f5e46f8d9e880d04a8f3afe4e Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 27 Apr 2026 11:17:13 +0200
Subject: [PATCH 1665/1764] ITS: fix ITSTrackROF outpu (#15328)

* ITS: fix ITSTrackROF outpu

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* TPCITS: make matcher internally consistent

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/GlobalTracking/src/MatchTPCITS.cxx  |   2 +-
 .../ITS/tracking/src/TrackingInterface.cxx    | 157 +++++++++---------
 2 files changed, 81 insertions(+), 78 deletions(-)

diff --git a/Detectors/GlobalTracking/src/MatchTPCITS.cxx b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
index 29c45edd6eb96..1457790c7c531 100644
--- a/Detectors/GlobalTracking/src/MatchTPCITS.cxx
+++ b/Detectors/GlobalTracking/src/MatchTPCITS.cxx
@@ -709,7 +709,7 @@ bool MatchTPCITS::prepareITSData()
   mITSWork.reserve(mITSTracksArray.size());
 
   // total N ITS clusters in TF
-  const auto& lastClROF = mITSClusterROFRec[nROFs - 1];
+  const auto& lastClROF = mITSClusterROFRec.back();
   int nITSClus = lastClROF.getFirstEntry() + lastClROF.getNEntries();
   mABClusterLinkIndex.resize(nITSClus, MinusOne);
   for (int sec = o2::constants::math::NSectors; sec--;) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index cc8731c8b6912..d469fa4246ef5 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -160,8 +160,27 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
   auto& allVerticesLabels = mIsMC ? pc.outputs().make<std::vector<o2::MCCompLabel>>(Output{"ITS", "VERTICESMCTR", 0}) : dummyMCLabVerts;
   auto& allVerticesPurities = mIsMC ? pc.outputs().make<std::vector<float>>(Output{"ITS", "VERTICESMCPUR", 0}) : dummyMCPurVerts;
 
+  const auto clock = mTimeFrame->getROFOverlapTableView().getClock();
+  const auto& clockLayer = mTimeFrame->getROFOverlapTableView().getClockLayer();
+  auto setBCData = [&](auto& rofs) {
+    for (size_t iROF{0}; iROF < rofs.size(); ++iROF) { // set BC data
+      auto& rof = rofs[iROF];
+      int orb = (iROF * par.getROFLengthInBC(clock) / o2::constants::lhc::LHCMaxBunches) + tfInfo.firstTForbit;
+      int bc = (iROF * par.getROFLengthInBC(clock) % o2::constants::lhc::LHCMaxBunches) + par.getROFDelayInBC(clock);
+      o2::InteractionRecord ir(bc, orb);
+      rof.setBCData(ir);
+      rof.setROFrame(iROF);
+      rof.setNEntries(0);
+      rof.setFirstEntry(-1);
+    }
+  };
+
   if (!hasClusters) {
     // skip processing if no data is received entirely but still create empty output so consumers do not wait
+    allTrackROFs.resize(clockLayer.mNROFsTF);
+    vertROFvec.resize(clockLayer.mNROFsTF);
+    setBCData(allTrackROFs);
+    setBCData(vertROFvec);
     return;
   }
 
@@ -269,86 +288,70 @@ void ITSTrackingInterface::run(framework::ProcessingContext& pc)
     if (mTimeFrame->hasBogusClusters()) {
       LOG(warning) << fmt::format(" + The processed timeframe had {} clusters with wild z coordinates, check the dictionaries", mTimeFrame->hasBogusClusters());
     }
+  }
 
-    auto& tracks = mTimeFrame->getTracks();
-    allTrackLabels.reserve(mTimeFrame->getTracksLabel().size()); // should be 0 if not MC
-    std::copy(mTimeFrame->getTracksLabel().begin(), mTimeFrame->getTracksLabel().end(), std::back_inserter(allTrackLabels));
-    {
-      // create the track to clock ROF association here
-      // the clock ROF is just the fastest ROF
-      // the number of ROFs does not necessarily reflect the actual ROFs
-      // due to possible delay of other layers, however it is guaranteed to be >=0
-      // tracks are guaranteed to be sorted here by their lower edge
-      const auto& clock = mTimeFrame->getROFOverlapTableView().getClock();
-      const auto& clockLayer = mTimeFrame->getROFOverlapTableView().getClockLayer();
-      auto setBCData = [&](auto& rofs) {
-        for (size_t iROF{0}; iROF < rofs.size(); ++iROF) { // set BC data
-          auto& rof = rofs[iROF];
-          int orb = (iROF * par.getROFLengthInBC(clock) / o2::constants::lhc::LHCMaxBunches) + tfInfo.firstTForbit;
-          int bc = (iROF * par.getROFLengthInBC(clock) % o2::constants::lhc::LHCMaxBunches) + par.getROFDelayInBC(clock);
-          o2::InteractionRecord ir(bc, orb);
-          rof.setBCData(ir);
-          rof.setROFrame(iROF);
-          rof.setNEntries(0);
-          rof.setFirstEntry(-1);
-        }
-      };
-      // we pick whatever is the largest possible number of rofs since there might be tracks/vertices which are beyond
-      // the clock layer
-      int highestROF{0};
-      for (const auto& trc : tracks) {
-        highestROF = std::max(highestROF, (int)clockLayer.getROF(trc.getTimeStamp()));
-      }
-      for (const auto& vtx : vertices) {
-        highestROF = std::max(highestROF, (int)clockLayer.getROF(vtx.getTimeStamp().lower()));
-      }
-      highestROF = std::max(highestROF, (int)clockLayer.mNROFsTF);
-      allTrackROFs.resize(highestROF);
-      vertROFvec.resize(highestROF);
-      setBCData(allTrackROFs);
-      setBCData(vertROFvec);
-
-      mTimeFrame->useMultiplictyMask(); // use multiplicty selection for IR frames
-
-      std::vector<int> rofEntries(highestROF + 1, 0);
-      for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
-        auto& trc{tracks[iTrk]};
-        trc.setFirstClusterEntry((int)allClusIdx.size()); // before adding tracks, create final cluster indices
-        int ncl = trc.getNumberOfClusters(), nclf = 0;
-        for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
-          auto clid = trc.getClusterIndex(ic);
-          if (clid >= 0) {
-            trc.setClusterSize(ic, mTimeFrame->getClusterSize((mDoStaggering) ? ic : 0, clid));
-            allClusIdx.push_back(clid);
-            nclf++;
-          }
-        }
-        assert(ncl == nclf);
-        allTracks.emplace_back(trc);
-        auto rof = clockLayer.getROF(trc.getTimeStamp());
-        ++rofEntries[rof];
-      }
-      std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
-      for (size_t iROF{0}; iROF < allTrackROFs.size(); ++iROF) {
-        allTrackROFs[iROF].setFirstEntry(rofEntries[iROF]);
-        allTrackROFs[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
-        if (mTimeFrame->getROFMaskView().isROFEnabled(clockLayerId, (int)iROF)) {
-          auto& irFrame = irFrames.emplace_back(allTrackROFs[iROF].getBCData(), allTrackROFs[iROF].getBCData() + clockLayer.mROFLength - 1);
-          irFrame.info = allTrackROFs[iROF].getNEntries();
-        }
-      }
-      // same thing for vertices rofs
-      std::fill(rofEntries.begin(), rofEntries.end(), 0);
-      for (const auto& vtx : vertices) {
-        auto rof = clockLayer.getROF(vtx.getTimeStamp().lower());
-        ++rofEntries[rof];
-      }
-      std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
-      for (size_t iROF{0}; iROF < vertROFvec.size(); ++iROF) {
-        vertROFvec[iROF].setFirstEntry(rofEntries[iROF]);
-        vertROFvec[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
+  auto& tracks = mTimeFrame->getTracks();
+  allTrackLabels.reserve(mTimeFrame->getTracksLabel().size()); // should be 0 if not MC
+  std::copy(mTimeFrame->getTracksLabel().begin(), mTimeFrame->getTracksLabel().end(), std::back_inserter(allTrackLabels));
+  // create the track to clock ROF association here
+  // the clock ROF is just the fastest ROF
+  // the number of ROFs does not necessarily reflect the actual ROFs
+  // due to possible delay of other layers, however it is guaranteed to be >=0
+  // tracks are guaranteed to be sorted here by their lower edge
+  // we pick whatever is the largest possible number of rofs since there might be tracks/vertices which are beyond
+  // the clock layer
+  int highestROF{0};
+  for (const auto& trc : tracks) {
+    highestROF = std::max(highestROF, (int)clockLayer.getROF(trc.getTimeStamp()));
+  }
+  for (const auto& vtx : vertices) {
+    highestROF = std::max(highestROF, (int)clockLayer.getROF(vtx.getTimeStamp().lower()));
+  }
+  highestROF = std::max(highestROF, (int)clockLayer.mNROFsTF);
+  allTrackROFs.resize(highestROF);
+  vertROFvec.resize(highestROF);
+  setBCData(allTrackROFs);
+  setBCData(vertROFvec);
+
+  mTimeFrame->useMultiplictyMask(); // use multiplicty selection for IR frames
+
+  std::vector<int> rofEntries(highestROF + 1, 0);
+  for (unsigned int iTrk{0}; iTrk < tracks.size(); ++iTrk) {
+    auto& trc{tracks[iTrk]};
+    trc.setFirstClusterEntry((int)allClusIdx.size()); // before adding tracks, create final cluster indices
+    int ncl = trc.getNumberOfClusters(), nclf = 0;
+    for (int ic = TrackITSExt::MaxClusters; ic--;) { // track internally keeps in->out cluster indices, but we want to store the references as out->in!!!
+      auto clid = trc.getClusterIndex(ic);
+      if (clid >= 0) {
+        trc.setClusterSize(ic, mTimeFrame->getClusterSize((mDoStaggering) ? ic : 0, clid));
+        allClusIdx.push_back(clid);
+        nclf++;
       }
     }
+    assert(ncl == nclf);
+    allTracks.emplace_back(trc);
+    auto rof = clockLayer.getROF(trc.getTimeStamp());
+    ++rofEntries[rof];
+  }
+  std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
+  for (size_t iROF{0}; iROF < allTrackROFs.size(); ++iROF) {
+    allTrackROFs[iROF].setFirstEntry(rofEntries[iROF]);
+    allTrackROFs[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
+    if (mTimeFrame->getROFMaskView().isROFEnabled(clockLayerId, (int)iROF)) {
+      auto& irFrame = irFrames.emplace_back(allTrackROFs[iROF].getBCData(), allTrackROFs[iROF].getBCData() + clockLayer.mROFLength - 1);
+      irFrame.info = allTrackROFs[iROF].getNEntries();
+    }
+  }
+  // same thing for vertices rofs
+  std::fill(rofEntries.begin(), rofEntries.end(), 0);
+  for (const auto& vtx : vertices) {
+    auto rof = clockLayer.getROF(vtx.getTimeStamp().lower());
+    ++rofEntries[rof];
+  }
+  std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
+  for (size_t iROF{0}; iROF < vertROFvec.size(); ++iROF) {
+    vertROFvec[iROF].setFirstEntry(rofEntries[iROF]);
+    vertROFvec[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
   }
 
   LOGP(info, "ITSTracker pushed {} tracks in {} rofs and {} vertices {}", allTracks.size(), allTrackROFs.size(), vertices.size(), ((mDoStaggering) ? "in staggered-readout mode" : ""));

From 2cc88ed03e8ece02aa38da697508837ea465f894 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 27 Apr 2026 10:59:42 +0200
Subject: [PATCH 1666/1764] Fix typo in GPUTPCGMMerger::MergedTrackStreamer

---
 GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
index 9ee2bcf4eb6b5..9f6858df4d3f2 100644
--- a/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
+++ b/GPU/GPUTracking/Merger/GPUTPCGMMergerDump.cxx
@@ -289,7 +289,7 @@ inline void GPUTPCGMMerger::MergedTrackStreamerInternal(const GPUTPCGMBorderTrac
 void GPUTPCGMMerger::MergedTrackStreamer(const GPUTPCGMBorderTrack& b1, const GPUTPCGMBorderTrack& b2, const char* name, int32_t sector1, int32_t sector2, uint8_t mergeMode, float weight, float frac) const
 {
 #ifdef DEBUG_STREAMER
-  if (!(mergeMode & mergeModes::mergeAcrossCE0)) {
+  if (!(mergeMode & mergeModes::mergeAcrossCE)) {
     MergedTrackStreamerInternal<0>(b1, b2, name, sector1, sector2, mergeMode, weight, frac);
   }
 #endif

From 5dfe60ee3b74a7cebe3233e7445e9ffdff98da53 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Mon, 27 Apr 2026 23:45:18 +0200
Subject: [PATCH 1667/1764] DPL: boost::property_tree::json_parser::write_json
 no longer adds EoL (#15333)

---
 Framework/Core/src/DataProcessingDevice.cxx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index b062f2bf68a75..2bc01df7c0260 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -402,7 +402,6 @@ void DataProcessingDevice::Init()
     if (entry.second.empty() == false) {
       boost::property_tree::json_parser::write_json(ss, entry.second, false);
       str = ss.str();
-      str.pop_back(); // remove EoL
     } else {
       str = entry.second.get_value<std::string>();
     }

From 75f2eef3bf0325d7945d912f77dd0df13d1fa81f Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 27 Apr 2026 18:16:01 +0200
Subject: [PATCH 1668/1764] Fix sign of the tgL in ITS seeding

---
 .../ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h     | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
index 584d28a3cd9a8..2224495607ee1 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
@@ -80,8 +80,7 @@ GPUdi() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
     q2pt = sign * crv / (bz * o2::constants::math::B2C);
     q2pt2 = crv * crv;
   }
-  const float tgl = 0.5f * (math_utils::computeTanDipAngle(x1, y1, x2, y2, cluster1.zCoordinate, cluster2.zCoordinate) +
-                            math_utils::computeTanDipAngle(x2, y2, x3, y3, cluster2.zCoordinate, tf3.positionTrackingFrame[1]));
+  const float tgl = -0.5f * sign * (math_utils::computeTanDipAngle(x1, y1, x2, y2, cluster1.zCoordinate, cluster2.zCoordinate) + math_utils::computeTanDipAngle(x2, y2, x3, y3, cluster2.zCoordinate, tf3.positionTrackingFrame[1]));
   const float sg2q2pt = o2::track::kC1Pt2max * o2::gpu::CAMath::Clamp(q2pt2, 0.0005f, 1.0f);
   return {x3, tf3.alphaTrackingFrame, {y3, tf3.positionTrackingFrame[1], snp, tgl, q2pt}, {tf3.covarianceTrackingFrame[0], tf3.covarianceTrackingFrame[1], tf3.covarianceTrackingFrame[2], 0.f, 0.f, o2::track::kCSnp2max, 0.f, 0.f, 0.f, o2::track::kCTgl2max, 0.f, 0.f, 0.f, 0.f, sg2q2pt}};
 }

From f3a09eadecd35b9e01e4b5632d1aa047f9fc2fa1 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 28 Apr 2026 10:21:04 +0200
Subject: [PATCH 1669/1764] DPL: improve messages about missing resources
 (#15330)

---
 .../Framework/ComputingQuotaEvaluator.h       |  4 ++-
 .../Core/include/Framework/ResourcePolicy.h   |  3 ++
 .../Core/src/ComputingQuotaEvaluator.cxx      | 15 +++++---
 Framework/Core/src/DataProcessingDevice.cxx   | 36 ++++++++++++++++---
 Framework/Core/src/ResourcePolicyHelpers.cxx  | 13 ++++---
 5 files changed, 56 insertions(+), 15 deletions(-)

diff --git a/Framework/Core/include/Framework/ComputingQuotaEvaluator.h b/Framework/Core/include/Framework/ComputingQuotaEvaluator.h
index 17ce9c2ba3e65..b25bc1611d79f 100644
--- a/Framework/Core/include/Framework/ComputingQuotaEvaluator.h
+++ b/Framework/Core/include/Framework/ComputingQuotaEvaluator.h
@@ -37,7 +37,9 @@ class ComputingQuotaEvaluator
   /// @a task the task which needs some quota
   /// @a request the resource request the @a task needs
   /// @a now the time (e.g. uv_now) when invoked.
-  bool selectOffer(int task, ComputingQuotaRequest const& request, uint64_t now);
+  /// @a accumulated if non-null, filled with the resources accumulated from
+  ///    selected offers (useful for diagnosing shortfalls on failure).
+  bool selectOffer(int task, ComputingQuotaRequest const& request, uint64_t now, ComputingQuotaOffer* accumulated = nullptr);
   /// Consume offers for a given taskId
   /// @a reportConsumedOffer callback which reports back that an offer has been consumed.
   void consume(int taskId,
diff --git a/Framework/Core/include/Framework/ResourcePolicy.h b/Framework/Core/include/Framework/ResourcePolicy.h
index eb8d77b209a8f..1062c223b07f6 100644
--- a/Framework/Core/include/Framework/ResourcePolicy.h
+++ b/Framework/Core/include/Framework/ResourcePolicy.h
@@ -31,6 +31,9 @@ struct ResourcePolicy {
   std::string name;
   Matcher matcher;
   ComputingQuotaRequest request;
+  /// Minimum resources required to run. Used to report which resources
+  /// are missing when scheduling fails.
+  ComputingQuotaOffer minRequired;
 };
 
 } // namespace o2::framework
diff --git a/Framework/Core/src/ComputingQuotaEvaluator.cxx b/Framework/Core/src/ComputingQuotaEvaluator.cxx
index 3f5bff2b53fab..5dd4249cab519 100644
--- a/Framework/Core/src/ComputingQuotaEvaluator.cxx
+++ b/Framework/Core/src/ComputingQuotaEvaluator.cxx
@@ -62,7 +62,7 @@ struct QuotaEvaluatorStats {
   std::vector<int> expired;
 };
 
-bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const& selector, uint64_t now)
+bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const& selector, uint64_t now, ComputingQuotaOffer* outAccumulated)
 {
   O2_SIGNPOST_ID_GENERATE(qid, quota);
 
@@ -102,10 +102,13 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
       }
       dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCES_SATISFACTORY), DataProcessingStats::Op::Add, 1});
     } else {
-      O2_SIGNPOST_START(quota, sid, "summary", "Not enough resources to select offers.");
-      dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCES_MISSING), DataProcessingStats::Op::Add, 1});
       if (result.size()) {
+        O2_SIGNPOST_START(quota, sid, "summary", "Not enough resources: accumulated %zu partial offers providing cpu=%d, memory=%lld MB, shared memory=%lld MB, timeslices=%lld, but still insufficient.",
+                          result.size(), totalOffer.cpu, totalOffer.memory / 1000000, totalOffer.sharedMemory / 1000000, totalOffer.timeslices);
         dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCES_INSUFFICIENT), DataProcessingStats::Op::Add, 1});
+      } else {
+        O2_SIGNPOST_START(quota, sid, "summary", "Not enough resources: no suitable offers found (all offers were invalid, expired, or owned by other tasks).");
+        dpStats.updateStats({static_cast<short>(ProcessingStatsId::RESOURCES_MISSING), DataProcessingStats::Op::Add, 1});
       }
     }
     if (stats.invalidOffers.size()) {
@@ -205,7 +208,11 @@ bool ComputingQuotaEvaluator::selectOffer(int task, ComputingQuotaRequest const&
       O2_SIGNPOST_EVENT_EMIT(quota, tid, "select", "Offer should be expired by now, checking again."); }, minValidity + 100, 0);
   }
   // If we get here it means we never got enough offers, so we return false.
-  return summarizeWhatHappended(enough, stats.selectedOffers, accumulated, stats);
+  bool result = summarizeWhatHappended(enough, stats.selectedOffers, accumulated, stats);
+  if (outAccumulated) {
+    *outAccumulated = accumulated;
+  }
+  return result;
 }
 
 void ComputingQuotaEvaluator::consume(int id, ComputingQuotaConsumer& consumer, std::function<void(ComputingQuotaOffer const& accumulatedConsumed, ComputingQuotaStats& reportConsumedOffer)>& reportConsumedOffer)
diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 2bc01df7c0260..8677aaa42a363 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1370,7 +1370,8 @@ void DataProcessingDevice::Run()
       // the evaluator. In this case, the request is always satisfied and
       // we run on whatever resource is available.
       auto& spec = ref.get<DeviceSpec const>();
-      bool enough = ref.get<ComputingQuotaEvaluator>().selectOffer(streamRef.index, spec.resourcePolicy.request, uv_now(state.loop));
+      ComputingQuotaOffer accumulated;
+      bool enough = ref.get<ComputingQuotaEvaluator>().selectOffer(streamRef.index, spec.resourcePolicy.request, uv_now(state.loop), &accumulated);
 
       struct SchedulingStats {
         std::atomic<size_t> lastScheduled = 0;
@@ -1398,17 +1399,42 @@ void DataProcessingDevice::Run()
           run_completion(&handle, 0);
         }
       } else {
+        auto const lastSched = schedulingStats.lastScheduled.load();
+        auto const schedInfo = lastSched ? fmt::format(", last scheduled {} ms ago", uv_now(state.loop) - lastSched) : std::string(", never successfully scheduled");
+        auto const buildMissingInfo = [&]() {
+          auto const& required = spec.resourcePolicy.minRequired;
+          std::string missingInfo;
+          if (required.sharedMemory > 0 && accumulated.sharedMemory < required.sharedMemory) {
+            missingInfo += fmt::format(" shared memory (have {} MB, need {} MB)", accumulated.sharedMemory / 1000000, required.sharedMemory / 1000000);
+          }
+          if (required.timeslices > 0 && accumulated.timeslices < required.timeslices) {
+            missingInfo += fmt::format(" timeslices (have {}, need {})", accumulated.timeslices, required.timeslices);
+          }
+          if (required.cpu > 0 && accumulated.cpu < required.cpu) {
+            missingInfo += fmt::format(" CPU cores (have {}, need {})", accumulated.cpu, required.cpu);
+          }
+          if (required.memory > 0 && accumulated.memory < required.memory) {
+            missingInfo += fmt::format(" memory (have {} MB, need {} MB)", accumulated.memory / 1000000, required.memory / 1000000);
+          }
+          return missingInfo.empty() ? std::string(" (policy: ") + spec.resourcePolicy.name + ")" : " -" + missingInfo;
+        };
         if (schedulingStats.numberOfUnscheduledSinceLastScheduled >= schedulingStats.nextWarnAt) {
+          auto const missingStr = buildMissingInfo();
           O2_SIGNPOST_EVENT_EMIT_WARN(scheduling, sid, "Run",
-                                      "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu. Data is not lost and it will be scheduled again.",
+                                      "Not enough resources to schedule computation on stream %d. %zu consecutive skips%s. Missing:%s. Data is not lost and it will be scheduled again.",
+                                      streamRef.index,
                                       schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
-                                      schedulingStats.lastScheduled.load());
+                                      schedInfo.c_str(),
+                                      missingStr.c_str());
           schedulingStats.nextWarnAt = schedulingStats.nextWarnAt * 2;
         } else {
+          auto const missingStr = buildMissingInfo();
           O2_SIGNPOST_EVENT_EMIT(scheduling, sid, "Run",
-                                 "Not enough resources to schedule computation. %zu skipped so far. Last scheduled at %zu. Data is not lost and it will be scheduled again.",
+                                 "Not enough resources to schedule computation on stream %d. %zu consecutive skips%s. Missing:%s. Data is not lost and it will be scheduled again.",
+                                 streamRef.index,
                                  schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
-                                 schedulingStats.lastScheduled.load());
+                                 schedInfo.c_str(),
+                                 missingStr.c_str());
         }
         schedulingStats.numberOfUnscheduled++;
         schedulingStats.numberOfUnscheduledSinceLastScheduled++;
diff --git a/Framework/Core/src/ResourcePolicyHelpers.cxx b/Framework/Core/src/ResourcePolicyHelpers.cxx
index 2c5c4f54dd9b5..650beec3ac599 100644
--- a/Framework/Core/src/ResourcePolicyHelpers.cxx
+++ b/Framework/Core/src/ResourcePolicyHelpers.cxx
@@ -36,7 +36,8 @@ ResourcePolicy ResourcePolicyHelpers::cpuBoundTask(char const* s, int requestedC
     [matcher = std::regex(s)](DeviceSpec const& spec) -> bool {
       return std::regex_match(spec.name, matcher);
     },
-    [requestedCPUs](ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated) -> OfferScore { return accumulated.cpu >= requestedCPUs ? OfferScore::Enough : OfferScore::More; }};
+    [requestedCPUs](ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated) -> OfferScore { return accumulated.cpu >= requestedCPUs ? OfferScore::Enough : OfferScore::More; },
+    ComputingQuotaOffer{.cpu = requestedCPUs}};
 }
 
 ResourcePolicy ResourcePolicyHelpers::rateLimitedSharedMemoryBoundTask(char const* s, int requestedSharedMemory, int requestedTimeslices)
@@ -46,7 +47,7 @@ ResourcePolicy ResourcePolicyHelpers::rateLimitedSharedMemoryBoundTask(char cons
     [matcher = std::regex(s)](DeviceSpec const& spec) -> bool {
       return std::regex_match(spec.name, matcher);
     },
-    [requestedSharedMemory, requestedTimeslices](ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated) -> OfferScore { 
+    [requestedSharedMemory, requestedTimeslices](ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated) -> OfferScore {
       // If we have enough memory and not enough timeslices,
       // ignore further shared memory.
       if (accumulated.sharedMemory >= requestedSharedMemory && offer.timeslices == 0) {
@@ -66,7 +67,8 @@ ResourcePolicy ResourcePolicyHelpers::rateLimitedSharedMemoryBoundTask(char cons
         return OfferScore::Enough;
       }
       // We need more resources
-      return OfferScore::More; }};
+      return OfferScore::More; },
+    ComputingQuotaOffer{.sharedMemory = requestedSharedMemory, .timeslices = requestedTimeslices}};
 }
 
 ResourcePolicy ResourcePolicyHelpers::sharedMemoryBoundTask(char const* s, int requestedSharedMemory)
@@ -76,11 +78,12 @@ ResourcePolicy ResourcePolicyHelpers::sharedMemoryBoundTask(char const* s, int r
     [matcher = std::regex(s)](DeviceSpec const& spec) -> bool {
       return std::regex_match(spec.name, matcher);
     },
-    [requestedSharedMemory](ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated) -> OfferScore { 
+    [requestedSharedMemory](ComputingQuotaOffer const& offer, ComputingQuotaOffer const& accumulated) -> OfferScore {
       if (offer.sharedMemory == 0) {
         return OfferScore::Unneeded;
       }
-      return (accumulated.sharedMemory + offer.sharedMemory)>= requestedSharedMemory ? OfferScore::Enough : OfferScore::More; }};
+      return (accumulated.sharedMemory + offer.sharedMemory) >= requestedSharedMemory ? OfferScore::Enough : OfferScore::More; },
+    ComputingQuotaOffer{.sharedMemory = requestedSharedMemory}};
 }
 
 } // namespace o2::framework

From 4bd0da6880f3495451cca41ea7fbdad0e831b1d2 Mon Sep 17 00:00:00 2001
From: Sandro Wenzel <sandro.wenzel@cern.ch>
Date: Mon, 27 Apr 2026 15:18:01 +0200
Subject: [PATCH 1670/1764] CollisionContextTool: Ability to use
 o2::ft0::EventsPerBC calib object

---
 .../FIT/FT0/include/DataFormatsFT0/EventsPerBc.h    | 13 +++++++++++++
 Steer/CMakeLists.txt                                |  2 +-
 Steer/src/CollisionContextTool.cxx                  | 11 ++++++++---
 3 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/EventsPerBc.h b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/EventsPerBc.h
index 9fcd1318914bd..632eac342fdc9 100644
--- a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/EventsPerBc.h
+++ b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/EventsPerBc.h
@@ -14,11 +14,24 @@
 
 #include "CommonConstants/LHCConstants.h"
 #include <Rtypes.h>
+#include <TH1F.h>
+#include <memory>
 
 namespace o2::ft0
 {
 struct EventsPerBc {
   std::array<double, o2::constants::lhc::LHCMaxBunches> histogram;
+
+  std::unique_ptr<TH1F> toTH1F(const char* name = "eventsPerBc") const
+  {
+    constexpr int N = o2::constants::lhc::LHCMaxBunches;
+    auto h = std::make_unique<TH1F>(name, name, N, 0, N);
+    for (int i = 0; i < N; ++i) {
+      h->SetBinContent(i + 1, histogram[i]);
+    }
+    return h;
+  }
+
   ClassDefNV(EventsPerBc, 1);
 };
 } // namespace o2::ft0
diff --git a/Steer/CMakeLists.txt b/Steer/CMakeLists.txt
index 8e2706d31bb0a..0d7f300c5513e 100644
--- a/Steer/CMakeLists.txt
+++ b/Steer/CMakeLists.txt
@@ -23,7 +23,7 @@ o2_add_library(Steer
 o2_add_executable(colcontexttool
                   COMPONENT_NAME steer
                   SOURCES src/CollisionContextTool.cxx
-                  PUBLIC_LINK_LIBRARIES Boost::program_options O2::Algorithm O2::Steer O2::SimulationDataFormat)
+                  PUBLIC_LINK_LIBRARIES Boost::program_options O2::Algorithm O2::Steer O2::SimulationDataFormat O2::DataFormatsFT0)
 
 o2_target_root_dictionary(Steer
                           HEADERS include/Steer/HitProcessingManager.h
diff --git a/Steer/src/CollisionContextTool.cxx b/Steer/src/CollisionContextTool.cxx
index 6bee407c01264..e97eeada3fd0c 100644
--- a/Steer/src/CollisionContextTool.cxx
+++ b/Steer/src/CollisionContextTool.cxx
@@ -19,6 +19,7 @@
 #include "DataFormatsCalibration/MeanVertexObject.h"
 #include "SimulationDataFormat/DigitizationContext.h"
 #include "SimConfig/InteractionDiamondParam.h"
+#include "DataFormatsFT0/EventsPerBc.h"
 #include <cmath>
 #include <TRandom.h>
 #include <numeric>
@@ -424,7 +425,7 @@ int main(int argc, char* argv[])
     auto mode = ispecs[id].syncmode;
     if (mode == InteractionLockMode::NOLOCK) {
       auto sampler = std::make_unique<o2::steer::InteractionSampler>();
-      TH1F* mu_hist = nullptr;
+      std::unique_ptr<TH1F> mu_hist;
 
       // we check if there is a realistic bunch crossing distribution available
       const auto& mu_distr_source = options.nontrivial_mu_distribution;
@@ -441,7 +442,11 @@ int main(int argc, char* argv[])
             ccdb_inst.setFatalWhenNull(false);
             auto local_hist = ccdb_inst.getForTimeStamp<TH1F>(ccdb_info.fullPath, options.timestamp);
             if (local_hist) {
-              mu_hist = (TH1F*)(local_hist->Clone("h2")); // we need to clone since ownership of local_hist is with TFile
+              // case in which CCDB object contains directly a ROOT histogram
+              mu_hist.reset((TH1F*)local_hist->Clone("h2")); // we need to clone since ownership of local_hist is with TFile
+            } else if (auto events_per_bc = ccdb_inst.getForTimeStamp<o2::ft0::EventsPerBc>(ccdb_info.fullPath, options.timestamp)) {
+              // case in which CCDB object is from FT0 EventsPerBC calib (will be default)
+              mu_hist = events_per_bc->toTH1F();
             } else {
               LOG(warn) << "No mu(bc) distribution found on CCDB. Using uniform one";
             }
@@ -451,7 +456,7 @@ int main(int argc, char* argv[])
           auto mudistr_file = TFile::Open(mu_distr_source.c_str(), "OPEN");
           if (mudistr_file && !mudistr_file->IsZombie()) {
             auto local_hist = mudistr_file->Get<TH1F>("hBcTVX");
-            mu_hist = (TH1F*)(local_hist->Clone("h2")); // we need to clone since ownership of local_hist is with TFile
+            mu_hist.reset((TH1F*)local_hist->Clone("h2")); // we need to clone since ownership of local_hist is with TFile
             mudistr_file->Close();
           }
         }

From 2ab49d25cbff7f5980f4e974b636737489addc8f Mon Sep 17 00:00:00 2001
From: pillot <pillot@subatech.in2p3.fr>
Date: Thu, 27 Nov 2025 10:24:58 +0100
Subject: [PATCH 1671/1764] filter trackable ROFs at clustering level

---
 .../MUON/MCH/Base/include/MCHBase/Trackable.h | 12 ++++++-
 Detectors/MUON/MCH/Base/src/Trackable.cxx     | 22 ++++++++++++
 .../include/MCHClustering/ClusterizerParam.h  |  2 ++
 .../include/MCHROFFiltering/TrackableFilter.h | 28 ++++++++++++++-
 Detectors/MUON/MCH/Workflow/CMakeLists.txt    |  1 +
 .../src/ClusterFinderOriginalSpec.cxx         | 35 ++++++++++++++++---
 6 files changed, 94 insertions(+), 6 deletions(-)

diff --git a/Detectors/MUON/MCH/Base/include/MCHBase/Trackable.h b/Detectors/MUON/MCH/Base/include/MCHBase/Trackable.h
index a862be411cb35..ef556d49a9201 100644
--- a/Detectors/MUON/MCH/Base/include/MCHBase/Trackable.h
+++ b/Detectors/MUON/MCH/Base/include/MCHBase/Trackable.h
@@ -38,11 +38,21 @@ bool isTrackable(std::array<int, 10> itemsPerChamber,
 /** Return the number of items per chamber.
  *
  * @tparam T the type of items : implementation exists so far
- * only for mch::Digit (clusters and pre-clusters to come next)
+ * for deIds (int) and mch::Digit
  */
 template <typename T>
 std::array<int, 10> perChamber(gsl::span<const T> items);
 
+/** Return the number of items per chamber.
+ *
+ * @tparam T1 the type of items : implementation exists so far
+ * for mch::PreCluster
+ * @tparam T2 the type of subitems pointed to by items,
+ * e.g. mch::Digit attached to mch::PreCluster
+ */
+template <typename T1, typename T2>
+std::array<int, 10> perChamber(gsl::span<const T1> items, gsl::span<const T2> subitems);
+
 /** Return the number of items per station (1 station==2 chambers). */
 template <typename T>
 std::array<int, 5> perStation(gsl::span<const T> items)
diff --git a/Detectors/MUON/MCH/Base/src/Trackable.cxx b/Detectors/MUON/MCH/Base/src/Trackable.cxx
index c25b12945cb90..0545f7cb1eac5 100644
--- a/Detectors/MUON/MCH/Base/src/Trackable.cxx
+++ b/Detectors/MUON/MCH/Base/src/Trackable.cxx
@@ -10,7 +10,9 @@
 // or submit itself to any jurisdiction.
 
 #include "MCHBase/Trackable.h"
+
 #include "DataFormatsMCH/Digit.h"
+#include "MCHBase/PreCluster.h"
 
 namespace o2::mch
 {
@@ -59,7 +61,27 @@ std::array<int, 10> perChamber(gsl::span<const Digit> digits)
   for (const auto& digit : digits) {
     nofDigits[digit.getDetID() / 100 - 1]++;
   }
+  // do not count isolated digits (at least 2 are required for a cluster)
+  for (auto i = 0; i < 10; ++i) {
+    if (nofDigits[i] == 1) {
+      nofDigits[i] = 0;
+    }
+  }
   return nofDigits;
 }
 
+/** Specialization of perChamber for PreClusters */
+template <>
+std::array<int, 10> perChamber(gsl::span<const PreCluster> preclusters, gsl::span<const Digit> digits)
+{
+  std::array<int, 10> nofPreclusters{};
+  for (const auto& precluster : preclusters) {
+    // only consider preclusters made of at least 2 digits
+    if (precluster.nDigits > 1) {
+      nofPreclusters[digits[precluster.firstDigit].getDetID() / 100 - 1]++;
+    }
+  }
+  return nofPreclusters;
+}
+
 } // namespace o2::mch
diff --git a/Detectors/MUON/MCH/Clustering/include/MCHClustering/ClusterizerParam.h b/Detectors/MUON/MCH/Clustering/include/MCHClustering/ClusterizerParam.h
index a24a8543af2cb..8f6f28a1f45d7 100644
--- a/Detectors/MUON/MCH/Clustering/include/MCHClustering/ClusterizerParam.h
+++ b/Detectors/MUON/MCH/Clustering/include/MCHClustering/ClusterizerParam.h
@@ -37,6 +37,8 @@ struct ClusterizerParam : public o2::conf::ConfigurableParamHelper<ClusterizerPa
 
   bool legacy = true; ///< use original (run2) clustering
 
+  bool onlyTrackable = true; ///< clusterize only ROFs that match the trackable condition @see MCHROFFiltering/TrackableFilter
+
   O2ParamDef(ClusterizerParam, "MCHClustering");
 };
 
diff --git a/Detectors/MUON/MCH/ROFFiltering/include/MCHROFFiltering/TrackableFilter.h b/Detectors/MUON/MCH/ROFFiltering/include/MCHROFFiltering/TrackableFilter.h
index c1f11f2d40e5c..68efedfc4b89d 100644
--- a/Detectors/MUON/MCH/ROFFiltering/include/MCHROFFiltering/TrackableFilter.h
+++ b/Detectors/MUON/MCH/ROFFiltering/include/MCHROFFiltering/TrackableFilter.h
@@ -33,7 +33,6 @@ namespace o2::mch
  *
  * @tparam : the type of the items pointed to by the ROFRecords
  */
-
 template <typename T>
 ROFFilter
   createTrackableFilter(gsl::span<const T> items,
@@ -46,6 +45,33 @@ ROFFilter
   };
 }
 
+/** Returns a ROFRecord filter that selects ROFs that are trackable.
+ *
+ * The returned filter is a function that takes a ROFRecord and returns
+ * a boolean.
+ *
+ * @param items : the items "pointed to" by the ROFRecords (preclusters, ...)
+ * @param subitems : the subitems "pointed to" by the items (digits, ...)
+ *
+ * @param requestStation : @ref isTrackable
+ * @param moreCandidates : @ref isTrackable
+ *
+ * @tparam T1 : the type of the items pointed to by the ROFRecords
+ * @tparam T2 : the type of the subitems pointed to by the items
+ */
+template <typename T1, typename T2>
+ROFFilter
+  createTrackableFilter(gsl::span<const T1> items,
+                        gsl::span<const T2> subitems,
+                        std::array<bool, 5> requestStation = {true, true, true, true, true},
+                        bool moreCandidates = false)
+{
+  return [items, subitems, requestStation, moreCandidates](const ROFRecord& rof) {
+    std::array<int, 10> nofItemsPerChamber = perChamber(items.subspan(rof.getFirstIdx(), rof.getNEntries()), subitems);
+    return isTrackable(nofItemsPerChamber, requestStation, moreCandidates);
+  };
+}
+
 } // namespace o2::mch
 
 #endif
diff --git a/Detectors/MUON/MCH/Workflow/CMakeLists.txt b/Detectors/MUON/MCH/Workflow/CMakeLists.txt
index e0fce7d103df7..f97c78526f21e 100644
--- a/Detectors/MUON/MCH/Workflow/CMakeLists.txt
+++ b/Detectors/MUON/MCH/Workflow/CMakeLists.txt
@@ -30,6 +30,7 @@ o2_add_library(MCHWorkflow
                    O2::MCHPreClustering
                    O2::MCHRawCommon
                    O2::MCHRawDecoder
+                   O2::MCHROFFiltering
                    ROOT::TreePlayer
                )
 
diff --git a/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx b/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
index 8344d2837b814..e369e514b0f2e 100644
--- a/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
+++ b/Detectors/MUON/MCH/Workflow/src/ClusterFinderOriginalSpec.cxx
@@ -35,13 +35,16 @@
 #include "Framework/Logger.h"
 
 #include "CommonUtils/ConfigurableParam.h"
-#include "DataFormatsMCH/ROFRecord.h"
+#include "DataFormatsMCH/Cluster.h"
 #include "DataFormatsMCH/Digit.h"
+#include "DataFormatsMCH/ROFRecord.h"
 #include "MCHBase/Error.h"
 #include "MCHBase/ErrorMap.h"
 #include "MCHBase/PreCluster.h"
-#include "DataFormatsMCH/Cluster.h"
+#include "MCHBase/TrackerParam.h"
 #include "MCHClustering/ClusterFinderOriginal.h"
+#include "MCHClustering/ClusterizerParam.h"
+#include "MCHROFFiltering/TrackableFilter.h"
 
 namespace o2
 {
@@ -94,11 +97,35 @@ class ClusterFinderOriginalTask
     auto& clusters = pc.outputs().make<std::vector<Cluster>>(OutputRef{"clusters"});
     auto& usedDigits = pc.outputs().make<std::vector<Digit>>(OutputRef{"clusterdigits"});
 
+    // create the trackable ROF filtering if needed
+    ROFFilter trackable{};
+    if (ClusterizerParam::Instance().onlyTrackable) {
+      const auto& trackerParam = TrackerParam::Instance();
+      std::array<bool, 5> requestStation{
+        trackerParam.requestStation[0],
+        trackerParam.requestStation[1],
+        trackerParam.requestStation[2],
+        trackerParam.requestStation[3],
+        trackerParam.requestStation[4]};
+      trackable = createTrackableFilter(preClusters, digits, requestStation, trackerParam.moreCandidates);
+    }
+
     clusterROFs.reserve(preClusterROFs.size());
     auto& errorMap = mClusterFinder.getErrorMap();
     errorMap.clear();
+    int nFilteredRofs = 0;
+    int nFilteredPreClusters = 0;
     for (const auto& preClusterROF : preClusterROFs) {
 
+      // filter out non-trackable ROFs if requested
+      if (ClusterizerParam::Instance().onlyTrackable && !trackable(preClusterROF)) {
+        // create an empty cluster ROF
+        clusterROFs.emplace_back(preClusterROF.getBCData(), clusters.size(), 0, preClusterROF.getBCWidth());
+        continue;
+      }
+      ++nFilteredRofs;
+      nFilteredPreClusters += preClusterROF.getNEntries();
+
       // prepare to clusterize the current ROF
       auto clusterOffset = clusters.size();
       mClusterFinder.reset();
@@ -137,8 +164,8 @@ class ClusterFinderOriginalTask
     });
     mErrorMap.add(errorMap);
 
-    LOGP(info, "Found {:4d} clusters from {:4d} preclusters in {:2d} ROFs",
-         clusters.size(), preClusters.size(), preClusterROFs.size());
+    LOGP(info, "Found {:4d} clusters from {:4d} preclusters (out of {:4d}) in {:2d} filtered ROFs (out of {:2d})",
+         clusters.size(), nFilteredPreClusters, preClusters.size(), nFilteredRofs, preClusterROFs.size());
   }
 
  private:

From 7b7c9fa9a21921d35ccc5b8066e6dd3d27fc9599 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Tue, 28 Apr 2026 11:33:56 +0200
Subject: [PATCH 1672/1764] DPL Analysis: fix analysis CCDB fetcher still using
 origin

---
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   |  3 +-
 Framework/Core/include/Framework/ASoA.h       | 68 +++++++++++--------
 2 files changed, 40 insertions(+), 31 deletions(-)

diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index 3892f200645f6..c65ef2903db59 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -48,8 +48,7 @@ namespace
 void fillValidRoutes(CCDBFetcherHelper& helper, std::vector<o2::framework::OutputRoute> const& outputRoutes, std::unordered_map<std::string, int>& bindings)
 {
   for (auto& route : outputRoutes) {
-    auto originMatcher = DataSpecUtils::asConcreteDataMatcher(route.matcher);
-    if (originMatcher.origin != header::DataOrigin{"ATIM"}) {
+    if (std::ranges::none_of(route.matcher.metadata, [](auto const& m) { return m.name.starts_with("ccdb:"); })) {
       continue;
     }
     auto specStr = DataSpecUtils::describe(route.matcher);
diff --git a/Framework/Core/include/Framework/ASoA.h b/Framework/Core/include/Framework/ASoA.h
index 1628ec2039483..fc17fa139875c 100644
--- a/Framework/Core/include/Framework/ASoA.h
+++ b/Framework/Core/include/Framework/ASoA.h
@@ -3407,38 +3407,48 @@ consteval auto getIndexTargets()
 //
 // The columns of this table have to be CCDB_COLUMNS so that for each timestamp, we get a row
 // which points to the specified CCDB objectes described by those columns.
-#define DECLARE_SOA_TIMESTAMPED_TABLE_FULL(_Name_, _Label_, _TimestampSource_, _TimestampColumn_, _Origin_, _Version_, _Desc_, ...) \
-  O2HASH(_Desc_ "/" #_Version_);                                                                                                    \
-  template <typename O>                                                                                                             \
-  using _Name_##TimestampFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>;              \
-  using _Name_##Timestamp = _Name_##TimestampFrom<o2::aod::Hash<_Origin_ ""_h>>;                                                    \
-  struct _Name_##TimestampMetadata : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {                        \
-    template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                            \
-    using base_table_t = _TimestampSource_##From<O>;                                                                                \
-    template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                            \
-    using extension_table_t = _Name_##TimestampFrom<O>;                                                                             \
-    static constexpr const auto ccdb_urls = []<typename... Cs>(framework::pack<Cs...>) {                                            \
-      return std::array<std::string_view, sizeof...(Cs)>{Cs::query...};                                                             \
-    }(framework::pack<__VA_ARGS__>{});                                                                                              \
-    static constexpr const auto ccdb_bindings = []<typename... Cs>(framework::pack<Cs...>) {                                        \
-      return std::array<std::string_view, sizeof...(Cs)>{Cs::mLabel...};                                                            \
-    }(framework::pack<__VA_ARGS__>{});                                                                                              \
-    template <typename O = o2::aod::Hash<_Origin_ ""_h>>                                                                            \
-    static constexpr auto sources = _TimestampSource_##From<O>::originals;                                                          \
-    static constexpr auto timestamp_column_label = _TimestampColumn_::mLabel;                                                       \
-    /*static constexpr auto timestampColumn = _TimestampColumn_;*/                                                                  \
-  };                                                                                                                                \
-  template <>                                                                                                                       \
-  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                                 \
-    using metadata = _Name_##TimestampMetadata;                                                                                     \
-  };                                                                                                                                \
-  template <typename O>                                                                                                             \
-  using _Name_##From = o2::soa::Join<_TimestampSource_, _Name_##TimestampFrom<O>>;                                                  \
-  using _Name_ = _Name_##From<o2::aod::Hash<_Origin_ ""_h>>;
+#define DECLARE_SOA_TIMESTAMPED_TABLE_FULL(_Name_, _Label_, _TimestampSource_, _TimestampColumn_, _Version_, _Desc_, ...) \
+  O2HASH(_Desc_ "/" #_Version_);                                                                                          \
+  template <typename O>                                                                                                   \
+  using _Name_##TimestampFrom = soa::Table<o2::aod::Hash<_Label_ ""_h>, o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, O>;    \
+  using _Name_##Timestamp = _Name_##TimestampFrom<o2::aod::Hash<                                                          \
+    "AOD"                                                                                                                 \
+    ""_h>>;                                                                                                               \
+  struct _Name_##TimestampMetadata : TableMetadata<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>, __VA_ARGS__> {              \
+    template <typename O = o2::aod::Hash<"AOD"                                                                            \
+                                         ""_h>>                                                                           \
+    using base_table_t = _TimestampSource_##From<O>;                                                                      \
+    template <typename O = o2::aod::Hash<"AOD"                                                                            \
+                                         ""_h>>                                                                           \
+    using extension_table_t = _Name_##TimestampFrom<O>;                                                                   \
+    static constexpr const auto ccdb_urls = []<typename... Cs>(framework::pack<Cs...>) {                                  \
+      return std::array<std::string_view, sizeof...(Cs)>{Cs::query...};                                                   \
+    }(framework::pack<__VA_ARGS__>{});                                                                                    \
+    static constexpr const auto ccdb_bindings = []<typename... Cs>(framework::pack<Cs...>) {                              \
+      return std::array<std::string_view, sizeof...(Cs)>{Cs::mLabel...};                                                  \
+    }(framework::pack<__VA_ARGS__>{});                                                                                    \
+    static constexpr auto N = _TimestampSource_::originals.size();                                                        \
+    template <o2::aod::is_origin_hash O = o2::aod::Hash<"AOD"_h>>                                                         \
+    static consteval auto generateSources()                                                                               \
+    {                                                                                                                     \
+      return _TimestampSource_##From<O>::originals;                                                                       \
+    }                                                                                                                     \
+    static constexpr auto timestamp_column_label = _TimestampColumn_::mLabel;                                             \
+    /*static constexpr auto timestampColumn = _TimestampColumn_;*/                                                        \
+  };                                                                                                                      \
+  template <>                                                                                                             \
+  struct MetadataTrait<o2::aod::Hash<_Desc_ "/" #_Version_ ""_h>> {                                                       \
+    using metadata = _Name_##TimestampMetadata;                                                                           \
+  };                                                                                                                      \
+  template <typename O>                                                                                                   \
+  using _Name_##From = o2::soa::Join<_TimestampSource_, _Name_##TimestampFrom<O>>;                                        \
+  using _Name_ = _Name_##From<o2::aod::Hash<                                                                              \
+    "AOD"                                                                                                                 \
+    ""_h>>;
 
 #define DECLARE_SOA_TIMESTAMPED_TABLE(_Name_, _TimestampSource_, _TimestampColumn_, _Version_, _Desc_, ...) \
   O2HASH(#_Name_ "Timestamped");                                                                            \
-  DECLARE_SOA_TIMESTAMPED_TABLE_FULL(_Name_, #_Name_ "Timestamped", _TimestampSource_, _TimestampColumn_, "AOD", _Version_, _Desc_, __VA_ARGS__)
+  DECLARE_SOA_TIMESTAMPED_TABLE_FULL(_Name_, #_Name_ "Timestamped", _TimestampSource_, _TimestampColumn_, _Version_, _Desc_, __VA_ARGS__)
 
 namespace o2::soa
 {

From 0528e00de1ddddffff010224362bbd494aae7d6d Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 29 Apr 2026 15:41:49 +0200
Subject: [PATCH 1673/1764] ITS: fix rare valid lookup at the edge of
 acceptance (#15327)

* ITS: fix rare valid lookup at the edge of acceptance

Technically, bin (0,0,0,0) is a valid result for the
phi-z cluster query.
Note though, that this if at all a super rare case and
in local tests this did only showed up in the number of
tracklets.
So more a consistency fix than anything.

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: speedup line selection

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: improve logging

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: cleanup tracklet class

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: let staggering macro also run over non-staggered data

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* ITS: fix time assignment

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/macros/test/CheckStaggering.C  | 18 +++--
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 20 +-----
 .../ITS/tracking/include/ITStracking/Cell.h   | 11 ++-
 .../tracking/include/ITStracking/Constants.h  | 17 +++--
 .../include/ITStracking/Definitions.h         | 15 +++-
 .../include/ITStracking/IndexTableUtils.h     |  2 +-
 .../tracking/include/ITStracking/MathUtils.h  |  6 ++
 .../tracking/include/ITStracking/TimeFrame.h  |  6 +-
 .../tracking/include/ITStracking/Tracker.h    | 17 +++--
 .../tracking/include/ITStracking/Tracklet.h   | 69 ++++++------------
 .../tracking/include/ITStracking/Vertexer.h   | 26 ++++---
 .../include/ITStracking/VertexerTraits.h      | 34 ---------
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx | 33 +++++++--
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 49 ++++++-------
 .../ITS/tracking/src/TrackingInterface.cxx    |  1 +
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      | 66 ++++++++++++-----
 .../ITS/tracking/src/VertexerTraits.cxx       | 66 +++++++++--------
 .../ITS/tracking/test/testROFLookupTables.cxx | 72 +++++++++++++++++++
 .../ITSMFT/ITS/workflow/src/TrackerSpec.cxx   |  7 +-
 19 files changed, 313 insertions(+), 222 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/macros/test/CheckStaggering.C b/Detectors/ITSMFT/ITS/macros/test/CheckStaggering.C
index e3a79779a5fb1..11ebcbbb1b1f1 100644
--- a/Detectors/ITSMFT/ITS/macros/test/CheckStaggering.C
+++ b/Detectors/ITSMFT/ITS/macros/test/CheckStaggering.C
@@ -80,9 +80,9 @@ void CheckStaggering(int runNumber, int max = -1, const std::string& dir = "")
   auto& ccdbmgr = o2::ccdb::BasicCCDBManager::instance();
   ccdbmgr.setURL("https://alice-ccdb.cern.ch");
   auto runDuration = ccdbmgr.getRunDuration(runNumber);
-  auto tRun = runDuration.first + (runDuration.second - runDuration.first) / 2; // time stamp for the middle of the run duration
+  auto tRun = runDuration.first + ((runDuration.second - runDuration.first) / 2); // time stamp for the middle of the run duration
   ccdbmgr.setTimestamp(tRun);
-  printf("Run %d has TS %lld", runNumber, tRun);
+  printf("Run %d has TS %ld", runNumber, tRun);
   auto geoAligned = ccdbmgr.get<TGeoManager>("GLO/Config/GeometryAligned");
   auto magField = ccdbmgr.get<o2::parameters::GRPMagField>("GLO/Config/GRPMagField");
   auto grpLHC = ccdbmgr.get<o2::parameters::GRPLHCIFData>("GLO/Config/GRPLHCIF");
@@ -134,7 +134,7 @@ void CheckStaggering(int runNumber, int max = -1, const std::string& dir = "")
   auto hVtxZ = new TH1F("hVtxZ", "seeding vertices Z", 200, -16, 16);
   auto hVtxNCont = new TH1F("hVtxNCont", "seeding vertices contributors", 100, 0, 100);
   auto hVtxZNCont = new TProfile("hVtxZNCont", "seeding vertices z-contributors", 200, -16, 16);
-  auto hVtxCls = new TProfile("hVtxCls", ";Cls/TF;Cls/Vtx", 400, 20000, 60000);
+  auto hVtxCls = new TProfile("hVtxCls", ";Cls/TF;Cls/Vtx", 2000, 600000, 900000);
   auto hVtxTS = new TH1D("hVtxTS", "vtx time t0;t0 (BC)", o2::constants::lhc::LHCMaxBunches, 0, o2::constants::lhc::LHCMaxBunches);
 
   const float minVtxWeight{5};
@@ -183,8 +183,12 @@ void CheckStaggering(int runNumber, int max = -1, const std::string& dir = "")
 
     tTrks->SetBranchAddress("ITSTrack", &trkArrPtr);
     tTrks->SetBranchAddress("Vertices", &vtxArrPtr);
-    for (int i{0}; i < 7; ++i) {
-      tCls->SetBranchAddress(Form("ITSClusterComp_%d", i), &clsArr[i]);
+    if (tCls->GetBranchStatus("ITSClusterComp")) {
+      tCls->SetBranchAddress("ITSClusterComp", &clsArr[0]);
+    } else {
+      for (int i{0}; i < 7; ++i) {
+        tCls->SetBranchAddress(Form("ITSClusterComp_%d", i), &clsArr[i]);
+      }
     }
 
     for (int iTF{0}; tTrks->LoadTree(iTF) >= 0; ++iTF) {
@@ -193,7 +197,9 @@ void CheckStaggering(int runNumber, int max = -1, const std::string& dir = "")
 
       size_t ncls = 0;
       for (int i{0}; i < 7; ++i) {
-        ncls += clsArr[i]->size();
+        if (clsArr[i]) {
+          ncls += clsArr[i]->size();
+        }
       }
 
       // for each TF built pool of positive and negaitve tracks
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 4b12583d99c00..49b8f19d68ea6 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -47,20 +47,6 @@ namespace o2::its
 namespace gpu
 {
 
-struct sort_tracklets {
-  GPUhd() bool operator()(const Tracklet& a, const Tracklet& b)
-  {
-    if (a.firstClusterIndex != b.firstClusterIndex) {
-      return a.firstClusterIndex < b.firstClusterIndex;
-    }
-    return a.secondClusterIndex < b.secondClusterIndex;
-  }
-};
-
-struct equal_tracklets {
-  GPUhd() bool operator()(const Tracklet& a, const Tracklet& b) { return a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex == b.secondClusterIndex; }
-};
-
 template <typename T1, typename T2>
 struct sort_by_second {
   GPUhd() bool operator()(const gpuPair<T1, T2>& a, const gpuPair<T1, T2>& b) const { return a.second < b.second; }
@@ -408,7 +394,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
         const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + constants::Tolerance)}; /// protecting from overflows adding the detector resolution
         const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * MSAngle))};
         const int4 selectedBinsRect{o2::its::getBinsRect(currentCluster, layerIndex + 1, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut, *utils)};
-        if (selectedBinsRect.x == 0 && selectedBinsRect.y == 0 && selectedBinsRect.z == 0 && selectedBinsRect.w == 0) {
+        if (selectedBinsRect.x < 0) {
           continue;
         }
         int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
@@ -687,8 +673,8 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
     mulScatAng[layer]);
   thrust::device_ptr<Tracklet> tracklets_ptr(spanTracklets[layer]);
   auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[layer].get());
-  thrust::sort(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[layer], gpu::sort_tracklets());
-  auto unique_end = thrust::unique(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[layer], gpu::equal_tracklets());
+  thrust::sort(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[layer]);
+  auto unique_end = thrust::unique(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[layer]);
   nTracklets[layer] = unique_end - tracklets_ptr;
   if (layer) {
     GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[layer], 0, (nClusters[layer] + 1) * sizeof(int), streams[layer].get()));
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index dce66bdf99415..c7718ee666311 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -56,18 +56,17 @@ class SeedBase : public o2::track::TrackParCovF
   GPUhd() const auto& clustersRaw() const { return mClusters; }
 
  private:
-  float mChi2 = -999.f;
-  int mLevel = constants::UnusedIndex;
+  float mChi2{constants::UnsetValue};
+  int mLevel{constants::UnusedIndex};
   std::array<int, 2> mTracklets = constants::helpers::initArray<int, 2, constants::UnusedIndex>();
   std::array<int, NClusters> mClusters = constants::helpers::initArray<int, NClusters, constants::UnusedIndex>();
   TimeEstBC mTime;
 };
 
 /// CellSeed: connections of three clusters
-class CellSeed final : public SeedBase<3>
+class CellSeed final : public SeedBase<constants::ClustersPerCell>
 {
-  static constexpr int NStoredClusters = 3;
-  using Base = SeedBase<NStoredClusters>;
+  using Base = SeedBase<constants::ClustersPerCell>;
 
  public:
   GPUhdDefault() CellSeed() = default;
@@ -98,7 +97,7 @@ class CellSeed final : public SeedBase<3>
   GPUhd() int getCluster(int layer) const
   {
     const int rel = layer - getInnerLayer();
-    return (rel >= 0 && rel < NStoredClusters) ? this->clustersRaw()[rel] : constants::UnusedIndex;
+    return (rel >= 0 && rel < constants::ClustersPerCell) ? this->clustersRaw()[rel] : constants::UnusedIndex;
   }
 };
 
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
index d48e8fb7c5856..34fa819b178eb 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Constants.h
@@ -19,9 +19,6 @@
 #include <array>
 #include <utility>
 
-#include "GPUCommonDef.h"
-#include "GPUCommonDefAPI.h"
-
 namespace o2::its::constants
 {
 
@@ -30,12 +27,14 @@ constexpr float MB = KB * KB;
 constexpr float GB = MB * KB;
 constexpr bool DoTimeBenchmarks = true;
 constexpr bool SaveTimeBenchmarks = false;
-constexpr float Tolerance = 1e-12; // numerical tolerance
-constexpr int ClustersPerCell = 3;
-constexpr int UnusedIndex = -1;
-constexpr float Radl = 9.36f; // Radiation length of Si [cm]
-constexpr float Rho = 2.33f;  // Density of Si [g/cm^3]
-constexpr int MaxIter = 4;    // Max. supported iterations
+constexpr float Tolerance = 1e-12;                  // numerical tolerance
+constexpr int ClustersPerCell = 3;                  // number of clusters for a cell
+constexpr int UnusedIndex = -1;                     // global unused flag
+constexpr float UnsetValue = -999.f;                // global unset value
+constexpr float Radl = 9.36f;                       // Radiation length of Si [cm]
+constexpr float Rho = 2.33f;                        // Density of Si [g/cm^3]
+constexpr int MaxIter = 4;                          // Max. supported iterations
+constexpr int MaxSelectedTrackletsPerCluster = 100; // vertexer: max lines per cluster
 
 namespace helpers
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
index 8dadf826aa80a..d79ea8c8bece8 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Definitions.h
@@ -50,6 +50,19 @@ struct LogLogThrottler {
     return false;
   }
 };
+
+struct TimingStats {
+  std::uint64_t calls = 0;
+  double totalTimeMs = 0.;
+
+  void add(double timeMs)
+  {
+    ++calls;
+    totalTimeMs += timeMs;
+  }
+  double averageTimeMs() const { return calls ? totalTimeMs / static_cast<double>(calls) : 0.; }
+};
+
 } // namespace o2::its
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
index e2487208e9453..4e8d5bcfea42a 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/IndexTableUtils.h
@@ -124,7 +124,7 @@ GPUhdi() int4 getBinsRect(const Cluster& currentCluster, const int layerIndex,
 
   if (zRangeMax < -utils.getLayerZ(layerIndex) ||
       zRangeMin > utils.getLayerZ(layerIndex) || zRangeMin > zRangeMax) {
-    return int4{0, 0, 0, 0};
+    return int4{-1, -1, -1, -1};
   }
 
   return int4{o2::gpu::GPUCommonMath::Max(0, utils.getZBinIndex(layerIndex, zRangeMin)),
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
index ab3c7d5d29873..d276e27638dbd 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
@@ -89,6 +89,12 @@ GPUhdi() float smallestAngleDifference(float a, float b)
   return o2::gpu::CAMath::Remainderf(b - a, o2::constants::math::TwoPI);
 }
 
+GPUhdi() bool isPhiDifferenceBelow(const float phiA, const float phiB, const float phiCut)
+{
+  const float deltaPhi = o2::gpu::CAMath::Abs(phiA - phiB);
+  return deltaPhi < phiCut || deltaPhi > o2::constants::math::TwoPI - phiCut;
+}
+
 GPUhdi() constexpr float Sq(float v)
 {
   return v * v;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index f2506694755c5..300abb2a3b10d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -26,9 +26,7 @@
 #include "ITStracking/Cell.h"
 #include "ITStracking/Cluster.h"
 #include "ITStracking/Configuration.h"
-#include "ITStracking/Constants.h"
 #include "ITStracking/ClusterLines.h"
-#include "ITStracking/Definitions.h"
 #include "ITStracking/Tracklet.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/ExternalAllocator.h"
@@ -103,7 +101,7 @@ struct TimeFrame {
   void setBeamPosition(const float x, const float y, const float s2, const float base = 50.f, const float systematic = 0.f)
   {
     isBeamPositionOverridden = true;
-    resetBeamXY(x, y, s2 / o2::gpu::CAMath::Sqrt(base * base + systematic));
+    resetBeamXY(x, y, s2 / o2::gpu::CAMath::Sqrt((base * base) + systematic));
   }
 
   float getBeamX() const { return mBeamPos[0]; }
@@ -249,7 +247,7 @@ struct TimeFrame {
 
   // Propagator
   const o2::base::PropagatorImpl<float>* getDevicePropagator() const { return mPropagatorDevice; }
-  virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>*) {};
+  virtual void setDevicePropagator(const o2::base::PropagatorImpl<float>* /*unused*/) {};
 
   template <typename... T>
   void addClusterToLayer(int layer, T&&... args);
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
index ad8ea5b3b56af..240b0eb1e2f63 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracker.h
@@ -25,10 +25,12 @@
 #include <string_view>
 #include <utility>
 #include <sstream>
+#include <vector>
 
 #include <oneapi/tbb/task_arena.h>
 
 #include "ITStracking/Configuration.h"
+#include "ITStracking/Definitions.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITStracking/BoundedAllocator.h"
@@ -91,16 +93,18 @@ class Tracker
   double mTotalTime{0};
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
 
-  enum State {
+  enum Steps {
     TFInit = 0,
     Trackleting,
     Celling,
     Neighbouring,
     Roading,
-    NStates,
+    NSteps,
   };
-  State mCurState{TFInit};
-  static constexpr std::array<const char*, NStates> StateNames{"TimeFrame initialisation", "Tracklet finding", "Cell finding", "Neighbour finding", "Road finding"};
+  Steps mCurStep{TFInit};
+  static constexpr std::array<const char*, NSteps> StateNames{"TimeFrame initialisation", "Tracklet finding", "Cell finding", "Neighbour finding", "Road finding"};
+  std::vector<std::array<TimingStats, NSteps>> mTimingStats;
+  void addTimingStatCurStep(int iteration, double timeMs);
 };
 
 template <int NLayers>
@@ -125,7 +129,7 @@ float Tracker<NLayers>::evaluateTask(void (Tracker<NLayers>::*task)(T...), std::
     }
     logger(sstream.str());
 
-    if (mTrkParams[0].SaveTimeBenchmarks) {
+    if (mTrkParams[iteration].SaveTimeBenchmarks) {
       std::string taskNameStr(taskName);
       std::transform(taskNameStr.begin(), taskNameStr.end(), taskNameStr.begin(),
                      [](unsigned char c) { return std::tolower(c); });
@@ -133,6 +137,7 @@ float Tracker<NLayers>::evaluateTask(void (Tracker<NLayers>::*task)(T...), std::
       if (std::ofstream file{"its_time_benchmarks.txt", std::ios::app}) {
         file << "trk:" << iteration << '\t' << taskNameStr << '\t' << diff << '\n';
       }
+      addTimingStatCurStep(iteration, diff);
     }
 
   } else {
@@ -140,7 +145,7 @@ float Tracker<NLayers>::evaluateTask(void (Tracker<NLayers>::*task)(T...), std::
   }
 
   if (mTrkParams[iteration].PrintMemory) {
-    LOGP(info, "iter:{}:{}: {}", iteration, StateNames[mCurState], mMemoryPool->asString());
+    LOGP(info, "iter:{}:{}: {}", iteration, StateNames[mCurStep], mMemoryPool->asString());
   }
 
   return diff;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
index d93a5e1c7d70e..829fe9fa984e4 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Tracklet.h
@@ -24,27 +24,35 @@
 #include "GPUCommonDef.h"
 #include "GPUCommonLogger.h"
 
-#ifndef GPUCA_GPUCODE_DEVICE
-#ifndef GPU_NO_FMT
-#include <string>
-#include <fmt/format.h>
-#endif
-#endif
-
 namespace o2::its
 {
 
+// tracklets are entirely determined by their two cluster idx
 struct Tracklet final {
   GPUhdDefault() Tracklet() = default;
-  GPUhdi() Tracklet(const int, const int, const Cluster&, const Cluster&, const TimeEstBC& t);
-  GPUhdi() Tracklet(const int, const int, float tanL, float phi, const TimeEstBC& t);
-  GPUhdDefault() bool operator==(const Tracklet&) const = default;
-  GPUhdi() unsigned char isEmpty() const
+  GPUhdi() Tracklet(const int firstClusterOrderingIndex, const int secondClusterOrderingIndex,
+                    const Cluster& firstCluster, const Cluster& secondCluster, const TimeEstBC& t)
+    : firstClusterIndex(firstClusterOrderingIndex),
+      secondClusterIndex(secondClusterOrderingIndex),
+      tanLambda((firstCluster.zCoordinate - secondCluster.zCoordinate) / (firstCluster.radius - secondCluster.radius)),
+      phi(o2::gpu::GPUCommonMath::ATan2(firstCluster.yCoordinate - secondCluster.yCoordinate, firstCluster.xCoordinate - secondCluster.xCoordinate)),
+      mTime(t) {}
+
+  GPUhdi() Tracklet(const int idx0, const int idx1, float tanL, float phi, const TimeEstBC& t)
+    : firstClusterIndex(idx0),
+      secondClusterIndex(idx1),
+      tanLambda(tanL),
+      phi(phi),
+      mTime(t) {}
+  GPUhdi() bool operator<(const Tracklet& o) const noexcept
+  {
+    return (firstClusterIndex != o.firstClusterIndex) ? firstClusterIndex < o.firstClusterIndex : secondClusterIndex < o.secondClusterIndex;
+  }
+  GPUhdi() bool operator==(const Tracklet& o) const noexcept
   {
-    return firstClusterIndex < 0 || secondClusterIndex < 0;
+    return firstClusterIndex == o.firstClusterIndex && secondClusterIndex == o.secondClusterIndex;
   }
   GPUhdi() bool isCompatible(const Tracklet& o) const { return mTime.isCompatible(o.mTime); }
-  GPUhdi() unsigned char operator<(const Tracklet&) const;
   GPUhd() void print() const
   {
     LOGP(info, "TRKLT: fClIdx:{} sClIdx:{} ts:{}+/-{} TgL={} Phi={}", firstClusterIndex, secondClusterIndex, mTime.getTimeStamp(), mTime.getTimeStampError(), tanLambda, phi);
@@ -54,44 +62,13 @@ struct Tracklet final {
 
   int firstClusterIndex{constants::UnusedIndex};
   int secondClusterIndex{constants::UnusedIndex};
-  float tanLambda{-999};
-  float phi{-999};
+  float tanLambda{constants::UnsetValue};
+  float phi{constants::UnsetValue};
   TimeEstBC mTime;
 
   ClassDefNV(Tracklet, 1);
 };
 
-GPUhdi() Tracklet::Tracklet(const int firstClusterOrderingIndex, const int secondClusterOrderingIndex,
-                            const Cluster& firstCluster, const Cluster& secondCluster, const TimeEstBC& t)
-  : firstClusterIndex(firstClusterOrderingIndex),
-    secondClusterIndex(secondClusterOrderingIndex),
-    tanLambda((firstCluster.zCoordinate - secondCluster.zCoordinate) /
-              (firstCluster.radius - secondCluster.radius)),
-    phi(o2::gpu::GPUCommonMath::ATan2(firstCluster.yCoordinate - secondCluster.yCoordinate,
-                                      firstCluster.xCoordinate - secondCluster.xCoordinate)),
-    mTime(t)
-{
-  // Nothing to do
-}
-
-GPUhdi() Tracklet::Tracklet(const int idx0, const int idx1, float tanL, float phi, const TimeEstBC& t)
-  : firstClusterIndex(idx0),
-    secondClusterIndex(idx1),
-    tanLambda(tanL),
-    phi(phi),
-    mTime(t)
-{
-  // Nothing to do
-}
-
-GPUhdi() unsigned char Tracklet::operator<(const Tracklet& t) const
-{
-  if (isEmpty()) {
-    return false;
-  }
-  return true;
-}
-
 } // namespace o2::its
 
 #endif /* TRACKINGITS_INCLUDE_TRACKLET_H_ */
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
index f1cf081473264..eff91e820c56d 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Vertexer.h
@@ -22,11 +22,11 @@
 #include <array>
 #include <iosfwd>
 #include <memory>
+#include <vector>
 
 #include <oneapi/tbb/task_arena.h>
 
 #include "ITStracking/Constants.h"
-#include "ITStracking/Definitions.h"
 #include "ITStracking/Configuration.h"
 #include "ITStracking/TimeFrame.h"
 #include "ITStracking/VertexerTraits.h"
@@ -56,6 +56,7 @@ class Vertexer
 
   float clustersToVertices(LogFunc = [](const std::string& s) { std::cout << s << '\n'; });
   void filterMCTracklets();
+  void printSummary() const;
 
   template <typename... T>
   void findTracklets(T&&... args)
@@ -90,9 +91,9 @@ class Vertexer
   float evaluateTask(void (Vertexer::*task)(T...), std::string_view taskName, int iteration, LogFunc& logger, T&&... args);
 
   void printEpilog(LogFunc& logger,
-                   const unsigned int trackletN01, const unsigned int trackletN12,
-                   const unsigned selectedN, const unsigned int vertexN, const unsigned int totalVertexN,
-                   const float trackletT, const float selecT, const float vertexT);
+                   unsigned int trackletN01, unsigned int trackletN12,
+                   unsigned selectedN, unsigned int vertexN, unsigned int totalVertexN,
+                   float initT, float trackletT, float selecT, float vertexT);
 
   void setNThreads(int n, std::shared_ptr<tbb::task_arena>& arena) { mTraits->setNThreads(n, arena); }
 
@@ -105,16 +106,18 @@ class Vertexer
   std::vector<VertexingParameters> mVertParams;
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
 
-  enum State {
+  enum Steps {
     Init = 0,
     Trackleting,
-    Validating,
+    Selection,
     Finding,
     TruthSeeding,
-    NStates,
+    NSteps,
   };
-  State mCurState{Init};
-  static constexpr std::array<const char*, NStates> StateNames{"Initialisation", "Tracklet finding", "Tracklet validation", "Vertex finding", "Truth seeding"};
+  Steps mCurStep{Init};
+  static constexpr std::array<const char*, NSteps> StateNames{"Initialisation", "Tracklet finding", "Tracklet selection", "Vertex finding", "Truth seeding"};
+  std::vector<std::array<TimingStats, NSteps>> mTimingStats;
+  void addTimingStatCurStep(int iteration, double timeMs);
 };
 
 template <int NLayers>
@@ -139,7 +142,7 @@ float Vertexer<NLayers>::evaluateTask(void (Vertexer<NLayers>::*task)(T...), std
     }
     logger(sstream.str());
 
-    if (mVertParams[0].SaveTimeBenchmarks) {
+    if (mVertParams[iteration].SaveTimeBenchmarks) {
       std::string taskNameStr(taskName);
       std::transform(taskNameStr.begin(), taskNameStr.end(), taskNameStr.begin(),
                      [](unsigned char c) { return std::tolower(c); });
@@ -147,13 +150,14 @@ float Vertexer<NLayers>::evaluateTask(void (Vertexer<NLayers>::*task)(T...), std
       if (std::ofstream file{"its_time_benchmarks.txt", std::ios::app}) {
         file << "vtx:" << iteration << '\t' << taskNameStr << '\t' << diff << '\n';
       }
+      addTimingStatCurStep(iteration, diff);
     }
   } else {
     (this->*task)(std::forward<T>(args)...);
   }
 
   if (mVertParams[iteration].PrintMemory) {
-    LOGP(info, "iter:{}:{}: {}", iteration, StateNames[mCurState], mMemoryPool->asString());
+    LOGP(info, "iter:{}:{}: {}", iteration, StateNames[mCurStep], mMemoryPool->asString());
   }
 
   return diff;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 1adb09551e326..3230737a0f87c 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -53,12 +53,6 @@ class VertexerTraits
   VertexerTraits() = default;
   virtual ~VertexerTraits() = default;
 
-  GPUhdi() static consteval int4 getEmptyBinsRect()
-  {
-    return int4{0, 0, 0, 0};
-  }
-  GPUhd() const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi);
-  GPUhd() static const int4 getBinsRect(const Cluster&, const int, const float, float maxdeltaz, float maxdeltaphi, const IndexTableUtilsN&);
   GPUhd() static const int2 getPhiBins(float phi, float deltaPhi, const IndexTableUtilsN&);
   GPUhd() const int2 getPhiBins(float phi, float deltaPhi) { return getPhiBins(phi, deltaPhi, mIndexTableUtils); }
 
@@ -134,34 +128,6 @@ GPUhdi() const int2 VertexerTraits<NLayers>::getPhiBins(float phi, float dPhi, c
               utils.getPhiBinIndex(math_utils::getNormalizedPhi(phi + dPhi))};
 }
 
-template <int NLayers>
-GPUhdi() const int4 VertexerTraits<NLayers>::getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                                                         const float directionZIntersection, float maxdeltaz, float maxdeltaphi,
-                                                         const IndexTableUtilsN& utils)
-{
-  const float zRangeMin = directionZIntersection - 2 * maxdeltaz;
-  const float phiRangeMin = currentCluster.phi - maxdeltaphi;
-  const float zRangeMax = directionZIntersection + 2 * maxdeltaz;
-  const float phiRangeMax = currentCluster.phi + maxdeltaphi;
-
-  if (zRangeMax < -utils.getLayerZ(layerIndex + 1) ||
-      zRangeMin > utils.getLayerZ(layerIndex + 1) || zRangeMin > zRangeMax) {
-    return getEmptyBinsRect();
-  }
-
-  return int4{o2::gpu::GPUCommonMath::Max(0, utils.getZBinIndex(layerIndex + 1, zRangeMin)),
-              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMin)),
-              o2::gpu::GPUCommonMath::Min(utils.getNzBins() - 1, utils.getZBinIndex(layerIndex + 1, zRangeMax)),
-              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phiRangeMax))};
-}
-
-template <int NLayers>
-GPUhdi() const int4 VertexerTraits<NLayers>::getBinsRect(const Cluster& currentCluster, const int layerIndex,
-                                                         const float directionZIntersection, float maxdeltaz, float maxdeltaphi)
-{
-  return VertexerTraits::getBinsRect(currentCluster, layerIndex, directionZIntersection, maxdeltaz, maxdeltaphi, mIndexTableUtils);
-}
-
 } // namespace its
 } // namespace o2
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 3e91788c9881c..382f2314b2e6a 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -49,7 +49,7 @@ float Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& e
   int iteration{0}, iVertex{0};
   auto handleException = [&](const auto& err) {
     LOGP(error, "Too much memory in {} in iteration {} iVtx={}: {:.2f} GB. Current limit is {:.2f} GB, check the detector status and/or the selections.",
-         StateNames[mCurState], iteration, iVertex,
+         StateNames[mCurStep], iteration, iVertex,
          (double)mTimeFrame->getArtefactsMemory() / GB,
          (double)mTrkParams[iteration].MaxMemory / GB);
     if (typeid(err) != typeid(std::bad_alloc)) { // only print if the exceptions is different from what is expected
@@ -76,16 +76,16 @@ float Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& e
       int nTracks{-static_cast<int>(mTimeFrame->getNumberOfTracks())};
       iVertex = std::min(maxNvertices, 0);
       logger(std::format("==== ITS {} Tracking iteration {} summary ====", mTraits->getName(), iteration));
-      total += timeFrame = evaluateTask(&Tracker::initialiseTimeFrame, StateNames[mCurState = TFInit], iteration, evalLog, iteration);
+      total += timeFrame = evaluateTask(&Tracker::initialiseTimeFrame, StateNames[mCurStep = TFInit], iteration, evalLog, iteration);
       logger(std::format(" - TimeFrame initialisation completed in {:.2f} ms", timeFrame));
       do {
-        timeTracklets += evaluateTask(&Tracker::computeTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration, iVertex);
+        timeTracklets += evaluateTask(&Tracker::computeTracklets, StateNames[mCurStep = Trackleting], iteration, evalLog, iteration, iVertex);
         nTracklets += mTraits->getTFNumberOfTracklets();
-        timeCells += evaluateTask(&Tracker::computeCells, StateNames[mCurState = Celling], iteration, evalLog, iteration);
+        timeCells += evaluateTask(&Tracker::computeCells, StateNames[mCurStep = Celling], iteration, evalLog, iteration);
         nCells += mTraits->getTFNumberOfCells();
-        timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, StateNames[mCurState = Neighbouring], iteration, evalLog, iteration);
+        timeNeighbours += evaluateTask(&Tracker::findCellsNeighbours, StateNames[mCurStep = Neighbouring], iteration, evalLog, iteration);
         nNeighbours += mTimeFrame->getNumberOfNeighbours();
-        timeRoads += evaluateTask(&Tracker::findRoads, StateNames[mCurState = Roading], iteration, evalLog, iteration);
+        timeRoads += evaluateTask(&Tracker::findRoads, StateNames[mCurStep = Roading], iteration, evalLog, iteration);
       } while (++iVertex < maxNvertices);
       logger(std::format(" - Tracklet finding: {} tracklets found in {:.2f} ms", nTracklets, timeTracklets));
       logger(std::format(" - Cell finding: {} cells found in {:.2f} ms", nCells, timeCells));
@@ -229,12 +229,33 @@ void Tracker<NLayers>::adoptTimeFrame(TimeFrame<NLayers>& tf)
   mTraits->adoptTimeFrame(&tf);
 }
 
+template <int NLayers>
+void Tracker<NLayers>::addTimingStatCurStep(int iteration, double timeMs)
+{
+  if (iteration < 0) {
+    return;
+  }
+  if (mTimingStats.size() < (iteration + 1)) {
+    mTimingStats.resize(iteration + 1);
+  }
+  mTimingStats[iteration][mCurStep].add(timeMs);
+}
+
 template <int NLayers>
 void Tracker<NLayers>::printSummary() const
 {
   auto avgTF = mTotalTime * 1.e-3 / ((mTimeFrameCounter > 0) ? (double)mTimeFrameCounter : -1.0);
   auto avgTFwithDropped = mTotalTime * 1.e-3 / (((mTimeFrameCounter + mNumberOfDroppedTFs) > 0) ? (double)(mTimeFrameCounter + mNumberOfDroppedTFs) : -1.0);
   LOGP(info, "Tracker summary: Processed {} TFs (dropped {}) in TOT={:.2f} s, AVG/TF={:.2f} ({:.2f}) s", mTimeFrameCounter, mNumberOfDroppedTFs, mTotalTime * 1.e-3, avgTF, avgTFwithDropped);
+  for (size_t iteration = 0; iteration < mTimingStats.size(); ++iteration) {
+    for (size_t state = 0; state < NSteps; ++state) {
+      const auto& stats = mTimingStats[iteration][state];
+      if (!stats.calls) {
+        continue;
+      }
+      LOGP(info, " - iter {} {}: calls={} total={:.2f} ms avg={:.2f} ms", iteration, StateNames[state], stats.calls, stats.totalTimeMs, stats.averageTimeMs());
+    }
+  }
 }
 
 template class Tracker<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 69ccd8228ad88..dc2d6e8889973 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -114,7 +114,7 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
           const auto bins = o2::its::getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax,
                                                  sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer),
                                                  mTimeFrame->getIndexTableUtils());
-          if (bins.x == 0 && bins.y == 0 && bins.z == 0 && bins.w == 0) {
+          if (bins.x < 0) {
             continue;
           }
           int phiBinsNum = bins.w - bins.y + 1;
@@ -150,11 +150,10 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
                 if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
                   continue;
                 }
-                const float deltaPhi = o2::gpu::CAMath::Abs(o2::math_utils::toPMPi(currentCluster.phi - nextCluster.phi));
                 const float deltaZ = o2::gpu::CAMath::Abs((tanLambda * (nextCluster.radius - currentCluster.radius)) + currentCluster.zCoordinate - nextCluster.zCoordinate);
 
                 if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
-                    ((deltaPhi < mTimeFrame->getPhiCut(iLayer) || o2::gpu::GPUCommonMath::Abs(deltaPhi - o2::constants::math::TwoPI) < mTimeFrame->getPhiCut(iLayer)))) {
+                    math_utils::isPhiDifferenceBelow(currentCluster.phi, nextCluster.phi, mTimeFrame->getPhiCut(iLayer))) {
                   const float phi{o2::gpu::CAMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate)};
                   const float tanL = (currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius);
                   if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
@@ -207,19 +206,11 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
     }
 
     tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
-      /// Sort tracklets
+      /// Sort tracklets & remove duplicates
+      // duplicates can exist simply since we evaluate per vertex
       auto& trkl{mTimeFrame->getTracklets()[iLayer]};
-      std::sort(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
-        if (a.firstClusterIndex != b.firstClusterIndex) {
-          return a.firstClusterIndex < b.firstClusterIndex;
-        }
-        return a.secondClusterIndex < b.secondClusterIndex;
-      });
-      /// Remove duplicates
-      trkl.erase(std::unique(trkl.begin(), trkl.end(), [](const Tracklet& a, const Tracklet& b) -> bool {
-                   return a.firstClusterIndex == b.firstClusterIndex && a.secondClusterIndex == b.secondClusterIndex;
-                 }),
-                 trkl.end());
+      std::sort(trkl.begin(), trkl.end());
+      trkl.erase(std::unique(trkl.begin(), trkl.end()), trkl.end());
       trkl.shrink_to_fit();
       if (iLayer > 0) { /// recalculate lut
         auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer - 1]};
@@ -810,30 +801,40 @@ void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITS
       continue;
     }
 
-    bool firstCls{true};
-    TimeEstBC ts;
+    bool firstCls{true}, nominalCompatible{true};
+    TimeEstBC nominalTS, expandedTS;
     for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
       if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
         continue;
       }
       mTimeFrame->markUsedCluster(iLayer, track.getClusterIndex(iLayer));
       int currentROF = mTimeFrame->getClusterROF(iLayer, track.getClusterIndex(iLayer));
-      auto rofTS = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).getROFTimeBounds(currentROF, true);
+      const auto nominalROFTS = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).getROFTimeBounds(currentROF);
+      const auto expandedROFTS = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).getROFTimeBounds(currentROF, true);
       if (firstCls) {
         firstCls = false;
-        ts = rofTS;
+        nominalTS = nominalROFTS;
+        expandedTS = expandedROFTS;
       } else {
-        if (!ts.isCompatible(rofTS)) {
-          LOGP(fatal, "TS {}+/-{} are incompatible with {}+/-{}, this should not happen!", rofTS.getTimeStamp(), rofTS.getTimeStampError(), ts.getTimeStamp(), ts.getTimeStampError());
+        if (nominalCompatible) {
+          if (nominalTS.isCompatible(nominalROFTS)) {
+            nominalTS += nominalROFTS;
+          } else {
+            nominalCompatible = false;
+          }
+        }
+        if (!expandedTS.isCompatible(expandedROFTS)) {
+          LOGP(fatal, "TS {}+/-{} are incompatible with {}+/-{}, this should not happen!", expandedROFTS.getTimeStamp(), expandedROFTS.getTimeStampError(), expandedTS.getTimeStamp(), expandedTS.getTimeStampError());
         }
-        ts += rofTS;
+        expandedTS += expandedROFTS;
       }
     }
-    track.getTimeStamp() = ts.makeSymmetrical();
+    track.getTimeStamp() = (nominalCompatible ? nominalTS : expandedTS).makeSymmetrical();
+    // this is a sanity clamp
+    // we cannot be worse than the clock so we clamp to this
     if (track.getTimeStamp().getTimeStampError() > smallestROFHalf) {
       track.getTimeStamp().setTimeStampError(smallestROFHalf);
     }
-
     track.setUserField(0);
     track.getParamOut().setUserField(0);
     mTimeFrame->getTracks().emplace_back(track);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index d469fa4246ef5..a48f23c5eb8f1 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -460,6 +460,7 @@ void ITSTrackingInterface::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
 
 void ITSTrackingInterface::printSummary() const
 {
+  mVertexer->printSummary();
   mTracker->printSummary();
 }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 556302cb2854f..2acbec7fe8bc0 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -15,11 +15,6 @@
 
 #include "ITStracking/Vertexer.h"
 #include "ITStracking/BoundedAllocator.h"
-#include "ITStracking/Cluster.h"
-
-#include "ITStracking/ClusterLines.h"
-#include "ITStracking/Tracklet.h"
-#include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/VertexerTraits.h"
 #include "ITStracking/TrackingConfigParam.h"
 
@@ -41,8 +36,9 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
   LogFunc evalLog = [](const std::string&) {};
 
   if (mTimeFrame->hasMCinformation() && mVertParams[0].useTruthSeeding) {
-    float t = evaluateTask(&Vertexer::addTruthSeeds, StateNames[mCurState = TruthSeeding], 0, evalLog);
+    float t = evaluateTask(&Vertexer::addTruthSeeds, StateNames[mCurStep = TruthSeeding], 0, evalLog);
     sortVertices();
+    ++mTimeFrameCounter;
     return t;
   }
 
@@ -50,7 +46,7 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
   mTraits->updateVertexingParameters(mVertParams);
 
   auto handleException = [&](const auto& err) {
-    LOGP(error, "Encountered critical error in step {}, stopping further processing of this TF: {}", StateNames[mCurState], err.what());
+    LOGP(error, "Encountered critical error in step {}, stopping further processing of this TF: {}", StateNames[mCurStep], err.what());
     if (!mVertParams[0].DropTFUponFailure) {
       throw err;
     } else {
@@ -59,6 +55,7 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
   };
 
   float timeTracklet{0.f}, timeSelection{0.f}, timeVertexing{0.f}, timeInit{0.f};
+  bool completed = false;
   try {
     for (int iteration = 0; iteration < (int)mVertParams.size(); ++iteration) {
       mMemoryPool->setMaxMemory(mVertParams[iteration].MaxMemory);
@@ -66,15 +63,15 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
       logger(fmt::format("=== ITS {} Seeding vertexer iteration {} summary:", mTraits->getName(), iteration));
       trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
       trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
-      auto timeInitIteration = evaluateTask(&Vertexer::initialiseVertexer, StateNames[mCurState = Init], iteration, evalLog, trkPars, iteration);
-      auto timeTrackletIteration = evaluateTask(&Vertexer::findTracklets, StateNames[mCurState = Trackleting], iteration, evalLog, iteration);
+      auto timeInitIteration = evaluateTask(&Vertexer::initialiseVertexer, StateNames[mCurStep = Init], iteration, evalLog, trkPars, iteration);
+      auto timeTrackletIteration = evaluateTask(&Vertexer::findTracklets, StateNames[mCurStep = Trackleting], iteration, evalLog, iteration);
       nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
       nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
-      auto timeSelectionIteration = evaluateTask(&Vertexer::validateTracklets, StateNames[mCurState = Validating], iteration, evalLog, iteration);
+      auto timeSelectionIteration = evaluateTask(&Vertexer::validateTracklets, StateNames[mCurStep = Selection], iteration, evalLog, iteration);
       const auto nVerticesBefore = mTimeFrame->getPrimaryVertices().size();
-      auto timeVertexingIteration = evaluateTask(&Vertexer::findVertices, StateNames[mCurState = Finding], iteration, evalLog, iteration);
+      auto timeVertexingIteration = evaluateTask(&Vertexer::findVertices, StateNames[mCurStep = Finding], iteration, evalLog, iteration);
       const auto nVerticesAfter = mTimeFrame->getPrimaryVertices().size();
-      printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), nVerticesAfter - nVerticesBefore, nVerticesAfter, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
+      printEpilog(logger, nTracklets01, nTracklets12, mTimeFrame->getNLinesTotal(), nVerticesAfter - nVerticesBefore, nVerticesAfter, timeInitIteration, timeTrackletIteration, timeSelectionIteration, timeVertexingIteration);
       timeInit += timeInitIteration;
       timeTracklet += timeTrackletIteration;
       timeSelection += timeSelectionIteration;
@@ -84,6 +81,7 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
       sortVertices();
       mTimeFrame->updateROFVertexLookupTable();
     }
+    completed = true;
   } catch (const BoundedMemoryResource::MemoryLimitExceeded& err) {
     handleException(err);
   } catch (const std::bad_alloc& err) {
@@ -92,6 +90,10 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
     LOGP(fatal, "Uncaught exception!");
   }
 
+  if (completed) {
+    ++mTimeFrameCounter;
+  }
+
   return timeInit + timeTracklet + timeSelection + timeVertexing;
 }
 
@@ -135,15 +137,43 @@ void Vertexer<NLayers>::adoptTimeFrame(TimeFrameN& tf)
   mTraits->adoptTimeFrame(&tf);
 }
 
+template <int NLayers>
+void Vertexer<NLayers>::addTimingStatCurStep(int iteration, double timeMs)
+{
+  if (iteration < 0) {
+    return;
+  }
+  if (mTimingStats.size() < (iteration + 1)) {
+    mTimingStats.resize(iteration + 1);
+  }
+  mTimingStats[iteration][mCurStep].add(timeMs);
+}
+
+template <int NLayers>
+void Vertexer<NLayers>::printSummary() const
+{
+  LOGP(info, "Vertexer summary: Processed {} TFs", mTimeFrameCounter);
+  for (size_t iteration = 0; iteration < mTimingStats.size(); ++iteration) {
+    for (size_t state = 0; state < NSteps; ++state) {
+      const auto& stats = mTimingStats[iteration][state];
+      if (!stats.calls) {
+        continue;
+      }
+      LOGP(info, " - iter {} {}: calls={} total={:.2f} ms avg={:.2f} ms", iteration, StateNames[state], stats.calls, stats.totalTimeMs, stats.averageTimeMs());
+    }
+  }
+}
+
 template <int NLayers>
 void Vertexer<NLayers>::printEpilog(LogFunc& logger,
-                                    const unsigned int trackletN01, const unsigned int trackletN12,
-                                    const unsigned selectedN, const unsigned int vertexN, const unsigned int totalVertexN,
-                                    const float trackletT, const float selecT, const float vertexT)
+                                    unsigned int trackletN01, unsigned int trackletN12,
+                                    unsigned selectedN, unsigned int vertexN, unsigned int totalVertexN,
+                                    float initT, float trackletT, float selecT, float vertexT)
 {
-  logger(fmt::format(" - {} Vertexer: found {} | {} tracklets in: {:.2f} ms", mTraits->getName(), trackletN01, trackletN12, trackletT));
-  logger(fmt::format(" - {} Vertexer: selected {} tracklets in: {:.2f} ms", mTraits->getName(), selectedN, selecT));
-  logger(fmt::format(" - {} Vertexer: found {} vertices (total: {}) in: {:.2f} ms", mTraits->getName(), vertexN, totalVertexN, vertexT));
+  logger(fmt::format(" - {}: completed in {:.2f} ms", StateNames[Init], initT));
+  logger(fmt::format(" - {}: found {} | {} tracklets in {:.2f} ms", StateNames[Trackleting], trackletN01, trackletN12, trackletT));
+  logger(fmt::format(" - {}: selected {} tracklets in {:.2f} ms", StateNames[Selection], selectedN, selecT));
+  logger(fmt::format(" - {}: found {} vertices (total {}) in {:.2f} ms", StateNames[Finding], vertexN, totalVertexN, vertexT));
 }
 
 template class Vertexer<7>;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index d0baa65c49147..00674b715b97d 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -36,6 +36,7 @@ namespace o2::its
 {
 namespace
 {
+
 template <TrackletMode Mode, bool EvalRun, int NLayers>
 void trackleterKernelHost(
   const gsl::span<const Cluster>& clustersNextLayer,    // 0 2
@@ -48,9 +49,9 @@ void trackleterKernelHost(
   const IndexTableUtils<NLayers>& utils,
   const TimeEstBC& timErr,
   gsl::span<int> rofFoundTrackletsOffsets,
-  const int globalOffsetNextLayer = 0,
-  const int globalOffsetCurrentLayer = 0,
-  const int maxTrackletsPerCluster = static_cast<int>(2e3))
+  const int globalOffsetNextLayer,
+  const int globalOffsetCurrentLayer,
+  const int maxTrackletsPerCluster)
 {
   const int PhiBins{utils.getNphiBins()};
   const int ZBins{utils.getNzBins()};
@@ -58,24 +59,24 @@ void trackleterKernelHost(
   for (int iCurrentLayerClusterIndex = 0; iCurrentLayerClusterIndex < clustersCurrentLayer.size(); ++iCurrentLayerClusterIndex) {
     int storedTracklets{0};
     const Cluster& currentCluster{clustersCurrentLayer[iCurrentLayerClusterIndex]};
-    const int4 selectedBinsRect{VertexerTraits<NLayers>::getBinsRect(currentCluster, (int)Mode, 0.f, 50.f, phiCut / 2, utils)};
-    if (selectedBinsRect.x != 0 || selectedBinsRect.y != 0 || selectedBinsRect.z != 0 || selectedBinsRect.w != 0) {
+    const int4 selectedBinsRect{o2::its::getBinsRect(currentCluster, (int)Mode + 1, 0.f, 0.f, 100.f, phiCut / 2, utils)};
+    if (selectedBinsRect.x >= 0) {
       int phiBinsNum{selectedBinsRect.w - selectedBinsRect.y + 1};
       if (phiBinsNum < 0) {
         phiBinsNum += PhiBins;
       }
       // loop on phi bins next layer
-      for (int iPhiBin{selectedBinsRect.y}, iPhiCount{0}; iPhiCount < phiBinsNum; iPhiBin = ++iPhiBin == PhiBins ? 0 : iPhiBin, iPhiCount++) {
+      for (int iPhiBin{selectedBinsRect.y}, iPhiCount{0}; iPhiCount < phiBinsNum && storedTracklets < maxTrackletsPerCluster; iPhiBin = ++iPhiBin == PhiBins ? 0 : iPhiBin, iPhiCount++) {
         const int firstBinIndex{utils.getBinIndex(selectedBinsRect.x, iPhiBin)};
         const int firstRowClusterIndex{indexTableNext[firstBinIndex]};
         const int maxRowClusterIndex{indexTableNext[firstBinIndex + ZBins]};
         // loop on clusters next layer
-        for (int iNextLayerClusterIndex{firstRowClusterIndex}; iNextLayerClusterIndex < maxRowClusterIndex && iNextLayerClusterIndex < static_cast<int>(clustersNextLayer.size()); ++iNextLayerClusterIndex) {
+        for (int iNextLayerClusterIndex{firstRowClusterIndex}; iNextLayerClusterIndex < maxRowClusterIndex && iNextLayerClusterIndex < static_cast<int>(clustersNextLayer.size()) && storedTracklets < maxTrackletsPerCluster; ++iNextLayerClusterIndex) {
           if (usedClustersNextLayer[iNextLayerClusterIndex]) {
             continue;
           }
           const Cluster& nextCluster{clustersNextLayer[iNextLayerClusterIndex]};
-          if (o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(currentCluster.phi, nextCluster.phi)) < phiCut) {
+          if (math_utils::isPhiDifferenceBelow(currentCluster.phi, nextCluster.phi, phiCut)) {
             if (storedTracklets < maxTrackletsPerCluster) {
               if constexpr (!EvalRun) {
                 if constexpr (Mode == TrackletMode::Layer0Layer1) {
@@ -105,35 +106,39 @@ void trackletSelectionKernelHost(
   gsl::span<unsigned char> usedClusters2, // global layer 2 used clusters
   const gsl::span<const Tracklet>& tracklets01,
   const gsl::span<const Tracklet>& tracklets12,
-  bounded_vector<bool>& usedTracklets,
+  bounded_vector<uint8_t>& usedTracklets,
   const gsl::span<int> foundTracklets01,
   const gsl::span<int> foundTracklets12,
   bounded_vector<Line>& lines,
   const gsl::span<const o2::MCCompLabel>& trackletLabels,
   bounded_vector<o2::MCCompLabel>& linesLabels,
   const int nLayer1Clusters,
-  const float tanLambdaCut = 0.025f,
-  const float phiCut = 0.005f,
-  const int maxTracklets = 100)
+  const float tanLambdaCut,
+  const float phiCut,
+  const int maxTracklets)
 {
   int offset01{0}, offset12{0};
   for (int iCurrentLayerClusterIndex{0}; iCurrentLayerClusterIndex < nLayer1Clusters; ++iCurrentLayerClusterIndex) {
     int validTracklets{0};
-    for (int iTracklet12{offset12}; iTracklet12 < offset12 + foundTracklets12[iCurrentLayerClusterIndex]; ++iTracklet12) {
-      for (int iTracklet01{offset01}; iTracklet01 < offset01 + foundTracklets01[iCurrentLayerClusterIndex]; ++iTracklet01) {
+    const int endTracklet01 = offset01 + foundTracklets01[iCurrentLayerClusterIndex];
+    const int endTracklet12 = offset12 + foundTracklets12[iCurrentLayerClusterIndex];
+    for (int iTracklet12{offset12}; iTracklet12 < endTracklet12 && validTracklets != maxTracklets; ++iTracklet12) {
+      const auto& tracklet12{tracklets12[iTracklet12]};
+      for (int iTracklet01{offset01}; iTracklet01 < endTracklet01 && validTracklets != maxTracklets; ++iTracklet01) {
         if (usedTracklets[iTracklet01]) {
           continue;
         }
 
         const auto& tracklet01{tracklets01[iTracklet01]};
-        const auto& tracklet12{tracklets12[iTracklet12]};
         if (!tracklet01.getTimeStamp().isCompatible(tracklet12.getTimeStamp())) {
           continue;
         }
 
         const float deltaTanLambda{o2::gpu::GPUCommonMath::Abs(tracklet01.tanLambda - tracklet12.tanLambda)};
-        const float deltaPhi{o2::gpu::GPUCommonMath::Abs(math_utils::smallestAngleDifference(tracklet01.phi, tracklet12.phi))};
-        if (deltaTanLambda < tanLambdaCut && deltaPhi < phiCut && validTracklets != maxTracklets) {
+        if (deltaTanLambda >= tanLambdaCut) {
+          continue;
+        }
+        if (math_utils::isPhiDifferenceBelow(tracklet01.phi, tracklet12.phi, phiCut) && validTracklets != maxTracklets) {
           usedClusters0[tracklet01.firstClusterIndex] = 1;
           usedClusters2[tracklet12.secondClusterIndex] = 1;
           usedTracklets[iTracklet01] = true;
@@ -264,20 +269,18 @@ void VertexerTraits<NLayers>::computeTracklets(const int iteration)
   if (mTimeFrame->hasMCinformation()) {
     for (const auto& trk : mTimeFrame->getTracklets()[0]) {
       o2::MCCompLabel label;
-      if (!trk.isEmpty()) {
-        int sortedId0{trk.firstClusterIndex};
-        int sortedId1{trk.secondClusterIndex};
-        for (const auto& lab0 : mTimeFrame->getClusterLabels(0, mTimeFrame->getClusters()[0][sortedId0].clusterId)) {
-          for (const auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
-            if (lab0 == lab1 && lab0.isValid()) {
-              label = lab0;
-              break;
-            }
-          }
-          if (label.isValid()) {
+      int sortedId0{trk.firstClusterIndex};
+      int sortedId1{trk.secondClusterIndex};
+      for (const auto& lab0 : mTimeFrame->getClusterLabels(0, mTimeFrame->getClusters()[0][sortedId0].clusterId)) {
+        for (const auto& lab1 : mTimeFrame->getClusterLabels(1, mTimeFrame->getClusters()[1][sortedId1].clusterId)) {
+          if (lab0 == lab1 && lab0.isValid()) {
+            label = lab0;
             break;
           }
         }
+        if (label.isValid()) {
+          break;
+        }
       }
       mTimeFrame->getTrackletsLabel(0).emplace_back(label);
     }
@@ -296,8 +299,8 @@ void VertexerTraits<NLayers>::computeTrackletMatching(const int iteration)
           if (mTimeFrame->getFoundTracklets(pivotRofId, 0).empty() || skipROF(iteration, pivotRofId)) {
             continue;
           }
-          mTimeFrame->getLines(pivotRofId).reserve(mTimeFrame->getNTrackletsCluster(pivotRofId, 0).size());
-          bounded_vector<bool> usedTracklets(mTimeFrame->getFoundTracklets(pivotRofId, 0).size(), false, mMemoryPool.get());
+          mTimeFrame->getLines(pivotRofId).reserve(std::min(mTimeFrame->getFoundTracklets(pivotRofId, 0).size(), mTimeFrame->getNTrackletsCluster(pivotRofId, 0).size() * constants::MaxSelectedTrackletsPerCluster));
+          bounded_vector<uint8_t> usedTracklets(mTimeFrame->getFoundTracklets(pivotRofId, 0).size(), 0, mMemoryPool.get());
           trackletSelectionKernelHost(
             mTimeFrame->getClusters()[0].data(),
             mTimeFrame->getClusters()[1].data(),
@@ -313,7 +316,8 @@ void VertexerTraits<NLayers>::computeTrackletMatching(const int iteration)
             mTimeFrame->getLinesLabel(pivotRofId),
             static_cast<int>(mTimeFrame->getClustersOnLayer(pivotRofId, 1).size()),
             mVrtParams[iteration].tanLambdaCut,
-            mVrtParams[iteration].phiCut);
+            mVrtParams[iteration].phiCut,
+            constants::MaxSelectedTrackletsPerCluster);
           totalLines.local() += mTimeFrame->getLines(pivotRofId).size();
         }
       });
diff --git a/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx b/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx
index 8594e59149444..dd98a75efca7c 100644
--- a/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx
@@ -135,6 +135,78 @@ BOOST_AUTO_TEST_CASE(rofoverlap_staggered_pp)
   view.printAll();
 }
 
+BOOST_AUTO_TEST_CASE(rofoverlap_staggered_track_time_ignores_added_error)
+{
+  const uint32_t rofLen{198};
+  const uint32_t rofDelay{33};
+  const uint32_t addTimeErr{100};
+
+  o2::its::ROFOverlapTable<7> tableNoError;
+  o2::its::ROFOverlapTable<7> tableWithError;
+  for (uint32_t lay{0}; lay < 7; ++lay) {
+    const auto delay = (lay == 6) ? 0 : lay * rofDelay;
+    tableNoError.defineLayer(lay, 2, rofLen, delay, 0, 0);
+    tableWithError.defineLayer(lay, 2, rofLen, delay, 0, addTimeErr);
+  }
+
+  auto getCommonTrackTime = [](const auto& table) {
+    auto ts = table.getLayer(0).getROFTimeBounds(0);
+    for (uint32_t lay{1}; lay < 7; ++lay) {
+      ts += table.getLayer(lay).getROFTimeBounds(0);
+    }
+    return ts.makeSymmetrical();
+  };
+
+  const auto tsNoError = getCommonTrackTime(tableNoError);
+  BOOST_CHECK_EQUAL(tsNoError.getTimeStamp(), 181.5f);
+  BOOST_CHECK_EQUAL(tsNoError.getTimeStampError(), 16.5f);
+
+  const auto tsWithError = getCommonTrackTime(tableWithError);
+  BOOST_CHECK_EQUAL(tsWithError.getTimeStamp(), 181.5f);
+  BOOST_CHECK_EQUAL(tsWithError.getTimeStampError(), 16.5f);
+}
+
+BOOST_AUTO_TEST_CASE(rofoverlap_track_time_boundary_migration_fallback)
+{
+  const uint32_t rofLen{198};
+  const uint32_t addTimeErr{30};
+
+  o2::its::ROFOverlapTable<7> table;
+  for (uint32_t lay{0}; lay < 7; ++lay) {
+    table.defineLayer(lay, 4, rofLen, 0, 0, addTimeErr);
+  }
+
+  auto getCommonTrackTime = [](const auto& table) {
+    bool firstCls{true}, nominalCompatible{true};
+    o2::its::TimeEstBC nominalTS, expandedTS;
+    for (uint32_t lay{0}; lay < 7; ++lay) {
+      const auto rof = lay < 3 ? 0 : 1;
+      const auto nominalROFTS = table.getLayer(lay).getROFTimeBounds(rof);
+      const auto expandedROFTS = table.getLayer(lay).getROFTimeBounds(rof, true);
+      if (firstCls) {
+        firstCls = false;
+        nominalTS = nominalROFTS;
+        expandedTS = expandedROFTS;
+      } else {
+        if (nominalCompatible) {
+          if (nominalTS.isCompatible(nominalROFTS)) {
+            nominalTS += nominalROFTS;
+          } else {
+            nominalCompatible = false;
+          }
+        }
+        BOOST_REQUIRE(expandedTS.isCompatible(expandedROFTS));
+        expandedTS += expandedROFTS;
+      }
+    }
+    return (nominalCompatible ? nominalTS : expandedTS).makeSymmetrical();
+  };
+
+  const auto tsWithError = getCommonTrackTime(table);
+  BOOST_CHECK_EQUAL(tsWithError.getTimeStamp(), 198.f);
+  BOOST_CHECK_EQUAL(tsWithError.getTimeStampError(), 30.f);
+}
+
 BOOST_AUTO_TEST_CASE(rofoverlap_staggered_alllayers)
 {
   // test staggered layers with ROF delay
diff --git a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
index 932c82c2d1ca4..bbafc48e931ed 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/TrackerSpec.cxx
@@ -85,8 +85,11 @@ void TrackerDPL::endOfStream(EndOfStreamContext& ec)
 
 void TrackerDPL::end()
 {
-  mITSTrackingInterface.printSummary();
-  LOGF(info, "ITS CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+  if (static bool printOnce{false}; !printOnce) {
+    printOnce = true;
+    mITSTrackingInterface.printSummary();
+    LOGF(info, "ITS CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+  }
 }
 
 DataProcessorSpec getTrackerSpec(bool useMC, bool doStag, bool useGeom, int trgType, TrackingMode::Type trMode, const bool overrBeamEst, o2::gpu::gpudatatypes::DeviceType dType)

From 011d107ba2e63b679fea977b237919498a470aff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Wed, 29 Apr 2026 20:42:31 +0200
Subject: [PATCH 1674/1764] [ALICE3] TF3: add proto-digitizer (#15340)

---
 .../Upgrades/ALICE3/IOTOF/CMakeLists.txt      |   1 +
 .../IOTOF/DataFormatsIOTOF/CMakeLists.txt     |  22 +++
 .../include/DataFormatsIOTOF/Digit.h          |  46 +++++
 .../src/DataFormatsIOTOFLinkDef.h             |  20 +++
 .../IOTOF/DataFormatsIOTOF/src/Digit.cxx      |  21 +++
 .../ALICE3/IOTOF/simulation/CMakeLists.txt    |   5 +-
 .../include/IOTOFSimulation/Digitizer.h       | 111 ++++++++++++
 .../ALICE3/IOTOF/simulation/src/Digitizer.cxx | 162 ++++++++++++++++++
 8 files changed, 387 insertions(+), 1 deletion(-)
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/include/DataFormatsIOTOF/Digit.h
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/DataFormatsIOTOFLinkDef.h
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/Digit.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/CMakeLists.txt b/Detectors/Upgrades/ALICE3/IOTOF/CMakeLists.txt
index 808320bf66404..04288f205d8f4 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/IOTOF/CMakeLists.txt
@@ -11,4 +11,5 @@
 
 add_subdirectory(base)
 add_subdirectory(simulation)
+add_subdirectory(DataFormatsIOTOF)
 add_subdirectory(macros)
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/CMakeLists.txt b/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/CMakeLists.txt
new file mode 100644
index 0000000000000..534e6217807c5
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/CMakeLists.txt
@@ -0,0 +1,22 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(DataFormatsIOTOF
+               SOURCES src/Digit.cxx
+            #    SOURCES src/MCLabel.cxx
+            #    SOURCES src/Cluster.cxx
+               PUBLIC_LINK_LIBRARIES O2::DataFormatsITSMFT)
+
+o2_target_root_dictionary(DataFormatsIOTOF
+                          HEADERS include/DataFormatsIOTOF/Digit.h
+                        #   HEADERS include/DataFormatsIOTOF/MCLabel.h
+                        #   HEADERS include/DataFormatsIOTOF/Cluster.h
+                          )
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/include/DataFormatsIOTOF/Digit.h b/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/include/DataFormatsIOTOF/Digit.h
new file mode 100644
index 0000000000000..19b5dc3bcd72b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/include/DataFormatsIOTOF/Digit.h
@@ -0,0 +1,46 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file Digit.h
+/// \brief Definition of IOTOF digit class
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
+/// \since 2026-03-17
+///
+
+#ifndef ALICEO2_IOTOF_DIGIT_H
+#define ALICEO2_IOTOF_DIGIT_H
+
+#include "DataFormatsITSMFT/Digit.h"
+
+namespace o2::iotof
+{
+class Digit : public o2::itsmft::Digit
+{
+ public:
+  Digit() = default;
+  ~Digit() = default;
+  Digit(UShort_t chipindex = 0, UShort_t row = 0, UShort_t col = 0, Int_t charge = 0, double time = 0.)
+    : o2::itsmft::Digit(chipindex, row, col, charge), mTime(time) {};
+
+  // Setters
+  void setTime(double time) { mTime = time; }
+
+  // Getters
+  double getTime() const { return mTime; }
+
+ private:
+  double mTime = 0.; ///< Measured time (ns)
+  ClassDefNV(Digit, 1);
+};
+
+} // namespace o2::iotof
+#endif // ALICEO2_IOTOF_DIGIT_H
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/DataFormatsIOTOFLinkDef.h b/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/DataFormatsIOTOFLinkDef.h
new file mode 100644
index 0000000000000..8a167df4d6c7b
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/DataFormatsIOTOFLinkDef.h
@@ -0,0 +1,20 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifdef __CLING__
+
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class o2::iotof::Digit + ;
+// #pragma link C++ class std::vector < o2::iotof::Digit> + ;
+#endif
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/Digit.cxx b/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/Digit.cxx
new file mode 100644
index 0000000000000..b15ecd94cd9af
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/DataFormatsIOTOF/src/Digit.cxx
@@ -0,0 +1,21 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file Digit.cxx
+/// \brief Implementation of IOTOF digit class
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
+/// \since 2026-03-17
+///
+
+#include "DataFormatsIOTOF/Digit.h"
+
+using namespace o2::iotof;
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt
index 5e7cbd87bfd35..f3418d9065fcb 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt
@@ -12,11 +12,14 @@
 o2_add_library(IOTOFSimulation
                SOURCES src/Layer.cxx
                        src/Detector.cxx
+                       src/Digitizer.cxx
                       #  src/IOTOFServices.cxx
                PUBLIC_LINK_LIBRARIES O2::IOTOFBase
+                                     O2::DataFormatsIOTOF
                                      O2::ITSMFTSimulation)
 
 o2_target_root_dictionary(IOTOFSimulation
                           HEADERS include/IOTOFSimulation/Detector.h
-                                  include/IOTOFSimulation/Layer.h)
+                                  include/IOTOFSimulation/Layer.h
+                                  include/IOTOFSimulation/Digitizer.h)
                                   # include/IOTOFSimulation/IOTOFServices.h)
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h
new file mode 100644
index 0000000000000..8964e33f8a1b6
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h
@@ -0,0 +1,111 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file Digitizer.h
+/// \brief Definition of the ALICE3 TOF digitizer
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
+/// \since 2026-03-17
+///
+
+#ifndef ALICEO2_IOTOF_DIGITIZER_H
+#define ALICEO2_IOTOF_DIGITIZER_H
+
+#include "ITSMFTSimulation/Hit.h"
+#include "DataFormatsITSMFT/Digit.h"
+#include "DataFormatsIOTOF/Digit.h"
+#include "DataFormatsITSMFT/ROFRecord.h"
+#include "CommonDataFormat/InteractionRecord.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "IOTOFBase/GeometryTGeo.h"
+
+namespace o2::iotof
+{
+
+/// \class Digitizer
+/// \brief Digitizer for the ALICE3 Inner/Outer TOF detector
+///
+/// Converts MC hits into detector digits by:
+/// - Applying time smearing according to detector resolution
+/// - Converting energy loss to charge
+/// - Applying charge threshold
+/// - Managing readout frames (ROF)
+class Digitizer
+{
+ public:
+  void setDigits(std::vector<o2::iotof::Digit>* dig) { mDigits = dig; }
+  void setMCLabels(o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mclb) { mMCLabels = mclb; }
+  void setROFRecords(std::vector<o2::itsmft::ROFRecord>* rec) { mROFRecords = rec; }
+
+  /// Initialize the digitizer
+  void init();
+
+  /// Steer conversion of hits to digits
+  void process(const std::vector<o2::itsmft::Hit>* hits, int evID, int srcID);
+
+  /// Set the event time
+  void setEventTime(const o2::InteractionTimeRecord& irt) { mEventTime = irt; }
+
+  /// Set continuous readout mode
+  void setContinuous(bool v) { mContinuous = v; }
+  bool isContinuous() const { return mContinuous; }
+
+  /// Flush the output container
+  void fillOutputContainer();
+
+  // 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);
+
+  /// Apply time smearing to simulate detector resolution
+  double smearTime(double time) const;
+
+  /// Convert energy loss to charge
+  int energyToCharge(float energyLoss) const;
+
+  /// Check if the hit passes efficiency cut
+  bool isEfficient() const;
+
+  static constexpr float sec2ns = 1e9f; ///< seconds to nanoseconds conversion
+
+  const o2::iotof::GeometryTGeo* mGeometry = nullptr; ///< IOTOF geometry
+
+  std::vector<o2::iotof::Digit>* mDigits = nullptr;                        //! output digits
+  std::vector<o2::itsmft::ROFRecord>* mROFRecords = nullptr;               //! output ROF records
+  o2::dataformats::MCTruthContainer<o2::MCCompLabel>* mMCLabels = nullptr; //! output labels
+
+  o2::InteractionTimeRecord mEventTime; ///< global event time and interaction record
+  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)
+};
+} // namespace o2::iotof
+
+#endif
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx
new file mode 100644
index 0000000000000..b865d6958ecfd
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx
@@ -0,0 +1,162 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+///
+/// \file Digitizer.cxx
+/// \brief Implementation of the ALICE3 TOF digitizer
+/// \author Nicolò Jacazio, Università del Piemonte Orientale (IT)
+/// \since 2026-03-17
+///
+
+#include "IOTOFSimulation/Digitizer.h"
+#include "DetectorsRaw/HBFUtils.h"
+
+#include <TRandom.h>
+#include <vector>
+#include <iostream>
+#include <numeric>
+#include <algorithm>
+#include <fairlogger/Logger.h>
+
+namespace o2::iotof
+{
+
+//_______________________________________________________________________
+void Digitizer::init()
+{
+  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) << "  Continuous mode: " << (mContinuous ? "ON" : "OFF");
+}
+
+//_______________________________________________________________________
+void Digitizer::process(const std::vector<o2::itsmft::Hit>* hits, int evID, int srcID)
+{
+  // Digitize hits from a single event
+  LOG(debug) << "Digitizing IOTOF hits: " << hits->size() << " hits from event " << evID << " source " << srcID;
+
+  if (!hits || hits->empty()) {
+    return;
+  }
+
+  // Sort hits by detector ID for better cache locality
+  std::vector<int> hitIdx(hits->size());
+  std::iota(hitIdx.begin(), hitIdx.end(), 0);
+  std::sort(hitIdx.begin(), hitIdx.end(),
+            [hits](int lhs, int rhs) {
+              return (*hits)[lhs].GetDetectorID() < (*hits)[rhs].GetDetectorID();
+            });
+
+  // Process each hit
+  for (int i : hitIdx) {
+    processHit((*hits)[i], evID, srcID);
+  }
+
+  // In triggered mode, flush output after each event
+  if (!mContinuous) {
+    fillOutputContainer();
+  }
+}
+
+//_______________________________________________________________________
+void Digitizer::processHit(const o2::itsmft::Hit& hit, int evID, int srcID)
+{
+  // Process a single hit and create a digit if it passes all cuts
+
+  // Apply efficiency cut
+  if (!isEfficient()) {
+    LOG(debug) << "Hit rejected by efficiency cut";
+    return;
+  }
+
+  // Get detector element ID
+  int detID = hit.GetDetectorID();
+
+  // Convert energy loss to charge (number of electrons)
+  float energyLoss = hit.GetEnergyLoss(); // in GeV
+  int charge = energyToCharge(energyLoss);
+
+  // Apply charge threshold
+  if (charge < mChargeThreshold) {
+    LOG(debug) << "Hit rejected by charge threshold: " << charge << " < " << mChargeThreshold;
+    return;
+  }
+
+  // Get hit time and apply smearing
+  // Hit time is in seconds, convert to ns and add event time
+  double hitTime = hit.GetTime() * sec2ns;      // convert to ns
+  double eventTimeNS = mEventTime.getTimeNS();  // event time since orbit 0
+  double absoluteTime = hitTime + eventTimeNS;  // absolute time
+  double smearedTime = smearTime(absoluteTime); // apply detector resolution
+
+  // For now, use simple row/col mapping from detector ID
+  // TODO: Implement proper segmentation when geometry is finalized
+  uint16_t chipIndex = static_cast<uint16_t>(detID);
+  uint16_t row = 0; // Will be determined from hit position
+  uint16_t col = 0; // Will be determined from hit position
+
+  // Create the digit with time information
+  int digID = mDigits->size();
+  mDigits->emplace_back(chipIndex, row, col, charge, smearedTime);
+
+  LOG(debug) << "Created digit #" << digID << " chip=" << chipIndex
+             << " charge=" << charge << " time=" << smearedTime << " ns";
+
+  // Add MC truth label
+  if (mMCLabels) {
+    o2::MCCompLabel lbl(hit.GetTrackID(), evID, srcID, false);
+    mMCLabels->addElement(digID, lbl);
+  }
+}
+
+//_______________________________________________________________________
+double Digitizer::smearTime(double time) const
+{
+  // Apply Gaussian smearing to simulate detector time resolution
+  if (mTimeResolution > 0) {
+    return time + gRandom->Gaus(0, mTimeResolution);
+  }
+  return time;
+}
+
+//_______________________________________________________________________
+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);
+}
+
+//_______________________________________________________________________
+bool Digitizer::isEfficient() const
+{
+  // Apply efficiency cut using random number
+  return gRandom->Uniform() < mEfficiency;
+}
+
+//_______________________________________________________________________
+void Digitizer::fillOutputContainer()
+{
+  // Create ROF record for the current event
+  if (mROFRecords && mDigits && !mDigits->empty()) {
+    o2::itsmft::ROFRecord rof;
+    rof.setFirstEntry(0);
+    rof.setNEntries(mDigits->size());
+    rof.setBCData(mEventTime);
+    mROFRecords->push_back(rof);
+    LOG(debug) << "Created ROF record with " << mDigits->size() << " digits";
+  }
+}
+
+} // namespace o2::iotof

From 38239f7417707ff1a9b91774a39006d15535fe01 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 30 Apr 2026 01:40:44 +0200
Subject: [PATCH 1675/1764] Avoid duplication of enable-M-shape-correction
 option

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 92e93e3977c65..5ab54f9cf4b43 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -325,7 +325,7 @@ while [[ $# -gt 0 ]]; do
   case "$1" in
     --lumi-type=*) TPC_CORR_OPT+=" --lumi-type ${1#*=}"; [[ ${1#*=} == "2" ]] && { IGNOREIDC=0; }; shift 1;;
     --lumi-type) TPC_CORR_OPT+=" --lumi-type ${2}"; [[ ${2} == "2" ]] && { IGNOREIDC=0; }; shift 2;;
-    --enable-M-shape-correction) TPC_CORR_OPT+=" --enable-M-shape-correction"; TPC_SCALERS_CONF+=" --enable-M-shape-correction" ; shift 1;;
+    --enable-M-shape-correction) TPC_CORR_OPT+=" --enable-M-shape-correction"; shift 1;;
     --corrmap-lumi-mode=*) TPC_CORR_OPT+=" --corrmap-lumi-mode ${1#*=}"; shift 1;;
     --corrmap-lumi-mode) TPC_CORR_OPT+=" --corrmap-lumi-mode ${2}"; shift 2;;
     --disable-ctp-lumi-request) TPC_CORR_OPT+=" --disable-ctp-lumi-request"; CTPLUMY_DISABLED=1; shift 1;;

From 499233f8c45ccab85a53e184744556805f96ea2d Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Thu, 30 Apr 2026 12:28:25 +0200
Subject: [PATCH 1676/1764] [ALICE3] TRK: introduce the staggering of ROFs in
 the TRK (#15335)

* ALICE3: Add method to get the TRK layer id

* ALICE3: introduce staggering logic in the digitizer

* ALICE3: Adapt test macros to new staggering structure

* ALICE3: adapt cluster finding to separated streams per layer

Fix CheckCluster macro

* Change macro name in CMakeLists.txt

* Fix Specs.h and use that in geometry building
---
 .../TRK/base/include/TRKBase/AlmiraParam.h    |  29 +-
 .../TRK/base/include/TRKBase/GeometryTGeo.h   |   3 +-
 .../ALICE3/TRK/base/include/TRKBase/Specs.h   |   2 +
 .../ALICE3/TRK/base/src/GeometryTGeo.cxx      |  16 +-
 .../ALICE3/TRK/macros/test/CMakeLists.txt     |   2 +-
 .../ALICE3/TRK/macros/test/CheckBandwidth.C   | 205 +++++-----
 .../ALICE3/TRK/macros/test/CheckClusters.C    | 380 +++++++++---------
 .../test/{CheckDigits.C => CheckDigitsTRK.C}  | 354 ++++++++--------
 .../include/TRKReconstruction/Clusterer.h     |   5 +-
 .../include/TRKReconstruction/ClustererACTS.h |   4 +-
 .../TRK/reconstruction/src/Clusterer.cxx      |  11 +-
 .../TRK/reconstruction/src/ClustererACTS.cxx  |   4 +-
 .../include/TRKSimulation/DigiParams.h        |  42 +-
 .../include/TRKSimulation/Digitizer.h         |  24 +-
 .../ALICE3/TRK/simulation/src/Detector.cxx    |  13 +-
 .../ALICE3/TRK/simulation/src/DigiParams.cxx  |  12 +-
 .../ALICE3/TRK/simulation/src/Digitizer.cxx   |  93 ++---
 .../include/TRKWorkflow/ClustererSpec.h       |   2 +
 .../include/TRKWorkflow/DigitReaderSpec.h     |  16 +-
 .../TRK/workflow/src/ClusterWriterSpec.cxx    |  86 +++-
 .../ALICE3/TRK/workflow/src/ClustererSpec.cxx | 126 +++---
 .../TRK/workflow/src/DigitReaderSpec.cxx      |  90 +++--
 .../TRK/workflow/src/DigitWriterSpec.cxx      | 105 +++--
 .../src/TRKDigitizerSpec.cxx                  | 302 +++++++-------
 24 files changed, 1018 insertions(+), 908 deletions(-)
 rename Detectors/Upgrades/ALICE3/TRK/macros/test/{CheckDigits.C => CheckDigitsTRK.C} (52%)

diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/AlmiraParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/AlmiraParam.h
index 2048666e21c00..9929a14c4e39c 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/AlmiraParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/AlmiraParam.h
@@ -12,21 +12,40 @@
 #ifndef O2_TRK_ALMIRAPARAM_H
 #define O2_TRK_ALMIRAPARAM_H
 
+#include <algorithm>
+
 #include "CommonConstants/LHCConstants.h"
 #include "CommonUtils/ConfigurableParam.h"
 #include "CommonUtils/ConfigurableParamHelper.h"
+#include "TRKBase/Specs.h"
 
 namespace o2
 {
 namespace trk
 {
-constexpr float DEFAlmiraStrobeDelay = 0.f; ///< default strobe delay in ns wrt ROF start, to be tuned with the real chip response
 
 struct AlmiraParam : public o2::conf::ConfigurableParamHelper<AlmiraParam> {
-  int roFrameLengthInBC = o2::constants::lhc::LHCMaxBunches / 198; ///< ROF length in BC for continuous mode
-  float strobeDelay = DEFAlmiraStrobeDelay;                        ///< strobe start in ns wrt ROF start
-  float strobeLengthCont = -1.;                                    ///< if < 0, full ROF length minus delay
-  int roFrameBiasInBC = 0;                                         ///< ROF start bias in BC wrt orbit start
+  static constexpr size_t kNLayers = constants::VD::petal::nLayers + constants::ML::nLayers + constants::OT::nLayers;
+  static constexpr size_t getNLayers() { return kNLayers; }
+
+  int roFrameLengthInBCPerLayer[kNLayers] = {0};  ///< ROF length in BC per layer
+  float strobeDelayPerLayer[kNLayers] = {0};      ///< strobe delay in ns per layer
+  float strobeLengthContPerLayer[kNLayers] = {0}; ///< strobe length in ns per layer
+  int roFrameBiasInBCPerLayer[kNLayers] = {0};    ///< ROF start bias in BC per layer
+  int roFrameDelayInBCPerLayer[kNLayers] = {0};   ///< extra ROF delay in BC per layer
+
+  int getROFLengthInBC(int layer) const
+  {
+    if (roFrameLengthInBCPerLayer[layer] > 0) {
+      return roFrameLengthInBCPerLayer[layer];
+    } else {
+      return o2::constants::lhc::LHCMaxBunches / 198;
+    }
+  }
+  float getStrobeDelay(int layer) const { return strobeDelayPerLayer[layer]; }
+  float getStrobeLengthCont(int layer) const { return strobeLengthContPerLayer[layer]; }
+  int getROFBiasInBC(int layer) const { return roFrameBiasInBCPerLayer[layer]; }
+  int getROFDelayInBC(int layer) const { return roFrameDelayInBCPerLayer[layer]; }
 
   O2ParamDef(AlmiraParam, "TRKAlmiraParam");
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
index 576dbf434f757..53ad7662cbfcd 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/GeometryTGeo.h
@@ -89,7 +89,8 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   int getSubDetID(int index) const;
   int getPetalCase(int index) const;
   int getDisk(int index) const;
-  int getLayer(int index) const;
+  int getLayer(int index) const;    ///< local layer index within the sub-detector (0-based per VD/MLOT)
+  int getLayerTRK(int index) const; ///< global layer index across the full TRK (VD layers 0..nVD-1, MLOT layers nVD..nTotal-1)
   int getStave(int index) const;
   int getHalfStave(int index) const;
   int getModule(int index) const;
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index 91d6f5669ef33..0ed7ca6a8a8d4 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -100,6 +100,7 @@ constexpr int nCols{static_cast<int>(length / chip::pitchZ)};
 
 namespace ML
 {
+constexpr int nLayers{5};                                 // number of layers in the ML
 constexpr double width{constants::moduleMLOT::width * 1}; // width of the stave
 // constexpr double length{constants::moduleMLOT::length * 10};                         // length of the stave
 constexpr double length{124 * cm};                                                   // length of the stave, hardcoded to fit the implemented geometry
@@ -117,6 +118,7 @@ constexpr double length{258 * cm};                                        // len
 constexpr int nRows{static_cast<int>(width / moduleMLOT::chip::pitchX)};  // number of rows in the halfstave
 constexpr int nCols{static_cast<int>(length / moduleMLOT::chip::pitchZ)}; // number of columns in the halfstave
 } // namespace halfstave
+constexpr int nLayers{3};                                                 // number of layers in the OT
 constexpr double width{halfstave::width * 2};                             // width of the stave
 constexpr double length{halfstave::length};                               // length of the stave
 constexpr int nRows{static_cast<int>(width / moduleMLOT::chip::pitchX)};  // number of rows in the stave
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
index 10c1c63615d35..ddfc844cc964d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/base/src/GeometryTGeo.cxx
@@ -12,6 +12,7 @@
 #include <TRKBase/GeometryTGeo.h>
 #include <TGeoManager.h>
 #include "TRKBase/SegmentationChip.h"
+#include "TRKBase/Specs.h"
 #include <TMath.h>
 
 #include <limits>
@@ -64,7 +65,7 @@ GeometryTGeo::GeometryTGeo(bool build, int loadTrans) : DetMatrixCache(detectors
 void GeometryTGeo::Build(int loadTrans)
 {
   ///// current geometry organization:
-  ///// total elements = x staves (*2 half staves if staggered geometry) * 8 layers ML+OT + 4 petal cases * (3 layers + 6 disks)
+  ///// total elements = x staves (*2 half staves if staggered geometry) * ML+OT layers + 4 petal cases * (3 layers + 6 disks)
   ///// indexing from 0 to 35: VD petals -> layers -> disks
   ///// indexing from 36 to y: MLOT staves
 
@@ -203,6 +204,15 @@ int GeometryTGeo::getLayer(int index) const
   return -1; /// -1 if not found
 }
 //__________________________________________________________________________
+int GeometryTGeo::getLayerTRK(int index) const
+{
+  if (getDisk(index) != -1) {
+    return -1; /// disks do not have a global layer index
+  }
+  int subDetID = getSubDetID(index);
+  return subDetID * o2::trk::constants::VD::petal::nLayers + getLayer(index); // MLOT: offset by number of VD layers
+}
+//__________________________________________________________________________
 int GeometryTGeo::getStave(int index) const
 {
   int subDetID = getSubDetID(index);
@@ -1121,7 +1131,7 @@ void GeometryTGeo::Print(Option_t*) const
   std::cout << "Detector ID: " << sInstance.get()->getDetID() << std::endl;
 
   LOGF(info, "Summary of GeometryTGeo: %s", getName());
-  LOGF(info, "Number of layers ML + OL: %d", mNumberOfLayersMLOT);
+  LOGF(info, "Number of layers ML + OT: %d", mNumberOfLayersMLOT);
   LOGF(info, "Number of active parts VD: %d", mNumberOfActivePartsVD);
   LOGF(info, "Number of layers VD: %d", mNumberOfLayersVD);
   LOGF(info, "Number of petals VD: %d", mNumberOfPetalsVD);
@@ -1133,7 +1143,7 @@ void GeometryTGeo::Print(Option_t*) const
   LOGF(info, "Number of staves and half staves per layer MLOT: ");
   for (int i = 0; i < mNumberOfLayersMLOT; i++) {
     std::string mlot = "";
-    mlot = (i < 4) ? "ML" : "OT";
+    mlot = (i < constants::ML::nLayers) ? "ML" : "OT";
     LOGF(info, "Layer: %d, %s, %d staves, %d half staves per stave", i, mlot.c_str(), mNumberOfStaves[i], mNumberOfHalfStaves[i]);
   }
   LOGF(info, "Number of modules per stave (half stave) in each ML(OT) layer: ");
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
index 33d1b4a5afdc6..cdae7c9c379fd 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CMakeLists.txt
@@ -21,7 +21,7 @@ o2_add_test_root_macro(CheckBandwidth.C
                                              O2::Steer
                        LABELS trk COMPILE_ONLY)
 
-o2_add_test_root_macro(CheckDigits.C
+o2_add_test_root_macro(CheckDigitsTRK.C
                        PUBLIC_LINK_LIBRARIES O2::ITSMFTBase
                                              O2::ITSMFTSimulation
                                              O2::TRKBase
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C
index 06d24361c7721..c071a06516d30 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckBandwidth.C
@@ -41,13 +41,9 @@
 namespace
 {
 constexpr double DigitBits = 24.;
-constexpr double BunchCrossingNS = 25.;
-constexpr int ReadoutCycleBC = 18;
-constexpr int ReadoutCycleSimBC = 18;
-constexpr double ReadoutCycleSeconds = ReadoutCycleBC * BunchCrossingNS * 1.e-9;
 } // namespace
 
-void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGeom = "o2sim_geometry.root", std::string collContextFile = "collisioncontext.root")
+void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGeom = "sgn_geometry.root", std::string collContextFile = "collisioncontext.root")
 {
   gStyle->SetPalette(55);
   gStyle->SetOptStat(0);
@@ -73,15 +69,14 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
     latex.DrawLatex(0.04, 0.06, Form("avg non-empty: %.3f collisions/ROF", nonEmptyAverageValue));
   };
 
-  auto drawCollisionInfoBox = [](double averageValue) {
-    const double effectiveIRRateHz = ReadoutCycleSeconds > 0. ? averageValue / ReadoutCycleSeconds : 0.;
+  auto drawCollisionInfoBox = [](double effectiveIRRateHz, double rofLengthBC) {
     TPaveText infoBox(0.55, 0.79, 0.88, 0.9, "NDC");
     infoBox.SetFillColor(0);
     infoBox.SetBorderSize(1);
     infoBox.SetTextAlign(12);
     infoBox.SetTextSize(0.028);
     infoBox.AddText(Form("effective IR: %.3f MHz", effectiveIRRateHz * 1.e-6));
-    infoBox.AddText(Form("ROF length: %d BC", ReadoutCycleBC));
+    infoBox.AddText(Form("ROF length: %d BC", rofLengthBC));
     infoBox.DrawClone();
   };
 
@@ -168,13 +163,42 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
     }
   }
 
+  // --- Digits ---
+
+  TFile* digFile = TFile::Open(digifile.data());
+  TTree* digTree = (TTree*)digFile->Get("o2sim");
+  const int nDigitTreeEntries = digTree->GetEntries();
+
+  std::vector<std::vector<o2::itsmft::Digit>*> digArr(nTotalLayers, nullptr);
+  std::vector<std::vector<o2::itsmft::ROFRecord>*> rofRecords(nTotalLayers, nullptr);
+  for (int nDigitsLayer{0}; nDigitsLayer < nTotalLayers; ++nDigitsLayer) {
+    if (!digTree->GetBranch(Form("TRKDigit_%i", nDigitsLayer))) {
+      break;
+    }
+    digTree->SetBranchAddress(Form("TRKDigit_%i", nDigitsLayer), &digArr[nDigitsLayer]);
+    digTree->SetBranchAddress(Form("TRKDigitROF_%i", nDigitsLayer), &rofRecords[nDigitsLayer]);
+  }
+
+  digTree->GetEntry(0);
+  if (nDigitTreeEntries > 1) {
+    LOG(warning) << "Digit tree has " << nDigitTreeEntries << " entries, but this macro processes entry 0 only.";
+  }
+
+  std::vector<unsigned int> rofLengthBC(nTotalLayers, 0u);
+  for (int iLayer = 0; iLayer < nTotalLayers; ++iLayer) {
+    if (rofRecords[iLayer]->size() < 2) {
+      LOG(fatal) << "ROF record tree for layer " << iLayer << " has " << rofRecords[iLayer]->size()
+                 << " entries, but at least 2 are expected (one per ROF + one empty at the end). Check input files.";
+    }
+    rofLengthBC[iLayer] = (*rofRecords[iLayer])[1].getBCData().bc - (*rofRecords[iLayer])[0].getBCData().bc;
+  }
+
   // --- Collision context ---
 
   TFile* ccFile = TFile::Open(collContextFile.data());
   auto* digiContext = (o2::steer::DigitizationContext*)ccFile->Get("DigitizationContext");
   const o2::InteractionRecord firstSampledIR{0, digiContext->getFirstOrbitForSampling()};
-  std::vector<unsigned int> collisionsPerROF;
-
+  std::vector<std::vector<unsigned int>> collisionsPerROF(nTotalLayers);
   for (const auto& record : digiContext->getEventRecords()) {
     auto nbc = record.differenceInBC(firstSampledIR);
     if (record.getTimeOffsetWrtBC() < 0. && nbc > 0) {
@@ -183,63 +207,47 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
     if (nbc < 0) {
       continue;
     }
-    const size_t rofID = nbc / ReadoutCycleSimBC;
-    if (rofID >= collisionsPerROF.size()) {
-      collisionsPerROF.resize(rofID + 1, 0u);
+    for (int iLayer = 0; iLayer < nTotalLayers; ++iLayer) {
+      if (rofLengthBC[iLayer] == 0) {
+        LOG(fatal) << "ROF length in BC for layer " << iLayer << " is zero. Check input files.";
+      }
+      const size_t rofID = nbc / rofLengthBC[iLayer];
+      if (rofID >= collisionsPerROF[iLayer].size()) {
+        collisionsPerROF[iLayer].resize(rofID + 1, 0u);
+      }
+      ++collisionsPerROF[iLayer][rofID];
     }
-    ++collisionsPerROF[rofID];
   }
 
-  // --- Digits ---
-
-  TFile* digFile = TFile::Open(digifile.data());
-  TTree* digTree = (TTree*)digFile->Get("o2sim");
-  const int nDigitTreeEntries = digTree->GetEntries();
-
-  std::vector<o2::itsmft::Digit>* digArr = nullptr;
-  std::vector<o2::itsmft::ROFRecord>* rofRecords = nullptr;
-  digTree->SetBranchAddress("TRKDigit", &digArr);
-  digTree->SetBranchAddress("TRKDigitROF", &rofRecords);
-
-  digTree->GetEntry(0);
-  if (nDigitTreeEntries > 1) {
-    LOG(warning) << "Digit tree has " << nDigitTreeEntries << " entries, but this macro processes entry 0 only.";
-  }
-
-  const int nROFRec = (int)rofRecords->size();
-  if (nROFRec != (int)collisionsPerROF.size()) {
+  const int nROFRec = (int)rofRecords[0]->size();
+  if (nROFRec != (int)collisionsPerROF[0].size()) {
     LOG(fatal) << "Mismatch between number of ROF records in digit tree (" << nROFRec
-               << ") and number of ROFs computed from collisioncontext.root (" << collisionsPerROF.size()
+               << ") and number of ROFs computed from collisioncontext.root (" << collisionsPerROF[0].size()
                << "). Check input files.";
   }
 
   // --- Accumulate per-chip digit counts across all ROFs ---
 
-  const double rofNorm = nROFRec > 0 ? 1. / nROFRec : 0.;
-  const double bitsToGbps = ReadoutCycleSeconds > 0. ? DigitBits / ReadoutCycleSeconds / 1.e9 : 0.;
-
   std::vector<unsigned long long> digitsPerChip(nChips, 0ull);
   std::vector<unsigned int> maxDigitsPerROFPerChip(nChips, 0u);
   std::vector<unsigned int> digitsInCurrentROFPerChip(nChips, 0u);
 
-  for (unsigned int iROF = 0; iROF < rofRecords->size(); ++iROF) {
+  for (unsigned int iROF = 0; iROF < (unsigned int)nROFRec; ++iROF) {
     std::vector<int> touchedChips;
-    const unsigned int rofStart = (*rofRecords)[iROF].getFirstEntry();
-    const unsigned int rofEnd = rofStart + (*rofRecords)[iROF].getNEntries();
-
-    for (unsigned int iDigit = rofStart; iDigit < rofEnd; ++iDigit) {
-      if (iDigit % 1000 == 0) {
-        std::cout << "Reading digit " << iDigit << " / " << digArr->size() << "\r" << std::flush;
-      }
-      const int chipID = (*digArr)[iDigit].getChipIndex();
-      if (chipGeom[chipID].disk != -1) {
-        continue;
-      }
-      if (digitsInCurrentROFPerChip[chipID] == 0) {
-        touchedChips.push_back(chipID);
+    for (int iLayer = 0; iLayer < nTotalLayers; ++iLayer) {
+      const unsigned int rofStart = (*rofRecords[iLayer])[iROF].getFirstEntry();
+      const unsigned int rofEnd = rofStart + (*rofRecords[iLayer])[iROF].getNEntries();
+      for (unsigned int iDigit = rofStart; iDigit < rofEnd; ++iDigit) {
+        const int chipID = (*digArr[iLayer])[iDigit].getChipIndex();
+        if (chipGeom[chipID].disk != -1) {
+          continue;
+        }
+        if (digitsInCurrentROFPerChip[chipID] == 0) {
+          touchedChips.push_back(chipID);
+        }
+        ++digitsPerChip[chipID];
+        ++digitsInCurrentROFPerChip[chipID];
       }
-      ++digitsPerChip[chipID];
-      ++digitsInCurrentROFPerChip[chipID];
     }
 
     for (const int chipID : touchedChips) {
@@ -273,19 +281,21 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
   // digitsInCurrentROFPerChip is all zeros after the first scan — reuse it here.
   {
     std::vector<int> touchedChips;
-    for (unsigned int iROF = 0; iROF < rofRecords->size(); ++iROF) {
+    for (unsigned int iROF = 0; iROF < (unsigned int)nROFRec; ++iROF) {
       touchedChips.clear();
-      const unsigned int rofStart = (*rofRecords)[iROF].getFirstEntry();
-      const unsigned int rofEnd = rofStart + (*rofRecords)[iROF].getNEntries();
-      for (unsigned int iDigit = rofStart; iDigit < rofEnd; ++iDigit) {
-        const int chipID = (*digArr)[iDigit].getChipIndex();
-        if (chipGeom[chipID].disk != -1) {
-          continue;
+      for (int iLayer = 0; iLayer < nTotalLayers; ++iLayer) {
+        const unsigned int rofStart = (*rofRecords[iLayer])[iROF].getFirstEntry();
+        const unsigned int rofEnd = rofStart + (*rofRecords[iLayer])[iROF].getNEntries();
+        for (unsigned int iDigit = rofStart; iDigit < rofEnd; ++iDigit) {
+          const int chipID = (*digArr[iLayer])[iDigit].getChipIndex();
+          if (chipGeom[chipID].disk != -1) {
+            continue;
+          }
+          if (digitsInCurrentROFPerChip[chipID] == 0) {
+            touchedChips.push_back(chipID);
+          }
+          ++digitsInCurrentROFPerChip[chipID];
         }
-        if (digitsInCurrentROFPerChip[chipID] == 0) {
-          touchedChips.push_back(chipID);
-        }
-        ++digitsInCurrentROFPerChip[chipID];
       }
       for (const int chipID : touchedChips) {
         const int l = chipGeom[chipID].globalLayer;
@@ -321,7 +331,7 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
       continue;
     }
     const int l = g.globalLayer;
-    const double avgDigits = digitsPerChip[chipID] * rofNorm;
+    const double avgDigits = digitsPerChip[chipID] / collisionsPerROF[l].size();
     const double maxDigits = (double)maxDigitsPerROFPerChip[chipID];
     layerStats[l].avgDigitsPerROF += avgDigits;
     layerStats[l].avgMaxDigitsPerROF += maxDigits;
@@ -334,37 +344,50 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
       layerStats[l].avgDigitsPerROF *= norm;
       layerStats[l].avgMaxDigitsPerROF *= norm;
     }
-    layerStats[l].avgBandwidthGbps = layerStats[l].avgDigitsPerROF * bitsToGbps;
-    layerStats[l].peakBandwidthGbps = layerStats[l].peakAvgDigitsPerROF * bitsToGbps;
+    layerStats[l].avgBandwidthGbps = layerStats[l].avgDigitsPerROF * DigitBits / rofLengthBC[l] / o2::constants::lhc::LHCBunchSpacingNS * 1.e9;
+    layerStats[l].peakBandwidthGbps = layerStats[l].peakAvgDigitsPerROF * DigitBits / rofLengthBC[l] / o2::constants::lhc::LHCBunchSpacingNS * 1.e9;
   }
 
   // --- Collision plots ---
 
   if (nROFRec > 0) {
-    auto* hCollisionsPerROF = new TH1D("h_collisions_per_rof", "Collisions per ROF;ROF id;N collisions",
-                                       nROFRec, -0.5, nROFRec - 0.5);
-    double totalCollisionsPerROF = 0.;
-    double peakCollisionsPerROF = 0.;
-    int nNonEmptyROFs = 0;
-
-    for (int rofID = 0; rofID < nROFRec; ++rofID) {
-      const double nColl = collisionsPerROF[rofID];
-      hCollisionsPerROF->SetBinContent(rofID + 1, nColl);
-      totalCollisionsPerROF += nColl;
-      peakCollisionsPerROF = std::max(peakCollisionsPerROF, nColl);
-      if (nColl > 0.) {
-        ++nNonEmptyROFs;
+    std::vector<double> totalCollisionsPerROF(nTotalLayers, 0.);
+    std::vector<double> peakCollisionsPerROF(nTotalLayers, 0.);
+    std::vector<int> nNonEmptyROFs(nTotalLayers, 0);
+    std::vector<TH1D*> hCollisionsPerROFPerLayer(nTotalLayers, nullptr);
+
+    for (int iLayer = 0; iLayer < nTotalLayers; ++iLayer) {
+      hCollisionsPerROFPerLayer[iLayer] = new TH1D(Form("h_collisions_per_rof_layer%d", iLayer),
+                                                   Form("Layer %d;ROF id;N collisions", iLayer),
+                                                   nROFRec, -0.5, nROFRec - 0.5);
+      for (int rofID = 0; rofID < nROFRec; ++rofID) {
+        const double nColl = collisionsPerROF[iLayer][rofID];
+        hCollisionsPerROFPerLayer[iLayer]->SetBinContent(rofID + 1, nColl);
+        totalCollisionsPerROF[iLayer] += nColl;
+        peakCollisionsPerROF[iLayer] = std::max(peakCollisionsPerROF[iLayer], nColl);
+        if (nColl > 0.) {
+          ++nNonEmptyROFs[iLayer];
+        }
       }
     }
 
-    const double avgCollisionsPerROF = totalCollisionsPerROF / nROFRec;
-    auto* canvCollisionsPerROF = new TCanvas("canvCollisionsPerROF", "Collisions per ROF", 1050, 1050);
-    canvCollisionsPerROF->SetTopMargin(0.08);
-    hCollisionsPerROF->Draw("hist");
-    drawCollisionSummary(avgCollisionsPerROF,
-                         nNonEmptyROFs > 0 ? totalCollisionsPerROF / nNonEmptyROFs : 0.,
-                         peakCollisionsPerROF);
-    drawCollisionInfoBox(avgCollisionsPerROF);
+    const int nCols = std::max(1, (int)std::ceil(std::sqrt((double)nTotalLayers)));
+    const int nRows = (nTotalLayers + nCols - 1) / nCols;
+    auto* canvCollisionsPerROF = new TCanvas("canvCollisionsPerROF", "Collisions per ROF", 350 * nCols, 300 * nRows);
+    canvCollisionsPerROF->Divide(nCols, nRows);
+    for (int iLayer = 0; iLayer < nTotalLayers; ++iLayer) {
+      canvCollisionsPerROF->cd(iLayer + 1);
+      gPad->SetTopMargin(0.10);
+      gPad->SetBottomMargin(0.14);
+      gPad->SetLeftMargin(0.14);
+      hCollisionsPerROFPerLayer[iLayer]->Draw("hist");
+      const double avgCollisionsPerROF = totalCollisionsPerROF[iLayer] / collisionsPerROF[iLayer].size();
+      drawCollisionSummary(avgCollisionsPerROF,
+                           nNonEmptyROFs[iLayer] > 0 ? totalCollisionsPerROF[iLayer] / nNonEmptyROFs[iLayer] : 0.,
+                           peakCollisionsPerROF[iLayer]);
+      const double effectiveIRRateHz = avgCollisionsPerROF / rofLengthBC[iLayer] / o2::constants::lhc::LHCBunchSpacingNS * 1.e9;
+      drawCollisionInfoBox(effectiveIRRateHz, rofLengthBC[iLayer]);
+    }
     appendCanvasToPdf(canvCollisionsPerROF);
   }
 
@@ -405,9 +428,9 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
     if (g.petal < 0 || g.petal >= nVDPetals) {
       continue;
     }
-    const double avgDigits = digitsPerChip[chipID] * rofNorm;
+    const double avgDigits = double(digitsPerChip[chipID]) / collisionsPerROF[g.globalLayer].size();
     const double maxDigits = (double)maxDigitsPerROFPerChip[chipID];
-    const double bandwidth = avgDigits * bitsToGbps;
+    const double bandwidth = avgDigits * DigitBits / rofLengthBC[g.globalLayer] / o2::constants::lhc::LHCBunchSpacingNS * 1.e9;
 
     hVDDigitsPerROF->SetBinContent(g.petal + 1, g.localLayer + 1, avgDigits);
     hVDMaxDigitsPerROF->SetBinContent(g.petal + 1, g.localLayer + 1, maxDigits);
@@ -483,12 +506,12 @@ void CheckBandwidth(std::string digifile = "trkdigits.root", std::string inputGe
         continue;
       }
       const double staveBinX = g.stave + (g.halfStave + 0.5) / nHalfStaves - 0.5;
-      const double avgDigits = digitsPerChip[chipID] * rofNorm;
+      const double avgDigits = double(digitsPerChip[chipID]) / collisionsPerROF[g.globalLayer].size();
       const double maxDigits = (double)maxDigitsPerROFPerChip[chipID];
 
       hDigitsPerROF->Fill(staveBinX, sensorID, avgDigits);
       hMaxDigitsPerROF->Fill(staveBinX, sensorID, maxDigits);
-      hBandwidth->Fill(staveBinX, sensorID, avgDigits * bitsToGbps);
+      hBandwidth->Fill(staveBinX, sensorID, avgDigits * DigitBits / rofLengthBC[g.globalLayer] / o2::constants::lhc::LHCBunchSpacingNS * 1.e9);
     }
 
     const auto& ls = layerStats[outputLayer];
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
index 327577102d86e..28dc61aed9c8b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
@@ -26,6 +26,7 @@
 
 #include "DataFormatsTRK/Cluster.h"
 #include "DataFormatsTRK/ROFRecord.h"
+#include "TRKBase/AlmiraParam.h"
 #include "TRKBase/GeometryTGeo.h"
 #include "TRKBase/SegmentationChip.h"
 #include "TRKSimulation/Hit.h"
@@ -142,47 +143,63 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
     return;
   }
 
-  std::vector<o2::trk::Cluster>* clusArr = nullptr;
-  std::vector<o2::trk::ROFRecord>* rofRecVecP = nullptr;
-  std::vector<unsigned char>* patternsPtr = nullptr;
-  clusTree->SetBranchAddress("TRKClusterComp", &clusArr);
-  clusTree->SetBranchAddress("TRKClustersROF", &rofRecVecP);
-  if (clusTree->GetBranch("TRKClusterPatt") != nullptr) {
-    clusTree->SetBranchAddress("TRKClusterPatt", &patternsPtr);
+  // Read per-layer cluster branches and accumulate
+  static constexpr int nLayers = o2::trk::AlmiraParam::kNLayers;
+  std::vector<std::vector<o2::trk::Cluster>*> clusArrPerLayer(nLayers, nullptr);
+  std::vector<std::vector<o2::trk::ROFRecord>*> rofRecVecPerLayer(nLayers, nullptr);
+  std::vector<std::vector<unsigned char>*> patternsPerLayer(nLayers, nullptr);
+  std::vector<o2::dataformats::MCTruthContainer<o2::MCCompLabel>*> clusLabArrPerLayer(nLayers, nullptr);
+
+  bool hasMC = true;
+  for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    std::string brClus = std::string("TRKClusterComp_") + std::to_string(iLayer);
+    std::string brROF = std::string("TRKClustersROF_") + std::to_string(iLayer);
+    std::string brPatt = std::string("TRKClusterPatt_") + std::to_string(iLayer);
+    std::string brMCTruth = std::string("TRKClusterMCTruth_") + std::to_string(iLayer);
+
+    if (clusTree->GetBranch(brClus.c_str()) == nullptr) {
+      LOGP(warning, "Branch {} not found, skipping layer {}", brClus, iLayer);
+      continue;
+    }
+    clusTree->SetBranchAddress(brClus.c_str(), &clusArrPerLayer[iLayer]);
+    clusTree->SetBranchAddress(brROF.c_str(), &rofRecVecPerLayer[iLayer]);
+    if (clusTree->GetBranch(brPatt.c_str()) != nullptr) {
+      clusTree->SetBranchAddress(brPatt.c_str(), &patternsPerLayer[iLayer]);
+    }
+    if (clusTree->GetBranch(brMCTruth.c_str()) != nullptr) {
+      clusTree->SetBranchAddress(brMCTruth.c_str(), &clusLabArrPerLayer[iLayer]);
+    } else {
+      hasMC = false;
+    }
   }
 
-  o2::dataformats::MCTruthContainer<o2::MCCompLabel>* clusLabArr = nullptr;
-  std::vector<MC2ROF> mc2rofVec, *mc2rofVecP = &mc2rofVec;
-  bool hasMC = (clusTree->GetBranch("TRKClusterMCTruth") != nullptr);
-  if (hasMC) {
-    clusTree->SetBranchAddress("TRKClusterMCTruth", &clusLabArr);
-    clusTree->SetBranchAddress("TRKClustersMC2ROF", &mc2rofVecP);
+  // Read entry and accumulate all layers
+  clusTree->GetEntry(0);
+  // Print total clusters per layer
+  for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    LOGP(info, "Layer {}: {} clusters", iLayer, clusArrPerLayer[iLayer]->size());
   }
 
-  clusTree->GetEntry(0);
-  const unsigned int nROFRec = rofRecVecP ? (unsigned int)rofRecVecP->size() : 0u;
+  // Accumulate max ROF count across all layers
+  unsigned int nROFRec = 0;
+  for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    nROFRec = std::max(nROFRec, (unsigned int)rofRecVecPerLayer[iLayer]->size());
+  }
   LOGP(info, "Number of ROF records: {}", nROFRec);
-  auto pattIt = patternsPtr ? patternsPtr->cbegin() : std::vector<unsigned char>::const_iterator{};
 
-  // ── Build per-ROF MC event range ───────────────────────────────────────────
-  std::vector<int> mcEvMin(nROFRec, (int)hitTree->GetEntries());
-  std::vector<int> mcEvMax(nROFRec, -1);
+  // ── Load all MC hit events upfront (TRK has no MC2ROF mapping) ──────────────
   if (hasMC) {
-    for (int imc = (int)mc2rofVec.size(); imc--;) {
-      const auto& mc2rof = mc2rofVec[imc];
-      if (mc2rof.rofRecordID < 0) {
-        continue;
-      }
-      for (unsigned int irfd = mc2rof.maxROF - mc2rof.minROF + 1; irfd--;) {
-        unsigned int irof = mc2rof.rofRecordID + irfd;
-        if (irof >= nROFRec) {
-          continue;
-        }
-        if (mcEvMin[irof] > imc) {
-          mcEvMin[irof] = imc;
-        }
-        if (mcEvMax[irof] < imc) {
-          mcEvMax[irof] = imc;
+    LOGP(info, "Pre-loading {} MC events", hitTree->GetEntries());
+    for (int im = 0; im < (int)hitTree->GetEntries(); im++) {
+      if (hitVecPool[im] == nullptr) {
+        hitTree->SetBranchAddress("TRKHit", &hitVecPool[im]);
+        hitTree->GetEntry(im);
+        auto& mc2hit = mc2hitVec[im];
+        const auto* hv = hitVecPool[im];
+        for (int ih = (int)hv->size(); ih--;) {
+          const auto& hit = (*hv)[ih];
+          uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
+          mc2hit.emplace(key, ih);
         }
       }
     }
@@ -203,170 +220,165 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
 
   // ── Main loop ──────────────────────────────────────────────────────────────
   for (unsigned int irof = 0; irof < nROFRec; irof++) {
-    const auto& rofRec = (*rofRecVecP)[irof];
-
-    // Cache MC hit events for this ROF
-    if (hasMC) {
-      for (int im = mcEvMin[irof]; im <= mcEvMax[irof]; im++) {
-        if (hitVecPool[im] == nullptr) {
-          hitTree->SetBranchAddress("TRKHit", &hitVecPool[im]);
-          hitTree->GetEntry(im);
-          auto& mc2hit = mc2hitVec[im];
-          const auto* hv = hitVecPool[im];
-          for (int ih = (int)hv->size(); ih--;) {
-            const auto& hit = (*hv)[ih];
-            uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
-            mc2hit.emplace(key, ih);
-          }
-        }
+    // Process each layer
+    for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+      if (rofRecVecPerLayer[iLayer]->empty() || irof >= rofRecVecPerLayer[iLayer]->size()) {
+        continue;
       }
-    }
-
-    for (int icl = 0; icl < rofRec.getNEntries(); icl++) {
-      const int clEntry = rofRec.getFirstEntry() + icl;
-      const auto& cluster = (*clusArr)[clEntry];
-      nTot++;
-
-      // ── Parse pattern → center-of-gravity within bounding box ──────────
-      // The cluster stores the bounding-box top-left pixel (row, col).
-      // The pattern stream encodes [rowSpan, colSpan, bitmap...] for each cluster.
-      // We accumulate pixel row/col offsets to obtain a sub-pixel CoG correction.
-      float cogDr{0.f}, cogDc{0.f}; // mean offsets from bbox origin (pixels)
-      if (patternsPtr) {
-        const uint8_t rowSpan = *pattIt++;
-        const uint8_t colSpan = *pattIt++;
-        const int nBytes = (rowSpan * colSpan + 7) / 8;
-        int nPix{0}, pixIdx{0};
-        for (int ib = 0; ib < nBytes; ib++) {
-          const uint8_t byte = *pattIt++;
-          for (int bit = 7; bit >= 0 && pixIdx < rowSpan * colSpan; bit--, pixIdx++) {
-            if (byte & (1 << bit)) {
-              cogDr += pixIdx / colSpan;
-              cogDc += pixIdx % colSpan;
-              nPix++;
+      const auto& rofRec = (*rofRecVecPerLayer[iLayer])[irof];
+      const auto& clusArr = *clusArrPerLayer[iLayer];
+      const auto& patternsPtr = (patternsPerLayer[iLayer] == nullptr) ? nullptr : patternsPerLayer[iLayer];
+      const auto& clusLabArr = clusLabArrPerLayer[iLayer];
+
+      // Create per-layer pattern iterator
+      auto pattIt = patternsPtr ? patternsPtr->cbegin() : std::vector<unsigned char>::const_iterator{};
+
+      for (int icl = 0; icl < rofRec.getNEntries(); icl++) {
+        const int clEntry = rofRec.getFirstEntry() + icl;
+        const auto& cluster = clusArr[clEntry];
+        nTot++;
+
+        // ── Parse pattern → center-of-gravity within bounding box ──────────
+        // The cluster stores the bounding-box top-left pixel (row, col).
+        // The pattern stream encodes [rowSpan, colSpan, bitmap...] for each cluster.
+        // We accumulate pixel row/col offsets to obtain a sub-pixel CoG correction.
+        float cogDr{0.f}, cogDc{0.f}; // mean offsets from bbox origin (pixels)
+        if (patternsPtr) {
+          const uint8_t rowSpan = *pattIt++;
+          const uint8_t colSpan = *pattIt++;
+          const int nBytes = (rowSpan * colSpan + 7) / 8;
+          int nPix{0}, pixIdx{0};
+          for (int ib = 0; ib < nBytes; ib++) {
+            const uint8_t byte = *pattIt++;
+            for (int bit = 7; bit >= 0 && pixIdx < rowSpan * colSpan; bit--, pixIdx++) {
+              if (byte & (1 << bit)) {
+                cogDr += pixIdx / colSpan;
+                cogDc += pixIdx % colSpan;
+                nPix++;
+              }
             }
           }
+          if (nPix > 1) {
+            cogDr /= nPix;
+            cogDc /= nPix;
+          }
         }
-        if (nPix > 1) {
-          cogDr /= nPix;
-          cogDc /= nPix;
+
+        // ── Cluster local → global (CoG position) ─────────────────────────────
+        // Get local coords of the bounding-box corner pixel, then apply the
+        // fractional CoG displacement using the pixel pitch.
+        // Formula from detectorToLocalUnchecked:
+        //   VD  : xRow = 0.5*(width[lay]-pitchRow) - row*pitchRow  → row↑ xRow↓
+        //         zCol = col*pitchCol + 0.5*(pitchCol-length)      → col↑ zCol↑
+        //   MLOT: same structure with MLOT pitches
+        float clLocX{0.f}, clLocZ{0.f};
+        o2::trk::SegmentationChip::detectorToLocalUnchecked(
+          cluster.row, cluster.col, clLocX, clLocZ,
+          cluster.subDetID, cluster.layer, cluster.disk);
+        const float pitchRow = (cluster.subDetID == 0)
+                                 ? o2::trk::SegmentationChip::PitchRowVD
+                                 : o2::trk::SegmentationChip::PitchRowMLOT;
+        const float pitchCol = (cluster.subDetID == 0)
+                                 ? o2::trk::SegmentationChip::PitchColVD
+                                 : o2::trk::SegmentationChip::PitchColMLOT;
+        clLocX -= cogDr * pitchRow; // increasing row → decreasing xRow
+        clLocZ += cogDc * pitchCol; // increasing col → increasing zCol
+        const float yResponse = (cluster.subDetID == 0) ? yPlaneVD : yPlaneMLOT;
+        // For VD the L2G matrix is built in the *curved* local frame (quasi-Cartesian,
+        // origin at the beam axis). Convert flat (clLocX, 0) → curved (xC, yC) first.
+        // For MLOT (flat sensors) the local frame is already Cartesian: pass directly.
+        // clLocX is already in the flat frame from detectorToLocalUnchecked + CoG and
+        // does NOT need any further transformation for the residual comparison.
+        o2::math_utils::Point3D<float> locC;
+        if (cluster.subDetID == 0) {
+          auto cv = o2::trk::SegmentationChip::flatToCurved(cluster.layer, clLocX, 0.f);
+          locC = {cv.X(), cv.Y(), clLocZ};
+        } else {
+          locC = {clLocX, yResponse, clLocZ};
+        }
+        auto gloC = gman->getMatrixL2G(cluster.chipID)(locC);
+
+        if (!hasMC || clusLabArr == nullptr) {
+          // No MC info: just fill geometry columns, leave residuals as 0
+          std::array<float, 21> data = {
+            -1.f, -1.f,
+            0.f, 0.f, 0.f, 0.f, 0.f,
+            (float)gloC.X(), (float)gloC.Y(), (float)gloC.Z(),
+            clLocX, clLocZ,
+            (float)rofRec.getROFrame(), (float)cluster.size, (float)cluster.chipID,
+            (float)cluster.layer, (float)cluster.disk, (float)cluster.subDetID,
+            (float)cluster.row, (float)cluster.col, -1.f};
+          nt.Fill(data.data());
+          continue;
         }
-      }
 
-      // ── Cluster local → global (CoG position) ─────────────────────────────
-      // Get local coords of the bounding-box corner pixel, then apply the
-      // fractional CoG displacement using the pixel pitch.
-      // Formula from detectorToLocalUnchecked:
-      //   VD  : xRow = 0.5*(width[lay]-pitchRow) - row*pitchRow  → row↑ xRow↓
-      //         zCol = col*pitchCol + 0.5*(pitchCol-length)      → col↑ zCol↑
-      //   MLOT: same structure with MLOT pitches
-      float clLocX{0.f}, clLocZ{0.f};
-      o2::trk::SegmentationChip::detectorToLocalUnchecked(
-        cluster.row, cluster.col, clLocX, clLocZ,
-        cluster.subDetID, cluster.layer, cluster.disk);
-      const float pitchRow = (cluster.subDetID == 0)
-                               ? o2::trk::SegmentationChip::PitchRowVD
-                               : o2::trk::SegmentationChip::PitchRowMLOT;
-      const float pitchCol = (cluster.subDetID == 0)
-                               ? o2::trk::SegmentationChip::PitchColVD
-                               : o2::trk::SegmentationChip::PitchColMLOT;
-      clLocX -= cogDr * pitchRow; // increasing row → decreasing xRow
-      clLocZ += cogDc * pitchCol; // increasing col → increasing zCol
-      const float yResponse = (cluster.subDetID == 0) ? yPlaneVD : yPlaneMLOT;
-      // For VD the L2G matrix is built in the *curved* local frame (quasi-Cartesian,
-      // origin at the beam axis). Convert flat (clLocX, 0) → curved (xC, yC) first.
-      // For MLOT (flat sensors) the local frame is already Cartesian: pass directly.
-      // clLocX is already in the flat frame from detectorToLocalUnchecked + CoG and
-      // does NOT need any further transformation for the residual comparison.
-      o2::math_utils::Point3D<float> locC;
-      if (cluster.subDetID == 0) {
-        auto cv = o2::trk::SegmentationChip::flatToCurved(cluster.layer, clLocX, 0.f);
-        locC = {cv.X(), cv.Y(), clLocZ};
-      } else {
-        locC = {clLocX, yResponse, clLocZ};
-      }
-      auto gloC = gman->getMatrixL2G(cluster.chipID)(locC);
+        // ── MC label ───────────────────────────────────────────────────────
+        const auto& labels = clusLabArr->getLabels(clEntry);
+        if (labels.empty() || !labels[0].isValid()) {
+          nInvalidLabel++;
+          continue;
+        }
+        const auto& lab = labels[0];
+        const int trID = lab.getTrackID();
+        const int evID = lab.getEventID();
+
+        // ── Find matching MC hit ────────────────────────────────────────────
+        const auto& mc2hit = mc2hitVec[evID];
+        uint64_t key = (uint64_t(trID) << 32) + cluster.chipID;
+        auto hitEntry = mc2hit.find(key);
+        if (hitEntry == mc2hit.end()) {
+          nNoMCHit++;
+          continue;
+        }
+        const auto& hit = (*hitVecPool[evID])[hitEntry->second];
+        const float pt = TMath::Hypot(hit.GetPx(), hit.GetPy());
+
+        // ── Hit global midpoint ────────────────────────────────────────────
+        const auto& gloHend = hit.GetPos();
+        const auto& gloHsta = hit.GetPosStart();
+        o2::math_utils::Point3D<float> gloHmid(
+          0.5f * (gloHend.X() + gloHsta.X()),
+          0.5f * (gloHend.Y() + gloHsta.Y()),
+          0.5f * (gloHend.Z() + gloHsta.Z()));
+
+        // ── Hit global → local ─────────────────────────────
+        o2::math_utils::Point3D<float> locHsta = gman->getMatrixL2G(cluster.chipID) ^ (gloHsta); // inverse L2G
+        o2::math_utils::Point3D<float> locHend = gman->getMatrixL2G(cluster.chipID) ^ (gloHend); // inverse L2G
+
+        // ── Propagate hit segment to the sensor response surface ───────────────
+        // Rather than the geometric midpoint, find where the track segment crosses
+        // the response plane (y = responseYShift in the flat local frame).
+        // For VD (curved): convert both endpoints to flat frame first.
+        // For ML/OT (flat): use local coordinates directly.
+        float hitLocX{0.f}, hitLocZ{0.f};
+        if (cluster.subDetID == 0) { // VD – curved sensor
+          auto flatSta = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHsta.X(), locHsta.Y());
+          auto flatEnd = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHend.X(), locHend.Y());
+          float x0 = flatSta.X(), y0 = flatSta.Y(), z0 = locHsta.Z();
+          float dltx = flatEnd.X() - x0, dlty = flatEnd.Y() - y0, dltz = locHend.Z() - z0;
+          float r = (std::abs(dlty) > 1e-9f) ? (yPlaneVD - y0) / dlty : 0.5f;
+          hitLocX = x0 + r * dltx;
+          hitLocZ = z0 + r * dltz;
+        } else { // ML/OT – flat sensor
+          float x0 = locHsta.X(), y0 = locHsta.Y(), z0 = locHsta.Z();
+          float dltx = locHend.X() - x0, dlty = locHend.Y() - y0, dltz = locHend.Z() - z0;
+          float r = (std::abs(dlty) > 1e-9f) ? (yPlaneMLOT - y0) / dlty : 0.5f;
+          hitLocX = x0 + r * dltx;
+          hitLocZ = z0 + r * dltz;
+        }
 
-      if (!hasMC || clusLabArr == nullptr) {
-        // No MC info: just fill geometry columns, leave residuals as 0
+        nValid++;
         std::array<float, 21> data = {
-          -1.f, -1.f,
-          0.f, 0.f, 0.f, 0.f, 0.f,
+          (float)evID, (float)trID,
+          hitLocX, hitLocZ,
+          (float)gloHmid.X(), (float)gloHmid.Y(), (float)gloHmid.Z(),
           (float)gloC.X(), (float)gloC.Y(), (float)gloC.Z(),
           clLocX, clLocZ,
           (float)rofRec.getROFrame(), (float)cluster.size, (float)cluster.chipID,
           (float)cluster.layer, (float)cluster.disk, (float)cluster.subDetID,
-          (float)cluster.row, (float)cluster.col, -1.f};
+          (float)cluster.row, (float)cluster.col, pt};
         nt.Fill(data.data());
-        continue;
-      }
-
-      // ── MC label ───────────────────────────────────────────────────────
-      const auto& labels = clusLabArr->getLabels(clEntry);
-      if (labels.empty() || !labels[0].isValid()) {
-        nInvalidLabel++;
-        continue;
       }
-      const auto& lab = labels[0];
-      const int trID = lab.getTrackID();
-      const int evID = lab.getEventID();
-
-      // ── Find matching MC hit ────────────────────────────────────────────
-      const auto& mc2hit = mc2hitVec[evID];
-      uint64_t key = (uint64_t(trID) << 32) + cluster.chipID;
-      auto hitEntry = mc2hit.find(key);
-      if (hitEntry == mc2hit.end()) {
-        nNoMCHit++;
-        continue;
-      }
-      const auto& hit = (*hitVecPool[evID])[hitEntry->second];
-      const float pt = TMath::Hypot(hit.GetPx(), hit.GetPy());
-
-      // ── Hit global midpoint ────────────────────────────────────────────
-      const auto& gloHend = hit.GetPos();
-      const auto& gloHsta = hit.GetPosStart();
-      o2::math_utils::Point3D<float> gloHmid(
-        0.5f * (gloHend.X() + gloHsta.X()),
-        0.5f * (gloHend.Y() + gloHsta.Y()),
-        0.5f * (gloHend.Z() + gloHsta.Z()));
-
-      // ── Hit global → local ─────────────────────────────
-      o2::math_utils::Point3D<float> locHsta = gman->getMatrixL2G(cluster.chipID) ^ (gloHsta); // inverse L2G
-      o2::math_utils::Point3D<float> locHend = gman->getMatrixL2G(cluster.chipID) ^ (gloHend); // inverse L2G
-
-      // ── Propagate hit segment to the sensor response surface ───────────────
-      // Rather than the geometric midpoint, find where the track segment crosses
-      // the response plane (y = responseYShift in the flat local frame).
-      // For VD (curved): convert both endpoints to flat frame first.
-      // For ML/OT (flat): use local coordinates directly.
-      float hitLocX{0.f}, hitLocZ{0.f};
-      if (cluster.subDetID == 0) { // VD – curved sensor
-        auto flatSta = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHsta.X(), locHsta.Y());
-        auto flatEnd = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHend.X(), locHend.Y());
-        float x0 = flatSta.X(), y0 = flatSta.Y(), z0 = locHsta.Z();
-        float dltx = flatEnd.X() - x0, dlty = flatEnd.Y() - y0, dltz = locHend.Z() - z0;
-        float r = (std::abs(dlty) > 1e-9f) ? (yPlaneVD - y0) / dlty : 0.5f;
-        hitLocX = x0 + r * dltx;
-        hitLocZ = z0 + r * dltz;
-      } else { // ML/OT – flat sensor
-        float x0 = locHsta.X(), y0 = locHsta.Y(), z0 = locHsta.Z();
-        float dltx = locHend.X() - x0, dlty = locHend.Y() - y0, dltz = locHend.Z() - z0;
-        float r = (std::abs(dlty) > 1e-9f) ? (yPlaneMLOT - y0) / dlty : 0.5f;
-        hitLocX = x0 + r * dltx;
-        hitLocZ = z0 + r * dltz;
-      }
-
-      nValid++;
-      std::array<float, 21> data = {
-        (float)evID, (float)trID,
-        hitLocX, hitLocZ,
-        (float)gloHmid.X(), (float)gloHmid.Y(), (float)gloHmid.Z(),
-        (float)gloC.X(), (float)gloC.Y(), (float)gloC.Z(),
-        clLocX, clLocZ,
-        (float)rofRec.getROFrame(), (float)cluster.size, (float)cluster.chipID,
-        (float)cluster.layer, (float)cluster.disk, (float)cluster.subDetID,
-        (float)cluster.row, (float)cluster.col, pt};
-      nt.Fill(data.data());
     }
   }
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigitsTRK.C
similarity index 52%
rename from Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
rename to Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigitsTRK.C
index ec1adf500f562..400457fc98585 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigits.C
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckDigitsTRK.C
@@ -75,7 +75,7 @@ void addTLines(float pitch)
   gPad->Update();
 }
 
-void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile = "o2sim_HitsTRK.root", std::string inputGeom = "o2sim_geometry.root", std::string paramfile = "o2sim_par.root")
+void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile = "o2sim_HitsTRK.root", std::string inputGeom = "o2sim_geometry.root")
 {
   gStyle->SetPalette(55);
 
@@ -97,6 +97,10 @@ void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile =
   auto* gman = o2::trk::GeometryTGeo::Instance();
   gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
 
+  const int nVDLayers = gman->extractNumberOfLayersVD();
+  const int nMLOTLayers = gman->getNumberOfLayersMLOT();
+  const int nTotalLayers = nVDLayers + nMLOTLayers;
+
   SegmentationChip seg;
   // seg.Print();
 
@@ -117,223 +121,181 @@ void CheckDigits(std::string digifile = "trkdigits.root", std::string hitfile =
 
   std::vector<std::unordered_map<uint64_t, int>> mc2hitVec(nevH);
 
-  // Digits
+  // Digits — per-layer branches
   TFile* digFile = TFile::Open(digifile.data());
   TTree* digTree = (TTree*)digFile->Get("o2sim");
 
-  std::vector<o2::itsmft::Digit>* digArr = nullptr;
-  digTree->SetBranchAddress("TRKDigit", &digArr);
-
-  o2::dataformats::IOMCTruthContainerView* plabels = nullptr;
-  digTree->SetBranchAddress("TRKDigitMCTruth", &plabels);
-
-  // Get Read Out Frame arrays
-  std::vector<o2::itsmft::ROFRecord>* ROFRecordArrray = nullptr;
-  digTree->SetBranchAddress("TRKDigitROF", &ROFRecordArrray);
-  std::vector<o2::itsmft::ROFRecord>& ROFRecordArrrayRef = *ROFRecordArrray;
+  int nDigitLayers = 0;
+  std::vector<std::vector<o2::itsmft::Digit>*> digArr(nTotalLayers, nullptr);
+  std::vector<std::vector<o2::itsmft::ROFRecord>*> rofRecordsArr(nTotalLayers, nullptr);
+  std::vector<o2::dataformats::IOMCTruthContainerView*> plabelsArr(nTotalLayers, nullptr);
 
-  std::vector<o2::itsmft::MC2ROFRecord>* MC2ROFRecordArrray = nullptr;
-  digTree->SetBranchAddress("TRKDigitMC2ROF", &MC2ROFRecordArrray);
-  std::vector<o2::itsmft::MC2ROFRecord>& MC2ROFRecordArrrayRef = *MC2ROFRecordArrray;
+  for (int iLayer = 0; iLayer < nTotalLayers; ++iLayer) {
+    if (!digTree->GetBranch(Form("TRKDigit_%i", iLayer))) {
+      break;
+    }
+    digTree->SetBranchAddress(Form("TRKDigit_%i", iLayer), &digArr[iLayer]);
+    digTree->SetBranchAddress(Form("TRKDigitROF_%i", iLayer), &rofRecordsArr[iLayer]);
+    digTree->SetBranchAddress(Form("TRKDigitMCTruth_%i", iLayer), &plabelsArr[iLayer]);
+    ++nDigitLayers;
+  }
 
   digTree->GetEntry(0);
 
-  int nROFRec = (int)ROFRecordArrrayRef.size();
-  std::vector<int> mcEvMin(nROFRec, hitTree->GetEntries());
-  std::vector<int> mcEvMax(nROFRec, -1);
-  o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel> labels;
-  plabels->copyandflatten(labels);
-  delete plabels;
-
-  // >> build min and max MC events used by each ROF
-  for (int imc = MC2ROFRecordArrrayRef.size(); imc--;) {
-    const auto& mc2rof = MC2ROFRecordArrrayRef[imc];
-    // printf("MCRecord: ");
-    // mc2rof.print();
-
-    if (mc2rof.rofRecordID < 0) {
-      continue; // this MC event did not contribute to any ROF
+  // Load all MC hit events upfront and build the hit lookup map.
+  for (int im = 0; im < nevH; ++im) {
+    hitTree->SetBranchAddress("TRKHit", &hitArray[im]);
+    hitTree->GetEntry(im);
+    auto& mc2hit = mc2hitVec[im];
+    for (int ih = hitArray[im]->size(); ih--;) {
+      const auto& hit = (*hitArray[im])[ih];
+      uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
+      mc2hit.emplace(key, ih);
     }
+  }
 
-    for (int irfd = mc2rof.maxROF - mc2rof.minROF + 1; irfd--;) {
+  // LOOP over layers, then ROFRecords within each layer
+  for (int iLayer = 0; iLayer < nDigitLayers; ++iLayer) {
+    auto& rofArr = *rofRecordsArr[iLayer];
+    const int nROFRec = (int)rofArr.size();
 
-      int irof = mc2rof.rofRecordID + irfd;
+    o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel> labels;
+    plabelsArr[iLayer]->copyandflatten(labels);
 
-      if (irof >= nROFRec) {
-        LOG(error) << "ROF=" << irof << " from MC2ROF record is >= N ROFs=" << nROFRec;
-      }
-      if (mcEvMin[irof] > imc) {
-        mcEvMin[irof] = imc;
-      }
-      if (mcEvMax[irof] < imc) {
-        mcEvMax[irof] = imc;
-      }
-    }
-  } // << build min and max MC events used by each ROF
+    // LOOP on : ROFRecord array
+    for (unsigned int iROF = 0; iROF < rofArr.size(); ++iROF) {
+
+      const unsigned int rofIndex = rofArr[iROF].getFirstEntry();
+      const unsigned int rofNEntries = rofArr[iROF].getNEntries();
 
-  unsigned int rofIndex = 0;
-  unsigned int rofNEntries = 0;
+      // LOOP on : digits array
+      for (unsigned int iDigit = rofIndex; iDigit < rofIndex + rofNEntries; iDigit++) {
+        if (iDigit % 1000 == 0)
+          std::cout << "Layer " << iLayer << ": reading digit " << iDigit << " / " << digArr[iLayer]->size() << std::endl;
 
-  // LOOP on : ROFRecord array
-  for (unsigned int iROF = 0; iROF < ROFRecordArrrayRef.size(); iROF++) {
+        Int_t ix = (*digArr[iLayer])[iDigit].getRow(), iz = (*digArr[iLayer])[iDigit].getColumn();
+        Int_t iDetID = (*digArr[iLayer])[iDigit].getChipIndex();
+        Int_t layer = gman->getLayer(iDetID);
+        Int_t disk = gman->getDisk(iDetID);
+        Int_t subDetID = gman->getSubDetID(iDetID);
+        Int_t petalCase = gman->getPetalCase(iDetID);
+        Int_t stave = gman->getStave(iDetID);
+        Int_t halfstave = gman->getHalfStave(iDetID);
 
-    rofIndex = ROFRecordArrrayRef[iROF].getFirstEntry();
-    rofNEntries = ROFRecordArrrayRef[iROF].getNEntries();
+        Float_t x = 0.f, y = 0.f, z = 0.f;
+        Float_t x_flat = 0.f, z_flat = 0.f;
 
-    // >> read and map MC events contributing to this ROF
-    for (int im = mcEvMin[iROF]; im <= mcEvMax[iROF]; im++) {
+        if (disk != -1) {
+          continue; // skip disks for the moment
+        }
 
-      if (!hitArray[im]) {
+        if (subDetID != 0) {
+          seg.detectorToLocal(ix, iz, x, z, subDetID, layer, disk);
+        } else if (subDetID == 0) {
+          seg.detectorToLocal(ix, iz, x_flat, z_flat, subDetID, layer, disk);
+          o2::math_utils::Vector2D<float> xyCurved = seg.flatToCurved(layer, x_flat, 0.);
+          x = xyCurved.X();
+          y = xyCurved.Y();
+          z = z_flat;
+        }
 
-        hitTree->SetBranchAddress("TRKHit", &hitArray[im]);
-        hitTree->GetEntry(im);
+        o2::math_utils::Point3D<float> locD(x, y, z);     // local Digit curved
+        o2::math_utils::Point3D<float> locDF(-1, -1, -1); // local Digit flat
 
-        auto& mc2hit = mc2hitVec[im];
+        Int_t chipID = (*digArr[iLayer])[iDigit].getChipIndex();
+        auto lab = (labels.getLabels(iDigit))[0];
 
-        for (int ih = hitArray[im]->size(); ih--;) {
+        int trID = lab.getTrackID();
 
-          const auto& hit = (*hitArray[im])[ih];
-          uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
-          mc2hit.emplace(key, ih);
+        if (!lab.isValid()) { // not a noise
+          continue;
         }
-      }
-    }
 
-    // LOOP on : digits array
-    for (unsigned int iDigit = rofIndex; iDigit < rofIndex + rofNEntries; iDigit++) {
-      // if (iDigit % 10000 != 0) /// looking only at a small sample
-      //   continue;
-
-      if (iDigit % 1000 == 0)
-        std::cout << "Reading digit " << iDigit << " / " << digArr->size() << std::endl;
-
-      Int_t ix = (*digArr)[iDigit].getRow(), iz = (*digArr)[iDigit].getColumn();
-      Int_t iDetID = (*digArr)[iDigit].getChipIndex();
-      Int_t layer = gman->getLayer(iDetID);
-      Int_t disk = gman->getDisk(iDetID);
-      Int_t subDetID = gman->getSubDetID(iDetID);
-      Int_t petalCase = gman->getPetalCase(iDetID);
-      Int_t stave = gman->getStave(iDetID);
-      Int_t halfstave = gman->getHalfStave(iDetID);
-
-      Float_t x = 0.f, y = 0.f, z = 0.f;
-      Float_t x_flat = 0.f, z_flat = 0.f;
-
-      if (disk != -1) {
-        continue; // skip disks for the moment
-      }
-
-      if (subDetID != 0) {
-        seg.detectorToLocal(ix, iz, x, z, subDetID, layer, disk);
-      } else if (subDetID == 0) {
-        seg.detectorToLocal(ix, iz, x_flat, z_flat, subDetID, layer, disk);
-        o2::math_utils::Vector2D<float> xyCurved = seg.flatToCurved(layer, x_flat, 0.);
-        x = xyCurved.X();
-        y = xyCurved.Y();
-        z = z_flat;
-      }
-
-      o2::math_utils::Point3D<float> locD(x, y, z);     // local Digit curved
-      o2::math_utils::Point3D<float> locDF(-1, -1, -1); // local Digit flat
-
-      Int_t chipID = (*digArr)[iDigit].getChipIndex();
-      auto lab = (labels.getLabels(iDigit))[0];
-
-      int trID = lab.getTrackID();
-
-      if (!lab.isValid()) { // not a noise
-        continue;
-      }
-
-      const auto gloD = gman->getMatrixL2G(chipID)(locD); // convert to global
-
-      std::unordered_map<uint64_t, int>* mc2hit = &mc2hitVec[lab.getEventID()];
-
-      // get MC info
-      uint64_t key = (uint64_t(trID) << 32) + chipID;
-      auto hitEntry = mc2hit->find(key);
-
-      if (hitEntry == mc2hit->end()) {
-
-        LOG(error) << "Failed to find MC hit entry for Tr" << trID << " chipID" << chipID;
-        continue;
-      }
-
-      ////// HITS
-      Hit& hit = (*hitArray[lab.getEventID()])[hitEntry->second];
-
-      auto xyzLocE = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
-      auto xyzLocS = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
-
-      // Hit local reference: Both VD and MLOT use response-plane interpolation (in flat local frame).
-      // For VD, transform curved → flat first, then interpolate.
-      o2::math_utils::Vector3D<float> locH;  /// Hit reference (at response plane)
-      o2::math_utils::Vector3D<float> locHS; /// Hit, start pos
-      locHS.SetCoordinates(xyzLocS.X(), xyzLocS.Y(), xyzLocS.Z());
-      o2::math_utils::Vector3D<float> locHE; /// Hit, end pos
-      locHE.SetCoordinates(xyzLocE.X(), xyzLocE.Y(), xyzLocE.Z());
-      o2::math_utils::Vector3D<float> locHF;
-
-      if (subDetID == 0) {
-        // VD: Interpolate to VD reference plane in flat frame; apply same r to X and Z
-        auto flatSta = seg.curvedToFlat(layer, locHS.X(), locHS.Y());
-        auto flatEnd = seg.curvedToFlat(layer, locHE.X(), locHE.Y());
-        float x0 = flatSta.X(), y0 = flatSta.Y(), z0 = locHS.Z();
-        float dltx = flatEnd.X() - x0, dlty = flatEnd.Y() - y0, dltz = locHE.Z() - z0;
-        float r = (std::abs(dlty) > 1e-9f) ? (yPlaneVD - y0) / dlty : 0.5f;
-        locH.SetCoordinates(x0 + r * dltx, yPlaneVD, z0 + r * dltz);
-      } else {
-        // MLOT: Interpolate to response plane
-        float x0 = locHS.X(), y0 = locHS.Y(), z0 = locHS.Z();
-        float dltx = locHE.X() - x0, dlty = locHE.Y() - y0, dltz = locHE.Z() - z0;
-        float r = (std::abs(dlty) > 1e-9f) ? (yPlaneMLOT - y0) / dlty : 0.5f;
-        locH.SetCoordinates(x0 + r * dltx, yPlaneMLOT, z0 + r * dltz);
-      }
-
-      int row = 0, col = 0;
-      float xlc = 0., zlc = 0.;
-
-      if (subDetID == 0) {
-        Float_t x_flat = 0.f, y_flat = 0.f;
-        // locH is already in flat frame from interpolation above; convert digit to flat for comparison
-        o2::math_utils::Vector2D<float> xyFlatD = seg.curvedToFlat(layer, locD.X(), locD.Y());
-        locDF.SetCoordinates(xyFlatD.X(), xyFlatD.Y(), locD.Z());
-        locHF.SetCoordinates(locH.X(), locH.Y(), locH.Z()); // locH already in flat frame
-        seg.localToDetector(locHF.X(), locHF.Z(), row, col, subDetID, layer, disk);
-      }
-
-      else {
-        seg.localToDetector(locH.X(), locH.Z(), row, col, subDetID, layer, disk);
-      }
-
-      seg.detectorToLocal(row, col, xlc, zlc, subDetID, layer, disk);
-
-      if (subDetID == 0) {
-        nt->Fill(chipID,                                        /// detector ID
-                 gloD.X(), gloD.Y(), gloD.Z(),                  /// global position retrieved from the digit: digit (row, col) ->local position -> global potision
-                 ix, iz,                                        /// row and column of the digit
-                 row, col,                                      /// row and col retrieved from the hit: hit global position -> hit local position -> detector position (row, col)
-                 locH.X(), locH.Z(),                            /// x and z of the hit in the local reference frame: hit global position -> hit local position
-                 xlc, zlc,                                      /// x and z of the hit in the local frame: hit global position -> hit local position -> detector position (row, col) -> local position
-                 locHF.X() - locDF.X(), locHF.Z() - locDF.Z()); /// difference in x and z between the hit and the digit in the local frame
-
-        nt2->Fill(chipID, gloD.Z(), locHS.X() - locHE.X(), locHS.Z() - locHE.Z()); /// differences between local hit start and hit end positions
-      } else {
-
-        nt->Fill(chipID,                                                           /// detector ID
-                 gloD.X(), gloD.Y(), gloD.Z(),                                     /// global position retrieved from the digit: digit (row, col) ->local position -> global potision
-                 ix, iz,                                                           /// row and column of the digit
-                 row, col,                                                         /// row and col retrieved from the hit: hit global position -> hit local position -> detector position (row, col)
-                 locH.X(), locH.Z(),                                               /// x and z of the hit in the local reference frame: hit global position -> hit local position
-                 xlc, zlc,                                                         /// x and z of the hit in the local frame: hit global position -> hit local position -> detector position (row, col) -> local position
-                 locH.X() - locD.X(), locH.Z() - locD.Z());                        /// difference in x and z between the hit and the digit in the local frame
-                                                                                   //  locHS.X() - locHE.X(), locHS.Z() - locHE.Z()); /// difference in x and z between the hit and the digit in the local frame
-        nt2->Fill(chipID, gloD.Z(), locHS.X() - locHE.X(), locHS.Z() - locHE.Z()); /// differences between local hit start and hit end positions
-      }
-
-    } // end loop on digits array
-
-  } // end loop on ROFRecords array
+        const auto gloD = gman->getMatrixL2G(chipID)(locD); // convert to global
+
+        std::unordered_map<uint64_t, int>* mc2hit = &mc2hitVec[lab.getEventID()];
+
+        // get MC info
+        uint64_t key = (uint64_t(trID) << 32) + chipID;
+        auto hitEntry = mc2hit->find(key);
+
+        if (hitEntry == mc2hit->end()) {
+          LOG(error) << "Failed to find MC hit entry for Tr" << trID << " chipID" << chipID;
+          continue;
+        }
+
+        ////// HITS
+        Hit& hit = (*hitArray[lab.getEventID()])[hitEntry->second];
+
+        auto xyzLocE = gman->getMatrixL2G(chipID) ^ (hit.GetPos()); // inverse conversion from global to local
+        auto xyzLocS = gman->getMatrixL2G(chipID) ^ (hit.GetPosStart());
+
+        // Hit local reference: Both VD and MLOT use response-plane interpolation (in flat local frame).
+        // For VD, transform curved → flat first, then interpolate.
+        o2::math_utils::Vector3D<float> locH;  /// Hit reference (at response plane)
+        o2::math_utils::Vector3D<float> locHS; /// Hit, start pos
+        locHS.SetCoordinates(xyzLocS.X(), xyzLocS.Y(), xyzLocS.Z());
+        o2::math_utils::Vector3D<float> locHE; /// Hit, end pos
+        locHE.SetCoordinates(xyzLocE.X(), xyzLocE.Y(), xyzLocE.Z());
+        o2::math_utils::Vector3D<float> locHF;
+
+        if (subDetID == 0) {
+          // VD: Interpolate to VD reference plane in flat frame; apply same r to X and Z
+          auto flatSta = seg.curvedToFlat(layer, locHS.X(), locHS.Y());
+          auto flatEnd = seg.curvedToFlat(layer, locHE.X(), locHE.Y());
+          float x0 = flatSta.X(), y0 = flatSta.Y(), z0 = locHS.Z();
+          float dltx = flatEnd.X() - x0, dlty = flatEnd.Y() - y0, dltz = locHE.Z() - z0;
+          float r = (std::abs(dlty) > 1e-9f) ? (yPlaneVD - y0) / dlty : 0.5f;
+          locH.SetCoordinates(x0 + r * dltx, yPlaneVD, z0 + r * dltz);
+        } else {
+          // MLOT: Interpolate to response plane
+          float x0 = locHS.X(), y0 = locHS.Y(), z0 = locHS.Z();
+          float dltx = locHE.X() - x0, dlty = locHE.Y() - y0, dltz = locHE.Z() - z0;
+          float r = (std::abs(dlty) > 1e-9f) ? (yPlaneMLOT - y0) / dlty : 0.5f;
+          locH.SetCoordinates(x0 + r * dltx, yPlaneMLOT, z0 + r * dltz);
+        }
+
+        int row = 0, col = 0;
+        float xlc = 0., zlc = 0.;
+
+        if (subDetID == 0) {
+          Float_t x_flat = 0.f, y_flat = 0.f;
+          // locH is already in flat frame from interpolation above; convert digit to flat for comparison
+          o2::math_utils::Vector2D<float> xyFlatD = seg.curvedToFlat(layer, locD.X(), locD.Y());
+          locDF.SetCoordinates(xyFlatD.X(), xyFlatD.Y(), locD.Z());
+          locHF.SetCoordinates(locH.X(), locH.Y(), locH.Z()); // locH already in flat frame
+          seg.localToDetector(locHF.X(), locHF.Z(), row, col, subDetID, layer, disk);
+        } else {
+          seg.localToDetector(locH.X(), locH.Z(), row, col, subDetID, layer, disk);
+        }
+
+        seg.detectorToLocal(row, col, xlc, zlc, subDetID, layer, disk);
+
+        if (subDetID == 0) {
+          nt->Fill(chipID,                                                           /// detector ID
+                   gloD.X(), gloD.Y(), gloD.Z(),                                     /// global position retrieved from the digit: digit (row, col) ->local position -> global potision
+                   ix, iz,                                                           /// row and column of the digit
+                   row, col,                                                         /// row and col retrieved from the hit: hit global position -> hit local position -> detector position (row, col)
+                   locH.X(), locH.Z(),                                               /// x and z of the hit in the local reference frame: hit global position -> hit local position
+                   xlc, zlc,                                                         /// x and z of the hit in the local frame: hit global position -> hit local position -> detector position (row, col) -> local position
+                   locHF.X() - locDF.X(), locHF.Z() - locDF.Z());                    /// difference in x and z between the hit and the digit in the local frame
+          nt2->Fill(chipID, gloD.Z(), locHS.X() - locHE.X(), locHS.Z() - locHE.Z()); /// differences between local hit start and hit end positions
+        } else {
+          nt->Fill(chipID,                                                           /// detector ID
+                   gloD.X(), gloD.Y(), gloD.Z(),                                     /// global position retrieved from the digit: digit (row, col) ->local position -> global potision
+                   ix, iz,                                                           /// row and column of the digit
+                   row, col,                                                         /// row and col retrieved from the hit: hit global position -> hit local position -> detector position (row, col)
+                   locH.X(), locH.Z(),                                               /// x and z of the hit in the local reference frame: hit global position -> hit local position
+                   xlc, zlc,                                                         /// x and z of the hit in the local frame: hit global position -> hit local position -> detector position (row, col) -> local position
+                   locH.X() - locD.X(), locH.Z() - locD.Z());                        /// difference in x and z between the hit and the digit in the local frame
+          nt2->Fill(chipID, gloD.Z(), locHS.X() - locHE.X(), locHS.Z() - locHE.Z()); /// differences between local hit start and hit end positions
+        }
+
+      } // end loop on digits array
+
+    } // end loop on ROFRecords
+
+  } // end loop on layers
 
   // digit maps in the xy and yz planes
   auto canvXY = new TCanvas("canvXY", "", 1600, 2400);
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
index 70518b2ace593..bcd95155f533f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
@@ -48,7 +48,6 @@ class Clusterer
 
   using Digit = o2::itsmft::Digit;
   using DigROFRecord = o2::itsmft::ROFRecord;
-  using DigMC2ROFRecord = o2::itsmft::MC2ROFRecord;
   using ClusterTruth = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
   using ConstDigitTruth = o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>;
   using Label = o2::MCCompLabel;
@@ -167,9 +166,7 @@ class Clusterer
                        std::vector<unsigned char>& patterns,
                        std::vector<o2::trk::ROFRecord>& clusterROFs,
                        const ConstDigitTruth* digitLabels = nullptr,
-                       ClusterTruth* clusterLabels = nullptr,
-                       gsl::span<const DigMC2ROFRecord> digMC2ROFs = {},
-                       std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs = nullptr);
+                       ClusterTruth* clusterLabels = nullptr);
 
  protected:
   int mNHugeClus = 0;
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
index 37a148aa78afb..5d68193e5e375 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
@@ -35,9 +35,7 @@ class ClustererACTS : public Clusterer
                std::vector<unsigned char>& patterns,
                std::vector<o2::trk::ROFRecord>& clusterROFs,
                const ConstDigitTruth* digitLabels = nullptr,
-               ClusterTruth* clusterLabels = nullptr,
-               gsl::span<const DigMC2ROFRecord> digMC2ROFs = {},
-               std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs = nullptr) override;
+               ClusterTruth* clusterLabels = nullptr) override;
 
  private:
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
index bdaa76319c1f2..e0d689e4db5ed 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
@@ -28,9 +28,7 @@ void Clusterer::process(gsl::span<const Digit> digits,
                         std::vector<unsigned char>& patterns,
                         std::vector<o2::trk::ROFRecord>& clusterROFs,
                         const ConstDigitTruth* digitLabels,
-                        ClusterTruth* clusterLabels,
-                        gsl::span<const DigMC2ROFRecord> digMC2ROFs,
-                        std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs)
+                        ClusterTruth* clusterLabels)
 {
   if (!mThread) {
     mThread = std::make_unique<ClustererThread>(this);
@@ -81,13 +79,6 @@ void Clusterer::process(gsl::span<const Digit> digits,
     clusterROFs.emplace_back(inROF.getBCData(), inROF.getROFrame(),
                              outFirst, static_cast<int>(clusters.size()) - outFirst);
   }
-
-  if (clusterMC2ROFs && !digMC2ROFs.empty()) {
-    clusterMC2ROFs->reserve(clusterMC2ROFs->size() + digMC2ROFs.size());
-    for (const auto& in : digMC2ROFs) {
-      clusterMC2ROFs->emplace_back(in.eventRecordID, in.rofRecordID, in.minROF, in.maxROF);
-    }
-  }
 }
 
 //__________________________________________________
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
index 2dbf56ae610e3..b764fcdd1cd79 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
@@ -162,9 +162,7 @@ void ClustererACTS::process(gsl::span<const Digit> digits,
                             std::vector<unsigned char>& patterns,
                             std::vector<o2::trk::ROFRecord>& clusterROFs,
                             const ConstDigitTruth* digitLabels,
-                            ClusterTruth* clusterLabels,
-                            gsl::span<const DigMC2ROFRecord> digMC2ROFs,
-                            std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs)
+                            ClusterTruth* clusterLabels)
 {
   if (!mThread) {
     mThread = std::make_unique<ClustererThread>(this);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
index 3bb58f21dd33b..d7d1ea28bfcf7 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/DigiParams.h
@@ -15,9 +15,12 @@
 #ifndef ALICEO2_TRK_DIGIPARAMS_H
 #define ALICEO2_TRK_DIGIPARAMS_H
 
+#include <array>
+
 #include <Rtypes.h>
 #include "ITSMFTSimulation/AlpideSignalTrapezoid.h"
 #include "ITSMFTSimulation/AlpideSimResponse.h"
+#include "TRKBase/AlmiraParam.h"
 #include "TRKBase/TRKBaseParam.h"
 #include "TRKBase/GeometryTGeo.h"
 
@@ -50,27 +53,24 @@ class DigiParams
   void setNoisePerPixel(float v) { mNoisePerPixel = v; }
   float getNoisePerPixel() const { return mNoisePerPixel; }
 
-  void setContinuous(bool v) { mIsContinuous = v; }
-  bool isContinuous() const { return mIsContinuous; }
-
-  int getROFrameLengthInBC() const { return mROFrameLengthInBC; }
-  void setROFrameLengthInBC(int n) { mROFrameLengthInBC = n; }
+  int getROFrameLengthInBC(int layer) const { return mROFrameLayerLengthInBC[layer]; }
+  void setROFrameLengthInBC(int n, int layer) { mROFrameLayerLengthInBC[layer] = n; }
 
-  void setROFrameLength(float ns);
-  float getROFrameLength() const { return mROFrameLength; }
-  float getROFrameLengthInv() const { return mROFrameLengthInv; }
+  void setROFrameLength(float ns, int layer);
+  float getROFrameLength(int layer) const { return mROFrameLayerLength[layer]; }
+  float getROFrameLengthInv(int layer) const { return mROFrameLayerLengthInv[layer]; }
 
-  void setStrobeDelay(float ns) { mStrobeDelay = ns; }
-  float getStrobeDelay() const { return mStrobeDelay; }
+  void setStrobeDelay(float ns, int layer) { mStrobeLayerDelay[layer] = ns; }
+  float getStrobeDelay(int layer) const { return mStrobeLayerDelay[layer]; }
 
-  void setStrobeLength(float ns) { mStrobeLength = ns; }
-  float getStrobeLength() const { return mStrobeLength; }
+  void setStrobeLength(float ns, int layer) { mStrobeLayerLength[layer] = ns; }
+  float getStrobeLength(int layer) const { return mStrobeLayerLength[layer]; }
 
   void setTimeOffset(double sec) { mTimeOffset = sec; }
   double getTimeOffset() const { return mTimeOffset; }
 
-  void setROFrameBiasInBC(int n) { mROFrameBiasInBC = n; }
-  int getROFrameBiasInBC() const { return mROFrameBiasInBC; }
+  void setROFrameBiasInBC(int n, int layer) { mROFrameLayerBiasInBC[layer] = n; }
+  int getROFrameBiasInBC(int layer) const { return mROFrameLayerBiasInBC[layer]; }
 
   void setChargeThreshold(int v, float frac2Account = 0.1);
   void setNSimSteps(int v);
@@ -102,14 +102,8 @@ class DigiParams
 
  private:
   static constexpr double infTime = 1e99;
-  bool mIsContinuous = false;            ///< flag for continuous simulation
   float mNoisePerPixel = 1.e-7;          ///< Noise per chip
-  int mROFrameLengthInBC = 0;            ///< ROF length in BC for continuos mode
-  float mROFrameLength = 0;              ///< length of RO frame in ns
-  float mStrobeDelay = 0.;               ///< strobe start (in ns) wrt ROF start
-  float mStrobeLength = 0;               ///< length of the strobe in ns (sig. over threshold checked in this window only)
   double mTimeOffset = -2 * infTime;     ///< time offset (in seconds!) to calculate ROFrame from hit time
-  int mROFrameBiasInBC = 0;              ///< misalignment of the ROF start in BC
   int mChargeThreshold = 75;             ///< charge threshold in Nelectrons
   int mMinChargeToAccount = 7;           ///< minimum charge contribution to account
   int mNSimSteps = 475;                  ///< number of steps in response simulation
@@ -121,12 +115,18 @@ class DigiParams
   float mIBVbb = 0.0; ///< back bias absolute value for ITS Inner Barrel (in Volt)
   float mOBVbb = 0.0; ///< back bias absolute value for ITS Outter Barrel (in Volt)
 
+  std::array<int, o2::trk::AlmiraParam::getNLayers()> mROFrameLayerLengthInBC; ///< staggering ROF length in BC for continuous mode per layer
+  std::array<int, o2::trk::AlmiraParam::getNLayers()> mROFrameLayerBiasInBC;   ///< staggering ROF bias in BC for continuous mode per layer
+  std::array<float, o2::trk::AlmiraParam::getNLayers()> mROFrameLayerLength;   ///< staggering ROF length in ns for continuous mode per layer
+  std::array<float, o2::trk::AlmiraParam::getNLayers()> mStrobeLayerLength;    ///< staggering strobe length in ns per layer
+  std::array<float, o2::trk::AlmiraParam::getNLayers()> mStrobeLayerDelay;     ///< staggering strobe delay in ns per layer
+
   o2::itsmft::AlpideSignalTrapezoid mSignalShape; ///< signal timeshape parameterization
 
   std::unique_ptr<o2::trk::ChipSimResponse> mResponse; //!< pointer on external response
 
   // auxiliary precalculated parameters
-  float mROFrameLengthInv = 0; ///< inverse length of RO frame in ns
+  std::array<float, o2::trk::AlmiraParam::getNLayers()> mROFrameLayerLengthInv; ///< inverse length of RO frame in ns per layer
 
   //   ClassDef(DigiParams, 2);
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
index 362de63fb8cb6..5910fc98134aa 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/Digitizer.h
@@ -55,18 +55,20 @@ class Digitizer
   const o2::trk::ChipSimResponse* getChipResponse(int chipID);
 
   /// Steer conversion of hits to digits
-  void process(const std::vector<o2::trk::Hit>* hits, int evID, int srcID);
-  void setEventTime(const o2::InteractionTimeRecord& irt);
-  double getEndTimeOfROFMax() const
+  void process(const std::vector<o2::trk::Hit>* hits, int evID, int srcID, int layer);
+  void setEventTime(const o2::InteractionTimeRecord& irt, int layer);
+
+  void fillOutputContainer(uint32_t maxFrame, int layer);
+
+  void resetROFrameBounds()
   {
-    ///< return the time corresponding to end of the last reserved ROFrame : mROFrameMax
-    return mParams.getROFrameLength() * (mROFrameMax + 1) + mParams.getTimeOffset();
+    mROFrameMin = 0;
+    mROFrameMax = 0;
+    mNewROFrame = 0;
+    mIsBeforeFirstRO = false;
+    mExtraBuff.clear();
   }
 
-  void setContinuous(bool v) { mParams.setContinuous(v); }
-  bool isContinuous() const { return mParams.isContinuous(); }
-  void fillOutputContainer(uint32_t maxFrame = 0xffffffff);
-
   const o2::trk::DigiParams& getDigitParams() const { return mParams; }
 
   // provide the common trk::GeometryTGeo to access matrices and segmentation
@@ -83,9 +85,9 @@ class Digitizer
   void setDeadChannelsMap(const o2::itsmft::NoiseMap* mp) { mDeadChanMap = mp; }
 
  private:
-  void processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, int srcID);
+  void processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, int srcID, int rofLayer);
   void registerDigits(o2::trk::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
-                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl);
+                      uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl, int layer);
 
   ExtraDig* getExtraDigBuffer(uint32_t roFrame)
   {
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 66ace4746d399..3fa51afe3ba2b 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -13,6 +13,7 @@
 
 #include "DetectorsBase/Stack.h"
 
+#include "TRKBase/Specs.h"
 #include "TRKBase/TRKBaseParam.h"
 #include "TRKSimulation/Hit.h"
 #include "TRKSimulation/VDGeometryBuilder.h"
@@ -99,7 +100,7 @@ void Detector::configMLOT()
     case kCylindrical: {
       const std::vector<float> length{128.35f, 128.35f, 128.35f, 128.35f, 128.35f, 256.7f, 256.7f, 256.7f};
       LOGP(warning, "Loading cylindrical configuration for ALICE3 TRK");
-      for (int i{0}; i < 8; ++i) {
+      for (int i{0}; i < constants::ML::nLayers + constants::OT::nLayers; ++i) {
         std::string name = GeometryTGeo::getTRKLayerPattern() + std::to_string(i);
         mLayers.push_back(std::make_unique<TRKCylindricalLayer>(i, name, rInn[i], length[i], thick, MatBudgetParamMode::Thickness));
       }
@@ -115,9 +116,9 @@ void Detector::configMLOT()
       const std::vector<float> stagOffsets{0.f, 0.f, 0.f, 1.17f, 0.89f};
 
       LOGP(warning, "Loading segmented configuration for ALICE3 TRK");
-      for (int i{0}; i < 8; ++i) {
+      for (int i{0}; i < constants::ML::nLayers + constants::OT::nLayers; ++i) {
         std::string name = GeometryTGeo::getTRKLayerPattern() + std::to_string(i);
-        if (i < 5) {
+        if (i < constants::ML::nLayers) {
           mLayers.push_back(std::make_unique<TRKMLLayer>(i, name, rInn[i], stagOffsets[i], tiltAngles[i], nStaves[i], nMods[i], thick, MatBudgetParamMode::Thickness));
         } else {
           mLayers.push_back(std::make_unique<TRKOTLayer>(i, name, rInn[i], tiltAngles[i], nStaves[i], nMods[i], thick, MatBudgetParamMode::Thickness));
@@ -202,8 +203,8 @@ void Detector::configFromFile(std::string fileName)
         // Default mode is Thickness
         MatBudgetParamMode mode = MatBudgetParamMode::Thickness;
 
-        if (layerCount < 5) {
-          // ML layers (0 to 4) require stagOffset (index 5)
+        if (layerCount < constants::ML::nLayers) {
+          // ML layers require stagOffset (index 5)
           if (tmpBuff.size() < 6) {
             LOGP(fatal, "Invalid configuration for ML layer {}: stagOffset is missing.", layerCount);
           }
@@ -215,7 +216,7 @@ void Detector::configFromFile(std::string fileName)
 
           mLayers.push_back(std::make_unique<TRKMLLayer>(layerCount, name, rInn, stagOffset, tiltAngle, nStaves, nMods, thick, mode));
         } else {
-          // OT layers (5+) do NOT have stagOffset. The optional mode is at index 5.
+          // OT layers do NOT have stagOffset. The optional mode is at index 5.
           if (tmpBuff.size() >= 6) {
             mode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[5]));
           }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
index d5d47b3658b04..3558a6a87ce71 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/DigiParams.cxx
@@ -25,12 +25,12 @@ DigiParams::DigiParams()
   setNSimSteps(mNSimSteps);
 }
 
-void DigiParams::setROFrameLength(float lNS)
+void DigiParams::setROFrameLength(float lNS, int layer)
 {
   // set ROFrame length in nanosecongs
-  mROFrameLength = lNS;
-  assert(mROFrameLength > 1.);
-  mROFrameLengthInv = 1. / mROFrameLength;
+  mROFrameLayerLength[layer] = lNS;
+  assert(mROFrameLayerLength[layer] > 1.);
+  mROFrameLayerLengthInv[layer] = 1. / mROFrameLayerLength[layer];
 }
 
 void DigiParams::setNSimSteps(int v)
@@ -59,10 +59,6 @@ void DigiParams::print() const
 {
   // print settings
   printf("TRK digitization params:\n");
-  printf("Continuous readout             : %s\n", mIsContinuous ? "ON" : "OFF");
-  printf("Readout Frame Length(ns)       : %f\n", mROFrameLength);
-  printf("Strobe delay (ns)              : %f\n", mStrobeDelay);
-  printf("Strobe length (ns)             : %f\n", mStrobeLength);
   printf("Threshold (N electrons)        : %d\n", mChargeThreshold);
   printf("Min N electrons to account     : %d\n", mMinChargeToAccount);
   printf("Number of charge sharing steps : %d\n", mNSimSteps);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
index 31b9a25b7e5f8..890c272fefbc2 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Digitizer.cxx
@@ -23,6 +23,7 @@
 #include <vector>
 #include <iostream>
 #include <numeric>
+#include <ranges>
 #include <fairlogger/Logger.h> // for LOG
 
 using o2::itsmft::Digit;
@@ -113,14 +114,13 @@ const o2::trk::ChipSimResponse* Digitizer::getChipResponse(int chipID)
 };
 
 //_______________________________________________________________________
-void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
+void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID, int layer)
 {
   // digitize single event, the time must have been set beforehand
 
   LOG(info) << " Digitizing " << mGeometry->getName() << " (ID: " << mGeometry->getDetID()
             << ") hits of event " << evID << " from source " << srcID
             << " at time " << mEventTime.getTimeNS() << " ROFrame = " << mNewROFrame
-            << " cont.mode: " << isContinuous()
             << " Min/Max ROFrames " << mROFrameMin << "/" << mROFrameMax;
 
   std::cout << "Printing segmentation info: " << std::endl;
@@ -128,7 +128,7 @@ void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
 
   // // is there something to flush ?
   if (mNewROFrame > mROFrameMin) {
-    fillOutputContainer(mNewROFrame - 1); // flush out all frames preceding the new one
+    fillOutputContainer(mNewROFrame - 1, layer); // flush out all frames preceding the new one
   }
 
   int nHits = hits->size();
@@ -140,66 +140,55 @@ void Digitizer::process(const std::vector<Hit>* hits, int evID, int srcID)
               return (*hits)[lhs].GetDetectorID() < (*hits)[rhs].GetDetectorID();
             });
   LOG(info) << "Processing " << nHits << " hits";
-  for (int i : hitIdx) {
-    processHit((*hits)[i], mROFrameMax, evID, srcID);
-  }
-
-  // in the triggered mode store digits after every MC event
-  // TODO: in the real triggered mode this will not be needed, this is actually for the
-  // single event processing only
-  if (!mParams.isContinuous()) {
-    fillOutputContainer(mROFrameMax);
+  for (int i : hitIdx | std::views::filter([&](int idx) {
+                 if (layer < 0) {
+                   return true;
+                 }
+                 return mGeometry->getLayerTRK((*hits)[idx].GetDetectorID()) == layer;
+               })) {
+    processHit((*hits)[i], mROFrameMax, evID, srcID, layer);
   }
 }
 
 //_______________________________________________________________________
-void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt)
+void Digitizer::setEventTime(const o2::InteractionTimeRecord& irt, int layer)
 {
   LOG(info) << "Setting event time to " << irt.getTimeNS() << " ns after orbit 0 bc 0";
   // assign event time in ns
   mEventTime = irt;
-  if (!mParams.isContinuous()) {
-    mROFrameMin = 0; // in triggered mode reset the frame counters
-    mROFrameMax = 0;
-  }
   // RO frame corresponding to provided time
   mCollisionTimeWrtROF = mEventTime.timeInBCNS; // in triggered mode the ROF starts at BC (is there a delay?)
-  if (mParams.isContinuous()) {
-    auto nbc = mEventTime.differenceInBC(mIRFirstSampledTF);
-
-    if (mCollisionTimeWrtROF < 0 && nbc > 0) {
-      nbc--;
-    }
-
-    if (nbc < 0) {
-      mNewROFrame = 0;
-      mIsBeforeFirstRO = true;
-    } else {
-      mNewROFrame = nbc / mParams.getROFrameLengthInBC();
-      mIsBeforeFirstRO = false;
-    }
+  auto nbc = mEventTime.differenceInBC(mIRFirstSampledTF);
 
-    LOG(debug) << " NewROFrame " << mNewROFrame << " = " << nbc << "/" << mParams.getROFrameLengthInBC() << " (nbc/mParams.getROFrameLengthInBC()";
+  if (mCollisionTimeWrtROF < 0 && nbc > 0) {
+    nbc--;
+  }
 
-    // in continuous mode depends on starts of periodic readout frame
-    mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC()) * o2::constants::lhc::LHCBunchSpacingNS;
-  } else {
+  if (nbc < 0) {
     mNewROFrame = 0;
+    mIsBeforeFirstRO = true;
+  } else {
+    mNewROFrame = nbc / mParams.getROFrameLengthInBC(layer);
     mIsBeforeFirstRO = false;
   }
 
+  LOG(debug) << " NewROFrame " << mNewROFrame << " = " << nbc << "/" << mParams.getROFrameLengthInBC(layer) << " (nbc/mParams.getROFrameLengthInBC()";
+
+  // in continuous mode depends on starts of periodic readout frame
+  mCollisionTimeWrtROF += (nbc % mParams.getROFrameLengthInBC(layer)) * o2::constants::lhc::LHCBunchSpacingNS;
+
   if (mNewROFrame < mROFrameMin) {
     LOG(error) << "New ROFrame " << mNewROFrame << " (" << irt << ") precedes currently cashed " << mROFrameMin;
     throw std::runtime_error("deduced ROFrame precedes already processed one");
   }
 
-  if (mParams.isContinuous() && mROFrameMax < mNewROFrame) {
+  if (mROFrameMax < mNewROFrame) {
     mROFrameMax = mNewROFrame - 1; // all frames up to this are finished
   }
 }
 
 //_______________________________________________________________________
-void Digitizer::fillOutputContainer(uint32_t frameLast)
+void Digitizer::fillOutputContainer(uint32_t frameLast, int layer)
 {
   // // fill output with digits from min.cached up to requested frame, generating the noise beforehand
   if (frameLast > mROFrameMax) {
@@ -219,7 +208,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
 
     auto& extra = *(mExtraBuff.front().get());
     for (auto& chip : mChips) {
-      if (chip.isDisabled()) {
+      if (chip.isDisabled() || (layer >= 0 && mGeometry->getLayerTRK(chip.getChipIndex()) != layer)) {
         continue;
       }
       chip.addNoise(mROFrameMin, mROFrameMin, &mParams, mGeometry->getSubDetID(chip.getChipIndex()), mGeometry->getLayer(chip.getChipIndex())); /// TODO: add noise
@@ -251,11 +240,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
     }
     // finalize ROF record
     rcROF.setNEntries(mDigits->size() - rcROF.getFirstEntry()); // number of digits
-    if (isContinuous()) {
-      rcROF.getBCData().setFromLong(mIRFirstSampledTF.toLong() + mROFrameMin * mParams.getROFrameLengthInBC());
-    } else {
-      rcROF.getBCData() = mEventTime; // RSTODO do we need to add trigger delay?
-    }
+    rcROF.getBCData().setFromLong(mIRFirstSampledTF.toLong() + mROFrameMin * mParams.getROFrameLengthInBC(layer));
     if (mROFRecords) {
       mROFRecords->push_back(rcROF);
     }
@@ -267,7 +252,7 @@ void Digitizer::fillOutputContainer(uint32_t frameLast)
 }
 
 //_______________________________________________________________________
-void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, int srcID)
+void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, int srcID, int rofLayer)
 {
   int chipID = hit.GetDetectorID(); //// the chip ID at the moment is not referred to the chip but to a wider detector element (e.g. quarter of layer or disk in VD, stave in ML, half stave in OT)
   int subDetID = mGeometry->getSubDetID(chipID);
@@ -297,9 +282,7 @@ void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, i
     }
     return;
   }
-  if (isContinuous()) {
-    timeInROF += mCollisionTimeWrtROF;
-  }
+  timeInROF += mCollisionTimeWrtROF;
   if (mIsBeforeFirstRO && timeInROF < 0) {
     // disregard this hit because it comes from an event byefore readout starts and it does not effect this RO
     LOG(debug) << "Ignoring hit with timeInROF = " << timeInROF;
@@ -312,9 +295,9 @@ void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, i
   }
   float tTot = mParams.getSignalShape().getMaxDuration();
   // frame of the hit signal start wrt event ROFrame
-  int roFrameRel = int(timeInROF * mParams.getROFrameLengthInv());
+  int roFrameRel = int(timeInROF * mParams.getROFrameLengthInv(rofLayer));
   // frame of the hit signal end  wrt event ROFrame: in the triggered mode we read just 1 frame
-  uint32_t roFrameRelMax = mParams.isContinuous() ? (timeInROF + tTot) * mParams.getROFrameLengthInv() : roFrameRel;
+  uint32_t roFrameRelMax = (timeInROF + tTot) * mParams.getROFrameLengthInv(rofLayer);
   int nFrames = roFrameRelMax + 1 - roFrameRel;
   uint32_t roFrameMax = mNewROFrame + roFrameRelMax;
   if (roFrameMax > maxFr) {
@@ -509,25 +492,25 @@ void Digitizer::processHit(const o2::trk::Hit& hit, uint32_t& maxFr, int evID, i
       if (mDeadChanMap && mDeadChanMap->isNoisy(chipID, rowIS, colIS)) {
         continue;
       }
-      registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl);
+      registerDigits(chip, roFrameAbs, timeInROF, nFrames, rowIS, colIS, nEle, lbl, rofLayer);
     }
   }
 }
 
 //________________________________________________________________________________
 void Digitizer::registerDigits(o2::trk::ChipDigitsContainer& chip, uint32_t roFrame, float tInROF, int nROF,
-                               uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl)
+                               uint16_t row, uint16_t col, int nEle, o2::MCCompLabel& lbl, int layer)
 {
   // Register digits for given pixel, accounting for the possible signal contribution to
   // multiple ROFrame. The signal starts at time tInROF wrt the start of provided roFrame
   // In every ROFrame we check the collected signal during strobe
   LOG(debug) << "Registering digits for chip " << chip.getChipIndex() << " at ROFrame " << roFrame
              << " row " << row << " col " << col << " nEle " << nEle << " label " << lbl;
-  float tStrobe = mParams.getStrobeDelay() - tInROF; // strobe start wrt signal start
-  for (int i = 0; i < nROF; i++) {                   // loop on all the ROFs occupied by the same signal to calculate the charge accumulated in that ROF
+  float tStrobe = mParams.getStrobeDelay(layer) - tInROF; // strobe start wrt signal start
+  for (int i = 0; i < nROF; i++) {                        // loop on all the ROFs occupied by the same signal to calculate the charge accumulated in that ROF
     uint32_t roFr = roFrame + i;
-    int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength());
-    tStrobe += mParams.getROFrameLength(); // for the next ROF
+    int nEleROF = mParams.getSignalShape().getCollectedCharge(nEle, tStrobe, tStrobe + mParams.getStrobeLength(layer));
+    tStrobe += mParams.getROFrameLength(layer); // for the next ROF
 
     // discard too small contributions, they have no chance to produce a digit
     if (nEleROF < mParams.getMinChargeToAccount()) { /// use threshold instead?
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
index 18cc6d245025a..9d072e85d574a 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/ClustererSpec.h
@@ -14,6 +14,7 @@
 
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
+#include "TRKBase/AlmiraParam.h"
 #include "TRKReconstruction/Clusterer.h"
 #ifdef O2_WITH_ACTS
 #include "TRKReconstruction/ClustererACTS.h"
@@ -30,6 +31,7 @@ class ClustererDPL : public o2::framework::Task
   void run(o2::framework::ProcessingContext& pc) final;
 
  private:
+  static constexpr int mLayers = o2::trk::AlmiraParam::kNLayers;
   bool mUseMC = true;
   int mNThreads = 1;
   o2::trk::Clusterer mClusterer;
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitReaderSpec.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitReaderSpec.h
index 2a0acd792f4a9..92b64e0815cfb 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitReaderSpec.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/DigitReaderSpec.h
@@ -12,16 +12,20 @@
 #ifndef O2_TRK_DIGITREADER
 #define O2_TRK_DIGITREADER
 
+#include <vector>
+
 #include "TFile.h"
 #include "TTree.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/GBTCalibData.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
+#include "SimulationDataFormat/IOMCTruthContainerView.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Task.h"
 #include "Headers/DataHeader.h"
 #include "DataFormatsITSMFT/ROFRecord.h"
 #include "DetectorsCommonDataFormats/DetID.h"
+#include "TRKBase/AlmiraParam.h"
 
 using namespace o2::framework;
 
@@ -41,11 +45,16 @@ class DigitReader : public Task
 
  protected:
   void connectTree(const std::string& filename);
+  template <typename Ptr>
+  void setBranchAddress(const std::string& base, Ptr& addr, int layer = -1);
+  std::string getBranchName(const std::string& base, int index) const;
+
+  static constexpr int mLayers = o2::trk::AlmiraParam::kNLayers;
 
-  std::vector<o2::itsmft::Digit> mDigits, *mDigitsPtr = &mDigits;
+  std::vector<std::vector<o2::itsmft::Digit>*> mDigits{nullptr};
   std::vector<o2::itsmft::GBTCalibData> mCalib, *mCalibPtr = &mCalib;
-  std::vector<o2::itsmft::ROFRecord> mDigROFRec, *mDigROFRecPtr = &mDigROFRec;
-  std::vector<o2::itsmft::MC2ROFRecord> mDigMC2ROFs, *mDigMC2ROFsPtr = &mDigMC2ROFs;
+  std::vector<std::vector<o2::itsmft::ROFRecord>*> mDigROFRec{nullptr};
+  std::vector<o2::dataformats::IOMCTruthContainerView*> mPLabels{nullptr};
 
   o2::header::DataOrigin mOrigin = o2::header::gDataOriginInvalid;
 
@@ -64,7 +73,6 @@ class DigitReader : public Task
   std::string mCalibBranchName = "Calib";
 
   std::string mDigtMCTruthBranchName = "DigitMCTruth";
-  std::string mDigtMC2ROFBranchName = "DigitMC2ROF";
 };
 
 class TRKDigitReader : public DigitReader
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClusterWriterSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClusterWriterSpec.cxx
index bc3a75c646198..863915bac0572 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClusterWriterSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClusterWriterSpec.cxx
@@ -11,9 +11,16 @@
 
 /// @file   ClusterWriterSpec.cxx
 
+#include <algorithm>
+#include <cctype>
+#include <memory>
 #include <vector>
+#include <format>
 
 #include "TRKWorkflow/ClusterWriterSpec.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/DataRef.h"
+#include "TRKBase/AlmiraParam.h"
 #include "DPLUtils/MakeRootTreeWriterSpec.h"
 #include "DataFormatsTRK/Cluster.h"
 #include "DataFormatsTRK/ROFRecord.h"
@@ -35,31 +42,68 @@ using ROFRecLblType = std::vector<o2::trk::MC2ROFRecord>;
 
 DataProcessorSpec getClusterWriterSpec(bool useMC)
 {
-  auto clustersSize = std::make_shared<int>(0);
-  auto clustersSizeGetter = [clustersSize](ClustersType const& clusters) {
-    *clustersSize = clusters.size();
+  static constexpr o2::header::DataOrigin Origin{o2::header::gDataOriginTRK};
+  static constexpr int nLayers = o2::trk::AlmiraParam::kNLayers;
+  const auto detName = Origin.as<std::string>();
+
+  auto compClusterSizes = std::make_shared<std::vector<size_t>>(nLayers, 0);
+  auto compClustersSizeGetter = [compClusterSizes](ClustersType const& compClusters, DataRef const& ref) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    (*compClusterSizes)[dh->subSpecification] = compClusters.size();
+  };
+  auto logger = [detName, compClusterSizes](ROFrameType const& rofs, DataRef const& ref) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    const auto i = dh->subSpecification;
+    LOG(info) << detName << "ClusterWriter on layer " << i
+              << " pulled " << (*compClusterSizes)[i] << " clusters, in " << rofs.size() << " RO frames";
   };
-  auto logger = [clustersSize](ROFrameType const& rofs) {
-    LOG(info) << "TRKClusterWriter pulled " << *clustersSize << " clusters, in " << rofs.size() << " RO frames";
+  auto getIndex = [](DataRef const& ref) -> size_t {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    return static_cast<size_t>(dh->subSpecification);
   };
+  auto getName = [](std::string base, size_t index) -> std::string {
+    return base + "_" + std::to_string(index);
+  };
+  auto detNameLC = detName;
+  std::transform(detNameLC.begin(), detNameLC.end(), detNameLC.begin(), [](unsigned char c) { return std::tolower(c); });
+
+  std::vector<InputSpec> vecInpSpecClus, vecInpSpecPatt, vecInpSpecROF, vecInpSpecLbl;
+  vecInpSpecClus.reserve(nLayers);
+  vecInpSpecPatt.reserve(nLayers);
+  vecInpSpecROF.reserve(nLayers);
+  vecInpSpecLbl.reserve(nLayers);
+  for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    vecInpSpecClus.emplace_back(getName("compclus", iLayer), Origin, "COMPCLUSTERS", iLayer);
+    vecInpSpecPatt.emplace_back(getName("patterns", iLayer), Origin, "PATTERNS", iLayer);
+    vecInpSpecROF.emplace_back(getName("ROframes", iLayer), Origin, "CLUSTERSROF", iLayer);
+    vecInpSpecLbl.emplace_back(getName("labels", iLayer), Origin, "CLUSTERSMCTR", iLayer);
+  }
 
-  return MakeRootTreeWriterSpec("trk-cluster-writer",
+  return MakeRootTreeWriterSpec(std::format("{}-cluster-writer", detNameLC).c_str(),
                                 "o2clus_trk.root",
-                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Tree with TRK clusters"},
-                                BranchDefinition<ClustersType>{InputSpec{"compclus", "TRK", "COMPCLUSTERS", 0},
-                                                               "TRKClusterComp",
-                                                               clustersSizeGetter},
-                                BranchDefinition<PatternsType>{InputSpec{"patterns", "TRK", "PATTERNS", 0},
-                                                               "TRKClusterPatt"},
-                                BranchDefinition<ROFrameType>{InputSpec{"ROframes", "TRK", "CLUSTERSROF", 0},
-                                                              "TRKClustersROF",
-                                                              logger},
-                                BranchDefinition<LabelsType>{InputSpec{"labels", "TRK", "CLUSTERSMCTR", 0},
-                                                             "TRKClusterMCTruth",
-                                                             (useMC ? 1 : 0)},
-                                BranchDefinition<ROFRecLblType>{InputSpec{"MC2ROframes", "TRK", "CLUSTERSMC2ROF", 0},
-                                                                "TRKClustersMC2ROF",
-                                                                (useMC ? 1 : 0)})();
+                                MakeRootTreeWriterSpec::TreeAttributes{.name = "o2sim", .title = "Tree with TRK clusters"},
+                                BranchDefinition<ClustersType>{vecInpSpecClus,
+                                                               "TRKClusterComp", "compact-cluster-branch",
+                                                               nLayers,
+                                                               compClustersSizeGetter,
+                                                               getIndex,
+                                                               getName},
+                                BranchDefinition<PatternsType>{vecInpSpecPatt,
+                                                               "TRKClusterPatt", "cluster-pattern-branch",
+                                                               nLayers,
+                                                               getIndex,
+                                                               getName},
+                                BranchDefinition<ROFrameType>{vecInpSpecROF,
+                                                              "TRKClustersROF", "cluster-rof-branch",
+                                                              nLayers,
+                                                              logger,
+                                                              getIndex,
+                                                              getName},
+                                BranchDefinition<LabelsType>{vecInpSpecLbl,
+                                                             "TRKClusterMCTruth", "cluster-label-branch",
+                                                             (useMC ? nLayers : 0),
+                                                             getIndex,
+                                                             getName})();
 }
 
 } // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx
index 5d9ac463b3f54..f91262e021a55 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/ClustererSpec.cxx
@@ -17,6 +17,8 @@
 #include "Framework/Logger.h"
 #include "SimulationDataFormat/ConstMCTruthContainer.h"
 
+#include <format>
+
 namespace o2::trk
 {
 
@@ -30,82 +32,84 @@ void ClustererDPL::init(o2::framework::InitContext& ic)
 
 void ClustererDPL::run(o2::framework::ProcessingContext& pc)
 {
-  auto digits = pc.inputs().get<gsl::span<o2::itsmft::Digit>>("digits");
-  auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>("ROframes");
+  o2::base::GeometryManager::loadGeometry("sgn_geometry.root", false, true);
 
-  gsl::span<const o2::itsmft::MC2ROFRecord> mc2rofs;
-  gsl::span<const char> labelbuffer;
-  if (mUseMC) {
-    labelbuffer = pc.inputs().get<gsl::span<char>>("labels");
-    mc2rofs = pc.inputs().get<gsl::span<o2::itsmft::MC2ROFRecord>>("MC2ROframes");
-  }
-  o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
+  uint64_t totalClusters = 0;
+  for (int iLayer = 0; iLayer < mLayers; ++iLayer) {
+    auto digits = pc.inputs().get<gsl::span<o2::itsmft::Digit>>(std::format("digits_{}", iLayer));
+    auto rofs = pc.inputs().get<gsl::span<o2::itsmft::ROFRecord>>(std::format("ROframes_{}", iLayer));
 
-  std::vector<o2::trk::Cluster> clusters;
-  std::vector<unsigned char> patterns;
-  std::vector<o2::trk::ROFRecord> clusterROFs;
-  std::unique_ptr<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> clusterLabels;
-  std::vector<o2::trk::MC2ROFRecord> clusterMC2ROFs;
-  if (mUseMC) {
-    clusterLabels = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
-  }
-  o2::base::GeometryManager::loadGeometry("o2sim_geometry.root", false, true);
+    gsl::span<const char> labelbuffer;
+    if (mUseMC) {
+      labelbuffer = pc.inputs().get<gsl::span<char>>(std::format("labels_{}", iLayer));
+    }
+    o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
+
+    std::vector<o2::trk::Cluster> clusters;
+    std::vector<unsigned char> patterns;
+    std::vector<o2::trk::ROFRecord> clusterROFs;
+    std::unique_ptr<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> clusterLabels;
+    if (mUseMC) {
+      clusterLabels = std::make_unique<o2::dataformats::MCTruthContainer<o2::MCCompLabel>>();
+    }
 
 #ifdef O2_WITH_ACTS
-  if (mUseACTS) {
-    LOG(info) << "Running TRKClusterer with ACTS";
-    mClustererACTS.process(digits,
-                           rofs,
-                           clusters,
-                           patterns,
-                           clusterROFs,
-                           mUseMC ? &labels : nullptr,
-                           clusterLabels.get(),
-                           mc2rofs,
-                           mUseMC ? &clusterMC2ROFs : nullptr);
-  } else
+    if (mUseACTS) {
+      LOG(info) << "Running TRKClusterer with ACTS on layer " << iLayer;
+      mClustererACTS.process(digits,
+                             rofs,
+                             clusters,
+                             patterns,
+                             clusterROFs,
+                             mUseMC ? &labels : nullptr,
+                             clusterLabels.get());
+    } else
 #endif
-  {
-    LOG(info) << "Running TRKClusterer";
-    mClusterer.process(digits,
-                       rofs,
-                       clusters,
-                       patterns,
-                       clusterROFs,
-                       mUseMC ? &labels : nullptr,
-                       clusterLabels.get(),
-                       mc2rofs,
-                       mUseMC ? &clusterMC2ROFs : nullptr);
-  }
-
-  pc.outputs().snapshot(o2::framework::Output{"TRK", "COMPCLUSTERS", 0}, clusters);
-  pc.outputs().snapshot(o2::framework::Output{"TRK", "PATTERNS", 0}, patterns);
-  pc.outputs().snapshot(o2::framework::Output{"TRK", "CLUSTERSROF", 0}, clusterROFs);
+    {
+      LOG(info) << "Running TRKClusterer on layer " << iLayer;
+      mClusterer.process(digits,
+                         rofs,
+                         clusters,
+                         patterns,
+                         clusterROFs,
+                         mUseMC ? &labels : nullptr,
+                         clusterLabels.get());
+    }
 
-  if (mUseMC) {
-    pc.outputs().snapshot(o2::framework::Output{"TRK", "CLUSTERSMCTR", 0}, *clusterLabels);
-    pc.outputs().snapshot(o2::framework::Output{"TRK", "CLUSTERSMC2ROF", 0}, clusterMC2ROFs);
+    const auto subspec = static_cast<o2::framework::DataAllocator::SubSpecificationType>(iLayer);
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "COMPCLUSTERS", subspec}, clusters);
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "PATTERNS", subspec}, patterns);
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "CLUSTERSROF", subspec}, clusterROFs);
+    if (mUseMC) {
+      pc.outputs().snapshot(o2::framework::Output{"TRK", "CLUSTERSMCTR", subspec}, *clusterLabels);
+    }
+    totalClusters += clusters.size();
+    LOGP(info, "TRKClusterer layer {} pushed {} clusters in {} ROFs", iLayer, clusters.size(), clusterROFs.size());
   }
 
-  LOGP(info, "TRKClusterer pushed {} clusters in {} ROFs", clusters.size(), clusterROFs.size());
+  LOGP(info, "TRKClusterer produced {} clusters", totalClusters);
 }
 
 o2::framework::DataProcessorSpec getClustererSpec(bool useMC)
 {
+  static constexpr int nLayers = o2::trk::AlmiraParam::kNLayers;
   std::vector<o2::framework::InputSpec> inputs;
-  inputs.emplace_back("digits", "TRK", "DIGITS", 0, o2::framework::Lifetime::Timeframe);
-  inputs.emplace_back("ROframes", "TRK", "DIGITSROF", 0, o2::framework::Lifetime::Timeframe);
+  for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
+    inputs.emplace_back(std::format("digits_{}", iLayer), "TRK", "DIGITS", iLayer, o2::framework::Lifetime::Timeframe);
+    inputs.emplace_back(std::format("ROframes_{}", iLayer), "TRK", "DIGITSROF", iLayer, o2::framework::Lifetime::Timeframe);
+    if (useMC) {
+      inputs.emplace_back(std::format("labels_{}", iLayer), "TRK", "DIGITSMCTR", iLayer, o2::framework::Lifetime::Timeframe);
+    }
+  }
 
   std::vector<o2::framework::OutputSpec> outputs;
-  outputs.emplace_back("TRK", "COMPCLUSTERS", 0, o2::framework::Lifetime::Timeframe);
-  outputs.emplace_back("TRK", "PATTERNS", 0, o2::framework::Lifetime::Timeframe);
-  outputs.emplace_back("TRK", "CLUSTERSROF", 0, o2::framework::Lifetime::Timeframe);
-
-  if (useMC) {
-    inputs.emplace_back("labels", "TRK", "DIGITSMCTR", 0, o2::framework::Lifetime::Timeframe);
-    inputs.emplace_back("MC2ROframes", "TRK", "DIGITSMC2ROF", 0, o2::framework::Lifetime::Timeframe);
-    outputs.emplace_back("TRK", "CLUSTERSMCTR", 0, o2::framework::Lifetime::Timeframe);
-    outputs.emplace_back("TRK", "CLUSTERSMC2ROF", 0, o2::framework::Lifetime::Timeframe);
+  for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
+    outputs.emplace_back("TRK", "COMPCLUSTERS", iLayer, o2::framework::Lifetime::Timeframe);
+    outputs.emplace_back("TRK", "PATTERNS", iLayer, o2::framework::Lifetime::Timeframe);
+    outputs.emplace_back("TRK", "CLUSTERSROF", iLayer, o2::framework::Lifetime::Timeframe);
+    if (useMC) {
+      outputs.emplace_back("TRK", "CLUSTERSMCTR", iLayer, o2::framework::Lifetime::Timeframe);
+    }
   }
 
   return o2::framework::DataProcessorSpec{
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitReaderSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitReaderSpec.cxx
index 09bb1f12a48e4..ec2b6d4d66192 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitReaderSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitReaderSpec.cxx
@@ -36,12 +36,15 @@ DigitReader::DigitReader(o2::detectors::DetID id, bool useMC, bool useCalib)
   mDetNameLC = mDetName = id.getName();
   mDigTreeName = "o2sim";
 
+  mDigits.resize(mLayers, nullptr);
+  mDigROFRec.resize(mLayers, nullptr);
+  mPLabels.resize(mLayers, nullptr);
+
   mDigitBranchName = mDetName + mDigitBranchName;
   mDigROFBranchName = mDetName + mDigROFBranchName;
   mCalibBranchName = mDetName + mCalibBranchName;
 
   mDigtMCTruthBranchName = mDetName + mDigtMCTruthBranchName;
-  mDigtMC2ROFBranchName = mDetName + mDigtMC2ROFBranchName;
 
   mUseMC = useMC;
   mUseCalib = useCalib;
@@ -58,30 +61,27 @@ void DigitReader::run(ProcessingContext& pc)
 {
   auto ent = mTree->GetReadEntry() + 1;
   assert(ent < mTree->GetEntries()); // this should not happen
+  mTree->GetEntry(ent);
+
+  for (int iLayer = 0; iLayer < mLayers; ++iLayer) {
+    LOG(info) << mDetName << "DigitReader on layer " << iLayer << " pushes " << mDigROFRec[iLayer]->size() << " ROFRecords, "
+              << mDigits[iLayer]->size() << " digits at entry " << ent;
 
-  o2::dataformats::IOMCTruthContainerView* plabels = nullptr;
-  if (mUseMC) {
-    mTree->SetBranchAddress(mDigtMCTruthBranchName.c_str(), &plabels);
+    pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", static_cast<o2::framework::DataAllocator::SubSpecificationType>(iLayer)}, *mDigROFRec[iLayer]);
+    pc.outputs().snapshot(Output{mOrigin, "DIGITS", static_cast<o2::framework::DataAllocator::SubSpecificationType>(iLayer)}, *mDigits[iLayer]);
+
+    if (mUseMC) {
+      auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", static_cast<o2::framework::DataAllocator::SubSpecificationType>(iLayer)});
+      mPLabels[iLayer]->copyandflatten(sharedlabels);
+      delete mPLabels[iLayer];
+      mPLabels[iLayer] = nullptr;
+    }
   }
-  mTree->GetEntry(ent);
-  LOG(info) << mDetName << "DigitReader pushes " << mDigROFRec.size() << " ROFRecords, "
-            << mDigits.size() << " digits at entry " << ent;
 
-  // This is a very ugly way of providing DataDescription, which anyway does not need to contain detector name.
-  // To be fixed once the names-definition class is ready
-  pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, mDigROFRec);
-  pc.outputs().snapshot(Output{mOrigin, "DIGITS", 0}, mDigits);
   if (mUseCalib) {
     pc.outputs().snapshot(Output{mOrigin, "GBTCALIB", 0}, mCalib);
   }
 
-  if (mUseMC) {
-    auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", 0});
-    plabels->copyandflatten(sharedlabels);
-    delete plabels;
-    pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, mDigMC2ROFs);
-  }
-
   if (mTree->GetReadEntry() + 1 >= mTree->GetEntries()) {
     pc.services().get<ControlService>().endOfStream();
     pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
@@ -96,35 +96,59 @@ void DigitReader::connectTree(const std::string& filename)
   mTree.reset((TTree*)mFile->Get(mDigTreeName.c_str()));
   assert(mTree);
 
-  mTree->SetBranchAddress(mDigROFBranchName.c_str(), &mDigROFRecPtr);
-  mTree->SetBranchAddress(mDigitBranchName.c_str(), &mDigitsPtr);
+  for (int iLayer = 0; iLayer < mLayers; ++iLayer) {
+    setBranchAddress(mDigROFBranchName, mDigROFRec[iLayer], iLayer);
+    setBranchAddress(mDigitBranchName, mDigits[iLayer], iLayer);
+    if (mUseMC) {
+      const auto mctruthBranch = getBranchName(mDigtMCTruthBranchName, iLayer);
+      if (!mTree->GetBranch(mctruthBranch.c_str())) {
+        throw std::runtime_error("MC data requested but missing branch(es) at layer " + std::to_string(iLayer) +
+                                 ": " + mctruthBranch);
+      }
+      setBranchAddress(mDigtMCTruthBranchName, mPLabels[iLayer], iLayer);
+    }
+  }
+
   if (mUseCalib) {
     if (!mTree->GetBranch(mCalibBranchName.c_str())) {
       throw std::runtime_error("GBT calibration data requested but not found in the tree");
     }
-    mTree->SetBranchAddress(mCalibBranchName.c_str(), &mCalibPtr);
-  }
-  if (mUseMC) {
-    if (!mTree->GetBranch(mDigtMC2ROFBranchName.c_str()) || !mTree->GetBranch(mDigtMCTruthBranchName.c_str())) {
-      throw std::runtime_error("MC data requested but not found in the tree");
-    }
-    mTree->SetBranchAddress(mDigtMC2ROFBranchName.c_str(), &mDigMC2ROFsPtr);
+    setBranchAddress(mCalibBranchName, mCalibPtr);
   }
   LOG(info) << "Loaded tree from " << filename << " with " << mTree->GetEntries() << " entries";
 }
 
+std::string DigitReader::getBranchName(const std::string& base, int index) const
+{
+  if (index >= 0) {
+    return base + "_" + std::to_string(index);
+  }
+  return base;
+}
+
+template <typename Ptr>
+void DigitReader::setBranchAddress(const std::string& base, Ptr& addr, int layer)
+{
+  const auto name = getBranchName(base, layer);
+  if (Int_t ret = mTree->SetBranchAddress(name.c_str(), &addr); ret != 0) {
+    LOGP(fatal, "failed to set branch address for {} ret={}", name, ret);
+  }
+}
+
 DataProcessorSpec getTRKDigitReaderSpec(bool useMC, bool useCalib, std::string defname)
 {
+  static constexpr int nLayers = o2::trk::AlmiraParam::kNLayers;
   std::vector<OutputSpec> outputSpec;
-  outputSpec.emplace_back("TRK", "DIGITS", 0, Lifetime::Timeframe);
-  outputSpec.emplace_back("TRK", "DIGITSROF", 0, Lifetime::Timeframe);
+  for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
+    outputSpec.emplace_back("TRK", "DIGITS", iLayer, Lifetime::Timeframe);
+    outputSpec.emplace_back("TRK", "DIGITSROF", iLayer, Lifetime::Timeframe);
+    if (useMC) {
+      outputSpec.emplace_back("TRK", "DIGITSMCTR", iLayer, Lifetime::Timeframe);
+    }
+  }
   if (useCalib) {
     outputSpec.emplace_back("TRK", "GBTCALIB", 0, Lifetime::Timeframe);
   }
-  if (useMC) {
-    outputSpec.emplace_back("TRK", "DIGITSMCTR", 0, Lifetime::Timeframe);
-    outputSpec.emplace_back("TRK", "DIGITSMC2ROF", 0, Lifetime::Timeframe);
-  }
 
   return DataProcessorSpec{
     "trk-digit-reader",
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitWriterSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitWriterSpec.cxx
index 2a743551adddb..591b084aee3ba 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitWriterSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/DigitWriterSpec.cxx
@@ -9,9 +9,12 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-/// @brief  Processor spec for a ROOT file writer for ITSMFT digits
+/// @brief  Processor spec for a ROOT file writer for TRK digits (per-layer)
 
 #include "TRKWorkflow/DigitWriterSpec.h"
+#include "Framework/ConcreteDataMatcher.h"
+#include "Framework/DataRef.h"
+#include "TRKBase/AlmiraParam.h"
 #include "DPLUtils/MakeRootTreeWriterSpec.h"
 #include "DataFormatsITSMFT/Digit.h"
 #include "DataFormatsITSMFT/GBTCalibData.h"
@@ -24,6 +27,7 @@
 #include <vector>
 #include <string>
 #include <algorithm>
+#include <format>
 
 using namespace o2::framework;
 using SubSpecificationType = o2::framework::DataAllocator::SubSpecificationType;
@@ -37,16 +41,22 @@ template <typename T>
 using BranchDefinition = MakeRootTreeWriterSpec::BranchDefinition<T>;
 using MCCont = o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>;
 
-/// create the processor spec
-/// describing a processor receiving digits for ITS/MFT and writing them to file
-DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib, o2::header::DataOrigin detOrig, o2::detectors::DetID detId)
+DataProcessorSpec getTRKDigitWriterSpec(bool mctruth, bool dec, bool calib)
 {
-  std::string detStr = o2::detectors::DetID::getName(detId);
-  std::string detStrL = dec ? "o2_" : ""; // for decoded digits prepend by o2
-  detStrL += detStr;
-  std::transform(detStrL.begin(), detStrL.end(), detStrL.begin(), ::tolower);
-  auto logger = [](std::vector<o2::itsmft::Digit> const& inDigits) {
-    LOG(info) << "RECEIVED DIGITS SIZE " << inDigits.size();
+  static constexpr o2::header::DataOrigin Origin = o2::header::gDataOriginTRK;
+  const int mLayers = o2::trk::AlmiraParam::kNLayers;
+  std::string detStr = "TRK";
+  std::string detStrL = dec ? "o2_trk" : "trk";
+
+  auto digitSizes = std::make_shared<std::vector<size_t>>(mLayers, 0);
+  auto digitSizeGetter = [digitSizes](std::vector<o2::itsmft::Digit> const& inDigits, DataRef const& ref) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    (*digitSizes)[dh->subSpecification] = inDigits.size();
+  };
+  auto rofSizes = std::make_shared<std::vector<size_t>>(mLayers, 0);
+  auto rofSizeGetter = [rofSizes](std::vector<o2::itsmft::ROFRecord> const& inROFs, DataRef const& ref) {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    (*rofSizes)[dh->subSpecification] = inROFs.size();
   };
 
   // the callback to be set as hook for custom action when the writer is closed
@@ -61,16 +71,18 @@ DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib, o2::hea
       nent = n;
     }
     outputtree->SetEntries(nent);
-    outputtree->Write("", TObject::kOverwrite);
+    outputfile->Write("", TObject::kOverwrite);
     outputfile->Close();
   };
 
   // handler for labels
-  // This is necessary since we can't store the original label buffer in a ROOT entry -- as is -- if it exceeds a certain size.
-  // We therefore convert it to a special split class.
-  auto fillLabels = [](TBranch& branch, std::vector<char> const& labelbuffer, DataRef const& /*ref*/) {
+  auto fillLabels = [detStr, digitSizes, rofSizes](TBranch& branch, std::vector<char> const& labelbuffer, DataRef const& ref) {
     o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel> labels(labelbuffer);
-    LOG(info) << "WRITING " << labels.getNElements() << " LABELS ";
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    auto layer = static_cast<size_t>(dh->subSpecification);
+    LOG(info) << detStr << ": WRITING " << labels.getNElements() << " LABELS"
+              << std::format(" FOR LAYER {}", layer) << " WITH " << (*digitSizes)[layer]
+              << " DIGITS IN " << (*rofSizes)[layer] << " ROFS";
 
     o2::dataformats::IOMCTruthContainerView outputcontainer;
     auto ptr = &outputcontainer;
@@ -80,30 +92,49 @@ DataProcessorSpec getDigitWriterSpec(bool mctruth, bool dec, bool calib, o2::hea
     br->ResetAddress();
   };
 
-  return MakeRootTreeWriterSpec((detStr + "DigitWriter" + (dec ? "_dec" : "")).c_str(),
+  auto getIndex = [](DataRef const& ref) -> size_t {
+    auto const* dh = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    return static_cast<size_t>(dh->subSpecification);
+  };
+  auto getName = [](std::string base, size_t index) -> std::string {
+    return base + "_" + std::to_string(index);
+  };
+
+  std::vector<InputSpec> vecInpSpecDig, vecInpSpecROF, vecInpSpecLbl;
+  vecInpSpecDig.reserve(mLayers);
+  vecInpSpecROF.reserve(mLayers);
+  vecInpSpecLbl.reserve(mLayers);
+  for (int iLayer = 0; iLayer < mLayers; iLayer++) {
+    vecInpSpecDig.emplace_back(getName(detStr + "digits", iLayer), Origin, "DIGITS", iLayer);
+    vecInpSpecROF.emplace_back(getName(detStr + "digitsROF", iLayer), Origin, "DIGITSROF", iLayer);
+    vecInpSpecLbl.emplace_back(getName(detStr + "_digitsMCTR", iLayer), Origin, "DIGITSMCTR", iLayer);
+  }
+
+  return MakeRootTreeWriterSpec(("TRKDigitWriter" + std::string(dec ? "_dec" : "")).c_str(),
                                 (detStrL + "digits.root").c_str(),
-                                MakeRootTreeWriterSpec::TreeAttributes{"o2sim", "Digits tree"},
+                                MakeRootTreeWriterSpec::TreeAttributes{.name = "o2sim", .title = detStr + " Digits tree"},
                                 MakeRootTreeWriterSpec::CustomClose(finishWriting),
-                                // in case of labels we first read them as std::vector<char> and process them correctly in the fillLabels hook
-                                BranchDefinition<std::vector<char>>{InputSpec{"digitsMCTR", detOrig, "DIGITSMCTR", 0},
-                                                                    (detStr + "DigitMCTruth").c_str(),
-                                                                    (mctruth ? 1 : 0), fillLabels},
-                                BranchDefinition<std::vector<itsmft::MC2ROFRecord>>{InputSpec{"digitsMC2ROF", detOrig, "DIGITSMC2ROF", 0},
-                                                                                    (detStr + "DigitMC2ROF").c_str(),
-                                                                                    (mctruth ? 1 : 0)},
-                                BranchDefinition<std::vector<itsmft::Digit>>{InputSpec{"digits", detOrig, "DIGITS", 0},
-                                                                             (detStr + "Digit").c_str(),
-                                                                             logger},
-                                BranchDefinition<std::vector<itsmft::GBTCalibData>>{InputSpec{"calib", detOrig, "GBTCALIB", 0},
-                                                                                    (detStr + "Calib").c_str(),
-                                                                                    (calib ? 1 : 0)},
-                                BranchDefinition<std::vector<itsmft::ROFRecord>>{InputSpec{"digitsROF", detOrig, "DIGITSROF", 0},
-                                                                                 (detStr + "DigitROF").c_str()})();
-}
-
-DataProcessorSpec getTRKDigitWriterSpec(bool mctruth, bool dec, bool calib)
-{
-  return getDigitWriterSpec(mctruth, dec, calib, o2::header::gDataOriginTRK, o2::detectors::DetID::TRK);
+                                BranchDefinition<std::vector<itsmft::Digit>>{vecInpSpecDig,
+                                                                             detStr + "Digit", "digit-branch",
+                                                                             mLayers,
+                                                                             digitSizeGetter,
+                                                                             getIndex,
+                                                                             getName},
+                                BranchDefinition<std::vector<itsmft::ROFRecord>>{vecInpSpecROF,
+                                                                                 detStr + "DigitROF", "digit-rof-branch",
+                                                                                 mLayers,
+                                                                                 rofSizeGetter,
+                                                                                 getIndex,
+                                                                                 getName},
+                                BranchDefinition<std::vector<char>>{vecInpSpecLbl,
+                                                                    detStr + "DigitMCTruth", "digit-mctruth-branch",
+                                                                    (mctruth ? mLayers : 0),
+                                                                    fillLabels,
+                                                                    getIndex,
+                                                                    getName},
+                                BranchDefinition<std::vector<itsmft::GBTCalibData>>{InputSpec{detStr + "calib", ConcreteDataTypeMatcher{Origin, "GBTCALIB"}},
+                                                                                    detStr + "Calib", "digit-calib-branch",
+                                                                                    (calib ? 1 : 0)})();
 }
 
 } // end namespace trk
diff --git a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
index 8957ebed223b2..06d922cc1a117 100644
--- a/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
+++ b/Steer/DigitizerWorkflow/src/TRKDigitizerSpec.cxx
@@ -30,6 +30,7 @@
 #include "TRKSimulation/DPLDigitizerParam.h"
 #include "TRKBase/AlmiraParam.h"
 #include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/Specs.h"
 #include "TRKBase/TRKBaseParam.h"
 
 #include <TChain.h>
@@ -47,11 +48,13 @@ namespace
 std::vector<OutputSpec> makeOutChannels(o2::header::DataOrigin detOrig, bool mctruth)
 {
   std::vector<OutputSpec> outputs;
-  outputs.emplace_back(detOrig, "DIGITS", 0, Lifetime::Timeframe);
-  outputs.emplace_back(detOrig, "DIGITSROF", 0, Lifetime::Timeframe);
-  if (mctruth) {
-    outputs.emplace_back(detOrig, "DIGITSMC2ROF", 0, Lifetime::Timeframe);
-    outputs.emplace_back(detOrig, "DIGITSMCTR", 0, Lifetime::Timeframe);
+  for (uint32_t iLayer = 0; iLayer < o2::trk::AlmiraParam::getNLayers(); ++iLayer) {
+    outputs.emplace_back(detOrig, "DIGITS", iLayer, Lifetime::Timeframe);
+    outputs.emplace_back(detOrig, "DIGITSROF", iLayer, Lifetime::Timeframe);
+    if (mctruth) {
+      outputs.emplace_back(detOrig, "DIGITSMC2ROF", iLayer, Lifetime::Timeframe);
+      outputs.emplace_back(detOrig, "DIGITSMCTR", iLayer, Lifetime::Timeframe);
+    }
   }
   outputs.emplace_back(detOrig, "ROMode", 0, Lifetime::Timeframe);
   return outputs;
@@ -99,163 +102,151 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
     timer.Start();
     LOG(info) << " CALLING TRK DIGITIZATION ";
 
-    mDigitizer.setDigits(&mDigits);
-    mDigitizer.setROFRecords(&mROFRecords);
-    mDigitizer.setMCLabels(&mLabels);
+    auto& eventParts = context->getEventParts(withQED);
+    uint64_t nDigits{0};
+    for (uint32_t iLayer = 0; iLayer < static_cast<uint32_t>(mLayers); ++iLayer) {
+      mDigits[iLayer].clear();
+      mROFRecords[iLayer].clear();
+      mROFRecordsAccum[iLayer].clear();
+      if (mWithMCTruth) {
+        mLabels[iLayer].clear();
+        mLabelsAccum[iLayer].clear();
+        mMC2ROFRecordsAccum[iLayer].clear();
+      }
+
+      mDigitizer.setDigits(&mDigits[iLayer]);
+      mDigitizer.setROFRecords(&mROFRecords[iLayer]);
+      mDigitizer.setMCLabels(&mLabels[iLayer]);
+      mDigitizer.resetROFrameBounds();
 
-    // digits are directly put into DPL owned resource
-    auto& digitsAccum = pc.outputs().make<std::vector<itsmft::Digit>>(Output{mOrigin, "DIGITS", 0});
+      // digits are directly put into DPL owned resource
+      auto& digitsAccum = pc.outputs().make<std::vector<itsmft::Digit>>(Output{mOrigin, "DIGITS", iLayer});
 
-    const int roFrameLengthInBC = mDigitizer.getParams().getROFrameLengthInBC();
-    const int nROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / roFrameLengthInBC;
-    const int nROFsTF = nROFsPerOrbit * raw::HBFUtils::Instance().getNOrbitsPerTF();
-    mROFRecordsAccum.reserve(nROFsTF);
+      const int roFrameLengthInBC = mDigitizer.getParams().getROFrameLengthInBC(iLayer);
+      const int nROFsPerOrbit = o2::constants::lhc::LHCMaxBunches / roFrameLengthInBC;
+      const int nROFsTF = nROFsPerOrbit * raw::HBFUtils::Instance().getNOrbitsPerTF();
+      mROFRecordsAccum[iLayer].reserve(nROFsTF);
 
-    auto accumulate = [this, &digitsAccum]() {
-      // accumulate result of single event processing, called after processing every event supplied
-      // AND after the final flushing via digitizer::fillOutputContainer
-      if (mDigits.empty()) {
-        LOG(debug) << "No digits to accumulate";
-        return; // no digits were flushed, nothing to accumulate
-      }
-      LOG(debug) << "Accumulating " << mDigits.size() << " digits ";
-      auto ndigAcc = digitsAccum.size();
-      std::copy(mDigits.begin(), mDigits.end(), std::back_inserter(digitsAccum));
-
-      // fix ROFrecords references on ROF entries
-      auto nROFRecsOld = mROFRecordsAccum.size();
-
-      for (int i = 0; i < mROFRecords.size(); i++) {
-        auto& rof = mROFRecords[i];
-        rof.setFirstEntry(ndigAcc + rof.getFirstEntry());
-        rof.print();
-
-        if (mFixMC2ROF < mMC2ROFRecordsAccum.size()) { // fix ROFRecord entry in MC2ROF records
-          for (int m2rid = mFixMC2ROF; m2rid < mMC2ROFRecordsAccum.size(); m2rid++) {
-            // need to register the ROFRecors entry for MC event starting from this entry
-            auto& mc2rof = mMC2ROFRecordsAccum[m2rid];
-            if (rof.getROFrame() == mc2rof.minROF) {
-              mFixMC2ROF++;
-              mc2rof.rofRecordID = nROFRecsOld + i;
-              mc2rof.print();
-            }
-          }
+      auto accumulate = [this, &digitsAccum, &iLayer]() {
+        // accumulate result of single event processing on one layer, called after each collision
+        // and after the final flushing via digitizer::fillOutputContainer
+        if (mDigits[iLayer].empty()) {
+          return;
         }
-      }
+        auto ndigAcc = digitsAccum.size();
+        std::copy(mDigits[iLayer].begin(), mDigits[iLayer].end(), std::back_inserter(digitsAccum));
 
-      std::copy(mROFRecords.begin(), mROFRecords.end(), std::back_inserter(mROFRecordsAccum));
-      if (mWithMCTruth) {
-        mLabelsAccum.mergeAtBack(mLabels);
-      }
-      LOG(info) << "Added " << mDigits.size() << " digits ";
-      // clean containers from already accumulated stuff
-      mLabels.clear();
-      mDigits.clear();
-      mROFRecords.clear();
-    }; // end accumulate lambda
+        for (auto& rof : mROFRecords[iLayer]) {
+          rof.setFirstEntry(ndigAcc + rof.getFirstEntry());
+        }
 
-    auto& eventParts = context->getEventParts(withQED);
-    // loop over all composite collisions given from context (aka loop over all the interaction records)
-    const int bcShift = mDigitizer.getParams().getROFrameBiasInBC();
-    // loop over all composite collisions given from context (aka loop over all the interaction records)
-    for (size_t collID = 0; collID < timesview.size(); ++collID) {
-      auto irt = timesview[collID];
-      if (irt.toLong() < bcShift) { // due to the ROF misalignment the collision would go to negative ROF ID, discard
-        continue;
-      }
-      irt -= bcShift; // account for the ROF start shift
-
-      mDigitizer.setEventTime(irt);
-      mDigitizer.resetEventROFrames(); // to estimate min/max ROF for this collID
-      // for each collision, loop over the constituents event and source IDs
-      // (background signal merging is basically taking place here)
-      for (auto& part : eventParts[collID]) {
-
-        // get the hits for this event and this source
-        mHits.clear();
-        context->retrieveHits(mSimChains, o2::detectors::SimTraits::DETECTORBRANCHNAMES[mID][0].c_str(), part.sourceID, part.entryID, &mHits);
-
-        if (!mHits.empty()) {
-          LOG(debug) << "For collision " << collID << " eventID " << part.entryID
-                     << " found " << mHits.size() << " hits ";
-          mDigitizer.process(&mHits, part.entryID, part.sourceID); // call actual digitization procedure
+        std::copy(mROFRecords[iLayer].begin(), mROFRecords[iLayer].end(), std::back_inserter(mROFRecordsAccum[iLayer]));
+        if (mWithMCTruth) {
+          mLabelsAccum[iLayer].mergeAtBack(mLabels[iLayer]);
         }
+        LOG(info) << "Added " << mDigits[iLayer].size() << " digits on layer " << iLayer;
+        mLabels[iLayer].clear();
+        mDigits[iLayer].clear();
+        mROFRecords[iLayer].clear();
+      };
+
+      const int bcShift = mDigitizer.getParams().getROFrameBiasInBC(iLayer);
+      for (size_t collID = 0; collID < timesview.size(); ++collID) {
+        auto irt = timesview[collID];
+        if (irt.toLong() < bcShift) {
+          continue;
+        }
+        irt -= bcShift;
+
+        mDigitizer.setEventTime(irt, iLayer);
+        mDigitizer.resetEventROFrames();
+        for (auto& part : eventParts[collID]) {
+          mHits.clear();
+          context->retrieveHits(mSimChains, o2::detectors::SimTraits::DETECTORBRANCHNAMES[mID][0].c_str(), part.sourceID, part.entryID, &mHits);
+
+          if (!mHits.empty()) {
+            LOG(debug) << "For collision " << collID << " eventID " << part.entryID
+                       << " found " << mHits.size() << " hits on layer " << iLayer;
+            mDigitizer.process(&mHits, part.entryID, part.sourceID, iLayer);
+          }
+        }
+        if (mWithMCTruth) {
+          mMC2ROFRecordsAccum[iLayer].emplace_back(collID, -1, mDigitizer.getEventROFrameMin(), mDigitizer.getEventROFrameMax());
+        }
+        accumulate();
       }
-      mMC2ROFRecordsAccum.emplace_back(collID, -1, mDigitizer.getEventROFrameMin(), mDigitizer.getEventROFrameMax());
+      mDigitizer.fillOutputContainer(0xffffffff, iLayer);
       accumulate();
-    }
-    mDigitizer.fillOutputContainer();
-    LOG(debug) << "mDigits size after fill: " << mDigits.size();
-    accumulate();
-
-    // here we have all digits and labels and we can send them to consumer (aka snapshot it onto output)
-    std::vector<o2::itsmft::ROFRecord> expDigitRofVec(nROFsTF);
-    for (int iROF = 0; iROF < nROFsTF; ++iROF) {
-      auto& rof = expDigitRofVec[iROF];
-      const int orb = iROF * roFrameLengthInBC / o2::constants::lhc::LHCMaxBunches + mFirstOrbitTF;
-      const int bc = iROF * roFrameLengthInBC % o2::constants::lhc::LHCMaxBunches;
-      rof.setBCData(o2::InteractionRecord(bc, orb));
-      rof.setROFrame(iROF);
-      rof.setNEntries(0);
-      rof.setFirstEntry(-1);
-    }
-
-    for (const auto& rof : mROFRecordsAccum) {
-      const auto& ir = rof.getBCData();
-      const auto irToFirst = ir - firstIR;
-      const auto irROF = irToFirst.toLong() / roFrameLengthInBC;
-      if (irROF < 0 || irROF >= nROFsTF) {
-        continue;
+      nDigits += digitsAccum.size();
+
+      std::vector<o2::itsmft::ROFRecord> expDigitRofVec(nROFsTF);
+      for (int iROF = 0; iROF < nROFsTF; ++iROF) {
+        auto& rof = expDigitRofVec[iROF];
+        const int orb = iROF * roFrameLengthInBC / o2::constants::lhc::LHCMaxBunches + mFirstOrbitTF;
+        const int bc = iROF * roFrameLengthInBC % o2::constants::lhc::LHCMaxBunches;
+        rof.setBCData(o2::InteractionRecord(bc, orb));
+        rof.setROFrame(iROF);
+        rof.setNEntries(0);
+        rof.setFirstEntry(-1);
       }
-      auto& expROF = expDigitRofVec[irROF];
-      expROF.setFirstEntry(rof.getFirstEntry());
-      expROF.setNEntries(rof.getNEntries());
-      if (expROF.getBCData() != rof.getBCData()) {
-        LOGP(fatal, "detected mismatch between expected {} and received {}", expROF.asString(), rof.asString());
+
+      for (const auto& rof : mROFRecordsAccum[iLayer]) {
+        const auto& ir = rof.getBCData();
+        const auto irToFirst = ir - firstIR;
+        const auto irROF = irToFirst.toLong() / roFrameLengthInBC;
+        if (irROF < 0 || irROF >= nROFsTF) {
+          continue;
+        }
+        auto& expROF = expDigitRofVec[irROF];
+        expROF.setFirstEntry(rof.getFirstEntry());
+        expROF.setNEntries(rof.getNEntries());
+        if (expROF.getBCData() != rof.getBCData()) {
+          LOGP(fatal, "detected mismatch between expected {} and received {}", expROF.asString(), rof.asString());
+        }
       }
-    }
 
-    int prevFirst = 0;
-    for (auto& rof : expDigitRofVec) {
-      if (rof.getFirstEntry() < 0) {
-        rof.setFirstEntry(prevFirst);
+      int prevFirst = 0;
+      for (auto& rof : expDigitRofVec) {
+        if (rof.getFirstEntry() < 0) {
+          rof.setFirstEntry(prevFirst);
+        }
+        prevFirst = rof.getFirstEntry();
       }
-      prevFirst = rof.getFirstEntry();
-    }
 
-    pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", 0}, expDigitRofVec);
-    if (mWithMCTruth) {
-      std::vector<o2::itsmft::MC2ROFRecord> clippedMC2ROFRecords;
-      clippedMC2ROFRecords.reserve(mMC2ROFRecordsAccum.size());
-      for (auto mc2rof : mMC2ROFRecordsAccum) {
-        if (mc2rof.rofRecordID < 0 || mc2rof.minROF >= static_cast<uint32_t>(nROFsTF)) {
-          mc2rof.rofRecordID = -1;
-          mc2rof.minROF = 0;
-          mc2rof.maxROF = 0;
-        } else {
-          mc2rof.maxROF = std::min<uint32_t>(mc2rof.maxROF, nROFsTF - 1);
-          if (mc2rof.minROF > mc2rof.maxROF) {
+      pc.outputs().snapshot(Output{mOrigin, "DIGITSROF", iLayer}, expDigitRofVec);
+      if (mWithMCTruth) {
+        std::vector<o2::itsmft::MC2ROFRecord> clippedMC2ROFRecords;
+        clippedMC2ROFRecords.reserve(mMC2ROFRecordsAccum[iLayer].size());
+        for (auto mc2rof : mMC2ROFRecordsAccum[iLayer]) {
+          if (mc2rof.minROF >= static_cast<uint32_t>(nROFsTF) || mc2rof.minROF > mc2rof.maxROF) {
             mc2rof.rofRecordID = -1;
             mc2rof.minROF = 0;
             mc2rof.maxROF = 0;
           } else {
-            mc2rof.rofRecordID = mc2rof.minROF;
+            mc2rof.maxROF = std::min<uint32_t>(mc2rof.maxROF, nROFsTF - 1);
+            if (mc2rof.minROF > mc2rof.maxROF) {
+              mc2rof.rofRecordID = -1;
+              mc2rof.minROF = 0;
+              mc2rof.maxROF = 0;
+            } else {
+              mc2rof.rofRecordID = mc2rof.minROF;
+            }
           }
+          clippedMC2ROFRecords.push_back(mc2rof);
         }
-        clippedMC2ROFRecords.push_back(mc2rof);
+        pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", iLayer}, clippedMC2ROFRecords);
+        auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", iLayer});
+        mLabelsAccum[iLayer].flatten_to(sharedlabels);
+        mLabels[iLayer].clear_andfreememory();
+        mLabelsAccum[iLayer].clear_andfreememory();
       }
-      pc.outputs().snapshot(Output{mOrigin, "DIGITSMC2ROF", 0}, clippedMC2ROFRecords);
-      auto& sharedlabels = pc.outputs().make<o2::dataformats::ConstMCTruthContainer<o2::MCCompLabel>>(Output{mOrigin, "DIGITSMCTR", 0});
-      mLabelsAccum.flatten_to(sharedlabels);
-      // free space of existing label containers
-      mLabels.clear_andfreememory();
-      mLabelsAccum.clear_andfreememory();
     }
     LOG(info) << mID.getName() << ": Sending ROMode= " << mROMode << " to GRPUpdater";
     pc.outputs().snapshot(Output{mOrigin, "ROMode", 0}, mROMode);
 
     timer.Stop();
     LOG(info) << "Digitization took " << timer.CpuTime() << "s";
+    LOG(info) << "Produced " << nDigits << " digits";
 
     // we should be only called once; tell DPL that this process is ready to exit
     pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
@@ -288,13 +279,25 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
       const auto& dopt = o2::trk::DPLDigitizerParam<o2::detectors::DetID::TRK>::Instance();
       // pc.inputs().get<o2::trk::AlmiraParam*>("TRK_almiraparam");
       const auto& aopt = o2::trk::AlmiraParam::Instance();
-      auto frameNS = aopt.roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingNS;
-      digipar.setContinuous(true);
-      digipar.setROFrameBiasInBC(aopt.roFrameBiasInBC);
-      digipar.setROFrameLengthInBC(aopt.roFrameLengthInBC);
-      digipar.setROFrameLength(frameNS); // RO frame in ns
-      digipar.setStrobeDelay(aopt.strobeDelay);
-      digipar.setStrobeLength(aopt.strobeLengthCont > 0 ? aopt.strobeLengthCont : frameNS - aopt.strobeDelay);
+      mLayers = constants::VD::petal::nLayers + geom->getNumberOfLayersMLOT();
+      mDigits.resize(mLayers);
+      mROFRecords.resize(mLayers);
+      mROFRecordsAccum.resize(mLayers);
+      mLabels.resize(mLayers);
+      mLabelsAccum.resize(mLayers);
+      mMC2ROFRecordsAccum.resize(mLayers);
+
+      for (int iLayer = 0; iLayer < mLayers; ++iLayer) {
+        const auto roFrameLengthInBC = aopt.getROFLengthInBC(iLayer);
+        const auto frameNS = roFrameLengthInBC * o2::constants::lhc::LHCBunchSpacingNS;
+        digipar.setROFrameLengthInBC(roFrameLengthInBC, iLayer);
+        // ROF delay is treated as an additional bias from the digitizer point of view.
+        digipar.setROFrameBiasInBC(aopt.getROFBiasInBC(iLayer) + aopt.getROFDelayInBC(iLayer), iLayer);
+        digipar.setStrobeDelay(aopt.getStrobeDelay(iLayer), iLayer);
+        const auto strobeLengthCont = aopt.getStrobeLengthCont(iLayer);
+        digipar.setStrobeLength(strobeLengthCont > 0 ? strobeLengthCont : frameNS - aopt.getStrobeDelay(iLayer), iLayer);
+        digipar.setROFrameLength(frameNS, iLayer);
+      }
       // parameters of signal time response: flat-top duration, max rise time and q @ which rise time is 0
       digipar.getSignalShape().setParameters(dopt.strobeFlatTop, dopt.strobeMaxRiseTime, dopt.strobeQRiseTime0);
       digipar.setChargeThreshold(dopt.chargeThreshold); // charge threshold in electrons
@@ -352,17 +355,16 @@ class TRKDPLDigitizerTask : BaseDPLDigitizer
   const o2::detectors::DetID mID{o2::detectors::DetID::TRK};
   const o2::header::DataOrigin mOrigin{o2::header::gDataOriginTRK};
   o2::trk::Digitizer mDigitizer{};
-  std::vector<o2::itsmft::Digit> mDigits{};
-  std::vector<o2::itsmft::ROFRecord> mROFRecords{};
-  std::vector<o2::itsmft::ROFRecord> mROFRecordsAccum{};
+  int mLayers{0};
+  std::vector<std::vector<o2::itsmft::Digit>> mDigits{};
+  std::vector<std::vector<o2::itsmft::ROFRecord>> mROFRecords{};
+  std::vector<std::vector<o2::itsmft::ROFRecord>> mROFRecordsAccum{};
   std::vector<o2::trk::Hit> mHits{};
   std::vector<o2::trk::Hit>* mHitsP{&mHits};
-  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabels{};
-  o2::dataformats::MCTruthContainer<o2::MCCompLabel> mLabelsAccum{};
-  std::vector<o2::itsmft::MC2ROFRecord> mMC2ROFRecordsAccum{};
+  std::vector<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> mLabels{};
+  std::vector<o2::dataformats::MCTruthContainer<o2::MCCompLabel>> mLabelsAccum{};
+  std::vector<std::vector<o2::itsmft::MC2ROFRecord>> mMC2ROFRecordsAccum{};
   std::vector<TChain*> mSimChains{};
-
-  int mFixMC2ROF = 0;                                                             // 1st entry in mc2rofRecordsAccum to be fixed for ROFRecordID
   o2::parameters::GRPObject::ROMode mROMode = o2::parameters::GRPObject::PRESENT; // readout mode
 };
 

From 72a2278ff53149436a5500d5375a1a3182d683b1 Mon Sep 17 00:00:00 2001
From: SuJeong Ji <120470463+SuJeong-Ji@users.noreply.github.com>
Date: Thu, 16 Apr 2026 00:22:27 +0900
Subject: [PATCH 1677/1764] Added physics constants for K1(1270)

---
 Common/Constants/include/CommonConstants/PhysicsConstants.h | 6 +++++-
 Common/Constants/include/CommonConstants/make_pdg_header.py | 2 ++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/Common/Constants/include/CommonConstants/PhysicsConstants.h b/Common/Constants/include/CommonConstants/PhysicsConstants.h
index 46aeff98d6033..e95b4343a63d4 100644
--- a/Common/Constants/include/CommonConstants/PhysicsConstants.h
+++ b/Common/Constants/include/CommonConstants/PhysicsConstants.h
@@ -92,7 +92,9 @@ enum Pdg {
   kHyperHelium4 = 1010020040,
   kHyperHelium5 = 1010020050,
   kHyperHelium4Sigma = 1110020040,
-  kLambda1520_Py = 102134
+  kLambda1520_Py = 102134,
+  kK1_1270_0 = 10313,
+  kK1_1270Plus = 10323
 };
 
 /// \brief Declarations of masses for additional particles
@@ -158,6 +160,8 @@ constexpr double MassHyperHelium4 = 3.921728;
 constexpr double MassHyperHelium5 = 4.839961;
 constexpr double MassHyperHelium4Sigma = 3.995;
 constexpr double MassLambda1520_Py = 1.5195;
+constexpr double MassK1_1270_0 = 1.253;
+constexpr double MassK1_1270Plus = 1.272;
 
 /// \brief Declarations of masses for particles in ROOT PDG_t
 constexpr double MassDown = 0.00467;
diff --git a/Common/Constants/include/CommonConstants/make_pdg_header.py b/Common/Constants/include/CommonConstants/make_pdg_header.py
index f83c44bb401db..ccea1863771f3 100755
--- a/Common/Constants/include/CommonConstants/make_pdg_header.py
+++ b/Common/Constants/include/CommonConstants/make_pdg_header.py
@@ -151,6 +151,8 @@ class Pdg(Enum):
     kHyperHelium5 = 1010020050
     kHyperHelium4Sigma = 1110020040
     kLambda1520_Py = 102134  # PYTHIA code different from PDG
+    kK1_1270_0 = 10313
+    kK1_1270Plus = 10323
 
 
 dbPdg = o2.O2DatabasePDG

From a3da6e46ee5f33b2aee7ba29dc21a6a08dbc3565 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 17 Mar 2026 17:25:12 +0100
Subject: [PATCH 1678/1764] DPL: allow determining the origin from user provide
 input

In order to support embedding, we need allow the user to provide
a mapping between the desired origin and the level in the parent file
chain where the table should be found.
---
 Framework/AnalysisSupport/CMakeLists.txt      |   9 ++
 .../src/AODJAlienReaderHelpers.cxx            |  34 ++++-
 .../AnalysisSupport/src/DataInputDirector.cxx |  84 +++++++++--
 .../AnalysisSupport/src/DataInputDirector.h   |  26 +++-
 .../test/test_NavigateToLevel.cxx             | 135 ++++++++++++++++++
 Framework/Core/src/Plugin.cxx                 |   3 +
 6 files changed, 268 insertions(+), 23 deletions(-)
 create mode 100644 Framework/AnalysisSupport/test/test_NavigateToLevel.cxx

diff --git a/Framework/AnalysisSupport/CMakeLists.txt b/Framework/AnalysisSupport/CMakeLists.txt
index 6024134a5495d..956c4a44c5684 100644
--- a/Framework/AnalysisSupport/CMakeLists.txt
+++ b/Framework/AnalysisSupport/CMakeLists.txt
@@ -47,6 +47,15 @@ o2_add_test(DataInputDirector NAME test_Framework_test_DataInputDirector
                LABELS framework
                PUBLIC_LINK_LIBRARIES O2::FrameworkAnalysisSupport)
 
+add_executable(o2-test-framework-analysis-support
+               test/test_NavigateToLevel.cxx)
+target_link_libraries(o2-test-framework-analysis-support PRIVATE O2::FrameworkAnalysisSupport O2::Catch2)
+
+get_filename_component(outdir ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/../tests ABSOLUTE)
+set_property(TARGET o2-test-framework-analysis-support PROPERTY RUNTIME_OUTPUT_DIRECTORY ${outdir})
+
+add_test(NAME framework:analysis-support COMMAND o2-test-framework-analysis-support)
+
 o2_add_test(TableToTree NAME benchmark_TableToTree
                SOURCES test/benchmark_TableToTree.cxx
                COMPONENT_NAME Framework
diff --git a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
index 57a397822d167..8fde9f52a0e09 100644
--- a/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
+++ b/Framework/AnalysisSupport/src/AODJAlienReaderHelpers.cxx
@@ -10,7 +10,10 @@
 // or submit itself to any jurisdiction.
 
 #include "AODJAlienReaderHelpers.h"
+#include <charconv>
 #include <memory>
+#include <ranges>
+#include <vector>
 #include "Framework/TableTreeHelpers.h"
 #include "Framework/AnalysisHelpers.h"
 #include "Framework/DataProcessingStats.h"
@@ -111,10 +114,31 @@ AlgorithmSpec AODJAlienReaderHelpers::rootFileReaderCallback(ConfigContext const
   if (ctx.options().isSet("aod-parent-access-level")) {
     parentAccessLevel = ctx.options().get<int>("aod-parent-access-level");
   }
-  auto callback = AlgorithmSpec{adaptStateful([parentFileReplacement, parentAccessLevel](ConfigParamRegistry const& options,
-                                                                                         DeviceSpec const& spec,
-                                                                                         Monitoring& monitoring,
-                                                                                         DataProcessingStats& stats) {
+  std::vector<std::pair<std::string, int>> originLevelMapping;
+  if (ctx.options().isSet("aod-origin-level-mapping")) {
+    auto originLevelMappingStr = ctx.options().get<std::string>("aod-origin-level-mapping");
+    for (auto pairRange : originLevelMappingStr | std::views::split(',')) {
+      std::string_view pair{pairRange.begin(), pairRange.end()};
+      auto colonPos = pair.find(':');
+      if (colonPos == std::string_view::npos) {
+        LOGP(fatal, "Badly formatted aod-origin-level-mapping entry: \"{}\"", pair);
+        continue;
+      }
+      std::string key(pair.substr(0, colonPos));
+      std::string_view valueStr = pair.substr(colonPos + 1);
+      int value{};
+      auto [ptr, ec] = std::from_chars(valueStr.data(), valueStr.data() + valueStr.size(), value);
+      if (ec == std::errc{}) {
+        originLevelMapping.emplace_back(std::move(key), value);
+      } else {
+        LOGP(fatal, "Unable to parse level in aod-origin-level-mapping entry: \"{}\"", pair);
+      }
+    }
+  }
+  auto callback = AlgorithmSpec{adaptStateful([parentFileReplacement, parentAccessLevel, originLevelMapping](ConfigParamRegistry const& options,
+                                                                                                             DeviceSpec const& spec,
+                                                                                                             Monitoring& monitoring,
+                                                                                                             DataProcessingStats& stats) {
     // FIXME: not actually needed, since data processing stats can specify that we should
     // send the initial value.
     stats.updateStats({static_cast<short>(ProcessingStatsId::ARROW_BYTES_CREATED), DataProcessingStats::Op::Set, 0});
@@ -134,7 +158,7 @@ AlgorithmSpec AODJAlienReaderHelpers::rootFileReaderCallback(ConfigContext const
     auto maxRate = options.get<float>("aod-max-io-rate");
 
     // create a DataInputDirector
-    auto didir = std::make_shared<DataInputDirector>(std::vector<std::string>{filename}, DataInputDirectorContext{&monitoring, parentAccessLevel, parentFileReplacement});
+    auto didir = std::make_shared<DataInputDirector>(std::vector<std::string>{filename}, DataInputDirectorContext{&monitoring, parentAccessLevel, parentFileReplacement, originLevelMapping});
     if (options.isSet("aod-reader-json")) {
       auto jsonFile = options.get<std::string>("aod-reader-json");
       if (!didir->readJson(jsonFile)) {
diff --git a/Framework/AnalysisSupport/src/DataInputDirector.cxx b/Framework/AnalysisSupport/src/DataInputDirector.cxx
index 7027655b7abe7..46674f19400a6 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.cxx
+++ b/Framework/AnalysisSupport/src/DataInputDirector.cxx
@@ -122,7 +122,7 @@ void DataInputDescriptor::addFileNameHolder(FileNameHolder* fn)
   mfilenames.emplace_back(fn);
 }
 
-bool DataInputDescriptor::setFile(int counter, std::string_view origin)
+bool DataInputDescriptor::setFile(int counter, int wantedParentLevel, std::string_view origin)
 {
   // no files left
   if (counter >= getNumberInputfiles()) {
@@ -133,7 +133,9 @@ bool DataInputDescriptor::setFile(int counter, std::string_view origin)
   // of the filename. In the future we might expand this for proper rewriting of the
   // filename based on the origin and the original file information.
   std::string filename = mfilenames[counter]->fileName;
-  if (!origin.starts_with("AOD")) {
+  // In case we do not need to remap parent levels, the requested origin is what
+  // drives the filename.
+  if (wantedParentLevel == -1 && !origin.starts_with("AOD")) {
     filename = std::regex_replace(filename, std::regex("[.]root$"), fmt::format("_{}.root", origin));
   }
 
@@ -146,7 +148,19 @@ bool DataInputDescriptor::setFile(int counter, std::string_view origin)
     closeInputFile();
   }
 
-  mCurrentFilesystem = std::make_shared<TFileFileSystem>(TFile::Open(filename.c_str()), 50 * 1024 * 1024, mFactory);
+  TFile* tfile = nullptr;
+  bool externalFile = false;
+  for (auto& [name, f] : mContext.openFiles) {
+    if (name == filename) {
+      tfile = f;
+      externalFile = true;
+      break;
+    }
+  }
+  if (tfile == nullptr) {
+    tfile = TFile::Open(filename.c_str());
+  }
+  mCurrentFilesystem = std::make_shared<TFileFileSystem>(tfile, 50 * 1024 * 1024, mFactory, !externalFile);
   if (!mCurrentFilesystem.get()) {
     throw std::runtime_error(fmt::format("Couldn't open file \"{}\"!", filename));
   }
@@ -218,11 +232,11 @@ bool DataInputDescriptor::setFile(int counter, std::string_view origin)
   return true;
 }
 
-uint64_t DataInputDescriptor::getTimeFrameNumber(int counter, int numTF, std::string_view origin)
+uint64_t DataInputDescriptor::getTimeFrameNumber(int counter, int numTF, int wantedParentLevel, std::string_view wantedOrigin)
 {
 
   // open file
-  if (!setFile(counter, origin)) {
+  if (!setFile(counter, wantedParentLevel, wantedOrigin)) {
     return 0ul;
   }
 
@@ -234,10 +248,32 @@ uint64_t DataInputDescriptor::getTimeFrameNumber(int counter, int numTF, std::st
   return (mfilenames[counter]->listOfTimeFrameNumbers)[numTF];
 }
 
-arrow::dataset::FileSource DataInputDescriptor::getFileFolder(int counter, int numTF, std::string_view origin)
+std::pair<DataInputDescriptor*, int> DataInputDescriptor::navigateToLevel(int counter, int numTF, int wantedParentLevel, std::string_view wantedOrigin)
+{
+  if (!setFile(counter, wantedParentLevel, wantedOrigin)) {
+    return {nullptr, -1};
+  }
+  auto folderName = fmt::format("DF_{}", mfilenames[counter]->listOfTimeFrameNumbers[numTF]);
+  auto parentFile = getParentFile(counter, numTF, "", wantedParentLevel, wantedOrigin);
+  if (parentFile == nullptr) {
+    return {nullptr, -1};
+  }
+  return {parentFile, parentFile->findDFNumber(0, folderName)};
+}
+
+arrow::dataset::FileSource DataInputDescriptor::getFileFolder(int counter, int numTF, int wantedParentLevel, std::string_view wantedOrigin)
 {
+  // If mapped to a parent level deeper than current, skip directly to the right level.
+  if (wantedParentLevel != -1 && mLevel < wantedParentLevel) {
+    auto [parentFile, parentNumTF] = navigateToLevel(counter, numTF, wantedParentLevel, wantedOrigin);
+    if (parentFile == nullptr || parentNumTF == -1) {
+      return {};
+    }
+    return parentFile->getFileFolder(0, parentNumTF, wantedParentLevel, wantedOrigin);
+  }
+
   // open file
-  if (!setFile(counter, origin)) {
+  if (!setFile(counter, wantedParentLevel, wantedOrigin)) {
     return {};
   }
 
@@ -251,7 +287,7 @@ arrow::dataset::FileSource DataInputDescriptor::getFileFolder(int counter, int n
   return {fmt::format("DF_{}", mfilenames[counter]->listOfTimeFrameNumbers[numTF]), mCurrentFilesystem};
 }
 
-DataInputDescriptor* DataInputDescriptor::getParentFile(int counter, int numTF, std::string treename, std::string_view origin)
+DataInputDescriptor* DataInputDescriptor::getParentFile(int counter, int numTF, std::string treename, int wantedParentLevel, std::string_view wantedOrigin)
 {
   if (!mParentFileMap) {
     // This file has no parent map
@@ -288,7 +324,7 @@ DataInputDescriptor* DataInputDescriptor::getParentFile(int counter, int numTF,
   mParentFile->mdefaultFilenamesPtr = new std::vector<FileNameHolder*>;
   mParentFile->mdefaultFilenamesPtr->emplace_back(makeFileNameHolder(parentFileName->GetString().Data()));
   mParentFile->fillInputfiles();
-  mParentFile->setFile(0, origin);
+  mParentFile->setFile(0, wantedParentLevel, wantedOrigin);
   return mParentFile;
 }
 
@@ -450,8 +486,26 @@ struct CalculateDelta {
 bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh, int counter, int numTF, std::string treename, size_t& totalSizeCompressed, size_t& totalSizeUncompressed)
 {
   CalculateDelta t(mIOTime);
-  std::string origin = dh.dataOrigin.as<std::string>();
-  auto folder = getFileFolder(counter, numTF, origin);
+  std::string wantedOrigin = dh.dataOrigin.as<std::string>();
+  int wantedLevel = mContext.levelForOrigin(wantedOrigin);
+
+  // If this origin is mapped to a parent level deeper than current, skip directly without
+  // attempting to read from this level.
+  if (wantedLevel != -1 && mLevel < wantedLevel) {
+    auto [parentFile, parentNumTF] = navigateToLevel(counter, numTF, wantedLevel, wantedOrigin);
+    if (parentFile == nullptr) {
+      auto rootFS = std::dynamic_pointer_cast<TFileFileSystem>(mCurrentFilesystem);
+      throw std::runtime_error(fmt::format(R"(No parent file found for "{}" while looking for level {} in "{}")", treename, wantedLevel, rootFS->GetFile()->GetName()));
+    }
+    if (parentNumTF == -1) {
+      auto parentRootFS = std::dynamic_pointer_cast<TFileFileSystem>(parentFile->mCurrentFilesystem);
+      throw std::runtime_error(fmt::format(R"(DF not found in parent file "{}")", parentRootFS->GetFile()->GetName()));
+    }
+    t.deactivate();
+    return parentFile->readTree(outputs, dh, 0, parentNumTF, treename, totalSizeCompressed, totalSizeUncompressed);
+  }
+
+  auto folder = getFileFolder(counter, numTF, wantedLevel, wantedOrigin);
   if (!folder.filesystem()) {
     t.deactivate();
     return false;
@@ -484,7 +538,7 @@ bool DataInputDescriptor::readTree(DataAllocator& outputs, header::DataHeader dh
   if (!format) {
     t.deactivate();
     LOGP(debug, "Could not find tree {}. Trying in parent file.", fullpath.path());
-    auto parentFile = getParentFile(counter, numTF, treename, origin);
+    auto parentFile = getParentFile(counter, numTF, treename, wantedLevel, wantedOrigin);
     if (parentFile != nullptr) {
       int parentNumTF = parentFile->findDFNumber(0, folder.path());
       if (parentNumTF == -1) {
@@ -817,8 +871,9 @@ arrow::dataset::FileSource DataInputDirector::getFileFolder(header::DataHeader d
     didesc = mdefaultDataInputDescriptor;
   }
   std::string origin = dh.dataOrigin.as<std::string>();
+  int wantedLevel = mContext.levelForOrigin(origin);
 
-  return didesc->getFileFolder(counter, numTF, origin);
+  return didesc->getFileFolder(counter, numTF, wantedLevel, origin);
 }
 
 int DataInputDirector::getTimeFramesInFile(header::DataHeader dh, int counter)
@@ -840,8 +895,9 @@ uint64_t DataInputDirector::getTimeFrameNumber(header::DataHeader dh, int counte
     didesc = mdefaultDataInputDescriptor;
   }
   std::string origin = dh.dataOrigin.as<std::string>();
+  int wantedLevel = mContext.levelForOrigin(origin);
 
-  return didesc->getTimeFrameNumber(counter, numTF, origin);
+  return didesc->getTimeFrameNumber(counter, numTF, wantedLevel, origin);
 }
 
 bool DataInputDirector::readTree(DataAllocator& outputs, header::DataHeader dh, int counter, int numTF, size_t& totalSizeCompressed, size_t& totalSizeUncompressed)
diff --git a/Framework/AnalysisSupport/src/DataInputDirector.h b/Framework/AnalysisSupport/src/DataInputDirector.h
index 2d63a1c71ea77..18ab5c0c1382e 100644
--- a/Framework/AnalysisSupport/src/DataInputDirector.h
+++ b/Framework/AnalysisSupport/src/DataInputDirector.h
@@ -21,6 +21,7 @@
 #include <arrow/dataset/dataset.h>
 
 #include <regex>
+#include <vector>
 #include "rapidjson/fwd.h"
 
 namespace o2::monitoring
@@ -44,6 +45,20 @@ struct DataInputDirectorContext {
   o2::monitoring::Monitoring* monitoring = nullptr;
   int allowedParentLevel = 0;
   std::string parentFileReplacement = "";
+  std::vector<std::pair<std::string, int>> parentLevelToOrigin = {};
+  // Optional registry of pre-opened TFiles (keyed by name) used to bypass
+  // TFile::Open for testing with in-memory TMemFile instances.
+  std::vector<std::pair<std::string, TFile*>> openFiles = {};
+
+  int levelForOrigin(std::string_view origin) const
+  {
+    for (auto& [o, level] : parentLevelToOrigin) {
+      if (o == origin) {
+        return level;
+      }
+    }
+    return -1;
+  }
 };
 
 class DataInputDescriptor
@@ -71,7 +86,7 @@ class DataInputDescriptor
 
   void addFileNameHolder(FileNameHolder* fn);
   int fillInputfiles();
-  bool setFile(int counter, std::string_view origin);
+  bool setFile(int counter, int wantedParentLevel, std::string_view wantedOrigin);
 
   // getters
   std::string getInputfilesFilename();
@@ -81,9 +96,12 @@ class DataInputDescriptor
   int getNumberTimeFrames() { return mtotalNumberTimeFrames; }
   int findDFNumber(int file, std::string dfName);
 
-  uint64_t getTimeFrameNumber(int counter, int numTF, std::string_view origin);
-  arrow::dataset::FileSource getFileFolder(int counter, int numTF, std::string_view origin);
-  DataInputDescriptor* getParentFile(int counter, int numTF, std::string treename, std::string_view origin);
+  uint64_t getTimeFrameNumber(int counter, int numTF, int wantedParentLevel, std::string_view wantedOrigin);
+  arrow::dataset::FileSource getFileFolder(int counter, int numTF, int wantedParentLevel, std::string_view wantedOrigin);
+  // Open the current file to populate the parent map, then return the parent descriptor and
+  // the TF index within it that corresponds to numTF at this level. Returns {nullptr, -1} on failure.
+  std::pair<DataInputDescriptor*, int> navigateToLevel(int counter, int numTF, int wantedParentLevel, std::string_view wantedOrigin);
+  DataInputDescriptor* getParentFile(int counter, int numTF, std::string treename, int wantedParentLevel, std::string_view wantedOrigin);
   int getTimeFramesInFile(int counter);
   int getReadTimeFramesInFile(int counter);
 
diff --git a/Framework/AnalysisSupport/test/test_NavigateToLevel.cxx b/Framework/AnalysisSupport/test/test_NavigateToLevel.cxx
new file mode 100644
index 0000000000000..0072ee3b67d37
--- /dev/null
+++ b/Framework/AnalysisSupport/test/test_NavigateToLevel.cxx
@@ -0,0 +1,135 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <catch_amalgamated.hpp>
+
+#include "../src/DataInputDirector.h"
+
+#include <TFile.h>
+#include <TMap.h>
+#include <TMemFile.h>
+#include <TObjString.h>
+
+using namespace o2::framework;
+
+// Tests for DataInputDirectorContext::levelForOrigin
+
+TEST_CASE("levelForOrigin empty mapping")
+{
+  DataInputDirectorContext ctx;
+  CHECK(ctx.levelForOrigin("AOD") == -1);
+  CHECK(ctx.levelForOrigin("DYN") == -1);
+}
+
+TEST_CASE("levelForOrigin single entry")
+{
+  DataInputDirectorContext ctx;
+  ctx.parentLevelToOrigin = {{"DYN", 1}};
+  CHECK(ctx.levelForOrigin("DYN") == 1);
+  CHECK(ctx.levelForOrigin("AOD") == -1);
+}
+
+TEST_CASE("levelForOrigin multiple entries")
+{
+  DataInputDirectorContext ctx;
+  ctx.parentLevelToOrigin = {{"DYN", 1}, {"EMB", 2}, {"EXT", 1}};
+  CHECK(ctx.levelForOrigin("DYN") == 1);
+  CHECK(ctx.levelForOrigin("EMB") == 2);
+  CHECK(ctx.levelForOrigin("EXT") == 1);
+  CHECK(ctx.levelForOrigin("AOD") == -1);
+  CHECK(ctx.levelForOrigin("") == -1);
+}
+
+// Tests for DataInputDescriptor::navigateToLevel
+
+TEST_CASE("navigateToLevel returns null with no input files")
+{
+  // With no input files setFile fails immediately → {nullptr, -1}
+  DataInputDirectorContext ctx;
+  ctx.allowedParentLevel = 2;
+  DataInputDescriptor desc(false, 0, ctx);
+
+  auto [parentFile, parentNumTF] = desc.navigateToLevel(0, 0, 1, "DYN");
+  CHECK(parentFile == nullptr);
+  CHECK(parentNumTF == -1);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers: build an AO2D-shaped TMemFile with one DF directory.
+// The AO2D format uses top-level TDirectory entries named DF_<id>.
+// An optional "parentFiles" TMap maps each DF name to its parent file path.
+// ---------------------------------------------------------------------------
+
+static TMemFile* makeAODFile(const char* name)
+{
+  auto* f = new TMemFile(name, "RECREATE");
+  f->mkdir("DF_1");
+  f->Write();
+  return f;
+}
+
+static TMemFile* makeAODFileWithParent(const char* name, const char* parentName)
+{
+  auto* f = new TMemFile(name, "RECREATE");
+  f->mkdir("DF_1");
+  auto* parentMap = new TMap();
+  parentMap->Add(new TObjString("DF_1"), new TObjString(parentName));
+  parentMap->Write("parentFiles", TObject::kSingleKey);
+  f->Write();
+  return f;
+}
+
+TEST_CASE("navigateToLevel finds parent TMemFile")
+{
+  // child.root  DF_1  parentFiles: {DF_1 -> parent.root}
+  // parent.root DF_1
+  auto* parentMF = makeAODFile("parent.root");
+  auto* childMF = makeAODFileWithParent("child.root", "parent.root");
+
+  DataInputDirectorContext ctx;
+  ctx.allowedParentLevel = 2;
+  ctx.openFiles = {{"child.root", childMF}, {"parent.root", parentMF}};
+
+  DataInputDescriptor desc(false, 0, ctx);
+  desc.addFileNameHolder(makeFileNameHolder("child.root"));
+
+  auto [parentDesc, parentNumTF] = desc.navigateToLevel(0, 0, 1, "AOD");
+
+  REQUIRE(parentDesc != nullptr);
+  // DF_1 is the only timeframe in the parent, so its index is 0
+  CHECK(parentNumTF == 0);
+}
+
+TEST_CASE("navigateToLevel returns -1 for missing DF in parent")
+{
+  // child has DF_2 but parent only has DF_1 — findDFNumber returns -1
+  auto* parentMF = makeAODFile("parent2.root");
+
+  auto* childMF = new TMemFile("child2.root", "RECREATE");
+  childMF->mkdir("DF_2");
+  auto* parentMap = new TMap();
+  parentMap->Add(new TObjString("DF_2"), new TObjString("parent2.root"));
+  parentMap->Write("parentFiles", TObject::kSingleKey);
+  childMF->Write();
+
+  DataInputDirectorContext ctx;
+  ctx.allowedParentLevel = 2;
+  ctx.openFiles = {{"child2.root", childMF}, {"parent2.root", parentMF}};
+
+  DataInputDescriptor desc(false, 0, ctx);
+  desc.addFileNameHolder(makeFileNameHolder("child2.root"));
+
+  auto [parentDesc, parentNumTF] = desc.navigateToLevel(0, 0, 1, "AOD");
+
+  // Parent has DF_1 but child references DF_2 — not found in parent
+  REQUIRE(parentDesc != nullptr);
+  CHECK(parentNumTF == -1);
+}
diff --git a/Framework/Core/src/Plugin.cxx b/Framework/Core/src/Plugin.cxx
index 8ed683d501906..503133442e794 100644
--- a/Framework/Core/src/Plugin.cxx
+++ b/Framework/Core/src/Plugin.cxx
@@ -168,6 +168,9 @@ struct DiscoverAODOptionsInCommandLine : o2::framework::ConfigDiscoveryPlugin {
           if (key == "aod-parent-access-level") {
             results.push_back(ConfigParamSpec{"aod-parent-access-level", VariantType::String, value, {"Allow parent file access up to specified level. Default: no (0)"}});
           }
+          if (key == "aod-origin-level-mapping") {
+            results.push_back(ConfigParamSpec{"aod-origin-level-mapping", VariantType::String, value, {"Map origin to parent level for AOD reading. Syntax: ORIGIN:LEVEL[,ORIGIN2:LEVEL2,...]. E.g. \"DYN:1\"."}});
+          }
         }
         if (injectOption) {
           results.push_back(ConfigParamSpec{"aod-writer-compression", VariantType::Int, 505, {"AOD Compression options"}});

From a43e1f5d685d271c33426741a87a3e792e091d82 Mon Sep 17 00:00:00 2001
From: rmunzer <97919772+rmunzer@users.noreply.github.com>
Date: Thu, 30 Apr 2026 16:20:31 +0200
Subject: [PATCH 1679/1764] TPC: Add CMV processing  (#15283)

* Add CMV processing

* Add parameters for CMV

* Add o2-tpc-cmv-aggragate-task

* Cleanup and change of parameters names

* Correct white spaces

* Remove white space

* Change Parameter name

* Fix bug for paramter definition

* Change default paramters

* Reduce lanesCMVaggregate to 8

* don't add ccdb-populator if not needed for IDC calib collection; refactor adding of IDC workflows

---------

Co-authored-by: Ernst Hellbar <ernst.hellbar@cern.ch>
---
 .../full-system-test/aggregator-workflow.sh   | 27 ++++++++++++++-----
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/prodtests/full-system-test/aggregator-workflow.sh b/prodtests/full-system-test/aggregator-workflow.sh
index a0d091a98d193..0dc30df93669d 100755
--- a/prodtests/full-system-test/aggregator-workflow.sh
+++ b/prodtests/full-system-test/aggregator-workflow.sh
@@ -161,7 +161,7 @@ if workflow_has_parameter CALIB_PROXIES; then
     fi
     CHANNELS_LIST=
     [[ $EPNSYNCMODE == 0 ]] && FLP_ADDRESS="tcp://localhost:29950"
-    if [[ -n ${CALIBDATASPEC_TPCIDC_A:-} ]] || [[ -n ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
+    if [[ -n ${CALIBDATASPEC_TPCIDC_A:-} ]] || [[ -n ${CALIBDATASPEC_TPCIDC_C:-} ]] || [[ -n ${CALIBDATASPEC_TPCCMV:-} ]]; then
       # define port for FLP
       : ${TPC_IDC_FLP_PORT:=29950}
       # expand FLPs; TPC uses from 001 to 145, but 145 is reserved for SAC
@@ -190,10 +190,16 @@ if workflow_has_parameter CALIB_PROXIES; then
       if [[ -n ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
         add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCIDC_C\""
       fi
+      if [[ -n ${CALIBDATASPEC_TPCCMV:-} ]]; then
+        add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCCMV\""
+      fi
       if [[ -n ${CALIBDATASPEC_TPCSAC:-} ]]; then
         add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCSAC\""
       fi
-      add_W o2-dpl-raw-proxy "--proxy-name tpcidc --io-threads 2 --dataspec \"$DATASPEC_LIST\" --sporadic-outputs --channel-config \"$CHANNELS_LIST\" ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} $TIMEFRAME_SHM_LIMIT" "" 0
+      if [[ -z ${O2_TPC_IDC_CMV_IO_THREADS:-} ]]; then
+        O2_TPC_IDC_CMV_IO_THREADS=4;
+    fi
+     add_W o2-dpl-raw-proxy "--proxy-name tpcidc --io-threads ${O2_TPC_IDC_CMV_IO_THREADS} --dataspec \"$DATASPEC_LIST\" --sporadic-outputs --channel-config \"$CHANNELS_LIST\" ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} $TIMEFRAME_SHM_LIMIT" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == CALO_TF ]]; then
     if [[ -n ${CALIBDATASPEC_CALO_TF:-} ]]; then
@@ -301,6 +307,8 @@ threadFactorize=${O2_TPC_IDC_FACTORIZE_NTHREADS:-16}
 nTFs=$((1000 * 128 / ${NHBPERTF}))
 nTFs_SAC=$((10000 * 128 / ${NHBPERTF}))
 nBuffer=$((100 * 128 / ${NHBPERTF}))
+nBuffer_cmv=$((50 * 128 / ${NHBPERTF}))
+lanesCMVaggregate=${O2_TPC_CMV_AGGREGATE_NLANES:-8}
 IDC_DELTA="--disable-IDCDelta true" # off by default
 # deltas are on by default; you need to request explicitly to switch them off;
 if [[ "${DISABLE_IDC_DELTA:-}" == "1" ]]; then IDC_DELTA=""; fi
@@ -308,17 +316,24 @@ if [[ "${ENABLE_IDC_DELTA_FILE:-}" == "1" ]]; then IDC_DELTA+=" --dump-IDCDelta-
 
 if [[ "${DISABLE_IDC_PAD_MAP_WRITING:-}" == 1 ]]; then TPC_WRITING_PAD_STATUS_MAP=""; else TPC_WRITING_PAD_STATUS_MAP="--enableWritingPadStatusMap true"; fi
 
-if ! workflow_has_parameter CALIB_LOCAL_INTEGRATED_AGGREGATOR; then
-  if [[ $CALIB_TPC_IDC == 1 ]] && [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC || $AGGREGATOR_TASKS == ALL ]]; then
-    add_W o2-tpc-idc-distribute "--crus ${crus} --timeframes ${nTFs} --output-lanes ${lanesFactorize} --send-precise-timestamp true --condition-tf-per-query ${nTFs} --n-TFs-buffer ${nBuffer}"
+if ! workflow_has_parameter CALIB_LOCAL_INTEGRATED_AGGREGATOR && [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC || $AGGREGATOR_TASKS == ALL ]]; then
+  if [[ $CALIB_TPC_IDC == 1 ]]; then
+    add_W o2-tpc-idc-distribute "--crus ${crus} --timeframes ${nTFs} --output-lanes ${lanesFactorize} --send-precise-timestamp true --condition-tf-per-query ${nTFs}  --n-TFs-buffer ${nBuffer}"
     add_W o2-tpc-idc-factorize "--n-TFs-buffer ${nBuffer} --input-lanes ${lanesFactorize} --crus ${crus} --timeframes ${nTFs} --nthreads-grouping ${threadFactorize} --nthreads-IDC-factorization ${threadFactorize} --sendOutputFFT true --enable-CCDB-output true --enablePadStatusMap true ${TPC_WRITING_PAD_STATUS_MAP} --use-precise-timestamp true $IDC_DELTA" "TPCIDCGroupParam.groupPadsSectorEdges=32211"
     add_W o2-tpc-idc-ft-aggregator "--rangeIDC 200 --inputLanes ${lanesFactorize} --nFourierCoeff 40 --nthreads 8"
   fi
-  if [[ $CALIB_TPC_SAC == 1 ]] && [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC || $AGGREGATOR_TASKS == ALL ]]; then
+  if [[ $CALIB_TPC_CMV == 1 ]]; then
+    if [[ -z ${O2_TPC_CMV_COMPRESSION:-} ]]; then O2_TPC_CMV_COMPRESSION="--use-sparse --cmv-zero-threshold 1.0 --cmv-dynamic-precision-mean 1.0 --cmv-dynamic-precision-sigma 8.0 --use-compression-huffman"; fi
+    if [[ -z ${O2_TPC_CMV_TIMEFRAMES:-} ]]; then O2_TPC_CMV_TIMEFRAMES="2000"; fi
+    add_W o2-tpc-cmv-distribute "--crus ${crus} --lanes 1 --output-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --timeframes ${O2_TPC_CMV_TIMEFRAMES} --send-precise-timestamp "
+    add_W o2-tpc-cmv-aggregate "--crus ${crus} --input-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --nthreads-compression 4 --timeframes ${O2_TPC_CMV_TIMEFRAMES} --use-precise-timestamp  ${O2_TPC_CMV_COMPRESSION} --output-dir $CALIB_DIR --meta-output-dir $EPN2EOS_METAFILES_DIR "
+  fi
+  if [[ $CALIB_TPC_SAC == 1 ]]; then
     add_W o2-tpc-sac-distribute "--timeframes ${nTFs_SAC} --output-lanes 1 "
     add_W o2-tpc-sac-factorize "--timeframes ${nTFs_SAC} --nthreads-SAC-factorization 4 --input-lanes 1 --compression 2"
     add_W o2-tpc-idc-ft-aggregator "--rangeIDC 200 --nFourierCoeff 40 --process-SACs true --inputLanes 1"
   fi
+  [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC ]] && [[ $CALIB_TPC_IDC == 0 && $CALIB_TPC_SAC == 0 && $CALIB_TPC_CMV == 1 ]] && CCDB_POPULATOR_UPLOAD_PATH="none"
 fi
 
 # Calo cal

From b4a57b23e6c6059210b7dba477c541adc72c91c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tuba=20G=C3=BCndem?=
 <48834043+tubagundem@users.noreply.github.com>
Date: Thu, 30 Apr 2026 17:14:32 +0200
Subject: [PATCH 1680/1764] TPC_CMV: Fix handling of buffered TFs, refactor
 tpc-cmv-distribute and create tpc-cmv-aggregate (#15308)

* Fix handling of n-TFs-buffer in tpc-distribute-cmv workflow

* Refactor cmv distribute workflow, create cmv aggregate workflow

* Renamed nthreads to nthreads-compression

* Fix CMV handling for empty and stale TF batches, handle empty Huffman symbol streams in CMVContainer

* Add meta-output-dir to aggregate workflow

* Fix return statement

* Preserve DPL orbit in CMV TFs when FLP orbit is missing
---
 .../include/TPCCalibration/CMVContainer.h     |  14 +-
 Detectors/TPC/calibration/macro/drawCMV.C     |  16 +-
 .../TPC/calibration/src/CMVContainer.cxx      |  13 +-
 Detectors/TPC/workflow/CMakeLists.txt         |   7 +-
 Detectors/TPC/workflow/README.md              |  43 +-
 .../include/TPCWorkflow/TPCAggregateCMVSpec.h | 720 ++++++++++++++++++
 .../TPCWorkflow/TPCDistributeCMVSpec.h        | 517 +++++--------
 .../TPC/workflow/src/tpc-aggregate-cmv.cxx    |  86 +++
 .../TPC/workflow/src/tpc-distribute-cmv.cxx   |  21 +-
 9 files changed, 1070 insertions(+), 367 deletions(-)
 create mode 100644 Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h
 create mode 100644 Detectors/TPC/workflow/src/tpc-aggregate-cmv.cxx

diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h b/Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h
index f1904c3db8f8d..6f69a928d29ec 100644
--- a/Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CMVContainer.h
@@ -58,9 +58,9 @@ struct CMVEncoding {
 ///       kZigzag + kVarint  → varint(zigzag(signed(raw)))
 ///       kZigzag + kHuffman → [Huffman table] + [bitstream] of zigzag(signed(raw))
 struct CMVPerTFCompressed {
-  uint32_t firstOrbit{0}; ///< First orbit of this TF
-  uint16_t firstBC{0};    ///< First bunch crossing of this TF
-  uint8_t mFlags{0};      ///< Bitmask of CMVEncoding values
+  uint32_t firstOrbit{0};    ///< First orbit of this TF
+  uint32_t firstOrbitDPL{0}; ///< First orbit of this TF
+  uint8_t mFlags{0};         ///< Bitmask of CMVEncoding values
 
   std::vector<uint8_t> mData; ///< Encoded payload
 
@@ -88,14 +88,14 @@ struct CMVPerTFCompressed {
   static void decodeDenseValues(const std::vector<uint32_t>& symbols, uint8_t flags, CMVPerTF* cmv);
 
  public:
-  ClassDefNV(CMVPerTFCompressed, 1)
+  ClassDefNV(CMVPerTFCompressed, 2)
 };
 
 /// CMV data for one TF across all CRUs
 /// Raw 16-bit CMV values are stored in a flat C array indexed as [cru * NTimeBinsPerTF + timeBin]
 struct CMVPerTF {
-  uint32_t firstOrbit{0}; ///< First orbit of this TF, from heartbeatOrbit of the first CMV packet
-  uint16_t firstBC{0};    ///< First bunch crossing of this TF, from heartbeatBC of the first CMV packet
+  uint32_t firstOrbit{0};    ///< First orbit of this TF, from heartbeatOrbit of the first CMV packet
+  uint32_t firstOrbitDPL{0}; ///< First orbit of this TF, from DPL
 
   // Raw 16-bit CMV values, flat array indexed as [cru * NTimeBinsPerTF + timeBin]
   uint16_t mDataPerTF[CRU::MaxCRU * cmv::NTimeBinsPerTF]{};
@@ -133,7 +133,7 @@ struct CMVPerTF {
   static void encodeVarintInto(uint32_t value, std::vector<uint8_t>& out);                               ///< Varint encode
 
  public:
-  ClassDefNV(CMVPerTF, 1)
+  ClassDefNV(CMVPerTF, 2)
 };
 
 } // namespace o2::tpc
diff --git a/Detectors/TPC/calibration/macro/drawCMV.C b/Detectors/TPC/calibration/macro/drawCMV.C
index 8a89157b75721..4f74db16cecd6 100644
--- a/Detectors/TPC/calibration/macro/drawCMV.C
+++ b/Detectors/TPC/calibration/macro/drawCMV.C
@@ -32,7 +32,7 @@ using namespace o2::tpc;
 /// \param filename  input ROOT file containing the ccdb_object TTree
 /// \param outDir    output directory for saved plots; nothing is saved if empty
 /// \return          array of canvases
-TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
+TObjArray* drawCMV(std::string_view filename, std::string_view outDir, std::string_view rootFileName = "CMVCanvases.root")
 {
   TObjArray* arrCanvases = new TObjArray;
   arrCanvases->SetName("CMV");
@@ -82,7 +82,7 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
                        110, -100.5, 9.5);
   h2d->SetStats(1);
   TH1F* h1d = new TH1F("hCMV", ";Common Mode Values (ADC);Counts",
-                       1100, -100.5, 9.5);
+                       110, -100.5, 9.5);
   h1d->SetStats(1);
 
   // auto-detect branch format: compressed or raw
@@ -105,6 +105,7 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
   }
 
   long firstOrbit = -1;
+  long firstOrbitDPL = -1;
 
   for (int i = 0; i < nEntries; ++i) {
     tree->GetEntry(i);
@@ -118,16 +119,15 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
       tf = tfRaw;
     }
 
-    if (i == 0) {
-      firstOrbit = tf->firstOrbit;
-    }
+    firstOrbit = tf->firstOrbit;
+    firstOrbitDPL = tf->firstOrbitDPL;
+    fmt::print("firstOrbit: {}, firstOrbitDPL: {}\n", firstOrbit, firstOrbitDPL);
 
     for (int cru = 0; cru < nCRUs; ++cru) {
       for (int tb = 0; tb < nTimeBins; ++tb) {
         const float cmvValue = tf->getCMVFloat(cru, tb);
         h2d->Fill(tb, cmvValue);
         h1d->Fill(cmvValue);
-        // fmt::print("cru: {}, tb: {}, cmv: {}\n", cru, tb, cmvValue);
       }
     }
   }
@@ -136,8 +136,6 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
   tree->ResetBranchAddresses();
   delete tfCompressed;
 
-  fmt::print("firstOrbit: {}\n", firstOrbit);
-
   // draw
   auto* c = new TCanvas("cCMVvsTimeBin", "");
   c->SetLogz();
@@ -152,7 +150,7 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir)
   arrCanvases->Add(c1);
 
   if (outDir.size()) {
-    utils::saveCanvases(*arrCanvases, outDir, "png,pdf", "CMVCanvases.root");
+    utils::saveCanvases(*arrCanvases, outDir, "", rootFileName);
   }
 
   f.Close();
diff --git a/Detectors/TPC/calibration/src/CMVContainer.cxx b/Detectors/TPC/calibration/src/CMVContainer.cxx
index 5a3b8f1c63c3a..0e02d32e754d5 100644
--- a/Detectors/TPC/calibration/src/CMVContainer.cxx
+++ b/Detectors/TPC/calibration/src/CMVContainer.cxx
@@ -124,6 +124,15 @@ uint32_t decodeVarintLocal(const uint8_t*& data, const uint8_t* end)
 ///   ceil(totalBits/8) bytes: MSB-first bitstream
 void huffmanEncode(const std::vector<uint32_t>& symbols, std::vector<uint8_t>& buf)
 {
+  if (symbols.empty()) {
+    // Write a valid empty Huffman stream: numSymbols=0, totalBits=0.
+    // The decoder handles this correctly (returns an empty symbol vector).
+    for (int i = 0; i < 12; ++i) {
+      buf.push_back(0);
+    }
+    return;
+  }
+
   // Frequency count
   std::map<uint32_t, uint64_t> freq;
   for (const uint32_t z : symbols) {
@@ -438,7 +447,7 @@ CMVPerTFCompressed CMVPerTF::compress(uint8_t flags) const
 {
   CMVPerTFCompressed out;
   out.firstOrbit = firstOrbit;
-  out.firstBC = firstBC;
+  out.firstOrbitDPL = firstOrbitDPL;
   out.mFlags = flags;
 
   if (flags & CMVEncoding::kSparse) {
@@ -661,7 +670,7 @@ void CMVPerTFCompressed::decompress(CMVPerTF* cmv) const
     throw std::invalid_argument("CMVPerTFCompressed::decompress: cmv pointer is null");
   }
   cmv->firstOrbit = firstOrbit;
-  cmv->firstBC = firstBC;
+  cmv->firstOrbitDPL = firstOrbitDPL;
   std::fill(std::begin(cmv->mDataPerTF), std::end(cmv->mDataPerTF), uint16_t(0));
 
   const uint8_t* ptr = mData.data();
diff --git a/Detectors/TPC/workflow/CMakeLists.txt b/Detectors/TPC/workflow/CMakeLists.txt
index 0f8d73b1cbe7e..37ac398db40ec 100644
--- a/Detectors/TPC/workflow/CMakeLists.txt
+++ b/Detectors/TPC/workflow/CMakeLists.txt
@@ -304,4 +304,9 @@ o2_add_executable(cmv-distribute
                   SOURCES src/tpc-distribute-cmv.cxx
                   PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
 
-add_subdirectory(readers)
\ No newline at end of file
+o2_add_executable(cmv-aggregate
+                  COMPONENT_NAME tpc
+                  SOURCES src/tpc-aggregate-cmv.cxx
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+
+add_subdirectory(readers)
diff --git a/Detectors/TPC/workflow/README.md b/Detectors/TPC/workflow/README.md
index b7a19da121e9b..5d2ccd3ac9166 100644
--- a/Detectors/TPC/workflow/README.md
+++ b/Detectors/TPC/workflow/README.md
@@ -285,7 +285,8 @@ The CMV workflows parse raw TPC data, buffer Common Mode Values per CRU on FLPs,
 |---|---|---|
 | `o2-tpc-cmv-to-vector` | `TPC/CMVVECTOR` | Parses raw TPC data and creates vectors of CMVs per CRU |
 | `o2-tpc-cmv-flp` | `TPC/CMVGROUP` | Buffers N TFs per CRU on the FLP and groups them for forwarding |
-| `o2-tpc-cmv-distribute` | TTree / CCDB payload | Merges CRUs over N TFs on the calibration node, serializes the CMVContainer into a TTree, and either writes it to disk (`--dump-cmvs`) or forwards it as a CCDB object (`--enable-CCDB-output`) |
+| `o2-tpc-cmv-distribute` | `TPC/CMVAGG*` | Routes grouped CMV batches from the calibration node to the aggregate workflow while preserving buffered TF and lane handling |
+| `o2-tpc-cmv-aggregate` | TTree / CCDB payload | Collects all CRUs for each aggregate lane, preprocesses and compresses CMVs per buffered TF slice, then writes the CMVContainer TTree to disk (`--output-dir`) and/or forwards it as a CCDB object (`--enable-CCDB-output`) |
 
 #### `o2-tpc-cmv-to-vector`
 
@@ -319,10 +320,27 @@ The CMV workflows parse raw TPC data, buffer Common Mode Values per CRU on FLPs,
 | `--timeframes` | 2000 | Number of TFs aggregated per calibration interval |
 | `--firstTF` | -1 | First time frame index; -1 = auto-detect from first incoming TF; values < -1 set an offset of `\|firstTF\|+1` TFs before the first interval begins |
 | `--lanes` | 1 | Number of parallel lanes (CRUs are split evenly across lanes) |
+| `--output-lanes` | 1 | Number of aggregate pipelines downstream; these lanes rotate whole CMV aggregation intervals, not CRU subsets |
 | `--n-TFs-buffer` | 1 | Number of TFs buffered per group in the upstream `o2-tpc-cmv-flp` (must match that workflow's setting) |
+| `--send-precise-timestamp` | false | Forward orbit-reset timing information needed by the aggregate workflow for precise CCDB validity timestamps |
+| `--drop-data-after-nTFs` | 0 | Drop data for a relative TF slot after this many TFs have passed without receiving all CRUs; 0 uses the default derived from `--check-data-every-n` |
+| `--check-data-every-n` | 0 | Check for missing CRU data every N invocations of the run function; -1 disables checking, 0 uses the default (timeframes/2) |
+| `--nFactorTFs` | 1000 | Number of TFs to skip before flushing the oldest incomplete aggregation interval |
+
+#### `o2-tpc-cmv-aggregate`
+
+> **Important:** `--n-TFs-buffer` must be set to the same value as in `o2-tpc-cmv-distribute` and `o2-tpc-cmv-flp`. Mismatched values will silently corrupt the relTF mapping and TTree entry count.
+
+| Option | Default | Description |
+|---|---|---|
+| `--crus` | `0-359` | Full CRU range expected for each aggregate interval |
+| `--timeframes` | 2000 | Number of TFs aggregated per calibration interval |
+| `--input-lanes` | 1 | Number of aggregate pipelines; must match `o2-tpc-cmv-distribute --output-lanes` |
+| `--n-TFs-buffer` | 1 | Number of real TFs packed into one CMV batch from upstream; **must match** `o2-tpc-cmv-distribute --n-TFs-buffer` |
 | `--enable-CCDB-output` | false | Forward the CMVContainer TTree as a CCDB object to `o2-calibration-ccdb-populator-workflow` |
-| `--use-precise-timestamp` | false | Fetch orbit-reset and GRPECS from CCDB to compute a precise CCDB validity timestamp |
-| `--dump-cmvs` | false | Write the CMVContainer TTree to a local ROOT file on disk |
+| `--use-precise-timestamp` | false | Use orbit-reset timing forwarded by the distribute lane (requires `o2-tpc-cmv-distribute --send-precise-timestamp`) for precise CCDB validity start timestamps |
+| `--output-dir` | `none` | Output directory for writing the CMVContainer ROOT file; must exist |
+| `--nthreads` | 1 | Number of threads used for CMV preprocessing and compression; each thread processes a contiguous slice of buffered TFs |
 | `--use-sparse` | false | Sparse encoding: skip zero time bins (raw uint16 values; combine with `--use-compression-varint` or `--use-compression-huffman` for compressed sparse output) |
 | `--use-compression-varint` | false | Delta + zigzag + varint compression over all values; combined with `--use-sparse`: varint-encoded exact values at non-zero positions |
 | `--use-compression-huffman` | false | Huffman encoding over all values; combined with `--use-sparse`: Huffman-encoded exact values at non-zero positions |
@@ -330,9 +348,6 @@ The CMV workflows parse raw TPC data, buffer Common Mode Values per CRU on FLPs,
 | `--cmv-round-integers-threshold` | 0 | Round values to nearest integer ADC for \|v\| ≤ N ADC before compression; 0 disables |
 | `--cmv-dynamic-precision-mean` | 1.0 | Gaussian centre in \|CMV\| (ADC) where the strongest fractional-bit trimming is applied |
 | `--cmv-dynamic-precision-sigma` | 0 | Gaussian width (ADC) for smooth CMV fractional-bit trimming; 0 disables |
-| `--drop-data-after-nTFs` | 0 | Drop data for a relative TF slot after this many TFs have passed without receiving all CRUs; 0 uses the default derived from `--check-data-every-n` |
-| `--check-data-every-n` | 0 | Check for missing CRU data every N invocations of the run function; -1 disables checking, 0 uses the default (timeframes/2) |
-| `--nFactorTFs` | 1000 | Number of TFs to skip before flushing the oldest incomplete aggregation interval |
 
 ### Example 1 — Simple usage for testing
 
@@ -361,7 +376,12 @@ o2-tpc-cmv-flp $ARGS_ALL \
   --crus ${CRUS} |
 o2-tpc-cmv-distribute $ARGS_ALL \
   --crus ${CRUS} \
-  --dump-cmvs \
+  --output-lanes 1 \
+  --send-precise-timestamp \
+|
+o2-tpc-cmv-aggregate $ARGS_ALL \
+  --crus ${CRUS} \
+  --output-dir ./ \
   --enable-CCDB-output \
   --cmv-zero-threshold 1.0 \
   --cmv-dynamic-precision-mean 1.0 \
@@ -450,7 +470,12 @@ o2-dpl-raw-proxy $ARGS_ALL \
   --dataspec "A:TPC/CMVGROUP;A:TPC/CMVORBITINFO" |
 o2-tpc-cmv-distribute $ARGS_ALL \
   --crus ${CRUS} \
-  --dump-cmvs \
+  --output-lanes 1 \
+  --send-precise-timestamp \
+|
+o2-tpc-cmv-aggregate $ARGS_ALL \
+  --crus ${CRUS} \
+  --output-dir ./ \
   --enable-CCDB-output \
   --cmv-zero-threshold 1.0 \
   --cmv-dynamic-precision-mean 1.0 \
@@ -461,4 +486,4 @@ o2-calibration-ccdb-populator-workflow $ARGS_ALL \
   --ccdb-path ccdb-test.cern.ch:8080
 ```
 
-The aggregator binds the ZeroMQ pull socket and waits for all FLPs to connect. Once `TPC/CMVGROUP` and `TPC/CMVORBITINFO` data arrive, `o2-tpc-cmv-distribute` merges them, applies compression, writes the object to the disk and uploads to the CCDB.
+The aggregator binds the ZeroMQ pull socket and waits for all FLPs to connect. Once `TPC/CMVGROUP` and `TPC/CMVORBITINFO` data arrive, `o2-tpc-cmv-distribute` routes the grouped CMV batches, and `o2-tpc-cmv-aggregate` gathers the full CRU set for each interval, applies preprocessing and compression, writes the object to disk, and uploads it to the CCDB.
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h
new file mode 100644
index 0000000000000..b46f2169f06c9
--- /dev/null
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h
@@ -0,0 +1,720 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   TPCAggregateCMVSpec.h
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  TPC aggregation of distributed CMVs, including preprocessing, compression and CCDB output
+
+#ifndef O2_TPCAGGREGATECMVSPEC_H
+#define O2_TPCAGGREGATECMVSPEC_H
+
+#include <algorithm>
+#include <chrono>
+#include <limits>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+#include <fmt/format.h>
+#include <filesystem>
+#include <fstream>
+#include "TMemFile.h"
+#include "TParameter.h"
+#include "Framework/Task.h"
+#include "Framework/ControlService.h"
+#include "Framework/Logger.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/InputRecordWalker.h"
+#include "Framework/DataTakingContext.h"
+#include "Framework/DataRefUtils.h"
+#include "Headers/DataHeader.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "CommonDataFormat/Pair.h"
+#include "CCDB/CcdbApi.h"
+#include "CCDB/CcdbObjectInfo.h"
+#include "DetectorsCalibration/Utils.h"
+#include "TPCWorkflow/TPCDistributeCMVSpec.h"
+#include "TPCWorkflow/ProcessingHelpers.h"
+#include "TPCCalibration/CMVContainer.h"
+#include "DataFormatsTPC/CMV.h"
+#include "DetectorsBase/GRPGeomHelper.h"
+#include "MemoryResources/MemoryResources.h"
+#include "CommonUtils/StringUtils.h"
+#include "DetectorsCommonDataFormats/FileMetaData.h"
+
+using namespace o2::framework;
+using o2::header::gDataOriginTPC;
+
+namespace o2::tpc
+{
+
+class TPCAggregateCMVDevice : public o2::framework::Task
+{
+ public:
+  TPCAggregateCMVDevice(const int lane,
+                        const std::vector<uint32_t>& crus,
+                        const unsigned int timeframes,
+                        const bool sendCCDB,
+                        const bool usePreciseTimestamp,
+                        const int nTFsBuffer,
+                        std::shared_ptr<o2::base::GRPGeomRequest> req)
+    : mLaneId{lane},
+      mCRUs{crus},
+      mTimeFrames{timeframes},
+      mSendCCDB{sendCCDB},
+      mUsePreciseTimestamp{usePreciseTimestamp},
+      mNTFsBuffer{nTFsBuffer},
+      mProcessedCRU(timeframes),
+      mProcessedCRUs(timeframes),
+      mRawCMVs(timeframes),
+      mOrbitInfo(timeframes),
+      mOrbitStep(timeframes),
+      mOrbitInfoSeen(timeframes, false),
+      mTFCompleted(timeframes, false),
+      mCCDBRequest(req)
+  {
+    std::sort(mCRUs.begin(), mCRUs.end());
+    for (auto& crusMap : mProcessedCRUs) {
+      crusMap.reserve(mCRUs.size());
+      for (const auto cruID : mCRUs) {
+        crusMap.emplace(cruID, false);
+      }
+    }
+    initIntervalTree();
+  }
+
+  void init(o2::framework::InitContext& ic) final
+  {
+    o2::base::GRPGeomHelper::instance().setRequest(mCCDBRequest);
+    mOutputDir = ic.options().get<std::string>("output-dir");
+    if (mOutputDir != "/dev/null") {
+      mOutputDir = o2::utils::Str::rectifyDirectory(mOutputDir);
+    }
+    mMetaFileDir = ic.options().get<std::string>("meta-output-dir");
+    if (mMetaFileDir != "/dev/null") {
+      mMetaFileDir = o2::utils::Str::rectifyDirectory(mMetaFileDir);
+    }
+    mUseCompressionVarint = ic.options().get<bool>("use-compression-varint");
+    mUseSparse = ic.options().get<bool>("use-sparse");
+    mUseCompressionHuffman = ic.options().get<bool>("use-compression-huffman");
+    mRoundIntegersThreshold = static_cast<uint16_t>(ic.options().get<int>("cmv-round-integers-threshold"));
+    mZeroThreshold = ic.options().get<float>("cmv-zero-threshold");
+    mDynamicPrecisionMean = ic.options().get<float>("cmv-dynamic-precision-mean");
+    mDynamicPrecisionSigma = ic.options().get<float>("cmv-dynamic-precision-sigma");
+    mThreads = std::max(1, ic.options().get<int>("nthreads-compression"));
+    LOGP(info, "CMV aggregation settings: output-dir={}, use-compression-varint={}, use-sparse={}, use-compression-huffman={}, cmv-round-integers-threshold={}, cmv-zero-threshold={}, cmv-dynamic-precision-mean={}, cmv-dynamic-precision-sigma={}, nthreads-compression={}",
+         mOutputDir, mUseCompressionVarint, mUseSparse, mUseCompressionHuffman, mRoundIntegersThreshold, mZeroThreshold, mDynamicPrecisionMean, mDynamicPrecisionSigma, mThreads);
+    initIntervalTree();
+  }
+
+  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final
+  {
+    o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
+  }
+
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    // Consume CCDB inputs; return early when they are the only valid inputs in this slot
+    int nCCDBInputs = 0;
+    if (pc.inputs().isValid("grpecs")) {
+      pc.inputs().get<o2::parameters::GRPECSObject*>("grpecs");
+      ++nCCDBInputs;
+    }
+    if (mUsePreciseTimestamp && pc.inputs().isValid("orbitreset")) {
+      mTFInfo = pc.inputs().get<dataformats::Pair<long, int>>("orbitreset");
+      ++nCCDBInputs;
+    }
+    if (nCCDBInputs > 0 && pc.inputs().countValidInputs() == nCCDBInputs) {
+      return;
+    }
+
+    if (mSetDataTakingCont) {
+      mDataTakingContext = pc.services().get<DataTakingContext>();
+      mSetDataTakingCont = false;
+    }
+
+    if (!mRun) {
+      mRun = processing_helpers::getRunNumber(pc);
+    }
+
+    const auto currTF = processing_helpers::getCurrentTF(pc);
+
+    if (mTFFirst == -1) {
+      for (auto& ref : InputRecordWalker(pc.inputs(), mFirstTFFilter)) {
+        mTFFirst = pc.inputs().get<long>(ref);
+        mIntervalFirstTF = mTFFirst;
+        mHasIntervalFirstTF = true;
+        break;
+      }
+    }
+
+    // EOS sentinel forwarded by the distribute lane for partial batches (n-TFs-buffer > actual TFs delivered)
+    if (currTF == std::numeric_limits<uint32_t>::max()) {
+      if (mTimestampStart == 0) {
+        mTimestampStart = pc.services().get<o2::framework::TimingInfo>().creation;
+      }
+      collectEOSInputs(pc);
+      return;
+    }
+
+    if (mTFFirst == -1) {
+      mTFFirst = currTF;
+      mIntervalFirstTF = mTFFirst;
+      mHasIntervalFirstTF = true;
+      LOGP(warning, "firstTF not found. Setting {} as first TF for aggregate lane {}", mTFFirst, mLaneId);
+    }
+
+    const long relTF = (currTF - mTFFirst) / mNTFsBuffer;
+    if (relTF < 0) {
+      LOGP(warning, "relTF={} < 0 for TF {}, skipping", relTF, currTF);
+      return;
+    }
+    if (relTF >= static_cast<long>(mTimeFrames)) {
+      // The distribute has advanced past this interval (empty CRU placeholders sent by checkMissingData
+      // arrive with the triggering TF's context, not the missing batch's context).
+      // Force-complete whatever was buffered so the next TF starts a fresh interval.
+      LOGP(warning, "relTF={} out of range [0, {}) for TF {}: force-completing stale interval and resetting", relTF, mTimeFrames, currTF);
+      if (mTimestampStart == 0) {
+        mTimestampStart = static_cast<long>(pc.services().get<o2::framework::TimingInfo>().creation);
+      }
+      materializeBufferedTFs(true);
+      sendOutput(pc.outputs());
+      // Advance mTFFirst to the interval containing currTF so that after reset() clears it to -1
+      // we can restore a valid value. Without this, the distribute won't resend CMVFIRSTTF (it was
+      // already sent for the current interval), causing "firstTF not found" and further bad relTFs.
+      long nextFirst = mIntervalFirstTF + static_cast<long>(mTimeFrames) * mNTFsBuffer;
+      while (static_cast<long>(currTF) >= nextFirst + static_cast<long>(mTimeFrames) * mNTFsBuffer) {
+        nextFirst += static_cast<long>(mTimeFrames) * mNTFsBuffer;
+      }
+      reset();
+      mTFFirst = nextFirst;
+      mIntervalFirstTF = nextFirst;
+      mHasIntervalFirstTF = true;
+      return;
+    }
+
+    // Capture orbit info first so setTimestampCCDB can use the measured stride
+    if (!mOrbitInfoSeen[relTF]) {
+      // all CRUs within a batch carry identical timing, so the first one is sufficient
+      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+        mOrbitInfo[relTF] = pc.inputs().get<uint64_t>(ref);
+        const auto batchFirstOrbit = static_cast<uint32_t>(mOrbitInfo[relTF] >> 32);
+        // TimingInfo.firstTForbit is the orbit of the last real TF in the batch (the TF that triggered the FLP to send).
+        // The FLP provides the orbit of the first real TF.  Interpolating between the two gives the true stride,
+        // independent of the GRPECS/config nHBFPerTF value.
+        const auto batchLastOrbit = static_cast<uint32_t>(pc.services().get<o2::framework::TimingInfo>().firstTForbit);
+        const auto defaultOrbitStep = static_cast<uint32_t>(o2::base::GRPGeomHelper::instance().getNHBFPerTF());
+        mOrbitStep[relTF] = ((batchFirstOrbit > 0) && (mNTFsBuffer > 1) && (batchLastOrbit > batchFirstOrbit)) ? (batchLastOrbit - batchFirstOrbit) / static_cast<uint32_t>(mNTFsBuffer - 1) : defaultOrbitStep;
+        mLastOrbitStep = mOrbitStep[relTF];
+        mOrbitInfoSeen[relTF] = true;
+        break;
+      }
+    }
+
+    if (mTimestampStart == 0) {
+      setTimestampCCDB(relTF, mOrbitStep[relTF], pc);
+    }
+
+    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+      auto const* hdr = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+      const unsigned int cru = hdr->subSpecification;
+      if (!(std::binary_search(mCRUs.begin(), mCRUs.end(), cru))) {
+        LOGP(debug, "Received CMV data from CRU {} which is not part of this aggregate lane", cru);
+        continue;
+      }
+      if (mProcessedCRUs[relTF][cru]) {
+        continue;
+      }
+
+      auto cmvVec = pc.inputs().get<pmr::vector<uint16_t>>(ref);
+      mRawCMVs[relTF][cru] = std::vector<uint16_t>(cmvVec.begin(), cmvVec.end());
+      mProcessedCRUs[relTF][cru] = true;
+      ++mProcessedCRU[relTF];
+    }
+
+    if (mProcessedCRU[relTF] == mCRUs.size() && !mTFCompleted[relTF]) {
+      mTFCompleted[relTF] = true;
+      ++mProcessedTFs;
+      mLastSeenTF = currTF;
+    }
+
+    if (mProcessedTFs == mTimeFrames) {
+      materializeBufferedTFs(false);
+      sendOutput(pc.outputs());
+      reset();
+    }
+  }
+
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final
+  {
+    materializeBufferedTFs(true);
+    materializeEOSBuffer();
+    sendOutput(ec.outputs());
+    ec.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+  }
+
+  static constexpr header::DataDescription getDataDescriptionCCDBCMV() { return header::DataDescription{"TPC_CMV"}; }
+
+ private:
+  struct PreparedTF {
+    CMVPerTF tf{};
+    CMVPerTFCompressed compressed{};
+  };
+
+  const int mLaneId{0};                   ///< aggregate lane index (matches the distribute output lane)
+  std::vector<uint32_t> mCRUs{};          ///< CRUs expected on this lane (sorted for binary_search)
+  const unsigned int mTimeFrames{};       ///< number of CMV batches per calibration interval (= total TFs / nTFsBuffer)
+  const bool mSendCCDB{false};            ///< send serialised TTree to the CCDB populator
+  const bool mUsePreciseTimestamp{false}; ///< use orbit-reset info forwarded by the distribute lane for precise CCDB timestamps
+  const int mNTFsBuffer{1};               ///< number of real TFs packed into one CMV batch (must match TPCFLPCMVSpec)
+  std::string mOutputDir{};               ///< directory to write local ROOT files ("/dev/null" to disable)
+  std::string mMetaFileDir{};             ///< directory to write calibration metadata files ("/dev/null" to disable)
+  o2::framework::DataTakingContext mDataTakingContext{};
+  bool mSetDataTakingCont{true};                                               ///< flag to capture DataTakingContext only once
+  bool mUseCompressionVarint{false};                                           ///< delta+zigzag+varint compression for all values (dense path); combined with mUseSparse → sparse+varint
+  bool mUseSparse{false};                                                      ///< sparse encoding (skip zero time bins); alone = raw uint16; combined with varint/Huffman → sparse+compressed
+  bool mUseCompressionHuffman{false};                                          ///< Huffman encoding; combined with mUseSparse → sparse+Huffman
+  uint16_t mRoundIntegersThreshold{0};                                         ///< round values to nearest integer ADC for |v| <= N ADC before compression; 0 = disabled
+  float mZeroThreshold{0.f};                                                   ///< zero out CMV values whose float magnitude is below this threshold; 0 = disabled
+  float mDynamicPrecisionMean{1.f};                                            ///< Gaussian centre in |CMV| ADC where the strongest fractional-bit trimming is applied
+  float mDynamicPrecisionSigma{0.f};                                           ///< Gaussian width in ADC for fractional-bit trimming; 0 disables
+  int mThreads{1};                                                             ///< number of threads for CMV preprocessing and compression in appendBatchToTree()
+  long mTFFirst{-1};                                                           ///< absolute TF index of the first real TF in the current interval (-1 = not yet received)
+  long mTimestampStart{0};                                                     ///< CCDB validity start timestamp in ms (0 until set by setTimestampCCDB)
+  long mIntervalFirstTF{0};                                                    ///< absolute TF counter stored in the TTree UserInfo as "firstTF"
+  bool mHasIntervalFirstTF{false};                                             ///< true once mIntervalFirstTF has been set for the current interval
+  unsigned int mProcessedTFs{0};                                               ///< number of completed CMV batches in the current interval
+  std::vector<unsigned int> mProcessedCRU{};                                   ///< counter of received CRUs per relTF slot; triggers completion when it reaches mCRUs.size()
+  std::vector<std::unordered_map<unsigned int, bool>> mProcessedCRUs{};        ///< per-CRU received flag per relTF ([relTF][CRU]); prevents double-counting on retransmission
+  std::vector<std::unordered_map<uint32_t, std::vector<uint16_t>>> mRawCMVs{}; ///< buffered raw CMV data per (relTF, CRU); unpacked in appendBatchToTree()
+  std::vector<uint64_t> mOrbitInfo{};                                          ///< packed (firstOrbit << 32 | firstBC) per relTF, forwarded by the distribute lane
+  std::vector<uint32_t> mOrbitStep{};                                          ///< per-sub-TF orbit stride per relTF; derived from actual batch timing
+  std::vector<bool> mOrbitInfoSeen{};                                          ///< true once orbit/BC has been captured for each relTF slot
+  std::vector<bool> mTFCompleted{};                                            ///< true once all CRUs have been received for a given relTF slot
+  std::unordered_map<uint32_t, std::vector<uint16_t>> mEOSRawCMVs{};           ///< CMV data received during the EOS sentinel path (partial batch at end of run)
+  uint32_t mEOSFirstOrbit{0};                                                  ///< firstOrbit captured from the FLP's EOS partial-buffer flush
+  uint16_t mEOSFirstBC{0};                                                     ///< firstBC captured from the FLP's EOS partial-buffer flush
+  uint32_t mLastOrbitStep{0};                                                  ///< cached orbit stride from the last complete batch; fallback for the EOS partial batch
+  uint32_t mLastSeenTF{0};                                                     ///< last TF counter seen in run(); used to compute lastTF metadata in the TTree
+  unsigned int mIntervalTFCount{0};                                            ///< number of TTree entries filled for the current interval
+  uint64_t mRun{0};                                                            ///< run number, captured once per run
+  uint32_t mIntervalFirstOrbit{0};                                             ///< first orbit of the first TF in the current interval
+  uint32_t mIntervalLastOrbit{0};                                              ///< first orbit of the last TF in the current interval
+  uint32_t mFirstOrbitDPL{0};                                                  ///< first orbit of the first TF in the current interval
+  bool mIntervalOrbitSet{false};                                               ///< true once first orbit has been captured for the current interval
+  dataformats::Pair<long, int> mTFInfo{};                                      ///< orbit-reset time (ms) and NHBFPerTF forwarded by distribute lane 0 for precise timestamps
+  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;                      ///< GRPECS request so GRPGeomHelper::getNHBFPerTF() is valid in this process
+  std::unique_ptr<TTree> mIntervalTree{};                                      ///< in-memory TTree accumulating one entry per real TF; serialised to CCDB/disk at interval end
+  CMVPerTF mCurrentTF{};                                                       ///< staging object written to the TTree branch for the uncompressed path
+  CMVPerTFCompressed mCurrentCompressedTF{};                                   ///< staging object written to the TTree branch when any compression flags are set
+  const std::vector<InputSpec> mFilter{
+    {"cmvagg",
+     ConcreteDataTypeMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(mLaneId)},
+     Lifetime::Sporadic}};
+  const std::vector<InputSpec> mOrbitFilter{
+    {"cmvorbit",
+     ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(mLaneId), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(mLaneId)}},
+     Lifetime::Sporadic}};
+  const std::vector<InputSpec> mFirstTFFilter{
+    {"firstTF",
+     ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(mLaneId)}},
+     Lifetime::Sporadic}};
+
+  uint8_t buildCompressionFlags() const
+  {
+    uint8_t flags = CMVEncoding::kNone;
+    if (mUseSparse) {
+      flags |= CMVEncoding::kSparse;
+    }
+    if (mUseCompressionHuffman) {
+      flags |= CMVEncoding::kDelta | CMVEncoding::kZigzag | CMVEncoding::kHuffman;
+    } else if (mUseCompressionVarint) {
+      flags |= CMVEncoding::kDelta | CMVEncoding::kZigzag | CMVEncoding::kVarint;
+    }
+    return flags;
+  }
+
+  /// Create a fresh in-memory TTree for the next aggregation interval
+  /// Uses a single CMVPerTFCompressed branch whenever any compression is active or a raw CMVPerTF branch when no compression flags are set.
+  void initIntervalTree()
+  {
+    mIntervalTree = std::make_unique<TTree>("ccdb_object", "ccdb_object");
+    mIntervalTree->SetAutoSave(0);
+    mIntervalTree->SetDirectory(nullptr);
+    if (buildCompressionFlags() != CMVEncoding::kNone) {
+      mIntervalTree->Branch("CMVPerTFCompressed", &mCurrentCompressedTF);
+    } else {
+      mIntervalTree->Branch("CMVPerTF", &mCurrentTF);
+    }
+  }
+
+  /// Accumulate CMV data from the EOS sentinel (TF == UINT32_MAX), i.e. a partial batch forwarded by the distribute lane when n-TFs-buffer > number of TFs actually delivered
+  /// Orbit/BC is captured once; raw data is appended per CRU into mEOSRawCMVs
+  void collectEOSInputs(o2::framework::ProcessingContext& pc)
+  {
+    if (mEOSFirstOrbit == 0) {
+      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+        const auto orbitBC = pc.inputs().get<uint64_t>(ref);
+        mEOSFirstOrbit = static_cast<uint32_t>(orbitBC >> 32);
+        mEOSFirstBC = static_cast<uint16_t>(orbitBC & 0xFFFFu);
+        break;
+      }
+    }
+
+    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+      auto const* hdr = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+      const unsigned int cru = hdr->subSpecification;
+      if (!(std::binary_search(mCRUs.begin(), mCRUs.end(), cru))) {
+        continue;
+      }
+      auto cmvVec = pc.inputs().get<pmr::vector<uint16_t>>(ref);
+      auto& buffer = mEOSRawCMVs[cru];
+      buffer.insert(buffer.end(), cmvVec.begin(), cmvVec.end());
+    }
+  }
+
+  /// Set the CCDB validity start timestamp
+  /// When using precise timestamps, back-calculates the orbit-reset-referenced wall-clock time for the first real TF in the interval using the orbit-reset time forwarded by distribute lane 0.
+  /// orbitStep is the dynamically measured per-sub-TF stride; when non-zero it is preferred over the GRP NHBFPerTF for the orbit-offset calculation.
+  void setTimestampCCDB(const long relTF, const uint32_t orbitStep, o2::framework::ProcessingContext& pc)
+  {
+    const auto& tinfo = pc.services().get<o2::framework::TimingInfo>();
+    if (mUsePreciseTimestamp && !mTFInfo.second) {
+      // Orbit-reset info (NHBFPerTF) not yet received from the distribute lane.
+      // Fall back to DPL wall-clock creation time so mTimestampStart is never
+      // left at 0, which would cause successive intervals to overwrite each other.
+      mTimestampStart = tinfo.creation;
+      LOGP(warning, "Orbit reset info not yet received; using DPL creation time {} ms as fallback timestamp for interval starting at TF {}", mTimestampStart, mTFFirst);
+      return;
+    }
+    // prefer the measured stride; fall back to NHBFPerTF from GRPECS
+    const int nHBFPerTF = (orbitStep > 0) ? static_cast<int>(orbitStep) : o2::base::GRPGeomHelper::instance().getNHBFPerTF();
+    const auto nOrbitsOffset = (relTF * mNTFsBuffer + (mNTFsBuffer - 1)) * nHBFPerTF;
+    mFirstOrbitDPL = tinfo.firstTForbit - nOrbitsOffset;
+    mTimestampStart = mUsePreciseTimestamp ? (mTFInfo.first + (tinfo.firstTForbit - nOrbitsOffset) * o2::constants::lhc::LHCOrbitMUS * 0.001) : tinfo.creation;
+    LOGP(info, "Setting timestamp reset reference to: {}, at tfCounter: {}, firstTForbit: {}, NHBFPerTF: {}, relTF: {}, nOrbitsOffset: {}",
+         mTFInfo.first, tinfo.tfCounter, tinfo.firstTForbit, nHBFPerTF, relTF, nOrbitsOffset);
+  }
+
+  /// Unpack and fill the TTree for all relTF slots that have been buffered during run().
+  /// When includeIncomplete=false (normal interval end) only fully-received batches are filled.
+  /// When includeIncomplete=true (EOS flush) partial batches are also flushed with a warning.
+  void materializeBufferedTFs(const bool includeIncomplete)
+  {
+    for (unsigned int relTF = 0; relTF < mTimeFrames; ++relTF) {
+      if (mProcessedCRU[relTF] == 0) {
+        continue;
+      }
+
+      if ((mProcessedCRU[relTF] != mCRUs.size()) && !includeIncomplete) {
+        continue;
+      }
+
+      if ((mProcessedCRU[relTF] != mCRUs.size()) && includeIncomplete) {
+        LOGP(warning, "Aggregate lane {} flushing incomplete CMV batch relTF {} at EOS: received {} CRUs out of {}", mLaneId, relTF, mProcessedCRU[relTF], mCRUs.size());
+      }
+
+      if (!mHasIntervalFirstTF) {
+        mIntervalFirstTF = mTFFirst == -1 ? 0 : mTFFirst;
+        mHasIntervalFirstTF = true;
+      }
+
+      // derive the actual number of sub-TFs from the buffer size; fall back to mNTFsBuffer if empty
+      const auto maxBufferSize = getMaxBufferSize(mRawCMVs[relTF]);
+      const int nTFsInBatch = maxBufferSize ? std::max(1, static_cast<int>(maxBufferSize / cmv::NTimeBinsPerTF)) : mNTFsBuffer;
+      // fall back to GRP NHBFPerTF only if no orbit stride was measured for this relTF
+      const auto orbitStep = mOrbitStep[relTF] ? mOrbitStep[relTF] : static_cast<uint32_t>(o2::base::GRPGeomHelper::instance().getNHBFPerTF());
+      appendBatchToTree(mRawCMVs[relTF], mOrbitInfo[relTF], orbitStep, nTFsInBatch);
+    }
+  }
+
+  /// Unpack and fill the TTree from the EOS partial-batch buffer (mEOSRawCMVs).
+  /// The number of real TFs is inferred from the raw buffer size divided by NTimeBinsPerTF.
+  /// Uses mLastOrbitStep from the last complete batch as the orbit stride fallback.
+  void materializeEOSBuffer()
+  {
+    if (mEOSRawCMVs.empty()) {
+      return;
+    }
+
+    const auto maxBufferSize = getMaxBufferSize(mEOSRawCMVs);
+    const int nTFsInBatch = static_cast<int>(maxBufferSize / cmv::NTimeBinsPerTF);
+    if (nTFsInBatch <= 0) {
+      return;
+    }
+
+    if (!mHasIntervalFirstTF) {
+      mIntervalFirstTF = mLastSeenTF + 1;
+      mHasIntervalFirstTF = true;
+    }
+
+    const uint64_t orbitInfo = (static_cast<uint64_t>(mEOSFirstOrbit) << 32) | static_cast<uint64_t>(mEOSFirstBC);
+    // use the actual stride seen in run(); fall back to GRP only if no complete batch was seen
+    const auto orbitStep = mLastOrbitStep ? mLastOrbitStep : static_cast<uint32_t>(o2::base::GRPGeomHelper::instance().getNHBFPerTF());
+    appendBatchToTree(mEOSRawCMVs, orbitInfo, orbitStep, nTFsInBatch);
+    mLastSeenTF += static_cast<uint32_t>(nTFsInBatch);
+  }
+
+  static size_t getMaxBufferSize(const std::unordered_map<uint32_t, std::vector<uint16_t>>& rawCMVs)
+  {
+    size_t maxBufferSize = 0;
+    for (const auto& [cru, values] : rawCMVs) {
+      maxBufferSize = std::max(maxBufferSize, values.size());
+    }
+    return maxBufferSize;
+  }
+
+  /// Unpack nTFsInBatch real TFs from rawCMVs, apply preprocessing (rounding, zeroing, trimming),
+  /// optionally compress them, and fill one TTree entry per real TF.
+  /// Processing is parallelised across nThreads workers using std::thread (each thread owns a disjoint chunk).
+  void appendBatchToTree(const std::unordered_map<uint32_t, std::vector<uint16_t>>& rawCMVs, const uint64_t orbitInfo, const uint32_t orbitStep, const int nTFsInBatch)
+  {
+    if (nTFsInBatch <= 0) {
+      return;
+    }
+
+    const auto firstOrbit = static_cast<uint32_t>(orbitInfo >> 32);
+    const auto firstBC = static_cast<uint16_t>(orbitInfo & 0xFFFFu);
+    // Use the DPL-derived orbit as fallback when the FLP orbit info is missing (firstOrbit == 0)
+    const auto batchFirstOrbitDPL = (firstOrbit > 0) ? firstOrbit : mFirstOrbitDPL;
+    if (!mIntervalOrbitSet) {
+      mIntervalFirstOrbit = batchFirstOrbitDPL;
+      mIntervalOrbitSet = true;
+    }
+    mIntervalLastOrbit = batchFirstOrbitDPL + static_cast<uint32_t>(nTFsInBatch - 1) * orbitStep;
+    const uint8_t flags = buildCompressionFlags();
+    std::vector<PreparedTF> prepared(nTFsInBatch);
+    const int nThreads = std::max(1, std::min(mThreads, nTFsInBatch));
+    const int chunkSize = (nTFsInBatch + nThreads - 1) / nThreads;
+
+    auto worker = [&](const int iThread) {
+      const int beginTF = iThread * chunkSize;
+      const int endTF = std::min(nTFsInBatch, beginTF + chunkSize);
+      for (int tfIndex = beginTF; tfIndex < endTF; ++tfIndex) {
+
+        auto& preparedTF = prepared[tfIndex];
+        preparedTF.tf.firstOrbit = firstOrbit + static_cast<uint32_t>(tfIndex) * orbitStep;
+        preparedTF.tf.firstOrbitDPL = batchFirstOrbitDPL + static_cast<uint32_t>(tfIndex) * orbitStep;
+
+        for (const auto& [cru, values] : rawCMVs) {
+          const uint32_t offset = static_cast<uint32_t>(tfIndex) * cmv::NTimeBinsPerTF;
+          if (offset >= static_cast<uint32_t>(values.size())) {
+            continue;
+          }
+          const uint32_t nBins = std::min(static_cast<uint32_t>(values.size()) - offset, cmv::NTimeBinsPerTF);
+          for (uint32_t tb = 0; tb < nBins; ++tb) {
+            preparedTF.tf.mDataPerTF[cru * cmv::NTimeBinsPerTF + tb] = values[offset + tb];
+          }
+        }
+
+        preparedTF.tf.roundToIntegers(mRoundIntegersThreshold);
+        if (mZeroThreshold > 0.f) {
+          preparedTF.tf.zeroSmallValues(mZeroThreshold);
+        }
+        if (mDynamicPrecisionSigma > 0.f) {
+          preparedTF.tf.trimGaussianPrecision(mDynamicPrecisionMean, mDynamicPrecisionSigma);
+        }
+        if (flags != CMVEncoding::kNone) {
+          preparedTF.compressed = preparedTF.tf.compress(flags);
+        }
+      }
+    };
+
+    std::vector<std::thread> workers;
+    workers.reserve(nThreads - 1);
+    for (int iThread = 1; iThread < nThreads; ++iThread) {
+      workers.emplace_back(worker, iThread);
+    }
+    worker(0);
+    for (auto& thread : workers) {
+      thread.join();
+    }
+
+    for (int tfIndex = 0; tfIndex < nTFsInBatch; ++tfIndex) {
+      if (flags != CMVEncoding::kNone) {
+        mCurrentCompressedTF = std::move(prepared[tfIndex].compressed);
+      } else {
+        mCurrentTF = std::move(prepared[tfIndex].tf);
+      }
+      mIntervalTree->Fill();
+      ++mIntervalTFCount;
+    }
+  }
+
+  void sendOutput(DataAllocator& output)
+  {
+    using timer = std::chrono::high_resolution_clock;
+
+    if (mIntervalTFCount == 0) {
+      LOGP(warning, "CMV interval is empty at sendOutput for lane {}, skipping", mLaneId);
+      return;
+    }
+
+    const auto lastTF = mIntervalFirstTF + static_cast<long>(mIntervalTFCount) - 1;
+    mIntervalTree->GetUserInfo()->Clear();
+    mIntervalTree->GetUserInfo()->Add(new TParameter<long>("firstTF", mIntervalFirstTF));
+    mIntervalTree->GetUserInfo()->Add(new TParameter<long>("lastTF", lastTF));
+
+    LOGP(info, "CMVPerTF TTree lane {}: {} entries, firstTF={}, lastTF={}", mLaneId, mIntervalTFCount, mIntervalFirstTF, lastTF);
+    auto start = timer::now();
+
+    const int nHBFPerTF = o2::base::GRPGeomHelper::instance().getNHBFPerTF();
+    const long timeStampEnd = mTimestampStart + static_cast<long>(mIntervalTFCount * nHBFPerTF * o2::constants::lhc::LHCOrbitMUS * 1e-3);
+
+    if (mOutputDir != "/dev/null") {
+      const std::string calibFName = fmt::format("CMV_run_{}_orbit_{}_{}_timestamp_{}_{}.root",
+                                                 mRun, mIntervalFirstOrbit, mIntervalLastOrbit, mTimestampStart, timeStampEnd);
+      try {
+        CMVPerTF::writeToFile(mOutputDir + calibFName, mIntervalTree);
+        LOGP(info, "CMV file written to {}", mOutputDir + calibFName);
+      } catch (const std::exception& e) {
+        LOGP(error, "Failed to write CMV file {}: {}", mOutputDir + calibFName, e.what());
+      }
+
+      if (mMetaFileDir != "/dev/null") {
+        o2::dataformats::FileMetaData calMetaData;
+        calMetaData.fillFileData(mOutputDir + calibFName);
+        calMetaData.setDataTakingContext(mDataTakingContext);
+        calMetaData.type = "calib";
+        calMetaData.priority = "low";
+        auto metaFileNameTmp = fmt::format("{}{}.tmp", mMetaFileDir, calibFName);
+        auto metaFileName = fmt::format("{}{}.done", mMetaFileDir, calibFName);
+        try {
+          std::ofstream metaFileOut(metaFileNameTmp);
+          metaFileOut << calMetaData;
+          metaFileOut.close();
+          std::filesystem::rename(metaFileNameTmp, metaFileName);
+        } catch (std::exception const& e) {
+          LOG(error) << "Failed to store CMV meta data file " << metaFileName << ", reason: " << e.what();
+        }
+      }
+    }
+
+    if ((!mSendCCDB) && (mOutputDir == "/dev/null")) {
+      LOGP(warning, "Neither CCDB output nor output-dir is enabled for aggregate lane {}, skipping CMV export", mLaneId);
+    }
+    if (!mSendCCDB) {
+      return;
+    }
+
+    if (timeStampEnd <= mTimestampStart) {
+      LOGP(warning, "Invalid CCDB timestamp range start:{} end:{}, skipping upload", mTimestampStart, timeStampEnd);
+      return;
+    }
+
+    o2::ccdb::CcdbObjectInfo ccdbInfoCMV("TPC/Calib/CMV", "TTree", "CMV.root", {}, mTimestampStart, timeStampEnd);
+    auto image = o2::ccdb::CcdbApi::createObjectImage((mIntervalTree.get()), &ccdbInfoCMV);
+    // trim TMemFile zero-padding: GetSize() is block-rounded, GetEND() is the actual file end
+    {
+      TMemFile mf("trim", image->data(), static_cast<Long64_t>(image->size()), "READ");
+      image->resize(static_cast<size_t>(mf.GetEND()));
+      mf.Close();
+    }
+
+    LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {}", ccdbInfoCMV.getPath(), ccdbInfoCMV.getFileName(), image->size(), ccdbInfoCMV.getStartValidityTimestamp(), ccdbInfoCMV.getEndValidityTimestamp());
+    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBCMV(), 0}, *image);
+    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBCMV(), 0}, ccdbInfoCMV);
+
+    auto stop = timer::now();
+    std::chrono::duration<float> elapsed = stop - start;
+    LOGP(info, "CMV CCDB serialisation time: {:.3f} s", elapsed.count());
+  }
+
+  /// Reset all per-interval state after a successful sendOutput(); prepares for the next interval
+  void reset()
+  {
+    mTFFirst = -1;
+    mTimestampStart = 0;
+    mIntervalFirstTF = 0;
+    mHasIntervalFirstTF = false;
+    mProcessedTFs = 0;
+    std::fill(mProcessedCRU.begin(), mProcessedCRU.end(), 0);
+    std::fill(mOrbitInfo.begin(), mOrbitInfo.end(), 0);
+    std::fill(mOrbitStep.begin(), mOrbitStep.end(), 0);
+    std::fill(mOrbitInfoSeen.begin(), mOrbitInfoSeen.end(), false);
+    std::fill(mTFCompleted.begin(), mTFCompleted.end(), false);
+    for (auto& processedMap : mProcessedCRUs) {
+      for (auto& [cru, seen] : processedMap) {
+        seen = false;
+      }
+    }
+    for (auto& rawPerTF : mRawCMVs) {
+      rawPerTF.clear();
+    }
+    mEOSRawCMVs.clear();
+    mEOSFirstOrbit = 0;
+    mEOSFirstBC = 0;
+    mLastOrbitStep = 0;
+    mLastSeenTF = 0;
+    mIntervalTFCount = 0;
+    mIntervalFirstOrbit = 0;
+    mIntervalLastOrbit = 0;
+    mFirstOrbitDPL = 0;
+    mIntervalOrbitSet = false;
+    mCurrentTF = CMVPerTF{};
+    mCurrentCompressedTF = CMVPerTFCompressed{};
+    initIntervalTree();
+  }
+};
+
+/// Build a DataProcessorSpec for one aggregate lane
+/// Each lane receives CMV data from one distribute output lane (matched by lane index) and expects the full CRU list — the distribute stage already routes per-CRU data to the correct lane
+inline DataProcessorSpec getTPCAggregateCMVSpec(const int lane,
+                                                const std::vector<uint32_t>& crus,
+                                                const unsigned int timeframes,
+                                                const bool sendCCDB,
+                                                const bool usePreciseTimestamp,
+                                                const int nTFsBuffer = 1)
+{
+  std::vector<OutputSpec> outputSpecs;
+  if (sendCCDB) {
+    outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, TPCAggregateCMVDevice::getDataDescriptionCCDBCMV()}, Lifetime::Sporadic);
+    outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, TPCAggregateCMVDevice::getDataDescriptionCCDBCMV()}, Lifetime::Sporadic);
+  }
+
+  std::vector<InputSpec> inputSpecs;
+  inputSpecs.emplace_back(InputSpec{"cmvagg", ConcreteDataTypeMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(lane)}, Lifetime::Sporadic});
+  inputSpecs.emplace_back(InputSpec{"cmvorbit", gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(lane), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, Lifetime::Sporadic});
+  inputSpecs.emplace_back(InputSpec{"firstTF", gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, Lifetime::Sporadic});
+  if (usePreciseTimestamp) {
+    inputSpecs.emplace_back(InputSpec{"orbitreset", gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, Lifetime::Sporadic});
+  }
+
+  // Request GRPECS from CCDB so that GRPGeomHelper::getNHBFPerTF() is valid in this (separate) process
+  auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
+                                                                true,                           // GRPECS (NHBFPerTF)
+                                                                false,                          // GRPLHCIF
+                                                                false,                          // GRPMagField
+                                                                false,                          // askMatLUT
+                                                                o2::base::GRPGeomRequest::None, // geometry
+                                                                inputSpecs);
+
+  DataProcessorSpec spec{
+    fmt::format("tpc-aggregate-cmv-{:02}", lane).data(),
+    inputSpecs,
+    outputSpecs,
+    AlgorithmSpec{adaptFromTask<TPCAggregateCMVDevice>(lane, crus, timeframes, sendCCDB, usePreciseTimestamp, nTFsBuffer, ccdbRequest)},
+    Options{{"output-dir", VariantType::String, "/dev/null", {"CMV output directory, must exist (if not /dev/null)"}},
+            {"meta-output-dir", VariantType::String, "/dev/null", {"calibration metadata output directory, must exist (if not /dev/null)"}},
+            {"nthreads-compression", VariantType::Int, 1, {"Number of threads used for CMV per timeframe preprocessing and compression"}},
+            {"use-sparse", VariantType::Bool, false, {"Sparse encoding (skip zero time bins). Alone: raw uint16 values. With --use-compression-varint: varint exact values. With --use-compression-huffman: Huffman exact values"}},
+            {"use-compression-varint", VariantType::Bool, false, {"Delta+zigzag+varint compression (all values). Combined with --use-sparse: sparse positions + varint encoded exact CMV values"}},
+            {"use-compression-huffman", VariantType::Bool, false, {"Huffman encoding. Combined with --use-sparse: sparse positions + Huffman-encoded exact CMV values"}},
+            {"cmv-zero-threshold", VariantType::Float, 0.f, {"Zero out CMV values whose float magnitude is below this threshold after optional integer rounding and before compression; 0 disables"}},
+            {"cmv-round-integers-threshold", VariantType::Int, 0, {"Round values to nearest integer ADC for |v| <= N ADC before compression; 0 disables"}},
+            {"cmv-dynamic-precision-mean", VariantType::Float, 1.f, {"Gaussian centre in |CMV| ADC where the strongest fractional bit trimming is applied"}},
+            {"cmv-dynamic-precision-sigma", VariantType::Float, 0.f, {"Gaussian width in ADC for smooth CMV fractional bit trimming; 0 disables"}}}};
+  spec.rank = lane;
+  return spec;
+}
+
+} // namespace o2::tpc
+
+#endif
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
index c1744ce86d3ac..f3373070ab7bb 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
@@ -11,15 +11,17 @@
 
 /// @file   TPCDistributeCMVSpec.h
 /// @author Tuba Gündem, tuba.gundem@cern.ch
-/// @brief  TPC aggregation of grouped CMVs
+/// @brief  TPC distribution of grouped CMVs towards the CMV aggregation workflow
 
 #ifndef O2_TPCDISTRIBUTECMVSPEC_H
 #define O2_TPCDISTRIBUTECMVSPEC_H
 
+#include <algorithm>
+#include <array>
+#include <limits>
+#include <unordered_map>
 #include <vector>
-#include <chrono>
 #include <fmt/format.h>
-#include "TParameter.h"
 #include "Framework/Task.h"
 #include "Framework/ControlService.h"
 #include "Framework/Logger.h"
@@ -33,12 +35,6 @@
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "CommonDataFormat/Pair.h"
-#include "TMemFile.h"
-#include "CCDB/CcdbApi.h"
-#include "CCDB/CcdbObjectInfo.h"
-#include "DetectorsCalibration/Utils.h"
-#include "TPCCalibration/CMVContainer.h"
-#include "DataFormatsTPC/CMV.h"
 
 using namespace o2::framework;
 using o2::header::gDataOriginTPC;
@@ -50,20 +46,25 @@ namespace o2::tpc
 class TPCDistributeCMVSpec : public o2::framework::Task
 {
  public:
-  TPCDistributeCMVSpec(const std::vector<uint32_t>& crus, const unsigned int timeframes, const int nTFsBuffer, const int firstTF, const bool sendCCDB, const bool usePreciseTimestamp, std::shared_ptr<o2::base::GRPGeomRequest> req)
+  TPCDistributeCMVSpec(const std::vector<uint32_t>& crus, const unsigned int timeframes, const int nTFsBuffer, const unsigned int outlanes, const int firstTF, std::shared_ptr<o2::base::GRPGeomRequest> req)
     : mCRUs{crus},
       mTimeFrames{timeframes},
       mNTFsBuffer{nTFsBuffer},
+      mOutLanes{outlanes},
       mProcessedCRU{{std::vector<unsigned int>(timeframes), std::vector<unsigned int>(timeframes)}},
-      mTFStart{{firstTF, firstTF + timeframes}},
-      mTFEnd{{firstTF + timeframes - 1, mTFStart[1] + timeframes - 1}},
+      mTFStart{{firstTF, firstTF + static_cast<long>(timeframes) * nTFsBuffer}},
+      mTFEnd{{firstTF + static_cast<long>(timeframes) * nTFsBuffer - 1, firstTF + 2LL * timeframes * nTFsBuffer - 1}},
       mCCDBRequest(req),
-      mSendCCDB{sendCCDB},
-      mUsePreciseTimestamp{usePreciseTimestamp},
-      mSendCCDBOutputOrbitReset(1),
-      mSendCCDBOutputGRPECS(1),
+      mSendCCDBOutputOrbitReset(outlanes),
+      mSendCCDBOutputGRPECS(outlanes),
       mOrbitInfoForwarded{{std::vector<bool>(timeframes, false), std::vector<bool>(timeframes, false)}}
   {
+    mDataDescrOut.reserve(mOutLanes);
+    mOrbitDescrOut.reserve(mOutLanes);
+    for (unsigned int i = 0; i < mOutLanes; ++i) {
+      mDataDescrOut.emplace_back(getDataDescriptionCMV(i));
+      mOrbitDescrOut.emplace_back(getDataDescriptionCMVOrbitInfo(i));
+    }
     // sort vector for binary_search
     std::sort(mCRUs.begin(), mCRUs.end());
 
@@ -79,10 +80,7 @@ class TPCDistributeCMVSpec : public o2::framework::Task
 
     mFilter.emplace_back(InputSpec{"cmvsgroup", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, Lifetime::Sporadic});
     mOrbitFilter.emplace_back(InputSpec{"cmvorbit", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo()}, Lifetime::Sporadic});
-
-    // pre-allocate the accumulator TTree for the current aggregation interval
-    initIntervalTree();
-  };
+  }
 
   void init(o2::framework::InitContext& ic) final
   {
@@ -97,33 +95,21 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       }
       mNTFsDataDrop = mCheckEveryNData;
     }
-    mDumpCMVs = ic.options().get<bool>("dump-cmvs");
-    mUseCompressionVarint = ic.options().get<bool>("use-compression-varint");
-    mUseSparse = ic.options().get<bool>("use-sparse");
-    mUseCompressionHuffman = ic.options().get<bool>("use-compression-huffman");
-    mRoundIntegersThreshold = static_cast<uint16_t>(ic.options().get<int>("cmv-round-integers-threshold"));
-    mZeroThreshold = ic.options().get<float>("cmv-zero-threshold");
-    mDynamicPrecisionMean = ic.options().get<float>("cmv-dynamic-precision-mean");
-    mDynamicPrecisionSigma = ic.options().get<float>("cmv-dynamic-precision-sigma");
-    LOGP(info, "CMV compression settings: use-compression-varint={}, use-sparse={}, use-compression-huffman={}, cmv-round-integers-threshold={}, cmv-zero-threshold={}, cmv-dynamic-precision-mean={}, cmv-dynamic-precision-sigma={}",
-         mUseCompressionVarint, mUseSparse, mUseCompressionHuffman, mRoundIntegersThreshold, mZeroThreshold, mDynamicPrecisionMean, mDynamicPrecisionSigma);
-    // re-initialise the interval tree now that compression options are known (constructor used the defaults)
-    initIntervalTree();
   }
 
   void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final
   {
     o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
     if (matcher == ConcreteDataMatcher("CTP", "ORBITRESET", 0)) {
-      LOGP(info, "Updating ORBITRESET");
+      LOGP(debug, "Updating ORBITRESET");
       std::fill(mSendCCDBOutputOrbitReset.begin(), mSendCCDBOutputOrbitReset.end(), true);
     } else if (matcher == ConcreteDataMatcher("GLO", "GRPECS", 0)) {
       // check if received object is valid
       if (o2::base::GRPGeomHelper::instance().getGRPECS()->getRun() != 0) {
-        LOGP(info, "Updating GRPECS");
+        LOGP(debug, "Updating GRPECS");
         std::fill(mSendCCDBOutputGRPECS.begin(), mSendCCDBOutputGRPECS.end(), true);
       } else {
-        LOGP(info, "Detected default GRPECS object");
+        LOGP(debug, "Detected default GRPECS object");
       }
     }
   }
@@ -143,44 +129,43 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       if (pc.inputs().countValidInputs() == (grpecsValid + orbitResetValid)) {
         return;
       }
-      // update mTFInfo from GRPGeomHelper whenever orbit-reset or GRPECS objects are fresh
-      if (mSendCCDBOutputOrbitReset[0] && mSendCCDBOutputGRPECS[0]) {
-        mSendCCDBOutputOrbitReset[0] = false;
-        mSendCCDBOutputGRPECS[0] = false;
-        mTFInfo = dataformats::Pair<long, int>{o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS(), o2::base::GRPGeomHelper::instance().getNHBFPerTF()};
-      }
     }
 
     const auto tf = processing_helpers::getCurrentTF(pc);
-    mLastSeenTF = tf; // track for endOfStream flush
+    if (tf == std::numeric_limits<uint32_t>::max()) {
+      forwardEOSData(pc);
+      return;
+    }
 
     // automatically detect firstTF in case firstTF was not specified
     if (mTFStart.front() <= -1) {
-      const auto firstTF = tf;
+      const auto firstTFDetected = tf;
       const long offsetTF = std::abs(mTFStart.front() + 1);
       const auto nTotTFs = getNRealTFs();
-      mTFStart = {firstTF + offsetTF, firstTF + offsetTF + nTotTFs};
+      // tf is the batch TF counter (= last real TF in the first batch), subtract (mNTFsBuffer - 1) to recover the actual first real TF of the interval
+      const long firstRealTF = static_cast<long>(firstTFDetected) - (mNTFsBuffer - 1) + offsetTF;
+      mTFStart = {firstRealTF, firstRealTF + nTotTFs};
       mTFEnd = {mTFStart[1] - 1, mTFStart[1] - 1 + nTotTFs};
-      LOGP(info, "Setting {} as first TF", mTFStart[0]);
-      LOGP(info, "Using offset of {} TFs for setting the first TF", offsetTF);
+      LOGP(detail, "Setting {} as first TF", mTFStart[0]);
+      LOGP(detail, "Using offset of {} TFs for setting the first TF", offsetTF);
     }
 
     // check which buffer to use for current incoming data
     const bool currentBuffer = (tf > mTFEnd[mBuffer]) ? !mBuffer : mBuffer;
     if (mTFStart[currentBuffer] > tf) {
-      LOGP(info, "All CRUs for current TF {} already received. Skipping this TF", tf);
+      LOGP(detail, "All CRUs for current TF {} already received. Skipping this TF", tf);
       return;
     }
 
+    const unsigned int currentOutLane = getOutLane(tf);
     const unsigned int relTF = (tf - mTFStart[currentBuffer]) / mNTFsBuffer;
-    LOGP(info, "Current TF: {}, relative TF: {}, current buffer: {}, mTFStart: {}", tf, relTF, currentBuffer, mTFStart[currentBuffer]);
+    LOGP(debug, "Current TF: {}, relative TF: {}, current buffer: {}, current output lane: {}, mTFStart: {}", tf, relTF, currentBuffer, currentOutLane, mTFStart[currentBuffer]);
 
     if (relTF >= mProcessedCRU[currentBuffer].size()) {
       LOGP(warning, "Skipping tf {}: relative tf {} is larger than size of buffer: {}", tf, relTF, mProcessedCRU[currentBuffer].size());
-
       // check number of processed CRUs for previous TFs. If CRUs are missing for them, they are probably lost/not received
       mProcessedTotalData = mCheckEveryNData;
-      checkIntervalsForMissingData(pc, currentBuffer, relTF, tf);
+      checkIntervalsForMissingData(pc, currentBuffer, relTF, currentOutLane, tf);
       return;
     }
 
@@ -188,33 +173,18 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       return;
     }
 
-    // record the absolute first TF of this aggregation interval
-    if (mIntervalTFCount == 0) {
-      mIntervalFirstTF = tf;
+    if (mSendOutputStartInfo[currentBuffer]) {
+      mSendOutputStartInfo[currentBuffer] = false;
+      pc.outputs().snapshot(Output{gDataOriginTPC, getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{currentOutLane}}, mTFStart[currentBuffer]);
     }
 
-    // set CCDB start timestamp once at the start of each aggregation interval
-    if (mTimestampStart == 0) {
-      setTimestampCCDB(relTF, pc);
+    if (mSendCCDBOutputOrbitReset[currentOutLane] && mSendCCDBOutputGRPECS[currentOutLane]) {
+      mSendCCDBOutputOrbitReset[currentOutLane] = false;
+      mSendCCDBOutputGRPECS[currentOutLane] = false;
+      pc.outputs().snapshot(Output{gDataOriginTPC, getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{currentOutLane}}, dataformats::Pair<long, int>{o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS(), o2::base::GRPGeomHelper::instance().getNHBFPerTF()});
     }
 
-    // capture orbit/BC info into the interval once per relTF.
-    // all CRUs within a TF carry identical timing, so the first one is sufficient.
-    if (!mOrbitInfoForwarded[currentBuffer][relTF]) {
-      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
-        auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
-        const unsigned int cru = hdr->subSpecification >> 7;
-        if (std::binary_search(mCRUs.begin(), mCRUs.end(), cru)) {
-          const auto orbitBC = pc.inputs().get<uint64_t>(ref);
-          if (mCurrentTF.firstOrbit == 0 && mCurrentTF.firstBC == 0) {
-            mCurrentTF.firstOrbit = static_cast<uint32_t>(orbitBC >> 32);
-            mCurrentTF.firstBC = static_cast<uint16_t>(orbitBC & 0xFFFFu);
-          }
-          mOrbitInfoForwarded[currentBuffer][relTF] = true;
-          break; // one per relTF is enough
-        }
-      }
-    }
+    forwardOrbitInfo(pc, currentBuffer, relTF, currentOutLane);
 
     for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
       auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
@@ -222,79 +192,43 @@ class TPCDistributeCMVSpec : public o2::framework::Task
 
       // check if cru is specified in input cru list
       if (!(std::binary_search(mCRUs.begin(), mCRUs.end(), cru))) {
-        LOGP(info, "Received data from CRU: {} which was not specified as input. Skipping", cru);
+        LOGP(debug, "Received data from CRU: {} which was not specified as input. Skipping", cru);
         continue;
       }
 
       if (mProcessedCRUs[currentBuffer][relTF][cru]) {
         continue;
-      } else {
-        // count total number of processed CRUs for given TF
-        ++mProcessedCRU[currentBuffer][relTF];
-
-        // to keep track of processed CRUs
-        mProcessedCRUs[currentBuffer][relTF][cru] = true;
       }
+      // count total number of processed CRUs for given TF
+      ++mProcessedCRU[currentBuffer][relTF];
+      // to keep track of processed CRUs
+      mProcessedCRUs[currentBuffer][relTF][cru] = true;
 
-      // accumulate raw 16-bit CMVs into the flat array for the current TF
-      auto cmvVec = pc.inputs().get<pmr::vector<uint16_t>>(ref);
-      const uint32_t nTimeBins = std::min(static_cast<uint32_t>(cmvVec.size()), cmv::NTimeBinsPerTF);
-      for (uint32_t tb = 0; tb < nTimeBins; ++tb) {
-        mCurrentTF.mDataPerTF[cru * cmv::NTimeBinsPerTF + tb] = cmvVec[tb];
-      }
+      sendOutput(pc, currentOutLane, cru, pc.inputs().get<pmr::vector<uint16_t>>(ref));
     }
 
-    LOGP(info, "Number of received CRUs for current TF: {} Needed a total number of processed CRUs of: {} Current TF: {}", mProcessedCRU[currentBuffer][relTF], mCRUs.size(), tf);
+    LOGP(detail, "Number of received CRUs for current TF: {} Needed a total number of processed CRUs of: {} Current TF: {}", mProcessedCRU[currentBuffer][relTF], mCRUs.size(), tf);
 
     // check for missing data if specified
     if (mNTFsDataDrop > 0) {
-      checkIntervalsForMissingData(pc, currentBuffer, relTF, tf);
+      checkIntervalsForMissingData(pc, currentBuffer, relTF, currentOutLane, tf);
     }
 
     if (mProcessedCRU[currentBuffer][relTF] == mCRUs.size()) {
       ++mProcessedTFs[currentBuffer];
-
-      // Pre-processing: quantisation / rounding / zeroing (applied before compression)
-      mCurrentTF.roundToIntegers(mRoundIntegersThreshold);
-      if (mZeroThreshold > 0.f) {
-        mCurrentTF.zeroSmallValues(mZeroThreshold);
-      }
-      if (mDynamicPrecisionSigma > 0.f) {
-        mCurrentTF.trimGaussianPrecision(mDynamicPrecisionMean, mDynamicPrecisionSigma);
-      }
-
-      // Compress; the raw CMVPerTF branch is used when all flags are zero
-      const uint8_t flags = buildCompressionFlags();
-      if (flags != CMVEncoding::kNone) {
-        mCurrentCompressedTF = mCurrentTF.compress(flags);
-      }
-
-      mIntervalTree->Fill();
-      ++mIntervalTFCount;
-      mCurrentTF = CMVPerTF{};
     }
 
     if (mProcessedTFs[currentBuffer] == mTimeFrames) {
-      sendOutput(pc.outputs(), tf);
-      finishInterval(pc, currentBuffer, tf);
+      finishInterval(pc, currentOutLane, currentBuffer, tf);
     }
   }
 
-  void endOfStream(o2::framework::EndOfStreamContext& ec) final
-  {
-    LOGP(info, "End of stream, flushing CMV interval ({} TFs)", mIntervalTFCount);
-    // correct mTFEnd for the partial last interval so the CCDB validity end timestamp reflects the actual last TF, not the expected interval end
-    mTFEnd[mBuffer] = mLastSeenTF;
-    sendOutput(ec.outputs(), mLastSeenTF);
-    ec.services().get<ControlService>().readyToQuit(QuitRequest::Me);
-  }
-
-  static constexpr header::DataDescription getDataDescriptionCCDBCMV() { return header::DataDescription{"TPC_CMV"}; }
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final { ec.services().get<ControlService>().readyToQuit(QuitRequest::Me); }
 
   /// Return data description for aggregated CMVs for a given lane
   static header::DataDescription getDataDescriptionCMV(const unsigned int lane)
   {
-    const std::string name = fmt::format("CMVAGG{}", lane).data();
+    const std::string name = fmt::format("CMVAGG{}", lane);
     header::DataDescription description;
     description.runtimeInit(name.substr(0, 16).c_str());
     return description;
@@ -315,276 +249,211 @@ class TPCDistributeCMVSpec : public o2::framework::Task
  private:
   std::vector<uint32_t> mCRUs{};                                                       ///< CRUs to process in this instance
   const unsigned int mTimeFrames{};                                                    ///< number of TFs per aggregation interval
-  const int mNTFsBuffer{1};                                                            ///< number of TFs for which the CMVs will be buffered
-  std::array<unsigned int, 2> mProcessedTFs{{0, 0}};                                   ///< number of processed time frames to keep track of when the writing to CCDB will be done
-  std::array<std::vector<unsigned int>, 2> mProcessedCRU{};                            ///< counter of received data from CRUs per TF to merge incoming data from FLPs. Buffer used in case one FLP delivers the TF after the last TF for the current aggregation interval faster then the other FLPs the last TF.
-  std::array<std::vector<std::unordered_map<unsigned int, bool>>, 2> mProcessedCRUs{}; ///< to keep track of the already processed CRUs ([buffer][relTF][CRU])
-  std::array<long, 2> mTFStart{};                                                      ///< storing of first TF for buffer interval
-  std::array<long, 2> mTFEnd{};                                                        ///< storing of last TF for buffer interval
-  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;                              ///< info for CCDB request
-  std::vector<bool> mSendCCDBOutputOrbitReset{};                                       ///< flag for received orbit reset time from CCDB
-  std::vector<bool> mSendCCDBOutputGRPECS{};                                           ///< flag for received orbit GRPECS from CCDB
-  bool mBuffer{false};                                                                 ///< buffer index
-  bool mSendCCDB{false};                                                               ///< send output to CCDB populator
-  bool mUsePreciseTimestamp{false};                                                    ///< use precise timestamp from orbit-reset info
-  bool mDumpCMVs{false};                                                               ///< write a local ROOT debug file
-  bool mUseCompressionVarint{false};                                                   ///< use delta+zigzag+varint compression (all values, no sparse skip); combined with mUseSparse → SparseV2 mode 1
-  bool mUseSparse{false};                                                              ///< sparse encoding; alone = raw uint16 values; combined with varint/Huffman flag → SparseV2
-  bool mUseCompressionHuffman{false};                                                  ///< Huffman encoding; combined with mUseSparse → SparseV2 mode 2
-  uint16_t mRoundIntegersThreshold{0};                                                 ///< round values to nearest integer ADC for |v| <= N ADC; 0 = disabled
-  float mZeroThreshold{0.f};                                                           ///< zero out CMV values whose float magnitude is below this threshold; 0 = disabled
-  float mDynamicPrecisionMean{1.f};                                                    ///< Gaussian centre in |CMV| ADC where the strongest fractional-bit trimming is applied
-  float mDynamicPrecisionSigma{0.f};                                                   ///< Gaussian width in ADC for the fractional-bit trimming; 0 disables
-  long mTimestampStart{0};                                                             ///< CCDB validity start timestamp
-  dataformats::Pair<long, int> mTFInfo{};                                              ///< orbit-reset time and NHBFPerTF for precise timestamp
-  std::unique_ptr<TTree> mIntervalTree{};                                              ///< TTree accumulating one entry per completed TF in the current interval
-  CMVPerTF mCurrentTF{};                                                               ///< staging object filled per CRU before compression
-  CMVPerTFCompressed mCurrentCompressedTF{};                                           ///< compressed output for the current TF (used when flags != kNone)
-  long mIntervalFirstTF{0};                                                            ///< absolute TF counter of the first TF in the current aggregation interval
-  unsigned int mIntervalTFCount{0};                                                    ///< number of TTree entries filled for the current aggregation interval
-  int mNFactorTFs{0};                                                                  ///< Number of TFs to skip for sending oldest TF
-  int mNTFsDataDrop{0};                                                                ///< delay for the check if TFs are missing in TF units
-  std::array<int, 2> mStartNTFsDataDrop{0};                                            ///< first relative TF to check
-  long mProcessedTotalData{0};                                                         ///< used to check for dropeed TF data
-  int mCheckEveryNData{1};                                                             ///< factor after which to check for missing data (in case data missing -> send dummy data)
-  std::vector<InputSpec> mFilter{};                                                    ///< filter for looping over input data
-  std::vector<InputSpec> mOrbitFilter{};                                               ///< filter for CMVORBITINFO from FLP
-  std::array<std::vector<bool>, 2> mOrbitInfoForwarded{};                              ///< tracks whether orbit/BC has been captured per (buffer, relTF)
-  uint32_t mLastSeenTF{0};                                                             ///< last TF counter seen in run(), used to set lastTF in endOfStream flush
-
-  /// Returns real number of TFs taking buffer size into account
+  const int mNTFsBuffer{1};                                                            ///< number of TFs for which the CMVs will be buffered (must match TPCFLPCMVSpec)
+  const unsigned int mOutLanes{};                                                      ///< number of parallel aggregate pipelines this distributor feeds
+  std::array<unsigned int, 2> mProcessedTFs{{0, 0}};                                   ///< number of processed timeframes per buffer; triggers sendOutput when it reaches mTimeFrames
+  std::array<std::vector<unsigned int>, 2> mProcessedCRU{};                            ///< counter of received CRUs per (buffer, relTF); used to detect when a relTF is complete
+  std::array<std::vector<std::unordered_map<unsigned int, bool>>, 2> mProcessedCRUs{}; ///< per-CRU received flag ([buffer][relTF][CRU]); prevents double-counting when a CRU re-sends
+  std::array<long, 2> mTFStart{};                                                      ///< absolute TF counter of the first TF in each buffer interval
+  std::array<long, 2> mTFEnd{};                                                        ///< absolute TF counter of the last TF in each buffer interval
+  std::array<bool, 2> mSendOutputStartInfo{true, true};                                ///< flag to send CMVFIRSTTF message once at the start of each buffer interval
+  std::shared_ptr<o2::base::GRPGeomRequest> mCCDBRequest;                              ///< info for CCDB request (orbit-reset and GRPECS, only on lane 0 when sendPreciseTimestamp=true)
+  std::vector<bool> mSendCCDBOutputOrbitReset{};                                       ///< per-output-lane flag: true when a fresh orbit-reset object has been received from CCDB
+  std::vector<bool> mSendCCDBOutputGRPECS{};                                           ///< per-output-lane flag: true when a fresh GRPECS object has been received from CCDB
+  unsigned int mCurrentOutLane{0};                                                     ///< output lane currently being filled
+  bool mBuffer{false};                                                                 ///< double-buffer index (false = buffer 0, true = buffer 1)
+  int mNFactorTFs{0};                                                                  ///< number of TFs to skip when setting oldestForChannel; resets to 0 after first interval
+  int mNTFsDataDrop{0};                                                                ///< delay (in relTF units) before declaring a relTF's missing CRUs as lost
+  std::array<int, 2> mStartNTFsDataDrop{0};                                            ///< first relative TF index to check for missing data in each buffer
+  long mProcessedTotalData{0};                                                         ///< call counter used to throttle checkIntervalsForMissingData checks
+  int mCheckEveryNData{1};                                                             ///< check for missing data every N run() calls (0 → default = mTimeFrames/2)
+  std::vector<InputSpec> mFilter{};                                                    ///< filter for looping over CMVGROUP input data from FLPs
+  std::vector<InputSpec> mOrbitFilter{};                                               ///< filter for CMVORBITINFO input from FLPs
+  std::vector<header::DataDescription> mDataDescrOut{};                                ///< per-output-lane CMV data descriptions (CMVAGG0, CMVAGG1, …)
+  std::vector<header::DataDescription> mOrbitDescrOut{};                               ///< per-output-lane orbit-info data descriptions (CMVORB0, CMVORB1, …)
+  std::array<std::vector<bool>, 2> mOrbitInfoForwarded{};                              ///< tracks whether orbit/BC has been forwarded to the aggregate lane per (buffer, relTF)
+
+  /// Returns the output aggregate lane for a given TF counter (advances when the current buffer interval has ended)
+  unsigned int getOutLane(const uint32_t tf) const { return (tf > mTFEnd[mBuffer]) ? (mCurrentOutLane + 1) % mOutLanes : mCurrentOutLane; }
+  /// Returns the total number of real TFs per buffer interval (= mNTFsBuffer * mTimeFrames)
   unsigned int getNRealTFs() const { return mNTFsBuffer * mTimeFrames; }
 
-  /// Build the CMVEncoding bitmask from the current option flags.
-  uint8_t buildCompressionFlags() const
+  void sendOutput(o2::framework::ProcessingContext& pc, const unsigned int currentOutLane, const unsigned int cru, o2::pmr::vector<uint16_t> cmvs)
   {
-    uint8_t flags = CMVEncoding::kNone;
-    if (mUseSparse) {
-      flags |= CMVEncoding::kSparse;
-    }
-    if (mUseCompressionHuffman) {
-      flags |= CMVEncoding::kZigzag | CMVEncoding::kHuffman;
-    } else if (mUseCompressionVarint) {
-      flags |= CMVEncoding::kZigzag | CMVEncoding::kVarint;
+    pc.outputs().adoptContainer(Output{gDataOriginTPC, mDataDescrOut[currentOutLane], header::DataHeader::SubSpecificationType{cru}}, std::move(cmvs));
+  }
+
+  void sendOrbitInfo(o2::framework::ProcessingContext& pc, const unsigned int outLane, const uint64_t orbitInfo)
+  {
+    pc.outputs().snapshot(Output{gDataOriginTPC, mOrbitDescrOut[outLane], header::DataHeader::SubSpecificationType{outLane}}, orbitInfo);
+  }
+
+  void forwardOrbitInfo(o2::framework::ProcessingContext& pc, const bool currentBuffer, const unsigned int relTF, const unsigned int currentOutLane)
+  {
+    if (mOrbitInfoForwarded[currentBuffer][relTF]) {
+      return;
     }
-    // Delta coding is only applied for the dense (non-sparse) path with a value compressor
-    if (!(flags & CMVEncoding::kSparse) && (flags & (CMVEncoding::kVarint | CMVEncoding::kHuffman))) {
-      flags |= CMVEncoding::kDelta;
+
+    for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+      auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+      const unsigned int cru = hdr->subSpecification >> 7;
+      if (!std::binary_search(mCRUs.begin(), mCRUs.end(), cru)) {
+        continue;
+      }
+
+      sendOrbitInfo(pc, currentOutLane, pc.inputs().get<uint64_t>(ref));
+      mOrbitInfoForwarded[currentBuffer][relTF] = true;
+      break;
     }
-    return flags;
   }
 
-  /// Create a fresh in-memory TTree for the next aggregation interval.
-  /// Uses a single CMVPerTFCompressed branch whenever any compression is active,
-  /// or a raw CMVPerTF branch when no compression flags are set.
-  void initIntervalTree()
+  void forwardEOSData(o2::framework::ProcessingContext& pc)
   {
-    mIntervalTree = std::make_unique<TTree>("ccdb_object", "ccdb_object");
-    mIntervalTree->SetAutoSave(0);
-    mIntervalTree->SetDirectory(nullptr);
-    if (buildCompressionFlags() != CMVEncoding::kNone) {
-      mIntervalTree->Branch("CMVPerTFCompressed", &mCurrentCompressedTF);
-    } else {
-      mIntervalTree->Branch("CMVPerTF", &mCurrentTF);
+    const unsigned int currentOutLane = mCurrentOutLane;
+
+    if (mSendOutputStartInfo[mBuffer] && (mTFStart[mBuffer] >= 0)) {
+      mSendOutputStartInfo[mBuffer] = false;
+      pc.outputs().snapshot(Output{gDataOriginTPC, getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{currentOutLane}}, mTFStart[mBuffer]);
+    }
+
+    if (mSendCCDBOutputOrbitReset[currentOutLane] && mSendCCDBOutputGRPECS[currentOutLane]) {
+      mSendCCDBOutputOrbitReset[currentOutLane] = false;
+      mSendCCDBOutputGRPECS[currentOutLane] = false;
+      pc.outputs().snapshot(Output{gDataOriginTPC, getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{currentOutLane}}, dataformats::Pair<long, int>{o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS(), o2::base::GRPGeomHelper::instance().getNHBFPerTF()});
+    }
+
+    if (!mOrbitInfoForwarded[mBuffer].empty()) {
+      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+        auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+        const unsigned int cru = hdr->subSpecification >> 7;
+        if (!std::binary_search(mCRUs.begin(), mCRUs.end(), cru)) {
+          continue;
+        }
+        sendOrbitInfo(pc, currentOutLane, pc.inputs().get<uint64_t>(ref));
+        break;
+      }
+    }
+
+    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+      auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+      const unsigned int cru = hdr->subSpecification >> 7;
+      if (!std::binary_search(mCRUs.begin(), mCRUs.end(), cru)) {
+        continue;
+      }
+      sendOutput(pc, currentOutLane, cru, pc.inputs().get<pmr::vector<uint16_t>>(ref));
     }
   }
 
   void clearBuffer(const bool currentBuffer)
   {
-    // resetting received CRUs
+    // reset per-CRU received flags so the next interval can accept data from all CRUs again
     for (auto& crusMap : mProcessedCRUs[currentBuffer]) {
       for (auto& it : crusMap) {
         it.second = false;
       }
     }
 
-    mProcessedTFs[currentBuffer] = 0; // reset processed TFs for next aggregation interval
+    mProcessedTFs[currentBuffer] = 0;
     std::fill(mProcessedCRU[currentBuffer].begin(), mProcessedCRU[currentBuffer].end(), 0);
     std::fill(mOrbitInfoForwarded[currentBuffer].begin(), mOrbitInfoForwarded[currentBuffer].end(), false);
 
-    // set integration range for next integration interval
     mTFStart[mBuffer] = mTFEnd[!mBuffer] + 1;
     mTFEnd[mBuffer] = mTFStart[mBuffer] + getNRealTFs() - 1;
 
-    // switch buffer
+    // switch buffer and advance output lane
     mBuffer = !mBuffer;
+    mCurrentOutLane = ++mCurrentOutLane % mOutLanes;
   }
 
-  void checkIntervalsForMissingData(o2::framework::ProcessingContext& pc, const bool currentBuffer, const long relTF, const uint32_t tf)
+  void checkIntervalsForMissingData(o2::framework::ProcessingContext& pc, const bool currentBuffer, const long relTF, const unsigned int currentOutLane, const uint32_t tf)
   {
     if (!(mProcessedTotalData++ % mCheckEveryNData)) {
-      LOGP(info, "Checking for dropped packages...");
+      LOGP(detail, "Checking for dropped packages...");
 
-      // if last buffer has smaller time range check the whole last buffer
+      // if the last buffer has a smaller time range than expected, flush its remaining uncompleted TFs
       if ((mTFStart[currentBuffer] > mTFStart[!currentBuffer]) && (relTF > mNTFsDataDrop)) {
         LOGP(warning, "Checking last buffer from {} to {}", mStartNTFsDataDrop[!currentBuffer], mProcessedCRU[!currentBuffer].size());
-        checkMissingData(pc, !currentBuffer, mStartNTFsDataDrop[!currentBuffer], mProcessedCRU[!currentBuffer].size());
-        LOGP(info, "All empty TFs for TF {} for current buffer filled with dummy and sent. Clearing buffer", tf);
-        sendOutput(pc.outputs(), tf);
-        finishInterval(pc, !currentBuffer, tf);
+        const unsigned int lastLane = (currentOutLane == 0) ? (mOutLanes - 1) : (currentOutLane - 1);
+        checkMissingData(pc, !currentBuffer, mStartNTFsDataDrop[!currentBuffer], mProcessedCRU[!currentBuffer].size(), lastLane);
+        LOGP(detail, "All empty TFs for TF {} for current buffer filled with dummy and sent. Clearing buffer", tf);
+        finishInterval(pc, lastLane, !currentBuffer, tf);
       }
 
       const int tfEndCheck = std::clamp(static_cast<int>(relTF) - mNTFsDataDrop, 0, static_cast<int>(mProcessedCRU[currentBuffer].size()));
-      LOGP(info, "Checking current buffer from {} to {}", mStartNTFsDataDrop[currentBuffer], tfEndCheck);
-      checkMissingData(pc, currentBuffer, mStartNTFsDataDrop[currentBuffer], tfEndCheck);
+      LOGP(detail, "Checking current buffer from {} to {}", mStartNTFsDataDrop[currentBuffer], tfEndCheck);
+      checkMissingData(pc, currentBuffer, mStartNTFsDataDrop[currentBuffer], tfEndCheck, currentOutLane);
       mStartNTFsDataDrop[currentBuffer] = tfEndCheck;
     }
   }
 
-  void checkMissingData(o2::framework::ProcessingContext& pc, const bool currentBuffer, const int startTF, const int endTF)
+  void checkMissingData(o2::framework::ProcessingContext& pc, const bool currentBuffer, const int startTF, const int endTF, const unsigned int outLane)
   {
     for (int iTF = startTF; iTF < endTF; ++iTF) {
       if (mProcessedCRU[currentBuffer][iTF] != mCRUs.size()) {
-        LOGP(warning, "CRUs for rel. TF: {}  curr TF {} are missing! Processed {} CRUs out of {}", iTF, mTFStart[currentBuffer] + iTF, mProcessedCRU[currentBuffer][iTF], mCRUs.size());
+        LOGP(warning, "CRUs for lane {} rel. TF: {} curr TF {} are missing! Processed {} CRUs out of {}", outLane, iTF, mTFStart[currentBuffer] + static_cast<long>(iTF) * mNTFsBuffer, mProcessedCRU[currentBuffer][iTF], mCRUs.size());
         ++mProcessedTFs[currentBuffer];
         mProcessedCRU[currentBuffer][iTF] = mCRUs.size();
 
-        // find missing CRUs and leave their interval slots empty (zero-filled)
+        // send empty payloads for missing CRUs so the aggregate lane sees a complete set
         for (auto& it : mProcessedCRUs[currentBuffer][iTF]) {
           if (!it.second) {
             it.second = true;
+            sendOutput(pc, outLane, it.first, pmr::vector<uint16_t>());
           }
         }
 
-        // leave orbit/BC as zero placeholder for missing TFs
-        mOrbitInfoForwarded[currentBuffer][iTF] = true;
+        // send zero orbit placeholder for missing TF so the aggregate lane can still reconstruct timing
+        if (!mOrbitInfoForwarded[currentBuffer][iTF]) {
+          sendOrbitInfo(pc, outLane, 0);
+          mOrbitInfoForwarded[currentBuffer][iTF] = true;
+        }
       }
     }
   }
 
-  void finishInterval(o2::framework::ProcessingContext& pc, const bool buffer, const uint32_t tf)
+  void finishInterval(o2::framework::ProcessingContext& pc, const unsigned int currentOutLane, const bool buffer, const uint32_t tf)
   {
     if (mNFactorTFs > 0) {
       mNFactorTFs = 0;
-      // ToDo: Find better fix
-      auto& deviceProxy = pc.services().get<FairMQDeviceProxy>();
-      if (deviceProxy.getNumOutputChannels() > 0) {
-        auto& state = deviceProxy.getOutputChannelState({0});
-        size_t oldest = std::numeric_limits<size_t>::max() - 1; // just set to really large value
+      // ToDo: Find better fix. Set oldestForChannel to a very large value so the DPL dispatcher does not block waiting for older TF data that will never arrive
+      for (unsigned int ilane = 0; ilane < mOutLanes; ++ilane) {
+        auto& deviceProxy = pc.services().get<FairMQDeviceProxy>();
+        auto& state = deviceProxy.getOutputChannelState({static_cast<int>(ilane)});
+        size_t oldest = std::numeric_limits<size_t>::max() - 1;
         state.oldestForChannel = {oldest};
       }
     }
 
-    LOGP(info, "All TFs {} for current buffer received. Clearing buffer", tf);
+    LOGP(detail, "All TFs {} for current buffer received. Clearing buffer", tf);
     clearBuffer(buffer);
     mStartNTFsDataDrop[buffer] = 0;
-
-    // reset per-interval state for the next aggregation interval
-    initIntervalTree();
-    mIntervalFirstTF = 0;
-    mIntervalTFCount = 0;
-    mCurrentTF = CMVPerTF{};
-    mCurrentCompressedTF = CMVPerTFCompressed{};
-    mTimestampStart = 0;
-    LOGP(info, "Everything cleared. Waiting for new data to arrive.");
-  }
-
-  void setTimestampCCDB(const long relTF, o2::framework::ProcessingContext& pc)
-  {
-    if (mUsePreciseTimestamp && !mTFInfo.second) {
-      return;
-    }
-    const auto& tinfo = pc.services().get<o2::framework::TimingInfo>();
-    const auto nOrbitsOffset = (relTF * mNTFsBuffer + (mNTFsBuffer - 1)) * mTFInfo.second;
-    mTimestampStart = mUsePreciseTimestamp
-                        ? (mTFInfo.first + (tinfo.firstTForbit - nOrbitsOffset) * o2::constants::lhc::LHCOrbitMUS * 0.001)
-                        : tinfo.creation;
-    LOGP(info, "Setting timestamp reset reference to: {}, at tfCounter: {}, firstTForbit: {}, NHBFPerTF: {}, relTF: {}, nOrbitsOffset: {}",
-         mTFInfo.first, tinfo.tfCounter, tinfo.firstTForbit, mTFInfo.second, relTF, nOrbitsOffset);
-  }
-
-  void sendOutput(DataAllocator& output, const uint32_t tf)
-  {
-    using timer = std::chrono::high_resolution_clock;
-
-    if (mIntervalTFCount == 0) {
-      LOGP(warning, "CMV interval is empty at sendOutput, skipping");
-      return;
-    }
-
-    // attach interval metadata to the TTree (stored once per tree)
-    mIntervalTree->GetUserInfo()->Clear();
-    mIntervalTree->GetUserInfo()->Add(new TParameter<long>("firstTF", mIntervalFirstTF));
-    mIntervalTree->GetUserInfo()->Add(new TParameter<long>("lastTF", mLastSeenTF));
-
-    LOGP(info, "CMVPerTF TTree: {} entries, firstTF={}, lastTF={}", mIntervalTFCount, mIntervalFirstTF, mLastSeenTF);
-    auto start = timer::now();
-
-    // write local ROOT file for debugging
-    if (mDumpCMVs) {
-      const std::string fname = fmt::format("CMV_timestamp{}.root", mTimestampStart);
-      try {
-        mCurrentTF.writeToFile(fname, mIntervalTree);
-        LOGP(info, "CMV debug file written to {}", fname);
-      } catch (const std::exception& e) {
-        LOGP(error, "Failed to write CMV debug file: {}", e.what());
-      }
-    }
-
-    if (!mSendCCDB) {
-      LOGP(warning, "CCDB output disabled, skipping upload!");
-      return;
-    }
-
-    const int nHBFPerTF = o2::base::GRPGeomHelper::instance().getNHBFPerTF();
-    // use the actual number of TFs in this interval (mIntervalTFCount) rather than mTimeFrames, so the CCDB validity end is correct for partial last intervals
-    const long timeStampEnd = mTimestampStart + static_cast<long>(mIntervalTFCount * mNTFsBuffer * nHBFPerTF * o2::constants::lhc::LHCOrbitMUS * 1e-3);
-
-    if (timeStampEnd <= mTimestampStart) {
-      LOGP(warning, "Invalid CCDB timestamp range start:{} end:{}, skipping upload!",
-           mTimestampStart, timeStampEnd);
-      return;
-    }
-
-    LOGP(info, "CCDB timestamp range start:{} end:{}", mTimestampStart, timeStampEnd);
-
-    o2::ccdb::CcdbObjectInfo ccdbInfoCMV(
-      "TPC/Calib/CMV",
-      "TTree",
-      "CMV.root",
-      {},
-      mTimestampStart,
-      timeStampEnd);
-
-    auto image = o2::ccdb::CcdbApi::createObjectImage((mIntervalTree.get()), &ccdbInfoCMV);
-    // trim TMemFile zero-padding: GetSize() is block-rounded, GetEND() is the actual file end
-    {
-      TMemFile mf("trim", image->data(), static_cast<Long64_t>(image->size()), "READ");
-      image->resize(static_cast<size_t>(mf.GetEND()));
-      mf.Close();
-    }
-    LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {}",
-         ccdbInfoCMV.getPath(), ccdbInfoCMV.getFileName(), image->size(),
-         ccdbInfoCMV.getStartValidityTimestamp(), ccdbInfoCMV.getEndValidityTimestamp());
-
-    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBCMV(), 0}, *image);
-    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBCMV(), 0}, ccdbInfoCMV);
-
-    auto stop = timer::now();
-    std::chrono::duration<float> elapsed = stop - start;
-    LOGP(info, "CMV CCDB serialisation time: {:.3f} s", elapsed.count());
+    mSendOutputStartInfo[buffer] = true;
   }
 };
 
-DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const unsigned int timeframes, const int firstTF, const bool sendCCDB = false, const bool usePreciseTimestamp = false, const int nTFsBuffer = 1)
+DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const unsigned int timeframes, const unsigned int outlanes, const int firstTF, const bool sendPrecisetimeStamp = false, const int nTFsBuffer = 1)
 {
   std::vector<InputSpec> inputSpecs;
   inputSpecs.emplace_back(InputSpec{"cmvsgroup", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, Lifetime::Sporadic});
   inputSpecs.emplace_back(InputSpec{"cmvorbit", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo()}, Lifetime::Sporadic});
 
   std::vector<OutputSpec> outputSpecs;
-  if (sendCCDB) {
-    outputSpecs.emplace_back(
-      ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload,
-                              TPCDistributeCMVSpec::getDataDescriptionCCDBCMV()},
-      Lifetime::Sporadic);
-    outputSpecs.emplace_back(
-      ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper,
-                              TPCDistributeCMVSpec::getDataDescriptionCCDBCMV()},
-      Lifetime::Sporadic);
+  outputSpecs.reserve(3 * outlanes);
+  for (unsigned int lane = 0; lane < outlanes; ++lane) {
+    outputSpecs.emplace_back(ConcreteDataTypeMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(lane)}, Lifetime::Sporadic);
+    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(lane), header::DataHeader::SubSpecificationType{lane}}, Lifetime::Sporadic);
+    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{lane}}, Lifetime::Sporadic);
+  }
+
+  // Only lane 0 fetches CCDB orbit-reset/GRPECS objects and broadcasts them to all aggregate lanes, the other distribute lanes do not need them, avoiding redundant CCDB requests
+  bool fetchCCDB = false;
+  if (sendPrecisetimeStamp && (ilane == 0)) {
+    fetchCCDB = true;
+    for (unsigned int lane = 0; lane < outlanes; ++lane) {
+      outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{lane}}, Lifetime::Sporadic);
+    }
   }
 
-  const bool fetchCCDB = usePreciseTimestamp;
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(fetchCCDB,                      // orbitResetTime
                                                                 fetchCCDB,                      // GRPECS=true
                                                                 false,                          // GRPLHCIF
@@ -593,25 +462,15 @@ DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uin
                                                                 o2::base::GRPGeomRequest::None, // geometry
                                                                 inputSpecs);
 
-  const std::string type = "cmv";
-  const auto id = fmt::format("tpc-distribute-{}-{:02}", type, ilane);
+  const auto id = fmt::format("tpc-distribute-cmv-{:02}", ilane);
   DataProcessorSpec spec{
     id.data(),
     inputSpecs,
     outputSpecs,
-    AlgorithmSpec{adaptFromTask<TPCDistributeCMVSpec>(crus, timeframes, nTFsBuffer, firstTF, sendCCDB, usePreciseTimestamp, ccdbRequest)},
-    Options{{"drop-data-after-nTFs", VariantType::Int, 0, {"Number of TFs after which to drop the data"}},
-            {"check-data-every-n", VariantType::Int, 0, {"Number of run function called after which to check for missing data (-1 for no checking, 0 for default checking)"}},
-            {"nFactorTFs", VariantType::Int, 1000, {"Number of TFs to skip for sending oldest TF"}},
-            {"dump-cmvs", VariantType::Bool, false, {"Dump CMVs to a local ROOT file for debugging"}},
-            {"use-sparse", VariantType::Bool, false, {"Sparse encoding (skip zero time bins). Alone: raw uint16 values. With --use-compression-varint: varint exact values. With --use-compression-huffman: Huffman exact values"}},
-            {"use-compression-varint", VariantType::Bool, false, {"Delta+zigzag+varint compression (all values). Combined with --use-sparse: sparse positions + varint encoded exact CMV values"}},
-            {"use-compression-huffman", VariantType::Bool, false, {"Huffman encoding. Combined with --use-sparse: sparse positions + Huffman-encoded exact CMV values"}},
-            {"cmv-zero-threshold", VariantType::Float, 0.f, {"Zero out CMV values whose float magnitude is below this threshold after optional integer rounding and before compression; 0 disables"}},
-            {"cmv-round-integers-threshold", VariantType::Int, 0, {"Round values to nearest integer ADC for |v| <= N ADC before compression; 0 disables"}},
-            {"cmv-dynamic-precision-mean", VariantType::Float, 1.f, {"Gaussian centre in |CMV| ADC where the strongest fractional bit trimming is applied"}},
-            {"cmv-dynamic-precision-sigma", VariantType::Float, 0.f, {"Gaussian width in ADC for smooth CMV fractional bit trimming; 0 disables"}}}}; // end DataProcessorSpec
-
+    AlgorithmSpec{adaptFromTask<TPCDistributeCMVSpec>(crus, timeframes, nTFsBuffer, outlanes, firstTF, ccdbRequest)},
+    Options{{"drop-data-after-nTFs", VariantType::Int, 0, {"Number of TFs after which to drop the data."}},
+            {"check-data-every-n", VariantType::Int, 0, {"Number of run function called after which to check for missing data (-1 for no checking, 0 for default checking)."}},
+            {"nFactorTFs", VariantType::Int, 1000, {"Number of TFs to skip for sending oldest TF."}}}};
   spec.rank = ilane;
   return spec;
 }
diff --git a/Detectors/TPC/workflow/src/tpc-aggregate-cmv.cxx b/Detectors/TPC/workflow/src/tpc-aggregate-cmv.cxx
new file mode 100644
index 0000000000000..32d2317c3b9b0
--- /dev/null
+++ b/Detectors/TPC/workflow/src/tpc-aggregate-cmv.cxx
@@ -0,0 +1,86 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <vector>
+#include <string>
+#include "Algorithm/RangeTokenizer.h"
+#include "Framework/WorkflowSpec.h"
+#include "Framework/ConfigParamSpec.h"
+#include "CommonUtils/ConfigurableParam.h"
+#include "TPCWorkflow/TPCAggregateCMVSpec.h"
+#include "Framework/CompletionPolicyHelpers.h"
+
+using namespace o2::framework;
+
+// customize the completion policy
+void customize(std::vector<o2::framework::CompletionPolicy>& policies)
+{
+  using o2::framework::CompletionPolicy;
+  policies.push_back(CompletionPolicyHelpers::defineByName("tpc-aggregate-*.*", CompletionPolicy::CompletionOp::Consume));
+}
+
+// we need to add workflow options before including Framework/runDataProcessing
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  const std::string cruDefault = "0-" + std::to_string(o2::tpc::CRU::MaxCRU - 1);
+
+  std::vector<ConfigParamSpec> options{
+    {"configFile", VariantType::String, "", {"Configuration file for configurable parameters"}},
+    {"timeframes", VariantType::Int, 2000, {"Number of TFs aggregated per calibration interval"}},
+    {"crus", VariantType::String, cruDefault.c_str(), {"List of CRUs, comma-separated ranges, e.g. 0-3,7,9-15"}},
+    {"input-lanes", VariantType::Int, 1, {"Number of aggregate pipelines set by --output-lanes in TPCDistributeCMVSpec"}},
+    {"use-precise-timestamp", VariantType::Bool, false, {"Use precise timestamp metadata from distribute when writing to CCDB"}},
+    {"enable-CCDB-output", VariantType::Bool, false, {"Send output to the CCDB populator"}},
+    {"n-TFs-buffer", VariantType::Int, 1, {"Buffer size that was set in TPCFLPCMVSpec"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon-separated key=value strings"}}};
+
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& config)
+{
+  using namespace o2::tpc;
+
+  // set up configuration
+  o2::conf::ConfigurableParam::updateFromFile(config.options().get<std::string>("configFile"));
+  o2::conf::ConfigurableParam::updateFromString(config.options().get<std::string>("configKeyValues"));
+  o2::conf::ConfigurableParam::writeINI("o2tpcaggregatecmv_configuration.ini");
+
+  const auto tpcCRUs = o2::RangeTokenizer::tokenize<int>(config.options().get<std::string>("crus"));
+  auto timeframes = static_cast<unsigned int>(config.options().get<int>("timeframes"));
+  int aggregateLanes = config.options().get<int>("input-lanes");
+  if (aggregateLanes <= 0) {
+    aggregateLanes = 1;
+  }
+  const bool usePreciseTimestamp = config.options().get<bool>("use-precise-timestamp");
+  const bool sendCCDB = config.options().get<bool>("enable-CCDB-output");
+
+  int nTFsBuffer = config.options().get<int>("n-TFs-buffer");
+  if (nTFsBuffer <= 0) {
+    nTFsBuffer = 1;
+  }
+
+  // convert total TFs per interval to number of buffered TFs
+  assert(timeframes >= static_cast<unsigned int>(nTFsBuffer));
+  timeframes /= static_cast<unsigned int>(nTFsBuffer);
+
+  const std::vector<uint32_t> rangeCRUs(tpcCRUs.begin(), tpcCRUs.end());
+
+  WorkflowSpec workflow;
+  workflow.reserve(static_cast<size_t>(aggregateLanes));
+  LOGP(info, "Starting CMV aggregate with {} lanes, {} timeframes, {} n-TFs-buffer", aggregateLanes, timeframes, nTFsBuffer);
+  for (int ilane = 0; ilane < aggregateLanes; ++ilane) {
+    workflow.emplace_back(getTPCAggregateCMVSpec(ilane, rangeCRUs, timeframes, sendCCDB, usePreciseTimestamp, nTFsBuffer));
+  }
+  return workflow;
+}
diff --git a/Detectors/TPC/workflow/src/tpc-distribute-cmv.cxx b/Detectors/TPC/workflow/src/tpc-distribute-cmv.cxx
index b6aaaa0a109ad..0fe780ebb16b3 100644
--- a/Detectors/TPC/workflow/src/tpc-distribute-cmv.cxx
+++ b/Detectors/TPC/workflow/src/tpc-distribute-cmv.cxx
@@ -38,9 +38,9 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"firstTF", VariantType::Int, -1, {"First time frame index. (if set to -1 the first TF will be automatically detected. Values < -1 are setting an offset for skipping the first TFs)"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"lanes", VariantType::Int, 1, {"Number of lanes of this device (CRUs are split per lane)"}},
-    {"use-precise-timestamp", VariantType::Bool, false, {"Use precise timestamp which can be used for writing to CCDB"}},
-    {"enable-CCDB-output", VariantType::Bool, false, {"Send output to the CCDB populator"}},
-    {"n-TFs-buffer", VariantType::Int, 1, {"Buffer which was defined in the TPCFLPCMVSpec."}}};
+    {"send-precise-timestamp", VariantType::Bool, false, {"Send precise timestamp information to the CMV aggregate workflow"}},
+    {"n-TFs-buffer", VariantType::Int, 1, {"Buffer which was defined in the TPCFLPCMVSpec."}},
+    {"output-lanes", VariantType::Int, 1, {"Number of parallel pipelines which will be used in the CMV aggregate device."}}};
   std::swap(workflowOptions, options);
 }
 
@@ -57,17 +57,18 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   const auto tpcCRUs = o2::RangeTokenizer::tokenize<int>(config.options().get<std::string>("crus"));
   const auto nCRUs = tpcCRUs.size();
   auto timeframes = static_cast<unsigned int>(config.options().get<int>("timeframes"));
+  const auto outlanes = static_cast<unsigned int>(config.options().get<int>("output-lanes"));
   const auto nLanes = static_cast<unsigned int>(config.options().get<int>("lanes"));
   const auto firstTF = static_cast<unsigned int>(config.options().get<int>("firstTF"));
-  const bool usePreciseTimestamp = config.options().get<bool>("use-precise-timestamp");
-  const bool sendCCDB = config.options().get<bool>("enable-CCDB-output");
+  const bool sendPrecisetimeStamp = config.options().get<bool>("send-precise-timestamp");
   int nTFsBuffer = config.options().get<int>("n-TFs-buffer");
   if (nTFsBuffer <= 0) {
     nTFsBuffer = 1;
   }
-  assert(timeframes >= nTFsBuffer);
-  timeframes /= nTFsBuffer;
-  LOGP(info, "Using {} timeframes as each TF contains {} CMVs", timeframes, nTFsBuffer);
+  assert(timeframes >= static_cast<unsigned int>(nTFsBuffer));
+  timeframes /= static_cast<unsigned int>(nTFsBuffer);
+  LOGP(info, "Using {} buffered CMV batches per interval with n-TFs-buffer={}", timeframes, nTFsBuffer);
+
   const auto crusPerLane = nCRUs / nLanes + ((nCRUs % nLanes) != 0);
   WorkflowSpec workflow;
   for (int ilane = 0; ilane < nLanes; ++ilane) {
@@ -77,8 +78,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
     }
     const auto last = std::min(tpcCRUs.end(), first + crusPerLane);
     const std::vector<uint32_t> rangeCRUs(first, last);
-    workflow.emplace_back(getTPCDistributeCMVSpec(ilane, rangeCRUs, timeframes, firstTF, sendCCDB, usePreciseTimestamp, nTFsBuffer));
+    workflow.emplace_back(getTPCDistributeCMVSpec(ilane, rangeCRUs, timeframes, outlanes, firstTF, sendPrecisetimeStamp, nTFsBuffer));
   }
 
   return workflow;
-}
\ No newline at end of file
+}

From dd8e9c1f8dc229d7ee523076f83765c15c825193 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 30 Apr 2026 18:39:19 +0200
Subject: [PATCH 1681/1764] ITS: update Pb-Pb vertex settings (#15341)

* ITS: update Pb-Pb vertex settings

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Refine geometrical cut values in TrackingConfigParam.h

Updated floating-point values in TrackingConfigParam.h for precision.

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITStracking/TrackingConfigParam.h  | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index acb55eb1cf993..1d997ef12147a 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -29,16 +29,16 @@ struct VertexerParamConfig : public o2::conf::ConfigurableParamHelper<VertexerPa
   // geometrical cuts for tracklet selection for Pb-Pb
   float zCut = 0.002f;
   float phiCut = 0.005f;
-  float pairCut = 0.0211211f;
-  float clusterCut = 0.4275412f;
-  float coarseZWindow = 0.6521316f;
-  float seedDedupZCut = 0.1461061f;
-  float refitDedupZCut = 0.1873750f;
-  float duplicateZCut = 0.7985643f;
-  float finalSelectionZCut = 0.2932624f;
-  float duplicateDistance2Cut = 0.0223001f;
+  float pairCut = 0.017321f;
+  float clusterCut = 0.170048f;
+  float coarseZWindow = 0.055458f;
+  float seedDedupZCut = 0.116685f;
+  float refitDedupZCut = 0.039855f;
+  float duplicateZCut = 0.200097f;
+  float finalSelectionZCut = 0.034535f;
+  float duplicateDistance2Cut = 0.005117f;
   float tanLambdaCut = 0.002f; // tanLambda = deltaZ/deltaR
-  float nSigmaCut = 0.0479011f;
+  float nSigmaCut = 0.0164651f;
   float maxZPositionAllowed = 25.f; // 4x sZ of the beam
 
   // Artefacts selections

From 52c78b98b16dfd32f2aadf0275b9169a1fa20dd8 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 30 Apr 2026 14:33:15 +0200
Subject: [PATCH 1682/1764] Optionally produce HistoManager file and pdf report
 + lot of fixes.

Add HistoManager class: TObjArray-based histos and graph container.

Extra options for o2-check-resid-workfow:
--no-tree : skip writing residuals tree ([checkresid.outname].root)
--no-hist : skip writing file with HistoManager ([checkresid.outname]_hman.root)
--draw-report: draw pdf report (([checkresid.outname]_hman.pdf)

Option --draw-external-only to use the workflow for drawing of already saved HistoManager files:
They should be provided as comma-separated list "checkresid.ext_hm_list=<file1>,..<fileN>;" passed
as configurableParam. The legend will bear the filename unless for every external file the labels are passed
as "checkresid.ext_leg_list=<name1>,..<nameN>;".

External HistoManager files can be also provided for overlay drawing on top of the standard report of the data
being processed.
---
 .../study/CMakeLists.txt                      |   4 +-
 .../GlobalTrackingStudy/CheckResidConfig.h    |  24 +-
 .../{CheckResid.h => CheckResidSpec.h}        |   2 +-
 .../GlobalTrackingStudy/HistoManager.h        |  93 ++++
 .../{CheckResid.cxx => CheckResidSpec.cxx}    | 522 +++++++++++++++---
 .../study/src/GlobalTrackingStudyLinkDef.h    |   2 +
 .../study/src/HistoManager.cxx                | 505 +++++++++++++++++
 .../study/src/check-resid-workflow.cxx        |  28 +-
 8 files changed, 1098 insertions(+), 82 deletions(-)
 rename Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/{CheckResid.h => CheckResidSpec.h} (91%)
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/HistoManager.h
 rename Detectors/GlobalTrackingWorkflow/study/src/{CheckResid.cxx => CheckResidSpec.cxx} (50%)
 create mode 100644 Detectors/GlobalTrackingWorkflow/study/src/HistoManager.cxx

diff --git a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
index df42af503db46..4ee9f2f314a08 100644
--- a/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
+++ b/Detectors/GlobalTrackingWorkflow/study/CMakeLists.txt
@@ -25,8 +25,9 @@ o2_add_library(GlobalTrackingStudy
                        src/TrackMCStudyConfig.cxx
                        src/TrackMCStudyTypes.cxx
                        src/TPCClusSelector.cxx
-                       src/CheckResid.cxx
+                       src/CheckResidSpec.cxx
                        src/CheckResidConfig.cxx
+                       src/HistoManager.cxx
                PUBLIC_LINK_LIBRARIES O2::GlobalTracking
                                      O2::GlobalTrackingWorkflowReaders
                                      O2::GlobalTrackingWorkflowHelpers
@@ -42,6 +43,7 @@ o2_target_root_dictionary(GlobalTrackingStudy
                                   include/GlobalTrackingStudy/TrackMCStudyTypes.h
                                   include/GlobalTrackingStudy/CheckResidTypes.h
                                   include/GlobalTrackingStudy/CheckResidConfig.h
+                                  include/GlobalTrackingStudy/HistoManager.h
                           LINKDEF src/GlobalTrackingStudyLinkDef.h
 )
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
index 2a07eaf87930f..09ebba2d2e3f2 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidConfig.h
@@ -21,7 +21,8 @@ struct CheckResidConfig : o2::conf::ConfigurableParamHelper<CheckResidConfig> {
   int minTPCCl = 60;
   int minITSCl = 7;
   float minPt = 0.4f;
-  float maxPt = 100.f;
+  float maxPt = 50.f;
+  float maxTgl = 2.f;
   float rCompIBOB = 12.f;
 
   bool pvcontribOnly = true;
@@ -34,6 +35,27 @@ struct CheckResidConfig : o2::conf::ConfigurableParamHelper<CheckResidConfig> {
   float refitPVMV = false;
   float refitPVIniScale = 100.f;
 
+  std::string outname{"checkResid"};
+  // histogram settings
+  int nBinsRes = 100;
+  int nBinsPhi = 30;
+  int nBinsZ = 20;
+  int nBinsPt = 15;
+  int nBinsTgl = 20;
+  int minHistoStat2Fit = 1000;
+  float maxPull = 4;
+  float zranges[8] = {10.f, 15.f, 15.f, 15.f, 40.f, 40.f, 74.f, 74.f};
+  float maxDYZ[8] = {0.03, 0.015, 0.01, 0.01, 0.08, 0.08, 0.12, 0.1};
+  float maxDPar[5] = {0.15, 0.15, 0.015, 0.015, 1.};
+  // drawing settings
+  float resMMLrY[8] = {0.003, 0.003, 0.003, 0.003, 0.005, 0.005, 0.005, 0.005};
+  float resMMLrZ[8] = {0.002, 0.0015, 0.0015, 0.0015, 0.005, 0.005, 0.005, 0.005};
+  float resMMPar[5] = {0.03, 0.01, 0.005, 0.001, 0.5};
+  //
+  // string with existing histomanagers files to draw (comma or semicolon separated) and optional legends
+  std::string ext_hm_list{};
+  std::string ext_leg_list{};
+
   O2ParamDef(CheckResidConfig, "checkresid");
 };
 } // namespace o2::checkresid
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidSpec.h
similarity index 91%
rename from Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h
rename to Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidSpec.h
index baba1a1d4d765..fceba6cb000fd 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResid.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidSpec.h
@@ -19,7 +19,7 @@
 namespace o2::checkresid
 {
 /// create a processor spec
-o2::framework::DataProcessorSpec getCheckResidSpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool useMC /*, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts*/);
+o2::framework::DataProcessorSpec getCheckResidSpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool drawOnly);
 
 } // namespace o2::checkresid
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/HistoManager.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/HistoManager.h
new file mode 100644
index 0000000000000..eb9cf6876333e
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/HistoManager.h
@@ -0,0 +1,93 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef _O2_HISTOMANAGER_H_
+#define _O2_HISTOMANAGER_H_
+
+#include <string>
+#include <Rtypes.h>
+#include "TObjArray.h"
+
+class TH1;
+class TH2;
+class TH1F;
+class TH2F;
+class TProfile;
+class TGraph;
+class TFile;
+
+namespace o2
+{
+
+class HistoManager : public TObjArray
+{
+ public:
+  HistoManager(const std::string& dirname = "", const std::string& fname = "histoman.root", bool load = kFALSE, const std::string& prefix = "");
+  ~HistoManager() override { Delete(); }
+
+  HistoManager* createClone(const std::string& prefix) const;
+  void addPrefix(const std::string& pref = "");
+
+  int getNHistos() const { return mNHistos; }
+  TGraph* getGraph(int id) const;
+  TH1* getHisto(int id) const;
+  TH1* getHisto(const std::string& name) const;
+  TH1F* getHisto1F(int id) const;
+  TH2F* getHisto2F(int id) const;
+  TProfile* getHistoP(int id) const;
+
+  int addHisto(TH1* histo, int at = -1);
+  int addGraph(TGraph* gr, int at = -1);
+  void delHisto(int at);
+
+  void setFile(TFile* file);
+  void setFileName(const std::string& fname);
+  const std::string& getFileName() const { return mDefName; }
+  void setDirName(const std::string& name) { mDirName = name; }
+  const std::string& getDirName() const { return mDirName; }
+
+  void reset();
+  void write(TFile* file = nullptr);
+  int write(const std::string& flname)
+  {
+    setFileName(flname);
+    write();
+    return 0;
+  }
+
+  void addHistos(const HistoManager* hm, Double_t c1 = 1.);
+  void divideHistos(const HistoManager* hm);
+  void multiplyHistos(const HistoManager* hm);
+  void scaleHistos(Double_t c1 = 1.);
+  void setColor(int tcolor = 1);
+  void setMarkerStyle(Style_t mstyle = 1, Size_t msize = 1);
+  void setMarkerSize(Size_t msize = 1);
+  void sumw2();
+  int load(const std::string& fname, const std::string& dirname = "");
+
+  void purify(bool emptyToo = kFALSE);
+
+  void Print(Option_t* option = "") const override;
+  void Clear(Option_t* option = "") override;
+  void Delete(Option_t* option = "") override;
+  void Compress() override;
+
+ private:
+  int mNHistos{0};        //! Number of histograms defined
+  std::string mDefName{}; //! Default file name
+  std::string mDirName{}; //! Directory name in the output file
+
+  ClassDefOverride(HistoManager, 0);
+};
+
+} // namespace o2
+
+#endif // _O2_HISTOMANAGER_H_
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
similarity index 50%
rename from Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
rename to Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
index dc002489c24e2..6f3055aa00806 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResid.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "GlobalTrackingStudy/CheckResid.h"
+#include "GlobalTrackingStudy/CheckResidSpec.h"
 #include "GlobalTrackingStudy/CheckResidTypes.h"
 #include "GlobalTrackingStudy/CheckResidConfig.h"
 #include <vector>
@@ -27,6 +27,7 @@
 #include "SimulationDataFormat/MCUtils.h"
 #include "CommonUtils/NameConf.h"
 #include "Framework/ConfigParamRegistry.h"
+#include "Framework/ControlService.h"
 #include "Framework/CCDBParamSpec.h"
 #include "Framework/DeviceSpec.h"
 #include "DataFormatsITSMFT/DPLAlpideParam.h"
@@ -38,6 +39,18 @@
 #include "CommonUtils/TreeStreamRedirector.h"
 #include "ReconstructionDataFormats/VtxTrackRef.h"
 #include "DetectorsVertexing/PVertexer.h"
+#include "GlobalTrackingStudy/HistoManager.h"
+#include <TROOT.h>
+#include <TStyle.h>
+#include <TLatex.h>
+#include <TCanvas.h>
+#include <TLegend.h>
+#include <TLegendEntry.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TProfile.h>
+#include <TGraph.h>
+#include <TF1.h>
 #ifdef WITH_OPENMP
 #include <omp.h>
 #endif
@@ -62,14 +75,9 @@ using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 class CheckResidSpec : public Task
 {
  public:
-  CheckResidSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool useMC /*, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts*/)
-    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mUseMC(useMC)
+  CheckResidSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool drawOnly)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mDrawOnly(drawOnly)
   {
-    /*
-    mTPCCorrMapsLoader.setLumiScaleType(sclOpts.lumiType);
-    mTPCCorrMapsLoader.setLumiScaleMode(sclOpts.lumiMode);
-    mTPCCorrMapsLoader.setCheckCTPIDCConsistency(sclOpts.checkCTPIDCconsistency);
-    */
   }
   ~CheckResidSpec() final = default;
   void init(InitContext& ic) final;
@@ -83,6 +91,10 @@ class CheckResidSpec : public Task
   bool refitPV(o2::dataformats::PrimaryVertex& pv, int vid);
   bool refitITStrack(o2::track::TrackParCov& track, GTrackID gid);
   bool processITSTrack(const o2::its::TrackITS& iTrack, const o2::dataformats::PrimaryVertex& pv, o2::checkresid::Track& resTrack);
+  void bookHistos();
+  void fillHistos(const o2::checkresid::Track& trc);
+  void postProcessHistos();
+  void drawHistos();
 
   o2::globaltracking::RecoContainer* mRecoData = nullptr;
   int mNThreads = 1;
@@ -94,30 +106,85 @@ class CheckResidSpec : public Task
   o2::vertexing::PVertexer mVertexer;
   std::shared_ptr<DataRequest> mDataRequest;
   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
-  bool mUseMC{false}; ///< MC flag
   std::unique_ptr<o2::utils::TreeStreamRedirector> mDBGOut;
   GTrackID::mask_t mTracksSrc{};
+
+  bool mDrawOnly = false;
+  bool mDraw = false;
+  bool mFillHistos = true;
+  bool mFillTree = true;
+  std::vector<std::unique_ptr<o2::HistoManager>> mHManV{};
+  o2::HistoManager* mHMan = nullptr;
 };
 
 void CheckResidSpec::init(InitContext& ic)
 {
-  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
+  mDraw = true;
+  if (!mDrawOnly) {
+    mDraw = ic.options().get<bool>("draw-report");
+    mFillHistos = !ic.options().get<bool>("no-hist");
+    mFillTree = !ic.options().get<bool>("no-tree");
+    mNThreads = ic.options().get<int>("nthreads");
+  }
+  const auto& params = o2::checkresid::CheckResidConfig::Instance();
   int lane = ic.services().get<const o2::framework::DeviceSpec>().inputTimesliceId;
   int maxLanes = ic.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices;
-  std::string dbgnm = maxLanes == 1 ? "checkResid.root" : fmt::format("checkResid_t{}.root", lane);
-  mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(dbgnm.c_str(), "recreate");
-  mNThreads = ic.options().get<int>("nthreads");
+  std::string nm = params.outname;
+  if (maxLanes > 1) {
+    o2::conf::ConfigurableParam::updateFromString(fmt::format("checkresid.outname={}_{}", nm, lane));
+  }
+  if (mDraw) {
+    mFillHistos = true;
+  }
+  if (!mDrawOnly && mFillHistos) {
+    bookHistos();
+  }
+  if (!params.ext_hm_list.empty()) {
+    auto vecNames = o2::utils::Str::tokenize(params.ext_hm_list, ',');
+    auto vecLegends = o2::utils::Str::tokenize(params.ext_leg_list, ',');
+    bool useLeg = true;
+    if (vecNames.size() != vecLegends.size()) {
+      LOGP(warn, "{} legend names provided for {} external histomanagers, will use file names as legends", vecLegends.size(), vecNames.size());
+      useLeg = false;
+    }
+    int cntH = 0;
+    for (const auto& vn : vecNames) {
+      LOGP(info, "Loading external HistoManager {}", vn);
+      mHManV.emplace_back() = std::make_unique<o2::HistoManager>("", vn, true);
+      auto hm = mHManV.back().get();
+      if (!hm) {
+        LOGP(error, "Failed to load histograms from {}", vn);
+        mHManV.pop_back();
+      } else {
+        hm->SetName(useLeg ? vecLegends[cntH].c_str() : vn.c_str());
+      }
+      cntH++;
+    }
+  }
+  if (mDrawOnly) {
+    return;
+  }
+  o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
 #ifndef WITH_OPENMP
   if (mNThreads > 1) {
     LOGP(warn, "No OpenMP");
   }
   mNThreads = 1;
 #endif
-  // mTPCCorrMapsLoader.init(ic);
+  if (mFillTree) {
+    nm += ".root";
+    mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(nm.c_str(), "recreate");
+  }
 }
 
 void CheckResidSpec::run(ProcessingContext& pc)
 {
+  if (mDrawOnly) {
+    drawHistos();
+    pc.services().get<ControlService>().endOfStream();
+    pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+    return;
+  }
   o2::globaltracking::RecoContainer recoData;
   mRecoData = &recoData;
   mRecoData->collectData(pc, *mDataRequest.get()); // select tracks of needed type, with minimal cuts, the real selected will be done in the vertexer
@@ -131,8 +198,6 @@ void CheckResidSpec::updateTimeDependentParams(ProcessingContext& pc)
 {
   o2::base::GRPGeomHelper::instance().checkUpdates(pc);
   pc.inputs().get<o2::dataformats::MeanVertexObject*>("meanvtx");
-  // mTPCVDriftHelper.extractCCDBInputs(pc);
-  // mTPCCorrMapsLoader.extractCCDBInputs(pc);
   static bool initOnceDone = false;
   if (!initOnceDone) { // this params need to be queried only once
     const auto& params = o2::checkresid::CheckResidConfig::Instance();
@@ -155,24 +220,6 @@ void CheckResidSpec::updateTimeDependentParams(ProcessingContext& pc)
     mVertexer.setMeanVertex(&mMeanVtx);
     mVertexer.initMeanVertexConstraint();
   }
-  bool updateMaps = false;
-  /*
-  if (mTPCCorrMapsLoader.isUpdated()) {
-    mTPCCorrMapsLoader.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (mTPCVDriftHelper.isUpdated()) {
-    LOGP(info, "Updating TPC fast transform map with new VDrift factor of {} wrt reference {} and DriftTimeOffset correction {} wrt {} from source {}",
-         mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift,
-         mTPCVDriftHelper.getVDriftObject().timeOffsetCorr, mTPCVDriftHelper.getVDriftObject().refTimeOffset,
-         mTPCVDriftHelper.getSourceName());
-    mTPCVDriftHelper.acknowledgeUpdate();
-    updateMaps = true;
-  }
-  if (updateMaps) {
-    mTPCCorrMapsLoader.updateVDrift(mTPCVDriftHelper.getVDriftObject().corrFact, mTPCVDriftHelper.getVDriftObject().refVDrift, mTPCVDriftHelper.getVDriftObject().getTimeOffset());
-  }
-  */
 }
 
 void CheckResidSpec::process()
@@ -249,14 +296,18 @@ void CheckResidSpec::process()
           continue;
         }
         const auto& trc = mRecoData->getTrackParam(vid);
+        const auto& itsTrack = mRecoData->getITSTrack(gidITS);
+        if (itsTrack.getNClusters() < params.minITSCl) {
+          continue;
+        }
         auto pt = trc.getPt();
         if (pt < params.minPt || pt > params.maxPt) {
           continue;
         }
-        const auto& itsTrack = mRecoData->getITSTrack(gidITS);
-        if (itsTrack.getNClusters() < params.minITSCl) {
+        if (std::abs(trc.getTgl()) > params.maxTgl) {
           continue;
         }
+
 #ifdef WITH_OPENMP
         auto& accum = slots[omp_get_thread_num()];
 #else
@@ -275,6 +326,9 @@ void CheckResidSpec::process()
   for (const auto& accum : slots) {
     for (const auto& tr : accum) {
       (*mDBGOut) << "res" << "tr=" << tr << "\n";
+      if (mHMan) {
+        fillHistos(tr);
+      }
     }
   }
   LOGP(info, "processed {} PVs out of {} good vertices (out of {} in total), PV refits took {} mus, {} refits failed", nvUse, nvGood, nv, pvFitDuration, nvRefFail);
@@ -439,10 +493,10 @@ bool CheckResidSpec::refitPV(o2::dataformats::PrimaryVertex& pv, int vid)
   auto trackIndex = mRecoData->getPrimaryVertexMatchedTracks();
   int itr = vtref.getFirstEntry(), itLim = itr + vtref.getEntries();
   for (; itr < itLim; itr++) {
-    auto vid = trackIndex[itr];
-    if (vid.isPVContributor()) {
-      tracks.emplace_back().setPID(mRecoData->getTrackParam(vid).getPID());
-      gidsITS.push_back(mRecoData->getITSContributorGID(vid));
+    auto tid = trackIndex[itr];
+    if (tid.isPVContributor() && mRecoData->isTrackSourceLoaded(tid.getSource())) {
+      tracks.emplace_back().setPID(mRecoData->getTrackParam(tid).getPID());
+      gidsITS.push_back(mRecoData->getITSContributorGID(tid));
     }
   }
   ntr = tracks.size();
@@ -507,9 +561,345 @@ bool CheckResidSpec::refitITStrack(o2::track::TrackParCov& track, GTrackID gid)
   return true;
 }
 
+void CheckResidSpec::fillHistos(const o2::checkresid::Track& trc)
+{
+  const auto& params = CheckResidConfig::Instance();
+  int np = trc.points.size();
+  auto pt = trc.track.getPt();
+  if (pt < params.minPt || pt > params.maxPt) {
+    return;
+  }
+  for (int ip = 0; ip < np; ip++) {
+    const auto& pnt = trc.points[ip];
+    int il = pnt.lr >= 0 ? pnt.lr + 1 : 0;
+    mHMan->getHisto2F(il * 10 + 0 * 100)->Fill(pnt.phi, pnt.dy);
+    mHMan->getHisto2F(il * 10 + 0 * 100 + 1000)->Fill(pnt.z, pnt.dy);
+    mHMan->getHisto2F(il * 10 + 0 * 100 + 2000)->Fill(pt, pnt.dy);
+    mHMan->getHisto2F(il * 10 + 0 * 100 + 3000)->Fill(trc.track.getTgl(), pnt.dy);
+    if (pnt.sig2y > 0) {
+      auto pull = pnt.dy / std::sqrt(pnt.sig2y);
+      mHMan->getHisto2F(il * 10 + 0 * 100 + 5)->Fill(pnt.phi, pull);
+      mHMan->getHisto2F(il * 10 + 0 * 100 + 5 + 1000)->Fill(pnt.z, pull);
+      mHMan->getHisto2F(il * 10 + 0 * 100 + 5 + 2000)->Fill(pt, pull);
+      mHMan->getHisto2F(il * 10 + 0 * 100 + 5 + 3000)->Fill(trc.track.getTgl(), pull);
+    }
+    mHMan->getHisto2F(il * 10 + 1 * 100)->Fill(pnt.phi, pnt.dz);
+    mHMan->getHisto2F(il * 10 + 1 * 100 + 1000)->Fill(pnt.z, pnt.dz);
+    mHMan->getHisto2F(il * 10 + 1 * 100 + 2000)->Fill(pt, pnt.dz);
+    mHMan->getHisto2F(il * 10 + 1 * 100 + 3000)->Fill(trc.track.getTgl(), pnt.dz);
+    if (pnt.sig2z > 0) {
+      auto pull = pnt.dz / std::sqrt(pnt.sig2z);
+      mHMan->getHisto2F(il * 10 + 1 * 100 + 5)->Fill(pnt.phi, pull);
+      mHMan->getHisto2F(il * 10 + 1 * 100 + 5 + 1000)->Fill(pnt.z, pull);
+      mHMan->getHisto2F(il * 10 + 1 * 100 + 5 + 2000)->Fill(pt, pull);
+      mHMan->getHisto2F(il * 10 + 1 * 100 + 5 + 3000)->Fill(trc.track.getTgl(), pull);
+    }
+  }
+  //--------------
+  if (trc.trIBOut.getX() > 1 && std::abs(trc.trIBOut.getX() - trc.trOBInw.getX()) < 0.1) {
+    for (int ip = 0; ip < 5; ip++) {
+      float d = trc.trIBOut.getParam(ip) - trc.trOBInw.getParam(ip);
+      mHMan->getHisto2F(10000 + ip * 10)->Fill(trc.trIBOut.getPhiPos(), d);
+      mHMan->getHisto2F(11000 + ip * 10)->Fill(trc.trIBOut.getZ(), d);
+      mHMan->getHisto2F(12000 + ip * 10)->Fill(pt, d);
+      mHMan->getHisto2F(13000 + ip * 10)->Fill(trc.track.getTgl(), d);
+      float sg = trc.trIBOut.getCovarElem(ip, ip) + trc.trOBInw.getCovarElem(ip, ip);
+      if (sg > 0) {
+        auto pull = d / std::sqrt(sg);
+        mHMan->getHisto2F(10000 + ip * 10 + 5)->Fill(trc.trIBOut.getPhiPos(), pull);
+        mHMan->getHisto2F(11000 + ip * 10 + 5)->Fill(trc.trIBOut.getZ(), pull);
+        mHMan->getHisto2F(12000 + ip * 10 + 5)->Fill(pt, pull);
+        mHMan->getHisto2F(13000 + ip * 10 + 5)->Fill(trc.track.getTgl(), pull);
+      }
+    }
+  }
+}
+
+void CheckResidSpec::bookHistos()
+{
+  const auto& params = o2::checkresid::CheckResidConfig::Instance();
+  mHManV.emplace_back() = std::make_unique<o2::HistoManager>("", fmt::format("{}_hman.root", params.outname));
+  mHMan = mHManV.back().get();
+  mHMan->SetName(params.outname.c_str());
+  auto defLogAxis = [](float xMn, float xMx, int nbin) { // get array for log axis
+    if (xMn <= 0 || xMx <= xMn || nbin < 2) {
+      LOGP(fatal, "Wrong log axis request: xmin = {} xmax = {} nbins = {}", xMn, xMx, nbin);
+    }
+    auto dx = std::log(xMx / xMn) / nbin;
+    std::vector<double> xax(nbin + 1);
+    for (int i = 0; i <= nbin; i++) {
+      xax[i] = xMn * std::exp(dx * i);
+    }
+    return xax;
+  };
+  float minPt = std::max(0.1f, params.minPt), maxPt = std::min(50.f, params.maxPt);
+  auto ptax = defLogAxis(minPt, maxPt, params.nBinsPt);
+
+  for (int il = 0; il < 8; il++) {
+    std::string lrName = il == 0 ? "Vtx" : fmt::format("Lr{}", il - 1);
+    for (int iyz = 0; iyz < 2; iyz++) {
+      std::string dname = iyz == 0 ? "dy" : "dz", dtit = iyz == 0 ? "#DeltaY" : "#DeltaZ";
+      auto h2 = new TH2F(fmt::format("{}_{}_{}", dname, lrName, "phi").c_str(), fmt::format("{}_{{{}}} vs {};#phi;{}", dtit, lrName, "#phi", dtit).c_str(), params.nBinsPhi, 0, TMath::Pi() * 2, params.nBinsRes, -params.maxDYZ[il], params.maxDYZ[il]);
+      mHMan->addHisto(h2, il * 10 + iyz * 100);
+      auto h2p = new TH2F(fmt::format("{}_{}_{}_pull", dname, lrName, "phi").c_str(), fmt::format("pull {}_{{{}}} vs {};#phi; pull{}", dtit, lrName, "phi", dtit).c_str(), params.nBinsPhi, 0, TMath::Pi() * 2, params.nBinsRes, -params.maxPull, params.maxPull);
+      mHMan->addHisto(h2p, il * 10 + iyz * 100 + 5);
+
+      auto hz2 = new TH2F(fmt::format("{}_{}_{}", dname, lrName, "Z").c_str(), fmt::format("{}_{{{}}} vs {};Z;{}", dtit, lrName, "Z", dtit).c_str(), params.nBinsZ, -params.zranges[il], params.zranges[il], params.nBinsRes, -params.maxDYZ[il], params.maxDYZ[il]);
+      mHMan->addHisto(hz2, il * 10 + iyz * 100 + 1000);
+      auto hz2p = new TH2F(fmt::format("{}_{}_{}_pull", dname, lrName, "Z").c_str(), fmt::format("pull {}_{{{}}} vs {};Z; pull{}", dtit, lrName, "Z", dtit).c_str(), params.nBinsZ, -params.zranges[il], params.zranges[il], params.nBinsRes, -params.maxPull, params.maxPull);
+      mHMan->addHisto(hz2p, il * 10 + iyz * 100 + 5 + 1000);
+
+      auto hpt2 = new TH2F(fmt::format("{}_{}_{}", dname, lrName, "Pt").c_str(), fmt::format("{}_{{{}}} vs {};p_{{T}};{}", dtit, lrName, "p_{T}", dtit).c_str(), params.nBinsPt, ptax.data(), params.nBinsRes, -params.maxDYZ[il], params.maxDYZ[il]);
+      mHMan->addHisto(hpt2, il * 10 + iyz * 100 + 2000);
+      auto hpt2p = new TH2F(fmt::format("{}_{}_{}_pull", dname, lrName, "Pt").c_str(), fmt::format("pull {}_{{{}}} vs {};p_{{T}}; pull{}", dtit, lrName, "p_{T}", dtit).c_str(), params.nBinsPt, ptax.data(), params.nBinsRes, -params.maxPull, params.maxPull);
+      mHMan->addHisto(hpt2p, il * 10 + iyz * 100 + 5 + 2000);
+
+      auto htgl2 = new TH2F(fmt::format("{}_{}_{}", dname, lrName, "tgl").c_str(), fmt::format("{}_{{{}}} vs {};tg#lambda;{}", dtit, lrName, "tg#lambda", dtit).c_str(), params.nBinsTgl, -params.maxTgl, params.maxTgl, params.nBinsRes, -params.maxDYZ[il], params.maxDYZ[il]);
+      mHMan->addHisto(htgl2, il * 10 + iyz * 100 + 3000);
+      auto htgl2p = new TH2F(fmt::format("{}_{}_{}_pull", dname, lrName, "tgl").c_str(), fmt::format("pull {}_{{{}}} vs {};tg#lambda; pull{}", dtit, lrName, "tg#lambda", dtit).c_str(), params.nBinsTgl, -params.maxTgl, params.maxTgl, params.nBinsRes, -params.maxPull, params.maxPull);
+      mHMan->addHisto(htgl2p, il * 10 + iyz * 100 + 5 + 3000);
+    }
+  }
+
+  for (int ip = 0; ip < 5; ip++) {
+    auto h2 = new TH2F(fmt::format("dPar{}_IBOBphi", ip).c_str(), fmt::format("#Delta par{} IB-OB vs phi;#phi;#Delta par{}", ip, ip).c_str(), params.nBinsPhi, 0, TMath::Pi() * 2, params.nBinsRes, -params.maxDPar[ip], params.maxDPar[ip]);
+    mHMan->addHisto(h2, 10000 + ip * 10);
+    auto h2p = new TH2F(fmt::format("dPar{}_IBOBphi_pull", ip).c_str(), fmt::format("pull #Delta par{} IB-OB vs phi;#phi;pull #Delta par{}", ip, ip).c_str(), params.nBinsPhi, 0, TMath::Pi() * 2, params.nBinsRes, -params.maxPull, params.maxPull);
+    mHMan->addHisto(h2p, 10000 + ip * 10 + 5);
+
+    auto hz2 = new TH2F(fmt::format("dPar{}_IBOBz", ip).c_str(), fmt::format("#Delta par{} IB-OB vs Z;Z;#Delta par{}", ip, ip).c_str(), params.nBinsZ, -20., 20., params.nBinsRes, -params.maxDPar[ip], params.maxDPar[ip]);
+    mHMan->addHisto(hz2, 11000 + ip * 10);
+    auto hz2p = new TH2F(fmt::format("dPar{}_IBOBz_pull", ip).c_str(), fmt::format("pull #Delta par{} IB-OB vs Z;Z;pull #Delta par{}", ip, ip).c_str(), params.nBinsZ, -20., 20., params.nBinsRes, -params.maxPull, params.maxPull);
+    mHMan->addHisto(hz2p, 11000 + ip * 10 + 5);
+
+    auto hpt2 = new TH2F(fmt::format("dPar{}_IBOBpt", ip).c_str(), fmt::format("#Delta par{} IB-OB vs pT;p_{{T}};#Delta par{}", ip, ip).c_str(), params.nBinsPt, ptax.data(), params.nBinsRes, -params.maxDPar[ip], params.maxDPar[ip]);
+    mHMan->addHisto(hpt2, 12000 + ip * 10);
+    auto hpt2p = new TH2F(fmt::format("dPar{}_IBOBpt_pull", ip).c_str(), fmt::format("pull #Delta par{} IB-OB vs pT;p_{{T}};pull #Delta par{}", ip, ip).c_str(), params.nBinsPt, ptax.data(), params.nBinsRes, -params.maxPull, params.maxPull);
+    mHMan->addHisto(hpt2p, 12000 + ip * 10 + 5);
+
+    auto htgl2 = new TH2F(fmt::format("dPar{}_IBOBtgl", ip).c_str(), fmt::format("#Delta par{} IB-OB vs tg#lambda;tg#lambda;#Delta par{}", ip, ip).c_str(), params.nBinsTgl, -params.maxTgl, params.maxTgl, params.nBinsRes, -params.maxDPar[ip], params.maxDPar[ip]);
+    mHMan->addHisto(htgl2, 13000 + ip * 10);
+    auto htgl2p = new TH2F(fmt::format("dPar{}_IBOBtgl_pull", ip).c_str(), fmt::format("pull #Delta par{} IB-OB vs tg#lambda;tg#lambda;pull #Delta par{}", ip, ip).c_str(), params.nBinsTgl, -params.maxTgl, params.maxTgl, params.nBinsRes, -params.maxPull, params.maxPull);
+    mHMan->addHisto(htgl2p, 13000 + ip * 10 + 5);
+  }
+}
+
+void CheckResidSpec::postProcessHistos()
+{
+  printf("Fitting histos\n");
+  const auto& params = o2::checkresid::CheckResidConfig::Instance();
+  auto gs = new TF1("gs", "gaus", -1, 1);
+  TObjArray arr;
+  auto* histm = mHMan;
+  auto fitSlices = [&](int id) {
+    auto h2 = histm->getHisto2F(id);
+    if (!h2 || h2->GetEntries() < params.minHistoStat2Fit) {
+      return;
+    }
+    h2->FitSlicesY(gs, 0, -1, 0, "QNR", &arr);
+    arr.SetOwner(true);
+    TH1* hmean = (TH1*)arr.RemoveAt(1);
+    if (hmean) {
+      hmean->SetTitle(Form("<%s>", h2->GetTitle()));
+      histm->addHisto(hmean, id + 1);
+    }
+    TH1* hsig = (TH1*)arr.RemoveAt(2);
+    if (hsig) {
+      hsig->SetTitle(Form("#sigma(%s)", h2->GetTitle()));
+      histm->addHisto(hsig, id + 2);
+    }
+  };
+  for (int ioffs = 0; ioffs <= 3; ioffs++) { // vs phi, Z, pT, tgl
+    int offs = ioffs * 1000;
+    for (int iht = 0; iht < 2; iht++) { // resid, pull
+      int offsV = iht == 0 ? 0 : 5;
+      for (int il = 0; il < 8; il++) {
+        for (int iyz = 0; iyz < 2; iyz++) {
+          fitSlices(il * 10 + iyz * 100 + offsV + offs);
+        }
+      }
+      for (int ip = 0; ip < 5; ip++) {
+        fitSlices(10000 + ip * 10 + offsV + offs);
+      }
+    }
+  }
+  histm->write();
+  delete gs;
+}
+
+void CheckResidSpec::drawHistos()
+{
+  gROOT->SetBatch(true);
+  gStyle->SetTitleX(0.2);
+  gStyle->SetTitleY(0.88);
+  gStyle->SetTitleW(0.25);
+  gStyle->SetOptStat(0);
+  int nhm = mHManV.size();
+  std::array<unsigned int, 3> hcol{EColor::kRed, EColor::kBlue, EColor::kGreen + 2};
+  std::unique_ptr<TLegend> lg;
+  lg = std::make_unique<TLegend>(0.12, 0.13, 0.9, 0.13 + std::min(0.5f, nhm * 0.2f / 3.f));
+  lg->SetFillStyle(0);
+  lg->SetBorderSize(0);
+  for (int i = 0; i < nhm; i++) {
+    auto hman = mHManV[i].get();
+    if (!hman || hman->GetLast() < 1) {
+      continue;
+    }
+    hman->setMarkerStyle(20 + i + (i % 2) * 4, 0.5);
+    hman->setColor(hcol[i % hcol.size()]);
+    auto le = lg->AddEntry(hman->getHisto(1), hman->GetName(), "lp");
+    le->SetTextColor(hcol[i % hcol.size()]);
+  }
+  TCanvas cly("cly", "", 600, 800), clz("clz", "", 600, 800), clpar("clpar", "", 600, 800);
+  TCanvas czly("czly", "", 600, 800), czlz("czlz", "", 600, 800), czlpar("czlpar", "", 600, 800);
+  const auto& params = o2::checkresid::CheckResidConfig::Instance();
+
+  auto AddLabel = [](const char* txt, float x = 0.1, float y = 0.9, int color = kBlack, float size = 0.04) {
+    TLatex* lt = new TLatex(x, y, txt);
+    lt->SetNDC();
+    lt->SetTextColor(color);
+    lt->SetTextSize(size);
+    lt->Draw();
+    return lt;
+  };
+
+  auto drawResLr = [this](TCanvas& canv, int offs, const float resMM[8], bool logX) {
+    canv.Clear();
+    canv.Divide(2, 4);
+    int nh = this->mHManV.size();
+    for (int i = 0; i < 8; i++) {
+      canv.cd(i + 1);
+      bool same = false;
+      for (int j = 0; j < nh; j++) {
+        auto hman = this->mHManV[j].get();
+        if (!hman || hman->GetLast() < 1) {
+          continue;
+        }
+        if (auto histo = hman->getHisto(10 * i + offs)) {
+          histo->Draw(same ? "same" : "");
+          if (!same) {
+            histo->SetMinimum(-resMM[i]);
+            histo->SetMaximum(resMM[i]);
+            same = true;
+          }
+        }
+      }
+      gPad->SetGrid();
+      gPad->SetLogx(logX);
+    }
+  };
+
+  auto drawResPar = [this](TCanvas& canv, int offs, const float resMM[8], bool logX) {
+    canv.Clear();
+    canv.Divide(2, 3);
+    int nh = this->mHManV.size();
+    for (int i = 0; i < 5; i++) {
+      canv.cd(i + 1);
+      bool same = false;
+      for (int j = 0; j < nh; j++) {
+        auto hman = this->mHManV[j].get();
+        if (!hman || hman->GetLast() < 1) {
+          continue;
+        }
+        if (auto histo = hman->getHisto(10 * i + offs)) {
+          histo->Draw(same ? "same" : "");
+          if (!same) {
+            histo->SetMinimum(-resMM[i]);
+            histo->SetMaximum(resMM[i]);
+            same = true;
+          }
+        }
+      }
+      gPad->SetGrid();
+      gPad->SetLogx(logX);
+    }
+  };
+
+  cly.Print(Form("%s_hman.pdf[", params.outname.c_str()));
+  drawResLr(cly, 1, params.resMMLrY, false);
+  cly.cd(2);
+  lg->Draw();
+  AddLabel("Y residuals", 0.1, 0.95);
+  cly.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResLr(clz, 101, params.resMMLrZ, false);
+  clz.cd(2);
+  lg->Draw();
+  AddLabel("Z residuals", 0.1, 0.95);
+  clz.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResLr(czly, 1001, params.resMMLrY, false);
+  czly.cd(2);
+  lg->Draw();
+  AddLabel("Y residuals", 0.1, 0.95);
+  czly.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResLr(czlz, 1101, params.resMMLrZ, false);
+  czlz.cd(2);
+  lg->Draw();
+  AddLabel("Z residuals", 0.1, 0.95);
+  czlz.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResLr(czly, 2001, params.resMMLrY, true);
+  czly.cd(2);
+  lg->Draw();
+  AddLabel("Y residuals", 0.1, 0.95);
+  czly.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResLr(czlz, 2101, params.resMMLrZ, true);
+  czlz.cd(2);
+  lg->Draw();
+  AddLabel("Z residuals", 0.1, 0.95);
+  czlz.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResLr(czly, 3001, params.resMMLrY, false);
+  czly.cd(2);
+  lg->Draw();
+  AddLabel("Y residuals", 0.1, 0.95);
+  czly.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResLr(czlz, 3101, params.resMMLrZ, false);
+  czlz.cd(2);
+  lg->Draw();
+  AddLabel("Z residuals", 0.1, 0.95);
+  czlz.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResPar(clpar, 10001, params.resMMPar, false);
+  clpar.cd(6);
+  lg->Draw();
+  AddLabel("IB-OB tracks params differences at R = 12 cm", 0.2, 0.8);
+  clpar.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResPar(czlpar, 11001, params.resMMPar, false);
+  czlpar.cd(6);
+  lg->Draw();
+  AddLabel("IB-OB tracks params differences at R = 12 cm", 0.2, 0.8);
+  czlpar.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResPar(czlpar, 12001, params.resMMPar, true);
+  czlpar.cd(6);
+  lg->Draw();
+  AddLabel("IB-OB tracks params differences at R = 12 cm", 0.2, 0.8);
+  czlpar.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  drawResPar(czlpar, 13001, params.resMMPar, false);
+  czlpar.cd(6);
+  lg->Draw();
+  AddLabel("IB-OB tracks params differences at R = 12 cm", 0.2, 0.8);
+  czlpar.Print(Form("%s_hman.pdf", params.outname.c_str()));
+
+  cly.Print(Form("%s_hman.pdf]", params.outname.c_str()));
+}
+
 void CheckResidSpec::endOfStream(EndOfStreamContext& ec)
 {
   mDBGOut.reset();
+  if (mHManV.size()) {
+    postProcessHistos();
+  }
+  if (mDraw) {
+    drawHistos();
+  }
 }
 
 void CheckResidSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
@@ -517,14 +907,6 @@ void CheckResidSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   if (o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj)) {
     return;
   }
-  /*
-  if (mTPCVDriftHelper.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
-  if (mTPCCorrMapsLoader.accountCCDBInputs(matcher, obj)) {
-    return;
-  }
-  */
   if (matcher == ConcreteDataMatcher("GLO", "MEANVERTEX", 0)) {
     LOG(info) << "Imposing new MeanVertex: " << ((const o2::dataformats::MeanVertexObject*)obj)->asString();
     mMeanVtx = *(const o2::dataformats::MeanVertexObject*)obj;
@@ -538,33 +920,39 @@ void CheckResidSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   }
 }
 
-DataProcessorSpec getCheckResidSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool useMC /*, const o2::tpc::CorrectionMapsLoaderGloOpts& sclOpts*/)
+DataProcessorSpec getCheckResidSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool drawOnly)
 {
   std::vector<OutputSpec> outputs;
   auto dataRequest = std::make_shared<DataRequest>();
-  dataRequest->requestTracks(srcTracks, useMC);
-  dataRequest->requestClusters(srcClusters, useMC);
-  dataRequest->requestPrimaryVertices(useMC);
-  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
-                                                              true,                              // GRPECS=true
-                                                              true,                              // GRPLHCIF
-                                                              true,                              // GRPMagField
-                                                              true,                              // askMatLUT
-                                                              o2::base::GRPGeomRequest::Aligned, // geometry
-                                                              dataRequest->inputs,
-                                                              true);
-  dataRequest->inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
-  Options opts{
-    {"nthreads", VariantType::Int, 1, {"number of threads"}},
-  };
-  //  o2::tpc::VDriftHelper::requestCCDBInputs(dataRequest->inputs);
-  //  o2::tpc::CorrectionMapsLoader::requestCCDBInputs(dataRequest->inputs, opts, sclOpts);
+  if (!drawOnly) {
+    bool useMC = false;
+    dataRequest->requestTracks(srcTracks, useMC);
+    dataRequest->requestClusters(srcClusters, useMC);
+    dataRequest->requestPrimaryVertices(useMC);
+    dataRequest->inputs.emplace_back("meanvtx", "GLO", "MEANVERTEX", 0, Lifetime::Condition, ccdbParamSpec("GLO/Calib/MeanVertex", {}, 1));
+  }
+  auto ggRequest = drawOnly ? std::make_shared<o2::base::GRPGeomRequest>(false, false, false, false, false, o2::base::GRPGeomRequest::None, dataRequest->inputs) : std::make_shared<o2::base::GRPGeomRequest>(false,                             // orbitResetTime
+                                                                                                                                                                                                              true,                              // GRPECS=true
+                                                                                                                                                                                                              true,                              // GRPLHCIF
+                                                                                                                                                                                                              true,                              // GRPMagField
+                                                                                                                                                                                                              true,                              // askMatLUT
+                                                                                                                                                                                                              o2::base::GRPGeomRequest::Aligned, // geometry
+                                                                                                                                                                                                              dataRequest->inputs, true);
+  Options opts;
+  if (!drawOnly) {
+    opts = Options{
+      {"nthreads", VariantType::Int, 1, {"number of threads"}},
+      {"no-tree", VariantType::Bool, false, {"do not fill residuals tree"}},
+      {"no-hist", VariantType::Bool, false, {"do not fill residuals histograms"}},
+      {"draw-report", VariantType::Bool, false, {"fill residuals report"}},
+    };
+  }
 
   return DataProcessorSpec{
     "check-resid",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<CheckResidSpec>(dataRequest, ggRequest, srcTracks, useMC /*, sclOpts*/)},
+    AlgorithmSpec{adaptFromTask<CheckResidSpec>(dataRequest, ggRequest, srcTracks, drawOnly)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h b/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
index 416820fc9aebb..b1fe732fbefc4 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
+++ b/Detectors/GlobalTrackingWorkflow/study/src/GlobalTrackingStudyLinkDef.h
@@ -49,4 +49,6 @@
 #pragma link C++ class o2::checkresid::CheckResidConfig + ;
 #pragma link C++ class o2::conf::ConfigurableParamHelper < o2::checkresid::CheckResidConfig> + ;
 
+#pragma link C++ class o2::HistoManager + ;
+
 #endif
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/HistoManager.cxx b/Detectors/GlobalTrackingWorkflow/study/src/HistoManager.cxx
new file mode 100644
index 0000000000000..e57a78e4b202d
--- /dev/null
+++ b/Detectors/GlobalTrackingWorkflow/study/src/HistoManager.cxx
@@ -0,0 +1,505 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <TDirectory.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TProfile.h>
+#include <TGraph.h>
+#include <TF1.h>
+#include <TFile.h>
+#include <TKey.h>
+#include <TList.h>
+#include <TNamed.h>
+#include <TPaveStats.h>
+#include <TROOT.h>
+#include <TSystem.h>
+#include "Framework/Logger.h"
+#include "GlobalTrackingStudy/HistoManager.h"
+
+namespace o2
+{
+
+HistoManager::HistoManager(const std::string& dirname, const std::string& fname, bool load, const std::string& prefix) : mDirName(dirname)
+{
+  setFileName(fname);
+  if (load && !mDefName.empty()) {
+    int nh = this->load(fname, dirname);
+    LOGP(info, "HistoManager::load was requested: got {} histos from {}/{}", nh, fname, dirname);
+    if (!prefix.empty()) {
+      addPrefix(prefix);
+    }
+  }
+}
+
+HistoManager* HistoManager::createClone(const std::string& prefix) const
+{
+  auto* hm = static_cast<HistoManager*>(Clone());
+  hm->addPrefix(prefix);
+  for (int i = 0; i < GetLast() + 1; ++i) {
+    TObject* obj = hm->UncheckedAt(i);
+    if (!obj) {
+      continue;
+    }
+    if (auto* histo = dynamic_cast<TH1*>(obj)) {
+      histo->SetDirectory(nullptr);
+    }
+  }
+  hm->mNHistos = mNHistos;
+  hm->setFileName(mDefName);
+  hm->setDirName(mDirName);
+  return hm;
+}
+
+int HistoManager::addHisto(TH1* histo, int at)
+{
+  if (!histo) {
+    return mNHistos;
+  }
+  if (at < 0) {
+    at = mNHistos;
+  }
+  AddAtAndExpand(histo, at);
+  histo->SetDirectory(nullptr);
+  histo->SetUniqueID(at + 1);
+  return mNHistos++;
+}
+
+TGraph* HistoManager::getGraph(int id) const
+{
+  return id <= GetLast() ? dynamic_cast<TGraph*>(UncheckedAt(id)) : nullptr;
+}
+
+TH1* HistoManager::getHisto(int id) const
+{
+  return id <= GetLast() ? dynamic_cast<TH1*>(UncheckedAt(id)) : nullptr;
+}
+
+TH1* HistoManager::getHisto(const std::string& name) const
+{
+  return dynamic_cast<TH1*>(FindObject(name.c_str()));
+}
+
+TH1F* HistoManager::getHisto1F(int id) const
+{
+  return dynamic_cast<TH1F*>(UncheckedAt(id));
+}
+
+TH2F* HistoManager::getHisto2F(int id) const
+{
+  return dynamic_cast<TH2F*>(UncheckedAt(id));
+}
+
+TProfile* HistoManager::getHistoP(int id) const
+{
+  return dynamic_cast<TProfile*>(UncheckedAt(id));
+}
+
+int HistoManager::addGraph(TGraph* gr, int at)
+{
+  if (!gr) {
+    return mNHistos;
+  }
+  if (at < 0) {
+    at = mNHistos;
+  }
+  AddAtAndExpand(gr, at);
+  gr->SetUniqueID(at + 1);
+  return mNHistos++;
+}
+
+void HistoManager::Compress()
+{
+  TObjArray::Compress();
+  for (int i = 0; i < GetLast() + 1; ++i) {
+    if (TObject* histo = At(i)) {
+      histo->SetUniqueID(i + 1);
+    }
+  }
+}
+
+void HistoManager::write(TFile* file)
+{
+  if (!mNHistos) {
+    return;
+  }
+
+  bool localFile = kFALSE;
+  TFile* lfile = nullptr;
+  const char* dirName = nullptr;
+  if (file) {
+    lfile = file;
+  } else {
+    auto* tmpF = static_cast<TFile*>(gROOT->GetListOfFiles()->FindObject(mDefName.c_str()));
+    if (tmpF && tmpF->IsOpen()) {
+      TString opt = tmpF->GetOption();
+      opt.ToLower();
+      if (!opt.Contains("read")) {
+        lfile = tmpF;
+        tmpF->cd();
+      }
+    }
+  }
+
+  TString pwd = gDirectory->GetPath();
+  if (!lfile) {
+    std::string originalName = mDefName;
+    if (mDefName.empty() || mDefName[0] == ' ') {
+      mDefName = "histoman";
+    }
+    TString rootName = mDefName.c_str();
+    if (!rootName.Contains(".root")) {
+      mDefName += ".root";
+    }
+    lfile = TFile::Open(mDefName.c_str(), "UPDATE");
+    mDefName = originalName;
+    localFile = kTRUE;
+  }
+
+  lfile->cd();
+  dirName = mDirName.c_str();
+  if (dirName && dirName[0] && dirName[0] != ' ') {
+    if (!lfile->Get(dirName)) {
+      lfile->mkdir(dirName);
+    }
+    lfile->cd(dirName);
+  }
+  LOGP(info, "Writing histograms to: {}/{}", lfile->GetPath(), dirName);
+
+  for (int i = 0; i < GetLast() + 1; ++i) {
+    TObject* obj = UncheckedAt(i);
+    if (!obj) {
+      continue;
+    }
+    auto* histo = dynamic_cast<TH1*>(obj);
+    TDirectory* dr = nullptr;
+    if (histo) {
+      dr = histo->GetDirectory();
+      histo->SetDirectory(nullptr);
+    }
+    obj->Write(nullptr, TObject::kOverwrite);
+    if (dr && histo) {
+      histo->SetDirectory(dr);
+    }
+  }
+
+  if (localFile) {
+    lfile->Close();
+    delete lfile;
+  }
+  auto* oldDir = static_cast<TDirectory*>(gROOT->GetListOfFiles()->FindObject(pwd.Data()));
+  if (oldDir) {
+    oldDir->cd();
+  }
+}
+
+void HistoManager::Clear(Option_t*)
+{
+  int nent = GetLast() + 1;
+  for (int i = 0; i < nent; ++i) {
+    TObject* hh = UncheckedAt(i);
+    if (!hh) {
+      continue;
+    }
+    RemoveAt(i);
+    --mNHistos;
+  }
+}
+
+//_______________________________________________________________
+void HistoManager::Delete(Option_t*)
+{
+  int nent = GetLast() + 1;
+  for (int i = 0; i < nent; ++i) {
+    TObject* hh = UncheckedAt(i);
+    if (!hh) {
+      continue;
+    }
+    RemoveAt(i);
+    delete hh;
+  }
+  mNHistos = 0;
+}
+
+void HistoManager::Print(Option_t* option) const
+{
+  int nent = GetLast() + 1;
+  for (int i = 0; i < nent; ++i) {
+    TObject* hh = UncheckedAt(i);
+    if (!hh) {
+      continue;
+    }
+    LOGP(info, "At position #{}", i);
+    hh->Print(option);
+  }
+  LOGP(info, "Total number of defined histograms: %d", mNHistos);
+  LOGP(info, "Current output path: {}/{}", mDefName, mDirName);
+}
+
+void HistoManager::addPrefix(const std::string& pref)
+{
+  if (pref.empty()) {
+    return;
+  }
+  int nent = GetLast() + 1;
+  for (int i = 0; i < nent; ++i) {
+    TObject* hh = UncheckedAt(i);
+    if (!hh) {
+      continue;
+    }
+    if (hh->InheritsFrom("TNamed")) {
+      auto name = pref + hh->GetName();
+      static_cast<TNamed*>(hh)->SetName(name.c_str());
+    }
+  }
+}
+
+void HistoManager::addHistos(const HistoManager* hm, Double_t c1)
+{
+  if (!hm) {
+    return;
+  }
+  int nent = GetLast() + 1;
+  int nent1 = hm->GetLast() + 1;
+  if (nent != nent1) {
+    Error("addHistos", "HistoManagers have different content: %d vs %d", nent, nent1);
+    return;
+  }
+  for (int i = 0; i < nent; ++i) {
+    TH1* hh1 = getHisto(i);
+    TH1* hh2 = hm->getHisto(i);
+    if (!hh1 || !hh2) {
+      continue;
+    }
+    hh1->Add(hh2, c1);
+  }
+}
+
+void HistoManager::divideHistos(const HistoManager* hm)
+{
+  if (!hm) {
+    return;
+  }
+  int nent = GetLast() + 1;
+  int nent1 = hm->GetLast() + 1;
+  if (nent != nent1) {
+    Error("divideHistos", "HistoManagers have different content: %d vs %d", nent, nent1);
+    return;
+  }
+  for (int i = 0; i < nent; ++i) {
+    TH1* hh1 = getHisto(i);
+    TH1* hh2 = hm->getHisto(i);
+    if (!hh1 || !hh2) {
+      continue;
+    }
+    hh1->Divide(hh2);
+  }
+}
+
+//_______________________________________________________________
+void HistoManager::multiplyHistos(const HistoManager* hm)
+{
+  if (!hm) {
+    return;
+  }
+  int nent = GetLast() + 1;
+  int nent1 = hm->GetLast() + 1;
+  if (nent != nent1) {
+    Error("multiplyHistos", "HistoManagers have different content: %d vs %d", nent, nent1);
+    return;
+  }
+  for (int i = 0; i < nent; ++i) {
+    TH1* hh1 = getHisto(i);
+    TH1* hh2 = hm->getHisto(i);
+    if (!hh1 || !hh2) {
+      continue;
+    }
+    hh1->Multiply(hh2);
+  }
+}
+
+void HistoManager::scaleHistos(Double_t c1)
+{
+  int nent = GetLast() + 1;
+  for (int i = 0; i < nent; ++i) {
+    TH1* hh1 = getHisto(i);
+    if (hh1) {
+      hh1->Scale(c1);
+    }
+  }
+}
+
+void HistoManager::sumw2()
+{
+  int nent = GetLast() + 1;
+  for (int i = 0; i < nent; ++i) {
+    auto* hh1 = dynamic_cast<TH1*>(UncheckedAt(i));
+    if (hh1) {
+      hh1->Sumw2();
+    }
+  }
+}
+
+void HistoManager::setFile(TFile* file)
+{
+  if (file) {
+    mDefName = file->GetName();
+  }
+}
+
+void HistoManager::delHisto(int at)
+{
+  TH1* hist = getHisto(at);
+  if (hist) {
+    RemoveAt(at);
+    delete hist;
+    --mNHistos;
+  }
+}
+
+void HistoManager::purify(bool emptyToo)
+{
+  int last = GetLast() + 1;
+  if (emptyToo) {
+    for (int i = 0; i < last; ++i) {
+      TH1* hist = getHisto(i);
+      if (!hist) {
+        continue;
+      }
+      if (hist->GetEntries() < 1) {
+        delHisto(i);
+      }
+    }
+  }
+  Compress();
+}
+
+void HistoManager::setFileName(const std::string& name)
+{
+  mDefName = gSystem->ExpandPathName(name.c_str());
+}
+
+void HistoManager::reset()
+{
+  int last = GetLast() + 1;
+  for (int i = 0; i < last; ++i) {
+    TH1* hist = getHisto(i);
+    if (!hist) {
+      continue;
+    }
+    hist->Reset();
+  }
+}
+
+int HistoManager::load(const std::string& fname, const std::string& dirname)
+{
+  TFile* file = TFile::Open(gSystem->ExpandPathName(fname.c_str()));
+  if (!file) {
+    LOGP(error, "No file {}", fname);
+    return 0;
+  }
+  if (!dirname.empty() && dirname[0] != ' ') {
+    if (!file->Get(dirname.c_str())) {
+      LOGP(error, "No {} directory in file {}", dirname, fname);
+      file->Close();
+      delete file;
+      return 0;
+    }
+    file->cd(dirname.c_str());
+  }
+  int count = 0;
+  TList* lst = gDirectory->GetListOfKeys();
+  TIter nextKey(lst);
+  TKey* key = nullptr;
+  while ((key = static_cast<TKey*>(nextKey()))) {
+    if (FindObject(key->GetName())) {
+      continue;
+    }
+    TString clName = key->GetClassName();
+    if (!(clName.BeginsWith("TH") || clName.BeginsWith("TProfile") || clName.BeginsWith("TGraph"))) {
+      printf("Object %s of type %s is not processed\n", key->GetName(), clName.Data());
+      continue;
+    }
+    TObject* hst = key->ReadObj();
+    int id = hst->GetUniqueID();
+    if (auto* h = dynamic_cast<TH1*>(hst)) {
+      addHisto(h, id - 1);
+      ++count;
+      continue;
+    }
+    if (auto* gr = dynamic_cast<TGraph*>(hst)) {
+      addGraph(gr, id - 1);
+      ++count;
+    }
+  }
+  file->Close();
+  delete file;
+  auto nm = fname;
+  if (!dirname.empty()) {
+    nm += fmt::format("/{}", dirname);
+  }
+  SetName(nm.c_str());
+  return count;
+}
+
+void HistoManager::setColor(int tcolor)
+{
+  int last = GetLast() + 1;
+  for (int i = 0; i < last; ++i) {
+    TH1* hist = getHisto(i);
+    if (!hist) {
+      continue;
+    }
+    hist->SetLineColor(tcolor);
+    hist->SetMarkerColor(tcolor);
+    TList* lst = hist->GetListOfFunctions();
+    if (lst) {
+      int nf = lst->GetSize();
+      for (int j = 0; j < nf; ++j) {
+        TObject* fnc = lst->At(j);
+        if (fnc->InheritsFrom("TF1")) {
+          static_cast<TF1*>(fnc)->SetLineColor(tcolor);
+          static_cast<TF1*>(fnc)->SetLineWidth(1);
+          static_cast<TF1*>(fnc)->ResetBit(TF1::kNotDraw);
+        } else if (fnc->InheritsFrom("TPaveStats")) {
+          static_cast<TPaveStats*>(fnc)->SetTextColor(tcolor);
+        }
+      }
+    }
+  }
+}
+
+void HistoManager::setMarkerStyle(Style_t mstyle, Size_t msize)
+{
+  int last = GetLast() + 1;
+  for (int i = 0; i < last; ++i) {
+    TH1* hist = getHisto(i);
+    if (!hist) {
+      continue;
+    }
+    hist->SetMarkerStyle(mstyle);
+    hist->SetMarkerSize(msize);
+  }
+}
+
+void HistoManager::setMarkerSize(Size_t msize)
+{
+  int last = GetLast() + 1;
+  for (int i = 0; i < last; ++i) {
+    TH1* hist = getHisto(i);
+    if (!hist) {
+      continue;
+    }
+    hist->SetMarkerSize(msize);
+  }
+}
+
+} // namespace o2
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
index 86e4bb9ca234a..72188eb5f06c6 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
@@ -9,7 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include "GlobalTrackingStudy/CheckResid.h"
+#include "GlobalTrackingStudy/CheckResidSpec.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DetectorsCommonDataFormats/DetID.h"
 #include "CommonUtils/ConfigurableParam.h"
@@ -20,8 +20,6 @@
 #include "DetectorsBase/DPLWorkflowUtils.h"
 #include "GlobalTrackingWorkflowHelpers/InputHelper.h"
 #include "DetectorsRaw/HBFUtilsInitializer.h"
-#include "TPCCalibration/CorrectionMapsOptions.h"
-#include "TPCWorkflow/TPCScalerSpec.h"
 #include "DataFormatsITSMFT/DPLAlpideParamInitializer.h"
 
 using namespace o2::framework;
@@ -39,14 +37,13 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
 {
   // option allowing to set parameters
   std::vector<o2::framework::ConfigParamSpec> options{
-    {"enable-mc", o2::framework::VariantType::Bool, false, {"enable MC propagation"}},
+    {"draw-external-only", VariantType::Bool, false, {"just draw content of comma-separated list of histomanagers from checkresid.ext_hm_list"}},
     {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of track sources to use"}},
     {"cluster-sources", VariantType::String, "ITS", {"comma-separated list of cluster sources to use"}},
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings ..."}}};
-  //  o2::tpc::CorrectionMapsLoader::addGlobalOptions(options);
+
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
-  o2::tpc::CorrectionMapsOptions::addGlobalOptions(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
 }
@@ -59,23 +56,30 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   WorkflowSpec specs;
 
+  bool drawOnly = configcontext.options().get<bool>("draw-external-only");
+
   GID::mask_t allowedSourcesTrc = GID::getSourcesMask("ITS,TPC,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
   GID::mask_t allowedSourcesClus = GID::getSourcesMask("ITS");
 
   // Update the (declared) parameters if changed from the command line
   o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
-  auto sclOpt = o2::tpc::CorrectionMapsOptions::parseGlobalOptions(configcontext.options());
-  auto useMC = configcontext.options().get<bool>("enable-mc");
 
   GID::mask_t srcTrc = allowedSourcesTrc & GID::getSourcesMask(configcontext.options().get<std::string>("track-sources"));
   GID::mask_t srcCls = allowedSourcesClus & GID::getSourcesMask(configcontext.options().get<std::string>("cluster-sources"));
-  o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, useMC);
-  o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, useMC); // P-vertex is always needed
 
-  specs.emplace_back(o2::checkresid::getCheckResidSpec(srcTrc, srcCls, useMC));
+  if (!drawOnly) {
+    o2::globaltracking::InputHelper::addInputSpecs(configcontext, specs, srcCls, srcTrc, srcTrc, false);
+    o2::globaltracking::InputHelper::addInputSpecsPVertex(configcontext, specs, false); // P-vertex is always needed
+  } else {
+    allowedSourcesTrc = {};
+    allowedSourcesClus = {};
+  }
+  specs.emplace_back(o2::checkresid::getCheckResidSpec(srcTrc, srcCls, drawOnly));
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
-  o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
+  if (!drawOnly) {
+    o2::raw::HBFUtilsInitializer hbfIni(configcontext, specs);
+  }
 
   return std::move(specs);
 }

From e2c7cc9878306f3dd455d4be6ce5ebdabf499290 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 27 Apr 2026 16:37:47 +0200
Subject: [PATCH 1683/1764] ITS: GPU: try to fix illegal access

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx     | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 0359f2cfb0d03..67b6b0bf5cdfe 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -209,16 +209,22 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
                                  this->mTrkParams[iteration].LayerxX0,
                                  mTimeFrameGPU->getStreams());
   }
+  mTimeFrameGPU->syncStreams(false);
 }
 
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
 {
   for (int iLayer{0}; iLayer < this->mTrkParams[iteration].NeighboursPerRoad(); ++iLayer) {
+    if (iLayer > 0) {
+      // Previous layer updates levels in this layer's cells.
+      mTimeFrameGPU->waitEvent(iLayer, iLayer - 1);
+    }
     const int currentLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer])};
     const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};
     if (!nextLayerCellsNum || !currentLayerCellsNum) {
       mTimeFrameGPU->getNNeighbours()[iLayer] = 0;
+      mTimeFrameGPU->recordEvent(iLayer);
       continue;
     }
     mTimeFrameGPU->createNeighboursIndexTablesDevice(iLayer);
@@ -239,6 +245,7 @@ void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
                                         mTimeFrameGPU->getStream(iLayer));
     mTimeFrameGPU->createNeighboursDevice(iLayer);
     if (mTimeFrameGPU->getNNeighbours()[iLayer] == 0) {
+      mTimeFrameGPU->recordEvent(iLayer);
       continue;
     }
     computeCellNeighboursHandler<NLayers>(mTimeFrameGPU->getDeviceArrayCells(),
@@ -259,6 +266,7 @@ void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
                                                                                mTimeFrameGPU->getArrayNNeighbours()[iLayer],
                                                                                mTimeFrameGPU->getStream(iLayer),
                                                                                mTimeFrameGPU->getFrameworkAllocator());
+    mTimeFrameGPU->recordEvent(iLayer);
   }
   mTimeFrameGPU->syncStreams(false);
 }

From a5da00aaaddd3c7045d2bdf6289b605e49a3c835 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Tue, 28 Apr 2026 10:41:44 +0200
Subject: [PATCH 1684/1764] ITS: account in selectReseedMidLayer for possible
 holes

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../include/ITStracking/TrackHelpers.h        | 39 +++++++++++--------
 1 file changed, 22 insertions(+), 17 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
index 2224495607ee1..a8cddd1190c16 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
@@ -29,19 +29,22 @@
 namespace o2::its::track
 {
 
-GPUdi() int selectReseedMidLayer(int minLayer, int maxLayer, int nLayers, const float* layerRadii)
+// Find the populated interior layer closest to the radial midpoint.
+// If no layer can be found, return constants::UnusedIndex.
+// Should minimize the sagitta bias.
+template <int NLayers>
+GPUdi() int selectReseedMidLayer(int minLayer, int maxLayer, const float* layerRadii, const TrackSeed<NLayers>& seed)
 {
-  if (maxLayer - minLayer == nLayers - 1) {
-    return (minLayer + maxLayer) / 2;
-  }
-  int midLayer = minLayer + 1;
+  int midLayer = constants::UnusedIndex;
+  float distanceToMidR = layerRadii[NLayers - 1]; // midpoint cannot be last layer
   const float midR = 0.5f * (layerRadii[maxLayer] + layerRadii[minLayer]);
-  float distanceToMidR = o2::gpu::CAMath::Abs(midR - layerRadii[midLayer]);
-  for (int iLayer = midLayer + 1; iLayer < maxLayer; ++iLayer) { // find the midpoint as closest to the midR
-    const float distance = o2::gpu::CAMath::Abs(midR - layerRadii[iLayer]);
-    if (distance < distanceToMidR) {
-      midLayer = iLayer;
-      distanceToMidR = distance;
+  for (int iLayer = minLayer + 1; iLayer < maxLayer; ++iLayer) {
+    if (seed.getCluster(iLayer) != constants::UnusedIndex) {
+      const float distance = o2::gpu::CAMath::Abs(midR - layerRadii[iLayer]);
+      if (distance < distanceToMidR) { // keep the smaller-radius layer on ties
+        midLayer = iLayer;
+        distanceToMidR = distance;
+      }
     }
   }
   return midLayer;
@@ -106,12 +109,14 @@ GPUdi() TrackITSExt seedTrackForRefit(const TrackSeed<NLayers>& seed,
   }
 
   const int ncl = temporaryTrack.getNClusters();
-  if (ncl < reseedIfShorter && ncl > 1) {
-    const int lrMid = selectReseedMidLayer(lrMin, lrMax, NLayers, layerRadii);
-    const auto& cluster0TF = foundTrackingFrameInfo[lrMin][seed.getCluster(lrMin)];
-    const auto& cluster1GL = unsortedClusters[lrMid][seed.getCluster(lrMid)];
-    const auto& cluster2GL = unsortedClusters[lrMax][seed.getCluster(lrMax)];
-    temporaryTrack.getParamIn() = buildTrackSeed(cluster2GL, cluster1GL, cluster0TF, bz, true);
+  if (ncl < reseedIfShorter && ncl > 2) {
+    const int lrMid = selectReseedMidLayer<NLayers>(lrMin, lrMax, layerRadii, seed);
+    if (lrMid != constants::UnusedIndex) {
+      const auto& cluster0TF = foundTrackingFrameInfo[lrMin][seed.getCluster(lrMin)];
+      const auto& cluster1GL = unsortedClusters[lrMid][seed.getCluster(lrMid)];
+      const auto& cluster2GL = unsortedClusters[lrMax][seed.getCluster(lrMax)];
+      temporaryTrack.getParamIn() = buildTrackSeed(cluster2GL, cluster1GL, cluster0TF, bz, true);
+    }
   }
 
   resetTrackCovariance(temporaryTrack);

From d87cff5580733c2f480f7bb8ad4cf97178349280 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 1 May 2026 15:05:39 +0200
Subject: [PATCH 1685/1764] ITS: do not use NAN in helpers for new ROCm

fixes:
 /home/fschlepp/alice/sw/SOURCES/O2/dev_head/0/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h:65:60: warning: use of NaN is undefined behavior due to the currently enabled floating-point options [-Wnan-infinity-disabled]
    65 |   float ca = NAN, sa = NAN, snp = NAN, q2pt = NAN, q2pt2 = NAN;
       |                                                            ^~~
 /opt/rocm-7.1.1/lib/llvm/lib/clang/20/include/float.h:174:16: note: expanded from macro 'NAN'
   174 | #  define NAN (__builtin_nanf(""))

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
index a8cddd1190c16..885cb0f2b9ca5 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
@@ -62,7 +62,7 @@ GPUdi() o2::track::TrackParCov buildTrackSeed(const Cluster& cluster1,
                                               const float bz,
                                               const bool reverse = false)
 {
-  float ca = NAN, sa = NAN, snp = NAN, q2pt = NAN, q2pt2 = NAN;
+  float ca = constants::UnsetValue, sa = constants::UnsetValue, snp = constants::UnsetValue, q2pt = constants::UnsetValue, q2pt2 = constants::UnsetValue;
   o2::gpu::CAMath::SinCos(tf3.alphaTrackingFrame, sa, ca);
   const float sign = reverse ? -1.f : 1.f;
   const float x1 = (cluster1.xCoordinate * ca) + (cluster1.yCoordinate * sa);

From 34bd36764fc89a31139f6de6bad2629649ea83e1 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 4 May 2026 17:55:10 +0200
Subject: [PATCH 1686/1764] Check for streamer presence before writing the
 output

---
 Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
index 6f3055aa00806..ff73be857346f 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
@@ -325,7 +325,9 @@ void CheckResidSpec::process()
   // output
   for (const auto& accum : slots) {
     for (const auto& tr : accum) {
-      (*mDBGOut) << "res" << "tr=" << tr << "\n";
+      if (mDBGOut) {
+        (*mDBGOut) << "res" << "tr=" << tr << "\n";
+      }
       if (mHMan) {
         fillHistos(tr);
       }

From cc6e4aeafde8454027562d22e4239f96ae71be18 Mon Sep 17 00:00:00 2001
From: Justus Rudolph <44173718+JustusRudolph@users.noreply.github.com>
Date: Mon, 4 May 2026 18:50:07 +0200
Subject: [PATCH 1687/1764] [ALICE3] FT3: Tiling Stave Geometry (#15339)

* Add separate file for constants in FT3 module creation

* Create modular design in similar fashion as before, but with slightly different module placement. Rewrite structure to be more granular and extendable. The old code remains for backward compatibility for now

* Give new geometry creation an FT3Layout enum and change Layer&Module accordingly. Also simplify create_layout_scopingV3 function since the layout_type isn't needed.

* Add functionality for the user to enforce a strict cut on module placement to remain within nominal radii. Also remove initial placement of sensor stack before calling fill_stave, moving to using y_start instead.

* Make forward and backward directions mirrored, front and back faces swap based on direction

* Add loop over all sensors in stack so all sensors are added to volume, not just the first in the stack

* Add constants for hollow stave based geometry

* Add carbon fiber material, functionality to toggle between stave and old geometry. Also rename material counts to 'volume' instead of 'sensor'. EDIT: Change TGeo layer thickness back to original. EDIT2: Change Middle layer disc usage to newly added segmentation.

* Add full hollow stave geometry functionality

* Make Stave layout the standard and remove old kSegmentedMarch26: EDIT 20/04/26: Revert to newly added middle disc layer segmentation.

* Remove all instances of old slab geometry and work only with staves.

* Remove all log(info) statements, except one which is changed to debug.

* Don't create the separation layer for stave layout, since we already get the structural support (in carbon) from the staves

* add bools for cutting staves and sensors on staves on nominal radii

* merge two if statements with the same if

* Add implementations for cutting staves and sensors on nominal radii. Also change kSensorsPerStack to a vector in which order of sensor stack height we will pad the staves.

* Fix bug in default y range for staves & sensor placements

* Bugfix: Stack correctly by using previous stack height in fill_stave, and move in correct direction when placing sensors later

* Remove now stale info statements. TODO: let staves be cut as well on nominal radii

* Add splitting of stave in case of strict inner cutoff

* Add support to place either a stack gap or single sensor around y=0 in staves that have full +Rout to -Rout coverage

* Bugfix: When starting sensor placement around the x-axis you can have a different number of sensor stacks on the positive/negative side of the stave leading to garbage memory access. Fixed now.

* Add option to draw reference circles onto the layer -- strictly for visualisation purposes

* remove stale info statements

* Remove stale overlap argument, and add local offset in z. In contrast to previous layout, to encapsulate the staves with face at local z=0 in air, we need to shift the staves and sensors locally since the mother volume is always around local z=0. Shift the layer volume by the same amount when adding it to get the right global position.

* Fix placement issue to get sensor materials inside the volume. This now means that the stave faces are not at local z=0 but instead at z=+-totalSensorMaterialThickness+0.1. Also fix global position bug since movement outwards is directional.

* Add OT only segmentation and change defaults

* Make stave geometry available with middle layer disks as well. Currently use simple calculated values for stave placements, these are subject to change. Hence the existence of kSegmentedOTOnly

* Change default to stave segmentation for outer disks only

* Please consider the following formatting changes

---------

Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../FT3/base/include/FT3Base/FT3BaseParam.h   |  14 +-
 .../include/FT3Simulation/FT3Layer.h          |   1 +
 .../include/FT3Simulation/FT3Module.h         |  65 +-
 .../FT3Simulation/FT3ModuleConstants.h        | 206 ++++++
 .../ALICE3/FT3/simulation/src/FT3Layer.cxx    |  87 ++-
 .../ALICE3/FT3/simulation/src/FT3Module.cxx   | 660 ++++++++++++++++++
 6 files changed, 1022 insertions(+), 11 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h

diff --git a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
index 67bf42458a88a..b0f26bc4675d4 100644
--- a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
+++ b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
@@ -24,10 +24,12 @@ enum eFT3Layout {
   kCylindrical = 0,
   kTrapezoidal,
   kSegmented,
+  kSegmentedStave,
+  kSegmentedStaveOTOnly
 };
 struct FT3BaseParam : public o2::conf::ConfigurableParamHelper<FT3BaseParam> {
   // Geometry Builder parameters
-  eFT3Layout layoutFT3 = kSegmented;
+  eFT3Layout layoutFT3 = kSegmentedStaveOTOnly;
   int nTrapezoidalSegments = 32; // for the simple trapezoidal disks
 
   // FT3Geometry::Telescope parameters
@@ -38,6 +40,16 @@ struct FT3BaseParam : public o2::conf::ConfigurableParamHelper<FT3BaseParam> {
   Float_t etaOut = 1.5;
   Float_t Layerx2X0 = 0.01;
 
+  // override values from FT3ModuleConstants, inner and outer
+  bool cutStavesOnNominalRadius_inner = true;
+  bool cutStavesOnNominalRadius_outer = false;
+
+  // What to place over x=0 line in case of full outer-outer stave: Gap or Sensor
+  bool placeSensorInMiddleOfStave = false;
+
+  // Draw reference circles at inner and outer radius of stave layer, for visualisation
+  bool drawReferenceCircles = false;
+
   O2ParamDef(FT3BaseParam, "FT3Base");
 };
 
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
index f6acebe80ac33..282f8fd274ec0 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Layer.h
@@ -64,6 +64,7 @@ class FT3Layer : public TObject
   // create layer for disk support
   void createSeparationLayer(TGeoVolume* motherVolume, const std::string& separationLayerName);
   void createSeparationLayer_waterCooling(TGeoVolume* motherVolume, const std::string& separationLayerName);
+  void createReferenceCircles(TGeoVolume* motherVolume, const std::string& name);
 
   static TGeoMaterial* carbonFiberMat;
   static TGeoMedium* medCarbonFiber;
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h
index 15ac6be995646..1311c6a4ff1b5 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3Module.h
@@ -17,6 +17,17 @@
 
 #include <TGeoVolume.h>
 #include <string>
+#include <vector>
+
+#include "FT3Simulation/FT3ModuleConstants.h"
+
+// define types for y positions, second element is the stack height
+using PositionType = std::pair<double, unsigned>;
+using PositionTypes = std::vector<PositionType>;
+using PosNegPositionTypes = std::pair<PositionTypes, PositionTypes>;
+// define type of the y position range: First pair is (min, max) for positive y
+using PositionRangeType = std::pair<std::pair<double, double>, std::pair<double, double>>;
+namespace Constants = o2::ft3::ModuleConstants;
 
 class FT3Module
 {
@@ -33,13 +44,63 @@ class FT3Module
   static TGeoMedium* epoxyMed;
   static TGeoMaterial* AluminumMat;
   static TGeoMedium* AluminumMed;
+  static TGeoMaterial* carbonFiberMat;
+  static TGeoMedium* carbonFiberMed;
 
   const char* mDetName;
 
-  static void createModule(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume);
+  static void createModule(
+    double mZ, int layerNumber, int direction, double Rin,
+    double Rout, double overlap, const std::string& face,
+    const std::string& layout_type, TGeoVolume* motherVolume);
+
+  void createModule_staveGeo(
+    double mZ, int layerNumber, int direction, double Rin,
+    double Rout, double z_offset_local, const Constants::StaveConfig& staveConfig,
+    TGeoVolume* motherVolume);
 
  private:
-  static void create_layout(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume);
+  static void create_layout(
+    double mZ, int layerNumber, int direction, double Rin,
+    double Rout, double overlap, const std::string& face,
+    const std::string& layout_type, TGeoVolume* motherVolume);
+
+  void create_layout_staveGeo(
+    double mZ, int layerNumber, int direction, double Rin,
+    double Rout, double z_offset_local, const Constants::StaveConfig& staveConfig,
+    TGeoVolume* motherVolume);
+
+  // Helper functions
+  void fill_stave(PosNegPositionTypes& y_positions, double Rin, double Rout,
+                  double x_left, unsigned kSensorStack, PositionRangeType y_range,
+                  std::pair<double, double>& absAllowedYRange);
+  void addStaveVolume(
+    TGeoVolume* motherVolume, std::string volumeName, int direction,
+    unsigned* volume_count, double staveLength,
+    std::array<std::array<double, 3>, 4> staveTriangles,
+    std::pair<double, double>& absAllowedYRange,
+    double x_mid, double y_mid, double z_stave_shift_forward);
+  void addDetectorVolume(
+    TGeoVolume* motherVolume, std::string volumeName, int color, unsigned* volume_count,
+    double x_mid, double y_mid, double z_mid,
+    double x_half_length, double y_half_length, double z_half_length);
+
+  void add2x1GlueVolume(
+    TGeoVolume* motherVolume, int layerNumber, int direction, unsigned stave_idx,
+    unsigned* volume_count, double x_mid, double y_mid, double z_mid,
+    std::string element_glued_to);
+
+  void add2x1CopperVolume(
+    TGeoVolume* motherVolume, int layerNumber, int direction, unsigned stave_idx,
+    unsigned* volume_count, double x_mid, double y_mid, double z_mid);
+
+  void add2x1KaptonVolume(
+    TGeoVolume* motherVolume, int layerNumber, int direction, unsigned stave_idx,
+    unsigned* volume_count, double x_mid, double y_mid, double z_mid);
+
+  void addSingleSensorVolume(
+    TGeoVolume* motherVolume, int layerNumber, int direction, unsigned stave_idx,
+    unsigned* volume_count, double active_x_mid, double y_mid, double z_mid, bool isLeft);
 };
 
 #endif // FT3MODULE_H
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h
new file mode 100644
index 0000000000000..1fe9f404245c1
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h
@@ -0,0 +1,206 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file FT3ModuleConstants.h
+/// \brief Definition of various constants for tiling the modules of sensors
+
+#ifndef FT3MODULECONSTANTS_H
+#define FT3MODULECONSTANTS_H
+
+#include <vector>
+#include <map>
+#include <TColor.h>
+#include <TMath.h>
+
+namespace o2::ft3::ModuleConstants
+{
+/* CURRENT STATUS:
+ * 25x32mm sensors, 2mm inactive on one side
+ * Most granular layout is 2x1 sensors, where the one on the right has the inactive region
+ * on the right, and the one on the left has the inactive region on the left.
+ * When stacking 2x1 modules, there is a 0.2mm gap between them. By default, we assume this
+ * gap to be ABOVE the most recently placed module.
+ *
+ * |<- 25mm ->|<- 25mm ->|
+ * _______________________
+ * -----------------------  0.2mm gap above
+ * | |        |        | |
+ * | |        |        | |
+ * | |        |        | |
+ * | |        |        | |  32mm sensor height
+ * | |        |        | |
+ * | |        |        | |
+ * ------------------------
+ *
+ */
+// First set all layout constants for the rest of the function
+const double single_sensor_width = 2.5;
+const double single_sensor_height = 3.2;
+const double inactive_width = 0.2;
+const double sensor2x1_gap = 0.02;
+const double stackGap = sensor2x1_gap; // gap between 2xN module stacks
+
+const double active_width = single_sensor_width - inactive_width;
+const double active_height = single_sensor_height;
+
+const double sensor2x1_width = 2 * single_sensor_width;
+const double sensor2x1_active_width = 2 * active_width;
+const double sensor2x1_height = single_sensor_height;
+const std::vector<unsigned> kSensorsPerStack = {4, 2, 1};
+inline const double getStackHeight(unsigned nSensorsPerStack)
+{
+  return nSensorsPerStack * sensor2x1_height +
+         (nSensorsPerStack - 1) * sensor2x1_gap;
+}
+
+// small helper function to get 1-indexed stave ID, counting from the middle outwards,
+// with negative IDs on the left and positive IDs on the right
+inline const int staveIdxToID(int staveIdx, unsigned nStavesPerDisc)
+{
+  unsigned nStavesOneSide = nStavesPerDisc / 2;
+  bool isRight = staveIdx >= nStavesOneSide;
+  return staveIdx - nStavesOneSide + isRight;
+}
+
+// material properties
+const double siliconThickness = 0.01;
+const double copperThickness = 0.006;
+const double kaptonThickness = 0.03;
+const double epoxyThickness = 0.0012;
+
+const double effectiveCarbonThickness_Stave = 0.02; // foam + shell
+const double staveOpeningAngle = 60 * TMath::DegToRad();
+const double sinTheta = TMath::Sin(staveOpeningAngle / 2);
+const double alpha = TMath::Pi() / 2 - staveOpeningAngle / 2; // bottom angles
+const double staveSensorGap = 0.1;                            // 2mm padding on each side when sensor is glued
+const double staveTriangleHeight = (sensor2x1_width + 2 * staveSensorGap) / 2.0 / tan(staveOpeningAngle / 2.0);
+/*
+ * Now describe the offset of every other stave in z to avoid overlaps
+ * ______      ______
+ * \    /______\    / | <-- z_offsetStave
+ *  \  / \    / \  /
+ *   \/   \  /   \/
+ *         \/
+ */
+// If midpoint spacing becomes non constant, this becomes a function
+// TODO: add some tolerance to avoid overlaps?
+inline const double z_offsetStave(double x_midpoint_spacing)
+{
+  return staveTriangleHeight *
+         (2 - x_midpoint_spacing / (sensor2x1_width / 2 + staveSensorGap));
+}
+
+const int SiColor = kGreen;
+const int SiInactiveColor = kRed;
+const int glueColor = kBlue;
+const int CuColor = kOrange;
+const int kaptonColor = kYellow;
+const int carbonColor = kBlack;
+
+// Struct for stave position configuration (varies between IT/OT)
+struct StaveConfig {
+  /*
+   * Constants for staves are written for both positive
+   * and negative x even though they are just mirrored now,
+   * because there might be design changes in the future
+   * that require a non-mirrored layout, making it easier to
+   * change here if so required, even though it looks uglier now.
+   *
+   * The second element in the mapping pair is whether the stave
+   * with a certain ID should be mirrored around the x-axis.
+   */
+  // map from Stave ID (1-indexed from other documents) to midpoint
+  // Do NOT add any zero midpoints, this is taken off separately
+  const std::map<int, std::pair<double, bool>>& staveID_to_y_midpoint;
+  // lengths of staves, their midpoint, and their face
+  const std::vector<double>& y_lengths;
+  const std::vector<double>& x_midpoints;
+  double x_midpoint_spacing;
+  // which side of the disc do we place the stave?
+  // kSegmentedStave: staggering staves in z (see z_offsetStave)
+  // accessed via stave index, NOT stave ID
+  const std::vector<bool>& staveOnFront;
+};
+
+namespace OT_StavePositions
+{
+const std::map<int, std::pair<double, bool>> staveID_to_y_midpoint = {
+  {-2, {39.0, true}},
+  {-1, {41.4, true}},
+  {1, {41.4, true}},
+  {2, {39.0, true}}};
+const std::vector<double> y_lengths = {
+  52.8, 66.0, 79.2, 92.4, 99.0, 105.6, 118.8, 118.8,
+  128.7, 132.0, 132.0, 138.6, 138.6, 56.1, 52.8,
+  52.8, 56.1, 138.6, 138.6, 132.0, 132.0, 128.7,
+  118.8, 118.8, 105.6, 99.0, 92.4, 79.2, 66.0, 52.8};
+const std::vector<double> x_midpoints = {
+  -65.25, -60.75, -56.25, -51.75, -47.25, -42.75, -38.25,       // L
+  -33.75, -29.25, -24.75, -20.25, -15.75, -11.25, -6.75, -2.25, // L
+  2.25, 6.75, 11.25, 15.75, 20.25, 24.75, 29.25, 33.75,         // R
+  38.25, 42.75, 47.25, 51.75, 56.25, 60.75, 65.25               // R
+};
+const double x_midpoint_spacing = 4.5; // assume constant for now
+const std::vector<bool> staveOnFront =
+  {
+    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, // L
+    0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0  // R
+};
+} // namespace OT_StavePositions
+
+namespace ML_StavePositions
+{
+// Use prelim numbers for now, these will change! TODO
+const std::map<int, std::pair<double, bool>> staveID_to_y_midpoint = {
+  {-3, {19.1, true}},
+  {-2, {21.8, true}},
+  {-1, {22.5, true}},
+  {1, {22.5, true}},
+  {2, {21.8, true}},
+  {3, {19.1, true}}};
+const std::vector<double> y_lengths = {
+  30.5, 44.5, 53.6, 60.0, 64.6, 29.5, 25.8, 25.0,
+  25.0, 25.8, 29.5, 64.6, 60.0, 53.6, 44.5, 30.5};
+const std::vector<double> x_midpoints = {
+  -33.75, -29.25, -24.75, -20.25, -15.75, -11.25, -6.75, -2.25, // L
+  2.25, 6.75, 11.25, 15.75, 20.25, 24.75, 29.25, 33.75          // R
+};
+const double x_midpoint_spacing = 4.5;
+const std::vector<bool> staveOnFront =
+  {
+    1, 0, 1, 0, 1, 0, 1, 0, // L
+    0, 1, 0, 1, 0, 1, 0, 1  // R
+};
+} // namespace ML_StavePositions
+
+// Get stave configuration based on tracker type
+inline StaveConfig getStaveConfig(bool isInnerDisk)
+{
+  if (isInnerDisk) {
+    return StaveConfig{
+      ML_StavePositions::staveID_to_y_midpoint,
+      ML_StavePositions::y_lengths,
+      ML_StavePositions::x_midpoints,
+      ML_StavePositions::x_midpoint_spacing,
+      ML_StavePositions::staveOnFront};
+  } else {
+    return StaveConfig{
+      OT_StavePositions::staveID_to_y_midpoint,
+      OT_StavePositions::y_lengths,
+      OT_StavePositions::x_midpoints,
+      OT_StavePositions::x_midpoint_spacing,
+      OT_StavePositions::staveOnFront};
+  }
+}
+
+} // namespace o2::ft3::ModuleConstants
+
+#endif // FT3MODULECONSTANTS_H
\ No newline at end of file
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
index 5be3c7abc30a3..cc6accda3adb8 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -17,6 +17,7 @@
 #include "FT3Simulation/FT3Layer.h"
 #include "FT3Base/GeometryTGeo.h"
 #include "FT3Base/FT3BaseParam.h"
+#include "FT3Simulation/FT3ModuleConstants.h"
 
 #include <TGeoManager.h>        // for TGeoManager, gGeoManager
 #include <TGeoMatrix.h>         // for TGeoCombiTrans, TGeoRotation, etc
@@ -226,6 +227,25 @@ void FT3Layer::createSeparationLayer(TGeoVolume* motherVolume, const std::string
   motherVolume->AddNode(carbonFiberLayerVol2, 1, new TGeoTranslation(0, 0, 0 + zSeparation));
 }
 
+void FT3Layer::createReferenceCircles(TGeoVolume* motherVolume, const std::string& name)
+{
+
+  // create reference circles at the inner and outer radius of the layer, for visualization purposes
+  TGeoTube* innerCircle = new TGeoTube(mInnerRadius - 0.1, mInnerRadius + 0.1, 0.01);
+  TGeoTube* outerCircle = new TGeoTube(mOuterRadius - 0.1, mOuterRadius + 0.1, 0.01);
+
+  TGeoVolume* innerCircleVol = new TGeoVolume((mLayerName + "_InnerCircle").c_str(), innerCircle, gGeoManager->GetMedium("FT3_AIR$"));
+  TGeoVolume* outerCircleVol = new TGeoVolume((mLayerName + "_OuterCircle").c_str(), outerCircle, gGeoManager->GetMedium("FT3_AIR$"));
+
+  innerCircleVol->SetLineColor(kRed);
+  outerCircleVol->SetLineColor(kBlue);
+
+  double z_position = mDirection ? 0.5 : -0.5;
+
+  motherVolume->AddNode(innerCircleVol, 1, new TGeoTranslation(0, 0, z_position));
+  motherVolume->AddNode(outerCircleVol, 1, new TGeoTranslation(0, 0, z_position));
+}
+
 void FT3Layer::createLayer(TGeoVolume* motherVolume)
 {
   auto& ft3Params = FT3BaseParam::Instance();
@@ -234,7 +254,9 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     LOG(fatal) << "Invalid layer number " << mLayerNumber << " for FT3 layer.";
   }
 
-  LOG(info) << "FT3: ft3Params.layoutFT3 = " << ft3Params.layoutFT3;
+  LOG(info) << "FT3: ft3Params.layoutFT3 = " << ft3Params.layoutFT3
+            << " Creating Layer " << mLayerNumber << " at z=" << mZ
+            << " with direction " << mDirection;
 
   // ### options for ML and OT disk layout
   if (ft3Params.layoutFT3 == kTrapezoidal /*|| (mIsMiddleLayer && ft3Params.layoutFT3 == kSegmented)*/) {
@@ -381,7 +403,8 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
 
     LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
-  } else if (ft3Params.layoutFT3 == kSegmented) {
+  } else if (ft3Params.layoutFT3 == kSegmented ||
+             (ft3Params.layoutFT3 == kSegmentedStaveOTOnly && mIsMiddleLayer)) {
     FT3Module module;
 
     // layer structure
@@ -390,20 +413,68 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     std::string separationLayerName = "FT3SeparationLayer" + std::to_string(mDirection) + std::to_string(mLayerNumber);
 
     TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$");
-    TGeoTube* layer = new TGeoTube(mInnerRadius - 0.1, mOuterRadius + 0.1, 1.5); // Add a little additional room in radius; Try with 1.5 cm thickness
-    TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+    TGeoVolume* layerVol = nullptr;
+    // Add a little additional room in radius
+    TGeoTube* layer = new TGeoTube(mInnerRadius - 0.1, mOuterRadius + 0.1, 1.5);
+    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
     layerVol->SetLineColor(kYellow + 2);
-
     // createSeparationLayer_waterCooling(motherVolume, separationLayerName);
     createSeparationLayer(layerVol, separationLayerName);
-
-    // create disk faces
     module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "front", "rectangular", layerVol);
     module.createModule(0, mLayerNumber, mDirection, mInnerRadius, mOuterRadius, 0., "back", "rectangular", layerVol);
 
     // Finally put everything in the mother volume
     auto* FwdDiskRotation = new TGeoRotation("FwdDiskRotation", 0, 0, 180);
-    auto* FwdDiskCombiTrans = new TGeoCombiTrans(0, 0, mZ, FwdDiskRotation);
+    // need to shift outwards always, so + forwards and - backwards
+    auto* FwdDiskCombiTrans = new TGeoCombiTrans(0, 0, mZ + 0, FwdDiskRotation);
+
+    LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
+    motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
+  } else if (ft3Params.layoutFT3 == kSegmentedStave ||
+             ft3Params.layoutFT3 == kSegmentedStaveOTOnly) {
+    FT3Module module;
+
+    // layer structure
+    std::string frontLayerName = o2::ft3::GeometryTGeo::getFT3LayerPattern() + std::to_string(mDirection) + std::to_string(mLayerNumber) + "_Front";
+    std::string backLayerName = o2::ft3::GeometryTGeo::getFT3LayerPattern() + std::to_string(mDirection) + std::to_string(mLayerNumber) + "_Back";
+    std::string separationLayerName = "FT3SeparationLayer" + std::to_string(mDirection) + std::to_string(mLayerNumber);
+
+    TGeoMedium* medAir = gGeoManager->GetMedium("FT3_AIR$");
+    TGeoVolume* layerVol = nullptr;
+
+    // set up stave config, differs between ML and OT disks
+    const Constants::StaveConfig& staveConfig = Constants::getStaveConfig(mIsMiddleLayer);
+
+    // need a thicker air layer to encompass the staves (4.5cm high, 1.2cm offsets)
+    // stave face is at z=0 (or +-z_offset_stave), meaning that volumes are at
+    // ~-+1cm < z < ~+-6cm, the +- referring forward/backward discs
+    double z_layer_thickness = // need to shift internally with this
+      o2::ft3::ModuleConstants::staveTriangleHeight +
+      o2::ft3::ModuleConstants::z_offsetStave(staveConfig.x_midpoint_spacing) +
+      o2::ft3::ModuleConstants::siliconThickness +
+      o2::ft3::ModuleConstants::copperThickness +
+      o2::ft3::ModuleConstants::kaptonThickness +
+      o2::ft3::ModuleConstants::epoxyThickness * 2 +
+      0.5; // add some extra room to ensure all volumes are encapsulated
+
+    // shift stave volumes into layer volume, since nominal z_{stave face} = 0
+    double z_local_offset = z_layer_thickness / 2.0;
+    TGeoTube* layer = new TGeoTube(mInnerRadius - 12, mOuterRadius + 5, z_layer_thickness / 2);
+    layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
+
+    if (ft3Params.drawReferenceCircles) {
+      std::string referenceCirclesName = "ReferenceCircles_Dir" + std::to_string(mDirection) + "_Layer" + std::to_string(mLayerNumber);
+      createReferenceCircles(layerVol, referenceCirclesName); // for visualization purposes
+    }
+
+    // need the -0.5 added to local offset to ensure all sensor modules are inside the layer
+    module.createModule_staveGeo(0., mLayerNumber, mDirection, mInnerRadius,
+                                 mOuterRadius, z_local_offset, staveConfig, layerVol);
+    // Finally put everything in the mother volume
+    auto* FwdDiskRotation = new TGeoRotation("FwdDiskRotation", 0, 0, 180);
+    // need to shift outwards always, so + forwards and - backwards
+    double z_offset_directional = mDirection ? z_local_offset : -z_local_offset;
+    auto* FwdDiskCombiTrans = new TGeoCombiTrans(0, 0, mZ + z_offset_directional, FwdDiskRotation);
 
     LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
index 4ed330c35ae59..221136000a371 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -13,17 +13,21 @@
 /// \brief Implementation of the FT3Module class
 
 #include "FT3Simulation/FT3Module.h"
+#include "FT3Base/FT3BaseParam.h"
 #include <TGeoManager.h>
 #include <TGeoMaterial.h>
 #include <TGeoMedium.h>
 #include <TGeoBBox.h>
+#include <TGeoXtru.h>
 #include <TGeoMatrix.h>
+#include <TGeoCompositeShape.h>
 #include <Framework/Logger.h>
 #include <cmath>
 #include <iostream>
 #include <vector>
 #include <set>
 #include <algorithm>
+#include <utility>
 
 TGeoMaterial* FT3Module::siliconMat = nullptr;
 TGeoMedium* FT3Module::siliconMed = nullptr;
@@ -40,6 +44,9 @@ TGeoMedium* FT3Module::epoxyMed = nullptr;
 TGeoMaterial* FT3Module::AluminumMat = nullptr;
 TGeoMedium* FT3Module::AluminumMed = nullptr;
 
+TGeoMaterial* FT3Module::carbonFiberMat = nullptr;
+TGeoMedium* FT3Module::carbonFiberMed = nullptr;
+
 void FT3Module::initialize_materials()
 {
   LOG(debug) << "FT3Module: initialize_materials";
@@ -62,6 +69,10 @@ void FT3Module::initialize_materials()
   kaptonMat = new TGeoMaterial("FT3_Kapton", 13.84, 6.88, 1.346);
   kaptonMed = new TGeoMedium("FT3_Kapton", 3, kaptonMat);
 
+  // TODO: Check with Rene the exact type of carbon fiber
+  carbonFiberMat = new TGeoMaterial("FT3_Carbon", 12.0107, 6, 1.8);
+  carbonFiberMed = new TGeoMedium("FT3_Carbon", 6, carbonFiberMat);
+
   // Epoxy: C18 H19 O3
   auto* itsEpoxy = new TGeoMixture("FT3_Epoxy", 3);
   itsEpoxy->AddElement(itsC, 18);
@@ -82,6 +93,643 @@ double calculate_y_circle(double x, double radius)
   return (x * x < radius * radius) ? std::sqrt(radius * radius - x * x) : 0;
 }
 
+std::pair<double, double> calculate_y_range(
+  double x_left, double x_right, double Rin, double Rout)
+{
+  double max_y_abs;
+  double min_y_abs;
+  /*
+   * Have 5 cases:
+   * (1) Stave wholly on the left of inner radius
+   * (2) Stave wholly on the left, but within inner radius
+   * (3) Stave crosses the middle x=0
+   * (4) Stave wholly on the right, but within inner radius
+   * (5) Stave wholly on the right of inner radius
+   */
+  if (x_right < -Rin) {
+    // Stave is completely on the left of inner radius
+    min_y_abs = 0;
+    max_y_abs = calculate_y_circle(x_left, Rout);
+  } else if (x_left < -Constants::sensor2x1_width) {
+    // Stave is completely on the left, but within inner radius
+    min_y_abs = calculate_y_circle(x_right, Rin);
+    max_y_abs = calculate_y_circle(x_left, Rout);
+  } else if (x_left < 0) {
+    // Stave crosses the middle x=0
+    min_y_abs = Rin;
+    // x_right should be > 0, but might have FLP issues, so do abs nonetheless
+    max_y_abs = calculate_y_circle(std::max(std::abs(x_left), std::abs(x_right)), Rout);
+  } else if (x_left < Rin) {
+    // Stave is completely on the right, but within inner radius
+    min_y_abs = calculate_y_circle(x_left, Rin);
+    max_y_abs = calculate_y_circle(x_right, Rout);
+  } else {
+    // Stave is completely on the right of inner radius
+    min_y_abs = 0.;
+    max_y_abs = calculate_y_circle(x_right, Rout);
+  }
+  return {min_y_abs, max_y_abs};
+}
+
+/*
+ * This function is a helper function which will pad out the stave with sensors
+ * until there is no more space available.
+ *
+ * Arguments:
+ * y_positions: a pair of vectors, where each vector contains pairs of
+ *              y position and stack height for the positive and negative y positions respectively.
+ *              This argument will be appended with the new sensor positions and stack heights.
+ * Rout: the outer radius of the layer
+ * Rin: the inner radius of the layer
+ * x_left: the x position of the left edge of the sensor to be placed
+ * kSensorStack: the number of sensors to be stacked on top of each other
+ * tolerance: the tolerance to be subtracted from the maximum y position to avoid
+ *            placing sensors too close to the edge. If this is negative, it effectively
+ *            means that you can place sensors beyond the nominal disc edge
+ * y_start: the y positions to start placing sensors,
+ *          for positive and negative y respectively
+ */
+void FT3Module::fill_stave(PosNegPositionTypes& y_positions, double Rin, double Rout,
+                           double x_left, unsigned kSensorStack, PositionRangeType y_ranges,
+                           std::pair<double, double>& absAllowedYRange)
+{
+  // start with upper half of the stave, then mirror to the bottom half
+  // add the height of kSensorStack sensors + the gaps in between them
+  double sensorStackHeight = Constants::getStackHeight(kSensorStack);
+  double sensorAbsStackYShift = sensorStackHeight + Constants::stackGap;
+
+  // in case a big tolerance is given, cut on the given range instead
+  double max_sensor_y_abs = std::min(absAllowedYRange.second, y_ranges.first.second);
+
+  double y_top; // top half of the xy grid, y>0
+  // either start at given value (adjusted for tolerance), or at last placed sensors
+  if (!y_positions.first.empty()) { // sensors already placed
+    double previousStackHeight = Constants::getStackHeight(y_positions.first.back().second);
+    y_top = y_positions.first.back().first + previousStackHeight + Constants::stackGap;
+  } else if (absAllowedYRange.first > 0) {
+    // there is a minimum inner value --> start at the max of the two
+    y_top = std::max(absAllowedYRange.first, y_ranges.first.first);
+  } else {
+    // No inner minimum value, start at given value
+    y_top = y_ranges.first.first;
+  }
+  // fill positive y sensor positions
+  while ((y_top + sensorStackHeight) <= max_sensor_y_abs) {
+    y_positions.first.emplace_back(y_top, kSensorStack);
+    y_top += sensorAbsStackYShift;
+  }
+
+  // now we do the same for the negative y positions
+  // they do not have to be exactly mirrored, hence done separately
+  double y_bottom;
+  if (!y_positions.second.empty()) {
+    // subtract instead to move further down
+    double previousStackHeight = Constants::getStackHeight(y_positions.second.back().second);
+    y_bottom = y_positions.second.back().first - previousStackHeight - Constants::stackGap;
+  } else if (absAllowedYRange.first > 0) {
+    // there is a minimum inner value --> start at the min of the two
+    y_bottom = std::min(-absAllowedYRange.first, y_ranges.second.first);
+  } else {
+    // No inner minimum value, start at given value
+    y_bottom = y_ranges.second.first;
+  }
+  // fill in the sensors on negative y
+  while ((y_bottom - sensorStackHeight) >= -max_sensor_y_abs) {
+    y_positions.second.emplace_back(y_bottom, kSensorStack);
+    y_bottom -= sensorAbsStackYShift;
+  }
+}
+
+/*
+ * Create the vertices of the triangles that make up the stave cross section
+ *
+ * Each array of 3 corresponds to x or z values of the 3 triangle vertices,
+ * and the outer array corresponds to which triangle:
+ *
+ * [x_outer, z_outer, x_inner, z_inner], each of which has three values
+ */
+std::array<std::array<double, 3>, 4> buildStaveTriangle(int direction)
+{
+  // Set some constants for readability
+  double d = Constants::effectiveCarbonThickness_Stave;
+  double H = Constants::staveTriangleHeight;
+  /*
+   * Inner and outer vertices of the stave cross section triangle
+   * all vertices are at y_mid, we simply extend the triangle into y dir.
+   * We work in the local coordinate system of the stave, but still
+   * call the coordinates x and z for readability.
+   *
+   * 1. Get all local coordinates of the two triangle vertices
+   * 2. Extrude a volume from the subtracted triangle cross section area
+   * 3. Rotate the volume around the x-axis since it is by default in xy,
+   *    and extruded in z. Rotate by -90 for xz -> xy, otherwise xz -> x(-y)
+   * 4. Translate the volume to the given position (arguments)
+   *
+   */
+  std::array<double, 3> xv_inner, xv_outer, zv_inner, zv_outer;
+  // calculate the coordinates of the triangle vertices
+  // Top/bottom vertex (apex)
+  xv_outer[0] = 0;
+  zv_outer[0] = (direction == 1) ? -H
+                                 : H;
+  ;
+  // right
+  xv_outer[1] = Constants::sensor2x1_width / 2 + Constants::staveSensorGap;
+  zv_outer[1] = 0;
+  // left
+  xv_outer[2] = -xv_outer[1];
+  zv_outer[2] = 0;
+
+  // now get inner vertices, shifted inwards by effective carbon thickness
+  xv_inner[0] = xv_outer[0];
+  double z_shift_inner = d / Constants::sinTheta;
+  zv_inner[0] = (direction == 1) ? zv_outer[0] + z_shift_inner
+                                 : zv_outer[0] - z_shift_inner;
+  // face vertices, first right
+  zv_inner[1] = (direction == 1) ? zv_outer[1] - d
+                                 : zv_outer[1] + d;
+  double x_shift_abs = d / TMath::Tan(Constants::alpha / 2);
+  xv_inner[1] = xv_outer[1] - x_shift_abs;
+  // left
+  zv_inner[2] = zv_inner[1];
+  xv_inner[2] = -xv_inner[1];
+
+  return {xv_outer, zv_outer, xv_inner, zv_inner};
+}
+
+/*
+ * This function creates a carbon fibre volume for the stave,
+ * onto which the sensor and its support will be glued.
+ */
+void FT3Module::addStaveVolume(
+  TGeoVolume* motherVolume, std::string volumeName, int direction,
+  unsigned* volume_count, double staveLength,
+  std::array<std::array<double, 3>, 4> staveTriangles,
+  std::pair<double, double>& absAllowedYRange,
+  double x_mid, double y_mid, double z_stave_shift_forward)
+{
+  // The allowed y range is assumed to be non-negative.
+  if (absAllowedYRange.first < 0 || absAllowedYRange.second < 0 ||
+      absAllowedYRange.first >= absAllowedYRange.second) {
+    LOG(error) << "Invalid allowed y range in addStaveVolume(): ("
+               << absAllowedYRange.first << ", " << absAllowedYRange.second
+               << "). Both values must be non-negative and the first "
+               << "value must be less than the second value.";
+    return;
+  }
+  // Set the lower and upper y values of the stave:
+  double y_lower = y_mid - staveLength / 2;
+  double y_upper = y_mid + staveLength / 2;
+  bool splitStave = false;
+  if (y_lower > 0) { // This stave is fully above x-axis
+    y_lower = std::max(y_lower, absAllowedYRange.first);
+    y_upper = std::min(y_upper, absAllowedYRange.second);
+  } else if (y_upper < 0) { // stave entirely below x-axis
+    y_lower = std::max(y_lower, -absAllowedYRange.second);
+    y_upper = std::min(y_upper, -absAllowedYRange.first);
+  } else { // Full range stave that goes across x-axis
+    // Here we might have to cut the stave up into two pieces
+    if (absAllowedYRange.first > 0) {
+      // There is a minimum inner value --> Split stave
+      splitStave = true;
+      y_lower = absAllowedYRange.first;
+    } else {
+      // regular stave, use full length, but don't forget outer cut
+      y_lower = std::max(y_lower, -absAllowedYRange.second);
+    }
+    y_upper = std::min(y_upper, absAllowedYRange.second);
+  }
+  double staveLengthToUse = y_upper - y_lower;
+  /*
+   * create the extruded volumes from z=0 (later y=0 after rotation) to stave length
+   * and not from midpoint - staveLength/2 to midpoint + staveLength/2, translate later
+   *
+   * Note also that we first need to check if the length is allowed given the inner
+   * and outer radius of the layer.
+   */
+  TGeoXtru* staveFull = new TGeoXtru(2);
+  staveFull->SetName((volumeName + "_Xtru_outer").c_str());
+  staveFull->DefinePolygon(3, staveTriangles[0].data(), staveTriangles[1].data());
+  staveFull->DefineSection(0, 0);
+  staveFull->DefineSection(1, staveLengthToUse);
+
+  TGeoXtru* staveInner = new TGeoXtru(2);
+  staveInner->SetName((volumeName + "_Xtru_inner").c_str());
+  staveInner->DefinePolygon(3, staveTriangles[2].data(), staveTriangles[3].data());
+  staveInner->DefineSection(0, 0);
+  staveInner->DefineSection(1, staveLengthToUse);
+
+  TGeoCompositeShape* staveShape = new TGeoCompositeShape(
+    (volumeName + "_shape").c_str(),
+    Form("%s - %s", staveFull->GetName(), staveInner->GetName()));
+  TGeoVolume* staveVolume = new TGeoVolume(
+    (volumeName).c_str(),
+    staveShape,
+    carbonFiberMed);
+  TGeoRotation* rot = new TGeoRotation();
+  rot->RotateX(-90); // lift from xy plane into xz plane
+  /*
+   * After rotations the face of the stave lies in the xy-plane,
+   * facing downwards for direction == 1 and upwards for direction == 0.
+   * We still need to shift it in z to get the right staggered layout.
+   * This means moving the staves that must be shifted in the opposite
+   * direction they are facing: up for direction 1, and down for direction 0.
+   *
+   * Unlike a regular node placement, we have to put the stave at its
+   * starting point in y, not the midpoint. Hence, if we have the mirror,
+   * the starting point is the upper y value, since that is the bottom
+   * of the mirrored stave -- by the outer radius
+   */
+  double z_shift = (direction == 1) ? z_stave_shift_forward : -z_stave_shift_forward;
+  TGeoCombiTrans* combiTrans =
+    new TGeoCombiTrans(x_mid, y_lower, z_shift, rot);
+  motherVolume->AddNode(staveVolume,
+                        *volume_count,
+                        combiTrans);
+  (*volume_count)++;
+
+  // if the stave needs to be split, reuse the same volume on opposite side
+  if (splitStave) {
+    TGeoCombiTrans* combiTransSplit =
+      new TGeoCombiTrans(x_mid, -y_upper, z_shift, rot);
+    motherVolume->AddNode(staveVolume,
+                          *volume_count,
+                          combiTransSplit);
+    (*volume_count)++;
+  }
+}
+
+/*
+ * Generic helper function that adds a box at the given position with
+ * the given dimensions to the given mother volume, with the given color and name.
+ */
+
+void FT3Module::addDetectorVolume(
+  TGeoVolume* motherVolume, std::string volumeName, int color,
+  unsigned* volume_count, double x_mid, double y_mid, double z_mid,
+  double x_half_length, double y_half_length, double z_half_length)
+{
+  TGeoManager* geoManager = gGeoManager;
+  TGeoVolume* volume = geoManager->MakeBox(volumeName.c_str(), siliconMed, x_half_length,
+                                           y_half_length, z_half_length);
+  volume->SetLineColor(color);
+  volume->SetFillColorAlpha(color, 0.4);
+  motherVolume->AddNode(
+    volume,
+    *volume_count,
+    new TGeoTranslation( // midpoint of box to add
+      x_mid,
+      y_mid,
+      z_mid) // TGeoTranslation
+  );         // addNode
+  (*volume_count)++;
+}
+
+/*
+ * This function adds a glue volume between two element layers,
+ * immediately for a whole 2x1 layout, under both the active and inactive region.
+ */
+void FT3Module::add2x1GlueVolume(
+  TGeoVolume* motherVolume, int layerNumber, int direction, unsigned stave_idx,
+  unsigned* volume_count, double x_mid, double y_mid, double z_mid,
+  std::string element_glued_to)
+{
+  std::string glue_name = "FT3glue_" + element_glued_to + "_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(stave_idx) + "_" + std::to_string(*volume_count);
+  addDetectorVolume(
+    motherVolume, glue_name, Constants::glueColor, volume_count,
+    x_mid, y_mid, z_mid,
+    Constants::sensor2x1_width / 2, Constants::sensor2x1_height / 2, Constants::epoxyThickness / 2);
+}
+
+/*
+ * This function adds a copper volume onto which the silicon sensor is glued.
+ * As with the glue, this is a whole 2x1 layout volume.
+ */
+void FT3Module::add2x1CopperVolume(
+  TGeoVolume* motherVolume, int layerNumber, int direction, unsigned stave_idx,
+  unsigned* volume_count, double x_mid, double y_mid, double z_mid)
+{
+  std::string copper_name = "FT3Copper_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(stave_idx) + "_" + std::to_string(*volume_count);
+  addDetectorVolume(
+    motherVolume, copper_name, Constants::CuColor, volume_count,
+    x_mid, y_mid, z_mid,
+    Constants::sensor2x1_width / 2, Constants::sensor2x1_height / 2, Constants::copperThickness / 2);
+}
+
+/*
+ * This function adds a kapton volume behind the copper, which represents the ???
+ * As with copper and glue, this is a whole 2x1 layout volume.
+ */
+void FT3Module::add2x1KaptonVolume(
+  TGeoVolume* motherVolume, int layerNumber, int direction, unsigned stave_idx,
+  unsigned* volume_count, double x_mid, double y_mid, double z_mid)
+{
+  std::string kapton_name = "FT3Kapton_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(stave_idx) + "_" + std::to_string(*volume_count);
+  addDetectorVolume(
+    motherVolume, kapton_name, Constants::kaptonColor, volume_count,
+    x_mid, y_mid, z_mid,
+    Constants::sensor2x1_width / 2, Constants::sensor2x1_height / 2, Constants::kaptonThickness / 2);
+}
+
+/*
+ * This function adds a single sensor (currently 2.5x3.2mm) to the given mother volume
+ * at the given (x,y,z) position of the module.
+ *
+ * Because the sensor has an inactive region of 0.2mm on one side, we also add a
+ * separate volume for the inactive region, which will be either on the left or
+ * or right dependent on the if the sensor is on the left or right in a 2x1 layout.
+ * See FT3Module.h for more details on the layout.
+ *
+ * Arguments:
+ * motherVolume: the volume to which the sensor volume will be added
+ * layerNumber: the layer number of the sensor, used for naming
+ * direction: the direction of the sensor (forward or backward eta), used for naming
+ * x_mid: the x position of the center of the sensor volume
+ * y_mid: the y position of the center of the sensor volume
+ * z_mid: the z position of the center of the sensor volume
+ * isLeft: whether the sensor is on the left or right in the 2x1 layout
+ */
+void FT3Module::addSingleSensorVolume(
+  TGeoVolume* motherVolume, int layerNumber, int direction, unsigned stave_idx,
+  unsigned* volume_count, double active_x_mid, double y_mid, double z_mid,
+  bool isLeft)
+{
+  TGeoVolume* sensor;
+  TGeoManager* geoManager = gGeoManager;
+  // ACTIVE AREA
+  std::string sensor_name = "FT3Sensor_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(stave_idx) + "_" + std::to_string(*volume_count);
+  sensor = geoManager->MakeBox(sensor_name.c_str(), siliconMed, Constants::active_width / 2,
+                               Constants::single_sensor_height / 2, Constants::siliconThickness / 2);
+  sensor->SetLineColor(Constants::SiColor);
+  sensor->SetFillColorAlpha(Constants::SiColor, 0.4);
+  motherVolume->AddNode(
+    sensor,
+    *volume_count,
+    new TGeoTranslation( // midpoint of box to add
+      active_x_mid,
+      y_mid,
+      z_mid) // TGeoTranslation
+  );         // addNode
+  (*volume_count)++;
+  // INACTIVE STRIP ON LEFT OR RIGHT
+  double inactive_x_mid = isLeft ? (active_x_mid - Constants::active_width / 2 - Constants::inactive_width / 2)
+                                 : (active_x_mid + Constants::active_width / 2 + Constants::inactive_width / 2);
+  std::string sensor_inactive_name =
+    "FT3Sensor_Inactive_" + std::to_string(layerNumber) + "_" + std::to_string(direction) + "_" + std::to_string(stave_idx) + "_" + std::to_string(*volume_count);
+  sensor = geoManager->MakeBox(sensor_inactive_name.c_str(), siliconMed, Constants::inactive_width / 2,
+                               Constants::single_sensor_height / 2, Constants::siliconThickness / 2);
+  sensor->SetLineColor(Constants::SiInactiveColor);
+  sensor->SetFillColorAlpha(Constants::SiInactiveColor, 0.4);
+  motherVolume->AddNode(
+    sensor,
+    *volume_count,
+    new TGeoTranslation( // midpoint of box to add
+      inactive_x_mid,
+      y_mid,
+      z_mid) // TGeoTranslation
+  );         // addNode
+  (*volume_count)++;
+}
+
+void FT3Module::create_layout_staveGeo(double mZ, int layerNumber, int direction,
+                                       double Rin, double Rout, double z_offset_local,
+                                       const Constants::StaveConfig& staveConfig,
+                                       TGeoVolume* motherVolume)
+{
+  LOG(debug) << "FT3Module: create_layout_staveGeo - Layer "
+             << layerNumber << ", Direction " << direction;
+
+  FT3Module::initialize_materials();
+  auto& ft3Params = o2::ft3::FT3BaseParam::Instance();
+
+  // First let's define some constants used throughout
+  /*
+   * we build the volume from the outside in, starting with the silicon,
+   * then glue & materials towards the stave. Depending on direction,
+   * the distance from the center will be mirrored.
+   *
+   * | SILICON SENSOR | GLUE | COPPER | KAPTON | GLUE | CARBON STAVE |
+   * ----------------------------------------------------------------> z
+   *
+   * Naturally, this will be mirrored for layers in the backwards direction,
+   * such that the face of the sensors always face the interaction region.
+   *
+   * Currently, we stipulate that the default stave face is at local z=0,
+   * that is then shifted by the half air thickness encapsulating the layer
+   * to avoid overlaps with the air and services. All offsets are
+   * calculated for backward direction (since that is a positive shift),
+   * and then flipped for forward. At that point, the innermost/frontmost
+   * stave face is at the edge of the air volume, so we shift it back a little
+   * to make space for the sensor materials and a slight margin.
+   */
+  double totalSensorMaterialThickness =
+    Constants::epoxyThickness + Constants::kaptonThickness + Constants::copperThickness +
+    Constants::epoxyThickness + Constants::siliconThickness;
+  double z_offset_to_carbon_face = z_offset_local - totalSensorMaterialThickness - 0.1;
+  double z_offset_to_glue_Ka =
+    z_offset_to_carbon_face + Constants::epoxyThickness / 2;
+  double z_offset_to_kapton =
+    z_offset_to_carbon_face + Constants::epoxyThickness +
+    Constants::kaptonThickness / 2;
+  double z_offset_to_copper =
+    z_offset_to_carbon_face + Constants::epoxyThickness +
+    Constants::kaptonThickness + Constants::copperThickness / 2;
+  double z_offset_to_glue_Si =
+    z_offset_to_carbon_face + Constants::epoxyThickness + Constants::kaptonThickness +
+    Constants::copperThickness + Constants::epoxyThickness / 2;
+  double z_offset_to_silicon =
+    z_offset_to_carbon_face + Constants::epoxyThickness +
+    Constants::kaptonThickness + Constants::copperThickness +
+    Constants::epoxyThickness + Constants::siliconThickness / 2;
+
+  // initialise all y_positions, vector over all staves/columns
+  std::vector<PosNegPositionTypes> y_positionsPosNeg;
+  unsigned volume_count = 0; // give each subvolume a unique ID
+  // stave triangle cross sections are the same for every stave (direction based)
+  std::array<std::array<double, 3>, 4> staveTriangles = buildStaveTriangle(direction);
+  // Create the stave volumes and fill the y positions where to put sensors on the stave
+  for (unsigned i_stave = 0; i_stave < staveConfig.x_midpoints.size(); i_stave++) {
+    y_positionsPosNeg.emplace_back(PosNegPositionTypes{PositionTypes{}, PositionTypes{}});
+    const int staveID = Constants::staveIdxToID(i_stave, staveConfig.x_midpoints.size());
+
+    double y_midpoint = 0.;
+    bool mirrorStaveAroundX = false;
+    // default positive and negative starting points has a gap around x-axis for symmetry
+    double stave_half_length = staveConfig.y_lengths[i_stave] / 2;
+    PositionRangeType y_ranges;
+    if (ft3Params.placeSensorInMiddleOfStave) {
+      /*
+       * We want a sensor to cross over the x-axis for coverage at y=0
+       * N.B. not necessarily exactly mirrored, only if stack gap is the same
+       * as the gap between sensors in a stack.
+       */
+      y_ranges = {{-Constants::sensor2x1_height / 2,
+                   stave_half_length},
+                  {-Constants::sensor2x1_height / 2 - Constants::stackGap,
+                   -stave_half_length}};
+    } else {
+      /*
+       * Otherwise have a gap around y=0, so sensors are not placed there.
+       * This means the stave is perfectly mirrored around the x-axis.
+       */
+      y_ranges = {{Constants::stackGap / 2, stave_half_length},
+                  {-Constants::stackGap / 2, -stave_half_length}};
+    }
+    auto y_midpoint_it = staveConfig.staveID_to_y_midpoint.find(staveID);
+    if (y_midpoint_it != staveConfig.staveID_to_y_midpoint.end()) {
+      // there is a defined midpoint for this stave, use this for starting points
+      y_midpoint = y_midpoint_it->second.first; // avoid double map lookup
+      mirrorStaveAroundX = y_midpoint_it->second.second;
+      y_ranges.first = {y_midpoint - stave_half_length, y_midpoint + stave_half_length};
+      y_ranges.second = {-y_midpoint + stave_half_length, -y_midpoint - stave_half_length};
+    }
+
+    // Define tolerances for cutting staves and placing sensors
+    double tolerance_inner = -1000; // large negative number to allow given numbers
+    double tolerance_outer = -1000;
+    // cut staves on nominal inner radius if specified
+    if (ft3Params.cutStavesOnNominalRadius_inner) {
+      tolerance_inner = 0.;
+    }
+    if (ft3Params.cutStavesOnNominalRadius_outer) {
+      tolerance_outer = 0.;
+    }
+
+    /*
+     * There are three cases in which we want to mirror the stave around the x-axis,
+     * which correspond to the stave not going fully from + to - Rout in y.
+     *
+     * (1) The inner tolerance is 0 (or positive)
+     *    a) AND either x_left or x_right lies within the inner radius
+     * (2) The inner tolerance is large (allow stave placement as wished)
+     *    a) AND the given stave midpoint is above the inner radius
+     */
+    double x_left = staveConfig.x_midpoints[i_stave] - Constants::sensor2x1_width / 2;
+    double x_right = x_left + Constants::sensor2x1_width;
+    std::pair<double, double> absAllowedYRange =
+      calculate_y_range(x_left, x_right, Rin, Rout);
+
+    /*
+     * Shift allowed range by tolerance. Note that both values in the range must
+     * be non-negative, and if the inner is not, then set it to 0. This just means
+     * that there is no lower limit. The upper limit must however be larger than 0,
+     * if it is not, then skip this stave and give a warning.
+     */
+    absAllowedYRange.first += tolerance_inner;
+    absAllowedYRange.second -= tolerance_outer;
+
+    if (absAllowedYRange.first < 0) {
+      absAllowedYRange.first = 0;
+    }
+    if (absAllowedYRange.second <= 0) {
+      LOG(warning) << "For stave " << i_stave << " in layer " << layerNumber
+                   << " with direction " << direction << ": no space to place sensors after applying tolerances, skipping stave.";
+      continue;
+    }
+
+    // Get whether the stave is shifted backward or not before creating
+    double z_stave_shift_abs = staveConfig.staveOnFront[i_stave] ? 0 : Constants::z_offsetStave(staveConfig.x_midpoint_spacing);
+    double z_stave_shift_forward = // move staves more inward to fit in layer volume
+      -z_offset_to_carbon_face + z_stave_shift_abs;
+    std::string stave_volume_name =
+      "Stave_" + std::to_string(i_stave) + "_" + std::to_string(layerNumber) +
+      "_" + std::to_string(direction);
+    addStaveVolume(
+      motherVolume, stave_volume_name, direction, &volume_count,
+      staveConfig.y_lengths[i_stave], staveTriangles, absAllowedYRange,
+      staveConfig.x_midpoints[i_stave], y_midpoint, z_stave_shift_forward);
+    // Now create the mirrored stave
+    if (mirrorStaveAroundX) {
+      addStaveVolume(
+        motherVolume, stave_volume_name + "_mirrored", direction, &volume_count,
+        staveConfig.y_lengths[i_stave], staveTriangles, absAllowedYRange,
+        staveConfig.x_midpoints[i_stave], -y_midpoint, z_stave_shift_forward);
+    }
+
+    // now add the sensor positions on the stave
+    for (unsigned i_kSens = 0; i_kSens < Constants::kSensorsPerStack.size(); i_kSens++) {
+      fill_stave(y_positionsPosNeg.back(), Rin, Rout, x_left,
+                 Constants::kSensorsPerStack[i_kSens], y_ranges,
+                 absAllowedYRange);
+    }
+  }
+
+  // Create volumes for the sensors and the support materials on top of the stave
+  for (unsigned i_stave = 0; i_stave < staveConfig.x_midpoints.size(); i_stave++) {
+    double x_mid = staveConfig.x_midpoints[i_stave];
+    int staveID = Constants::staveIdxToID(i_stave, staveConfig.x_midpoints.size());
+    /*
+     * Declare an offset multiplier for the z offsets, used for distinguishing
+     * sensors facing either forward or backward.
+     *
+     * In the stave layout, all sensors face inward, and isFront
+     * refers to whether a stave is shifted backwards or not. Thus,
+     * we decide the offset multiplier only with direction, to
+     * keep the face facing inwards.
+     */
+    bool isFront;
+    if (direction == 1) { // direction = 1 is forward
+      isFront = staveConfig.staveOnFront[i_stave];
+    } else {
+      isFront = !(staveConfig.staveOnFront[i_stave]);
+    }
+    int z_offset_multiplier = (direction == 1) ? -1 : 1;
+
+    // Get whether the stave is shifted for staggering or not
+    double z_stave_shift = 0;
+    if (!staveConfig.staveOnFront[i_stave]) {
+      // in forward direction, shifting backwards means +z shift
+      z_stave_shift = (direction == 1) ? Constants::z_offsetStave(staveConfig.x_midpoint_spacing)
+                                       : -Constants::z_offsetStave(staveConfig.x_midpoint_spacing);
+    }
+
+    for (int y_sign = -1; y_sign < 2; y_sign += 2) {
+      // place sensors at positive and negative y
+      const auto& positions = (y_sign == 1) ? y_positionsPosNeg[i_stave].first
+                                            : y_positionsPosNeg[i_stave].second;
+      // define starting midpoint: y = y_start +- distance to middle of sensor
+      for (unsigned i_y_pos = 0; i_y_pos < positions.size(); i_y_pos++) {
+        double y_mid = positions[i_y_pos].first + y_sign * Constants::sensor2x1_height / 2;
+        for (unsigned i_sens = 0; i_sens < positions[i_y_pos].second; i_sens++) {
+          TGeoVolume* sensor;
+          // ------------ (1) Silicon sensor ------------
+          // left single sensor of the 2x1
+          double z_mid = z_offset_to_silicon * z_offset_multiplier + z_stave_shift;
+          addSingleSensorVolume(
+            motherVolume, layerNumber, direction, i_stave, &volume_count,
+            x_mid - Constants::active_width / 2, y_mid, z_mid, true);
+          // right single sensor of the 2x1
+          addSingleSensorVolume(
+            motherVolume, layerNumber, direction, i_stave, &volume_count,
+            x_mid + Constants::active_width / 2, y_mid, z_mid, false);
+          // ------------ (2) Epoxy glue layer between silicon and copper (FPC) ------------
+          z_mid = z_offset_to_glue_Si * z_offset_multiplier + z_stave_shift;
+          add2x1GlueVolume(
+            motherVolume, layerNumber, direction, i_stave, &volume_count,
+            x_mid, y_mid, z_mid, "SiCu");
+          // ------------ (3) Copper layer (FPC) ------------
+          z_mid = z_offset_to_copper * z_offset_multiplier + z_stave_shift;
+          add2x1CopperVolume(
+            motherVolume, layerNumber, direction, i_stave, &volume_count,
+            x_mid, y_mid, z_mid);
+          // ------------ (4) Kapton layer (FPC) ------------
+          z_mid = z_offset_to_kapton * z_offset_multiplier + z_stave_shift;
+          add2x1KaptonVolume(
+            motherVolume, layerNumber, direction, i_stave, &volume_count,
+            x_mid, y_mid, z_mid);
+          // ------------ (5) Epoxy glue layer between stave and Kapton ------------
+          z_mid = z_offset_to_glue_Ka * z_offset_multiplier + z_stave_shift;
+          add2x1GlueVolume(
+            motherVolume, layerNumber, direction, i_stave, &volume_count,
+            x_mid, y_mid, z_mid, "CarbonKapton");
+          // increment to next sensor: (height + gap of one sensor)
+          y_mid += y_sign * (Constants::sensor2x1_height + Constants::sensor2x1_gap);
+        } // sensors in stack
+      } // for y_sign (writing of positive or negative y positions)
+    } // i_y_pos
+  } // i_stave
+}
+
 void FT3Module::create_layout(double mZ, int layerNumber, int direction, double Rin, double Rout, double overlap, const std::string& face, const std::string& layout_type, TGeoVolume* motherVolume)
 {
 
@@ -740,3 +1388,15 @@ void FT3Module::createModule(double mZ, int layerNumber, int direction, double R
   create_layout(mZ, layerNumber, direction, Rin, Rout, overlap, face, layout_type, motherVolume);
   LOG(debug) << "FT3Module: done createModule";
 }
+
+void FT3Module::createModule_staveGeo(double mZ, int layerNumber, int direction,
+                                      double Rin, double Rout, double z_offset_local,
+                                      const Constants::StaveConfig& staveConfig,
+                                      TGeoVolume* motherVolume)
+{
+  LOG(debug) << "FT3Module: createModule_staveGeo - Layer " << layerNumber
+             << " at z=" << mZ << ", Direction " << direction;
+  create_layout_staveGeo(mZ, layerNumber, direction, Rin, Rout,
+                         z_offset_local, staveConfig, motherVolume);
+  LOG(debug) << "FT3Module: done createModule_staveGeo";
+}

From d477eed4d180328b3411ceb78bc000c5c05c1aed Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 4 May 2026 18:58:36 +0200
Subject: [PATCH 1688/1764] Optionally postpocess histoManagers before drawing

---
 .../GlobalTrackingStudy/CheckResidSpec.h      |  2 +-
 .../study/src/CheckResidSpec.cxx              | 90 +++++++++++--------
 .../study/src/check-resid-workflow.cxx        |  5 +-
 3 files changed, 59 insertions(+), 38 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidSpec.h b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidSpec.h
index fceba6cb000fd..3cae8e94b8e68 100644
--- a/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidSpec.h
+++ b/Detectors/GlobalTrackingWorkflow/study/include/GlobalTrackingStudy/CheckResidSpec.h
@@ -19,7 +19,7 @@
 namespace o2::checkresid
 {
 /// create a processor spec
-o2::framework::DataProcessorSpec getCheckResidSpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool drawOnly);
+o2::framework::DataProcessorSpec getCheckResidSpec(o2::dataformats::GlobalTrackID::mask_t srcTracks, o2::dataformats::GlobalTrackID::mask_t srcClus, bool drawOnly, bool postProcOnly);
 
 } // namespace o2::checkresid
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
index ff73be857346f..01ec999fce1eb 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
@@ -75,8 +75,8 @@ using timeEst = o2::dataformats::TimeStampWithError<float, float>;
 class CheckResidSpec : public Task
 {
  public:
-  CheckResidSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool drawOnly)
-    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mDrawOnly(drawOnly)
+  CheckResidSpec(std::shared_ptr<DataRequest> dr, std::shared_ptr<o2::base::GRPGeomRequest> gr, GTrackID::mask_t src, bool drawOnly, bool postProcOnly)
+    : mDataRequest(dr), mGGCCDBRequest(gr), mTracksSrc(src), mDrawOnly(drawOnly), mPostProcOnly(postProcOnly)
   {
   }
   ~CheckResidSpec() final = default;
@@ -110,6 +110,7 @@ class CheckResidSpec : public Task
   GTrackID::mask_t mTracksSrc{};
 
   bool mDrawOnly = false;
+  bool mPostProcOnly = false;
   bool mDraw = false;
   bool mFillHistos = true;
   bool mFillTree = true;
@@ -179,8 +180,17 @@ void CheckResidSpec::init(InitContext& ic)
 
 void CheckResidSpec::run(ProcessingContext& pc)
 {
+  bool quit = false;
+  if (mPostProcOnly) {
+
+    postProcessHistos();
+    quit = true;
+  }
   if (mDrawOnly) {
     drawHistos();
+    quit = true;
+  }
+  if (quit) {
     pc.services().get<ControlService>().endOfStream();
     pc.services().get<ControlService>().readyToQuit(QuitRequest::Me);
     return;
@@ -689,43 +699,53 @@ void CheckResidSpec::bookHistos()
 void CheckResidSpec::postProcessHistos()
 {
   printf("Fitting histos\n");
+  if (!mHMan) {
+    if (mHManV.empty()) {
+      LOGP(warn, "nothing to process");
+      return;
+    }
+    mHMan = mHManV[0].get();
+  }
   const auto& params = o2::checkresid::CheckResidConfig::Instance();
   auto gs = new TF1("gs", "gaus", -1, 1);
+  int maxH = mPostProcOnly ? mHManV.size() : 1;
   TObjArray arr;
-  auto* histm = mHMan;
-  auto fitSlices = [&](int id) {
-    auto h2 = histm->getHisto2F(id);
-    if (!h2 || h2->GetEntries() < params.minHistoStat2Fit) {
-      return;
-    }
-    h2->FitSlicesY(gs, 0, -1, 0, "QNR", &arr);
-    arr.SetOwner(true);
-    TH1* hmean = (TH1*)arr.RemoveAt(1);
-    if (hmean) {
-      hmean->SetTitle(Form("<%s>", h2->GetTitle()));
-      histm->addHisto(hmean, id + 1);
-    }
-    TH1* hsig = (TH1*)arr.RemoveAt(2);
-    if (hsig) {
-      hsig->SetTitle(Form("#sigma(%s)", h2->GetTitle()));
-      histm->addHisto(hsig, id + 2);
-    }
-  };
-  for (int ioffs = 0; ioffs <= 3; ioffs++) { // vs phi, Z, pT, tgl
-    int offs = ioffs * 1000;
-    for (int iht = 0; iht < 2; iht++) { // resid, pull
-      int offsV = iht == 0 ? 0 : 5;
-      for (int il = 0; il < 8; il++) {
-        for (int iyz = 0; iyz < 2; iyz++) {
-          fitSlices(il * 10 + iyz * 100 + offsV + offs);
-        }
+  for (int ihm = 0; ihm < maxH; ihm++) {
+    auto* histm = mHManV[ihm].get();
+    auto fitSlices = [&](int id) {
+      auto h2 = histm->getHisto2F(id);
+      if (!h2 || h2->GetEntries() < params.minHistoStat2Fit) {
+        return;
+      }
+      h2->FitSlicesY(gs, 0, -1, 0, "QNR", &arr);
+      arr.SetOwner(true);
+      TH1* hmean = (TH1*)arr.RemoveAt(1);
+      if (hmean) {
+        hmean->SetTitle(Form("<%s>", h2->GetTitle()));
+        histm->addHisto(hmean, id + 1);
+      }
+      TH1* hsig = (TH1*)arr.RemoveAt(2);
+      if (hsig) {
+        hsig->SetTitle(Form("#sigma(%s)", h2->GetTitle()));
+        histm->addHisto(hsig, id + 2);
       }
-      for (int ip = 0; ip < 5; ip++) {
-        fitSlices(10000 + ip * 10 + offsV + offs);
+    };
+    for (int ioffs = 0; ioffs <= 3; ioffs++) { // vs phi, Z, pT, tgl
+      int offs = ioffs * 1000;
+      for (int iht = 0; iht < 2; iht++) { // resid, pull
+        int offsV = iht == 0 ? 0 : 5;
+        for (int il = 0; il < 8; il++) {
+          for (int iyz = 0; iyz < 2; iyz++) {
+            fitSlices(il * 10 + iyz * 100 + offsV + offs);
+          }
+        }
+        for (int ip = 0; ip < 5; ip++) {
+          fitSlices(10000 + ip * 10 + offsV + offs);
+        }
       }
     }
+    histm->write();
   }
-  histm->write();
   delete gs;
 }
 
@@ -922,11 +942,11 @@ void CheckResidSpec::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
   }
 }
 
-DataProcessorSpec getCheckResidSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool drawOnly)
+DataProcessorSpec getCheckResidSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t srcClusters, bool drawOnly, bool postProcOnly)
 {
   std::vector<OutputSpec> outputs;
   auto dataRequest = std::make_shared<DataRequest>();
-  if (!drawOnly) {
+  if (!drawOnly && !postProcOnly) {
     bool useMC = false;
     dataRequest->requestTracks(srcTracks, useMC);
     dataRequest->requestClusters(srcClusters, useMC);
@@ -954,7 +974,7 @@ DataProcessorSpec getCheckResidSpec(GTrackID::mask_t srcTracks, GTrackID::mask_t
     "check-resid",
     dataRequest->inputs,
     outputs,
-    AlgorithmSpec{adaptFromTask<CheckResidSpec>(dataRequest, ggRequest, srcTracks, drawOnly)},
+    AlgorithmSpec{adaptFromTask<CheckResidSpec>(dataRequest, ggRequest, srcTracks, drawOnly, postProcOnly)},
     opts};
 }
 
diff --git a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
index 72188eb5f06c6..0791d72474ad3 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/check-resid-workflow.cxx
@@ -38,6 +38,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   // option allowing to set parameters
   std::vector<o2::framework::ConfigParamSpec> options{
     {"draw-external-only", VariantType::Bool, false, {"just draw content of comma-separated list of histomanagers from checkresid.ext_hm_list"}},
+    {"postproc-external-only", VariantType::Bool, false, {"just post-process raw content of comma-separated list of histomanagers from checkresid.ext_hm_list"}},
     {"track-sources", VariantType::String, std::string{GID::ALL}, {"comma-separated list of track sources to use"}},
     {"cluster-sources", VariantType::String, "ITS", {"comma-separated list of cluster sources to use"}},
     {"disable-root-input", VariantType::Bool, false, {"disable root-files input reader"}},
@@ -57,7 +58,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   WorkflowSpec specs;
 
   bool drawOnly = configcontext.options().get<bool>("draw-external-only");
-
+  bool postProcOnly = configcontext.options().get<bool>("postproc-external-only");
   GID::mask_t allowedSourcesTrc = GID::getSourcesMask("ITS,TPC,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF");
   GID::mask_t allowedSourcesClus = GID::getSourcesMask("ITS");
 
@@ -74,7 +75,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     allowedSourcesTrc = {};
     allowedSourcesClus = {};
   }
-  specs.emplace_back(o2::checkresid::getCheckResidSpec(srcTrc, srcCls, drawOnly));
+  specs.emplace_back(o2::checkresid::getCheckResidSpec(srcTrc, srcCls, drawOnly, postProcOnly));
 
   // configure dpl timer to inject correct firstTForbit: start from the 1st orbit of TF containing 1st sampled orbit
   if (!drawOnly) {

From 1678fd707a1a519e87e1d7c6b8c735852c71126f Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Mon, 4 May 2026 15:28:07 +0200
Subject: [PATCH 1689/1764] Option to write only ROFRecord to ITS/MFT clusters
 file:

With --cluster-rof-branch-only passed to the ITS or MFT reco workflows the
cluster writing will be activated (even if --disable-root-output was globally
passed to the workflows) and only the ROFRecords branch will be stored.

Option to scale the ITS entropy decoding with N_ITSENTDEC or MULTIPLICITY_PROCESS_its_entropy_decoder
env. var.
---
 .../ITSWorkflow/ClusterWriterWorkflow.h        |  2 +-
 .../include/ITSWorkflow/RecoWorkflow.h         |  2 +-
 .../ITS/workflow/src/ClusterWriterWorkflow.cxx |  4 ++--
 .../ITSMFT/ITS/workflow/src/RecoWorkflow.cxx   |  5 +++--
 .../src/its-cluster-writer-workflow.cxx        | 10 +++++++++-
 .../ITS/workflow/src/its-reco-workflow.cxx     |  5 ++++-
 .../include/MFTWorkflow/RecoWorkflow.h         |  1 +
 .../ITSMFT/MFT/workflow/src/RecoWorkflow.cxx   |  5 +++--
 .../src/mft-cluster-writer-workflow.cxx        |  7 ++++---
 .../MFT/workflow/src/mft-reco-workflow.cxx     |  5 ++++-
 .../include/ITSMFTWorkflow/ClusterWriterSpec.h |  6 +++---
 .../common/workflow/src/ClusterWriterSpec.cxx  | 18 +++++++++++++++---
 prodtests/full-system-test/dpl-workflow.sh     |  2 +-
 13 files changed, 51 insertions(+), 21 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterWorkflow.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterWorkflow.h
index a91038b32a1c1..868c57f70df24 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterWorkflow.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/ClusterWriterWorkflow.h
@@ -23,7 +23,7 @@ namespace its
 
 namespace cluster_writer_workflow
 {
-framework::WorkflowSpec getWorkflow(bool useMC, bool doStag);
+framework::WorkflowSpec getWorkflow(bool useMC, bool doStag, bool clusterROFOnly = false);
 }
 
 } // namespace its
diff --git a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
index bfbde0093d55d..3068954c92003 100644
--- a/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
+++ b/Detectors/ITSMFT/ITS/workflow/include/ITSWorkflow/RecoWorkflow.h
@@ -27,7 +27,7 @@ namespace reco_workflow
 {
 
 framework::WorkflowSpec getWorkflow(bool useMC, bool doStag, TrackingMode::Type trmode, const bool overrideBeamPosition = false,
-                                    bool upstreamDigits = false, bool upstreamClusters = false, bool disableRootOutput = false, bool useGeom = false, int useTrig = 0,
+                                    bool upstreamDigits = false, bool upstreamClusters = false, bool clrofOnly = false, bool disableRootOutput = false, bool useGeom = false, int useTrig = 0,
                                     bool useGPUWF = false, o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
 }
 
diff --git a/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
index 35c911f856436..e05e55ffabd18 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/ClusterWriterWorkflow.cxx
@@ -22,11 +22,11 @@ namespace its
 namespace cluster_writer_workflow
 {
 
-framework::WorkflowSpec getWorkflow(bool useMC, bool doStag)
+framework::WorkflowSpec getWorkflow(bool useMC, bool doStag, bool clusterROFOnly)
 {
   framework::WorkflowSpec specs;
 
-  specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC, doStag));
+  specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC, doStag, clusterROFOnly));
 
   return specs;
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
index 5da4b080995b5..06b3f019a6be7 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/RecoWorkflow.cxx
@@ -32,6 +32,7 @@ framework::WorkflowSpec getWorkflow(bool useMC, bool doStag,
                                     const bool overrideBeamPosition,
                                     bool upstreamDigits,
                                     bool upstreamClusters,
+                                    bool clrofOnly,
                                     bool disableRootOutput,
                                     bool useGeom,
                                     int useTrig,
@@ -45,8 +46,8 @@ framework::WorkflowSpec getWorkflow(bool useMC, bool doStag,
   if (!upstreamClusters) {
     specs.emplace_back(o2::itsmft::getITSClustererSpec(useMC, doStag));
   }
-  if (!disableRootOutput) {
-    specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC, doStag));
+  if (!disableRootOutput || clrofOnly) {
+    specs.emplace_back(o2::itsmft::getITSClusterWriterSpec(useMC, doStag, clrofOnly));
   }
   if ((trmode != TrackingMode::Off) && (TrackerParamConfig::Instance().trackingMode != TrackingMode::Off)) {
     if (useGPUWF) {
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-cluster-writer-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-cluster-writer-workflow.cxx
index c10a1659d5f76..6c46f6b038571 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-cluster-writer-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-cluster-writer-workflow.cxx
@@ -30,6 +30,13 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
       o2::framework::VariantType::Bool,
       false,
       {"disable MC propagation even if available"}});
+  workflowOptions.push_back(
+    ConfigParamSpec{
+      "cluster-rof-branch-only",
+      o2::framework::VariantType::Bool,
+      false,
+      {"writer will store only ClustersROF brunch"}});
+
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(workflowOptions);
 }
 
@@ -39,5 +46,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   auto doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext);
-  return std::move(o2::its::cluster_writer_workflow::getWorkflow(useMC, doStag));
+  auto clrofOnly = configcontext.options().get<bool>("cluster-rof-branch-only");
+  return std::move(o2::its::cluster_writer_workflow::getWorkflow(useMC, doStag, clrofOnly));
 }
diff --git a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
index bdade0effcbf0..f1d60b8ac2c9b 100644
--- a/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
+++ b/Detectors/ITSMFT/ITS/workflow/src/its-reco-workflow.cxx
@@ -50,7 +50,8 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight ITS part"}},
     {"use-gpu-workflow", o2::framework::VariantType::Bool, false, {"use GPU workflow (default: false)"}},
-    {"gpu-device", o2::framework::VariantType::Int, 1, {"use gpu device: CPU=1,CUDA=2,HIP=3 (default: CPU)"}}};
+    {"gpu-device", o2::framework::VariantType::Int, 1, {"use gpu device: CPU=1,CUDA=2,HIP=3 (default: CPU)"}},
+    {"cluster-rof-branch-only", o2::framework::VariantType::Bool, false, {"writer will store only ClustersROF brunch"}}};
   o2::itsmft::DPLAlpideParamInitializer::addITSConfigOption(options);
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   std::swap(workflowOptions, options);
@@ -75,6 +76,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
   auto doStag = o2::itsmft::DPLAlpideParamInitializer::isITSStaggeringEnabled(configcontext);
+  auto clrofOnly = configcontext.options().get<bool>("cluster-rof-branch-only");
   if (configcontext.options().get<bool>("disable-tracking")) {
     trmode = "off";
   }
@@ -97,6 +99,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     beamPosOVerride,
     extDigits,
     extClusters,
+    clrofOnly,
     disableRootOutput,
     useGeom,
     trType,
diff --git a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/RecoWorkflow.h b/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/RecoWorkflow.h
index 51234e2e8017d..73ffc744f915b 100644
--- a/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/RecoWorkflow.h
+++ b/Detectors/ITSMFT/MFT/workflow/include/MFTWorkflow/RecoWorkflow.h
@@ -29,6 +29,7 @@ framework::WorkflowSpec getWorkflow(
   bool useGeom,
   bool upstreamDigits,
   bool upstreamClusters,
+  bool clrofOnly,
   bool disableRootOutput,
   bool runAssessment,
   bool processGen,
diff --git a/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
index fb99715cae4ee..178c1dd50f4df 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/RecoWorkflow.cxx
@@ -36,6 +36,7 @@ framework::WorkflowSpec getWorkflow(
   bool useGeom,
   bool upstreamDigits,
   bool upstreamClusters,
+  bool clrofOnly,
   bool disableRootOutput,
   bool runAssessment,
   bool processGen,
@@ -55,8 +56,8 @@ framework::WorkflowSpec getWorkflow(
   if (!upstreamClusters) {
     specs.emplace_back(o2::itsmft::getMFTClustererSpec(useMC, doStag));
   }
-  if (!disableRootOutput) {
-    specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC, doStag));
+  if (!disableRootOutput || clrofOnly) {
+    specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC, doStag, clrofOnly));
   }
 
   if (runTracking) {
diff --git a/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
index 5a5112e03c866..99aad4d8c57f4 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/mft-cluster-writer-workflow.cxx
@@ -24,8 +24,8 @@ void customize(std::vector<o2::framework::CompletionPolicy>& policies)
 
 void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
 {
-  workflowOptions.push_back(
-    ConfigParamSpec{"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}});
+  workflowOptions.push_back(ConfigParamSpec{"disable-mc", o2::framework::VariantType::Bool, false, {"disable MC propagation even if available"}});
+  workflowOptions.push_back(ConfigParamSpec{"cluster-rof-branch-only", o2::framework::VariantType::Bool, false, {"writer will store only ClustersROF brunch"}});
   o2::itsmft::DPLAlpideParamInitializer::addMFTConfigOption(workflowOptions);
 }
 
@@ -35,7 +35,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   auto useMC = !configcontext.options().get<bool>("disable-mc");
   auto doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
+  auto clrofOnly = configcontext.options().get<bool>("cluster-rof-branch-only");
   WorkflowSpec specs;
-  specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC, doStag));
+  specs.emplace_back(o2::itsmft::getMFTClusterWriterSpec(useMC, doStag, clrofOnly));
   return specs;
 }
diff --git a/Detectors/ITSMFT/MFT/workflow/src/mft-reco-workflow.cxx b/Detectors/ITSMFT/MFT/workflow/src/mft-reco-workflow.cxx
index 11b4fc233c6b4..494d36cc609ec 100644
--- a/Detectors/ITSMFT/MFT/workflow/src/mft-reco-workflow.cxx
+++ b/Detectors/ITSMFT/MFT/workflow/src/mft-reco-workflow.cxx
@@ -44,7 +44,8 @@ void customize(std::vector<o2::framework::ConfigParamSpec>& workflowOptions)
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
     {"nThreads", VariantType::Int, 1, {"Number of threads"}},
     {"use-full-geometry", o2::framework::VariantType::Bool, false, {"use full geometry instead of the light-weight MFT part"}},
-    {"run-tracks2records", o2::framework::VariantType::Bool, false, {"run MFT alignment tracks to records workflow"}}};
+    {"run-tracks2records", o2::framework::VariantType::Bool, false, {"run MFT alignment tracks to records workflow"}},
+    {"cluster-rof-branch-only", o2::framework::VariantType::Bool, false, {"writer will store only ClustersROF brunch"}}};
   o2::raw::HBFUtilsInitializer::addConfigOption(options);
   o2::itsmft::DPLAlpideParamInitializer::addMFTConfigOption(options);
   std::swap(workflowOptions, options);
@@ -70,6 +71,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   auto runTracks2Records = configcontext.options().get<bool>("run-tracks2records");
   auto useGeom = configcontext.options().get<bool>("use-full-geometry");
   auto doStag = o2::itsmft::DPLAlpideParamInitializer::isMFTStaggeringEnabled(configcontext);
+  auto clrofOnly = configcontext.options().get<bool>("cluster-rof-branch-only");
 
   auto wf = o2::mft::reco_workflow::getWorkflow(
     useMC,
@@ -77,6 +79,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
     useGeom,
     extDigits,
     extClusters,
+    clrofOnly,
     disableRootOutput,
     runAssessment,
     processGen,
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
index 6607c05fb141d..e43e5def18482 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/ClusterWriterSpec.h
@@ -20,9 +20,9 @@ namespace o2::itsmft
 {
 
 template <int N>
-framework::DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag);
-framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC, bool doStag);
-framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC, bool doStag);
+framework::DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag, bool clusterROFOnly = false);
+framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC, bool doStag, bool clusterROFOnly = false);
+framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC, bool doStag, bool clusterROFOnly = false);
 
 } // namespace o2::itsmft
 
diff --git a/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx b/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
index 52520194537b8..b189e9c644e27 100644
--- a/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/ClusterWriterSpec.cxx
@@ -41,7 +41,7 @@ using ROFRecLblT = std::vector<o2::itsmft::MC2ROFRecord>;
 using namespace o2::header;
 
 template <int N>
-DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag)
+DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag, bool clusterROFOnly)
 {
   static constexpr o2::header::DataOrigin Origin{N == o2::detectors::DetID::ITS ? o2::header::gDataOriginITS : o2::header::gDataOriginMFT};
   const int nLayers = (doStag) ? DPLAlpideParam<N>::getNLayers() : 1;
@@ -82,6 +82,18 @@ DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag)
     vecInpSpecLbl.emplace_back(getName("labels", iLayer), Origin, "CLUSTERSMCTR", iLayer);
   }
 
+  if (clusterROFOnly) {
+    return MakeRootTreeWriterSpec(std::format("{}-cluster-writer", detNameLC).c_str(),
+                                  (o2::detectors::DetID::ITS == N) ? "o2clus_its.root" : "mftclusters.root",
+                                  MakeRootTreeWriterSpec::TreeAttributes{.name = "o2sim", .title = std::format("Tree with {} cluster ROFs only", detName)},
+                                  BranchDefinition<ROFrameRType>{vecInpSpecROF,
+                                                                 (detName + "ClustersROF").c_str(), "cluster-rof-branch",
+                                                                 nLayers,
+                                                                 logger,
+                                                                 getIndex,
+                                                                 getName})();
+  }
+
   return MakeRootTreeWriterSpec(std::format("{}-cluster-writer", detNameLC).c_str(),
                                 (o2::detectors::DetID::ITS == N) ? "o2clus_its.root" : "mftclusters.root",
                                 MakeRootTreeWriterSpec::TreeAttributes{.name = "o2sim", .title = std::format("Tree with {} clusters", detName)},
@@ -114,7 +126,7 @@ DataProcessorSpec getClusterWriterSpec(bool useMC, bool doStag)
                                                              getName})();
 }
 
-framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC, bool doStag) { return getClusterWriterSpec<o2::detectors::DetID::ITS>(useMC, doStag); }
-framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC, bool doStag) { return getClusterWriterSpec<o2::detectors::DetID::MFT>(useMC, doStag); }
+framework::DataProcessorSpec getITSClusterWriterSpec(bool useMC, bool doStag, bool clusterROFOnly) { return getClusterWriterSpec<o2::detectors::DetID::ITS>(useMC, doStag, clusterROFOnly); }
+framework::DataProcessorSpec getMFTClusterWriterSpec(bool useMC, bool doStag, bool clusterROFOnly) { return getClusterWriterSpec<o2::detectors::DetID::MFT>(useMC, doStag, clusterROFOnly); }
 
 } // namespace o2::itsmft
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 5ab54f9cf4b43..ca466d311ed30 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -468,7 +468,7 @@ if [[ -n $INPUT_DETECTOR_LIST ]]; then
     if [[ $NTIMEFRAMES == -1 ]]; then NTIMEFRAMES_CMD= ; else NTIMEFRAMES_CMD="--max-tf $NTIMEFRAMES"; fi
     CTF_EMC_SUBSPEC=
     ( workflow_has_parameter AOD || [[ -z "$DISABLE_ROOT_OUTPUT" ]] || needs_root_output o2-emcal-cell-writer-workflow ) && has_detector EMC && CTF_EMC_SUBSPEC="--emcal-decoded-subspec 1"
-    add_W o2-ctf-reader-workflow "$RANS_OPT --delay $TFDELAY --loop $TFLOOP $NTIMEFRAMES_CMD $ITS_STAGGERED $MFT_STAGGERED --ctf-input ${CTFName} ${INPUT_FILE_COPY_CMD+--copy-cmd} ${INPUT_FILE_COPY_CMD:-} --onlyDet $INPUT_DETECTOR_LIST $CTF_EMC_SUBSPEC ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} ${TIMEFRAME_SHM_LIMIT:-} --pipeline $(get_N tpc-entropy-decoder TPC REST 1 TPCENTDEC)"
+    add_W o2-ctf-reader-workflow "$RANS_OPT --delay $TFDELAY --loop $TFLOOP $NTIMEFRAMES_CMD $ITS_STAGGERED $MFT_STAGGERED --ctf-input ${CTFName} ${INPUT_FILE_COPY_CMD+--copy-cmd} ${INPUT_FILE_COPY_CMD:-} --onlyDet $INPUT_DETECTOR_LIST $CTF_EMC_SUBSPEC ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} ${TIMEFRAME_SHM_LIMIT:-} --pipeline $(get_N tpc-entropy-decoder TPC REST 1 TPCENTDEC),$(get_N its-entropy-decoder ITS REST 1 ITSENTDEC)"
   elif [[ $RAWTFINPUT == 1 ]]; then
     TFName=`ls -t $RAWINPUTDIR/o2_*.tf 2> /dev/null | head -n1`
     [[ -z $TFName && $WORKFLOWMODE == "print" ]] && TFName='$TFName'

From 9b38548d37a892ddbafca06e5de771062a13a611 Mon Sep 17 00:00:00 2001
From: spulawsk <s.pulawski@cern.ch>
Date: Tue, 5 May 2026 09:12:58 +0200
Subject: [PATCH 1690/1764] FT0: fix return type mismatch in ChannelData
 getters (int16_t) (#15303)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* FT0: fix type mismatch in ChannelData getters (uint → int)

* Additionally fixing mismatch in FV0

---------

Co-authored-by: Szymon Pulawski <spulawsk@h010.nuph.us.edu.pl>
---
 .../Detectors/FIT/FT0/include/DataFormatsFT0/ChannelData.h    | 4 ++--
 .../Detectors/FIT/FV0/include/DataFormatsFV0/ChannelData.h    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/ChannelData.h b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/ChannelData.h
index 9b3d6ec805604..dfe41525af480 100644
--- a/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/ChannelData.h
+++ b/DataFormats/Detectors/FIT/FT0/include/DataFormatsFT0/ChannelData.h
@@ -76,8 +76,8 @@ struct ChannelData {
   void print() const;
   void printLog() const;
   [[nodiscard]] uint8_t getChannelID() const { return ChId; }
-  [[nodiscard]] uint16_t getTime() const { return CFDTime; }
-  [[nodiscard]] uint16_t getAmp() const { return QTCAmpl; }
+  [[nodiscard]] int16_t getTime() const { return CFDTime; }
+  [[nodiscard]] int16_t getAmp() const { return QTCAmpl; }
 
   bool operator==(ChannelData const& other) const
   {
diff --git a/DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/ChannelData.h b/DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/ChannelData.h
index 054b336510c4f..29447dfa04202 100644
--- a/DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/ChannelData.h
+++ b/DataFormats/Detectors/FIT/FV0/include/DataFormatsFV0/ChannelData.h
@@ -76,8 +76,8 @@ struct ChannelData {
   void print() const;
   void printLog() const;
   [[nodiscard]] uint8_t getChannelID() const { return ChId; }
-  [[nodiscard]] uint16_t getTime() const { return CFDTime; }
-  [[nodiscard]] uint16_t getAmp() const { return QTCAmpl; }
+  [[nodiscard]] int16_t getTime() const { return CFDTime; }
+  [[nodiscard]] int16_t getAmp() const { return QTCAmpl; }
 
   bool operator==(ChannelData const& other) const
   {

From 32f4cad1145b0f2ccd92497dcd90551a26def180 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 26 Apr 2026 16:03:34 +0200
Subject: [PATCH 1691/1764] DPL: make sure data preparation remains on the main
 thread

This way we can process incoming data while doing computation
separately, without having to worry about thready safety of the DataRelayer itself.
---
 Framework/Core/src/DataProcessingDevice.cxx | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index 8677aaa42a363..be25133158072 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -212,9 +212,8 @@ DataProcessingDevice::DataProcessingDevice(RunningDeviceRef running, ServiceRegi
   });
 }
 
-// Callback to execute the processing. Notice how the data is
-// is a vector of DataProcessorContext so that we can index the correct
-// one with the thread id. For the moment we simply use the first one.
+// Callback to execute the processing. Receives and relays data (doPrepare)
+// happens on the main thread before this is queued, so we only dispatch here.
 void run_callback(uv_work_t* handle)
 {
   auto* task = (TaskStreamInfo*)handle->data;
@@ -223,7 +222,6 @@ void run_callback(uv_work_t* handle)
   auto& dataProcessorContext = ref.get<DataProcessorContext>();
   O2_SIGNPOST_ID_FROM_POINTER(sid, device, &dataProcessorContext);
   O2_SIGNPOST_START(device, sid, "run_callback", "Starting run callback on stream %d", task->id.index);
-  DataProcessingDevice::doPrepare(ref);
   DataProcessingDevice::doRun(ref);
   O2_SIGNPOST_END(device, sid, "run_callback", "Done processing data for stream %d", task->id.index);
 }
@@ -1332,6 +1330,10 @@ void DataProcessingDevice::Run()
       handleRegionCallbacks(mServiceRegistry, mPendingRegionInfos);
     }
 
+    // Receive and relay incoming data on the main thread so that I/O
+    // overlaps with computation running concurrently on work threads.
+    DataProcessingDevice::doPrepare(ref);
+
     assert(mStreams.size() == mHandles.size());
     /// Decide which task to use
     TaskStreamRef streamRef{-1};

From 6938e1e3c846ba76080fbbf1670a9cc22dc47536 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 29 Apr 2026 14:17:57 +0200
Subject: [PATCH 1692/1764] Common: Allow EnumFlags on gpu

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Common/Utils/include/CommonUtils/EnumFlags.h | 32 +++++++++++++++++---
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/Common/Utils/include/CommonUtils/EnumFlags.h b/Common/Utils/include/CommonUtils/EnumFlags.h
index e7481c903e666..5032b6c0f1483 100644
--- a/Common/Utils/include/CommonUtils/EnumFlags.h
+++ b/Common/Utils/include/CommonUtils/EnumFlags.h
@@ -24,6 +24,7 @@
 #include <string>
 #include <sstream>
 #include <limits>
+#include <bit>
 #include <bitset>
 #include <initializer_list>
 #include <cstdint>
@@ -34,7 +35,9 @@
 #include <iostream>
 #include <iomanip>
 
+#ifndef GPUCA_GPUCODE
 #include "CommonUtils/StringUtils.h"
+#endif
 
 namespace o2::utils
 {
@@ -55,6 +58,7 @@ concept EnumFlagHelper = requires {
 // This is very much inspired by much more extensive libraries like magic_enum.
 // Inspiration by its c++20 version (https://github.com/fix8mt/conjure_enum).
 // NOTE: Cannot detect if bit values past the underlying type are defined.
+#ifndef GPUCA_GPUCODE
 template <EnumFlagHelper E>
 struct FlagsHelper final {
   using U = std::underlying_type_t<E>;
@@ -317,10 +321,12 @@ struct FlagsHelper final {
     return false;
   }
 };
+#endif
 
 } // namespace details::enum_flags
 
 // Require an enum to fullfil what one would except from a bitset.
+#ifndef GPUCA_GPUCODE
 template <typename E>
 concept EnumFlag = requires {
   // range checks
@@ -332,6 +338,10 @@ concept EnumFlag = requires {
   requires !details::enum_flags::FlagsHelper<E>::hasNone(); // added automatically
   requires !details::enum_flags::FlagsHelper<E>::hasAll();  // added automatically
 };
+#else
+template <typename E>
+concept EnumFlag = details::enum_flags::EnumFlagHelper<E>;
+#endif
 
 /**
  * \brief Class to aggregate and manage enum-based on-off flags.
@@ -358,7 +368,9 @@ template <EnumFlag E>
 class EnumFlags
 {
   static constexpr int DefaultBase{2};
+#ifndef GPUCA_GPUCODE
   using H = details::enum_flags::FlagsHelper<E>;
+#endif
   using U = std::underlying_type_t<E>;
   U mBits{0};
 
@@ -388,18 +400,21 @@ class EnumFlags
   // Initialize with a list of flags.
   constexpr EnumFlags(std::initializer_list<E> flags) noexcept
   {
-    std::for_each(flags.begin(), flags.end(), [this](const E f) noexcept { mBits |= to_bit(f); });
+    for (const E f : flags) {
+      mBits |= to_bit(f);
+    }
   }
+#ifndef GPUCA_GPUCODE
   // Init from a string.
   //
   explicit EnumFlags(const std::string& str, int base = DefaultBase)
   {
     set(str, base);
   }
-  // Destructor.
-  constexpr ~EnumFlags() = default;
+#endif
 
-  static constexpr U None{0};        // Represents no flags set.
+  static constexpr U None{0}; // Represents no flags set.
+#ifndef GPUCA_GPUCODE
   static constexpr U All{H::MaxRep}; // Represents all flags set.
 
   // Return list of all enum values
@@ -432,6 +447,7 @@ class EnumFlags
       throw;
     }
   }
+#endif
   // Returns the raw bitset value.
   [[nodiscard]] constexpr auto value() const noexcept
   {
@@ -493,6 +509,7 @@ class EnumFlags
   }
 
   // Checks if all flags are set.
+#ifndef GPUCA_GPUCODE
   [[nodiscard]] constexpr bool all() const noexcept
   {
     return mBits == All;
@@ -537,6 +554,7 @@ class EnumFlags
     }
     return oss.str();
   }
+#endif
 
   // Checks if any flag is set (Boolean context).
   [[nodiscard]] constexpr explicit operator bool() const noexcept
@@ -645,6 +663,7 @@ class EnumFlags
   }
 
   // Serializes the flag set to a string.
+#ifndef GPUCA_GPUCODE
   [[nodiscard]] std::string serialize() const
   {
     return std::to_string(mBits);
@@ -659,6 +678,7 @@ class EnumFlags
     }
     mBits = static_cast<U>(v);
   }
+#endif
 
   // Counts the number of set bits (active flags).
   [[nodiscard]] constexpr size_t count() const noexcept
@@ -686,6 +706,7 @@ class EnumFlags
 
  private:
   // Set implementation, bits was zeroed before.
+#ifndef GPUCA_GPUCODE
   void setImpl(const std::string& s, int base = 2)
   {
     // Helper to check if character is valid for given base
@@ -782,14 +803,17 @@ class EnumFlags
       throw std::invalid_argument("Cannot parse string!");
     }
   }
+#endif
 };
 
+#ifndef GPUCA_GPUCODE
 template <EnumFlag E>
 std::ostream& operator<<(std::ostream& os, const EnumFlags<E>& f)
 {
   os << f.pstring(true);
   return os;
 }
+#endif
 
 } // namespace o2::utils
 

From bd54ed4b604c681ca5d5b07c80eb5a927a35da3e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 5 May 2026 10:18:37 +0200
Subject: [PATCH 1693/1764] DPL: improve catching of low memory related bugs

---
 Framework/Core/src/DataAllocator.cxx | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/Framework/Core/src/DataAllocator.cxx b/Framework/Core/src/DataAllocator.cxx
index f0de6a40935b7..c6fe5f3d82877 100644
--- a/Framework/Core/src/DataAllocator.cxx
+++ b/Framework/Core/src/DataAllocator.cxx
@@ -263,9 +263,15 @@ void DataAllocator::adopt(const Output& spec, LifetimeHolder<FragmentToBatch>& f
     // Serialization happens in here, so that we can
     // get rid of the intermediate tree 2 table object, saving memory.
     auto batch = source.finalize();
+    if (!batch) {
+      throw std::runtime_error("FragmentToBatch::finalize() returned null RecordBatch");
+    }
     auto mock = std::make_shared<arrow::io::MockOutputStream>();
     int64_t expectedSize = 0;
     auto mockWriter = arrow::ipc::MakeStreamWriter(mock.get(), batch->schema());
+    if (!mockWriter.ok()) {
+      throw std::runtime_error(fmt::format("Unable to create mock stream writer: {}", mockWriter.status().ToString()));
+    }
     arrow::Status outStatus = mockWriter.ValueOrDie()->WriteRecordBatch(*batch);
 
     expectedSize = mock->Tell().ValueOrDie();
@@ -275,6 +281,9 @@ void DataAllocator::adopt(const Output& spec, LifetimeHolder<FragmentToBatch>& f
     }
 
     auto deferredWriterStream = source.streamer(buffer);
+    if (!deferredWriterStream) {
+      throw std::runtime_error("FragmentToBatch streamer returned null OutputStream");
+    }
 
     auto outBatch = arrow::ipc::MakeStreamWriter(deferredWriterStream, batch->schema());
     if (outBatch.ok() == false) {

From 1615376151510e8cca9060e3ba05ac11f14429f3 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 5 May 2026 12:28:13 +0200
Subject: [PATCH 1694/1764] Use currentTS+14days to define EOV of TRD DCS-DP
 processor objects

---
 Detectors/TRD/calibration/src/DCSProcessor.cxx | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Detectors/TRD/calibration/src/DCSProcessor.cxx b/Detectors/TRD/calibration/src/DCSProcessor.cxx
index f110ba844791e..6f719b71e10c3 100644
--- a/Detectors/TRD/calibration/src/DCSProcessor.cxx
+++ b/Detectors/TRD/calibration/src/DCSProcessor.cxx
@@ -382,7 +382,7 @@ bool DCSProcessor::updateGasDPsCCDB()
   }
   std::map<std::string, std::string> md;
   md["responsible"] = "Ole Schmidt";
-  o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSGas, mCcdbGasDPsInfo, "TRD/Calib/DCSDPsGas", md, mGasStartTS, mGasStartTS + 3 * o2::ccdb::CcdbObjectInfo::DAY);
+  o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSGas, mCcdbGasDPsInfo, "TRD/Calib/DCSDPsGas", md, mGasStartTS, mCurrentTS + 14 * o2::ccdb::CcdbObjectInfo::DAY);
 
   return retVal;
 }
@@ -410,7 +410,7 @@ bool DCSProcessor::updateCurrentsDPsCCDB()
   }
   std::map<std::string, std::string> md;
   md["responsible"] = "Ole Schmidt";
-  o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSCurrents, mCcdbCurrentsDPsInfo, "TRD/Calib/DCSDPsI", md, mCurrentsStartTS, mCurrentsStartTS + 3 * o2::ccdb::CcdbObjectInfo::DAY);
+  o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSCurrents, mCcdbCurrentsDPsInfo, "TRD/Calib/DCSDPsI", md, mCurrentsStartTS, mCurrentTS + 14 * o2::ccdb::CcdbObjectInfo::DAY);
 
   return retVal;
 }
@@ -437,7 +437,7 @@ bool DCSProcessor::updateVoltagesDPsCCDB()
   }
   std::map<std::string, std::string> md;
   md["responsible"] = "Ole Schmidt";
-  o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSVoltages, mCcdbVoltagesDPsInfo, "TRD/Calib/DCSDPsU", md, mVoltagesStartTS, mVoltagesStartTS + 7 * o2::ccdb::CcdbObjectInfo::DAY);
+  o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSVoltages, mCcdbVoltagesDPsInfo, "TRD/Calib/DCSDPsU", md, mVoltagesStartTS, mCurrentTS + 14 * o2::ccdb::CcdbObjectInfo::DAY);
 
   return retVal;
 }
@@ -465,7 +465,7 @@ bool DCSProcessor::updateEnvDPsCCDB()
   }
   std::map<std::string, std::string> md;
   md["responsible"] = "Leonardo Barreto";
-  o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSEnv, mCcdbEnvDPsInfo, "TRD/Calib/DCSDPsEnv", md, mEnvStartTS, mEnvStartTS + 3 * o2::ccdb::CcdbObjectInfo::DAY);
+  o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSEnv, mCcdbEnvDPsInfo, "TRD/Calib/DCSDPsEnv", md, mEnvStartTS, mCurrentTS + 14 * o2::ccdb::CcdbObjectInfo::DAY);
 
   return retVal;
 }
@@ -498,7 +498,7 @@ bool DCSProcessor::updateFedChamberStatusDPsCCDB()
   // LB: set start timestamp 30000 miliseconds before DPs are received
   o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSFedChamberStatus, mCcdbFedChamberStatusDPsInfo,
                                                 "TRD/Calib/DCSDPsFedChamberStatus", md, mFedChamberStatusStartTS - 30000,
-                                                mFedChamberStatusStartTS + 3 * o2::ccdb::CcdbObjectInfo::DAY);
+                                                mCurrentTS + 14 * o2::ccdb::CcdbObjectInfo::DAY);
 
   return retVal;
 }
@@ -531,7 +531,7 @@ bool DCSProcessor::updateFedCFGtagDPsCCDB()
   // LB: set start timestamp 30000 seconds before DPs are received
   o2::calibration::Utils::prepareCCDBobjectInfo(mTRDDCSFedCFGtag, mCcdbFedCFGtagDPsInfo,
                                                 "TRD/Calib/DCSDPsFedCFGtag", md, mFedCFGtagStartTS - 30000,
-                                                mFedCFGtagStartTS + 3 * o2::ccdb::CcdbObjectInfo::DAY);
+                                                mCurrentTS + 14 * o2::ccdb::CcdbObjectInfo::DAY);
 
   return retVal;
 }

From fadee8bcee862baf30405647e00ec0764b6889ba Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 5 May 2026 17:28:04 +0200
Subject: [PATCH 1695/1764] DPL: more debug messages for the reader

---
 Framework/Core/src/FragmentToBatch.cxx | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/FragmentToBatch.cxx b/Framework/Core/src/FragmentToBatch.cxx
index 1a6c3bca3cc60..ada31be814fc8 100644
--- a/Framework/Core/src/FragmentToBatch.cxx
+++ b/Framework/Core/src/FragmentToBatch.cxx
@@ -44,7 +44,14 @@ void FragmentToBatch::fill(std::shared_ptr<arrow::Schema> schema, std::shared_pt
   options->dataset_schema = schema;
   auto scanner = format->ScanBatchesAsync(options, mFragment);
   auto batch = (*scanner)();
-  mRecordBatch = *batch.result();
+  auto result = batch.result();
+  if (!result.ok()) {
+    throw std::runtime_error("FragmentToBatch::fill: scan failed: " + result.status().ToString());
+  }
+  mRecordBatch = *result;
+  if (!mRecordBatch) {
+    throw std::runtime_error("FragmentToBatch::fill: scan returned null RecordBatch");
+  }
   // Notice that up to here the buffer was not yet filled.
 }
 

From 85ac260325f1e7a09bada0e3625cda805d08f490 Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Wed, 6 May 2026 00:13:37 +0200
Subject: [PATCH 1696/1764] [ALICE3] TRK: adjust zLengthCylinderMiddleServices
 for ML barrel services, make it parametrized (#15366)

Co-authored-by: Igor Altsybeev <Igor.Altsybeev@cern.ch>
---
 .../ALICE3/TRK/simulation/src/TRKServices.cxx | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 7cf7dc863607e..be88412186533 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -568,8 +568,9 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   // Get geometry information from TRK which is already present
   float rMinMiddleServices = 35.f;
   float rMinMiddleBarrel = rMinMiddleServices;
-  const float zLengthCylinderMiddleServices = 40.5f;
+  const float zLengthMiddleBarrel = 64.5f;
   const float zLengthMiddleServices = 143.f;
+  const float zLengthCylinderMiddleServices = zLengthMiddleServices - zLengthMiddleBarrel;
 
   // Middle layer barrel services are only on A side
   rMinMiddleServices = 35.f;
@@ -578,7 +579,6 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   // Middle barrel connection disks
   const float rMinMiddleBarrelDisk = 5.68f;
   const float rMaxMiddleBarrelDisk = 35.f;
-  const float zLengthMiddleBarrel = 64.5f;
   auto orientation = Orientation::kASide;
   float diskCircumference = rMaxMiddleBarrelDisk * 3.14; // Use only half circumference
 
@@ -628,29 +628,29 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       // create data fiber volumes
       double rCur = rMinMiddleServices;
       double dR = siO2FiberAreaD / (3.14 * rCur);
-      TGeoTubeSeg* middleDiskFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+      TGeoTubeSeg* middleDiskFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
       TGeoVolume* middleDiskFiberSIO2Volume = new TGeoVolume(Form("TRK_MLD_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), middleDiskFiberSIO2, medSiO2);
       middleDiskFiberSIO2Volume->SetLineColor(kGray);
 
       rCur += dR;
       dR = peFiberAreaD / (3.14 * rCur);
-      TGeoTubeSeg* middleDiskFiberPE = new TGeoTubeSeg(Form("TRK_MLD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+      TGeoTubeSeg* middleDiskFiberPE = new TGeoTubeSeg(Form("TRK_MLD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
       TGeoVolume* middleDiskFiberPEVolume = new TGeoVolume(Form("TRK_MLD_FIBER_PE_%s%d", orLabel.c_str(), iSide), middleDiskFiberPE, medPE);
       middleDiskFiberPEVolume->SetLineColor(kGray);
-      auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices), new TGeoRotation("", refAngle + iSide * 180., 0, 0));
+      auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices / 2), new TGeoRotation("", refAngle + iSide * 180., 0, 0));
       motherVolume->AddNode(middleDiskFiberSIO2Volume, 1, combiTrans);
       motherVolume->AddNode(middleDiskFiberPEVolume, 1, combiTrans);
 
       // Create powerlines
       rCur += dR;
       dR = cuPowerAreaD / (3.14 * rCur);
-      TGeoTubeSeg* middleDiskPowerCu = new TGeoTubeSeg(Form("TRK_MLD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+      TGeoTubeSeg* middleDiskPowerCu = new TGeoTubeSeg(Form("TRK_MLD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
       TGeoVolume* middleDiskPowerCuVolume = new TGeoVolume(Form("TRK_MLD_POWER_CU_%s%d", orLabel.c_str(), iSide), middleDiskPowerCu, medCu);
       middleDiskPowerCuVolume->SetLineColor(kGray);
 
       rCur += dR;
       dR = pePowerAreaD / (3.14 * rCur);
-      TGeoTubeSeg* middleDiskPowerPE = new TGeoTubeSeg(Form("TRK_MLD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+      TGeoTubeSeg* middleDiskPowerPE = new TGeoTubeSeg(Form("TRK_MLD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
       TGeoVolume* middleDiskPowerPEVolume = new TGeoVolume(Form("TRK_MLD_POWER_PE_%s%d", orLabel.c_str(), iSide), middleDiskPowerPE, medPE);
       middleDiskPowerPEVolume->SetLineColor(kGray);
 
@@ -662,29 +662,29 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
         // create data fiber volumes
         rCur += dR;
         dR = siO2FiberAreaB / (3.14 * rCur);
-        TGeoTubeSeg* middleBarrelFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLB_FIBER_SIO2sh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+        TGeoTubeSeg* middleBarrelFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLB_FIBER_SIO2sh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
         TGeoVolume* middleBarrelFiberSIO2Volume = new TGeoVolume(Form("TRK_MLB_FIBER_SIO2_A%d", iSide), middleBarrelFiberSIO2, medSiO2);
         middleBarrelFiberSIO2Volume->SetLineColor(kGray);
 
         rCur += dR;
         dR = peFiberAreaB / (3.14 * rCur);
-        TGeoTubeSeg* middleBarrelFiberPE = new TGeoTubeSeg(Form("TRK_MLB_FIBER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+        TGeoTubeSeg* middleBarrelFiberPE = new TGeoTubeSeg(Form("TRK_MLB_FIBER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
         TGeoVolume* middleBarrelFiberPEVolume = new TGeoVolume(Form("TRK_MLB_FIBER_PE_A%d", iSide), middleBarrelFiberPE, medPE);
         middleBarrelFiberPEVolume->SetLineColor(kGray);
-        auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices), new TGeoRotation(nullptr, refAngle + iSide * 180., 0, 0));
+        auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices / 2), new TGeoRotation(nullptr, refAngle + iSide * 180., 0, 0));
         motherVolume->AddNode(middleBarrelFiberSIO2Volume, 1, combiTrans);
         motherVolume->AddNode(middleBarrelFiberPEVolume, 1, combiTrans);
 
         // Create powerlines
         rCur += dR;
         dR = cuPowerAreaB / (3.14 * rCur);
-        TGeoTubeSeg* middleBarrelPowerCu = new TGeoTubeSeg(Form("TRK_MLB_POWER_CUsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+        TGeoTubeSeg* middleBarrelPowerCu = new TGeoTubeSeg(Form("TRK_MLB_POWER_CUsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
         TGeoVolume* middleBarrelPowerCuVolume = new TGeoVolume(Form("TRK_MLB_POWER_CU_A%d", iSide), middleBarrelPowerCu, medCu);
         middleBarrelPowerCuVolume->SetLineColor(kGray);
 
         rCur += dR;
         dR = pePowerAreaB / (3.14 * rCur);
-        TGeoTubeSeg* middleBarrelPowerPE = new TGeoTubeSeg(Form("TRK_MLB_POWER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices, -45, 45);
+        TGeoTubeSeg* middleBarrelPowerPE = new TGeoTubeSeg(Form("TRK_MLB_POWER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
         TGeoVolume* middleBarrelPowerPEVolume = new TGeoVolume(Form("TRK_MLB_POWER_PE_A%d", iSide), middleBarrelPowerPE, medPE);
         middleBarrelPowerPEVolume->SetLineColor(kGray);
 

From fb65f6e7642bdb6ca478f617826431c27c967923 Mon Sep 17 00:00:00 2001
From: Justus Rudolph <44173718+JustusRudolph@users.noreply.github.com>
Date: Wed, 6 May 2026 11:29:11 +0200
Subject: [PATCH 1697/1764] [ ALICE3] FT3: Stave tiling bugfixes & readme
 (#15365)

* Change carbon fiber colour to very dark grey, and add it to stave volume to get consistent colours. Also update sensor height to 2.9cm in line with new documents, and fix bug in ML stave positioning to get staggering right.

* update readme with recent changes
---
 Detectors/Upgrades/ALICE3/FT3/README.md        | 18 +++++++++++-------
 .../include/FT3Simulation/FT3ModuleConstants.h |  6 +++---
 .../ALICE3/FT3/simulation/src/FT3Module.cxx    |  3 +++
 3 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/README.md b/Detectors/Upgrades/ALICE3/FT3/README.md
index 34a6782a2b0c2..c11352607db85 100644
--- a/Detectors/Upgrades/ALICE3/FT3/README.md
+++ b/Detectors/Upgrades/ALICE3/FT3/README.md
@@ -12,18 +12,22 @@ This is top page for the FT3 detector documentation.
 Configuration of the endcap disks can be done by setting values for the `FT3Base.layoutFT3` configurable,
 the available options are presented in the following Table:
 
-| Option                 | Comments                                                                                                          |
-| ---------------------- | ----------------------------------------------------------------------------------------------------------------- |
-| `kSegmented` (default) | Currently, only OT disks have realistic implementation, for ML - simple trapezoids                                |
-| `kTrapezoidal`         | Simple trapezoisal disks (in both ML and OT), with `FT3Base.nTrapezoidalSegments=32`                              |
-| `kCylindrical`         | Simplest possible disks as TGeoTubes (ML and OT), bad for ACTS (wrong digi due to polar coorinates on disk sides) |
+| Option                            | Comments                                                                                                          |
+| --------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
+| `kSegmentedStave`                 | Segmentation of ML and OT disks: Modules are placed on staggered staves with user defined constants               |
+| `kSegmentedStaveOTOnly` (default) | Only OT disks are contain staves with modules, ML layers are segmented with strips of modules on front/back       |
+| `kSegmented`                      | Segmentation of ML and OT disk with strips of modules of chips on the front and back of a layer                   |
+| `kTrapezoidal`                    | Simple trapezoidal disks (in both ML and OT), with `FT3Base.nTrapezoidalSegments=32`                              |
+| `kCylindrical`                    | Simplest possible disks as TGeoTubes (ML and OT), bad for ACTS (wrong digi due to polar coorinates on disk sides) |
+
+Furthermore, there are more options in the case of stave segmentation -- for only OT or both. The user can set to cut the staves exactly on the nominal inner radii (true by default), and outer radii (false by default) of the disks. This exists since (planned) placements of sensors & staves often protrude out of the nominal radii to be more able to cover the nominal disk area. In addition, it is possible to draw reference circles in root for the stave segmented layouts for both the inner (red) and outer (blue) radii. This is off by default, yet can be toggled if the user wants to see how tight the tiling is to the nominal radii -- for visualisation purposes only.
 
 [ [Link to definitions](./base/include/FT3Base/FT3BaseParam.h) ]
 
-For example, a geometry with the endcaps-only can be obtained by
+For example, see the command below to generate a geometry with the endcaps only, all layers with the stave geometry, and including reference circles of nominal radii for visualisation.
 ```bash
 o2-sim-serial-run5 -n 1 -g pythia8hi -m FT3 \
-  --configKeyValues "FT3Base.layoutFT3=kTrapezoidal"
+  --configKeyValues "FT3Base.layoutFT3=kSegmented; FT3Base.drawReferenceCircles=true"
 ```
 
 <!-- doxy
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h
index 1fe9f404245c1..5c976bc3bd902 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/FT3ModuleConstants.h
@@ -43,7 +43,7 @@ namespace o2::ft3::ModuleConstants
  */
 // First set all layout constants for the rest of the function
 const double single_sensor_width = 2.5;
-const double single_sensor_height = 3.2;
+const double single_sensor_height = 2.9;
 const double inactive_width = 0.2;
 const double sensor2x1_gap = 0.02;
 const double stackGap = sensor2x1_gap; // gap between 2xN module stacks
@@ -103,7 +103,7 @@ const int SiInactiveColor = kRed;
 const int glueColor = kBlue;
 const int CuColor = kOrange;
 const int kaptonColor = kYellow;
-const int carbonColor = kBlack;
+const int carbonFiberColor = kGray + 1;
 
 // Struct for stave position configuration (varies between IT/OT)
 struct StaveConfig {
@@ -177,7 +177,7 @@ const double x_midpoint_spacing = 4.5;
 const std::vector<bool> staveOnFront =
   {
     1, 0, 1, 0, 1, 0, 1, 0, // L
-    0, 1, 0, 1, 0, 1, 0, 1  // R
+    1, 0, 1, 0, 1, 0, 1, 0  // R
 };
 } // namespace ML_StavePositions
 
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
index 221136000a371..c439da9d539d0 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Module.cxx
@@ -326,6 +326,9 @@ void FT3Module::addStaveVolume(
     (volumeName).c_str(),
     staveShape,
     carbonFiberMed);
+  staveVolume->SetLineColor(Constants::carbonFiberColor);
+  staveVolume->SetFillColorAlpha(Constants::carbonFiberColor, 0.4);
+
   TGeoRotation* rot = new TGeoRotation();
   rot->RotateX(-90); // lift from xy plane into xz plane
   /*

From 1319eff3dd42967427bbeccef2846aca5b24d91c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 6 May 2026 17:42:31 +0200
Subject: [PATCH 1698/1764] DPL: avoid hiding the actual issue (#15367)

---
 Framework/Core/src/DataAllocator.cxx | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/DataAllocator.cxx b/Framework/Core/src/DataAllocator.cxx
index c6fe5f3d82877..d7bfff0dbf19d 100644
--- a/Framework/Core/src/DataAllocator.cxx
+++ b/Framework/Core/src/DataAllocator.cxx
@@ -264,7 +264,11 @@ void DataAllocator::adopt(const Output& spec, LifetimeHolder<FragmentToBatch>& f
     // get rid of the intermediate tree 2 table object, saving memory.
     auto batch = source.finalize();
     if (!batch) {
-      throw std::runtime_error("FragmentToBatch::finalize() returned null RecordBatch");
+      // Do not throw here: this callback runs from ~LifetimeHolder which may
+      // execute during stack unwinding (e.g. if fill() failed). Throwing during
+      // unwinding calls std::terminate.
+      LOG(error) << "FragmentToBatch::finalize() returned null RecordBatch, skipping serialization";
+      return;
     }
     auto mock = std::make_shared<arrow::io::MockOutputStream>();
     int64_t expectedSize = 0;

From dd5516abf2e64d73c8447681193cd317a89b0a06 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 6 May 2026 21:09:57 +0200
Subject: [PATCH 1699/1764] DPL GUI: improve palette, add "light" mode (#15371)

---
 .../src/FrameworkGUIDevicesGraph.cxx          | 62 +++++++++++++++----
 Framework/GUISupport/src/FrameworkGUIState.h  |  1 +
 Framework/GUISupport/src/PaletteHelpers.cxx   | 45 +++++++++-----
 3 files changed, 80 insertions(+), 28 deletions(-)

diff --git a/Framework/GUISupport/src/FrameworkGUIDevicesGraph.cxx b/Framework/GUISupport/src/FrameworkGUIDevicesGraph.cxx
index 1c4ddd7e6aabf..eeb9aeb44795e 100644
--- a/Framework/GUISupport/src/FrameworkGUIDevicesGraph.cxx
+++ b/Framework/GUISupport/src/FrameworkGUIDevicesGraph.cxx
@@ -41,8 +41,37 @@ struct NodeColor {
 
 using LogLevel = LogParsingHelpers::LogLevel;
 
-NodeColor decideColorForNode(const DeviceInfo& info)
+NodeColor decideColorForNode(const DeviceInfo& info, bool lightMode)
 {
+  if (lightMode) {
+    // Dark-on-bright: rich medium-dark cards on a white canvas, white text on nodes
+    if (info.active == false) {
+      return NodeColor{
+        .normal = ImVec4(0xb5 / 255.f, 0x26 / 255.f, 0x18 / 255.f, 1), // dark crimson
+        .hovered = ImVec4(0xc2 / 255.f, 0x2d / 255.f, 0x1d / 255.f, 1)};
+    }
+    switch (info.streamingState) {
+      case StreamingState::EndOfStreaming:
+        return NodeColor{
+          .normal = ImVec4(0x8c / 255.f, 0x6c / 255.f, 0x00 / 255.f, 1), // dark amber
+          .hovered = ImVec4(0x9e / 255.f, 0x7a / 255.f, 0x00 / 255.f, 1),
+          .title = ImVec4(0x6e / 255.f, 0x54 / 255.f, 0x00 / 255.f, 1),
+          .title_hovered = ImVec4(0x5a / 255.f, 0x44 / 255.f, 0x00 / 255.f, 1)};
+      case StreamingState::Idle:
+        return NodeColor{
+          .normal = ImVec4(0x1a / 255.f, 0x80 / 255.f, 0x40 / 255.f, 1), // dark forest green
+          .hovered = ImVec4(0x22 / 255.f, 0x8b / 255.f, 0x47 / 255.f, 1),
+          .title = ImVec4(0x11 / 255.f, 0x60 / 255.f, 0x2e / 255.f, 1),
+          .title_hovered = ImVec4(0x0a / 255.f, 0x4d / 255.f, 0x23 / 255.f, 1)};
+      case StreamingState::Streaming:
+      default:
+        return NodeColor{
+          .normal = ImVec4(0x3a / 255.f, 0x3a / 255.f, 0x3c / 255.f, 1), // macOS tertiary dark
+          .hovered = ImVec4(0x48 / 255.f, 0x48 / 255.f, 0x4a / 255.f, 1),
+          .title = ImVec4(0x2c / 255.f, 0x2c / 255.f, 0x2e / 255.f, 1),
+          .title_hovered = ImVec4(0x1c / 255.f, 0x1c / 255.f, 0x1e / 255.f, 1)};
+    }
+  }
   if (info.active == false) {
     return NodeColor{
       .normal = PaletteHelpers::RED,
@@ -82,7 +111,7 @@ const static ImColor ARROW_BACKGROUND_COLOR = {100, 100, 0};
 const static ImColor ARROW_HALFGROUND_COLOR = {170, 170, 70};
 const static ImColor ARROW_COLOR = {200, 200, 100};
 const static ImColor ARROW_SELECTED_COLOR = {200, 0, 100};
-const static ImU32 GRID_COLOR = ImColor(200, 200, 200, 40);
+const static ImU32 GRID_COLOR = ImColor(150, 150, 150, 80);
 const static ImColor NODE_BORDER_COLOR = {100, 100, 100};
 const static ImColor LEGEND_COLOR = {100, 100, 100};
 
@@ -508,6 +537,8 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
   ImGui::SameLine();
   ImGui::Checkbox("Show legend", &show_legend);
   ImGui::SameLine();
+  ImGui::Checkbox("Light mode", &state.topologyLightMode);
+  ImGui::SameLine();
   if (ImGui::Button("Center")) {
     scrolling = ImVec2(0., 0.);
   }
@@ -577,11 +608,10 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
 
   ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(1, 1));
   ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0, 0));
-#if defined(ImGuiCol_ChildWindowBg)
-  ImGui::PushStyleColor(ImGuiCol_ChildWindowBg, (ImU32)ImColor(60, 60, 70, 200));
-#else
-  ImGui::PushStyleColor(ImGuiCol_WindowBg, (ImU32)ImColor(60, 60, 70, 200));
-#endif
+  auto canvasBg = state.topologyLightMode ? (ImU32)ImColor(250, 250, 252, 255) : (ImU32)ImColor(44, 44, 46, 255);
+  auto canvasText = (ImU32)ImColor(235, 235, 245, 255); // nodes are always dark, so text is always light
+  ImGui::PushStyleColor(ImGuiCol_ChildBg, canvasBg);
+  ImGui::PushStyleColor(ImGuiCol_Text, canvasText);
   ImVec2 graphSize = ImGui::GetWindowSize();
   if (state.leftPaneVisible) {
     graphSize.x -= state.leftPaneSize;
@@ -604,6 +634,12 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
 
   ImVec2 win_pos = ImGui::GetCursorScreenPos();
   ImVec2 canvas_sz = ImGui::GetWindowSize();
+
+  // Arrow colors — richer amber in light mode to stand out on white canvas
+  const ImColor arrowBgColor = state.topologyLightMode ? ImColor(140, 80, 0) : ARROW_BACKGROUND_COLOR;
+  const ImColor arrowHalfColor = state.topologyLightMode ? ImColor(180, 110, 0) : ARROW_HALFGROUND_COLOR;
+  const ImColor arrowColor = state.topologyLightMode ? ImColor(220, 140, 0) : ARROW_COLOR;
+
   // Display links but only if they are inside the view.
   for (int link_idx = 0; link_idx < links.Size; link_idx++) {
     // Do the geometry culling upfront.
@@ -627,7 +663,7 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
       continue;
     }
     draw_list->ChannelsSetCurrent(0); // Background
-    auto color = ARROW_BACKGROUND_COLOR;
+    auto color = arrowBgColor;
     auto thickness = ARROW_BACKGROUND_THICKNESS;
 
     bool p1Inside = false;
@@ -643,12 +679,12 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
     if (p1Inside && p2Inside) {
       // Whatever the two edges completely within the view, gets brighter color and foreground.
       draw_list->ChannelsSetCurrent(2);
-      color = ARROW_COLOR;
+      color = arrowColor;
       thickness = ARROW_THICKNESS;
     } else if (p1Inside || p2Inside) {
       draw_list->ChannelsSetCurrent(1);
       // Whenever one of the two ends is within the view, increase the color but keep the background
-      color = ARROW_HALFGROUND_COLOR;
+      color = arrowHalfColor;
       thickness = ARROW_HALFGROUND_THICKNESS;
     }
 
@@ -756,7 +792,7 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
       scrolling = scrolling - ImVec2(ImGui::GetIO().MouseDelta.x / 4.f, ImGui::GetIO().MouseDelta.y / 4.f);
     }
 
-    auto nodeBg = decideColorForNode(info);
+    auto nodeBg = decideColorForNode(info, state.topologyLightMode);
 
     auto hovered = (node_hovered_in_list == node->ID || node_hovered_in_scene == node->ID || (node_hovered_in_list == -1 && node_selected == node->ID));
     ImVec4 nodeBgColor = hovered ? nodeBg.hovered : nodeBg.normal;
@@ -776,7 +812,7 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
       auto pp1 = p1 + offset + slotPos;
       auto pp2 = p2 + offset + slotPos;
       auto pp3 = p3 + offset + slotPos;
-      auto color = ARROW_COLOR;
+      auto color = arrowColor;
       if (node_idx == node_selected) {
         color = ARROW_SELECTED_COLOR;
       }
@@ -881,7 +917,7 @@ void showTopologyNodeGraph(WorkspaceGUIState& state,
 
   ImGui::PopItemWidth();
   ImGui::EndChild();
-  ImGui::PopStyleColor();
+  ImGui::PopStyleColor(2);
   ImGui::PopStyleVar(2);
   ImGui::EndGroup();
 
diff --git a/Framework/GUISupport/src/FrameworkGUIState.h b/Framework/GUISupport/src/FrameworkGUIState.h
index 8a1cd8dd3bd1e..d36b6c6120fc0 100644
--- a/Framework/GUISupport/src/FrameworkGUIState.h
+++ b/Framework/GUISupport/src/FrameworkGUIState.h
@@ -34,6 +34,7 @@ struct WorkspaceGUIState {
   bool leftPaneVisible;
   bool rightPaneVisible;
   bool bottomPaneVisible;
+  bool topologyLightMode;
   double startTime;
 };
 
diff --git a/Framework/GUISupport/src/PaletteHelpers.cxx b/Framework/GUISupport/src/PaletteHelpers.cxx
index 1ad04ce7c7f3f..fa19b0dd43319 100644
--- a/Framework/GUISupport/src/PaletteHelpers.cxx
+++ b/Framework/GUISupport/src/PaletteHelpers.cxx
@@ -13,20 +13,35 @@
 namespace o2::framework
 {
 
-const ImVec4 PaletteHelpers::RED = ImVec4(0.945, 0.094, 0.298, 1);
-const ImVec4 PaletteHelpers::GREEN = ImVec4(0x7e / 255., 0xc4 / 255., 0x52 / 255., 1);
-const ImVec4 PaletteHelpers::BLUE = ImVec4(0x3d / 255., 0xb7 / 255., 0xe0 / 255., 1);
-const ImVec4 PaletteHelpers::YELLOW = ImVec4(0.949, 0.769, 0.239, 1);
-const ImVec4 PaletteHelpers::SHADED_RED = ImVec4(0xd5 / 255., 0x72 / 255., 0x73 / 255., 1);
-const ImVec4 PaletteHelpers::SHADED_GREEN = ImVec4(0x98 / 255., 0xba / 255., 0x96 / 255., 1);
-const ImVec4 PaletteHelpers::SHADED_BLUE = ImVec4(0x7a / 255., 0xab / 255., 0xea / 255., 1);
-const ImVec4 PaletteHelpers::SHADED_YELLOW = ImVec4(0xeb / 255., 0xb9 / 255., 0x7a / 255., 1);
-const ImVec4 PaletteHelpers::DARK_RED = ImVec4(0xd4 / 255., 0x06 / 255., 0x02 / 255., 255. / 255.);
-const ImVec4 PaletteHelpers::DARK_GREEN = ImVec4(153. / 255., 61. / 255., 61. / 255., 255. / 255.);
-const ImVec4 PaletteHelpers::DARK_YELLOW = ImVec4(0xf1 / 255., 0x9b / 255., 0x2c / 255., 255. / 255.);
-const ImVec4 PaletteHelpers::WHITE = ImVec4(0xce / 255., 0xbe / 255., 0x91 / 255., 1);
-const ImVec4 PaletteHelpers::BLACK = ImVec4(0x28 / 255., 0x28 / 255., 0x28 / 255., 1);
-const ImVec4 PaletteHelpers::GRAY = ImVec4(60 / 255., 60 / 255., 60 / 255., 1);
-const ImVec4 PaletteHelpers::LIGHT_GRAY = ImVec4(75 / 255., 75 / 255., 75 / 255., 1);
+// Vivid accent colors — macOS system color palette / Pantone-adjacent
+// RED: macOS Red (#FF3B30) / Pantone 485 C adjacent
+const ImVec4 PaletteHelpers::RED = ImVec4(0xff / 255., 0x3b / 255., 0x30 / 255., 1);
+// GREEN: macOS Green (#34C759) / Pantone 368 C adjacent
+const ImVec4 PaletteHelpers::GREEN = ImVec4(0x34 / 255., 0xc7 / 255., 0x59 / 255., 1);
+// BLUE: macOS Blue (#007AFF) / Pantone 2728 C adjacent
+const ImVec4 PaletteHelpers::BLUE = ImVec4(0x00 / 255., 0x7a / 255., 0xff / 255., 1);
+// YELLOW: macOS Yellow (#FFCC00) / Pantone 116 C adjacent
+const ImVec4 PaletteHelpers::YELLOW = ImVec4(0xff / 255., 0xcc / 255., 0x00 / 255., 1);
+// Muted/shaded variants — desaturated for secondary use
+const ImVec4 PaletteHelpers::SHADED_RED = ImVec4(0xff / 255., 0x69 / 255., 0x61 / 255., 1);
+const ImVec4 PaletteHelpers::SHADED_GREEN = ImVec4(0x86 / 255., 0xd9 / 255., 0x88 / 255., 1);
+const ImVec4 PaletteHelpers::SHADED_BLUE = ImVec4(0x5a / 255., 0xc8 / 255., 0xfa / 255., 1);
+const ImVec4 PaletteHelpers::SHADED_YELLOW = ImVec4(0xff / 255., 0xd6 / 255., 0x0a / 255., 1);
+// Dark variants — for title bars and hovered states
+// DARK_RED: Pantone 485 C (#DA291C)
+const ImVec4 PaletteHelpers::DARK_RED = ImVec4(0xda / 255., 0x29 / 255., 0x1c / 255., 1);
+// DARK_GREEN: (#1E8449)
+const ImVec4 PaletteHelpers::DARK_GREEN = ImVec4(0x1e / 255., 0x84 / 255., 0x49 / 255., 1);
+// DARK_YELLOW: macOS Orange (#FF9F0A) / Pantone 137 C adjacent
+const ImVec4 PaletteHelpers::DARK_YELLOW = ImVec4(0xff / 255., 0x9f / 255., 0x0a / 255., 1);
+// Neutrals — macOS dark mode system backgrounds
+// WHITE: used as primary text / highlight color in dark UI
+const ImVec4 PaletteHelpers::WHITE = ImVec4(0xf5 / 255., 0xf5 / 255., 0xf7 / 255., 1);
+// BLACK: macOS dark background (#1C1C1E)
+const ImVec4 PaletteHelpers::BLACK = ImVec4(0x1c / 255., 0x1c / 255., 0x1e / 255., 1);
+// GRAY: macOS secondary background (#2C2C2E)
+const ImVec4 PaletteHelpers::GRAY = ImVec4(0x2c / 255., 0x2c / 255., 0x2e / 255., 1);
+// LIGHT_GRAY: macOS tertiary background (#3A3A3C)
+const ImVec4 PaletteHelpers::LIGHT_GRAY = ImVec4(0x3a / 255., 0x3a / 255., 0x3c / 255., 1);
 
 } // namespace o2::framework

From 70bfe0eca36520b90046517288f8959ee2b3cb2e Mon Sep 17 00:00:00 2001
From: mcoquet642 <74600025+mcoquet642@users.noreply.github.com>
Date: Thu, 7 May 2026 11:43:42 +0200
Subject: [PATCH 1700/1764] AODProducer option to store all mft covariances
 (#15338)

Co-authored-by: Maurice Coquet <mcoquet@alicecerno2.cern.ch>
---
 .../AODProducerWorkflowSpec.h                 |  5 +-
 Detectors/AOD/src/AODProducerWorkflowSpec.cxx | 71 +++++++++++++------
 2 files changed, 54 insertions(+), 22 deletions(-)

diff --git a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
index 8947a50fe42cd..02f1b2582d74b 100644
--- a/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
+++ b/Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h
@@ -249,6 +249,7 @@ class AODProducerWorkflowDPL : public Task
   bool mThinTracks{false};
   bool mPropTracks{false};
   bool mPropMuons{false};
+  bool mStoreAllMFTCov{false};
   float mTrackQCKeepGlobalTracks{false};
   float mTrackQCRetainOnlydEdx{false};
   float mTrackQCFraction{0.00};
@@ -547,8 +548,8 @@ class AODProducerWorkflowDPL : public Task
   template <typename TRDsExtraCursorType>
   void addToTRDsExtra(const o2::globaltracking::RecoContainer& recoData, TRDsExtraCursorType& trdExtraCursor, const GIndex& trkIdx, int trkTableIdx);
 
-  template <typename mftTracksCursorType, typename AmbigMFTTracksCursorType>
-  void addToMFTTracksTable(mftTracksCursorType& mftTracksCursor, AmbigMFTTracksCursorType& ambigMFTTracksCursor,
+  template <typename mftTracksCursorType, typename mftTracksCovCursorType, typename AmbigMFTTracksCursorType>
+  void addToMFTTracksTable(mftTracksCursorType& mftTracksCursor, mftTracksCovCursorType& mftTracksCovCursor, AmbigMFTTracksCursorType& ambigMFTTracksCursor,
                            GIndex trackID, const o2::globaltracking::RecoContainer& data, int collisionID,
                            std::uint64_t collisionBC, const std::map<uint64_t, int>& bcsMap);
 
diff --git a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
index 03f38206b2a47..8365628f1644b 100644
--- a/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
+++ b/Detectors/AOD/src/AODProducerWorkflowSpec.cxx
@@ -507,8 +507,8 @@ void AODProducerWorkflowDPL::addToTRDsExtra(const o2::globaltracking::RecoContai
   trdExtraCursor(trkTableIdx, q0s, q1s, q2s, q0sCor, q1sCor, q2sCor, ttgls, tphis);
 }
 
-template <typename mftTracksCursorType, typename AmbigMFTTracksCursorType>
-void AODProducerWorkflowDPL::addToMFTTracksTable(mftTracksCursorType& mftTracksCursor, AmbigMFTTracksCursorType& ambigMFTTracksCursor,
+template <typename mftTracksCursorType, typename mftTracksCovCursorType, typename AmbigMFTTracksCursorType>
+void AODProducerWorkflowDPL::addToMFTTracksTable(mftTracksCursorType& mftTracksCursor, mftTracksCovCursorType& mftTracksCovCursor, AmbigMFTTracksCursorType& ambigMFTTracksCursor,
                                                  GIndex trackID, const o2::globaltracking::RecoContainer& data, int collisionID,
                                                  std::uint64_t collisionBC, const std::map<uint64_t, int>& bcsMap)
 {
@@ -543,6 +543,30 @@ void AODProducerWorkflowDPL::addToMFTTracksTable(mftTracksCursorType& mftTracksC
                   truncateFloatFraction(track.getTrackChi2(), mTrackChi2),
                   truncateFloatFraction(trackTime, mTrackTime),
                   truncateFloatFraction(trackTimeRes, mTrackTimeError));
+  if (mStoreAllMFTCov) {
+    float sX = TMath::Sqrt(track.getSigma2X());
+    float sY = TMath::Sqrt(track.getSigma2Y());
+    float sPhi = TMath::Sqrt(track.getSigma2Phi());
+    float sTgl = TMath::Sqrt(track.getSigma2Tanl());
+    float sQ2Pt = TMath::Sqrt(track.getSigma2InvQPt());
+
+    mftTracksCovCursor(mTableTrMFTID,
+                       truncateFloatFraction(sX, mTrackCovDiag),
+                       truncateFloatFraction(sY, mTrackCovDiag),
+                       truncateFloatFraction(sPhi, mTrackCovDiag),
+                       truncateFloatFraction(sTgl, mTrackCovDiag),
+                       truncateFloatFraction(sQ2Pt, mTrackCovDiag),
+                       (Char_t)(128. * track.getCovariances()(0, 1) / (sX * sY)),
+                       (Char_t)(128. * track.getCovariances()(0, 2) / (sPhi * sX)),
+                       (Char_t)(128. * track.getCovariances()(1, 2) / (sPhi * sY)),
+                       (Char_t)(128. * track.getCovariances()(0, 3) / (sTgl * sX)),
+                       (Char_t)(128. * track.getCovariances()(1, 3) / (sTgl * sY)),
+                       (Char_t)(128. * track.getCovariances()(2, 3) / (sTgl * sPhi)),
+                       (Char_t)(128. * track.getCovariances()(0, 4) / (sQ2Pt * sX)),
+                       (Char_t)(128. * track.getCovariances()(1, 4) / (sQ2Pt * sY)),
+                       (Char_t)(128. * track.getCovariances()(2, 4) / (sQ2Pt * sPhi)),
+                       (Char_t)(128. * track.getCovariances()(3, 4) / (sQ2Pt * sTgl)));
+  }
   if (needBCSlice) {
     ambigMFTTracksCursor(mTableTrMFTID, bcSlice);
   }
@@ -579,10 +603,13 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
     int nToReserve = end - start; // + last index for a given table
     if (src == GIndex::Source::MFT) {
       mftTracksCursor.reserve(nToReserve + mftTracksCursor.lastIndex());
+      if (mStoreAllMFTCov) {
+        mftTracksCovCursor.reserve(nToReserve + mftTracksCovCursor.lastIndex());
+      }
     } else if (src == GIndex::Source::MCH || src == GIndex::Source::MFTMCH || src == GIndex::Source::MCHMID) {
       fwdTracksCursor.reserve(nToReserve + fwdTracksCursor.lastIndex());
       fwdTracksCovCursor.reserve(nToReserve + fwdTracksCovCursor.lastIndex());
-      if (src == GIndex::Source::MFTMCH) {
+      if (!mStoreAllMFTCov && src == GIndex::Source::MFTMCH) {
         mftTracksCovCursor.reserve(nToReserve + mftTracksCovCursor.lastIndex());
       }
     } else {
@@ -597,7 +624,7 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
           if (trackIndex.isAmbiguous() && mGIDToTableMFTID.find(trackIndex) != mGIDToTableMFTID.end()) { // was it already stored ?
             continue;
           }
-          addToMFTTracksTable(mftTracksCursor, ambigMFTTracksCursor, trackIndex, data, collisionID, collisionBC, bcsMap);
+          addToMFTTracksTable(mftTracksCursor, mftTracksCovCursor, ambigMFTTracksCursor, trackIndex, data, collisionID, collisionBC, bcsMap);
           mGIDToTableMFTID.emplace(trackIndex, mTableTrMFTID);
           mTableTrMFTID++;
         } else if (src == GIndex::Source::MCH || src == GIndex::Source::MFTMCH || src == GIndex::Source::MCHMID) { // FwdTracks tracks are treated separately since they are stored in a different table
@@ -929,22 +956,24 @@ void AODProducerWorkflowDPL::addToFwdTracksTable(FwdTracksCursorType& fwdTracksC
     float sX = TMath::Sqrt(mfttrack.getSigma2X()), sY = TMath::Sqrt(mfttrack.getSigma2Y()), sPhi = TMath::Sqrt(mfttrack.getSigma2Phi()),
           sTgl = TMath::Sqrt(mfttrack.getSigma2Tanl()), sQ2Pt = TMath::Sqrt(mfttrack.getSigma2InvQPt());
 
-    mftTracksCovCursor(fwdInfo.matchmfttrackid,
-                       truncateFloatFraction(sX, mTrackCovDiag),
-                       truncateFloatFraction(sY, mTrackCovDiag),
-                       truncateFloatFraction(sPhi, mTrackCovDiag),
-                       truncateFloatFraction(sTgl, mTrackCovDiag),
-                       truncateFloatFraction(sQ2Pt, mTrackCovDiag),
-                       (Char_t)(128. * mfttrack.getCovariances()(0, 1) / (sX * sY)),
-                       (Char_t)(128. * mfttrack.getCovariances()(0, 2) / (sPhi * sX)),
-                       (Char_t)(128. * mfttrack.getCovariances()(1, 2) / (sPhi * sY)),
-                       (Char_t)(128. * mfttrack.getCovariances()(0, 3) / (sTgl * sX)),
-                       (Char_t)(128. * mfttrack.getCovariances()(1, 3) / (sTgl * sY)),
-                       (Char_t)(128. * mfttrack.getCovariances()(2, 3) / (sTgl * sPhi)),
-                       (Char_t)(128. * mfttrack.getCovariances()(0, 4) / (sQ2Pt * sX)),
-                       (Char_t)(128. * mfttrack.getCovariances()(1, 4) / (sQ2Pt * sY)),
-                       (Char_t)(128. * mfttrack.getCovariances()(2, 4) / (sQ2Pt * sPhi)),
-                       (Char_t)(128. * mfttrack.getCovariances()(3, 4) / (sQ2Pt * sTgl)));
+    if (!mStoreAllMFTCov) {
+      mftTracksCovCursor(fwdInfo.matchmfttrackid,
+                         truncateFloatFraction(sX, mTrackCovDiag),
+                         truncateFloatFraction(sY, mTrackCovDiag),
+                         truncateFloatFraction(sPhi, mTrackCovDiag),
+                         truncateFloatFraction(sTgl, mTrackCovDiag),
+                         truncateFloatFraction(sQ2Pt, mTrackCovDiag),
+                         (Char_t)(128. * mfttrack.getCovariances()(0, 1) / (sX * sY)),
+                         (Char_t)(128. * mfttrack.getCovariances()(0, 2) / (sPhi * sX)),
+                         (Char_t)(128. * mfttrack.getCovariances()(1, 2) / (sPhi * sY)),
+                         (Char_t)(128. * mfttrack.getCovariances()(0, 3) / (sTgl * sX)),
+                         (Char_t)(128. * mfttrack.getCovariances()(1, 3) / (sTgl * sY)),
+                         (Char_t)(128. * mfttrack.getCovariances()(2, 3) / (sTgl * sPhi)),
+                         (Char_t)(128. * mfttrack.getCovariances()(0, 4) / (sQ2Pt * sX)),
+                         (Char_t)(128. * mfttrack.getCovariances()(1, 4) / (sQ2Pt * sY)),
+                         (Char_t)(128. * mfttrack.getCovariances()(2, 4) / (sQ2Pt * sPhi)),
+                         (Char_t)(128. * mfttrack.getCovariances()(3, 4) / (sQ2Pt * sTgl)));
+    }
   }
 
   std::uint64_t bcOfTimeRef;
@@ -1830,6 +1859,7 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
   mPropTracks = ic.options().get<bool>("propagate-tracks");
   mMaxPropXiu = ic.options().get<float>("propagate-tracks-max-xiu");
   mPropMuons = ic.options().get<bool>("propagate-muons");
+  mStoreAllMFTCov = ic.options().get<bool>("store-all-mft-cov");
   if (auto s = ic.options().get<std::string>("with-streamers"); !s.empty()) {
     mStreamerFlags.set(s);
     if (mStreamerFlags) {
@@ -3524,6 +3554,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"propagate-tracks-max-xiu", VariantType::Float, 5.0f, {"Propagate tracks to IP if X_IU smaller than this value (and if propagate tracks enabled)"}},
       ConfigParamSpec{"hepmc-update", VariantType::String, "always", {"When to update HepMC Aux tables: always - force update, never - never update, all - if all keys are present, any - when any key is present (not valid yet)"}},
       ConfigParamSpec{"propagate-muons", VariantType::Bool, false, {"Propagate muons to IP"}},
+      ConfigParamSpec{"store-all-mft-cov", VariantType::Bool, false, {"Store covariance matrices for all MFT tracks"}},
       ConfigParamSpec{"thin-tracks", VariantType::Bool, false, {"Produce thinned track tables"}},
       ConfigParamSpec{"trackqc-keepglobaltracks", VariantType::Bool, false, {"Always keep TrackQA for global tracks"}},
       ConfigParamSpec{"trackqc-retainonlydedx", VariantType::Bool, false, {"Keep only dEdx information, zero out everything else"}},

From bfbf945464acdaeda2a24a7c84bd98a7f99595fe Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 7 May 2026 13:30:45 +0200
Subject: [PATCH 1701/1764] DPL: allow for configurable CCDB paths (#15337)

---
 .../CCDBSupport/src/AnalysisCCDBHelpers.cxx   | 34 +++++++++++++------
 .../Core/include/Framework/AnalysisHelpers.h  | 14 ++++----
 .../Core/include/Framework/Configurable.h     | 29 +++++++++++++---
 Framework/Core/src/AnalysisHelpers.cxx        |  1 +
 Framework/Core/src/ArrowSupport.cxx           | 29 ++++++++++++++++
 .../TestWorkflows/src/o2TestAnalysisCCDB.cxx  | 18 +++++++++-
 6 files changed, 102 insertions(+), 23 deletions(-)

diff --git a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
index c65ef2903db59..21fdae4a57760 100644
--- a/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
+++ b/Framework/CCDBSupport/src/AnalysisCCDBHelpers.cxx
@@ -21,7 +21,7 @@
 #include "Framework/Signpost.h"
 #include "Framework/DanglingEdgesContext.h"
 #include "Framework/ConfigContext.h"
-#include "Framework/ConfigContext.h"
+#include "Framework/ConfigParamsHelper.h"
 #include <arrow/array/builder_binary.h>
 #include <arrow/type.h>
 #include <arrow/type_fwd.h>
@@ -71,31 +71,45 @@ AlgorithmSpec AnalysisCCDBHelpers::fetchFromCCDB(ConfigContext const& /*ctx*/)
 {
   return adaptStateful([](ConfigParamRegistry const& options, DeviceSpec const& spec, InitContext& ic) {
     auto& dec = ic.services().get<DanglingEdgesContext>();
+    // The effective default for each ccdb: option was already resolved at topology
+    // time by ArrowSupport (consulting task Configurables) and registered on this
+    // device's options. Here we just read the final value — honouring any further
+    // runtime override supplied via CLI or JSON config.
+    std::unordered_map<std::string, std::string> ccdbUrls;
+    for (auto& input : dec.analysisCCDBInputs) {
+      for (auto& m : input.metadata) {
+        if (!m.name.starts_with("ccdb:") || ccdbUrls.count(m.name)) {
+          continue;
+        }
+        std::string url = m.defaultValue.asString();
+        if (ConfigParamsHelper::hasOption(spec.options, m.name)) {
+          url = options.get<std::string>(m.name.c_str());
+        }
+        LOGP(info, "CCDB path resolved for {}: {}", m.name, url);
+        ccdbUrls.emplace(m.name, std::move(url));
+      }
+    }
     std::vector<std::shared_ptr<arrow::Schema>> schemas;
-    auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
-
     for (auto& input : dec.analysisCCDBInputs) {
+      auto schemaMetadata = std::make_shared<arrow::KeyValueMetadata>();
       std::vector<std::shared_ptr<arrow::Field>> fields;
       schemaMetadata->Append("outputRoute", DataSpecUtils::describe(input));
       schemaMetadata->Append("outputBinding", input.binding);
-
       for (auto& m : input.metadata) {
-        // Save the list of input tables
         if (m.name.starts_with("input:")) {
           auto name = m.name.substr(6);
           schemaMetadata->Append("sourceTable", name);
           schemaMetadata->Append("sourceMatcher", DataSpecUtils::describe(std::get<ConcreteDataMatcher>(DataSpecUtils::fromMetadataString(m.defaultValue.get<std::string>()).matcher)));
           continue;
         }
-        // Ignore the non ccdb: entries
         if (!m.name.starts_with("ccdb:")) {
           continue;
         }
-        // Create the schema of the output
-        auto metadata = std::make_shared<arrow::KeyValueMetadata>();
-        metadata->Append("url", m.defaultValue.asString());
+        auto fieldMetadata = std::make_shared<arrow::KeyValueMetadata>();
+        auto it = ccdbUrls.find(m.name);
+        fieldMetadata->Append("url", it != ccdbUrls.end() ? it->second : m.defaultValue.asString());
         auto columnName = m.name.substr(strlen("ccdb:"));
-        fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, metadata));
+        fields.emplace_back(std::make_shared<arrow::Field>(columnName, arrow::binary_view(), false, fieldMetadata));
       }
       schemas.emplace_back(std::make_shared<arrow::Schema>(fields, schemaMetadata));
     }
diff --git a/Framework/Core/include/Framework/AnalysisHelpers.h b/Framework/Core/include/Framework/AnalysisHelpers.h
index bfc5a02891dad..cfd2f357ba06f 100644
--- a/Framework/Core/include/Framework/AnalysisHelpers.h
+++ b/Framework/Core/include/Framework/AnalysisHelpers.h
@@ -172,7 +172,7 @@ struct Builder {
 
   std::shared_ptr<arrow::Table> materialize(ProcessingContext& pc);
 };
-}  // namespace o2::framework
+} // namespace o2::framework
 
 namespace o2::soa
 {
@@ -394,7 +394,7 @@ constexpr auto getIndexMetadata() -> std::vector<framework::ConfigParamSpec>
   return {};
 }
 
-}  // namespace
+} // namespace
 
 template <TableRef R>
 constexpr auto tableRef2InputSpec()
@@ -463,7 +463,7 @@ constexpr auto tableRef2OutputRef()
     o2::aod::label<R>(),
     R.version};
 }
-}  // namespace o2::soa
+} // namespace o2::soa
 
 namespace o2::framework
 {
@@ -672,7 +672,7 @@ struct Spawns : decltype(transformBase<T>()) {
 
   std::shared_ptr<typename T::table_t> table = nullptr;
   std::shared_ptr<extension_t> extension = nullptr;
-  std::array<o2::framework::expressions::Projector, N> projectors = []<typename... C>(framework::pack<C...>) -> std::array<expressions::Projector, sizeof...(C)>
+  std::array<o2::framework::expressions::Projector, N> projectors = []<typename... C>(framework::pack<C...>)->std::array<expressions::Projector, sizeof...(C)>
   {
     return {{std::move(C::Projector())...}};
   }
@@ -1077,7 +1077,7 @@ concept is_partition = requires(T t) {
   requires std::same_as<decltype(t.filter), expressions::Filter>;
   requires std::same_as<decltype(t.mFiltered), std::unique_ptr<o2::soa::Filtered<typename T::content_t>>>;
 };
-}  // namespace o2::framework
+} // namespace o2::framework
 
 namespace o2::soa
 {
@@ -1100,6 +1100,6 @@ auto Attach(T const& table)
   using output_t = Join<T, o2::soa::Table<o2::aod::Hash<"JOIN"_h>, o2::aod::Hash<"JOIN/0"_h>, o2::aod::Hash<"JOIN"_h>, Cs...>>;
   return output_t{{table.asArrowTable()}, table.offset()};
 }
-}  // namespace o2::soa
+} // namespace o2::soa
 
-#endif  // o2_framework_AnalysisHelpers_H_DEFINED
+#endif // o2_framework_AnalysisHelpers_H_DEFINED
diff --git a/Framework/Core/include/Framework/Configurable.h b/Framework/Core/include/Framework/Configurable.h
index 0931884da1ff7..3cbd1839b7d89 100644
--- a/Framework/Core/include/Framework/Configurable.h
+++ b/Framework/Core/include/Framework/Configurable.h
@@ -83,6 +83,26 @@ struct Configurable : IP {
 template <typename T, ConfigParamKind K = ConfigParamKind::kGeneric>
 using MutableConfigurable = Configurable<T, K, ConfigurablePolicyMutable<T, K>>;
 
+/// Convenience wrapper for overriding the CCDB path of a CCDB column declared
+/// with DECLARE_SOA_CCDB_COLUMN / DECLARE_SOA_CCDB_COLUMN_FULL.
+///
+/// The option name, default value, and help string are all derived automatically
+/// from the column type: name = "ccdb:" + Column::mLabel, default = Column::query.
+///
+/// Example:
+///   struct MyTask {
+///     ConfigurableCCDBPath<tofcalib::LHCphase> lhcPhasePath;
+///   };
+template <typename Column>
+struct ConfigurableCCDBPath : Configurable<std::string> {
+  ConfigurableCCDBPath()
+    : Configurable<std::string>{std::string{"ccdb:"} + Column::mLabel,
+                                std::string{Column::query},
+                                std::string{"CCDB path for "} + Column::mLabel + " (default: " + Column::query + ")"}
+  {
+  }
+};
+
 template <typename T>
 concept is_configurable = requires(T t) {
   requires std::same_as<std::string, decltype(t.name)>;
@@ -93,11 +113,10 @@ concept is_configurable = requires(T t) {
 using ConfigurableAxis = Configurable<std::vector<double>, ConfigParamKind::kAxisSpec, ConfigurablePolicyConst<std::vector<double>, ConfigParamKind::kAxisSpec>>;
 
 template <typename T>
-concept is_configurable_axis = is_configurable<T>&&
-  requires()
-{
-  T::kind == ConfigParamKind::kAxisSpec;
-};
+concept is_configurable_axis = is_configurable<T> &&
+                               requires() {
+                                 T::kind == ConfigParamKind::kAxisSpec;
+                               };
 
 template <typename T, typename... As>
 struct ProcessConfigurable : Configurable<bool, ConfigParamKind::kProcessFlag> {
diff --git a/Framework/Core/src/AnalysisHelpers.cxx b/Framework/Core/src/AnalysisHelpers.cxx
index b7eac692d3859..149664c42caba 100644
--- a/Framework/Core/src/AnalysisHelpers.cxx
+++ b/Framework/Core/src/AnalysisHelpers.cxx
@@ -201,4 +201,5 @@ std::shared_ptr<arrow::Table> Builder::materialize(ProcessingContext& pc)
   result = o2::soa::IndexBuilder::materialize(*builders.get(), std::move(tables), records, outputSchema, exclusive);
   return result;
 }
+
 } // namespace o2::framework
diff --git a/Framework/Core/src/ArrowSupport.cxx b/Framework/Core/src/ArrowSupport.cxx
index 780c836437c2b..eecff4ce87c74 100644
--- a/Framework/Core/src/ArrowSupport.cxx
+++ b/Framework/Core/src/ArrowSupport.cxx
@@ -34,6 +34,7 @@
 #include "Framework/ServiceRegistryHelpers.h"
 #include "Framework/Signpost.h"
 #include "Framework/DefaultsHelpers.h"
+#include "Framework/ConfigParamsHelper.h"
 
 #include "CommonMessageBackendsHelpers.h"
 #include <Monitoring/Monitoring.h>
@@ -637,6 +638,34 @@ o2::framework::ServiceSpec ArrowSupport::arrowBackendSpec()
         analysisCCDB->outputs.clear();
         analysisCCDB->inputs.clear();
         AnalysisSupportHelpers::addMissingOutputsToBuilder(dec.analysisCCDBInputs, dec.requestedAODs, dec.requestedDYNs, *analysisCCDB);
+        // Register each ccdb: column path as an actual device option on the CCDB
+        // device so it can be read from ConfigParamRegistry at runtime.
+        // If any analysis task declared a Configurable<std::string> with the same
+        // "ccdb:fXxx" name, prefer its default over the compile-time ::query value.
+        // First encountered wins; log a warning if two tasks declare conflicting defaults.
+        for (auto& input : dec.analysisCCDBInputs) {
+          for (auto& m : input.metadata | std::views::filter(checks::has_params_with_name_starting("ccdb:"))) {
+            ConfigParamSpec effective = m; // start with compile-time default
+            bool foundFirst = false;
+            for (auto& d : workflow | views::exclude_by_name(analysisCCDB->name)) {
+              for (auto& opt : d.options) {
+                if (opt.name == m.name) {
+                  if (!foundFirst) {
+                    effective = opt; // first task Configurable wins
+                    foundFirst = true;
+                  } else if (opt.defaultValue.asString() != effective.defaultValue.asString()) {
+                    LOGP(warn, "Task '{}' declares Configurable '{}' = '{}' which conflicts "
+                               "with an earlier value '{}'; earlier value will be used.",
+                         d.name, opt.name, opt.defaultValue.asString(),
+                         effective.defaultValue.asString());
+                  }
+                  break;
+                }
+              }
+            }
+            ConfigParamsHelper::addOptionIfMissing(analysisCCDB->options, effective);
+          }
+        }
         // load real AlgorithmSpec before deployment
         analysisCCDB->algorithm = PluginManager::loadAlgorithmFromPlugin("O2FrameworkCCDBSupport", "AnalysisCCDBFetcherPlugin", ctx);
       }
diff --git a/Framework/TestWorkflows/src/o2TestAnalysisCCDB.cxx b/Framework/TestWorkflows/src/o2TestAnalysisCCDB.cxx
index f9684762539f7..3cf20d9ff5296 100644
--- a/Framework/TestWorkflows/src/o2TestAnalysisCCDB.cxx
+++ b/Framework/TestWorkflows/src/o2TestAnalysisCCDB.cxx
@@ -51,8 +51,11 @@ struct DummyTimestampsTable {
 };
 
 struct SimpleCCDBConsumer {
+  ConfigurableCCDBPath<o2::aod::tofcalib::LHCphase> lhcPhasePath;
+
   void process(o2::aod::TOFCalibrationObjects const& ccdbObjectsForAllTimestamps)
   {
+    LOGP(info, "LHCphase CCDB path configurable value: {}", lhcPhasePath.value);
     LOGP(info, "Looking at all the LHCphases associated to the timestamps");
     for (auto& object : ccdbObjectsForAllTimestamps) {
       std::cout << object.lhcPhase().getStartValidity() << " " << object.lhcPhase().getEndValidity() << std::endl;
@@ -60,10 +63,23 @@ struct SimpleCCDBConsumer {
   }
 };
 
+struct AnotherCCDBConsumer {
+  ConfigurableCCDBPath<o2::aod::tofcalib::LHCphase> lhcPhasePath;
+
+  void process(o2::aod::TOFCalibrationObjects const& ccdbObjectsForAllTimestamps)
+  {
+    LOGP(info, "AnotherCCDBConsumer LHCphase CCDB path configurable value: {}", lhcPhasePath.value);
+    for (auto& object : ccdbObjectsForAllTimestamps) {
+      std::cout << object.lhcPhase().getStartValidity() << " " << object.lhcPhase().getEndValidity() << std::endl;
+    }
+  }
+};
+
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
   return WorkflowSpec{
     adaptAnalysisTask<DummyTimestampsTable>(cfgc),
-    adaptAnalysisTask<SimpleCCDBConsumer>(cfgc, TaskName{"simple-ccdb-cunsumer"}),
+    adaptAnalysisTask<SimpleCCDBConsumer>(cfgc, TaskName{"simple-ccdb-consumer"}),
+    adaptAnalysisTask<AnotherCCDBConsumer>(cfgc, TaskName{"another-ccdb-consumer"}),
   };
 }

From 4ba3efa7d28316144ae5a58ac5f14b89bab746c8 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 4 May 2026 18:35:36 +0200
Subject: [PATCH 1702/1764] ITS: add hash function over clidx

---
 .../ITS/include/DataFormatsITS/TrackITS.h     | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
index 5d13ad753b8bc..a06395e76afff 100644
--- a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
+++ b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
@@ -210,6 +210,33 @@ class TrackITSExt : public TrackITS
     return mIndex;
   }
 
+#ifndef GPUCA_GPUCODE
+  // build order-independent hash via the external cluster idx (unique within a TF) for the selected layers
+  // cluster indices are either sorted inward or outward
+  size_t hash(uint16_t layerMask = 0xFFFF, bool inward = true) const noexcept
+  {
+    size_t h1 = 0, h2 = 0;
+    int from = (int)getLastClusterLayer(), to = -1, step = -1;
+    if (inward) {
+      from = (int)getFirstClusterLayer();
+      to = MaxClusters;
+      step = 1;
+    }
+    // clusters are stored continously but they do not necesarrily correspond to the layers
+    for (int layer = from, slot{0}; layer != to; layer += step) {
+      if (hasHitOnLayer(layer)) {
+        int idx = mIndex[slot++];
+        if (layerMask & (uint16_t(1) << layer)) {
+          size_t v = std::hash<int>{}(idx);
+          h1 ^= v;
+          h2 += v * 0x9e3779b97f4a7c15ULL; // boost's hash_combine
+        }
+      }
+    }
+    return h1 ^ (h2 << 1);
+  }
+#endif
+
  private:
   std::array<int, MaxClusters> mIndex = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; ///< Indices of associated clusters
   ClassDefNV(TrackITSExt, 3);

From eae2bb09a28de78958e5c675216d49bc743a534b Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Wed, 22 Apr 2026 21:02:20 +0200
Subject: [PATCH 1703/1764] ITS: fix truth seeding mode

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index 2acbec7fe8bc0..b4585929d2dcf 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -79,7 +79,6 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
 
       // update LUT with all currently found vertices so in second iteration we can check vertPerROFThreshold
       sortVertices();
-      mTimeFrame->updateROFVertexLookupTable();
     }
     completed = true;
   } catch (const BoundedMemoryResource::MemoryLimitExceeded& err) {
@@ -128,6 +127,8 @@ void Vertexer<NLayers>::sortVertices()
     }
     mc.swap(sortedMC);
   }
+  // update LUT after sorting
+  mTimeFrame->updateROFVertexLookupTable();
 }
 
 template <int NLayers>

From caec08121c136141d8b7882866259ed53213d418 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 6 May 2026 15:33:40 +0200
Subject: [PATCH 1704/1764] aggregator-workflow.sh: decouple IDC and CMV
 workflows

---
 .../full-system-test/aggregator-workflow.sh   | 102 ++++++++++--------
 1 file changed, 59 insertions(+), 43 deletions(-)

diff --git a/prodtests/full-system-test/aggregator-workflow.sh b/prodtests/full-system-test/aggregator-workflow.sh
index 0dc30df93669d..6ae609b494d78 100755
--- a/prodtests/full-system-test/aggregator-workflow.sh
+++ b/prodtests/full-system-test/aggregator-workflow.sh
@@ -155,25 +155,35 @@ if workflow_has_parameter CALIB_PROXIES; then
     if [[ -n ${CALIBDATASPEC_BARREL_SPORADIC:-} ]]; then
       add_W o2-dpl-raw-proxy "--dataspec \"$CALIBDATASPEC_BARREL_SPORADIC\" $(get_proxy_connection barrel_sp input sporadic)" "" 0
     fi
-  elif [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC ]]; then
+  elif [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC || $AGGREGATOR_TASKS == TPC_CMV ]]; then
     if [[ $EPNSYNCMODE != 1 ]]; then
-      echo "ERROR: TPC IDC / SAC calib workflow enabled without EPNSYNCMODE, please note that there will not be input data for it" 1>&2
+      echo "ERROR: TPC IDC / SAC / CMV calib workflow enabled without EPNSYNCMODE, please note that there will not be input data for it" 1>&2
     fi
     CHANNELS_LIST=
     [[ $EPNSYNCMODE == 0 ]] && FLP_ADDRESS="tcp://localhost:29950"
     if [[ -n ${CALIBDATASPEC_TPCIDC_A:-} ]] || [[ -n ${CALIBDATASPEC_TPCIDC_C:-} ]] || [[ -n ${CALIBDATASPEC_TPCCMV:-} ]]; then
-      # define port for FLP
-      : ${TPC_IDC_FLP_PORT:=29950}
+      # define port for FLP and channel prefix
+      TPC_FLP_PORT=
+      TPC_FLP_CHAN_PREFIX=
+      if [[ $AGGREGATOR_TASKS == TPC_CMV ]] && [[ -n ${CALIBDATASPEC_TPCCMV:-} ]]; then
+        TPC_FLP_PORT=29952
+        TPC_FLP_CHAN_PREFIX=tpccmv
+      elif [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC ]] && [[ -n ${CALIBDATASPEC_TPCIDC_A:-} || -n ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
+        TPC_FLP_PORT=29950
+        TPC_FLP_CHAN_PREFIX=tpcidc
+      fi
       # expand FLPs; TPC uses from 001 to 145, but 145 is reserved for SAC
-      if [[ "${GEN_TOPO_DEPLOYMENT_TYPE:-}" == "ALICE_STAGING" ]]; then
-        FLP_ADDRESS="tcp://alio2-cr1-mvs03-ib:${TPC_IDC_FLP_PORT}"
-        CHANNELS_LIST+="type=pull,name=tpcidc_flp,transport=zeromq,address=$FLP_ADDRESS,method=connect,rateLogging=10;"
-      else
-        for flp in $(seq -f "%03g" 1 144); do
-          [[ ! $FLP_IDS =~ (^|,)"$flp"(,|$) ]] && continue
-          [[ $EPNSYNCMODE == 1 ]] && FLP_ADDRESS="tcp://alio2-cr1-flp${flp}-ib:${TPC_IDC_FLP_PORT}"
-          CHANNELS_LIST+="type=pull,name=tpcidc_flp${flp},transport=zeromq,address=$FLP_ADDRESS,method=connect,rateLogging=10;"
-        done
+      if [[ -n $TPC_FLP_PORT ]]; then
+        if [[ "${GEN_TOPO_DEPLOYMENT_TYPE:-}" == "ALICE_STAGING" ]]; then
+          FLP_ADDRESS="tcp://alio2-cr1-mvs03-ib:${TPC_FLP_PORT}"
+          CHANNELS_LIST+="type=pull,name=${TPC_FLP_CHAN_PREFIX}_flp,transport=zeromq,address=$FLP_ADDRESS,method=connect,rateLogging=10;"
+        else
+          for flp in $(seq -f "%03g" 1 144); do
+            [[ ! $FLP_IDS =~ (^|,)"$flp"(,|$) ]] && continue
+            [[ $EPNSYNCMODE == 1 ]] && FLP_ADDRESS="tcp://alio2-cr1-flp${flp}-ib:${TPC_FLP_PORT}"
+            CHANNELS_LIST+="type=pull,name=${TPC_FLP_CHAN_PREFIX}_flp${flp},transport=zeromq,address=$FLP_ADDRESS,method=connect,rateLogging=10;"
+          done
+        fi
       fi
     fi
     if [[ -n ${CALIBDATASPEC_TPCSAC:-} ]]; then
@@ -184,22 +194,25 @@ if workflow_has_parameter CALIB_PROXIES; then
     fi
     if [[ -n $CHANNELS_LIST ]]; then
       DATASPEC_LIST=
-      if [[ -n ${CALIBDATASPEC_TPCIDC_A:-} ]]; then
-        add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCIDC_A\""
-      fi
-      if [[ -n ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
-        add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCIDC_C\""
-      fi
-      if [[ -n ${CALIBDATASPEC_TPCCMV:-} ]]; then
-        add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCCMV\""
-      fi
-      if [[ -n ${CALIBDATASPEC_TPCSAC:-} ]]; then
-        add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCSAC\""
+      if [[ $AGGREGATOR_TASKS == TPC_CMV ]]; then
+        if [[ -n ${CALIBDATASPEC_TPCCMV:-} ]]; then
+          add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCCMV\""
+        fi
+      else
+        if [[ -n ${CALIBDATASPEC_TPCIDC_A:-} ]]; then
+          add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCIDC_A\""
+        fi
+        if [[ -n ${CALIBDATASPEC_TPCIDC_C:-} ]]; then
+          add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCIDC_C\""
+        fi
+        if [[ -n ${CALIBDATASPEC_TPCSAC:-} ]]; then
+          add_semicolon_separated DATASPEC_LIST "\"$CALIBDATASPEC_TPCSAC\""
+        fi
       fi
       if [[ -z ${O2_TPC_IDC_CMV_IO_THREADS:-} ]]; then
         O2_TPC_IDC_CMV_IO_THREADS=4;
-    fi
-     add_W o2-dpl-raw-proxy "--proxy-name tpcidc --io-threads ${O2_TPC_IDC_CMV_IO_THREADS} --dataspec \"$DATASPEC_LIST\" --sporadic-outputs --channel-config \"$CHANNELS_LIST\" ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} $TIMEFRAME_SHM_LIMIT" "" 0
+      fi
+      add_W o2-dpl-raw-proxy "--proxy-name ${TPC_FLP_CHAN_PREFIX} --io-threads ${O2_TPC_IDC_CMV_IO_THREADS} --dataspec \"$DATASPEC_LIST\" --sporadic-outputs --channel-config \"$CHANNELS_LIST\" ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} $TIMEFRAME_SHM_LIMIT" "" 0
     fi
   elif [[ $AGGREGATOR_TASKS == CALO_TF ]]; then
     if [[ -n ${CALIBDATASPEC_CALO_TF:-} ]]; then
@@ -309,6 +322,8 @@ nTFs_SAC=$((10000 * 128 / ${NHBPERTF}))
 nBuffer=$((100 * 128 / ${NHBPERTF}))
 nBuffer_cmv=$((50 * 128 / ${NHBPERTF}))
 lanesCMVaggregate=${O2_TPC_CMV_AGGREGATE_NLANES:-8}
+cmvCompression=${O2_TPC_CMV_COMPRESSION:---use-sparse --cmv-zero-threshold 1.0 --cmv-dynamic-precision-mean 1.0 --cmv-dynamic-precision-sigma 8.0 --use-compression-huffman}
+cmvTimeframes=${O2_TPC_CMV_TIMEFRAMES:-2000}
 IDC_DELTA="--disable-IDCDelta true" # off by default
 # deltas are on by default; you need to request explicitly to switch them off;
 if [[ "${DISABLE_IDC_DELTA:-}" == "1" ]]; then IDC_DELTA=""; fi
@@ -316,24 +331,25 @@ if [[ "${ENABLE_IDC_DELTA_FILE:-}" == "1" ]]; then IDC_DELTA+=" --dump-IDCDelta-
 
 if [[ "${DISABLE_IDC_PAD_MAP_WRITING:-}" == 1 ]]; then TPC_WRITING_PAD_STATUS_MAP=""; else TPC_WRITING_PAD_STATUS_MAP="--enableWritingPadStatusMap true"; fi
 
-if ! workflow_has_parameter CALIB_LOCAL_INTEGRATED_AGGREGATOR && [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC || $AGGREGATOR_TASKS == ALL ]]; then
-  if [[ $CALIB_TPC_IDC == 1 ]]; then
-    add_W o2-tpc-idc-distribute "--crus ${crus} --timeframes ${nTFs} --output-lanes ${lanesFactorize} --send-precise-timestamp true --condition-tf-per-query ${nTFs}  --n-TFs-buffer ${nBuffer}"
-    add_W o2-tpc-idc-factorize "--n-TFs-buffer ${nBuffer} --input-lanes ${lanesFactorize} --crus ${crus} --timeframes ${nTFs} --nthreads-grouping ${threadFactorize} --nthreads-IDC-factorization ${threadFactorize} --sendOutputFFT true --enable-CCDB-output true --enablePadStatusMap true ${TPC_WRITING_PAD_STATUS_MAP} --use-precise-timestamp true $IDC_DELTA" "TPCIDCGroupParam.groupPadsSectorEdges=32211"
-    add_W o2-tpc-idc-ft-aggregator "--rangeIDC 200 --inputLanes ${lanesFactorize} --nFourierCoeff 40 --nthreads 8"
-  fi
-  if [[ $CALIB_TPC_CMV == 1 ]]; then
-    if [[ -z ${O2_TPC_CMV_COMPRESSION:-} ]]; then O2_TPC_CMV_COMPRESSION="--use-sparse --cmv-zero-threshold 1.0 --cmv-dynamic-precision-mean 1.0 --cmv-dynamic-precision-sigma 8.0 --use-compression-huffman"; fi
-    if [[ -z ${O2_TPC_CMV_TIMEFRAMES:-} ]]; then O2_TPC_CMV_TIMEFRAMES="2000"; fi
-    add_W o2-tpc-cmv-distribute "--crus ${crus} --lanes 1 --output-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --timeframes ${O2_TPC_CMV_TIMEFRAMES} --send-precise-timestamp "
-    add_W o2-tpc-cmv-aggregate "--crus ${crus} --input-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --nthreads-compression 4 --timeframes ${O2_TPC_CMV_TIMEFRAMES} --use-precise-timestamp  ${O2_TPC_CMV_COMPRESSION} --output-dir $CALIB_DIR --meta-output-dir $EPN2EOS_METAFILES_DIR "
-  fi
-  if [[ $CALIB_TPC_SAC == 1 ]]; then
-    add_W o2-tpc-sac-distribute "--timeframes ${nTFs_SAC} --output-lanes 1 "
-    add_W o2-tpc-sac-factorize "--timeframes ${nTFs_SAC} --nthreads-SAC-factorization 4 --input-lanes 1 --compression 2"
-    add_W o2-tpc-idc-ft-aggregator "--rangeIDC 200 --nFourierCoeff 40 --process-SACs true --inputLanes 1"
+if ! workflow_has_parameter CALIB_LOCAL_INTEGRATED_AGGREGATOR; then
+  if [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC || $AGGREGATOR_TASKS == ALL ]]; then
+    if [[ $CALIB_TPC_IDC == 1 ]]; then
+      add_W o2-tpc-idc-distribute "--crus ${crus} --timeframes ${nTFs} --output-lanes ${lanesFactorize} --send-precise-timestamp true --condition-tf-per-query ${nTFs}  --n-TFs-buffer ${nBuffer}"
+      add_W o2-tpc-idc-factorize "--n-TFs-buffer ${nBuffer} --input-lanes ${lanesFactorize} --crus ${crus} --timeframes ${nTFs} --nthreads-grouping ${threadFactorize} --nthreads-IDC-factorization ${threadFactorize} --sendOutputFFT true --enable-CCDB-output true --enablePadStatusMap true ${TPC_WRITING_PAD_STATUS_MAP} --use-precise-timestamp true $IDC_DELTA" "TPCIDCGroupParam.groupPadsSectorEdges=32211"
+      add_W o2-tpc-idc-ft-aggregator "--rangeIDC 200 --inputLanes ${lanesFactorize} --nFourierCoeff 40 --nthreads 8"
+    fi
+    if [[ $CALIB_TPC_SAC == 1 ]]; then
+      add_W o2-tpc-sac-distribute "--timeframes ${nTFs_SAC} --output-lanes 1 "
+      add_W o2-tpc-sac-factorize "--timeframes ${nTFs_SAC} --nthreads-SAC-factorization 4 --input-lanes 1 --compression 2"
+      add_W o2-tpc-idc-ft-aggregator "--rangeIDC 200 --nFourierCoeff 40 --process-SACs true --inputLanes 1"
+    fi
+  elif [[ $AGGREGATOR_TASKS == TPC_CMV || $AGGREGATOR_TASKS == ALL ]]; then
+    if [[ $CALIB_TPC_CMV == 1 ]]; then
+      add_W o2-tpc-cmv-distribute "--crus ${crus} --lanes 1 --output-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --timeframes ${cmvTimeframes} --send-precise-timestamp "
+      add_W o2-tpc-cmv-aggregate "--crus ${crus} --input-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --nthreads-compression 4 --timeframes ${cmvTimeframes} --use-precise-timestamp  ${cmvCompression} --output-dir $CALIB_DIR --meta-output-dir $EPN2EOS_METAFILES_DIR "
+      CCDB_POPULATOR_UPLOAD_PATH=none
+    fi
   fi
-  [[ $AGGREGATOR_TASKS == TPC_IDCBOTH_SAC ]] && [[ $CALIB_TPC_IDC == 0 && $CALIB_TPC_SAC == 0 && $CALIB_TPC_CMV == 1 ]] && CCDB_POPULATOR_UPLOAD_PATH="none"
 fi
 
 # Calo cal

From 6432b3e25eb7571cbaa852f6646a83402593d81e Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Wed, 6 May 2026 15:37:03 +0200
Subject: [PATCH 1705/1764] aggregator-workflow.sh: update CMV workflow default
 parameters

---
 prodtests/full-system-test/aggregator-workflow.sh | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/prodtests/full-system-test/aggregator-workflow.sh b/prodtests/full-system-test/aggregator-workflow.sh
index 6ae609b494d78..18568f2b94388 100755
--- a/prodtests/full-system-test/aggregator-workflow.sh
+++ b/prodtests/full-system-test/aggregator-workflow.sh
@@ -321,9 +321,9 @@ nTFs=$((1000 * 128 / ${NHBPERTF}))
 nTFs_SAC=$((10000 * 128 / ${NHBPERTF}))
 nBuffer=$((100 * 128 / ${NHBPERTF}))
 nBuffer_cmv=$((50 * 128 / ${NHBPERTF}))
-lanesCMVaggregate=${O2_TPC_CMV_AGGREGATE_NLANES:-8}
+lanesCMVaggregate=${O2_TPC_CMV_AGGREGATE_NLANES:-4}
 cmvCompression=${O2_TPC_CMV_COMPRESSION:---use-sparse --cmv-zero-threshold 1.0 --cmv-dynamic-precision-mean 1.0 --cmv-dynamic-precision-sigma 8.0 --use-compression-huffman}
-cmvTimeframes=${O2_TPC_CMV_TIMEFRAMES:-2000}
+cmvTimeframes=${O2_TPC_CMV_TIMEFRAMES:-4000}
 IDC_DELTA="--disable-IDCDelta true" # off by default
 # deltas are on by default; you need to request explicitly to switch them off;
 if [[ "${DISABLE_IDC_DELTA:-}" == "1" ]]; then IDC_DELTA=""; fi
@@ -346,7 +346,7 @@ if ! workflow_has_parameter CALIB_LOCAL_INTEGRATED_AGGREGATOR; then
   elif [[ $AGGREGATOR_TASKS == TPC_CMV || $AGGREGATOR_TASKS == ALL ]]; then
     if [[ $CALIB_TPC_CMV == 1 ]]; then
       add_W o2-tpc-cmv-distribute "--crus ${crus} --lanes 1 --output-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --timeframes ${cmvTimeframes} --send-precise-timestamp "
-      add_W o2-tpc-cmv-aggregate "--crus ${crus} --input-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --nthreads-compression 4 --timeframes ${cmvTimeframes} --use-precise-timestamp  ${cmvCompression} --output-dir $CALIB_DIR --meta-output-dir $EPN2EOS_METAFILES_DIR "
+      add_W o2-tpc-cmv-aggregate "--crus ${crus} --input-lanes ${lanesCMVaggregate} --n-TFs-buffer ${nBuffer_cmv} --nthreads-compression 8 --timeframes ${cmvTimeframes} --use-precise-timestamp  ${cmvCompression} --output-dir $CALIB_DIR --meta-output-dir $EPN2EOS_METAFILES_DIR "
       CCDB_POPULATOR_UPLOAD_PATH=none
     fi
   fi

From a5278aaab18e3bc51049fbfdc8f861bc3bde5b8d Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <maximiliano.puccio@cern.ch>
Date: Tue, 5 May 2026 16:27:47 +0200
Subject: [PATCH 1706/1764] ITS: add 11-layer GPU tracking support

---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |   6 +-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     |   4 +
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |   3 +
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 181 ++++++++++++++++++
 4 files changed, 191 insertions(+), 3 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index c87b3d36b9a6a..8852810399eeb 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -25,7 +25,7 @@ namespace o2::its::gpu
 {
 
 template <int NLayers>
-class TimeFrameGPU final : public TimeFrame<NLayers>
+class TimeFrameGPU : public TimeFrame<NLayers>
 {
   using typename TimeFrame<NLayers>::IndexTableUtilsN;
   using typename TimeFrame<NLayers>::ROFOverlapTableN;
@@ -35,7 +35,7 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
 
  public:
   TimeFrameGPU() = default;
-  ~TimeFrameGPU() final = default;
+  ~TimeFrameGPU() override = default;
 
   /// Most relevant operations
   void pushMemoryStack(const int);
@@ -104,7 +104,7 @@ class TimeFrameGPU final : public TimeFrame<NLayers>
 
   /// interface
   virtual bool isGPU() const noexcept final { return true; }
-  virtual const char* getName() const noexcept { return "GPU"; }
+  virtual const char* getName() const noexcept override final { return "GPU"; }
   IndexTableUtilsN* getDeviceIndexTableUtils() { return mIndexTableUtilsDevice; }
   const auto getDeviceROFOverlapTableView() { return mDeviceROFOverlapTableView; }
   const auto getDeviceROFVertexLookupTableView() { return mDeviceROFVertexLookupTableView; }
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index b9091eebde377..03957cd678df0 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -694,4 +694,8 @@ void TimeFrameGPU<NLayers>::wipe()
 }
 
 template class TimeFrameGPU<7>;
+// ALICE3 upgrade
+#ifdef ENABLE_UPGRADES
+template class TimeFrameGPU<11>;
+#endif
 } // namespace o2::its::gpu
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 67b6b0bf5cdfe..8bb0bb5310b52 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -388,4 +388,7 @@ void TrackerTraitsGPU<NLayers>::setBz(float bz)
 }
 
 template class TrackerTraitsGPU<7>;
+#ifdef ENABLE_UPGRADES
+template class TrackerTraitsGPU<11>;
+#endif
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 49b8f19d68ea6..6d778f17dc932 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -1258,4 +1258,185 @@ template void computeTrackSeedHandler(TrackSeed<7>* trackSeeds,
                                       const o2::base::PropagatorF::MatCorrType matCorrType,
                                       o2::its::ExternalAllocator* alloc);
 
+/// Explicit instantiation of ALICE3 handlers
+#ifdef ENABLE_UPGRADES
+template void countTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils,
+                                              const ROFMaskTable<11>::View& rofMask,
+                                              const int layer,
+                                              const ROFOverlapTable<11>::View& rofOverlaps,
+                                              const ROFVertexLookupTable<11>::View& vertexLUT,
+                                              const int vertexId,
+                                              const Vertex* vertices,
+                                              const int* rofPV,
+                                              const Cluster** clusters,
+                                              std::vector<unsigned int> nClusters,
+                                              const int** ROFClusters,
+                                              const unsigned char** usedClusters,
+                                              const int** clustersIndexTables,
+                                              int** trackletsLUTs,
+                                              gsl::span<int*> trackletsLUTsHost,
+                                              const int iteration,
+                                              const float NSigmaCut,
+                                              bounded_vector<float>& phiCuts,
+                                              const float resolutionPV,
+                                              std::array<float, 11>& minRs,
+                                              std::array<float, 11>& maxRs,
+                                              bounded_vector<float>& resolutions,
+                                              std::vector<float>& radii,
+                                              bounded_vector<float>& mulScatAng,
+                                              o2::its::ExternalAllocator* alloc,
+                                              gpu::Streams& streams);
+
+template void computeTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils,
+                                                const ROFMaskTable<11>::View& rofMask,
+                                                const int layer,
+                                                const ROFOverlapTable<11>::View& rofOverlaps,
+                                                const ROFVertexLookupTable<11>::View& vertexLUT,
+                                                const int vertexId,
+                                                const Vertex* vertices,
+                                                const int* rofPV,
+                                                const Cluster** clusters,
+                                                std::vector<unsigned int> nClusters,
+                                                const int** ROFClusters,
+                                                const unsigned char** usedClusters,
+                                                const int** clustersIndexTables,
+                                                Tracklet** tracklets,
+                                                gsl::span<Tracklet*> spanTracklets,
+                                                gsl::span<int> nTracklets,
+                                                int** trackletsLUTs,
+                                                gsl::span<int*> trackletsLUTsHost,
+                                                const int iteration,
+                                                const float NSigmaCut,
+                                                bounded_vector<float>& phiCuts,
+                                                const float resolutionPV,
+                                                std::array<float, 11>& minRs,
+                                                std::array<float, 11>& maxRs,
+                                                bounded_vector<float>& resolutions,
+                                                std::vector<float>& radii,
+                                                bounded_vector<float>& mulScatAng,
+                                                o2::its::ExternalAllocator* alloc,
+                                                gpu::Streams& streams);
+
+template void countCellsHandler<11>(const Cluster** sortedClusters,
+                                    const Cluster** unsortedClusters,
+                                    const TrackingFrameInfo** tfInfo,
+                                    Tracklet** tracklets,
+                                    int** trackletsLUT,
+                                    const int nTracklets,
+                                    const int layer,
+                                    CellSeed* cells,
+                                    int** cellsLUTsArrayDevice,
+                                    int* cellsLUTsHost,
+                                    const float bz,
+                                    const float maxChi2ClusterAttachment,
+                                    const float cellDeltaTanLambdaSigma,
+                                    const float nSigmaCut,
+                                    const std::vector<float>& layerxX0Host,
+                                    o2::its::ExternalAllocator* alloc,
+                                    gpu::Streams& streams);
+
+template void computeCellsHandler<11>(const Cluster** sortedClusters,
+                                      const Cluster** unsortedClusters,
+                                      const TrackingFrameInfo** tfInfo,
+                                      Tracklet** tracklets,
+                                      int** trackletsLUT,
+                                      const int nTracklets,
+                                      const int layer,
+                                      CellSeed* cells,
+                                      int** cellsLUTsArrayDevice,
+                                      int* cellsLUTsHost,
+                                      const float bz,
+                                      const float maxChi2ClusterAttachment,
+                                      const float cellDeltaTanLambdaSigma,
+                                      const float nSigmaCut,
+                                      const std::vector<float>& layerxX0Host,
+                                      gpu::Streams& streams);
+
+template void countCellNeighboursHandler<11>(CellSeed** cellsLayersDevice,
+                                             int* neighboursLUT,
+                                             int** cellsLUTs,
+                                             gpuPair<int, int>* cellNeighbours,
+                                             int* neighboursIndexTable,
+                                             const Tracklet** tracklets,
+                                             const float maxChi2ClusterAttachment,
+                                             const float bz,
+                                             const int layerIndex,
+                                             const unsigned int nCells,
+                                             const unsigned int nCellsNext,
+                                             const int maxCellNeighbours,
+                                             o2::its::ExternalAllocator* alloc,
+                                             gpu::Stream& stream);
+
+template void computeCellNeighboursHandler<11>(CellSeed** cellsLayersDevice,
+                                               int* neighboursLUT,
+                                               int** cellsLUTs,
+                                               gpuPair<int, int>* cellNeighbours,
+                                               int* neighboursIndexTable,
+                                               const Tracklet** tracklets,
+                                               const float maxChi2ClusterAttachment,
+                                               const float bz,
+                                               const int layerIndex,
+                                               const unsigned int nCells,
+                                               const unsigned int nCellsNext,
+                                               const int maxCellNeighbours,
+                                               gpu::Stream& stream);
+
+template void processNeighboursHandler<11>(const int startLayer,
+                                           const int startLevel,
+                                           CellSeed** allCellSeeds,
+                                           CellSeed* currentCellSeeds,
+                                           std::array<int, 9>& nCells,
+                                           const unsigned char** usedClusters,
+                                           std::array<int*, 9>& neighbours,
+                                           gsl::span<int*> neighboursDeviceLUTs,
+                                           const TrackingFrameInfo** foundTrackingFrameInfo,
+                                           bounded_vector<TrackSeed<11>>& seedsHost,
+                                           const float bz,
+                                           const float maxChi2ClusterAttachment,
+                                           const float maxChi2NDF,
+                                           const std::vector<float>& layerxX0Host,
+                                           const o2::base::Propagator* propagator,
+                                           const o2::base::PropagatorF::MatCorrType matCorrType,
+                                           o2::its::ExternalAllocator* alloc);
+
+template void countTrackSeedHandler(TrackSeed<11>* trackSeeds,
+                                    const TrackingFrameInfo** foundTrackingFrameInfo,
+                                    const Cluster** unsortedClusters,
+                                    int* seedLUT,
+                                    const std::vector<float>& layerRadiiHost,
+                                    const std::vector<float>& minPtsHost,
+                                    const std::vector<float>& layerxX0Host,
+                                    const unsigned int nSeeds,
+                                    const float bz,
+                                    const int startLevel,
+                                    const float maxChi2ClusterAttachment,
+                                    const float maxChi2NDF,
+                                    const int reseedIfShorter,
+                                    const bool repeatRefitOut,
+                                    const bool shiftRefToCluster,
+                                    const o2::base::Propagator* propagator,
+                                    const o2::base::PropagatorF::MatCorrType matCorrType,
+                                    o2::its::ExternalAllocator* alloc);
+
+template void computeTrackSeedHandler(TrackSeed<11>* trackSeeds,
+                                      const TrackingFrameInfo** foundTrackingFrameInfo,
+                                      const Cluster** unsortedClusters,
+                                      o2::its::TrackITSExt* tracks,
+                                      const int* seedLUT,
+                                      const std::vector<float>& layerRadiiHost,
+                                      const std::vector<float>& minPtsHost,
+                                      const std::vector<float>& layerxX0Host,
+                                      const unsigned int nSeeds,
+                                      const unsigned int nTracks,
+                                      const float bz,
+                                      const int startLevel,
+                                      const float maxChi2ClusterAttachment,
+                                      const float maxChi2NDF,
+                                      const int reseedIfShorter,
+                                      const bool repeatRefitOut,
+                                      const bool shiftRefToCluster,
+                                      const o2::base::Propagator* propagator,
+                                      const o2::base::PropagatorF::MatCorrType matCorrType,
+                                      o2::its::ExternalAllocator* alloc);
+#endif
 } // namespace o2::its

From 204e32877db4740c401773a5dd0197364d2e10f6 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Thu, 7 May 2026 21:48:25 +0200
Subject: [PATCH 1707/1764] DPL: allow for larger state information to be sent
 around (#15378)

---
 Framework/Core/src/DataProcessingStates.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/DataProcessingStates.cxx b/Framework/Core/src/DataProcessingStates.cxx
index 64be1829d8c97..8bf80e79b1839 100644
--- a/Framework/Core/src/DataProcessingStates.cxx
+++ b/Framework/Core/src/DataProcessingStates.cxx
@@ -111,9 +111,9 @@ void DataProcessingStates::updateState(CommandSpec cmd)
   // Add a static mutex to protect the queue
   // Get the next available operation in an atomic way.
   int size = sizeof(CommandHeader) + cmd.size;
-  if (size > 16384) {
-    throw runtime_error_f("State size is %d for state %s. States larger than 16384 bytes not supported for now.",
-                          size, stateSpecs[cmd.id].name.c_str());
+  if (size > STATES_BUFFER_SIZE / 8) {
+    throw runtime_error_f("State size is %d (data: %d bytes, header: %zu bytes) for state %s. States larger than %d bytes (1/8 of the states buffer) not supported. State data preview: %.100s",
+                          size, cmd.size, sizeof(CommandHeader), stateSpecs[cmd.id].name.c_str(), STATES_BUFFER_SIZE / 8, cmd.data ? cmd.data : "(null)");
   }
   int idx = nextState.fetch_sub(size, std::memory_order_relaxed);
   if (idx - size < 0) {

From 1cb2e463b0eebe86a5a78c5f84a1fdd0c1431227 Mon Sep 17 00:00:00 2001
From: wiechula <11199190+wiechula@users.noreply.github.com>
Date: Thu, 7 May 2026 22:35:56 +0200
Subject: [PATCH 1708/1764] Add missing includes reported by gcc 16.1 (#15379)

---
 .../reconstruction/include/EMCALReconstruction/TRUDataHandler.h  | 1 +
 Framework/Core/include/Framework/TableConsumer.h                 | 1 +
 Framework/Foundation/include/Framework/Signpost.h                | 1 +
 GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h                  | 1 +
 GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h                  | 1 +
 5 files changed, 5 insertions(+)

diff --git a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/TRUDataHandler.h b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/TRUDataHandler.h
index 811faf13a05ff..ea9820563dee6 100644
--- a/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/TRUDataHandler.h
+++ b/Detectors/EMCAL/reconstruction/include/EMCALReconstruction/TRUDataHandler.h
@@ -13,6 +13,7 @@
 
 #include <array>
 #include <bitset>
+#include <climits>
 #include <cstdint>
 #include <exception>
 #include <iosfwd>
diff --git a/Framework/Core/include/Framework/TableConsumer.h b/Framework/Core/include/Framework/TableConsumer.h
index f2a041952470c..1924d0694097b 100644
--- a/Framework/Core/include/Framework/TableConsumer.h
+++ b/Framework/Core/include/Framework/TableConsumer.h
@@ -12,6 +12,7 @@
 #ifndef FRAMEWORK_TABLECONSUMER_H
 #define FRAMEWORK_TABLECONSUMER_H
 
+#include <cstdint>
 #include <memory>
 
 namespace arrow
diff --git a/Framework/Foundation/include/Framework/Signpost.h b/Framework/Foundation/include/Framework/Signpost.h
index 51d1b0433b0de..0bbaaa5c37ed2 100644
--- a/Framework/Foundation/include/Framework/Signpost.h
+++ b/Framework/Foundation/include/Framework/Signpost.h
@@ -14,6 +14,7 @@
 #include "Framework/CompilerBuiltins.h"
 #include <atomic>
 #include <array>
+#include <unistd.h>
 #ifdef __APPLE__
 #include <os/log.h>
 #endif
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
index 0af10dbe4f388..f85a376b9185a 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceRefit.h
@@ -16,6 +16,7 @@
 #define GPUO2INTERFACEREFIT_H
 
 #include "GPUO2ExternalUser.h"
+#include <cstdint>
 #include <memory>
 #include <vector>
 #include <gsl/span>
diff --git a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h
index 813444470082e..92f87cee66232 100644
--- a/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h
+++ b/GPU/GPUTracking/Interface/GPUO2InterfaceUtils.h
@@ -15,6 +15,7 @@
 #ifndef GPUO2INTERFACEUTILS_H
 #define GPUO2INTERFACEUTILS_H
 
+#include <cstdint>
 #include <functional>
 #include <memory>
 

From a0f94b478403c4dcca457b1269b43ffba1890468 Mon Sep 17 00:00:00 2001
From: Giorgio Alberto Lucia
 <87222843+GiorgioAlbertoLucia@users.noreply.github.com>
Date: Fri, 8 May 2026 03:39:22 +0200
Subject: [PATCH 1709/1764] [ALICE3] IOTOF: Digitization for the TOF3  (#15372)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* one sensor per chip

* one sensor per chip also in second layer

* iotof segmentation and parameters. Segmentation parameters are stolen from ALPIDE and probably nonsensical

* compute number of chips in IOTOF

* fill L2G transformation matrices

* fix cmakelist

* only fill segmentation details if layout is segmented + add function to retrieve chip index

* use proper chip id for segmented barrel

* refactoring of segmentation, idependent for inner and outer tof, nonstatic

* singleton implementation of the segmentation class

* realistic values fot the chip segmentation

* hit processing in place, tested on A3Studies/Digitization/testDigitization.cpp

* clang format

* protect against disks for now

* added sanity checks

* thickness that matches the values currently in O2

* default init of chipspecifics to zero

* double typo (half the honor)

* Please consider the following formatting changes

* Fix row and column assignment in detector functions

* Change return type in segmentation function

Updated return statement to remove false return value.

* Remove return statement from detectorToLocalUnchecked

Updated detectorToLocalUnchecked methods to remove return type.

* Remove Mat3D alias from GeometryTGeo class

Removed the alias 'Mat3D' for 'o2::math_utils::Transform3D'.

* Replace matrix transformation with Transform3D

---------

Co-authored-by: maciacco <mario.ciacco@cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
Co-authored-by: Nicolò Jacazio <njacazio@users.noreply.github.com>
---
 .../base/include/IOTOFBase/GeometryTGeo.h     |  36 ++-
 .../base/include/IOTOFBase/IOTOFBaseParam.h   |  21 ++
 .../ALICE3/IOTOF/base/src/GeometryTGeo.cxx    | 213 +++++++++++++++++
 .../ALICE3/IOTOF/simulation/CMakeLists.txt    |   7 +-
 .../include/IOTOFSimulation/Digitizer.h       |   3 +
 .../include/IOTOFSimulation/Segmentation.h    | 215 ++++++++++++++++++
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  |  24 +-
 .../ALICE3/IOTOF/simulation/src/Digitizer.cxx |  24 +-
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     |   8 +-
 .../IOTOF/simulation/src/Segmentation.cxx     |  90 ++++++++
 10 files changed, 627 insertions(+), 14 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Segmentation.h
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Segmentation.cxx

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/GeometryTGeo.h b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/GeometryTGeo.h
index 577bd1bcabaf1..b998619684b28 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/GeometryTGeo.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/GeometryTGeo.h
@@ -22,6 +22,8 @@ namespace iotof
 class GeometryTGeo : public o2::detectors::DetMatrixCache
 {
  public:
+  using DetMatrixCache::getMatrixL2G;
+
   GeometryTGeo(bool build = false, int loadTrans = 0);
   void Build(int loadTrans);
   void fillMatrixCache(int mask);
@@ -79,7 +81,25 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static const char* composeBTOFSymNameChip(int d, int lr);
   static const char* composeBTOFSymNameSensor(int d, int layer);
 
+  int getIOTOFFirstChipIndex(int lay) const;
+  int getIOTOFLayer(int index) const;
+  int getIOTOFChipIndex(int lay, int sta, int mod, int chip) const;
+  bool getIOTOFChipId(int index, int& lay, int& sta, int& mod, int& chip) const;
+
+  /// Get the transformation matrix of the SENSOR (not necessary the same as the chip)
+  /// for a given chip 'index' by querying the TGeoManager
+  TGeoHMatrix* extractMatrixSensor(int index) const;
+
+  TString getMatrixPath(int index) const;
+
  protected:
+  // Determine the number of active parts in the geometry
+  int extractNumberOfStavesIOTOF(int lay) const;
+  int extractNumberOfModulesIOTOF(int lay) const;
+  int extractNumberOfChipsPerModuleIOTOF(int lay) const;
+  int extractNumberOfChipsFTOF() const;
+  int extractNumberOfChipsBTOF() const;
+
   // i/oTOF mother volume
   static std::string sIOTOFVolumeName;
 
@@ -107,10 +127,24 @@ class GeometryTGeo : public o2::detectors::DetMatrixCache
   static std::string sBTOFChipName;
   static std::string sBTOFSensorName;
 
+  // Inner/outer TOF
+  int mNumberOfStavesIOTOF[2];
+  int mNumberOfModulesIOTOF[2];
+  int mNumberOfChipsPerModuleIOTOF[2];
+  int mNumberOfChipsPerStaveIOTOF[2];
+  int mNumberOfChipsIOTOF[2];
+  int mLastChipIndex[2];
+
+  // Forward TOF
+  int mNumberOfChipsFTOF;
+
+  // Backward TOF
+  int mNumberOfChipsBTOF;
+
  private:
   static std::unique_ptr<o2::iotof::GeometryTGeo> sInstance;
 };
 
 } // namespace iotof
 } // namespace o2
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
index c1a9578484c17..c4cf5fd8844a8 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/include/IOTOFBase/IOTOFBaseParam.h
@@ -20,6 +20,24 @@ namespace o2
 namespace iotof
 {
 
+struct ChipSpecifics {
+  int NCols = 0;
+  int NRows = 0;
+  float PitchCol = 0.;
+  float PitchRow = 0.;
+  float PassiveEdgeReadOut = 0.;
+  float PassiveEdgeTop = 0.;
+  float PassiveEdgeSide = 0.;
+  float SensorLayerThicknessEff = 0.;
+  float SensorLayerThickness = 0.;
+
+  int NPixels() const { return NCols * NRows; }
+  float ActiveMatrixSizeCols() const { return PitchCol * NCols; }
+  float ActiveMatrixSizeRows() const { return PitchRow * NRows; }
+  float SensorSizeCols() const { return ActiveMatrixSizeCols() + 2 * PassiveEdgeSide; }
+  float SensorSizeRows() const { return ActiveMatrixSizeRows() + PassiveEdgeTop + PassiveEdgeReadOut; }
+};
+
 struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam> {
   bool enableInnerTOF = true;       // Enable Inner TOF layer
   bool enableOuterTOF = true;       // Enable Outer TOF layer
@@ -31,6 +49,9 @@ struct IOTOFBaseParam : public o2::conf::ConfigurableParamHelper<IOTOFBaseParam>
   float x2x0 = 0.02f;               // thickness expressed in radiation length, for all layers for the moment
   float sensorThickness = 0.0050f;  // thickness of the sensor in cm, for all layers for the moment, the default is set to 50 microns
 
+  ChipSpecifics iTofChipSpecifics{258, 271, 250.00e-4, 100.00e-4, 0.00f, 0.00e-4, 0.00e-4, 50.e-4, 50.e-4};
+  ChipSpecifics oTofChipSpecifics{251, 487, 250.00e-4, 100.00e-4, 0.00f, 0.00e-4, 106.48e-4, 50.e-4, 50.e-4};
+
   O2ParamDef(IOTOFBaseParam, "IOTOFBase");
 };
 
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/base/src/GeometryTGeo.cxx b/Detectors/Upgrades/ALICE3/IOTOF/base/src/GeometryTGeo.cxx
index f7d0eb135a27a..eb209931207e3 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/base/src/GeometryTGeo.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/base/src/GeometryTGeo.cxx
@@ -10,6 +10,7 @@
 // or submit itself to any jurisdiction.
 
 #include <IOTOFBase/GeometryTGeo.h>
+#include <IOTOFBase/IOTOFBaseParam.h>
 #include <TGeoManager.h>
 
 namespace o2
@@ -55,6 +56,171 @@ GeometryTGeo::GeometryTGeo(bool build, int loadTrans) : DetMatrixCache()
   }
 }
 
+int GeometryTGeo::extractNumberOfStavesIOTOF(int lay) const
+{
+  int numberOfStaves{0};
+
+  std::string layName = lay == 0 ? GeometryTGeo::getITOFLayerPattern() : GeometryTGeo::getOTOFLayerPattern();
+  TGeoVolume* layV = gGeoManager->GetVolume(layName.c_str());
+  if (layV == nullptr) {
+    LOG(fatal) << "Can't find volume " << layName;
+    return -1;
+  }
+
+  TObjArray* nodes = layV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j{0}; j < nNodes; ++j) {
+    if (strstr(nodes->At(j)->GetName(), lay == 0 ? GeometryTGeo::getITOFStavePattern() : GeometryTGeo::getOTOFStavePattern()) != nullptr) {
+      numberOfStaves++;
+    }
+  }
+
+  return numberOfStaves;
+}
+
+int GeometryTGeo::extractNumberOfModulesIOTOF(int lay) const
+{
+  int numberOfModules{0};
+
+  std::string staveName = lay == 0 ? GeometryTGeo::getITOFStavePattern() : GeometryTGeo::getOTOFStavePattern();
+  TGeoVolume* staveV = gGeoManager->GetVolume(staveName.c_str());
+  if (staveV == nullptr) {
+    LOG(fatal) << "Can't find volume " << staveName;
+    return -1;
+  }
+
+  TObjArray* nodes = staveV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j{0}; j < nNodes; ++j) {
+    if (strstr(nodes->At(j)->GetName(), lay == 0 ? GeometryTGeo::getITOFModulePattern() : GeometryTGeo::getOTOFModulePattern()) != nullptr) {
+      numberOfModules++;
+    }
+  }
+
+  return numberOfModules;
+}
+
+int GeometryTGeo::extractNumberOfChipsPerModuleIOTOF(int lay) const
+{
+  int numberOfChips{0};
+
+  std::string moduleName = lay == 0 ? GeometryTGeo::getITOFModulePattern() : GeometryTGeo::getOTOFModulePattern();
+  TGeoVolume* moduleV = gGeoManager->GetVolume(moduleName.c_str());
+  if (moduleV == nullptr) {
+    LOG(fatal) << "Can't find volume " << moduleName;
+    return -1;
+  }
+
+  TObjArray* nodes = moduleV->GetNodes();
+  int nNodes = nodes->GetEntriesFast();
+
+  for (int j{0}; j < nNodes; ++j) {
+    if (strstr(nodes->At(j)->GetName(), lay == 0 ? GeometryTGeo::getITOFChipPattern() : GeometryTGeo::getOTOFChipPattern()) != nullptr) {
+      numberOfChips++;
+    }
+  }
+
+  return numberOfChips;
+}
+
+int GeometryTGeo::extractNumberOfChipsFTOF() const
+{
+  return 0;
+}
+
+int GeometryTGeo::extractNumberOfChipsBTOF() const
+{
+  return 0;
+}
+
+int GeometryTGeo::getIOTOFFirstChipIndex(int lay) const
+{
+  return lay == 0 ? 0 : mLastChipIndex[0] + 1;
+}
+
+int GeometryTGeo::getIOTOFLayer(int index) const
+{
+  if (index < 0 || index > mLastChipIndex[1]) {
+    LOG(fatal) << "Invalid chip index " << index;
+    return -1;
+  }
+  return index > mLastChipIndex[0] ? 1 : 0;
+}
+
+int GeometryTGeo::getIOTOFChipIndex(int lay, int sta, int mod, int chip) const
+{
+  return getIOTOFFirstChipIndex(lay) + (sta - 1) * mNumberOfChipsPerStaveIOTOF[lay] + (mod - 1) * mNumberOfChipsPerModuleIOTOF[lay] + (chip - 1);
+}
+
+bool GeometryTGeo::getIOTOFChipId(int index, int& lay, int& sta, int& mod, int& chip) const
+{
+  lay = getIOTOFLayer(index);
+  index -= getIOTOFFirstChipIndex(lay);
+  sta = mNumberOfStavesIOTOF[lay] > 0 ? index / mNumberOfChipsPerStaveIOTOF[lay] : -1;
+  index %= mNumberOfChipsPerStaveIOTOF[lay];
+  mod = mNumberOfModulesIOTOF[lay] > 0 ? index / mNumberOfChipsPerModuleIOTOF[lay] : -1;
+  chip = index % mNumberOfChipsPerModuleIOTOF[lay];
+  return true;
+}
+
+TString GeometryTGeo::getMatrixPath(int index) const
+{
+  int lay, sta, mod, chip;
+  getIOTOFChipId(index, lay, sta, mod, chip);
+
+  TString path = Form("/cave_1/barrel_1/%s_2/", GeometryTGeo::getIOTOFVolPattern());
+  sta += 1;
+  mod += 1;
+  chip += 1;
+
+  if (lay == 0) {
+    path += Form("%s_1/", GeometryTGeo::getITOFLayerPattern());
+    if (mNumberOfStavesIOTOF[lay] > 0)
+      path += Form("%s_%d/", GeometryTGeo::getITOFStavePattern(), sta);
+    if (mNumberOfModulesIOTOF[lay] > 0)
+      path += Form("%s_%d/", GeometryTGeo::getITOFModulePattern(), mod);
+    if (mNumberOfChipsPerModuleIOTOF[lay] > 0)
+      path += Form("%s_%d/%s_1", GeometryTGeo::getITOFChipPattern(), chip, GeometryTGeo::getITOFSensorPattern());
+  } else {
+    path += Form("%s_1/", GeometryTGeo::getOTOFLayerPattern());
+    if (mNumberOfStavesIOTOF[lay] > 0)
+      path += Form("%s_%d/", GeometryTGeo::getOTOFStavePattern(), sta);
+    if (mNumberOfModulesIOTOF[lay] > 0)
+      path += Form("%s_%d/", GeometryTGeo::getOTOFModulePattern(), mod);
+    if (mNumberOfChipsPerModuleIOTOF[lay] > 0)
+      path += Form("%s_%d/%s_1", GeometryTGeo::getOTOFChipPattern(), chip, GeometryTGeo::getOTOFSensorPattern());
+  }
+
+  return path;
+}
+
+TGeoHMatrix* GeometryTGeo::extractMatrixSensor(int index) const
+{
+  auto path = getMatrixPath(index);
+
+  static TGeoHMatrix matTmp;
+  gGeoManager->PushPath();
+
+  if (!gGeoManager->cd(path.Data())) {
+    gGeoManager->PopPath();
+    LOG(error) << "Error in cd-ing to " << path.Data();
+    return nullptr;
+  }
+
+  matTmp = *gGeoManager->GetCurrentMatrix();
+  // LOG(info) << "Path = " << path.Data();
+
+  // Restore the modeler state
+  gGeoManager->PopPath();
+
+  // account for the difference between physical sensitive layer (where charge collection is simulated) and effective sensor thicknesses
+  // TODO: apply translation by the effective sensor thickness, not yet done (see ITS)
+
+  return &matTmp;
+}
+
 void GeometryTGeo::Build(int loadTrans)
 {
   if (isBuilt()) {
@@ -66,11 +232,58 @@ void GeometryTGeo::Build(int loadTrans)
     LOGP(fatal, "Geometry is not loaded");
   }
 
+  auto& iotofPars = IOTOFBaseParam::Instance();
+  if (!iotofPars.segmentedInnerTOF && !iotofPars.segmentedOuterTOF) {
+    return;
+  }
+
+  // Inner/outer TOF
+  for (int j{0}; j < 2; ++j) {
+    mNumberOfStavesIOTOF[j] = extractNumberOfStavesIOTOF(j);
+    mNumberOfModulesIOTOF[j] = extractNumberOfModulesIOTOF(j);
+    mNumberOfChipsPerModuleIOTOF[j] = extractNumberOfChipsPerModuleIOTOF(j);
+  }
+
+  // Forward TOF
+  mNumberOfChipsFTOF = extractNumberOfChipsFTOF();
+
+  // Backward TOF
+  mNumberOfChipsBTOF = extractNumberOfChipsBTOF();
+
+  int numberOfChips{0};
+  for (int j{0}; j < 2; ++j) {
+    mNumberOfChipsPerStaveIOTOF[j] = mNumberOfModulesIOTOF[j] * mNumberOfChipsPerModuleIOTOF[j];
+    mNumberOfChipsIOTOF[j] = mNumberOfStavesIOTOF[j] * mNumberOfChipsPerStaveIOTOF[j];
+    numberOfChips += mNumberOfChipsIOTOF[j];
+    mLastChipIndex[j] = numberOfChips - 1;
+  }
+
+  LOG(info) << "numberOfChipsITOF = " << mNumberOfChipsIOTOF[0] << ", numberOfChipsOTOF = " << mNumberOfChipsIOTOF[1] << ", numberOfChips = " << numberOfChips << ", mNumberOfChipesPerStaveITOF" << mNumberOfChipsPerStaveIOTOF[0];
+
+  setSize(numberOfChips);
   fillMatrixCache(loadTrans);
+  // fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
 }
 
 void GeometryTGeo::fillMatrixCache(int mask)
 {
+  if (mSize < 1) {
+    LOG(warning) << "The method Build was not called yet";
+    Build(mask);
+    return;
+  }
+
+  if ((mask & o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G)) && !getCacheL2G().isFilled()) {
+    // Matrices for Local (Sensor!!! rather than the full chip) to Global frame transformation
+    LOG(info) << "Loading " << getName() << " L2G matrices from TGeo; there are " << mSize << " matrices";
+    auto& cacheL2G = getCacheL2G();
+    cacheL2G.setSize(mSize);
+
+    for (int i = 0; i < mSize; i++) {
+      TGeoHMatrix* hm = extractMatrixSensor(i);
+      cacheL2G.setMatrix(o2::math_utils::Transform3D(*hm), i);
+    }
+  }
 }
 
 GeometryTGeo* GeometryTGeo::Instance()
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt b/Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt
index f3418d9065fcb..25d623c0047a9 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/CMakeLists.txt
@@ -14,6 +14,7 @@ o2_add_library(IOTOFSimulation
                        src/Detector.cxx
                        src/Digitizer.cxx
                       #  src/IOTOFServices.cxx
+                      src/Segmentation.cxx
                PUBLIC_LINK_LIBRARIES O2::IOTOFBase
                                      O2::DataFormatsIOTOF
                                      O2::ITSMFTSimulation)
@@ -21,5 +22,7 @@ o2_add_library(IOTOFSimulation
 o2_target_root_dictionary(IOTOFSimulation
                           HEADERS include/IOTOFSimulation/Detector.h
                                   include/IOTOFSimulation/Layer.h
-                                  include/IOTOFSimulation/Digitizer.h)
-                                  # include/IOTOFSimulation/IOTOFServices.h)
\ No newline at end of file
+                                  include/IOTOFSimulation/Digitizer.h
+                                  # include/IOTOFSimulation/IOTOFServices.h
+                                  include/IOTOFSimulation/Segmentation.h
+                          )
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h
index 8964e33f8a1b6..aae989248f07e 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Digitizer.h
@@ -27,6 +27,7 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "IOTOFBase/GeometryTGeo.h"
+#include "IOTOFSimulation/Segmentation.h"
 
 namespace o2::iotof
 {
@@ -105,6 +106,8 @@ class Digitizer
   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)
 };
 } // namespace o2::iotof
 
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Segmentation.h b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Segmentation.h
new file mode 100644
index 0000000000000..cd0ab55bd03d7
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/include/IOTOFSimulation/Segmentation.h
@@ -0,0 +1,215 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Segmentation.h
+/// \brief Definition of the Segmentation class
+/// \author Giorgio Alberto Lucia: giorgio.alberto.lucia@cern.ch
+
+#ifndef ALICEO2_IOTOF_SEGMENTATION_H
+#define ALICEO2_IOTOF_SEGMENTATION_H
+
+#include <Rtypes.h>
+#include <memory>
+#include "MathUtils/Cartesian.h"
+#include "IOTOFBase/IOTOFBaseParam.h"
+
+namespace o2
+{
+namespace iotof
+{
+
+/// Segmentation and response for pixels in inner and outer TOF of the ALICE 3 apparatus
+/// Questions to solve:
+class Segmentation
+{
+ private:
+  Segmentation();
+  static std::unique_ptr<o2::iotof::Segmentation> sInstance;
+
+ public:
+  ChipSpecifics mITofSpecsConfig;
+  ChipSpecifics mOTofSpecsConfig;
+  static Segmentation* Instance();
+
+  ~Segmentation() = default;
+
+  void configChip(const int nCols, const int nRows, const float pitchCol, const float pitchRow, const float passiveEdgeReadOut, const float passiveEdgeTop,
+                  const float passiveEdgeSide, const float sensorLayerThicknessEff, const float sensorLayerThickness, const int subDetectorID);
+  void configChip(const ChipSpecifics& specsConfig, const int subDetectorID);
+
+  /// Transformation from Geant detector centered local coordinates (cm) to
+  /// Pixel cell numbers iRow and iCol.
+  /// Returns kTRUE if point x,z is inside sensitive volume, kFALSE otherwise.
+  /// A value of -1 for iRow or iCol indicates that this point is outside of the
+  /// detector segmentation as defined.
+  /// \param float x Detector local coordinate x in cm with respect to
+  /// the center of the sensitive volume.
+  /// \param float z Detector local coordinate z in cm with respect to
+  /// the center of the sensitive volulme.
+  /// \param int iRow Detector x cell coordinate. Has the range 0 <= iRow < mNumberOfRows
+  /// \param int iCol Detector z cell coordinate. Has the range 0 <= iCol < mNumberOfColumns
+  bool localToDetector(float x, float z, int& iRow, int& iCol, const int subDetectorID);
+  /// same but w/o check for row/column range
+  void localToDetectorUnchecked(float xRow, float zCol, int& iRow, int& iCol, const int subDetectorID);
+
+  /// Transformation from Detector cell coordiantes to Geant detector centered
+  /// local coordinates (cm)
+  /// \param int iRow Detector x cell coordinate. Has the range 0 <= iRow < mNumberOfRows
+  /// \param int iCol Detector z cell coordinate. Has the range 0 <= iCol < mNumberOfColumns
+  /// \param float x Detector local coordinate x in cm with respect to the
+  /// center of the sensitive volume.
+  /// \param float z Detector local coordinate z in cm with respect to the
+  /// center of the sensitive volulme.
+  /// If iRow and or iCol is outside of the segmentation range a value of -0.5*Dx()
+  /// or -0.5*Dz() is returned.
+
+  // w/o check for row/col range
+  template <typename T = float, typename L = float>
+  void detectorToLocalUnchecked(L row, L col, T& xRow, T& zCol, const int subDetectorID)
+  {
+    if (subDetectorID != 0 && subDetectorID != 1) {
+      row = col = -1;
+      return;
+    }
+    const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+    xRow = getFirstRowCoordinate(subDetectorID) - row * specsConfig.PitchRow;
+    zCol = col * specsConfig.PitchCol + getFirstColCoordinate(subDetectorID);
+  }
+  template <typename T = float, typename L = float>
+  void detectorToLocalUnchecked(L row, L col, math_utils::Point3D<T>& loc, const int subDetectorID)
+  {
+    if (subDetectorID != 0 && subDetectorID != 1) {
+      row = col = -1;
+      return;
+    }
+    const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+    loc.SetCoordinates(getFirstRowCoordinate(subDetectorID) - row * specsConfig.PitchRow, T(0.), col * specsConfig.PitchCol + getFirstColCoordinate(subDetectorID));
+  }
+  template <typename T = float, typename L = float>
+  void detectorToLocalUnchecked(L row, L col, std::array<T, 3>& loc, const int subDetectorID)
+  {
+    if (subDetectorID != 0 && subDetectorID != 1) {
+      row = col = -1;
+      return;
+    }
+    const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+    loc[0] = getFirstRowCoordinate(subDetectorID) - row * specsConfig.PitchRow;
+    loc[1] = T(0);
+    loc[2] = col * specsConfig.PitchCol + getFirstColCoordinate(subDetectorID);
+  }
+
+  // same but with check for row/col range
+
+  template <typename T = float, typename L = float>
+  bool detectorToLocal(L row, L col, T& xRow, T& zCol, const int subDetectorID)
+  {
+    if (subDetectorID != 0 && subDetectorID != 1) {
+      row = col = -1;
+      return false;
+    }
+    const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+    if (row < 0 || row >= specsConfig.NRows || col < 0 || col >= specsConfig.NCols) {
+      return false;
+    }
+    detectorToLocalUnchecked(row, col, xRow, zCol, subDetectorID);
+    return true;
+  }
+
+  template <typename T = float, typename L = float>
+  bool detectorToLocal(L row, L col, math_utils::Point3D<T>& loc, const int subDetectorID)
+  {
+    if (subDetectorID != 0 && subDetectorID != 1) {
+      row = col = -1;
+      return false;
+    }
+    const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+    if (row < 0 || row >= specsConfig.NRows || col < 0 || col >= specsConfig.NCols) {
+      return false;
+    }
+    detectorToLocalUnchecked(row, col, loc, subDetectorID);
+    return true;
+  }
+  template <typename T = float, typename L = float>
+  bool detectorToLocal(L row, L col, std::array<T, 3>& loc, const int subDetectorID)
+  {
+    if (subDetectorID != 0 && subDetectorID != 1) {
+      row = col = -1;
+      return false;
+    }
+    const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+    if (row < 0 || row >= specsConfig.NRows || col < 0 || col >= specsConfig.NCols) {
+      return false;
+    }
+    detectorToLocalUnchecked(row, col, loc, subDetectorID);
+    return true;
+  }
+
+  float getFirstRowCoordinate(const int subDetectorID)
+  {
+    const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+    return 0.5 * ((specsConfig.ActiveMatrixSizeRows() - specsConfig.PassiveEdgeTop + specsConfig.PassiveEdgeReadOut) - specsConfig.PitchRow);
+  }
+  float getFirstColCoordinate(const int subDetectorID)
+  {
+    const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+    return 0.5 * (specsConfig.PitchCol - specsConfig.ActiveMatrixSizeCols());
+  }
+
+  void print();
+
+  ClassDefNV(Segmentation, 1); // Segmentation class upgrade pixels
+};
+
+//_________________________________________________________________________________________________
+inline void Segmentation::localToDetectorUnchecked(float xRow, float zCol, int& iRow, int& iCol, const int subDetectorID)
+{
+  // convert to row/col w/o over/underflow check
+  if (subDetectorID != 0 && subDetectorID != 1) {
+    iRow = iCol = -1;
+    return;
+  }
+  const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+  xRow = 0.5 * (specsConfig.ActiveMatrixSizeRows() - specsConfig.PassiveEdgeTop + specsConfig.PassiveEdgeReadOut) - xRow; // coordinate wrt top edge of Active matrix
+  zCol += 0.5 * specsConfig.ActiveMatrixSizeCols();                                                                       // coordinate wrt left edge of Active matrix
+  iRow = int(xRow / specsConfig.PitchRow);
+  iCol = int(zCol / specsConfig.PitchCol);
+  if (xRow < 0) {
+    iRow -= 1;
+  }
+  if (zCol < 0) {
+    iCol -= 1;
+  }
+}
+
+//_________________________________________________________________________________________________
+inline bool Segmentation::localToDetector(float xRow, float zCol, int& iRow, int& iCol, const int subDetectorID)
+{
+  // convert to row/col
+  if (subDetectorID != 0 && subDetectorID != 1) {
+    iRow = iCol = -1;
+    return false;
+  }
+  const ChipSpecifics& specsConfig = (subDetectorID == 0) ? mITofSpecsConfig : mOTofSpecsConfig;
+  xRow = 0.5 * (specsConfig.ActiveMatrixSizeRows() - specsConfig.PassiveEdgeTop + specsConfig.PassiveEdgeReadOut) - xRow; // coordinate wrt top edge of Active matrix
+  zCol += 0.5 * specsConfig.ActiveMatrixSizeCols();                                                                       // coordinate wrt left edge of Active matrix
+  if (xRow < 0 || xRow >= specsConfig.ActiveMatrixSizeRows() || zCol < 0 || zCol >= specsConfig.ActiveMatrixSizeCols()) {
+    iRow = iCol = -1;
+    return false;
+  }
+  iRow = int(xRow / specsConfig.PitchRow);
+  iCol = int(zCol / specsConfig.PitchCol);
+  return true;
+}
+
+} // namespace iotof
+} // namespace o2
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index 59b914a3dd076..bed8cbfd6dfac 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -314,13 +314,29 @@ bool Detector::ProcessHits(FairVolume* vol)
     TLorentzVector positionStop;
     fMC->TrackPosition(positionStop);
     // Retrieve the indices with the volume path
-    int stave(0), halfstave(0), chipinmodule(0), module;
+    int stave(0), chipinmodule(0), module(0);
     fMC->CurrentVolOffID(1, chipinmodule);
     fMC->CurrentVolOffID(2, module);
-    fMC->CurrentVolOffID(3, halfstave);
-    fMC->CurrentVolOffID(4, stave);
+    fMC->CurrentVolOffID(3, stave);
 
-    o2::itsmft::Hit* p = addHit(stack->GetCurrentTrackNumber(), lay, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
+    int sensorID = lay;
+    auto& iotofPars = IOTOFBaseParam::Instance();
+
+    int layN = -1;
+    if (strstr(vol->GetName(), GeometryTGeo::getITOFSensorPattern()) != nullptr) {
+      layN = 0;
+    } else if (strstr(vol->GetName(), GeometryTGeo::getOTOFSensorPattern())) {
+      layN = 1;
+    }
+    if (iotofPars.segmentedInnerTOF && iotofPars.segmentedOuterTOF) {
+      if (layN > -1) {
+        sensorID = mGeometryTGeo->getIOTOFChipIndex(layN, stave, module, chipinmodule);
+      } else {
+        sensorID += (mGeometryTGeo->getSize() - 1); // temporary as f/b tof is not yet segmented
+      }
+    }
+
+    o2::itsmft::Hit* p = addHit(stack->GetCurrentTrackNumber(), sensorID, mTrackData.mPositionStart.Vect(), positionStop.Vect(),
                                 mTrackData.mMomentumStart.Vect(), mTrackData.mMomentumStart.E(), positionStop.T(),
                                 mTrackData.mEnergyLoss, mTrackData.mTrkStatusStart, status);
 
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx
index b865d6958ecfd..8e5e74dd1f0ca 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Digitizer.cxx
@@ -29,6 +29,8 @@
 namespace o2::iotof
 {
 
+o2::iotof::Segmentation* Digitizer::sSegmentation = nullptr;
+
 //_______________________________________________________________________
 void Digitizer::init()
 {
@@ -37,6 +39,7 @@ void Digitizer::init()
   LOG(info) << "  Charge threshold: " << mChargeThreshold << " electrons";
   LOG(info) << "  Detection efficiency: " << mEfficiency * 100 << " %";
   LOG(info) << "  Continuous mode: " << (mContinuous ? "ON" : "OFF");
+  sSegmentation = o2::iotof::Segmentation::Instance();
 }
 
 //_______________________________________________________________________
@@ -102,12 +105,27 @@ void Digitizer::processHit(const o2::itsmft::Hit& hit, int evID, int srcID)
   // For now, use simple row/col mapping from detector ID
   // TODO: Implement proper segmentation when geometry is finalized
   uint16_t chipIndex = static_cast<uint16_t>(detID);
-  uint16_t row = 0; // Will be determined from hit position
-  uint16_t col = 0; // Will be determined from hit position
+
+  if (detID > mGeometry->getSize() || mGeometry->getSize() < 1) {
+    LOG(debug) << "Invalid detector ID: " << detID;
+    return; // invalid detector ID
+  }
+  const auto& matrix = mGeometry->getMatrixL2G(hit.GetDetectorID());
+
+  math_utils::Vector3D<float> xyzPositionStart(matrix ^ (hit.GetPosStart())); // start position in sensor frame
+  // math_utils::Vector3D<float> xyzPositionEnd(matrix ^ (hit.GetPos()));      // end position in sensor frame
+
+  int row = 0; // Will be determined from start hit position
+  int col = 0; // Will be determined from start hit position
+
+  if (!sSegmentation->localToDetector(xyzPositionStart.X(), xyzPositionStart.Z(), row, col, mGeometry->getIOTOFLayer(detID))) {
+    LOG(debug) << "Hit position out of bounds for detector ID " << detID;
+    return; // hit is outside the active area
+  }
 
   // Create the digit with time information
   int digID = mDigits->size();
-  mDigits->emplace_back(chipIndex, row, col, charge, smearedTime);
+  mDigits->emplace_back(chipIndex, static_cast<uint16_t>(row), static_cast<uint16_t>(col), charge, smearedTime);
 
   LOG(debug) << "Created digit #" << digID << " chip=" << chipIndex
              << " charge=" << charge << " time=" << smearedTime << " ns";
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index b603d2a4a423b..4f76d71b63aa3 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -197,8 +197,8 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       setChipStyle(chipVol);
 
       // Finally we create the volume of the sensor, which is the same for all chips
-      const int sensorsPerChipX = 2;                          // we assume that each chip is divided in 2 sensors along the x direction
-      const int sensorsPerChipZ = 2;                          // we assume that each chip is divided in 2 sensors along the z direction
+      const int sensorsPerChipX = 1;                          // we assume that each chip is divided in 2 sensors along the x direction
+      const int sensorsPerChipZ = 1;                          // we assume that each chip is divided in 2 sensors along the z direction
       const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
       const double sensorSizeY = mSensorThickness;            // cm
       const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
@@ -331,8 +331,8 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
       setChipStyle(chipVol);
 
       // Finally we create the volume of the sensor, which is the same for all chips
-      const int sensorsPerChipX = 2;                          // we assume that each chip is divided in 2 sensors along the x direction
-      const int sensorsPerChipZ = 2;                          // we assume that each chip is divided in 2 sensors along the z direction
+      const int sensorsPerChipX = 1;                          // we assume that each chip is divided in 2 sensors along the x direction
+      const int sensorsPerChipZ = 1;                          // we assume that each chip is divided in 2 sensors along the z direction
       const double sensorSizeX = chipSizeX / sensorsPerChipX; // cm
       const double sensorSizeY = mSensorThickness;            // cm
       const double sensorSizeZ = chipSizeZ / sensorsPerChipZ; // cm
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Segmentation.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Segmentation.cxx
new file mode 100644
index 0000000000000..bbfb60234210d
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Segmentation.cxx
@@ -0,0 +1,90 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file Segmentation.cxx
+/// \brief Implementation of the Segmentation class
+
+#include "IOTOFSimulation/Segmentation.h"
+#include "IOTOFBase/IOTOFBaseParam.h"
+#include <cstdio>
+
+namespace o2
+{
+
+namespace iotof
+{
+
+std::unique_ptr<o2::iotof::Segmentation> Segmentation::sInstance;
+
+Segmentation* Segmentation::Instance()
+{
+  if (!sInstance) {
+    sInstance = std::unique_ptr<Segmentation>(new Segmentation());
+  }
+  return sInstance.get();
+}
+
+Segmentation::Segmentation()
+{
+  if (sInstance) {
+    printf("Invalid use of public constructor: o2::iotof::Segmentation instance exists\n");
+  } else {
+    auto& iotofPars = IOTOFBaseParam::Instance();
+    const ChipSpecifics& mITofChipPars = iotofPars.iTofChipSpecifics;
+    const ChipSpecifics& mOTofChipPars = iotofPars.oTofChipSpecifics;
+
+    configChip(mITofChipPars, 0 /* subDetectorID for iTOF */);
+    configChip(mOTofChipPars, 1 /* subDetectorID for oTOF */);
+  }
+}
+
+void Segmentation::configChip(const int nCols, const int nRows, const float pitchCol, const float pitchRow, const float passiveEdgeReadOut,
+                              const float passiveEdgeTop, const float passiveEdgeSide, const float sensorLayerThicknessEff, const float sensorLayerThickness, const int subDetectorID)
+{
+  if (subDetectorID == 0) {
+    mITofSpecsConfig = ChipSpecifics(nCols, nRows, pitchCol, pitchRow, passiveEdgeReadOut, passiveEdgeTop, passiveEdgeSide, sensorLayerThicknessEff, sensorLayerThickness);
+  } else if (subDetectorID == 1) {
+    mOTofSpecsConfig = ChipSpecifics(nCols, nRows, pitchCol, pitchRow, passiveEdgeReadOut, passiveEdgeTop, passiveEdgeSide, sensorLayerThicknessEff, sensorLayerThickness);
+  } else {
+    printf("Invalid subDetectorID %d. Must be 0 (iTOF) or 1 (oTOF). No configuration applied.\n", subDetectorID);
+  }
+}
+
+void Segmentation::configChip(const ChipSpecifics& specsConfig, const int subDetectorID)
+{
+  if (subDetectorID == 0) {
+    mITofSpecsConfig = specsConfig;
+  } else if (subDetectorID == 1) {
+    mOTofSpecsConfig = specsConfig;
+  } else {
+    printf("Invalid subDetectorID %d. Must be 0 (iTOF) or 1 (oTOF). No configuration applied.\n", subDetectorID);
+  }
+}
+
+void Segmentation::print()
+{
+  // iTOF specs
+  printf("iTOF specs:\n");
+  printf("Pixel size: %.2f (along %d rows) %.2f (along %d columns) microns\n", mITofSpecsConfig.PitchRow * 1e4, mITofSpecsConfig.NRows, mITofSpecsConfig.PitchCol * 1e4, mITofSpecsConfig.NCols);
+  printf("Passive edges: bottom: %.2f, top: %.2f, left/right: %.2f microns\n", mITofSpecsConfig.PassiveEdgeReadOut * 1e4, mITofSpecsConfig.PassiveEdgeTop * 1e4, mITofSpecsConfig.PassiveEdgeSide * 1e4);
+  printf("Active/Total size: %.6f/%.6f (rows) %.6f/%.6f (cols) cm\n", mITofSpecsConfig.ActiveMatrixSizeRows(), mITofSpecsConfig.SensorSizeRows(), mITofSpecsConfig.ActiveMatrixSizeCols(), mITofSpecsConfig.SensorSizeCols());
+
+  // oTOF specs
+  printf("oTOF specs:\n");
+  printf("Pixel size: %.2f (along %d rows) %.2f (along %d columns) microns\n", mOTofSpecsConfig.PitchRow * 1e4, mOTofSpecsConfig.NRows, mOTofSpecsConfig.PitchCol * 1e4, mOTofSpecsConfig.NCols);
+  printf("Passive edges: bottom: %.2f, top: %.2f, left/right: %.2f microns\n", mOTofSpecsConfig.PassiveEdgeReadOut * 1e4, mOTofSpecsConfig.PassiveEdgeTop * 1e4, mOTofSpecsConfig.PassiveEdgeSide * 1e4);
+  printf("Active/Total size: %.6f/%.6f (rows) %.6f/%.6f (cols) cm\n", mOTofSpecsConfig.ActiveMatrixSizeRows(), mOTofSpecsConfig.SensorSizeRows(), mOTofSpecsConfig.ActiveMatrixSizeCols(), mOTofSpecsConfig.SensorSizeCols());
+}
+
+} // namespace iotof
+} // namespace o2
+
+ClassImp(o2::iotof::Segmentation);

From 0a6ade3635e0d7ed0cc69e79ca6f25de3737c549 Mon Sep 17 00:00:00 2001
From: SCHOTTER Romain <47983209+romainschotter@users.noreply.github.com>
Date: Tue, 5 May 2026 15:00:41 +0200
Subject: [PATCH 1710/1764] Add new particles to O2DatabasePDG

---
 .../SimulationDataFormat/O2DatabasePDG.h      | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h b/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
index 23dc30119aa7a..ef259e5322bb8 100644
--- a/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
+++ b/DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h
@@ -524,6 +524,48 @@ inline void O2DatabasePDG::addALICEParticles(TDatabasePDG* db)
     db->AddParticle("f2_1525", "f2_1525", 1.525, kFALSE, 0.073, 0, "Resonance", ionCode);
   }
 
+  // when using hadronic rescattering in Pythia8
+  ionCode = 9000221;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("f0_500", "f0_500", 0.500, kFALSE, 0.350, 0.0, "Resonance", ionCode);
+  }
+  ionCode = -100313;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("K*(1410)bar0", "K*(1410)bar0", 1.414, kFALSE, 0.232, 0, "Resonance", ionCode);
+  }
+  ionCode = 100313;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("K*(1410)0", "K*(1410)0", 1.414, kFALSE, 0.232, 0, "Resonance", ionCode);
+  }
+  ionCode = 100323;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("K*(1410)+", "K*(1410)+", 1.414, kFALSE, 0.232, +1, "Resonance", ionCode);
+  }
+  ionCode = -100323;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("K*(1410)-", "K*(1410)-", 1.414, kFALSE, 0.232, -1, "Resonance", ionCode);
+  }
+  ionCode = 100211;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("pi(1300)+", "pi(1300)+", 1.165, kFALSE, 0.400, +1, "Resonance", ionCode);
+  }
+  ionCode = -100211;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("pi(1300)-", "pi(1300)-", 1.165, kFALSE, 0.400, -1, "Resonance", ionCode);
+  }
+  ionCode = 202112;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("n(1440)0", "n(1440)0", 1.358, kFALSE, 0.350, 0, "Ion", ionCode);
+  }
+  ionCode = -202212;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("p(1440)bar-", "p(1440)bar-", 1.793, kFALSE, 0.350, -1, "Ion", ionCode);
+  }
+  ionCode = 202212;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("p(1440)+", "p(1440)+", 1.793, kFALSE, 0.350, 1, "Ion", ionCode);
+  }
+
   // Xi-/+ (1820)
   ionCode = 123314;
   if (!db->GetParticle(ionCode)) {

From bbe74d692d24b35672572a9e58004e47d3242867 Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 7 May 2026 11:58:26 +0200
Subject: [PATCH 1711/1764] ITSMFT: replace input filter of decoder  with
 DataSpecUtils::dataDescriptorMatcherFrom

---
 .../ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx     | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx b/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
index 7158551e02e20..df397b9323408 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
@@ -237,10 +237,7 @@ void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
   auto datadesc = (mUserDataDescription == o2::header::gDataDescriptionInvalid) ? o2::header::gDataDescriptionRawData : mUserDataDescription;
   if (mUserDataDescription != o2::header::gDataDescriptionInvalid) { // overwrite data filter origin&descriptions with user defined ones if possible
     for (auto& filt : mInputFilter) {
-      if (std::holds_alternative<o2::framework::ConcreteDataMatcher>(filt.matcher)) {
-        std::get<o2::framework::ConcreteDataMatcher>(filt.matcher).origin = origin;
-        std::get<o2::framework::ConcreteDataMatcher>(filt.matcher).description = datadesc;
-      }
+      filt.matcher = o2::framework::DataSpecUtils::dataDescriptorMatcherFrom(ConcreteDataTypeMatcher(origin, datadesc));
     }
   }
 

From 953df52b99c581ca1a81d82b633c6dd632c48eee Mon Sep 17 00:00:00 2001
From: Ernst Hellbar <ernst.hellbar@cern.ch>
Date: Thu, 7 May 2026 11:58:27 +0200
Subject: [PATCH 1712/1764] ITSMFT: simplify setting of input filter of the
 decoder

---
 .../reconstruction/src/RawPixelDecoder.cxx    |  6 -----
 .../common/workflow/src/STFDecoderSpec.cxx    | 22 +++++++++----------
 2 files changed, 11 insertions(+), 17 deletions(-)

diff --git a/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx b/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
index df397b9323408..df877cd38c578 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/RawPixelDecoder.cxx
@@ -235,12 +235,6 @@ void RawPixelDecoder<Mapping>::setupLinks(InputRecord& inputs)
   auto nLinks = mGBTLinks.size();
   auto origin = (mUserDataOrigin == o2::header::gDataOriginInvalid) ? mMAP.getOrigin() : mUserDataOrigin;
   auto datadesc = (mUserDataDescription == o2::header::gDataDescriptionInvalid) ? o2::header::gDataDescriptionRawData : mUserDataDescription;
-  if (mUserDataDescription != o2::header::gDataDescriptionInvalid) { // overwrite data filter origin&descriptions with user defined ones if possible
-    for (auto& filt : mInputFilter) {
-      filt.matcher = o2::framework::DataSpecUtils::dataDescriptorMatcherFrom(ConcreteDataTypeMatcher(origin, datadesc));
-    }
-  }
-
   // if we see requested data type input with 0xDEADBEEF subspec and 0 payload this means that the "delayed message"
   // mechanism created it in absence of real data from upstream. Processor should send empty output to not block the workflow
   {
diff --git a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
index 8fb6ba4e6aa97..3cc88752d290c 100644
--- a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
@@ -72,11 +72,22 @@ void STFDecoder<Mapping>::init(InitContext& ic)
     header::DataDescription dataDesc;
     dataOrig.runtimeInit(v1[0].c_str());
     dataDesc.runtimeInit(v2[0].c_str());
+    Mapping map;
     for (int iLayer{0}; iLayer < mLayers; ++iLayer) {
       auto& dec = mDecoder.emplace_back(std::make_unique<RawPixelDecoder<Mapping>>());
       dec->setUserDataOrigin(dataOrig);
       dec->setUserDataDescription(dataDesc);
       dec->init(); // is this no-op?
+
+      if (mDoStaggering) {
+        std::vector<o2::framework::InputSpec> filter;
+        for (const auto feeID : map.getLayer2FEEIDs(iLayer)) {
+          filter.emplace_back("filter", ConcreteDataMatcher{dataOrig, dataDesc, (o2::header::DataHeader::SubSpecificationType)feeID});
+        }
+        dec->setInputFilter(filter);
+      } else {
+        dec->setInputFilter({InputSpec{"filter", ConcreteDataTypeMatcher(dataOrig, dataDesc)}});
+      }
     }
   } catch (const std::exception& e) {
     LOG(error) << "exception was thrown in decoder creation: " << e.what();
@@ -131,17 +142,6 @@ void STFDecoder<Mapping>::init(InitContext& ic)
     mClusterer = std::make_unique<Clusterer>();
     mClusterer->setNChips(Mapping::getNChips());
   }
-
-  if (mDoStaggering) {
-    Mapping map;
-    for (uint32_t iLayer{0}; iLayer < mLayers; ++iLayer) {
-      std::vector<o2::framework::InputSpec> filter;
-      for (const auto feeID : map.getLayer2FEEIDs(iLayer)) {
-        filter.emplace_back("filter", ConcreteDataMatcher{Mapping::getOrigin(), o2::header::gDataDescriptionRawData, (o2::header::DataHeader::SubSpecificationType)feeID});
-      }
-      mDecoder[iLayer]->setInputFilter(filter);
-    }
-  }
 }
 
 ///_______________________________________

From 285dbb7fbe74a3117c114f6499a7a0b2fe5a7750 Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Fri, 8 May 2026 21:07:55 +0200
Subject: [PATCH 1713/1764] move OT barrel service disks closer to stave
 'edges' (to 135 cm), change rMax from 68 to 80 cm (#15384)

Co-authored-by: Igor Altsybeev <Igor.Altsybeev@cern.ch>
---
 .../ALICE3/TRK/simulation/src/TRKServices.cxx | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index be88412186533..01a945ee7a753 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -881,35 +881,35 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
     // TODO: add cables/connections at ends of OT barrels
     // Set rMin, rMax and dZ
 
-    double rMin = 45.0;
-    double rMax = rMinOuterServices;
-    double zCur = 145.0;
-    double dZ = siO2FiberAreaB / (4 * 3.14 * rMax);
-    TGeoTube* outerBarrelFiberSIO2 = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_SIO2sh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    double rMinOTbarrelServices = 45.0; // cm, radius of first OT layer
+    double rMaxOTbarrelServices = 80;   // cm, radius of last OT layer
+    double zCur = 135.0;                // cm, approximate position of OT services in z
+    double dZ = siO2FiberAreaB / (4 * 3.14 * rMaxOTbarrelServices);
+    TGeoTube* outerBarrelFiberSIO2 = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_SIO2sh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelFiberSIO2Volume = new TGeoVolume(Form("TRK_OUTERBARREL_FIBER_SIO2_%s", orLabel.c_str()), outerBarrelFiberSIO2, medSiO2);
     outerBarrelFiberSIO2Volume->SetLineColor(kGray);
     auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelFiberSIO2Volume, 1, combiTrans);
 
     zCur += 2 * dZ;
-    dZ = peFiberAreaB / (4 * 3.14 * rMax);
-    TGeoTube* outerBarrelFiberPE = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_PEsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    dZ = peFiberAreaB / (4 * 3.14 * rMaxOTbarrelServices);
+    TGeoTube* outerBarrelFiberPE = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_PEsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelFiberPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_FIBER_PE_%s", orLabel.c_str()), outerBarrelFiberPE, medPE);
     outerBarrelFiberPEVolume->SetLineColor(kGray);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelFiberPEVolume, 1, combiTrans);
 
     zCur += 2 * dZ;
-    dZ = cuPowerAreaB / (4 * 3.14 * rMax);
-    TGeoTube* outerBarrelPowerCu = new TGeoTube(Form("TRK_OUTERBARREL_POWER_CUsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    dZ = cuPowerAreaB / (4 * 3.14 * rMaxOTbarrelServices);
+    TGeoTube* outerBarrelPowerCu = new TGeoTube(Form("TRK_OUTERBARREL_POWER_CUsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelPowerCuVolume = new TGeoVolume(Form("TRK_OUTERBARREL_POWER_CU_%s", orLabel.c_str()), outerBarrelPowerCu, medCu);
-    outerBarrelFiberSIO2Volume->SetLineColor(kGray);
+    outerBarrelPowerCuVolume->SetLineColor(kGray);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelPowerCuVolume, 1, combiTrans);
 
     zCur += 2 * dZ;
-    dZ = pePowerAreaB / (4 * 3.14 * rMax);
-    TGeoTube* outerBarrelPowerPE = new TGeoTube(Form("TRK_OUTERBARREL_POWER_PEsh_%s", orLabel.c_str()), rMin, rMax, dZ);
+    dZ = pePowerAreaB / (4 * 3.14 * rMaxOTbarrelServices);
+    TGeoTube* outerBarrelPowerPE = new TGeoTube(Form("TRK_OUTERBARREL_POWER_PEsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelPowerPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_POWER_PE_%s", orLabel.c_str()), outerBarrelPowerPE, medPE);
     outerBarrelPowerPEVolume->SetLineColor(kGray);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);

From a4e6201f85b53ac446c4ebbf5431e5aa49e11c68 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 17 Apr 2026 07:50:09 +0200
Subject: [PATCH 1714/1764] ITSMFT: remove redirect header

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../common/base/include/ITSMFTBase/DPLAlpideParam.h | 13 -------------
 1 file changed, 13 deletions(-)
 delete mode 100644 Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h

diff --git a/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h b/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h
deleted file mode 100644
index e217808c06177..0000000000000
--- a/Detectors/ITSMFT/common/base/include/ITSMFTBase/DPLAlpideParam.h
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-// FIXME: temporary shim to no not break O2Physics
-#include "DataFormatsITSMFT/DPLAlpideParam.h"

From d03d586b0e8455a58fbcf6ca140d95d583878542 Mon Sep 17 00:00:00 2001
From: Anton Alkin <anton.alkin@cern.ch>
Date: Fri, 8 May 2026 11:34:54 +0200
Subject: [PATCH 1715/1764] DPL: ensure dummy sink is added with correct rate
 limiting configuration

* If there is a TFN/TFF source, sink has to catch these messages to be
  at the topology end
* If the TFN/TFF source is aod-producer, the rate limiting config should
  be with out-of-band channel instead of scheduler
---
 Framework/Core/src/WorkflowHelpers.cxx | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/Framework/Core/src/WorkflowHelpers.cxx b/Framework/Core/src/WorkflowHelpers.cxx
index 5f1c1eaee5544..9b80ef14d7621 100644
--- a/Framework/Core/src/WorkflowHelpers.cxx
+++ b/Framework/Core/src/WorkflowHelpers.cxx
@@ -627,12 +627,15 @@ void WorkflowHelpers::injectServiceDevices(WorkflowSpec& workflow, ConfigContext
     // Use the new dummy sink when the AOD reader is there
     O2_SIGNPOST_ID_GENERATE(sid, workflow_helpers);
     if (tfnsource != workflow.end()) {
-      O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting scheduled dummy sink");
-      // if there is a tfnsource, make sure the sink gets TFN/TFF
       DataSpecUtils::updateInputList(ignored, InputSpec{"tfn", "TFN", "TFNumber", 0, Lifetime::Sporadic});
       DataSpecUtils::updateInputList(ignored, InputSpec{"tff", "TFF", "TFFilename", 0, Lifetime::Sporadic});
+    }
+
+    if (tfnsource != workflow.end() && !tfnsource->name.starts_with("aod-producer-workflow")) { // any tfnsource except the aod-producer should use scheduled sink
+      O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting scheduled dummy sink");
+      // if there is a tfnsource, make sure the sink gets TFN/TFF
       extraSpecs.push_back(CommonDataProcessors::getScheduledDummySink(ignored));
-    } else {
+    } else { // if there is no tfn source or if that source is aod-producer-workflow, out-of-band channel is used to propagate the number of consumed timeframes
       O2_SIGNPOST_EVENT_EMIT(workflow_helpers, sid, "injectServiceDevices", "Injecting rate limited dummy sink");
       std::string rateLimitingChannelConfigOutput;
       if (rateLimitingIPCID != -1) {

From 810e8f1a486643e0d07bb0ad177b8313bfc99141 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Thu, 30 Apr 2026 22:15:06 +0200
Subject: [PATCH 1716/1764] Common: add count trailing zeros Ctz

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 GPU/Common/GPUCommonMath.h | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/GPU/Common/GPUCommonMath.h b/GPU/Common/GPUCommonMath.h
index 0ff31899dec0c..8f81762d87373 100644
--- a/GPU/Common/GPUCommonMath.h
+++ b/GPU/Common/GPUCommonMath.h
@@ -108,6 +108,7 @@ class GPUCommonMath
   GPUd() constexpr static float QuietNaN() { return GPUCA_CHOICE(std::numeric_limits<float>::quiet_NaN(), __builtin_nanf(""), nan(0u)); }
 #endif
   GPUd() constexpr static uint32_t Clz(uint32_t val);
+  GPUd() constexpr static uint32_t Ctz(uint32_t val);
   GPUd() constexpr static uint32_t Popcount(uint32_t val);
 
   GPUd() static void memcpy(void* dst, const void* src, size_t size);
@@ -332,6 +333,20 @@ GPUdi() constexpr uint32_t GPUCommonMath::Clz(uint32_t x)
 #endif
 }
 
+GPUdi() constexpr uint32_t GPUCommonMath::Ctz(uint32_t x)
+{
+#if (defined(__GNUC__) || defined(__clang__) || defined(__CUDACC__) || defined(__HIPCC__))
+  return x == 0 ? 32 : GPUCA_CHOICE(__builtin_ctz(x), __ffs(x) - 1, __builtin_ctz(x));
+#else
+  for (uint32_t i = 0; i < 32; ++i) {
+    if (x & (1u << i)) {
+      return i;
+    }
+  }
+  return 32;
+#endif
+}
+
 GPUdi() constexpr uint32_t GPUCommonMath::Popcount(uint32_t x)
 {
 #if (defined(__GNUC__) || defined(__clang__) || defined(__CUDACC__) || defined(__HIPCC__)) && !defined(__OPENCL__) // TODO: remove OPENCL when reported SPIR-V bug is fixed

From 0c43b9e5a37c21adf97347d8a54c64742a35d05b Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 10 May 2026 00:04:23 +0200
Subject: [PATCH 1717/1764] DPL: schedule rescan when oldest possible timeframe
 updated (#15383)

---
 Framework/Core/src/CommonServices.cxx         | 56 +++++++++++++++++++
 .../Core/src/CompletionPolicyHelpers.cxx      |  2 +
 Framework/Core/src/DecongestionService.h      |  2 +
 3 files changed, 60 insertions(+)

diff --git a/Framework/Core/src/CommonServices.cxx b/Framework/Core/src/CommonServices.cxx
index 0f53f5a6be5a1..2cdd046dedc34 100644
--- a/Framework/Core/src/CommonServices.cxx
+++ b/Framework/Core/src/CommonServices.cxx
@@ -589,6 +589,46 @@ auto decongestionCallbackOrdered = [](AsyncTask& task, size_t id) -> void {
   }
 };
 
+// Callback for consumeWhenPastOldestPossibleTimeframe.
+// Runs in the async queue at the beginning of the next iteration,
+// after Retry slots unblocked by an oldestPossibleInput change have
+// been consumed and freed. Rescans all slots and forwards the
+// (now up-to-date) oldestPossibleOutput downstream.
+auto decongestionCallbackPastOldest = [](AsyncTask& task, size_t id) -> void {
+  auto& ref = task.user<DecongestionContext>().ref;
+
+  auto& decongestion = ref.get<DecongestionService>();
+  auto& timesliceIndex = ref.get<TimesliceIndex>();
+  auto& relayer = ref.get<DataRelayer>();
+  auto& proxy = ref.get<FairMQDeviceProxy>();
+  O2_SIGNPOST_ID_GENERATE(cid, async_queue);
+
+  timesliceIndex.rescan();
+  timesliceIndex.updateOldestPossibleOutput(decongestion.nextEnumerationTimesliceRewinded);
+  auto oldestPossibleOutput = relayer.getOldestPossibleOutput();
+
+  if (oldestPossibleOutput.timeslice.value <= decongestion.lastTimeslice) {
+    O2_SIGNPOST_EVENT_EMIT(async_queue, cid, "oldest_possible_timeslice",
+                           "consumeWhenPastOldestPossibleTimeframe: not forwarding already sent value %" PRIu64,
+                           (uint64_t)oldestPossibleOutput.timeslice.value);
+    return;
+  }
+  O2_SIGNPOST_EVENT_EMIT(async_queue, cid, "oldest_possible_timeslice",
+                         "consumeWhenPastOldestPossibleTimeframe: forwarding oldest possible timeslice %" PRIu64,
+                         (uint64_t)oldestPossibleOutput.timeslice.value);
+  DataProcessingHelpers::broadcastOldestPossibleTimeslice(ref, oldestPossibleOutput.timeslice.value);
+
+  for (int fi = 0; fi < proxy.getNumForwardChannels(); fi++) {
+    auto& info = proxy.getForwardChannelInfo(ChannelIndex{fi});
+    auto& state = proxy.getForwardChannelState(ChannelIndex{fi});
+    if (info.channelType != ChannelAccountingType::DPL) {
+      continue;
+    }
+    DataProcessingHelpers::sendOldestPossibleTimeframe(ref, info, state, oldestPossibleOutput.timeslice.value);
+  }
+  decongestion.lastTimeslice = oldestPossibleOutput.timeslice.value;
+};
+
 // Decongestion service
 // If we do not have any Timeframe input, it means we must be creating timeslices
 // in order and that we should propagate the oldest possible timeslice at the end
@@ -705,6 +745,22 @@ o2::framework::ServiceSpec
       timesliceIndex.updateOldestPossibleOutput(decongestion.nextEnumerationTimesliceRewinded);
       auto oldestPossibleOutput = relayer.getOldestPossibleOutput();
 
+      // When consumeWhenPastOldestPossibleTimeframe is active, we always
+      // schedule the callback even when oldestPossibleOutput has not changed
+      // yet. Retry slots held by this policy will be consumed after this
+      // domainInfoUpdated call (once getReadyToProcess re-checks them), and
+      // the callback — running in the next iteration — will recompute
+      // oldestPossibleOutput and forward the updated value downstream.
+      if (decongestion.consumeWhenPastOldestPossibleTimeframeActive) {
+        auto& queue = services.get<AsyncQueue>();
+        AsyncQueueHelpers::post(
+          queue, AsyncTask{.timeslice = TimesliceId{oldestPossibleTimeslice},
+                           .id = decongestion.oldestPossibleTimesliceTask,
+                           .debounce = -1,
+                           .callback = decongestionCallbackPastOldest}
+                   .user<DecongestionContext>({.ref = services, .oldestPossibleOutput = oldestPossibleOutput}));
+      }
+
       if (oldestPossibleOutput.timeslice.value == decongestion.lastTimeslice) {
         O2_SIGNPOST_EVENT_EMIT(data_processor_context, cid, "oldest_possible_timeslice", "Synchronous: Not sending already sent value: %" PRIu64, (uint64_t)oldestPossibleOutput.timeslice.value);
         return;
diff --git a/Framework/Core/src/CompletionPolicyHelpers.cxx b/Framework/Core/src/CompletionPolicyHelpers.cxx
index cc593ee7a2ed9..e5a91ae58f899 100644
--- a/Framework/Core/src/CompletionPolicyHelpers.cxx
+++ b/Framework/Core/src/CompletionPolicyHelpers.cxx
@@ -267,6 +267,8 @@ CompletionPolicy CompletionPolicyHelpers::consumeWhenAnyZeroCount(const char* na
 CompletionPolicy CompletionPolicyHelpers::consumeWhenPastOldestPossibleTimeframe(const char* name, CompletionPolicy::Matcher matcher)
 {
   auto callback = [](InputSpan const& inputs, std::vector<InputSpec> const&, ServiceRegistryRef& ref) -> CompletionPolicy::CompletionOp {
+    auto& decongestionService = ref.get<DecongestionService>();
+    decongestionService.consumeWhenPastOldestPossibleTimeframeActive = true;
     size_t currentTimeslice = -1;
     for (auto& input : inputs) {
       if (input.header == nullptr) {
diff --git a/Framework/Core/src/DecongestionService.h b/Framework/Core/src/DecongestionService.h
index 1a42d3577bc0a..fe7fce8d640db 100644
--- a/Framework/Core/src/DecongestionService.h
+++ b/Framework/Core/src/DecongestionService.h
@@ -33,6 +33,8 @@ struct DecongestionService {
   int64_t nextTimeslice = 0;
   /// Ordered completion policy is active.
   bool orderedCompletionPolicyActive = false;
+  /// consumeWhenPastOldestPossibleTimeframe completion policy is active.
+  bool consumeWhenPastOldestPossibleTimeframeActive = false;
   // Task to enqueue the oldest possible timeslice propagation
   // at the end of any processing chain.
   o2::framework::AsyncTaskId oldestPossibleTimesliceTask = {0};

From 4d1d2e1a38aa502fd8f62587399e83ab1060e2da Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <maximiliano.puccio@cern.ch>
Date: Tue, 5 May 2026 18:08:52 +0200
Subject: [PATCH 1718/1764] Vertexing: make material correction configurable

---
 Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h | 3 +++
 Detectors/Vertexing/src/PVertexer.cxx                      | 4 ++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h b/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
index cdf83603258cd..db8bff7d52ebe 100644
--- a/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
+++ b/Detectors/Vertexing/include/DetectorsVertexing/PVertexer.h
@@ -29,6 +29,7 @@
 #include "ReconstructionDataFormats/PrimaryVertex.h"
 #include "DetectorsVertexing/PVertexerHelpers.h"
 #include "DetectorsVertexing/PVertexerParams.h"
+#include "DetectorsBase/Propagator.h"
 #include "ReconstructionDataFormats/GlobalTrackID.h"
 #include "DataFormatsCalibration/MeanVertexObject.h"
 #include "DataFormatsITSMFT/DPLAlpideParam.h"
@@ -85,6 +86,7 @@ class PVertexer
   void setBunchFilling(const o2::BunchFilling& bf);
 
   void setBz(float bz) { mBz = bz; }
+  void setMatCorrType(o2::base::Propagator::MatCorrType type) { mMatCorr = type; }
   void setValidateWithIR(bool v) { mValidateWithIR = v; }
   bool getValidateWithIR() const { return mValidateWithIR; }
   void setTrackSources(GTrackID::mask_t s);
@@ -187,6 +189,7 @@ class PVertexer
   std::vector<TimeZCluster> mTimeZClusters; ///< set of time clusters
   float mITSROFrameLengthMUS = 0;           ///< ITS readout time span in \mus
   float mBz = 0.;                           ///< mag.field at beam line
+  o2::base::Propagator::MatCorrType mMatCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT; ///< material correction for propagation
   float mDBScanDeltaT = 0.;                 ///< deltaT cut for DBScan check
   float mDBSMaxZ2InvCorePoint = 0;          ///< inverse of max sigZ^2 of the track which can be core point in the DBScan
   bool mValidateWithIR = false;             ///< require vertex validation with InteractionCandidates (if available)
diff --git a/Detectors/Vertexing/src/PVertexer.cxx b/Detectors/Vertexing/src/PVertexer.cxx
index 10e504bba0772..c4b5dc5cfc14c 100644
--- a/Detectors/Vertexing/src/PVertexer.cxx
+++ b/Detectors/Vertexing/src/PVertexer.cxx
@@ -1218,7 +1218,7 @@ bool PVertexer::relateTrackToMeanVertex(o2::track::TrackParCov& trc, float vtxEr
     z = mMeanVertex.getZ();
   }
   mMeanVertex.setMeanXYVertexAtZ(mMeanVertexSeed, z);
-  if (!o2::base::Propagator::Instance()->propagateToDCA(mMeanVertex, trc, mBz, 2.0f, o2::base::Propagator::MatCorrType::USEMatCorrLUT, &dca, nullptr, 0, mPVParams->dcaTolerance)) {
+  if (!o2::base::Propagator::Instance()->propagateToDCA(mMeanVertex, trc, mBz, 2.0f, mMatCorr, &dca, nullptr, 0, mPVParams->dcaTolerance)) {
     return false;
   }
   return dca.getY() * dca.getY() / (dca.getSigmaY2() + vtxErr2) < mPVParams->pullIniCut;
@@ -1227,7 +1227,7 @@ bool PVertexer::relateTrackToMeanVertex(o2::track::TrackParCov& trc, float vtxEr
 //______________________________________________
 bool PVertexer::relateTrackToVertex(o2::track::TrackParCov& trc, const o2d::VertexBase& vtxSeed) const
 {
-  return o2::base::Propagator::Instance()->propagateToDCA(vtxSeed, trc, mBz, 2.0f, o2::base::Propagator::MatCorrType::USEMatCorrLUT);
+  return o2::base::Propagator::Instance()->propagateToDCA(vtxSeed, trc, mBz, 2.0f, mMatCorr);
 }
 
 //______________________________________________

From add4011f9e174df084a4b8be40d706a0110975ee Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 11 May 2026 11:46:50 +0200
Subject: [PATCH 1719/1764] DPL: allDone should really be atomic (#15385)

---
 Framework/Core/include/Framework/DataProcessingContext.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/DataProcessingContext.h b/Framework/Core/include/Framework/DataProcessingContext.h
index 221f7b099dc07..976331ba42c3c 100644
--- a/Framework/Core/include/Framework/DataProcessingContext.h
+++ b/Framework/Core/include/Framework/DataProcessingContext.h
@@ -13,6 +13,7 @@
 
 #include "Framework/DataRelayer.h"
 #include "Framework/AlgorithmSpec.h"
+#include <atomic>
 #include <functional>
 
 namespace o2::framework
@@ -33,7 +34,7 @@ struct DataProcessorContext {
   DataProcessorContext(DataProcessorContext const&) = delete;
   DataProcessorContext() = default;
 
-  bool allDone = false;
+  std::atomic<bool> allDone = false;
   /// Latest run number we processed globally for this DataProcessor.
   int64_t lastRunNumberProcessed = -1;
 

From 52941f645ef932a4edb9b98dc86f78eca651beb0 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Mon, 11 May 2026 16:19:34 +0200
Subject: [PATCH 1720/1764] Fix nLayers calculation for MFT detector (#15389)

* Fix nLayers calculation for MFT detector

When decoding the staggered data I realised that we made a mistake leading to missing all data blocks in ctf beyond layer 7:
```
 Exception while running: Failed to read CTF header for MFT_7. Rethrowing.
```

* Fix MFT layer count retrieval in CTFWriterSpec
---
 Detectors/CTF/workflow/src/CTFWriterSpec.cxx | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/Detectors/CTF/workflow/src/CTFWriterSpec.cxx b/Detectors/CTF/workflow/src/CTFWriterSpec.cxx
index 5d6db7d613674..f175bf4c2e5d3 100644
--- a/Detectors/CTF/workflow/src/CTFWriterSpec.cxx
+++ b/Detectors/CTF/workflow/src/CTFWriterSpec.cxx
@@ -310,7 +310,7 @@ size_t CTFWriterSpec::processDet(o2::framework::ProcessingContext& pc, DetID det
   if (det == DetID::ITS) {
     nLayers = mInput.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
   } else if (det == DetID::MFT) {
-    nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+    nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::MFT>::getNLayers() : 1;
   }
   for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
     auto binding = getBinding(det.getName(), iLayer);
@@ -431,7 +431,7 @@ size_t CTFWriterSpec::estimateCTFSize(ProcessingContext& pc)
     if (det == DetID::ITS) {
       nLayers = mInput.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
     } else if (det == DetID::MFT) {
-      nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+      nLayers = mInput.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::MFT>::getNLayers() : 1;
     }
     for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
       auto binding = getBinding(det.getName(), iLayer);
@@ -818,7 +818,7 @@ DataProcessorSpec getCTFWriterSpec(const o2::ctf::CTFWriterInp& inp)
       if (det == DetID::ITS) {
         nLayers = inp.doITSStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
       } else if (det == DetID::MFT) {
-        nLayers = inp.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::ITS>::getNLayers() : 1;
+        nLayers = inp.doMFTStaggering ? o2::itsmft::DPLAlpideParam<DetID::MFT>::getNLayers() : 1;
       }
       for (uint32_t iLayer = 0; iLayer < nLayers; iLayer++) {
         inputs.emplace_back(CTFWriterSpec::getBinding(det.getName(), iLayer), det.getDataOrigin(), "CTFDATA", iLayer, Lifetime::Timeframe);

From 560821941e2a39d676457c642a7feabaf0361bbb Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Mon, 11 May 2026 18:25:48 +0200
Subject: [PATCH 1721/1764] [ALICE 3] TRK: Changed chip size and module number
 for TRK barrel + updated TRK documentation + included low services around
 beam pipe (#15382)

* Changed module length and number of modules accordingly

* Update TRK documentation

* Fix TRK documentation

* Added services around beam pipe

* Fix documentation

* Fix

* Account for f/bTOF

* Fix documentation
---
 Detectors/Upgrades/ALICE3/TRK/README.md       | 67 ++++++++++++++-
 .../ALICE3/TRK/base/include/TRKBase/Specs.h   |  4 +-
 .../TRK/base/include/TRKBase/TRKBaseParam.h   |  3 +-
 .../include/TRKSimulation/TRKServices.h       |  4 +-
 .../ALICE3/TRK/simulation/src/Detector.cxx    | 30 ++++---
 .../ALICE3/TRK/simulation/src/TRKServices.cxx | 86 ++++++++++++++++---
 6 files changed, 166 insertions(+), 28 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/README.md b/Detectors/Upgrades/ALICE3/TRK/README.md
index a061a06be66f3..efe07ab092eb2 100644
--- a/Detectors/Upgrades/ALICE3/TRK/README.md
+++ b/Detectors/Upgrades/ALICE3/TRK/README.md
@@ -15,7 +15,7 @@ Configurables for various sub-detectors are presented in the following Table:
 | Subsystem          | Available options                                       | Comments                                                         |
 | ------------------ | ------------------------------------------------------- | ---------------------------------------------------------------- |
 | `TRKBase.layoutVD` | `kIRIS4` (default), `kIRISFullCyl`, `kIRIS5`, `kIRIS4a` | [link to definitions](./base/include/TRKBase/TRKBaseParam.h) |
-| `TRKBase.layoutMLOT` | `kCylindrical`, `kSegmented` (default)     | `kSegmented` produced a Turbo layout for ML and a Staggered layout for OT                                                                 |
+| `TRKBase.layoutMLOT` | `kCylindrical`, `kSegmented` (default)     | `kSegmented` produces a Turbo layout for ML and a Staggered layout for OT                                                                 |
 | `TRKBase.layoutSRV` | `kPeacockv1` (default), `kLOISymm` | `kLOISymm` produces radially symmetric service volumes, as used in the LoI |
 
 For example, a geometry with fully cylindrical tracker barrel (for all layers in VD, ML and OT) can be obtained by
@@ -24,5 +24,70 @@ o2-sim-serial-run5 -n 1 -g pythia8hi -m A3IP TRK FT3 TF3 \
   --configKeyValues "TRKBase.layoutVD=kIRISFullCyl;TRKBase.layoutMLOT=kCylindrical"
 ```
 
+## Custom Geometry Configuration
+
+The geometry of the ML and OT layers can be overridden by providing a custom plain-text configuration file via `TRKBase.configFile=filename.txt`. The parser interprets the file differently depending on the active `TRKBase.layoutMLOT` setting (`kCylindrical` or `kSegmented`).
+
+### General Syntax Rules
+* **Separators:** All columns **must** be separated by a single TAB (`\t`). Using spaces will result in a parsing error.
+* **Comments:** Any line starting with a forward slash (`/`) is treated as a comment and ignored.
+* **Layer Count:** The parser reads valid lines sequentially. The first valid line corresponds to Layer 0, the second to Layer 1, and so on.
+* **Material Budget Mode:** All layer definitions accept an optional `matBudgetMode` parameter at the end of the line (e.g., `0` = Thickness, `1` = X2X0). If omitted, it defaults to `Thickness`.
+
+### 1. Cylindrical Layout (`kCylindrical`)
+
+When `TRKBase.layoutMLOT=kCylindrical` is used, each layer requires a minimum of 3 parameters to define the `TRKCylindricalLayer`.
+
+* **Format:** `rInn` \t `length` \t `thick` \t `[optional_mode]`
+* *(Note: `rInn`, `length`, and `thick` map directly to the constructor arguments for the cylindrical layer, typically corresponding to Radius, Length, and Thickness).*
+
+**Example for `kCylindrical`:**
+```text
+/ Configuration for kCylindrical layout - ALICE3 TRK
+/ rInn	length	thick	[optional_mode]
+7.0	127.985	0.1
+9.0	127.985	0.1
+12.0	127.985	0.1
+20.0	127.985	0.1
+30.0	127.985	0.1
+45.0	255.9	0.1
+60.0	255.9	0.1
+80.0	255.9	0.1
+```
+
+### 2. Segmented Layout (`kSegmented`)
+
+When `TRKBase.layoutMLOT=kSegmented` is used, each layer requires a minimum of 5 base parameters to define the geometry. The parser distinguishes between Middle Layers (ML) and Outer Layers (OT) based on the sequential layer index.
+
+* *(Note: The 5 base parameters map directly to: Inner Radius (`rInn`), Thickness (`thick`), Tilt Angle (`tiltAngle`), Number of Staves (`nStaves`), and Number of Modules per stave (`nMods`)).*
+
+**Middle Layers (ML) - Indices 0 to 4**
+The first 5 valid lines are parsed as `TRKMLLayer` objects. These layers **require** a 6th parameter for the staggering offset (`stagOffset`).
+* **Format:** `rInn` \t `thick` \t `tiltAngle` \t `nStaves` \t `nMods` \t `stagOffset` \t `[optional_mode]`
+
+**Outer Layers (OT) - Indices 5 and above**
+From the 6th valid line onwards, lines are parsed as `TRKOTLayer` objects. These layers do **not** have a staggering offset. The optional mode parameter shifts to the 6th column.
+* **Format:** `rInn` \t `thick` \t `tiltAngle` \t `nStaves` \t `nMods` \t `[optional_mode]`
+
+**Example for `kSegmented`:**
+
+```text
+/ Configuration for kSegmented layout - ALICE3 TRK
+/ --- ML LAYERS (Indices 0 to 4) ---
+/ rInn	thick	tilt	nStaves	nMods	stagOffset	[optional_mode]
+7.0	0.01	11.2	10	11	0.0	1
+9.0	0.01	11.9	14	11	0.0	1
+12.0	0.01	11.4	18	11	0.0	1
+20.0	0.01	0.0	26	11	1.17	1
+30.0	0.01	0.0	38	11	0.89	1
+/
+/ --- OT LAYERS (Indices 5 to 7) ---
+/ Outer layers do NOT have stagOffset.
+/ rInn	thick	tilt	nStaves	nMods	[optional_mode]
+45.0	0.01	0.0	32	22	1
+60.0	0.01	0.0	42	22	1
+80.0	0.01	0.0	56	22	1
+```
+
 <!-- doxy
 /doxy -->
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
index 0ed7ca6a8a8d4..b484e13f3546e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/Specs.h
@@ -16,7 +16,9 @@
 #define O2_ALICE_TRK_SPECS
 
 #include <array>
+
 #include <math.h>
+
 // This is a temporary version with the specs for the ALICE3 TRK
 // This files defines the design specifications of the chips for VD, ML, OT.
 // Each TGeoShape has the following properties
@@ -78,7 +80,7 @@ constexpr double thickness{0 * mu}; // thickness of the copper metal stack - for
 namespace chip
 {
 constexpr double width{25 * mm};                                              // width of the chip
-constexpr double length{32 * mm};                                             // length of the chip
+constexpr double length{29 * mm};                                             // length of the chip
 constexpr double pitchX{20 * mu};                                             // pitch of the row
 constexpr double pitchZ{20 * mu};                                             // pitch of the column
 constexpr double totalThickness{silicon::thickness + metalstack::thickness};  // total thickness of the chip
diff --git a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
index 63e961db44505..65194ad6edfcb 100644
--- a/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
+++ b/Detectors/Upgrades/ALICE3/TRK/base/include/TRKBase/TRKBaseParam.h
@@ -40,7 +40,8 @@ enum eSrvLayout {
 struct TRKBaseParam : public o2::conf::ConfigurableParamHelper<TRKBaseParam> {
   std::string configFile = "";
   float serviceTubeX0 = 0.02f; // X0 Al2O3
-  Bool_t irisOpen = false;
+  bool irisOpen = false;
+  bool includeLowServices = false;
 
   eVDLayout layoutVD = kIRIS4;         // VD detector layout design
   eMLOTLayout layoutMLOT = kSegmented; // ML and OT detector layout design
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
index 79033f48cb0b9..dedbbb096b8e8 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKServices.h
@@ -21,6 +21,7 @@
 // Water bundle disk       PU            0,44       19        H2O         0,56      36,08
 
 #include <TGeoManager.h>
+
 #include <FairModule.h>
 
 namespace o2
@@ -51,6 +52,7 @@ class TRKServices : public FairModule
   void createMiddleServices(TGeoVolume* motherVolume);
   void createOuterDisksServices(TGeoVolume* motherVolume);
   void createOuterBarrelServices(TGeoVolume* motherVolume);
+  void createServicesAroundBeamPipe(TGeoVolume* motherVolume);
   void createMLServicesPeacock(TGeoVolume* motherVolume);
   void createOTServicesPeacock(TGeoVolume* motherVolume);
   void createVacuumCompositeShape();
@@ -81,4 +83,4 @@ class TRKServices : public FairModule
 };
 } // namespace trk
 } // namespace o2
-#endif // O2_TRK_SERVICES_H
\ No newline at end of file
+#endif // O2_TRK_SERVICES_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
index 3fa51afe3ba2b..196727b2c140f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/Detector.cxx
@@ -98,7 +98,7 @@ void Detector::configMLOT()
 
   switch (trkPars.layoutMLOT) {
     case kCylindrical: {
-      const std::vector<float> length{128.35f, 128.35f, 128.35f, 128.35f, 128.35f, 256.7f, 256.7f, 256.7f};
+      const std::vector<float> length{127.985f, 127.985f, 127.985f, 127.985f, 127.985f, 255.9f, 255.9f, 255.9f};
       LOGP(warning, "Loading cylindrical configuration for ALICE3 TRK");
       for (int i{0}; i < constants::ML::nLayers + constants::OT::nLayers; ++i) {
         std::string name = GeometryTGeo::getTRKLayerPattern() + std::to_string(i);
@@ -111,7 +111,7 @@ void Detector::configMLOT()
       // const std::vector<float> tiltAngles{10.f, 16.1f, 19.2f, 0.f, 0.f, 0.f, 0.f, 0.f};
       const std::vector<int> nStaves{10, 14, 18, 26, 38, 32, 42, 56};
       // const std::vector<int> nStaves{10, 16, 22, 26, 38, 32, 42, 56};
-      const std::vector<int> nMods{10, 10, 10, 10, 10, 20, 20, 20};
+      const std::vector<int> nMods{11, 11, 11, 11, 11, 22, 22, 22};
 
       const std::vector<float> stagOffsets{0.f, 0.f, 0.f, 1.17f, 0.89f};
 
@@ -165,18 +165,28 @@ void Detector::configFromFile(std::string fileName)
 
     switch (trkPars.layoutMLOT) {
       case kCylindrical: {
+        // Expected column mapping in the text file (separated by \t):
+        // tmpBuff[0] = rInn
+        // tmpBuff[1] = length
+        // tmpBuff[2] = thick
+        // tmpBuff[3] = matBudgetMode (optional, default = Thickness)
+
         // Cylindrical requires at least 3 parameters
         if (tmpBuff.size() < 3) {
           LOGP(fatal, "Invalid configuration for cylindrical layer {}: insufficient parameters.", layerCount);
         }
 
+        float rInn = tmpBuff[0];
+        float length = tmpBuff[1];
+        float thick = tmpBuff[2];
+
         // Default mode is Thickness
-        MatBudgetParamMode mode = MatBudgetParamMode::Thickness;
+        MatBudgetParamMode matBudgetMode = MatBudgetParamMode::Thickness;
         if (tmpBuff.size() >= 4) {
-          mode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[3]));
+          matBudgetMode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[3]));
         }
 
-        mLayers.push_back(std::make_unique<TRKCylindricalLayer>(layerCount, name, tmpBuff[0], tmpBuff[1], tmpBuff[2], mode));
+        mLayers.push_back(std::make_unique<TRKCylindricalLayer>(layerCount, name, rInn, length, thick, matBudgetMode));
         break;
       }
       case kSegmented: {
@@ -201,7 +211,7 @@ void Detector::configFromFile(std::string fileName)
         int nMods = static_cast<int>(tmpBuff[4]);
 
         // Default mode is Thickness
-        MatBudgetParamMode mode = MatBudgetParamMode::Thickness;
+        MatBudgetParamMode matBudgetMode = MatBudgetParamMode::Thickness;
 
         if (layerCount < constants::ML::nLayers) {
           // ML layers require stagOffset (index 5)
@@ -211,17 +221,17 @@ void Detector::configFromFile(std::string fileName)
           float stagOffset = tmpBuff[5];
 
           if (tmpBuff.size() >= 7) {
-            mode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[6]));
+            matBudgetMode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[6]));
           }
 
-          mLayers.push_back(std::make_unique<TRKMLLayer>(layerCount, name, rInn, stagOffset, tiltAngle, nStaves, nMods, thick, mode));
+          mLayers.push_back(std::make_unique<TRKMLLayer>(layerCount, name, rInn, stagOffset, tiltAngle, nStaves, nMods, thick, matBudgetMode));
         } else {
           // OT layers do NOT have stagOffset. The optional mode is at index 5.
           if (tmpBuff.size() >= 6) {
-            mode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[5]));
+            matBudgetMode = static_cast<MatBudgetParamMode>(static_cast<int>(tmpBuff[5]));
           }
 
-          mLayers.push_back(std::make_unique<TRKOTLayer>(layerCount, name, rInn, tiltAngle, nStaves, nMods, thick, mode));
+          mLayers.push_back(std::make_unique<TRKOTLayer>(layerCount, name, rInn, tiltAngle, nStaves, nMods, thick, matBudgetMode));
         }
         break;
       }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 01a945ee7a753..7b61d2e120196 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -9,22 +9,23 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#include <TRKSimulation/TRKServices.h>
 #include <DetectorsBase/MaterialManager.h>
+#include <Framework/Logger.h>
+
+#include <TColor.h>
+#include <TGeoCompositeShape.h>
+#include <TGeoNode.h>
+#include <TGeoTube.h>
+#include <TGeoVolume.h>
 #include <TRKBase/GeometryTGeo.h>
 #include <TRKBase/TRKBaseParam.h>
+#include <TRKSimulation/TRKServices.h>
+
 #include <FT3Base/GeometryTGeo.h>
-#include <TGeoVolume.h>
-#include <TGeoNode.h>
-#include <TGeoTube.h>
-#include <TGeoCompositeShape.h>
-#include <TColor.h>
-#include <Rtypes.h>
-#include <numeric>
 
-#include <Framework/Logger.h>
+#include <Rtypes.h>
 
-using std::string;
+#include <numeric>
 
 namespace o2
 {
@@ -140,6 +141,9 @@ void TRKServices::createServices(TGeoVolume* motherVolume)
     createOuterBarrelServices(vol);
   } else {
     LOGP(info, "TRK services: Peacock layout");
+    if (trkPars.includeLowServices) {
+      createServicesAroundBeamPipe(vol);
+    }
     createMLServicesPeacock(vol);
     createOTServicesPeacock(vol);
   }
@@ -521,9 +525,63 @@ void TRKServices::createOuterBarrelServices(TGeoVolume* motherVolume)
   motherVolume->AddNode(outerBarrelCoolingH2OVolume, 1, nullptr);
 }
 
+void TRKServices::createServicesAroundBeamPipe(TGeoVolume* motherVolume)
+{
+  // This method hardcodes the shape for the low services around the beam pipe
+  auto& matmgr = o2::base::MaterialManager::Instance();
+
+  TGeoMedium* medCu = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_COPPER");
+
+  const float tolleranceLowServices = 0.3f;
+
+  // Low services start longitudinally from middle barrel on the C side, while from the middle barrel connection disks on the A side
+  const float zStartASideFirstBlock = 65.265f + tolleranceLowServices;
+  const float zStartCSideFirstBlock = 64.5f + tolleranceLowServices;
+  const float zStartSecondBlock = 150.f;
+  const float zStartThirdBlock = 365.f;
+  const float zEndThirdBlock = 400.f;
+
+  // Low services start radially from IRIS out-vacuum services on the A side, while from beam pipe on the C side
+  const float rInASide = 3.333f + tolleranceLowServices;
+  const float rInCSide = 5.6f + tolleranceLowServices;
+
+  // Low services end radially at the disks inners radius
+  const float rOutFirstBlock = 10.f - tolleranceLowServices;
+  const float rOutSecondBlock = 20.f - tolleranceLowServices;
+  const float rOutThirdBlock = 15.f - tolleranceLowServices;
+
+  for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
+    std::string orLabel = orientation == Orientation::kASide ? "A" : "C";
+
+    float zStartLowServices = orientation == Orientation::kASide ? zStartASideFirstBlock : zStartCSideFirstBlock;
+    float rInLowServices = orientation == Orientation::kASide ? rInASide : rInCSide;
+
+    TGeoTube* lowServicesFirstBlock = new TGeoTube(Form("TRK_LOWSERVICES_FIRSTBLOCKsh_%s", orLabel.c_str()), rInLowServices, rOutFirstBlock, (zStartSecondBlock - zStartLowServices) / 2.);
+    TGeoVolume* lowServicesFirstBlockVolume = new TGeoVolume(Form("TRK_LOWSERVICES_FIRSTBLOCK_%s", orLabel.c_str()), lowServicesFirstBlock, medCu);
+    lowServicesFirstBlockVolume->SetLineColor(kGray);
+
+    TGeoTube* lowServicesSecondBlock = new TGeoTube(Form("TRK_LOWSERVICES_SECONDBLOCKsh_%s", orLabel.c_str()), rInLowServices, rOutSecondBlock, (zStartThirdBlock - zStartSecondBlock) / 2.);
+    TGeoVolume* lowServicesSecondBlockVolume = new TGeoVolume(Form("TRK_LOWSERVICES_SECONDBLOCK_%s", orLabel.c_str()), lowServicesSecondBlock, medCu);
+    lowServicesSecondBlockVolume->SetLineColor(kGray);
+
+    TGeoTube* lowServicesThirdBlock = new TGeoTube(Form("TRK_LOWSERVICES_THIRDBLOCKsh_%s", orLabel.c_str()), rInLowServices, rOutThirdBlock, (zEndThirdBlock - zStartThirdBlock) / 2.);
+    TGeoVolume* lowServicesThirdBlockVolume = new TGeoVolume(Form("TRK_LOWSERVICES_THIRDBLOCK_%s", orLabel.c_str()), lowServicesThirdBlock, medCu);
+    lowServicesThirdBlockVolume->SetLineColor(kGray);
+
+    auto* rot = new TGeoRotation("", 0, 0, 180);
+    auto* combiTransFirstBlock = new TGeoCombiTrans(0, 0, (int)orientation * (zStartLowServices + (zStartSecondBlock - zStartLowServices) / 2.), rot);
+    auto* combiTransSecondBlock = new TGeoCombiTrans(0, 0, (int)orientation * (zStartSecondBlock + (zStartThirdBlock - zStartSecondBlock) / 2.), rot);
+    auto* combiTransThirdBlock = new TGeoCombiTrans(0, 0, (int)orientation * (zStartThirdBlock + (zEndThirdBlock - zStartThirdBlock) / 2.), rot);
+
+    motherVolume->AddNode(lowServicesFirstBlockVolume, 1, combiTransFirstBlock);
+    motherVolume->AddNode(lowServicesSecondBlockVolume, 1, combiTransSecondBlock);
+    motherVolume->AddNode(lowServicesThirdBlockVolume, 1, combiTransThirdBlock);
+  }
+}
+
 void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
 {
-  // This method hardcoes the yellow shape for the middle services
+  // This method hardcodes the yellow shape for the middle services
   auto& matmgr = o2::base::MaterialManager::Instance();
 
   TGeoMedium* medSiO2 = matmgr.getTGeoMedium("ALICE3_TRKSERVICES_SILICONDIOXIDE");
@@ -619,7 +677,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
     for (int iSide = 0; iSide < 2; iSide++) { // left/right or top/bottom
       float refAngle = 0;
-      string orLabel("A");
+      std::string orLabel("A");
       if (orientation == Orientation::kCSide) {
         orLabel = "C";
         refAngle = 90;
@@ -703,7 +761,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   diskCircumference = rMaxMiddleServicesBarFwd * 3.14; // Only half of the area is used
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
     float refAngle = 0;
-    string orLabel("A");
+    std::string orLabel("A");
     if (orientation == Orientation::kCSide) {
       refAngle = 90;
       orLabel = "C";
@@ -872,7 +930,7 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
   motherVolume->AddNode(outerBarrelCarbonSupportVolume, 1, nullptr);
 
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
-    string orLabel = "A";
+    std::string orLabel = "A";
     float refAngle = 0;
     if (orientation == Orientation::kCSide) {
       orLabel = "C";

From 9ad6dd4b29fdf5749b138ac8bf4ea62c49405378 Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Mon, 11 May 2026 20:14:10 +0200
Subject: [PATCH 1722/1764] Raw TF dump workflow (#15374)

* Raw TF dump workflow

* Add trigger

* Add throttling to requested dumping rate, + readme

* Add optional o2-raw-tf-dump-workflow to the dpl-worlflow.sh

Will be added in the raw-data driven modes (CTFINPUT==0 and DIGITINPUT==0) if the env.var
DPL_RAWTFDUMP is defined and ==1.
If an external trigger for dumping is provided, e.g. `TPC/CMVTRIGGER`, it will be added to the PROXY_INSPEC (also passed to the raw-proxy) and passed to
the o2-raw-tf-dump-workflow via option
```
--triggerspec ${DPL_RAWTFDUMP_TRIGGER}
```
Other hardcoded options are:
```
--dataspec   ${PROXY_INSPEC} : the usual output string of the raw-input proxy
--output-dir ${RAWTF_DIR:-$CTF_DIR}: output directory, if not specified, then CTF directory will be used (where a temporary run-specific sub-directory will be created)
--meta-output-dir ${EPN2EOS_METAFILES_DIR}
--max-dump-rate ${RAWTF_DUMPRATE:-0.1}: max. output rate in percents (either as a standalone trigger or a throttling device on top of the external trigger, if provided)
--min-file-size ${RAWTF_MINSIZE:-$CTF_MINSIZE}: max. output file size to accumulate (if not provided, CTF-writer settings will be used)
--max-tf-per-file ${RAWTF_MAX_PER_FILE:-$CTF_MAX_PER_FILE}: max. TFs in the output file to accumulate (if not provided, CTF-writer settings will be used)
--mute-warn-period ${RAWTF_MUTE_PERIOD:-200}: if externally triggered TF is throttled by the max-dump-rate, warn at most once per this number of TFs.
--max-warn ${RAWTF_MAX_WARN:-5}: maximum throttling warnings to issue
```
For other possible options see Detectors/Raw/README.md#raw-tf-dd-format-dumping-workflow.
---
 Common/Utils/include/CommonUtils/NameConf.h   |   3 +
 Common/Utils/src/NameConf.cxx                 |   5 +
 Detectors/Raw/README.md                       |  76 +++
 Detectors/Raw/TFReaderDD/CMakeLists.txt       |   7 +
 .../Raw/TFReaderDD/src/RawTFDumpSpec.cxx      | 574 ++++++++++++++++++
 Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.h  |  23 +
 .../TFReaderDD/src/SubTimeFrameFileReader.cxx |   5 +-
 .../TFReaderDD/src/tf-data-dump-workflow.cxx  |  46 ++
 prodtests/full-system-test/dpl-workflow.sh    |  90 ++-
 9 files changed, 794 insertions(+), 35 deletions(-)
 create mode 100644 Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
 create mode 100644 Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.h
 create mode 100644 Detectors/Raw/TFReaderDD/src/tf-data-dump-workflow.cxx

diff --git a/Common/Utils/include/CommonUtils/NameConf.h b/Common/Utils/include/CommonUtils/NameConf.h
index fb10f929c9782..8d4c0a2c1c4f8 100644
--- a/Common/Utils/include/CommonUtils/NameConf.h
+++ b/Common/Utils/include/CommonUtils/NameConf.h
@@ -100,6 +100,9 @@ class NameConf : public o2::conf::ConfigurableParamHelper<NameConf>
   // CTF Dictionary
   static std::string getCTFDictFileName();
 
+  // O2 Raw TF Filename
+  static std::string getRawTFFileName(uint32_t run, uint32_t orb, uint32_t id, const std::string& host, const std::string_view prefix = "o2_rawtf_dump");
+
   // Default CCDB server
   static std::string getCCDBServer();
 
diff --git a/Common/Utils/src/NameConf.cxx b/Common/Utils/src/NameConf.cxx
index 45646284a878b..48cefacaf14c7 100644
--- a/Common/Utils/src/NameConf.cxx
+++ b/Common/Utils/src/NameConf.cxx
@@ -95,6 +95,11 @@ std::string NameConf::getCTFFileName(uint32_t run, uint32_t orb, uint32_t id, co
   return o2::utils::Str::concat_string(prefix, '_', fmt::format("run{:08d}_orbit{:010d}_tf{:010d}_{}", run, orb, id, host), ".root");
 }
 
+std::string NameConf::getRawTFFileName(uint32_t run, uint32_t orb, uint32_t id, const std::string& host, const std::string_view prefix)
+{
+  return o2::utils::Str::concat_string(prefix, '_', fmt::format("run{:08d}_orbit{:010d}_tf{:010d}_{}", run, orb, id, host), ".tf");
+}
+
 std::string NameConf::getCTFDictFileName()
 {
   return o2::utils::Str::concat_string(CTFDICT, ".root");
diff --git a/Detectors/Raw/README.md b/Detectors/Raw/README.md
index 557245030b980..d896b232d2647 100644
--- a/Detectors/Raw/README.md
+++ b/Detectors/Raw/README.md
@@ -548,6 +548,82 @@ list of detectors for which raw outputs are discarded.
 
 The raw data will be propagated (if present) only if the detector is selected in `--onlyDet` and `NOT` selected in `--non-raw-only-det`. The non-raw data will be propagated (if defined for the given detector and present in the file) only if the detector is selected in `--onlyDet` and `NOT` selected in `--raw-only-det`.
 
+## Raw TF (DD format) dumping workflow
+
+Use `o2-raw-tf-dump-workflow` to dump raw TF data in DD format. The options are:
+```
+--dataspec arg (=tst:TST/A)
+```
+Optional selection string for the data to be dumped, e.g. the same string supplied to the input raw proxy
+```
+--triggerspec arg (="")
+```
+Selection string for the external trigger to dump particular TF. Must be contained in the `--dataspec`. The workflow will loop over all available trigger inputs, interpreting them as span<bool>: any `span[0]==true` will trigger writing process (modulo throttling).
+```
+--include-deadbeef (false)
+```
+Include data with DPL-generated 0xdeadbeef subspecs (for data missing in the original TF).
+```
+--max-dump-rate arg (=0)
+```
+Fraction in (`%`) of TFs to dump. W/o external trigger: random(>0) or periodic(<0) rejection. With external trigger: throttle dumping to have the lowest estimated acceptance rate compatible with this rate.
+```
+--rate-est-conf-limit arg (=0.05)
+```
+Quantile for the lowest rate estimate confidence limit
+```
+--max-warn arg (=5)
+```
+If throttling, max allowed warnings
+```
+--mute-warn-period arg (=100)
+```
+Mute warnings about throttling for this number of TFs
+```
+--output-dir arg (=none)
+```
+Dumped TFs output directory, must exist. `none` means current dir., `/dev/null`: ignort writing (dry run)
+```
+--meta-output-dir arg (=/dev/null)
+```
+TF metadata output directory, must exist (if not /dev/null, in which case the metadata will not be created)
+```
+--md5-for-meta (false)
+```
+Fill CTF file MD5 sum in the metadata file
+```
+--min-file-size arg (=0)
+```
+Accumulate TFs until given file size reached
+```
+--max-file-size arg (=0)
+```
+If > 0, try to avoid exceeding given file size, also used for space check
+```
+--max-tf-per-file arg (=0)
+```
+If > 0, avoid storing more than requested CTFs per file
+```
+--require-free-disk arg (=0)
+```
+Pause writing op. if available disk space is below this margin, in bytes if >0, as a fraction of total if <0
+```
+--wait-for-free-disk arg (=10)
+```
+If paused due to the low disk space, recheck after this time (in s)
+```
+--max-wait-for-free-disk arg (=60)
+```
+Produce fatal if paused due to the low disk space for more than time in seconds.
+```
+--verbosity-level (=0)
+```
+Verbose mode: 1: decision on every TF, 2: details of saved TF, 3: more details.
+```
+--ignore-partition-run-dir
+```
+Do not creare partition-run directory in output-dir
+
 ## TF rate limiting
 
 To apply TF rate limiting (i.e. make sure that no more than N TFs are in processing) provide `--timeframes-rate-limit <N> --timeframes-rate-limit-ipcid <IPCID>`
diff --git a/Detectors/Raw/TFReaderDD/CMakeLists.txt b/Detectors/Raw/TFReaderDD/CMakeLists.txt
index 12ecc9ca8795d..f87d1b5a7704e 100644
--- a/Detectors/Raw/TFReaderDD/CMakeLists.txt
+++ b/Detectors/Raw/TFReaderDD/CMakeLists.txt
@@ -26,3 +26,10 @@ o2_add_executable(tf-reader-workflow
                   SOURCES src/TFReaderSpec.cxx
                           src/tf-reader-workflow.cxx
                   PUBLIC_LINK_LIBRARIES O2::TFReaderDD)
+
+
+o2_add_executable(tf-dump-workflow
+                  COMPONENT_NAME raw
+                  SOURCES src/RawTFDumpSpec.cxx
+                          src/tf-data-dump-workflow.cxx
+                  PUBLIC_LINK_LIBRARIES O2::TFReaderDD)
diff --git a/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx b/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
new file mode 100644
index 0000000000000..4e2d0372b3069
--- /dev/null
+++ b/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
@@ -0,0 +1,574 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "Framework/WorkflowSpec.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/RawDeviceService.h"
+#include "Framework/DataProcessingHelpers.h"
+#include "Framework/InputRecordWalker.h"
+#include "Framework/Task.h"
+#include "Framework/DataTakingContext.h"
+#include "Framework/TimingInfo.h"
+#include "DataFormatsParameters/GRPECSObject.h"
+#include "DetectorsCommonDataFormats/FileMetaData.h"
+#include "RawTFDumpSpec.h"
+#include "TFReaderDD/SubTimeFrameFile.h"
+#include "CommonUtils/NameConf.h"
+#include "CommonUtils/FileSystemUtils.h"
+#include "CommonUtils/StringUtils.h"
+#include "Algorithm/RangeTokenizer.h"
+#include <unistd.h>
+#include <TMath.h>
+#include <filesystem>
+#include <random>
+
+namespace o2::rawdd
+{
+namespace o2h = o2::header;
+using namespace o2::framework;
+using DataHeader = o2::header::DataHeader;
+using DetID = o2::detectors::DetID;
+using ios = std::ios_base;
+
+class RawTFDump : public Task
+{
+ public:
+  static constexpr o2h::DataDescription DESCRaw{"RAWDATA"}, DESCCRaw{"CRAWDATA"};
+
+  RawTFDump(const std::string& trigger);
+  void init(InitContext& ic) final;
+  void run(ProcessingContext& pc) final;
+  void endOfStream(EndOfStreamContext& ec) final;
+
+ private:
+  bool triggerTF(ProcessingContext& pc);
+  void updateTimeDependentParams(ProcessingContext& pc);
+  void prepareTFForWriting(ProcessingContext& pc);
+  size_t getTFSizeInFile() const;
+  size_t getCurrentFileSize();
+  void prepareTFFile();
+  void closeTFFile();
+  bool checkFreeSpace(ProcessingContext& pc);
+  std::string reportRates() const;
+
+  SubTimeFrameFileDataIndex mTFDataIndex;
+  std::vector<std::pair<const void*, const void*>> mTFData;
+  std::map<EquipmentIdentifier, std::tuple<size_t, size_t, size_t>> mDataMap;
+  std::vector<InputSpec> mFilter{};
+  std::vector<InputSpec> mTriggerFilter{};
+
+  size_t mTFSize = 0;
+  size_t mMinFileSize = 0; // if > 0, accumulate TFs in the same file until the total size exceeds this minimum
+  size_t mMaxFileSize = 0; // if > MinSize, and accumulated size will exceed this value, stop accumulation (even if mMinFileSize is not reached)
+
+  int mNTFsSeen = 0;          // total number of TFs seen
+  int mNTFsExtTrig = 0;       // total nunber of TFs externally triggered
+  int mNTFsAccepted = 0;      // total number of TFs written
+  int mNTFsInFile = 0;        // total number of TFs accumulated in the current file
+  int mNTFFiles = 0;          // total number of TF files written
+  int mLastWarned = 0;        // TF when last warned about throttling
+  int mMaxTFPerFile = 0;      // max TFs per files to store
+  int mNWarnThrottle = 0;     // number of times we warned about the throttling
+  int mMaxWarnThrottle = 0;   // max allowed warnings about the throttling
+  int mWarnThrottleTF = 0;    // min period (in TFs) between the warnings about the throttling
+  int mWaitDiskFull = 0;      // if mCheckDiskFull triggers, pause for this amount of ms before new attempt
+  int mWaitDiskFullMax = -1;  // produce fatal mCheckDiskFull block the workflow for more than this time (in ms)
+  float mCheckDiskFull = 0.;  // wait for if available abs. disk space is < mCheckDiskFull (if >0) or if its fraction is < -mCheckDiskFull (if <0)
+  float mMaxAccRate = 0.f;    // max acceptance rate
+  float mConfLim = 0.05f;     // confidence limit for rate esimate (lower quantile)
+  float mRateEstAccLow = 0.f; // lower limit on accepted TFs rate
+  float mRateEstAccUpp = 0.f; // upper limit on accepted TFs rate
+  float mRateEstTrgLow = 0.f; // lower limit on triggered TFs rate
+  float mRateEstTrgUpp = 0.f; // upper limit on triggered TFs rate
+
+  bool mFillMD5 = false;
+  bool mWriteTF = true; // for dry run
+  bool mStoreMetaFile = false;
+  bool mCreateRunEnvDir = true;
+  bool mAcceptCurrentTF = false;
+  bool mRejectDEADBEEF = false;
+  int mVerbose = 0;
+  std::vector<uint32_t> mTFOrbits{}; // 1st orbits of TF accumulated in current file
+  o2::framework::DataTakingContext mDataTakingContext{};
+  o2::framework::TimingInfo mTimingInfo{};
+
+  std::string mTrigger{}; // external trigger input
+  std::string mHostName{};
+  std::string mTFDir{};
+  std::string mTFMetaFileDir = "/dev/null";
+  std::string mCurrentTFFileName{};
+  std::string mCurrentTFFileNameFull{};
+  std::string mCurrentTFFileNameFullTmp{};
+  std::string mMetaDataType{};
+
+  static constexpr size_t MiB = 1ul << 20;
+  static constexpr std::streamsize sBuffSize = MiB; // 1 MiB
+  static constexpr std::streamsize sChunkSize = 512;
+  static const std::string TMPFileEnding;
+  std::unique_ptr<char[]> mFileBuf;
+  std::ofstream mFile;
+  std::uniform_real_distribution<double> mUniformDist{0.0, 100.0};
+  std::default_random_engine mRGen;
+
+  // helper to make sure the written blocks are buffered
+  template <
+    typename pointer,
+    typename std::enable_if<
+      std::is_pointer<pointer>::value &&                      // pointers only
+      (std::is_void<std::remove_pointer_t<pointer>>::value || // void* or standard layout!
+       std::is_standard_layout<std::remove_pointer_t<pointer>>::value)>::type* = nullptr>
+  void buffered_write(const pointer p, std::streamsize pCount)
+  {
+    // make sure we're not doing a short write
+    assert((pCount % sizeof(std::conditional_t<std::is_void<std::remove_pointer_t<pointer>>::value,
+                                               char, std::remove_pointer_t<pointer>>) ==
+            0) &&
+           "Performing short write?");
+
+    const char* lPtr = reinterpret_cast<const char*>(p);
+    // avoid the optimization if the write is large enough
+    if (pCount >= sBuffSize) {
+      mFile.write(lPtr, pCount);
+    } else {
+      // split the write to smaller chunks
+      while (pCount > 0) {
+        const auto lToWrite = std::min(pCount, sChunkSize);
+        assert(lToWrite > 0 && lToWrite <= sChunkSize && lToWrite <= pCount);
+
+        mFile.write(lPtr, lToWrite);
+        lPtr += lToWrite;
+        pCount -= lToWrite;
+      }
+    }
+  }
+};
+
+const std::string RawTFDump::TMPFileEnding{".part"};
+
+//________________________________________
+RawTFDump::RawTFDump(const std::string& trigger) : mTrigger{trigger}
+{
+  mTriggerFilter = select(trigger.c_str());
+  mFileBuf = std::make_unique<char[]>(sBuffSize);
+  mFile.rdbuf()->pubsetbuf(mFileBuf.get(), sBuffSize);
+  mFile.clear();
+  mFile.exceptions(std::fstream::failbit | std::fstream::badbit);
+}
+
+//________________________________________
+void RawTFDump::init(InitContext& ic)
+{
+  mRGen = std::default_random_engine(getpid());
+  mTFMetaFileDir = ic.options().get<std::string>("meta-output-dir");
+  if (mTFMetaFileDir != "/dev/null") {
+    mTFMetaFileDir = o2::utils::Str::rectifyDirectory(mTFMetaFileDir);
+    mStoreMetaFile = true;
+    mFillMD5 = ic.options().get<bool>("md5-for-meta");
+  }
+
+  mTFDir = ic.options().get<std::string>("output-dir");
+  if (mTFDir != "/dev/null") {
+    mTFDir = o2::utils::Str::rectifyDirectory(mTFDir);
+    mWriteTF = true;
+  } else {
+    mWriteTF = false;
+    mStoreMetaFile = false;
+  }
+
+  mRejectDEADBEEF = !ic.options().get<bool>("include-deadbeef");
+  mCreateRunEnvDir = !ic.options().get<bool>("ignore-partition-run-dir");
+  mMinFileSize = ic.options().get<int64_t>("min-file-size");
+  mMaxFileSize = ic.options().get<int64_t>("max-file-size");
+  mMaxTFPerFile = ic.options().get<int>("max-tf-per-file");
+  mMaxAccRate = ic.options().get<float>("max-dump-rate");
+  float cl = ic.options().get<float>("rate-est-conf-limit");
+  if (mConfLim < 0.001 || mConfLim > 0.32) {
+    LOGP(warn, "Bad confidence limit {} for rate estimate, setting to default {}", cl, mConfLim);
+  } else {
+    mConfLim = cl;
+  }
+  mMaxWarnThrottle = ic.options().get<int>("max-warn");
+  mWarnThrottleTF = ic.options().get<int>("mute-warn-period");
+
+  mVerbose = ic.options().get<int>("verbosity-level");
+  if (mTrigger.empty()) {
+    if (mMaxAccRate >= 0.f) {
+      LOGP(info, "Will accept randomly {}% of TFs", mMaxAccRate);
+    } else {
+      LOGP(info, "Will accept every {}-th TF", int(std::ceil(-100.f / mMaxAccRate)));
+    }
+  } else {
+    mMaxAccRate = std::abs(mMaxAccRate);
+    LOGP(info, "Will limit TFs triggered with {} by {}% at most", mTrigger, mMaxAccRate);
+  }
+
+  if (mWriteTF) {
+    if (mMinFileSize > 0) {
+      LOGP(info, "Multiple TFs will be accumulated in the file until its size exceeds {}{}",
+           mMinFileSize, mMaxFileSize > mMinFileSize ? fmt::format(" but does not exceed {} B", mMaxFileSize) : std::string{});
+    }
+  }
+
+  mCheckDiskFull = ic.options().get<float>("require-free-disk");
+  mWaitDiskFull = 1000 * ic.options().get<float>("wait-for-free-disk");
+  mWaitDiskFullMax = 1000 * ic.options().get<float>("max-wait-for-free-disk");
+
+  char hostname[_POSIX_HOST_NAME_MAX];
+  gethostname(hostname, _POSIX_HOST_NAME_MAX);
+  mHostName = hostname;
+  mHostName = mHostName.substr(0, mHostName.find('.'));
+}
+
+//________________________________________
+void RawTFDump::run(ProcessingContext& pc)
+{
+  mNTFsSeen++;
+  updateTimeDependentParams(pc);
+  mAcceptCurrentTF = triggerTF(pc);
+  if (mAcceptCurrentTF) {
+    prepareTFForWriting(pc);
+  } else {
+    return;
+  }
+
+  prepareTFFile();
+  if (mWriteTF && checkFreeSpace(pc)) { // write data
+    try {
+      size_t lTFSizeInFile = getTFSizeInFile();
+      SubTimeFrameFileMeta lTFFileMeta(lTFSizeInFile);
+
+      mFile << lTFFileMeta;  // Write DataHeader + SubTimeFrameFileMeta
+      mFile << mTFDataIndex; // Write DataHeader + SubTimeFrameFileDataIndex
+
+      for (const auto& eqEntry : mDataMap) {
+        auto& [lSize, lCnt, lEntry] = eqEntry.second;
+        for (size_t part = 0; part < lCnt; part++) {
+          const auto& dataPtr = mTFData[lEntry + part];
+          DataHeader hdToWrite = *reinterpret_cast<const DataHeader*>(dataPtr.first); // make a local DataHeader copy to clear flagsNextHeader bit
+          hdToWrite.flagsNextHeader = 0;
+          buffered_write(reinterpret_cast<const char*>(&hdToWrite), sizeof(DataHeader));
+          buffered_write(dataPtr.second, hdToWrite.payloadSize);
+        }
+      }
+      mFile.flush(); // flush the buffer and check the state
+      mTFOrbits.push_back(mTimingInfo.firstTForbit);
+      mNTFsInFile++;
+    } catch (const std::ios_base::failure& eFailExc) {
+      LOGP(error, "Writing of TF {} to file {} failed. error={}", mTimingInfo.tfCounter, mCurrentTFFileNameFullTmp, eFailExc.what());
+    }
+  }
+  // cleanup
+  mTFData.clear();
+  mDataMap.clear();
+  mTFDataIndex.clear();
+  mTFSize = 0;
+}
+
+//____________________________________________________________
+void RawTFDump::endOfStream(EndOfStreamContext&)
+{
+  closeTFFile();
+  LOGP(info, "Dumped {} TFs to {} files", mNTFsAccepted, mNTFFiles);
+  if (!mTriggerFilter.empty()) {
+    LOGP(info, "External trigger summary: {}", reportRates());
+  }
+}
+
+//________________________________________
+size_t RawTFDump::getTFSizeInFile() const
+{
+  return SubTimeFrameFileMeta::getSizeInFile() + mTFDataIndex.getSizeInFile() + mTFSize;
+}
+
+//________________________________________
+size_t RawTFDump::getCurrentFileSize()
+{
+  return mFile.is_open() ? size_t(mFile.tellp()) : 0;
+}
+
+//___________________________________________________________________
+void RawTFDump::prepareTFFile()
+{
+  if (!mWriteTF) {
+    return;
+  }
+  bool needToOpen;
+  if (!mFile.is_open()) {
+    needToOpen = true;
+  } else {
+    auto currSize = getCurrentFileSize();
+    if ((mNTFsInFile >= mMaxTFPerFile) ||
+        (currSize >= mMinFileSize) ||                                                         // min size exceeded, may close the file.
+        (currSize && mMaxFileSize > mMinFileSize && ((currSize + mTFSize) > mMaxFileSize))) { // this is not the 1st TF in the file and the new size will exceed allowed max
+      needToOpen = true;
+    } else {
+      LOGP(info, "Will add new TF of size {} to existing file of size {} with {} TFs", mTFSize, currSize, mNTFsInFile);
+      needToOpen = false;
+    }
+  }
+  if (needToOpen) {
+    closeTFFile();
+    auto TFDir = mTFDir.empty() ? o2::utils::Str::rectifyDirectory("./") : mTFDir;
+    if (mCreateRunEnvDir && !mDataTakingContext.envId.empty() && (mDataTakingContext.envId != o2::framework::DataTakingContext::UNKNOWN)) {
+      TFDir += fmt::format("{}_{}tf/", mDataTakingContext.envId, mDataTakingContext.runNumber);
+      if (!TFDir.empty()) {
+        o2::utils::createDirectoriesIfAbsent(TFDir);
+        LOGP(info, "Created {} directory for TFs output", TFDir);
+      }
+    }
+    mCurrentTFFileName = o2::base::NameConf::getRawTFFileName(mTimingInfo.runNumber, mTimingInfo.firstTForbit, mTimingInfo.tfCounter, mHostName);
+    mCurrentTFFileNameFull = fmt::format("{}{}", TFDir, mCurrentTFFileName);
+    mCurrentTFFileNameFullTmp = TMPFileEnding.empty() ? mCurrentTFFileNameFull : o2::utils::Str::concat_string(mCurrentTFFileNameFull, TMPFileEnding);
+    mFile.open(mCurrentTFFileNameFullTmp.c_str(), ios::binary | ios::trunc | ios::out | ios::ate);
+    LOGP(info, "Opened new raw-tf dump file {}[{}]", mCurrentTFFileNameFull, TMPFileEnding);
+    mNTFFiles++;
+  }
+}
+
+//___________________________________________________________________
+void RawTFDump::updateTimeDependentParams(ProcessingContext& pc)
+{
+  namespace GRPECS = o2::parameters::GRPECS;
+  mTimingInfo = pc.services().get<o2::framework::TimingInfo>();
+  if (mTimingInfo.globalRunNumberChanged) {
+    mDataTakingContext = pc.services().get<DataTakingContext>();
+    // determine the output type for the TF metadata
+    mMetaDataType = GRPECS::getRawDataPersistencyMode(mDataTakingContext.runType, mDataTakingContext.forcedRaw);
+  }
+}
+
+//___________________________________________________________________
+void RawTFDump::closeTFFile()
+{
+  if (!mFile.is_open()) {
+    return;
+  }
+  try {
+    LOGP(info, "Closing output file {}[{}]", mCurrentTFFileNameFull, TMPFileEnding);
+    mFile.close();
+    // write TF file metaFile data
+    if (mStoreMetaFile) {
+      o2::dataformats::FileMetaData TFMetaData;
+      if (!TFMetaData.fillFileData(mCurrentTFFileNameFullTmp, mFillMD5, TMPFileEnding)) {
+        throw std::runtime_error("metadata file was requested but not created");
+      }
+      TFMetaData.setDataTakingContext(mDataTakingContext);
+      TFMetaData.type = mMetaDataType;
+      TFMetaData.priority = "high";
+      TFMetaData.tfOrbits.swap(mTFOrbits);
+      auto metaFileNameTmp = fmt::format("{}{}.tmp", mTFMetaFileDir, mCurrentTFFileName);
+      auto metaFileName = fmt::format("{}{}.done", mTFMetaFileDir, mCurrentTFFileName);
+      try {
+        std::ofstream metaFileOut(metaFileNameTmp);
+        metaFileOut << TFMetaData;
+        metaFileOut.close();
+        if (!TMPFileEnding.empty()) {
+          std::filesystem::rename(mCurrentTFFileNameFullTmp, mCurrentTFFileNameFull);
+        }
+        std::filesystem::rename(metaFileNameTmp, metaFileName);
+        LOGP(info, "wrote meta file {}", metaFileName);
+      } catch (std::exception const& e) {
+        LOGP(error, "Failed to store TF meta data file {}, reason {}", metaFileName, e.what());
+      }
+    } else if (!TMPFileEnding.empty()) {
+      std::filesystem::rename(mCurrentTFFileNameFullTmp, mCurrentTFFileNameFull);
+    }
+  } catch (std::exception const& e) {
+    LOGP(error, "Failed to finalize TF file {}, reason: ", mCurrentTFFileNameFull, e.what());
+  }
+  mTFOrbits.clear();
+  mNTFsInFile = 0;
+}
+
+//________________________________________
+bool RawTFDump::checkFreeSpace(ProcessingContext& pc)
+{
+  int totalWait = 0, nwaitCycles = 0;
+  while (mCheckDiskFull) {
+    constexpr int showFirstN = 10, prsecaleWarnings = 50;
+    try {
+      const auto si = std::filesystem::space(mCurrentTFFileNameFullTmp);
+      std::string wmsg{};
+      if (mCheckDiskFull > 0.f && si.available < mCheckDiskFull) {
+        nwaitCycles++;
+        wmsg = fmt::format("Disk has {} MiB available while at least {} MiB is requested, wait for {} ms (on top of {} ms)", si.available / MiB, size_t(mCheckDiskFull) / MiB, mWaitDiskFull, totalWait);
+      } else if (mCheckDiskFull < 0.f && float(si.available) / si.capacity < -mCheckDiskFull) { // relative margin requested
+        nwaitCycles++;
+        wmsg = fmt::format("Disk has {:.3f}% available while at least {:.3f}% is requested, wait for {} ms (on top of {} ms)", si.capacity ? float(si.available) / si.capacity * 100.f : 0., -mCheckDiskFull, mWaitDiskFull, totalWait);
+      } else {
+        nwaitCycles = 0;
+      }
+      if (nwaitCycles) {
+        if (mWaitDiskFullMax > 0 && totalWait > mWaitDiskFullMax) {
+          closeTFFile(); // try to save whatever we have
+          LOGP(fatal, "Disk has {} MiB available out of {} MiB after waiting for {} ms", si.available / MiB, si.capacity / MiB, mWaitDiskFullMax);
+        }
+        if (nwaitCycles < showFirstN + 1 || (prsecaleWarnings && (nwaitCycles % prsecaleWarnings) == 0)) {
+          LOGP(alarm, "{}", wmsg);
+        }
+        pc.services().get<RawDeviceService>().waitFor((unsigned int)(mWaitDiskFull));
+        totalWait += mWaitDiskFull;
+        continue;
+      }
+    } catch (std::exception const& e) {
+      LOGP(fatal, "unable to query disk space info for path {}, reason {}", mCurrentTFFileNameFull, e.what()); // do we want this?
+    }
+    break;
+  }
+  return true;
+}
+
+//________________________________________
+bool RawTFDump::triggerTF(ProcessingContext& pc)
+{
+  bool trig = false;
+  if (mTrigger.empty()) { // random
+    if (mMaxAccRate > 0.f) {
+      trig = (mUniformDist(mRGen) <= mMaxAccRate);
+    } else if (mMaxAccRate < 0.f) {
+      trig = (mTimingInfo.tfCounter % int(std::ceil(-100.f / mMaxAccRate))) == 0;
+    }
+  } else {
+    for (auto const& ref : InputRecordWalker(pc.inputs(), mTriggerFilter)) {
+      auto const* dh = DataRefUtils::getHeader<DataHeader*>(ref);
+      if (!dh) {
+        LOGP(error, "Failed to extract header for trigger input");
+        continue;
+      }
+      auto extTrig = DataRefUtils::as<bool>(ref);
+      if (mVerbose > 0) {
+        LOGP(info, "trigger input {}, part: {} of {}, payload {}, 1stTFOrbit: {} TF: {} | span size: {} span[0]={}",
+             DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}),
+             dh->splitPayloadIndex, dh->splitPayloadParts, dh->payloadSize, dh->firstTForbit, dh->tfCounter, extTrig.size(), extTrig.size() > 0 ? extTrig[0] : false);
+      }
+      if (extTrig.size() && extTrig[0]) {
+        trig = true;
+        break;
+      }
+    }
+    if (trig) { // do we need to throttle?
+      mNTFsExtTrig++;
+      mRateEstTrgLow = TMath::ChisquareQuantile(mConfLim, 2 * (mNTFsExtTrig)) / (2 * mNTFsSeen);
+      mRateEstTrgUpp = TMath::ChisquareQuantile(1. - mConfLim, 2 * (mNTFsExtTrig + 1)) / (2 * mNTFsSeen);
+      mRateEstAccLow = TMath::ChisquareQuantile(mConfLim, 2 * (mNTFsAccepted)) / (2 * mNTFsSeen);
+      mRateEstAccUpp = TMath::ChisquareQuantile(1. - mConfLim, 2 * (mNTFsAccepted + 1)) / (2 * mNTFsSeen);
+      if (mRateEstAccLow > 0.01 * mMaxAccRate) { // current lowest estimate on the acceptance rate exceeds desired limit -> ignore trigger
+        trig = false;
+        // do we need to warn?
+        if ((mNTFsSeen - mLastWarned) > mWarnThrottleTF && ((mNWarnThrottle < mMaxWarnThrottle) || mMaxWarnThrottle < 0)) {
+          mLastWarned = mNTFsSeen;
+          std::string swarn = reportRates();
+          if (++mNWarnThrottle == mMaxWarnThrottle) {
+            swarn += " Will not warn anymore.";
+          } else {
+            swarn += fmt::format(" Will suppress this warnings for {} TFs", mWarnThrottleTF);
+          }
+          LOGP(alarm, "Ignoring TF triggered for dumping: {}", swarn);
+        }
+      }
+    }
+  }
+  if (trig) {
+    mNTFsAccepted++;
+  }
+  if (mVerbose > 0) {
+    LOGP(info, "TF#{} (slice#{}) will{} be written, {}", mTimingInfo.tfCounter, mTimingInfo.timeslice, trig ? "" : " not", reportRates());
+  }
+  return trig;
+}
+
+//________________________________________
+void RawTFDump::prepareTFForWriting(ProcessingContext& pc)
+{
+  for (auto const& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+    auto const* dh = DataRefUtils::getHeader<DataHeader*>(ref);
+    if (!dh) {
+      LOGP(error, "Failed to extract header");
+      continue;
+    }
+    if (dh->subSpecification == 0xdeadbeef && mRejectDEADBEEF) {
+      continue;
+    }
+    const auto lHdrDataSize = sizeof(DataHeader) + dh->payloadSize;
+    mTFSize += lHdrDataSize;
+
+    auto& [lSize, lCnt, lEntry] = mDataMap[EquipmentIdentifier(*dh)];
+    if (!lCnt) {
+      lEntry = mTFData.size(); // flag where the data of this spec starts
+    }
+    lSize += lHdrDataSize;
+    lCnt++;
+    mTFData.push_back({ref.header, ref.payload});
+    if (mVerbose > 2) {
+      LOGP(info, "{}, part: {} of {}, payload {}, 1stTFOrbit: {} TF: {}",
+           DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}),
+           dh->splitPayloadIndex, dh->splitPayloadParts, dh->payloadSize, dh->firstTForbit, dh->tfCounter);
+    }
+  }
+
+  // build the index
+  {
+    LOGP(info, "Creating dump image for TF {} of run {}, starting orbit {}, size = {}", mTimingInfo.tfCounter, mTimingInfo.runNumber, mTimingInfo.firstTForbit, mTFSize);
+    std::uint64_t lCurrOff = 0;
+    for (const auto& eqEntry : mDataMap) {
+      const auto& eq = eqEntry.first;
+      auto& [lSize, lCnt, lEntry] = eqEntry.second;
+      assert(lSize > sizeof(DataHeader));
+
+      OutputSpec spec{eq.mDataOrigin, eq.mDataDescription, eq.mSubSpecification};
+      if (mVerbose > 1) {
+        LOGP(info, "{} : {} parts of size {} | offset: {}", DataSpecUtils::describe(spec), lCnt, lSize, lCurrOff);
+      }
+      mTFDataIndex.AddStfElement(eq, lCnt, lCurrOff, lSize);
+      lCurrOff += lSize;
+    }
+  }
+}
+
+//____________________________________________________________
+std::string RawTFDump::reportRates() const
+{
+  std::string rep = fmt::format("{} TFs seen, {} accepted", mNTFsSeen, mNTFsAccepted);
+  if (!mTrigger.empty()) {
+    rep += fmt::format(", {} ext.triggered,  est.rate: [{:.2e}:{:.2e}]/[{:.2e}:{:.2e}].", mNTFsExtTrig, mRateEstAccLow, mRateEstAccUpp, mRateEstTrgLow, mRateEstTrgUpp);
+  }
+  return rep;
+}
+
+//__________________________________________________________
+DataProcessorSpec getRawTFDumpSpec(const std::string& inpconfig, const std::string& trigger)
+{
+  std::vector<InputSpec> inputs = select(inpconfig.c_str());
+  return DataProcessorSpec{
+    "raw-tf-dump",
+    inputs,
+    {},
+    AlgorithmSpec{adaptFromTask<RawTFDump>(trigger)},
+    Options{
+      {"include-deadbeef", VariantType::Bool, false, {"Include DPL-generated 0xdeadbeef subspecs for missing data"}},
+      {"max-dump-rate", VariantType::Float, 0.f, {"%-age of TFs to dump. W/o external trigger: random(>0) or periodic(<0) rejection, with: max limit"}},
+      {"rate-est-conf-limit", VariantType::Float, 0.05f, {"quantile for the lowest rate estimate confidence limit"}},
+      {"max-warn", VariantType::Int, 5, {"max allowed warnings on throttling"}},
+      {"mute-warn-period", VariantType::Int, 100, {"mute warnings on throttling for this number of TFs"}},
+      {"output-dir", VariantType::String, "none", {"TF output directory, must exist"}},
+      {"meta-output-dir", VariantType::String, "/dev/null", {"TF metadata output directory, must exist (if not /dev/null)"}},
+      {"md5-for-meta", VariantType::Bool, false, {"fill CTF file MD5 sum in the metadata file"}},
+      {"min-file-size", VariantType::Int64, 0l, {"accumulate TFs until given file size reached"}},
+      {"max-file-size", VariantType::Int64, 0l, {"if > 0, try to avoid exceeding given file size, also used for space check"}},
+      {"max-tf-per-file", VariantType::Int, 0, {"if > 0, avoid storing more than requested CTFs per file"}},
+      {"require-free-disk", VariantType::Float, 0.f, {"pause writing op. if available disk space is below this margin, in bytes if >0, as a fraction of total if <0"}},
+      {"wait-for-free-disk", VariantType::Float, 10.f, {"if paused due to the low disk space, recheck after this time (in s)"}},
+      {"max-wait-for-free-disk", VariantType::Float, 60.f, {"produce fatal if paused due to the low disk space for more than this amount in s."}},
+      {"verbosity-level", VariantType::Int, 0, {"Verbose mode: 1: decision on every TF, 2: details of saved TF, 3: more details"}},
+      {"ignore-partition-run-dir", VariantType::Bool, false, {"Do not creare partition-run directory in output-dir"}}}};
+}
+
+} // namespace o2::rawdd
diff --git a/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.h b/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.h
new file mode 100644
index 0000000000000..a39cfb026ed52
--- /dev/null
+++ b/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.h
@@ -0,0 +1,23 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_RAW_TF_DUMP_SPEC_
+#define O2_RAW_TF_DUMP_SPEC_
+
+#include "DetectorsCommonDataFormats/DetID.h"
+#include "Framework/DeviceSpec.h"
+
+namespace o2::rawdd
+{
+o2::framework::DataProcessorSpec getRawTFDumpSpec(const std::string& inpconfig, const std::string& trigger);
+}
+
+#endif
diff --git a/Detectors/Raw/TFReaderDD/src/SubTimeFrameFileReader.cxx b/Detectors/Raw/TFReaderDD/src/SubTimeFrameFileReader.cxx
index f227390e67ef3..5f862dffe512f 100644
--- a/Detectors/Raw/TFReaderDD/src/SubTimeFrameFileReader.cxx
+++ b/Detectors/Raw/TFReaderDD/src/SubTimeFrameFileReader.cxx
@@ -115,7 +115,7 @@ std::size_t SubTimeFrameFileReader::getHeaderStackSize() // throws ios_base::fai
     LOGP(error, "FileReader: Reached max number of headers allowed: {}.", cMaxHeaders);
     return 0;
   }
-
+  LOGP(debug, "getHeaderStackSize, pos = {}, size = {}", lFilePosStart, lStackSize);
   return lStackSize;
 }
 
@@ -252,6 +252,7 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
     return nullptr;
   }
   lStfMetaDataHdr = o2::header::DataHeader::Get(lMetaHdrStack.first());
+  LOGP(debug, "read filemeta, pos = {}, size = {}", position(), sizeof(SubTimeFrameFileMeta));
   if (!read_advance(&lStfFileMeta, sizeof(SubTimeFrameFileMeta))) {
     return nullptr;
   }
@@ -320,7 +321,6 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
   STFHeader stfHeader{tfID, -1u, -1u};
   // read <hdrStack + data> pairs
   while (lLeftToRead > 0) {
-
     // allocate and read the Headers
     std::size_t lDataHeaderStackSize = 0;
     Stack lDataHeaderStack = getHeaderStack(lDataHeaderStackSize);
@@ -398,6 +398,7 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
     msgSW.Stop();
 #endif
     memcpy(lHdrStackMsg->GetData(), headerStack.data(), headerStack.size());
+    LOGP(debug, "read data, pos = {}, size = {} leftToRead {}", position(), lDataSize, lLeftToRead);
 
     if (!read_advance(lDataMsg->GetData(), lDataSize)) {
       return nullptr;
diff --git a/Detectors/Raw/TFReaderDD/src/tf-data-dump-workflow.cxx b/Detectors/Raw/TFReaderDD/src/tf-data-dump-workflow.cxx
new file mode 100644
index 0000000000000..fbade100d202f
--- /dev/null
+++ b/Detectors/Raw/TFReaderDD/src/tf-data-dump-workflow.cxx
@@ -0,0 +1,46 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "CommonUtils/ConfigurableParam.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/CompletionPolicy.h"
+#include "Framework/CompletionPolicyHelpers.h"
+
+using namespace o2::framework;
+
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::vector<ConfigParamSpec> options;
+  options.push_back(ConfigParamSpec{"dataspec", VariantType::String, "tst:TST/A", {"selection string for the data to be proxied"}});
+  options.push_back(ConfigParamSpec{"triggerspec", VariantType::String, "", {"selection string for the trigger input (must be also in dataspec if non-empty)"}});
+  options.push_back(ConfigParamSpec{"configKeyValues", VariantType::String, "", {"semicolon separated key=value strings"}});
+  std::swap(workflowOptions, options);
+}
+
+void customize(std::vector<CompletionPolicy>& policies)
+{
+  policies.push_back({CompletionPolicyHelpers::consumeWhenPastOldestPossibleTimeframe("raw-tf-dump", [](auto const&) -> bool { return true; })});
+  // policies.push_back({CompletionPolicyHelpers::consumeWhenAllOrdered("raw-tf-dump", [](auto const&) -> bool { return true; })}); // RSTOREM
+}
+
+// ------------------------------------------------------------------
+
+#include "Framework/runDataProcessing.h"
+#include "RawTFDumpSpec.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
+{
+  o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
+  auto inpconfig = configcontext.options().get<std::string>("dataspec");
+  auto trigger = configcontext.options().get<std::string>("triggerspec");
+  WorkflowSpec specs{o2::rawdd::getRawTFDumpSpec(inpconfig, trigger)};
+  return specs;
+}
diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index ca466d311ed30..3619cc38a0c09 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -71,6 +71,50 @@ elif [[ -z ${SYNCRAWMODE:-} ]]; then
   SYNCRAWMODE=0
 fi
 
+# ---------------------------------------------------------------------------------------------------------------------
+# build incoming raw inputs specs
+define_raw_inputs()
+{
+  PROXY_INSPEC="dd:FLP/DISTSUBTIMEFRAME/0"
+  PROXY_IN_N=0
+  for i in ${INPUT_DETECTOR_LIST//,/ }; do
+    if has_detector_flp_processing $i; then
+      case $i in
+        TOF)
+          PROXY_INTYPE="CRAWDATA";;
+        FT0 | FV0 | FDD)
+          PROXY_INTYPE="DIGITSBC/0 DIGITSCH/0";;
+        PHS)
+          PROXY_INTYPE="CELLS CELLTRIGREC";;
+        CPV)
+          PROXY_INTYPE="DIGITS/0 DIGITTRIGREC/0 RAWHWERRORS";;
+        EMC)
+          PROXY_INTYPE="CELLS/0 CELLSTRGR/0 DECODERERR";;
+        CTP)
+          PROXY_INTYPE="LUMI/0 RAWDATA"
+          CTP_CONFIG=" --no-lumi "
+          ;;
+        *)
+          echo Input type for detector $i with FLP processing not defined 1>&2
+          exit 1;;
+      esac
+    else
+      PROXY_INTYPE=RAWDATA
+    fi
+    for j in $PROXY_INTYPE; do
+      PROXY_INNAME="RAWIN$PROXY_IN_N"
+      let PROXY_IN_N=$PROXY_IN_N+1
+      PROXY_INSPEC+=";$PROXY_INNAME:$i/$j"
+    done
+  done
+  # do we have DPL_RAWTFDUMP_TRIGGER trigger (e.g. TPC/CMVTRIGGER)? If so, add its spec
+  if has_detector TPC && [[ -n ${DPL_RAWTFDUMP_TRIGGER:-} ]]; then
+    PROXY_INNAME="RAWIN$PROXY_IN_N"
+    let PROXY_IN_N=$PROXY_IN_N+1
+    PROXY_INSPEC+=";$PROXY_INNAME:${DPL_RAWTFDUMP_TRIGGER}"
+  fi
+}
+
 # ---------------------------------------------------------------------------------------------------------------------
 # Set some individual workflow arguments depending on configuration
 GPU_INPUT=zsraw
@@ -109,6 +153,7 @@ EVE_OPT=" --jsons-folder $EDJSONS_DIR"
 : ${ALPIDE_ERR_DUMPS:=}
 : ${ITSSTAGGERED:=}
 : ${MFTSTAGGERED:=}
+: ${PROXY_INSPEC:=}
 
 [[ -z $ALPIDE_ERR_DUMPS ]] && [[ $EPNSYNCMODE == 1 && $RUNTYPE == "PHYSICS" ]] && ALPIDE_ERR_DUMPS=1 || ALPIDE_ERR_DUMPS=0
 
@@ -483,38 +528,7 @@ if [[ -n $INPUT_DETECTOR_LIST ]]; then
     add_W o2-raw-tf-reader-workflow "--delay $TFDELAY $TFRAWOPT --loop $TFLOOP $NTIMEFRAMES_CMD --input-data ${TFName} ${INPUT_FILE_COPY_CMD+--copy-cmd} ${INPUT_FILE_COPY_CMD:-} --onlyDet $INPUT_DETECTOR_LIST ${TIMEFRAME_SHM_LIMIT+--timeframes-shm-limit} ${TIMEFRAME_SHM_LIMIT:-}"
   elif [[ $EXTINPUT == 1 ]]; then
     PROXY_CHANNEL="name=readout-proxy,type=pull,method=connect,address=ipc://${UDS_PREFIX}${INRAWCHANNAME},transport=shmem,rateLogging=$EPNSYNCMODE"
-    PROXY_INSPEC="dd:FLP/DISTSUBTIMEFRAME/0"
-    PROXY_IN_N=0
-    for i in ${INPUT_DETECTOR_LIST//,/ }; do
-      if has_detector_flp_processing $i; then
-        case $i in
-          TOF)
-            PROXY_INTYPE="CRAWDATA";;
-          FT0 | FV0 | FDD)
-            PROXY_INTYPE="DIGITSBC/0 DIGITSCH/0";;
-          PHS)
-            PROXY_INTYPE="CELLS CELLTRIGREC";;
-          CPV)
-            PROXY_INTYPE="DIGITS/0 DIGITTRIGREC/0 RAWHWERRORS";;
-          EMC)
-            PROXY_INTYPE="CELLS/0 CELLSTRGR/0 DECODERERR";;
-          CTP)
-            PROXY_INTYPE="LUMI/0 RAWDATA"
-            CTP_CONFIG=" --no-lumi "
-            ;;
-          *)
-            echo Input type for detector $i with FLP processing not defined 1>&2
-            exit 1;;
-        esac
-      else
-        PROXY_INTYPE=RAWDATA
-      fi
-      for j in $PROXY_INTYPE; do
-        PROXY_INNAME="RAWIN$PROXY_IN_N"
-        let PROXY_IN_N=$PROXY_IN_N+1
-        PROXY_INSPEC+=";$PROXY_INNAME:$i/$j"
-      done
-    done
+    define_raw_inputs
     [[ -n ${TIMEFRAME_RATE_LIMIT:-} ]] && [[ $TIMEFRAME_RATE_LIMIT != 0 ]] && PROXY_CHANNEL+=";name=metric-feedback,type=pull,method=connect,address=ipc://${UDS_PREFIX}metric-feedback-${O2JOBID:-$NUMAID},transport=shmem,rateLogging=0"
     if [[ $EPNSYNCMODE == 1 ]]; then
       RAWPROXY_CONFIG="--print-input-sizes 1000"
@@ -544,8 +558,18 @@ if [[ -z ${WORKFLOW_DETECTORS_USE_GLOBAL_READER_TRACKS} ]] && [[ -z ${WORKFLOW_D
 fi
 
 # ---------------------------------------------------------------------------------------------------------------------
-# Raw decoder workflows - disabled in async mode
+
 if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
+# Check if raw TF data dump was requested, RAWTF_DUMPRATE must be in %
+  if [[ ${DPL_RAWTFDUMP:-} == 1 ]]; then
+     [[ -z ${PROXY_INSPEC} ]] && define_raw_inputs
+     CONFIG_RAWTFDUMP="--dataspec \"${PROXY_INSPEC}\" --output-dir \"${RAWTF_DIR:-$CTF_DIR}\" --meta-output-dir \"${EPN2EOS_METAFILES_DIR}\" --max-dump-rate ${RAWTF_DUMPRATE:-0.1} "
+     CONFIG_RAWTFDUMP+=" --min-file-size ${RAWTF_MINSIZE:-$CTF_MINSIZE} --max-tf-per-file ${RAWTF_MAX_PER_FILE:-$CTF_MAX_PER_FILE} --mute-warn-period ${RAWTF_MUTE_PERIOD:-200} --max-warn ${RAWTF_MAX_WARN:-5} "
+     [[ -n ${DPL_RAWTFDUMP_TRIGGER:-} ]] && CONFIG_RAWTFDUMP+=" --triggerspec \"${DPL_RAWTFDUMP_TRIGGER}\" "
+     add_W o2-raw-tf-dump-workflow "$CONFIG_RAWTFDUMP"
+  fi
+
+# Raw decoder workflows - disabled in async mode
   if has_detector TPC && [[ "${TPC_CONVERT_LINKZS_TO_RAW:-}" == "1" ]]; then
     GPU_INPUT=zsonthefly
     RAWTODIGITOPTIONS=

From 3159c533bd690d8713692722982ae405190069f8 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sun, 10 May 2026 10:06:51 +0200
Subject: [PATCH 1723/1764] ITS: simplify Configuration

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         | 46 ++++-----
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  4 +-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 96 +++++++++----------
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 94 +++++++++---------
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 20 ++--
 .../include/ITStracking/Configuration.h       | 19 +++-
 .../tracking/include/ITStracking/TimeFrame.h  |  2 +-
 .../include/ITStracking/TrackerTraits.h       |  3 +-
 .../include/ITStracking/TrackingInterface.h   |  6 +-
 .../include/ITStracking/VertexerTraits.h      | 24 +----
 .../ITSMFT/ITS/tracking/src/Configuration.cxx | 18 +++-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     |  8 +-
 Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx |  2 +-
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx |  8 +-
 .../ITS/tracking/src/TrackingInterface.cxx    |  8 +-
 .../ITSMFT/ITS/tracking/src/Vertexer.cxx      | 11 ++-
 .../ITS/tracking/src/VertexerTraits.cxx       | 11 ++-
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   |  4 +-
 18 files changed, 210 insertions(+), 174 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 8852810399eeb..1ecff79f2d200 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -42,30 +42,30 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void popMemoryStack(const int);
   void registerHostMemory(const int);
   void unregisterHostMemory(const int);
-  void initialise(const int, const TrackingParameters&, const int);
-  void loadIndexTableUtils(const int);
-  void loadTrackingFrameInfoDevice(const int, const int);
-  void createTrackingFrameInfoDeviceArray(const int);
-  void loadUnsortedClustersDevice(const int, const int);
-  void createUnsortedClustersDeviceArray(const int, const int = NLayers);
-  void loadClustersDevice(const int, const int);
-  void createClustersDeviceArray(const int, const int = NLayers);
-  void loadClustersIndexTables(const int, const int);
-  void createClustersIndexTablesArray(const int);
-  void createUsedClustersDevice(const int, const int);
-  void createUsedClustersDeviceArray(const int, const int = NLayers);
+  void initialise(const TrackingParameters&, int maxLayers);
+  void loadIndexTableUtils();
+  void loadTrackingFrameInfoDevice(const int);
+  void createTrackingFrameInfoDeviceArray();
+  void loadUnsortedClustersDevice(const int);
+  void createUnsortedClustersDeviceArray(const int = NLayers);
+  void loadClustersDevice(const int);
+  void createClustersDeviceArray(const int = NLayers);
+  void loadClustersIndexTables(const int);
+  void createClustersIndexTablesArray();
+  void createUsedClustersDevice(const int);
+  void createUsedClustersDeviceArray(const int = NLayers);
   void loadUsedClustersDevice();
-  void loadROFrameClustersDevice(const int, const int);
-  void createROFrameClustersDeviceArray(const int);
+  void loadROFrameClustersDevice(const int);
+  void createROFrameClustersDeviceArray();
   void loadROFCutMask(const int);
-  void loadVertices(const int);
-  void loadROFOverlapTable(const int);
-  void loadROFVertexLookupTable(const int);
-  void updateROFVertexLookupTable(const int);
+  void loadVertices();
+  void loadROFOverlapTable();
+  void loadROFVertexLookupTable();
+  void updateROFVertexLookupTable();
 
   ///
-  void createTrackletsLUTDevice(const int, const int);
-  void createTrackletsLUTDeviceArray(const int);
+  void createTrackletsLUTDevice(bool, const int);
+  void createTrackletsLUTDeviceArray();
   void loadTrackletsDevice();
   void loadTrackletsLUTDevice();
   void loadCellsDevice();
@@ -74,12 +74,12 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void loadTrackSeedsChi2Device();
   void loadTrackSeedsDevice(bounded_vector<TrackSeedN>&);
   void createTrackletsBuffers(const int);
-  void createTrackletsBuffersArray(const int);
+  void createTrackletsBuffersArray();
   void createCellsBuffers(const int);
-  void createCellsBuffersArray(const int);
+  void createCellsBuffersArray();
   void createCellsDevice();
   void createCellsLUTDevice(const int);
-  void createCellsLUTDeviceArray(const int);
+  void createCellsLUTDeviceArray();
   void createNeighboursIndexTablesDevice(const int);
   void createNeighboursDevice(const unsigned int layer);
   void createNeighboursLUTDevice(const int, const unsigned int);
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index bf004426f9134..fe272f6f8d3bb 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -51,7 +51,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  const int** clustersIndexTables,
                                  int** trackletsLUTs,
                                  gsl::span<int*> trackletsLUTsHost,
-                                 const int iteration,
+                                 const bool selectUPCVertices,
                                  const float NSigmaCut,
                                  bounded_vector<float>& phiCuts,
                                  const float resolutionPV,
@@ -82,7 +82,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    gsl::span<int> nTracklets,
                                    int** trackletsLUTs,
                                    gsl::span<int*> trackletsLUTsHost,
-                                   const int iteration,
+                                   const bool selectUPCVertices,
                                    const float NSigmaCut,
                                    bounded_vector<float>& phiCuts,
                                    const float resolutionPV,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index 03957cd678df0..b541518a88119 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -52,10 +52,10 @@ void TimeFrameGPU<NLayers>::allocMem(void** ptr, size_t size, bool extAllocator,
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadIndexTableUtils(const int iteration)
+void TimeFrameGPU<NLayers>::loadIndexTableUtils()
 {
   GPUTimer timer("loading indextable utils");
-  if (!iteration) {
+  {
     GPULog("gpu-allocation: allocating IndexTableUtils buffer, for {:.2f} MB.", sizeof(IndexTableUtilsN) / constants::MB);
     allocMem(reinterpret_cast<void**>(&mIndexTableUtilsDevice), sizeof(IndexTableUtilsN), this->hasFrameworkAllocator());
   }
@@ -64,9 +64,9 @@ void TimeFrameGPU<NLayers>::loadIndexTableUtils(const int iteration)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createUnsortedClustersDeviceArray(const int iteration, const int maxLayers)
+void TimeFrameGPU<NLayers>::createUnsortedClustersDeviceArray(const int maxLayers)
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating unsorted clusters array");
     allocMem(reinterpret_cast<void**>(&mUnsortedClustersDeviceArray), NLayers * sizeof(Cluster*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mUnsortedClustersDevice.data(), NLayers * sizeof(Cluster*), cudaHostRegisterPortable));
@@ -81,9 +81,9 @@ void TimeFrameGPU<NLayers>::createUnsortedClustersDeviceArray(const int iteratio
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadUnsortedClustersDevice(const int iteration, const int layer)
+void TimeFrameGPU<NLayers>::loadUnsortedClustersDevice(const int layer)
 {
-  if (!iteration) {
+  {
     GPUTimer timer(mGpuStreams[layer], "loading unsorted clusters", layer);
     GPULog("gpu-transfer: loading {} unsorted clusters on layer {}, for {:.2f} MB.", this->mUnsortedClusters[layer].size(), layer, this->mUnsortedClusters[layer].size() * sizeof(Cluster) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mUnsortedClustersDevice[layer]), this->mUnsortedClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->hasFrameworkAllocator());
@@ -93,9 +93,9 @@ void TimeFrameGPU<NLayers>::loadUnsortedClustersDevice(const int iteration, cons
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createClustersDeviceArray(const int iteration, const int maxLayers)
+void TimeFrameGPU<NLayers>::createClustersDeviceArray(const int maxLayers)
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating sorted clusters array");
     allocMem(reinterpret_cast<void**>(&mClustersDeviceArray), NLayers * sizeof(Cluster*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mClustersDevice.data(), NLayers * sizeof(Cluster*), cudaHostRegisterPortable));
@@ -110,9 +110,9 @@ void TimeFrameGPU<NLayers>::createClustersDeviceArray(const int iteration, const
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadClustersDevice(const int iteration, const int layer)
+void TimeFrameGPU<NLayers>::loadClustersDevice(const int layer)
 {
-  if (!iteration) {
+  {
     GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
     GPULog("gpu-transfer: loading {} clusters on layer {}, for {:.2f} MB.", this->mClusters[layer].size(), layer, this->mClusters[layer].size() * sizeof(Cluster) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mClustersDevice[layer]), this->mClusters[layer].size() * sizeof(Cluster), mGpuStreams[layer], this->hasFrameworkAllocator());
@@ -122,9 +122,9 @@ void TimeFrameGPU<NLayers>::loadClustersDevice(const int iteration, const int la
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createClustersIndexTablesArray(const int iteration)
+void TimeFrameGPU<NLayers>::createClustersIndexTablesArray()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating clustersindextable array");
     allocMem(reinterpret_cast<void**>(&mClustersIndexTablesDeviceArray), NLayers * sizeof(int*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mClustersIndexTablesDevice.data(), NLayers * sizeof(int*), cudaHostRegisterPortable));
@@ -139,9 +139,9 @@ void TimeFrameGPU<NLayers>::createClustersIndexTablesArray(const int iteration)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadClustersIndexTables(const int iteration, const int layer)
+void TimeFrameGPU<NLayers>::loadClustersIndexTables(const int layer)
 {
-  if (!iteration) {
+  {
     GPUTimer timer(mGpuStreams[layer], "loading sorted clusters", layer);
     GPULog("gpu-transfer: loading clusters indextable for layer {} with {} elements, for {:.2f} MB.", layer, this->mIndexTables[layer].size(), this->mIndexTables[layer].size() * sizeof(int) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mClustersIndexTablesDevice[layer]), this->mIndexTables[layer].size() * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator());
@@ -151,9 +151,9 @@ void TimeFrameGPU<NLayers>::loadClustersIndexTables(const int iteration, const i
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createUsedClustersDeviceArray(const int iteration, const int maxLayers)
+void TimeFrameGPU<NLayers>::createUsedClustersDeviceArray(const int maxLayers)
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating used clusters flags");
     allocMem(reinterpret_cast<void**>(&mUsedClustersDeviceArray), NLayers * sizeof(uint8_t*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mUsedClustersDevice.data(), NLayers * sizeof(uint8_t*), cudaHostRegisterPortable));
@@ -168,9 +168,9 @@ void TimeFrameGPU<NLayers>::createUsedClustersDeviceArray(const int iteration, c
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createUsedClustersDevice(const int iteration, const int layer)
+void TimeFrameGPU<NLayers>::createUsedClustersDevice(const int layer)
 {
-  if (!iteration) {
+  {
     GPUTimer timer(mGpuStreams[layer], "creating used clusters flags", layer);
     GPULog("gpu-transfer: creating {} used clusters flags on layer {}, for {:.2f} MB.", this->mUsedClusters[layer].size(), layer, this->mUsedClusters[layer].size() * sizeof(unsigned char) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mUsedClustersDevice[layer]), this->mUsedClusters[layer].size() * sizeof(unsigned char), mGpuStreams[layer], this->hasFrameworkAllocator());
@@ -190,9 +190,9 @@ void TimeFrameGPU<NLayers>::loadUsedClustersDevice()
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createROFrameClustersDeviceArray(const int iteration)
+void TimeFrameGPU<NLayers>::createROFrameClustersDeviceArray()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating ROFrame clusters array");
     allocMem(reinterpret_cast<void**>(&mROFramesClustersDeviceArray), NLayers * sizeof(int*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mROFramesClustersDevice.data(), NLayers * sizeof(int*), cudaHostRegisterPortable));
@@ -207,9 +207,9 @@ void TimeFrameGPU<NLayers>::createROFrameClustersDeviceArray(const int iteration
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadROFrameClustersDevice(const int iteration, const int layer)
+void TimeFrameGPU<NLayers>::loadROFrameClustersDevice(const int layer)
 {
-  if (!iteration) {
+  {
     GPUTimer timer(mGpuStreams[layer], "loading ROframe clusters", layer);
     GPULog("gpu-transfer: loading {} ROframe clusters info on layer {}, for {:.2f} MB.", this->mROFramesClusters[layer].size(), layer, this->mROFramesClusters[layer].size() * sizeof(int) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mROFramesClustersDevice[layer]), this->mROFramesClusters[layer].size() * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator());
@@ -219,9 +219,9 @@ void TimeFrameGPU<NLayers>::loadROFrameClustersDevice(const int iteration, const
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createTrackingFrameInfoDeviceArray(const int iteration)
+void TimeFrameGPU<NLayers>::createTrackingFrameInfoDeviceArray()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating trackingframeinfo array");
     allocMem(reinterpret_cast<void**>(&mTrackingFrameInfoDeviceArray), NLayers * sizeof(TrackingFrameInfo*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaHostRegister(mTrackingFrameInfoDevice.data(), NLayers * sizeof(TrackingFrameInfo*), cudaHostRegisterPortable));
@@ -236,9 +236,9 @@ void TimeFrameGPU<NLayers>::createTrackingFrameInfoDeviceArray(const int iterati
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadTrackingFrameInfoDevice(const int iteration, const int layer)
+void TimeFrameGPU<NLayers>::loadTrackingFrameInfoDevice(const int layer)
 {
-  if (!iteration) {
+  {
     GPUTimer timer(mGpuStreams[layer], "loading trackingframeinfo", layer);
     GPULog("gpu-transfer: loading {} tfinfo on layer {}, for {:.2f} MB.", this->mTrackingFrameInfo[layer].size(), layer, this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mTrackingFrameInfoDevice[layer]), this->mTrackingFrameInfo[layer].size() * sizeof(TrackingFrameInfo), mGpuStreams[layer], this->hasFrameworkAllocator());
@@ -250,7 +250,7 @@ void TimeFrameGPU<NLayers>::loadTrackingFrameInfoDevice(const int iteration, con
 template <int NLayers>
 void TimeFrameGPU<NLayers>::loadROFCutMask(const int iteration)
 {
-  if (!iteration || iteration == 3) { // we need to re-load the swapped mult-mask in upc iteration
+  {
     GPUTimer timer("loading multiplicity cut mask");
     const auto& hostTable = *(this->mROFMask);
     const auto hostView = hostTable.getView();
@@ -270,9 +270,9 @@ void TimeFrameGPU<NLayers>::loadROFCutMask(const int iteration)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadVertices(const int iteration)
+void TimeFrameGPU<NLayers>::loadVertices()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("loading seeding vertices");
     GPULog("gpu-transfer: loading {} seeding vertices, for {:.2f} MB.", this->mPrimaryVertices.size(), this->mPrimaryVertices.size() * sizeof(Vertex) / constants::MB);
     allocMem(reinterpret_cast<void**>(&mPrimaryVerticesDevice), this->mPrimaryVertices.size() * sizeof(Vertex), this->hasFrameworkAllocator());
@@ -281,9 +281,9 @@ void TimeFrameGPU<NLayers>::loadVertices(const int iteration)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadROFOverlapTable(const int iteration)
+void TimeFrameGPU<NLayers>::loadROFOverlapTable()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("initialising device view of ROFOverlapTable");
     const auto& hostTable = this->getROFOverlapTable();
     const auto& hostView = this->getROFOverlapTableView();
@@ -305,9 +305,9 @@ void TimeFrameGPU<NLayers>::loadROFOverlapTable(const int iteration)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::loadROFVertexLookupTable(const int iteration)
+void TimeFrameGPU<NLayers>::loadROFVertexLookupTable()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("initialising device view of ROFVertexLookupTable");
     const auto& hostTable = this->getROFVertexLookupTable();
     const auto& hostView = this->getROFVertexLookupTableView();
@@ -329,10 +329,10 @@ void TimeFrameGPU<NLayers>::loadROFVertexLookupTable(const int iteration)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::updateROFVertexLookupTable(const int iteration)
+void TimeFrameGPU<NLayers>::updateROFVertexLookupTable()
 {
   const auto& hostTable = this->getROFVertexLookupTable();
-  if (!iteration) {
+  {
     GPUTimer timer("updating device view of ROFVertexLookupTable");
     const auto& hostView = this->getROFVertexLookupTableView();
     using TableEntry = ROFVertexLookupTable<NLayers>::TableEntry;
@@ -345,19 +345,19 @@ void TimeFrameGPU<NLayers>::updateROFVertexLookupTable(const int iteration)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createTrackletsLUTDeviceArray(const int iteration)
+void TimeFrameGPU<NLayers>::createTrackletsLUTDeviceArray()
 {
-  if (!iteration) {
+  {
     allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (NLayers - 1) * sizeof(int*), this->hasFrameworkAllocator());
   }
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createTrackletsLUTDevice(const int iteration, const int layer)
+void TimeFrameGPU<NLayers>::createTrackletsLUTDevice(bool allocate, const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating tracklets LUTs", layer);
   const int ncls = this->mClusters[layer].size() + 1;
-  if (!iteration) {
+  if (allocate) {
     GPULog("gpu-allocation: creating tracklets LUT for {} elements on layer {}, for {:.2f} MB.", ncls, layer, ncls * sizeof(int) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[layer]), ncls * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpyAsync(&mTrackletsLUTDeviceArray[layer], &mTrackletsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
@@ -366,9 +366,9 @@ void TimeFrameGPU<NLayers>::createTrackletsLUTDevice(const int iteration, const
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createTrackletsBuffersArray(const int iteration)
+void TimeFrameGPU<NLayers>::createTrackletsBuffersArray()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating tracklet buffers array");
     allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (NLayers - 1) * sizeof(Tracklet*), this->hasFrameworkAllocator());
   }
@@ -442,9 +442,9 @@ void TimeFrameGPU<NLayers>::loadCellsDevice()
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createCellsLUTDeviceArray(const int iteration)
+void TimeFrameGPU<NLayers>::createCellsLUTDeviceArray()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating cells LUTs array");
     allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (NLayers - 2) * sizeof(int*), this->hasFrameworkAllocator());
   }
@@ -461,9 +461,9 @@ void TimeFrameGPU<NLayers>::createCellsLUTDevice(const int layer)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::createCellsBuffersArray(const int iteration)
+void TimeFrameGPU<NLayers>::createCellsBuffersArray()
 {
-  if (!iteration) {
+  {
     GPUTimer timer("creating cells buffers array");
     allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (NLayers - 2) * sizeof(CellSeed*), this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeed*), cudaMemcpyHostToDevice));
@@ -646,12 +646,10 @@ void TimeFrameGPU<NLayers>::popMemoryStack(const int iteration)
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::initialise(const int iteration,
-                                       const TrackingParameters& trkParam,
-                                       const int maxLayers)
+void TimeFrameGPU<NLayers>::initialise(const TrackingParameters& trkParam, int maxLayers)
 {
   mGpuStreams.resize(NLayers);
-  o2::its::TimeFrame<NLayers>::initialise(iteration, trkParam, maxLayers, false);
+  o2::its::TimeFrame<NLayers>::initialise(trkParam, maxLayers);
 }
 
 template <int NLayers>
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 8bb0bb5310b52..2d2ca5432cdf9 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -10,16 +10,11 @@
 // or submit itself to any jurisdiction.
 ///
 
-#include <array>
-#include <vector>
 #include <unistd.h>
 
-#include "DataFormatsITS/TrackITS.h"
-
-#include "ITStracking/TrackHelpers.h"
 #include "ITStrackingGPU/TrackerTraitsGPU.h"
 #include "ITStrackingGPU/TrackingKernels.h"
-#include "ITStracking/Constants.h"
+#include "ITStracking/Configuration.h"
 
 namespace o2::its
 {
@@ -27,28 +22,33 @@ namespace o2::its
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::initialiseTimeFrame(const int iteration)
 {
-  mTimeFrameGPU->initialise(iteration, this->mTrkParams[iteration], NLayers);
-  // on default stream
-  mTimeFrameGPU->loadVertices(iteration);
-  // TODO these tables can be put in persistent memory
-  mTimeFrameGPU->loadROFOverlapTable(iteration); // this can be put in constant memory actually
-  mTimeFrameGPU->loadROFVertexLookupTable(iteration);
-  // once the tables are in persistent memory just update the vertex one
-  // mTimeFrameGPU->updateROFVertexLookupTable(iteration);
-  mTimeFrameGPU->loadIndexTableUtils(iteration);
-  mTimeFrameGPU->loadROFCutMask(iteration);
-  // pinned on host
-  mTimeFrameGPU->createUsedClustersDeviceArray(iteration);
-  mTimeFrameGPU->createClustersDeviceArray(iteration);
-  mTimeFrameGPU->createUnsortedClustersDeviceArray(iteration);
-  mTimeFrameGPU->createClustersIndexTablesArray(iteration);
-  mTimeFrameGPU->createTrackingFrameInfoDeviceArray(iteration);
-  mTimeFrameGPU->createROFrameClustersDeviceArray(iteration);
-  // device array
-  mTimeFrameGPU->createTrackletsLUTDeviceArray(iteration);
-  mTimeFrameGPU->createTrackletsBuffersArray(iteration);
-  mTimeFrameGPU->createCellsBuffersArray(iteration);
-  mTimeFrameGPU->createCellsLUTDeviceArray(iteration);
+  mTimeFrameGPU->initialise(this->mTrkParams[iteration], NLayers);
+
+  if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
+    // on default stream
+    mTimeFrameGPU->loadVertices();
+    // TODO these tables can be put in persistent memory
+    mTimeFrameGPU->loadROFOverlapTable(); // this can be put in constant memory actually
+    mTimeFrameGPU->loadROFVertexLookupTable();
+    // once the tables are in persistent memory just update the vertex one
+    // mTimeFrameGPU->updateROFVertexLookupTable();
+    mTimeFrameGPU->loadIndexTableUtils();
+    // pinned on host
+    mTimeFrameGPU->createUsedClustersDeviceArray();
+    mTimeFrameGPU->createClustersDeviceArray();
+    mTimeFrameGPU->createUnsortedClustersDeviceArray();
+    mTimeFrameGPU->createClustersIndexTablesArray();
+    mTimeFrameGPU->createTrackingFrameInfoDeviceArray();
+    mTimeFrameGPU->createROFrameClustersDeviceArray();
+    // device array
+    mTimeFrameGPU->createTrackletsLUTDeviceArray();
+    mTimeFrameGPU->createTrackletsBuffersArray();
+    mTimeFrameGPU->createCellsBuffersArray();
+    mTimeFrameGPU->createCellsLUTDeviceArray();
+  }
+  if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass] || this->mTrkParams[iteration].PassFlags[IterationStep::UseUPCMask]) {
+    mTimeFrameGPU->loadROFCutMask(iteration);
+  }
   // push every create artefact on the stack
   mTimeFrameGPU->pushMemoryStack(iteration);
 }
@@ -65,22 +65,26 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
 {
   // start by queuing loading needed of two last layers
   for (int iLayer{NLayers}; iLayer-- > NLayers - 2;) {
-    mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer);
-    mTimeFrameGPU->loadClustersDevice(iteration, iLayer);
-    mTimeFrameGPU->loadClustersIndexTables(iteration, iLayer);
-    mTimeFrameGPU->loadROFrameClustersDevice(iteration, iLayer);
+    if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
+      mTimeFrameGPU->createUsedClustersDevice(iLayer);
+      mTimeFrameGPU->loadClustersDevice(iLayer);
+      mTimeFrameGPU->loadClustersIndexTables(iLayer);
+      mTimeFrameGPU->loadROFrameClustersDevice(iLayer);
+    }
     mTimeFrameGPU->recordEvent(iLayer);
   }
 
   for (int iLayer{this->mTrkParams[iteration].TrackletsPerRoad()}; iLayer--;) {
     if (iLayer) { // queue loading data of next layer in parallel, this the copies are overlapping with computation kernels
-      mTimeFrameGPU->createUsedClustersDevice(iteration, iLayer - 1);
-      mTimeFrameGPU->loadClustersDevice(iteration, iLayer - 1);
-      mTimeFrameGPU->loadClustersIndexTables(iteration, iLayer - 1);
-      mTimeFrameGPU->loadROFrameClustersDevice(iteration, iLayer - 1);
+      if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
+        mTimeFrameGPU->createUsedClustersDevice(iLayer - 1);
+        mTimeFrameGPU->loadClustersDevice(iLayer - 1);
+        mTimeFrameGPU->loadClustersIndexTables(iLayer - 1);
+        mTimeFrameGPU->loadROFrameClustersDevice(iLayer - 1);
+      }
       mTimeFrameGPU->recordEvent(iLayer - 1);
     }
-    mTimeFrameGPU->createTrackletsLUTDevice(iteration, iLayer);
+    mTimeFrameGPU->createTrackletsLUTDevice(this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass], iLayer);
     mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
     countTrackletsInROFsHandler<NLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
                                          mTimeFrameGPU->getDeviceROFMaskTableView(),
@@ -97,7 +101,7 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getDeviceArrayClustersIndexTables(),
                                          mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
                                          mTimeFrameGPU->getDeviceTrackletsLUTs(),
-                                         iteration,
+                                         this->mTrkParams[iteration].PassFlags[IterationStep::SelectUPCVertices],
                                          this->mTrkParams[iteration].NSigmaCut,
                                          mTimeFrameGPU->getPhiCuts(),
                                          this->mTrkParams[iteration].PVres,
@@ -130,7 +134,7 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
                                            mTimeFrameGPU->getNTracklets(),
                                            mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
                                            mTimeFrameGPU->getDeviceTrackletsLUTs(),
-                                           iteration,
+                                           this->mTrkParams[iteration].PassFlags[IterationStep::SelectUPCVertices],
                                            this->mTrkParams[iteration].NSigmaCut,
                                            mTimeFrameGPU->getPhiCuts(),
                                            this->mTrkParams[iteration].PVres,
@@ -149,15 +153,19 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
 {
   // start by queuing loading needed of three last layers
   for (int iLayer{NLayers}; iLayer-- > NLayers - 3;) {
-    mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer);
-    mTimeFrameGPU->loadTrackingFrameInfoDevice(iteration, iLayer);
+    if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
+      mTimeFrameGPU->loadUnsortedClustersDevice(iLayer);
+      mTimeFrameGPU->loadTrackingFrameInfoDevice(iLayer);
+    }
     mTimeFrameGPU->recordEvent(iLayer);
   }
 
   for (int iLayer{this->mTrkParams[iteration].CellsPerRoad()}; iLayer--;) {
     if (iLayer) {
-      mTimeFrameGPU->loadUnsortedClustersDevice(iteration, iLayer - 1);
-      mTimeFrameGPU->loadTrackingFrameInfoDevice(iteration, iLayer - 1);
+      if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
+        mTimeFrameGPU->loadUnsortedClustersDevice(iLayer - 1);
+        mTimeFrameGPU->loadTrackingFrameInfoDevice(iLayer - 1);
+      }
       mTimeFrameGPU->recordEvent(iLayer - 1);
     }
 
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index 6d778f17dc932..a732327a64d15 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -322,7 +322,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
   const int** indexTables,
   Tracklet** tracklets,
   int** trackletsLUT,
-  const int iteration,
+  const bool selectUPCVertices,
   const float NSigmaCut,
   const float phiCut,
   const float resolutionPV,
@@ -383,7 +383,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
         if (!vertexLUT.isVertexCompatible(layerIndex, pivotROF, primaryVertex)) {
           continue;
         }
-        if ((primaryVertex.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) || (iteration == 3 && !primaryVertex.isFlagSet(Vertex::Flags::UPCMode))) {
+        if (primaryVertex.isFlagSet(Vertex::Flags::UPCMode) != selectUPCVertices) {
           continue;
         }
 
@@ -576,7 +576,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  const int** clustersIndexTables,
                                  int** trackletsLUTs,
                                  gsl::span<int*> trackletsLUTsHost,
-                                 const int iteration,
+                                 const bool selectUPCVertices,
                                  const float NSigmaCut,
                                  bounded_vector<float>& phiCuts,
                                  const float resolutionPV,
@@ -603,7 +603,7 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
     clustersIndexTables,
     nullptr,
     trackletsLUTs,
-    iteration,
+    selectUPCVertices,
     NSigmaCut,
     phiCuts[layer],
     resolutionPV,
@@ -635,7 +635,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    gsl::span<int> nTracklets,
                                    int** trackletsLUTs,
                                    gsl::span<int*> trackletsLUTsHost,
-                                   const int iteration,
+                                   const bool selectUPCVertices,
                                    const float NSigmaCut,
                                    bounded_vector<float>& phiCuts,
                                    const float resolutionPV,
@@ -662,7 +662,7 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
     clustersIndexTables,
     tracklets,
     trackletsLUTs,
-    iteration,
+    selectUPCVertices,
     NSigmaCut,
     phiCuts[layer],
     resolutionPV,
@@ -1094,7 +1094,7 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                              const int** clustersIndexTables,
                                              int** trackletsLUTs,
                                              gsl::span<int*> trackletsLUTsHost,
-                                             const int iteration,
+                                             const bool selectUPCVertices,
                                              const float NSigmaCut,
                                              bounded_vector<float>& phiCuts,
                                              const float resolutionPV,
@@ -1124,7 +1124,7 @@ template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                                gsl::span<int> nTracklets,
                                                int** trackletsLUTs,
                                                gsl::span<int*> trackletsLUTsHost,
-                                               const int iteration,
+                                               const bool selectUPCVertices,
                                                const float NSigmaCut,
                                                bounded_vector<float>& phiCuts,
                                                const float resolutionPV,
@@ -1275,7 +1275,7 @@ template void countTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils,
                                               const int** clustersIndexTables,
                                               int** trackletsLUTs,
                                               gsl::span<int*> trackletsLUTsHost,
-                                              const int iteration,
+                                              const bool selectUPCVertices,
                                               const float NSigmaCut,
                                               bounded_vector<float>& phiCuts,
                                               const float resolutionPV,
@@ -1305,7 +1305,7 @@ template void computeTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils
                                                 gsl::span<int> nTracklets,
                                                 int** trackletsLUTs,
                                                 gsl::span<int*> trackletsLUTsHost,
-                                                const int iteration,
+                                                const bool selectUPCVertices,
                                                 const float NSigmaCut,
                                                 bounded_vector<float>& phiCuts,
                                                 const float resolutionPV,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index dbce5e0dc08a7..ce7b3e5a87630 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -23,12 +23,25 @@
 #include <vector>
 #endif
 
+#include "CommonUtils/EnumFlags.h"
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Constants.h"
 
 namespace o2::its
 {
 
+// Steering of dedicated steps in an iteration
+enum class IterationStep : uint8_t {
+  FirstPass = 0,
+  RebuildClusterLUT,
+  UseUPCMask,
+  SelectUPCVertices,
+  ResetVertices,
+  SkipROFsAboveThreshold,
+  MarkVerticesAsUPC,
+};
+using IterationSteps = o2::utils::EnumFlags<IterationStep>;
+
 struct TrackingParameters {
   int CellMinimumLevel() const noexcept { return MinTrackLength - constants::ClustersPerCell + 1; }
   int NeighboursPerRoad() const noexcept { return NLayers - 3; }
@@ -36,6 +49,7 @@ struct TrackingParameters {
   int TrackletsPerRoad() const noexcept { return NLayers - 1; }
   std::string asString() const;
 
+  IterationSteps PassFlags{IterationStep::FirstPass, IterationStep::RebuildClusterLUT};
   int NLayers = 7;
   std::vector<uint32_t> AddTimeError = {0, 0, 0, 0, 0, 0, 0};
   std::vector<float> LayerZ = {16.333f + 1, 16.333f + 1, 16.333f + 1, 42.140f + 1, 42.140f + 1, 73.745f + 1, 73.745f + 1};
@@ -73,9 +87,7 @@ struct TrackingParameters {
   bool SaveTimeBenchmarks = false;
   bool DoUPCIteration = false;
   bool FataliseUponFailure = true;
-
-  bool createArtefactLabels{false};
-
+  bool CreateArtefactLabels{false};
   bool PrintMemory = false; // print allocator usage in epilog report
   size_t MaxMemory = std::numeric_limits<size_t>::max();
   bool DropTFUponFailure = false;
@@ -84,6 +96,7 @@ struct TrackingParameters {
 struct VertexingParameters {
   std::string asString() const;
 
+  IterationSteps PassFlags{IterationStep::FirstPass, IterationStep::ResetVertices};
   std::vector<float> LayerZ = {16.333f + 1, 16.333f + 1, 16.333f + 1, 42.140f + 1, 42.140f + 1, 73.745f + 1, 73.745f + 1};
   std::vector<float> LayerRadii = {2.33959f, 3.14076f, 3.91924f, 19.6213f, 24.5597f, 34.388f, 39.3329f};
   int vertPerRofThreshold = 0; // Maximum number of vertices per ROF to trigger second a round
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index 300abb2a3b10d..b78540bddfabf 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -177,7 +177,7 @@ struct TimeFrame {
   auto& getCellsLabel(int layer) { return mCellLabels[layer]; }
 
   bool hasMCinformation() const { return mClusterLabels[0] != nullptr; }
-  void initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers = NLayers, bool resetVertices = true);
+  void initialise(const TrackingParameters& trkParam, const int maxLayers = NLayers);
 
   bool isClusterUsed(int layer, int clusterId) const { return mUsedClusters[layer][clusterId]; }
   void markUsedCluster(int layer, int clusterId) { mUsedClusters[layer][clusterId] = true; }
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 1c3c642429686..aa4592c63f404 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -18,7 +18,6 @@
 
 #include <oneapi/tbb.h>
 
-#include "DetectorsBase/Propagator.h"
 #include "ITStracking/Configuration.h"
 #include "ITStracking/IndexTableUtils.h"
 #include "ITStracking/TimeFrame.h"
@@ -46,7 +45,7 @@ class TrackerTraits
 
   virtual ~TrackerTraits() = default;
   virtual void adoptTimeFrame(TimeFrame<NLayers>* tf) { mTimeFrame = tf; }
-  virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(iteration, mTrkParams[iteration], mTrkParams[iteration].NLayers, false); }
+  virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(mTrkParams[iteration], mTrkParams[iteration].NLayers); }
 
   virtual void computeLayerTracklets(const int iteration, int iVertex);
   virtual void computeLayerCells(const int iteration);
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
index ac4b99a0a8cd8..14c5d6a62e0ad 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingInterface.h
@@ -34,6 +34,7 @@ namespace o2::its
 {
 class ITSTrackingInterface
 {
+ public:
   static constexpr int NLayers{7};
   using VertexerN = Vertexer<NLayers>;
   using VertexerTraitsN = VertexerTraits<NLayers>;
@@ -41,7 +42,6 @@ class ITSTrackingInterface
   using TrackerTraitsN = TrackerTraits<NLayers>;
   using TimeFrameN = TimeFrame<NLayers>;
 
- public:
   ITSTrackingInterface(bool isMC,
                        bool doStag,
                        int trgType,
@@ -80,6 +80,8 @@ class ITSTrackingInterface
   TimeFrameN* mTimeFrame = nullptr;
 
  protected:
+  virtual void overrideParameters(std::vector<TrackingParameters>& t, std::vector<VertexingParameters>& v) {}
+  virtual void requestTopologyDictionary(framework::ProcessingContext& pc);
   virtual void loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                        gsl::span<const itsmft::CompClusterExt> clusters,
                        gsl::span<const unsigned char>::iterator& pattIt,
@@ -98,7 +100,7 @@ class ITSTrackingInterface
   const o2::itsmft::TopologyDictionary* mDict = nullptr;
   std::unique_ptr<TrackerN> mTracker = nullptr;
   std::unique_ptr<VertexerN> mVertexer = nullptr;
-  const o2::dataformats::MeanVertexObject* mMeanVertex;
+  const o2::dataformats::MeanVertexObject* mMeanVertex{};
   std::shared_ptr<BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<tbb::task_arena> mTaskArena;
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
index 3230737a0f87c..daf8d708e1e23 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/VertexerTraits.h
@@ -53,14 +53,11 @@ class VertexerTraits
   VertexerTraits() = default;
   virtual ~VertexerTraits() = default;
 
-  GPUhd() static const int2 getPhiBins(float phi, float deltaPhi, const IndexTableUtilsN&);
-  GPUhd() const int2 getPhiBins(float phi, float deltaPhi) { return getPhiBins(phi, deltaPhi, mIndexTableUtils); }
-
   // virtual vertexer interface
-  virtual void initialise(const TrackingParameters& trackingParams, const int iteration = 0);
-  virtual void computeTracklets(const int iteration = 0);
-  virtual void computeTrackletMatching(const int iteration = 0);
-  virtual void computeVertices(const int iteration = 0);
+  virtual void initialise(const TrackingParameters& trackingParams);
+  virtual void computeTracklets(const int iteration);
+  virtual void computeTrackletMatching(const int iteration);
+  virtual void computeVertices(const int iteration);
   virtual void adoptTimeFrame(TimeFrameN* tf) noexcept { mTimeFrame = tf; }
   virtual void updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar);
 
@@ -115,19 +112,6 @@ class VertexerTraits
   std::shared_ptr<tbb::task_arena> mTaskArena;
 };
 
-template <int NLayers>
-inline void VertexerTraits<NLayers>::initialise(const TrackingParameters& trackingParams, const int iteration)
-{
-  mTimeFrame->initialise(0, trackingParams, 3, (bool)(!iteration)); // iteration for initialisation must be 0 for correctly resetting the frame, we need to pass the non-reset flag for vertices as well, tho.
-}
-
-template <int NLayers>
-GPUhdi() const int2 VertexerTraits<NLayers>::getPhiBins(float phi, float dPhi, const IndexTableUtilsN& utils)
-{
-  return int2{utils.getPhiBinIndex(math_utils::getNormalizedPhi(phi - dPhi)),
-              utils.getPhiBinIndex(math_utils::getNormalizedPhi(phi + dPhi))};
-}
-
 } // namespace its
 } // namespace o2
 #endif
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 49bf9b5b1887d..c425d467a8061 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -143,7 +143,7 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
       // check if something was overridden via configurable params
       if (ip < constants::MaxIter) {
         if (tc.startLayerMask[ip] > 0) {
-          trackParams[2].StartLayerMask = tc.startLayerMask[ip];
+          param.StartLayerMask = tc.startLayerMask[ip];
         }
         if (tc.minTrackLgtIter[ip] > 0) {
           param.MinTrackLength = tc.minTrackLgtIter[ip];
@@ -174,6 +174,14 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     LOGP(fatal, "Unsupported ITS tracking mode {} ", toString(mode));
   }
 
+  for (auto& param : trackParams) {
+    param.PassFlags.reset();
+  }
+  trackParams[0].PassFlags.set(IterationStep::FirstPass, IterationStep::RebuildClusterLUT);
+  if (trackParams.size() > 3 && tc.doUPCIteration) {
+    trackParams[3].PassFlags.set(IterationStep::UseUPCMask, IterationStep::RebuildClusterLUT, IterationStep::SelectUPCVertices);
+  }
+
   float bFactor = std::abs(o2::base::Propagator::Instance()->getNominalBz()) / 5.0066791f;
   float bFactorTracklets = bFactor < 0.01f ? 1.f : bFactor; // for tracklets only
 
@@ -188,7 +196,7 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     p.ReseedIfShorter = tc.reseedIfShorter;
     p.RepeatRefitOut = tc.repeatRefitOut;
     p.ShiftRefToCluster = tc.shiftRefToCluster;
-    p.createArtefactLabels = tc.createArtefactLabels;
+    p.CreateArtefactLabels = tc.createArtefactLabels;
 
     p.PrintMemory = tc.printMemory;
     p.MaxMemory = tc.maxMemory;
@@ -241,6 +249,12 @@ std::vector<VertexingParameters> TrackingMode::getVertexingParameters(TrackingMo
 {
   const auto& vc = o2::its::VertexerParamConfig::Instance();
   std::vector<VertexingParameters> vertParams(2); // The number of actual iterations will be set as a configKeyVal to allow for pp/PbPb choice
+  for (auto& param : vertParams) {
+    param.PassFlags.reset();
+  }
+  vertParams[0].PassFlags.set(IterationStep::FirstPass, IterationStep::ResetVertices);
+  vertParams[1].PassFlags.set(IterationStep::SkipROFsAboveThreshold, IterationStep::MarkVerticesAsUPC);
+
   // global parameters set for every iteration
   for (auto& p : vertParams) {
     p.vertPerRofThreshold = vc.vertPerRofThreshold;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index cafddfcc41a76..fc99bf0f35403 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -241,14 +241,14 @@ void TimeFrame<NLayers>::prepareClusters(const TrackingParameters& trkParam, con
 }
 
 template <int NLayers>
-void TimeFrame<NLayers>::initialise(const int iteration, const TrackingParameters& trkParam, const int maxLayers, bool resetVertices)
+void TimeFrame<NLayers>::initialise(const TrackingParameters& trkParam, const int maxLayers)
 {
-  if (iteration == 0) {
+  if (trkParam.PassFlags[IterationStep::FirstPass]) {
     deepVectorClear(mTracks);
     deepVectorClear(mTracksLabel);
     deepVectorClear(mLines);
     deepVectorClear(mLinesLabels);
-    if (resetVertices) {
+    if (trkParam.PassFlags[IterationStep::ResetVertices]) {
       deepVectorClear(mPrimaryVertices);
       deepVectorClear(mPrimaryVerticesLabels);
     }
@@ -293,7 +293,7 @@ void TimeFrame<NLayers>::initialise(const int iteration, const TrackingParameter
   for (auto& v : mNTrackletsPerROF) {
     v = bounded_vector<int>(getNrof(1) + 1, 0, mMemoryPool.get());
   }
-  if (iteration == 0 || iteration == 3) {
+  if (trkParam.PassFlags[IterationStep::RebuildClusterLUT]) {
     prepareClusters(trkParam, maxLayers);
   }
   mTotalTracklets = {0, 0};
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
index 382f2314b2e6a..f17d961fc7bb7 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Tracker.cxx
@@ -68,7 +68,7 @@ float Tracker<NLayers>::clustersToTracks(const LogFunc& logger, const LogFunc& e
   try {
     for (iteration = 0; iteration < (int)mTrkParams.size(); ++iteration) {
       mMemoryPool->setMaxMemory(mTrkParams[iteration].MaxMemory);
-      if (iteration == 3 && mTrkParams[0].DoUPCIteration) {
+      if (mTrkParams[iteration].PassFlags[IterationStep::UseUPCMask]) {
         mTimeFrame->useUPCMask();
       }
       float timeFrame{0.}, timeTracklets{0.}, timeCells{0.}, timeNeighbours{0.}, timeRoads{0.};
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index dc2d6e8889973..19cae4b70f158 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -101,7 +101,7 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
           if (!mTimeFrame->getROFVertexLookupTableView().isVertexCompatible(iLayer, pivotROF, pv)) {
             continue;
           }
-          if ((pv.isFlagSet(Vertex::Flags::UPCMode) && iteration != 3) || (iteration == 3 && !pv.isFlagSet(Vertex::Flags::UPCMode))) {
+          if (pv.isFlagSet(Vertex::Flags::UPCMode) != mTrkParams[iteration].PassFlags[IterationStep::SelectUPCVertices]) {
             continue;
           }
           const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)) + math_utils::Sq(mTrkParams[iteration].PVres) / float(pv.getNContributors()));
@@ -224,7 +224,7 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
     });
 
     /// Create tracklets labels
-    if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
+    if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].CreateArtefactLabels) {
       tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
         for (auto& trk : mTimeFrame->getTracklets()[iLayer]) {
           MCCompLabel label;
@@ -256,7 +256,7 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
     if (iLayer > 0) {
       deepVectorClear(mTimeFrame->getCellsLookupTable()[iLayer - 1]);
     }
-    if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
+    if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].CreateArtefactLabels) {
       deepVectorClear(mTimeFrame->getCellsLabel(iLayer));
     }
   }
@@ -390,7 +390,7 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
         std::copy_n(perTrackletCount.begin(), currentLayerTrackletsNum + 1, lut.begin());
       }
 
-      if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].createArtefactLabels) {
+      if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].CreateArtefactLabels) {
         auto& labels = mTimeFrame->getCellsLabel(iLayer);
         labels.reserve(layerCells.size());
         for (const auto& cell : layerCells) {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index a48f23c5eb8f1..f745d671419af 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -50,6 +50,7 @@ void ITSTrackingInterface::initialise()
   }
   auto trackParams = TrackingMode::getTrackingParameters(mMode);
   auto vertParams = TrackingMode::getVertexingParameters(mMode);
+  overrideParameters(trackParams, vertParams);
   LOGP(info, "Initializing tracker in {} phase reconstruction with {} passes for tracking and {}/{} for vertexing", TrackingMode::toString(mMode), trackParams.size(), o2::its::VertexerParamConfig::Instance().nIterations, vertParams.size());
   mTracker->setParameters(trackParams);
   mVertexer->setParameters(vertParams);
@@ -372,7 +373,7 @@ void ITSTrackingInterface::updateTimeDependentParams(framework::ProcessingContex
   }
   if (!initOnceDone) { // this params need to be queried only once
     initOnceDone = true;
-    pc.inputs().get<o2::itsmft::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
+    requestTopologyDictionary(pc);
     pc.inputs().get<o2::itsmft::DPLAlpideParam<o2::detectors::DetID::ITS>*>("itsalppar");
     if (pc.inputs().getPos("itsTGeo") >= 0) {
       pc.inputs().get<o2::its::GeometryTGeo*>("itsTGeo");
@@ -485,6 +486,11 @@ void ITSTrackingInterface::setTraitsFromProvider(VertexerTraitsN* vertexerTraits
   mVertexer->setMemoryPool(mMemoryPool);
 }
 
+void ITSTrackingInterface::requestTopologyDictionary(framework::ProcessingContext& pc)
+{
+  pc.inputs().get<o2::itsmft::TopologyDictionary*>("itscldict"); // just to trigger the finaliseCCDB
+}
+
 void ITSTrackingInterface::loadROF(gsl::span<const itsmft::ROFRecord>& trackROFspan,
                                    gsl::span<const itsmft::CompClusterExt> clusters,
                                    gsl::span<const unsigned char>::iterator& pattIt,
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
index b4585929d2dcf..ba37275f87688 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Vertexer.cxx
@@ -61,9 +61,14 @@ float Vertexer<NLayers>::clustersToVertices(LogFunc logger)
       mMemoryPool->setMaxMemory(mVertParams[iteration].MaxMemory);
       unsigned int nTracklets01{0}, nTracklets12{0};
       logger(fmt::format("=== ITS {} Seeding vertexer iteration {} summary:", mTraits->getName(), iteration));
-      trkPars.PhiBins = mTraits->getVertexingParameters()[0].PhiBins;
-      trkPars.ZBins = mTraits->getVertexingParameters()[0].ZBins;
-      auto timeInitIteration = evaluateTask(&Vertexer::initialiseVertexer, StateNames[mCurStep = Init], iteration, evalLog, trkPars, iteration);
+      const auto& currentVtxPars = mTraits->getVertexingParameters()[iteration];
+      trkPars.PhiBins = currentVtxPars.PhiBins;
+      trkPars.ZBins = currentVtxPars.ZBins;
+      trkPars.LayerZ = currentVtxPars.LayerZ;
+      trkPars.LayerRadii = currentVtxPars.LayerRadii;
+      trkPars.PassFlags = mVertParams[iteration].PassFlags;
+      trkPars.PassFlags.set(IterationStep::FirstPass, IterationStep::RebuildClusterLUT);
+      auto timeInitIteration = evaluateTask(&Vertexer::initialiseVertexer, StateNames[mCurStep = Init], iteration, evalLog, trkPars);
       auto timeTrackletIteration = evaluateTask(&Vertexer::findTracklets, StateNames[mCurStep = Trackleting], iteration, evalLog, iteration);
       nTracklets01 = mTimeFrame->getTotalTrackletsTF(0);
       nTracklets12 = mTimeFrame->getTotalTrackletsTF(1);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
index 00674b715b97d..237e99e57e0da 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/VertexerTraits.cxx
@@ -156,6 +156,12 @@ void trackletSelectionKernelHost(
 }
 } // namespace
 
+template <int NLayers>
+void VertexerTraits<NLayers>::initialise(const TrackingParameters& trackingParams)
+{
+  mTimeFrame->initialise(trackingParams, 3);
+}
+
 template <int NLayers>
 void VertexerTraits<NLayers>::updateVertexingParameters(const std::vector<VertexingParameters>& vrtPar)
 {
@@ -528,7 +534,7 @@ void VertexerTraits<NLayers>::computeVertices(const int iteration)
                     cluster.getRMS2(),
                     (ushort)cluster.getSize(),
                     cluster.getAvgDistance2()};
-      if (iteration) {
+      if (mVrtParams[iteration].PassFlags[IterationStep::MarkVerticesAsUPC]) {
         vertex.setFlags(Vertex::UPCMode);
       }
       vertex.setTimeStamp(cluster.getTimeStamp());
@@ -629,7 +635,8 @@ void VertexerTraits<NLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena
 template <int NLayers>
 bool VertexerTraits<NLayers>::skipROF(int iteration, int rof) const
 {
-  return iteration && (int)mTimeFrame->getROFVertexLookupTableView().getVertices(1, rof).getEntries() > mVrtParams[iteration].vertPerRofThreshold;
+  return mVrtParams[iteration].PassFlags[IterationStep::SkipROFsAboveThreshold] &&
+         (int)mTimeFrame->getROFVertexLookupTableView().getVertices(1, rof).getEntries() > mVrtParams[iteration].vertPerRofThreshold;
 }
 
 template class VertexerTraits<7>;
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
index c9d793a3ec78f..cb4cc3897ae9e 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
@@ -177,7 +177,7 @@ std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromCon
     //   params.UseTrackFollowerMix = paramConfig["UseTrackFollowerMix"].get<bool>();
     // }
     if (paramConfig.contains("createArtefactLabels")) {
-      params.createArtefactLabels = paramConfig["createArtefactLabels"].get<bool>();
+      params.CreateArtefactLabels = paramConfig["createArtefactLabels"].get<bool>();
     }
     if (paramConfig.contains("PrintMemory")) {
       params.PrintMemory = paramConfig["PrintMemory"].get<bool>();
@@ -300,7 +300,7 @@ void TrackerDPL::run(ProcessingContext& pc)
     const auto trackingLoopStart = std::chrono::steady_clock::now();
     for (size_t iter{0}; iter < trackingParams.size(); ++iter) {
       LOGP(info, "{}", trackingParams[iter].asString());
-      timeFrame.initialise(iter, trackingParams[iter], 11, false);
+      timeFrame.initialise(trackingParams[iter], 11);
       itsTrackerTraits.computeLayerTracklets(iter, -1);
       LOGP(info, "Number of tracklets in iteration {}: {}", iter, timeFrame.getNumberOfTracklets());
       itsTrackerTraits.computeLayerCells(iter);

From a204d4181b2ecbea705cec293ae80bbaad3eef4a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tuba=20G=C3=BCndem?=
 <48834043+tubagundem@users.noreply.github.com>
Date: Tue, 12 May 2026 08:55:25 +0200
Subject: [PATCH 1724/1764] TPC_CMV: Improving the CMV workflows (#15360)

* Implemented Vit's comments

* Minor fixes

* Added trigger to FLP workflow

* Add helper for CMV files, improve draw macro, move tpc-cmv-trigger to test folder
---
 .../TPC/include/DataFormatsTPC/CMV.h          |   8 +-
 Detectors/TPC/calibration/CMakeLists.txt      |   4 +-
 .../include/TPCCalibration/CMVHelper.h        |  52 ++++++++
 Detectors/TPC/calibration/macro/drawCMV.C     | 118 ++++++++---------
 Detectors/TPC/calibration/src/CMVHelper.cxx   |  98 ++++++++++++++
 .../calibration/src/TPCCalibrationLinkDef.h   |   1 +
 Detectors/TPC/workflow/CMakeLists.txt         |   5 +
 .../include/TPCWorkflow/CMVToVectorSpec.h     |   2 +-
 .../include/TPCWorkflow/TPCAggregateCMVSpec.h | 103 ++++++++-------
 .../TPCWorkflow/TPCDistributeCMVSpec.h        |  76 ++++++-----
 .../include/TPCWorkflow/TPCFLPCMVSpec.h       | 121 +++++++++++++-----
 .../TPC/workflow/src/CMVToVectorSpec.cxx      |  18 +--
 .../TPC/workflow/test/test_cmv-trigger.cxx    |  85 ++++++++++++
 13 files changed, 488 insertions(+), 203 deletions(-)
 create mode 100644 Detectors/TPC/calibration/include/TPCCalibration/CMVHelper.h
 create mode 100644 Detectors/TPC/calibration/src/CMVHelper.cxx
 create mode 100644 Detectors/TPC/workflow/test/test_cmv-trigger.cxx

diff --git a/DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h b/DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h
index 109eff2654466..8195b3e39c689 100644
--- a/DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h
+++ b/DataFormats/Detectors/TPC/include/DataFormatsTPC/CMV.h
@@ -85,11 +85,13 @@ struct Data {
     return positive ? magnitude : -magnitude;
   }
 
-  // Encode from float: clamps magnitude to 15 bits, range ±255.992
+  // Encode from float: truncates magnitude to 15 bits, range ±255.992
   void setCMVFloat(float value)
   {
     const bool positive = (value >= 0.f);
-    const uint16_t magnitude = static_cast<uint16_t>(std::abs(value) * 128.f + 0.5f) & 0x7FFF;
+    const uint16_t magnitude = static_cast<uint16_t>(
+                                 std::lround(std::abs(value) * 128.f)) &
+                               0x7FFF;
     cmv = (positive ? 0x8000 : 0x0000) | magnitude;
   }
 };
@@ -119,4 +121,4 @@ struct Container {
 
 } // namespace o2::tpc::cmv
 
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/TPC/calibration/CMakeLists.txt b/Detectors/TPC/calibration/CMakeLists.txt
index 675f15e89258b..6aeb497c1cf23 100644
--- a/Detectors/TPC/calibration/CMakeLists.txt
+++ b/Detectors/TPC/calibration/CMakeLists.txt
@@ -60,6 +60,7 @@ o2_add_library(TPCCalibration
                        src/PressureTemperatureHelper.cxx
                        src/CMVContainer.cxx
                        src/CorrectionMapsLoader.cxx
+                       src/CMVHelper.cxx
                PUBLIC_LINK_LIBRARIES O2::DataFormatsTPC O2::TPCBaseRecSim
                                      O2::TPCReconstruction ROOT::Minuit
                                      Microsoft.GSL::GSL
@@ -119,7 +120,8 @@ o2_target_root_dictionary(TPCCalibration
                                   include/TPCCalibration/CorrectdEdxDistortions.h
                                   include/TPCCalibration/PressureTemperatureHelper.h
                                   include/TPCCalibration/CMVContainer.h
-                                  include/TPCCalibration/CorrectionMapsLoader.h)
+                                  include/TPCCalibration/CorrectionMapsLoader.h
+                                  include/TPCCalibration/CMVHelper.h)
 
 o2_add_test_root_macro(macro/comparePedestalsAndNoise.C
                        PUBLIC_LINK_LIBRARIES O2::TPCBaseRecSim
diff --git a/Detectors/TPC/calibration/include/TPCCalibration/CMVHelper.h b/Detectors/TPC/calibration/include/TPCCalibration/CMVHelper.h
new file mode 100644
index 0000000000000..d687c6872b8df
--- /dev/null
+++ b/Detectors/TPC/calibration/include/TPCCalibration/CMVHelper.h
@@ -0,0 +1,52 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   CMVHelper.h
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  Helper utilities for reading CMV ROOT files
+
+#ifndef ALICEO2_TPC_CMVHELPER_H_
+#define ALICEO2_TPC_CMVHELPER_H_
+
+#include <string>
+
+#include "TFile.h"
+#include "TTree.h"
+
+namespace o2::tpc
+{
+
+struct CMVPerTF;
+struct CMVPerTFCompressed;
+
+struct CMVFileHandle {
+  TFile* file{nullptr};
+  TTree* tree{nullptr};
+  bool isCompressed{false};
+  CMVPerTFCompressed* tfCompressed{nullptr};
+  CMVPerTF* tfRaw{nullptr};
+  CMVPerTF* tfDecoded{nullptr}; ///< scratch buffer used when decompressing
+  long firstTFInTree{-1};       ///< first global TF index from tree UserInfo ("firstTF"); -1 if absent
+  long lastTFInTree{-1};        ///< last  global TF index from tree UserInfo ("lastTF");  -1 if absent
+
+  /// Open path and set up branch addresses. Returns false on any error
+  bool open(const std::string& path);
+
+  /// Load entry iEntry and return a pointer to the decoded CMVPerTF, or nullptr on error
+  const CMVPerTF* getEntry(long long iEntry);
+
+  /// Release all resources
+  void close();
+};
+
+} // namespace o2::tpc
+
+#endif // ALICEO2_TPC_CMVHELPER_H_
diff --git a/Detectors/TPC/calibration/macro/drawCMV.C b/Detectors/TPC/calibration/macro/drawCMV.C
index 4f74db16cecd6..78e951fcfd676 100644
--- a/Detectors/TPC/calibration/macro/drawCMV.C
+++ b/Detectors/TPC/calibration/macro/drawCMV.C
@@ -11,19 +11,19 @@
 
 #if !defined(__CLING__) || defined(__ROOTCLING__)
 #include <string>
-#include <vector>
 #include <string_view>
+#include <vector>
 #include <fmt/format.h>
 
-#include "TFile.h"
-#include "TParameter.h"
 #include "TTree.h"
 #include "TH1F.h"
 #include "TH2F.h"
 #include "TCanvas.h"
 
-#include "TPCCalibration/CMVContainer.h"
 #include "TPCBase/Utils.h"
+#include "TPCCalibration/CMVContainer.h"
+#include "TPCCalibration/CMVHelper.h"
+
 #endif
 
 using namespace o2::tpc;
@@ -38,39 +38,20 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir, std::stri
   arrCanvases->SetName("CMV");
 
   // open file
-  TFile f(filename.data(), "READ");
-  if (f.IsZombie()) {
+  CMVFileHandle fh;
+  if (!fh.open(std::string(filename))) {
     fmt::print("ERROR: cannot open '{}'\n", filename);
     return arrCanvases;
   }
   fmt::print("Opened file: {}\n", filename);
+  fmt::print("Tree 'ccdb_object' found, entries: {}\n", fh.tree->GetEntries());
 
-  // get TTree
-  TTree* tree = nullptr;
-  f.GetObject("ccdb_object", tree);
-  if (!tree) {
-    fmt::print("ERROR: TTree 'ccdb_object' not found\n");
-    return arrCanvases;
-  }
-  fmt::print("Tree 'ccdb_object' found, entries: {}\n", tree->GetEntries());
-
-  // read metadata
-  long firstTF = -1, lastTF = -1;
-  if (auto* userInfo = tree->GetUserInfo()) {
-    for (int i = 0; i < userInfo->GetSize(); ++i) {
-      if (auto* p = dynamic_cast<TParameter<long>*>(userInfo->At(i))) {
-        if (std::string(p->GetName()) == "firstTF")
-          firstTF = p->GetVal();
-        if (std::string(p->GetName()) == "lastTF")
-          lastTF = p->GetVal();
-      }
-    }
-  }
-  fmt::print("firstTF: {}, lastTF: {}\n", firstTF, lastTF);
+  fmt::print("firstTF: {}, lastTF: {}\n", fh.firstTFInTree, fh.lastTFInTree);
 
-  const int nEntries = tree->GetEntries();
+  const int nEntries = fh.tree->GetEntries();
   if (nEntries == 0) {
     fmt::print("ERROR: no entries in tree\n");
+    fh.close();
     return arrCanvases;
   }
 
@@ -80,61 +61,62 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir, std::stri
   TH2F* h2d = new TH2F("hCMVvsTimeBin", ";Timebin (200 ns);Common Mode Values (ADC)",
                        100, 0, nTimeBins,
                        110, -100.5, 9.5);
+  h2d->SetDirectory(nullptr);
   h2d->SetStats(1);
   TH1F* h1d = new TH1F("hCMV", ";Common Mode Values (ADC);Counts",
                        110, -100.5, 9.5);
+  h1d->SetDirectory(nullptr);
   h1d->SetStats(1);
 
-  // auto-detect branch format: compressed or raw
-  const bool isCompressed = (tree->GetBranch("CMVPerTFCompressed") != nullptr);
-  const bool isRaw = (tree->GetBranch("CMVPerTF") != nullptr);
-  if (!isCompressed && !isRaw) {
-    fmt::print("ERROR: no recognised branch found (expected 'CMVPerTFCompressed' or 'CMVPerTF')\n");
-    return arrCanvases;
-  }
-  fmt::print("Branch format: {}\n", isCompressed ? "CMVPerTFCompressed" : "CMVPerTF (raw)");
-
-  o2::tpc::CMVPerTFCompressed* tfCompressed = nullptr;
-  o2::tpc::CMVPerTF* tfRaw = nullptr;
-  CMVPerTF* tfDecoded = isCompressed ? new CMVPerTF() : nullptr;
+  TH1F* h1dCRU = new TH1F("hCRU", ";CRU;Counts",
+                          360, -0.5, 359.5);
+  h1dCRU->SetDirectory(nullptr);
+  h1dCRU->SetStats(1);
+  TH2F* h2dCRU = new TH2F("hCMVvsCRU", ";CRU;Common Mode Values (ADC)",
+                          360, -0.5, 359.5,
+                          110, -100.5, 9.5);
+  h2dCRU->SetDirectory(nullptr);
+  h2dCRU->SetStats(0);
 
-  if (isCompressed) {
-    tree->SetBranchAddress("CMVPerTFCompressed", &tfCompressed);
-  } else {
-    tree->SetBranchAddress("CMVPerTF", &tfRaw);
-  }
+  fmt::print("Branch format: {}\n", fh.isCompressed ? "CMVPerTFCompressed" : "CMVPerTF (raw)");
 
   long firstOrbit = -1;
   long firstOrbitDPL = -1;
 
+  // Pre-allocate fill arrays once; x-values (timebins) are constant across entries and CRUs
+  const int fillsPerEntry = nCRUs * nTimeBins;
+  std::vector<double> xArr(fillsPerEntry), yArr(fillsPerEntry), wArr(fillsPerEntry, 1.0), cruArr(fillsPerEntry);
+  for (int cru = 0; cru < nCRUs; ++cru) {
+    for (int tb = 0; tb < nTimeBins; ++tb) {
+      xArr[cru * nTimeBins + tb] = tb;
+      cruArr[cru * nTimeBins + tb] = cru;
+    }
+  }
+
   for (int i = 0; i < nEntries; ++i) {
-    tree->GetEntry(i);
-
-    // Decompress if needed; resolve to a unified CMVPerTF pointer
-    const CMVPerTF* tf = nullptr;
-    if (isCompressed) {
-      tfCompressed->decompress(tfDecoded);
-      tf = tfDecoded;
-    } else {
-      tf = tfRaw;
+    const CMVPerTF* tf = fh.getEntry(i);
+    if (!tf) {
+      continue;
     }
 
     firstOrbit = tf->firstOrbit;
     firstOrbitDPL = tf->firstOrbitDPL;
-    fmt::print("firstOrbit: {}, firstOrbitDPL: {}\n", firstOrbit, firstOrbitDPL);
+
+    fmt::print("Entry {}: firstOrbit: {}, firstOrbitDPL: {}\n", i, firstOrbit, firstOrbitDPL);
 
     for (int cru = 0; cru < nCRUs; ++cru) {
       for (int tb = 0; tb < nTimeBins; ++tb) {
-        const float cmvValue = tf->getCMVFloat(cru, tb);
-        h2d->Fill(tb, cmvValue);
-        h1d->Fill(cmvValue);
+        yArr[cru * nTimeBins + tb] = tf->getCMVFloat(cru, tb);
+        // fmt::print("Entry {}: cru: {}, tb: {}, cmv: {}\n", i, cru, tb, tf->getCMVFloat(cru, tb));
       }
     }
+    h2d->FillN(fillsPerEntry, xArr.data(), yArr.data(), wArr.data());
+    h1d->FillN(fillsPerEntry, yArr.data(), wArr.data());
+    h2dCRU->FillN(fillsPerEntry, cruArr.data(), yArr.data(), wArr.data());
+    h1dCRU->FillN(fillsPerEntry, cruArr.data(), wArr.data());
   }
 
-  delete tfDecoded;
-  tree->ResetBranchAddresses();
-  delete tfCompressed;
+  fh.close();
 
   // draw
   auto* c = new TCanvas("cCMVvsTimeBin", "");
@@ -149,10 +131,20 @@ TObjArray* drawCMV(std::string_view filename, std::string_view outDir, std::stri
 
   arrCanvases->Add(c1);
 
+  auto* c2 = new TCanvas("cCRUDistribution", "");
+  h1dCRU->Draw();
+
+  arrCanvases->Add(c2);
+
+  auto* c3 = new TCanvas("cCMVvsCRU", "");
+  c3->SetLogz();
+  h2dCRU->Draw("colz");
+
+  arrCanvases->Add(c3);
+
   if (outDir.size()) {
     utils::saveCanvases(*arrCanvases, outDir, "", rootFileName);
   }
 
-  f.Close();
   return arrCanvases;
 }
diff --git a/Detectors/TPC/calibration/src/CMVHelper.cxx b/Detectors/TPC/calibration/src/CMVHelper.cxx
new file mode 100644
index 0000000000000..abcbd977a9acb
--- /dev/null
+++ b/Detectors/TPC/calibration/src/CMVHelper.cxx
@@ -0,0 +1,98 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   CMVHelper.cxx
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  Helper utilities for reading CMV ROOT files
+
+#include "TPCCalibration/CMVHelper.h"
+
+#include <iostream>
+
+#include "TPCCalibration/CMVContainer.h"
+#include "TParameter.h"
+
+namespace o2::tpc
+{
+
+bool CMVFileHandle::open(const std::string& path)
+{
+  file = TFile::Open(path.c_str());
+  if (!file || file->IsZombie()) {
+    std::cerr << "CMVFileHandle: failed to open: " << path << "\n";
+    return false;
+  }
+  file->GetObject("ccdb_object", tree);
+  if (!tree) {
+    std::cerr << "CMVFileHandle: TTree 'ccdb_object' not found in: " << path << "\n";
+    close();
+    return false;
+  }
+
+  // Extract firstTF / lastTF from UserInfo if stored by the aggregation workflow
+  if (auto* ui = tree->GetUserInfo()) {
+    if (auto* p = dynamic_cast<TParameter<long>*>(ui->FindObject("firstTF"))) {
+      firstTFInTree = p->GetVal();
+    }
+    if (auto* p = dynamic_cast<TParameter<long>*>(ui->FindObject("lastTF"))) {
+      lastTFInTree = p->GetVal();
+    }
+  }
+
+  isCompressed = (tree->GetBranch("CMVPerTFCompressed") != nullptr);
+  const bool isRaw = (tree->GetBranch("CMVPerTF") != nullptr);
+  if (!isCompressed && !isRaw) {
+    std::cerr << "CMVFileHandle: no recognised branch (CMVPerTFCompressed / CMVPerTF) in: "
+              << path << "\n";
+    close();
+    return false;
+  }
+
+  if (isCompressed) {
+    tree->SetBranchAddress("CMVPerTFCompressed", &tfCompressed);
+    tfDecoded = new CMVPerTF();
+  } else {
+    tree->SetBranchAddress("CMVPerTF", &tfRaw);
+  }
+  return true;
+}
+
+const CMVPerTF* CMVFileHandle::getEntry(long long iEntry)
+{
+  tree->GetEntry(iEntry);
+  if (isCompressed) {
+    if (!tfCompressed) {
+      return nullptr;
+    }
+    tfCompressed->decompress(tfDecoded);
+    return tfDecoded;
+  }
+  return tfRaw;
+}
+
+void CMVFileHandle::close()
+{
+  if (tree) {
+    tree->ResetBranchAddresses();
+    tree = nullptr;
+  }
+  tfCompressed = nullptr;
+  tfRaw = nullptr;
+  delete tfDecoded;
+  tfDecoded = nullptr;
+  if (file) {
+    file->Close();
+    delete file;
+    file = nullptr;
+  }
+}
+
+} // namespace o2::tpc
diff --git a/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h b/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
index 14d3d0a8ffb8e..847ae5ad7d788 100644
--- a/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
+++ b/Detectors/TPC/calibration/src/TPCCalibrationLinkDef.h
@@ -124,6 +124,7 @@
 #pragma link C++ class std::vector < o2::tpc::DigitAdd> + ;
 #pragma link C++ class o2::tpc::PressureTemperatureHelper + ;
 
+#pragma link C++ struct o2::tpc::CMVFileHandle + ;
 #pragma link C++ class o2::tpc::CMVPerTF + ;
 #pragma link C++ class o2::tpc::CMVPerTFCompressed + ;
 
diff --git a/Detectors/TPC/workflow/CMakeLists.txt b/Detectors/TPC/workflow/CMakeLists.txt
index 37ac398db40ec..f64a223f683d8 100644
--- a/Detectors/TPC/workflow/CMakeLists.txt
+++ b/Detectors/TPC/workflow/CMakeLists.txt
@@ -309,4 +309,9 @@ o2_add_executable(cmv-aggregate
                   SOURCES src/tpc-aggregate-cmv.cxx
                   PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
 
+o2_add_executable(cmv-trigger
+                  COMPONENT_NAME tpc
+                  SOURCES test/test_cmv-trigger.cxx
+                  PUBLIC_LINK_LIBRARIES O2::TPCWorkflow)
+
 add_subdirectory(readers)
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/CMVToVectorSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/CMVToVectorSpec.h
index add37af5706e5..2f9209ee07da8 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/CMVToVectorSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/CMVToVectorSpec.h
@@ -23,7 +23,7 @@ namespace o2::tpc
 
 /// create a processor spec
 /// convert CMV raw values to a vector in a CRU
-o2::framework::DataProcessorSpec getCMVToVectorSpec(const std::string inputSpec, std::vector<uint32_t> const& crus);
+o2::framework::DataProcessorSpec getCMVToVectorSpec(std::string const& inputSpec, std::vector<uint32_t> const& crus);
 
 } // end namespace o2::tpc
 
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h
index b46f2169f06c9..3383da527cccf 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCAggregateCMVSpec.h
@@ -49,9 +49,6 @@
 #include "CommonUtils/StringUtils.h"
 #include "DetectorsCommonDataFormats/FileMetaData.h"
 
-using namespace o2::framework;
-using o2::header::gDataOriginTPC;
-
 namespace o2::tpc
 {
 
@@ -114,7 +111,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     initIntervalTree();
   }
 
-  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
   {
     o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
   }
@@ -136,7 +133,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     }
 
     if (mSetDataTakingCont) {
-      mDataTakingContext = pc.services().get<DataTakingContext>();
+      mDataTakingContext = pc.services().get<o2::framework::DataTakingContext>();
       mSetDataTakingCont = false;
     }
 
@@ -147,7 +144,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     const auto currTF = processing_helpers::getCurrentTF(pc);
 
     if (mTFFirst == -1) {
-      for (auto& ref : InputRecordWalker(pc.inputs(), mFirstTFFilter)) {
+      for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mFirstTFFilter)) {
         mTFFirst = pc.inputs().get<long>(ref);
         mIntervalFirstTF = mTFFirst;
         mHasIntervalFirstTF = true;
@@ -203,7 +200,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     // Capture orbit info first so setTimestampCCDB can use the measured stride
     if (!mOrbitInfoSeen[relTF]) {
       // all CRUs within a batch carry identical timing, so the first one is sufficient
-      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+      for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mOrbitFilter)) {
         mOrbitInfo[relTF] = pc.inputs().get<uint64_t>(ref);
         const auto batchFirstOrbit = static_cast<uint32_t>(mOrbitInfo[relTF] >> 32);
         // TimingInfo.firstTForbit is the orbit of the last real TF in the batch (the TF that triggered the FLP to send).
@@ -222,8 +219,8 @@ class TPCAggregateCMVDevice : public o2::framework::Task
       setTimestampCCDB(relTF, mOrbitStep[relTF], pc);
     }
 
-    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
-      auto const* hdr = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mFilter)) {
+      auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
       const unsigned int cru = hdr->subSpecification;
       if (!(std::binary_search(mCRUs.begin(), mCRUs.end(), cru))) {
         LOGP(debug, "Received CMV data from CRU {} which is not part of this aggregate lane", cru);
@@ -233,7 +230,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
         continue;
       }
 
-      auto cmvVec = pc.inputs().get<pmr::vector<uint16_t>>(ref);
+      auto cmvVec = pc.inputs().get<o2::pmr::vector<uint16_t>>(ref);
       mRawCMVs[relTF][cru] = std::vector<uint16_t>(cmvVec.begin(), cmvVec.end());
       mProcessedCRUs[relTF][cru] = true;
       ++mProcessedCRU[relTF];
@@ -257,7 +254,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     materializeBufferedTFs(true);
     materializeEOSBuffer();
     sendOutput(ec.outputs());
-    ec.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+    ec.services().get<o2::framework::ControlService>().readyToQuit(o2::framework::QuitRequest::Me);
   }
 
   static constexpr header::DataDescription getDataDescriptionCCDBCMV() { return header::DataDescription{"TPC_CMV"}; }
@@ -314,18 +311,18 @@ class TPCAggregateCMVDevice : public o2::framework::Task
   std::unique_ptr<TTree> mIntervalTree{};                                      ///< in-memory TTree accumulating one entry per real TF; serialised to CCDB/disk at interval end
   CMVPerTF mCurrentTF{};                                                       ///< staging object written to the TTree branch for the uncompressed path
   CMVPerTFCompressed mCurrentCompressedTF{};                                   ///< staging object written to the TTree branch when any compression flags are set
-  const std::vector<InputSpec> mFilter{
+  const std::vector<o2::framework::InputSpec> mFilter{
     {"cmvagg",
-     ConcreteDataTypeMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(mLaneId)},
-     Lifetime::Sporadic}};
-  const std::vector<InputSpec> mOrbitFilter{
+     o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(mLaneId)},
+     o2::framework::Lifetime::Sporadic}};
+  const std::vector<o2::framework::InputSpec> mOrbitFilter{
     {"cmvorbit",
-     ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(mLaneId), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(mLaneId)}},
-     Lifetime::Sporadic}};
-  const std::vector<InputSpec> mFirstTFFilter{
+     o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(mLaneId), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(mLaneId)}},
+     o2::framework::Lifetime::Sporadic}};
+  const std::vector<o2::framework::InputSpec> mFirstTFFilter{
     {"firstTF",
-     ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(mLaneId)}},
-     Lifetime::Sporadic}};
+     o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(mLaneId)}},
+     o2::framework::Lifetime::Sporadic}};
 
   uint8_t buildCompressionFlags() const
   {
@@ -360,7 +357,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
   void collectEOSInputs(o2::framework::ProcessingContext& pc)
   {
     if (mEOSFirstOrbit == 0) {
-      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+      for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mOrbitFilter)) {
         const auto orbitBC = pc.inputs().get<uint64_t>(ref);
         mEOSFirstOrbit = static_cast<uint32_t>(orbitBC >> 32);
         mEOSFirstBC = static_cast<uint16_t>(orbitBC & 0xFFFFu);
@@ -368,13 +365,13 @@ class TPCAggregateCMVDevice : public o2::framework::Task
       }
     }
 
-    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
-      auto const* hdr = DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+    for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mFilter)) {
+      auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
       const unsigned int cru = hdr->subSpecification;
       if (!(std::binary_search(mCRUs.begin(), mCRUs.end(), cru))) {
         continue;
       }
-      auto cmvVec = pc.inputs().get<pmr::vector<uint16_t>>(ref);
+      auto cmvVec = pc.inputs().get<o2::pmr::vector<uint16_t>>(ref);
       auto& buffer = mEOSRawCMVs[cru];
       buffer.insert(buffer.end(), cmvVec.begin(), cmvVec.end());
     }
@@ -548,7 +545,7 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     }
   }
 
-  void sendOutput(DataAllocator& output)
+  void sendOutput(o2::framework::DataAllocator& output)
   {
     using timer = std::chrono::high_resolution_clock;
 
@@ -619,8 +616,8 @@ class TPCAggregateCMVDevice : public o2::framework::Task
     }
 
     LOGP(info, "Sending object {} / {} of size {} bytes, valid for {} : {}", ccdbInfoCMV.getPath(), ccdbInfoCMV.getFileName(), image->size(), ccdbInfoCMV.getStartValidityTimestamp(), ccdbInfoCMV.getEndValidityTimestamp());
-    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBCMV(), 0}, *image);
-    output.snapshot(Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBCMV(), 0}, ccdbInfoCMV);
+    output.snapshot(o2::framework::Output{o2::calibration::Utils::gDataOriginCDBPayload, getDataDescriptionCCDBCMV(), 0}, *image);
+    output.snapshot(o2::framework::Output{o2::calibration::Utils::gDataOriginCDBWrapper, getDataDescriptionCCDBCMV(), 0}, ccdbInfoCMV);
 
     auto stop = timer::now();
     std::chrono::duration<float> elapsed = stop - start;
@@ -666,25 +663,25 @@ class TPCAggregateCMVDevice : public o2::framework::Task
 
 /// Build a DataProcessorSpec for one aggregate lane
 /// Each lane receives CMV data from one distribute output lane (matched by lane index) and expects the full CRU list — the distribute stage already routes per-CRU data to the correct lane
-inline DataProcessorSpec getTPCAggregateCMVSpec(const int lane,
-                                                const std::vector<uint32_t>& crus,
-                                                const unsigned int timeframes,
-                                                const bool sendCCDB,
-                                                const bool usePreciseTimestamp,
-                                                const int nTFsBuffer = 1)
+inline o2::framework::DataProcessorSpec getTPCAggregateCMVSpec(const int lane,
+                                                               const std::vector<uint32_t>& crus,
+                                                               const unsigned int timeframes,
+                                                               const bool sendCCDB,
+                                                               const bool usePreciseTimestamp,
+                                                               const int nTFsBuffer = 1)
 {
-  std::vector<OutputSpec> outputSpecs;
+  std::vector<o2::framework::OutputSpec> outputSpecs;
   if (sendCCDB) {
-    outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, TPCAggregateCMVDevice::getDataDescriptionCCDBCMV()}, Lifetime::Sporadic);
-    outputSpecs.emplace_back(ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, TPCAggregateCMVDevice::getDataDescriptionCCDBCMV()}, Lifetime::Sporadic);
+    outputSpecs.emplace_back(o2::framework::ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBPayload, TPCAggregateCMVDevice::getDataDescriptionCCDBCMV()}, o2::framework::Lifetime::Sporadic);
+    outputSpecs.emplace_back(o2::framework::ConcreteDataTypeMatcher{o2::calibration::Utils::gDataOriginCDBWrapper, TPCAggregateCMVDevice::getDataDescriptionCCDBCMV()}, o2::framework::Lifetime::Sporadic);
   }
 
-  std::vector<InputSpec> inputSpecs;
-  inputSpecs.emplace_back(InputSpec{"cmvagg", ConcreteDataTypeMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(lane)}, Lifetime::Sporadic});
-  inputSpecs.emplace_back(InputSpec{"cmvorbit", gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(lane), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, Lifetime::Sporadic});
-  inputSpecs.emplace_back(InputSpec{"firstTF", gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, Lifetime::Sporadic});
+  std::vector<o2::framework::InputSpec> inputSpecs;
+  inputSpecs.emplace_back(o2::framework::InputSpec{"cmvagg", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(lane)}, o2::framework::Lifetime::Sporadic});
+  inputSpecs.emplace_back(o2::framework::InputSpec{"cmvorbit", o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(lane), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, o2::framework::Lifetime::Sporadic});
+  inputSpecs.emplace_back(o2::framework::InputSpec{"firstTF", o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, o2::framework::Lifetime::Sporadic});
   if (usePreciseTimestamp) {
-    inputSpecs.emplace_back(InputSpec{"orbitreset", gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, Lifetime::Sporadic});
+    inputSpecs.emplace_back(o2::framework::InputSpec{"orbitreset", o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{static_cast<unsigned int>(lane)}, o2::framework::Lifetime::Sporadic});
   }
 
   // Request GRPECS from CCDB so that GRPGeomHelper::getNHBFPerTF() is valid in this (separate) process
@@ -696,21 +693,21 @@ inline DataProcessorSpec getTPCAggregateCMVSpec(const int lane,
                                                                 o2::base::GRPGeomRequest::None, // geometry
                                                                 inputSpecs);
 
-  DataProcessorSpec spec{
+  o2::framework::DataProcessorSpec spec{
     fmt::format("tpc-aggregate-cmv-{:02}", lane).data(),
     inputSpecs,
     outputSpecs,
-    AlgorithmSpec{adaptFromTask<TPCAggregateCMVDevice>(lane, crus, timeframes, sendCCDB, usePreciseTimestamp, nTFsBuffer, ccdbRequest)},
-    Options{{"output-dir", VariantType::String, "/dev/null", {"CMV output directory, must exist (if not /dev/null)"}},
-            {"meta-output-dir", VariantType::String, "/dev/null", {"calibration metadata output directory, must exist (if not /dev/null)"}},
-            {"nthreads-compression", VariantType::Int, 1, {"Number of threads used for CMV per timeframe preprocessing and compression"}},
-            {"use-sparse", VariantType::Bool, false, {"Sparse encoding (skip zero time bins). Alone: raw uint16 values. With --use-compression-varint: varint exact values. With --use-compression-huffman: Huffman exact values"}},
-            {"use-compression-varint", VariantType::Bool, false, {"Delta+zigzag+varint compression (all values). Combined with --use-sparse: sparse positions + varint encoded exact CMV values"}},
-            {"use-compression-huffman", VariantType::Bool, false, {"Huffman encoding. Combined with --use-sparse: sparse positions + Huffman-encoded exact CMV values"}},
-            {"cmv-zero-threshold", VariantType::Float, 0.f, {"Zero out CMV values whose float magnitude is below this threshold after optional integer rounding and before compression; 0 disables"}},
-            {"cmv-round-integers-threshold", VariantType::Int, 0, {"Round values to nearest integer ADC for |v| <= N ADC before compression; 0 disables"}},
-            {"cmv-dynamic-precision-mean", VariantType::Float, 1.f, {"Gaussian centre in |CMV| ADC where the strongest fractional bit trimming is applied"}},
-            {"cmv-dynamic-precision-sigma", VariantType::Float, 0.f, {"Gaussian width in ADC for smooth CMV fractional bit trimming; 0 disables"}}}};
+    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<TPCAggregateCMVDevice>(lane, crus, timeframes, sendCCDB, usePreciseTimestamp, nTFsBuffer, ccdbRequest)},
+    o2::framework::Options{{"output-dir", o2::framework::VariantType::String, "/dev/null", {"CMV output directory, must exist (if not /dev/null)"}},
+                           {"meta-output-dir", o2::framework::VariantType::String, "/dev/null", {"calibration metadata output directory, must exist (if not /dev/null)"}},
+                           {"nthreads-compression", o2::framework::VariantType::Int, 1, {"Number of threads used for CMV per timeframe preprocessing and compression"}},
+                           {"use-sparse", o2::framework::VariantType::Bool, false, {"Sparse encoding (skip zero time bins). Alone: raw uint16 values. With --use-compression-varint: varint exact values. With --use-compression-huffman: Huffman exact values"}},
+                           {"use-compression-varint", o2::framework::VariantType::Bool, false, {"Delta+zigzag+varint compression (all values). Combined with --use-sparse: sparse positions + varint encoded exact CMV values"}},
+                           {"use-compression-huffman", o2::framework::VariantType::Bool, false, {"Huffman encoding. Combined with --use-sparse: sparse positions + Huffman-encoded exact CMV values"}},
+                           {"cmv-zero-threshold", o2::framework::VariantType::Float, 0.f, {"Zero out CMV values whose float magnitude is below this threshold after optional integer rounding and before compression; 0 disables"}},
+                           {"cmv-round-integers-threshold", o2::framework::VariantType::Int, 0, {"Round values to nearest integer ADC for |v| <= N ADC before compression; 0 disables"}},
+                           {"cmv-dynamic-precision-mean", o2::framework::VariantType::Float, 1.f, {"Gaussian centre in |CMV| ADC where the strongest fractional bit trimming is applied"}},
+                           {"cmv-dynamic-precision-sigma", o2::framework::VariantType::Float, 0.f, {"Gaussian width in ADC for smooth CMV fractional bit trimming; 0 disables"}}}};
   spec.rank = lane;
   return spec;
 }
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
index f3373070ab7bb..af576b2f30a5b 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCDistributeCMVSpec.h
@@ -36,10 +36,6 @@
 #include "DetectorsBase/GRPGeomHelper.h"
 #include "CommonDataFormat/Pair.h"
 
-using namespace o2::framework;
-using o2::header::gDataOriginTPC;
-using namespace o2::tpc;
-
 namespace o2::tpc
 {
 
@@ -78,8 +74,8 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       }
     }
 
-    mFilter.emplace_back(InputSpec{"cmvsgroup", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, Lifetime::Sporadic});
-    mOrbitFilter.emplace_back(InputSpec{"cmvorbit", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo()}, Lifetime::Sporadic});
+    mFilter.emplace_back(o2::framework::InputSpec{"cmvsgroup", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, o2::framework::Lifetime::Sporadic});
+    mOrbitFilter.emplace_back(o2::framework::InputSpec{"cmvorbit", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo()}, o2::framework::Lifetime::Sporadic});
   }
 
   void init(o2::framework::InitContext& ic) final
@@ -97,13 +93,13 @@ class TPCDistributeCMVSpec : public o2::framework::Task
     }
   }
 
-  void finaliseCCDB(ConcreteDataMatcher& matcher, void* obj) final
+  void finaliseCCDB(o2::framework::ConcreteDataMatcher& matcher, void* obj) final
   {
     o2::base::GRPGeomHelper::instance().finaliseCCDB(matcher, obj);
-    if (matcher == ConcreteDataMatcher("CTP", "ORBITRESET", 0)) {
+    if (matcher == o2::framework::ConcreteDataMatcher("CTP", "ORBITRESET", 0)) {
       LOGP(debug, "Updating ORBITRESET");
       std::fill(mSendCCDBOutputOrbitReset.begin(), mSendCCDBOutputOrbitReset.end(), true);
-    } else if (matcher == ConcreteDataMatcher("GLO", "GRPECS", 0)) {
+    } else if (matcher == o2::framework::ConcreteDataMatcher("GLO", "GRPECS", 0)) {
       // check if received object is valid
       if (o2::base::GRPGeomHelper::instance().getGRPECS()->getRun() != 0) {
         LOGP(debug, "Updating GRPECS");
@@ -175,18 +171,18 @@ class TPCDistributeCMVSpec : public o2::framework::Task
 
     if (mSendOutputStartInfo[currentBuffer]) {
       mSendOutputStartInfo[currentBuffer] = false;
-      pc.outputs().snapshot(Output{gDataOriginTPC, getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{currentOutLane}}, mTFStart[currentBuffer]);
+      pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{currentOutLane}}, mTFStart[currentBuffer]);
     }
 
     if (mSendCCDBOutputOrbitReset[currentOutLane] && mSendCCDBOutputGRPECS[currentOutLane]) {
       mSendCCDBOutputOrbitReset[currentOutLane] = false;
       mSendCCDBOutputGRPECS[currentOutLane] = false;
-      pc.outputs().snapshot(Output{gDataOriginTPC, getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{currentOutLane}}, dataformats::Pair<long, int>{o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS(), o2::base::GRPGeomHelper::instance().getNHBFPerTF()});
+      pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{currentOutLane}}, dataformats::Pair<long, int>{o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS(), o2::base::GRPGeomHelper::instance().getNHBFPerTF()});
     }
 
     forwardOrbitInfo(pc, currentBuffer, relTF, currentOutLane);
 
-    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+    for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mFilter)) {
       auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
       const unsigned int cru = tpcCRUHeader->subSpecification >> 7;
 
@@ -204,7 +200,7 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       // to keep track of processed CRUs
       mProcessedCRUs[currentBuffer][relTF][cru] = true;
 
-      sendOutput(pc, currentOutLane, cru, pc.inputs().get<pmr::vector<uint16_t>>(ref));
+      sendOutput(pc, currentOutLane, cru, pc.inputs().get<o2::pmr::vector<uint16_t>>(ref));
     }
 
     LOGP(detail, "Number of received CRUs for current TF: {} Needed a total number of processed CRUs of: {} Current TF: {}", mProcessedCRU[currentBuffer][relTF], mCRUs.size(), tf);
@@ -223,7 +219,7 @@ class TPCDistributeCMVSpec : public o2::framework::Task
     }
   }
 
-  void endOfStream(o2::framework::EndOfStreamContext& ec) final { ec.services().get<ControlService>().readyToQuit(QuitRequest::Me); }
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final { ec.services().get<o2::framework::ControlService>().readyToQuit(o2::framework::QuitRequest::Me); }
 
   /// Return data description for aggregated CMVs for a given lane
   static header::DataDescription getDataDescriptionCMV(const unsigned int lane)
@@ -267,8 +263,8 @@ class TPCDistributeCMVSpec : public o2::framework::Task
   std::array<int, 2> mStartNTFsDataDrop{0};                                            ///< first relative TF index to check for missing data in each buffer
   long mProcessedTotalData{0};                                                         ///< call counter used to throttle checkIntervalsForMissingData checks
   int mCheckEveryNData{1};                                                             ///< check for missing data every N run() calls (0 → default = mTimeFrames/2)
-  std::vector<InputSpec> mFilter{};                                                    ///< filter for looping over CMVGROUP input data from FLPs
-  std::vector<InputSpec> mOrbitFilter{};                                               ///< filter for CMVORBITINFO input from FLPs
+  std::vector<o2::framework::InputSpec> mFilter{};                                     ///< filter for looping over CMVGROUP input data from FLPs
+  std::vector<o2::framework::InputSpec> mOrbitFilter{};                                ///< filter for CMVORBITINFO input from FLPs
   std::vector<header::DataDescription> mDataDescrOut{};                                ///< per-output-lane CMV data descriptions (CMVAGG0, CMVAGG1, …)
   std::vector<header::DataDescription> mOrbitDescrOut{};                               ///< per-output-lane orbit-info data descriptions (CMVORB0, CMVORB1, …)
   std::array<std::vector<bool>, 2> mOrbitInfoForwarded{};                              ///< tracks whether orbit/BC has been forwarded to the aggregate lane per (buffer, relTF)
@@ -280,12 +276,12 @@ class TPCDistributeCMVSpec : public o2::framework::Task
 
   void sendOutput(o2::framework::ProcessingContext& pc, const unsigned int currentOutLane, const unsigned int cru, o2::pmr::vector<uint16_t> cmvs)
   {
-    pc.outputs().adoptContainer(Output{gDataOriginTPC, mDataDescrOut[currentOutLane], header::DataHeader::SubSpecificationType{cru}}, std::move(cmvs));
+    pc.outputs().adoptContainer(o2::framework::Output{o2::header::gDataOriginTPC, mDataDescrOut[currentOutLane], header::DataHeader::SubSpecificationType{cru}}, std::move(cmvs));
   }
 
   void sendOrbitInfo(o2::framework::ProcessingContext& pc, const unsigned int outLane, const uint64_t orbitInfo)
   {
-    pc.outputs().snapshot(Output{gDataOriginTPC, mOrbitDescrOut[outLane], header::DataHeader::SubSpecificationType{outLane}}, orbitInfo);
+    pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, mOrbitDescrOut[outLane], header::DataHeader::SubSpecificationType{outLane}}, orbitInfo);
   }
 
   void forwardOrbitInfo(o2::framework::ProcessingContext& pc, const bool currentBuffer, const unsigned int relTF, const unsigned int currentOutLane)
@@ -294,7 +290,7 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       return;
     }
 
-    for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+    for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mOrbitFilter)) {
       auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
       const unsigned int cru = hdr->subSpecification >> 7;
       if (!std::binary_search(mCRUs.begin(), mCRUs.end(), cru)) {
@@ -313,17 +309,17 @@ class TPCDistributeCMVSpec : public o2::framework::Task
 
     if (mSendOutputStartInfo[mBuffer] && (mTFStart[mBuffer] >= 0)) {
       mSendOutputStartInfo[mBuffer] = false;
-      pc.outputs().snapshot(Output{gDataOriginTPC, getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{currentOutLane}}, mTFStart[mBuffer]);
+      pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{currentOutLane}}, mTFStart[mBuffer]);
     }
 
     if (mSendCCDBOutputOrbitReset[currentOutLane] && mSendCCDBOutputGRPECS[currentOutLane]) {
       mSendCCDBOutputOrbitReset[currentOutLane] = false;
       mSendCCDBOutputGRPECS[currentOutLane] = false;
-      pc.outputs().snapshot(Output{gDataOriginTPC, getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{currentOutLane}}, dataformats::Pair<long, int>{o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS(), o2::base::GRPGeomHelper::instance().getNHBFPerTF()});
+      pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{currentOutLane}}, dataformats::Pair<long, int>{o2::base::GRPGeomHelper::instance().getOrbitResetTimeMS(), o2::base::GRPGeomHelper::instance().getNHBFPerTF()});
     }
 
     if (!mOrbitInfoForwarded[mBuffer].empty()) {
-      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+      for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mOrbitFilter)) {
         auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
         const unsigned int cru = hdr->subSpecification >> 7;
         if (!std::binary_search(mCRUs.begin(), mCRUs.end(), cru)) {
@@ -334,13 +330,13 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       }
     }
 
-    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+    for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mFilter)) {
       auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
       const unsigned int cru = hdr->subSpecification >> 7;
       if (!std::binary_search(mCRUs.begin(), mCRUs.end(), cru)) {
         continue;
       }
-      sendOutput(pc, currentOutLane, cru, pc.inputs().get<pmr::vector<uint16_t>>(ref));
+      sendOutput(pc, currentOutLane, cru, pc.inputs().get<o2::pmr::vector<uint16_t>>(ref));
     }
   }
 
@@ -398,7 +394,7 @@ class TPCDistributeCMVSpec : public o2::framework::Task
         for (auto& it : mProcessedCRUs[currentBuffer][iTF]) {
           if (!it.second) {
             it.second = true;
-            sendOutput(pc, outLane, it.first, pmr::vector<uint16_t>());
+            sendOutput(pc, outLane, it.first, o2::pmr::vector<uint16_t>());
           }
         }
 
@@ -417,7 +413,7 @@ class TPCDistributeCMVSpec : public o2::framework::Task
       mNFactorTFs = 0;
       // ToDo: Find better fix. Set oldestForChannel to a very large value so the DPL dispatcher does not block waiting for older TF data that will never arrive
       for (unsigned int ilane = 0; ilane < mOutLanes; ++ilane) {
-        auto& deviceProxy = pc.services().get<FairMQDeviceProxy>();
+        auto& deviceProxy = pc.services().get<o2::framework::FairMQDeviceProxy>();
         auto& state = deviceProxy.getOutputChannelState({static_cast<int>(ilane)});
         size_t oldest = std::numeric_limits<size_t>::max() - 1;
         state.oldestForChannel = {oldest};
@@ -431,18 +427,18 @@ class TPCDistributeCMVSpec : public o2::framework::Task
   }
 };
 
-DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const unsigned int timeframes, const unsigned int outlanes, const int firstTF, const bool sendPrecisetimeStamp = false, const int nTFsBuffer = 1)
+o2::framework::DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const unsigned int timeframes, const unsigned int outlanes, const int firstTF, const bool sendPrecisetimeStamp = false, const int nTFsBuffer = 1)
 {
-  std::vector<InputSpec> inputSpecs;
-  inputSpecs.emplace_back(InputSpec{"cmvsgroup", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, Lifetime::Sporadic});
-  inputSpecs.emplace_back(InputSpec{"cmvorbit", ConcreteDataTypeMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo()}, Lifetime::Sporadic});
+  std::vector<o2::framework::InputSpec> inputSpecs;
+  inputSpecs.emplace_back(o2::framework::InputSpec{"cmvsgroup", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup()}, o2::framework::Lifetime::Sporadic});
+  inputSpecs.emplace_back(o2::framework::InputSpec{"cmvorbit", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo()}, o2::framework::Lifetime::Sporadic});
 
-  std::vector<OutputSpec> outputSpecs;
+  std::vector<o2::framework::OutputSpec> outputSpecs;
   outputSpecs.reserve(3 * outlanes);
   for (unsigned int lane = 0; lane < outlanes; ++lane) {
-    outputSpecs.emplace_back(ConcreteDataTypeMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(lane)}, Lifetime::Sporadic);
-    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(lane), header::DataHeader::SubSpecificationType{lane}}, Lifetime::Sporadic);
-    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{lane}}, Lifetime::Sporadic);
+    outputSpecs.emplace_back(o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMV(lane)}, o2::framework::Lifetime::Sporadic);
+    outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitInfo(lane), header::DataHeader::SubSpecificationType{lane}}, o2::framework::Lifetime::Sporadic);
+    outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVFirstTF(), header::DataHeader::SubSpecificationType{lane}}, o2::framework::Lifetime::Sporadic);
   }
 
   // Only lane 0 fetches CCDB orbit-reset/GRPECS objects and broadcasts them to all aggregate lanes, the other distribute lanes do not need them, avoiding redundant CCDB requests
@@ -450,7 +446,7 @@ DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uin
   if (sendPrecisetimeStamp && (ilane == 0)) {
     fetchCCDB = true;
     for (unsigned int lane = 0; lane < outlanes; ++lane) {
-      outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{lane}}, Lifetime::Sporadic);
+      outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCDistributeCMVSpec::getDataDescriptionCMVOrbitReset(), header::DataHeader::SubSpecificationType{lane}}, o2::framework::Lifetime::Sporadic);
     }
   }
 
@@ -463,14 +459,14 @@ DataProcessorSpec getTPCDistributeCMVSpec(const int ilane, const std::vector<uin
                                                                 inputSpecs);
 
   const auto id = fmt::format("tpc-distribute-cmv-{:02}", ilane);
-  DataProcessorSpec spec{
+  o2::framework::DataProcessorSpec spec{
     id.data(),
     inputSpecs,
     outputSpecs,
-    AlgorithmSpec{adaptFromTask<TPCDistributeCMVSpec>(crus, timeframes, nTFsBuffer, outlanes, firstTF, ccdbRequest)},
-    Options{{"drop-data-after-nTFs", VariantType::Int, 0, {"Number of TFs after which to drop the data."}},
-            {"check-data-every-n", VariantType::Int, 0, {"Number of run function called after which to check for missing data (-1 for no checking, 0 for default checking)."}},
-            {"nFactorTFs", VariantType::Int, 1000, {"Number of TFs to skip for sending oldest TF."}}}};
+    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<TPCDistributeCMVSpec>(crus, timeframes, nTFsBuffer, outlanes, firstTF, ccdbRequest)},
+    o2::framework::Options{{"drop-data-after-nTFs", o2::framework::VariantType::Int, 0, {"Number of TFs after which to drop the data."}},
+                           {"check-data-every-n", o2::framework::VariantType::Int, 0, {"Number of run function called after which to check for missing data (-1 for no checking, 0 for default checking)."}},
+                           {"nFactorTFs", o2::framework::VariantType::Int, 1000, {"Number of TFs to skip for sending oldest TF."}}}};
   spec.rank = ilane;
   return spec;
 }
diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
index 9931c27c9d3fa..4b7886d4493a7 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
@@ -13,8 +13,8 @@
 /// @author Tuba Gündem, tuba.gundem@cern.ch
 /// @brief TPC device for processing CMVs on FLPs
 
-#ifndef O2_TPCFLPIDCSPEC_H
-#define O2_TPCFLPIDCSPEC_H
+#ifndef O2_TPCFLPCMVSPEC_H
+#define O2_TPCFLPCMVSPEC_H
 
 #include <vector>
 #include <unordered_map>
@@ -28,12 +28,9 @@
 #include "Headers/DataHeader.h"
 #include "TPCWorkflow/ProcessingHelpers.h"
 #include "TPCBase/CRU.h"
+#include "DataFormatsTPC/CMV.h"
 #include "TFile.h"
 
-using namespace o2::framework;
-using o2::header::gDataOriginTPC;
-using namespace o2::tpc;
-
 namespace o2::tpc
 {
 
@@ -46,6 +43,12 @@ class TPCFLPCMVDevice : public o2::framework::Task
   void init(o2::framework::InitContext& ic) final
   {
     mDumpCMVs = ic.options().get<bool>("dump-cmvs-flp");
+    mEnableTrigger = ic.options().get<bool>("trigger");
+    mTriggerThresholdCMV = ic.options().get<float>("trigger-threshold-cmv");
+    mTriggerThresholdMeanMax = ic.options().get<float>("trigger-threshold-cmvMeanMax");
+    mTriggerThresholdMeanMin = ic.options().get<float>("trigger-threshold-cmvMeanMin");
+    mTriggerTimebinMin = ic.options().get<int>("trigger-threshold-timebinMin");
+    mTriggerTimebinMax = ic.options().get<int>("trigger-threshold-timebinMax");
   }
 
   void run(o2::framework::ProcessingContext& pc) final
@@ -56,7 +59,7 @@ class TPCFLPCMVDevice : public o2::framework::Task
 
     // Capture heartbeatOrbit / heartbeatBC from the first TF in the buffer
     if (mCountTFsForBuffer == 1) {
-      for (auto& ref : InputRecordWalker(pc.inputs(), mOrbitFilter)) {
+      for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mOrbitFilter)) {
         auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
         const uint32_t cru = hdr->subSpecification >> 7;
         if (mFirstOrbitBC.find(cru) == mFirstOrbitBC.end()) {
@@ -68,12 +71,18 @@ class TPCFLPCMVDevice : public o2::framework::Task
       }
     }
 
-    for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+    bool triggered = false;
+    for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mFilter)) {
       auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
-      const int cru = tpcCRUHeader->subSpecification >> 7;
+      const uint32_t cru = tpcCRUHeader->subSpecification >> 7;
       auto vecCMVs = pc.inputs().get<o2::pmr::vector<uint16_t>>(ref);
       mCMVs[cru].insert(mCMVs[cru].end(), vecCMVs.begin(), vecCMVs.end());
+
+      const bool cruTriggered = mEnableTrigger && evaluateTrigger(vecCMVs);
+      triggered |= cruTriggered;
     }
+    const header::DataHeader::SubSpecificationType trigSubSpec{mCRUs.front() << 7};
+    pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVTrigger(), trigSubSpec}, triggered);
 
     if (mCountTFsForBuffer >= mNTFsBuffer) {
       mCountTFsForBuffer = 0;
@@ -86,7 +95,7 @@ class TPCFLPCMVDevice : public o2::framework::Task
 
     if (mDumpCMVs) {
       TFile fOut(fmt::format("CMVs_{}_tf_{}.root", mLane, processing_helpers::getCurrentTF(pc)).data(), "RECREATE");
-      for (auto& ref : InputRecordWalker(pc.inputs(), mFilter)) {
+      for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mFilter)) {
         auto const* tpcCRUHeader = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
         const int cru = tpcCRUHeader->subSpecification >> 7;
         auto vec = pc.inputs().get<std::vector<uint16_t>>(ref);
@@ -103,7 +112,7 @@ class TPCFLPCMVDevice : public o2::framework::Task
         sendOutput(ec.outputs(), cru);
       }
     }
-    ec.services().get<ControlService>().readyToQuit(QuitRequest::Me);
+    ec.services().get<o2::framework::ControlService>().readyToQuit(o2::framework::QuitRequest::Me);
   }
 
   static constexpr header::DataDescription getDataDescriptionCMVGroup() { return header::DataDescription{"CMVGROUP"}; }
@@ -111,6 +120,9 @@ class TPCFLPCMVDevice : public o2::framework::Task
   /// Data description for the packed (orbit<<32|bc) scalar forwarded alongside each CRU's CMVGROUP.
   static constexpr header::DataDescription getDataDescriptionCMVOrbitInfo() { return header::DataDescription{"CMVORBITINFO"}; }
 
+  /// Data description for the per-CRU per-TF trigger flag (empty span = not triggered or disabled; {1} = triggered).
+  static constexpr header::DataDescription getDataDescriptionCMVTrigger() { return header::DataDescription{"CMVTRIGGER"}; }
+
  private:
   const int mLane{};                                                   ///< lane number of processor
   const std::vector<uint32_t> mCRUs{};                                 ///< CRUs to process in this instance
@@ -119,13 +131,53 @@ class TPCFLPCMVDevice : public o2::framework::Task
   int mCountTFsForBuffer{0};                                           ///< counts TFs to track when to send output
   std::unordered_map<unsigned int, o2::pmr::vector<uint16_t>> mCMVs{}; ///< buffered raw 16-bit CMV values per CRU
   std::unordered_map<uint32_t, uint64_t> mFirstOrbitBC{};              ///< first packed orbit/BC per CRU for the current buffer window
+  bool mEnableTrigger{false};                                          ///< enable CMV trigger evaluation
+  float mTriggerThresholdCMV{-10.f};                                   ///< CMV value threshold: trigger sequence starts when value drops below this
+  float mTriggerThresholdMeanMax{-40.f};                               ///< upper bound on trigger-sequence mean CMV value
+  float mTriggerThresholdMeanMin{-80.f};                               ///< lower bound on trigger-sequence mean CMV value
+  int mTriggerTimebinMin{4};                                           ///< minimum trigger-sequence length (timebins) to accept
+  int mTriggerTimebinMax{-1};                                          ///< maximum trigger-sequence length (timebins) to accept; -1 disables
 
   /// Filter for CMV float vectors (one CMVVECTOR message per CRU per TF)
-  const std::vector<InputSpec> mFilter = {{"cmvs", ConcreteDataTypeMatcher{gDataOriginTPC, "CMVVECTOR"}, Lifetime::Timeframe}};
+  const std::vector<o2::framework::InputSpec> mFilter = {{"cmvs", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, "CMVVECTOR"}, o2::framework::Lifetime::Timeframe}};
   /// Filter for CMV packet timing info (one CMVORBITS message per CRU per TF, sent by CMVToVectorSpec)
-  const std::vector<InputSpec> mOrbitFilter = {{"cmvorbits", ConcreteDataTypeMatcher{gDataOriginTPC, "CMVORBITS"}, Lifetime::Timeframe}};
+  const std::vector<o2::framework::InputSpec> mOrbitFilter = {{"cmvorbits", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, "CMVORBITS"}, o2::framework::Lifetime::Timeframe}};
+
+  // Scan a CRU's CMV vector for contiguous below-threshold sequences.
+  // Returns true as soon as one sequence satisfies both the length and mean criteria.
+  bool evaluateTrigger(const o2::pmr::vector<uint16_t>& cmvs) const
+  {
+    float seqSum = 0.f;
+    int seqLen = 0;
+
+    auto checkSequence = [&]() -> bool {
+      if (seqLen == 0) {
+        return false;
+      }
+      const float mean = seqSum / seqLen;
+      return (seqLen >= mTriggerTimebinMin) &&
+             (mTriggerTimebinMax < 0 || seqLen <= mTriggerTimebinMax) &&
+             (mean >= mTriggerThresholdMeanMin) &&
+             (mean <= mTriggerThresholdMeanMax);
+    };
+
+    for (const auto raw : cmvs) {
+      const float val = cmv::Data{raw}.getCMVFloat();
+      if (val < mTriggerThresholdCMV) {
+        seqSum += val;
+        ++seqLen;
+      } else {
+        if (checkSequence()) {
+          return true;
+        }
+        seqLen = 0;
+        seqSum = 0.f;
+      }
+    }
+    return checkSequence(); // trailing sequence that reached end of buffer
+  }
 
-  void sendOutput(DataAllocator& output, const uint32_t cru)
+  void sendOutput(o2::framework::DataAllocator& output, const uint32_t cru)
   {
     const header::DataHeader::SubSpecificationType subSpec{cru << 7};
 
@@ -134,39 +186,50 @@ class TPCFLPCMVDevice : public o2::framework::Task
     if (auto it = mFirstOrbitBC.find(cru); it != mFirstOrbitBC.end()) {
       orbitBC = it->second;
     }
-    output.snapshot(Output{gDataOriginTPC, getDataDescriptionCMVOrbitInfo(), subSpec}, orbitBC);
+    output.snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVOrbitInfo(), subSpec}, orbitBC);
 
-    output.adoptContainer(Output{gDataOriginTPC, getDataDescriptionCMVGroup(), subSpec}, std::move(mCMVs[cru]));
+    output.adoptContainer(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVGroup(), subSpec}, std::move(mCMVs[cru]));
   }
 };
 
-DataProcessorSpec getTPCFLPCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const int nTFsBuffer = 1)
+o2::framework::DataProcessorSpec getTPCFLPCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const int nTFsBuffer = 1)
 {
-  std::vector<OutputSpec> outputSpecs;
-  std::vector<InputSpec> inputSpecs;
-  outputSpecs.reserve(crus.size());
-  inputSpecs.reserve(crus.size());
+  std::vector<o2::framework::OutputSpec> outputSpecs;
+  std::vector<o2::framework::InputSpec> inputSpecs;
+  outputSpecs.reserve(crus.size() * 2 + 1);
+  inputSpecs.reserve(crus.size() * 2);
 
   for (const auto& cru : crus) {
     const header::DataHeader::SubSpecificationType subSpec{cru << 7};
 
     // Inputs from CMVToVectorSpec
-    inputSpecs.emplace_back(InputSpec{"cmvs", gDataOriginTPC, "CMVVECTOR", subSpec, Lifetime::Timeframe});
-    inputSpecs.emplace_back(InputSpec{"cmvorbits", gDataOriginTPC, "CMVORBITS", subSpec, Lifetime::Timeframe});
+    inputSpecs.emplace_back(o2::framework::InputSpec{"cmvs", o2::header::gDataOriginTPC, "CMVVECTOR", subSpec, o2::framework::Lifetime::Timeframe});
+    inputSpecs.emplace_back(o2::framework::InputSpec{"cmvorbits", o2::header::gDataOriginTPC, "CMVORBITS", subSpec, o2::framework::Lifetime::Timeframe});
 
     // Outputs to TPCDistributeCMVSpec
-    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup(), subSpec}, Lifetime::Sporadic);
-    outputSpecs.emplace_back(ConcreteDataMatcher{gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo(), subSpec}, Lifetime::Sporadic);
+    outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup(), subSpec}, o2::framework::Lifetime::Sporadic);
+    outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo(), subSpec}, o2::framework::Lifetime::Sporadic);
   }
 
+  // Single per-FLP trigger output, subspec keyed on the first CRU
+  const header::DataHeader::SubSpecificationType trigSubSpec{crus.front() << 7};
+  outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVTrigger(), trigSubSpec}, o2::framework::Lifetime::Timeframe);
+
   const auto id = fmt::format("tpc-flp-cmv-{:02}", ilane);
-  return DataProcessorSpec{
+  return o2::framework::DataProcessorSpec{
     id.data(),
     inputSpecs,
     outputSpecs,
-    AlgorithmSpec{adaptFromTask<TPCFLPCMVDevice>(ilane, crus, nTFsBuffer)},
-    Options{{"dump-cmvs-flp", VariantType::Bool, false, {"Dump CMVs to file"}}}};
+    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<TPCFLPCMVDevice>(ilane, crus, nTFsBuffer)},
+    o2::framework::Options{
+      {"dump-cmvs-flp", o2::framework::VariantType::Bool, false, {"Dump CMVs to file"}},
+      {"trigger", o2::framework::VariantType::Bool, false, {"Enable CMV trigger evaluation"}},
+      {"trigger-threshold-cmv", o2::framework::VariantType::Float, -10.f, {"CMV threshold: sequence starts when value drops below this (ADC units)"}},
+      {"trigger-threshold-cmvMeanMax", o2::framework::VariantType::Float, -40.f, {"Upper bound on trigger-sequence mean CMV value"}},
+      {"trigger-threshold-cmvMeanMin", o2::framework::VariantType::Float, -80.f, {"Lower bound on trigger-sequence mean CMV value"}},
+      {"trigger-threshold-timebinMin", o2::framework::VariantType::Int, 4, {"Minimum trigger-sequence length in timebins"}},
+      {"trigger-threshold-timebinMax", o2::framework::VariantType::Int, -1, {"Maximum trigger-sequence length in timebins (-1 disables upper bound)"}}}};
 }
 
 } // namespace o2::tpc
-#endif
\ No newline at end of file
+#endif
diff --git a/Detectors/TPC/workflow/src/CMVToVectorSpec.cxx b/Detectors/TPC/workflow/src/CMVToVectorSpec.cxx
index 81ce358d1a809..86cf4ca97aa19 100644
--- a/Detectors/TPC/workflow/src/CMVToVectorSpec.cxx
+++ b/Detectors/TPC/workflow/src/CMVToVectorSpec.cxx
@@ -76,7 +76,6 @@ class CMVToVectorDevice : public o2::framework::Task
   {
     const auto runNumber = processing_helpers::getRunNumber(pc);
     std::vector<InputSpec> filter = {{"check", ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, "RAWDATA"}, Lifetime::Timeframe}};
-    const auto& mapper = Mapper::instance();
 
     // open files if necessary
     if ((mWriteDebug || mWriteDebugOnError) && !mDebugStream) {
@@ -95,10 +94,7 @@ class CMVToVectorDevice : public o2::framework::Task
       mRawOutputFile.open(rawFileName, std::ios::binary);
     }
 
-    uint32_t heartbeatOrbit = 0;
-    uint16_t heartbeatBC = 0;
     uint32_t tfCounter = 0;
-    bool first = true;
     bool hasErrors = false;
 
     for (auto const& ref : InputRecordWalker(pc.inputs(), filter)) {
@@ -149,7 +145,7 @@ class CMVToVectorDevice : public o2::framework::Task
           LOGP(debug, "Processing firstTForbit {:9}, tfCounter {:5}, run {:6}, feeId {:6}, cruID {:3}, link {:2}", dh->firstTForbit, dh->tfCounter, dh->runNumber, feeId, cruID, link);
 
           if (std::find(mCRUs.begin(), mCRUs.end(), cruID) == mCRUs.end()) {
-            LOGP(warning, "CMV CRU {:3} not configured in CRUs, skipping", cruID);
+            // LOGP(debug, "CMV CRU {:3} not configured in CRUs, skipping", cruID);
             continue;
           }
 
@@ -171,7 +167,7 @@ class CMVToVectorDevice : public o2::framework::Task
           cmvVec.reserve(cmvVec.size() + cmv::NTimeBinsPerPacket);
           for (uint32_t tb = 0; tb < cmv::NTimeBinsPerPacket; ++tb) {
             cmvVec.push_back(cmvs.getCMV(tb));
-            // LOGP(debug, "Appended CMV {} for timebin {}, CRU {}, orbit {}, bc {}", cmvs.getCMV(tb), tb, cruID, orbit, bc);
+            // LOGP(debug, "For CRU {}, timebin {}, orbit {}, bc {}, appended CMV {} float: {}", cruID, tb, orbit, bc, cmvs.getCMV(tb), cmvs.getCMVFloat(tb));
           }
         }
       } catch (const std::exception& e) {
@@ -204,7 +200,7 @@ class CMVToVectorDevice : public o2::framework::Task
       }
     }
 
-    hasErrors |= snapshotCMVs(pc.outputs(), tfCounter);
+    hasErrors |= snapshotCMVs(pc.outputs());
 
     if (mWriteDebug || (mWriteDebugOnError && hasErrors)) {
       writeDebugOutput(tfCounter);
@@ -274,7 +270,7 @@ class CMVToVectorDevice : public o2::framework::Task
   std::string mRawOutputFileName;                                  ///< name of the raw output file
 
   //____________________________________________________________________________
-  bool snapshotCMVs(DataAllocator& output, uint32_t tfCounter)
+  bool snapshotCMVs(DataAllocator& output)
   {
     bool hasErrors = false;
 
@@ -321,12 +317,8 @@ class CMVToVectorDevice : public o2::framework::Task
   //____________________________________________________________________________
   void writeDebugOutput(uint32_t tfCounter)
   {
-    const auto& mapper = Mapper::instance();
-
     mDebugStream->GetFile()->cd();
     auto& stream = (*mDebugStream) << "cmvs";
-    uint32_t seen = 0;
-    static uint32_t firstOrbit = std::numeric_limits<uint32_t>::max();
 
     for (auto cru : mCRUs) {
       if (mCMVInfos.find(cru) == mCMVInfos.end()) {
@@ -404,7 +396,7 @@ class CMVToVectorDevice : public o2::framework::Task
   }
 };
 
-o2::framework::DataProcessorSpec getCMVToVectorSpec(const std::string inputSpec, std::vector<uint32_t> const& crus)
+o2::framework::DataProcessorSpec getCMVToVectorSpec(std::string const& inputSpec, std::vector<uint32_t> const& crus)
 {
   using device = o2::tpc::CMVToVectorDevice;
 
diff --git a/Detectors/TPC/workflow/test/test_cmv-trigger.cxx b/Detectors/TPC/workflow/test/test_cmv-trigger.cxx
new file mode 100644
index 0000000000000..c102a5ae531f4
--- /dev/null
+++ b/Detectors/TPC/workflow/test/test_cmv-trigger.cxx
@@ -0,0 +1,85 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// @file   test_cmv-trigger.cxx
+/// @author Tuba Gündem, tuba.gundem@cern.ch
+/// @brief  Test workflow: reads CMVTRIGGER packets from tpc-flp-cmv and logs results
+
+#include <vector>
+#include <string>
+#include "Framework/WorkflowSpec.h"
+#include "Framework/ConfigParamSpec.h"
+#include "Framework/Task.h"
+#include "Framework/ControlService.h"
+#include "Framework/Logger.h"
+#include "Framework/DataProcessorSpec.h"
+#include "Framework/InputRecordWalker.h"
+#include "Framework/DataRefUtils.h"
+#include "Headers/DataHeader.h"
+#include "TPCWorkflow/ProcessingHelpers.h"
+#include "TPCWorkflow/TPCFLPCMVSpec.h"
+
+using namespace o2::framework;
+
+void customize(std::vector<ConfigParamSpec>&) {}
+
+#include "Framework/runDataProcessing.h"
+
+namespace o2::tpc
+{
+
+class CMVTriggerDevice : public o2::framework::Task
+{
+ public:
+  void run(o2::framework::ProcessingContext& pc) final
+  {
+    const auto tf = processing_helpers::getCurrentTF(pc);
+
+    for (auto& ref : o2::framework::InputRecordWalker(pc.inputs(), mFilter)) {
+      auto const* hdr = o2::framework::DataRefUtils::getHeader<o2::header::DataHeader*>(ref);
+      const uint32_t firstCRU = hdr->subSpecification >> 7;
+      const bool triggered = pc.inputs().get<bool>(ref);
+      if (triggered) {
+        LOGP(info, "TF {:6} first CRU {:3}: {}", tf, firstCRU, "triggered");
+      }
+    }
+  }
+
+  void endOfStream(o2::framework::EndOfStreamContext& ec) final
+  {
+    ec.services().get<o2::framework::ControlService>().readyToQuit(o2::framework::QuitRequest::Me);
+  }
+
+ private:
+  const std::vector<o2::framework::InputSpec> mFilter = {
+    {"cmvtrigger", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, o2::tpc::TPCFLPCMVDevice::getDataDescriptionCMVTrigger()}, o2::framework::Lifetime::Timeframe}};
+};
+
+o2::framework::DataProcessorSpec getCMVTriggerSpec()
+{
+  std::vector<o2::framework::InputSpec> inputSpecs;
+  inputSpecs.emplace_back(o2::framework::InputSpec{"cmvtrigger", o2::framework::ConcreteDataTypeMatcher{o2::header::gDataOriginTPC, o2::tpc::TPCFLPCMVDevice::getDataDescriptionCMVTrigger()}, o2::framework::Lifetime::Timeframe});
+
+  return o2::framework::DataProcessorSpec{
+    "tpc-cmv-trigger",
+    inputSpecs,
+    {},
+    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<CMVTriggerDevice>()}};
+}
+
+} // namespace o2::tpc
+
+WorkflowSpec defineDataProcessing(ConfigContext const& config)
+{
+  WorkflowSpec workflow;
+  workflow.emplace_back(o2::tpc::getCMVTriggerSpec());
+  return workflow;
+}

From 3ddeb15d809b3ccc224282d5862c988115e88560 Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Tue, 12 May 2026 09:57:30 +0200
Subject: [PATCH 1725/1764] [ALICE3] TRK: update of TRK and FT3 services, to
 better match with Corrado's scheme (#15392)

* update of TRK and FT3 services, to better match with Corrado's scheme

* adjust spacing

---------

Co-authored-by: Igor Altsybeev <Igor.Altsybeev@cern.ch>
---
 .../FT3/base/include/FT3Base/FT3BaseParam.h   |   2 +-
 .../ALICE3/FT3/simulation/src/FT3Layer.cxx    |   7 +-
 .../ALICE3/TRK/simulation/src/TRKServices.cxx | 151 +++++++++++-------
 3 files changed, 102 insertions(+), 58 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
index b0f26bc4675d4..bb2969b69dc79 100644
--- a/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
+++ b/Detectors/Upgrades/ALICE3/FT3/base/include/FT3Base/FT3BaseParam.h
@@ -42,7 +42,7 @@ struct FT3BaseParam : public o2::conf::ConfigurableParamHelper<FT3BaseParam> {
 
   // override values from FT3ModuleConstants, inner and outer
   bool cutStavesOnNominalRadius_inner = true;
-  bool cutStavesOnNominalRadius_outer = false;
+  bool cutStavesOnNominalRadius_outer = true;
 
   // What to place over x=0 line in case of full outer-outer stave: Gap or Sensor
   bool placeSensorInMiddleOfStave = false;
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
index cc6accda3adb8..517bad767a645 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -428,7 +428,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     // need to shift outwards always, so + forwards and - backwards
     auto* FwdDiskCombiTrans = new TGeoCombiTrans(0, 0, mZ + 0, FwdDiskRotation);
 
-    LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
+    LOG(info) << "Inserting " << layerVol->GetName() << " (Rmin=" << mInnerRadius << ", Rmax=" << mOuterRadius << ", z=" << mZ << "cm) inside " << motherVolume->GetName();
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
   } else if (ft3Params.layoutFT3 == kSegmentedStave ||
              ft3Params.layoutFT3 == kSegmentedStaveOTOnly) {
@@ -459,7 +459,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
 
     // shift stave volumes into layer volume, since nominal z_{stave face} = 0
     double z_local_offset = z_layer_thickness / 2.0;
-    TGeoTube* layer = new TGeoTube(mInnerRadius - 12, mOuterRadius + 5, z_layer_thickness / 2);
+    TGeoTube* layer = new TGeoTube(mInnerRadius - 0.2, mOuterRadius + 0.4, z_layer_thickness / 2); // margins to ensure staves are fully encapsulated in the layer volume
     layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
 
     if (ft3Params.drawReferenceCircles) {
@@ -476,7 +476,8 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
     double z_offset_directional = mDirection ? z_local_offset : -z_local_offset;
     auto* FwdDiskCombiTrans = new TGeoCombiTrans(0, 0, mZ + z_offset_directional, FwdDiskRotation);
 
-    LOG(info) << "Inserting " << layerVol->GetName() << " inside " << motherVolume->GetName();
+    LOG(info) << "Inserting " << layerVol->GetName() << " (Rmin=" << mInnerRadius << ", Rmax=" << mOuterRadius << ", z=" << mZ << "cm, segmented disk with staves) inside " << motherVolume->GetName();
+
     motherVolume->AddNode(layerVol, 1, FwdDiskCombiTrans);
   } else {
     LOG(fatal) << "Unknown FT3 layout option: " << static_cast<int>(ft3Params.layoutFT3);
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 7b61d2e120196..09745dc35f4a6 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -191,7 +191,7 @@ void TRKServices::registerVacuum(TGeoVolume* motherVolume)
   TGeoVolume* vacuumVolume = new TGeoVolume("A3IP_VACUUM", vacuumComposite, kMedVac);
 
   // Add the vacuum to the barrel
-  vacuumVolume->SetLineColor(kAzure + 7);
+  vacuumVolume->SetLineColor(kAzure + 6);
   vacuumVolume->SetTransparency(80);
 
   motherVolume->AddNode(vacuumVolume, 1, new TGeoTranslation(0, 0, 0));
@@ -614,9 +614,9 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   float pePowerAreaD = ITDisknPower * mPowerBundleArea * mPowerBundleComposition[1];
 
   // Carbon Fiber Cylinder support for the middle tracker
-  float rMinMiddleCarbonSupport = 34.8f; // Arbitrary value
-  float rMaxMiddleCarbonSupport = 35.f;  // 2 mm of carbon fiber
-  const float zLengthMiddleCarbon = 129.f;
+  float rMinMiddleCarbonSupport = 38.5f;   // cm, from Corrado's drawing
+  float rMaxMiddleCarbonSupport = 39.0f;   // 5 mm of carbon fiber
+  const float zLengthMiddleCarbon = 282.f; // cm, to cover the full length of ML barrel and disks, from Corrado's drawing
   TGeoTube* middleBarrelCarbonSupport = new TGeoTube("TRK_MID_CARBONSUPPORTsh", rMinMiddleCarbonSupport, rMaxMiddleCarbonSupport, zLengthMiddleCarbon / 2.);
   TGeoVolume* middleBarrelCarbonSupportVolume = new TGeoVolume("TRK_MID_CARBONSUPPORT", middleBarrelCarbonSupport, medCFiber);
   middleBarrelCarbonSupportVolume->SetLineColor(kGray);
@@ -624,19 +624,18 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   motherVolume->AddNode(middleBarrelCarbonSupportVolume, 1, nullptr);
 
   // Get geometry information from TRK which is already present
-  float rMinMiddleServices = 35.f;
+  float rMinMiddleServices = 36.5f; // maximum radius allowed for sensors, plus some margin
   float rMinMiddleBarrel = rMinMiddleServices;
   const float zLengthMiddleBarrel = 64.5f;
   const float zLengthMiddleServices = 143.f;
   const float zLengthCylinderMiddleServices = zLengthMiddleServices - zLengthMiddleBarrel;
 
   // Middle layer barrel services are only on A side
-  rMinMiddleServices = 35.f;
   LOGP(info, "Building services for Middle Tracker rminMiddleServices");
 
   // Middle barrel connection disks
   const float rMinMiddleBarrelDisk = 5.68f;
-  const float rMaxMiddleBarrelDisk = 35.f;
+  const float rMaxMiddleBarrelDisk = rMinMiddleServices;
   auto orientation = Orientation::kASide;
   float diskCircumference = rMaxMiddleBarrelDisk * 3.14; // Use only half circumference
 
@@ -644,7 +643,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   double dZ = siO2FiberAreaB / diskCircumference / 2.;
   TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube("TRK_MIDBARCONN_DISK_FIBER_SIO2sh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
   TGeoVolume* middleBarrelConnDiskSIO2Volume = new TGeoVolume("TRK_MIDBARCONN_DISK_FIBER_SIO2", middleBarrelConnDiskSIO2, medSiO2);
-  middleBarrelConnDiskSIO2Volume->SetLineColor(kGray);
+  middleBarrelConnDiskSIO2Volume->SetLineColor(kOrange + 1);
   auto* rot = new TGeoRotation("", 0, 0, 180); // Why this?
   auto* combiTransSIO2 = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
 
@@ -652,7 +651,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   dZ = peFiberAreaB / diskCircumference / 2.;
   TGeoTube* middleBarrelConnDiskPE = new TGeoTube("TRK_MIDBARCONN_DISK_FIBER_PEsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
   TGeoVolume* middleBarrelConnDiskPEVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_FIBER_PE", middleBarrelConnDiskPE, medPE);
-  middleBarrelConnDiskPEVolume->SetLineColor(kGray);
+  middleBarrelConnDiskPEVolume->SetLineColor(kOrange + 1);
   auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
 
   motherVolume->AddNode(middleBarrelConnDiskSIO2Volume, 1, combiTransSIO2);
@@ -662,14 +661,14 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   dZ = cuPowerAreaB / diskCircumference / 2.;
   TGeoTube* middleBarrelConnDiskCu = new TGeoTube("TRK_MIDBARCONN_DISK_POWER_CUsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
   TGeoVolume* middleBarrelConnDiskCuVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_POWER_CU", middleBarrelConnDiskCu, medCu);
-  middleBarrelConnDiskCuVolume->SetLineColor(kGray);
+  middleBarrelConnDiskCuVolume->SetLineColor(kOrange + 1);
   auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
 
   zCur += 2. * dZ;
   dZ = pePowerAreaB / diskCircumference / 2.;
   TGeoTube* middleBarrelConnDiskPEPower = new TGeoTube("TRK_MIDBARCONN_DISK_POWER_PEsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
   TGeoVolume* middleBarrelConnDiskPEPowerVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_POWER_PE", middleBarrelConnDiskPEPower, medPE);
-  middleBarrelConnDiskPEPowerVolume->SetLineColor(kGray);
+  middleBarrelConnDiskPEPowerVolume->SetLineColor(kOrange + 1);
   auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
   motherVolume->AddNode(middleBarrelConnDiskCuVolume, 1, combiTransCu);
   motherVolume->AddNode(middleBarrelConnDiskPEPowerVolume, 1, combiTransPEPower);
@@ -688,13 +687,13 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       double dR = siO2FiberAreaD / (3.14 * rCur);
       TGeoTubeSeg* middleDiskFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
       TGeoVolume* middleDiskFiberSIO2Volume = new TGeoVolume(Form("TRK_MLD_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), middleDiskFiberSIO2, medSiO2);
-      middleDiskFiberSIO2Volume->SetLineColor(kGray);
+      middleDiskFiberSIO2Volume->SetLineColor(kOrange + 1);
 
       rCur += dR;
       dR = peFiberAreaD / (3.14 * rCur);
       TGeoTubeSeg* middleDiskFiberPE = new TGeoTubeSeg(Form("TRK_MLD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
       TGeoVolume* middleDiskFiberPEVolume = new TGeoVolume(Form("TRK_MLD_FIBER_PE_%s%d", orLabel.c_str(), iSide), middleDiskFiberPE, medPE);
-      middleDiskFiberPEVolume->SetLineColor(kGray);
+      middleDiskFiberPEVolume->SetLineColor(kOrange + 1);
       auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices / 2), new TGeoRotation("", refAngle + iSide * 180., 0, 0));
       motherVolume->AddNode(middleDiskFiberSIO2Volume, 1, combiTrans);
       motherVolume->AddNode(middleDiskFiberPEVolume, 1, combiTrans);
@@ -704,13 +703,13 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       dR = cuPowerAreaD / (3.14 * rCur);
       TGeoTubeSeg* middleDiskPowerCu = new TGeoTubeSeg(Form("TRK_MLD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
       TGeoVolume* middleDiskPowerCuVolume = new TGeoVolume(Form("TRK_MLD_POWER_CU_%s%d", orLabel.c_str(), iSide), middleDiskPowerCu, medCu);
-      middleDiskPowerCuVolume->SetLineColor(kGray);
+      middleDiskPowerCuVolume->SetLineColor(kOrange + 1);
 
       rCur += dR;
       dR = pePowerAreaD / (3.14 * rCur);
       TGeoTubeSeg* middleDiskPowerPE = new TGeoTubeSeg(Form("TRK_MLD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
       TGeoVolume* middleDiskPowerPEVolume = new TGeoVolume(Form("TRK_MLD_POWER_PE_%s%d", orLabel.c_str(), iSide), middleDiskPowerPE, medPE);
-      middleDiskPowerPEVolume->SetLineColor(kGray);
+      middleDiskPowerPEVolume->SetLineColor(kOrange + 1);
 
       motherVolume->AddNode(middleDiskPowerCuVolume, 1, combiTrans);
       motherVolume->AddNode(middleDiskPowerPEVolume, 1, combiTrans);
@@ -722,13 +721,13 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
         dR = siO2FiberAreaB / (3.14 * rCur);
         TGeoTubeSeg* middleBarrelFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLB_FIBER_SIO2sh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
         TGeoVolume* middleBarrelFiberSIO2Volume = new TGeoVolume(Form("TRK_MLB_FIBER_SIO2_A%d", iSide), middleBarrelFiberSIO2, medSiO2);
-        middleBarrelFiberSIO2Volume->SetLineColor(kGray);
+        middleBarrelFiberSIO2Volume->SetLineColor(kOrange + 1);
 
         rCur += dR;
         dR = peFiberAreaB / (3.14 * rCur);
         TGeoTubeSeg* middleBarrelFiberPE = new TGeoTubeSeg(Form("TRK_MLB_FIBER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
         TGeoVolume* middleBarrelFiberPEVolume = new TGeoVolume(Form("TRK_MLB_FIBER_PE_A%d", iSide), middleBarrelFiberPE, medPE);
-        middleBarrelFiberPEVolume->SetLineColor(kGray);
+        middleBarrelFiberPEVolume->SetLineColor(kOrange + 1);
         auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices / 2), new TGeoRotation(nullptr, refAngle + iSide * 180., 0, 0));
         motherVolume->AddNode(middleBarrelFiberSIO2Volume, 1, combiTrans);
         motherVolume->AddNode(middleBarrelFiberPEVolume, 1, combiTrans);
@@ -738,13 +737,13 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
         dR = cuPowerAreaB / (3.14 * rCur);
         TGeoTubeSeg* middleBarrelPowerCu = new TGeoTubeSeg(Form("TRK_MLB_POWER_CUsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
         TGeoVolume* middleBarrelPowerCuVolume = new TGeoVolume(Form("TRK_MLB_POWER_CU_A%d", iSide), middleBarrelPowerCu, medCu);
-        middleBarrelPowerCuVolume->SetLineColor(kGray);
+        middleBarrelPowerCuVolume->SetLineColor(kOrange + 1);
 
         rCur += dR;
         dR = pePowerAreaB / (3.14 * rCur);
         TGeoTubeSeg* middleBarrelPowerPE = new TGeoTubeSeg(Form("TRK_MLB_POWER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
         TGeoVolume* middleBarrelPowerPEVolume = new TGeoVolume(Form("TRK_MLB_POWER_PE_A%d", iSide), middleBarrelPowerPE, medPE);
-        middleBarrelPowerPEVolume->SetLineColor(kGray);
+        middleBarrelPowerPEVolume->SetLineColor(kOrange + 1);
 
         motherVolume->AddNode(middleBarrelPowerCuVolume, 1, combiTrans);
         motherVolume->AddNode(middleBarrelPowerPEVolume, 1, combiTrans);
@@ -788,8 +787,8 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       }
       TGeoTubeSeg* middleBarFwdFiberPE = new TGeoTubeSeg(Form("TRK_MIDBARFWD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rMinMiddleBarrel, rMaxMiddleServicesBarFwd, dZ, -45, 45);
       TGeoVolume* middleBarFwdFiberPEVolume = new TGeoVolume(Form("TRK_MIDBARFWD_FIBER_PE_%s%d", orLabel.c_str(), iSide), middleBarFwdFiberPE, medPE);
-      middleBarFwdFiberSIO2Volume->SetLineColor(kGray);
-      middleBarFwdFiberPEVolume->SetLineColor(kGray);
+      middleBarFwdFiberSIO2Volume->SetLineColor(kOrange + 1);
+      middleBarFwdFiberPEVolume->SetLineColor(kOrange + 1);
       auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
       motherVolume->AddNode(middleBarFwdFiberSIO2Volume, 1, combiTransSIO2);
       motherVolume->AddNode(middleBarFwdFiberPEVolume, 1, combiTransPE);
@@ -813,8 +812,8 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       }
       TGeoTubeSeg* middleBarFwdPowerPE = new TGeoTubeSeg(Form("TRK_MIDBARFWD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rMinMiddleBarrel, rMaxMiddleServicesBarFwd, dZ, -45, 45);
       TGeoVolume* middleBarFwdPowerPEVolume = new TGeoVolume(Form("TRK_MIDBARFWD_POWER_PE_%s%d", orLabel.c_str(), iSide), middleBarFwdPowerPE, medPE);
-      middleBarFwdPowerCuVolume->SetLineColor(kGray);
-      middleBarFwdPowerPEVolume->SetLineColor(kGray);
+      middleBarFwdPowerCuVolume->SetLineColor(kOrange + 1);
+      middleBarFwdPowerPEVolume->SetLineColor(kOrange + 1);
       auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
       motherVolume->AddNode(middleBarFwdPowerCuVolume, 1, combiTransCu);
       motherVolume->AddNode(middleBarFwdPowerPEVolume, 1, combiTransPEPower);
@@ -838,7 +837,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       }
       TGeoTubeSeg* middleFwdFiberSIO2 = new TGeoTubeSeg(Form("TRK_MIDFWD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthMiddleServicesFwd / 2, -45, 45);
       TGeoVolume* middleFwdFiberSIO2Volume = new TGeoVolume(Form("TRK_MIDFWD_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), middleFwdFiberSIO2, medSiO2);
-      middleFwdFiberSIO2Volume->SetLineColor(kGray);
+      middleFwdFiberSIO2Volume->SetLineColor(kOrange + 1);
 
       rCur += dR;
       dR = peFiberAreaD / (3.14 * rCur);
@@ -847,7 +846,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       }
       TGeoTubeSeg* middleFwdFiberPE = new TGeoTubeSeg(Form("TRK_MIDFWD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthMiddleServicesFwd / 2, -45, 45);
       TGeoVolume* middleFwdFiberPEVolume = new TGeoVolume(Form("TRK_MIDFWD_FIBER_PE_%s%d", orLabel.c_str(), iSide), middleFwdFiberPE, medPE);
-      middleFwdFiberPEVolume->SetLineColor(kGray);
+      middleFwdFiberPEVolume->SetLineColor(kOrange + 1);
 
       auto* rot = new TGeoRotation("", refAngle + iSide * 180., 0, 0.);
       auto* combiTrans = new TGeoCombiTrans(0, 0, translation, rot);
@@ -862,7 +861,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       }
       TGeoTubeSeg* middleFwdPowerCu = new TGeoTubeSeg(Form("TRK_MIDFWD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthMiddleServicesFwd / 2, -45, 45);
       TGeoVolume* middleFwdPowerCuVolume = new TGeoVolume(Form("TRK_MIDFWD_POWER_CU_%s%d", orLabel.c_str(), iSide), middleFwdPowerCu, medCu);
-      middleFwdPowerCuVolume->SetLineColor(kGray);
+      middleFwdPowerCuVolume->SetLineColor(kOrange + 1);
 
       rCur += dR;
       dR = pePowerAreaD / (3.14 * rCur);
@@ -871,7 +870,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       }
       TGeoTubeSeg* middleFwdPowerPE = new TGeoTubeSeg(Form("TRK_MIDFWD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthMiddleServicesFwd / 2, -45, 45);
       TGeoVolume* middleFwdPowerPEVolume = new TGeoVolume(Form("TRK_MIDFWD_POWER_PE_%s%d", orLabel.c_str(), iSide), middleFwdPowerPE, medPE);
-      middleFwdPowerPEVolume->SetLineColor(kGray);
+      middleFwdPowerPEVolume->SetLineColor(kOrange + 1);
       motherVolume->AddNode(middleFwdPowerCuVolume, 1, combiTrans);
       motherVolume->AddNode(middleFwdPowerPEVolume, 1, combiTrans);
 
@@ -916,8 +915,20 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
   float cuPowerAreaB = OTBarrelnPower * mPowerBundleArea * mPowerBundleComposition[0];
   float pePowerAreaB = OTBarrelnPower * mPowerBundleArea * mPowerBundleComposition[1];
 
-  float rMinOuterServices = 68.5f;    // 68.5cm
-  float zLengthOuterServices = 201.f; // 201cm
+  // geometry of service "disk" for OT barrel
+  double rMinOTbarrelServices = 45.0; // cm, radius of first OT barrel layer
+  double rMaxOTbarrelServices = 78.0; // cm, radius of last OT barrel layer
+  double zOTbarrelServices = 132.0;   // cm, approximate position of OT services in z
+
+  // geometry of service "tubes" for OT barrel
+  float rMinOuterBarrelTubeServices = rMaxOTbarrelServices;       // cm, IA, May 11, 2026: temporary radius (?)
+  float zStartOuterBarrelTubeServices = zOTbarrelServices + 0.8f; // cm, IA, May 11, 2026: start "OT service tubes" close in z to the "OT service disks"
+  float zLengthOuterBarrelTubeServices = 215.f;                   // cm, IA, May 11, 2026: temporary length (?)
+
+  // geometry of service "tubes" for OT disks
+  float rMinOuterDiskServices = 68.5f;    // cm
+  float zStartOuterDiskServices = 149.f;  // cm
+  float zLengthOuterDiskServices = 201.f; // cm
 
   // Carbon Fiber Cylinder support for the middle tracker
   float rMinOuterCarbonSupport = 82.0f;    // TODO: get more precise location
@@ -937,15 +948,12 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
       refAngle = 90;
     }
     // TODO: add cables/connections at ends of OT barrels
-    // Set rMin, rMax and dZ
+    double zCur = zOTbarrelServices;
 
-    double rMinOTbarrelServices = 45.0; // cm, radius of first OT layer
-    double rMaxOTbarrelServices = 80;   // cm, radius of last OT layer
-    double zCur = 135.0;                // cm, approximate position of OT services in z
     double dZ = siO2FiberAreaB / (4 * 3.14 * rMaxOTbarrelServices);
     TGeoTube* outerBarrelFiberSIO2 = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_SIO2sh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelFiberSIO2Volume = new TGeoVolume(Form("TRK_OUTERBARREL_FIBER_SIO2_%s", orLabel.c_str()), outerBarrelFiberSIO2, medSiO2);
-    outerBarrelFiberSIO2Volume->SetLineColor(kGray);
+    outerBarrelFiberSIO2Volume->SetLineColor(kAzure + 6);
     auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelFiberSIO2Volume, 1, combiTrans);
 
@@ -953,7 +961,7 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
     dZ = peFiberAreaB / (4 * 3.14 * rMaxOTbarrelServices);
     TGeoTube* outerBarrelFiberPE = new TGeoTube(Form("TRK_OUTERBARREL_FIBER_PEsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelFiberPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_FIBER_PE_%s", orLabel.c_str()), outerBarrelFiberPE, medPE);
-    outerBarrelFiberPEVolume->SetLineColor(kGray);
+    outerBarrelFiberPEVolume->SetLineColor(kAzure + 6);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelFiberPEVolume, 1, combiTrans);
 
@@ -961,7 +969,7 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
     dZ = cuPowerAreaB / (4 * 3.14 * rMaxOTbarrelServices);
     TGeoTube* outerBarrelPowerCu = new TGeoTube(Form("TRK_OUTERBARREL_POWER_CUsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelPowerCuVolume = new TGeoVolume(Form("TRK_OUTERBARREL_POWER_CU_%s", orLabel.c_str()), outerBarrelPowerCu, medCu);
-    outerBarrelPowerCuVolume->SetLineColor(kGray);
+    outerBarrelPowerCuVolume->SetLineColor(kAzure + 6);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelPowerCuVolume, 1, combiTrans);
 
@@ -969,41 +977,76 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
     dZ = pePowerAreaB / (4 * 3.14 * rMaxOTbarrelServices);
     TGeoTube* outerBarrelPowerPE = new TGeoTube(Form("TRK_OUTERBARREL_POWER_PEsh_%s", orLabel.c_str()), rMinOTbarrelServices, rMaxOTbarrelServices, dZ);
     TGeoVolume* outerBarrelPowerPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_POWER_PE_%s", orLabel.c_str()), outerBarrelPowerPE, medPE);
-    outerBarrelPowerPEVolume->SetLineColor(kGray);
+    outerBarrelPowerPEVolume->SetLineColor(kAzure + 6);
     combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), nullptr);
     motherVolume->AddNode(outerBarrelPowerPEVolume, 1, combiTrans);
 
     for (int iSide = 0; iSide < 2; iSide++) {
-      // Create fibers
-      double rCur = rMinOuterServices;
-      double dR = (siO2FiberAreaD + siO2FiberAreaB) / (3.14 * rCur);
-      TGeoTubeSeg* outerDisksFiberSIO2 = new TGeoTubeSeg(Form("TRK_OUTERDISKS_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterServices / 2, -45, 45);
+      // #### OT barrel services, implemented as tubes
+      // Create fibers for service barrel tubes
+      double rCur = rMinOuterBarrelTubeServices; // set starting radius for barrel service tube
+      double dR = siO2FiberAreaB / (3.14 * rCur);
+      TGeoTubeSeg* outerBarrelTubeFiberSIO2 = new TGeoTubeSeg(Form("TRK_OUTERBARREL_TUBE_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterBarrelTubeServices / 2, -45, 45);
+      TGeoVolume* outerBarrelTubeFiberSIO2Volume = new TGeoVolume(Form("TRK_OUTERBARREL_TUBE_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), outerBarrelTubeFiberSIO2, medSiO2);
+      outerBarrelTubeFiberSIO2Volume->SetLineColor(kAzure + 6);
+
+      rCur += dR;
+      dR = peFiberAreaB / (3.14 * rCur);
+      TGeoTubeSeg* outerBarrelTubeFiberPE = new TGeoTubeSeg(Form("TRK_OUTERBARREL_TUBE_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterBarrelTubeServices / 2, -45, 45);
+      TGeoVolume* outerBarrelTubeFiberPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_TUBE_FIBER_PE_%s%d", orLabel.c_str(), iSide), outerBarrelTubeFiberPE, medPE);
+      outerBarrelTubeFiberPEVolume->SetLineColor(kAzure + 6);
+
+      float translation = (int)orientation * (zStartOuterBarrelTubeServices + zLengthOuterBarrelTubeServices / 2);
+      auto* combiTrans = new TGeoCombiTrans(0, 0, translation, new TGeoRotation("", refAngle + iSide * 180., 0, 0));
+      motherVolume->AddNode(outerBarrelTubeFiberSIO2Volume, 1, combiTrans);
+      motherVolume->AddNode(outerBarrelTubeFiberPEVolume, 1, combiTrans);
+
+      // Create power lines for service barrel tubes
+      rCur += dR;
+      dR = cuPowerAreaB / (3.14 * rCur);
+      TGeoTubeSeg* outerBarrelTubePowerCu = new TGeoTubeSeg(Form("TRK_OUTERBARREL_TUBE_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterBarrelTubeServices / 2, -45, 45);
+      TGeoVolume* outerBarrelTubePowerCuVolume = new TGeoVolume(Form("TRK_OUTERBARREL_TUBE_POWER_CU_%s%d", orLabel.c_str(), iSide), outerBarrelTubePowerCu, medCu);
+      outerBarrelTubePowerCuVolume->SetLineColor(kAzure + 6);
+
+      rCur += dR;
+      dR = pePowerAreaB / (3.14 * rCur);
+      TGeoTubeSeg* outerBarrelTubePowerPE = new TGeoTubeSeg(Form("TRK_OUTERBARREL_TUBE_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterBarrelTubeServices / 2, -45, 45);
+      TGeoVolume* outerBarrelTubePowerPEVolume = new TGeoVolume(Form("TRK_OUTERBARREL_TUBE_POWER_PE_%s%d", orLabel.c_str(), iSide), outerBarrelTubePowerPE, medPE);
+      outerBarrelTubePowerPEVolume->SetLineColor(kAzure + 6);
+      motherVolume->AddNode(outerBarrelTubePowerCuVolume, 1, combiTrans);
+      motherVolume->AddNode(outerBarrelTubePowerPEVolume, 1, combiTrans);
+
+      // #### OT disk services, implemented as tubes
+      // Create fibers for disks
+      rCur = rMinOuterDiskServices; // set starting radius for disk service tube
+      dR = siO2FiberAreaD / (3.14 * rCur);
+      TGeoTubeSeg* outerDisksFiberSIO2 = new TGeoTubeSeg(Form("TRK_OUTERDISKS_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterDiskServices / 2, -45, 45);
       TGeoVolume* outerDisksFiberSIO2Volume = new TGeoVolume(Form("TRK_OUTERDISKS_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), outerDisksFiberSIO2, medSiO2);
-      outerDisksFiberSIO2Volume->SetLineColor(kGray);
+      outerDisksFiberSIO2Volume->SetLineColor(kMagenta);
 
       rCur += dR;
-      dR = (peFiberAreaD + peFiberAreaB) / (3.14 * rCur);
-      TGeoTubeSeg* outerDisksFiberPE = new TGeoTubeSeg(Form("TRK_OUTERDISKS_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterServices / 2, -45, 45);
+      dR = peFiberAreaD / (3.14 * rCur);
+      TGeoTubeSeg* outerDisksFiberPE = new TGeoTubeSeg(Form("TRK_OUTERDISKS_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterDiskServices / 2, -45, 45);
       TGeoVolume* outerDisksFiberPEVolume = new TGeoVolume(Form("TRK_OUTERDISKS_FIBER_PE_%s%d", orLabel.c_str(), iSide), outerDisksFiberPE, medPE);
-      outerDisksFiberPEVolume->SetLineColor(kGray);
+      outerDisksFiberPEVolume->SetLineColor(kMagenta);
 
-      float translation = (int)orientation * (149.f + zLengthOuterServices / 2); // ±149cm
-      auto* combiTrans = new TGeoCombiTrans(0, 0, translation, new TGeoRotation("", refAngle + iSide * 180., 0, 0));
+      translation = (int)orientation * (zStartOuterDiskServices + zLengthOuterDiskServices / 2);
+      combiTrans = new TGeoCombiTrans(0, 0, translation, new TGeoRotation("", refAngle + iSide * 180., 0, 0));
       motherVolume->AddNode(outerDisksFiberSIO2Volume, 1, combiTrans);
       motherVolume->AddNode(outerDisksFiberPEVolume, 1, combiTrans);
 
-      // Create power lines
+      // Create power lines for disks
       rCur += dR;
-      dR = (cuPowerAreaD + cuPowerAreaB) / (3.14 * rCur);
-      TGeoTubeSeg* outerDisksPowerCu = new TGeoTubeSeg(Form("TRK_OUTERDISKS_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterServices / 2, -45, 45);
+      dR = cuPowerAreaD / (3.14 * rCur);
+      TGeoTubeSeg* outerDisksPowerCu = new TGeoTubeSeg(Form("TRK_OUTERDISKS_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterDiskServices / 2, -45, 45);
       TGeoVolume* outerDisksPowerCuVolume = new TGeoVolume(Form("TRK_OUTERDISKS_POWER_CU_%s%d", orLabel.c_str(), iSide), outerDisksPowerCu, medCu);
-      outerDisksPowerCuVolume->SetLineColor(kGray);
+      outerDisksPowerCuVolume->SetLineColor(kMagenta + 1);
 
       rCur += dR;
-      dR = (pePowerAreaD + pePowerAreaB) / (3.14 * rCur);
-      TGeoTubeSeg* outerDisksPowerPE = new TGeoTubeSeg(Form("TRK_OUTERDISKS_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterServices / 2, -45, 45);
+      dR = pePowerAreaD / (3.14 * rCur);
+      TGeoTubeSeg* outerDisksPowerPE = new TGeoTubeSeg(Form("TRK_OUTERDISKS_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthOuterDiskServices / 2, -45, 45);
       TGeoVolume* outerDisksPowerPEVolume = new TGeoVolume(Form("TRK_OUTERDISKS_POWER_PE_%s%d", orLabel.c_str(), iSide), outerDisksPowerPE, medPE);
-      outerDisksPowerPEVolume->SetLineColor(kGray);
+      outerDisksPowerPEVolume->SetLineColor(kMagenta + 1);
       motherVolume->AddNode(outerDisksPowerCuVolume, 1, combiTrans);
       motherVolume->AddNode(outerDisksPowerPEVolume, 1, combiTrans);
 

From 761ffa28e324bcf49f846832133009b962ff5c5c Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 12 May 2026 11:47:28 +0200
Subject: [PATCH 1726/1764] Optionally exclude certain specs from the trigger

---
 Detectors/Raw/README.md                       |  5 ++++
 .../Raw/TFReaderDD/src/RawTFDumpSpec.cxx      | 26 ++++++++++++++++++-
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/Detectors/Raw/README.md b/Detectors/Raw/README.md
index d896b232d2647..1fece239723ec 100644
--- a/Detectors/Raw/README.md
+++ b/Detectors/Raw/README.md
@@ -564,6 +564,11 @@ Selection string for the external trigger to dump particular TF. Must be contain
 ```
 Include data with DPL-generated 0xdeadbeef subspecs (for data missing in the original TF).
 ```
+--exclude-trigger-specs (="")
+
+```
+Ignore trigger seen in these inputs of triggerspec (e.g. to suppress noisy trigger inputs)
+```
 --max-dump-rate arg (=0)
 ```
 Fraction in (`%`) of TFs to dump. W/o external trigger: random(>0) or periodic(<0) rejection. With external trigger: throttle dumping to have the lowest estimated acceptance rate compatible with this rate.
diff --git a/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx b/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
index 4e2d0372b3069..64c39fa7ef75a 100644
--- a/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
+++ b/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
@@ -29,6 +29,7 @@
 #include <TMath.h>
 #include <filesystem>
 #include <random>
+#include <set>
 
 namespace o2::rawdd
 {
@@ -64,6 +65,7 @@ class RawTFDump : public Task
   std::map<EquipmentIdentifier, std::tuple<size_t, size_t, size_t>> mDataMap;
   std::vector<InputSpec> mFilter{};
   std::vector<InputSpec> mTriggerFilter{};
+  std::vector<InputSpec> mExclTriggerFilter{};
 
   size_t mTFSize = 0;
   size_t mMinFileSize = 0; // if > 0, accumulate TFs in the same file until the total size exceeds this minimum
@@ -101,6 +103,7 @@ class RawTFDump : public Task
   o2::framework::TimingInfo mTimingInfo{};
 
   std::string mTrigger{}; // external trigger input
+  std::string mExclTriggerSpecs{}; // trigger specs to ignore
   std::string mHostName{};
   std::string mTFDir{};
   std::string mTFMetaFileDir = "/dev/null";
@@ -182,7 +185,6 @@ void RawTFDump::init(InitContext& ic)
     mWriteTF = false;
     mStoreMetaFile = false;
   }
-
   mRejectDEADBEEF = !ic.options().get<bool>("include-deadbeef");
   mCreateRunEnvDir = !ic.options().get<bool>("ignore-partition-run-dir");
   mMinFileSize = ic.options().get<int64_t>("min-file-size");
@@ -199,6 +201,10 @@ void RawTFDump::init(InitContext& ic)
   mWarnThrottleTF = ic.options().get<int>("mute-warn-period");
 
   mVerbose = ic.options().get<int>("verbosity-level");
+  mExclTriggerSpecs = ic.options().get<std::string>("exclude-trigger-specs");
+  if (!mExclTriggerSpecs.empty()) {
+    mExclTriggerFilter = select(mExclTriggerSpecs.c_str());
+  }
   if (mTrigger.empty()) {
     if (mMaxAccRate >= 0.f) {
       LOGP(info, "Will accept randomly {}% of TFs", mMaxAccRate);
@@ -208,6 +214,9 @@ void RawTFDump::init(InitContext& ic)
   } else {
     mMaxAccRate = std::abs(mMaxAccRate);
     LOGP(info, "Will limit TFs triggered with {} by {}% at most", mTrigger, mMaxAccRate);
+    if (!mExclTriggerFilter.empty()) {
+      LOGP(info, "Inputs excluded from the trigger: {}", mExclTriggerSpecs);
+    }
   }
 
   if (mWriteTF) {
@@ -450,6 +459,20 @@ bool RawTFDump::triggerTF(ProcessingContext& pc)
              dh->splitPayloadIndex, dh->splitPayloadParts, dh->payloadSize, dh->firstTForbit, dh->tfCounter, extTrig.size(), extTrig.size() > 0 ? extTrig[0] : false);
       }
       if (extTrig.size() && extTrig[0]) {
+        // is the input with this trigger vetoed?
+        bool veto = false;
+        for (const auto& excl : mExclTriggerFilter) {
+          if (DataRefUtils::match(ref, excl)) {
+            if (mVerbose > 0) {
+              LOGP(info, "ignoring trigger from black-listed {}", DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}));
+            }
+            veto = true;
+            break;
+          }
+        }
+        if (veto) {
+          continue;
+        }
         trig = true;
         break;
       }
@@ -554,6 +577,7 @@ DataProcessorSpec getRawTFDumpSpec(const std::string& inpconfig, const std::stri
     AlgorithmSpec{adaptFromTask<RawTFDump>(trigger)},
     Options{
       {"include-deadbeef", VariantType::Bool, false, {"Include DPL-generated 0xdeadbeef subspecs for missing data"}},
+      {"exclude-trigger-specs", VariantType::String, "", {"Ignore trigger seen in these inputs of triggerspec"}},
       {"max-dump-rate", VariantType::Float, 0.f, {"%-age of TFs to dump. W/o external trigger: random(>0) or periodic(<0) rejection, with: max limit"}},
       {"rate-est-conf-limit", VariantType::Float, 0.05f, {"quantile for the lowest rate estimate confidence limit"}},
       {"max-warn", VariantType::Int, 5, {"max allowed warnings on throttling"}},

From 88fae317e014b2adf20714a6667f6baa88fc71f1 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 12 May 2026 13:56:56 +0200
Subject: [PATCH 1727/1764] Optionally aggregate CMV triggers per FLP

---
 .../workflow/include/TPCWorkflow/TPCFLPCMVSpec.h  | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
index 4b7886d4493a7..bb7f9632c6308 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
@@ -44,6 +44,7 @@ class TPCFLPCMVDevice : public o2::framework::Task
   {
     mDumpCMVs = ic.options().get<bool>("dump-cmvs-flp");
     mEnableTrigger = ic.options().get<bool>("trigger");
+    mTriggerPerFLP = ic.options().get<bool>("trigger-per-flp");
     mTriggerThresholdCMV = ic.options().get<float>("trigger-threshold-cmv");
     mTriggerThresholdMeanMax = ic.options().get<float>("trigger-threshold-cmvMeanMax");
     mTriggerThresholdMeanMin = ic.options().get<float>("trigger-threshold-cmvMeanMin");
@@ -79,10 +80,16 @@ class TPCFLPCMVDevice : public o2::framework::Task
       mCMVs[cru].insert(mCMVs[cru].end(), vecCMVs.begin(), vecCMVs.end());
 
       const bool cruTriggered = mEnableTrigger && evaluateTrigger(vecCMVs);
-      triggered |= cruTriggered;
+      if (!mTriggerPerFLP) {
+        pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVTrigger(), tpcCRUHeader->subSpecification}, cruTriggered);
+      } else {
+        triggered |= cruTriggered;
+      }
+    }
+    if (mTriggerPerFLP) {
+      const header::DataHeader::SubSpecificationType trigSubSpec{mCRUs.front() << 7};
+      pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVTrigger(), trigSubSpec}, triggered);
     }
-    const header::DataHeader::SubSpecificationType trigSubSpec{mCRUs.front() << 7};
-    pc.outputs().snapshot(o2::framework::Output{o2::header::gDataOriginTPC, getDataDescriptionCMVTrigger(), trigSubSpec}, triggered);
 
     if (mCountTFsForBuffer >= mNTFsBuffer) {
       mCountTFsForBuffer = 0;
@@ -128,6 +135,7 @@ class TPCFLPCMVDevice : public o2::framework::Task
   const std::vector<uint32_t> mCRUs{};                                 ///< CRUs to process in this instance
   int mNTFsBuffer{1};                                                  ///< number of TFs to buffer before sending
   bool mDumpCMVs{};                                                    ///< dump CMVs to file for debugging
+  bool mTriggerPerFLP{false};                                          ///< send per-FLP trigger decision aggregated over CRUs
   int mCountTFsForBuffer{0};                                           ///< counts TFs to track when to send output
   std::unordered_map<unsigned int, o2::pmr::vector<uint16_t>> mCMVs{}; ///< buffered raw 16-bit CMV values per CRU
   std::unordered_map<uint32_t, uint64_t> mFirstOrbitBC{};              ///< first packed orbit/BC per CRU for the current buffer window
@@ -224,6 +232,7 @@ o2::framework::DataProcessorSpec getTPCFLPCMVSpec(const int ilane, const std::ve
     o2::framework::Options{
       {"dump-cmvs-flp", o2::framework::VariantType::Bool, false, {"Dump CMVs to file"}},
       {"trigger", o2::framework::VariantType::Bool, false, {"Enable CMV trigger evaluation"}},
+      {"trigger-per-flp", o2::framework::VariantType::Bool, false, {"Aggregate triggers of CRUs on FLP to a single trigger"}},
       {"trigger-threshold-cmv", o2::framework::VariantType::Float, -10.f, {"CMV threshold: sequence starts when value drops below this (ADC units)"}},
       {"trigger-threshold-cmvMeanMax", o2::framework::VariantType::Float, -40.f, {"Upper bound on trigger-sequence mean CMV value"}},
       {"trigger-threshold-cmvMeanMin", o2::framework::VariantType::Float, -80.f, {"Lower bound on trigger-sequence mean CMV value"}},

From b3e2e7ab0e2663ba6c9cca8731c761c863970d02 Mon Sep 17 00:00:00 2001
From: altsybee <ialtsybeev@gmail.com>
Date: Wed, 13 May 2026 10:54:08 +0200
Subject: [PATCH 1728/1764] [ALICE3] TRK: adjustments for z and r of services,
 split OT barrel into two halves (#15395)

* adjustments for service z and r positions, split OT barrel into two halves

* reverting back OT stave tilting angle

* Please consider the following formatting changes

---------

Co-authored-by: Igor Altsybeev <Igor.Altsybeev@cern.ch>
Co-authored-by: ALICE Action Bot <alibuild@cern.ch>
---
 .../ALICE3/FT3/simulation/src/FT3Layer.cxx    |  2 +-
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     |  2 +-
 .../include/TRKSimulation/TRKLayer.h          |  3 +
 .../ALICE3/TRK/simulation/src/TRKLayer.cxx    | 33 ++++++---
 .../ALICE3/TRK/simulation/src/TRKServices.cxx | 70 ++++++++++---------
 5 files changed, 65 insertions(+), 45 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
index 517bad767a645..d8245fa1d34b4 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/FT3Layer.cxx
@@ -459,7 +459,7 @@ void FT3Layer::createLayer(TGeoVolume* motherVolume)
 
     // shift stave volumes into layer volume, since nominal z_{stave face} = 0
     double z_local_offset = z_layer_thickness / 2.0;
-    TGeoTube* layer = new TGeoTube(mInnerRadius - 0.2, mOuterRadius + 0.4, z_layer_thickness / 2); // margins to ensure staves are fully encapsulated in the layer volume
+    TGeoTube* layer = new TGeoTube(mInnerRadius - 0.2, mOuterRadius + 2.5, z_layer_thickness / 2); // margins to ensure staves are fully encapsulated in the layer volume
     layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
 
     if (ft3Params.drawReferenceCircles) {
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 4f76d71b63aa3..627fb599ff8ae 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -168,7 +168,7 @@ void ITOFLayer::createLayer(TGeoVolume* motherVolume)
       const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY);           // we increase the size of the layer to account for the tilt of the staves
       const double radiusMax = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY + avgRadius * 2. * deltaForTilt); // we increase the outer radius to account for the tilt of the staves
       const double radiusMin = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY - avgRadius * 2. * deltaForTilt); // we decrease the inner radius to account for the tilt of the staves
-      TGeoTube* layer = new TGeoTube(radiusMin, radiusMax, mZLength / 2);
+      TGeoTube* layer = new TGeoTube(radiusMin - 0.05, radiusMax + 0.05, mZLength / 2);                                                                            // cm, small margins to ensure staves are fully encapsulated in the layer volume
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
index ef4d5657a1b4f..e900cfa679ffe 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/include/TRKSimulation/TRKLayer.h
@@ -141,6 +141,9 @@ class TRKOTLayer : public TRKSegmentedLayer
   TGeoVolume* createHalfStave();
   void createLayer(TGeoVolume* motherVolume) override;
 
+ protected:
+  static constexpr float sGapBetweenOuterTrackerBarrelHalves = 0.8; // cm, gap between the two halves of the OT barrel
+
  private:
   static constexpr double sHalfStaveWidth = constants::OT::halfstave::width;
   static constexpr double sInStaveOverlap = constants::moduleMLOT::gaps::outerEdgeLongSide + constants::moduleMLOT::chip::passiveEdgeReadOut + 0.1; // 1.5mm outer-edge + 1mm deadzone + 1mm (true) overlap
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
index 7a4b7bef34e03..5206985992ecf 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKLayer.cxx
@@ -388,13 +388,15 @@ TGeoVolume* TRKOTLayer::createHalfStave()
 {
   TGeoMedium* medSi = gGeoManager->GetMedium("TRK_SILICON$");
   std::string halfStaveName = GeometryTGeo::getTRKHalfStavePattern() + std::to_string(mLayerNumber);
-  TGeoShape* halfStave = new TGeoBBox(sHalfStaveWidth / 2, mChipThickness / 2, mLength / 2);
+  float lengthHalfBarrel = mLength / 2;
+  TGeoShape* halfStave = new TGeoBBox(sHalfStaveWidth / 2, mChipThickness / 2, lengthHalfBarrel / 2);
   TGeoVolume* halfStaveVol = new TGeoVolume(halfStaveName.c_str(), halfStave, medSi);
   halfStaveVol->SetLineColor(kYellow);
 
-  for (int iModule = 0; iModule < mNumberOfModules; iModule++) {
+  int nModulesPerHalfBarrel = mNumberOfModules / 2; // assuming mNumberOfModules is always even, which should be the case given the current specifications
+  for (int iModule = 0; iModule < nModulesPerHalfBarrel; iModule++) {
     TGeoVolume* moduleVol = createModule();
-    double zPos = -0.5 * mNumberOfModules * sModuleLength + (iModule + 0.5) * sModuleLength;
+    double zPos = -0.5 * nModulesPerHalfBarrel * sModuleLength + (iModule + 0.5) * sModuleLength;
     TGeoCombiTrans* trans = new TGeoCombiTrans();
     trans->SetTranslation(0, 0, zPos);
     LOGP(debug, "Inserting {} in {} ", moduleVol->GetName(), halfStaveVol->GetName());
@@ -431,35 +433,46 @@ void TRKOTLayer::createLayer(TGeoVolume* motherVolume)
 
   TGeoMedium* medAir = gGeoManager->GetMedium("TRK_AIR$");
   // TGeoTube* layer = new TGeoTube(mInnerRadius - 0.333 * sLogicalVolumeThickness, mInnerRadius + 0.667 * sLogicalVolumeThickness, mLength / 2);
-  TGeoTube* layer = new TGeoTube(rMin, rMax, mLength / 2);
+  TGeoTube* layer = new TGeoTube(rMin, rMax, (mLength + sGapBetweenOuterTrackerBarrelHalves) / 2);
   TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
   layerVol->SetLineColor(kYellow);
 
   // Compute the number of staves
-  int nStaves = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / sStaveWidth);
-  nStaves += nStaves % 2; // Require an even number of staves
+  int nStavesHalfBarrel = (int)std::ceil(mInnerRadius * 2 * TMath::Pi() / sStaveWidth);
+  nStavesHalfBarrel += nStavesHalfBarrel % 2; // Require an even number of staves
 
   // Nominal average radius used as the placement barycenter for all staves
   const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
 
   // Compute the size of the overlap region
-  double theta = 2. * TMath::Pi() / nStaves;
+  double theta = 2. * TMath::Pi() / nStavesHalfBarrel;
   double theta1 = std::atan(sStaveWidth / 2 / mInnerRadius);
   double st = std::sin(theta);
   double ct = std::cos(theta);
   double theta2 = std::atan((mInnerRadius * st - sStaveWidth / 2 * ct) / (mInnerRadius * ct + sStaveWidth / 2 * st));
   double overlap = (theta1 - theta2) * mInnerRadius;
-  LOGP(info, "Creating a layer with {} staves and {} mm overlap", nStaves, overlap * 10);
+  LOGP(info, "Creating a layer with two half barrels, each with {} staves and {} mm overlap", nStavesHalfBarrel, overlap * 10);
+
+  float lengthHalfBarrel = mLength / 2;
+  int nStaves = nStavesHalfBarrel * 2; // since we now have two half-barrels (separated by a small gap), we double the number of staves
 
   for (int iStave = 0; iStave < nStaves; iStave++) {
     TGeoVolume* staveVol = createStave();
+    int whichHalfBarrel = iStave / nStavesHalfBarrel; // 0 for the first half (negative z), 1 for the second half (positive z)
     TGeoCombiTrans* trans = new TGeoCombiTrans();
     double phi = theta * iStave;
     double phiDeg = phi * TMath::RadToDeg();
-    TGeoRotation* rot = new TGeoRotation("rot", phiDeg + 90 + mTiltAngle, 0, 0);
+    // TGeoRotation* rot = new TGeoRotation("rot", phiDeg + 90 + mTiltAngle, 0, 0);
+    TGeoRotation* rot = new TGeoRotation("rot");
+    if (whichHalfBarrel == 1) {
+      rot->RotateY(180.); // degrees, rotate the second half barrel by 180 degrees around Y to achieve the correct staggering orientation
+    }
+    rot->RotateZ(phiDeg + 90 + (whichHalfBarrel == 0 ? +1 : -1) * mTiltAngle); // phi in degrees, tilting depends on the half-barrel side
     trans->SetRotation(rot);
     // trans->SetTranslation(mInnerRadius * std::cos(phi), mInnerRadius * std::sin(phi), 0);
-    trans->SetTranslation(avgRadius * std::cos(phi), avgRadius * std::sin(phi), 0);
+    // trans->SetTranslation(avgRadius * std::cos(phi), avgRadius * std::sin(phi), 0);
+    double zPos = (whichHalfBarrel == 0 ? -1 : 1) * (0.5 * lengthHalfBarrel + sGapBetweenOuterTrackerBarrelHalves / 2);
+    trans->SetTranslation(avgRadius * std::cos(phi), avgRadius * std::sin(phi), zPos);
     LOGP(debug, "Inserting {} in {} ", staveVol->GetName(), layerVol->GetName());
     layerVol->AddNode(staveVol, iStave, trans);
   }
diff --git a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
index 09745dc35f4a6..53ac0a4b12865 100644
--- a/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/simulation/src/TRKServices.cxx
@@ -109,7 +109,7 @@ void TRKServices::createMaterials()
   matmgr.Material("ALICE3_TRKSERVICES", 73, "BERYLLIUM", 9.01, 4., 1.848, 35.3, 36.7);                                                 // Beryllium - Candidate for IRIS vacuum vessel
   matmgr.Mixture("ALICE3_TRKSERVICES", 74, "ALUMINIUM5083", aAl5083, zAl5083, dAl5083, 9, wAl5083);                                    // AL5083 - Candidate for IRIS vacuum vessel
   matmgr.Mixture("ALICE3_TRKSERVICES", 75, "ALUMINIUMBERYLLIUMMETAL", aAlBeMet, zAlBeMet, dAlBeMet, 2, wAlBeMet);                      // Aluminium-Beryllium metal - Candidate for IRIS vacuum vessel
-  matmgr.Material("ALICE3_TRKSERVICES", 76, "CARBONFIBERM55J6K", 12.0107, 6, 1.92, 22.4, 999);                                         // Carbon Fiber M55J
+  matmgr.Material("ALICE3_TRKSERVICES", 76, "CARBONFIBERM55J6K", 12.0107, 6, 1.92, 22.4, 45.4);                                        // Carbon Fiber M55J
   matmgr.Mixture("ALICE3_PIPE", 77, "VACUUM", aAir, zAir, dAir1, 4, wAir);
 
   matmgr.Medium("ALICE3_TRKSERVICES", 1, "CERAMIC", 66, 0, ifield, fieldm, tmaxfd, stemax, deemax, epsil, stmin);                  // Ceramic for cold plate
@@ -614,8 +614,9 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   float pePowerAreaD = ITDisknPower * mPowerBundleArea * mPowerBundleComposition[1];
 
   // Carbon Fiber Cylinder support for the middle tracker
-  float rMinMiddleCarbonSupport = 38.5f;   // cm, from Corrado's drawing
-  float rMaxMiddleCarbonSupport = 39.0f;   // 5 mm of carbon fiber
+  // (from ICD_ALICE3_V3.b.3 drawing: 38.5 cm are allocated for staves and services, + 1 cm for the support; we assume less for the support - to be reconsidered if necessary)
+  float rMinMiddleCarbonSupport = 39.3f;   // cm
+  float rMaxMiddleCarbonSupport = 39.5f;   // cm, assume 2 mm of carbon fiber, ~0.88% X/X0
   const float zLengthMiddleCarbon = 282.f; // cm, to cover the full length of ML barrel and disks, from Corrado's drawing
   TGeoTube* middleBarrelCarbonSupport = new TGeoTube("TRK_MID_CARBONSUPPORTsh", rMinMiddleCarbonSupport, rMaxMiddleCarbonSupport, zLengthMiddleCarbon / 2.);
   TGeoVolume* middleBarrelCarbonSupportVolume = new TGeoVolume("TRK_MID_CARBONSUPPORT", middleBarrelCarbonSupport, medCFiber);
@@ -624,14 +625,16 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   motherVolume->AddNode(middleBarrelCarbonSupportVolume, 1, nullptr);
 
   // Get geometry information from TRK which is already present
-  float rMinMiddleServices = 36.5f; // maximum radius allowed for sensors, plus some margin
-  float rMinMiddleBarrel = rMinMiddleServices;
-  const float zLengthMiddleBarrel = 64.5f;
-  const float zLengthMiddleServices = 143.f;
-  const float zLengthCylinderMiddleServices = zLengthMiddleServices - zLengthMiddleBarrel;
+  float rMinMiddleServices = 38.0f;                       // cm, start radius of the ML services = maximum radius allowed for sensors (35 cm), plus some margin for disk paving with modules
+  const float zMiddleServicesBarrel = 64.5f;              // cm, z position of the first barrel ML service disk
+  const float zMiddleServicesBarrelFwdConnection = 143.f; // cm, z position of barrel to forward connection services
+  const float zLengthCylinderMiddleServicesBarrel = zMiddleServicesBarrelFwdConnection - zMiddleServicesBarrel;
+
+  const float zStartServicesForMiddleDisks = 77.0f; // cm, starting z position of ML disk services, assumed to be the same as of the first ML disk
+  const float zLengthCylinderMiddleServicesDisk = zMiddleServicesBarrelFwdConnection - zStartServicesForMiddleDisks;
 
   // Middle layer barrel services are only on A side
-  LOGP(info, "Building services for Middle Tracker rminMiddleServices");
+  LOGP(info, "Building services for barrel Middle Layers");
 
   // Middle barrel connection disks
   const float rMinMiddleBarrelDisk = 5.68f;
@@ -639,11 +642,11 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   auto orientation = Orientation::kASide;
   float diskCircumference = rMaxMiddleBarrelDisk * 3.14; // Use only half circumference
 
-  double zCur = zLengthMiddleBarrel;
+  double zCur = zMiddleServicesBarrel;
   double dZ = siO2FiberAreaB / diskCircumference / 2.;
   TGeoTube* middleBarrelConnDiskSIO2 = new TGeoTube("TRK_MIDBARCONN_DISK_FIBER_SIO2sh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
   TGeoVolume* middleBarrelConnDiskSIO2Volume = new TGeoVolume("TRK_MIDBARCONN_DISK_FIBER_SIO2", middleBarrelConnDiskSIO2, medSiO2);
-  middleBarrelConnDiskSIO2Volume->SetLineColor(kOrange + 1);
+  middleBarrelConnDiskSIO2Volume->SetLineColor(kOrange - 9);
   auto* rot = new TGeoRotation("", 0, 0, 180); // Why this?
   auto* combiTransSIO2 = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
 
@@ -651,7 +654,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   dZ = peFiberAreaB / diskCircumference / 2.;
   TGeoTube* middleBarrelConnDiskPE = new TGeoTube("TRK_MIDBARCONN_DISK_FIBER_PEsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
   TGeoVolume* middleBarrelConnDiskPEVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_FIBER_PE", middleBarrelConnDiskPE, medPE);
-  middleBarrelConnDiskPEVolume->SetLineColor(kOrange + 1);
+  middleBarrelConnDiskPEVolume->SetLineColor(kOrange - 9);
   auto* combiTransPE = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
 
   motherVolume->AddNode(middleBarrelConnDiskSIO2Volume, 1, combiTransSIO2);
@@ -661,14 +664,14 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   dZ = cuPowerAreaB / diskCircumference / 2.;
   TGeoTube* middleBarrelConnDiskCu = new TGeoTube("TRK_MIDBARCONN_DISK_POWER_CUsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
   TGeoVolume* middleBarrelConnDiskCuVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_POWER_CU", middleBarrelConnDiskCu, medCu);
-  middleBarrelConnDiskCuVolume->SetLineColor(kOrange + 1);
+  middleBarrelConnDiskCuVolume->SetLineColor(kOrange - 9);
   auto* combiTransCu = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
 
   zCur += 2. * dZ;
   dZ = pePowerAreaB / diskCircumference / 2.;
   TGeoTube* middleBarrelConnDiskPEPower = new TGeoTube("TRK_MIDBARCONN_DISK_POWER_PEsh", rMinMiddleBarrelDisk, rMaxMiddleBarrelDisk, dZ);
   TGeoVolume* middleBarrelConnDiskPEPowerVolume = new TGeoVolume("TRK_MIDBARCONN_DISK_POWER_PE", middleBarrelConnDiskPEPower, medPE);
-  middleBarrelConnDiskPEPowerVolume->SetLineColor(kOrange + 1);
+  middleBarrelConnDiskPEPowerVolume->SetLineColor(kOrange - 9);
   auto* combiTransPEPower = new TGeoCombiTrans(0, 0, (int)orientation * (zCur + dZ), rot);
   motherVolume->AddNode(middleBarrelConnDiskCuVolume, 1, combiTransCu);
   motherVolume->AddNode(middleBarrelConnDiskPEPowerVolume, 1, combiTransPEPower);
@@ -685,29 +688,29 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
       // create data fiber volumes
       double rCur = rMinMiddleServices;
       double dR = siO2FiberAreaD / (3.14 * rCur);
-      TGeoTubeSeg* middleDiskFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
+      TGeoTubeSeg* middleDiskFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLD_FIBER_SIO2sh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServicesDisk / 2, -45, 45);
       TGeoVolume* middleDiskFiberSIO2Volume = new TGeoVolume(Form("TRK_MLD_FIBER_SIO2_%s%d", orLabel.c_str(), iSide), middleDiskFiberSIO2, medSiO2);
       middleDiskFiberSIO2Volume->SetLineColor(kOrange + 1);
 
       rCur += dR;
       dR = peFiberAreaD / (3.14 * rCur);
-      TGeoTubeSeg* middleDiskFiberPE = new TGeoTubeSeg(Form("TRK_MLD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
+      TGeoTubeSeg* middleDiskFiberPE = new TGeoTubeSeg(Form("TRK_MLD_FIBER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServicesDisk / 2, -45, 45);
       TGeoVolume* middleDiskFiberPEVolume = new TGeoVolume(Form("TRK_MLD_FIBER_PE_%s%d", orLabel.c_str(), iSide), middleDiskFiberPE, medPE);
       middleDiskFiberPEVolume->SetLineColor(kOrange + 1);
-      auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices / 2), new TGeoRotation("", refAngle + iSide * 180., 0, 0));
+      auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zMiddleServicesBarrelFwdConnection - zLengthCylinderMiddleServicesDisk / 2), new TGeoRotation("", refAngle + iSide * 180., 0, 0));
       motherVolume->AddNode(middleDiskFiberSIO2Volume, 1, combiTrans);
       motherVolume->AddNode(middleDiskFiberPEVolume, 1, combiTrans);
 
       // Create powerlines
       rCur += dR;
       dR = cuPowerAreaD / (3.14 * rCur);
-      TGeoTubeSeg* middleDiskPowerCu = new TGeoTubeSeg(Form("TRK_MLD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
+      TGeoTubeSeg* middleDiskPowerCu = new TGeoTubeSeg(Form("TRK_MLD_POWER_CUsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServicesDisk / 2, -45, 45);
       TGeoVolume* middleDiskPowerCuVolume = new TGeoVolume(Form("TRK_MLD_POWER_CU_%s%d", orLabel.c_str(), iSide), middleDiskPowerCu, medCu);
       middleDiskPowerCuVolume->SetLineColor(kOrange + 1);
 
       rCur += dR;
       dR = pePowerAreaD / (3.14 * rCur);
-      TGeoTubeSeg* middleDiskPowerPE = new TGeoTubeSeg(Form("TRK_MLD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
+      TGeoTubeSeg* middleDiskPowerPE = new TGeoTubeSeg(Form("TRK_MLD_POWER_PEsh_%s%d", orLabel.c_str(), iSide), rCur, rCur + dR, zLengthCylinderMiddleServicesDisk / 2, -45, 45);
       TGeoVolume* middleDiskPowerPEVolume = new TGeoVolume(Form("TRK_MLD_POWER_PE_%s%d", orLabel.c_str(), iSide), middleDiskPowerPE, medPE);
       middleDiskPowerPEVolume->SetLineColor(kOrange + 1);
 
@@ -719,31 +722,31 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
         // create data fiber volumes
         rCur += dR;
         dR = siO2FiberAreaB / (3.14 * rCur);
-        TGeoTubeSeg* middleBarrelFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLB_FIBER_SIO2sh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
+        TGeoTubeSeg* middleBarrelFiberSIO2 = new TGeoTubeSeg(Form("TRK_MLB_FIBER_SIO2sh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServicesBarrel / 2, -45, 45);
         TGeoVolume* middleBarrelFiberSIO2Volume = new TGeoVolume(Form("TRK_MLB_FIBER_SIO2_A%d", iSide), middleBarrelFiberSIO2, medSiO2);
-        middleBarrelFiberSIO2Volume->SetLineColor(kOrange + 1);
+        middleBarrelFiberSIO2Volume->SetLineColor(kOrange - 9);
 
         rCur += dR;
         dR = peFiberAreaB / (3.14 * rCur);
-        TGeoTubeSeg* middleBarrelFiberPE = new TGeoTubeSeg(Form("TRK_MLB_FIBER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
+        TGeoTubeSeg* middleBarrelFiberPE = new TGeoTubeSeg(Form("TRK_MLB_FIBER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServicesBarrel / 2, -45, 45);
         TGeoVolume* middleBarrelFiberPEVolume = new TGeoVolume(Form("TRK_MLB_FIBER_PE_A%d", iSide), middleBarrelFiberPE, medPE);
-        middleBarrelFiberPEVolume->SetLineColor(kOrange + 1);
-        auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zLengthMiddleServices - zLengthCylinderMiddleServices / 2), new TGeoRotation(nullptr, refAngle + iSide * 180., 0, 0));
+        middleBarrelFiberPEVolume->SetLineColor(kOrange - 9);
+        auto* combiTrans = new TGeoCombiTrans(0, 0, (int)orientation * (zMiddleServicesBarrelFwdConnection - zLengthCylinderMiddleServicesBarrel / 2), new TGeoRotation(nullptr, refAngle + iSide * 180., 0, 0));
         motherVolume->AddNode(middleBarrelFiberSIO2Volume, 1, combiTrans);
         motherVolume->AddNode(middleBarrelFiberPEVolume, 1, combiTrans);
 
         // Create powerlines
         rCur += dR;
         dR = cuPowerAreaB / (3.14 * rCur);
-        TGeoTubeSeg* middleBarrelPowerCu = new TGeoTubeSeg(Form("TRK_MLB_POWER_CUsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
+        TGeoTubeSeg* middleBarrelPowerCu = new TGeoTubeSeg(Form("TRK_MLB_POWER_CUsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServicesBarrel / 2, -45, 45);
         TGeoVolume* middleBarrelPowerCuVolume = new TGeoVolume(Form("TRK_MLB_POWER_CU_A%d", iSide), middleBarrelPowerCu, medCu);
-        middleBarrelPowerCuVolume->SetLineColor(kOrange + 1);
+        middleBarrelPowerCuVolume->SetLineColor(kOrange - 9);
 
         rCur += dR;
         dR = pePowerAreaB / (3.14 * rCur);
-        TGeoTubeSeg* middleBarrelPowerPE = new TGeoTubeSeg(Form("TRK_MLB_POWER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServices / 2, -45, 45);
+        TGeoTubeSeg* middleBarrelPowerPE = new TGeoTubeSeg(Form("TRK_MLB_POWER_PEsh_A%d", iSide), rCur, rCur + dR, zLengthCylinderMiddleServicesBarrel / 2, -45, 45);
         TGeoVolume* middleBarrelPowerPEVolume = new TGeoVolume(Form("TRK_MLB_POWER_PE_A%d", iSide), middleBarrelPowerPE, medPE);
-        middleBarrelPowerPEVolume->SetLineColor(kOrange + 1);
+        middleBarrelPowerPEVolume->SetLineColor(kOrange - 9);
 
         motherVolume->AddNode(middleBarrelPowerCuVolume, 1, combiTrans);
         motherVolume->AddNode(middleBarrelPowerPEVolume, 1, combiTrans);
@@ -757,6 +760,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
   // A side: barrel + disk services
   // C side: only disk services
   float rMaxMiddleServicesBarFwd = 74.5f;              // TODO: add thickness of service barrels
+  float rMinMiddleBarrel = rMinMiddleServices;         // min radius of the service disk
   diskCircumference = rMaxMiddleServicesBarFwd * 3.14; // Only half of the area is used
   for (auto& orientation : {Orientation::kASide, Orientation::kCSide}) {
     float refAngle = 0;
@@ -768,7 +772,7 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
     double totalThickness = 0;
     for (int iSide = 0; iSide < 2; iSide++) {
       // Create fibers
-      double zCur = zLengthMiddleServices; // Change to f
+      double zCur = zMiddleServicesBarrelFwdConnection; // Change to f
       double dZ = siO2FiberAreaD / diskCircumference / 2.;
       totalThickness += 2 * dZ;
       if (orientation == Orientation::kASide) {
@@ -822,13 +826,13 @@ void TRKServices::createMLServicesPeacock(TGeoVolume* motherVolume)
     }
 
     // Forward part
-    float zLengthMiddleServicesFwd = 350.f - (143.f + totalThickness);
+    float zLengthMiddleServicesFwd = 350.f - (zMiddleServicesBarrelFwdConnection + totalThickness);
+    float rMinMiddleServicesFwd = 74.5f; // 74.5cm
 
     for (int iSide = 0; iSide < 2; iSide++) {
       // Create fibers
-      float rMinMiddleServicesFwd = 74.5f; // 74.5cm
 
-      float translation = (int)orientation * (143.f + totalThickness + zLengthMiddleServicesFwd / 2);
+      float translation = (int)orientation * (zMiddleServicesBarrelFwdConnection + totalThickness + zLengthMiddleServicesFwd / 2);
 
       double rCur = rMinMiddleServicesFwd;
       double dR = siO2FiberAreaD / (3.14 * rCur);
@@ -926,7 +930,7 @@ void TRKServices::createOTServicesPeacock(TGeoVolume* motherVolume)
   float zLengthOuterBarrelTubeServices = 215.f;                   // cm, IA, May 11, 2026: temporary length (?)
 
   // geometry of service "tubes" for OT disks
-  float rMinOuterDiskServices = 68.5f;    // cm
+  float rMinOuterDiskServices = 70.5f;    // cm
   float zStartOuterDiskServices = 149.f;  // cm
   float zLengthOuterDiskServices = 201.f; // cm
 

From 510ed793182aec6e2e2d35738ecc0860b1e4c56e Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Wed, 13 May 2026 10:55:25 +0200
Subject: [PATCH 1729/1764] ALICE3: start global tracking directory with TRK
 tracking (CPU+GPU and ROF staggering) (#15351)

* ALICE3: move tracking to GlobalReconstruction

* ALICE3: add cluster and GPU tracking paths

* ALICE3: derive ROF timing for TRK inputs

* ALICE3: write track ROFs and IR frames

* ALICE3: assign cluster MC labels in TimeFrame loading

* ALICE3: share TimeFrame code between CPU and GPU

* ALICE3: validate configuration before running

* ALICE3: clang-format

* ALICE3: fix initialisation with MC vertices

Co-authored-by: Copilot <copilot@github.com>

* ALICE3: add new performance macro

* ALICE3: Fix check cluster macro

* ALICE3: add protections in reading clusters

---------

Co-authored-by: Copilot <copilot@github.com>
---
 Detectors/Upgrades/ALICE3/CMakeLists.txt      |   1 +
 .../GlobalReconstruction/CMakeLists.txt       |  14 +
 .../macros/CMakeLists.txt                     |  21 +
 .../macros/CheckTracksALICE3.C                | 619 ++++++++++++++++++
 .../reconstruction/CMakeLists.txt             |  74 +++
 .../GPUExternalAllocator.h                    |  65 ++
 .../ALICE3GlobalReconstruction/TimeFrame.h    |  35 +
 .../ALICE3GlobalReconstruction/TimeFrameGPU.h |  35 +
 .../TimeFrameMixin.h                          | 557 ++++++++++++++++
 .../ALICE3GlobalReconstruction}/TrackerACTS.h |   6 +-
 .../src/GPUExternalAllocator.cxx              | 210 ++++++
 .../reconstruction/src/TimeFrame.cxx          |  25 +
 .../reconstruction/src/TimeFrameGPU.cxx       |  25 +
 .../reconstruction/src/TrackerACTS.cxx        |   6 +-
 .../workflow/CMakeLists.txt                   |  35 +
 .../GlobalReconstruction/workflow/README.md   | 133 ++++
 .../RecoWorkflow.h                            |  30 +
 .../TrackWriterSpec.h                         |   0
 .../TrackerSpec.h                             |   8 +-
 .../workflow/src/RecoWorkflow.cxx             |  40 ++
 .../workflow/src/TrackWriterSpec.cxx          |   2 +-
 .../workflow/src/TrackerSpec.cxx              | 549 ++++++++++++++++
 .../alice3-global-reconstruction-workflow.cxx |  65 ++
 .../ALICE3/TRK/macros/test/CheckClusters.C    | 236 +++++--
 .../ALICE3/TRK/reconstruction/CMakeLists.txt  |  18 +-
 .../include/TRKReconstruction/Clusterer.h     |   9 +-
 .../include/TRKReconstruction/ClustererACTS.h |   4 +-
 .../include/TRKReconstruction/TimeFrame.h     |  68 --
 .../TRK/reconstruction/src/Clusterer.cxx      |  57 +-
 .../TRK/reconstruction/src/ClustererACTS.cxx  |   4 +-
 .../TRK/reconstruction/src/TimeFrame.cxx      | 225 -------
 .../ALICE3/TRK/workflow/CMakeLists.txt        |   5 +-
 .../Upgrades/ALICE3/TRK/workflow/README.md    | 127 +---
 .../include/TRKWorkflow/RecoWorkflow.h        |   7 +-
 .../ALICE3/TRK/workflow/src/RecoWorkflow.cxx  |  15 +-
 .../ALICE3/TRK/workflow/src/TrackerSpec.cxx   | 439 -------------
 .../TRK/workflow/src/trk-reco-workflow.cxx    |  24 +-
 37 files changed, 2795 insertions(+), 998 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CheckTracksALICE3.C
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/GPUExternalAllocator.h
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrame.h
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameGPU.h
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameMixin.h
 rename Detectors/Upgrades/ALICE3/{TRK/reconstruction/include/TRKReconstruction => GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction}/TrackerACTS.h (96%)
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TimeFrame.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TimeFrameGPU.cxx
 rename Detectors/Upgrades/ALICE3/{TRK => GlobalReconstruction}/reconstruction/src/TrackerACTS.cxx (98%)
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/CMakeLists.txt
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/README.md
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/RecoWorkflow.h
 rename Detectors/Upgrades/ALICE3/{TRK/workflow/include/TRKWorkflow => GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow}/TrackWriterSpec.h (100%)
 rename Detectors/Upgrades/ALICE3/{TRK/workflow/include/TRKWorkflow => GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow}/TrackerSpec.h (84%)
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/RecoWorkflow.cxx
 rename Detectors/Upgrades/ALICE3/{TRK => GlobalReconstruction}/workflow/src/TrackWriterSpec.cxx (97%)
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/alice3-global-reconstruction-workflow.cxx
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
 delete mode 100644 Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx

diff --git a/Detectors/Upgrades/ALICE3/CMakeLists.txt b/Detectors/Upgrades/ALICE3/CMakeLists.txt
index 0335e85007c01..334bb13064783 100644
--- a/Detectors/Upgrades/ALICE3/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/CMakeLists.txt
@@ -11,6 +11,7 @@
 
 add_subdirectory(Passive)
 add_subdirectory(TRK)
+add_subdirectory(GlobalReconstruction)
 add_subdirectory(ECal)
 add_subdirectory(FD3)
 add_subdirectory(FT3)
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/GlobalReconstruction/CMakeLists.txt
new file mode 100644
index 0000000000000..6b859412a0ff5
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/CMakeLists.txt
@@ -0,0 +1,14 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+add_subdirectory(reconstruction)
+add_subdirectory(workflow)
+add_subdirectory(macros)
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CMakeLists.txt b/Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CMakeLists.txt
new file mode 100644
index 0000000000000..8295e490f4d7d
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_test_root_macro(CheckTracksALICE3.C
+                       PUBLIC_LINK_LIBRARIES O2::DataFormatsITS
+                                             O2::DataFormatsTRK
+                                             O2::ITStracking
+                                             O2::SimulationDataFormat
+                                             O2::DetectorsBase
+                                             O2::TRKBase
+                                             O2::TRKSimulation
+                                             O2::Steer
+                       LABELS trk COMPILE_ONLY)
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CheckTracksALICE3.C b/Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CheckTracksALICE3.C
new file mode 100644
index 0000000000000..836327507018c
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/macros/CheckTracksALICE3.C
@@ -0,0 +1,619 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file CheckTracksALICE3.C
+/// \brief Quality assurance macro for TRK tracking
+
+#if !defined(__CLING__) || defined(__ROOTCLING__)
+#include <array>
+#include <cmath>
+#include <iostream>
+#include <unordered_map>
+#include <vector>
+#include <unordered_set>
+
+#include <TFile.h>
+#include <TTree.h>
+#include <TH1D.h>
+#include <TCanvas.h>
+#include <THStack.h>
+#include <TLegend.h>
+#include <TLatex.h>
+#include <TStyle.h>
+
+#include "DataFormatsITS/TrackITS.h"
+#include "DataFormatsTRK/Cluster.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTrack.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "SimulationDataFormat/O2DatabasePDG.h"
+#include "Steer/MCKinematicsReader.h"
+
+#endif
+
+using namespace std;
+using namespace o2;
+
+struct ParticleClusterInfo {
+  std::bitset<11> layerClusters;
+  int nClusters = 0;
+  float pt = 0.0f;
+
+  void addCluster(int layer)
+  {
+    if (!layerClusters[layer]) {
+      layerClusters[layer] = true;
+      nClusters++;
+    }
+  }
+
+  bool hasConsecutiveLayers(int nConsecutive) const
+  {
+    for (int startLayer = 0; startLayer <= 11 - nConsecutive; ++startLayer) {
+      bool allSet = true;
+      for (int i = 0; i < nConsecutive; ++i) {
+        if (!layerClusters[startLayer + i]) {
+          allSet = false;
+          break;
+        }
+      }
+      if (allSet) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+void CheckTracksALICE3(std::string tracfile = "o2trac_trk.root",
+                       std::string simprefix = "o2sim",
+                       std::string clusfile = "o2clus_trk.root",
+                       std::string outputfile = "trk_qa_output.root")
+{
+  gStyle->SetOptStat(0);
+
+  std::cout << "=== Starting TRK Track Quality Assurance ===" << std::endl;
+  std::cout << "Input files:" << std::endl;
+  std::cout << "  Tracks:      " << tracfile << std::endl;
+  std::cout << "  Sim prefix:  " << simprefix << std::endl;
+  std::cout << "  Clusters:    " << clusfile << std::endl;
+  std::cout << "  Output:      " << outputfile << std::endl;
+  std::cout << std::endl;
+
+  // MC kinematics reader
+  o2::steer::MCKinematicsReader kineReader(simprefix, o2::steer::MCKinematicsReader::Mode::kMCKine);
+  const int nEvents = kineReader.getNEvents(0);
+  std::cout << "Number of MC events: " << nEvents << std::endl;
+
+  // Open clusters file to count cluster-associated layers per particle
+  TFile* clustersFile = TFile::Open(clusfile.c_str(), "READ");
+  if (!clustersFile || clustersFile->IsZombie()) {
+    std::cerr << "ERROR: Cannot open clusters file: " << clusfile << std::endl;
+    return;
+  }
+  TTree* clusTree = clustersFile->Get<TTree>("o2sim");
+  if (!clusTree) {
+    std::cerr << "ERROR: Cannot find o2sim tree in clusters file" << std::endl;
+    return;
+  }
+
+  // Open reconstructed tracks file
+  TFile* tracFile = TFile::Open(tracfile.c_str(), "READ");
+  if (!tracFile || tracFile->IsZombie()) {
+    std::cerr << "ERROR: Cannot open tracks file: " << tracfile << std::endl;
+    return;
+  }
+  TTree* recTree = tracFile->Get<TTree>("o2sim");
+  if (!recTree) {
+    std::cerr << "ERROR: Cannot find o2sim tree in tracks file" << std::endl;
+    return;
+  }
+
+  // Reconstructed tracks and labels
+  std::vector<o2::its::TrackITS>* recTracks = nullptr;
+  std::vector<o2::MCCompLabel>* trkLabels = nullptr;
+  recTree->SetBranchAddress("TRKTrack", &recTracks);
+  recTree->SetBranchAddress("TRKTrackMCTruth", &trkLabels);
+
+  std::cout << "Reading tracks from tree..." << std::endl;
+
+  // Analyze cluster tree to count cluster-associated layers per particle
+  std::cout << "Analyzing clusters from tree..." << std::endl;
+  std::unordered_map<o2::MCCompLabel, ParticleClusterInfo> particleClusterMap;
+
+  static constexpr int nTRKLayers = 11;
+  std::array<std::vector<o2::trk::Cluster>*, nTRKLayers> clustersPerLayer{};
+  std::array<o2::dataformats::MCTruthContainer<o2::MCCompLabel>*, nTRKLayers> clusterLabelsPerLayer{};
+
+  for (int iLayer = 0; iLayer < nTRKLayers; ++iLayer) {
+    const std::string clusBranch = std::string("TRKClusterComp_") + std::to_string(iLayer);
+    const std::string truthBranch = std::string("TRKClusterMCTruth_") + std::to_string(iLayer);
+    if (!clusTree->GetBranch(clusBranch.c_str())) {
+      std::cerr << "WARNING: Missing cluster branch for layer " << iLayer << " (expected " << clusBranch << ")" << std::endl;
+      continue;
+    }
+    if (!clusTree->GetBranch(truthBranch.c_str())) {
+      std::cerr << "WARNING: Missing cluster MC-truth branch for layer " << iLayer << " (expected " << truthBranch << ")" << std::endl;
+      continue;
+    }
+    clusTree->SetBranchAddress(clusBranch.c_str(), &clustersPerLayer[iLayer]);
+    clusTree->SetBranchAddress(truthBranch.c_str(), &clusterLabelsPerLayer[iLayer]);
+  }
+
+  Long64_t nClusEntries = clusTree->GetEntries();
+  std::cout << "Processing " << nClusEntries << " cluster entries..." << std::endl;
+
+  for (Long64_t iEntry = 0; iEntry < nClusEntries; ++iEntry) {
+    clusTree->GetEntry(iEntry);
+    for (int iLayer = 0; iLayer < nTRKLayers; ++iLayer) {
+      const auto* clusArr = clustersPerLayer[iLayer];
+      const auto* clusLabArr = clusterLabelsPerLayer[iLayer];
+      if (!clusArr || !clusLabArr) {
+        continue;
+      }
+      for (size_t iClus = 0; iClus < clusArr->size(); ++iClus) {
+        const auto labels = clusLabArr->getLabels(iClus);
+        if (labels.empty()) {
+          continue;
+        }
+        const auto& lab = labels[0];
+        if (!lab.isValid() || lab.getSourceID() != 0 || !lab.isCorrect()) {
+          continue;
+        }
+        int trackID = -1, evID = -1, srcID = -1;
+        bool fake = false;
+        lab.get(trackID, evID, srcID, fake);
+        if (trackID < 0 || evID < 0) {
+          continue;
+        }
+        particleClusterMap[o2::MCCompLabel(trackID, evID, 0)].addCluster(iLayer);
+      }
+    }
+  }
+
+  std::cout << "Found " << particleClusterMap.size() << " unique particles with clusters" << std::endl;
+
+  // Store particle info and fill generated histograms
+  std::unordered_map<o2::MCCompLabel, float> particlePtMap;
+
+  // Create histograms
+  constexpr int nb = 100;
+  double xbins[nb + 1], ptcutl = 0.05, ptcuth = 10.;
+  double a = std::log(ptcuth / ptcutl) / nb;
+  for (int i = 0; i <= nb; i++)
+    xbins[i] = ptcutl * std::exp(i * a);
+
+  TH1D genParticlePtHist("genParticlePt", "Generated Particle p_{T} (All Layers); #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+  TH1D genParticlePt7LayersHist("genParticlePt7Layers", "Generated Particle p_{T} with clusters in at least 7 consecutive layers; #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+  TH1D chargedPrimaryPtHist("chargedPrimaryPt",
+                            "Charged primary particles |#eta| < 2; #it{p}_{T} (GeV/#it{c}); Counts",
+                            nb, xbins);
+  TH1D goodTracks("goodTracks", "Good Tracks; p_{T} (GeV/c); Counts", nb, xbins);
+  TH1D fakeTracks("fakeTracks", "Fake Tracks; p_{T} (GeV/c); Counts", nb, xbins);
+
+  std::array<TH1D, 5> goodTracksMatching, fakeTracksMatching;
+  for (int i = 0; i < 5; ++i) {
+    goodTracksMatching[i] = TH1D(Form("goodTracksMatching_%dLayers", i + 7),
+                                 Form("Good Tracks with %d cluster layers; p_{T} (GeV/c); Counts", i + 7),
+                                 nb, xbins);
+    fakeTracksMatching[i] = TH1D(Form("fakeTracksMatching_%dLayers", i + 7),
+                                 Form("Fake Tracks with %d cluster layers; p_{T} (GeV/c); Counts", i + 7),
+                                 nb, xbins);
+  }
+
+  TH1D numberOfClustersPerTrack("numberOfClustersPerTrack",
+                                "Number of clusters per track; N_{clusters}; Counts",
+                                12, -0.5, 11.5);
+  TH1D cloneTracks("cloneTracks", "Clone Tracks; #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+
+  std::array<TH1D, 5> duplicateTracksMatching;
+  for (int i = 0; i < 5; ++i) {
+    duplicateTracksMatching[i] = TH1D(Form("duplicateTracksMatching_%dLayers", i + 7),
+                                      Form("Duplicate Tracks with %d cluster layers; p_{T} (GeV/c); Counts", i + 7),
+                                      nb, xbins);
+  }
+
+  TH1D genParticleEtaHist("genParticleEta",
+                          "Generated Particle #eta (11 consec. layers, p_{T} > 1 GeV/c); #eta; Counts",
+                          100, -2.5, 2.5);
+  std::array<TH1D, 5> goodTracksMatchingEta;
+  for (int i = 0; i < 5; ++i) {
+    goodTracksMatchingEta[i] = TH1D(Form("goodTracksMatchingEta_%dLayers", i + 7),
+                                    Form("Good Tracks #eta with %d cluster layers (p_{T} > 1 GeV/c); #eta; Counts", i + 7),
+                                    100, -2.5, 2.5);
+  }
+
+  // Numerators for summary efficiency/fake/duplicate vs 7-layer reference
+  TH1D goodTracks7("goodTracks7Layers", "Good Tracks (7 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+  TH1D fakeTracks7("fakeTracks7Layers", "Fake Tracks (7 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+  TH1D cloneTracks7("cloneTracks7Layers", "Clone Tracks (7 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+
+  // Deduplicated fake/clone numerators for 11-layer reference summary
+  TH1D fakeTracks11("fakeTracks11Layers", "Fake Tracks (11 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+  TH1D cloneTracks11("cloneTracks11Layers", "Clone Tracks (11 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Counts", nb, xbins);
+
+  // First pass: identify particles with full hit coverage from kinematics
+  std::cout << "Analyzing MC particles..." << std::endl;
+  for (int iEvent = 0; iEvent < nEvents; ++iEvent) {
+    const auto& mcTracks = kineReader.getTracks(iEvent);
+    for (size_t iTrack = 0; iTrack < mcTracks.size(); ++iTrack) {
+      const auto& mcTrack = mcTracks[iTrack];
+      if (!mcTrack.isPrimary()) {
+        continue;
+      }
+
+      // Create label for this particle
+      o2::MCCompLabel label(iTrack, iEvent, 0);
+      float pt = mcTrack.GetPt();
+
+      // Charged primary in |eta| < 2
+      if (std::abs(mcTrack.GetEta()) < 2.f) {
+        auto* pdgPart = o2::O2DatabasePDG::Instance()->GetParticle(mcTrack.GetPdgCode());
+        if (pdgPart != nullptr && pdgPart->Charge() != 0.) {
+          chargedPrimaryPtHist.Fill(pt);
+        }
+      }
+
+      // Store particle info
+      particlePtMap[label] = pt;
+
+      auto clusIt = particleClusterMap.find(label);
+      if (clusIt != particleClusterMap.end()) {
+        clusIt->second.pt = pt;
+
+        if (clusIt->second.hasConsecutiveLayers(11)) {
+          genParticlePtHist.Fill(pt);
+          if (pt > 1.f) {
+            genParticleEtaHist.Fill(mcTrack.GetEta());
+          }
+        }
+
+        if (clusIt->second.hasConsecutiveLayers(7)) {
+          genParticlePt7LayersHist.Fill(pt);
+        }
+      }
+    }
+  }
+
+  std::cout << "Generated particles with 11 cluster layers: " << genParticlePtHist.GetEntries() << std::endl;
+  std::cout << "Generated particles with 7+ consecutive cluster layers: " << genParticlePt7LayersHist.GetEntries() << std::endl;
+
+  // Count how many reconstructed tracks point to each MC label (clone detection)
+  std::unordered_map<o2::MCCompLabel, int> labelRecoCount;
+  {
+    int nROFsTmp = recTree->GetEntries();
+    for (int iROF = 0; iROF < nROFsTmp; ++iROF) {
+      recTree->GetEntry(iROF);
+      if (!trkLabels) {
+        continue;
+      }
+      for (const auto& lab : *trkLabels) {
+        if (!lab.isSet() || !lab.isValid() || lab.isFake()) {
+          continue;
+        }
+        int eventID = lab.getEventID();
+        int trackID = lab.getTrackID();
+        if (eventID < 0 || eventID >= nEvents) {
+          continue;
+        }
+        const auto& mcTracks = kineReader.getTracks(eventID);
+        if (trackID < 0 || trackID >= (int)mcTracks.size()) {
+          continue;
+        }
+        if (!mcTracks[trackID].isPrimary()) {
+          continue;
+        }
+        labelRecoCount[o2::MCCompLabel(lab.getTrackID(), lab.getEventID(), 0)]++;
+      }
+    }
+  }
+
+  // Second pass: analyze reconstructed tracks
+  std::cout << "Analyzing reconstructed tracks..." << std::endl;
+  int nROFs = recTree->GetEntries();
+  int totalTracks = 0;
+  int goodTracksCount = 0;
+  int fakeTracksCount = 0;
+  int cloneTracksCount = 0;
+  // Track which MC labels have already been filled per matching bin to avoid double-counting clones
+  std::array<std::unordered_set<o2::MCCompLabel>, 5> filledGoodLabels;
+  std::unordered_set<o2::MCCompLabel> filledGoodLabelsAny;
+  std::unordered_set<o2::MCCompLabel> filledGoodLabelsAny7;
+  std::unordered_set<o2::MCCompLabel> filledFakeLabelsAny11;
+  std::unordered_set<o2::MCCompLabel> filledCloneLabelsAny11;
+
+  for (int iROF = 0; iROF < nROFs; ++iROF) {
+    recTree->GetEntry(iROF);
+
+    if (!recTracks || !trkLabels) {
+      continue;
+    }
+
+    totalTracks += recTracks->size();
+
+    for (size_t iTrack = 0; iTrack < recTracks->size(); ++iTrack) {
+      const auto& track = recTracks->at(iTrack);
+      const auto& label = trkLabels->at(iTrack);
+
+      if (!label.isSet() || !label.isValid()) {
+        continue;
+      }
+
+      int eventID = label.getEventID();
+      int trackID = label.getTrackID();
+      int nClusters = track.getNumberOfClusters();
+
+      // Get MC track info
+      if (eventID < 0 || eventID >= nEvents) {
+        continue;
+      }
+
+      const auto& mcTracks = kineReader.getTracks(eventID);
+      if (trackID < 0 || trackID >= (int)mcTracks.size()) {
+        continue;
+      }
+      if (!mcTracks[trackID].isPrimary()) {
+        continue;
+      }
+
+      float pt = mcTracks[trackID].GetPt();
+      float eta = mcTracks[trackID].GetEta();
+
+      // Fill histograms
+      numberOfClustersPerTrack.Fill(nClusters);
+
+      auto key = o2::MCCompLabel(trackID, eventID, 0);
+      if (particleClusterMap.find(key) != particleClusterMap.end() && particleClusterMap[key].hasConsecutiveLayers(11)) {
+        if (label.isFake()) {
+          fakeTracks.Fill(pt);
+          fakeTracksCount++;
+          if (nClusters >= 7 && nClusters <= 11) {
+            fakeTracksMatching[nClusters - 7].Fill(pt);
+          }
+          filledFakeLabelsAny11.insert(key);
+        } else {
+          if (filledGoodLabelsAny.insert(key).second) {
+            goodTracks.Fill(pt);
+            goodTracksCount++;
+          }
+          if (nClusters >= 7 && nClusters <= 11) {
+            int bin = nClusters - 7;
+            if (filledGoodLabels[bin].insert(key).second) {
+              goodTracksMatching[bin].Fill(pt);
+              if (pt > 1.f) {
+                goodTracksMatchingEta[bin].Fill(eta);
+              }
+            } else {
+              duplicateTracksMatching[bin].Fill(pt);
+            }
+          }
+          if (labelRecoCount[key] > 1) {
+            cloneTracks.Fill(pt);
+            cloneTracksCount++;
+            filledCloneLabelsAny11.insert(key);
+          }
+        }
+      }
+
+      // Fill summary histograms vs 7-layer reference
+      auto clusIt7 = particleClusterMap.find(key);
+      if (clusIt7 != particleClusterMap.end() && clusIt7->second.hasConsecutiveLayers(7)) {
+        if (label.isFake()) {
+          fakeTracks7.Fill(pt);
+        } else {
+          if (filledGoodLabelsAny7.insert(key).second) {
+            goodTracks7.Fill(pt);
+          }
+          if (labelRecoCount[key] > 1) {
+            cloneTracks7.Fill(pt);
+          }
+        }
+      }
+    }
+  }
+
+  // Create efficiency histograms
+  std::cout << "Total tracks: " << totalTracks << ". Out of those matching particles with 11 clusters, good: " << goodTracksCount
+            << ", fake: " << fakeTracksCount << ", clones: " << cloneTracksCount << std::endl;
+
+  std::cout << "Computing efficiencies..." << std::endl;
+
+  std::array<TH1D, 5> efficiencyHistograms;
+  THStack* efficiencyStack = new THStack("efficiencyStack",
+                                         "Tracking Efficiency; #it{p}_{T} (GeV/#it{c}); Efficiency");
+
+  std::array<TH1D, 5> efficiencyEtaHistograms;
+  THStack* efficiencyEtaStack = new THStack("efficiencyEtaStack",
+                                            "Tracking Efficiency vs #eta (p_{T} > 1 GeV/c); #eta; Efficiency");
+
+  int colors[5] = {kRed, kBlue, kGreen + 2, kMagenta, kOrange};
+  for (int i = 0; i < 5; ++i) {
+    int nClusters = i + 7;
+    efficiencyHistograms[i] = TH1D(Form("efficiency_%dClusters", nClusters),
+                                   Form("Efficiency for %d cluster tracks; #it{p}_{T} (GeV/#it{c}); Efficiency", nClusters),
+                                   nb, xbins);
+
+    efficiencyHistograms[i].Divide(&goodTracksMatching[i], &genParticlePtHist, 1, 1, "B");
+
+    efficiencyHistograms[i].SetLineColor(colors[i]);
+    efficiencyHistograms[i].SetFillColor(colors[i]);
+    efficiencyHistograms[i].SetLineWidth(2);
+    efficiencyHistograms[i].SetMarkerColor(colors[i]);
+    efficiencyHistograms[i].SetMarkerStyle(20 + i);
+    efficiencyStack->Add(&efficiencyHistograms[i]);
+
+    efficiencyEtaHistograms[i] = TH1D(Form("efficiencyEta_%dClusters", nClusters),
+                                      Form("Efficiency vs #eta for %d cluster tracks (p_{T} > 1 GeV/c); #eta; Efficiency", nClusters),
+                                      100, -2.5, 2.5);
+    efficiencyEtaHistograms[i].Divide(&goodTracksMatchingEta[i], &genParticleEtaHist, 1, 1, "B");
+    efficiencyEtaHistograms[i].SetLineColor(colors[i]);
+    efficiencyEtaHistograms[i].SetFillColor(colors[i]);
+    efficiencyEtaHistograms[i].SetLineWidth(2);
+    efficiencyEtaHistograms[i].SetMarkerColor(colors[i]);
+    efficiencyEtaHistograms[i].SetMarkerStyle(20 + i);
+    efficiencyEtaStack->Add(&efficiencyEtaHistograms[i]);
+  }
+
+  // Build summary efficiency/fake/duplicate vs 7-layer reference
+  TH1D effVs7("efficiencyVs7Layers",
+              "Tracking Efficiency (7 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Rate",
+              nb, xbins);
+  effVs7.Divide(&goodTracks7, &genParticlePt7LayersHist, 1, 1, "B");
+  effVs7.SetLineColor(kBlue);
+  effVs7.SetLineWidth(2);
+  effVs7.SetMarkerColor(kBlue);
+  effVs7.SetMarkerStyle(20);
+
+  TH1D fakeVs7("fakeRateVs7Layers",
+               "Fake Rate (7 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Rate",
+               nb, xbins);
+  fakeVs7.Divide(&fakeTracks7, &genParticlePt7LayersHist, 1, 1, "B");
+  fakeVs7.SetLineColor(kRed);
+  fakeVs7.SetLineWidth(2);
+  fakeVs7.SetMarkerColor(kRed);
+  fakeVs7.SetMarkerStyle(21);
+
+  TH1D dupVs7("duplicateRateVs7Layers",
+              "Duplicate Rate (7 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Rate",
+              nb, xbins);
+  dupVs7.Divide(&cloneTracks7, &genParticlePt7LayersHist, 1, 1, "B");
+  dupVs7.SetLineColor(kGreen + 2);
+  dupVs7.SetLineWidth(2);
+  dupVs7.SetMarkerColor(kGreen + 2);
+  dupVs7.SetMarkerStyle(22);
+
+  // Build summary efficiency/fake/duplicate vs 11-layer reference
+  // Fill deduplicated fake/clone histograms from the sets collected during the reco loop
+  for (const auto& [lbl, info] : particleClusterMap) {
+    if (!info.hasConsecutiveLayers(11)) {
+      continue;
+    }
+    auto ptIt = particlePtMap.find(lbl);
+    if (ptIt == particlePtMap.end()) {
+      continue;
+    }
+    float ptLbl = ptIt->second;
+    if (filledFakeLabelsAny11.count(lbl)) {
+      fakeTracks11.Fill(ptLbl);
+    }
+    if (filledCloneLabelsAny11.count(lbl)) {
+      cloneTracks11.Fill(ptLbl);
+    }
+  }
+
+  TH1D effVs11("efficiencyVs11Layers",
+               "Tracking Efficiency (11 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Rate",
+               nb, xbins);
+  effVs11.Divide(&goodTracks, &genParticlePtHist, 1, 1, "B");
+  effVs11.SetLineColor(kBlue);
+  effVs11.SetLineWidth(2);
+  effVs11.SetMarkerColor(kBlue);
+  effVs11.SetMarkerStyle(20);
+
+  TH1D fakeVs11("fakeRateVs11Layers",
+                "Fake Rate (11 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Rate",
+                nb, xbins);
+  fakeVs11.Divide(&fakeTracks11, &genParticlePtHist, 1, 1, "B");
+  fakeVs11.SetLineColor(kRed);
+  fakeVs11.SetLineWidth(2);
+  fakeVs11.SetMarkerColor(kRed);
+  fakeVs11.SetMarkerStyle(21);
+
+  TH1D dupVs11("duplicateRateVs11Layers",
+               "Duplicate Rate (11 consec. layers ref.); #it{p}_{T} (GeV/#it{c}); Rate",
+               nb, xbins);
+  dupVs11.Divide(&cloneTracks11, &genParticlePtHist, 1, 1, "B");
+  dupVs11.SetLineColor(kGreen + 2);
+  dupVs11.SetLineWidth(2);
+  dupVs11.SetMarkerColor(kGreen + 2);
+  dupVs11.SetMarkerStyle(22);
+
+  // Summary canvas — 7-layer reference
+  TCanvas summaryCanvas("summaryCanvas7Layers", "TRK Tracking QA Summary (7 layers ref.)", 800, 600);
+  summaryCanvas.SetLogx();
+  double ymax = std::max({effVs7.GetMaximum(), fakeVs7.GetMaximum(), dupVs7.GetMaximum()});
+  effVs7.GetYaxis()->SetRangeUser(0., 1.1 * ymax + 0.05);
+  effVs7.Draw("E");
+  fakeVs7.Draw("E SAME");
+  dupVs7.Draw("E SAME");
+  TLegend leg(0.65, 0.70, 0.88, 0.88);
+  leg.SetBorderSize(0);
+  leg.AddEntry(&effVs7, "Efficiency", "lp");
+  leg.AddEntry(&fakeVs7, "Fake rate", "lp");
+  leg.AddEntry(&dupVs7, "Duplicate rate", "lp");
+  leg.Draw();
+
+  // Summary canvas — 11-layer reference
+  TCanvas summaryCanvas11("summaryCanvas11Layers", "TRK Tracking QA Summary (11 layers ref.)", 800, 600);
+  summaryCanvas11.SetLogx();
+  double ymax11 = std::max({effVs11.GetMaximum(), fakeVs11.GetMaximum(), dupVs11.GetMaximum()});
+  effVs11.GetYaxis()->SetRangeUser(0., 1.1 * ymax11 + 0.05);
+  effVs11.Draw("E");
+  fakeVs11.Draw("E SAME");
+  dupVs11.Draw("E SAME");
+  TLegend leg11(0.65, 0.70, 0.88, 0.88);
+  leg11.SetBorderSize(0);
+  leg11.AddEntry(&effVs11, "Efficiency", "lp");
+  leg11.AddEntry(&fakeVs11, "Fake rate", "lp");
+  leg11.AddEntry(&dupVs11, "Duplicate rate", "lp");
+  leg11.Draw();
+
+  // Write output
+  std::cout << "Writing output to " << outputfile << std::endl;
+  TFile outFile(outputfile.c_str(), "RECREATE");
+
+  // Top-level: summary plots
+  summaryCanvas.Write();
+  effVs7.Write();
+  fakeVs7.Write();
+  dupVs7.Write();
+  summaryCanvas11.Write();
+  effVs11.Write();
+  fakeVs11.Write();
+  dupVs11.Write();
+
+  // Details directory: per-cluster-count breakdowns and raw counts
+  TDirectory* detDir = outFile.mkdir("details");
+  detDir->cd();
+  genParticlePtHist.Write();
+  genParticlePt7LayersHist.Write();
+  genParticleEtaHist.Write();
+  chargedPrimaryPtHist.Write();
+  goodTracks.Write();
+  fakeTracks.Write();
+  cloneTracks.Write();
+  goodTracks7.Write();
+  fakeTracks7.Write();
+  cloneTracks7.Write();
+  fakeTracks11.Write();
+  cloneTracks11.Write();
+  numberOfClustersPerTrack.Write();
+  for (int i = 0; i < 5; ++i) {
+    goodTracksMatching[i].Write();
+    fakeTracksMatching[i].Write();
+    duplicateTracksMatching[i].Write();
+    efficiencyHistograms[i].Write();
+    goodTracksMatchingEta[i].Write();
+    efficiencyEtaHistograms[i].Write();
+  }
+  efficiencyStack->Write();
+  efficiencyEtaStack->Write();
+
+  outFile.Close();
+
+  // Clean up
+  clustersFile->Close();
+  tracFile->Close();
+  delete efficiencyStack;
+  delete efficiencyEtaStack;
+  delete clustersFile;
+  delete tracFile;
+}
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt
new file mode 100644
index 0000000000000..8805c1885b079
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt
@@ -0,0 +1,74 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+if(Acts_FOUND)
+  set(actsTarget Acts::Core)
+endif()
+
+set(alice3GlobalRecoGpuSources "")
+set(alice3GlobalRecoGpuTargets "")
+set(alice3GlobalRecoGpuPrivateTargets "")
+if(CUDA_ENABLED)
+  find_package(CUDAToolkit REQUIRED)
+  list(APPEND alice3GlobalRecoGpuSources src/TimeFrameGPU.cxx src/GPUExternalAllocator.cxx)
+  list(APPEND alice3GlobalRecoGpuTargets O2::ITStrackingCUDA)
+  list(APPEND alice3GlobalRecoGpuPrivateTargets CUDA::cudart)
+elseif(HIP_ENABLED)
+  list(APPEND alice3GlobalRecoGpuSources src/TimeFrameGPU.cxx src/GPUExternalAllocator.cxx)
+  list(APPEND alice3GlobalRecoGpuTargets O2::ITStrackingHIP)
+  list(APPEND alice3GlobalRecoGpuPrivateTargets hip::host)
+endif()
+
+o2_add_library(ALICE3GlobalReconstruction
+               TARGETVARNAME targetName
+               SOURCES src/TimeFrame.cxx
+                       ${alice3GlobalRecoGpuSources}
+                       $<$<BOOL:${Acts_FOUND}>:src/TrackerACTS.cxx>
+               PUBLIC_LINK_LIBRARIES
+                       O2::ITStracking
+                       O2::GPUCommon
+                       Microsoft.GSL::GSL
+                       O2::CommonConstants
+                       O2::DataFormatsITSMFT
+                       O2::DataFormatsTRK
+                       O2::SimulationDataFormat
+                       O2::ITSBase
+                       O2::ITSReconstruction
+                       O2::ITSMFTReconstruction
+                       O2::DataFormatsITS
+                       O2::TRKBase
+                       O2::TRKReconstruction
+                       O2::TRKSimulation
+                       nlohmann_json::nlohmann_json
+                       ${alice3GlobalRecoGpuTargets}
+                       ${actsTarget}
+               PRIVATE_LINK_LIBRARIES
+                       O2::Steer
+                       TBB::tbb
+                       ${alice3GlobalRecoGpuPrivateTargets})
+
+if(alice3GlobalRecoGpuTargets)
+  target_compile_definitions(${targetName} PUBLIC TRK_HAS_GPU_TRACKING)
+endif()
+
+if(CUDA_ENABLED)
+  target_include_directories(${targetName} PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
+endif()
+
+if(CUDA_ENABLED)
+  target_compile_definitions(${targetName} PUBLIC TRK_HAS_CUDA_TRACKING)
+elseif(HIP_ENABLED)
+  target_compile_definitions(${targetName} PUBLIC TRK_HAS_HIP_TRACKING)
+endif()
+
+if(Acts_FOUND)
+  target_compile_definitions(${targetName} PUBLIC O2_WITH_ACTS)
+endif()
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/GPUExternalAllocator.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/GPUExternalAllocator.h
new file mode 100644
index 0000000000000..e873931a5a46c
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/GPUExternalAllocator.h
@@ -0,0 +1,65 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef ALICEO2_ALICE3GLOBALRECONSTRUCTION_GPUEXTERNALALLOCATOR_H
+#define ALICEO2_ALICE3GLOBALRECONSTRUCTION_GPUEXTERNALALLOCATOR_H
+
+#include "ITStracking/ExternalAllocator.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <mutex>
+#include <type_traits>
+#include <unordered_map>
+#include <vector>
+
+namespace o2::trk
+{
+
+class GPUExternalAllocator final : public o2::its::ExternalAllocator
+{
+ public:
+  GPUExternalAllocator() = default;
+  ~GPUExternalAllocator();
+
+  void* allocate(size_t size) override;
+  void deallocate(char* ptr, size_t size) override;
+  void pushTagOnStack(uint64_t tag) override;
+  void popTagOffStack(uint64_t tag) override;
+
+  void releaseAll();
+
+ private:
+  enum class AllocationSpace { Host,
+                               Device };
+
+  struct AllocationMeta {
+    AllocationSpace space;
+    uint64_t tag;
+    bool stacked;
+  };
+
+  using MemoryType = std::underlying_type_t<o2::gpu::GPUMemoryResource::MemoryType>;
+
+  void* allocateHost(size_t size);
+  void* allocateDevice(size_t size);
+  void freeAllocation(void* ptr, AllocationSpace space);
+  void removeFromTagLocked(uint64_t tag, void* ptr);
+
+  std::mutex mMutex;
+  std::vector<uint64_t> mTagStack;
+  std::unordered_map<uint64_t, std::vector<void*>> mTaggedAllocations;
+  std::unordered_map<void*, AllocationMeta> mAllocations;
+};
+
+} // namespace o2::trk
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrame.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrame.h
new file mode 100644
index 0000000000000..6daefb2346e2c
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrame.h
@@ -0,0 +1,35 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file TimeFrame.h
+/// \brief CPU TRK TimeFrame wrapper.
+///
+
+#ifndef ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAME_H
+#define ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAME_H
+
+#include "ALICE3GlobalReconstruction/TimeFrameMixin.h"
+#include "ITStracking/TimeFrame.h"
+
+namespace o2::trk
+{
+
+template <int nLayers = 11>
+class TimeFrame : public TimeFrameMixin<nLayers, o2::its::TimeFrame<nLayers>>
+{
+ public:
+  TimeFrame() = default;
+  ~TimeFrame() override = default;
+};
+
+} // namespace o2::trk
+
+#endif // ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAME_H
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameGPU.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameGPU.h
new file mode 100644
index 0000000000000..744fca166489f
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameGPU.h
@@ -0,0 +1,35 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file TimeFrameGPU.h
+/// \brief GPU TRK TimeFrame wrapper.
+///
+
+#ifndef ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAMEGPU_H
+#define ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAMEGPU_H
+
+#include "ALICE3GlobalReconstruction/TimeFrameMixin.h"
+#include "ITStrackingGPU/TimeFrameGPU.h"
+
+namespace o2::trk
+{
+
+template <int nLayers = 11>
+class TimeFrameGPU : public TimeFrameMixin<nLayers, o2::its::gpu::TimeFrameGPU<nLayers>>
+{
+ public:
+  TimeFrameGPU() = default;
+  ~TimeFrameGPU() override = default;
+};
+
+} // namespace o2::trk
+
+#endif // ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAMEGPU_H
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameMixin.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameMixin.h
new file mode 100644
index 0000000000000..6e95be32dd0e1
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TimeFrameMixin.h
@@ -0,0 +1,557 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file TimeFrameMixin.h
+/// \brief Shared TRK TimeFrame helpers for CPU and GPU backends.
+///
+
+#ifndef ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAMEMIXIN_H
+#define ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAMEMIXIN_H
+
+#include "CommonDataFormat/InteractionRecord.h"
+#include "DataFormatsTRK/Cluster.h"
+#include "DataFormatsTRK/ROFRecord.h"
+#include "ITStracking/ROFLookupTables.h"
+#include "ITStracking/TimeFrame.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCEventHeader.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "SimulationDataFormat/DigitizationContext.h"
+#include "Steer/MCKinematicsReader.h"
+#include "TRKReconstruction/Clusterer.h"
+#include "TRKSimulation/Hit.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/SegmentationChip.h"
+#include "Framework/Logger.h"
+
+#include <Rtypes.h>
+#include <TTree.h>
+#include <TRandom3.h>
+#include <gsl/span>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <limits>
+#include <ranges>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+namespace o2::trk
+{
+
+template <int nLayers, class Base>
+class TimeFrameMixin : public Base
+{
+ public:
+  TimeFrameMixin() = default;
+  ~TimeFrameMixin() override = default;
+
+  int loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config);
+
+  int loadROFrameData(const std::array<gsl::span<const o2::trk::ROFRecord>, nLayers>& layerROFs,
+                      const std::array<gsl::span<const o2::trk::Cluster>, nLayers>& layerClusters,
+                      const std::array<gsl::span<const unsigned char>, nLayers>& layerPatterns,
+                      const std::array<const dataformats::MCTruthContainer<MCCompLabel>*, nLayers>* mcLabels = nullptr,
+                      float yPlaneMLOT = 0.f);
+
+  void getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup);
+
+  void addTruthSeedingVertices();
+
+  void deriveAndInitTiming(const std::array<gsl::span<const o2::trk::ROFRecord>, nLayers>& layerROFs);
+
+  const o2::InteractionRecord& getTFAnchorIR() const noexcept { return mTFAnchorIR; }
+
+ protected:
+  void initTimingTables(const std::array<o2::its::LayerTiming, nLayers>& timings);
+  void updateHostROFVertexLookupTable();
+
+  bool mTimingTablesInitialised{false};
+  o2::InteractionRecord mTFAnchorIR{0, 0};
+};
+
+template <int nLayers, class Base>
+void TimeFrameMixin<nLayers, Base>::updateHostROFVertexLookupTable()
+{
+  static_cast<o2::its::TimeFrame<nLayers>*>(this)->updateROFVertexLookupTable();
+}
+
+template <int nLayers, class Base>
+void TimeFrameMixin<nLayers, Base>::initTimingTables(const std::array<o2::its::LayerTiming, nLayers>& timings)
+{
+  if (mTimingTablesInitialised) {
+    return;
+  }
+  typename o2::its::TimeFrame<nLayers>::ROFOverlapTableN rofOverlapTable;
+  typename o2::its::TimeFrame<nLayers>::ROFVertexLookupTableN rofVertexLookupTable;
+  typename o2::its::TimeFrame<nLayers>::ROFMaskTableN rofMaskTable;
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    rofOverlapTable.defineLayer(iLayer, timings[iLayer]);
+    rofVertexLookupTable.defineLayer(iLayer, timings[iLayer]);
+    rofMaskTable.defineLayer(iLayer, timings[iLayer]);
+  }
+  rofOverlapTable.init();
+  rofVertexLookupTable.init();
+  rofMaskTable.init();
+  rofMaskTable.resetMask(1u);
+  this->setROFOverlapTable(std::move(rofOverlapTable));
+  this->setROFVertexLookupTable(std::move(rofVertexLookupTable));
+  this->setMultiplicityCutMask(std::move(rofMaskTable));
+  this->useMultiplictyMask();
+  mTimingTablesInitialised = true;
+
+  const auto maskView = this->getROFMaskView();
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    LOGP(info, "TRK timing initialised: layer {}: {}", iLayer, timings[iLayer].asString());
+    LOGP(info, "TRK ROF mask: {}", maskView.asString(iLayer));
+  }
+}
+
+template <int nLayers, class Base>
+void TimeFrameMixin<nLayers, Base>::deriveAndInitTiming(const std::array<gsl::span<const o2::trk::ROFRecord>, nLayers>& layerROFs)
+{
+  if (mTimingTablesInitialised) {
+    return;
+  }
+
+  o2::InteractionRecord anchor{0, 0};
+  bool haveAnchor = false;
+  for (const auto& span : layerROFs) {
+    if (span.empty()) {
+      continue;
+    }
+    const auto& first = span.front().getBCData();
+    if (!haveAnchor || first.toLong() < anchor.toLong()) {
+      anchor = first;
+      haveAnchor = true;
+    }
+  }
+  mTFAnchorIR = anchor;
+  const int64_t anchorBC = anchor.toLong();
+
+  std::array<o2::its::LayerTiming, nLayers> timings{};
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    const auto& span = layerROFs[iLayer];
+    auto& t = timings[iLayer];
+    t.mNROFsTF = static_cast<o2::its::LayerTiming::BCType>(span.size());
+
+    if (span.size() >= 2) {
+      const int64_t delta = span[1].getBCData().toLong() - span[0].getBCData().toLong();
+      if (delta > 0) {
+        t.mROFLength = static_cast<o2::its::LayerTiming::BCType>(delta);
+      } else {
+        LOGP(warning, "TRK layer {}: non-positive BC delta between rofs[0] and rofs[1] ({}); falling back to mROFLength=1", iLayer, delta);
+        t.mROFLength = 1;
+      }
+    } else {
+      if (span.size() == 1) {
+        LOGP(warning, "TRK layer {}: only one input ROF — cannot derive mROFLength; falling back to mROFLength=1", iLayer);
+      }
+      t.mROFLength = 1;
+    }
+
+    if (!span.empty()) {
+      const int64_t bias = span.front().getBCData().toLong() - anchorBC;
+      t.mROFBias = static_cast<o2::its::LayerTiming::BCType>(bias);
+    }
+    t.mROFDelay = 0;
+    t.mROFAddTimeErr = 0;
+  }
+
+  initTimingTables(timings);
+}
+
+template <int nLayers, class Base>
+int TimeFrameMixin<nLayers, Base>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config)
+{
+  constexpr std::array<int, 2> startLayer{0, 3};
+  const Long64_t nEvents = hitsTree->GetEntries();
+  this->setIsStaggered(true);
+
+  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L) | o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+
+  std::vector<o2::trk::Hit>* trkHit = nullptr;
+  hitsTree->SetBranchAddress("TRKHit", &trkHit);
+
+  const int inROFpileup{config.contains("inROFpileup") ? config["inROFpileup"].get<int>() : 1};
+
+  const int nRofs = (nEvents + inROFpileup - 1) / inROFpileup;
+  std::array<o2::its::LayerTiming, nLayers> timings{};
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    timings[iLayer].mNROFsTF = static_cast<o2::its::LayerTiming::BCType>(nRofs);
+    timings[iLayer].mROFLength = 1;
+  }
+  this->initTimingTables(timings);
+  const auto& timing = this->getROFOverlapTableView().getLayer(0);
+  if (timing.mNROFsTF != static_cast<o2::its::LayerTiming::BCType>(nRofs)) {
+    LOGP(fatal, "TRK: inconsistent number of ROFs across TFs: timing has {}, hit-tree path produced {}", timing.mNROFsTF, nRofs);
+  }
+
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    this->mMinR[iLayer] = std::numeric_limits<float>::max();
+    this->mMaxR[iLayer] = std::numeric_limits<float>::lowest();
+    this->mROFramesClusters[iLayer].clear();
+    this->mROFramesClusters[iLayer].resize(nRofs + 1, 0);
+    this->mUnsortedClusters[iLayer].clear();
+    this->mTrackingFrameInfo[iLayer].clear();
+    this->mClusterExternalIndices[iLayer].clear();
+    this->mClusterSize[iLayer].clear();
+  }
+
+  std::array<int, nLayers> clusterCountPerLayer{};
+  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
+    hitsTree->GetEntry(iEvent);
+    for (const auto& hit : *trkHit) {
+      if (gman->getDisk(hit.GetDetectorID()) != -1) {
+        continue;
+      }
+      int subDetID = gman->getSubDetID(hit.GetDetectorID());
+      const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
+      if (layer >= nLayers) {
+        continue;
+      }
+      ++clusterCountPerLayer[layer];
+    }
+  }
+
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    this->mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    this->mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    this->mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
+    this->mClusterSize[iLayer].reserve(clusterCountPerLayer[iLayer]);
+  }
+
+  std::array<float, 11> resolution{0.001, 0.001, 0.001, 0.001, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004};
+  if (config["geometry"]["pitch"].size() == nLayers) {
+    for (int iLayer{0}; iLayer < config["geometry"]["pitch"].size(); ++iLayer) {
+      LOGP(info, "Setting resolution for layer {} from config", iLayer);
+      LOGP(info, "Layer {} pitch {} cm", iLayer, config["geometry"]["pitch"][iLayer].get<float>());
+      resolution[iLayer] = config["geometry"]["pitch"][iLayer].get<float>() / std::sqrt(12.f);
+    }
+  }
+  LOGP(info, "Number of active parts in VD: {}", gman->getNumberOfActivePartsVD());
+
+  std::array<int, nLayers> hitCounterPerLayer{};
+  std::array<dataformats::MCTruthContainer<MCCompLabel>*, nLayers> labels{};
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    labels[iLayer] = new dataformats::MCTruthContainer<MCCompLabel>();
+    this->mClusterLabels[iLayer] = labels[iLayer];
+  }
+
+  int iRof{0};
+  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
+    hitsTree->GetEntry(iEvent);
+
+    for (auto& hit : *trkHit) {
+      if (gman->getDisk(hit.GetDetectorID()) != -1) {
+        continue;
+      }
+      int subDetID = gman->getSubDetID(hit.GetDetectorID());
+      const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
+
+      float alpha{0.f};
+      o2::math_utils::Point3D<float> gloXYZ;
+      o2::math_utils::Point3D<float> trkXYZ;
+      float r{0.f};
+      if (layer >= nLayers) {
+        continue;
+      }
+      if (layer >= 3) {
+        int chipID = hit.GetDetectorID();
+        alpha = gman->getSensorRefAlphaMLOT(chipID);
+        const o2::math_utils::Transform3D& l2g = gman->getMatrixL2G(chipID);
+        auto locXYZ = l2g ^ (hit.GetPos());
+        locXYZ.SetX(locXYZ.X() + gRandom->Gaus(0.0, resolution[layer]));
+        locXYZ.SetZ(locXYZ.Z() + gRandom->Gaus(0.0, resolution[layer]));
+        gloXYZ = gman->getMatrixL2G(chipID) * locXYZ;
+        trkXYZ = gman->getMatrixT2L(chipID - gman->getNumberOfActivePartsVD()) ^ locXYZ;
+        r = std::hypot(gloXYZ.X(), gloXYZ.Y());
+      } else {
+        const auto& hitPos = hit.GetPos();
+        r = std::hypot(hitPos.X(), hitPos.Y());
+        alpha = std::atan2(hitPos.Y(), hitPos.X()) + gRandom->Gaus(0.0, resolution[layer] / r);
+        o2::math_utils::bringTo02Pi(alpha);
+        gloXYZ.SetX(r * std::cos(alpha));
+        gloXYZ.SetY(r * std::sin(alpha));
+        gloXYZ.SetZ(hitPos.Z() + gRandom->Gaus(0.0, resolution[layer]));
+        trkXYZ.SetX(r);
+        trkXYZ.SetY(0.f);
+        trkXYZ.SetZ(gloXYZ.Z());
+      }
+      this->mMinR[layer] = std::min(this->mMinR[layer], r);
+      this->mMaxR[layer] = std::max(this->mMaxR[layer], r);
+      this->addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), alpha,
+                                        std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
+                                        std::array<float, 3>{resolution[layer] * resolution[layer], 0., resolution[layer] * resolution[layer]});
+      this->addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), this->mUnsortedClusters[layer].size());
+      const int layerHitCounter = hitCounterPerLayer[layer]++;
+      this->addClusterExternalIndexToLayer(layer, layerHitCounter);
+      this->mClusterSize[layer].push_back(1);
+      MCCompLabel label{hit.GetTrackID(), static_cast<int>(iEvent), 0};
+      labels[layer]->addElement(layerHitCounter, label);
+    }
+    trkHit->clear();
+
+    if ((iEvent + 1) % inROFpileup == 0 || iEvent == nEvents - 1) {
+      iRof++;
+      for (unsigned int iLayer{0}; iLayer < this->mUnsortedClusters.size(); ++iLayer) {
+        this->mROFramesClusters[iLayer][iRof] = this->mUnsortedClusters[iLayer].size();
+      }
+    }
+  }
+  return nRofs;
+}
+
+template <int nLayers, class Base>
+int TimeFrameMixin<nLayers, Base>::loadROFrameData(const std::array<gsl::span<const o2::trk::ROFRecord>, nLayers>& layerROFs,
+                                                   const std::array<gsl::span<const o2::trk::Cluster>, nLayers>& layerClusters,
+                                                   const std::array<gsl::span<const unsigned char>, nLayers>& layerPatterns,
+                                                   const std::array<const dataformats::MCTruthContainer<MCCompLabel>*, nLayers>* mcLabels,
+                                                   float yPlaneMLOT)
+{
+  constexpr std::array<int, 2> startLayer{0, 3};
+  this->setIsStaggered(true);
+  GeometryTGeo* geom = GeometryTGeo::Instance();
+  geom->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L) | o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
+
+  if (!mTimingTablesInitialised) {
+    LOGP(fatal, "TRK::loadROFrameData: timing tables not initialised — call deriveAndInitTiming() first");
+  }
+  int nRofs{0};
+  for (const auto& rofs : layerROFs) {
+    nRofs = std::max(nRofs, static_cast<int>(rofs.size()));
+  }
+
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    const auto& timing = this->getROFOverlapTableView().getLayer(iLayer);
+    if (timing.mNROFsTF != static_cast<o2::its::LayerTiming::BCType>(layerROFs[iLayer].size())) {
+      LOGP(fatal, "TRK: inconsistent number of ROFs on layer {}: timing has {}, cluster path received {}", iLayer, timing.mNROFsTF, layerROFs[iLayer].size());
+    }
+    this->mMinR[iLayer] = std::numeric_limits<float>::max();
+    this->mMaxR[iLayer] = std::numeric_limits<float>::lowest();
+    this->mROFramesClusters[iLayer].clear();
+    this->mROFramesClusters[iLayer].resize(layerROFs[iLayer].size() + 1, 0);
+    this->mUnsortedClusters[iLayer].clear();
+    this->mTrackingFrameInfo[iLayer].clear();
+    this->mClusterExternalIndices[iLayer].clear();
+    this->mClusterSize[iLayer].clear();
+    this->mUnsortedClusters[iLayer].reserve(layerClusters[iLayer].size());
+    this->mTrackingFrameInfo[iLayer].reserve(layerClusters[iLayer].size());
+    this->mClusterExternalIndices[iLayer].reserve(layerClusters[iLayer].size());
+    this->mClusterSize[iLayer].reserve(layerClusters[iLayer].size());
+  }
+
+  std::array<std::vector<size_t>, nLayers> patternOffsetsPerLayer;
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    auto& offsets = patternOffsetsPerLayer[iLayer];
+    offsets.resize(layerClusters[iLayer].size(), std::numeric_limits<size_t>::max());
+    size_t pattPos = 0;
+    bool validPatterns = true;
+    for (size_t clusterId{0}; clusterId < layerClusters[iLayer].size(); ++clusterId) {
+      if (pattPos + 2 > layerPatterns[iLayer].size()) {
+        validPatterns = false;
+        break;
+      }
+      offsets[clusterId] = pattPos;
+      const uint8_t rowSpan = layerPatterns[iLayer][pattPos];
+      const uint8_t colSpan = layerPatterns[iLayer][pattPos + 1];
+      const size_t nBytes = (size_t(rowSpan) * colSpan + 7) / 8;
+      if (pattPos + 2 + nBytes > layerPatterns[iLayer].size()) {
+        validPatterns = false;
+        break;
+      }
+      pattPos += 2 + nBytes;
+    }
+    if (!validPatterns || pattPos != layerPatterns[iLayer].size()) {
+      LOGP(fatal, "Malformed TRK pattern stream for layer {}: {} bytes for {} clusters",
+           iLayer, layerPatterns[iLayer].size(), layerClusters[iLayer].size());
+    }
+  }
+
+  for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+    for (size_t iRof{0}; iRof < layerROFs[iLayer].size(); ++iRof) {
+      const auto& rof = layerROFs[iLayer][iRof];
+      const int first = rof.getFirstEntry();
+      const int last = first + rof.getNEntries();
+
+      for (int clusterId{first}; clusterId < last; ++clusterId) {
+        if (clusterId < 0 || clusterId >= static_cast<int>(layerClusters[iLayer].size())) {
+          LOGP(warning, "Skipping out-of-range TRK cluster {} on layer {}", clusterId, iLayer);
+          continue;
+        }
+
+        const auto& c = layerClusters[iLayer][clusterId];
+        if (c.subDetID < 0 || c.subDetID > 1 || c.disk != -1) {
+          continue;
+        }
+
+        const int clusterLayer = startLayer[c.subDetID] + c.layer;
+        if (clusterLayer != iLayer) {
+          LOGP(error, "Skipping cluster from layer {} found in TRK layer stream {}", clusterLayer, iLayer);
+          continue;
+        }
+
+        const auto pattOffset = patternOffsetsPerLayer[iLayer][clusterId];
+        const uint8_t* pattForCluster = layerPatterns[iLayer].data() + pattOffset;
+        auto locXYZ = Clusterer::getClusterLocalCoordinates(c, pattForCluster, yPlaneMLOT);
+
+        const auto gloXYZ = geom->getMatrixL2G(c.chipID) * locXYZ;
+
+        float alpha{0.f};
+        o2::math_utils::Point3D<float> trkXYZ;
+        if (c.subDetID == 1) {
+          alpha = geom->getSensorRefAlphaMLOT(c.chipID);
+          trkXYZ = geom->getMatrixT2L(c.chipID - geom->getNumberOfActivePartsVD()) ^ locXYZ;
+        } else {
+          const float r = std::hypot(gloXYZ.X(), gloXYZ.Y());
+          alpha = std::atan2(gloXYZ.Y(), gloXYZ.X());
+          o2::math_utils::bringTo02Pi(alpha);
+          trkXYZ.SetX(r);
+          trkXYZ.SetY(0.f);
+          trkXYZ.SetZ(gloXYZ.Z());
+        }
+
+        const float r = std::hypot(gloXYZ.X(), gloXYZ.Y());
+        this->mMinR[iLayer] = std::min(this->mMinR[iLayer], r);
+        this->mMaxR[iLayer] = std::max(this->mMaxR[iLayer], r);
+
+        const float sigmaY2 = (c.subDetID == 0)
+                                ? 0.25f * SegmentationChip::PitchRowVD * SegmentationChip::PitchRowVD
+                                : 0.25f * SegmentationChip::PitchRowMLOT * SegmentationChip::PitchRowMLOT;
+        const float sigmaZ2 = (c.subDetID == 0)
+                                ? 0.25f * SegmentationChip::PitchColVD * SegmentationChip::PitchColVD
+                                : 0.25f * SegmentationChip::PitchColMLOT * SegmentationChip::PitchColMLOT;
+
+        this->addTrackingFrameInfoToLayer(iLayer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), alpha,
+                                          std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
+                                          std::array<float, 3>{sigmaY2, 0.f, sigmaZ2});
+        this->addClusterToLayer(iLayer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), this->mUnsortedClusters[iLayer].size());
+        this->addClusterExternalIndexToLayer(iLayer, clusterId);
+        this->mClusterSize[iLayer].push_back(std::clamp(static_cast<unsigned int>(c.size), 0u, 255u));
+      }
+
+      this->mROFramesClusters[iLayer][iRof + 1] = this->mUnsortedClusters[iLayer].size();
+    }
+  }
+
+  for (auto i = 0; i < this->mNTrackletsPerCluster.size(); ++i) {
+    this->mNTrackletsPerCluster[i].resize(this->mUnsortedClusters[1].size());
+    this->mNTrackletsPerClusterSum[i].resize(this->mUnsortedClusters[1].size() + 1);
+  }
+
+  if (mcLabels != nullptr) {
+    for (int iLayer{0}; iLayer < nLayers; ++iLayer) {
+      this->mClusterLabels[iLayer] = (*mcLabels)[iLayer];
+    }
+  }
+
+  return nRofs;
+}
+
+template <int nLayers, class Base>
+void TimeFrameMixin<nLayers, Base>::getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup)
+{
+  auto mcheader = new o2::dataformats::MCEventHeader;
+  mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
+
+  this->mPrimaryVertices.clear();
+  this->mPrimaryVerticesLabels.clear();
+
+  const auto& clockLayer = this->getROFOverlapTableView().getClockLayer();
+  const auto rofLength = clockLayer.mROFLength;
+
+  int iRof{0};
+  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
+    mcHeaderTree->GetEntry(iEvent);
+    o2::its::Vertex vertex;
+    vertex.setTimeStamp(o2::its::TimeEstBC{
+      clockLayer.getROFStartInBC(iRof),
+      static_cast<o2::its::TimeStampErrorType>(rofLength)});
+    vertex.setXYZ(mcheader->GetX(), mcheader->GetY(), mcheader->GetZ());
+    vertex.setNContributors(30);
+    vertex.setChi2(0.f);
+    LOGP(debug, "ROF {}: Added primary vertex at ({}, {}, {})", iRof, mcheader->GetX(), mcheader->GetY(), mcheader->GetZ());
+    this->addPrimaryVertex(vertex);
+    this->addPrimaryVertexLabel({o2::MCCompLabel{o2::MCCompLabel::maxTrackID(), static_cast<int>(iEvent), 0, false}, 1.f});
+    if ((iEvent + 1) % inROFpileup == 0 || iEvent == nEvents - 1) {
+      iRof++;
+    }
+  }
+  updateHostROFVertexLookupTable();
+}
+
+template <int nLayers, class Base>
+void TimeFrameMixin<nLayers, Base>::addTruthSeedingVertices()
+{
+  LOGP(info, "TRK: using truth seeds as vertices from DigitizationContext");
+  this->mPrimaryVertices.clear();
+  this->mPrimaryVerticesLabels.clear();
+
+  const auto dc = o2::steer::DigitizationContext::loadFromFile("collisioncontext.root");
+  const auto irs = dc->getEventRecords();
+  o2::steer::MCKinematicsReader mcReader(dc);
+
+  const int64_t anchorBC = mTFAnchorIR.toLong();
+  const auto& clockLayer = this->getROFOverlapTableView().getClockLayer();
+  const auto rofLength = clockLayer.mROFLength;
+
+  using Vertex = o2::its::Vertex;
+  struct VertEntry {
+    int64_t bc;
+    Vertex vertex;
+    int event;
+  };
+  std::vector<VertEntry> entries;
+
+  const int iSrc = 0;
+  auto eveId2colId = dc->getCollisionIndicesForSource(iSrc);
+  for (int iEve{0}; iEve < mcReader.getNEvents(iSrc); ++iEve) {
+    const auto& ir = irs[eveId2colId[iEve]];
+    if (!ir.isDummy()) {
+      const auto& eve = mcReader.getMCEventHeader(iSrc, iEve);
+      const int64_t evBC = ir.toLong() - anchorBC;
+      if (evBC >= 0) {
+        Vertex vert;
+        vert.setTimeStamp(o2::its::TimeEstBC{
+          static_cast<o2::its::TimeStampType>(evBC),
+          static_cast<o2::its::TimeStampErrorType>(rofLength)});
+        vert.setNContributors(std::max(1L, std::ranges::count_if(
+                                             mcReader.getTracks(iSrc, iEve),
+                                             [](const auto& trk) {
+                                               return trk.isPrimary() && trk.GetPt() > 0.05 && std::abs(trk.GetEta()) < 1.1;
+                                             })));
+        vert.setXYZ((float)eve.GetX(), (float)eve.GetY(), (float)eve.GetZ());
+        vert.setChi2(1);
+        constexpr float cov = 50e-9f;
+        vert.setCov(cov, cov, cov, cov, cov, cov);
+        entries.push_back({evBC, vert, iEve});
+      }
+    }
+    mcReader.releaseTracksForSourceAndEvent(iSrc, iEve);
+  }
+
+  // Sort by BC so the lookup table binary search works correctly
+  std::ranges::sort(entries, {}, &VertEntry::bc);
+
+  for (const auto& e : entries) {
+    this->addPrimaryVertex(e.vertex);
+    o2::MCCompLabel lbl(o2::MCCompLabel::maxTrackID(), e.event, iSrc, false);
+    this->addPrimaryVertexLabel({lbl, 1.f});
+  }
+  updateHostROFVertexLookupTable();
+  LOGP(info, "TRK truth seeding: added {} vertices", entries.size());
+}
+
+} // namespace o2::trk
+
+#endif // ALICEO2_ALICE3GLOBALRECONSTRUCTION_TIMEFRAMEMIXIN_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TrackerACTS.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TrackerACTS.h
similarity index 96%
rename from Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TrackerACTS.h
rename to Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TrackerACTS.h
index 2910abf480961..ee69b32a23895 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TrackerACTS.h
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/include/ALICE3GlobalReconstruction/TrackerACTS.h
@@ -16,8 +16,8 @@
 /// \since 2026-04-01
 ///
 
-#ifndef ALICE3_INCLUDE_TRACKERACTS_H_
-#define ALICE3_INCLUDE_TRACKERACTS_H_
+#ifndef ALICE3_GLOBALRECONSTRUCTION_INCLUDE_TRACKERACTS_H_
+#define ALICE3_GLOBALRECONSTRUCTION_INCLUDE_TRACKERACTS_H_
 
 #include "Acts/Definitions/Units.hpp"
 #include "Framework/Logger.h"
@@ -186,4 +186,4 @@ float TrackerACTS<nLayers>::evaluateTask(Func&& task, std::string_view taskName)
 
 } // namespace o2::trk
 
-#endif /* ALICE3_INCLUDE_TRACKERACTS_H_ */
+#endif /* ALICE3_GLOBALRECONSTRUCTION_INCLUDE_TRACKERACTS_H_ */
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cxx
new file mode 100644
index 0000000000000..df2a2c30b037a
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cxx
@@ -0,0 +1,210 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#if defined(TRK_HAS_CUDA_TRACKING)
+#include <cuda_runtime.h>
+#elif defined(TRK_HAS_HIP_TRACKING)
+#include <hip/hip_runtime.h>
+#endif
+
+#include "ALICE3GlobalReconstruction/GPUExternalAllocator.h"
+
+#include <algorithm>
+#include <stdexcept>
+#include <string>
+
+namespace
+{
+#if defined(TRK_HAS_CUDA_TRACKING)
+void checkGpuError(cudaError_t error, const char* call)
+{
+  if (error != cudaSuccess) {
+    throw std::runtime_error(std::string(call) + ": " + cudaGetErrorString(error));
+  }
+}
+#elif defined(TRK_HAS_HIP_TRACKING)
+void checkGpuError(hipError_t error, const char* call)
+{
+  if (error != hipSuccess) {
+    throw std::runtime_error(std::string(call) + ": " + hipGetErrorString(error));
+  }
+}
+#endif
+} // namespace
+
+namespace o2::trk
+{
+
+GPUExternalAllocator::~GPUExternalAllocator()
+{
+  releaseAll();
+}
+
+void* GPUExternalAllocator::allocate(size_t size)
+{
+  const auto type = static_cast<MemoryType>(getType());
+  const bool useHost = (type & static_cast<MemoryType>(o2::gpu::GPUMemoryResource::MEMORY_HOST)) != 0;
+  const bool useStack = (type & static_cast<MemoryType>(o2::gpu::GPUMemoryResource::MEMORY_STACK)) != 0;
+
+  void* ptr = useHost ? allocateHost(size) : allocateDevice(size);
+
+  std::lock_guard<std::mutex> guard(mMutex);
+  const uint64_t tag = (useStack && !mTagStack.empty()) ? mTagStack.back() : 0;
+  mAllocations.emplace(ptr, AllocationMeta{useHost ? AllocationSpace::Host : AllocationSpace::Device, tag, useStack});
+  if (useStack) {
+    mTaggedAllocations[tag].push_back(ptr);
+  }
+
+  return ptr;
+}
+
+void GPUExternalAllocator::deallocate(char* ptr, size_t)
+{
+  if (!ptr) {
+    return;
+  }
+
+  AllocationMeta meta;
+  {
+    std::lock_guard<std::mutex> guard(mMutex);
+    const auto found = mAllocations.find(ptr);
+    if (found == mAllocations.end()) {
+      return;
+    }
+    meta = found->second;
+    mAllocations.erase(found);
+    if (meta.stacked) {
+      removeFromTagLocked(meta.tag, ptr);
+    }
+  }
+
+  freeAllocation(ptr, meta.space);
+}
+
+void GPUExternalAllocator::pushTagOnStack(uint64_t tag)
+{
+  std::lock_guard<std::mutex> guard(mMutex);
+  mTagStack.push_back(tag);
+}
+
+void GPUExternalAllocator::popTagOffStack(uint64_t tag)
+{
+  std::vector<std::pair<void*, AllocationSpace>> toFree;
+  {
+    std::lock_guard<std::mutex> guard(mMutex);
+    if (mTagStack.empty() || mTagStack.back() != tag) {
+      throw std::runtime_error("GPUExternalAllocator tag stack mismatch");
+    }
+
+    const auto tagged = mTaggedAllocations.find(tag);
+    if (tagged != mTaggedAllocations.end()) {
+      toFree.reserve(tagged->second.size());
+      for (void* ptr : tagged->second) {
+        const auto found = mAllocations.find(ptr);
+        if (found != mAllocations.end()) {
+          toFree.emplace_back(ptr, found->second.space);
+          mAllocations.erase(found);
+        }
+      }
+      mTaggedAllocations.erase(tagged);
+    }
+
+    mTagStack.pop_back();
+  }
+
+  for (const auto& [ptr, space] : toFree) {
+    freeAllocation(ptr, space);
+  }
+}
+
+void GPUExternalAllocator::releaseAll()
+{
+  std::vector<std::pair<void*, AllocationSpace>> toFree;
+  {
+    std::lock_guard<std::mutex> guard(mMutex);
+    toFree.reserve(mAllocations.size());
+    for (const auto& [ptr, meta] : mAllocations) {
+      toFree.emplace_back(ptr, meta.space);
+    }
+    mAllocations.clear();
+    mTaggedAllocations.clear();
+    mTagStack.clear();
+  }
+
+  for (const auto& [ptr, space] : toFree) {
+    freeAllocation(ptr, space);
+  }
+}
+
+void* GPUExternalAllocator::allocateHost(size_t size)
+{
+  void* ptr = nullptr;
+#if defined(TRK_HAS_CUDA_TRACKING)
+  checkGpuError(cudaHostAlloc(&ptr, size, cudaHostAllocPortable), "cudaHostAlloc");
+#elif defined(TRK_HAS_HIP_TRACKING)
+  checkGpuError(hipHostMalloc(&ptr, size, hipHostMallocPortable), "hipHostMalloc");
+#else
+  throw std::runtime_error("GPUExternalAllocator built without a GPU backend");
+#endif
+  return ptr;
+}
+
+void* GPUExternalAllocator::allocateDevice(size_t size)
+{
+  void* ptr = nullptr;
+#if defined(TRK_HAS_CUDA_TRACKING)
+  checkGpuError(cudaMalloc(&ptr, size), "cudaMalloc");
+#elif defined(TRK_HAS_HIP_TRACKING)
+  checkGpuError(hipMalloc(&ptr, size), "hipMalloc");
+#else
+  throw std::runtime_error("GPUExternalAllocator built without a GPU backend");
+#endif
+  return ptr;
+}
+
+void GPUExternalAllocator::freeAllocation(void* ptr, AllocationSpace space)
+{
+  if (!ptr) {
+    return;
+  }
+
+#if defined(TRK_HAS_CUDA_TRACKING)
+  if (space == AllocationSpace::Host) {
+    checkGpuError(cudaFreeHost(ptr), "cudaFreeHost");
+  } else {
+    checkGpuError(cudaFree(ptr), "cudaFree");
+  }
+#elif defined(TRK_HAS_HIP_TRACKING)
+  if (space == AllocationSpace::Host) {
+    checkGpuError(hipHostFree(ptr), "hipHostFree");
+  } else {
+    checkGpuError(hipFree(ptr), "hipFree");
+  }
+#else
+  (void)space;
+#endif
+}
+
+void GPUExternalAllocator::removeFromTagLocked(uint64_t tag, void* ptr)
+{
+  const auto tagged = mTaggedAllocations.find(tag);
+  if (tagged == mTaggedAllocations.end()) {
+    return;
+  }
+
+  auto& entries = tagged->second;
+  entries.erase(std::remove(entries.begin(), entries.end(), ptr), entries.end());
+  if (entries.empty()) {
+    mTaggedAllocations.erase(tagged);
+  }
+}
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TimeFrame.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TimeFrame.cxx
new file mode 100644
index 0000000000000..1f7997b2e3968
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TimeFrame.cxx
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file TimeFrame.cxx
+/// \brief Explicit instantiation of TimeFrameMixin and TimeFrame for the
+///        ITS CPU base. Shared method bodies live in TimeFrameMixin.h.
+///
+
+#include "ALICE3GlobalReconstruction/TimeFrame.h"
+
+namespace o2::trk
+{
+
+template class TimeFrameMixin<11, o2::its::TimeFrame<11>>;
+template class TimeFrame<11>;
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TimeFrameGPU.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TimeFrameGPU.cxx
new file mode 100644
index 0000000000000..714ead765b005
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TimeFrameGPU.cxx
@@ -0,0 +1,25 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+///
+/// \file TimeFrameGPU.cxx
+/// \brief Explicit instantiation of TimeFrameMixin and TimeFrameGPU for the
+///        ITS GPU base. Shared method bodies live in TimeFrameMixin.h.
+///
+
+#include "ALICE3GlobalReconstruction/TimeFrameGPU.h"
+
+namespace o2::trk
+{
+
+template class TimeFrameMixin<11, o2::its::gpu::TimeFrameGPU<11>>;
+template class TimeFrameGPU<11>;
+
+} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TrackerACTS.cxx
similarity index 98%
rename from Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx
rename to Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TrackerACTS.cxx
index 732a0acc14b66..e870ee934816f 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TrackerACTS.cxx
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/TrackerACTS.cxx
@@ -16,7 +16,7 @@
 /// \since 2026-04-01
 ///
 
-#include "TRKReconstruction/TrackerACTS.h"
+#include "ALICE3GlobalReconstruction/TrackerACTS.h"
 
 #include <Acts/EventData/Seed.hpp>
 #include <Acts/EventData/SpacePointContainer.hpp>
@@ -261,10 +261,10 @@ void TrackerACTS<nLayers>::clustersToTracks()
 
   double totalTime = 0.;
   LOG(info) << "==== TRK ACTS Tracking ====";
-  LOG(info) << "Processing " << mTimeFrame->getNrof(0) << " ROFs with B = " << mBz << " T";
+  LOG(info) << "Processing " << mTimeFrame->getNrof() << " ROFs with B = " << mBz << " T";
 
   // Process each ROF
-  for (int iROF = 0; iROF < mTimeFrame->getNrof(0); ++iROF) {
+  for (int iROF = 0; iROF < mTimeFrame->getNrof(); ++iROF) {
     LOG(info) << "Processing ROF " << iROF;
     // Build space points
     mCurState = SpacePointBuilding;
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/CMakeLists.txt b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/CMakeLists.txt
new file mode 100644
index 0000000000000..be6add9c03483
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/CMakeLists.txt
@@ -0,0 +1,35 @@
+# Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+
+o2_add_library(ALICE3GlobalReconstructionWorkflow
+               TARGETVARNAME targetName
+               SOURCES src/TrackerSpec.cxx
+                       src/TrackWriterSpec.cxx
+                       src/RecoWorkflow.cxx
+               PUBLIC_LINK_LIBRARIES O2::Framework
+                                     O2::GPUWorkflow
+                                     O2::SimConfig
+                                     O2::DataFormatsITSMFT
+                                     O2::DataFormatsTRK
+                                     O2::SimulationDataFormat
+                                     O2::DPLUtils
+                                     O2::TRKBase
+                                     O2::TRKSimulation
+                                     O2::ALICE3GlobalReconstruction
+                                     nlohmann_json::nlohmann_json)
+
+o2_add_executable(reco-workflow
+                  SOURCES src/alice3-global-reconstruction-workflow.cxx
+                  COMPONENT_NAME alice3-global-reconstruction
+                  PUBLIC_LINK_LIBRARIES O2::ALICE3GlobalReconstructionWorkflow
+                                        O2::TRKSimulation
+                                        O2::ALICE3GlobalReconstruction
+                                        O2::ITStracking)
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/README.md b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/README.md
new file mode 100644
index 0000000000000..f22e95d6971db
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/README.md
@@ -0,0 +1,133 @@
+# ALICE 3 Global Reconstruction Workflow
+
+This document describes how to run the ALICE 3 global reconstruction workflow and provides examples of configuration files.
+
+## Overview
+
+The global reconstruction workflow performs track reconstruction from simulated hits or TRK clusters, producing reconstructed tracks with MC truth labels. The workflow currently supports tracking using the Cellular Automaton (CA) algorithm. The output is stored to a ROOT file for offline analysis (example of QA macro provided in `TRK/macros/test/CheckTracksCA.C`).
+
+## Quick Start
+
+### Basic Command
+
+```bash
+o2-alice3-global-reconstruction-reco-workflow --tracking-from-hits-config config_tracker.json -b
+```
+
+### Command Line Options
+
+- `--tracking-from-hits-config <file>`: Path to tracking-from-hits configuration JSON file
+- `--tracking-from-clusters-config <file>`: Path to tracking-from-clusters configuration JSON file
+- `--gpu-device <id>`: Tracking device type (`1` CPU, `2` CUDA, `3` HIP)
+- `-b`: Batch mode (no GUI)
+- `--disable-root-output`: Skip writing tracks to ROOT file
+- `--help`: Show all available options
+
+## Configuration File
+
+The tracking configuration is provided via a JSON file that specifies:
+1. Input file paths
+2. Geometry parameters (magnetic field, detector pitch)
+3. Tracking algorithm parameters (can specify multiple iterations)
+
+### Example Configuration (`config_tracker.json`)
+
+```json
+{
+  "inputfiles": {
+    "hits": "o2sim_HitsTRK.root",
+    "geometry": "o2sim_geometry.root",
+    "mcHeader": "o2sim_MCHeader.root",
+    "kinematics": "o2sim_Kine.root"
+  },
+  "geometry": {
+    "bz": 5.0,
+    "pitch": [0.001, 0.001, 0.001, 0.001, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004]
+  },
+  "trackingparams": [{
+    "NLayers": 11,
+    "DeltaROF": 0,
+    "LayerZ": [25.1, 25.1, 25.1, 64.2, 64.2, 64.2, 64.2, 64.2, 128.5, 128.5, 128.5],
+    "LayerRadii": [0.5, 1.2, 2.5, 7.05, 9.05, 12.05, 20.05, 30.05, 45.05, 60.5, 80.05],
+    "LayerxX0": [0.001, 0.001, 0.001, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+    "LayerResolution": [0.0003, 0.0003, 0.0003, 0.0003, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012],
+    "SystErrorY2": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+    "SystErrorZ2": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+    "AddTimeError": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    "ZBins": 256,
+    "PhiBins": 128,
+    "nROFsPerIterations": -1,
+    "UseDiamond": false,
+    "Diamond": [0.0, 0.0, 0.0],
+    "AllowSharingFirstCluster": false,
+    "ClusterSharing": 0,
+    "MinTrackLength": 7,
+    "NSigmaCut": 10,
+    "PVres": 0.01,
+    "TrackletMinPt": 0.1,
+    "TrackletsPerClusterLimit": 2.0,
+    "CellDeltaTanLambdaSigma": 0.007,
+    "CellsPerClusterLimit": 2.0,
+    "MaxChi2ClusterAttachment": 60.0,
+    "MaxChi2NDF": 30.0,
+    "ReseedIfShorter": 6,
+    "MinPt": [0.0, 0.0, 0.0, 0.0, 0.0],
+    "StartLayerMask": 4095,
+    "RepeatRefitOut": false,
+    "ShiftRefToCluster": true,
+    "FindShortTracks": false,
+    "PerPrimaryVertexProcessing": false,
+    "SaveTimeBenchmarks": false,
+    "DoUPCIteration": false,
+    "FataliseUponFailure": true,
+    "UseTrackFollower": true,
+    "UseTrackFollowerTop": false,
+    "UseTrackFollowerBot": false,
+    "UseTrackFollowerMix": true,
+    "TrackFollowerNSigmaCutZ": 1.0,
+    "TrackFollowerNSigmaCutPhi": 1.0,
+    "createArtefactLabels": false,
+    "PrintMemory": false,
+    "DropTFUponFailure": false
+  }]
+}
+```
+Note that the `trackingparams` field can contain multiple sets of parameters for different iterations of the tracking algorithm. The example above shows a single iteration with 11 layers and it is **not** optimized.
+
+## Complete Workflow Example
+
+### 1. Run Simulation
+
+First, generate simulation data:
+
+```bash
+o2-sim-serial-run5 -n 200 -g pythia8hi -m TRK --configKeyValues "Diamond.width[0]=0.01;Diamond.width[1]=0.01;Diamond.width[2]=5;TRKBase.layoutML=kTurboStaves;TRKBase.layoutOT=kStaggered;"
+```
+
+This produces, among other files:
+- `o2sim_HitsTRK.root`
+- `o2sim_geometry.root`
+- `o2sim_MCHeader.root`
+- `o2sim_Kine.root`
+That will be used by the reconstruction as currently we do not have clusters.
+
+### 2. Run Reconstruction
+
+Execute the tracking workflow:
+
+```bash
+o2-alice3-global-reconstruction-reco-workflow --tracking-from-hits-config config_tracker.json -b
+```
+
+This produces:
+- `o2trac_trk.root`: Reconstructed tracks with MC labels
+
+### 3. Run Quality Assurance
+
+Analyze the tracking performance:
+
+```bash
+root -l
+.L CheckTracksCA.C+
+CheckTracksCA("o2trac_trk.root", "o2sim_Kine.root", "o2sim_HitsTRK.root", "trk_qa_output.root")
+```
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/RecoWorkflow.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/RecoWorkflow.h
new file mode 100644
index 0000000000000..98a5176d5db44
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/RecoWorkflow.h
@@ -0,0 +1,30 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_ALICE3_GLOBALRECONSTRUCTION_RECOWORKFLOW_H
+#define O2_ALICE3_GLOBALRECONSTRUCTION_RECOWORKFLOW_H
+
+#include "Framework/WorkflowSpec.h"
+#include "GPUDataTypesConfig.h"
+#include <string>
+
+namespace o2::trk::global_reco_workflow
+{
+
+o2::framework::WorkflowSpec getWorkflow(bool useMC,
+                                        const std::string& hitRecoConfig,
+                                        const std::string& clusterRecoConfig,
+                                        bool disableRootOutput = false,
+                                        o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
+
+} // namespace o2::trk::global_reco_workflow
+
+#endif
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackWriterSpec.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackWriterSpec.h
similarity index 100%
rename from Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackWriterSpec.h
rename to Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackWriterSpec.h
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpec.h
similarity index 84%
rename from Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
rename to Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpec.h
index 304b32041c2dc..006bb4cbf5260 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/TrackerSpec.h
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpec.h
@@ -22,6 +22,7 @@
 #include <oneapi/tbb/task_arena.h>
 
 #include "ITStracking/BoundedAllocator.h"
+#include "ITStracking/ExternalAllocator.h"
 #include "ITStracking/TrackingInterface.h"
 #include "GPUDataTypesConfig.h"
 
@@ -39,6 +40,7 @@ class TrackerDPL : public framework::Task
   TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
              bool isMC,
              const std::string& hitRecoConfig,
+             const std::string& clusterRecoConfig,
              gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
   ~TrackerDPL() override = default;
   void init(framework::InitContext& ic) final;
@@ -54,16 +56,20 @@ class TrackerDPL : public framework::Task
   //   std::unique_ptr<o2::gpu::GPUChainITS> mChainITS = nullptr;
   //   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
   //   ITSTrackingInterface mITSTrackingInterface;
+  bool mIsMC{true};
+  gpu::gpudatatypes::DeviceType mDeviceType{gpu::gpudatatypes::DeviceType::CPU};
   std::shared_ptr<its::BoundedMemoryResource> mMemoryPool;
+  std::shared_ptr<its::ExternalAllocator> mGPUAllocator;
   std::shared_ptr<tbb::task_arena> mTaskArena;
   nlohmann::json mHitRecoConfig;
+  nlohmann::json mClusterRecoConfig;
   TStopwatch mTimer;
 #ifdef O2_WITH_ACTS
   bool mUseACTS = false;
 #endif
 };
 
-framework::DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
+framework::DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, const std::string& clusterRecoConfig, gpu::gpudatatypes::DeviceType dType = gpu::gpudatatypes::DeviceType::CPU);
 
 } // namespace o2::trk
 #endif /* O2_TRK_TRACKERDPL */
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/RecoWorkflow.cxx
new file mode 100644
index 0000000000000..024bd3b4425f8
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/RecoWorkflow.cxx
@@ -0,0 +1,40 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ALICE3GlobalReconstructionWorkflow/RecoWorkflow.h"
+#include "ALICE3GlobalReconstructionWorkflow/TrackerSpec.h"
+#include "ALICE3GlobalReconstructionWorkflow/TrackWriterSpec.h"
+#include "Framework/Logger.h"
+
+namespace o2::trk::global_reco_workflow
+{
+
+framework::WorkflowSpec getWorkflow(bool useMC,
+                                    const std::string& hitRecoConfig,
+                                    const std::string& clusterRecoConfig,
+                                    bool disableRootOutput,
+                                    o2::gpu::gpudatatypes::DeviceType dtype)
+{
+  framework::WorkflowSpec specs;
+
+  if (!hitRecoConfig.empty() || !clusterRecoConfig.empty()) {
+    LOG_IF(info, !hitRecoConfig.empty()) << "Using hit reco config from file " << hitRecoConfig;
+    LOG_IF(info, !clusterRecoConfig.empty()) << "Using cluster reco config from file " << clusterRecoConfig;
+    specs.emplace_back(o2::trk::getTrackerSpec(useMC, hitRecoConfig, clusterRecoConfig, dtype));
+    if (!disableRootOutput) {
+      specs.emplace_back(o2::trk::getTrackWriterSpec(useMC));
+    }
+  }
+
+  return specs;
+}
+
+} // namespace o2::trk::global_reco_workflow
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackWriterSpec.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackWriterSpec.cxx
similarity index 97%
rename from Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackWriterSpec.cxx
rename to Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackWriterSpec.cxx
index 1606c32a0ea78..9827c2fc2469d 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackWriterSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackWriterSpec.cxx
@@ -13,7 +13,7 @@
 
 #include <vector>
 
-#include "TRKWorkflow/TrackWriterSpec.h"
+#include "ALICE3GlobalReconstructionWorkflow/TrackWriterSpec.h"
 #include "DPLUtils/MakeRootTreeWriterSpec.h"
 #include "DataFormatsITS/TrackITS.h"
 #include "SimulationDataFormat/MCCompLabel.h"
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
new file mode 100644
index 0000000000000..9fb2899ab3ef5
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
@@ -0,0 +1,549 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <vector>
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <format>
+#include <fstream>
+#include <numeric>
+
+#include "CommonDataFormat/IRFrame.h"
+#include "DataFormatsTRK/Cluster.h"
+#include "DataFormatsTRK/ROFRecord.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "ITStracking/TimeFrame.h"
+#include "ITStracking/Configuration.h"
+#include "Field/MagneticField.h"
+#include "Field/MagFieldParam.h"
+#include "Framework/ControlService.h"
+#include "Framework/ConfigParamRegistry.h"
+#include "Framework/CCDBParamSpec.h"
+#include "ITStracking/TrackingConfigParam.h"
+#include "SimulationDataFormat/MCEventHeader.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/SegmentationChip.h"
+#include "TRKSimulation/Hit.h"
+#include "ALICE3GlobalReconstruction/TimeFrame.h"
+#ifdef TRK_HAS_GPU_TRACKING
+#include "ALICE3GlobalReconstruction/TimeFrameGPU.h"
+#include "ALICE3GlobalReconstruction/GPUExternalAllocator.h"
+#include "ITStrackingGPU/TrackerTraitsGPU.h"
+#endif
+#include "ALICE3GlobalReconstructionWorkflow/TrackerSpec.h"
+#include <TGeoGlobalMagField.h>
+
+#ifdef O2_WITH_ACTS
+#include "ALICE3GlobalReconstruction/TrackerACTS.h"
+#endif
+
+#include <TFile.h>
+#include <TTree.h>
+
+namespace o2
+{
+using namespace framework;
+namespace trk
+{
+using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
+
+TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
+                       bool isMC,
+                       const std::string& hitRecoConfigFileName,
+                       const std::string& clusterRecoConfigFileName,
+                       o2::gpu::gpudatatypes::DeviceType dType)
+{
+  if (!hitRecoConfigFileName.empty()) {
+    std::ifstream configFile(hitRecoConfigFileName);
+    mHitRecoConfig = nlohmann::json::parse(configFile);
+  }
+  if (!clusterRecoConfigFileName.empty()) {
+    std::ifstream configFile(clusterRecoConfigFileName);
+    mClusterRecoConfig = nlohmann::json::parse(configFile);
+  }
+  mIsMC = isMC;
+  mDeviceType = dType;
+}
+
+void TrackerDPL::init(InitContext& ic)
+{
+#ifdef O2_WITH_ACTS
+  mUseACTS = ic.options().get<bool>("useACTS");
+#endif
+}
+
+void TrackerDPL::stop()
+{
+  LOGF(info, "CPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+}
+
+std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromConfig()
+{
+  std::vector<o2::its::TrackingParameters> trackingParams;
+  auto loadTrackingParamsFromJson = [](std::vector<o2::its::TrackingParameters>& trackingParams, const nlohmann::json& paramConfigJson) {
+    for (const auto& paramConfig : paramConfigJson) {
+      o2::its::TrackingParameters params;
+
+      if (paramConfig.contains("NLayers")) {
+        params.NLayers = paramConfig["NLayers"].get<int>();
+      }
+      if (paramConfig.contains("ZBins")) {
+        params.ZBins = paramConfig["ZBins"].get<int>();
+      }
+      if (paramConfig.contains("PhiBins")) {
+        params.PhiBins = paramConfig["PhiBins"].get<int>();
+      }
+      if (paramConfig.contains("ClusterSharing")) {
+        params.ClusterSharing = paramConfig["ClusterSharing"].get<int>();
+      }
+      if (paramConfig.contains("MinTrackLength")) {
+        params.MinTrackLength = paramConfig["MinTrackLength"].get<int>();
+      }
+      if (paramConfig.contains("ReseedIfShorter")) {
+        params.ReseedIfShorter = paramConfig["ReseedIfShorter"].get<int>();
+      }
+      if (paramConfig.contains("StartLayerMask")) {
+        params.StartLayerMask = paramConfig["StartLayerMask"].get<uint16_t>();
+      }
+
+      if (paramConfig.contains("NSigmaCut")) {
+        params.NSigmaCut = paramConfig["NSigmaCut"].get<float>();
+      }
+      if (paramConfig.contains("PVres")) {
+        params.PVres = paramConfig["PVres"].get<float>();
+      }
+      if (paramConfig.contains("TrackletMinPt")) {
+        params.TrackletMinPt = paramConfig["TrackletMinPt"].get<float>();
+      }
+      if (paramConfig.contains("CellDeltaTanLambdaSigma")) {
+        params.CellDeltaTanLambdaSigma = paramConfig["CellDeltaTanLambdaSigma"].get<float>();
+      }
+      if (paramConfig.contains("MaxChi2ClusterAttachment")) {
+        params.MaxChi2ClusterAttachment = paramConfig["MaxChi2ClusterAttachment"].get<float>();
+      }
+      if (paramConfig.contains("MaxChi2NDF")) {
+        params.MaxChi2NDF = paramConfig["MaxChi2NDF"].get<float>();
+      }
+
+      if (paramConfig.contains("UseDiamond")) {
+        params.UseDiamond = paramConfig["UseDiamond"].get<bool>();
+      }
+      if (paramConfig.contains("AllowSharingFirstCluster")) {
+        params.AllowSharingFirstCluster = paramConfig["AllowSharingFirstCluster"].get<bool>();
+      }
+      if (paramConfig.contains("RepeatRefitOut")) {
+        params.RepeatRefitOut = paramConfig["RepeatRefitOut"].get<bool>();
+      }
+      if (paramConfig.contains("ShiftRefToCluster")) {
+        params.ShiftRefToCluster = paramConfig["ShiftRefToCluster"].get<bool>();
+      }
+      if (paramConfig.contains("PerPrimaryVertexProcessing")) {
+        params.PerPrimaryVertexProcessing = paramConfig["PerPrimaryVertexProcessing"].get<bool>();
+      }
+      if (paramConfig.contains("SaveTimeBenchmarks")) {
+        params.SaveTimeBenchmarks = paramConfig["SaveTimeBenchmarks"].get<bool>();
+      }
+      if (paramConfig.contains("DoUPCIteration")) {
+        params.DoUPCIteration = paramConfig["DoUPCIteration"].get<bool>();
+      }
+      if (paramConfig.contains("FataliseUponFailure")) {
+        params.FataliseUponFailure = paramConfig["FataliseUponFailure"].get<bool>();
+      }
+      if (paramConfig.contains("CreateArtefactLabels")) {
+        params.CreateArtefactLabels = paramConfig["CreateArtefactLabels"].get<bool>();
+      }
+      if (paramConfig.contains("PrintMemory")) {
+        params.PrintMemory = paramConfig["PrintMemory"].get<bool>();
+      }
+      if (paramConfig.contains("DropTFUponFailure")) {
+        params.DropTFUponFailure = paramConfig["DropTFUponFailure"].get<bool>();
+      }
+
+      if (paramConfig.contains("LayerZ")) {
+        params.LayerZ = paramConfig["LayerZ"].get<std::vector<float>>();
+      }
+      if (paramConfig.contains("LayerRadii")) {
+        params.LayerRadii = paramConfig["LayerRadii"].get<std::vector<float>>();
+      }
+      if (paramConfig.contains("LayerxX0")) {
+        params.LayerxX0 = paramConfig["LayerxX0"].get<std::vector<float>>();
+      }
+      if (paramConfig.contains("LayerResolution")) {
+        params.LayerResolution = paramConfig["LayerResolution"].get<std::vector<float>>();
+      }
+      if (paramConfig.contains("SystErrorY2")) {
+        params.SystErrorY2 = paramConfig["SystErrorY2"].get<std::vector<float>>();
+      }
+      if (paramConfig.contains("SystErrorZ2")) {
+        params.SystErrorZ2 = paramConfig["SystErrorZ2"].get<std::vector<float>>();
+      }
+      if (paramConfig.contains("MinPt")) {
+        params.MinPt = paramConfig["MinPt"].get<std::vector<float>>();
+      }
+      if (paramConfig.contains("AddTimeError")) {
+        params.AddTimeError = paramConfig["AddTimeError"].get<std::vector<UInt_t>>();
+      }
+
+      if (paramConfig.contains("Diamond") && paramConfig["Diamond"].is_array() && paramConfig["Diamond"].size() == 3) {
+        params.Diamond[0] = paramConfig["Diamond"][0].get<float>();
+        params.Diamond[1] = paramConfig["Diamond"][1].get<float>();
+        params.Diamond[2] = paramConfig["Diamond"][2].get<float>();
+      }
+
+      if (paramConfig.contains("MaxMemory")) {
+        params.MaxMemory = paramConfig["MaxMemory"].get<size_t>();
+      }
+
+      if (paramConfig.contains("CorrType")) {
+        int corrTypeInt = paramConfig["CorrType"].get<int>();
+        params.CorrType = static_cast<o2::base::PropagatorImpl<float>::MatCorrType>(corrTypeInt);
+      }
+
+      const auto nLayers = static_cast<size_t>(params.NLayers);
+      LOG_IF(fatal, params.LayerZ.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter LayerZ: expected " << nLayers << " entries, got " << params.LayerZ.size();
+      LOG_IF(fatal, params.LayerRadii.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter LayerRadii: expected " << nLayers << " entries, got " << params.LayerRadii.size();
+      LOG_IF(fatal, params.LayerxX0.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter LayerxX0: expected " << nLayers << " entries, got " << params.LayerxX0.size();
+      LOG_IF(fatal, params.LayerResolution.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter LayerResolution: expected " << nLayers << " entries, got " << params.LayerResolution.size();
+      LOG_IF(fatal, params.SystErrorY2.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter SystErrorY2: expected " << nLayers << " entries, got " << params.SystErrorY2.size();
+      LOG_IF(fatal, params.SystErrorZ2.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter SystErrorZ2: expected " << nLayers << " entries, got " << params.SystErrorZ2.size();
+      LOG_IF(fatal, params.AddTimeError.size() != nLayers) << "Invalid ALICE3 TRK tracking parameter AddTimeError: expected " << nLayers << " entries, got " << params.AddTimeError.size();
+
+      LOG_IF(fatal, params.MinTrackLength > params.NLayers) << "Invalid ALICE3 TRK tracking parameter MinTrackLength: expected <= NLayers (" << params.NLayers << "), got " << params.MinTrackLength;
+      const auto minPtSize = static_cast<size_t>(params.NLayers - params.MinTrackLength + 1);
+      LOG_IF(fatal, params.MinPt.size() != minPtSize) << "Invalid ALICE3 TRK tracking parameter MinPt: expected " << minPtSize << " entries, got " << params.MinPt.size();
+
+      trackingParams.push_back(params);
+    }
+  };
+
+  if (mHitRecoConfig.contains("trackingparams") && mHitRecoConfig["trackingparams"].is_array()) {
+    loadTrackingParamsFromJson(trackingParams, mHitRecoConfig["trackingparams"]);
+  } else if (mClusterRecoConfig.contains("trackingparams") && mClusterRecoConfig["trackingparams"].is_array()) {
+    loadTrackingParamsFromJson(trackingParams, mClusterRecoConfig["trackingparams"]);
+  } else {
+    LOGP(fatal, "No trackingparams field found in configuration or it is not an array. Returning empty vector.");
+    return trackingParams;
+  }
+
+  LOGP(info, "Loaded {} tracking parameter sets from configuration", trackingParams.size());
+  return trackingParams;
+}
+
+void TrackerDPL::run(ProcessingContext& pc)
+{
+  if (mMemoryPool.get() == nullptr) {
+    mMemoryPool = std::make_shared<its::BoundedMemoryResource>();
+  }
+  if (mTaskArena.get() == nullptr) {
+    mTaskArena = std::make_shared<tbb::task_arena>(1); /// TODO: make it configurable
+  }
+
+  auto trackingParams = createTrackingParamsFromConfig();
+
+  auto cput = mTimer.CpuTime();
+  auto realt = mTimer.RealTime();
+  mTimer.Start(false);
+
+  const bool useGPU = mDeviceType != o2::gpu::gpudatatypes::DeviceType::CPU;
+#ifndef TRK_HAS_GPU_TRACKING
+  if (useGPU) {
+    LOGP(fatal, "TRK GPU tracking was requested but this build has no TRK GPU tracking backend");
+  }
+#else
+#ifdef TRK_HAS_CUDA_TRACKING
+  if (useGPU && mDeviceType != o2::gpu::gpudatatypes::DeviceType::CUDA) {
+    LOGP(fatal, "This build provides the CUDA TRK tracking backend only, but device type {} was requested", static_cast<int>(mDeviceType));
+  }
+#elif defined(TRK_HAS_HIP_TRACKING)
+  if (useGPU && mDeviceType != o2::gpu::gpudatatypes::DeviceType::HIP) {
+    LOGP(fatal, "This build provides the HIP TRK tracking backend only, but device type {} was requested", static_cast<int>(mDeviceType));
+  }
+#endif
+#endif
+
+  auto runTracking = [&](auto& timeFrame, auto& trackerTraits) {
+    o2::its::Tracker<11> itsTracker(&trackerTraits);
+    timeFrame.setMemoryPool(mMemoryPool);
+    trackerTraits.setMemoryPool(mMemoryPool);
+    trackerTraits.setNThreads(mTaskArena->max_concurrency(), mTaskArena);
+    trackerTraits.adoptTimeFrame(static_cast<o2::its::TimeFrame<11>*>(&timeFrame));
+    itsTracker.adoptTimeFrame(timeFrame);
+    trackerTraits.updateTrackingParameters(trackingParams);
+
+    int nRofs{0};
+    if (!mHitRecoConfig.empty()) {
+      TFile hitsFile(mHitRecoConfig["inputfiles"]["hits"].get<std::string>().c_str(), "READ");
+      TFile mcHeaderFile(mHitRecoConfig["inputfiles"]["mcHeader"].get<std::string>().c_str(), "READ");
+      TTree* hitsTree = hitsFile.Get<TTree>("o2sim");
+      std::vector<o2::trk::Hit>* trkHit = nullptr;
+      hitsTree->SetBranchAddress("TRKHit", &trkHit);
+
+      TTree* mcHeaderTree = mcHeaderFile.Get<TTree>("o2sim");
+      auto mcheader = new o2::dataformats::MCEventHeader;
+      mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
+
+      o2::base::GeometryManager::loadGeometry(mHitRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
+      auto* gman = o2::trk::GeometryTGeo::Instance();
+
+      const Long64_t nEvents{hitsTree->GetEntries()};
+      LOGP(info, "Starting {} reconstruction from hits for {} events", trackerTraits.getName(), nEvents);
+
+      trackerTraits.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
+      auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mHitRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
+      TGeoGlobalMagField::Instance()->SetField(field);
+      TGeoGlobalMagField::Instance()->Lock();
+
+      nRofs = timeFrame.loadROFsFromHitTree(hitsTree, gman, mHitRecoConfig);
+      const int inROFpileup{mHitRecoConfig.contains("inROFpileup") ? mHitRecoConfig["inROFpileup"].get<int>() : 1};
+      timeFrame.getPrimaryVerticesFromMC(mcHeaderTree, nRofs, nEvents, inROFpileup);
+    } else if (!mClusterRecoConfig.empty()) {
+      LOGP(info, "Starting {} reconstruction from clusters", trackerTraits.getName());
+
+      o2::base::GeometryManager::loadGeometry(mClusterRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
+      o2::trk::GeometryTGeo::Instance();
+
+      trackerTraits.setBz(mClusterRecoConfig["geometry"]["bz"].get<float>());
+      auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mClusterRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
+      TGeoGlobalMagField::Instance()->SetField(field);
+      TGeoGlobalMagField::Instance()->Lock();
+
+      constexpr int nLayers{11};
+      std::array<gsl::span<const o2::trk::Cluster>, nLayers> layerClusters;
+      std::array<gsl::span<const unsigned char>, nLayers> layerPatterns;
+      std::array<gsl::span<const o2::trk::ROFRecord>, nLayers> layerROFs;
+      std::array<const dataformats::MCTruthContainer<MCCompLabel>*, nLayers> layerLabels{};
+
+      size_t nInputRofs{0};
+      for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
+        layerClusters[iLayer] = pc.inputs().get<gsl::span<o2::trk::Cluster>>(std::format("compClusters_{}", iLayer));
+        layerPatterns[iLayer] = pc.inputs().get<gsl::span<unsigned char>>(std::format("patterns_{}", iLayer));
+        layerROFs[iLayer] = pc.inputs().get<gsl::span<o2::trk::ROFRecord>>(std::format("ROframes_{}", iLayer));
+        nInputRofs = std::max(nInputRofs, layerROFs[iLayer].size());
+        if (mIsMC) {
+          layerLabels[iLayer] = pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>(std::format("trkmclabels_{}", iLayer)).release();
+        }
+      }
+
+      timeFrame.deriveAndInitTiming(layerROFs);
+
+      const float yPlaneMLOT = 0.0010f;
+      nRofs = timeFrame.loadROFrameData(layerROFs, layerClusters, layerPatterns, mIsMC ? &layerLabels : nullptr, yPlaneMLOT);
+      timeFrame.addTruthSeedingVertices();
+    }
+
+    const auto trackingLoopStart = std::chrono::steady_clock::now();
+    for (size_t iter{0}; iter < trackingParams.size(); ++iter) {
+      LOGP(info, "{}", trackingParams[iter].asString());
+      trackerTraits.initialiseTimeFrame(iter);
+      trackerTraits.computeLayerTracklets(iter, -1);
+      LOGP(info, "Number of tracklets in iteration {}: {}", iter, timeFrame.getNumberOfTracklets());
+      trackerTraits.computeLayerCells(iter);
+      LOGP(info, "Number of cells in iteration {}: {}", iter, timeFrame.getNumberOfCells());
+      trackerTraits.findCellsNeighbours(iter);
+      LOGP(info, "Number of cell neighbours in iteration {}: {}", iter, timeFrame.getNumberOfNeighbours());
+      trackerTraits.findRoads(iter);
+      LOGP(info, "Number of roads in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
+    }
+    const auto trackingLoopElapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - trackingLoopStart).count();
+    LOGP(info, "Tracking iterations block took {} ms", trackingLoopElapsedMs);
+
+    if (mIsMC) {
+      itsTracker.computeTracksMClabels();
+    }
+
+    const auto& tracks = timeFrame.getTracks();
+    const auto& labels = timeFrame.getTracksLabel();
+    std::vector<o2::its::TrackITS> allTracks(tracks.begin(), tracks.end());
+    std::vector<o2::MCCompLabel> allLabels;
+
+    int totalTracks = allTracks.size();
+    int goodTracks = 0;
+    int fakeTracks = 0;
+
+    if (mIsMC) {
+      allLabels.assign(labels.begin(), labels.end());
+      for (const auto& label : allLabels) {
+        if (label.isFake()) {
+          ++fakeTracks;
+        } else {
+          ++goodTracks;
+        }
+      }
+    }
+
+    LOGP(info, "=== Tracking Summary ===");
+    LOGP(info, "Total tracks reconstructed: {}", totalTracks);
+    LOGP(info, "Good tracks: {} ({:.1f}%)", goodTracks, totalTracks > 0 ? 100.0 * goodTracks / totalTracks : 0);
+    LOGP(info, "Fake tracks: {} ({:.1f}%)", fakeTracks, totalTracks > 0 ? 100.0 * fakeTracks / totalTracks : 0);
+
+    const auto& rofView = timeFrame.getROFOverlapTableView();
+    const auto& clockLayer = rofView.getClockLayer();
+    const int clockLayerId = rofView.getClock();
+    const int64_t anchorBC = timeFrame.getTFAnchorIR().toLong();
+
+    int highestROF = static_cast<int>(clockLayer.mNROFsTF);
+    for (const auto& trc : allTracks) {
+      highestROF = std::max(highestROF, static_cast<int>(clockLayer.getROF(trc.getTimeStamp())));
+    }
+    for (const auto& vtx : timeFrame.getPrimaryVertices()) {
+      highestROF = std::max(highestROF, static_cast<int>(clockLayer.getROF(vtx.getTimeStamp().lower())));
+    }
+
+    std::vector<o2::trk::ROFRecord> allTrackROFs(highestROF);
+    for (size_t iROF = 0; iROF < allTrackROFs.size(); ++iROF) {
+      auto& rof = allTrackROFs[iROF];
+      o2::InteractionRecord ir;
+      ir.setFromLong(anchorBC + static_cast<int64_t>(clockLayer.getROFStartInBC(iROF)));
+      rof.setBCData(ir);
+      rof.setROFrame(iROF);
+      rof.setFirstEntry(0);
+      rof.setNEntries(0);
+    }
+
+    std::vector<int> rofEntries(highestROF + 1, 0);
+    for (const auto& trc : allTracks) {
+      const int rof = static_cast<int>(clockLayer.getROF(trc.getTimeStamp()));
+      if (rof >= 0 && rof < highestROF) {
+        ++rofEntries[rof];
+      }
+    }
+    std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
+
+    std::vector<o2::dataformats::IRFrame> irFrames;
+    irFrames.reserve(allTrackROFs.size());
+    const auto& maskView = timeFrame.getROFMaskView();
+    const auto rofLenMinus1 = clockLayer.mROFLength > 0 ? clockLayer.mROFLength - 1 : 0;
+    for (size_t iROF = 0; iROF < allTrackROFs.size(); ++iROF) {
+      allTrackROFs[iROF].setFirstEntry(rofEntries[iROF]);
+      allTrackROFs[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
+      if (maskView.isROFEnabled(clockLayerId, static_cast<int>(iROF))) {
+        const auto& bcStart = allTrackROFs[iROF].getBCData();
+        auto& irFrame = irFrames.emplace_back(bcStart, bcStart + rofLenMinus1);
+        irFrame.info = allTrackROFs[iROF].getNEntries();
+      }
+    }
+
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKS", 0}, allTracks);
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSROF", 0}, allTrackROFs);
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "IRFRAMES", 0}, irFrames);
+    if (mIsMC) {
+      pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSMCTR", 0}, allLabels);
+    }
+
+    LOGP(info, "TRK pushed {} tracks in {} ROFs and {} IR frames{}",
+         allTracks.size(), allTrackROFs.size(), irFrames.size(),
+         mIsMC ? " (with MC labels)" : "");
+
+    timeFrame.wipe();
+  };
+
+#ifdef TRK_HAS_GPU_TRACKING
+  if (useGPU) {
+    o2::trk::TimeFrameGPU<11> timeFrame;
+    o2::its::TrackerTraitsGPU<11> itsTrackerTraits;
+    if (!mGPUAllocator) {
+      mGPUAllocator = std::make_shared<o2::trk::GPUExternalAllocator>();
+    }
+    timeFrame.setFrameworkAllocator(mGPUAllocator.get());
+    runTracking(timeFrame, itsTrackerTraits);
+  } else
+#endif
+  {
+    o2::trk::TimeFrame<11> timeFrame;
+    o2::its::TrackerTraits<11> itsTrackerTraits;
+    runTracking(timeFrame, itsTrackerTraits);
+  }
+
+  pc.services().get<o2::framework::ControlService>().endOfStream();
+  pc.services().get<o2::framework::ControlService>().readyToQuit(framework::QuitRequest::Me);
+
+  mTimer.Stop();
+  LOGP(info, "CPU Reconstruction time for this TF {} s (cpu), {} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
+}
+
+void TrackerDPL::endOfStream(EndOfStreamContext& ec)
+{
+  LOGF(info, "TRK CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
+}
+
+DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, const std::string& clusterRecoConfig, o2::gpu::gpudatatypes::DeviceType dType)
+{
+  std::vector<InputSpec> inputs;
+  std::vector<OutputSpec> outputs;
+  outputs.emplace_back("TRK", "TRACKS", 0, Lifetime::Timeframe);
+  outputs.emplace_back("TRK", "TRACKSROF", 0, Lifetime::Timeframe);
+  outputs.emplace_back("TRK", "IRFRAMES", 0, Lifetime::Timeframe);
+  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
+                                                              false,                          // GRPECS=true
+                                                              false,                          // GRPLHCIF
+                                                              false,                          // GRPMagField
+                                                              false,                          // askMatLUT
+                                                              o2::base::GRPGeomRequest::None, // geometry, but ignored until it will be put in the CCDB
+                                                              inputs,
+                                                              true);
+
+  if (!hitRecoConfig.empty()) {
+    if (useMC) {
+      outputs.emplace_back("TRK", "TRACKSMCTR", 0, Lifetime::Timeframe);
+    }
+    return DataProcessorSpec{
+      "trk-hits-tracker",
+      {},
+      outputs,
+      AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
+                                              useMC,
+                                              hitRecoConfig,
+                                              clusterRecoConfig,
+                                              dType)},
+      Options{ConfigParamSpec{"max-loops", VariantType::Int, 1, {"max number of loops"}}
+#ifdef O2_WITH_ACTS
+              ,
+              {"useACTS", o2::framework::VariantType::Bool, false, {"Use ACTS for tracking"}}
+#endif
+      }};
+  }
+
+  inputs.emplace_back("dummy", "TRK", "DUMMY", 0, Lifetime::Timeframe);
+
+  if (!clusterRecoConfig.empty()) {
+    inputs.pop_back();
+    constexpr int nLayers{11};
+    for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
+      inputs.emplace_back(std::format("compClusters_{}", iLayer), "TRK", "COMPCLUSTERS", iLayer, Lifetime::Timeframe);
+      inputs.emplace_back(std::format("patterns_{}", iLayer), "TRK", "PATTERNS", iLayer, Lifetime::Timeframe);
+      inputs.emplace_back(std::format("ROframes_{}", iLayer), "TRK", "CLUSTERSROF", iLayer, Lifetime::Timeframe);
+      if (useMC) {
+        inputs.emplace_back(std::format("trkmclabels_{}", iLayer), "TRK", "CLUSTERSMCTR", iLayer, Lifetime::Timeframe);
+      }
+    }
+  }
+
+  if (useMC) {
+    outputs.emplace_back("TRK", "TRACKSMCTR", 0, Lifetime::Timeframe);
+  }
+
+  return DataProcessorSpec{
+    "trk-tracker",
+    inputs,
+    outputs,
+    AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
+                                            useMC,
+                                            hitRecoConfig,
+                                            clusterRecoConfig,
+                                            dType)},
+    Options{}};
+}
+
+} // namespace trk
+} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/alice3-global-reconstruction-workflow.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/alice3-global-reconstruction-workflow.cxx
new file mode 100644
index 0000000000000..7e9950f4def2e
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/alice3-global-reconstruction-workflow.cxx
@@ -0,0 +1,65 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ALICE3GlobalReconstructionWorkflow/RecoWorkflow.h"
+#include "CommonUtils/ConfigurableParam.h"
+
+#include "Framework/CallbacksPolicy.h"
+#include "Framework/ConfigContext.h"
+#include "Framework/CompletionPolicyHelpers.h"
+
+#include <stdexcept>
+#include <vector>
+
+using namespace o2::framework;
+
+void customize(std::vector<CallbacksPolicy>& policies)
+{
+  // o2::raw::HBFUtilsInitializer::addNewTimeSliceCallback(policies);
+}
+
+void customize(std::vector<CompletionPolicy>& policies)
+{
+  policies.push_back(CompletionPolicyHelpers::consumeWhenAllOrdered(".*(?:TRK|trk).*[W,w]riter.*"));
+}
+
+void customize(std::vector<ConfigParamSpec>& workflowOptions)
+{
+  std::vector<ConfigParamSpec> options{
+    {"disable-root-output", VariantType::Bool, false, {"do not write output root files"}},
+    {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
+    {"tracking-from-hits-config", VariantType::String, "", {"JSON file with tracking from hits configuration"}},
+    {"tracking-from-clusters-config", VariantType::String, "", {"JSON file with tracking from clusters configuration"}},
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
+    {"gpu-device", VariantType::Int, 1, {"use gpu device: CPU=1,CUDA=2,HIP=3 (default: CPU)"}}};
+  std::swap(workflowOptions, options);
+}
+
+#include "Framework/runDataProcessing.h"
+#include "Framework/Logger.h"
+
+WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
+{
+  auto useMC = !configcontext.options().get<bool>("disable-mc");
+  auto hitRecoConfig = configcontext.options().get<std::string>("tracking-from-hits-config");
+  auto clusterRecoConfig = configcontext.options().get<std::string>("tracking-from-clusters-config");
+  auto gpuDevice = static_cast<o2::gpu::gpudatatypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
+  auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
+  o2::conf::ConfigurableParam::updateFromString(configcontext.options().get<std::string>("configKeyValues"));
+
+  if (hitRecoConfig.empty() && clusterRecoConfig.empty()) {
+    throw std::invalid_argument("no reconstruction input configured: provide either --tracking-from-hits-config <file> or --tracking-from-clusters-config <file>");
+  }
+
+  o2::conf::ConfigurableParam::writeINI("o2alice3globalrecoflow_configuration.ini");
+
+  return o2::trk::global_reco_workflow::getWorkflow(useMC, hitRecoConfig, clusterRecoConfig, disableRootOutput, gpuDevice);
+}
diff --git a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
index 28dc61aed9c8b..7b9365dbe2011 100644
--- a/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
+++ b/Detectors/Upgrades/ALICE3/TRK/macros/test/CheckClusters.C
@@ -22,7 +22,12 @@
 #include <TTree.h>
 #include <TROOT.h>
 #include <TStyle.h>
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <limits>
 #include <unordered_map>
+#include <vector>
 
 #include "DataFormatsTRK/Cluster.h"
 #include "DataFormatsTRK/ROFRecord.h"
@@ -48,11 +53,8 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
 {
   gROOT->SetBatch(batch);
 
-  using o2::MCCompLabel;
-  using ROFRec = o2::trk::ROFRecord;
-  using MC2ROF = o2::trk::MC2ROFRecord;
   using HitVec = std::vector<o2::trk::Hit>;
-  using MC2HITS_map = std::unordered_map<uint64_t, int>; // maps (trackID << 32) + chipID -> hit index
+  using MC2HITS_map = std::unordered_map<uint64_t, std::vector<int>>; // maps (trackID << 32) + chipID -> hit indices
 
   // ── Chip response (for hit-segment propagation to charge-collection plane) ──
   // Fetches the same AlpideSimResponse from CCDB as the digitizer (IT3/Calib/APTSResponse)
@@ -130,6 +132,10 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
     LOGP(error, "Cannot find o2sim tree in {}", hitfile);
     return;
   }
+  if (hitTree->GetBranch("TRKHit") == nullptr) {
+    LOGP(error, "Cannot find TRKHit branch in {}", hitfile);
+    return;
+  }
   std::vector<MC2HITS_map> mc2hitVec;
   std::vector<HitVec*> hitVecPool;
   mc2hitVec.resize(hitTree->GetEntries());
@@ -149,8 +155,10 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
   std::vector<std::vector<o2::trk::ROFRecord>*> rofRecVecPerLayer(nLayers, nullptr);
   std::vector<std::vector<unsigned char>*> patternsPerLayer(nLayers, nullptr);
   std::vector<o2::dataformats::MCTruthContainer<o2::MCCompLabel>*> clusLabArrPerLayer(nLayers, nullptr);
+  std::vector<std::vector<size_t>> patternOffsetsPerLayer(nLayers);
+  std::vector<bool> layerActive(nLayers, false);
 
-  bool hasMC = true;
+  bool hasAnyMC = false;
   for (int iLayer = 0; iLayer < nLayers; iLayer++) {
     std::string brClus = std::string("TRKClusterComp_") + std::to_string(iLayer);
     std::string brROF = std::string("TRKClustersROF_") + std::to_string(iLayer);
@@ -161,45 +169,112 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
       LOGP(warning, "Branch {} not found, skipping layer {}", brClus, iLayer);
       continue;
     }
+    if (clusTree->GetBranch(brROF.c_str()) == nullptr) {
+      LOGP(error, "Branch {} not found, skipping layer {}", brROF, iLayer);
+      continue;
+    }
     clusTree->SetBranchAddress(brClus.c_str(), &clusArrPerLayer[iLayer]);
     clusTree->SetBranchAddress(brROF.c_str(), &rofRecVecPerLayer[iLayer]);
     if (clusTree->GetBranch(brPatt.c_str()) != nullptr) {
       clusTree->SetBranchAddress(brPatt.c_str(), &patternsPerLayer[iLayer]);
+    } else {
+      LOGP(warning, "Branch {} not found, layer {} cluster positions use bbox origins", brPatt, iLayer);
     }
     if (clusTree->GetBranch(brMCTruth.c_str()) != nullptr) {
       clusTree->SetBranchAddress(brMCTruth.c_str(), &clusLabArrPerLayer[iLayer]);
-    } else {
-      hasMC = false;
+      hasAnyMC = true;
     }
+    layerActive[iLayer] = true;
   }
 
   // Read entry and accumulate all layers
-  clusTree->GetEntry(0);
+  if (clusTree->GetEntry(0) <= 0) {
+    LOGP(error, "Cannot read entry 0 from {}", clusfile);
+    return;
+  }
+
+  auto hasAnyActiveLayer = false;
+  for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    hasAnyActiveLayer = hasAnyActiveLayer || layerActive[iLayer];
+  }
+  if (!hasAnyActiveLayer) {
+    LOGP(error, "No usable TRK cluster layers found in {}", clusfile);
+    return;
+  }
+
   // Print total clusters per layer
   for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    if (!layerActive[iLayer]) {
+      continue;
+    }
+    if (clusArrPerLayer[iLayer] == nullptr || rofRecVecPerLayer[iLayer] == nullptr) {
+      LOGP(error, "Layer {} branches were declared but did not load usable data, skipping layer", iLayer);
+      layerActive[iLayer] = false;
+      continue;
+    }
     LOGP(info, "Layer {}: {} clusters", iLayer, clusArrPerLayer[iLayer]->size());
   }
 
+  // The pattern stream is variable-length, so index it by cluster entry once.
+  for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    if (!layerActive[iLayer] || patternsPerLayer[iLayer] == nullptr) {
+      continue;
+    }
+    const auto nClusters = clusArrPerLayer[iLayer]->size();
+    const auto& patterns = *patternsPerLayer[iLayer];
+    auto& offsets = patternOffsetsPerLayer[iLayer];
+    offsets.resize(nClusters, std::numeric_limits<size_t>::max());
+    size_t pattPos = 0;
+    bool validPatterns = true;
+    for (size_t icl = 0; icl < nClusters; icl++) {
+      if (pattPos + 2 > patterns.size()) {
+        validPatterns = false;
+        break;
+      }
+      offsets[icl] = pattPos;
+      const uint8_t rowSpan = patterns[pattPos];
+      const uint8_t colSpan = patterns[pattPos + 1];
+      const size_t nBytes = (size_t(rowSpan) * colSpan + 7) / 8;
+      if (pattPos + 2 + nBytes > patterns.size()) {
+        validPatterns = false;
+        break;
+      }
+      pattPos += 2 + nBytes;
+    }
+    if (!validPatterns || pattPos != patterns.size()) {
+      LOGP(error, "Malformed pattern stream for layer {}: {} pattern bytes for {} clusters, disabling CoG corrections for this layer",
+           iLayer, patterns.size(), nClusters);
+      patternsPerLayer[iLayer] = nullptr;
+      offsets.clear();
+    }
+  }
+
   // Accumulate max ROF count across all layers
   unsigned int nROFRec = 0;
   for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+    if (!layerActive[iLayer]) {
+      continue;
+    }
     nROFRec = std::max(nROFRec, (unsigned int)rofRecVecPerLayer[iLayer]->size());
   }
   LOGP(info, "Number of ROF records: {}", nROFRec);
 
   // ── Load all MC hit events upfront (TRK has no MC2ROF mapping) ──────────────
-  if (hasMC) {
+  if (hasAnyMC) {
     LOGP(info, "Pre-loading {} MC events", hitTree->GetEntries());
     for (int im = 0; im < (int)hitTree->GetEntries(); im++) {
       if (hitVecPool[im] == nullptr) {
         hitTree->SetBranchAddress("TRKHit", &hitVecPool[im]);
-        hitTree->GetEntry(im);
+        if (hitTree->GetEntry(im) <= 0 || hitVecPool[im] == nullptr) {
+          LOGP(error, "Cannot read TRKHit entry {} from {}", im, hitfile);
+          return;
+        }
         auto& mc2hit = mc2hitVec[im];
         const auto* hv = hitVecPool[im];
         for (int ih = (int)hv->size(); ih--;) {
           const auto& hit = (*hv)[ih];
           uint64_t key = (uint64_t(hit.GetTrackID()) << 32) + hit.GetDetectorID();
-          mc2hit.emplace(key, ih);
+          mc2hit[key].push_back(ih);
         }
       }
     }
@@ -210,40 +285,45 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
   // columns: event, MC track label,
   //   local hit x/z (flat frame), global hit x/y/z (midpoint),
   //   global cluster x/y/z, local cluster x/z,
-  //   residuals dx/dz (local, cluster - hit),
   //   ROF frame, cluster size, chipID, layer, disk, subDetID, row, col, pt
   TNtuple nt("ntc", "TRK cluster ntuple",
              "event:mcTrackID:hitLocX:hitLocZ:hitGlobX:hitGlobY:hitGlobZ:clusGlobX:clusGlobY:clusGlobZ:clusLocX:clusLocZ:rofFrame:clusSize:chipID:layer:disk:subdet:row:col:pt");
 
   // ── Counters ───────────────────────────────────────────────────────────────
-  long nTot{0}, nInvalidLabel{0}, nNoMCHit{0}, nValid{0};
+  long nTot{0}, nInvalidLabel{0}, nInvalidEvent{0}, nNoMCHit{0}, nValid{0};
 
   // ── Main loop ──────────────────────────────────────────────────────────────
   for (unsigned int irof = 0; irof < nROFRec; irof++) {
     // Process each layer
     for (int iLayer = 0; iLayer < nLayers; iLayer++) {
+      if (!layerActive[iLayer]) {
+        continue;
+      }
       if (rofRecVecPerLayer[iLayer]->empty() || irof >= rofRecVecPerLayer[iLayer]->size()) {
         continue;
       }
       const auto& rofRec = (*rofRecVecPerLayer[iLayer])[irof];
       const auto& clusArr = *clusArrPerLayer[iLayer];
-      const auto& patternsPtr = (patternsPerLayer[iLayer] == nullptr) ? nullptr : patternsPerLayer[iLayer];
       const auto& clusLabArr = clusLabArrPerLayer[iLayer];
-
-      // Create per-layer pattern iterator
-      auto pattIt = patternsPtr ? patternsPtr->cbegin() : std::vector<unsigned char>::const_iterator{};
+      const auto* patternsPtr = patternsPerLayer[iLayer];
+      const auto& patternOffsets = patternOffsetsPerLayer[iLayer];
 
       for (int icl = 0; icl < rofRec.getNEntries(); icl++) {
         const int clEntry = rofRec.getFirstEntry() + icl;
+        if (clEntry < 0 || clEntry >= (int)clusArr.size()) {
+          LOGP(error, "Layer {} ROF {} points to cluster entry {} outside {} clusters",
+               iLayer, irof, clEntry, clusArr.size());
+          continue;
+        }
         const auto& cluster = clusArr[clEntry];
         nTot++;
 
         // ── Parse pattern → center-of-gravity within bounding box ──────────
-        // The cluster stores the bounding-box top-left pixel (row, col).
-        // The pattern stream encodes [rowSpan, colSpan, bitmap...] for each cluster.
-        // We accumulate pixel row/col offsets to obtain a sub-pixel CoG correction.
+        // Keep this in sync with Clusterer::getClusterLocalCoordinates().
         float cogDr{0.f}, cogDc{0.f}; // mean offsets from bbox origin (pixels)
-        if (patternsPtr) {
+        if (patternsPtr != nullptr) {
+          const auto pattOffset = patternOffsets[clEntry];
+          const auto* pattIt = patternsPtr->data() + pattOffset;
           const uint8_t rowSpan = *pattIt++;
           const uint8_t colSpan = *pattIt++;
           const int nBytes = (rowSpan * colSpan + 7) / 8;
@@ -267,10 +347,6 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
         // ── Cluster local → global (CoG position) ─────────────────────────────
         // Get local coords of the bounding-box corner pixel, then apply the
         // fractional CoG displacement using the pixel pitch.
-        // Formula from detectorToLocalUnchecked:
-        //   VD  : xRow = 0.5*(width[lay]-pitchRow) - row*pitchRow  → row↑ xRow↓
-        //         zCol = col*pitchCol + 0.5*(pitchCol-length)      → col↑ zCol↑
-        //   MLOT: same structure with MLOT pitches
         float clLocX{0.f}, clLocZ{0.f};
         o2::trk::SegmentationChip::detectorToLocalUnchecked(
           cluster.row, cluster.col, clLocX, clLocZ,
@@ -281,24 +357,19 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
         const float pitchCol = (cluster.subDetID == 0)
                                  ? o2::trk::SegmentationChip::PitchColVD
                                  : o2::trk::SegmentationChip::PitchColMLOT;
-        clLocX -= cogDr * pitchRow; // increasing row → decreasing xRow
-        clLocZ += cogDc * pitchCol; // increasing col → increasing zCol
-        const float yResponse = (cluster.subDetID == 0) ? yPlaneVD : yPlaneMLOT;
-        // For VD the L2G matrix is built in the *curved* local frame (quasi-Cartesian,
-        // origin at the beam axis). Convert flat (clLocX, 0) → curved (xC, yC) first.
-        // For MLOT (flat sensors) the local frame is already Cartesian: pass directly.
-        // clLocX is already in the flat frame from detectorToLocalUnchecked + CoG and
-        // does NOT need any further transformation for the residual comparison.
+        clLocX -= cogDr * pitchRow; // increasing row -> decreasing xRow
+        clLocZ += cogDc * pitchCol; // increasing col -> increasing zCol
+
         o2::math_utils::Point3D<float> locC;
         if (cluster.subDetID == 0) {
           auto cv = o2::trk::SegmentationChip::flatToCurved(cluster.layer, clLocX, 0.f);
           locC = {cv.X(), cv.Y(), clLocZ};
         } else {
-          locC = {clLocX, yResponse, clLocZ};
+          locC = {clLocX, yPlaneMLOT, clLocZ};
         }
         auto gloC = gman->getMatrixL2G(cluster.chipID)(locC);
 
-        if (!hasMC || clusLabArr == nullptr) {
+        if (!hasAnyMC || clusLabArr == nullptr) {
           // No MC info: just fill geometry columns, leave residuals as 0
           std::array<float, 21> data = {
             -1.f, -1.f,
@@ -321,6 +392,10 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
         const auto& lab = labels[0];
         const int trID = lab.getTrackID();
         const int evID = lab.getEventID();
+        if (evID < 0 || evID >= (int)mc2hitVec.size()) {
+          nInvalidEvent++;
+          continue;
+        }
 
         // ── Find matching MC hit ────────────────────────────────────────────
         const auto& mc2hit = mc2hitVec[evID];
@@ -330,7 +405,53 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
           nNoMCHit++;
           continue;
         }
-        const auto& hit = (*hitVecPool[evID])[hitEntry->second];
+        auto projectHitToResponsePlane = [&](const o2::trk::Hit& hit, float& hitLocX, float& hitLocZ) {
+          const auto& gloHend = hit.GetPos();
+          const auto& gloHsta = hit.GetPosStart();
+          o2::math_utils::Point3D<float> locHsta = gman->getMatrixL2G(cluster.chipID) ^ (gloHsta); // inverse L2G
+          o2::math_utils::Point3D<float> locHend = gman->getMatrixL2G(cluster.chipID) ^ (gloHend); // inverse L2G
+
+          // Rather than the geometric midpoint, find where the track segment crosses
+          // the response plane. For VD convert the curved endpoints to the flat frame first.
+          if (cluster.subDetID == 0) {
+            auto flatSta = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHsta.X(), locHsta.Y());
+            auto flatEnd = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHend.X(), locHend.Y());
+            float x0 = flatSta.X(), y0 = flatSta.Y(), z0 = locHsta.Z();
+            float dltx = flatEnd.X() - x0, dlty = flatEnd.Y() - y0, dltz = locHend.Z() - z0;
+            float r = (std::abs(dlty) > 1e-9f) ? (yPlaneVD - y0) / dlty : 0.5f;
+            hitLocX = x0 + r * dltx;
+            hitLocZ = z0 + r * dltz;
+          } else {
+            float x0 = locHsta.X(), y0 = locHsta.Y(), z0 = locHsta.Z();
+            float dltx = locHend.X() - x0, dlty = locHend.Y() - y0, dltz = locHend.Z() - z0;
+            float r = (std::abs(dlty) > 1e-9f) ? (yPlaneMLOT - y0) / dlty : 0.5f;
+            hitLocX = x0 + r * dltx;
+            hitLocZ = z0 + r * dltz;
+          }
+        };
+
+        const o2::trk::Hit* bestHit = nullptr;
+        float hitLocX{0.f}, hitLocZ{0.f};
+        float bestDist2 = std::numeric_limits<float>::max();
+        for (const auto ih : hitEntry->second) {
+          const auto& candHit = (*hitVecPool[evID])[ih];
+          float candLocX{0.f}, candLocZ{0.f};
+          projectHitToResponsePlane(candHit, candLocX, candLocZ);
+          const float dx = clLocX - candLocX;
+          const float dz = clLocZ - candLocZ;
+          const float dist2 = dx * dx + dz * dz;
+          if (dist2 < bestDist2) {
+            bestDist2 = dist2;
+            bestHit = &candHit;
+            hitLocX = candLocX;
+            hitLocZ = candLocZ;
+          }
+        }
+        if (bestHit == nullptr) {
+          nNoMCHit++;
+          continue;
+        }
+        const auto& hit = *bestHit;
         const float pt = TMath::Hypot(hit.GetPx(), hit.GetPy());
 
         // ── Hit global midpoint ────────────────────────────────────────────
@@ -341,32 +462,6 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
           0.5f * (gloHend.Y() + gloHsta.Y()),
           0.5f * (gloHend.Z() + gloHsta.Z()));
 
-        // ── Hit global → local ─────────────────────────────
-        o2::math_utils::Point3D<float> locHsta = gman->getMatrixL2G(cluster.chipID) ^ (gloHsta); // inverse L2G
-        o2::math_utils::Point3D<float> locHend = gman->getMatrixL2G(cluster.chipID) ^ (gloHend); // inverse L2G
-
-        // ── Propagate hit segment to the sensor response surface ───────────────
-        // Rather than the geometric midpoint, find where the track segment crosses
-        // the response plane (y = responseYShift in the flat local frame).
-        // For VD (curved): convert both endpoints to flat frame first.
-        // For ML/OT (flat): use local coordinates directly.
-        float hitLocX{0.f}, hitLocZ{0.f};
-        if (cluster.subDetID == 0) { // VD – curved sensor
-          auto flatSta = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHsta.X(), locHsta.Y());
-          auto flatEnd = o2::trk::SegmentationChip::curvedToFlat(cluster.layer, locHend.X(), locHend.Y());
-          float x0 = flatSta.X(), y0 = flatSta.Y(), z0 = locHsta.Z();
-          float dltx = flatEnd.X() - x0, dlty = flatEnd.Y() - y0, dltz = locHend.Z() - z0;
-          float r = (std::abs(dlty) > 1e-9f) ? (yPlaneVD - y0) / dlty : 0.5f;
-          hitLocX = x0 + r * dltx;
-          hitLocZ = z0 + r * dltz;
-        } else { // ML/OT – flat sensor
-          float x0 = locHsta.X(), y0 = locHsta.Y(), z0 = locHsta.Z();
-          float dltx = locHend.X() - x0, dlty = locHend.Y() - y0, dltz = locHend.Z() - z0;
-          float r = (std::abs(dlty) > 1e-9f) ? (yPlaneMLOT - y0) / dlty : 0.5f;
-          hitLocX = x0 + r * dltx;
-          hitLocZ = z0 + r * dltz;
-        }
-
         nValid++;
         std::array<float, 21> data = {
           (float)evID, (float)trID,
@@ -387,6 +482,7 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
   LOGP(info, "Total clusters:          {}", nTot);
   LOGP(info, "Valid (hit matched):     {}", nValid);
   LOGP(info, "Invalid/noise MC labels: {}", nInvalidLabel);
+  LOGP(info, "Invalid MC event IDs:    {}", nInvalidEvent);
   LOGP(info, "MC hit not found:        {}", nNoMCHit);
   // ── Visualisation ──────────────────────────────────────────────────────────
   auto canvGlobal = new TCanvas("canvGlobal", "Cluster global positions", 1600, 800);
@@ -400,25 +496,25 @@ void CheckClusters(const std::string& clusfile = "o2clus_trk.root",
   auto canvRes = new TCanvas("canvRes", "Residuals (cluster - hit) [cm]", 1600, 1200);
   canvRes->Divide(2, 3);
   canvRes->cd(1)->SetLogy();
-  nt.Draw("hitLocX-clusLocX>>h_dx_VD(200,-0.02,0.02)", "subdet==0&&event>=0");
+  nt.Draw("clusLocX-hitLocX>>h_dx_VD(200,-0.02,0.02)", "subdet==0&&event>=0");
   canvRes->cd(2)->SetLogy();
-  nt.Draw("hitLocZ-clusLocZ>>h_dz_VD(200,-0.02,0.02)", "subdet==0&&event>=0");
+  nt.Draw("clusLocZ-hitLocZ>>h_dz_VD(200,-0.02,0.02)", "subdet==0&&event>=0");
   canvRes->cd(3)->SetLogy();
-  nt.Draw("hitLocX-clusLocX>>h_dx_MLOT(200,-0.02,0.02)", "subdet==1&&event>=0");
+  nt.Draw("clusLocX-hitLocX>>h_dx_MLOT(200,-0.02,0.02)", "subdet==1&&event>=0");
   canvRes->cd(4)->SetLogy();
-  nt.Draw("hitLocZ-clusLocZ>>h_dz_MLOT(200,-0.02,0.02)", "subdet==1&&event>=0");
+  nt.Draw("clusLocZ-hitLocZ>>h_dz_MLOT(200,-0.02,0.02)", "subdet==1&&event>=0");
   canvRes->cd(5)->SetLogz();
-  nt.Draw("hitLocX-clusLocX:hitLocZ-clusLocZ>>h_dxdz_VD(200,-0.02,0.02,200,-0.02,0.02)", "subdet==0&&event>=0", "colz");
+  nt.Draw("clusLocX-hitLocX:clusLocZ-hitLocZ>>h_dxdz_VD(200,-0.02,0.02,200,-0.02,0.02)", "subdet==0&&event>=0", "colz");
   canvRes->cd(6);
-  nt.Draw("hitLocX-clusLocX:hitLocZ-clusLocZ>>h_dxdz_MLOT(200,-0.02,0.02,200,-0.02,0.02)", "subdet==1&&event>=0", "colz");
+  nt.Draw("clusLocX-hitLocX:clusLocZ-hitLocZ>>h_dxdz_MLOT(200,-0.02,0.02,200,-0.02,0.02)", "subdet==1&&event>=0", "colz");
   canvRes->SaveAs("trk_residuals.png");
 
   auto canvResVsLayer = new TCanvas("canvResVsLayer", "Residuals vs layer", 1600, 600);
   canvResVsLayer->Divide(2, 1);
   canvResVsLayer->cd(1);
-  nt.Draw("hitLocX-clusLocX:layer>>h_dx_vs_lay(20,0,20,200,-0.02,0.02)", "event>=0", "prof");
+  nt.Draw("clusLocX-hitLocX:layer>>h_dx_vs_lay(20,0,20,200,-0.02,0.02)", "event>=0", "prof");
   canvResVsLayer->cd(2);
-  nt.Draw("hitLocZ-clusLocZ:layer>>h_dz_vs_lay(20,0,20,200,-0.02,0.02)", "event>=0", "prof");
+  nt.Draw("clusLocZ-hitLocZ:layer>>h_dz_vs_lay(20,0,20,200,-0.02,0.02)", "event>=0", "prof");
   canvResVsLayer->SaveAs("trk_residuals_vs_layer.png");
 
   fout.cd();
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
index b8cb6a88f7163..45ce53ba7c3a3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/CMakeLists.txt
@@ -15,28 +15,16 @@ endif()
 
 o2_add_library(TRKReconstruction
                TARGETVARNAME targetName
-               SOURCES src/TimeFrame.cxx
-                       src/Clusterer.cxx
+               SOURCES src/Clusterer.cxx
                        $<$<BOOL:${Acts_FOUND}>:src/ClustererACTS.cxx>
-                       $<$<BOOL:${Acts_FOUND}>:src/TrackerACTS.cxx>
                PUBLIC_LINK_LIBRARIES
-                       O2::ITStracking
-                       O2::GPUCommon
                        Microsoft.GSL::GSL
-                       O2::CommonConstants
                        O2::DataFormatsITSMFT
                        O2::DataFormatsTRK
                        O2::SimulationDataFormat
-                       O2::ITSBase
-                       O2::ITSReconstruction
-                       O2::ITSMFTReconstruction
-                       O2::DataFormatsITS
-                       O2::TRKSimulation
+                       O2::TRKBase
                        nlohmann_json::nlohmann_json
-                       ${actsTarget}
-               PRIVATE_LINK_LIBRARIES
-                       O2::Steer
-                       TBB::tbb)
+                       ${actsTarget})
 
 if(Acts_FOUND)
   target_compile_definitions(${targetName} PUBLIC O2_WITH_ACTS)
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
index bcd95155f533f..3d30eb5068efe 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/Clusterer.h
@@ -28,6 +28,7 @@
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 #include "TRKBase/Specs.h"
+#include "MathUtils/Cartesian.h"
 #include <gsl/span>
 #include <vector>
 #include <array>
@@ -48,6 +49,7 @@ class Clusterer
 
   using Digit = o2::itsmft::Digit;
   using DigROFRecord = o2::itsmft::ROFRecord;
+  using DigMC2ROFRecord = o2::itsmft::MC2ROFRecord;
   using ClusterTruth = o2::dataformats::MCTruthContainer<o2::MCCompLabel>;
   using ConstDigitTruth = o2::dataformats::ConstMCTruthContainerView<o2::MCCompLabel>;
   using Label = o2::MCCompLabel;
@@ -166,7 +168,12 @@ class Clusterer
                        std::vector<unsigned char>& patterns,
                        std::vector<o2::trk::ROFRecord>& clusterROFs,
                        const ConstDigitTruth* digitLabels = nullptr,
-                       ClusterTruth* clusterLabels = nullptr);
+                       ClusterTruth* clusterLabels = nullptr,
+                       gsl::span<const DigMC2ROFRecord> digMC2ROFs = {},
+                       std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs = nullptr);
+
+  static o2::math_utils::Point3D<float> getClusterLocalCoordinates(const Cluster& cluster, const uint8_t* patt,
+                                                                   float yPlaneMLOT = 0.f) noexcept;
 
  protected:
   int mNHugeClus = 0;
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
index 5d68193e5e375..37a148aa78afb 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/ClustererACTS.h
@@ -35,7 +35,9 @@ class ClustererACTS : public Clusterer
                std::vector<unsigned char>& patterns,
                std::vector<o2::trk::ROFRecord>& clusterROFs,
                const ConstDigitTruth* digitLabels = nullptr,
-               ClusterTruth* clusterLabels = nullptr) override;
+               ClusterTruth* clusterLabels = nullptr,
+               gsl::span<const DigMC2ROFRecord> digMC2ROFs = {},
+               std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs = nullptr) override;
 
  private:
 };
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h b/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
deleted file mode 100644
index 005237fe28839..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/include/TRKReconstruction/TimeFrame.h
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file TimeFrame.h
-/// \brief TRK TimeFrame class derived from ITS TimeFrame
-///
-
-#ifndef ALICEO2_TRK_TIMEFRAME_H
-#define ALICEO2_TRK_TIMEFRAME_H
-
-#include "ITStracking/TimeFrame.h"
-#include "ITStracking/Constants.h"
-#include "ITStracking/Configuration.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include <vector>
-#include <unordered_map>
-#include <bitset>
-#include <cstdint>
-
-#include <nlohmann/json.hpp>
-
-class TTree;
-
-namespace o2
-{
-namespace trk
-{
-class GeometryTGeo;
-
-/// TRK TimeFrame class that extends ITS TimeFrame functionality
-/// This allows for customization of tracking algorithms specific to the TRK detector
-template <int NLayers = 11>
-class TimeFrame : public o2::its::TimeFrame<NLayers>
-{
- public:
-  TimeFrame() = default;
-  ~TimeFrame() override = default;
-
-  /// Override methods if needed for TRK-specific behavior
-  /// For now, we inherit all functionality from ITS TimeFrame
-
-  /// Process hits from TTree to initialize ROFs
-  /// \param hitsTree Tree containing TRK hits
-  /// \param gman TRK geometry manager instance
-  /// \param config Configuration parameters for hit reconstruction
-  int loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config);
-
-  /// Add primary vertices from MC headers for each ROF
-  /// \param mcHeaderTree Tree containing MC event headers
-  /// \param nRofs Number of ROFs (Read-Out Frames)
-  /// \param nEvents Number of events to process
-  /// \param inROFpileup Number of events per ROF
-  /// \param rofLength ROF length in BCs (must match what was used in loadROFsFromHitTree)
-  void getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup, uint32_t rofLength = 198);
-};
-
-} // namespace trk
-} // namespace o2
-
-#endif // ALICEO2_TRK_TIMEFRAME_H
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
index e0d689e4db5ed..d60d6900657ba 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/Clusterer.cxx
@@ -14,6 +14,7 @@
 
 #include "TRKReconstruction/Clusterer.h"
 #include "TRKBase/GeometryTGeo.h"
+#include "TRKBase/SegmentationChip.h"
 
 #include <algorithm>
 #include <numeric>
@@ -21,6 +22,51 @@
 namespace o2::trk
 {
 
+//__________________________________________________
+o2::math_utils::Point3D<float> Clusterer::getClusterLocalCoordinates(const Cluster& cluster, const uint8_t* patt,
+                                                                     float yPlaneMLOT) noexcept
+{
+  const uint8_t rowSpan = *patt++;
+  const uint8_t colSpan = *patt++;
+  const int nBytes = (rowSpan * colSpan + 7) / 8;
+
+  float cogDr{0.f}, cogDc{0.f};
+  int nPix{0}, pixIdx{0};
+  for (int ib = 0; ib < nBytes; ib++) {
+    const uint8_t byte = *patt++;
+    for (int bit = 7; bit >= 0 && pixIdx < rowSpan * colSpan; bit--, pixIdx++) {
+      if (byte & (1 << bit)) {
+        cogDr += pixIdx / colSpan;
+        cogDc += pixIdx % colSpan;
+        nPix++;
+      }
+    }
+  }
+  if (nPix > 1) {
+    cogDr /= nPix;
+    cogDc /= nPix;
+  }
+
+  float x{0.f}, y{0.f}, z{0.f};
+  SegmentationChip::detectorToLocalUnchecked(cluster.row, cluster.col, x, z,
+                                             cluster.subDetID, cluster.layer, cluster.disk);
+
+  const float pitchRow = (cluster.subDetID == 0) ? SegmentationChip::PitchRowVD : SegmentationChip::PitchRowMLOT;
+  const float pitchCol = (cluster.subDetID == 0) ? SegmentationChip::PitchColVD : SegmentationChip::PitchColMLOT;
+  x -= cogDr * pitchRow;
+  z += cogDc * pitchCol;
+
+  if (cluster.subDetID == 0) {
+    auto cv = SegmentationChip::flatToCurved(cluster.layer, x, 0.f);
+    x = cv.X();
+    y = cv.Y();
+  } else {
+    y = yPlaneMLOT;
+  }
+
+  return {x, y, z};
+}
+
 //__________________________________________________
 void Clusterer::process(gsl::span<const Digit> digits,
                         gsl::span<const DigROFRecord> digitROFs,
@@ -28,7 +74,9 @@ void Clusterer::process(gsl::span<const Digit> digits,
                         std::vector<unsigned char>& patterns,
                         std::vector<o2::trk::ROFRecord>& clusterROFs,
                         const ConstDigitTruth* digitLabels,
-                        ClusterTruth* clusterLabels)
+                        ClusterTruth* clusterLabels,
+                        gsl::span<const DigMC2ROFRecord> digMC2ROFs,
+                        std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs)
 {
   if (!mThread) {
     mThread = std::make_unique<ClustererThread>(this);
@@ -79,6 +127,13 @@ void Clusterer::process(gsl::span<const Digit> digits,
     clusterROFs.emplace_back(inROF.getBCData(), inROF.getROFrame(),
                              outFirst, static_cast<int>(clusters.size()) - outFirst);
   }
+
+  if (clusterMC2ROFs && !digMC2ROFs.empty()) {
+    clusterMC2ROFs->reserve(clusterMC2ROFs->size() + digMC2ROFs.size());
+    for (const auto& in : digMC2ROFs) {
+      clusterMC2ROFs->emplace_back(in.eventRecordID, in.rofRecordID, in.minROF, in.maxROF);
+    }
+  }
 }
 
 //__________________________________________________
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
index b764fcdd1cd79..2dbf56ae610e3 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
@@ -162,7 +162,9 @@ void ClustererACTS::process(gsl::span<const Digit> digits,
                             std::vector<unsigned char>& patterns,
                             std::vector<o2::trk::ROFRecord>& clusterROFs,
                             const ConstDigitTruth* digitLabels,
-                            ClusterTruth* clusterLabels)
+                            ClusterTruth* clusterLabels,
+                            gsl::span<const DigMC2ROFRecord> digMC2ROFs,
+                            std::vector<o2::trk::MC2ROFRecord>* clusterMC2ROFs)
 {
   if (!mThread) {
     mThread = std::make_unique<ClustererThread>(this);
diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
deleted file mode 100644
index 957560aea8cae..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/TimeFrame.cxx
+++ /dev/null
@@ -1,225 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-///
-/// \file TimeFrame.cxx
-/// \brief TRK TimeFrame implementation
-///
-
-#include "TRKReconstruction/TimeFrame.h"
-#include "TRKSimulation/Hit.h"
-#include "TRKBase/GeometryTGeo.h"
-#include "Framework/Logger.h"
-#include "SimulationDataFormat/MCEventHeader.h"
-#include <TTree.h>
-#include <TRandom3.h>
-#include <vector>
-#include <array>
-
-using o2::its::clearResizeBoundedVector;
-
-namespace o2::trk
-{
-
-template <int NLayers>
-int TimeFrame<NLayers>::loadROFsFromHitTree(TTree* hitsTree, GeometryTGeo* gman, const nlohmann::json& config)
-{
-  constexpr std::array<int, 2> startLayer{0, 3};
-  const Long64_t nEvents = hitsTree->GetEntries();
-
-  gman->fillMatrixCache(o2::math_utils::bit2Mask(o2::math_utils::TransformType::T2L) | o2::math_utils::bit2Mask(o2::math_utils::TransformType::L2G));
-
-  std::vector<o2::trk::Hit>* trkHit = nullptr;
-  hitsTree->SetBranchAddress("TRKHit", &trkHit);
-
-  const int inROFpileup{config.contains("inROFpileup") ? config["inROFpileup"].get<int>() : 1};
-
-  // Calculate number of ROFs
-  const int nRofs = (nEvents + inROFpileup - 1) / inROFpileup;
-
-  // Set up ROF timing for all layers (no staggering in TRK simulation, all layers read out together)
-  constexpr uint32_t rofLength = 198; // ROF length in BC
-  o2::its::ROFOverlapTable<NLayers> overlapTable;
-  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
-    overlapTable.defineLayer(iLayer, nRofs, rofLength, 0, 0, 0);
-  }
-  overlapTable.init();
-  this->setROFOverlapTable(overlapTable);
-
-  // Set up the vertex lookup table timing (pre-allocate, vertices will be filled later)
-  o2::its::ROFVertexLookupTable<NLayers> vtxLookupTable;
-  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
-    vtxLookupTable.defineLayer(iLayer, nRofs, rofLength, 0, 0, 0);
-  }
-  vtxLookupTable.init(); // pre-allocate without vertices
-  this->setROFVertexLookupTable(vtxLookupTable);
-
-  // Reset and prepare ROF data structures
-  for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
-    this->mMinR[iLayer] = std::numeric_limits<float>::max();
-    this->mMaxR[iLayer] = std::numeric_limits<float>::lowest();
-    this->mROFramesClusters[iLayer].clear();
-    this->mROFramesClusters[iLayer].resize(nRofs + 1, 0);
-    this->mUnsortedClusters[iLayer].clear();
-    this->mTrackingFrameInfo[iLayer].clear();
-    this->mClusterExternalIndices[iLayer].clear();
-  }
-
-  // Pre-count hits to reserve memory efficiently
-  std::array<int, NLayers> clusterCountPerLayer{};
-  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
-    hitsTree->GetEntry(iEvent);
-    for (const auto& hit : *trkHit) {
-      if (gman->getDisk(hit.GetDetectorID()) != -1) {
-        continue; // skip non-barrel hits
-      }
-      int subDetID = gman->getSubDetID(hit.GetDetectorID());
-      const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
-      if (layer >= NLayers) {
-        continue;
-      }
-      ++clusterCountPerLayer[layer];
-    }
-  }
-
-  // Reserve memory for all layers (mClusterSize is now per-layer)
-  for (int iLayer{0}; iLayer < NLayers; ++iLayer) {
-    this->mUnsortedClusters[iLayer].reserve(clusterCountPerLayer[iLayer]);
-    this->mTrackingFrameInfo[iLayer].reserve(clusterCountPerLayer[iLayer]);
-    this->mClusterExternalIndices[iLayer].reserve(clusterCountPerLayer[iLayer]);
-    clearResizeBoundedVector(this->mClusterSize[iLayer], clusterCountPerLayer[iLayer], this->mMemoryPool.get());
-  }
-
-  std::array<float, 11> resolution{0.001, 0.001, 0.001, 0.001, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004};
-  if (config["geometry"]["pitch"].size() == static_cast<size_t>(NLayers)) {
-    for (size_t iLayer{0}; iLayer < config["geometry"]["pitch"].size(); ++iLayer) {
-      LOGP(info, "Setting resolution for layer {} from config", iLayer);
-      LOGP(info, "Layer {} pitch {} cm", iLayer, config["geometry"]["pitch"][iLayer].get<float>());
-      resolution[iLayer] = config["geometry"]["pitch"][iLayer].get<float>() / std::sqrt(12.f);
-    }
-  }
-  LOGP(info, "Number of active parts in VD: {}", gman->getNumberOfActivePartsVD());
-
-  // One shared MC label container for all layers
-  auto* labels = new dataformats::MCTruthContainer<MCCompLabel>();
-
-  int hitCounter{0};
-  int iRof{0}; // Current ROF index
-  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
-    hitsTree->GetEntry(iEvent);
-
-    for (auto& hit : *trkHit) {
-      if (gman->getDisk(hit.GetDetectorID()) != -1) {
-        continue; // skip non-barrel hits for this test
-      }
-      int subDetID = gman->getSubDetID(hit.GetDetectorID());
-      const int layer = startLayer[subDetID] + gman->getLayer(hit.GetDetectorID());
-
-      float alpha{0.f};
-      o2::math_utils::Point3D<float> gloXYZ;
-      o2::math_utils::Point3D<float> trkXYZ;
-      float r{0.f};
-      if (layer >= NLayers) {
-        continue;
-      }
-      if (layer >= 3) {
-        int chipID = hit.GetDetectorID();
-        alpha = gman->getSensorRefAlphaMLOT(chipID);
-        const o2::math_utils::Transform3D& l2g = gman->getMatrixL2G(chipID);
-        auto locXYZ = l2g ^ (hit.GetPos());
-        locXYZ.SetX(locXYZ.X() + gRandom->Gaus(0.0, resolution[layer]));
-        locXYZ.SetZ(locXYZ.Z() + gRandom->Gaus(0.0, resolution[layer]));
-        gloXYZ = gman->getMatrixL2G(chipID) * locXYZ;
-        trkXYZ = gman->getMatrixT2L(chipID - gman->getNumberOfActivePartsVD()) ^ locXYZ;
-        r = std::hypot(gloXYZ.X(), gloXYZ.Y());
-      } else {
-        const auto& hitPos = hit.GetPos();
-        r = std::hypot(hitPos.X(), hitPos.Y());
-        alpha = std::atan2(hitPos.Y(), hitPos.X()) + gRandom->Gaus(0.0, resolution[layer] / r);
-        o2::math_utils::bringTo02Pi(alpha);
-        gloXYZ.SetX(r * std::cos(alpha));
-        gloXYZ.SetY(r * std::sin(alpha));
-        gloXYZ.SetZ(hitPos.Z() + gRandom->Gaus(0.0, resolution[layer]));
-        trkXYZ.SetX(r);
-        trkXYZ.SetY(0.f);
-        trkXYZ.SetZ(gloXYZ.Z());
-      }
-      this->mMinR[layer] = std::min(this->mMinR[layer], r);
-      this->mMaxR[layer] = std::max(this->mMaxR[layer], r);
-      this->addTrackingFrameInfoToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), trkXYZ.x(), alpha,
-                                        std::array<float, 2>{trkXYZ.y(), trkXYZ.z()},
-                                        std::array<float, 3>{resolution[layer] * resolution[layer], 0., resolution[layer] * resolution[layer]});
-      /// Rotate to the global frame
-      const int clusterIdxInLayer = this->mUnsortedClusters[layer].size();
-      this->addClusterToLayer(layer, gloXYZ.x(), gloXYZ.y(), gloXYZ.z(), clusterIdxInLayer);
-      this->addClusterExternalIndexToLayer(layer, hitCounter);
-      MCCompLabel label{hit.GetTrackID(), static_cast<int>(iEvent), 0};
-      labels->addElement(hitCounter, label);
-      this->mClusterSize[layer][clusterIdxInLayer] = 1;
-      hitCounter++;
-    }
-    trkHit->clear();
-
-    // Update ROF structure when we complete an ROF or reach the last event
-    if ((iEvent + 1) % inROFpileup == 0 || iEvent == nEvents - 1) {
-      iRof++;
-      for (unsigned int iLayer{0}; iLayer < this->mUnsortedClusters.size(); ++iLayer) {
-        this->mROFramesClusters[iLayer][iRof] = this->mUnsortedClusters[iLayer].size(); // effectively calculating an exclusive sum
-      }
-    }
-  }
-
-  // Set the shared labels container for all layers
-  for (int iLayer = 0; iLayer < NLayers; ++iLayer) {
-    this->mClusterLabels[iLayer] = labels;
-  }
-
-  return nRofs;
-}
-
-template <int NLayers>
-void TimeFrame<NLayers>::getPrimaryVerticesFromMC(TTree* mcHeaderTree, int nRofs, Long64_t nEvents, int inROFpileup, uint32_t rofLength)
-{
-  auto mcheader = new o2::dataformats::MCEventHeader;
-  mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
-
-  this->mPrimaryVertices.clear();
-
-  int iRof{0};
-  for (Long64_t iEvent = 0; iEvent < nEvents; ++iEvent) {
-    mcHeaderTree->GetEntry(iEvent);
-    o2::its::Vertex vertex;
-    vertex.setXYZ(mcheader->GetX(), mcheader->GetY(), mcheader->GetZ());
-    vertex.setNContributors(30);
-    vertex.setChi2(0.f);
-
-    // Set proper BC timestamp for vertex-ROF compatibility
-    // The vertex timestamp is set to the center of its ROF with half-ROF as error
-    const uint32_t rofCenter = static_cast<uint32_t>(rofLength * iRof + rofLength / 2);
-    const uint16_t rofHalf = static_cast<uint16_t>(rofLength / 2);
-    vertex.setTimeStamp({rofCenter, rofHalf});
-
-    LOGP(debug, "ROF {}: Added primary vertex at ({}, {}, {}) with BC timestamp [{}, +/-{}]",
-         iRof, mcheader->GetX(), mcheader->GetY(), mcheader->GetZ(), rofCenter, rofHalf);
-    this->addPrimaryVertex(vertex);
-    if ((iEvent + 1) % inROFpileup == 0 || iEvent == nEvents - 1) {
-      iRof++;
-    }
-  }
-  this->mMultiplicityCutMask.resetMask(1u); /// all ROFs are valid with MC primary vertices.
-
-  // Update the vertex lookup table with the newly added vertices
-  this->updateROFVertexLookupTable();
-}
-
-// Explicit template instantiation for TRK with 11 layers
-template class TimeFrame<11>;
-
-} // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
index 42402fe6b62dc..e3309d78f47ea 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/CMakeLists.txt
@@ -15,8 +15,6 @@ o2_add_library(TRKWorkflow
                        src/DigitWriterSpec.cxx
                        src/ClustererSpec.cxx
                        src/ClusterWriterSpec.cxx
-                       src/TrackerSpec.cxx
-                       src/TrackWriterSpec.cxx
                        src/RecoWorkflow.cxx
                PUBLIC_LINK_LIBRARIES O2::Framework
                                      O2::GPUWorkflow
@@ -35,5 +33,4 @@ o2_add_executable(reco-workflow
                   COMPONENT_NAME alice3-trk
                   PUBLIC_LINK_LIBRARIES O2::TRKWorkflow
                                         O2::TRKSimulation
-                                        O2::TRKReconstruction
-                                        O2::ITStracking)
+                                        O2::TRKReconstruction)
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/README.md b/Detectors/Upgrades/ALICE3/TRK/workflow/README.md
index 1cdce15b72726..2afb599319217 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/README.md
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/README.md
@@ -1,130 +1,11 @@
 # TRK Reconstruction Workflow
 
-This document describes how to run the TRK (ALICE 3 Tracker) reconstruction workflow and provides examples of configuration files.
+This workflow handles TRK-local reconstruction devices such as digit reading and clusterization.
 
-## Overview
-
-The TRK reconstruction workflow performs track reconstruction from simulated hits, producing reconstructed tracks with MC truth labels. The workflow currently supports the track reconstruction from hits using the Cellular Automaton (CA) algorithm. The ouput is stored to a ROOT file for offline analysis (example of QA macro provided in `macros/test/CheckTracksCA.C`).
-
-## Quick Start
-
-### Basic Command
+## Basic Command
 
 ```bash
-o2-alice3-trk-reco-workflow --tracking-from-hits-config config_tracker.json -b
-```
-
-### Command Line Options
-
-- `--tracking-from-hits-config <file>`: Path to tracking configuration JSON file (required)
-- `-b`: Batch mode (no GUI)
-- `--disable-root-output`: Skip writing tracks to ROOT file
-- `--help`: Show all available options
-
-## Configuration File
-
-The tracking configuration is provided via a JSON file that specifies:
-1. Input file paths
-2. Geometry parameters (magnetic field, detector pitch)
-3. Tracking algorithm parameters (can specify multiple iterations)
-
-### Example Configuration (`config_tracker.json`)
-
-```json
-{
-  "inputfiles": {
-    "hits": "o2sim_HitsTRK.root",
-    "geometry": "o2sim_geometry.root",
-    "mcHeader": "o2sim_MCHeader.root",
-    "kinematics": "o2sim_Kine.root"
-  },
-  "geometry": {
-    "bz": 5.0,
-    "pitch": [0.001, 0.001, 0.001, 0.001, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004, 0.004]
-  },
-  "trackingparams": [{
-    "NLayers": 11,
-    "DeltaROF": 0,
-    "LayerZ": [25.1, 25.1, 25.1, 64.2, 64.2, 64.2, 64.2, 64.2, 128.5, 128.5, 128.5],
-    "LayerRadii": [0.5, 1.2, 2.5, 7.05, 9.05, 12.05, 20.05, 30.05, 45.05, 60.5, 80.05],
-    "LayerxX0": [0.001, 0.001, 0.001, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
-    "LayerResolution": [0.0003, 0.0003, 0.0003, 0.0003, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012, 0.0012],
-    "SystErrorY2": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
-    "SystErrorZ2": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
-    "ZBins": 256,
-    "PhiBins": 128,
-    "nROFsPerIterations": -1,
-    "UseDiamond": false,
-    "Diamond": [0.0, 0.0, 0.0],
-    "AllowSharingFirstCluster": false,
-    "ClusterSharing": 0,
-    "MinTrackLength": 7,
-    "NSigmaCut": 10,
-    "PVres": 0.01,
-    "TrackletMinPt": 0.1,
-    "TrackletsPerClusterLimit": 2.0,
-    "CellDeltaTanLambdaSigma": 0.007,
-    "CellsPerClusterLimit": 2.0,
-    "MaxChi2ClusterAttachment": 60.0,
-    "MaxChi2NDF": 30.0,
-    "ReseedIfShorter": 6,
-    "MinPt": [0.0, 0.0, 0.0, 0.0],
-    "StartLayerMask": 4095,
-    "RepeatRefitOut": false,
-    "ShiftRefToCluster": true,
-    "FindShortTracks": false,
-    "PerPrimaryVertexProcessing": false,
-    "SaveTimeBenchmarks": false,
-    "DoUPCIteration": false,
-    "FataliseUponFailure": true,
-    "UseTrackFollower": true,
-    "UseTrackFollowerTop": false,
-    "UseTrackFollowerBot": false,
-    "UseTrackFollowerMix": true,
-    "TrackFollowerNSigmaCutZ": 1.0,
-    "TrackFollowerNSigmaCutPhi": 1.0,
-    "createArtefactLabels": false,
-    "PrintMemory": false,
-    "DropTFUponFailure": false
-  }]
-}
+o2-alice3-trk-reco-workflow -b
 ```
-Note that the `trackingparams` field can contain multiple sets of parameters for different iterations of the tracking algorithm. The example above shows a single iteration with 11 layers and it is **not** optimized.
-
-## Complete Workflow Example
 
-### 1. Run Simulation
-
-First, generate simulation data:
-
-```bash
-o2-sim-serial-run5 -n 200 -g pythia8hi -m TRK --configKeyValues "Diamond.width[0]=0.01;Diamond.width[1]=0.01;Diamond.width[2]=5;TRKBase.layoutML=kTurboStaves;TRKBase.layoutOT=kStaggered;"
-```
-
-This produces, among other files:
-- `o2sim_HitsTRK.root`
-- `o2sim_geometry.root`
-- `o2sim_MCHeader.root`
-- `o2sim_Kine.root`
-That will be used by the reconstruction as currently we do not have clusters.
-
-### 2. Run Reconstruction
-
-Execute the tracking workflow:
-
-```bash
-o2-alice3-trk-reco-workflow --tracking-from-hits-config config_tracker.json -b
-```
-
-This produces:
-- `o2trac_trk.root`: Reconstructed tracks with MC labels
-
-### 3. Run Quality Assurance
-
-Analyze the tracking performance:
-
-```bash
-root -l
-.L CheckTracksCA.C+
-CheckTracksCA("o2trac_trk.root", "o2sim_Kine.root", "o2sim_HitsTRK.root", "trk_qa_output.root")
-```
+Use `o2-alice3-global-reconstruction-reco-workflow` for ALICE 3 tracking from hits.
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
index 7046955a20c2e..863c5deae7241 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/include/TRKWorkflow/RecoWorkflow.h
@@ -13,8 +13,6 @@
 #define O2_TRK_RECOWORKFLOW_H
 
 #include "Framework/WorkflowSpec.h"
-#include "GPUDataTypesConfig.h"
-#include <string>
 
 namespace o2::trk
 {
@@ -22,12 +20,9 @@ namespace reco_workflow
 {
 
 o2::framework::WorkflowSpec getWorkflow(bool useMC,
-                                        const std::string& hitRecoConfig,
                                         bool upstreamDigits = false,
                                         bool upstreamClusters = false,
-                                        bool disableRootOutput = false,
-                                        bool useGPUWF = false,
-                                        o2::gpu::gpudatatypes::DeviceType dType = o2::gpu::gpudatatypes::DeviceType::CPU);
+                                        bool disableRootOutput = false);
 }
 
 } // namespace o2::trk
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
index d10feb4214f38..02895f42ac094 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/RecoWorkflow.cxx
@@ -13,8 +13,6 @@
 #include "TRKWorkflow/ClustererSpec.h"
 #include "TRKWorkflow/ClusterWriterSpec.h"
 #include "TRKWorkflow/DigitReaderSpec.h"
-#include "TRKWorkflow/TrackerSpec.h"
-#include "TRKWorkflow/TrackWriterSpec.h"
 #include "Framework/CCDBParamSpec.h"
 
 #include <string>
@@ -23,12 +21,9 @@ namespace o2::trk::reco_workflow
 {
 
 framework::WorkflowSpec getWorkflow(bool useMC,
-                                    const std::string& hitRecoConfig,
                                     bool upstreamDigits,
                                     bool upstreamClusters,
-                                    bool disableRootOutput,
-                                    bool useGPUWF,
-                                    o2::gpu::gpudatatypes::DeviceType dtype)
+                                    bool disableRootOutput)
 {
   framework::WorkflowSpec specs;
 
@@ -43,14 +38,6 @@ framework::WorkflowSpec getWorkflow(bool useMC,
     specs.emplace_back(o2::trk::getClusterWriterSpec(useMC));
   }
 
-  if (!hitRecoConfig.empty()) {
-    LOGP(info, "Using hit reco config from file {}", hitRecoConfig);
-    specs.emplace_back(o2::trk::getTrackerSpec(useMC, hitRecoConfig, dtype));
-    if (!disableRootOutput) {
-      specs.emplace_back(o2::trk::getTrackWriterSpec(useMC));
-    }
-  }
-
   return specs;
 }
 
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
deleted file mode 100644
index cb4cc3897ae9e..0000000000000
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/TrackerSpec.cxx
+++ /dev/null
@@ -1,439 +0,0 @@
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
-#include <vector>
-#include <chrono>
-
-#include "DetectorsBase/GeometryManager.h"
-#include "ITStracking/TimeFrame.h"
-#include "ITStracking/Configuration.h"
-#include "Field/MagneticField.h"
-#include "Field/MagFieldParam.h"
-#include "Framework/ControlService.h"
-#include "Framework/ConfigParamRegistry.h"
-#include "Framework/CCDBParamSpec.h"
-#include "SimulationDataFormat/MCEventHeader.h"
-#include "SimulationDataFormat/MCCompLabel.h"
-#include "TRKBase/GeometryTGeo.h"
-#include "TRKBase/SegmentationChip.h"
-#include "TRKSimulation/Hit.h"
-#include "TRKReconstruction/TimeFrame.h"
-#include "TRKWorkflow/TrackerSpec.h"
-#include <TGeoGlobalMagField.h>
-
-#ifdef O2_WITH_ACTS
-#include "TRKReconstruction/TrackerACTS.h"
-#endif
-
-#include <TFile.h>
-#include <TTree.h>
-
-namespace o2
-{
-using namespace framework;
-namespace trk
-{
-
-TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
-                       bool isMC,
-                       const std::string& hitRecoConfigFileName,
-                       o2::gpu::gpudatatypes::DeviceType dType)
-{
-  if (!hitRecoConfigFileName.empty()) {
-    std::ifstream configFile(hitRecoConfigFileName);
-    mHitRecoConfig = nlohmann::json::parse(configFile);
-  }
-
-  // mITSTrackingInterface.setTrackingMode(trMode);
-}
-
-void TrackerDPL::init(InitContext& ic)
-{
-  // mTimer.Stop();
-  // mTimer.Reset();
-  // o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
-  // mChainITS.reset(mRecChain->AddChain<o2::gpu::GPUChainITS>());
-  // mITSTrackingInterface.setTraitsFromProvider(mChainITS->GetITSVertexerTraits(),
-  //                                             mChainITS->GetITSTrackerTraits(),
-  //                                             mChainITS->GetITSTimeframe());
-
-#ifdef O2_WITH_ACTS
-  mUseACTS = ic.options().get<bool>("useACTS");
-#endif
-}
-
-void TrackerDPL::stop()
-{
-  LOGF(info, "CPU Reconstruction total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
-}
-
-std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromConfig()
-{
-  std::vector<o2::its::TrackingParameters> trackingParams;
-
-  if (!mHitRecoConfig.contains("trackingparams") || !mHitRecoConfig["trackingparams"].is_array()) {
-    LOGP(fatal, "No trackingparams field found in configuration or it is not an array. Returning empty vector.");
-    return trackingParams;
-  }
-
-  for (const auto& paramConfig : mHitRecoConfig["trackingparams"]) {
-    o2::its::TrackingParameters params;
-
-    // Parse integer parameters
-    if (paramConfig.contains("NLayers")) {
-      params.NLayers = paramConfig["NLayers"].get<int>();
-    }
-    if (paramConfig.contains("ZBins")) {
-      params.ZBins = paramConfig["ZBins"].get<int>();
-    }
-    if (paramConfig.contains("PhiBins")) {
-      params.PhiBins = paramConfig["PhiBins"].get<int>();
-    }
-    if (paramConfig.contains("ClusterSharing")) {
-      params.ClusterSharing = paramConfig["ClusterSharing"].get<int>();
-    }
-    if (paramConfig.contains("MinTrackLength")) {
-      params.MinTrackLength = paramConfig["MinTrackLength"].get<int>();
-    }
-    if (paramConfig.contains("ReseedIfShorter")) {
-      params.ReseedIfShorter = paramConfig["ReseedIfShorter"].get<int>();
-    }
-    if (paramConfig.contains("StartLayerMask")) {
-      params.StartLayerMask = paramConfig["StartLayerMask"].get<uint16_t>();
-    }
-
-    // Parse float parameters
-    if (paramConfig.contains("NSigmaCut")) {
-      params.NSigmaCut = paramConfig["NSigmaCut"].get<float>();
-    }
-    if (paramConfig.contains("PVres")) {
-      params.PVres = paramConfig["PVres"].get<float>();
-    }
-    if (paramConfig.contains("TrackletMinPt")) {
-      params.TrackletMinPt = paramConfig["TrackletMinPt"].get<float>();
-    }
-    if (paramConfig.contains("CellDeltaTanLambdaSigma")) {
-      params.CellDeltaTanLambdaSigma = paramConfig["CellDeltaTanLambdaSigma"].get<float>();
-    }
-    if (paramConfig.contains("MaxChi2ClusterAttachment")) {
-      params.MaxChi2ClusterAttachment = paramConfig["MaxChi2ClusterAttachment"].get<float>();
-    }
-    if (paramConfig.contains("MaxChi2NDF")) {
-      params.MaxChi2NDF = paramConfig["MaxChi2NDF"].get<float>();
-    }
-    // if (paramConfig.contains("TrackFollowerNSigmaCutZ")) {
-    //   params.TrackFollowerNSigmaCutZ = paramConfig["TrackFollowerNSigmaCutZ"].get<float>();
-    // }
-    // if (paramConfig.contains("TrackFollowerNSigmaCutPhi")) {
-    //   params.TrackFollowerNSigmaCutPhi = paramConfig["TrackFollowerNSigmaCutPhi"].get<float>();
-    // }
-
-    // Parse boolean parameters
-    if (paramConfig.contains("UseDiamond")) {
-      params.UseDiamond = paramConfig["UseDiamond"].get<bool>();
-    }
-    if (paramConfig.contains("AllowSharingFirstCluster")) {
-      params.AllowSharingFirstCluster = paramConfig["AllowSharingFirstCluster"].get<bool>();
-    }
-    if (paramConfig.contains("RepeatRefitOut")) {
-      params.RepeatRefitOut = paramConfig["RepeatRefitOut"].get<bool>();
-    }
-    if (paramConfig.contains("ShiftRefToCluster")) {
-      params.ShiftRefToCluster = paramConfig["ShiftRefToCluster"].get<bool>();
-    }
-    // if (paramConfig.contains("FindShortTracks")) {
-    //   params.FindShortTracks = paramConfig["FindShortTracks"].get<bool>();
-    // }
-    if (paramConfig.contains("PerPrimaryVertexProcessing")) {
-      params.PerPrimaryVertexProcessing = paramConfig["PerPrimaryVertexProcessing"].get<bool>();
-    }
-    if (paramConfig.contains("SaveTimeBenchmarks")) {
-      params.SaveTimeBenchmarks = paramConfig["SaveTimeBenchmarks"].get<bool>();
-    }
-    if (paramConfig.contains("DoUPCIteration")) {
-      params.DoUPCIteration = paramConfig["DoUPCIteration"].get<bool>();
-    }
-    if (paramConfig.contains("FataliseUponFailure")) {
-      params.FataliseUponFailure = paramConfig["FataliseUponFailure"].get<bool>();
-    }
-    // if (paramConfig.contains("UseTrackFollower")) {
-    //   params.UseTrackFollower = paramConfig["UseTrackFollower"].get<bool>();
-    // }
-    // if (paramConfig.contains("UseTrackFollowerTop")) {
-    //   params.UseTrackFollowerTop = paramConfig["UseTrackFollowerTop"].get<bool>();
-    // }
-    // if (paramConfig.contains("UseTrackFollowerBot")) {
-    //   params.UseTrackFollowerBot = paramConfig["UseTrackFollowerBot"].get<bool>();
-    // }
-    // if (paramConfig.contains("UseTrackFollowerMix")) {
-    //   params.UseTrackFollowerMix = paramConfig["UseTrackFollowerMix"].get<bool>();
-    // }
-    if (paramConfig.contains("createArtefactLabels")) {
-      params.CreateArtefactLabels = paramConfig["createArtefactLabels"].get<bool>();
-    }
-    if (paramConfig.contains("PrintMemory")) {
-      params.PrintMemory = paramConfig["PrintMemory"].get<bool>();
-    }
-    if (paramConfig.contains("DropTFUponFailure")) {
-      params.DropTFUponFailure = paramConfig["DropTFUponFailure"].get<bool>();
-    }
-
-    // Parse vector parameters
-    if (paramConfig.contains("LayerZ")) {
-      params.LayerZ = paramConfig["LayerZ"].get<std::vector<float>>();
-    }
-    if (paramConfig.contains("LayerRadii")) {
-      params.LayerRadii = paramConfig["LayerRadii"].get<std::vector<float>>();
-    }
-    if (paramConfig.contains("LayerxX0")) {
-      params.LayerxX0 = paramConfig["LayerxX0"].get<std::vector<float>>();
-    }
-    if (paramConfig.contains("LayerResolution")) {
-      params.LayerResolution = paramConfig["LayerResolution"].get<std::vector<float>>();
-    }
-    if (paramConfig.contains("SystErrorY2")) {
-      params.SystErrorY2 = paramConfig["SystErrorY2"].get<std::vector<float>>();
-    }
-    if (paramConfig.contains("SystErrorZ2")) {
-      params.SystErrorZ2 = paramConfig["SystErrorZ2"].get<std::vector<float>>();
-    }
-    if (paramConfig.contains("MinPt")) {
-      params.MinPt = paramConfig["MinPt"].get<std::vector<float>>();
-    }
-
-    // Parse Diamond array
-    if (paramConfig.contains("Diamond") && paramConfig["Diamond"].is_array() && paramConfig["Diamond"].size() == 3) {
-      params.Diamond[0] = paramConfig["Diamond"][0].get<float>();
-      params.Diamond[1] = paramConfig["Diamond"][1].get<float>();
-      params.Diamond[2] = paramConfig["Diamond"][2].get<float>();
-    }
-
-    // Parse size_t parameter
-    if (paramConfig.contains("MaxMemory")) {
-      params.MaxMemory = paramConfig["MaxMemory"].get<size_t>();
-    }
-
-    // Parse CorrType enum
-    if (paramConfig.contains("CorrType")) {
-      int corrTypeInt = paramConfig["CorrType"].get<int>();
-      params.CorrType = static_cast<o2::base::PropagatorImpl<float>::MatCorrType>(corrTypeInt);
-    }
-
-    trackingParams.push_back(params);
-  }
-
-  LOGP(info, "Loaded {} tracking parameter sets from configuration", trackingParams.size());
-  return trackingParams;
-}
-
-void TrackerDPL::run(ProcessingContext& pc)
-{
-  auto cput = mTimer.CpuTime();
-  auto realt = mTimer.RealTime();
-  mTimer.Start(false);
-
-  if (!mHitRecoConfig.empty()) {
-    TFile hitsFile(mHitRecoConfig["inputfiles"]["hits"].get<std::string>().c_str(), "READ");
-    TFile mcHeaderFile(mHitRecoConfig["inputfiles"]["mcHeader"].get<std::string>().c_str(), "READ");
-    TTree* hitsTree = hitsFile.Get<TTree>("o2sim");
-    std::vector<o2::trk::Hit>* trkHit = nullptr;
-    hitsTree->SetBranchAddress("TRKHit", &trkHit);
-
-    TTree* mcHeaderTree = mcHeaderFile.Get<TTree>("o2sim");
-    auto mcheader = new o2::dataformats::MCEventHeader;
-    mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
-
-    o2::base::GeometryManager::loadGeometry(mHitRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
-    auto* gman = o2::trk::GeometryTGeo::Instance();
-
-    const Long64_t nEvents{hitsTree->GetEntries()};
-    LOGP(info, "Starting reconstruction from hits for {} events", nEvents);
-
-    if (mMemoryPool.get() == nullptr) {
-      mMemoryPool = std::make_shared<its::BoundedMemoryResource>();
-    }
-    if (mTaskArena.get() == nullptr) {
-      mTaskArena = std::make_shared<tbb::task_arena>(1); /// TODO: make it configurable
-    }
-
-    o2::trk::TimeFrame<11> timeFrame;
-    o2::its::TrackerTraits<11> itsTrackerTraits;
-    o2::its::Tracker<11> itsTracker(&itsTrackerTraits);
-    timeFrame.setMemoryPool(mMemoryPool);
-    itsTrackerTraits.setMemoryPool(mMemoryPool);
-    itsTrackerTraits.setNThreads(mTaskArena->max_concurrency(), mTaskArena);
-    itsTrackerTraits.adoptTimeFrame(static_cast<o2::its::TimeFrame<11>*>(&timeFrame));
-    itsTrackerTraits.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
-    auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mHitRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
-    TGeoGlobalMagField::Instance()->SetField(field);
-    TGeoGlobalMagField::Instance()->Lock();
-    itsTracker.adoptTimeFrame(timeFrame);
-
-    const int nRofs = timeFrame.loadROFsFromHitTree(hitsTree, gman, mHitRecoConfig);
-    const int inROFpileup{mHitRecoConfig.contains("inROFpileup") ? mHitRecoConfig["inROFpileup"].get<int>() : 1};
-
-    // Add primary vertices from MC headers for each ROF
-    timeFrame.getPrimaryVerticesFromMC(mcHeaderTree, nRofs, nEvents, inROFpileup);
-    // Create tracking parameters from config and set them in the time frame
-    auto trackingParams = createTrackingParamsFromConfig();
-
-    itsTrackerTraits.updateTrackingParameters(trackingParams);
-
-#ifdef O2_WITH_ACTS
-    if (mUseACTS) {
-      LOG(info) << "Running the tracking with ACTS";
-      o2::trk::TrackerACTS<11> actsTracker;
-      actsTracker.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
-      actsTracker.adoptTimeFrame(timeFrame);
-      actsTracker.clustersToTracks();
-    }
-#endif
-
-    const auto trackingLoopStart = std::chrono::steady_clock::now();
-    for (size_t iter{0}; iter < trackingParams.size(); ++iter) {
-      LOGP(info, "{}", trackingParams[iter].asString());
-      timeFrame.initialise(trackingParams[iter], 11);
-      itsTrackerTraits.computeLayerTracklets(iter, -1);
-      LOGP(info, "Number of tracklets in iteration {}: {}", iter, timeFrame.getNumberOfTracklets());
-      itsTrackerTraits.computeLayerCells(iter);
-      LOGP(info, "Number of cells in iteration {}: {}", iter, timeFrame.getNumberOfCells());
-      itsTrackerTraits.findCellsNeighbours(iter);
-      LOGP(info, "Number of cell neighbours in iteration {}: {}", iter, timeFrame.getNumberOfNeighbours());
-      itsTrackerTraits.findRoads(iter);
-      LOGP(info, "Number of tracks in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
-    }
-    const auto trackingLoopElapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - trackingLoopStart).count();
-    LOGP(info, "Tracking iterations block took {} ms", trackingLoopElapsedMs);
-
-    itsTracker.computeTracksMClabels();
-
-    // Collect tracks and labels (flat vectors in the new interface)
-    const auto& tracks = timeFrame.getTracks();
-    const auto& labels = timeFrame.getTracksLabel();
-
-    // Copy to output vectors (TrackITSExt -> TrackITS slicing for output compatibility)
-    std::vector<o2::its::TrackITS> allTracks(tracks.begin(), tracks.end());
-    std::vector<o2::MCCompLabel> allLabels(labels.begin(), labels.end());
-
-    int totalTracks = allTracks.size();
-    int goodTracks = 0;
-    int fakeTracks = 0;
-
-    for (const auto& label : allLabels) {
-      if (label.isFake()) {
-        fakeTracks++;
-      } else {
-        goodTracks++;
-      }
-    }
-
-    LOGP(info, "=== Tracking Summary ===");
-    LOGP(info, "Total tracks reconstructed: {}", totalTracks);
-    LOGP(info, "Good tracks: {} ({:.1f}%)", goodTracks, totalTracks > 0 ? 100.0 * goodTracks / totalTracks : 0);
-    LOGP(info, "Fake tracks: {} ({:.1f}%)", fakeTracks, totalTracks > 0 ? 100.0 * fakeTracks / totalTracks : 0);
-
-    // Stream tracks and labels to DPL output
-    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKS", 0}, allTracks);
-    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSMCTR", 0}, allLabels);
-
-    LOGP(info, "Tracks and MC labels streamed to output");
-
-    pc.services().get<o2::framework::ControlService>().endOfStream();
-    pc.services().get<o2::framework::ControlService>().readyToQuit(framework::QuitRequest::Me);
-  }
-
-  mTimer.Stop();
-  LOGP(info, "CPU Reconstruction time for this TF {} s (cpu), {} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
-}
-
-// void TrackerDPL::finaliseCCDB(ConcreteDataMatcher& matcher, void* obj)
-// {
-//   // mITSTrackingInterface.finaliseCCDB(matcher, obj);
-// }
-
-void TrackerDPL::endOfStream(EndOfStreamContext& ec)
-{
-  LOGF(info, "TRK CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
-}
-
-DataProcessorSpec getTrackerSpec(bool useMC, const std::string& hitRecoConfig, o2::gpu::gpudatatypes::DeviceType dType)
-{
-  std::vector<InputSpec> inputs;
-  std::vector<OutputSpec> outputs;
-  outputs.emplace_back("TRK", "TRACKS", 0, Lifetime::Timeframe);
-  auto ggRequest = std::make_shared<o2::base::GRPGeomRequest>(false,                          // orbitResetTime
-                                                              false,                          // GRPECS=true
-                                                              false,                          // GRPLHCIF
-                                                              false,                          // GRPMagField
-                                                              false,                          // askMatLUT
-                                                              o2::base::GRPGeomRequest::None, // geometry, but ignored until it will be put in the CCDB
-                                                              inputs,
-                                                              true);
-
-  if (!hitRecoConfig.empty()) {
-    outputs.emplace_back("TRK", "TRACKSMCTR", 0, Lifetime::Timeframe);
-    return DataProcessorSpec{
-      "trk-hits-tracker",
-      {},
-      outputs,
-      AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
-                                              useMC,
-                                              hitRecoConfig,
-                                              dType)},
-      Options{ConfigParamSpec{"max-loops", VariantType::Int, 1, {"max number of loops"}}
-#ifdef O2_WITH_ACTS
-              ,
-              {"useACTS", o2::framework::VariantType::Bool, false, {"Use ACTS for tracking"}}
-#endif
-      }};
-  }
-
-  inputs.emplace_back("dummy", "TRK", "DUMMY", 0, Lifetime::Timeframe);
-
-  constexpr bool expectClusterInputs = false;
-  if (expectClusterInputs) {
-    inputs.pop_back();
-    inputs.emplace_back("compClusters", "TRK", "COMPCLUSTERS", 0, Lifetime::Timeframe);
-    inputs.emplace_back("patterns", "TRK", "PATTERNS", 0, Lifetime::Timeframe);
-    inputs.emplace_back("ROframes", "TRK", "CLUSTERSROF", 0, Lifetime::Timeframe);
-  }
-
-  // inputs.emplace_back("itscldict", "TRK", "CLUSDICT", 0, Lifetime::Condition, ccdbParamSpec("ITS/Calib/ClusterDictionary"));
-  // inputs.emplace_back("TRK_almiraparam", "TRK", "ALMIRAPARAM", 0, Lifetime::Condition, ccdbParamSpec("TRK/Config/AlmiraParam"));
-
-  // outputs.emplace_back("TRK", "TRACKCLSID", 0, Lifetime::Timeframe);
-  // outputs.emplace_back("TRK", "TRKTrackROF", 0, Lifetime::Timeframe);
-  // outputs.emplace_back("TRK", "VERTICES", 0, Lifetime::Timeframe);
-  // outputs.emplace_back("TRK", "VERTICESROF", 0, Lifetime::Timeframe);
-  // outputs.emplace_back("TRK", "IRFRAMES", 0, Lifetime::Timeframe);
-
-  if (useMC) {
-    // inputs.emplace_back("trkmclabels", "TRK", "CLUSTERSMCTR", 0, Lifetime::Timeframe);
-    // inputs.emplace_back("TRKMC2ROframes", "TRK", "CLUSTERSMC2ROF", 0, Lifetime::Timeframe);
-    // outputs.emplace_back("TRK", "VERTICESMCTR", 0, Lifetime::Timeframe);
-    // outputs.emplace_back("TRK", "VERTICESMCPUR", 0, Lifetime::Timeframe);
-    // outputs.emplace_back("TRK", "TRACKSMCTR", 0, Lifetime::Timeframe);
-    // outputs.emplace_back("TRK", "TRKTrackMC2ROF", 0, Lifetime::Timeframe);
-  }
-
-  return DataProcessorSpec{
-    "trk-tracker",
-    inputs,
-    outputs,
-    AlgorithmSpec{adaptFromTask<TrackerDPL>(ggRequest,
-                                            useMC,
-                                            hitRecoConfig,
-                                            dType)},
-    Options{}};
-}
-
-} // namespace trk
-} // namespace o2
diff --git a/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx b/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
index 166e6f65b4b2b..bd1d5acc9b9a7 100644
--- a/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/workflow/src/trk-reco-workflow.cxx
@@ -9,21 +9,8 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
-// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
-// All rights not expressly granted are reserved.
-//
-// This software is distributed under the terms of the GNU General Public
-// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
-//
-// In applying this license CERN does not waive the privileges and immunities
-// granted to it by virtue of its status as an Intergovernmental Organization
-// or submit itself to any jurisdiction.
-
 #include "TRKWorkflow/RecoWorkflow.h"
 #include "CommonUtils/ConfigurableParam.h"
-#include "ITStracking/TrackingConfigParam.h"
-#include "ITStracking/Configuration.h"
 
 #include "Framework/CallbacksPolicy.h"
 #include "Framework/ConfigContext.h"
@@ -52,11 +39,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"clusters-from-upstream", VariantType::Bool, false, {"clusters will be provided from upstream, skip clusterizer"}},
     {"disable-root-output", VariantType::Bool, false, {"do not write output root files"}},
     {"disable-mc", VariantType::Bool, false, {"disable MC propagation even if available"}},
-    {"tracking-from-hits-config", VariantType::String, "", {"JSON file with tracking from hits configuration"}},
-    {"disable-tracking", VariantType::Bool, false, {"disable tracking step"}},
-    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}},
-    {"use-gpu-workflow", VariantType::Bool, false, {"use GPU workflow (default: false)"}},
-    {"gpu-device", VariantType::Int, 1, {"use gpu device: CPU=1,CUDA=2,HIP=3 (default: CPU)"}}};
+    {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
   std::swap(workflowOptions, options);
 }
 
@@ -67,9 +50,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
 {
   // Update the (declared) parameters if changed from the command line
   auto useMC = !configcontext.options().get<bool>("disable-mc");
-  auto hitRecoConfig = configcontext.options().get<std::string>("tracking-from-hits-config");
-  auto useGpuWF = configcontext.options().get<bool>("use-gpu-workflow");
-  auto gpuDevice = static_cast<o2::gpu::gpudatatypes::DeviceType>(configcontext.options().get<int>("gpu-device"));
   auto extDigits = configcontext.options().get<bool>("digits-from-upstream");
   auto extClusters = configcontext.options().get<bool>("clusters-from-upstream");
   auto disableRootOutput = configcontext.options().get<bool>("disable-root-output");
@@ -78,5 +58,5 @@ WorkflowSpec defineDataProcessing(ConfigContext const& configcontext)
   // write the configuration used for the reco workflow
   o2::conf::ConfigurableParam::writeINI("o2itsrecoflow_configuration.ini");
 
-  return o2::trk::reco_workflow::getWorkflow(useMC, hitRecoConfig, extDigits, extClusters, disableRootOutput, useGpuWF, gpuDevice);
+  return o2::trk::reco_workflow::getWorkflow(useMC, extDigits, extClusters, disableRootOutput);
 }

From 01f370ca8c4af38375b301e4bb450014fdbfad79 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 13 May 2026 14:12:58 +0200
Subject: [PATCH 1730/1764] DPL: add actual handling of
 --aod-origin-level-mapping (#15396)

---
 Framework/Core/src/Plugin.cxx            | 6 +++++-
 Framework/Core/src/runDataProcessing.cxx | 1 +
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/Framework/Core/src/Plugin.cxx b/Framework/Core/src/Plugin.cxx
index 503133442e794..82599310eafe9 100644
--- a/Framework/Core/src/Plugin.cxx
+++ b/Framework/Core/src/Plugin.cxx
@@ -70,6 +70,10 @@ auto lookForCommandLineAODOptions = [](ConfigParamRegistry& registry, int argc,
       O2_SIGNPOST_EVENT_EMIT(capabilities, sid, "DiscoverAODOptionsInCommandLineCapability", "AOD options found in arguments. Populating from them.");
       return true;
     }
+    if (arg.starts_with("--aod-origin-")) {
+      O2_SIGNPOST_EVENT_EMIT(capabilities, sid, "DiscoverAODOptionsInCommandLineCapability", "AOD options found in arguments. Populating from them.");
+      return true;
+    }
   }
   return false;
 };
@@ -150,7 +154,7 @@ struct DiscoverAODOptionsInCommandLine : o2::framework::ConfigDiscoveryPlugin {
         bool injectOption = true;
         for (size_t i = 0; i < argc; i++) {
           std::string_view arg = argv[i];
-          if (!arg.starts_with("--aod-writer-") && !arg.starts_with("--aod-parent-")) {
+          if (!arg.starts_with("--aod-writer-") && !arg.starts_with("--aod-parent-") && !arg.starts_with("--aod-origin-")) {
             continue;
           }
           std::string key = arg.data() + 2;
diff --git a/Framework/Core/src/runDataProcessing.cxx b/Framework/Core/src/runDataProcessing.cxx
index d012e1656efc4..c58f8e7287b3b 100644
--- a/Framework/Core/src/runDataProcessing.cxx
+++ b/Framework/Core/src/runDataProcessing.cxx
@@ -2052,6 +2052,7 @@ int runStateMachine(DataProcessorSpecs const& workflow,
             "--aod-max-io-rate",
             "--aod-parent-access-level",
             "--aod-parent-base-path-replacement",
+            "--aod-origin-level-mapping",
             "--driver-client-backend",
             "--fairmq-ipc-prefix",
             "--readers",

From f781bf7b234974bd7664399d823e4af3facd0871 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 12 May 2026 14:54:09 +0200
Subject: [PATCH 1731/1764] Throw on the mismatch only if N decoded clusters is
 > N declared

Due to the ensureContinuousROF some stray ROFs with clusters may be eliminated, which was not
accounted in the cluster vector.
---
 .../include/ITSMFTReconstruction/CTFCoder.h          | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
index 4f9bc90c1c758..76ac8878562de 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/CTFCoder.h
@@ -356,8 +356,10 @@ void CTFCoder<N>::decompress(const CompressedClusters& compCl, VROF& rofRecVec,
   assert(chipCount == compCl.header.nChips);
 
   if (clCount != compCl.header.nClusters) {
-    LOG(error) << "expected " << compCl.header.nClusters << " but counted " << clCount << " in ROFRecords";
-    throw std::runtime_error("mismatch between expected and counter number of clusters");
+    LOGP(error, "expected {} but counted {} clusters in {} ROFRecords", compCl.header.nClusters, clCount, compCl.header.nROFs);
+    if (clCount > compCl.header.nClusters) {
+      throw std::runtime_error("mismatch between expected and counter number of clusters");
+    }
   }
 }
 
@@ -456,8 +458,10 @@ void CTFCoder<N>::decompress(const CompressedClusters& compCl, VROF& rofRecVec,
   assert(chipCount == compCl.header.nChips);
 
   if (clCount != compCl.header.nClusters) {
-    LOG(error) << "expected " << compCl.header.nClusters << " but counted " << clCount << " in ROFRecords";
-    throw std::runtime_error("mismatch between expected and counter number of clusters");
+    LOGP(error, "expected {} but counted {} clusters in {} ROFRecords", compCl.header.nClusters, clCount, compCl.header.nROFs);
+    if (clCount > compCl.header.nClusters) {
+      throw std::runtime_error("mismatch between expected and counter number of clusters");
+    }
   }
 }
 

From b9e3cd3b36bc36257f6213cffb2c80c669a8303c Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 12 May 2026 18:40:08 +0200
Subject: [PATCH 1732/1764] Fix clusters/patterns/digits after
 ensureContinuousROF

---
 .../include/ITSMFTReconstruction/Clusterer.h  |  2 +
 .../include/ITSMFTReconstruction/LookUp.h     |  2 +-
 .../include/ITSMFTWorkflow/STFDecoderSpec.h   |  4 +-
 .../common/workflow/src/STFDecoderSpec.cxx    | 93 +++++++++++++++++--
 4 files changed, 91 insertions(+), 10 deletions(-)

diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
index 0bdbb701a9356..dd3052e2cc5bd 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h
@@ -236,6 +236,8 @@ class Clusterer
   ///< load the dictionary of cluster topologies
   void loadDictionary(const std::string& fileName) { mPattIdConverter.loadDictionary(fileName); }
   void setDictionary(const TopologyDictionary* dict) { mPattIdConverter.setDictionary(dict); }
+  const TopologyDictionary& getDictionary() const { return mPattIdConverter.getDictionary(); }
+  auto& getPattIdConverter() const { return mPattIdConverter; }
 
   TStopwatch& getTimer() { return mTimer; }           // cannot be const
   TStopwatch& getTimerMerge() { return mTimerMerge; } // cannot be const
diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/LookUp.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/LookUp.h
index 3537a1f408886..4f84a838efc70 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/LookUp.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/LookUp.h
@@ -43,7 +43,7 @@ class LookUp
   bool isGroup(int id) const { return mDictionary.isGroup(id); }
   int size() const { return mDictionary.getSize(); }
   auto getPattern(int id) const { return mDictionary.getPattern(id); }
-  auto getDictionaty() const { return mDictionary; }
+  auto& getDictionary() const { return mDictionary; }
 
  private:
   TopologyDictionary mDictionary;
diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
index 29b9f75bcbc4e..1739822d121cf 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
@@ -75,7 +75,9 @@ class STFDecoder : public Task
   void finalize();
   void reset();
   std::unique_ptr<o2::itsmft::Clusterer> setupClusterer(const std::string& dictName);
-  void ensureContinuousROF(const std::vector<ROFRecord>& in, std::vector<ROFRecord>& out, int lr, int nROFsTF, const char* name);
+  bool ensureContinuousROF(const std::vector<ROFRecord>& in, std::vector<ROFRecord>& out, int lr, int nROFsTF, const char* name);
+  void rectifyDigits(std::vector<ROFRecord>& rofVec, std::vector<Digit>& digVec);
+  void rectifyClusters(std::vector<ROFRecord>& rofVec, std::vector<CompClusterExt>& clusVec, std::vector<unsigned char>& pattVec);
 
   TStopwatch mTimer;
   bool mDoClusters = false;
diff --git a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
index 3cc88752d290c..cc7200a1120a6 100644
--- a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
@@ -258,10 +258,14 @@ void STFDecoder<Mapping>::run(ProcessingContext& pc)
       }
     }
     if (mDoDigits) {
-      pc.outputs().snapshot(Output{orig, "DIGITS", iLayer}, digVec);
       std::vector<o2::itsmft::ROFRecord> expDigRofVec(nROFsTF);
-      ensureContinuousROF(digROFVec, expDigRofVec, iLayer, nROFsTF, "digits");
-      pc.outputs().snapshot(Output{orig, "DIGITSROF", iLayer}, digROFVec);
+      if (ensureContinuousROF(digROFVec, expDigRofVec, iLayer, nROFsTF, "digits")) {
+        auto oldNDig = digVec.size();
+        rectifyDigits(expDigRofVec, digVec);
+        LOGP(warn, "Rectified {} digits out of original {} on layer {} following ensureContinuousROF", digVec.size(), oldNDig, iLayer);
+      }
+      pc.outputs().snapshot(Output{orig, "DIGITS", iLayer}, digVec);
+      pc.outputs().snapshot(Output{orig, "DIGITSROF", iLayer}, expDigRofVec);
       mEstNDig[iLayer] = std::max(mEstNDig[iLayer], size_t(digVec.size() * 1.2));
       if (mDoCalibData) {
         pc.outputs().snapshot(Output{orig, "GBTCALIB", iLayer}, calVec);
@@ -272,7 +276,11 @@ void STFDecoder<Mapping>::run(ProcessingContext& pc)
 
     if (mDoClusters) { // we are not obliged to create vectors which are not requested, but other devices might not know the options of this one
       std::vector<o2::itsmft::ROFRecord> expClusRofVec(nROFsTF);
-      ensureContinuousROF(clusROFVec, expClusRofVec, iLayer, nROFsTF, "clusters");
+      if (ensureContinuousROF(clusROFVec, expClusRofVec, iLayer, nROFsTF, "clusters")) {
+        auto oldNClus = clusCompVec.size(), oldNPatt = clusPattVec.size();
+        rectifyClusters(expClusRofVec, clusCompVec, clusPattVec);
+        LOGP(warn, "Rectified {} clusters and {} patterns out of original {} and {} on layer {} following ensureContinuousROF", clusCompVec.size(), clusPattVec.size(), oldNClus, oldNPatt, iLayer);
+      }
       pc.outputs().snapshot(Output{orig, "COMPCLUSTERS", iLayer}, clusCompVec);
       pc.outputs().snapshot(Output{orig, "PATTERNS", iLayer}, clusPattVec);
       pc.outputs().snapshot(Output{orig, "CLUSTERSROF", iLayer}, expClusRofVec);
@@ -416,7 +424,7 @@ void STFDecoder<Mapping>::reset()
 
 ///_______________________________________
 template <class Mapping>
-void STFDecoder<Mapping>::ensureContinuousROF(const std::vector<ROFRecord>& rofVec, std::vector<ROFRecord>& expROFVec, int lr, int nROFsTF, const char* name)
+bool STFDecoder<Mapping>::ensureContinuousROF(const std::vector<ROFRecord>& rofVec, std::vector<ROFRecord>& expROFVec, int lr, int nROFsTF, const char* name)
 {
   const auto& par = AlpideParam::Instance();
   // ensure that the rof output is continuous
@@ -465,13 +473,82 @@ void STFDecoder<Mapping>::ensureContinuousROF(const std::vector<ROFRecord>& rofV
       }
     }
   }
-  int prevFirst{0};
+  int prevLast{0};
+  bool reReference = false; // in case a non-last ROF with non-0 entries is removed, ROF references need to be shifted and clusters/digits rewritten
   for (auto& rof : expROFVec) {
     if (rof.getFirstEntry() < 0) {
-      rof.setFirstEntry(prevFirst);
+      rof.setFirstEntry(prevLast);
+    } else if (rof.getFirstEntry() != prevLast) {
+      reReference = true; // there is jump
+    }
+    prevLast = rof.getFirstEntry() + rof.getNEntries();
+  }
+  return reReference;
+}
+
+///_______________________________________
+template <class Mapping>
+void STFDecoder<Mapping>::rectifyDigits(std::vector<ROFRecord>& rofVec, std::vector<Digit>& digVec)
+{
+  // following ensureContinuousROF call some old ROFs might have been dropped, need to rebuild digits vector and rereference ROF
+  std::vector<Digit> digVecTmp;
+  digVecTmp.reserve(digVec.size());
+  auto beg0 = digVec.begin();
+  for (auto& rof : rofVec) {
+    int firstEntry = digVecTmp.size();
+    if (rof.getNEntries()) {
+      auto beg = beg0 + rof.getFirstEntry(), end = beg + rof.getNEntries();
+      std::copy(beg, end, std::back_inserter(digVecTmp));
+    }
+    rof.setFirstEntry(firstEntry);
+  }
+  digVec.swap(digVecTmp);
+}
+
+///_______________________________________
+template <class Mapping>
+void STFDecoder<Mapping>::rectifyClusters(std::vector<ROFRecord>& rofVec, std::vector<CompClusterExt>& clusVec, std::vector<unsigned char>& pattVec)
+{
+  // following ensureContinuousROF call some old ROFs might have been dropped, need to rebuild clusters and patterns vectors and rereference ROF
+  std::vector<CompClusterExt> clusVecTmp;
+  clusVecTmp.reserve(clusVec.size());
+  std::vector<unsigned char> pattVecTmp;
+  pattVecTmp.reserve(pattVec.size());
+  const auto& dict = mClusterer->getDictionary();
+  auto begCl0 = clusVec.begin(), begClForPatt = begCl0;
+  auto pattIt = pattVec.begin();
+
+  auto skipToLastPattern = [&begClForPatt, &pattIt, &dict](const decltype(begCl0) tgt) {
+    while (begClForPatt < tgt) { // iterate clusters skipping their patterns until we reach targed cluster
+      const auto& clp = *begClForPatt;
+      auto pattID = clp.getPatternID();
+      if (pattID == itsmft::CompCluster::InvalidPatternID || dict.isGroup(pattID)) {
+        ClusterPattern::skipPattern(pattIt);
+      }
+      begClForPatt++;
+    }
+  };
+
+  for (auto& rof : rofVec) {
+    int firstEntry = clusVecTmp.size();
+    if (rof.getNEntries()) {
+      auto begClROF = begCl0 + rof.getFirstEntry(), endClROF = begClROF + rof.getNEntries(); // clusters to copy start/end here
+      if (mDoPatterns) {
+        if (begClForPatt > begClROF) { // normally should no happen unless original ROFs were not ordered
+          begClForPatt = begCl0;       // start from the beginning
+        }
+        skipToLastPattern(begClROF); // iterate clusters skipping their patterns until we reach the 1st cluster to be copied
+        auto begPattToCopy = pattIt; // the 1st pattern corresponding to the needed ROF
+        skipToLastPattern(endClROF); // iterate clusters skipping their patterns until we reach the last cluster to be copied
+        std::copy(begPattToCopy, pattIt, std::back_inserter(pattVecTmp));
+      }
+      std::copy(begClROF, endClROF, std::back_inserter(clusVecTmp));
     }
-    prevFirst = rof.getFirstEntry();
+    // copy patterns corresponding to this ROF
+    rof.setFirstEntry(firstEntry);
   }
+  clusVec.swap(clusVecTmp);
+  pattVec.swap(pattVecTmp);
 }
 
 ///_______________________________________

From aafbebfdbc2f211a12d361a901e2fd8da41a27f4 Mon Sep 17 00:00:00 2001
From: Stefano Cannito <143754257+scannito@users.noreply.github.com>
Date: Wed, 13 May 2026 19:54:37 +0200
Subject: [PATCH 1733/1764] [ALICE 3] TRK: Fix sensitive volumes definition for
 FT3  (#15397)

* Fix sensitive volumes name for FT3

* Removed unused variables
---
 .../include/FT3Simulation/Detector.h          |  22 +--
 .../ALICE3/FT3/simulation/src/Detector.cxx    | 126 ++++++++++--------
 2 files changed, 81 insertions(+), 67 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
index 8bc4b7f634d7c..361d94463ef56 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/include/FT3Simulation/Detector.h
@@ -15,16 +15,20 @@
 #ifndef ALICEO2_FT3_DETECTOR_H_
 #define ALICEO2_FT3_DETECTOR_H_
 
-#include <vector>                             // for vector
-#include "DetectorsBase/GeometryManager.h"    // for getSensID
+#include "Rtypes.h" // for Int_t, Double_t, Float_t, Bool_t, etc
+
 #include "DetectorsBase/Detector.h"           // for Detector
+#include "DetectorsBase/GeometryManager.h"    // for getSensID
 #include "DetectorsCommonDataFormats/DetID.h" // for Detector
 #include "ITSMFTSimulation/Hit.h"             // for Hit
-#include "Rtypes.h"                           // for Int_t, Double_t, Float_t, Bool_t, etc
-#include "TArrayD.h"                          // for TArrayD
-#include "TGeoManager.h"                      // for gGeoManager, TGeoManager (ptr only)
-#include "TLorentzVector.h"                   // for TLorentzVector
-#include "TVector3.h"                         // for TVector3
+
+#include "TArrayD.h"        // for TArrayD
+#include "TGeoManager.h"    // for gGeoManager, TGeoManager (ptr only)
+#include "TLorentzVector.h" // for TLorentzVector
+#include "TVector3.h"       // for TVector3
+
+#include <unordered_map>
+#include <vector>
 
 class FairVolume;
 class TGeoVolume;
@@ -111,8 +115,8 @@ class Detector : public o2::base::DetImpl<Detector>
   void buildFT3ScopingV3();
 
  protected:
-  std::vector<Int_t> mLayerID;
   std::array<std::vector<TString>, 2> mLayerName; // Two sets of layer names, one per direction (forward/backward)
+  std::unordered_map<int, int> mActiveSensorMap;
 
  private:
   /// this is transient data about track passing the sensor
@@ -145,7 +149,7 @@ class Detector : public o2::base::DetImpl<Detector>
 
   template <typename Det>
   friend class o2::base::DetImpl;
-  ClassDefOverride(Detector, 1);
+  ClassDefOverride(Detector, 2);
 };
 
 } // namespace o2::ft3
diff --git a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
index 2a9a9633cdd11..1f9f95c1914dd 100644
--- a/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/FT3/simulation/src/Detector.cxx
@@ -12,32 +12,34 @@
 /// \file Detector.cxx
 /// \brief Implementation of the Detector class
 
-#include "ITSMFTSimulation/Hit.h"
-#include "FT3Base/GeometryTGeo.h"
 #include "FT3Simulation/Detector.h"
-#include "FT3Simulation/FT3Layer.h"
-#include "FT3Base/FT3BaseParam.h"
 
 #include "DetectorsBase/Stack.h"
+#include "ITSMFTSimulation/Hit.h"
 #include "SimulationDataFormat/TrackReference.h"
 
+#include "FT3Base/FT3BaseParam.h"
+#include "FT3Base/GeometryTGeo.h"
+#include "FT3Simulation/FT3Layer.h"
+
 // FairRoot includes
-#include "FairDetector.h"      // for FairDetector
-#include <fairlogger/Logger.h> // for LOG, LOG_IF
-#include "FairRootManager.h"   // for FairRootManager
-#include "FairRun.h"           // for FairRun
-#include "FairRuntimeDb.h"     // for FairRuntimeDb
-#include "FairVolume.h"        // for FairVolume
+#include "FairDetector.h"    // for FairDetector
+#include "FairRootManager.h" // for FairRootManager
 #include "FairRootManager.h"
+#include "FairRun.h"       // for FairRun
+#include "FairRuntimeDb.h" // for FairRuntimeDb
+#include "FairVolume.h"    // for FairVolume
 
 #include "TGeoManager.h"     // for TGeoManager, gGeoManager
-#include "TGeoTube.h"        // for TGeoTube
 #include "TGeoPcon.h"        // for TGeoPcon
+#include "TGeoTube.h"        // for TGeoTube
 #include "TGeoVolume.h"      // for TGeoVolume, TGeoVolumeAssembly
 #include "TString.h"         // for TString, operator+
 #include "TVirtualMC.h"      // for gMC, TVirtualMC
 #include "TVirtualMCStack.h" // for TVirtualMCStack
 
+#include <fairlogger/Logger.h> // for LOG, LOG_IF
+
 #include <cstdio> // for NULL, snprintf
 
 #define MAX_SENSORS 2000
@@ -75,7 +77,6 @@ void Detector::buildBasicFT3(const FT3BaseParam& param)
   const auto Layerx2X0 = param.Layerx2X0;
   mLayerName[IdxBackwardDisks].resize(numberOfLayers);
   mLayerName[IdxForwardDisks].resize(numberOfLayers);
-  mLayerID.clear();
 
   for (int direction : {IdxBackwardDisks, IdxForwardDisks}) {
     for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
@@ -117,7 +118,6 @@ void Detector::buildFT3V1()
 
   mLayerName[IdxBackwardDisks].resize(numberOfLayers);
   mLayerName[IdxForwardDisks].resize(numberOfLayers);
-  mLayerID.clear();
 
   for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
     for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
@@ -165,7 +165,6 @@ void Detector::buildFT3V3b()
 
   mLayerName[IdxBackwardDisks].resize(numberOfLayers);
   mLayerName[IdxForwardDisks].resize(numberOfLayers);
-  mLayerID.clear();
 
   for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
     for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
@@ -224,7 +223,6 @@ void Detector::buildFT3NewVacuumVessel()
 
   mLayerName[IdxBackwardDisks].resize(numberOfLayers);
   mLayerName[IdxForwardDisks].resize(numberOfLayers);
-  mLayerID.clear();
 
   for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
     for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
@@ -280,8 +278,6 @@ void Detector::buildFT3ScopingV3()
                                                                   LayerConfig{220., 20.0, 68.f, layersx2X0}};
   const std::array<bool, numberOfLayers> enabled{true, true, true, true, true, true}; // To enable or disable layers for debug purpose
 
-  mLayerID.clear();
-
   for (int direction : {IdxBackwardDisks, IdxForwardDisks}) {
     mLayerName[direction].clear();
     const std::array<LayerConfig, numberOfLayers>& layerConfig = (direction == IdxBackwardDisks) ? layersConfigCSide : layersConfigASide;
@@ -330,7 +326,6 @@ void Detector::buildFT3Scoping()
 
   mLayerName[IdxBackwardDisks].resize(numberOfLayers);
   mLayerName[IdxForwardDisks].resize(numberOfLayers);
-  mLayerID.clear();
 
   for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
     for (int layerNumber = 0; layerNumber < numberOfLayers; layerNumber++) {
@@ -367,8 +362,8 @@ Detector::Detector(const Detector& rhs)
     /// Container for data points
     mHits(o2::utils::createSimVector<o2::itsmft::Hit>())
 {
-  mLayerID = rhs.mLayerID;
   mLayerName = rhs.mLayerName;
+  mActiveSensorMap = rhs.mActiveSensorMap;
 }
 
 //_________________________________________________________________________________________________
@@ -399,8 +394,8 @@ Detector& Detector::operator=(const Detector& rhs)
   // base class assignment
   base::Detector::operator=(rhs);
 
-  mLayerID = rhs.mLayerID;
   mLayerName = rhs.mLayerName;
+  mActiveSensorMap = rhs.mActiveSensorMap;
   mLayers = rhs.mLayers;
   mTrackData = rhs.mTrackData;
 
@@ -427,11 +422,15 @@ bool Detector::ProcessHits(FairVolume* vol)
     return kFALSE;
   }
 
-  int lay = 0, volID = vol->getMCid();
-  while ((lay <= mLayerID.size()) && (volID != mLayerID[lay])) {
-    ++lay;
+  int volID = vol->getMCid();
+
+  auto it = mActiveSensorMap.find(volID);
+  if (it == mActiveSensorMap.end()) {
+    return kFALSE; // Not a sensitive volume
   }
 
+  int lay = it->second;
+
   auto stack = (o2::data::Stack*)fMC->GetStack();
 
   bool startHit = false, stopHit = false;
@@ -605,58 +604,69 @@ void Detector::createGeometry()
     A3IPvac->AddNode(volIFT3, 2, new TGeoTranslation(0., 0., 0.));
     vALIC->AddNode(volFT3, 2, new TGeoTranslation(0., 30., 0.));
   }
-
-  for (auto direction : {IdxBackwardDisks, IdxForwardDisks}) {
-    std::string directionString = direction ? "Forward" : "Backward";
-    LOG(info) << "  Registering FT3 " << directionString << " LayerIDs for " << mLayers[direction].size() << " layers:";
-    for (int iLayer = 0; iLayer < mLayers[direction].size(); iLayer++) {
-      auto layerID = gMC ? TVirtualMC::GetMC()->VolId(Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer)) : 0;
-      mLayerID.push_back(layerID);
-      LOG(info) << " " << directionString << " layer " << iLayer << " LayerID " << layerID;
-    }
-  }
 }
 
 //_________________________________________________________________________________________________
 void Detector::defineSensitiveVolumes()
 {
   TGeoManager* geoManager = gGeoManager;
-  TGeoVolume* v;
 
-  TString volumeName;
-  LOG(info) << "Adding FT3 Sensitive Volumes";
+  // Get the flat list of ALL volumes present in the geometry
+  TObjArray* allVolumes = geoManager->GetListOfVolumes();
+  int nVolumes = allVolumes->GetEntriesFast();
+
+  LOG(info) << "Adding FT3 Sensitive Volumes by iterating over all geometry volumes...";
 
   for (int direction : {IdxBackwardDisks, IdxForwardDisks}) {
     for (int iLayer = 0; iLayer < getNumberOfLayers(); iLayer++) {
-      LOG(info) << "Adding FT3 Sensitive Volume for direction " << direction << " layer " << iLayer << "/" << getNumberOfLayers();
-      volumeName = o2::ft3::GeometryTGeo::getFT3SensorPattern() + std::to_string(iLayer);
       int iSens = 0;
-      /*if (mLayers[direction][iLayer].getIsInMiddleLayer()) { // ML disks
-        const std::string sensorName = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer);
-        v = geoManager->GetVolume(sensorName.c_str());
-        if (!v) {
-          geoManager->GetListOfVolumes()->ls();
-          LOG(fatal) << "Could not find volume " << sensorName << " for direction " << direction << " layer " << iLayer;
+
+      // Build the "signatures" (prefixes) of the names for the various layouts for this specific layer and direction:
+
+      // 1. Trapezoidal/Cylindrical (format: FT3Sensor_<dir>_<layer>)
+      std::string sig1 = Form("%s_%d_%d", GeometryTGeo::getFT3SensorPattern(), direction, iLayer);
+
+      // 2. Segmented front/back (format: FT3Sensor_front_<layer>_<dir>_...)
+      std::string sig2 = "FT3Sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction);
+      std::string sig3 = "FT3Sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction);
+
+      // 3. SegmentedStave (format: FT3Sensor_<layer>_<dir>_...)
+      // Add the trailing underscore to avoid confusing it with sig1
+      std::string sig4 = "FT3Sensor_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_";
+
+      // Iterate over all existing volumes to find matches
+      for (int i = 0; i < nVolumes; ++i) {
+        TGeoVolume* v = (TGeoVolume*)allVolumes->At(i);
+        std::string vName = v->GetName();
+
+        // Explicitly exclude the inactive silicon regions created in FT3Module
+        if (vName.find("Inactive") != std::string::npos || vName.find("inactive") != std::string::npos) {
+          continue;
         }
-        AddSensitiveVolume(v);
-        iSens++;
-      } else { // OT disks*/
-      for (int sensor_count = 0; sensor_count < MAX_SENSORS; ++sensor_count) {
-        std::string sensor_name_front = "FT3Sensor_front_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-        std::string sensor_name_back = "FT3Sensor_back_" + std::to_string(iLayer) + "_" + std::to_string(direction) + "_" + std::to_string(sensor_count);
-        v = geoManager->GetVolume(sensor_name_front.c_str());
-        if (v) {
-          AddSensitiveVolume(v);
-          iSens++;
+
+        // Check if the volume name matches one of our active sensors
+        bool isMatch = false;
+        if (vName == sig1) {
+          isMatch = true; // Exact match for Trapezoidal/Cylindrical layouts
+        } else if (vName.find(sig2) == 0 || vName.find(sig3) == 0 || vName.find(sig4) == 0) {
+          isMatch = true; // Prefix match for Segmented and SegmentedStave layouts
         }
-        v = geoManager->GetVolume(sensor_name_back.c_str());
-        if (v) {
+
+        if (isMatch) {
           AddSensitiveVolume(v);
+          int volID = gMC ? TVirtualMC::GetMC()->VolId(vName.c_str()) : 0;
+          if (volID > 0) {
+            mActiveSensorMap[volID] = iLayer;
+          }
           iSens++;
         }
       }
-      //}
-      LOG(info) << iSens << " sensitive volumes added";
+
+      if (iSens == 0) {
+        LOG(error) << "NO sensitive volume found for direction " << direction << ", layer " << iLayer;
+      } else {
+        LOG(info) << iSens << " sensitive volume(s) added for direction " << direction << " layer " << iLayer;
+      }
     }
   }
 }

From 877dc1f3cca0d35a5538423bb26322301768fb37 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 15 May 2026 09:28:13 +0200
Subject: [PATCH 1734/1764] ITS: allow to reconstruct incomplete track
 topologies (#15390)

* ITS: hole-tracking

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>

* Add HoleLayerMask parameter to function call

---------

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../GPU/ITStrackingGPU/TimeFrameGPU.h         |  57 +-
 .../GPU/ITStrackingGPU/TrackingKernels.h      |  71 ++-
 .../ITS/tracking/GPU/cuda/TimeFrameGPU.cu     | 101 +++-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    | 241 ++++----
 .../ITS/tracking/GPU/cuda/TrackingKernels.cu  | 550 ++++++++++--------
 .../ITS/tracking/include/ITStracking/Cell.h   |  65 ++-
 .../include/ITStracking/Configuration.h       |   9 +-
 .../tracking/include/ITStracking/LayerMask.h  | 115 ++++
 .../tracking/include/ITStracking/MathUtils.h  |   2 +
 .../tracking/include/ITStracking/TimeFrame.h  |  27 +-
 .../include/ITStracking/TrackHelpers.h        |  12 +-
 .../include/ITStracking/TrackerTraits.h       |   4 +-
 .../include/ITStracking/TrackingConfigParam.h |   2 +
 .../include/ITStracking/TrackingTopology.h    | 219 +++++++
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |   9 +-
 .../ITSMFT/ITS/tracking/src/TimeFrame.cxx     | 123 ++--
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 473 +++++++--------
 .../ITS/tracking/src/TrackingInterface.cxx    |   6 +
 .../ITSMFT/ITS/tracking/test/CMakeLists.txt   |   6 +
 .../ITS/tracking/test/testROFLookupTables.cxx |   1 +
 .../tracking/test/testTrackingTopology.cxx    | 119 ++++
 21 files changed, 1484 insertions(+), 728 deletions(-)
 create mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/LayerMask.h
 create mode 100644 Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingTopology.h
 create mode 100644 Detectors/ITSMFT/ITS/tracking/test/testTrackingTopology.cxx

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
index 1ecff79f2d200..5f56e3f272473 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h
@@ -31,7 +31,11 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   using typename TimeFrame<NLayers>::ROFOverlapTableN;
   using typename TimeFrame<NLayers>::ROFVertexLookupTableN;
   using typename TimeFrame<NLayers>::ROFMaskTableN;
+  using typename TimeFrame<NLayers>::TrackingTopologyN;
   using typename TimeFrame<NLayers>::TrackSeedN;
+  static constexpr int MaxTransitions = TrackingTopologyN::MaxTransitions;
+  static constexpr int MaxCells = TrackingTopologyN::MaxCells;
+  static constexpr int MaxStreams = MaxCells > NLayers ? MaxCells : NLayers;
 
  public:
   TimeFrameGPU() = default;
@@ -43,7 +47,9 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void registerHostMemory(const int);
   void unregisterHostMemory(const int);
   void initialise(const TrackingParameters&, int maxLayers);
+  void initialise(const TrackingParameters&, int maxLayers, int iteration);
   void loadIndexTableUtils();
+  void loadTrackingTopologies();
   void loadTrackingFrameInfoDevice(const int);
   void createTrackingFrameInfoDeviceArray();
   void loadUnsortedClustersDevice(const int);
@@ -85,7 +91,7 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void createNeighboursLUTDevice(const int, const unsigned int);
   void createTrackITSExtDevice(const size_t);
   void downloadTrackITSExtDevice();
-  void downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>&, const int);
+  void downloadCellsNeighboursDevice(std::vector<bounded_vector<CellNeighbour>>&, const int);
   void downloadNeighboursLUTDevice(bounded_vector<int>&, const int);
   void downloadCellsDevice();
   void downloadCellsLUTDevice();
@@ -109,6 +115,7 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   const auto getDeviceROFOverlapTableView() { return mDeviceROFOverlapTableView; }
   const auto getDeviceROFVertexLookupTableView() { return mDeviceROFVertexLookupTableView; }
   const auto getDeviceROFMaskTableView() { return mDeviceROFMaskTableView; }
+  const auto getDeviceTrackingTopologyView() const { return mDeviceTrackingTopologyView; }
   int* getDeviceROFramesClusters(const int layer) { return mROFramesClustersDevice[layer]; }
   auto& getTrackITSExt() { return mTrackITSExt; }
   Vertex* getDeviceVertices() { return mPrimaryVerticesDevice; }
@@ -120,10 +127,9 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   TrackITSExt* getDeviceTrackITSExt() { return mTrackITSExtDevice; }
   int* getDeviceNeighboursLUT(const int layer) { return mNeighboursLUTDevice[layer]; }
   gsl::span<int*> getDeviceNeighboursLUTs() { return mNeighboursLUTDevice; }
-  gpuPair<int, int>* getDeviceNeighbourPairs(const int layer) { return mNeighbourPairsDevice[layer]; }
-  std::array<int*, NLayers - 2>& getDeviceNeighboursAll() { return mNeighboursDevice; }
-  int* getDeviceNeighbours(const int layer) { return mNeighboursDevice[layer]; }
-  int** getDeviceNeighboursArray() { return mNeighboursDevice.data(); }
+  CellNeighbour** getDeviceArrayNeighbours() { return mNeighboursDeviceArray; }
+  std::array<CellNeighbour*, MaxCells>& getDeviceNeighboursAll() { return mNeighboursDevice; }
+  CellNeighbour* getDeviceNeighbours(const int layer) { return mNeighboursDevice[layer]; }
   TrackingFrameInfo* getDeviceTrackingFrameInfo(const int);
   const TrackingFrameInfo** getDeviceArrayTrackingFrameInfo() const { return mTrackingFrameInfoDeviceArray; }
   const Cluster** getDeviceArrayClusters() const { return mClustersDeviceArray; }
@@ -147,10 +153,10 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void setDevicePropagator(const o2::base::PropagatorImpl<float>* p) final { this->mPropagatorDevice = p; }
 
   // Host-specific getters
-  gsl::span<int, NLayers - 1> getNTracklets() { return mNTracklets; }
-  gsl::span<int, NLayers - 2> getNCells() { return mNCells; }
+  gsl::span<int> getNTracklets() { return {mNTracklets.data(), static_cast<gsl::span<int>::size_type>(this->mTrackingTopologyView.nTransitions)}; }
+  gsl::span<int> getNCells() { return {mNCells.data(), static_cast<gsl::span<int>::size_type>(this->mTrackingTopologyView.nCells)}; }
   auto& getArrayNCells() { return mNCells; }
-  gsl::span<int, NLayers - 3> getNNeighbours() { return mNNeighbours; }
+  gsl::span<int> getNNeighbours() { return {mNNeighbours.data(), static_cast<gsl::span<int>::size_type>(this->mTrackingTopologyView.nCells)}; }
   auto& getArrayNNeighbours() { return mNNeighbours; }
 
   // Host-available device getters
@@ -169,9 +175,9 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   void allocMem(void**, size_t, bool, int32_t = o2::gpu::GPUMemoryResource::MEMORY_GPU);               // Abstract owned and unowned memory allocations on default stream
 
   // Host-available device buffer sizes
-  std::array<int, NLayers - 1> mNTracklets;
-  std::array<int, NLayers - 2> mNCells;
-  std::array<int, NLayers - 3> mNNeighbours;
+  std::array<int, MaxTransitions> mNTracklets{};
+  std::array<int, MaxCells> mNCells{};
+  std::array<int, MaxCells> mNNeighbours{};
 
   // Device pointers
   IndexTableUtilsN* mIndexTableUtilsDevice;
@@ -179,6 +185,8 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   ROFOverlapTableN::View mDeviceROFOverlapTableView;
   ROFVertexLookupTableN::View mDeviceROFVertexLookupTableView;
   ROFMaskTableN::View mDeviceROFMaskTableView;
+  std::vector<typename TrackingTopologyN::View> mDeviceTrackerTopologyViews;
+  typename TrackingTopologyN::View mDeviceTrackingTopologyView;
 
   // Hybrid pref
   Vertex* mPrimaryVerticesDevice;
@@ -193,30 +201,29 @@ class TimeFrameGPU : public TimeFrame<NLayers>
   const int** mClustersIndexTablesDeviceArray;
   uint8_t** mUsedClustersDeviceArray;
   const int** mROFramesClustersDeviceArray;
-  std::array<Tracklet*, NLayers - 1> mTrackletsDevice;
-  std::array<int*, NLayers - 1> mTrackletsLUTDevice;
-  std::array<int*, NLayers - 2> mCellsLUTDevice;
-  std::array<int*, NLayers - 3> mNeighboursLUTDevice;
+  std::array<Tracklet*, MaxTransitions> mTrackletsDevice{};
+  std::array<int*, MaxTransitions> mTrackletsLUTDevice{};
+  std::array<int*, MaxCells> mCellsLUTDevice{};
+  std::array<int*, MaxCells> mNeighboursLUTDevice{};
 
   Tracklet** mTrackletsDeviceArray{nullptr};
   int** mCellsLUTDeviceArray{nullptr};
-  int** mNeighboursCellDeviceArray{nullptr};
   int** mNeighboursCellLUTDeviceArray{nullptr};
   int** mTrackletsLUTDeviceArray{nullptr};
-  std::array<CellSeed*, NLayers - 2> mCellsDevice;
+  std::array<CellSeed*, MaxCells> mCellsDevice{};
   CellSeed** mCellsDeviceArray;
-  std::array<int*, NLayers - 3> mNeighboursIndexTablesDevice;
+  std::array<int*, MaxCells> mNeighboursIndexTablesDevice{};
   TrackSeedN* mTrackSeedsDevice{nullptr};
   int* mTrackSeedsLUTDevice{nullptr};
   unsigned int mNTracks{0};
-  std::array<o2::track::TrackParCovF*, NLayers - 2> mCellSeedsDevice;
+  std::array<o2::track::TrackParCovF*, MaxCells> mCellSeedsDevice{};
   o2::track::TrackParCovF** mCellSeedsDeviceArray;
-  std::array<float*, NLayers - 2> mCellSeedsChi2Device;
+  std::array<float*, MaxCells> mCellSeedsChi2Device{};
   float** mCellSeedsChi2DeviceArray;
 
   TrackITSExt* mTrackITSExtDevice;
-  std::array<gpuPair<int, int>*, NLayers - 2> mNeighbourPairsDevice;
-  std::array<int*, NLayers - 2> mNeighboursDevice;
+  std::array<CellNeighbour*, MaxCells> mNeighboursDevice{};
+  CellNeighbour** mNeighboursDeviceArray{nullptr};
   std::array<TrackingFrameInfo*, NLayers> mTrackingFrameInfoDevice;
   const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
@@ -245,19 +252,19 @@ inline std::vector<unsigned int> TimeFrameGPU<NLayers>::getClusterSizes()
 template <int NLayers>
 inline size_t TimeFrameGPU<NLayers>::getNumberOfTracklets() const
 {
-  return std::accumulate(mNTracklets.begin(), mNTracklets.end(), 0);
+  return std::accumulate(mNTracklets.begin(), mNTracklets.begin() + this->mTrackingTopologyView.nTransitions, 0);
 }
 
 template <int NLayers>
 inline size_t TimeFrameGPU<NLayers>::getNumberOfCells() const
 {
-  return std::accumulate(mNCells.begin(), mNCells.end(), 0);
+  return std::accumulate(mNCells.begin(), mNCells.begin() + this->mTrackingTopologyView.nCells, 0);
 }
 
 template <int NLayers>
 inline size_t TimeFrameGPU<NLayers>::getNumberOfNeighbours() const
 {
-  return std::accumulate(mNNeighbours.begin(), mNNeighbours.end(), 0);
+  return std::accumulate(mNNeighbours.begin(), mNNeighbours.begin() + this->mTrackingTopologyView.nCells, 0);
 }
 
 } // namespace o2::its::gpu
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
index fe272f6f8d3bb..161283db2a2bc 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h
@@ -17,14 +17,14 @@
 
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/ROFLookupTables.h"
-#include "ITStracking/Definitions.h"
+#include "ITStracking/TrackingTopology.h"
 #include "ITStrackingGPU/Utils.h"
 #include "DetectorsBase/Propagator.h"
-#include "GPUCommonDef.h"
 
 namespace o2::its
 {
 class CellSeed;
+struct CellNeighbour;
 template <int>
 class TrackSeed;
 class TrackingFrameInfo;
@@ -38,7 +38,9 @@ class ExternalAllocator;
 template <int NLayers>
 void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  const typename ROFMaskTable<NLayers>::View& rofMask,
-                                 const int layer,
+                                 const int transitionId,
+                                 const int fromLayer,
+                                 const int toLayer,
                                  const typename ROFOverlapTable<NLayers>::View& rofOverlaps,
                                  const typename ROFVertexLookupTable<NLayers>::View& vertexLUT,
                                  const int vertexId,
@@ -53,20 +55,23 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  gsl::span<int*> trackletsLUTsHost,
                                  const bool selectUPCVertices,
                                  const float NSigmaCut,
-                                 bounded_vector<float>& phiCuts,
+                                 const typename TrackingTopology<NLayers>::View topology,
+                                 bounded_vector<float>& transitionPhiCuts,
                                  const float resolutionPV,
                                  std::array<float, NLayers>& minR,
                                  std::array<float, NLayers>& maxR,
                                  bounded_vector<float>& resolutions,
                                  std::vector<float>& radii,
-                                 bounded_vector<float>& mulScatAng,
+                                 bounded_vector<float>& transitionMSAngles,
                                  o2::its::ExternalAllocator* alloc,
                                  gpu::Streams& streams);
 
 template <int NLayers>
 void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    const typename ROFMaskTable<NLayers>::View& rofMask,
-                                   const int layer,
+                                   const int transitionId,
+                                   const int fromLayer,
+                                   const int toLayer,
                                    const typename ROFOverlapTable<NLayers>::View& rofOverlaps,
                                    const typename ROFVertexLookupTable<NLayers>::View& vertexLUT,
                                    const int vertexId,
@@ -84,13 +89,14 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    gsl::span<int*> trackletsLUTsHost,
                                    const bool selectUPCVertices,
                                    const float NSigmaCut,
-                                   bounded_vector<float>& phiCuts,
+                                   const typename TrackingTopology<NLayers>::View topology,
+                                   bounded_vector<float>& transitionPhiCuts,
                                    const float resolutionPV,
                                    std::array<float, NLayers>& minR,
                                    std::array<float, NLayers>& maxR,
                                    bounded_vector<float>& resolutions,
                                    std::vector<float>& radii,
-                                   bounded_vector<float>& mulScatAng,
+                                   bounded_vector<float>& transitionMSAngles,
                                    o2::its::ExternalAllocator* alloc,
                                    gpu::Streams& streams);
 
@@ -101,7 +107,8 @@ void countCellsHandler(const Cluster** sortedClusters,
                        Tracklet** tracklets,
                        int** trackletsLUT,
                        const int nTracklets,
-                       const int layer,
+                       const int cellTopologyId,
+                       const typename TrackingTopology<NLayers>::View topology,
                        CellSeed* cells,
                        int** cellsLUTsDeviceArray,
                        int* cellsLUTsHost,
@@ -120,7 +127,8 @@ void computeCellsHandler(const Cluster** sortedClusters,
                          Tracklet** tracklets,
                          int** trackletsLUT,
                          const int nTracklets,
-                         const int layer,
+                         const int cellTopologyId,
+                         const typename TrackingTopology<NLayers>::View topology,
                          CellSeed* cells,
                          int** cellsLUTsDeviceArray,
                          int* cellsLUTsHost,
@@ -133,33 +141,31 @@ void computeCellsHandler(const Cluster** sortedClusters,
 
 template <int NLayers>
 void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
-                                int* neighboursLUTs,
+                                int* neighboursCursor,
                                 int** cellsLUTs,
-                                gpuPair<int, int>* cellNeighbours,
-                                int* neighboursIndexTable,
-                                const Tracklet** tracklets,
+                                const int sourceCellTopologyId,
+                                const int targetCellTopologyId,
                                 const float maxChi2ClusterAttachment,
                                 const float bz,
-                                const int layerIndex,
                                 const unsigned int nCells,
-                                const unsigned int nCellsNext,
-                                const int maxCellNeighbours,
-                                o2::its::ExternalAllocator* alloc,
                                 gpu::Stream& stream);
 
+void scanCellNeighboursHandler(int* neighboursCursor,
+                               int* neighboursLUT,
+                               const unsigned int nCells,
+                               o2::its::ExternalAllocator* alloc,
+                               gpu::Stream& stream);
+
 template <int NLayers>
 void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
-                                  int* neighboursLUTs,
+                                  int* neighboursCursor,
                                   int** cellsLUTs,
-                                  gpuPair<int, int>* cellNeighbours,
-                                  int* neighboursIndexTable,
-                                  const Tracklet** tracklets,
+                                  CellNeighbour* cellNeighbours,
+                                  const int sourceCellTopologyId,
+                                  const int targetCellTopologyId,
                                   const float maxChi2ClusterAttachment,
                                   const float bz,
-                                  const int layerIndex,
                                   const unsigned int nCells,
-                                  const unsigned int nCellsNext,
-                                  const int maxCellNeighbours,
                                   gpu::Stream& stream);
 
 int filterCellNeighboursHandler(gpuPair<int, int>*,
@@ -169,19 +175,24 @@ int filterCellNeighboursHandler(gpuPair<int, int>*,
                                 o2::its::ExternalAllocator* = nullptr);
 
 template <int NLayers>
-void processNeighboursHandler(const int startLayer,
-                              const int startLevel,
+void processNeighboursHandler(const int startLevel,
+                              const int defaultCellTopologyId,
                               CellSeed** allCellSeeds,
                               CellSeed* currentCellSeeds,
-                              std::array<int, NLayers - 2>& nCells,
+                              const int* currentCellTopologyIds,
+                              const int* currentCellIds,
+                              const int* nCells,
                               const unsigned char** usedClusters,
-                              std::array<int*, NLayers - 2>& neighbours,
-                              gsl::span<int*> neighboursDeviceLUTs,
+                              CellNeighbour** neighbours,
+                              int** neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
                               bounded_vector<TrackSeed<NLayers>>& seedsHost,
                               const float bz,
                               const float MaxChi2ClusterAttachment,
                               const float maxChi2NDF,
+                              const int maxHoles,
+                              const int minTrackLength,
+                              const LayerMask holeLayerMask,
                               const std::vector<float>& layerxX0Host,
                               const o2::base::Propagator* propagator,
                               const o2::base::PropagatorF::MatCorrType matCorrType,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
index b541518a88119..5fff30f5162b1 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TimeFrameGPU.cu
@@ -328,6 +328,37 @@ void TimeFrameGPU<NLayers>::loadROFVertexLookupTable()
   }
 }
 
+template <int NLayers>
+void TimeFrameGPU<NLayers>::loadTrackingTopologies()
+{
+  GPUTimer timer("initialising device views of TrackingTopology");
+  const auto& hostTopologies = this->getTrackerTopologies();
+  mDeviceTrackerTopologyViews.resize(hostTopologies.size());
+  using LayerTransition = typename TrackingTopologyN::LayerTransition;
+  using CellTopology = typename TrackingTopologyN::CellTopology;
+  using Range = typename TrackingTopologyN::Range;
+  using Id = typename TrackingTopologyN::Id;
+  for (size_t iteration = 0; iteration < hostTopologies.size(); ++iteration) {
+    const auto& topology = hostTopologies[iteration];
+    LayerTransition* dTransitions{nullptr};
+    CellTopology* dCells{nullptr};
+    Range* dCellsByFirstTransitionIndex{nullptr};
+    Id* dCellsByFirstTransition{nullptr};
+    allocMem(reinterpret_cast<void**>(&dTransitions), topology.getNTransitions() * sizeof(LayerTransition), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&dCells), topology.getNCells() * sizeof(CellTopology), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&dCellsByFirstTransitionIndex), topology.getNTransitions() * sizeof(Range), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&dCellsByFirstTransition), topology.getNCellsByFirstTransition() * sizeof(Id), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemcpy(dTransitions, topology.getTransitions().data(), topology.getNTransitions() * sizeof(LayerTransition), cudaMemcpyHostToDevice));
+    GPUChkErrS(cudaMemcpy(dCells, topology.getCells().data(), topology.getNCells() * sizeof(CellTopology), cudaMemcpyHostToDevice));
+    GPUChkErrS(cudaMemcpy(dCellsByFirstTransitionIndex, topology.getCellsByFirstTransitionIndex().data(), topology.getNTransitions() * sizeof(Range), cudaMemcpyHostToDevice));
+    GPUChkErrS(cudaMemcpy(dCellsByFirstTransition, topology.getCellsByFirstTransition().data(), topology.getNCellsByFirstTransition() * sizeof(Id), cudaMemcpyHostToDevice));
+    mDeviceTrackerTopologyViews[iteration] = topology.getDeviceView(dTransitions, dCells, dCellsByFirstTransitionIndex, dCellsByFirstTransition);
+  }
+  if (!mDeviceTrackerTopologyViews.empty()) {
+    mDeviceTrackingTopologyView = mDeviceTrackerTopologyViews.front();
+  }
+}
+
 template <int NLayers>
 void TimeFrameGPU<NLayers>::updateROFVertexLookupTable()
 {
@@ -348,7 +379,7 @@ template <int NLayers>
 void TimeFrameGPU<NLayers>::createTrackletsLUTDeviceArray()
 {
   {
-    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), (NLayers - 1) * sizeof(int*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackletsLUTDeviceArray), MaxTransitions * sizeof(int*), this->hasFrameworkAllocator());
   }
 }
 
@@ -356,8 +387,9 @@ template <int NLayers>
 void TimeFrameGPU<NLayers>::createTrackletsLUTDevice(bool allocate, const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating tracklets LUTs", layer);
-  const int ncls = this->mClusters[layer].size() + 1;
-  if (allocate) {
+  const int fromLayer = this->mTrackingTopologyView.getTransition(layer).fromLayer;
+  const int ncls = this->mClusters[fromLayer].size() + 1;
+  if (allocate || mTrackletsLUTDevice[layer] == nullptr) {
     GPULog("gpu-allocation: creating tracklets LUT for {} elements on layer {}, for {:.2f} MB.", ncls, layer, ncls * sizeof(int) / constants::MB);
     allocMemAsync(reinterpret_cast<void**>(&mTrackletsLUTDevice[layer]), ncls * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator());
     GPUChkErrS(cudaMemcpyAsync(&mTrackletsLUTDeviceArray[layer], &mTrackletsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
@@ -370,7 +402,7 @@ void TimeFrameGPU<NLayers>::createTrackletsBuffersArray()
 {
   {
     GPUTimer timer("creating tracklet buffers array");
-    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), (NLayers - 1) * sizeof(Tracklet*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mTrackletsDeviceArray), MaxTransitions * sizeof(Tracklet*), this->hasFrameworkAllocator());
   }
 }
 
@@ -379,7 +411,8 @@ void TimeFrameGPU<NLayers>::createTrackletsBuffers(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating tracklet buffers", layer);
   mNTracklets[layer] = 0;
-  GPUChkErrS(cudaMemcpyAsync(&mNTracklets[layer], mTrackletsLUTDevice[layer] + this->mClusters[layer].size(), sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
+  const int fromLayer = this->mTrackingTopologyView.getTransition(layer).fromLayer;
+  GPUChkErrS(cudaMemcpyAsync(&mNTracklets[layer], mTrackletsLUTDevice[layer] + this->mClusters[fromLayer].size(), sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of tracklets is correct
   GPULog("gpu-transfer: creating tracklets buffer for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer], layer, mNTracklets[layer] * sizeof(Tracklet) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mTrackletsDevice[layer]), mNTracklets[layer] * sizeof(Tracklet), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
@@ -426,6 +459,7 @@ void TimeFrameGPU<NLayers>::createNeighboursLUTDevice(const int layer, const uns
   GPULog("gpu-allocation: reserving neighbours LUT for {} elements on layer {} , for {:.2f} MB.", nCells + 1, layer, (nCells + 1) * sizeof(int) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mNeighboursLUTDevice[layer]), (nCells + 1) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK)); // We need one element more to move exc -> inc
   GPUChkErrS(cudaMemsetAsync(mNeighboursLUTDevice[layer], 0, (nCells + 1) * sizeof(int), mGpuStreams[layer].get()));
+  GPUChkErrS(cudaMemcpyAsync(&mNeighboursCellLUTDeviceArray[layer], &mNeighboursLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
 template <int NLayers>
@@ -446,7 +480,9 @@ void TimeFrameGPU<NLayers>::createCellsLUTDeviceArray()
 {
   {
     GPUTimer timer("creating cells LUTs array");
-    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), (NLayers - 2) * sizeof(int*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mCellsLUTDeviceArray), MaxCells * sizeof(int*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mNeighboursCellLUTDeviceArray), MaxCells * sizeof(int*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemset(mNeighboursCellLUTDeviceArray, 0, MaxCells * sizeof(int*)));
   }
 }
 
@@ -454,9 +490,10 @@ template <int NLayers>
 void TimeFrameGPU<NLayers>::createCellsLUTDevice(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells LUTs", layer);
-  GPULog("gpu-transfer: creating cell LUT for {} elements on layer {}, for {:.2f} MB.", mNTracklets[layer] + 1, layer, (mNTracklets[layer] + 1) * sizeof(int) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[layer]), (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
-  GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[layer], 0, (mNTracklets[layer] + 1) * sizeof(int), mGpuStreams[layer].get()));
+  const int firstTransition = this->mTrackingTopologyView.getCell(layer).firstTransition;
+  GPULog("gpu-transfer: creating cell LUT for {} elements on layer {}, for {:.2f} MB.", mNTracklets[firstTransition] + 1, layer, (mNTracklets[firstTransition] + 1) * sizeof(int) / constants::MB);
+  allocMemAsync(reinterpret_cast<void**>(&mCellsLUTDevice[layer]), (mNTracklets[firstTransition] + 1) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  GPUChkErrS(cudaMemsetAsync(mCellsLUTDevice[layer], 0, (mNTracklets[firstTransition] + 1) * sizeof(int), mGpuStreams[layer].get()));
   GPUChkErrS(cudaMemcpyAsync(&mCellsLUTDeviceArray[layer], &mCellsLUTDevice[layer], sizeof(int*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
@@ -465,7 +502,9 @@ void TimeFrameGPU<NLayers>::createCellsBuffersArray()
 {
   {
     GPUTimer timer("creating cells buffers array");
-    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), (NLayers - 2) * sizeof(CellSeed*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mCellsDeviceArray), MaxCells * sizeof(CellSeed*), this->hasFrameworkAllocator());
+    allocMem(reinterpret_cast<void**>(&mNeighboursDeviceArray), MaxCells * sizeof(CellNeighbour*), this->hasFrameworkAllocator());
+    GPUChkErrS(cudaMemset(mNeighboursDeviceArray, 0, MaxCells * sizeof(CellNeighbour*)));
     GPUChkErrS(cudaMemcpy(mCellsDeviceArray, mCellsDevice.data(), mCellsDevice.size() * sizeof(CellSeed*), cudaMemcpyHostToDevice));
   }
 }
@@ -475,7 +514,8 @@ void TimeFrameGPU<NLayers>::createCellsBuffers(const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "creating cells buffers");
   mNCells[layer] = 0;
-  GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[layer], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
+  const int firstTransition = this->mTrackingTopologyView.getCell(layer).firstTransition;
+  GPUChkErrS(cudaMemcpyAsync(&mNCells[layer], mCellsLUTDevice[layer] + mNTracklets[firstTransition], sizeof(int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of cells is correct
   GPULog("gpu-transfer: creating cell buffer for {} elements on layer {}, for {:.2f} MB.", mNCells[layer], layer, mNCells[layer] * sizeof(CellSeed) / constants::MB);
   allocMemAsync(reinterpret_cast<void**>(&mCellsDevice[layer]), mNCells[layer] * sizeof(CellSeed), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
@@ -511,13 +551,22 @@ void TimeFrameGPU<NLayers>::createNeighboursDevice(const unsigned int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "reserving neighbours", layer);
   this->mNNeighbours[layer] = 0;
-  GPUChkErrS(cudaMemcpyAsync(&(this->mNNeighbours[layer]), &(mNeighboursLUTDevice[layer][this->mNCells[layer + 1] - 1]), sizeof(unsigned int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
+  if (this->mNCells[layer] == 0) {
+    mNeighboursDevice[layer] = nullptr;
+    GPUChkErrS(cudaMemcpyAsync(&mNeighboursDeviceArray[layer], &mNeighboursDevice[layer], sizeof(CellNeighbour*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+    return;
+  }
+  GPUChkErrS(cudaMemcpyAsync(&(this->mNNeighbours[layer]), &(mNeighboursLUTDevice[layer][this->mNCells[layer]]), sizeof(unsigned int), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
   mGpuStreams[layer].sync(); // ensure number of neighbours is correct
-  GPULog("gpu-allocation: reserving {} neighbours (pairs), for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighbourPairsDevice[layer]), (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
-  GPUChkErrS(cudaMemsetAsync(mNeighbourPairsDevice[layer], -1, (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>), mGpuStreams[layer].get()));
-  GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(gpuPair<int, int>) / constants::MB);
-  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(int), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  if (this->mNNeighbours[layer] == 0) {
+    mNeighboursDevice[layer] = nullptr;
+    GPUChkErrS(cudaMemcpyAsync(&mNeighboursDeviceArray[layer], &mNeighboursDevice[layer], sizeof(CellNeighbour*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
+    return;
+  }
+  GPULog("gpu-allocation: reserving {} neighbours, for {:.2f} MB.", this->mNNeighbours[layer], (this->mNNeighbours[layer]) * sizeof(CellNeighbour) / constants::MB);
+  allocMemAsync(reinterpret_cast<void**>(&mNeighboursDevice[layer]), (this->mNNeighbours[layer]) * sizeof(CellNeighbour), mGpuStreams[layer], this->hasFrameworkAllocator(), (o2::gpu::GPUMemoryResource::MEMORY_GPU | o2::gpu::GPUMemoryResource::MEMORY_STACK));
+  GPUChkErrS(cudaMemsetAsync(mNeighboursDevice[layer], -1, (this->mNNeighbours[layer]) * sizeof(CellNeighbour), mGpuStreams[layer].get()));
+  GPUChkErrS(cudaMemcpyAsync(&mNeighboursDeviceArray[layer], &mNeighboursDevice[layer], sizeof(CellNeighbour*), cudaMemcpyHostToDevice, mGpuStreams[layer].get()));
 }
 
 template <int NLayers>
@@ -555,11 +604,11 @@ void TimeFrameGPU<NLayers>::downloadCellsLUTDevice()
 }
 
 template <int NLayers>
-void TimeFrameGPU<NLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<std::pair<int, int>>>& neighbours, const int layer)
+void TimeFrameGPU<NLayers>::downloadCellsNeighboursDevice(std::vector<bounded_vector<CellNeighbour>>& neighbours, const int layer)
 {
   GPUTimer timer(mGpuStreams[layer], "downloading neighbours from layer", layer);
-  GPULog("gpu-transfer: downloading {} neighbours, for {:.2f} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(std::pair<int, int>) / constants::MB);
-  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighbourPairsDevice[layer], neighbours[layer].size() * sizeof(gpuPair<int, int>), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
+  GPULog("gpu-transfer: downloading {} neighbours, for {:.2f} MB.", neighbours[layer].size(), neighbours[layer].size() * sizeof(CellNeighbour) / constants::MB);
+  GPUChkErrS(cudaMemcpyAsync(neighbours[layer].data(), mNeighboursDevice[layer], neighbours[layer].size() * sizeof(CellNeighbour), cudaMemcpyDeviceToHost, mGpuStreams[layer].get()));
 }
 
 template <int NLayers>
@@ -648,10 +697,20 @@ void TimeFrameGPU<NLayers>::popMemoryStack(const int iteration)
 template <int NLayers>
 void TimeFrameGPU<NLayers>::initialise(const TrackingParameters& trkParam, int maxLayers)
 {
-  mGpuStreams.resize(NLayers);
+  mGpuStreams.resize(MaxStreams);
   o2::its::TimeFrame<NLayers>::initialise(trkParam, maxLayers);
 }
 
+template <int NLayers>
+void TimeFrameGPU<NLayers>::initialise(const TrackingParameters& trkParam, int maxLayers, int iteration)
+{
+  mGpuStreams.resize(MaxStreams);
+  o2::its::TimeFrame<NLayers>::initialise(trkParam, maxLayers, iteration);
+  if (iteration != constants::UnusedIndex && iteration < static_cast<int>(mDeviceTrackerTopologyViews.size())) {
+    mDeviceTrackingTopologyView = mDeviceTrackerTopologyViews[iteration];
+  }
+}
+
 template <int NLayers>
 void TimeFrameGPU<NLayers>::syncStream(const size_t stream)
 {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 2d2ca5432cdf9..f1812c9f6f764 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -22,7 +22,7 @@ namespace o2::its
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::initialiseTimeFrame(const int iteration)
 {
-  mTimeFrameGPU->initialise(this->mTrkParams[iteration], NLayers);
+  mTimeFrameGPU->initialise(this->mTrkParams[iteration], NLayers, iteration);
 
   if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
     // on default stream
@@ -30,6 +30,7 @@ void TrackerTraitsGPU<NLayers>::initialiseTimeFrame(const int iteration)
     // TODO these tables can be put in persistent memory
     mTimeFrameGPU->loadROFOverlapTable(); // this can be put in constant memory actually
     mTimeFrameGPU->loadROFVertexLookupTable();
+    mTimeFrameGPU->loadTrackingTopologies();
     // once the tables are in persistent memory just update the vertex one
     // mTimeFrameGPU->updateROFVertexLookupTable();
     mTimeFrameGPU->loadIndexTableUtils();
@@ -63,8 +64,9 @@ void TrackerTraitsGPU<NLayers>::adoptTimeFrame(TimeFrame<NLayers>* tf)
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int iVertex)
 {
-  // start by queuing loading needed of two last layers
-  for (int iLayer{NLayers}; iLayer-- > NLayers - 2;) {
+  const auto topology = mTimeFrameGPU->getDeviceTrackingTopologyView();
+  const auto hostTopology = mTimeFrameGPU->getTrackingTopologyView();
+  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].NLayers; ++iLayer) {
     if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
       mTimeFrameGPU->createUsedClustersDevice(iLayer);
       mTimeFrameGPU->loadClustersDevice(iLayer);
@@ -74,21 +76,16 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
     mTimeFrameGPU->recordEvent(iLayer);
   }
 
-  for (int iLayer{this->mTrkParams[iteration].TrackletsPerRoad()}; iLayer--;) {
-    if (iLayer) { // queue loading data of next layer in parallel, this the copies are overlapping with computation kernels
-      if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
-        mTimeFrameGPU->createUsedClustersDevice(iLayer - 1);
-        mTimeFrameGPU->loadClustersDevice(iLayer - 1);
-        mTimeFrameGPU->loadClustersIndexTables(iLayer - 1);
-        mTimeFrameGPU->loadROFrameClustersDevice(iLayer - 1);
-      }
-      mTimeFrameGPU->recordEvent(iLayer - 1);
-    }
-    mTimeFrameGPU->createTrackletsLUTDevice(this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass], iLayer);
-    mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
+  for (int transitionId{0}; transitionId < hostTopology.nTransitions; ++transitionId) {
+    const auto transition = hostTopology.getTransition(transitionId);
+    mTimeFrameGPU->createTrackletsLUTDevice(this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass], transitionId);
+    mTimeFrameGPU->waitEvent(transitionId, transition.fromLayer);
+    mTimeFrameGPU->waitEvent(transitionId, transition.toLayer);
     countTrackletsInROFsHandler<NLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
                                          mTimeFrameGPU->getDeviceROFMaskTableView(),
-                                         iLayer,
+                                         transitionId,
+                                         transition.fromLayer,
+                                         transition.toLayer,
                                          mTimeFrameGPU->getDeviceROFOverlapTableView(),
                                          mTimeFrameGPU->getDeviceROFVertexLookupTableView(),
                                          iVertex,
@@ -103,22 +100,26 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
                                          mTimeFrameGPU->getDeviceTrackletsLUTs(),
                                          this->mTrkParams[iteration].PassFlags[IterationStep::SelectUPCVertices],
                                          this->mTrkParams[iteration].NSigmaCut,
-                                         mTimeFrameGPU->getPhiCuts(),
+                                         topology,
+                                         mTimeFrameGPU->getTransitionPhiCuts(),
                                          this->mTrkParams[iteration].PVres,
                                          mTimeFrameGPU->getMinRs(),
                                          mTimeFrameGPU->getMaxRs(),
                                          mTimeFrameGPU->getPositionResolutions(),
                                          this->mTrkParams[iteration].LayerRadii,
-                                         mTimeFrameGPU->getMSangles(),
+                                         mTimeFrameGPU->getTransitionMSAngles(),
                                          mTimeFrameGPU->getFrameworkAllocator(),
                                          mTimeFrameGPU->getStreams());
-    mTimeFrameGPU->createTrackletsBuffers(iLayer);
-    if (mTimeFrameGPU->getNTracklets()[iLayer] == 0) {
+    mTimeFrameGPU->createTrackletsBuffers(transitionId);
+    if (mTimeFrameGPU->getNTracklets()[transitionId] == 0) {
+      mTimeFrameGPU->recordEvent(transitionId);
       continue;
     }
     computeTrackletsInROFsHandler<NLayers>(mTimeFrameGPU->getDeviceIndexTableUtils(),
                                            mTimeFrameGPU->getDeviceROFMaskTableView(),
-                                           iLayer,
+                                           transitionId,
+                                           transition.fromLayer,
+                                           transition.toLayer,
                                            mTimeFrameGPU->getDeviceROFOverlapTableView(),
                                            mTimeFrameGPU->getDeviceROFVertexLookupTableView(),
                                            iVertex,
@@ -136,23 +137,26 @@ void TrackerTraitsGPU<NLayers>::computeLayerTracklets(const int iteration, int i
                                            mTimeFrameGPU->getDeviceTrackletsLUTs(),
                                            this->mTrkParams[iteration].PassFlags[IterationStep::SelectUPCVertices],
                                            this->mTrkParams[iteration].NSigmaCut,
-                                           mTimeFrameGPU->getPhiCuts(),
+                                           topology,
+                                           mTimeFrameGPU->getTransitionPhiCuts(),
                                            this->mTrkParams[iteration].PVres,
                                            mTimeFrameGPU->getMinRs(),
                                            mTimeFrameGPU->getMaxRs(),
                                            mTimeFrameGPU->getPositionResolutions(),
                                            this->mTrkParams[iteration].LayerRadii,
-                                           mTimeFrameGPU->getMSangles(),
+                                           mTimeFrameGPU->getTransitionMSAngles(),
                                            mTimeFrameGPU->getFrameworkAllocator(),
                                            mTimeFrameGPU->getStreams());
+    mTimeFrameGPU->recordEvent(transitionId);
   }
 }
 
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
 {
-  // start by queuing loading needed of three last layers
-  for (int iLayer{NLayers}; iLayer-- > NLayers - 3;) {
+  const auto topology = mTimeFrameGPU->getDeviceTrackingTopologyView();
+  const auto hostTopology = mTimeFrameGPU->getTrackingTopologyView();
+  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].NLayers; ++iLayer) {
     if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
       mTimeFrameGPU->loadUnsortedClustersDevice(iLayer);
       mTimeFrameGPU->loadTrackingFrameInfoDevice(iLayer);
@@ -160,35 +164,33 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
     mTimeFrameGPU->recordEvent(iLayer);
   }
 
-  for (int iLayer{this->mTrkParams[iteration].CellsPerRoad()}; iLayer--;) {
-    if (iLayer) {
-      if (this->mTrkParams[iteration].PassFlags[IterationStep::FirstPass]) {
-        mTimeFrameGPU->loadUnsortedClustersDevice(iLayer - 1);
-        mTimeFrameGPU->loadTrackingFrameInfoDevice(iLayer - 1);
-      }
-      mTimeFrameGPU->recordEvent(iLayer - 1);
-    }
-
-    // if there are no tracklets skip entirely
-    const int currentLayerTrackletsNum{static_cast<int>(mTimeFrameGPU->getNTracklets()[iLayer])};
-    if (!currentLayerTrackletsNum || !mTimeFrameGPU->getNTracklets()[iLayer + 1]) {
-      mTimeFrameGPU->getNCells()[iLayer] = 0;
+  for (int cellTopologyId{hostTopology.nCells}; cellTopologyId--;) {
+    const auto cellTopology = hostTopology.getCell(cellTopologyId);
+    const auto first = hostTopology.getTransition(cellTopology.firstTransition);
+    const auto second = hostTopology.getTransition(cellTopology.secondTransition);
+    const int currentLayerTrackletsNum{static_cast<int>(mTimeFrameGPU->getNTracklets()[cellTopology.firstTransition])};
+    if (!currentLayerTrackletsNum || !mTimeFrameGPU->getNTracklets()[cellTopology.secondTransition]) {
+      mTimeFrameGPU->getNCells()[cellTopologyId] = 0;
       continue;
     }
 
-    mTimeFrameGPU->createCellsLUTDevice(iLayer);
-    mTimeFrameGPU->waitEvent(iLayer, iLayer + 1); // wait stream until all data is available
-    mTimeFrameGPU->waitEvent(iLayer, iLayer + 2); // wait stream until all data is available
+    mTimeFrameGPU->createCellsLUTDevice(cellTopologyId);
+    mTimeFrameGPU->waitEvent(cellTopologyId, cellTopology.firstTransition);
+    mTimeFrameGPU->waitEvent(cellTopologyId, cellTopology.secondTransition);
+    mTimeFrameGPU->waitEvent(cellTopologyId, first.fromLayer);
+    mTimeFrameGPU->waitEvent(cellTopologyId, first.toLayer);
+    mTimeFrameGPU->waitEvent(cellTopologyId, second.toLayer);
     countCellsHandler<NLayers>(mTimeFrameGPU->getDeviceArrayClusters(),
                                mTimeFrameGPU->getDeviceArrayUnsortedClusters(),
                                mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                                mTimeFrameGPU->getDeviceArrayTracklets(),
                                mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
                                currentLayerTrackletsNum,
-                               iLayer,
+                               cellTopologyId,
+                               topology,
                                nullptr,
                                mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                               mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
+                               mTimeFrameGPU->getDeviceCellLUTs()[cellTopologyId],
                                this->mBz,
                                this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
@@ -196,8 +198,9 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
                                this->mTrkParams[iteration].LayerxX0,
                                mTimeFrameGPU->getFrameworkAllocator(),
                                mTimeFrameGPU->getStreams());
-    mTimeFrameGPU->createCellsBuffers(iLayer);
-    if (mTimeFrameGPU->getNCells()[iLayer] == 0) {
+    mTimeFrameGPU->createCellsBuffers(cellTopologyId);
+    if (mTimeFrameGPU->getNCells()[cellTopologyId] == 0) {
+      mTimeFrameGPU->recordEvent(cellTopologyId);
       continue;
     }
     computeCellsHandler<NLayers>(mTimeFrameGPU->getDeviceArrayClusters(),
@@ -206,16 +209,18 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
                                  mTimeFrameGPU->getDeviceArrayTracklets(),
                                  mTimeFrameGPU->getDeviceArrayTrackletsLUT(),
                                  currentLayerTrackletsNum,
-                                 iLayer,
-                                 mTimeFrameGPU->getDeviceCells()[iLayer],
+                                 cellTopologyId,
+                                 topology,
+                                 mTimeFrameGPU->getDeviceCells()[cellTopologyId],
                                  mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                                 mTimeFrameGPU->getDeviceCellLUTs()[iLayer],
+                                 mTimeFrameGPU->getDeviceCellLUTs()[cellTopologyId],
                                  this->mBz,
                                  this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                  this->mTrkParams[iteration].CellDeltaTanLambdaSigma,
                                  this->mTrkParams[iteration].NSigmaCut,
                                  this->mTrkParams[iteration].LayerxX0,
                                  mTimeFrameGPU->getStreams());
+    mTimeFrameGPU->recordEvent(cellTopologyId);
   }
   mTimeFrameGPU->syncStreams(false);
 }
@@ -223,58 +228,71 @@ void TrackerTraitsGPU<NLayers>::computeLayerCells(const int iteration)
 template <int NLayers>
 void TrackerTraitsGPU<NLayers>::findCellsNeighbours(const int iteration)
 {
-  for (int iLayer{0}; iLayer < this->mTrkParams[iteration].NeighboursPerRoad(); ++iLayer) {
-    if (iLayer > 0) {
-      // Previous layer updates levels in this layer's cells.
-      mTimeFrameGPU->waitEvent(iLayer, iLayer - 1);
-    }
-    const int currentLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer])};
-    const int nextLayerCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[iLayer + 1])};
-    if (!nextLayerCellsNum || !currentLayerCellsNum) {
-      mTimeFrameGPU->getNNeighbours()[iLayer] = 0;
-      mTimeFrameGPU->recordEvent(iLayer);
-      continue;
-    }
-    mTimeFrameGPU->createNeighboursIndexTablesDevice(iLayer);
-    mTimeFrameGPU->createNeighboursLUTDevice(iLayer, nextLayerCellsNum);
-    countCellNeighboursHandler<NLayers>(mTimeFrameGPU->getDeviceArrayCells(),
-                                        mTimeFrameGPU->getDeviceNeighboursLUT(iLayer), // LUT is initialised here.
-                                        mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                                        mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
-                                        mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
-                                        (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                                        this->mTrkParams[iteration].MaxChi2ClusterAttachment,
-                                        this->mBz,
-                                        iLayer,
-                                        currentLayerCellsNum,
-                                        nextLayerCellsNum,
-                                        1e2,
-                                        mTimeFrameGPU->getFrameworkAllocator(),
-                                        mTimeFrameGPU->getStream(iLayer));
-    mTimeFrameGPU->createNeighboursDevice(iLayer);
-    if (mTimeFrameGPU->getNNeighbours()[iLayer] == 0) {
-      mTimeFrameGPU->recordEvent(iLayer);
-      continue;
+  const auto hostTopology = mTimeFrameGPU->getTrackingTopologyView();
+  for (int outerLayer{0}; outerLayer < NLayers; ++outerLayer) {
+    for (int targetCellTopologyId{0}; targetCellTopologyId < hostTopology.nCells; ++targetCellTopologyId) {
+      const auto targetCellTopology = hostTopology.getCell(targetCellTopologyId);
+      if (targetCellTopology.hitLayerMask.last() != outerLayer) {
+        continue;
+      }
+      const int targetCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[targetCellTopologyId])};
+      if (!targetCellsNum) {
+        mTimeFrameGPU->getNNeighbours()[targetCellTopologyId] = 0;
+        mTimeFrameGPU->recordEvent(targetCellTopologyId);
+        continue;
+      }
+      mTimeFrameGPU->createNeighboursIndexTablesDevice(targetCellTopologyId);
+      mTimeFrameGPU->createNeighboursLUTDevice(targetCellTopologyId, targetCellsNum);
+
+      for (int sourceCellTopologyId{0}; sourceCellTopologyId < hostTopology.nCells; ++sourceCellTopologyId) {
+        const auto sourceCellTopology = hostTopology.getCell(sourceCellTopologyId);
+        const int sourceCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[sourceCellTopologyId])};
+        if (!sourceCellsNum || sourceCellTopology.secondTransition != targetCellTopology.firstTransition) {
+          continue;
+        }
+        mTimeFrameGPU->waitEvent(targetCellTopologyId, sourceCellTopologyId);
+        countCellNeighboursHandler<NLayers>(mTimeFrameGPU->getDeviceArrayCells(),
+                                            mTimeFrameGPU->getDeviceNeighboursIndexTables(targetCellTopologyId),
+                                            mTimeFrameGPU->getDeviceArrayCellsLUT(),
+                                            sourceCellTopologyId,
+                                            targetCellTopologyId,
+                                            this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                                            this->mBz,
+                                            sourceCellsNum,
+                                            mTimeFrameGPU->getStream(targetCellTopologyId));
+      }
+
+      scanCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighboursIndexTables(targetCellTopologyId),
+                                mTimeFrameGPU->getDeviceNeighboursLUT(targetCellTopologyId),
+                                targetCellsNum,
+                                mTimeFrameGPU->getFrameworkAllocator(),
+                                mTimeFrameGPU->getStream(targetCellTopologyId));
+
+      mTimeFrameGPU->createNeighboursDevice(targetCellTopologyId);
+      if (mTimeFrameGPU->getNNeighbours()[targetCellTopologyId] == 0) {
+        mTimeFrameGPU->recordEvent(targetCellTopologyId);
+        continue;
+      }
+
+      for (int sourceCellTopologyId{0}; sourceCellTopologyId < hostTopology.nCells; ++sourceCellTopologyId) {
+        const auto sourceCellTopology = hostTopology.getCell(sourceCellTopologyId);
+        const int sourceCellsNum{static_cast<int>(mTimeFrameGPU->getNCells()[sourceCellTopologyId])};
+        if (!sourceCellsNum || sourceCellTopology.secondTransition != targetCellTopology.firstTransition) {
+          continue;
+        }
+        computeCellNeighboursHandler<NLayers>(mTimeFrameGPU->getDeviceArrayCells(),
+                                              mTimeFrameGPU->getDeviceNeighboursIndexTables(targetCellTopologyId),
+                                              mTimeFrameGPU->getDeviceArrayCellsLUT(),
+                                              mTimeFrameGPU->getDeviceNeighbours(targetCellTopologyId),
+                                              sourceCellTopologyId,
+                                              targetCellTopologyId,
+                                              this->mTrkParams[iteration].MaxChi2ClusterAttachment,
+                                              this->mBz,
+                                              sourceCellsNum,
+                                              mTimeFrameGPU->getStream(targetCellTopologyId));
+      }
+      mTimeFrameGPU->recordEvent(targetCellTopologyId);
     }
-    computeCellNeighboursHandler<NLayers>(mTimeFrameGPU->getDeviceArrayCells(),
-                                          mTimeFrameGPU->getDeviceNeighboursLUT(iLayer),
-                                          mTimeFrameGPU->getDeviceArrayCellsLUT(),
-                                          mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
-                                          mTimeFrameGPU->getDeviceNeighboursIndexTables(iLayer),
-                                          (const Tracklet**)mTimeFrameGPU->getDeviceArrayTracklets(),
-                                          this->mTrkParams[iteration].MaxChi2ClusterAttachment,
-                                          this->mBz,
-                                          iLayer,
-                                          currentLayerCellsNum,
-                                          nextLayerCellsNum,
-                                          1e2,
-                                          mTimeFrameGPU->getStream(iLayer));
-    mTimeFrameGPU->getArrayNNeighbours()[iLayer] = filterCellNeighboursHandler(mTimeFrameGPU->getDeviceNeighbourPairs(iLayer),
-                                                                               mTimeFrameGPU->getDeviceNeighbours(iLayer),
-                                                                               mTimeFrameGPU->getArrayNNeighbours()[iLayer],
-                                                                               mTimeFrameGPU->getStream(iLayer),
-                                                                               mTimeFrameGPU->getFrameworkAllocator());
-    mTimeFrameGPU->recordEvent(iLayer);
   }
   mTimeFrameGPU->syncStreams(false);
 }
@@ -286,26 +304,33 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
   bounded_vector<bounded_vector<int>> sharedFirstClusters(this->mTrkParams[iteration].NLayers, bounded_vector<int>(this->getMemoryPool().get()), this->getMemoryPool().get());
   firstClusters.resize(this->mTrkParams[iteration].NLayers);
   sharedFirstClusters.resize(this->mTrkParams[iteration].NLayers);
+  const auto hostTopology = mTimeFrameGPU->getTrackingTopologyView();
   for (int startLevel{this->mTrkParams[iteration].CellsPerRoad()}; startLevel >= this->mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
-    const int minimumLayer{startLevel - 1};
     bounded_vector<TrackSeed<NLayers>> trackSeeds(this->getMemoryPool().get());
-    for (int startLayer{this->mTrkParams[iteration].CellsPerRoad() - 1}; startLayer >= minimumLayer; --startLayer) {
-      if ((this->mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
+    for (int startCellTopologyId{0}; startCellTopologyId < hostTopology.nCells; ++startCellTopologyId) {
+      const int startLayer = hostTopology.getCell(startCellTopologyId).hitLayerMask.last();
+      if ((this->mTrkParams[iteration].StartLayerMask & (1 << startLayer)) == 0 ||
+          mTimeFrameGPU->getNCells()[startCellTopologyId] == 0) {
         continue;
       }
-      processNeighboursHandler<NLayers>(startLayer,
-                                        startLevel,
+      processNeighboursHandler<NLayers>(startLevel,
+                                        startCellTopologyId,
                                         mTimeFrameGPU->getDeviceArrayCells(),
-                                        mTimeFrameGPU->getDeviceCells()[startLayer],
-                                        mTimeFrameGPU->getArrayNCells(),
+                                        mTimeFrameGPU->getDeviceCells()[startCellTopologyId],
+                                        nullptr,
+                                        nullptr,
+                                        mTimeFrameGPU->getArrayNCells().data(),
                                         (const uint8_t**)mTimeFrameGPU->getDeviceArrayUsedClusters(),
-                                        mTimeFrameGPU->getDeviceNeighboursAll(),
-                                        mTimeFrameGPU->getDeviceNeighboursLUTs(),
+                                        mTimeFrameGPU->getDeviceArrayNeighbours(),
+                                        mTimeFrameGPU->getDeviceArrayNeighboursCellLUT(),
                                         mTimeFrameGPU->getDeviceArrayTrackingFrameInfo(),
                                         trackSeeds,
                                         this->mBz,
                                         this->mTrkParams[iteration].MaxChi2ClusterAttachment,
                                         this->mTrkParams[iteration].MaxChi2NDF,
+                                        this->mTrkParams[iteration].MaxHoles,
+                                        this->mTrkParams[iteration].MinTrackLength,
+                                        this->mTrkParams[iteration].HoleLayerMask,
                                         this->mTrkParams[iteration].LayerxX0,
                                         mTimeFrameGPU->getDevicePropagator(),
                                         this->mTrkParams[iteration].CorrType,
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
index a732327a64d15..571afe08fc209 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu
@@ -86,20 +86,25 @@ struct is_valid_pair {
 
 template <int NLayers>
 struct seed_selector {
-  float maxQ2Pt;
-  float maxChi2;
+  float mMaxQ2Pt;
+  float mMaxChi2;
+  int mMaxHoles;
+  int mMinTrackLength;
+  LayerMask mHoleLayerMask;
 
-  GPUhd() seed_selector(float maxQ2Pt, float maxChi2) : maxQ2Pt(maxQ2Pt), maxChi2(maxChi2) {}
+  GPUhd() seed_selector(float maxQ2Pt, float maxChi2, int maxHoles, int minTrackLength, LayerMask holeLayerMask) : mMaxQ2Pt(maxQ2Pt), mMaxChi2(maxChi2), mMaxHoles(maxHoles), mMinTrackLength(minTrackLength), mHoleLayerMask(holeLayerMask) {}
   GPUhd() bool operator()(const TrackSeed<NLayers>& seed) const
   {
-    return !(seed.getQ2Pt() > maxQ2Pt || seed.getChi2() > maxChi2);
+    return !(seed.getQ2Pt() > mMaxQ2Pt || seed.getChi2() > mMaxChi2) &&
+           seed.getHitLayerMask().length() >= mMinTrackLength &&
+           seed.getHitLayerMask().isAllowed(mMaxHoles, mHoleLayerMask);
   }
 };
 
 struct compare_track_chi2 {
   GPUhd() bool operator()(const TrackITSExt& a, const TrackITSExt& b) const
   {
-    return a.getChi2() < b.getChi2();
+    return o2::its::track::isBetter(a, b);
   }
 };
 
@@ -160,30 +165,22 @@ GPUg() void __launch_bounds__(256, 1) fitTrackSeedsKernel(
 template <bool initRun, int NLayers>
 GPUg() void __launch_bounds__(256, 1) computeLayerCellNeighboursKernel(
   CellSeed** cellSeedArray,
-  int* neighboursLUT,
-  int* neighboursIndexTable,
+  int* neighboursCursor,
   int** cellsLUTs,
-  gpuPair<int, int>* cellNeighbours,
-  const Tracklet** tracklets,
+  CellNeighbour* cellNeighbours,
+  const int sourceCellTopologyId,
+  const int targetCellTopologyId,
   const float maxChi2ClusterAttachment,
   const float bz,
-  const int layerIndex,
-  const unsigned int nCells,
-  const int maxCellNeighbours = 1e2)
+  const unsigned int nCells)
 {
   for (int iCurrentCellIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentCellIndex < nCells; iCurrentCellIndex += blockDim.x * gridDim.x) {
-    if constexpr (!initRun) {
-      if (neighboursIndexTable[iCurrentCellIndex] == neighboursIndexTable[iCurrentCellIndex + 1]) {
-        continue;
-      }
-    }
-    const auto& currentCellSeed{cellSeedArray[layerIndex][iCurrentCellIndex]};
+    const auto& currentCellSeed{cellSeedArray[sourceCellTopologyId][iCurrentCellIndex]};
     const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
-    const int nextLayerFirstCellIndex{cellsLUTs[layerIndex + 1][nextLayerTrackletIndex]};
-    const int nextLayerLastCellIndex{cellsLUTs[layerIndex + 1][nextLayerTrackletIndex + 1]};
-    int foundNeighbours{0};
+    const int nextLayerFirstCellIndex{cellsLUTs[targetCellTopologyId][nextLayerTrackletIndex]};
+    const int nextLayerLastCellIndex{cellsLUTs[targetCellTopologyId][nextLayerTrackletIndex + 1]};
     for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
-      auto nextCellSeed{cellSeedArray[layerIndex + 1][iNextCell]}; // Copy
+      auto nextCellSeed{cellSeedArray[targetCellTopologyId][iNextCell]}; // Copy
       if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex || !currentCellSeed.getTimeStamp().isCompatible(nextCellSeed.getTimeStamp())) {
         break;
       }
@@ -199,14 +196,13 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellNeighboursKernel(
       }
 
       if constexpr (initRun) {
-        atomicAdd(neighboursLUT + iNextCell, 1);
-        neighboursIndexTable[iCurrentCellIndex]++;
+        atomicAdd(neighboursCursor + iNextCell, 1);
       } else {
-        cellNeighbours[neighboursIndexTable[iCurrentCellIndex] + foundNeighbours] = {iCurrentCellIndex, iNextCell};
-        foundNeighbours++;
+        const int offset = atomicAdd(neighboursCursor + iNextCell, 1);
+        cellNeighbours[offset] = {sourceCellTopologyId, iCurrentCellIndex, targetCellTopologyId, iNextCell, currentCellSeed.getLevel() + 1};
         const int currentCellLevel{currentCellSeed.getLevel()};
         if (currentCellLevel >= nextCellSeed.getLevel()) {
-          atomicMax(cellSeedArray[layerIndex + 1][iNextCell].getLevelPtr(), currentCellLevel + 1);
+          atomicMax(cellSeedArray[targetCellTopologyId][iNextCell].getLevelPtr(), currentCellLevel + 1);
         }
       }
     }
@@ -221,7 +217,8 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
   Tracklet** tracklets,
   int** trackletsLUT,
   const int nTrackletsCurrent,
-  const int layer,
+  const int cellTopologyId,
+  const typename TrackingTopology<NLayers>::View topology,
   CellSeed* cells,
   int** cellsLUTs,
   const float* layerxX0,
@@ -230,25 +227,29 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
   const float cellDeltaTanLambdaSigma,
   const float nSigmaCut)
 {
+  const auto cellTopology = topology.getCell(cellTopologyId);
+  const auto first = topology.getTransition(cellTopology.firstTransition);
+  const auto second = topology.getTransition(cellTopology.secondTransition);
+  const int layers[3] = {first.fromLayer, first.toLayer, second.toLayer};
   for (int iCurrentTrackletIndex = blockIdx.x * blockDim.x + threadIdx.x; iCurrentTrackletIndex < nTrackletsCurrent; iCurrentTrackletIndex += blockDim.x * gridDim.x) {
     if constexpr (!initRun) {
-      if (cellsLUTs[layer][iCurrentTrackletIndex] == cellsLUTs[layer][iCurrentTrackletIndex + 1]) {
+      if (cellsLUTs[cellTopologyId][iCurrentTrackletIndex] == cellsLUTs[cellTopologyId][iCurrentTrackletIndex + 1]) {
         continue;
       }
     }
-    const Tracklet& currentTracklet = tracklets[layer][iCurrentTrackletIndex];
+    const Tracklet& currentTracklet = tracklets[cellTopology.firstTransition][iCurrentTrackletIndex];
     const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
-    const int nextLayerFirstTrackletIndex{trackletsLUT[layer + 1][nextLayerClusterIndex]};
-    const int nextLayerLastTrackletIndex{trackletsLUT[layer + 1][nextLayerClusterIndex + 1]};
+    const int nextLayerFirstTrackletIndex{trackletsLUT[cellTopology.secondTransition][nextLayerClusterIndex]};
+    const int nextLayerLastTrackletIndex{trackletsLUT[cellTopology.secondTransition][nextLayerClusterIndex + 1]};
     if (nextLayerFirstTrackletIndex == nextLayerLastTrackletIndex) {
       continue;
     }
     int foundCells{0};
     for (int iNextTrackletIndex{nextLayerFirstTrackletIndex}; iNextTrackletIndex < nextLayerLastTrackletIndex; ++iNextTrackletIndex) {
-      if (tracklets[layer + 1][iNextTrackletIndex].firstClusterIndex != nextLayerClusterIndex) {
+      if (tracklets[cellTopology.secondTransition][iNextTrackletIndex].firstClusterIndex != nextLayerClusterIndex) {
         break;
       }
-      const Tracklet& nextTracklet = tracklets[layer + 1][iNextTrackletIndex];
+      const Tracklet& nextTracklet = tracklets[cellTopology.secondTransition][iNextTrackletIndex];
       if (!currentTracklet.getTimeStamp().isCompatible(nextTracklet.getTimeStamp())) {
         continue;
       }
@@ -256,18 +257,18 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
 
       if (deltaTanLambda / cellDeltaTanLambdaSigma < nSigmaCut) {
         const int clusId[3]{
-          sortedClusters[layer][currentTracklet.firstClusterIndex].clusterId,
-          sortedClusters[layer + 1][nextTracklet.firstClusterIndex].clusterId,
-          sortedClusters[layer + 2][nextTracklet.secondClusterIndex].clusterId};
+          sortedClusters[layers[0]][currentTracklet.firstClusterIndex].clusterId,
+          sortedClusters[layers[1]][nextTracklet.firstClusterIndex].clusterId,
+          sortedClusters[layers[2]][nextTracklet.secondClusterIndex].clusterId};
 
-        const auto& cluster1_glo = unsortedClusters[layer][clusId[0]];
-        const auto& cluster2_glo = unsortedClusters[layer + 1][clusId[1]];
-        const auto& cluster3_tf = tfInfo[layer + 2][clusId[2]];
+        const auto& cluster1_glo = unsortedClusters[layers[0]][clusId[0]];
+        const auto& cluster2_glo = unsortedClusters[layers[1]][clusId[1]];
+        const auto& cluster3_tf = tfInfo[layers[2]][clusId[2]];
         auto track{o2::its::track::buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf, bz)};
         float chi2{0.f};
         bool good{false};
         for (int iC{2}; iC--;) {
-          const TrackingFrameInfo& trackingHit = tfInfo[layer + iC][clusId[iC]];
+          const TrackingFrameInfo& trackingHit = tfInfo[layers[iC]][clusId[iC]];
           if (!track.rotate(trackingHit.alphaTrackingFrame)) {
             break;
           }
@@ -275,7 +276,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
             break;
           }
 
-          if (!track.correctForMaterial(layerxX0[layer + iC], layerxX0[layer + iC] * constants::Radl * constants::Rho, true)) {
+          if (!track.correctForMaterial(layerxX0[layers[iC]], layerxX0[layers[iC]] * constants::Radl * constants::Rho, true)) {
             break;
           }
 
@@ -295,13 +296,13 @@ GPUg() void __launch_bounds__(256, 1) computeLayerCellsKernel(
         if constexpr (!initRun) {
           TimeEstBC ts = currentTracklet.getTimeStamp();
           ts += nextTracklet.getTimeStamp();
-          new (cells + cellsLUTs[layer][iCurrentTrackletIndex] + foundCells) CellSeed{layer, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2, ts};
+          new (cells + cellsLUTs[cellTopologyId][iCurrentTrackletIndex] + foundCells) CellSeed{cellTopology.hitLayerMask, clusId[0], clusId[1], clusId[2], iCurrentTrackletIndex, iNextTrackletIndex, track, chi2, ts};
         }
         ++foundCells;
       }
     }
     if constexpr (initRun) {
-      cellsLUTs[layer][iCurrentTrackletIndex] = foundCells;
+      cellsLUTs[cellTopologyId][iCurrentTrackletIndex] = foundCells;
     }
   }
 }
@@ -310,7 +311,8 @@ template <bool initRun, int NLayers>
 GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
   const IndexTableUtils<NLayers>* utils,
   const typename ROFMaskTable<NLayers>::View rofMask,
-  const int layerIndex,
+  const int transitionId,
+  const typename TrackingTopology<NLayers>::View topology,
   const typename ROFOverlapTable<NLayers>::View rofOverlaps,
   const typename ROFVertexLookupTable<NLayers>::View vertexLUT,
   const Vertex* vertices,
@@ -332,17 +334,20 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
   const float meanDeltaR,
   const float MSAngle)
 {
+  const auto transition = topology.getTransition(transitionId);
+  const int fromLayer = transition.fromLayer;
+  const int toLayer = transition.toLayer;
   const int phiBins{utils->getNphiBins()};
   const int zBins{utils->getNzBins()};
   const int tableSize{phiBins * zBins + 1};
-  const int totalROFs0 = rofOverlaps.getLayer(layerIndex).mNROFsTF;
-  const int totalROFs1 = rofOverlaps.getLayer(layerIndex + 1).mNROFsTF;
+  const int totalROFs0 = rofOverlaps.getLayer(fromLayer).mNROFsTF;
+  const int totalROFs1 = rofOverlaps.getLayer(toLayer).mNROFsTF;
   for (unsigned int pivotROF{blockIdx.x}; pivotROF < totalROFs0; pivotROF += gridDim.x) {
-    if (!rofMask.isROFEnabled(layerIndex, pivotROF)) {
+    if (!rofMask.isROFEnabled(fromLayer, pivotROF)) {
       continue;
     }
 
-    const auto& pvs = vertexLUT.getVertices(layerIndex, pivotROF);
+    const auto& pvs = vertexLUT.getVertices(fromLayer, pivotROF);
     auto primaryVertices = gpuSpan<const Vertex>(&vertices[pvs.getFirstEntry()], pvs.getEntries());
     if (primaryVertices.empty()) {
       continue;
@@ -353,12 +358,12 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
       continue;
     }
 
-    const auto& rofOverlap = rofOverlaps.getOverlap(layerIndex, layerIndex + 1, pivotROF);
+    const auto& rofOverlap = rofOverlaps.getOverlap(fromLayer, toLayer, pivotROF);
     if (!rofOverlap.getEntries()) {
       continue;
     }
 
-    auto clustersCurrentLayer = getClustersOnLayer(pivotROF, totalROFs0, layerIndex, ROFClusters, clusters);
+    auto clustersCurrentLayer = getClustersOnLayer(pivotROF, totalROFs0, fromLayer, ROFClusters, clusters);
     if (clustersCurrentLayer.empty()) {
       continue;
     }
@@ -367,12 +372,12 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
 
       unsigned int storedTracklets{0};
       const auto& currentCluster{clustersCurrentLayer[currentClusterIndex]};
-      const int currentSortedIndex{ROFClusters[layerIndex][pivotROF] + currentClusterIndex};
-      if (usedClusters[layerIndex][currentCluster.clusterId]) {
+      const int currentSortedIndex{ROFClusters[fromLayer][pivotROF] + currentClusterIndex};
+      if (usedClusters[fromLayer][currentCluster.clusterId]) {
         continue;
       }
       if constexpr (!initRun) {
-        if (trackletsLUT[layerIndex][currentSortedIndex] == trackletsLUT[layerIndex][currentSortedIndex + 1]) {
+        if (trackletsLUT[transitionId][currentSortedIndex] == trackletsLUT[transitionId][currentSortedIndex + 1]) {
           continue;
         }
       }
@@ -380,7 +385,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
       const float inverseR0{1.f / currentCluster.radius};
       for (int iV{startVtx}; iV < endVtx; ++iV) {
         auto& primaryVertex{primaryVertices[iV]};
-        if (!vertexLUT.isVertexCompatible(layerIndex, pivotROF, primaryVertex)) {
+        if (!vertexLUT.isVertexCompatible(fromLayer, pivotROF, primaryVertex)) {
           continue;
         }
         if (primaryVertex.isFlagSet(Vertex::Flags::UPCMode) != selectUPCVertices) {
@@ -393,7 +398,7 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
         const float zAtRmax{tanLambda * (maxR - currentCluster.radius) + currentCluster.zCoordinate};
         const float sqInverseDeltaZ0{1.f / (math_utils::Sq(currentCluster.zCoordinate - primaryVertex.getZ()) + constants::Tolerance)}; /// protecting from overflows adding the detector resolution
         const float sigmaZ{o2::gpu::CAMath::Sqrt(math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInverseDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * MSAngle))};
-        const int4 selectedBinsRect{o2::its::getBinsRect(currentCluster, layerIndex + 1, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut, *utils)};
+        const int4 selectedBinsRect{o2::its::getBinsRect(currentCluster, toLayer, zAtRmin, zAtRmax, sigmaZ * NSigmaCut, phiCut, *utils)};
         if (selectedBinsRect.x < 0) {
           continue;
         }
@@ -404,14 +409,14 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
         }
 
         for (short targetROF = rofOverlap.getFirstEntry(); targetROF < rofOverlap.getEntriesBound(); ++targetROF) {
-          if (!rofMask.isROFEnabled(layerIndex + 1, targetROF)) {
+          if (!rofMask.isROFEnabled(toLayer, targetROF)) {
             continue;
           }
-          auto clustersNextLayer = getClustersOnLayer(targetROF, totalROFs1, layerIndex + 1, ROFClusters, clusters);
+          auto clustersNextLayer = getClustersOnLayer(targetROF, totalROFs1, toLayer, ROFClusters, clusters);
           if (clustersNextLayer.empty()) {
             continue;
           }
-          const auto ts = rofOverlaps.getTimeStamp(layerIndex, pivotROF, layerIndex + 1, targetROF);
+          const auto ts = rofOverlaps.getTimeStamp(fromLayer, pivotROF, toLayer, targetROF);
           if (!ts.isCompatible(primaryVertex.getTimeStamp())) {
             continue;
           }
@@ -419,26 +424,26 @@ GPUg() void __launch_bounds__(256, 1) computeLayerTrackletsMultiROFKernel(
             int iPhiBin = (selectedBinsRect.y + iPhiCount) % phiBins;
             const int firstBinIndex{utils->getBinIndex(selectedBinsRect.x, iPhiBin)};
             const int maxBinIndex{firstBinIndex + selectedBinsRect.z - selectedBinsRect.x + 1};
-            const int firstRowClusterIndex = indexTables[layerIndex + 1][(targetROF)*tableSize + firstBinIndex];
-            const int maxRowClusterIndex = indexTables[layerIndex + 1][(targetROF)*tableSize + maxBinIndex];
+            const int firstRowClusterIndex = indexTables[toLayer][(targetROF)*tableSize + firstBinIndex];
+            const int maxRowClusterIndex = indexTables[toLayer][(targetROF)*tableSize + maxBinIndex];
             for (int nextClusterIndex{firstRowClusterIndex}; nextClusterIndex < maxRowClusterIndex; ++nextClusterIndex) {
               if (nextClusterIndex >= clustersNextLayer.size()) {
                 break;
               }
               const Cluster& nextCluster{clustersNextLayer[nextClusterIndex]};
-              if (usedClusters[layerIndex + 1][nextCluster.clusterId]) {
+              if (usedClusters[toLayer][nextCluster.clusterId]) {
                 continue;
               }
               const float deltaPhi{o2::gpu::CAMath::Abs(currentCluster.phi - nextCluster.phi)};
               const float deltaZ{o2::gpu::CAMath::Abs(tanLambda * (nextCluster.radius - currentCluster.radius) + currentCluster.zCoordinate - nextCluster.zCoordinate)};
               if (deltaZ / sigmaZ < NSigmaCut && (deltaPhi < phiCut || o2::gpu::CAMath::Abs(deltaPhi - o2::constants::math::TwoPI) < phiCut)) {
                 if constexpr (initRun) {
-                  trackletsLUT[layerIndex][currentSortedIndex]++; // we need l0 as well for usual exclusive sums.
+                  trackletsLUT[transitionId][currentSortedIndex]++; // we need l0 as well for usual exclusive sums.
                 } else {
                   const float phi{o2::gpu::CAMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate)};
                   const float tanL{(currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius)};
-                  const int nextSortedIndex{ROFClusters[layerIndex + 1][targetROF] + nextClusterIndex};
-                  new (tracklets[layerIndex] + trackletsLUT[layerIndex][currentSortedIndex] + storedTracklets) Tracklet{currentSortedIndex, nextSortedIndex, tanL, phi, ts};
+                  const int nextSortedIndex{ROFClusters[toLayer][targetROF] + nextClusterIndex};
+                  new (tracklets[transitionId] + trackletsLUT[transitionId][currentSortedIndex] + storedTracklets) Tracklet{currentSortedIndex, nextSortedIndex, tanL, phi, ts};
                 }
                 ++storedTracklets;
               }
@@ -462,18 +467,20 @@ GPUg() void __launch_bounds__(256, 1) compileTrackletsLookupTableKernel(
 
 template <bool dryRun, int NLayers, typename CurrentSeed>
 GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
-  const int layer,
+  const int defaultCellTopologyId,
   const int level,
   CellSeed** allCellSeeds,
   CurrentSeed* currentCellSeeds,
   const int* currentCellIds,
+  const int* currentCellTopologyIds,
   const unsigned int nCurrentCells,
   TrackSeed<NLayers>* updatedCellSeeds,
   int* updatedCellsIds,
+  int* updatedCellTopologyIds,
   int* foundSeedsTable,               // auxiliary only in GPU code to compute the number of cells per iteration
   const unsigned char** usedClusters, // Used clusters
-  int* neighbours,
-  int* neighboursLUT,
+  CellNeighbour** neighbours,
+  int** neighboursLUT,
   const TrackingFrameInfo** foundTrackingFrameInfo,
   const float* layerxX0,
   const float bz,
@@ -489,22 +496,33 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
     }
     int foundSeeds{0};
     const auto& currentCell{currentCellSeeds[iCurrentCell]};
+    const int cellTopologyId = currentCellTopologyIds == nullptr ? defaultCellTopologyId : currentCellTopologyIds[iCurrentCell];
     if (currentCell.getLevel() != level) {
       continue;
     }
-    if (currentCellIds == nullptr && (usedClusters[layer][currentCell.getFirstClusterIndex()] ||
-                                      usedClusters[layer + 1][currentCell.getSecondClusterIndex()] ||
-                                      usedClusters[layer + 2][currentCell.getThirdClusterIndex()])) {
-      continue;
+    if (currentCellIds == nullptr) {
+      bool used = false;
+      for (int layer = 0; layer < NLayers; ++layer) {
+        const int clusterIndex = currentCell.getCluster(layer);
+        used |= clusterIndex != constants::UnusedIndex && usedClusters[layer][clusterIndex];
+      }
+      if (used) {
+        continue;
+      }
     }
     const int cellId = currentCellIds == nullptr ? iCurrentCell : currentCellIds[iCurrentCell];
+    if (cellTopologyId < 0 || neighboursLUT[cellTopologyId] == nullptr || neighbours[cellTopologyId] == nullptr) {
+      continue;
+    }
 
-    const int startNeighbourId{cellId ? neighboursLUT[cellId - 1] : 0};
-    const int endNeighbourId{neighboursLUT[cellId]};
+    const int startNeighbourId{neighboursLUT[cellTopologyId][cellId]};
+    const int endNeighbourId{neighboursLUT[cellTopologyId][cellId + 1]};
 
     for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
-      const int neighbourCellId = neighbours[iNeighbourCell];
-      const auto& neighbourCell = allCellSeeds[layer - 1][neighbourCellId];
+      const auto& neighbourRef = neighbours[cellTopologyId][iNeighbourCell];
+      const int neighbourCellTopologyId = neighbourRef.cellTopology;
+      const int neighbourCellId = neighbourRef.cell;
+      const auto& neighbourCell = allCellSeeds[neighbourCellTopologyId][neighbourCellId];
 
       if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
         continue;
@@ -515,11 +533,13 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
       if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
         continue;
       }
-      if (usedClusters[layer - 1][neighbourCell.getFirstClusterIndex()]) {
+      const int neighbourLayer = neighbourCell.getInnerLayer();
+      const int neighbourCluster = neighbourCell.getFirstClusterIndex();
+      if (usedClusters[neighbourLayer][neighbourCluster]) {
         continue;
       }
       TrackSeed<NLayers> seed{currentCell};
-      auto& trHit = foundTrackingFrameInfo[layer - 1][neighbourCell.getFirstClusterIndex()];
+      auto& trHit = foundTrackingFrameInfo[neighbourLayer][neighbourCluster];
 
       if (!seed.rotate(trHit.alphaTrackingFrame)) {
         continue;
@@ -530,7 +550,7 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
       }
 
       if (matCorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-        if (!seed.correctForMaterial(layerxX0[layer - 1], layerxX0[layer - 1] * constants::Radl * constants::Rho, true)) {
+        if (!seed.correctForMaterial(layerxX0[neighbourLayer], layerxX0[neighbourLayer] * constants::Radl * constants::Rho, true)) {
           continue;
         }
       }
@@ -546,11 +566,15 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
       if constexpr (dryRun) {
         foundSeedsTable[iCurrentCell]++;
       } else {
-        seed.getClusters()[layer - 1] = neighbourCell.getFirstClusterIndex();
+        seed.getClusters()[neighbourLayer] = neighbourCluster;
+        auto mask = seed.getHitLayerMask();
+        mask.set(neighbourLayer);
+        seed.setHitLayerMask(mask);
         seed.setLevel(neighbourCell.getLevel());
         seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
         seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
         updatedCellsIds[foundSeedsTable[iCurrentCell] + foundSeeds] = neighbourCellId;
+        updatedCellTopologyIds[foundSeedsTable[iCurrentCell] + foundSeeds] = neighbourCellTopologyId;
         updatedCellSeeds[foundSeedsTable[iCurrentCell] + foundSeeds] = seed;
       }
       foundSeeds++;
@@ -563,7 +587,9 @@ GPUg() void __launch_bounds__(256, 1) processNeighboursKernel(
 template <int NLayers>
 void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  const typename ROFMaskTable<NLayers>::View& rofMask,
-                                 const int layer,
+                                 const int transitionId,
+                                 const int fromLayer,
+                                 const int toLayer,
                                  const typename ROFOverlapTable<NLayers>::View& rofOverlaps,
                                  const typename ROFVertexLookupTable<NLayers>::View& vertexLUT,
                                  const int vertexId,
@@ -578,20 +604,22 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                  gsl::span<int*> trackletsLUTsHost,
                                  const bool selectUPCVertices,
                                  const float NSigmaCut,
-                                 bounded_vector<float>& phiCuts,
+                                 const typename TrackingTopology<NLayers>::View topology,
+                                 bounded_vector<float>& transitionPhiCuts,
                                  const float resolutionPV,
                                  std::array<float, NLayers>& minRs,
                                  std::array<float, NLayers>& maxRs,
                                  bounded_vector<float>& resolutions,
                                  std::vector<float>& radii,
-                                 bounded_vector<float>& mulScatAng,
+                                 bounded_vector<float>& transitionMSAngles,
                                  o2::its::ExternalAllocator* alloc,
                                  gpu::Streams& streams)
 {
-  gpu::computeLayerTrackletsMultiROFKernel<true><<<60, 256, 0, streams[layer].get()>>>(
+  gpu::computeLayerTrackletsMultiROFKernel<true><<<60, 256, 0, streams[transitionId].get()>>>(
     utils,
     rofMask,
-    layer,
+    transitionId,
+    topology,
     rofOverlaps,
     vertexLUT,
     vertices,
@@ -605,21 +633,23 @@ void countTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
     trackletsLUTs,
     selectUPCVertices,
     NSigmaCut,
-    phiCuts[layer],
+    transitionPhiCuts[transitionId],
     resolutionPV,
-    minRs[layer + 1],
-    maxRs[layer + 1],
-    resolutions[layer],
-    radii[layer + 1] - radii[layer],
-    mulScatAng[layer]);
-  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[layer].get());
-  thrust::exclusive_scan(nosync_policy, trackletsLUTsHost[layer], trackletsLUTsHost[layer] + nClusters[layer] + 1, trackletsLUTsHost[layer]);
+    minRs[toLayer],
+    maxRs[toLayer],
+    resolutions[fromLayer],
+    radii[toLayer] - radii[fromLayer],
+    transitionMSAngles[transitionId]);
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[transitionId].get());
+  thrust::exclusive_scan(nosync_policy, trackletsLUTsHost[transitionId], trackletsLUTsHost[transitionId] + nClusters[fromLayer] + 1, trackletsLUTsHost[transitionId]);
 }
 
 template <int NLayers>
 void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    const typename ROFMaskTable<NLayers>::View& rofMask,
-                                   const int layer,
+                                   const int transitionId,
+                                   const int fromLayer,
+                                   const int toLayer,
                                    const typename ROFOverlapTable<NLayers>::View& rofOverlaps,
                                    const typename ROFVertexLookupTable<NLayers>::View& vertexLUT,
                                    const int vertexId,
@@ -637,20 +667,22 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
                                    gsl::span<int*> trackletsLUTsHost,
                                    const bool selectUPCVertices,
                                    const float NSigmaCut,
-                                   bounded_vector<float>& phiCuts,
+                                   const typename TrackingTopology<NLayers>::View topology,
+                                   bounded_vector<float>& transitionPhiCuts,
                                    const float resolutionPV,
                                    std::array<float, NLayers>& minRs,
                                    std::array<float, NLayers>& maxRs,
                                    bounded_vector<float>& resolutions,
                                    std::vector<float>& radii,
-                                   bounded_vector<float>& mulScatAng,
+                                   bounded_vector<float>& transitionMSAngles,
                                    o2::its::ExternalAllocator* alloc,
                                    gpu::Streams& streams)
 {
-  gpu::computeLayerTrackletsMultiROFKernel<false><<<60, 256, 0, streams[layer].get()>>>(
+  gpu::computeLayerTrackletsMultiROFKernel<false><<<60, 256, 0, streams[transitionId].get()>>>(
     utils,
     rofMask,
-    layer,
+    transitionId,
+    topology,
     rofOverlaps,
     vertexLUT,
     vertices,
@@ -664,25 +696,25 @@ void computeTrackletsInROFsHandler(const IndexTableUtils<NLayers>* utils,
     trackletsLUTs,
     selectUPCVertices,
     NSigmaCut,
-    phiCuts[layer],
+    transitionPhiCuts[transitionId],
     resolutionPV,
-    minRs[layer + 1],
-    maxRs[layer + 1],
-    resolutions[layer],
-    radii[layer + 1] - radii[layer],
-    mulScatAng[layer]);
-  thrust::device_ptr<Tracklet> tracklets_ptr(spanTracklets[layer]);
-  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[layer].get());
-  thrust::sort(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[layer]);
-  auto unique_end = thrust::unique(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[layer]);
-  nTracklets[layer] = unique_end - tracklets_ptr;
-  if (layer) {
-    GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[layer], 0, (nClusters[layer] + 1) * sizeof(int), streams[layer].get()));
-    gpu::compileTrackletsLookupTableKernel<<<60, 256, 0, streams[layer].get()>>>(
-      spanTracklets[layer],
-      trackletsLUTsHost[layer],
-      nTracklets[layer]);
-    thrust::exclusive_scan(nosync_policy, trackletsLUTsHost[layer], trackletsLUTsHost[layer] + nClusters[layer] + 1, trackletsLUTsHost[layer]);
+    minRs[toLayer],
+    maxRs[toLayer],
+    resolutions[fromLayer],
+    radii[toLayer] - radii[fromLayer],
+    transitionMSAngles[transitionId]);
+  thrust::device_ptr<Tracklet> tracklets_ptr(spanTracklets[transitionId]);
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[transitionId].get());
+  thrust::sort(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[transitionId]);
+  auto unique_end = thrust::unique(nosync_policy, tracklets_ptr, tracklets_ptr + nTracklets[transitionId]);
+  nTracklets[transitionId] = unique_end - tracklets_ptr;
+  if (fromLayer > 0) {
+    GPUChkErrS(cudaMemsetAsync(trackletsLUTsHost[transitionId], 0, (nClusters[fromLayer] + 1) * sizeof(int), streams[transitionId].get()));
+    gpu::compileTrackletsLookupTableKernel<<<60, 256, 0, streams[transitionId].get()>>>(
+      spanTracklets[transitionId],
+      trackletsLUTsHost[transitionId],
+      nTracklets[transitionId]);
+    thrust::exclusive_scan(nosync_policy, trackletsLUTsHost[transitionId], trackletsLUTsHost[transitionId] + nClusters[fromLayer] + 1, trackletsLUTsHost[transitionId]);
   }
 }
 
@@ -694,7 +726,8 @@ void countCellsHandler(
   Tracklet** tracklets,
   int** trackletsLUT,
   const int nTracklets,
-  const int layer,
+  const int cellTopologyId,
+  const typename TrackingTopology<NLayers>::View topology,
   CellSeed* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
@@ -707,14 +740,15 @@ void countCellsHandler(
   gpu::Streams& streams)
 {
   thrust::device_vector<float> layerxX0(layerxX0Host);
-  gpu::computeLayerCellsKernel<true, NLayers><<<60, 256, 0, streams[layer].get()>>>(
-    sortedClusters,       // const Cluster**
-    unsortedClusters,     // const Cluster**
-    tfInfo,               // const TrackingFrameInfo**
-    tracklets,            // const Tracklets**
-    trackletsLUT,         // const int**
-    nTracklets,           // const int
-    layer,                // const int
+  gpu::computeLayerCellsKernel<true, NLayers><<<60, 256, 0, streams[cellTopologyId].get()>>>(
+    sortedClusters,   // const Cluster**
+    unsortedClusters, // const Cluster**
+    tfInfo,           // const TrackingFrameInfo**
+    tracklets,        // const Tracklets**
+    trackletsLUT,     // const int**
+    nTracklets,       // const int
+    cellTopologyId,   // const int
+    topology,
     cells,                // CellSeed*
     cellsLUTsArrayDevice, // int**
     thrust::raw_pointer_cast(&layerxX0[0]),
@@ -722,7 +756,7 @@ void countCellsHandler(
     maxChi2ClusterAttachment, // const float
     cellDeltaTanLambdaSigma,  // const float
     nSigmaCut);               // const float
-  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[layer].get());
+  auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(streams[cellTopologyId].get());
   thrust::exclusive_scan(nosync_policy, cellsLUTsHost, cellsLUTsHost + nTracklets + 1, cellsLUTsHost);
 }
 
@@ -734,7 +768,8 @@ void computeCellsHandler(
   Tracklet** tracklets,
   int** trackletsLUT,
   const int nTracklets,
-  const int layer,
+  const int cellTopologyId,
+  const typename TrackingTopology<NLayers>::View topology,
   CellSeed* cells,
   int** cellsLUTsArrayDevice,
   int* cellsLUTsHost,
@@ -746,14 +781,15 @@ void computeCellsHandler(
   gpu::Streams& streams)
 {
   thrust::device_vector<float> layerxX0(layerxX0Host);
-  gpu::computeLayerCellsKernel<false, NLayers><<<60, 256, 0, streams[layer].get()>>>(
-    sortedClusters,       // const Cluster**
-    unsortedClusters,     // const Cluster**
-    tfInfo,               // const TrackingFrameInfo**
-    tracklets,            // const Tracklets**
-    trackletsLUT,         // const int**
-    nTracklets,           // const int
-    layer,                // const int
+  gpu::computeLayerCellsKernel<false, NLayers><<<60, 256, 0, streams[cellTopologyId].get()>>>(
+    sortedClusters,   // const Cluster**
+    unsortedClusters, // const Cluster**
+    tfInfo,           // const TrackingFrameInfo**
+    tracklets,        // const Tracklets**
+    trackletsLUT,     // const int**
+    nTracklets,       // const int
+    cellTopologyId,   // const int
+    topology,
     cells,                // CellSeed*
     cellsLUTsArrayDevice, // int**
     thrust::raw_pointer_cast(&layerxX0[0]),
@@ -765,64 +801,60 @@ void computeCellsHandler(
 
 template <int NLayers>
 void countCellNeighboursHandler(CellSeed** cellsLayersDevice,
-                                int* neighboursLUT,
+                                int* neighboursCursor,
                                 int** cellsLUTs,
-                                gpuPair<int, int>* cellNeighbours,
-                                int* neighboursIndexTable,
-                                const Tracklet** tracklets,
+                                const int sourceCellTopologyId,
+                                const int targetCellTopologyId,
                                 const float maxChi2ClusterAttachment,
                                 const float bz,
-                                const int layerIndex,
                                 const unsigned int nCells,
-                                const unsigned int nCellsNext,
-                                const int maxCellNeighbours,
-                                o2::its::ExternalAllocator* alloc,
                                 gpu::Stream& stream)
 {
   gpu::computeLayerCellNeighboursKernel<true, NLayers><<<60, 256, 0, stream.get()>>>(
     cellsLayersDevice,
-    neighboursLUT,
-    neighboursIndexTable,
+    neighboursCursor,
     cellsLUTs,
-    cellNeighbours,
-    tracklets,
+    nullptr,
+    sourceCellTopologyId,
+    targetCellTopologyId,
     maxChi2ClusterAttachment,
     bz,
-    layerIndex,
-    nCells,
-    maxCellNeighbours);
+    nCells);
+}
+
+void scanCellNeighboursHandler(int* neighboursCursor,
+                               int* neighboursLUT,
+                               const unsigned int nCells,
+                               o2::its::ExternalAllocator* alloc,
+                               gpu::Stream& stream)
+{
   auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(stream.get());
-  thrust::inclusive_scan(nosync_policy, neighboursLUT, neighboursLUT + nCellsNext, neighboursLUT);
-  thrust::exclusive_scan(nosync_policy, neighboursIndexTable, neighboursIndexTable + nCells + 1, neighboursIndexTable);
+  thrust::exclusive_scan(nosync_policy, neighboursCursor, neighboursCursor + nCells + 1, neighboursCursor);
+  GPUChkErrS(cudaMemcpyAsync(neighboursLUT, neighboursCursor, (nCells + 1) * sizeof(int), cudaMemcpyDeviceToDevice, stream.get()));
 }
 
 template <int NLayers>
 void computeCellNeighboursHandler(CellSeed** cellsLayersDevice,
-                                  int* neighboursLUT,
+                                  int* neighboursCursor,
                                   int** cellsLUTs,
-                                  gpuPair<int, int>* cellNeighbours,
-                                  int* neighboursIndexTable,
-                                  const Tracklet** tracklets,
+                                  CellNeighbour* cellNeighbours,
+                                  const int sourceCellTopologyId,
+                                  const int targetCellTopologyId,
                                   const float maxChi2ClusterAttachment,
                                   const float bz,
-                                  const int layerIndex,
                                   const unsigned int nCells,
-                                  const unsigned int nCellsNext,
-                                  const int maxCellNeighbours,
                                   gpu::Stream& stream)
 {
   gpu::computeLayerCellNeighboursKernel<false, NLayers><<<60, 256, 0, stream.get()>>>(
     cellsLayersDevice,
-    neighboursLUT,
-    neighboursIndexTable,
+    neighboursCursor,
     cellsLUTs,
     cellNeighbours,
-    tracklets,
+    sourceCellTopologyId,
+    targetCellTopologyId,
     maxChi2ClusterAttachment,
     bz,
-    layerIndex,
-    nCells,
-    maxCellNeighbours);
+    nCells);
 }
 
 int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
@@ -842,19 +874,24 @@ int filterCellNeighboursHandler(gpuPair<int, int>* cellNeighbourPairs,
 }
 
 template <int NLayers>
-void processNeighboursHandler(const int startLayer,
-                              const int startLevel,
+void processNeighboursHandler(const int startLevel,
+                              const int defaultCellTopologyId,
                               CellSeed** allCellSeeds,
                               CellSeed* currentCellSeeds,
-                              std::array<int, NLayers - 2>& nCells,
+                              const int* currentCellTopologyIds,
+                              const int* currentCellIds,
+                              const int* nCells,
                               const unsigned char** usedClusters,
-                              std::array<int*, NLayers - 2>& neighbours,
-                              gsl::span<int*> neighboursDeviceLUTs,
+                              CellNeighbour** neighbours,
+                              int** neighboursDeviceLUTs,
                               const TrackingFrameInfo** foundTrackingFrameInfo,
                               bounded_vector<TrackSeed<NLayers>>& seedsHost,
                               const float bz,
                               const float maxChi2ClusterAttachment,
                               const float maxChi2NDF,
+                              const int maxHoles,
+                              const int minTrackLength,
+                              const LayerMask holeLayerMask,
                               const std::vector<float>& layerxX0Host,
                               const o2::base::Propagator* propagator,
                               const o2::base::PropagatorF::MatCorrType matCorrType,
@@ -865,22 +902,24 @@ void processNeighboursHandler(const int startLayer,
   auto allocInt = gpu::TypedAllocator<int>(alloc);
   auto allocTrackSeed = gpu::TypedAllocator<TrackSeed<NLayers>>(alloc);
   thrust::device_vector<float> layerxX0(layerxX0Host);
-  thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[startLayer] + 1, 0, allocInt);
+  thrust::device_vector<int, gpu::TypedAllocator<int>> foundSeedsTable(nCells[defaultCellTopologyId] + 1, 0, allocInt);
   auto nosync_policy = THRUST_NAMESPACE::par_nosync(gpu::TypedAllocator<char>(alloc)).on(gpu::Stream::DefaultStream);
 
   gpu::processNeighboursKernel<true, NLayers, CellSeed><<<60, 256>>>(
-    startLayer,
+    defaultCellTopologyId,
     startLevel,
     allCellSeeds,
     currentCellSeeds,
     nullptr,
-    nCells[startLayer],
+    nullptr,
+    nCells[defaultCellTopologyId],
+    nullptr,
     nullptr,
     nullptr,
     thrust::raw_pointer_cast(&foundSeedsTable[0]),
     usedClusters,
-    neighbours[startLayer - 1],
-    neighboursDeviceLUTs[startLayer - 1],
+    neighbours,
+    neighboursDeviceLUTs,
     foundTrackingFrameInfo,
     thrust::raw_pointer_cast(&layerxX0[0]),
     bz,
@@ -890,20 +929,23 @@ void processNeighboursHandler(const int startLayer,
   thrust::exclusive_scan(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), foundSeedsTable.begin());
 
   thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellId(foundSeedsTable.back(), 0, allocInt);
+  thrust::device_vector<int, gpu::TypedAllocator<int>> updatedCellTopologyId(foundSeedsTable.back(), 0, allocInt);
   thrust::device_vector<TrackSeed<NLayers>, gpu::TypedAllocator<TrackSeed<NLayers>>> updatedCellSeed(foundSeedsTable.back(), allocTrackSeed);
   gpu::processNeighboursKernel<false, NLayers, CellSeed><<<60, 256>>>(
-    startLayer,
+    defaultCellTopologyId,
     startLevel,
     allCellSeeds,
     currentCellSeeds,
     nullptr,
-    nCells[startLayer],
+    nullptr,
+    nCells[defaultCellTopologyId],
     thrust::raw_pointer_cast(&updatedCellSeed[0]),
     thrust::raw_pointer_cast(&updatedCellId[0]),
+    thrust::raw_pointer_cast(&updatedCellTopologyId[0]),
     thrust::raw_pointer_cast(&foundSeedsTable[0]),
     usedClusters,
-    neighbours[startLayer - 1],
-    neighboursDeviceLUTs[startLayer - 1],
+    neighbours,
+    neighboursDeviceLUTs,
     foundTrackingFrameInfo,
     thrust::raw_pointer_cast(&layerxX0[0]),
     bz,
@@ -914,29 +956,35 @@ void processNeighboursHandler(const int startLayer,
 
   int level = startLevel;
   thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellId(allocInt);
+  thrust::device_vector<int, gpu::TypedAllocator<int>> lastCellTopologyId(allocInt);
   thrust::device_vector<TrackSeed<NLayers>, gpu::TypedAllocator<TrackSeed<NLayers>>> lastCellSeed(allocTrackSeed);
-  for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
+  while (level > 2 && !updatedCellSeed.empty()) {
     lastCellSeed.swap(updatedCellSeed);
     lastCellId.swap(updatedCellId);
+    lastCellTopologyId.swap(updatedCellTopologyId);
     thrust::device_vector<TrackSeed<NLayers>, gpu::TypedAllocator<TrackSeed<NLayers>>>(allocTrackSeed).swap(updatedCellSeed);
     thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellId);
+    thrust::device_vector<int, gpu::TypedAllocator<int>>(allocInt).swap(updatedCellTopologyId);
     auto lastCellSeedSize{lastCellSeed.size()};
     foundSeedsTable.resize(lastCellSeedSize + 1);
     thrust::fill(nosync_policy, foundSeedsTable.begin(), foundSeedsTable.end(), 0);
 
+    --level;
     gpu::processNeighboursKernel<true, NLayers, TrackSeed<NLayers>><<<60, 256>>>(
-      iLayer,
-      --level,
+      constants::UnusedIndex,
+      level,
       allCellSeeds,
       thrust::raw_pointer_cast(&lastCellSeed[0]),
       thrust::raw_pointer_cast(&lastCellId[0]),
+      thrust::raw_pointer_cast(&lastCellTopologyId[0]),
       lastCellSeedSize,
       nullptr,
       nullptr,
+      nullptr,
       thrust::raw_pointer_cast(&foundSeedsTable[0]),
       usedClusters,
-      neighbours[iLayer - 1],
-      neighboursDeviceLUTs[iLayer - 1],
+      neighbours,
+      neighboursDeviceLUTs,
       foundTrackingFrameInfo,
       thrust::raw_pointer_cast(&layerxX0[0]),
       bz,
@@ -948,22 +996,26 @@ void processNeighboursHandler(const int startLayer,
     auto foundSeeds{foundSeedsTable.back()};
     updatedCellId.resize(foundSeeds);
     thrust::fill(nosync_policy, updatedCellId.begin(), updatedCellId.end(), 0);
+    updatedCellTopologyId.resize(foundSeeds);
+    thrust::fill(nosync_policy, updatedCellTopologyId.begin(), updatedCellTopologyId.end(), 0);
     updatedCellSeed.resize(foundSeeds);
     thrust::fill(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), TrackSeed<NLayers>());
 
     gpu::processNeighboursKernel<false, NLayers, TrackSeed<NLayers>><<<60, 256>>>(
-      iLayer,
+      constants::UnusedIndex,
       level,
       allCellSeeds,
       thrust::raw_pointer_cast(&lastCellSeed[0]),
       thrust::raw_pointer_cast(&lastCellId[0]),
+      thrust::raw_pointer_cast(&lastCellTopologyId[0]),
       lastCellSeedSize,
       thrust::raw_pointer_cast(&updatedCellSeed[0]),
       thrust::raw_pointer_cast(&updatedCellId[0]),
+      thrust::raw_pointer_cast(&updatedCellTopologyId[0]),
       thrust::raw_pointer_cast(&foundSeedsTable[0]),
       usedClusters,
-      neighbours[iLayer - 1],
-      neighboursDeviceLUTs[iLayer - 1],
+      neighbours,
+      neighboursDeviceLUTs,
       foundTrackingFrameInfo,
       thrust::raw_pointer_cast(&layerxX0[0]),
       bz,
@@ -973,7 +1025,7 @@ void processNeighboursHandler(const int startLayer,
   }
   GPUChkErrS(cudaStreamSynchronize(gpu::Stream::DefaultStream));
   thrust::device_vector<TrackSeed<NLayers>, gpu::TypedAllocator<TrackSeed<NLayers>>> outSeeds(updatedCellSeed.size(), allocTrackSeed);
-  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector<NLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5)));
+  auto end = thrust::copy_if(nosync_policy, updatedCellSeed.begin(), updatedCellSeed.end(), outSeeds.begin(), gpu::seed_selector<NLayers>(1.e3, maxChi2NDF * ((startLevel + 2) * 2 - 5), maxHoles, minTrackLength, holeLayerMask));
   auto s{end - outSeeds.begin()};
   seedsHost.reserve(seedsHost.size() + s);
   thrust::copy(outSeeds.begin(), outSeeds.begin() + s, std::back_inserter(seedsHost));
@@ -1081,7 +1133,9 @@ void computeTrackSeedHandler(TrackSeed<NLayers>* trackSeeds,
 /// Explicit instantiation of ITS2 handlers
 template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                              const ROFMaskTable<7>::View& rofMask,
-                                             const int layer,
+                                             const int transitionId,
+                                             const int fromLayer,
+                                             const int toLayer,
                                              const ROFOverlapTable<7>::View& rofOverlaps,
                                              const ROFVertexLookupTable<7>::View& vertexLUT,
                                              const int vertexId,
@@ -1096,19 +1150,22 @@ template void countTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                              gsl::span<int*> trackletsLUTsHost,
                                              const bool selectUPCVertices,
                                              const float NSigmaCut,
-                                             bounded_vector<float>& phiCuts,
+                                             const TrackingTopology<7>::View topology,
+                                             bounded_vector<float>& transitionPhiCuts,
                                              const float resolutionPV,
                                              std::array<float, 7>& minRs,
                                              std::array<float, 7>& maxRs,
                                              bounded_vector<float>& resolutions,
                                              std::vector<float>& radii,
-                                             bounded_vector<float>& mulScatAng,
+                                             bounded_vector<float>& transitionMSAngles,
                                              o2::its::ExternalAllocator* alloc,
                                              gpu::Streams& streams);
 
 template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                                const ROFMaskTable<7>::View& rofMask,
-                                               const int layer,
+                                               const int transitionId,
+                                               const int fromLayer,
+                                               const int toLayer,
                                                const ROFOverlapTable<7>::View& rofOverlaps,
                                                const ROFVertexLookupTable<7>::View& vertexLUT,
                                                const int vertexId,
@@ -1126,13 +1183,14 @@ template void computeTrackletsInROFsHandler<7>(const IndexTableUtils<7>* utils,
                                                gsl::span<int*> trackletsLUTsHost,
                                                const bool selectUPCVertices,
                                                const float NSigmaCut,
-                                               bounded_vector<float>& phiCuts,
+                                               const TrackingTopology<7>::View topology,
+                                               bounded_vector<float>& transitionPhiCuts,
                                                const float resolutionPV,
                                                std::array<float, 7>& minRs,
                                                std::array<float, 7>& maxRs,
                                                bounded_vector<float>& resolutions,
                                                std::vector<float>& radii,
-                                               bounded_vector<float>& mulScatAng,
+                                               bounded_vector<float>& transitionMSAngles,
                                                o2::its::ExternalAllocator* alloc,
                                                gpu::Streams& streams);
 
@@ -1142,7 +1200,8 @@ template void countCellsHandler<7>(const Cluster** sortedClusters,
                                    Tracklet** tracklets,
                                    int** trackletsLUT,
                                    const int nTracklets,
-                                   const int layer,
+                                   const int cellTopologyId,
+                                   const TrackingTopology<7>::View topology,
                                    CellSeed* cells,
                                    int** cellsLUTsArrayDevice,
                                    int* cellsLUTsHost,
@@ -1160,7 +1219,8 @@ template void computeCellsHandler<7>(const Cluster** sortedClusters,
                                      Tracklet** tracklets,
                                      int** trackletsLUT,
                                      const int nTracklets,
-                                     const int layer,
+                                     const int cellTopologyId,
+                                     const TrackingTopology<7>::View topology,
                                      CellSeed* cells,
                                      int** cellsLUTsArrayDevice,
                                      int* cellsLUTsHost,
@@ -1172,47 +1232,44 @@ template void computeCellsHandler<7>(const Cluster** sortedClusters,
                                      gpu::Streams& streams);
 
 template void countCellNeighboursHandler<7>(CellSeed** cellsLayersDevice,
-                                            int* neighboursLUT,
+                                            int* neighboursCursor,
                                             int** cellsLUTs,
-                                            gpuPair<int, int>* cellNeighbours,
-                                            int* neighboursIndexTable,
-                                            const Tracklet** tracklets,
+                                            const int sourceCellTopologyId,
+                                            const int targetCellTopologyId,
                                             const float maxChi2ClusterAttachment,
                                             const float bz,
-                                            const int layerIndex,
                                             const unsigned int nCells,
-                                            const unsigned int nCellsNext,
-                                            const int maxCellNeighbours,
-                                            o2::its::ExternalAllocator* alloc,
                                             gpu::Stream& stream);
 
 template void computeCellNeighboursHandler<7>(CellSeed** cellsLayersDevice,
-                                              int* neighboursLUT,
+                                              int* neighboursCursor,
                                               int** cellsLUTs,
-                                              gpuPair<int, int>* cellNeighbours,
-                                              int* neighboursIndexTable,
-                                              const Tracklet** tracklets,
+                                              CellNeighbour* cellNeighbours,
+                                              const int sourceCellTopologyId,
+                                              const int targetCellTopologyId,
                                               const float maxChi2ClusterAttachment,
                                               const float bz,
-                                              const int layerIndex,
                                               const unsigned int nCells,
-                                              const unsigned int nCellsNext,
-                                              const int maxCellNeighbours,
                                               gpu::Stream& stream);
 
-template void processNeighboursHandler<7>(const int startLayer,
-                                          const int startLevel,
+template void processNeighboursHandler<7>(const int startLevel,
+                                          const int defaultCellTopologyId,
                                           CellSeed** allCellSeeds,
                                           CellSeed* currentCellSeeds,
-                                          std::array<int, 5>& nCells,
+                                          const int* currentCellTopologyIds,
+                                          const int* currentCellIds,
+                                          const int* nCells,
                                           const unsigned char** usedClusters,
-                                          std::array<int*, 5>& neighbours,
-                                          gsl::span<int*> neighboursDeviceLUTs,
+                                          CellNeighbour** neighbours,
+                                          int** neighboursDeviceLUTs,
                                           const TrackingFrameInfo** foundTrackingFrameInfo,
                                           bounded_vector<TrackSeed<7>>& seedsHost,
                                           const float bz,
                                           const float maxChi2ClusterAttachment,
                                           const float maxChi2NDF,
+                                          const int maxHoles,
+                                          const int minTrackLength,
+                                          const LayerMask holeLayerMask,
                                           const std::vector<float>& layerxX0Host,
                                           const o2::base::Propagator* propagator,
                                           const o2::base::PropagatorF::MatCorrType matCorrType,
@@ -1262,7 +1319,9 @@ template void computeTrackSeedHandler(TrackSeed<7>* trackSeeds,
 #ifdef ENABLE_UPGRADES
 template void countTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils,
                                               const ROFMaskTable<11>::View& rofMask,
-                                              const int layer,
+                                              const int transitionId,
+                                              const int fromLayer,
+                                              const int toLayer,
                                               const ROFOverlapTable<11>::View& rofOverlaps,
                                               const ROFVertexLookupTable<11>::View& vertexLUT,
                                               const int vertexId,
@@ -1277,19 +1336,22 @@ template void countTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils,
                                               gsl::span<int*> trackletsLUTsHost,
                                               const bool selectUPCVertices,
                                               const float NSigmaCut,
-                                              bounded_vector<float>& phiCuts,
+                                              const TrackingTopology<11>::View topology,
+                                              bounded_vector<float>& transitionPhiCuts,
                                               const float resolutionPV,
                                               std::array<float, 11>& minRs,
                                               std::array<float, 11>& maxRs,
                                               bounded_vector<float>& resolutions,
                                               std::vector<float>& radii,
-                                              bounded_vector<float>& mulScatAng,
+                                              bounded_vector<float>& transitionMSAngles,
                                               o2::its::ExternalAllocator* alloc,
                                               gpu::Streams& streams);
 
 template void computeTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils,
                                                 const ROFMaskTable<11>::View& rofMask,
-                                                const int layer,
+                                                const int transitionId,
+                                                const int fromLayer,
+                                                const int toLayer,
                                                 const ROFOverlapTable<11>::View& rofOverlaps,
                                                 const ROFVertexLookupTable<11>::View& vertexLUT,
                                                 const int vertexId,
@@ -1307,13 +1369,14 @@ template void computeTrackletsInROFsHandler<11>(const IndexTableUtils<11>* utils
                                                 gsl::span<int*> trackletsLUTsHost,
                                                 const bool selectUPCVertices,
                                                 const float NSigmaCut,
-                                                bounded_vector<float>& phiCuts,
+                                                const TrackingTopology<11>::View topology,
+                                                bounded_vector<float>& transitionPhiCuts,
                                                 const float resolutionPV,
                                                 std::array<float, 11>& minRs,
                                                 std::array<float, 11>& maxRs,
                                                 bounded_vector<float>& resolutions,
                                                 std::vector<float>& radii,
-                                                bounded_vector<float>& mulScatAng,
+                                                bounded_vector<float>& transitionMSAngles,
                                                 o2::its::ExternalAllocator* alloc,
                                                 gpu::Streams& streams);
 
@@ -1323,7 +1386,8 @@ template void countCellsHandler<11>(const Cluster** sortedClusters,
                                     Tracklet** tracklets,
                                     int** trackletsLUT,
                                     const int nTracklets,
-                                    const int layer,
+                                    const int cellTopologyId,
+                                    const TrackingTopology<11>::View topology,
                                     CellSeed* cells,
                                     int** cellsLUTsArrayDevice,
                                     int* cellsLUTsHost,
@@ -1341,7 +1405,8 @@ template void computeCellsHandler<11>(const Cluster** sortedClusters,
                                       Tracklet** tracklets,
                                       int** trackletsLUT,
                                       const int nTracklets,
-                                      const int layer,
+                                      const int cellTopologyId,
+                                      const TrackingTopology<11>::View topology,
                                       CellSeed* cells,
                                       int** cellsLUTsArrayDevice,
                                       int* cellsLUTsHost,
@@ -1353,47 +1418,44 @@ template void computeCellsHandler<11>(const Cluster** sortedClusters,
                                       gpu::Streams& streams);
 
 template void countCellNeighboursHandler<11>(CellSeed** cellsLayersDevice,
-                                             int* neighboursLUT,
+                                             int* neighboursCursor,
                                              int** cellsLUTs,
-                                             gpuPair<int, int>* cellNeighbours,
-                                             int* neighboursIndexTable,
-                                             const Tracklet** tracklets,
+                                             const int sourceCellTopologyId,
+                                             const int targetCellTopologyId,
                                              const float maxChi2ClusterAttachment,
                                              const float bz,
-                                             const int layerIndex,
                                              const unsigned int nCells,
-                                             const unsigned int nCellsNext,
-                                             const int maxCellNeighbours,
-                                             o2::its::ExternalAllocator* alloc,
                                              gpu::Stream& stream);
 
 template void computeCellNeighboursHandler<11>(CellSeed** cellsLayersDevice,
-                                               int* neighboursLUT,
+                                               int* neighboursCursor,
                                                int** cellsLUTs,
-                                               gpuPair<int, int>* cellNeighbours,
-                                               int* neighboursIndexTable,
-                                               const Tracklet** tracklets,
+                                               CellNeighbour* cellNeighbours,
+                                               const int sourceCellTopologyId,
+                                               const int targetCellTopologyId,
                                                const float maxChi2ClusterAttachment,
                                                const float bz,
-                                               const int layerIndex,
                                                const unsigned int nCells,
-                                               const unsigned int nCellsNext,
-                                               const int maxCellNeighbours,
                                                gpu::Stream& stream);
 
-template void processNeighboursHandler<11>(const int startLayer,
-                                           const int startLevel,
+template void processNeighboursHandler<11>(const int startLevel,
+                                           const int defaultCellTopologyId,
                                            CellSeed** allCellSeeds,
                                            CellSeed* currentCellSeeds,
-                                           std::array<int, 9>& nCells,
+                                           const int* currentCellTopologyIds,
+                                           const int* currentCellIds,
+                                           const int* nCells,
                                            const unsigned char** usedClusters,
-                                           std::array<int*, 9>& neighbours,
-                                           gsl::span<int*> neighboursDeviceLUTs,
+                                           CellNeighbour** neighbours,
+                                           int** neighboursDeviceLUTs,
                                            const TrackingFrameInfo** foundTrackingFrameInfo,
                                            bounded_vector<TrackSeed<11>>& seedsHost,
                                            const float bz,
                                            const float maxChi2ClusterAttachment,
                                            const float maxChi2NDF,
+                                           const int maxHoles,
+                                           const int minTrackLength,
+                                           const LayerMask holeLayerMask,
                                            const std::vector<float>& layerxX0Host,
                                            const o2::base::Propagator* propagator,
                                            const o2::base::PropagatorF::MatCorrType matCorrType,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
index c7718ee666311..4706977d08ba6 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Cell.h
@@ -16,7 +16,10 @@
 #ifndef TRACKINGITSU_INCLUDE_CACELL_H_
 #define TRACKINGITSU_INCLUDE_CACELL_H_
 
+#include <cstdint>
+
 #include "ITStracking/Constants.h"
+#include "ITStracking/LayerMask.h"
 #include "DataFormatsITS/TimeEstBC.h"
 #include "ReconstructionDataFormats/Track.h"
 #include "GPUCommonDef.h"
@@ -24,11 +27,21 @@
 namespace o2::its
 {
 
+struct CellNeighbour {
+  int cellTopology{-1};
+  int cell{-1};
+  int nextCellTopology{-1};
+  int nextCell{-1};
+  int level{-1};
+};
+
 template <int NClusters>
 class SeedBase : public o2::track::TrackParCovF
 {
  public:
-  GPUhd() int getInnerLayer() const { return getUserField(); }
+  GPUhd() LayerMask getHitLayerMask() const { return LayerMask{static_cast<uint16_t>(getUserField())}; }
+  GPUhd() void setHitLayerMask(LayerMask mask) { setUserField(mask.value()); }
+  GPUhd() int getInnerLayer() const { return getHitLayerMask().first(); }
   GPUhd() int getFirstTrackletIndex() const { return mTracklets[0]; };
   GPUhd() void setFirstTrackletIndex(int trkl) { mTracklets[0] = trkl; };
   GPUhd() int getSecondTrackletIndex() const { return mTracklets[1]; };
@@ -71,9 +84,13 @@ class CellSeed final : public SeedBase<constants::ClustersPerCell>
  public:
   GPUhdDefault() CellSeed() = default;
   GPUhd() CellSeed(int innerL, int cl0, int cl1, int cl2, int trkl0, int trkl1, const o2::track::TrackParCovF& tpc, float chi2, const TimeEstBC& time)
+    : CellSeed(LayerMask(innerL, innerL + 1, innerL + 2), cl0, cl1, cl2, trkl0, trkl1, tpc, chi2, time)
+  {
+  }
+  GPUhd() CellSeed(LayerMask hitLayerMask, int cl0, int cl1, int cl2, int trkl0, int trkl1, const o2::track::TrackParCovF& tpc, float chi2, const TimeEstBC& time)
     : Base(tpc, chi2, 1, time)
   {
-    setUserField(innerL);
+    setHitLayerMask(hitLayerMask);
     auto& clusters = this->clustersRaw();
     clusters[0] = cl0;
     clusters[1] = cl1;
@@ -92,12 +109,12 @@ class CellSeed final : public SeedBase<constants::ClustersPerCell>
   GPUhd() int getThirdClusterIndex() const { return this->clustersRaw()[2]; };
   GPUhd() auto& getClusters() { return this->clustersRaw(); }
   GPUhd() const auto& getClusters() const { return this->clustersRaw(); }
-  /// getCluster takes an ABSOLUTE layer index and returns UnusedIndex if the
-  /// layer is outside the 3 stored slots (innerL, innerL+1, innerL+2).
+  /// getCluster takes an ABSOLUTE layer index. Compact cluster slots are
+  /// mapped to absolute layers by set-bit order in the hit-layer mask.
   GPUhd() int getCluster(int layer) const
   {
-    const int rel = layer - getInnerLayer();
-    return (rel >= 0 && rel < constants::ClustersPerCell) ? this->clustersRaw()[rel] : constants::UnusedIndex;
+    const int slot = getHitLayerMask().slot(layer);
+    return (slot >= 0 && slot < constants::ClustersPerCell) ? this->clustersRaw()[slot] : constants::UnusedIndex;
   }
 };
 
@@ -114,14 +131,17 @@ class TrackSeed final : public SeedBase<NLayers>
   GPUhd() TrackSeed(const CellSeed& cs)
     : Base(static_cast<const o2::track::TrackParCovF&>(cs), cs.getChi2(), cs.getLevel(), cs.getTimeStamp())
   {
-    this->setUserField(cs.getInnerLayer());
+    this->setHitLayerMask(cs.getHitLayerMask());
     this->setFirstTrackletIndex(cs.getFirstTrackletIndex());
     this->setSecondTrackletIndex(cs.getSecondTrackletIndex());
-    const int innerL = cs.getInnerLayer();
     auto& clusters = this->clustersRaw();
-    clusters[innerL + 0] = cs.getFirstClusterIndex();
-    clusters[innerL + 1] = cs.getSecondClusterIndex();
-    clusters[innerL + 2] = cs.getThirdClusterIndex();
+    int slot = 0;
+    const auto hitMask = cs.getHitLayerMask();
+    for (int layer = 0; layer < NLayers; ++layer) {
+      if (hitMask.has(layer)) {
+        clusters[layer] = cs.getClusters()[slot++];
+      }
+    }
   }
   GPUhdDefault() TrackSeed(const TrackSeed&) = default;
   GPUhdDefault() ~TrackSeed() = default;
@@ -129,14 +149,27 @@ class TrackSeed final : public SeedBase<NLayers>
   GPUhdDefault() TrackSeed& operator=(const TrackSeed&) = default;
   GPUhdDefault() TrackSeed& operator=(TrackSeed&&) = default;
 
-  /// Three-cluster view of the original cell — note: innerL (UserField) is not
-  /// updated when processNeighbours extends the cluster list leftward.
-  GPUhd() int getFirstClusterIndex() const { return this->clustersRaw()[this->getUserField()]; }
-  GPUhd() int getSecondClusterIndex() const { return this->clustersRaw()[this->getUserField() + 1]; }
-  GPUhd() int getThirdClusterIndex() const { return this->clustersRaw()[this->getUserField() + 2]; }
+  GPUhd() int getFirstClusterIndex() const { return getClusterBySlot(0); }
+  GPUhd() int getSecondClusterIndex() const { return getClusterBySlot(1); }
+  GPUhd() int getThirdClusterIndex() const { return getClusterBySlot(2); }
   GPUhd() auto& getClusters() { return this->clustersRaw(); }
   GPUhd() const auto& getClusters() const { return this->clustersRaw(); }
   GPUhd() int getCluster(int layer) const { return this->clustersRaw()[layer]; }
+
+ private:
+  GPUhd() int getClusterBySlot(int requestedSlot) const
+  {
+    int slot = 0;
+    const auto hitMask = this->getHitLayerMask();
+    for (int layer = 0; layer < NLayers; ++layer) {
+      if (hitMask.has(layer)) {
+        if (slot++ == requestedSlot) {
+          return this->clustersRaw()[layer];
+        }
+      }
+    }
+    return constants::UnusedIndex;
+  }
 };
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index ce7b3e5a87630..c939f39532fdb 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -43,7 +43,12 @@ enum class IterationStep : uint8_t {
 using IterationSteps = o2::utils::EnumFlags<IterationStep>;
 
 struct TrackingParameters {
-  int CellMinimumLevel() const noexcept { return MinTrackLength - constants::ClustersPerCell + 1; }
+  int CellMinimumLevel() const noexcept
+  {
+    const int minClusters = MinTrackLength - (MaxHoles > 0 ? MaxHoles : 0);
+    const int effectiveMinClusters = minClusters > constants::ClustersPerCell ? minClusters : constants::ClustersPerCell;
+    return effectiveMinClusters - constants::ClustersPerCell + 1;
+  }
   int NeighboursPerRoad() const noexcept { return NLayers - 3; }
   int CellsPerRoad() const noexcept { return NLayers - 2; }
   int TrackletsPerRoad() const noexcept { return NLayers - 1; }
@@ -68,6 +73,8 @@ struct TrackingParameters {
   bool AllowSharingFirstCluster = false;
   int ClusterSharing = 0;
   int MinTrackLength = 7;
+  int MaxHoles = 0;
+  uint16_t HoleLayerMask = 0;
   float NSigmaCut = 5;
   float PVres = 1.e-2f;
   /// Trackleting cuts
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LayerMask.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LayerMask.h
new file mode 100644
index 0000000000000..9fe9894b3b457
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/LayerMask.h
@@ -0,0 +1,115 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef TRACKINGITSU_INCLUDE_LAYERMASK_H_
+#define TRACKINGITSU_INCLUDE_LAYERMASK_H_
+
+#include <cstdint>
+#include <type_traits>
+
+#ifndef GPUCA_GPUCODE
+#include <fmt/format.h>
+#include <string>
+#endif
+
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
+#include "ITStracking/Constants.h"
+
+namespace o2::its
+{
+
+struct LayerMask {
+  GPUhdDefault() constexpr LayerMask() noexcept = default;
+  GPUhdDefault() constexpr LayerMask(uint16_t mask) noexcept : mBits{mask} {}
+  GPUhdDefault() constexpr LayerMask(int layer0, int layer1, int layer2) noexcept
+    : mBits{static_cast<uint16_t>((uint16_t(1) << layer0) | (uint16_t(1) << layer1) | (uint16_t(1) << layer2))}
+  {
+  }
+  GPUhdi() constexpr operator uint16_t() const noexcept { return mBits; }
+  GPUhdi() constexpr uint16_t value() const noexcept { return mBits; }
+  GPUhdi() constexpr void set(int layer) noexcept { mBits |= (uint16_t(1) << layer); }
+
+  GPUhdi() LayerMask operator~() const noexcept { return LayerMask{static_cast<uint16_t>(~mBits)}; }
+  GPUhdi() LayerMask operator&(LayerMask other) const noexcept { return LayerMask{static_cast<uint16_t>(mBits & other.mBits)}; }
+  GPUhdi() LayerMask operator|(LayerMask other) const noexcept { return LayerMask{static_cast<uint16_t>(mBits | other.mBits)}; }
+  GPUhdi() LayerMask& operator&=(LayerMask other) noexcept
+  {
+    mBits &= other.mBits;
+    return *this;
+  }
+  GPUhdi() LayerMask& operator|=(LayerMask other) noexcept
+  {
+    mBits |= other.mBits;
+    return *this;
+  }
+
+  GPUhdi() bool empty() const noexcept { return mBits == 0; }
+  GPUhdi() bool has(int layer) const noexcept { return mBits & (uint16_t(1) << layer); }
+  GPUhdi() bool isSubsetOf(LayerMask allowed) const noexcept { return (*this & ~allowed).empty(); }
+  GPUhdi() bool isAllowedHoleMask(int maxHoles, LayerMask allowedHoleMask) const noexcept
+  {
+    const int allowedHoles = maxHoles > 0 ? maxHoles : 0;
+    return count() <= allowedHoles && isSubsetOf(allowedHoleMask);
+  }
+  GPUhdi() bool isAllowed(int maxHoles, LayerMask allowedHoleMask) const noexcept
+  {
+    return holeMask().isAllowedHoleMask(maxHoles, allowedHoleMask);
+  }
+  GPUhdi() int length() const noexcept { return empty() ? 0 : last() - first() + 1; }
+  GPUhdi() int count() const noexcept { return static_cast<int>(o2::gpu::GPUCommonMath::Popcount(mBits)); }
+  GPUhdi() int first() const noexcept { return mBits ? static_cast<int>(o2::gpu::GPUCommonMath::Ctz(mBits)) : constants::UnusedIndex; }
+  GPUhdi() int last() const noexcept { return mBits ? 31 - static_cast<int>(o2::gpu::GPUCommonMath::Clz(mBits)) : constants::UnusedIndex; }
+  GPUhdi() LayerMask holeMask() const noexcept
+  {
+    return empty() ? LayerMask{0} : (span(first(), last()) & ~(*this));
+  }
+
+  GPUhdi() int slot(int layer) const noexcept
+  {
+    if (!has(layer)) {
+      return constants::UnusedIndex;
+    }
+    const uint32_t lowerLayers = (uint32_t(1) << layer) - 1;
+    return static_cast<int>(o2::gpu::GPUCommonMath::Popcount(static_cast<uint32_t>(mBits) & lowerLayers));
+  }
+
+  static GPUhdi() LayerMask span(int fromLayer, int toLayer) noexcept
+  {
+    if (fromLayer > toLayer) {
+      return 0;
+    }
+    const uint32_t upper = (uint32_t(1) << (toLayer + 1)) - 1;
+    const uint32_t lower = (uint32_t(1) << fromLayer) - 1;
+    return static_cast<uint16_t>(upper & ~lower);
+  }
+
+  static GPUhdi() LayerMask skipped(int fromLayer, int toLayer) noexcept
+  {
+    return (toLayer - fromLayer <= 1) ? LayerMask{0} : span(fromLayer + 1, toLayer - 1);
+  }
+
+#ifndef GPUCA_GPUCODE
+  std::string asString() const { return fmt::format("{:016b}", mBits); }
+#endif
+
+ private:
+  uint16_t mBits{0};
+};
+
+static_assert(std::is_standard_layout_v<LayerMask>);
+static_assert(std::is_trivially_copyable_v<LayerMask>);
+static_assert(sizeof(LayerMask) == sizeof(uint16_t));
+static_assert(alignof(LayerMask) == alignof(uint16_t));
+
+} // namespace o2::its
+
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
index d276e27638dbd..950d8c0a9117f 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/MathUtils.h
@@ -16,6 +16,8 @@
 #ifndef O2_ITS_TRACKING_MATHUTILS_H_
 #define O2_ITS_TRACKING_MATHUTILS_H_
 
+#include <cstdint>
+
 #include "CommonConstants/MathConstants.h"
 #include "ITStracking/Constants.h"
 #include "MathUtils/Utils.h"
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
index b78540bddfabf..3fef2dc640cbc 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TimeFrame.h
@@ -32,6 +32,7 @@
 #include "ITStracking/ExternalAllocator.h"
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/ROFLookupTables.h"
+#include "ITStracking/TrackingTopology.h"
 #include "SimulationDataFormat/MCCompLabel.h"
 #include "SimulationDataFormat/MCTruthContainer.h"
 
@@ -66,6 +67,7 @@ struct TimeFrame {
   using ROFOverlapTableN = ROFOverlapTable<NLayers>;
   using ROFVertexLookupTableN = ROFVertexLookupTable<NLayers>;
   using ROFMaskTableN = ROFMaskTable<NLayers>;
+  using TrackingTopologyN = TrackingTopology<NLayers>;
   using TrackSeedN = TrackSeed<NLayers>;
   friend class gpu::TimeFrameGPU<NLayers>;
 
@@ -112,10 +114,10 @@ struct TimeFrame {
   auto& getMaxRs() { return mMaxR; }
   float getMinR(int layer) const { return mMinR[layer]; }
   float getMaxR(int layer) const { return mMaxR[layer]; }
-  float getMSangle(int layer) const { return mMSangles[layer]; }
-  auto& getMSangles() { return mMSangles; }
-  float getPhiCut(int layer) const { return mPhiCuts[layer]; }
-  auto& getPhiCuts() { return mPhiCuts; }
+  float getTransitionPhiCut(int transitionId) const { return mTransitionPhiCuts[transitionId]; }
+  float getTransitionMSAngle(int transitionId) const { return mTransitionMSAngles[transitionId]; }
+  auto& getTransitionPhiCuts() { return mTransitionPhiCuts; }
+  auto& getTransitionMSAngles() { return mTransitionMSAngles; }
   float getPositionResolution(int layer) const { return mPositionResolution[layer]; }
   auto& getPositionResolutions() { return mPositionResolution; }
 
@@ -135,6 +137,8 @@ struct TimeFrame {
   const auto& getIndexTableUtils() const { return mIndexTableUtils; }
   const auto& getROFOverlapTable() const { return mROFOverlapTable; }
   const auto& getROFOverlapTableView() const { return mROFOverlapTableView; }
+  const auto& getTrackerTopologies() const { return mTrackerTopologies; }
+  const auto& getTrackingTopologyView() const { return mTrackingTopologyView; }
   void setROFOverlapTable(ROFOverlapTableN table)
   {
     mROFOverlapTable = std::move(table);
@@ -177,7 +181,10 @@ struct TimeFrame {
   auto& getCellsLabel(int layer) { return mCellLabels[layer]; }
 
   bool hasMCinformation() const { return mClusterLabels[0] != nullptr; }
-  void initialise(const TrackingParameters& trkParam, const int maxLayers = NLayers);
+  void initVertexingTopology(const TrackingParameters& trkParam);
+  void initDefaultTrackingTopology(const TrackingParameters& trkParam, const int maxLayers = NLayers);
+  void initTrackerTopologies(gsl::span<const TrackingParameters> trkParams, const int maxLayers = NLayers);
+  void initialise(const TrackingParameters& trkParam, const int maxLayers = NLayers, const int iteration = constants::UnusedIndex);
 
   bool isClusterUsed(int layer, int clusterId) const { return mUsedClusters[layer][clusterId]; }
   void markUsedCluster(int layer, int clusterId) { mUsedClusters[layer][clusterId] = true; }
@@ -193,6 +200,7 @@ struct TimeFrame {
 
   auto& getCellsLookupTable() { return mCellsLookupTable; }
   auto& getCellsNeighbours() { return mCellsNeighbours; }
+  auto& getCellsNeighboursTopology() { return mCellsNeighboursTopology; }
   auto& getCellsNeighboursLUT() { return mCellsNeighboursLUT; }
   auto& getTracks() { return mTracks; }
   auto& getTracksLabel() { return mTracksLabel; }
@@ -273,6 +281,7 @@ struct TimeFrame {
   bounded_vector<TrackITSExt> mTracks;
   bounded_vector<MCCompLabel> mTracksLabel;
   std::vector<bounded_vector<int>> mCellsNeighbours;
+  std::vector<bounded_vector<int>> mCellsNeighboursTopology;
   std::vector<bounded_vector<int>> mCellsLookupTable;
 
   const o2::base::PropagatorImpl<float>* mPropagatorDevice = nullptr; // Needed only for GPU
@@ -292,8 +301,8 @@ struct TimeFrame {
   bool isBeamPositionOverridden = false;
   std::array<float, NLayers> mMinR;
   std::array<float, NLayers> mMaxR;
-  bounded_vector<float> mMSangles;
-  bounded_vector<float> mPhiCuts;
+  bounded_vector<float> mTransitionPhiCuts;
+  bounded_vector<float> mTransitionMSAngles;
   bounded_vector<float> mPositionResolution;
   std::array<bounded_vector<uint8_t>, NLayers> mClusterSize;
 
@@ -319,6 +328,10 @@ struct TimeFrame {
   IndexTableUtilsN mIndexTableUtils;
   ROFOverlapTableN mROFOverlapTable;
   ROFOverlapTableN::View mROFOverlapTableView;
+  TrackingTopologyN mVertexingTopology;
+  TrackingTopologyN mDefaultTrackingTopology;
+  std::vector<TrackingTopologyN> mTrackerTopologies;
+  typename TrackingTopologyN::View mTrackingTopologyView;
   ROFVertexLookupTableN mROFVertexLookupTable;
   ROFVertexLookupTableN::View mROFVertexLookupTableView;
   ROFMaskTableN mMultiplicityCutMask;
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
index 885cb0f2b9ca5..d244b39ff9d11 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackHelpers.h
@@ -16,8 +16,6 @@
 #ifndef O2_ITS_TRACKING_TRACKHELPERS_H_
 #define O2_ITS_TRACKING_TRACKHELPERS_H_
 
-#include <cmath>
-
 #include "DataFormatsITS/TrackITS.h"
 #include "ITStracking/Cell.h"
 #include "ITStracking/Cluster.h"
@@ -29,6 +27,16 @@
 namespace o2::its::track
 {
 
+// Prefer 1) longer track 2) sorted in chi2
+GPUhdi() bool isBetter(const o2::its::TrackITS& a, const o2::its::TrackITS& b)
+{
+  const auto ncla = a.getNumberOfClusters();
+  const auto nclb = b.getNumberOfClusters();
+  // is a as long as b ? then decide on chi2
+  // otherwise prefer longer
+  return (ncla == nclb) ? (a.getChi2() < b.getChi2()) : ncla > nclb;
+}
+
 // Find the populated interior layer closest to the radial midpoint.
 // If no layer can be found, return constants::UnusedIndex.
 // Should minimize the sagitta bias.
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index aa4592c63f404..647403bb6b548 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -45,7 +45,7 @@ class TrackerTraits
 
   virtual ~TrackerTraits() = default;
   virtual void adoptTimeFrame(TimeFrame<NLayers>* tf) { mTimeFrame = tf; }
-  virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(mTrkParams[iteration], mTrkParams[iteration].NLayers); }
+  virtual void initialiseTimeFrame(const int iteration) { mTimeFrame->initialise(mTrkParams[iteration], mTrkParams[iteration].NLayers, iteration); }
 
   virtual void computeLayerTracklets(const int iteration, int iVertex);
   virtual void computeLayerCells(const int iteration);
@@ -53,7 +53,7 @@ class TrackerTraits
   virtual void findRoads(const int iteration);
 
   template <typename InputSeed>
-  void processNeighbours(int iteration, int iLayer, int iLevel, const bounded_vector<InputSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<TrackSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId);
+  void processNeighbours(int iteration, int defaultCellTopologyId, int iLevel, const bounded_vector<InputSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, const bounded_vector<int>& currentCellTopologyId, bounded_vector<TrackSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId, bounded_vector<int>& updatedCellTopologyId);
 
   void acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters, bounded_vector<bounded_vector<int>>& sharedFirstClusters);
   void markTracks(int iteration, bounded_vector<bounded_vector<int>>& sharedFirstClusters);
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 1d997ef12147a..21b4f928d5b73 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -71,6 +71,8 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   int addTimeError[7] = {0};                                                           // configure the width of the window in BC to be considered for the tracking.
   int minTrackLgtIter[constants::MaxIter] = {};                                        // minimum track length at each iteration, used only if >0, otherwise use code defaults
   uint8_t startLayerMask[constants::MaxIter] = {};                                     // mask of start layer for this iteration (if >0)
+  int maxHolesIter[constants::MaxIter] = {};                                           // maximum number of missing internal layers allowed in the CA topology for each iteration
+  uint16_t holeLayerMaskIter[constants::MaxIter] = {};                                 // layers that may be skipped by the CA topology for each iteration
   float minPtIterLgt[constants::MaxIter * (MaxTrackLength - MinTrackLength + 1)] = {}; // min.pT for given track length at this iteration, used only if >0, otherwise use code defaults
   float sysErrY2[7] = {0};                                                             // systematic error^2 in Y per layer
   float sysErrZ2[7] = {0};                                                             // systematic error^2 in Z per layer
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingTopology.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingTopology.h
new file mode 100644
index 0000000000000..2afb67609664f
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingTopology.h
@@ -0,0 +1,219 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef TRACKINGITSU_INCLUDE_TRACKINGTOPOLOGY_H_
+#define TRACKINGITSU_INCLUDE_TRACKINGTOPOLOGY_H_
+
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#ifndef GPUCA_GPUCODE
+#include <fmt/format.h>
+#include <string>
+#include "Framework/Logger.h"
+#endif
+
+#include "CommonDataFormat/RangeReference.h"
+#include "GPUCommonDef.h"
+#include "GPUCommonMath.h"
+#include "ITStracking/LayerMask.h"
+
+namespace o2::its
+{
+
+template <int NLayers>
+class TrackingTopology
+{
+ public:
+  using Id = uint8_t;
+  using Mask = LayerMask;
+  using Range = o2::dataformats::RangeReference<Id, Id>;
+  static constexpr int MaxTransitions = (NLayers * (NLayers - 1)) / 2;
+  static constexpr int MaxCells = (NLayers * (NLayers - 1) * (NLayers - 2)) / 6;
+  static_assert(NLayers < std::numeric_limits<Id>::max());
+  static_assert(MaxTransitions <= std::numeric_limits<Id>::max());
+  static_assert(MaxCells <= std::numeric_limits<Id>::max());
+
+  // Describes from which layer to which layer the look-up happens
+  struct LayerTransition {
+    Id fromLayer{0};
+    Id toLayer{0};
+  };
+  static_assert(std::is_standard_layout_v<LayerTransition>);
+  static_assert(std::is_trivially_copyable_v<LayerTransition>);
+  static_assert(sizeof(LayerTransition) == (2 * sizeof(Id)));
+
+  // Describes from which LayerTransition a tracklet is allowed to originate
+  // and with which LayerTransition this can be combined additionally the hitMasked is cached
+  struct CellTopology {
+    Id firstTransition{0};
+    Id secondTransition{0};
+    Mask hitLayerMask{0};
+  };
+  static_assert(std::is_standard_layout_v<CellTopology>);
+  static_assert(std::is_trivially_copyable_v<CellTopology>);
+  static_assert(sizeof(CellTopology) == (2 * sizeof(Id)) + sizeof(Mask));
+
+  // GPU ready view of the underlying LUTs
+  struct View {
+    const LayerTransition* transitions{nullptr};
+    const CellTopology* cells{nullptr};
+    const Range* cellsByFirstTransitionIndex{nullptr};
+    const Id* cellsByFirstTransition{nullptr};
+    Id nTransitions{0};
+    Id nCells{0};
+    Id nCellsByFirstTransition{0};
+
+    GPUhdi() const LayerTransition& getTransition(Id id) const { return transitions[id]; }
+    GPUhdi() const CellTopology& getCell(Id id) const { return cells[id]; }
+    GPUhdi() Range getCellsStartingWithTransition(Id transitionId) const { return cellsByFirstTransitionIndex[transitionId]; }
+
+#ifndef GPUCA_GPUCODE
+    std::string asString() const
+    {
+      std::string out = fmt::format("TrackingTopology: transitions={} cells={}", nTransitions, nCells);
+      out += "\n  transitions:";
+      for (Id transitionId = 0; transitionId < nTransitions; ++transitionId) {
+        const auto& t = transitions[transitionId];
+        out += fmt::format("\n    {}: {} -> {}", transitionId, t.fromLayer, t.toLayer);
+      }
+      out += "\n  cells:";
+      for (Id cellId = 0; cellId < nCells; ++cellId) {
+        const auto& c = cells[cellId];
+        const auto& first = transitions[c.firstTransition];
+        const auto& second = transitions[c.secondTransition];
+        out += fmt::format("\n    {}: {} -> {} -> {} hitMask={} transitions=({}, {})", cellId, first.fromLayer, first.toLayer, second.toLayer, c.hitLayerMask.asString(), c.firstTransition, c.secondTransition);
+      }
+      return out;
+    }
+
+    void print() const
+    {
+      LOGP(info, "{}", asString());
+    }
+#endif
+  };
+
+  void init(int maxLayers, int maxHoles, Mask holeLayerMask)
+  {
+    clear();
+    mMaxLayers = o2::gpu::CAMath::Max(0, o2::gpu::CAMath::Min(maxLayers, NLayers));
+    mMaxHoles = o2::gpu::CAMath::Max(maxHoles, 0);
+    mHoleLayerMask = holeLayerMask;
+    for (int fromLayer = 0; fromLayer < mMaxLayers; ++fromLayer) {
+      for (int toLayer = fromLayer + 1; toLayer < mMaxLayers; ++toLayer) {
+        if (Mask::skipped(fromLayer, toLayer).isAllowedHoleMask(mMaxHoles, mHoleLayerMask)) {
+          mTransitions[mNTransitions++] = LayerTransition{static_cast<Id>(fromLayer), static_cast<Id>(toLayer)};
+        }
+      }
+    }
+
+    for (Id firstId = 0; firstId < mNTransitions; ++firstId) {
+      const auto& first = mTransitions[firstId];
+      for (Id secondId = 0; secondId < mNTransitions; ++secondId) {
+        const auto& second = mTransitions[secondId];
+        if (first.toLayer != second.fromLayer) {
+          continue;
+        }
+        const Mask hitMask{first.fromLayer, first.toLayer, second.toLayer};
+        if (hitMask.isAllowed(mMaxHoles, mHoleLayerMask)) {
+          mCells[mNCells++] = CellTopology{firstId, secondId, hitMask};
+        }
+      }
+    }
+
+    fillCellsByTransition();
+  }
+
+  View getView() const
+  {
+    return View{mTransitions.data(),
+                mCells.data(),
+                mCellsByFirstTransitionIndex.data(),
+                mCellsByFirstTransition.data(),
+                mNTransitions,
+                mNCells,
+                mNCellsByFirstTransition};
+  }
+
+  View getDeviceView(const LayerTransition* deviceTransitions,
+                     const CellTopology* deviceCells,
+                     const Range* deviceCellsByFirstTransitionIndex,
+                     const Id* deviceCellsByFirstTransition) const
+  {
+    return View{deviceTransitions,
+                deviceCells,
+                deviceCellsByFirstTransitionIndex,
+                deviceCellsByFirstTransition,
+                mNTransitions,
+                mNCells,
+                mNCellsByFirstTransition};
+  }
+
+  const auto& getTransitions() const noexcept { return mTransitions; }
+  const auto& getCells() const noexcept { return mCells; }
+  const auto& getCellsByFirstTransitionIndex() const noexcept { return mCellsByFirstTransitionIndex; }
+  const auto& getCellsByFirstTransition() const noexcept { return mCellsByFirstTransition; }
+  Id getNTransitions() const noexcept { return mNTransitions; }
+  Id getNCells() const noexcept { return mNCells; }
+  Id getNCellsByFirstTransition() const noexcept { return mNCellsByFirstTransition; }
+
+ private:
+  void clear()
+  {
+    mNTransitions = 0;
+    mNCells = 0;
+    mNCellsByFirstTransition = 0;
+    mTransitions.fill({});
+    mCells.fill({});
+    mCellsByFirstTransitionIndex.fill(Range{0, 0});
+    mCellsByFirstTransition.fill(0);
+  }
+
+  void fillCellsByTransition()
+  {
+    std::array<Id, MaxTransitions> counts{};
+    for (Id cellId = 0; cellId < mNCells; ++cellId) {
+      ++counts[mCells[cellId].firstTransition];
+    }
+
+    Id offset = 0;
+    for (Id transitionId = 0; transitionId < mNTransitions; ++transitionId) {
+      mCellsByFirstTransitionIndex[transitionId].setFirstEntry(offset);
+      mCellsByFirstTransitionIndex[transitionId].setEntries(counts[transitionId]);
+      offset += counts[transitionId];
+    }
+
+    std::array<Id, MaxTransitions> cursor{};
+    for (Id cellId = 0; cellId < mNCells; ++cellId) {
+      const Id transitionId = mCells[cellId].firstTransition;
+      mCellsByFirstTransition[mCellsByFirstTransitionIndex[transitionId].getFirstEntry() + cursor[transitionId]++] = cellId;
+    }
+    mNCellsByFirstTransition = offset;
+  }
+
+  int mMaxLayers{0};
+  int mMaxHoles{0};
+  Mask mHoleLayerMask{0};
+  Id mNTransitions{0};
+  Id mNCells{0};
+  Id mNCellsByFirstTransition{0};
+  std::array<LayerTransition, MaxTransitions> mTransitions{};
+  std::array<CellTopology, MaxCells> mCells{};
+  std::array<Range, MaxTransitions> mCellsByFirstTransitionIndex{};
+  std::array<Id, MaxCells> mCellsByFirstTransition{};
+};
+
+} // namespace o2::its
+
+#endif
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index c425d467a8061..0087da0a85ac2 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -24,8 +24,8 @@ using namespace o2::its;
 
 std::string TrackingParameters::asString() const
 {
-  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{}",
-                                ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength);
+  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{} MaxHoles:{} HoleMask:{:#x}",
+                                ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength, MaxHoles, HoleLayerMask);
   bool first = true;
   for (int il = NLayers; il >= MinTrackLength; il--) {
     int slot = NLayers - il;
@@ -204,6 +204,11 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     p.SaveTimeBenchmarks = tc.saveTimeBenchmarks;
     p.FataliseUponFailure = tc.fataliseUponFailure;
     p.AllowSharingFirstCluster = tc.allowSharingFirstCluster;
+    const auto iter = &p - trackParams.data();
+    if (iter < constants::MaxIter) {
+      p.MaxHoles = tc.maxHolesIter[iter];
+      p.HoleLayerMask = tc.holeLayerMaskIter[iter];
+    }
 
     if (tc.useMatCorrTGeo) {
       p.CorrType = o2::base::PropagatorImpl<float>::MatCorrType::USEMatCorrTGeo;
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
index fc99bf0f35403..8375004cbfbad 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TimeFrame.cxx
@@ -241,8 +241,32 @@ void TimeFrame<NLayers>::prepareClusters(const TrackingParameters& trkParam, con
 }
 
 template <int NLayers>
-void TimeFrame<NLayers>::initialise(const TrackingParameters& trkParam, const int maxLayers)
+void TimeFrame<NLayers>::initVertexingTopology(const TrackingParameters& trkParam)
 {
+  mVertexingTopology.init(3, trkParam.MaxHoles, trkParam.HoleLayerMask);
+}
+
+template <int NLayers>
+void TimeFrame<NLayers>::initDefaultTrackingTopology(const TrackingParameters& trkParam, const int maxLayers)
+{
+  mDefaultTrackingTopology.init(maxLayers, trkParam.MaxHoles, trkParam.HoleLayerMask);
+}
+
+template <int NLayers>
+void TimeFrame<NLayers>::initTrackerTopologies(gsl::span<const TrackingParameters> trkParams, const int maxLayers)
+{
+  mTrackerTopologies.resize(trkParams.size());
+  for (size_t iteration = 0; iteration < trkParams.size(); ++iteration) {
+    const int iterationMaxLayers = std::min(maxLayers, trkParams[iteration].NLayers);
+    mTrackerTopologies[iteration].init(iterationMaxLayers, trkParams[iteration].MaxHoles, trkParams[iteration].HoleLayerMask);
+  }
+}
+
+template <int NLayers>
+void TimeFrame<NLayers>::initialise(const TrackingParameters& trkParam, const int maxLayers, const int iteration)
+{
+  mTrackingTopologyView = iteration != constants::UnusedIndex ? mTrackerTopologies[iteration].getView() : (maxLayers == 3 ? mVertexingTopology.getView() : mDefaultTrackingTopology.getView());
+
   if (trkParam.PassFlags[IterationStep::FirstPass]) {
     deepVectorClear(mTracks);
     deepVectorClear(mTracksLabel);
@@ -253,14 +277,6 @@ void TimeFrame<NLayers>::initialise(const TrackingParameters& trkParam, const in
       deepVectorClear(mPrimaryVerticesLabels);
     }
     clearResizeBoundedVector(mLinesLabels, getNrof(1), mMemoryPool.get());
-    clearResizeBoundedVector(mCells, trkParam.CellsPerRoad(), mMemoryPool.get());
-    clearResizeBoundedVector(mCellsLookupTable, trkParam.CellsPerRoad() - 1, mMemoryPool.get());
-    clearResizeBoundedVector(mCellsNeighbours, trkParam.CellsPerRoad() - 1, mMemoryPool.get());
-    clearResizeBoundedVector(mCellsNeighboursLUT, trkParam.CellsPerRoad() - 1, mMemoryPool.get());
-    clearResizeBoundedVector(mCellLabels, trkParam.CellsPerRoad(), mMemoryPool.get());
-    clearResizeBoundedVector(mTracklets, std::min(trkParam.TrackletsPerRoad(), maxLayers - 1), mMemoryPool.get());
-    clearResizeBoundedVector(mTrackletLabels, trkParam.TrackletsPerRoad(), mMemoryPool.get());
-    clearResizeBoundedVector(mTrackletsLookupTable, trkParam.TrackletsPerRoad(), mMemoryPool.get());
     mIndexTableUtils.setTrackingParameters(trkParam);
     clearResizeBoundedVector(mPositionResolution, trkParam.NLayers, mMemoryPool.get());
     clearResizeBoundedVector(mBogusClusters, trkParam.NLayers, mMemoryPool.get());
@@ -289,6 +305,17 @@ void TimeFrame<NLayers>::initialise(const TrackingParameters& trkParam, const in
     mMinR.fill(std::numeric_limits<float>::max());
     mMaxR.fill(std::numeric_limits<float>::min());
   }
+  clearResizeBoundedVector(mCells, mTrackingTopologyView.nCells, mMemoryPool.get());
+  clearResizeBoundedVector(mCellsLookupTable, mTrackingTopologyView.nCells, mMemoryPool.get());
+  clearResizeBoundedVector(mCellsNeighbours, mTrackingTopologyView.nCells, mMemoryPool.get());
+  clearResizeBoundedVector(mCellsNeighboursTopology, mTrackingTopologyView.nCells, mMemoryPool.get());
+  clearResizeBoundedVector(mCellsNeighboursLUT, mTrackingTopologyView.nCells, mMemoryPool.get());
+  clearResizeBoundedVector(mCellLabels, mTrackingTopologyView.nCells, mMemoryPool.get());
+  clearResizeBoundedVector(mTracklets, mTrackingTopologyView.nTransitions, mMemoryPool.get());
+  clearResizeBoundedVector(mTrackletLabels, mTrackingTopologyView.nTransitions, mMemoryPool.get());
+  clearResizeBoundedVector(mTrackletsLookupTable, mTrackingTopologyView.nTransitions, mMemoryPool.get());
+  clearResizeBoundedVector(mTransitionPhiCuts, mTrackingTopologyView.nTransitions, mMemoryPool.get());
+  clearResizeBoundedVector(mTransitionMSAngles, mTrackingTopologyView.nTransitions, mMemoryPool.get());
   mNTrackletsPerROF.resize(2);
   for (auto& v : mNTrackletsPerROF) {
     v = bounded_vector<int>(getNrof(1) + 1, 0, mMemoryPool.get());
@@ -304,42 +331,48 @@ void TimeFrame<NLayers>::initialise(const TrackingParameters& trkParam, const in
     }
   }
 
-  mMSangles.resize(trkParam.NLayers);
-  mPhiCuts.resize(mClusters.size() - 1, 0.f);
-  float oneOverR{0.001f * 0.3f * std::abs(mBz) / trkParam.TrackletMinPt};
+  // estimate MS per layer
+  std::array<float, NLayers> msAngles{};
   for (unsigned int iLayer{0}; iLayer < NLayers; ++iLayer) {
-    mMSangles[iLayer] = math_utils::MSangle(0.14f, trkParam.TrackletMinPt, trkParam.LayerxX0[iLayer]);
+    msAngles[iLayer] = math_utils::MSangle(0.14f, trkParam.TrackletMinPt, trkParam.LayerxX0[iLayer]);
     mPositionResolution[iLayer] = o2::gpu::CAMath::Sqrt((0.5f * (trkParam.SystErrorZ2[iLayer] + trkParam.SystErrorY2[iLayer])) + (trkParam.LayerResolution[iLayer] * trkParam.LayerResolution[iLayer]));
-    if (iLayer < mClusters.size() - 1) {
-      const float& r1 = trkParam.LayerRadii[iLayer];
-      const float& r2 = trkParam.LayerRadii[iLayer + 1];
-      oneOverR = (0.5 * oneOverR >= 1.f / r2) ? (2.f / r2) - o2::constants::math::Almost0 : oneOverR;
-      const float res1 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[iLayer]);
-      const float res2 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[iLayer + 1]);
-      const float cosTheta1half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r1 * oneOverR));
-      const float cosTheta2half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r2 * oneOverR));
-      float x = (r2 * cosTheta1half) - (r1 * cosTheta2half);
-      float delta = o2::gpu::CAMath::Sqrt(1.f / (1.f - 0.25f * math_utils::Sq(x * oneOverR)) * (math_utils::Sq((0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta2half) + cosTheta1half) * math_utils::Sq(res1) + math_utils::Sq((0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta1half) + cosTheta2half) * math_utils::Sq(res2)));
-      /// the expression std::asin(0.5f * x * oneOverR) is equivalent to std::aCos(0.5f * r1 * oneOverR) - std::acos(0.5 * r2 * oneOverR)
-      mPhiCuts[iLayer] = std::min(o2::gpu::CAMath::ASin(0.5f * x * oneOverR) + 2.f * mMSangles[iLayer] + delta, o2::constants::math::PI * 0.5f);
-    }
   }
 
-  for (int iLayer{0}; iLayer < std::min((int)mTracklets.size(), maxLayers); ++iLayer) {
-    deepVectorClear(mTracklets[iLayer]);
-    deepVectorClear(mTrackletLabels[iLayer]);
-    if (iLayer < (int)mCells.size()) {
-      deepVectorClear(mCells[iLayer]);
-      deepVectorClear(mTrackletsLookupTable[iLayer]);
-      mTrackletsLookupTable[iLayer].resize(mClusters[iLayer + 1].size() + 1, 0);
-      deepVectorClear(mCellLabels[iLayer]);
+  // for each transition calculate the phi-cuts + integrated MS
+  float oneOverR{0.001f * 0.3f * std::abs(mBz) / trkParam.TrackletMinPt};
+  for (int transitionId{0}; transitionId < (int)mTracklets.size(); ++transitionId) {
+    const auto& transition = mTrackingTopologyView.getTransition(transitionId);
+    float ms2 = 0.;
+    for (int layer = transition.fromLayer; layer < transition.toLayer; ++layer) {
+      ms2 += math_utils::Sq(msAngles[layer]);
     }
+    mTransitionMSAngles[transitionId] = o2::gpu::CAMath::Sqrt(ms2);
+    const float& r1 = trkParam.LayerRadii[transition.fromLayer];
+    const float& r2 = trkParam.LayerRadii[transition.toLayer];
+    oneOverR = (0.5 * oneOverR >= 1.f / r2) ? (2.f / r2) - o2::constants::math::Almost0 : oneOverR;
+    const float res1 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[transition.fromLayer]);
+    const float res2 = o2::gpu::CAMath::Hypot(trkParam.PVres, mPositionResolution[transition.toLayer]);
+    const float cosTheta1half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r1 * oneOverR));
+    const float cosTheta2half = o2::gpu::CAMath::Sqrt(1.f - math_utils::Sq(0.5f * r2 * oneOverR));
+    float x = (r2 * cosTheta1half) - (r1 * cosTheta2half);
+    float delta = o2::gpu::CAMath::Sqrt(1.f / (1.f - 0.25f * math_utils::Sq(x * oneOverR)) * (math_utils::Sq((0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta2half) + cosTheta1half) * math_utils::Sq(res1) + math_utils::Sq((0.25f * r1 * r2 * math_utils::Sq(oneOverR) / cosTheta1half) + cosTheta2half) * math_utils::Sq(res2)));
+    /// the expression std::asin(0.5f * x * oneOverR) is equivalent to std::aCos(0.5f * r1 * oneOverR) - std::acos(0.5 * r2 * oneOverR)
+    mTransitionPhiCuts[transitionId] = o2::gpu::CAMath::Min(o2::gpu::CAMath::ASin(0.5f * x * oneOverR) + 2.f * mTransitionMSAngles[transitionId] + delta, o2::constants::math::PI * 0.5f);
+
+    // some cleanup
+    deepVectorClear(mTracklets[transitionId]);
+    deepVectorClear(mTrackletLabels[transitionId]);
+    deepVectorClear(mTrackletsLookupTable[transitionId]);
+    mTrackletsLookupTable[transitionId].resize(mClusters[transition.fromLayer].size() + 1, 0);
+  }
 
-    if (iLayer < (int)mCells.size() - 1) {
-      deepVectorClear(mCellsLookupTable[iLayer]);
-      deepVectorClear(mCellsNeighbours[iLayer]);
-      deepVectorClear(mCellsNeighboursLUT[iLayer]);
-    }
+  for (int cellId{0}; cellId < (int)mCells.size(); ++cellId) {
+    deepVectorClear(mCells[cellId]);
+    deepVectorClear(mCellsLookupTable[cellId]);
+    deepVectorClear(mCellsNeighbours[cellId]);
+    deepVectorClear(mCellsNeighboursTopology[cellId]);
+    deepVectorClear(mCellsNeighboursLUT[cellId]);
+    deepVectorClear(mCellLabels[cellId]);
   }
 }
 
@@ -356,6 +389,9 @@ unsigned long TimeFrame<NLayers>::getArtefactsMemory() const
   for (const auto& cellsN : mCellsNeighbours) {
     size += sizeof(int) * cellsN.size();
   }
+  for (const auto& cellsN : mCellsNeighboursTopology) {
+    size += sizeof(int) * cellsN.size();
+  }
   return size;
 }
 
@@ -401,8 +437,8 @@ void TimeFrame<NLayers>::setMemoryPool(std::shared_ptr<BoundedMemoryResource> po
   initContainers(mNTrackletsPerClusterSum);
   initContainers(mNClustersPerROF);
   initVector(mPrimaryVertices);
-  initVector(mMSangles);
-  initVector(mPhiCuts);
+  initVector(mTransitionPhiCuts);
+  initVector(mTransitionMSAngles);
   initVector(mPositionResolution);
   initContainers(mClusterSize);
   initVector(mPValphaX);
@@ -442,6 +478,7 @@ void TimeFrame<NLayers>::wipe()
   deepVectorClear(mTracklets);
   deepVectorClear(mCells);
   deepVectorClear(mCellsNeighbours);
+  deepVectorClear(mCellsNeighboursTopology);
   deepVectorClear(mCellsLookupTable);
   deepVectorClear(mPrimaryVertices);
   deepVectorClear(mTrackletsLookupTable);
@@ -449,8 +486,8 @@ void TimeFrame<NLayers>::wipe()
   deepVectorClear(mNTrackletsPerCluster);
   deepVectorClear(mNTrackletsPerClusterSum);
   deepVectorClear(mNClustersPerROF);
-  deepVectorClear(mMSangles);
-  deepVectorClear(mPhiCuts);
+  deepVectorClear(mTransitionPhiCuts);
+  deepVectorClear(mTransitionMSAngles);
   deepVectorClear(mPositionResolution);
   deepVectorClear(mClusterSize);
   deepVectorClear(mPValphaX);
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 19cae4b70f158..9fef067559e8a 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -15,25 +15,23 @@
 
 #include <algorithm>
 #include <iterator>
-#include <ranges>
 #include <cmath>
 #include <type_traits>
 
 #include <oneapi/tbb/blocked_range.h>
-#include <oneapi/tbb/parallel_sort.h>
+#include <oneapi/tbb/enumerable_thread_specific.h>
 
-#include "CommonConstants/MathConstants.h"
 #include "DetectorsBase/Propagator.h"
 #include "GPUCommonMath.h"
 #include "ITStracking/BoundedAllocator.h"
 #include "ITStracking/Cell.h"
 #include "ITStracking/Constants.h"
 #include "ITStracking/IndexTableUtils.h"
+#include "ITStracking/LayerMask.h"
 #include "ITStracking/ROFLookupTables.h"
 #include "ITStracking/TrackerTraits.h"
 #include "ITStracking/TrackHelpers.h"
 #include "ITStracking/Tracklet.h"
-#include "ReconstructionDataFormats/Track.h"
 
 namespace o2::its
 {
@@ -47,23 +45,23 @@ struct PassMode {
 template <int NLayers>
 void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVertex)
 {
-  for (int iLayer = 0; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
-    mTimeFrame->getTracklets()[iLayer].clear();
-    mTimeFrame->getTrackletsLabel(iLayer).clear();
-    if (iLayer > 0) {
-      std::fill(mTimeFrame->getTrackletsLookupTable()[iLayer - 1].begin(), mTimeFrame->getTrackletsLookupTable()[iLayer - 1].end(), 0);
-    }
+  const auto topology = mTimeFrame->getTrackingTopologyView();
+  for (int transitionId = 0; transitionId < topology.nTransitions; ++transitionId) {
+    mTimeFrame->getTracklets()[transitionId].clear();
+    mTimeFrame->getTrackletsLabel(transitionId).clear();
+    std::fill(mTimeFrame->getTrackletsLookupTable()[transitionId].begin(), mTimeFrame->getTrackletsLookupTable()[transitionId].end(), 0);
   }
 
   const Vertex diamondVert(mTrkParams[iteration].Diamond, mTrkParams[iteration].DiamondCov, 1, 1.f);
   gsl::span<const Vertex> diamondSpan(&diamondVert, 1);
 
   mTaskArena->execute([&] {
-    auto forTracklets = [&](auto Tag, int iLayer, int pivotROF, int base, int& offset) -> int {
-      if (!mTimeFrame->getROFMaskView().isROFEnabled(iLayer, pivotROF)) {
+    auto forTracklets = [&](auto Tag, int transitionId, int pivotROF, int base, int& offset) -> int {
+      const auto& transition = topology.getTransition(transitionId);
+      if (!mTimeFrame->getROFMaskView().isROFEnabled(transition.fromLayer, pivotROF)) {
         return 0;
       }
-      gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(iLayer, pivotROF);
+      gsl::span<const Vertex> primaryVertices = mTrkParams[iteration].UseDiamond ? diamondSpan : mTimeFrame->getPrimaryVertices(transition.fromLayer, pivotROF);
       if (primaryVertices.empty()) {
         return 0;
       }
@@ -73,46 +71,46 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
         return 0;
       }
 
-      // does this layer have any overlap with the next layer
-      const auto& rofOverlap = mTimeFrame->getROFOverlapTableView().getOverlap(iLayer, iLayer + 1, pivotROF);
+      const auto& rofOverlap = mTimeFrame->getROFOverlapTableView().getOverlap(transition.fromLayer, transition.toLayer, pivotROF);
       if (!rofOverlap.getEntries()) {
         return 0;
       }
 
       int localCount = 0;
-      auto& tracklets = mTimeFrame->getTracklets()[iLayer];
-      auto layer0 = mTimeFrame->getClustersOnLayer(pivotROF, iLayer);
+      auto& tracklets = mTimeFrame->getTracklets()[transitionId];
+      auto layer0 = mTimeFrame->getClustersOnLayer(pivotROF, transition.fromLayer);
       if (layer0.empty()) {
         return 0;
       }
 
-      const float meanDeltaR = mTrkParams[iteration].LayerRadii[iLayer + 1] - mTrkParams[iteration].LayerRadii[iLayer];
+      const float meanDeltaR = mTrkParams[iteration].LayerRadii[transition.toLayer] - mTrkParams[iteration].LayerRadii[transition.fromLayer];
+      const float phiCut = mTimeFrame->getTransitionPhiCut(transitionId);
+      const float msAngle = mTimeFrame->getTransitionMSAngle(transitionId);
 
       for (int iCluster = 0; iCluster < int(layer0.size()); ++iCluster) {
         const Cluster& currentCluster = layer0[iCluster];
-        const int currentSortedIndex = mTimeFrame->getSortedIndex(pivotROF, iLayer, iCluster);
-        if (mTimeFrame->isClusterUsed(iLayer, currentCluster.clusterId)) {
+        const int currentSortedIndex = mTimeFrame->getSortedIndex(pivotROF, transition.fromLayer, iCluster);
+        if (mTimeFrame->isClusterUsed(transition.fromLayer, currentCluster.clusterId)) {
           continue;
         }
         const float inverseR0 = 1.f / currentCluster.radius;
 
         for (int iV = startVtx; iV < endVtx; ++iV) {
           const auto& pv = primaryVertices[iV];
-          if (!mTimeFrame->getROFVertexLookupTableView().isVertexCompatible(iLayer, pivotROF, pv)) {
+          if (!mTimeFrame->getROFVertexLookupTableView().isVertexCompatible(transition.fromLayer, pivotROF, pv)) {
             continue;
           }
           if (pv.isFlagSet(Vertex::Flags::UPCMode) != mTrkParams[iteration].PassFlags[IterationStep::SelectUPCVertices]) {
             continue;
           }
-          const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTimeFrame->getPositionResolution(iLayer)) + math_utils::Sq(mTrkParams[iteration].PVres) / float(pv.getNContributors()));
+          const float resolution = o2::gpu::CAMath::Sqrt(math_utils::Sq(mTimeFrame->getPositionResolution(transition.fromLayer)) + math_utils::Sq(mTrkParams[iteration].PVres) / float(pv.getNContributors()));
           const float tanLambda = (currentCluster.zCoordinate - pv.getZ()) * inverseR0;
-          const float zAtRmin = tanLambda * (mTimeFrame->getMinR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
-          const float zAtRmax = tanLambda * (mTimeFrame->getMaxR(iLayer + 1) - currentCluster.radius) + currentCluster.zCoordinate;
+          const float zAtRmin = tanLambda * (mTimeFrame->getMinR(transition.toLayer) - currentCluster.radius) + currentCluster.zCoordinate;
+          const float zAtRmax = tanLambda * (mTimeFrame->getMaxR(transition.toLayer) - currentCluster.radius) + currentCluster.zCoordinate;
           const float sqInvDeltaZ0 = 1.f / (math_utils::Sq(currentCluster.zCoordinate - pv.getZ()) + constants::Tolerance);
-          const float sigmaZ = o2::gpu::CAMath::Sqrt(
-            math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInvDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f) + math_utils::Sq(meanDeltaR * mTimeFrame->getMSangle(iLayer)));
-          const auto bins = o2::its::getBinsRect(currentCluster, iLayer + 1, zAtRmin, zAtRmax,
-                                                 sigmaZ * mTrkParams[iteration].NSigmaCut, mTimeFrame->getPhiCut(iLayer),
+          const float sigmaZ = o2::gpu::CAMath::Sqrt((math_utils::Sq(resolution) * math_utils::Sq(tanLambda) * ((math_utils::Sq(inverseR0) + sqInvDeltaZ0) * math_utils::Sq(meanDeltaR) + 1.f)) + math_utils::Sq(meanDeltaR * msAngle));
+          const auto bins = o2::its::getBinsRect(currentCluster, transition.toLayer, zAtRmin, zAtRmax,
+                                                 sigmaZ * mTrkParams[iteration].NSigmaCut, phiCut,
                                                  mTimeFrame->getIndexTableUtils());
           if (bins.x < 0) {
             continue;
@@ -123,18 +121,18 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
           }
 
           for (int targetROF = rofOverlap.getFirstEntry(); targetROF < rofOverlap.getEntriesBound(); ++targetROF) {
-            if (!mTimeFrame->getROFMaskView().isROFEnabled(iLayer + 1, targetROF)) {
+            if (!mTimeFrame->getROFMaskView().isROFEnabled(transition.toLayer, targetROF)) {
               continue;
             }
-            auto layer1 = mTimeFrame->getClustersOnLayer(targetROF, iLayer + 1);
+            auto layer1 = mTimeFrame->getClustersOnLayer(targetROF, transition.toLayer);
             if (layer1.empty()) {
               continue;
             }
-            const auto ts = mTimeFrame->getROFOverlapTableView().getTimeStamp(iLayer, pivotROF, iLayer + 1, targetROF);
+            const auto ts = mTimeFrame->getROFOverlapTableView().getTimeStamp(transition.fromLayer, pivotROF, transition.toLayer, targetROF);
             if (!ts.isCompatible(pv.getTimeStamp())) {
               continue;
             }
-            const auto& targetIndexTable = mTimeFrame->getIndexTable(targetROF, iLayer + 1);
+            const auto& targetIndexTable = mTimeFrame->getIndexTable(targetROF, transition.toLayer);
             const int zBinRange = (bins.z - bins.x) + 1;
             for (int iPhi = 0; iPhi < phiBinsNum; ++iPhi) {
               const int iPhiBin = (bins.y + iPhi) % mTrkParams[iteration].PhiBins;
@@ -147,22 +145,22 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
                   break;
                 }
                 const Cluster& nextCluster = layer1[iNext];
-                if (mTimeFrame->isClusterUsed(iLayer + 1, nextCluster.clusterId)) {
+                if (mTimeFrame->isClusterUsed(transition.toLayer, nextCluster.clusterId)) {
                   continue;
                 }
                 const float deltaZ = o2::gpu::CAMath::Abs((tanLambda * (nextCluster.radius - currentCluster.radius)) + currentCluster.zCoordinate - nextCluster.zCoordinate);
 
                 if (deltaZ / sigmaZ < mTrkParams[iteration].NSigmaCut &&
-                    math_utils::isPhiDifferenceBelow(currentCluster.phi, nextCluster.phi, mTimeFrame->getPhiCut(iLayer))) {
+                    math_utils::isPhiDifferenceBelow(currentCluster.phi, nextCluster.phi, phiCut)) {
                   const float phi{o2::gpu::CAMath::ATan2(currentCluster.yCoordinate - nextCluster.yCoordinate, currentCluster.xCoordinate - nextCluster.xCoordinate)};
                   const float tanL = (currentCluster.zCoordinate - nextCluster.zCoordinate) / (currentCluster.radius - nextCluster.radius);
                   if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
-                    tracklets.emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, iLayer + 1, iNext), tanL, phi, ts);
+                    tracklets.emplace_back(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, transition.toLayer, iNext), tanL, phi, ts);
                   } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
                     ++localCount;
                   } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
                     const int idx = base + offset++;
-                    tracklets[idx] = Tracklet(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, iLayer + 1, iNext), tanL, phi, ts);
+                    tracklets[idx] = Tracklet(currentSortedIndex, mTimeFrame->getSortedIndex(targetROF, transition.toLayer, iNext), tanL, phi, ts);
                   }
                 }
               }
@@ -175,22 +173,24 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
 
     int dummy{0};
     if (mTaskArena->max_concurrency() <= 1) {
-      for (int iLayer{0}; iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
-        const int startROF = 0, endROF = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).mNROFsTF;
+      for (int transitionId{0}; transitionId < topology.nTransitions; ++transitionId) {
+        const int fromLayer = topology.getTransition(transitionId).fromLayer;
+        const int startROF = 0, endROF = mTimeFrame->getROFOverlapTableView().getLayer(fromLayer).mNROFsTF;
         for (int pivotROF{startROF}; pivotROF < endROF; ++pivotROF) {
-          forTracklets(PassMode::OnePass{}, iLayer, pivotROF, 0, dummy);
+          forTracklets(PassMode::OnePass{}, transitionId, pivotROF, 0, dummy);
         }
       }
     } else {
-      tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
-        const int startROF = 0, endROF = mTimeFrame->getROFOverlapTableView().getLayer(iLayer).mNROFsTF;
+      tbb::parallel_for(0, static_cast<int>(topology.nTransitions), [&](const int transitionId) {
+        const int fromLayer = topology.getTransition(transitionId).fromLayer;
+        const int startROF = 0, endROF = mTimeFrame->getROFOverlapTableView().getLayer(fromLayer).mNROFsTF;
         bounded_vector<int> perROFCount((endROF - startROF) + 1, mMemoryPool.get());
         tbb::parallel_for(startROF, endROF, [&](const int pivotROF) {
-          perROFCount[pivotROF - startROF] = forTracklets(PassMode::TwoPassCount{}, iLayer, pivotROF, 0, dummy);
+          perROFCount[pivotROF - startROF] = forTracklets(PassMode::TwoPassCount{}, transitionId, pivotROF, 0, dummy);
         });
         std::exclusive_scan(perROFCount.begin(), perROFCount.end(), perROFCount.begin(), 0);
         const int nTracklets = perROFCount.back();
-        mTimeFrame->getTracklets()[iLayer].resize(nTracklets);
+        mTimeFrame->getTracklets()[transitionId].resize(nTracklets);
         if (nTracklets == 0) {
           return;
         }
@@ -200,38 +200,37 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
             return;
           }
           int localIdx = 0;
-          forTracklets(PassMode::TwoPassInsert{}, iLayer, pivotROF, baseIdx, localIdx);
+          forTracklets(PassMode::TwoPassInsert{}, transitionId, pivotROF, baseIdx, localIdx);
         });
       });
     }
 
-    tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
+    tbb::parallel_for(0, static_cast<int>(topology.nTransitions), [&](const int transitionId) {
       /// Sort tracklets & remove duplicates
       // duplicates can exist simply since we evaluate per vertex
-      auto& trkl{mTimeFrame->getTracklets()[iLayer]};
+      auto& trkl{mTimeFrame->getTracklets()[transitionId]};
       std::sort(trkl.begin(), trkl.end());
       trkl.erase(std::unique(trkl.begin(), trkl.end()), trkl.end());
       trkl.shrink_to_fit();
-      if (iLayer > 0) { /// recalculate lut
-        auto& lut{mTimeFrame->getTrackletsLookupTable()[iLayer - 1]};
-        if (!trkl.empty()) {
-          for (const auto& tkl : trkl) {
-            lut[tkl.firstClusterIndex + 1]++;
-          }
-          std::inclusive_scan(lut.begin(), lut.end(), lut.begin());
+      auto& lut{mTimeFrame->getTrackletsLookupTable()[transitionId]};
+      if (!trkl.empty()) {
+        for (const auto& tkl : trkl) {
+          lut[tkl.firstClusterIndex + 1]++;
         }
+        std::inclusive_scan(lut.begin(), lut.end(), lut.begin());
       }
     });
 
     /// Create tracklets labels
     if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].CreateArtefactLabels) {
-      tbb::parallel_for(0, mTrkParams[iteration].TrackletsPerRoad(), [&](const int iLayer) {
-        for (auto& trk : mTimeFrame->getTracklets()[iLayer]) {
+      tbb::parallel_for(0, static_cast<int>(topology.nTransitions), [&](const int transitionId) {
+        const auto& transition = topology.getTransition(transitionId);
+        for (auto& trk : mTimeFrame->getTracklets()[transitionId]) {
           MCCompLabel label;
-          int currentId{mTimeFrame->getClusters()[iLayer][trk.firstClusterIndex].clusterId};
-          int nextId{mTimeFrame->getClusters()[iLayer + 1][trk.secondClusterIndex].clusterId};
-          for (const auto& lab1 : mTimeFrame->getClusterLabels(iLayer, currentId)) {
-            for (const auto& lab2 : mTimeFrame->getClusterLabels(iLayer + 1, nextId)) {
+          int currentId{mTimeFrame->getClusters()[transition.fromLayer][trk.firstClusterIndex].clusterId};
+          int nextId{mTimeFrame->getClusters()[transition.toLayer][trk.secondClusterIndex].clusterId};
+          for (const auto& lab1 : mTimeFrame->getClusterLabels(transition.fromLayer, currentId)) {
+            for (const auto& lab2 : mTimeFrame->getClusterLabels(transition.toLayer, nextId)) {
               if (lab1 == lab2 && lab1.isValid()) {
                 label = lab1;
                 break;
@@ -241,7 +240,7 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
               break;
             }
           }
-          mTimeFrame->getTrackletsLabel(iLayer).emplace_back(label);
+          mTimeFrame->getTrackletsLabel(transitionId).emplace_back(label);
         }
       });
     }
@@ -251,26 +250,28 @@ void TrackerTraits<NLayers>::computeLayerTracklets(const int iteration, int iVer
 template <int NLayers>
 void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
 {
-  for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-    deepVectorClear(mTimeFrame->getCells()[iLayer]);
-    if (iLayer > 0) {
-      deepVectorClear(mTimeFrame->getCellsLookupTable()[iLayer - 1]);
-    }
+  const auto topology = mTimeFrame->getTrackingTopologyView();
+  for (int cellTopologyId = 0; cellTopologyId < topology.nCells; ++cellTopologyId) {
+    deepVectorClear(mTimeFrame->getCells()[cellTopologyId]);
+    deepVectorClear(mTimeFrame->getCellsLookupTable()[cellTopologyId]);
     if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].CreateArtefactLabels) {
-      deepVectorClear(mTimeFrame->getCellsLabel(iLayer));
+      deepVectorClear(mTimeFrame->getCellsLabel(cellTopologyId));
     }
   }
 
   mTaskArena->execute([&] {
-    auto forTrackletCells = [&](auto Tag, int iLayer, bounded_vector<CellSeed>& layerCells, int iTracklet, int offset = 0) -> int {
-      const Tracklet& currentTracklet{mTimeFrame->getTracklets()[iLayer][iTracklet]};
+    auto forTrackletCells = [&](auto Tag, int cellTopologyId, bounded_vector<CellSeed>& layerCells, int iTracklet, int offset = 0) -> int {
+      const auto& cellTopology = topology.getCell(cellTopologyId);
+      const auto& firstTransition = topology.getTransition(cellTopology.firstTransition);
+      const auto& secondTransition = topology.getTransition(cellTopology.secondTransition);
+      const Tracklet& currentTracklet{mTimeFrame->getTracklets()[cellTopology.firstTransition][iTracklet]};
       const int nextLayerClusterIndex{currentTracklet.secondClusterIndex};
-      const int nextLayerFirstTrackletIndex{mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex]};
-      const int nextLayerLastTrackletIndex{mTimeFrame->getTrackletsLookupTable()[iLayer][nextLayerClusterIndex + 1]};
+      const int nextLayerFirstTrackletIndex{mTimeFrame->getTrackletsLookupTable()[cellTopology.secondTransition][nextLayerClusterIndex]};
+      const int nextLayerLastTrackletIndex{mTimeFrame->getTrackletsLookupTable()[cellTopology.secondTransition][nextLayerClusterIndex + 1]};
       int foundCells{0};
       for (int iNextTracklet{nextLayerFirstTrackletIndex}; iNextTracklet < nextLayerLastTrackletIndex; ++iNextTracklet) {
-        const Tracklet& nextTracklet{mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet]};
-        if (mTimeFrame->getTracklets()[iLayer + 1][iNextTracklet].firstClusterIndex != nextLayerClusterIndex) {
+        const Tracklet& nextTracklet{mTimeFrame->getTracklets()[cellTopology.secondTransition][iNextTracklet]};
+        if (nextTracklet.firstClusterIndex != nextLayerClusterIndex) {
           break;
         }
         if (!currentTracklet.getTimeStamp().isCompatible(nextTracklet.getTimeStamp())) {
@@ -282,18 +283,20 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
 
           /// Track seed preparation. Clusters are numbered progressively from the innermost going outward.
           const int clusId[3]{
-            mTimeFrame->getClusters()[iLayer][currentTracklet.firstClusterIndex].clusterId,
-            mTimeFrame->getClusters()[iLayer + 1][nextTracklet.firstClusterIndex].clusterId,
-            mTimeFrame->getClusters()[iLayer + 2][nextTracklet.secondClusterIndex].clusterId};
-          const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[iLayer][clusId[0]];
-          const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[iLayer + 1][clusId[1]];
-          const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + 2)[clusId[2]];
+            mTimeFrame->getClusters()[firstTransition.fromLayer][currentTracklet.firstClusterIndex].clusterId,
+            mTimeFrame->getClusters()[firstTransition.toLayer][nextTracklet.firstClusterIndex].clusterId,
+            mTimeFrame->getClusters()[secondTransition.toLayer][nextTracklet.secondClusterIndex].clusterId};
+          const int hitLayers[3]{firstTransition.fromLayer, firstTransition.toLayer, secondTransition.toLayer};
+          const auto& cluster1_glo = mTimeFrame->getUnsortedClusters()[firstTransition.fromLayer][clusId[0]];
+          const auto& cluster2_glo = mTimeFrame->getUnsortedClusters()[firstTransition.toLayer][clusId[1]];
+          const auto& cluster3_tf = mTimeFrame->getTrackingFrameInfoOnLayer(secondTransition.toLayer)[clusId[2]];
           auto track{o2::its::track::buildTrackSeed(cluster1_glo, cluster2_glo, cluster3_tf, mBz)};
 
           float chi2{0.f};
           bool good{false};
           for (int iC{2}; iC--;) {
-            const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer + iC)[clusId[iC]];
+            const int hitLayer = hitLayers[iC];
+            const TrackingFrameInfo& trackingHit = mTimeFrame->getTrackingFrameInfoOnLayer(hitLayer)[clusId[iC]];
 
             if (!track.rotate(trackingHit.alphaTrackingFrame)) {
               break;
@@ -303,7 +306,7 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
               break;
             }
 
-            if (!track.correctForMaterial(mTrkParams[iteration].LayerxX0[iLayer + iC], mTrkParams[iteration].LayerxX0[iLayer + iC] * constants::Radl * constants::Rho, true)) {
+            if (!track.correctForMaterial(mTrkParams[iteration].LayerxX0[hitLayer], mTrkParams[iteration].LayerxX0[hitLayer] * constants::Radl * constants::Rho, true)) {
               break;
             }
 
@@ -323,12 +326,13 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
             TimeEstBC ts = currentTracklet.getTimeStamp();
             ts += nextTracklet.getTimeStamp();
             if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
-              layerCells.emplace_back(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
+              layerCells.emplace_back(cellTopology.hitLayerMask, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
               ++foundCells;
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
               ++foundCells;
             } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
-              layerCells[offset++] = CellSeed(iLayer, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
+              layerCells[offset++] = CellSeed(cellTopology.hitLayerMask, clusId[0], clusId[1], clusId[2], iTracklet, iNextTracklet, track, chi2, ts);
+              ++foundCells;
             } else {
               static_assert(false, "Unknown mode!");
             }
@@ -338,39 +342,32 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
       return foundCells;
     };
 
-    for (int iLayer = 0; iLayer < mTrkParams[iteration].CellsPerRoad(); ++iLayer) {
-      if (mTimeFrame->getTracklets()[iLayer + 1].empty() ||
-          mTimeFrame->getTracklets()[iLayer].empty()) {
-        if (iLayer < mTrkParams[iteration].TrackletsPerRoad()) {
-          deepVectorClear(mTimeFrame->getTracklets()[iLayer]);
-          deepVectorClear(mTimeFrame->getTrackletsLabel(iLayer));
-        }
+    for (int cellTopologyId = 0; cellTopologyId < topology.nCells; ++cellTopologyId) {
+      const auto& cellTopology = topology.getCell(cellTopologyId);
+      if (mTimeFrame->getTracklets()[cellTopology.firstTransition].empty() ||
+          mTimeFrame->getTracklets()[cellTopology.secondTransition].empty()) {
         continue;
       }
 
-      auto& layerCells = mTimeFrame->getCells()[iLayer];
-      const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[iLayer].size())};
+      auto& layerCells = mTimeFrame->getCells()[cellTopologyId];
+      const int currentLayerTrackletsNum{static_cast<int>(mTimeFrame->getTracklets()[cellTopology.firstTransition].size())};
       bounded_vector<int> perTrackletCount(currentLayerTrackletsNum + 1, 0, mMemoryPool.get());
       if (mTaskArena->max_concurrency() <= 1) {
         for (int iTracklet{0}; iTracklet < currentLayerTrackletsNum; ++iTracklet) {
-          perTrackletCount[iTracklet] = forTrackletCells(PassMode::OnePass{}, iLayer, layerCells, iTracklet);
+          perTrackletCount[iTracklet] = forTrackletCells(PassMode::OnePass{}, cellTopologyId, layerCells, iTracklet);
         }
         std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
       } else {
         tbb::parallel_for(0, currentLayerTrackletsNum, [&](const int iTracklet) {
-          perTrackletCount[iTracklet] = forTrackletCells(PassMode::TwoPassCount{}, iLayer, layerCells, iTracklet);
+          perTrackletCount[iTracklet] = forTrackletCells(PassMode::TwoPassCount{}, cellTopologyId, layerCells, iTracklet);
         });
 
         std::exclusive_scan(perTrackletCount.begin(), perTrackletCount.end(), perTrackletCount.begin(), 0);
         auto totalCells{perTrackletCount.back()};
         if (totalCells == 0) {
-          if (iLayer > 0) {
-            auto& lut = mTimeFrame->getCellsLookupTable()[iLayer - 1];
-            lut.resize(currentLayerTrackletsNum + 1);
-            std::fill(lut.begin(), lut.end(), 0);
-          }
-          deepVectorClear(mTimeFrame->getTracklets()[iLayer]);
-          deepVectorClear(mTimeFrame->getTrackletsLabel(iLayer));
+          auto& lut = mTimeFrame->getCellsLookupTable()[cellTopologyId];
+          lut.resize(currentLayerTrackletsNum + 1);
+          std::fill(lut.begin(), lut.end(), 0);
           continue;
         }
         layerCells.resize(totalCells);
@@ -380,181 +377,184 @@ void TrackerTraits<NLayers>::computeLayerCells(const int iteration)
           if (offset == perTrackletCount[iTracklet + 1]) {
             return;
           }
-          forTrackletCells(PassMode::TwoPassInsert{}, iLayer, layerCells, iTracklet, offset);
+          forTrackletCells(PassMode::TwoPassInsert{}, cellTopologyId, layerCells, iTracklet, offset);
         });
       }
 
-      if (iLayer > 0) {
-        auto& lut = mTimeFrame->getCellsLookupTable()[iLayer - 1];
-        lut.resize(currentLayerTrackletsNum + 1);
-        std::copy_n(perTrackletCount.begin(), currentLayerTrackletsNum + 1, lut.begin());
-      }
+      auto& lut = mTimeFrame->getCellsLookupTable()[cellTopologyId];
+      lut.resize(currentLayerTrackletsNum + 1);
+      std::copy_n(perTrackletCount.begin(), currentLayerTrackletsNum + 1, lut.begin());
 
       if (mTimeFrame->hasMCinformation() && mTrkParams[iteration].CreateArtefactLabels) {
-        auto& labels = mTimeFrame->getCellsLabel(iLayer);
+        auto& labels = mTimeFrame->getCellsLabel(cellTopologyId);
         labels.reserve(layerCells.size());
         for (const auto& cell : layerCells) {
-          MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(iLayer)[cell.getFirstTrackletIndex()]};
-          MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(iLayer + 1)[cell.getSecondTrackletIndex()]};
+          MCCompLabel currentLab{mTimeFrame->getTrackletsLabel(cellTopology.firstTransition)[cell.getFirstTrackletIndex()]};
+          MCCompLabel nextLab{mTimeFrame->getTrackletsLabel(cellTopology.secondTransition)[cell.getSecondTrackletIndex()]};
           labels.emplace_back(currentLab == nextLab ? currentLab : MCCompLabel());
         }
       }
-
-      // Once layer i cells are built and labelled, the corresponding tracklet artefacts are no longer needed.
-      deepVectorClear(mTimeFrame->getTracklets()[iLayer]);
-      deepVectorClear(mTimeFrame->getTrackletsLabel(iLayer));
     }
   });
 
-  // Clear the trailing tracklet artefacts that are not consumed as the first leg of a cell.
-  for (int iLayer = mTrkParams[iteration].CellsPerRoad(); iLayer < mTrkParams[iteration].TrackletsPerRoad(); ++iLayer) {
-    deepVectorClear(mTimeFrame->getTracklets()[iLayer]);
-    deepVectorClear(mTimeFrame->getTrackletsLabel(iLayer));
+  for (int transitionId = 0; transitionId < topology.nTransitions; ++transitionId) {
+    deepVectorClear(mTimeFrame->getTracklets()[transitionId]);
+    deepVectorClear(mTimeFrame->getTrackletsLabel(transitionId));
   }
 }
 
 template <int NLayers>
 void TrackerTraits<NLayers>::findCellsNeighbours(const int iteration)
 {
-  struct Neighbor {
-    int cell{-1}, nextCell{-1}, level{-1};
-  };
-
+  const auto topology = mTimeFrame->getTrackingTopologyView();
   mTaskArena->execute([&] {
-    for (int iLayer{0}; iLayer < mTrkParams[iteration].NeighboursPerRoad(); ++iLayer) {
-      deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
-      deepVectorClear(mTimeFrame->getCellsNeighboursLUT()[iLayer]);
-      if (mTimeFrame->getCells()[iLayer + 1].empty() ||
-          mTimeFrame->getCellsLookupTable()[iLayer].empty()) {
-        continue;
-      }
+    std::vector<bounded_vector<CellNeighbour>> cellsNeighboursByTarget;
+    cellsNeighboursByTarget.reserve(topology.nCells);
+    for (int cellTopologyId{0}; cellTopologyId < topology.nCells; ++cellTopologyId) {
+      deepVectorClear(mTimeFrame->getCellsNeighbours()[cellTopologyId]);
+      deepVectorClear(mTimeFrame->getCellsNeighboursTopology()[cellTopologyId]);
+      deepVectorClear(mTimeFrame->getCellsNeighboursLUT()[cellTopologyId]);
+      cellsNeighboursByTarget.emplace_back(mMemoryPool.get());
+    }
 
-      int nCells{static_cast<int>(mTimeFrame->getCells()[iLayer].size())};
-      bounded_vector<Neighbor> cellsNeighbours(mMemoryPool.get());
-
-      auto forCellNeighbour = [&](auto Tag, int iCell, int offset = 0) -> int {
-        const auto& currentCellSeed{mTimeFrame->getCells()[iLayer][iCell]};
-        const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
-        const int nextLayerFirstCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex]};
-        const int nextLayerLastCellIndex{mTimeFrame->getCellsLookupTable()[iLayer][nextLayerTrackletIndex + 1]};
-        int foundNextCells{0};
-        for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
-          auto nextCellSeed{mTimeFrame->getCells()[iLayer + 1][iNextCell]}; /// copy
-          if (nextCellSeed.getFirstTrackletIndex() != nextLayerTrackletIndex || !currentCellSeed.getTimeStamp().isCompatible(nextCellSeed.getTimeStamp())) {
-            break;
-          }
+    for (int outerLayer{0}; outerLayer < NLayers; ++outerLayer) {
+      for (int cellTopologyId{0}; cellTopologyId < topology.nCells; ++cellTopologyId) {
+        const auto& cellTopology = topology.getCell(cellTopologyId);
+        if (cellTopology.hitLayerMask.last() != outerLayer ||
+            mTimeFrame->getCells()[cellTopologyId].empty()) {
+          continue;
+        }
+        const auto successors = topology.getCellsStartingWithTransition(cellTopology.secondTransition);
+        if (!successors.getEntries()) {
+          continue;
+        }
 
-          if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
-              !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
-            continue;
-          }
+        tbb::enumerable_thread_specific<bounded_vector<CellNeighbour>> sourceNeighbours([&]() { return bounded_vector<CellNeighbour>{mMemoryPool.get()}; });
+        tbb::parallel_for(0, static_cast<int>(mTimeFrame->getCells()[cellTopologyId].size()), [&](const int iCell) {
+          auto& localNeighbours = sourceNeighbours.local();
+          const auto& currentCellSeed{mTimeFrame->getCells()[cellTopologyId][iCell]};
+          const int nextLayerTrackletIndex{currentCellSeed.getSecondTrackletIndex()};
+          for (int iSuccessor{0}; iSuccessor < successors.getEntries(); ++iSuccessor) {
+            const int nextCellTopologyId = topology.cellsByFirstTransition[successors.getFirstEntry() + iSuccessor];
+            if (mTimeFrame->getCells()[nextCellTopologyId].empty() ||
+                mTimeFrame->getCellsLookupTable()[nextCellTopologyId].empty()) {
+              continue;
+            }
+            const auto& nextCellLUT = mTimeFrame->getCellsLookupTable()[nextCellTopologyId];
+            if (nextLayerTrackletIndex + 1 >= static_cast<int>(nextCellLUT.size())) {
+              continue;
+            }
+            const int nextLayerFirstCellIndex{nextCellLUT[nextLayerTrackletIndex]};
+            const int nextLayerLastCellIndex{nextCellLUT[nextLayerTrackletIndex + 1]};
+            for (int iNextCell{nextLayerFirstCellIndex}; iNextCell < nextLayerLastCellIndex; ++iNextCell) {
+              const auto& nextCellSeedRef{mTimeFrame->getCells()[nextCellTopologyId][iNextCell]};
+              if (nextCellSeedRef.getFirstTrackletIndex() != nextLayerTrackletIndex || !currentCellSeed.getTimeStamp().isCompatible(nextCellSeedRef.getTimeStamp())) {
+                break;
+              }
 
-          float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed); /// TODO: switch to the chi2 wrt cluster to avoid correlation
-          if (chi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
-            continue;
-          }
+              auto nextCellSeed{mTimeFrame->getCells()[nextCellTopologyId][iNextCell]}; /// copy
+              if (!nextCellSeed.rotate(currentCellSeed.getAlpha()) ||
+                  !nextCellSeed.propagateTo(currentCellSeed.getX(), getBz())) {
+                continue;
+              }
 
-          if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
-            cellsNeighbours.emplace_back(iCell, iNextCell, currentCellSeed.getLevel() + 1);
-          } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
-            ++foundNextCells;
-          } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
-            cellsNeighbours[offset++] = {iCell, iNextCell, currentCellSeed.getLevel() + 1};
-          } else {
-            static_assert(false, "Unknown mode!");
-          }
-        }
-        return foundNextCells;
-      };
+              float chi2 = currentCellSeed.getPredictedChi2(nextCellSeed);
+              if (chi2 > mTrkParams[iteration].MaxChi2ClusterAttachment) {
+                continue;
+              }
 
-      if (mTaskArena->max_concurrency() <= 1) {
-        for (int iCell{0}; iCell < nCells; ++iCell) {
-          forCellNeighbour(PassMode::OnePass{}, iCell);
-        }
-      } else {
-        bounded_vector<int> perCellCount(nCells + 1, 0, mMemoryPool.get());
-        tbb::parallel_for(0, nCells, [&](const int iCell) {
-          perCellCount[iCell] = forCellNeighbour(PassMode::TwoPassCount{}, iCell);
+              const int nextLevel = currentCellSeed.getLevel() + 1;
+              localNeighbours.emplace_back(cellTopologyId, iCell, nextCellTopologyId, iNextCell, nextLevel);
+            }
+          }
         });
 
-        std::exclusive_scan(perCellCount.begin(), perCellCount.end(), perCellCount.begin(), 0);
-        int totalCellNeighbours = perCellCount.back();
-        if (totalCellNeighbours == 0) {
-          deepVectorClear(mTimeFrame->getCellsNeighbours()[iLayer]);
-          continue;
+        bounded_vector<size_t> count(topology.nCells, 0, mMemoryPool.get());
+        for (const auto& localNeighbours : sourceNeighbours) {
+          for (const auto& neigh : localNeighbours) {
+            ++count[neigh.nextCellTopology];
+          }
         }
-        cellsNeighbours.resize(totalCellNeighbours);
-
-        tbb::parallel_for(0, nCells, [&](const int iCell) {
-          int offset = perCellCount[iCell];
-          if (offset == perCellCount[iCell + 1]) {
-            return;
+        for (size_t i{0}; i < topology.nCells; ++i) {
+          cellsNeighboursByTarget[i].reserve(count[i]);
+        }
+        for (const auto& localNeighbours : sourceNeighbours) {
+          for (const auto& neigh : localNeighbours) {
+            cellsNeighboursByTarget[neigh.nextCellTopology].emplace_back(neigh);
+            if (neigh.level > mTimeFrame->getCells()[neigh.nextCellTopology][neigh.nextCell].getLevel()) {
+              mTimeFrame->getCells()[neigh.nextCellTopology][neigh.nextCell].setLevel(neigh.level);
+            }
           }
-          forCellNeighbour(PassMode::TwoPassInsert{}, iCell, offset);
-        });
+        }
       }
+    }
 
+    for (int cellTopologyId{0}; cellTopologyId < topology.nCells; ++cellTopologyId) {
+      auto& cellsNeighbours = cellsNeighboursByTarget[cellTopologyId];
       if (cellsNeighbours.empty()) {
         continue;
       }
 
-      tbb::parallel_sort(cellsNeighbours.begin(), cellsNeighbours.end(), [](const auto& a, const auto& b) {
+      std::sort(cellsNeighbours.begin(), cellsNeighbours.end(), [](const auto& a, const auto& b) {
         return a.nextCell < b.nextCell;
       });
 
-      auto& cellsNeighbourLUT = mTimeFrame->getCellsNeighboursLUT()[iLayer];
-      cellsNeighbourLUT.assign(mTimeFrame->getCells()[iLayer + 1].size(), 0);
+      auto& cellsNeighbourLUT = mTimeFrame->getCellsNeighboursLUT()[cellTopologyId];
+      cellsNeighbourLUT.assign(mTimeFrame->getCells()[cellTopologyId].size(), 0);
       for (const auto& neigh : cellsNeighbours) {
         ++cellsNeighbourLUT[neigh.nextCell];
       }
       std::inclusive_scan(cellsNeighbourLUT.begin(), cellsNeighbourLUT.end(), cellsNeighbourLUT.begin());
 
-      mTimeFrame->getCellsNeighbours()[iLayer].reserve(cellsNeighbours.size());
-      std::ranges::transform(cellsNeighbours, std::back_inserter(mTimeFrame->getCellsNeighbours()[iLayer]), [](const auto& neigh) { return neigh.cell; });
-
-      for (auto it = cellsNeighbours.begin(); it != cellsNeighbours.end();) {
-        int cellIdx = it->nextCell;
-        int maxLvl = it->level;
-        while (++it != cellsNeighbours.end() && it->nextCell == cellIdx) {
-          maxLvl = std::max(maxLvl, it->level);
-        }
-        mTimeFrame->getCells()[iLayer + 1][cellIdx].setLevel(maxLvl);
-      }
+      mTimeFrame->getCellsNeighbours()[cellTopologyId].reserve(cellsNeighbours.size());
+      mTimeFrame->getCellsNeighboursTopology()[cellTopologyId].reserve(cellsNeighbours.size());
+      std::ranges::transform(cellsNeighbours, std::back_inserter(mTimeFrame->getCellsNeighbours()[cellTopologyId]), [](const auto& neigh) { return neigh.cell; });
+      std::ranges::transform(cellsNeighbours, std::back_inserter(mTimeFrame->getCellsNeighboursTopology()[cellTopologyId]), [](const auto& neigh) { return neigh.cellTopology; });
+    }
 
-      // clear cells LUT
-      deepVectorClear(mTimeFrame->getCellsLookupTable()[iLayer]);
+    // clean up LUTs
+    for (auto& cellLUT : mTimeFrame->getCellsLookupTable()) {
+      deepVectorClear(cellLUT);
     }
   });
 }
 
 template <int NLayers>
 template <typename InputSeed>
-void TrackerTraits<NLayers>::processNeighbours(int iteration, int iLayer, int iLevel, const bounded_vector<InputSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, bounded_vector<TrackSeedN>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds)
+void TrackerTraits<NLayers>::processNeighbours(int iteration, int defaultCellTopologyId, int iLevel, const bounded_vector<InputSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, const bounded_vector<int>& currentCellTopologyId, bounded_vector<TrackSeedN>& updatedCellSeeds, bounded_vector<int>& updatedCellsIds, bounded_vector<int>& updatedCellsTopologyIds)
 {
   auto propagator = o2::base::Propagator::Instance();
 
   mTaskArena->execute([&] {
     auto forCellNeighbours = [&](auto Tag, int iCell, int offset = 0) -> int {
       const auto& currentCell{currentCellSeed[iCell]};
+      const int cellTopologyId = currentCellTopologyId.empty() ? defaultCellTopologyId : currentCellTopologyId[iCell];
 
       if constexpr (decltype(Tag)::value != PassMode::TwoPassInsert::value) {
         if (currentCell.getLevel() != iLevel) {
           return 0;
         }
-        if (currentCellId.empty() && (mTimeFrame->isClusterUsed(iLayer, currentCell.getFirstClusterIndex()) ||
-                                      mTimeFrame->isClusterUsed(iLayer + 1, currentCell.getSecondClusterIndex()) ||
-                                      mTimeFrame->isClusterUsed(iLayer + 2, currentCell.getThirdClusterIndex()))) {
-          return 0; /// this we do only on the first iteration, hence the check on currentCellId
+        if (currentCellId.empty()) {
+          for (int layer = 0; layer < NLayers; ++layer) {
+            const int clusterIndex = currentCell.getCluster(layer);
+            if (clusterIndex != constants::UnusedIndex && mTimeFrame->isClusterUsed(layer, clusterIndex)) {
+              return 0; /// this we do only on the first iteration, hence the check on currentCellId
+            }
+          }
         }
       }
 
       const int cellId = currentCellId.empty() ? iCell : currentCellId[iCell];
-      const int startNeighbourId{cellId ? mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId - 1] : 0};
-      const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[iLayer - 1][cellId]};
+      if (cellTopologyId < 0 || mTimeFrame->getCellsNeighboursLUT()[cellTopologyId].empty()) {
+        return 0;
+      }
+      const int startNeighbourId{cellId ? mTimeFrame->getCellsNeighboursLUT()[cellTopologyId][cellId - 1] : 0};
+      const int endNeighbourId{mTimeFrame->getCellsNeighboursLUT()[cellTopologyId][cellId]};
       int foundSeeds{0};
       for (int iNeighbourCell{startNeighbourId}; iNeighbourCell < endNeighbourId; ++iNeighbourCell) {
-        const int neighbourCellId = mTimeFrame->getCellsNeighbours()[iLayer - 1][iNeighbourCell];
-        const auto& neighbourCell = mTimeFrame->getCells()[iLayer - 1][neighbourCellId];
+        const int neighbourCellTopologyId = mTimeFrame->getCellsNeighboursTopology()[cellTopologyId][iNeighbourCell];
+        const int neighbourCellId = mTimeFrame->getCellsNeighbours()[cellTopologyId][iNeighbourCell];
+        const auto& neighbourCell = mTimeFrame->getCells()[neighbourCellTopologyId][neighbourCellId];
         if (neighbourCell.getSecondTrackletIndex() != currentCell.getFirstTrackletIndex()) {
           continue;
         }
@@ -564,7 +564,9 @@ void TrackerTraits<NLayers>::processNeighbours(int iteration, int iLayer, int iL
         if (currentCell.getLevel() - 1 != neighbourCell.getLevel()) {
           continue;
         }
-        if (mTimeFrame->isClusterUsed(iLayer - 1, neighbourCell.getFirstClusterIndex())) {
+        const int neighbourLayer = neighbourCell.getInnerLayer();
+        const int neighbourCluster = neighbourCell.getFirstClusterIndex();
+        if (mTimeFrame->isClusterUsed(neighbourLayer, neighbourCluster)) {
           continue;
         }
 
@@ -572,7 +574,7 @@ void TrackerTraits<NLayers>::processNeighbours(int iteration, int iLayer, int iL
         TrackSeedN seed{currentCell};
         seed.getTimeStamp() = currentCell.getTimeStamp();
         seed.getTimeStamp() += neighbourCell.getTimeStamp();
-        const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer - 1)[neighbourCell.getFirstClusterIndex()];
+        const auto& trHit = mTimeFrame->getTrackingFrameInfoOnLayer(neighbourLayer)[neighbourCluster];
 
         if (!seed.rotate(trHit.alphaTrackingFrame)) {
           continue;
@@ -583,7 +585,7 @@ void TrackerTraits<NLayers>::processNeighbours(int iteration, int iLayer, int iL
         }
 
         if (mTrkParams[iteration].CorrType == o2::base::PropagatorF::MatCorrType::USEMatCorrNONE) {
-          if (!seed.correctForMaterial(mTrkParams[iteration].LayerxX0[iLayer - 1], mTrkParams[iteration].LayerxX0[iLayer - 1] * constants::Radl * constants::Rho, true)) {
+          if (!seed.correctForMaterial(mTrkParams[iteration].LayerxX0[neighbourLayer], mTrkParams[iteration].LayerxX0[neighbourLayer] * constants::Radl * constants::Rho, true)) {
             continue;
           }
         }
@@ -598,7 +600,10 @@ void TrackerTraits<NLayers>::processNeighbours(int iteration, int iLayer, int iL
         }
 
         if constexpr (decltype(Tag)::value != PassMode::TwoPassCount::value) {
-          seed.getClusters()[iLayer - 1] = neighbourCell.getFirstClusterIndex();
+          seed.getClusters()[neighbourLayer] = neighbourCluster;
+          auto mask = seed.getHitLayerMask();
+          mask.set(neighbourLayer);
+          seed.setHitLayerMask(mask);
           seed.setLevel(neighbourCell.getLevel());
           seed.setFirstTrackletIndex(neighbourCell.getFirstTrackletIndex());
           seed.setSecondTrackletIndex(neighbourCell.getSecondTrackletIndex());
@@ -607,11 +612,13 @@ void TrackerTraits<NLayers>::processNeighbours(int iteration, int iLayer, int iL
         if constexpr (decltype(Tag)::value == PassMode::OnePass::value) {
           updatedCellSeeds.push_back(seed);
           updatedCellsIds.push_back(neighbourCellId);
+          updatedCellsTopologyIds.push_back(neighbourCellTopologyId);
         } else if constexpr (decltype(Tag)::value == PassMode::TwoPassCount::value) {
           ++foundSeeds;
         } else if constexpr (decltype(Tag)::value == PassMode::TwoPassInsert::value) {
           updatedCellSeeds[offset] = seed;
-          updatedCellsIds[offset++] = neighbourCellId;
+          updatedCellsIds[offset] = neighbourCellId;
+          updatedCellsTopologyIds[offset++] = neighbourCellTopologyId;
         } else {
           static_assert(false, "Unknown mode!");
         }
@@ -637,6 +644,7 @@ void TrackerTraits<NLayers>::processNeighbours(int iteration, int iLayer, int iL
       }
       updatedCellSeeds.resize(totalNeighbours);
       updatedCellsIds.resize(totalNeighbours);
+      updatedCellsTopologyIds.resize(totalNeighbours);
 
       tbb::parallel_for(0, nCells, [&](const int iCell) {
         int offset = perCellCount[iCell];
@@ -663,33 +671,42 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
     tfInfos[iLayer] = mTimeFrame->getTrackingFrameInfoOnLayer(iLayer).data();
     unsortedClusters[iLayer] = mTimeFrame->getUnsortedClusters()[iLayer].data();
   }
+  const auto topology = mTimeFrame->getTrackingTopologyView();
   for (int startLevel{mTrkParams[iteration].CellsPerRoad()}; startLevel >= mTrkParams[iteration].CellMinimumLevel(); --startLevel) {
 
     auto seedFilter = [&](const auto& seed) {
-      return seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[iteration].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
+      return seed.getHitLayerMask().isAllowed(mTrkParams[iteration].MaxHoles, mTrkParams[iteration].HoleLayerMask) &&
+             seed.getHitLayerMask().length() >= mTrkParams[iteration].MinTrackLength &&
+             seed.getQ2Pt() <= 1.e3 && seed.getChi2() <= mTrkParams[iteration].MaxChi2NDF * ((startLevel + 2) * 2 - 5);
     };
 
     bounded_vector<TrackSeedN> trackSeeds(mMemoryPool.get());
-    for (int startLayer{mTrkParams[iteration].NeighboursPerRoad()}; startLayer >= startLevel - 1; --startLayer) {
-      if ((mTrkParams[iteration].StartLayerMask & (1 << (startLayer + 2))) == 0) {
+    for (int startCellTopologyId{0}; startCellTopologyId < topology.nCells; ++startCellTopologyId) {
+      const int startLayer = topology.getCell(startCellTopologyId).hitLayerMask.last();
+      if ((mTrkParams[iteration].StartLayerMask & (1 << startLayer)) == 0 ||
+          mTimeFrame->getCells()[startCellTopologyId].empty()) {
         continue;
       }
 
       bounded_vector<int> lastCellId(mMemoryPool.get()), updatedCellId(mMemoryPool.get());
+      bounded_vector<int> lastCellTopologyId(mMemoryPool.get()), updatedCellTopologyId(mMemoryPool.get());
       bounded_vector<TrackSeedN> lastCellSeed(mMemoryPool.get()), updatedCellSeed(mMemoryPool.get());
 
-      processNeighbours(iteration, startLayer, startLevel, mTimeFrame->getCells()[startLayer], lastCellId, updatedCellSeed, updatedCellId);
+      processNeighbours(iteration, startCellTopologyId, startLevel, mTimeFrame->getCells()[startCellTopologyId], lastCellId, lastCellTopologyId, updatedCellSeed, updatedCellId, updatedCellTopologyId);
 
       int level = startLevel;
-      for (int iLayer{startLayer - 1}; iLayer > 0 && level > 2; --iLayer) {
+      while (level > 2 && !updatedCellSeed.empty()) {
         lastCellSeed.swap(updatedCellSeed);
         lastCellId.swap(updatedCellId);
+        lastCellTopologyId.swap(updatedCellTopologyId);
         deepVectorClear(updatedCellSeed); /// tame the memory peaks
         deepVectorClear(updatedCellId);   /// tame the memory peaks
-        processNeighbours(iteration, iLayer, --level, lastCellSeed, lastCellId, updatedCellSeed, updatedCellId);
+        deepVectorClear(updatedCellTopologyId);
+        processNeighbours(iteration, constants::UnusedIndex, --level, lastCellSeed, lastCellId, lastCellTopologyId, updatedCellSeed, updatedCellId, updatedCellTopologyId);
       }
-      deepVectorClear(lastCellId);   /// tame the memory peaks
-      deepVectorClear(lastCellSeed); /// tame the memory peaks
+      deepVectorClear(lastCellId);         /// tame the memory peaks
+      deepVectorClear(lastCellTopologyId); /// tame the memory peaks
+      deepVectorClear(lastCellSeed);       /// tame the memory peaks
 
       if (!updatedCellSeed.empty()) {
         trackSeeds.reserve(trackSeeds.size() + std::count_if(updatedCellSeed.begin(), updatedCellSeed.end(), seedFilter));
@@ -767,7 +784,7 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
     });
 
     std::sort(tracks.begin(), tracks.end(), [](const auto& a, const auto& b) {
-      return a.getChi2() < b.getChi2();
+      return track::isBetter(a, b);
     });
 
     acceptTracks(iteration, tracks, firstClusters, sharedFirstClusters);
@@ -778,6 +795,8 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
 template <int NLayers>
 void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters, bounded_vector<bounded_vector<int>>& sharedFirstClusters)
 {
+  auto& trks = mTimeFrame->getTracks();
+  trks.reserve(trks.size() + tracks.size());
   const float smallestROFHalf = mTimeFrame->getROFOverlapTableView().getClockLayer().mROFLength * 0.5f;
   for (auto& track : tracks) {
     int nShared = 0;
@@ -837,7 +856,7 @@ void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITS
     }
     track.setUserField(0);
     track.getParamOut().setUserField(0);
-    mTimeFrame->getTracks().emplace_back(track);
+    trks.emplace_back(track);
 
     if (mTrkParams[iteration].AllowSharingFirstCluster) {
       firstClusters[firstLayer].push_back(firstCluster);
@@ -897,13 +916,13 @@ void TrackerTraits<NLayers>::setNThreads(int n, std::shared_ptr<tbb::task_arena>
 }
 
 template class TrackerTraits<7>;
-template void TrackerTraits<7>::processNeighbours<CellSeed>(int, int, int, const bounded_vector<CellSeed>&, const bounded_vector<int>&, bounded_vector<TrackSeed<7>>&, bounded_vector<int>&);
-template void TrackerTraits<7>::processNeighbours<TrackSeed<7>>(int, int, int, const bounded_vector<TrackSeed<7>>&, const bounded_vector<int>&, bounded_vector<TrackSeed<7>>&, bounded_vector<int>&);
+template void TrackerTraits<7>::processNeighbours<CellSeed>(int, int, int, const bounded_vector<CellSeed>&, const bounded_vector<int>&, const bounded_vector<int>&, bounded_vector<TrackSeed<7>>&, bounded_vector<int>&, bounded_vector<int>&);
+template void TrackerTraits<7>::processNeighbours<TrackSeed<7>>(int, int, int, const bounded_vector<TrackSeed<7>>&, const bounded_vector<int>&, const bounded_vector<int>&, bounded_vector<TrackSeed<7>>&, bounded_vector<int>&, bounded_vector<int>&);
 // ALICE3 upgrade
 #ifdef ENABLE_UPGRADES
 template class TrackerTraits<11>;
-template void TrackerTraits<11>::processNeighbours<CellSeed>(int, int, int, const bounded_vector<CellSeed>&, const bounded_vector<int>&, bounded_vector<TrackSeed<11>>&, bounded_vector<int>&);
-template void TrackerTraits<11>::processNeighbours<TrackSeed<11>>(int, int, int, const bounded_vector<TrackSeed<11>>&, const bounded_vector<int>&, bounded_vector<TrackSeed<11>>&, bounded_vector<int>&);
+template void TrackerTraits<11>::processNeighbours<CellSeed>(int, int, int, const bounded_vector<CellSeed>&, const bounded_vector<int>&, const bounded_vector<int>&, bounded_vector<TrackSeed<11>>&, bounded_vector<int>&, bounded_vector<int>&);
+template void TrackerTraits<11>::processNeighbours<TrackSeed<11>>(int, int, int, const bounded_vector<TrackSeed<11>>&, const bounded_vector<int>&, const bounded_vector<int>&, bounded_vector<TrackSeed<11>>&, bounded_vector<int>&, bounded_vector<int>&);
 #endif
 
 } // namespace o2::its
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
index f745d671419af..7f10419d63fea 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackingInterface.cxx
@@ -54,6 +54,12 @@ void ITSTrackingInterface::initialise()
   LOGP(info, "Initializing tracker in {} phase reconstruction with {} passes for tracking and {}/{} for vertexing", TrackingMode::toString(mMode), trackParams.size(), o2::its::VertexerParamConfig::Instance().nIterations, vertParams.size());
   mTracker->setParameters(trackParams);
   mVertexer->setParameters(vertParams);
+  TrackingParameters vertexTrackingParams;
+  mTimeFrame->initVertexingTopology(vertexTrackingParams);
+  if (!trackParams.empty()) {
+    mTimeFrame->initDefaultTrackingTopology(trackParams[0], NLayers);
+    mTimeFrame->initTrackerTopologies(gsl::span<const TrackingParameters>(trackParams.data(), trackParams.size()));
+  }
 
   if (mMode == TrackingMode::Cosmics) {
     mRunVertexer = false;
diff --git a/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt b/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
index 063583b4cfa1b..f8fce10b78602 100644
--- a/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
+++ b/Detectors/ITSMFT/ITS/tracking/test/CMakeLists.txt
@@ -20,3 +20,9 @@ o2_add_test(roflookuptables
             COMPONENT_NAME its-tracking
             LABELS "its;tracking"
             PUBLIC_LINK_LIBRARIES O2::ITStracking)
+
+o2_add_test(trackingtopology
+            SOURCES testTrackingTopology.cxx
+            COMPONENT_NAME its-tracking
+            LABELS "its;tracking"
+            PUBLIC_LINK_LIBRARIES O2::ITStracking)
diff --git a/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx b/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx
index dd98a75efca7c..9626e42efd547 100644
--- a/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/test/testROFLookupTables.cxx
@@ -559,6 +559,7 @@ BOOST_AUTO_TEST_CASE(rofvertex_basic)
   vertices.push_back(vert1);
   table.update(vertices.data(), vertices.size());
   const auto view = table.getView();
+  view.printAll();
 }
 
 BOOST_AUTO_TEST_CASE(rofvertex_init_with_vertices)
diff --git a/Detectors/ITSMFT/ITS/tracking/test/testTrackingTopology.cxx b/Detectors/ITSMFT/ITS/tracking/test/testTrackingTopology.cxx
new file mode 100644
index 0000000000000..4944d00b15fea
--- /dev/null
+++ b/Detectors/ITSMFT/ITS/tracking/test/testTrackingTopology.cxx
@@ -0,0 +1,119 @@
+// Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include <boost/test/tools/old/interface.hpp>
+#define BOOST_TEST_MODULE ITS TrackingTopology
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_DYN_LINK
+
+#include <boost/test/unit_test.hpp>
+#include "ITStracking/TrackingTopology.h"
+
+/// -------- Tests --------
+BOOST_AUTO_TEST_CASE(layermask_holes_and_length)
+{
+  using o2::its::LayerMask;
+
+  const LayerMask layer3Hole{0x77}; // layers 0,1,2,4,5,6
+  BOOST_CHECK_EQUAL(layer3Hole.count(), 6);
+  BOOST_CHECK_EQUAL(layer3Hole.length(), 7);
+  BOOST_CHECK_EQUAL(layer3Hole.holeMask().value(), 0x08);
+  BOOST_CHECK(layer3Hole.isAllowed(1, 0x08));
+  BOOST_CHECK(!layer3Hole.isAllowed(0, 0x08));
+
+  const LayerMask missingLeadingLayer0{0x7e}; // layers 1..6
+  BOOST_CHECK_EQUAL(missingLeadingLayer0.count(), 6);
+  BOOST_CHECK_EQUAL(missingLeadingLayer0.length(), 6);
+  BOOST_CHECK_EQUAL(missingLeadingLayer0.holeMask().value(), 0x00);
+
+  const LayerMask missingTrailingLayer6{0x3f}; // layers 0..5
+  BOOST_CHECK_EQUAL(missingTrailingLayer6.count(), 6);
+  BOOST_CHECK_EQUAL(missingTrailingLayer6.length(), 6);
+  BOOST_CHECK_EQUAL(missingTrailingLayer6.holeMask().value(), 0x00);
+}
+
+BOOST_AUTO_TEST_CASE(layermask_topological_length_counts_internal_holes)
+{
+  using o2::its::LayerMask;
+
+  BOOST_CHECK_GE(LayerMask{0x7f}.length(), 7); // 7 clusters
+  BOOST_CHECK_GE(LayerMask{0x77}.length(), 7); // 6 clusters + layer-3 hole
+  BOOST_CHECK_LT(LayerMask{0x7e}.length(), 7); // missing leading layer
+  BOOST_CHECK_LT(LayerMask{0x3f}.length(), 7); // missing trailing layer
+}
+
+BOOST_AUTO_TEST_CASE(trackingtopology_basic)
+{
+  o2::its::TrackingTopology<4> topo;
+  topo.init(4, 0, 0);
+  const auto view = topo.getView();
+  view.print();
+
+  BOOST_CHECK_EQUAL(view.nTransitions, 3);
+  for (int i{0}; i < 3; ++i) {
+    const auto& tra = view.getTransition(i);
+    BOOST_CHECK_EQUAL(tra.fromLayer, i);
+    BOOST_CHECK_EQUAL(tra.toLayer, i + 1);
+  }
+
+  BOOST_CHECK_EQUAL(view.nCells, 2);
+  for (int i{0}; i < 2; ++i) {
+    const auto& cell = view.getCell(i);
+    BOOST_CHECK_EQUAL(cell.firstTransition, i);
+    BOOST_CHECK_EQUAL(cell.secondTransition, i + 1);
+  }
+}
+
+BOOST_AUTO_TEST_CASE(trackingtopology_single_allowed_hole)
+{
+  o2::its::TrackingTopology<5> topo;
+  topo.init(5, 1, 1 << 2);
+  const auto view = topo.getView();
+  view.print();
+
+  BOOST_CHECK_EQUAL(view.nTransitions, 5);
+  BOOST_CHECK_EQUAL(view.nCells, 5);
+
+  bool hasHoleTransition = false;
+  for (int i{0}; i < view.nTransitions; ++i) {
+    const auto& transition = view.getTransition(i);
+    hasHoleTransition |= transition.fromLayer == 1 && transition.toLayer == 3;
+    BOOST_CHECK(o2::its::LayerMask::skipped(transition.fromLayer, transition.toLayer).isAllowedHoleMask(1, 1 << 2));
+  }
+  BOOST_CHECK(hasHoleTransition);
+
+  bool hasHoleCell = false;
+  for (int i{0}; i < view.nCells; ++i) {
+    const auto& cell = view.getCell(i);
+    hasHoleCell |= cell.hitLayerMask.value() == 0x0b; // layers 0,1,3
+    BOOST_CHECK(cell.hitLayerMask.isAllowed(1, 1 << 2));
+  }
+  BOOST_CHECK(hasHoleCell);
+}
+
+BOOST_AUTO_TEST_CASE(trackingtopology_rejects_wrong_hole_layer)
+{
+  o2::its::TrackingTopology<5> topo;
+  topo.init(5, 1, 1 << 2);
+  const auto view = topo.getView();
+  view.print();
+
+  for (int i{0}; i < view.nTransitions; ++i) {
+    const auto& transition = view.getTransition(i);
+    BOOST_CHECK(!(transition.fromLayer == 0 && transition.toLayer == 2));
+    BOOST_CHECK(!(transition.fromLayer == 2 && transition.toLayer == 4));
+  }
+
+  for (int i{0}; i < view.nCells; ++i) {
+    const auto& cell = view.getCell(i);
+    BOOST_CHECK(cell.hitLayerMask.holeMask().isSubsetOf(1 << 2));
+  }
+}

From 3108ae1cdc66c36a6cdaa2d7788b33fac4fe3579 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 15 May 2026 10:54:31 +0200
Subject: [PATCH 1735/1764] Fix trigger input alias for the raw-tf-dump
 workflow

---
 prodtests/full-system-test/dpl-workflow.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/prodtests/full-system-test/dpl-workflow.sh b/prodtests/full-system-test/dpl-workflow.sh
index 3619cc38a0c09..445cf7a5b5a02 100755
--- a/prodtests/full-system-test/dpl-workflow.sh
+++ b/prodtests/full-system-test/dpl-workflow.sh
@@ -565,7 +565,7 @@ if [[ $CTFINPUT == 0 && $DIGITINPUT == 0 ]]; then
      [[ -z ${PROXY_INSPEC} ]] && define_raw_inputs
      CONFIG_RAWTFDUMP="--dataspec \"${PROXY_INSPEC}\" --output-dir \"${RAWTF_DIR:-$CTF_DIR}\" --meta-output-dir \"${EPN2EOS_METAFILES_DIR}\" --max-dump-rate ${RAWTF_DUMPRATE:-0.1} "
      CONFIG_RAWTFDUMP+=" --min-file-size ${RAWTF_MINSIZE:-$CTF_MINSIZE} --max-tf-per-file ${RAWTF_MAX_PER_FILE:-$CTF_MAX_PER_FILE} --mute-warn-period ${RAWTF_MUTE_PERIOD:-200} --max-warn ${RAWTF_MAX_WARN:-5} "
-     [[ -n ${DPL_RAWTFDUMP_TRIGGER:-} ]] && CONFIG_RAWTFDUMP+=" --triggerspec \"${DPL_RAWTFDUMP_TRIGGER}\" "
+     [[ -n ${DPL_RAWTFDUMP_TRIGGER:-} ]] && CONFIG_RAWTFDUMP+=" --triggerspec \"DMPTRG:${DPL_RAWTFDUMP_TRIGGER}\" "
      add_W o2-raw-tf-dump-workflow "$CONFIG_RAWTFDUMP"
   fi
 

From 52b0ff0754be9d9725d3df7b8e4541d26f9d273b Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 15 May 2026 12:16:39 +0200
Subject: [PATCH 1736/1764] Configure TPCFLPCMVSpec output accorging to the
 triggerPerFlp flag

---
 .../include/TPCWorkflow/TPCFLPCMVSpec.h       | 22 ++++++++++---------
 Detectors/TPC/workflow/src/tpc-flp-cmv.cxx    |  6 +++--
 2 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
index bb7f9632c6308..d86356234a1c2 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFLPCMVSpec.h
@@ -37,14 +37,13 @@ namespace o2::tpc
 class TPCFLPCMVDevice : public o2::framework::Task
 {
  public:
-  TPCFLPCMVDevice(const int lane, const std::vector<uint32_t>& crus, const int nTFsBuffer)
-    : mLane{lane}, mCRUs{crus}, mNTFsBuffer{nTFsBuffer} {}
+  TPCFLPCMVDevice(const int lane, const std::vector<uint32_t>& crus, const bool triggerPerFlp, const int nTFsBuffer)
+    : mLane{lane}, mCRUs{crus}, mTriggerPerFLP{triggerPerFlp}, mNTFsBuffer{nTFsBuffer} {}
 
   void init(o2::framework::InitContext& ic) final
   {
     mDumpCMVs = ic.options().get<bool>("dump-cmvs-flp");
     mEnableTrigger = ic.options().get<bool>("trigger");
-    mTriggerPerFLP = ic.options().get<bool>("trigger-per-flp");
     mTriggerThresholdCMV = ic.options().get<float>("trigger-threshold-cmv");
     mTriggerThresholdMeanMax = ic.options().get<float>("trigger-threshold-cmvMeanMax");
     mTriggerThresholdMeanMin = ic.options().get<float>("trigger-threshold-cmvMeanMin");
@@ -200,7 +199,7 @@ class TPCFLPCMVDevice : public o2::framework::Task
   }
 };
 
-o2::framework::DataProcessorSpec getTPCFLPCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const int nTFsBuffer = 1)
+o2::framework::DataProcessorSpec getTPCFLPCMVSpec(const int ilane, const std::vector<uint32_t>& crus, const bool triggerPerFlp, const int nTFsBuffer = 1)
 {
   std::vector<o2::framework::OutputSpec> outputSpecs;
   std::vector<o2::framework::InputSpec> inputSpecs;
@@ -217,22 +216,25 @@ o2::framework::DataProcessorSpec getTPCFLPCMVSpec(const int ilane, const std::ve
     // Outputs to TPCDistributeCMVSpec
     outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVGroup(), subSpec}, o2::framework::Lifetime::Sporadic);
     outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVOrbitInfo(), subSpec}, o2::framework::Lifetime::Sporadic);
-  }
 
-  // Single per-FLP trigger output, subspec keyed on the first CRU
-  const header::DataHeader::SubSpecificationType trigSubSpec{crus.front() << 7};
-  outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVTrigger(), trigSubSpec}, o2::framework::Lifetime::Timeframe);
+    if (!triggerPerFlp) {
+      outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVTrigger(), subSpec}, o2::framework::Lifetime::Timeframe);
+    }
+  }
+  if (triggerPerFlp) { // Single per-FLP trigger output, subspec keyed on the first CRU
+    const header::DataHeader::SubSpecificationType trigSubSpec{crus.front() << 7};
+    outputSpecs.emplace_back(o2::framework::ConcreteDataMatcher{o2::header::gDataOriginTPC, TPCFLPCMVDevice::getDataDescriptionCMVTrigger(), trigSubSpec}, o2::framework::Lifetime::Timeframe);
+  }
 
   const auto id = fmt::format("tpc-flp-cmv-{:02}", ilane);
   return o2::framework::DataProcessorSpec{
     id.data(),
     inputSpecs,
     outputSpecs,
-    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<TPCFLPCMVDevice>(ilane, crus, nTFsBuffer)},
+    o2::framework::AlgorithmSpec{o2::framework::adaptFromTask<TPCFLPCMVDevice>(ilane, crus, triggerPerFlp, nTFsBuffer)},
     o2::framework::Options{
       {"dump-cmvs-flp", o2::framework::VariantType::Bool, false, {"Dump CMVs to file"}},
       {"trigger", o2::framework::VariantType::Bool, false, {"Enable CMV trigger evaluation"}},
-      {"trigger-per-flp", o2::framework::VariantType::Bool, false, {"Aggregate triggers of CRUs on FLP to a single trigger"}},
       {"trigger-threshold-cmv", o2::framework::VariantType::Float, -10.f, {"CMV threshold: sequence starts when value drops below this (ADC units)"}},
       {"trigger-threshold-cmvMeanMax", o2::framework::VariantType::Float, -40.f, {"Upper bound on trigger-sequence mean CMV value"}},
       {"trigger-threshold-cmvMeanMin", o2::framework::VariantType::Float, -80.f, {"Lower bound on trigger-sequence mean CMV value"}},
diff --git a/Detectors/TPC/workflow/src/tpc-flp-cmv.cxx b/Detectors/TPC/workflow/src/tpc-flp-cmv.cxx
index f41fe5b8fbd15..b7734c5d0b24f 100644
--- a/Detectors/TPC/workflow/src/tpc-flp-cmv.cxx
+++ b/Detectors/TPC/workflow/src/tpc-flp-cmv.cxx
@@ -32,6 +32,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
     {"time-lanes", VariantType::Int, 1, {"Number of parallel processing lanes (timeframes are split per device)"}},
     {"crus", VariantType::String, cruDefault.c_str(), {"List of CRUs, comma separated ranges, e.g. 0-3,7,9-15"}},
     {"n-TFs-buffer", VariantType::Int, 1, {"Buffer n-TFs before sending output"}},
+    {"trigger-per-flp", VariantType::Bool, false, {"Aggregate triggers of CRUs on FLP to a single trigger"}},
     {"configKeyValues", VariantType::String, "", {"Semicolon separated key=value strings"}}};
 
   std::swap(workflowOptions, options);
@@ -48,6 +49,7 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   const auto nLanes = std::min(static_cast<unsigned long>(config.options().get<int>("lanes")), nCRUs);
   const auto time_lanes = static_cast<unsigned int>(config.options().get<int>("time-lanes"));
   const auto crusPerLane = nCRUs / nLanes + ((nCRUs % nLanes) != 0);
+  const bool triggerPerFLP = config.options().get<bool>("trigger-per-flp");
   const int nTFsBuffer = config.options().get<int>("n-TFs-buffer");
 
   o2::conf::ConfigurableParam::updateFromFile(config.options().get<std::string>("configFile"));
@@ -65,8 +67,8 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
     }
     const auto last = std::min(tpcCRUs.end(), first + crusPerLane);
     const std::vector<uint32_t> rangeCRUs(first, last);
-    workflow.emplace_back(timePipeline(getTPCFLPCMVSpec(ilane, rangeCRUs, nTFsBuffer), time_lanes));
+    workflow.emplace_back(timePipeline(getTPCFLPCMVSpec(ilane, rangeCRUs, triggerPerFLP, nTFsBuffer), time_lanes));
   }
 
   return workflow;
-}
\ No newline at end of file
+}

From 3e65dc02af3ed1ed1a0be40b20854766817cd6b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Wed, 18 Feb 2026 19:11:28 +0100
Subject: [PATCH 1737/1764] BinningPolicy: Fix bug in getAllBinsCount

---
 Framework/Core/include/Framework/BinningPolicy.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Framework/Core/include/Framework/BinningPolicy.h b/Framework/Core/include/Framework/BinningPolicy.h
index 3e41302c920f8..f4ea6885192e4 100644
--- a/Framework/Core/include/Framework/BinningPolicy.h
+++ b/Framework/Core/include/Framework/BinningPolicy.h
@@ -188,7 +188,7 @@ struct BinningPolicyBase {
     if constexpr (N == 2) {
       return getXBinsCount() * getYBinsCount();
     }
-    if constexpr (N == 2) {
+    if constexpr (N == 3) {
       return getXBinsCount() * getYBinsCount() * getZBinsCount();
     }
     return -1;

From a0409929ccd01c66c23d08d1dd268025c10f133c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?V=C3=ADt=20Ku=C4=8Dera?=
 <26327373+vkucera@users.noreply.github.com>
Date: Fri, 24 Apr 2026 14:19:01 +0200
Subject: [PATCH 1738/1764] Update Clang-Tidy config file

---
 .clang-tidy | 43 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 2 deletions(-)

diff --git a/.clang-tidy b/.clang-tidy
index da768906bcc32..080c35ba31df3 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,3 +1,42 @@
+---
+Checks:
+  - -*
+  - modernize-avoid-bind
+  - modernize-deprecated-headers
+  - modernize-make-shared
+  - modernize-raw-string-literal
+  - modernize-redundant-void-arg
+  - modernize-replace-auto-ptr
+  - modernize-replace-random-shuffle
+  - modernize-shrink-to-fit
+  - modernize-unary-static-assert
+  - modernize-use-equals-default
+  - modernize-use-noexcept
+  - modernize-use-nullptr
+  - modernize-use-override
+  - modernize-use-transparent-functors
+  - modernize-use-uncaught-exceptions
+  - readability-braces-around-statements
+  - -clang-diagnostic-vla-cxx-extension
 CheckOptions:
-  - key: CheckPathRegex
-    value: '.*/O2/.*'
+  # Naming conventions
+  readability-identifier-naming.ClassCase: CamelCase
+  readability-identifier-naming.ClassMemberPrefix: m
+  readability-identifier-naming.ConceptCase: CamelCase
+  readability-identifier-naming.ConstexprVariableCase: CamelCase
+  readability-identifier-naming.EnumCase: CamelCase
+  readability-identifier-naming.EnumConstantCase: CamelCase
+  readability-identifier-naming.EnumConstantIgnoredRegexp: "^k?[A-Z][a-zA-Z0-9_]*$" # Allow "k" prefix and non-trailing underscores in PDG names.
+  readability-identifier-naming.FunctionCase: camelBack
+  readability-identifier-naming.MacroDefinitionCase: UPPER_CASE
+  readability-identifier-naming.MacroDefinitionIgnoredRegexp: "^[A-Z][A-Z0-9_]*_$" # Allow the trailing underscore in header guards.
+  readability-identifier-naming.MemberCase: camelBack
+  readability-identifier-naming.NamespaceCase: lower_case
+  readability-identifier-naming.ParameterCase: camelBack
+  readability-identifier-naming.StructCase: CamelCase
+  readability-identifier-naming.TemplateParameterCase: CamelCase
+  readability-identifier-naming.TypeAliasCase: CamelCase
+  readability-identifier-naming.TypedefCase: CamelCase
+  readability-identifier-naming.TypeTemplateParameterCase: CamelCase
+  readability-identifier-naming.VariableCase: camelBack
+...

From ebf41956da11035737a898b6e38da224b9547b30 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Fri, 15 May 2026 17:26:20 +0200
Subject: [PATCH 1739/1764] Disable ensureContinuousROF when calibration data
 is requested

By default avoid ROFs modifications in ensureContinuousROF when the --enable-calib-data is active:
calibration runs do not respect declared number of ROFs and inject bogus orbits.
There is still a possibility to enforce ensureContinuousROF with eventual rectifyDigits/Clusters
in case the calibration data is requested via --enforce-continuous-rof-with-calib
(beware that this may lead to a desynchronization between the calibration data container and
ROFs/digits).
Also, for backward compatibility, option --disable-rectify-continuous-rof will disable
the calling of rectifyDigits/Clusters after eventual ensureContinuousROF.
---
 .../include/ITSMFTWorkflow/STFDecoderSpec.h   |  2 +
 .../common/workflow/src/STFDecoderSpec.cxx    | 42 ++++++++++++++++---
 2 files changed, 39 insertions(+), 5 deletions(-)

diff --git a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
index 1739822d121cf..8c16759e16726 100644
--- a/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
+++ b/Detectors/ITSMFT/common/workflow/include/ITSMFTWorkflow/STFDecoderSpec.h
@@ -92,6 +92,8 @@ class STFDecoder : public Task
   bool mUseClusterDictionary = true;
   bool mVerifyDecoder = false;
   bool mDumpFrom1stPipeline = false;
+  bool mRunEnsureContinuousROF = true;
+  bool mDisableRectifyContinuousROF = false;
   int mDumpOnError = 0;
   int mNThreads = 1;
   int mVerbosity = 0;
diff --git a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
index cc7200a1120a6..79372160c6ade 100644
--- a/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
+++ b/Detectors/ITSMFT/common/workflow/src/STFDecoderSpec.cxx
@@ -63,6 +63,7 @@ STFDecoder<Mapping>::STFDecoder(const STFDecoderInp& inp, std::shared_ptr<o2::ba
 template <class Mapping>
 void STFDecoder<Mapping>::init(InitContext& ic)
 {
+  int lane = ic.services().get<const o2::framework::DeviceSpec>().inputTimesliceId;
   o2::base::GRPGeomHelper::instance().setRequest(mGGCCDBRequest);
   try {
     auto v0 = o2::utils::Str::tokenize(mInputSpec, ':');
@@ -137,6 +138,31 @@ void STFDecoder<Mapping>::init(InitContext& ic)
     LOG(error) << "non-std::exception was thrown in decoder configuration";
     throw;
   }
+  if (mDoCalibData) {
+    std::string warnMsg;
+    bool enforceEnsureContinuousROFinCalib = ic.options().get<bool>("enforce-continuous-rof-with-calib");
+    if (ic.options().get<bool>("enforce-continuous-rof-with-calib")) {
+      warnMsg = "Calibration data requested but the ensureContinuousROF is explicitly enforced!";
+    } else {
+      mRunEnsureContinuousROF = false;
+      warnMsg = "Calibration data requested, disabling ensureContinuousROF!";
+    }
+    if (lane == 0) {
+      LOGP(alarm, "{}", warnMsg);
+    } else {
+      LOGP(info, "{}", warnMsg);
+    }
+  }
+
+  mDisableRectifyContinuousROF = ic.options().get<bool>("disable-rectify-continuous-rof");
+  if (mDisableRectifyContinuousROF && mRunEnsureContinuousROF) {
+    std::string warnMsg = "Rectification of clusters/digits is explicitly disabled after the ensureContinuousROF!";
+    if (lane == 0) {
+      LOGP(alarm, "{}", warnMsg);
+    } else {
+      LOGP(info, "{}", warnMsg);
+    }
+  }
 
   if (mDoClusters) {
     mClusterer = std::make_unique<Clusterer>();
@@ -258,8 +284,8 @@ void STFDecoder<Mapping>::run(ProcessingContext& pc)
       }
     }
     if (mDoDigits) {
-      std::vector<o2::itsmft::ROFRecord> expDigRofVec(nROFsTF);
-      if (ensureContinuousROF(digROFVec, expDigRofVec, iLayer, nROFsTF, "digits")) {
+      std::vector<o2::itsmft::ROFRecord> expDigRofVec;
+      if (ensureContinuousROF(digROFVec, expDigRofVec, iLayer, nROFsTF, "digits") && !mDisableRectifyContinuousROF) {
         auto oldNDig = digVec.size();
         rectifyDigits(expDigRofVec, digVec);
         LOGP(warn, "Rectified {} digits out of original {} on layer {} following ensureContinuousROF", digVec.size(), oldNDig, iLayer);
@@ -271,12 +297,12 @@ void STFDecoder<Mapping>::run(ProcessingContext& pc)
         pc.outputs().snapshot(Output{orig, "GBTCALIB", iLayer}, calVec);
         mEstNCalib[iLayer] = std::max(mEstNCalib[iLayer], size_t(calVec.size() * 1.2));
       }
-      LOG(debug) << mSelfName << " Decoded " << digVec.size() << " Digits in " << digROFVec.size() << " ROFs" << ((mDoStaggering) ? std::format(" on layer {}", iLayer) : "");
+      LOG(debug) << mSelfName << " Decoded " << digVec.size() << " Digits in " << expDigRofVec.size() << " ROFs" << ((mDoStaggering) ? std::format(" on layer {}", iLayer) : "");
     }
 
     if (mDoClusters) { // we are not obliged to create vectors which are not requested, but other devices might not know the options of this one
-      std::vector<o2::itsmft::ROFRecord> expClusRofVec(nROFsTF);
-      if (ensureContinuousROF(clusROFVec, expClusRofVec, iLayer, nROFsTF, "clusters")) {
+      std::vector<o2::itsmft::ROFRecord> expClusRofVec;
+      if (ensureContinuousROF(clusROFVec, expClusRofVec, iLayer, nROFsTF, "clusters") && !mDisableRectifyContinuousROF) {
         auto oldNClus = clusCompVec.size(), oldNPatt = clusPattVec.size();
         rectifyClusters(expClusRofVec, clusCompVec, clusPattVec);
         LOGP(warn, "Rectified {} clusters and {} patterns out of original {} and {} on layer {} following ensureContinuousROF", clusCompVec.size(), clusPattVec.size(), oldNClus, oldNPatt, iLayer);
@@ -426,6 +452,10 @@ void STFDecoder<Mapping>::reset()
 template <class Mapping>
 bool STFDecoder<Mapping>::ensureContinuousROF(const std::vector<ROFRecord>& rofVec, std::vector<ROFRecord>& expROFVec, int lr, int nROFsTF, const char* name)
 {
+  if (!mRunEnsureContinuousROF) {
+    expROFVec = rofVec;
+    return false;
+  }
   const auto& par = AlpideParam::Instance();
   // ensure that the rof output is continuous
   // we will preserve the digits/clusters as they are but the stray ROFs will be removed (leaving their clusters/digits unaddressed).
@@ -621,6 +651,8 @@ DataProcessorSpec getSTFDecoderSpec(const STFDecoderInp& inp)
       {"unmute-extra-lanes", VariantType::Bool, false, {"allow extra lanes to be as verbose as 1st one"}},
       {"allow-empty-rofs", VariantType::Bool, false, {"record ROFs w/o any hit"}},
       {"ignore-noise-map", VariantType::Bool, false, {"do not mask pixels flagged in the noise map"}},
+      {"enforce-continuous-rof-with-calib", VariantType::Bool, false, {"enforce ensureContinuousROF call even when calibration data is requested (not recommended)"}},
+      {"disable-rectify-continuous-rof", VariantType::Bool, false, {"do not rectify clusters and digits after ensureContinuousROF (not recommended)"}},
       {"accept-rof-rampup-data", VariantType::Bool, false, {"do not discard data during ROF ramp up"}},
       {"rof-length-error-freq", VariantType::Float, 60.f, {"do not report ROF length error more frequently than this value, disable if negative"}},
       {"ignore-cluster-dictionary", VariantType::Bool, false, {"do not use cluster dictionary, always store explicit patterns"}}}};

From 2487a80694a80d39ed1beb4c149911cf99fa474f Mon Sep 17 00:00:00 2001
From: shahor02 <shahor02@users.noreply.github.com>
Date: Sun, 17 May 2026 21:19:36 +0200
Subject: [PATCH 1740/1764] Repair raw tf part counters / headers (#15405)

* Repair raw tf part counters / headers

Can be disabled by --ignore-repair-headers.

* By default do not store FLP/DISTSUBTIMEFRAME in the rawTF

* Fix payloadIndex, ignore writing DistSTF by default, extra verbose output

* Ignore stored DistSTF by default
---
 .../include/TFReaderDD/SubTimeFrameFile.h     | 18 ++++-
 .../TFReaderDD/SubTimeFrameFileReader.h       | 11 ++-
 .../Raw/TFReaderDD/src/RawTFDumpSpec.cxx      | 21 +++++-
 .../TFReaderDD/src/SubTimeFrameFileReader.cxx | 73 ++++++++++++++++---
 Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx | 13 +++-
 Detectors/Raw/TFReaderDD/src/TFReaderSpec.h   |  2 +
 .../Raw/TFReaderDD/src/tf-reader-workflow.cxx |  2 +-
 7 files changed, 117 insertions(+), 23 deletions(-)

diff --git a/Detectors/Raw/TFReaderDD/include/TFReaderDD/SubTimeFrameFile.h b/Detectors/Raw/TFReaderDD/include/TFReaderDD/SubTimeFrameFile.h
index 340027642b74c..eeabf8e8d4117 100644
--- a/Detectors/Raw/TFReaderDD/include/TFReaderDD/SubTimeFrameFile.h
+++ b/Detectors/Raw/TFReaderDD/include/TFReaderDD/SubTimeFrameFile.h
@@ -21,6 +21,8 @@
 #include <vector>
 
 #include <Headers/DataHeader.h>
+#include "Framework/DataSpecUtils.h"
+#include "Framework/OutputSpec.h"
 #include "Framework/Logger.h"
 
 namespace o2
@@ -151,13 +153,13 @@ struct SubTimeFrameFileMeta {
   ///
   std::uint64_t mWriteTimeMs;
 
-  auto getTimePoint()
+  auto getTimePoint() const
   {
     using namespace std::chrono;
     return time_point<system_clock, milliseconds>{milliseconds{mWriteTimeMs}};
   }
 
-  std::string getTimeString()
+  std::string getTimeString() const
   {
     using namespace std::chrono;
     std::time_t lTime = system_clock::to_time_t(getTimePoint());
@@ -167,6 +169,11 @@ struct SubTimeFrameFileMeta {
     return lTimeStream.str();
   }
 
+  const std::string info() const
+  {
+    return fmt::format("Size in file: {} Time: {} Version: {}", mStfSizeInFile, getTimeString(), mStfFileVersion);
+  }
+
   SubTimeFrameFileMeta(const std::uint64_t pStfSize)
     : SubTimeFrameFileMeta()
   {
@@ -220,6 +227,11 @@ struct SubTimeFrameFileDataIndex {
       static_assert(sizeof(DataIndexElem) == 48,
                     "DataIndexElem changed -> Binary compatibility is lost!");
     }
+
+    const std::string info() const
+    {
+      return fmt::format("DH: {} Cnt:{} Size:{} Offset:{}", o2::framework::DataSpecUtils::describe(o2::framework::OutputSpec{mDataOrigin, mDataDescription, mSubSpecification}), mDataBlockCnt, mSize, mOffset);
+    }
   };
 
   SubTimeFrameFileDataIndex() = default;
@@ -240,6 +252,8 @@ struct SubTimeFrameFileDataIndex {
     return sizeof(o2::header::DataHeader) + (sizeof(DataIndexElem) * mDataIndex.size());
   }
 
+  const std::vector<DataIndexElem>& getDataIndex() const { return mDataIndex; }
+
   friend std::ostream& operator<<(std::ostream& pStream, const SubTimeFrameFileDataIndex& pIndex);
 
  private:
diff --git a/Detectors/Raw/TFReaderDD/include/TFReaderDD/SubTimeFrameFileReader.h b/Detectors/Raw/TFReaderDD/include/TFReaderDD/SubTimeFrameFileReader.h
index 3b926e0a79206..2b7d2b7ab8e74 100644
--- a/Detectors/Raw/TFReaderDD/include/TFReaderDD/SubTimeFrameFileReader.h
+++ b/Detectors/Raw/TFReaderDD/include/TFReaderDD/SubTimeFrameFileReader.h
@@ -46,11 +46,11 @@ class SubTimeFrameFileReader
  public:
 
   SubTimeFrameFileReader() = delete;
-  SubTimeFrameFileReader(const std::string& pFileName, o2::detectors::DetID::mask_t detMask);
+  SubTimeFrameFileReader(const std::string& pFileName, o2::detectors::DetID::mask_t detMask, int verb, bool sup0xccdb, bool repaireHeaders, bool rejectDistSTF);
   ~SubTimeFrameFileReader();
 
   /// Read a single TF from the file
-  std::unique_ptr<MessagesPerRoute> read(fair::mq::Device* device, const std::vector<o2f::OutputRoute>& outputRoutes, const std::string& rawChannel, size_t slice, bool sup0xccdb, int verbosity);
+  std::unique_ptr<MessagesPerRoute> read(fair::mq::Device* device, const std::vector<o2f::OutputRoute>& outputRoutes, const std::string& rawChannel, size_t slice);
 
   /// Tell the current position of the file
   inline std::uint64_t position() const { return mFileMapOffset; }
@@ -76,6 +76,13 @@ class SubTimeFrameFileReader
   std::uint64_t mFileMapOffset = 0;
   std::uint64_t mFileSize = 0;
 
+  int mVerbosity = 0;
+  bool mSup0xccdb = true;
+  bool mRepaireHeaders = true;
+  bool mRejectDistSTF = true;
+
+  const std::string describeHeader(const o2::header::DataHeader& hd, bool full = false) const;
+
   // helper to make sure written chunks are buffered, only allow pointers
   template <typename pointer,
             typename = std::enable_if_t<std::is_pointer<pointer>::value>>
diff --git a/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx b/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
index 64c39fa7ef75a..03bd26ae0deb9 100644
--- a/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
+++ b/Detectors/Raw/TFReaderDD/src/RawTFDumpSpec.cxx
@@ -97,6 +97,7 @@ class RawTFDump : public Task
   bool mCreateRunEnvDir = true;
   bool mAcceptCurrentTF = false;
   bool mRejectDEADBEEF = false;
+  bool mRejectDistSTF = true;
   int mVerbose = 0;
   std::vector<uint32_t> mTFOrbits{}; // 1st orbits of TF accumulated in current file
   o2::framework::DataTakingContext mDataTakingContext{};
@@ -185,6 +186,7 @@ void RawTFDump::init(InitContext& ic)
     mWriteTF = false;
     mStoreMetaFile = false;
   }
+  mRejectDistSTF = !ic.options().get<bool>("include-dist-stf");
   mRejectDEADBEEF = !ic.options().get<bool>("include-deadbeef");
   mCreateRunEnvDir = !ic.options().get<bool>("ignore-partition-run-dir");
   mMinFileSize = ic.options().get<int64_t>("min-file-size");
@@ -253,6 +255,7 @@ void RawTFDump::run(ProcessingContext& pc)
     try {
       size_t lTFSizeInFile = getTFSizeInFile();
       SubTimeFrameFileMeta lTFFileMeta(lTFSizeInFile);
+      lTFFileMeta.mWriteTimeMs = mTimingInfo.creation;
 
       mFile << lTFFileMeta;  // Write DataHeader + SubTimeFrameFileMeta
       mFile << mTFDataIndex; // Write DataHeader + SubTimeFrameFileDataIndex
@@ -263,6 +266,10 @@ void RawTFDump::run(ProcessingContext& pc)
           const auto& dataPtr = mTFData[lEntry + part];
           DataHeader hdToWrite = *reinterpret_cast<const DataHeader*>(dataPtr.first); // make a local DataHeader copy to clear flagsNextHeader bit
           hdToWrite.flagsNextHeader = 0;
+          hdToWrite.splitPayloadIndex = part;
+          if (mVerbose > 2) {
+            LOGP(info, "Writing part:{}/{} of {} | TFCounter:{} part{}/{}", part, lCnt, DataSpecUtils::describe(OutputSpec{hdToWrite.dataOrigin, hdToWrite.dataDescription, hdToWrite.subSpecification}), hdToWrite.firstTForbit, hdToWrite.splitPayloadIndex, hdToWrite.splitPayloadParts);
+          }
           buffered_write(reinterpret_cast<const char*>(&hdToWrite), sizeof(DataHeader));
           buffered_write(dataPtr.second, hdToWrite.payloadSize);
         }
@@ -517,7 +524,11 @@ void RawTFDump::prepareTFForWriting(ProcessingContext& pc)
       LOGP(error, "Failed to extract header");
       continue;
     }
-    if (dh->subSpecification == 0xdeadbeef && mRejectDEADBEEF) {
+    if ((dh->subSpecification == 0xdeadbeef && mRejectDEADBEEF) ||
+        (dh->dataOrigin == o2::header::gDataOriginFLP && dh->dataDescription == o2::header::gDataDescriptionDISTSTF && mRejectDistSTF)) {
+      if (mVerbose > 2) {
+        LOGP(info, "Rejecting {}", DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}));
+      }
       continue;
     }
     const auto lHdrDataSize = sizeof(DataHeader) + dh->payloadSize;
@@ -531,9 +542,10 @@ void RawTFDump::prepareTFForWriting(ProcessingContext& pc)
     lCnt++;
     mTFData.push_back({ref.header, ref.payload});
     if (mVerbose > 2) {
-      LOGP(info, "{}, part: {} of {}, payload {}, 1stTFOrbit: {} TF: {}",
+      const auto* dph = DataRefUtils::getHeader<DataProcessingHeader*>(ref);
+      LOGP(info, "{}, part: {} of {}, payload {}, 1stTFOrbit: {} TF: {}, creation: {} | counter:{} size:{} entry:{}",
            DataSpecUtils::describe(OutputSpec{dh->dataOrigin, dh->dataDescription, dh->subSpecification}),
-           dh->splitPayloadIndex, dh->splitPayloadParts, dh->payloadSize, dh->firstTForbit, dh->tfCounter);
+           dh->splitPayloadIndex, dh->splitPayloadParts, dh->payloadSize, dh->firstTForbit, dh->tfCounter, dph ? dph->creation : -1UL, lCnt, lSize, lEntry);
     }
   }
 
@@ -548,7 +560,7 @@ void RawTFDump::prepareTFForWriting(ProcessingContext& pc)
 
       OutputSpec spec{eq.mDataOrigin, eq.mDataDescription, eq.mSubSpecification};
       if (mVerbose > 1) {
-        LOGP(info, "{} : {} parts of size {} | offset: {}", DataSpecUtils::describe(spec), lCnt, lSize, lCurrOff);
+        LOGP(info, "{} : {} parts of size {} entry {}| offset: {}", DataSpecUtils::describe(spec), lCnt, lSize, lEntry, lCurrOff);
       }
       mTFDataIndex.AddStfElement(eq, lCnt, lCurrOff, lSize);
       lCurrOff += lSize;
@@ -577,6 +589,7 @@ DataProcessorSpec getRawTFDumpSpec(const std::string& inpconfig, const std::stri
     AlgorithmSpec{adaptFromTask<RawTFDump>(trigger)},
     Options{
       {"include-deadbeef", VariantType::Bool, false, {"Include DPL-generated 0xdeadbeef subspecs for missing data"}},
+      {"include-dist-stf", VariantType::Bool, false, {"Include FLP/DISTSUBTIMEFRAME input"}},
       {"exclude-trigger-specs", VariantType::String, "", {"Ignore trigger seen in these inputs of triggerspec"}},
       {"max-dump-rate", VariantType::Float, 0.f, {"%-age of TFs to dump. W/o external trigger: random(>0) or periodic(<0) rejection, with: max limit"}},
       {"rate-est-conf-limit", VariantType::Float, 0.05f, {"quantile for the lowest rate estimate confidence limit"}},
diff --git a/Detectors/Raw/TFReaderDD/src/SubTimeFrameFileReader.cxx b/Detectors/Raw/TFReaderDD/src/SubTimeFrameFileReader.cxx
index 5f862dffe512f..c8bc6ff374ead 100644
--- a/Detectors/Raw/TFReaderDD/src/SubTimeFrameFileReader.cxx
+++ b/Detectors/Raw/TFReaderDD/src/SubTimeFrameFileReader.cxx
@@ -45,8 +45,8 @@ namespace o2f = o2::framework;
 /// SubTimeFrameFileReader
 ////////////////////////////////////////////////////////////////////////////////
 
-SubTimeFrameFileReader::SubTimeFrameFileReader(const std::string& pFileName, o2::detectors::DetID::mask_t detMask)
-  : mFileName(pFileName)
+SubTimeFrameFileReader::SubTimeFrameFileReader(const std::string& pFileName, o2::detectors::DetID::mask_t detMask, int verb, bool sup0xccdb, bool repaireHeaders, bool rejectDistSTF)
+  : mFileName(pFileName), mVerbosity(verb), mSup0xccdb(sup0xccdb), mRepaireHeaders(repaireHeaders), mRejectDistSTF(rejectDistSTF)
 {
   mFileMap.open(mFileName);
   if (!mFileMap.is_open()) {
@@ -178,13 +178,21 @@ Stack SubTimeFrameFileReader::getHeaderStack(std::size_t& pOrigsize)
   return Stack(lStackMem);
 }
 
+const std::string SubTimeFrameFileReader::describeHeader(const o2::header::DataHeader& hd, bool full) const
+{
+  std::string res = fmt::format("{}", o2f::DataSpecUtils::describe(o2::framework::OutputSpec{hd.dataOrigin, hd.dataDescription, hd.subSpecification}));
+  if (full) {
+    res += fmt::format(" part:{}/{} sz:{} TF:{} Orb:{} Run:{}", hd.splitPayloadIndex, hd.splitPayloadParts, hd.payloadSize, hd.tfCounter, hd.firstTForbit, hd.runNumber);
+  }
+  return res;
+}
+
 std::uint32_t sRunNumber = 0;                     // TODO: add id to files metadata
 std::uint32_t sFirstTForbit = 0;                  // TODO: add id to files metadata
 std::uint64_t sCreationTime = 0;
 std::mutex stfMtx;
 
-std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device* device, const std::vector<o2f::OutputRoute>& outputRoutes,
-                                                               const std::string& rawChannel, size_t slice, bool sup0xccdb, int verbosity)
+std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device* device, const std::vector<o2f::OutputRoute>& outputRoutes, const std::string& rawChannel, size_t slice)
 {
   std::unique_ptr<MessagesPerRoute> messagesPerRoute = std::make_unique<MessagesPerRoute>();
   auto& msgMap = *messagesPerRoute.get();
@@ -252,10 +260,15 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
     return nullptr;
   }
   lStfMetaDataHdr = o2::header::DataHeader::Get(lMetaHdrStack.first());
-  LOGP(debug, "read filemeta, pos = {}, size = {}", position(), sizeof(SubTimeFrameFileMeta));
+  if (mVerbosity > 0) {
+    LOGP(info, "read filemeta, pos = {}, size = {}", position(), sizeof(SubTimeFrameFileMeta));
+  }
   if (!read_advance(&lStfFileMeta, sizeof(SubTimeFrameFileMeta))) {
     return nullptr;
   }
+  if (mVerbosity > 0) {
+    LOGP(info, "TFMeta : {}", lStfFileMeta.info());
+  }
   if (lStfFileMeta.mWriteTimeMs == 0 && creationFallBack != 0) {
     if (!creation0Notified) {
       creation0Notified = true;
@@ -319,6 +332,7 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
 
   std::int64_t lLeftToRead = lStfDataSize;
   STFHeader stfHeader{tfID, -1u, -1u};
+  DataHeader prevHeader;
   // read <hdrStack + data> pairs
   while (lLeftToRead > 0) {
     // allocate and read the Headers
@@ -335,6 +349,25 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
       return nullptr;
     }
     DataHeader locDataHeader(*lDataHeader);
+
+    if (mRepaireHeaders) {
+      if (locDataHeader == prevHeader) {
+        if (prevHeader.tfCounter == locDataHeader.tfCounter && (prevHeader.splitPayloadIndex + 1) != locDataHeader.splitPayloadIndex) {
+          if (mVerbosity > 3) {
+            LOGP(warn, "Repairing wrong part index for {} to {}", describeHeader(locDataHeader, true), (prevHeader.splitPayloadIndex + 1) % prevHeader.splitPayloadParts);
+          }
+          locDataHeader.splitPayloadIndex = (++prevHeader.splitPayloadIndex) % prevHeader.splitPayloadParts;
+        }
+      } else { // new header
+        if (locDataHeader.splitPayloadIndex != 0) {
+          if (mVerbosity > 2) {
+            LOGP(warn, "Repairing wrong part index for new {} to {}", describeHeader(locDataHeader, true), (prevHeader.splitPayloadIndex + 1) % prevHeader.splitPayloadParts);
+          }
+          locDataHeader.splitPayloadIndex = 0;
+        }
+      }
+      prevHeader = locDataHeader;
+    }
     // sanity check
     if (int(locDataHeader.firstTForbit) == -1) {
       if (!negativeOrbitNotified) {
@@ -350,6 +383,18 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
       }
       locDataHeader.runNumber = runNumberFallBack;
     }
+    const std::uint64_t lDataSize = locDataHeader.payloadSize;
+
+    if (locDataHeader.dataOrigin == o2::header::gDataOriginFLP && locDataHeader.dataDescription == o2::header::gDataDescriptionDISTSTF && mRejectDistSTF) {
+      if (mVerbosity > 0) {
+        LOGP(warn, "Ignoring stored {}", describeHeader(locDataHeader));
+      }
+      if (!ignore_nbytes(lDataSize)) {
+        return nullptr;
+      }
+      lLeftToRead -= (lDataHeaderStackSize + lDataSize); // update the counter
+      continue;
+    }
     o2::header::Stack headerStack{locDataHeader, o2f::DataProcessingHeader{tfID, 1, lStfFileMeta.mWriteTimeMs}};
     if (stfHeader.runNumber == -1) {
       stfHeader.id = locDataHeader.tfCounter;
@@ -359,8 +404,6 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
       sRunNumber = stfHeader.runNumber;
       sFirstTForbit = stfHeader.firstOrbit;
     }
-
-    const std::uint64_t lDataSize = locDataHeader.payloadSize;
     // do we accept these data?
     auto detOrigStatus = mDetOrigMap.find(locDataHeader.dataOrigin);
     if (detOrigStatus != mDetOrigMap.end() && !detOrigStatus->second) { // this is a detector data and we don't want to read it
@@ -403,10 +446,10 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
     if (!read_advance(lDataMsg->GetData(), lDataSize)) {
       return nullptr;
     }
-    if (verbosity > 0) {
-      if (verbosity > 1 || locDataHeader.splitPayloadIndex == 0) {
+    if (mVerbosity > 0) {
+      if (mVerbosity > 1 || locDataHeader.splitPayloadIndex == 0) {
         printStack(headerStack);
-        if (o2::raw::RDHUtils::checkRDH(lDataMsg->GetData()) && verbosity > 2) {
+        if (o2::raw::RDHUtils::checkRDH(lDataMsg->GetData()) && mVerbosity > 2) {
           o2::raw::RDHUtils::printRDH(lDataMsg->GetData());
         }
       }
@@ -414,6 +457,9 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
 #ifdef _RUN_TIMING_MEASUREMENT_
     addPartSW.Start(false);
 #endif
+    if (mVerbosity > 2) {
+      LOGP(info, "addPart {} to {} | HdrSize:{} DataSize:{}", describeHeader(locDataHeader, true), fmqChannel, lHdrStackMsg->GetSize(), lDataMsg->GetSize());
+    }
     addPart(std::move(lHdrStackMsg), std::move(lDataMsg), fmqChannel);
 #ifdef _RUN_TIMING_MEASUREMENT_
     addPartSW.Stop();
@@ -435,7 +481,7 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
   }
 
   unsigned stfSS[2] = {0, 0xccdb};
-  for (int iss = 0; iss < (sup0xccdb ? 1 : 2); iss++) {
+  for (int iss = 0; iss < (mSup0xccdb ? 1 : 2); iss++) {
     o2::header::DataHeader stfDistDataHeader(o2::header::gDataDescriptionDISTSTF, o2::header::gDataOriginFLP, stfSS[iss], sizeof(STFHeader), 0, 1);
     stfDistDataHeader.payloadSerializationMethod = o2::header::gSerializationMethodNone;
     stfDistDataHeader.firstTForbit = stfHeader.firstOrbit;
@@ -445,7 +491,7 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
     if (!fmqChannel.empty()) { // no output channel
       auto fmqFactory = device->GetChannel(fmqChannel, 0).Transport();
       o2::header::Stack headerStackSTF{stfDistDataHeader, o2f::DataProcessingHeader{tfID, 1, lStfFileMeta.mWriteTimeMs}};
-      if (verbosity > 0) {
+      if (mVerbosity > 0) {
         printStack(headerStackSTF);
       }
       auto hdMessageSTF = fmqFactory->CreateMessage(headerStackSTF.size(), fair::mq::Alignment{64});
@@ -455,6 +501,9 @@ std::unique_ptr<MessagesPerRoute> SubTimeFrameFileReader::read(fair::mq::Device*
 #ifdef _RUN_TIMING_MEASUREMENT_
       addPartSW.Start(false);
 #endif
+      if (mVerbosity > 2) {
+        LOGP(info, "addPart forced {} to {} | HdrSize:{} DataSize:{}", describeHeader(stfDistDataHeader, true), fmqChannel, hdMessageSTF->GetSize(), plMessageSTF->GetSize());
+      }
       addPart(std::move(hdMessageSTF), std::move(plMessageSTF), fmqChannel);
 #ifdef _RUN_TIMING_MEASUREMENT_
       addPartSW.Stop();
diff --git a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
index 919e76083f595..d0de5fb893e3d 100644
--- a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
+++ b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.cxx
@@ -118,6 +118,9 @@ void TFReaderSpec::init(o2f::InitContext& ic)
   mInput.maxTFsPerFile = mInput.maxTFsPerFile > 0 ? mInput.maxTFsPerFile : 0x7fffffff;
   mInput.maxTFCache = std::max(1, ic.options().get<int>("max-cached-tf"));
   mInput.maxFileCache = std::max(1, ic.options().get<int>("max-cached-files"));
+  mInput.repairHeaders = !ic.options().get<bool>("ignore-repair-headers");
+  mInput.rejectDistSTF = !ic.options().get<bool>("read-dist-stf");
+
   if (!mInput.fileRunTimeSpans.empty()) {
     loadRunTimeSpans(mInput.fileRunTimeSpans);
   }
@@ -263,7 +266,11 @@ void TFReaderSpec::run(o2f::ProcessingContext& ctx)
       setTimingInfo(*tfPtr.get());
       size_t nparts = 0, dataSize = 0;
       if (mInput.sendDummyForMissing) {
+        int cntAck = 0;
         for (auto& msgIt : *tfPtr.get()) { // complete with empty output for the specs which were requested but were not seen in the data
+          if (mInput.verbosity > 0) {
+            LOGP(info, "acknowledgeOutput {}", cntAck++);
+          }
           acknowledgeOutput(*msgIt.second.get(), true);
         }
         addMissingParts(*tfPtr.get());
@@ -409,7 +416,7 @@ void TFReaderSpec::TFBuilder()
     }
 
     LOG(info) << "Processing file " << tfFileName;
-    SubTimeFrameFileReader reader(tfFileName, mInput.detMask);
+    SubTimeFrameFileReader reader(tfFileName, mInput.detMask, mInput.verbosity, mInput.sup0xccdb, mInput.repairHeaders, mInput.rejectDistSTF);
     size_t locID = 0;
     // try
     {
@@ -421,7 +428,7 @@ void TFReaderSpec::TFBuilder()
           std::this_thread::sleep_for(sleepTime);
           continue;
         }
-        auto tf = reader.read(mDevice, mOutputRoutes, mInput.rawChannelConfig, mAccTFCounter, mInput.sup0xccdb, mInput.verbosity);
+        auto tf = reader.read(mDevice, mOutputRoutes, mInput.rawChannelConfig, mAccTFCounter);
         bool acceptTF = true;
         if (tf) {
           if (mRunTimeRanges.size()) {
@@ -675,6 +682,8 @@ o2f::DataProcessorSpec o2::rawdd::getTFReaderSpec(o2::rawdd::TFReaderInp& rinp)
   }
   spec.options.emplace_back(o2f::ConfigParamSpec{"select-tf-ids", o2f::VariantType::String, "", {"comma-separated list TF IDs to inject (from cumulative counter of TFs seen)"}});
   spec.options.emplace_back(o2f::ConfigParamSpec{"fetch-failure-threshold", o2f::VariantType::Float, 0.f, {"Fatil if too many failures( >0: fraction, <0: abs number, 0: no threshold)"}});
+  spec.options.emplace_back(o2f::ConfigParamSpec{"ignore-repair-headers", o2f::VariantType::Bool, false, {"do not check/repair headers"}});
+  spec.options.emplace_back(o2f::ConfigParamSpec{"read-dist-stf", o2f::VariantType::Bool, false, {"do not ignore stored FLP/DISTSUBTIMEFRAME (will clash with injected one)"}});
   spec.options.emplace_back(o2f::ConfigParamSpec{"max-tf", o2f::VariantType::Int, -1, {"max TF ID to process (<= 0 : infinite)"}});
   spec.options.emplace_back(o2f::ConfigParamSpec{"max-tf-per-file", o2f::VariantType::Int, -1, {"max TFs to process per raw-tf file (<= 0 : infinite)"}});
   spec.options.emplace_back(o2f::ConfigParamSpec{"max-cached-tf", o2f::VariantType::Int, 3, {"max TFs to cache in memory"}});
diff --git a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
index 2c1c62ecbb414..6ecce0d032c06 100644
--- a/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
+++ b/Detectors/Raw/TFReaderDD/src/TFReaderSpec.h
@@ -49,6 +49,8 @@ struct TFReaderInp {
   bool sendDummyForMissing = true;
   bool sup0xccdb = false;
   bool invertIRFramesSelection = false;
+  bool repairHeaders = true;
+  bool rejectDistSTF = true;
   std::vector<o2::header::DataHeader> hdVec;
   std::vector<int> tfIDs{};
 };
diff --git a/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx b/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
index b424353531de7..a29b4dadfdb25 100644
--- a/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
+++ b/Detectors/Raw/TFReaderDD/src/tf-reader-workflow.cxx
@@ -34,7 +34,7 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   options.push_back(ConfigParamSpec{"copy-dir", VariantType::String, "/tmp/", {"copy base directory for remote files"}});
   options.push_back(ConfigParamSpec{"tf-file-regex", VariantType::String, ".+\\.tf$", {"regex string to identify TF files"}});
   options.push_back(ConfigParamSpec{"remote-regex", VariantType::String, "^(alien://|)/alice/data/.+", {"regex string to identify remote files"}}); // Use "^/eos/aliceo2/.+" for direct EOS access
-  options.push_back(ConfigParamSpec{"tf-reader-verbosity", VariantType::Int, 0, {"verbosity level (1 or 2: check RDH, print DH/DPH for 1st or all slices, >2 print RDH)"}});
+  options.push_back(ConfigParamSpec{"tf-reader-verbosity", VariantType::Int, 0, {"verbosity level (1 or 2: check RDH, print DH/DPH for 1st or all slices, >2 print RDH), report repairs"}});
   options.push_back(ConfigParamSpec{"raw-channel-config", VariantType::String, "", {"optional raw FMQ channel for non-DPL output"}});
   options.push_back(ConfigParamSpec{"send-diststf-0xccdb", VariantType::Bool, false, {"send explicit FLP/DISTSUBTIMEFRAME/0xccdb output"}});
   options.push_back(ConfigParamSpec{"disable-dummy-output", VariantType::Bool, false, {"Disable sending empty output if corresponding data is not found in the data"}});

From 231abca7cb99fb989328cf4ee782bc104dbaa7ec Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 11 May 2026 23:18:56 +0200
Subject: [PATCH 1741/1764] DPL: auto register CCDB path options

ConfigurableCCDBPath only needed if you want to override the
value directly.
---
 Framework/Core/include/Framework/AnalysisTask.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/Framework/Core/include/Framework/AnalysisTask.h b/Framework/Core/include/Framework/AnalysisTask.h
index fbd523c7b0c37..1b25727874749 100644
--- a/Framework/Core/include/Framework/AnalysisTask.h
+++ b/Framework/Core/include/Framework/AnalysisTask.h
@@ -16,6 +16,7 @@
 #include "Framework/AlgorithmSpec.h"
 #include "Framework/CallbackService.h"
 #include "Framework/ConfigContext.h"
+#include "Framework/ConfigParamsHelper.h"
 #include "Framework/ControlService.h"
 #include "Framework/DataProcessorSpec.h"
 #include "Framework/Expressions.h"
@@ -557,6 +558,17 @@ DataProcessorSpec adaptAnalysisTask(ConfigContext const& ctx, Args&&... args)
     LOG(warn) << "Task " << name_str << " has no inputs";
   }
 
+  // Auto-register default ccdb: path options from subscribed timestamped-table inputs.
+  // This allows tasks to accept --ccdb:fXxx overrides without requiring an explicit
+  // ConfigurableCCDBPath<> member for every column in the subscribed table.
+  for (auto& input : inputs) {
+    for (auto& meta : input.metadata) {
+      if (meta.name.starts_with("ccdb:") && meta.name != "ccdb:") {
+        ConfigParamsHelper::addOptionIfMissing(options, meta);
+      }
+    }
+  }
+
   homogeneous_apply_refs_sized<numElements>([&outputs, &hash](auto& element) { return analysis_task_parsers::appendOutput(outputs, element, hash); }, *task.get());
 
   auto requiredServices = CommonServices::defaultServices();

From 2f52be1afa9d96fc02148b3fee7eb73fb1ef7661 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 19 May 2026 11:33:06 +0200
Subject: [PATCH 1742/1764] DPL MCP: support multiple workflows

Rather than having to specify a single workflow in the
MCP configuration, allow it to connect to any running workflow.
---
 .../scripts/dpl-mcp-server/dpl_mcp_server.py  | 351 +++++++++++-------
 1 file changed, 223 insertions(+), 128 deletions(-)

diff --git a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
index 3900a646632a1..dca5058b01dcd 100644
--- a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
+++ b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
@@ -14,19 +14,21 @@
 Bridges the DPL driver /status WebSocket endpoint to MCP tools so that an
 AI assistant (e.g. Claude) can inspect and monitor a running DPL workflow.
 
+Supports multiple concurrent workflows.  Use the ``connect`` tool to attach
+to a running topology by port or PID, then pass the returned workflow name
+to every other tool.
+
 Usage
 -----
-    python3 dpl_mcp_server.py --port 8080
-    python3 dpl_mcp_server.py --pid 12345       # port derived as 8080 + pid % 30000
-    DPL_STATUS_PORT=8080 python3 dpl_mcp_server.py
+    python3 dpl_mcp_server.py
 
-Wire protocol (client → driver)
+Wire protocol (client -> driver)
 --------------------------------
     {"cmd":"list_metrics","device":"<name>"}
     {"cmd":"subscribe","device":"<name>","metrics":["m1","m2"]}
     {"cmd":"unsubscribe","device":"<name>","metrics":["m1"]}
 
-Wire protocol (driver → client)
+Wire protocol (driver -> client)
 --------------------------------
     {"type":"snapshot","devices":[{"name","pid","active","streamingState","deviceState"},...]}
     {"type":"update","device":<idx>,"name":"<name>","metrics":{<name:value,...>}}
@@ -35,80 +37,115 @@
 
 from __future__ import annotations
 
-import argparse
 import asyncio
 import json
-import os
-import sys
 from typing import Any
 
 import websockets
 from mcp.server.fastmcp import FastMCP
 
+
 # ---------------------------------------------------------------------------
-# Global connection state (all access from the single asyncio event loop)
+# Per-workflow connection state
 # ---------------------------------------------------------------------------
-_port: int = 8080
-_ws: Any = None
-_reader_task: asyncio.Task | None = None
-_snapshot: dict = {}
-_updates: list[dict] = []
-_logs: list[dict] = []
-_metrics_lists: dict[str, list[str]] = {}
-
-
-async def _ensure_connected() -> None:
-    """Connect (or reconnect) to the driver's /status WebSocket."""
-    global _ws, _reader_task
-
-    # Check liveness of existing connection.
-    if _ws is not None:
+class WorkflowConnection:
+    """Holds WebSocket connection and buffered state for one DPL workflow."""
+
+    def __init__(self, port: int, name: str):
+        self.port = port
+        self.name = name
+        self.ws: Any = None
+        self.reader_task: asyncio.Task | None = None
+        self.snapshot: dict = {}
+        self.updates: list[dict] = []
+        self.logs: list[dict] = []
+        self.metrics_lists: dict[str, list[str]] = {}
+
+    async def ensure_connected(self) -> None:
+        """Connect (or reconnect) to the driver's /status WebSocket."""
+        if self.ws is not None:
+            try:
+                pong = await asyncio.wait_for(self.ws.ping(), timeout=2.0)
+                await pong
+                return
+            except Exception:
+                old_ws = self.ws
+                self.ws = None
+                if self.reader_task is not None and not self.reader_task.done():
+                    self.reader_task.cancel()
+                    try:
+                        await self.reader_task
+                    except (asyncio.CancelledError, Exception):
+                        pass
+                self.reader_task = None
+                try:
+                    await old_ws.close()
+                except Exception:
+                    pass
+
+        url = f"ws://localhost:{self.port}/status"
+        self.ws = await websockets.connect(url, subprotocols=["dpl"])
+        if self.reader_task is None or self.reader_task.done():
+            self.reader_task = asyncio.create_task(self._reader())
+
+    async def _reader(self) -> None:
+        """Background task: read frames from the driver and buffer them."""
         try:
-            pong = await asyncio.wait_for(_ws.ping(), timeout=2.0)
-            await pong
-            return
+            async for raw in self.ws:
+                try:
+                    msg = json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+                t = msg.get("type")
+                if t == "snapshot":
+                    self.snapshot = msg
+                    self.metrics_lists.clear()
+                elif t == "update":
+                    self.updates.append(msg)
+                elif t == "log":
+                    self.logs.append(msg)
+                elif t == "metrics_list":
+                    device = msg.get("device", "")
+                    self.metrics_lists[device] = msg.get("metrics", [])
         except Exception:
-            _ws = None
-            if _reader_task is not None and not _reader_task.done():
-                _reader_task.cancel()
-            _reader_task = None
-
-    url = f"ws://localhost:{_port}/status"
-    _ws = await websockets.connect(url, subprotocols=["dpl"])
-    if _reader_task is None or _reader_task.done():
-        _reader_task = asyncio.create_task(_reader())
-
-
-async def _reader() -> None:
-    """Background task: read frames from the driver and buffer them."""
-    global _ws, _snapshot, _updates, _logs, _metrics_lists
-    try:
-        async for raw in _ws:
+            pass
+        finally:
+            self.ws = None
+
+    async def send(self, obj: dict) -> None:
+        await self.ensure_connected()
+        await self.ws.send(json.dumps(obj, separators=(",", ":")))
+
+    async def close(self) -> None:
+        ws = self.ws
+        self.ws = None
+        if self.reader_task is not None and not self.reader_task.done():
+            self.reader_task.cancel()
             try:
-                msg = json.loads(raw)
-            except json.JSONDecodeError:
-                continue
-            t = msg.get("type")
-            if t == "snapshot":
-                _snapshot = msg
-                # Clear stale metric lists from a previous driver instance.
-                _metrics_lists.clear()
-            elif t == "update":
-                _updates.append(msg)
-            elif t == "log":
-                _logs.append(msg)
-            elif t == "metrics_list":
-                device = msg.get("device", "")
-                _metrics_lists[device] = msg.get("metrics", [])
-    except Exception:
-        pass
-    finally:
-        _ws = None
-
-
-async def _send(obj: dict) -> None:
-    await _ensure_connected()
-    await _ws.send(json.dumps(obj, separators=(",", ":")))
+                await self.reader_task
+            except (asyncio.CancelledError, Exception):
+                pass
+        self.reader_task = None
+        if ws is not None:
+            await ws.close()
+
+
+# ---------------------------------------------------------------------------
+# Workflow registry
+# ---------------------------------------------------------------------------
+_workflows: dict[str, WorkflowConnection] = {}
+
+
+def _get(workflow: str) -> WorkflowConnection:
+    """Look up a workflow by name, raising a clear error if not found."""
+    conn = _workflows.get(workflow)
+    if conn is None:
+        available = ", ".join(_workflows.keys()) if _workflows else "(none)"
+        raise ValueError(
+            f"No workflow named '{workflow}'. Connected workflows: {available}. "
+            f"Use the connect tool first."
+        )
+    return conn
 
 
 # ---------------------------------------------------------------------------
@@ -118,16 +155,81 @@ async def _send(obj: dict) -> None:
 
 
 @mcp.tool()
-async def list_devices() -> str:
+async def connect(port: int = 0, pid: int = 0, name: str = "") -> str:
+    """Connect to a running DPL workflow.
+
+    Provide either ``port`` (the driver's WebSocket port) or ``pid`` (the
+    driver PID, port derived as 8080 + pid % 30000).  An optional ``name``
+    gives the workflow a human-friendly label; if omitted the port number is
+    used.
+
+    Args:
+        port: TCP port of the DPL driver status WebSocket.
+        pid:  PID of the DPL driver process (alternative to port).
+        name: Optional human-friendly name for this workflow.
+    """
+    if pid:
+        port = 8080 + pid % 30000
+    if not port:
+        return "Provide either port or pid."
+
+    wf_name = name or str(port)
+    if wf_name in _workflows:
+        old = _workflows[wf_name]
+        await old.close()
+
+    conn = WorkflowConnection(port, wf_name)
+    await conn.ensure_connected()
+    _workflows[wf_name] = conn
+
+    devices = conn.snapshot.get("devices", [])
+    return (
+        f"Connected to workflow '{wf_name}' on port {port} "
+        f"({len(devices)} device(s))."
+    )
+
+
+@mcp.tool()
+async def disconnect(workflow: str) -> str:
+    """Disconnect from a DPL workflow and release its resources.
+
+    Args:
+        workflow: Workflow name as returned by connect.
+    """
+    conn = _get(workflow)
+    await conn.close()
+    del _workflows[workflow]
+    return f"Disconnected from workflow '{workflow}'."
+
+
+@mcp.tool()
+async def list_workflows() -> str:
+    """List all currently connected DPL workflows."""
+    if not _workflows:
+        return "No workflows connected. Use the connect tool first."
+    lines = []
+    for wf_name, conn in _workflows.items():
+        n = len(conn.snapshot.get("devices", []))
+        status = "connected" if conn.ws is not None else "disconnected"
+        lines.append(f"{wf_name}: port={conn.port} devices={n} status={status}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+async def list_devices(workflow: str) -> str:
     """List all DPL devices with their current status.
 
     Returns each device's name, PID, active flag, streaming state, and device
     state as reported by the driver snapshot.
+
+    Args:
+        workflow: Workflow name as returned by connect.
     """
-    await _ensure_connected()
-    if not _snapshot:
-        return "No snapshot received yet — the driver may still be starting."
-    devices = _snapshot.get("devices", [])
+    conn = _get(workflow)
+    await conn.ensure_connected()
+    if not conn.snapshot:
+        return "No snapshot received yet -- the driver may still be starting."
+    devices = conn.snapshot.get("devices", [])
     if not devices:
         return "No devices in snapshot."
     lines = []
@@ -140,7 +242,7 @@ async def list_devices() -> str:
 
 
 @mcp.tool()
-async def list_metrics(device: str) -> str:
+async def list_metrics(workflow: str, device: str) -> str:
     """List the available numeric metrics for a DPL device.
 
     Sends a list_metrics command to the driver and waits up to 3 seconds for
@@ -148,15 +250,16 @@ async def list_metrics(device: str) -> str:
     and enum metrics are excluded.
 
     Args:
+        workflow: Workflow name as returned by connect.
         device: Device name exactly as shown by list_devices.
     """
-    # Remove any stale cached result so we can detect the fresh reply.
-    _metrics_lists.pop(device, None)
-    await _send({"cmd": "list_metrics", "device": device})
+    conn = _get(workflow)
+    conn.metrics_lists.pop(device, None)
+    await conn.send({"cmd": "list_metrics", "device": device})
     for _ in range(60):          # up to 3 s
         await asyncio.sleep(0.05)
-        if device in _metrics_lists:
-            names = _metrics_lists[device]
+        if device in conn.metrics_lists:
+            names = conn.metrics_lists[device]
             if not names:
                 return f"Device '{device}' has no numeric metrics yet."
             return f"{len(names)} metric(s): " + ", ".join(names)
@@ -164,7 +267,7 @@ async def list_metrics(device: str) -> str:
 
 
 @mcp.tool()
-async def subscribe(device: str, metrics: list[str]) -> str:
+async def subscribe(workflow: str, device: str, metrics: list[str]) -> str:
     """Subscribe to one or more metrics for a DPL device.
 
     After subscribing, the driver will push update frames for the device
@@ -172,60 +275,70 @@ async def subscribe(device: str, metrics: list[str]) -> str:
     the buffer.
 
     Args:
+        workflow: Workflow name as returned by connect.
         device: Device name exactly as shown by list_devices.
         metrics: List of metric names to subscribe to (from list_metrics).
     """
-    await _send({"cmd": "subscribe", "device": device, "metrics": metrics})
+    conn = _get(workflow)
+    await conn.send({"cmd": "subscribe", "device": device, "metrics": metrics})
     return f"Subscribed to {len(metrics)} metric(s) for '{device}': {', '.join(metrics)}"
 
 
 @mcp.tool()
-async def unsubscribe(device: str, metrics: list[str]) -> str:
+async def unsubscribe(workflow: str, device: str, metrics: list[str]) -> str:
     """Stop receiving updates for specific metrics of a DPL device.
 
     Args:
+        workflow: Workflow name as returned by connect.
         device: Device name exactly as shown by list_devices.
         metrics: List of metric names to unsubscribe from.
     """
-    await _send({"cmd": "unsubscribe", "device": device, "metrics": metrics})
+    conn = _get(workflow)
+    await conn.send({"cmd": "unsubscribe", "device": device, "metrics": metrics})
     return f"Unsubscribed from {len(metrics)} metric(s) for '{device}'."
 
 
 @mcp.tool()
-async def subscribe_logs(device: str) -> str:
+async def subscribe_logs(workflow: str, device: str) -> str:
     """Subscribe to log output for a DPL device.
 
     After subscribing, new log lines from the device will be buffered and
     can be retrieved with get_logs().
 
     Args:
+        workflow: Workflow name as returned by connect.
         device: Device name exactly as shown by list_devices.
     """
-    await _send({"cmd": "subscribe_logs", "device": device})
+    conn = _get(workflow)
+    await conn.send({"cmd": "subscribe_logs", "device": device})
     return f"Subscribed to logs for '{device}'."
 
 
 @mcp.tool()
-async def unsubscribe_logs(device: str) -> str:
+async def unsubscribe_logs(workflow: str, device: str) -> str:
     """Stop receiving log output for a DPL device.
 
     Args:
+        workflow: Workflow name as returned by connect.
         device: Device name exactly as shown by list_devices.
     """
-    await _send({"cmd": "unsubscribe_logs", "device": device})
+    conn = _get(workflow)
+    await conn.send({"cmd": "unsubscribe_logs", "device": device})
     return f"Unsubscribed from logs for '{device}'."
 
 
 @mcp.tool()
-async def get_logs(max_lines: int = 100) -> str:
+async def get_logs(workflow: str, max_lines: int = 100) -> str:
     """Drain and return buffered log lines received since the last call.
 
     Args:
+        workflow: Workflow name as returned by connect.
         max_lines: Maximum number of log lines to return (default 100).
     """
-    await _ensure_connected()
-    batch = _logs[:max_lines]
-    del _logs[:max_lines]
+    conn = _get(workflow)
+    await conn.ensure_connected()
+    batch = conn.logs[:max_lines]
+    del conn.logs[:max_lines]
     if not batch:
         return "No buffered log lines."
     lines = []
@@ -238,17 +351,21 @@ async def get_logs(max_lines: int = 100) -> str:
 
 
 @mcp.tool()
-async def start_devices() -> str:
+async def start_devices(workflow: str) -> str:
     """Resume all stopped DPL devices (send SIGCONT).
 
     Use this when the workflow was started with -s (all devices paused).
+
+    Args:
+        workflow: Workflow name as returned by connect.
     """
-    await _send({"cmd": "start_devices"})
+    conn = _get(workflow)
+    await conn.send({"cmd": "start_devices"})
     return "Sent SIGCONT to all active devices."
 
 
 @mcp.tool()
-async def enable_signpost(device: str, streams: list[str]) -> str:
+async def enable_signpost(workflow: str, device: str, streams: list[str]) -> str:
     """Enable one or more signpost log streams for a DPL device.
 
     Signpost streams produce detailed trace output visible in the device logs.
@@ -259,27 +376,31 @@ async def enable_signpost(device: str, streams: list[str]) -> str:
     ch.cern.aliceo2.data_processor_context, ch.cern.aliceo2.stream_context.
 
     Args:
+        workflow: Workflow name as returned by connect.
         device: Device name as shown by list_devices, or "" for the driver.
         streams: List of full signpost log names to enable.
     """
-    await _send({"cmd": "enable_signpost", "device": device, "streams": streams})
+    conn = _get(workflow)
+    await conn.send({"cmd": "enable_signpost", "device": device, "streams": streams})
     return f"Enabled {len(streams)} signpost stream(s) for '{device or 'driver'}': {', '.join(streams)}"
 
 
 @mcp.tool()
-async def disable_signpost(device: str, streams: list[str]) -> str:
+async def disable_signpost(workflow: str, device: str, streams: list[str]) -> str:
     """Disable one or more signpost log streams for a DPL device.
 
     Args:
+        workflow: Workflow name as returned by connect.
         device: Device name as shown by list_devices, or "" for the driver.
         streams: List of full signpost log names to disable.
     """
-    await _send({"cmd": "disable_signpost", "device": device, "streams": streams})
+    conn = _get(workflow)
+    await conn.send({"cmd": "disable_signpost", "device": device, "streams": streams})
     return f"Disabled {len(streams)} signpost stream(s) for '{device or 'driver'}': {', '.join(streams)}"
 
 
 @mcp.tool()
-async def get_updates(max_updates: int = 50) -> str:
+async def get_updates(workflow: str, max_updates: int = 50) -> str:
     """Drain and return buffered metric update frames received since the last call.
 
     Each frame contains the latest values of all subscribed metrics that
@@ -287,11 +408,13 @@ async def get_updates(max_updates: int = 50) -> str:
     time-ordered view of metric evolution.
 
     Args:
+        workflow: Workflow name as returned by connect.
         max_updates: Maximum number of update frames to return (default 50).
     """
-    await _ensure_connected()
-    batch = _updates[:max_updates]
-    del _updates[:max_updates]
+    conn = _get(workflow)
+    await conn.ensure_connected()
+    batch = conn.updates[:max_updates]
+    del conn.updates[:max_updates]
     if not batch:
         return "No buffered updates."
     lines = []
@@ -310,34 +433,6 @@ async def get_updates(max_updates: int = 50) -> str:
 # Entry point
 # ---------------------------------------------------------------------------
 def main() -> None:
-    global _port
-
-    parser = argparse.ArgumentParser(
-        description="DPL status MCP server — expose DPL driver metrics via MCP tools"
-    )
-    group = parser.add_mutually_exclusive_group()
-    group.add_argument(
-        "--port",
-        type=int,
-        default=None,
-        help="TCP port of the DPL driver status WebSocket (default: 8080 or DPL_STATUS_PORT env var)",
-    )
-    group.add_argument(
-        "--pid",
-        type=int,
-        default=None,
-        help="PID of the DPL driver process; port is derived as 8080 + pid %% 30000",
-    )
-    args = parser.parse_args()
-
-    if args.pid is not None:
-        _port = 8080 + args.pid % 30000
-    elif args.port is not None:
-        _port = args.port
-    elif "DPL_STATUS_PORT" in os.environ:
-        _port = int(os.environ["DPL_STATUS_PORT"])
-    # else leave _port at the default 8080
-
     mcp.run()
 
 

From 3ee5c9fe4f3e8b26cab7c37198fab29582d6019b Mon Sep 17 00:00:00 2001
From: mcoquet642 <74600025+mcoquet642@users.noreply.github.com>
Date: Tue, 19 May 2026 22:05:49 +0200
Subject: [PATCH 1743/1764] [MFT] Fixing number of links per RU/zone in mapping
 (#15410)

Co-authored-by: Maurice Coquet <mcoquet@alicecerno2.cern.ch>
---
 .../ITSMFTReconstruction/ChipMappingMFT.h       | 17 ++++++++---------
 .../reconstruction/src/ChipMappingMFT.cxx       |  6 +++---
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h
index eee9bdbb6a4dc..63d37a25ffbc9 100644
--- a/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h
+++ b/Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/ChipMappingMFT.h
@@ -73,16 +73,15 @@ class ChipMappingMFT
   ///< total number of RUs
   static constexpr Int_t getNRUs() { return NRUs; }
 
-  ///< get FEEId of the RU (software id of the RU), read via given link
+  ///< get software id of the RU, from first 8 bits of FEEID (HW id of RU)
   uint8_t FEEId2RUSW(uint16_t hw) const { return mFEEId2RUSW[hw & 0xff]; }
 
-  ///< get HW id of the RU (software id of the RU)
+  ///< get FEEID, from software id of the RU and link number
   uint16_t RUSW2FEEId(uint16_t sw, uint16_t linkID = 0) const { return ((linkID << 8) + mRUInfo[sw].idHW); }
 
   ///< compose FEEid for given stave (ru) relative to layer and link, see documentation in the constructor
   uint16_t composeFEEId(uint16_t layer, uint16_t ruOnLayer, uint16_t link) const
   {
-    // only one link is used
     // ruOnLayer is 0, 1, 2, 3 for half = 0
     //              4, 5, 6, 7            1
     auto dhalf = std::div(ruOnLayer, 4);
@@ -114,7 +113,7 @@ class ChipMappingMFT
     face = (feeID >> 2) & 0x1;
   }
 
-  ///< get info on sw RU
+  ///< get info on sw RU corresponding to given FEEID
   const RUInfo* getRUInfoFEEId(Int_t feeID) const { return &mRUInfo[FEEId2RUSW(feeID)]; }
 
   ///< get number of chips served by single cable on given RU type
@@ -123,13 +122,13 @@ class ChipMappingMFT
     return ((0x1 << 7) + (cableHW & 0x1f));
   }
 
-  ///< convert HW cable ID to its position on the ActiveLanes word in the GBT.header for given RU type
+  ///< convert HW cable ID to its position on the ActiveLanes word in the GBT.header for given RU type (note: this position is equal to the HW cable ID)
   uint8_t cableHW2Pos(uint8_t ruType, uint8_t hwid) const { return mCableHW2Pos[ruType][hwid]; }
 
   ///< convert HW cable ID to SW ID for give RU type
   uint8_t cableHW2SW(uint8_t ruType, uint8_t hwid) const { return hwid < mCableHW2SW[ruType].size() ? mCableHW2SW[ruType][hwid] : 0xff; }
 
-  ///< convert cable iterator ID to its position on the ActiveLanes word in the GBT.header for given RU type
+  ///< convert cable iterator ID (i.e. chipOnModule) to its position on the ActiveLanes word in the GBT.header for given RU type (note: this position is equal to the HW cable ID)
   uint8_t cablePos(uint8_t ruType, uint8_t id) const { return mCablePos[ruType][id]; }
 
   ///< get chipID on module from chip global SW ID, cable SW ID and stave (RU) info
@@ -139,7 +138,7 @@ class ChipMappingMFT
     return 0xffff;
   }
 
-  ///< get chip global SW ID from chipID on module, cable SW ID and stave (RU) info
+  ///< get chip global SW ID from cable HW ID and stave (RU) info (note: chOnModuleHW is unused)
   uint16_t getGlobalChipID(uint16_t chOnModuleHW, int cableHW, const RUInfo& ruInfo) const
   {
     auto chipOnRU = cableHW2SW(ruInfo.ruType, cableHW);
@@ -393,11 +392,11 @@ class ChipMappingMFT
 
  private:
   Int_t invalid() const;
-  static constexpr Int_t NRUs = NLayers * NZonesPerLayer;
+  static constexpr Int_t NRUs = NLayers * NZonesPerLayer; // 10 layers * 8 zones per layer
   static constexpr Int_t NModules = 280;
   static constexpr Int_t NChipsInfo = 7 + 8 + 9 + 10 + 11 + 12 + 13 + 14 + 16 + 17 + 18 + 19 + 14;
   static constexpr Int_t NChipsPerCable = 1;
-  static constexpr Int_t NLinks = 1;
+  static constexpr Int_t NLinks = 3;
   static constexpr Int_t NConnectors = 5;
   static constexpr Int_t NMaxChipsPerLadder = 5;
   static constexpr Int_t NRUCables = 25;
diff --git a/Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx b/Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx
index de2358469e894..b79c529bef803 100644
--- a/Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx
+++ b/Detectors/ITSMFT/common/reconstruction/src/ChipMappingMFT.cxx
@@ -1624,7 +1624,7 @@ ChipMappingMFT::ChipMappingMFT()
 {
   // init chips info
 
-  uint32_t maxRUHW = composeFEEId(NLayers - 1, NZonesPerLayer - 1, NLinks - 1); // Max possible FEE ID
+  uint32_t maxRUHW = composeFEEId(NLayers - 1, NZonesPerLayer - 1, 0); // Max possible RU HW ID (first 8 bits of max FEEID, while link stored in 9th and 10th bit of FEEID)
   mFEEId2RUSW.resize(maxRUHW + 1, 0xff);
 
   int curLayer = -1, curZone = -1, curHalf = -1;
@@ -1698,8 +1698,8 @@ ChipMappingMFT::ChipMappingMFT()
       auto& ruInfo = mRUInfo[ctrRU];
       ruInfo.idSW = ctrRU++;
 
-      // map FEEIds (RU read out by at most 3 GBT links) to SW ID
-      ruInfo.idHW = composeFEEId(iLayer, iZone, 0); // FEEId for link 0
+      // map RU HW ID (RU read out by at most 3 GBT links) to SW ID
+      ruInfo.idHW = composeFEEId(iLayer, iZone, 0); // RU HW ID (first 8 bits of FEEID)
       mFEEId2RUSW[ruInfo.idHW] = ruInfo.idSW;
       ruInfo.layer = iLayer;
       ruInfo.ruType = ZoneRUType[iZone % 4][iLayer / 2];

From 2e26434c440f559711b7a4e0aa576f0ab5ded134 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Tue, 19 May 2026 17:00:48 +0200
Subject: [PATCH 1744/1764] Fixes for ROFs downscaling for ITS tracking

---
 .../ITSMFT/ITS/tracking/src/FastMultEst.cxx   | 86 +++++--------------
 1 file changed, 21 insertions(+), 65 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx b/Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx
index cb831d7db71d0..cfbfdd8a9150e 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/FastMultEst.cxx
@@ -168,85 +168,41 @@ int FastMultEst::selectROFs(const std::array<gsl::span<const o2::itsmft::ROFReco
                             ROFMaskTableN& sel)
 {
   const auto& multEstConf = FastMultEstConfig::Instance(); // parameters for mult estimation and cuts
-  const int selectionLayer = overlapView.getClock();
-  int multLayer = std::clamp(multEstConf.cutMultClusLayer, 0, NLayers - 1);
-  if (doStaggering && rofs[multLayer].empty()) {
-    LOGP(info, "FastMultEst multiplicity layer {} has no ROFs, falling back to selection layer {}", multLayer, selectionLayer);
-    multLayer = selectionLayer;
-  }
-
-  const auto multCounts = buildMultiplicityCounts<NLayers>(rofs, clus, doStaggering, multLayer);
+  const int selectionLayer = multEstConf.isMultCutRequested() ? std::clamp(multEstConf.cutMultClusLayer, 0, NLayers - 1) : overlapView.getClock();
+  const auto multCounts = buildMultiplicityCounts<NLayers>(rofs, clus, doStaggering, selectionLayer);
   const int selectionRofCount = doStaggering ? static_cast<int>(rofs[selectionLayer].size()) : static_cast<int>(rofs[0].size());
 
   sel.resetMask();
   lastRandomSeed = gRandom->GetSeed();
   const o2::InteractionRecord tfStartIR{0, firstTForbit};
-
-  if (!trig.empty()) {
+  // mask ROFs which are not good from the multiplicity selection (if any) POV
+  struct ROFStatus {
+    int entry = 0, priority = 0;
+  };
+  std::vector<ROFStatus> selROFs;
+  selROFs.reserve(selectionRofCount);
+  bool selmult = multEstConf.isMultCutRequested();
+  for (int selectionRof = 0; selectionRof < selectionRofCount; ++selectionRof) {
+    selROFs.emplace_back(selectionRof, (selmult && !multEstConf.isPassingMultCut(process(multCounts[selectionRof]))) ? -1 : 0);
+  }
+  if (!trig.empty() && multEstConf.preferTriggered) {
     const auto& selectionLayerTiming = overlapView.getLayer(selectionLayer);
-    const auto& multLayerTiming = overlapView.getLayer(multLayer);
-
     for (const auto& trigger : trig) {
       const int selectionRof = findROFForIR(trigger.ir, tfStartIR, selectionLayerTiming);
-      if (selectionRof < 0) {
-        continue;
-      }
-      if (multEstConf.cutRandomFraction > 0.f && gRandom->Rndm() < multEstConf.cutRandomFraction) {
-        continue;
-      }
-      if (multEstConf.isMultCutRequested()) {
-        const int triggerMultRof = doStaggering ? findROFForIR(trigger.ir, tfStartIR, multLayerTiming) : selectionRof;
-        if (triggerMultRof < 0 || triggerMultRof >= static_cast<int>(multCounts.size())) {
-          continue;
-        }
-        if (!multEstConf.isPassingMultCut(process(multCounts[triggerMultRof]))) {
-          continue;
-        }
-      }
-      enableCompatibleROFs<NLayers>(selectionLayer, selectionRof, overlapView, sel);
-    }
-  } else {
-    LOGP(info, "FastMultEst received no physics/TRD triggers, falling back to ROF-driven filtering on layer {}", selectionLayer);
-    for (int selectionRof = 0; selectionRof < selectionRofCount; ++selectionRof) {
-      if (multEstConf.isMultCutRequested()) {
-        bool passes = false;
-        if (!doStaggering || selectionLayer == multLayer) {
-          if (selectionRof < static_cast<int>(multCounts.size())) {
-            passes = multEstConf.isPassingMultCut(process(multCounts[selectionRof]));
-          }
-        } else {
-          const auto& overlap = overlapView.getOverlap(selectionLayer, multLayer, selectionRof);
-          for (int rof = overlap.getFirstEntry(); rof < overlap.getEntriesBound(); ++rof) {
-            if (rof < static_cast<int>(multCounts.size())) {
-              if (multEstConf.isPassingMultCut(process(multCounts[rof]))) {
-                passes = true;
-                break;
-              }
-            }
-          }
-        }
-        if (!passes) {
-          continue;
-        }
-      }
-      if (multEstConf.cutRandomFraction > 0.f && gRandom->Rndm() < multEstConf.cutRandomFraction) {
+      if (selectionRof < 0 || selROFs[selectionRof].priority < 0) {
         continue;
       }
-      enableCompatibleROFs<NLayers>(selectionLayer, selectionRof, overlapView, sel);
+      selROFs[selectionRof].priority++; // increment trigger counter
     }
+    sort(selROFs.begin(), selROFs.end(), [](const ROFStatus& a, const ROFStatus& b) { return a.priority > b.priority; }); // order in number of triggers, masked will go to the end
   }
-
-  const auto selView = sel.getView();
   int nsel = 0;
-  for (int irof = 0; irof < selectionRofCount; ++irof) {
-    nsel += selView.isROFEnabled(selectionLayer, irof);
-  }
-
-  if (!trig.empty() && multEstConf.preferTriggered) {
-    LOGP(debug, "FastMultEst preferTriggered is ignored in trigger-driven mask mode");
+  for (auto& rof : selROFs) {
+    if (rof.priority >= 0 && (multEstConf.cutRandomFraction <= 0.f || (gRandom->Rndm() > multEstConf.cutRandomFraction))) {
+      enableCompatibleROFs<NLayers>(selectionLayer, rof.entry, overlapView, sel);
+      nsel++;
+    }
   }
-
   LOGP(debug, "NSel = {} of {} rofs on layer {} Seeds: before {} after {}", nsel, selectionRofCount, selectionLayer, lastRandomSeed, gRandom->GetSeed());
-
   return nsel;
 }

From f8f5d1eb6c74aa9d5840407a082bef9af3f56555 Mon Sep 17 00:00:00 2001
From: Martin Eide <43970264+mrtineide@users.noreply.github.com>
Date: Wed, 20 May 2026 14:06:56 +0200
Subject: [PATCH 1745/1764] Add token for the test CCDB instance

Before the test instance did not need a token. This has changed, which
broke tests that relied on hardcoded HTTP, and not HTTPS.
Now the test instance redirects to HTTPS and we need a token.
---
 CCDB/src/CcdbApi.cxx | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/CCDB/src/CcdbApi.cxx b/CCDB/src/CcdbApi.cxx
index 42bc13904bf61..93a79ad56c477 100644
--- a/CCDB/src/CcdbApi.cxx
+++ b/CCDB/src/CcdbApi.cxx
@@ -213,8 +213,7 @@ void CcdbApi::init(std::string const& host)
     snapshotReport += ')';
   }
 
-  mNeedAlienToken = (host.find("https://") != std::string::npos) || (host.find("alice-ccdb.cern.ch") != std::string::npos);
-
+  mNeedAlienToken = (host.find("https://") != std::string::npos) || (host.find("alice-ccdb.cern.ch") != std::string::npos) || (host.find("ccdb-test.cern.ch") != std::string::npos);
   // Set the curl timeout. It can be forced with an env var or it has different defaults based on the deployment mode.
   if (getenv("ALICEO2_CCDB_CURL_TIMEOUT_DOWNLOAD")) {
     auto timeout = atoi(getenv("ALICEO2_CCDB_CURL_TIMEOUT_DOWNLOAD"));

From 084c3660c7bce5e8fa011fa0fee40a32d0d86f84 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <matthias.kleiner@cern.ch>
Date: Wed, 20 May 2026 15:23:30 +0200
Subject: [PATCH 1746/1764] TPC: add option for disabling corrections

- add option for using static corrections instead of main corrections
---
 .../calibration/src/CorrectionMapsLoader.cxx  | 13 +++-
 .../calibration/src/CorrectionMapsOptions.cxx |  4 +-
 Detectors/TPC/workflow/src/TPCScalerSpec.cxx  | 63 ++++++++++---------
 .../CorrectionMapsHelper.cxx                  | 43 ++++++++++++-
 .../CorrectionMapsTypes.h                     | 14 +++--
 5 files changed, 96 insertions(+), 41 deletions(-)

diff --git a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
index 9569e0eb8abd2..c8bdfa0f99350 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsLoader.cxx
@@ -28,8 +28,13 @@ using namespace o2::framework;
 void CorrectionMapsLoader::extractCCDBInputs(ProcessingContext& pc, float tpcScaler)
 {
   pc.inputs().get<o2::tpc::CorrMapParam*>("tpcCorrPar");
-  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMap");
-  pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapRef");
+  const auto lumiMode = getLumiScaleMode();
+  if (lumiMode != LumiScaleMode::NoCorrection && lumiMode != LumiScaleMode::StaticMapOnly) {
+    pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMap");
+  }
+  if (lumiMode != LumiScaleMode::NoCorrection) {
+    pc.inputs().get<o2::gpu::TPCFastTransform*>("tpcCorrMapRef");
+  }
   const int maxDumRep = 5;
   int dumRep = 0;
   o2::ctp::LumiInfo lumiObj;
@@ -97,6 +102,10 @@ void CorrectionMapsLoader::requestCCDBInputs(std::vector<InputSpec>& inputs, con
     // for MC corrections
     addInput(inputs, {"tpcCorrMap", "TPC", "CorrMap", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapMC), {}, 1)});            // time-dependent
     addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrDerivMapMC), {}, 1)}); // time-dependent
+  } else if (gloOpts.lumiMode == LumiScaleMode::NoCorrection) {
+    // no correction maps needed — a dummy map is created at runtime
+  } else if (gloOpts.lumiMode == LumiScaleMode::StaticMapOnly) {
+    addInput(inputs, {"tpcCorrMapRef", "TPC", "CorrMapRef", 0, Lifetime::Condition, ccdbParamSpec(CDBTypeMap.at(CDBType::CalCorrMapRef), {}, 0)}); // load once
   } else {
     LOG(fatal) << "Correction mode unknown! Choose either 0 (default) or 1 (derivative map) for flag corrmap-lumi-mode.";
   }
diff --git a/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx b/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
index 604b7c680385b..45c3771db57bf 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
@@ -21,13 +21,13 @@ CorrectionMapsGloOpts CorrectionMapsOptions::parseGlobalOptions(const o2::framew
 {
   CorrectionMapsGloOpts tpcopt;
   auto lumiTypeVal = opts.get<int>("lumi-type");
-  if (lumiTypeVal < -1 || lumiTypeVal > 2) {
+  if (lumiTypeVal < static_cast<int>(LumiScaleType::Unset) || lumiTypeVal >= static_cast<int>(LumiScaleType::Count)) {
     LOGP(fatal, "Invalid lumi-type value: {}", lumiTypeVal);
   }
   tpcopt.lumiType = static_cast<LumiScaleType>(lumiTypeVal);
 
   auto lumiModeVal = opts.get<int>("corrmap-lumi-mode");
-  if (lumiModeVal < -1 || lumiModeVal > 2) {
+  if (lumiModeVal < static_cast<int>(LumiScaleMode::Unset) || lumiModeVal >= static_cast<int>(LumiScaleMode::Count)) {
     LOGP(fatal, "Invalid corrmap-lumi-mode value: {}", lumiModeVal);
   }
   tpcopt.lumiMode = static_cast<LumiScaleMode>(lumiModeVal);
diff --git a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
index 8e2a78d69757b..1df192dd5ec00 100644
--- a/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCScalerSpec.cxx
@@ -183,40 +183,45 @@ class TPCScalerSpec : public Task
 
   void buildMap(ProcessingContext& pc)
   {
-    // reference map
-    auto* corrMap = mTPCCorrMapsLoader.getCorrMap();
-
-    // // new correction map
+    const auto lumiMode = mTPCCorrMapsLoader.getLumiScaleMode();
     o2::gpu::TPCFastTransform finalMap;
-    finalMap.cloneFromObject(*corrMap, nullptr);
-    finalMap.setApplyCorrectionOn();
-
-    const auto* corrMapRef = mTPCCorrMapsLoader.getCorrMapRef();
-    const float lumiScale = mTPCCorrMapsLoader.getLumiScale();
     std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> additionalCorrections;
 
-    // if standard scaling is used: map(lumi) = (mean_map - ref_map) * lumiScale + ref_map
-    if (mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::Linear) {
-      const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step0{{&(corrMapRef->getCorrection()), -1.f}};
-      // finalMap = (mean_map - finalMap)
-      TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, step0, true);
-
-      // finalMap = finalMap * lumiScale + ref_map
-      const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step1{{&(corrMapRef->getCorrection()), 1.f}};
-      TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), lumiScale, step1, true);
-
-    } else if (mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::DerivativeMap || mTPCCorrMapsLoader.getLumiScaleMode() == LumiScaleMode::DerivativeMapMC) {
-      additionalCorrections.emplace_back(&(corrMapRef->getCorrection()), lumiScale);
-    }
+    if (lumiMode == LumiScaleMode::NoCorrection) {
+      std::unique_ptr<o2::gpu::TPCFastTransform> dummy(TPCFastTransformHelperO2::instance()->create(0));
+      finalMap.cloneFromObject(*dummy, nullptr);
+      finalMap.setApplyCorrectionOff();
+    } else {
+      auto* corrMap = mTPCCorrMapsLoader.getCorrMap();
+      const auto* corrMapRef = mTPCCorrMapsLoader.getCorrMapRef();
+      finalMap.cloneFromObject(lumiMode == LumiScaleMode::StaticMapOnly && corrMapRef ? *corrMapRef : *corrMap, nullptr);
+      finalMap.setApplyCorrectionOn();
+
+      const float lumiScale = mTPCCorrMapsLoader.getLumiScale();
+
+      // if standard scaling is used: map(lumi) = (mean_map - ref_map) * lumiScale + ref_map
+      if (lumiMode == LumiScaleMode::Linear) {
+        const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step0{{&(corrMapRef->getCorrection()), -1.f}};
+        // finalMap = (mean_map - finalMap)
+        TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, step0, true);
+
+        // finalMap = finalMap * lumiScale + ref_map
+        const std::vector<std::pair<const o2::gpu::TPCFastSpaceChargeCorrection*, float>> step1{{&(corrMapRef->getCorrection()), 1.f}};
+        TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), lumiScale, step1, true);
+
+      } else if (lumiMode == LumiScaleMode::DerivativeMap || lumiMode == LumiScaleMode::DerivativeMapMC) {
+        additionalCorrections.emplace_back(&(corrMapRef->getCorrection()), lumiScale);
+      }
 
-    // if mshape map valid
-    if (!mTPCCorrMapsLoader.isCorrMapMShapeDummy()) {
-      LOGP(info, "Adding M-shape correction to the final map with scaling factor {}", mMShapeScalingFac);
-      additionalCorrections.emplace_back(&(mTPCCorrMapsLoader.getCorrMapMShape()->getCorrection()), 1.f);
-    }
+      // if mshape map valid
+      if (!mTPCCorrMapsLoader.isCorrMapMShapeDummy()) {
+        LOGP(info, "Adding M-shape correction to the final map with scaling factor {}", mMShapeScalingFac);
+        additionalCorrections.emplace_back(&(mTPCCorrMapsLoader.getCorrMapMShape()->getCorrection()), 1.f);
+      }
 
-    if (!additionalCorrections.empty()) {
-      TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, additionalCorrections, true);
+      if (!additionalCorrections.empty()) {
+        TPCFastSpaceChargeCorrectionHelper::instance()->mergeCorrections(finalMap.getCorrection(), 1, additionalCorrections, true);
+      }
     }
 
     Output corrMapOutput{header::gDataOriginTPC, "TPCCORRMAP", 0};
diff --git a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
index 7f7deddafe1c8..4bfedc117dec7 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
+++ b/GPU/TPCFastTransformation/CorrectionMapsHelper.cxx
@@ -38,6 +38,10 @@ void CorrectionMapsHelper::setCorrMapMShape(std::unique_ptr<TPCFastTransform>&&
 void CorrectionMapsHelper::updateLumiScale(bool report)
 {
   if (!canUseCorrections()) {
+    if (mLumiScaleMode != LumiScaleMode::NoCorrection) {
+      LOGP(warning, "Negative meanLumi={} detected, switching to NoCorrection mode for backward compatibility", mMeanLumi);
+      mLumiScaleMode = LumiScaleMode::NoCorrection;
+    }
     mLumiScale = -1.f;
   } else if ((mLumiScaleMode == LumiScaleMode::DerivativeMap) || (mLumiScaleMode == LumiScaleMode::DerivativeMapMC)) {
     mLumiScale = mMeanLumiRef ? (mInstLumi - mMeanLumi) / mMeanLumiRef : 0.f;
@@ -54,7 +58,40 @@ void CorrectionMapsHelper::updateLumiScale(bool report)
 //________________________________________________________
 void CorrectionMapsHelper::reportScaling()
 {
-  LOGP(info, "Map scaling update: LumiScaleType={} instLumi(CTP)={} instLumi(scaling)={} meanLumiRef={}, meanLumi={} -> LumiScale={} lumiScaleMode={}, M-Shape map valid: {}, M-Shape default: {}",
-       mLumiScaleType == LumiScaleType::NoScaling ? "NoScaling" : (mLumiScaleType == LumiScaleType::CTPLumi ? "LumiCTP" : "TPCScaler"), getInstLumiCTP(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(),
-       mLumiScaleMode == LumiScaleMode::Linear ? "Linear" : "Derivative", (mCorrMapMShape != nullptr), isCorrMapMShapeDummy());
+  auto lumiTypeName = [](LumiScaleType t) {
+    switch (t) {
+      case LumiScaleType::NoScaling:
+        return "NoScaling";
+      case LumiScaleType::CTPLumi:
+        return "CTPLumi";
+      case LumiScaleType::TPCScaler:
+        return "TPCScaler";
+      default:
+        return "Unknown";
+    }
+  };
+
+  const bool mshapeValid = (mCorrMapMShape != nullptr) && !isCorrMapMShapeDummy();
+
+  if (mLumiScaleMode == LumiScaleMode::NoCorrection) {
+    LOGP(info, "Map scaling update: mode=NoCorrection (corrections disabled, dummy map in use)");
+  } else if (mLumiScaleMode == LumiScaleMode::StaticMapOnly) {
+    LOGP(info, "Map scaling update: mode=StaticMapOnly (static reference map, no lumi scaling), M-Shape correction: {}", mshapeValid ? "applied" : "not applied");
+  } else {
+    auto lumiModeName = [](LumiScaleMode m) {
+      switch (m) {
+        case LumiScaleMode::Linear:
+          return "Linear";
+        case LumiScaleMode::DerivativeMap:
+          return "DerivativeMap";
+        case LumiScaleMode::DerivativeMapMC:
+          return "DerivativeMapMC";
+        default:
+          return "Unknown";
+      }
+    };
+    LOGP(info, "Map scaling update: LumiScaleType={} instLumi(CTP)={} instLumi(scaling)={} meanLumiRef={} meanLumi={} -> LumiScale={} lumiScaleMode={}, M-Shape correction: {}",
+         lumiTypeName(mLumiScaleType), getInstLumiCTP(), getInstLumi(), getMeanLumiRef(), getMeanLumi(), getLumiScale(),
+         lumiModeName(mLumiScaleMode), mshapeValid ? "applied" : "not applied");
+  }
 }
diff --git a/GPU/TPCFastTransformation/CorrectionMapsTypes.h b/GPU/TPCFastTransformation/CorrectionMapsTypes.h
index e239b668ab751..092a2927ebe3e 100644
--- a/GPU/TPCFastTransformation/CorrectionMapsTypes.h
+++ b/GPU/TPCFastTransformation/CorrectionMapsTypes.h
@@ -22,14 +22,18 @@ enum class LumiScaleType : int {
   Unset = -1,    ///< init value
   NoScaling = 0, ///< no scaling, use map as is
   CTPLumi = 1,   ///< use CTP luminosity for scaling
-  TPCScaler = 2  ///< use TPC scaler for scaling
+  TPCScaler = 2, ///< use TPC scaler for scaling
+  Count          ///< sentinel - keep last
 };
 
 enum class LumiScaleMode : int {
-  Unset = -1,         ///< init value
-  Linear = 0,         ///< map(lumi) = (mean_map - referenceMap) * lumiScale + referenceMap
-  DerivativeMap = 1,  ///< map(lumi) = mean_map + lumiScale * (derivativeMap) where derivativeMap = (mean_map_A - mean_map_B)
-  DerivativeMapMC = 2 ///< same DerivativeMap, but for MC
+  Unset = -1,          ///< init value
+  Linear = 0,          ///< map(lumi) = (mean_map - referenceMap) * lumiScale + referenceMap
+  DerivativeMap = 1,   ///< map(lumi) = mean_map + lumiScale * (derivativeMap) where derivativeMap = (mean_map_A - mean_map_B)
+  DerivativeMapMC = 2, ///< same DerivativeMap, but for MC
+  NoCorrection = 3,    ///< no corrections at all
+  StaticMapOnly = 4,   ///< use only static map instead of main map
+  Count                ///< sentinel - keep last
 };
 
 struct CorrectionMapsGloOpts {

From aa96c1a9fd301f775c2ab3a04d49fe890c03782d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Thu, 21 May 2026 12:00:34 +0200
Subject: [PATCH 1747/1764] IOTOF: align geometry to specs (#15414)

- add macro to draw geometry
- streamline setup of IOTOF active layers
---
 .../ALICE3/IOTOF/macros/CMakeLists.txt        |  3 +
 .../ALICE3/IOTOF/macros/drawTOFGeometry.C     | 90 +++++++++++++++++++
 .../ALICE3/IOTOF/simulation/src/Detector.cxx  | 29 ++++--
 .../ALICE3/IOTOF/simulation/src/Layer.cxx     | 53 ++++++++---
 4 files changed, 156 insertions(+), 19 deletions(-)
 create mode 100644 Detectors/Upgrades/ALICE3/IOTOF/macros/drawTOFGeometry.C

diff --git a/Detectors/Upgrades/ALICE3/IOTOF/macros/CMakeLists.txt b/Detectors/Upgrades/ALICE3/IOTOF/macros/CMakeLists.txt
index b2f1857186c0b..41b800ed114b4 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/macros/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/IOTOF/macros/CMakeLists.txt
@@ -11,3 +11,6 @@
 
 o2_add_test_root_macro(defineIOTOFGeo.C
                        LABELS alice3)
+
+o2_add_test_root_macro(drawTOFGeometry.C
+                       LABELS alice3)
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/macros/drawTOFGeometry.C b/Detectors/Upgrades/ALICE3/IOTOF/macros/drawTOFGeometry.C
new file mode 100644
index 0000000000000..4e58fb54fbf6e
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/IOTOF/macros/drawTOFGeometry.C
@@ -0,0 +1,90 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "IOTOFBase/GeometryTGeo.h"
+#include "IOTOFSimulation/Layer.h"
+
+#include <TCanvas.h>
+#include <TGeoManager.h>
+#include <TGeoMaterial.h>
+#include <TGeoMatrix.h>
+#include <TGeoVolume.h>
+#include <TStyle.h>
+
+#include <iostream>
+
+namespace
+{
+void ensureMedium(const char* name, int id, double a, double z, double density)
+{
+  if (!gGeoManager->GetMedium(name)) {
+    auto* mat = new TGeoMaterial(name, a, z, density);
+    new TGeoMedium(name, id, mat);
+  }
+}
+
+void prepareMinimalMedia()
+{
+  ensureMedium("VACUUM$", 0, 1., 1., 1.e-16);
+  ensureMedium("TF3_AIR$", 1, 14.61, 7.3, 1.20479e-3);
+  ensureMedium("TF3_SILICON$", 3, 28.086, 14., 2.33);
+}
+} // namespace
+
+void drawTOFGeometry(double x2x0 = 0.02,
+                     double sensorThickness = 0.005,
+                     bool checkOverlaps = true,
+                     double overlapToleranceCm = 0.01)
+{
+  gStyle->SetOptStat(0);
+
+  if (gGeoManager) {
+    delete gGeoManager;
+  }
+
+  auto* geo = new TGeoManager("IOTOFGeomFromLayer", "Geometry built from Layer.h classes");
+  prepareMinimalMedia();
+
+  auto* top = geo->MakeBox("TOP", geo->GetMedium("VACUUM$"), 1200., 1200., 1200.);
+  geo->SetTopVolume(top);
+
+  auto* mother = new TGeoVolumeAssembly("IOTOFMacroVol");
+  top->AddNode(mother, 1, new TGeoTranslation(0., 0., 0.));
+
+  // Build using the same classes and createLayer() used by detector geometry code.
+  o2::iotof::ITOFLayer itof(o2::iotof::GeometryTGeo::getITOFLayerPattern(),
+                            21.f, 0.f, 129.f, 0.f, x2x0,
+                            o2::iotof::Layer::kBarrelSegmented,
+                            24, 5.42, 3.0, 10, sensorThickness);
+
+  o2::iotof::OTOFLayer otof(o2::iotof::GeometryTGeo::getOTOFLayerPattern(),
+                            92.f, 0.f, 680.f, 0.f, x2x0,
+                            o2::iotof::Layer::kBarrelSegmented,
+                            62, 9.74, 5.0, 54, sensorThickness);
+
+  itof.createLayer(mother);
+  otof.createLayer(mother);
+
+  geo->CloseGeometry();
+
+  std::cout << "Built geometry from Layer.h classes with x2x0=" << x2x0
+            << " and sensorThickness=" << sensorThickness << " cm\n";
+  std::cout << "ITOF sensitive volumes: " << o2::iotof::ITOFLayer::mRegister.size() << "\n";
+  std::cout << "OTOF sensitive volumes: " << o2::iotof::OTOFLayer::mRegister.size() << "\n";
+
+  if (checkOverlaps) {
+    std::cout << "Checking overlaps with tolerance=" << overlapToleranceCm << " cm\n";
+    geo->CheckOverlaps(overlapToleranceCm);
+    geo->PrintOverlaps();
+  }
+
+  top->Draw("ogl");
+}
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
index bed8cbfd6dfac..ab9a68bd401ec 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Detector.cxx
@@ -200,28 +200,47 @@ void Detector::defineSensitiveVolumes()
   TGeoManager* geoManager = gGeoManager;
   TGeoVolume* v;
 
-  // The names of the IOTOF sensitive volumes have the format: IOTOFLayer(0...mLayers.size()-1)
   auto& iotofPars = IOTOFBaseParam::Instance();
-  if (iotofPars.enableInnerTOF) {
+  const bool itof = iotofPars.enableInnerTOF;
+  const bool otof = iotofPars.enableOuterTOF;
+  bool ftof = iotofPars.enableForwardTOF;
+  bool btof = iotofPars.enableBackwardTOF;
+  const std::string pattern = iotofPars.detectorPattern;
+  if (pattern == "") {
+    LOG(info) << "Default pattern";
+  } else if (pattern == "v3b") {
+    ftof = false;
+    btof = false;
+  } else if (pattern == "v3b1a") {
+  } else if (pattern == "v3b1b") {
+  } else if (pattern == "v3b2a") {
+  } else if (pattern == "v3b2b") {
+  } else if (pattern == "v3b3") {
+  } else {
+    LOG(fatal) << "IOTOF layer pattern " << pattern << " not recognized, exiting";
+  }
+
+  // The names of the IOTOF sensitive volumes have the format: IOTOFLayer(0...mLayers.size()-1)
+  if (itof) {
     for (const std::string& itofSensor : ITOFLayer::mRegister) {
       v = geoManager->GetVolume(itofSensor.c_str());
       LOGP(info, "Adding IOTOF Sensitive Volume {}", v->GetName());
       AddSensitiveVolume(v);
     }
   }
-  if (iotofPars.enableOuterTOF) {
+  if (otof) {
     for (const std::string& otofSensor : OTOFLayer::mRegister) {
       v = geoManager->GetVolume(otofSensor.c_str());
       LOGP(info, "Adding IOTOF Sensitive Volume {}", v->GetName());
       AddSensitiveVolume(v);
     }
   }
-  if (iotofPars.enableForwardTOF) {
+  if (ftof) {
     v = geoManager->GetVolume(GeometryTGeo::getFTOFSensorPattern());
     LOGP(info, "Adding IOTOF Sensitive Volume {}", v->GetName());
     AddSensitiveVolume(v);
   }
-  if (iotofPars.enableBackwardTOF) {
+  if (btof) {
     v = geoManager->GetVolume(GeometryTGeo::getBTOFSensorPattern());
     LOGP(info, "Adding IOTOF Sensitive Volume {}", v->GetName());
     AddSensitiveVolume(v);
diff --git a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
index 627fb599ff8ae..f2e42e1bce172 100644
--- a/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
+++ b/Detectors/Upgrades/ALICE3/IOTOF/simulation/src/Layer.cxx
@@ -296,12 +296,24 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
     case kBarrelSegmented: {
       // First we create the volume for the whole layer, which will be used as mother volume for the segments
       const double avgRadius = 0.5 * (mInnerRadius + mOuterRadius);
-      const double staveSizeX = mStaves.second;                                                                                                                    // cm
-      const double staveSizeY = mOuterRadius - mInnerRadius;                                                                                                       // cm
-      const double staveSizeZ = mZLength;                                                                                                                          // cm
-      const double deltaForTilt = 0.5 * (std::sin(TMath::DegToRad() * mTiltAngle) * staveSizeX + std::cos(TMath::DegToRad() * mTiltAngle) * staveSizeY);           // we increase the size of the layer to account for the tilt of the staves
-      const double radiusMax = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY + avgRadius * 2. * deltaForTilt); // we increase the outer radius to account for the tilt of the staves
-      const double radiusMin = std::sqrt(avgRadius * avgRadius + 0.25 * staveSizeX * staveSizeX + 0.25 * staveSizeY * staveSizeY - avgRadius * 2. * deltaForTilt); // we decrease the inner radius to account for the tilt of the staves
+      const double staveSizeX = mStaves.second;              // cm, tangential stave size
+      const double staveSizeY = mOuterRadius - mInnerRadius; // cm, radial stave size
+      const double staveSizeZ = mZLength;                    // cm
+
+      // Build the mother layer tube from the exact inscribed/outscribed radii of a tilted stave rectangle.
+      const double alpha = mTiltAngle * TMath::DegToRad();
+      const double u0 = -avgRadius * std::cos(alpha);
+      const double v0 = avgRadius * std::sin(alpha);
+      const double uClamped = std::max(-0.5 * staveSizeY, std::min(0.5 * staveSizeY, u0));
+      const double vClamped = std::max(-0.5 * staveSizeX, std::min(0.5 * staveSizeX, v0));
+      const double radiusMin = std::hypot(uClamped - u0, vClamped - v0);
+
+      const double uCorners[4] = {-0.5 * staveSizeY, 0.5 * staveSizeY, 0.5 * staveSizeY, -0.5 * staveSizeY};
+      const double vCorners[4] = {-0.5 * staveSizeX, -0.5 * staveSizeX, 0.5 * staveSizeX, 0.5 * staveSizeX};
+      double radiusMax = 0.0;
+      for (int i = 0; i < 4; ++i) {
+        radiusMax = std::max(radiusMax, std::hypot(uCorners[i] - u0, vCorners[i] - v0));
+      }
       TGeoTube* layer = new TGeoTube(radiusMin, radiusMax, mZLength / 2);
       TGeoVolume* layerVol = new TGeoVolume(mLayerName.c_str(), layer, medAir);
       setLayerStyle(layerVol);
@@ -312,10 +324,21 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
       setStaveStyle(staveVol);
 
       // Now we create the volume for a single module (sensor + chip)
-      const int modulesPerStaveX = 1;                           // we assume that each stave is divided in 2 modules along the x direction
-      const double moduleSizeX = staveSizeX / modulesPerStaveX; // cm
-      const double moduleSizeY = staveSizeY;                    // cm
-      const double moduleSizeZ = staveSizeZ / mModulesPerStave; // cm
+      // oTOF V2 is a 2xN matrix of modules per stave with overlap along z.
+      const int modulesPerStaveX = 2;
+      if (mModulesPerStave % modulesPerStaveX != 0) {
+        LOG(fatal) << "Invalid oTOF module layout: total modules per stave " << mModulesPerStave
+                   << " is not divisible by modulesPerStaveX=" << modulesPerStaveX;
+      }
+      const int modulesPerStaveZ = mModulesPerStave / modulesPerStaveX;
+      const double moduleOverlapZ = 0.7; // cm, 7 mm longitudinal overlap from oTOF V2 specs
+      const double moduleSizeX = staveSizeX / modulesPerStaveX;
+      const double moduleSizeY = staveSizeY;
+      const double moduleSizeZ = (staveSizeZ + (modulesPerStaveZ - 1) * moduleOverlapZ) / modulesPerStaveZ;
+      const double modulePitchZ = moduleSizeZ - moduleOverlapZ;
+      if (modulePitchZ <= 0.0) {
+        LOG(fatal) << "Invalid oTOF module overlap " << moduleOverlapZ << " cm for module size " << moduleSizeZ << " cm";
+      }
       TGeoBBox* module = new TGeoBBox(moduleSizeX * 0.5, moduleSizeY * 0.5, moduleSizeZ * 0.5);
       TGeoVolume* moduleVol = new TGeoVolume(moduleName, module, medAir);
       setModuleStyle(moduleVol);
@@ -363,10 +386,12 @@ void OTOFLayer::createLayer(TGeoVolume* motherVolume)
 
       // Now we build a stave from modules
       for (int i = 0; i < modulesPerStaveX; ++i) {
-        for (int j = 0; j < mModulesPerStave; ++j) {
-          LOGP(info, "oTOF: Creating module {}/{} for stave {}/{}", i + 1, modulesPerStaveX, j + 1, mModulesPerStave);
-          auto* translation = new TGeoTranslation((i + 0.5) * moduleSizeX - 0.5 * staveSizeX, 0, (j + 0.5) * moduleSizeZ - 0.5 * staveSizeZ);
-          staveVol->AddNode(moduleVol, 1 + i * mModulesPerStave + j, translation);
+        for (int j = 0; j < modulesPerStaveZ; ++j) {
+          LOGP(info, "oTOF: Creating module {}/{} for stave {}/{}", i + 1, modulesPerStaveX, j + 1, modulesPerStaveZ);
+          const double tx = (i + 0.5) * moduleSizeX - 0.5 * staveSizeX;
+          const double tz = -0.5 * staveSizeZ + 0.5 * moduleSizeZ + j * modulePitchZ;
+          auto* translation = new TGeoTranslation(tx, 0, tz);
+          staveVol->AddNode(moduleVol, 1 + i * modulesPerStaveZ + j, translation);
         }
       }
 

From f017263d5da7a08e808cbb061139195cd2bf4a31 Mon Sep 17 00:00:00 2001
From: Maximiliano Puccio <mpuccio@users.noreply.github.com>
Date: Thu, 21 May 2026 12:18:14 +0200
Subject: [PATCH 1748/1764] ALICE3: factor GPU tracking into dynamically loaded
 CUDA/HIP backend (#15420)

---
 .../reconstruction/CMakeLists.txt             |  33 +--
 ...lAllocator.cxx => GPUExternalAllocator.cu} |  37 +--
 .../workflow/CMakeLists.txt                   |  34 +++
 .../TrackerSpec.h                             |  10 +
 .../TrackerSpecImpl.h                         | 226 ++++++++++++++++
 .../workflow/src/TrackerSpec.cxx              | 250 +++---------------
 .../workflow/src/TrackerSpecGPU.cxx           |  28 ++
 7 files changed, 342 insertions(+), 276 deletions(-)
 rename Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/{GPUExternalAllocator.cxx => GPUExternalAllocator.cu} (81%)
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpecImpl.h
 create mode 100644 Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpecGPU.cxx

diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt
index 8805c1885b079..1dfcb7a22f725 100644
--- a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/CMakeLists.txt
@@ -13,24 +13,9 @@ if(Acts_FOUND)
   set(actsTarget Acts::Core)
 endif()
 
-set(alice3GlobalRecoGpuSources "")
-set(alice3GlobalRecoGpuTargets "")
-set(alice3GlobalRecoGpuPrivateTargets "")
-if(CUDA_ENABLED)
-  find_package(CUDAToolkit REQUIRED)
-  list(APPEND alice3GlobalRecoGpuSources src/TimeFrameGPU.cxx src/GPUExternalAllocator.cxx)
-  list(APPEND alice3GlobalRecoGpuTargets O2::ITStrackingCUDA)
-  list(APPEND alice3GlobalRecoGpuPrivateTargets CUDA::cudart)
-elseif(HIP_ENABLED)
-  list(APPEND alice3GlobalRecoGpuSources src/TimeFrameGPU.cxx src/GPUExternalAllocator.cxx)
-  list(APPEND alice3GlobalRecoGpuTargets O2::ITStrackingHIP)
-  list(APPEND alice3GlobalRecoGpuPrivateTargets hip::host)
-endif()
-
 o2_add_library(ALICE3GlobalReconstruction
                TARGETVARNAME targetName
                SOURCES src/TimeFrame.cxx
-                       ${alice3GlobalRecoGpuSources}
                        $<$<BOOL:${Acts_FOUND}>:src/TrackerACTS.cxx>
                PUBLIC_LINK_LIBRARIES
                        O2::ITStracking
@@ -48,26 +33,10 @@ o2_add_library(ALICE3GlobalReconstruction
                        O2::TRKReconstruction
                        O2::TRKSimulation
                        nlohmann_json::nlohmann_json
-                       ${alice3GlobalRecoGpuTargets}
                        ${actsTarget}
                PRIVATE_LINK_LIBRARIES
                        O2::Steer
-                       TBB::tbb
-                       ${alice3GlobalRecoGpuPrivateTargets})
-
-if(alice3GlobalRecoGpuTargets)
-  target_compile_definitions(${targetName} PUBLIC TRK_HAS_GPU_TRACKING)
-endif()
-
-if(CUDA_ENABLED)
-  target_include_directories(${targetName} PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
-endif()
-
-if(CUDA_ENABLED)
-  target_compile_definitions(${targetName} PUBLIC TRK_HAS_CUDA_TRACKING)
-elseif(HIP_ENABLED)
-  target_compile_definitions(${targetName} PUBLIC TRK_HAS_HIP_TRACKING)
-endif()
+                       TBB::tbb)
 
 if(Acts_FOUND)
   target_compile_definitions(${targetName} PUBLIC O2_WITH_ACTS)
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cu
similarity index 81%
rename from Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cxx
rename to Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cu
index df2a2c30b037a..c7b5f1cee50f5 100644
--- a/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cxx
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/reconstruction/src/GPUExternalAllocator.cu
@@ -9,11 +9,9 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
-#if defined(TRK_HAS_CUDA_TRACKING)
+#define GPUCA_GPUCODE_HOSTONLY
+
 #include <cuda_runtime.h>
-#elif defined(TRK_HAS_HIP_TRACKING)
-#include <hip/hip_runtime.h>
-#endif
 
 #include "ALICE3GlobalReconstruction/GPUExternalAllocator.h"
 
@@ -23,21 +21,12 @@
 
 namespace
 {
-#if defined(TRK_HAS_CUDA_TRACKING)
 void checkGpuError(cudaError_t error, const char* call)
 {
   if (error != cudaSuccess) {
     throw std::runtime_error(std::string(call) + ": " + cudaGetErrorString(error));
   }
 }
-#elif defined(TRK_HAS_HIP_TRACKING)
-void checkGpuError(hipError_t error, const char* call)
-{
-  if (error != hipSuccess) {
-    throw std::runtime_error(std::string(call) + ": " + hipGetErrorString(error));
-  }
-}
-#endif
 } // namespace
 
 namespace o2::trk
@@ -147,26 +136,14 @@ void GPUExternalAllocator::releaseAll()
 void* GPUExternalAllocator::allocateHost(size_t size)
 {
   void* ptr = nullptr;
-#if defined(TRK_HAS_CUDA_TRACKING)
   checkGpuError(cudaHostAlloc(&ptr, size, cudaHostAllocPortable), "cudaHostAlloc");
-#elif defined(TRK_HAS_HIP_TRACKING)
-  checkGpuError(hipHostMalloc(&ptr, size, hipHostMallocPortable), "hipHostMalloc");
-#else
-  throw std::runtime_error("GPUExternalAllocator built without a GPU backend");
-#endif
   return ptr;
 }
 
 void* GPUExternalAllocator::allocateDevice(size_t size)
 {
   void* ptr = nullptr;
-#if defined(TRK_HAS_CUDA_TRACKING)
   checkGpuError(cudaMalloc(&ptr, size), "cudaMalloc");
-#elif defined(TRK_HAS_HIP_TRACKING)
-  checkGpuError(hipMalloc(&ptr, size), "hipMalloc");
-#else
-  throw std::runtime_error("GPUExternalAllocator built without a GPU backend");
-#endif
   return ptr;
 }
 
@@ -176,21 +153,11 @@ void GPUExternalAllocator::freeAllocation(void* ptr, AllocationSpace space)
     return;
   }
 
-#if defined(TRK_HAS_CUDA_TRACKING)
   if (space == AllocationSpace::Host) {
     checkGpuError(cudaFreeHost(ptr), "cudaFreeHost");
   } else {
     checkGpuError(cudaFree(ptr), "cudaFree");
   }
-#elif defined(TRK_HAS_HIP_TRACKING)
-  if (space == AllocationSpace::Host) {
-    checkGpuError(hipHostFree(ptr), "hipHostFree");
-  } else {
-    checkGpuError(hipFree(ptr), "hipFree");
-  }
-#else
-  (void)space;
-#endif
 }
 
 void GPUExternalAllocator::removeFromTagLocked(uint64_t tag, void* ptr)
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/CMakeLists.txt b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/CMakeLists.txt
index be6add9c03483..6a4994e11467b 100644
--- a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/CMakeLists.txt
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/CMakeLists.txt
@@ -24,8 +24,42 @@ o2_add_library(ALICE3GlobalReconstructionWorkflow
                                      O2::TRKBase
                                      O2::TRKSimulation
                                      O2::ALICE3GlobalReconstruction
+                                     O2::CommonUtils
                                      nlohmann_json::nlohmann_json)
 
+if(CUDA_ENABLED OR HIP_ENABLED)
+  target_compile_definitions(${targetName} PUBLIC TRK_HAS_GPU_TRACKING)
+endif()
+
+if(CUDA_ENABLED)
+  find_package(CUDAToolkit REQUIRED)
+  target_compile_definitions(${targetName} PUBLIC TRK_HAS_CUDA_TRACKING)
+  o2_add_library(ALICE3GlobalReconstructionWorkflowCUDA
+                 TARGETVARNAME cudaTargetName
+                 SOURCES src/TrackerSpecGPU.cxx
+                         ../reconstruction/src/TimeFrameGPU.cxx
+                         ../reconstruction/src/GPUExternalAllocator.cu
+                 PUBLIC_LINK_LIBRARIES
+                         O2::ALICE3GlobalReconstructionWorkflow
+                         O2::ITStrackingCUDA
+                 PRIVATE_LINK_LIBRARIES
+                         CUDA::cudart)
+  target_include_directories(${cudaTargetName} PRIVATE ${CUDAToolkit_INCLUDE_DIRS})
+endif()
+
+if(HIP_ENABLED)
+  target_compile_definitions(${targetName} PUBLIC TRK_HAS_HIP_TRACKING)
+  o2_add_hipified_library(ALICE3GlobalReconstructionWorkflowHIP
+                          SOURCES src/TrackerSpecGPU.cxx
+                                  ../reconstruction/src/TimeFrameGPU.cxx
+                                  ../reconstruction/src/GPUExternalAllocator.cu
+                          PUBLIC_LINK_LIBRARIES
+                                  O2::ALICE3GlobalReconstructionWorkflow
+                                  O2::ITStrackingHIP
+                          PRIVATE_LINK_LIBRARIES
+                                  hip::host)
+endif()
+
 o2_add_executable(reco-workflow
                   SOURCES src/alice3-global-reconstruction-workflow.cxx
                   COMPONENT_NAME alice3-global-reconstruction
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpec.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpec.h
index 006bb4cbf5260..c1e7e051fb3f1 100644
--- a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpec.h
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpec.h
@@ -32,6 +32,10 @@
 
 #include <nlohmann/json.hpp>
 
+#include <memory>
+#include <utility>
+#include <vector>
+
 namespace o2::trk
 {
 class TrackerDPL : public framework::Task
@@ -48,10 +52,15 @@ class TrackerDPL : public framework::Task
   void endOfStream(framework::EndOfStreamContext& ec) final;
   //   void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj) final;
   void stop() final;
+  template <typename TimeFrameT, typename TrackerTraitsT>
+  void runTracking(framework::ProcessingContext& pc, TimeFrameT& timeFrame, TrackerTraitsT& trackerTraits);
+  const std::shared_ptr<its::ExternalAllocator>& getGPUAllocator() const noexcept { return mGPUAllocator; }
+  void setGPUAllocator(std::shared_ptr<its::ExternalAllocator> allocator) { mGPUAllocator = std::move(allocator); }
 
  private:
   void updateTimeDependentParams(framework::ProcessingContext& pc);
   std::vector<o2::its::TrackingParameters> createTrackingParamsFromConfig();
+  void runGPUTracking(framework::ProcessingContext& pc);
   //   std::unique_ptr<o2::gpu::GPUReconstruction> mRecChain = nullptr;
   //   std::unique_ptr<o2::gpu::GPUChainITS> mChainITS = nullptr;
   //   std::shared_ptr<o2::base::GRPGeomRequest> mGGCCDBRequest;
@@ -61,6 +70,7 @@ class TrackerDPL : public framework::Task
   std::shared_ptr<its::BoundedMemoryResource> mMemoryPool;
   std::shared_ptr<its::ExternalAllocator> mGPUAllocator;
   std::shared_ptr<tbb::task_arena> mTaskArena;
+  std::vector<o2::its::TrackingParameters> mTrackingParams;
   nlohmann::json mHitRecoConfig;
   nlohmann::json mClusterRecoConfig;
   TStopwatch mTimer;
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpecImpl.h b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpecImpl.h
new file mode 100644
index 0000000000000..f6221e485f369
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/include/ALICE3GlobalReconstructionWorkflow/TrackerSpecImpl.h
@@ -0,0 +1,226 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_TRK_TRACKERSPECIMPL_H
+#define O2_TRK_TRACKERSPECIMPL_H
+
+#include "ALICE3GlobalReconstructionWorkflow/TrackerSpec.h"
+
+#include "CommonDataFormat/IRFrame.h"
+#include "DataFormatsTRK/Cluster.h"
+#include "DataFormatsTRK/ROFRecord.h"
+#include "DetectorsBase/GeometryManager.h"
+#include "Field/MagFieldParam.h"
+#include "Field/MagneticField.h"
+#include "Framework/ControlService.h"
+#include "ITStracking/Tracker.h"
+#include "SimulationDataFormat/MCCompLabel.h"
+#include "SimulationDataFormat/MCEventHeader.h"
+#include "SimulationDataFormat/MCTruthContainer.h"
+#include "TRKBase/GeometryTGeo.h"
+#include "TRKSimulation/Hit.h"
+
+#include <TFile.h>
+#include <TGeoGlobalMagField.h>
+#include <TTree.h>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <format>
+#include <numeric>
+#include <vector>
+
+namespace o2::trk
+{
+
+template <typename TimeFrameT, typename TrackerTraitsT>
+void TrackerDPL::runTracking(framework::ProcessingContext& pc, TimeFrameT& timeFrame, TrackerTraitsT& trackerTraits)
+{
+  o2::its::Tracker<11> itsTracker(&trackerTraits);
+  timeFrame.setMemoryPool(mMemoryPool);
+  trackerTraits.setMemoryPool(mMemoryPool);
+  trackerTraits.setNThreads(mTaskArena->max_concurrency(), mTaskArena);
+  trackerTraits.adoptTimeFrame(static_cast<o2::its::TimeFrame<11>*>(&timeFrame));
+  itsTracker.adoptTimeFrame(timeFrame);
+  trackerTraits.updateTrackingParameters(mTrackingParams);
+  timeFrame.initTrackerTopologies(mTrackingParams, 11);
+
+  int nRofs{0};
+  if (!mHitRecoConfig.empty()) {
+    TFile hitsFile(mHitRecoConfig["inputfiles"]["hits"].get<std::string>().c_str(), "READ");
+    TFile mcHeaderFile(mHitRecoConfig["inputfiles"]["mcHeader"].get<std::string>().c_str(), "READ");
+    TTree* hitsTree = hitsFile.Get<TTree>("o2sim");
+    std::vector<o2::trk::Hit>* trkHit = nullptr;
+    hitsTree->SetBranchAddress("TRKHit", &trkHit);
+
+    TTree* mcHeaderTree = mcHeaderFile.Get<TTree>("o2sim");
+    auto mcheader = new o2::dataformats::MCEventHeader;
+    mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
+
+    o2::base::GeometryManager::loadGeometry(mHitRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
+    auto* gman = o2::trk::GeometryTGeo::Instance();
+
+    const Long64_t nEvents{hitsTree->GetEntries()};
+    LOGP(info, "Starting {} reconstruction from hits for {} events", trackerTraits.getName(), nEvents);
+
+    trackerTraits.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
+    auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mHitRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
+    TGeoGlobalMagField::Instance()->SetField(field);
+    TGeoGlobalMagField::Instance()->Lock();
+
+    nRofs = timeFrame.loadROFsFromHitTree(hitsTree, gman, mHitRecoConfig);
+    const int inROFpileup{mHitRecoConfig.contains("inROFpileup") ? mHitRecoConfig["inROFpileup"].get<int>() : 1};
+    timeFrame.getPrimaryVerticesFromMC(mcHeaderTree, nRofs, nEvents, inROFpileup);
+  } else if (!mClusterRecoConfig.empty()) {
+    LOGP(info, "Starting {} reconstruction from clusters", trackerTraits.getName());
+
+    o2::base::GeometryManager::loadGeometry(mClusterRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
+    o2::trk::GeometryTGeo::Instance();
+
+    trackerTraits.setBz(mClusterRecoConfig["geometry"]["bz"].get<float>());
+    auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mClusterRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
+    TGeoGlobalMagField::Instance()->SetField(field);
+    TGeoGlobalMagField::Instance()->Lock();
+
+    constexpr int nLayers{11};
+    std::array<gsl::span<const o2::trk::Cluster>, nLayers> layerClusters;
+    std::array<gsl::span<const unsigned char>, nLayers> layerPatterns;
+    std::array<gsl::span<const o2::trk::ROFRecord>, nLayers> layerROFs;
+    std::array<const dataformats::MCTruthContainer<MCCompLabel>*, nLayers> layerLabels{};
+
+    size_t nInputRofs{0};
+    for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
+      layerClusters[iLayer] = pc.inputs().get<gsl::span<o2::trk::Cluster>>(std::format("compClusters_{}", iLayer));
+      layerPatterns[iLayer] = pc.inputs().get<gsl::span<unsigned char>>(std::format("patterns_{}", iLayer));
+      layerROFs[iLayer] = pc.inputs().get<gsl::span<o2::trk::ROFRecord>>(std::format("ROframes_{}", iLayer));
+      nInputRofs = std::max(nInputRofs, layerROFs[iLayer].size());
+      if (mIsMC) {
+        layerLabels[iLayer] = pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>(std::format("trkmclabels_{}", iLayer)).release();
+      }
+    }
+
+    timeFrame.deriveAndInitTiming(layerROFs);
+
+    const float yPlaneMLOT = 0.0010f;
+    nRofs = timeFrame.loadROFrameData(layerROFs, layerClusters, layerPatterns, mIsMC ? &layerLabels : nullptr, yPlaneMLOT);
+    timeFrame.addTruthSeedingVertices();
+  }
+
+  const auto trackingLoopStart = std::chrono::steady_clock::now();
+  for (size_t iter{0}; iter < mTrackingParams.size(); ++iter) {
+    LOGP(info, "{}", mTrackingParams[iter].asString());
+    trackerTraits.initialiseTimeFrame(iter);
+    trackerTraits.computeLayerTracklets(iter, -1);
+    LOGP(info, "Number of tracklets in iteration {}: {}", iter, timeFrame.getNumberOfTracklets());
+    trackerTraits.computeLayerCells(iter);
+    LOGP(info, "Number of cells in iteration {}: {}", iter, timeFrame.getNumberOfCells());
+    trackerTraits.findCellsNeighbours(iter);
+    LOGP(info, "Number of cell neighbours in iteration {}: {}", iter, timeFrame.getNumberOfNeighbours());
+    trackerTraits.findRoads(iter);
+    LOGP(info, "Number of roads in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
+  }
+  const auto trackingLoopElapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - trackingLoopStart).count();
+  LOGP(info, "Tracking iterations block took {} ms", trackingLoopElapsedMs);
+
+  if (mIsMC) {
+    itsTracker.computeTracksMClabels();
+  }
+
+  const auto& tracks = timeFrame.getTracks();
+  const auto& labels = timeFrame.getTracksLabel();
+  std::vector<o2::its::TrackITS> allTracks(tracks.begin(), tracks.end());
+  std::vector<o2::MCCompLabel> allLabels;
+
+  int totalTracks = allTracks.size();
+  int goodTracks = 0;
+  int fakeTracks = 0;
+
+  if (mIsMC) {
+    allLabels.assign(labels.begin(), labels.end());
+    for (const auto& label : allLabels) {
+      if (label.isFake()) {
+        ++fakeTracks;
+      } else {
+        ++goodTracks;
+      }
+    }
+  }
+
+  LOGP(info, "=== Tracking Summary ===");
+  LOGP(info, "Total tracks reconstructed: {}", totalTracks);
+  LOGP(info, "Good tracks: {} ({:.1f}%)", goodTracks, totalTracks > 0 ? 100.0 * goodTracks / totalTracks : 0);
+  LOGP(info, "Fake tracks: {} ({:.1f}%)", fakeTracks, totalTracks > 0 ? 100.0 * fakeTracks / totalTracks : 0);
+
+  const auto& rofView = timeFrame.getROFOverlapTableView();
+  const auto& clockLayer = rofView.getClockLayer();
+  const int clockLayerId = rofView.getClock();
+  const int64_t anchorBC = timeFrame.getTFAnchorIR().toLong();
+
+  int highestROF = static_cast<int>(clockLayer.mNROFsTF);
+  for (const auto& trc : allTracks) {
+    highestROF = std::max(highestROF, static_cast<int>(clockLayer.getROF(trc.getTimeStamp())));
+  }
+  for (const auto& vtx : timeFrame.getPrimaryVertices()) {
+    highestROF = std::max(highestROF, static_cast<int>(clockLayer.getROF(vtx.getTimeStamp().lower())));
+  }
+
+  std::vector<o2::trk::ROFRecord> allTrackROFs(highestROF);
+  for (size_t iROF = 0; iROF < allTrackROFs.size(); ++iROF) {
+    auto& rof = allTrackROFs[iROF];
+    o2::InteractionRecord ir;
+    ir.setFromLong(anchorBC + static_cast<int64_t>(clockLayer.getROFStartInBC(iROF)));
+    rof.setBCData(ir);
+    rof.setROFrame(iROF);
+    rof.setFirstEntry(0);
+    rof.setNEntries(0);
+  }
+
+  std::vector<int> rofEntries(highestROF + 1, 0);
+  for (const auto& trc : allTracks) {
+    const int rof = static_cast<int>(clockLayer.getROF(trc.getTimeStamp()));
+    if (rof >= 0 && rof < highestROF) {
+      ++rofEntries[rof];
+    }
+  }
+  std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
+
+  std::vector<o2::dataformats::IRFrame> irFrames;
+  irFrames.reserve(allTrackROFs.size());
+  const auto& maskView = timeFrame.getROFMaskView();
+  const auto rofLenMinus1 = clockLayer.mROFLength > 0 ? clockLayer.mROFLength - 1 : 0;
+  for (size_t iROF = 0; iROF < allTrackROFs.size(); ++iROF) {
+    allTrackROFs[iROF].setFirstEntry(rofEntries[iROF]);
+    allTrackROFs[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
+    if (maskView.isROFEnabled(clockLayerId, static_cast<int>(iROF))) {
+      const auto& bcStart = allTrackROFs[iROF].getBCData();
+      auto& irFrame = irFrames.emplace_back(bcStart, bcStart + rofLenMinus1);
+      irFrame.info = allTrackROFs[iROF].getNEntries();
+    }
+  }
+
+  pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKS", 0}, allTracks);
+  pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSROF", 0}, allTrackROFs);
+  pc.outputs().snapshot(o2::framework::Output{"TRK", "IRFRAMES", 0}, irFrames);
+  if (mIsMC) {
+    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSMCTR", 0}, allLabels);
+  }
+
+  LOGP(info, "TRK pushed {} tracks in {} ROFs and {} IR frames{}",
+       allTracks.size(), allTrackROFs.size(), irFrames.size(),
+       mIsMC ? " (with MC labels)" : "");
+
+  timeFrame.wipe();
+}
+
+} // namespace o2::trk
+
+#endif // O2_TRK_TRACKERSPECIMPL_H
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
index 9fb2899ab3ef5..6f9f5561a5ef6 100644
--- a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
@@ -17,6 +17,7 @@
 #include <fstream>
 #include <numeric>
 
+#include "CommonUtils/DLLoaderBase.h"
 #include "CommonDataFormat/IRFrame.h"
 #include "DataFormatsTRK/Cluster.h"
 #include "DataFormatsTRK/ROFRecord.h"
@@ -36,12 +37,8 @@
 #include "TRKBase/SegmentationChip.h"
 #include "TRKSimulation/Hit.h"
 #include "ALICE3GlobalReconstruction/TimeFrame.h"
-#ifdef TRK_HAS_GPU_TRACKING
-#include "ALICE3GlobalReconstruction/TimeFrameGPU.h"
-#include "ALICE3GlobalReconstruction/GPUExternalAllocator.h"
-#include "ITStrackingGPU/TrackerTraitsGPU.h"
-#endif
 #include "ALICE3GlobalReconstructionWorkflow/TrackerSpec.h"
+#include "ALICE3GlobalReconstructionWorkflow/TrackerSpecImpl.h"
 #include <TGeoGlobalMagField.h>
 
 #ifdef O2_WITH_ACTS
@@ -58,6 +55,18 @@ namespace trk
 {
 using Vertex = o2::dataformats::Vertex<o2::dataformats::TimeStamp<int>>;
 
+namespace
+{
+class ALICE3TrackingBackendLoader : public o2::utils::DLLoaderBase<ALICE3TrackingBackendLoader>
+{
+  O2DLLoaderDef(ALICE3TrackingBackendLoader)
+};
+
+O2DLLoaderImpl(ALICE3TrackingBackendLoader)
+
+  constexpr const char* kGPUBackendFunction = "runALICE3GPUTracking";
+} // namespace
+
 TrackerDPL::TrackerDPL(std::shared_ptr<o2::base::GRPGeomRequest> gr,
                        bool isMC,
                        const std::string& hitRecoConfigFileName,
@@ -249,220 +258,20 @@ void TrackerDPL::run(ProcessingContext& pc)
     mTaskArena = std::make_shared<tbb::task_arena>(1); /// TODO: make it configurable
   }
 
-  auto trackingParams = createTrackingParamsFromConfig();
+  mTrackingParams = createTrackingParamsFromConfig();
 
   auto cput = mTimer.CpuTime();
   auto realt = mTimer.RealTime();
   mTimer.Start(false);
 
   const bool useGPU = mDeviceType != o2::gpu::gpudatatypes::DeviceType::CPU;
-#ifndef TRK_HAS_GPU_TRACKING
-  if (useGPU) {
-    LOGP(fatal, "TRK GPU tracking was requested but this build has no TRK GPU tracking backend");
-  }
-#else
-#ifdef TRK_HAS_CUDA_TRACKING
-  if (useGPU && mDeviceType != o2::gpu::gpudatatypes::DeviceType::CUDA) {
-    LOGP(fatal, "This build provides the CUDA TRK tracking backend only, but device type {} was requested", static_cast<int>(mDeviceType));
-  }
-#elif defined(TRK_HAS_HIP_TRACKING)
-  if (useGPU && mDeviceType != o2::gpu::gpudatatypes::DeviceType::HIP) {
-    LOGP(fatal, "This build provides the HIP TRK tracking backend only, but device type {} was requested", static_cast<int>(mDeviceType));
-  }
-#endif
-#endif
-
-  auto runTracking = [&](auto& timeFrame, auto& trackerTraits) {
-    o2::its::Tracker<11> itsTracker(&trackerTraits);
-    timeFrame.setMemoryPool(mMemoryPool);
-    trackerTraits.setMemoryPool(mMemoryPool);
-    trackerTraits.setNThreads(mTaskArena->max_concurrency(), mTaskArena);
-    trackerTraits.adoptTimeFrame(static_cast<o2::its::TimeFrame<11>*>(&timeFrame));
-    itsTracker.adoptTimeFrame(timeFrame);
-    trackerTraits.updateTrackingParameters(trackingParams);
-
-    int nRofs{0};
-    if (!mHitRecoConfig.empty()) {
-      TFile hitsFile(mHitRecoConfig["inputfiles"]["hits"].get<std::string>().c_str(), "READ");
-      TFile mcHeaderFile(mHitRecoConfig["inputfiles"]["mcHeader"].get<std::string>().c_str(), "READ");
-      TTree* hitsTree = hitsFile.Get<TTree>("o2sim");
-      std::vector<o2::trk::Hit>* trkHit = nullptr;
-      hitsTree->SetBranchAddress("TRKHit", &trkHit);
-
-      TTree* mcHeaderTree = mcHeaderFile.Get<TTree>("o2sim");
-      auto mcheader = new o2::dataformats::MCEventHeader;
-      mcHeaderTree->SetBranchAddress("MCEventHeader.", &mcheader);
-
-      o2::base::GeometryManager::loadGeometry(mHitRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
-      auto* gman = o2::trk::GeometryTGeo::Instance();
-
-      const Long64_t nEvents{hitsTree->GetEntries()};
-      LOGP(info, "Starting {} reconstruction from hits for {} events", trackerTraits.getName(), nEvents);
-
-      trackerTraits.setBz(mHitRecoConfig["geometry"]["bz"].get<float>());
-      auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mHitRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
-      TGeoGlobalMagField::Instance()->SetField(field);
-      TGeoGlobalMagField::Instance()->Lock();
-
-      nRofs = timeFrame.loadROFsFromHitTree(hitsTree, gman, mHitRecoConfig);
-      const int inROFpileup{mHitRecoConfig.contains("inROFpileup") ? mHitRecoConfig["inROFpileup"].get<int>() : 1};
-      timeFrame.getPrimaryVerticesFromMC(mcHeaderTree, nRofs, nEvents, inROFpileup);
-    } else if (!mClusterRecoConfig.empty()) {
-      LOGP(info, "Starting {} reconstruction from clusters", trackerTraits.getName());
-
-      o2::base::GeometryManager::loadGeometry(mClusterRecoConfig["inputfiles"]["geometry"].get<std::string>().c_str(), false, true);
-      o2::trk::GeometryTGeo::Instance();
-
-      trackerTraits.setBz(mClusterRecoConfig["geometry"]["bz"].get<float>());
-      auto field = new field::MagneticField("ALICE3Mag", "ALICE 3 Magnetic Field", mClusterRecoConfig["geometry"]["bz"].get<float>() / 5.f, 0.0, o2::field::MagFieldParam::k5kGUniform);
-      TGeoGlobalMagField::Instance()->SetField(field);
-      TGeoGlobalMagField::Instance()->Lock();
-
-      constexpr int nLayers{11};
-      std::array<gsl::span<const o2::trk::Cluster>, nLayers> layerClusters;
-      std::array<gsl::span<const unsigned char>, nLayers> layerPatterns;
-      std::array<gsl::span<const o2::trk::ROFRecord>, nLayers> layerROFs;
-      std::array<const dataformats::MCTruthContainer<MCCompLabel>*, nLayers> layerLabels{};
-
-      size_t nInputRofs{0};
-      for (int iLayer = 0; iLayer < nLayers; ++iLayer) {
-        layerClusters[iLayer] = pc.inputs().get<gsl::span<o2::trk::Cluster>>(std::format("compClusters_{}", iLayer));
-        layerPatterns[iLayer] = pc.inputs().get<gsl::span<unsigned char>>(std::format("patterns_{}", iLayer));
-        layerROFs[iLayer] = pc.inputs().get<gsl::span<o2::trk::ROFRecord>>(std::format("ROframes_{}", iLayer));
-        nInputRofs = std::max(nInputRofs, layerROFs[iLayer].size());
-        if (mIsMC) {
-          layerLabels[iLayer] = pc.inputs().get<const dataformats::MCTruthContainer<MCCompLabel>*>(std::format("trkmclabels_{}", iLayer)).release();
-        }
-      }
-
-      timeFrame.deriveAndInitTiming(layerROFs);
-
-      const float yPlaneMLOT = 0.0010f;
-      nRofs = timeFrame.loadROFrameData(layerROFs, layerClusters, layerPatterns, mIsMC ? &layerLabels : nullptr, yPlaneMLOT);
-      timeFrame.addTruthSeedingVertices();
-    }
-
-    const auto trackingLoopStart = std::chrono::steady_clock::now();
-    for (size_t iter{0}; iter < trackingParams.size(); ++iter) {
-      LOGP(info, "{}", trackingParams[iter].asString());
-      trackerTraits.initialiseTimeFrame(iter);
-      trackerTraits.computeLayerTracklets(iter, -1);
-      LOGP(info, "Number of tracklets in iteration {}: {}", iter, timeFrame.getNumberOfTracklets());
-      trackerTraits.computeLayerCells(iter);
-      LOGP(info, "Number of cells in iteration {}: {}", iter, timeFrame.getNumberOfCells());
-      trackerTraits.findCellsNeighbours(iter);
-      LOGP(info, "Number of cell neighbours in iteration {}: {}", iter, timeFrame.getNumberOfNeighbours());
-      trackerTraits.findRoads(iter);
-      LOGP(info, "Number of roads in iteration {}: {}", iter, timeFrame.getNumberOfTracks());
-    }
-    const auto trackingLoopElapsedMs = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - trackingLoopStart).count();
-    LOGP(info, "Tracking iterations block took {} ms", trackingLoopElapsedMs);
-
-    if (mIsMC) {
-      itsTracker.computeTracksMClabels();
-    }
-
-    const auto& tracks = timeFrame.getTracks();
-    const auto& labels = timeFrame.getTracksLabel();
-    std::vector<o2::its::TrackITS> allTracks(tracks.begin(), tracks.end());
-    std::vector<o2::MCCompLabel> allLabels;
-
-    int totalTracks = allTracks.size();
-    int goodTracks = 0;
-    int fakeTracks = 0;
-
-    if (mIsMC) {
-      allLabels.assign(labels.begin(), labels.end());
-      for (const auto& label : allLabels) {
-        if (label.isFake()) {
-          ++fakeTracks;
-        } else {
-          ++goodTracks;
-        }
-      }
-    }
-
-    LOGP(info, "=== Tracking Summary ===");
-    LOGP(info, "Total tracks reconstructed: {}", totalTracks);
-    LOGP(info, "Good tracks: {} ({:.1f}%)", goodTracks, totalTracks > 0 ? 100.0 * goodTracks / totalTracks : 0);
-    LOGP(info, "Fake tracks: {} ({:.1f}%)", fakeTracks, totalTracks > 0 ? 100.0 * fakeTracks / totalTracks : 0);
-
-    const auto& rofView = timeFrame.getROFOverlapTableView();
-    const auto& clockLayer = rofView.getClockLayer();
-    const int clockLayerId = rofView.getClock();
-    const int64_t anchorBC = timeFrame.getTFAnchorIR().toLong();
 
-    int highestROF = static_cast<int>(clockLayer.mNROFsTF);
-    for (const auto& trc : allTracks) {
-      highestROF = std::max(highestROF, static_cast<int>(clockLayer.getROF(trc.getTimeStamp())));
-    }
-    for (const auto& vtx : timeFrame.getPrimaryVertices()) {
-      highestROF = std::max(highestROF, static_cast<int>(clockLayer.getROF(vtx.getTimeStamp().lower())));
-    }
-
-    std::vector<o2::trk::ROFRecord> allTrackROFs(highestROF);
-    for (size_t iROF = 0; iROF < allTrackROFs.size(); ++iROF) {
-      auto& rof = allTrackROFs[iROF];
-      o2::InteractionRecord ir;
-      ir.setFromLong(anchorBC + static_cast<int64_t>(clockLayer.getROFStartInBC(iROF)));
-      rof.setBCData(ir);
-      rof.setROFrame(iROF);
-      rof.setFirstEntry(0);
-      rof.setNEntries(0);
-    }
-
-    std::vector<int> rofEntries(highestROF + 1, 0);
-    for (const auto& trc : allTracks) {
-      const int rof = static_cast<int>(clockLayer.getROF(trc.getTimeStamp()));
-      if (rof >= 0 && rof < highestROF) {
-        ++rofEntries[rof];
-      }
-    }
-    std::exclusive_scan(rofEntries.begin(), rofEntries.end(), rofEntries.begin(), 0);
-
-    std::vector<o2::dataformats::IRFrame> irFrames;
-    irFrames.reserve(allTrackROFs.size());
-    const auto& maskView = timeFrame.getROFMaskView();
-    const auto rofLenMinus1 = clockLayer.mROFLength > 0 ? clockLayer.mROFLength - 1 : 0;
-    for (size_t iROF = 0; iROF < allTrackROFs.size(); ++iROF) {
-      allTrackROFs[iROF].setFirstEntry(rofEntries[iROF]);
-      allTrackROFs[iROF].setNEntries(rofEntries[iROF + 1] - rofEntries[iROF]);
-      if (maskView.isROFEnabled(clockLayerId, static_cast<int>(iROF))) {
-        const auto& bcStart = allTrackROFs[iROF].getBCData();
-        auto& irFrame = irFrames.emplace_back(bcStart, bcStart + rofLenMinus1);
-        irFrame.info = allTrackROFs[iROF].getNEntries();
-      }
-    }
-
-    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKS", 0}, allTracks);
-    pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSROF", 0}, allTrackROFs);
-    pc.outputs().snapshot(o2::framework::Output{"TRK", "IRFRAMES", 0}, irFrames);
-    if (mIsMC) {
-      pc.outputs().snapshot(o2::framework::Output{"TRK", "TRACKSMCTR", 0}, allLabels);
-    }
-
-    LOGP(info, "TRK pushed {} tracks in {} ROFs and {} IR frames{}",
-         allTracks.size(), allTrackROFs.size(), irFrames.size(),
-         mIsMC ? " (with MC labels)" : "");
-
-    timeFrame.wipe();
-  };
-
-#ifdef TRK_HAS_GPU_TRACKING
   if (useGPU) {
-    o2::trk::TimeFrameGPU<11> timeFrame;
-    o2::its::TrackerTraitsGPU<11> itsTrackerTraits;
-    if (!mGPUAllocator) {
-      mGPUAllocator = std::make_shared<o2::trk::GPUExternalAllocator>();
-    }
-    timeFrame.setFrameworkAllocator(mGPUAllocator.get());
-    runTracking(timeFrame, itsTrackerTraits);
-  } else
-#endif
-  {
+    runGPUTracking(pc);
+  } else {
     o2::trk::TimeFrame<11> timeFrame;
     o2::its::TrackerTraits<11> itsTrackerTraits;
-    runTracking(timeFrame, itsTrackerTraits);
+    runTracking(pc, timeFrame, itsTrackerTraits);
   }
 
   pc.services().get<o2::framework::ControlService>().endOfStream();
@@ -472,6 +281,29 @@ void TrackerDPL::run(ProcessingContext& pc)
   LOGP(info, "CPU Reconstruction time for this TF {} s (cpu), {} s (wall)", mTimer.CpuTime() - cput, mTimer.RealTime() - realt);
 }
 
+void TrackerDPL::runGPUTracking(ProcessingContext& pc)
+{
+  auto& loader = ALICE3TrackingBackendLoader::Instance();
+  switch (mDeviceType) {
+    case o2::gpu::gpudatatypes::DeviceType::CUDA:
+#ifdef TRK_HAS_CUDA_TRACKING
+      loader.executeFunctionAlias<int, TrackerDPL*, ProcessingContext*>("O2ALICE3GlobalReconstructionWorkflowCUDA", kGPUBackendFunction, this, &pc);
+      return;
+#else
+      LOGP(fatal, "CUDA TRK GPU tracking was requested but this build has no CUDA TRK GPU tracking backend");
+#endif
+    case o2::gpu::gpudatatypes::DeviceType::HIP:
+#ifdef TRK_HAS_HIP_TRACKING
+      loader.executeFunctionAlias<int, TrackerDPL*, ProcessingContext*>("O2ALICE3GlobalReconstructionWorkflowHIP", kGPUBackendFunction, this, &pc);
+      return;
+#else
+      LOGP(fatal, "HIP TRK GPU tracking was requested but this build has no HIP TRK GPU tracking backend");
+#endif
+    default:
+      LOGP(fatal, "Unsupported TRK GPU device type {}", static_cast<int>(mDeviceType));
+  }
+}
+
 void TrackerDPL::endOfStream(EndOfStreamContext& ec)
 {
   LOGF(info, "TRK CA-Tracker total timing: Cpu: %.3e Real: %.3e s in %d slots", mTimer.CpuTime(), mTimer.RealTime(), mTimer.Counter() - 1);
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpecGPU.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpecGPU.cxx
new file mode 100644
index 0000000000000..ea98ab3f852e5
--- /dev/null
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpecGPU.cxx
@@ -0,0 +1,28 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#include "ALICE3GlobalReconstruction/GPUExternalAllocator.h"
+#include "ALICE3GlobalReconstruction/TimeFrameGPU.h"
+#include "ALICE3GlobalReconstructionWorkflow/TrackerSpec.h"
+#include "ALICE3GlobalReconstructionWorkflow/TrackerSpecImpl.h"
+#include "ITStrackingGPU/TrackerTraitsGPU.h"
+
+extern "C" int runALICE3GPUTracking(o2::trk::TrackerDPL* tracker, o2::framework::ProcessingContext* pc)
+{
+  o2::trk::TimeFrameGPU<11> timeFrame;
+  o2::its::TrackerTraitsGPU<11> itsTrackerTraits;
+  if (!tracker->getGPUAllocator()) {
+    tracker->setGPUAllocator(std::make_shared<o2::trk::GPUExternalAllocator>());
+  }
+  timeFrame.setFrameworkAllocator(tracker->getGPUAllocator().get());
+  tracker->runTracking(*pc, timeFrame, itsTrackerTraits);
+  return 0;
+}

From c7d5958f58ac9ac4295c8e79f9578f74ddd72bf7 Mon Sep 17 00:00:00 2001
From: Fabrizio Chinu <91954233+fchinu@users.noreply.github.com>
Date: Thu, 21 May 2026 13:36:01 +0200
Subject: [PATCH 1749/1764] ITS: add selections on tracks sharing clusters
 (#15406)

* ITS: add selections on tracks sharing clusters

* Refactor selection function, return simple int instead of reference to int

* Use isPhiDifferenceBelow, avoid variable narrowing

* Improve memory management for selection of tracks with shared clusters
---
 .../ITS/include/DataFormatsITS/TrackITS.h     |  8 ++-
 .../tracking/GPU/cuda/TrackerTraitsGPU.cxx    |  4 +-
 .../include/ITStracking/Configuration.h       |  7 ++-
 .../include/ITStracking/TrackerTraits.h       |  4 +-
 .../include/ITStracking/TrackingConfigParam.h |  5 ++
 .../ITSMFT/ITS/tracking/src/Configuration.cxx |  3 +
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx | 61 ++++++++++++-------
 7 files changed, 63 insertions(+), 29 deletions(-)

diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
index a06395e76afff..89f6416c6e177 100644
--- a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
+++ b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
@@ -192,7 +192,13 @@ class TrackITSExt : public TrackITS
     getClusterRefs().setEntries(ncl);
   }
 
-  GPUhdi() const int& getClusterIndex(int lr) const { return mIndex[lr]; }
+  GPUhdi() const int getClusterIndex(int lr) const { return mIndex[lr]; }
+
+  GPUh() const int getFirstLayerClusterIndex() const
+  {
+    int firstLayer = getFirstClusterLayer();
+    return getClusterIndex(firstLayer);
+  }
 
   GPUhdi() void setExternalClusterIndex(int layer, int idx, bool newCluster = false)
   {
diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index f1812c9f6f764..32c46e2ea55d2 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -387,10 +387,10 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
     mTimeFrameGPU->downloadTrackITSExtDevice();
 
     auto& tracks = mTimeFrameGPU->getTrackITSExt();
-    this->acceptTracks(iteration, tracks, firstClusters, sharedFirstClusters);
+    this->acceptTracks(iteration, tracks, firstClusters);
     mTimeFrameGPU->loadUsedClustersDevice();
   }
-  this->markTracks(iteration, sharedFirstClusters);
+  this->markTracks(iteration);
   // wipe the artefact memory
   mTimeFrameGPU->popMemoryStack(iteration);
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index c939f39532fdb..852c5ecd24633 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -70,7 +70,6 @@ struct TrackingParameters {
   float DiamondCov[6] = {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f};
 
   /// General parameters
-  bool AllowSharingFirstCluster = false;
   int ClusterSharing = 0;
   int MinTrackLength = 7;
   int MaxHoles = 0;
@@ -98,6 +97,12 @@ struct TrackingParameters {
   bool PrintMemory = false; // print allocator usage in epilog report
   size_t MaxMemory = std::numeric_limits<size_t>::max();
   bool DropTFUponFailure = false;
+
+  // Selections on tracks sharing clusters
+  bool AllowSharingFirstCluster = false;
+  float SharedClusterMaxDeltaPhi = 0.05f; // For tracks sharing clusters, maximum allowed delta phi at the cluster position
+  float SharedClusterMaxDeltaEta = 0.03f; // For tracks sharing clusters, maximum allowed delta eta at the cluster position
+  bool SharedClusterOppositeSign = false; // For tracks sharing clusters, require opposite sign of the tracklets
 };
 
 struct VertexingParameters {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
index 647403bb6b548..f536e86fe95d5 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackerTraits.h
@@ -55,8 +55,8 @@ class TrackerTraits
   template <typename InputSeed>
   void processNeighbours(int iteration, int defaultCellTopologyId, int iLevel, const bounded_vector<InputSeed>& currentCellSeed, const bounded_vector<int>& currentCellId, const bounded_vector<int>& currentCellTopologyId, bounded_vector<TrackSeedN>& updatedCellSeed, bounded_vector<int>& updatedCellId, bounded_vector<int>& updatedCellTopologyId);
 
-  void acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters, bounded_vector<bounded_vector<int>>& sharedFirstClusters);
-  void markTracks(int iteration, bounded_vector<bounded_vector<int>>& sharedFirstClusters);
+  void acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters);
+  void markTracks(int iteration);
 
   void updateTrackingParameters(const std::vector<TrackingParameters>& trkPars)
   {
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
index 21b4f928d5b73..69aa3c5fdaf06 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/TrackingConfigParam.h
@@ -102,7 +102,12 @@ struct TrackerParamConfig : public o2::conf::ConfigurableParamHelper<TrackerPara
   size_t maxMemory = std::numeric_limits<size_t>::max();
   bool dropTFUponFailure = false;
   bool fataliseUponFailure = true;       // granular management of the fatalisation in async mode
+
+  // Selections on tracks sharing clusters
   bool allowSharingFirstCluster = false; // allow first cluster sharing among tracks
+  float sharedClusterMaxDeltaPhi = 0.05f; // Maximum allowed delta phi at the cluster position
+  float sharedClusterMaxDeltaEta = 0.03f; // Maximum allowed delta eta at the cluster position
+  bool sharedClusterOppositeSign = false; // Require opposite sign of the tracklets
 
   O2ParamDef(TrackerParamConfig, "ITSCATrackerParam");
 };
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 0087da0a85ac2..0bf383c996a68 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -204,6 +204,9 @@ std::vector<TrackingParameters> TrackingMode::getTrackingParameters(TrackingMode
     p.SaveTimeBenchmarks = tc.saveTimeBenchmarks;
     p.FataliseUponFailure = tc.fataliseUponFailure;
     p.AllowSharingFirstCluster = tc.allowSharingFirstCluster;
+    p.SharedClusterMaxDeltaPhi = tc.sharedClusterMaxDeltaPhi;
+    p.SharedClusterMaxDeltaEta = tc.sharedClusterMaxDeltaEta;
+    p.SharedClusterOppositeSign = tc.sharedClusterOppositeSign;
     const auto iter = &p - trackParams.data();
     if (iter < constants::MaxIter) {
       p.MaxHoles = tc.maxHolesIter[iter];
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 9fef067559e8a..3432b60162002 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -661,9 +661,7 @@ template <int NLayers>
 void TrackerTraits<NLayers>::findRoads(const int iteration)
 {
   bounded_vector<bounded_vector<int>> firstClusters(mTrkParams[iteration].NLayers, bounded_vector<int>(mMemoryPool.get()), mMemoryPool.get());
-  bounded_vector<bounded_vector<int>> sharedFirstClusters(mTrkParams[iteration].NLayers, bounded_vector<int>(mMemoryPool.get()), mMemoryPool.get());
   firstClusters.resize(mTrkParams[iteration].NLayers);
-  sharedFirstClusters.resize(mTrkParams[iteration].NLayers);
   const auto propagator = o2::base::Propagator::Instance();
   const TrackingFrameInfo* tfInfos[NLayers]{};
   const Cluster* unsortedClusters[NLayers]{};
@@ -787,13 +785,13 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
       return track::isBetter(a, b);
     });
 
-    acceptTracks(iteration, tracks, firstClusters, sharedFirstClusters);
+    acceptTracks(iteration, tracks, firstClusters);
   }
-  markTracks(iteration, sharedFirstClusters);
+  markTracks(iteration);
 }
 
 template <int NLayers>
-void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters, bounded_vector<bounded_vector<int>>& sharedFirstClusters)
+void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITSExt>& tracks, bounded_vector<bounded_vector<int>>& firstClusters)
 {
   auto& trks = mTimeFrame->getTracks();
   trks.reserve(trks.size() + tracks.size());
@@ -860,34 +858,51 @@ void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITS
 
     if (mTrkParams[iteration].AllowSharingFirstCluster) {
       firstClusters[firstLayer].push_back(firstCluster);
-      if (isFirstShared) {
-        sharedFirstClusters[firstLayer].push_back(firstCluster);
-      }
     }
   }
 }
 
 template <int NLayers>
-void TrackerTraits<NLayers>::markTracks(int iteration, bounded_vector<bounded_vector<int>>& sharedFirstClusters)
+void TrackerTraits<NLayers>::markTracks(int iteration)
 {
   if (mTrkParams[iteration].AllowSharingFirstCluster) {
     /// Now we have to set the shared cluster flag
-    for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
-      std::sort(sharedFirstClusters[iLayer].begin(), sharedFirstClusters[iLayer].end());
-    }
+    auto& tracks = mTimeFrame->getTracks();
 
-    for (auto& track : mTimeFrame->getTracks()) {
-      int firstLayer{mTrkParams[iteration].NLayers}, firstCluster{constants::UnusedIndex};
-      for (int iLayer{0}; iLayer < mTrkParams[iteration].NLayers; ++iLayer) {
-        if (track.getClusterIndex(iLayer) == constants::UnusedIndex) {
-          continue;
-        }
-        firstLayer = iLayer;
-        firstCluster = track.getClusterIndex(iLayer);
-        break;
+    bounded_vector<int> fclusSort(tracks.size(), mMemoryPool.get());
+    std::iota(fclusSort.begin(), fclusSort.end(), 0);
+    std::sort(fclusSort.begin(), fclusSort.end(), [&tracks](int a, int b) {
+      return tracks[a].getFirstLayerClusterIndex() < tracks[b].getFirstLayerClusterIndex();
+    });
+
+    auto areTracksSelected = [this, iteration](const TrackITSExt& t1, const TrackITSExt& t2) {
+      const auto t1FirstLayer{t1.getFirstClusterLayer()}, t2FirstLayer{t2.getFirstClusterLayer()};
+      if (t1FirstLayer != t2FirstLayer) {
+        return false;
+      }
+      if (mTimeFrame->getClusterROF(t1FirstLayer, t1.getClusterIndex(t1FirstLayer)) != mTimeFrame->getClusterROF(t2FirstLayer, t2.getClusterIndex(t2FirstLayer))) {
+        return false;
+      }
+      if (!math_utils::isPhiDifferenceBelow(t1.getPhi(), t2.getPhi(), mTrkParams[iteration].SharedClusterMaxDeltaPhi)) {
+        return false;
+      }
+      if (std::abs(t1.getEta() - t2.getEta()) > mTrkParams[iteration].SharedClusterMaxDeltaEta) {
+        return false;
       }
-      if (std::binary_search(sharedFirstClusters[firstLayer].begin(), sharedFirstClusters[firstLayer].end(), firstCluster)) {
-        track.setSharedClusters();
+      if (mTrkParams[iteration].SharedClusterOppositeSign && t1.getSign() == t2.getSign()) {
+        return false;
+      }
+      return true;
+    };
+
+    for (int i{0}; i < static_cast<int>(fclusSort.size()); ++i) {
+      auto& track = tracks[fclusSort[i]];
+      for (int j{i + 1}; j < static_cast<int>(fclusSort.size()) && tracks[fclusSort[j]].getFirstLayerClusterIndex() == track.getFirstLayerClusterIndex(); ++j) {
+        auto& track2 = tracks[fclusSort[j]];
+        if (areTracksSelected(track, track2)) {
+          track.setSharedClusters();
+          track2.setSharedClusters();
+        }
       }
     }
   }

From 8c2216f6a5eb93d433f0a834d5c410efd2e98904 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Thu, 21 May 2026 18:04:09 +0200
Subject: [PATCH 1750/1764] Update CorrectionMapsOptions help hints

---
 Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx b/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
index 45c3771db57bf..5518d680420ca 100644
--- a/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
+++ b/Detectors/TPC/calibration/src/CorrectionMapsOptions.cxx
@@ -45,7 +45,7 @@ void CorrectionMapsOptions::addGlobalOptions(std::vector<ConfigParamSpec>& optio
 {
   // these are options which should be added at the workflow level, since they modify the inputs of the devices
   addOption(options, ConfigParamSpec{"lumi-type", o2::framework::VariantType::Int, 0, {"1 = use CTP lumi for TPC correction scaling, 2 = use TPC scalers for TPC correction scaling"}});
-  addOption(options, ConfigParamSpec{"corrmap-lumi-mode", o2::framework::VariantType::Int, 0, {"scaling mode: (default) 0 = static + scale * full; 1 = full + scale * derivative; 2 = full + scale * derivative (for MC)"}});
+  addOption(options, ConfigParamSpec{"corrmap-lumi-mode", o2::framework::VariantType::Int, 0, {"scaling mode: (default) 0 = static + scale * full; 1 = full + scale * derivative; 2 = full + scale * derivative (for MC); 3 = no correction; 4 = static only"}});
   addOption(options, ConfigParamSpec{"enable-M-shape-correction", o2::framework::VariantType::Bool, false, {"Enable M-shape distortion correction"}});
   addOption(options, ConfigParamSpec{"disable-ctp-lumi-request", o2::framework::VariantType::Bool, false, {"do not request CTP lumi (regardless what is used for corrections)"}});
   addOption(options, ConfigParamSpec{"disable-lumi-type-consistency-check", o2::framework::VariantType::Bool, false, {"disable check of selected CTP or IDC scaling source being consistent with the map"}});

From 86a999e410d7959a8a74c9ac16b42e828795c20d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Fri, 22 May 2026 19:39:53 +0200
Subject: [PATCH 1751/1764] DPL MCP: allow connecting to a running Hyperloop
 test

---
 .../scripts/dpl-mcp-server/dpl_mcp_server.py  | 59 +++++++++++++++++--
 1 file changed, 54 insertions(+), 5 deletions(-)

diff --git a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
index dca5058b01dcd..ed457b8a57d9d 100644
--- a/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
+++ b/Framework/Core/scripts/dpl-mcp-server/dpl_mcp_server.py
@@ -39,7 +39,9 @@
 
 import asyncio
 import json
+import os
 from typing import Any
+from urllib.parse import urlparse
 
 import websockets
 from mcp.server.fastmcp import FastMCP
@@ -51,9 +53,10 @@
 class WorkflowConnection:
     """Holds WebSocket connection and buffered state for one DPL workflow."""
 
-    def __init__(self, port: int, name: str):
-        self.port = port
+    def __init__(self, *, url: str, name: str, extra_headers: dict[str, str] | None = None):
+        self.url = url
         self.name = name
+        self.extra_headers = extra_headers or {}
         self.ws: Any = None
         self.reader_task: asyncio.Task | None = None
         self.snapshot: dict = {}
@@ -83,8 +86,11 @@ async def ensure_connected(self) -> None:
                 except Exception:
                     pass
 
-        url = f"ws://localhost:{self.port}/status"
-        self.ws = await websockets.connect(url, subprotocols=["dpl"])
+        self.ws = await websockets.connect(
+            self.url,
+            subprotocols=["dpl"],
+            additional_headers=self.extra_headers if self.extra_headers else None,
+        )
         if self.reader_task is None or self.reader_task.done():
             self.reader_task = asyncio.create_task(self._reader())
 
@@ -178,7 +184,8 @@ async def connect(port: int = 0, pid: int = 0, name: str = "") -> str:
         old = _workflows[wf_name]
         await old.close()
 
-    conn = WorkflowConnection(port, wf_name)
+    url = f"ws://localhost:{port}/status"
+    conn = WorkflowConnection(url=url, name=wf_name)
     await conn.ensure_connected()
     _workflows[wf_name] = conn
 
@@ -189,6 +196,48 @@ async def connect(port: int = 0, pid: int = 0, name: str = "") -> str:
     )
 
 
+@mcp.tool()
+async def connect_hyperloop(url: str, name: str = "", token: str = "") -> str:
+    """Connect to a DPL workflow running on Hyperloop via the remote proxy.
+
+    Accepts a URL like:
+        https://alimonitor.cern.ch/train-workdir/remote-gui/remote_proxy.html?<token>/<port>
+
+    and remaps it to the local WebSocket proxy endpoint.
+
+    Args:
+        url: The remote_proxy.html URL from alimonitor.
+        name: Optional human-friendly name for this workflow.
+        token: Hyperloop auth token. Falls back to HYPERLOOP_TOKEN env var.
+    """
+    token = token or os.environ.get("HYPERLOOP_TOKEN", "")
+    if not token:
+        return "No token provided and HYPERLOOP_TOKEN environment variable is not set."
+
+    parsed = urlparse(url)
+    path_suffix = parsed.query  # everything after '?'
+    if not path_suffix:
+        return f"Cannot parse token/port from URL: {url}"
+
+    ws_url = f"ws://localhost:8888/remote-mcp/o2/{path_suffix}/status"
+    wf_name = name or path_suffix.split("/")[-1]
+
+    if wf_name in _workflows:
+        old = _workflows[wf_name]
+        await old.close()
+
+    headers = {"Authorization": f"Bearer {token}"}
+    conn = WorkflowConnection(url=ws_url, name=wf_name, extra_headers=headers)
+    await conn.ensure_connected()
+    _workflows[wf_name] = conn
+
+    devices = conn.snapshot.get("devices", [])
+    return (
+        f"Connected to Hyperloop workflow '{wf_name}' via {ws_url} "
+        f"({len(devices)} device(s))."
+    )
+
+
 @mcp.tool()
 async def disconnect(workflow: str) -> str:
     """Disconnect from a DPL workflow and release its resources.

From d13ebbbc141dc9229dcbe3ec69905b167b3d5075 Mon Sep 17 00:00:00 2001
From: shahoian <ruben.shahoyan@cern.ch>
Date: Sat, 23 May 2026 00:39:54 +0200
Subject: [PATCH 1752/1764] Fix output file name for checkResid streamers

---
 .../GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx      | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
index 01ec999fce1eb..6a1915791a911 100644
--- a/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
+++ b/Detectors/GlobalTrackingWorkflow/study/src/CheckResidSpec.cxx
@@ -132,7 +132,7 @@ void CheckResidSpec::init(InitContext& ic)
   int maxLanes = ic.services().get<const o2::framework::DeviceSpec>().maxInputTimeslices;
   std::string nm = params.outname;
   if (maxLanes > 1) {
-    o2::conf::ConfigurableParam::updateFromString(fmt::format("checkresid.outname={}_{}", nm, lane));
+    o2::conf::ConfigurableParam::updateFromString(fmt::format("checkresid.outname={}_t{}", nm, lane));
   }
   if (mDraw) {
     mFillHistos = true;
@@ -173,8 +173,7 @@ void CheckResidSpec::init(InitContext& ic)
   mNThreads = 1;
 #endif
   if (mFillTree) {
-    nm += ".root";
-    mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(nm.c_str(), "recreate");
+    mDBGOut = std::make_unique<o2::utils::TreeStreamRedirector>(fmt::format("{}.root", params.outname).c_str(), "recreate");
   }
 }
 

From c36617d3be5c39397aa9373f8b49b07d9e8fd453 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <matthias.kleiner@cern.ch>
Date: Tue, 19 May 2026 12:09:06 +0200
Subject: [PATCH 1753/1764] TPC timeseries: make data requests conditional on
 input sources

- do not request PV and FT0 in TPC-only mode
- do not request TPC clusters if TPC is not in input sources
- make time series work without any track input
---
 Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
index ac3ff15fd3a29..0c0ae72056318 100644
--- a/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
+++ b/Detectors/TPC/workflow/src/TPCTimeSeriesSpec.cxx
@@ -1825,15 +1825,16 @@ o2::framework::DataProcessorSpec getTPCTimeSeriesSpec(const bool disableWriter,
   auto dataRequest = std::make_shared<DataRequest>();
   bool useMC = false;
   GTrackID::mask_t srcTracks = GTrackID::getSourcesMask("TPC,ITS,ITS-TPC,ITS-TPC-TRD,ITS-TPC-TOF,ITS-TPC-TRD-TOF") & src;
-  srcTracks.set(GTrackID::TPC); // TPC must be always there
   dataRequest->requestTracks(srcTracks, useMC);
-  dataRequest->requestClusters(GTrackID::getSourcesMask("TPC"), useMC);
+  if (src[GTrackID::TPC]) {
+    dataRequest->requestClusters(GTrackID::getSourcesMask("TPC"), useMC);
+  }
 
   bool tpcOnly = srcTracks == GTrackID::getSourcesMask("TPC");
-  if (!tpcOnly) {
+  if (srcTracks.any() && !tpcOnly) {
     dataRequest->requestFT0RecPoints(useMC);
+    dataRequest->requestPrimaryVertices(useMC);
   }
-  dataRequest->requestPrimaryVertices(useMC);
 
   const bool enableAskMatLUT = matType == o2::base::Propagator::MatCorrType::USEMatCorrLUT;
   auto ccdbRequest = std::make_shared<o2::base::GRPGeomRequest>(!disableWriter,                 // orbitResetTime

From a4bd6bc0c69b2dd18b1073390a8b062002d8e360 Mon Sep 17 00:00:00 2001
From: Matthias Kleiner <Matthias.Kleiner@cern.ch>
Date: Thu, 23 Apr 2026 16:04:23 +0200
Subject: [PATCH 1754/1764] TPC: move nthreads to local option

---
 .../include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h  | 5 ++++-
 .../TPC/workflow/src/tpc-fouriertransform-aggregator.cxx     | 3 ---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h
index 35f51dd489115..7facee78fb3d6 100644
--- a/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h
+++ b/Detectors/TPC/workflow/include/TPCWorkflow/TPCFourierTransformAggregatorSpec.h
@@ -64,6 +64,8 @@ class TPCFourierTransformAggregatorSpec : public o2::framework::Task
     mLengthIDCScalerSeconds = ic.options().get<float>("tpcScalerLengthS");
     mDisableScaler = ic.options().get<bool>("disable-scaler");
     mEnableFFTCCDB = ic.options().get<bool>("enable-fft-CCDB");
+    int nthreads = ic.options().get<int>("nthreads");
+    TPCFourierTransformAggregatorSpec::IDCFType::setNThreads(nthreads);
     resizeBuffer(mInputLanes);
   }
 
@@ -448,7 +450,8 @@ DataProcessorSpec getTPCFourierTransformAggregatorSpec(const unsigned int rangeI
             {"dump-coefficients-agg", VariantType::Bool, false, {"Dump fourier coefficients to file"}},
             {"tpcScalerLengthS", VariantType::Float, 300.f, {"Length of the TPC scalers in seconds"}},
             {"disable-scaler", VariantType::Bool, false, {"Disable creation of IDC scaler"}},
-            {"enable-fft-CCDB", VariantType::Bool, false, {"Enable writing of FFT coefficients to CCDB"}}}};
+            {"enable-fft-CCDB", VariantType::Bool, false, {"Enable writing of FFT coefficients to CCDB"}},
+            {"nthreads", VariantType::Int, 1, {"Number of threads which will be used during the calculation of the fourier coefficients."}}}};
 }
 
 } // namespace o2::tpc
diff --git a/Detectors/TPC/workflow/src/tpc-fouriertransform-aggregator.cxx b/Detectors/TPC/workflow/src/tpc-fouriertransform-aggregator.cxx
index b0f09e02e627b..2f66a144251f1 100644
--- a/Detectors/TPC/workflow/src/tpc-fouriertransform-aggregator.cxx
+++ b/Detectors/TPC/workflow/src/tpc-fouriertransform-aggregator.cxx
@@ -26,7 +26,6 @@ void customize(std::vector<ConfigParamSpec>& workflowOptions)
   std::vector<ConfigParamSpec> options{
     {"rangeIDC", VariantType::Int, 200, {"Number of 1D-IDCs which will be used for the calculation of the fourier coefficients. TODO ALREADY SET IN ABERAGEGROUP"}},
     {"nFourierCoeff", VariantType::Int, 60, {"Number of fourier coefficients (real+imag) which will be stored in the CCDB. The maximum can be 'rangeIDC + 2'."}},
-    {"nthreads", VariantType::Int, 1, {"Number of threads which will be used during the calculation of the fourier coefficients."}},
     {"inputLanes", VariantType::Int, 2, {"Number of expected input lanes."}},
     {"sendOutput", VariantType::Bool, false, {"send fourier coefficients"}},
     {"use-naive-fft", VariantType::Bool, false, {"using naive fourier transform (true) or FFTW (false)"}},
@@ -51,8 +50,6 @@ WorkflowSpec defineDataProcessing(ConfigContext const& config)
   const bool processSACs = config.options().get<bool>("process-SACs");
   const auto rangeIDC = static_cast<unsigned int>(config.options().get<int>("rangeIDC"));
   const auto nFourierCoeff = std::clamp(static_cast<unsigned int>(config.options().get<int>("nFourierCoeff")), static_cast<unsigned int>(0), rangeIDC + 2);
-  const auto nthreadsFourier = static_cast<unsigned long>(config.options().get<int>("nthreads"));
-  TPCFourierTransformAggregatorSpec::IDCFType::setNThreads(nthreadsFourier);
   TPCFourierTransformAggregatorSpec::IDCFType::setFFT(!fft);
   const auto inputLanes = config.options().get<int>("inputLanes");
   WorkflowSpec workflow{getTPCFourierTransformAggregatorSpec(rangeIDC, nFourierCoeff, sendOutput, processSACs, inputLanes)};

From 5b4b32f9f0a761711c4e9448877f62f6cd0c2f78 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Sun, 24 May 2026 00:04:36 +0200
Subject: [PATCH 1755/1764] DPL: add debug information for rate limiting

---
 Framework/Core/src/ControlWebSocketHandler.cxx |  9 +++++++++
 Framework/Core/src/DevicesManager.cxx          | 11 +++++++++++
 2 files changed, 20 insertions(+)

diff --git a/Framework/Core/src/ControlWebSocketHandler.cxx b/Framework/Core/src/ControlWebSocketHandler.cxx
index 35528a1d6dfec..8be91c0e22fc3 100644
--- a/Framework/Core/src/ControlWebSocketHandler.cxx
+++ b/Framework/Core/src/ControlWebSocketHandler.cxx
@@ -14,10 +14,13 @@
 #include "StatusWebSocketHandler.h"
 #include "Framework/DeviceMetricsHelper.h"
 #include "Framework/ServiceMetricsInfo.h"
+#include "Framework/Signpost.h"
 #include <regex>
 #include "Framework/Logger.h"
 #include "Framework/DeviceConfigInfo.h"
 
+O2_DECLARE_DYNAMIC_LOG(rate_limiting);
+
 namespace o2::framework
 {
 void ControlWebSocketHandler::frame(char const* frame, size_t s)
@@ -74,6 +77,10 @@ void ControlWebSocketHandler::endChunk()
   if (!didProcessMetric) {
     return;
   }
+  O2_SIGNPOST_ID_GENERATE(sid, rate_limiting);
+  O2_SIGNPOST_START(rate_limiting, sid, "endChunk",
+                    "Processing metrics from device %d (had new metric: %d)",
+                    mIndex, (int)didHaveNewMetric);
   size_t timestamp = (uv_hrtime() - mContext.driver->startTime) / 1000000 + mContext.driver->startTimeMsFromEpoch;
   assert(mContext.metrics);
   assert(mContext.infos);
@@ -91,6 +98,8 @@ void ControlWebSocketHandler::endChunk()
   for (auto& metricsInfo : *mContext.metrics) {
     std::fill(metricsInfo.changed.begin(), metricsInfo.changed.end(), false);
   }
+  O2_SIGNPOST_END(rate_limiting, sid, "endChunk",
+                  "Done processing metrics from device %d", mIndex);
 }
 
 void ControlWebSocketHandler::headers(std::map<std::string, std::string> const& headers)
diff --git a/Framework/Core/src/DevicesManager.cxx b/Framework/Core/src/DevicesManager.cxx
index e6fa2c2c61ae6..b427e72ca781d 100644
--- a/Framework/Core/src/DevicesManager.cxx
+++ b/Framework/Core/src/DevicesManager.cxx
@@ -13,12 +13,19 @@
 #include "Framework/RuntimeError.h"
 #include "Framework/Logger.h"
 #include "Framework/DeviceController.h"
+#include "Framework/Signpost.h"
+
+O2_DECLARE_DYNAMIC_LOG(devices_manager);
 
 namespace o2::framework
 {
 
 void DevicesManager::queueMessage(char const* target, char const* message)
 {
+  O2_SIGNPOST_ID_GENERATE(sid, devices_manager);
+  O2_SIGNPOST_EVENT_EMIT(devices_manager, sid, "queue",
+                         "Queuing message for %{public}s: %{public}s",
+                         target, message);
   for (int di = 0; di < specs.size(); ++di) {
     if (specs[di].id == target) {
       messages.push_back({di, message});
@@ -44,6 +51,10 @@ void DevicesManager::flush()
       LOGP(info, "Controller for {} now available.", specs[handle.ref.index].id);
       notifiedAvailable = true;
     }
+    O2_SIGNPOST_ID_GENERATE(sid, devices_manager);
+    O2_SIGNPOST_EVENT_EMIT(devices_manager, sid, "flush",
+                           "Flushing message to %{public}s: %{public}s",
+                           specs[handle.ref.index].id.c_str(), handle.message.c_str());
     controller->write(handle.message.c_str(), handle.message.size());
   }
 

From 19b82ba383c8000a3d1be23cc15d4cb0c36f83b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Nicol=C3=B2=20Jacazio?= <njacazio@users.noreply.github.com>
Date: Mon, 25 May 2026 09:14:46 +0200
Subject: [PATCH 1756/1764] [ALICE3] TRK: fix ACTS clusterer compilation
 (#15352)

Comment out the processing of digMC2ROFs if condition.
---
 .../ALICE3/TRK/reconstruction/src/ClustererACTS.cxx  | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
index 2dbf56ae610e3..30ab503b7e250 100644
--- a/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
+++ b/Detectors/Upgrades/ALICE3/TRK/reconstruction/src/ClustererACTS.cxx
@@ -387,10 +387,10 @@ void ClustererACTS::process(gsl::span<const Digit> digits,
                              outFirst, static_cast<int>(clusters.size()) - outFirst);
   }
 
-  if (clusterMC2ROFs && !digMC2ROFs.empty()) {
-    clusterMC2ROFs->reserve(clusterMC2ROFs->size() + digMC2ROFs.size());
-    for (const auto& in : digMC2ROFs) {
-      clusterMC2ROFs->emplace_back(in.eventRecordID, in.rofRecordID, in.minROF, in.maxROF);
-    }
-  }
+  // if (clusterMC2ROFs && !digMC2ROFs.empty()) {
+  //   clusterMC2ROFs->reserve(clusterMC2ROFs->size() + digMC2ROFs.size());
+  //   for (const auto& in : digMC2ROFs) {
+  //     clusterMC2ROFs->emplace_back(in.eventRecordID, in.rofRecordID, in.minROF, in.maxROF);
+  //   }
+  // }
 }

From 8936d29ea8fdee5085990361442be87c809ab99c Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 25 May 2026 10:01:47 +0200
Subject: [PATCH 1757/1764] DPL: fix mismatched type in signpost

---
 Framework/Core/src/ControlWebSocketHandler.cxx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/src/ControlWebSocketHandler.cxx b/Framework/Core/src/ControlWebSocketHandler.cxx
index 8be91c0e22fc3..8d2f85b034364 100644
--- a/Framework/Core/src/ControlWebSocketHandler.cxx
+++ b/Framework/Core/src/ControlWebSocketHandler.cxx
@@ -79,7 +79,7 @@ void ControlWebSocketHandler::endChunk()
   }
   O2_SIGNPOST_ID_GENERATE(sid, rate_limiting);
   O2_SIGNPOST_START(rate_limiting, sid, "endChunk",
-                    "Processing metrics from device %d (had new metric: %d)",
+                    "Processing metrics from device %zu (had new metric: %d)",
                     mIndex, (int)didHaveNewMetric);
   size_t timestamp = (uv_hrtime() - mContext.driver->startTime) / 1000000 + mContext.driver->startTimeMsFromEpoch;
   assert(mContext.metrics);
@@ -99,7 +99,7 @@ void ControlWebSocketHandler::endChunk()
     std::fill(metricsInfo.changed.begin(), metricsInfo.changed.end(), false);
   }
   O2_SIGNPOST_END(rate_limiting, sid, "endChunk",
-                  "Done processing metrics from device %d", mIndex);
+                  "Done processing metrics from device %zu", mIndex);
 }
 
 void ControlWebSocketHandler::headers(std::map<std::string, std::string> const& headers)

From 440a899dee1673762ec344cad73735ecf44ad57d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Mon, 25 May 2026 09:33:52 +0200
Subject: [PATCH 1758/1764] DPL: reduce number of spurious warnings

---
 Framework/Core/src/DataProcessingDevice.cxx | 22 +++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/Framework/Core/src/DataProcessingDevice.cxx b/Framework/Core/src/DataProcessingDevice.cxx
index be25133158072..b45a48c28f691 100644
--- a/Framework/Core/src/DataProcessingDevice.cxx
+++ b/Framework/Core/src/DataProcessingDevice.cxx
@@ -1420,14 +1420,24 @@ void DataProcessingDevice::Run()
           }
           return missingInfo.empty() ? std::string(" (policy: ") + spec.resourcePolicy.name + ")" : " -" + missingInfo;
         };
+        auto const timeSinceLastScheduled = lastSched ? uv_now(state.loop) - lastSched : 0;
         if (schedulingStats.numberOfUnscheduledSinceLastScheduled >= schedulingStats.nextWarnAt) {
           auto const missingStr = buildMissingInfo();
-          O2_SIGNPOST_EVENT_EMIT_WARN(scheduling, sid, "Run",
-                                      "Not enough resources to schedule computation on stream %d. %zu consecutive skips%s. Missing:%s. Data is not lost and it will be scheduled again.",
-                                      streamRef.index,
-                                      schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
-                                      schedInfo.c_str(),
-                                      missingStr.c_str());
+          if (timeSinceLastScheduled >= 50) {
+            O2_SIGNPOST_EVENT_EMIT_WARN(scheduling, sid, "Run",
+                                        "Not enough resources to schedule computation on stream %d. %zu consecutive skips%s. Missing:%s. Data is not lost and it will be scheduled again.",
+                                        streamRef.index,
+                                        schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
+                                        schedInfo.c_str(),
+                                        missingStr.c_str());
+          } else {
+            O2_SIGNPOST_EVENT_EMIT(scheduling, sid, "Run",
+                                   "Not enough resources to schedule computation on stream %d. %zu consecutive skips%s. Missing:%s. Data is not lost and it will be scheduled again.",
+                                   streamRef.index,
+                                   schedulingStats.numberOfUnscheduledSinceLastScheduled.load(),
+                                   schedInfo.c_str(),
+                                   missingStr.c_str());
+          }
           schedulingStats.nextWarnAt = schedulingStats.nextWarnAt * 2;
         } else {
           auto const missingStr = buildMissingInfo();

From 67473780483d90c743df4d8092abfa6ae596e097 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Sat, 16 May 2026 20:23:13 +0200
Subject: [PATCH 1759/1764] ITS: adjust printing and use mask

Signed-off-by: Felix Schlepper <felix.schlepper@cern.ch>
---
 .../ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx |  3 +--
 .../include/ITStracking/Configuration.h        |  7 ++++---
 .../ITSMFT/ITS/tracking/src/Configuration.cxx  | 18 ++++++++++++++----
 .../ITSMFT/ITS/tracking/src/TrackerTraits.cxx  |  5 ++---
 .../workflow/src/TrackerSpec.cxx               |  4 ++--
 5 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
index 32c46e2ea55d2..141d558712e6d 100644
--- a/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx
@@ -309,8 +309,7 @@ void TrackerTraitsGPU<NLayers>::findRoads(const int iteration)
     bounded_vector<TrackSeed<NLayers>> trackSeeds(this->getMemoryPool().get());
     for (int startCellTopologyId{0}; startCellTopologyId < hostTopology.nCells; ++startCellTopologyId) {
       const int startLayer = hostTopology.getCell(startCellTopologyId).hitLayerMask.last();
-      if ((this->mTrkParams[iteration].StartLayerMask & (1 << startLayer)) == 0 ||
-          mTimeFrameGPU->getNCells()[startCellTopologyId] == 0) {
+      if (!(this->mTrkParams[iteration].StartLayerMask.has(startLayer)) || mTimeFrameGPU->getNCells()[startCellTopologyId] == 0) {
         continue;
       }
       processNeighboursHandler<NLayers>(startLevel,
diff --git a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
index 852c5ecd24633..275752854665b 100644
--- a/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
+++ b/Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h
@@ -26,6 +26,7 @@
 #include "CommonUtils/EnumFlags.h"
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Constants.h"
+#include "ITStracking/LayerMask.h"
 
 namespace o2::its
 {
@@ -70,10 +71,9 @@ struct TrackingParameters {
   float DiamondCov[6] = {25.e-6f, 0.f, 0.f, 25.e-6f, 0.f, 36.f};
 
   /// General parameters
-  int ClusterSharing = 0;
   int MinTrackLength = 7;
   int MaxHoles = 0;
-  uint16_t HoleLayerMask = 0;
+  LayerMask HoleLayerMask = 0;
   float NSigmaCut = 5;
   float PVres = 1.e-2f;
   /// Trackleting cuts
@@ -86,7 +86,7 @@ struct TrackingParameters {
   float MaxChi2NDF = 30.f;
   int ReseedIfShorter = 6; // reseed for the final fit track with the length shorter than this
   std::vector<float> MinPt = {0.f, 0.f, 0.f, 0.f};
-  uint16_t StartLayerMask = 0x7F;
+  LayerMask StartLayerMask = 0x7F;
   bool RepeatRefitOut = false;   // repeat outward refit using inward refit as a seed
   bool ShiftRefToCluster = true; // TrackFit: after update shift the linearization reference to cluster
   bool PerPrimaryVertexProcessing = false;
@@ -103,6 +103,7 @@ struct TrackingParameters {
   float SharedClusterMaxDeltaPhi = 0.05f; // For tracks sharing clusters, maximum allowed delta phi at the cluster position
   float SharedClusterMaxDeltaEta = 0.03f; // For tracks sharing clusters, maximum allowed delta eta at the cluster position
   bool SharedClusterOppositeSign = false; // For tracks sharing clusters, require opposite sign of the tracklets
+  int SharedMaxClusters = 0;              // Maximal allowed shared clusters (excluding first cluster)
 };
 
 struct VertexingParameters {
diff --git a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
index 0bf383c996a68..f07a8f3394c05 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/Configuration.cxx
@@ -24,8 +24,9 @@ using namespace o2::its;
 
 std::string TrackingParameters::asString() const
 {
-  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} ClSh:{} TtklMinPt:{:.2f} MinCl:{} MaxHoles:{} HoleMask:{:#x}",
-                                ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, ClusterSharing, TrackletMinPt, MinTrackLength, MaxHoles, HoleLayerMask);
+  std::string str = std::format("NZb:{} NPhB:{} PerVtx:{} DropFail:{} TtklMinPt:{:.2f} MinCl:{}", ZBins, PhiBins, PerPrimaryVertexProcessing, DropTFUponFailure, TrackletMinPt, MinTrackLength);
+  auto isSet = [](auto e) { return e >= 0; };
+  auto isAnySet = [&isSet](auto v) { return !v.empty() && std::any_of(v.begin(), v.end(), isSet); };
   bool first = true;
   for (int il = NLayers; il >= MinTrackLength; il--) {
     int slot = NLayers - il;
@@ -37,18 +38,27 @@ std::string TrackingParameters::asString() const
       str += std::format("L{}:{:.2f} ", il, MinPt[slot]);
     }
   }
-  if (!SystErrorY2.empty() || !SystErrorZ2.empty()) {
+  if (isAnySet(SystErrorY2) || isAnySet(SystErrorZ2)) {
     str += " SystErrY/Z:";
     for (size_t i = 0; i < SystErrorY2.size(); i++) {
       str += std::format("{:.2e}/{:.2e} ", SystErrorY2[i], SystErrorZ2[i]);
     }
   }
-  if (!AddTimeError.empty()) {
+  if (isAnySet(AddTimeError)) {
     str += " AddTimeError:";
     for (unsigned int i : AddTimeError) {
       str += std::format("{} ", i);
     }
   }
+  if (SharedMaxClusters) {
+    str += std::format(" ShaMaxCls:{} ", SharedMaxClusters);
+  }
+  if (AllowSharingFirstCluster) {
+    str += std::format(" ShaClsDPhi:{} ShaClsDEta:{} ShaClsSign:{}", SharedClusterMaxDeltaPhi, SharedClusterMaxDeltaEta, SharedClusterOppositeSign);
+  }
+  if (MaxHoles) {
+    str += std::format(" MaxHoles:{} HoleMask:{}", MaxHoles, HoleLayerMask.asString());
+  }
   if (std::numeric_limits<size_t>::max() != MaxMemory) {
     str += std::format(" MemLimit {:.2f} GB", double(MaxMemory) / constants::GB);
   }
diff --git a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
index 3432b60162002..c4439dc74d29e 100644
--- a/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
+++ b/Detectors/ITSMFT/ITS/tracking/src/TrackerTraits.cxx
@@ -681,8 +681,7 @@ void TrackerTraits<NLayers>::findRoads(const int iteration)
     bounded_vector<TrackSeedN> trackSeeds(mMemoryPool.get());
     for (int startCellTopologyId{0}; startCellTopologyId < topology.nCells; ++startCellTopologyId) {
       const int startLayer = topology.getCell(startCellTopologyId).hitLayerMask.last();
-      if ((mTrkParams[iteration].StartLayerMask & (1 << startLayer)) == 0 ||
-          mTimeFrame->getCells()[startCellTopologyId].empty()) {
+      if (!(mTrkParams[iteration].StartLayerMask.has(startLayer)) || mTimeFrame->getCells()[startCellTopologyId].empty()) {
         continue;
       }
 
@@ -814,7 +813,7 @@ void TrackerTraits<NLayers>::acceptTracks(int iteration, bounded_vector<TrackITS
     }
 
     /// do not account for the first cluster in the shared clusters number if it is allowed
-    if (nShared - int(isFirstShared && mTrkParams[iteration].AllowSharingFirstCluster) > mTrkParams[iteration].ClusterSharing) {
+    if (nShared - int(isFirstShared && mTrkParams[iteration].AllowSharingFirstCluster) > mTrkParams[iteration].SharedMaxClusters) {
       continue;
     }
 
diff --git a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
index 6f9f5561a5ef6..070466ea8711d 100644
--- a/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
+++ b/Detectors/Upgrades/ALICE3/GlobalReconstruction/workflow/src/TrackerSpec.cxx
@@ -113,8 +113,8 @@ std::vector<o2::its::TrackingParameters> TrackerDPL::createTrackingParamsFromCon
       if (paramConfig.contains("PhiBins")) {
         params.PhiBins = paramConfig["PhiBins"].get<int>();
       }
-      if (paramConfig.contains("ClusterSharing")) {
-        params.ClusterSharing = paramConfig["ClusterSharing"].get<int>();
+      if (paramConfig.contains("SharedMaxClusters")) {
+        params.SharedMaxClusters = paramConfig["SharedMaxClusters"].get<int>();
       }
       if (paramConfig.contains("MinTrackLength")) {
         params.MinTrackLength = paramConfig["MinTrackLength"].get<int>();

From ac48d72874fbf15ad87af0d0a17313d60f3bf716 Mon Sep 17 00:00:00 2001
From: Felix Schlepper <felix.schlepper@cern.ch>
Date: Fri, 22 May 2026 20:15:05 +0200
Subject: [PATCH 1760/1764] ITS: Remove redundant 'const' from getter methods

the redunant const from #15406 qualifiers lead to warnings:
```
O2/GPU/GPUTracking/Standalone/../../../DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h:195:12: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
  195 |   GPUhdi() const int getClusterIndex(int lr) const { return mIndex[lr]; }
      |            ^~~~~
/O2/GPU/GPUTracking/Standalone/../../../DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h:197:10: warning: type qualifiers ignored on function return type [-Wignored-qualifiers]
  197 |   GPUh() const int getFirstLayerClusterIndex() const
      |          ^~~~~
```
---
 .../Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
index 89f6416c6e177..20fb7c63ebacd 100644
--- a/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
+++ b/DataFormats/Detectors/ITSMFT/ITS/include/DataFormatsITS/TrackITS.h
@@ -192,12 +192,11 @@ class TrackITSExt : public TrackITS
     getClusterRefs().setEntries(ncl);
   }
 
-  GPUhdi() const int getClusterIndex(int lr) const { return mIndex[lr]; }
+  GPUhdi() int getClusterIndex(int lr) const { return mIndex[lr]; }
 
-  GPUh() const int getFirstLayerClusterIndex() const
+  GPUh() int getFirstLayerClusterIndex() const
   {
-    int firstLayer = getFirstClusterLayer();
-    return getClusterIndex(firstLayer);
+    return getClusterIndex(getFirstClusterLayer());
   }
 
   GPUhdi() void setExternalClusterIndex(int layer, int idx, bool newCluster = false)

From d6bb77ba228579f516de43c62b80a1d25a21c4ed Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Wed, 1 Apr 2026 15:15:12 +0200
Subject: [PATCH 1761/1764] DPL: add ability to get CCDB blobs without
 deserialization

---
 .../Core/include/Framework/DataRefUtils.h     |  5 +++++
 .../Core/include/Framework/InputRecord.h      | 19 +++++++++++++++++++
 Framework/Core/src/DataRefUtils.cxx           | 16 ++++++++++++++++
 3 files changed, 40 insertions(+)

diff --git a/Framework/Core/include/Framework/DataRefUtils.h b/Framework/Core/include/Framework/DataRefUtils.h
index d50699badc63b..498b4eb5f7a87 100644
--- a/Framework/Core/include/Framework/DataRefUtils.h
+++ b/Framework/Core/include/Framework/DataRefUtils.h
@@ -23,6 +23,7 @@
 
 #include <gsl/gsl>
 
+#include <span>
 #include <type_traits>
 #include <typeinfo>
 
@@ -184,6 +185,10 @@ struct DataRefUtils {
   // Decode a CCDB object using the CcdbApi.
   static void* decodeCCDB(DataRef const& ref, std::type_info const& info);
   static std::map<std::string, std::string> extractCCDBHeaders(DataRef const& ref);
+  /// Return a span over the raw CCDB payload bytes, stripping the flattened HTTP
+  /// headers footer that CCDBFetcherHelper appends. Use this when the CCDB entry is
+  /// a binary blob rather than a ROOT-serialised object.
+  static std::span<const char> getCCDBPayloadBlob(DataRef const& ref);
 
   static o2::header::DataHeader::PayloadSizeType getPayloadSize(const DataRef& ref)
   {
diff --git a/Framework/Core/include/Framework/InputRecord.h b/Framework/Core/include/Framework/InputRecord.h
index d2e152c1bcacc..c52610b6ddb62 100644
--- a/Framework/Core/include/Framework/InputRecord.h
+++ b/Framework/Core/include/Framework/InputRecord.h
@@ -35,6 +35,7 @@
 #include <memory>
 #include <type_traits>
 #include <concepts>
+#include <span>
 
 #include <fairmq/FwdDecls.h>
 
@@ -45,6 +46,12 @@ namespace o2::framework
 struct CCDBMetadataExtractor {
 };
 
+/// Tag type to retrieve the raw binary payload of a CCDB entry without ROOT
+/// deserialization. The returned span is valid for the duration of the
+/// processing callback. Use as: inputs.get<CCDBBlob>("binding")
+struct CCDBBlob {
+};
+
 struct InputSpec;
 class InputSpan;
 class CallbackService;
@@ -522,6 +529,18 @@ class InputRecord
     return cache.idToMetadata[id];
   }
 
+  template <typename T = DataRef, typename R>
+  std::span<const char> get(R binding, int part = 0) const
+    requires std::same_as<T, CCDBBlob>
+  {
+    auto ref = getRef(binding, part);
+    auto header = DataRefUtils::getHeader<header::DataHeader*>(ref);
+    if (header->payloadSerializationMethod != header::gSerializationMethodCCDB) {
+      throw runtime_error("Attempt to extract CCDBBlob from a non-CCDB-serialized message");
+    }
+    return DataRefUtils::getCCDBPayloadBlob(ref);
+  }
+
   template <typename T>
     requires(std::same_as<T, DataRef>)
   decltype(auto) get(ConcreteDataMatcher matcher, int part = 0)
diff --git a/Framework/Core/src/DataRefUtils.cxx b/Framework/Core/src/DataRefUtils.cxx
index 69eb1dc7faba6..894ad0b8ace63 100644
--- a/Framework/Core/src/DataRefUtils.cxx
+++ b/Framework/Core/src/DataRefUtils.cxx
@@ -9,6 +9,7 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include <span>
 #include <typeinfo>
 #include <cstring>
 #include "Framework/DataRefUtils.h"
@@ -148,4 +149,19 @@ std::map<std::string, std::string> DataRefUtils::extractCCDBHeaders(DataRef cons
   return res;
 }
 
+std::span<const char> DataRefUtils::getCCDBPayloadBlob(DataRef const& ref)
+{
+  auto* dh = o2::header::get<o2::header::DataHeader*>(ref.header);
+  const char* buff = ref.payload;
+  size_t payloadSize = dh->payloadSize;
+  constexpr char FlatHeaderAnnot[] = "$HEADER$";
+  constexpr size_t Offset = sizeof(int) + sizeof(FlatHeaderAnnot);
+  int headerSize = 0;
+  if (payloadSize >= Offset &&
+      !std::strncmp(buff + payloadSize - sizeof(FlatHeaderAnnot), FlatHeaderAnnot, sizeof(FlatHeaderAnnot))) {
+    headerSize = *reinterpret_cast<const int*>(buff + payloadSize - Offset);
+  }
+  return {buff, payloadSize - headerSize};
+}
+
 } // namespace o2::framework

From bd1ec4e59f7a1113c8c97cddcaf6d0c53bd10173 Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 26 May 2026 11:56:39 +0200
Subject: [PATCH 1762/1764] DPL MCP: add server to inspect the perf results

---
 .../hyperloop-perf-server/perf_mcp_server.py  | 419 ++++++++++++++++++
 .../hyperloop-perf-server/pyproject.toml      |  19 +
 2 files changed, 438 insertions(+)
 create mode 100644 Framework/Core/scripts/hyperloop-perf-server/perf_mcp_server.py
 create mode 100644 Framework/Core/scripts/hyperloop-perf-server/pyproject.toml

diff --git a/Framework/Core/scripts/hyperloop-perf-server/perf_mcp_server.py b/Framework/Core/scripts/hyperloop-perf-server/perf_mcp_server.py
new file mode 100644
index 0000000000000..b0e51fc270a40
--- /dev/null
+++ b/Framework/Core/scripts/hyperloop-perf-server/perf_mcp_server.py
@@ -0,0 +1,419 @@
+#!/usr/bin/env python3
+# Copyright 2019-2026 CERN and copyright holders of ALICE O2.
+# See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+# All rights not expressly granted are reserved.
+#
+# This software is distributed under the terms of the GNU General Public
+# License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+#
+# In applying this license CERN does not waive the privileges and immunities
+# granted to it by virtue of its status as an Intergovernmental Organization
+# or submit itself to any jurisdiction.
+"""Hyperloop perf profile MCP server.
+
+Fetches Linux ``perf script`` output files hosted on the Hyperloop web server,
+parses and indexes them in memory, and exposes query tools so an AI assistant
+can investigate performance hotspots without ever seeing the raw file.
+
+Usage
+-----
+    python3 perf_mcp_server.py
+
+Multiple profiles can be loaded simultaneously, enabling before/after
+comparisons via the ``compare`` tool.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import Optional
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+# ---------------------------------------------------------------------------
+# Perf profile data model
+# ---------------------------------------------------------------------------
+
+_OFFSET_RE = re.compile(r"\+0x[0-9a-fA-F]+")
+
+
+def _strip(sym: str) -> str:
+    """Remove hex offsets from a symbol name."""
+    return _OFFSET_RE.sub("", sym)
+
+
+@dataclass
+class PerfProfile:
+    url: str
+    total_cycles: int
+    processes: set[str]
+    # leaf[sym] = cycles where sym was the innermost (hot) frame
+    leaf: dict[str, int]
+    # inclusive[sym] = cycles where sym appeared anywhere in the stack
+    inclusive: dict[str, int]
+    # callers[sym][caller] = cycles attributed to this caller→sym edge
+    callers: dict[str, dict[str, int]]
+    # callees[sym][callee] = cycles attributed to this sym→callee edge
+    callees: dict[str, dict[str, int]]
+    # raw stacks for chain queries: (cycles, process_name, [sym0, sym1, ...])
+    # sym0 is the innermost (leaf) frame; sym[-1] is the outermost caller.
+    stacks: list[tuple[int, str, list[str]]] = field(default_factory=list)
+
+
+def _parse(text: str) -> PerfProfile:
+    """Parse ``perf script`` text output into a PerfProfile."""
+    leaf: dict[str, int] = defaultdict(int)
+    inclusive: dict[str, int] = defaultdict(int)
+    callers: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    callees: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    stacks: list[tuple[int, str, list[str]]] = []
+    processes: set[str] = set()
+    total_cycles = 0
+
+    cycles = 0
+    process = ""
+    stack: list[str] = []
+
+    def _flush() -> None:
+        nonlocal total_cycles
+        if not stack or not cycles:
+            return
+        stacks.append((cycles, process, list(stack)))
+        total_cycles += cycles
+        leaf[stack[0]] += cycles
+        seen: set[str] = set()
+        for i, sym in enumerate(stack):
+            if sym not in seen:
+                inclusive[sym] += cycles
+                seen.add(sym)
+            # stack[i] is called by stack[i+1]; stack[i] calls stack[i-1]
+            if i > 0:
+                callers[stack[i - 1]][stack[i]] += cycles
+                callees[stack[i]][stack[i - 1]] += cycles
+
+    for line in text.splitlines():
+        if not line:
+            continue
+        if not line[0].isspace():
+            _flush()
+            m = re.search(r"(\d+) cycles:", line)
+            cycles = int(m.group(1)) if m else 0
+            parts = line.split()
+            process = parts[0] if parts else ""
+            processes.add(process)
+            stack = []
+        elif line[0] == "\t":
+            parts = line.split()
+            if len(parts) >= 2:
+                stack.append(_strip(parts[1]))
+
+    _flush()
+
+    return PerfProfile(
+        url="",
+        total_cycles=total_cycles,
+        processes=processes,
+        leaf=dict(leaf),
+        inclusive=dict(inclusive),
+        callers={k: dict(v) for k, v in callers.items()},
+        callees={k: dict(v) for k, v in callees.items()},
+        stacks=stacks,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Profile registry
+# ---------------------------------------------------------------------------
+
+_profiles: dict[str, PerfProfile] = {}
+
+
+def _get(name: str) -> PerfProfile:
+    p = _profiles.get(name)
+    if p is None:
+        available = ", ".join(_profiles.keys()) if _profiles else "(none)"
+        raise ValueError(
+            f"No profile named '{name}'. Loaded profiles: {available}. "
+            f"Use load_profile first."
+        )
+    return p
+
+
+def _pct(cycles: int, total: int) -> str:
+    return f"{cycles * 100 / total:.2f}%" if total else "N/A"
+
+
+def _top_table(hot: dict[str, int], total: int, n: int, process_note: str = "") -> str:
+    rows = sorted(hot.items(), key=lambda x: -x[1])[:n]
+    if not rows:
+        return "No data."
+    header = f"{'cycles':>16}  {'%':>7}  symbol"
+    if process_note:
+        header = f"[filtered: {process_note}]\n" + header
+    lines = [header]
+    for sym, cyc in rows:
+        lines.append(f"{cyc:>16,}  {_pct(cyc, total):>7}  {sym}")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# MCP server
+# ---------------------------------------------------------------------------
+
+mcp = FastMCP("Hyperloop Perf")
+
+
+@mcp.tool()
+async def load_profile(url: str, name: str = "", token: str = "", proxy_token: str = "") -> str:
+    """Fetch a ``perf script`` text file and index it for querying.
+
+    The file is downloaded once and kept in memory.  Subsequent tool calls
+    use the in-memory index and do not re-fetch.
+
+    Args:
+        url:         Direct URL to the perf script text file.
+        name:        Human-friendly label (defaults to the filename portion of the URL).
+        token:       Hyperloop auth token. Falls back to HYPERLOOP_TOKEN env var.
+        proxy_token: Bearer token for the local proxy. Falls back to PROXY_TOKEN env var,
+                     then to token.
+    """
+    token = token or os.environ.get("HYPERLOOP_TOKEN", "")
+    proxy_token = proxy_token or os.environ.get("PROXY_TOKEN", "") or token
+
+    # Rewrite alimonitor.cern.ch URLs through the local proxy (same pattern as
+    # connect_hyperloop).  The proxy must have a route like:
+    #   {"prefix": "/alimonitor/", "upstream": "https://alimonitor.cern.ch", "token": "..."}
+    fetch_url = url
+    if "alimonitor.cern.ch" in url:
+        path = url.split("alimonitor.cern.ch", 1)[1].lstrip("/")
+        fetch_url = f"http://localhost:8888/alimonitor/{path}"
+
+    headers = {"Authorization": f"Bearer {proxy_token}"} if proxy_token else {}
+    headers["Accept-Encoding"] = "identity"
+
+    async with httpx.AsyncClient(verify=False) as client:
+        r = await client.get(fetch_url, headers=headers, timeout=120.0, follow_redirects=True)
+        r.raise_for_status()
+        text = r.content.decode("utf-8", errors="replace")
+
+    profile = await asyncio.get_event_loop().run_in_executor(None, _parse, text)
+    profile.url = url
+
+    pname = name or url.rstrip("/").split("/")[-1]
+    _profiles[pname] = profile
+
+    return (
+        f"Loaded '{pname}': {len(profile.stacks):,} samples, "
+        f"{profile.total_cycles:,} total cycles, "
+        f"processes: {', '.join(sorted(profile.processes))}"
+    )
+
+
+@mcp.tool()
+def list_profiles() -> str:
+    """List all loaded perf profiles with their basic stats."""
+    if not _profiles:
+        return "No profiles loaded. Use load_profile first."
+    lines = []
+    for name, p in _profiles.items():
+        lines.append(
+            f"{name}: {len(p.stacks):,} samples, {p.total_cycles:,} cycles, "
+            f"url={p.url}"
+        )
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def drop_profile(name: str) -> str:
+    """Free a loaded profile from memory.
+
+    Args:
+        name: Profile name as returned by load_profile.
+    """
+    _get(name)
+    del _profiles[name]
+    return f"Dropped profile '{name}'."
+
+
+@mcp.tool()
+def top_functions(profile_name: str, n: int = 40, process: str = "") -> str:
+    """Show the hottest leaf functions (where CPU was actually executing).
+
+    Args:
+        profile_name: Profile name as returned by load_profile.
+        n:            Number of entries to return (default 40).
+        process:      Optional process name filter (exact match).
+    """
+    p = _get(profile_name)
+    if process:
+        hot: dict[str, int] = defaultdict(int)
+        for cyc, proc, stack in p.stacks:
+            if proc == process and stack:
+                hot[stack[0]] += cyc
+        total = sum(hot.values())
+        return _top_table(dict(hot), total, n, process)
+    return _top_table(p.leaf, p.total_cycles, n)
+
+
+@mcp.tool()
+def top_inclusive(profile_name: str, n: int = 40, process: str = "") -> str:
+    """Show the hottest functions by inclusive cycles (appears anywhere in stack).
+
+    Args:
+        profile_name: Profile name as returned by load_profile.
+        n:            Number of entries to return (default 40).
+        process:      Optional process name filter (exact match).
+    """
+    p = _get(profile_name)
+    if process:
+        hot: dict[str, int] = defaultdict(int)
+        for cyc, proc, stack in p.stacks:
+            if proc != process:
+                continue
+            for sym in set(stack):
+                hot[sym] += cyc
+        total = sum(cyc for cyc, proc, _ in p.stacks if proc == process)
+        return _top_table(dict(hot), total, n, process)
+    return _top_table(p.inclusive, p.total_cycles, n)
+
+
+@mcp.tool()
+def callers_of(profile_name: str, sym: str, n: int = 20) -> str:
+    """Show what calls a given function, weighted by cycles.
+
+    Uses substring matching on the symbol name.
+
+    Args:
+        profile_name: Profile name as returned by load_profile.
+        sym:          Symbol name (or substring) to look up.
+        n:            Number of callers to return (default 20).
+    """
+    p = _get(profile_name)
+    merged: dict[str, int] = defaultdict(int)
+    for fn, caller_map in p.callers.items():
+        if sym in fn:
+            for caller, cyc in caller_map.items():
+                merged[caller] += cyc
+    if not merged:
+        return f"No callers found for '{sym}'."
+    return _top_table(dict(merged), p.total_cycles, n)
+
+
+@mcp.tool()
+def callees_of(profile_name: str, sym: str, n: int = 20) -> str:
+    """Show what a given function calls, weighted by cycles.
+
+    Uses substring matching on the symbol name.
+
+    Args:
+        profile_name: Profile name as returned by load_profile.
+        sym:          Symbol name (or substring) to look up.
+        n:            Number of callees to return (default 20).
+    """
+    p = _get(profile_name)
+    merged: dict[str, int] = defaultdict(int)
+    for fn, callee_map in p.callees.items():
+        if sym in fn:
+            for callee, cyc in callee_map.items():
+                merged[callee] += cyc
+    if not merged:
+        return f"No callees found for '{sym}'."
+    return _top_table(dict(merged), p.total_cycles, n)
+
+
+@mcp.tool()
+def chains_through(profile_name: str, sym: str, depth: int = 3, n: int = 20, process: str = "") -> str:
+    """Show call chain windows centered on a function.
+
+    Finds all samples where ``sym`` appears in the stack and returns the
+    most common surrounding call chains, each showing ``depth`` frames on
+    either side.
+
+    Args:
+        profile_name: Profile name as returned by load_profile.
+        sym:          Symbol name (or substring) to search for.
+        depth:        Number of frames to show on each side (default 3).
+        n:            Number of top chains to return (default 20).
+        process:      Optional process name filter (exact match).
+    """
+    p = _get(profile_name)
+    chains: dict[str, int] = defaultdict(int)
+
+    for cyc, proc, stack in p.stacks:
+        if process and proc != process:
+            continue
+        for i, frame in enumerate(stack):
+            if sym in frame:
+                start = max(0, i - depth)
+                end = min(len(stack), i + depth + 1)
+                chain = " <- ".join(stack[start:end])
+                chains[chain] += cyc
+                break
+
+    if not chains:
+        return f"No samples found containing '{sym}'."
+
+    lines = [f"Call chains through '{sym}' (depth={depth}):"]
+    lines.append(f"{'cycles':>16}  {'%':>7}  chain")
+    for chain, cyc in sorted(chains.items(), key=lambda x: -x[1])[:n]:
+        lines.append(f"{cyc:>16,}  {_pct(cyc, p.total_cycles):>7}  {chain}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+def compare(name_a: str, name_b: str, n: int = 40, mode: str = "leaf") -> str:
+    """Compare two profiles and show which functions changed the most.
+
+    Normalises each profile's cycles to a fraction of its total so that
+    differences in overall run length do not skew the comparison.
+    Positive Δ means the function got *heavier* in B relative to A.
+
+    Args:
+        name_a: Baseline profile name.
+        name_b: Comparison profile name.
+        n:      Number of entries to show (default 40).
+        mode:   "leaf" (default) or "inclusive".
+    """
+    a = _get(name_a)
+    b = _get(name_b)
+
+    hot_a = a.leaf if mode == "leaf" else a.inclusive
+    hot_b = b.leaf if mode == "leaf" else b.inclusive
+    total_a = a.total_cycles or 1
+    total_b = b.total_cycles or 1
+
+    all_syms = set(hot_a) | set(hot_b)
+    diffs = []
+    for sym in all_syms:
+        fa = hot_a.get(sym, 0) / total_a
+        fb = hot_b.get(sym, 0) / total_b
+        diffs.append((fb - fa, sym, fa, fb))
+
+    diffs.sort(key=lambda x: -abs(x[0]))
+
+    lines = [
+        f"Comparing '{name_a}' (A) vs '{name_b}' (B) [{mode}]",
+        f"A total: {a.total_cycles:,} cycles   B total: {b.total_cycles:,} cycles",
+        f"",
+        f"{'Δ%':>8}  {'A%':>7}  {'B%':>7}  symbol",
+    ]
+    for delta, sym, fa, fb in diffs[:n]:
+        lines.append(f"{delta*100:>+8.2f}  {fa*100:>7.2f}  {fb*100:>7.2f}  {sym}")
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/Framework/Core/scripts/hyperloop-perf-server/pyproject.toml b/Framework/Core/scripts/hyperloop-perf-server/pyproject.toml
new file mode 100644
index 0000000000000..33224df62e694
--- /dev/null
+++ b/Framework/Core/scripts/hyperloop-perf-server/pyproject.toml
@@ -0,0 +1,19 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "hyperloop-perf-server"
+version = "0.1.0"
+description = "MCP server for querying Linux perf profiles from Hyperloop workflows"
+requires-python = ">=3.11"
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.27",
+]
+
+[project.scripts]
+hyperloop-perf-server = "perf_mcp_server:main"
+
+[tool.hatch.build.targets.wheel]
+include = ["perf_mcp_server.py"]

From 531ea81b73ddb6e198d915e53d2f6961928e6a1e Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 26 May 2026 18:04:01 +0200
Subject: [PATCH 1763/1764] Allow retries

---
 .../scripts/hyperloop-perf-server/perf_mcp_server.py   | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/Framework/Core/scripts/hyperloop-perf-server/perf_mcp_server.py b/Framework/Core/scripts/hyperloop-perf-server/perf_mcp_server.py
index b0e51fc270a40..cce2d31bf00e3 100644
--- a/Framework/Core/scripts/hyperloop-perf-server/perf_mcp_server.py
+++ b/Framework/Core/scripts/hyperloop-perf-server/perf_mcp_server.py
@@ -197,8 +197,14 @@ async def load_profile(url: str, name: str = "", token: str = "", proxy_token: s
     headers["Accept-Encoding"] = "identity"
 
     async with httpx.AsyncClient(verify=False) as client:
-        r = await client.get(fetch_url, headers=headers, timeout=120.0, follow_redirects=True)
-        r.raise_for_status()
+        for attempt in range(3):
+            try:
+                r = await client.get(fetch_url, headers=headers, timeout=300.0, follow_redirects=True)
+                r.raise_for_status()
+                break
+            except (httpx.RemoteProtocolError, httpx.ReadError) as exc:
+                if attempt == 2:
+                    raise
         text = r.content.decode("utf-8", errors="replace")
 
     profile = await asyncio.get_event_loop().run_in_executor(None, _parse, text)

From bd619d006cea7c41e22cfb2500958fcab72bd07d Mon Sep 17 00:00:00 2001
From: Giulio Eulisse <10544+ktf@users.noreply.github.com>
Date: Tue, 26 May 2026 14:40:39 +0200
Subject: [PATCH 1764/1764] Avoid filling a vector just to count the bits

---
 DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx b/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
index 5f31fe5741240..939203d168604 100644
--- a/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
+++ b/DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx
@@ -233,9 +233,7 @@ double CTPRateFetcher::pileUpCorrection(double triggerRate)
   if (mLHCIFdata.getFillNumber() == 0) {
     LOG(fatal) << "No filling" << std::endl;
   }
-  auto bfilling = mLHCIFdata.getBunchFilling();
-  std::vector<int> bcs = bfilling.getFilledBCs();
-  double nbc = bcs.size();
+  double nbc = mLHCIFdata.getBunchFilling().getPattern().count();
   double nTriggersPerFilledBC = triggerRate / nbc / constants::lhc::LHCRevFreq;
   double mu = -std::log(1 - nTriggersPerFilledBC);
   return mu * nbc * constants::lhc::LHCRevFreq;